mgltools-utpackages-1.5.7~rc1~cvs.20130519/0000755000175000017500000000000012146213620017355 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTpackages/0000755000175000017500000000000012146213450021405 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTpackages/Tests/0000755000175000017500000000000012146213450022507 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTpackages/Tests/__init__.py0000644000175000017500000000000010620450224024603 0ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTpackages/Tests/test_dependencies.py0000644000175000017500000000152410406105553026551 0ustar debiandebian# ################################################################# # Author: Sowjanya Karnati ################################################################# # #Purpose:To update dependencies list # # $Id: test_dependencies.py,v 1.2 2006/03/15 21:47:23 sowjanya Exp $ from mglutil.TestUtil.Tests.dependenciestest import DependencyTester import unittest d = DependencyTester() result_expected =[] class test_dep(unittest.TestCase): def test_dep_1(self): result = d.rundeptester('UTpackages') if result !=[]: print "\nThe Following Packages are not present in CRITICAL or NONCRITICAL DEPENDENCIES of UTpackages :\n %s" %result self.assertEqual(result,result_expected) else: self.assertEqual(result,result_expected) if __name__ == '__main__': unittest.main() mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTpackages/__init__.py0000644000175000017500000000021410404121602023503 0ustar debiandebian# __MGLTOOLSVersion__ = '1-4alpha3' CRITICAL_DEPENDENCIES = ['Numeric'] NONCRITICAL_DEPENDENCIES = ['Pmv', 'opengltk', 'mglutil', 'DejaVu'] mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/0000755000175000017500000000000012146213607022161 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/setup.cfg0000644000175000017500000000014110240173436023774 0ustar debiandebian# Important : this instructs distutils to build SWIG wrappers for C++ [build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/0000755000175000017500000000000012146213614022746 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/0000755000175000017500000000000012146213614025413 5ustar debiandebian././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/StaticExtensionPointers.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/StaticExtensionPointers.0000644000175000017500000032105511006453404032267 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef STATICEXTENSIONPOINTERS_H #define STATICEXTENSIONPOINTERS_H #if !defined(_WIN32) && !defined(GLX_ARB_get_proc_address) && !defined(GLX_get_proc_address) static bool staticPointersInitialized = false; // GL_VERSION_1_2 static MYPFNGLBLENDCOLORPROC staticPointerglBlendColor = 0; static MYPFNGLBLENDEQUATIONPROC staticPointerglBlendEquation = 0; static MYPFNGLDRAWRANGEELEMENTSPROC staticPointerglDrawRangeElements = 0; static MYPFNGLCOLORTABLEPROC staticPointerglColorTable = 0; static MYPFNGLCOLORTABLEPARAMETERFVPROC staticPointerglColorTableParameterfv = 0; static MYPFNGLCOLORTABLEPARAMETERIVPROC staticPointerglColorTableParameteriv = 0; static MYPFNGLCOPYCOLORTABLEPROC staticPointerglCopyColorTable = 0; static MYPFNGLGETCOLORTABLEPROC staticPointerglGetColorTable = 0; static MYPFNGLGETCOLORTABLEPARAMETERFVPROC staticPointerglGetColorTableParameterfv = 0; static MYPFNGLGETCOLORTABLEPARAMETERIVPROC staticPointerglGetColorTableParameteriv = 0; static MYPFNGLCOLORSUBTABLEPROC staticPointerglColorSubTable = 0; static MYPFNGLCOPYCOLORSUBTABLEPROC staticPointerglCopyColorSubTable = 0; static MYPFNGLCONVOLUTIONFILTER1DPROC staticPointerglConvolutionFilter1D = 0; static MYPFNGLCONVOLUTIONFILTER2DPROC staticPointerglConvolutionFilter2D = 0; static MYPFNGLCONVOLUTIONPARAMETERFPROC staticPointerglConvolutionParameterf = 0; static MYPFNGLCONVOLUTIONPARAMETERFVPROC staticPointerglConvolutionParameterfv = 0; static MYPFNGLCONVOLUTIONPARAMETERIPROC staticPointerglConvolutionParameteri = 0; static MYPFNGLCONVOLUTIONPARAMETERIVPROC staticPointerglConvolutionParameteriv = 0; static MYPFNGLCOPYCONVOLUTIONFILTER1DPROC staticPointerglCopyConvolutionFilter1D = 0; static MYPFNGLCOPYCONVOLUTIONFILTER2DPROC staticPointerglCopyConvolutionFilter2D = 0; static MYPFNGLGETCONVOLUTIONFILTERPROC staticPointerglGetConvolutionFilter = 0; static MYPFNGLGETCONVOLUTIONPARAMETERFVPROC staticPointerglGetConvolutionParameterfv = 0; static MYPFNGLGETCONVOLUTIONPARAMETERIVPROC staticPointerglGetConvolutionParameteriv = 0; static MYPFNGLGETSEPARABLEFILTERPROC staticPointerglGetSeparableFilter = 0; static MYPFNGLSEPARABLEFILTER2DPROC staticPointerglSeparableFilter2D = 0; static MYPFNGLGETHISTOGRAMPROC staticPointerglGetHistogram = 0; static MYPFNGLGETHISTOGRAMPARAMETERFVPROC staticPointerglGetHistogramParameterfv = 0; static MYPFNGLGETHISTOGRAMPARAMETERIVPROC staticPointerglGetHistogramParameteriv = 0; static MYPFNGLGETMINMAXPROC staticPointerglGetMinmax = 0; static MYPFNGLGETMINMAXPARAMETERFVPROC staticPointerglGetMinmaxParameterfv = 0; static MYPFNGLGETMINMAXPARAMETERIVPROC staticPointerglGetMinmaxParameteriv = 0; static MYPFNGLHISTOGRAMPROC staticPointerglHistogram = 0; static MYPFNGLMINMAXPROC staticPointerglMinmax = 0; static MYPFNGLRESETHISTOGRAMPROC staticPointerglResetHistogram = 0; static MYPFNGLRESETMINMAXPROC staticPointerglResetMinmax = 0; static MYPFNGLTEXIMAGE3DPROC staticPointerglTexImage3D = 0; static MYPFNGLTEXSUBIMAGE3DPROC staticPointerglTexSubImage3D = 0; static MYPFNGLCOPYTEXSUBIMAGE3DPROC staticPointerglCopyTexSubImage3D = 0; // End OpenGL version 1.2 // OpenGL version 1.3 static MYPFNGLACTIVETEXTUREPROC staticPointerglActiveTexture = 0; static MYPFNGLCLIENTACTIVETEXTUREPROC staticPointerglClientActiveTexture = 0; static MYPFNGLMULTITEXCOORD1DPROC staticPointerglMultiTexCoord1d = 0; static MYPFNGLMULTITEXCOORD1DVPROC staticPointerglMultiTexCoord1dv = 0; static MYPFNGLMULTITEXCOORD1FPROC staticPointerglMultiTexCoord1f = 0; static MYPFNGLMULTITEXCOORD1FVPROC staticPointerglMultiTexCoord1fv = 0; static MYPFNGLMULTITEXCOORD1IPROC staticPointerglMultiTexCoord1i = 0; static MYPFNGLMULTITEXCOORD1IVPROC staticPointerglMultiTexCoord1iv = 0; static MYPFNGLMULTITEXCOORD1SPROC staticPointerglMultiTexCoord1s = 0; static MYPFNGLMULTITEXCOORD1SVPROC staticPointerglMultiTexCoord1sv = 0; static MYPFNGLMULTITEXCOORD2DPROC staticPointerglMultiTexCoord2d = 0; static MYPFNGLMULTITEXCOORD2DVPROC staticPointerglMultiTexCoord2dv = 0; static MYPFNGLMULTITEXCOORD2FPROC staticPointerglMultiTexCoord2f = 0; static MYPFNGLMULTITEXCOORD2FVPROC staticPointerglMultiTexCoord2fv = 0; static MYPFNGLMULTITEXCOORD2IPROC staticPointerglMultiTexCoord2i = 0; static MYPFNGLMULTITEXCOORD2IVPROC staticPointerglMultiTexCoord2iv = 0; static MYPFNGLMULTITEXCOORD2SPROC staticPointerglMultiTexCoord2s = 0; static MYPFNGLMULTITEXCOORD2SVPROC staticPointerglMultiTexCoord2sv = 0; static MYPFNGLMULTITEXCOORD3DPROC staticPointerglMultiTexCoord3d = 0; static MYPFNGLMULTITEXCOORD3DVPROC staticPointerglMultiTexCoord3dv = 0; static MYPFNGLMULTITEXCOORD3FPROC staticPointerglMultiTexCoord3f = 0; static MYPFNGLMULTITEXCOORD3FVPROC staticPointerglMultiTexCoord3fv = 0; static MYPFNGLMULTITEXCOORD3IPROC staticPointerglMultiTexCoord3i = 0; static MYPFNGLMULTITEXCOORD3IVPROC staticPointerglMultiTexCoord3iv = 0; static MYPFNGLMULTITEXCOORD3SPROC staticPointerglMultiTexCoord3s = 0; static MYPFNGLMULTITEXCOORD3SVPROC staticPointerglMultiTexCoord3sv = 0; static MYPFNGLMULTITEXCOORD4DPROC staticPointerglMultiTexCoord4d = 0; static MYPFNGLMULTITEXCOORD4DVPROC staticPointerglMultiTexCoord4dv = 0; static MYPFNGLMULTITEXCOORD4FPROC staticPointerglMultiTexCoord4f = 0; static MYPFNGLMULTITEXCOORD4FVPROC staticPointerglMultiTexCoord4fv = 0; static MYPFNGLMULTITEXCOORD4IPROC staticPointerglMultiTexCoord4i = 0; static MYPFNGLMULTITEXCOORD4IVPROC staticPointerglMultiTexCoord4iv = 0; static MYPFNGLMULTITEXCOORD4SPROC staticPointerglMultiTexCoord4s = 0; static MYPFNGLMULTITEXCOORD4SVPROC staticPointerglMultiTexCoord4sv = 0; static MYPFNGLLOADTRANSPOSEMATRIXFPROC staticPointerglLoadTransposeMatrixf = 0; static MYPFNGLLOADTRANSPOSEMATRIXDPROC staticPointerglLoadTransposeMatrixd = 0; static MYPFNGLMULTTRANSPOSEMATRIXFPROC staticPointerglMultTransposeMatrixf = 0; static MYPFNGLMULTTRANSPOSEMATRIXDPROC staticPointerglMultTransposeMatrixd = 0; static MYPFNGLSAMPLECOVERAGEPROC staticPointerglSampleCoverage = 0; static MYPFNGLCOMPRESSEDTEXIMAGE3DPROC staticPointerglCompressedTexImage3D = 0; static MYPFNGLCOMPRESSEDTEXIMAGE2DPROC staticPointerglCompressedTexImage2D = 0; static MYPFNGLCOMPRESSEDTEXIMAGE1DPROC staticPointerglCompressedTexImage1D = 0; static MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC staticPointerglCompressedTexSubImage3D = 0; static MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC staticPointerglCompressedTexSubImage2D = 0; static MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC staticPointerglCompressedTexSubImage1D = 0; static MYPFNGLGETCOMPRESSEDTEXIMAGEPROC staticPointerglGetCompressedTexImage = 0; // End OpenGL version 1.3 // OpenGL version 1.4 static MYPFNGLBLENDFUNCSEPARATEPROC staticPointerglBlendFuncSeparate = 0; static MYPFNGLFOGCOORDFPROC staticPointerglFogCoordf = 0; static MYPFNGLFOGCOORDFVPROC staticPointerglFogCoordfv = 0; static MYPFNGLFOGCOORDDPROC staticPointerglFogCoordd = 0; static MYPFNGLFOGCOORDDVPROC staticPointerglFogCoorddv = 0; static MYPFNGLFOGCOORDPOINTERPROC staticPointerglFogCoordPointer = 0; static MYPFNGLMULTIDRAWARRAYSPROC staticPointerglMultiDrawArrays = 0; static MYPFNGLMULTIDRAWELEMENTSPROC staticPointerglMultiDrawElements = 0; static MYPFNGLPOINTPARAMETERFPROC staticPointerglPointParameterf = 0; static MYPFNGLPOINTPARAMETERFVPROC staticPointerglPointParameterfv = 0; static MYPFNGLPOINTPARAMETERIPROC staticPointerglPointParameteri = 0; static MYPFNGLPOINTPARAMETERIVPROC staticPointerglPointParameteriv = 0; static MYPFNGLSECONDARYCOLOR3BPROC staticPointerglSecondaryColor3b = 0; static MYPFNGLSECONDARYCOLOR3BVPROC staticPointerglSecondaryColor3bv = 0; static MYPFNGLSECONDARYCOLOR3DPROC staticPointerglSecondaryColor3d = 0; static MYPFNGLSECONDARYCOLOR3DVPROC staticPointerglSecondaryColor3dv = 0; static MYPFNGLSECONDARYCOLOR3FPROC staticPointerglSecondaryColor3f = 0; static MYPFNGLSECONDARYCOLOR3FVPROC staticPointerglSecondaryColor3fv = 0; static MYPFNGLSECONDARYCOLOR3IPROC staticPointerglSecondaryColor3i = 0; static MYPFNGLSECONDARYCOLOR3IVPROC staticPointerglSecondaryColor3iv = 0; static MYPFNGLSECONDARYCOLOR3SPROC staticPointerglSecondaryColor3s = 0; static MYPFNGLSECONDARYCOLOR3SVPROC staticPointerglSecondaryColor3sv = 0; static MYPFNGLSECONDARYCOLOR3UBPROC staticPointerglSecondaryColor3ub = 0; static MYPFNGLSECONDARYCOLOR3UBVPROC staticPointerglSecondaryColor3ubv = 0; static MYPFNGLSECONDARYCOLOR3UIPROC staticPointerglSecondaryColor3ui = 0; static MYPFNGLSECONDARYCOLOR3UIVPROC staticPointerglSecondaryColor3uiv = 0; static MYPFNGLSECONDARYCOLOR3USPROC staticPointerglSecondaryColor3us = 0; static MYPFNGLSECONDARYCOLOR3USVPROC staticPointerglSecondaryColor3usv = 0; static MYPFNGLSECONDARYCOLORPOINTERPROC staticPointerglSecondaryColorPointer = 0; static MYPFNGLWINDOWPOS2DPROC staticPointerglWindowPos2d = 0; static MYPFNGLWINDOWPOS2DVPROC staticPointerglWindowPos2dv = 0; static MYPFNGLWINDOWPOS2FPROC staticPointerglWindowPos2f = 0; static MYPFNGLWINDOWPOS2FVPROC staticPointerglWindowPos2fv = 0; static MYPFNGLWINDOWPOS2IPROC staticPointerglWindowPos2i = 0; static MYPFNGLWINDOWPOS2IVPROC staticPointerglWindowPos2iv = 0; static MYPFNGLWINDOWPOS2SPROC staticPointerglWindowPos2s = 0; static MYPFNGLWINDOWPOS2SVPROC staticPointerglWindowPos2sv = 0; static MYPFNGLWINDOWPOS3DPROC staticPointerglWindowPos3d = 0; static MYPFNGLWINDOWPOS3DVPROC staticPointerglWindowPos3dv = 0; static MYPFNGLWINDOWPOS3FPROC staticPointerglWindowPos3f = 0; static MYPFNGLWINDOWPOS3FVPROC staticPointerglWindowPos3fv = 0; static MYPFNGLWINDOWPOS3IPROC staticPointerglWindowPos3i = 0; static MYPFNGLWINDOWPOS3IVPROC staticPointerglWindowPos3iv = 0; static MYPFNGLWINDOWPOS3SPROC staticPointerglWindowPos3s = 0; static MYPFNGLWINDOWPOS3SVPROC staticPointerglWindowPos3sv = 0; // End OpenGL version 1.4 // OpenGL version 1.5 static MYPFNGLGENQUERIESPROC staticPointerglGenQueries = 0; static MYPFNGLDELETEQUERIESPROC staticPointerglDeleteQueries = 0; static MYPFNGLISQUERYPROC staticPointerglIsQuery = 0; static MYPFNGLBEGINQUERYPROC staticPointerglBeginQuery = 0; static MYPFNGLENDQUERYPROC staticPointerglEndQuery = 0; static MYPFNGLGETQUERYIVPROC staticPointerglGetQueryiv = 0; static MYPFNGLGETQUERYOBJECTIVPROC staticPointerglGetQueryObjectiv = 0; static MYPFNGLGETQUERYOBJECTUIVPROC staticPointerglGetQueryObjectuiv = 0; static MYPFNGLBINDBUFFERPROC staticPointerglBindBuffer = 0; static MYPFNGLDELETEBUFFERSPROC staticPointerglDeleteBuffers = 0; static MYPFNGLGENBUFFERSPROC staticPointerglGenBuffers = 0; static MYPFNGLISBUFFERPROC staticPointerglIsBuffer = 0; static MYPFNGLBUFFERDATAPROC staticPointerglBufferData = 0; static MYPFNGLBUFFERSUBDATAPROC staticPointerglBufferSubData = 0; static MYPFNGLGETBUFFERSUBDATAPROC staticPointerglGetBufferSubData = 0; static MYPFNGLMAPBUFFERPROC staticPointerglMapBuffer = 0; static MYPFNGLUNMAPBUFFERPROC staticPointerglUnmapBuffer = 0; static MYPFNGLGETBUFFERPARAMETERIVPROC staticPointerglGetBufferParameteriv = 0; static MYPFNGLGETBUFFERPOINTERVPROC staticPointerglGetBufferPointerv = 0; // End OpenGL version 1.5 // OpenGL version 2.0 static MYPFNGLBLENDEQUATIONSEPARATEPROC staticPointerglBlendEquationSeparate = 0; static MYPFNGLDRAWBUFFERSPROC staticPointerglDrawBuffers = 0; static MYPFNGLSTENCILOPSEPARATEPROC staticPointerglStencilOpSeparate = 0; static MYPFNGLSTENCILFUNCSEPARATEPROC staticPointerglStencilFuncSeparate = 0; static MYPFNGLSTENCILMASKSEPARATEPROC staticPointerglStencilMaskSeparate = 0; static MYPFNGLATTACHSHADERPROC staticPointerglAttachShader = 0; static MYPFNGLBINDATTRIBLOCATIONPROC staticPointerglBindAttribLocation = 0; static MYPFNGLCOMPILESHADERPROC staticPointerglCompileShader = 0; static MYPFNGLCREATEPROGRAMPROC staticPointerglCreateProgram = 0; static MYPFNGLCREATESHADERPROC staticPointerglCreateShader = 0; static MYPFNGLDELETEPROGRAMPROC staticPointerglDeleteProgram = 0; static MYPFNGLDELETESHADERPROC staticPointerglDeleteShader = 0; static MYPFNGLDETACHSHADERPROC staticPointerglDetachShader = 0; static MYPFNGLDISABLEVERTEXATTRIBARRAYPROC staticPointerglDisableVertexAttribArray = 0; static MYPFNGLENABLEVERTEXATTRIBARRAYPROC staticPointerglEnableVertexAttribArray = 0; static MYPFNGLGETACTIVEATTRIBPROC staticPointerglGetActiveAttrib = 0; static MYPFNGLGETACTIVEUNIFORMPROC staticPointerglGetActiveUniform = 0; static MYPFNGLGETATTACHEDSHADERSPROC staticPointerglGetAttachedShaders = 0; static MYPFNGLGETATTRIBLOCATIONPROC staticPointerglGetAttribLocation = 0; static MYPFNGLGETPROGRAMIVPROC staticPointerglGetProgramiv = 0; static MYPFNGLGETPROGRAMINFOLOGPROC staticPointerglGetProgramInfoLog = 0; static MYPFNGLGETSHADERIVPROC staticPointerglGetShaderiv = 0; static MYPFNGLGETSHADERINFOLOGPROC staticPointerglGetShaderInfoLog = 0; static MYPFNGLGETSHADERSOURCEPROC staticPointerglGetShaderSource = 0; static MYPFNGLGETUNIFORMLOCATIONPROC staticPointerglGetUniformLocation = 0; static MYPFNGLGETUNIFORMFVPROC staticPointerglGetUniformfv = 0; static MYPFNGLGETUNIFORMIVPROC staticPointerglGetUniformiv = 0; static MYPFNGLGETVERTEXATTRIBDVPROC staticPointerglGetVertexAttribdv = 0; static MYPFNGLGETVERTEXATTRIBFVPROC staticPointerglGetVertexAttribfv = 0; static MYPFNGLGETVERTEXATTRIBIVPROC staticPointerglGetVertexAttribiv = 0; static MYPFNGLGETVERTEXATTRIBPOINTERVPROC staticPointerglGetVertexAttribPointerv = 0; static MYPFNGLISPROGRAMPROC staticPointerglIsProgram = 0; static MYPFNGLISSHADERPROC staticPointerglIsShader = 0; static MYPFNGLLINKPROGRAMPROC staticPointerglLinkProgram = 0; static MYPFNGLSHADERSOURCEPROC staticPointerglShaderSource = 0; static MYPFNGLUSEPROGRAMPROC staticPointerglUseProgram = 0; static MYPFNGLUNIFORM1FPROC staticPointerglUniform1f = 0; static MYPFNGLUNIFORM2FPROC staticPointerglUniform2f = 0; static MYPFNGLUNIFORM3FPROC staticPointerglUniform3f = 0; static MYPFNGLUNIFORM4FPROC staticPointerglUniform4f = 0; static MYPFNGLUNIFORM1IPROC staticPointerglUniform1i = 0; static MYPFNGLUNIFORM2IPROC staticPointerglUniform2i = 0; static MYPFNGLUNIFORM3IPROC staticPointerglUniform3i = 0; static MYPFNGLUNIFORM4IPROC staticPointerglUniform4i = 0; static MYPFNGLUNIFORM1FVPROC staticPointerglUniform1fv = 0; static MYPFNGLUNIFORM2FVPROC staticPointerglUniform2fv = 0; static MYPFNGLUNIFORM3FVPROC staticPointerglUniform3fv = 0; static MYPFNGLUNIFORM4FVPROC staticPointerglUniform4fv = 0; static MYPFNGLUNIFORM1IVPROC staticPointerglUniform1iv = 0; static MYPFNGLUNIFORM2IVPROC staticPointerglUniform2iv = 0; static MYPFNGLUNIFORM3IVPROC staticPointerglUniform3iv = 0; static MYPFNGLUNIFORM4IVPROC staticPointerglUniform4iv = 0; static MYPFNGLUNIFORMMATRIX2FVPROC staticPointerglUniformMatrix2fv = 0; static MYPFNGLUNIFORMMATRIX3FVPROC staticPointerglUniformMatrix3fv = 0; static MYPFNGLUNIFORMMATRIX4FVPROC staticPointerglUniformMatrix4fv = 0; static MYPFNGLVALIDATEPROGRAMPROC staticPointerglValidateProgram = 0; static MYPFNGLVERTEXATTRIB1DPROC staticPointerglVertexAttrib1d = 0; static MYPFNGLVERTEXATTRIB1DVPROC staticPointerglVertexAttrib1dv = 0; static MYPFNGLVERTEXATTRIB1FPROC staticPointerglVertexAttrib1f = 0; static MYPFNGLVERTEXATTRIB1FVPROC staticPointerglVertexAttrib1fv = 0; static MYPFNGLVERTEXATTRIB1SPROC staticPointerglVertexAttrib1s = 0; static MYPFNGLVERTEXATTRIB1SVPROC staticPointerglVertexAttrib1sv = 0; static MYPFNGLVERTEXATTRIB2DPROC staticPointerglVertexAttrib2d = 0; static MYPFNGLVERTEXATTRIB2DVPROC staticPointerglVertexAttrib2dv = 0; static MYPFNGLVERTEXATTRIB2FPROC staticPointerglVertexAttrib2f = 0; static MYPFNGLVERTEXATTRIB2FVPROC staticPointerglVertexAttrib2fv = 0; static MYPFNGLVERTEXATTRIB2SPROC staticPointerglVertexAttrib2s = 0; static MYPFNGLVERTEXATTRIB2SVPROC staticPointerglVertexAttrib2sv = 0; static MYPFNGLVERTEXATTRIB3DPROC staticPointerglVertexAttrib3d = 0; static MYPFNGLVERTEXATTRIB3DVPROC staticPointerglVertexAttrib3dv = 0; static MYPFNGLVERTEXATTRIB3FPROC staticPointerglVertexAttrib3f = 0; static MYPFNGLVERTEXATTRIB3FVPROC staticPointerglVertexAttrib3fv = 0; static MYPFNGLVERTEXATTRIB3SPROC staticPointerglVertexAttrib3s = 0; static MYPFNGLVERTEXATTRIB3SVPROC staticPointerglVertexAttrib3sv = 0; static MYPFNGLVERTEXATTRIB4NBVPROC staticPointerglVertexAttrib4Nbv = 0; static MYPFNGLVERTEXATTRIB4NIVPROC staticPointerglVertexAttrib4Niv = 0; static MYPFNGLVERTEXATTRIB4NSVPROC staticPointerglVertexAttrib4Nsv = 0; static MYPFNGLVERTEXATTRIB4NUBPROC staticPointerglVertexAttrib4Nub = 0; static MYPFNGLVERTEXATTRIB4NUBVPROC staticPointerglVertexAttrib4Nubv = 0; static MYPFNGLVERTEXATTRIB4NUIVPROC staticPointerglVertexAttrib4Nuiv = 0; static MYPFNGLVERTEXATTRIB4NUSVPROC staticPointerglVertexAttrib4Nusv = 0; static MYPFNGLVERTEXATTRIB4BVPROC staticPointerglVertexAttrib4bv = 0; static MYPFNGLVERTEXATTRIB4DPROC staticPointerglVertexAttrib4d = 0; static MYPFNGLVERTEXATTRIB4DVPROC staticPointerglVertexAttrib4dv = 0; static MYPFNGLVERTEXATTRIB4FPROC staticPointerglVertexAttrib4f = 0; static MYPFNGLVERTEXATTRIB4FVPROC staticPointerglVertexAttrib4fv = 0; static MYPFNGLVERTEXATTRIB4IVPROC staticPointerglVertexAttrib4iv = 0; static MYPFNGLVERTEXATTRIB4SPROC staticPointerglVertexAttrib4s = 0; static MYPFNGLVERTEXATTRIB4SVPROC staticPointerglVertexAttrib4sv = 0; static MYPFNGLVERTEXATTRIB4UBVPROC staticPointerglVertexAttrib4ubv = 0; static MYPFNGLVERTEXATTRIB4UIVPROC staticPointerglVertexAttrib4uiv = 0; static MYPFNGLVERTEXATTRIB4USVPROC staticPointerglVertexAttrib4usv = 0; static MYPFNGLVERTEXATTRIBPOINTERPROC staticPointerglVertexAttribPointer = 0; // End OpenGL version 2.0 // GL_EXT_paletted_texture static MYPFNGLCOLORTABLEEXTPROC staticPointerglColorTableEXT = (MYPFNGLCOLORTABLEEXTPROC) 0; static MYPFNGLGETCOLORTABLEEXTPROC staticPointerglGetColorTableEXT = (MYPFNGLGETCOLORTABLEEXTPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC staticPointerglGetColorTableParameterivEXT = (MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC staticPointerglGetColorTableParameterfvEXT = (MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) 0; // End GL_EXT_paletted_texture // GL_ARB_multitexture static MYPFNGLACTIVETEXTUREARBPROC staticPointerglActiveTextureARB = (MYPFNGLACTIVETEXTUREARBPROC) 0; static MYPFNGLCLIENTACTIVETEXTUREARBPROC staticPointerglClientActiveTextureARB = (MYPFNGLCLIENTACTIVETEXTUREARBPROC) 0; static MYPFNGLMULTITEXCOORD1DARBPROC staticPointerglMultiTexCoord1dARB = (MYPFNGLMULTITEXCOORD1DARBPROC) 0; static MYPFNGLMULTITEXCOORD1DVARBPROC staticPointerglMultiTexCoord1dvARB = (MYPFNGLMULTITEXCOORD1DVARBPROC) 0; static MYPFNGLMULTITEXCOORD1FARBPROC staticPointerglMultiTexCoord1fARB = (MYPFNGLMULTITEXCOORD1FARBPROC) 0; static MYPFNGLMULTITEXCOORD1FVARBPROC staticPointerglMultiTexCoord1fvARB = (MYPFNGLMULTITEXCOORD1FVARBPROC) 0; static MYPFNGLMULTITEXCOORD1IARBPROC staticPointerglMultiTexCoord1iARB = (MYPFNGLMULTITEXCOORD1IARBPROC) 0; static MYPFNGLMULTITEXCOORD1IVARBPROC staticPointerglMultiTexCoord1ivARB = (MYPFNGLMULTITEXCOORD1IVARBPROC) 0; static MYPFNGLMULTITEXCOORD1SARBPROC staticPointerglMultiTexCoord1sARB = (MYPFNGLMULTITEXCOORD1SARBPROC) 0; static MYPFNGLMULTITEXCOORD1SVARBPROC staticPointerglMultiTexCoord1svARB = (MYPFNGLMULTITEXCOORD1SVARBPROC) 0; static MYPFNGLMULTITEXCOORD2DARBPROC staticPointerglMultiTexCoord2dARB = (MYPFNGLMULTITEXCOORD2DARBPROC) 0; static MYPFNGLMULTITEXCOORD2DVARBPROC staticPointerglMultiTexCoord2dvARB = (MYPFNGLMULTITEXCOORD2DVARBPROC) 0; static MYPFNGLMULTITEXCOORD2FARBPROC staticPointerglMultiTexCoord2fARB = (MYPFNGLMULTITEXCOORD2FARBPROC) 0; static MYPFNGLMULTITEXCOORD2FVARBPROC staticPointerglMultiTexCoord2fvARB = (MYPFNGLMULTITEXCOORD2FVARBPROC) 0; static MYPFNGLMULTITEXCOORD2IARBPROC staticPointerglMultiTexCoord2iARB = (MYPFNGLMULTITEXCOORD2IARBPROC) 0; static MYPFNGLMULTITEXCOORD2IVARBPROC staticPointerglMultiTexCoord2ivARB = (MYPFNGLMULTITEXCOORD2IVARBPROC) 0; static MYPFNGLMULTITEXCOORD2SARBPROC staticPointerglMultiTexCoord2sARB = (MYPFNGLMULTITEXCOORD2SARBPROC) 0; static MYPFNGLMULTITEXCOORD2SVARBPROC staticPointerglMultiTexCoord2svARB = (MYPFNGLMULTITEXCOORD2SVARBPROC) 0; static MYPFNGLMULTITEXCOORD3DARBPROC staticPointerglMultiTexCoord3dARB = (MYPFNGLMULTITEXCOORD3DARBPROC) 0; static MYPFNGLMULTITEXCOORD3DVARBPROC staticPointerglMultiTexCoord3dvARB = (MYPFNGLMULTITEXCOORD3DVARBPROC) 0; static MYPFNGLMULTITEXCOORD3FARBPROC staticPointerglMultiTexCoord3fARB = (MYPFNGLMULTITEXCOORD3FARBPROC) 0; static MYPFNGLMULTITEXCOORD3FVARBPROC staticPointerglMultiTexCoord3fvARB = (MYPFNGLMULTITEXCOORD3FVARBPROC) 0; static MYPFNGLMULTITEXCOORD3IARBPROC staticPointerglMultiTexCoord3iARB = (MYPFNGLMULTITEXCOORD3IARBPROC) 0; static MYPFNGLMULTITEXCOORD3IVARBPROC staticPointerglMultiTexCoord3ivARB = (MYPFNGLMULTITEXCOORD3IVARBPROC) 0; static MYPFNGLMULTITEXCOORD3SARBPROC staticPointerglMultiTexCoord3sARB = (MYPFNGLMULTITEXCOORD3SARBPROC) 0; static MYPFNGLMULTITEXCOORD3SVARBPROC staticPointerglMultiTexCoord3svARB = (MYPFNGLMULTITEXCOORD3SVARBPROC) 0; static MYPFNGLMULTITEXCOORD4DARBPROC staticPointerglMultiTexCoord4dARB = (MYPFNGLMULTITEXCOORD4DARBPROC) 0; static MYPFNGLMULTITEXCOORD4DVARBPROC staticPointerglMultiTexCoord4dvARB = (MYPFNGLMULTITEXCOORD4DVARBPROC) 0; static MYPFNGLMULTITEXCOORD4FARBPROC staticPointerglMultiTexCoord4fARB = (MYPFNGLMULTITEXCOORD4FARBPROC) 0; static MYPFNGLMULTITEXCOORD4FVARBPROC staticPointerglMultiTexCoord4fvARB = (MYPFNGLMULTITEXCOORD4FVARBPROC) 0; static MYPFNGLMULTITEXCOORD4IARBPROC staticPointerglMultiTexCoord4iARB = (MYPFNGLMULTITEXCOORD4IARBPROC) 0; static MYPFNGLMULTITEXCOORD4IVARBPROC staticPointerglMultiTexCoord4ivARB = (MYPFNGLMULTITEXCOORD4IVARBPROC) 0; static MYPFNGLMULTITEXCOORD4SARBPROC staticPointerglMultiTexCoord4sARB = (MYPFNGLMULTITEXCOORD4SARBPROC) 0; static MYPFNGLMULTITEXCOORD4SVARBPROC staticPointerglMultiTexCoord4svARB = (MYPFNGLMULTITEXCOORD4SVARBPROC) 0; // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table static MYPFNGLCOLORTABLESGIPROC staticPointerglColorTableSGI = (MYPFNGLCOLORTABLESGIPROC) 0; static MYPFNGLCOLORTABLEPARAMETERFVSGIPROC staticPointerglColorTableParameterfvSGI = (MYPFNGLCOLORTABLEPARAMETERFVSGIPROC) 0; static MYPFNGLCOLORTABLEPARAMETERIVSGIPROC staticPointerglColorTableParameterivSGI = (MYPFNGLCOLORTABLEPARAMETERIVSGIPROC) 0; static MYPFNGLCOPYCOLORTABLESGIPROC staticPointerglCopyColorTableSGI = (MYPFNGLCOPYCOLORTABLESGIPROC) 0; static MYPFNGLGETCOLORTABLESGIPROC staticPointerglGetColorTableSGI = (MYPFNGLGETCOLORTABLESGIPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC staticPointerglGetColorTableParameterfvSGI = (MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC staticPointerglGetColorTableParameterivSGI = (MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) 0; // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D static MYPFNGLTEXIMAGE3DEXTPROC staticPointerglTexImage3DEXT = (MYPFNGLTEXIMAGE3DEXTPROC) 0; static MYPFNGLTEXSUBIMAGE3DEXTPROC staticPointerglTexSubImage3DEXT = (MYPFNGLTEXSUBIMAGE3DEXTPROC) 0; // End GL_EXT_texture3D // GL_NV_fragment_program static MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC staticPointerglProgramNamedParameter4fNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) 0; static MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC staticPointerglProgramNamedParameter4dNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) 0; static MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC staticPointerglProgramNamedParameter4fvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) 0; static MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC staticPointerglProgramNamedParameter4dvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) 0; static MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC staticPointerglGetProgramNamedParameterfvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) 0; static MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC staticPointerglGetProgramNamedParameterdvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) 0; // GL_NV_fragment_program // GL_NV_vertex_program static MYPFNGLAREPROGRAMSRESIDENTNVPROC staticPointerglAreProgramsResidentNV = (MYPFNGLAREPROGRAMSRESIDENTNVPROC) 0; static MYPFNGLBINDPROGRAMNVPROC staticPointerglBindProgramNV = (MYPFNGLBINDPROGRAMNVPROC) 0; static MYPFNGLDELETEPROGRAMSNVPROC staticPointerglDeleteProgramsNV = (MYPFNGLDELETEPROGRAMSNVPROC) 0; static MYPFNGLEXECUTEPROGRAMNVPROC staticPointerglExecuteProgramNV = (MYPFNGLEXECUTEPROGRAMNVPROC) 0; static MYPFNGLGENPROGRAMSNVPROC staticPointerglGenProgramsNV = (MYPFNGLGENPROGRAMSNVPROC) 0; static MYPFNGLGETPROGRAMPARAMETERDVNVPROC staticPointerglGetProgramParameterdvNV = (MYPFNGLGETPROGRAMPARAMETERDVNVPROC) 0; static MYPFNGLGETPROGRAMPARAMETERFVNVPROC staticPointerglGetProgramParameterfvNV = (MYPFNGLGETPROGRAMPARAMETERFVNVPROC) 0; static MYPFNGLGETPROGRAMIVNVPROC staticPointerglGetProgramivNV = (MYPFNGLGETPROGRAMIVNVPROC) 0; static MYPFNGLGETPROGRAMSTRINGNVPROC staticPointerglGetProgramStringNV = (MYPFNGLGETPROGRAMSTRINGNVPROC) 0; static MYPFNGLGETTRACKMATRIXIVNVPROC staticPointerglGetTrackMatrixivNV = (MYPFNGLGETTRACKMATRIXIVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBDVNVPROC staticPointerglGetVertexAttribdvNV = (MYPFNGLGETVERTEXATTRIBDVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBFVNVPROC staticPointerglGetVertexAttribfvNV = (MYPFNGLGETVERTEXATTRIBFVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBIVNVPROC staticPointerglGetVertexAttribivNV = (MYPFNGLGETVERTEXATTRIBIVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC staticPointerglGetVertexAttribPointervNV = (MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC) 0; static MYPFNGLISPROGRAMNVPROC staticPointerglIsProgramNV = (MYPFNGLISPROGRAMNVPROC) 0; static MYPFNGLLOADPROGRAMNVPROC staticPointerglLoadProgramNV = (MYPFNGLLOADPROGRAMNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4DNVPROC staticPointerglProgramParameter4dNV = (MYPFNGLPROGRAMPARAMETER4DNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4DVNVPROC staticPointerglProgramParameter4dvNV = (MYPFNGLPROGRAMPARAMETER4DVNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4FNVPROC staticPointerglProgramParameter4fNV = (MYPFNGLPROGRAMPARAMETER4FNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4FVNVPROC staticPointerglProgramParameter4fvNV = (MYPFNGLPROGRAMPARAMETER4FVNVPROC) 0; static MYPFNGLPROGRAMPARAMETERS4DVNVPROC staticPointerglProgramParameters4dvNV = (MYPFNGLPROGRAMPARAMETERS4DVNVPROC) 0; static MYPFNGLPROGRAMPARAMETERS4FVNVPROC staticPointerglProgramParameters4fvNV = (MYPFNGLPROGRAMPARAMETERS4FVNVPROC) 0; static MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC staticPointerglRequestResidentProgramsNV = (MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC) 0; static MYPFNGLTRACKMATRIXNVPROC staticPointerglTrackMatrixNV = (MYPFNGLTRACKMATRIXNVPROC) 0; static MYPFNGLVERTEXATTRIBPOINTERNVPROC staticPointerglVertexAttribPointerNV = (MYPFNGLVERTEXATTRIBPOINTERNVPROC) 0; static MYPFNGLVERTEXATTRIB1DNVPROC staticPointerglVertexAttrib1dNV = (MYPFNGLVERTEXATTRIB1DNVPROC) 0; static MYPFNGLVERTEXATTRIB1DVNVPROC staticPointerglVertexAttrib1dvNV = (MYPFNGLVERTEXATTRIB1DVNVPROC) 0; static MYPFNGLVERTEXATTRIB1FNVPROC staticPointerglVertexAttrib1fNV = (MYPFNGLVERTEXATTRIB1FNVPROC) 0; static MYPFNGLVERTEXATTRIB1FVNVPROC staticPointerglVertexAttrib1fvNV = (MYPFNGLVERTEXATTRIB1FVNVPROC) 0; static MYPFNGLVERTEXATTRIB1SNVPROC staticPointerglVertexAttrib1sNV = (MYPFNGLVERTEXATTRIB1SNVPROC) 0; static MYPFNGLVERTEXATTRIB1SVNVPROC staticPointerglVertexAttrib1svNV = (MYPFNGLVERTEXATTRIB1SVNVPROC) 0; static MYPFNGLVERTEXATTRIB2DNVPROC staticPointerglVertexAttrib2dNV = (MYPFNGLVERTEXATTRIB2DNVPROC) 0; static MYPFNGLVERTEXATTRIB2DVNVPROC staticPointerglVertexAttrib2dvNV = (MYPFNGLVERTEXATTRIB2DVNVPROC) 0; static MYPFNGLVERTEXATTRIB2FNVPROC staticPointerglVertexAttrib2fNV = (MYPFNGLVERTEXATTRIB2FNVPROC) 0; static MYPFNGLVERTEXATTRIB2FVNVPROC staticPointerglVertexAttrib2fvNV = (MYPFNGLVERTEXATTRIB2FVNVPROC) 0; static MYPFNGLVERTEXATTRIB2SNVPROC staticPointerglVertexAttrib2sNV = (MYPFNGLVERTEXATTRIB2SNVPROC) 0; static MYPFNGLVERTEXATTRIB2SVNVPROC staticPointerglVertexAttrib2svNV = (MYPFNGLVERTEXATTRIB2SVNVPROC) 0; static MYPFNGLVERTEXATTRIB3DNVPROC staticPointerglVertexAttrib3dNV = (MYPFNGLVERTEXATTRIB3DNVPROC) 0; static MYPFNGLVERTEXATTRIB3DVNVPROC staticPointerglVertexAttrib3dvNV = (MYPFNGLVERTEXATTRIB3DVNVPROC) 0; static MYPFNGLVERTEXATTRIB3FNVPROC staticPointerglVertexAttrib3fNV = (MYPFNGLVERTEXATTRIB3FNVPROC) 0; static MYPFNGLVERTEXATTRIB3FVNVPROC staticPointerglVertexAttrib3fvNV = (MYPFNGLVERTEXATTRIB3FVNVPROC) 0; static MYPFNGLVERTEXATTRIB3SNVPROC staticPointerglVertexAttrib3sNV = (MYPFNGLVERTEXATTRIB3SNVPROC) 0; static MYPFNGLVERTEXATTRIB3SVNVPROC staticPointerglVertexAttrib3svNV = (MYPFNGLVERTEXATTRIB3SVNVPROC) 0; static MYPFNGLVERTEXATTRIB4DNVPROC staticPointerglVertexAttrib4dNV = (MYPFNGLVERTEXATTRIB4DNVPROC) 0; static MYPFNGLVERTEXATTRIB4DVNVPROC staticPointerglVertexAttrib4dvNV = (MYPFNGLVERTEXATTRIB4DVNVPROC) 0; static MYPFNGLVERTEXATTRIB4FNVPROC staticPointerglVertexAttrib4fNV = (MYPFNGLVERTEXATTRIB4FNVPROC) 0; static MYPFNGLVERTEXATTRIB4FVNVPROC staticPointerglVertexAttrib4fvNV = (MYPFNGLVERTEXATTRIB4FVNVPROC) 0; static MYPFNGLVERTEXATTRIB4SNVPROC staticPointerglVertexAttrib4sNV = (MYPFNGLVERTEXATTRIB4SNVPROC) 0; static MYPFNGLVERTEXATTRIB4SVNVPROC staticPointerglVertexAttrib4svNV = (MYPFNGLVERTEXATTRIB4SVNVPROC) 0; static MYPFNGLVERTEXATTRIB4UBNVPROC staticPointerglVertexAttrib4ubNV = (MYPFNGLVERTEXATTRIB4UBNVPROC) 0; static MYPFNGLVERTEXATTRIB4UBVNVPROC staticPointerglVertexAttrib4ubvNV = (MYPFNGLVERTEXATTRIB4UBVNVPROC) 0; static MYPFNGLVERTEXATTRIBS1DVNVPROC staticPointerglVertexAttribs1dvNV = (MYPFNGLVERTEXATTRIBS1DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS1FVNVPROC staticPointerglVertexAttribs1fvNV = (MYPFNGLVERTEXATTRIBS1FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS1SVNVPROC staticPointerglVertexAttribs1svNV = (MYPFNGLVERTEXATTRIBS1SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS2DVNVPROC staticPointerglVertexAttribs2dvNV = (MYPFNGLVERTEXATTRIBS2DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS2FVNVPROC staticPointerglVertexAttribs2fvNV = (MYPFNGLVERTEXATTRIBS2FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS2SVNVPROC staticPointerglVertexAttribs2svNV = (MYPFNGLVERTEXATTRIBS2SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS3DVNVPROC staticPointerglVertexAttribs3dvNV = (MYPFNGLVERTEXATTRIBS3DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS3FVNVPROC staticPointerglVertexAttribs3fvNV = (MYPFNGLVERTEXATTRIBS3FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS3SVNVPROC staticPointerglVertexAttribs3svNV = (MYPFNGLVERTEXATTRIBS3SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4DVNVPROC staticPointerglVertexAttribs4dvNV = (MYPFNGLVERTEXATTRIBS4DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4FVNVPROC staticPointerglVertexAttribs4fvNV = (MYPFNGLVERTEXATTRIBS4FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4SVNVPROC staticPointerglVertexAttribs4svNV = (MYPFNGLVERTEXATTRIBS4SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4UBVNVPROC staticPointerglVertexAttribs4ubvNV = (MYPFNGLVERTEXATTRIBS4UBVNVPROC) 0; // GL_NV_vertex_program // GL_ARB_vertex_program static MYPFNGLVERTEXATTRIB1DARBPROC staticPointerglVertexAttrib1dARB = (MYPFNGLVERTEXATTRIB1DARBPROC) 0; static MYPFNGLVERTEXATTRIB1DVARBPROC staticPointerglVertexAttrib1dvARB = (MYPFNGLVERTEXATTRIB1DVARBPROC) 0; static MYPFNGLVERTEXATTRIB1FARBPROC staticPointerglVertexAttrib1fARB = (MYPFNGLVERTEXATTRIB1FARBPROC) 0; static MYPFNGLVERTEXATTRIB1FVARBPROC staticPointerglVertexAttrib1fvARB = (MYPFNGLVERTEXATTRIB1FVARBPROC) 0; static MYPFNGLVERTEXATTRIB1SARBPROC staticPointerglVertexAttrib1sARB = (MYPFNGLVERTEXATTRIB1SARBPROC) 0; static MYPFNGLVERTEXATTRIB1SVARBPROC staticPointerglVertexAttrib1svARB = (MYPFNGLVERTEXATTRIB1SVARBPROC) 0; static MYPFNGLVERTEXATTRIB2DARBPROC staticPointerglVertexAttrib2dARB = (MYPFNGLVERTEXATTRIB2DARBPROC) 0; static MYPFNGLVERTEXATTRIB2DVARBPROC staticPointerglVertexAttrib2dvARB = (MYPFNGLVERTEXATTRIB2DVARBPROC) 0; static MYPFNGLVERTEXATTRIB2FARBPROC staticPointerglVertexAttrib2fARB = (MYPFNGLVERTEXATTRIB2FARBPROC) 0; static MYPFNGLVERTEXATTRIB2FVARBPROC staticPointerglVertexAttrib2fvARB = (MYPFNGLVERTEXATTRIB2FVARBPROC) 0; static MYPFNGLVERTEXATTRIB2SARBPROC staticPointerglVertexAttrib2sARB = (MYPFNGLVERTEXATTRIB2SARBPROC) 0; static MYPFNGLVERTEXATTRIB2SVARBPROC staticPointerglVertexAttrib2svARB = (MYPFNGLVERTEXATTRIB2SVARBPROC) 0; static MYPFNGLVERTEXATTRIB3DARBPROC staticPointerglVertexAttrib3dARB = (MYPFNGLVERTEXATTRIB3DARBPROC) 0; static MYPFNGLVERTEXATTRIB3DVARBPROC staticPointerglVertexAttrib3dvARB = (MYPFNGLVERTEXATTRIB3DVARBPROC) 0; static MYPFNGLVERTEXATTRIB3FARBPROC staticPointerglVertexAttrib3fARB = (MYPFNGLVERTEXATTRIB3FARBPROC) 0; static MYPFNGLVERTEXATTRIB3FVARBPROC staticPointerglVertexAttrib3fvARB = (MYPFNGLVERTEXATTRIB3FVARBPROC) 0; static MYPFNGLVERTEXATTRIB3SARBPROC staticPointerglVertexAttrib3sARB = (MYPFNGLVERTEXATTRIB3SARBPROC) 0; static MYPFNGLVERTEXATTRIB3SVARBPROC staticPointerglVertexAttrib3svARB = (MYPFNGLVERTEXATTRIB3SVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NBVARBPROC staticPointerglVertexAttrib4NbvARB = (MYPFNGLVERTEXATTRIB4NBVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NIVARBPROC staticPointerglVertexAttrib4NivARB = (MYPFNGLVERTEXATTRIB4NIVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NSVARBPROC staticPointerglVertexAttrib4NsvARB = (MYPFNGLVERTEXATTRIB4NSVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUBARBPROC staticPointerglVertexAttrib4NubARB = (MYPFNGLVERTEXATTRIB4NUBARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUBVARBPROC staticPointerglVertexAttrib4NubvARB = (MYPFNGLVERTEXATTRIB4NUBVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUIVARBPROC staticPointerglVertexAttrib4NuivARB = (MYPFNGLVERTEXATTRIB4NUIVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUSVARBPROC staticPointerglVertexAttrib4NusvARB = (MYPFNGLVERTEXATTRIB4NUSVARBPROC) 0; static MYPFNGLVERTEXATTRIB4BVARBPROC staticPointerglVertexAttrib4bvARB = (MYPFNGLVERTEXATTRIB4BVARBPROC) 0; static MYPFNGLVERTEXATTRIB4DARBPROC staticPointerglVertexAttrib4dARB = (MYPFNGLVERTEXATTRIB4DARBPROC) 0; static MYPFNGLVERTEXATTRIB4DVARBPROC staticPointerglVertexAttrib4dvARB = (MYPFNGLVERTEXATTRIB4DVARBPROC) 0; static MYPFNGLVERTEXATTRIB4FARBPROC staticPointerglVertexAttrib4fARB = (MYPFNGLVERTEXATTRIB4FARBPROC) 0; static MYPFNGLVERTEXATTRIB4FVARBPROC staticPointerglVertexAttrib4fvARB = (MYPFNGLVERTEXATTRIB4FVARBPROC) 0; static MYPFNGLVERTEXATTRIB4IVARBPROC staticPointerglVertexAttrib4ivARB = (MYPFNGLVERTEXATTRIB4IVARBPROC) 0; static MYPFNGLVERTEXATTRIB4SARBPROC staticPointerglVertexAttrib4sARB = (MYPFNGLVERTEXATTRIB4SARBPROC) 0; static MYPFNGLVERTEXATTRIB4SVARBPROC staticPointerglVertexAttrib4svARB = (MYPFNGLVERTEXATTRIB4SVARBPROC) 0; static MYPFNGLVERTEXATTRIB4UBVARBPROC staticPointerglVertexAttrib4ubvARB = (MYPFNGLVERTEXATTRIB4UBVARBPROC) 0; static MYPFNGLVERTEXATTRIB4UIVARBPROC staticPointerglVertexAttrib4uivARB = (MYPFNGLVERTEXATTRIB4UIVARBPROC) 0; static MYPFNGLVERTEXATTRIB4USVARBPROC staticPointerglVertexAttrib4usvARB = (MYPFNGLVERTEXATTRIB4USVARBPROC) 0; static MYPFNGLVERTEXATTRIBPOINTERARBPROC staticPointerglVertexAttribPointerARB = (MYPFNGLVERTEXATTRIBPOINTERARBPROC) 0; static MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC staticPointerglEnableVertexAttribArrayARB = (MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC) 0; static MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC staticPointerglDisableVertexAttribArrayARB = (MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) 0; static MYPFNGLPROGRAMSTRINGARBPROC staticPointerglProgramStringARB = (MYPFNGLPROGRAMSTRINGARBPROC) 0; static MYPFNGLBINDPROGRAMARBPROC staticPointerglBindProgramARB = (MYPFNGLBINDPROGRAMARBPROC) 0; static MYPFNGLDELETEPROGRAMSARBPROC staticPointerglDeleteProgramsARB = (MYPFNGLDELETEPROGRAMSARBPROC) 0; static MYPFNGLGENPROGRAMSARBPROC staticPointerglGenProgramsARB = (MYPFNGLGENPROGRAMSARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4DARBPROC staticPointerglProgramEnvParameter4dARB = (MYPFNGLPROGRAMENVPARAMETER4DARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4DVARBPROC staticPointerglProgramEnvParameter4dvARB = (MYPFNGLPROGRAMENVPARAMETER4DVARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4FARBPROC staticPointerglProgramEnvParameter4fARB = (MYPFNGLPROGRAMENVPARAMETER4FARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4FVARBPROC staticPointerglProgramEnvParameter4fvARB = (MYPFNGLPROGRAMENVPARAMETER4FVARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC staticPointerglProgramLocalParameter4dARB = (MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC staticPointerglProgramLocalParameter4dvARB = (MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC staticPointerglProgramLocalParameter4fARB = (MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC staticPointerglProgramLocalParameter4fvARB = (MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) 0; static MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC staticPointerglGetProgramEnvParameterdvARB = (MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC) 0; static MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC staticPointerglGetProgramEnvParameterfvARB = (MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC) 0; static MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC staticPointerglGetProgramLocalParameterdvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) 0; static MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC staticPointerglGetProgramLocalParameterfvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) 0; static MYPFNGLGETPROGRAMIVARBPROC staticPointerglGetProgramivARB = (MYPFNGLGETPROGRAMIVARBPROC) 0; static MYPFNGLGETPROGRAMSTRINGARBPROC staticPointerglGetProgramStringARB = (MYPFNGLGETPROGRAMSTRINGARBPROC) 0; static MYPFNGLGETVERTEXATTRIBDVARBPROC staticPointerglGetVertexAttribdvARB = (MYPFNGLGETVERTEXATTRIBDVARBPROC) 0; static MYPFNGLGETVERTEXATTRIBFVARBPROC staticPointerglGetVertexAttribfvARB = (MYPFNGLGETVERTEXATTRIBFVARBPROC) 0; static MYPFNGLGETVERTEXATTRIBIVARBPROC staticPointerglGetVertexAttribivARB = (MYPFNGLGETVERTEXATTRIBIVARBPROC) 0; static MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC staticPointerglGetVertexAttribPointervARB = (MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC) 0; static MYPFNGLISPROGRAMARBPROC staticPointerglIsProgramARB = (MYPFNGLISPROGRAMARBPROC) 0; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program // EXT_secondary_color static MYPFNGLSECONDARYCOLOR3BEXTPROC staticPointerglSecondaryColor3bEXT = (MYPFNGLSECONDARYCOLOR3BEXTPROC)0; static MYPFNGLSECONDARYCOLOR3BVEXTPROC staticPointerglSecondaryColor3bvEXT = (MYPFNGLSECONDARYCOLOR3BVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3DEXTPROC staticPointerglSecondaryColor3dEXT = (MYPFNGLSECONDARYCOLOR3DEXTPROC)0; static MYPFNGLSECONDARYCOLOR3DVEXTPROC staticPointerglSecondaryColor3dvEXT = (MYPFNGLSECONDARYCOLOR3DVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3FEXTPROC staticPointerglSecondaryColor3fEXT = (MYPFNGLSECONDARYCOLOR3FEXTPROC)0; static MYPFNGLSECONDARYCOLOR3FVEXTPROC staticPointerglSecondaryColor3fvEXT = (MYPFNGLSECONDARYCOLOR3FVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3IEXTPROC staticPointerglSecondaryColor3iEXT = (MYPFNGLSECONDARYCOLOR3IEXTPROC)0; static MYPFNGLSECONDARYCOLOR3IVEXTPROC staticPointerglSecondaryColor3ivEXT = (MYPFNGLSECONDARYCOLOR3IVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3SEXTPROC staticPointerglSecondaryColor3sEXT = (MYPFNGLSECONDARYCOLOR3SEXTPROC)0; static MYPFNGLSECONDARYCOLOR3SVEXTPROC staticPointerglSecondaryColor3svEXT = (MYPFNGLSECONDARYCOLOR3SVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3UBEXTPROC staticPointerglSecondaryColor3ubEXT = (MYPFNGLSECONDARYCOLOR3UBEXTPROC)0; static MYPFNGLSECONDARYCOLOR3UBVEXTPROC staticPointerglSecondaryColor3ubvEXT = (MYPFNGLSECONDARYCOLOR3UBVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3UIEXTPROC staticPointerglSecondaryColor3uiEXT = (MYPFNGLSECONDARYCOLOR3UIEXTPROC)0; static MYPFNGLSECONDARYCOLOR3UIVEXTPROC staticPointerglSecondaryColor3uivEXT = (MYPFNGLSECONDARYCOLOR3UIVEXTPROC)0; static MYPFNGLSECONDARYCOLOR3USEXTPROC staticPointerglSecondaryColor3usEXT = (MYPFNGLSECONDARYCOLOR3USEXTPROC)0; static MYPFNGLSECONDARYCOLOR3USVEXTPROC staticPointerglSecondaryColor3usvEXT = (MYPFNGLSECONDARYCOLOR3USVEXTPROC)0; static MYPFNGLSECONDARYCOLORPOINTEREXTPROC staticPointerglSecondaryColorPointerEXT = (MYPFNGLSECONDARYCOLORPOINTEREXTPROC)0; // ARB_vertex_buffer_object static MYPFNGLBINDBUFFERARBPROC staticPointerglBindBufferARB = (MYPFNGLBINDBUFFERARBPROC)0; static MYPFNGLDELETEBUFFERSARBPROC staticPointerglDeleteBuffersARB = (MYPFNGLDELETEBUFFERSARBPROC)0; static MYPFNGLGENBUFFERSARBPROC staticPointerglGenBuffersARB = (MYPFNGLGENBUFFERSARBPROC)0; static MYPFNGLISBUFFERARBPROC staticPointerglIsBufferARB = (MYPFNGLISBUFFERARBPROC)0; static MYPFNGLBUFFERDATAARBPROC staticPointerglBufferDataARB = (MYPFNGLBUFFERDATAARBPROC)0; static MYPFNGLBUFFERSUBDATAARBPROC staticPointerglBufferSubDataARB = (MYPFNGLBUFFERSUBDATAARBPROC)0; static MYPFNGLGETBUFFERSUBDATAARBPROC staticPointerglGetBufferSubDataARB = (MYPFNGLGETBUFFERSUBDATAARBPROC)0; static MYPFNGLMAPBUFFERARBPROC staticPointerglMapBufferARB = (MYPFNGLMAPBUFFERARBPROC)0; static MYPFNGLUNMAPBUFFERARBPROC staticPointerglUnmapBufferARB = (MYPFNGLUNMAPBUFFERARBPROC)0; static MYPFNGLGETBUFFERPARAMETERIVARBPROC staticPointerglGetBufferParameterivARB = (MYPFNGLGETBUFFERPARAMETERIVARBPROC)0; static MYPFNGLGETBUFFERPOINTERVARBPROC staticPointerglGetBufferPointervARB = (MYPFNGLGETBUFFERPOINTERVARBPROC)0; void initStaticPointers() { if (staticPointersInitialized==true) return; staticPointersInitialized = true; #if defined(GL_VERSION_1_2) && GL_VERSION_1_2 staticPointerglBlendColor = (MYPFNGLBLENDCOLORPROC)glBlendColor; staticPointerglBlendEquation = (MYPFNGLBLENDEQUATIONPROC)glBlendEquation; staticPointerglDrawRangeElements = (MYPFNGLDRAWRANGEELEMENTSPROC)glDrawRangeElements; staticPointerglColorTable = (MYPFNGLCOLORTABLEPROC)glColorTable; staticPointerglColorTableParameterfv = (MYPFNGLCOLORTABLEPARAMETERFVPROC)glColorTableParameterfv; staticPointerglColorTableParameteriv = (MYPFNGLCOLORTABLEPARAMETERIVPROC)glColorTableParameteriv; staticPointerglCopyColorTable = (MYPFNGLCOPYCOLORTABLEPROC)glCopyColorTable; staticPointerglGetColorTable = (MYPFNGLGETCOLORTABLEPROC)glGetColorTable; staticPointerglGetColorTableParameterfv = (MYPFNGLGETCOLORTABLEPARAMETERFVPROC)glGetColorTableParameterfv; staticPointerglGetColorTableParameteriv = (MYPFNGLGETCOLORTABLEPARAMETERIVPROC)glGetColorTableParameteriv; staticPointerglColorSubTable = (MYPFNGLCOLORSUBTABLEPROC)glColorSubTable; staticPointerglCopyColorSubTable = (MYPFNGLCOPYCOLORSUBTABLEPROC)glCopyColorSubTable; staticPointerglConvolutionFilter1D = (MYPFNGLCONVOLUTIONFILTER1DPROC)glConvolutionFilter1D; staticPointerglConvolutionFilter2D = (MYPFNGLCONVOLUTIONFILTER2DPROC)glConvolutionFilter2D; staticPointerglConvolutionParameterf = (MYPFNGLCONVOLUTIONPARAMETERFPROC)glConvolutionParameterf; staticPointerglConvolutionParameterfv = (MYPFNGLCONVOLUTIONPARAMETERFVPROC)glConvolutionParameterfv; staticPointerglConvolutionParameteri = (MYPFNGLCONVOLUTIONPARAMETERIPROC)glConvolutionParameteri; staticPointerglConvolutionParameteriv = (MYPFNGLCONVOLUTIONPARAMETERIVPROC)glConvolutionParameteriv; staticPointerglCopyConvolutionFilter1D = (MYPFNGLCOPYCONVOLUTIONFILTER1DPROC)glCopyConvolutionFilter1D; staticPointerglCopyConvolutionFilter2D = (MYPFNGLCOPYCONVOLUTIONFILTER2DPROC)glCopyConvolutionFilter2D; staticPointerglGetConvolutionFilter = (MYPFNGLGETCONVOLUTIONFILTERPROC)glGetConvolutionFilter; staticPointerglGetConvolutionParameterfv = (MYPFNGLGETCONVOLUTIONPARAMETERFVPROC)glGetConvolutionParameterfv; staticPointerglGetConvolutionParameteriv = (MYPFNGLGETCONVOLUTIONPARAMETERIVPROC)glGetConvolutionParameteriv; staticPointerglGetSeparableFilter = (MYPFNGLGETSEPARABLEFILTERPROC)glGetSeparableFilter; staticPointerglSeparableFilter2D = (MYPFNGLSEPARABLEFILTER2DPROC)glSeparableFilter2D; staticPointerglGetHistogram = (MYPFNGLGETHISTOGRAMPROC)glGetHistogram; staticPointerglGetHistogramParameterfv = (MYPFNGLGETHISTOGRAMPARAMETERFVPROC)glGetHistogramParameterfv; staticPointerglGetHistogramParameteriv = (MYPFNGLGETHISTOGRAMPARAMETERIVPROC)glGetHistogramParameteriv; staticPointerglGetMinmax = (MYPFNGLGETMINMAXPROC)glGetMinmax; staticPointerglGetMinmaxParameterfv = (MYPFNGLGETMINMAXPARAMETERFVPROC)glGetMinmaxParameterfv; staticPointerglGetMinmaxParameteriv = (MYPFNGLGETMINMAXPARAMETERIVPROC)glGetMinmaxParameteriv; staticPointerglHistogram = (MYPFNGLHISTOGRAMPROC)glHistogram; staticPointerglMinmax = (MYPFNGLMINMAXPROC)glMinmax; staticPointerglResetHistogram = (MYPFNGLRESETHISTOGRAMPROC)glResetHistogram; staticPointerglResetMinmax = (MYPFNGLRESETMINMAXPROC)glResetMinmax; staticPointerglTexImage3D = (MYPFNGLTEXIMAGE3DPROC)glTexImage3D; staticPointerglTexSubImage3D = (MYPFNGLTEXSUBIMAGE3DPROC)glTexSubImage3D; staticPointerglCopyTexSubImage3D = (MYPFNGLCOPYTEXSUBIMAGE3DPROC)glCopyTexSubImage3D; #else staticPointerglBlendColor = 0; staticPointerglBlendEquation = 0; staticPointerglDrawRangeElements = 0; staticPointerglColorTable = 0; staticPointerglColorTableParameterfv = 0; staticPointerglColorTableParameteriv = 0; staticPointerglCopyColorTable = 0; staticPointerglGetColorTable = 0; staticPointerglGetColorTableParameterfv = 0; staticPointerglGetColorTableParameteriv = 0; staticPointerglColorSubTable = 0; staticPointerglCopyColorSubTable = 0; staticPointerglConvolutionFilter1D = 0; staticPointerglConvolutionFilter2D = 0; staticPointerglConvolutionParameterf = 0; staticPointerglConvolutionParameterfv = 0; staticPointerglConvolutionParameteri = 0; staticPointerglConvolutionParameteriv = 0; staticPointerglCopyConvolutionFilter1D = 0; staticPointerglCopyConvolutionFilter2D = 0; staticPointerglGetConvolutionFilter = 0; staticPointerglGetConvolutionParameterfv = 0; staticPointerglGetConvolutionParameteriv = 0; staticPointerglGetSeparableFilter = 0; staticPointerglSeparableFilter2D = 0; staticPointerglGetHistogram = 0; staticPointerglGetHistogramParameterfv = 0; staticPointerglGetHistogramParameteriv = 0; staticPointerglGetMinmax = 0; staticPointerglGetMinmaxParameterfv = 0; staticPointerglGetMinmaxParameteriv = 0; staticPointerglHistogram = 0; staticPointerglMinmax = 0; staticPointerglResetHistogram = 0; staticPointerglResetMinmax = 0; staticPointerglTexImage3D = 0; staticPointerglTexSubImage3D = 0; staticPointerglCopyTexSubImage3D = 0; #endif // End OpenGL version 1.2 #if defined(GL_VERSION_1_3) && GL_VERSION_1_3 staticPointerglActiveTexture = (MYPFNGLACTIVETEXTUREPROC) glActiveTexture; staticPointerglClientActiveTexture = (MYPFNGLCLIENTACTIVETEXTUREPROC) glClientActiveTexture; staticPointerglMultiTexCoord1d = (MYPFNGLMULTITEXCOORD1DPROC) glMultiTexCoord1d; staticPointerglMultiTexCoord1dv = (MYPFNGLMULTITEXCOORD1DVPROC) glMultiTexCoord1dv; staticPointerglMultiTexCoord1f = (MYPFNGLMULTITEXCOORD1FPROC) glMultiTexCoord1f; staticPointerglMultiTexCoord1fv = (MYPFNGLMULTITEXCOORD1FVPROC) glMultiTexCoord1fv; staticPointerglMultiTexCoord1i = (MYPFNGLMULTITEXCOORD1IPROC) glMultiTexCoord1i; staticPointerglMultiTexCoord1iv = (MYPFNGLMULTITEXCOORD1IVPROC) glMultiTexCoord1iv; staticPointerglMultiTexCoord1s = (MYPFNGLMULTITEXCOORD1SPROC) glMultiTexCoord1s; staticPointerglMultiTexCoord1sv = (MYPFNGLMULTITEXCOORD1SVPROC) glMultiTexCoord1sv; staticPointerglMultiTexCoord2d = (MYPFNGLMULTITEXCOORD2DPROC) glMultiTexCoord2d; staticPointerglMultiTexCoord2dv = (MYPFNGLMULTITEXCOORD2DVPROC) glMultiTexCoord2dv; staticPointerglMultiTexCoord2f = (MYPFNGLMULTITEXCOORD2FPROC) glMultiTexCoord2f; staticPointerglMultiTexCoord2fv = (MYPFNGLMULTITEXCOORD2FVPROC) glMultiTexCoord2fv; staticPointerglMultiTexCoord2i = (MYPFNGLMULTITEXCOORD2IPROC) glMultiTexCoord2i; staticPointerglMultiTexCoord2iv = (MYPFNGLMULTITEXCOORD2IVPROC) glMultiTexCoord2iv; staticPointerglMultiTexCoord2s = (MYPFNGLMULTITEXCOORD2SPROC) glMultiTexCoord2s; staticPointerglMultiTexCoord2sv = (MYPFNGLMULTITEXCOORD2SVPROC) glMultiTexCoord2sv; staticPointerglMultiTexCoord3d = (MYPFNGLMULTITEXCOORD3DPROC) glMultiTexCoord3d; staticPointerglMultiTexCoord3dv = (MYPFNGLMULTITEXCOORD3DVPROC) glMultiTexCoord3dv; staticPointerglMultiTexCoord3f = (MYPFNGLMULTITEXCOORD3FPROC) glMultiTexCoord3f; staticPointerglMultiTexCoord3fv = (MYPFNGLMULTITEXCOORD3FVPROC) glMultiTexCoord3fv; staticPointerglMultiTexCoord3i = (MYPFNGLMULTITEXCOORD3IPROC) glMultiTexCoord3i; staticPointerglMultiTexCoord3iv = (MYPFNGLMULTITEXCOORD3IVPROC) glMultiTexCoord3iv; staticPointerglMultiTexCoord3s = (MYPFNGLMULTITEXCOORD3SPROC) glMultiTexCoord3s; staticPointerglMultiTexCoord3sv = (MYPFNGLMULTITEXCOORD3SVPROC) glMultiTexCoord3sv; staticPointerglMultiTexCoord4d = (MYPFNGLMULTITEXCOORD4DPROC) glMultiTexCoord4d; staticPointerglMultiTexCoord4dv = (MYPFNGLMULTITEXCOORD4DVPROC) glMultiTexCoord4dv; staticPointerglMultiTexCoord4f = (MYPFNGLMULTITEXCOORD4FPROC) glMultiTexCoord4f; staticPointerglMultiTexCoord4fv = (MYPFNGLMULTITEXCOORD4FVPROC) glMultiTexCoord4fv; staticPointerglMultiTexCoord4i = (MYPFNGLMULTITEXCOORD4IPROC) glMultiTexCoord4i; staticPointerglMultiTexCoord4iv = (MYPFNGLMULTITEXCOORD4IVPROC) glMultiTexCoord4iv; staticPointerglMultiTexCoord4s = (MYPFNGLMULTITEXCOORD4SPROC) glMultiTexCoord4s; staticPointerglMultiTexCoord4sv = (MYPFNGLMULTITEXCOORD4SVPROC) glMultiTexCoord4sv; staticPointerglLoadTransposeMatrixf = (MYPFNGLLOADTRANSPOSEMATRIXFPROC) glLoadTransposeMatrixf; staticPointerglLoadTransposeMatrixd = (MYPFNGLLOADTRANSPOSEMATRIXDPROC) glLoadTransposeMatrixd; staticPointerglMultTransposeMatrixf = (MYPFNGLMULTTRANSPOSEMATRIXFPROC) glMultTransposeMatrixf; staticPointerglMultTransposeMatrixd = (MYPFNGLMULTTRANSPOSEMATRIXDPROC) glMultTransposeMatrixd; staticPointerglSampleCoverage = (MYPFNGLSAMPLECOVERAGEPROC) glSampleCoverage; staticPointerglCompressedTexImage3D = (MYPFNGLCOMPRESSEDTEXIMAGE3DPROC) glCompressedTexImage3D; staticPointerglCompressedTexImage2D = (MYPFNGLCOMPRESSEDTEXIMAGE2DPROC) glCompressedTexImage2D; staticPointerglCompressedTexImage1D = (MYPFNGLCOMPRESSEDTEXIMAGE1DPROC) glCompressedTexImage1D; staticPointerglCompressedTexSubImage3D = (MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) glCompressedTexSubImage3D; staticPointerglCompressedTexSubImage2D = (MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) glCompressedTexSubImage2D; staticPointerglCompressedTexSubImage1D = (MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) glCompressedTexSubImage1D; staticPointerglGetCompressedTexImage = (MYPFNGLGETCOMPRESSEDTEXIMAGEPROC) glGetCompressedTexImage; #else staticPointerglActiveTexture = 0; staticPointerglClientActiveTexture = 0; staticPointerglMultiTexCoord1d = 0; staticPointerglMultiTexCoord1dv = 0; staticPointerglMultiTexCoord1f = 0; staticPointerglMultiTexCoord1fv = 0; staticPointerglMultiTexCoord1i = 0; staticPointerglMultiTexCoord1iv = 0; staticPointerglMultiTexCoord1s = 0; staticPointerglMultiTexCoord1sv = 0; staticPointerglMultiTexCoord2d = 0; staticPointerglMultiTexCoord2dv = 0; staticPointerglMultiTexCoord2f = 0; staticPointerglMultiTexCoord2fv = 0; staticPointerglMultiTexCoord2i = 0; staticPointerglMultiTexCoord2iv = 0; staticPointerglMultiTexCoord2s = 0; staticPointerglMultiTexCoord2sv = 0; staticPointerglMultiTexCoord3d = 0; staticPointerglMultiTexCoord3dv = 0; staticPointerglMultiTexCoord3f = 0; staticPointerglMultiTexCoord3fv = 0; staticPointerglMultiTexCoord3i = 0; staticPointerglMultiTexCoord3iv = 0; staticPointerglMultiTexCoord3s = 0; staticPointerglMultiTexCoord3sv = 0; staticPointerglMultiTexCoord4d = 0; staticPointerglMultiTexCoord4dv = 0; staticPointerglMultiTexCoord4f = 0; staticPointerglMultiTexCoord4fv = 0; staticPointerglMultiTexCoord4i = 0; staticPointerglMultiTexCoord4iv = 0; staticPointerglMultiTexCoord4s = 0; staticPointerglMultiTexCoord4sv = 0; staticPointerglLoadTransposeMatrixf = 0; staticPointerglLoadTransposeMatrixd = 0; staticPointerglMultTransposeMatrixf = 0; staticPointerglMultTransposeMatrixd = 0; staticPointerglSampleCoverage = 0; staticPointerglCompressedTexImage3D = 0; staticPointerglCompressedTexImage2D = 0; staticPointerglCompressedTexImage1D = 0; staticPointerglCompressedTexSubImage3D = 0; staticPointerglCompressedTexSubImage2D = 0; staticPointerglCompressedTexSubImage1D = 0; staticPointerglGetCompressedTexImage = 0; #endif // End OpenGL version 1.3 #if defined(GL_VERSION_1_4) && GL_VERSION_1_4 staticPointerglBlendFuncSeparate = (MYPFNGLBLENDFUNCSEPARATEPROC) glBlendFuncSeparate; staticPointerglFogCoordf = (MYPFNGLFOGCOORDFPROC) glFogCoordf; staticPointerglFogCoordfv = (MYPFNGLFOGCOORDFVPROC) glFogCoordfv; staticPointerglFogCoordd = (MYPFNGLFOGCOORDDPROC) glFogCoordd; staticPointerglFogCoorddv = (MYPFNGLFOGCOORDDVPROC) glFogCoorddv; staticPointerglFogCoordPointer = (MYPFNGLFOGCOORDPOINTERPROC) glFogCoordPointer; staticPointerglMultiDrawArrays = (MYPFNGLMULTIDRAWARRAYSPROC) glMultiDrawArrays; staticPointerglMultiDrawElements = (MYPFNGLMULTIDRAWELEMENTSPROC) glMultiDrawElements; staticPointerglPointParameterf = (MYPFNGLPOINTPARAMETERFPROC) glPointParameterf; staticPointerglPointParameterfv = (MYPFNGLPOINTPARAMETERFVPROC) glPointParameterfv; staticPointerglPointParameteri = (MYPFNGLPOINTPARAMETERIPROC) glPointParameteri; staticPointerglPointParameteriv = (MYPFNGLPOINTPARAMETERIVPROC) glPointParameteriv; staticPointerglSecondaryColor3b = (MYPFNGLSECONDARYCOLOR3BPROC) glSecondaryColor3b; staticPointerglSecondaryColor3bv = (MYPFNGLSECONDARYCOLOR3BVPROC) glSecondaryColor3bv; staticPointerglSecondaryColor3d = (MYPFNGLSECONDARYCOLOR3DPROC) glSecondaryColor3d; staticPointerglSecondaryColor3dv = (MYPFNGLSECONDARYCOLOR3DVPROC) glSecondaryColor3dv; staticPointerglSecondaryColor3f = (MYPFNGLSECONDARYCOLOR3FPROC) glSecondaryColor3f; staticPointerglSecondaryColor3fv = (MYPFNGLSECONDARYCOLOR3FVPROC) glSecondaryColor3fv; staticPointerglSecondaryColor3i = (MYPFNGLSECONDARYCOLOR3IPROC) glSecondaryColor3i; staticPointerglSecondaryColor3iv = (MYPFNGLSECONDARYCOLOR3IVPROC) glSecondaryColor3iv; staticPointerglSecondaryColor3s = (MYPFNGLSECONDARYCOLOR3SPROC) glSecondaryColor3s; staticPointerglSecondaryColor3sv = (MYPFNGLSECONDARYCOLOR3SVPROC) glSecondaryColor3sv; staticPointerglSecondaryColor3ub = (MYPFNGLSECONDARYCOLOR3UBPROC) glSecondaryColor3ub; staticPointerglSecondaryColor3ubv = (MYPFNGLSECONDARYCOLOR3UBVPROC) glSecondaryColor3ubv; staticPointerglSecondaryColor3ui = (MYPFNGLSECONDARYCOLOR3UIPROC) glSecondaryColor3ui; staticPointerglSecondaryColor3uiv = (MYPFNGLSECONDARYCOLOR3UIVPROC) glSecondaryColor3uiv; staticPointerglSecondaryColor3us = (MYPFNGLSECONDARYCOLOR3USPROC) glSecondaryColor3us; staticPointerglSecondaryColor3usv = (MYPFNGLSECONDARYCOLOR3USVPROC) glSecondaryColor3usv; staticPointerglSecondaryColorPointer = (MYPFNGLSECONDARYCOLORPOINTERPROC) glSecondaryColorPointer; staticPointerglWindowPos2d = (MYPFNGLWINDOWPOS2DPROC) glWindowPos2d; staticPointerglWindowPos2dv = (MYPFNGLWINDOWPOS2DVPROC) glWindowPos2dv; staticPointerglWindowPos2f = (MYPFNGLWINDOWPOS2FPROC) glWindowPos2f; staticPointerglWindowPos2fv = (MYPFNGLWINDOWPOS2FVPROC) glWindowPos2fv; staticPointerglWindowPos2i = (MYPFNGLWINDOWPOS2IPROC) glWindowPos2i; staticPointerglWindowPos2iv = (MYPFNGLWINDOWPOS2IVPROC) glWindowPos2iv; staticPointerglWindowPos2s = (MYPFNGLWINDOWPOS2SPROC) glWindowPos2s; staticPointerglWindowPos2sv = (MYPFNGLWINDOWPOS2SVPROC) glWindowPos2sv; staticPointerglWindowPos3d = (MYPFNGLWINDOWPOS3DPROC) glWindowPos3d; staticPointerglWindowPos3dv = (MYPFNGLWINDOWPOS3DVPROC) glWindowPos3dv; staticPointerglWindowPos3f = (MYPFNGLWINDOWPOS3FPROC) glWindowPos3f; staticPointerglWindowPos3fv = (MYPFNGLWINDOWPOS3FVPROC) glWindowPos3fv; staticPointerglWindowPos3i = (MYPFNGLWINDOWPOS3IPROC) glWindowPos3i; staticPointerglWindowPos3iv = (MYPFNGLWINDOWPOS3IVPROC) glWindowPos3iv; staticPointerglWindowPos3s = (MYPFNGLWINDOWPOS3SPROC) glWindowPos3s; staticPointerglWindowPos3sv = (MYPFNGLWINDOWPOS3SVPROC) glWindowPos3sv; #else staticPointerglBlendFuncSeparate = 0; staticPointerglFogCoordf = 0; staticPointerglFogCoordfv = 0; staticPointerglFogCoordd = 0; staticPointerglFogCoorddv = 0; staticPointerglFogCoordPointer = 0; staticPointerglMultiDrawArrays = 0; staticPointerglMultiDrawElements = 0; staticPointerglPointParameterf = 0; staticPointerglPointParameterfv = 0; staticPointerglPointParameteri = 0; staticPointerglPointParameteriv = 0; staticPointerglSecondaryColor3b = 0; staticPointerglSecondaryColor3bv = 0; staticPointerglSecondaryColor3d = 0; staticPointerglSecondaryColor3dv = 0; staticPointerglSecondaryColor3f = 0; staticPointerglSecondaryColor3fv = 0; staticPointerglSecondaryColor3i = 0; staticPointerglSecondaryColor3iv = 0; staticPointerglSecondaryColor3s = 0; staticPointerglSecondaryColor3sv = 0; staticPointerglSecondaryColor3ub = 0; staticPointerglSecondaryColor3ubv = 0; staticPointerglSecondaryColor3ui = 0; staticPointerglSecondaryColor3uiv = 0; staticPointerglSecondaryColor3us = 0; staticPointerglSecondaryColor3usv = 0; staticPointerglSecondaryColorPointer = 0; staticPointerglWindowPos2d = 0; staticPointerglWindowPos2dv = 0; staticPointerglWindowPos2f = 0; staticPointerglWindowPos2fv = 0; staticPointerglWindowPos2i = 0; staticPointerglWindowPos2iv = 0; staticPointerglWindowPos2s = 0; staticPointerglWindowPos2sv = 0; staticPointerglWindowPos3d = 0; staticPointerglWindowPos3dv = 0; staticPointerglWindowPos3f = 0; staticPointerglWindowPos3fv = 0; staticPointerglWindowPos3i = 0; staticPointerglWindowPos3iv = 0; staticPointerglWindowPos3s = 0; staticPointerglWindowPos3sv = 0; #endif // End OpenGL version 1.4 #if defined(GL_VERSION_1_5) && GL_VERSION_1_5 staticPointerglGenQueries = (MYPFNGLGENQUERIESPROC) glGenQueries; staticPointerglDeleteQueries = (MYPFNGLDELETEQUERIESPROC) glDeleteQueries; staticPointerglIsQuery = (MYPFNGLISQUERYPROC) glIsQuery; staticPointerglBeginQuery = (MYPFNGLBEGINQUERYPROC) glBeginQuery; staticPointerglEndQuery = (MYPFNGLENDQUERYPROC) glEndQuery; staticPointerglGetQuery = (MYPFNGLGETQUERYIVPROC) glGetQueryiv; staticPointerglGetQueryObjectiv = (MYPFNGLGETQUERYOBJECTIVPROC) glGetQueryObjectiv; staticPointerglGetQueryObjecyuiv = (MYPFNGLGETQUERYOBJECTUIVPROC) glGetQueryObjectuiv; staticPointerglBindBuffer = (MYPFNGLBINDBUFFERPROC) glBindBuffer; staticPointerglDeleteBuffers = (MYPFNGLDELETEBUFFERSPROC) glDeleteBuffers; staticPointerglGenBuffers = (MYPFNGLGENBUFFERSPROC) glGenBuffers; staticPointerglIsBuffer = (MYPFNGLISBUFFERPROC) glIsBuffer; staticPointerglBufferData = (MYPFNGLBUFFERDATAPROC) glBufferData; staticPointerglBufferSubData = (MYPFNGLBUFFERSUBDATAPROC) glBufferSubData; staticPointerglGetBufferSubData = (MYPFNGLGETBUFFERSUBDATAPROC) glGetBufferSubData; staticPointerglMapBuffer = (MYPFNGLMAPBUFFERPROC) glMapBuffer; staticPointerglUnmapBuffer = (MYPFNGLUNMAPBUFFERPROC) glUnmapBuffer; staticPointerglGetBufferParameteriv = (MYPFNGLGETBUFFERPARAMETERIVPROC) glGetBufferParameteriv; staticPointerglGetBufferPointerv = (MYPFNGLGETBUFFERPOINTERVPROC) glGetBufferPointerv; #else staticPointerglGenQueries = 0; staticPointerglDeleteQueries = 0; staticPointerglIsQuery = 0; staticPointerglBeginQuery = 0; staticPointerglEndQuery = 0; staticPointerglGetQueryiv = 0; staticPointerglGetQueryObjectiv = 0; staticPointerglGetQueryObjectuiv = 0; staticPointerglBindBuffer = 0; staticPointerglDeleteBuffers = 0; staticPointerglGenBuffers = 0; staticPointerglIsBuffer = 0; staticPointerglBufferData = 0; staticPointerglBufferSubData = 0; staticPointerglGetBufferSubData = 0; staticPointerglMapBuffer = 0; staticPointerglUnmapBuffer = 0; staticPointerglGetBufferParameteriv = 0; staticPointerglGetBufferPointerv = 0; #endif // End OpenGL version 1.5 #if defined(GL_VERSION_2_0) && GL_VERSION_2_0 staticPointerglBlendEquationSeparate = (MYPFNGLBLENDEQUATIONSEPARATEPROC) glBlendEquationSeparate; staticPointerglDrawBuffers = (MYPFNGLDRAWBUFFERSPROC) glDrawBuffers; staticPointerglStencilOpSeparate = (MYPFNGLSTENCILOPSEPARATEPROC) glStencilOpSeparate; staticPointerglStencilFuncSeparate = (MYPFNGLSTENCILFUNCSEPARATEPROC) glStencilFuncSeparate; staticPointerglStencilMaskSeparate = (MYPFNGLSTENCILMASKSEPARATEPROC) glStencilMaskSeparate; staticPointerglAttachShader = (MYPFNGLATTACHSHADERPROC) glAttachShader; staticPointerglBindAttribLocation = (MYPFNGLBINDATTRIBLOCATIONPROC) glBindAttribLocation; staticPointerglCompileShader = (MYPFNGLCOMPILESHADERPROC) glCompileShader; staticPointerglCreateProgram = (MYPFNGLCREATEPROGRAMPROC) glCreateProgram; staticPointerglCreateShader = (MYPFNGLCREATESHADERPROC) glCreateShader; staticPointerglDeleteProgram = (MYPFNGLDELETEPROGRAMPROC) glDeleteProgram; staticPointerglDeleteShader = (MYPFNGLDELETESHADERPROC) glDeleteShader; staticPointerglDetachShader = (MYPFNGLDETACHSHADERPROC) glDetachShader; staticPointerglDisableVertexAttribArray = (MYPFNGLDISABLEVERTEXATTRIBARRAYPROC) glDisableVertexAttribArray; staticPointerglEnableVertexAttribArray = (MYPFNGLENABLEVERTEXATTRIBARRAYPROC) glEnableVertexAttribArray; staticPointerglGetActiveAttrib = (MYPFNGLGETACTIVEATTRIBPROC) glGetActiveAttrib; staticPointerglGetActiveUniform = (MYPFNGLGETACTIVEUNIFORMPROC) glGetActiveUniform; staticPointerglGetAttachedShaders = (MYPFNGLGETATTACHEDSHADERSPROC) glGetAttachedShaders; staticPointerglGetAttribLocation = (MYPFNGLGETATTRIBLOCATIONPROC) glGetAttribLocation; staticPointerglGetProgramiv = (MYPFNGLGETPROGRAMIVPROC) glGetProgramiv; staticPointerglGetProgramInfoLog = (MYPFNGLGETPROGRAMINFOLOGPROC) glGetProgramInfoLog; staticPointerglGetShaderiv = (MYPFNGLGETSHADERIVPROC) glGetShaderiv; staticPointerglGetShaderInfoLog = (MYPFNGLGETSHADERINFOLOGPROC) glGetShaderInfoLog; staticPointerglGetShaderSource = (MYPFNGLGETSHADERSOURCEPROC) glGetShaderSource; staticPointerglGetUniformLocation = (MYPFNGLGETUNIFORMLOCATIONPROC) glGetUniformLocation; staticPointerglGetUniformfv = (MYPFNGLGETUNIFORMFVPROC) glGetUniformfv; staticPointerglGetUniformiv = (MYPFNGLGETUNIFORMIVPROC) glGetUniformiv; staticPointerglGetVertexAttribdv = (MYPFNGLGETVERTEXATTRIBDVPROC) glGetVertexAttribdv; staticPointerglGetVertexAttribfv = (MYPFNGLGETVERTEXATTRIBFVPROC) glGetVertexAttribfv; staticPointerglGetVertexAttribiv = (MYPFNGLGETVERTEXATTRIBIVPROC) glGetVertexAttribiv; staticPointerglGetVertexAttribPointerv = (MYPFNGLGETVERTEXATTRIBPOINTERVPROC) glGetVertexAttribPointerv; staticPointerglIsProgram = (MYPFNGLISPROGRAMPROC) glIsProgram; staticPointerglIsShader = (MYPFNGLISSHADERPROC) glIsShader; staticPointerglLinkProgram = (MYPFNGLLINKPROGRAMPROC) glLinkProgram; staticPointerglShaderSource = (MYPFNGLSHADERSOURCEPROC) glShaderSource; staticPointerglUseProgram = (MYPFNGLUSEPROGRAMPROC) glUseProgram; staticPointerglUniform1f = (MYPFNGLUNIFORM1FPROC) glUniform1f; staticPointerglUniform2f = (MYPFNGLUNIFORM2FPROC) glUniform2f; staticPointerglUniform3f = (MYPFNGLUNIFORM3FPROC) glUniform3f; staticPointerglUniform4f = (MYPFNGLUNIFORM4FPROC) glUniform4f; staticPointerglUniform1i = (MYPFNGLUNIFORM1IPROC) glUniform1i; staticPointerglUniform2i = (MYPFNGLUNIFORM2IPROC) glUniform2i; staticPointerglUniform3i = (MYPFNGLUNIFORM3IPROC) glUniform3i; staticPointerglUniform4i = (MYPFNGLUNIFORM4IPROC) glUniform4i; staticPointerglUniform1fv = (MYPFNGLUNIFORM1FVPROC) glUniform1fv; staticPointerglUniform2fv = (MYPFNGLUNIFORM2FVPROC) glUniform2fv; staticPointerglUniform3fv = (MYPFNGLUNIFORM3FVPROC) glUniform3fv; staticPointerglUniform4fv = (MYPFNGLUNIFORM4FVPROC) glUniform4fv; staticPointerglUniform1iv = (MYPFNGLUNIFORM1IVPROC) glUniform1iv; staticPointerglUniform2iv = (MYPFNGLUNIFORM2IVPROC) glUniform2iv; staticPointerglUniform3iv = (MYPFNGLUNIFORM3IVPROC) glUniform3iv; staticPointerglUniform4iv = (MYPFNGLUNIFORM4IVPROC) glUniform4iv; staticPointerglUniformMatrix2fv = (MYPFNGLUNIFORMMATRIX2FVPROC) glUniformMatrix2fv; staticPointerglUniformMatrix3fv = (MYPFNGLUNIFORMMATRIX3FVPROC) glUniformMatrix3fv; staticPointerglUniformMatrix4fv = (MYPFNGLUNIFORMMATRIX4FVPROC) glUniformMatrix4fv; staticPointerglValidateProgram = (MYPFNGLVALIDATEPROGRAMPROC) glValidateProgram; staticPointerglVertexAttrib1d = (MYPFNGLVERTEXATTRIB1DPROC) glVertexAttrib1d; staticPointerglVertexAttrib1dv = (MYPFNGLVERTEXATTRIB1DVPROC) glVertexAttrib1dv; staticPointerglVertexAttrib1f = (MYPFNGLVERTEXATTRIB1FPROC) glVertexAttrib1f; staticPointerglVertexAttrib1fv = (MYPFNGLVERTEXATTRIB1FVPROC) glVertexAttrib1fv; staticPointerglVertexAttrib1s = (MYPFNGLVERTEXATTRIB1SPROC) glVertexAttrib1s; staticPointerglVertexAttrib1sv = (MYPFNGLVERTEXATTRIB1SVPROC) glVertexAttrib1sv; staticPointerglVertexAttrib2d = (MYPFNGLVERTEXATTRIB2DPROC) glVertexAttrib2d; staticPointerglVertexAttrib2dv = (MYPFNGLVERTEXATTRIB2DVPROC) glVertexAttrib2dv; staticPointerglVertexAttrib2f = (MYPFNGLVERTEXATTRIB2FPROC) glVertexAttrib2f; staticPointerglVertexAttrib2fv = (MYPFNGLVERTEXATTRIB2FVPROC) glVertexAttrib2fv; staticPointerglVertexAttrib2s = (MYPFNGLVERTEXATTRIB2SPROC) glVertexAttrib2s; staticPointerglVertexAttrib2sv = (MYPFNGLVERTEXATTRIB2SVPROC) glVertexAttrib2sv; staticPointerglVertexAttrib3d = (MYPFNGLVERTEXATTRIB3DPROC) glVertexAttrib3d; staticPointerglVertexAttrib3dv = (MYPFNGLVERTEXATTRIB3DVPROC) glVertexAttrib3dv; staticPointerglVertexAttrib3f = (MYPFNGLVERTEXATTRIB3FPROC) glVertexAttrib3f; staticPointerglVertexAttrib3fv = (MYPFNGLVERTEXATTRIB3FVPROC) glVertexAttrib3fv; staticPointerglVertexAttrib3s = (MYPFNGLVERTEXATTRIB3SPROC) glVertexAttrib3s; staticPointerglVertexAttrib3sv = (MYPFNGLVERTEXATTRIB3SVPROC) glVertexAttrib3sv; staticPointerglVertexAttrib4Nbv = (MYPFNGLVERTEXATTRIB4NBVPROC) glVertexAttrib4Nbv; staticPointerglVertexAttrib4Niv = (MYPFNGLVERTEXATTRIB4NIVPROC) glVertexAttrib4Niv; staticPointerglVertexAttrib4Nsv = (MYPFNGLVERTEXATTRIB4NSVPROC) glVertexAttrib4Nsv; staticPointerglVertexAttrib4Nub = (MYPFNGLVERTEXATTRIB4NUBPROC) glVertexAttrib4Nub; staticPointerglVertexAttrib4Nubv = (MYPFNGLVERTEXATTRIB4NUBVPROC) glVertexAttrib4Nubv; staticPointerglVertexAttrib4Nuiv = (MYPFNGLVERTEXATTRIB4NUIVPROC) glVertexAttrib4Nuiv; staticPointerglVertexAttrib4Nusv = (MYPFNGLVERTEXATTRIB4NUSVPROC) glVertexAttrib4Nusv; staticPointerglVertexAttrib4bv = (MYPFNGLVERTEXATTRIB4BVPROC) glVertexAttrib4bv; staticPointerglVertexAttrib4d = (MYPFNGLVERTEXATTRIB4DPROC) glVertexAttrib4d; staticPointerglVertexAttrib4dv = (MYPFNGLVERTEXATTRIB4DVPROC) glVertexAttrib4dv; staticPointerglVertexAttrib4f = (MYPFNGLVERTEXATTRIB4FPROC) glVertexAttrib4f; staticPointerglVertexAttrib4fv = (MYPFNGLVERTEXATTRIB4FVPROC) glVertexAttrib4fv; staticPointerglVertexAttrib4iv = (MYPFNGLVERTEXATTRIB4IVPROC) glVertexAttrib4iv; staticPointerglVertexAttrib4s = (MYPFNGLVERTEXATTRIB4SPROC) glVertexAttrib4s; staticPointerglVertexAttrib4sv = (MYPFNGLVERTEXATTRIB4SVPROC) glVertexAttrib4sv; staticPointerglVertexAttrib4ubv = (MYPFNGLVERTEXATTRIB4UBVPROC) glVertexAttrib4ubv; staticPointerglVertexAttrib4uiv = (MYPFNGLVERTEXATTRIB4UIVPROC) glVertexAttrib4uiv; staticPointerglVertexAttrib4usv = (MYPFNGLVERTEXATTRIB4USVPROC) glVertexAttrib4usv; staticPointerglVertexAttribPointer = (MYPFNGLVERTEXATTRIBPOINTERPROC) glVertexAttribPointer; #else staticPointerglBlendEquationSeparate = (MYPFNGLBLENDEQUATIONSEPARATEPROC) 0; staticPointerglDrawBuffers = (MYPFNGLDRAWBUFFERSPROC) 0; staticPointerglStencilOpSeparate = (MYPFNGLSTENCILOPSEPARATEPROC) 0; staticPointerglStencilFuncSeparate = (MYPFNGLSTENCILFUNCSEPARATEPROC) 0; staticPointerglStencilMaskSeparate = (MYPFNGLSTENCILMASKSEPARATEPROC) 0; staticPointerglAttachShader = (MYPFNGLATTACHSHADERPROC) 0; staticPointerglBindAttribLocation = (MYPFNGLBINDATTRIBLOCATIONPROC) 0; staticPointerglCompileShader = (MYPFNGLCOMPILESHADERPROC) 0; staticPointerglCreateProgram = (MYPFNGLCREATEPROGRAMPROC) 0; staticPointerglCreateShader = (MYPFNGLCREATESHADERPROC) 0; staticPointerglDeleteProgram = (MYPFNGLDELETEPROGRAMPROC) 0; staticPointerglDeleteShader = (MYPFNGLDELETESHADERPROC) 0; staticPointerglDetachShader = (MYPFNGLDETACHSHADERPROC) 0; staticPointerglDisableVertexAttribArray = (MYPFNGLDISABLEVERTEXATTRIBARRAYPROC) 0; staticPointerglEnableVertexAttribArray = (MYPFNGLENABLEVERTEXATTRIBARRAYPROC) 0; staticPointerglGetActiveAttrib = (MYPFNGLGETACTIVEATTRIBPROC) 0; staticPointerglGetActiveUniform = (MYPFNGLGETACTIVEUNIFORMPROC) 0; staticPointerglGetAttachedShaders = (MYPFNGLGETATTACHEDSHADERSPROC) 0; staticPointerglGetAttribLocation = (MYPFNGLGETATTRIBLOCATIONPROC) 0; staticPointerglGetProgramiv = (MYPFNGLGETPROGRAMIVPROC) 0; staticPointerglGetProgramInfoLog = (MYPFNGLGETPROGRAMINFOLOGPROC) 0; staticPointerglGetShaderiv = (MYPFNGLGETSHADERIVPROC) 0; staticPointerglGetShaderInfoLog = (MYPFNGLGETSHADERINFOLOGPROC) 0; staticPointerglGetShaderSource = (MYPFNGLGETSHADERSOURCEPROC) 0; staticPointerglGetUniformLocation = (MYPFNGLGETUNIFORMLOCATIONPROC) 0; staticPointerglGetUniformfv = (MYPFNGLGETUNIFORMFVPROC) 0; staticPointerglGetUniformiv = (MYPFNGLGETUNIFORMIVPROC) 0; staticPointerglGetVertexAttribdv = (MYPFNGLGETVERTEXATTRIBDVPROC) 0; staticPointerglGetVertexAttribfv = (MYPFNGLGETVERTEXATTRIBFVPROC) 0; staticPointerglGetVertexAttribiv = (MYPFNGLGETVERTEXATTRIBIVPROC) 0; staticPointerglGetVertexAttribPointerv = (MYPFNGLGETVERTEXATTRIBPOINTERVPROC) 0; staticPointerglIsProgram = (MYPFNGLISPROGRAMPROC) 0; staticPointerglIsShader = (MYPFNGLISSHADERPROC) 0; staticPointerglLinkProgram = (MYPFNGLLINKPROGRAMPROC) 0; staticPointerglShaderSource = (MYPFNGLSHADERSOURCEPROC) 0; staticPointerglUseProgram = (MYPFNGLUSEPROGRAMPROC) 0; staticPointerglUniform1f = (MYPFNGLUNIFORM1FPROC) 0; staticPointerglUniform2f = (MYPFNGLUNIFORM2FPROC) 0; staticPointerglUniform3f = (MYPFNGLUNIFORM3FPROC) 0; staticPointerglUniform4f = (MYPFNGLUNIFORM4FPROC) 0; staticPointerglUniform1i = (MYPFNGLUNIFORM1IPROC) 0; staticPointerglUniform2i = (MYPFNGLUNIFORM2IPROC) 0; staticPointerglUniform3i = (MYPFNGLUNIFORM3IPROC) 0; staticPointerglUniform4i = (MYPFNGLUNIFORM4IPROC) 0; staticPointerglUniform1fv = (MYPFNGLUNIFORM1FVPROC) 0; staticPointerglUniform2fv = (MYPFNGLUNIFORM2FVPROC) 0; staticPointerglUniform3fv = (MYPFNGLUNIFORM3FVPROC) 0; staticPointerglUniform4fv = (MYPFNGLUNIFORM4FVPROC) 0; staticPointerglUniform1iv = (MYPFNGLUNIFORM1IVPROC) 0; staticPointerglUniform2iv = (MYPFNGLUNIFORM2IVPROC) 0; staticPointerglUniform3iv = (MYPFNGLUNIFORM3IVPROC) 0; staticPointerglUniform4iv = (MYPFNGLUNIFORM4IVPROC) 0; staticPointerglUniformMatrix2fv = (MYPFNGLUNIFORMMATRIX2FVPROC) 0; staticPointerglUniformMatrix3fv = (MYPFNGLUNIFORMMATRIX3FVPROC) 0; staticPointerglUniformMatrix4fv = (MYPFNGLUNIFORMMATRIX4FVPROC) 0; staticPointerglValidateProgram = (MYPFNGLVALIDATEPROGRAMPROC) 0; staticPointerglVertexAttrib1d = (MYPFNGLVERTEXATTRIB1DPROC) 0; staticPointerglVertexAttrib1dv = (MYPFNGLVERTEXATTRIB1DVPROC) 0; staticPointerglVertexAttrib1f = (MYPFNGLVERTEXATTRIB1FPROC) 0; staticPointerglVertexAttrib1fv = (MYPFNGLVERTEXATTRIB1FVPROC) 0; staticPointerglVertexAttrib1s = (MYPFNGLVERTEXATTRIB1SPROC) 0; staticPointerglVertexAttrib1sv = (MYPFNGLVERTEXATTRIB1SVPROC) 0; staticPointerglVertexAttrib2d = (MYPFNGLVERTEXATTRIB2DPROC) 0; staticPointerglVertexAttrib2dv = (MYPFNGLVERTEXATTRIB2DVPROC) 0; staticPointerglVertexAttrib2f = (MYPFNGLVERTEXATTRIB2FPROC) 0; staticPointerglVertexAttrib2fv = (MYPFNGLVERTEXATTRIB2FVPROC) 0; staticPointerglVertexAttrib2s = (MYPFNGLVERTEXATTRIB2SPROC) 0; staticPointerglVertexAttrib2sv = (MYPFNGLVERTEXATTRIB2SVPROC) 0; staticPointerglVertexAttrib3d = (MYPFNGLVERTEXATTRIB3DPROC) 0; staticPointerglVertexAttrib3dv = (MYPFNGLVERTEXATTRIB3DVPROC) 0; staticPointerglVertexAttrib3f = (MYPFNGLVERTEXATTRIB3FPROC) 0; staticPointerglVertexAttrib3fv = (MYPFNGLVERTEXATTRIB3FVPROC) 0; staticPointerglVertexAttrib3s = (MYPFNGLVERTEXATTRIB3SPROC) 0; staticPointerglVertexAttrib3sv = (MYPFNGLVERTEXATTRIB3SVPROC) 0; staticPointerglVertexAttrib4Nbv = (MYPFNGLVERTEXATTRIB4NBVPROC) 0; staticPointerglVertexAttrib4Niv = (MYPFNGLVERTEXATTRIB4NIVPROC) 0; staticPointerglVertexAttrib4Nsv = (MYPFNGLVERTEXATTRIB4NSVPROC) 0; staticPointerglVertexAttrib4Nub = (MYPFNGLVERTEXATTRIB4NUBPROC) 0; staticPointerglVertexAttrib4Nubv = (MYPFNGLVERTEXATTRIB4NUBVPROC) 0; staticPointerglVertexAttrib4Nuiv = (MYPFNGLVERTEXATTRIB4NUIVPROC) 0; staticPointerglVertexAttrib4Nusv = (MYPFNGLVERTEXATTRIB4NUSVPROC) 0; staticPointerglVertexAttrib4bv = (MYPFNGLVERTEXATTRIB4BVPROC) 0; staticPointerglVertexAttrib4d = (MYPFNGLVERTEXATTRIB4DPROC) 0; staticPointerglVertexAttrib4dv = (MYPFNGLVERTEXATTRIB4DVPROC) 0; staticPointerglVertexAttrib4f = (MYPFNGLVERTEXATTRIB4FPROC) 0; staticPointerglVertexAttrib4fv = (MYPFNGLVERTEXATTRIB4FVPROC) 0; staticPointerglVertexAttrib4iv = (MYPFNGLVERTEXATTRIB4IVPROC) 0; staticPointerglVertexAttrib4s = (MYPFNGLVERTEXATTRIB4SPROC) 0; staticPointerglVertexAttrib4sv = (MYPFNGLVERTEXATTRIB4SVPROC) 0; staticPointerglVertexAttrib4ubv = (MYPFNGLVERTEXATTRIB4UBVPROC) 0; staticPointerglVertexAttrib4uiv = (MYPFNGLVERTEXATTRIB4UIVPROC) 0; staticPointerglVertexAttrib4usv = (MYPFNGLVERTEXATTRIB4USVPROC) 0; staticPointerglVertexAttribPointer = (MYPFNGLVERTEXATTRIBPOINTERPROC) 0; #endif // End OpenGL version 2.0 #if defined(GL_EXT_paletted_texture) && GL_EXT_paletted_texture staticPointerglColorTableEXT = (MYPFNGLCOLORTABLEEXTPROC)glColorTableEXT; staticPointerglGetColorTableEXT = (MYPFNGLGETCOLORTABLEEXTPROC)glGetColorTableEXT; staticPointerglGetColorTableParameterivEXT = (MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glGetColorTableParameterivEXT; staticPointerglGetColorTableParameterfvEXT = (MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glGetColorTableParameterfvEXT; #else staticPointerglColorTableEXT = (MYPFNGLCOLORTABLEEXTPROC) 0; staticPointerglGetColorTableEXT = (MYPFNGLGETCOLORTABLEEXTPROC) 0; staticPointerglGetColorTableParameterivEXT = (MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) 0; staticPointerglGetColorTableParameterfvEXT = (MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) 0; #endif // End GL_EXT_paletted_texture #if defined(GL_ARB_multitexture) && GL_ARB_multitexture staticPointerglActiveTextureARB = (MYPFNGLACTIVETEXTUREARBPROC)glActiveTextureARB; staticPointerglClientActiveTextureARB = (MYPFNGLCLIENTACTIVETEXTUREARBPROC)glClientActiveTextureARB; staticPointerglMultiTexCoord1dARB = (MYPFNGLMULTITEXCOORD1DARBPROC)glMultiTexCoord1dARB; staticPointerglMultiTexCoord1dvARB = (MYPFNGLMULTITEXCOORD1DVARBPROC)glMultiTexCoord1dvARB; staticPointerglMultiTexCoord1fARB = (MYPFNGLMULTITEXCOORD1FARBPROC)glMultiTexCoord1fARB; staticPointerglMultiTexCoord1fvARB = (MYPFNGLMULTITEXCOORD1FVARBPROC)glMultiTexCoord1fvARB; staticPointerglMultiTexCoord1iARB = (MYPFNGLMULTITEXCOORD1IARBPROC)glMultiTexCoord1iARB; staticPointerglMultiTexCoord1ivARB = (MYPFNGLMULTITEXCOORD1IVARBPROC)glMultiTexCoord1ivARB; staticPointerglMultiTexCoord1sARB = (MYPFNGLMULTITEXCOORD1SARBPROC)glMultiTexCoord1sARB; staticPointerglMultiTexCoord1svARB = (MYPFNGLMULTITEXCOORD1SVARBPROC)glMultiTexCoord1svARB; staticPointerglMultiTexCoord2dARB = (MYPFNGLMULTITEXCOORD2DARBPROC)glMultiTexCoord2dARB; staticPointerglMultiTexCoord2dvARB = (MYPFNGLMULTITEXCOORD2DVARBPROC)glMultiTexCoord2dvARB; staticPointerglMultiTexCoord2fARB = (MYPFNGLMULTITEXCOORD2FARBPROC)glMultiTexCoord2fARB; staticPointerglMultiTexCoord2fvARB = (MYPFNGLMULTITEXCOORD2FVARBPROC)glMultiTexCoord2fvARB; staticPointerglMultiTexCoord2iARB = (MYPFNGLMULTITEXCOORD2IARBPROC)glMultiTexCoord2iARB; staticPointerglMultiTexCoord2ivARB = (MYPFNGLMULTITEXCOORD2IVARBPROC)glMultiTexCoord2ivARB; staticPointerglMultiTexCoord2sARB = (MYPFNGLMULTITEXCOORD2SARBPROC)glMultiTexCoord2sARB; staticPointerglMultiTexCoord2svARB = (MYPFNGLMULTITEXCOORD2SVARBPROC)glMultiTexCoord2svARB; staticPointerglMultiTexCoord3dARB = (MYPFNGLMULTITEXCOORD3DARBPROC)glMultiTexCoord3dARB; staticPointerglMultiTexCoord3dvARB = (MYPFNGLMULTITEXCOORD3DVARBPROC)glMultiTexCoord3dvARB; staticPointerglMultiTexCoord3fARB = (MYPFNGLMULTITEXCOORD3FARBPROC)glMultiTexCoord3fARB; staticPointerglMultiTexCoord3fvARB = (MYPFNGLMULTITEXCOORD3FVARBPROC)glMultiTexCoord3fvARB; staticPointerglMultiTexCoord3iARB = (MYPFNGLMULTITEXCOORD3IARBPROC)glMultiTexCoord3iARB; staticPointerglMultiTexCoord3ivARB = (MYPFNGLMULTITEXCOORD3IVARBPROC)glMultiTexCoord3ivARB; staticPointerglMultiTexCoord3sARB = (MYPFNGLMULTITEXCOORD3SARBPROC)glMultiTexCoord3sARB; staticPointerglMultiTexCoord3svARB = (MYPFNGLMULTITEXCOORD3SVARBPROC)glMultiTexCoord3svARB; staticPointerglMultiTexCoord4dARB = (MYPFNGLMULTITEXCOORD4DARBPROC)glMultiTexCoord4dARB; staticPointerglMultiTexCoord4dvARB = (MYPFNGLMULTITEXCOORD4DVARBPROC)glMultiTexCoord4dvARB; staticPointerglMultiTexCoord4fARB = (MYPFNGLMULTITEXCOORD4FARBPROC)glMultiTexCoord4fARB; staticPointerglMultiTexCoord4fvARB = (MYPFNGLMULTITEXCOORD4FVARBPROC)glMultiTexCoord4fvARB; staticPointerglMultiTexCoord4iARB = (MYPFNGLMULTITEXCOORD4IARBPROC)glMultiTexCoord4iARB; staticPointerglMultiTexCoord4ivARB = (MYPFNGLMULTITEXCOORD4IVARBPROC)glMultiTexCoord4ivARB; staticPointerglMultiTexCoord4sARB = (MYPFNGLMULTITEXCOORD4SARBPROC)glMultiTexCoord4sARB; staticPointerglMultiTexCoord4svARB = (MYPFNGLMULTITEXCOORD4SVARBPROC)glMultiTexCoord4svARB; #else staticPointerglActiveTextureARB = (MYPFNGLACTIVETEXTUREARBPROC) 0; staticPointerglClientActiveTextureARB = (MYPFNGLCLIENTACTIVETEXTUREARBPROC) 0; staticPointerglMultiTexCoord1dARB = (MYPFNGLMULTITEXCOORD1DARBPROC) 0; staticPointerglMultiTexCoord1dvARB = (MYPFNGLMULTITEXCOORD1DVARBPROC) 0; staticPointerglMultiTexCoord1fARB = (MYPFNGLMULTITEXCOORD1FARBPROC) 0; staticPointerglMultiTexCoord1fvARB = (MYPFNGLMULTITEXCOORD1FVARBPROC) 0; staticPointerglMultiTexCoord1iARB = (MYPFNGLMULTITEXCOORD1IARBPROC) 0; staticPointerglMultiTexCoord1ivARB = (MYPFNGLMULTITEXCOORD1IVARBPROC) 0; staticPointerglMultiTexCoord1sARB = (MYPFNGLMULTITEXCOORD1SARBPROC) 0; staticPointerglMultiTexCoord1svARB = (MYPFNGLMULTITEXCOORD1SVARBPROC) 0; staticPointerglMultiTexCoord2dARB = (MYPFNGLMULTITEXCOORD2DARBPROC) 0; staticPointerglMultiTexCoord2dvARB = (MYPFNGLMULTITEXCOORD2DVARBPROC) 0; staticPointerglMultiTexCoord2fARB = (MYPFNGLMULTITEXCOORD2FARBPROC) 0; staticPointerglMultiTexCoord2fvARB = (MYPFNGLMULTITEXCOORD2FVARBPROC) 0; staticPointerglMultiTexCoord2iARB = (MYPFNGLMULTITEXCOORD2IARBPROC) 0; staticPointerglMultiTexCoord2ivARB = (MYPFNGLMULTITEXCOORD2IVARBPROC) 0; staticPointerglMultiTexCoord2sARB = (MYPFNGLMULTITEXCOORD2SARBPROC) 0; staticPointerglMultiTexCoord2svARB = (MYPFNGLMULTITEXCOORD2SVARBPROC) 0; staticPointerglMultiTexCoord3dARB = (MYPFNGLMULTITEXCOORD3DARBPROC) 0; staticPointerglMultiTexCoord3dvARB = (MYPFNGLMULTITEXCOORD3DVARBPROC) 0; staticPointerglMultiTexCoord3fARB = (MYPFNGLMULTITEXCOORD3FARBPROC) 0; staticPointerglMultiTexCoord3fvARB = (MYPFNGLMULTITEXCOORD3FVARBPROC) 0; staticPointerglMultiTexCoord3iARB = (MYPFNGLMULTITEXCOORD3IARBPROC) 0; staticPointerglMultiTexCoord3ivARB = (MYPFNGLMULTITEXCOORD3IVARBPROC) 0; staticPointerglMultiTexCoord3sARB = (MYPFNGLMULTITEXCOORD3SARBPROC) 0; staticPointerglMultiTexCoord3svARB = (MYPFNGLMULTITEXCOORD3SVARBPROC) 0; staticPointerglMultiTexCoord4dARB = (MYPFNGLMULTITEXCOORD4DARBPROC) 0; staticPointerglMultiTexCoord4dvARB = (MYPFNGLMULTITEXCOORD4DVARBPROC) 0; staticPointerglMultiTexCoord4fARB = (MYPFNGLMULTITEXCOORD4FARBPROC) 0; staticPointerglMultiTexCoord4fvARB = (MYPFNGLMULTITEXCOORD4FVARBPROC) 0; staticPointerglMultiTexCoord4iARB = (MYPFNGLMULTITEXCOORD4IARBPROC) 0; staticPointerglMultiTexCoord4ivARB = (MYPFNGLMULTITEXCOORD4IVARBPROC) 0; staticPointerglMultiTexCoord4sARB = (MYPFNGLMULTITEXCOORD4SARBPROC) 0; staticPointerglMultiTexCoord4svARB = (MYPFNGLMULTITEXCOORD4SVARBPROC) 0; #endif // End GL_ARB_multitexture #if defined(GL_SGI_texture_color_table) && GL_SGI_texture_color_table // No new functions. #endif // End GL_SGI_texture_color_table #if defined(GL_SGI_color_table) && GL_SGI_color_table staticPointerglColorTableSGI = (MYPFNGLCOLORTABLESGIPROC)glColorTableSGI; staticPointerglColorTableParameterfvSGI = (MYPFNGLCOLORTABLEPARAMETERFVSGIPROC)glColorTableParameterfvSGI; staticPointerglColorTableParameterivSGI = (MYPFNGLCOLORTABLEPARAMETERIVSGIPROC)glColorTableParameterivSGI; staticPointerglCopyColorTableSGI = (MYPFNGLCOPYCOLORTABLESGIPROC)glCopyColorTableSGI; staticPointerglGetColorTableSGI = (MYPFNGLGETCOLORTABLESGIPROC)glGetColorTableSGI; staticPointerglGetColorTableParameterfvSGI = (MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glGetColorTableParameterfvSGI; staticPointerglGetColorTableParameterivSGI = (MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glGetColorTableParameterivSGI; #else staticPointerglColorTableSGI = (MYPFNGLCOLORTABLESGIPROC) 0; staticPointerglColorTableParameterfvSGI = (MYPFNGLCOLORTABLEPARAMETERFVSGIPROC) 0; staticPointerglColorTableParameterivSGI = (MYPFNGLCOLORTABLEPARAMETERIVSGIPROC) 0; staticPointerglCopyColorTableSGI = (MYPFNGLCOPYCOLORTABLESGIPROC) 0; staticPointerglGetColorTableSGI = (MYPFNGLGETCOLORTABLESGIPROC) 0; staticPointerglGetColorTableParameterfvSGI = (MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) 0; staticPointerglGetColorTableParameterivSGI = (MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) 0; #endif // End GL_SGI_color_table #if defined(GL_SGIS_texture_edge_clamp) && GL_SGIS_texture_edge_clamp // No new functions. #endif // End GL_SGIS_texture_edge_clamp #if defined(GL_EXT_texture3D) && GL_EXT_texture3D staticPointerglTexImage3DEXT = (MYPFNGLTEXIMAGE3DEXTPROC)glTexImage3DEXT; staticPointerglTexSubImage3DEXT = (MYPFNGLTEXSUBIMAGE3DEXTPROC)glTexSubImage3DEXT; #else staticPointerglTexImage3DEXT = (MYPFNGLTEXIMAGE3DEXTPROC) 0; staticPointerglTexSubImage3DEXT = (MYPFNGLTEXSUBIMAGE3DEXTPROC) 0; #endif // End GL_EXT_texture3D #if defined(GL_NV_fragment_program) && GL_NV_fragment_program staticPointerglProgramNamedParameter4fNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glProgramNamedParameter4fNV; staticPointerglProgramNamedParameter4dNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glProgramNamedParameter4dNV; staticPointerglProgramNamedParameter4fvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glProgramNamedParameter4fvNV; staticPointerglProgramNamedParameter4dvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glProgramNamedParameter4dvNV; staticPointerglGetProgramNamedParameterfvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glGetProgramNamedParameterfvNV; staticPointerglGetProgramNamedParameterdvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glGetProgramNamedParameterdvNV; #else staticPointerglProgramNamedParameter4fNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) 0; staticPointerglProgramNamedParameter4dNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) 0; staticPointerglProgramNamedParameter4fvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) 0; staticPointerglProgramNamedParameter4dvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) 0; staticPointerglGetProgramNamedParameterfvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) 0; staticPointerglGetProgramNamedParameterdvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) 0; #endif // GL_NV_fragment_program #if defined(GL_NV_vertex_program) && GL_NV_vertex_program staticPointerglAreProgramsResidentNV = (MYPFNGLAREPROGRAMSRESIDENTNVPROC)glAreProgramsResidentNV; staticPointerglBindProgramNV = (MYPFNGLBINDPROGRAMNVPROC)glBindProgramNV; staticPointerglDeleteProgramsNV = (MYPFNGLDELETEPROGRAMSNVPROC)glDeleteProgramsNV; staticPointerglExecuteProgramNV = (MYPFNGLEXECUTEPROGRAMNVPROC)glExecuteProgramNV; staticPointerglGenProgramsNV = (MYPFNGLGENPROGRAMSNVPROC)glGenProgramsNV; staticPointerglGetProgramParameterdvNV = (MYPFNGLGETPROGRAMPARAMETERDVNVPROC)glGetProgramParameterdvNV; staticPointerglGetProgramParameterfvNV = (MYPFNGLGETPROGRAMPARAMETERFVNVPROC)glGetProgramParameterfvNV; staticPointerglGetProgramivNV = (MYPFNGLGETPROGRAMIVNVPROC)glGetProgramivNV; staticPointerglGetProgramStringNV = (MYPFNGLGETPROGRAMSTRINGNVPROC)glGetProgramStringNV; staticPointerglGetTrackMatrixivNV = (MYPFNGLGETTRACKMATRIXIVNVPROC)glGetTrackMatrixivNV; staticPointerglGetVertexAttribdvNV = (MYPFNGLGETVERTEXATTRIBDVNVPROC)glGetVertexAttribdvNV; staticPointerglGetVertexAttribfvNV = (MYPFNGLGETVERTEXATTRIBFVNVPROC)glGetVertexAttribfvNV; staticPointerglGetVertexAttribivNV = (MYPFNGLGETVERTEXATTRIBIVNVPROC)glGetVertexAttribivNV; staticPointerglGetVertexAttribPointervNV = (MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC)glGetVertexAttribPointervNV; staticPointerglIsProgramNV = (MYPFNGLISPROGRAMNVPROC)glIsProgramNV; staticPointerglLoadProgramNV = (MYPFNGLLOADPROGRAMNVPROC)glLoadProgramNV; staticPointerglProgramParameter4dNV = (MYPFNGLPROGRAMPARAMETER4DNVPROC)glProgramParameter4dNV; staticPointerglProgramParameter4dvNV = (MYPFNGLPROGRAMPARAMETER4DVNVPROC)glProgramParameter4dvNV; staticPointerglProgramParameter4fNV = (MYPFNGLPROGRAMPARAMETER4FNVPROC)glProgramParameter4fNV; staticPointerglProgramParameter4fvNV = (MYPFNGLPROGRAMPARAMETER4FVNVPROC)glProgramParameter4fvNV; staticPointerglProgramParameters4dvNV = (MYPFNGLPROGRAMPARAMETERS4DVNVPROC)glProgramParameters4dvNV; staticPointerglProgramParameters4fvNV = (MYPFNGLPROGRAMPARAMETERS4FVNVPROC)glProgramParameters4fvNV; staticPointerglRequestResidentProgramsNV = (MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC)glRequestResidentProgramsNV; staticPointerglTrackMatrixNV = (MYPFNGLTRACKMATRIXNVPROC)glTrackMatrixNV; staticPointerglVertexAttribPointerNV = (MYPFNGLVERTEXATTRIBPOINTERNVPROC)glVertexAttribPointerNV; staticPointerglVertexAttrib1dNV = (MYPFNGLVERTEXATTRIB1DNVPROC)glVertexAttrib1dNV; staticPointerglVertexAttrib1dvNV = (MYPFNGLVERTEXATTRIB1DVNVPROC)glVertexAttrib1dvNV; staticPointerglVertexAttrib1fNV = (MYPFNGLVERTEXATTRIB1FNVPROC)glVertexAttrib1fNV; staticPointerglVertexAttrib1fvNV = (MYPFNGLVERTEXATTRIB1FVNVPROC)glVertexAttrib1fvNV; staticPointerglVertexAttrib1sNV = (MYPFNGLVERTEXATTRIB1SNVPROC)glVertexAttrib1sNV; staticPointerglVertexAttrib1svNV = (MYPFNGLVERTEXATTRIB1SVNVPROC)glVertexAttrib1svNV; staticPointerglVertexAttrib2dNV = (MYPFNGLVERTEXATTRIB2DNVPROC)glVertexAttrib2dNV; staticPointerglVertexAttrib2dvNV = (MYPFNGLVERTEXATTRIB2DVNVPROC)glVertexAttrib2dvNV; staticPointerglVertexAttrib2fNV = (MYPFNGLVERTEXATTRIB2FNVPROC)glVertexAttrib2fNV; staticPointerglVertexAttrib2fvNV = (MYPFNGLVERTEXATTRIB2FVNVPROC)glVertexAttrib2fvNV; staticPointerglVertexAttrib2sNV = (MYPFNGLVERTEXATTRIB2SNVPROC)glVertexAttrib2sNV; staticPointerglVertexAttrib2svNV = (MYPFNGLVERTEXATTRIB2SVNVPROC)glVertexAttrib2svNV; staticPointerglVertexAttrib3dNV = (MYPFNGLVERTEXATTRIB3DNVPROC)glVertexAttrib3dNV; staticPointerglVertexAttrib3dvNV = (MYPFNGLVERTEXATTRIB3DVNVPROC)glVertexAttrib3dvNV; staticPointerglVertexAttrib3fNV = (MYPFNGLVERTEXATTRIB3FNVPROC)glVertexAttrib3fNV; staticPointerglVertexAttrib3fvNV = (MYPFNGLVERTEXATTRIB3FVNVPROC)glVertexAttrib3fvNV; staticPointerglVertexAttrib3sNV = (MYPFNGLVERTEXATTRIB3SNVPROC)glVertexAttrib3sNV; staticPointerglVertexAttrib3svNV = (MYPFNGLVERTEXATTRIB3SVNVPROC)glVertexAttrib3svNV; staticPointerglVertexAttrib4dNV = (MYPFNGLVERTEXATTRIB4DNVPROC)glVertexAttrib4dNV; staticPointerglVertexAttrib4dvNV = (MYPFNGLVERTEXATTRIB4DVNVPROC)glVertexAttrib4dvNV; staticPointerglVertexAttrib4fNV = (MYPFNGLVERTEXATTRIB4FNVPROC)glVertexAttrib4fNV; staticPointerglVertexAttrib4fvNV = (MYPFNGLVERTEXATTRIB4FVNVPROC)glVertexAttrib4fvNV; staticPointerglVertexAttrib4sNV = (MYPFNGLVERTEXATTRIB4SNVPROC)glVertexAttrib4sNV; staticPointerglVertexAttrib4svNV = (MYPFNGLVERTEXATTRIB4SVNVPROC)glVertexAttrib4svNV; staticPointerglVertexAttrib4ubNV = (MYPFNGLVERTEXATTRIB4UBNVPROC)glVertexAttrib4ubNV; staticPointerglVertexAttrib4ubvNV = (MYPFNGLVERTEXATTRIB4UBVNVPROC)glVertexAttrib4ubvNV; staticPointerglVertexAttribs1dvNV = (MYPFNGLVERTEXATTRIBS1DVNVPROC)glVertexAttribs1dvNV; staticPointerglVertexAttribs1fvNV = (MYPFNGLVERTEXATTRIBS1FVNVPROC)glVertexAttribs1fvNV; staticPointerglVertexAttribs1svNV = (MYPFNGLVERTEXATTRIBS1SVNVPROC)glVertexAttribs1svNV; staticPointerglVertexAttribs2dvNV = (MYPFNGLVERTEXATTRIBS2DVNVPROC)glVertexAttribs2dvNV; staticPointerglVertexAttribs2fvNV = (MYPFNGLVERTEXATTRIBS2FVNVPROC)glVertexAttribs2fvNV; staticPointerglVertexAttribs2svNV = (MYPFNGLVERTEXATTRIBS2SVNVPROC)glVertexAttribs2svNV; staticPointerglVertexAttribs3dvNV = (MYPFNGLVERTEXATTRIBS3DVNVPROC)glVertexAttribs3dvNV; staticPointerglVertexAttribs3fvNV = (MYPFNGLVERTEXATTRIBS3FVNVPROC)glVertexAttribs3fvNV; staticPointerglVertexAttribs3svNV = (MYPFNGLVERTEXATTRIBS3SVNVPROC)glVertexAttribs3svNV; staticPointerglVertexAttribs4dvNV = (MYPFNGLVERTEXATTRIBS4DVNVPROC)glVertexAttribs4dvNV; staticPointerglVertexAttribs4fvNV = (MYPFNGLVERTEXATTRIBS4FVNVPROC)glVertexAttribs4fvNV; staticPointerglVertexAttribs4svNV = (MYPFNGLVERTEXATTRIBS4SVNVPROC)glVertexAttribs4svNV; staticPointerglVertexAttribs4ubvNV = (MYPFNGLVERTEXATTRIBS4UBVNVPROC)glVertexAttribs4ubvNV; #else staticPointerglAreProgramsResidentNV = (MYPFNGLAREPROGRAMSRESIDENTNVPROC) 0; staticPointerglBindProgramNV = (MYPFNGLBINDPROGRAMNVPROC) 0; staticPointerglDeleteProgramsNV = (MYPFNGLDELETEPROGRAMSNVPROC) 0; staticPointerglExecuteProgramNV = (MYPFNGLEXECUTEPROGRAMNVPROC) 0; staticPointerglGenProgramsNV = (MYPFNGLGENPROGRAMSNVPROC) 0; staticPointerglGetProgramParameterdvNV = (MYPFNGLGETPROGRAMPARAMETERDVNVPROC) 0; staticPointerglGetProgramParameterfvNV = (MYPFNGLGETPROGRAMPARAMETERFVNVPROC) 0; staticPointerglGetProgramivNV = (MYPFNGLGETPROGRAMIVNVPROC) 0; staticPointerglGetProgramStringNV = (MYPFNGLGETPROGRAMSTRINGNVPROC) 0; staticPointerglGetTrackMatrixivNV = (MYPFNGLGETTRACKMATRIXIVNVPROC) 0; staticPointerglGetVertexAttribdvNV = (MYPFNGLGETVERTEXATTRIBDVNVPROC) 0; staticPointerglGetVertexAttribfvNV = (MYPFNGLGETVERTEXATTRIBFVNVPROC) 0; staticPointerglGetVertexAttribivNV = (MYPFNGLGETVERTEXATTRIBIVNVPROC) 0; staticPointerglGetVertexAttribPointervNV = (MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC) 0; staticPointerglIsProgramNV = (MYPFNGLISPROGRAMNVPROC) 0; staticPointerglLoadProgramNV = (MYPFNGLLOADPROGRAMNVPROC) 0; staticPointerglProgramParameter4dNV = (MYPFNGLPROGRAMPARAMETER4DNVPROC) 0; staticPointerglProgramParameter4dvNV = (MYPFNGLPROGRAMPARAMETER4DVNVPROC) 0; staticPointerglProgramParameter4fNV = (MYPFNGLPROGRAMPARAMETER4FNVPROC) 0; staticPointerglProgramParameter4fvNV = (MYPFNGLPROGRAMPARAMETER4FVNVPROC) 0; staticPointerglProgramParameters4dvNV = (MYPFNGLPROGRAMPARAMETERS4DVNVPROC) 0; staticPointerglProgramParameters4fvNV = (MYPFNGLPROGRAMPARAMETERS4FVNVPROC) 0; staticPointerglRequestResidentProgramsNV = (MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC) 0; staticPointerglTrackMatrixNV = (MYPFNGLTRACKMATRIXNVPROC) 0; staticPointerglVertexAttribPointerNV = (MYPFNGLVERTEXATTRIBPOINTERNVPROC) 0; staticPointerglVertexAttrib1dNV = (MYPFNGLVERTEXATTRIB1DNVPROC) 0; staticPointerglVertexAttrib1dvNV = (MYPFNGLVERTEXATTRIB1DVNVPROC) 0; staticPointerglVertexAttrib1fNV = (MYPFNGLVERTEXATTRIB1FNVPROC) 0; staticPointerglVertexAttrib1fvNV = (MYPFNGLVERTEXATTRIB1FVNVPROC) 0; staticPointerglVertexAttrib1sNV = (MYPFNGLVERTEXATTRIB1SNVPROC) 0; staticPointerglVertexAttrib1svNV = (MYPFNGLVERTEXATTRIB1SVNVPROC) 0; staticPointerglVertexAttrib2dNV = (MYPFNGLVERTEXATTRIB2DNVPROC) 0; staticPointerglVertexAttrib2dvNV = (MYPFNGLVERTEXATTRIB2DVNVPROC) 0; staticPointerglVertexAttrib2fNV = (MYPFNGLVERTEXATTRIB2FNVPROC) 0; staticPointerglVertexAttrib2fvNV = (MYPFNGLVERTEXATTRIB2FVNVPROC) 0; staticPointerglVertexAttrib2sNV = (MYPFNGLVERTEXATTRIB2SNVPROC) 0; staticPointerglVertexAttrib2svNV = (MYPFNGLVERTEXATTRIB2SVNVPROC) 0; staticPointerglVertexAttrib3dNV = (MYPFNGLVERTEXATTRIB3DNVPROC) 0; staticPointerglVertexAttrib3dvNV = (MYPFNGLVERTEXATTRIB3DVNVPROC) 0; staticPointerglVertexAttrib3fNV = (MYPFNGLVERTEXATTRIB3FNVPROC) 0; staticPointerglVertexAttrib3fvNV = (MYPFNGLVERTEXATTRIB3FVNVPROC) 0; staticPointerglVertexAttrib3sNV = (MYPFNGLVERTEXATTRIB3SNVPROC) 0; staticPointerglVertexAttrib3svNV = (MYPFNGLVERTEXATTRIB3SVNVPROC) 0; staticPointerglVertexAttrib4dNV = (MYPFNGLVERTEXATTRIB4DNVPROC) 0; staticPointerglVertexAttrib4dvNV = (MYPFNGLVERTEXATTRIB4DVNVPROC) 0; staticPointerglVertexAttrib4fNV = (MYPFNGLVERTEXATTRIB4FNVPROC) 0; staticPointerglVertexAttrib4fvNV = (MYPFNGLVERTEXATTRIB4FVNVPROC) 0; staticPointerglVertexAttrib4sNV = (MYPFNGLVERTEXATTRIB4SNVPROC) 0; staticPointerglVertexAttrib4svNV = (MYPFNGLVERTEXATTRIB4SVNVPROC) 0; staticPointerglVertexAttrib4ubNV = (MYPFNGLVERTEXATTRIB4UBNVPROC) 0; staticPointerglVertexAttrib4ubvNV = (MYPFNGLVERTEXATTRIB4UBVNVPROC) 0; staticPointerglVertexAttribs1dvNV = (MYPFNGLVERTEXATTRIBS1DVNVPROC) 0; staticPointerglVertexAttribs1fvNV = (MYPFNGLVERTEXATTRIBS1FVNVPROC) 0; staticPointerglVertexAttribs1svNV = (MYPFNGLVERTEXATTRIBS1SVNVPROC) 0; staticPointerglVertexAttribs2dvNV = (MYPFNGLVERTEXATTRIBS2DVNVPROC) 0; staticPointerglVertexAttribs2fvNV = (MYPFNGLVERTEXATTRIBS2FVNVPROC) 0; staticPointerglVertexAttribs2svNV = (MYPFNGLVERTEXATTRIBS2SVNVPROC) 0; staticPointerglVertexAttribs3dvNV = (MYPFNGLVERTEXATTRIBS3DVNVPROC) 0; staticPointerglVertexAttribs3fvNV = (MYPFNGLVERTEXATTRIBS3FVNVPROC) 0; staticPointerglVertexAttribs3svNV = (MYPFNGLVERTEXATTRIBS3SVNVPROC) 0; staticPointerglVertexAttribs4dvNV = (MYPFNGLVERTEXATTRIBS4DVNVPROC) 0; staticPointerglVertexAttribs4fvNV = (MYPFNGLVERTEXATTRIBS4FVNVPROC) 0; staticPointerglVertexAttribs4svNV = (MYPFNGLVERTEXATTRIBS4SVNVPROC) 0; staticPointerglVertexAttribs4ubvNV = (MYPFNGLVERTEXATTRIBS4UBVNVPROC) 0; #endif // GL_NV_vertex_program #if defined(GL_ARB_vertex_program) && GL_ARB_vertex_program staticPointerglVertexAttrib1dARB = (MYPFNGLVERTEXATTRIB1DARBPROC) glVertexAttrib1dARB; staticPointerglVertexAttrib1dvARB = (MYPFNGLVERTEXATTRIB1DVARBPROC) glVertexAttrib1dvARB; staticPointerglVertexAttrib1fARB = (MYPFNGLVERTEXATTRIB1FARBPROC) glVertexAttrib1fARB; staticPointerglVertexAttrib1fvARB = (MYPFNGLVERTEXATTRIB1FVARBPROC) glVertexAttrib1fvARB; staticPointerglVertexAttrib1sARB = (MYPFNGLVERTEXATTRIB1SARBPROC) glVertexAttrib1sARB; staticPointerglVertexAttrib1svARB = (MYPFNGLVERTEXATTRIB1SVARBPROC) glVertexAttrib1svARB; staticPointerglVertexAttrib2dARB = (MYPFNGLVERTEXATTRIB2DARBPROC) glVertexAttrib2dARB; staticPointerglVertexAttrib2dvARB = (MYPFNGLVERTEXATTRIB2DVARBPROC) glVertexAttrib2dvARB; staticPointerglVertexAttrib2fARB = (MYPFNGLVERTEXATTRIB2FARBPROC) glVertexAttrib2fARB; staticPointerglVertexAttrib2fvARB = (MYPFNGLVERTEXATTRIB2FVARBPROC) glVertexAttrib2fvARB; staticPointerglVertexAttrib2sARB = (MYPFNGLVERTEXATTRIB2SARBPROC) glVertexAttrib2sARB; staticPointerglVertexAttrib2svARB = (MYPFNGLVERTEXATTRIB2SVARBPROC) glVertexAttrib2svARB; staticPointerglVertexAttrib3dARB = (MYPFNGLVERTEXATTRIB3DARBPROC) glVertexAttrib3dARB; staticPointerglVertexAttrib3dvARB = (MYPFNGLVERTEXATTRIB3DVARBPROC) glVertexAttrib3dvARB; staticPointerglVertexAttrib3fARB = (MYPFNGLVERTEXATTRIB3FARBPROC) glVertexAttrib3fARB; staticPointerglVertexAttrib3fvARB = (MYPFNGLVERTEXATTRIB3FVARBPROC) glVertexAttrib3fvARB; staticPointerglVertexAttrib3sARB = (MYPFNGLVERTEXATTRIB3SARBPROC) glVertexAttrib3sARB; staticPointerglVertexAttrib3svARB = (MYPFNGLVERTEXATTRIB3SVARBPROC) glVertexAttrib3svARB; staticPointerglVertexAttrib4NbvARB = (MYPFNGLVERTEXATTRIB4NBVARBPROC) glVertexAttrib4NbvARB; staticPointerglVertexAttrib4NivARB = (MYPFNGLVERTEXATTRIB4NIVARBPROC) glVertexAttrib4NivARB; staticPointerglVertexAttrib4NsvARB = (MYPFNGLVERTEXATTRIB4NSVARBPROC) glVertexAttrib4NsvARB; staticPointerglVertexAttrib4NubARB = (MYPFNGLVERTEXATTRIB4NUBARBPROC) glVertexAttrib4NubARB; staticPointerglVertexAttrib4NubvARB = (MYPFNGLVERTEXATTRIB4NUBVARBPROC) glVertexAttrib4NubvARB; staticPointerglVertexAttrib4NuivARB = (MYPFNGLVERTEXATTRIB4NUIVARBPROC) glVertexAttrib4NuivARB; staticPointerglVertexAttrib4NusvARB = (MYPFNGLVERTEXATTRIB4NUSVARBPROC) glVertexAttrib4NusvARB; staticPointerglVertexAttrib4bvARB = (MYPFNGLVERTEXATTRIB4BVARBPROC) glVertexAttrib4bvARB; staticPointerglVertexAttrib4dARB = (MYPFNGLVERTEXATTRIB4DARBPROC) glVertexAttrib4dARB; staticPointerglVertexAttrib4dvARB = (MYPFNGLVERTEXATTRIB4DVARBPROC) glVertexAttrib4dvARB; staticPointerglVertexAttrib4fARB = (MYPFNGLVERTEXATTRIB4FARBPROC) glVertexAttrib4fARB; staticPointerglVertexAttrib4fvARB = (MYPFNGLVERTEXATTRIB4FVARBPROC) glVertexAttrib4fvARB; staticPointerglVertexAttrib4ivARB = (MYPFNGLVERTEXATTRIB4IVARBPROC) glVertexAttrib4ivARB; staticPointerglVertexAttrib4sARB = (MYPFNGLVERTEXATTRIB4SARBPROC) glVertexAttrib4sARB; staticPointerglVertexAttrib4svARB = (MYPFNGLVERTEXATTRIB4SVARBPROC) glVertexAttrib4svARB; staticPointerglVertexAttrib4ubvARB = (MYPFNGLVERTEXATTRIB4UBVARBPROC) glVertexAttrib4ubvARB; staticPointerglVertexAttrib4uivARB = (MYPFNGLVERTEXATTRIB4UIVARBPROC) glVertexAttrib4uivARB; staticPointerglVertexAttrib4usvARB = (MYPFNGLVERTEXATTRIB4USVARBPROC) glVertexAttrib4usvARB; staticPointerglVertexAttribPointerARB = (MYPFNGLVERTEXATTRIBPOINTERARBPROC) glVertexAttribPointerARB; staticPointerglEnableVertexAttribArrayARB = (MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC) glEnableVertexAttribArrayARB; staticPointerglDisableVertexAttribArrayARB = (MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) glDisableVertexAttribArrayARB; staticPointerglProgramStringARB = (MYPFNGLPROGRAMSTRINGARBPROC) glProgramStringARB; staticPointerglBindProgramARB = (MYPFNGLBINDPROGRAMARBPROC) glBindProgramARB; staticPointerglDeleteProgramsARB = (MYPFNGLDELETEPROGRAMSARBPROC) glDeleteProgramsARB; staticPointerglGenProgramsARB = (MYPFNGLGENPROGRAMSARBPROC) glGenProgramsARB; staticPointerglProgramEnvParameter4dARB = (MYPFNGLPROGRAMENVPARAMETER4DARBPROC) glProgramEnvParameter4dARB; staticPointerglProgramEnvParameter4dvARB = (MYPFNGLPROGRAMENVPARAMETER4DVARBPROC) glProgramEnvParameter4dvARB; staticPointerglProgramEnvParameter4fARB = (MYPFNGLPROGRAMENVPARAMETER4FARBPROC) glProgramEnvParameter4fARB; staticPointerglProgramEnvParameter4fvARB = (MYPFNGLPROGRAMENVPARAMETER4FVARBPROC) glProgramEnvParameter4fvARB; staticPointerglProgramLocalParameter4dARB = (MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC) glProgramLocalParameter4dARB; staticPointerglProgramLocalParameter4dvARB = (MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) glProgramLocalParameter4dvARB; staticPointerglProgramLocalParameter4fARB = (MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC) glProgramLocalParameter4fARB; staticPointerglProgramLocalParameter4fvARB = (MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) glProgramLocalParameter4fvARB; staticPointerglGetProgramEnvParameterdvARB = (MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC) glGetProgramEnvParameterdvARB; staticPointerglGetProgramEnvParameterfvARB = (MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC) glGetProgramEnvParameterfvARB; staticPointerglGetProgramLocalParameterdvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) glGetProgramLocalParameterdvARB; staticPointerglGetProgramLocalParameterfvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) glGetProgramLocalParameterfvARB; staticPointerglGetProgramivARB = (MYPFNGLGETPROGRAMIVARBPROC) glGetProgramivARB; staticPointerglGetProgramStringARB = (MYPFNGLGETPROGRAMSTRINGARBPROC) glGetProgramStringARB; staticPointerglGetVertexAttribdvARB = (MYPFNGLGETVERTEXATTRIBDVARBPROC) glGetVertexAttribdvARB; staticPointerglGetVertexAttribfvARB = (MYPFNGLGETVERTEXATTRIBFVARBPROC) glGetVertexAttribfvARB; staticPointerglGetVertexAttribivARB = (MYPFNGLGETVERTEXATTRIBIVARBPROC) glGetVertexAttribivARB; staticPointerglGetVertexAttribPointervARB = (MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC) glGetVertexAttribPointervARB; staticPointerglIsProgramARB = (MYPFNGLISPROGRAMARBPROC) glIsProgramARB; #else staticPointerglVertexAttrib1dARB = 0; staticPointerglVertexAttrib1dvARB = 0; staticPointerglVertexAttrib1fARB = 0; staticPointerglVertexAttrib1fvARB = 0; staticPointerglVertexAttrib1sARB = 0; staticPointerglVertexAttrib1svARB = 0; staticPointerglVertexAttrib2dARB = 0; staticPointerglVertexAttrib2dvARB = 0; staticPointerglVertexAttrib2fARB = 0; staticPointerglVertexAttrib2fvARB = 0; staticPointerglVertexAttrib2sARB = 0; staticPointerglVertexAttrib2svARB = 0; staticPointerglVertexAttrib3dARB = 0; staticPointerglVertexAttrib3dvARB = 0; staticPointerglVertexAttrib3fARB = 0; staticPointerglVertexAttrib3fvARB = 0; staticPointerglVertexAttrib3sARB = 0; staticPointerglVertexAttrib3svARB = 0; staticPointerglVertexAttrib4NbvARB = 0; staticPointerglVertexAttrib4NivARB = 0; staticPointerglVertexAttrib4NsvARB = 0; staticPointerglVertexAttrib4NubARB = 0; staticPointerglVertexAttrib4NubvARB = 0; staticPointerglVertexAttrib4NuivARB = 0; staticPointerglVertexAttrib4NusvARB = 0; staticPointerglVertexAttrib4bvARB = 0; staticPointerglVertexAttrib4dARB = 0; staticPointerglVertexAttrib4dvARB = 0; staticPointerglVertexAttrib4fARB = 0; staticPointerglVertexAttrib4fvARB = 0; staticPointerglVertexAttrib4ivARB = 0; staticPointerglVertexAttrib4sARB = 0; staticPointerglVertexAttrib4svARB = 0; staticPointerglVertexAttrib4ubvARB = 0; staticPointerglVertexAttrib4uivARB = 0; staticPointerglVertexAttrib4usvARB = 0; staticPointerglVertexAttribPointerARB = 0; staticPointerglEnableVertexAttribArrayARB = 0; staticPointerglDisableVertexAttribArrayARB = 0; staticPointerglProgramStringARB = 0; staticPointerglBindProgramARB = 0; staticPointerglDeleteProgramsARB = 0; staticPointerglGenProgramsARB = 0; staticPointerglProgramEnvParameter4dARB = 0; staticPointerglProgramEnvParameter4dvARB = 0; staticPointerglProgramEnvParameter4fARB = 0; staticPointerglProgramEnvParameter4fvARB = 0; staticPointerglProgramLocalParameter4dARB = 0; staticPointerglProgramLocalParameter4dvARB = 0; staticPointerglProgramLocalParameter4fARB = 0; staticPointerglProgramLocalParameter4fvARB = 0; staticPointerglGetProgramEnvParameterdvARB = 0; staticPointerglGetProgramEnvParameterfvARB = 0; staticPointerglGetProgramLocalParameterdvARB = 0; staticPointerglGetProgramLocalParameterfvARB = 0; staticPointerglGetProgramivARB = 0; staticPointerglGetProgramStringARB = 0; staticPointerglGetVertexAttribdvARB = 0; staticPointerglGetVertexAttribfvARB = 0; staticPointerglGetVertexAttribivARB = 0; staticPointerglGetVertexAttribPointervARB = 0; staticPointerglIsProgramARB = 0; #endif // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program #if defined(GL_EXT_secondary_color) && GL_EXT_secondary_color staticPointerglSecondaryColor3bEXT = (MYPFNGLSECONDARYCOLOR3BEXTPROC)glSecondaryColor3bEXT; staticPointerglSecondaryColor3bvEXT = (MYPFNGLSECONDARYCOLOR3BVEXTPROC)glSecondaryColor3bvEXT; staticPointerglSecondaryColor3dEXT = (MYPFNGLSECONDARYCOLOR3DEXTPROC)glSecondaryColor3dEXT; staticPointerglSecondaryColor3dvEXT = (MYPFNGLSECONDARYCOLOR3DVEXTPROC)glSecondaryColor3dvEXT; staticPointerglSecondaryColor3fEXT = (MYPFNGLSECONDARYCOLOR3FEXTPROC)glSecondaryColor3fEXT; staticPointerglSecondaryColor3fvEXT = (MYPFNGLSECONDARYCOLOR3FVEXTPROC)glSecondaryColor3fvEXT; staticPointerglSecondaryColor3iEXT = (MYPFNGLSECONDARYCOLOR3IEXTPROC)glSecondaryColor3iEXT; staticPointerglSecondaryColor3ivEXT = (MYPFNGLSECONDARYCOLOR3IVEXTPROC)glSecondaryColor3ivEXT; staticPointerglSecondaryColor3sEXT = (MYPFNGLSECONDARYCOLOR3SEXTPROC)glSecondaryColor3sEXT; staticPointerglSecondaryColor3svEXT = (MYPFNGLSECONDARYCOLOR3SVEXTPROC)glSecondaryColor3svEXT; staticPointerglSecondaryColor3ubEXT = (MYPFNGLSECONDARYCOLOR3UBEXTPROC)glSecondaryColor3ubEXT; staticPointerglSecondaryColor3ubvEXT = (MYPFNGLSECONDARYCOLOR3UBVEXTPROC)glSecondaryColor3ubvEXT; staticPointerglSecondaryColor3uiEXT = (MYPFNGLSECONDARYCOLOR3UIEXTPROC)glSecondaryColor3uiEXT; staticPointerglSecondaryColor3uivEXT = (MYPFNGLSECONDARYCOLOR3UIVEXTPROC)glSecondaryColor3uivEXT; staticPointerglSecondaryColor3usEXT = (MYPFNGLSECONDARYCOLOR3USEXTPROC)glSecondaryColor3usEXT; staticPointerglSecondaryColor3usvEXT = (MYPFNGLSECONDARYCOLOR3USVEXTPROC)glSecondaryColor3usvEXT; staticPointerglSecondaryColorPointerEXT = (MYPFNGLSECONDARYCOLORPOINTEREXTPROC)glSecondaryColorPointerEXT; #else staticPointerglSecondaryColor3bEXT = 0; staticPointerglSecondaryColor3bvEXT = 0; staticPointerglSecondaryColor3dEXT = 0; staticPointerglSecondaryColor3dvEXT = 0; staticPointerglSecondaryColor3fEXT = 0; staticPointerglSecondaryColor3fvEXT = 0; staticPointerglSecondaryColor3iEXT = 0; staticPointerglSecondaryColor3ivEXT = 0; staticPointerglSecondaryColor3sEXT = 0; staticPointerglSecondaryColor3svEXT = 0; staticPointerglSecondaryColor3ubEXT = 0; staticPointerglSecondaryColor3ubvEXT = 0; staticPointerglSecondaryColor3uiEXT = 0; staticPointerglSecondaryColor3uivEXT = 0; staticPointerglSecondaryColor3usEXT = 0; staticPointerglSecondaryColor3usvEXT = 0; staticPointerglSecondaryColorPointerEXT = 0; #endif // GL_EXT_secondary_color // ARB_vertex_buffer_object #if defined(GL_ARB_vertex_buffer_object) && GL_ARB_vertex_buffer_object staticPointerglBindBufferARB = (MYPFNGLBINDBUFFERARBPROC)glBindBufferARB; staticPointerglDeleteBuffersARB = (MYPFNGLDELETEBUFFERSARBPROC)glDeleteBuffersARB; staticPointerglGenBuffersARB = (MYPFNGLGENBUFFERSARBPROC)glGenBuffersARB; staticPointerglIsBufferARB = (MYPFNGLISBUFFERARBPROC)glIsBufferARB; staticPointerglBufferDataARB = (MYPFNGLBUFFERDATAARBPROC)glBufferDataARB; staticPointerglBufferSubDataARB = (MYPFNGLBUFFERSUBDATAARBPROC)glBufferSubDataARB; staticPointerglGetBufferSubDataARB = (MYPFNGLGETBUFFERSUBDATAARBPROC)glGetBufferSubDataARB; staticPointerglMapBufferARB = (MYPFNGLMAPBUFFERARBPROC)glMapBufferARB; staticPointerglUnmapBufferARB = (MYPFNGLUNMAPBUFFERARBPROC)glUnmapBufferARB; staticPointerglGetBufferParameterivARB = (MYPFNGLGETBUFFERPARAMETERIVARBPROC)glGetBufferParameterivARB; staticPointerglGetBufferPointervARB = (MYPFNGLGETBUFFERPOINTERVARBPROC)glGetBufferPointervARB; #else staticPointerglBindBufferARB = 0; staticPointerglDeleteBuffersARB = 0; staticPointerglGenBuffersARB = 0; staticPointerglIsBufferARB = 0; staticPointerglBufferDataARB = 0; staticPointerglBufferSubDataARB = 0; staticPointerglGetBufferSubDataARB = 0; staticPointerglMapBufferARB = 0; staticPointerglUnmapBufferARB = 0; staticPointerglGetBufferParameterivARB = 0; staticPointerglGetBufferPointervARB = 0; #endif // GL_ARB_vertex_buffer_object } #else void initStaticPointers() { // do nothing } #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/OpenGL_Viewer.dsp0000644000175000017500000000645410240173437030602 0ustar debiandebian# Microsoft Developer Studio Project File - Name="OpenGL_Viewer" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=OpenGL_Viewer - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "OpenGL_Viewer.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "OpenGL_Viewer.mak" CFG="OpenGL_Viewer - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "OpenGL_Viewer - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "OpenGL_Viewer - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "OpenGL_Viewer - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "../UsefulMath" /I "../Geometry" /I "../GeometryRenderer" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "OpenGL_Viewer - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /I "../UsefulMath" /I "../Geometry" /I "../GeometryRenderer" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "QT_DLL" /D "QT_THREAD_SUPPORT" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "OpenGL_Viewer - Win32 Release" # Name "OpenGL_Viewer - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\MyExtensions.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\ExtensionPointers.h # End Source File # Begin Source File SOURCE=.\MyExtensions.h # End Source File # Begin Source File SOURCE=.\StaticExtensionPointers.h # End Source File # End Group # Begin Source File SOURCE=.\OpenGL_Viewer.pro # End Source File # End Target # End Project mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/Makefile0000644000175000017500000000100710240173436027051 0ustar debiandebianCC = g++ CCFLAGS = -Wall -O3 -finline # ----- Example programs -------------------------------------------------------- PROG_SRC = MyExtensions.cpp PROG_OBJ = MyExtensions.o TARGET = libOpenGL_Viewer.a # ------------------------------------------------------------------------------- all: Makefile $(TARGET) $(TARGET): $(PROG_OBJ) rm -f $(TARGET) ar cqs $(TARGET) $(PROG_OBJ) MyExtensions.o: MyExtensions.cpp $(CC) $(CCFLAGS) -c MyExtensions.cpp -o MyExtensions.o -I. clean: rm $(TARGET) MyExtensions.o mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/ExtensionPointers.h0000644000175000017500000014125211006453404031266 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Supervisor: Dr C Bajaj bajaj@cs.utexas.edu, */ /* Authors: Anthony Thane thanea@ices.utexas.edu */ /* S K Vinay skvinay@cs.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ #ifndef EXTENSIONPOINTERS_H #define EXTENSIONPOINTERS_H // This file supports the following extensions: // GL_EXT_paletted_texture GL_ARB_multitexture // GL_SGI_color_table GL_SGI_texture_color_table GL_EXT_texture3D // SKVINAY, added EXT_secondary_color // OpenGL version 1.2 typedef void (APIENTRY * MYPFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); typedef void (APIENTRY * MYPFNGLBLENDEQUATIONPROC) (GLenum mode); typedef void (APIENTRY * MYPFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); typedef void (APIENTRY * MYPFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRY * MYPFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRY * MYPFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); typedef void (APIENTRY * MYPFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); typedef void (APIENTRY * MYPFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); typedef void (APIENTRY * MYPFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRY * MYPFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRY * MYPFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); typedef void (APIENTRY * MYPFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); typedef void (APIENTRY * MYPFNGLRESETHISTOGRAMPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLRESETMINMAXPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * MYPFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * MYPFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); // End OpenGL version 1.2 // OpenGL version 1.3 typedef void (APIENTRY * MYPFNGLACTIVETEXTUREPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m); typedef void (APIENTRY * MYPFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m); typedef void (APIENTRY * MYPFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m); typedef void (APIENTRY * MYPFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m); typedef void (APIENTRY * MYPFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, GLvoid *img); // End OpenGL version 1.3 // OpenGL version 1.4 typedef void (APIENTRY * MYPFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); typedef void (APIENTRY * MYPFNGLFOGCOORDFPROC) (GLfloat coord); typedef void (APIENTRY * MYPFNGLFOGCOORDFVPROC) (const GLfloat *coord); typedef void (APIENTRY * MYPFNGLFOGCOORDDPROC) (GLdouble coord); typedef void (APIENTRY * MYPFNGLFOGCOORDDVPROC) (const GLdouble *coord); typedef void (APIENTRY * MYPFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); typedef void (APIENTRY * MYPFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2DVPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2FVPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS2IPROC) (GLint x, GLint y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2IVPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2SVPROC) (const GLshort *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3DVPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3FVPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3IVPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3SVPROC) (const GLshort *v); // End OpenGL version 1.4 // OpenGL version 1.5 typedef void (APIENTRY * MYPFNGLGENQUERIESPROC) (GLsizei n, GLuint *ids); typedef void (APIENTRY * MYPFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint *ids); typedef GLboolean (APIENTRY * MYPFNGLISQUERYPROC) (GLuint id); typedef void (APIENTRY * MYPFNGLBEGINQUERYPROC) (GLenum target, GLuint id); typedef void (APIENTRY * MYPFNGLENDQUERYPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint *params); typedef void (APIENTRY * MYPFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); typedef void (APIENTRY * MYPFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); typedef void (APIENTRY * MYPFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers); typedef GLboolean (APIENTRY * MYPFNGLISBUFFERPROC) (GLuint buffer); typedef void (APIENTRY * MYPFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); typedef void (APIENTRY * MYPFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); typedef void (APIENTRY * MYPFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data); typedef GLvoid* (APIENTRY * MYPFNGLMAPBUFFERPROC) (GLenum target, GLenum access); typedef GLboolean (APIENTRY * MYPFNGLUNMAPBUFFERPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, GLvoid* *params); // End OpenGL version 1.5 // OpenGL version 2.0 typedef void (APIENTRY * MYPFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha); typedef void (APIENTRY * MYPFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum *bufs); typedef void (APIENTRY * MYPFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); typedef void (APIENTRY * MYPFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); typedef void (APIENTRY * MYPFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuint mask); typedef void (APIENTRY * MYPFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); typedef void (APIENTRY * MYPFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar *name); typedef void (APIENTRY * MYPFNGLCOMPILESHADERPROC) (GLuint shader); typedef GLuint (APIENTRY * MYPFNGLCREATEPROGRAMPROC) (void); typedef GLuint (APIENTRY * MYPFNGLCREATESHADERPROC) (GLenum type); typedef void (APIENTRY * MYPFNGLDELETEPROGRAMPROC) (GLuint program); typedef void (APIENTRY * MYPFNGLDELETESHADERPROC) (GLuint shader); typedef void (APIENTRY * MYPFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); typedef void (APIENTRY * MYPFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index); typedef void (APIENTRY * MYPFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index); typedef void (APIENTRY * MYPFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); typedef void (APIENTRY * MYPFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); typedef void (APIENTRY * MYPFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj); typedef GLint (APIENTRY * MYPFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name); typedef void (APIENTRY * MYPFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); typedef void (APIENTRY * MYPFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); typedef void (APIENTRY * MYPFNGLGETSHADERSOURCEPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); typedef GLint (APIENTRY * MYPFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name); typedef void (APIENTRY * MYPFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRY * MYPFNGLISPROGRAMPROC) (GLuint program); typedef GLboolean (APIENTRY * MYPFNGLISSHADERPROC) (GLuint shader); typedef void (APIENTRY * MYPFNGLLINKPROGRAMPROC) (GLuint program); typedef void (APIENTRY * MYPFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length); typedef void (APIENTRY * MYPFNGLUSEPROGRAMPROC) (GLuint program); typedef void (APIENTRY * MYPFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); typedef void (APIENTRY * MYPFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); typedef void (APIENTRY * MYPFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (APIENTRY * MYPFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (APIENTRY * MYPFNGLUNIFORM1IPROC) (GLint location, GLint v0); typedef void (APIENTRY * MYPFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); typedef void (APIENTRY * MYPFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); typedef void (APIENTRY * MYPFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (APIENTRY * MYPFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRY * MYPFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRY * MYPFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRY * MYPFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRY * MYPFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRY * MYPFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRY * MYPFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRY * MYPFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRY * MYPFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRY * MYPFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRY * MYPFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRY * MYPFNGLVALIDATEPROGRAMPROC) (GLuint program); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); // End OpenGL version 2.0 // GL_EXT_paletted_texture typedef void (APIENTRY * MYPFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); // End GL_EXT_paletted_texture // GL_ARB_multitexture typedef void (APIENTRY * MYPFNGLACTIVETEXTUREARBPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table typedef void (APIENTRY * MYPFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params); // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D typedef void (APIENTRY * MYPFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * MYPFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); // End GL_EXT_texture3D // GL_NV_fragment_program typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v); typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v); typedef void (APIENTRY * MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params); // End GL_NV_fragment_program // GL_NV_vertex_program typedef GLboolean (APIENTRY * MYPFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint *programs, GLboolean *residences); typedef void (APIENTRY * MYPFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); typedef void (APIENTRY * MYPFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRY * MYPFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat *params); typedef void (APIENTRY * MYPFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *programs); typedef void (APIENTRY * MYPFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte *program); typedef void (APIENTRY * MYPFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRY * MYPFNGLISPROGRAMNVPROC) (GLuint id); typedef void (APIENTRY * MYPFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRY * MYPFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, const GLubyte *v); // End GL_NV_vertex_program // GL_ARB_vertex_program typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (APIENTRY * MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (APIENTRY * MYPFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); typedef void (APIENTRY * MYPFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); typedef void (APIENTRY * MYPFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRY * MYPFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRY * MYPFNGLISPROGRAMARBPROC) (GLuint program); // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program // EXT_secondary_color typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); // ARB_vertex_buffer_object typedef void (APIENTRY * MYPFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); typedef void (APIENTRY * MYPFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers); typedef void (APIENTRY * MYPFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers); typedef GLboolean (APIENTRY * MYPFNGLISBUFFERARBPROC) (GLuint buffer); typedef void (APIENTRY * MYPFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage); typedef void (APIENTRY * MYPFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data); typedef void (APIENTRY * MYPFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data); typedef GLvoid* (APIENTRY * MYPFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); typedef GLboolean (APIENTRY * MYPFNGLUNMAPBUFFERARBPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, GLvoid* *params); /// WGL extensions follows #if defined(WIN32) // WGL_ARB_pixel_format typedef BOOL (WINAPI * MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues); typedef BOOL (WINAPI * MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues); typedef BOOL (WINAPI * MYPFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); // End WGL_ARB_pixel_format // WGL_ARB_pbuffer typedef HPBUFFERARB (WINAPI * MYPFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); typedef HDC (WINAPI * MYPFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); typedef int (WINAPI * MYPFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); typedef BOOL (WINAPI * MYPFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); typedef BOOL (WINAPI * MYPFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue); // End WGL_ARB_pbuffer // WGL_ARB_render_texture typedef BOOL (WINAPI * MYPFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); typedef BOOL (WINAPI * MYPFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); typedef BOOL (WINAPI * MYPFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList); // End WGL_ARB_render_texture // WGL_ARB_extensions_string typedef const char * (WINAPI * MYPFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); // End WGL_ARB_extensions_string #endif // defined(WIN32) #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/glext.h0000644000175000017500000121436511006453447026727 0ustar debiandebian#ifndef __glext_h_ #define __glext_h_ #ifdef __cplusplus extern "C" { #endif /* ** License Applicability. Except to the extent portions of this file are ** made subject to an alternative license as permitted in the SGI Free ** Software License B, Version 1.1 (the "License"), the contents of this ** file are subject only to the provisions of the License. You may not use ** this file except in compliance with the License. You may obtain a copy ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: ** ** http://oss.sgi.com/projects/FreeB ** ** Note that, as provided in the License, the Software is distributed on an ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. ** ** Original Code. The Original Code is: OpenGL Sample Implementation, ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, ** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc. ** Copyright in any portions created by third parties is as indicated ** elsewhere herein. All Rights Reserved. ** ** Additional Notice Provisions: This software was created using the ** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has ** not been independently verified as being compliant with the OpenGL(R) ** version 1.2.1 Specification. */ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) #define WIN32_LEAN_AND_MEAN 1 #include #endif #ifndef APIENTRY #define APIENTRY #endif #ifndef APIENTRYP #define APIENTRYP APIENTRY * #endif #ifndef GLAPI #define GLAPI extern #endif /*************************************************************/ /* Header file version number, required by OpenGL ABI for Linux */ /* glext.h last updated 2005/03/17 */ /* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */ #define GL_GLEXT_VERSION 27 #ifndef GL_VERSION_1_2 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_RESCALE_NORMAL 0x803A #define GL_TEXTURE_BINDING_3D 0x806A #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_TEXTURE_3D 0x806F #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_CLAMP_TO_EDGE 0x812F #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_SINGLE_COLOR 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E #endif #ifndef GL_ARB_imaging #define GL_CONSTANT_COLOR 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_CONSTANT_ALPHA 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_BLEND_COLOR 0x8005 #define GL_FUNC_ADD 0x8006 #define GL_MIN 0x8007 #define GL_MAX 0x8008 #define GL_BLEND_EQUATION 0x8009 #define GL_FUNC_SUBTRACT 0x800A #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_CONVOLUTION_1D 0x8010 #define GL_CONVOLUTION_2D 0x8011 #define GL_SEPARABLE_2D 0x8012 #define GL_CONVOLUTION_BORDER_MODE 0x8013 #define GL_CONVOLUTION_FILTER_SCALE 0x8014 #define GL_CONVOLUTION_FILTER_BIAS 0x8015 #define GL_REDUCE 0x8016 #define GL_CONVOLUTION_FORMAT 0x8017 #define GL_CONVOLUTION_WIDTH 0x8018 #define GL_CONVOLUTION_HEIGHT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH 0x801A #define GL_MAX_CONVOLUTION_HEIGHT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F #define GL_POST_CONVOLUTION_RED_BIAS 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 #define GL_HISTOGRAM 0x8024 #define GL_PROXY_HISTOGRAM 0x8025 #define GL_HISTOGRAM_WIDTH 0x8026 #define GL_HISTOGRAM_FORMAT 0x8027 #define GL_HISTOGRAM_RED_SIZE 0x8028 #define GL_HISTOGRAM_GREEN_SIZE 0x8029 #define GL_HISTOGRAM_BLUE_SIZE 0x802A #define GL_HISTOGRAM_ALPHA_SIZE 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C #define GL_HISTOGRAM_SINK 0x802D #define GL_MINMAX 0x802E #define GL_MINMAX_FORMAT 0x802F #define GL_MINMAX_SINK 0x8030 #define GL_TABLE_TOO_LARGE 0x8031 #define GL_COLOR_MATRIX 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB #define GL_COLOR_TABLE 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 #define GL_PROXY_COLOR_TABLE 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 #define GL_COLOR_TABLE_SCALE 0x80D6 #define GL_COLOR_TABLE_BIAS 0x80D7 #define GL_COLOR_TABLE_FORMAT 0x80D8 #define GL_COLOR_TABLE_WIDTH 0x80D9 #define GL_COLOR_TABLE_RED_SIZE 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF #define GL_CONSTANT_BORDER 0x8151 #define GL_REPLICATE_BORDER 0x8153 #define GL_CONVOLUTION_BORDER_COLOR 0x8154 #endif #ifndef GL_VERSION_1_3 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_MULTISAMPLE 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLES 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_MULTISAMPLE_BIT 0x20000000 #define GL_NORMAL_MAP 0x8511 #define GL_REFLECTION_MAP 0x8512 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_CLAMP_TO_BORDER 0x812D #define GL_COMBINE 0x8570 #define GL_COMBINE_RGB 0x8571 #define GL_COMBINE_ALPHA 0x8572 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_RGB 0x8582 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE2_ALPHA 0x858A #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_RGB 0x8592 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND2_ALPHA 0x859A #define GL_RGB_SCALE 0x8573 #define GL_ADD_SIGNED 0x8574 #define GL_INTERPOLATE 0x8575 #define GL_SUBTRACT 0x84E7 #define GL_CONSTANT 0x8576 #define GL_PRIMARY_COLOR 0x8577 #define GL_PREVIOUS 0x8578 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #endif #ifndef GL_VERSION_1_4 #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_MIRRORED_REPEAT 0x8370 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORDINATE 0x8451 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_COLOR_SUM 0x8458 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_INCR_WRAP 0x8507 #define GL_DECR_WRAP 0x8508 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_R_TO_TEXTURE 0x884E #endif #ifndef GL_VERSION_1_5 #define GL_BUFFER_SIZE 0x8764 #define GL_BUFFER_USAGE 0x8765 #define GL_QUERY_COUNTER_BITS 0x8864 #define GL_CURRENT_QUERY 0x8865 #define GL_QUERY_RESULT 0x8866 #define GL_QUERY_RESULT_AVAILABLE 0x8867 #define GL_ARRAY_BUFFER 0x8892 #define GL_ELEMENT_ARRAY_BUFFER 0x8893 #define GL_ARRAY_BUFFER_BINDING 0x8894 #define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 #define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 #define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 #define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 #define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D #define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F #define GL_READ_ONLY 0x88B8 #define GL_WRITE_ONLY 0x88B9 #define GL_READ_WRITE 0x88BA #define GL_BUFFER_ACCESS 0x88BB #define GL_BUFFER_MAPPED 0x88BC #define GL_BUFFER_MAP_POINTER 0x88BD #define GL_STREAM_DRAW 0x88E0 #define GL_STREAM_READ 0x88E1 #define GL_STREAM_COPY 0x88E2 #define GL_STATIC_DRAW 0x88E4 #define GL_STATIC_READ 0x88E5 #define GL_STATIC_COPY 0x88E6 #define GL_DYNAMIC_DRAW 0x88E8 #define GL_DYNAMIC_READ 0x88E9 #define GL_DYNAMIC_COPY 0x88EA #define GL_SAMPLES_PASSED 0x8914 #define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE #define GL_FOG_COORD GL_FOG_COORDINATE #define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE #define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE #define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE #define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER #define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY #define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING #define GL_SRC0_RGB GL_SOURCE0_RGB #define GL_SRC1_RGB GL_SOURCE1_RGB #define GL_SRC2_RGB GL_SOURCE2_RGB #define GL_SRC0_ALPHA GL_SOURCE0_ALPHA #define GL_SRC1_ALPHA GL_SOURCE1_ALPHA #define GL_SRC2_ALPHA GL_SOURCE2_ALPHA #endif #ifndef GL_VERSION_2_0 #define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION #define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 #define GL_CURRENT_VERTEX_ATTRIB 0x8626 #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 #define GL_STENCIL_BACK_FUNC 0x8800 #define GL_STENCIL_BACK_FAIL 0x8801 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 #define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 #define GL_MAX_DRAW_BUFFERS 0x8824 #define GL_DRAW_BUFFER0 0x8825 #define GL_DRAW_BUFFER1 0x8826 #define GL_DRAW_BUFFER2 0x8827 #define GL_DRAW_BUFFER3 0x8828 #define GL_DRAW_BUFFER4 0x8829 #define GL_DRAW_BUFFER5 0x882A #define GL_DRAW_BUFFER6 0x882B #define GL_DRAW_BUFFER7 0x882C #define GL_DRAW_BUFFER8 0x882D #define GL_DRAW_BUFFER9 0x882E #define GL_DRAW_BUFFER10 0x882F #define GL_DRAW_BUFFER11 0x8830 #define GL_DRAW_BUFFER12 0x8831 #define GL_DRAW_BUFFER13 0x8832 #define GL_DRAW_BUFFER14 0x8833 #define GL_DRAW_BUFFER15 0x8834 #define GL_BLEND_EQUATION_ALPHA 0x883D #define GL_POINT_SPRITE 0x8861 #define GL_COORD_REPLACE 0x8862 #define GL_MAX_VERTEX_ATTRIBS 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A #define GL_MAX_TEXTURE_COORDS 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 #define GL_FRAGMENT_SHADER 0x8B30 #define GL_VERTEX_SHADER 0x8B31 #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 #define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A #define GL_MAX_VARYING_FLOATS 0x8B4B #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D #define GL_SHADER_TYPE 0x8B4F #define GL_FLOAT_VEC2 0x8B50 #define GL_FLOAT_VEC3 0x8B51 #define GL_FLOAT_VEC4 0x8B52 #define GL_INT_VEC2 0x8B53 #define GL_INT_VEC3 0x8B54 #define GL_INT_VEC4 0x8B55 #define GL_BOOL 0x8B56 #define GL_BOOL_VEC2 0x8B57 #define GL_BOOL_VEC3 0x8B58 #define GL_BOOL_VEC4 0x8B59 #define GL_FLOAT_MAT2 0x8B5A #define GL_FLOAT_MAT3 0x8B5B #define GL_FLOAT_MAT4 0x8B5C #define GL_SAMPLER_1D 0x8B5D #define GL_SAMPLER_2D 0x8B5E #define GL_SAMPLER_3D 0x8B5F #define GL_SAMPLER_CUBE 0x8B60 #define GL_SAMPLER_1D_SHADOW 0x8B61 #define GL_SAMPLER_2D_SHADOW 0x8B62 #define GL_DELETE_STATUS 0x8B80 #define GL_COMPILE_STATUS 0x8B81 #define GL_LINK_STATUS 0x8B82 #define GL_VALIDATE_STATUS 0x8B83 #define GL_INFO_LOG_LENGTH 0x8B84 #define GL_ATTACHED_SHADERS 0x8B85 #define GL_ACTIVE_UNIFORMS 0x8B86 #define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 #define GL_SHADER_SOURCE_LENGTH 0x8B88 #define GL_ACTIVE_ATTRIBUTES 0x8B89 #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B #define GL_SHADING_LANGUAGE_VERSION 0x8B8C #define GL_CURRENT_PROGRAM 0x8B8D #define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 #define GL_LOWER_LEFT 0x8CA1 #define GL_UPPER_LEFT 0x8CA2 #define GL_STENCIL_BACK_REF 0x8CA3 #define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 #define GL_STENCIL_BACK_WRITEMASK 0x8CA5 #endif #ifndef GL_ARB_multitexture #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 #define GL_TEXTURE2_ARB 0x84C2 #define GL_TEXTURE3_ARB 0x84C3 #define GL_TEXTURE4_ARB 0x84C4 #define GL_TEXTURE5_ARB 0x84C5 #define GL_TEXTURE6_ARB 0x84C6 #define GL_TEXTURE7_ARB 0x84C7 #define GL_TEXTURE8_ARB 0x84C8 #define GL_TEXTURE9_ARB 0x84C9 #define GL_TEXTURE10_ARB 0x84CA #define GL_TEXTURE11_ARB 0x84CB #define GL_TEXTURE12_ARB 0x84CC #define GL_TEXTURE13_ARB 0x84CD #define GL_TEXTURE14_ARB 0x84CE #define GL_TEXTURE15_ARB 0x84CF #define GL_TEXTURE16_ARB 0x84D0 #define GL_TEXTURE17_ARB 0x84D1 #define GL_TEXTURE18_ARB 0x84D2 #define GL_TEXTURE19_ARB 0x84D3 #define GL_TEXTURE20_ARB 0x84D4 #define GL_TEXTURE21_ARB 0x84D5 #define GL_TEXTURE22_ARB 0x84D6 #define GL_TEXTURE23_ARB 0x84D7 #define GL_TEXTURE24_ARB 0x84D8 #define GL_TEXTURE25_ARB 0x84D9 #define GL_TEXTURE26_ARB 0x84DA #define GL_TEXTURE27_ARB 0x84DB #define GL_TEXTURE28_ARB 0x84DC #define GL_TEXTURE29_ARB 0x84DD #define GL_TEXTURE30_ARB 0x84DE #define GL_TEXTURE31_ARB 0x84DF #define GL_ACTIVE_TEXTURE_ARB 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 #endif #ifndef GL_ARB_transpose_matrix #define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX_ARB 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX_ARB 0x84E6 #endif #ifndef GL_ARB_multisample #define GL_MULTISAMPLE_ARB 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E #define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F #define GL_SAMPLE_COVERAGE_ARB 0x80A0 #define GL_SAMPLE_BUFFERS_ARB 0x80A8 #define GL_SAMPLES_ARB 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA #define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB #define GL_MULTISAMPLE_BIT_ARB 0x20000000 #endif #ifndef GL_ARB_texture_env_add #endif #ifndef GL_ARB_texture_cube_map #define GL_NORMAL_MAP_ARB 0x8511 #define GL_REFLECTION_MAP_ARB 0x8512 #define GL_TEXTURE_CUBE_MAP_ARB 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C #endif #ifndef GL_ARB_texture_compression #define GL_COMPRESSED_ALPHA_ARB 0x84E9 #define GL_COMPRESSED_LUMINANCE_ARB 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB #define GL_COMPRESSED_INTENSITY_ARB 0x84EC #define GL_COMPRESSED_RGB_ARB 0x84ED #define GL_COMPRESSED_RGBA_ARB 0x84EE #define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0 #define GL_TEXTURE_COMPRESSED_ARB 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3 #endif #ifndef GL_ARB_texture_border_clamp #define GL_CLAMP_TO_BORDER_ARB 0x812D #endif #ifndef GL_ARB_point_parameters #define GL_POINT_SIZE_MIN_ARB 0x8126 #define GL_POINT_SIZE_MAX_ARB 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128 #define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129 #endif #ifndef GL_ARB_vertex_blend #define GL_MAX_VERTEX_UNITS_ARB 0x86A4 #define GL_ACTIVE_VERTEX_UNITS_ARB 0x86A5 #define GL_WEIGHT_SUM_UNITY_ARB 0x86A6 #define GL_VERTEX_BLEND_ARB 0x86A7 #define GL_CURRENT_WEIGHT_ARB 0x86A8 #define GL_WEIGHT_ARRAY_TYPE_ARB 0x86A9 #define GL_WEIGHT_ARRAY_STRIDE_ARB 0x86AA #define GL_WEIGHT_ARRAY_SIZE_ARB 0x86AB #define GL_WEIGHT_ARRAY_POINTER_ARB 0x86AC #define GL_WEIGHT_ARRAY_ARB 0x86AD #define GL_MODELVIEW0_ARB 0x1700 #define GL_MODELVIEW1_ARB 0x850A #define GL_MODELVIEW2_ARB 0x8722 #define GL_MODELVIEW3_ARB 0x8723 #define GL_MODELVIEW4_ARB 0x8724 #define GL_MODELVIEW5_ARB 0x8725 #define GL_MODELVIEW6_ARB 0x8726 #define GL_MODELVIEW7_ARB 0x8727 #define GL_MODELVIEW8_ARB 0x8728 #define GL_MODELVIEW9_ARB 0x8729 #define GL_MODELVIEW10_ARB 0x872A #define GL_MODELVIEW11_ARB 0x872B #define GL_MODELVIEW12_ARB 0x872C #define GL_MODELVIEW13_ARB 0x872D #define GL_MODELVIEW14_ARB 0x872E #define GL_MODELVIEW15_ARB 0x872F #define GL_MODELVIEW16_ARB 0x8730 #define GL_MODELVIEW17_ARB 0x8731 #define GL_MODELVIEW18_ARB 0x8732 #define GL_MODELVIEW19_ARB 0x8733 #define GL_MODELVIEW20_ARB 0x8734 #define GL_MODELVIEW21_ARB 0x8735 #define GL_MODELVIEW22_ARB 0x8736 #define GL_MODELVIEW23_ARB 0x8737 #define GL_MODELVIEW24_ARB 0x8738 #define GL_MODELVIEW25_ARB 0x8739 #define GL_MODELVIEW26_ARB 0x873A #define GL_MODELVIEW27_ARB 0x873B #define GL_MODELVIEW28_ARB 0x873C #define GL_MODELVIEW29_ARB 0x873D #define GL_MODELVIEW30_ARB 0x873E #define GL_MODELVIEW31_ARB 0x873F #endif #ifndef GL_ARB_matrix_palette #define GL_MATRIX_PALETTE_ARB 0x8840 #define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841 #define GL_MAX_PALETTE_MATRICES_ARB 0x8842 #define GL_CURRENT_PALETTE_MATRIX_ARB 0x8843 #define GL_MATRIX_INDEX_ARRAY_ARB 0x8844 #define GL_CURRENT_MATRIX_INDEX_ARB 0x8845 #define GL_MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846 #define GL_MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847 #define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848 #define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849 #endif #ifndef GL_ARB_texture_env_combine #define GL_COMBINE_ARB 0x8570 #define GL_COMBINE_RGB_ARB 0x8571 #define GL_COMBINE_ALPHA_ARB 0x8572 #define GL_SOURCE0_RGB_ARB 0x8580 #define GL_SOURCE1_RGB_ARB 0x8581 #define GL_SOURCE2_RGB_ARB 0x8582 #define GL_SOURCE0_ALPHA_ARB 0x8588 #define GL_SOURCE1_ALPHA_ARB 0x8589 #define GL_SOURCE2_ALPHA_ARB 0x858A #define GL_OPERAND0_RGB_ARB 0x8590 #define GL_OPERAND1_RGB_ARB 0x8591 #define GL_OPERAND2_RGB_ARB 0x8592 #define GL_OPERAND0_ALPHA_ARB 0x8598 #define GL_OPERAND1_ALPHA_ARB 0x8599 #define GL_OPERAND2_ALPHA_ARB 0x859A #define GL_RGB_SCALE_ARB 0x8573 #define GL_ADD_SIGNED_ARB 0x8574 #define GL_INTERPOLATE_ARB 0x8575 #define GL_SUBTRACT_ARB 0x84E7 #define GL_CONSTANT_ARB 0x8576 #define GL_PRIMARY_COLOR_ARB 0x8577 #define GL_PREVIOUS_ARB 0x8578 #endif #ifndef GL_ARB_texture_env_crossbar #endif #ifndef GL_ARB_texture_env_dot3 #define GL_DOT3_RGB_ARB 0x86AE #define GL_DOT3_RGBA_ARB 0x86AF #endif #ifndef GL_ARB_texture_mirrored_repeat #define GL_MIRRORED_REPEAT_ARB 0x8370 #endif #ifndef GL_ARB_depth_texture #define GL_DEPTH_COMPONENT16_ARB 0x81A5 #define GL_DEPTH_COMPONENT24_ARB 0x81A6 #define GL_DEPTH_COMPONENT32_ARB 0x81A7 #define GL_TEXTURE_DEPTH_SIZE_ARB 0x884A #define GL_DEPTH_TEXTURE_MODE_ARB 0x884B #endif #ifndef GL_ARB_shadow #define GL_TEXTURE_COMPARE_MODE_ARB 0x884C #define GL_TEXTURE_COMPARE_FUNC_ARB 0x884D #define GL_COMPARE_R_TO_TEXTURE_ARB 0x884E #endif #ifndef GL_ARB_shadow_ambient #define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF #endif #ifndef GL_ARB_window_pos #endif #ifndef GL_ARB_vertex_program #define GL_COLOR_SUM_ARB 0x8458 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF #endif #ifndef GL_ARB_fragment_program #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #endif #ifndef GL_ARB_vertex_buffer_object #define GL_BUFFER_SIZE_ARB 0x8764 #define GL_BUFFER_USAGE_ARB 0x8765 #define GL_ARRAY_BUFFER_ARB 0x8892 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893 #define GL_ARRAY_BUFFER_BINDING_ARB 0x8894 #define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895 #define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896 #define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897 #define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898 #define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D #define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F #define GL_READ_ONLY_ARB 0x88B8 #define GL_WRITE_ONLY_ARB 0x88B9 #define GL_READ_WRITE_ARB 0x88BA #define GL_BUFFER_ACCESS_ARB 0x88BB #define GL_BUFFER_MAPPED_ARB 0x88BC #define GL_BUFFER_MAP_POINTER_ARB 0x88BD #define GL_STREAM_DRAW_ARB 0x88E0 #define GL_STREAM_READ_ARB 0x88E1 #define GL_STREAM_COPY_ARB 0x88E2 #define GL_STATIC_DRAW_ARB 0x88E4 #define GL_STATIC_READ_ARB 0x88E5 #define GL_STATIC_COPY_ARB 0x88E6 #define GL_DYNAMIC_DRAW_ARB 0x88E8 #define GL_DYNAMIC_READ_ARB 0x88E9 #define GL_DYNAMIC_COPY_ARB 0x88EA #endif #ifndef GL_ARB_occlusion_query #define GL_QUERY_COUNTER_BITS_ARB 0x8864 #define GL_CURRENT_QUERY_ARB 0x8865 #define GL_QUERY_RESULT_ARB 0x8866 #define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867 #define GL_SAMPLES_PASSED_ARB 0x8914 #endif #ifndef GL_ARB_shader_objects #define GL_PROGRAM_OBJECT_ARB 0x8B40 #define GL_SHADER_OBJECT_ARB 0x8B48 #define GL_OBJECT_TYPE_ARB 0x8B4E #define GL_OBJECT_SUBTYPE_ARB 0x8B4F #define GL_FLOAT_VEC2_ARB 0x8B50 #define GL_FLOAT_VEC3_ARB 0x8B51 #define GL_FLOAT_VEC4_ARB 0x8B52 #define GL_INT_VEC2_ARB 0x8B53 #define GL_INT_VEC3_ARB 0x8B54 #define GL_INT_VEC4_ARB 0x8B55 #define GL_BOOL_ARB 0x8B56 #define GL_BOOL_VEC2_ARB 0x8B57 #define GL_BOOL_VEC3_ARB 0x8B58 #define GL_BOOL_VEC4_ARB 0x8B59 #define GL_FLOAT_MAT2_ARB 0x8B5A #define GL_FLOAT_MAT3_ARB 0x8B5B #define GL_FLOAT_MAT4_ARB 0x8B5C #define GL_SAMPLER_1D_ARB 0x8B5D #define GL_SAMPLER_2D_ARB 0x8B5E #define GL_SAMPLER_3D_ARB 0x8B5F #define GL_SAMPLER_CUBE_ARB 0x8B60 #define GL_SAMPLER_1D_SHADOW_ARB 0x8B61 #define GL_SAMPLER_2D_SHADOW_ARB 0x8B62 #define GL_SAMPLER_2D_RECT_ARB 0x8B63 #define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 #define GL_OBJECT_DELETE_STATUS_ARB 0x8B80 #define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81 #define GL_OBJECT_LINK_STATUS_ARB 0x8B82 #define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83 #define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84 #define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85 #define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86 #define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87 #define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88 #endif #ifndef GL_ARB_vertex_shader #define GL_VERTEX_SHADER_ARB 0x8B31 #define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A #define GL_MAX_VARYING_FLOATS_ARB 0x8B4B #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D #define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89 #define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A #endif #ifndef GL_ARB_fragment_shader #define GL_FRAGMENT_SHADER_ARB 0x8B30 #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49 #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B #endif #ifndef GL_ARB_shading_language_100 #define GL_SHADING_LANGUAGE_VERSION_ARB 0x8B8C #endif #ifndef GL_ARB_texture_non_power_of_two #endif #ifndef GL_ARB_point_sprite #define GL_POINT_SPRITE_ARB 0x8861 #define GL_COORD_REPLACE_ARB 0x8862 #endif #ifndef GL_ARB_fragment_program_shadow #endif #ifndef GL_ARB_draw_buffers #define GL_MAX_DRAW_BUFFERS_ARB 0x8824 #define GL_DRAW_BUFFER0_ARB 0x8825 #define GL_DRAW_BUFFER1_ARB 0x8826 #define GL_DRAW_BUFFER2_ARB 0x8827 #define GL_DRAW_BUFFER3_ARB 0x8828 #define GL_DRAW_BUFFER4_ARB 0x8829 #define GL_DRAW_BUFFER5_ARB 0x882A #define GL_DRAW_BUFFER6_ARB 0x882B #define GL_DRAW_BUFFER7_ARB 0x882C #define GL_DRAW_BUFFER8_ARB 0x882D #define GL_DRAW_BUFFER9_ARB 0x882E #define GL_DRAW_BUFFER10_ARB 0x882F #define GL_DRAW_BUFFER11_ARB 0x8830 #define GL_DRAW_BUFFER12_ARB 0x8831 #define GL_DRAW_BUFFER13_ARB 0x8832 #define GL_DRAW_BUFFER14_ARB 0x8833 #define GL_DRAW_BUFFER15_ARB 0x8834 #endif #ifndef GL_ARB_texture_rectangle #define GL_TEXTURE_RECTANGLE_ARB 0x84F5 #define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6 #define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 #endif #ifndef GL_ARB_color_buffer_float #define GL_RGBA_FLOAT_MODE_ARB 0x8820 #define GL_CLAMP_VERTEX_COLOR_ARB 0x891A #define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B #define GL_CLAMP_READ_COLOR_ARB 0x891C #define GL_FIXED_ONLY_ARB 0x891D #endif #ifndef GL_ARB_half_float_pixel #define GL_HALF_FLOAT_ARB 0x140B #endif #ifndef GL_ARB_texture_float #define GL_TEXTURE_RED_TYPE_ARB 0x8C10 #define GL_TEXTURE_GREEN_TYPE_ARB 0x8C11 #define GL_TEXTURE_BLUE_TYPE_ARB 0x8C12 #define GL_TEXTURE_ALPHA_TYPE_ARB 0x8C13 #define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x8C14 #define GL_TEXTURE_INTENSITY_TYPE_ARB 0x8C15 #define GL_TEXTURE_DEPTH_TYPE_ARB 0x8C16 #define GL_UNSIGNED_NORMALIZED_ARB 0x8C17 #define GL_RGBA32F_ARB 0x8814 #define GL_RGB32F_ARB 0x8815 #define GL_ALPHA32F_ARB 0x8816 #define GL_INTENSITY32F_ARB 0x8817 #define GL_LUMINANCE32F_ARB 0x8818 #define GL_LUMINANCE_ALPHA32F_ARB 0x8819 #define GL_RGBA16F_ARB 0x881A #define GL_RGB16F_ARB 0x881B #define GL_ALPHA16F_ARB 0x881C #define GL_INTENSITY16F_ARB 0x881D #define GL_LUMINANCE16F_ARB 0x881E #define GL_LUMINANCE_ALPHA16F_ARB 0x881F #endif #ifndef GL_ARB_pixel_buffer_object #define GL_PIXEL_PACK_BUFFER_ARB 0x88EB #define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC #define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED #define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF #endif #ifndef GL_EXT_abgr #define GL_ABGR_EXT 0x8000 #endif #ifndef GL_EXT_blend_color #define GL_CONSTANT_COLOR_EXT 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002 #define GL_CONSTANT_ALPHA_EXT 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004 #define GL_BLEND_COLOR_EXT 0x8005 #endif #ifndef GL_EXT_polygon_offset #define GL_POLYGON_OFFSET_EXT 0x8037 #define GL_POLYGON_OFFSET_FACTOR_EXT 0x8038 #define GL_POLYGON_OFFSET_BIAS_EXT 0x8039 #endif #ifndef GL_EXT_texture #define GL_ALPHA4_EXT 0x803B #define GL_ALPHA8_EXT 0x803C #define GL_ALPHA12_EXT 0x803D #define GL_ALPHA16_EXT 0x803E #define GL_LUMINANCE4_EXT 0x803F #define GL_LUMINANCE8_EXT 0x8040 #define GL_LUMINANCE12_EXT 0x8041 #define GL_LUMINANCE16_EXT 0x8042 #define GL_LUMINANCE4_ALPHA4_EXT 0x8043 #define GL_LUMINANCE6_ALPHA2_EXT 0x8044 #define GL_LUMINANCE8_ALPHA8_EXT 0x8045 #define GL_LUMINANCE12_ALPHA4_EXT 0x8046 #define GL_LUMINANCE12_ALPHA12_EXT 0x8047 #define GL_LUMINANCE16_ALPHA16_EXT 0x8048 #define GL_INTENSITY_EXT 0x8049 #define GL_INTENSITY4_EXT 0x804A #define GL_INTENSITY8_EXT 0x804B #define GL_INTENSITY12_EXT 0x804C #define GL_INTENSITY16_EXT 0x804D #define GL_RGB2_EXT 0x804E #define GL_RGB4_EXT 0x804F #define GL_RGB5_EXT 0x8050 #define GL_RGB8_EXT 0x8051 #define GL_RGB10_EXT 0x8052 #define GL_RGB12_EXT 0x8053 #define GL_RGB16_EXT 0x8054 #define GL_RGBA2_EXT 0x8055 #define GL_RGBA4_EXT 0x8056 #define GL_RGB5_A1_EXT 0x8057 #define GL_RGBA8_EXT 0x8058 #define GL_RGB10_A2_EXT 0x8059 #define GL_RGBA12_EXT 0x805A #define GL_RGBA16_EXT 0x805B #define GL_TEXTURE_RED_SIZE_EXT 0x805C #define GL_TEXTURE_GREEN_SIZE_EXT 0x805D #define GL_TEXTURE_BLUE_SIZE_EXT 0x805E #define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F #define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060 #define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061 #define GL_REPLACE_EXT 0x8062 #define GL_PROXY_TEXTURE_1D_EXT 0x8063 #define GL_PROXY_TEXTURE_2D_EXT 0x8064 #define GL_TEXTURE_TOO_LARGE_EXT 0x8065 #endif #ifndef GL_EXT_texture3D #define GL_PACK_SKIP_IMAGES_EXT 0x806B #define GL_PACK_IMAGE_HEIGHT_EXT 0x806C #define GL_UNPACK_SKIP_IMAGES_EXT 0x806D #define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E #define GL_TEXTURE_3D_EXT 0x806F #define GL_PROXY_TEXTURE_3D_EXT 0x8070 #define GL_TEXTURE_DEPTH_EXT 0x8071 #define GL_TEXTURE_WRAP_R_EXT 0x8072 #define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 #endif #ifndef GL_SGIS_texture_filter4 #define GL_FILTER4_SGIS 0x8146 #define GL_TEXTURE_FILTER4_SIZE_SGIS 0x8147 #endif #ifndef GL_EXT_subtexture #endif #ifndef GL_EXT_copy_texture #endif #ifndef GL_EXT_histogram #define GL_HISTOGRAM_EXT 0x8024 #define GL_PROXY_HISTOGRAM_EXT 0x8025 #define GL_HISTOGRAM_WIDTH_EXT 0x8026 #define GL_HISTOGRAM_FORMAT_EXT 0x8027 #define GL_HISTOGRAM_RED_SIZE_EXT 0x8028 #define GL_HISTOGRAM_GREEN_SIZE_EXT 0x8029 #define GL_HISTOGRAM_BLUE_SIZE_EXT 0x802A #define GL_HISTOGRAM_ALPHA_SIZE_EXT 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE_EXT 0x802C #define GL_HISTOGRAM_SINK_EXT 0x802D #define GL_MINMAX_EXT 0x802E #define GL_MINMAX_FORMAT_EXT 0x802F #define GL_MINMAX_SINK_EXT 0x8030 #define GL_TABLE_TOO_LARGE_EXT 0x8031 #endif #ifndef GL_EXT_convolution #define GL_CONVOLUTION_1D_EXT 0x8010 #define GL_CONVOLUTION_2D_EXT 0x8011 #define GL_SEPARABLE_2D_EXT 0x8012 #define GL_CONVOLUTION_BORDER_MODE_EXT 0x8013 #define GL_CONVOLUTION_FILTER_SCALE_EXT 0x8014 #define GL_CONVOLUTION_FILTER_BIAS_EXT 0x8015 #define GL_REDUCE_EXT 0x8016 #define GL_CONVOLUTION_FORMAT_EXT 0x8017 #define GL_CONVOLUTION_WIDTH_EXT 0x8018 #define GL_CONVOLUTION_HEIGHT_EXT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH_EXT 0x801A #define GL_MAX_CONVOLUTION_HEIGHT_EXT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F #define GL_POST_CONVOLUTION_RED_BIAS_EXT 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023 #endif #ifndef GL_SGI_color_matrix #define GL_COLOR_MATRIX_SGI 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB #endif #ifndef GL_SGI_color_table #define GL_COLOR_TABLE_SGI 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 #define GL_PROXY_COLOR_TABLE_SGI 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 #define GL_COLOR_TABLE_SCALE_SGI 0x80D6 #define GL_COLOR_TABLE_BIAS_SGI 0x80D7 #define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 #define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF #endif #ifndef GL_SGIS_pixel_texture #define GL_PIXEL_TEXTURE_SGIS 0x8353 #define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354 #define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355 #define GL_PIXEL_GROUP_COLOR_SGIS 0x8356 #endif #ifndef GL_SGIX_pixel_texture #define GL_PIXEL_TEX_GEN_SGIX 0x8139 #define GL_PIXEL_TEX_GEN_MODE_SGIX 0x832B #endif #ifndef GL_SGIS_texture4D #define GL_PACK_SKIP_VOLUMES_SGIS 0x8130 #define GL_PACK_IMAGE_DEPTH_SGIS 0x8131 #define GL_UNPACK_SKIP_VOLUMES_SGIS 0x8132 #define GL_UNPACK_IMAGE_DEPTH_SGIS 0x8133 #define GL_TEXTURE_4D_SGIS 0x8134 #define GL_PROXY_TEXTURE_4D_SGIS 0x8135 #define GL_TEXTURE_4DSIZE_SGIS 0x8136 #define GL_TEXTURE_WRAP_Q_SGIS 0x8137 #define GL_MAX_4D_TEXTURE_SIZE_SGIS 0x8138 #define GL_TEXTURE_4D_BINDING_SGIS 0x814F #endif #ifndef GL_SGI_texture_color_table #define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC #define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD #endif #ifndef GL_EXT_cmyka #define GL_CMYK_EXT 0x800C #define GL_CMYKA_EXT 0x800D #define GL_PACK_CMYK_HINT_EXT 0x800E #define GL_UNPACK_CMYK_HINT_EXT 0x800F #endif #ifndef GL_EXT_texture_object #define GL_TEXTURE_PRIORITY_EXT 0x8066 #define GL_TEXTURE_RESIDENT_EXT 0x8067 #define GL_TEXTURE_1D_BINDING_EXT 0x8068 #define GL_TEXTURE_2D_BINDING_EXT 0x8069 #define GL_TEXTURE_3D_BINDING_EXT 0x806A #endif #ifndef GL_SGIS_detail_texture #define GL_DETAIL_TEXTURE_2D_SGIS 0x8095 #define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096 #define GL_LINEAR_DETAIL_SGIS 0x8097 #define GL_LINEAR_DETAIL_ALPHA_SGIS 0x8098 #define GL_LINEAR_DETAIL_COLOR_SGIS 0x8099 #define GL_DETAIL_TEXTURE_LEVEL_SGIS 0x809A #define GL_DETAIL_TEXTURE_MODE_SGIS 0x809B #define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C #endif #ifndef GL_SGIS_sharpen_texture #define GL_LINEAR_SHARPEN_SGIS 0x80AD #define GL_LINEAR_SHARPEN_ALPHA_SGIS 0x80AE #define GL_LINEAR_SHARPEN_COLOR_SGIS 0x80AF #define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0 #endif #ifndef GL_EXT_packed_pixels #define GL_UNSIGNED_BYTE_3_3_2_EXT 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4_EXT 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 #define GL_UNSIGNED_INT_8_8_8_8_EXT 0x8035 #define GL_UNSIGNED_INT_10_10_10_2_EXT 0x8036 #endif #ifndef GL_SGIS_texture_lod #define GL_TEXTURE_MIN_LOD_SGIS 0x813A #define GL_TEXTURE_MAX_LOD_SGIS 0x813B #define GL_TEXTURE_BASE_LEVEL_SGIS 0x813C #define GL_TEXTURE_MAX_LEVEL_SGIS 0x813D #endif #ifndef GL_SGIS_multisample #define GL_MULTISAMPLE_SGIS 0x809D #define GL_SAMPLE_ALPHA_TO_MASK_SGIS 0x809E #define GL_SAMPLE_ALPHA_TO_ONE_SGIS 0x809F #define GL_SAMPLE_MASK_SGIS 0x80A0 #define GL_1PASS_SGIS 0x80A1 #define GL_2PASS_0_SGIS 0x80A2 #define GL_2PASS_1_SGIS 0x80A3 #define GL_4PASS_0_SGIS 0x80A4 #define GL_4PASS_1_SGIS 0x80A5 #define GL_4PASS_2_SGIS 0x80A6 #define GL_4PASS_3_SGIS 0x80A7 #define GL_SAMPLE_BUFFERS_SGIS 0x80A8 #define GL_SAMPLES_SGIS 0x80A9 #define GL_SAMPLE_MASK_VALUE_SGIS 0x80AA #define GL_SAMPLE_MASK_INVERT_SGIS 0x80AB #define GL_SAMPLE_PATTERN_SGIS 0x80AC #endif #ifndef GL_EXT_rescale_normal #define GL_RESCALE_NORMAL_EXT 0x803A #endif #ifndef GL_EXT_vertex_array #define GL_VERTEX_ARRAY_EXT 0x8074 #define GL_NORMAL_ARRAY_EXT 0x8075 #define GL_COLOR_ARRAY_EXT 0x8076 #define GL_INDEX_ARRAY_EXT 0x8077 #define GL_TEXTURE_COORD_ARRAY_EXT 0x8078 #define GL_EDGE_FLAG_ARRAY_EXT 0x8079 #define GL_VERTEX_ARRAY_SIZE_EXT 0x807A #define GL_VERTEX_ARRAY_TYPE_EXT 0x807B #define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C #define GL_VERTEX_ARRAY_COUNT_EXT 0x807D #define GL_NORMAL_ARRAY_TYPE_EXT 0x807E #define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F #define GL_NORMAL_ARRAY_COUNT_EXT 0x8080 #define GL_COLOR_ARRAY_SIZE_EXT 0x8081 #define GL_COLOR_ARRAY_TYPE_EXT 0x8082 #define GL_COLOR_ARRAY_STRIDE_EXT 0x8083 #define GL_COLOR_ARRAY_COUNT_EXT 0x8084 #define GL_INDEX_ARRAY_TYPE_EXT 0x8085 #define GL_INDEX_ARRAY_STRIDE_EXT 0x8086 #define GL_INDEX_ARRAY_COUNT_EXT 0x8087 #define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 #define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 #define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A #define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B #define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C #define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D #define GL_VERTEX_ARRAY_POINTER_EXT 0x808E #define GL_NORMAL_ARRAY_POINTER_EXT 0x808F #define GL_COLOR_ARRAY_POINTER_EXT 0x8090 #define GL_INDEX_ARRAY_POINTER_EXT 0x8091 #define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 #define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 #endif #ifndef GL_EXT_misc_attribute #endif #ifndef GL_SGIS_generate_mipmap #define GL_GENERATE_MIPMAP_SGIS 0x8191 #define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192 #endif #ifndef GL_SGIX_clipmap #define GL_LINEAR_CLIPMAP_LINEAR_SGIX 0x8170 #define GL_TEXTURE_CLIPMAP_CENTER_SGIX 0x8171 #define GL_TEXTURE_CLIPMAP_FRAME_SGIX 0x8172 #define GL_TEXTURE_CLIPMAP_OFFSET_SGIX 0x8173 #define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174 #define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175 #define GL_TEXTURE_CLIPMAP_DEPTH_SGIX 0x8176 #define GL_MAX_CLIPMAP_DEPTH_SGIX 0x8177 #define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178 #define GL_NEAREST_CLIPMAP_NEAREST_SGIX 0x844D #define GL_NEAREST_CLIPMAP_LINEAR_SGIX 0x844E #define GL_LINEAR_CLIPMAP_NEAREST_SGIX 0x844F #endif #ifndef GL_SGIX_shadow #define GL_TEXTURE_COMPARE_SGIX 0x819A #define GL_TEXTURE_COMPARE_OPERATOR_SGIX 0x819B #define GL_TEXTURE_LEQUAL_R_SGIX 0x819C #define GL_TEXTURE_GEQUAL_R_SGIX 0x819D #endif #ifndef GL_SGIS_texture_edge_clamp #define GL_CLAMP_TO_EDGE_SGIS 0x812F #endif #ifndef GL_SGIS_texture_border_clamp #define GL_CLAMP_TO_BORDER_SGIS 0x812D #endif #ifndef GL_EXT_blend_minmax #define GL_FUNC_ADD_EXT 0x8006 #define GL_MIN_EXT 0x8007 #define GL_MAX_EXT 0x8008 #define GL_BLEND_EQUATION_EXT 0x8009 #endif #ifndef GL_EXT_blend_subtract #define GL_FUNC_SUBTRACT_EXT 0x800A #define GL_FUNC_REVERSE_SUBTRACT_EXT 0x800B #endif #ifndef GL_EXT_blend_logic_op #endif #ifndef GL_SGIX_interlace #define GL_INTERLACE_SGIX 0x8094 #endif #ifndef GL_SGIX_pixel_tiles #define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E #define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F #define GL_PIXEL_TILE_WIDTH_SGIX 0x8140 #define GL_PIXEL_TILE_HEIGHT_SGIX 0x8141 #define GL_PIXEL_TILE_GRID_WIDTH_SGIX 0x8142 #define GL_PIXEL_TILE_GRID_HEIGHT_SGIX 0x8143 #define GL_PIXEL_TILE_GRID_DEPTH_SGIX 0x8144 #define GL_PIXEL_TILE_CACHE_SIZE_SGIX 0x8145 #endif #ifndef GL_SGIS_texture_select #define GL_DUAL_ALPHA4_SGIS 0x8110 #define GL_DUAL_ALPHA8_SGIS 0x8111 #define GL_DUAL_ALPHA12_SGIS 0x8112 #define GL_DUAL_ALPHA16_SGIS 0x8113 #define GL_DUAL_LUMINANCE4_SGIS 0x8114 #define GL_DUAL_LUMINANCE8_SGIS 0x8115 #define GL_DUAL_LUMINANCE12_SGIS 0x8116 #define GL_DUAL_LUMINANCE16_SGIS 0x8117 #define GL_DUAL_INTENSITY4_SGIS 0x8118 #define GL_DUAL_INTENSITY8_SGIS 0x8119 #define GL_DUAL_INTENSITY12_SGIS 0x811A #define GL_DUAL_INTENSITY16_SGIS 0x811B #define GL_DUAL_LUMINANCE_ALPHA4_SGIS 0x811C #define GL_DUAL_LUMINANCE_ALPHA8_SGIS 0x811D #define GL_QUAD_ALPHA4_SGIS 0x811E #define GL_QUAD_ALPHA8_SGIS 0x811F #define GL_QUAD_LUMINANCE4_SGIS 0x8120 #define GL_QUAD_LUMINANCE8_SGIS 0x8121 #define GL_QUAD_INTENSITY4_SGIS 0x8122 #define GL_QUAD_INTENSITY8_SGIS 0x8123 #define GL_DUAL_TEXTURE_SELECT_SGIS 0x8124 #define GL_QUAD_TEXTURE_SELECT_SGIS 0x8125 #endif #ifndef GL_SGIX_sprite #define GL_SPRITE_SGIX 0x8148 #define GL_SPRITE_MODE_SGIX 0x8149 #define GL_SPRITE_AXIS_SGIX 0x814A #define GL_SPRITE_TRANSLATION_SGIX 0x814B #define GL_SPRITE_AXIAL_SGIX 0x814C #define GL_SPRITE_OBJECT_ALIGNED_SGIX 0x814D #define GL_SPRITE_EYE_ALIGNED_SGIX 0x814E #endif #ifndef GL_SGIX_texture_multi_buffer #define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E #endif #ifndef GL_EXT_point_parameters #define GL_POINT_SIZE_MIN_EXT 0x8126 #define GL_POINT_SIZE_MAX_EXT 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128 #define GL_DISTANCE_ATTENUATION_EXT 0x8129 #endif #ifndef GL_SGIS_point_parameters #define GL_POINT_SIZE_MIN_SGIS 0x8126 #define GL_POINT_SIZE_MAX_SGIS 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128 #define GL_DISTANCE_ATTENUATION_SGIS 0x8129 #endif #ifndef GL_SGIX_instruments #define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180 #define GL_INSTRUMENT_MEASUREMENTS_SGIX 0x8181 #endif #ifndef GL_SGIX_texture_scale_bias #define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179 #define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A #define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B #define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C #endif #ifndef GL_SGIX_framezoom #define GL_FRAMEZOOM_SGIX 0x818B #define GL_FRAMEZOOM_FACTOR_SGIX 0x818C #define GL_MAX_FRAMEZOOM_FACTOR_SGIX 0x818D #endif #ifndef GL_SGIX_tag_sample_buffer #endif #ifndef GL_FfdMaskSGIX #define GL_TEXTURE_DEFORMATION_BIT_SGIX 0x00000001 #define GL_GEOMETRY_DEFORMATION_BIT_SGIX 0x00000002 #endif #ifndef GL_SGIX_polynomial_ffd #define GL_GEOMETRY_DEFORMATION_SGIX 0x8194 #define GL_TEXTURE_DEFORMATION_SGIX 0x8195 #define GL_DEFORMATIONS_MASK_SGIX 0x8196 #define GL_MAX_DEFORMATION_ORDER_SGIX 0x8197 #endif #ifndef GL_SGIX_reference_plane #define GL_REFERENCE_PLANE_SGIX 0x817D #define GL_REFERENCE_PLANE_EQUATION_SGIX 0x817E #endif #ifndef GL_SGIX_flush_raster #endif #ifndef GL_SGIX_depth_texture #define GL_DEPTH_COMPONENT16_SGIX 0x81A5 #define GL_DEPTH_COMPONENT24_SGIX 0x81A6 #define GL_DEPTH_COMPONENT32_SGIX 0x81A7 #endif #ifndef GL_SGIS_fog_function #define GL_FOG_FUNC_SGIS 0x812A #define GL_FOG_FUNC_POINTS_SGIS 0x812B #define GL_MAX_FOG_FUNC_POINTS_SGIS 0x812C #endif #ifndef GL_SGIX_fog_offset #define GL_FOG_OFFSET_SGIX 0x8198 #define GL_FOG_OFFSET_VALUE_SGIX 0x8199 #endif #ifndef GL_HP_image_transform #define GL_IMAGE_SCALE_X_HP 0x8155 #define GL_IMAGE_SCALE_Y_HP 0x8156 #define GL_IMAGE_TRANSLATE_X_HP 0x8157 #define GL_IMAGE_TRANSLATE_Y_HP 0x8158 #define GL_IMAGE_ROTATE_ANGLE_HP 0x8159 #define GL_IMAGE_ROTATE_ORIGIN_X_HP 0x815A #define GL_IMAGE_ROTATE_ORIGIN_Y_HP 0x815B #define GL_IMAGE_MAG_FILTER_HP 0x815C #define GL_IMAGE_MIN_FILTER_HP 0x815D #define GL_IMAGE_CUBIC_WEIGHT_HP 0x815E #define GL_CUBIC_HP 0x815F #define GL_AVERAGE_HP 0x8160 #define GL_IMAGE_TRANSFORM_2D_HP 0x8161 #define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162 #define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163 #endif #ifndef GL_HP_convolution_border_modes #define GL_IGNORE_BORDER_HP 0x8150 #define GL_CONSTANT_BORDER_HP 0x8151 #define GL_REPLICATE_BORDER_HP 0x8153 #define GL_CONVOLUTION_BORDER_COLOR_HP 0x8154 #endif #ifndef GL_INGR_palette_buffer #endif #ifndef GL_SGIX_texture_add_env #define GL_TEXTURE_ENV_BIAS_SGIX 0x80BE #endif #ifndef GL_EXT_color_subtable #endif #ifndef GL_PGI_vertex_hints #define GL_VERTEX_DATA_HINT_PGI 0x1A22A #define GL_VERTEX_CONSISTENT_HINT_PGI 0x1A22B #define GL_MATERIAL_SIDE_HINT_PGI 0x1A22C #define GL_MAX_VERTEX_HINT_PGI 0x1A22D #define GL_COLOR3_BIT_PGI 0x00010000 #define GL_COLOR4_BIT_PGI 0x00020000 #define GL_EDGEFLAG_BIT_PGI 0x00040000 #define GL_INDEX_BIT_PGI 0x00080000 #define GL_MAT_AMBIENT_BIT_PGI 0x00100000 #define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000 #define GL_MAT_DIFFUSE_BIT_PGI 0x00400000 #define GL_MAT_EMISSION_BIT_PGI 0x00800000 #define GL_MAT_COLOR_INDEXES_BIT_PGI 0x01000000 #define GL_MAT_SHININESS_BIT_PGI 0x02000000 #define GL_MAT_SPECULAR_BIT_PGI 0x04000000 #define GL_NORMAL_BIT_PGI 0x08000000 #define GL_TEXCOORD1_BIT_PGI 0x10000000 #define GL_TEXCOORD2_BIT_PGI 0x20000000 #define GL_TEXCOORD3_BIT_PGI 0x40000000 #define GL_TEXCOORD4_BIT_PGI 0x80000000 #define GL_VERTEX23_BIT_PGI 0x00000004 #define GL_VERTEX4_BIT_PGI 0x00000008 #endif #ifndef GL_PGI_misc_hints #define GL_PREFER_DOUBLEBUFFER_HINT_PGI 0x1A1F8 #define GL_CONSERVE_MEMORY_HINT_PGI 0x1A1FD #define GL_RECLAIM_MEMORY_HINT_PGI 0x1A1FE #define GL_NATIVE_GRAPHICS_HANDLE_PGI 0x1A202 #define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203 #define GL_NATIVE_GRAPHICS_END_HINT_PGI 0x1A204 #define GL_ALWAYS_FAST_HINT_PGI 0x1A20C #define GL_ALWAYS_SOFT_HINT_PGI 0x1A20D #define GL_ALLOW_DRAW_OBJ_HINT_PGI 0x1A20E #define GL_ALLOW_DRAW_WIN_HINT_PGI 0x1A20F #define GL_ALLOW_DRAW_FRG_HINT_PGI 0x1A210 #define GL_ALLOW_DRAW_MEM_HINT_PGI 0x1A211 #define GL_STRICT_DEPTHFUNC_HINT_PGI 0x1A216 #define GL_STRICT_LIGHTING_HINT_PGI 0x1A217 #define GL_STRICT_SCISSOR_HINT_PGI 0x1A218 #define GL_FULL_STIPPLE_HINT_PGI 0x1A219 #define GL_CLIP_NEAR_HINT_PGI 0x1A220 #define GL_CLIP_FAR_HINT_PGI 0x1A221 #define GL_WIDE_LINE_HINT_PGI 0x1A222 #define GL_BACK_NORMALS_HINT_PGI 0x1A223 #endif #ifndef GL_EXT_paletted_texture #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED #endif #ifndef GL_EXT_clip_volume_hint #define GL_CLIP_VOLUME_CLIPPING_HINT_EXT 0x80F0 #endif #ifndef GL_SGIX_list_priority #define GL_LIST_PRIORITY_SGIX 0x8182 #endif #ifndef GL_SGIX_ir_instrument1 #define GL_IR_INSTRUMENT1_SGIX 0x817F #endif #ifndef GL_SGIX_calligraphic_fragment #define GL_CALLIGRAPHIC_FRAGMENT_SGIX 0x8183 #endif #ifndef GL_SGIX_texture_lod_bias #define GL_TEXTURE_LOD_BIAS_S_SGIX 0x818E #define GL_TEXTURE_LOD_BIAS_T_SGIX 0x818F #define GL_TEXTURE_LOD_BIAS_R_SGIX 0x8190 #endif #ifndef GL_SGIX_shadow_ambient #define GL_SHADOW_AMBIENT_SGIX 0x80BF #endif #ifndef GL_EXT_index_texture #endif #ifndef GL_EXT_index_material #define GL_INDEX_MATERIAL_EXT 0x81B8 #define GL_INDEX_MATERIAL_PARAMETER_EXT 0x81B9 #define GL_INDEX_MATERIAL_FACE_EXT 0x81BA #endif #ifndef GL_EXT_index_func #define GL_INDEX_TEST_EXT 0x81B5 #define GL_INDEX_TEST_FUNC_EXT 0x81B6 #define GL_INDEX_TEST_REF_EXT 0x81B7 #endif #ifndef GL_EXT_index_array_formats #define GL_IUI_V2F_EXT 0x81AD #define GL_IUI_V3F_EXT 0x81AE #define GL_IUI_N3F_V2F_EXT 0x81AF #define GL_IUI_N3F_V3F_EXT 0x81B0 #define GL_T2F_IUI_V2F_EXT 0x81B1 #define GL_T2F_IUI_V3F_EXT 0x81B2 #define GL_T2F_IUI_N3F_V2F_EXT 0x81B3 #define GL_T2F_IUI_N3F_V3F_EXT 0x81B4 #endif #ifndef GL_EXT_compiled_vertex_array #define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT 0x81A8 #define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT 0x81A9 #endif #ifndef GL_EXT_cull_vertex #define GL_CULL_VERTEX_EXT 0x81AA #define GL_CULL_VERTEX_EYE_POSITION_EXT 0x81AB #define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC #endif #ifndef GL_SGIX_ycrcb #define GL_YCRCB_422_SGIX 0x81BB #define GL_YCRCB_444_SGIX 0x81BC #endif #ifndef GL_SGIX_fragment_lighting #define GL_FRAGMENT_LIGHTING_SGIX 0x8400 #define GL_FRAGMENT_COLOR_MATERIAL_SGIX 0x8401 #define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402 #define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403 #define GL_MAX_FRAGMENT_LIGHTS_SGIX 0x8404 #define GL_MAX_ACTIVE_LIGHTS_SGIX 0x8405 #define GL_CURRENT_RASTER_NORMAL_SGIX 0x8406 #define GL_LIGHT_ENV_MODE_SGIX 0x8407 #define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408 #define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409 #define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A #define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B #define GL_FRAGMENT_LIGHT0_SGIX 0x840C #define GL_FRAGMENT_LIGHT1_SGIX 0x840D #define GL_FRAGMENT_LIGHT2_SGIX 0x840E #define GL_FRAGMENT_LIGHT3_SGIX 0x840F #define GL_FRAGMENT_LIGHT4_SGIX 0x8410 #define GL_FRAGMENT_LIGHT5_SGIX 0x8411 #define GL_FRAGMENT_LIGHT6_SGIX 0x8412 #define GL_FRAGMENT_LIGHT7_SGIX 0x8413 #endif #ifndef GL_IBM_rasterpos_clip #define GL_RASTER_POSITION_UNCLIPPED_IBM 0x19262 #endif #ifndef GL_HP_texture_lighting #define GL_TEXTURE_LIGHTING_MODE_HP 0x8167 #define GL_TEXTURE_POST_SPECULAR_HP 0x8168 #define GL_TEXTURE_PRE_SPECULAR_HP 0x8169 #endif #ifndef GL_EXT_draw_range_elements #define GL_MAX_ELEMENTS_VERTICES_EXT 0x80E8 #define GL_MAX_ELEMENTS_INDICES_EXT 0x80E9 #endif #ifndef GL_WIN_phong_shading #define GL_PHONG_WIN 0x80EA #define GL_PHONG_HINT_WIN 0x80EB #endif #ifndef GL_WIN_specular_fog #define GL_FOG_SPECULAR_TEXTURE_WIN 0x80EC #endif #ifndef GL_EXT_light_texture #define GL_FRAGMENT_MATERIAL_EXT 0x8349 #define GL_FRAGMENT_NORMAL_EXT 0x834A #define GL_FRAGMENT_COLOR_EXT 0x834C #define GL_ATTENUATION_EXT 0x834D #define GL_SHADOW_ATTENUATION_EXT 0x834E #define GL_TEXTURE_APPLICATION_MODE_EXT 0x834F #define GL_TEXTURE_LIGHT_EXT 0x8350 #define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351 #define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352 /* reuse GL_FRAGMENT_DEPTH_EXT */ #endif #ifndef GL_SGIX_blend_alpha_minmax #define GL_ALPHA_MIN_SGIX 0x8320 #define GL_ALPHA_MAX_SGIX 0x8321 #endif #ifndef GL_SGIX_impact_pixel_texture #define GL_PIXEL_TEX_GEN_Q_CEILING_SGIX 0x8184 #define GL_PIXEL_TEX_GEN_Q_ROUND_SGIX 0x8185 #define GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX 0x8186 #define GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX 0x8187 #define GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX 0x8188 #define GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX 0x8189 #define GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX 0x818A #endif #ifndef GL_EXT_bgra #define GL_BGR_EXT 0x80E0 #define GL_BGRA_EXT 0x80E1 #endif #ifndef GL_SGIX_async #define GL_ASYNC_MARKER_SGIX 0x8329 #endif #ifndef GL_SGIX_async_pixel #define GL_ASYNC_TEX_IMAGE_SGIX 0x835C #define GL_ASYNC_DRAW_PIXELS_SGIX 0x835D #define GL_ASYNC_READ_PIXELS_SGIX 0x835E #define GL_MAX_ASYNC_TEX_IMAGE_SGIX 0x835F #define GL_MAX_ASYNC_DRAW_PIXELS_SGIX 0x8360 #define GL_MAX_ASYNC_READ_PIXELS_SGIX 0x8361 #endif #ifndef GL_SGIX_async_histogram #define GL_ASYNC_HISTOGRAM_SGIX 0x832C #define GL_MAX_ASYNC_HISTOGRAM_SGIX 0x832D #endif #ifndef GL_INTEL_texture_scissor #endif #ifndef GL_INTEL_parallel_arrays #define GL_PARALLEL_ARRAYS_INTEL 0x83F4 #define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5 #define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6 #define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7 #define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8 #endif #ifndef GL_HP_occlusion_test #define GL_OCCLUSION_TEST_HP 0x8165 #define GL_OCCLUSION_TEST_RESULT_HP 0x8166 #endif #ifndef GL_EXT_pixel_transform #define GL_PIXEL_TRANSFORM_2D_EXT 0x8330 #define GL_PIXEL_MAG_FILTER_EXT 0x8331 #define GL_PIXEL_MIN_FILTER_EXT 0x8332 #define GL_PIXEL_CUBIC_WEIGHT_EXT 0x8333 #define GL_CUBIC_EXT 0x8334 #define GL_AVERAGE_EXT 0x8335 #define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336 #define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337 #define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT 0x8338 #endif #ifndef GL_EXT_pixel_transform_color_table #endif #ifndef GL_EXT_shared_texture_palette #define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB #endif #ifndef GL_EXT_separate_specular_color #define GL_LIGHT_MODEL_COLOR_CONTROL_EXT 0x81F8 #define GL_SINGLE_COLOR_EXT 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR_EXT 0x81FA #endif #ifndef GL_EXT_secondary_color #define GL_COLOR_SUM_EXT 0x8458 #define GL_CURRENT_SECONDARY_COLOR_EXT 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D #define GL_SECONDARY_COLOR_ARRAY_EXT 0x845E #endif #ifndef GL_EXT_texture_perturb_normal #define GL_PERTURB_EXT 0x85AE #define GL_TEXTURE_NORMAL_EXT 0x85AF #endif #ifndef GL_EXT_multi_draw_arrays #endif #ifndef GL_EXT_fog_coord #define GL_FOG_COORDINATE_SOURCE_EXT 0x8450 #define GL_FOG_COORDINATE_EXT 0x8451 #define GL_FRAGMENT_DEPTH_EXT 0x8452 #define GL_CURRENT_FOG_COORDINATE_EXT 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 #define GL_FOG_COORDINATE_ARRAY_EXT 0x8457 #endif #ifndef GL_REND_screen_coordinates #define GL_SCREEN_COORDINATES_REND 0x8490 #define GL_INVERTED_SCREEN_W_REND 0x8491 #endif #ifndef GL_EXT_coordinate_frame #define GL_TANGENT_ARRAY_EXT 0x8439 #define GL_BINORMAL_ARRAY_EXT 0x843A #define GL_CURRENT_TANGENT_EXT 0x843B #define GL_CURRENT_BINORMAL_EXT 0x843C #define GL_TANGENT_ARRAY_TYPE_EXT 0x843E #define GL_TANGENT_ARRAY_STRIDE_EXT 0x843F #define GL_BINORMAL_ARRAY_TYPE_EXT 0x8440 #define GL_BINORMAL_ARRAY_STRIDE_EXT 0x8441 #define GL_TANGENT_ARRAY_POINTER_EXT 0x8442 #define GL_BINORMAL_ARRAY_POINTER_EXT 0x8443 #define GL_MAP1_TANGENT_EXT 0x8444 #define GL_MAP2_TANGENT_EXT 0x8445 #define GL_MAP1_BINORMAL_EXT 0x8446 #define GL_MAP2_BINORMAL_EXT 0x8447 #endif #ifndef GL_EXT_texture_env_combine #define GL_COMBINE_EXT 0x8570 #define GL_COMBINE_RGB_EXT 0x8571 #define GL_COMBINE_ALPHA_EXT 0x8572 #define GL_RGB_SCALE_EXT 0x8573 #define GL_ADD_SIGNED_EXT 0x8574 #define GL_INTERPOLATE_EXT 0x8575 #define GL_CONSTANT_EXT 0x8576 #define GL_PRIMARY_COLOR_EXT 0x8577 #define GL_PREVIOUS_EXT 0x8578 #define GL_SOURCE0_RGB_EXT 0x8580 #define GL_SOURCE1_RGB_EXT 0x8581 #define GL_SOURCE2_RGB_EXT 0x8582 #define GL_SOURCE0_ALPHA_EXT 0x8588 #define GL_SOURCE1_ALPHA_EXT 0x8589 #define GL_SOURCE2_ALPHA_EXT 0x858A #define GL_OPERAND0_RGB_EXT 0x8590 #define GL_OPERAND1_RGB_EXT 0x8591 #define GL_OPERAND2_RGB_EXT 0x8592 #define GL_OPERAND0_ALPHA_EXT 0x8598 #define GL_OPERAND1_ALPHA_EXT 0x8599 #define GL_OPERAND2_ALPHA_EXT 0x859A #endif #ifndef GL_APPLE_specular_vector #define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0 #endif #ifndef GL_APPLE_transform_hint #define GL_TRANSFORM_HINT_APPLE 0x85B1 #endif #ifndef GL_SGIX_fog_scale #define GL_FOG_SCALE_SGIX 0x81FC #define GL_FOG_SCALE_VALUE_SGIX 0x81FD #endif #ifndef GL_SUNX_constant_data #define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5 #define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6 #endif #ifndef GL_SUN_global_alpha #define GL_GLOBAL_ALPHA_SUN 0x81D9 #define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA #endif #ifndef GL_SUN_triangle_list #define GL_RESTART_SUN 0x0001 #define GL_REPLACE_MIDDLE_SUN 0x0002 #define GL_REPLACE_OLDEST_SUN 0x0003 #define GL_TRIANGLE_LIST_SUN 0x81D7 #define GL_REPLACEMENT_CODE_SUN 0x81D8 #define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0 #define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1 #define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2 #define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3 #define GL_R1UI_V3F_SUN 0x85C4 #define GL_R1UI_C4UB_V3F_SUN 0x85C5 #define GL_R1UI_C3F_V3F_SUN 0x85C6 #define GL_R1UI_N3F_V3F_SUN 0x85C7 #define GL_R1UI_C4F_N3F_V3F_SUN 0x85C8 #define GL_R1UI_T2F_V3F_SUN 0x85C9 #define GL_R1UI_T2F_N3F_V3F_SUN 0x85CA #define GL_R1UI_T2F_C4F_N3F_V3F_SUN 0x85CB #endif #ifndef GL_SUN_vertex #endif #ifndef GL_EXT_blend_func_separate #define GL_BLEND_DST_RGB_EXT 0x80C8 #define GL_BLEND_SRC_RGB_EXT 0x80C9 #define GL_BLEND_DST_ALPHA_EXT 0x80CA #define GL_BLEND_SRC_ALPHA_EXT 0x80CB #endif #ifndef GL_INGR_color_clamp #define GL_RED_MIN_CLAMP_INGR 0x8560 #define GL_GREEN_MIN_CLAMP_INGR 0x8561 #define GL_BLUE_MIN_CLAMP_INGR 0x8562 #define GL_ALPHA_MIN_CLAMP_INGR 0x8563 #define GL_RED_MAX_CLAMP_INGR 0x8564 #define GL_GREEN_MAX_CLAMP_INGR 0x8565 #define GL_BLUE_MAX_CLAMP_INGR 0x8566 #define GL_ALPHA_MAX_CLAMP_INGR 0x8567 #endif #ifndef GL_INGR_interlace_read #define GL_INTERLACE_READ_INGR 0x8568 #endif #ifndef GL_EXT_stencil_wrap #define GL_INCR_WRAP_EXT 0x8507 #define GL_DECR_WRAP_EXT 0x8508 #endif #ifndef GL_EXT_422_pixels #define GL_422_EXT 0x80CC #define GL_422_REV_EXT 0x80CD #define GL_422_AVERAGE_EXT 0x80CE #define GL_422_REV_AVERAGE_EXT 0x80CF #endif #ifndef GL_NV_texgen_reflection #define GL_NORMAL_MAP_NV 0x8511 #define GL_REFLECTION_MAP_NV 0x8512 #endif #ifndef GL_EXT_texture_cube_map #define GL_NORMAL_MAP_EXT 0x8511 #define GL_REFLECTION_MAP_EXT 0x8512 #define GL_TEXTURE_CUBE_MAP_EXT 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C #endif #ifndef GL_SUN_convolution_border_modes #define GL_WRAP_BORDER_SUN 0x81D4 #endif #ifndef GL_EXT_texture_env_add #endif #ifndef GL_EXT_texture_lod_bias #define GL_MAX_TEXTURE_LOD_BIAS_EXT 0x84FD #define GL_TEXTURE_FILTER_CONTROL_EXT 0x8500 #define GL_TEXTURE_LOD_BIAS_EXT 0x8501 #endif #ifndef GL_EXT_texture_filter_anisotropic #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF #endif #ifndef GL_EXT_vertex_weighting #define GL_MODELVIEW0_STACK_DEPTH_EXT GL_MODELVIEW_STACK_DEPTH #define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502 #define GL_MODELVIEW0_MATRIX_EXT GL_MODELVIEW_MATRIX #define GL_MODELVIEW1_MATRIX_EXT 0x8506 #define GL_VERTEX_WEIGHTING_EXT 0x8509 #define GL_MODELVIEW0_EXT GL_MODELVIEW #define GL_MODELVIEW1_EXT 0x850A #define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B #define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C #define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D #define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E #define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F #define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510 #endif #ifndef GL_NV_light_max_exponent #define GL_MAX_SHININESS_NV 0x8504 #define GL_MAX_SPOT_EXPONENT_NV 0x8505 #endif #ifndef GL_NV_vertex_array_range #define GL_VERTEX_ARRAY_RANGE_NV 0x851D #define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E #define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F #define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520 #define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521 #endif #ifndef GL_NV_register_combiners #define GL_REGISTER_COMBINERS_NV 0x8522 #define GL_VARIABLE_A_NV 0x8523 #define GL_VARIABLE_B_NV 0x8524 #define GL_VARIABLE_C_NV 0x8525 #define GL_VARIABLE_D_NV 0x8526 #define GL_VARIABLE_E_NV 0x8527 #define GL_VARIABLE_F_NV 0x8528 #define GL_VARIABLE_G_NV 0x8529 #define GL_CONSTANT_COLOR0_NV 0x852A #define GL_CONSTANT_COLOR1_NV 0x852B #define GL_PRIMARY_COLOR_NV 0x852C #define GL_SECONDARY_COLOR_NV 0x852D #define GL_SPARE0_NV 0x852E #define GL_SPARE1_NV 0x852F #define GL_DISCARD_NV 0x8530 #define GL_E_TIMES_F_NV 0x8531 #define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532 #define GL_UNSIGNED_IDENTITY_NV 0x8536 #define GL_UNSIGNED_INVERT_NV 0x8537 #define GL_EXPAND_NORMAL_NV 0x8538 #define GL_EXPAND_NEGATE_NV 0x8539 #define GL_HALF_BIAS_NORMAL_NV 0x853A #define GL_HALF_BIAS_NEGATE_NV 0x853B #define GL_SIGNED_IDENTITY_NV 0x853C #define GL_SIGNED_NEGATE_NV 0x853D #define GL_SCALE_BY_TWO_NV 0x853E #define GL_SCALE_BY_FOUR_NV 0x853F #define GL_SCALE_BY_ONE_HALF_NV 0x8540 #define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541 #define GL_COMBINER_INPUT_NV 0x8542 #define GL_COMBINER_MAPPING_NV 0x8543 #define GL_COMBINER_COMPONENT_USAGE_NV 0x8544 #define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545 #define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546 #define GL_COMBINER_MUX_SUM_NV 0x8547 #define GL_COMBINER_SCALE_NV 0x8548 #define GL_COMBINER_BIAS_NV 0x8549 #define GL_COMBINER_AB_OUTPUT_NV 0x854A #define GL_COMBINER_CD_OUTPUT_NV 0x854B #define GL_COMBINER_SUM_OUTPUT_NV 0x854C #define GL_MAX_GENERAL_COMBINERS_NV 0x854D #define GL_NUM_GENERAL_COMBINERS_NV 0x854E #define GL_COLOR_SUM_CLAMP_NV 0x854F #define GL_COMBINER0_NV 0x8550 #define GL_COMBINER1_NV 0x8551 #define GL_COMBINER2_NV 0x8552 #define GL_COMBINER3_NV 0x8553 #define GL_COMBINER4_NV 0x8554 #define GL_COMBINER5_NV 0x8555 #define GL_COMBINER6_NV 0x8556 #define GL_COMBINER7_NV 0x8557 /* reuse GL_TEXTURE0_ARB */ /* reuse GL_TEXTURE1_ARB */ /* reuse GL_ZERO */ /* reuse GL_NONE */ /* reuse GL_FOG */ #endif #ifndef GL_NV_fog_distance #define GL_FOG_DISTANCE_MODE_NV 0x855A #define GL_EYE_RADIAL_NV 0x855B #define GL_EYE_PLANE_ABSOLUTE_NV 0x855C /* reuse GL_EYE_PLANE */ #endif #ifndef GL_NV_texgen_emboss #define GL_EMBOSS_LIGHT_NV 0x855D #define GL_EMBOSS_CONSTANT_NV 0x855E #define GL_EMBOSS_MAP_NV 0x855F #endif #ifndef GL_NV_blend_square #endif #ifndef GL_NV_texture_env_combine4 #define GL_COMBINE4_NV 0x8503 #define GL_SOURCE3_RGB_NV 0x8583 #define GL_SOURCE3_ALPHA_NV 0x858B #define GL_OPERAND3_RGB_NV 0x8593 #define GL_OPERAND3_ALPHA_NV 0x859B #endif #ifndef GL_MESA_resize_buffers #endif #ifndef GL_MESA_window_pos #endif #ifndef GL_EXT_texture_compression_s3tc #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 #endif #ifndef GL_IBM_cull_vertex #define GL_CULL_VERTEX_IBM 103050 #endif #ifndef GL_IBM_multimode_draw_arrays #endif #ifndef GL_IBM_vertex_array_lists #define GL_VERTEX_ARRAY_LIST_IBM 103070 #define GL_NORMAL_ARRAY_LIST_IBM 103071 #define GL_COLOR_ARRAY_LIST_IBM 103072 #define GL_INDEX_ARRAY_LIST_IBM 103073 #define GL_TEXTURE_COORD_ARRAY_LIST_IBM 103074 #define GL_EDGE_FLAG_ARRAY_LIST_IBM 103075 #define GL_FOG_COORDINATE_ARRAY_LIST_IBM 103076 #define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077 #define GL_VERTEX_ARRAY_LIST_STRIDE_IBM 103080 #define GL_NORMAL_ARRAY_LIST_STRIDE_IBM 103081 #define GL_COLOR_ARRAY_LIST_STRIDE_IBM 103082 #define GL_INDEX_ARRAY_LIST_STRIDE_IBM 103083 #define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084 #define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085 #define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086 #define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087 #endif #ifndef GL_SGIX_subsample #define GL_PACK_SUBSAMPLE_RATE_SGIX 0x85A0 #define GL_UNPACK_SUBSAMPLE_RATE_SGIX 0x85A1 #define GL_PIXEL_SUBSAMPLE_4444_SGIX 0x85A2 #define GL_PIXEL_SUBSAMPLE_2424_SGIX 0x85A3 #define GL_PIXEL_SUBSAMPLE_4242_SGIX 0x85A4 #endif #ifndef GL_SGIX_ycrcb_subsample #endif #ifndef GL_SGIX_ycrcba #define GL_YCRCB_SGIX 0x8318 #define GL_YCRCBA_SGIX 0x8319 #endif #ifndef GL_SGI_depth_pass_instrument #define GL_DEPTH_PASS_INSTRUMENT_SGIX 0x8310 #define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311 #define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312 #endif #ifndef GL_3DFX_texture_compression_FXT1 #define GL_COMPRESSED_RGB_FXT1_3DFX 0x86B0 #define GL_COMPRESSED_RGBA_FXT1_3DFX 0x86B1 #endif #ifndef GL_3DFX_multisample #define GL_MULTISAMPLE_3DFX 0x86B2 #define GL_SAMPLE_BUFFERS_3DFX 0x86B3 #define GL_SAMPLES_3DFX 0x86B4 #define GL_MULTISAMPLE_BIT_3DFX 0x20000000 #endif #ifndef GL_3DFX_tbuffer #endif #ifndef GL_EXT_multisample #define GL_MULTISAMPLE_EXT 0x809D #define GL_SAMPLE_ALPHA_TO_MASK_EXT 0x809E #define GL_SAMPLE_ALPHA_TO_ONE_EXT 0x809F #define GL_SAMPLE_MASK_EXT 0x80A0 #define GL_1PASS_EXT 0x80A1 #define GL_2PASS_0_EXT 0x80A2 #define GL_2PASS_1_EXT 0x80A3 #define GL_4PASS_0_EXT 0x80A4 #define GL_4PASS_1_EXT 0x80A5 #define GL_4PASS_2_EXT 0x80A6 #define GL_4PASS_3_EXT 0x80A7 #define GL_SAMPLE_BUFFERS_EXT 0x80A8 #define GL_SAMPLES_EXT 0x80A9 #define GL_SAMPLE_MASK_VALUE_EXT 0x80AA #define GL_SAMPLE_MASK_INVERT_EXT 0x80AB #define GL_SAMPLE_PATTERN_EXT 0x80AC #define GL_MULTISAMPLE_BIT_EXT 0x20000000 #endif #ifndef GL_SGIX_vertex_preclip #define GL_VERTEX_PRECLIP_SGIX 0x83EE #define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF #endif #ifndef GL_SGIX_convolution_accuracy #define GL_CONVOLUTION_HINT_SGIX 0x8316 #endif #ifndef GL_SGIX_resample #define GL_PACK_RESAMPLE_SGIX 0x842C #define GL_UNPACK_RESAMPLE_SGIX 0x842D #define GL_RESAMPLE_REPLICATE_SGIX 0x842E #define GL_RESAMPLE_ZERO_FILL_SGIX 0x842F #define GL_RESAMPLE_DECIMATE_SGIX 0x8430 #endif #ifndef GL_SGIS_point_line_texgen #define GL_EYE_DISTANCE_TO_POINT_SGIS 0x81F0 #define GL_OBJECT_DISTANCE_TO_POINT_SGIS 0x81F1 #define GL_EYE_DISTANCE_TO_LINE_SGIS 0x81F2 #define GL_OBJECT_DISTANCE_TO_LINE_SGIS 0x81F3 #define GL_EYE_POINT_SGIS 0x81F4 #define GL_OBJECT_POINT_SGIS 0x81F5 #define GL_EYE_LINE_SGIS 0x81F6 #define GL_OBJECT_LINE_SGIS 0x81F7 #endif #ifndef GL_SGIS_texture_color_mask #define GL_TEXTURE_COLOR_WRITEMASK_SGIS 0x81EF #endif #ifndef GL_EXT_texture_env_dot3 #define GL_DOT3_RGB_EXT 0x8740 #define GL_DOT3_RGBA_EXT 0x8741 #endif #ifndef GL_ATI_texture_mirror_once #define GL_MIRROR_CLAMP_ATI 0x8742 #define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x8743 #endif #ifndef GL_NV_fence #define GL_ALL_COMPLETED_NV 0x84F2 #define GL_FENCE_STATUS_NV 0x84F3 #define GL_FENCE_CONDITION_NV 0x84F4 #endif #ifndef GL_IBM_texture_mirrored_repeat #define GL_MIRRORED_REPEAT_IBM 0x8370 #endif #ifndef GL_NV_evaluators #define GL_EVAL_2D_NV 0x86C0 #define GL_EVAL_TRIANGULAR_2D_NV 0x86C1 #define GL_MAP_TESSELLATION_NV 0x86C2 #define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3 #define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4 #define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5 #define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6 #define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7 #define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8 #define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9 #define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA #define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB #define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC #define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD #define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE #define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF #define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0 #define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1 #define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2 #define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3 #define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4 #define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5 #define GL_MAX_MAP_TESSELLATION_NV 0x86D6 #define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7 #endif #ifndef GL_NV_packed_depth_stencil #define GL_DEPTH_STENCIL_NV 0x84F9 #define GL_UNSIGNED_INT_24_8_NV 0x84FA #endif #ifndef GL_NV_register_combiners2 #define GL_PER_STAGE_CONSTANTS_NV 0x8535 #endif #ifndef GL_NV_texture_compression_vtc #endif #ifndef GL_NV_texture_rectangle #define GL_TEXTURE_RECTANGLE_NV 0x84F5 #define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6 #define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7 #define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8 #endif #ifndef GL_NV_texture_shader #define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C #define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D #define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E #define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9 #define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA #define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB #define GL_DSDT_MAG_INTENSITY_NV 0x86DC #define GL_SHADER_CONSISTENT_NV 0x86DD #define GL_TEXTURE_SHADER_NV 0x86DE #define GL_SHADER_OPERATION_NV 0x86DF #define GL_CULL_MODES_NV 0x86E0 #define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1 #define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2 #define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3 #define GL_OFFSET_TEXTURE_2D_MATRIX_NV GL_OFFSET_TEXTURE_MATRIX_NV #define GL_OFFSET_TEXTURE_2D_SCALE_NV GL_OFFSET_TEXTURE_SCALE_NV #define GL_OFFSET_TEXTURE_2D_BIAS_NV GL_OFFSET_TEXTURE_BIAS_NV #define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4 #define GL_CONST_EYE_NV 0x86E5 #define GL_PASS_THROUGH_NV 0x86E6 #define GL_CULL_FRAGMENT_NV 0x86E7 #define GL_OFFSET_TEXTURE_2D_NV 0x86E8 #define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9 #define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA #define GL_DOT_PRODUCT_NV 0x86EC #define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED #define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE #define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0 #define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1 #define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2 #define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3 #define GL_HILO_NV 0x86F4 #define GL_DSDT_NV 0x86F5 #define GL_DSDT_MAG_NV 0x86F6 #define GL_DSDT_MAG_VIB_NV 0x86F7 #define GL_HILO16_NV 0x86F8 #define GL_SIGNED_HILO_NV 0x86F9 #define GL_SIGNED_HILO16_NV 0x86FA #define GL_SIGNED_RGBA_NV 0x86FB #define GL_SIGNED_RGBA8_NV 0x86FC #define GL_SIGNED_RGB_NV 0x86FE #define GL_SIGNED_RGB8_NV 0x86FF #define GL_SIGNED_LUMINANCE_NV 0x8701 #define GL_SIGNED_LUMINANCE8_NV 0x8702 #define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 #define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 #define GL_SIGNED_ALPHA_NV 0x8705 #define GL_SIGNED_ALPHA8_NV 0x8706 #define GL_SIGNED_INTENSITY_NV 0x8707 #define GL_SIGNED_INTENSITY8_NV 0x8708 #define GL_DSDT8_NV 0x8709 #define GL_DSDT8_MAG8_NV 0x870A #define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B #define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C #define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D #define GL_HI_SCALE_NV 0x870E #define GL_LO_SCALE_NV 0x870F #define GL_DS_SCALE_NV 0x8710 #define GL_DT_SCALE_NV 0x8711 #define GL_MAGNITUDE_SCALE_NV 0x8712 #define GL_VIBRANCE_SCALE_NV 0x8713 #define GL_HI_BIAS_NV 0x8714 #define GL_LO_BIAS_NV 0x8715 #define GL_DS_BIAS_NV 0x8716 #define GL_DT_BIAS_NV 0x8717 #define GL_MAGNITUDE_BIAS_NV 0x8718 #define GL_VIBRANCE_BIAS_NV 0x8719 #define GL_TEXTURE_BORDER_VALUES_NV 0x871A #define GL_TEXTURE_HI_SIZE_NV 0x871B #define GL_TEXTURE_LO_SIZE_NV 0x871C #define GL_TEXTURE_DS_SIZE_NV 0x871D #define GL_TEXTURE_DT_SIZE_NV 0x871E #define GL_TEXTURE_MAG_SIZE_NV 0x871F #endif #ifndef GL_NV_texture_shader2 #define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF #endif #ifndef GL_NV_vertex_array_range2 #define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533 #endif #ifndef GL_NV_vertex_program #define GL_VERTEX_PROGRAM_NV 0x8620 #define GL_VERTEX_STATE_PROGRAM_NV 0x8621 #define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 #define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 #define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 #define GL_CURRENT_ATTRIB_NV 0x8626 #define GL_PROGRAM_LENGTH_NV 0x8627 #define GL_PROGRAM_STRING_NV 0x8628 #define GL_MODELVIEW_PROJECTION_NV 0x8629 #define GL_IDENTITY_NV 0x862A #define GL_INVERSE_NV 0x862B #define GL_TRANSPOSE_NV 0x862C #define GL_INVERSE_TRANSPOSE_NV 0x862D #define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E #define GL_MAX_TRACK_MATRICES_NV 0x862F #define GL_MATRIX0_NV 0x8630 #define GL_MATRIX1_NV 0x8631 #define GL_MATRIX2_NV 0x8632 #define GL_MATRIX3_NV 0x8633 #define GL_MATRIX4_NV 0x8634 #define GL_MATRIX5_NV 0x8635 #define GL_MATRIX6_NV 0x8636 #define GL_MATRIX7_NV 0x8637 #define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 #define GL_CURRENT_MATRIX_NV 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 #define GL_PROGRAM_PARAMETER_NV 0x8644 #define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 #define GL_PROGRAM_TARGET_NV 0x8646 #define GL_PROGRAM_RESIDENT_NV 0x8647 #define GL_TRACK_MATRIX_NV 0x8648 #define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 #define GL_VERTEX_PROGRAM_BINDING_NV 0x864A #define GL_PROGRAM_ERROR_POSITION_NV 0x864B #define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 #define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 #define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 #define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 #define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 #define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 #define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 #define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 #define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 #define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 #define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A #define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B #define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C #define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D #define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E #define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F #define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 #define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 #define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 #define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 #define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 #define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 #define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 #define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 #define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 #define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 #define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A #define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B #define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C #define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D #define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E #define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F #define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 #define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 #define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 #define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 #define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 #define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 #define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 #define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 #define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 #define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 #define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A #define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B #define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C #define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D #define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E #define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F #endif #ifndef GL_SGIX_texture_coordinate_clamp #define GL_TEXTURE_MAX_CLAMP_S_SGIX 0x8369 #define GL_TEXTURE_MAX_CLAMP_T_SGIX 0x836A #define GL_TEXTURE_MAX_CLAMP_R_SGIX 0x836B #endif #ifndef GL_SGIX_scalebias_hint #define GL_SCALEBIAS_HINT_SGIX 0x8322 #endif #ifndef GL_OML_interlace #define GL_INTERLACE_OML 0x8980 #define GL_INTERLACE_READ_OML 0x8981 #endif #ifndef GL_OML_subsample #define GL_FORMAT_SUBSAMPLE_24_24_OML 0x8982 #define GL_FORMAT_SUBSAMPLE_244_244_OML 0x8983 #endif #ifndef GL_OML_resample #define GL_PACK_RESAMPLE_OML 0x8984 #define GL_UNPACK_RESAMPLE_OML 0x8985 #define GL_RESAMPLE_REPLICATE_OML 0x8986 #define GL_RESAMPLE_ZERO_FILL_OML 0x8987 #define GL_RESAMPLE_AVERAGE_OML 0x8988 #define GL_RESAMPLE_DECIMATE_OML 0x8989 #endif #ifndef GL_NV_copy_depth_to_color #define GL_DEPTH_STENCIL_TO_RGBA_NV 0x886E #define GL_DEPTH_STENCIL_TO_BGRA_NV 0x886F #endif #ifndef GL_ATI_envmap_bumpmap #define GL_BUMP_ROT_MATRIX_ATI 0x8775 #define GL_BUMP_ROT_MATRIX_SIZE_ATI 0x8776 #define GL_BUMP_NUM_TEX_UNITS_ATI 0x8777 #define GL_BUMP_TEX_UNITS_ATI 0x8778 #define GL_DUDV_ATI 0x8779 #define GL_DU8DV8_ATI 0x877A #define GL_BUMP_ENVMAP_ATI 0x877B #define GL_BUMP_TARGET_ATI 0x877C #endif #ifndef GL_ATI_fragment_shader #define GL_FRAGMENT_SHADER_ATI 0x8920 #define GL_REG_0_ATI 0x8921 #define GL_REG_1_ATI 0x8922 #define GL_REG_2_ATI 0x8923 #define GL_REG_3_ATI 0x8924 #define GL_REG_4_ATI 0x8925 #define GL_REG_5_ATI 0x8926 #define GL_REG_6_ATI 0x8927 #define GL_REG_7_ATI 0x8928 #define GL_REG_8_ATI 0x8929 #define GL_REG_9_ATI 0x892A #define GL_REG_10_ATI 0x892B #define GL_REG_11_ATI 0x892C #define GL_REG_12_ATI 0x892D #define GL_REG_13_ATI 0x892E #define GL_REG_14_ATI 0x892F #define GL_REG_15_ATI 0x8930 #define GL_REG_16_ATI 0x8931 #define GL_REG_17_ATI 0x8932 #define GL_REG_18_ATI 0x8933 #define GL_REG_19_ATI 0x8934 #define GL_REG_20_ATI 0x8935 #define GL_REG_21_ATI 0x8936 #define GL_REG_22_ATI 0x8937 #define GL_REG_23_ATI 0x8938 #define GL_REG_24_ATI 0x8939 #define GL_REG_25_ATI 0x893A #define GL_REG_26_ATI 0x893B #define GL_REG_27_ATI 0x893C #define GL_REG_28_ATI 0x893D #define GL_REG_29_ATI 0x893E #define GL_REG_30_ATI 0x893F #define GL_REG_31_ATI 0x8940 #define GL_CON_0_ATI 0x8941 #define GL_CON_1_ATI 0x8942 #define GL_CON_2_ATI 0x8943 #define GL_CON_3_ATI 0x8944 #define GL_CON_4_ATI 0x8945 #define GL_CON_5_ATI 0x8946 #define GL_CON_6_ATI 0x8947 #define GL_CON_7_ATI 0x8948 #define GL_CON_8_ATI 0x8949 #define GL_CON_9_ATI 0x894A #define GL_CON_10_ATI 0x894B #define GL_CON_11_ATI 0x894C #define GL_CON_12_ATI 0x894D #define GL_CON_13_ATI 0x894E #define GL_CON_14_ATI 0x894F #define GL_CON_15_ATI 0x8950 #define GL_CON_16_ATI 0x8951 #define GL_CON_17_ATI 0x8952 #define GL_CON_18_ATI 0x8953 #define GL_CON_19_ATI 0x8954 #define GL_CON_20_ATI 0x8955 #define GL_CON_21_ATI 0x8956 #define GL_CON_22_ATI 0x8957 #define GL_CON_23_ATI 0x8958 #define GL_CON_24_ATI 0x8959 #define GL_CON_25_ATI 0x895A #define GL_CON_26_ATI 0x895B #define GL_CON_27_ATI 0x895C #define GL_CON_28_ATI 0x895D #define GL_CON_29_ATI 0x895E #define GL_CON_30_ATI 0x895F #define GL_CON_31_ATI 0x8960 #define GL_MOV_ATI 0x8961 #define GL_ADD_ATI 0x8963 #define GL_MUL_ATI 0x8964 #define GL_SUB_ATI 0x8965 #define GL_DOT3_ATI 0x8966 #define GL_DOT4_ATI 0x8967 #define GL_MAD_ATI 0x8968 #define GL_LERP_ATI 0x8969 #define GL_CND_ATI 0x896A #define GL_CND0_ATI 0x896B #define GL_DOT2_ADD_ATI 0x896C #define GL_SECONDARY_INTERPOLATOR_ATI 0x896D #define GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E #define GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F #define GL_NUM_PASSES_ATI 0x8970 #define GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971 #define GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972 #define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973 #define GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974 #define GL_COLOR_ALPHA_PAIRING_ATI 0x8975 #define GL_SWIZZLE_STR_ATI 0x8976 #define GL_SWIZZLE_STQ_ATI 0x8977 #define GL_SWIZZLE_STR_DR_ATI 0x8978 #define GL_SWIZZLE_STQ_DQ_ATI 0x8979 #define GL_SWIZZLE_STRQ_ATI 0x897A #define GL_SWIZZLE_STRQ_DQ_ATI 0x897B #define GL_RED_BIT_ATI 0x00000001 #define GL_GREEN_BIT_ATI 0x00000002 #define GL_BLUE_BIT_ATI 0x00000004 #define GL_2X_BIT_ATI 0x00000001 #define GL_4X_BIT_ATI 0x00000002 #define GL_8X_BIT_ATI 0x00000004 #define GL_HALF_BIT_ATI 0x00000008 #define GL_QUARTER_BIT_ATI 0x00000010 #define GL_EIGHTH_BIT_ATI 0x00000020 #define GL_SATURATE_BIT_ATI 0x00000040 #define GL_COMP_BIT_ATI 0x00000002 #define GL_NEGATE_BIT_ATI 0x00000004 #define GL_BIAS_BIT_ATI 0x00000008 #endif #ifndef GL_ATI_pn_triangles #define GL_PN_TRIANGLES_ATI 0x87F0 #define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1 #define GL_PN_TRIANGLES_POINT_MODE_ATI 0x87F2 #define GL_PN_TRIANGLES_NORMAL_MODE_ATI 0x87F3 #define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4 #define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5 #define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6 #define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7 #define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8 #endif #ifndef GL_ATI_vertex_array_object #define GL_STATIC_ATI 0x8760 #define GL_DYNAMIC_ATI 0x8761 #define GL_PRESERVE_ATI 0x8762 #define GL_DISCARD_ATI 0x8763 #define GL_OBJECT_BUFFER_SIZE_ATI 0x8764 #define GL_OBJECT_BUFFER_USAGE_ATI 0x8765 #define GL_ARRAY_OBJECT_BUFFER_ATI 0x8766 #define GL_ARRAY_OBJECT_OFFSET_ATI 0x8767 #endif #ifndef GL_EXT_vertex_shader #define GL_VERTEX_SHADER_EXT 0x8780 #define GL_VERTEX_SHADER_BINDING_EXT 0x8781 #define GL_OP_INDEX_EXT 0x8782 #define GL_OP_NEGATE_EXT 0x8783 #define GL_OP_DOT3_EXT 0x8784 #define GL_OP_DOT4_EXT 0x8785 #define GL_OP_MUL_EXT 0x8786 #define GL_OP_ADD_EXT 0x8787 #define GL_OP_MADD_EXT 0x8788 #define GL_OP_FRAC_EXT 0x8789 #define GL_OP_MAX_EXT 0x878A #define GL_OP_MIN_EXT 0x878B #define GL_OP_SET_GE_EXT 0x878C #define GL_OP_SET_LT_EXT 0x878D #define GL_OP_CLAMP_EXT 0x878E #define GL_OP_FLOOR_EXT 0x878F #define GL_OP_ROUND_EXT 0x8790 #define GL_OP_EXP_BASE_2_EXT 0x8791 #define GL_OP_LOG_BASE_2_EXT 0x8792 #define GL_OP_POWER_EXT 0x8793 #define GL_OP_RECIP_EXT 0x8794 #define GL_OP_RECIP_SQRT_EXT 0x8795 #define GL_OP_SUB_EXT 0x8796 #define GL_OP_CROSS_PRODUCT_EXT 0x8797 #define GL_OP_MULTIPLY_MATRIX_EXT 0x8798 #define GL_OP_MOV_EXT 0x8799 #define GL_OUTPUT_VERTEX_EXT 0x879A #define GL_OUTPUT_COLOR0_EXT 0x879B #define GL_OUTPUT_COLOR1_EXT 0x879C #define GL_OUTPUT_TEXTURE_COORD0_EXT 0x879D #define GL_OUTPUT_TEXTURE_COORD1_EXT 0x879E #define GL_OUTPUT_TEXTURE_COORD2_EXT 0x879F #define GL_OUTPUT_TEXTURE_COORD3_EXT 0x87A0 #define GL_OUTPUT_TEXTURE_COORD4_EXT 0x87A1 #define GL_OUTPUT_TEXTURE_COORD5_EXT 0x87A2 #define GL_OUTPUT_TEXTURE_COORD6_EXT 0x87A3 #define GL_OUTPUT_TEXTURE_COORD7_EXT 0x87A4 #define GL_OUTPUT_TEXTURE_COORD8_EXT 0x87A5 #define GL_OUTPUT_TEXTURE_COORD9_EXT 0x87A6 #define GL_OUTPUT_TEXTURE_COORD10_EXT 0x87A7 #define GL_OUTPUT_TEXTURE_COORD11_EXT 0x87A8 #define GL_OUTPUT_TEXTURE_COORD12_EXT 0x87A9 #define GL_OUTPUT_TEXTURE_COORD13_EXT 0x87AA #define GL_OUTPUT_TEXTURE_COORD14_EXT 0x87AB #define GL_OUTPUT_TEXTURE_COORD15_EXT 0x87AC #define GL_OUTPUT_TEXTURE_COORD16_EXT 0x87AD #define GL_OUTPUT_TEXTURE_COORD17_EXT 0x87AE #define GL_OUTPUT_TEXTURE_COORD18_EXT 0x87AF #define GL_OUTPUT_TEXTURE_COORD19_EXT 0x87B0 #define GL_OUTPUT_TEXTURE_COORD20_EXT 0x87B1 #define GL_OUTPUT_TEXTURE_COORD21_EXT 0x87B2 #define GL_OUTPUT_TEXTURE_COORD22_EXT 0x87B3 #define GL_OUTPUT_TEXTURE_COORD23_EXT 0x87B4 #define GL_OUTPUT_TEXTURE_COORD24_EXT 0x87B5 #define GL_OUTPUT_TEXTURE_COORD25_EXT 0x87B6 #define GL_OUTPUT_TEXTURE_COORD26_EXT 0x87B7 #define GL_OUTPUT_TEXTURE_COORD27_EXT 0x87B8 #define GL_OUTPUT_TEXTURE_COORD28_EXT 0x87B9 #define GL_OUTPUT_TEXTURE_COORD29_EXT 0x87BA #define GL_OUTPUT_TEXTURE_COORD30_EXT 0x87BB #define GL_OUTPUT_TEXTURE_COORD31_EXT 0x87BC #define GL_OUTPUT_FOG_EXT 0x87BD #define GL_SCALAR_EXT 0x87BE #define GL_VECTOR_EXT 0x87BF #define GL_MATRIX_EXT 0x87C0 #define GL_VARIANT_EXT 0x87C1 #define GL_INVARIANT_EXT 0x87C2 #define GL_LOCAL_CONSTANT_EXT 0x87C3 #define GL_LOCAL_EXT 0x87C4 #define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5 #define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6 #define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7 #define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8 #define GL_MAX_VERTEX_SHADER_LOCALS_EXT 0x87C9 #define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA #define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB #define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CC #define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CD #define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE #define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF #define GL_VERTEX_SHADER_VARIANTS_EXT 0x87D0 #define GL_VERTEX_SHADER_INVARIANTS_EXT 0x87D1 #define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2 #define GL_VERTEX_SHADER_LOCALS_EXT 0x87D3 #define GL_VERTEX_SHADER_OPTIMIZED_EXT 0x87D4 #define GL_X_EXT 0x87D5 #define GL_Y_EXT 0x87D6 #define GL_Z_EXT 0x87D7 #define GL_W_EXT 0x87D8 #define GL_NEGATIVE_X_EXT 0x87D9 #define GL_NEGATIVE_Y_EXT 0x87DA #define GL_NEGATIVE_Z_EXT 0x87DB #define GL_NEGATIVE_W_EXT 0x87DC #define GL_ZERO_EXT 0x87DD #define GL_ONE_EXT 0x87DE #define GL_NEGATIVE_ONE_EXT 0x87DF #define GL_NORMALIZED_RANGE_EXT 0x87E0 #define GL_FULL_RANGE_EXT 0x87E1 #define GL_CURRENT_VERTEX_EXT 0x87E2 #define GL_MVP_MATRIX_EXT 0x87E3 #define GL_VARIANT_VALUE_EXT 0x87E4 #define GL_VARIANT_DATATYPE_EXT 0x87E5 #define GL_VARIANT_ARRAY_STRIDE_EXT 0x87E6 #define GL_VARIANT_ARRAY_TYPE_EXT 0x87E7 #define GL_VARIANT_ARRAY_EXT 0x87E8 #define GL_VARIANT_ARRAY_POINTER_EXT 0x87E9 #define GL_INVARIANT_VALUE_EXT 0x87EA #define GL_INVARIANT_DATATYPE_EXT 0x87EB #define GL_LOCAL_CONSTANT_VALUE_EXT 0x87EC #define GL_LOCAL_CONSTANT_DATATYPE_EXT 0x87ED #endif #ifndef GL_ATI_vertex_streams #define GL_MAX_VERTEX_STREAMS_ATI 0x876B #define GL_VERTEX_STREAM0_ATI 0x876C #define GL_VERTEX_STREAM1_ATI 0x876D #define GL_VERTEX_STREAM2_ATI 0x876E #define GL_VERTEX_STREAM3_ATI 0x876F #define GL_VERTEX_STREAM4_ATI 0x8770 #define GL_VERTEX_STREAM5_ATI 0x8771 #define GL_VERTEX_STREAM6_ATI 0x8772 #define GL_VERTEX_STREAM7_ATI 0x8773 #define GL_VERTEX_SOURCE_ATI 0x8774 #endif #ifndef GL_ATI_element_array #define GL_ELEMENT_ARRAY_ATI 0x8768 #define GL_ELEMENT_ARRAY_TYPE_ATI 0x8769 #define GL_ELEMENT_ARRAY_POINTER_ATI 0x876A #endif #ifndef GL_SUN_mesh_array #define GL_QUAD_MESH_SUN 0x8614 #define GL_TRIANGLE_MESH_SUN 0x8615 #endif #ifndef GL_SUN_slice_accum #define GL_SLICE_ACCUM_SUN 0x85CC #endif #ifndef GL_NV_multisample_filter_hint #define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534 #endif #ifndef GL_NV_depth_clamp #define GL_DEPTH_CLAMP_NV 0x864F #endif #ifndef GL_NV_occlusion_query #define GL_PIXEL_COUNTER_BITS_NV 0x8864 #define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865 #define GL_PIXEL_COUNT_NV 0x8866 #define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867 #endif #ifndef GL_NV_point_sprite #define GL_POINT_SPRITE_NV 0x8861 #define GL_COORD_REPLACE_NV 0x8862 #define GL_POINT_SPRITE_R_MODE_NV 0x8863 #endif #ifndef GL_NV_texture_shader3 #define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850 #define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851 #define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852 #define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853 #define GL_OFFSET_HILO_TEXTURE_2D_NV 0x8854 #define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855 #define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856 #define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857 #define GL_DEPENDENT_HILO_TEXTURE_2D_NV 0x8858 #define GL_DEPENDENT_RGB_TEXTURE_3D_NV 0x8859 #define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A #define GL_DOT_PRODUCT_PASS_THROUGH_NV 0x885B #define GL_DOT_PRODUCT_TEXTURE_1D_NV 0x885C #define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D #define GL_HILO8_NV 0x885E #define GL_SIGNED_HILO8_NV 0x885F #define GL_FORCE_BLUE_TO_ONE_NV 0x8860 #endif #ifndef GL_NV_vertex_program1_1 #endif #ifndef GL_EXT_shadow_funcs #endif #ifndef GL_EXT_stencil_two_side #define GL_STENCIL_TEST_TWO_SIDE_EXT 0x8910 #define GL_ACTIVE_STENCIL_FACE_EXT 0x8911 #endif #ifndef GL_ATI_text_fragment_shader #define GL_TEXT_FRAGMENT_SHADER_ATI 0x8200 #endif #ifndef GL_APPLE_client_storage #define GL_UNPACK_CLIENT_STORAGE_APPLE 0x85B2 #endif #ifndef GL_APPLE_element_array #define GL_ELEMENT_ARRAY_APPLE 0x8768 #define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8769 #define GL_ELEMENT_ARRAY_POINTER_APPLE 0x876A #endif #ifndef GL_APPLE_fence #define GL_DRAW_PIXELS_APPLE 0x8A0A #define GL_FENCE_APPLE 0x8A0B #endif #ifndef GL_APPLE_vertex_array_object #define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5 #endif #ifndef GL_APPLE_vertex_array_range #define GL_VERTEX_ARRAY_RANGE_APPLE 0x851D #define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E #define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F #define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521 #define GL_STORAGE_CACHED_APPLE 0x85BE #define GL_STORAGE_SHARED_APPLE 0x85BF #endif #ifndef GL_APPLE_ycbcr_422 #define GL_YCBCR_422_APPLE 0x85B9 #define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA #define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB #endif #ifndef GL_S3_s3tc #define GL_RGB_S3TC 0x83A0 #define GL_RGB4_S3TC 0x83A1 #define GL_RGBA_S3TC 0x83A2 #define GL_RGBA4_S3TC 0x83A3 #endif #ifndef GL_ATI_draw_buffers #define GL_MAX_DRAW_BUFFERS_ATI 0x8824 #define GL_DRAW_BUFFER0_ATI 0x8825 #define GL_DRAW_BUFFER1_ATI 0x8826 #define GL_DRAW_BUFFER2_ATI 0x8827 #define GL_DRAW_BUFFER3_ATI 0x8828 #define GL_DRAW_BUFFER4_ATI 0x8829 #define GL_DRAW_BUFFER5_ATI 0x882A #define GL_DRAW_BUFFER6_ATI 0x882B #define GL_DRAW_BUFFER7_ATI 0x882C #define GL_DRAW_BUFFER8_ATI 0x882D #define GL_DRAW_BUFFER9_ATI 0x882E #define GL_DRAW_BUFFER10_ATI 0x882F #define GL_DRAW_BUFFER11_ATI 0x8830 #define GL_DRAW_BUFFER12_ATI 0x8831 #define GL_DRAW_BUFFER13_ATI 0x8832 #define GL_DRAW_BUFFER14_ATI 0x8833 #define GL_DRAW_BUFFER15_ATI 0x8834 #endif #ifndef GL_ATI_pixel_format_float #define GL_TYPE_RGBA_FLOAT_ATI 0x8820 #define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835 #endif #ifndef GL_ATI_texture_env_combine3 #define GL_MODULATE_ADD_ATI 0x8744 #define GL_MODULATE_SIGNED_ADD_ATI 0x8745 #define GL_MODULATE_SUBTRACT_ATI 0x8746 #endif #ifndef GL_ATI_texture_float #define GL_RGBA_FLOAT32_ATI 0x8814 #define GL_RGB_FLOAT32_ATI 0x8815 #define GL_ALPHA_FLOAT32_ATI 0x8816 #define GL_INTENSITY_FLOAT32_ATI 0x8817 #define GL_LUMINANCE_FLOAT32_ATI 0x8818 #define GL_LUMINANCE_ALPHA_FLOAT32_ATI 0x8819 #define GL_RGBA_FLOAT16_ATI 0x881A #define GL_RGB_FLOAT16_ATI 0x881B #define GL_ALPHA_FLOAT16_ATI 0x881C #define GL_INTENSITY_FLOAT16_ATI 0x881D #define GL_LUMINANCE_FLOAT16_ATI 0x881E #define GL_LUMINANCE_ALPHA_FLOAT16_ATI 0x881F #endif #ifndef GL_NV_float_buffer #define GL_FLOAT_R_NV 0x8880 #define GL_FLOAT_RG_NV 0x8881 #define GL_FLOAT_RGB_NV 0x8882 #define GL_FLOAT_RGBA_NV 0x8883 #define GL_FLOAT_R16_NV 0x8884 #define GL_FLOAT_R32_NV 0x8885 #define GL_FLOAT_RG16_NV 0x8886 #define GL_FLOAT_RG32_NV 0x8887 #define GL_FLOAT_RGB16_NV 0x8888 #define GL_FLOAT_RGB32_NV 0x8889 #define GL_FLOAT_RGBA16_NV 0x888A #define GL_FLOAT_RGBA32_NV 0x888B #define GL_TEXTURE_FLOAT_COMPONENTS_NV 0x888C #define GL_FLOAT_CLEAR_COLOR_VALUE_NV 0x888D #define GL_FLOAT_RGBA_MODE_NV 0x888E #endif #ifndef GL_NV_fragment_program #define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 #define GL_FRAGMENT_PROGRAM_NV 0x8870 #define GL_MAX_TEXTURE_COORDS_NV 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 #define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 #define GL_PROGRAM_ERROR_STRING_NV 0x8874 #endif #ifndef GL_NV_half_float #define GL_HALF_FLOAT_NV 0x140B #endif #ifndef GL_NV_pixel_data_range #define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878 #define GL_READ_PIXEL_DATA_RANGE_NV 0x8879 #define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A #define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B #define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C #define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D #endif #ifndef GL_NV_primitive_restart #define GL_PRIMITIVE_RESTART_NV 0x8558 #define GL_PRIMITIVE_RESTART_INDEX_NV 0x8559 #endif #ifndef GL_NV_texture_expand_normal #define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F #endif #ifndef GL_NV_vertex_program2 #endif #ifndef GL_ATI_map_object_buffer #endif #ifndef GL_ATI_separate_stencil #define GL_STENCIL_BACK_FUNC_ATI 0x8800 #define GL_STENCIL_BACK_FAIL_ATI 0x8801 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802 #define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803 #endif #ifndef GL_ATI_vertex_attrib_array_object #endif #ifndef GL_OES_read_format #define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A #define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B #endif #ifndef GL_EXT_depth_bounds_test #define GL_DEPTH_BOUNDS_TEST_EXT 0x8890 #define GL_DEPTH_BOUNDS_EXT 0x8891 #endif #ifndef GL_EXT_texture_mirror_clamp #define GL_MIRROR_CLAMP_EXT 0x8742 #define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 #define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912 #endif #ifndef GL_EXT_blend_equation_separate #define GL_BLEND_EQUATION_RGB_EXT GL_BLEND_EQUATION #define GL_BLEND_EQUATION_ALPHA_EXT 0x883D #endif #ifndef GL_MESA_pack_invert #define GL_PACK_INVERT_MESA 0x8758 #endif #ifndef GL_MESA_ycbcr_texture #define GL_UNSIGNED_SHORT_8_8_MESA 0x85BA #define GL_UNSIGNED_SHORT_8_8_REV_MESA 0x85BB #define GL_YCBCR_MESA 0x8757 #endif #ifndef GL_EXT_pixel_buffer_object #define GL_PIXEL_PACK_BUFFER_EXT 0x88EB #define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC #define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED #define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF #endif #ifndef GL_NV_fragment_program_option #endif #ifndef GL_NV_fragment_program2 #define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 #define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 #define GL_MAX_PROGRAM_IF_DEPTH_NV 0x88F6 #define GL_MAX_PROGRAM_LOOP_DEPTH_NV 0x88F7 #define GL_MAX_PROGRAM_LOOP_COUNT_NV 0x88F8 #endif #ifndef GL_NV_vertex_program2_option /* reuse GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ /* reuse GL_MAX_PROGRAM_CALL_DEPTH_NV */ #endif #ifndef GL_NV_vertex_program3 /* reuse GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */ #endif #ifndef GL_EXT_framebuffer_object #define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 #define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 #define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 #define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 #define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 #define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 #define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENTS_EXT 0x8CD6 #define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 #define GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT 0x8CD8 #define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 #define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA #define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB #define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC #define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD #define GL_FRAMEBUFFER_STATUS_ERROR_EXT 0x8CDE #define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF #define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 #define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 #define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 #define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 #define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 #define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 #define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 #define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 #define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 #define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 #define GL_COLOR_ATTACHMENT10_EXT 0x8CEA #define GL_COLOR_ATTACHMENT11_EXT 0x8CEB #define GL_COLOR_ATTACHMENT12_EXT 0x8CEC #define GL_COLOR_ATTACHMENT13_EXT 0x8CED #define GL_COLOR_ATTACHMENT14_EXT 0x8CEE #define GL_COLOR_ATTACHMENT15_EXT 0x8CEF #define GL_DEPTH_ATTACHMENT_EXT 0x8D00 #define GL_STENCIL_ATTACHMENT_EXT 0x8D20 #define GL_FRAMEBUFFER_EXT 0x8D40 #define GL_RENDERBUFFER_EXT 0x8D41 #define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 #define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 #define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 #define GL_STENCIL_INDEX_EXT 0x8D45 #define GL_STENCIL_INDEX1_EXT 0x8D46 #define GL_STENCIL_INDEX4_EXT 0x8D47 #define GL_STENCIL_INDEX8_EXT 0x8D48 #define GL_STENCIL_INDEX16_EXT 0x8D49 #endif #ifndef GL_GREMEDY_string_marker #endif /*************************************************************/ #include #ifndef GL_VERSION_2_0 /* GL type for program/shader text */ typedef char GLchar; /* native character */ #endif #ifndef GL_VERSION_1_5 /* GL types for handling large vertex buffer objects */ typedef ptrdiff_t GLintptr; typedef ptrdiff_t GLsizeiptr; #endif #ifndef GL_ARB_vertex_buffer_object /* GL types for handling large vertex buffer objects */ typedef ptrdiff_t GLintptrARB; typedef ptrdiff_t GLsizeiptrARB; #endif #ifndef GL_ARB_shader_objects /* GL types for handling shader object handles and program/shader text */ typedef char GLcharARB; /* native character */ typedef unsigned int GLhandleARB; /* shader object handle */ #endif /* GL types for "half" precision (s10e5) float data in host memory */ #ifndef GL_ARB_half_float_pixel typedef unsigned short GLhalfARB; #endif #ifndef GL_NV_half_float typedef unsigned short GLhalfNV; #endif #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf); GLAPI void APIENTRY glBlendEquation (GLenum); GLAPI void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *); GLAPI void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei); GLAPI void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *); GLAPI void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei); GLAPI void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat); GLAPI void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint); GLAPI void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei); GLAPI void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei); GLAPI void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *); GLAPI void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *); GLAPI void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *); GLAPI void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean); GLAPI void APIENTRY glMinmax (GLenum, GLenum, GLboolean); GLAPI void APIENTRY glResetHistogram (GLenum); GLAPI void APIENTRY glResetMinmax (GLenum); GLAPI void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode); typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); typedef void (APIENTRYP PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRYP PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); typedef void (APIENTRYP PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); typedef void (APIENTRYP PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); typedef void (APIENTRYP PFNGLRESETHISTOGRAMPROC) (GLenum target); typedef void (APIENTRYP PFNGLRESETMINMAXPROC) (GLenum target); typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); #endif #ifndef GL_VERSION_1_3 #define GL_VERSION_1_3 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glActiveTexture (GLenum); GLAPI void APIENTRY glClientActiveTexture (GLenum); GLAPI void APIENTRY glMultiTexCoord1d (GLenum, GLdouble); GLAPI void APIENTRY glMultiTexCoord1dv (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord1f (GLenum, GLfloat); GLAPI void APIENTRY glMultiTexCoord1fv (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord1i (GLenum, GLint); GLAPI void APIENTRY glMultiTexCoord1iv (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord1s (GLenum, GLshort); GLAPI void APIENTRY glMultiTexCoord1sv (GLenum, const GLshort *); GLAPI void APIENTRY glMultiTexCoord2d (GLenum, GLdouble, GLdouble); GLAPI void APIENTRY glMultiTexCoord2dv (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord2f (GLenum, GLfloat, GLfloat); GLAPI void APIENTRY glMultiTexCoord2fv (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord2i (GLenum, GLint, GLint); GLAPI void APIENTRY glMultiTexCoord2iv (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord2s (GLenum, GLshort, GLshort); GLAPI void APIENTRY glMultiTexCoord2sv (GLenum, const GLshort *); GLAPI void APIENTRY glMultiTexCoord3d (GLenum, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glMultiTexCoord3dv (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord3f (GLenum, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glMultiTexCoord3fv (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord3i (GLenum, GLint, GLint, GLint); GLAPI void APIENTRY glMultiTexCoord3iv (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord3s (GLenum, GLshort, GLshort, GLshort); GLAPI void APIENTRY glMultiTexCoord3sv (GLenum, const GLshort *); GLAPI void APIENTRY glMultiTexCoord4d (GLenum, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glMultiTexCoord4dv (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord4f (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glMultiTexCoord4fv (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord4i (GLenum, GLint, GLint, GLint, GLint); GLAPI void APIENTRY glMultiTexCoord4iv (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord4s (GLenum, GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glMultiTexCoord4sv (GLenum, const GLshort *); GLAPI void APIENTRY glLoadTransposeMatrixf (const GLfloat *); GLAPI void APIENTRY glLoadTransposeMatrixd (const GLdouble *); GLAPI void APIENTRY glMultTransposeMatrixf (const GLfloat *); GLAPI void APIENTRY glMultTransposeMatrixd (const GLdouble *); GLAPI void APIENTRY glSampleCoverage (GLclampf, GLboolean); GLAPI void APIENTRY glCompressedTexImage3D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexImage2D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexImage1D (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexSubImage2D (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexSubImage1D (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glGetCompressedTexImage (GLenum, GLint, GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture); typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m); typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m); typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m); typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m); typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, GLvoid *img); #endif #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendFuncSeparate (GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glFogCoordf (GLfloat); GLAPI void APIENTRY glFogCoordfv (const GLfloat *); GLAPI void APIENTRY glFogCoordd (GLdouble); GLAPI void APIENTRY glFogCoorddv (const GLdouble *); GLAPI void APIENTRY glFogCoordPointer (GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glMultiDrawArrays (GLenum, GLint *, GLsizei *, GLsizei); GLAPI void APIENTRY glMultiDrawElements (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei); GLAPI void APIENTRY glPointParameterf (GLenum, GLfloat); GLAPI void APIENTRY glPointParameterfv (GLenum, const GLfloat *); GLAPI void APIENTRY glPointParameteri (GLenum, GLint); GLAPI void APIENTRY glPointParameteriv (GLenum, const GLint *); GLAPI void APIENTRY glSecondaryColor3b (GLbyte, GLbyte, GLbyte); GLAPI void APIENTRY glSecondaryColor3bv (const GLbyte *); GLAPI void APIENTRY glSecondaryColor3d (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glSecondaryColor3dv (const GLdouble *); GLAPI void APIENTRY glSecondaryColor3f (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glSecondaryColor3fv (const GLfloat *); GLAPI void APIENTRY glSecondaryColor3i (GLint, GLint, GLint); GLAPI void APIENTRY glSecondaryColor3iv (const GLint *); GLAPI void APIENTRY glSecondaryColor3s (GLshort, GLshort, GLshort); GLAPI void APIENTRY glSecondaryColor3sv (const GLshort *); GLAPI void APIENTRY glSecondaryColor3ub (GLubyte, GLubyte, GLubyte); GLAPI void APIENTRY glSecondaryColor3ubv (const GLubyte *); GLAPI void APIENTRY glSecondaryColor3ui (GLuint, GLuint, GLuint); GLAPI void APIENTRY glSecondaryColor3uiv (const GLuint *); GLAPI void APIENTRY glSecondaryColor3us (GLushort, GLushort, GLushort); GLAPI void APIENTRY glSecondaryColor3usv (const GLushort *); GLAPI void APIENTRY glSecondaryColorPointer (GLint, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glWindowPos2d (GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos2dv (const GLdouble *); GLAPI void APIENTRY glWindowPos2f (GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos2fv (const GLfloat *); GLAPI void APIENTRY glWindowPos2i (GLint, GLint); GLAPI void APIENTRY glWindowPos2iv (const GLint *); GLAPI void APIENTRY glWindowPos2s (GLshort, GLshort); GLAPI void APIENTRY glWindowPos2sv (const GLshort *); GLAPI void APIENTRY glWindowPos3d (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos3dv (const GLdouble *); GLAPI void APIENTRY glWindowPos3f (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos3fv (const GLfloat *); GLAPI void APIENTRY glWindowPos3i (GLint, GLint, GLint); GLAPI void APIENTRY glWindowPos3iv (const GLint *); GLAPI void APIENTRY glWindowPos3s (GLshort, GLshort, GLshort); GLAPI void APIENTRY glWindowPos3sv (const GLshort *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); typedef void (APIENTRYP PFNGLFOGCOORDFPROC) (GLfloat coord); typedef void (APIENTRYP PFNGLFOGCOORDFVPROC) (const GLfloat *coord); typedef void (APIENTRYP PFNGLFOGCOORDDPROC) (GLdouble coord); typedef void (APIENTRYP PFNGLFOGCOORDDVPROC) (const GLdouble *coord); typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount); typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC) (GLint x, GLint y); typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC) (const GLshort *v); #endif #ifndef GL_VERSION_1_5 #define GL_VERSION_1_5 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGenQueries (GLsizei, GLuint *); GLAPI void APIENTRY glDeleteQueries (GLsizei, const GLuint *); GLAPI GLboolean APIENTRY glIsQuery (GLuint); GLAPI void APIENTRY glBeginQuery (GLenum, GLuint); GLAPI void APIENTRY glEndQuery (GLenum); GLAPI void APIENTRY glGetQueryiv (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetQueryObjectiv (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetQueryObjectuiv (GLuint, GLenum, GLuint *); GLAPI void APIENTRY glBindBuffer (GLenum, GLuint); GLAPI void APIENTRY glDeleteBuffers (GLsizei, const GLuint *); GLAPI void APIENTRY glGenBuffers (GLsizei, GLuint *); GLAPI GLboolean APIENTRY glIsBuffer (GLuint); GLAPI void APIENTRY glBufferData (GLenum, GLsizeiptr, const GLvoid *, GLenum); GLAPI void APIENTRY glBufferSubData (GLenum, GLintptr, GLsizeiptr, const GLvoid *); GLAPI void APIENTRY glGetBufferSubData (GLenum, GLintptr, GLsizeiptr, GLvoid *); GLAPI GLvoid* APIENTRY glMapBuffer (GLenum, GLenum); GLAPI GLboolean APIENTRY glUnmapBuffer (GLenum); GLAPI void APIENTRY glGetBufferParameteriv (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetBufferPointerv (GLenum, GLenum, GLvoid* *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGENQUERIESPROC) (GLsizei n, GLuint *ids); typedef void (APIENTRYP PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint *ids); typedef GLboolean (APIENTRYP PFNGLISQUERYPROC) (GLuint id); typedef void (APIENTRYP PFNGLBEGINQUERYPROC) (GLenum target, GLuint id); typedef void (APIENTRYP PFNGLENDQUERYPROC) (GLenum target); typedef void (APIENTRYP PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint *params); typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers); typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC) (GLuint buffer); typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data); typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, GLvoid* *params); #endif #ifndef GL_VERSION_2_0 #define GL_VERSION_2_0 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendEquationSeparate (GLenum, GLenum); GLAPI void APIENTRY glDrawBuffers (GLsizei, const GLenum *); GLAPI void APIENTRY glStencilOpSeparate (GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glStencilFuncSeparate (GLenum, GLenum, GLint, GLuint); GLAPI void APIENTRY glStencilMaskSeparate (GLenum, GLuint); GLAPI void APIENTRY glAttachShader (GLuint, GLuint); GLAPI void APIENTRY glBindAttribLocation (GLuint, GLuint, const GLchar *); GLAPI void APIENTRY glCompileShader (GLuint); GLAPI GLuint APIENTRY glCreateProgram (void); GLAPI GLuint APIENTRY glCreateShader (GLenum); GLAPI void APIENTRY glDeleteProgram (GLuint); GLAPI void APIENTRY glDeleteShader (GLuint); GLAPI void APIENTRY glDetachShader (GLuint, GLuint); GLAPI void APIENTRY glDisableVertexAttribArray (GLuint); GLAPI void APIENTRY glEnableVertexAttribArray (GLuint); GLAPI void APIENTRY glGetActiveAttrib (GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *); GLAPI void APIENTRY glGetActiveUniform (GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *); GLAPI void APIENTRY glGetAttachedShaders (GLuint, GLsizei, GLsizei *, GLuint *); GLAPI GLint APIENTRY glGetAttribLocation (GLuint, const GLchar *); GLAPI void APIENTRY glGetProgramiv (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetProgramInfoLog (GLuint, GLsizei, GLsizei *, GLchar *); GLAPI void APIENTRY glGetShaderiv (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetShaderInfoLog (GLuint, GLsizei, GLsizei *, GLchar *); GLAPI void APIENTRY glGetShaderSource (GLuint, GLsizei, GLsizei *, GLchar *); GLAPI GLint APIENTRY glGetUniformLocation (GLuint, const GLchar *); GLAPI void APIENTRY glGetUniformfv (GLuint, GLint, GLfloat *); GLAPI void APIENTRY glGetUniformiv (GLuint, GLint, GLint *); GLAPI void APIENTRY glGetVertexAttribdv (GLuint, GLenum, GLdouble *); GLAPI void APIENTRY glGetVertexAttribfv (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetVertexAttribiv (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetVertexAttribPointerv (GLuint, GLenum, GLvoid* *); GLAPI GLboolean APIENTRY glIsProgram (GLuint); GLAPI GLboolean APIENTRY glIsShader (GLuint); GLAPI void APIENTRY glLinkProgram (GLuint); GLAPI void APIENTRY glShaderSource (GLuint, GLsizei, const GLchar* *, const GLint *); GLAPI void APIENTRY glUseProgram (GLuint); GLAPI void APIENTRY glUniform1f (GLint, GLfloat); GLAPI void APIENTRY glUniform2f (GLint, GLfloat, GLfloat); GLAPI void APIENTRY glUniform3f (GLint, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glUniform4f (GLint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glUniform1i (GLint, GLint); GLAPI void APIENTRY glUniform2i (GLint, GLint, GLint); GLAPI void APIENTRY glUniform3i (GLint, GLint, GLint, GLint); GLAPI void APIENTRY glUniform4i (GLint, GLint, GLint, GLint, GLint); GLAPI void APIENTRY glUniform1fv (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform2fv (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform3fv (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform4fv (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform1iv (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniform2iv (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniform3iv (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniform4iv (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniformMatrix2fv (GLint, GLsizei, GLboolean, const GLfloat *); GLAPI void APIENTRY glUniformMatrix3fv (GLint, GLsizei, GLboolean, const GLfloat *); GLAPI void APIENTRY glUniformMatrix4fv (GLint, GLsizei, GLboolean, const GLfloat *); GLAPI void APIENTRY glValidateProgram (GLuint); GLAPI void APIENTRY glVertexAttrib1d (GLuint, GLdouble); GLAPI void APIENTRY glVertexAttrib1dv (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib1f (GLuint, GLfloat); GLAPI void APIENTRY glVertexAttrib1fv (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib1s (GLuint, GLshort); GLAPI void APIENTRY glVertexAttrib1sv (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib2d (GLuint, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib2dv (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib2f (GLuint, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib2fv (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib2s (GLuint, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib2sv (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib3d (GLuint, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib3dv (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib3f (GLuint, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib3fv (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib3s (GLuint, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib3sv (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4Nbv (GLuint, const GLbyte *); GLAPI void APIENTRY glVertexAttrib4Niv (GLuint, const GLint *); GLAPI void APIENTRY glVertexAttrib4Nsv (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4Nub (GLuint, GLubyte, GLubyte, GLubyte, GLubyte); GLAPI void APIENTRY glVertexAttrib4Nubv (GLuint, const GLubyte *); GLAPI void APIENTRY glVertexAttrib4Nuiv (GLuint, const GLuint *); GLAPI void APIENTRY glVertexAttrib4Nusv (GLuint, const GLushort *); GLAPI void APIENTRY glVertexAttrib4bv (GLuint, const GLbyte *); GLAPI void APIENTRY glVertexAttrib4d (GLuint, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib4dv (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib4f (GLuint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib4fv (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib4iv (GLuint, const GLint *); GLAPI void APIENTRY glVertexAttrib4s (GLuint, GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib4sv (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4ubv (GLuint, const GLubyte *); GLAPI void APIENTRY glVertexAttrib4uiv (GLuint, const GLuint *); GLAPI void APIENTRY glVertexAttrib4usv (GLuint, const GLushort *); GLAPI void APIENTRY glVertexAttribPointer (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha); typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum *bufs); typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuint mask); typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar *name); typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader); typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void); typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type); typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program); typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader); typedef void (APIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index); typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index); typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj); typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name); typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name); typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat *params); typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC) (GLuint program); typedef GLboolean (APIENTRYP PFNGLISSHADERPROC) (GLuint shader); typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program); typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length); typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program); typedef void (APIENTRYP PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); typedef void (APIENTRYP PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); typedef void (APIENTRYP PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (APIENTRYP PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0); typedef void (APIENTRYP PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); typedef void (APIENTRYP PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); typedef void (APIENTRYP PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (APIENTRYP PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC) (GLuint program); typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); #endif #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glActiveTextureARB (GLenum); GLAPI void APIENTRY glClientActiveTextureARB (GLenum); GLAPI void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble); GLAPI void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat); GLAPI void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord1iARB (GLenum, GLint); GLAPI void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort); GLAPI void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *); GLAPI void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble); GLAPI void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat); GLAPI void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint); GLAPI void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort); GLAPI void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *); GLAPI void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint); GLAPI void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort); GLAPI void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *); GLAPI void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *); GLAPI void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *); GLAPI void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint); GLAPI void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *); GLAPI void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLACTIVETEXTUREARBPROC) (GLenum texture); typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); typedef void (APIENTRYP PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); #endif #ifndef GL_ARB_transpose_matrix #define GL_ARB_transpose_matrix 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *); GLAPI void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *); GLAPI void APIENTRY glMultTransposeMatrixfARB (const GLfloat *); GLAPI void APIENTRY glMultTransposeMatrixdARB (const GLdouble *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *m); typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble *m); typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat *m); typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble *m); #endif #ifndef GL_ARB_multisample #define GL_ARB_multisample 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glSampleCoverageARB (GLclampf, GLboolean); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert); #endif #ifndef GL_ARB_texture_env_add #define GL_ARB_texture_env_add 1 #endif #ifndef GL_ARB_texture_cube_map #define GL_ARB_texture_cube_map 1 #endif #ifndef GL_ARB_texture_compression #define GL_ARB_texture_compression 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, GLvoid *img); #endif #ifndef GL_ARB_texture_border_clamp #define GL_ARB_texture_border_clamp 1 #endif #ifndef GL_ARB_point_parameters #define GL_ARB_point_parameters 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPointParameterfARB (GLenum, GLfloat); GLAPI void APIENTRY glPointParameterfvARB (GLenum, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GLfloat *params); #endif #ifndef GL_ARB_vertex_blend #define GL_ARB_vertex_blend 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glWeightbvARB (GLint, const GLbyte *); GLAPI void APIENTRY glWeightsvARB (GLint, const GLshort *); GLAPI void APIENTRY glWeightivARB (GLint, const GLint *); GLAPI void APIENTRY glWeightfvARB (GLint, const GLfloat *); GLAPI void APIENTRY glWeightdvARB (GLint, const GLdouble *); GLAPI void APIENTRY glWeightubvARB (GLint, const GLubyte *); GLAPI void APIENTRY glWeightusvARB (GLint, const GLushort *); GLAPI void APIENTRY glWeightuivARB (GLint, const GLuint *); GLAPI void APIENTRY glWeightPointerARB (GLint, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glVertexBlendARB (GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLWEIGHTBVARBPROC) (GLint size, const GLbyte *weights); typedef void (APIENTRYP PFNGLWEIGHTSVARBPROC) (GLint size, const GLshort *weights); typedef void (APIENTRYP PFNGLWEIGHTIVARBPROC) (GLint size, const GLint *weights); typedef void (APIENTRYP PFNGLWEIGHTFVARBPROC) (GLint size, const GLfloat *weights); typedef void (APIENTRYP PFNGLWEIGHTDVARBPROC) (GLint size, const GLdouble *weights); typedef void (APIENTRYP PFNGLWEIGHTUBVARBPROC) (GLint size, const GLubyte *weights); typedef void (APIENTRYP PFNGLWEIGHTUSVARBPROC) (GLint size, const GLushort *weights); typedef void (APIENTRYP PFNGLWEIGHTUIVARBPROC) (GLint size, const GLuint *weights); typedef void (APIENTRYP PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRYP PFNGLVERTEXBLENDARBPROC) (GLint count); #endif #ifndef GL_ARB_matrix_palette #define GL_ARB_matrix_palette 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glCurrentPaletteMatrixARB (GLint); GLAPI void APIENTRY glMatrixIndexubvARB (GLint, const GLubyte *); GLAPI void APIENTRY glMatrixIndexusvARB (GLint, const GLushort *); GLAPI void APIENTRY glMatrixIndexuivARB (GLint, const GLuint *); GLAPI void APIENTRY glMatrixIndexPointerARB (GLint, GLenum, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index); typedef void (APIENTRYP PFNGLMATRIXINDEXUBVARBPROC) (GLint size, const GLubyte *indices); typedef void (APIENTRYP PFNGLMATRIXINDEXUSVARBPROC) (GLint size, const GLushort *indices); typedef void (APIENTRYP PFNGLMATRIXINDEXUIVARBPROC) (GLint size, const GLuint *indices); typedef void (APIENTRYP PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); #endif #ifndef GL_ARB_texture_env_combine #define GL_ARB_texture_env_combine 1 #endif #ifndef GL_ARB_texture_env_crossbar #define GL_ARB_texture_env_crossbar 1 #endif #ifndef GL_ARB_texture_env_dot3 #define GL_ARB_texture_env_dot3 1 #endif #ifndef GL_ARB_texture_mirrored_repeat #define GL_ARB_texture_mirrored_repeat 1 #endif #ifndef GL_ARB_depth_texture #define GL_ARB_depth_texture 1 #endif #ifndef GL_ARB_shadow #define GL_ARB_shadow 1 #endif #ifndef GL_ARB_shadow_ambient #define GL_ARB_shadow_ambient 1 #endif #ifndef GL_ARB_window_pos #define GL_ARB_window_pos 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glWindowPos2dARB (GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos2dvARB (const GLdouble *); GLAPI void APIENTRY glWindowPos2fARB (GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos2fvARB (const GLfloat *); GLAPI void APIENTRY glWindowPos2iARB (GLint, GLint); GLAPI void APIENTRY glWindowPos2ivARB (const GLint *); GLAPI void APIENTRY glWindowPos2sARB (GLshort, GLshort); GLAPI void APIENTRY glWindowPos2svARB (const GLshort *); GLAPI void APIENTRY glWindowPos3dARB (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos3dvARB (const GLdouble *); GLAPI void APIENTRY glWindowPos3fARB (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos3fvARB (const GLfloat *); GLAPI void APIENTRY glWindowPos3iARB (GLint, GLint, GLint); GLAPI void APIENTRY glWindowPos3ivARB (const GLint *); GLAPI void APIENTRY glWindowPos3sARB (GLshort, GLshort, GLshort); GLAPI void APIENTRY glWindowPos3svARB (const GLshort *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLWINDOWPOS2DVARBPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLWINDOWPOS2FVARBPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y); typedef void (APIENTRYP PFNGLWINDOWPOS2IVARBPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y); typedef void (APIENTRYP PFNGLWINDOWPOS2SVARBPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLWINDOWPOS3DVARBPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLWINDOWPOS3FVARBPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRYP PFNGLWINDOWPOS3IVARBPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLWINDOWPOS3SVARBPROC) (const GLshort *v); #endif #ifndef GL_ARB_vertex_program #define GL_ARB_vertex_program 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertexAttrib1dARB (GLuint, GLdouble); GLAPI void APIENTRY glVertexAttrib1dvARB (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib1fARB (GLuint, GLfloat); GLAPI void APIENTRY glVertexAttrib1fvARB (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib1sARB (GLuint, GLshort); GLAPI void APIENTRY glVertexAttrib1svARB (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib2dARB (GLuint, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib2dvARB (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib2fARB (GLuint, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib2fvARB (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib2sARB (GLuint, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib2svARB (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib3dARB (GLuint, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib3dvARB (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib3fARB (GLuint, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib3fvARB (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib3sARB (GLuint, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib3svARB (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4NbvARB (GLuint, const GLbyte *); GLAPI void APIENTRY glVertexAttrib4NivARB (GLuint, const GLint *); GLAPI void APIENTRY glVertexAttrib4NsvARB (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4NubARB (GLuint, GLubyte, GLubyte, GLubyte, GLubyte); GLAPI void APIENTRY glVertexAttrib4NubvARB (GLuint, const GLubyte *); GLAPI void APIENTRY glVertexAttrib4NuivARB (GLuint, const GLuint *); GLAPI void APIENTRY glVertexAttrib4NusvARB (GLuint, const GLushort *); GLAPI void APIENTRY glVertexAttrib4bvARB (GLuint, const GLbyte *); GLAPI void APIENTRY glVertexAttrib4dARB (GLuint, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib4dvARB (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib4fARB (GLuint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib4fvARB (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib4ivARB (GLuint, const GLint *); GLAPI void APIENTRY glVertexAttrib4sARB (GLuint, GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib4svARB (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4ubvARB (GLuint, const GLubyte *); GLAPI void APIENTRY glVertexAttrib4uivARB (GLuint, const GLuint *); GLAPI void APIENTRY glVertexAttrib4usvARB (GLuint, const GLushort *); GLAPI void APIENTRY glVertexAttribPointerARB (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *); GLAPI void APIENTRY glEnableVertexAttribArrayARB (GLuint); GLAPI void APIENTRY glDisableVertexAttribArrayARB (GLuint); GLAPI void APIENTRY glProgramStringARB (GLenum, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glBindProgramARB (GLenum, GLuint); GLAPI void APIENTRY glDeleteProgramsARB (GLsizei, const GLuint *); GLAPI void APIENTRY glGenProgramsARB (GLsizei, GLuint *); GLAPI void APIENTRY glProgramEnvParameter4dARB (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glProgramEnvParameter4dvARB (GLenum, GLuint, const GLdouble *); GLAPI void APIENTRY glProgramEnvParameter4fARB (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glProgramEnvParameter4fvARB (GLenum, GLuint, const GLfloat *); GLAPI void APIENTRY glProgramLocalParameter4dARB (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glProgramLocalParameter4dvARB (GLenum, GLuint, const GLdouble *); GLAPI void APIENTRY glProgramLocalParameter4fARB (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glProgramLocalParameter4fvARB (GLenum, GLuint, const GLfloat *); GLAPI void APIENTRY glGetProgramEnvParameterdvARB (GLenum, GLuint, GLdouble *); GLAPI void APIENTRY glGetProgramEnvParameterfvARB (GLenum, GLuint, GLfloat *); GLAPI void APIENTRY glGetProgramLocalParameterdvARB (GLenum, GLuint, GLdouble *); GLAPI void APIENTRY glGetProgramLocalParameterfvARB (GLenum, GLuint, GLfloat *); GLAPI void APIENTRY glGetProgramivARB (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetProgramStringARB (GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetVertexAttribdvARB (GLuint, GLenum, GLdouble *); GLAPI void APIENTRY glGetVertexAttribfvARB (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetVertexAttribivARB (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetVertexAttribPointervARB (GLuint, GLenum, GLvoid* *); GLAPI GLboolean APIENTRY glIsProgramARB (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (APIENTRYP PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); typedef void (APIENTRYP PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); typedef void (APIENTRYP PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRYP PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs); typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); typedef void (APIENTRYP PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRYP PFNGLISPROGRAMARBPROC) (GLuint program); #endif #ifndef GL_ARB_fragment_program #define GL_ARB_fragment_program 1 /* All ARB_fragment_program entry points are shared with ARB_vertex_program. */ #endif #ifndef GL_ARB_vertex_buffer_object #define GL_ARB_vertex_buffer_object 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBindBufferARB (GLenum, GLuint); GLAPI void APIENTRY glDeleteBuffersARB (GLsizei, const GLuint *); GLAPI void APIENTRY glGenBuffersARB (GLsizei, GLuint *); GLAPI GLboolean APIENTRY glIsBufferARB (GLuint); GLAPI void APIENTRY glBufferDataARB (GLenum, GLsizeiptrARB, const GLvoid *, GLenum); GLAPI void APIENTRY glBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid *); GLAPI void APIENTRY glGetBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrARB, GLvoid *); GLAPI GLvoid* APIENTRY glMapBufferARB (GLenum, GLenum); GLAPI GLboolean APIENTRY glUnmapBufferARB (GLenum); GLAPI void APIENTRY glGetBufferParameterivARB (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetBufferPointervARB (GLenum, GLenum, GLvoid* *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); typedef void (APIENTRYP PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers); typedef void (APIENTRYP PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers); typedef GLboolean (APIENTRYP PFNGLISBUFFERARBPROC) (GLuint buffer); typedef void (APIENTRYP PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage); typedef void (APIENTRYP PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data); typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data); typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERARBPROC) (GLenum target); typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, GLvoid* *params); #endif #ifndef GL_ARB_occlusion_query #define GL_ARB_occlusion_query 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGenQueriesARB (GLsizei, GLuint *); GLAPI void APIENTRY glDeleteQueriesARB (GLsizei, const GLuint *); GLAPI GLboolean APIENTRY glIsQueryARB (GLuint); GLAPI void APIENTRY glBeginQueryARB (GLenum, GLuint); GLAPI void APIENTRY glEndQueryARB (GLenum); GLAPI void APIENTRY glGetQueryivARB (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetQueryObjectivARB (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetQueryObjectuivARB (GLuint, GLenum, GLuint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint *ids); typedef void (APIENTRYP PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLuint *ids); typedef GLboolean (APIENTRYP PFNGLISQUERYARBPROC) (GLuint id); typedef void (APIENTRYP PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id); typedef void (APIENTRYP PFNGLENDQUERYARBPROC) (GLenum target); typedef void (APIENTRYP PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint *params); #endif #ifndef GL_ARB_shader_objects #define GL_ARB_shader_objects 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDeleteObjectARB (GLhandleARB); GLAPI GLhandleARB APIENTRY glGetHandleARB (GLenum); GLAPI void APIENTRY glDetachObjectARB (GLhandleARB, GLhandleARB); GLAPI GLhandleARB APIENTRY glCreateShaderObjectARB (GLenum); GLAPI void APIENTRY glShaderSourceARB (GLhandleARB, GLsizei, const GLcharARB* *, const GLint *); GLAPI void APIENTRY glCompileShaderARB (GLhandleARB); GLAPI GLhandleARB APIENTRY glCreateProgramObjectARB (void); GLAPI void APIENTRY glAttachObjectARB (GLhandleARB, GLhandleARB); GLAPI void APIENTRY glLinkProgramARB (GLhandleARB); GLAPI void APIENTRY glUseProgramObjectARB (GLhandleARB); GLAPI void APIENTRY glValidateProgramARB (GLhandleARB); GLAPI void APIENTRY glUniform1fARB (GLint, GLfloat); GLAPI void APIENTRY glUniform2fARB (GLint, GLfloat, GLfloat); GLAPI void APIENTRY glUniform3fARB (GLint, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glUniform4fARB (GLint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glUniform1iARB (GLint, GLint); GLAPI void APIENTRY glUniform2iARB (GLint, GLint, GLint); GLAPI void APIENTRY glUniform3iARB (GLint, GLint, GLint, GLint); GLAPI void APIENTRY glUniform4iARB (GLint, GLint, GLint, GLint, GLint); GLAPI void APIENTRY glUniform1fvARB (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform2fvARB (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform3fvARB (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform4fvARB (GLint, GLsizei, const GLfloat *); GLAPI void APIENTRY glUniform1ivARB (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniform2ivARB (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniform3ivARB (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniform4ivARB (GLint, GLsizei, const GLint *); GLAPI void APIENTRY glUniformMatrix2fvARB (GLint, GLsizei, GLboolean, const GLfloat *); GLAPI void APIENTRY glUniformMatrix3fvARB (GLint, GLsizei, GLboolean, const GLfloat *); GLAPI void APIENTRY glUniformMatrix4fvARB (GLint, GLsizei, GLboolean, const GLfloat *); GLAPI void APIENTRY glGetObjectParameterfvARB (GLhandleARB, GLenum, GLfloat *); GLAPI void APIENTRY glGetObjectParameterivARB (GLhandleARB, GLenum, GLint *); GLAPI void APIENTRY glGetInfoLogARB (GLhandleARB, GLsizei, GLsizei *, GLcharARB *); GLAPI void APIENTRY glGetAttachedObjectsARB (GLhandleARB, GLsizei, GLsizei *, GLhandleARB *); GLAPI GLint APIENTRY glGetUniformLocationARB (GLhandleARB, const GLcharARB *); GLAPI void APIENTRY glGetActiveUniformARB (GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *); GLAPI void APIENTRY glGetUniformfvARB (GLhandleARB, GLint, GLfloat *); GLAPI void APIENTRY glGetUniformivARB (GLhandleARB, GLint, GLint *); GLAPI void APIENTRY glGetShaderSourceARB (GLhandleARB, GLsizei, GLsizei *, GLcharARB *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); typedef GLhandleARB (APIENTRYP PFNGLGETHANDLEARBPROC) (GLenum pname); typedef void (APIENTRYP PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); typedef GLhandleARB (APIENTRYP PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); typedef void (APIENTRYP PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length); typedef void (APIENTRYP PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); typedef GLhandleARB (APIENTRYP PFNGLCREATEPROGRAMOBJECTARBPROC) (void); typedef void (APIENTRYP PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); typedef void (APIENTRYP PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); typedef void (APIENTRYP PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); typedef void (APIENTRYP PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); typedef void (APIENTRYP PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); typedef void (APIENTRYP PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); typedef void (APIENTRYP PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); typedef void (APIENTRYP PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); typedef void (APIENTRYP PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); typedef void (APIENTRYP PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); typedef void (APIENTRYP PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); typedef void (APIENTRYP PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); typedef void (APIENTRYP PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint *value); typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog); typedef void (APIENTRYP PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj); typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name); typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name); typedef void (APIENTRYP PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat *params); typedef void (APIENTRYP PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint *params); typedef void (APIENTRYP PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source); #endif #ifndef GL_ARB_vertex_shader #define GL_ARB_vertex_shader 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBindAttribLocationARB (GLhandleARB, GLuint, const GLcharARB *); GLAPI void APIENTRY glGetActiveAttribARB (GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *); GLAPI GLint APIENTRY glGetAttribLocationARB (GLhandleARB, const GLcharARB *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB *name); typedef void (APIENTRYP PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name); typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name); #endif #ifndef GL_ARB_fragment_shader #define GL_ARB_fragment_shader 1 #endif #ifndef GL_ARB_shading_language_100 #define GL_ARB_shading_language_100 1 #endif #ifndef GL_ARB_texture_non_power_of_two #define GL_ARB_texture_non_power_of_two 1 #endif #ifndef GL_ARB_point_sprite #define GL_ARB_point_sprite 1 #endif #ifndef GL_ARB_fragment_program_shadow #define GL_ARB_fragment_program_shadow 1 #endif #ifndef GL_ARB_draw_buffers #define GL_ARB_draw_buffers 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDrawBuffersARB (GLsizei, const GLenum *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum *bufs); #endif #ifndef GL_ARB_texture_rectangle #define GL_ARB_texture_rectangle 1 #endif #ifndef GL_ARB_color_buffer_float #define GL_ARB_color_buffer_float 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glClampColorARB (GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp); #endif #ifndef GL_ARB_half_float_pixel #define GL_ARB_half_float_pixel 1 #endif #ifndef GL_ARB_texture_float #define GL_ARB_texture_float 1 #endif #ifndef GL_ARB_pixel_buffer_object #define GL_ARB_pixel_buffer_object 1 #endif #ifndef GL_EXT_abgr #define GL_EXT_abgr 1 #endif #ifndef GL_EXT_blend_color #define GL_EXT_blend_color 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); #endif #ifndef GL_EXT_polygon_offset #define GL_EXT_polygon_offset 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias); #endif #ifndef GL_EXT_texture #define GL_EXT_texture 1 #endif #ifndef GL_EXT_texture3D #define GL_EXT_texture3D 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); #endif #ifndef GL_SGIS_texture_filter4 #define GL_SGIS_texture_filter4 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat *weights); typedef void (APIENTRYP PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights); #endif #ifndef GL_EXT_subtexture #define GL_EXT_subtexture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); #endif #ifndef GL_EXT_copy_texture #define GL_EXT_copy_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint); GLAPI void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); GLAPI void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei); GLAPI void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); GLAPI void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); #endif #ifndef GL_EXT_histogram #define GL_EXT_histogram 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *); GLAPI void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean); GLAPI void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean); GLAPI void APIENTRY glResetHistogramEXT (GLenum); GLAPI void APIENTRY glResetMinmaxEXT (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); typedef void (APIENTRYP PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink); typedef void (APIENTRYP PFNGLRESETHISTOGRAMEXTPROC) (GLenum target); typedef void (APIENTRYP PFNGLRESETMINMAXEXTPROC) (GLenum target); #endif #ifndef GL_EXT_convolution #define GL_EXT_convolution 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat); GLAPI void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint); GLAPI void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei); GLAPI void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei); GLAPI void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *); GLAPI void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat params); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint params); typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); #endif #ifndef GL_EXT_color_matrix #define GL_EXT_color_matrix 1 #endif #ifndef GL_SGI_color_table #define GL_SGI_color_table 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei); GLAPI void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRYP PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params); #endif #ifndef GL_SGIX_pixel_texture #define GL_SGIX_pixel_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPixelTexGenSGIX (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPIXELTEXGENSGIXPROC) (GLenum mode); #endif #ifndef GL_SGIS_pixel_texture #define GL_SGIS_pixel_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint); GLAPI void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *); GLAPI void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat); GLAPI void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *); GLAPI void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *); GLAPI void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, GLfloat *params); #endif #ifndef GL_SGIS_texture4D #define GL_SGIS_texture4D 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRYP PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels); #endif #ifndef GL_SGI_texture_color_table #define GL_SGI_texture_color_table 1 #endif #ifndef GL_EXT_cmyka #define GL_EXT_cmyka 1 #endif #ifndef GL_EXT_texture_object #define GL_EXT_texture_object 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *); GLAPI void APIENTRY glBindTextureEXT (GLenum, GLuint); GLAPI void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *); GLAPI void APIENTRY glGenTexturesEXT (GLsizei, GLuint *); GLAPI GLboolean APIENTRY glIsTextureEXT (GLuint); GLAPI void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLboolean (APIENTRYP PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint *textures, GLboolean *residences); typedef void (APIENTRYP PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture); typedef void (APIENTRYP PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint *textures); typedef void (APIENTRYP PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *textures); typedef GLboolean (APIENTRYP PFNGLISTEXTUREEXTPROC) (GLuint texture); typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint *textures, const GLclampf *priorities); #endif #ifndef GL_SGIS_detail_texture #define GL_SGIS_detail_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *); GLAPI void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points); typedef void (APIENTRYP PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat *points); #endif #ifndef GL_SGIS_sharpen_texture #define GL_SGIS_sharpen_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *); GLAPI void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points); typedef void (APIENTRYP PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat *points); #endif #ifndef GL_EXT_packed_pixels #define GL_EXT_packed_pixels 1 #endif #ifndef GL_SGIS_texture_lod #define GL_SGIS_texture_lod 1 #endif #ifndef GL_SGIS_multisample #define GL_SGIS_multisample 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean); GLAPI void APIENTRY glSamplePatternSGIS (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert); typedef void (APIENTRYP PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); #endif #ifndef GL_EXT_rescale_normal #define GL_EXT_rescale_normal 1 #endif #ifndef GL_EXT_vertex_array #define GL_EXT_vertex_array 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glArrayElementEXT (GLint); GLAPI void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *); GLAPI void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei); GLAPI void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *); GLAPI void APIENTRY glGetPointervEXT (GLenum, GLvoid* *); GLAPI void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *); GLAPI void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *); GLAPI void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *); GLAPI void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLARRAYELEMENTEXTPROC) (GLint i); typedef void (APIENTRYP PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); typedef void (APIENTRYP PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); typedef void (APIENTRYP PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean *pointer); typedef void (APIENTRYP PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *params); typedef void (APIENTRYP PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); typedef void (APIENTRYP PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); typedef void (APIENTRYP PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); typedef void (APIENTRYP PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); #endif #ifndef GL_EXT_misc_attribute #define GL_EXT_misc_attribute 1 #endif #ifndef GL_SGIS_generate_mipmap #define GL_SGIS_generate_mipmap 1 #endif #ifndef GL_SGIX_clipmap #define GL_SGIX_clipmap 1 #endif #ifndef GL_SGIX_shadow #define GL_SGIX_shadow 1 #endif #ifndef GL_SGIS_texture_edge_clamp #define GL_SGIS_texture_edge_clamp 1 #endif #ifndef GL_SGIS_texture_border_clamp #define GL_SGIS_texture_border_clamp 1 #endif #ifndef GL_EXT_blend_minmax #define GL_EXT_blend_minmax 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendEquationEXT (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); #endif #ifndef GL_EXT_blend_subtract #define GL_EXT_blend_subtract 1 #endif #ifndef GL_EXT_blend_logic_op #define GL_EXT_blend_logic_op 1 #endif #ifndef GL_SGIX_interlace #define GL_SGIX_interlace 1 #endif #ifndef GL_SGIX_pixel_tiles #define GL_SGIX_pixel_tiles 1 #endif #ifndef GL_SGIX_texture_select #define GL_SGIX_texture_select 1 #endif #ifndef GL_SGIX_sprite #define GL_SGIX_sprite 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat); GLAPI void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *); GLAPI void APIENTRY glSpriteParameteriSGIX (GLenum, GLint); GLAPI void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, const GLint *params); #endif #ifndef GL_SGIX_texture_multi_buffer #define GL_SGIX_texture_multi_buffer 1 #endif #ifndef GL_EXT_point_parameters #define GL_EXT_point_parameters 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPointParameterfEXT (GLenum, GLfloat); GLAPI void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params); #endif #ifndef GL_SGIS_point_parameters #define GL_SGIS_point_parameters 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPointParameterfSGIS (GLenum, GLfloat); GLAPI void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params); #endif #ifndef GL_SGIX_instruments #define GL_SGIX_instruments 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLint APIENTRY glGetInstrumentsSGIX (void); GLAPI void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *); GLAPI GLint APIENTRY glPollInstrumentsSGIX (GLint *); GLAPI void APIENTRY glReadInstrumentsSGIX (GLint); GLAPI void APIENTRY glStartInstrumentsSGIX (void); GLAPI void APIENTRY glStopInstrumentsSGIX (GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLint (APIENTRYP PFNGLGETINSTRUMENTSSGIXPROC) (void); typedef void (APIENTRYP PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLint *buffer); typedef GLint (APIENTRYP PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p); typedef void (APIENTRYP PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker); typedef void (APIENTRYP PFNGLSTARTINSTRUMENTSSGIXPROC) (void); typedef void (APIENTRYP PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker); #endif #ifndef GL_SGIX_texture_scale_bias #define GL_SGIX_texture_scale_bias 1 #endif #ifndef GL_SGIX_framezoom #define GL_SGIX_framezoom 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFrameZoomSGIX (GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFRAMEZOOMSGIXPROC) (GLint factor); #endif #ifndef GL_SGIX_tag_sample_buffer #define GL_SGIX_tag_sample_buffer 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTagSampleBufferSGIX (void); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); #endif #ifndef GL_SGIX_polynomial_ffd #define GL_SGIX_polynomial_ffd 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDeformationMap3dSGIX (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *); GLAPI void APIENTRY glDeformationMap3fSGIX (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *); GLAPI void APIENTRY glDeformSGIX (GLbitfield); GLAPI void APIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDEFORMATIONMAP3DSGIXPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points); typedef void (APIENTRYP PFNGLDEFORMATIONMAP3FSGIXPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points); typedef void (APIENTRYP PFNGLDEFORMSGIXPROC) (GLbitfield mask); typedef void (APIENTRYP PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) (GLbitfield mask); #endif #ifndef GL_SGIX_reference_plane #define GL_SGIX_reference_plane 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glReferencePlaneSGIX (const GLdouble *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equation); #endif #ifndef GL_SGIX_flush_raster #define GL_SGIX_flush_raster 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFlushRasterSGIX (void); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFLUSHRASTERSGIXPROC) (void); #endif #ifndef GL_SGIX_depth_texture #define GL_SGIX_depth_texture 1 #endif #ifndef GL_SGIS_fog_function #define GL_SGIS_fog_function 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *); GLAPI void APIENTRY glGetFogFuncSGIS (GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *points); typedef void (APIENTRYP PFNGLGETFOGFUNCSGISPROC) (GLfloat *points); #endif #ifndef GL_SGIX_fog_offset #define GL_SGIX_fog_offset 1 #endif #ifndef GL_HP_image_transform #define GL_HP_image_transform 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint); GLAPI void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat); GLAPI void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, GLint param); typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, GLfloat *params); #endif #ifndef GL_HP_convolution_border_modes #define GL_HP_convolution_border_modes 1 #endif #ifndef GL_SGIX_texture_add_env #define GL_SGIX_texture_add_env 1 #endif #ifndef GL_EXT_color_subtable #define GL_EXT_color_subtable 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); #endif #ifndef GL_PGI_vertex_hints #define GL_PGI_vertex_hints 1 #endif #ifndef GL_PGI_misc_hints #define GL_PGI_misc_hints 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glHintPGI (GLenum, GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLHINTPGIPROC) (GLenum target, GLint mode); #endif #ifndef GL_EXT_paletted_texture #define GL_EXT_paletted_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); GLAPI void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *); GLAPI void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRYP PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data); typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); #endif #ifndef GL_EXT_clip_volume_hint #define GL_EXT_clip_volume_hint 1 #endif #ifndef GL_SGIX_list_priority #define GL_SGIX_list_priority 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *); GLAPI void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat); GLAPI void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *); GLAPI void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint); GLAPI void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum pname, GLint param); typedef void (APIENTRYP PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, const GLint *params); #endif #ifndef GL_SGIX_ir_instrument1 #define GL_SGIX_ir_instrument1 1 #endif #ifndef GL_SGIX_calligraphic_fragment #define GL_SGIX_calligraphic_fragment 1 #endif #ifndef GL_SGIX_texture_lod_bias #define GL_SGIX_texture_lod_bias 1 #endif #ifndef GL_SGIX_shadow_ambient #define GL_SGIX_shadow_ambient 1 #endif #ifndef GL_EXT_index_texture #define GL_EXT_index_texture 1 #endif #ifndef GL_EXT_index_material #define GL_EXT_index_material 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glIndexMaterialEXT (GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode); #endif #ifndef GL_EXT_index_func #define GL_EXT_index_func 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glIndexFuncEXT (GLenum, GLclampf); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref); #endif #ifndef GL_EXT_index_array_formats #define GL_EXT_index_array_formats 1 #endif #ifndef GL_EXT_compiled_vertex_array #define GL_EXT_compiled_vertex_array 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glLockArraysEXT (GLint, GLsizei); GLAPI void APIENTRY glUnlockArraysEXT (void); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); typedef void (APIENTRYP PFNGLUNLOCKARRAYSEXTPROC) (void); #endif #ifndef GL_EXT_cull_vertex #define GL_EXT_cull_vertex 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *); GLAPI void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble *params); typedef void (APIENTRYP PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat *params); #endif #ifndef GL_SGIX_ycrcb #define GL_SGIX_ycrcb 1 #endif #ifndef GL_SGIX_fragment_lighting #define GL_SGIX_fragment_lighting 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum); GLAPI void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat); GLAPI void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint); GLAPI void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat); GLAPI void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *); GLAPI void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint); GLAPI void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *); GLAPI void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat); GLAPI void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint); GLAPI void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *); GLAPI void APIENTRY glLightEnviSGIX (GLenum, GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, GLint param); typedef void (APIENTRYP PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint param); #endif #ifndef GL_IBM_rasterpos_clip #define GL_IBM_rasterpos_clip 1 #endif #ifndef GL_HP_texture_lighting #define GL_HP_texture_lighting 1 #endif #ifndef GL_EXT_draw_range_elements #define GL_EXT_draw_range_elements 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); #endif #ifndef GL_WIN_phong_shading #define GL_WIN_phong_shading 1 #endif #ifndef GL_WIN_specular_fog #define GL_WIN_specular_fog 1 #endif #ifndef GL_EXT_light_texture #define GL_EXT_light_texture 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glApplyTextureEXT (GLenum); GLAPI void APIENTRY glTextureLightEXT (GLenum); GLAPI void APIENTRY glTextureMaterialEXT (GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode); typedef void (APIENTRYP PFNGLTEXTURELIGHTEXTPROC) (GLenum pname); typedef void (APIENTRYP PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode); #endif #ifndef GL_SGIX_blend_alpha_minmax #define GL_SGIX_blend_alpha_minmax 1 #endif #ifndef GL_EXT_bgra #define GL_EXT_bgra 1 #endif #ifndef GL_SGIX_async #define GL_SGIX_async 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glAsyncMarkerSGIX (GLuint); GLAPI GLint APIENTRY glFinishAsyncSGIX (GLuint *); GLAPI GLint APIENTRY glPollAsyncSGIX (GLuint *); GLAPI GLuint APIENTRY glGenAsyncMarkersSGIX (GLsizei); GLAPI void APIENTRY glDeleteAsyncMarkersSGIX (GLuint, GLsizei); GLAPI GLboolean APIENTRY glIsAsyncMarkerSGIX (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLASYNCMARKERSGIXPROC) (GLuint marker); typedef GLint (APIENTRYP PFNGLFINISHASYNCSGIXPROC) (GLuint *markerp); typedef GLint (APIENTRYP PFNGLPOLLASYNCSGIXPROC) (GLuint *markerp); typedef GLuint (APIENTRYP PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range); typedef void (APIENTRYP PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range); typedef GLboolean (APIENTRYP PFNGLISASYNCMARKERSGIXPROC) (GLuint marker); #endif #ifndef GL_SGIX_async_pixel #define GL_SGIX_async_pixel 1 #endif #ifndef GL_SGIX_async_histogram #define GL_SGIX_async_histogram 1 #endif #ifndef GL_INTEL_parallel_arrays #define GL_INTEL_parallel_arrays 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *); GLAPI void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *); GLAPI void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *); GLAPI void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer); typedef void (APIENTRYP PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const GLvoid* *pointer); typedef void (APIENTRYP PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer); typedef void (APIENTRYP PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer); #endif #ifndef GL_HP_occlusion_test #define GL_HP_occlusion_test 1 #endif #ifndef GL_EXT_pixel_transform #define GL_EXT_pixel_transform 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint); GLAPI void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat); GLAPI void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param); typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params); #endif #ifndef GL_EXT_pixel_transform_color_table #define GL_EXT_pixel_transform_color_table 1 #endif #ifndef GL_EXT_shared_texture_palette #define GL_EXT_shared_texture_palette 1 #endif #ifndef GL_EXT_separate_specular_color #define GL_EXT_separate_specular_color 1 #endif #ifndef GL_EXT_secondary_color #define GL_EXT_secondary_color 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte); GLAPI void APIENTRY glSecondaryColor3bvEXT (const GLbyte *); GLAPI void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glSecondaryColor3dvEXT (const GLdouble *); GLAPI void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glSecondaryColor3fvEXT (const GLfloat *); GLAPI void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint); GLAPI void APIENTRY glSecondaryColor3ivEXT (const GLint *); GLAPI void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort); GLAPI void APIENTRY glSecondaryColor3svEXT (const GLshort *); GLAPI void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte); GLAPI void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *); GLAPI void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint); GLAPI void APIENTRY glSecondaryColor3uivEXT (const GLuint *); GLAPI void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort); GLAPI void APIENTRY glSecondaryColor3usvEXT (const GLushort *); GLAPI void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v); typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); #endif #ifndef GL_EXT_texture_perturb_normal #define GL_EXT_texture_perturb_normal 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTextureNormalEXT (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTEXTURENORMALEXTPROC) (GLenum mode); #endif #ifndef GL_EXT_multi_draw_arrays #define GL_EXT_multi_draw_arrays 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei); GLAPI void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount); #endif #ifndef GL_EXT_fog_coord #define GL_EXT_fog_coord 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFogCoordfEXT (GLfloat); GLAPI void APIENTRY glFogCoordfvEXT (const GLfloat *); GLAPI void APIENTRY glFogCoorddEXT (GLdouble); GLAPI void APIENTRY glFogCoorddvEXT (const GLdouble *); GLAPI void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFOGCOORDFEXTPROC) (GLfloat coord); typedef void (APIENTRYP PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord); typedef void (APIENTRYP PFNGLFOGCOORDDEXTPROC) (GLdouble coord); typedef void (APIENTRYP PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord); typedef void (APIENTRYP PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); #endif #ifndef GL_REND_screen_coordinates #define GL_REND_screen_coordinates 1 #endif #ifndef GL_EXT_coordinate_frame #define GL_EXT_coordinate_frame 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte); GLAPI void APIENTRY glTangent3bvEXT (const GLbyte *); GLAPI void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glTangent3dvEXT (const GLdouble *); GLAPI void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTangent3fvEXT (const GLfloat *); GLAPI void APIENTRY glTangent3iEXT (GLint, GLint, GLint); GLAPI void APIENTRY glTangent3ivEXT (const GLint *); GLAPI void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort); GLAPI void APIENTRY glTangent3svEXT (const GLshort *); GLAPI void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte); GLAPI void APIENTRY glBinormal3bvEXT (const GLbyte *); GLAPI void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glBinormal3dvEXT (const GLdouble *); GLAPI void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glBinormal3fvEXT (const GLfloat *); GLAPI void APIENTRY glBinormal3iEXT (GLint, GLint, GLint); GLAPI void APIENTRY glBinormal3ivEXT (const GLint *); GLAPI void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort); GLAPI void APIENTRY glBinormal3svEXT (const GLshort *); GLAPI void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLbyte tz); typedef void (APIENTRYP PFNGLTANGENT3BVEXTPROC) (const GLbyte *v); typedef void (APIENTRYP PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty, GLdouble tz); typedef void (APIENTRYP PFNGLTANGENT3DVEXTPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, GLfloat tz); typedef void (APIENTRYP PFNGLTANGENT3FVEXTPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint tz); typedef void (APIENTRYP PFNGLTANGENT3IVEXTPROC) (const GLint *v); typedef void (APIENTRYP PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, GLshort tz); typedef void (APIENTRYP PFNGLTANGENT3SVEXTPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GLbyte bz); typedef void (APIENTRYP PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v); typedef void (APIENTRYP PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by, GLdouble bz); typedef void (APIENTRYP PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by, GLfloat bz); typedef void (APIENTRYP PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLint bz); typedef void (APIENTRYP PFNGLBINORMAL3IVEXTPROC) (const GLint *v); typedef void (APIENTRYP PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by, GLshort bz); typedef void (APIENTRYP PFNGLBINORMAL3SVEXTPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRYP PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); #endif #ifndef GL_EXT_texture_env_combine #define GL_EXT_texture_env_combine 1 #endif #ifndef GL_APPLE_specular_vector #define GL_APPLE_specular_vector 1 #endif #ifndef GL_APPLE_transform_hint #define GL_APPLE_transform_hint 1 #endif #ifndef GL_SGIX_fog_scale #define GL_SGIX_fog_scale 1 #endif #ifndef GL_SUNX_constant_data #define GL_SUNX_constant_data 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFinishTextureSUNX (void); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFINISHTEXTURESUNXPROC) (void); #endif #ifndef GL_SUN_global_alpha #define GL_SUN_global_alpha 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGlobalAlphaFactorbSUN (GLbyte); GLAPI void APIENTRY glGlobalAlphaFactorsSUN (GLshort); GLAPI void APIENTRY glGlobalAlphaFactoriSUN (GLint); GLAPI void APIENTRY glGlobalAlphaFactorfSUN (GLfloat); GLAPI void APIENTRY glGlobalAlphaFactordSUN (GLdouble); GLAPI void APIENTRY glGlobalAlphaFactorubSUN (GLubyte); GLAPI void APIENTRY glGlobalAlphaFactorusSUN (GLushort); GLAPI void APIENTRY glGlobalAlphaFactoruiSUN (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor); typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor); #endif #ifndef GL_SUN_triangle_list #define GL_SUN_triangle_list 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glReplacementCodeuiSUN (GLuint); GLAPI void APIENTRY glReplacementCodeusSUN (GLushort); GLAPI void APIENTRY glReplacementCodeubSUN (GLubyte); GLAPI void APIENTRY glReplacementCodeuivSUN (const GLuint *); GLAPI void APIENTRY glReplacementCodeusvSUN (const GLushort *); GLAPI void APIENTRY glReplacementCodeubvSUN (const GLubyte *); GLAPI void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *code); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *code); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *code); typedef void (APIENTRYP PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const GLvoid* *pointer); #endif #ifndef GL_SUN_vertex #define GL_SUN_vertex 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat); GLAPI void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *); GLAPI void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *); GLAPI void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *); GLAPI void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *); GLAPI void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *); GLAPI void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *); GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *); GLAPI void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLuint *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint *, const GLubyte *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *); GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c, const GLfloat *v); typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c, const GLfloat *v); typedef void (APIENTRYP PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *v); typedef void (APIENTRYP PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat *tc, const GLubyte *c, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint *rc, const GLubyte *c, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); #endif #ifndef GL_EXT_blend_func_separate #define GL_EXT_blend_func_separate 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); #endif #ifndef GL_INGR_blend_func_separate #define GL_INGR_blend_func_separate 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendFuncSeparateINGR (GLenum, GLenum, GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEINGRPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); #endif #ifndef GL_INGR_color_clamp #define GL_INGR_color_clamp 1 #endif #ifndef GL_INGR_interlace_read #define GL_INGR_interlace_read 1 #endif #ifndef GL_EXT_stencil_wrap #define GL_EXT_stencil_wrap 1 #endif #ifndef GL_EXT_422_pixels #define GL_EXT_422_pixels 1 #endif #ifndef GL_NV_texgen_reflection #define GL_NV_texgen_reflection 1 #endif #ifndef GL_SUN_convolution_border_modes #define GL_SUN_convolution_border_modes 1 #endif #ifndef GL_EXT_texture_env_add #define GL_EXT_texture_env_add 1 #endif #ifndef GL_EXT_texture_lod_bias #define GL_EXT_texture_lod_bias 1 #endif #ifndef GL_EXT_texture_filter_anisotropic #define GL_EXT_texture_filter_anisotropic 1 #endif #ifndef GL_EXT_vertex_weighting #define GL_EXT_vertex_weighting 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertexWeightfEXT (GLfloat); GLAPI void APIENTRY glVertexWeightfvEXT (const GLfloat *); GLAPI void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight); typedef void (APIENTRYP PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight); typedef void (APIENTRYP PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer); #endif #ifndef GL_NV_light_max_exponent #define GL_NV_light_max_exponent 1 #endif #ifndef GL_NV_vertex_array_range #define GL_NV_vertex_array_range 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glFlushVertexArrayRangeNV (void); GLAPI void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void); typedef void (APIENTRYP PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, const GLvoid *pointer); #endif #ifndef GL_NV_register_combiners #define GL_NV_register_combiners 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *); GLAPI void APIENTRY glCombinerParameterfNV (GLenum, GLfloat); GLAPI void APIENTRY glCombinerParameterivNV (GLenum, const GLint *); GLAPI void APIENTRY glCombinerParameteriNV (GLenum, GLint); GLAPI void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean); GLAPI void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param); typedef void (APIENTRYP PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); typedef void (APIENTRYP PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); typedef void (APIENTRYP PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); typedef void (APIENTRYP PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint *params); #endif #ifndef GL_NV_fog_distance #define GL_NV_fog_distance 1 #endif #ifndef GL_NV_texgen_emboss #define GL_NV_texgen_emboss 1 #endif #ifndef GL_NV_blend_square #define GL_NV_blend_square 1 #endif #ifndef GL_NV_texture_env_combine4 #define GL_NV_texture_env_combine4 1 #endif #ifndef GL_MESA_resize_buffers #define GL_MESA_resize_buffers 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glResizeBuffersMESA (void); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLRESIZEBUFFERSMESAPROC) (void); #endif #ifndef GL_MESA_window_pos #define GL_MESA_window_pos 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos2dvMESA (const GLdouble *); GLAPI void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos2fvMESA (const GLfloat *); GLAPI void APIENTRY glWindowPos2iMESA (GLint, GLint); GLAPI void APIENTRY glWindowPos2ivMESA (const GLint *); GLAPI void APIENTRY glWindowPos2sMESA (GLshort, GLshort); GLAPI void APIENTRY glWindowPos2svMESA (const GLshort *); GLAPI void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos3dvMESA (const GLdouble *); GLAPI void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos3fvMESA (const GLfloat *); GLAPI void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint); GLAPI void APIENTRY glWindowPos3ivMESA (const GLint *); GLAPI void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort); GLAPI void APIENTRY glWindowPos3svMESA (const GLshort *); GLAPI void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glWindowPos4dvMESA (const GLdouble *); GLAPI void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glWindowPos4fvMESA (const GLfloat *); GLAPI void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint); GLAPI void APIENTRY glWindowPos4ivMESA (const GLint *); GLAPI void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glWindowPos4svMESA (const GLshort *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y); typedef void (APIENTRYP PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y); typedef void (APIENTRYP PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRYP PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v); typedef void (APIENTRYP PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v); typedef void (APIENTRYP PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v); typedef void (APIENTRYP PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w); typedef void (APIENTRYP PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v); typedef void (APIENTRYP PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRYP PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v); #endif #ifndef GL_IBM_cull_vertex #define GL_IBM_cull_vertex 1 #endif #ifndef GL_IBM_multimode_draw_arrays #define GL_IBM_multimode_draw_arrays 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glMultiModeDrawArraysIBM (const GLenum *, const GLint *, const GLsizei *, GLsizei, GLint); GLAPI void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* const *, GLsizei, GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride); typedef void (APIENTRYP PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount, GLint modestride); #endif #ifndef GL_IBM_vertex_array_lists #define GL_IBM_vertex_array_lists 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); GLAPI void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); GLAPI void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint); GLAPI void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint); GLAPI void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint); GLAPI void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint); GLAPI void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); GLAPI void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); typedef void (APIENTRYP PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); #endif #ifndef GL_SGIX_subsample #define GL_SGIX_subsample 1 #endif #ifndef GL_SGIX_ycrcba #define GL_SGIX_ycrcba 1 #endif #ifndef GL_SGIX_ycrcb_subsample #define GL_SGIX_ycrcb_subsample 1 #endif #ifndef GL_SGIX_depth_pass_instrument #define GL_SGIX_depth_pass_instrument 1 #endif #ifndef GL_3DFX_texture_compression_FXT1 #define GL_3DFX_texture_compression_FXT1 1 #endif #ifndef GL_3DFX_multisample #define GL_3DFX_multisample 1 #endif #ifndef GL_3DFX_tbuffer #define GL_3DFX_tbuffer 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTbufferMask3DFX (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTBUFFERMASK3DFXPROC) (GLuint mask); #endif #ifndef GL_EXT_multisample #define GL_EXT_multisample 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glSampleMaskEXT (GLclampf, GLboolean); GLAPI void APIENTRY glSamplePatternEXT (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert); typedef void (APIENTRYP PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern); #endif #ifndef GL_SGIX_vertex_preclip #define GL_SGIX_vertex_preclip 1 #endif #ifndef GL_SGIX_convolution_accuracy #define GL_SGIX_convolution_accuracy 1 #endif #ifndef GL_SGIX_resample #define GL_SGIX_resample 1 #endif #ifndef GL_SGIS_point_line_texgen #define GL_SGIS_point_line_texgen 1 #endif #ifndef GL_SGIS_texture_color_mask #define GL_SGIS_texture_color_mask 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); #endif #ifndef GL_SGIX_igloo_interface #define GL_SGIX_igloo_interface 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glIglooInterfaceSGIX (GLenum, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, const GLvoid *params); #endif #ifndef GL_EXT_texture_env_dot3 #define GL_EXT_texture_env_dot3 1 #endif #ifndef GL_ATI_texture_mirror_once #define GL_ATI_texture_mirror_once 1 #endif #ifndef GL_NV_fence #define GL_NV_fence 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDeleteFencesNV (GLsizei, const GLuint *); GLAPI void APIENTRY glGenFencesNV (GLsizei, GLuint *); GLAPI GLboolean APIENTRY glIsFenceNV (GLuint); GLAPI GLboolean APIENTRY glTestFenceNV (GLuint); GLAPI void APIENTRY glGetFenceivNV (GLuint, GLenum, GLint *); GLAPI void APIENTRY glFinishFenceNV (GLuint); GLAPI void APIENTRY glSetFenceNV (GLuint, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint *fences); typedef void (APIENTRYP PFNGLGENFENCESNVPROC) (GLsizei n, GLuint *fences); typedef GLboolean (APIENTRYP PFNGLISFENCENVPROC) (GLuint fence); typedef GLboolean (APIENTRYP PFNGLTESTFENCENVPROC) (GLuint fence); typedef void (APIENTRYP PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLFINISHFENCENVPROC) (GLuint fence); typedef void (APIENTRYP PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition); #endif #ifndef GL_NV_evaluators #define GL_NV_evaluators 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, const GLvoid *); GLAPI void APIENTRY glMapParameterivNV (GLenum, GLenum, const GLint *); GLAPI void APIENTRY glMapParameterfvNV (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glGetMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, GLvoid *); GLAPI void APIENTRY glGetMapParameterivNV (GLenum, GLenum, GLint *); GLAPI void APIENTRY glGetMapParameterfvNV (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetMapAttribParameterivNV (GLenum, GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetMapAttribParameterfvNV (GLenum, GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glEvalMapsNV (GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points); typedef void (APIENTRYP PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRYP PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points); typedef void (APIENTRYP PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode); #endif #ifndef GL_NV_packed_depth_stencil #define GL_NV_packed_depth_stencil 1 #endif #ifndef GL_NV_register_combiners2 #define GL_NV_register_combiners2 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glCombinerStageParameterfvNV (GLenum, GLenum, const GLfloat *); GLAPI void APIENTRY glGetCombinerStageParameterfvNV (GLenum, GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat *params); typedef void (APIENTRYP PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat *params); #endif #ifndef GL_NV_texture_compression_vtc #define GL_NV_texture_compression_vtc 1 #endif #ifndef GL_NV_texture_rectangle #define GL_NV_texture_rectangle 1 #endif #ifndef GL_NV_texture_shader #define GL_NV_texture_shader 1 #endif #ifndef GL_NV_texture_shader2 #define GL_NV_texture_shader2 1 #endif #ifndef GL_NV_vertex_array_range2 #define GL_NV_vertex_array_range2 1 #endif #ifndef GL_NV_vertex_program #define GL_NV_vertex_program 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLboolean APIENTRY glAreProgramsResidentNV (GLsizei, const GLuint *, GLboolean *); GLAPI void APIENTRY glBindProgramNV (GLenum, GLuint); GLAPI void APIENTRY glDeleteProgramsNV (GLsizei, const GLuint *); GLAPI void APIENTRY glExecuteProgramNV (GLenum, GLuint, const GLfloat *); GLAPI void APIENTRY glGenProgramsNV (GLsizei, GLuint *); GLAPI void APIENTRY glGetProgramParameterdvNV (GLenum, GLuint, GLenum, GLdouble *); GLAPI void APIENTRY glGetProgramParameterfvNV (GLenum, GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetProgramivNV (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetProgramStringNV (GLuint, GLenum, GLubyte *); GLAPI void APIENTRY glGetTrackMatrixivNV (GLenum, GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetVertexAttribdvNV (GLuint, GLenum, GLdouble *); GLAPI void APIENTRY glGetVertexAttribfvNV (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetVertexAttribivNV (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetVertexAttribPointervNV (GLuint, GLenum, GLvoid* *); GLAPI GLboolean APIENTRY glIsProgramNV (GLuint); GLAPI void APIENTRY glLoadProgramNV (GLenum, GLuint, GLsizei, const GLubyte *); GLAPI void APIENTRY glProgramParameter4dNV (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glProgramParameter4dvNV (GLenum, GLuint, const GLdouble *); GLAPI void APIENTRY glProgramParameter4fNV (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glProgramParameter4fvNV (GLenum, GLuint, const GLfloat *); GLAPI void APIENTRY glProgramParameters4dvNV (GLenum, GLuint, GLuint, const GLdouble *); GLAPI void APIENTRY glProgramParameters4fvNV (GLenum, GLuint, GLuint, const GLfloat *); GLAPI void APIENTRY glRequestResidentProgramsNV (GLsizei, const GLuint *); GLAPI void APIENTRY glTrackMatrixNV (GLenum, GLuint, GLenum, GLenum); GLAPI void APIENTRY glVertexAttribPointerNV (GLuint, GLint, GLenum, GLsizei, const GLvoid *); GLAPI void APIENTRY glVertexAttrib1dNV (GLuint, GLdouble); GLAPI void APIENTRY glVertexAttrib1dvNV (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib1fNV (GLuint, GLfloat); GLAPI void APIENTRY glVertexAttrib1fvNV (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib1sNV (GLuint, GLshort); GLAPI void APIENTRY glVertexAttrib1svNV (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib2dNV (GLuint, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib2dvNV (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib2fNV (GLuint, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib2fvNV (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib2sNV (GLuint, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib2svNV (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib3dNV (GLuint, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib3dvNV (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib3fNV (GLuint, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib3fvNV (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib3sNV (GLuint, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib3svNV (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4dNV (GLuint, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexAttrib4dvNV (GLuint, const GLdouble *); GLAPI void APIENTRY glVertexAttrib4fNV (GLuint, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexAttrib4fvNV (GLuint, const GLfloat *); GLAPI void APIENTRY glVertexAttrib4sNV (GLuint, GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexAttrib4svNV (GLuint, const GLshort *); GLAPI void APIENTRY glVertexAttrib4ubNV (GLuint, GLubyte, GLubyte, GLubyte, GLubyte); GLAPI void APIENTRY glVertexAttrib4ubvNV (GLuint, const GLubyte *); GLAPI void APIENTRY glVertexAttribs1dvNV (GLuint, GLsizei, const GLdouble *); GLAPI void APIENTRY glVertexAttribs1fvNV (GLuint, GLsizei, const GLfloat *); GLAPI void APIENTRY glVertexAttribs1svNV (GLuint, GLsizei, const GLshort *); GLAPI void APIENTRY glVertexAttribs2dvNV (GLuint, GLsizei, const GLdouble *); GLAPI void APIENTRY glVertexAttribs2fvNV (GLuint, GLsizei, const GLfloat *); GLAPI void APIENTRY glVertexAttribs2svNV (GLuint, GLsizei, const GLshort *); GLAPI void APIENTRY glVertexAttribs3dvNV (GLuint, GLsizei, const GLdouble *); GLAPI void APIENTRY glVertexAttribs3fvNV (GLuint, GLsizei, const GLfloat *); GLAPI void APIENTRY glVertexAttribs3svNV (GLuint, GLsizei, const GLshort *); GLAPI void APIENTRY glVertexAttribs4dvNV (GLuint, GLsizei, const GLdouble *); GLAPI void APIENTRY glVertexAttribs4fvNV (GLuint, GLsizei, const GLfloat *); GLAPI void APIENTRY glVertexAttribs4svNV (GLuint, GLsizei, const GLshort *); GLAPI void APIENTRY glVertexAttribs4ubvNV (GLuint, GLsizei, const GLubyte *); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLboolean (APIENTRYP PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint *programs, GLboolean *residences); typedef void (APIENTRYP PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); typedef void (APIENTRYP PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRYP PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat *params); typedef void (APIENTRYP PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *programs); typedef void (APIENTRYP PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRYP PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte *program); typedef void (APIENTRYP PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRYP PFNGLISPROGRAMNVPROC) (GLuint id); typedef void (APIENTRYP PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program); typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v); typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v); typedef void (APIENTRYP PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRYP PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRYP PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, const GLubyte *v); #endif #ifndef GL_SGIX_texture_coordinate_clamp #define GL_SGIX_texture_coordinate_clamp 1 #endif #ifndef GL_SGIX_scalebias_hint #define GL_SGIX_scalebias_hint 1 #endif #ifndef GL_OML_interlace #define GL_OML_interlace 1 #endif #ifndef GL_OML_subsample #define GL_OML_subsample 1 #endif #ifndef GL_OML_resample #define GL_OML_resample 1 #endif #ifndef GL_NV_copy_depth_to_color #define GL_NV_copy_depth_to_color 1 #endif #ifndef GL_ATI_envmap_bumpmap #define GL_ATI_envmap_bumpmap 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glTexBumpParameterivATI (GLenum, const GLint *); GLAPI void APIENTRY glTexBumpParameterfvATI (GLenum, const GLfloat *); GLAPI void APIENTRY glGetTexBumpParameterivATI (GLenum, GLint *); GLAPI void APIENTRY glGetTexBumpParameterfvATI (GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, const GLint *param); typedef void (APIENTRYP PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, const GLfloat *param); typedef void (APIENTRYP PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); typedef void (APIENTRYP PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); #endif #ifndef GL_ATI_fragment_shader #define GL_ATI_fragment_shader 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLuint APIENTRY glGenFragmentShadersATI (GLuint); GLAPI void APIENTRY glBindFragmentShaderATI (GLuint); GLAPI void APIENTRY glDeleteFragmentShaderATI (GLuint); GLAPI void APIENTRY glBeginFragmentShaderATI (void); GLAPI void APIENTRY glEndFragmentShaderATI (void); GLAPI void APIENTRY glPassTexCoordATI (GLuint, GLuint, GLenum); GLAPI void APIENTRY glSampleMapATI (GLuint, GLuint, GLenum); GLAPI void APIENTRY glColorFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glColorFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glColorFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glAlphaFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glAlphaFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glAlphaFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glSetFragmentShaderConstantATI (GLuint, const GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLuint (APIENTRYP PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range); typedef void (APIENTRYP PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id); typedef void (APIENTRYP PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id); typedef void (APIENTRYP PFNGLBEGINFRAGMENTSHADERATIPROC) (void); typedef void (APIENTRYP PFNGLENDFRAGMENTSHADERATIPROC) (void); typedef void (APIENTRYP PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle); typedef void (APIENTRYP PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle); typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); typedef void (APIENTRYP PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat *value); #endif #ifndef GL_ATI_pn_triangles #define GL_ATI_pn_triangles 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPNTrianglesiATI (GLenum, GLint); GLAPI void APIENTRY glPNTrianglesfATI (GLenum, GLfloat); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param); #endif #ifndef GL_ATI_vertex_array_object #define GL_ATI_vertex_array_object 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLuint APIENTRY glNewObjectBufferATI (GLsizei, const GLvoid *, GLenum); GLAPI GLboolean APIENTRY glIsObjectBufferATI (GLuint); GLAPI void APIENTRY glUpdateObjectBufferATI (GLuint, GLuint, GLsizei, const GLvoid *, GLenum); GLAPI void APIENTRY glGetObjectBufferfvATI (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetObjectBufferivATI (GLuint, GLenum, GLint *); GLAPI void APIENTRY glFreeObjectBufferATI (GLuint); GLAPI void APIENTRY glArrayObjectATI (GLenum, GLint, GLenum, GLsizei, GLuint, GLuint); GLAPI void APIENTRY glGetArrayObjectfvATI (GLenum, GLenum, GLfloat *); GLAPI void APIENTRY glGetArrayObjectivATI (GLenum, GLenum, GLint *); GLAPI void APIENTRY glVariantArrayObjectATI (GLuint, GLenum, GLsizei, GLuint, GLuint); GLAPI void APIENTRY glGetVariantArrayObjectfvATI (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetVariantArrayObjectivATI (GLuint, GLenum, GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLuint (APIENTRYP PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage); typedef GLboolean (APIENTRYP PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer); typedef void (APIENTRYP PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve); typedef void (APIENTRYP PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer); typedef void (APIENTRYP PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); typedef void (APIENTRYP PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); typedef void (APIENTRYP PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint *params); #endif #ifndef GL_EXT_vertex_shader #define GL_EXT_vertex_shader 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBeginVertexShaderEXT (void); GLAPI void APIENTRY glEndVertexShaderEXT (void); GLAPI void APIENTRY glBindVertexShaderEXT (GLuint); GLAPI GLuint APIENTRY glGenVertexShadersEXT (GLuint); GLAPI void APIENTRY glDeleteVertexShaderEXT (GLuint); GLAPI void APIENTRY glShaderOp1EXT (GLenum, GLuint, GLuint); GLAPI void APIENTRY glShaderOp2EXT (GLenum, GLuint, GLuint, GLuint); GLAPI void APIENTRY glShaderOp3EXT (GLenum, GLuint, GLuint, GLuint, GLuint); GLAPI void APIENTRY glSwizzleEXT (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glWriteMaskEXT (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glInsertComponentEXT (GLuint, GLuint, GLuint); GLAPI void APIENTRY glExtractComponentEXT (GLuint, GLuint, GLuint); GLAPI GLuint APIENTRY glGenSymbolsEXT (GLenum, GLenum, GLenum, GLuint); GLAPI void APIENTRY glSetInvariantEXT (GLuint, GLenum, const GLvoid *); GLAPI void APIENTRY glSetLocalConstantEXT (GLuint, GLenum, const GLvoid *); GLAPI void APIENTRY glVariantbvEXT (GLuint, const GLbyte *); GLAPI void APIENTRY glVariantsvEXT (GLuint, const GLshort *); GLAPI void APIENTRY glVariantivEXT (GLuint, const GLint *); GLAPI void APIENTRY glVariantfvEXT (GLuint, const GLfloat *); GLAPI void APIENTRY glVariantdvEXT (GLuint, const GLdouble *); GLAPI void APIENTRY glVariantubvEXT (GLuint, const GLubyte *); GLAPI void APIENTRY glVariantusvEXT (GLuint, const GLushort *); GLAPI void APIENTRY glVariantuivEXT (GLuint, const GLuint *); GLAPI void APIENTRY glVariantPointerEXT (GLuint, GLenum, GLuint, const GLvoid *); GLAPI void APIENTRY glEnableVariantClientStateEXT (GLuint); GLAPI void APIENTRY glDisableVariantClientStateEXT (GLuint); GLAPI GLuint APIENTRY glBindLightParameterEXT (GLenum, GLenum); GLAPI GLuint APIENTRY glBindMaterialParameterEXT (GLenum, GLenum); GLAPI GLuint APIENTRY glBindTexGenParameterEXT (GLenum, GLenum, GLenum); GLAPI GLuint APIENTRY glBindTextureUnitParameterEXT (GLenum, GLenum); GLAPI GLuint APIENTRY glBindParameterEXT (GLenum); GLAPI GLboolean APIENTRY glIsVariantEnabledEXT (GLuint, GLenum); GLAPI void APIENTRY glGetVariantBooleanvEXT (GLuint, GLenum, GLboolean *); GLAPI void APIENTRY glGetVariantIntegervEXT (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetVariantFloatvEXT (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetVariantPointervEXT (GLuint, GLenum, GLvoid* *); GLAPI void APIENTRY glGetInvariantBooleanvEXT (GLuint, GLenum, GLboolean *); GLAPI void APIENTRY glGetInvariantIntegervEXT (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetInvariantFloatvEXT (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetLocalConstantBooleanvEXT (GLuint, GLenum, GLboolean *); GLAPI void APIENTRY glGetLocalConstantIntegervEXT (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetLocalConstantFloatvEXT (GLuint, GLenum, GLfloat *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBEGINVERTEXSHADEREXTPROC) (void); typedef void (APIENTRYP PFNGLENDVERTEXSHADEREXTPROC) (void); typedef void (APIENTRYP PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id); typedef GLuint (APIENTRYP PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range); typedef void (APIENTRYP PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id); typedef void (APIENTRYP PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1); typedef void (APIENTRYP PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2); typedef void (APIENTRYP PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3); typedef void (APIENTRYP PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); typedef void (APIENTRYP PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); typedef void (APIENTRYP PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); typedef void (APIENTRYP PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); typedef GLuint (APIENTRYP PFNGLGENSYMBOLSEXTPROC) (GLenum datatype, GLenum storagetype, GLenum range, GLuint components); typedef void (APIENTRYP PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, const GLvoid *addr); typedef void (APIENTRYP PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, const GLvoid *addr); typedef void (APIENTRYP PFNGLVARIANTBVEXTPROC) (GLuint id, const GLbyte *addr); typedef void (APIENTRYP PFNGLVARIANTSVEXTPROC) (GLuint id, const GLshort *addr); typedef void (APIENTRYP PFNGLVARIANTIVEXTPROC) (GLuint id, const GLint *addr); typedef void (APIENTRYP PFNGLVARIANTFVEXTPROC) (GLuint id, const GLfloat *addr); typedef void (APIENTRYP PFNGLVARIANTDVEXTPROC) (GLuint id, const GLdouble *addr); typedef void (APIENTRYP PFNGLVARIANTUBVEXTPROC) (GLuint id, const GLubyte *addr); typedef void (APIENTRYP PFNGLVARIANTUSVEXTPROC) (GLuint id, const GLushort *addr); typedef void (APIENTRYP PFNGLVARIANTUIVEXTPROC) (GLuint id, const GLuint *addr); typedef void (APIENTRYP PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, const GLvoid *addr); typedef void (APIENTRYP PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); typedef void (APIENTRYP PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); typedef GLuint (APIENTRYP PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value); typedef GLuint (APIENTRYP PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value); typedef GLuint (APIENTRYP PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value); typedef GLuint (APIENTRYP PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value); typedef GLuint (APIENTRYP PFNGLBINDPARAMETEREXTPROC) (GLenum value); typedef GLboolean (APIENTRYP PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap); typedef void (APIENTRYP PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); typedef void (APIENTRYP PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); typedef void (APIENTRYP PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); typedef void (APIENTRYP PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, GLvoid* *data); typedef void (APIENTRYP PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); typedef void (APIENTRYP PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); typedef void (APIENTRYP PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); typedef void (APIENTRYP PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); typedef void (APIENTRYP PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); typedef void (APIENTRYP PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); #endif #ifndef GL_ATI_vertex_streams #define GL_ATI_vertex_streams 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertexStream1sATI (GLenum, GLshort); GLAPI void APIENTRY glVertexStream1svATI (GLenum, const GLshort *); GLAPI void APIENTRY glVertexStream1iATI (GLenum, GLint); GLAPI void APIENTRY glVertexStream1ivATI (GLenum, const GLint *); GLAPI void APIENTRY glVertexStream1fATI (GLenum, GLfloat); GLAPI void APIENTRY glVertexStream1fvATI (GLenum, const GLfloat *); GLAPI void APIENTRY glVertexStream1dATI (GLenum, GLdouble); GLAPI void APIENTRY glVertexStream1dvATI (GLenum, const GLdouble *); GLAPI void APIENTRY glVertexStream2sATI (GLenum, GLshort, GLshort); GLAPI void APIENTRY glVertexStream2svATI (GLenum, const GLshort *); GLAPI void APIENTRY glVertexStream2iATI (GLenum, GLint, GLint); GLAPI void APIENTRY glVertexStream2ivATI (GLenum, const GLint *); GLAPI void APIENTRY glVertexStream2fATI (GLenum, GLfloat, GLfloat); GLAPI void APIENTRY glVertexStream2fvATI (GLenum, const GLfloat *); GLAPI void APIENTRY glVertexStream2dATI (GLenum, GLdouble, GLdouble); GLAPI void APIENTRY glVertexStream2dvATI (GLenum, const GLdouble *); GLAPI void APIENTRY glVertexStream3sATI (GLenum, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexStream3svATI (GLenum, const GLshort *); GLAPI void APIENTRY glVertexStream3iATI (GLenum, GLint, GLint, GLint); GLAPI void APIENTRY glVertexStream3ivATI (GLenum, const GLint *); GLAPI void APIENTRY glVertexStream3fATI (GLenum, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexStream3fvATI (GLenum, const GLfloat *); GLAPI void APIENTRY glVertexStream3dATI (GLenum, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexStream3dvATI (GLenum, const GLdouble *); GLAPI void APIENTRY glVertexStream4sATI (GLenum, GLshort, GLshort, GLshort, GLshort); GLAPI void APIENTRY glVertexStream4svATI (GLenum, const GLshort *); GLAPI void APIENTRY glVertexStream4iATI (GLenum, GLint, GLint, GLint, GLint); GLAPI void APIENTRY glVertexStream4ivATI (GLenum, const GLint *); GLAPI void APIENTRY glVertexStream4fATI (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glVertexStream4fvATI (GLenum, const GLfloat *); GLAPI void APIENTRY glVertexStream4dATI (GLenum, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glVertexStream4dvATI (GLenum, const GLdouble *); GLAPI void APIENTRY glNormalStream3bATI (GLenum, GLbyte, GLbyte, GLbyte); GLAPI void APIENTRY glNormalStream3bvATI (GLenum, const GLbyte *); GLAPI void APIENTRY glNormalStream3sATI (GLenum, GLshort, GLshort, GLshort); GLAPI void APIENTRY glNormalStream3svATI (GLenum, const GLshort *); GLAPI void APIENTRY glNormalStream3iATI (GLenum, GLint, GLint, GLint); GLAPI void APIENTRY glNormalStream3ivATI (GLenum, const GLint *); GLAPI void APIENTRY glNormalStream3fATI (GLenum, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glNormalStream3fvATI (GLenum, const GLfloat *); GLAPI void APIENTRY glNormalStream3dATI (GLenum, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glNormalStream3dvATI (GLenum, const GLdouble *); GLAPI void APIENTRY glClientActiveVertexStreamATI (GLenum); GLAPI void APIENTRY glVertexBlendEnviATI (GLenum, GLint); GLAPI void APIENTRY glVertexBlendEnvfATI (GLenum, GLfloat); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEXSTREAM1SATIPROC) (GLenum stream, GLshort x); typedef void (APIENTRYP PFNGLVERTEXSTREAM1SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM1IATIPROC) (GLenum stream, GLint x); typedef void (APIENTRYP PFNGLVERTEXSTREAM1IVATIPROC) (GLenum stream, const GLint *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM1FATIPROC) (GLenum stream, GLfloat x); typedef void (APIENTRYP PFNGLVERTEXSTREAM1FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM1DATIPROC) (GLenum stream, GLdouble x); typedef void (APIENTRYP PFNGLVERTEXSTREAM1DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y); typedef void (APIENTRYP PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y); typedef void (APIENTRYP PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y); typedef void (APIENTRYP PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y); typedef void (APIENTRYP PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); typedef void (APIENTRYP PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); typedef void (APIENTRYP PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRYP PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRYP PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRYP PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w); typedef void (APIENTRYP PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (APIENTRYP PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (APIENTRYP PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz); typedef void (APIENTRYP PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *coords); typedef void (APIENTRYP PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort nx, GLshort ny, GLshort nz); typedef void (APIENTRYP PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords); typedef void (APIENTRYP PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint nx, GLint ny, GLint nz); typedef void (APIENTRYP PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *coords); typedef void (APIENTRYP PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz); typedef void (APIENTRYP PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords); typedef void (APIENTRYP PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz); typedef void (APIENTRYP PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords); typedef void (APIENTRYP PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream); typedef void (APIENTRYP PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param); #endif #ifndef GL_ATI_element_array #define GL_ATI_element_array 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glElementPointerATI (GLenum, const GLvoid *); GLAPI void APIENTRY glDrawElementArrayATI (GLenum, GLsizei); GLAPI void APIENTRY glDrawRangeElementArrayATI (GLenum, GLuint, GLuint, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLELEMENTPOINTERATIPROC) (GLenum type, const GLvoid *pointer); typedef void (APIENTRYP PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count); typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count); #endif #ifndef GL_SUN_mesh_array #define GL_SUN_mesh_array 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDrawMeshArraysSUN (GLenum, GLint, GLsizei, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDRAWMESHARRAYSSUNPROC) (GLenum mode, GLint first, GLsizei count, GLsizei width); #endif #ifndef GL_SUN_slice_accum #define GL_SUN_slice_accum 1 #endif #ifndef GL_NV_multisample_filter_hint #define GL_NV_multisample_filter_hint 1 #endif #ifndef GL_NV_depth_clamp #define GL_NV_depth_clamp 1 #endif #ifndef GL_NV_occlusion_query #define GL_NV_occlusion_query 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGenOcclusionQueriesNV (GLsizei, GLuint *); GLAPI void APIENTRY glDeleteOcclusionQueriesNV (GLsizei, const GLuint *); GLAPI GLboolean APIENTRY glIsOcclusionQueryNV (GLuint); GLAPI void APIENTRY glBeginOcclusionQueryNV (GLuint); GLAPI void APIENTRY glEndOcclusionQueryNV (void); GLAPI void APIENTRY glGetOcclusionQueryivNV (GLuint, GLenum, GLint *); GLAPI void APIENTRY glGetOcclusionQueryuivNV (GLuint, GLenum, GLuint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint *ids); typedef void (APIENTRYP PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint *ids); typedef GLboolean (APIENTRYP PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); typedef void (APIENTRYP PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id); typedef void (APIENTRYP PFNGLENDOCCLUSIONQUERYNVPROC) (void); typedef void (APIENTRYP PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint *params); #endif #ifndef GL_NV_point_sprite #define GL_NV_point_sprite 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPointParameteriNV (GLenum, GLint); GLAPI void APIENTRY glPointParameterivNV (GLenum, const GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param); typedef void (APIENTRYP PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint *params); #endif #ifndef GL_NV_texture_shader3 #define GL_NV_texture_shader3 1 #endif #ifndef GL_NV_vertex_program1_1 #define GL_NV_vertex_program1_1 1 #endif #ifndef GL_EXT_shadow_funcs #define GL_EXT_shadow_funcs 1 #endif #ifndef GL_EXT_stencil_two_side #define GL_EXT_stencil_two_side 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glActiveStencilFaceEXT (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face); #endif #ifndef GL_ATI_text_fragment_shader #define GL_ATI_text_fragment_shader 1 #endif #ifndef GL_APPLE_client_storage #define GL_APPLE_client_storage 1 #endif #ifndef GL_APPLE_element_array #define GL_APPLE_element_array 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glElementPointerAPPLE (GLenum, const GLvoid *); GLAPI void APIENTRY glDrawElementArrayAPPLE (GLenum, GLint, GLsizei); GLAPI void APIENTRY glDrawRangeElementArrayAPPLE (GLenum, GLuint, GLuint, GLint, GLsizei); GLAPI void APIENTRY glMultiDrawElementArrayAPPLE (GLenum, const GLint *, const GLsizei *, GLsizei); GLAPI void APIENTRY glMultiDrawRangeElementArrayAPPLE (GLenum, GLuint, GLuint, const GLint *, const GLsizei *, GLsizei); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const GLvoid *pointer); typedef void (APIENTRYP PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count); typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count); typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount); typedef void (APIENTRYP PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount); #endif #ifndef GL_APPLE_fence #define GL_APPLE_fence 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glGenFencesAPPLE (GLsizei, GLuint *); GLAPI void APIENTRY glDeleteFencesAPPLE (GLsizei, const GLuint *); GLAPI void APIENTRY glSetFenceAPPLE (GLuint); GLAPI GLboolean APIENTRY glIsFenceAPPLE (GLuint); GLAPI GLboolean APIENTRY glTestFenceAPPLE (GLuint); GLAPI void APIENTRY glFinishFenceAPPLE (GLuint); GLAPI GLboolean APIENTRY glTestObjectAPPLE (GLenum, GLuint); GLAPI void APIENTRY glFinishObjectAPPLE (GLenum, GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint *fences); typedef void (APIENTRYP PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLuint *fences); typedef void (APIENTRYP PFNGLSETFENCEAPPLEPROC) (GLuint fence); typedef GLboolean (APIENTRYP PFNGLISFENCEAPPLEPROC) (GLuint fence); typedef GLboolean (APIENTRYP PFNGLTESTFENCEAPPLEPROC) (GLuint fence); typedef void (APIENTRYP PFNGLFINISHFENCEAPPLEPROC) (GLuint fence); typedef GLboolean (APIENTRYP PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GLuint name); typedef void (APIENTRYP PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint name); #endif #ifndef GL_APPLE_vertex_array_object #define GL_APPLE_vertex_array_object 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBindVertexArrayAPPLE (GLuint); GLAPI void APIENTRY glDeleteVertexArraysAPPLE (GLsizei, const GLuint *); GLAPI void APIENTRY glGenVertexArraysAPPLE (GLsizei, const GLuint *); GLAPI GLboolean APIENTRY glIsVertexArrayAPPLE (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array); typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint *arrays); typedef void (APIENTRYP PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint *arrays); typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array); #endif #ifndef GL_APPLE_vertex_array_range #define GL_APPLE_vertex_array_range 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertexArrayRangeAPPLE (GLsizei, GLvoid *); GLAPI void APIENTRY glFlushVertexArrayRangeAPPLE (GLsizei, GLvoid *); GLAPI void APIENTRY glVertexArrayParameteriAPPLE (GLenum, GLint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, GLvoid *pointer); typedef void (APIENTRYP PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, GLvoid *pointer); typedef void (APIENTRYP PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pname, GLint param); #endif #ifndef GL_APPLE_ycbcr_422 #define GL_APPLE_ycbcr_422 1 #endif #ifndef GL_S3_s3tc #define GL_S3_s3tc 1 #endif #ifndef GL_ATI_draw_buffers #define GL_ATI_draw_buffers 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDrawBuffersATI (GLsizei, const GLenum *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum *bufs); #endif #ifndef GL_ATI_pixel_format_float #define GL_ATI_pixel_format_float 1 /* This is really a WGL extension, but defines some associated GL enums. * ATI does not export "GL_ATI_pixel_format_float" in the GL_EXTENSIONS string. */ #endif #ifndef GL_ATI_texture_env_combine3 #define GL_ATI_texture_env_combine3 1 #endif #ifndef GL_ATI_texture_float #define GL_ATI_texture_float 1 #endif #ifndef GL_NV_float_buffer #define GL_NV_float_buffer 1 #endif #ifndef GL_NV_fragment_program #define GL_NV_fragment_program 1 /* Some NV_fragment_program entry points are shared with ARB_vertex_program. */ #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glProgramNamedParameter4fNV (GLuint, GLsizei, const GLubyte *, GLfloat, GLfloat, GLfloat, GLfloat); GLAPI void APIENTRY glProgramNamedParameter4dNV (GLuint, GLsizei, const GLubyte *, GLdouble, GLdouble, GLdouble, GLdouble); GLAPI void APIENTRY glProgramNamedParameter4fvNV (GLuint, GLsizei, const GLubyte *, const GLfloat *); GLAPI void APIENTRY glProgramNamedParameter4dvNV (GLuint, GLsizei, const GLubyte *, const GLdouble *); GLAPI void APIENTRY glGetProgramNamedParameterfvNV (GLuint, GLsizei, const GLubyte *, GLfloat *); GLAPI void APIENTRY glGetProgramNamedParameterdvNV (GLuint, GLsizei, const GLubyte *, GLdouble *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v); typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v); typedef void (APIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params); typedef void (APIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params); #endif #ifndef GL_NV_half_float #define GL_NV_half_float 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertex2hNV (GLhalfNV, GLhalfNV); GLAPI void APIENTRY glVertex2hvNV (const GLhalfNV *); GLAPI void APIENTRY glVertex3hNV (GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glVertex3hvNV (const GLhalfNV *); GLAPI void APIENTRY glVertex4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glVertex4hvNV (const GLhalfNV *); GLAPI void APIENTRY glNormal3hNV (GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glNormal3hvNV (const GLhalfNV *); GLAPI void APIENTRY glColor3hNV (GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glColor3hvNV (const GLhalfNV *); GLAPI void APIENTRY glColor4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glColor4hvNV (const GLhalfNV *); GLAPI void APIENTRY glTexCoord1hNV (GLhalfNV); GLAPI void APIENTRY glTexCoord1hvNV (const GLhalfNV *); GLAPI void APIENTRY glTexCoord2hNV (GLhalfNV, GLhalfNV); GLAPI void APIENTRY glTexCoord2hvNV (const GLhalfNV *); GLAPI void APIENTRY glTexCoord3hNV (GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glTexCoord3hvNV (const GLhalfNV *); GLAPI void APIENTRY glTexCoord4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glTexCoord4hvNV (const GLhalfNV *); GLAPI void APIENTRY glMultiTexCoord1hNV (GLenum, GLhalfNV); GLAPI void APIENTRY glMultiTexCoord1hvNV (GLenum, const GLhalfNV *); GLAPI void APIENTRY glMultiTexCoord2hNV (GLenum, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glMultiTexCoord2hvNV (GLenum, const GLhalfNV *); GLAPI void APIENTRY glMultiTexCoord3hNV (GLenum, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glMultiTexCoord3hvNV (GLenum, const GLhalfNV *); GLAPI void APIENTRY glMultiTexCoord4hNV (GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glMultiTexCoord4hvNV (GLenum, const GLhalfNV *); GLAPI void APIENTRY glFogCoordhNV (GLhalfNV); GLAPI void APIENTRY glFogCoordhvNV (const GLhalfNV *); GLAPI void APIENTRY glSecondaryColor3hNV (GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glSecondaryColor3hvNV (const GLhalfNV *); GLAPI void APIENTRY glVertexWeighthNV (GLhalfNV); GLAPI void APIENTRY glVertexWeighthvNV (const GLhalfNV *); GLAPI void APIENTRY glVertexAttrib1hNV (GLuint, GLhalfNV); GLAPI void APIENTRY glVertexAttrib1hvNV (GLuint, const GLhalfNV *); GLAPI void APIENTRY glVertexAttrib2hNV (GLuint, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glVertexAttrib2hvNV (GLuint, const GLhalfNV *); GLAPI void APIENTRY glVertexAttrib3hNV (GLuint, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glVertexAttrib3hvNV (GLuint, const GLhalfNV *); GLAPI void APIENTRY glVertexAttrib4hNV (GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); GLAPI void APIENTRY glVertexAttrib4hvNV (GLuint, const GLhalfNV *); GLAPI void APIENTRY glVertexAttribs1hvNV (GLuint, GLsizei, const GLhalfNV *); GLAPI void APIENTRY glVertexAttribs2hvNV (GLuint, GLsizei, const GLhalfNV *); GLAPI void APIENTRY glVertexAttribs3hvNV (GLuint, GLsizei, const GLhalfNV *); GLAPI void APIENTRY glVertexAttribs4hvNV (GLuint, GLsizei, const GLhalfNV *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEX2HNVPROC) (GLhalfNV x, GLhalfNV y); typedef void (APIENTRYP PFNGLVERTEX2HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEX3HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z); typedef void (APIENTRYP PFNGLVERTEX3HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEX4HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); typedef void (APIENTRYP PFNGLVERTEX4HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLNORMAL3HNVPROC) (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz); typedef void (APIENTRYP PFNGLNORMAL3HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); typedef void (APIENTRYP PFNGLCOLOR3HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLCOLOR4HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha); typedef void (APIENTRYP PFNGLCOLOR4HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLTEXCOORD1HNVPROC) (GLhalfNV s); typedef void (APIENTRYP PFNGLTEXCOORD1HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLTEXCOORD2HNVPROC) (GLhalfNV s, GLhalfNV t); typedef void (APIENTRYP PFNGLTEXCOORD2HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLTEXCOORD3HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r); typedef void (APIENTRYP PFNGLTEXCOORD3HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLTEXCOORD4HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); typedef void (APIENTRYP PFNGLTEXCOORD4HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalfNV s); typedef void (APIENTRYP PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, const GLhalfNV *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t); typedef void (APIENTRYP PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, const GLhalfNV *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r); typedef void (APIENTRYP PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalfNV *v); typedef void (APIENTRYP PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); typedef void (APIENTRYP PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalfNV *v); typedef void (APIENTRYP PFNGLFOGCOORDHNVPROC) (GLhalfNV fog); typedef void (APIENTRYP PFNGLFOGCOORDHVNVPROC) (const GLhalfNV *fog); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXWEIGHTHNVPROC) (GLhalfNV weight); typedef void (APIENTRYP PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalfNV *weight); typedef void (APIENTRYP PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalfNV x); typedef void (APIENTRYP PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y); typedef void (APIENTRYP PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z); typedef void (APIENTRYP PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); typedef void (APIENTRYP PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); typedef void (APIENTRYP PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); #endif #ifndef GL_NV_pixel_data_range #define GL_NV_pixel_data_range 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPixelDataRangeNV (GLenum, GLsizei, GLvoid *); GLAPI void APIENTRY glFlushPixelDataRangeNV (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, GLvoid *pointer); typedef void (APIENTRYP PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target); #endif #ifndef GL_NV_primitive_restart #define GL_NV_primitive_restart 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glPrimitiveRestartNV (void); GLAPI void APIENTRY glPrimitiveRestartIndexNV (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLPRIMITIVERESTARTNVPROC) (void); typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index); #endif #ifndef GL_NV_texture_expand_normal #define GL_NV_texture_expand_normal 1 #endif #ifndef GL_NV_vertex_program2 #define GL_NV_vertex_program2 1 #endif #ifndef GL_ATI_map_object_buffer #define GL_ATI_map_object_buffer 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLvoid* APIENTRY glMapObjectBufferATI (GLuint); GLAPI void APIENTRY glUnmapObjectBufferATI (GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLvoid* (APIENTRYP PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer); typedef void (APIENTRYP PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer); #endif #ifndef GL_ATI_separate_stencil #define GL_ATI_separate_stencil 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glStencilOpSeparateATI (GLenum, GLenum, GLenum, GLenum); GLAPI void APIENTRY glStencilFuncSeparateATI (GLenum, GLenum, GLint, GLuint); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); #endif #ifndef GL_ATI_vertex_attrib_array_object #define GL_ATI_vertex_attrib_array_object 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glVertexAttribArrayObjectATI (GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint); GLAPI void APIENTRY glGetVertexAttribArrayObjectfvATI (GLuint, GLenum, GLfloat *); GLAPI void APIENTRY glGetVertexAttribArrayObjectivATI (GLuint, GLenum, GLint *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint index, GLenum pname, GLint *params); #endif #ifndef GL_OES_read_format #define GL_OES_read_format 1 #endif #ifndef GL_EXT_depth_bounds_test #define GL_EXT_depth_bounds_test 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glDepthBoundsEXT (GLclampd, GLclampd); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax); #endif #ifndef GL_EXT_texture_mirror_clamp #define GL_EXT_texture_mirror_clamp 1 #endif #ifndef GL_EXT_blend_equation_separate #define GL_EXT_blend_equation_separate 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glBlendEquationSeparateEXT (GLenum, GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha); #endif #ifndef GL_MESA_pack_invert #define GL_MESA_pack_invert 1 #endif #ifndef GL_MESA_ycbcr_texture #define GL_MESA_ycbcr_texture 1 #endif #ifndef GL_EXT_pixel_buffer_object #define GL_EXT_pixel_buffer_object 1 #endif #ifndef GL_NV_fragment_program_option #define GL_NV_fragment_program_option 1 #endif #ifndef GL_NV_fragment_program2 #define GL_NV_fragment_program2 1 #endif #ifndef GL_NV_vertex_program2_option #define GL_NV_vertex_program2_option 1 #endif #ifndef GL_NV_vertex_program3 #define GL_NV_vertex_program3 1 #endif #ifndef GL_EXT_framebuffer_object #define GL_EXT_framebuffer_object 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI GLboolean APIENTRY glIsRenderbufferEXT (GLuint); GLAPI void APIENTRY glBindRenderbufferEXT (GLenum, GLuint); GLAPI void APIENTRY glDeleteRenderbuffersEXT (GLsizei, const GLuint *); GLAPI void APIENTRY glGenRenderbuffersEXT (GLsizei, GLuint *); GLAPI void APIENTRY glRenderbufferStorageEXT (GLenum, GLenum, GLsizei, GLsizei); GLAPI void APIENTRY glGetRenderbufferParameterivEXT (GLenum, GLenum, GLint *); GLAPI GLboolean APIENTRY glIsFramebufferEXT (GLuint); GLAPI void APIENTRY glBindFramebufferEXT (GLenum, GLuint); GLAPI void APIENTRY glDeleteFramebuffersEXT (GLsizei, const GLuint *); GLAPI void APIENTRY glGenFramebuffersEXT (GLsizei, GLuint *); GLAPI GLenum APIENTRY glCheckFramebufferStatusEXT (GLenum); GLAPI void APIENTRY glFramebufferTexture1DEXT (GLenum, GLenum, GLenum, GLuint, GLint); GLAPI void APIENTRY glFramebufferTexture2DEXT (GLenum, GLenum, GLenum, GLuint, GLint); GLAPI void APIENTRY glFramebufferTexture3DEXT (GLenum, GLenum, GLenum, GLuint, GLint, GLint); GLAPI void APIENTRY glFramebufferRenderbufferEXT (GLenum, GLenum, GLenum, GLuint); GLAPI void APIENTRY glGetFramebufferAttachmentParameterivEXT (GLenum, GLenum, GLenum, GLint *); GLAPI void APIENTRY glGenerateMipmapEXT (GLenum); #endif /* GL_GLEXT_PROTOTYPES */ typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); typedef void (APIENTRYP PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer); typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint *renderbuffers); typedef void (APIENTRYP PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint *renderbuffers); typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); typedef void (APIENTRYP PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer); typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint *framebuffers); typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint *framebuffers); typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint *params); typedef void (APIENTRYP PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); #endif #ifndef GL_GREMEDY_string_marker #define GL_GREMEDY_string_marker 1 #ifdef GL_GLEXT_PROTOTYPES GLAPI void APIENTRY glStringMarkerGREMEDY (GLsizei, const GLvoid *); #endif /* GL_GLEXT_PROTOTYPES */ typedef void (APIENTRYP PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const GLvoid *string); #endif #ifdef __cplusplus } #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/MyExtensions.h0000644000175000017500000020517211006453404030235 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.h: interface for the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) #define AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN 1 #include #endif #if ! defined (__APPLE__) #include // for ptrdiff_t #else #include #endif #if defined(__APPLE__) # include # define GL_GLEXT_PROTOTYPES # include "glext.h" #else # define GL_GLEXT_PROTOTYPES # include # include "glext.h" # if defined(WIN32) # include # include # else # define GLX_GLXEXT_PROTOTYPES # include # endif #endif #ifndef APIENTRY #define APIENTRY #endif #ifndef GLAPI #define GLAPI extern #endif #if defined(_WIN64) typedef __int64 GLintptrARB; typedef __int64 GLsizeiptrARB; #elif defined(__ia64__) || defined(__x86_64__) typedef long int GLintptrARB; typedef long int GLsizeiptrARB; #elif defined(__APPLE__) typedef long int GLintptrARB; typedef long int GLsizeiptrARB; #else typedef int GLintptrARB; typedef int GLsizeiptrARB; #endif #ifndef GL_VERSION_2_0 /* GL type for program/shader text */ typedef char GLchar; /* native character */ #endif //#ifndef GL_VERSION_1_5 // SKVINAY without this, maverick will complain /* GL types for handling large vertex buffer objects */ #if ! defined(__APPLE__) typedef ptrdiff_t GLintptr; typedef ptrdiff_t GLsizeiptr; #endif //#endif //#ifndef GL_ARB_vertex_buffer_object //typedef ptrdiff_t GLintptrARB; //typedef ptrdiff_t GLsizeiptrARB; //#endif #ifndef GL_ARB_shader_objects /* GL types for handling shader object handles and program/shader text */ typedef char GLcharARB; /* native character */ typedef unsigned int GLhandleARB; /* shader object handle */ #endif /* GL types for "half" precision (s10e5) float data in host memory */ #ifndef GL_ARB_half_float_pixel typedef unsigned short GLhalfARB; #endif #ifndef GL_NV_half_float typedef unsigned short GLhalfNV; #endif #include "ExtensionPointers.h" #ifdef DECLARE_STATIC_POINTERS #include "StaticExtensionPointers.h" #undef DECLARE_STATIC_POINTERS #endif class MyExtensions { public: MyExtensions(); ~MyExtensions(); static bool checkExtensions(const char* requestedExtensions); bool extensionExists(const char* extension, const char* allExtensions); bool initExtensions(const char* requestedExtensions); bool initExtension(const char* extension); // OpenGL version 1.2 MYPFNGLBLENDCOLORPROC glBlendColor; MYPFNGLBLENDEQUATIONPROC glBlendEquation; MYPFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements; MYPFNGLCOLORTABLEPROC glColorTable; MYPFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv; MYPFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv; MYPFNGLCOPYCOLORTABLEPROC glCopyColorTable; MYPFNGLGETCOLORTABLEPROC glGetColorTable; MYPFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv; MYPFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv; MYPFNGLCOLORSUBTABLEPROC glColorSubTable; MYPFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable; MYPFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D; MYPFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D; MYPFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf; MYPFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv; MYPFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri; MYPFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv; MYPFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D; MYPFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D; MYPFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter; MYPFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv; MYPFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv; MYPFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter; MYPFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D; MYPFNGLGETHISTOGRAMPROC glGetHistogram; MYPFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv; MYPFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv; MYPFNGLGETMINMAXPROC glGetMinmax; MYPFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv; MYPFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv; MYPFNGLHISTOGRAMPROC glHistogram; MYPFNGLMINMAXPROC glMinmax; MYPFNGLRESETHISTOGRAMPROC glResetHistogram; MYPFNGLRESETMINMAXPROC glResetMinmax; MYPFNGLTEXIMAGE3DPROC glTexImage3D; MYPFNGLTEXSUBIMAGE3DPROC glTexSubImage3D; MYPFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D; // End OpenGL version 1.2 // OpenGL version 1.3 MYPFNGLACTIVETEXTUREPROC glActiveTexture; MYPFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture; MYPFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d; MYPFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv; MYPFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f; MYPFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv; MYPFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i; MYPFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv; MYPFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s; MYPFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv; MYPFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d; MYPFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv; MYPFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f; MYPFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv; MYPFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i; MYPFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv; MYPFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s; MYPFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv; MYPFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d; MYPFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv; MYPFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f; MYPFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv; MYPFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i; MYPFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv; MYPFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s; MYPFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv; MYPFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d; MYPFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv; MYPFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f; MYPFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv; MYPFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i; MYPFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv; MYPFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s; MYPFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv; MYPFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf; MYPFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd; MYPFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf; MYPFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd; MYPFNGLSAMPLECOVERAGEPROC glSampleCoverage; MYPFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D; MYPFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; MYPFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D; MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; MYPFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage; // End OpenGL version 1.3 // OpenGL version 1.4 MYPFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate; MYPFNGLFOGCOORDFPROC glFogCoordf; MYPFNGLFOGCOORDFVPROC glFogCoordfv; MYPFNGLFOGCOORDDPROC glFogCoordd; MYPFNGLFOGCOORDDVPROC glFogCoorddv; MYPFNGLFOGCOORDPOINTERPROC glFogCoordPointer; MYPFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays; MYPFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements; MYPFNGLPOINTPARAMETERFPROC glPointParameterf; MYPFNGLPOINTPARAMETERFVPROC glPointParameterfv; MYPFNGLPOINTPARAMETERIPROC glPointParameteri; MYPFNGLPOINTPARAMETERIVPROC glPointParameteriv; MYPFNGLSECONDARYCOLOR3BPROC glSecondaryColor3b; MYPFNGLSECONDARYCOLOR3BVPROC glSecondaryColor3bv; MYPFNGLSECONDARYCOLOR3DPROC glSecondaryColor3d; MYPFNGLSECONDARYCOLOR3DVPROC glSecondaryColor3dv; MYPFNGLSECONDARYCOLOR3FPROC glSecondaryColor3f; MYPFNGLSECONDARYCOLOR3FVPROC glSecondaryColor3fv; MYPFNGLSECONDARYCOLOR3IPROC glSecondaryColor3i; MYPFNGLSECONDARYCOLOR3IVPROC glSecondaryColor3iv; MYPFNGLSECONDARYCOLOR3SPROC glSecondaryColor3s; MYPFNGLSECONDARYCOLOR3SVPROC glSecondaryColor3sv; MYPFNGLSECONDARYCOLOR3UBPROC glSecondaryColor3ub; MYPFNGLSECONDARYCOLOR3UBVPROC glSecondaryColor3ubv; MYPFNGLSECONDARYCOLOR3UIPROC glSecondaryColor3ui; MYPFNGLSECONDARYCOLOR3UIVPROC glSecondaryColor3uiv; MYPFNGLSECONDARYCOLOR3USPROC glSecondaryColor3us; MYPFNGLSECONDARYCOLOR3USVPROC glSecondaryColor3usv; MYPFNGLSECONDARYCOLORPOINTERPROC glSecondaryColorPointer; MYPFNGLWINDOWPOS2DPROC glWindowPos2d; MYPFNGLWINDOWPOS2DVPROC glWindowPos2dv; MYPFNGLWINDOWPOS2FPROC glWindowPos2f; MYPFNGLWINDOWPOS2FVPROC glWindowPos2fv; MYPFNGLWINDOWPOS2IPROC glWindowPos2i; MYPFNGLWINDOWPOS2IVPROC glWindowPos2iv; MYPFNGLWINDOWPOS2SPROC glWindowPos2s; MYPFNGLWINDOWPOS2SVPROC glWindowPos2sv; MYPFNGLWINDOWPOS3DPROC glWindowPos3d; MYPFNGLWINDOWPOS3DVPROC glWindowPos3dv; MYPFNGLWINDOWPOS3FPROC glWindowPos3f; MYPFNGLWINDOWPOS3FVPROC glWindowPos3fv; MYPFNGLWINDOWPOS3IPROC glWindowPos3i; MYPFNGLWINDOWPOS3IVPROC glWindowPos3iv; MYPFNGLWINDOWPOS3SPROC glWindowPos3s; MYPFNGLWINDOWPOS3SVPROC glWindowPos3sv; // End OpenGL version 1.4 // OpenGL version 1.5 MYPFNGLGENQUERIESPROC glGenQueries; MYPFNGLDELETEQUERIESPROC glDeleteQueries; MYPFNGLISQUERYPROC glIsQuery; MYPFNGLBEGINQUERYPROC glBeginQuery; MYPFNGLENDQUERYPROC glEndQuery; MYPFNGLGETQUERYIVPROC glGetQueryiv; MYPFNGLGETQUERYOBJECTIVPROC glGetQueryObjectiv; MYPFNGLGETQUERYOBJECTUIVPROC glGetQueryObjectuiv; MYPFNGLBINDBUFFERPROC glBindBuffer; MYPFNGLDELETEBUFFERSPROC glDeleteBuffers; MYPFNGLGENBUFFERSPROC glGenBuffers; MYPFNGLISBUFFERPROC glIsBuffer; MYPFNGLBUFFERDATAPROC glBufferData; MYPFNGLBUFFERSUBDATAPROC glBufferSubData; MYPFNGLGETBUFFERSUBDATAPROC glGetBufferSubData; MYPFNGLMAPBUFFERPROC glMapBuffer; MYPFNGLUNMAPBUFFERPROC glUnmapBuffer; MYPFNGLGETBUFFERPARAMETERIVPROC glGetBufferParameteriv; MYPFNGLGETBUFFERPOINTERVPROC glGetBufferPointerv; // End OpenGL version 1.5 // OpenGL version 2.0 MYPFNGLBLENDEQUATIONSEPARATEPROC glBlendEquationSeparate; MYPFNGLDRAWBUFFERSPROC glDrawBuffers; MYPFNGLSTENCILOPSEPARATEPROC glStencilOpSeparate; MYPFNGLSTENCILFUNCSEPARATEPROC glStencilFuncSeparate; MYPFNGLSTENCILMASKSEPARATEPROC glStencilMaskSeparate; MYPFNGLATTACHSHADERPROC glAttachShader; MYPFNGLBINDATTRIBLOCATIONPROC glBindAttribLocation; MYPFNGLCOMPILESHADERPROC glCompileShader; MYPFNGLCREATEPROGRAMPROC glCreateProgram; MYPFNGLCREATESHADERPROC glCreateShader; MYPFNGLDELETEPROGRAMPROC glDeleteProgram; MYPFNGLDELETESHADERPROC glDeleteShader; MYPFNGLDETACHSHADERPROC glDetachShader; MYPFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray; MYPFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray; MYPFNGLGETACTIVEATTRIBPROC glGetActiveAttrib; MYPFNGLGETACTIVEUNIFORMPROC glGetActiveUniform; MYPFNGLGETATTACHEDSHADERSPROC glGetAttachedShaders; MYPFNGLGETATTRIBLOCATIONPROC glGetAttribLocation; MYPFNGLGETPROGRAMIVPROC glGetProgramiv; MYPFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog; MYPFNGLGETSHADERIVPROC glGetShaderiv; MYPFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog; MYPFNGLGETSHADERSOURCEPROC glGetShaderSource; MYPFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation; MYPFNGLGETUNIFORMFVPROC glGetUniformfv; MYPFNGLGETUNIFORMIVPROC glGetUniformiv; MYPFNGLGETVERTEXATTRIBDVPROC glGetVertexAttribdv; MYPFNGLGETVERTEXATTRIBFVPROC glGetVertexAttribfv; MYPFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv; MYPFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv; MYPFNGLISPROGRAMPROC glIsProgram; MYPFNGLISSHADERPROC glIsShader; MYPFNGLLINKPROGRAMPROC glLinkProgram; MYPFNGLSHADERSOURCEPROC glShaderSource; MYPFNGLUSEPROGRAMPROC glUseProgram; MYPFNGLUNIFORM1FPROC glUniform1f; MYPFNGLUNIFORM2FPROC glUniform2f; MYPFNGLUNIFORM3FPROC glUniform3f; MYPFNGLUNIFORM4FPROC glUniform4f; MYPFNGLUNIFORM1IPROC glUniform1i; MYPFNGLUNIFORM2IPROC glUniform2i; MYPFNGLUNIFORM3IPROC glUniform3i; MYPFNGLUNIFORM4IPROC glUniform4i; MYPFNGLUNIFORM1FVPROC glUniform1fv; MYPFNGLUNIFORM2FVPROC glUniform2fv; MYPFNGLUNIFORM3FVPROC glUniform3fv; MYPFNGLUNIFORM4FVPROC glUniform4fv; MYPFNGLUNIFORM1IVPROC glUniform1iv; MYPFNGLUNIFORM2IVPROC glUniform2iv; MYPFNGLUNIFORM3IVPROC glUniform3iv; MYPFNGLUNIFORM4IVPROC glUniform4iv; MYPFNGLUNIFORMMATRIX2FVPROC glUniformMatrix2fv; MYPFNGLUNIFORMMATRIX3FVPROC glUniformMatrix3fv; MYPFNGLUNIFORMMATRIX4FVPROC glUniformMatrix4fv; MYPFNGLVALIDATEPROGRAMPROC glValidateProgram; MYPFNGLVERTEXATTRIB1DPROC glVertexAttrib1d; MYPFNGLVERTEXATTRIB1DVPROC glVertexAttrib1dv; MYPFNGLVERTEXATTRIB1FPROC glVertexAttrib1f; MYPFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv; MYPFNGLVERTEXATTRIB1SPROC glVertexAttrib1s; MYPFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv; MYPFNGLVERTEXATTRIB2DPROC glVertexAttrib2d; MYPFNGLVERTEXATTRIB2DVPROC glVertexAttrib2dv; MYPFNGLVERTEXATTRIB2FPROC glVertexAttrib2f; MYPFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv; MYPFNGLVERTEXATTRIB2SPROC glVertexAttrib2s; MYPFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv; MYPFNGLVERTEXATTRIB3DPROC glVertexAttrib3d; MYPFNGLVERTEXATTRIB3DVPROC glVertexAttrib3dv; MYPFNGLVERTEXATTRIB3FPROC glVertexAttrib3f; MYPFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv; MYPFNGLVERTEXATTRIB3SPROC glVertexAttrib3s; MYPFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv; MYPFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv; MYPFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv; MYPFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv; MYPFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub; MYPFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv; MYPFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv; MYPFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv; MYPFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv; MYPFNGLVERTEXATTRIB4DPROC glVertexAttrib4d; MYPFNGLVERTEXATTRIB4DVPROC glVertexAttrib4dv; MYPFNGLVERTEXATTRIB4FPROC glVertexAttrib4f; MYPFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv; MYPFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv; MYPFNGLVERTEXATTRIB4SPROC glVertexAttrib4s; MYPFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv; MYPFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv; MYPFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv; MYPFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv; MYPFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer; // End OpenGL version 2.0 // GL_EXT_paletted_texture MYPFNGLCOLORTABLEEXTPROC glColorTableEXT; MYPFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; // End GL_EXT_paletted_texture // GL_ARB_multitexture MYPFNGLACTIVETEXTUREARBPROC glActiveTextureARB; MYPFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB; MYPFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB; MYPFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB; MYPFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB; MYPFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB; MYPFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB; MYPFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB; MYPFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB; MYPFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB; MYPFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB; MYPFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB; MYPFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB; MYPFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB; MYPFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB; MYPFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB; MYPFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB; MYPFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB; MYPFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB; MYPFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB; MYPFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB; MYPFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB; MYPFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB; MYPFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB; MYPFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB; MYPFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB; MYPFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB; MYPFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB; MYPFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB; MYPFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB; MYPFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB; MYPFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB; MYPFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB; MYPFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB; // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table MYPFNGLCOLORTABLESGIPROC glColorTableSGI; MYPFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; MYPFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; MYPFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; MYPFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D MYPFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; MYPFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; // End GL_EXT_texture3D // GL_NV_fragment_program MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; // End GL_NV_fragment_program // GL_NV_vertex_program MYPFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; MYPFNGLBINDPROGRAMNVPROC glBindProgramNV; MYPFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; MYPFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; MYPFNGLGENPROGRAMSNVPROC glGenProgramsNV; MYPFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; MYPFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; MYPFNGLGETPROGRAMIVNVPROC glGetProgramivNV; MYPFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; MYPFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; MYPFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; MYPFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; MYPFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; MYPFNGLISPROGRAMNVPROC glIsProgramNV; MYPFNGLLOADPROGRAMNVPROC glLoadProgramNV; MYPFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; MYPFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; MYPFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; MYPFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; MYPFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; MYPFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; MYPFNGLTRACKMATRIXNVPROC glTrackMatrixNV; MYPFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; MYPFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; MYPFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; MYPFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; MYPFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; MYPFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; MYPFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; MYPFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; MYPFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; MYPFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; MYPFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; MYPFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; MYPFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; MYPFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; MYPFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; MYPFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; MYPFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; MYPFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; MYPFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; MYPFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; MYPFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; MYPFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; MYPFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; MYPFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; MYPFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; MYPFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; MYPFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; MYPFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; MYPFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; MYPFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; MYPFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; MYPFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; MYPFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; MYPFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; MYPFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; MYPFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; MYPFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; MYPFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; MYPFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; MYPFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; // End GL_NV_vertex_program // GL_ARB_vertex_program MYPFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; MYPFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; MYPFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; MYPFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; MYPFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; MYPFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; MYPFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; MYPFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; MYPFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; MYPFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; MYPFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; MYPFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; MYPFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; MYPFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; MYPFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; MYPFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; MYPFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; MYPFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; MYPFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; MYPFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; MYPFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; MYPFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; MYPFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; MYPFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; MYPFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; MYPFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; MYPFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; MYPFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; MYPFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; MYPFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; MYPFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; MYPFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; MYPFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; MYPFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; MYPFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; MYPFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; MYPFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; MYPFNGLPROGRAMSTRINGARBPROC glProgramStringARB; MYPFNGLBINDPROGRAMARBPROC glBindProgramARB; MYPFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; MYPFNGLGENPROGRAMSARBPROC glGenProgramsARB; MYPFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; MYPFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; MYPFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; MYPFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; MYPFNGLGETPROGRAMIVARBPROC glGetProgramivARB; MYPFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; MYPFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; MYPFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; MYPFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; MYPFNGLISPROGRAMARBPROC glIsProgramARB; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program // EXT_secondary_color MYPFNGLSECONDARYCOLOR3BEXTPROC glSecondaryColor3bEXT; MYPFNGLSECONDARYCOLOR3BVEXTPROC glSecondaryColor3bvEXT; MYPFNGLSECONDARYCOLOR3DEXTPROC glSecondaryColor3dEXT; MYPFNGLSECONDARYCOLOR3DVEXTPROC glSecondaryColor3dvEXT; MYPFNGLSECONDARYCOLOR3FEXTPROC glSecondaryColor3fEXT; MYPFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT; MYPFNGLSECONDARYCOLOR3IEXTPROC glSecondaryColor3iEXT; MYPFNGLSECONDARYCOLOR3IVEXTPROC glSecondaryColor3ivEXT; MYPFNGLSECONDARYCOLOR3SEXTPROC glSecondaryColor3sEXT; MYPFNGLSECONDARYCOLOR3SVEXTPROC glSecondaryColor3svEXT; MYPFNGLSECONDARYCOLOR3UBEXTPROC glSecondaryColor3ubEXT; MYPFNGLSECONDARYCOLOR3UBVEXTPROC glSecondaryColor3ubvEXT; MYPFNGLSECONDARYCOLOR3UIEXTPROC glSecondaryColor3uiEXT; MYPFNGLSECONDARYCOLOR3UIVEXTPROC glSecondaryColor3uivEXT; MYPFNGLSECONDARYCOLOR3USEXTPROC glSecondaryColor3usEXT; MYPFNGLSECONDARYCOLOR3USVEXTPROC glSecondaryColor3usvEXT; MYPFNGLSECONDARYCOLORPOINTEREXTPROC glSecondaryColorPointerEXT; // ARB_vertex_buffer_object MYPFNGLBINDBUFFERARBPROC glBindBufferARB; MYPFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB; MYPFNGLGENBUFFERSARBPROC glGenBuffersARB; MYPFNGLISBUFFERARBPROC glIsBufferARB; MYPFNGLBUFFERDATAARBPROC glBufferDataARB; MYPFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB; MYPFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB; MYPFNGLMAPBUFFERARBPROC glMapBufferARB; MYPFNGLUNMAPBUFFERARBPROC glUnmapBufferARB; MYPFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB; MYPFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB; #if defined(WIN32) /// WGL extensions follows // WGL_ARB_pixel_format MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB; MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC wglGetPixelFormatAttribfvARB; MYPFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer MYPFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB; MYPFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB; MYPFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB; MYPFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB; MYPFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB; // End WGL_ARB_pbuffer // WGL_ARB_render_texture MYPFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB; MYPFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB; MYPFNWGLSETPBUFFERATTRIBARBPROC wglSetPbufferAttribARB; // End WGL_ARB_render_texture // WGL_ARB_extensions_string MYPFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB; // End WGL_ARB_extensions_string #endif // defined(WIN32) protected: void initPointersToZero(); static const char* EatWhiteSpace(const char* str); static const char* EatNonWhiteSpace(const char* str); static const char* getExtensionStringPrivate(); static const char* getSystemExtensions(); }; // declare the extensions that we support and prepare the constants #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_RESCALE_NORMAL 0x803A #define GL_TEXTURE_BINDING_3D 0x806A #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_TEXTURE_3D 0x806F #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_CLAMP_TO_EDGE 0x812F #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_SINGLE_COLOR 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E #endif #ifndef GL_VERSION_1_3 #define GL_VERSION_1_3 1 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_MULTISAMPLE 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLES 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_MULTISAMPLE_BIT 0x20000000 #define GL_NORMAL_MAP 0x8511 #define GL_REFLECTION_MAP 0x8512 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_CLAMP_TO_BORDER 0x812D #define GL_CLAMP_TO_BORDER_SGIS 0x812D #define GL_COMBINE 0x8570 #define GL_COMBINE_RGB 0x8571 #define GL_COMBINE_ALPHA 0x8572 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_RGB 0x8582 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE2_ALPHA 0x858A #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_RGB 0x8592 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND2_ALPHA 0x859A #define GL_RGB_SCALE 0x8573 #define GL_ADD_SIGNED 0x8574 #define GL_INTERPOLATE 0x8575 #define GL_SUBTRACT 0x84E7 #define GL_CONSTANT 0x8576 #define GL_PRIMARY_COLOR 0x8577 #define GL_PREVIOUS 0x8578 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #endif #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_MIRRORED_REPEAT 0x8370 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORDINATE 0x8451 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_COLOR_SUM 0x8458 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_INCR_WRAP 0x8507 #define GL_DECR_WRAP 0x8508 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_R_TO_TEXTURE 0x884E #endif #ifndef GL_VERSION_1_5 #define GL_VERSION_1_5 1 #define GL_BUFFER_SIZE 0x8764 #define GL_BUFFER_USAGE 0x8765 #define GL_QUERY_COUNTER_BITS 0x8864 #define GL_CURRENT_QUERY 0x8865 #define GL_QUERY_RESULT 0x8866 #define GL_QUERY_RESULT_AVAILABLE 0x8867 #define GL_ARRAY_BUFFER 0x8892 #define GL_ELEMENT_ARRAY_BUFFER 0x8893 #define GL_ARRAY_BUFFER_BINDING 0x8894 #define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 #define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 #define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 #define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 #define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D #define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F #define GL_READ_ONLY 0x88B8 #define GL_WRITE_ONLY 0x88B9 #define GL_READ_WRITE 0x88BA #define GL_BUFFER_ACCESS 0x88BB #define GL_BUFFER_MAPPED 0x88BC #define GL_BUFFER_MAP_POINTER 0x88BD #define GL_STREAM_DRAW 0x88E0 #define GL_STREAM_READ 0x88E1 #define GL_STREAM_COPY 0x88E2 #define GL_STATIC_DRAW 0x88E4 #define GL_STATIC_READ 0x88E5 #define GL_STATIC_COPY 0x88E6 #define GL_DYNAMIC_DRAW 0x88E8 #define GL_DYNAMIC_READ 0x88E9 #define GL_DYNAMIC_COPY 0x88EA #define GL_SAMPLES_PASSED 0x8914 #define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE #define GL_FOG_COORD GL_FOG_COORDINATE #define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE #define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE #define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE #define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER #define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY #define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING #define GL_SRC0_RGB GL_SOURCE0_RGB #define GL_SRC1_RGB GL_SOURCE1_RGB #define GL_SRC2_RGB GL_SOURCE2_RGB #define GL_SRC0_ALPHA GL_SOURCE0_ALPHA #define GL_SRC1_ALPHA GL_SOURCE1_ALPHA #define GL_SRC2_ALPHA GL_SOURCE2_ALPHA #endif #ifndef GL_VERSION_2_0 #define GL_VERSION_2_0 1 #define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION #define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 #define GL_CURRENT_VERTEX_ATTRIB 0x8626 #define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 #define GL_STENCIL_BACK_FUNC 0x8800 #define GL_STENCIL_BACK_FAIL 0x8801 #define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 #define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 #define GL_MAX_DRAW_BUFFERS 0x8824 #define GL_DRAW_BUFFER0 0x8825 #define GL_DRAW_BUFFER1 0x8826 #define GL_DRAW_BUFFER2 0x8827 #define GL_DRAW_BUFFER3 0x8828 #define GL_DRAW_BUFFER4 0x8829 #define GL_DRAW_BUFFER5 0x882A #define GL_DRAW_BUFFER6 0x882B #define GL_DRAW_BUFFER7 0x882C #define GL_DRAW_BUFFER8 0x882D #define GL_DRAW_BUFFER9 0x882E #define GL_DRAW_BUFFER10 0x882F #define GL_DRAW_BUFFER11 0x8830 #define GL_DRAW_BUFFER12 0x8831 #define GL_DRAW_BUFFER13 0x8832 #define GL_DRAW_BUFFER14 0x8833 #define GL_DRAW_BUFFER15 0x8834 #define GL_BLEND_EQUATION_ALPHA 0x883D #define GL_POINT_SPRITE 0x8861 #define GL_COORD_REPLACE 0x8862 #define GL_MAX_VERTEX_ATTRIBS 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A #define GL_MAX_TEXTURE_COORDS 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 #define GL_FRAGMENT_SHADER 0x8B30 #define GL_VERTEX_SHADER 0x8B31 #define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 #define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A #define GL_MAX_VARYING_FLOATS 0x8B4B #define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C #define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D #define GL_SHADER_TYPE 0x8B4F #define GL_FLOAT_VEC2 0x8B50 #define GL_FLOAT_VEC3 0x8B51 #define GL_FLOAT_VEC4 0x8B52 #define GL_INT_VEC2 0x8B53 #define GL_INT_VEC3 0x8B54 #define GL_INT_VEC4 0x8B55 #define GL_BOOL 0x8B56 #define GL_BOOL_VEC2 0x8B57 #define GL_BOOL_VEC3 0x8B58 #define GL_BOOL_VEC4 0x8B59 #define GL_FLOAT_MAT2 0x8B5A #define GL_FLOAT_MAT3 0x8B5B #define GL_FLOAT_MAT4 0x8B5C #define GL_SAMPLER_1D 0x8B5D #define GL_SAMPLER_2D 0x8B5E #define GL_SAMPLER_3D 0x8B5F #define GL_SAMPLER_CUBE 0x8B60 #define GL_SAMPLER_1D_SHADOW 0x8B61 #define GL_SAMPLER_2D_SHADOW 0x8B62 #define GL_DELETE_STATUS 0x8B80 #define GL_COMPILE_STATUS 0x8B81 #define GL_LINK_STATUS 0x8B82 #define GL_VALIDATE_STATUS 0x8B83 #define GL_INFO_LOG_LENGTH 0x8B84 #define GL_ATTACHED_SHADERS 0x8B85 #define GL_ACTIVE_UNIFORMS 0x8B86 #define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 #define GL_SHADER_SOURCE_LENGTH 0x8B88 #define GL_ACTIVE_ATTRIBUTES 0x8B89 #define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A #define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B #define GL_SHADING_LANGUAGE_VERSION 0x8B8C #define GL_CURRENT_PROGRAM 0x8B8D #define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 #define GL_LOWER_LEFT 0x8CA1 #define GL_UPPER_LEFT 0x8CA2 #define GL_STENCIL_BACK_REF 0x8CA3 #define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 #define GL_STENCIL_BACK_WRITEMASK 0x8CA5 #endif #ifndef GL_ARB_imaging #define GL_CONSTANT_COLOR 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_CONSTANT_ALPHA 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_BLEND_COLOR 0x8005 #define GL_FUNC_ADD 0x8006 #define GL_MIN 0x8007 #define GL_MAX 0x8008 #define GL_BLEND_EQUATION 0x8009 #define GL_FUNC_SUBTRACT 0x800A #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_CONVOLUTION_1D 0x8010 #define GL_CONVOLUTION_2D 0x8011 #define GL_SEPARABLE_2D 0x8012 #define GL_CONVOLUTION_BORDER_MODE 0x8013 #define GL_CONVOLUTION_FILTER_SCALE 0x8014 #define GL_CONVOLUTION_FILTER_BIAS 0x8015 #define GL_REDUCE 0x8016 #define GL_CONVOLUTION_FORMAT 0x8017 #define GL_CONVOLUTION_WIDTH 0x8018 #define GL_CONVOLUTION_HEIGHT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH 0x801A #define GL_MAX_CONVOLUTION_HEIGHT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F #define GL_POST_CONVOLUTION_RED_BIAS 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 #define GL_HISTOGRAM 0x8024 #define GL_PROXY_HISTOGRAM 0x8025 #define GL_HISTOGRAM_WIDTH 0x8026 #define GL_HISTOGRAM_FORMAT 0x8027 #define GL_HISTOGRAM_RED_SIZE 0x8028 #define GL_HISTOGRAM_GREEN_SIZE 0x8029 #define GL_HISTOGRAM_BLUE_SIZE 0x802A #define GL_HISTOGRAM_ALPHA_SIZE 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C #define GL_HISTOGRAM_SINK 0x802D #define GL_MINMAX 0x802E #define GL_MINMAX_FORMAT 0x802F #define GL_MINMAX_SINK 0x8030 #define GL_TABLE_TOO_LARGE 0x8031 #define GL_COLOR_MATRIX 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB #define GL_COLOR_TABLE 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 #define GL_PROXY_COLOR_TABLE 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 #define GL_COLOR_TABLE_SCALE 0x80D6 #define GL_COLOR_TABLE_BIAS 0x80D7 #define GL_COLOR_TABLE_FORMAT 0x80D8 #define GL_COLOR_TABLE_WIDTH 0x80D9 #define GL_COLOR_TABLE_RED_SIZE 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF #define GL_CONSTANT_BORDER 0x8151 #define GL_REPLICATE_BORDER 0x8153 #define GL_CONVOLUTION_BORDER_COLOR 0x8154 #endif #ifndef GL_EXT_paletted_texture #define GL_EXT_paletted_texture 1 #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED #endif #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 #define GL_TEXTURE2_ARB 0x84C2 #define GL_TEXTURE3_ARB 0x84C3 #define GL_TEXTURE4_ARB 0x84C4 #define GL_TEXTURE5_ARB 0x84C5 #define GL_TEXTURE6_ARB 0x84C6 #define GL_TEXTURE7_ARB 0x84C7 #define GL_TEXTURE8_ARB 0x84C8 #define GL_TEXTURE9_ARB 0x84C9 #define GL_TEXTURE10_ARB 0x84CA #define GL_TEXTURE11_ARB 0x84CB #define GL_TEXTURE12_ARB 0x84CC #define GL_TEXTURE13_ARB 0x84CD #define GL_TEXTURE14_ARB 0x84CE #define GL_TEXTURE15_ARB 0x84CF #define GL_TEXTURE16_ARB 0x84D0 #define GL_TEXTURE17_ARB 0x84D1 #define GL_TEXTURE18_ARB 0x84D2 #define GL_TEXTURE19_ARB 0x84D3 #define GL_TEXTURE20_ARB 0x84D4 #define GL_TEXTURE21_ARB 0x84D5 #define GL_TEXTURE22_ARB 0x84D6 #define GL_TEXTURE23_ARB 0x84D7 #define GL_TEXTURE24_ARB 0x84D8 #define GL_TEXTURE25_ARB 0x84D9 #define GL_TEXTURE26_ARB 0x84DA #define GL_TEXTURE27_ARB 0x84DB #define GL_TEXTURE28_ARB 0x84DC #define GL_TEXTURE29_ARB 0x84DD #define GL_TEXTURE30_ARB 0x84DE #define GL_TEXTURE31_ARB 0x84DF #define GL_ACTIVE_TEXTURE_ARB 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 #endif #ifndef GL_SGI_texture_color_table #define GL_SGI_texture_color_table 1 #define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC #define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD #endif #ifndef GL_SGI_color_table #define GL_SGI_color_table 1 #define GL_COLOR_TABLE_SGI 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 #define GL_PROXY_COLOR_TABLE_SGI 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 #define GL_COLOR_TABLE_SCALE_SGI 0x80D6 #define GL_COLOR_TABLE_BIAS_SGI 0x80D7 #define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 #define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF #endif #ifndef GL_SGIS_texture_edge_clamp #define GL_SGIS_texture_edge_clamp 1 #define GL_CLAMP_TO_EDGE_SGIS 0x812F #endif #ifndef GL_EXT_texture3D #define GL_EXT_texture3D 1 #define GL_PACK_SKIP_IMAGES_EXT 0x806B #define GL_PACK_IMAGE_HEIGHT_EXT 0x806C #define GL_UNPACK_SKIP_IMAGES_EXT 0x806D #define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E #define GL_TEXTURE_3D_EXT 0x806F #define GL_PROXY_TEXTURE_3D_EXT 0x8070 #define GL_TEXTURE_DEPTH_EXT 0x8071 #define GL_TEXTURE_WRAP_R_EXT 0x8072 #define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 #endif #ifndef GL_NV_fragment_program #define GL_NV_fragment_program 1 #define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 #define GL_FRAGMENT_PROGRAM_NV 0x8870 #define GL_MAX_TEXTURE_COORDS_NV 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 #define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 #define GL_PROGRAM_ERROR_STRING_NV 0x8874 #endif #ifndef GL_NV_vertex_program #define GL_NV_vertex_program 1 #define GL_VERTEX_PROGRAM_NV 0x8620 #define GL_VERTEX_STATE_PROGRAM_NV 0x8621 #define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 #define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 #define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 #define GL_CURRENT_ATTRIB_NV 0x8626 #define GL_PROGRAM_LENGTH_NV 0x8627 #define GL_PROGRAM_STRING_NV 0x8628 #define GL_MODELVIEW_PROJECTION_NV 0x8629 #define GL_IDENTITY_NV 0x862A #define GL_INVERSE_NV 0x862B #define GL_TRANSPOSE_NV 0x862C #define GL_INVERSE_TRANSPOSE_NV 0x862D #define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E #define GL_MAX_TRACK_MATRICES_NV 0x862F #define GL_MATRIX0_NV 0x8630 #define GL_MATRIX1_NV 0x8631 #define GL_MATRIX2_NV 0x8632 #define GL_MATRIX3_NV 0x8633 #define GL_MATRIX4_NV 0x8634 #define GL_MATRIX5_NV 0x8635 #define GL_MATRIX6_NV 0x8636 #define GL_MATRIX7_NV 0x8637 #define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 #define GL_CURRENT_MATRIX_NV 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 #define GL_PROGRAM_PARAMETER_NV 0x8644 #define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 #define GL_PROGRAM_TARGET_NV 0x8646 #define GL_PROGRAM_RESIDENT_NV 0x8647 #define GL_TRACK_MATRIX_NV 0x8648 #define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 #define GL_VERTEX_PROGRAM_BINDING_NV 0x864A #define GL_PROGRAM_ERROR_POSITION_NV 0x864B #define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 #define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 #define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 #define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 #define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 #define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 #define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 #define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 #define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 #define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 #define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A #define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B #define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C #define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D #define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E #define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F #define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 #define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 #define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 #define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 #define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 #define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 #define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 #define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 #define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 #define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 #define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A #define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B #define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C #define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D #define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E #define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F #define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 #define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 #define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 #define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 #define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 #define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 #define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 #define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 #define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 #define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 #define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A #define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B #define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C #define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D #define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E #define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F #endif #ifndef GL_ARB_vertex_program #define GL_ARB_vertex_program 1 #define GL_COLOR_SUM_ARB 0x8458 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF #endif #ifndef GL_ARB_fragment_program #define GL_ARB_fragment_program 1 #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #endif // EXT_secondary_color #ifndef GL_EXT_secondary_color #define GL_EXT_secondary_color 1 #define GL_COLOR_SUM_EXT 0x8458 #define GL_CURRENT_SECONDARY_COLOR_EXT 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D #define GL_SECONDARY_COLOR_ARRAY_EXT 0x845E #endif // ARB_vertex_buffer_object #ifndef GL_ARB_vertex_buffer_object #define GL_ARB_vertex_buffer_object 1 #define GL_BUFFER_SIZE_ARB 0x8764 #define GL_BUFFER_USAGE_ARB 0x8765 #define GL_ARRAY_BUFFER_ARB 0x8892 #define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893 #define GL_ARRAY_BUFFER_BINDING_ARB 0x8894 #define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895 #define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896 #define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897 #define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898 #define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899 #define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A #define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B #define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C #define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D #define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E #define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F #define GL_READ_ONLY_ARB 0x88B8 #define GL_WRITE_ONLY_ARB 0x88B9 #define GL_READ_WRITE_ARB 0x88BA #define GL_BUFFER_ACCESS_ARB 0x88BB #define GL_BUFFER_MAPPED_ARB 0x88BC #define GL_BUFFER_MAP_POINTER_ARB 0x88BD #define GL_STREAM_DRAW_ARB 0x88E0 #define GL_STREAM_READ_ARB 0x88E1 #define GL_STREAM_COPY_ARB 0x88E2 #define GL_STATIC_DRAW_ARB 0x88E4 #define GL_STATIC_READ_ARB 0x88E5 #define GL_STATIC_COPY_ARB 0x88E6 #define GL_DYNAMIC_DRAW_ARB 0x88E8 #define GL_DYNAMIC_READ_ARB 0x88E9 #define GL_DYNAMIC_COPY_ARB 0x88EA #endif /// WGL extensions follow #if defined(WIN32) #ifndef WGL_ARB_pixel_format #define WGL_ARB_pixel_format 1 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 #define WGL_DRAW_TO_WINDOW_ARB 0x2001 #define WGL_DRAW_TO_BITMAP_ARB 0x2002 #define WGL_ACCELERATION_ARB 0x2003 #define WGL_NEED_PALETTE_ARB 0x2004 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 #define WGL_SWAP_METHOD_ARB 0x2007 #define WGL_NUMBER_OVERLAYS_ARB 0x2008 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009 #define WGL_TRANSPARENT_ARB 0x200A #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B #define WGL_SHARE_DEPTH_ARB 0x200C #define WGL_SHARE_STENCIL_ARB 0x200D #define WGL_SHARE_ACCUM_ARB 0x200E #define WGL_SUPPORT_GDI_ARB 0x200F #define WGL_SUPPORT_OPENGL_ARB 0x2010 #define WGL_DOUBLE_BUFFER_ARB 0x2011 #define WGL_STEREO_ARB 0x2012 #define WGL_PIXEL_TYPE_ARB 0x2013 #define WGL_COLOR_BITS_ARB 0x2014 #define WGL_RED_BITS_ARB 0x2015 #define WGL_RED_SHIFT_ARB 0x2016 #define WGL_GREEN_BITS_ARB 0x2017 #define WGL_GREEN_SHIFT_ARB 0x2018 #define WGL_BLUE_BITS_ARB 0x2019 #define WGL_BLUE_SHIFT_ARB 0x201A #define WGL_ALPHA_BITS_ARB 0x201B #define WGL_ALPHA_SHIFT_ARB 0x201C #define WGL_ACCUM_BITS_ARB 0x201D #define WGL_ACCUM_RED_BITS_ARB 0x201E #define WGL_ACCUM_GREEN_BITS_ARB 0x201F #define WGL_ACCUM_BLUE_BITS_ARB 0x2020 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 #define WGL_DEPTH_BITS_ARB 0x2022 #define WGL_STENCIL_BITS_ARB 0x2023 #define WGL_AUX_BUFFERS_ARB 0x2024 #define WGL_NO_ACCELERATION_ARB 0x2025 #define WGL_GENERIC_ACCELERATION_ARB 0x2026 #define WGL_FULL_ACCELERATION_ARB 0x2027 #define WGL_SWAP_EXCHANGE_ARB 0x2028 #define WGL_SWAP_COPY_ARB 0x2029 #define WGL_SWAP_UNDEFINED_ARB 0x202A #define WGL_TYPE_RGBA_ARB 0x202B #define WGL_TYPE_COLORINDEX_ARB 0x202C #endif #ifndef WGL_ARB_pbuffer #define WGL_ARB_pbuffer 1 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 #define WGL_PBUFFER_LARGEST_ARB 0x2033 #define WGL_PBUFFER_WIDTH_ARB 0x2034 #define WGL_PBUFFER_HEIGHT_ARB 0x2035 #define WGL_PBUFFER_LOST_ARB 0x2036 #endif #ifndef WGL_ARB_render_texture #define WGL_ARB_render_texture 1 #define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 #define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 #define WGL_TEXTURE_FORMAT_ARB 0x2072 #define WGL_TEXTURE_TARGET_ARB 0x2073 #define WGL_MIPMAP_TEXTURE_ARB 0x2074 #define WGL_TEXTURE_RGB_ARB 0x2075 #define WGL_TEXTURE_RGBA_ARB 0x2076 #define WGL_NO_TEXTURE_ARB 0x2077 #define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 #define WGL_TEXTURE_1D_ARB 0x2079 #define WGL_TEXTURE_2D_ARB 0x207A #define WGL_MIPMAP_LEVEL_ARB 0x207B #define WGL_CUBE_MAP_FACE_ARB 0x207C #define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 #define WGL_FRONT_LEFT_ARB 0x2083 #define WGL_FRONT_RIGHT_ARB 0x2084 #define WGL_BACK_LEFT_ARB 0x2085 #define WGL_BACK_RIGHT_ARB 0x2086 #define WGL_AUX0_ARB 0x2087 #define WGL_AUX1_ARB 0x2088 #define WGL_AUX2_ARB 0x2089 #define WGL_AUX3_ARB 0x208A #define WGL_AUX4_ARB 0x208B #define WGL_AUX5_ARB 0x208C #define WGL_AUX6_ARB 0x208D #define WGL_AUX7_ARB 0x208E #define WGL_AUX8_ARB 0x208F #define WGL_AUX9_ARB 0x2090 #endif #ifndef WGL_ARB_extensions_string #define WGL_ARB_extensions_string 1 #endif #endif // defined(WIN32) // CHANGE !!! SKVINAY #define GL_HILO_NV 0x86F4 #endif // !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/OpenGL_Viewer/MyExtensions.cpp0000644000175000017500000016122411006453404030567 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.cpp: implementation of the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #define DECLARE_STATIC_POINTERS #include "MyExtensions.h" #include #include #include #include #include #include #define STATIC_POINTER_PREFIX staticPointer #define CREATESTATICNAME2(a,b) a##b #define CREATESTATICNAME(a,b) CREATESTATICNAME2(a,b) // define a macro for getting the address of a function #if defined(_WIN32) // use the windows technique #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) wglGetProcAddress(#procName) ; if (procName==0) return false #elif defined(GLX_ARB_get_proc_address) // use glXGetProcAddress #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) glXGetProcAddressARB( (const GLubyte *) #procName) ; if (procName==0) return false #elif defined(GLX_get_proc_address) // use glXGetProcAddress for Maverick (sun os) #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) glXGetProcAddress( (const GLubyte *) #procName) ; if (procName==0) return false #else // try to get the static location of the function #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) CREATESTATICNAME(STATIC_POINTER_PREFIX,procName) ; if (procName==0) return false #endif // define a macro for getting addresses of wgl functions #if defined(_WIN32) #define INIT_WGL_PROC_POINTER(pointerType,procName) procName = (pointerType) wglGetProcAddress(#procName) ; if (procName==0) return false #else // wgl functions are only supported in windows #define INIT_WGL_PROC_POINTER(pointerType,procName) procName = 0 ; return false #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// MyExtensions::MyExtensions() { initPointersToZero(); initStaticPointers(); } MyExtensions::~MyExtensions() { } bool MyExtensions::extensionExists(const char* extension, const char* allExtensions) { int extLen = strlen(extension); char* padExtName = new char[extLen + 2]; strcpy(padExtName, extension); padExtName[extLen] = ' '; padExtName[extLen+1] = 0; if (0 == strcmp(extension, "GL_VERSION_1_2")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_3")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_4")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version || strstr(version, "1.3") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_5")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version || strstr(version, "1.3") == version || strstr(version, "1.4") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_2_0")) { const char *version = (const char*)glGetString(GL_VERSION); const char* whatever = strstr(version, "1.5"); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version || strstr(version, "1.3") == version || strstr(version, "1.4") == version || strstr(version, "1.5") == version) { return false; } else { return true; } } if (strstr(allExtensions, padExtName)) { delete [] padExtName; return true; } else { delete [] padExtName; return false; } } bool MyExtensions::checkExtensions(const char* requestedExtensions) { MyExtensions myExtensions; return myExtensions.initExtensions(requestedExtensions); } bool MyExtensions::initExtensions(const char* requestedExtensions) { if (!requestedExtensions) { return false; } // get the extensions string and pad it const char *extensions = getExtensionStringPrivate(); if( !extensions ) { return false; // SKVINAY : this was needed ! } int normalExtsLen = 0; if(extensions) normalExtsLen = strlen(extensions); const char* systemExtensions = getSystemExtensions(); int systemExtsLen; char* paddedExtensions; if (systemExtensions) { systemExtsLen = strlen(systemExtensions); paddedExtensions = new char[normalExtsLen + 1 + systemExtsLen + 2]; if(extensions) strcpy(paddedExtensions, extensions); paddedExtensions[normalExtsLen] = ' '; strcpy(paddedExtensions+normalExtsLen+1, systemExtensions); paddedExtensions[normalExtsLen + 1 + systemExtsLen] = ' '; paddedExtensions[normalExtsLen + 1 + systemExtsLen+1] = 0; } else { systemExtsLen = 0; paddedExtensions = new char[normalExtsLen+2]; if(extensions) strcpy(paddedExtensions, extensions); paddedExtensions[normalExtsLen] = ' '; paddedExtensions[normalExtsLen+1] = 0; } // duplicate the requested string int reqExtsLen = strlen(requestedExtensions); char* reqExts = new char[reqExtsLen+1]; strcpy(reqExts, requestedExtensions); char* currentExt; bool success = true; // Parse requested extension list for (currentExt = reqExts; (currentExt = (char*)EatWhiteSpace(currentExt)) && *currentExt; currentExt = (char*)EatNonWhiteSpace(currentExt)) { char *extEnd = (char*)EatNonWhiteSpace(currentExt); char saveChar = *extEnd; *extEnd = (char)0; bool exists = extensionExists(currentExt, paddedExtensions); bool inits = initExtension(currentExt); if (!exists || !inits) { // failed // std::cerr << "Couldn't find " << currentExt << " " << exists << " " << inits << "\n"; success = false; } *extEnd = saveChar; } delete [] paddedExtensions; delete [] reqExts; return success; } bool MyExtensions::initExtension(const char* extension) { if (0 == extension) { return false; } #ifdef GL_VERSION_1_2 else if (0 == strcmp(extension, "GL_VERSION_1_2")) { INIT_PROC_POINTER(MYPFNGLBLENDCOLORPROC, glBlendColor); INIT_PROC_POINTER(MYPFNGLBLENDEQUATIONPROC, glBlendEquation); INIT_PROC_POINTER(MYPFNGLDRAWRANGEELEMENTSPROC, glDrawRangeElements); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPROC, glColorTable); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERFVPROC, glColorTableParameterfv); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERIVPROC, glColorTableParameteriv); INIT_PROC_POINTER(MYPFNGLCOPYCOLORTABLEPROC, glCopyColorTable); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPROC, glGetColorTable); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVPROC, glGetColorTableParameterfv); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVPROC, glGetColorTableParameteriv); INIT_PROC_POINTER(MYPFNGLCOLORSUBTABLEPROC, glColorSubTable); INIT_PROC_POINTER(MYPFNGLCOPYCOLORSUBTABLEPROC, glCopyColorSubTable); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONFILTER1DPROC, glConvolutionFilter1D); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONFILTER2DPROC, glConvolutionFilter2D); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERFPROC, glConvolutionParameterf); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERFVPROC, glConvolutionParameterfv); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERIPROC, glConvolutionParameteri); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERIVPROC, glConvolutionParameteriv); INIT_PROC_POINTER(MYPFNGLCOPYCONVOLUTIONFILTER1DPROC, glCopyConvolutionFilter1D); INIT_PROC_POINTER(MYPFNGLCOPYCONVOLUTIONFILTER2DPROC, glCopyConvolutionFilter2D); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONFILTERPROC, glGetConvolutionFilter); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONPARAMETERFVPROC, glGetConvolutionParameterfv); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONPARAMETERIVPROC, glGetConvolutionParameteriv); INIT_PROC_POINTER(MYPFNGLGETSEPARABLEFILTERPROC, glGetSeparableFilter); INIT_PROC_POINTER(MYPFNGLSEPARABLEFILTER2DPROC, glSeparableFilter2D); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPROC, glGetHistogram); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPARAMETERFVPROC, glGetHistogramParameterfv); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPARAMETERIVPROC, glGetHistogramParameteriv); INIT_PROC_POINTER(MYPFNGLGETMINMAXPROC, glGetMinmax); INIT_PROC_POINTER(MYPFNGLGETMINMAXPARAMETERFVPROC, glGetMinmaxParameterfv); INIT_PROC_POINTER(MYPFNGLGETMINMAXPARAMETERIVPROC, glGetMinmaxParameteriv); INIT_PROC_POINTER(MYPFNGLHISTOGRAMPROC, glHistogram); INIT_PROC_POINTER(MYPFNGLMINMAXPROC, glMinmax); INIT_PROC_POINTER(MYPFNGLRESETHISTOGRAMPROC, glResetHistogram); INIT_PROC_POINTER(MYPFNGLRESETMINMAXPROC, glResetMinmax); INIT_PROC_POINTER(MYPFNGLTEXIMAGE3DPROC, glTexImage3D); INIT_PROC_POINTER(MYPFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D); INIT_PROC_POINTER(MYPFNGLCOPYTEXSUBIMAGE3DPROC, glCopyTexSubImage3D); return true; } #endif // GL_VERSION_1_2 #ifdef GL_VERSION_1_3 else if (0 == strcmp(extension, "GL_VERSION_1_3")) { INIT_PROC_POINTER(MYPFNGLACTIVETEXTUREPROC, glActiveTexture); INIT_PROC_POINTER(MYPFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv); INIT_PROC_POINTER(MYPFNGLLOADTRANSPOSEMATRIXFPROC, glLoadTransposeMatrixf); INIT_PROC_POINTER(MYPFNGLLOADTRANSPOSEMATRIXDPROC, glLoadTransposeMatrixd); INIT_PROC_POINTER(MYPFNGLMULTTRANSPOSEMATRIXFPROC, glMultTransposeMatrixf); INIT_PROC_POINTER(MYPFNGLMULTTRANSPOSEMATRIXDPROC, glMultTransposeMatrixd); INIT_PROC_POINTER(MYPFNGLSAMPLECOVERAGEPROC, glSampleCoverage); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE3DPROC, glCompressedTexImage3D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE2DPROC, glCompressedTexImage2D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE1DPROC, glCompressedTexImage1D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D); INIT_PROC_POINTER(MYPFNGLGETCOMPRESSEDTEXIMAGEPROC, glGetCompressedTexImage); return initExtension("GL_VERSION_1_2"); } #endif // GL_VERSION_1_3 #ifdef GL_VERSION_1_4 else if (0 == strcmp(extension, "GL_VERSION_1_4")) { INIT_PROC_POINTER(MYPFNGLBLENDFUNCSEPARATEPROC, glBlendFuncSeparate); INIT_PROC_POINTER(MYPFNGLFOGCOORDFPROC, glFogCoordf); INIT_PROC_POINTER(MYPFNGLFOGCOORDFVPROC, glFogCoordfv); INIT_PROC_POINTER(MYPFNGLFOGCOORDDPROC, glFogCoordd); INIT_PROC_POINTER(MYPFNGLFOGCOORDDVPROC, glFogCoorddv); INIT_PROC_POINTER(MYPFNGLFOGCOORDPOINTERPROC, glFogCoordPointer); INIT_PROC_POINTER(MYPFNGLMULTIDRAWARRAYSPROC, glMultiDrawArrays); INIT_PROC_POINTER(MYPFNGLMULTIDRAWELEMENTSPROC, glMultiDrawElements); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERFPROC, glPointParameterf); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERFVPROC, glPointParameterfv); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERIPROC, glPointParameteri); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERIVPROC, glPointParameteriv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BPROC, glSecondaryColor3b); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BVPROC, glSecondaryColor3bv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DPROC, glSecondaryColor3d); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DVPROC, glSecondaryColor3dv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FPROC, glSecondaryColor3f); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FVPROC, glSecondaryColor3fv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IPROC, glSecondaryColor3i); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IVPROC, glSecondaryColor3iv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SPROC, glSecondaryColor3s); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SVPROC, glSecondaryColor3sv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBPROC, glSecondaryColor3ub); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBVPROC, glSecondaryColor3ubv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIPROC, glSecondaryColor3ui); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIVPROC, glSecondaryColor3uiv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USPROC, glSecondaryColor3us); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USVPROC, glSecondaryColor3usv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLORPOINTERPROC, glSecondaryColorPointer); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2DPROC, glWindowPos2d); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2DVPROC, glWindowPos2dv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2FPROC, glWindowPos2f); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2FVPROC, glWindowPos2fv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2IPROC, glWindowPos2i); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2IVPROC, glWindowPos2iv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2SPROC, glWindowPos2s); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2SVPROC, glWindowPos2sv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3DPROC, glWindowPos3d); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3DVPROC, glWindowPos3dv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3FPROC, glWindowPos3f); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3FVPROC, glWindowPos3fv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3IPROC, glWindowPos3i); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3IVPROC, glWindowPos3iv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3SPROC, glWindowPos3s); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3SVPROC, glWindowPos3sv); return initExtension("GL_VERSION_1_3"); } #endif // GL_VERSION_1_4 #ifdef GL_VERSION_1_5 else if (0 == strcmp(extension, "GL_VERSION_1_5")) { INIT_PROC_POINTER(MYPFNGLGENQUERIESPROC, glGenQueries); INIT_PROC_POINTER(MYPFNGLDELETEQUERIESPROC, glDeleteQueries); INIT_PROC_POINTER(MYPFNGLISQUERYPROC, glIsQuery); INIT_PROC_POINTER(MYPFNGLBEGINQUERYPROC, glBeginQuery); INIT_PROC_POINTER(MYPFNGLENDQUERYPROC, glEndQuery); INIT_PROC_POINTER(MYPFNGLGETQUERYIVPROC, glGetQueryiv); INIT_PROC_POINTER(MYPFNGLGETQUERYOBJECTIVPROC, glGetQueryObjectiv); INIT_PROC_POINTER(MYPFNGLGETQUERYOBJECTUIVPROC, glGetQueryObjectuiv); INIT_PROC_POINTER(MYPFNGLBINDBUFFERPROC, glBindBuffer); INIT_PROC_POINTER(MYPFNGLDELETEBUFFERSPROC, glDeleteBuffers); INIT_PROC_POINTER(MYPFNGLGENBUFFERSPROC, glGenBuffers); INIT_PROC_POINTER(MYPFNGLISBUFFERPROC, glIsBuffer); INIT_PROC_POINTER(MYPFNGLBUFFERDATAPROC, glBufferData); INIT_PROC_POINTER(MYPFNGLBUFFERSUBDATAPROC, glBufferSubData); INIT_PROC_POINTER(MYPFNGLGETBUFFERSUBDATAPROC, glGetBufferSubData); INIT_PROC_POINTER(MYPFNGLMAPBUFFERPROC, glMapBuffer); INIT_PROC_POINTER(MYPFNGLUNMAPBUFFERPROC, glUnmapBuffer); INIT_PROC_POINTER(MYPFNGLGETBUFFERPARAMETERIVPROC, glGetBufferParameteriv); INIT_PROC_POINTER(MYPFNGLGETBUFFERPOINTERVPROC, glGetBufferPointerv); return initExtension("GL_VERSION_1_4"); } #endif // GL_VERSION_1_5 #ifdef GL_VERSION_2_0 else if (0 == strcmp(extension, "GL_VERSION_2_0")) { INIT_PROC_POINTER(MYPFNGLBLENDEQUATIONSEPARATEPROC,glBlendEquationSeparate); INIT_PROC_POINTER(MYPFNGLDRAWBUFFERSPROC,glDrawBuffers); INIT_PROC_POINTER(MYPFNGLSTENCILOPSEPARATEPROC,glStencilOpSeparate); INIT_PROC_POINTER(MYPFNGLSTENCILFUNCSEPARATEPROC,glStencilFuncSeparate); INIT_PROC_POINTER(MYPFNGLSTENCILMASKSEPARATEPROC,glStencilMaskSeparate); INIT_PROC_POINTER(MYPFNGLATTACHSHADERPROC,glAttachShader); INIT_PROC_POINTER(MYPFNGLBINDATTRIBLOCATIONPROC,glBindAttribLocation); INIT_PROC_POINTER(MYPFNGLCOMPILESHADERPROC,glCompileShader); INIT_PROC_POINTER(MYPFNGLCREATEPROGRAMPROC,glCreateProgram); INIT_PROC_POINTER(MYPFNGLCREATESHADERPROC,glCreateShader); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMPROC,glDeleteProgram); INIT_PROC_POINTER(MYPFNGLDELETESHADERPROC,glDeleteShader); INIT_PROC_POINTER(MYPFNGLDETACHSHADERPROC,glDetachShader); INIT_PROC_POINTER(MYPFNGLDISABLEVERTEXATTRIBARRAYPROC,glDisableVertexAttribArray); INIT_PROC_POINTER(MYPFNGLENABLEVERTEXATTRIBARRAYPROC,glEnableVertexAttribArray); INIT_PROC_POINTER(MYPFNGLGETACTIVEATTRIBPROC,glGetActiveAttrib); INIT_PROC_POINTER(MYPFNGLGETACTIVEUNIFORMPROC,glGetActiveUniform); INIT_PROC_POINTER(MYPFNGLGETATTACHEDSHADERSPROC,glGetAttachedShaders); INIT_PROC_POINTER(MYPFNGLGETATTRIBLOCATIONPROC,glGetAttribLocation); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVPROC,glGetProgramiv); INIT_PROC_POINTER(MYPFNGLGETPROGRAMINFOLOGPROC,glGetProgramInfoLog); INIT_PROC_POINTER(MYPFNGLGETSHADERIVPROC,glGetShaderiv); INIT_PROC_POINTER(MYPFNGLGETSHADERINFOLOGPROC,glGetShaderInfoLog); INIT_PROC_POINTER(MYPFNGLGETSHADERSOURCEPROC,glGetShaderSource); INIT_PROC_POINTER(MYPFNGLGETUNIFORMLOCATIONPROC,glGetUniformLocation); INIT_PROC_POINTER(MYPFNGLGETUNIFORMFVPROC,glGetUniformfv); INIT_PROC_POINTER(MYPFNGLGETUNIFORMIVPROC,glGetUniformiv); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVPROC,glGetVertexAttribdv); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVPROC,glGetVertexAttribfv); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVPROC,glGetVertexAttribiv); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVPROC,glGetVertexAttribPointerv); INIT_PROC_POINTER(MYPFNGLISPROGRAMPROC,glIsProgram); INIT_PROC_POINTER(MYPFNGLISSHADERPROC,glIsShader); INIT_PROC_POINTER(MYPFNGLLINKPROGRAMPROC,glLinkProgram); INIT_PROC_POINTER(MYPFNGLSHADERSOURCEPROC,glShaderSource); INIT_PROC_POINTER(MYPFNGLUSEPROGRAMPROC,glUseProgram); INIT_PROC_POINTER(MYPFNGLUNIFORM1FPROC,glUniform1f); INIT_PROC_POINTER(MYPFNGLUNIFORM2FPROC,glUniform2f); INIT_PROC_POINTER(MYPFNGLUNIFORM3FPROC,glUniform3f); INIT_PROC_POINTER(MYPFNGLUNIFORM4FPROC,glUniform4f); INIT_PROC_POINTER(MYPFNGLUNIFORM1IPROC,glUniform1i); INIT_PROC_POINTER(MYPFNGLUNIFORM2IPROC,glUniform2i); INIT_PROC_POINTER(MYPFNGLUNIFORM3IPROC,glUniform3i); INIT_PROC_POINTER(MYPFNGLUNIFORM4IPROC,glUniform4i); INIT_PROC_POINTER(MYPFNGLUNIFORM1FVPROC,glUniform1fv); INIT_PROC_POINTER(MYPFNGLUNIFORM2FVPROC,glUniform2fv); INIT_PROC_POINTER(MYPFNGLUNIFORM3FVPROC,glUniform3fv); INIT_PROC_POINTER(MYPFNGLUNIFORM4FVPROC,glUniform4fv); INIT_PROC_POINTER(MYPFNGLUNIFORM1IVPROC,glUniform1iv); INIT_PROC_POINTER(MYPFNGLUNIFORM2IVPROC,glUniform2iv); INIT_PROC_POINTER(MYPFNGLUNIFORM3IVPROC,glUniform3iv); INIT_PROC_POINTER(MYPFNGLUNIFORM4IVPROC,glUniform4iv); INIT_PROC_POINTER(MYPFNGLUNIFORMMATRIX2FVPROC,glUniformMatrix2fv); INIT_PROC_POINTER(MYPFNGLUNIFORMMATRIX3FVPROC,glUniformMatrix3fv); INIT_PROC_POINTER(MYPFNGLUNIFORMMATRIX4FVPROC,glUniformMatrix4fv); INIT_PROC_POINTER(MYPFNGLVALIDATEPROGRAMPROC,glValidateProgram); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DPROC,glVertexAttrib1d); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVPROC,glVertexAttrib1dv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FPROC,glVertexAttrib1f); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVPROC,glVertexAttrib1fv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SPROC,glVertexAttrib1s); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVPROC,glVertexAttrib1sv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DPROC,glVertexAttrib2d); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVPROC,glVertexAttrib2dv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FPROC,glVertexAttrib2f); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVPROC,glVertexAttrib2fv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SPROC,glVertexAttrib2s); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVPROC,glVertexAttrib2sv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DPROC,glVertexAttrib3d); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVPROC,glVertexAttrib3dv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FPROC,glVertexAttrib3f); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVPROC,glVertexAttrib3fv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SPROC,glVertexAttrib3s); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVPROC,glVertexAttrib3sv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NBVPROC,glVertexAttrib4Nbv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NIVPROC,glVertexAttrib4Niv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NSVPROC,glVertexAttrib4Nsv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBPROC,glVertexAttrib4Nub); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBVPROC,glVertexAttrib4Nubv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUIVPROC,glVertexAttrib4Nuiv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUSVPROC,glVertexAttrib4Nusv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4BVPROC,glVertexAttrib4bv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DPROC,glVertexAttrib4d); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVPROC,glVertexAttrib4dv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FPROC,glVertexAttrib4f); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVPROC,glVertexAttrib4fv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4IVPROC,glVertexAttrib4iv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SPROC,glVertexAttrib4s); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVPROC,glVertexAttrib4sv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVPROC,glVertexAttrib4ubv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UIVPROC,glVertexAttrib4uiv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4USVPROC,glVertexAttrib4usv); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERPROC,glVertexAttribPointer); return initExtension("GL_VERSION_1_5"); } #endif // GL_VERSION_2_0 #ifdef GL_EXT_paletted_texture else if (0 == strcmp(extension, "GL_EXT_paletted_texture")) { INIT_PROC_POINTER(MYPFNGLCOLORTABLEEXTPROC, glColorTableEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEEXTPROC, glGetColorTableEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC, glGetColorTableParameterivEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC, glGetColorTableParameterfvEXT); return true; } #endif // GL_EXT_paletted_texture #ifdef GL_ARB_multitexture else if (0 == strcmp(extension, "GL_ARB_multitexture")) { INIT_PROC_POINTER(MYPFNGLACTIVETEXTUREARBPROC, glActiveTextureARB); INIT_PROC_POINTER(MYPFNGLCLIENTACTIVETEXTUREARBPROC, glClientActiveTextureARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DARBPROC, glMultiTexCoord1dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DVARBPROC, glMultiTexCoord1dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FARBPROC, glMultiTexCoord1fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FVARBPROC, glMultiTexCoord1fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IARBPROC, glMultiTexCoord1iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IVARBPROC, glMultiTexCoord1ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SARBPROC, glMultiTexCoord1sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SVARBPROC, glMultiTexCoord1svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DARBPROC, glMultiTexCoord2dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DVARBPROC, glMultiTexCoord2dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FARBPROC, glMultiTexCoord2fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FVARBPROC, glMultiTexCoord2fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IARBPROC, glMultiTexCoord2iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IVARBPROC, glMultiTexCoord2ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SARBPROC, glMultiTexCoord2sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SVARBPROC, glMultiTexCoord2svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DARBPROC, glMultiTexCoord3dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DVARBPROC, glMultiTexCoord3dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FARBPROC, glMultiTexCoord3fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FVARBPROC, glMultiTexCoord3fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IARBPROC, glMultiTexCoord3iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IVARBPROC, glMultiTexCoord3ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SARBPROC, glMultiTexCoord3sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SVARBPROC, glMultiTexCoord3svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DARBPROC, glMultiTexCoord4dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DVARBPROC, glMultiTexCoord4dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FARBPROC, glMultiTexCoord4fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FVARBPROC, glMultiTexCoord4fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IARBPROC, glMultiTexCoord4iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IVARBPROC, glMultiTexCoord4ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SARBPROC, glMultiTexCoord4sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SVARBPROC, glMultiTexCoord4svARB); return true; } #endif // GL_ARB_multitexture #ifdef GL_SGI_texture_color_table else if (0 == strcmp(extension, "GL_SGI_texture_color_table")) { return true; } #endif // GL_SGI_texture_color_table #ifdef GL_SGI_color_table else if (0 == strcmp(extension, "GL_SGI_color_table")) { INIT_PROC_POINTER(MYPFNGLCOLORTABLESGIPROC, glColorTableSGI); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERFVSGIPROC, glColorTableParameterfvSGI); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERIVSGIPROC, glColorTableParameterivSGI); INIT_PROC_POINTER(MYPFNGLCOPYCOLORTABLESGIPROC, glCopyColorTableSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLESGIPROC, glGetColorTableSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC, glGetColorTableParameterfvSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC, glGetColorTableParameterivSGI); return true; } #endif // GL_SGI_color_table #ifdef GL_SGIS_texture_edge_clamp else if (0 == strcmp(extension, "GL_SGIS_texture_edge_clamp")) { return true; } #endif // GL_SGIS_texture_edge_clamp #ifdef GL_EXT_texture3D else if (0 == strcmp(extension, "GL_EXT_texture3D")) { INIT_PROC_POINTER(MYPFNGLTEXIMAGE3DEXTPROC, glTexImage3DEXT); INIT_PROC_POINTER(MYPFNGLTEXSUBIMAGE3DEXTPROC, glTexSubImage3DEXT); return true; } #endif // GL_EXT_texture3D #ifdef GL_NV_fragment_program else if (0 == strcmp(extension, "GL_NV_fragment_program")) { INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC, glProgramNamedParameter4fNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC, glProgramNamedParameter4dNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC, glProgramNamedParameter4fvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC, glProgramNamedParameter4dvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC, glGetProgramNamedParameterfvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC, glGetProgramNamedParameterdvNV); return true; } #endif // GL_NV_fragment_program #ifdef GL_NV_vertex_program else if (0 == strcmp(extension, "GL_NV_vertex_program")) { INIT_PROC_POINTER(MYPFNGLAREPROGRAMSRESIDENTNVPROC, glAreProgramsResidentNV); INIT_PROC_POINTER(MYPFNGLBINDPROGRAMNVPROC, glBindProgramNV); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMSNVPROC, glDeleteProgramsNV); INIT_PROC_POINTER(MYPFNGLEXECUTEPROGRAMNVPROC, glExecuteProgramNV); INIT_PROC_POINTER(MYPFNGLGENPROGRAMSNVPROC, glGenProgramsNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMPARAMETERDVNVPROC, glGetProgramParameterdvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMPARAMETERFVNVPROC, glGetProgramParameterfvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVNVPROC, glGetProgramivNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMSTRINGNVPROC, glGetProgramStringNV); INIT_PROC_POINTER(MYPFNGLGETTRACKMATRIXIVNVPROC, glGetTrackMatrixivNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVNVPROC, glGetVertexAttribdvNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVNVPROC, glGetVertexAttribfvNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVNVPROC, glGetVertexAttribivNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC, glGetVertexAttribPointervNV); INIT_PROC_POINTER(MYPFNGLISPROGRAMNVPROC, glIsProgramNV); INIT_PROC_POINTER(MYPFNGLLOADPROGRAMNVPROC, glLoadProgramNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4DNVPROC, glProgramParameter4dNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4DVNVPROC, glProgramParameter4dvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4FNVPROC, glProgramParameter4fNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4FVNVPROC, glProgramParameter4fvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETERS4DVNVPROC, glProgramParameters4dvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETERS4FVNVPROC, glProgramParameters4fvNV); INIT_PROC_POINTER(MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC, glRequestResidentProgramsNV); INIT_PROC_POINTER(MYPFNGLTRACKMATRIXNVPROC, glTrackMatrixNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERNVPROC, glVertexAttribPointerNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DNVPROC, glVertexAttrib1dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVNVPROC, glVertexAttrib1dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FNVPROC, glVertexAttrib1fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVNVPROC, glVertexAttrib1fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SNVPROC, glVertexAttrib1sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVNVPROC, glVertexAttrib1svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DNVPROC, glVertexAttrib2dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVNVPROC, glVertexAttrib2dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FNVPROC, glVertexAttrib2fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVNVPROC, glVertexAttrib2fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SNVPROC, glVertexAttrib2sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVNVPROC, glVertexAttrib2svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DNVPROC, glVertexAttrib3dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVNVPROC, glVertexAttrib3dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FNVPROC, glVertexAttrib3fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVNVPROC, glVertexAttrib3fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SNVPROC, glVertexAttrib3sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVNVPROC, glVertexAttrib3svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DNVPROC, glVertexAttrib4dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVNVPROC, glVertexAttrib4dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FNVPROC, glVertexAttrib4fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVNVPROC, glVertexAttrib4fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SNVPROC, glVertexAttrib4sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVNVPROC, glVertexAttrib4svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBNVPROC, glVertexAttrib4ubNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVNVPROC, glVertexAttrib4ubvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1DVNVPROC, glVertexAttribs1dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1FVNVPROC, glVertexAttribs1fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1SVNVPROC, glVertexAttribs1svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2DVNVPROC, glVertexAttribs2dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2FVNVPROC, glVertexAttribs2fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2SVNVPROC, glVertexAttribs2svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3DVNVPROC, glVertexAttribs3dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3FVNVPROC, glVertexAttribs3fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3SVNVPROC, glVertexAttribs3svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4DVNVPROC, glVertexAttribs4dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4FVNVPROC, glVertexAttribs4fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4SVNVPROC, glVertexAttribs4svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4UBVNVPROC, glVertexAttribs4ubvNV); return true; } #endif // GL_NV_vertex_program #ifdef GL_ARB_vertex_program else if (0 == strcmp(extension, "GL_ARB_vertex_program")) { INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DARBPROC, glVertexAttrib1dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVARBPROC, glVertexAttrib1dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FARBPROC, glVertexAttrib1fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVARBPROC, glVertexAttrib1fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SARBPROC, glVertexAttrib1sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVARBPROC, glVertexAttrib1svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DARBPROC, glVertexAttrib2dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVARBPROC, glVertexAttrib2dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FARBPROC, glVertexAttrib2fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVARBPROC, glVertexAttrib2fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SARBPROC, glVertexAttrib2sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVARBPROC, glVertexAttrib2svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DARBPROC, glVertexAttrib3dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVARBPROC, glVertexAttrib3dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FARBPROC, glVertexAttrib3fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVARBPROC, glVertexAttrib3fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SARBPROC, glVertexAttrib3sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVARBPROC, glVertexAttrib3svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NBVARBPROC, glVertexAttrib4NbvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NIVARBPROC, glVertexAttrib4NivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NSVARBPROC, glVertexAttrib4NsvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBARBPROC, glVertexAttrib4NubARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBVARBPROC, glVertexAttrib4NubvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUIVARBPROC, glVertexAttrib4NuivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUSVARBPROC, glVertexAttrib4NusvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4BVARBPROC, glVertexAttrib4bvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DARBPROC, glVertexAttrib4dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVARBPROC, glVertexAttrib4dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FARBPROC, glVertexAttrib4fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVARBPROC, glVertexAttrib4fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4IVARBPROC, glVertexAttrib4ivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SARBPROC, glVertexAttrib4sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVARBPROC, glVertexAttrib4svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVARBPROC, glVertexAttrib4ubvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UIVARBPROC, glVertexAttrib4uivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4USVARBPROC, glVertexAttrib4usvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointerARB); INIT_PROC_POINTER(MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArrayARB); INIT_PROC_POINTER(MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArrayARB); INIT_PROC_POINTER(MYPFNGLPROGRAMSTRINGARBPROC, glProgramStringARB); INIT_PROC_POINTER(MYPFNGLBINDPROGRAMARBPROC, glBindProgramARB); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMSARBPROC, glDeleteProgramsARB); INIT_PROC_POINTER(MYPFNGLGENPROGRAMSARBPROC, glGenProgramsARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4DARBPROC, glProgramEnvParameter4dARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4DVARBPROC, glProgramEnvParameter4dvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4FARBPROC, glProgramEnvParameter4fARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4FVARBPROC, glProgramEnvParameter4fvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC, glProgramLocalParameter4dARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC, glProgramLocalParameter4dvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC, glProgramLocalParameter4fARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC, glProgramLocalParameter4fvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC, glGetProgramEnvParameterdvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC, glGetProgramEnvParameterfvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC, glGetProgramLocalParameterdvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC, glGetProgramLocalParameterfvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVARBPROC, glGetProgramivARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMSTRINGARBPROC, glGetProgramStringARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVARBPROC, glGetVertexAttribdvARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVARBPROC, glGetVertexAttribfvARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVARBPROC, glGetVertexAttribivARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC, glGetVertexAttribPointervARB); INIT_PROC_POINTER(MYPFNGLISPROGRAMARBPROC, glIsProgramARB); return true; } #endif // GL_ARB_vertex_program #ifdef GL_ARB_fragment_program else if (0 == strcmp(extension, "GL_ARB_fragment_program")) { return true; } #endif // GL_ARB_fragment_program // EXT_secondary_color #ifdef GL_EXT_secondary_color else if (0 == strcmp(extension, "GL_EXT_secondary_color")) { INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BEXTPROC, glSecondaryColor3bEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BVEXTPROC, glSecondaryColor3bvEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DEXTPROC, glSecondaryColor3dEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DVEXTPROC, glSecondaryColor3dvEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FEXTPROC, glSecondaryColor3fEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FVEXTPROC, glSecondaryColor3fvEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IEXTPROC, glSecondaryColor3iEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IVEXTPROC, glSecondaryColor3ivEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SEXTPROC, glSecondaryColor3sEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SVEXTPROC, glSecondaryColor3svEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBEXTPROC, glSecondaryColor3ubEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBVEXTPROC, glSecondaryColor3ubvEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIEXTPROC, glSecondaryColor3uiEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIVEXTPROC, glSecondaryColor3uivEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USEXTPROC, glSecondaryColor3usEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USVEXTPROC, glSecondaryColor3usvEXT); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLORPOINTEREXTPROC, glSecondaryColorPointerEXT); return true; } #endif //GL_EXT_secondary_color // // ARB_vertex_buffer_object #ifdef GL_ARB_vertex_buffer_object else if (0 == strcmp(extension, "GL_ARB_vertex_buffer_object")) { INIT_PROC_POINTER(MYPFNGLBINDBUFFERARBPROC, glBindBufferARB); INIT_PROC_POINTER(MYPFNGLDELETEBUFFERSARBPROC, glDeleteBuffersARB); INIT_PROC_POINTER(MYPFNGLGENBUFFERSARBPROC, glGenBuffersARB); INIT_PROC_POINTER(MYPFNGLISBUFFERARBPROC, glIsBufferARB); INIT_PROC_POINTER(MYPFNGLBUFFERDATAARBPROC, glBufferDataARB); INIT_PROC_POINTER(MYPFNGLBUFFERSUBDATAARBPROC, glBufferSubDataARB); INIT_PROC_POINTER(MYPFNGLGETBUFFERSUBDATAARBPROC, glGetBufferSubDataARB); INIT_PROC_POINTER(MYPFNGLMAPBUFFERARBPROC, glMapBufferARB); INIT_PROC_POINTER(MYPFNGLUNMAPBUFFERARBPROC, glUnmapBufferARB); INIT_PROC_POINTER(MYPFNGLGETBUFFERPARAMETERIVARBPROC, glGetBufferParameterivARB); INIT_PROC_POINTER(MYPFNGLGETBUFFERPOINTERVARBPROC, glGetBufferPointervARB); return true; } #endif //GL_ARB_vertex_buffer_object /// WGL extensions follows #if defined(WIN32) #ifdef WGL_ARB_pixel_format else if (0 == strcmp(extension, "WGL_ARB_pixel_format")) { INIT_WGL_PROC_POINTER(MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB); INIT_WGL_PROC_POINTER(MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC, wglGetPixelFormatAttribfvARB); INIT_WGL_PROC_POINTER(MYPFNWGLCHOOSEPIXELFORMATARBPROC, wglChoosePixelFormatARB); return true; } #endif // WGL_ARB_pixel_format #ifdef WGL_ARB_pbuffer else if (0 == strcmp(extension, "WGL_ARB_pbuffer")) { INIT_WGL_PROC_POINTER(MYPFNWGLCREATEPBUFFERARBPROC, wglCreatePbufferARB); INIT_WGL_PROC_POINTER(MYPFNWGLGETPBUFFERDCARBPROC, wglGetPbufferDCARB); INIT_WGL_PROC_POINTER(MYPFNWGLRELEASEPBUFFERDCARBPROC, wglReleasePbufferDCARB); INIT_WGL_PROC_POINTER(MYPFNWGLDESTROYPBUFFERARBPROC, wglDestroyPbufferARB); INIT_WGL_PROC_POINTER(MYPFNWGLQUERYPBUFFERARBPROC, wglQueryPbufferARB); return true; } #endif // WGL_ARB_pbuffer #ifdef WGL_ARB_render_texture else if (0 == strcmp(extension, "WGL_ARB_render_texture")) { INIT_WGL_PROC_POINTER(MYPFNWGLBINDTEXIMAGEARBPROC, wglBindTexImageARB); INIT_WGL_PROC_POINTER(MYPFNWGLRELEASETEXIMAGEARBPROC, wglReleaseTexImageARB); INIT_WGL_PROC_POINTER(MYPFNWGLSETPBUFFERATTRIBARBPROC, wglSetPbufferAttribARB); return true; } #endif // WGL_ARB_render_texture #ifdef WGL_ARB_extensions_string else if (0 == strcmp(extension, "WGL_ARB_extensions_string")) { INIT_WGL_PROC_POINTER(MYPFNWGLGETEXTENSIONSSTRINGARBPROC, wglGetExtensionsStringARB); return true; } #endif // WGL_ARB_extensions_string #endif // defined(WIN32) else if(0 == strcmp(extension, "GL_ARB_fragment_program_shadow")) { return true; } else if(0 == strcmp(extension, "GL_ARB_depth_texture")) { return true; } else if(0 == strcmp(extension, "GL_ARB_shadow")) { return true; } else if(0 == strcmp(extension, "GL_EXT_texture_rectangle")) { return true; } else if(0 == strcmp(extension, "GL_NV_texture_rectangle")) { return true; } else { return false; } } void MyExtensions::initPointersToZero() { // OpenGL version 1.2 glBlendColor = 0; glBlendEquation = 0; glDrawRangeElements = 0; glColorTable = 0; glColorTableParameterfv = 0; glColorTableParameteriv = 0; glCopyColorTable = 0; glGetColorTable = 0; glGetColorTableParameterfv = 0; glGetColorTableParameteriv = 0; glColorSubTable = 0; glCopyColorSubTable = 0; glConvolutionFilter1D = 0; glConvolutionFilter2D = 0; glConvolutionParameterf = 0; glConvolutionParameterfv = 0; glConvolutionParameteri = 0; glConvolutionParameteriv = 0; glCopyConvolutionFilter1D = 0; glCopyConvolutionFilter2D = 0; glGetConvolutionFilter = 0; glGetConvolutionParameterfv = 0; glGetConvolutionParameteriv = 0; glGetSeparableFilter = 0; glSeparableFilter2D = 0; glGetHistogram = 0; glGetHistogramParameterfv = 0; glGetHistogramParameteriv = 0; glGetMinmax = 0; glGetMinmaxParameterfv = 0; glGetMinmaxParameteriv = 0; glHistogram = 0; glMinmax = 0; glResetHistogram = 0; glResetMinmax = 0; glTexImage3D = 0; glTexSubImage3D = 0; glCopyTexSubImage3D = 0; // End OpenGL version 1.2 // OpenGL version 1.3 glActiveTexture = 0; glClientActiveTexture = 0; glMultiTexCoord1d = 0; glMultiTexCoord1dv = 0; glMultiTexCoord1f = 0; glMultiTexCoord1fv = 0; glMultiTexCoord1i = 0; glMultiTexCoord1iv = 0; glMultiTexCoord1s = 0; glMultiTexCoord1sv = 0; glMultiTexCoord2d = 0; glMultiTexCoord2dv = 0; glMultiTexCoord2f = 0; glMultiTexCoord2fv = 0; glMultiTexCoord2i = 0; glMultiTexCoord2iv = 0; glMultiTexCoord2s = 0; glMultiTexCoord2sv = 0; glMultiTexCoord3d = 0; glMultiTexCoord3dv = 0; glMultiTexCoord3f = 0; glMultiTexCoord3fv = 0; glMultiTexCoord3i = 0; glMultiTexCoord3iv = 0; glMultiTexCoord3s = 0; glMultiTexCoord3sv = 0; glMultiTexCoord4d = 0; glMultiTexCoord4dv = 0; glMultiTexCoord4f = 0; glMultiTexCoord4fv = 0; glMultiTexCoord4i = 0; glMultiTexCoord4iv = 0; glMultiTexCoord4s = 0; glMultiTexCoord4sv = 0; glLoadTransposeMatrixf = 0; glLoadTransposeMatrixd = 0; glMultTransposeMatrixf = 0; glMultTransposeMatrixd = 0; glSampleCoverage = 0; glCompressedTexImage3D = 0; glCompressedTexImage2D = 0; glCompressedTexImage1D = 0; glCompressedTexSubImage3D = 0; glCompressedTexSubImage2D = 0; glCompressedTexSubImage1D = 0; glGetCompressedTexImage = 0; // End OpenGL version 1.3 // OpenGL version 1.4 glBlendFuncSeparate = 0; glFogCoordf = 0; glFogCoordfv = 0; glFogCoordd = 0; glFogCoorddv = 0; glFogCoordPointer = 0; glMultiDrawArrays = 0; glMultiDrawElements = 0; glPointParameterf = 0; glPointParameterfv = 0; glPointParameteri = 0; glPointParameteriv = 0; glSecondaryColor3b = 0; glSecondaryColor3bv = 0; glSecondaryColor3d = 0; glSecondaryColor3dv = 0; glSecondaryColor3f = 0; glSecondaryColor3fv = 0; glSecondaryColor3i = 0; glSecondaryColor3iv = 0; glSecondaryColor3s = 0; glSecondaryColor3sv = 0; glSecondaryColor3ub = 0; glSecondaryColor3ubv = 0; glSecondaryColor3ui = 0; glSecondaryColor3uiv = 0; glSecondaryColor3us = 0; glSecondaryColor3usv = 0; glSecondaryColorPointer = 0; glWindowPos2d = 0; glWindowPos2dv = 0; glWindowPos2f = 0; glWindowPos2fv = 0; glWindowPos2i = 0; glWindowPos2iv = 0; glWindowPos2s = 0; glWindowPos2sv = 0; glWindowPos3d = 0; glWindowPos3dv = 0; glWindowPos3f = 0; glWindowPos3fv = 0; glWindowPos3i = 0; glWindowPos3iv = 0; glWindowPos3s = 0; glWindowPos3sv = 0; // End OpenGL version 1.4 // OpenGL version 1.5 glGenQueries= 0; glDeleteQueries= 0; glIsQuery= 0; glBeginQuery= 0; glEndQuery= 0; glGetQueryiv= 0; glGetQueryObjectiv= 0; glGetQueryObjectuiv= 0; glBindBuffer= 0; glDeleteBuffers= 0; glGenBuffers= 0; glIsBuffer= 0; glBufferData= 0; glBufferSubData= 0; glGetBufferSubData= 0; glMapBuffer= 0; glUnmapBuffer= 0; glGetBufferParameteriv= 0; glGetBufferPointerv= 0; // End OpenGL version 1.5 // OpenGL version 2.0 glBlendEquationSeparate = 0; glDrawBuffers = 0; glStencilOpSeparate = 0; glStencilFuncSeparate = 0; glStencilMaskSeparate = 0; glAttachShader = 0; glBindAttribLocation = 0; glCompileShader = 0; glCreateProgram = 0; glCreateShader = 0; glDeleteProgram = 0; glDeleteShader = 0; glDetachShader = 0; glDisableVertexAttribArray = 0; glEnableVertexAttribArray = 0; glGetActiveAttrib = 0; glGetActiveUniform = 0; glGetAttachedShaders = 0; glGetAttribLocation = 0; glGetProgramiv = 0; glGetProgramInfoLog = 0; glGetShaderiv = 0; glGetShaderInfoLog = 0; glGetShaderSource = 0; glGetUniformLocation = 0; glGetUniformfv = 0; glGetUniformiv = 0; glGetVertexAttribdv = 0; glGetVertexAttribfv = 0; glGetVertexAttribiv = 0; glGetVertexAttribPointerv = 0; glIsProgram = 0; glIsShader = 0; glLinkProgram = 0; glShaderSource = 0; glUseProgram = 0; glUniform1f = 0; glUniform2f = 0; glUniform3f = 0; glUniform4f = 0; glUniform1i = 0; glUniform2i = 0; glUniform3i = 0; glUniform4i = 0; glUniform1fv = 0; glUniform2fv = 0; glUniform3fv = 0; glUniform4fv = 0; glUniform1iv = 0; glUniform2iv = 0; glUniform3iv = 0; glUniform4iv = 0; glUniformMatrix2fv = 0; glUniformMatrix3fv = 0; glUniformMatrix4fv = 0; glValidateProgram = 0; glVertexAttrib1d = 0; glVertexAttrib1dv = 0; glVertexAttrib1f = 0; glVertexAttrib1fv = 0; glVertexAttrib1s = 0; glVertexAttrib1sv = 0; glVertexAttrib2d = 0; glVertexAttrib2dv = 0; glVertexAttrib2f = 0; glVertexAttrib2fv = 0; glVertexAttrib2s = 0; glVertexAttrib2sv = 0; glVertexAttrib3d = 0; glVertexAttrib3dv = 0; glVertexAttrib3f = 0; glVertexAttrib3fv = 0; glVertexAttrib3s = 0; glVertexAttrib3sv = 0; glVertexAttrib4Nbv = 0; glVertexAttrib4Niv = 0; glVertexAttrib4Nsv = 0; glVertexAttrib4Nub = 0; glVertexAttrib4Nubv = 0; glVertexAttrib4Nuiv = 0; glVertexAttrib4Nusv = 0; glVertexAttrib4bv = 0; glVertexAttrib4d = 0; glVertexAttrib4dv = 0; glVertexAttrib4f = 0; glVertexAttrib4fv = 0; glVertexAttrib4iv = 0; glVertexAttrib4s = 0; glVertexAttrib4sv = 0; glVertexAttrib4ubv = 0; glVertexAttrib4uiv = 0; glVertexAttrib4usv = 0; glVertexAttribPointer = 0; // End OpenGL version 2.0 // GL_EXT_paletted_texture glColorTableEXT = 0; glGetColorTableEXT = 0; glGetColorTableParameterivEXT = 0; glGetColorTableParameterfvEXT = 0; // End GL_EXT_paletted_texture // GL_ARB_multitexture glActiveTextureARB = 0; glClientActiveTextureARB = 0; glMultiTexCoord1dARB = 0; glMultiTexCoord1dvARB = 0; glMultiTexCoord1fARB = 0; glMultiTexCoord1fvARB = 0; glMultiTexCoord1iARB = 0; glMultiTexCoord1ivARB = 0; glMultiTexCoord1sARB = 0; glMultiTexCoord1svARB = 0; glMultiTexCoord2dARB = 0; glMultiTexCoord2dvARB = 0; glMultiTexCoord2fARB = 0; glMultiTexCoord2fvARB = 0; glMultiTexCoord2iARB = 0; glMultiTexCoord2ivARB = 0; glMultiTexCoord2sARB = 0; glMultiTexCoord2svARB = 0; glMultiTexCoord3dARB = 0; glMultiTexCoord3dvARB = 0; glMultiTexCoord3fARB = 0; glMultiTexCoord3fvARB = 0; glMultiTexCoord3iARB = 0; glMultiTexCoord3ivARB = 0; glMultiTexCoord3sARB = 0; glMultiTexCoord3svARB = 0; glMultiTexCoord4dARB = 0; glMultiTexCoord4dvARB = 0; glMultiTexCoord4fARB = 0; glMultiTexCoord4fvARB = 0; glMultiTexCoord4iARB = 0; glMultiTexCoord4ivARB = 0; glMultiTexCoord4sARB = 0; glMultiTexCoord4svARB = 0; // End GL_ARB_multitexture // GL_NV_fragment_program glProgramNamedParameter4fNV = 0; glProgramNamedParameter4dNV = 0; glProgramNamedParameter4fvNV = 0; glProgramNamedParameter4dvNV = 0; glGetProgramNamedParameterfvNV = 0; glGetProgramNamedParameterdvNV = 0; // End GL_NV_fragment_program // GL_NV_vertex_program glAreProgramsResidentNV = 0; glBindProgramNV = 0; glDeleteProgramsNV = 0; glExecuteProgramNV = 0; glGenProgramsNV = 0; glGetProgramParameterdvNV = 0; glGetProgramParameterfvNV = 0; glGetProgramivNV = 0; glGetProgramStringNV = 0; glGetTrackMatrixivNV = 0; glGetVertexAttribdvNV = 0; glGetVertexAttribfvNV = 0; glGetVertexAttribivNV = 0; glGetVertexAttribPointervNV = 0; glIsProgramNV = 0; glLoadProgramNV = 0; glProgramParameter4dNV = 0; glProgramParameter4dvNV = 0; glProgramParameter4fNV = 0; glProgramParameter4fvNV = 0; glProgramParameters4dvNV = 0; glProgramParameters4fvNV = 0; glRequestResidentProgramsNV = 0; glTrackMatrixNV = 0; glVertexAttribPointerNV = 0; glVertexAttrib1dNV = 0; glVertexAttrib1dvNV = 0; glVertexAttrib1fNV = 0; glVertexAttrib1fvNV = 0; glVertexAttrib1sNV = 0; glVertexAttrib1svNV = 0; glVertexAttrib2dNV = 0; glVertexAttrib2dvNV = 0; glVertexAttrib2fNV = 0; glVertexAttrib2fvNV = 0; glVertexAttrib2sNV = 0; glVertexAttrib2svNV = 0; glVertexAttrib3dNV = 0; glVertexAttrib3dvNV = 0; glVertexAttrib3fNV = 0; glVertexAttrib3fvNV = 0; glVertexAttrib3sNV = 0; glVertexAttrib3svNV = 0; glVertexAttrib4dNV = 0; glVertexAttrib4dvNV = 0; glVertexAttrib4fNV = 0; glVertexAttrib4fvNV = 0; glVertexAttrib4sNV = 0; glVertexAttrib4svNV = 0; glVertexAttrib4ubNV = 0; glVertexAttrib4ubvNV = 0; glVertexAttribs1dvNV = 0; glVertexAttribs1fvNV = 0; glVertexAttribs1svNV = 0; glVertexAttribs2dvNV = 0; glVertexAttribs2fvNV = 0; glVertexAttribs2svNV = 0; glVertexAttribs3dvNV = 0; glVertexAttribs3fvNV = 0; glVertexAttribs3svNV = 0; glVertexAttribs4dvNV = 0; glVertexAttribs4fvNV = 0; glVertexAttribs4svNV = 0; glVertexAttribs4ubvNV = 0; // End GL_NV_vertex_program // GL_ARB_vertex_program glVertexAttrib1dARB = 0; glVertexAttrib1dvARB = 0; glVertexAttrib1fARB = 0; glVertexAttrib1fvARB = 0; glVertexAttrib1sARB = 0; glVertexAttrib1svARB = 0; glVertexAttrib2dARB = 0; glVertexAttrib2dvARB = 0; glVertexAttrib2fARB = 0; glVertexAttrib2fvARB = 0; glVertexAttrib2sARB = 0; glVertexAttrib2svARB = 0; glVertexAttrib3dARB = 0; glVertexAttrib3dvARB = 0; glVertexAttrib3fARB = 0; glVertexAttrib3fvARB = 0; glVertexAttrib3sARB = 0; glVertexAttrib3svARB = 0; glVertexAttrib4NbvARB = 0; glVertexAttrib4NivARB = 0; glVertexAttrib4NsvARB = 0; glVertexAttrib4NubARB = 0; glVertexAttrib4NubvARB = 0; glVertexAttrib4NuivARB = 0; glVertexAttrib4NusvARB = 0; glVertexAttrib4bvARB = 0; glVertexAttrib4dARB = 0; glVertexAttrib4dvARB = 0; glVertexAttrib4fARB = 0; glVertexAttrib4fvARB = 0; glVertexAttrib4ivARB = 0; glVertexAttrib4sARB = 0; glVertexAttrib4svARB = 0; glVertexAttrib4ubvARB = 0; glVertexAttrib4uivARB = 0; glVertexAttrib4usvARB = 0; glVertexAttribPointerARB = 0; glEnableVertexAttribArrayARB = 0; glDisableVertexAttribArrayARB = 0; glProgramStringARB = 0; glBindProgramARB = 0; glDeleteProgramsARB = 0; glGenProgramsARB = 0; glProgramEnvParameter4dARB = 0; glProgramEnvParameter4dvARB = 0; glProgramEnvParameter4fARB = 0; glProgramEnvParameter4fvARB = 0; glProgramLocalParameter4dARB = 0; glProgramLocalParameter4dvARB = 0; glProgramLocalParameter4fARB = 0; glProgramLocalParameter4fvARB = 0; glGetProgramEnvParameterdvARB = 0; glGetProgramEnvParameterfvARB = 0; glGetProgramLocalParameterdvARB = 0; glGetProgramLocalParameterfvARB = 0; glGetProgramivARB = 0; glGetProgramStringARB = 0; glGetVertexAttribdvARB = 0; glGetVertexAttribfvARB = 0; glGetVertexAttribivARB = 0; glGetVertexAttribPointervARB = 0; glIsProgramARB = 0; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program // EXT_secondary_color glSecondaryColor3bEXT = 0; glSecondaryColor3bvEXT = 0; glSecondaryColor3dEXT = 0; glSecondaryColor3dvEXT = 0; glSecondaryColor3fEXT = 0; glSecondaryColor3fvEXT = 0; glSecondaryColor3iEXT = 0; glSecondaryColor3ivEXT = 0; glSecondaryColor3sEXT = 0; glSecondaryColor3svEXT = 0; glSecondaryColor3ubEXT = 0; glSecondaryColor3ubvEXT = 0; glSecondaryColor3uiEXT = 0; glSecondaryColor3uivEXT = 0; glSecondaryColor3usEXT = 0; glSecondaryColor3usvEXT = 0; glSecondaryColorPointerEXT = 0; // ARB_vertex_buffer_object glBindBufferARB = 0; glDeleteBuffersARB = 0; glGenBuffersARB = 0; glIsBufferARB = 0; glBufferDataARB = 0; glBufferSubDataARB = 0; glGetBufferSubDataARB = 0; glMapBufferARB = 0; glUnmapBufferARB = 0; glGetBufferParameterivARB = 0; glGetBufferPointervARB = 0; /// WGL extensions follows #if defined(WIN32) // WGL_ARB_pixel_format wglGetPixelFormatAttribivARB = 0; wglGetPixelFormatAttribfvARB = 0; wglChoosePixelFormatARB = 0; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer wglCreatePbufferARB = 0; wglGetPbufferDCARB = 0; wglReleasePbufferDCARB = 0; wglDestroyPbufferARB = 0; wglQueryPbufferARB = 0; // End WGL_ARB_pbuffer // WGL_ARB_render_texture wglBindTexImageARB = 0; wglReleaseTexImageARB = 0; wglSetPbufferAttribARB = 0; // End WGL_ARB_render_texture #endif // defined(WIN32) } const char* MyExtensions::EatWhiteSpace(const char* str) { for (; *str && (' ' == *str || '\t' == *str || '\n' == *str); str++); return str; } const char* MyExtensions::EatNonWhiteSpace(const char* str) { for (; *str && (' ' != *str && '\t' != *str && '\n' != *str); str++); return str; } const char* MyExtensions::getExtensionStringPrivate() { const char* normalExtensions = (const char*)glGetString(GL_EXTENSIONS); return normalExtensions; } const char* MyExtensions::getSystemExtensions() { // for now, we only do wgl extensions, not glx extensions #if defined(_WIN32) MYPFNWGLGETEXTENSIONSSTRINGARBPROC mywglGetExtensionsStringARB = 0; mywglGetExtensionsStringARB = (MYPFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB"); if(mywglGetExtensionsStringARB) { return mywglGetExtensionsStringARB(wglGetCurrentDC()); } else { return 0; } #else return 0; #endif } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/0000755000175000017500000000000012146213610026233 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshHelixRenderer.cpp0000644000175000017500000001206511006453060032317 0ustar debiandebian/* * A fallback replacement for the CG-Impostor system currently used to draw Helices. * This class will read the CG-encoded data and interpret it to draw Mesh instances. * * Note that per-pixel effects like those provided by the shader are not feasible with this * system. * * m_strange@mail.utexas.edu * * */ #include "MeshHelixRenderer.h" #include "../UsefulMath/Vector.h" #include "../UsefulMath/Matrix.h" #include GLUquadric* MeshHelixRenderer::m_Quadric = 0; const int MeshHelixRenderer::LEVEL_OF_DETAIL = 10; // constants that approximate Vinay's Helix drawing const GLfloat MeshHelixRenderer::HEIGHT_STEP = 0.03f; const GLfloat MeshHelixRenderer::STRIP_HEIGHT = 0.6; const GLfloat MeshHelixRenderer::HEIGHT_TO_COILS = 0.08f; void MeshHelixRenderer::DrawHelixBuffer(const ExpandableBuffer& position, const ExpandableBuffer& color, const ExpandableBuffer& textureCoord1, const ExpandableBuffer& textureCoord2) { // NOTE: leaked, but this is a singleton if(m_Quadric == 0) { m_Quadric = gluNewQuadric(); } // we extract the centers and radii from the encoding that is usually passed to the CG program const int numBalls = position.getNumObjects()/16; for(int i=0; i 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // HelixRenderer.cpp: implementation of the HelixRenderer class. // ////////////////////////////////////////////////////////////////////// #include "HelixRenderer.h" #include "GlobalCGContext.h" #include "Vector.h" #include "cgGLHelixVertexShader.h" #include "cgGLHelixFragmentShader.h" #include "MeshHelixRenderer.h" using CCVImposterRenderer::HelixRenderer; bool HelixRenderer::m_UseGLFallback = false; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// HelixRenderer::HelixRenderer( MyExtensions* extensions ) { initDefaults( extensions ); } void HelixRenderer::initDefaults( MyExtensions* extensions ) { m_Initialized = false; m_NumberOfHelices = 0; m_Extensions = extensions; m_VertexProgram = 0; m_FragmentProgram = 0; } HelixRenderer::~HelixRenderer() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); } void HelixRenderer::clear() { m_TextureCoord1.clearBuffer(); m_TextureCoord2.clearBuffer(); m_Color.clearBuffer(); m_Position.clearBuffer(); m_NumberOfHelices = 0; } int HelixRenderer::getNum() const { return m_NumberOfHelices; } void HelixRenderer::initRenderer( bool drawFunction ) { // without extensions we cannot operate at all if(!initExtensions()) { m_Initialized = false; fprintf(stderr, "ERROR: OpenGL extensions unavailable, update your graphics drivers.\n"); return; } // if FP30 isn't present we will use a different branch of every render method if(!initCG( drawFunction )) { fprintf(stderr, "WARNING: FP30 not found, falling back on GL Rendering.\n"); m_UseGLFallback = true; } m_Initialized = true; } void HelixRenderer::renderOnce() { // MESH RENDERING if(m_UseGLFallback) { MeshHelixRenderer::DrawHelixBuffer(m_Position, m_Color, m_TextureCoord1, m_TextureCoord2); } // CG RENDERING else { // rendering individually, not as a buffer because we need to send parameters which vary // per cylinder and there is no more space left in those arrays! int i; for( i=0; i<(int)m_NumberOfHelices; i++ ) { int index = 16*i; float radius = m_Position.get(index+2); CCVOpenGLMath::Vector ePoint = CCVOpenGLMath::Vector( m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), 1 ); CCVOpenGLMath::Vector begPoint = CCVOpenGLMath::Vector( m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), 1 ); CCVOpenGLMath::Vector axis = ePoint - begPoint; float helixLength = axis.norm(); axis = axis.normalize(); CCVOpenGLMath::Vector refVector(0,0,0,0); if (axis[0] < 0.1 && axis[0] > -0.1 ) { refVector[1] = axis[2]; refVector[2] = -1*axis[1]; } else { refVector[0] = axis[1]; refVector[1] = -1*axis[0]; } refVector = refVector.normalize(); CCVOpenGLMath::Vector helixDCsCrossRefVector = axis.cross( refVector ); helixDCsCrossRefVector = helixDCsCrossRefVector.normalize(); cgGLSetParameter3f(m_HelixDCs, axis[0], axis[1], axis[2]); cgGLSetParameter3f(m_RefVector, refVector[0], refVector[1], refVector[2]); // vector cgGLSetParameter3f(m_HelixDCsCrossRefVector, helixDCsCrossRefVector[0], helixDCsCrossRefVector[1], helixDCsCrossRefVector[2]); cgGLSetParameter1f(m_LengthOfHelix, helixLength); int c; for( c =0; c<2; c++ ) { cgGLSetParameter4f(m_EndPoint1, begPoint[0], begPoint[1], begPoint[2], radius); // point radius = radius * -1; glBegin( GL_QUADS ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); index += 4; m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); index += 4; m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); index += 4; m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); glEnd(); index -= 12; } } } } void HelixRenderer::renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors ) { if(m_UseGLFallback) { // bail if not initialized if (!m_Initialized) { return; } if (m_NumberOfHelices==0) { // we are done return; } glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT); // Set up for Stick rendering // cgGLEnableProfile(m_VertexProfile); // cgGLBindProgram(m_VertexProgram); // cgGLEnableProfile(m_FragmentProfile); // cgGLBindProgram(m_FragmentProgram); // glDisable(GL_CULL_FACE); // glDisable(GL_LIGHTING); // glEnable(GL_ALPHA_TEST); // glAlphaFunc(GL_GREATER, 0.5 ); // glEnable(GL_COLOR_SUM_ARB); glDisable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); // cgGLEnableTextureParameter(m_NormalMapParam); // cgGLEnableTextureParameter(m_DepthMapParam); // cgGLEnableTextureParameter(m_OpacityMapParam); m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); // cgGLSetParameter4f(m_MainColorParam, 0.7f, 0.7f, 0.7f, 1.0f); // gray if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; iglSecondaryColor3fEXT(0.,0.,1.); cgGLSetParameter4f(m_MainColorParam, 0.7f, 0.7f, 0.7f, 1.0f); // gray if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; icalculateCylinderNormalMap(512); m_TextureDepthMap = new Texture(); m_TextureDepthMap->calculateCylinderDepthMap(512); m_TextureOpacityMap = new Texture(); m_TextureOpacityMap->calculateHelixOpacityMap(512, 512); cgGLSetTextureParameter(m_NormalMapParam, m_TextureNormalMap->getTextureID()); cgGLSetTextureParameter(m_DepthMapParam, m_TextureDepthMap->getTextureID()); cgGLSetTextureParameter(m_OpacityMapParam, m_TextureOpacityMap->getTextureID()); return true; } bool HelixRenderer::initExtensions() { return true; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/PlainSphereRenderer.h0000644000175000017500000000546211006452675032326 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // PlainSphereRenderer.h: interface for the PlainSphereRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_PLAINSPHERERENDERER_H__EADD46E7_06F6_4BEF_B26C_21081B2E64CC__INCLUDED_) #define AFX_PLAINSPHERERENDERER_H__EADD46E7_06F6_4BEF_B26C_21081B2E64CC__INCLUDED_ #include namespace CCVImposterRenderer { class Texture; class PlainSphereRenderer { public: PlainSphereRenderer(); virtual ~PlainSphereRenderer(); bool bindProgramAndParams(); bool unbindProgramAndParams(); bool initCG(); bool loadProgram(); void bindMatrices(); protected: CGprofile m_VertexProfile; CGprofile m_FragmentProfile; CGprogram m_VertexProgram; CGprogram m_FragmentProgram; CGparameter m_PositionParam; CGparameter m_ColorParam; CGparameter m_ModelViewITParam; CGparameter m_ModelViewInverseParam; CGparameter m_ModelViewProjParam; CGparameter m_ProjParam; CGparameter m_MainColorParam; CGparameter m_NormalMapParam; CGparameter m_DepthMapParam; Texture* m_TextureNormalMap; Texture* m_TextureDepthMap; }; }; #endif // !defined(AFX_PLAINSPHERERENDERER_H__EADD46E7_06F6_4BEF_B26C_21081B2E64CC__INCLUDED_) ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLFragmentFunctionShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLFragmentFunctionS0000644000175000017500000001015611006452675032324 0ustar debiandebianconst char cgGLFragmentFunctionShader[] = "// this is the fragment program\n" "\n" "/*struct inputs\n" "{\n" " float4 color : COLOR0;\n" " float4 color1 : COLOR1;\n" " //float4 texcoord : TEXCOORD0;\n" " //float4 texcoord1 : TEXCOORD1;\n" "};*/\n" "\n" "struct inputs\n" "{\n" " float4 HPOS : POSITION;\n" " float4 texcoord : TEXCOORD0;\n" " float4 texcoord1 : TEXCOORD1;\n" " float4 texcoord2 : TEXCOORD2;\n" " float4 texcoord3 : TEXCOORD3; // duplicate of HPOS to read it\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float3 expand(float3 vector)\n" "{\n" " return 2.0 * (vector - 0.5);\n" "}\n" "\n" "// register combiner vector normalization function\n" "float3 normalize(float3 vector)\n" "{\n" " float3 VdotV = dot(expand(vector), expand(vector));\n" " return (1-saturate(VdotV)) * (vector-0.5) + expand(vector);\n" "}\n" "\n" "float3 interpolateColor( float3 color1, float3 color2, float left, float right, float val )\n" "{\n" " float t = (val - left ) / ( right - left );\n" " return (1-t)*color1 + t*color2;\n" "}\n" "\n" "float4 main(inputs IN, out float depth: DEPTH,\n" " uniform float4 maincolor,\n" " uniform sampler2D normalmap,\n" " uniform sampler2D depthmap,\n" " uniform sampler3D functionmap,\n" " uniform float4x4 ModelViewProjInverse,\n" " uniform float3 minExtent,\n" " uniform float3 maxExtent\n" " ) : COLOR\n" "{\n" " // calculate depth\n" " float3 depthVal = tex2D(depthmap, IN.texcoord.xy).rgb;\n" " float z = dot(IN.texcoord1.xyz, depthVal);\n" " float w = dot(IN.texcoord2.xyz, depthVal);\n" " depth = (z / w);//*0.5+0.5; \n" "\n" " float mydepth = depth-0.5;\n" " mydepth = mydepth*2.0;\n" " // get object pos to look up into texture\n" " float4 ndcPos = float4( IN.texcoord3.x, IN.texcoord3.y, mydepth, 1.0 );\n" " //float4 ndcPos = IN.texcoord3;\n" " float4 objectPos = mul(ModelViewProjInverse,ndcPos);\n" "\n" " // compress object pos into unit cube\n" " float unitx = (objectPos.x - minExtent[0]) / (maxExtent[0] - minExtent[0]);\n" " float unity = (objectPos.y - minExtent[1]) / (maxExtent[1] - minExtent[1]);\n" " float unitz = (objectPos.z - minExtent[2]) / (maxExtent[2] - minExtent[2]);\n" " \n" " // do a color map lookup, but now just do something ....\n" " float4 dens = tex3D( functionmap, float3(unitx, unity, unitz));\n" "\n" " float3 surfaceColor;\n" "\n" " if( dens.r >= 0 && dens.r < 0.46 )\n" " {\n" " surfaceColor = interpolateColor( float3(0.5,0,0), float3(1,0,0), 0, 0.46, dens.r );\n" " }\n" " if( dens.r >= 0.46 && dens.r < 0.5 )\n" " {\n" " surfaceColor = interpolateColor( float3(1,0,0), float3(0,0,0), 0.46, 0.5, dens.r );\n" " }\n" " if( dens.r >= 0.5 && dens.r < 0.529 )\n" " {\n" " surfaceColor = interpolateColor( float3(0,0,0), float3(0,1,0), 0.5, 0.529, dens.r );\n" " }\n" " if( dens.r >= 0.529 && dens.r <= 1.0 )\n" " {\n" " surfaceColor = interpolateColor( float3(0,1,0), float3(0,0.5,0), 0.529, 1.0, dens.r );\n" " } \n" " \n" " //float3 normal = (tex2D(normalmap, IN.texcoord1.xy)).rgb;\n" " float4 normal = 2.0 * (tex2D(normalmap, IN.texcoord.xy) - 0.5);\n" " \n" " //IN.secondarycolor.rgb = 2.0*(IN.secondarycolor.rgb-0.5);\n" " IN.secondarycolor.rgb = normalize(IN.secondarycolor.rgb);\n" "\n" " float3 NdotL = dot(normal.rgb, IN.secondarycolor);\n" " // instead of using input color, use the newly computed surface color\n" " //float3 color = IN.primarycolor.rgb*(saturate(NdotL) + IN.primarycolor.w);\n" " float3 color = surfaceColor.rgb*(saturate(NdotL) + IN.primarycolor.w);\n" "\n" " // calculate reflection vector\n" " // R = 2 * (N * (N dot L) - L/2)\n" " // = 2 * N * (N dot L) - L\n" " float3 reflectVec = ((NdotL * normal.rgb) + (-0.5 * IN.secondarycolor)) * 2.0;\n" "\n" " // eye vector E = (0, 0, 1)\n" " // R dot E = (R.r*0 + R.g*0 + 1*R.b) = R.b\n" " float RdotE = saturate(reflectVec.b); // max(0, RdotE);\n" "\n" " // calculate specular as pow(RdotE, 16)\n" " float specular = pow(RdotE, 16); \n" "\n" " // add specular light contribution to final color\n" " //finalColor += specular;\n" " color += specular;\n" "\n" " float4 outcolor = float4(color, normal.w); \n" " return outcolor;\n" "}\n"; ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/FunctionSphereRenderer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/FunctionSphereRendere0000644000175000017500000000656011006452675032440 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // FunctionSphereRenderer.h: interface for the FunctionSphereRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_FUNCTIONSPHERERENDERER_H__6F47A833_5065_4885_A0C3_B44CF7530782__INCLUDED_) #define AFX_FUNCTIONSPHERERENDERER_H__6F47A833_5065_4885_A0C3_B44CF7530782__INCLUDED_ #include namespace CCVImposterRenderer { class Texture; class FunctionSphereRenderer { public: FunctionSphereRenderer(); virtual ~FunctionSphereRenderer(); bool bindProgramAndParams(); bool unbindProgramAndParams(); bool initCG(); bool loadProgram(); bool fallbackLoadProgram(); bool addFunction( unsigned char* data, double minx, double miny, double minz, double maxx, double maxy, double maxz, int width, int height, int depth); void bindMatrices(); protected: CGprofile m_VertexProfile; CGprofile m_FragmentProfile; CGprogram m_VertexProgram; CGprogram m_FragmentProgram; CGparameter m_PositionParam; CGparameter m_ColorParam; CGparameter m_ModelViewITParam; CGparameter m_ModelViewInverseParam; CGparameter m_ModelViewProjParam; CGparameter m_ProjParam; CGparameter m_ModelViewProjInverseParam; CGparameter m_MainColorParam; CGparameter m_MinExtentParam; CGparameter m_MaxExtentParam; CGparameter m_NormalMapParam; CGparameter m_DepthMapParam; CGparameter m_FunctionMapParam; Texture* m_TextureNormalMap; Texture* m_TextureDepthMap; Texture* m_TextureFunctionMap; unsigned char* m_Data; double m_minx; double m_miny; double m_minz; double m_maxx; double m_maxy; double m_maxz; int m_Width; int m_Height; int m_Depth; }; }; #endif // !defined(AFX_FUNCTIONSPHERERENDERER_H__6F47A833_5065_4885_A0C3_B44CF7530782__INCLUDED_) ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHollowCylinderVertexShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHollowCylinderVer0000644000175000017500000001226711006452675032350 0ustar debiandebianconst char cgGLHollowCylinderVertexShader[] = "// this is the vertex program\n" "\n" "//#pragma bind appdata.position = ATTR0\n" "//#pragma bind appdata.normal = ATTR1\n" "\n" "struct appdata : application2vertex \n" "{\n" " float4 offsetRadius : POSITION;\n" " float4 p1 : TEXCOORD0;\n" " float4 p2 : TEXCOORD1;\n" " float4 color : COLOR0;\n" "};\n" "\n" "struct vfconn : vertex2fragment \n" "{\n" " float4 HPOS : POSITION;\n" " float4 TEX0 : TEXCOORD0;\n" " float4 TEX1 : TEXCOORD1;\n" " float4 TEX2 : TEXCOORD2;\n" " float4 TEX3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float4 remapTo01(float4 v, float4 low, float4 high) {\n" " return saturate((v - low)/(high-low));\n" "}\n" "\n" "vfconn main(appdata IN,\n" " uniform float4x4 ModelViewIT,\n" " uniform float4x4 ModelViewProj,\n" " uniform float4x4 Proj,\n" " uniform float4x4 ModelViewInverse,\n" " uniform float4x4 ModelView)\n" "{\n" " vfconn OUT;\n" "\n" " // eye_space_offset = radius * v[OPOS]\n" " float radius = IN.offsetRadius.z;\n" "\n" " // get vector from P1 to P2\n" " float4 axis = IN.p2 - IN.p1;\n" "\n" " float4 eye_space_axis = normalize(mul(ModelView, axis));\n" " float h = 1 / sqrt(1-eye_space_axis.z*eye_space_axis.z);\n" "\n" " //float4 eye_space_offset = radius * float4(IN.offset.xyz, 0.0);\n" " float4 unit_eye_space_offset = normalize(float4(eye_space_axis.y,-eye_space_axis.x , 0, 0));\n" "/*\n" " float4 eye_space_offset = unit_eye_space_offset * IN.offsetRadius.y * radius;\n" "\n" " if( IN.offsetRadius.x < 0.5 ) \n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * h*radius * eye_space_axis.z;\n" " }\n" " else\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z;\n" " }\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " // offsetRadius.x = 0 or 1 for points near p0 or p1. \n" " // obtain the output position in object space\n" " // assume that w is correct\n" " IN.p2 = IN.p1 + IN.offsetRadius.x*axis + object_space_offset;\n" "*/\n" "\n" "\n" "\n" " float4 eye_space_offset = unit_eye_space_offset * IN.offsetRadius.y * radius;\n" "\n" " if( IN.offsetRadius.x < 0.5 )// && eye_space_axis.z < 0 ) \n" " {\n" " if( eye_space_axis.z < 0 )\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * h*radius * eye_space_axis.z;\n" " }\n" " else\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * h*radius * eye_space_axis.z*-1;\n" " }\n" " }\n" " else\n" " {\n" " if( eye_space_axis.z < 0 )\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z;\n" "\n" " }\n" " else\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z*-1;\n" " }\n" " }\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " // offsetRadius.x = 0 or 1 for points near p0 or p1. \n" " // obtain the output position in object space\n" " // assume that w is correct\n" " IN.p2 = IN.p1 + IN.offsetRadius.x*axis + object_space_offset;\n" "\n" "\n" "\n" "\n" " //---------------------------------------------\n" " // clip coordinates\n" " // IN.p2 has the position\n" " OUT.HPOS = mul(ModelViewProj, IN.p2);\n" " OUT.TEX1 = OUT.HPOS; // because HPOS is apparently not readable !\n" "\n" " OUT.primarycolor.xyzw = IN.color.xyzw;\n" "\n" " // calculate normal-space light vector\n" " // float4 lightVect = float4(00,100,140,1) - IN.p2;\n" " //float4 lightVect = float4(-10,-10,10,0);\n" " float4 lightVect = float4(50,100,140,0);\n" "\n" " lightVect = normalize(lightVect);\n" "\n" " OUT.TEX0 = float4(IN.offsetRadius.y*0.5+0.5,0,0,1);\n" " OUT.TEX0.y = 0.5;\n" "\n" "\n" " // xform light vector into eye space\n" " \n" " float4 eyeLightVec = lightVect; //mul(ModelViewIT, lightVect);\n" " eyeLightVec = float4(dot(unit_eye_space_offset, eyeLightVec), \n" " dot(eye_space_axis, eyeLightVec),\n" " dot(cross(unit_eye_space_offset.xyz, eye_space_axis.xyz), eyeLightVec.xyz),//eyeLightVec.z,\n" " 0);\n" " \n" " // Range compress light vector to fit in a color\n" " OUT.secondarycolor.xyz = eyeLightVec.xyz * 0.5 + 0.5;\n" "\n" " \n" " radius = radius * h;\n" "\n" " /* works ! going to remove the 1/2 optimization thing from here+fragment shader\n" " // z_scale = radius * PROJ[10];\n" " OUT.TEX2.x = radius * Proj[2].z*0.5;\n" " // z_bias = MVP[2] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[2], IN.p2)*0.5;\n" "\n" " // w_scale = radius * PROJ[11]\n" " OUT.TEX3.x = radius * Proj[3].z;\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX3.z = dot(ModelViewProj[3], IN.p2);\n" "\n" " OUT.TEX2.xz = OUT.TEX2.xz + OUT.TEX3.xz/2.0;\n" " */\n" " // z_scale = radius * PROJ[10];\n" " OUT.TEX2.x = radius * Proj[2].z;\n" " // z_bias = MVP[2] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[2], IN.p2);\n" "\n" " // w_scale = radius * PROJ[11]\n" " OUT.TEX3.x = radius * Proj[3].z;\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX3.z = dot(ModelViewProj[3], IN.p2);\n" "\n" " return OUT;\n" "} // main;\n"; ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/FunctionSphereRenderer.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/FunctionSphereRendere0000644000175000017500000001724011006452675032435 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // FunctionSphereRenderer.cpp: implementation of the FunctionSphereRenderer class. // ////////////////////////////////////////////////////////////////////// #include "FunctionSphereRenderer.h" #include "Texture.h" #include "GlobalCGContext.h" #include "cgGLVertexFunctionShader.h" #include "cgGLFragmentFunctionShader.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// using CCVImposterRenderer::FunctionSphereRenderer; FunctionSphereRenderer::FunctionSphereRenderer() { m_VertexProgram = 0; m_FragmentProgram = 0; m_Data = 0; m_minx = 0.0; m_miny = 0.0; m_minz = 0.0; m_maxx = 1.0; m_maxy = 1.0; m_maxz = 1.0; m_Width = 10; m_Height = 10; m_Depth = 10; } FunctionSphereRenderer::~FunctionSphereRenderer() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); delete [] m_Data; m_Data = 0; } bool FunctionSphereRenderer::bindProgramAndParams() { // Set up for ball rendering cgGLEnableProfile(m_VertexProfile); cgGLBindProgram(m_VertexProgram); cgGLEnableProfile(m_FragmentProfile); cgGLBindProgram(m_FragmentProgram); cgGLEnableTextureParameter(m_NormalMapParam); cgGLEnableTextureParameter(m_DepthMapParam); cgGLEnableTextureParameter(m_FunctionMapParam); cgGLSetParameter4f(m_MainColorParam, 1.0, 0.0, 0.0, 1.0); // red cgGLSetParameter3f(m_MinExtentParam, (float)m_minx, (float)m_miny, (float)m_minz ); cgGLSetParameter3f(m_MaxExtentParam, (float)m_maxx, (float)m_maxy, (float)m_maxz ); return true; } void FunctionSphereRenderer::bindMatrices() { cgGLSetStateMatrixParameter(m_ModelViewITParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); cgGLSetStateMatrixParameter(m_ModelViewProjParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(m_ProjParam, CG_GL_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(m_ModelViewInverseParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE); cgGLSetStateMatrixParameter(m_ModelViewProjInverseParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_INVERSE); } bool FunctionSphereRenderer::unbindProgramAndParams() { cgGLDisableTextureParameter(m_FunctionMapParam); cgGLDisableTextureParameter(m_NormalMapParam); cgGLDisableTextureParameter(m_DepthMapParam); cgGLDisableProfile(m_VertexProfile); cgGLDisableProfile(m_FragmentProfile); return true; } bool FunctionSphereRenderer::initCG() { if ( cgGLIsProfileSupported(CG_PROFILE_VP20) ) m_VertexProfile = CG_PROFILE_VP20; else return false; if ( cgGLIsProfileSupported(CG_PROFILE_FP30) ) m_FragmentProfile = CG_PROFILE_FP30; else return false; return true; } bool FunctionSphereRenderer::loadProgram() { if( !m_Data ) return false; // this shouldnt crash the rendering, ensure that if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); CGcontext context = GlobalCGContext::getCGContext(); // Create Vertex Program for Spheres //m_VertexProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLVertexFunctionShader.cg", m_VertexProfile, 0, 0); m_VertexProgram = cgCreateProgram(context, CG_SOURCE,cgGLVertexFunctionShader, m_VertexProfile, 0, 0 ); // Load Vertex Program cgGLLoadProgram(m_VertexProgram); // get parameter handles m_PositionParam = cgGetNamedParameter(m_VertexProgram, "IN.center"); m_ColorParam = cgGetNamedParameter(m_VertexProgram, "IN.color"); m_ModelViewITParam = cgGetNamedParameter(m_VertexProgram, "ModelViewIT"); m_ModelViewInverseParam = cgGetNamedParameter(m_VertexProgram, "ModelViewInverse"); m_ModelViewProjParam = cgGetNamedParameter(m_VertexProgram, "ModelViewProj"); m_ProjParam = cgGetNamedParameter(m_VertexProgram, "Proj"); if (!m_ModelViewITParam || !m_ModelViewProjParam || !m_ProjParam || !m_ColorParam || !m_PositionParam ) return false; // Create Fragment Program //m_FragmentProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLFragmentFunctionShader.cg", m_FragmentProfile, 0, 0); m_FragmentProgram = cgCreateProgram(context, CG_SOURCE,cgGLFragmentFunctionShader, m_FragmentProfile, 0, 0 ); // Load Fragment Program cgGLLoadProgram(m_FragmentProgram); // get parameter handles m_MainColorParam = cgGetNamedParameter(m_FragmentProgram, "maincolor"); m_NormalMapParam = cgGetNamedParameter(m_FragmentProgram, "normalmap"); m_DepthMapParam = cgGetNamedParameter(m_FragmentProgram, "depthmap"); m_FunctionMapParam = cgGetNamedParameter(m_FragmentProgram, "functionmap"); m_ModelViewProjInverseParam = cgGetNamedParameter(m_FragmentProgram, "ModelViewProjInverse"); m_MinExtentParam = cgGetNamedParameter(m_FragmentProgram, "minExtent"); m_MaxExtentParam = cgGetNamedParameter(m_FragmentProgram, "maxExtent"); // prepare the textures m_TextureNormalMap = new Texture(); //m_TextureNormalMap->loadPGM("alphamask.pgm"); m_TextureNormalMap->calculateSphereOpacityAndNormalMap(512); m_TextureDepthMap = new Texture(); m_TextureDepthMap->calculateDepthMap(512,512); m_TextureFunctionMap = new Texture(); if( !m_TextureFunctionMap->loadFunction(m_Data, m_Width, m_Height, m_Depth)) return false; cgGLSetTextureParameter(m_NormalMapParam, m_TextureNormalMap->getTextureID()); cgGLSetTextureParameter(m_DepthMapParam, m_TextureDepthMap->getTextureID()); cgGLSetTextureParameter(m_FunctionMapParam, m_TextureFunctionMap->getTextureID()); return true; } bool FunctionSphereRenderer::addFunction( unsigned char* data, double minx, double miny, double minz, double maxx, double maxy, double maxz, int width, int height, int depth) { delete [] m_Data; // how to delete from CG ? m_Data = data; m_minx = minx; m_miny = miny; m_minz = minz; m_maxx = maxx; m_maxy = maxy; m_maxz = maxz; m_Width = width; m_Height = height; m_Depth = depth; return true; } // loads cubemap without making CG calls bool FunctionSphereRenderer::fallbackLoadProgram() { m_TextureFunctionMap = new Texture(); return m_TextureFunctionMap->loadFunction(m_Data, m_Width, m_Height, m_Depth); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/ExpandableBuffer.h0000644000175000017500000001014211006452675031611 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ #ifndef EXPANDABLEBUFFER_H #define EXPANDABLEBUFFER_H template class ExpandableBuffer { public: ExpandableBuffer(unsigned int size = 1024); ~ExpandableBuffer(); bool allocateBuffer(unsigned int size); T get(int index) const; bool add(T object); void clearBuffer(); bool tighten(); unsigned int getNumObjects() const; T* getBuffer(); protected: bool forceAllocate(unsigned int size); bool doubleBuffer(); T* m_Buffer; unsigned int m_BufferSize; unsigned int m_NumberOfObjects; }; template ExpandableBuffer ::ExpandableBuffer(unsigned int size) { m_BufferSize = 0; m_NumberOfObjects = 0; m_Buffer = 0; allocateBuffer(size); } template ExpandableBuffer ::~ExpandableBuffer() { delete [] m_Buffer; m_Buffer = 0; } template bool ExpandableBuffer ::allocateBuffer(unsigned int size) { if (size<=m_BufferSize) { clearBuffer(); return true; } else { return forceAllocate(size); } } template T ExpandableBuffer ::get(int index) const { if( index < 0 ) return NULL; if (m_NumberOfObjects <= (unsigned int)index ) return NULL; return m_Buffer[index]; } template bool ExpandableBuffer ::add(T object) { if (m_NumberOfObjects==m_BufferSize) { if (!doubleBuffer()) { return false; } } m_Buffer[m_NumberOfObjects] = object; m_NumberOfObjects++; return true; } template void ExpandableBuffer ::clearBuffer() { m_NumberOfObjects = 0; } template bool ExpandableBuffer ::tighten() { T* temp = new T[m_NumberOfObjects]; if (!temp) { return false; } unsigned int c; for (c=0; c unsigned int ExpandableBuffer ::getNumObjects() const { return m_NumberOfObjects; } template T* ExpandableBuffer ::getBuffer() { return m_Buffer; } template bool ExpandableBuffer ::forceAllocate(unsigned int size) { delete [] m_Buffer; m_Buffer = new T[size]; if (!m_Buffer) { m_BufferSize = 0; m_NumberOfObjects = 0; return false; } else { m_BufferSize = size; m_NumberOfObjects = 0; return true; } } template bool ExpandableBuffer ::doubleBuffer() { T* temp = new T[(m_BufferSize*3)/2]; if (!temp) { return false; } unsigned int c; for (c=0; c # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=ImposterRenderer - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "ImposterRenderer.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "ImposterRenderer.mak" CFG="ImposterRenderer - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "ImposterRenderer - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "ImposterRenderer - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "ImposterRenderer - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /O2 /I "$(CG_INC_PATH)" /I "../UsefulMath" /I "../OpenGL_Viewer" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FD /c # SUBTRACT CPP /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "ImposterRenderer - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "$(CG_INC_PATH)" /I "../UsefulMath" /I "../OpenGL_Viewer" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "QT_DLL" /D "QT_THREAD_SUPPORT" /FD /GZ /c # SUBTRACT CPP /YX # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "ImposterRenderer - Win32 Release" # Name "ImposterRenderer - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\BallRenderer.cpp # End Source File # Begin Source File SOURCE=.\FunctionSphereRenderer.cpp # End Source File # Begin Source File SOURCE=.\GaussianRenderer.cpp # End Source File # Begin Source File SOURCE=.\GlobalCGContext.cpp # End Source File # Begin Source File SOURCE=.\HelixRenderer.cpp # End Source File # Begin Source File SOURCE=.\HollowCylinderRenderer.cpp # End Source File # Begin Source File SOURCE=.\ImposterRenderer.cpp # End Source File # Begin Source File SOURCE=.\PlainSphereRenderer.cpp # End Source File # Begin Source File SOURCE=.\sphereDrawing.cpp # End Source File # Begin Source File SOURCE=.\StickRenderer.cpp # End Source File # Begin Source File SOURCE=.\Texture.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\BallRenderer.h # End Source File # Begin Source File SOURCE=.\ExpandableBuffer.h # End Source File # Begin Source File SOURCE=.\FunctionSphereRenderer.h # End Source File # Begin Source File SOURCE=.\GaussianRenderer.h # End Source File # Begin Source File SOURCE=.\GlobalCGContext.h # End Source File # Begin Source File SOURCE=.\HelixRenderer.h # End Source File # Begin Source File SOURCE=.\HollowCylinderRenderer.h # End Source File # Begin Source File SOURCE=.\ImposterRenderer.h # End Source File # Begin Source File SOURCE=.\PlainSphereRenderer.h # End Source File # Begin Source File SOURCE=.\sphereDrawing.h # End Source File # Begin Source File SOURCE=.\StickRenderer.h # End Source File # Begin Source File SOURCE=.\Texture.h # End Source File # End Group # Begin Group "CG Files" # PROP Default_Filter "*.cg" # Begin Source File SOURCE=..\cgGLCylFragmentShader.cg # End Source File # Begin Source File SOURCE=.\cgGLCylFragmentShader.h # End Source File # Begin Source File SOURCE=..\cgGLCylVertexShader.cg # End Source File # Begin Source File SOURCE=.\cgGLCylVertexShader.h # End Source File # Begin Source File SOURCE=..\cgGLFragmentFunctionShader.cg # End Source File # Begin Source File SOURCE=.\cgGLFragmentFunctionShader.h # End Source File # Begin Source File SOURCE=..\cgGLFragmentShader.cg # End Source File # Begin Source File SOURCE=.\cgGLFragmentShader.h # End Source File # Begin Source File SOURCE=..\cgGLHelixFragmentShader.cg # End Source File # Begin Source File SOURCE=.\cgGLHelixFragmentShader.h # End Source File # Begin Source File SOURCE=..\cgGLHelixVertexShader.cg # End Source File # Begin Source File SOURCE=.\cgGLHelixVertexShader.h # End Source File # Begin Source File SOURCE=..\cgGLHollowCylinderFragmentShader.cg # End Source File # Begin Source File SOURCE=.\cgGLHollowCylinderFragmentShader.h # End Source File # Begin Source File SOURCE=..\cgGLHollowCylinderVertexShader.cg # End Source File # Begin Source File SOURCE=.\cgGLHollowCylinderVertexShader.h # End Source File # Begin Source File SOURCE=..\cgGLVertexFunctionShader.cg # End Source File # Begin Source File SOURCE=.\cgGLVertexFunctionShader.h # End Source File # Begin Source File SOURCE=..\cgGLVertexShader.cg # End Source File # Begin Source File SOURCE=.\cgGLVertexShader.h # End Source File # End Group # Begin Source File SOURCE=.\ImposterRenderer.pro # End Source File # End Target # End Project mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/sphereDrawing.h0000644000175000017500000000346211006452675031225 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* Ariel Shamir arik@ices.utexas.edu */ /* Peter Djeu djeu@cs.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ #ifndef _SPHEREDRAWING_H_ #define _SPHEREDRAWING_H_ #include #include namespace CCVImposterRenderer { void VoroDrawSphere(int c); }; #endif // _SPHEREDRAWING_H_ ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshCylinderRenderer.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshCylinderRenderer.0000644000175000017500000000666311006453060032323 0ustar debiandebian/* * A fallback replacement for the CG-Impostor system currently used to draw Cylinders. * This class will read the CG-encoded data and interpret it to draw Mesh instances. * * Note that per-pixel effects like those provided by the shader are not feasible with this * system. * * m_strange@mail.utexas.edu * * */ #include "MeshCylinderRenderer.h" #include "../UsefulMath/Vector.h" #include GLUquadric* MeshCylinderRenderer::m_Quadric = 0; const int MeshCylinderRenderer::LEVEL_OF_DETAIL = 10; void MeshCylinderRenderer::DrawCylinderBuffer(const ExpandableBuffer& position, const ExpandableBuffer& color, const ExpandableBuffer& textureCoord1, const ExpandableBuffer& textureCoord2) { // NOTE: leaked, but this is a singleton if(m_Quadric == 0) { m_Quadric = gluNewQuadric(); } // we extract the centers and radii from the encoding that is usually passed to the CG program const int numBalls = position.getNumObjects()/16; for(int i=0; i 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // GaussianRenderer.h: interface for the GaussianRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_GAUSSIANRENDERER_H__B61DC823_49F9_4912_BE8E_6E4AABE7F0CB__INCLUDED_) #define AFX_GAUSSIANRENDERER_H__B61DC823_49F9_4912_BE8E_6E4AABE7F0CB__INCLUDED_ #include #include #include "ExpandableBuffer.h" #include "MyExtensions.h" namespace CCVImposterRenderer { class PlainSphereRenderer; class FunctionSphereRenderer; class Texture; class GaussianRenderer { public: GaussianRenderer(); virtual ~GaussianRenderer(); void clearGaussians(); inline void addGaussian(float x, float y, float z, float radius, float red, float green, float blue); int getNumGaussians() const; void initRenderer( bool drawFunction ); void renderBuffer(); static void forceMeshRendering(bool status) { m_UseGLFallback = status; } protected: bool initCG(); bool initExtensions(); bool loadProgram(); void prepareBuffers(); bool bindProgramAndParams(); bool unbindProgramAndParams(); void bindMatrices(); void allocateBufferObjects(unsigned int num); void deallocateBufferObjects(); void renderOnce(); bool m_Initialized; static bool m_UseGLFallback; // the buffers ExpandableBuffer m_TextureCoord; ExpandableBuffer m_Position; ExpandableBuffer m_Color; bool m_Dirty; unsigned int m_NumGaussians; unsigned int m_NumBufferObjectsAllocated; GLuint* m_BufferObjects; MyExtensions* m_Extensions; int m_CGRequirements; int m_OpenGLRequirements; int m_ProgramsLoaded; CGprogram m_VertexProgram; CGprogram m_FragmentProgram; CGprofile m_VertexProfile; CGprofile m_FragmentProfile; CGparameter m_PositionParam; CGparameter m_ColorParam; CGparameter m_ModelViewITParam; CGparameter m_ModelViewInverseParam; CGparameter m_ModelViewProjParam; CGparameter m_ProjParam; CGparameter m_MainColorParam; CGparameter m_NormalMapParam; CGparameter m_DepthMapParam; Texture* m_TextureNormalMap; Texture* m_TextureDepthMap; }; inline void GaussianRenderer::addGaussian(float x, float y, float z, float radius, float red, float green, float blue) { m_Dirty = true; bool result = true; // position result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(0); result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(1); result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(2); result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(3); // color result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.1f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.6f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.1f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.1f); if (!result) { printf("Warning, could not add gaussian"); } m_NumGaussians++; } }; #endif // !defined(AFX_GAUSSIANRENDERER_H__B61DC823_49F9_4912_BE8E_6E4AABE7F0CB__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/Makefile0000644000175000017500000000501010240173436027673 0ustar debiandebianCC = g++ CCFLAGS = -Wall -O3 -finline # ----- Example programs -------------------------------------------------------- PROG_SRC = BallRenderer.cpp FunctionSphereRenderer.cpp GaussianRenderer.cpp GlobalCGContext.cpp HelixRenderer.cpp HollowCylinderRenderer.cpp ImposterRenderer.cpp PlainSphereRenderer.cpp sphereDrawing.cpp StickRenderer.cpp Texture.cpp PROG_OBJ = BallRenderer.o FunctionSphereRenderer.o GaussianRenderer.o GlobalCGContext.o HelixRenderer.o HollowCylinderRenderer.o ImposterRenderer.o PlainSphereRenderer.o sphereDrawing.o StickRenderer.o Texture.o TARGET = libImposterRenderer.a # ------------------------------------------------------------------------------- all: Makefile $(TARGET) $(TARGET): $(PROG_OBJ) rm -f $(TARGET) ar cqs $(TARGET) $(PROG_OBJ) BallRenderer.o: BallRenderer.cpp $(CC) $(CCFLAGS) -c BallRenderer.cpp -o BallRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath FunctionSphereRenderer.o: FunctionSphereRenderer.cpp $(CC) $(CCFLAGS) -c FunctionSphereRenderer.cpp -o FunctionSphereRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath GaussianRenderer.o: GaussianRenderer.cpp $(CC) $(CCFLAGS) -c GaussianRenderer.cpp -o GaussianRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath GlobalCGContext.o: GlobalCGContext.cpp $(CC) $(CCFLAGS) -c GlobalCGContext.cpp -o GlobalCGContext.o -I. -I../OpenGL_Viewer -I../UsefulMath HelixRenderer.o: HelixRenderer.cpp $(CC) $(CCFLAGS) -c HelixRenderer.cpp -o HelixRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath HollowCylinderRenderer.o: HollowCylinderRenderer.cpp $(CC) $(CCFLAGS) -c HollowCylinderRenderer.cpp -o HollowCylinderRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath ImposterRenderer.o: ImposterRenderer.cpp $(CC) $(CCFLAGS) -c ImposterRenderer.cpp -o ImposterRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath PlainSphereRenderer.o: PlainSphereRenderer.cpp $(CC) $(CCFLAGS) -c PlainSphereRenderer.cpp -o PlainSphereRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath sphereDrawing.o: sphereDrawing.cpp $(CC) $(CCFLAGS) -c sphereDrawing.cpp -o sphereDrawing.o -I. -I../OpenGL_Viewer -I../UsefulMath StickRenderer.o: StickRenderer.cpp $(CC) $(CCFLAGS) -c StickRenderer.cpp -o StickRenderer.o -I. -I../OpenGL_Viewer -I../UsefulMath Texture.o: Texture.cpp $(CC) $(CCFLAGS) -c Texture.cpp -o Texture.o -I. -I../OpenGL_Viewer -I../UsefulMath clean: rm $(TARGET) BallRenderer.o FunctionSphereRenderer.o GaussianRenderer.o GlobalCGContext.o HelixRenderer.o HollowCylinderRenderer.o ImposterRenderer.o PlainSphereRenderer.o sphereDrawing.o StickRenderer.o Texture.o ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLCylFragmentShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLCylFragmentShader0000644000175000017500000000463311006452675032275 0ustar debiandebianconst char cgGLCylFragmentShader[] = "// this is the fragment program\n" "\n" "struct inputs\n" "{\n" " float4 HPOS : POSITION;\n" " float4 texcoord : TEXCOORD0;\n" " float4 texcoord1 : TEXCOORD1;\n" " float4 texcoord2 : TEXCOORD2;\n" " float4 texcoord3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float3 expand(float3 vector)\n" "{\n" " return 2.0 * (vector - 0.5);\n" "}\n" "\n" "// register combiner vector normalization function\n" "float3 normalize(float3 vector)\n" "{\n" " float3 VdotV = dot(expand(vector), expand(vector));\n" " return (1-saturate(VdotV)) * (vector-0.5) + expand(vector);\n" "}\n" "\n" "float4 main(inputs IN, out float depth: DEPTH,\n" " uniform float4 maincolor,\n" " uniform sampler1D normalmap,\n" " uniform sampler2D depthmap) : COLOR\n" "{\n" "\n" " \n" " //float3 color = tex2D(alphamap, IN.texcoord.xy).xyz;\n" " float4 normal = 2.0 * (tex1D(normalmap, IN.texcoord.x) - 0.5);\n" "\n" "\n" " //float3 normal = (tex2D(normalmap, IN.texcoord1.xy)).rgb;\n" " \n" " //IN.secondarycolor.rgb = 2.0*(IN.secondarycolor.rgb-0.5);\n" " IN.secondarycolor.rgb = normalize(IN.secondarycolor.rgb);\n" "\n" " float3 NdotL = dot(normal.rgb, IN.secondarycolor);\n" " float3 color = IN.primarycolor.rgb*(saturate(NdotL) + IN.primarycolor.w);\n" " //float3 diffuse = IN.col1.rgb;\n" " //float3 specular = (float3)lighting.a;\n" "\n" " // calculate reflection vector\n" " // R = 2 * (N * (N dot L) - L/2)\n" " // = 2 * N * (N dot L) - L\n" " float3 reflectVec = ((NdotL * normal.rgb) + (-0.5 * IN.secondarycolor)) * 2.0;\n" "\n" " // eye vector E = (0, 0, 1)\n" " // R dot E = (R.r*0 + R.g*0 + 1*R.b) = R.b\n" " float RdotE = saturate(reflectVec.b); // max(0, RdotE);\n" "\n" " // calculate specular as pow(RdotE, 16)\n" " float specular = pow(RdotE, 16); \n" "\n" " // add specular light contribution to final color\n" " color += specular;\n" " //finalColor += specular;\n" "\n" "\n" " //IN.color.rgb = IN.color.rgb * diffuse;// + specular;\n" " //IN.color.w = 1.0;\n" " \n" " float3 depthVal = tex2D(depthmap, IN.texcoord1.xy).rgb;\n" " // check with no extra depth to see whats being drawn.\n" " //depthVal.x = 0.0;\n" "\n" " float z = dot(IN.texcoord2.xyz, depthVal);\n" " float w = dot(IN.texcoord3.xyz, depthVal);\n" " depth = (z / w);\n" "\n" " float4 outcolor = float4(color, normal.w);\n" " return outcolor;\n" "}\n"; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLCylVertexShader.h0000644000175000017500000000655111006452675032236 0ustar debiandebianconst char cgGLCylVertexShader[] = "// this is the vertex program\n" "\n" "//#pragma bind appdata.position = ATTR0\n" "//#pragma bind appdata.normal = ATTR1\n" "\n" "struct appdata : application2vertex \n" "{\n" " float4 offsetRadius : POSITION;\n" " float4 p1 : TEXCOORD0;\n" " float4 p2 : TEXCOORD1;\n" " float4 color : COLOR0;\n" "};\n" "\n" "struct vfconn : vertex2fragment \n" "{\n" " float4 HPOS : POSITION;\n" " float4 TEX0 : TEXCOORD0;\n" " float4 TEX1 : TEXCOORD1;\n" " float4 TEX2 : TEXCOORD2;\n" " float4 TEX3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float4 remapTo01(float4 v, float4 low, float4 high) {\n" " return saturate((v - low)/(high-low));\n" "}\n" "\n" "vfconn main(appdata IN,\n" " uniform float4x4 ModelViewIT,\n" " uniform float4x4 ModelViewProj,\n" " uniform float4x4 Proj,\n" " uniform float4x4 ModelViewInverse,\n" " uniform float4x4 ModelView)\n" "{\n" " vfconn OUT;\n" "\n" " // eye_space_offset = radius * v[OPOS]\n" " float radius = IN.offsetRadius.z;\n" "\n" " // get vector from P1 to P2\n" " float4 axis = IN.p2 - IN.p1;\n" "\n" " float4 eye_space_axis = normalize(mul(ModelView, axis));\n" " float h = 1 / sqrt(1-eye_space_axis.z*eye_space_axis.z);\n" "\n" " //float4 eye_space_offset = radius * float4(IN.offset.xyz, 0.0);\n" " float4 unit_eye_space_offset = normalize(float4(eye_space_axis.y,-eye_space_axis.x , 0, 0));\n" " float4 eye_space_offset = unit_eye_space_offset * IN.offsetRadius.y * radius;\n" "\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z;\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " // offsetRadius.x = 0 or 1 for points near p0 or p1. \n" " // obtain the output position in object space\n" " // assume that w is correct\n" " IN.p2 = IN.p1 + IN.offsetRadius.x*axis + object_space_offset;\n" "\n" " // clip coordinates\n" " // IN.p2 has the position\n" " OUT.HPOS = mul(ModelViewProj, IN.p2);\n" "\n" " OUT.primarycolor.xyzw = IN.color.xyzw;\n" "\n" " // calculate normal-space light vector\n" " // float4 lightVect = float4(00,100,140,1) - IN.p2;\n" " float4 lightVect = float4(50,100,140,0);\n" " lightVect = normalize(lightVect);\n" "\n" " OUT.TEX0 = float4(IN.offsetRadius.y*0.5+0.5,0,0,1);\n" " OUT.TEX1 = OUT.TEX0;\n" " OUT.TEX1.y = 0.5;\n" "\n" "\n" " // xform light vector into eye space\n" " \n" " float4 eyeLightVec = lightVect; //mul(ModelViewIT, lightVect);\n" " eyeLightVec = float4(dot(unit_eye_space_offset, eyeLightVec), \n" " dot(eye_space_axis, eyeLightVec),\n" " dot(cross(unit_eye_space_offset.xyz, eye_space_axis.xyz), eyeLightVec.xyz),//eyeLightVec.z,\n" " 0);\n" " \n" " // Range compress light vector to fit in a color\n" " OUT.secondarycolor.xyz = eyeLightVec.xyz * 0.5 + 0.5;\n" "\n" " \n" " radius = radius * h;\n" "\n" " // z_scale = radius * PROJ[10];\n" " OUT.TEX2.x = radius * Proj[2].z*0.5;\n" " // z_bias = MVP[2] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[2], IN.p2)*0.5;\n" "\n" " // w_scale = radius * PROJ[11]\n" " OUT.TEX3.x = radius * Proj[3].z;\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX3.z = dot(ModelViewProj[3], IN.p2);\n" "\n" " OUT.TEX2.xz = OUT.TEX2.xz + OUT.TEX3.xz/2.0;\n" " \n" "\n" "\n" " return OUT;\n" "} // main;\n"; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLVertexShader.h0000644000175000017500000000654711006452675031573 0ustar debiandebianconst char cgGLVertexShader[] = "// this is the vertex program\n" "//#pragma bind appdata.position = ATTR0\n" "//#pragma bind appdata.normal = ATTR1\n" "struct appdata\n" "{\n" " float4 center : POSITION;\n" " float4 color : COLOR0;\n" " //float4 offset : TEXCOORD0;\n" "};\n" "\n" "struct vfconn\n" "{\n" " float4 HPOS : POSITION;\n" " float4 TEX0 : TEXCOORD0;\n" " float4 TEX1 : TEXCOORD1;\n" " float4 TEX2 : TEXCOORD2;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float4 remapTo01(float4 v, float4 low, float4 high) {\n" " return saturate((v - low)/(high-low));\n" "}\n" "\n" "vfconn main(appdata IN,\n" " uniform float4x4 ModelViewIT,\n" " uniform float4x4 ModelViewProj,\n" " uniform float4x4 Proj,\n" " uniform float4x4 ModelViewInverse)\n" "{\n" " vfconn OUT;\n" " //float4 positions[4] = {float4(-1,-1,0, 0.1), float4(1,-1,0, 0.6), float4(1,1,0, 0.1), float4(-1,1,0, 0.1)};\n" " //float2 textures[4] = {float2(0,0), float2(1,0), float2(1,1), float2(0,1)};\n" " float3 offset;\n" " float ambient;\n" " if(IN.center.w == 0) {\n" " offset = float3(-1,-1,0);\n" " ambient = 0.1;\n" " }\n" " else if(IN.center.w == 1) {\n" " offset = float3(1,-1,0);\n" " ambient = 0.6;\n" " }\n" " else if(IN.center.w == 2) {\n" " offset = float3(1,1,0);\n" " ambient = 0.1;\n" " }\n" " else if(IN.center.w == 3) {\n" " offset = float3(-1,1,0);\n" " ambient = 0.1;\n" " }\n" "\n" " OUT.TEX0 = remapTo01(float4(offset, 0.0), (float4)-1.0, (float4)1.0);\n" " OUT.TEX0.zw = float2(0,1);\n" " //OUT.TEX0.xy = textures[IN.center.w];\n" " //OUT.TEX0.zw = float2(0,1);\n" " IN.center.w = 1.0;\n" " float radius = IN.color.w;\n" " \n" " // 1. z_scale = radius * PROJ[10];\n" " OUT.TEX1.x = radius * Proj[2].z*0.5;\n" " \n" " // z_bias = MVP[2] * center;\n" " OUT.TEX1.z = dot(ModelViewProj[2], IN.center)*0.5;\n" " \n" "\n" " // 2. w_scale = radius * PROJ[11]\n" " OUT.TEX2.x = radius * Proj[3].z;\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[3], IN.center);\n" "\n" " // 3. optimization, instead of doing *0.5 + 0.5, we simply do it here itself\n" " OUT.TEX1.xz = OUT.TEX1.xz + OUT.TEX2.xz/2.0;\n" "\n" " // In the above, we are assuming that OUT.TEX1.y = OUT.TEX2.y = 0, \n" " // and/or the low component in the depth map is 0!\n" "\n" " // eye_space_offset = radius * v[OPOS]\n" " float4 eye_space_offset = radius * float4(offset, 0.0);\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " IN.center.xyz = IN.center.xyz + object_space_offset.xyz;\n" " // clip coordinates\n" " OUT.HPOS = mul(ModelViewProj, IN.center);\n" "\n" " OUT.primarycolor.xyz = IN.color.xyz;\n" " OUT.primarycolor.w = ambient;\n" "\n" "// OUT.TEX1 = OUT.TEX0;\n" "\n" " //float4 lightVect = float4(600,600,640,1) - IN.center;\n" " float4 lightVect = float4(50,100,140,0);\n" " \n" " lightVect = normalize(lightVect);\n" "\n" " // xform light vector into eye space\n" " float4 eyeLightVec = lightVect;//mul(ModelViewIT, lightVect);\n" "\n" " // Range compress light vector to fit in a color\n" " OUT.secondarycolor.xyz = eyeLightVec.xyz * 0.5 + 0.5;\n" "\n" " return OUT;\n" "} // main;\n"; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/ImposterRenderer.dsw0000644000175000017500000000101611006452675032253 0ustar debiandebianMicrosoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "ImposterRenderer"=.\ImposterRenderer.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/HelixRenderer.h0000644000175000017500000002213511006452675031161 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // HelixRenderer.h: interface for the HelixRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_HELIXRENDERER_H__854674F3_B887_4AA6_BED9_56ADE76375C8__INCLUDED_) #define AFX_HELIXRENDERER_H__854674F3_B887_4AA6_BED9_56ADE76375C8__INCLUDED_ #include #include #include #include "Texture.h" #include "ExpandableBuffer.h" #include "MyExtensions.h" namespace CCVImposterRenderer { class HelixRenderer { public: HelixRenderer( MyExtensions* extensions ); virtual ~HelixRenderer(); void clear(); inline void add(float x1, float y1, float z1, float x2, float y2, float z2, float radius, float red, float green, float blue); int getNum() const; void initRenderer( bool drawFunction ); void renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors ); static void forceMeshRendering(bool status) { m_UseGLFallback = status; } protected: bool initCG(bool drawFunction); bool initExtensions(); void initDefaults( MyExtensions* extensions ); void renderOnce(); bool m_Initialized; static bool m_UseGLFallback; // profiles CGprofile m_VertexProfile; CGprofile m_FragmentProfile; CGprogram m_VertexProgram; CGparameter m_ModelViewITParam; CGparameter m_ModelViewInverseParam; CGparameter m_ModelViewProjParam; CGparameter m_ModelViewParam; CGparameter m_ProjParam; CGprogram m_FragmentProgram; CGparameter m_MainColorParam; CGparameter m_NormalMapParam; CGparameter m_DepthMapParam; CGparameter m_OpacityMapParam; CGparameter m_ModelViewProjInverseParam; CGparameter m_HelixDCs; CGparameter m_RefVector; CGparameter m_EndPoint1; CGparameter m_HelixDCsCrossRefVector; CGparameter m_LengthOfHelix; Texture* m_TextureNormalMap; Texture* m_TextureDepthMap; Texture* m_TextureOpacityMap; // the buffers ExpandableBuffer m_TextureCoord1; ExpandableBuffer m_TextureCoord2; ExpandableBuffer m_Position; ExpandableBuffer m_Color; unsigned int m_NumberOfHelices; MyExtensions* m_Extensions; }; inline void HelixRenderer::add(float x1, float y1, float z1, float x2, float y2, float z2, float radius, float red, float green, float blue) { radius /= 1.5; //srand( (int)(x1*100000) ); //red = rand() / ( RAND_MAX + 1.0f ); green = rand() / ( RAND_MAX + 1.0f ); blue = rand() / ( RAND_MAX + 1.0f ); /* { static bool addedOne = false; if( addedOne ) return; addedOne = true; x1 = 10.0f; y1 = 0.0f; z1 = 10.0f; x2 = 1.0f; y2 = 0.0f; z2 = 1.0f; radius = 2.0f; }*/ /* { static int addedTwo = 0; if( addedTwo == 2 ) return; addedTwo++; double shift = 7; if( addedTwo == 1 ) { x1 = 13.0f-shift; y1 = -5.0f+shift-4; z1 = 15.0f; x2 = 4.0f-shift; y2 = 0.0f+shift-4; z2 = 1.0f; red = 1.0; green = 0.0; blue = 0.0; } else { x1 = 10.0f-shift; y1 = 0.0f+shift-4; z1 = 25.0f; x2 = 7.0f-shift; y2 = 0.0f+shift-4; z2 = -10.0f; red = 0.0; green = 1.0; blue = 0.0; } radius = 2.0f; } */ bool result = true; // position - stores the offsets result &= m_Position.add(0); result &= m_Position.add(-1); result &= m_Position.add(radius*2); result &= m_Position.add(1); result &= m_Position.add(0); result &= m_Position.add(1); result &= m_Position.add(radius*2); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(radius*2); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(-1); result &= m_Position.add(radius*2); result &= m_Position.add(1); // texturecoord - stores the 2 end points result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); // color result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.4f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.0f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.0f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.4f); if (!result) { printf("Warning, could not add Helix"); } m_NumberOfHelices++; } }; #endif // !defined(AFX_HELIXRENDERER_H__854674F3_B887_4AA6_BED9_56ADE76375C8__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/ImposterRenderer.h0000644000175000017500000000676411006664020031711 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* Peter Djeu djeu@cs.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // ImposterRenderer.h: interface for the ImposterRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_IMPOSTERRENDERER_H__01E3AE03_D9AD_4A30_A364_BA19EF5ADEFE__INCLUDED_) #define AFX_IMPOSTERRENDERER_H__01E3AE03_D9AD_4A30_A364_BA19EF5ADEFE__INCLUDED_ class MyExtensions; class VolumeData; #include "Texture.h" #include "BallRenderer.h" #include "GaussianRenderer.h" #include "StickRenderer.h" #include "HelixRenderer.h" #include "HollowCylinderRenderer.h" #include "sphereDrawing.h" #include #include namespace CCVImposterRenderer { class ImposterRenderer { public: ImposterRenderer(); virtual ~ImposterRenderer(); bool initRenderer(); void renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors, float avgradius ); void initSubRenderers( bool drawFunction ); bool addFunction( unsigned char* data, double minx, double miny, double minz, double maxx, double maxy, double maxz, int width, int height, int depth); //void drawFunctionOnSurfaces( bool drawFunction ); void clear(); BallRenderer* m_BallRenderer; GaussianRenderer* m_GaussianRenderer; StickRenderer* m_StickRenderer; HelixRenderer* m_HelixRenderer; HollowCylinderRenderer* m_HollowCylinderRenderer; /* force using OpenGL meshes instead of the CG impostors */ static void forceMeshRendering(bool status); protected: bool initialized; // general cg CGcontext m_ShaderContext; CGprofile m_VertexProfile; CGprofile m_FragmentProfile; /* MyExtensions* m_Extensions; */ MyExtensions m_Extensions; }; }; #endif // !defined(AFX_IMPOSTERRENDERER_H__01E3AE03_D9AD_4A30_A364_BA19EF5ADEFE__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/StickRenderer.cpp0000644000175000017500000004527411006452675031531 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // StickRenderer.cpp: implementation of the StickRenderer class. // ////////////////////////////////////////////////////////////////////// #include "StickRenderer.h" #include "GlobalCGContext.h" #include "cgGLCylVertexShader.h" #include "cgGLCylFragmentShader.h" #include "MeshCylinderRenderer.h" using CCVImposterRenderer::StickRenderer; bool StickRenderer::m_UseGLFallback = false; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// StickRenderer::StickRenderer( MyExtensions* extensions ) { initDefaults( extensions ); } void StickRenderer::initDefaults( MyExtensions* extensions ) { m_Initialized = false; m_NumSticks = 0; m_Extensions = extensions; m_VertexProgram = 0; m_FragmentProgram = 0; } StickRenderer::~StickRenderer() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); } void StickRenderer::clearSticks() { m_TextureCoord1.clearBuffer(); m_TextureCoord2.clearBuffer(); m_Color.clearBuffer(); m_Position.clearBuffer(); m_NumSticks = 0; } int StickRenderer::getNumSticks() const { return m_NumSticks; } void StickRenderer::initRenderer( bool drawFunction ) { // without extensions we cannot operate at all if(!initExtensions()) { m_Initialized = false; fprintf(stderr, "ERROR: OpenGL extensions unavailable, update your graphics drivers.\n"); return; } // if FP30 isn't present we will use a different branch of every render method if(!initCG( drawFunction )) { fprintf(stderr, "WARNING: FP30 not found, falling back on GL Rendering.\n"); m_UseGLFallback = true; } m_Initialized = true; } void StickRenderer::renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors ) { // MESH RENDERING if(m_UseGLFallback) { // bail if not initialized if (!m_Initialized) { return; } if (m_NumSticks==0) { // we are done return; } glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT); // Set up for Stick rendering // cgGLEnableProfile(m_VertexProfile); // cgGLBindProgram(m_VertexProgram); // cgGLEnableProfile(m_FragmentProfile); // cgGLBindProgram(m_FragmentProgram); glDisable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); // cgGLEnableTextureParameter(m_NormalMapParam); // cgGLEnableTextureParameter(m_DepthMapParam); // cgGLSetParameter4f(m_MainColorParam, 0.7f, 0.7f, 0.7f, 1.0f); // gray m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); // set up multitextures // m_Extensions->glClientActiveTextureARB( GL_TEXTURE0_ARB ); // glEnableClientState(GL_TEXTURE_COORD_ARRAY); // glTexCoordPointer(4, GL_FLOAT, 0, m_TextureCoord1.getBuffer()); // m_Extensions->glClientActiveTextureARB( GL_TEXTURE1_ARB ); // glEnableClientState(GL_TEXTURE_COORD_ARRAY); // glTexCoordPointer(4, GL_FLOAT, 0, m_TextureCoord2.getBuffer()); // draw // glEnableClientState(GL_VERTEX_ARRAY); // glEnableClientState(GL_COLOR_ARRAY); ////// perform transformations if needed and repeat the rendering if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; iglSecondaryColor3fEXT(0.,0.,1.); // set up multitextures m_Extensions->glClientActiveTextureARB( GL_TEXTURE0_ARB ); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(4, GL_FLOAT, 0, m_TextureCoord1.getBuffer()); m_Extensions->glClientActiveTextureARB( GL_TEXTURE1_ARB ); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(4, GL_FLOAT, 0, m_TextureCoord2.getBuffer()); // draw glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); ////// perform transformations if needed and repeat the rendering if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; iglClientActiveTextureARB( GL_TEXTURE1_ARB ); glDisableClientState(GL_TEXTURE_COORD_ARRAY); m_Extensions->glClientActiveTextureARB( GL_TEXTURE0_ARB ); glDisableClientState(GL_TEXTURE_COORD_ARRAY); cgGLDisableTextureParameter(m_DepthMapParam); cgGLDisableTextureParameter(m_NormalMapParam); glDisable(GL_BLEND); glDisable(GL_COLOR_SUM_ARB); cgGLDisableProfile(m_VertexProfile); cgGLDisableProfile(m_FragmentProfile); glPopAttrib(); } } bool StickRenderer::initCG( bool drawFunction ) { if ( cgGLIsProfileSupported(CG_PROFILE_VP20) ) m_VertexProfile = CG_PROFILE_VP20; else return false; if ( cgGLIsProfileSupported(CG_PROFILE_FP30) ) m_FragmentProfile = CG_PROFILE_FP30; else return false; CGcontext context = GlobalCGContext::getCGContext(); // Create Vertex Program for Cylinder // m_VertexProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLCylVertexShader.cg", m_VertexProfile, NULL, NULL); m_VertexProgram = cgCreateProgram(context, CG_SOURCE,cgGLCylVertexShader, m_VertexProfile, NULL, NULL ); // Load Vertex Program for Cylinder cgGLLoadProgram(m_VertexProgram); m_ModelViewITParam = cgGetNamedParameter(m_VertexProgram, "ModelViewIT"); m_ModelViewInverseParam = cgGetNamedParameter(m_VertexProgram, "ModelViewInverse"); m_ModelViewProjParam = cgGetNamedParameter(m_VertexProgram, "ModelViewProj"); m_ModelViewParam = cgGetNamedParameter(m_VertexProgram, "ModelView"); m_ProjParam = cgGetNamedParameter(m_VertexProgram, "Proj"); if (!m_ModelViewITParam || !m_ModelViewInverseParam || !m_ModelViewProjParam || !m_ModelViewParam || !m_ProjParam) //if (!m_ModelViewITParam || !m_ModelViewInverseParam || !m_ModelViewProjParam || !m_ProjParam) return false; // Create Fragment Program // m_FragmentProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLCylFragmentShader.cg", m_FragmentProfile, NULL, NULL); m_FragmentProgram = cgCreateProgram(context, CG_SOURCE,cgGLCylFragmentShader, m_FragmentProfile, NULL, NULL ); // Load Fragment Program cgGLLoadProgram(m_FragmentProgram); m_MainColorParam = cgGetNamedParameter(m_FragmentProgram, "maincolor"); m_NormalMapParam = cgGetNamedParameter(m_FragmentProgram, "normalmap"); m_DepthMapParam = cgGetNamedParameter(m_FragmentProgram, "depthmap"); m_TextureNormalMap = new Texture(); m_TextureNormalMap->calculateCylinderNormalMap(512); m_TextureDepthMap = new Texture(); m_TextureDepthMap->calculateCylinderDepthMap(512); cgGLSetTextureParameter(m_NormalMapParam, m_TextureNormalMap->getTextureID()); cgGLSetTextureParameter(m_DepthMapParam, m_TextureDepthMap->getTextureID()); return true; } bool StickRenderer::initExtensions() { return true; } ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLVertexFunctionShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLVertexFunctionSha0000644000175000017500000000551411006452675032351 0ustar debiandebianconst char cgGLVertexFunctionShader[] = "// this is the vertex program\n" "\n" "//#pragma bind appdata.position = ATTR0\n" "//#pragma bind appdata.normal = ATTR1\n" "\n" "struct appdata\n" "{\n" " float4 center : POSITION;\n" " float4 color : COLOR0;\n" " //float4 offset : TEXCOORD0;\n" "};\n" "\n" "struct vfconn\n" "{\n" " float4 HPOS : POSITION;\n" " float4 TEX0 : TEXCOORD0;\n" " float4 TEX1 : TEXCOORD1;\n" " float4 TEX2 : TEXCOORD2;\n" " float4 TEX3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float4 remapTo01(float4 v, float4 low, float4 high) {\n" " return saturate((v - low)/(high-low));\n" "}\n" "\n" "vfconn main(appdata IN,\n" " uniform float4x4 ModelViewIT,\n" " uniform float4x4 ModelViewProj,\n" " uniform float4x4 Proj,\n" " uniform float4x4 ModelViewInverse)\n" "{\n" " vfconn OUT;\n" " float4 positions[4] = {float4(-1,-1,0, 0.1), float4(1,-1,0, 0.6), float4(1,1,0, 0.1), float4(-1,1,0, 0.1)};\n" " //float2 textures[4] = {float2(0,0), float2(1,0), float2(1,1), float2(0,1)};\n" " float3 offset = positions[IN.center.w].xyz;\n" " float ambient = positions[IN.center.w].w;\n" " OUT.TEX0 = remapTo01(float4(offset, 0.0), (float4)-1.0, (float4)1.0);\n" " OUT.TEX0.zw = float2(0,1);\n" " //OUT.TEX0.xy = textures[IN.center.w];\n" " //OUT.TEX0.zw = float2(0,1);\n" " IN.center.w = 1.0;\n" " float radius = IN.color.w;\n" "\n" " // z_scale = radius * PROJ[10];\n" " OUT.TEX1.x = radius * Proj[2].z*0.5;\n" "\n" " // z_bias = MVP[2] * center;\n" " OUT.TEX1.z = dot(ModelViewProj[2], IN.center)*0.5;\n" "\n" " // w_scale = radius * PROJ[11]\n" " OUT.TEX2.x = radius * Proj[3].z;\n" "\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[3], IN.center);\n" "\n" " OUT.TEX1.xz = OUT.TEX1.xz + OUT.TEX2.xz/2.0;\n" "\n" " // eye_space_offset = radius * v[OPOS]\n" " float4 eye_space_offset = radius * float4(offset, 0.0);\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " IN.center.xyz = IN.center.xyz + object_space_offset.xyz;\n" " \n" " // clip coordinates\n" " OUT.HPOS = mul(ModelViewProj, IN.center);\n" " // apparently HPOS cannot be read ! ridiculous. \n" " OUT.TEX3 = OUT.HPOS;//mul(ModelViewProj, IN.center);\n" "\n" "\n" " OUT.primarycolor.xyz = IN.color.xyz;\n" " OUT.primarycolor.w = ambient;\n" "\n" " //float4 lightVect = float4(600,600,640,1) - IN.center;\n" " float4 lightVect = float4(50,100,140,0);\n" " \n" " lightVect = normalize(lightVect);\n" "\n" " // xform light vector into eye space\n" " float4 eyeLightVec = lightVect;//mul(ModelViewIT, lightVect);\n" "\n" " // Range compress light vector to fit in a color\n" " OUT.secondarycolor.xyz = eyeLightVec.xyz * 0.5 + 0.5;\n" "\n" " return OUT;\n" "} // main;\n"; ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/HollowCylinderRenderer.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/HollowCylinderRendere0000644000175000017500000005762211006452675032447 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // HollowCylinderRenderer.cpp: implementation of the HollowCylinderRenderer class. // ////////////////////////////////////////////////////////////////////// #include "HollowCylinderRenderer.h" #include "GlobalCGContext.h" #include "Vector.h" #include "cgGLHollowCylinderVertexShader.h" #include "cgGLHollowCylinderFragmentShader.h" #include "MeshCylinderRenderer.h" using CCVImposterRenderer::HollowCylinderRenderer; bool HollowCylinderRenderer::m_UseGLFallback = false; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// HollowCylinderRenderer::HollowCylinderRenderer( MyExtensions* extensions ) { initDefaults( extensions ); } void HollowCylinderRenderer::initDefaults( MyExtensions* extensions ) { m_Initialized = false; m_NumberOfCylinders = 0; m_Extensions = extensions; m_VertexProgram = 0; m_FragmentProgram = 0; } HollowCylinderRenderer::~HollowCylinderRenderer() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); } void HollowCylinderRenderer::clear() { m_TextureCoord1.clearBuffer(); m_TextureCoord2.clearBuffer(); m_Color.clearBuffer(); m_Position.clearBuffer(); m_NumberOfCylinders = 0; } int HollowCylinderRenderer::getNum() const { return m_NumberOfCylinders; } void HollowCylinderRenderer::initRenderer( bool drawFunction ) { // without extensions we cannot operate at all if(!initExtensions()) { m_Initialized = false; fprintf(stderr, "ERROR: OpenGL extensions unavailable, update your graphics drivers.\n"); return; } // if FP30 isn't present we will use a different branch of every render method if(!initCG( drawFunction )) { fprintf(stderr, "WARNING: FP30 not found, falling back on GL Rendering.\n"); m_UseGLFallback = true; } m_Initialized = true; } void HollowCylinderRenderer::renderOnce() { // MESH RENDERING if(m_UseGLFallback) { MeshCylinderRenderer::DrawCylinderBuffer(m_Position, m_Color, m_TextureCoord1, m_TextureCoord2); } // CG RENDERING else { // rendering individually, not as a buffer because we need to send parameters which vary // per cylinder and there is no more space left in those arrays! int i; for( i=0; i<(int)m_NumberOfCylinders; i++ ) { int index = 16*i; float radius = m_Position.get(index+2); CCVOpenGLMath::Vector ePoint = CCVOpenGLMath::Vector( m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), 1 ); CCVOpenGLMath::Vector begPoint = CCVOpenGLMath::Vector( m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), 1 ); CCVOpenGLMath::Vector axis = ePoint - begPoint; float cylinderLength = axis.norm(); axis = axis.normalize(); cgGLSetParameter3f(m_CylinderDCs, axis[0], axis[1], axis[2]); cgGLSetParameter1f(m_LengthOfCylinder, cylinderLength); int c; for( c =0; c<2; c++ ) { cgGLSetParameter4f(m_EndPoint1, begPoint[0], begPoint[1], begPoint[2], radius); // point radius = radius * -1; glBegin( GL_QUADS ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); index += 4; m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); index += 4; m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); index += 4; m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE0_ARB, m_TextureCoord1.get(index+0), m_TextureCoord1.get(index+1), m_TextureCoord1.get(index+2), m_TextureCoord1.get(index+3) ); m_Extensions->glMultiTexCoord4dARB(GL_TEXTURE1_ARB, m_TextureCoord2.get(index+0), m_TextureCoord2.get(index+1), m_TextureCoord2.get(index+2), m_TextureCoord2.get(index+3) ); glColor4f(m_Color.get(index+0), m_Color.get(index+1), m_Color.get(index+2), m_Color.get(index+3) ); glVertex4f(m_Position.get(index+0), m_Position.get(index+1), m_Position.get(index+2), m_Position.get(index+3) ); glEnd(); index -= 12; } } } } void HollowCylinderRenderer::renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors ) { // MESH RENDERER if(m_UseGLFallback) { // bail if not initialized if (!m_Initialized) { return; } if (m_NumberOfCylinders==0) { // we are done return; } glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT); // // Set up for Stick rendering // cgGLEnableProfile(m_VertexProfile); // cgGLBindProgram(m_VertexProgram); // cgGLEnableProfile(m_FragmentProfile); // cgGLBindProgram(m_FragmentProgram); glDisable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); // cgGLEnableTextureParameter(m_NormalMapParam); // cgGLEnableTextureParameter(m_DepthMapParam); m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); // cgGLSetParameter4f(m_MainColorParam, 0.7f, 0.7f, 0.7f, 1.0f); // gray if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; iglSecondaryColor3fEXT(0.,0.,1.); cgGLSetParameter4f(m_MainColorParam, 0.7f, 0.7f, 0.7f, 1.0f); // gray if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; icalculateCylinderNormalMap(512); m_TextureDepthMap = new Texture(); m_TextureDepthMap->calculateCylinderDepthMap(512); cgGLSetTextureParameter(m_NormalMapParam, m_TextureNormalMap->getTextureID()); cgGLSetTextureParameter(m_DepthMapParam, m_TextureDepthMap->getTextureID()); return true; } bool HollowCylinderRenderer::initExtensions() { return true; } ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHelixVertexShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHelixVertexShader0000644000175000017500000001217111006452675032325 0ustar debiandebianconst char cgGLHelixVertexShader[] = "// this is the vertex program\n" "\n" "//#pragma bind appdata.position = ATTR0\n" "//#pragma bind appdata.normal = ATTR1\n" "\n" "struct appdata : application2vertex \n" "{\n" " float4 offsetRadius : POSITION;\n" " float4 p1 : TEXCOORD0;\n" " float4 p2 : TEXCOORD1;\n" " float4 color : COLOR0;\n" "};\n" "\n" "struct vfconn : vertex2fragment \n" "{\n" " float4 HPOS : POSITION;\n" " float4 TEX0 : TEXCOORD0;\n" " float4 TEX1 : TEXCOORD1;\n" " float4 TEX2 : TEXCOORD2;\n" " float4 TEX3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float4 remapTo01(float4 v, float4 low, float4 high) {\n" " return saturate((v - low)/(high-low));\n" "}\n" "\n" "vfconn main(appdata IN,\n" " uniform float4x4 ModelViewIT,\n" " uniform float4x4 ModelViewProj,\n" " uniform float4x4 Proj,\n" " uniform float4x4 ModelViewInverse,\n" " uniform float4x4 ModelView)\n" "{\n" " vfconn OUT;\n" "\n" " // eye_space_offset = radius * v[OPOS]\n" " float radius = IN.offsetRadius.z;\n" "\n" " // get vector from P1 to P2\n" " float4 axis = IN.p2 - IN.p1;\n" "\n" " float4 eye_space_axis = normalize(mul(ModelView, axis));\n" " float h = 1 / sqrt(1-eye_space_axis.z*eye_space_axis.z);\n" "\n" " //float4 eye_space_offset = radius * float4(IN.offset.xyz, 0.0);\n" " float4 unit_eye_space_offset = normalize(float4(eye_space_axis.y,-eye_space_axis.x , 0, 0));\n" "/*\n" " float4 eye_space_offset = unit_eye_space_offset * IN.offsetRadius.y * radius;\n" "\n" " if( IN.offsetRadius.x < 0.5 ) \n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * h*radius * eye_space_axis.z;\n" " }\n" " else\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z;\n" " }\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " // offsetRadius.x = 0 or 1 for points near p0 or p1. \n" " // obtain the output position in object space\n" " // assume that w is correct\n" " IN.p2 = IN.p1 + IN.offsetRadius.x*axis + object_space_offset;\n" "*/\n" "\n" "\n" "\n" " float4 eye_space_offset = unit_eye_space_offset * IN.offsetRadius.y * radius;\n" "\n" " if( IN.offsetRadius.x < 0.5 )// && eye_space_axis.z < 0 ) \n" " {\n" " if( eye_space_axis.z < 0 )\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * h*radius * eye_space_axis.z;\n" " }\n" " else\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * h*radius * eye_space_axis.z*-1;\n" " }\n" " }\n" " else\n" " {\n" " if( eye_space_axis.z < 0 )\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z;\n" "\n" " }\n" " else\n" " {\n" " eye_space_offset = eye_space_offset + eye_space_axis * -h*radius * eye_space_axis.z*-1;\n" " }\n" " }\n" "\n" " // object_space_offset = INV_MV * eye_space_offset\n" " float4 object_space_offset = mul(ModelViewInverse, eye_space_offset);\n" "\n" " // offsetRadius.x = 0 or 1 for points near p0 or p1. \n" " // obtain the output position in object space\n" " // assume that w is correct\n" " IN.p2 = IN.p1 + IN.offsetRadius.x*axis + object_space_offset;\n" "\n" "\n" "\n" "\n" " //---------------------------------------------\n" " // clip coordinates\n" " // IN.p2 has the position\n" " OUT.HPOS = mul(ModelViewProj, IN.p2);\n" " OUT.TEX1 = OUT.HPOS; // because HPOS is apparently not readable !\n" "\n" " OUT.primarycolor.xyzw = IN.color.xyzw;\n" "\n" " // calculate normal-space light vector\n" " // float4 lightVect = float4(00,100,140,1) - IN.p2;\n" " float4 lightVect = float4(50,100,140,0);\n" " lightVect = normalize(lightVect);\n" "\n" " OUT.TEX0 = float4(IN.offsetRadius.y*0.5+0.5,0,0,1);\n" " OUT.TEX0.y = 0.5;\n" "\n" "\n" " // xform light vector into eye space\n" " \n" " float4 eyeLightVec = lightVect; //mul(ModelViewIT, lightVect);\n" " eyeLightVec = float4(dot(unit_eye_space_offset, eyeLightVec), \n" " dot(eye_space_axis, eyeLightVec),\n" " dot(cross(unit_eye_space_offset.xyz, eye_space_axis.xyz), eyeLightVec.xyz),//eyeLightVec.z,\n" " 0);\n" " \n" " // Range compress light vector to fit in a color\n" " OUT.secondarycolor.xyz = eyeLightVec.xyz * 0.5 + 0.5;\n" "\n" " \n" " radius = radius * h;\n" "\n" " /* works ! going to remove the 1/2 optimization thing from here+fragment shader\n" " // z_scale = radius * PROJ[10];\n" " OUT.TEX2.x = radius * Proj[2].z*0.5;\n" " // z_bias = MVP[2] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[2], IN.p2)*0.5;\n" "\n" " // w_scale = radius * PROJ[11]\n" " OUT.TEX3.x = radius * Proj[3].z;\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX3.z = dot(ModelViewProj[3], IN.p2);\n" "\n" " OUT.TEX2.xz = OUT.TEX2.xz + OUT.TEX3.xz/2.0;\n" " */\n" " // z_scale = radius * PROJ[10];\n" " OUT.TEX2.x = radius * Proj[2].z;\n" " // z_bias = MVP[2] * center;\n" " OUT.TEX2.z = dot(ModelViewProj[2], IN.p2);\n" "\n" " // w_scale = radius * PROJ[11]\n" " OUT.TEX3.x = radius * Proj[3].z;\n" " // w_bias = MVP[3] * center;\n" " OUT.TEX3.z = dot(ModelViewProj[3], IN.p2);\n" "\n" " return OUT;\n" "} // main;\n"; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/Texture.h0000644000175000017500000000546511006452675030070 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // Texture.h: interface for the Texture class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_TEXTURE_H__BC94627F_0E50_4516_A138_B7E672BEDE4E__INCLUDED_) #define AFX_TEXTURE_H__BC94627F_0E50_4516_A138_B7E672BEDE4E__INCLUDED_ class MyExtensions; namespace CCVImposterRenderer { class Texture { public: Texture(); virtual ~Texture(); void loadPGM(const char* name); void loadPPM(const char* name); bool loadFunction(unsigned char* m_Data, int w, int h, int d); void calculateSphereOpacityAndNormalMap( int size ); void calculateNormalMap(unsigned int w, unsigned int h); bool calculateHelixOpacityMap(unsigned int w, unsigned int h); void calculateCylinderDepthMap(unsigned int w); void calculateCylinderNormalMap(unsigned int w); void calculateShadingLookupTable(int w, int h, double shininess); void calculateDepthMap(int w, int h); unsigned int getTextureID() const; void bindTexture( int dim ) const; protected: bool init3DTexture(); private: unsigned int m_TextureID; MyExtensions* m_Extensions; int m_Texture3dPresent; }; }; #endif // !defined(AFX_TEXTURE_H__BC94627F_0E50_4516_A138_B7E672BEDE4E__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/StickRenderer.h0000644000175000017500000001446211006452675031171 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // StickRenderer.h: interface for the StickRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_STICKRENDERER_H__55F98E43_5A95_4CB7_9F7D_B6ADBD4D0FA9__INCLUDED_) #define AFX_STICKRENDERER_H__55F98E43_5A95_4CB7_9F7D_B6ADBD4D0FA9__INCLUDED_ #include #include #include "Texture.h" #include "ExpandableBuffer.h" #include "MyExtensions.h" namespace CCVImposterRenderer { class StickRenderer { public: StickRenderer( MyExtensions* extensions ); virtual ~StickRenderer(); void clearSticks(); inline void addStick(float x1, float y1, float z1, float x2, float y2, float z2, float radius, float red1, float green1, float blue1, float red2, float green2, float blue2); int getNumSticks() const; void initRenderer( bool drawFunction ); void renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors ); static void forceMeshRendering(bool status) { m_UseGLFallback = status; } protected: bool initCG(bool drawFunction); bool initExtensions(); void initDefaults( MyExtensions* extensions ); bool m_Initialized; static bool m_UseGLFallback; // profiles CGprofile m_VertexProfile; CGprofile m_FragmentProfile; CGprogram m_VertexProgram; CGparameter m_ModelViewITParam; CGparameter m_ModelViewInverseParam; CGparameter m_ModelViewProjParam; CGparameter m_ModelViewParam; CGparameter m_ProjParam; CGprogram m_FragmentProgram; CGparameter m_MainColorParam; CGparameter m_NormalMapParam; CGparameter m_DepthMapParam; Texture* m_TextureNormalMap; Texture* m_TextureDepthMap; // the buffers ExpandableBuffer m_TextureCoord1; ExpandableBuffer m_TextureCoord2; ExpandableBuffer m_Position; ExpandableBuffer m_Color; unsigned int m_NumSticks; MyExtensions* m_Extensions; }; inline void StickRenderer::addStick( float x1, float y1, float z1, float x2, float y2, float z2, float radius, float red1, float green1, float blue1, float red2, float green2, float blue2) { double length = (x1-x2)*(x1-x2) + (y1-y2)*(y1-y2) + (z1-z2)*(z1-z2); if( length > 50 ) return; bool result = true; // position - stores the offsets result &= m_Position.add(0); result &= m_Position.add(-1); result &= m_Position.add(radius); result &= m_Position.add(1); result &= m_Position.add(0); result &= m_Position.add(1); result &= m_Position.add(radius); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(radius); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(-1); result &= m_Position.add(radius); result &= m_Position.add(1); // texturecoord - stores the 2 end points result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); // color result &= m_Color.add(red1); result &= m_Color.add(green1); result &= m_Color.add(blue1); result &= m_Color.add(0.4f); result &= m_Color.add(red1); result &= m_Color.add(green1); result &= m_Color.add(blue1); result &= m_Color.add(0.0f); result &= m_Color.add(red2); result &= m_Color.add(green2); result &= m_Color.add(blue2); result &= m_Color.add(0.0f); result &= m_Color.add(red2); result &= m_Color.add(green2); result &= m_Color.add(blue2); result &= m_Color.add(0.4f); if (!result) { printf("Warning, could not add Stick"); } m_NumSticks++; } }; #endif // !defined(AFX_STICKRENDERER_H__55F98E43_5A95_4CB7_9F7D_B6ADBD4D0FA9__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/BallRenderer.cpp0000644000175000017500000005103511006452675031316 0ustar debiandebian/***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // BallRenderer.cpp: implementation of the BallRenderer class. // ////////////////////////////////////////////////////////////////////// #include "BallRenderer.h" #include "PlainSphereRenderer.h" #include "FunctionSphereRenderer.h" #include "GlobalCGContext.h" #include "MeshSphereRenderer.h" #include static const int BatchSize = 10000; static const int TRI_STATE_WORKS = 0; static const int TRI_STATE_DOESNT_WORK= 1; static const int TRI_STATE_UNKNOWN = 2; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// using CCVImposterRenderer::BallRenderer; using CCVImposterRenderer::PlainSphereRenderer; using CCVImposterRenderer::FunctionSphereRenderer; bool BallRenderer::m_UseGLFallback = false; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// BallRenderer::BallRenderer() { initDefaults(); } void BallRenderer::initDefaults() { m_Initialized = false; m_UseGLFallback = false; m_NumBalls = 0; m_Dirty = true; m_NumBufferObjectsAllocated = 0; m_BufferObjects = 0; m_Extensions = 0; m_CGRequirements = TRI_STATE_UNKNOWN; m_OpenGLRequirements = TRI_STATE_UNKNOWN; m_ProgramsLoaded = TRI_STATE_UNKNOWN; m_PlainSphereRenderer = new PlainSphereRenderer(); m_FunctionSphereRenderer = 0; } BallRenderer::~BallRenderer() { deallocateBufferObjects(); delete m_Extensions; m_Extensions = 0; delete m_PlainSphereRenderer; m_PlainSphereRenderer = 0; delete m_FunctionSphereRenderer; m_FunctionSphereRenderer = 0; } void BallRenderer::initRenderer( bool drawFunction ) { // without extensions we cannot operate at all if(!initExtensions()) { m_Initialized = false; fprintf(stderr, "ERROR: OpenGL extensions unavailable, update your graphics drivers.\n"); return; } // if FP30 isn't present we will use a different branch of every render method if(!initCG()) { fprintf(stderr, "WARNING: FP30 not found, falling back on GL Rendering.\n"); m_UseGLFallback = true; } m_Initialized = true; } bool BallRenderer::initCG() { if( m_CGRequirements != TRI_STATE_UNKNOWN ) return true; // drastic, change if( !m_PlainSphereRenderer ) { m_CGRequirements = TRI_STATE_DOESNT_WORK; return false; } if( !m_PlainSphereRenderer->initCG()) { m_CGRequirements = TRI_STATE_DOESNT_WORK; return false; } bool ret = m_PlainSphereRenderer->loadProgram(); if( ret ) m_CGRequirements = TRI_STATE_WORKS; else m_CGRequirements = TRI_STATE_DOESNT_WORK; return ret; } bool BallRenderer::initExtensions() { delete m_Extensions; m_Extensions = 0; m_Extensions = new MyExtensions(); if( !m_Extensions->initExtensions( "GL_VERSION_1_2 " "GL_EXT_secondary_color " "GL_ARB_multitexture " "GL_ARB_vertex_buffer_object" )) { m_OpenGLRequirements = TRI_STATE_DOESNT_WORK; return false; } m_OpenGLRequirements = TRI_STATE_WORKS; return true; } void BallRenderer::clearBalls() { m_TextureCoord.clearBuffer(); m_Color.clearBuffer(); m_Position.clearBuffer(); m_NumBalls = 0; } int BallRenderer::getNumBalls() const { return m_NumBalls; } #define BUFFER_OFFSET(i) ((char *)NULL + (i)) void BallRenderer::prepareBuffers() { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. unsigned int remaining = m_NumBalls; unsigned int batch = BatchSize; unsigned int offset = 0; unsigned int currentBuffer = 0; allocateBufferObjects((m_NumBalls/BatchSize+1)*2); while (remaining>0) { unsigned int thisRender = (remainingglBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer]); m_Extensions->glBufferDataARB(GL_ARRAY_BUFFER_ARB, thisRender*4*4*sizeof(float), m_Position.getBuffer()+offset, GL_STATIC_DRAW_ARB); m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer+1]); m_Extensions->glBufferDataARB(GL_ARRAY_BUFFER_ARB, thisRender*4*4*sizeof(float), m_Color.getBuffer()+offset, GL_STATIC_DRAW_ARB); // decrement remaining remaining-=thisRender; // increment offset offset+=thisRender*4*4; currentBuffer+=2; } m_Dirty = false; } void BallRenderer::renderOnce() { // MESH RENDERING if(m_UseGLFallback) { MeshSphereRenderer::DrawSphereBuffer(m_Position, m_Color); } // CG RENDERING else { // try rendering in batches unsigned int remaining = m_NumBalls; unsigned int batch = BatchSize; unsigned int offset = 0; unsigned int currentBuffer = 0; while (remaining>0) { unsigned int thisRender = (remainingglBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer]); glVertexPointer(4, GL_FLOAT, 0, BUFFER_OFFSET(0)); m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer+1]); glColorPointer(4, GL_FLOAT, 0, BUFFER_OFFSET(0)); glDrawArrays(GL_QUADS, 0, thisRender*4); //glDrawRangeElements( GL_QUADS, 0 , thisRender*4-1 , thisRender*4 , GLenum type , const GLvoid *indices ); // decrement remaining remaining-=thisRender; // increment offset offset+=thisRender*4*4*sizeof(GLfloat); currentBuffer+=2; } } } void BallRenderer::renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors, float avgradius ) { // MESH RENDERER if(m_UseGLFallback) { if (!m_Initialized) return; if (m_NumBalls==0) return; glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT ); // if ( useFunctionOnSurface ) // { // if( !m_FunctionSphereRenderer ) return; // m_FunctionSphereRenderer->bindProgramAndParams(); // } // else // { // if( !m_PlainSphereRenderer ) return; // m_PlainSphereRenderer->bindProgramAndParams(); // } glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); srand(255); // needed to call rand to set colors for SS, CHAIN and PROTEINS ////// perform transformations if needed and repeat the rendering if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; ibindMatrices(); else m_PlainSphereRenderer->bindMatrices(); if( randomizeColors ) { float blue = (float)(rand() / ( RAND_MAX + 1.0f )); float red = (float)(rand() / ( RAND_MAX + 1.0f )); float green = (float)(rand() / ( RAND_MAX + 1.0f )); glColor4f( red, blue, green, avgradius ); } renderOnce(); glPopMatrix(); } } else { if ( useFunctionOnSurface ) m_FunctionSphereRenderer->bindMatrices(); else m_PlainSphereRenderer->bindMatrices(); renderOnce(); } // if ( useFunctionOnSurface ) // { // if( !m_FunctionSphereRenderer ) return; // m_FunctionSphereRenderer->unbindProgramAndParams(); // } // else // { // if( !m_PlainSphereRenderer ) return; // m_PlainSphereRenderer->unbindProgramAndParams(); // } m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glDisable(GL_BLEND); glDisable(GL_COLOR_SUM_ARB); glPopAttrib(); } // CG RENDERER else { if( useHardwareBuffer ) { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. } // bail if not initialized // WRONG SKVINAY, use glusphere or something like that if (!m_Initialized) return; if (m_NumBalls==0) return; if (m_Dirty) prepareBuffers(); glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT ); if ( useFunctionOnSurface ) { if( !m_FunctionSphereRenderer ) return; m_FunctionSphereRenderer->bindProgramAndParams(); } else { if( !m_PlainSphereRenderer ) return; m_PlainSphereRenderer->bindProgramAndParams(); } glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); glEnableClientState(GL_VERTEX_ARRAY); if( ! randomizeColors ) glEnableClientState(GL_COLOR_ARRAY); srand(255); // needed to call rand to set colors for SS, CHAIN and PROTEINS ////// perform transformations if needed and repeat the rendering if( rotations && translations && (numberOfTransformations>0) ) { int i; for( i=0; ibindMatrices(); else m_PlainSphereRenderer->bindMatrices(); if( randomizeColors ) { float blue = (float)(rand() / ( RAND_MAX + 1.0f )); float red = (float)(rand() / ( RAND_MAX + 1.0f )); float green = (float)(rand() / ( RAND_MAX + 1.0f )); glColor4f( red, blue, green, avgradius ); } renderOnce(); glPopMatrix(); } } else { if ( useFunctionOnSurface ) m_FunctionSphereRenderer->bindMatrices(); else m_PlainSphereRenderer->bindMatrices(); renderOnce(); } glDisableClientState(GL_VERTEX_ARRAY); if( ! randomizeColors ) glDisableClientState(GL_COLOR_ARRAY); if ( useFunctionOnSurface ) { if( !m_FunctionSphereRenderer ) return; m_FunctionSphereRenderer->unbindProgramAndParams(); } else { if( !m_PlainSphereRenderer ) return; m_PlainSphereRenderer->unbindProgramAndParams(); } m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glDisable(GL_BLEND); glDisable(GL_COLOR_SUM_ARB); glPopAttrib(); } } void BallRenderer::allocateBufferObjects(unsigned int num) { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. deallocateBufferObjects(); m_BufferObjects = new GLuint[num]; m_NumBufferObjectsAllocated = num; m_Extensions->glGenBuffersARB(num, m_BufferObjects); } void BallRenderer::deallocateBufferObjects() { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. if (m_BufferObjects) m_Extensions->glDeleteBuffersARB(m_NumBufferObjectsAllocated, m_BufferObjects); m_NumBufferObjectsAllocated = 0; delete [] m_BufferObjects; m_BufferObjects = 0; } bool BallRenderer::addFunction( unsigned char* data, double minx, double miny, double minz, double maxx, double maxy, double maxz, int width, int height, int depth) { if(m_UseGLFallback) { delete m_FunctionSphereRenderer; m_FunctionSphereRenderer = new FunctionSphereRenderer(); if( !m_FunctionSphereRenderer->initCG()) return false; if( !m_FunctionSphereRenderer->addFunction( data, minx, miny, minz, maxx, maxy, maxz, width, height, depth) ) return false; return m_FunctionSphereRenderer->fallbackLoadProgram(); } else { delete m_FunctionSphereRenderer; m_FunctionSphereRenderer = new FunctionSphereRenderer(); if( !m_FunctionSphereRenderer->initCG()) return false; if( !m_FunctionSphereRenderer->addFunction( data, minx, miny, minz, maxx, maxy, maxz, width, height, depth) ) return false; return m_FunctionSphereRenderer->loadProgram(); } } ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshCylinderRenderer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshCylinderRenderer.0000644000175000017500000000212411006453060032307 0ustar debiandebian/* * A fallback replacement for the CG-Impostor system currently used to draw Cylinders. * This class will read the CG-encoded data and interpret it to draw Mesh instances. * * Note that per-pixel effects like those provided by the shader are not feasible with this * system. * * m_strange@mail.utexas.edu * * */ #ifndef __MESHCYLINDERRENDERER_H__ #define __MESHCYLINDERRENDERER_H__ #if defined(__APPLE__) # include # include #else # include # include #endif #include #include "ExpandableBuffer.h" class MeshCylinderRenderer { public: /* this function uses gluCylinder to draw the actual components */ static void DrawCylinderBuffer(const ExpandableBuffer& position, const ExpandableBuffer& color, const ExpandableBuffer& textureCoord1, const ExpandableBuffer& textureCoord2); private: static GLUquadric *m_Quadric; static const int LEVEL_OF_DETAIL; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/ImposterRenderer.cpp0000644000175000017500000001271311006452675032246 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* Peter Djeu djeu@cs.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // ImposterRenderer.cpp: implementation of the ImposterRenderer class. // ////////////////////////////////////////////////////////////////////// #include "ImposterRenderer.h" #include "MyExtensions.h" #include #include ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// using CCVImposterRenderer::ImposterRenderer; using CCVImposterRenderer::BallRenderer; using CCVImposterRenderer::GaussianRenderer; using CCVImposterRenderer::StickRenderer; using CCVImposterRenderer::HelixRenderer; using CCVImposterRenderer::HollowCylinderRenderer; ImposterRenderer::ImposterRenderer() { // m_Extensions = new MyExtensions(); m_BallRenderer = new BallRenderer(); m_GaussianRenderer = new GaussianRenderer(); m_StickRenderer = new StickRenderer(&m_Extensions); m_HelixRenderer = new HelixRenderer(&m_Extensions); m_HollowCylinderRenderer = new HollowCylinderRenderer(&m_Extensions); initialized = false; m_ShaderContext = 0; } ImposterRenderer::~ImposterRenderer() { if( m_ShaderContext ) cgDestroyContext(m_ShaderContext); delete m_HollowCylinderRenderer; m_HollowCylinderRenderer = 0; delete m_HelixRenderer; m_HelixRenderer = 0; delete m_StickRenderer; m_StickRenderer = 0; delete m_GaussianRenderer; m_GaussianRenderer = 0; delete m_BallRenderer; m_BallRenderer = 0; // delete m_Extensions; m_Extensions = 0; } void cgErrorCallback(void) { CGerror LastError = cgGetError(); } void ImposterRenderer::initSubRenderers( bool drawFunction ) { m_BallRenderer->initRenderer( drawFunction ); m_GaussianRenderer->initRenderer( drawFunction ); m_StickRenderer->initRenderer( drawFunction ); m_HelixRenderer->initRenderer( drawFunction ); m_HollowCylinderRenderer->initRenderer( drawFunction ); } bool ImposterRenderer::initRenderer() { // dont need to return false, change SKVINAY cgSetErrorCallback(cgErrorCallback); if( !m_Extensions.initExtensions( "GL_VERSION_1_2 " "GL_EXT_secondary_color " "GL_ARB_multitexture " "GL_ARB_vertex_buffer_object" )) return false; initialized = true; return true; } void ImposterRenderer::renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors, float avgradius ) { m_BallRenderer->renderBuffer(useHardwareBuffer, useFunctionOnSurface, rotations, translations, numberOfTransformations, randomizeColors, avgradius); m_GaussianRenderer->renderBuffer(); m_StickRenderer->renderBuffer(useHardwareBuffer, useFunctionOnSurface, rotations, translations, numberOfTransformations, randomizeColors); m_HelixRenderer->renderBuffer(useHardwareBuffer, useFunctionOnSurface, rotations, translations, numberOfTransformations, randomizeColors); m_HollowCylinderRenderer->renderBuffer(useHardwareBuffer, useFunctionOnSurface, rotations, translations, numberOfTransformations, randomizeColors); } bool ImposterRenderer::addFunction( unsigned char* data, double minx, double miny, double minz, double maxx, double maxy, double maxz, int width, int height, int depth) { return m_BallRenderer->addFunction(data, minx, miny, minz, maxx, maxy, maxz, width, height, depth); } void ImposterRenderer::clear() { m_BallRenderer->clearBalls(); m_GaussianRenderer->clearGaussians(); m_StickRenderer->clearSticks(); m_HelixRenderer->clear(); m_HollowCylinderRenderer->clear(); } void ImposterRenderer::forceMeshRendering(bool status) { BallRenderer::forceMeshRendering(status); GaussianRenderer::forceMeshRendering(status); StickRenderer::forceMeshRendering(status); HelixRenderer::forceMeshRendering(status); HollowCylinderRenderer::forceMeshRendering(status); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/BallRenderer.h0000644000175000017500000001374611006452675030772 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // BallRenderer.h: interface for the BallRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_BALLRENDERER_H__18AC0DE6_49B9_4036_9221_63B5DF373C4B__INCLUDED_) #define AFX_BALLRENDERER_H__18AC0DE6_49B9_4036_9221_63B5DF373C4B__INCLUDED_ #include #include #include "ExpandableBuffer.h" #include "MyExtensions.h" namespace CCVImposterRenderer { class PlainSphereRenderer; class FunctionSphereRenderer; class BallRenderer { public: BallRenderer(); virtual ~BallRenderer(); void clearBalls(); inline void addBall(float x, float y, float z, float radius, float red, float green, float blue); int getNumBalls() const; void initRenderer( bool drawFunction ); void renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors, float avgradius ); bool addFunction( unsigned char* data, double minx, double miny, double minz, double maxx, double maxy, double maxz, int width, int height, int depth); static void forceMeshRendering(bool status) { m_UseGLFallback = status; } protected: bool initCG(); bool initExtensions(); void initDefaults(); void prepareBuffers(); void allocateBufferObjects(unsigned int num); void deallocateBufferObjects(); void renderOnce(); // the buffers ExpandableBuffer m_TextureCoord; ExpandableBuffer m_Position; ExpandableBuffer m_Color; bool m_Dirty; unsigned int m_NumBalls; unsigned int m_NumBufferObjectsAllocated; GLuint* m_BufferObjects; MyExtensions* m_Extensions; int m_CGRequirements; int m_OpenGLRequirements; bool m_Initialized; static bool m_UseGLFallback; int m_ProgramsLoaded; PlainSphereRenderer* m_PlainSphereRenderer; FunctionSphereRenderer* m_FunctionSphereRenderer; }; inline void BallRenderer::addBall(float x, float y, float z, float radius, float red, float green, float blue) { //if( x > 0 ) return; //if( y < 65 ) return; //red = 1; //green = 0; //blue = 0; /* static FILE* fp; static fileOpened = false; if( !fileOpened ) { fp = fopen("Atoms.txt", "a"); fileOpened = true; } fprintf( fp, "%f %f %f %f\n", x, y, z, radius ); */ /* { red = 0.5; green = 0; blue = 0.25; static int addedNumber = 0; if( addedNumber == 2 ) return; addedNumber++; x = 0 + addedNumber*2.0; y = 0; z = 0; radius = 2.0f; } */ m_Dirty = true; bool result = true; // position result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(0); result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(1); result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(2); result &= m_Position.add(x); result &= m_Position.add(y); result &= m_Position.add(z); result &= m_Position.add(3); // color result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.1f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.6f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.1f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(radius); //0.1f); // texturecoord/offset /* result &= m_TextureCoord.add(-1); result &= m_TextureCoord.add(-1); result &= m_TextureCoord.add(0.0); result &= m_TextureCoord.add(radius); result &= m_TextureCoord.add(1); result &= m_TextureCoord.add(-1); result &= m_TextureCoord.add(0.0); result &= m_TextureCoord.add(radius); result &= m_TextureCoord.add(1); result &= m_TextureCoord.add(1); result &= m_TextureCoord.add(0.0); result &= m_TextureCoord.add(radius); result &= m_TextureCoord.add(-1); result &= m_TextureCoord.add(1); result &= m_TextureCoord.add(0.0); result &= m_TextureCoord.add(radius); */ if (!result) { printf("Warning, could not add ball"); } m_NumBalls++; } }; #endif // !defined(AFX_BALLRENDERER_H__18AC0DE6_49B9_4036_9221_63B5DF373C4B__INCLUDED_) ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshSphereRenderer.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshSphereRenderer.cp0000644000175000017500000000377311006453060032322 0ustar debiandebian/* * A fallback replacement for the CG-Impostor system currently used to draw Spheres. * This class will read the CG-encoded data and interpret it to draw Mesh instances. * * Note that per-pixel effects like those provided by the shader are not feasible with this * system. * * m_strange@mail.utexas.edu * * */ #include "MeshSphereRenderer.h" #include "../UsefulMath/Vector.h" GLUquadric* MeshSphereRenderer::m_Quadric = 0; const int MeshSphereRenderer::MAX_LEVEL_OF_DETAIL = 10; const int MeshSphereRenderer::MIN_LEVEL_OF_DETAIL = 1; void MeshSphereRenderer::DrawSphereBuffer(const ExpandableBuffer& position, const ExpandableBuffer& color) { // NOTE: leaked, but this is a singleton if(m_Quadric == 0) { m_Quadric = gluNewQuadric(); } // we extract the centers and radii from the encoding that is usually passed to the CG program const int numBalls = position.getNumObjects()/16; for(int i=0; i # include #else # include # include #endif #include #include "ExpandableBuffer.h" class MeshSphereRenderer { public: /* this function uses gluSphere to draw the actual components */ static void DrawSphereBuffer(const ExpandableBuffer& position, const ExpandableBuffer& color); /* levelOfDetail refers to the slice/stack count used when drawing the sphere */ /* static void DrawSphere(float radius, int levelOfDetail); */ private: static GLUquadric *m_Quadric; static const int MIN_LEVEL_OF_DETAIL; static const int MAX_LEVEL_OF_DETAIL; /* VBO ids for vertex and normal data, respectively */ /* static GLuint m_SpherePositionBuffer[bufferObjectSize]; * static GLuint m_SphereNormalBuffer[bufferObjectSize]; */ /* NOTE: no longer using LOD */ /* clip bounds for LOD */ /* static const int MIN_LOD = 1; * static const int MAX_LOD = 20; * static const float LOD_PER_PIXEL; */ }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/sphereDrawing.cpp0000644000175000017500000000701211006452675031553 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* Ariel Shamir arik@ices.utexas.edu */ /* Peter Djeu djeu@cs.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // sphereDrawing.cpp: draws a unit sphere with a specifiable level of triangulation #include "sphereDrawing.h" #include #define XC (float).52573111 #define ZC (float).85065080 #define YC (float)0.0 static GLuint faces[20][3] = { {0,4,1},{0,9,4},{9,5,4},{4,5,8},{4,8,1}, {8,10,1},{8,3,10},{5,3,8},{5,2,3},{2,7,3}, {7,10,3},{7,6,10},{7,11,6},{11,0,6},{0,1,6}, {6,1,10},{9,0,11},{9,11,2},{9,2,5},{7,2,11} }; static GLfloat vdata[12][3] = { {-XC,YC,ZC},{XC,YC,ZC},{-XC,YC,-ZC},{XC,YC,-ZC}, {YC,ZC,XC},{YC,ZC,-XC},{YC,-ZC,XC},{YC,-ZC,-XC}, {ZC,XC,YC},{-ZC,XC,YC},{ZC,-XC,YC},{-ZC,-XC,YC} }; // Draw a triangulation void DrawCurve(float *v1, float *v2, float *v3, int s) { if (s == 0) { glNormal3fv(v1); glVertex3fv(v1); glNormal3fv(v2); glVertex3fv(v2); glNormal3fv(v3); glVertex3fv(v3); } else { float v12[3], v23[3], v13[3], l; v12[0] = (v1[0] + v2[0]); v12[1] = (v1[1] + v2[1]); v12[2] = (v1[2] + v2[2]); l = (float) sqrt(v12[0]*v12[0] + v12[1]*v12[1] + v12[2]*v12[2]); v12[0] /= l; v12[1] /= l; v12[2] /= l; v23[0] = (v2[0] + v3[0]); v23[1] = (v2[1] + v3[1]); v23[2] = (v2[2] + v3[2]); l = (float) sqrt(v23[0]*v23[0] + v23[1]*v23[1] + v23[2]*v23[2]); v23[0] /= l; v23[1] /= l; v23[2] /= l; v13[0] = (v1[0] + v3[0]); v13[1] = (v1[1] + v3[1]); v13[2] = (v1[2] + v3[2]); l = (float) sqrt(v13[0]*v13[0] + v13[1]*v13[1] + v13[2]*v13[2]); v13[0] /= l; v13[1] /= l; v13[2] /= l; DrawCurve(v1, v12, v13, s-1); DrawCurve(v2, v23, v12, s-1); DrawCurve(v3, v13, v23, s-1); DrawCurve(v12, v23, v13, s-1); } } // Draw a sphere using openGL. // Arg c specifies the level of refinement for the triangulated sphere, where 0 is the coarsest refinement. void CCVImposterRenderer::VoroDrawSphere(int c) { int i; glBegin(GL_TRIANGLES); for (i=0; i<20; i++) { DrawCurve(&vdata[faces[i][1]][0], &vdata[faces[i][0]][0], &vdata[faces[i][2]][0], c); } glEnd(); } ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/HollowCylinderRenderer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/HollowCylinderRendere0000644000175000017500000002134511006452675032440 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // HollowCylinderRenderer.h: interface for the HollowCylinderRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_HOLLOWCYLINDERRENDERER_H__022231BF_C467_4D2B_B5CC_006AB4B39E62__INCLUDED_) #define AFX_HOLLOWCYLINDERRENDERER_H__022231BF_C467_4D2B_B5CC_006AB4B39E62__INCLUDED_ #include #include #include "Texture.h" #include "ExpandableBuffer.h" #include "MyExtensions.h" namespace CCVImposterRenderer { class HollowCylinderRenderer { public: HollowCylinderRenderer( MyExtensions* extensions ); virtual ~HollowCylinderRenderer(); void clear(); inline void add(float x1, float y1, float z1, float x2, float y2, float z2, float radius, float red, float green, float blue); int getNum() const; void initRenderer( bool drawFunction ); void renderBuffer( bool useHardwareBuffer, bool useFunctionOnSurface, double* rotations, double* translations, int numberOfTransformations, bool randomizeColors ); static void forceMeshRendering(bool status) { m_UseGLFallback = status; } protected: bool initCG(bool drawFunction); bool initExtensions(); void initDefaults( MyExtensions* extensions ); void renderOnce(); bool m_Initialized; static bool m_UseGLFallback; // profiles CGprofile m_VertexProfile; CGprofile m_FragmentProfile; CGprogram m_VertexProgram; CGparameter m_ModelViewITParam; CGparameter m_ModelViewInverseParam; CGparameter m_ModelViewProjParam; CGparameter m_ModelViewParam; CGparameter m_ProjParam; CGprogram m_FragmentProgram; CGparameter m_MainColorParam; CGparameter m_NormalMapParam; CGparameter m_DepthMapParam; CGparameter m_ModelViewProjInverseParam; CGparameter m_CylinderDCs; CGparameter m_EndPoint1; CGparameter m_LengthOfCylinder; Texture* m_TextureNormalMap; Texture* m_TextureDepthMap; // the buffers ExpandableBuffer m_TextureCoord1; ExpandableBuffer m_TextureCoord2; ExpandableBuffer m_Position; ExpandableBuffer m_Color; unsigned int m_NumberOfCylinders; MyExtensions* m_Extensions; }; inline void HollowCylinderRenderer::add(float x1, float y1, float z1, float x2, float y2, float z2, float radius, float red, float green, float blue) { radius /= 2.0; /* { static int addedTwo = 0; if( addedTwo == 2 ) return; addedTwo++; double shift = 7; if( addedTwo == 1 ) { x1 = 13.0f-shift; y1 = -5.0f+shift-4; z1 = 15.0f; x2 = 4.0f-shift; y2 = 0.0f+shift-4; z2 = 1.0f; red = 1.0; green = 0.0; blue = 0.0; } else { x1 = 10.0f-shift; y1 = 0.0f+shift-4; z1 = 25.0f; x2 = 7.0f-shift; y2 = 0.0f+shift-4; z2 = -10.0f; red = 0.0; green = 1.0; blue = 0.0; } radius = 2.0f; } */ bool result = true; // position - stores the offsets result &= m_Position.add(0); result &= m_Position.add(-1); result &= m_Position.add(radius); result &= m_Position.add(1); result &= m_Position.add(0); result &= m_Position.add(1); result &= m_Position.add(radius); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(radius); result &= m_Position.add(1); result &= m_Position.add(1); result &= m_Position.add(-1); result &= m_Position.add(radius); result &= m_Position.add(1); // texturecoord - stores the 2 end points result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord1.add(x1); result &= m_TextureCoord1.add(y1); result &= m_TextureCoord1.add(z1); result &= m_TextureCoord1.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); result &= m_TextureCoord2.add(x2); result &= m_TextureCoord2.add(y2); result &= m_TextureCoord2.add(z2); result &= m_TextureCoord2.add(1); // color result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.4f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.0f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.0f); result &= m_Color.add(red); result &= m_Color.add(green); result &= m_Color.add(blue); result &= m_Color.add(0.4f); if (!result) { printf("Warning, could not add Hollow Cylinder"); } m_NumberOfCylinders++; } }; #endif // !defined(AFX_HOLLOWCYLINDERRENDERER_H__022231BF_C467_4D2B_B5CC_006AB4B39E62__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/GlobalCGContext.h0000644000175000017500000000441211006452675031376 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // GlobalCGContext.h: interface for the GlobalCGContext class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_GLOBALCGCONTEXT_H__37EBD53C_2758_4A18_9DD1_7FDF0DB7D705__INCLUDED_) #define AFX_GLOBALCGCONTEXT_H__37EBD53C_2758_4A18_9DD1_7FDF0DB7D705__INCLUDED_ #include namespace CCVImposterRenderer { class GlobalCGContext { public: virtual ~GlobalCGContext(); static CGcontext getCGContext(); protected: GlobalCGContext(); CGcontext m_ShaderContext; static void initGlobalPointer(); static void cgErrorCallback(void); static GlobalCGContext* ms_GlobalCGContext; }; }; #endif // !defined(AFX_GLOBALCGCONTEXT_H__37EBD53C_2758_4A18_9DD1_7FDF0DB7D705__INCLUDED_) ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHelixFragmentShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHelixFragmentShad0000644000175000017500000001105611006452675032265 0ustar debiandebianconst char cgGLHelixFragmentShader[] = "// this is the fragment program\n" "\n" "\n" "struct inputs\n" "{\n" " float4 HPOS : POSITION;\n" " float4 texcoord : TEXCOORD0;\n" " float4 texcoord1 : TEXCOORD1; // duplicate of HPOS to read it\n" " float4 texcoord2 : TEXCOORD2;\n" " float4 texcoord3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float3 expand(float3 vector)\n" "{\n" " return 2.0 * (vector - 0.5);\n" "}\n" "\n" "// register combiner vector normalization function\n" "float3 normalize(float3 vector)\n" "{\n" " float3 VdotV = dot(expand(vector), expand(vector));\n" " return (1-saturate(VdotV)) * (vector-0.5) + expand(vector);\n" "}\n" "\n" "float getOpacity(uniform float4x4 ModelViewProjInverse,\n" " float4 ndcPos,\n" " uniform float4 endPoint1,\n" " uniform float3 helixDCs,\n" " uniform float3 refVector,\n" " uniform sampler2D opacitymap,\n" " uniform float3 helixDCsCrossRefVector,\n" " uniform float lengthOfHelix)\n" "{\n" " float pitch = endPoint1.a;\n" " endPoint1.a = 1.0;\n" "\n" " // P be obj pos of frag\n" " // DCs be DCs of axis\n" " // P1 be one end point\n" " // P0 be a point on cylinder\n" " // P2 be point on axis closest to P\n" "\n" " // 1. Get obj pos of point P\n" " float4 P = mul(ModelViewProjInverse,ndcPos);\n" "\n" " // 2. t = (DCs . (P-P1)) / 1 ( 1 = DC.DC if DCs is normalized )\n" " float3 PminusP1 = (P-endPoint1).rgb;\n" " float y = dot(helixDCs, PminusP1);\n" "\n" " float opacity = 0.0;\n" "\n" " if( y >= 0 ) \n" " {\n" " if( y <= lengthOfHelix )\n" " {\n" " // 3. x = cos-1 [(P-P1-t*DCs) . (P0-P1)]\n" " float3 PVector = PminusP1-y*helixDCs;\n" " PVector = PVector / length(PVector);\n" " float x = acos(dot(PVector,refVector)); // theta lies in 0 to 180\n" "\n" " // take cross of ref vec, dcs. // sent in by program\n" " // see which side new vector lies on\n" " float side = dot( PVector, helixDCsCrossRefVector );\n" " // modify the theta to lie in 0 - 360\n" " if( side < 0 ) x = 2.0*3.1415926535897932384626433832795 - x;\n" " x = x / (2.0*3.1415926535897932384626433832795); // get answer from 0 - 1\n" " \n" " // H = endPoint1.a = pitch\n" " y = fmod( y, pitch ) / pitch;\n" "\n" " // 5. opacity = TEX2D( opacitymap, xy )\n" " opacity = tex2D(opacitymap, float2(x,y)).r;\n" "// opacity = 1.0;\n" " }\n" " }\n" "\n" " return opacity;\n" "}\n" "\n" "float4 main(inputs IN, out float depth: DEPTH,\n" " uniform float4 maincolor,\n" " uniform sampler1D normalmap,\n" " uniform sampler2D depthmap,\n" " uniform sampler2D opacitymap,\n" " uniform float4x4 ModelViewProjInverse,\n" " uniform float3 helixDCs,\n" " uniform float3 refVector,\n" " uniform float3 helixDCsCrossRefVector,\n" " uniform float4 endPoint1,\n" " uniform float lengthOfHelix) : COLOR\n" "{\n" " float4 normal = 2.0 * (tex1D(normalmap, IN.texcoord.x) - 0.5);\n" " \n" " IN.secondarycolor.rgb = normalize(IN.secondarycolor.rgb);\n" "\n" " float3 NdotL = dot(normal.rgb, IN.secondarycolor);\n" " float3 color = IN.primarycolor.rgb*(saturate(NdotL) + IN.primarycolor.w);\n" "\n" " // calculate reflection vector\n" " // R = 2 * (N * (N dot L) - L/2)\n" " // = 2 * N * (N dot L) - L\n" " float3 reflectVec = ((NdotL * normal.rgb) + (-0.5 * IN.secondarycolor)) * 2.0;\n" "\n" " // eye vector E = (0, 0, 1)\n" " // R dot E = (R.r*0 + R.g*0 + 1*R.b) = R.b\n" " float RdotE = saturate(reflectVec.b); // max(0, RdotE);\n" "\n" " // calculate specular as pow(RdotE, 16)\n" " float specular = pow(RdotE, 16); \n" " // add specular light contribution to final color\n" " color += specular;\n" " \n" " float3 depthVal;\n" " float z;\n" " float w;\n" " float4 ndcPos;\n" "\n" "\n" " depthVal = tex2D(depthmap, IN.texcoord.xy).rgb;\n" " // this endPoint.a is totally overloaded !\n" " if( endPoint1.a < 0.0 ) \n" " {\n" " depthVal.r = -1.0 * depthVal.r;\n" " endPoint1.a = -1.0 * endPoint1.a;\n" " color = color*0.5;\n" " }\n" " z = dot(IN.texcoord2.xyz, depthVal);\n" " w = dot(IN.texcoord3.xyz, depthVal);\n" " depth = (z / w);\n" " ndcPos = float4( IN.texcoord1.x, IN.texcoord1.y, depth, 1.0 );\n" "\n" " float opacity = getOpacity(ModelViewProjInverse,\n" " ndcPos,\n" " endPoint1,\n" " helixDCs,\n" " refVector,\n" " opacitymap,\n" " helixDCsCrossRefVector,\n" " lengthOfHelix);\n" " \n" " depth = depth*0.5 + 0.5;\n" " return float4(color, opacity);\n" "}\n" "\n" "\n" "// send in a helix opacity map\n" "// obtain the fragments rotation and offset on cylinder\n" "// get a mod of the offset\n" "// lookup opacity!\n"; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/GaussianRenderer.cpp0000644000175000017500000003740011006452675032216 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // GaussianRenderer.cpp: implementation of the GaussianRenderer class. // ////////////////////////////////////////////////////////////////////// #include "GaussianRenderer.h" #include "Texture.h" #include "GlobalCGContext.h" #include "cgGLVertexShader.h" #include "cgGLFragmentShader.h" #include "MeshSphereRenderer.h" #include static const int BatchSize = 10000; static const int TRI_STATE_WORKS = 0; static const int TRI_STATE_DOESNT_WORK= 1; static const int TRI_STATE_UNKNOWN = 2; using CCVImposterRenderer::GaussianRenderer; bool GaussianRenderer::m_UseGLFallback = false; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// GaussianRenderer::GaussianRenderer() { m_Initialized = false; m_NumGaussians = 0; m_Dirty = true; m_NumBufferObjectsAllocated = 0; m_BufferObjects = 0; m_Extensions = 0; m_CGRequirements = TRI_STATE_UNKNOWN; m_OpenGLRequirements = TRI_STATE_UNKNOWN; m_ProgramsLoaded = TRI_STATE_UNKNOWN; m_VertexProgram = 0; m_FragmentProgram = 0; } GaussianRenderer::~GaussianRenderer() { deallocateBufferObjects(); delete m_Extensions; m_Extensions = 0; } void GaussianRenderer::initRenderer( bool drawFunction ) { // without extensions we cannot operate at all if(!initExtensions()) { m_Initialized = false; fprintf(stderr, "ERROR: OpenGL extensions unavailable, update your graphics drivers.\n"); return; } // if FP30 isn't present we will use a different branch of every render method if(!initCG()) { fprintf(stderr, "WARNING: FP30 not found, falling back on GL Rendering.\n"); m_UseGLFallback = true; } m_Initialized = true; } bool GaussianRenderer::initCG() { if( m_CGRequirements != TRI_STATE_UNKNOWN ) return true; if ( cgGLIsProfileSupported(CG_PROFILE_VP20) ) m_VertexProfile = CG_PROFILE_VP20; else { m_CGRequirements = TRI_STATE_DOESNT_WORK; return false; } if ( cgGLIsProfileSupported(CG_PROFILE_FP30) ) m_FragmentProfile = CG_PROFILE_FP30; else { m_CGRequirements = TRI_STATE_DOESNT_WORK; return false; } m_CGRequirements = TRI_STATE_WORKS; bool ret = loadProgram(); if( ret ) m_CGRequirements = TRI_STATE_WORKS; else m_CGRequirements = TRI_STATE_DOESNT_WORK; return true; } bool GaussianRenderer::loadProgram() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); CGcontext context = GlobalCGContext::getCGContext(); // Create Vertex Program for Spheres // m_VertexProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLVertexShader.cg", m_VertexProfile, 0, 0); m_VertexProgram = cgCreateProgram(context, CG_SOURCE,cgGLVertexShader, m_VertexProfile, 0, 0 ); // Load Vertex Program cgGLLoadProgram(m_VertexProgram); // get parameter handles m_PositionParam = cgGetNamedParameter(m_VertexProgram, "IN.center"); m_ColorParam = cgGetNamedParameter(m_VertexProgram, "IN.color"); m_ModelViewITParam = cgGetNamedParameter(m_VertexProgram, "ModelViewIT"); m_ModelViewInverseParam = cgGetNamedParameter(m_VertexProgram, "ModelViewInverse"); m_ModelViewProjParam = cgGetNamedParameter(m_VertexProgram, "ModelViewProj"); m_ProjParam = cgGetNamedParameter(m_VertexProgram, "Proj"); if (!m_ModelViewITParam || !m_ModelViewProjParam || !m_ProjParam || !m_ColorParam || !m_PositionParam) return false; // Create Fragment Program // m_FragmentProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLFragmentShader.cg", m_FragmentProfile, 0, 0); m_FragmentProgram = cgCreateProgram(context, CG_SOURCE,cgGLFragmentShader, m_FragmentProfile, 0, 0 ); // Load Fragment Program cgGLLoadProgram(m_FragmentProgram); // get parameter handles m_MainColorParam = cgGetNamedParameter(m_FragmentProgram, "maincolor"); m_NormalMapParam = cgGetNamedParameter(m_FragmentProgram, "normalmap"); m_DepthMapParam = cgGetNamedParameter(m_FragmentProgram, "depthmap"); // prepare the textures m_TextureNormalMap = new Texture(); //m_TextureNormalMap->loadPGM("alphamask.pgm"); m_TextureNormalMap->calculateSphereOpacityAndNormalMap(512); m_TextureDepthMap = new Texture(); m_TextureDepthMap->calculateDepthMap(512,512); cgGLSetTextureParameter(m_NormalMapParam, m_TextureNormalMap->getTextureID()); cgGLSetTextureParameter(m_DepthMapParam, m_TextureDepthMap->getTextureID()); return true; } bool GaussianRenderer::initExtensions() { delete m_Extensions; m_Extensions = 0; m_Extensions = new MyExtensions(); if( !m_Extensions->initExtensions( "GL_VERSION_1_2 " "GL_EXT_secondary_color " "GL_ARB_multitexture " "GL_ARB_vertex_buffer_object" )) { m_OpenGLRequirements = TRI_STATE_DOESNT_WORK; return false; } m_OpenGLRequirements = TRI_STATE_WORKS; return true; } void GaussianRenderer::deallocateBufferObjects() { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. if (m_BufferObjects) m_Extensions->glDeleteBuffersARB(m_NumBufferObjectsAllocated, m_BufferObjects); m_NumBufferObjectsAllocated = 0; delete [] m_BufferObjects; m_BufferObjects = 0; } void GaussianRenderer::clearGaussians() { m_TextureCoord.clearBuffer(); m_Color.clearBuffer(); m_Position.clearBuffer(); m_NumGaussians = 0; } int GaussianRenderer::getNumGaussians() const { return m_NumGaussians; } #define BUFFER_OFFSET(i) ((char *)NULL + (i)) void GaussianRenderer::prepareBuffers() { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. unsigned int remaining = m_NumGaussians; unsigned int batch = BatchSize; unsigned int offset = 0; unsigned int currentBuffer = 0; allocateBufferObjects((m_NumGaussians/BatchSize+1)*2); while (remaining>0) { unsigned int thisRender = (remainingglBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer]); m_Extensions->glBufferDataARB(GL_ARRAY_BUFFER_ARB, thisRender*4*4*sizeof(float), m_Position.getBuffer()+offset, GL_STATIC_DRAW_ARB); m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer+1]); m_Extensions->glBufferDataARB(GL_ARRAY_BUFFER_ARB, thisRender*4*4*sizeof(float), m_Color.getBuffer()+offset, GL_STATIC_DRAW_ARB); // decrement remaining remaining-=thisRender; // increment offset offset+=thisRender*4*4; currentBuffer+=2; } m_Dirty = false; } void GaussianRenderer::renderOnce() { if(m_UseGLFallback) { MeshSphereRenderer::DrawSphereBuffer(m_Position, m_Color); } else { // try rendering in batches unsigned int remaining = m_NumGaussians; unsigned int batch = BatchSize; unsigned int offset = 0; unsigned int currentBuffer = 0; while (remaining>0) { unsigned int thisRender = (remainingglBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer]); glVertexPointer(4, GL_FLOAT, 0, BUFFER_OFFSET(0)); m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_BufferObjects[currentBuffer+1]); glColorPointer(4, GL_FLOAT, 0, BUFFER_OFFSET(0)); glDrawArrays(GL_QUADS, 0, thisRender*4); //glDrawRangeElements( GL_QUADS, 0 , thisRender*4-1 , thisRender*4 , GLenum type , const GLvoid *indices ); // decrement remaining remaining-=thisRender; // increment offset offset+=thisRender*4*4*sizeof(GLfloat); currentBuffer+=2; } } } void GaussianRenderer::renderBuffer() { if(m_UseGLFallback) { if (!m_Initialized) return; if (m_NumGaussians==0) return; glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT ); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); bindMatrices(); renderOnce(); m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glDisable(GL_CULL_FACE); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glDisable(GL_BLEND); glDisable(GL_COLOR_SUM_ARB); glPopAttrib(); } else { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // bail if not initialized // WRONG SKVINAY, use glusphere or something like that if (!m_Initialized) return; if (m_NumGaussians==0) return; if (m_Dirty) prepareBuffers(); glPushAttrib(GL_ENABLE_BIT | GL_CURRENT_BIT | GL_LIGHTING_BIT ); bindProgramAndParams(); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_ALPHA_TEST); glAlphaFunc(GL_GREATER, 0.5 ); glEnable(GL_COLOR_SUM_ARB); m_Extensions->glSecondaryColor3fEXT(0.,0.,1.); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); bindMatrices(); renderOnce(); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); unbindProgramAndParams(); m_Extensions->glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); glDisable(GL_BLEND); glDisable(GL_COLOR_SUM_ARB); glPopAttrib(); } } void GaussianRenderer::allocateBufferObjects(unsigned int num) { if( m_OpenGLRequirements == TRI_STATE_UNKNOWN ) { if( !initExtensions() ) return; } if( m_OpenGLRequirements == TRI_STATE_DOESNT_WORK ) return; // OK, buffers are present on this card. deallocateBufferObjects(); m_BufferObjects = new GLuint[num]; m_NumBufferObjectsAllocated = num; m_Extensions->glGenBuffersARB(num, m_BufferObjects); } bool GaussianRenderer::bindProgramAndParams() { // Set up for ball rendering cgGLEnableProfile(m_VertexProfile); cgGLBindProgram(m_VertexProgram); cgGLEnableProfile(m_FragmentProfile); cgGLBindProgram(m_FragmentProgram); cgGLEnableTextureParameter(m_NormalMapParam); cgGLEnableTextureParameter(m_DepthMapParam); cgGLSetParameter4f(m_MainColorParam, 1.0, 0.0, 0.0, 1.0); // red return true; } bool GaussianRenderer::unbindProgramAndParams() { cgGLDisableTextureParameter(m_NormalMapParam); cgGLDisableTextureParameter(m_DepthMapParam); cgGLDisableProfile(m_VertexProfile); cgGLDisableProfile(m_FragmentProfile); return true; } void GaussianRenderer::bindMatrices() { cgGLSetStateMatrixParameter(m_ModelViewITParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); cgGLSetStateMatrixParameter(m_ModelViewProjParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(m_ProjParam, CG_GL_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(m_ModelViewInverseParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/Texture.cpp0000644000175000017500000004165311006452675030422 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // Texture.cpp: implementation of the Texture class. // ////////////////////////////////////////////////////////////////////// #include "Texture.h" #include "MyExtensions.h" #ifdef _WIN32 #include #endif #include #include #include #include #include #include using CCVImposterRenderer::Texture; static const int TRI_STATE_WORKS = 0; static const int TRI_STATE_DOESNT_WORK= 1; static const int TRI_STATE_UNKNOWN = 2; void normalize(float* n) { float length = n[0]*n[0]+n[1]*n[1]+n[2]*n[2]; n[0] /= length; n[1] /= length; n[2] /= length; } float clamp_0_to_1(float x) { return (float)((fabs(x) - fabs(x-1.)) * .5 + .5); } Texture::Texture() { m_Texture3dPresent = TRI_STATE_UNKNOWN; m_Extensions = new MyExtensions(); m_TextureID = 0; glGenTextures(1, &m_TextureID); } bool Texture::init3DTexture() { if( m_Texture3dPresent != TRI_STATE_UNKNOWN ) { if( m_Texture3dPresent == TRI_STATE_WORKS ) return true; else return false; } if (!m_Extensions->initExtensions( "GL_VERSION_1_2 " // "GL_SGIS_texture_edge_clamp " "GL_EXT_texture3D") ) { m_Texture3dPresent = TRI_STATE_DOESNT_WORK; return false; } m_Texture3dPresent = TRI_STATE_WORKS; return true; } Texture::~Texture() { glDeleteTextures(1, &m_TextureID); delete m_Extensions; m_Extensions = 0; } void Texture::loadPGM(const char* name) { GLubyte* dest = 0; FILE* input; int w,h,max,i,j; char grey[1]; //GLubyte* vol; char buffer[200]; if ((input = fopen(name,"rb")) == 0) { printf("Cannot open file %s \n",name); exit(1); } /* read a line of input */ fgets(buffer,200,input); if (strncmp(buffer,"P5",2) != 0) { fprintf(stderr,"%s is not a binary PGM file \n",name); exit(1); } /* get second line, ignoring comments */ do { fgets(buffer,200,input); } while (strncmp(buffer,"#",1) == 0); if (sscanf(buffer,"%d %d",&w,&h) != 2) { fprintf(stderr,"can't read sizes! \n"); exit(1); } dest = new GLubyte[w*h*4]; /* third line, ignoring comments */ do { fgets(buffer,200,input); } while (strncmp(buffer,"#",1) == 0); if (sscanf(buffer,"%d",&max) != 1) { fprintf(stderr,"what about max size? \n"); exit(1); } // fprintf(stderr,"reading %d columns %d rows \n",w,h); int count; for (i=h-1; i>=0; i--) { for (j=0; j 1 ) { *(dest+i*size*4+j*4+3) = 0; } else { *(dest+i*size*4+j*4+3) = 255; } } } GLubyte* uip = dest; for(j=0; j < (int)size; j++) { float fj = 2*j/(size-1.f) - 1; for(int i=0; i < (int)size; i++) { float fi = 2*i/(size-1.f) - 1; float n[3]; n[0] = fi; n[1] = fj; n[2] = (float)(sqrt( 1 - fi*fi - fj*fj)); normalize(n); if(n[2] <= 0) { n[0] = 0; n[1] = 0; n[2] = 1; } *uip++ = (GLubyte)(n[0] * 127 + 128); *uip++ = (GLubyte)(n[1] * 127 + 128); *uip++ = (GLubyte)(n[2] * 127 + 128); uip++; } } bindTexture(2); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); gluBuild2DMipmaps(GL_TEXTURE_2D, 4, size, size, GL_RGBA, GL_UNSIGNED_BYTE, dest); delete [] dest; dest = 0; } /*void Texture::calculateSphereOpacityAndNormalMap( int size ) { GLfloat* dest = 0; int i,j; dest = new GLfloat[size*size*4]; for(j=0; j < size; j++) { float fj = 2*j/(size-1.f) - 1; for(i=0; i < size; i++) { float fi = 2*i/(size-1.f) - 1; if( fi*fi + fj*fj > 1 ) { *(dest+i*size*4+j*4+3) = 0; } else { *(dest+i*size*4+j*4+3) = (GLfloat)1.0; } } } GLfloat* uip = dest; for(j=0; j < (int)size; j++) { float fj = 2*j/(size-1.f) - 1; for(int i=0; i < (int)size; i++) { float fi = 2*i/(size-1.f) - 1; float n[3]; n[0] = fi; n[1] = fj; n[2] = sqrt( 1 - fi*fi - fj*fj); normalize(n); if(n[2] <= 0) { n[0] = 0; n[1] = 0; n[2] = 1; } *uip++ = (GLfloat)(n[0]);// * 0.5 + 1.0); *uip++ = (GLfloat)(n[1]);// * 0.5 + 1.0); *uip++ = (GLfloat)(n[2]);// * 0.5 + 1.0); uip++; } } bindTexture(2); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); gluBuild2DMipmaps(GL_TEXTURE_2D, 4, size, size, GL_RGBA, GL_FLOAT, dest); delete [] dest; dest = 0; }*/ void Texture::loadPPM(const char* name) { GLubyte* dest = 0; FILE* input; int w,h,max,i,j,k; char rgb[3]; //GLubyte* vol; char buffer[200]; if ((input = fopen(name,"rb")) == 0) { fprintf(stderr,"Cannot open file %s \n",name); exit(1); } /* read a line of input */ fgets(buffer,200,input); if (strncmp(buffer,"P6",2) != 0) { fprintf(stderr,"%s is not a binary PPM file \n",name); exit(1); } /* get second line, ignoring comments */ do { fgets(buffer,200,input); } while (strncmp(buffer,"#",1) == 0); if (sscanf(buffer,"%d %d",&w,&h) != 2) { fprintf(stderr,"can't read sizes! \n"); exit(1); } dest = new GLubyte[w*h*3]; /* third line, ignoring comments */ do { fgets(buffer,200,input); } while (strncmp(buffer,"#",1) == 0); if (sscanf(buffer,"%d",&max) != 1) { fprintf(stderr,"what about max size? \n"); exit(1); } // fprintf(stderr,"reading %d columns %d rows \n",w,h); int count; for (i=h-1; i>=0; i--) { for (j=0; jglTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_LUMINANCE, w, h, d, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, dest); // glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE_SGIS); //glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE_SGIS); //glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR); delete [] dest; dest = 0; // test for error error = glGetError(); if (error == GL_NO_ERROR) return true; else return false; } bool Texture::calculateHelixOpacityMap(unsigned int w, unsigned int h) { GLubyte* dest = 0; unsigned int i,j; dest = new GLubyte[w*h]; for( i=0; i= (int)h ) y = y - h; if( y >= (int)h ) { printf("what???\n"); } //if( y < h ) *(dest + (y)*w + i) = (GLubyte)255; } } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; // try loading the texture bindTexture(2); glTexImage2D(GL_TEXTURE_2D, 0, 1, w, h, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, dest); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); delete [] dest; dest = 0; // test for error error = glGetError(); if (error == GL_NO_ERROR) return true; else return false; } void Texture::calculateNormalMap(unsigned int w, unsigned int h) { GLshort* dest = new GLshort[w*h*2]; GLshort* sip = dest; GLubyte* rgbdest = new GLubyte[w*h*3]; GLubyte* uip = rgbdest; for(int j=0; j < (int)h; j++) { float fj = 2*j/(h-1.f) - 1; for(int i=0; i < (int)w; i++) { float fi = 2*i/(w-1.f) - 1; float n[3]; n[0] = fi; n[1] = fj; n[2] = (float)(sqrt( 1 - fi*fi - fj*fj)); normalize(n); if(n[2] <= 0) { n[0] = 0; n[1] = 0; n[2] = 1; *sip++ = (GLshort)(n[0] * 32767); *sip++ = (GLshort)(n[1] * 32767); *uip++ = (GLubyte)(n[0] * 127 + 128); *uip++ = (GLubyte)(n[1] * 127 + 128); *uip++ = (GLubyte)(n[2] * 127 + 128); } else { *sip++ = (GLshort)(n[0] * 32767); *sip++ = (GLshort)(n[1] * 32767); *uip++ = (GLubyte)(n[0] * 127 + 128); *uip++ = (GLubyte)(n[1] * 127 + 128); *uip++ = (GLubyte)(n[2] * 127 + 128); } } } bindTexture(2); /*glTexImage2D(GL_TEXTURE_2D, 0, GL_SIGNED_HILO_NV, w, h, 0, GL_HILO_NV, GL_SHORT, dest);*/ glTexImage2D(GL_TEXTURE_2D, 0, 3, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, rgbdest); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); delete [] dest; dest = 0; delete [] rgbdest; rgbdest = 0; } void Texture::calculateShadingLookupTable(int w, int h, double shininess) { GLubyte* rgbdest = new GLubyte[w*h*2]; GLubyte* uip = rgbdest; double fi, fj; for (int j=0; j 1 ) { *ip++ = 0;// outside circle, doesnt matter *ip++ = 0; } else { n[2] = clamp_0_to_1((float)(sqrt(1. - fi*fi - fj*fj))); normalize(n); *ip++ = (GLushort)(n[2] * 65535); // depth *ip++ = 0;//(GLushort)(/*n[2]*/1 * 65535); // not used } } } bindTexture(2); glTexImage2D(GL_TEXTURE_2D, 0, GL_HILO_NV, w, h, 0, GL_HILO_NV, GL_UNSIGNED_SHORT, img); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); delete [] img; img = 0; } void Texture::calculateCylinderNormalMap(unsigned int w) { GLubyte* rgbdest = new GLubyte[w*4]; GLubyte* uip = rgbdest; float a; float fj = 0; for(int i=0; i < (int)w; i++) { float fi = 2*i/(w-1.f) - 1; float n[3]; n[0] = fi; n[1] = fj; n[2] = (float)(sqrt( 1 - fi*fi - fj*fj)); a = 1.0; normalize(n); if(n[2] <= 0) { n[0] = 0; n[1] = 0; n[2] = 1; a = 0.0; } *uip++ = (GLubyte)(n[0] * 127 + 128); *uip++ = (GLubyte)(n[1] * 127 + 128); *uip++ = (GLubyte)(n[2] * 127 + 128); *uip++ = (GLubyte)(a*255); } bindTexture(1); glTexImage1D(GL_TEXTURE_1D, 0, 4, w, 0, GL_RGBA, GL_UNSIGNED_BYTE, rgbdest); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); delete [] rgbdest; rgbdest = 0; } void Texture::calculateCylinderDepthMap(unsigned int w) { unsigned int h = w; GLushort * img = new GLushort[w*h*2]; GLushort * ip = img; for(int j=0; j < (int)h; j++) { float fj =0; for(int i=0; i < (int)w; i++) { float fi = 2*i/(w-1.f) - 1; float n[3]; n[0] = fi; n[1] = fj; n[2] = clamp_0_to_1((float)(sqrt(1. - fi*fi - fj*fj))); normalize(n); *ip++ = (GLushort)(n[2] * 65535); // depth *ip++ = 0;//(GLushort)(/*n[2]*/1 * 65535); // not used } } bindTexture(2); glTexImage2D(GL_TEXTURE_2D, 0, GL_HILO_NV, w, h, 0, GL_HILO_NV, GL_UNSIGNED_SHORT, img); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); delete [] img; img = 0; } unsigned int Texture::getTextureID() const { return m_TextureID; } void Texture::bindTexture( int dim ) const { if( dim == 1 ) glBindTexture(GL_TEXTURE_1D, m_TextureID); if( dim == 2 ) glBindTexture(GL_TEXTURE_2D, m_TextureID); if( dim == 3 ) glBindTexture(GL_TEXTURE_3D, m_TextureID); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/MeshHelixRenderer.h0000644000175000017500000000230611006453060031761 0ustar debiandebian/* * A fallback replacement for the CG-Impostor system currently used to draw Helices. * This class will read the CG-encoded data and interpret it to draw Mesh instances. * * Note that per-pixel effects like those provided by the shader are not feasible with this * system. * * m_strange@mail.utexas.edu * * */ #ifndef __MESHHELIXRENDERER_H__ #define __MESHHELIXRENDERER_H__ #if defined(__APPLE__) # include # include #else # include # include #endif #include #include "ExpandableBuffer.h" class MeshHelixRenderer { public: /* this function uses gluHelix to draw the actual components */ static void DrawHelixBuffer(const ExpandableBuffer& position, const ExpandableBuffer& color, const ExpandableBuffer& textureCoord1, const ExpandableBuffer& textureCoord2); private: static GLUquadric *m_Quadric; static const int LEVEL_OF_DETAIL; static const GLfloat HEIGHT_STEP; static const GLfloat STRIP_HEIGHT; static const GLfloat HEIGHT_TO_COILS; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/GlobalCGContext.cpp0000644000175000017500000000520211006452675031727 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // GlobalCGContext.cpp: implementation of the GlobalCGContext class. // ////////////////////////////////////////////////////////////////////// #include "GlobalCGContext.h" #include using CCVImposterRenderer::GlobalCGContext; GlobalCGContext* GlobalCGContext::ms_GlobalCGContext = 0; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// GlobalCGContext::GlobalCGContext() { m_ShaderContext = cgCreateContext(); cgSetErrorCallback(cgErrorCallback); } GlobalCGContext::~GlobalCGContext() { cgDestroyContext(m_ShaderContext); } CGcontext GlobalCGContext::getCGContext() { if (ms_GlobalCGContext == 0) { initGlobalPointer(); return ms_GlobalCGContext->m_ShaderContext; } else { return ms_GlobalCGContext->m_ShaderContext; } } void GlobalCGContext::initGlobalPointer() { ms_GlobalCGContext = new GlobalCGContext; } void GlobalCGContext::cgErrorCallback(void) { const char* error = cgGetErrorString(cgGetError()); // qDebug("Error: %s", error); printf("Error: %s", error); } ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/PlainSphereRenderer.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/PlainSphereRenderer.c0000644000175000017500000001345111006452675032316 0ustar debiandebian /***********************************************************************************/ /* */ /* Copyright 2003 University of Texas at Austin */ /* Authors: Dr C Bajaj bajaj@cs.utexas.edu, */ /* S K Vinay skvinay@cs.utexas.edu */ /* Anthony Thane thanea@ices.utexas.edu */ /* */ /* 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 of the License, 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* */ /***********************************************************************************/ // PlainSphereRenderer.cpp: implementation of the PlainSphereRenderer class. // ////////////////////////////////////////////////////////////////////// #include "PlainSphereRenderer.h" #include "Texture.h" #include "GlobalCGContext.h" #include "cgGLVertexShader.h" #include "cgGLFragmentShader.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// using CCVImposterRenderer::PlainSphereRenderer; PlainSphereRenderer::PlainSphereRenderer() { m_VertexProgram = 0; m_FragmentProgram = 0; } PlainSphereRenderer::~PlainSphereRenderer() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); } bool PlainSphereRenderer::bindProgramAndParams() { // Set up for ball rendering cgGLEnableProfile(m_VertexProfile); cgGLBindProgram(m_VertexProgram); cgGLEnableProfile(m_FragmentProfile); cgGLBindProgram(m_FragmentProgram); cgGLEnableTextureParameter(m_NormalMapParam); cgGLEnableTextureParameter(m_DepthMapParam); cgGLSetParameter4f(m_MainColorParam, 1.0, 0.0, 0.0, 1.0); // red return true; } void PlainSphereRenderer::bindMatrices() { cgGLSetStateMatrixParameter(m_ModelViewITParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE_TRANSPOSE); cgGLSetStateMatrixParameter(m_ModelViewProjParam, CG_GL_MODELVIEW_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(m_ProjParam, CG_GL_PROJECTION_MATRIX, CG_GL_MATRIX_IDENTITY); cgGLSetStateMatrixParameter(m_ModelViewInverseParam, CG_GL_MODELVIEW_MATRIX, CG_GL_MATRIX_INVERSE); } bool PlainSphereRenderer::unbindProgramAndParams() { cgGLDisableTextureParameter(m_NormalMapParam); cgGLDisableTextureParameter(m_DepthMapParam); cgGLDisableProfile(m_VertexProfile); cgGLDisableProfile(m_FragmentProfile); return true; } bool PlainSphereRenderer::initCG() { if ( cgGLIsProfileSupported(CG_PROFILE_VP20) ) m_VertexProfile = CG_PROFILE_VP20; else return false; if ( cgGLIsProfileSupported(CG_PROFILE_FP30) ) m_FragmentProfile = CG_PROFILE_FP30; else return false; return true; } bool PlainSphereRenderer::loadProgram() { if( m_FragmentProgram ) cgDestroyProgram(m_FragmentProgram); if( m_VertexProgram ) cgDestroyProgram(m_VertexProgram); CGcontext context = GlobalCGContext::getCGContext(); // Create Vertex Program for Spheres // m_VertexProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLVertexShader.cg", m_VertexProfile, 0, 0); m_VertexProgram = cgCreateProgram(context, CG_SOURCE,cgGLVertexShader, m_VertexProfile, 0, 0 ); // Load Vertex Program cgGLLoadProgram(m_VertexProgram); // get parameter handles m_PositionParam = cgGetNamedParameter(m_VertexProgram, "IN.center"); m_ColorParam = cgGetNamedParameter(m_VertexProgram, "IN.color"); m_ModelViewITParam = cgGetNamedParameter(m_VertexProgram, "ModelViewIT"); m_ModelViewInverseParam = cgGetNamedParameter(m_VertexProgram, "ModelViewInverse"); m_ModelViewProjParam = cgGetNamedParameter(m_VertexProgram, "ModelViewProj"); m_ProjParam = cgGetNamedParameter(m_VertexProgram, "Proj"); if (!m_ModelViewITParam || !m_ModelViewProjParam || !m_ProjParam || !m_ColorParam || !m_PositionParam) return false; // Create Fragment Program // m_FragmentProgram = cgCreateProgramFromFile(context, CG_SOURCE, // "cgGLFragmentShader.cg", m_FragmentProfile, 0, 0); m_FragmentProgram = cgCreateProgram(context, CG_SOURCE,cgGLFragmentShader, m_FragmentProfile, 0, 0 ); // Load Fragment Program cgGLLoadProgram(m_FragmentProgram); // get parameter handles m_MainColorParam = cgGetNamedParameter(m_FragmentProgram, "maincolor"); m_NormalMapParam = cgGetNamedParameter(m_FragmentProgram, "normalmap"); m_DepthMapParam = cgGetNamedParameter(m_FragmentProgram, "depthmap"); // prepare the textures m_TextureNormalMap = new Texture(); //m_TextureNormalMap->loadPGM("alphamask.pgm"); m_TextureNormalMap->calculateSphereOpacityAndNormalMap(512); m_TextureDepthMap = new Texture(); m_TextureDepthMap->calculateDepthMap(512,512); cgGLSetTextureParameter(m_NormalMapParam, m_TextureNormalMap->getTextureID()); cgGLSetTextureParameter(m_DepthMapParam, m_TextureDepthMap->getTextureID()); return true; }mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLFragmentShader.h0000644000175000017500000000543311006452675032052 0ustar debiandebianconst char cgGLFragmentShader[] = "// this is the fragment program\n" "\n" "/*struct inputs\n" "{\n" " float4 color : COLOR0;\n" " float4 color1 : COLOR1;\n" " //float4 texcoord : TEXCOORD0;\n" " //float4 texcoord1 : TEXCOORD1;\n" "};*/\n" "\n" "struct inputs \n" "{\n" " float4 HPOS : POSITION;\n" " float4 texcoord : TEXCOORD0;\n" " float4 texcoord1 : TEXCOORD1;\n" " float4 texcoord2 : TEXCOORD2;\n" "// float4 texcoord3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float3 expand(float3 vector)\n" "{\n" " return 2.0 * (vector - 0.5);\n" "}\n" "\n" "// register combiner vector normalization function\n" "float3 normalize(float3 vector)\n" "{\n" " float3 VdotV = dot(expand(vector), expand(vector));\n" " return (1-saturate(VdotV)) * (vector-0.5) + expand(vector);\n" "}\n" "\n" "float4 main(inputs IN, out float depth: DEPTH,\n" " uniform float4 maincolor,\n" " uniform sampler2D normalmap,\n" " uniform sampler2D depthmap\n" " ) : COLOR\n" "{\n" "\n" " \n" " //float3 color = tex2D(alphamap, IN.texcoord.xy).xyz;\n" " float4 normal = 2.0 * (tex2D(normalmap, IN.texcoord.xy) - 0.5);\n" "\n" " //float3 normal = (tex2D(normalmap, IN.texcoord1.xy)).rgb;\n" " \n" " //IN.secondarycolor.rgb = 2.0*(IN.secondarycolor.rgb-0.5);\n" " IN.secondarycolor.rgb = normalize(IN.secondarycolor.rgb);\n" "\n" " float3 NdotL = dot(normal.rgb, IN.secondarycolor);\n" " float3 color = IN.primarycolor.rgb*(saturate(NdotL) + IN.primarycolor.w);\n" " //float3 diffuse = IN.col1.rgb;\n" " //float3 specular = (float3)lighting.a;\n" "\n" " // calculate reflection vector\n" " // R = 2 * (N * (N dot L) - L/2)\n" " // = 2 * N * (N dot L) - L\n" " float3 reflectVec = ((NdotL * normal.rgb) + (-0.5 * IN.secondarycolor)) * 2.0;\n" "\n" " // eye vector E = (0, 0, 1)\n" " // R dot E = (R.r*0 + R.g*0 + 1*R.b) = R.b\n" " float RdotE = saturate(reflectVec.b); // max(0, RdotE);\n" "\n" " // calculate specular as pow(RdotE, 16)\n" " float specular = pow(RdotE, 16); \n" "\n" " color += specular;\n" "\n" " //color = IN.primarycolor.rgb;\n" " // add specular light contribution to final color\n" " //finalColor += specular;\n" "\n" " //IN.color.rgb = IN.color.rgb * diffuse;// + specular;\n" " //IN.color.w = 1.0;\n" " float3 depthVal = tex2D(depthmap, IN.texcoord.xy).rgb;\n" "\n" " //depthVal.r = 0;\n" " // radius * depth + xxx * 0 + center * 1\n" " float z = dot(IN.texcoord1.xyz, depthVal);\n" " float w = dot(IN.texcoord2.xyz, depthVal);\n" " depth = (z / w);//*0.5+0.5; why do we need 0-1 ? isnt opengl -1 to 1 ?\n" "\n" " float4 outcolor = float4(color, normal.w);\n" " //float4 outcolor = float4(color, 1.0);\n" "\n" "\n" "\n" " //float4 outcolor = float4(color, opacity.x);\n" " //float4 outcolor = opacity;\n" " return outcolor;\n" "}\n"; ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHollowCylinderFragmentShader.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/ImposterRenderer/cgGLHollowCylinderFra0000644000175000017500000000644411006452675032324 0ustar debiandebianconst char cgGLHollowCylinderFragmentShader[] = "// this is the fragment program\n" "\n" "\n" "struct inputs\n" "{\n" " float4 HPOS : POSITION;\n" " float4 texcoord : TEXCOORD0;\n" " float4 texcoord1 : TEXCOORD1; // duplicate of HPOS to read it\n" " float4 texcoord2 : TEXCOORD2;\n" " float4 texcoord3 : TEXCOORD3;\n" " float4 primarycolor : COLOR0;\n" " float3 secondarycolor : COLOR1;\n" "};\n" "\n" "float3 expand(float3 vector)\n" "{\n" " return 2.0 * (vector - 0.5);\n" "}\n" "\n" "// register combiner vector normalization function\n" "float3 normalize(float3 vector)\n" "{\n" " float3 VdotV = dot(expand(vector), expand(vector));\n" " return (1-saturate(VdotV)) * (vector-0.5) + expand(vector);\n" "}\n" "\n" "float getOpacity(uniform float4x4 ModelViewProjInverse,\n" " float4 ndcPos,\n" " uniform float4 endPoint1,\n" " uniform float3 cylinderDCs,\n" " uniform float lengthOfCylinder)\n" "{\n" " // 1. Get obj pos of point P\n" " float4 P = mul(ModelViewProjInverse,ndcPos);\n" "\n" " // 2. t = (DCs . (P-P1)) / 1 ( 1 = DC.DC if DCs is normalized )\n" " float3 PminusP1 = (P-endPoint1).rgb;\n" " float y = dot(cylinderDCs, PminusP1);\n" "\n" " float opacity = 0.0;\n" "\n" " if( y >= 0 ) \n" " {\n" " if( y <= lengthOfCylinder )\n" " {\n" " opacity = 1.0;\n" " }\n" " }\n" "\n" " return opacity;\n" "}\n" "\n" "float4 main(inputs IN, out float depth: DEPTH,\n" " uniform float4 maincolor,\n" " uniform sampler1D normalmap,\n" " uniform sampler2D depthmap,\n" " uniform float4x4 ModelViewProjInverse,\n" " uniform float3 cylinderDCs,\n" " uniform float4 endPoint1,\n" " uniform float lengthOfCylinder) : COLOR\n" "{\n" " float4 normal = 2.0 * (tex1D(normalmap, IN.texcoord.x) - 0.5);\n" " \n" " IN.secondarycolor.rgb = normalize(IN.secondarycolor.rgb);\n" "\n" " float3 NdotL = dot(normal.rgb, IN.secondarycolor);\n" " float3 color = IN.primarycolor.rgb*(saturate(NdotL) + IN.primarycolor.w);\n" "\n" " // calculate reflection vector\n" " // R = 2 * (N * (N dot L) - L/2)\n" " // = 2 * N * (N dot L) - L\n" " float3 reflectVec = ((NdotL * normal.rgb) + (-0.5 * IN.secondarycolor)) * 2.0;\n" "\n" " // eye vector E = (0, 0, 1)\n" " // R dot E = (R.r*0 + R.g*0 + 1*R.b) = R.b\n" " float RdotE = saturate(reflectVec.b); // max(0, RdotE);\n" "\n" " // calculate specular as pow(RdotE, 16)\n" " float specular = pow(RdotE, 16); \n" " // add specular light contribution to final color\n" " color += specular;\n" " \n" " float3 depthVal;\n" " float z;\n" " float w;\n" " float4 ndcPos;\n" "\n" "\n" " depthVal = tex2D(depthmap, IN.texcoord.xy).rgb;\n" " // this endPoint.a is totally overloaded !\n" " if( endPoint1.a < 0.0 ) \n" " {\n" " depthVal.r = -1.0 * depthVal.r;\n" " endPoint1.a = -1.0 * endPoint1.a;\n" " color = color*0.5;\n" " }\n" " endPoint1.a = 1.0;\n" "\n" " z = dot(IN.texcoord2.xyz, depthVal);\n" " w = dot(IN.texcoord3.xyz, depthVal);\n" " depth = (z / w);\n" " ndcPos = float4( IN.texcoord1.x, IN.texcoord1.y, depth, 1.0 );\n" "\n" " float opacity = getOpacity(ModelViewProjInverse,\n" " ndcPos,\n" " endPoint1,\n" " cylinderDCs,\n" " lengthOfCylinder);\n" " \n" " depth = depth*0.5 + 0.5;\n" " return float4(color, opacity);\n" "}\n" "\n" "\n" "// obtain the fragments rotation and offset on cylinder\n" "// get a mod of the offset\n"; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/0000755000175000017500000000000012146213615025024 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/UsefulMath.dsp0000644000175000017500000000735411006452470027620 0ustar debiandebian# Microsoft Developer Studio Project File - Name="UsefulMath" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=UsefulMath - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "UsefulMath.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "UsefulMath.mak" CFG="UsefulMath - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "UsefulMath - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "UsefulMath - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "UsefulMath - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FD /c # SUBTRACT CPP /YX # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "UsefulMath - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "QT_DLL" /D "QT_THREAD_SUPPORT" /FD /GZ /c # SUBTRACT CPP /YX # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "UsefulMath - Win32 Release" # Name "UsefulMath - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\AreaVolumes.cpp # End Source File # Begin Source File SOURCE=.\LinearAlgebra.cpp # End Source File # Begin Source File SOURCE=.\Matrix.cpp # End Source File # Begin Source File SOURCE=.\Quaternion.cpp # End Source File # Begin Source File SOURCE=.\Ray.cpp # End Source File # Begin Source File SOURCE=.\TrilinearGrid.cpp # End Source File # Begin Source File SOURCE=.\Tuple.cpp # End Source File # Begin Source File SOURCE=.\Vector.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\AreaVolumes.h # End Source File # Begin Source File SOURCE=.\LinearAlgebra.h # End Source File # Begin Source File SOURCE=.\Matrix.h # End Source File # Begin Source File SOURCE=.\Quaternion.h # End Source File # Begin Source File SOURCE=.\Ray.h # End Source File # Begin Source File SOURCE=.\TrilinearGrid.h # End Source File # Begin Source File SOURCE=.\Tuple.h # End Source File # Begin Source File SOURCE=.\Vector.h # End Source File # End Group # Begin Source File SOURCE=.\UsefulMath.pro # End Source File # End Target # End Project mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Quaternion.cpp0000644000175000017500000002463111006452470027661 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Quaternion.cpp: implementation of the Quaternion class. // ////////////////////////////////////////////////////////////////////// #include "Quaternion.h" #include "Vector.h" #include "Ray.h" #include "Matrix.h" #include using CCVOpenGLMath::Tuple; using CCVOpenGLMath::Vector; using CCVOpenGLMath::Ray; using CCVOpenGLMath::Quaternion; using CCVOpenGLMath::Matrix; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Quaternion::Quaternion(float w, float x, float y, float z) : Tuple(w,x,y,z) { } Quaternion::Quaternion() : Tuple(1.0, 0.0, 0.0, 0.0) { } Quaternion::Quaternion(const Vector& vec) { p[0] = 0.0f; p[1] = vec[0]; p[2] = vec[1]; p[3] = vec[2]; } Quaternion::~Quaternion() { } Quaternion::Quaternion(const Quaternion& copy): Tuple(copy) { } Quaternion& Quaternion::operator=(const Quaternion& copy) { if (this!=©) { set(copy); } return *this; } Quaternion& Quaternion::set(float w, float x, float y, float z) { Tuple::set(w,x,y,z); return *this; } Quaternion& Quaternion::set(float* array) { Tuple::set(array); return *this; } Quaternion& Quaternion::set(const Quaternion& copy) { Tuple::set(copy); return *this; } Quaternion Quaternion::operator*(const Quaternion& quat) const { return Quaternion( p[0]*quat[0] - p[1]*quat[1] - p[2]*quat[2] - p[3]*quat[3], p[0]*quat[1] + p[1]*quat[0] + p[2]*quat[3] - p[3]*quat[2], p[0]*quat[2] - p[1]*quat[3] + p[2]*quat[0] + p[3]*quat[1], p[0]*quat[3] + p[1]*quat[2] - p[2]*quat[1] + p[3]*quat[0] ); } Quaternion& Quaternion::preMultiply(const Quaternion& quat) { return set(quat*(*this)); } Quaternion& Quaternion::postMultiply(const Quaternion& quat) { return set((*this)*quat); } Quaternion& Quaternion::rotate(float angle, float x, float y, float z) { return preMultiply(rotation(angle, x, y, z)); } Quaternion Quaternion::operator*(float scalar) const { return Quaternion(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]*scalar); } Quaternion& Quaternion::operator*=(float scalar) { return set(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]*scalar); } Quaternion Quaternion::operator/(float scalar) const { return Quaternion(p[0]/scalar, p[1]/scalar, p[2]/scalar, p[3]/scalar); } Quaternion& Quaternion::operator/=(float scalar) { return set(p[0]/scalar, p[1]/scalar, p[2]/scalar, p[3]/scalar); } Quaternion& Quaternion::normalize() { float n = norm(); return (*this)/=n; } Quaternion Quaternion::conjugate() const { return Quaternion(p[0], -p[1], -p[2], -p[3]); } Quaternion Quaternion::inverse() const { return conjugate()/norm(); } float Quaternion::norm() const { return p[0]*p[0]+p[1]*p[1]+p[2]*p[2]+p[3]*p[3]; } Vector Quaternion::applyRotation(const Vector& vec) const { Quaternion result = (*this) * Quaternion(vec) * (conjugate()); return Vector(result[1], result[2], result[3], vec[3]); } Ray Quaternion::applyRotation(const Ray& ray) const { Quaternion origin = (*this) * Quaternion(ray.m_Origin) * (conjugate()); Quaternion dir = (*this) * Quaternion(ray.m_Dir) * (conjugate()); return Ray(Vector(origin[1], origin[2], origin[3], ray.m_Origin[3]), Vector(dir[1], dir[2], dir[3], ray.m_Dir[3])); } Matrix Quaternion::buildMatrix() const { float w = p[0]; float x = p[1]; float y = p[2]; float z = p[3]; return Matrix( 1.0f-2.0f*y*y-2.0f*z*z, 2.0f*x*y-2.0f*w*z, 2.0f*x*z + 2.0f*w*y, 0.0f, 2.0f*x*y + 2.0f*w*z, 1.0f - 2.0f*x*x - 2.0f*z*z, 2.0f*y*z - 2.0f*w*x, 0.0f, 2.0f*x*z - 2.0f*w*y, 2.0f*y*z + 2.0f*w*x, 1.0f - 2.0f*x*x - 2.0f*y*y, 0.0f, 0.0f,0.0f,0.0f,1.0f ); } Quaternion Quaternion::rotation(float angle, float x, float y, float z) { float len = (float)sqrt(x*x+y*y+z*z); if (len!=0.0) { len = (float)(sin(angle/2.0f)/len); return Quaternion((float) cos(angle/2.0f), x*len, y*len, z*len); } else { return Quaternion(); } } Quaternion Quaternion::rotation(float angle, const Vector& axis) { float len = (float)sqrt(axis[0]*axis[0]+axis[1]*axis[1]+axis[2]*axis[2]); if (len!=0.0) { len = (float)(sin(angle/2.0f)/len); return Quaternion((float) cos(angle/2.0f), axis[0]*len, axis[1]*len, axis[2]*len); } else { return Quaternion(); } } Quaternion Quaternion::power( double scalar ) { float Dest[4]; double theta; if (p[0]>=0.9999f) { theta = 0; } else if (p[0]<=-0.9999f) { theta = 2.0*3.1415926535897932384626433832795; } else { theta = acos(p[0]); } double u[3]; double scale = p[1]*p[1]+p[2]*p[2]+p[3]*p[3]; scale = sqrt(scale); if (p[1]==0.0f && p[2]==0.0f && p[3]==0.0f) { u[0] = 0.0; u[1] = 0.0; u[2] = 0.0; } else { u[0] = p[1]/scale; u[1] = p[2]/scale; u[2] = p[3]/scale; } Dest[0] = (float)cos(scalar*theta); Dest[1] = (float)(u[0] * sin(scalar*theta)); Dest[2] = (float)(u[1] * sin(scalar*theta)); Dest[3] = (float)(u[2] * sin(scalar*theta)); return Quaternion( Dest[0], Dest[1], Dest[2], Dest[3] ); } // Quaternion Quaternion::slerp(const Quaternion& rhs, const float t) { // // http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/ // // v0 and v1 should be unit length or else // // something broken will happen. // Quaternion v0 = *this; // Quaternion v1 = rhs; // // Compute the cosine of the angle between the two vectors. // double dot = v0[0]*v1[0] + v0[1]*v1[1] + v0[2]*v1[2] + v0[3]*v1[3]; // const double DOT_THRESHOLD = 0.9995; // if (dot > DOT_THRESHOLD) { // // If the inputs are too close for comfort, linearly interpolate // // and normalize the result. // Quaternion result = v0 + ((v1 - v0)*t); // result.normalize(); // return result; // } // // Clamp(dot, -1, 1); // Robustness: Stay within domain of acos() // if(dot < -1) dot = -1; // if(dot > 1) dot = 1; // double theta_0 = acos(dot); // theta_0 = angle between input vectors // double theta = theta_0*t; // theta = angle between v0 and result // Quaternion v2 = v1 - v0*dot; // v2.normalize(); // { v0, v2 } is now an orthonormal basis // return (v0*cos(theta) + v2*sin(theta)); // } // Quaternion Quaternion::operator-(const Quaternion& rhs) { // Quaternion lhs = *this; // Quaternion rv (p[0] - rhs[0], // p[1] - rhs[1], // p[2] - rhs[2], // p[3] - rhs[3]); // return rv; // } // Quaternion Quaternion::operator+(const Quaternion& rhs) { // Quaternion lhs = *this; // Quaternion rv(p[0] + rhs[0], // p[1] + rhs[1], // p[2] + rhs[2], // p[3] + rhs[3]); // return rv; // } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Makefile0000644000175000017500000000177410240173436026474 0ustar debiandebianCC = g++ CCFLAGS = -Wall -O3 -finline # ----- Example programs -------------------------------------------------------- PROG_SRC = LinearAlgebra.cpp Matrix.cpp Vector.cpp Quaternion.cpp Ray.cpp Tuple.cpp PROG_OBJ = LinearAlgebra.o Matrix.o Vector.o Quaternion.o Ray.o Tuple.o TARGET = libUsefulMath.a # ------------------------------------------------------------------------------- all: Makefile $(TARGET) $(TARGET): $(PROG_OBJ) rm -f $(TARGET) ar cqs $(TARGET) $(PROG_OBJ) LinearAlgebra.o: LinearAlgebra.cpp $(CC) $(CCFLAGS) -c LinearAlgebra.cpp -o LinearAlgebra.o -I. Matrix.o: Matrix.cpp $(CC) $(CCFLAGS) -c Matrix.cpp -o Matrix.o -I. Vector.o: Vector.cpp $(CC) $(CCFLAGS) -c Vector.cpp -o Vector.o -I. Quaternion.o: Quaternion.cpp $(CC) $(CCFLAGS) -c Quaternion.cpp -o Quaternion.o -I. Ray.o: Ray.cpp $(CC) $(CCFLAGS) -c Ray.cpp -o Ray.o -I. Tuple.o: Tuple.cpp $(CC) $(CCFLAGS) -c Tuple.cpp -o Tuple.o -I. clean: rm $(TARGET) LinearAlgebra.o Matrix.o Vector.o Quaternion.o Ray.o Tuple.o mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Tuple.cpp0000644000175000017500000001151111006452470026616 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Tuple.cpp: implementation of the Tuple class. // ////////////////////////////////////////////////////////////////////// #include "Tuple.h" #include using CCVOpenGLMath::Tuple; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Tuple::Tuple(float x, float y, float z, float w) { set(x,y,z,w); } Tuple::Tuple() { set(0.0, 0.0, 0.0, 0.0); } Tuple::~Tuple() { } Tuple::Tuple(const Tuple& copy) { set(copy); } Tuple& Tuple::operator=(const Tuple& copy) { return set(copy); } Tuple& Tuple::set(float x, float y, float z, float w) { p[0] = x; p[1] = y; p[2] = z; p[3] = w; return *this; } Tuple& Tuple::set(float* array) { p[0] = array[0]; p[1] = array[1]; p[2] = array[2]; p[3] = array[3]; return *this; } Tuple& Tuple::set(const Tuple& copy) { if (this!=©) { p[0] = copy.p[0]; p[1] = copy.p[1]; p[2] = copy.p[2]; p[3] = copy.p[3]; } return *this; } float& Tuple::operator[](unsigned int i) { return p[i]; } const float& Tuple::operator[](unsigned int i) const { return p[i]; } void Tuple::print() const { printf("[%5.3lf %5.3lf %5.3lf %5.3lf ]\n", p[0], p[1], p[2], p[3] ); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Tuple.h0000644000175000017500000001056111006452470026267 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Tuple.h: interface for the Tuple class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_TUPLE_H__5AD4C604_B71A_4924_941A_15A0955C4E4E__INCLUDED_) #define AFX_TUPLE_H__5AD4C604_B71A_4924_941A_15A0955C4E4E__INCLUDED_ namespace CCVOpenGLMath { class Tuple { public: Tuple(float x, float y, float z, float w); Tuple(); virtual ~Tuple(); Tuple(const Tuple& copy); Tuple& operator=(const Tuple& copy); void print() const; Tuple& set(float x, float y, float z, float w); Tuple& set(float* array); Tuple& set(const Tuple& copy); float& operator[](unsigned int i); const float& operator[](unsigned int i) const; protected: float p[4]; }; }; #endif // !defined(AFX_TUPLE_H__5AD4C604_B71A_4924_941A_15A0955C4E4E__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Quaternion.h0000644000175000017500000001313011006452470027316 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Quaternion.h: interface for the Quaternion class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_QUATERNION_H__4A5485F3_5ADE_437D_A2C9_6D864A63C23B__INCLUDED_) #define AFX_QUATERNION_H__4A5485F3_5ADE_437D_A2C9_6D864A63C23B__INCLUDED_ #include "Tuple.h" namespace CCVOpenGLMath { class Vector; class Matrix; class Ray; class Quaternion : public Tuple { public: Quaternion(); virtual ~Quaternion(); Quaternion(const Quaternion& copy); Quaternion& operator=(const Quaternion& copy); Quaternion(float w, float x, float y, float z); Quaternion& set(float w, float x, float y, float z); Quaternion& set(float* array); Quaternion& set(const Quaternion& copy); Quaternion operator*(const Quaternion& quat) const; Quaternion operator*(float scalar) const; Quaternion& operator*=(float scalar); Quaternion operator/(float scalar) const; Quaternion& operator/=(float scalar); Quaternion& preMultiply(const Quaternion& quat); Quaternion& postMultiply(const Quaternion& quat); Quaternion& rotate(float angle, float x, float y, float z); Quaternion& normalize(); Quaternion conjugate() const; Quaternion inverse() const; float norm() const; Vector applyRotation(const Vector& vec) const; Ray applyRotation(const Ray& ray) const; Matrix buildMatrix() const; Quaternion power(double scalar); Quaternion slerp(const Quaternion& rhs, const float t) { Quaternion lhs = *this; Quaternion rv = lhs * ((lhs.inverse() * rhs).power(t)); return rv; } // Quaternion operator+(const Quaternion& rhs); // Quaternion operator-(const Quaternion& rhs); // Quaternion slerp(const Quaternion& rhs, const float t); static Quaternion rotation(float angle, float x, float y, float z); static Quaternion rotation(float angle, const Vector& axis); protected: explicit Quaternion(const Vector& vec); }; }; #endif // !defined(AFX_QUATERNION_H__4A5485F3_5ADE_437D_A2C9_6D864A63C23B__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Matrix.h0000644000175000017500000001275211006452470026446 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Matrix.h: interface for the Matrix class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_MATRIX_H__AB7171AD_869D_4D29_A455_5919551F0B67__INCLUDED_) #define AFX_MATRIX_H__AB7171AD_869D_4D29_A455_5919551F0B67__INCLUDED_ namespace CCVOpenGLMath { class Quaternion; class Vector; class Ray; class Matrix { public: Matrix(); Matrix( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ); Matrix(const Quaternion& quat); virtual ~Matrix(); Matrix(const Matrix& copy); Matrix& operator=(const Matrix& copy); void print() const; Matrix& set ( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ); Matrix& set(const Matrix& copy); Matrix& reset(); inline float get(int row, int column) const; const float* getMatrix() const; Vector operator*(const Vector& vec) const; Ray operator*(const Ray& ray) const; Matrix operator*(const Matrix& mat) const; Matrix& preMultiplication(const Matrix& mat); Matrix& postMultiplication(const Matrix& mat); Matrix inverse() const; Matrix inverseTranspose() const; Matrix transpose() const; float determinant() const; static Matrix rotationX(float angle); static Matrix rotationY(float angle); static Matrix rotationZ(float angle); static Matrix translation(float x, float y, float z); static Matrix translation(const Vector& vec); static Matrix scale(float x, float y, float z); protected: float m[16]; }; inline float Matrix::get(int row, int column) const { return m[row + column*4]; } }; #endif // !defined(AFX_MATRIX_H__AB7171AD_869D_4D29_A455_5919551F0B67__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Vector.h0000644000175000017500000001160511006452470026440 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Vector.h: interface for the Vector class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_VECTOR_H__C73C6BDB_2D75_4770_B86A_E3329C07A817__INCLUDED_) #define AFX_VECTOR_H__C73C6BDB_2D75_4770_B86A_E3329C07A817__INCLUDED_ #include "Tuple.h" namespace CCVOpenGLMath { class Vector : public Tuple { public: Vector(float x, float y, float z, float w); Vector(float* array); Vector(); virtual ~Vector(); Vector(const Vector& copy); Vector& operator=(const Vector& copy); Vector& set(float x, float y, float z, float w); Vector& set(float* array); Vector& set(const Vector& copy); Vector cross(const Vector& vec) const; Vector& crossEquals(const Vector& vec); float dot(const Vector& vec) const; Vector operator+(const Vector vec) const; Vector& operator+=(const Vector vec); Vector operator-(const Vector vec) const; Vector& operator-=(const Vector vec); Vector operator*(float scalar) const; Vector& operator*=(float scalar); Vector operator-() const; Vector& normalize(); float norm() const; bool isBad(); static Vector badVector(); static bool getCorners(double* min, double* max, CCVOpenGLMath::Vector* vCorner); virtual Vector* clone() const; }; }; #endif // !defined(AFX_VECTOR_H__C73C6BDB_2D75_4770_B86A_E3329C07A817__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Matrix.cpp0000644000175000017500000004102611006452470026775 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Matrix.cpp: implementation of the Matrix class. // ////////////////////////////////////////////////////////////////////// #include "Matrix.h" #include "Vector.h" #include "Ray.h" #include #include using CCVOpenGLMath::Vector; using CCVOpenGLMath::Ray; //using CCVOpenGLMath::Quaternion; using CCVOpenGLMath::Matrix; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Matrix::Matrix() { set(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix::Matrix( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ) { m[0]=m00; m[1]=m10; m[2]=m20; m[3]=m30; m[4]=m01; m[5]=m11; m[6]=m21; m[7]=m31; m[8]=m02; m[9]=m12; m[10]=m22; m[11]=m32; m[12]=m03; m[13]=m13; m[14]=m23; m[15]=m33; } Matrix::~Matrix() { } Matrix::Matrix(const Matrix& copy) { set(copy); } Matrix& Matrix::operator=(const Matrix& copy) { return set(copy); } Matrix& Matrix::set ( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ) { m[0]=m00; m[1]=m10; m[2]=m20; m[3]=m30; m[4]=m01; m[5]=m11; m[6]=m21; m[7]=m31; m[8]=m02; m[9]=m12; m[10]=m22; m[11]=m32; m[12]=m03; m[13]=m13; m[14]=m23; m[15]=m33; return *this; } Matrix& Matrix::set(const Matrix& copy) { if (this!=©) { set( copy.m[0], copy.m[4], copy.m[8], copy.m[12], copy.m[1], copy.m[5], copy.m[9], copy.m[13], copy.m[2], copy.m[6], copy.m[10], copy.m[14], copy.m[3], copy.m[7], copy.m[11], copy.m[15] ); } return *this; } Matrix& Matrix::reset() { set( 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0); return *this; } const float* Matrix::getMatrix() const { return m; } Vector Matrix::operator*(const Vector& vec) const { return Vector( m[0]*vec[0]+m[4]*vec[1]+m[8]*vec[2]+m[12]*vec[3], m[1]*vec[0]+m[5]*vec[1]+m[9]*vec[2]+m[13]*vec[3], m[2]*vec[0]+m[6]*vec[1]+m[10]*vec[2]+m[14]*vec[3], m[3]*vec[0]+m[7]*vec[1]+m[11]*vec[2]+m[15]*vec[3] ); } Ray Matrix::operator*(const Ray& ray) const { return Ray((*this)*ray.m_Origin, (*this)*ray.m_Dir); } Matrix Matrix::operator*(const Matrix& mat) const { return Matrix( m[0]*mat.m[0]+m[4]*mat.m[1]+m[8]*mat.m[2]+m[12]*mat.m[3], m[0]*mat.m[4]+m[4]*mat.m[5]+m[8]*mat.m[6]+m[12]*mat.m[7], m[0]*mat.m[8]+m[4]*mat.m[9]+m[8]*mat.m[10]+m[12]*mat.m[11], m[0]*mat.m[12]+m[4]*mat.m[13]+m[8]*mat.m[14]+m[12]*mat.m[15], m[1]*mat.m[0]+m[5]*mat.m[1]+m[9]*mat.m[2]+m[13]*mat.m[3], m[1]*mat.m[4]+m[5]*mat.m[5]+m[9]*mat.m[6]+m[13]*mat.m[7], m[1]*mat.m[8]+m[5]*mat.m[9]+m[9]*mat.m[10]+m[13]*mat.m[11], m[1]*mat.m[12]+m[5]*mat.m[13]+m[9]*mat.m[14]+m[13]*mat.m[15], m[2]*mat.m[0]+m[6]*mat.m[1]+m[10]*mat.m[2]+m[14]*mat.m[3], m[2]*mat.m[4]+m[6]*mat.m[5]+m[10]*mat.m[6]+m[14]*mat.m[7], m[2]*mat.m[8]+m[6]*mat.m[9]+m[10]*mat.m[10]+m[14]*mat.m[11], m[2]*mat.m[12]+m[6]*mat.m[13]+m[10]*mat.m[14]+m[14]*mat.m[15], m[3]*mat.m[0]+m[7]*mat.m[1]+m[11]*mat.m[2]+m[15]*mat.m[3], m[3]*mat.m[4]+m[7]*mat.m[5]+m[11]*mat.m[6]+m[15]*mat.m[7], m[3]*mat.m[8]+m[7]*mat.m[9]+m[11]*mat.m[10]+m[15]*mat.m[11], m[3]*mat.m[12]+m[7]*mat.m[13]+m[11]*mat.m[14]+m[15]*mat.m[15] ); } Matrix& Matrix::preMultiplication(const Matrix& mat) { return set(mat*(*this)); } Matrix& Matrix::postMultiplication(const Matrix& mat) { return set((*this)*mat); } Matrix Matrix::inverse() const { Matrix ret; float det = determinant(); if (det!=0.0) { ret.set( (get(1, 2)*get(2, 3)*get(3, 1) - get(1, 3)*get(2, 2)*get(3, 1) + get(1, 3)*get(2, 1)*get(3, 2) - get(1, 1)*get(2, 3)*get(3, 2) - get(1, 2)*get(2, 1)*get(3, 3) + get(1, 1)*get(2, 2)*get(3, 3))/det, (get(0, 3)*get(2, 2)*get(3, 1) - get(0, 2)*get(2, 3)*get(3, 1) - get(0, 3)*get(2, 1)*get(3, 2) + get(0, 1)*get(2, 3)*get(3, 2) + get(0, 2)*get(2, 1)*get(3, 3) - get(0, 1)*get(2, 2)*get(3, 3))/det, (get(0, 2)*get(1, 3)*get(3, 1) - get(0, 3)*get(1, 2)*get(3, 1) + get(0, 3)*get(1, 1)*get(3, 2) - get(0, 1)*get(1, 3)*get(3, 2) - get(0, 2)*get(1, 1)*get(3, 3) + get(0, 1)*get(1, 2)*get(3, 3))/det, (get(0, 3)*get(1, 2)*get(2, 1) - get(0, 2)*get(1, 3)*get(2, 1) - get(0, 3)*get(1, 1)*get(2, 2) + get(0, 1)*get(1, 3)*get(2, 2) + get(0, 2)*get(1, 1)*get(2, 3) - get(0, 1)*get(1, 2)*get(2, 3))/det, (get(1, 3)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 0)*get(3, 2) + get(1, 0)*get(2, 3)*get(3, 2) + get(1, 2)*get(2, 0)*get(3, 3) - get(1, 0)*get(2, 2)*get(3, 3))/det, (get(0, 2)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 2)*get(3, 0) + get(0, 3)*get(2, 0)*get(3, 2) - get(0, 0)*get(2, 3)*get(3, 2) - get(0, 2)*get(2, 0)*get(3, 3) + get(0, 0)*get(2, 2)*get(3, 3))/det, (get(0, 3)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 0)*get(3, 2) + get(0, 0)*get(1, 3)*get(3, 2) + get(0, 2)*get(1, 0)*get(3, 3) - get(0, 0)*get(1, 2)*get(3, 3))/det, (get(0, 2)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 2)*get(2, 0) + get(0, 3)*get(1, 0)*get(2, 2) - get(0, 0)*get(1, 3)*get(2, 2) - get(0, 2)*get(1, 0)*get(2, 3) + get(0, 0)*get(1, 2)*get(2, 3))/det, (get(1, 1)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 1)*get(3, 0) + get(1, 3)*get(2, 0)*get(3, 1) - get(1, 0)*get(2, 3)*get(3, 1) - get(1, 1)*get(2, 0)*get(3, 3) + get(1, 0)*get(2, 1)*get(3, 3))/det, (get(0, 3)*get(2, 1)*get(3, 0) - get(0, 1)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 0)*get(3, 1) + get(0, 0)*get(2, 3)*get(3, 1) + get(0, 1)*get(2, 0)*get(3, 3) - get(0, 0)*get(2, 1)*get(3, 3))/det, (get(0, 1)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 1)*get(3, 0) + get(0, 3)*get(1, 0)*get(3, 1) - get(0, 0)*get(1, 3)*get(3, 1) - get(0, 1)*get(1, 0)*get(3, 3) + get(0, 0)*get(1, 1)*get(3, 3))/det, (get(0, 3)*get(1, 1)*get(2, 0) - get(0, 1)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 0)*get(2, 1) + get(0, 0)*get(1, 3)*get(2, 1) + get(0, 1)*get(1, 0)*get(2, 3) - get(0, 0)*get(1, 1)*get(2, 3))/det, (get(1, 2)*get(2, 1)*get(3, 0) - get(1, 1)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 0)*get(3, 1) + get(1, 0)*get(2, 2)*get(3, 1) + get(1, 1)*get(2, 0)*get(3, 2) - get(1, 0)*get(2, 1)*get(3, 2))/det, (get(0, 1)*get(2, 2)*get(3, 0) - get(0, 2)*get(2, 1)*get(3, 0) + get(0, 2)*get(2, 0)*get(3, 1) - get(0, 0)*get(2, 2)*get(3, 1) - get(0, 1)*get(2, 0)*get(3, 2) + get(0, 0)*get(2, 1)*get(3, 2))/det, (get(0, 2)*get(1, 1)*get(3, 0) - get(0, 1)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 0)*get(3, 1) + get(0, 0)*get(1, 2)*get(3, 1) + get(0, 1)*get(1, 0)*get(3, 2) - get(0, 0)*get(1, 1)*get(3, 2))/det, (get(0, 1)*get(1, 2)*get(2, 0) - get(0, 2)*get(1, 1)*get(2, 0) + get(0, 2)*get(1, 0)*get(2, 1) - get(0, 0)*get(1, 2)*get(2, 1) - get(0, 1)*get(1, 0)*get(2, 2) + get(0, 0)*get(1, 1)*get(2, 2))/det ); } // if det==0.0, ret will be identity return ret; } Matrix Matrix::inverseTranspose() const { Matrix ret; float det = determinant(); if (det!=0.0) { ret.set( (get(1, 2)*get(2, 3)*get(3, 1) - get(1, 3)*get(2, 2)*get(3, 1) + get(1, 3)*get(2, 1)*get(3, 2) - get(1, 1)*get(2, 3)*get(3, 2) - get(1, 2)*get(2, 1)*get(3, 3) + get(1, 1)*get(2, 2)*get(3, 3))/det, (get(1, 3)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 0)*get(3, 2) + get(1, 0)*get(2, 3)*get(3, 2) + get(1, 2)*get(2, 0)*get(3, 3) - get(1, 0)*get(2, 2)*get(3, 3))/det, (get(1, 1)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 1)*get(3, 0) + get(1, 3)*get(2, 0)*get(3, 1) - get(1, 0)*get(2, 3)*get(3, 1) - get(1, 1)*get(2, 0)*get(3, 3) + get(1, 0)*get(2, 1)*get(3, 3))/det, (get(1, 2)*get(2, 1)*get(3, 0) - get(1, 1)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 0)*get(3, 1) + get(1, 0)*get(2, 2)*get(3, 1) + get(1, 1)*get(2, 0)*get(3, 2) - get(1, 0)*get(2, 1)*get(3, 2))/det, (get(0, 3)*get(2, 2)*get(3, 1) - get(0, 2)*get(2, 3)*get(3, 1) - get(0, 3)*get(2, 1)*get(3, 2) + get(0, 1)*get(2, 3)*get(3, 2) + get(0, 2)*get(2, 1)*get(3, 3) - get(0, 1)*get(2, 2)*get(3, 3))/det, (get(0, 2)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 2)*get(3, 0) + get(0, 3)*get(2, 0)*get(3, 2) - get(0, 0)*get(2, 3)*get(3, 2) - get(0, 2)*get(2, 0)*get(3, 3) + get(0, 0)*get(2, 2)*get(3, 3))/det, (get(0, 3)*get(2, 1)*get(3, 0) - get(0, 1)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 0)*get(3, 1) + get(0, 0)*get(2, 3)*get(3, 1) + get(0, 1)*get(2, 0)*get(3, 3) - get(0, 0)*get(2, 1)*get(3, 3))/det, (get(0, 1)*get(2, 2)*get(3, 0) - get(0, 2)*get(2, 1)*get(3, 0) + get(0, 2)*get(2, 0)*get(3, 1) - get(0, 0)*get(2, 2)*get(3, 1) - get(0, 1)*get(2, 0)*get(3, 2) + get(0, 0)*get(2, 1)*get(3, 2))/det, (get(0, 2)*get(1, 3)*get(3, 1) - get(0, 3)*get(1, 2)*get(3, 1) + get(0, 3)*get(1, 1)*get(3, 2) - get(0, 1)*get(1, 3)*get(3, 2) - get(0, 2)*get(1, 1)*get(3, 3) + get(0, 1)*get(1, 2)*get(3, 3))/det, (get(0, 3)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 0)*get(3, 2) + get(0, 0)*get(1, 3)*get(3, 2) + get(0, 2)*get(1, 0)*get(3, 3) - get(0, 0)*get(1, 2)*get(3, 3))/det, (get(0, 1)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 1)*get(3, 0) + get(0, 3)*get(1, 0)*get(3, 1) - get(0, 0)*get(1, 3)*get(3, 1) - get(0, 1)*get(1, 0)*get(3, 3) + get(0, 0)*get(1, 1)*get(3, 3))/det, (get(0, 2)*get(1, 1)*get(3, 0) - get(0, 1)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 0)*get(3, 1) + get(0, 0)*get(1, 2)*get(3, 1) + get(0, 1)*get(1, 0)*get(3, 2) - get(0, 0)*get(1, 1)*get(3, 2))/det, (get(0, 3)*get(1, 2)*get(2, 1) - get(0, 2)*get(1, 3)*get(2, 1) - get(0, 3)*get(1, 1)*get(2, 2) + get(0, 1)*get(1, 3)*get(2, 2) + get(0, 2)*get(1, 1)*get(2, 3) - get(0, 1)*get(1, 2)*get(2, 3))/det, (get(0, 2)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 2)*get(2, 0) + get(0, 3)*get(1, 0)*get(2, 2) - get(0, 0)*get(1, 3)*get(2, 2) - get(0, 2)*get(1, 0)*get(2, 3) + get(0, 0)*get(1, 2)*get(2, 3))/det, (get(0, 3)*get(1, 1)*get(2, 0) - get(0, 1)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 0)*get(2, 1) + get(0, 0)*get(1, 3)*get(2, 1) + get(0, 1)*get(1, 0)*get(2, 3) - get(0, 0)*get(1, 1)*get(2, 3))/det, (get(0, 1)*get(1, 2)*get(2, 0) - get(0, 2)*get(1, 1)*get(2, 0) + get(0, 2)*get(1, 0)*get(2, 1) - get(0, 0)*get(1, 2)*get(2, 1) - get(0, 1)*get(1, 0)*get(2, 2) + get(0, 0)*get(1, 1)*get(2, 2))/det ); } // if det==0.0, ret will be identity return ret; } Matrix Matrix::transpose() const { Matrix ret; ret.set( m[0],m[1],m[2],m[3], m[4],m[5],m[6],m[7], m[8],m[9],m[10],m[11], m[12],m[13],m[14],m[15]); return ret; } float Matrix::determinant() const { double ret; ret = get(0, 3) * get(1, 2) * get(2, 1) * get(3, 0)-get(0, 2) * get(1, 3) * get(2, 1) * get(3, 0)-get(0, 3) * get(1, 1) * get(2, 2) * get(3, 0)+get(0, 1) * get(1, 3) * get(2, 2) * get(3, 0)+ get(0, 2) * get(1, 1) * get(2, 3) * get(3, 0)-get(0, 1) * get(1, 2) * get(2, 3) * get(3, 0)-get(0, 3) * get(1, 2) * get(2, 0) * get(3, 1)+get(0, 2) * get(1, 3) * get(2, 0) * get(3, 1)+ get(0, 3) * get(1, 0) * get(2, 2) * get(3, 1)-get(0, 0) * get(1, 3) * get(2, 2) * get(3, 1)-get(0, 2) * get(1, 0) * get(2, 3) * get(3, 1)+get(0, 0) * get(1, 2) * get(2, 3) * get(3, 1)+ get(0, 3) * get(1, 1) * get(2, 0) * get(3, 2)-get(0, 1) * get(1, 3) * get(2, 0) * get(3, 2)-get(0, 3) * get(1, 0) * get(2, 1) * get(3, 2)+get(0, 0) * get(1, 3) * get(2, 1) * get(3, 2)+ get(0, 1) * get(1, 0) * get(2, 3) * get(3, 2)-get(0, 0) * get(1, 1) * get(2, 3) * get(3, 2)-get(0, 2) * get(1, 1) * get(2, 0) * get(3, 3)+get(0, 1) * get(1, 2) * get(2, 0) * get(3, 3)+ get(0, 2) * get(1, 0) * get(2, 1) * get(3, 3)-get(0, 0) * get(1, 2) * get(2, 1) * get(3, 3)-get(0, 1) * get(1, 0) * get(2, 2) * get(3, 3)+get(0, 0) * get(1, 1) * get(2, 2) * get(3, 3); return (float)ret; } Matrix Matrix::rotationX(float angle) { float ca = (float)cos(angle); float sa = (float)sin(angle); return Matrix(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, ca, sa, 0.0f, 0.0f, -sa, ca, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::rotationY(float angle) { float ca = (float)cos(angle); float sa = (float)sin(angle); return Matrix(ca, 0.0f, -sa, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, sa, 0.0f, ca, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::rotationZ(float angle) { float ca = (float)cos(angle); float sa = (float)sin(angle); return Matrix(ca, sa, 0.0f, 0.0f, -sa, ca, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::translation(float x, float y, float z) { return Matrix(1.0f, 0.0f, 0.0f, x, 0.0f, 1.0f, 0.0f, y, 0.0f, 0.0f, 1.0f, z, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::translation(const Vector& vec) { return Matrix(1.0f, 0.0f, 0.0f, vec[0], 0.0f, 1.0f, 0.0f, vec[1], 0.0f, 0.0f, 1.0f, vec[2], 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::scale(float x, float y, float z) { return Matrix(x, 0.0f, 0.0f, 0.0f, 0.0f, y, 0.0f, 0.0f, 0.0f, 0.0f, z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } void Matrix::print() const { printf("m=[%8.3lf %8.3lf %8.3lf %8.3lf ]\n [%8.3lf %8.3lf %8.3lf %8.3lf ]\n [%8.3lf %8.3lf %8.3lf %8.3lf ]\n [%8.3lf %8.3lf %8.3lf %8.3lf ]\n", m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15] ); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Ray.cpp0000644000175000017500000002054511006452470026267 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Ray.cpp: implementation of the Ray class. // ////////////////////////////////////////////////////////////////////// #include "Ray.h" #include #include using CCVOpenGLMath::Vector; using CCVOpenGLMath::Ray; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Ray::Ray() : m_Origin(0.0f, 0.0f, 0.0f, 1.0f), m_Dir(0.0f, 0.0f, 1.0f, 0.0f) { } Ray::Ray(const Vector& origin, const Vector& dir) : m_Origin(origin), m_Dir(dir) { } Ray::~Ray() { } Vector Ray::getPointOnRay(float t) const { return m_Origin+m_Dir*t; } float Ray::nearestTOnXAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); float distance = ray.distanceToXAxis(Origin); float t = -(ray.m_Origin[1]*ray.m_Dir[1] + ray.m_Origin[2]*ray.m_Dir[2])/ ((ray.m_Dir[1]*ray.m_Dir[1]+ray.m_Dir[2]*ray.m_Dir[2]) ); return t; } float Ray::nearestTOnYAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); float distance = ray.distanceToYAxis(Origin); float t = -(ray.m_Origin[0]*ray.m_Dir[0] + ray.m_Origin[2]*ray.m_Dir[2])/ ((ray.m_Dir[0]*ray.m_Dir[0]+ray.m_Dir[2]*ray.m_Dir[2])); return t; } float Ray::nearestTOnZAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); float distance = ray.distanceToZAxis(Origin); float t = -(ray.m_Origin[0]*ray.m_Dir[0] + ray.m_Origin[1]*ray.m_Dir[1])/ ((ray.m_Dir[1]*ray.m_Dir[1]+ray.m_Dir[0]*ray.m_Dir[0])); return t; } Vector Ray::nearestPointOnXAxis(Vector Origin) const { Origin[3] = 0; float t = nearestTOnXAxis(Origin); Vector result = getPointOnRay(t); // project to axis result[1] = Origin[1]; result[2] = Origin[2]; //result+=Origin; return result; } Vector Ray::nearestPointOnYAxis(Vector Origin) const { Origin[3] = 0; float t = nearestTOnYAxis(Origin); Vector result = getPointOnRay(t); // project to axis result[0] = Origin[0]; result[2] = Origin[2]; //result+=Origin; return result; } Vector Ray::nearestPointOnZAxis(Vector Origin) const { Origin[3] = 0; float t = nearestTOnZAxis(Origin); Vector result = getPointOnRay(t); // project to axis result[0] = Origin[0]; result[1] = Origin[1]; return result; } float Ray::distanceToXAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); return (float)fabs( ( ray.m_Origin[2]*ray.m_Dir[1]-ray.m_Origin[1]*m_Dir[2] ) / (float)sqrt( ray.m_Dir[2]*ray.m_Dir[2] + ray.m_Dir[1]*ray.m_Dir[1] ) ); } float Ray::distanceToYAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); return (float)fabs( ( ray.m_Origin[2]*ray.m_Dir[0]-ray.m_Origin[0]*m_Dir[2] ) / (float)sqrt( ray.m_Dir[2]*ray.m_Dir[2] + ray.m_Dir[0]*ray.m_Dir[0] ) ); } float Ray::distanceToZAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); return (float)fabs( ( ray.m_Origin[0]*ray.m_Dir[1]-ray.m_Origin[1]*m_Dir[0] ) / (float)sqrt( ray.m_Dir[0]*ray.m_Dir[0] + ray.m_Dir[1]*ray.m_Dir[1] ) ); } /*********************************************************/ /* */ /* Returns false if there is no intersection. */ /* Else, it returns both the points and the values of */ /* the parameter where the intersections took place. */ /* */ /*********************************************************/ bool Ray::intersectSphere( Vector center, float radius, Vector *point1, Vector* point2, float *distance1, float* distance2 ) { if( !point1 || !point2 ) return false; if( radius <= 0 ) return false; /// solve quadratic equation ///// //// A = Xd^2 + Yd^2 + Zd^2 //// B = 2 * (Xd * (X0 - Xc) + Yd * (Y0 - Yc) + Zd * (Z0 - Zc)) //// C = (X0 - Xc)^2 + (Y0 - Yc)^2 + (Z0 - Zc)^2 - Sr^2 /////////////////////////////////// float A = m_Dir[0]*m_Dir[0] + m_Dir[1]*m_Dir[1] + m_Dir[2]*m_Dir[2]; float B = 2* ( m_Dir[0] * (m_Origin[0] - center[0]) + m_Dir[1] * (m_Origin[1] - center[1]) + m_Dir[2] * (m_Origin[2] - center[2]) ); float C = (m_Origin[0] - center[0])*(m_Origin[0] - center[0]) + (m_Origin[1] - center[1])*(m_Origin[1] - center[1]) + (m_Origin[2] - center[2])*(m_Origin[2] - center[2]) - radius*radius; float discriminant = B*B - 4*A*C; if( discriminant < 0 ) return false; *distance1 = (float)(( -B - sqrt( discriminant ) ) / ( 4.0 * A * C )); *distance2 = (float)(( -B + sqrt( discriminant ) ) / ( 4.0 * A * C )); *point1 = m_Origin + m_Dir * (*distance1); *point2 = m_Origin + m_Dir * (*distance2); return true; } void Ray::print() { printf("[%5.3lf %5.3lf %5.3lf %5.3lf ] [%5.3lf %5.3lf %5.3lf %5.3lf ]\n", m_Origin[0], m_Origin[1], m_Origin[2], m_Origin[3], m_Dir[0], m_Dir[1], m_Dir[2], m_Dir[3] ); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/LinearAlgebra.cpp0000644000175000017500000003412011006452470030216 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // LinearAlgebra.cpp: implementation of the LinearAlgebra class. // ////////////////////////////////////////////////////////////////////// #include "LinearAlgebra.h" #include "Vector.h" #include using CCVOpenGLMath::Vector; using CCVOpenGLMath::LinearAlgebra; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// LinearAlgebra::LinearAlgebra() { } LinearAlgebra::~LinearAlgebra() { } bool LinearAlgebra::getCylinderFit( int n, double* x, double* y, double* z, Vector* p1, Vector* p2, double* radius ) { // 1: Get the best fit Lxy on xy projection of points // 2: Get the best fit Lxz on xz projection of points // 3: Combine Lxy, Lxz to get the axis of cylinder // 4. Define the centroid to be a point on the axis // 5. Let radius of cyinder be average of radii of above two fits // 6. Some how get the extent of the axis double m1, m2, c1, c2, radius1, radius2; // step 1: if( !leastSquares( n, x, y, &m1, &c1, &radius1 ) ) return false; // step 2: if( !leastSquares( n, x, z, &m2, &c2, &radius2 ) ) return false; // step 3: // sin t = sqrt( m^2 / ( 1 + m^2 ) ) // cos t = sqrt( 1 / ( 1 + m^2 ) ) // The dcs of line 1 are norm( cos t1, sin t1, 0, 0 ) // The dcs of line 2 are norm( cos t2, 0, sin t2, 0 ) // The DCs are norm( cost1+cos t2, sint1, sin t2, 0 ) double sin_t1 = sqrt( m1*m1 / ( 1.0 + m1*m1) ); double cos_t1 = sqrt( 1 / ( 1.0 + m1*m1 ) ); if( m1 < 0 ) sin_t1 = -1* sin_t1; double sin_t2 = sqrt( m2*m2 / ( 1.0 + m2*m2) ); double cos_t2 = sqrt( 1 / ( 1.0 + m2*m2 ) ); if( m2 < 0 ) sin_t2 = -1*sin_t2; Vector DCs = Vector( (float)(cos_t1+cos_t2), (float)sin_t1, (float)sin_t2, 0 ); DCs.normalize(); // step 4: double x0, y0, z0; // point on axis ( say centroid ) if( !mean( x, n, &x0 ) ) return false; if( !mean( y, n, &y0 ) ) return false; if( !mean( z, n, &z0 ) ) return false; // step 5: *radius = ( radius1 + radius2 ) * 0.5; // step 6: // minLen = maxLen = 0 // for each point P // get norm ( p-p0 ) // compute cos t = dot prod ( axis dcs with prev result ) // len = len( ( p-p0 ) * cos t ) // update minLen, maxLen with len and sign of cos t // end // Endpoints are center + max Len, center - minLen double minLen = 0, maxLen = 0; int i; for( i=0; i maxLen ) maxLen = len; } // Endpoints are center + max Len, center - minLen p1->set((float)(x0+minLen*DCs[0]), (float)(y0+minLen*DCs[1]), (float)(z0+minLen*DCs[2]), 1); p2->set((float)(x0+maxLen*DCs[0]), (float)(y0+maxLen*DCs[1]), (float)(z0+maxLen*DCs[2]), 1); return true; } bool LinearAlgebra::leastSquares( int n, double* x, double* y, double* m, double* c, double* radius ) { if( !x ) return false; if( !y ) return false; if( n < 1 ) return false; double xMean = 0, yMean = 0, xSumSquare = 0, ySumSquare = 0, xDotY = 0; if( !mean( x, n, &xMean ) ) return false; if( !mean( y, n, &yMean ) ) return false; if( !sumOfSquares( x, n, &xSumSquare ) ) return false; if( !sumOfSquares( y, n, &ySumSquare ) ) return false; if( !dotProduct( x, y, n, &xDotY ) ) return false; double denomM = n*xMean*yMean -xDotY; // hope it wont happen ! if( (denomM < 0.000000001) && (denomM > -0.000000001 ) ) return false; // slope is 90 degrees, not really a error ! double M = 0.5*( ySumSquare - n*yMean*yMean - xSumSquare + n*xMean*xMean ) / denomM; // quadratic has two solutions, get the least residual as the answer double m1 = -M + sqrt( M*M+1 ); double m2 = -M - sqrt( M*M+1 ); double c1 = yMean - m1 * xMean; double c2 = yMean - m2 * xMean; double residual1 = 0; double residual2 = 0; int i; double dist1 = 0, dist2 = 0; for( i=0; i 0 ) x[i] = posVal; } return true; } bool LinearAlgebra::correlate( double* x, double* y, int n, double* correlationCoefficient ) { if( !x ) return false; if( !y ) return false; if( n < 1 ) return false; if( !correlationCoefficient ) return false; double dotProd = 0; double norm1 = 0; double norm2 = 0; if( !dotProduct( x, y, n, &dotProd ) ) return false; if( !dotProduct( x, x, n, &norm1 ) ) return false; if( !dotProduct( y, y, n, &norm2 ) ) return false; norm1 = sqrt(norm1); norm2 = sqrt(norm2); double denom = norm1*norm2; if( denom < 0.0000000000000001 ) denom = 0.0000000000000001; *correlationCoefficient = dotProd / denom; return true; } ////////////// // // if usePositiveValues is true, take all positive x values and correlate with corresponding y values. // ////////////// bool LinearAlgebra::selectivelyCorrelate( double* x, int rangeToCorrelate, double* y, int n, double* correlationCoefficient ) { if( !x ) return false; if( !y ) return false; if( n < 1 ) return false; if( !correlationCoefficient ) return false; // find how many significant values are there in x. int nUseful = 0; if( rangeToCorrelate == 0 ) nUseful = n; else { int i; for( i=0; i0) && (x[i]>0) ) nUseful++; else if( (rangeToCorrelate<0) && (x[i]<0) ) nUseful++; } } if( nUseful <= 0 ) return false; double* xUseful = new double[nUseful]; double* yUseful = new double[nUseful]; // fill up above arrays { int c = 0; int i; for( i=0; i0) && (x[i]>0) ) { xUseful[c] = x[i]; yUseful[c] = y[i]; c++; } else if( (rangeToCorrelate<0) && (x[i]<0) ) { xUseful[c] = x[i]; yUseful[c] = y[i]; c++; } } } // correllate *correlationCoefficient = 0; if( !correlate( xUseful, yUseful, nUseful, correlationCoefficient ) ) return false; return true; } bool LinearAlgebra::solveSystem(double a11, double a12, double a13, double a21, double a22, double a23, double a31, double a32, double a33, double b1, double b2, double b3, double* x, double* y, double* z) { double determinant = a11*(a22*a33 - a32*a23) - a12*(a21*a33 - a31*a23) + a13*(a21*a32 - a31*a22); double xdeterminant = b1*(a22*a33 - a32*a23) - a12*(b2 *a33 - b3*a23) + a13*(b2 *a32 - b3 *a22); double ydeterminant = a11*(b2 *a33 - b3 *a23) - b1 *(a21*a33 - a31*a23) + a13*(a21*b3 - a31*b2); double zdeterminant = a11*(a22*b3 - a32*b2) - a12*(a21*b3 - a31*b2 ) + b1 *(a21*a32 - a31*a22); if( fabs(determinant) < 1e-10 ) return false; if( fabs(xdeterminant) < 1e-10 ) return false; if( fabs(ydeterminant) < 1e-10 ) return false; if( fabs(zdeterminant) < 1e-10 ) return false; *x = xdeterminant / determinant; *y = ydeterminant / determinant; *z = zdeterminant / determinant; return true; } bool LinearAlgebra::solve2x2System( double a11, double a12, double b1, double a21, double a22, double b2, double* x, double* y) { double d = a11*a22 - a12*a21; if( fabs(d) < 1e-10 ) return false; *x = (b1*a22 - b2*a12) / d; *y = (b2*a11 - b1*a21) / d; return true; } bool LinearAlgebra::solveDependentEquations( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* vec ) { // try making x as 1, find y and z. { vec[0] = 1; if( solve2x2System( c12, c13, -c11, c22, c23, -c21, &(vec[1]), &(vec[2]) ) ) return true; if( solve2x2System( c12, c13, -c11, c32, c33, -c31, &(vec[1]), &(vec[2]) ) ) return true; if( solve2x2System( c22, c23, -c21, c32, c33, -c31, &(vec[1]), &(vec[2]) ) ) return true; } // try making y as 1, find x and z. { vec[1] = 1; if( solve2x2System( c11, c13, -c12, c21, c23, -c22, &(vec[0]), &(vec[2]) ) ) return true; if( solve2x2System( c11, c13, -c12, c31, c33, -c32, &(vec[0]), &(vec[2]) ) ) return true; if( solve2x2System( c21, c23, -c22, c31, c33, -c32, &(vec[0]), &(vec[2]) ) ) return true; } // try making z as 1, find x and y. { vec[2] = 1; if( solve2x2System( c11, c12, -c13, c21, c22, -c23, &(vec[0]), &(vec[1]) ) ) return true; if( solve2x2System( c11, c12, -c13, c31, c32, -c33, &(vec[0]), &(vec[1]) ) ) return true; if( solve2x2System( c21, c22, -c23, c31, c32, -c33, &(vec[0]), &(vec[1]) ) ) return true; } return false; } bool LinearAlgebra::solveEigenSystem( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* k1Vec, double* k2Vec, double g1, double g2) { if( !solveDependentEquations(c11-g1, c12, c13, c21, c22-g1, c23, c31, c32, c33-g1, k1Vec) ) return false; if( !solveDependentEquations(c11-g2, c12, c13, c21, c22-g2, c23, c31, c32, c33-g2, k2Vec) ) return false; return true; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Ray.h0000644000175000017500000001173211006452470025732 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Ray.h: interface for the Ray class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_RAY_H__8760CFFE_A656_460F_A893_4C81FF806264__INCLUDED_) #define AFX_RAY_H__8760CFFE_A656_460F_A893_4C81FF806264__INCLUDED_ #include "Vector.h" namespace CCVOpenGLMath { class Ray { public: Ray(); Ray(const Vector& origin, const Vector& dir); virtual ~Ray(); void print(); Vector getPointOnRay(float t) const; float nearestTOnXAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float nearestTOnYAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float nearestTOnZAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; Vector nearestPointOnXAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; Vector nearestPointOnYAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; Vector nearestPointOnZAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float distanceToXAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float distanceToYAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float distanceToZAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; bool intersectSphere( Vector center, float radius, Vector *point1, Vector* point2, float *distance1, float* distance2 ); Vector m_Origin; Vector m_Dir; }; }; #endif // !defined(AFX_RAY_H__8760CFFE_A656_460F_A893_4C81FF806264__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/LinearAlgebra.h0000644000175000017500000001335411006452470027671 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // LinearAlgebra.h: interface for the LinearAlgebra class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_LINEARALGEBRA_H__AD644F94_D742_4858_A926_AC7E6964B1E2__INCLUDED_) #define AFX_LINEARALGEBRA_H__AD644F94_D742_4858_A926_AC7E6964B1E2__INCLUDED_ #include "Vector.h" namespace CCVOpenGLMath { class LinearAlgebra { public: LinearAlgebra(); virtual ~LinearAlgebra(); static bool getCylinderFit( int n, double* x, double* y, double* z, CCVOpenGLMath::Vector* p1, CCVOpenGLMath::Vector* p2, double* radius ); // fit a line y = mx + c minimizing the least squares norm. static bool leastSquares( int n, double* x, double* y, double* m, double* c, double* radius ); static bool mean( double* x, int n, double* mean ); static bool summation( double* x, int n, double* sum ); static bool sumOfSquares( double* x, int n, double* sumSquare ); static bool dotProduct( double* x, double* y, int n, double* dotProd ); static bool correlate( double* x, double* y, int n, double* correlationCoefficient ); static bool selectivelyCorrelate( double* x, int rangeToCorrelate, double* y, int n, double* correlationCoefficient ); static bool discretize( double* x, int n, double posVal, double negVal ); // solve ax=b static bool solveSystem(double a11, double a12, double a13, double a21, double a22, double a23, double a31, double a32, double a33, double b1, double b2, double b3, double* x, double* y, double* z); static bool solve2x2System( double a11, double a12, double b1, double a21, double a22, double b2, double* x, double* y); static bool solveEigenSystem( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* k1Vec, double* k2Vec, double g1, double g2); static bool solveDependentEquations( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* vec ); }; }; #endif // !defined(AFX_LINEARALGEBRA_H__AD644F94_D742_4858_A926_AC7E6964B1E2__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/src/UsefulMath/Vector.cpp0000644000175000017500000001603211006452470026772 0ustar debiandebian/*****************************************************************************/ /* ______________________ */ /* / _ _ _ _ _ _ _ _ _ _ _) */ /* ____ ____ _ / /__ __ _____ __ */ /* (_ _)( ___)( \/ /( \/ )( _ )( ) */ /* )( )__) ) ( ) ( )(_)( )(__ */ /* (__) (____)/ /\_)(_/\/\_)(_____)(____) */ /* _ _ _ _ __/ / */ /* (___________/ ___ ___ */ /* \ )| | ) _ _|\ ) */ /* --- \/ | | / |___| \_/ */ /* _/ */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* This software comes with a license. Using this code implies that you */ /* read, understood and agreed to all the terms and conditions in that */ /* license. */ /* */ /* We request that you agree to acknowledge the use of the software that */ /* results in any published work, including scientific papers, films and */ /* videotapes by citing the reference listed below */ /* */ /* C. Bajaj, P. Djeu, V. Siddavanahalli, A. Thane, */ /* Interactive Visual Exploration of Large Flexible Multi-component */ /* Molecular Complexes, */ /* Proc. of the Annual IEEE Visualization Conference, October 2004, */ /* Austin, Texas, IEEE Computer Society Press, pp. 243-250. */ /* */ /*****************************************************************************/ // Vector.cpp: implementation of the Vector class. // ////////////////////////////////////////////////////////////////////// #include "Vector.h" #include using CCVOpenGLMath::Tuple; using CCVOpenGLMath::Vector; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// const float EPS = 0.00001f; Vector::Vector(float x, float y, float z, float w) : Tuple(x,y,z,w) { } Vector::Vector() : Tuple() { } Vector::Vector(float* array) { set(array); } Vector::~Vector() { } Vector::Vector(const Vector& copy): Tuple(copy) { } Vector& Vector::operator=(const Vector& copy) { if (this!=©) { set(copy); } return *this; } Vector& Vector::set(float x, float y, float z, float w) { Tuple::set(x,y,z,w); return *this; } Vector& Vector::set(float* array) { Tuple::set(array); return *this; } Vector& Vector::set(const Vector& copy) { Tuple::set(copy); return *this; } Vector Vector::cross(const Vector& vec) const { return Vector( p[1]*vec[2] - p[2]*vec[1], p[2]*vec[0] - p[0]*vec[2], p[0]*vec[1] - p[1]*vec[0], 0.0f ); } Vector& Vector::crossEquals(const Vector& vec) { return set( p[1]*vec[2] - p[2]*vec[1], p[2]*vec[0] - p[0]*vec[2], p[0]*vec[1] - p[1]*vec[0], 0.0f ); } float Vector::dot(const Vector& vec) const { return p[0]*vec[0] + p[1]*vec[1] + p[2]*vec[2] + p[3]*vec[3]; } Vector Vector::operator+(const Vector vec) const { return Vector( p[0]+vec[0], p[1]+vec[1], p[2]+vec[2], p[3]+vec[3]); } Vector& Vector::operator+=(const Vector vec) { return set( p[0]+vec[0], p[1]+vec[1], p[2]+vec[2], p[3]+vec[3]); } Vector Vector::operator-(const Vector vec) const { return Vector( p[0]-vec[0], p[1]-vec[1], p[2]-vec[2], p[3]-vec[3]); } Vector& Vector::operator-=(const Vector vec) { return set( p[0]-vec[0], p[1]-vec[1], p[2]-vec[2], p[3]-vec[3]); } Vector Vector::operator*(float scalar) const { return Vector(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]); } Vector& Vector::operator*=(float scalar) { return set(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]); } Vector Vector::operator-() const { return Vector(-p[0], -p[1], -p[2], p[3]); } Vector& Vector::normalize() { if ((float)fabs(p[3])<=EPS) { float length = (float)sqrt((double)(p[0]*p[0]+p[1]*p[1]+p[2]*p[2])); return set(p[0]/length,p[1]/length,p[2]/length,0.0f); } else { return set(p[0]/p[3], p[1]/p[3], p[2]/p[3], 1.0f); } } float Vector::norm() const { return (float)sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]); } bool Vector::isBad() { return (p[0]==0.0f && p[1]==0.0f && p[2]==0.0f && p[3]==0.0f); } Vector Vector::badVector() { return Vector(0.0f, 0.0f, 0.0f, 0.0f); } Vector* Vector::clone() const { return new Vector(*this); } bool Vector::getCorners(double* min, double* max, CCVOpenGLMath::Vector* vCorner) { if( !min || !max || !vCorner ) return false; vCorner[0].set((float)min[0], (float)min[1], (float)min[2], 1.f); vCorner[1].set((float)max[0], (float)min[1], (float)min[2], 1.f); vCorner[2].set((float)min[0], (float)max[1], (float)min[2], 1.f); vCorner[3].set((float)max[0], (float)max[1], (float)min[2], 1.f); vCorner[4].set((float)min[0], (float)min[1], (float)max[2], 1.f); vCorner[5].set((float)max[0], (float)min[1], (float)max[2], 1.f); vCorner[6].set((float)min[0], (float)max[1], (float)max[2], 1.f); vCorner[7].set((float)max[0], (float)max[1], (float)max[2], 1.f); return true; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/setup.py0000755000175000017500000001315211006653176023703 0ustar debiandebian####################################################################### ### This file contains Distutil setup() for building UTimposter package ########################################################################### from distutils.core import setup, Extension from distutils.command.sdist import sdist from distutils.command.install_data import install_data from distutils.command.install_lib import install_lib from distutils.command.install import install from distutils.command.build import build from distutils.command.bdist_dumb import bdist_dumb from glob import glob import os, sys from os import path platform = sys.platform buildExt = True if platform in ('sunos5', 'linux2', 'irix6'): if not path.isfile("/usr/lib/libCgGL.so"): print "Warning: Can not build UTimposter extension. libCgGL.so is required" buildExt = False # # HACK: replace cc with CC (gcc with g++) CC_exe = 'CC' cc_exe = 'cc' if platform in ("linux2", "darwin"): CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to',`g[n]` if platform in ('sunos5', 'linux2', 'irix6', 'darwin'): sysconfig._init_posix = my_init_posix # Change the order of commands that are called by "build" # so that 'byuld_py' comes after 'build_ext'. In this case # 'build_py' will install python modules generated by # 'build_ext'. class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] # Overwrite the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. class modified_sdist(sdist): def prune_file_list(self): """ """ build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) packFullName = "UTpackages.UTimposter" packName = "UTimposter" # List of the python packages to be included in this distribution. # sdist does not go recursively into subpackages so they need to be # explicitly listed. # From these packages only the python modules will be taken packages = [packFullName, packFullName+".Tests"] # libImposterRenderer.a imposter_source_files = ["BallRenderer.cpp", "FunctionSphereRenderer.cpp", "GaussianRenderer.cpp", "GlobalCGContext.cpp", "HelixRenderer.cpp", "HollowCylinderRenderer.cpp", "ImposterRenderer.cpp", "MeshCylinderRenderer.cpp", "MeshHelixRenderer.cpp", "MeshSphereRenderer.cpp", "PlainSphereRenderer.cpp", "sphereDrawing.cpp", "StickRenderer.cpp", "Texture.cpp"] for i in range(len(imposter_source_files)): imposter_source_files[i] = path.join("src", "ImposterRenderer", imposter_source_files[i]) source_include = [path.join("src", "ImposterRenderer"), path.join("src", "UsefulMath"), path.join("src", "OpenGL_Viewer")] import numpy numpy_include = numpy.get_include() source_include.append(numpy_include) #libUsefulMath.a math_source_files = ["LinearAlgebra.cpp", "Matrix.cpp", "Vector.cpp", "Quaternion.cpp", "Ray.cpp", "Tuple.cpp"] for i in range(len(math_source_files)): math_source_files[i] = path.join("src", "UsefulMath", math_source_files[i]) #libOpenGL_Viewer.a viewer_source_files = [path.join("src", "OpenGL_Viewer", "MyExtensions.cpp")] # describe the extensions: # _utimposterrend.so* imposter_libs = {'posix': [ "GL", "GLU", "CgGL"], 'nt': ['OPENGL32', "CgGL", "GLU"]}.get( os.name, []) imposter_includes = source_include imposter_ext = [Extension ( "_utimposterrend", [path.join(packName, "utimposter.i"),], include_dirs = imposter_includes, libraries = imposter_libs, extra_compile_args = []), ] # description of what is going to be included in the distribution and # installed. dist = setup (name = packFullName, version = '1.0', description = "Volume Rendering Library python package", author = 'Molecular Graphics Laboratory', author_email = 'mgltools@scripps.edu', download_url = 'http://www.scripps.edu/~sanner/software/packager.html', url = 'http://www.scripps.edu/~sanner/software/index.html', packages = packages, package_dir = {packFullName: packName}, libraries = [('ImposterRenderer', {'sources': imposter_source_files, 'include_dirs': source_include} ), ('OpenGL_Viewer', {'sources': viewer_source_files, 'include_dirs': source_include} ), ("UsefulMath", {'sources': math_source_files, 'include_dirs': source_include})] , ext_modules = imposter_ext, ext_package = packFullName, cmdclass = {'sdist': modified_sdist, 'build': modified_build, }, ) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/README0000644000175000017500000000274510260340633023044 0ustar debiandebianThis module builds a python extension of the GlutImposterRenderer library developed in Chandrajit Bajaj's group at UT Austin (http://ccvweb.csres.utexas.edu/software). This distribution contains source code of the library. Cg toolkit is required for building this library (can be downloaded from http://developer.nvidia.com/object/cg_toolkit.html). Distutils are used to wrap the library with SWIG (version 1.3.20 or higher), build the C++ libraries and build the python extension (_utimposterrend.so). To build and install the extension: python2.4 setup.py install This will: - build static libraries libImposterRenderer.a, libOpenGL_Viewer.a, libUsefulMath.a in ./build/temp.; - generate a python shadow class module utimposterrend.py in ./build/lib./UTpackages/UTimposter - build _utimposterrend.so in ./build/lib./UTpackages/UTimposter; - copy the UTimposter package from ./build/lib./UTpackages to sys.exec_prefix/lib/python2.4/site-packages/UTpackages; The install command can be called with the following options: --install-platlib=INSTALL_DIR installs the UTimposter package in INSTALL_DIR/UTpackages --no-compile do not compile .py to .pyc Example: python2.4 setup.py install --install-platlib=/home/myname/myinstalldir To build the extension only: python2.4 setup.py build To build source distribution: python2.4 setup.py sdist To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/UTimposter/0000755000175000017500000000000012146213607024274 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/UTimposter/Tests/0000755000175000017500000000000012146213607025376 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/UTimposter/Tests/__init__.py0000644000175000017500000000001510240173437027502 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/UTimposter/Tests/test.py0000644000175000017500000001452610240452660026734 0ustar debiandebiantry: from opengltk.OpenGL.GL import * from opengltk.OpenGL.GLUT import * from opengltk.OpenGL.GLU import * except: print "Error: Could not import opengltk " import sys from UTpackages.UTimposter import utimposterrend class TestImposterRenderer: def __init__(self): self.initialized = False self.windowCreated = False self.imposterRenderer = None self.state = "ROTATE" self.mousex =0 self.mousey =0 self.cdx = 0 self.cdy = 0 self.whichbutton=0 self.rotMatrix = [1.,0.,0.,0., 0.,1.,0.,0., 0.,0.,1.,0., 0.,0.,0.,1.] self.transMatrix = [1.,0.,0.,0., 0.,1.,0.,0., 0.,0.,1.,0., 0.,0.,0.,1.] def display(self): glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glMatrixMode(GL_MODELVIEW) # glLoadIdentity() #glTranslated(0.0, 0.0, -4.0) glMultMatrixd(self.transMatrix) glMultMatrixd(self.rotMatrix) # #glPushMatrix() if self.imposterRenderer: self.imposterRenderer.renderBuffer(True, False, None, None, 0, False, 1.0) #glPopMatrix() glutSwapBuffers() def mouseCallbackFunction(self, button, state, x, y): if (state == GLUT_DOWN): self.mousex = x self.mousey = y self.whichbutton = button self.cdx = 0 self.cdy = 0 pass def mouseMotionCallbackFunction(self, x, y): #return dx = x-self.mousex dy = y-self.mousey if self.state == 'ROTATE': self.Rotate(dx, dy) elif self.state == 'TRANSLATE': if (self.whichbutton == GLUT_LEFT_BUTTON): self.Translate(dx, -dy,0) else: self.Translate(0,0,-dy) else: pass self.mousex = x self.mousey = y glutPostRedisplay() def reshapeCallbackFunction(self, w, h): if w < 6: w = 6 if h < 6: h = 6 glMatrixMode(GL_PROJECTION) glLoadIdentity() glViewport(0, 0, w, h) windowSize = None if w>h: windowSize = w/15.0 else: windowSize = h/15.0 glOrtho(-windowSize/2.0, windowSize/2.0, -windowSize/2.0, windowSize/2.0, -200, 200) glMatrixMode(GL_MODELVIEW) glLoadIdentity() gluLookAt(0.0,0.0,5.0, 0.0,0.0,-1.0, 0.0, 1.0, 0.0) def setCallbacks(self): glutDisplayFunc(self.display) #glutIdleFunc(self.Idle) glutMouseFunc(self.mouseCallbackFunction) glutMotionFunc(self.mouseMotionCallbackFunction) glutReshapeFunc(self.reshapeCallbackFunction) glutKeyboardFunc(self.Keyboard) def Idle(self): self.Rotate(self.cdx, self.cdy) glutPostRedisplay() def BeginGraphics(self): glutInit('foo') glutInitDisplayMode( GLUT_DEPTH | GLUT_RGBA | GLUT_DOUBLE ) self.initialized = True windowHandle = glutCreateWindow("ImposterRenderer") self.windowCreated = True self.initModelMatrix() self.setCallbacks() numBalls = 4 x = [1,1,4,1] y = [2,3,2,8] z = [3,5,3,1] r = [1,1,1,1] red = [1,1,0,0] green = [1,0,1,0] blue = [0,0,0,1] if not self.initializeImposterRenderer(numBalls, x, y, z, r, red, green, blue): print "Could not initialize the imposter renderer\n" return if not self.startLoop(): print "Could not start the glut loop\n" def initializeImposterRenderer(self, numBalls, x, y, z, r, red, green, blue): self.imposterRenderer = utimposterrend.ImposterRenderer() status = self.imposterRenderer.initRenderer() #print "status:", status if not status: print "Could not initialize the imposter renderer\n" return False self.imposterRenderer.initSubRenderers(0) self.imposterRenderer.clear() brp = utimposterrend.BallRendererPtr(self.imposterRenderer.m_BallRenderer) self.imposterRenderer.setLightVector([0,1,1,0]) for i in range(numBalls): brp.addBall(x[i], y[i], z[i], r[i], red[i], green[i], blue[i]) return True def startLoop(self): if self.initialized and self.windowCreated: glutMainLoop() else: return False def Keyboard(self,key, x, y): print '--> keyboard( %s <%c>, %i, %i)' % (key, chr( key), x, y) chkey = chr(key) if (chkey == 'R') or (chkey=='r'): self.state = 'ROTATE' elif (chkey == 't') or (chkey=='T'): self.state = 'TRANSLATE' elif (chkey == 'q') or (chkey == 'Q'): sys.exit() else: pass def Rotate(self,dx, dy): glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() glRotated((float(dy)), 1.0, 0.0, 0.0) glRotated((float(dx)), 0.0, 1.0, 0.0) glMultMatrixd(self.rotMatrix) self.rotMatrix=glGetDoublev(GL_MODELVIEW_MATRIX) #self.rotMatrix.shape = (16,) glPopMatrix() def Translate(self,dx,dy, dz): glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() glTranslated((float(dx))/100.0, (float(dy))/100.0, (float(dz))/10.0) glMultMatrixd(self.transMatrix) self.transMatrix = glGetDoublev(GL_MODELVIEW_MATRIX) self.transMatrix.shape = (16,) glPopMatrix() def initModelMatrix(self): glMatrixMode(GL_MODELVIEW) glLoadIdentity() self.rotMatrix=glGetDoublev(GL_MODELVIEW_MATRIX) self.transMatrix=glGetDoublev(GL_MODELVIEW_MATRIX) ## imposterRenderer = ImposterRenderer() ## imposterRenderer.initRenderer() ## imposterRenderer.initSubRenderers(0) ## imposterRenderer.clear() ## brp = BallRendererPtr(imposterRenderer.m_BallRenderer) ## brp.addBall(1 ,2, 3, 1, 1, 1, 0) #import _utimposterrend #_utimposterrend.BallRenderer_addBall(imposterRenderer.m_BallRenderer, 1, 2, 3, 1, 1, 1, 0) ## imposterRenderer.renderBuffer(True, False, None, None, 0, False, 1.0) #print "Use the mouse buttons to control." #print " Hit 't' or 'T' to do translation." #print " Hit 'r' or 'R' to do rotation." print "Hit q key to quit." t = TestImposterRenderer() t.BeginGraphics() mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/UTimposter/__init__.py0000644000175000017500000000001510240173437026400 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTimposterDIST/UTimposter/utimposter.i0000644000175000017500000000625210653454424026673 0ustar debiandebian%module utimposterrend %init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #include "numpy/arrayobject.h" static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} %{ #include "ImposterRenderer.h" #include "BallRenderer.h" #include "GaussianRenderer.h" #include "StickRenderer.h" #include "HelixRenderer.h" #include "HollowCylinderRenderer.h" using namespace CCVImposterRenderer; //using CCVImposterRenderer::GaussianRenderer; //using CCVImposterRenderer::BallRenderer; // using CCVImposterRenderer::StickRenderer; // using CCVImposterRenderer::HollowCylinderRenderer; //using CCVImposterRenderer::HelixRenderer; %} %include src/ImposterRenderer/BallRenderer.h %typemap(in) double* (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 1, expected_dims); if (! array) return NULL; $1 = (double *)array->data; } else { array = NULL; $1 = NULL; } %} %typemap(in) float VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; %} %typemap(freearg) float VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %apply float VECTOR[ANY] { float light[4] } %include src/ImposterRenderer/ImposterRenderer.h mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/0000755000175000017500000000000012146213616021073 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/setup.cfg0000644000175000017500000000003210242725543022711 0ustar debiandebian[build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/0000755000175000017500000000000012146213615022117 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/utsdf.i0000644000175000017500000001117311165234135023421 0ustar debiandebian%module utsdf %init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #ifdef _MSC_VER #include #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif #include "numpy/arrayobject.h" static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} %{ #include "sdfLib.h" %} // typemap to input an array of verts and triangles %typemap(in) (int nverts, float* verts) (PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = 0; expected_dims[1] = 3; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = ((PyArrayObject *)(array))->dimensions[0]; $2 = (float *)array->data; } else { array = NULL; $1 = 0; $2 = NULL; } %} %typemap(freearg) (int nverts, float* verts) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %typemap(in) (int ntris, int* tris) (PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = 0; expected_dims[1] = 3; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = ((PyArrayObject *)(array))->dimensions[0]; $2 = (int *)array->data; } else { array = NULL; $1 = 0; $2 = NULL; } %} %typemap(freearg) (int ntris, int* tris) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %typemap(in) double bufarr[6] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 1, expected_dims); if (! array) return NULL; $1 = (double *)array->data; %} %typemap(freearg) double bufarr[6] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %native(createNumArr)PyObject *Py_createNumArr(PyObject *self, PyObject *args); %{ static PyObject *Py_createNumArr(PyObject *self, PyObject *args) { PyObject * swigPt = 0 ; npy_intp dim[1]; float *data; PyArrayObject *out; if(!PyArg_ParseTuple(args, "Oi", &swigPt, &dim[0])) return NULL; if (swigPt) { swig_type_info *ty = SWIG_TypeQuery("float *"); if ((SWIG_ConvertPtr(swigPt, (void **)&data, ty,1)) == -1) { printf("utsdf,createNumArr: failed to convert a pointer\n"); return NULL; } } out = (PyArrayObject *)PyArray_SimpleNewFromData(1, dim, PyArray_FLOAT, (char *) data); if (!out) { PyErr_SetString(PyExc_RuntimeError, "Failed to allocate memory for normals"); return NULL; } #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: out->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected out->flags |= NPY_OWNDATA; #endif return Py_BuildValue("O", (PyObject *)out); } %} %include src/sdfLib.h mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/Tests/0000755000175000017500000000000012146213616023222 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/Tests/eight.raw0000644000175000017500000014060710242725543025047 0ustar debiandebian 766 1536 -0.622292 0.665115 -0.0016712 -0.316768 1.19689 0.0001174 0.316871 1.19704 -7.69e-05 0.62067 0.663161 0.0010798 0.258336 0.250979 -0.206003 -0.200461 0.218732 -0.226989 -0.447104 0.621525 -0.195217 -0.266899 1.02761 -0.199094 0.195582 1.06946 -0.19898 0.461592 0.691921 -0.198326 0.229196 0.248813 0.216239 -0.229102 0.224883 0.217127 -0.462885 0.693466 0.197762 -0.195442 1.06933 0.198978 0.267014 1.0278 0.199095 0.445403 0.619345 0.195798 0.136283 0.406093 -0.0033625 -0.145501 0.408032 0.0027764 -0.288276 0.650916 0.0024544 -0.145577 0.900051 -0.0002276 0.145727 0.900216 0.0001867 0.286035 0.649145 -0.0018572 0.316768 -1.19689 0.0001174 -0.316871 -1.19704 -7.69e-05 -0.62067 -0.663162 0.0010798 -0.440357 0.0051792 -1.47e-05 0.440357 -0.0051792 -1.47e-05 0.622292 -0.665115 -0.0016712 0.266899 -1.02761 -0.199094 -0.195582 -1.06946 -0.19898 -0.461592 -0.691921 -0.198326 -0.258336 -0.250979 -0.206003 0.200461 -0.218732 -0.226989 0.447104 -0.621525 -0.195217 0.195442 -1.06933 0.198978 -0.267014 -1.0278 0.199095 -0.445403 -0.619345 0.195798 -0.229196 -0.248813 0.216239 0.229102 -0.224883 0.217127 0.462885 -0.693467 0.197762 0.145577 -0.900051 -0.0002276 -0.145727 -0.900216 0.0001867 -0.286035 -0.649145 -0.0018572 -0.136283 -0.406093 -0.0033625 0.145501 -0.408032 0.0027764 0.288276 -0.650916 0.0024544 -0.515195 0.914267 -0.139684 -0.54644 0.966452 -0.0001795 -0.563417 0.636336 -0.138723 -0.579046 0.689497 0.137561 -0.509978 0.407279 0.136273 -0.541187 0.357666 -0.0024369 -0.0311882 1.22943 -0.139826 1.83e-05 1.28115 9.5e-06 -0.317393 1.13614 -0.139774 -0.264008 1.16727 0.13991 -0.487299 0.966578 0.139675 0.487088 0.96639 -0.139797 0.546138 0.966325 5.18e-05 0.264119 1.1674 -0.139881 0.317502 1.1363 0.139806 0.0312102 1.22944 0.139839 0.515268 0.914618 0.139642 0.576629 0.686739 -0.138399 0.509367 0.403074 -0.136175 0.562679 0.635312 0.13872 0.538969 0.351425 0.0018564 0.0302593 0.319054 -0.138244 0.195223 0.374586 -0.137788 0.415727 0.46127 -0.196773 0.387495 0.130982 -0.141638 0.0185174 0.18684 -0.233521 0.203247 0.0237715 -0.237891 -0.272482 0.461062 -0.135481 -0.367485 0.407429 -0.198747 -0.142243 0.350267 -0.138632 -0.348742 0.142258 -0.176379 -0.203247 -0.0237715 -0.237891 0 0 -0.266768 -0.31045 0.793734 -0.138945 -0.416903 0.845479 -0.198309 -0.335553 0.625119 -0.135642 -0.477996 0.359028 -0.139247 -0.0312504 0.991469 -0.139853 -0.0414301 1.11042 -0.19904 -0.198321 0.929654 -0.140006 0.281273 0.846969 -0.139717 0.379319 0.915363 -0.198931 0.145124 0.960974 -0.139676 0.341855 0.679618 -0.140062 0.310082 0.508425 -0.139544 0.141394 0.350419 0.138127 0.268207 0.459005 0.135381 0.365177 0.403172 0.198628 0.348378 0.138895 0.175953 0.205577 0.0271115 0.238522 0.0433333 0.18771 0.233956 -0.417084 0.463572 0.196818 -0.200457 0.376029 0.137782 -0.0313556 0.318275 0.138721 -0.385747 0.134508 0.142234 -0.205577 -0.0271115 0.238522 0 0 0.266253 -0.379049 0.915208 0.198898 -0.342619 0.680261 0.140092 -0.314416 0.511379 0.13882 0.0414385 1.11042 0.19904 -0.144964 0.960828 0.139644 -0.281015 0.846841 0.139764 0.417029 0.845817 0.198353 0.198449 0.929835 0.139976 0.0312746 0.991445 0.139839 0.310248 0.793559 0.139075 0.332545 0.622023 0.136474 0.475204 0.352556 0.139787 -0.0053834 0.370389 -0.0006772 0.243565 0.506612 -0.0035388 -0.24933 0.509457 0.0040665 -0.251567 0.794282 0.0004005 1.95e-05 0.939793 -9.8e-06 0.251391 0.794031 -0.0002704 0.0311883 -1.22943 -0.139826 -1.83e-05 -1.28115 9.5e-06 0.317393 -1.13614 -0.139774 0.264008 -1.16727 0.13991 0.487299 -0.966578 0.139675 0.54644 -0.966452 -0.0001795 -0.487088 -0.96639 -0.139797 -0.546138 -0.966325 5.18e-05 -0.264119 -1.1674 -0.139881 -0.317502 -1.1363 0.139806 -0.0312102 -1.22944 0.139839 -0.509367 -0.403074 -0.136175 -0.538969 -0.351425 0.0018564 -0.576629 -0.686739 -0.138399 -0.562679 -0.635312 0.13872 -0.515268 -0.914618 0.139642 -0.475204 -0.352556 0.139787 -0.387495 -0.130982 -0.141638 -0.348378 -0.138895 0.175953 0.477996 -0.359028 -0.139247 0.541187 -0.357666 -0.0024369 0.348742 -0.142258 -0.176379 0.385747 -0.134508 0.142234 0.509978 -0.407279 0.136273 0.563417 -0.636336 -0.138723 0.515195 -0.914267 -0.139684 0.579046 -0.689497 0.137561 0.0312504 -0.991469 -0.139853 0.0414301 -1.11042 -0.19904 0.198321 -0.929654 -0.140006 0.416903 -0.845479 -0.198309 -0.281273 -0.846969 -0.139717 -0.379319 -0.915363 -0.198931 -0.145124 -0.960974 -0.139676 -0.310082 -0.508425 -0.139544 -0.415727 -0.46127 -0.196772 -0.341855 -0.679618 -0.140062 -0.0302593 -0.319054 -0.138244 -0.195223 -0.374586 -0.137788 -0.0185174 -0.18684 -0.233521 0.272482 -0.461062 -0.135481 0.367485 -0.407429 -0.198747 0.142243 -0.350267 -0.138632 0.335553 -0.625119 -0.135642 0.31045 -0.793734 -0.138945 -0.0414385 -1.11042 0.19904 0.144964 -0.960828 0.139644 0.281015 -0.846841 0.139764 0.379049 -0.915208 0.198898 -0.417029 -0.845817 0.198353 -0.198449 -0.929835 0.139976 -0.0312746 -0.991445 0.139839 -0.365177 -0.403172 0.198628 -0.332545 -0.622023 0.136474 -0.310248 -0.793559 0.139075 -0.141394 -0.350419 0.138127 -0.268207 -0.459005 0.135381 -0.0433333 -0.18771 0.233956 0.417084 -0.463572 0.196818 0.200457 -0.376029 0.137782 0.0313556 -0.318275 0.138721 0.314416 -0.511379 0.13882 0.342619 -0.680261 0.140092 -1.95e-05 -0.939793 -9.8e-06 0.251567 -0.794282 0.0004005 -0.251391 -0.794031 -0.0002704 -0.243565 -0.506612 -0.0035388 0.0053834 -0.370389 -0.0006772 0.24933 -0.509457 0.0040665 -0.595054 0.799865 -0.0756847 -0.606486 0.819004 -0.0007967 -0.604058 0.649625 -0.0758566 -0.613209 0.679498 0.0731082 -0.591617 0.529322 0.0718328 -0.595537 0.511979 -0.0024384 -0.177456 1.24201 -0.0753324 -0.164193 1.25974 6.4e-05 -0.324763 1.17609 -0.0752908 -0.294843 1.19353 0.0754997 -0.425259 1.09879 0.075484 -0.447101 1.09615 9.08e-05 0.425304 1.0989 -0.0754755 0.447134 1.09628 -8.25e-05 0.294946 1.19367 -0.0754626 0.324867 1.17625 0.0753292 0.177519 1.24209 0.0753607 0.164256 1.25982 -3.56e-05 0.594563 0.79959 0.0754529 0.605571 0.818228 0.0004361 0.610987 0.676907 -0.0738758 0.588978 0.525062 -0.0726645 0.603054 0.648343 0.0755211 0.593362 0.508174 0.0017362 0.134507 0.278795 -0.186787 0.228322 0.326305 -0.182356 0.397276 0.309643 -0.181887 0.34874 0.355413 -0.197727 0.334758 0.188931 -0.187904 0.1313 0.200931 -0.223422 0.223561 0.136267 -0.224801 -0.2468 0.350774 -0.187318 -0.297555 0.311468 -0.208848 -0.164532 0.294798 -0.192912 -0.281717 0.184661 -0.216361 -0.197125 0.0923448 -0.24146 -0.100987 0.101965 -0.256103 -0.0898514 0.194371 -0.234837 -0.387631 0.719048 -0.180943 -0.447771 0.734963 -0.196937 -0.387112 0.620589 -0.179123 -0.508335 0.626814 -0.18073 -0.477413 0.500794 -0.180068 -0.41842 0.511274 -0.194842 -0.14104 1.02295 -0.183512 -0.159768 1.08392 -0.199082 -0.232897 0.973583 -0.183537 -0.296642 1.08413 -0.183414 -0.398393 0.992458 -0.183334 -0.354954 0.945645 -0.198938 0.254209 0.957879 -0.183268 0.297566 1.0046 -0.198961 0.165858 1.01297 -0.183304 0.229553 1.12347 -0.18342 0.0985819 1.16637 -0.183415 0.0798455 1.1054 -0.199007 0.497078 0.823367 -0.183085 0.435369 0.808337 -0.198791 0.398037 0.688205 -0.183102 0.393944 0.58638 -0.182547 0.523961 0.69162 -0.182329 0.454958 0.574443 -0.197428 0.177332 0.30193 0.189249 0.250664 0.356122 0.184172 0.302233 0.315461 0.205722 0.288481 0.19502 0.212801 0.211465 0.139536 0.233307 0.144574 0.206252 0.227252 -0.342738 0.351383 0.200934 -0.390074 0.306717 0.185107 -0.223645 0.321281 0.185554 -0.121183 0.272662 0.190664 -0.326318 0.179644 0.191813 -0.213761 0.0906481 0.233941 -0.0759422 0.191311 0.232283 -0.107788 0.102596 0.253172 -0.435526 0.808673 0.198584 -0.497736 0.82414 0.182743 -0.398789 0.689086 0.182801 -0.396334 0.588752 0.181835 -0.525972 0.693926 0.181574 -0.457622 0.577542 0.196577 -0.079806 1.10534 0.199 -0.0985449 1.16632 0.183421 -0.165703 1.01283 0.183284 -0.253913 0.95766 0.183262 -0.229427 1.12334 0.183436 -0.297292 1.00438 0.198967 0.35516 0.946007 0.198933 0.398585 0.992816 0.18334 0.233018 0.97377 0.18352 0.141079 1.023 0.183505 0.296756 1.08431 0.183433 0.159803 1.08397 0.199088 0.386781 0.718136 0.181303 0.44736 0.734606 0.197168 0.384618 0.617691 0.17988 0.415132 0.506659 0.195645 0.507318 0.625411 0.181057 0.474896 0.496715 0.180744 0.0532269 0.363041 0.071338 0.0674666 0.379182 -0.0022446 0.127523 0.38739 0.0708666 0.161943 0.401929 -0.0757155 0.222096 0.45165 -0.0767217 0.196547 0.449395 -0.0037654 -0.229123 0.454541 0.0760885 -0.204125 0.451993 0.003795 -0.170575 0.404633 0.074753 -0.135 0.389009 -0.0709139 -0.0614372 0.36353 -0.0718121 -0.0778221 0.38023 0.0011238 -0.288802 0.744712 0.0760512 -0.279441 0.725121 0.0013113 -0.303453 0.666979 0.0767163 -0.300263 0.635717 -0.0718736 -0.284119 0.559263 -0.0706412 -0.277948 0.577213 0.0035372 -0.0619732 0.947292 0.0752514 -0.0752482 0.929573 -0.0001537 -0.137599 0.920869 0.0751662 -0.167498 0.903392 -0.0755955 -0.22769 0.85109 -0.0753958 -0.205908 0.853826 -0.0001038 0.227807 0.851226 0.0753887 0.206046 0.853934 9.61e-05 0.167634 0.903564 0.075558 0.137756 0.921022 -0.075205 0.0620487 0.947389 -0.0752802 0.0753235 0.929666 0.0001248 0.28836 0.744268 -0.0758094 0.278488 0.724186 -0.0009464 0.297363 0.633107 0.0726383 0.27951 0.555945 0.0714669 0.302069 0.665981 -0.0763626 0.274007 0.5747 -0.0028332 0.177456 -1.24201 -0.0753324 0.164193 -1.25974 6.4e-05 0.324763 -1.17609 -0.0752908 0.294843 -1.19353 0.0754997 0.425259 -1.09879 0.075484 0.447101 -1.09615 9.08e-05 -0.425304 -1.0989 -0.0754755 -0.447134 -1.09628 -8.25e-05 -0.294946 -1.19367 -0.0754626 -0.324867 -1.17625 0.0753292 -0.177519 -1.24209 0.0753607 -0.164256 -1.25982 -3.56e-05 -0.588978 -0.525062 -0.0726645 -0.593362 -0.508174 0.0017362 -0.610987 -0.676907 -0.0738758 -0.603054 -0.648343 0.0755211 -0.594563 -0.79959 0.0754529 -0.605571 -0.818228 0.0004361 -0.456943 -0.19129 0.0798024 -0.478963 -0.188807 0.0011814 -0.458981 0.200239 -0.0795909 -0.480475 0.197653 -0.001448 -0.404914 0.0856978 -0.106857 -0.422385 -0.0705368 -0.0791313 -0.403466 -0.0763801 0.106989 -0.422384 0.0798014 0.0790048 0.458981 -0.200239 -0.0795909 0.480475 -0.197653 -0.001448 0.456943 0.19129 0.0798024 0.478963 0.188807 0.0011814 0.404914 -0.0856978 -0.106857 0.422385 0.0705368 -0.0791313 0.403466 0.0763801 0.106989 0.422384 -0.0798015 0.0790048 0.591617 -0.529322 0.0718328 0.595537 -0.511979 -0.0024384 0.604058 -0.649625 -0.0758566 0.595054 -0.799865 -0.0756847 0.613209 -0.679498 0.0731081 0.606486 -0.819004 -0.0007967 0.14104 -1.02295 -0.183512 0.159768 -1.08392 -0.199082 0.232896 -0.973583 -0.183537 0.296642 -1.08413 -0.183414 0.398393 -0.992458 -0.183334 0.354954 -0.945645 -0.198938 -0.254209 -0.957879 -0.183268 -0.297566 -1.0046 -0.198961 -0.165858 -1.01297 -0.183304 -0.229553 -1.12347 -0.18342 -0.098582 -1.16637 -0.183415 -0.0798455 -1.1054 -0.199007 -0.393944 -0.58638 -0.182547 -0.454958 -0.574443 -0.197428 -0.398037 -0.688205 -0.183102 -0.523961 -0.69162 -0.182329 -0.497078 -0.823367 -0.183085 -0.435369 -0.808337 -0.198791 -0.134507 -0.278795 -0.186787 -0.228322 -0.326305 -0.182356 -0.397276 -0.309643 -0.181887 -0.34874 -0.355413 -0.197728 -0.334758 -0.188931 -0.187904 -0.1313 -0.200931 -0.223422 -0.223561 -0.136267 -0.224801 0.2468 -0.350774 -0.187318 0.297555 -0.311467 -0.208848 0.164532 -0.294798 -0.192912 0.281717 -0.184661 -0.216361 0.0898514 -0.194371 -0.234837 0.100987 -0.101965 -0.256103 0.197125 -0.0923448 -0.24146 0.477413 -0.500794 -0.180068 0.41842 -0.511274 -0.194842 0.387112 -0.620589 -0.179123 0.387631 -0.719048 -0.180943 0.508335 -0.626814 -0.18073 0.447771 -0.734963 -0.196937 0.079806 -1.10534 0.199 0.0985449 -1.16632 0.183421 0.165703 -1.01283 0.183284 0.253913 -0.95766 0.183262 0.229427 -1.12334 0.183436 0.297292 -1.00438 0.198967 -0.35516 -0.946007 0.198933 -0.398585 -0.992816 0.18334 -0.233018 -0.97377 0.18352 -0.141079 -1.023 0.183505 -0.296756 -1.08431 0.183433 -0.159803 -1.08397 0.199088 -0.415132 -0.506659 0.195645 -0.474896 -0.496715 0.180744 -0.384618 -0.617691 0.17988 -0.386781 -0.718136 0.181303 -0.507318 -0.625411 0.181057 -0.44736 -0.734606 0.197168 -0.177332 -0.30193 0.189249 -0.250664 -0.356122 0.184172 -0.302233 -0.315461 0.205722 -0.288481 -0.19502 0.212801 -0.211465 -0.139536 0.233307 -0.144574 -0.206252 0.227252 0.342738 -0.351383 0.200934 0.390074 -0.306717 0.185107 0.223645 -0.321281 0.185554 0.121183 -0.272662 0.190664 0.326318 -0.179644 0.191813 0.0759422 -0.191311 0.232283 0.213761 -0.0906481 0.233941 0.107788 -0.102596 0.253172 0.396334 -0.588752 0.181835 0.457622 -0.577542 0.196577 0.398789 -0.689086 0.182801 0.435526 -0.808673 0.198584 0.525972 -0.693926 0.181574 0.497736 -0.82414 0.182743 0.0619732 -0.947292 0.0752514 0.0752482 -0.929573 -0.0001537 0.137599 -0.920869 0.0751662 0.167498 -0.903392 -0.0755955 0.22769 -0.85109 -0.0753957 0.205908 -0.853826 -0.0001038 -0.227807 -0.851226 0.0753887 -0.206046 -0.853934 9.61e-05 -0.167634 -0.903564 0.075558 -0.137756 -0.921022 -0.075205 -0.0620487 -0.947389 -0.0752803 -0.0753235 -0.929666 0.0001248 -0.27951 -0.555945 0.0714669 -0.274007 -0.5747 -0.0028332 -0.297363 -0.633107 0.0726383 -0.302069 -0.665981 -0.0763626 -0.28836 -0.744268 -0.0758094 -0.278488 -0.724186 -0.0009464 -0.0532269 -0.363041 0.071338 -0.0674666 -0.379182 -0.0022447 -0.127523 -0.38739 0.0708666 -0.161943 -0.401929 -0.0757155 -0.222096 -0.45165 -0.0767217 -0.196547 -0.449395 -0.0037654 0.229123 -0.454541 0.0760885 0.204125 -0.451993 0.003795 0.170575 -0.404633 0.074753 0.135 -0.389009 -0.0709139 0.0614372 -0.36353 -0.0718121 0.0778221 -0.38023 0.0011238 0.284119 -0.559263 -0.0706412 0.277948 -0.577213 0.0035372 0.303453 -0.666979 0.0767163 0.288802 -0.744712 0.0760512 0.300263 -0.635717 -0.0718736 0.279441 -0.725121 0.0013113 -0.431884 1.03726 -0.139761 -0.542192 0.944823 -0.0754648 -0.559707 0.777577 -0.139369 -0.470776 0.879794 -0.182975 -0.449379 1.07391 -0.075312 -0.526603 0.974233 0.0751946 -0.591175 0.83069 0.0744012 -0.507757 0.755171 -0.182086 -0.531685 0.495287 -0.13786 -0.573657 0.498984 -0.0756513 -0.552547 0.832303 0.138928 -0.562715 0.546578 0.136319 -0.515476 0.562829 0.180435 -0.465913 0.43359 0.181201 -0.442443 0.271088 0.137598 -0.537977 0.381779 0.0712212 -0.519419 0.347214 -0.0752481 -0.473892 0.232939 0.0721958 0.120658 1.21762 -0.139852 -0.0175212 1.26737 -0.0753792 -0.180618 1.20169 -0.139798 -0.0390654 1.1742 -0.183414 0.143757 1.25088 -0.075421 0.0175535 1.26738 0.0753968 -0.143703 1.25081 0.0754451 -0.173952 1.14618 -0.183417 -0.120614 1.21756 0.139869 -0.388829 1.08137 0.139907 -0.344095 1.04782 0.183435 -0.435571 0.945336 0.183287 0.551421 0.831152 -0.139373 0.526248 0.97398 -0.0753387 0.388939 1.0815 -0.139896 0.435613 0.945323 -0.183366 0.589956 0.829529 -0.0748529 0.54207 0.944935 0.075377 0.449452 1.07412 0.0753229 0.344297 1.048 -0.183423 0.432023 1.03755 0.139774 0.180671 1.20176 0.139822 0.173995 1.14624 0.183434 0.0390771 1.1742 0.183421 0.559538 0.777664 0.139288 0.470954 0.880249 0.182976 0.560062 0.542531 -0.137084 0.51283 0.559275 -0.181209 0.444084 0.267102 -0.136798 0.535846 0.375722 -0.0718364 0.466267 0.431495 -0.180575 0.50762 0.755231 0.182168 0.529944 0.491907 0.138119 0.572025 0.495706 0.0753681 0.47272 0.22502 -0.0725567 0.517331 0.341082 0.0752259 -0.0586947 0.324934 -0.139114 0.0310415 0.261554 -0.19263 0.116837 0.334897 -0.137416 0.0158163 0.356493 -0.0729181 0.0917703 0.369373 -0.0742948 0.261215 0.434702 -0.13869 0.305212 0.400666 -0.18129 0.362148 0.489174 -0.181712 0.296756 0.066226 -0.19872 0.355041 -0.005314 -0.154855 -0.0704666 0.267636 -0.194957 0.0053197 0.0982337 -0.25845 0.114272 0.1061 -0.24809 0.280399 -0.0582536 -0.210049 0.104171 0.0031148 -0.259602 -0.313908 0.540199 -0.134671 -0.313526 0.432192 -0.181214 -0.214458 0.395746 -0.137223 -0.249779 0.489387 -0.0701241 -0.361271 0.523975 -0.178538 -0.425054 0.383229 -0.183718 -0.358496 0.278345 -0.195777 -0.199151 0.431555 -0.0702841 -0.414566 0.239432 -0.15041 -0.280399 0.0582536 -0.210049 -0.355041 0.005314 -0.154855 -0.296756 -0.066226 -0.19872 -0.114272 -0.1061 -0.24809 -0.104171 -0.0031148 -0.259602 -0.0053197 -0.0982337 -0.25845 -0.263878 0.868495 -0.139768 -0.36122 0.815064 -0.182514 -0.334621 0.710959 -0.137425 -0.271684 0.786213 -0.0746894 -0.308317 0.902104 -0.183321 -0.296214 0.71294 -0.0734081 0.0589138 0.987669 -0.13975 -0.0391098 1.04667 -0.183431 -0.118935 0.971736 -0.139968 -0.0175652 0.953559 -0.0754069 0.0656206 1.04315 -0.183361 -0.0957914 0.938504 -0.0755427 0.322466 0.767094 -0.139883 0.325267 0.881419 -0.183269 0.220927 0.91307 -0.139649 0.255003 0.816119 -0.0754141 0.374311 0.789165 -0.183261 0.20366 0.876305 -0.0752232 0.337655 0.591429 -0.140033 0.29499 0.587534 -0.0768931 0.267726 0.514581 -0.0770878 0.0591705 0.324527 0.139138 0.0906606 0.269917 0.193665 0.211446 0.395825 0.136452 0.192218 0.429091 0.0705887 0.243776 0.486292 0.0707298 0.309517 0.536367 0.135417 0.311394 0.430302 0.180577 0.357464 0.519593 0.179275 0.42181 0.37689 0.1843 0.358043 0.274572 0.195021 0.411946 0.231351 0.150755 0.282601 0.0724863 0.208914 0.354053 0.0022643 0.154977 0.293849 -0.0522939 0.200511 0.120439 0.108072 0.250093 0.110847 0.0041829 0.258797 -0.0107337 0.259796 0.194322 0.0115896 0.0990465 0.258078 -0.365691 0.49246 0.180958 -0.306747 0.401587 0.181907 -0.266904 0.437935 0.13793 -0.120401 0.334355 0.138067 -0.101068 0.371098 0.0733101 -0.0248948 0.357082 0.0721051 -0.293849 0.0522939 0.200511 -0.354053 -0.0022643 0.154977 -0.282601 -0.0724863 0.208914 -0.120439 -0.108072 0.250093 -0.110847 -0.0041829 0.258797 -0.0115896 -0.0990465 0.258078 -0.324902 0.881196 0.183276 -0.374189 0.78922 0.183203 -0.322458 0.767186 0.139982 -0.339937 0.593111 0.139759 -0.297885 0.589262 0.0771765 -0.272601 0.517023 0.0769895 0.0391232 1.04665 0.183424 -0.0655681 1.04308 0.183343 -0.0588481 0.987582 0.139725 -0.220668 0.912888 0.139637 -0.203467 0.876174 0.0752124 -0.254969 0.816182 0.0755046 0.36119 0.815149 0.182604 0.308497 0.902405 0.18331 0.264017 0.868705 0.139759 0.118985 0.9718 0.13995 0.0958555 0.938583 0.0755179 0.0176 0.953543 0.0753888 0.333371 0.709618 0.13788 0.271409 0.785899 0.0748376 0.294914 0.711597 0.0738637 -0.120658 -1.21762 -0.139852 0.0175212 -1.26737 -0.0753792 0.180618 -1.20169 -0.139798 0.0390654 -1.1742 -0.183414 -0.143757 -1.25088 -0.075421 -0.0175535 -1.26738 0.0753968 0.143703 -1.25081 0.0754451 0.173952 -1.14618 -0.183417 0.431884 -1.03726 -0.139761 0.449379 -1.07391 -0.075312 0.120614 -1.21756 0.139869 0.388829 -1.08137 0.139907 0.344095 -1.04782 0.183435 0.435571 -0.945336 0.183287 0.552547 -0.832303 0.138928 0.526603 -0.974233 0.0751946 0.542192 -0.944823 -0.0754648 0.591175 -0.83069 0.0744012 -0.551421 -0.831152 -0.139373 -0.526248 -0.97398 -0.0753387 -0.388939 -1.0815 -0.139896 -0.435613 -0.945323 -0.183366 -0.589956 -0.829529 -0.0748529 -0.54207 -0.944935 0.075377 -0.449452 -1.07412 0.0753229 -0.344297 -1.048 -0.183423 -0.432023 -1.03755 0.139774 -0.180671 -1.20176 0.139822 -0.173995 -1.14624 0.183434 -0.0390771 -1.1742 0.183421 -0.444084 -0.267102 -0.136798 -0.535846 -0.375722 -0.0718364 -0.560062 -0.542531 -0.137084 -0.466267 -0.431495 -0.180575 -0.47272 -0.22502 -0.0725567 -0.517331 -0.341082 0.0752259 -0.572025 -0.495706 0.0753681 -0.51283 -0.559275 -0.181209 -0.529944 -0.491907 0.138119 -0.559538 -0.777664 0.139288 -0.50762 -0.755231 0.182168 -0.470954 -0.880249 0.182976 -0.411946 -0.231351 0.150755 -0.42181 -0.37689 0.1843 -0.358043 -0.274572 0.195021 0.531685 -0.495288 -0.13786 0.519419 -0.347214 -0.0752481 0.414566 -0.239432 -0.15041 0.425054 -0.383229 -0.183718 0.573657 -0.498984 -0.0756513 0.537977 -0.381779 0.0712212 0.473892 -0.232939 0.0721958 0.358496 -0.278345 -0.195777 0.442443 -0.271088 0.137598 0.562715 -0.546578 0.136319 0.465913 -0.433589 0.181201 0.559707 -0.777577 -0.139369 0.507757 -0.755171 -0.182086 0.470776 -0.879794 -0.182975 0.515476 -0.562829 0.180435 -0.0589138 -0.987669 -0.13975 0.0391098 -1.04667 -0.183431 0.118935 -0.971736 -0.139968 0.0175652 -0.953559 -0.0754069 -0.0656206 -1.04315 -0.183361 0.0957914 -0.938504 -0.0755427 0.263878 -0.868495 -0.139768 0.308317 -0.902104 -0.183321 0.36122 -0.815064 -0.182514 -0.322466 -0.767094 -0.139883 -0.325267 -0.881419 -0.183269 -0.220927 -0.91307 -0.139649 -0.255003 -0.816119 -0.0754141 -0.374311 -0.789165 -0.183261 -0.20366 -0.876305 -0.0752232 -0.261215 -0.434702 -0.13869 -0.362148 -0.489174 -0.181712 -0.337655 -0.591429 -0.140033 -0.267726 -0.514581 -0.0770878 -0.305212 -0.400666 -0.18129 -0.29499 -0.587534 -0.0768931 0.0586947 -0.324934 -0.139114 -0.0310415 -0.261554 -0.19263 -0.116837 -0.334897 -0.137416 -0.0158163 -0.356493 -0.0729181 -0.0917703 -0.369373 -0.0742948 0.0704666 -0.267636 -0.194957 0.313908 -0.540199 -0.134671 0.313526 -0.432192 -0.181214 0.214458 -0.395746 -0.137223 0.249779 -0.489387 -0.0701241 0.361271 -0.523975 -0.178538 0.199151 -0.431555 -0.0702841 0.334621 -0.710959 -0.137425 0.296214 -0.71294 -0.0734081 0.271684 -0.786213 -0.0746894 -0.0391232 -1.04665 0.183424 0.0655681 -1.04308 0.183343 0.0588481 -0.987582 0.139725 0.220668 -0.912888 0.139637 0.203467 -0.876174 0.0752124 0.254969 -0.816182 0.0755046 0.322458 -0.767186 0.139982 0.324902 -0.881196 0.183276 0.374189 -0.78922 0.183203 -0.36119 -0.815149 0.182604 -0.308497 -0.902405 0.18331 -0.264017 -0.868705 0.139759 -0.118985 -0.9718 0.13995 -0.0958555 -0.938583 0.0755179 -0.0176 -0.953543 0.0753888 -0.311394 -0.430302 0.180577 -0.357464 -0.519593 0.179275 -0.309517 -0.536367 0.135417 -0.333371 -0.709618 0.13788 -0.294914 -0.711597 0.0738637 -0.271409 -0.785899 0.0748376 -0.0591705 -0.324527 0.139138 -0.0906606 -0.269917 0.193665 -0.211446 -0.395825 0.136452 -0.192218 -0.429091 0.0705887 -0.243776 -0.486292 0.0707298 0.0107337 -0.259796 0.194322 0.365691 -0.49246 0.180958 0.306747 -0.401587 0.181907 0.266904 -0.437935 0.13793 0.120401 -0.334355 0.138067 0.101068 -0.371098 0.0733101 0.0248948 -0.357082 0.0721051 0.339937 -0.593111 0.139759 0.272601 -0.517023 0.0769895 0.297885 -0.589262 0.0771765 434 435 38 598 102 435 434 95 598 434 598 435 600 265 102 264 11 265 600 96 264 600 264 265 597 257 96 256 10 257 597 95 256 597 256 257 598 600 102 597 96 600 598 95 597 598 597 600 263 265 11 611 102 265 263 101 611 263 611 265 612 435 102 433 38 435 612 178 433 612 433 435 610 427 178 426 37 427 610 101 426 610 426 427 611 612 102 610 178 612 611 101 610 611 610 612 396 397 32 546 72 397 396 78 546 396 546 397 544 220 72 219 4 220 544 71 219 544 219 220 543 227 71 226 5 227 543 78 226 543 226 227 546 544 72 543 71 544 546 78 543 546 543 544 226 225 5 560 77 225 226 78 560 226 560 225 559 390 77 389 31 390 559 160 389 559 389 390 561 395 160 396 32 395 561 78 396 561 396 395 560 559 77 561 160 559 560 78 561 560 561 559 350 351 25 608 100 351 350 139 608 350 608 351 607 262 100 263 11 262 607 101 263 607 263 262 609 426 101 425 37 426 609 139 425 609 425 426 608 607 100 609 101 607 608 139 609 608 609 607 348 349 25 557 138 349 348 76 557 348 557 349 558 388 138 390 31 388 558 77 390 558 390 388 556 225 77 224 5 225 556 76 224 556 224 225 557 558 138 556 77 558 557 76 556 557 556 558 358 359 26 595 143 359 358 94 595 358 595 359 596 432 143 434 38 432 596 95 434 596 434 432 594 256 95 255 10 256 594 94 255 594 255 256 595 596 143 594 95 596 595 94 594 595 594 596 356 357 26 541 70 357 356 142 541 356 541 357 540 218 70 220 4 218 540 72 220 540 220 218 545 397 72 394 32 397 545 142 394 545 394 397 541 540 70 545 72 540 541 142 545 541 545 540 212 213 3 529 66 213 212 65 529 212 529 213 531 355 66 354 26 355 531 114 354 531 354 355 528 289 114 288 15 289 528 65 288 528 288 289 529 531 66 528 114 531 529 65 528 529 528 531 255 254 10 592 93 254 255 94 592 255 592 254 591 287 93 289 15 287 591 114 289 591 289 287 593 354 114 358 26 354 593 94 358 593 358 354 592 591 93 593 114 591 592 94 593 592 593 591 250 251 9 523 69 251 250 63 523 250 523 251 526 217 69 216 4 217 526 64 216 526 216 217 522 211 64 210 3 211 522 63 210 522 210 211 523 526 69 522 64 526 523 63 522 523 522 526 357 355 26 530 66 355 357 70 530 357 530 355 525 213 66 211 3 213 525 64 211 525 211 213 524 216 64 218 4 216 524 70 218 524 218 216 530 525 66 524 64 525 530 70 524 530 524 525 324 325 21 581 116 325 324 89 581 324 581 325 582 295 116 294 16 295 582 90 294 582 294 295 580 249 90 248 9 249 580 89 248 580 248 249 581 582 116 580 90 582 581 89 580 581 580 582 215 217 4 538 69 217 215 68 538 215 538 217 539 251 69 249 9 251 539 90 249 539 249 251 537 294 90 293 16 294 537 68 293 537 293 294 538 539 69 537 90 539 538 68 537 538 537 539 286 287 15 590 93 287 286 113 590 286 590 287 589 254 93 253 10 254 589 92 253 589 253 254 588 323 92 322 21 323 588 113 322 588 322 323 590 589 93 588 92 589 590 113 588 590 588 589 292 295 16 586 116 295 292 91 586 292 586 295 587 325 116 323 21 325 587 92 323 587 323 325 585 253 92 252 10 253 585 91 252 585 252 253 586 587 116 585 92 587 586 91 585 586 585 587 293 291 16 536 115 291 293 68 536 293 536 291 535 301 115 300 17 301 535 67 300 535 300 301 534 214 67 215 4 214 534 68 215 534 215 214 536 535 115 534 67 535 536 68 534 536 534 535 223 227 5 542 71 227 223 75 542 223 542 227 533 219 71 214 4 219 533 67 214 533 214 219 532 300 67 299 17 300 532 75 299 532 299 300 542 533 71 532 67 533 542 75 532 542 532 533 252 257 10 584 96 257 252 91 584 252 584 257 599 264 96 261 11 264 599 99 261 599 261 264 583 290 99 292 16 290 583 91 292 583 292 290 584 599 96 583 99 599 584 91 583 584 583 599 298 301 17 605 115 301 298 98 605 298 605 301 606 291 115 290 16 291 606 99 290 606 290 291 604 261 99 260 11 261 604 98 260 604 260 261 605 606 115 604 99 606 605 98 604 605 604 606 351 347 25 495 51 347 351 100 495 351 495 347 493 195 51 194 0 195 493 50 194 493 194 195 492 259 50 262 11 259 492 100 262 492 262 259 495 493 51 492 50 493 495 100 492 495 492 493 270 271 12 490 97 271 270 49 490 270 490 271 491 258 97 259 11 258 491 50 259 491 259 258 489 194 50 193 0 194 489 49 193 489 193 194 490 491 97 489 50 491 490 49 489 490 489 491 224 222 5 553 74 222 224 76 553 224 553 222 552 233 74 232 6 233 552 82 232 552 232 233 555 346 82 348 25 346 555 76 348 555 348 346 553 552 74 555 82 552 553 76 555 553 555 552 192 195 0 487 51 195 192 48 487 192 487 195 494 347 51 346 25 347 494 82 346 494 346 347 486 232 82 231 6 232 486 48 231 486 231 232 487 494 51 486 82 494 487 48 486 487 486 494 299 297 17 554 117 297 299 75 554 299 554 297 550 307 117 306 18 307 550 73 306 550 306 307 549 221 73 223 5 221 549 75 223 549 223 221 554 550 117 549 73 550 554 75 549 554 549 550 230 233 6 551 74 233 230 81 551 230 551 233 548 222 74 221 5 222 548 73 221 548 221 222 547 306 73 305 18 306 547 81 305 547 305 306 551 548 74 547 73 548 551 81 547 551 547 548 260 258 11 602 97 258 260 98 602 260 602 258 601 271 97 269 12 271 601 105 269 601 269 271 603 296 105 298 17 296 603 98 298 603 298 296 602 601 97 603 105 601 602 98 603 602 603 601 304 307 18 617 117 307 304 104 617 304 617 307 618 297 117 296 17 297 618 105 296 618 296 297 616 269 105 268 12 269 616 104 268 616 268 269 617 618 117 616 105 618 617 104 616 617 616 618 193 191 0 484 47 191 193 49 484 193 484 191 483 201 47 200 1 201 483 56 200 483 200 201 488 267 56 270 12 267 488 49 270 488 270 267 484 483 47 488 56 483 484 49 488 484 488 483 276 277 13 506 103 277 276 55 506 276 506 277 507 266 103 267 12 266 507 56 267 507 267 266 505 200 56 199 1 200 505 55 199 505 199 200 506 507 103 505 56 507 506 55 505 506 505 507 231 229 6 485 80 229 231 48 485 231 485 229 481 239 80 238 7 239 481 46 238 481 238 239 480 190 46 192 0 190 480 48 192 480 192 190 485 481 80 480 46 481 485 48 480 485 480 481 198 201 1 482 47 201 198 54 482 198 482 201 479 191 47 190 0 191 479 46 190 479 190 191 478 238 46 237 7 238 478 54 237 478 237 238 482 479 47 478 46 479 482 54 478 482 478 479 305 303 18 567 118 303 305 81 567 305 567 303 565 313 118 312 19 313 565 79 312 565 312 313 564 228 79 230 6 228 564 81 230 564 230 228 567 565 118 564 79 565 567 81 564 567 564 565 236 239 7 566 80 239 236 85 566 236 566 239 563 229 80 228 6 229 563 79 228 563 228 229 562 312 79 311 19 312 562 85 311 562 311 312 566 563 80 562 79 563 566 85 562 566 562 563 268 266 12 614 103 266 268 104 614 268 614 266 613 277 103 275 13 277 613 108 275 613 275 277 615 302 108 304 18 302 615 104 304 615 304 302 614 613 103 615 108 613 614 104 615 614 615 613 310 313 19 623 118 313 310 107 623 310 623 313 624 303 118 302 18 303 624 108 302 624 302 303 622 275 108 274 13 275 622 107 274 622 274 275 623 624 118 622 108 624 623 107 622 623 622 624 199 197 1 502 53 197 199 55 502 199 502 197 501 207 53 206 2 207 501 61 206 501 206 207 504 273 61 276 13 273 504 55 276 504 276 273 502 501 53 504 61 501 502 55 504 502 504 501 282 283 14 518 106 283 282 60 518 282 518 283 519 272 106 273 13 272 519 61 273 519 273 272 517 206 61 205 2 206 517 60 205 517 205 206 518 519 106 517 61 519 518 60 517 518 517 519 237 235 7 503 84 235 237 54 503 237 503 235 499 245 84 244 8 245 499 52 244 499 244 245 498 196 52 198 1 196 498 54 198 498 198 196 503 499 84 498 52 499 503 54 498 503 498 499 204 207 2 500 53 207 204 59 500 204 500 207 497 197 53 196 1 197 497 52 196 497 196 197 496 244 52 243 8 244 496 59 243 496 243 244 500 497 53 496 52 497 500 59 496 500 496 497 311 309 19 573 119 309 311 85 573 311 573 309 571 319 119 318 20 319 571 83 318 571 318 319 570 234 83 236 7 234 570 85 236 570 236 234 573 571 119 570 83 571 573 85 570 573 570 571 242 245 8 572 84 245 242 88 572 242 572 245 569 235 84 234 7 235 569 83 234 569 234 235 568 318 83 317 20 318 568 88 317 568 317 318 572 569 84 568 83 569 572 88 568 572 568 569 274 272 13 620 106 272 274 107 620 274 620 272 619 283 106 281 14 283 619 111 281 619 281 283 621 308 111 310 19 308 621 107 310 621 310 308 620 619 106 621 111 619 620 107 621 620 621 619 316 319 20 629 119 319 316 110 629 316 629 319 630 309 119 308 19 309 630 111 308 630 308 309 628 281 111 280 14 281 628 110 280 628 280 281 629 630 119 628 111 630 629 110 628 629 628 630 205 203 2 514 58 203 205 60 514 205 514 203 513 209 58 208 3 209 513 62 208 513 208 209 516 279 62 282 14 279 516 60 282 516 282 279 514 513 58 516 62 513 514 60 516 514 516 513 288 285 15 527 109 285 288 65 527 288 527 285 521 278 109 279 14 278 521 62 279 521 279 278 520 208 62 212 3 208 520 65 212 520 212 208 527 521 109 520 62 521 527 65 520 527 520 521 243 241 8 515 87 241 243 59 515 243 515 241 511 247 87 246 9 247 511 57 246 511 246 247 510 202 57 204 2 202 510 59 204 510 204 202 515 511 87 510 57 511 515 59 510 515 510 511 210 209 3 512 58 209 210 63 512 210 512 209 509 203 58 202 2 203 509 57 202 509 202 203 508 246 57 250 9 246 508 63 250 508 250 246 512 509 58 508 57 509 512 63 508 512 508 509 317 315 20 579 120 315 317 88 579 317 579 315 577 321 120 320 21 321 577 86 320 577 320 321 576 240 86 242 8 240 576 88 242 576 242 240 579 577 120 576 86 577 579 88 576 579 576 577 248 247 9 578 87 247 248 89 578 248 578 247 575 241 87 240 8 241 575 86 240 575 240 241 574 320 86 324 21 320 574 89 324 574 324 320 578 575 87 574 86 575 578 89 574 578 574 575 280 278 14 626 109 278 280 110 626 280 626 278 625 285 109 284 15 285 625 112 284 625 284 285 627 314 112 316 20 314 627 110 316 627 316 314 626 625 109 627 112 625 626 110 627 626 627 625 322 321 21 633 120 321 322 113 633 322 633 321 632 315 120 314 20 315 632 112 314 632 314 315 631 284 112 286 15 284 631 113 286 631 286 284 633 632 120 631 112 632 633 113 631 633 631 632 364 365 27 651 126 365 364 147 651 364 651 365 649 331 126 330 22 331 649 125 330 649 330 331 648 441 125 440 39 441 648 147 440 648 440 441 651 649 126 648 125 649 651 147 648 651 648 649 408 409 34 646 169 409 408 124 646 408 646 409 647 439 169 441 39 439 647 125 441 647 441 439 645 330 125 329 22 330 645 124 329 645 329 330 646 647 169 645 125 647 646 124 645 646 645 647 402 403 33 691 151 403 402 145 691 402 691 403 692 371 151 370 28 371 692 146 370 692 370 371 690 363 146 362 27 363 690 145 362 690 362 363 691 692 151 690 146 692 691 145 690 691 690 692 328 331 22 643 126 331 328 123 643 328 643 331 650 365 126 363 27 365 650 146 363 650 363 365 642 370 146 369 28 370 642 123 369 642 369 370 643 650 126 642 146 650 643 123 642 643 642 650 476 477 45 728 185 477 476 164 728 476 728 477 729 447 185 446 40 447 729 165 446 729 446 447 727 401 165 400 33 401 727 164 400 727 400 401 728 729 185 727 165 729 728 164 727 728 727 729 368 371 28 701 151 371 368 150 701 368 701 371 702 403 151 401 33 403 702 165 401 702 401 403 700 446 165 445 40 446 700 150 445 700 445 446 701 702 151 700 165 702 701 150 700 701 700 702 438 439 39 738 169 439 438 183 738 438 738 439 737 409 169 407 34 409 737 168 407 737 407 409 736 475 168 474 45 475 736 183 474 736 474 475 738 737 169 736 168 737 738 183 736 738 736 737 444 447 40 734 185 447 444 167 734 444 734 447 735 477 185 475 45 477 735 168 475 735 475 477 733 407 168 406 34 407 733 167 406 733 406 407 734 735 185 733 168 735 734 167 733 734 733 735 329 327 22 640 122 327 329 124 640 329 640 327 639 337 122 336 23 337 639 131 336 639 336 337 644 405 131 408 34 405 644 124 408 644 408 405 640 639 122 644 131 639 640 124 644 640 644 639 414 415 35 662 166 415 414 130 662 414 662 415 663 404 166 405 34 404 663 131 405 663 405 404 661 336 131 335 23 336 661 130 335 661 335 336 662 663 166 661 131 663 662 130 661 662 661 663 369 367 28 641 149 367 369 123 641 369 641 367 637 377 149 376 29 377 637 121 376 637 376 377 636 326 121 328 22 326 636 123 328 636 328 326 641 637 149 636 121 637 641 123 636 641 636 637 334 337 23 638 122 337 334 129 638 334 638 337 635 327 122 326 22 327 635 121 326 635 326 327 634 376 121 375 29 376 634 129 375 634 375 376 638 635 122 634 121 635 638 129 634 638 634 635 445 443 40 699 184 443 445 150 699 445 699 443 697 453 184 452 41 453 697 148 452 697 452 453 696 366 148 368 28 366 696 150 368 696 368 366 699 697 184 696 148 697 699 150 696 699 696 697 374 377 29 698 149 377 374 154 698 374 698 377 695 367 149 366 28 367 695 148 366 695 366 367 694 452 148 451 41 452 694 154 451 694 451 452 698 695 149 694 148 695 698 154 694 698 694 695 406 404 34 731 166 404 406 167 731 406 731 404 730 415 166 413 35 415 730 172 413 730 413 415 732 442 172 444 40 442 732 167 444 732 444 442 731 730 166 732 172 730 731 167 732 731 732 730 450 453 41 743 184 453 450 171 743 450 743 453 744 443 184 442 40 443 744 172 442 744 442 443 742 413 172 412 35 413 742 171 412 742 412 413 743 744 184 742 172 744 743 171 742 743 742 744 335 333 23 658 128 333 335 130 658 335 658 333 657 343 128 342 24 343 657 136 342 657 342 343 660 411 136 414 35 411 660 130 414 660 414 411 658 657 128 660 136 657 658 130 660 658 660 657 420 421 36 674 170 421 420 135 674 420 674 421 675 410 170 411 35 410 675 136 411 675 411 410 673 342 136 341 24 342 673 135 341 673 341 342 674 675 170 673 136 675 674 135 673 674 673 675 375 373 29 659 153 373 375 129 659 375 659 373 655 383 153 382 30 383 655 127 382 655 382 383 654 332 127 334 23 332 654 129 334 654 334 332 659 655 153 654 127 655 659 129 654 659 654 655 340 343 24 656 128 343 340 134 656 340 656 343 653 333 128 332 23 333 653 127 332 653 332 333 652 382 127 381 30 382 652 134 381 652 381 382 656 653 128 652 127 653 656 134 652 656 652 653 451 449 41 708 186 449 451 154 708 451 708 449 706 459 186 458 42 459 706 152 458 706 458 459 705 372 152 374 29 372 705 154 374 705 374 372 708 706 186 705 152 706 708 154 705 708 705 706 380 383 30 707 153 383 380 157 707 380 707 383 704 373 153 372 29 373 704 152 372 704 372 373 703 458 152 457 42 458 703 157 457 703 457 458 707 704 153 703 152 704 707 157 703 707 703 704 412 410 35 740 170 410 412 171 740 412 740 410 739 421 170 419 36 421 739 175 419 739 419 421 741 448 175 450 41 448 741 171 450 741 450 448 740 739 170 741 175 739 740 171 741 740 741 739 456 459 42 749 186 459 456 174 749 456 749 459 750 449 186 448 41 449 750 175 448 750 448 449 748 419 175 418 36 419 748 174 418 748 418 419 749 750 186 748 175 750 749 174 748 749 748 750 341 339 24 670 133 339 341 135 670 341 670 339 669 345 133 344 25 345 669 137 344 669 344 345 672 417 137 420 36 417 672 135 420 672 420 417 670 669 133 672 137 669 670 135 672 670 672 669 425 424 37 678 173 424 425 139 678 425 678 424 677 416 173 417 36 416 677 137 417 677 417 416 676 344 137 350 25 344 676 139 350 676 350 344 678 677 173 676 137 677 678 139 676 678 676 677 381 379 30 671 156 379 381 134 671 381 671 379 667 387 156 386 31 387 667 132 386 667 386 387 666 338 132 340 24 338 666 134 340 666 340 338 671 667 156 666 132 667 671 134 666 671 666 667 349 345 25 668 133 345 349 138 668 349 668 345 665 339 133 338 24 339 665 132 338 665 338 339 664 386 132 388 31 386 664 138 388 664 388 386 668 665 133 664 132 665 668 138 664 668 664 665 457 455 42 714 187 455 457 157 714 457 714 455 712 465 187 464 43 465 712 155 464 712 464 465 711 378 155 380 30 378 711 157 380 711 380 378 714 712 187 711 155 712 714 157 711 714 711 712 385 387 31 713 156 387 385 159 713 385 713 387 710 379 156 378 30 379 710 155 378 710 378 379 709 464 155 463 43 464 709 159 463 709 463 464 713 710 156 709 155 710 713 159 709 713 709 710 418 416 36 746 173 416 418 174 746 418 746 416 745 424 173 423 37 424 745 177 423 745 423 424 747 454 177 456 42 454 747 174 456 747 456 454 746 745 173 747 177 745 746 174 747 746 747 745 462 465 43 754 187 465 462 176 754 462 754 465 755 455 187 454 42 455 755 177 454 755 454 455 753 423 177 422 37 423 753 176 422 753 422 423 754 755 187 753 177 755 754 176 753 754 753 755 463 461 43 719 188 461 463 159 719 463 719 461 718 471 188 470 44 471 718 158 470 718 470 471 717 384 158 385 31 384 717 159 385 717 385 384 719 718 188 717 158 718 719 159 717 719 717 718 393 395 32 720 160 395 393 163 720 393 720 395 716 389 160 384 31 389 716 158 384 716 384 389 715 470 158 469 44 470 715 163 469 715 469 470 720 716 160 715 158 716 720 163 715 720 715 716 422 427 37 752 178 427 422 176 752 422 752 427 756 433 178 431 38 433 756 181 431 756 431 433 751 460 181 462 43 460 751 176 462 751 462 460 752 756 178 751 181 756 752 176 751 752 751 756 468 471 44 761 188 471 468 180 761 468 761 471 762 461 188 460 43 461 762 181 460 762 460 461 760 431 181 430 38 431 760 180 430 760 430 431 761 762 188 760 181 762 761 180 760 761 760 762 359 353 26 685 141 353 359 143 685 359 685 353 684 361 141 360 27 361 684 144 360 684 360 361 687 429 144 432 38 429 687 143 432 687 432 429 685 684 141 687 144 684 685 143 687 685 687 684 440 437 39 693 179 437 440 147 693 440 693 437 689 428 179 429 38 428 689 144 429 689 429 428 688 360 144 364 27 360 688 147 364 688 364 360 693 689 179 688 144 689 693 147 688 693 688 689 394 392 32 686 162 392 394 142 686 394 686 392 682 399 162 398 33 399 682 140 398 682 398 399 681 352 140 356 26 352 681 142 356 681 356 352 686 682 162 681 140 682 686 142 681 686 681 682 362 361 27 683 141 361 362 145 683 362 683 361 680 353 141 352 26 353 680 140 352 680 352 353 679 398 140 402 33 398 679 145 402 679 402 398 683 680 141 679 140 680 683 145 679 683 679 680 469 467 44 726 189 467 469 163 726 469 726 467 724 473 189 472 45 473 724 161 472 724 472 473 723 391 161 393 32 391 723 163 393 723 393 391 726 724 189 723 161 724 726 163 723 726 723 724 400 399 33 725 162 399 400 164 725 400 725 399 722 392 162 391 32 392 722 161 391 722 391 392 721 472 161 476 45 472 721 164 476 721 476 472 725 722 162 721 161 722 725 164 721 725 721 722 430 428 38 758 179 428 430 180 758 430 758 428 757 437 179 436 39 437 757 182 436 757 436 437 759 466 182 468 44 466 759 180 468 759 468 466 758 757 179 759 182 757 758 180 759 758 759 757 474 473 45 765 189 473 474 183 765 474 765 473 764 467 189 466 44 467 764 182 466 764 466 467 763 436 182 438 39 436 763 183 438 763 438 436 765 764 189 763 182 764 765 183 763 765 763 764 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/Tests/__init__.py0000644000175000017500000000001510242725543025331 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/Tests/test.py0000644000175000017500000000432710653444130024557 0ustar debiandebian## Automatically adapted for numpy.oldnumeric Jul 30, 2007 by #from UTpackages.UTsdf import utsdf from string import split import struct, os import unittest def write_file(data, dim, packType = 'f', file = "outfile.rawiv"): """Writes data in .rawiv file.""" nx = ny = nz = dim print "writing to file: %s, data size: %d, %d, %d" % (file, nx,ny,nz) size = nx*ny*nz size1 = (nx-1)*(ny-1)*(nz-1) of = open(file,"wb") #Header: FIXME - not sure if this is right st=(0.0, 0.0, 0.0, float(nx), float(ny),float(nz), size, size1, nx, ny, nz, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0) of.write(apply(struct.pack, ('>6f5I6f',)+st)) #fmt = ">%dB"%size fmt = ">%d%s"%(size, packType) of.write( apply(struct.pack, (fmt,)+tuple(data.ravel()))) def readData (file): f= open(file) l1 = f.readline() str = split(l1) nverts = int(str[0]) ntris = int(str[1]) print "nverts = %d, ntris = %d"%(nverts, ntris) verts = [] tris = [] for i in range(nverts): l = f.readline() str = split(l) if len(str) != 3: print "reading verts: i = %d, str = %s"%(i, str) f.close() return 0,0 v = [float(str[0]), float(str[1]), float(str[2])] verts.append(v) for i in range(ntris): l = f.readline() str = split(l) if len(str) != 3: print "reading tris: i = %d, str = %s"%(i, str) f.close() return 0,0 tri = [int(str[0]), int(str[1]), int(str[2])] tris.append(tri) f.close() return verts, tris def test_0import(): print "test_0import()" from UTpackages.UTsdf import utsdf def test_1lib(): print "test_1lib()" from UTpackages.UTsdf import utsdf verts, tris = readData("eight.raw") dim = 64 utsdf.setParameters(dim, 0, 1, [0,0,0,0,0,0]) datap = utsdf.computeSDF(verts, tris) dim1 = dim+1 size = dim1*dim1*dim1 data = utsdf.createNumArr(datap, dim1*dim1*dim1) print "len(data) = ", len(data) assert len(data) == size outfile = "outsdf.rawiv" write_file(data, dim1,file = outfile) assert os.path.isfile( outfile) if __name__ == '__main__': unittest.main(argv=([__name__,]) ) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/UTsdf/__init__.py0000644000175000017500000000001510242725543024227 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/0000755000175000017500000000000012146213617021663 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/testing.cpp0000644000175000017500000001351410312611777024052 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ /* * Sample parameters: -i eight.raw -e 0 -s 64 */ #include #include #include #include #include "sdfLib.h" int size; bool normal,insidezero; int nverts, ntris; int* tris = NULL; float* verts = NULL; float* values = NULL; char* ifn = NULL; double buffarr[6]; //Functions needed by the RAWIV file writer... int putFloat(float *flts, int n, FILE *fp) { //#ifndef WIN32 // return fwrite(flts, sizeof(float), n, fp); //#else unsigned char *pb = new unsigned char[n*4]; unsigned char *pf = (unsigned char *)flts; int nbytes; //swap the byte order for(int i = 0; i < n; i++) { pb[4*i] = pf[4*i+3]; pb[4*i+1] = pf[4*i+2]; pb[4*i+2] = pf[4*i+1]; pb[4*i+3] = pf[4*i]; } nbytes = fwrite(pb, 1, 4*n, fp); delete pb; return nbytes; //#endif } int putInt(int *Ints, int n, FILE *fp) { //#ifndef WIN32 // return fwrite(Ints, sizeof(int), n, fp); //#else unsigned char *pb = new unsigned char[4*n]; unsigned char *pf = (unsigned char *)Ints; int nbytes; //swap the byte order for(int i = 0; i < n; i++) { pb[4*i] = pf[4*i+3]; pb[4*i+1] = pf[4*i+2]; pb[4*i+2] = pf[4*i+1]; pb[4*i+3] = pf[4*i]; } nbytes=fwrite(pb, 1, 4*n, fp); delete pb; return nbytes; //#endif } void write_RAWIV() { FILE *fp; long int max; char buff[4000]; int temp; float tfloat; sprintf(buff, "output.rawiv"); if ((fp=fopen(buff,"wb")) == NULL) { printf("Cannot open the Output file for RAW output\n"); exit(0); } printf("writing head info \n"); //The origin 0,0,0 tfloat = 0; putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); //The max (size+1),(size+1),(size+1) tfloat = (float) size+1; putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); //The #of vertices temp=(size+1)*(size+1)*(size+1); putInt(&temp,1,fp); //The #of cells temp=(size)*(size)*(size); putInt(&temp,1,fp); //The dim of the volume temp=size+1; putInt(&temp,1,fp); putInt(&temp,1,fp); putInt(&temp,1,fp); //The Origin of the volume tfloat = 0; putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); // origin //The span of the volume tfloat = 1; putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); putFloat(&tfloat,1,fp); //span printf("writing data \n"); max = (long int)((size+1)* (size+1) * (size+1)); //for the Voxels. putFloat(&(values[0]),max,fp); fclose(fp); } void readGeometry(char* ifname) { FILE *fp; int i; float temp[3]; if ((fp = fopen(ifname, "r")) == NULL) { fprintf(stderr, "ERROR: fopen(%s)\n", ifname); exit(0); } printf("Reading Geometry: %s\n", ifname); if (fscanf(fp,"%d %d", &nverts, &ntris) == EOF) { printf("Input file is not valid....Exiting...\n"); exit(0); } printf("vert= %d and tri = %d \n", nverts,ntris); verts = (float*) malloc (sizeof (float) *3 * nverts); tris = (int*) malloc (sizeof (int) *3 * ntris); for (i=0; i -s -n -z -h \n"); printf("\t (string) Name of the input file (.RAW format)\n"); printf("\t (int) The grid size has to be 64, 128 or 256 or 512\n"); printf("\t (0 or 1) Flip normals of the input file?\n"); } void parse_config (int argc, char *argv[]) { int i, j; for (i=1; i Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include #include #include "common.h" using namespace SDFLibrary; extern int point_in_polygon(myPoint result, int tri); extern int ray_polygon_intersection (ray r, int tri); extern void apply_distance_transform(int vi, int vj, int vk); extern int confirm_SDF(int flag); int x_assign(int vi, int vj, int vk) { int i, j, k, inters, temp, flag, v; listnode* currNode; ray r; int pts[50]; //the given ray cant intersect the surface more than 50 times... //pick a direction n shoot rays to the outside BB. i=(int)vi; j= (int)vj; k= (int)vk; r.ox = (double)vi; r.oy = (double)vj; r.oz = (double)vk; r.dx =1.0f; r.dy =0.0f; r.dz =0.0f; inters=0; v = i; for (i=v; iindex); if (temp ==1) { flag =0; for (temp=0; tempindex) flag=1; } if (flag ==0) pts[inters++] = currNode->index; } currNode = currNode->next; } } } return (inters); } int y_assign(int vi, int vj, int vk) { int i, j, k, inters, temp, flag, v; listnode* currNode; ray r; int pts[50]; //the given ray cant intersect the surface more than 50 times... //pick a direction n shoot rays to the outside BB. i=(int)vi; j= (int)vj; k= (int)vk; r.ox = (double)vi; r.oy = (double)vj; r.oz = (double)vk; r.dx =0.0f; r.dy =1.0f; r.dz =0.0f; inters=0; v = j; for (j=v; jindex); if (temp ==1) { flag =0; for (temp=0; tempindex) flag=1; } if (flag ==0) pts[inters++] = currNode->index; } currNode = currNode->next; } } } return (inters); } int z_assign(int vi, int vj, int vk) { int i, j, k, inters, temp, flag, v; listnode* currNode; ray r; int pts[50]; //the given ray cant intersect the surface more than 50 times... //pick a direction n shoot rays to the outside BB. i=(int)vi; j= (int)vj; k= (int)vk; r.ox = (double)vi; r.oy = (double)vj; r.oz = (double)vk; r.dx =0.0f; r.dy =0.0f; r.dz =1.0f; inters=0; v = k; for (k=v; kindex); if (temp ==1) { flag =0; for (temp=0; tempindex) flag=1; } if (flag ==0) pts[inters++] = currNode->index; } currNode = currNode->next; } } } return (inters); } int klc_assign(int vi, int vj, int vk) { int inters[3]; if ((vi<=0) || (vj<=0) || (vk<=0) || (vi>=size) || (vj>=size) || (vk>=size)) { return 1; } else { inters[0] = x_assign(vi, vj, vk); inters[1] = y_assign(vi, vj, vk); inters[2] = z_assign(vi, vj, vk); } if ( (inters[0]%2 ==0) && (inters[1]%2 ==0) && (inters[2]%2 ==0) ) return 1; else if ( (inters[0]%2 ==1) && (inters[1]%2 ==1) && (inters[2]%2 ==1) ) return -1; //Else, u have run into some doubleing pt. error and need to count the #of intersections. if ( ((inters[0]%2) + (inters[1]%2) + (inters[2]%2)) %2 ==1) return 1; else return -1; /* if ((vi<=0) || (vj<=0) || (vk<=0) || (vi>=size) || (vj>=size) || (vk>=size)) return 1; if (x_assign(vi, vj, vk) %2 ==0) return 1; return -1; */ } double sort_3_distances(double vals[3], myPoint closest[3], myPoint* inter) { double dist; if (vals[0] <= vals[1]) { if (vals[0] <=vals[2]) { dist = vals[0]; inter->x = closest[0].x; inter->y = closest[0].y; inter->z = closest[0].z; } else { dist = vals[2]; inter->x = closest[2].x; inter->y = closest[2].y; inter->z = closest[2].z; } } else { if (vals[1] <=vals[2]) { dist = vals[1]; inter->x = closest[1].x; inter->y = closest[1].y; inter->z = closest[1].z; } else { dist = vals[2]; inter->x = closest[2].x; inter->y = closest[2].y; inter->z = closest[2].z; } } return dist; } //project the point proj onto the line i-j and find the nearest point. double getClipPoint(int one, int two, int i, int j, int k, myPoint* inter) { double denom, theta, tempLen, t; double d1, d2, d3, e1, e2, e3; //1) Normalize the triangle edge and the line from a vertex to the point. d1 = vertices[one].x - vertices[two].x; d2 = vertices[one].y - vertices[two].y; d3 = vertices[one].z - vertices[two].z; denom = d1*d1 + d2*d2 + d3*d3; denom = sqrt(denom); tempLen = denom; //len of the tri edge d1 /=denom; d2 /=denom; d3 /=denom; e1 = (double)i - vertices[two].x; e2 = (double)j - vertices[two].y; e3 = (double)k - vertices[two].z; denom = e1*e1 + e2*e2 + e3*e3; if (isZero(denom)) { //Then, the pt is CLOSE to the vertex TWO. inter->x = vertices[two].x; inter->y = vertices[two].y; inter->z = vertices[two].z; return fabs(denom); } denom = sqrt(denom); //len of the line from point to tri vertex. e1 /=denom; e2 /=denom; e3 /=denom; //2) Find the angle between these lines. theta = e1*d1 + e2*d2 + e3*d3; if (isZero(theta)) { d1 = (double)i - vertices[one].x; d2 = (double)j - vertices[one].y; d3 = (double)k - vertices[one].z; theta = sqrt(d1*d1 + d2*d2 + d3*d3); if (theta <=denom) { inter->x = vertices[one].x; inter->y = vertices[one].y; inter->z = vertices[one].z; return fabs(theta); } else { inter->x = vertices[two].x; inter->y = vertices[two].y; inter->z = vertices[two].z; return fabs(denom); } } if (theta <0) { inter->x = vertices[two].x; inter->y = vertices[two].y; inter->z = vertices[two].z; return (denom); } else if ((denom * theta) > tempLen) { d1 = (double)i - vertices[one].x; d2 = (double)j - vertices[one].y; d3 = (double)k - vertices[one].z; theta = d1*d1 + d2*d2 + d3*d3; inter->x = vertices[one].x; inter->y = vertices[one].y; inter->z = vertices[one].z; return sqrt(theta); } else { t = denom*theta; theta = acos(theta); inter->x = vertices[two].x + t*(vertices[one].x - vertices[two].x); inter->y = vertices[two].y + t*(vertices[one].y - vertices[two].y); inter->z = vertices[two].z + t*(vertices[one].z - vertices[two].z); return fabs((sin(theta) *denom)); } } //compute the least distance of the triangle TRI to the vertex (i,j,k). double point_2_plane(int tri, int i, int j, int k, myPoint* inter) { double dist, temp[3]; int fact; myPoint res, val[3]; //1) First compute the shortest signed distance between the Vertex and the Plane of the Triangle. dist = ( ((( (double)i)* normals[tri].x + ((double)j)* normals[tri].y + ((double)k)* normals[tri].z)) + distances[tri]); if (isZero(dist)) { res.x =1.0f*i; res.y =1.0f*j; res.z =1.0f*k; if(point_in_polygon(res, tri)) { (*inter).x = res.x; (*inter).y = res.y; (*inter).z = res.z; return fabs(dist); } } if (dist <0) fact = -1; else fact = 1; //2) Then chq if the projected point is within the triangle or not. if yes, then the above is the correct shortest distance. res.x = (double)(i -normals[tri].x*dist); res.y = (double)(j -normals[tri].y*dist); res.z = (double)(k -normals[tri].z*dist); if (point_in_polygon(res, tri)) { (*inter).x = res.x; (*inter).y = res.y; (*inter).z = res.z; return fabs(dist); } //3) now, project the planeProj onto the edge "i <-> j" and get the nearest point on the line segment to this point. temp[0] = getClipPoint(surface[tri].v1, surface[tri].v2, i, j, k, &val[0]); temp[1] = getClipPoint(surface[tri].v3, surface[tri].v2, i, j, k, &val[1]); temp[2] = getClipPoint(surface[tri].v1, surface[tri].v3, i, j, k, &val[2]); dist = sort_3_distances(temp, val, inter); if (dist >= (MAX_DIST) || dist <= (-1*MAX_DIST)) printf("err vert= %d %d %d tri= %d\n", i, j, k, tri); return dist; } //compute the distance of each Triangle in the cell (ci,cj,ck) from the Vertex vert. int each_cell(int ci, int cj, int ck, int vi, int vj, int vk) { int vert, currrentTri; listnode* currNode; double val; myPoint temp; int res =0; vert = index2vert(vi, vj, vk); currNode = sdf[ci][cj][ck].tindex; if ((vert==10301) || (vert ==10302)) res=0; while (currNode != NULL) { currrentTri = currNode->index; val = (double)point_2_plane(currrentTri, vi, vj, vk, &temp); if (val < values[vert].value ) { values[vert].value = (float)val; values[vert].closestV.x = temp.x; values[vert].closestV.y = temp.y; values[vert].closestV.z = temp.z; } currNode = currNode->next; res =1; } values[vert].processed =1; if (values[vert].value >= (MAX_DIST) || values[vert].value <= (-1*MAX_DIST)) printf("err vert= %d %d %d \n", vi, vj, vk); return res; } //Just compute the Distance Function for the given vert. void compute_SDF(int i, int j, int k) { int level, ci, cj, ck; //Get the corresponding Octree cell. if (i == size) ci = i-1; else ci=i; if (j == size) cj = j-1; else cj=j; if (k == size) ck = k-1; else ck=k; level =1; for (ci=i-level; ci<=i+level; ci++) { for (cj=j-level; cj<=j+level; cj++) { for (ck=k-level; ck<=k+level; ck++) { if ((ci < 0) || (ci >= size)) continue; if ((cj < 0) || (cj >= size)) continue; if ((ck < 0) || (ck >= size)) continue; if (sdf[ci][cj][ck].useful >0) each_cell(ci, cj, ck, i, j, k); } } } } void compute_boundarySDF() { int ind, i, j, k; for (ind =0; ind Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include #include "common.h" namespace SDFLibrary{ double MAX_DIST; int size; int total_points, total_triangles, all_verts_touched; double minx, miny, minz, maxx, maxy, maxz; double TOLERANCE; int octree_depth; int flipNormals; int insideZero; SDFLibrary::triangle* surface; SDFLibrary::myVert* vertices; SDFLibrary::myPoint* normals; SDFLibrary::cell*** sdf; SDFLibrary::voxel* values; double* distances; char *ifname; bool* bverts; int* queues; double buffArr[6]; } void init_all_vars() { SDFLibrary::TOLERANCE = 1e-6; SDFLibrary::size =64; SDFLibrary::flipNormals =0; SDFLibrary::insideZero =1; SDFLibrary::ifname= NULL; SDFLibrary::surface = NULL; SDFLibrary::vertices = NULL; SDFLibrary::normals = NULL; SDFLibrary::distances = NULL; SDFLibrary::sdf = NULL; SDFLibrary::values = NULL; SDFLibrary::bverts = NULL; SDFLibrary::queues = NULL; SDFLibrary::total_points = SDFLibrary::total_triangles = SDFLibrary::all_verts_touched= 0; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/new_adjust.cpp0000644000175000017500000001511010271742357024535 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include #include "common.h" using namespace SDFLibrary; int* neighbors; int usedNeighs, prevUsed, total_done; std::map myMap; std::map::const_iterator iter; void re_orient_all() { int i, closestTri; int inside_point = -1; double err, dist; //double lamda = -0.5; //The dist that the pt is going to be moved inside the surface, along the normal. err = size*size*size; for (i=0; i 0) { printf("Normals are correctly oriented\n"); } else { for (i=0; i : %d %d %d %d\n", one, two, ver1, ver2); return 1; //wot 2 return... :-( } if (isAligned(v1, v2)) { if (isAligned(c1, c2)) { //problemo. exchangeVerts(two, ver1, ver2); return 0; } else { //no problemo return 1; } } else { if (isAligned(c1, c2)) { //no problemo. return 1; } else { //problemo exchangeVerts(two, ver1, ver2); return 0; } } } void insert_tri(int tri) { if (surface[tri].type == -1) return; iter = myMap.find(tri); if(iter == myMap.end()) //ie not found { myMap[tri] = tri; neighbors[usedNeighs++] = tri; total_done++; } } void align_us(int with, int what, int vert) { int i, j, flag=-1; int v1[3], v2[3]; if (surface[what].type != -1) return; v1[0] = surface[with].v1; v1[1] = surface[with].v2; v1[2] = surface[with].v3; v2[0] = surface[what].v1; v2[1] = surface[what].v2; v2[2] = surface[what].v3; for (i=0; i<3; i++) { if (v1[i] == vert) continue; for (j=0; j<3; j++) { if (v2[j] == vert) continue; if (v1[i] == v2[j]) flag = v1[i]; } } if (flag == -1) return; //then compare the two triangles. if (triangle_angles(with, what, vert, flag)) surface[what].type = surface[with].type; else { normals[what].x *= -1; normals[what].y *= -1; normals[what].z *= -1; distances[what] *= -1; //need to re-calculate the distances also. surface[what].type = !(surface[with].type); } //Then insert this triangle into the NEIGHBORS array. insert_tri(what); } void orient_vert(int tri, int vert) { int i; for (i=0; i started...\n"); myMap.clear(); lastone = usedNeighs= total_done =0; while (1) { prevUsed = usedNeighs; printf("still processing with %d Triangles\n", prevUsed); if (lastone == prevUsed) getNextComponent(); else lastone = prevUsed; for (i=0; i over...\n"); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/init.cpp0000644000175000017500000002422710312612137023332 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include #include #include "common.h" using namespace SDFLibrary; extern void update_bounding_box( long int current_triangle, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int cur_level ); extern void check_octree(); extern void start_fireworks(); extern int putdouble(double *flts, int n, FILE *fp); extern int putInt(int *Ints, int n, FILE *fp); int maxInd; double TRANS_X, TRANS_Y, TRANS_Z, SCALE; void build_octree() { double t1, t2; t1 = getTime(); for (int i =0; i= MAX_TRIS_PER_VERT) { printf("more than %d triangles share this vertex... %d for vert=%d\n", MAX_TRIS_PER_VERT, vertices[ surface[i].v1 ].trisUsed, surface[i].v1); flag =1; } if (vertices[ surface[i].v2 ].trisUsed >= MAX_TRIS_PER_VERT) { printf("more than %d triangles share this vertex... %d for vert=%d\n", MAX_TRIS_PER_VERT, vertices[ surface[i].v2 ].trisUsed, surface[i].v2); flag =1; } if (vertices[ surface[i].v3 ].trisUsed >= MAX_TRIS_PER_VERT) { printf("more than %d triangles share this vertex... %d for vert=%d\n", MAX_TRIS_PER_VERT, vertices[ surface[i].v3 ].trisUsed, surface[i].v3); flag =1; } //If any of these above statements are printed, then please increase the MAX_TRIS_PER_VERT definition in head.h file and try. if (flag ==1) { printf("Please try changing the MAX_TRIS_PER_VERT variable in file and rerun\n"); exit(0); } } } /**** void adjustData() { double tx, ty, tz; double cx, cy, cz; int i; //shift the entire inputS into the octreeArray grid (0 to size) //TRANS_X = minx-2; //TRANS_Y = miny-2; //TRANS_Z = minz-2; tx = maxx - minx; ty = maxy - miny; tz = maxz - minz; cx = (maxx- minx)/2.0f + minx; cy = (maxy- miny)/2.0f + miny; cz = (maxz- minz)/2.0f + minz; if (tx>ty) { if (tx>tz) SCALE = tx; else SCALE = tz; } else { if (ty>tz) SCALE = ty; else SCALE = tz; } SCALE = (size - 4.0f) / SCALE ; //make sure that the re-scaled data fits into the octree grid. for (i = 0; i < total_points; i++) { vertices[i].x = (((vertices[i].x - cx) * SCALE) + (size/2.0f)); vertices[i].y = (((vertices[i].y - cy) * SCALE) + (size/2.0f)); vertices[i].z = (((vertices[i].z - cz) * SCALE) + (size/2.0f)); } minx = (minx - cx) * SCALE + (size/2.0f); miny = (miny - cy) * SCALE + (size/2.0f); minz = (minz - cz) * SCALE + (size/2.0f); maxx = (maxx - cx) * SCALE + (size/2.0f); maxy = (maxy - cy) * SCALE + (size/2.0f); maxz = (maxz - cz) * SCALE + (size/2.0f); printf("translate distances are: %f %f %f and scale factor is: %f \n", TRANS_X, TRANS_Y, TRANS_Z, SCALE); printf("Moved Bounding box is: %f %f %f to %f %f %f \n", minx, miny, minz, maxx, maxy, maxz); //Then re-calculate the normals of the triangles. reverse_ptrs(); //This wud align them in a consistent manner. ie: all out or all in. :-) if (flipNormals) start_fireworks(); //Then build the Octree. build_octree(); } ****/ void adjustData() { double tx, ty, tz; double cx, cy, cz; int i; //shift the entire inputS into the octreeArray grid (0 to size) TRANS_X = buffArr[0] + buffArr[1]; TRANS_Y = buffArr[2] + buffArr[3]; TRANS_Z = buffArr[4] + buffArr[5]; tx = maxx - minx; ty = maxy - miny; tz = maxz - minz; tx = (size-TRANS_X)/tx; ty = (size-TRANS_Y)/ty; tz = (size-TRANS_Z)/tz; cx = (maxx- minx)/2.0f + minx; cy = (maxy- miny)/2.0f + miny; cz = (maxz- minz)/2.0f + minz; if (tx maxx) maxx = (double) vertices[i].x; if (vertices[i].y > maxy) maxy = (double) vertices[i].y; if (vertices[i].z > maxz) maxz = (double) vertices[i].z; } void readGeom(int nverts, float* verts, int ntris, int* tris) { int i; total_points = nverts; total_triangles = ntris; printf("vert= %d and tri = %d \n", total_points,total_triangles); vertices = (myVert*) malloc (sizeof (myVert) * total_points); surface = (triangle*) malloc (sizeof (triangle) * total_triangles); normals = (myPoint*) malloc (sizeof (myPoint) * total_triangles); distances = (double*) malloc (sizeof (double) * total_triangles); for (i=0; i Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #ifndef COMMON_H #define COMMON_H #ifdef _MSC_VER #pragma warning (disable : 4786) #endif //_MSC_VER #include #include #include #include "head.h" void initSDF(); void readGeom(int nverts, float* verts, int ntris, int* tris); void adjustData(); void compute(); int isEqual (double one, double two); int isZero(double num); int isNegative(double num); int isBetween(double one, double two, double num); int isZero(SDFLibrary::myPoint one); int isSame(SDFLibrary::myPoint one, SDFLibrary::myPoint two); void init_all_vars(); void propagate_left(int i, int j, int k); void propagate_bottom(int i, int j, int k); void propagate_inside(int i, int j, int k); void propagate_right(int i, int j, int k); void propagate_top(int i, int j, int k); void propagate_outside(int i, int j, int k); void apply_distance_transform(int vi, int vj, int vk); void insert_bound_vert(int vert); int index2vert(int i, int j, int k); void _vert2index(int c, int &i, int &j, int &k); double xCoord(int i); double yCoord(int i); double zCoord(int i); double getTime(); namespace SDFLibrary { extern double MAX_DIST; extern int size; extern triangle* surface; extern myVert* vertices; extern myPoint* normals; extern double* distances; extern cell*** sdf; extern voxel* values; extern int total_points, total_triangles, all_verts_touched; extern double minx, miny, minz, maxx, maxy, maxz; extern double TOLERANCE; extern int octree_depth; extern int flipNormals; extern int insideZero; extern double buffArr[6]; extern bool *bverts; extern int *queues; }; //namespace SDFLibrary #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/Makefile0000644000175000017500000000113610242725543023325 0ustar debiandebianOBJS = common.o compute.o init.o main.o head.o new_adjust.o octree.o propagate.o LIBNAME = sdfLib.a $(LIBNAME) : $(OBJS) ar rv $(LIBNAME) $(OBJS) $(OBJS): common.h head.h sdfLib.h common.o: common.cpp g++ -Wall -c common.cpp compute.o: compute.cpp g++ -Wall -c compute.cpp init.o: init.cpp g++ -Wall -c init.cpp main.o: main.cpp g++ -Wall -c main.cpp new_adjust.o: new_adjust.cpp g++ -Wall -c new_adjust.cpp octree.o: octree.cpp g++ -Wall -c octree.cpp head.o: head.cpp g++ -Wall -c head.cpp propagate.o: propagate.cpp g++ -Wall -c propagate.cpp .PHONY: clean clean: rm -f $(OBJS) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/propagate.cpp0000644000175000017500000001065610242725543024362 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include "common.h" using namespace SDFLibrary; double dist_grid_3Dpts(int one, int two) { int vi, vj, vk; double ui, uj, uk; _vert2index(one, vi, vj, vk); ui = values[two].closestV.x; uj = values[two].closestV.y; uk = values[two].closestV.z; return (sqrt( (vi-ui)*(vi-ui) + (vj-uj)*(vj-uj) + (vk-uk)*(vk-uk)) ); } void update_distance_2_vertex(int ind, int vi, int vj, int vk) { double val; int upd; upd = index2vert(vi, vj, vk); if ( (vi>=0) && (vi<=size) ) { if ( (vj>=0) && (vj<=size) ) { if ( (vk>=0) && (vk<=size) ) { if (values[upd].processed == 1) return; //if (values[ind].signe*values[upd].signe <0) // return; val = dist_grid_3Dpts(upd, ind); if (val < values[upd].value ) { values[upd].value = (float)val; values[upd].closestV.x = values[ind].closestV.x; values[upd].closestV.y = values[ind].closestV.y; values[upd].closestV.z = values[ind].closestV.z; } insert_bound_vert(upd); } } } } //Current implementation only does the COMPLETE 3X3 Distance Matrix void apply_distance_transform(int vi, int vj, int vk) { int ind; //Current vertex ind = index2vert(vi, vj, vk); //Front Y slice update_distance_2_vertex(ind, vi-1, vj-1, vk-1); update_distance_2_vertex(ind, vi, vj-1, vk-1); update_distance_2_vertex(ind, vi+1, vj-1, vk-1); update_distance_2_vertex(ind, vi-1, vj-1, vk); update_distance_2_vertex(ind, vi, vj-1, vk); update_distance_2_vertex(ind, vi+1, vj-1, vk); update_distance_2_vertex(ind, vi-1, vj-1, vk+1); update_distance_2_vertex(ind, vi, vj-1, vk+1); update_distance_2_vertex(ind, vi+1, vj-1, vk+1); //Middle Y slice update_distance_2_vertex(ind, vi-1, vj, vk-1); update_distance_2_vertex(ind, vi, vj, vk-1); update_distance_2_vertex(ind, vi+1, vj, vk-1); update_distance_2_vertex(ind, vi-1, vj, vk); //update_distance_2_vertex(ind, vi, vj, vk); //Current vertex update_distance_2_vertex(ind, vi+1, vj, vk); update_distance_2_vertex(ind, vi-1, vj, vk+1); update_distance_2_vertex(ind, vi, vj, vk+1); update_distance_2_vertex(ind, vi+1, vj, vk+1); //Back Y slice update_distance_2_vertex(ind, vi-1, vj+1, vk-1); update_distance_2_vertex(ind, vi, vj+1, vk-1); update_distance_2_vertex(ind, vi+1, vj+1, vk-1); update_distance_2_vertex(ind, vi-1, vj+1, vk); update_distance_2_vertex(ind, vi, vj+1, vk); update_distance_2_vertex(ind, vi+1, vj+1, vk); update_distance_2_vertex(ind, vi-1, vj+1, vk+1); update_distance_2_vertex(ind, vi, vj+1, vk+1); update_distance_2_vertex(ind, vi+1, vj+1, vk+1); } void insert_bound_vert(int vert) { if(bverts[vert] == 0) //ie not found { bverts[vert] =1; queues[all_verts_touched++] = vert; } } void propagate_from_here(int vert) { int i, j, k, ci, cj, ck, level, ind, test; int MAX_LEVELS =10; _vert2index(vert, i, j, k); if (i == size) ci = i-1; else ci=i; if (j == size) cj = j-1; else cj=j; if (k == size) ck = k-1; else ck=k; for (level=1; level= size)) continue; if ((cj < 0) || (cj >= size)) continue; if ((ck < 0) || (ck >= size)) continue; ind = index2vert(ci, cj, ck); test = values[ind].processed; test = values[ind].signe; test = (int)values[ind].value; if ( (values[ind].processed ==1) && (values[ind].value != MAX_DIST) ) update_distance_2_vertex(ind, i, j, k); } } } } } int confirm_SDF(int flag) { int i, grid_pts; grid_pts = (size+1)*(size+1)*(size+1); for (i=0; i Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include #include #include "common.h" using namespace SDFLibrary; long int INF = 9999999; #define PI 3.14159 double n_dotv( double x, double y, double z, ray r , double temp123); myPoint inbox ( ray r, myPoint p, double dist, double* t); int ray_polygon_intersection (ray r, int tri); myPoint normalize(double x, double y, double z) ; int max_3( double x, double y, double z ); int inside_cube(ray r, double xmin, double xmax, double ymin, double ymax, int flag); int point_in_polygon(myPoint result, int tri); void update_boundary_vertices(int cx, int cy, int cz); int within( int tri, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax ) { int v1, v2, v3; double t; double x0, y0, z0, x1, y1, z1, x2, y2, z2; myPoint p,one,two,three; ray r; v1 = surface[tri].v1; v2 = surface[tri].v2; v3 = surface[tri].v3; // find if completely on some side ! x0 = vertices[v1].x; y0 = vertices[v1].y; z0 = vertices[v1].z; x1 = vertices[v2].x; y1 = vertices[v2].y; z1 = vertices[v2].z; x2 = vertices[v3].x; y2 = vertices[v3].y; z2 = vertices[v3].z; // If all 3 vertices on same side, then return 0 if( (x0xmax) && (x1>xmax) && (x2>xmax) ) return 0; if( (y0ymax) && (y1>ymax) && (y2>ymax) ) return 0; if( (z0zmax) && (z1>zmax) && (z2>zmax) ) return 0; //if either of the 3 points are inside the cube, then the Trianlge MUST intersect the cube.... if ( (isBetween(xmin, xmax, x0)) && (isBetween(ymin, ymax, y0)) && (isBetween(zmin, zmax, z0)) ) return 1; if ( (isBetween(xmin, xmax, x1)) && (isBetween(ymin, ymax, y1)) && (isBetween(zmin, zmax, z1)) ) return 1; if ( (isBetween(xmin, xmax, x2)) && (isBetween(ymin, ymax, y2)) && (isBetween(zmin, zmax, z2)) ) return 1; //then the dammed cases when the Triangle intersects any face (edge) of the cube or vice versa... //A) Triangle with the cube... r.ox = (double)x0; r.oy = (double)y0; r.oz = (double)z0; r.dx = (double)(x1-x0); r.dy = (double)(y1-y0); r.dz = (double)(z1-z0); //1) a> edge1 with face 1 ... one = normalize(xmax- xmin,0,0); p = inbox(r,one,-xmin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, zmin, zmax, 1)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(ymin, ymax, p.y)) && isBetween(zmin, zmax, p.z)) return 1; } //1) b> edge1 with face 4... one = normalize(xmax- xmin,0,0); p = inbox(r,one,-xmax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, zmin, zmax, 1)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(ymin, ymax, p.y)) && isBetween(zmin, zmax, p.z)) return 1; } //1) c> edge1 with face 2... one = normalize(0,ymax-ymin,0); p = inbox(r,one,-ymin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, xmin, xmax, zmin, zmax, 2)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(zmin, zmax, p.z)) return 1; } //1) d> edge1 with face 5... one = normalize(0,ymax-ymin,0); p = inbox(r,one,-ymax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, xmin, xmax, zmin, zmax, 2)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(zmin, zmax, p.z)) return 1; } //1) e> edge1 with face 3... one = normalize(0,0,zmax-zmin); p = inbox(r,one,-zmin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, xmin, xmax, 3)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(ymin, ymax, p.y)) return 1; } //1) f> edge1 with face 6... one = normalize(0,0,zmax-zmin); p = inbox(r,one,-zmax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, xmin, xmax, 3)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(ymin, ymax, p.y)) return 1; } ///////////////////////////////// r.ox = (double)x1; r.oy = (double)y1; r.oz = (double)z1; r.dx = (double)(x2-x1); r.dy = (double)(y2-y1); r.dz = (double)(z2-z1); //2) a> edge2 with face 1 ... one = normalize(xmax-xmin,0,0); p = inbox(r,one,-xmin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, zmin, zmax, 1)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(ymin, ymax, p.y)) && isBetween(zmin, zmax, p.z)) return 1; } //2) b> edge2 with face 4...klc one = normalize(xmax- xmin,0,0); p = inbox(r,one,-xmax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, zmin, zmax, 1)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(ymin, ymax, p.y)) && isBetween(zmin, zmax, p.z)) return 1; } //2) c> edge2 with face 2... one = normalize(0,ymax-ymin,0); p = inbox(r,one,-ymin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, xmin, xmax, zmin, zmax, 2)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(zmin, zmax, p.z)) return 1; } //2) d> edge2 with face 5... one = normalize(0,ymax-ymin,0); p = inbox(r,one,-ymax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, xmin, xmax, zmin, zmax, 2)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(zmin, zmax, p.z)) return 1; } //2) e> edge2 with face 3... one = normalize(0,0,zmax-zmin); p = inbox(r,one,-zmin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, xmin, xmax, 3)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(ymin, ymax, p.y)) return 1; } //2) f> edge2 with face 6... one = normalize(0,0,zmax-zmin); p = inbox(r,one,-zmax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, xmin, xmax, 3)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(ymin, ymax, p.y)) return 1; } ///////////////////////////////// r.ox = (double)x2; r.oy = (double)y2; r.oz = (double)z2; r.dx = (double)(x0-x2); r.dy = (double)(y0-y2); r.dz = (double)(z0-z2); //3) a> edge3 with face 1 ... one = normalize(xmax- xmin,0,0); p = inbox(r,one,-xmin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, zmin, zmax, 1)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(ymin, ymax, p.y)) && isBetween(zmin, zmax, p.z)) return 1; } //3) b> edge3 with face 4... one = normalize(xmax- xmin,0,0); p = inbox(r,one,-xmax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, zmin, zmax, 1)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(ymin, ymax, p.y)) && isBetween(zmin, zmax, p.z)) return 1; } //3) c> edge3 with face 2... one = normalize(0,ymax-ymin,0); p = inbox(r,one,-ymin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, xmin, xmax, zmin, zmax, 2)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(zmin, zmax, p.z)) return 1; } //3) d> edge3 with face 5... one = normalize(0,ymax-ymin,0); p = inbox(r,one,-ymax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, xmin, xmax, zmin, zmax, 2)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(zmin, zmax, p.z)) return 1; } //3) e> edge3 with face 3... one = normalize(0,0,zmax-zmin); p = inbox(r,one,-zmin, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, xmin, xmax, 3)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(ymin, ymax, p.y)) return 1; } //3) f> edge3 with face 6... one = normalize(0,0,zmax-zmin); p = inbox(r,one,-zmax, &t); if((p.isNull)) { if ( (isEqual(1.0, t)) && (inside_cube(r, ymin, ymax, xmin, xmax, 3)) ) return 1; } else { if(isBetween(0.0, 1.0, t)) if ((isBetween(xmin, xmax, p.x)) && isBetween(ymin, ymax, p.y)) return 1; } /////////////////////////// //Then the case where the Cube intersects the Triangle... one.x = (double)x0; one.y = (double)y0; one.z = (double)z0; two.x = (double)x1; two.y = (double)y1; two.z = (double)z1; three.x = (double)x2; three.y = (double)y2; three.z = (double)z2; //2)1 a>. r.ox = (double)xmin; r.oy = (double)ymin; r.oz = (double)zmin; r.dx = (double)0; r.dy = (double)0; r.dz = (double)(zmax-zmin); if (ray_polygon_intersection(r, tri)) return 1; //2)1 b>. r.dx = (double)(xmax-xmin); r.dy = (double)0; r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; //2)1 c>. r.dx = (double)0; r.dy = (double)(ymax-ymin); r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; //2)2 a>. r.ox = (double)xmax; r.oy = (double)ymax; r.oz = (double)zmax; r.dx = (double)0; r.dy = (double)0; r.dz = (double)(-(zmax-zmin)); if (ray_polygon_intersection(r, tri)) return 1; //2)2 b>. r.dx = (double)(-(xmax-xmin)); r.dy = (double)0; r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; //2)2 c>. r.dx = (double)0; r.dy = (double)(-(ymax-ymin)); r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; //2)3 a>. r.ox = (double)xmax; r.oy = (double)ymax; r.oz = (double)zmin; r.dx = (double)0; r.dy = (double)(-(ymax-ymin)); r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; //2)3 c>. r.dx = (double)(-(xmax-xmin)); r.dy = (double)0; r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; //2)4 a>. r.ox = (double)xmax; r.oy = (double)ymin; r.oz = (double)zmax; r.dx = (double)0; r.dy = (double)0; r.dz = (double)(-(zmax-zmin)); if (ray_polygon_intersection(r, tri)) return 1; //2)4 b>. r.dx = (double)(-(xmax-xmin)); r.dy = (double)0; r.dz = (double)0; p.isNull = 0; if (ray_polygon_intersection(r, tri)) return 1; //2)5 a>. r.ox = (double)xmin; r.oy = (double)ymax; r.oz = (double)zmax; r.dx = (double)0; r.dy = (double)0; r.dz = (double)(-(zmax-zmin)); if (ray_polygon_intersection(r, tri)) return 1; //2)5 b>. r.dx = (double)0; r.dy = (double)(-(ymax-ymin)); r.dz = (double)0; if (ray_polygon_intersection(r, tri)) return 1; return 0; } void update_bounding_box( long int current_triangle, double xmin, double xmax, double ymin, double ymax, double zmin, double zmax, int cur_level ) { int intersects = 0; int i, j, k; listnode* l; listnode* temp; i = (int) (xmax + xmin)/2; j = (int) (ymax + ymin)/2; k = (int) (zmax + zmin)/2; intersects = 0; if( within(current_triangle, xmin, xmax, ymin, ymax, zmin, zmax ) ) intersects = 1; if( intersects ) { if( cur_level < octree_depth ) { update_bounding_box( current_triangle, xmin, ( xmax + xmin ) /2.0, ( ymax + ymin ) /2.0, ymax, zmin, ( zmax+ zmin ) /2.0, cur_level+1 ); update_bounding_box( current_triangle, ( xmax + xmin ) /2.0, xmax, ( ymax + ymin ) /2.0, ymax, zmin, ( zmax+ zmin ) /2.0, cur_level+1 ); update_bounding_box( current_triangle, ( xmax + xmin ) /2.0, xmax, ( ymax + ymin ) /2.0, ymax, ( zmax + zmin ) /2.0, zmax, cur_level+1 ); update_bounding_box( current_triangle, xmin, ( xmax + xmin ) /2.0, ( ymax + ymin ) /2.0, ymax, ( zmax + zmin ) /2.0, zmax, cur_level+1 ); update_bounding_box( current_triangle, xmin, ( xmax + xmin ) /2.0, ymin, ( ymax + ymin ) /2.0, zmin, ( zmax+ zmin ) /2.0, cur_level+1 ); update_bounding_box( current_triangle, ( xmax + xmin ) /2.0, xmax, ymin, ( ymax + ymin ) /2.0, zmin, ( zmax+ zmin ) /2.0, cur_level+1 ); update_bounding_box( current_triangle, ( xmax + xmin ) /2.0, xmax, ymin, ( ymax + ymin ) /2.0, ( zmax + zmin ) /2.0, zmax, cur_level+1 ); update_bounding_box( current_triangle, xmin, ( xmax + xmin ) /2.0, ymin, ( ymax + ymin ) /2.0, ( zmax + zmin ) /2.0, zmax, cur_level+1 ); } else { l = (listnode*) malloc( sizeof( listnode ) ); l->index = current_triangle; l->next = NULL; if( sdf[i][j][k].tindex == NULL ) { sdf[i][j][k].useful = 1; sdf[i][j][k].tindex = l; sdf[i][j][k].no = 1; sdf[i][j][k].type =4; } else { temp = sdf[i][j][k].tindex; l->next = temp; sdf[i][j][k].tindex = l; sdf[i][j][k].no++; } update_boundary_vertices(i, j, k); if ( (xmax - xmin != 1) || (ymax - ymin != 1) || (zmax - zmin != 1) ) printf("err in octree\n"); } } } int inside_cube(ray r, double ymin, double ymax, double zmin, double zmax, int flag) { double k=1, t=1; double xmax, xmin; //intersect each edge of the tri with ray R n c if the pt of intersection is on the edge segment... switch (flag) { case 1: //ZY //a) ymin if (! isZero(r.dy)) { t = (double)( (ymin - r.oy)/r.dy ); k = r.oz + t*r.dz; if ((isBetween(0.0, 1.0, t)) && (isBetween(zmin, zmax, k))) return 1; } //b) ymax if (! isZero(r.dy)) { t = (double)( (ymax - r.oy)/r.dy ); k = r.oz + t*r.dz; if ((isBetween(0.0, 1.0, t)) && (isBetween(zmin, zmax, k))) return 1; } //c) zmin if (! isZero(r.dz)) { t = (double)( (zmin - r.oz)/r.dz ); k = r.oy + t*r.dy; if ((isBetween(0.0, 1.0, t)) && (isBetween(ymin, ymax, k))) return 1; } //d) zmax if (! isZero(r.dz)) { t = (double)( (zmax- r.oz)/r.dz ); k = r.oy + t*r.dy; if ((isBetween(0.0, 1.0, t)) && (isBetween(zmin, zmax, k))) return 1; } //if ((isBetween(zmin, zmax, r.oz)) && (ymin, ymax, r.oy)) return 1; break; case 2: //XZ xmin = ymin; xmax = ymax; //a) xmin if (! isZero(r.dx)) { t = (double)( (xmin - r.ox)/r.dx ); k = r.oz + t*r.dz; if ((isBetween(0.0, 1.0, t)) && (isBetween(zmin, zmax, k))) return 1; } //b) xmax if (! isZero(r.dx)) { t = (double)( (xmax - r.ox)/r.dx ); k = r.oz + t*r.dz; if ((isBetween(0.0, 1.0, t)) && (isBetween(zmin, zmax, k))) return 1; } //c) zmin if (! isZero(r.dz)) { t = (double)( (zmin - r.oz)/r.dz ); k = r.ox + t*r.dx; if ((isBetween(0.0, 1.0, t)) && (isBetween(xmin, xmax, k))) return 1; } //d) zmax if (! isZero(r.dz)) { t = (double)( (zmax- r.oz)/r.dz ); k = r.ox + t*r.dx; if ((isBetween(0.0, 1.0, t)) && (isBetween(xmin, xmax, k))) return 1; } //if ((isBetween(zmin, zmax, r.oz)) && (xmin, xmax, r.ox)) return 1; break; case 3: //YX xmin = zmin; xmax = zmax; //a) ymin if (! isZero(r.dy)) { t = (double)( (ymin - r.oy)/r.dy ); k = r.ox + t*r.dx; if ((isBetween(0.0, 1.0, t)) && (isBetween(xmin, xmax, k))) return 1; } //b) ymax if (! isZero(r.dy)) { t = (double)( (ymax - r.oy)/r.dy ); k = r.ox + t*r.dx; if ((isBetween(0.0, 1.0, t)) && (isBetween(xmin, xmax, k))) return 1; } //c) xmin if (! isZero(r.dx)) { t = (double)( (xmin - r.ox)/r.dx ); k = r.oy + t*r.dy; if ((isBetween(0.0, 1.0, t)) && (isBetween(ymin, ymax, k))) return 1; } //d) xmax if (! isZero(r.dx)) { t = (double)( (xmax- r.ox)/r.dx ); k = r.oy + t*r.dy; if ((isBetween(0.0, 1.0, t)) && (isBetween(ymin, ymax, k))) return 1; } //if ((isBetween(ymin, ymax, r.oy)) && (xmin, xmax, r.ox)) return 1; break; default: printf("unknown case in inside_cube: %d \n", flag); return 1; break; } return 0; } myPoint inbox (ray r, myPoint p, double dist, double* t) { myPoint result; double myt=0.0; myt = n_dotv(p.x, p.y, p.z, r, dist); result.x = result.y =result.z=0; if (myt==INF) //ie the denoms 0 and so the ray is || to the plane... { //c if the Origin of the ray satisfies the plane eqn or not. if ( isZero( (p.x * r.ox) + (p.y * r.oy) + (p.z * r.oz) + (double)dist) ) *t=1; //need to chq later if the ray ACTUALLY intersects the cube or not.... else *t=0; result.isNull = 1; return result; } result.x = (double)(r.ox + (myt)*r.dx); result.y = (double)(r.oy + (myt)*r.dy); result.z = (double)(r.oz + (myt)*r.dz); result.isNull = 0; *t = myt; return result; } int chqOrientedCorrectly(myPoint* start, myPoint* finish, int tri, ray r) { double dist[2]; dist[0] = ( ((( start->x)* normals[tri].x + (start->y)* normals[tri].y + (start->z)* normals[tri].z)) + distances[tri]); dist[1] = ( ((( finish->x)* normals[tri].x + (finish->y)* normals[tri].y + (finish->z)* normals[tri].z)) + distances[tri]); if ( (isZero(dist[0])) || (isZero(dist[1])) ) return 1; if (dist[0]*dist[1] <0) return 1; return 0; } int sign3DTest(myPoint d, myPoint a, myPoint b, myPoint c) { double m11, m12, m13, m21, m22, m23, m31, m32, m33; double determ; m11 = a.x-d.x; m12 = a.y-d.y; m13 = a.z-d.z; m21 = b.x-d.x; m22 = b.y-d.y; m23 = b.z-d.z; m31 = c.x-d.x; m32 = c.y-d.y; m33 = c.z-d.z; determ = m11*(m22*m33-m23*m32); determ -= m12*(m21*m33-m23*m31); determ += m13*(m21*m32-m22*m31); determ /=6.0; if (isZero(determ)) return 0; if (isNegative(determ)) return -1; return 1; } int ray_polygon_intersection (ray r, int tri) { myPoint start, finish, triA, triB, triC; int i, j, k; start.x = r.ox; start.y = r.oy; start.z = r.oz; triA.x = vertices[surface[tri].v1].x; triA.y = vertices[surface[tri].v1].y; triA.z = vertices[surface[tri].v1].z; triB.x = vertices[surface[tri].v2].x; triB.y = vertices[surface[tri].v2].y; triB.z = vertices[surface[tri].v2].z; triC.x = vertices[surface[tri].v3].x; triC.y = vertices[surface[tri].v3].y; triC.z = vertices[surface[tri].v3].z; //Start from the Origin and shoot to the bounding box. finish.x = start.x; finish.y = start.y; finish.z = start.z; if (r.dx >0) finish.x = (double)(size+1); if (r.dy >0) finish.y = (double)(size+1); if (r.dz >0) finish.z = (double)(size+1); if (chqOrientedCorrectly(&start, &finish, tri, r) ==0) { //Both the points are on the same side of the trianngle. //So, the ray will NEVER intersect the triangle ? return 0; } if (sign3DTest(start, triA, triB, triC) >= 0) { i = sign3DTest(finish, triA, triB, start); j = sign3DTest(finish, triB, triC, start); k = sign3DTest(finish, triC, triA, start); } else if (sign3DTest(start, triA, triC, triB) >= 0) { i = sign3DTest(finish, triA, triC, start); j = sign3DTest(finish, triC, triB, start); k = sign3DTest(finish, triB, triA, start); } else printf("wot now?\n"); //First, intersection at a vertex of the triangle if ( ( (i==0) && (j==0) ) || ( (i==0) && (k==0) ) || ( (j==0) && (k==0) ) ) { //intersects in the corresponding vertex. return 1; } //Second, interesection on an edge of the triangle if ( (i==0) && (j==k) || (j==0) && (i==k) || (k==0) && (i==j) ) { //intersects in the corresponding edge return 1; } //Finally, intersection inside the triangle if ( (i==j) && (j==k) ) return 1; return 0; } double n_dotv( double x, double y, double z, ray r, double temp123) { double ndotv1, ndotv2, dote; ndotv1=ndotv2=dote=0.0; ndotv1 += x * r.dx; ndotv1 += y * r.dy; ndotv1 += z * r.dz; if (isZero(ndotv1)) return INF; ndotv2 += x * r.ox; ndotv2 += y * r.oy; ndotv2 += z * r.oz; dote = -(ndotv2+ temp123)/(ndotv1); return dote; } myPoint normalize(double x, double y, double z) { myPoint result; double n; n = sqrt(x*x + y*y + z*z); result.x = (double)(x/n); result.y = (double)(y/n); result.z = (double)(z/n); return result; } int max_3( double x, double y, double z ) { if( x < 0 ) x *= -1; if( y < 0 ) y *= -1; if( z < 0 ) z *= -1; if( x > y ) { if( x > z ) return 0; return 2; } if( y > z ) return 1; return 2; } ////////////////////////////////////. //take a point on the plane and c if it lies in the triangle or not. int point_in_polygon(myPoint result, int tri) { double alpha, beta; double u0, u1, u2, v0, v1, v2; int index; double p1, p2; int i, j; //added this if ( !isZero((result.x*normals[tri].x) + (result.y*normals[tri].y) + (result.z*normals[tri].z) + (distances[tri])) ) return 0; //now do the point in Triangle test... index = max_3( normals[tri].x, normals[tri].y, normals[tri].z ); if( index == 0 ) { p1 = result.y; p2 = result.z; i = 1; j = 2; u0 = p1 - vertices[ surface[tri].v1 ].y; u1 = vertices[ surface[tri].v2 ].y - vertices[ surface[tri].v1 ].y; u2 = vertices[ surface[tri].v3 ].y - vertices[ surface[tri].v1 ].y; v0 = p2 - vertices[ surface[tri].v1 ].z; v1 = vertices[ surface[tri].v2 ].z - vertices[ surface[tri].v1 ].z; v2 = vertices[ surface[tri].v3 ].z - vertices[ surface[tri].v1 ].z; } else if ( index == 1 ) { p1 = result.z; p2 = result.x; i = 2; j = 0; u0 = p1 - vertices[ surface[tri].v1 ].z; u1 = vertices[ surface[tri].v2 ].z - vertices[ surface[tri].v1 ].z; u2 = vertices[ surface[tri].v3 ].z - vertices[ surface[tri].v1 ].z; v0 = p2 - vertices[ surface[tri].v1 ].x; v1 = vertices[ surface[tri].v2 ].x - vertices[ surface[tri].v1 ].x; v2 = vertices[ surface[tri].v3 ].x - vertices[ surface[tri].v1 ].x; } else { p1 = result.x; p2 = result.y; i = 0; j = 1; u0 = p1 - vertices[ surface[tri].v1 ].x; u1 = vertices[ surface[tri].v2 ].x - vertices[ surface[tri].v1 ].x; u2 = vertices[ surface[tri].v3 ].x - vertices[ surface[tri].v1 ].x; v0 = p2 - vertices[ surface[tri].v1 ].y; v1 = vertices[ surface[tri].v2 ].y - vertices[ surface[tri].v1 ].y; v2 = vertices[ surface[tri].v3 ].y - vertices[ surface[tri].v1 ].y; } alpha = ( u0*v2 - v0*u2 ) / ( u1*v2 - v1*u2 ); if( isNegative(alpha) ) return 0; beta = ( u1*v0 - v1*u0 ) / ( u1*v2 - v1*u2 ); if( isNegative(beta)) return 0; if( isBetween(0.0, 1.0, alpha+beta)) return 1; return 0; } //Add all the vertices of the cell into the boundary_vertices array. void update_boundary_vertices(int cx, int cy, int cz) { insert_bound_vert(index2vert(cx+0, cy+0, cz+0)); insert_bound_vert(index2vert(cx+1, cy+0, cz+0)); insert_bound_vert(index2vert(cx+1, cy+1, cz+0)); insert_bound_vert(index2vert(cx+0, cy+1, cz+0)); insert_bound_vert(index2vert(cx+0, cy+0, cz+1)); insert_bound_vert(index2vert(cx+1, cy+0, cz+1)); insert_bound_vert(index2vert(cx+1, cy+1, cz+1)); insert_bound_vert(index2vert(cx+0, cy+1, cz+1)); }mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/SDF-license.txt0000644000175000017500000000614410334435753024471 0ustar debiandebianTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 1. This software is the copyright of THE UNIVERSITY OF TEXAS AT AUSTIN, 2005. 2. The software is available under multiple licenses. 3. For non commercial educational and non commercial academic use, the software including source code, interface definitions and compile scripts are freely available. Any distribution of code, library or executables which contains any modules from this software should contain, conspicously and appropriately, on each copy, this copyright and license notice and should be freely distributed. 4. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation. 5. For any other purpose, including commercial purposes, please contact The University of Texas at Austin for a different license. 6. Credits: This software has been developed at the Computational and Visualization center under Dr Chandrajit Bajaj, Computational Applied Mathematics Chair in Visualization, Professor of Computer Sciences, Director of Center for Computational Visualization, Department of Computer Sciences & The Institute of Computational Engineering and Sciences , Center for Computational Visualization, 201 East 24th Street, ACES 2.324A, 1 University Station, C0200, Austin, TX 78712-0027. We request that you agree to acknowledge the use of the software that results in any published work, including scientific papers, films and videotapes by citing the references listed below C. Bajaj, V. Siddavanahalli An Adaptive Grid Based Method for Computing Molecular Surfaces and Properties ICES and CS Technical Reports, The University of Texas at Austin, 2005. 7. No warranty 7a. Because the library is licensed free of charge, there is no warranty for the library, to the extent permitted by applicable law. except when otherwise stated in writing the copyright holders and/or other parties provide the library "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. the entire risk as to the quality and performance of the library is with you. should the library prove defective, you assume the cost of all necessary servicing, repair or correction. 7b. In no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute the library as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use the library (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the library to operate with any other software), even if such holder or other party has been advised of the possibility of such damages. END OF TERMS AND CONDITIONS mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/MakefileApp0000755000175000017500000000005110242725543023764 0ustar debiandebiang++ -o test.exe testing.cpp sdfLib.a -lm mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/common.cpp0000644000175000017500000000554010242725543023664 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include "common.h" #include #ifdef _WIN32 #include #include #else #include #endif int isEqual (double one, double two) { if ( (-1*SDFLibrary::TOLERANCE <= (one-two)) && ((one-two) <= SDFLibrary::TOLERANCE) ) return true; return false; } int isZero(double num) { if ( (-1*SDFLibrary::TOLERANCE <= num) && (num <= SDFLibrary::TOLERANCE) ) return true; return false; } int isNegative(double num) { if (num <0) return true; return false; } int isBetween(double one, double two, double num) { if ( ((one<=num) && (num<=two)) || ((isEqual(num, one)) || (isEqual(num, two))) ) return true; return false; } int isZero(SDFLibrary::myPoint one) { double val = sqrt(one.x*one.x + one.y*one.y + one.z*one.z); if (isZero(val)) return true; return false; } int isSame(SDFLibrary::myPoint one, SDFLibrary::myPoint two) { double val = sqrt( (one.x-two.x)*(one.x-two.x) + (one.y-two.y)*(one.y-two.y) + (one.z-two.z)*(one.z-two.z) ); if (isZero(val)) return true; return false; } void _vert2index(int c, int &i, int &j, int &k) { int _left; i = c%(SDFLibrary::size+1); _left = c/(SDFLibrary::size+1); j = _left%(SDFLibrary::size+1); _left = _left/(SDFLibrary::size+1); k = _left; if (i<0) i=0; if (j<0) j=0; if (k<0) k=0; if (i>SDFLibrary::size+1) i=SDFLibrary::size+1; if (j>SDFLibrary::size+1) j=SDFLibrary::size+1; if (k>SDFLibrary::size+1) k=SDFLibrary::size+1; } int index2vert(int i, int j, int k) { return(k*(SDFLibrary::size+1)*(SDFLibrary::size+1) + j*(SDFLibrary::size+1) + i); } double xCoord(int i) { if ((0<=i) && (i<= SDFLibrary::size+1)) return((double)i); return -1; } double yCoord(int j) { if ((0<=j) && (j<= SDFLibrary::size+1)) return((double)j); return -1; } double zCoord(int k) { if ((0<=k) && (k<= SDFLibrary::size+1)) return((double)k); return -1; } //Get the current time in seconds as a double value double getTime() { #ifdef _WIN32 time_t ltime; _timeb tstruct; time( <ime ); _ftime( &tstruct ); return (double) (ltime + 1e-3*(tstruct.millitm)); #else struct timeval t; gettimeofday( &t, NULL ); return (double)(t.tv_sec + 1e-6*t.tv_usec); #endif }mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/userManual.txt0000644000175000017500000000344510242725543024547 0ustar debiandebianUsers Manual for SDF (LINUX v. 2.0) written by KLC (mailto: ckl@ices.utexas.edu) Introduction: This library can generate the Signed Distance Function fields. In the current release (v.2.0), it can generate functions only on uniform grids. Compared to ver1.0, this version significantly improves the run-time speed for SDF computation. Inputs: The inputs to the library are as follows: A set of parameters that can tweak the quality of the SDF. These are described here: Size: this is the resolution of the volume grid. It has to be a power of 2 (64,128,256 etc) Flip Normals: setting this parameter to 1 checks the orientation of the input surface and flips the normals of the triangles to a uniform side InsideZero: setting this parameter to 1 causes the sign inside the volume to be negative and outside as positive. Input file: the input surface is specified here. It is given in the .RAW format (http://www.ices.utexas.edu/cvc/). Note that the surface has to be a closed surface Output: The library outputs a voluemtric grid of the dimensions (size+1)^3. Sample Files: A sample input file in the ASCII .RAW format is included in this distribution. The source file shows a sample example on how to use the library. Source Code: All the relevant source files are included in this distrubution. Installation: The release is pretty much platform independant. To compile it with a GNU compiler, please refer to the makefile alongwith this distribution. The project workspaces for the MSVC6.0 are also included in the distribution Makefiles : (i) Makefile - generates sdfLib.a ( see sdfLib.h for available functions generating SDF ) (ii) MakefileApp - compiles sample application code testing.cpp Reporting Bugs: In case of any errors, please send an email to ckl@ices.utexas.edu mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/head.h0000644000175000017500000000353210242725543022741 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #ifndef HEAD_H #define HEAD_H namespace SDFLibrary { #define MAX_TRIS_PER_VERT 100 typedef struct _Pt_ { double x; double y; double z; char isNull; } myPoint; typedef struct _Vt_ { double x; double y; double z; char isNull; int tris[MAX_TRIS_PER_VERT]; //not more than MAX_TRIS_PER_VERT triangles can share a vertex. int trisUsed; //elements used in the above array. } myVert; typedef struct _tri_ { int v1; int v2; int v3; int type; // default = -1; done =1. wrong =3; } triangle; typedef struct listnodedef { int index; //index of the triangle struct listnodedef* next; } listnode; typedef struct nodedef { char useful; // 0 - no triangles in it ; 1 - there are triangles in it char type; // 0 - interior node ; 1 - leaf node, containing triangles long int no; listnode* tindex; } cell; typedef struct { double ox; double oy; double oz; double dx; double dy; double dz; } ray; typedef struct _voxel_ { float value; signed char signe; //-1 = inside, 1 = outside bool processed; // 1 = propagated distance FROM here. 0 = not myPoint closestV; //the closest vertex on the surface }voxel; }; //namespace SDFLibrary #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/src/main.cpp0000644000175000017500000000566410312611777023330 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Lalit Karlapalem Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #include #include #include #include #include "common.h" void free_memory() { int i, j, k; SDFLibrary::listnode* temp; SDFLibrary::listnode* currNode; printf("starting memory de-allocation\n"); //1. Octree for (i = 0; i < SDFLibrary::size; i++) { for (j = 0; j < SDFLibrary::size; j++) { for (k = 0; k < SDFLibrary::size; k++) { currNode = SDFLibrary::sdf[i][j][k].tindex; while(currNode != NULL) { temp = currNode; currNode = currNode->next; free(temp); } } free(SDFLibrary::sdf[i][j]); } free(SDFLibrary::sdf[i]); } free(SDFLibrary::sdf); free(SDFLibrary::values); if (SDFLibrary::vertices != NULL) free(SDFLibrary::vertices); if (SDFLibrary::surface != NULL) free(SDFLibrary::surface); if (SDFLibrary::normals != NULL) free(SDFLibrary::normals); if (SDFLibrary::distances != NULL) free(SDFLibrary::distances); if (SDFLibrary::queues != NULL) free(SDFLibrary::queues); if (SDFLibrary::bverts != NULL) free(SDFLibrary::bverts); printf("Memory de-allocated successfully! \n"); } void setParameters(int Size, bool isNormalFlip, bool insideZero, double bufferArr[6]) { int i; //First the default values. init_all_vars(); //Then, assign the actual input values. SDFLibrary::size = Size; SDFLibrary::flipNormals = isNormalFlip; SDFLibrary::insideZero = insideZero; for (i=0; i<6; i++) SDFLibrary::buffArr[i] = bufferArr[i]; if ((Size!=16) && (Size!=32) &&(Size!=64) && (Size!=128) && (Size!=256) &&(Size!=512) &&(Size!=1024)) { printf("size is incorrect\n"); exit(1); } } float* computeSDF(int nverts, float* verts, int ntris, int* tris) { int i, numb; float* sdfValues =NULL; float isoval; //Set up the volume grid initSDF(); //Read in the Geometry readGeom(nverts, verts, ntris, tris); //Setup the Octree adjustData(); //Compute the SDF compute(); //Return the SDF numb = (SDFLibrary::size+1)*(SDFLibrary::size+1)*(SDFLibrary::size+1); sdfValues = (float*)(malloc(sizeof(float)*(numb))); isoval = 100.0f; for (i=0; i Advisor: Chandrajit Bajaj This is a 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 of the License, or (at your option) any later version. This 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. */ #ifndef SDFLIB_H #define SDFLIB_H /*First, set the parameters of the SDF grid. * SIZE = size of the volume. has to be 16, 32, 64, 128, 512 or 1024. The number of voxels returned is 17, 33, 65, 129, 513 or 1025 cubed. * ISNORMALFLIP: to orient the normals of the input triangulation. Also, ensures that the normals are pointing outwards. * INSIDEZERO: the sign of the function is negative inside the surface and positive outside, if this parameter is true. */ void setParameters(int size, bool isNormalFlip, bool insideZero, double bufarr[6]); /*Then, call the function with the input triangulated data. The SDF values are returned * The size of the return array is (size+1)*(size+1)*(size+1) */ float* computeSDF(int nverts, float* verts, int ntris, int* tris); #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/setup.py0000755000175000017500000001062610675046134022621 0ustar debiandebian# setup.py is used with Distutils for building UTsdf package import sys, os from os import path from distutils.core import setup, Extension from distutils.command.build_clib import build_clib from distutils.command.build_ext import build_ext from distutils.command.build import build from distutils.command.sdist import sdist from distutils.command.install_data import install_data packFullName = "UTpackages.UTsdf" packName = "UTsdf" ext_name = "_utsdf" platform = sys.platform py_packages = [packFullName, packFullName+'.Tests'] # HACK: replace cc with CC (gcc with g++) CC_exe = 'CC' cc_exe = 'cc' if platform == "linux2" or platform == "darwin": CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to',`g[n]` if platform != "win32": sysconfig._init_posix = my_init_posix # C++ sources : # sdf_sources = ["common.cpp", "head.cpp", "main.cpp", "octree.cpp", "testing.cpp", "compute.cpp", "init.cpp", "new_adjust.cpp", "propagate.cpp"] for i in range(len(sdf_sources)): sdf_sources[i] = path.join("src", sdf_sources[i]) # Lists of macros, compiler and linker options sdf_macros = [] #if platform == "win32": # sdf_macros = [("WIN32", None)] import numpy numpy_include = numpy.get_include() sdf_include = ["src", numpy_include] comp_opts = [] link_opts = [] libs = [] if platform in ('sunos5', 'irix6'): libs.append({'sunos5':'Crun', 'irix6':'C'}.get(platform)) if platform == "win32": comp_opts.append("/MT") data_files = [(path.join(packName,"Tests"), [path.join(packName, "Tests", "eight.raw"),] ), ] # Modify the order of commands called by 'build' command - # 'build-py' should go after 'build_ext'. This way a python module generated # by SWIG in 'build_ext'command is copied to the build directory by # 'build_py' command. class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] # Overwrite the run method of the install_data to install the data files # in the package instead of a particular data directory class modified_install_data(install_data): def run(self): install_cmd = self.get_finalized_command('install') self.install_dir = getattr(install_cmd, 'install_lib')+"UTpackages" return install_data.run(self) # This class overwrites the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. class modified_sdist(sdist): def prune_file_list(self): build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) dist = setup(name = packFullName, version="1.0", description = "SDF library extension module", author = "Molecular Graphics Laboratory", author_email = "mgltools@scripps.edu", url = "http://www.scripps.edu/~sanner/python/packager.html", packages = py_packages, package_dir = {packFullName: packName}, ext_package = packFullName, data_files = data_files, # use the derived command classes: cmdclass = {"build" : modified_build, "install_data": modified_install_data, "sdist" : modified_sdist}, ext_modules = [Extension (ext_name, [path.join(packName, "utsdf.i")]+sdf_sources, include_dirs = sdf_include, define_macros = sdf_macros, #library_dirs = [], libraries = libs, extra_compile_args = comp_opts, extra_link_args = link_opts, ) ] ,) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/README0000644000175000017500000000247510334436535021767 0ustar debiandebianThis module builds a python extension of SDFlibrary developed at University of Texas (www.ices.utexas.edu/ccv/software). This library generates the Signed Distance Function fields (on uniform grids). This distribution contains source code of the library (see ./src/SDF-license.txt). Distutils are used to wrap the library with SWIG (version 1.3.20 or higher) and build the python extension (_utsdf.so). To build and install the extension: python2.4 setup.py install This will: - compile the source code and place the object files into ./build/temp./src; - generate a python shadow class module utsdf.py in ./build/lib./UTpackages/UTsdf - build _utsdf.so in ./build/lib./UTpackages/UTsdf; - copy the UTsdf package from ./build/lib.UTpackages to sys.exec_prefix/lib/python2.4/site-packages/UTpackages; The install command can be called with the following options: --install-platlib=INSTALL_DIR installs the package in specified INSTALL_DIR --no-compile do not compile .py to .pyc Example: python2.4 setup.py install --install-platlib=/home/myname/myinstalldir To build the extension only: python2.4 setup.py build To build source distribution: python2.4 setup.py sdist To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTsdfDIST/MANIFEST.in0000644000175000017500000000027010263313523022624 0ustar debiandebianinclude MANIFEST.in include src/* include UTsdf/*.i include UTsdf/Tests/eight.raw exclude UTmesh/utsdf.py include CVS/* include UTsdf/CVS/* include UTsdf/Tests/CVS/* include src/CVS/* mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/0000755000175000017500000000000012146213512022516 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/0000755000175000017500000000000012146213451025175 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/isocontour.i0000644000175000017500000004160411165234135027562 0ustar debiandebian/********************* This module wraps the fast isocontouring library developped at UT Austin. The basic functionnality of this library is to create a 2D or 3D data set from which 2D or 3D iso-contoured can be extracted rapidly. This version of the library supports multiple variables and timesteps on data sets of unsigned character, short and float. example: import isocontour, Numeric # create a data file from a file the_data = isocontour.loadDataset(isocontour.CONTOUR_FLOAT, isocontour.CONTOUR_REG_3D, 3, 1, ["pot-2eti-glucose-3fields.raw"]); # compute an isocontour isovar = 0 timestep = 0 isovalue = 0.23 isoc = isocontour.getContour3d(the_data, isovar, timestep, isovalue, isocontour.NO_COLOR_VARIABLE) # create numeric arrays for the geometry vert = Numeric.zeros((isoc.nvert,3)).astype('f') norm = Numeric.zeros((isoc.nvert,3)).astype('f') col = Numeric.zeros((isoc.nvert)).astype('f') tri = Numeric.zeros((isoc.ntri,3)).astype('i') # get the triangles isocontour.getContour3dData(isoc, vert, norm, col, tri) **************************/ %module isocontour %{ #ifdef _MSC_VER #include #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif //#include #include #include "contour.h" #include "dataset.h" #include "datareg3.h" #include "datareg2.h" #include "conplot2d.h" %} //%include typemaps.i %include "numarr.i" %include "Misc.i" // typemaps for char ** %include "contour_i.hpp" %extend DatasetInfo { void _dim( int OUT_VECTOR[3] ) { OUT_VECTOR[0] = self->dim[0]; OUT_VECTOR[1] = self->dim[1]; OUT_VECTOR[2] = self->dim[2]; } void _orig( float OUT_VECTOR[3] ) { OUT_VECTOR[0] = self->orig[0]; OUT_VECTOR[1] = self->orig[1]; OUT_VECTOR[2] = self->orig[2]; } void _span( float OUT_VECTOR[3] ) { OUT_VECTOR[0] = self->span[0]; OUT_VECTOR[1] = self->span[1]; OUT_VECTOR[2] = self->span[2]; } void _minext( float OUT_VECTOR[3] ) { OUT_VECTOR[0] = self->minext[0]; OUT_VECTOR[1] = self->minext[1]; OUT_VECTOR[2] = self->minext[2]; } void _maxext( float OUT_VECTOR[3] ) { OUT_VECTOR[0] = self->maxext[0]; OUT_VECTOR[1] = self->maxext[1]; OUT_VECTOR[2] = self->maxext[2]; } } %extend ConDataset { Signature *getSignature(int variable, int timestep, int funcnum) { int max = getNumberOfSignatures(self); if (!self->sfun[variable][timestep]) getSignatureFunctions(self,variable, timestep); if (funcnum<0) funcnum=0; if (funcnum>max) funcnum=max-1; return &self->sfun[variable][timestep][funcnum]; } } %extend Signature { void getFx(float VECTOR[1]) { int i; for (i=0; inval; i++) VECTOR[i]=self->fx[i]; } void getFy(float VECTOR[1]) { int i; for (i=0; inval; i++) VECTOR[i]=self->fy[i]; } } // set the library's error handler %{ void errorHandlerRaisePythonException(char *mystring, int x) { printf("ERROR caught by myhandler %s %d\n", mystring, x); PyErr_SetString(PyExc_NameError, mystring); } %} %init %{ setErrorHandler(errorHandlerRaisePythonException); %} %{ extern int verbose; void delDatasetReg(ConDataset *dataset) { int i,t, v; // timestep index variable Contour3d *isocontour; if (dataset == NULL) return; if (verbose) printf ("delDatasetReg :\n"); if (dataset->data) { if (dataset->sfun) { for (v = 0; v < dataset->data->nData(); v++) // delete signatures { if (verbose) printf ("delete dataset->sfun\n"); for (t = 0; t < dataset->data->nTime(); t++) if (dataset->sfun[v][t]) delete [] dataset->sfun[v][t]; delete [] dataset->sfun[v]; } delete [] dataset->sfun; } if (verbose) printf ("delete dataset->data\n"); delete dataset->data; dataset->data = NULL; } // delete data, set to NULL if (dataset->plot) { if (verbose) printf ("delete dataset->plot\n"); //isocontour = dataset->plot->getContour3d(); //isocontour->~Contour3d(); delete dataset->plot; dataset->plot = NULL; } if (dataset->vnames) { if (verbose) printf ("delete dataset->vnames\n"); for (i = 0; i < dataset->data->nData(); i++) { if (dataset->vnames[i]) { delete [] dataset->vnames[i]; } } delete [] dataset->vnames; } delete dataset; /************ if (dataset->data) delete dataset->data; if (dataset->plot) delete dataset->plot; if (dataset->sfun) delete dataset->sfun; if (dataset->vnames) free(dataset->vnames); *****************/ } void delContour3d (Contour3dData * contour) { delete contour; } ConDataset *newDatasetRegFloat3D( int *dim, float data[1][1][1][1][1], float orig[3], float span[3]) { ConDataset * dataset = newDatasetReg( CONTOUR_FLOAT, CONTOUR_REG_3D, dim[1], dim[0], &dim[2], (u_char *)data); ((Datareg3 *)dataset->data->getData(0))->setOrig(orig); ((Datareg3 *)dataset->data->getData(0))->setSpan(span); return dataset; } ConDataset *newDatasetRegFloat2D( int *dim, float data[1][1][1][1], float orig[2], float span[2]) { ConDataset * dataset = newDatasetReg( CONTOUR_FLOAT, CONTOUR_REG_2D, dim[1], dim[0], &dim[2], (u_char *)data); ((Datareg2 *)dataset->data->getData(0))->setOrig(orig); ((Datareg2 *)dataset->data->getData(0))->setSpan(span); return dataset; } ConDataset *newDatasetRegShort3D( int *dim, short data[1][1][1][1][1], float orig[3], float span[3]) { ConDataset * dataset = newDatasetReg( CONTOUR_USHORT, CONTOUR_REG_3D, dim[1], dim[0], &dim[2], (u_char *)data); ((Datareg3 *)dataset->data->getData(0))->setOrig(orig); ((Datareg3 *)dataset->data->getData(0))->setSpan(span); return dataset; } ConDataset *newDatasetRegShort2D( int *dim, short data[1][1][1][1], float orig[2], float span[2]) { ConDataset * dataset = newDatasetReg( CONTOUR_USHORT, CONTOUR_REG_2D, dim[1], dim[0], &dim[2], (u_char *)data); ((Datareg2 *)dataset->data->getData(0))->setOrig(orig); ((Datareg2 *)dataset->data->getData(0))->setSpan(span); return dataset; } ConDataset *newDatasetRegUchar3D( int *dim, u_char data[1][1][1][1][1], float orig[3], float span[3]) { ConDataset * dataset = newDatasetReg( CONTOUR_UCHAR, CONTOUR_REG_3D, dim[1], dim[0], &dim[2], (u_char *)data); ((Datareg3 *)dataset->data->getData(0))->setOrig(orig); ((Datareg3 *)dataset->data->getData(0))->setSpan(span); return dataset; } ConDataset *newDatasetRegUchar2D( int *dim, u_char data[1][1][1][1], float orig[2], float span[2]) { ConDataset * dataset = newDatasetReg( CONTOUR_UCHAR, CONTOUR_REG_2D, dim[1], dim[0], &dim[2], (u_char *)data); ((Datareg2 *)dataset->data->getData(0))->setOrig(orig); ((Datareg2 *)dataset->data->getData(0))->setSpan(span); return dataset; } void setOrig3D(ConDataset * dataset, float orig[3]) { if (!dataset || !dataset->data || !dataset->plot) { errorHandler("setOrig3D: invalid dataset", FALSE); } ((Datareg3 *)dataset->data->getData(0))->setOrig(orig); } void setSpan3D(ConDataset * dataset, float span[3]) { if (!dataset || !dataset->data || !dataset->plot) { errorHandler("setSpan3D: invalid dataset", FALSE); } ((Datareg3 *)dataset->data->getData(0))->setSpan(span); } void setOrig2D(ConDataset * dataset, float orig[2]) { if (!dataset || !dataset->data || !dataset->plot) { errorHandler("setOrig2D: invalid dataset", FALSE); } ((Datareg2 *)dataset->data->getData(0))->setOrig(orig); } void setSpan2D(ConDataset * dataset, float span[2]) { if (!dataset || !dataset->data || !dataset->plot) { errorHandler("setSpan2D: invalid dataset", FALSE); } ((Datareg2 *)dataset->data->getData(0))->setSpan(span); } %} // "newDatasetRegFloat3D" FLOAT_ARRAY5D(dim, data, [1][1][1][1][1]) %apply float VECTOR[ANY] { float orig[3] } %apply float VECTOR[ANY] { float span[3] } // // Create a data set of 3D floats on a regular grid // // dim : array of grid dimensions: [time][var][x][y][z] // data : nested sequences or 3D numeric array of float // // example: // >>> # 10x10x10 cube, 1 variable, 1 time step // >>> a = Numeric.ones( (1,1,10,10,10) ).astype('f') // >>> d = newDatasetRegFloat3D( a ) // // >>> # 10x10x10 cube, 4variables, 1 time step // >>> a = Numeric.ones( (1,4,10,10,10) ).astype('f') // >>> d = newDatasetRegFloat3D( 4, 1, a ) // // NOTE: in the array the data is organized such that the first index varies // the fastest and the last one the slowest extern ConDataset *newDatasetRegFloat3D(int *dim, float data[1][1][1][1][1], float orig[3], float span[3]); extern void delDatasetReg(ConDataset *dataset); extern void delContour3d (Contour3dData * contour); //"newDatasetRegShort3D" SHORT_ARRAY5D(dim, data, [1][1][1][1][1]) // // Create a data set of 3D shorts on a regular grid // see newDatasetRegFloat3D for explanation of arguments extern ConDataset *newDatasetRegShort3D(int *dim, short data[1][1][1][1][1], float orig[3], float span[3]); //"newDatasetRegUchar3D" UCHAR_ARRAY5D(dim, data, [1][1][1][1][1]) // // Create a data set of 3D chars on a regular grid // see newDatasetRegFloat3D for explanation of arguments extern ConDataset *newDatasetRegUchar3D(int *dim, u_char data[1][1][1][1][1], float orig[3], float span[3]); extern void setOrig3D (ConDataset *dataset, float orig[3]); extern void setSpan3D (ConDataset *dataset, float span[3]); %apply float VECTOR[ANY] { float orig[2] } %apply float VECTOR[ANY] { float span[2] } //"newDatasetRegFloat2D" FLOAT_ARRAY4D(dim, data, [1][1][1][1]) // // Create a data set of 2D floats on a regular grid // see newDatasetRegFloat3D for explanation of arguments extern ConDataset *newDatasetRegFloat2D(int *dim, float data[1][1][1][1], float orig[2], float span[2]); //"newDatasetRegShort2D" SHORT_ARRAY4D(dim, data, [1][1][1][1]) // // Create a data set of 2D short on a regular grid // see newDatasetRegFloat3D for explanation of arguments extern ConDataset *newDatasetRegShort2D(int *dim, short data[1][1][1][1], float orig[2], float span[2]); // "newDatasetRegUchar2D" UCHAR_ARRAY4D(dim, data, [1][1][1][1]) // // Create a data set of 2D chars on a regular grid // see newDatasetRegFloat3D for explanation of arguments extern ConDataset *newDatasetRegUchar2D(int *dim, u_char data[1][1][1][1], float orig[2], float span[2]); extern void setOrig2D (ConDataset *dataset, float orig[2]); extern void setSpan2D (ConDataset *dataset, float span[2]); %apply float ARRAY2D[ANY][ANY] { float vert[1][3] } %apply float ARRAY2D[ANY][ANY] { float norm[1][3] } %apply float VECTOR[ANY] { float vfun[1] } %apply int ARRAY2D[ANY][ANY] { int tri[1][3] } %{ void getContour3dData(Contour3dData *iscontour, float vert[1][3], float norm[1][3], float vfun[1], int tri[1][3], int flipNormals) { int i, j; if (flipNormals) flipNormals=-1.0; else flipNormals=1.0; for (i=0; i < iscontour->nvert; i++) { for (j=0; j < 3; j++) { vert[i][j] = iscontour->vert[i][j]; norm[i][j] = flipNormals*iscontour->vnorm[i][j]; } vfun[i] = iscontour->vfun[i]; } if (flipNormals==1.0) { for (i=0; i < iscontour->ntri; i++) { tri[i][0] = iscontour->tri[i][0]; tri[i][1] = iscontour->tri[i][1]; tri[i][2] = iscontour->tri[i][2]; } } else { for (i=0; i < iscontour->ntri; i++) { tri[i][0] = iscontour->tri[i][0]; tri[i][1] = iscontour->tri[i][2]; tri[i][2] = iscontour->tri[i][1]; } } } %} // "getContour3dData" // // Extract vertices, normals, vfun, and triangles from a 3D contour // vert and norm are Numeric arrays of floats of shape [isontour->nvert][3] // vfun is a Numeric arrays of floats of shape [isontour->nvert] // tri is Numeric arrays of int of shape [isontour->ntri][3] // flipNormals is an integer (1: flips normals, 0: doesn't) extern void getContour3dData(Contour3dData *iscontour, float vert[1][3], float norm[1][3], float vfun[1], int tri[1][3], int flipNormals); %apply float ARRAY2D[ANY][ANY] { float vert[1][2] }; %apply int ARRAY2D[ANY][ANY] { int edge[1][2] }; %{ void getContour2dData(Contour2dData *iscontour, float vert[1][2], int edge[1][2]) { int i, j; for (i=0; i < iscontour->nvert; i++) { vert[i][0] = iscontour->vert[i][0]; vert[i][1] = iscontour->vert[i][1]; } for (i=0; i < iscontour->nedge; i++) { edge[i][0] = iscontour->edge[i][0]; edge[i][1] = iscontour->edge[i][1]; } } %} //"getContour2dData" // // Extract vertices and edges from a 2D contour // vert is a Numeric arrays of floats of shape [isocontour->nvert][3] // tri is Numeric arrays of int of shape [isontour->ntri][3] extern void getContour2dData(Contour2dData *iscocontour, float vert[1][2], int edge[1][2]); //"Misc helpers" %{ #include static PyObject *string2Float(PyObject *self, PyObject *args) { char *stringFloat; float *floatlist; int i; PyObject *list = NULL; PyArrayObject *array; if (!PyArg_ParseTuple(args, "O:string2Float", &list)) return NULL; if (PyList_Check(list)) { npy_intp size = PyList_Size(list); int i = 0; floatlist = (float *) malloc((size)*sizeof(float)); for (i = 0; i < size; i++) { PyObject *o = PyList_GetItem(list,i); if (PyString_Check(o)) floatlist[i] = atof( PyString_AsString(o) ); else { PyErr_SetString(PyExc_TypeError,"list must contain strings"); free(floatlist); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, &size, PyArray_FLOAT, (char *)floatlist); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif } } else { PyErr_SetString(PyExc_TypeError,"not a list"); return NULL; } return Py_BuildValue("O", array); } %} %native(string2Float) string2Float; %native (getSliceArray) PyObject *getSliceArray(PyObject *self, PyObject *args); %{ static PyObject *getSliceArray(PyObject *self, PyObject *args) { PyObject * _resultobj; SliceData * _result; ConDataset * _arg0; PyArrayObject *slice_array; int _arg1; int _arg2; char _arg3; int _arg4; PyObject * _argc0 = 0; /**char _ptemp[128];**/ npy_intp dims[2]; if(!PyArg_ParseTuple(args,"Oiici:getSliceArray",&_argc0,&_arg1,&_arg2,&_arg3,&_arg4)) { return NULL; } if (_argc0) { //if (SWIG_GetPtr(_argc0,(void **) &_arg0,"_ConDataset_p")) { swig_type_info *ty = SWIG_TypeQuery("ConDataset *"); if ((SWIG_ConvertPtr(_argc0,(void **) &_arg0, ty,1)) == -1){ PyErr_SetString(PyExc_TypeError,"Type error in argument 1 of getSlice. Expected p_ConDataset"); return NULL; } } _result = (SliceData *)getSlice(_arg0,_arg1,_arg2,_arg3,_arg4); dims[0] = _result->width; dims[1] = _result->height; if (_result->datatype == CONTOUR_UCHAR) { slice_array = (PyArrayObject *)PyArray_SimpleNewFromData(2, dims, \ PyArray_UBYTE, (char *)_result->ucdata); } else if (_result->datatype == CONTOUR_USHORT) { slice_array = (PyArrayObject *)PyArray_SimpleNewFromData(2, dims, \ PyArray_SHORT, (char *)_result->usdata); } else { /*if (_result->datatype == CONTOUR_FLOAT) { */ slice_array = (PyArrayObject *)PyArray_SimpleNewFromData(2, dims, \ PyArray_FLOAT, (char *)_result->fdata); } #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: slice_array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected slice_array->flags |= NPY_OWNDATA; #endif return (PyObject *)slice_array; } %} /**%native (getSliceArray) getSliceArray; **/ /**************** "References" **************** C. Bajaj, V. Pascucci, D. Schikore. "Accelerated IsoContouring of Scalar Fields," chapter in: Data Visualization Techniques edited by C. Bajaj John Wiley and Sons C. Bajaj, V.Pascucci, and D.Schikore. "The Contour Spectrum". Proceedings of the 1997 IEEE Visualization Conference,167-173, October 1997 Phoeniz, Arizona. C. Bajaj, V. Pascucci, D. Schikore. "Fast Isocontouring for Improved Interactivity". Proceedings: ACM Siggraph/IEEE Symposium on Volume Visualization, ACM Press, (1996), San Francisco, CA ***********************************************/ %pragma (python) include = "isocontour_include.py" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/contour_i.hpp0000644000175000017500000001755610453043164027726 0ustar debiandebian/*------------------------------------------------------------------------ * * contour.h - contour library include file * * Copyright (c) 1999 Emilio Camahort * *----------------------------------------------------------------------*/ /* $Id: contour_i.hpp,v 1.2 2006/07/05 23:08:36 annao Exp $ */ #ifndef _CONTOUR_H_ #define _CONTOUR_H_ #ifndef WIN32 #include #endif typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; /*------------------------------------------------------------------------ * * constant definitions * *----------------------------------------------------------------------*/ #define CONTOUR_UCHAR 0 /* supported types of raw data */ #define CONTOUR_USHORT 1 #define CONTOUR_FLOAT 2 #define CONTOUR_2D 2 /* supported types of meshes */ #define CONTOUR_3D 3 #define CONTOUR_REG_2D 4 #define CONTOUR_REG_3D 5 #define NO_COLOR_VARIABLE -1 /* do not color an isocontour */ /*------------------------------------------------------------------------ * * data structures * *----------------------------------------------------------------------*/ /*------------------------------------------------------------------------ * data structures for storing some dataset information *----------------------------------------------------------------------*/ typedef struct DatasetInfo { int datatype; /* the dataset's base type */ int meshtype; /* type of mesh (see defs above) */ int nvars; /* number of variables */ int ntime; /* number of timesteps */ u_int dim[3]; /* dataset's x, y, z dimensions */ float orig[3]; /* coordinates of dataset's origin */ float span[3]; /* how far does the dataset go */ float minext[3]; /* min corner of dataset */ float maxext[3]; /* max corner of dataset */ float *minvar; /* min value for each variable */ float *maxvar; /* max value for each variable */ } DatasetInfo; /*------------------------------------------------------------------------ * data structures for storing seed cells *----------------------------------------------------------------------*/ typedef struct Seed /* store one seed cell (see seedCells.h) */ { float min; /* cell minimum value */ float max; /* cell maximum value */ u_int cell_id; /* cell identifier */ } Seed; typedef struct SeedData /* structure to store seeds */ { int nseeds; /* number of seed cells */ Seed *seeds; /* array of seed cells */ } SeedData; /*------------------------------------------------------------------------ * data structure for storing signature functions *----------------------------------------------------------------------*/ typedef struct Signature /* a single signature function */ { char *name; /* fuction name */ u_int nval; /* number of function values */ float *fx; /* x-values of function */ float *fy; /* y-values of function */ } Signature; /*------------------------------------------------------------------------ * a slice of a 3D regular grid *----------------------------------------------------------------------*/ typedef struct SliceData /* structure to store a 2d scalar data slice */ { int width; /* slice width */ int height; /* slice height */ int datatype; /* type of data: uchar, ushort, float */ u_char *ucdata; /* slice data for uchar datatype */ u_short *usdata; /* slice data for ushort datatype */ float *fdata; /* slice data for float datatype */ } SliceData; /*------------------------------------------------------------------------ * store a 2D isocontour *----------------------------------------------------------------------*/ typedef struct Contour2dData /* structure to store a 2d isocontour */ { int nvert; /* size of vertex array */ int nedge; /* size of edge array */ /*float *vert[2];*/ /* polyline vertex array */ /* u_int *edge[2];*? /* array of edge indices */ } Contour2dData; /*------------------------------------------------------------------------ * store a 3D isocontour *----------------------------------------------------------------------*/ typedef struct Contour3dData /* structure to store a 3d isocontour */ { int nvert; /* number of vertices in vertex array */ int ntri; /* triangles in triangle array */ /* float *vert[3]; */ /* isosurface vertex array */ /* float *vnorm[3]; */ /* array of vertex normals */ float *vfun; /* color values at vertices */ /* u_int *tri[3]; */ /* triangle mesh array */ int colorvar; /* color variable (-1 if no color) */ float fmin, fmax; /* min and max color values */ } Contour3dData; /*------------------------------------------------------------------------ * a structure to store a dataset of scalar data *----------------------------------------------------------------------*/ class Dataset; class Conplot; typedef struct ConDataset // structure to store and entire dataset { char **vnames; // variable names int nsfun; // number of signature functions Signature ***sfun; // signature functions Dataset *data; // input data/dataset Conplot *plot; // isocontouring algorithm and data } ConDataset; /*------------------------------------------------------------------------ * * library routines * *----------------------------------------------------------------------*/ /* set the library's level of verbosity, default is 1 */ void setVerboseLevel(int level); /* set the library's error handler */ /*void setErrorHandler(void (*handler)(char *, int)); */ /* create a new dataset for unstructured data */ ConDataset *newDatasetUnstr(int datatype, int meshtype, int nvars, int ntime, int nverts, int ncells, double *verts, u_int *cells, int *celladj, u_char *data); /* create a new dataset for a regular grid of data */ ConDataset *newDatasetReg(int datatype, int meshtype, int nvars, int ntime, int *dim, u_char *data); /* load from disk a new dataset */ ConDataset *loadDataset(int datatype, int meshtype, int nvars, int ntime, char **files); /* get the dataset's basic information */ DatasetInfo *getDatasetInfo(ConDataset *dataset); /* get variable names for multi-variate datasets */ char **getVariableNames(ConDataset *dataset); /* extract seed cells for variable and timestep */ SeedData *getSeedCells(ConDataset *dataset, int variable, int timestep); /* return the number of signature functions */ int getNumberOfSignatures(ConDataset *dataset); /* compute signature functions for variable and timestep */ Signature *getSignatureFunctions(ConDataset *dataset, int variable, int timestep); /* get signature values for isovalue, variable and timestep */ float *getSignatureValues(ConDataset *dataset, int variable, int timestep, float isovalue); /* extract a dataset slice */ SliceData *getSlice(ConDataset *dataset, int variable, int timestep, char axis, u_int index); /* extract a 2d isocontour */ Contour2dData *getContour2d(ConDataset *dataset, int variable, int timestep, float isovalue); /* extract a 3d isocontour */ Contour3dData *getContour3d(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar); /* extract a 2d isocontour and write it to a file */ void saveContour2d(ConDataset *dataset, int variable, int timestep, float isovalue, char *filename); /* extract a 3d isocontour and write it to a file */ void saveContour3d(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar, char *filename); /* write isocontour connected components to ipoly files */ void writeIsoComponents(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar, char *fprefix); /* clear (delete) dataset from memory */ void clearDataset(ConDataset *dataset); #endif /* of _CONTOUR_H_ */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/numarr.i0000644000175000017500000006576211165234135026675 0ustar debiandebian%init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #ifdef _MSC_VER #include #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif #include "numpy/arrayobject.h" static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i, numitems, itemsize; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} /**********************************************************/ /* OUTPUT */ /**********************************************************/ %{ static PyObject* l_output_helper2(PyObject* target, PyObject* o) { PyObject* o2; PyObject* o3; if (!target) { target = o; } else if (target == Py_None) { Py_DECREF(Py_None); target = o; } else { if (!PyList_Check(target)) { o2 = target; target = PyList_New(0); PyList_Append(target, o2); Py_XDECREF(o2); } PyList_Append(target,o); Py_XDECREF(o); } return target; } %} /**********************************************************/ /* OUTPUT: int VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) int OUT_VECTOR[ANY], int OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) int OUT_VECTOR[ANY] (PyArrayObject *array, npy_intp out_dims[1]) %{ out_dims[0] = $1_dim0; $1 = (int *)malloc($1_dim0*sizeof(int)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_INT, (char *)$1); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif %} %typemap(in, numinputs=0) int OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { int *data = (int *)malloc($1_dim0*$1_dim1*sizeof(int)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_INT, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (int (*)[$1_dim1])data; } /**********************************************************/ /* OUTPUT: float VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) float OUT_VECTOR[ANY], float OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) float OUT_VECTOR[ANY](PyArrayObject *array, npy_intp out_dims[1]) %{ out_dims[0] = $1_dim0; $1= (float *)malloc($1_dim0*sizeof(float)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_FLOAT, (char *)($1)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif %} %typemap(in, numinputs=0) float OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { float *data = (float *)malloc($1_dim0*$1_dim1*sizeof(float)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_FLOAT, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (float (*)[$1_dim1])data; } /**********************************************************/ /* OUTPUT: double VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) double OUT_VECTOR[ANY], double OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) double OUT_VECTOR[ANY] (PyArrayObject *array, npy_intp out_dims[1]) { out_dims[0] = $1_dim0; $1= (double *)malloc($1_dim0*sizeof(double)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_DOUBLE, (char *)($1)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif } %typemap(in, numinputs=0) double OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { double *data = (double *)malloc($1_dim0*$1_dim1*sizeof(double)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_DOUBLE, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (double (*)[$1_dim1])data; } /*************************************************************/ /* INPUT */ /*************************************************************/ /*************************************************************/ /* INPUT: u_char VECTOR */ /*************************************************************/ %typemap(in) u_char VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[1] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 1, expected_dims); if (! array) return NULL; $1 = (u_char *)array->data; %} %typemap(freearg) u_char VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: u_char ARRAY2D */ /*************************************************************/ %typemap(in) u_char ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 2, expected_dims); if (! array) return NULL; $1 = (u_char (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) u_char ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: int VECTOR */ /*************************************************************/ %typemap(in) int VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; %} %typemap(freearg) int VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: int ARRAY2D */ /*************************************************************/ %typemap(in) int ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = (int (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) int ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: float VECTOR */ /*************************************************************/ %typemap(in) float VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; %} %typemap(freearg) float VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: float ARRAY2D */ /*************************************************************/ %typemap(in) float ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) float ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*******************************************************/ /** Input: float ARRAY2D_NULL **/ /*******************************************************/ %typemap(in) float ARRAY2D_NULL[ANY][ANY] (PyArrayObject *array , int expected_dims[2]) { if ($input == Py_None) { $1 = NULL; } else { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } } /*************************************************************/ /* INPUT: double VECTOR */ /*************************************************************/ %typemap(in) double VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 1, expected_dims); if (! array) return NULL; $1 = (double *)array->data; %} %typemap(freearg) double VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: double ARRAY2D */ /*************************************************************/ %typemap(in) double ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 2, expected_dims); if (! array) return NULL; $1 = (double (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) double ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %define UCHAR_ARRAY2D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int* DIM, u_char ARRAYNAME##ARRAYSHAPE) (PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 2, expected_dims); if (! array) return NULL; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $1 = intdims; $2 = (u_char (*)[$2_dim1])array->data; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int* DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /*** Macros to generate typemaps for pairs of arguments *******/ /**************************************************************/ /**************************************************************/ /* Input: FLOAT_ARRAY4D */ /**************************************************************/ %define FLOAT_ARRAY4D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, float ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 4, expected_dims); if (! array) return NULL; $2 = (float(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, float ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: SHORT_ARRAY4D */ /**************************************************************/ %define SHORT_ARRAY4D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int *DIM, short ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_SHORT, 4, expected_dims); if (! array) return NULL; $2 = (short(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, short ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: UCHAR_ARRAY4D */ /**************************************************************/ %define UCHAR_ARRAY4D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 4, expected_dims); if (! array) return NULL; $2 = (u_char(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef %define SHORT_ARRAY5D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, short ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_SHORT, 5, expected_dims); if (! array) return NULL; $2 = (short(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, short ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: UCHAR_ARRAY5D */ /**************************************************************/ %define UCHAR_ARRAY5D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 5, expected_dims); if (! array) return NULL; $2 = (u_char(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_ARRAY5D */ /**************************************************************/ %define FLOAT_ARRAY5D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int* DIM, float ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 5, expected_dims); if (! array) return NULL; $2 = (float(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int* DIM, float ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: INT_VECTOR */ /**************************************************************/ %define INT_VECTOR( ARRAYNAME, ARRAYSHAPE, LENGTH ) %typemap(in) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_VECTOR */ /**************************************************************/ %define FLOAT_VECTOR( ARRAYNAME, ARRAYSHAPE, LENGTH ) %typemap(in) (float ARRAYNAME##ARRAYSHAPE, int LENGTH) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: INT_ARRAY2D */ /**************************************************************/ %define INT_ARRAY2D( ARRAYNAME, ARRAYSHAPE, DIMENSIONS ) %typemap(in) ( int ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS)(PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = (int (*)[$1_dim1])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $2 = intdims; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_ARRAY2D */ /**************************************************************/ %define FLOAT_ARRAY2D( ARRAYNAME, ARRAYSHAPE, DIMENSIONS ) %typemap(in) ( float ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS)(PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $2 = intdims; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (float ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS ) %{ if (array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Tests/0000755000175000017500000000000012146213512026275 5ustar debiandebian././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Tests/pot-2eti-glucose-3fields.rawmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Tests/pot-2eti-glucose-3fie0000644000175000017500000227077410064121656032175 0ustar debiandebian?€?€?€CÈ€C´€C¥€Éz¹ )%"?€?€?€A A A »o»D›¦»D›¦»ƒo»ƒo»£× »£× »Ä›¦»å`B»å`B¼o¼t¼¼#× ¼#× ¼49X¼D›¦¼Týô¼Týô¼e`B¼u¼u¼u¼u¼u¼u¼u¼e`B¼e`B¼Týô¼D›¦¼49X¼#× ¼t¼¼o»å`B»å`B»Ä›¦»£× »£× »ƒo»ƒo»D›¦»D›¦»ƒo»ƒo»£× »£× »Ä›¦»å`B¼o¼t¼¼#× ¼49X¼D›¦¼Týô¼e`B¼u¼ƒo¼‹C–¼‹C–¼“t¼¼›¥ã¼›¥ã¼›¥ã¼›¥ã¼›¥ã¼“t¼¼“t¼¼‹C–¼ƒo¼u¼Týô¼D›¦¼49X¼#× ¼t¼¼o»å`B»Ä›¦»£× »£× »ƒo»D›¦»ƒo»ƒo»£× »£× »Ä›¦»å`B¼o¼t¼¼#× ¼D›¦¼Týô¼e`B¼u¼‹C–¼“t¼¼›¥ã¼£× ¼¬1¼´9X¼¼j¼¼j¼Ä›¦¼Ä›¦¼¼j¼¼j¼´9X¼¬1¼›¥ã¼“t¼¼ƒo¼u¼Týô¼D›¦¼#× ¼t¼¼o»å`B»Ä›¦»£× »£× »D›¦»ƒo»£× »£× »Ä›¦»å`B¼o¼#× ¼49X¼D›¦¼e`B¼u¼‹C–¼›¥ã¼¬1¼´9X¼Ä›¦¼ÌÌͼÔýô¼Ý/¼å`B¼í‘h¼í‘h¼í‘h¼í‘h¼å`B¼Ý/¼ÌÌͼ¼j¼´9X¼£× ¼“t¼¼ƒo¼e`B¼D›¦¼49X¼t¼¼o»å`B»Ä›¦»£× »ƒo»£× »£× »Ä›¦»å`B¼o¼#× ¼49X¼Týô¼u¼‹C–¼›¥ã¼¬1¼¼j¼ÌÌͼÝ/¼í‘h¼ýó¶½o½ C–½\)½\)½t¼½t¼½\)½ C–½+¼ýó¶¼å`B¼Ôýô¼¼j¼¬1¼›¥ã¼ƒo¼e`B¼D›¦¼49X¼t¼¼o»å`B»Ä›¦»ƒo»£× »Ä›¦»å`B¼o¼#× ¼49X¼Týô¼u¼“t¼¼£× ¼¼j¼ÌÌͼå`B¼ýó¶½+½t¼½¥ã½#× ½'ïž½0 Ž0 Ž49X½49X½0 Ž'ïž½¾w½P½ C–¼ýó¶¼å`B¼ÌÌͼ´9X¼›¥ã¼ƒo¼e`B¼D›¦¼#× ¼t¼»å`B»Ä›¦»£× »Ä›¦»å`B¼o¼#× ¼49X¼Týô¼ƒo¼“t¼¼¬1¼Ä›¦¼Ý/¼ýó¶½ C–½P½'ïž½49X½vɾ.{¾¬¾ =q½ï²½ÌÌͽ®{½‘hs½m‘h½D›¦½¾w½o¼Ôýô¼¬1¼‹C–¼e`B¼D›¦¼u¼›¥ã¼Ä›¦¼õ½P½vɾ,1¾™š¾+½ë…½ÊÀƒ½¬1½‘hs½q©ü½H´9½#× ½+¼Ý/¼´9X¼“t¼¼u¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½¾w½D›¦½q©ü½“t¼½° ŽÒñª½÷ÎÙ¾hs¾&éy¾>vɾV¾k…¾}󶾄›¦¾†§ð¾„“¾}ó¶¾n—¾]/¾Iº^¾7KǾ$Ý/¾n˜¾%½áG®½Â\½¥ãT½‹C–½ixÕ½D›¦½¾w½o¼Ý/¼´9X¼“t¼¼u¼D›¦¼ƒo¼›¥ã¼Ä›¦¼õ½P½vɾ.{¾¬¾ Iº½ûçm½ß;d½Æ§ð½° Ž›¥ã½‡+½ixÕ½H´9½,1½\)¼õ¼ÌÌͼ¬1¼‹C–¼e`B¼D›¦¼t¼¼49X¼e`B¼‹C–¼¬1¼ÌÌͼõ½t¼½,1½LÌͽq©ü½\)½§ïž½Æ§ð½éxÕ¾+¾™š¾(õþ49X¾6E¢¾2-¾'ïž¾™š¾ C–½ùÛ#½ß;d½È´9½²-½²-½‹C–½u½Týô½8Qì½¥ã½o¼Ý/¼¼j¼›¥ã¼ƒo¼Týô¼49X¼t¼¼#× ¼Týô¼u¼“t¼¼´9X¼Ôýô¼ýó¶½P½49X½På`½u½‘hs½©ûç½Æ§ð½å`B¾ J¾\)¾P¾Ÿ¾¾P¾\)¾“½ñ©ü½Ù‡½Ä›¦½° ޲-½‹C–½u½Y‡½vɾbMÓ¾†$ݾ/¾´9X¾È1'¾Ôýô¾× =¾ÎÙ¾À¾­‘h¾šŸ¾¾ˆ´9¾r°!¾V¾;dZ¾#× ¾V½ó¶F½ÎÙ½¬1½\)½m‘h½@ƒ½¾w¼ýó¶¼Ôýô¼¬1¼‹C–¼e`B¼“t¼¼´9X¼å`B½\)½49X½aG®½‰7L½§ïž½ÊÀƒ½ó¶F¾hs¾.{¾På`¾yÛ#¾”zá¾­V¾Â J¾Ïß;¾Ñ녾ȴ9¾·ÎÙ¾¤Z¾å`¾}ó¶¾_;d¾D›¦¾-V¾‡+¾o½áG®½¾vɽŸ¾w½…¸½]/½8Qì½P¼õ¼ě¦¼£× ¼ƒo¼Týô¼ƒo¼¬1¼Ôýô½o½#× ½LÌͽyÛ#½—P½´9X½Ù‡¾ J¾¬¾vɾP½í‘h½º^5½“t¼½e`B½49X½\)¼Ý/¼´9X¼“t¼¼Ä›¦¼ýó¶½'ïž½]/½‘hs½Àƒ½ûçm¾"Ðå¾På`¾„“¾£Sø¾Å¸¾èõÿéy¿Û#¿,Iº¿<(ö¿F§ð¿Iº^¿DÝ/¿9X¿*Àƒ¿¥ã¿ Ì;ü푾áG®¾Å¸¾¨õþŽV¾j~ú¾=p¤¾P½ï²½¾vɽ•½ixÕ½8Qì½\)¼å`B¼´9X¼›¥ã¼ÌÌͽo½,1½e`B½•½Ä›¦¾¾$Ý/¾Që…¾ƒo¾¡G®¾Á‰7¾äZ¿“¿È´¿)7L¿9X¿D“¿G+¿BMÓ¿6È´¿'ïž¿ÎÙ¿r°¾ó¶F¾Øb¾¼í‘¾¢MÓ¾‰7L¾cSø¾9X¾zá½í‘h½¼j½•½ixÕ½8Qì½t¼¼å`B¼´9X¼›¥ã¼ÌÌͽ+½0 Že`B½—P½Ä›¦½ýó¶¾!ÊÁ¾Kƨ¾|푾𬾏Ôþ¾Ú¬¾ýp¤¿©ü¿$Z¿4¼j¿?|î¿BMÓ¿<í‘¿0å`¿!‰7¿hs¿ÊÁ¾æff¾ËC–¾±©ü¾˜“u¾‰7¾Xb¾1&é¾\)½çl‹½¸Q콑hs½e`B½8Qì½\)¼å`B¼´9X¼›¥ã¼ÌÌͽo½0 Že`B½•½Àƒ½õ¾Ÿ¾¾A‰7¾m‘h¾ß;¾¬‹D¾ÌÌ;ñ&é¿ Iº¿ ƒ¿1ë…¿<í‘¿?;d¿8Qì¿+ ¿Ÿ¾¿ º^¾ó¶F¾× =¾¼í‘¾¤Ý/¾ŽV¾q©ü¾JÀƒ¾&éy¾1'½Ý/½²-½Oß½aG®½49X½\)¼Ý/¼´9X¼›¥ã¼Ä›¦½o½'ïž½]/½\)½¸Qì½éxÕ¾hs¾333¾["Ѿ„“¾Ÿ;d¾¾vɾäZ¿l‹¿ó¶¿1ë…¿>5?¿?¾w¿6È´¿&§ð¿9X¿MÓ¾ã× ¾Ç®¾®—¾˜b¾ƒo¾`A‰¾5?¿?;d¿0 Å¿b¾þùÛ¾Ôýô¾³¶F¾™™š¾„›¦¾fff¾F§ð¾+ ¾hs½õ½ÊÀƒ½§ïž½‰7L½]/½49X½\)¼å`B¼¼j¼“t¼¼u¼›¥ã¼Ä›¦¼õ½¥ã½D›¦½q©ü½•½¶E¢½Ý/¾$ݾ"Ðå¾Iº^¾{çm¾ A‰¾ÍOß¿G®¿"Ñ¿,Iº¿-Òò¿¾w¿ º^¾åãT¾¾ùÛ¾ Äœ¾‰7L¾l‹D¾MÒò¾2-¾™š¾o½Ý/½¸Qì½™™š½yÛ#½LÌͽ#× ½+¼Ôýô¼¬1¼‹C–¼Týô¼‹C–¼¬1¼Ý/½+½'ïž½På`½%½›¥ã½¼j½ãSø¾ =q¾+ ¾V¾ˆ1'¾­‘h¾Ù‡¿ÊÁ¿ß;¿©ü¿+¾ë ¾Æ$ݾ¥`B¾‹Æ¨¾o²¾Oß;¾49X¾¬¾1'½éxսƧð½¥ãT½‰7L½aG®½8Qì½P¼õ¼ě¦¼£× ¼ƒo¼D›¦¼u¼›¥ã¼¼j¼í‘h½t¼½49X½Y‡½ƒo½²-½¾vɽçl‹¾V¾1&é¾^5?¾‹Æ¨¾¬1¾ÊÀƒ¾ß¾w¾ãSø¾Ö¾½p¤¾¢Ð徊Àƒ¾l‹D¾LÌ;2-¾¥ã¾1'½í‘h½ÌÌͽ®{½“t¼½u½H´9½'ïž½+¼Ý/¼´9X¼“t¼¼u¼49X¼Týô¼ƒo¼£× ¼ÌÌͼõ½P½49X½Y‡½ƒo½²-½¾vɽçl‹¾V¾0 žY‡¾‚\¾—P¾¥`B¾¨õþ¡ÊÁ¾’ñª¾%¾`A‰¾C•¾+ ¾‡+¾“½éxÕ½ÊÀƒ½° Ž—P½}ó¶½Týô½49X½t¼¼õ¼ě¦¼£× ¼ƒo¼Týô¼#× ¼D›¦¼e`B¼‹C–¼¬1¼Ôýô¼ýó¶½P½49X½Y‡½%½›¥ã½º^5½áG®¾ 7L¾$Ý/¾A‰7¾]/¾o²¾t¼j¾m‘h¾]/¾G®¾2-¾²-¾ C–½÷ÎÙ½Ý/½Â\½¬1½•½%½]/½8Qì½¥ã½o¼Ôýô¼´9X¼“t¼¼u¼D›¦¼o¼#× ¼D›¦¼u¼“t¼¼´9X¼Ôýô¼ýó¶½P½0 ŽPå`½yÛ#½•½° ŽÒñª½÷ÎÙ¾V¾¾w¾,1¾1&é¾.{¾$Ý/¾“u¾ =q½ùÛ#½áG®½ÊÀƒ½¶E¢½¡ÊÁ½\)½yÛ#½Y‡½vɾ^5?¾{çm¾ŠÀƒ¾”ýô¾œ(ö¾¡ÊÁ¾¦ff¾« ¾° ž³¶F¾³¶F¾­‘h¾ Äœ¾\)¾u¾LÌ;%ãT¾¸½Òñª½¥ãT½ƒo½LÌͽ#× ¼ýó¶¼ÌÌͼ£× ¼ƒo¼D›¦¼u¼£× ¼ÌÌͽo½'ïž½Y‡½‹C–½²-½áG®¾ Iº¾.{¾Týô¾€ƒ¾—P¾­‘h¾Àƒ¾ÍÒò¾Õ¾Ù‡¾Û¥ã¾Þ5?¾áG®¾ãSø¾áG®¾Ø“u¾È1'¾±&é¾— =¾yÛ#¾H´9¾¾w½ùÛ#½Â\½—P½m‘h½8Qì½\)¼å`B¼´9X¼“t¼¼e`B¼“t¼¼¼j¼í‘h½¥ã½H´9½ƒo½©ûç½Ý/¾V¾5?}¾cSø¾ŒÌ;«…¾ÌÌ;í‘h¿Z¿ V¿&é¿©ü¿bN¿ ¿V¿ Oß¿ Àƒ¿Z¾ó33¾Ö‡+¾µÂ¾•¾n—¾5?¿B\¿@Äœ¿;çm¿6E¢¿1hs¿-V¿'+¿ó¶¿bN¾ýp¤¾Ö¾®—¾‹C–¾Y‡¾'ïž¾%½Ä›¦½—P½ixÕ½49X½ C–¼Ý/¼¬1¼‹C–¼´9X¼í‘h½¥ã½LÌͽ‰7L½¸Qì½÷ÎÙ¾%ãT¾["ѾŽV¾µÂ¾äZ¿ V¿+C–¿J~ú¿e`B¿vÈ´¿|¬¿y‡¿o\)¿c•¿X“u¿N—¿DZ¿7P¿&ff¿©ü¾ô¼j¾Ç+¾²-¾t¼j¾5?¿(ö¿Sø¾àA‰¾Àƒ¾¤Z¾‹C–¾hr°¾?|½ûçm½È´9½Ÿ¾w½yÛ#½D›¦½¥ã¼õ¼ě¦¼›¥ã¼ÌÌͽ+½49X½ixÕ½—P½Â\½õ¾“u¾;dZ¾cSø¾‹Æ¨¾®—¾áÊÁ¿KÇ¿P Å¿ŽvÉ¿¸r°¿Ôýô¿Ô9X¿¸Qì¿’MÓ¿a‰7¿0bN¿V¾íV¾Éº^¾­V¾“÷Ͼ{çm¾Rñª¾/ ¾V½çl‹½¸Q콓t¼½ixÕ½8Qì½t¼¼å`B¼´9X¼“t¼¼¼j¼õ½¾w½LÌͽƒo½§ïž½Ðå`¾%¾²-¾@ƒ¾l‹D¾”ýô¾Â\¿× ¿7KÇ¿}󶿦$Ý¿Áhs¿Áhs¿§ïž¿„¼j¿K…¿²-¾ü푾Ñë…¾²°!¾™‡¾ƒ•¾`A‰¾=p¤¾²-¾%½Ðå`½§ïž½‡+½Týô½'ïž½+¼Ôýô¼¬1¼ƒo¼¬1¼Ôýô½ C–½0 ŽaG®½Oß½®{½× =¾ J¾¾w¾D›¦¾xÔþ¾¡ÊÁ¾Ú¬¿‡+¿MÒò¿…¸¿š^5¿›dZ¿ˆõÿ\¬¿+ƨ¿éy¾Ù™š¾µÂ¾šŸ¾¾…¡Ë¾fff¾E¡Ë¾&éy¾ C–½å`B½¼j½—P½q©ü½@ƒ½¥ã¼õ¼ě¦¼›¥ã¼e`B¼“t¼¼¼j¼í‘h½P½ùÛ¿BMÓ¿<í‘¿-‘h¿E¢¾÷Îپě¦¾˜“u¾hr°¾0 ž¸½ÊÀƒ½™™š½ixÕ½49X½ C–¼Ý/¼¬1¼ƒo¼¬1¼Ý/½\)½@ƒ½%½¬1½å`B¾™š¾Kƨ¾…¸¾¬1¾Û¥ã¿ Àƒ¿+ƨ¿MV¿g®¿vE¢¿y‡¿t¼j¿o ¿lÌÍ¿o ¿st¼¿t9X¿kƨ¿WÎÙ¿:^5¿‡¾ñ©ü¾¹X¾ŒIº¾Që…¾¬½ë…½° Ž…¸½LÌͽ¥ã¼õ¼¼j¼“t¼¼¼j¼ýó¶½'ïž½e`B½™™š½Òñª¾bN¾D›¦¾…¸¾±&é¾çïž¿¿@¿r-¿“t¼¿¨õÿ´“¿´9X¿­‘h¿¤ýô¿ž{¿š~ú¿™7L¿–éy¿ Å¿ƒ33¿b J¿9‡¿&é¾Ý/¾¥`B¾u¾5?}¾+½È´9½—P½e`B½,1½+¼ÌÌͼ£× ¼Ôýô½\)½@ƒ½…¸½¶E¢½ýó¶¾1&é¾wÎÙ¾ª~ú¾æéy¿Ôþ¿Fff¿~¸R¿¢MÓ¿Èõÿê^5¿üIº¿üÌÍ¿ñ‰7¿àå`¿ÐÄœ¿Å¸¿½p¤¿¶ff¿«çm¿›dZ¿…¿Y™š¿)û翃¾¾vɾ‹Æ¨¾MÒò¾P½ß;d½§ïž½yÛ#½@ƒ½\)¼Ý/¼´9X¼í‘h½¾w½]/½—P½Ôýô¾¾S÷Ͼ— =¾Ó÷Ï¿©ü¿B J¿{dZ¿Ÿß;¿Ê¬¿û…À¼jÀ# À&E¢À r°À(öÀ²-¿óSø¿â J¿Ó÷Ï¿ÄZ¿° Å¿–éy¿u¿?;d¿ß;¾Ôzá¾›"ѾbMÓ¾%ãT½õ½¶E¢½‰7L½LÌͽ¥ã¼í‘h¼Ä›¦½o½49X½u½©ûç½ï²¾+ ¾t¼j¾° žú^5¿.V¿iº^¿–E¢¿»C–¿ç+À ÂÀ(r°À<í‘ÀG ÀDýôÀ6VÀ!%À ‘h¿þ5?¿çïž¿Óo¿»çm¿ Äœ¿ƒ33¿L‹D¿¬¾ãSø¾¥ãT¾r°!¾2-¾o½Â\½‘hs½Y‡½#× ¼ýó¶¼Ôýô½\)½@ƒ½‡+½¼j¾¸¾=p¤¾‡®¾Ão¿ C–¿B\¿‚°!¿¦È´¿ËC–¿ò\ÀÄœÀ+33ÀCçmÀUp¤ÀXå`ÀJŸ¾À1&éÀ1'Àí‘¿ìÌÍ¿Ó× ¿»"Ñ¿ A‰¿ƒt¼¿N—¿푾èõþ«…¾{çm¾9X¾1'½ÊÀƒ½—P½e`B½,1½o¼Ý/½P½På`½\)½ÊÀƒ¾V¾JÀƒ¾bN¾ÍOß¿å`¿H´9¿…ãT¿©xÕ¿Ë"Ñ¿ì‹DÀ ÊÁÀ!hsÀ:^5ÀN¸RÀUÀI™šÀ0å`À =ÀÛ#¿âñª¿È1'¿¯|î¿–‡+¿xÔþ¿EãT¿Qì¾å`B¾ª~ú¾|푾;dZ¾ C–½ÎÙ½›¥ã½ixÕ½0 Ž+¼å`B½¥ã½Y‡½—P½Ôýô¾‡+¾Rñª¾“÷ϾÎV¿V¿@Äœ¿|í‘¿ž5?¿¼‹D¿Ú^5¿ýVÀ¶FÀ*~úÀ<í‘ÀCSøÀ9º^À$ÌÍÀ `B¿ñ‰7¿Ðƒ¿µ¡Ë¿ž5?¿‡®¿b J¿6E¢¿—¾Ú¬¾¤Ý/¾vÈ´¾9X¾ =q½ÎÙ½›¥ã½m‘h½49X½+¼í‘h½¾w½aG®½›¥ã½Û"Ѿ™š¾W =¾“÷Ͼȴ9¿ff¿0bN¿a‰7¿‹…¿¦éy¿Ä›¦¿èbÀ ‡À—À.VÀ2^5À(å`À5?À‡¿ÛdZ¿»…¿¡ÊÁ¿‹çm¿o²¿Hõÿ#× ¿MÓ¾ÊÀƒ¾›"Ѿl‹D¾333¾+½ÌÌͽ™™š½ixÕ½0 Ž+¼í‘h½#× ½aG®½²-½Ý/¾™š¾S÷Ͼß;¾¾ùÛ¾÷ÎÙ¿p¤¿DZ¿på`¿’-¿±ÊÁ¿Ú=qÀp¤ÀÀ-OßÀ.E¢À!&éÀ Z¿í/¿Ç =¿¨1'¿ß;¿wKÇ¿St¼¿1ë…¿n˜¾ë…¾¹Û#¾bN¾^5?¾)ûç¾ J½Ä›¦½•½e`B½0 Ž+¼å`B½¾w½]/½™™š½× =¾zá¾Kƨ¾ˆ1'¾°£×¾ß¾w¿ Àƒ¿*=q¿PbN¿G®¿£÷ϿԼjÀ ™šÀ)Û#À>VÀvÉ¿¾w¿¬j¿çïžÀ²-À0QìÀ9º^À2ÀƒÀ$IºÀvÉÀ5?À ¸À´9ÀƨÀbÀ~ú¿Ú=q¿ª~ú¿}p¤¿6E¢¿G®¾¶E¢¾‰7¾9X¾¸½Â\½\)½Týô½#× ¼õ¼¼j¼ýó¶½0 Žq©ü½©ûç½ñ©ü¾0 ž%¾½ó¶¿ ~ú¿DÝ/¿‡KÇ¿µãT¿õ?}À'|îÀ^ffÀ†{Àl‹ÀŠÈ´À|‹DÀ`“uÀJn˜À>ÙÀ;t¼À9‰7À1ûçÀ r°À$Ý¿Ñ&鿚¬¿["Ñ¿‡¾Ôýô¾•¾Rñª¾P½Û"ѽŸ¾w½m‘h½0 Ž+¼Ôýô½\)½D›¦½‹C–½Æ§ð¾\)¾S÷ϾŸ¾w¾ò°!¿6‡+¿…?}¿¹ûç¿ør°À#…À[33À‘¸À®^5ÀÁG®ÀÅXÀ·÷ÏÀ¢vÉÀŒ´9À{oÀjŸ¾À_²ÀQë…À;÷ÏÀOß¿õ¸¿³•¿|¬¿.Ù¾ñ&é¾§l‹¾k…¾&éy½ñ©ü½° Ž%½@ƒ½\)¼å`B½¾w½]/½²-½áG®¾%ãT¾wÎÙ¾½p¤¿n˜¿aÊÁ¿©X¿ðƒÀ²ÀIÛ#À€1À£¾wÀăÀã"ÑÀôýôÀê‡+ÀÒffÀ´“À˜Ý/À‡²ÀxA‰ÀcdZÀJ^5À*-ÀO߿öF¿‰™š¿=ó¶¿Ðå¾µ?}¾}ó¶¾49X¾ J½¼j½‹C–½LÌͽ¥ã¼ýó¶½,1½u½®{½ûçm¾:^5¾‹Æ¨¾Õ¿%`B¿€bN¿Ã33À ¬À: JÀb~úÀ†$ÝÀ¢ÐåÀÆffÀëçmÁ¬ÀûC–ÀçÎÙÀÊÀ¦5?À‡ÀxõÃÀ^È´ÀDí‘À&ÙÀj¿Äýô¿Œ(ö¿CSø¿l‹¾¼í‘¾…¸¾=p¤¾1'½Æ§ð½‘hs½Y‡½¾w½+½8Q콃o½¾vɾ =q¾Kƨ¾˜b¾å`B¿.V¿…?}¿ÈÔþÀbNÀ=ÂÀa©üÀ~È´À’ñªÀ°ÔþÀÖÀõ%Àù?}Àè¬ÀÇt¼À¡xÕÀ…p¤ÀdÌÍÀH“uÀ/ïžÀãT¿ñë…¿·ïž¿…ãT¿>5?¿$ݾ½ó¶¾‡+¾B\¾ Iº½ÌÌͽ•½]/½#× ½ C–½D›¦½Oß½ÊÀƒ¾zá¾["Ѿ¡G®¾í‘h¿.Ù¿€bN¿º~úÀMÓÀ(ÔþÀGPÀ_ÎÙÀ+À˜1'À·÷ÏÀÕ%ÀßÎÙÀÑÊÁÀ²Ÿ¾À‘XÀmãTÀGß;À,“À¿ÿ\)¿Ñ&é¿¢ñª¿st¼¿1©ü¿¾¸Ôþ¾…¸¾A‰7¾ Iº½ÎÙ½—P½aG®½'ïž½\)½LÌͽ‘hs½Ôýô¾¬¾e`B¾§l‹¾ñ&é¿*~ú¿m‘h¿¢°!¿Ø“uÀ %À#t¼À=²-À`r°Àˆ‹DÀ¤ƒÀ» =ÀÁxÕÀ´ZÀšÐåÀ~vÉÀO\)À+× Àë…¿û ¿Ö¿°å`¿Œ‹D¿WKÇ¿!%¾î{¾¯ ¾€ƒ¾¸R¿xb¿’MÓ¿˜1'¿Œ(ö¿l1¿>vÉ¿X¾ýp¤¾×P¾»çm¾¥ãT¾‘hs¾záH¾S÷Ͼ/ ¾ Oß½áG®½° މ7L½Y‡½'ïž½o¼ÌÌͼ£× ¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½¾w½D›¦½q©ü½‘hs½²-½Ù‡¾¸¾&éy¾S÷Ͼ‰7L¾²-¾ã× ¿ …¿|î¿&§ð¿ ¿²¾øQì¾Ó÷Ͼ¶E¢¾Ÿ;d¾Oß¾záH¾^5?¾A‰7¾$Ý/¾ =q½áG®½¶E¢½‘hs½e`B½49X½\)¼å`B¼´9X¼“t¼¼49X¼Týô¼‹C–¼¬1¼ÌÌͼýó¶½¥ã½ÙA¥÷ÏÀÖáHÀzáÀ.5?¿òÐå¿ÀbN¿£o¿Œ¬¿p£×¿H´9¿!‰7¾ùÛ#¾»dZ¾‰º^¾H´9¾n˜½× =½Ÿ¾w½m‘h½49X½+¼Ä›¦½o½0 Žm‘h½Ÿ¾w½× =¾V¾7KǾfff¾Òò¾­‘h¾Ø“u¿{¿K…¿£33À%À€ÌÍÀ™ó¶¾„›¦¿–ffÀ¿çmÀŸdZÀHÀG®¿» ¿–ff¿€Äœ¿`Äœ¿BÐå¿$›¦¿$ݾÑë…¾Ÿ;d¾l‹D¾-V½ýó¶½¼j½‹C–½På`½¾w¼õ¼£× ¼Ôýô½\)½¸RÀ4záÀ6ÀRMÓÀЇ+Àº¬ÀÞ~úÀÜbÀÂMÓÀ‘xÕÀÀ"=qÀ¾w¿ÜIº¿ª=q¿xÔþ¿.—¾ð ž¤Ý/¾dZ¾¾w½ãSø½£× ½q©ü½49X½o½8Qì½…¸½¾vɾ C–¾Iº^¾ŽV¾Â J¾úáH¿^5¿7KÇ¿ZŸ¾¿ŠŸ¾¿Èr°À.¸RÀ® J@‚n˜CúCúCúCúÀ=VÁÛ#À›•ÀVffÀ.ffÀÀ?}¿å?}¿¾5?¿•¸¿[çm¿Ÿ¾¾Ôzᾑhs¾Iº^¾ Oß½ÊÀƒ½“t¼½Y‡½¾w¼Ý/½¥ã½Týô½•½ÎÙ¾\)¾C•¾%¾¤Z¾ÊÀƒ¾õ¿È´¿CSø¿Œ‹D¿èÔþÀ["ÑÀºŸ¾@È1'B¿Ü)BÑ­?ꟾÁ ãTÀµ™šÀ_ß;À—ÀÊÁ¿ä¼j¿ÌIº¿³Sø¿—KÇ¿på`¿4zá¿Äœ¾³33¾xÔþ¾.{½õ½²-½%½@ƒ½\)¼¼j¼ýó¶½,1½e`B½›¥ã½Ðå`¾ 7L¾1&é¾^5?¾‰7L¾¨r°¾Ñë…¿r°¿?¾w¿“÷Ï¿ù‡ÀW;dÀ§|îÀÒ$ÝÀèÝ/ÀÚ§ðÀ¢~úÀY‡À33¿Ü¬¿¸1'¿£¶F¿“¶F¿ƒo¿_¾w¿4ýô¿ ~ú¾ÊÀƒ¾bN¾LÌ;hs½Ðå`½—P½aG®½'ïž¼ýó¶¼›¥ã¼ÌÌͽ+½49X½m‘h½™™š½Ä›¦½ùÛ#¾¥ã¾?|î¾l‹D¾“t¼¾¾vÉ¿G®¿:¬¿ŒIº¿Ö$ÝÀdZÀHQìÀ[ ÀIë…À"Ÿ¾¿ô›¦¿¸r°¿“t¼¿|í‘¿b\¿MOß¿7 =¿p¤¿‰7¾ËC–¾™‡¾`A‰¾"Ðå½í‘h½®{½%½@ƒ½t¼¼Ý/¼ƒo¼¬1¼Ý/½\)½49X½e`B½‘hs½¶E¢½ß;d¾ 7L¾(õþQë…¾…¸¾®—¾ì‹D¿#•¿aG®¿”ýô¿µ`B¿Å?}¿¾¸R¿§KÇ¿‹ ¿dÝ/¿AÊÁ¿*~ú¿¬¿ ƨ¾ùÛ#¾Ø“u¾´¼j¾å`¾aG®¾)ûç½ýó¶½¾vɽ\)½Y‡½#× ¼ýó¶¼Ä›¦¼e`B¼‹C–¼´9X¼Ý/½ C–½0 ŽY‡½‡+½¥ãT½È´9½õ¾P¾­VÀ¨ÄœÁQ\)CDß;CúCúCúCúCúC–„þC ÞwCúCúCúCúCúCf%`B;1ÁoÀär°Às•À^5¿’°!¿.Ù¾Ú¬¾ŒÌ;:^5½ýó¶½° Žu½49X½%½Â\¾‡+¾p£×¾ÊÀƒ¿8b¿¸1'ÀJMÓÀºÈ´A…¸RCiüC~×C¶UC0¸“CúCúCúCúCúCúCúCúCúCúCúCúCúCÖÓÀžE¢ÁvÉÀ’5?À^5¿«Æ¨¿K ¾úáH¾ A‰¾Që…¾ Iº½Àƒ½‡+½D›¦½“t¼½áG®¾1&é¾ß;¾õ?}¿^5?¿Û¥ãÀn{ÀÖŸ¾AµŸ¾CÆ'+CúCúCúCúCúCúCúCúCúCúCúCúCÁÌCŽ 7CúCúCúÀ™šÁº^À› À&ff¿¼j¿a%¿ C–¾±&é¾fff¾“u½ÎÙ½\)½Y‡½£× ¾¾NÙ¾¬‹D¿zá¿„zá¿ø1'Àx“uÀóC–¿5CúCúCúCúC;C™/CúCúCúCúCúC#ôC%H´B‡+À9ë…C =Cæ}Bl³3Á‰7Á =À’§ðÀ$(ö¿Áhs¿mV¿zᾼ푾t¼j¾!ÊÁ½Ù‡½•½m‘h½¶E¢¾hs¾p£×¾Ïß;¿8Q쿤ýôÀ°!ÀÊÁÀèjÁ"í‘BÔ™CúCúCúÁ›¦Á³‹DC^ÄZCúCúCúCúB›âÑÁŒdZÁ¼ñªÁ°¸Á[²-ÀµÒòÀ‡Àÿß;ÀÔÄœÀ}ãTÀùÛ¿»"Ñ¿lÌͿȴ¾Á‰7¾záH¾%ãT½ß;d½™™š½yÛ#½Â\¾ Äœ¾‰º^¾øÔþ¿gïž¿ØQìÀ>—À˜jÀã²Á$‹DÁ¥ãBp¤Bªn˜?ÎùÛÁ%BÂC 3¶CúCúCúCúCÜë…À¦=qÁ© ÅÁŽr°Ál§ðÁCOßÁVÀï¾wÀ¥ó¶ÀO®À÷Ï¿«çm¿`Äœ¿-¾½p¤¾wÎÙ¾$Ý/½ß;d½™™š½%½ÌÌ;+ ¾—P¿V¿Œ(öÀ hsÀsC–À³PÀíãTÁº^Á.MÓÁBE¢Á^“uÁˆ‹DAêt¼CúCúCúCúCÑŸ;CúC~ô¼Àâ{Á…å`Á^éyÁE Á&1Á…ÀºÙÀ|¬À'|î¿á%¿˜Qì¿L‹D¿®¾²°!¾l‹D¾¸R½Ù‡½•½%½ÌÌ;-V¾›¥ã¿¿—PÀÀƒ÷ÏÀ±ÂÀá©üÁïžÁ ß;ÁffÁ*MÓÁVå`BdZCúCúCúCúC“øAµ|î¾ÒñªÁ{ß;Á_ë…Á;l‹Á$ffÁXÀÉë…À‘xÕÀJÐåÀ ÷Ï¿Áhs¿…?}¿5¾ô¼j¾£× ¾\(ö¾½ÌÌͽ\)½u½ě¦¾$Ý/¾“t¼¿ ‹D¿ŒIºÀ Ÿ¾Ào¾wÀ¥hsÀÎ~úÀé`BÀè1ÀãÎÙÁ›¦Á7®Àß…CúCúCúCúCúÁ&E¢Á™¾wÁl-ÁFzáÁ-/ÁùÛÀè“uÀ®áHÀ~¸RÀ4ÌÍ¿ûçm¿­‘h¿m‘h¿!‰7¾ÚŸ¾¾“÷ϾH´9¾ =q½Àƒ½‡+½e`B½²-¾t¼¾€¾ë ¿_;d¿ÑhsÀ2~úÀ€í‘ÀŸ¾wÀ­&éÀ©xÕÀ¦MÓÀÀ(öÁoÁM¸CúCúCúCúCúBqªÁ–º^ÁV¸RÁ1²-Á›¦Án˜ÀוÀ¥%Àv5?À1G®¿ôýô¿¤›¦¿["Ñ¿-¾Ä“¾…¸¾6E¢½ûçm½²-½}ó¶½LÌͽ²-½ùÛ#¾Oß;¾³¶F¿¸R¿‰Û#¿ÞvÉÀvÉÀCƨÀUó¶ÀYÛ#ÀcSøÀ‹ÎÙÀã ÁBéyCV­ÓCúCúCúCúBý=ôÁG®ÁH1Á+Á ß;Àó ÀÉxÕÀ bÀw®À5`B¿÷®¿¡&é¿O ¿$ݾ±&é¾n—¾#× ½ãSø½¡ÊÁ½ixÕ½49X½…¸½ÌÌ;!ÊÁ¾‚\¾Õ¿*~ú¿€£×¿°Äœ¿Ú~ú¿öéyÀ¡ËÀ§ðÀF—À¨ÔþÁéyCOCúCúCúCúClã×ÁD~úÁ/ûçÁº^Àç+ÀÏ"ÑÀ²¬À”“uÀnùÛÀ2\¿ò°!¿š~ú¿A%¾ô¼j¾Ÿ;d¾Týô¾n˜½ÌÌͽ‘hs½Týô½P½]/½¡ÊÁ½ó¶F¾:^5¾Oß¾Òn˜¿¿G+¿v‡+¿¿¤ýô¿ÆÈ´À ‰7Àk"ÑÀé/AmKÇCúCúCúCúC¨0¤À¶ÀƒÁ ¼jÀȃÀ®¬ÀŸ33ÀŽùÛÀyº^ÀO|îÀÒò¿Ø1'¿‰º^¿+C–¾×P¾‹Æ¨¾;dZ¾%½¶E¢½ƒo½@ƒ¼ýó¶½49X½}󶽸Q쾓¾>vɾ…¡Ë¾µÂ¾ì1¿-¿/\)¿Q©ü¿ƒ÷Ï¿¹™šÀ‡À’n˜À÷l‹A•ÊÁCŒlîCúBùEAÅbÁÀÂffÀ‹|îÀpr°À_\)ÀO =À9ûçÀ²-¿ô9X¿«"Ñ¿_|î¿{¾µÂ¾n—¾ Äœ½ß;d½²-½e`B½'ïž¼Ôýô½t¼½H´9½‹C–½¾vɾo¾1&é¾hr°¾”zá¾·ÎÙ¾àA‰¿ º^¿0£×¿v¿¾ùÛÀ$‹DÀ“× Àï;dÁSøÁQìÁ=qÀøZÀ¶—ÀsoÀ5ó¶ÀÒòÀ33À Û#¿ú¬¿ÖE¢¿©X¿u¿'+¾Ü¬¾‘ë…¾C•¾+½¾vɽ‰7L½H´9½t¼¼´9X¼í‘h½¾w½Týô½Oß½º^5½ó¶F¾¬¾D›¦¾s¶F¾•¾¹Û#¾î—¿" J¿kƨ¿¶ÀQìÀ\“À•`BÀªÀƒÀ¢-ÀƒPÀAûçÀÈ´¿äzá¿ÉxÕ¿»C–¿®Ù¿ž—¿ˆÔþ¿\¬¿%ãT¾ì‹D¾£× ¾aG®¾¬½Ý/½²-½ixÕ½,1½o¼“t¼¼¼j¼ýó¶½#× ½Týô½‰7L½®{½Û"Ѿ1'¾'ïž¾NÙ¾€ƒ¾£Sø¾× =¿33¿O²¿“t¼¿Ê^5À ÅÀÀ ãT¿ù‡¿Ìj¿¦§ð¿²-¿~vÉ¿kƨ¿ZŸ¾¿E¡Ë¿+…¿ Ì;Û"Ѿ£Sø¾l‹D¾)ûç½ó¶F½²-½ƒo½@ƒ½t¼¼Ý/¼u¼›¥ã¼Ä›¦¼ýó¶½#× ½LÌͽ}󶽟¾w½Ä›¦½ï²¾n˜¾5?}¾bMÓ¾bN¾»çm¾÷ÎÙ¿"MÓ¿MÒò¿v‡+¿‡ïž¿ˆõÿ|î¿bÐå¿F§ð¿0å`¿!‰7¿¿ ûç¾øÔþ¾Ø“u¾µ?}¾‘hs¾aG®¾)ûç½ýó¶½¼j½Oß½Týô½¾w¼õ¼¼j¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½¥ã½@ƒ½m‘h½\)½®{½Ôýô¾ J¾¾w¾E¡Ë¾vÈ´¾šŸ¾¾¿|î¾æff¿›¦¿ Å¿33¿—¿¸¾ô¼j¾àÄœ¾ÐbN¾Á%¾±©ü¾ A‰¾ŒIº¾n—¾C•¾¬½ó¶F½¼j½‘hs½]/½,1½o¼ÌÌͼ£× ¼49X¼Týô¼ƒo¼£× ¼Ä›¦¼õ½t¼½49X½Y‡½ƒo½›¥ã½¼j½ãSø¾ =q¾&éy¾H´9¾n—¾ŠÀƒ¾›¥ã¾§l‹¾¬‹D¾« ¾¤Ý/¾›¥ã¾’n˜¾ˆ´9¾}ó¶¾ixÕ¾Rñª¾:^5¾ Äœ¾$ݽÝ/½²-½Oß½]/½0 Ž C–¼Ý/¼¬1¼‹C–¼t¼¼49X¼Týô¼ƒo¼›¥ã¼¼j¼å`B½ C–½#× ½D›¦½ixÕ½‹C–½¥ãT½Ä›¦½çl‹¾+¾¬¾1&é¾C•¾På`¾Xb¾Y‡¾S÷ϾLÌ;B\¾7KǾ+ ¾²-¾\)½ýó¶½Ý/½¼j½²-½ƒo½Týô½,1½ C–¼Ý/¼´9X¼“t¼¼e`B»å`B¼t¼¼49X¼Týô¼ƒo¼›¥ã¼´9X¼Ôýô¼ýó¶½P½0 ŽPå`½q©ü½Oß½£× ½¼j½Ôýô½í‘h¾%¾ 7L¾ Oß¾\)¾ Oß¾ =q¾“½ûçm½ë…½Û"ѽƧð½²-½²-½‡+½e`B½@ƒ½¾w½o¼Ý/¼´9X¼“t¼¼u¼D›¦»Ä›¦¼o¼t¼¼49X¼Týô¼u¼“t¼¼¬1¼Ä›¦¼å`B½+½¥ã½49X½På`½m‘h½…¸½•½£× ½° Žº^5½Àƒ½Â\½Â\½¾vɽ¸Qì½° Ž¥ãT½™™š½Oß½}ó¶½aG®½D›¦½,1½t¼¼õ¼ÌÌͼ¬1¼‹C–¼u¼D›¦¼#× »£× »Ä›¦»å`B¼t¼¼#× ¼D›¦¼e`B¼‹C–¼›¥ã¼´9X¼Ôýô¼í‘h½+½¥ã½0 ŽD›¦½Týô½ixÕ½yÛ#½ƒo½‡+½‰7L½‰7L½‡+½ƒo½yÛ#½m‘h½]/½LÌͽ8Qì½'ïž½t¼¼ýó¶¼Ý/¼¼j¼£× ¼‹C–¼e`B¼D›¦¼#× ¼o»£× »Ä›¦¼o¼t¼¼49X¼Týô¼u¼“t¼¼¬1¼ÌÌͼí‘h½ C–½¾w½8Qì½På`½m‘h½…¸½“t¼½¡ÊÁ½²-½Â\½Òñª½ãSø½ï²½ó¶F½ñ©ü½çl‹½Ôýô½¼j½£× ½‹C–½ixÕ½@ƒ½¥ã¼ýó¶¼Ôýô¼¬1¼‹C–¼e`B¼49X¼t¼»Ä›¦¼o¼t¼¼49X¼Týô¼ƒo¼›¥ã¼¼j¼å`B½+½¾w½vɾF§ð¾E¡Ë¾:^5¾(õþt¼½÷ÎÙ½ÌÌͽ¥ãT½…¸½Týô½'ïž½+¼Ôýô¼¬1¼‹C–¼e`B¼49X»å`B¼t¼¼49X¼Týô¼ƒo¼£× ¼Ä›¦¼õ½t¼½49X½Týô½%½—P½²-½Îٽﲾ1'¾™š¾-V¾C•¾_;d¾~ùÛ¾‘hs¾¡G®¾«…¾¬1¾ Äœ¾Òò¾n—¾A‰7¾“u½ï²½º^5½\)½aG®½0 Ž C–¼Ý/¼¬1¼‹C–¼e`B¼t¼¼49X¼Týô¼‹C–¼£× ¼ÌÌͼýó¶½¾w½D›¦½q©ü½“t¼½²-½× =¾%¾P¾0 žJÀƒ¾fff¾ƒo¾–‡+¾° žÒn˜¾üj¿¶F¿"MÓ¿#•¿E¢¾ýó¶¾ÊÀƒ¾›¥ã¾j~ú¾/ ¾o½Ä›¦½•½aG®½0 Ž+¼Ôýô¼£× ¼ƒo¼#× ¼Týô¼ƒo¼£× ¼Ôýô½o½'ïž½På`½ƒo½¥ãT½ÎÙ¾¾¬¾>vɾdZ¾†§ð¾›¥ã¾²-¾Ëƨ¾íV¿\)¿5¿k…¿”›¦¿«çm¿®—¿šŸ¾¿t¼j¿4¼j¿G®¾¶È´¾‚ J¾:^5¾+½Æ§ð½“t¼½]/½'ïž½o¼ÌÌͼ›¥ã¼D›¦¼ƒo¼£× ¼ÌÌͽo½'ïž½Y‡½Oß½´9X½çl‹¾t¼¾;dZ¾k…¾’n˜¾³33¾Ö‡+¾ú^5¿\)¿#•¿?|î¿o²¿£•¿ëçmÀ$¬ÀIûçÀN—À.ùÛ¿ýp¤¿¨Qì¿ZáH¿ß;¾Àƒ¾ƒ•¾8Qì¾o½¾vɽ‹C–½På`½¾w¼í‘h¼¼j¼u¼›¥ã¼Ä›¦¼ýó¶½'ïž½]/½‘hs½Àƒ½ûçm¾%ãT¾Y‡¾Òò¾·KǾë ¿÷Ï¿4¼j¿U?}¿st¼¿ˆÔþ¿ž—¿ÊÀƒÀE¢ÀpÀ¨záÀ«çmÀ—SøÀ¤À‚ùÛÀ =¿¹Û#¿a%¿ Òò¾¹X¾xÔþ¾,1½ó¶F½° Ž%½@ƒ½\)¼Ý/¼‹C–¼´9X¼í‘h½¾w½Týô½\)½Ä›¦¾¸¾5?}¾u¾¥`B¾Þ¸R¿?}¿G+¿‚MÓ¿¤“¿Ã¶F¿ÝOß¿ñë…ÀÙÀ*^5À‚°!À\)A‹çmB¿kC‚ÞÙB¯‚ ÀKSøÀG®À‡¿¬1¿MOß¿ƒ¾§l‹¾aG®¾¥ã½Û"ѽ²-½ixÕ½,1½o¼£× ¼Ý/½t¼½H´9½‰7L½¾vɾ$ݾ=p¤¾†$ݾ¼í‘¿× ¿7P¿€A‰¿´¼j¿û"ÑÀ%¸ÀG =À\1Àe¸Àm²-À‹|îÀ»SøB”{CúCúCúCúBlQìÀÕó¶ÀmOß¿ýÒò¿‘G®¿/ß;¾Þ5?¾‘ë…¾E¡Ë¾1'½Àƒ½‹C–½LÌͽP¼Ä›¦½o½49X½yÛ#½° ž¾;dZ¾‹C–¾Ïß;¿¬¿`A‰¿¡%¿êÀƒÀ1&éÀ„ÌÍÀ³ÎÙÀÙ?}ÀíûçÀé©üÀÛ¾wÀáãTÀþÐåBãCúCúCúCúBØ<îÁt¼À¬£×À5p¤¿ÊŸ¾¿n—¿ñª¾¼j¾xÔþ¾(õýë…½¥ãT½q©ü½0 żå`B½¥ã½Y‡½›¥ã½å`B¾,1¾…¸¾Òñª¿*=q¿‡ïž¿Ðå`ÀûçÀdÌÍÀ²MÓÀ·dZA_p¤AÅÊÁÀÒE¢Ág+ÁPbÁ=l‹ÁMG®A Cã•¢CúCúCú@íûçÁaoÀõOßÀp¤À ó¶¿¢°!¿B\¾ò-¾œ(ö¾Oß;¾ O߽ě¦½‹C–½H´9½o½8Qì½…¸½Â\¾n˜¾gl‹¾¾vÉ¿$Ý/¿“× À•ÀXõÃÀ ÄœÀè“ÁïžC 7LCúCúCúB¸ïžBøÕÁˆõÃÁŸPÁ¬Ý/B+Û#CúCúCúB«ÁVñªÁ+ÎÙÀÀZÀM‘h¿á©ü¿hs¿çm¾Ä“¾~ùÛ¾)ûç½éxÕ½¡ÊÁ½e`B½P½Y‡½Ÿ¾w½ï²¾;dZ¾™™š¿l‹¿%À¶FÀ‡À¨ÄœÀCC–Á ß;¿íOßCúCúCúCúCúCúCÇ®A OßCˆ‡ðC‘hCúCúCúCúCõŠ?­²-Á È´À˜A‰ÀE¢¿¬(ö¿Gl‹¾ó¶F¾šŸ¾¾JÀƒ¾1'½º^5½ƒo½0 Ž}ó¶½¼j¾hs¾j~ú¾È1'¿9Û#¿ÁhsÀZMÓÀv§ðBÌIºCúCºÎÙB>]/CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBí¶ÉÀÓ|îÀÍVÀW =¿ß¾w¿záH¿¾¹X¾m‘h¾¬½Òñª½‘hs½D›¦½“t¼½ß;d¾0 žå`¾üí‘¿që…ÀSøÀ•/AÙCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCVe`AGC–À⟾À…²-À ë…¿˜Ôþ¿333¾Ú¬¾ˆ´9¾1&é½ë…½Ÿ¾w½]/½§ïž¾o¾S÷Ͼ²-¿²-¿–E¢À®À¯…AÐ1'CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCW ¿-VÁƨÀ•G®ÀE¢¿±ÊÁ¿O²¾ùX¾™™š¾C•¾½¬1½u½¾vɾ“u¾~ù۾ݲ-¿Hõÿ½OßÀ;ƨÀÃ;dÀUãTCªíqCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC—qHÀâ~úÁ {À–vÉÀ(å`¿Ã¶F¿eãT¿´9¾¦éy¾På`¾+½¶E¢½‡+½Ôýô¾0 ž™™š¿ V¿‡ =ÀÀƒÀv‡+ÀߥãÁ=º^@^È´CúCúCúCúBÀE¢CŒÛCúCúCúCúCúCúCúBÔàÅBÞ =CúCúCúCúÀ!Û#Àíº^À‹SøÀ'|î¿ÉxÕ¿o²¿Ù¾­V¾Xb¾ Iº½º^5½\)½éxÕ¾G®¾¶È´¿3÷Ï¿»…ÀB-ÀªffÀáº^Á*ffÁ‡+@ õÃC‘ÓCúB»&éCzèöCúCúCúCúCúCúCúCúÁn‹D¿µ`BC©yC `C#w AúÀüå`À¿l‹Àq%Àë…¿À¿hõÿ Iº¾«…¾Xb¾ C–½º^5½•½õ¾Y‡¾Ïß;¿YÛ#¿õãTÀ€1¿œ(öBwÏB ¸RA`BÁ \)Á ;dÁ³Æ¨Á í‘CúCúCúCúCúCúCúCúC›wLB733BÞbÑ¿‡ÎÙÁn1'ÁCÎÙÁ Ÿ¾ÀåVÀ•hsÀFùÛÀZ¿ª=q¿S÷Ï¿\¾¢MÓ¾NÙ¾+½¶E¢½•½÷ÎÙ¾^5?¾Ù™š¿l1À =qÀ„9XAQ+C@V‡C,ÆéBÇYšBhë…ÁW`BÁ›È´Àßß;CúCúCúCúCúCúCúCú¾cSøB†Ý²Cn˜?õÁw&éÁE"ÑÁ À¶$ÝÀr~úÀ$(ö¿ÜÌÍ¿ƒ¿8“u¾éxÕ¾”zá¾@ƒ¾½®{½\)½í‘h¾S÷ϾÍÒò¿\¬¿þÙÀ}Oß@tjB‡8RB›*B5SøAÇùÛÁ:{Ái™šÁ~=qC°CúCúCúCúCú¿â\ÁÉŸ¾Á°ÀƒÁT›¦À‰Û#ÁwdZÁp‡+Á2å`Àù/À¦ùÛÀ\“À“u¿½p¤¿vE¢¿¸R¾ÌIº¾…¸¾0 Ží‘h½£× ½…¸½Ù‡¾;dZ¾¯²¿2ñª¿ÁÊÁÀI‰7ÀŒå`¿ƒt¼¿óoÀéë…Á&éÁ!ó¶Á%p¤Á[ß;Áe¥ãCúCúCúCúCúCRòÁè`BÁ­™šÁ"°!@þ=qÀþÀƒÁc7LÁ2ÐåÁÙÀ°ÄœÀc¶FÀ ýô¿®{¿Z¬¿ Àƒ¾³¶F¾l‹D¾¸R½Ù‡½—P½m‘h½º^5¾¬¾ŠÀƒ¿MÓ¿;d¿÷®ÀWß;ÀœÝ/ÀÇ ÀÞ-ÀÚ JÀÎMÓÀÜbNÁÌÍÁ~ƒC[‹…CúCúCúCúCúÁ›dZÁ¬ûç¿lÌÍAìKǽPÁU"ÑÁ1‘hÀü“uÀ¼ÌÍÀyë…ÀMÓ¿¨r°¿H1'¾÷ÎÙ¾ž¸R¾Që…¾ Oß½Â\½‰7L½LÌͽ›¥ã½ùÛ#¾Oß;¾²°!¿²-¿ˆÔþ¿ÞvÉÀ!‡ÀK¶FÀcçmÀk Àrn˜Àއ+ÀÙë…ÁIÊÁBi¸RCúCúCúCúCúB““Á–ë…Á;¸À„ZÁ× ÁFÁÀƒÀª=qÀª\À€¬À33¿¡hs¿7Îپݲ-¾ŒIº¾9X½ûçm½° ŽyÛ#½,1½}ó¶½Â\¾P¾q©ü¾Â J¿“u¿dZ¿Òò¿Æéy¿æff¿þ5?À|îÀ7\)À’{Á£×Àµ‰7CúCúCúCúCúC6vFÁf´9Á?&éÁ/ =Á(IºÁ%Áí‘À¶5?À¢§ðÀhõÃÀj¿ß;¿" J¾Â J¾t¼j¾!ÊÁ½Ý/½›¥ã½]/½\)½LÌͽ•½Ý/¾$Ý/¾u¾³33¾ûçm¿'®¿Që…¿yÛ#¿‘©ü¿¯ß;¿ëçmÀ;oÀ°9XÁ%VA^VCúCúCúCúA7ÎÙÁ"£×Àý¸ÀíÊÁÀê\Àã¾wÀÑÒòÀ¯KÇÀ†áHÀ2-¿Ï ¿h´9¿$ݾ¢Ðå¾Oß;¾ C–½Àƒ½‡+½D›¦¼í‘h½#× ½e`B½¡ÊÁ½å`B¾!ÊÁ¾_;d¾–¾Â\¾ò°!¿33¿2-¿_;d¿—ÎÙ¿çÎÙÀG¾wÀ·ïžÁ £×?´9XA¨× A³¸R¿b JÁ°!ÀÄå`À˜r°ÀެÀŽ JÀ‹PÀ‚E¢À`£×À,ÌÍ¿éÛ#¿A‰¿,Iº¾Ðå`¾ƒo¾,1½éxÕ½£× ½ixÕ½,1¼Ä›¦½o½49X½q©ü½£× ½Ý/¾t¼¾?|î¾s¶F¾—P¾º^5¾å`B¿ë…¿DZ¿Ž5?¿Ý²-À4ÌÍÀïžÀɉ7Àí&éÀ웦ÀÈA‰À”¬ÀYXÀ1©üÀ$ÌÍÀ!ÊÁÀVÀ©ü¿ü(ö¿Æ‡+¿‘h¿;çm¾ñ&é¾›"ѾLÌ; =q½Àƒ½‰7L½H´9½t¼¼£× ¼Ôýô½ C–½8Qì½q©ü½²-½ÌÌ; J¾"Ðå¾Iº^¾wÎÙ¾š¬¾Ão¿A‰¿0 Å¿{"Ñ¿¶‡+ÀÊÁÀ+C–ÀGÎÙÀIë…À2áHÀMÓ¿îvÉ¿ÎvÉ¿¿¾w¿¸Q쿯²¿¡%¿‹¥ã¿aG®¿(õþﲾ¤Ý/¾aG®¾¥ã½Û"ѽ›¥ã½e`B½'ïž¼ý󶼃o¼¬1¼Ý/½\)½8Qì½ixÕ½“t¼½¸Qì½ãSø¾ Iº¾,1¾Týô¾…¸¾ª~ú¾Þ¸R¿9X¿E`B¿€A‰¿‘h¿² J¿¶§ð¿«Æ¨¿™7L¿‡ =¿t9X¿c× ¿WÎÙ¿J=q¿7ÎÙ¿ ¿× ¾ÍÒò¾š¬¾`A‰¾!ÊÁ½éxÕ½©ûç½yÛ#½úCúCúCú@ÀA‰À×|îÀbŸ¾¿ð Å¿‡®¿"MÓ¾ÌIº¾…¡Ë¾5?}½ûçm½²-½%½@ƒ½\)¼¬1¼í‘h½¥ã½Týô½“t¼½ÎÙ¾n˜¾På`¾•¾Ôýô¿È´¿Tzá¿–§ð¿ØQìÀMÓÀS À†VÀ²-ÀªvÉÀ°A‰ÀÉÀ–§ðCúCúCúCúCúCº`!ÁÀ¸1À7®¿Äýô¿bMÓ¿ û羯²¾hr°¾¸R½Ý/½²-½e`B½'ïž¼ÌÌͽ C–½@ƒ½‡+½Àƒ¾ C–¾NÙ¾›"Ѿë ¿0å`¿‚n˜¿½²-À •ÀTÌÍÀ¢ JÀâñªÁÛ#Á)ë…Á'ÒòÁ ÄœÁ(MÓÀNÈ´CúCúCúCúCúCúÁ`ZÁ ÅÀ†ÙÀ “¿œIº¿9‡¾æff¾”ýô¾F§ð¾1'½¾vɽ‡+½D›¦¼õ½'ïž½ixÕ½©ûç½ùÛ#¾=p¤¾”zá¾ï²¿DÝ/¿ bN¿û À:ñªÀ‹ =ÀÖñªÀÑ‘hA¦çmB‚ Àìí‘Á$ffÁ#©üÁ‚éyÁ„¬C¼cøCúCúCúCúCdú Á”(öÁC‰7ÀàÀHA‰¿Ùº^¿z^5¿KǾ¾vɾxÔþ¾&éy½ãSø½Ÿ¾w½aG®½\)½H´9½\)½Òñª¾!ÊÁ¾€ƒ¾×P¿>¸R¿° ÅÀ!XÀ†-ÀÅXÁ¾wÁ#¡ËCPñ'CúCúCúC›çBm#×Á¨(öÁàQìÁq|îCúCúCúCúCú@¶—ÁwûçÁÀ•ó¶À¬¿¬(ö¿Hr°¾ô¼j¾›¥ã¾JÀƒ¾1'½º^5½ƒo½#× ½ixÕ½¬1¾o¾Oß;¾­V¿¥ã¿™‡À"-À— =>.{AÕVA7¶F@$9XCúCúCúCúCúCúCSÙXA‡Ÿ¾C›49CúCúCúCúCúCúB³¯žÀÿ¶FÀß"ÑÀh“u¿ðbN¿…¡Ë¿²-¾Â J¾vÈ´¾!ÊÁ½Ù‡½•½vɽùÛ#½§ïž½Týô½Ÿ¾w½÷ÎÙ¾E¡Ë¾¥`B¿t¼¿ƒÀ"áHÀ¢^5CRòCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBŒJÀÔbNÀ\í‘¿çÎÙ¿€ƒ¿÷Ͼ±&é¾["Ѿ Oß½º^5½q©ü½º^5¾n˜¾q©ü¾ÐbN¿=/¿¹7LÀK À½ë…Cr>5CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúAJ´9ÁçmÀ‰Û#À-¿ž¸R¿1&é¾ÍOß¾wÎÙ¾¥ã½ÊÀƒ½‡+½Ôýô¾.{¾•¿§ð¿}p¤¿ø1'À}Àÿ;dBøÕCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBÿŸ¾ÁOÛ#Án˜ÀŸSøÀ-ãT¿ºÀƒ¿K ¾äÝ/¾‡+¾&éy½× =½•½ñ©ü¾LÌ;¹Û#¿3÷Ï¿·ïžÀ=ÂÀµ™šÁ`BÁfÝ/B…»çCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC ÁU/Á l‹À¦vÉÀ<ýô¿ËC–¿YÛ#¾ò-¾Oß¾.{½ß;d½Ÿ¾w¾¸¾l‹D¾äÝ/¿rñªÀ áHÀޏR?&§ðBMhsB“@B|‹DBCSøCÊqËCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú?Á%Á2ÄœÀî§ðÀš=qÀ6E¢¿ÇP¿WÎÙ¾ð£×¾Oß¾.{½ß;d½§ïž¾V¾‚\¿¡Ë¿š¬À>$Ý¿·®CƒÚÁCúCúCúCúBP¬A°!Bðt9CúCúCúCúCúCúCúCúCúCúCúCúC{dAí1'Á ¡ËÁEãTÁ ~úÀ¿|îÀPÀ¶F¿°bN¿DÝ/¾áG®¾†§ð¾'ïž½Ù‡½§ïž¾bN¾‡+¿V¿«"ÑÀU`BAbNCúCúCúCúCúC¡¼Á¥È´A~9XCúCúCúCúCúCúCúCúC˳øCúCúCúBîÛ#¿ÿ¾wÁk`BÁ#PÀÙ&éÀ” ÅÀD¬¿ô¼j¿Äœ¿(õþÉ7L¾vÈ´¾²-½ÎÙ½¡ÊÁ¾ =q¾%¿ff¿Ÿ¾wÀG;d@QXCúCúCúCúCúC°¤Áƒ{Á©•CúCúCúCúCúCúAÎKÇC¾%`CúCúCúC§®A +ÁZ{ÁfõÃÁ‡+ÀÄ´9Àw|îÀ¥ã¿ÀbN¿iº^¿{¾¯ ¾]/¾bN½Àƒ½•½ùÛ#¾cSø¾âMÓ¿{çmÀ ÀVAêbCœÙºC¶pC$XÕBšÆ¨Àî¸RÁY‰7ÁžïžÁšn˜C1ÉCúCúCúCúC¦È1C9µCúCúCúCúAc/Á"ýôÁI…Á$jÀÖ‡+Àu`BÀ 33¿¢°!¿C•¾ð£×¾˜b¾D›¦¾ J½²-½…¸½× =¾:^5¾®{¿/ß;¿½/ÀF§ðÀŸ À‰ÊÁÀ¼bÁn˜Á2ÌÍÁ3²Á-ÎÙÁV—Á§‡B'ØCúCúCúCúCúC‚B~¾CúCúCúBæfAÔBÔ.AaÊÁÀ×t¼À†áHÀ J¿”Z¿+ ¾ÐbN¾„“¾-V½éxÕ½¡ÊÁ½e`B½²-¾n˜¾|푾æéy¿Y™š¿Ì(öÀ2 JÀ‡× À²MÓÀÊ{ÀÎ JÀÈ ÅÀУ×Á t¼Án1À2áHCúCúCúCúCúCú@¯oC¨PCúCºGÏB”¥`C™õ`CúC^5ÀiG®ÀŒƒÀQ쿉X¿b¾¶E¢¾fff¾“u½ÎÙ½\)½@ƒ½\)½ß;d¾49X¾•¾ûdZ¿PbN¿¤›¦¿î—À…À6ÀDIºÀPbNÀrÐåÀ®E¢Áp¤Áa7LCúCúCúCúCúCúÁ^—ÁC™šAUÒòBèËÇB¾C{¦CáWBð!À²-ÀKÇ¿ó÷Ï¿q©ü¿“¾/¾G®¾¸½¶E¢½%½¾w½e`B½©ûç¾¾D›¦¾— =¾äÝ/¿&ff¿d›¦¿’MÓ¿®¸R¿ÇÎÙ¿ç+À=qÀZ JÀÄ›¦Á*§ðC”#uCúCúCúCúBs ÁsÁ`Ý/ÁCë…¾¤Z¿Æ‡+ÀŠ J@ù`BÀ-À¨¬ÀBŸ¾¿¿;d¿D“¾Û"Ѿ„“¾)ûç½ãSø½²-½aG®½o½49X½%½¸Q쾸¾?|®¾º^5¾öE¢¿dZ¿<í‘¿a‰7¿‰Û#¿µÀE¢ÀcoÀÏdZÀ,“C1”{CºMqCaHAæC–Á{Á"ÑÀþáHÁ‰7ÁÁ G®Á¡ËÀ× À¨ ÅÀ`å`¿ûƨ¿…ãT¿t¼¾¬‹D¾W =¾ Oß½Àƒ½‡+½D›¦¼Ôýô½\)½D›¦½‡+½º^5¾¾-V¾dZ¾’ñª¾¸Qì¾áÊÁ¿ ~ú¿-Òò¿f$Ý¿¤Z¿ÿ ÀRáHÀªÙÀäí‘ÁéyÁIºÁSøÀÓÎÙÀŸt¼À‰¸Àˆí‘À"ÑÀzáÀˆ‹DÀl(öÀ5‘h¿ô9X¿”Ý/¿/\)¾Ñë…¾ƒo¾)ûç½å`B½Ÿ¾w½e`B½'ïž¼¬1¼å`B½P½LÌͽ‡+½²-½éxÕ¾‡+¾=p¤¾l‹D¾‘ë…¾´9X¾ãSø¿¼j¿K ¿‘&é¿ÕÀ•ÀTIºÀ€bNÀ…ÂÀqÛ#ÀH1'À%ÂÀzáÀƒÀõÃÀ ó¶Àçm¿ä9X¿´9X¿hs¿-Oß¾àÄœ¾‘ë…¾A‰7¾“½¸Q콃o½@ƒ½\)¼“t¼¼¼j¼í‘h½¥ã½H´9½%½¥ãT½Ðå`¾ J¾ Äœ¾E¡Ë¾t¼j¾™‡¾Ã•¿A‰¿+C–¿f$Ý¿—ïž¿¾¸R¿ÜÌÍ¿çP¿Ý‘h¿È1'¿³t¼¿¥ãT¿Ÿ;d¿š~ú¿“Sø¿†È´¿i7L¿=/¿²¾Ï\)¾‘hs¾JÀƒ¾V½ÊÀƒ½‘hs½Týô½¾w¼õ¼u¼“t¼¼¼j¼õ½P½@ƒ½q©ü½•½¸Qì½ãSø¾ C–¾+ ¾Rñª¾ƒ•¾¥ãT¾Òn˜¿Ý/¿$Z¿Co¿["Ñ¿f§ð¿d›¦¿YÛ#¿LIº¿A%¿8b¿/\)¿$“¿¼j¿G®¾Ö‡+¾©û羉7¾@ƒ¾ Oß½Ðå`½™™š½e`B½,1½o¼ÌÌͼD›¦¼u¼›¥ã¼¼j¼í‘h½t¼½49X½]/½‡+½¥ãT½È´9½ó¶F¾zá¾5?}¾]/¾‡+¾¢Ðå¾Á%¾Ý/¾ó¶F¿A‰¿‰7¾ýó¶¾ô9X¾éxÕ¾Þ5?¾Ñë…¾Ão¾° žš¬¾‚ J¾Týô¾(õþo½È´9½™™š½ixÕ½49X½ C–¼Ôýô¼¬1¼#× ¼D›¦¼u¼›¥ã¼¼j¼å`B½ C–½'ïž½LÌͽu½“t¼½° ŽÒñª½ýó¶¾P¾333¾Që…¾p£×¾‡+¾’n˜¾š¬¾/¾œ(ö¾˜b¾’ñª¾‹Æ¨¾ƒ•¾s¶F¾\(ö¾B\¾&éy¾ C–½ãSø½¶E¢½‘hs½e`B½49X½\)¼Ý/¼´9X¼‹C–¼o¼#× ¼D›¦¼u¼“t¼¼´9X¼Ý/½o½¥ã½8Qì½]/½ƒo½™™š½´9X½Òñª½õ¾ Iº¾²-¾.{¾:^5¾C•¾G®¾G®¾D›¦¾>vɾ6E¢¾+ ¾¸R¾bN¾½ß;d½¾vɽŸ¾w½ƒo½Týô½,1½ C–¼Ý/¼´9X¼“t¼¼e`B»å`B¼t¼¼#× ¼D›¦¼u¼“t¼¼¬1¼ÌÌͼí‘h½\)½'ïž½@ƒ½aG®½ƒo½—P½¬1½Àƒ½Ôýô½éxÕ½÷ÎÙ¾%¾“¾¸¾o½ýó¶½ó¶F½å`B½Ôýô½Â\½®{½™™š½…¸½aG®½@ƒ½¾w½o¼Ôýô¼´9X¼“t¼¼e`B¼D›¦»Ä›¦»å`B¼o¼#× ¼D›¦¼e`B¼‹C–¼›¥ã¼¼j¼Ý/¼ýó¶½t¼½'ïž½@ƒ½Y‡½u½‰7L½•½Ÿ¾w½©ûç½° Ž´9X½¶E¢½´9X½®{½§ïž½Ÿ¾w½“t¼½‡+½u½Y‡½@ƒ½#× ½\)¼í‘h¼ÌÌͼ¬1¼‹C–¼e`B¼D›¦¼#× »Ä›¦»å`B¼o¼#× ¼D›¦¼e`B¼‹C–¼£× ¼Ä›¦¼å`B½+½¾w½8Qì½Týô½u½‹C–½²-½° Žě¦½Ù‡½ï²¾o¾V¾‡+¾Ÿ¾¾™š¾t¼¾+½ï²½ÎÙ½¬1½Oß½ixÕ½vɾ%½²-½yÛ#½t¼½På`½•½Ý/¾)û羇+¾âMÓ¿G®¿·ïžÀ(“uÀ™šÀÕ?}Á(öÁcG®A‰÷ÏCúCúCúCúCúC†oßÁòhsB)ž¸CúCúCúCúCúC QhÁ`5?ÁDÝ/ÀÇ¥ãÀJ^5¿Ø´9¿wKÇ¿9X¾¸Ôþ¾l‹D¾¬½Òñª½‘hs½,1½u½¶E¢¾ =q¾["Ѿ¶È´¿#•¿Ÿß;À'ß;ÀX¿kƨA³°!AoÁ+`BCήÙCúCúCúCúCúCúCA $ÝCúCúCúCúCúCúC "NA8QìÁÄœÀœ(öÀvÉ¿¬(ö¿F$ݾí‘h¾“t¼¾ž¸RÀî¬À¶À4›¦¿©7L¿(1'¾µÂ¾S÷Ͼo½¬1¾bN¾ƒ•¿o¿‘‰7À.—ÀA‰B(„CìîVCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú¾Â\Àµ‡@˜´9À’ÐåÀ¬IºÀ3× ¿©‡¿(1'¾¶E¢¾S÷Ͼ“½´9X¾¥ã¾’ñª¿¥ã¿½²-Àkt¼A›“uCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú?ü(öÁ£ÂÁ+²-Àƒ+À·¥ãÀ‘ë…À‰7¿–‡+¿"Ѿ¬1¾LÌ;½¶E¢¾¸R¾˜“u¿'l‹¿Õ`BÀwPB¾ŒÍCúCúCúCúCúCúCúC:ZáCúCúCúCúCúCúCúCúCúCúCúCúCúCúÀšÁ‹ÄœÁ<å`ÀýOßÀ¯¾wÀWïž¿éX¿v¿§ð¾›¥ã¾>vɽó¶F½®{¾“u¾‘ë…¿5?¿Ç+Àq7LBG¶FCúCúCúCúCúCúCúBŒ™C%Ÿ¾CúCúCúCúCúCúCúCúCúCúCúCúCëwLA1Á~E¢Á+xÕÀÓ33À‡Àïž¿¬j¿Co¾âÐ徉7L¾,1½áG®½¡ÊÁ¾ 7L¾~ùÛ¿“¿›C–ÀBn˜¿N—Cž.wCúCúCúCúCúCúA9ïžÁò‡C¢gLCúCúCúCúCúCúCúCúCúCúCúCúC)¬¿Õ¡ËÁ+&éÀÌbNÀXå`¿í²-¿‡ =¿5?¾¾ùÛ¾n—¾Ÿ¾½ÌÌͽ\)½ë…¾På`¾È´9¿S÷Ï¿ñ&éÀº^Àl›¦A‹•B1 ÅC<“øB¨ßAnÝ/@²ñªÁƒ+ÁÌG®AŽ´9CúCúCúCúCúCúCúCúCúCúCúCúCúCúALjÀÔA‰ÀXr°¿Ó÷Ï¿dÝ/¿¸¾£Sø¾Oß;¾1'½¸Qì½u½Â\¾!ÊÁ¾ß;¿®¿…ãTÀ‹DÀt1ÀÁ¡ËÀë¶FÀ¶vÉÀ÷× Á;dÁ¼jÁ0bÁ‡‹DÁ©Ý/CúCúCúCúCúCúCúCúCúCúCúCúCúCúBé À´IºÀY™š¿Ä›¦¿Hõþå`B¾ŒIº¾49X½ñ©ü½¥ãT½LÌͽ›¥ã½õ¾Iº^¾¬1¿?}¿%¿ÕÀ# À^$ÝÀ…VÀïžÀ“ƨÀŸPÀθRÁ,¬Á„KÇCúCúCúCúCúCúBµò-B£ÅCúCúCúCúCúCúBšr-À°“uÀBáH¿¬(ö¿-V¾Ã•¾p£×¾¥ã½Òñª½‘hs½'ïž½u½¸Qì¾V¾^5?¾®—¿®¿L1¿‘%¿¿;d¿èbÀ× ÀƨÀ1xÕÀxÀÒ=qÁ3KÇCŒ¡CúCúCúCúCúÁnõÃÁž× BQ|îCúCúC¢p¤CúCŒs–@£KÇÀž JÀ¼j¿ˆ´9¿ Oß¾¢Ðå¾JÀƒ¾¸½¶E¢½}ó¶½ C–½D›¦½‹C–½ÊÀƒ¾zá¾Y‡¾œ(ö¾Û"Ñ¿¶F¿=²-¿gïž¿‰Û#¿¥`B¿Ó33ÀvÉÀup¤ÀÜ1'Àp ÅC)¡CÔ— CúCúAŽdZÁQÛ#ÁK‰7Á>bNÀ7+À`1'ÀãTAº|î@ Ý/À¢{ÀL‹D¿Å¡Ë¿F§ð¾Ú¬¾‚\¾&éy½ß;d½™™š½]/¼å`B½¥ã½Týô½“t¼½ÌÌ;V¾B\¾‚\¾©ûç¾× =¿›¦¿" J¿IxÕ¿ƒSø¿·ÎÙÀ çmÀdÌÍÀºáHÁ•ÁIºÀ­ÀÂÐåÁå`ÀÞffÀÎÐåÀÝÊÁÀï+ÀöáHÀçß;Àº JÀ‘‡ÀD›¦¿ß¾w¿rñª¿1'¾¡ÊÁ¾JÀƒ¾$ݽ¸Q콃o½ùÛ¿ªŸ¾À£×À²-À͸Á =Ás¸Á„…BeïžCúCúCúCúCú¿²C—œJCúCúCúCúCúCúB¹åÁ`Ý/ÀîñªÀpbÀ Å¿‘G®¿,‹D¾Ó÷Ͼ†$ݾ.{½éxÕ½Ÿ¾w½0 ŽyÛ#½¸Qì¾ Iº¾\(ö¾µ?}¿5?¿”záÀ¼jÀ‘ë…ÀÚ~úÀÛïž¿?¾wB%YCoäÝCúCúCúCúCúCúC”“¶ÁLÀƒCúCúCúCúCúCúCúAÑdZÁ"“uÀ½‘hÀBÀƒ¿Òñª¿o ¿ Iº¾ª~ú¾V¾ C–½º^5½H´9½“t¼½ß;d¾.{¾ŒÌ;ð Å¿\j¿ß ÀtÝ/À­ÒòBn%ãCÖÈ“CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA£9XÁ JÀœ›¦À!G®¿«dZ¿<푾Ù‡¾‚\¾#× ½Ôýô½e`B½®{¾$ݾW =¾³33¿p¤¿”›¦À“À­`BA&—CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC[¶‡Á:r°ÀüQìÀ€zá¿ü‹D¿€A‰¿ ûç¾²-¾>vɽñ©ü½ƒo½ÊÀƒ¾ Äœ¾…¡Ë¾çl‹¿Qhs¿ÈbÀN¸RÀÞ$ÝA€çmCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC%Ê=ÀÃdZÀŲ-À9X¿«çm¿+…¾¹Û#¾Xb¾$ݽ“t¼½éxÕ¾A‰7¾¨r°¿Ÿ¾¿“÷ÏÀûçÀ’¬ÁPÁ,å`C—tÝCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBõÃÀð1À~V¿ÛC–¿L1¾Òn˜¾m‘h¾bN½£× ¾¸¾gl‹¾× =¿VÈ´¿ä¼jÀt(öÀáVÁ!ïžÀ·SøBô±ªCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCG =À jÀ–Àƒ¿þ{¿a‰7¾áÊÁ¾záH¾‡+½° ž¾‡®¿+¿–ffÀ5?}À›t¼B+àBCõ CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCSVFCúCúCú@ÞéyÀ”záÀQì¿bÐå¾âÐå¾{çm¾P½º^5¾ Äœ¾—P¿ Äœ¿Ä“Àv$ÝA™¶FCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBºwÏB@ƒCúCúCÉ¿ÀÀ{33¿ß;d¿N—¾Õ¾q©ü¾t¼½º^5¾#× ¾²-¿-V¿Üí‘À‚—B»&fCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBÕ:áÁª‰7A—A¸33=ÎÙÀ¡p¤À5¡Ë¿­Oß¿.V¾¾vɾ_;d¾ C–½´9X¾²-¾— =¿$“¿Î—À}ó¶B>ÖCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúAÅVÁt~úÁÎÙÀăÀeãT¿õ¡Ë¿‰7¿V¾¤Ý/¾H´9¾½¥ãT¾V¾„›¦¿ xÕ¿¡ÊÁÀLZ¿½²-C¤.VCúCúCúCúCúCúCúB#bNCúCúCúCúCúCúCúCúCúCúCúCúCúCúC•Qh¿êÀƒÁl‹ÀœA‰À$(ö¿²n˜¿H1'¾èõþOß¾2-½éxÕ½“t¼½ó¶F¾Y‡¾Ñhs¿^5?¿ÿ ÀŒ£×À•`BAÎPCúCúCúCúC¾¥¿Ñ©üÁåbNC •CúCúCúCúCúCúCúCúCúCúCúCúCúCúCú¿…ÂÀ•ó¶À ›¦¿‘&é¿#•¾Ão¾r°!¾¬½Ðå`½}ó¶½È´9¾(õþ–‡+¿ ¿Ž—À1'À‰ë…ÀÛ"Ñ?ÙÛ#B_¸A®§ðÁOßÁ0IºÁ_&éÁMÓÁ• CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA³ß;À’Ÿ¾À‡¿z^5¿ =q¾¥`B¾På`¾ 7L½¸Qì½Týô½¡ÊÁ¾¾S÷ϾµÂ¿|‹D¿ðƒÀ@À†ñªÀ¡©üÀ¶Ÿ¾À¿¾wÀÉ%Àô“uÁ:Ý/ÁhsCúCúCúCúCúCúCSi7CúCúCúCúCúCúCúCú@ÏÎÙÀ„zá¿ß¾w¿Týô¾èõþŒIº¾2-½í‘h½¡ÊÁ½0 Ž%½Àƒ¾¾j~ú¾ºáH¿t¼¿bÐ忦¿áë…À ZÀ ÄœÀ2Ÿ¾ÀPÄœÀ‹ ÀÝG®ÁBE¢Ai\)CúCúCúCúCúÁ'33BhŒJCúCúCúCúCúCúC4,JÀžMÓÀJ-¿®V¿+…¾¿|î¾ixÕ¾P½ÊÀƒ½Oß½\)½LÌͽ‘hs½Ôýô¾¬¾gl‹¾¨r°¾ð£×¿$Ý/¿WP¿…¡Ë¿Ÿ²¿¾¸R¿ï|îÀ%?}À€ÌÍÀßß;Á1¶F?C}]²CúCúBˆùÛÁŠ÷ÏÁ‡?}A¶FCŽ•ÃC•ãCLjCúCÑ\Í@v$ÝÀ‰Û#À-¿vÈ´¿MÓ¾˜b¾>vɽûçm½¬1½q©ü¼í‘h½¾w½]/½›¥ã½Ù‡¾P¾På`¾Òò¾ºáH¾ï ¿¼j¿6È´¿co¿’°!¿ÉXÀÌÍÀkdZÀ¾‡+Á^5ÁV?ë…¿ÓSøÁ(öÁXÁ;dÁùÛÁ¬ÁùÛÁ¿©Û#ÀXQìÀ‘hÀýô¿™xÕ¿$›¦¾½p¤¾ixÕ¾P½ÎÙ½\)½LÌͼ¼j¼ýó¶½,1½e`B½›¥ã½Ðå`¾ =q¾5?}¾ixÕ¾“÷Ͼ¸Qì¾åãT¿£×¿:áH¿z^5¿®vÉ¿úÀƒÀ5À}VÀ¡‡À³¶FÀ±À¡‰7À’5?À;dÀ—\)ÀŸ¾wÀžñªÀ’$ÝÀtÌÍÀ9&é¿÷ÎÙ¿–éy¿2°!¾×P¾†§ð¾0 Ží‘h½¥ãT½m‘h½,1¼›¥ã¼ÌÌͽ+½0 Že`B½•½Àƒ½÷ÎÙ¾¬¾D›¦¾t¼j¾™‡¾À¾õ?}¿|î¿R°!¿Œ‹D¿¹ûç¿îVÀ¾wÀ®À"ñªÀzáÀ(öÀbÀbNÀQìÀ n˜¿ú=q¿Ót¼¿¤ýô¿mÒò¿!‰7¾Ö¾Òò¾>vɾo½¸Qì½…¸½D›¦½\)¼ƒo¼£× ¼Ôýô½+½,1½]/½Oß½° ŽÝ/¾ 7L¾)ûç¾Rñª¾ƒo¾¤Z¾Ï\)¿•¿&$Ý¿NÙ¿z^5¿å`¿žÙ¿¤›¦¿£Sø¿ž¸R¿š¬¿–E¢¿å`¿‡®¿rñª¿NÙ¿&§ð¾þùÛ¾ºáH¾…¡Ë¾>vɾ+½Â\½\)½Týô½¾w¼í‘h¼Týô¼‹C–¼¬1¼Ôýô½+½'ïž½På`½ƒo½Ÿ¾w½Æ§ð½ó¶F¾¾7KǾaG®¾Š=q¾©xÕ¾ÍÒò¾õ¿ ¿!%¿.V¿5¿6‡+¿3¶F¿.—¿(1'¿|î¿t¼¿× ¾âÐå¾»dZ¾•¾fff¾.{¾o½Â\½‘hs½]/½'ïž¼ýó¶¼Ä›¦¼49X¼e`B¼‹C–¼¬1¼Ôýô½o½¾w½D›¦½m‘h½‘hs½° Å½× =¾ J¾¬¾jÁc\)ÁŒxÕCþ¸CúCúCúCúBw²-Á<£×À˲À7ïž¿¸´9¿NV¾ùX¾ž¸R¾Që…¾\)½Æ§ð½Oß½LÌͼÝ/½t¼½LÌͽO߽ȴ9¾bN¾S÷Ͼœ¬¾ê~ú¿/ß;¿ƒ÷Ï¿Èr°ÀÂÀ…/Àéº^À‚~úB´MPC‚ÅCúC×ÏßA‚t¼Á¶¡ËÁ*Ÿ¾CúCúCúCúCúCúÀ}p¤Á+À„bÀ‡¿p¤¿'®¾Ñhs¾‡®¾5?}½õ½¬1½q©ü½o½0 ŽyÛ#½²-¾%¾@ƒ¾“t¼¾åãT¿6¿£×¿äZÀ3çmÀ‘©üÀüzáÁ8CFœCúCúCúCúCúA{CÍ‘CúCúCúCúCúCúBÌcTÁ>ZÀ¶E¢À3× ¿Ä“¿dÝ/¿ ƨ¾°£×¾e`B¾“u½ÎÙ½‘hs½P½Týô½—P½Ý/¾%ãT¾€ƒ¾ÎV¿+ ¿’ J¿ûdZÀTZÀ®ffÁ ÂÁgdZÀ ƒCúCúCúCúCúCúC´­/CúCúCúCúCúCúCúCrc×Ám× Á™šÀƒt¼À5?¿¢ J¿?¾w¾éûç¾’ñª¾=p¤½ùÛ#½©ûç½0 ŽyÛ#½¶E¢¾ 7L¾S÷Ͼª~ú¿²¿~ùÛ¿í²-Àa‡ÀË\)Á"A‰ÀT‹DB-yÛCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúAaÁ=ãTÀÒŸ¾À_ =¿ó¶F¿ˆÔþ¿vɾ½p¤¾j~ú¾‡+½Æ§ð½H´9½“t¼½Û"Ѿ(õþ†§ð¾àA‰¿D›¦¿¹7LÀ;33À½º^ÁáH@™ÊÁCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁ “Á3²-À¿× ÀFV¿Íp¤¿[çm¾öÈ´¾‘hs¾333½çl‹½e`B½¬1¾“¾På`¾« ¿n˜¿„“ÀbNÀ‡KÇÁ9X?×+ClÍCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB“xR>:^5Á ÀªE¢À!‡¿›C–¿ A‰¾²-¾Rñª¾o½ƒo½Æ§ð¾²-¾%¾Û¥ã¿BMÓ¿²ÐåÀ-²-À´“uÁ1p¤@øIºCàóCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBNÊÁÀó À{33¿Ù‡¿L‹D¾Ôýô¾q©ü¾n˜½‘hs½å`B¾È´À‰²-À§Æ¨ÀÆ\ÀÙOßÀéxÕÁ ¾wÁMt¼Á<¼jCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB»dÀ“PÀQì¿rñª¿Z¾²-¾G®¾o½²-½0 Ž%½Àƒ¾zá¾hr°¾¸Qì¿ë…¿bMÓ¿¨“u¿êáHÀÀ/KÇÀFÈ´Àk Àš—ÀéûçÁ<›¦A®|îCúCúCúCúC¹øöC/\CúCúCúCúCúCúCúCëÀÀdZÀe?}¿Å?}¿A%¾× =¾‚\¾&éy½ß;d½™™š½\)½LÌͽ“t¼½× =¾²-¾hr°¾ª~ú¾ô¼j¿)º^¿a‰7¿ŽV¿­/¿Ò JÀ¬À4‹DÀ‡ =ÀÝVÁ3Û#ÁFQìB"wÏCúC»;D¿MÓÁ£OßÁ‰7C5†fCúCúCúCúCúA‡IºÀ˜‹DÀ°!¿Š¬¿hs¾¨õþRñª¾ =q½¼j½ƒo¼í‘h½#× ½aG®½²-½Ý/¾Ÿ¾¾V¾‘ë…¾Â\¾ûçm¿;d¿Fff¿y™š¿¡ÊÁ¿ÛƨÀÒòÀnùÛÀ¹ë…Á …Á1²-Áë…Á/ãTÁK™šÁG× ÁL¼jÁ<\@~5?@Œ“ÀÄQì@Ôå`¿&§ðÀ¸À'ß;¿«…¿6È´¾Ñë…¾%¾&éy½áG®½›¥ã½]/¼Ä›¦½o½0 Žm‘h½Ÿ¾w½× =¾\)¾vɾV½Òñª½²-½m‘h½49X½+¼Ôýô¼49X¼e`B¼‹C–¼´9X¼Ý/½+½'ïž½LÌͽ}ó¶½›¥ã½¾vɽéxÕ¾V¾-V¾På`¾yÛ#¾“t¼¾« ¾Ão¾Ø“u¾éûç¾õ?}¾ùX¾÷ÎÙ¾ñ©ü¾æéy¾Ø“u¾Æ$ݾ¯²¾—P¾|푾MÒò¾#× ¾½Æ§ð½™™š½m‘h½49X½ C–¼Ý/¼¬1¼t¼¼D›¦¼e`B¼‹C–¼¬1¼Ôýô½o½¾w½@ƒ½ixÕ½Oß½©ûç½ÌÌͽó¶F¾bN¾(õþB\¾]/¾vÈ´¾†§ð¾\)¾•¾—P¾— =¾’ñª¾ŒÌ;ƒ•¾q©ü¾Xb¾vɾ@ƒ¾?|î¾:^5¾2-¾'ïž¾Ÿ¾¾ C–½õ½Ôýô½¶E¢½—P½yÛ#½LÌͽ'ïž½+¼Ý/¼´9X¼‹C–¼e`B»å`B¼o¼#× ¼49X¼e`B¼ƒo¼£× ¼¼j¼å`B½+½¾w½8Qì½Y‡½yÛ#½\)½¡ÊÁ½¶E¢½È´9½Ù‡½çl‹½ó¶F½ùÛ#½ûçm½ûçm½õ½ë…½Ý/½ÌÌͽº^5½¥ãT½‘hs½}ó¶½Y‡½49X½P¼ýó¶¼ÌÌͼ¬1¼‹C–¼e`B¼D›¦»Ä›¦»å`B¼t¼¼#× ¼D›¦¼u¼“t¼¼¬1¼ÌÌͼõ½\)½,1½H´9½m‘h½‰7L½²-½´9X½ÊÀƒ½ãSø½ùÛ#¾ 7L¾¾¾w¾'ïž¾-V¾,1¾$Ý/¾“u¾+½éxÕ½Â\½Ÿ¾w½%½På`½'ïž½+¼Ôýô¼¬1¼‹C–¼e`B¼49X»å`B¼o¼#× ¼D›¦¼u¼“t¼¼´9X¼Ý/½+½¾w½D›¦½ixÕ½Oß½§ïž½Ä›¦½å`B¾¸¾P¾,1¾@ƒ¾V¾l‹D¾%¾‹C–¾‘hs¾’n˜¾ŒÌ;€ƒ¾_;d¾:^5¾‡+½ï²½º^5½‘hs½e`B½0 Ž C–¼Ý/¼¬1¼‹C–¼e`B¼o¼#× ¼D›¦¼u¼›¥ã¼¼j¼å`B½\)½0 ŽY‡½…¸½¡ÊÁ½Æ§ð½ñ©ü¾bN¾,1¾JÀƒ¾j~ú¾†$ݾ˜“u¾¬1¾Â\¾Û"Ѿó¶F¿Sø¿§ð¿‰7¾èr°¾Ã•¾œ¬¾q©ü¾7KǾ 7L½ÎÙ½›¥ã½m‘h½49X½ C–¼Ý/¼¬1¼‹C–¼#× ¼D›¦¼u¼›¥ã¼¼j¼í‘h½t¼½8Qì½ixÕ½‘hs½¸Qì½å`B¾\)¾2-¾["Ѿ…¡Ë¾ A‰¾¼j¾Ú¬¾ú^5¿ß;¿&éy¿CSø¿c•¿€ƒ¿‡ÎÙ¿ƒSø¿fff¿9X¿ ƨ¾ÊÀƒ¾bN¾MÒò¾t¼½× =½²-½m‘h½49X½ C–¼Ôýô¼£× ¼D›¦¼u¼“t¼¼¼j¼í‘h½P½@ƒ½u½²-½È´9¾%¾$Ý/¾S÷Ͼ‡®¾­V¾Ø“u¿¸¿;d¿:^5¿WKÇ¿z¬¿•¸¿·®¿åÂÀ "ÑÀMÓÀ—À¿ÀÄœ¿…¡Ë¿1©ü¾éûç¾›¥ã¾S÷Ͼzá½Òñª½™™š½e`B½,1½o¼ÌÌͼe`B¼‹C–¼´9X¼å`B½P½@ƒ½yÛ#½£× ½Ôýô¾ C–¾8Qì¾r°!¾¡G®¾× =¿Ù¿:Ÿ¾¿mV¿£×¿©ûç¿Ã•¿ãoÀ ^5À5OßÀy‰7À¦VÀÃÆ¨ÀÁ`BÀžùÛÀ\ÌÍÀ´9¿¡ÊÁ¿A%¾î{¾™‡¾LÌ; O߽ȴ9½‘hs½Týô½¾w¼õ¼ƒo¼¬1¼Ý/½\)½È´ÀXÀ„“À·|îÁ r°Á4°!ÁVÀ²E¢ÁÙÀù²-À‘&éÀÈ´¿Ÿß;¿4ýô¾Û"ѾŒIº¾{ÁU•Á]®Áw™šÁ§PAŽ CúCúCúCúCúA–ƒÀÚÀƒÀF$Ý¿ÂMÓ¿VÈ´¿%¾¤Z¾Y‡¾zá½ÎÙ½‘hs½Týô¼Ý/½t¼½H´9½‰7L½Àƒ¾ 7L¾F§ð¾å`¾Õ¿¸R¿mÒò¿¶À=qÀ®Àßl‹AH{CÄ~VCúCu#–Bd‹DÁ‚©üÁ„QìÁ†$ÝCѪCúCúCúCúCúC~¸Á|îÀŒ›¦À;d¿“Sø¿.V¾Ù™š¾Oß¾;dZ¾½²-½}ó¶¼ýó¶½,1½q©ü½©ûç½õ¾49X¾‡+¾ÍÒò¿ùÛ¿wP¿Áë…À=qÀ€bNÀç¶FÀÉ`BCúCúCúCúCúCƒý²CúCúCúCúCúCúCúCúBxˆ1ÁKSøÀ½‘hÀ:áH¿Ì‹D¿o²¿n˜¾¸Ôþ¾o²¾¸R½Ù‡½•½t¼½LÌͽ‘hs½Òñª¾¬¾l‹D¾¸Qì¿t¼¿på`¿ÇKÇÀ%OßÀ‰ÒòÀêùÛÁM²-@”1'CúCúCúCúCúCúCúCúCúCúCúCúCúCúB ­Á‚Ÿ¾Á‘hÀ‡¶FÀ/¿«dZ¿K ¾÷KÇ¾šŸ¾¾F§ð¾o½²-½,1½q©ü½° ž J¾E¡Ë¾šŸ¾¾úáH¿R°!¿·l‹À#"ÑÀ‘G®ÀüÔþÁ?ïžÁL9XCYL‹CúCúCúCúCúCúCúCúCúCúCúCúCúCúBLƨÁ‡+ÁK\)ÀÛÎÙÀn‡+ÀdZ¿“33¿)7L¾É7L¾wÎÙ¾¸R½Ðå`½D›¦½Oß½Ðå`¾¸R¾xÔþ¾È´9¿(1'¿“÷ÏÀ´9À‚Ÿ¾ÀøõÃÁC\)BAËÇCì¹ÛCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB5ɺÁ™÷ÏÁBE¢ÀÔ¼jÀ\ÌÍ¿áë…¿n—¿Z¾šŸ¾¾=p¤½ó¶F½]/½£× ½ùÛ#¾B\¾œ(ö¿‰7¿_;d¿Ê^5ÀB~úÀÃ÷ÏÁC/ÁN¬CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB¿Aà—ÀÞ\ÀÁÂÀ5¿« ¿-Òò¾¾ùÛ¾`A‰¾ C–½yÛ#½¾vɾzá¾m‘h¾Å¡Ë¿(õÿ•`BÀ XÀ…G®Áí‘Á†£×@}?}CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC¯¢-ÀÌõÃÀ1'¿ò°!¿_|î¾åãT¾%¾¥ã½Oß½Ù‡¾/ ¾’n˜¾ýó¶¿d“¿ÑÊÁÀC× À»× Á< ÅÁ9XC·´œCúCúCúCúCúCúCúCúCúCúCúCúCúCªÁHCúCúCúCúCúCúCúCúA¡&éÀÈQìÀ"-¿ˆõÿ›¦¾ß;¾(õý™™š½õ¾LÌ;³33¿&$Ý¿ ÄœÀùÛÀš§ðÁçmÁ‰7B. =CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC’¦ÉÀÁ©üÀAG®¿šÀƒ¿bN¾™‡¾2-½¥ãT¾+¾ixÕ¾Øb¿WKÇ¿å¸ÀxQìÀòÐåÁ>¬¿{çmCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÀïžÀDIº¿œÌÍ¿-¾›"Ѿ49X½¬1¾\)¾€¾÷KÇ¿ƒ•À1'À« À©hsBE¢CúCúCúCúCúCúCúCúCúCúCúC«=qCúCúCúCúCúCúCúCúCúCúCúCúCúCO}ÀœQìÀ(bN¿ó¶¿ xÕ¾•¾0 Ž®{¾n˜¾„“¿Ðå¿ß;À-À¼‹D@ÕÒòC÷"-CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCð§ CgðCúCúCš$þ@¬À‹ =¿ýOß¿l1¾ô9X¾Š=q¾&éy½§ïž¾ Iº¾}ó¶¾ùÛ#¿ˆ“uÀ#33À·•¾PCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÀ-`BÀ £×ÀÕ%À­À7¾w¿¶¿=/¾Ñë…¾wÎÙ¾™š½›¥ã¾%¾bMÓ¾Øb¿a‰7¿ÿ;dÀ’È´Án˜B‡9ÛCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBd±'ÁG%Àß÷ÏÀlzá¿úÀƒ¿‡®¿Qì¾²°!¾["Ѿ C–½‹C–½áG®¾>vɾ¬‹D¿'®¿­OßÀ9º^À¿ïžÀ³Æ¨C=¨sCúCúCúCFÕÃC-ŠÁCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú@?}À½ãTÀ9&é¿Á%¿V‡+¾ú^5¾˜b¾?|î½ùÛ#½q©ü½¼j¾™š¾‚\¾éûç¿Z^5¿Ñ%ÀG²À­ó¶Àr°@ýÊÁ¿J~úÁ!XÁh{ÁŠ$ÝÁ–\)ÁÌhsCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB.0!À¨ýôÀV¿žvÉ¿/ß;¾ÐbN¾%¾%ãT½Û"ѽLÌͽ›¥ã½ï²¾@ƒ¾Ÿ;d¿éy¿gl‹¿ÄÝ/À!xÕÀq™šÀž~úÀ¾5?ÀÖÈ´Àø¬Á bNÁgûçÁŸ‡Cz)CúCúCúCúCúCúCúCúCúCúCúCúCúCúAZÀ’n˜Ào¿©ü¿ ž¬‹D¾Z¬¾V½Àƒ½,1½yÛ#½º^5¾ Oß¾Y‡¾©ûç¿Ý/¿LÌÍ¿˜“u¿ÖéyÀ “À*ÀƒÀL1À~¸RÀ­%ÁƒÁI²-Á®C -PCúCúCúCúCúCúCúCúCúCúCúCúB³ó3À½‘hÀ[çm¿Çl‹¿K…¾çl‹¾Oß¾5?}½ñ©ü½¥ãT½\)½H´9½\)½ÎÙ¾P¾^5?¾¡ÊÁ¾èr°¿"MÓ¿Z¬¿ŒÌÍ¿°å`¿ÞùÛÀ©üÀI%À’ñªÀâ°!Á1…ÁqxÕÁ-B_;CËFCúBB¨ö¿ôýôC3ìCúCúChò-CúC/yÀ1À“…À ãT¿Œ(ö¿Qì¾´9X¾bMÓ¾zá½ÊÀƒ½Oß¼í‘h½¾w½]/½›¥ã½Ù‡¾‡+¾Që…¾\)¾Á%¾ýp¤¿#Sø¿Qhs¿‡KÇ¿³t¼¿õ`BÀ-/À{× À»C–Á oÁB ÅÁ(E¢BÓøBD‰7ÁZÁ„å`Ái+¿³¶F¿åÁ0{ÀÈÝ/À®ñªÀŽ5?À ´9¿ª¬¿;¥ã¾Ü(ö¾ˆ´9¾2-½ï²½¥ãT½m‘h¼Ä›¦½o½0 ŽixÕ½²-½Ôýô¾\)¾>vɾyÛ#¾¡ÊÁ¾Ðå`¿ff¿.Ù¿f§ð¿š~ú¿ÑÊÁÀÀGKÇÀŠ$ÝÀ»÷ÏÀë Àé‡Àã× Àý²-Àû¥ãÀþ—ÀübÀæ^5ÀÀƒÀ“ïžÀS À Û#¿¨Qì¿Iûç¾öÈ´¾œ(ö¾LÌ; =q½Àƒ½‰7L½D›¦¼£× ¼Ôýô½ C–½49X½m‘h½›¥ã½ÌÌ;¸¾+ ¾\(ö¾Oß¾µ?}¾éûç¿b¿Féy¿‚ J¿©ûç¿Ý‘hÀ\)À6ffÀ^‡+ÀzŸ¾À€9XÀu‘hÀi&éÀbn˜ÀXå`ÀCçmÀ$ýôÀ°!¿Ão¿‰X¿9X¾õ?}¾¢Ðå¾\(ö¾P½Ôýô½—P½]/½#× ¼ƒo¼¬1¼Ý/½\)½8Qì½ixÕ½•½Àƒ½õ¾¥ã¾E¡Ë¾záH¾ A‰¾ÌIº¿ J¿$›¦¿N—¿€bN¿/¿¼Iº¿Ùº^¿îV¿ôÝ/¿ï²¿æ¿Û¥ã¿Í‘h¿¸Ôþ¿ž5?¿€å`¿H´9¿¾Ù‡¾šŸ¾¾["Ѿ¥ã½ß;d½¡ÊÁ½m‘h½49X½+¼e`B¼‹C–¼´9X¼Ý/½\)½49X½aG®½\)½´9X½áG®¾ Oß¾1&é¾^5?¾ŠÀƒ¾¬‹D¾Ôzá¿%¿^5¿5?}¿P Å¿g®¿wÎÙ¿~5?¿{çm¿s¶F¿gïž¿WP¿B J¿(1'¿ Iº¾áÊÁ¾°£×¾†$ݾIº^¾½ß;d½¥ãT½yÛ#½vÉ¿ŽùÛ¿Ü‹DÀ)&éÀu`BÀ£®ÀÉë…ÀèIºÀÿ¥ãÁn˜Á0“uÁnå`B·LCúCúCúBD[#ÀÐZÀ†{¿ýó¶¿„Z¿“u¾½p¤¾wÎÙ¾'녽§ïž½q©ü½0 ż´9X¼í‘h½¾w½Týô½\)½Æ§ð¾ 7L¾>vɾ†$ݾ¾vÉ¿õÿIxÕ¿™ûç¿ùº^ÀU‘hÀ°(öÀî°!Á{ÁP9XÁE•ÁL1ÁˆMÓÁ«ÎÙÁ}¾wCúCúCúCúCúBŽÐåÀÎÐåÀB~ú¿¾Ù¿S÷Ï¿A‰¾¤Z¾Z¬¾zá½ÎÙ½“t¼½Týô¼Ôýô½ C–½@ƒ½ƒo½¶E¢¾¾5?}¾‚\¾½p¤¿  ¿NÙ¿²-¿ü¬À[çmÀÄýô>™‡CCgLB?¥ãBéxÕC£’ÑCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁpÄœÁaß;Àó À€‹DÀ1'¿“o¿$›¦¾À¾ixÕ¾t¼½%½ÊÀƒ¾%ãT¾ŽÙ¿‰7¿wKÇ¿ô¼jÀtIºÀÔIºÀ.vÉAŽ"ÑBVÐåCU*=BiC–CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCĤþ@Ë\)Á9VÀÄå`ÀFÈ´¿Ó33¿k ¿1'¾£× ¾LÌ;“½e`B½®{¾1'¾`A‰¾¾ùÛ¿(r°¿—ïžÀ ûçÀqë…ÀºÀƒÀôZÁPÁ1 =Áj-Á~—À#oA¸ùÛCúCúCúCúCúCúCúCúCúCúCúCúCúCúB§G+Á|îÀ¥/À!‡¿©xÕ¿>¸R¾áÊÁ¾ŠÀƒ¾1&é½éxÕ½D›¦½\)½Û"Ѿ+ ¾ˆ´9¾ß;d¿8Qì¿—KÇ¿ñÊÁÀ5¸Àw;dÀ›Æ¨ÀÀ1'Àý7LÁ6§ðÁ‚¥ãÁ­Æ¨AN JC££×CúCúCúCúCúCúCúCúCúCúCúCÂmÓA¶Û#Àñó¶Àƒ²¿þ¸R¿†§ð¿™š¾¹X¾ixÕ¾P½ÊÀƒ½#× ½m‘h½®{¾%¾B\¾”ýô¾ã× ¿,Iº¿~5?¿³Sø¿ðÀÐåÀI‡ÀЬÀË"ÑÁÀƒÁl JÁ§Ÿ¾Áy%Ck°¤CúCúCúCúCúCúCúCúCúCŸ™yB#¶FÀéxÕÀ—À>{¿¾5?¿O ¾ò°!¾–¾@ƒ¾½®{½ C–½@ƒ½‰7L½Â\¾ Iº¾Kƨ¾’ñª¾Ñhs¿°!¿Gïž¿„Ý/¿¯;d¿ë À#¶FÀlí‘À¯ =ÁûçÁAPÁŒQìÀ?ÎÙCúCúCúCúBµØ“CúCúCú@&5?Àãt¼ÀùVÀÛÆ¨Àsçm¿ú^5¿†E¢¿¬¾ºáH¾m‘h¾¬½Ôýô½“t¼¼å`B½¥ã½Y‡½•½ÎÙ¾\)¾F§ð¾ˆ1'¾¸Ôþ¾÷KÇ¿$“¿ZŸ¾¿”9X¿Íp¤Àå`ÀM‘hÀ‘Û#ÀÐÝ/ÁxÕÁ?ÎÙB°Ý²CúCúCYU?Á/@ 7LA‘©üÀô¼jÁQ•ÁÂÀÄ(öÀq©üÀ n˜¿œ¬¿6È´¾Þ¸R¾Oß¾:^5½ûçm½®{½u¼ě¦¼ýó¶½,1½e`B½™™š½Ðå`¾ C–¾:^5¾wÎÙ¾¤Z¾Ù‡¿£×¿CSø¿…¸¿¶‡+¿ù‡À(ÔþÀeÀŸ¶FÀà¼jÀçïžA'7LA§ðÀ݉7ÁOßÁ©üÁÒòÀù¡ËÀÀÝ/ÀŠ=qÀ=`B¿÷KÇ¿›¥ã¿B J¾ô¼j¾ž¸R¾Rñª¾\)½È´9½Oß½LÌͼ£× ¼Ôýô½+½49X½m‘h½›¥ã½ÊÀƒ¾¸¾.{¾dZ¾•¾Å¡Ë¿•¿/²¿iº^¿™ûç¿È1'À7LÀ'²ÀZñªÀЏRÀžffÀ¢§ðÀœ“À¬ÀˆbÀzÐåÀW¾wÀ,(öÀ-¿¼í‘¿„Z¿4zá¾ó33¾¤Z¾`A‰¾¥ã½Ý/½²-½e`B½'ïž¼ƒo¼¬1¼Ý/½\)½8Qì½m‘h½—P½Ä›¦½ûçm¾"Ðå¾S÷Ͼ‰º^¾³¶F¾éûç¿KÇ¿A%¿që…¿•`B¿¶‡+¿Ü¬Àë…À“uÀ/ÀÄœÀå`À1'¿éûç¿Ëçm¿¨“u¿…?}¿KC–¿È´¾ÚŸ¾¾œ(ö¾_;d¾¾w½çl‹½§ïž½yÛ#½8Qì½ C–¼e`B¼‹C–¼´9X¼å`B½\)½49X½e`B½“t¼½º^5½í‘h¾P¾A‰7¾wÎÙ¾/¾Æ$ݾõ?}¿?}¿1©ü¿Oß;¿n—¿…`B¿|î¿“•¿‘ÊÁ¿Œ(ö¿ƒ¶F¿på`¿Tzá¿49X¿t¼¾éûç¾µ?}¾‰º^¾MÒò¾™š½å`B½¬1½%½@ƒ½t¼¼å`B¼49X¼e`B¼“t¼¼´9X¼å`B½\)½0 Ž]/½‹C–½®{½Û"Ѿ =q¾,1¾V¾ƒo¾ž¸R¾»çm¾Ù™š¾÷KÇ¿ 7L¿ýô¿í‘¿ ƒ¿;d¿¬¿©ü¿ãT¾ï ¾ÎÙ¾­‘h¾ŽV¾cSø¾333¾ C–½× =½¥ãT½}ó¶½D›¦½P¼í‘h¼¼j¼#× ¼D›¦¼u¼“t¼¼´9X¼Ý/½ C–½,1½På`½ƒo½Ÿ¾w½Æ§ð½ñ©ü¾t¼¾0 žPå`¾q©ü¾‰7L¾˜“u¾¦ff¾±&龸Qì¾»dZ¾¹Û#¾´9X¾« ¾ž5?¾ŽÙ¾záH¾W =¾49X¾zá½ñ©ü½Àƒ½™™š½q©ü½@ƒ½P¼í‘h¼¼j¼“t¼¼o¼#× ¼D›¦¼u¼“t¼¼´9X¼Ôýô½o½¾w½D›¦½m‘h½\)½¬1½ÌÌͽñ©ü¾ Iº¾¾w¾2-¾B\¾På`¾\(ö¾cSø¾fff¾dZ¾]/¾Rñª¾D›¦¾333¾¾w¾ C–½í‘h½È´9½¥ãT½‰7L½]/½49X½t¼¼í‘h¼¼j¼›¥ã¼u»å`B¼o¼#× ¼D›¦¼e`B¼‹C–¼¬1¼ÌÌͼõ½t¼½0 ŽPå`½yÛ#½‘hs½§ïž½Àƒ½× =½í‘h¾¾1'¾V¾n˜¾t¼¾n˜¾V¾+½ýó¶½éxÕ½Òñª½º^5½¡ÊÁ½‹C–½ixÕ½D›¦½#× ½+¼Ý/¼´9X¼“t¼¼u¼D›¦»Ä›¦»å`B¼o¼#× ¼D›¦¼e`B¼‹C–¼£× ¼Ä›¦¼í‘h½ C–½'ïž½D›¦½ixÕ½‡+½›¥ã½²-½ÊÀƒ½áG®½÷ÎÙ¾$ݾbN¾P¾²-¾¾w¾²-¾‡+¾ C–½ùÛ#½× =½¶E¢½—P½u½H´9½#× ½o¼Ôýô¼¬1¼‹C–¼e`B¼49X»å`B¼o¼#× ¼D›¦¼u¼“t¼¼¬1¼Ôýô¼ýó¶½¥ã½vɾ =q½ÌÌͽ—P½e`B½0 Ž+¼Ôýô¼£× ¼49X¼e`B¼‹C–¼´9X¼Ý/½\)½49X½e`B½‘hs½¸Qì½í‘h¾“u¾D›¦¾~ùÛ¾¤Z¾Òn˜¿¡Ë¿&$Ý¿IxÕ¿kƨ¿…?}¿“•¿¤zá¿»¥ã¿×Kǿ쬿녿Î{¿ ¿d“¿dZ¾Ñë…¾ŽÙ¾F§ð¾ Iº½ÊÀƒ½•½aG®½'ïž½o¼Ä›¦¼Týô¼‹C–¼¬1¼Ý/½ C–½49X½e`B½•½Àƒ½ûçm¾%ãT¾["Ѿ‘녾Õ¿× ¿0å`¿k ¿™7L¿Áë…¿éxÕÀjÀÔþÀ!XÀ@ ÅÀo;dÀŒ¼jÀ²Àwß;À2ñª¿ä¼j¿‹…¿+ ¾Øb¾Òò¾A‰7¾+½Â\½Oß½Týô½¾w¼õ¼u¼£× ¼ÌÌͽ+½,1½aG®½•½Ä›¦¾ J¾.{¾j~ú¾Ÿ;d¾Ü¬¿áH¿[çm¿œIº¿Ü(öÀbNÀL(öÀ+ÀÝ/À™º^À§33ÀͲ-Àü¼j¾ ÄœA(¼jÀ„ÔþÀļjÀoKÇÀ1'¿Œ(ö¿#Sø¾ÊÀƒ¾„›¦¾49X½ûçm½´9X½ƒo½D›¦½t¼¼“t¼¼¼j¼õ½#× ½Y‡½\)½Àƒ¾ J¾0 žp£×¾¦éy¾ë ¿)xÕ¿{dZ¿¿;dÀMÓÀ\1À¡VÀÝVÀý‘hÁŸ¾ÁXÁ0-ÁT‹DAž =CúCúCúA²-ÀÕG®Àf5?¿áhs¿rn˜¿Ù¾´¼j¾n—¾#× ½å`B½£× ½m‘h½0 ż¬1¼å`B½P½H´9½‡+½¶E¢½ùÛ#¾-V¾p£×¾¨õþð£×¿/ ¿ƒ÷Ï¿ÐA‰À,1ÀާðÀß®Á$(öÀµ?}BŸŸ;BåA~=qÁˆ£×Á«ë…CØ+…CúCúCúCú@¢ffÀ¹`BÀ,(ö¿®¸R¿Féy¾ô¼j¾ž5?¾S÷Ͼhs½ÌÌͽ‘hs½Týô¼ÌÌͽ+½49X½u½§ïž½éxÕ¾"Ðå¾gl‹¾¥`B¾ï ¿/\)¿ƒ× ¿Î—À,¬À™VÀíÒòÀ˜A‰ÀQ7LCN{CúCúCúBm¶FC]qCúCúCúCúCúBrÅ¢Á…Àuó¶¿ôýô¿‰X¿&$ݾÒñª¾Š=q¾9X½ýó¶½²-½}ó¶¼í‘h½¥ã½Y‡½•½Ðå`¾zá¾Týô¾›"ѾäÝ/¿+ ¿‰7¿È“uÀ!ÊÁÀ‹× Àö¬?áë…CEbCÊêÁCúCúCúCúCúCúCúCúCúCúCúAñ Á3ÎÙÀ©7LÀ+¶F¿Àƒ¿e¡Ë¿V¾µÂ¾m‘h¾¸R½Ù‡½—P½+½8Qì½}ó¶½´9X¾%¾;dZ¾ŠÀƒ¾Ðå`¿|î¿w =¿Â JÀSøÀ€ÀÝOßÁ8“uAå;dCúCúCúCúCúCúCúCúCúCúCúCúCúB‘hÁpÌÍÀóC–À}ÒòÀ Oß¿¤Z¿E¸¾ò°!¾™‡¾F§ð¾“½´9X½¥ã½Týô½—P½Ù‡¾¸R¾l‹D¾´9X¿ ƨ¿]²-¿³t¼ÀƨÀvùÛÀÐr°Á0‹DÁZÀ´ZC½eCúCúCúCúCúCúCúCúCúCúCúCúCkìÁ4—ÁBr°ÀÏKÇÀ_P¿÷ïž¿Œí‘¿$Ý/¾Æ§ð¾wÎÙ¾¾w½Òñª½0 Žu½²-¾ J¾B\¾”zá¾çl‹¿9™š¿™7LÀn˜Àd“ÀÉÊÁÁ-\)Áw÷ÏÁ€²-Á–p¤CZ!CúCúCúCúCúCúCúCúCúCúCúCúCúCšÁ‹1Á8bÀ¿l‹ÀEãT¿Ð¿b\¿%¾™™š¾?|î½õ½D›¦½Oß½ÎÙ¾Ÿ¾¾l‹D¾¸Qì¿¶F¿s÷Ͽщ7À<›¦À±VÁ"A‰ÁbõÃB/gmCõ?}C=ÌCowLCúCúCúCúCúCúCúCúCúCúCúCúCúCúBô 7ÁcÎÙÁ¬À¢éyÀ9X¿›çm¿%ãT¾»çm¾aG®¾ Oß½Y‡½Ÿ¾w½ï²¾7KǾŽÙ¾äÝ/¿;çm¿Ÿ;dÀ p¤À†^5Á°!À õÃCS¥`CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC´ßAR-ÀòéyÀdÌÍ¿Ñ&é¿O²¾ß¾w¾‰7¾¸R½q©ü½²-¾1'¾V¾¬‹D¿V¿oß;¿Ð ÅÀ=OßÀ¹xÕÁçmCVƒTCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCH}qÁ dZÀ™XÀ1¿wP¿A‰¾bN¾-V½%½Ä›¦¾™š¾wÎÙ¾ÎV¿0£×¿š=qÀ ™šÀ}‘hÀö°!Á'²CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC#bÀÑG®À²À|™š¿ C–¾š¬¾7Kǽ‰7L½Òñª¾(õþŒIº¾ñ©ü¿WÎÙ¿ÄýôÀ6vÉÀª-Á‡+Á\C ÷ÏCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCŠ¿ó÷ÏÀ°¬À\¿Œí‘¿Ù¾ž5?¾;dZ½Oß½Ý/¾333¾˜“u¿l‹¿{"Ñ¿ðA‰ÀhbNÀÖvÉÁ!ë…Á6ffAþÛ#CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB¥‰ÀÂÈ´À›¥ãÀ ¬¿…`B¿ ~ú¾›¥ã¾:^5½Oß½ß;d¾6E¢¾œ¬¿ Òò¿†§ðÀÝ/À„A‰ÀÍÂA$¬BOßBž5?BG.Cš· BõšCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC°¾BÉ­Á7®Á33À“PÀ$Ý¿žvÉ¿.پɺ^¾s¶F¾™š½m‘h½²-¾ Iº¾fff¾Ã•¿,1¿›çmÀ;dÀ|îÀËoÁ  ÁMÓÀÚ5?ÁbÙC øCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú@$IºÁ]7LÁQÛ#ÀäIºÀe‘h¿íó¶¿&é¿°!¾®{¾W =¾ =q½På`½›¥ã½í‘h¾:^5¾—P¾ûçm¿T¼j¿´›¦ÀÀj^5À§ÎÙÀàÁ°!Á_/@;ƨCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁÀƒÁ“ƒÁ'ƨÀªùÛÀ.vÉ¿¹º^¿O²¾ò°!¾“t¼¾:^5½ó¶F½49X½ƒo½Â\¾t¼¾dZ¾²°!¿ Oß¿^vÉ¿«dZ¿ýOßÀ1‰7Àqë…ÀªvÉÁbNÁ<¼jAôº^C¬‹C–fCúCúCúCúCúCúCúCúCúCúCúCúÁBÐåÁZ5?ÀíÂÀtzáÀ“u¿‘h¿#•¾Ä›¦¾u¾¸R½Òñª½¥ã½]/½²-½å`B¾)ûç¾}ó¶¾½p¤¿ Iº¿LIº¿‘%¿É7LÀ ƨÀJn˜À¡ËÁ"ÑÁIß;Á§ðÁ´…Á§SøC¾éXCúCúCúCúCúCúCúCúC•ÀÓ|îÁn\Á¡ËÀG®À'|î¿·ïž¿Rñª¾üj¾œ¬¾Iº^¾¸½´9X½o½49X½}ó¶½²-½ýó¶¾6E¢¾‚ J¾¸Q쿉7¿3÷Ï¿yX¿¯|îÀbÀC…À™G®Àí‰7Á.ñªÁt9XÁ+B¹ ÓCúCúCúCúC¨…CúCúCúA r°Áv°!Á9XÀ­ÊÁÀC¶F¿Üí‘¿€ Å¿¬¾¿|î¾vÈ´¾"Ðå½Ý/½™™š¼Ý/½P½LÌͽ‹C–½Àƒ¾¸¾8Qì¾|푾®{¾î—¿$Ý/¿h´9¿¨´9¿úÀƒÀ;¶FÀ‰º^À§ðÁE¢Á;Àñ&éC§æFCúCúCúÁV›¦B¦éB©@‹ Á>¼jÁbNÀ  ÅÀC"Ñ¿ëC–¿ŽV¿/\)¾Ý²-¾\)¾>vɾ J½´9X½}ó¶¼¼j¼õ½#× ½]/½“t¼½Æ§ð¾$ݾ49X¾s¶F¾¥`B¾ãSø¿¸R¿b J¿£33¿ê^5À$“À]ÒòÀ’áHÀÇC–Á°!ÀÅë…BC–BMð¤À¨bNÁC%Á5ÊÁÁ× Áó¶À¾VÀ}ó¶À&ٿٺ^¿Œí‘¿6E¢¾î{¾²-¾Týô¾n˜½ÌÌͽ‘hs½Týô¼›¥ã¼ÌÌͽo½0 Že`B½—P½È´9¾“¾0 žk…¾Ÿ¾w¾Û"Ñ¿Qì¿T¼j¿“o¿ÅãTÀ“uÀ"ÐåÀNVÀ…XÀ¨ƒÀ¾=qÀ¸RÀ½¸À¯oÀ¡hsÀ"ÑÀiÊÁÀ0bN¿ýó¶¿²ñª¿xÔþ¿+…¾ë ¾¡ÊÁ¾`A‰¾²-½ß;d½¡ÊÁ½ixÕ½,1¼ƒo¼¬1¼Ôýô½ C–½49X½ixÕ½—P½Ä›¦¾%¾+ ¾cSø¾˜“u¾ÍÒò¿  ¿9‡¿p Å¿–È´¿·P¿Û¥ãÀ~úÀbNÀ)‡À.VÀ)G®ÀPÀt¼Ào¿Ü‹D¿¯²¿†ff¿H´9¿t¼¾Ö¾š¬¾^5?¾ Äœ½éxÕ½©ûç½}ó¶½vɽýó¶½®{½\)½D›¦½‰7L½Â\¾ C–¾JÀƒ¾–¾âMÓ¿-Òò¿‡®¿×+À,záÀ‹•Àä“uÁ>~úÁ›¦ÁË|îBÅÂCúCúCúCúCúCúCúCúCúCúCúC™boÀÃ÷ÏÁ.IºÀº JÀHQì¿ß|î¿€£×¿Ôþ¾ºáH¾l‹D¾™š½ÌÌͽ¾w½aG®½Ÿ¾w½å`B¾&éy¾xÔþ¾¼í‘¿n˜¿h´9¿½‘hÀ¡ËÀ„IºÀÜÁ2ÌÍÁ?}ÁâÌÍÁÈå`CúCúCúCúCúCúCúCúCúCúCúCúCúCúÁbÁ" JÀ¤záÀ*°!¿·P¿M‘h¾ï²¾‘hs¾7Kǽﲽ49X½}ó¶½¶E¢¾$ݾG®¾˜b¾ë…¿;¥ã¿š^5À÷ÏÀi‰7ÀÎñªÁ-Á…ÙÁ·¶FÁ~´9B˜bCúCúCúCúCúCúCúCúCúCúCúCúCúCúBS\Á{‰7Áå`À‚°!Àn˜¿ˆ´9¿KǾ° žW =¾ 7L½H´9½\)½Ðå`¾¥ã¾l‹D¾·KÇ¿©ü¿m‘h¿ÉÛ#À5/ÀªMÓÁýôÀÒ^5À;× BÌÍCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁÈ´ÁEt¼À¾=qÀ2Ÿ¾¿° Å¿9X¾Ïß;¾vÈ´¾™š½Y‡½²-½ë…¾2-¾ŠÀƒ¾Û¥ã¿2-¿”záÀ‡Ào|îÀä ÅÀW|îC dœCÃNCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú¿%`BÁkº^À÷¥ãÀbáH¿Öff¿YX¾ì‹D¾‰7L¾'ïž½ixÕ½¬1¾ J¾Iº^¾ A‰¿ J¿WÎÙ¿·+À õÃÀ•™šÁ P@‰?}CÄg®CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC{×Áf“uÁ}SøÁ IºÀ‚{¿ò J¿p£×¿Äœ¾“t¼¾2-½u½¶E¢¾ Iº¾^5?¾´9X¿‡+¿€¿ÝÒòÀCçmÀ±ÂÁ"n˜Á25?B”èsCn!CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBúÀƒÁš%Áqó¶Á ¼jÀ†$Ý¿û¥ã¿z^5¿¡Ë¾˜“u¾8Qì½yÛ#½¼j¾n˜¾k…¾Ã•¿&éy¿‘©üÀ&éÀe‘hÀÉ¡ËÁ.(öÁ‰ÂÀôÄœCCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁ·ùÛÁ{®ÁKÇÀ~È´¿ó¶F¿v¿›¦¾˜b¾8Qì½yÛ#½¾vɾzá¾o²¾È´9¿-Òò¿š^5À C–Àx“uÀÑÊÁÁ)çmÁt¼ÁfýôB‚bCG#TCúCúCúCúCúCúCúCúCúCúB}+CúCúCúCúCúCú¾Ä“ÁrÌÍÀõÀhb¿áhs¿g®¾ýp¤¾’ñª¾333½q©ü½¸Qì¾\)¾gl‹¾Á%¿&éy¿”“À¡ËÀlýôÀÂvÉÁ× ÁRjÁ‡•Á—ïžCQV‡CúCúCúCúCúCúCúCúCúCû#CúCúCúCúCúCúCúCA‰üÁDn˜ÀÝÛ#ÀO;d¿Ê=q¿Rñª¾ê~ú¾‰º^¾(õýe`B½¬1¾“¾Rñª¾­‘h¿33¿|î¿àå`ÀBáHÀžÈ´ÀðIºÁ'/ÁjñªÁ¥çmC‹W+CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCüjÁ+¾wÀ¾n˜À1xÕ¿¯ ¿9Û#¾Òn˜¾záH¾¬½På`½›¥ã½ë…¾7KǾ’ñª¾ñ&é¿IxÕ¿©XÀ IºÀ^$ÝÀ¦Àï÷ÏÁ6°!ÁzáC˜HsCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú@0bNÁº^À”bÀ ó¶¿å`¿5?¾·KǾ_;d¾ Oß½éyÀ7l‹À)%À=q¿ìIº¿´›¦¿…¡Ë¿Co¿ Òò¾ÍÒò¾•¾Y‡¾¸R½çl‹½©ûç½}󶽸R¿(1'¿ ƨ¾Ü(ö¾§ïž¾záH¾;dZ¾ C–½Ðå`½Ÿ¾w½q©ü½vÉCúCúCúCúCúAyt¼Á™šÁrbÁD‡+Á"A‰Àÿ÷ÏÀ¡‘hÀ:ñª¿ÝOß¿ˆõÿ0 žèõþ/¾W =¾‡+½Ôýô½—P½]/¼¼j¼õ½#× ½Y‡½“t¼½Æ§ð¾ 7L¾=p¤¾„›¦¾»dZ¿ff¿C× ¿’n˜¿ã33À:=qÀ¦¸RÁ!•A¸+CúCúCúCúCúCúÁ²²-Á”V?–E¢@0ƒÁ®Àï33À‹ß;À$(ö¿È1'¿{dZ¿!G®¾Òñª¾ŒÌ;>vɾo½¸Q콃o¼Ôýô½ C–½5?¿”Z¿ó× À\ZÀãSøÁt›¦B‡t¼CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB ÅÁ|îÀšùÛÀ ¿ˆ“u¿²¾£Sø¾D›¦½ùÛ#½+½vɾOß¾ÚŸ¾¿/ ¿\)¿è“uÀ2ñªÀv{ÀŽ—À‡À{oÀXr°ÀG\)ÀIxÕÀVffÀ]ÀNéyÀ*MÓ¿ü¬¿±‰7¿wKÇ¿.—¾úáH¾·KǾ†§ð¾F§ð¾t¼½Û"ѽ¡ÊÁ½q©ü½8Qì½ C–¼D›¦¼ƒo¼£× ¼ÌÌͽo½,1½aG®½“t¼½È´9¾ C–¾D›¦¾\)¾Ó÷Ï¿vÉ¿hõÿ¤9X¿Õ¡Ë¿÷ =¿úÀƒ¿çl‹¿Ð Å¿ÁÊÁ¿¾{¿¿¾w¿½Òò¿°Äœ¿—ÎÙ¿s¶F¿;"Ñ¿ V¾Ó÷Ͼ A‰¾r°!¾8Qì¾ Iº½Ôýô½¡ÊÁ½yÛ#½{À%¡ËÀ n˜¿Ö‡+¿›Æ¨¿Z^5¿P¾Ó÷Ͼ–¾W =¾¥ã½ãSø½§ïž½yÛ#½ùÛ¾õ?}¾ A‰¾V¾hs½ÊÀƒ½\)¼Ôýô½\)½@ƒ½%½° Žó¶F¾+ ¾q©ü¾­V¾üj¿;"Ñ¿ŽÙ¿ã33À?ïžÀ¬jÁÝ/Á JB ÖCúCúCúCúCúCúÁ¨Á±A‰Á‚^5ÁuhsÁf“uÁ5²-ÁÒòÀ¨“uÀK"Ñ¿íV¿‹dZ¿(r°¾Ñë…¾‡+¾2-½ñ©ü½§ïž¼í‘h½¾w½Y‡½“t¼½ÌÌ;\)¾Kƨ¾’n˜¾Ö¿|î¿s¶F¿ÀƒÀ å`À’‡+Á¸A²Æ¨CúCúCúCúCúCúCúBuxÕB<Ö?aG®A‚p¤¿\)¿Ê¬¾r°!Á*1'Á|îÀ¹OßÀCt¼¿Ï\)¿gïž¿õþ¨õþXb¾V½Àƒ½o½0 Žq©ü½¥ãT½éxÕ¾%ãT¾n—¾®—¿MÓ¿Féy¿œ(ö¿ÿß;À`ÄœÀÚŸ¾Á ‘hCúCúCúCúCúCúCúCúCúCúCúBÕ«…B²©üCúCúCúB©ÀƒÀéÛ#À A‰ÀõÿOß¿/\)¾Ïß;¾%¾%ãT½Ý/½ C–½@ƒ½…¸½º^5¾o¾=p¤¾‰º^¾ÌÌÍ¿dZ¿që…¿ÃoÀ%?}À—¥ãÁ“ÀçKÇCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB>hÀæÈ´ÀVV¿Íp¤¿Z^5¾ú^5¾— =¾>vɽ÷ÎÙ½P½LÌͽ\)½ÊÀƒ¾hs¾Rñª¾›¥ã¾éûç¿3÷Ï¿Ž—¿êáHÀL¬ÀÂáHÁC‘hB²gmCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCf-ÓÁ \)ÀŠ¿þùÛ¿ƒSø¿n˜¾­V¾Týô¾1'½¾w½Y‡½™™š½Û"Ѿ²-¾gl‹¾¬1¿ J¿Iº^¿¡hsÀéyÀpÄœÀìýôÁb—CÙa‰CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCÔ¸1Á-À¥ÒòÀA‰¿™™š¿'+¾Á%¾ixÕ¾t¼½#× ½e`B½Ÿ¾w½å`B¾&éy¾vÈ´¾¸Qì¿ Iº¿Z^5¿¯;dÀ¥ãÀ†5?Á²Á=PCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC2×ÁHÌÍÀÈÝ/À5¿±hs¿:áH¾Òn˜¾yÛ#¾¥ã½'ïž½ixÕ½£× ½ë…¾,1¾~ùÛ¾¿|î¿ë…¿co¿¶ffÀ¬ÀûçÁÈ´@çC–CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÀ,ÌÍÀüÌÍÀ_\)¿Ì1¿MV¾ß¾w¾‚\¾ Äœ½#× ½e`B½£× ½ë…¾,1¾~ùÛ¾À¿-¿co¿¶$ÝÀ¬À+ÁE¢¾ß;CúCúCúCúCúCúCúCúC<ºáCúCúC0"ÑCúCúCúCúCúCúCúCï¬JÀª~úÀ‡dZ¿å?}¿Z¬¾æéy¾„›¦¾ Äœ½¾w½aG®½Ÿ¾w½å`B¾&éy¾vÈ´¾¸Ôþ¿ ‹D¿YÛ#¿®—À9XÀŠéyÁ Á|~úCJXCúCúCúCúCúCúCúCúCñCTCúC1+DCúCúCúCúCúCúCúCúA˜bNÀ’vÉ¿ð Å¿[¥ã¾ã× ¾‰7¾²-½¥ã½Týô½—P½Ù‡¾¬¾fff¾«…¿ÊÁ¿H´9¿ å`À ‰7À‚\Á áHÁ‚7LCL4{CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA7¶FÀ‰G®¿àA‰¿M‘h¾Ö¾s¶F¾zá½\)½H´9½‹C–½Æ§ð¾\)¾Oß;¾™™š¾çl‹¿2-¿;d¿÷ =Àm‘hÁr°Á‰ƒCG+CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBíãTÀÇïžÀYÊÁ¿¹X¿1hs¾½ó¶¾\(ö¾1'½+½8Qì½}ó¶½²-½ýó¶¾7KǾ†$ݾÈ1'¿Û#¿xb¿Ø1'ÀRMÓÀé`BÁ…záB? ÅCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCùýÓ@êÀƒÁ“uÀ¥ÂÀ“¿‹"Ñ¿ ¾ A‰¾?|î½ñ©ü¼õ½#× ½aG®½²-½Ý/¾²-¾dZ¾©xÕ¿ J¿R°!¿¹™šÀ7ÎÙÀÏt¼Áa•BYKÇCúCúCúCúCúCúCúCúCúCúCúCúCúC£×Áž`BÀ` ÅÁ¬ÁoÀ·oÀ:MÓ¿»çm¿E¡Ë¾Ü¬¾‚ J¾!ÊÁ½Ðå`¼Ý/½t¼½H´9½‰7L½¾vɾ¸¾?|î¾Oß¾Øb¿/ß;¿œ¬À—À¶ÀƒÀ_ïžCúCúCúCúCúCúCúCúCúCúCúCúCúCúBŽp¤Á{+Á)¾wÀèå`À—t¼À5p¤¿Ïß;¿lÌÍ¿ º^¾¥`B¾MÒò¾¸½²-¼Ä›¦¼ýó¶½,1½ixÕ½Ÿ¾w½ß;d¾¸R¾hr°¾°£×¿\)¿€ ÅÀoÀ˜1'@ZáHCúCúCúCúCúCúC_‡mCŒ¡‰CúCúCúCúCúCúÀ9XÁ5?À®Ÿ¾Àct¼Àff¿Áë…¿t9X¿“u¾À¾u¾ Äœ½× =½“t¼¼¬1¼Ý/½t¼½H´9½‡+½º^5¾ J¾vɽõ½ C–½333ÁëÒòAš§ðCúCúCúCúCúCúBköÉÁïžÀvvÉ¿Ñ%¿G®¾Ó÷Ͼs¶F¾½ C–½@ƒ½…¸½¼j¾$ݾB\¾\)¾Øb¿'ïž¿‰™š¿ôýôÀvùÛÁ ¸R?ÈÔþCúCúCúCúCúCúCúCú@» Á¨jAÂA1©ü¿çïžCúCúCúCúCúCúCúÀœ¬À‰xÕ¿ÝÒò¿Kƨ¾Ó÷Ͼp£×¾n˜½+½8Qì½}ó¶½´9X½ýó¶¾8Q쾇+¾ËC–¿vÉ¿‚n˜¿éÛ#Àm‘hÁ\)A=ÎÙCúCúCúCúCúCúCúCúC_KDCúCúCúCúCúCúCúCúCúCúCðr À³KÇÀ‚ J¿Ñhs¿@ƒ¾È1'¾dZ¾ C–¼ýó¶½,1½m‘h½¥ãT½ë…¾(õþwÎÙ¾¹Û#¿&é¿o²¿×ïžÀ[t¼ÀüÝ/Á$$ÝCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA¸ó¶ÀꟾÀM¿®—¿'l‹¾²°!¾Oß;¾¼í‘h½¾w½]/½—P½Ôýô¾“u¾^5?¾¥ãT¿‰7¿VÈ´¿Ân˜ÀEÂÀä‹DÁ|‹DC—ñ'CúCúCúCúCúCß‚CúCúCúCúCúCúC‰-/A¤-CúCúCúA]©üÁÀžVÀ Iº¿ƒ¶F¿l‹¾—P¾5?}½å`B¼Ý/½t¼½D›¦½‰7L½¾vɾ$ݾB\¾å`¾âMÓ¿ùÛ¿—ïž¿è1'À å`À<‹DÀ6‡+À‡+¿ä9X¿´“¿Ÿ²¿šáH¿˜r°¿Òò¿r°!¿A‰7¿9X¾àA‰¾ª~ú¾‚\¾Iº^¾¥ã½ñ©ü½º^5½\)½]/½,1½o¼ÌÌͼ#× ¼D›¦¼u¼›¥ã¼Ä›¦¼õ½#× ½Týô½\)½Ä›¦¾ 7L¾C•¾Oß¾ÌIº¿ë…¿Gïž¿}ó¶¿A‰¿ß;¿€£×¿Z^5¿<(ö¿*~ú¿!‰7¿Û#¿V¾úáH¾Òñª¾¬1¾‰º^¾["Ѿ.{¾ =q½Û"ѽ®{½‰7L½Y‡½,1½+¼Ôýô¼£× ¼o¼#× ¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½#× ½Y‡½Oß½¾vɾ¾-V¾ixÕ¾™™š¾Â\¾èõÿĜ¿o¾ùX¾äZ¾ÐbN¾Á‰7¾¶È´¾¬1¾Ÿ;d¾ŽÙ¾xÔþ¾Rñª¾0 žhs½í‘h½Àƒ½²-½}ó¶½LÌͽ#× ½o¼Ôýô¼¬1¼‹C–»å`B¼t¼¼49X¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½#× ½På`½…¸½¬1½Ý/¾ Oß¾0 žS÷Ͼs¶F¾„›¦¾‰7L¾‡+¾‰7¾t¼j¾hr°¾\(ö¾NÙ¾@ƒ¾/ ¾¥ã¾1'½éxսě¦½¥ãT½‰7L½e`B½æffCúCúCúC# ‘ÀbÀúùÛÀ±ó¶ÀŠÙÀeãTÀ? ÀC–¿ò\¿´zá¿€bN¿1&é¾ñ&龤Z¾bMÓ¾²-½Ý/½Ÿ¾w½e`B¼¬1¼Ý/½t¼½@ƒ½%½®{½ë…¾!ÊÁ¾`A‰¾Ÿ;d¾åãT¿*Àƒ¿ƒ33¿ÑÊÁÀ,¼jÀÒòÀÞ5?Á'\)Á*´9C&û#CúCúBûÇ®ÁÙÁ)ë…Á ÅÀÔ“À³ïžÀšÐåÀ‚—ÀO®Àïž¿ÍÒò¿…?}¿*Àƒ¾Ý/¾‘ë…¾D›¦¾+½¼j½…¸¼¼j¼õ½#× ½Y‡½‘hs½Æ§ð¾ 7L¾>vɾ‡+¾Ã•¿hs¿`A‰¿µÀC–ÀŠÀçPÁí‘Á:$ÝÁ‰ÎÙ¿à ÅCt(sCËZ=AÕ`BÁ‚vÉÁ_`BÁMXÁ3¡ËÁ$ÝÁ C–ÀðbÀ¿®ÀŠ$ÝÀ01'¿ÐA‰¿u¿¼j¾ºáH¾r°!¾!ÊÁ½Ý/½™™š¼ÌÌͽ+½49X½q©ü½£× ½áG®¾¬¾^5?¾ A‰¾íV¿5¿’-¿úŸ¾Àg;dÀÝVÁ(bN@'KÇA¯ =Á(5?Áºl‹ÁÀ-?}ÁœbNA*ÌÍB‰ø@¾wÁ„&éÁ„ ÁedZÁhs?‰Û#À‡PÀ‘ÒòÀ#dZ¿¯\)¿Fff¾í‘h¾”zá¾@ƒ¾%½° żÝ/½\)½@ƒ½ƒo½´9X½ûçm¾1&é¾}󶾺^5¿ Oß¿_;d¿»…À*ñªÀ©ó¶Á#OßÀ8ƒCDØÕCúC_ÁËÁýôÁîzáÁÑ~úBlñªCúCúCúC®”9BeiyB…G+CþwCáú B½ôÀžE¢Àq7L¿ñÊÁ¿%¿¶F¾²°!¾aG®¾t¼½Æ§ð¼å`B½¥ã½På`½O߽ě¦¾ =q¾D›¦¾ŽV¾Ôzá¿$Z¿†¿ëdZÀdjÀðA‰ÀÊvÉC¯3CúCúCúCúA‡Û#B¯33CúCúCúCúCúCúCúCúCúCd1'À’\À¢ÀÒò¿¢\¿49X¾Ót¼¾‚ J¾%ãT½Û"Ѽí‘h½¾w½]/½—P½Òñª¾zá¾Týô¾œ(ö¾ì1¿:^5¿œjÀ²À”9XÁ ^5A3ÊÁCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCç›çB,¿}Á'ÂÀÎ~úÀGP¿ÉxÕ¿X“u¾öE¢¾“t¼¾8Qì½í‘h¼õ½'ïž½e`B½²-½Û"Ѿ¥ã¾aG®¾¦éy¾þùÛ¿LÌÍ¿°£×À)XÀ¸bÁ,bNBé¦éCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCà#øÁa7LÁ‚¥ãÁÈ´Àó¶¿ü(ö¿hs¿ Oß¾£× ¾G®½ýó¶¼ýó¶½'ïž½ixÕ½Ÿ¾w½áG®¾ Äœ¾hr°¾­‘h¿ãT¿Z¬¿ÀƒÀ? ÀÖáHÀÀzáCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCZÁ/hsÁ<›¦À³ À ƒ¿™X¿;d¾²-¾S÷Ͼ¸¼ýó¶½'ïž½ixÕ½Ÿ¾w½áG®¾ Äœ¾j~ú¾¯ ¿1'¿`ƒ¿ÉûçÀMÂÀíûçÀðå`CúCúCúCúCúCúCúCúCúAhsÁ4ÀƒÁ£&éB™šCúCúCúCúCúCú¿÷ÎÙÀí²-ÀGÎÙ¿°¿-V¾»dZ¾Z¬¾+¼õ½#× ½aG®½²-½Ý/¾²-¾e`B¾¬‹D¿§ð¿_¾w¿ËçmÀS…ÀõÊÁA>°!CúCúCúCúCúCúCúCúBxýôÁÜVÁÂVÁÐvÉ@‰xÕCúCúCúCúCúCúCMDœÀû¾wÀ`Äœ¿»…¿1©ü¾¼j¾Y‡¾¸¼í‘h½¾w½Y‡½•½Òñª¾‡+¾["Ѿ¤Ý/¿G®¿Xb¿ÆÀN—Àíó¶BdZCúCúCúCúCúCúCúCúÁz~úÁTbNBTÜ)BÍÚ Àå¡ËCΞwCúCúCúCúCúC¬6fÀé?}ÀW ¿²°!¿)7L¾³33¾NÙ½ýó¶¼Ý/½P½LÌͽO߽ě¦¾ Iº¾LÌ;™™š¾ñ&é¿J=q¿¹XÀ?ß;ÀÞÐåÀb JCúCúCúCúCúCúCúAç®Á~ÐåB BCúCúBšÇ+¿¦CúCúCúCúCúAšãTÀÌÀ,Ý/¿—+¿zá¾ Äœ¾vɾ“u½õ½ě¦½²-½yÛ#½H´9½¾w¼ýó¶¼Ä›¦¼›¥ã¼o¼#× ¼D›¦¼u¼“t¼¼¼j¼õ½¥ã½LÌͽ‡+½´9X½ñ©ü¾#× ¾]/¾‘hs¾¸Qì¾Û¥ã¾ò-¾õ?}¾æéy¾ÐbN¾ºáH¾ª~ú¾ž¸R¾“÷Ͼˆ1'¾t¼j¾V¾7KǾ™š¾½Òñª½®{½Oß½ixÕ½áG®Á‘°!Á4(öÀ¹ãTÀ:~ú¿¿|î¿M‘h¾èr°¾Š=q¾,1½ß;d¼Ý/½t¼½D›¦½…¸½º^5¾ J¾;dZ¾Š=q¾Ó÷Ï¿+…¿•¡ËÀA‰À›oÁ'7LÀÄœCx‘ªCúCúCúCúCúCúCúCúCÀã–C¡WÏC¸M/CúCúCúCúAåbÁr=qÁ |îÀ€zá¿òn˜¿s33¿o¾–‡+¾7KǽéxÕ¼Ý/½\)½D›¦½‡+½º^5¾o¾=p¤¾ŒÌ;ٙš¿2°!¿Ÿ ÀÀ° ÅÁ8áHA ¸CúCúCúCúCúCúCúCú@êVÁí‘Á‚¸RCúCúCúCúCúCúBVõÃÁr°À«¶FÀÌÍ¿ŠáH¿—¾ž¸R¾=p¤½í‘h¼Ôýô½\)½@ƒ½ƒo½¶E¢¾%¾;dZ¾‹C–¾Ù™š¿49X¿¢ÐåÀ%/À»ïžÀÍãTCúCúCúCúCúCúCúCúCIŸ¾Áp¤ÁÁÌÍC¯\CúCúCúCúCúCúAžÄœÀĬÀ&V¿“•¿°!¾ A‰¾:^Á‘n˜Áp=qÁJ-ÁVÌÍÁ”?}Bä¸CúCúCúCúCpžÀ†n˜À› =À¬¿t9X¾øÔþ¾ŠÀƒ¾%ãT½Ðå`¼¼j¼õ½#× ½aG®½™™š½Ù‡¾¬¾j~ú¾·ÎÙ¿X¿Š^5À º^À—¶FÁ*bNÀ CúCúCúCúCúA*ffÁ¢dZÁ€¸Á^QìÁSVÁ[çmÁƒbÁG¶FC&!HCúCúBލsÁ ZÀÚ=qÀNéy¿ÀA‰¿?|î¾ÎV¾n—¾n˜½¼j¼¬1¼å`B½P½LÌͽO߽ě¦¾V¾S÷Ͼ¥ãT¿ =q¿yX¿÷ïžÀˆjÁýôÁ‡C­âNCúCúCúCúBÎ&éÁ‚çmÁZ“Á(r°ÁÐåÁQKÇÁQG®ÁO|îÁ:MÓÀÉó¶ÀéÛ#Á+ÀØZÀmÒò¿ö¿€Äœ¿ Ì;¢MÓ¾D›¦½ùÛ#½£× ¼›¥ã¼ÌÌͽ C–½8Qì½}ó¶½° Žûçm¾;dZ¾’n˜¾ó33¿\(ö¿Ý‘hÀy‡ÁIºA?}CúCúCúCúCúBà¼jÁTVÁ05?À&ff?üjÁ‘hÁ&ÄœÁ\)ÀôýôÀÜ(öÀÀÀ”ÀF§ð¿ó33¿ ¿'®¾È´9¾vÈ´¾²-½ÎÙ½Oß¼“t¼¼¼j¼õ½#× ½aG®½›¥ã½Û"Ѿ!ÊÁ¾záH¾Ïß;¿;dZ¿½OßÀW =ÀÖéyB"©üCúCúCúCúCú@(bÁ9t¼Á33À¹ÒòÀûçÀµG®Àû\)ÀÊ JÀ‘‰7À_+À1‰7À¿Â°!¿ƒ33¿*Àƒ¾Û¥ã¾Òò¾9X½÷ÎÙ½©ûç½m‘h¼ƒo¼¬1¼Ý/½\)½D›¦½…¸½¼j¾ 7L¾Që…¾« ¿P¿•?}À$ÌÍÀ³ß;>ŸCdCúCúCúCú¿¶$ÝÁ C–ÀÖ¸RÀÔ›¦À¼A‰ÀªáHÀ°9XÀ„í‘À3•¿þ—¿¾¸R¿ƒ¿U¿‡¾Õ¾’ñª¾Iº^¾ C–½Â\½‰7L½D›¦¼e`B¼“t¼¼Ä›¦¼ýó¶½'ïž½e`B½²-½ãSø¾+ ¾‡®¾çl‹¿XQì¿Ý²-Ào Àâ5?ÀH£×C,ÒoCúCúC¡À¬ýôÀ³|îÀˆ¬ÀŠ\À¾wÀ…ãTÀ^—À¾w¿Ùûç¿™™š¿b\¿+ ¿Äœ¾¾ùÛ¾‹Æ¨¾Iº^¾hs½Ðå`½—P½]/½#× ¼Týô¼ƒo¼¬1¼Ý/½\)½@ƒ½ƒo½º^5¾+¾Oß;¾¨õÿñª¿ˆ“uÀýôÀ€1'ÀÒÙ¿ˆQìBéyB Ø¿7ÎÙÀ¢¬ÀRÐåÀ®À‡À× À J¿ðå`¿³× ¿‰7¿<í‘¿ ‘h¾Øb¾¥`B¾{çm¾>vɾV½Ôýô½²-½ixÕ½0 Ž+¼49X¼e`B¼“t¼¼¼j¼õ½¾w½Y‡½“t¼½Òñª¾¥ã¾o²¾Á%¿"\¿Œ¬¿ó33ÀG|îÀ‹¾wÀ•¡ËÀެÀtIºÀ)Û#¿åãT¿´›¦¿¥¡Ë¿ A‰¿”zá¿|í‘¿Hõÿ^5¾ì1¾¶E¢¾Òò¾]/¾,1¾¸½ÌÌͽ²-½q©ü½8Qì½\)¼Ý/¼#× ¼D›¦¼u¼›¥ã¼ÌÌͽo½0 ŽixÕ½¡ÊÁ½å`B¾&éy¾{çm¾Á‰7¿È´¿h1'¿«¥ã¿çKÇÀffÀŸ¾¿Øb¿¢°!¿wKÇ¿MV¿9X¿-‘h¿|î¿ C–¾èr°¾»çm¾–¾o²¾?|u½ñ©ü½Àƒ½—P½m‘h½8Qì½\)¼å`B¼´9X¼o¼#× ¼Týô¼ƒo¼¬1¼Ôýô½ C–½8Qì½u½§ïž½éxÕ¾$Ý/¾k…¾§ïž¾ë ¿ó¶¿E¸¿]/¿[dZ¿C•¿#× ¿ 7L¾î—¾Ù‡¾È´9¾·ÎÙ¾£Sø¾ŒÌ;l‹D¾C•¾ Äœ¾o½× =½®{½‹C–½aG®½49X½\)¼å`B¼´9X¼“t¼»å`B¼t¼¼49X¼e`B¼‹C–¼´9X¼Ý/½\)½$ÝÀxå`ÀƨÀå`À{¥ãÀEOßÀ7L¿÷KÇ¿ÎÙ¿°A‰¿–ff¿}²-¿P£×¿%ãT¾þùÛ¾¾vɾ‹Æ¨¾Kƨ¾zá½Ù‡½Ÿ¾w½m‘h½0 żƒo¼¬1¼Ý/½\)½8Qì½q©ü½¡ÊÁ½× =¾hs¾G®¾ŠÀƒ¾Ã•¿ ƨ¿IxÕ¿å`¿ÌIºÀ 33À7 ÀkSøÀ‘ãTÀ¥p¤À¦§ðÀ•‘hÀ{oÀR-À2ÀƒÀõÃÀ"Ñ¿àÄœ¿¾vÉ¿œIº¿týô¿7KÇ¿Z¾»dZ¾„“¾:^5¾“½¾vɽ‹C–½LÌͼ“t¼¼¼j¼õ½¾w½På`½‰7L½¸Qì½ùÛ#¾,1¾p£×¾«…¾ùX¿9‡¿‹C–¿ÐÄœÀPÀNE¢ÀG®À—l‹Àª$ÝÀ·+À¹ó¶À³× Àª^5ÀžùÛÀoÀv¸RÀP“uÀ1&éÀó¶¿ô¼j¿»¥ã¿‡ =¿:^5¾üj¾« ¾ixÕ¾!ÊÁ½ãSø½¡ÊÁ½ixÕ¼›¥ã¼ÌÌͽo½,1½e`B½™™š½Ðå`¾\)¾H´9¾ß;¾Òn˜¿¸R¿vE¢¿ÃoÀ°!Àk× À¤(öÀÉ©üÀÜ›¦ÀàA‰ÀàbÀåó¶ÀõûçÁbNÁ =ÀûKÇÀ× À°A‰À‘¡ËÀsdZÀC× Àº^¿ÈQ쿃33¿)xÕ¾Ü(ö¾‘hs¾C•¾¸½º^5½ƒo¼£× ¼Ý/½\)½—À«¾wÁ9XÁ"ÌÍÀ´(ö=q©ü@œjÁMOßÁk@]VB=¢ÑB!B‘þúAúí‘ÁÙÁ;²-Áp¤ÀíÛ#À£çmÀNff¿÷KÇ¿’Ðå¿0£×¾Ù™š¾‰º^¾333½ï²½£× ¼´9X¼í‘h½¾w½Týô½\)½Ä›¦¾ =q¾E¡Ë¾‘hs¾Þ5?¿2-¿— =À ÅÀ€ÄœÀót¼ÁK|îÁN9XAzÙCúCúBòÖ¿Ïß;B®‡®C¿ÑìCP†fC©HCâÑÀi7LÁ2éyÁGº^Á8ZÀùhsÀ”¬À)™š¿ÀbN¿]ó¶¿Sø¾ Äœ¾Kƨ¾¸½²-¼¼j¼õ½#× ½]/½•½ÎÙ¾n˜¾Rñª¾²-¾öE¢¿JÀƒ¿²n˜À(ƒÀ§C–Á#;dÁ…ƨÁBMÓB´5?CúCúCúCúBá0¤Ck…ãB؃BôÉ7B‡BCµË#CúC¸pƒ@På`ÁAÎÙÀæÀs•ÀÄœ¿‹¥ã¿p¤¾¸Ôþ¾cSø¾bN½¾vɼ¼j¼ýó¶½'ïž½aG®½™™š½Ôýô¾P¾]/¾§l‹¿›¦¿`¿ËƨÀH£×ÀÏ®ÁN$ÝÁ}ƨCˆìJCúCúCúCúCúCú@ì(öÀî\Á;dC°…ãCúCúCúCúÀŒ1Á3XÀ´å`À.E¢¿®V¿8Ôþ¾Ïß;¾vÈ´¾™š½È´9¼¼j¼ýó¶½'ïž½aG®½™™š½× =¾™š¾bMÓ¾¬‹D¿ Àƒ¿o ¿à ÅÀe/Àô´9Á`9XA {CúCúCúCúCúCúCúÁ%VÁpŸ¾ÁbCúCúCúCúCúC3Û¦Á=ƨÀü¼jÀc…¿Ñ‰7¿På`¾áG®¾‚ J¾¾w½ÌÌͼ¼j¼õ½#× ½]/½—P½Ôýô¾“u¾aG®¾­‘h¿ ÌÍ¿vE¢¿ëdZÀw¾wÁÎÙÀm¡ËCF¨CúCúCúCúCúCúB¯ÁLÁ;‘hÁ&IºCúCúCúCúCúCúA‹jÁ p¤À„›¦¿ç+¿\¬¾çl‹¾ƒ•¾¾w½ÊÀƒ¼´9X¼í‘h½¾w½Y‡½“t¼½ÎÙ¾zá¾["Ѿ©xÕ¿ ~ú¿s33¿éûçÀwÎÙÀü¼j@²¸RC[TþCúCúCúCúCúCÒaHÁ>ZÁ,È´ÁÊÁÁ?VAŸ¸RCúCúCúCúCúBI49Á¬À‚V¿àå`¿U?}¾Þ¸R¾|푾™š½Â\¼¬1¼å`B½P½LÌͽO߽ě¦¾ Oß¾På`¾¡G®¿× ¿g+¿Ü(öÀdÌÍÀñOßÁoAýÐåCvɾwÎÙ¾ Äœ¾Ðå`¿®¿.—¿\(ö¿„Z¿’°!¿“33¿†§ð¿h1'¿C•¿%`B¿ Oß¾ó33¾Ñhs¾²-¾•¾vÈ´¾H´9¾ Äœ½ý󶽯§ð½™™š½q©ü½8Qì½\)¼å`B¼D›¦¼u¼›¥ã¼Ä›¦¼õ½¥ã½H´9½%½¥ãT½× =¾ Oß¾9X¾s¶F¾ Äœ¾Ót¼¿ Àƒ¿4¼j¿iº^¿”zá¿´Z¿É™š¿Ê¬¿·®¿œÌÍ¿ƒ•¿^vÉ¿>¸R¿$›¦¿ Òò¾ñ©ü¾Ê=q¾¥ãT¾…¸¾Që…¾"Ðå½ùÛ#½¾vɽ‘hs½]/½,1½o¼Týô¼‹C–¼¬1¼Ý/½ C–½49X½ixÕ½—P½Ä›¦¾ J¾-V¾hr°¾œ(ö¾Ñë…¿ 1¿8Ôþ¿p Å¿™7L¿¿|î¿å¿ÿ¾wÀ“u¿ëƨ¿Ì‹D¿®ùÛ¿–§ð¿‚°!¿co¿DZ¿'l‹¿ ƨ¾ãSø¾³¶F¾ŠÀƒ¾Që…¾²-½ë…½° Ž…¸½H´9½P¼e`B¼“t¼¼¼j¼õ½¥ã½LÌͽ…¸½° ŽéxÕ¾¬¾Týô¾‘녾ȴ9¿ ~ú¿<¬¿{¥ã¿¢MÓ¿ÉÛ#¿òn˜À 1À£×ÀMÓÀÊÁÀzá¿í‘h¿ÓSø¿º¬¿¢-¿Œ(ö¿nÙ¿Fff¿;d¾öÈ´¾¹Û#¾‰7L¾H´9¾n˜½Ôýô½²-½ixÕ½,1¼ƒo¼£× ¼ÌÌͽ+½0 Že`B½—P½ÊÀƒ¾ 7L¾;dZ¾‚ J¾¶È´¿ J¿8Ôþ¿ë…¿±%¿äÝ/À  À;dÀ.5?À7|îÀ:\À8å`À4IºÀ,1ÀVÀ Iº¿òn˜¿Ï|²¿£×¿d“¿,Iº¾ûdZ¾³¶F¾~ùÛ¾5?}¾%½º^5½‡+½D›¦¼‹C–¼¬1¼å`B½t¼½@ƒ½}󶽩ûç½çl‹¾¸R¾]/¾²-¾äÝ/¿(r°¿y™š¿¶È´À‡À*\ÀN—Àe?}Àn‡+ÀpÔþÀtÌÍÀKÇÀ…Û#À‡oÀ~vÉÀ_®À<ÌÍÀffÀZ¿Ö§ð¿¥¿që…¿*=q¾ë ¾¡G®¾^5?¾Ÿ¾½Ù‡½›¥ã½aG®¼“t¼¼¼j¼õ½¾w½På`½‹C–½¼j¾ J¾5?}¾‰7¾½p¤¿ Òò¿YX¿¨´9À JÀA%À„í‘À¥/À¸“ÀºáHÀ´£×À²ÙÀ½ó¶ÀÏC–À×ÎÙÀÌÌÍÀ²ÙÀ”ýôÀv‡+ÀK•À!ÊÁ¿ñÊÁ¿ª=q¿fff¿‡¾ÊÀƒ¾‡®¾7Kǽûçm½° ŽyÛ#¼›¥ã¼Ä›¦¼ýó¶½'ïž½aG®½—P½ÎÙ¾bN¾LÌ;”ýô¾ß¾w¿-‘h¿ŠÀƒ¿áë…À7²À× ÀЃÁ²-Á÷ÏÁXÁñªÁ ‰7Á ¶FÁ“uÁ\)Á -Àÿl‹ÀäÔþÀŸÀ¤bÀ}ó¶À4í‘¿ò-¿œIº¿G+¾ý󶾤Z¾Xb¾bN½Æ§ð½‹C–¼›¥ã¼ÌÌͽ+½49X½m‘h½¡ÊÁ½ß;d¾¬¾bMÓ¾¨r°¿ÊÁ¿PbN¿­OßÀçmÀ|¬ÀÐ ÅÁýôÁS©üÁ' =?Œí‘À—C–Á;OßÁ2È´ÁýôÁ&QìÁ=qÁ!©üÁ²ÁÊÁÁ ÀÖ-ÀÝ/À3•¿Ø´9¿‚n˜¿¸R¾Å¸¾záH¾#× ½Û"ѽ•¼£× ¼Ôýô½ C–½8Qì½yÛ#½©ûç½ë…¾'ïž¾u¾º^5¿33¿st¼¿Ò\À;¥ãÀ§¶FÁZÁ`ÌÍÁt°!C }qCúCúB \Á2MÓÁ2bNÁ2ÙÁ8¼jÁçmB9ýôC'îÙB\üîÀÌ ÅÀó•À%À"Ñ¿¬ÌÍ¿EãT¾éûç¾\)¾6E¢½í‘h½¡ÊÁ¼£× ¼Ôýô½\)½bB±G+CúCúCúCúC®.w?çKÇÁA‰Á;dÁÄœCqnVCúCúCúCúA$ñªÁ©üÀ™G®Àl‹¿ŽV¿P¾¬‹D¾Oß;¾o½¬1¼£× ¼Ôýô½ C–½]/ÀµãTÀ!º^¿–éy¿¬¾« ¾Iº^½ûçm½¥ãT¼›¥ã¼Ä›¦½o½0 Žm‘h½£× ½çl‹¾(õþ€¾Ê=q¿(r°¿”ýôÀ 33À…ûçÀøbÁHÌÍÁƒ=qÁ…Oß@È‹DCøB89XÀøQìÀå‘hÀ¦5?À›l‹ÀÇ+Á33AýŸ¾CúCúCúCÂ]/ÀKÇÀ”í‘À¾w¿‚Ðå¿ 7L¾šŸ¾¾9X½ë…½›¥ã¼“t¼¼¼j¼õ½#× ½]/½™™š½Ù‡¾¸R¾n—¾¼j¿(ö¿ˆr°¿ùÛ#Àj^5ÀÖÀƒÁ2ÙÁnõÃÁIÁAÛ#ÁO²Á(QìÀöÀƒÀªñªÀ†ÙÀ€“uÀ”£×ÀÐA‰À˾wB‡)yCÏk…ChÖFA1ïžÀ·;dÀIÊÁ¿Å¿L‹D¾áÊÁ¾„“¾"Ðå½Òñª½Oß¼‹C–¼´9X¼å`B½P½LÌͽO߽ȴ9¾hs¾Z¬¾«…¿ Oß¿týô¿ÝÒòÀMÀ»+ÁOßÁp¤AØ“AçA‰Àú^5Á +À»dZÀ†¬ÀaXÀXA‰Àc÷ÏÀ†VÀ­²-À¼¼jÀx´9À’E¢À£t¼ÀWP¿îùÛ¿ƒo¿zᾯ ¾W =¾ =q½¶E¢½yÛ#¼u¼£× ¼Ôýô½ C–½5?¿St¼¿På`¿9Û#¿áH¾ÿ|î¾Ù™š¾Àƒ¾¯ ¾Ÿ¾w¾ŽÙ¾záH¾Xb¾7KǾŸ¾¾%½Ôýô½®{½Oß½e`B½8Qì½t¼¼å`B¼¼j¼“t¼»å`B¼t¼¼49X¼e`B¼‹C–¼´9X¼å`B½t¼½@ƒ½}󶽩ûç½å`B¾¥ã¾På`¾ˆ´9¾¬1¾ËC–¾Ý²-¾Þ5?¾ÎV¾¶È´¾Ÿ;d¾ŒÌ;}ó¶¾hr°¾S÷Ͼ?|î¾)ûç¾zá¾½Ù‡½¸Qì½™™š½%½Týô½,1½\)¼å`B¼¼j¼“t¼¼u»ě¦¼o¼t¼¼D›¦¼e`B¼“t¼¼´9X¼å`B½t¼½@ƒ½yÛ#½¡ÊÁ½Ðå`¾¸¾%ãT¾H´9¾e`B¾wÎÙ¾záH¾p£×¾^5?¾JÀƒ¾8Qì¾(õþ¥ã¾\)¾ J½éxÕ½ÎÙ½´9X½›¥ã½…¸½e`B½@ƒ½¾w½+¼Ý/¼´9X¼“t¼¼u¼D›¦»Ä›¦»å`B¼o¼#× ¼D›¦¼u¼“t¼¼¼j¼å`B½\)½49X½e`B½Oß½®{½Òñª½õ¾ 7L¾t¼¾‡+¾t¼¾ Oß¾“½õ½å`B½Ôýô½Æ§ð½´9X½£× ½“t¼½%½e`B½D›¦½,1½\)¼õ¼ÌÌͼ¬1¼“t¼¼u¼D›¦¼#× »£× »Ä›¦»å`B¼o¼#× ¼D›¦¼u¼“t¼¼´9X¼Ý/½+½#× ½D›¦½m‘h½‹C–½²-½®{½¸Qì½¾vɽ¾vɽ¸Qì½²-½§ïž½Ÿ¾w½•½‹C–½%½ixÕ½Týô½5?¿MOß¿O\)¿E`B¿3÷Ï¿ ƒ¿V¾ûçm¾Ý²-¾Â J¾§ïž¾ŽÙ¾n—¾C•¾²-½ùÛ#½Ä›¦½™™š½m‘h½8Qì½\)¼Ý/¼D›¦¼u¼“t¼¼¼j¼í‘h½P½@ƒ½u½Ÿ¾w½ÎÙ¾$ݾ/ ¾dZ¾”zá¾¾ùÛ¾ñ©ü¿¿5?}¿Týô¿på`¿hs¿‚ñª¿{"Ñ¿g®¿Që…¿vÉÀCdZÀD›¦À<›¦À,“ÀQìÀÌÍ¿â J¿¸1'¿Ž—¿R°!¿‡+¾Òñª¾’n˜¾Kƨ¾V½ÊÀƒ½‘hs½På`¼ƒo¼¬1¼Ý/½\)½´¼jÀÆ~úÀJ=q¿Ãt¼¿Iº^¾ß¾w¾ƒ•¾"Ðå½Òñª½Oß¼‹C–¼´9X¼å`B½¥ã½LÌͽO߽ě¦¾ Iº¾MÒò¾œ¬¾øQì¿LIº¿®5?À À€õÃÀÏ\)ÁÒòÁ<¼jÁ9©üÀŸ¾ÀêE¢ÀöéyÀª~úÀt“ÀfvÉÀœzáÀúŸ¾ÀÙC?ß;CúCÓ5?A™hsÀ¸r°ÀJ-¿Àå`¿E¸¾Ù‡¾~ùÛ¾²-½ÌÌͽ‰7L¼ƒo¼¬1¼Ý/½t¼½D›¦½‡+½¼j¾$ݾE¡Ë¾–‡+¾î{¿Co¿¤›¦À záÀjn˜À·+ÁÝ/Á33Á%º^Á ´9Àë;dÀ·PÀ€9XÀC…À:ñªÀn$ÝÀ½xÕÀæ{BV@ƒCÉÁ‰C ú@‘?}Àž°!À)7L¿¦E¢¿.V¾Ã•¾ixÕ¾n˜½¾vɽ%¼ƒo¼£× ¼Ôýô½ C–½vɾ.{¾¾w¾hs¾ J½çl‹½ÊÀƒ½° Ž—P½%½Y‡½49X½P¼õ¼ÌÌͼ£× ¼ƒo¼Týô»Ä›¦»å`B¼t¼¼#× ¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½#× ½På`½…¸½§ïž½Ðå`½ýó¶¾¾(õþ49X¾7KǾ2-¾'ïž¾¥ã¾\)¾“½ó¶F½áG®½ÌÌͽº^5½¥ãT½“t¼½%½aG®½@ƒ½#× ½ C–¼å`B¼Ä›¦¼£× ¼ƒo¼e`B¼49X»£× »Ä›¦»å`B¼t¼¼49X¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½¥ã½@ƒ½ixÕ½Oß½§ïž½Àƒ½× =½å`B½éxÕ½çl‹½ß;d½Òñª½Æ§ð½¸Q콬1½Ÿ¾w½“t¼½‡+½q©ü½Y‡½@ƒ½'ïž½t¼¼ýó¶¼Ôýô¼´9X¼›¥ã¼ƒo¼Týô¼49X¼t¼»ƒo»£× »Ä›¦¼o¼t¼¼49X¼Týô¼ƒo¼›¥ã¼Ä›¦¼í‘h½ C–½'ïž½D›¦½e`B½%½Oß½•½™™š½™™š½—P½‘hs½‹C–½ƒo½u½e`B½Týô½D›¦½49X½¾w½\)¼ýó¶¼Ý/¼Ä›¦¼¬1¼“t¼¼u¼Týô¼49X¼t¼¼o»D›¦»ƒo»ƒo»£× »£× »Ä›¦»å`B¼o¼t¼¼49X¼D›¦¼e`B¼u¼‹C–¼›¥ã¼¬1¼¼j¼ÌÌͼÝ/¼å`B¼í‘h¼í‘h¼í‘h¼í‘h¼å`B¼Ý/¼Ôýô¼Ä›¦¼¼j¼¬1¼›¥ã¼‹C–¼ƒo¼e`B¼D›¦¼49X¼t¼¼o»å`B»Ä›¦»£× »D›¦»ƒo»£× »£× »Ä›¦»å`B¼o¼#× ¼49X¼Týô¼u¼‹C–¼›¥ã¼´9X¼Ä›¦¼Ý/¼õ½o½ C–½t¼½¥ã½¥ã½¥ã½¥ã½P½\)½+¼ýó¶¼í‘h¼Ôýô¼Ä›¦¼´9X¼›¥ã¼‹C–¼u¼Týô¼49X¼#× ¼o»å`B»Ä›¦»ƒo»£× »£× »Ä›¦»å`B¼o¼#× ¼D›¦¼Týô¼ƒo¼“t¼¼¬1¼Ä›¦¼Ý/¼ýó¶½ C–½¥ã½,1½8Qì½D›¦½H´9½LÌͽLÌͽLÌͽD›¦½vɾ/ ¾¸R¾V½ýó¶½áG®½Ä›¦½©û网hs½u½LÌͽ'ïž½ C–¼å`B¼¼j¼›¥ã¼u¼o¼t¼¼49X¼e`B¼‹C–¼¬1¼ÌÌͼýó¶½¥ã½@ƒ½m‘h½‘hs½²-½Ù‡¾o¾²-¾:^5¾Y‡¾u¾‡+¾ŽÙ¾å`¾Oß¾…¡Ë¾wÎÙ¾bMÓ¾LÌ;7KǾ"Ðå¾\)½÷ÎÙ½Ôýô½´9X½—P½yÛ#½LÌͽ'ïž½+¼Ý/¼´9X¼“t¼¼t¼¼#× ¼Týô¼ƒo¼›¥ã¼Ä›¦¼í‘h½P½8Qì½e`B½\)½²-½Ý/¾1'¾%ãT¾H´9¾n—¾‹Æ¨¾Ÿ;d¾¯²¾¹Û#¾¼j¾·ÎÙ¾­V¾Ÿ¾w¾‘hs¾ƒ•¾k…¾På`¾7KǾ¸R¾+½ãSø½¼j½›¥ã½yÛ#½LÌͽ#× ½o¼ÌÌͼ£× ¼t¼¼D›¦¼e`B¼“t¼¼´9X¼Ý/½ C–½,1½Y‡½‰7L½¬1½Ù‡¾1'¾)ûç¾På`¾}󶾘b¾²-¾ÊÀƒ¾ß¾w¾íV¾ð£×¾ê~ú¾Ý²-¾ÌÌ;»dZ¾©xÕ¾˜b¾†§ð¾l‹D¾Kƨ¾-V¾bN½í‘h½Àƒ½™™š½u½@ƒ½P¼õ¼¼j¼#× ¼Týô¼ƒo¼£× ¼Ä›¦¼ýó¶½¾w½H´9½}󶽡ÊÁ½ÎÙ¾“¾'ïž¾S÷Ͼ„“¾¡ÊÁ¾Â J¾âMÓ¿A‰¿ ‹D¿zá¿È´¿¶F¿ ‹D¿Sø¾ñ©ü¾Ü(ö¾Æ$ݾ° žš¬¾„“¾_;d¾8Qì¾½í‘h½¼j½“t¼½e`B½49X½ C–¼Ý/¼49X¼e`B¼‹C–¼´9X¼Ý/½ C–½49X½e`B½“t¼½¾vɽ÷ÎÙ¾ Äœ¾Oß;¾…¸¾§ïž¾Ïß;¾ùX¿å`¿"Ðå¿0£×¿9‡¿;çm¿9X¿2ñª¿)º^¿5?¿å`¿Ðå¾èr°¾ËC–¾­‘h¾‘hs¾m‘h¾=p¤¾zá½çl‹½²-½‰7L½På`½¾w¼õ¼D›¦¼u¼›¥ã¼Ä›¦¼õ½¥ã½H´9½ƒo½©ûç½ß;d¾t¼¾B\¾€ƒ¾§ïž¾×P¿éy¿#o¿=p¤¿Rñª¿aÊÁ¿j=q¿lÌÍ¿k…¿féy¿^vÉ¿Që…¿B J¿/²¿(ö¿1'¾çl‹¾¿|¬¾q©ü¾:^5¾ Oß½Ôýô½¡ÊÁ½q©ü½8Qì½ C–¼Týô¼ƒo¼£× ¼Ôýô½+½,1½aG®½“t¼½Â\¾ J¾.{¾j~ú¾ž5?¾Ó÷Ï¿ …¿2-¿Z^5¿;d¿²-¿–$Ý¿™X¿™™š¿˜õÿ—l‹¿“× ¿/¿ƒSø¿o ¿U?}¿9Û#¿í‘¿¾Éº^¾šŸ¾¾hr°¾-V¾½¼j½‹C–½På`½¥ã¼Týô¼‹C–¼´9X¼å`B½\)½vɾOß¾Õ¿" J¿t¼j¿³•¿ùûçÀ A‰À7ïžÀ9ë…À&ÙÀ hs¿ÚÀƒ¿±©ü¿š=q¿“33¿œ¬¿¸´9¿çïžÀVÀáHÀ `B¿Ø“u¿’ J¿9X¾èr°¾“÷Ͼ@ƒ¾½° Žu½0 żD›¦¼u¼›¥ã¼ÌÌͽ+½49X½u½§ïž½í‘h¾+ ¾{çm¾¼j¿V¿Týô¿› ¿Ö$ÝÀ1'ÀŸ¾ÀÛ#ÀP¿Ü‹D¿¯²¿A‰¿|(ö¿mV¿n—¿|—¿Òò¿¢°!¿”Ý/¿pbN¿0 žó¶F¾¥`B¾_;d¾“u½Òñª½“t¼½Týô½¥ã¼49X¼e`B¼“t¼¼¼j¼õ½#× ½]/½•½Òñª¾‡+¾["Ѿ¢MÓ¾ò-¿3t¼¿hs¿°Äœ¿Þ5?¿ùX¿ö¿×ÎÙ¿¯²¿Œ‹D¿h´9¿Kƨ¿<í‘¿6È´¿6‡+¿9Û#¿vɾvɾ(õþt¼½ýó¶½× =½´9X½“t¼½q©ü½D›¦½¥ã¼ýó¶¼ÌÌͼ£× ¼t¼¼49X¼e`B¼‹C–¼¬1¼Ôýô½o½#× ½LÌͽ}󶽟¾w½È´9½÷ÎÙ¾“u¾9X¾]/¾%¾’ñª¾£Sø¾° ž¸Q쾺áH¾¸Ôþ¾³33¾©û羟;d¾“t¼¾†$ݾq©ü¾V¾:^5¾¾w¾$ݽÝ/½´9X½‘hs½ixÕ½8Qì½t¼¼å`B¼´9X¼#× ¼D›¦¼u¼“t¼¼¼j¼í‘h½t¼½8Qì½ixÕ½•½¼j½ï²¾‡+¾;dZ¾fff¾Š=q¾¢MÓ¾¸Ôþ¾ÌIº¾Û"Ѿã× ¾çl‹¾åãT¾ß¾w¾Ö¾Ê=q¾»çm¾«…¾šŸ¾¾ˆ´9¾m‘h¾Iº^¾'ïž¾ 7L½Ý/½° މ7L½Y‡½'ïž½o¼ÌÌͼ#× ¼Týô¼ƒo¼£× ¼ÌÌͽo½#× ½På`½…¸½¬1½Ý/¾V¾6E¢¾fff¾ß;¾®—¾ÎV¾ë ¿‰7¿ ûç¿—¿ Å¿ ¿ Iº¿l‹¿Äœ¾ð£×¾Ý²-¾È1'¾±&é¾™‡¾%¾Týô¾+ ¾+½Òñª½£× ½}ó¶½D›¦½P¼å`B¼49X¼e`B¼‹C–¼´9X¼Ý/½\)½49X½ixÕ½—P½Ä›¦¾%¾(õþ\(ö¾Òò¾³¶F¾Ý²-¿›¦¿b¿'®¿1hs¿5¿6¿3÷Ï¿0bN¿+C–¿$Z¿"Ñ¿ß;¿o¾èr°¾È1'¾¦éy¾‡+¾V¾%ãT½ýó¶½Àƒ½“t¼½]/½'ïž½o¼D›¦¼u¼“t¼¼¼j¼í‘h½¥ã½H´9½%½©ûç½áG®¾zá¾F§ð¾ƒ•¾­‘h¾àÄœ¿ ‘h¿,1¿H1'¿]ó¶¿iûç¿l‹D¿h´9¿b\¿\j¿VÈ´¿Oß;¿Gl‹¿<¬¿.V¿çm¿¡Ë¾Ü(ö¾®—¾†§ð¾Kƨ¾“u½ãSø½©ûç½}ó¶½vɾƒo¾µÂ¾ú^5¿)º^¿`Äœ¿|î¿®ùÛ¿È´9¿Õ¸¿Ð Å¿¿ ¿¬j¿Ÿ;d¿™Û#¿›dZ¿¢n˜¿ª=q¿ª~ú¿V¿ƒ× ¿MV¿P¾Ù™š¾š¬¾Y‡¾“u½Ù‡½›¥ã½e`B½'ïž¼Týô¼ƒo¼¬1¼Ôýô½ C–½8Qì½q©ü½¡ÊÁ½Û"Ѿ‡+¾På`¾’ñª¾ÎÙ¿hs¿IxÕ¿ˆ“u¿²°!¿ÞùÛÀ=qÀ ñªÀp¤¿ë"Ñ¿ÉxÕ¿³o¿¬1¿µ¸¿ÌÌÍ¿éº^¿÷ïž¿è1'¿¿|î¿;d¿Iº^¿ û羺áH¾}ó¶¾.{½ñ©ü½©ûç½u½0 żTýô¼ƒo¼¬1¼Ý/½\)½5?¿7 =¿?;d¿V‡+¿z¬¿ŽvÉ¿”¼j¿ˆr°¿[¥ã¿ ƒ¾Ý²-¾–¾JÀƒ¾ C–½Â\½‰7L½D›¦½\)¼49X¼Týô¼‹C–¼¬1¼å`B½t¼½D›¦½…¸½¶E¢½ûçm¾1&é¾záH¾°£×¾õ¿&$Ý¿V¿€Äœ¿Ž—¿ Å¿†¿kC–¿Iº^¿.Ù¿/¿ýô¿?}¿í‘¿)7L¿3÷Ï¿4ýô¿&$Ý¿ Àƒ¾Ö¾/¾`A‰¾¸R½áG®½¡ÊÁ½ixÕ½,1¼ýó¶¼#× ¼D›¦¼u¼£× ¼ÌÌͽ+½49X½m‘h½¡ÊÁ½ß;d¾¥ã¾Y‡¾˜b¾Ñhs¿ 1¿2n˜¿Týô¿iº^¿j~ú¿YX¿>¸R¿$“¿Ù¿A‰¾ï²¾èr°¾èr°¾ë…¾ì1¾äZ¾ÐbN¾²-¾\)¾\(ö¾%ãT½õ½´9X½…¸½D›¦½t¼¼Ý/¼t¼¼49X¼e`B¼“t¼¼¼j¼õ½¾w½På`½Oß½Àƒ¾¸¾7KǾ|푾¬1¾ãSø¿ ¿(õÿ8b¿8Qì¿+C–¿ =¿o¾å`B¾ÍÒò¾¾vɾ´¼j¾®{¾¨õþ¢MÓ¾˜b¾‰7L¾m‘h¾D›¦¾¬½ó¶F½º^5½\)½Y‡½#× ¼ýó¶¼Ä›¦¼o¼#× ¼Týô¼ƒo¼£× ¼Ôýô½ C–½8Qì½q©ü½£× ½Ý/¾‡+¾LÌ;ˆ´9¾±©ü¾Ü(ö¿ƒ¿ C–¿ …¿MÓ¾èõÃ¾ËÆ¨¾´9X¾¢MÓ¾•¾‹Æ¨¾ƒ•¾wÎÙ¾gl‹¾S÷Ͼ=p¤¾$Ý/¾ =q½ãSø½¶E¢½\)½aG®½0 Ž+¼Ôýô¼£× ¼o¼t¼¼49X¼e`B¼“t¼¼¼j¼í‘h½¥ã½LÌͽ‡+½´9X½ñ©ü¾ Äœ¾Që…¾…¡Ë¾¢Ðå¾»çm¾Ê=q¾ËC–¾À¾®{¾›"ѾŠ=q¾yÛ#¾fff¾Týô¾F§ð¾7KǾ(õþ“u¾1'½ë…½È´9½§ïž½‰7L½]/½0 Ž\)¼Ý/¼´9X¼‹C–»å`B¼o¼#× ¼Týô¼ƒo¼£× ¼ÌÌͽo½,1½]/½‘hs½¼j½õ¾¬¾C•¾ixÕ¾…¸¾ŽÙ¾ß;¾‰º^¾}ó¶¾fff¾Oß;¾=p¤¾/ ¾!ÊÁ¾¾ 7L½ùÛ#½áG®½Æ§ð½®{½•½}ó¶½På`½,1½ C–¼å`B¼¼j¼“t¼¼u»ě¦»å`B¼t¼¼49X¼e`B¼‹C–¼¬1¼Ý/½ C–½49X½e`B½‘hs½¸Qì½çl‹¾ Iº¾$Ý/¾9X¾E¡Ë¾H´9¾B\¾6E¢¾'ïž¾Ÿ¾¾V¾o½ó¶F½áG®½ÌÌͽº^5½§ïž½•½ƒo½aG®½@ƒ½#× ½+¼å`B¼¼j¼›¥ã¼u¼D›¦»£× »å`B¼o¼#× ¼D›¦¼e`B¼“t¼¼´9X¼å`B½\)½49X½aG®½‰7L½§ïž½È´9½çl‹¾¾1'¾ C–¾1'¾ J½ó¶F½ãSø½Òñª½Ä›¦½¶E¢½§ïž½›¥ã½Oß½}ó¶½aG®½D›¦½,1½t¼¼ýó¶¼Ôýô¼´9X¼“t¼¼u¼Týô¼49X»£× »Ä›¦»å`B¼o¼#× ¼D›¦¼u¼“t¼¼¼j¼å`B½ C–½,1½LÌͽu½\)½¡ÊÁ½²-½¼j½Â\½Àƒ½º^5½²-½§ïž½²-½“t¼½‰7L½}ó¶½ixÕ½Týô½@ƒ½,1½P½+¼å`B¼ÌÌͼ¬1¼“t¼¼u¼Týô¼49X¼t¼»ƒo»£× »Ä›¦»å`B¼t¼¼#× ¼D›¦¼u¼“t¼¼´9X¼Ôýô½o½¥ã½49X½LÌͽe`B½yÛ#½…¸½‰7L½‰7L½…¸½%½u½ixÕ½]/½LÌͽ@ƒ½0 Ž#× ½t¼½o¼í‘h¼Ôýô¼´9X¼›¥ã¼‹C–¼e`B¼D›¦¼#× ¼t¼¼o»ƒo»ƒo»£× »Ä›¦»å`B¼t¼¼#× ¼D›¦¼u¼‹C–¼¬1¼Ä›¦¼å`B½+½P½'ïž½49X½vɾo½¶E¢½ƒo½vÉ¿+ ¿X¿ Oß¿ ~ú¿©ü¿#o¿:áH¿O²¿Týô¿Co¿¾w¾ð ž«…¾o²¾&éy½éxÕ½¥ãT½m‘h½,1¼ýó¶¼#× ¼D›¦¼u¼›¥ã¼ÌÌͽo½,1½aG®½—P½ÌÌ; =q¾vɾt¼j¾›"Ѿ¿|î¾äZ¿o¿ ¿zá¿ë…¿ =q¿Äœ¾ó¶F¾î—¾ô9X¿G®¿´9¿ …¿¡Ë¾í‘h¾Å¸¾›"Ѿk…¾/ ¾%½¼j½‹C–½På`½¥ã¼í‘h¼#× ¼D›¦¼u¼›¥ã¼Ä›¦¼õ½¾w½LÌͽ‡+½° Žçl‹¾“u¾F§ð¾€ƒ¾£Sø¾Ê=q¾ñ&é¿ ûç¿¿Ÿ¾¿È´¿ ‘h¿Ðå¾öE¢¾ò°!¾üj¿r°¿÷Ï¿^5¿¿ãT¾Ý/¾¬1¾€ƒ¾;dZ¾1'½Æ§ð½‘hs½Týô½¾w¼í‘h¼#× ¼D›¦¼u¼›¥ã¼Ä›¦¼õ½¾w½LÌͽ‡+½²-½éxÕ¾Ÿ¾¾JÀƒ¾ƒo¾¦ff¾ÌÌ;ó¶F¿ =q¿?}¿Qì¿t¼¿ º^¾ýó¶¾ï ¾ì‹D¾÷ÎÙ¿®¿¿vÉ¿çm¿ Iº¾çïž¾³¶F¾…¸¾@ƒ¾ =q½È´9½‘hs½Týô½¾w¼í‘h¼t¼¼D›¦¼u¼“t¼¼¼j¼õ½¥ã½LÌͽ…¸½° Žçl‹¾“u¾G®¾%¾£Sø¾È1'¾ë…¿Z¿ O߿ٿ º^¿A‰¾íV¾ß¾w¾Ý/¾çïž¾ýó¶¿ Iº¿¿¼j¿+¾àÄœ¾®—¾‰7¾;dZ¾+½Â\½Oß½På`½¥ã¼å`B¼t¼¼49X¼e`B¼“t¼¼¼j¼í‘h½P½D›¦½%½©ûç½ß;d¾t¼¾@ƒ¾vÈ´¾›"Ѿ¼j¾Û¥ã¾ô9X¿%¿G®¾øQì¾çl‹¾Ö¾Ê=q¾Ç®¾Ï\)¾àÄœ¾õ¿\¿ J¾î—¾È´9¾²-¾l‹D¾-V½ûçm½¶E¢½…¸½D›¦½t¼¼Ý/¼t¼¼49X¼e`B¼‹C–¼´9X¼å`B½t¼½vɾ6E¢¾,1¾ Äœ¾‡+¾ Oß¾$ݾ½ó¶F½å`B½Ôýô½Àƒ½¬1½•½}ó¶½På`½,1½ C–¼å`B¼´9X¼“t¼¼e`B»Ä›¦»å`B¼t¼¼49X¼Týô¼ƒo¼£× ¼ÌÌͼýó¶½¾w½H´9½yÛ#½›¥ã½¼j½Ý/½ýó¶¾ Oß¾‡+¾™š¾P¾hs¾ =q¾%½ó¶F½å`B½× =½ÊÀƒ½¾vɽ²-½£× ½•½…¸½e`B½D›¦½'ïž½ C–¼å`B¼¼j¼›¥ã¼u¼Týô»£× »Ä›¦¼o¼t¼¼D›¦¼e`B¼‹C–¼´9X¼Ý/½+½'ïž½LÌͽyÛ#½•½° ŽƧð½Û"ѽéxÕ½í‘h½í‘h½å`B½Ù‡½ÌÌͽÂ\½¶E¢½¬1½¡ÊÁ½•½‹C–½}ó¶½e`B½LÌͽ49X½¥ã½+¼å`B¼¼j¼›¥ã¼ƒo¼Týô¼49X»£× »Ä›¦»å`B¼o¼#× ¼D›¦¼u¼“t¼¼¼j¼å`B½ C–½'ïž½H´9½m‘h½‰7L½™™š½§ïž½²-½¶E¢½¶E¢½²-½©û罡ÊÁ½™™š½\)½‡+½}ó¶½m‘h½Y‡½H´9½49X½#× ½\)¼õ¼Ôýô¼´9X¼›¥ã¼ƒo¼Týô¼49X¼t¼»ƒo»£× »Ä›¦»å`B¼t¼¼49X¼Týô¼ƒo¼›¥ã¼¼j¼Ý/½+½¾w½8Qì½Týô½m‘h½%½‡+½‹C–½‹C–½‰7L½ƒo½}ó¶½q©ü½aG®½Týô½H´9½vɾ6E¢¾+ ¾²-¾ Oß½÷ÎÙ½Òñª½° Ž‘hs½m‘h½vɾvɾ;dZ¾;dZ¾vɾ8Qì¾333¾1&é¾1&é¾2-¾49X¾2-¾+ ¾²-¾ C–½ë…½Â\½›¥ã½u½@ƒ½P¼í‘h¼¼j¼“t¼»å`B¼o¼#× ¼D›¦¼u¼›¥ã¼¼j¼í‘h½t¼½8Qì½e`B½Oß½¬1½Ðå`½õ¾ Oß¾²-¾+ ¾49X¾7KǾ6E¢¾2-¾,1¾&éy¾$Ý/¾#× ¾$Ý/¾%ãT¾#× ¾²-¾hs¾%½Û"ѽ¶E¢½“t¼½ixÕ½8Qì½\)¼å`B¼´9X¼‹C–»å`B¼o¼#× ¼D›¦¼u¼“t¼¼´9X¼å`B½\)½0 ŽY‡½‡+½£× ½Ä›¦½çl‹¾“¾t¼¾¸R¾%ãT¾'ïž¾&éy¾"Ðå¾²-¾“u¾¾zá¾zá¾t¼¾hs¾ C–¾%½å`B½Ä›¦½£× ½…¸½Týô½,1½+¼Ôýô¼¬1¼ƒo»Ä›¦¼o¼t¼¼49X¼e`B¼‹C–¼¬1¼Ôýô½+½#× ½LÌͽyÛ#½—P½¶E¢½Ôýô½ñ©ü¾$ݾ\)¾¾P¾¾hs¾ Oß¾1'¾¸¾o¾ J¾½ùÛ#½ï²½Ý/½Ä›¦½©ûç½\)½m‘h½@ƒ½¥ã¼õ¼ě¦¼›¥ã¼u»ě¦»å`B¼t¼¼49X¼Týô¼ƒo¼£× ¼Ä›¦¼õ½P½$ÝÁ6VÁ4éyÁ:(öÁFÔþÁZbNÁt‡+Á‰÷ÏÁ›¼jÁ®™šÁÁïžÁÔéyÁç =Á÷ÎÙÂ~ú +ÂäZ©üÂvÉÂ_;ÂbN¤ÝÂ"ÑÂÂMÓÁÕXÁÖ ÁÕÆ¨ÁÔl‹ÁÑ× ÁÍå`ÁÈxÕÁÁ‘hÁ¹-Á¯vÉÁ¤Ÿ¾Á™%Á =Á?}Ál=qÁXÐåÁIOßÁ?G®Á;™šÁ?‘hÁK?}Á_ =ÁyãTÁ‡+Á KÇÁ´‡+ÁÉ33ÁÝ|îÁðÒòÂQì XÂW ÂNÙÂ1'ÂbÂ!êÂ#Ü)Â$í‘Â%=qÂ$× Â#âNÁàãTÁâffÁâéyÁâOßÁàVÁÜçmÁ×ÌÍÁÑ =ÁÈ‹DÁ¾‡+Á³"ÑÁ¦ÌÍÁ™ë…ÁVÁ€ÔþÁk¶FÁYÒòÁM;dÁG‘hÁI™šÁTjÁg²-Á™šÁ’¸RÁ¦r°Á»º^Áч+ÁçÁûZÂhÂl‹Â¹XÂÖÂ!ØÂ%¯Â(€Â*E¢Â+-Â+9XÂ*˜“Â)OßÁìçmÁïMÓÁðÂÁðùÛÁïÔþÁíÁèn˜ÁáéyÁÙ‡+ÁÏKÇÁÃPÁ¶™šÁ¨ýôÁ›E¢ÁŽbÁ‚“ÁpÁa\)ÁYl‹ÁYÛ#Ác`BÁuë…Áˆ¸RÁš&éÁ®|îÁÄ‹DÁÛ;dÁñ—Â_; ¬Â¿}Â>wÂ#yÛÂ({çÂ,QìÂ.üîÂ0¢ÑÂ1G®Â1¬Â0(öÂ.²Áù9XÁü°!Áÿ"ÑÂ49ÂhÁþ1'Áú9XÁô33Áì1ÁáÛ#ÁÕáHÁÈ›¦Áºp¤Á¬+Áž=qÁ‘PÁ†¡ËÁ|å`Ás¸Áq× Áy¡ËÁ…©üÁ“ Á¤ƒÁ¹ÁÏl‹Áæ“uÁýdZ ˆ1Âp¤ÂDœÂ#ÓøÂ*"ÑÂ/¦Â2Ý/Â5aHÂ6ÓøÂ7·LÂ>¡ËÂ=PåÂ;Â7öÉÂ4¡ËÂ1\)Â.{çÂ,&éÂ*^5Â) Â'í‘Â'bÂ&€Â&qªÂ'+Â(àBÂ+©üÂ/r°Â4\Â91'Â>”{ÂCß;ÂHÊÁÂM‡ÂP”{ÂS¬ÂT£×ÂU¾ÂTŸ¾ÂS0!ÂPò°ÂMýôÂJ{çÂ&ñªÂ,úáÂ2ÏßÂ8DœÂ="ÑÂA9XÂDPåÂFLÍÂG“ÂFÍÓÂE—ÂCËÇÂAÅ¢Â?èsÂ>r°Â=‚ Â<÷ÏÂ<›¦Â<¾Â;aHÂ:bNÂ9iyÂ8ÊÁÂ8àBÂ9Ý/Â;ÑìÂ>¥ãÂB$ÝÂF 7ÂJ =ÂMÚÂQ;dÂSó¶ÂUâNÂVçmÂW ÂV/ÂT†%ÂR‡ÂOÂK`BÂ)ÏßÂ0¾Â6NÙÂ<%ãÂAyÛÂF‡ÂIÑìÂL‰7ÂN7LÂNèsÂNÙÂNKÇÂM¤ÝÂM/ÂM+ÂM–‡ÂNF¨ÂNÙÂNð¤ÂNE¢ÂLäZÂK DÂI2-ÂGÁ‰ÂGuÂGLÍÂHp¤ÂJW ÂLɺÂOÂR7LÂT¦éÂVœ¬ÂWæfÂXožÂX"ÑÂW 7ÂU#×ÂRbÂO_;ÂK¨öÂ+àBÂ2e`Â8ËÇÂ>ïžÂD˜“ÂI¨öÂMë…ÂQPåÂSɺÂUr°ÂVxÕÂW ÅÂWÅ¢ÂX¦éÂYöÉÂ[Ÿ¾Â]dZÂ^Ç®Â_[#Â^ɺÂ]VÂZ€ÂW˜“ÂTâNÂR¾wÂQvÉÂQšÂQPÂR©üÂT,ÂUÔþÂW]/ÂX‘hÂYA‰ÂYIºÂX ÅÂW;dÂU(öÂRn˜ÂO)üÂKl‹Â-.Â3ËÇÂ:SøÂ@ ÅÂF\ÂKïžÂP¤ÝÂT•ÂWÅ¢ÂZBÂ\DœÂ^Â_ÎÙÂaàBÂdJÁÂfþúÂi˜“Âk¤ÝÂl\ÂloÂj"ÑÂg DÂcdZÂ_¯Â\p¤ÂYñªÂXOßÂWŒJÂWzáÂWë…ÂXš ÂYMÓÂYËÇÂYâNÂYvÉÂXn˜ÂVÊÁÂT†%ÂQ´9ÂN\)ÂJ›¦Â-ÖÂ4aHÂ:ó¶ÂAPåÂG`BÂLó¶ÂQûçÂV`BÂZ¾Â]VÂ`&éÂbÒòÂeŽVÂhŽVÂkÔþÂoDœÂrr°ÂtçmÂvVÂu£×Âs“uÂp>wÂl¾ÂgÓøÂcÍÓÂ`ožÂ]Ü)Â\¾Â[ÂZž¸ÂZuÃÂZiyÂZ>wÂYÎÙÂXñªÂW™šÂU¶FÂSMÓÂPaHÂM%ÂIDœÂ-›¦Â4'ðÂ:¨öÂAÂG{ÂLÄœÂQüîÂV®ÂZß;Â^²ÂbšÂezáÂhë…Âl•Âpl‹ÂtKÇÂwÇ®ÂzožÂ{ÀƒÂ{cTÂyffÂvÂqËÇÂmwÂT,ÂQŸ¾ÂN¨öÂKH´ÂG’oÂ,ËÇÂ36FÂ9–‡Â?ÔþÂEÜ)ÂKPÂPâNÂUÈ´ÂZE¢Â^n˜Âb[#Âf:^Âj(öÂn6FÂr_;ÂvhsÂz Â|µ?Â~ DÂ}ÐåÂ{ó¶ÂxÄœÂt¬Âp²Âkœ¬Âgs¶Âcå`Â`ùÛÂ^³3Â\í‘Â[‰7ÂZQìÂY#×ÂWÒòÂVG®ÂTffÂR(öÂO†%ÂL…ÂI'ðÂE€Â+jÂ1ž¸Â7ÍÓÂ=äZÂCÇ®ÂIm‘ÂN¾wÂS¾wÂXdZÂ\ÌÍÂaÂe-ÂiYÂm˜“ÂqÏßÂuØÂyVÂ{ò°Â}G®Â}+Â{Š=Âx©üÂtÞ5Âp™šÂl9XÂh¬Âdl‹ÂaJÁÂ^®Â\ŒJÂZ½qÂY#×ÂW•ÂUöÉÂT&éÂRÂO·LÂM%ÂIýôÂF­ÂCoÂ)…Â/{çÂ5p¤Â;LÍÂA+ÂF†%ÂKÊÁÂPÂÂU}ôÂYüîÂ^YÂbŸ¾ÂfäZÂk ÅÂoF¨Âs ÅÂvr°ÂxâNÂz49Âz.ÂxÚÂvW ÂrþúÂo¬ÂkÂg'ðÂc\Â`]/Â]ž¸Â[>wÂY/ÂWKÇÂUzáÂS›¦ÂQ²ÂOffÂLñªÂJ33ÂG1'ÂCéyÂ@gmÂ':^Â,í‘Â2›¦Â8=qÂ=»dÂCbÂH/ÂMÂQÖÂVF¨ÂZ¡ËÂ^êÂc¸Âg?}Âk0!ÂnÒòÂqâNÂt+ÂuiyÂu‡+ÂtvÉÂrbNÂoÂl¾Âh}ôÂdèsÂa€Â^ffÂ[Ÿ¾ÂY+ÂVð¤ÂTâNÂRàBÂPÚÂNµ?ÂLhsÂIâNÂG$ÝÂD'ðÂ@ñªÂ=…Â$œ¬Â*%Â/ožÂ4ÊÁÂ: JÂ?(öÂD¦ÂHÛ#ÂMr°ÂQÜ)ÂV&éÂZPåÂ^dZÂbPåÂf1Âi`BÂl5?ÂnJÁÂoÂo´9Âní‘Âm;dÂjÙÂgñªÂdËÇÂa’oÂ^vÉÂ[ˆ1ÂXÙÂVaHÂT¦ÂQò°ÂOØÂMµ?ÂK}ôÂI¾ÂF—ÂCÚÂ@ë…Â=Ç®Â:vÉÂ!ÂÂ&äZÂ,Â1“Â6{Â:öÉÂ?°!ÂDE¢ÂH°!ÂLöÉÂQÂU¦ÂXøÕÂ\¬Â`¦Âc33ÂeÅ¢Âg·LÂhÞ5Âi1'Âh¥ãÂgYÂeffÂbþúÂ`KÇÂ]}ôÂZ±'ÂXÂUt¼ÂSbÂPÌÍÂNž¸ÂLxÕÂJKÇÂH =ÂE«ÂC#×Â@r°Â=“uÂ:‡+Â7Rò§ðÂ#~úÂ(SøÂ- ÅÂ1ÚÂ6yÛÂ:úáÂ?YÂC”{ÂG«ÂK²ÂOm‘ÂSuÂV‡+ÂY·LÂ\PÂ^ì‹Â`º^ÂaÜ)ÂbG®ÂaùÛÂaÂ_yÛÂ]‚ Â[?}ÂXÖÂV_;ÂSïžÂQ“uÂOMÓÂM¦ÂJõÃÂHÑìÂF¤ÝÂDe`ÂB 7Â?ŒJÂ<éyÂ:²Â7,Â4Âp¤ÂþúÂ$PÂ)oÂ-ˆ1Â1çmÂ6+Â:PåÂ>TþÂB7LÂEõÃÂIPÂLùÛÂP0!ÂS"ÑÂU¾wÂWî˜ÂY²ÂZ»dÂ[;dÂ[¾ÂZp¤ÂYDœÂW±'ÂUÒòÂSƨÂQ¢ÑÂOwÏÂMOßÂK0!ÂI“ÂGÂDí‘ÂBɺÂ@“uÂ>C–Â;ÔþÂ9C–Â6\Â3¹XÂ0Á‰Â,Âuà½qÂ$ýôÂ)1'Â-OßÂ1VÂ5A‰Â9 PÂ<¸RÂ@?}ÂCž¸ÂFÐåÂIÌÍÂL†%ÂNïžÂPöÉÂRPÂS¤ÝÂT7LÂTC–ÂSÒòÂRò°ÂQµ?ÂP0!ÂNxÕÂL ÅÂJ·LÂHÅ¢ÂFÐåÂDÚÂBÞ5Â@ÚÂ>ƨÂ<Ÿ¾Â:aHÂ8Â5Š=Â2ïžÂ05?Â-^5ÂäZÂë…ÂñªÂ ïžÂ$áHÂ(Á‰Â,‹DÂ0;dÂ3ÎÙÂ7A‰Â:’oÂ=º^Â@¶FÂC{çÂF ÂH=qÂJ!ËÂK¡ËÂLµ?ÂMTþÂM„ÂME¢ÂL¤ÝÂK¯ÂJvÉÂI 7ÂGvÉÂEÊÁÂD PÂBDœÂ@p¤Â>‘hÂ<¥ãÂ:§ðÂ8•Â6jÂ4$ÝÂ1ÂÂ/BÂ,¦éÂ)î˜Â ÅÂiyÂ/ÂïžÂ ¢ÑÂ$F¨Â'ÔþÂ+LÍÂ.§ðÂ1å`Â5Â7ó¶Â:»dÂ=OßÂ?¨öÂA¼jÂCÂDî˜ÂEüîÂF¨öÂFñªÂFÜ)ÂFožÂE¶FÂD½qÂCbÂB;dÂ@ƨÂ?;dÂ=œ¬Â;í‘Â:.Â8\)Â6wÏÂ4|îÂ2iyÂ0wÂúá¶FÂ{çÂ^5ÂožÂÄœÂt¼Â”{ÁΙšÁÎQìÁÌùÛÁÊhsÁÆn˜ÁÀïžÁ¹ÎÙÁ±1Á¦©üÁšß;ÁïžÁ€E¢ÁdÀƒÁIº^Á0ÙÁ²Á ‘hÁE¢ÁoÁñªÁE¢Á4ÀƒÁW/Á€VÁ–¬Á®IºÁÅÝ/ÁÜÁñ‘hÂPå º^Â÷ÏÂ+Âí‘ ¸RÂ#uÃÂ%;dÂ&¾Â&:^Â%¤ÝÂ$xÕÁÚ\ÁÛbÁÚvÉÁ؉7ÁÕ“ÁÏó¶ÁÈ÷ÏÁÀ‡ÁµXÁ¨å`Á› =ÁŒ5?Áyë…Á[ß;Á?ÂÁ'&éÁÂÁXÁ…Á ‘hÁ¬Á4ùÛÁXñªÁ‚7LÁšr°Á³ß;ÁÍC–Á埾Áü5?ÂE¢Â0!ÂÌͦÂ$$ÝÂ'õÃÂ*¢ÑÂ,BÂ,ð¤Â,Ç®Â+å`Â*gmÁçQìÁèÄœÁébÁçùÛÁå=qÁà¡ËÁÙ÷ÏÁÑ$ÝÁÆ+Á¹1'Áª‡+Áš¥ãÁŠ&éÁsxÕÁTQìÁ8ƒÁ!× Á=qÁ ‘hÁhsÁ´9Á9xÕÁ^záÁ†%ÁŸ©üÁº¶FÁÕÂÁï°!ÂÔþ•Âô¼ÂæfÂ&iyÂ+Š=Â/YÂ1êÂ3\)Â3ËÇÂ3XÂ2"ÑÂ0JÁÁôÀƒÁ÷KÇÁø©üÁø•Áö¾wÁòß;Áì¶FÁä¸ÁÙ{Á˸RÁ¼bNÁ«—ÁšÁˆdZÁo%ÁPjÁ6ÌÍÁ$-Á¬Á ÅÁ)ÎÙÁCó¶ÁihsÁŒ/Á¦å`ÁÃ7LÁߟ¾ÁúÙ üîÂ9XÂøÕÂ'-Â-ØÂ3Â6ÖÂ92-Â:l‹Â:•Â9ÐåÂ8BÂ6VÂYÂ;d‰7¶F“uÁ2ƒÁ1¡ËÁ=t¼ÁVzáÁ{¡ËÁ•‰7Á°ÎÙÁÍå`Áë+ Å—Â(öÂ&+Â.Š=Â5H´Â:p¤Â>‡Â@W ÂARòÂA/Â@Â>,Â;™šÂvÉ %  ÂbÂA¡ËÂC,ÂBñªÂ@Û#Â= Â7´9Â1uÃÂ*å`Â$²ÂuÂ~úÂß;ÂVÂó¶Â²ÂNÙÂdZÂ'ðº^ÂöÉÂ&†%Â.î˜Â7³3Â@ZÂHvÉÂO´9ÂUÍÓÂZ”{Â]ð¤Â_Ü)Â`bNÂ_Ÿ¾Â]¸RÂZÙÂW/ÂRå`Â-í‘Â4¤ÝÂ;Â@üîÂFbÂIüîÂLt¼ÂM?}ÂLF¨ÂI¢ÑÂE«Â@áHÂ;å`Â7QìÂ3’oÂ0ÌÍÂ.Û#Â-e`Â,oÂ*Å¢Â)¯Â)>wÂ)í‘Â,hÂ/¿}Â4ÍÓÂ:æfÂAž¸ÂH‡+ÂO2-ÂUDœÂZn˜Â^yÛÂaBÂbº^ÂbæfÂaÝ/Â_½qÂ\°!ÂXß;ÂTvÉÂ1Þ5Â9 DÂ@ ÂFƒÂLF¨ÂPúáÂTYÂV(öÂV[#ÂU DÂR\ÂOjÂL9XÂI\ÂGËÇÂFýôÂF× ÂFɺÂFBÂDõÃÂC DÂA 7Â?š Â?H´Â@^5ÂBß;ÂF—ÂK/ÂP@ƒÂU`BÂZ-Â^RòÂabÂc¸RÂdµ?Âd†%Âc7LÂ`æfÂ]¶FÂYËÇÂUPåÂ4× Â…ÂF¸ÂMgmÂT¸ÂZÂ^ß;ÂbƒÂdêÂf8RÂf¾wÂföÉÂghsÂhŒJÂjŸ¾ÂmÂp›¦Âs1ÂsÙÂrŠ=Âo8RÂj”{Âe—Âa‡Â]±'Â[³3Â[²Â[ÂÂ]OßÂ_gmÂa¦éÂc³3ÂeBÂf²Âf¾Âe;dÂcqªÂ`ÑìÂ]t¼ÂYwÏÂTùÛÂ7ÌÍÂ?“uÂGG®ÂN¹XÂU²-Â[öÉÂaW Âe²-ÂiÂkt¼ÂmNÙÂoÂq Âs¹XÂwOßÂ{\ÂÎÙˆ´Â‚.˜ÂŽÙÂn˜Âz+Âsí‘Ân 7ÂioÂejÂc)üÂb49ÂbDœÂc%Âd Âe+Âeì‹Âf%ãÂe°!ÂduÃÂbt¼Â_·LÂ\NÙÂXTþÂSäZÂ7Ý/Â?•ÂGBÂN»dÂUÎÙÂ\KÇÂb =ÂfñªÂkÂndZÂqYÂtA‰Âw„Â{p¤Â€V‚¡HÂ… Â†üj‡Ê=‡;çÂ…\¬Â‚ƒÂ~`BÂw®Âq´9ÂláHÂiaHÂg&éÂeüîÂe™šÂe¦éÂeÔþÂeÚÂe|îÂd•Âc JÂ`ÚÂ^ÂZ•ÂV¤ÝÂRH´Â7Â>¥ãÂF0!ÂM‘hÂTž¸Â[0!Âa&éÂfožÂkbÂo(öÂr÷ÏÂvÊÁÂzô¼Â®‚~wÂ…IºÂ‡å`‰Ý/ŠÀƒÂŠL͈ˆ´Â…Á‚kÂ}æfÂwr°ÂqõÃÂm¤ÝÂj‚ ÂhgmÂg“ÂfJÁÂe´9ÂeuÂd1'ÂbäZÂa{Â^·LÂ[ÌÍÂX_;ÂT|îÂP8RÂ5“uÂ<æfÂD8RÂKhsÂRTþÂXÝ/Â^èsÂdjÂijÂnÂrjÂvÛ#Â{“u€]/ƒ#TÂ…ô¼Âˆ†%Šs¶Â‹]/‹´Â‰yX†í‘ƒɺ€nÂziyÂt²-ÂoöÉÂlC–Âi‚ ÂgƒÂf1ÂdÑìÂc¥ãÂbPåÂ`­Â^ ÅÂ\¾ÂY'ðÂU½qÂQì‹ÂMÅ¢Â3s¶Â:{çÂAƒÂHp¤ÂO'ðÂU\Â[’oÂa+Âf^5ÂkC–ÂpÂtÌÍÂyÊÁÂb‚F¨Â„úá‡e`‰3¶ÂЉãTˆ•†^5ƒ\€yÛÂzÛ#ÂuDœÂps¶Âl}ôÂiYÂfâNÂdéyÂc8RÂa²Â_ë…Â^Â[ÂÂY%ãÂV$ÝÂRÖÂO1ÂKÂ0ÖÂ7ˆ1Â>;dÂDÚÂKLÍÂQ€ÂWdZÂ\ô¼Âb7LÂg=qÂl#×Âq PÂvuÂ{@ƒÂ€=q‚Á„õ?†š Â‡s¶Â‡\)†Qì„xÕ‚ßÂ~±'Ây,ÂsöÉÂoPåÂkVÂh%ÂeIºÂbüîÂ`ô¼Â_+Â]\ÂZì‹ÂXŠ=ÂUÚÂR× ÂOÂKÝ/ÂGõÃÂ-ÖÂ4-Â:…Â@ÍÓÂFò°ÂLå`ÂR™šÂX DÂ]>wÂbA‰Âg'ðÂl%Âpí‘ÂuÝ/Âz¹XÂL͠Ń Âƒæfƒèsƒ5 ÅÂ@ƒÂzŸ¾ÂuËÇÂq²ÂlÌÍÂhùÛÂe¬ÂbÓøÂ`XÂ^“Â[ó¶ÂYɺÂWÂUÂRJÁÂOJÁÂLÂHyÛÂDµ?Â*ŽVÂ0ˆ1Â6„ÂwÂOÓøÂMG®ÂJbÂG¥ãÂD‰7ÂA9XÂ=¼jÂ#}ôÂ(Á‰Â.Â3?}Â8gmÂ=r°ÂB]/ÂG!ËÂKÀƒÂP;dÂT–‡ÂXÒòÂ\ì‹Â`Û#ÂdŠ=ÂgÛ#Âj¨öÂlËÇÂn¾Ân‘hÂn¦ÂlÒòÂjÛ#Âh^5Âe\Âb›¦Â_¦éÂ\ɺÂZhÂWÂUoÂRº^ÂPjÂNÂK­ÂI%ãÂFyÛÂC¢ÑÂ@ž¸Â=n˜Â:‡Â× Â$ÖÂ)°!Â.”{Â3iyÂ8&éÂ<ƨÂAE¢ÂE¢ÑÂIÞ5ÂM÷ÏÂQí‘ÂU»dÂYW Â\°!Â_®Âb49Âd&éÂel‹ÂeöÉÂeÂÂdÝ/ÂcaHÂam‘Â_(öÂ\´9ÂZ.ÂW«ÂU8RÂRÙÂP‹DÂNH´ÂL+ÂI½qÂG_;ÂDæfÂBJÁÂ?Š=Â<¡ËÂ9’oÂ6`BÂ. ǮÂ%bNÂ)ô¼Â.yÛÂ2éyÂ7@ƒÂ;yÛÂ?“uÂCPÂGcTÂKuÂN˜“ÂQèsÂTõÃÂW¬ÂYøÕÂ[ÄœÂ\þúÂ]œ¬Â]œ¬Â]+Â[ð¤ÂZožÂXž¸ÂVš ÂTwÏÂRIºÂP ÂMïžÂKɺÂI¤ÝÂGyÛÂEBÂBöÉÂ@bÂ> DÂ;cTÂ8˜“Â5¬Â2ž¸ÂŠ=Â× Â!"ÑÂ%hsÂ)¡ËÂ-È´Â1ØÂ5ÌÍÂ9¤ÝÂ=\)Â@ñªÂD_;ÂG ÅÂJ¬ÂMvÉÂOò°ÂR PÂSº^ÂTë…ÂU˜“ÂUÁ‰ÂUm‘ÂT¨öÂS„ÂRÂPn˜ÂN£×ÂLÂÂJÔþÂHß;ÂFãTÂDàBÂBÐåÂ@±'Â>{çÂ<-Â9Á‰Â76FÂ4‹DÂ1¿}Â.ØÂó¶Â÷ÏÂûç øÕÂ$êÂ(ËÇÂ,—Â0JÁÂ3ãTÂ7[#Â:²-Â=áHÂ@äZÂC´9ÂFE¢ÂHPÂJÂLuÂM;dÂMô¼ÂN>wÂN¬ÂM™šÂLÀƒÂK¡ËÂJJÁÂHÌÍÂG/ÂE|îÂC¹XÂAèsÂ@ 7Â>“Â<Â9úáÂ7ƨÂ5uÃÂ31Â0|îÂ-ÓøÂ+bÁŽ =Á‹…ÁˆvÉÁ„ß;Á€ÀƒÁx=qÁn{Ác+ÁWƨÁL-Á@ÀƒÁ5ó¶Á,E¢Á$9XÁbNÁ7LÁ+Á“uÁ%²Á0MÓÁ>r°ÁOº^ÁcPÁy|îÁˆdZÁ”dZÁ jÁ¬1'Á·záÁ ÁËéyÁÔÒòÁÜÄœÁã¸RÁé®Áî£×Áò£×Áõº^Á÷ïžÁùXÁúÁ“MÓÁ²-ÁzáÁ‰Ÿ¾Á… ÅÁ€Át£×ÁhA‰Á["ÑÁM²Á@“Á3‡Á'/Á%Á;dÁvÉÁC–Á JÁ Á$vÉÁ3ë…ÁG¸Á]XÁvÁˆ$ÝÁ•¥ãÁ£&éÁ°QìÁ¼ß;ÁȲÁÓdZÁݬÁå¶FÁí+Áó|îÁø°!ÁüÎÙÁÿçm¤ÝÂÝ/Á™VÁ–¶FÁ“bNÁOßÁŠ|îÁ„å`Á}/ÁoG®Á`VÁP¸RÁ@áHÁ1dZÁ"õÃÁIºÁ 1'Áp¤Á¸RÁŸ¾Á |îÁp¤Á(E¢Á=…ÁV^5Ár ÅÁ‡Û#Á—bÁ¦5?Á´ë…ÁÂÝ/ÁÏÔþÁÛ£×Áæ7LÁï~úÁ÷vÉÁþ"ÑÂƨÂáHÂiyÂk…ÂïžÂÁ 9XÁ©üÁšMÓÁ–‡ÁûçÁŠ÷ÏÁ„bÁx´9Ágß;ÁV1ÁC©üÁ1p¤Á ¬Á“uÁ¾wÀõ&éÀëïžÀí7LÀú{Á hsÁ•Á3%ÁN¼jÁmçmÁ‡—Á˜®Á©©üÁºbÁɉ7Á×ÎÙÁäº^Áð1'Áú+ÂSøÂÔþ¡ˠ @ƒÂ + P uÃÁ¨VÁ¥¥ãÁ¢ZÁž‡Á˜ÊÁÁ’jÁŠùÛÁ‚ƒÁrMÓÁ^$ÝÁI¸Á3çmÁdZÁ —Àù/Àá‡ÀÓoÀÐýôÀÜ9XÀõ`BÁ¬Á'ƨÁF“uÁip¤Á‡dZÁš\Á­\Á¿ÒòÁÐïžÁàŸ¾Áî¶FÁû¬ÂæfÂdZ V í‘ PÂyÛÂC–ÂzáÂ/Á°ãTÁ®ÂÁ«§ðÁ§vÉÁ¢{Á›r°Á“‹DÁŠdZÁ€ Áiº^ÁQë…Á9PÁ!•Á +Àï+ÀÐIºÀ¼r°Àµó¶À¾Ÿ¾À×|îÁ1'ÁbÁ> JÁdáHÁ‡SøÁœÆ¨Á±ùÛÁÆA‰ÁÙ$ÝÁêSøÁù£×€ 33 ð¤Â¾w©üÂÀƒÂu³3µ?Â,ÁºÊÁÁ¹{Á¶MÓÁ²QìÁ­ Á¦?}ÁýôÁ”?}Á‰“Áyp¤Á^ÔþÁC/Á'•Á C–ÀëdZÀÄÔþÀ©ûçÀãTÀ¢áHÀºn˜Àä´9ÁA‰Á5|îÁ`záÁ‡~úÁŸdZÁ¶÷ÏÁÍjÁâ1'Áôó¶ÂĜ ð¤ÂþúÂ÷ÏÂäZÂÔþÂÚÂ1Ât¼Â6FÂdZÁÅÆ¨ÁÄ¥ãÁÂ`BÁ¾Æ¨Á¹°!Á²÷ÏÁª…Á MÓÁ”bNÁ†ïžÁpƒÁQ™šÁ2A‰ÁÛ#ÀðÀÀå`ÀžÀ‹ =À‹ À ÀʧðÁõÃÁ-OßÁ\\ÁˆÁ¢Á¼—ÁÕVÁì“ÂA‰Â 33ÂÞ5ÂE¢Âs¶Â xÕÂ#e`Â%OßÂ&NÙÂ&|îÂ%ó¶Â$ÎÙÁÑÛ#ÁÑzáÁÏå`ÁÌáHÁÈ9XÁÁ¾wÁ¹E¢Á®¾wÁ¢/Á“ÀƒÁƒÆ¨Áel‹ÁBZÁÒòÀÿoÀÆÐåÀ› Àß;ÀráHÀŠn˜À´1'Àõó¶Á&-ÁY•Á‰1Á¦7LÁÂí‘ÁÞVÁöß;Â|î“Â@ƒÂýôÂ$]/Â(p¤Â+PåÂ-{Â-ÙÂ-½qÂ,ß;Â+]/ÁÞûçÁßPÁÞÛ#ÁÜ£×ÁØ£×ÁÒ™šÁÊOßÁ¿¥ãÁ²™šÁ£OßÁ’¸Á =ÁXbNÁ1ÒòÁ +ÀØÄœÀ£|îÀ~§ðÀb JÀy%À£ïžÀæéyÁ! =ÁXbNÁŠáHÁª¾wÁʇÁ矾Â@ƒÂ %ãÂhs =Â'‡Â,ž¸Â0¹XÂ3Â5uÂ5“uÂ5!ËÂ3äZÂ1üîÁí{ÁîÆ¨Áï/ÁíýôÁêáHÁåƒÁÝŸ¾ÁÓ%ÁÅ¥ãÁµ¡ËÁ£SøÁKÇÁt\ÁJ=qÁ!t¼Àør°À¹º^ÀŒ1Àj¬Àst¼ÀG®Àà“ÁhsÁZ$ÝÁŽ%Á°hsÁÒC–Áò¬Â}ôÂ1'ÂuÂ(%ãÂ/xÕÂ5¾Â97LÂ;Ü)Â=2-Â=bNÂ<’oÂ:ì‹Â8—Áü Áÿ%Â_;ÂgmÁþÐåÁú^5Áó¬ÁèÄœÁÛ;dÁÊŸ¾Á·OßÁ¡õÃÁ‹hsÁi"ÑÁ<ÀƒÁ²ÀßçmÀ©¸À‰7LÀ†MÓÀ¤ÔþÀæ{Á#hsÁ`¼jÁ“/Á·¸RÁÛÈ´Áý©üÂ&é“uÂ'Â0xÕÂ8Â=¾wÂAÅ¢ÂD=qÂEMÓÂE$ÝÂCî˜ÂAÚÂ?hÂɺ D ©ü ožÂ ²ÂxÕÂE¢ÂVÁó+Áâ ÁÍí‘Á·ffÁŸ~úÁ‡E¢Á_\)Á3;dÁ 9XÀÚ JÀ²{À§¶FÀÀ£×ÀþùÛÁ/ë…Án¬Á›`BÁÁn˜Áç“ÂA‰ÂBÂ#@ƒÂ/²Â8Þ5Â@bÂFNÙÂJ:^ÂLzáÂM=qÂL´9ÂKoÂH‹DÂENÙ ÖÂÙÂPåÂí‘ÂhsÂvÉÂÐå ;d˜“ÁûãTÁç =ÁÏ‘hÁ¶Ÿ¾ÁjÁ„õÃÁ\ ÅÁ333ÁPÀõ7LÀä£×À÷ïžÁoÁHjÁƒzáÁ§ÌÍÁÎdZÁôÀƒÂ xÕÂØÂ+(öÂ7F¨ÂA/ÂHïžÂNŸ¾ÂRcTÂTbNÂTÐåÂSäZÂQ× ÂNÞ5ÂK/ÂÈ´ÂÀƒÂ#ׯÂ!b ð¤ÂøÕÂáH‚  ãTÂMÓÁê“uÁÑbÁ·r°ÁžÒòÁ‡ñªÁfñªÁDÄœÁ,ƒÁ"$ÝÁ);dÁC²ÁpQìÁ–?}Á¹“uÁßl‹Â£×˜“Â$ë…Â3ÎÙÂCMÓÂF:^ÂG¦ÂEŠ=ÂAKÇÂ:l‹Â1RòÂ&¼jœ¬ÂäZÂDœÁþ¬Áð|îÁån˜ÁÝVÁØ ÅÁ×å`ÁÝ‹DÁé•ÁûĜ p¤Â ÅÂ$ŽVÂ2k…Â?\ÂK{çÂUÔþÂ^[#Âdë…ÂixÕÂlbÂlÏßÂkêÂiš Âf ÅÂa¼jÂ\¨öÂ2r°Â9î˜ÂA"ÑÂG¸RÂMC–ÂQJÁÂSPåÂRì‹ÂOãTÂJE¢ÂBÂ9]/Â/ØÂ&ë…ÂOßÂMÓ¹XÂ)üÂH´Â šÂ o ãTÂÂçmÂ{Â' PÂ2¬Â=PÂH¹XÂS Â\DœÂcäZÂiÅ¢ÂmËÇÂoöÉÂp_;Âo0!ÂlŸ¾Âhì‹ÂdTþÂ_oÂ7ÀƒÂ?éyÂGáHÂOQìÂUÑìÂZå`Â^hÂ^î˜Â]E¢ÂY-ÂS“ÂKÒòÂD_;Â=»dÂ8Ÿ¾Â5A‰Â3IºÂ1ò°Â0wÏÂ.záÂ,QìÂ*ÒòÂ*äZÂ-šÂ1“uÂ8+Â?í‘ÂH§ðÂQ˜“ÂZ0!ÂaõÃÂh…Âm–‡ÂqÂr¶FÂrÅ¢ÂqRòÂnŽVÂj³3ÂeùÛÂ`›¦Â<ÂD²-ÂMDœÂUhsÂ\·LÂb¹XÂfúáÂišÂhæfÂf~úÂbXÂ]>wÂX49ÂT2-ÂQéyÂQwÏÂRMÓÂSG®ÂS'ðÂQ>wÂMÌÍÂIÜ)ÂF³3ÂE@ƒÂEùÛÂHØÂM~úÂSffÂYøÕÂ`£×ÂfáHÂl>wÂpgmÂs#×ÂtZÂtbÂr_;Âor°Âk|îÂf´9ÂaLÍÂ?“ÂH#×ÂQ!ËÂYƨÂa³3ÂhwÏÂm©üÂpô¼Âr0!ÂqÂo^5ÂlbÂjbÂhÌÍÂiffÂkß;Âol‹Âr‘hÂs§ðÂq¹XÂmÂfƨÂ`¢ÑÂ[ÒòÂYÂX˜“ÂZ(öÂ]SøÂabÂfH´ÂjïžÂo JÂr=qÂt@ƒÂtó¶ÂtOßÂrffÂoZÂkW ÂfPÂa-ÂAÂJ6FÂSm‘Â\]/Âd¯Âl ÂqõÃÂvBÂxÎÙÂyÀƒÂy‘hÂxýôÂxïžÂzBÂ}~úÂE„49†«…‡³3†·ÏƒÚ¤ÝÂw¦ÂoŠ=ÂiæfÂf‰7Âe`BÂfoÂh ÅÂjüîÂnÂpò°Âs(öÂtožÂt›¦ÂsŸ¾ÂqƒÂn^5ÂjYÂeš Â`MÓÂA¾wÂJô¼ÂT33Â]9XÂe¼jÂme`ÂsäZÂy Â|¬Âb€Oß‚߃Ðb†|î‰ùX¹XÂËÇÂ’(ö‘5ÃÂŽò‰~ú„t9Ân˜Âw¨öÂroÂn¶FÂmRòÂmzáÂn¦éÂpPåÂqùÛÂs%ÂFp¤ÂNèsÂWE¢Â_XÂfô¼Âmò°ÂtÞ5ÂDäZÂJÄœÂPuÃÂUõÃÂ[F¨Â`ožÂe~úÂj‚ Âo~úÂtn˜Ây9XÂ}­€Ã‚;dƒ#ƒJÁ‚Ţ²Âì‹Â{ïžÂwŸ¾ÂsH´Âo#×ÂkSøÂgäZÂdÐåÂb 7Â_uÃÂ\ûçÂZ‚ ÂWñªÂU:^ÂRNÙÂO+ÂKÊÁÂH2-ÂDffÂ(XÂ. PÂ3Å¢Â9uÃÂ?hÂD\ÂIæfÂO{ÂT ÂXüîÂ]ÂÂbp¤Âg1Âk€ÂoÁ‰Âs¦éÂvüîÂyPÂ{$ÝÂ{¤ÝÂ{Ây]/ÂvàBÂsƨÂpQìÂl¿}Âi;dÂeæfÂbËÇÂ_í‘Â]BÂZº^ÂXBÂUÇ®ÂS8RÂPˆ1ÂM¬ÂJ²ÂG]/ÂCë…Â@LÍÂ$8RÂ)…Â.ÔþÂ4²Â9TþÂ>r°ÂCqªÂHLÍÂMÂQ™šÂV\ÂZgmÂ^²Âb¨öÂft¼ÂiäZÂlÒòÂo“Âp“uÂq-ÂpáHÂo¾wÂmèsÂk‡+ÂhÌÍÂeãTÂbò°Â`hÂ]NÙÂZ®ÂX+ÂU¼jÂSTþÂPå`ÂNbNÂKÀƒÂH÷ÏÂFÂBæfÂ?›¦Â<(ö !ËÂ%VÂ)üîÂ.äZÂ3½qÂ8€Â='ðÂA±'ÂF ÂJbNÂNˆ1ÂRŒJÂVhsÂZuÂ]{çÂ`‹DÂc'ðÂe49Âf™šÂgG®Âgk…Â;G®Â8¬ °!Â%DœÂ)ÑìÂ.RòÂ2Á‰Â7Â;QìÂ?m‘ÂCiyÂGC–ÂJøÕÂNƒÂQÙÂTí‘ÂW¯ÂZ =Â[êÂ]?}Â]ýôÂ^$ÝÂ]º^Â\ÐåÂ[yÛÂYÑìÂWð¤ÂUë…ÂSÓøÂQ´9ÂO“uÂMqªÂKJÁÂI¦ÂFÛ#ÂD…ÂBoÂ?€Â<ÊÁÂ9ò°Â6öÉÂ3Û#Â/Âp¤Â ²-Â$í‘Â)¬Â-;dÂ1C–Â533Â9+Â<»dÂ@LÍÂCº^ÂFúáÂJ+ÂLÔþÂOW ÂQ|îÂS:^ÂT‚ ÂULÍÂU™šÂUm‘ÂTÒòÂSÛ#ÂR•ÂQÂOl‹ÂM¦éÂKÎÙÂIéyÂG÷ÏÂEùÛÂCì‹ÂAÊÁÂ?’oÂ==qÂ:ɺÂ85?Â5Â2­Â/»dÁŒÛ#Á‰ñªÁ†p¤Á‚OßÁ{"ÑÁpvÉÁd´9ÁXbÁJÄœÁ=+Á/²-Á"áHÁG®Á ‰7ÁIºÁ(öÁ©üÁ7LÁ %Á¸Á)C–Á=%ÁS²-Ál´9Áƒ•Á‘"ÑÁž¡ËÁ«ÄœÁ¸E¢ÁÃõÃÁβ-ÁØ`BÁàùÛÁèr°ÁîÐåÁô‡ÁøMÓÁû‡+ÁýÌÍÁÿ33ÁÿÌÍÁ’A‰Á?}Á‹‰7Á‡“ÁéyÁwûçÁjÄœÁ\ZÁLùÛÁ=VÁ-%ÁÁ+ÁÌÍÀòMÓÀæ{Àâ=qÀç× À÷²ÁÈ´Á£×Á0ÙÁJ‡+ÁfýôÁ‚PÁ‘ó¶Á¡9XÁ°Á½ûçÁÊõÃÁÖÈ´Áá`BÁê°!Áò¸RÁùzáÁþýô©üÂE¢Â\)ÂöÉÂ"ÑÁ˜…Á•xÕÁ‘²ÁŒë…Á‡SøÁ€ÙÁs Áb¼jÁQ+Á>¬Á+ÊÁÁ33Á²-ÀðbNÀ×KÇÀÆ{À¾vÉÀÁë…ÀÑOßÀìå`Á ¬Á#%Á@¬Á`~úÁdZÁ’ãTÁ¤+Á´È´ÁÄffÁÒÆ¨ÁßÈ´ÁëVÁõffÁýûçÂ\Ân˜Â¢Ñ 7L 8R ³3 ´9ÁŸº^Áœ¼jÁ˜× Á“ó¶ÁŽ1Á‡1Á}ïžÁkÊÁÁWçmÁB¬Á,¬Á£×Á…ÀܼjÀ¼´9À¥XÀ˜Ý/À™/À§PÀÄzáÀït¼ÁPÁ4n˜ÁY;dÁ€ ÅÁ“ýôÁ§‰7Áº33Á˲ÁÛ…ÁéÈ´ÁöV–‡Â(öÂès ß;‡œ¬Â€ÂÏß²Á§ýôÁ¥-Á¡VÁœbNÁ–9XÁŽÈ´Á†VÁx(öÁaïžÁIÒòÁ0záÁ°!Àû =ÀÌbNÀ¤1'À…XÀeOßÀ]OßÀv{À˜¬ÀÇ33Á~úÁ'…ÁQC–Á}™šÁ•VÁ«ffÁÀVÁÓ¸RÁåE¢Áôß;ˆ´9>¶E¢¾ÎÙÀÀƒÀr°Àõ²-Á5ë…Áu¥ãÁ›33Áº…Á׬ÁñùÛ•™šÂuÂuÂ#«Â'ïžÂ*öÉÂ,Ü)Â-º^Â-±'Â,àBÂ+hsÁÕ JÁÔ™šÁÒÈ´ÁÏVÁÉùÛÁÂn˜Á¸~úÁ¬ ÁœñªÁ‹r°Áo¶FÁEhsÁp¤ÀÛ33À‡çm¿÷l‹½£× ??ÀÄœ?m‘h¿,1ÀP´9ÀÖ$ÝÁ,VÁshsÁå`ÁÀÔþÁá$ÝÁþ‡Â ®Â~úÂPÂ&î˜Â,¼jÂ1 PÂ3þúÂ5°!Â6BÂ5Ü)Â4 ÅÂ2¶FÁãr°Áä¸ÁãdZÁàí‘ÁÜbNÁÕl‹ÁËÀƒÁ¿ ÅÁ¯xÕÁœãTÁ‡¼jÁa7LÁ0›¦ÀþùÛÀ 1À^5¼Týô?Íó¶@Ù@Ðå? ÀãTÀ¸(öÁ#`BÁqãTÁ¡ ÁÇÎÙÁëp¤ÂŽVÂF¨ÂèsÂ(Š=Â0JÁÂ6E¢Â:š Â=iyÂ>ØÂ?bÂ>wÂaÏßÂ\¤ÝÂ%XÂ+SøÂ0ÓøÂ5wÏÂ8ƨÂ:33Â9#×Â5 =Â-~úÂ"m‘Â8RÂÊÁÁäÝ/ÁÂÐåÁ£bÁ…ýôÁV´9Á&õÃÁ£×ÀÕ‡Àׯ¨ÁÈ´Á@9XÁ†È´Á´‰7ÁåE¢Â ¶FÂ!1'Â5KÇÂF¥ãÂU Â`©üÂi_;ÂoYÂrƨÂså`Âs Âps¶ÂlŽVÂg¤ÝÂbÂ-Û#Â4úáÂ;º^ÂA±'ÂFZÂIÂI:^ÂF²Â?NÙÂ4·LÂ&ɺ‘hƒÁê$ÝÁÌdZÁ²7LÁ›“Á†ÂÁl~úÁXIºÁW?}Ám©üÁÎÙÁ®éyÁÖõÃÂ9X“Â+àBÂ>ÄœÂOJÁÂ]49ÂhaHÂpÈ´ÂvxÕÂy–‡Âz^5Ây¦Âv&éÂqÛ#ÂlŠ=Âf‚ Â5¼jÂ=ó¶ÂEèsÂM/ÂS:^ÂW]/ÂXÚÂVýôÂQMÓÂG´9Â:´9Â+qªÂ}ô n˜Áþ®Áé%Á×1'ÁÈ&éÁ»º^Á³=qÁ±(öÁ·ÄœÁÇõÃÁá ÅÂPÂbÂ%?}Â7|îÂHxÕÂW ÅÂd”{Âo{ÂvûçÂ|E¢Â 7ÂzáÂ}å`Âzž¸ÂvÂpaHÂjVÂ<º^ÂEì‹ÂNüîÂW}ôÂ^Þ5ÂdiyÂgYÂfô¼Âb½qÂZ¥ãÂO>wÂAº^Â3¹XÂ&å`Âp¤Â¶FÂ>w VÂKÇÂÞ5²ÂâN²- ^5ÂiyÂ%Ü)Â4²ÂC¨öÂR,Â_}ôÂk¬Ât§ðÂ{Þ5€RoÂÂ倢ÑÂ}ÀƒÂxêÂs“Âl”{ÂB•ÂL˜“ÂV—Â`&éÂh¶FÂobÂsïžÂu¬Âr²Âlp¤Âc0!ÂXuÂLÖÂBó¶Â;èsÂ8+Â6¦éÂ6:^Â5%Â2$ÝÂ.-Â*ÊÁÂ)¸RÂ+ò°Â1‘hÂ:ÂDl‹ÂOáHÂ[ŒJÂf²-Âp²-Ây PÂgmÂǮ‚¾w‚¥ã›¦Âˆ1Âz’oÂt§ðÂn\ÂG-ÂQÊÁÂ\}ôÂfß;ÂpcTÂx\)Â~ J€bÑ€VÂ| Âu`BÂm'ðÂe“Â^å`Â[Ü)Â\]/Â_záÂbýôÂd7LÂa†%Â[ffÂTÂMÞ5ÂJ\ÂJ³3ÂN{ÂT 7Â[Á‰Âde`Âm(öÂuVÂ|Qì€Ö‚߃H´Âƒ´Âæf€Â{+Âu¦Ânˆ1ÂJ^5ÂUZÂ`|îÂkffÂu”{Â~e`‚•„¥`Â…5?„Pb‚I7ÂvÉÂzæfÂxŽVÂy·LÂ~­ƒšÂ†³¶Âˆ\¬Â†ô9‚ ÂzOßÂozáÂg¬Âb;dÂ`çmÂb¨öÂfÅ¢ÂliyÂr¿}ÂyÂ~„ÂcT‚¹Xƒ0!‚È1‘ìÂQìÂz\)Ât„Ân DÂL"ÑÂW=qÂb‰7Âm­Âx49€ƨ„߇49ˆ‘숹X‡þú†öɆbN‡ J‰PÂýq“›¦Â˜´9›'m™£T”‚Âff†#TÂÛ#ÂvÙÂq‹DÂo¢ÑÂpÂs[#Âw\)Â{·L»dÂm‚Z‚‹ÇÂûd€´9Â}”{Âx´9ÂsÂl²-ÂL‰7ÂW‡+Âbº^ÂmÑìÂxe`€üîÂ…%ˆ#Š#׋7Ï‹§ð‹üjÂŒå㓠˜ïŸÁÂ¥ÀƒÂ¨¯§)y¡”{™¦é‘G®Â‰½qƒƨÂ@ƒÂzožÂx™šÂy%ÂzéyÂ}zဢœˆ´Ât9€»dÂ~Ç®Âz÷ÏÂv5?Âp¯Âj—ÂK¯ÂV`BÂaDœÂluÂvt¼Â€Â„&釈1Š‹êÂPåÂŽÁ‰ÂÔþ”"N™城٦Ĝ¬öɰ P®¹Û©På¡bN˜¼î¢N‰߾„Æ%ÂXÂ~ÊÁÂ}=qÂ}QìÂ~L͆%€9Û€X“ÂþúÂ~?}Â{p¤Âw§ðÂs+Âm´9ÂgÛ#ÂIÁ‰ÂTÂ^jÂhÅ¢ÂrÄœÂ|{‚2-Â…¾wˆ©y‹ ÓÂ/Âq'Â’O\–?}›†¨Â¢ƒÂ¨âÑ®¯žÂ±§ð°®˜Â«ô9¤·Lœˆ1”å¢Ñˆ¸Â„šÂt¼ÂãTÂ~…Â~(öÂ~7LÂ~0!Â}´9Â|‚ ÂzwÏÂwŒJÂsËÇÂoMÓÂj2-Âdš ÂFïžÂP¡ËÂZyÛÂdC–ÂmÁ‰Âv±'Â~؃®Â†+ˆð¤Â‹ßÂŽX“‘¨öÂ•ÓøÂ› þú§²Â¬.®Ú®@ƒÂªp¤Â¤MPÂu•È1Â0¤Â‰µ?Â…{d‚u?€u?Â~yÛÂ}\Â|&éÂ{OßÂz2-ÂxŽVÂvA‰ÂswÂp¿}Âw¸RÂ~33‚)yÂ….ˆRo‹Ö Å“ê˜m‘œ¹X *¢{¡ÿ}Ÿ޸œì—>wÂ’ÂŒð!ˆdZ„å‚Â~RòÂzÊÁÂx Âuì‹Âsð¤Âqå`Âo˜“ÂlèsÂiÂÂf"ÑÂbVÂ]’oÂX¾wÂ;VÂBçmÂJÑìÂR³3ÂZk…ÂaÞ5Âhô¼Âo¦éÂuûçÂ|b 7„ B‡gðŠð¤ÂޱªÂ’~w– ˜É7š]/šm‘˜ì–øÂ’UÂŽ#׉ð¤Â† D‚£×™šÂ{ ÂwYÂtbNÂqÞ5ÂoPÂm8RÂj¶FÂgèsÂd½qÂa-Â]wÂEñªÂL‰7ÂRõÃÂY,Â_'ðÂdì‹Âjˆ1ÂpVÂu—Â{1'€n˜Âƒ@Â…ïžÂˆOߊ)y‹G+‹…Šڠ‰]²Â‡A‰Â„¼î‚ ÓÂ~ÌÍÂy× Âu_;Âqr°Ân+ÂkÂhE¢Âe¬ÂcuÂ``BÂ]€ÂZaHÂVþúÂSW ÂOožÂKLÍÂ-$ÝÂ3OßÂ9ƒÂ?®ÂEÖÂK¶FÂQ}ôÂW‡Â\‚ ÂaÈ´ÂföÉÂl“Âq2-Âv>wÂ{$Ý·LÂٚƒgm„`Å„®„H´Âƒ@´9˜“Â{gmÂw!ËÂs Âo+Âk«ÂhÂež¸Âbí‘Â`RòÂ]·LÂ[ÂX+ÂU²ÂQØÂNXÂJž¸ÂF³3Â(ƒÂ.49Â3éyÂ9˜“Â?49ÂDµ?ÂJoÂOH´ÂTYÂYF¨Â^ÂbÐåÂgr°Âkó¶Âp=qÂt.Âw–‡ÂzA‰Â|Â|´9Â|RòÂzïžÂx·LÂuÝ/Âr ÅÂo9XÂkÔþÂh’oÂe€Âb ÅÂ_í‘Â]W ÂZÌÍÂXw ‰7 $ÝÂ!ËÂPÂwÏÁžýôÁ›PÁ—oÁ‘xÕÁŠ©üÁ‚•ÁrzáÁ]\)ÁF1Á,õÃÁÈ´Àð¼jÀ½¡ËÀŽÙÀN—À× ¿æ‡+¿ãt¼Àn˜ÀV§ðÀž‡+Ààí‘Á•ÁC‡ÁpÐåÁn˜Á¥È´ÁºãTÁÎQìÁßß;Áït¼ÁýoÂ]/ >w 7LÂQ윬Â$ÝÂûçÂ49ÂáHÁ§°!Á¤l‹Á ÁšQìÁ“7LÁŠŸ¾Á€záÁi²ÁOl‹Á2ÌÍÁn˜Àê—À­/Àgl‹ÀC–¿Týô½•=ý󶾡G®¿¶ÀK…À°£×ÁoÁ7"ÑÁkÎÙÁSøÁ©ÐåÁÁ£×Á×^5ÁêÊÁÁûÝ/ÂOß b½qÂàB =ÂIºÂ±'ÂW ÂNÙ±'Á±©üÁ®ÀƒÁª•Á¤÷ÏÁ¼jÁ”ÄœÁ‰ïžÁzzáÁ]xÕÁ=;dÁ~úÀìzáÀ£¾wÀ’ñª@2\@—|î@¼Ý/@Ã33@¦$Ý@H£×€À€záÁ ÀƒÁZ¬Á”¡ËÁºoÁÜ JÁú ñªÂô¼Â+Â%´9Â+§ðÂ0¸Â333Â5Â5°!Â5_;Â46FÂ2YÁØ Á×—ÁÕ‘hÁѰ!ÁË›¦ÁÂ÷ÏÁ·p¤Á¨ÊÁÁ–çmÁÝ/ÁTÁçmÀÒ-ÀF¸R>t¼j@Q™š@¸›¦@î—A?}@íÛ#@­©ü@È´À(öÀñ™šÁRéyÁ–t¼ÁÀÌÍÁæß;Â1Â49Â!ËÂ'ýôÂ/ò°Â6¬Â:š Â=ŒJÂ?Â?_;Â>–‡Â<èsÂ:~úÁçÙÁè®Áç÷ÏÁåOßÁàG®ÁØjÁÍKÇÁ¾\Á¬ Á•§ðÁwº^Á>Ÿ¾ÁïžÀ‡®¾Ö‡+@JMÓ@ÈQìA VAïžA$Ý@õÛ#@ˆ‹D¿Ý/ÀÊÐåÁJå`Á˜MÓÁÇûçÁò —Â{Â'øÕÂ2Â:ß;ÂA8RÂE°!ÂHn˜ÂI²ÂIp¤ÂH²ÂE× ÂBÏßÁøûçÁût¼ÁüffÁûVÁ÷¾wÁñVÁæ¶FÁØ5?ÁÅ9XÁ­´9Á’ =Áf“Á#ÊÁÀ¿o¿Ûçm@b@ÂéyAhsA/33A4^5AZ@Ì?¤ýôÀ£ ÁB\Áš9XÁÏ…Áþ¾wÂŽVÂ$qªÂ2YÂ=’oÂFXÂLØÂQwÂ]¾Ân=qÂ} „záˆå㋱ªÂŒéyÂŒ°¤Â‹;çˆÈ1Â…“øÂÙšÂ{‘hÂNm‘ÂZɺÂgvÉÂsõÉ7„”þ‡Ï߈Òo‡ B‚“uÂwÂeì‹ÂTffÂEt¼Â;gmÂ7 ÅÂ7—Â9ÓøÂ:\Â6bÂ.êÂ(!ËÂ%“Â'`BÂ.ÍÓÂ:33ÂH!ËÂWMÓÂfœ¬Âu"Ñ 7†aËŠ_;ÂŒâNÂë“øÂŒ ljŒJ†Pb‚ßÂ|õÃÂSaHÂ`ožÂmïžÂ{gm„߉Ӗ‡ÂßÂ+‹áH†…¢ÂƨÂr¢ÑÂh—Âd!ËÂfe`Ân49Âwp¤Â|;dÂxbÂmt¼Â_ÎÙÂT”{ÂN`BÂM¾wÂQó¶ÂYÍÓÂd PÂo‰7Â{)ü‚üj‡‘h‹+Â1'ÂŽÂå‹ÿ}‰‚ †NÙ‚šÂ}"ÑÂV¥ãÂdhÂr€†´¼ÂŒ¦é‘JÁ””¨öÂ’ó3ÂaËŠ߾†ºá„k…Â…=ô‰Ôþ‘uÙr-ÂĜ›¤Ý“և‰¥`€A‰ÂrŸ¾Âj¯ÂhF¨Âjm‘Âoó¶Âw¡Ë€#T„e`ˆ BŠúáÂŒ½ôÂSuŒŋ/ˆ½qÂ…Ÿ¾Â‚¢Â|0!ÂX49Âe§ðÂs£×€ß;‡­ÂÓøÂ’Ù–F%—ÎV—r°Â•¡H“:^‘{d‘ÍÓ•záÂ$ݧñªÂ²­‘¸eãµÆ%¬Ÿ%`’׈ã×ÂøRÂ|1ÂyDœÂz\Â~³3‚9XÂ…Ròˆ)yŠ\)‹®ÂŒƒÂ‹SøÂ‰»ç‡\)„\¬Â€åãÂz=qÂX%ãÂeRòÂs €hs‡ Â=ôÂ’k…–E¢Â˜”{™eã™&阦f™›ŒÍ¡hö«'m·×ÂÄåÂʃ–ÂǨö¼÷Ï®ÍP ãT•bÂŒ ņ&f‚ٚ¾ú‚EƒÐbÂ…ÎهÉKDŠ&fŠ1'‰cT‡ɺ…}q‚Ÿ;Â~¥ãÂwp¤ÂV£×ÂcMÓÂpiyÂ}ž¸Â…ú‡¡HÂ…5ÄyÛ„ß;Â…Ý/†üj‡߾ˆEˆ¨Â‡Â…xRƒ>ú€„ÂzƨÂsò°ÂSë…Â_å`Âl^5ÂE³3ÂMÂT2-Â[1'Âaî˜ÂhdZÂn—Âtœ¬Âzb€JÁƒe`†²Â‰çm¾ PÂ’cTÂ“× Â”/žÂ“^¸Â‘‰ÂŽÜ¬Â‹»çˆr-Â…@‚QìÂ|îÂ{ÂwYÂt"ÑÂqG®Ân˜“ÂkêÂi¬Âf{ÂbÂÂ_¾Â[,ÂVí‘ÂRm‘Â1ÏßÂ8t¼Â?#×ÂEÍÓÂL_;ÂRÈ´ÂYÂ^þúÂdËÇÂjožÂoþúÂu‹DÂ{$Ý€d݃0¤Â…ۦˆ;dŠ5‹Rò‹¶É‹?}‰ýqˆ¬Â…Ï߃O߀ÌJÂ|ÒòÂxxÕÂt–‡Âq(öÂnÂkDœÂhbÂeÛ#Âc DÂ` =Â\ÍÓÂYMÓÂU‰7ÂQ„ÂMF¨Â,¥ãÂ2º^Â8ÖÂ>ë…ÂDí‘ÂJÏßÂP‰7ÂV‡Â[yÛÂ`¹XÂeÞ5Âjó¶ÂoýôÂtõÃÂyÅ¢Â~DœÂ¦Â‚­‘ƒ¸R„%`ƒí‘ƒ)ÂÌJ€;Â|xÕÂx\Ât¶FÂquÂmµ?Âjž¸ÂgÁ‰Âe DÂbffÂ_»dÂ\õÃÂZ1ÂVæfÂSŠ=ÂOõÃÂL(öÂH)üÂ'¤ÝÂ-7LÂ2ÏßÂ8aHÂ=âNÂCIºÂH\ÂM±'ÂR®ÂW‰7Â\G®Â`ì‹ÂevÉÂiÞ5Ân\Âqë…ÂuH´ÂwúáÂy× ÂzÀƒÂz®Ây­ÂwâNÂuwÏÂr¥ãÂo²Âl‰7Âi†%Âf¡ËÂcâNÂaA‰Â^´9Â\+ÂY•ÂVæfÂThÂQ\ÂMÜ)ÂJuÃÂFß;ÂC¬Â"ÒòÂ'ò°Â-{Â20!Â7>wÂ<6FÂAoÂEÎÙÂJk…ÂNèsÂSDœÂWƒÂ[²Â_ŒJÂc?}Âfž¸ÂiŽVÂkí‘Âm¡ËÂn˜“ÂnɺÂn>wÂmVÂkXÂi?}ÂfêÂduÃÂa÷ÏÂ_Â]ÂZ³3ÂXRòÂUí‘ÂSuÃÂPäZÂN/ÂKOßÂHE¢ÂEVÂA¬Â>!ËÂ49Â"ë…Â'£×Â,W Â0üîÂ5‘hÂ: JÂ>l‹ÂB¯ÂFÒòÂJÖÂN·LÂRqªÂUûçÂYIºÂ\H´Â^äZÂa1ÂbŸ¾Âcž¸ÂdÂcÊÁÂcVÂaÝ/Â`RòÂ^ˆ1Â\“uÂZ‡+ÂXn˜ÂVNÙÂT(öÂQùÛÂO»dÂMgmÂJöÉÂHdZÂE«ÂBɺÂ?Á‰Â<‘hÂ9=qÁ‰ñªÁ†5?Á¸RÁxÝ/Ál°!Á^éyÁO¥ãÁ?‡Á-…Á`BÁ 33ÀïSøÀÏ"ÑÀ³•Àž~úÀ‘©üÀާðÀ–Ÿ¾ÀªE¢ÀÉÀó¥ãÁ¥ãÁ1+ÁQxÕÁsC–ÁŠ´9Á›vÉÁ«ÁºPÁÈhsÁÔ÷ÏÁà+ÁêÁòvÉÁù•Áÿj¸RÂãTÂŽVÂÅ¢Á“uÁ‹®Á†å`Á-Átí‘ÁePÁT=qÁA/Á,¬Á&éÁC–À×…À¯33À‹¾wÀ^éyÀ9XÀ*áHÀ6ÙÀ_ À‘ûçÀÁãTÀý‰7Á!‡ÁF¸RÁnÁоwÁûçÁ°=qÁÁ5?ÁЮÁÞ‘hÁê× ÁõƒÁþ™šÂu¸Âuà%ã ;d Ö ÌÍÁ–7LÁ’?}ÁA‰Á‡&éÁÂÁnÈ´Á[`BÁE®Á-ó¶Á°!ÀõVÀÀÌÍÀŽÐåÀCt¼¿ñ©ü¿‡®¿'l‹¿=󶿯\)À"ñªÀ‡ÎÙÀÌ´9ÁVÁ:IºÁh{ÁŠë…Á¡1ÁµÎÙÁÈå`ÁÚ"ÑÁét¼ÁöÛ#Â1' P 1 .Š=Â)ü¸ÂwÏÂF¨Áž Áš{Á•ÁŽ¡ËÁ†ß;Á{G®ÁeÎÙÁMdZÁ2E¢Áå`Àë÷ÏÀ­‡À_|î¿ÜIº¾Týô?n{?Éûç?щ7?…¡Ë¾gl‹À &éÀ”1ÀñG®Á, JÁaÁ‹OßÁ¤º^Á¼ZÁÑÎÙÁäõÃÁõÊÁÂ/ÂdZ ŽV¹XÂó¶ÂIºÂÎÙ”{±'Â7LÁ§ Á£`BÁžZÁ—Ý/ÁÀƒÁ…å`ÁtffÁYOßÁ:¬ÁñªÀé©üÀžéyÀ)‡¾ãSø?¾Ù@A&é@ @ˆj@p Å@MÓ>ˆ1'À%¡ËÀ¿\)Á× ÁZQìÁŒ Á©=qÁÄoÁܸÁñQìÂß; ĜÂk…ÂâNÂ8RÂ{çÂÁ‰Â!¬Â!¤ÝÂ!s¶Â ¡ËÁ±¡ËÁ®KÇÁ©‰7Á£"ÑÁšáHÁ‘hÁ„VÁj‡+ÁHvÉÁ"A‰ÀñOßÀ™¡ËÀhs?*=q@F‡+@£t¼@ÏÎÙ@â~ú@×"Ñ@«dZ@?|$ÝÀ†E¢Á p¤ÁRvÉÁoÁ®®ÁͬÁèÁÿbN ¼jÂA‰ÂZšÂ#‘hÂ&ÔþÂ(ùÛÂ*šÂ*QìÂ)ÀƒÂ(„Á½¸RÁ»Á¶Æ¨Á°º^Á¨•Áž{ÁûçÁ"ÑÁ] Á2jÁ7LÀ¡7L¿â\?ºÀƒ@ =@á©üA|îA©üA5?A /@Àí‘@l‹À \ÀèýôÁI¾wÁŽƒÁµ"ÑÁ×—Áõ‘h¢ÑÂP¶FÂ#?}Â)A‰Â-ÑìÂ1%Â2øÕÂ3ÊÁÂ3œ¬Â2•Â0ÙÁËt¼ÁÉ©üÁÆA‰ÁÀãTÁ¹33Á®ÙÁ¡|îÁß;Áy¶FÁKVÁffÀºÀáH?à£×@¬¬A MÓA3p¤ALÐåAQó¶A?ÒòAP@©²->n˜À¸í‘Á?¾wÁ5?Á¼\Áã‡+Âp¤Âˆ1Â[#Â&+Â.$ÝÂ4dZÂ9Â<uÂ=¾wÂ>(öÂ=}ôÂ;éyÂ9—ÁÚå`ÁÚXÁظÁÓÐåÁÍ ÁÃ7LÁ¶ Á¥ÁñªÁm¥ãÁ3çmÀè1À?¾w?®Ù@´õÃA$ÝAO¾wAuVA÷ÏAw²-ANA‰AÀƒ@0ÄœÀ&éÁ3®Á‘× ÁľwÁðÈ´Â ë…ÂYÂ'$ÝÂ1£×Â: JÂ@~úÂE“ÂGõÃÂIA‰ÂI,ÂGèsÂE­ÂB®Áì JÁí‡Áìr°Áé©üÁä1'ÁÛvÉÁÎå`Á½ïžÁ¨5?Á—Á\È´ÁÈ´À— => Äœ@¡º^An˜A` JAЬA˜SøA—/A„Ÿ¾AAKÇ@· ¿ÿ;dÁ$ƒÁ’í‘ÁÍ;dÁþõÃÂuÂ$ûçÂ2ÔþÂ>VÂFçmÂM†%ÂR 7ÂTš ÂUk…ÂT¹XÂRÂÂOÇ®ÂLÁþÙÂ푲Â8RÁþÔþÁ÷°!ÁìE¢ÁÛÙÁÅÐåÁ©éyÁˆr°ÁDå`ÀåÒò¿î—@b\AýôAa A“MÓAªZA°•A¢jA}‰7A>º^5ÁxÕÁ’çmÁÕjÂÀƒÂ©üÂ0=qÂ?C–ÂKF¨ÂT‘hÂ[PåÂ_®ÂaÚÂbÂ`©üÂ]å`ÂZoÂUwÏ ‘h ?}Â,ÂÂj ê =Áþ—Áè~úÁËQìÁ§QìÁ{ÊÁÁ"£×ÀŽ—?¨Ôþ@ç+AR§ðA•1'A¶ÊÁAÆÄœA¿-AhsAG&é@:áHÀ÷ =Á‘¼jÁÜçm ë…Â'e`Â;ÓøÂL)üÂY1ÂbÈ´Âi¡ËÂmÅ¢ÂouÃÂoÂlƨÂi²Âd`BÂ^Ý/ÂVÂaH¦ÂùÛÂÎÙÂýôÂÞ5ÂÐåÁðÛ#ÁÉ‘hÁ›Ÿ¾ÁTõÃÀå©ü¿“t¼@ r°A8 ÅA¬A¼ß;A؇AØZA¹&éAyp¤@¨ÀÏoÁÐåÁä-Âî˜Â1 =ÂGqªÂY.Âfô¼Âq+ÂxÂ{ò°Â}‡Â{áHÂxÁ‰Ât%ãÂnr°Âh‹DÂ% ÅÂ*-Â.E¢Â0Þ5Â1H´Â.¹XÂ(PåÂ1' ¶FÁíÄœÁ¹ÔþÁ‚²Á¸RÀ]¡Ë@,jA²-A„dZAºãTAà¶FAè$ÝAÊÎÙA‹í‘@ГuÀ¿®Á“Áí J²Â:‹DÂRÈ´ÂeâNÂtŒJÂ6Fƒ„ݲ…#ׄ$Ý‚ ÅÂ~®ÂxÂp¤ÝÂ*õÃÂ2:^Â9 ÅÂ?0!ÂCÖÂFÂDêÂ?QìÂ4bÂ"C– Ü)ÁØÌÍÁš‘hÁA7LÀ·®>9X@Ó A^È´A«¸A×¶FAã~úAÆÒòA†‡+@³Æ¨ÀãSøÁžG®Áú-Â$“ÂD Â]Ÿ¾ÂqÓøÂ€¡Ë†(ö‰¦f‹F%‹B‰áH‡l‹Â„-€cTÂx‰7Â6H´Â?RòÂH6FÂPm‘ÂW7LÂ[\Â\.ÂWœ¬ÂLdZÂ9j§ðÁü¸Á·¶FÁs‰7Á …ÀU¸@…A£×A‚²A¯ ÅA»ÐåA ‰7AE•?ÔzáÁ';dÁ´¶FÂêÂ-p¤ÂM\Âg¿}Â|™šÂ†G+‹ñªÂm‘Âçð¡ËÂŽèsÂŒ߈gð„7ÏÂn˜ÂA(öÂKþúÂVïžÂak…Âjš ÂqKÇÂsøÕÂpÚÂf5?ÂR× Â6Û#˜“Áá¡ËÁ¡ó¶Á_¥ãÁZÀ‰º^?…¡Ë@Ú\A7× AOl‹A#xÕ@l(öÀ±%Á ÁדuÂZÂ8^5ÂW9XÂpûç‚ì‹ÂŠú^°¤Â”#T•|î”ÿ}“Â׋ݲ‡[#‚ÓÂK49ÂWÂÂd²-Âqr°Â}šÂƒ*Â…³3Â…$Ý€Š=Ân—ÂS)üÂ1m‘ÂG®ÁÞzáÁ¯C–ÁçmÁg\)Á2jÀï²À†$ÝÀ,IºÀ‚éyÁA‰ÁvA‰Á½í‘ÂcTÂ$Þ5ÂD¢ÑÂ`Û#Ây,†¬ÂŽ’ò”4¼Â—“u˜Ïߘ+•ûdÂ’ž5ÂŽl‹Â‰³¶Â„²-ÂTÂb“ÂpÖ­†×ÂŒº^ÂŽÙ‘>wÂÊÁÂ…¦éÂr=qÂS+Â2Ôþ‰7Â1Áì9XÁáE¢ÁÚ÷ÏÁÐß;ÁÀt¼Á°ZÁ«p¤Á¸™šÁØ%Âl‹Âl‹Â7m‘ÂQ¸RÂj;d€¦Â‰‘––k…™¥`šÇ+š =—”LÍ ‹0!†Â[2-Âj|îÂz®Â…²Â/”Ÿ¾Â™¯›±ªÂ™©ü“¬ÂˆnÂvVÂZOßÂB¸RÂ3{çÂ.¢ÑÂ3VÂ;¢ÑÂ@;dÂ:ýôÂ-ùÛÂ!%Â× Â˜“Â(!ËÂ7ùÛÂJÓøÂ^÷ÏÂs‡Âƒ Á‹vFÂ’YšÂ—`ÅšbÑ›gmšž¸Â˜Tþ”áËœ)‹ÎV†·LÂ`‰7Âp£×€æf‰ ’t9šLÍ ]²Â£–£ ºÂžSu•æé‹+€F%Âop¤Âg¨öÂlC–Â|ËljCÂ-ÂÁ‰Âƒ5?ÂmhÂYxÕÂO33ÂMçmÂS˜“Â^49Âk÷ÏÂ{ZÂ…wLÂŒ®˜Â’À—@™ó¶ÂšÔ{š%—ÊÁ”q'ÂH´Â‹™šÂ†²ÂcØÂtKÇ‚î˜ÂŒ D•hÂ]/¤ì¨9Û©¨Â¦,‹Â ,‹Â˜bÑÂ߾Œ¬ÂŒš Â”C–£ D´ŽÙ¿gm»Û#¬T{™s¶Â‰…¢Â}"ÑÂq5?Âm£×Âp“uÂx=qÂr°Â‡p¤ÂOßÂ’iy–A‰Â˜å™C–˜p¤Â–LJ“#Â#TŠ¥ãÂ…ÙšÂe¦Âur°Âƒp!ÂŒyÛ•t9ÂÌͤ©„«lªLͦ­¡ؓÂÁ‰ÂœÌJ¡ŒJ®&é¿}ÂÚ‡ÂçÖÂâ.ÂÍև¶ Ç¡Š=Â’'ð‡ûç‚e`€—´9„Ñ쉮€ƒÂ‘‹D”£×–{ç–ô¼Â–” P‘ DÂNى߄€ƒÂduÃÂtJÁ‚ŒÍ‹<î“Ý/›ï¢Ñh§Þ5ªœ)ªùÛ©€Â§^5¦W¨Ÿ;° ÅÂÀyXÂØc×ÂòêÃåÂûƒÂä(öÂʾ³LÍ¡I7”RòÂŒ‰Â‡®˜Â†ŒÍ‡¶ÉŠBÂZ ÂNÙÂ’œ)“ð!”#T“6F‘AÂŽoŠñ'†÷L‚­‘Âb$ÝÂq(ö€€Âˆ¤Z´¼Â˜G+žÝ/£úá§MP¨Ý/©+…©B ª£×¯.˜Â¸å`ÂÉq'Âà²-Âù\Ãïà ÁÂí€ÂÔ×¾-«k…Â,“G®ÂDœÂŠr°ÂŠÂ‹uÂŒäÝÂŽÌÍÂO\‘‘ ÂûçÂŽ ‹q'ˆ0!„{ç€yÛÂ^wÏÂlxÕÂ{ ÅÂ… PÂŒq'“hs™’ož˜¢H1¤¹X¦aH¨¦Â« B°áHºÒòÂÉîÂÝŽVÂñxÕÂýRòÂú†¨ÂëF¨ÂÖ±'ÂÂJÁ°ƒ¢^¸Â—ÿ}‘²Â0¤Â‹†¨Â‹c×ÂŒ ÓÂÒòÂŽšÂ³3Œߊ´9ˆ3¶Â…+…¹ÛÂ{ýôÂYÖÂf¦éÂt =€Ðb‡€ƒÂÔ{“†¨Â˜\)œ;çŸC¡և¤£T¨“u®®˜Â·áËÂÄ‘ìÂÓݲÂâ¯ÂëàBÂë8ÕÂá1ÂÑ^¸ÂÀ‰ºÂ±œÂ¤š&é“/ÂŽŸ;ÂŒ%㋊æé‹ß‹/ŠýôŠMÓ‰ LJ49„ÒòÂüîÂ}’oÂv¢ÑÂTW Â`Âl6FÂxr°Â‚wÂ=^5ÂD‹DÂK³3ÂR¿}ÂY²Â`?}Âfž¸Âl¿}Âr³3Âx’oÂ~{ç‚C–Â…^¸Âˆ„œÂ‹—ÂŽe`­Â’-Â’³¶Â’0!¶ÉÂŽ~w‹ǮˆÛ#Â…õ?ƒ@ƒÂ€Ô{Â}ožÂyÊÁÂv™šÂs´9Âpò°Ân-ÂkDœÂh ÅÂd´9Â`÷ÏÂ\ë…ÂX•ÂTÂ0‰7Â7Â=ÂCúáÂJ_;ÂPž¸ÂV¯Â\‹DÂb7LÂg½qÂm)üÂr\Âw÷ÏÂ}`BÂZ Âƒã׆(öˆ‰?}‰ȴ‰åˆ£T‡!ËÂ…5Ã߀Û#Â}ožÂys¶ÂuÖÂr’oÂo˜“ÂlÍÓÂjÂgXÂdyÛÂaiyÂ^¦ÂZŠ=ÂV¶FÂR¢ÑÂNW Â+bÂ0ó¶Â6Ý/Â<¿}ÂBbÂHBÂMÏßÂS49ÂXp¤Â]‰7Âb‡+Âgp¤ÂlH´Âq 7Âuž¸ÂyçmÂ}²-€cTÂxÕ‚¢Â‚ ÂuÀvFÂ~:^Â{‡Âw¾wÂtbNÂq"ÑÂnbÂk/ÂhuÃÂeÓøÂc7LÂ`ŽVÂ]ÄœÂZÏßÂW¥ãÂTA‰ÂP£×ÂLÎÙÂHÈ´Â%ÙÂ+9XÂ0²Â5ûçÂ;JÁÂ@ÂE˜“ÂJŽVÂOaHÂTuÂX¨öÂ]!ËÂa|îÂe´9Âiµ?ÂmgmÂp¨öÂsSøÂuDœÂvdZÂv§ðÂv“ÂtÐåÂró¶Âp­Ân'ðÂk…ÂhàBÂfIºÂcÖÂaLÍÂ^Û#Â\cTÂYØÂW-ÂTYÂQVÂN¾ÂJ·LÂG²ÂCY âNÂ%ÏßÂ*¿}Â/¨öÂ4…Â9LÍÂ=úáÂBŒJÂFþúÂKQìÂO†%ÂSš ÂW‹DÂ[QìÂ^Þ5Âb¸ÂdúáÂgYÂi!ËÂjF¨Âj¾wÂj\ÂiËÇÂh‰7ÂfçmÂeÂbð¤Â`ËÇÂ^œ¬Â\jÂZ49ÂWô¼ÂU¥ãÂS>wÂP·LÂN1ÂK.ÂH&éÂDñªÂA‘hÂ> =Áˆ=qÁ„oÁ~ ÅÁrVÁd¼jÁUOßÁD(öÁ1|îÁ•Áí‘ÀèIºÀ¿çmÀš§ðÀtýôÀCdZÀ$‹DÀZÀ-¡ËÀYÛ#ÀzáÀÀ“uÀût¼Á?}ÁC¾wÁi©üÁ‡ÒòÁšMÓÁ«× Á¼$ÝÁË JÁØvÉÁä\)ÁîÀƒÁ÷§ðÁÿ¸Â˜“Â÷Ï·LÂâN†%¯ÁïžÁ‰‘hÁ„9XÁ{¡ËÁl›¦Á[KÇÁGÂÁ2(öÁÈ´Á$ÝÀÑÊÁÀŸïžÀaº^ÀV¿–‡+¾ð ž`A‰¿ä9XÀЬÀç®Á&ÙÁ[l‹Á‡§ðÁ bNÁ·IºÁÌ{ÁÞ¡ËÁîûçÁý33¯ Ǯ ð¤Â2-›¦Â;dÂ"ÑÂe`‡ÁœÀƒÁ˜QìÁ’™šÁ‹l‹Á‚©üÁpffÁWó¶Á;÷ÏÁ¬Àõ¸À¬¼jÀDýô¿Kƨ?ª^5@J\@‘Òò@«²@®§ð@˜9X@Néy?m‘hÀ33À°¬ÁùÛÁS7LÁˆVÁ¤°!Á¾× ÁÖ9XÁêÐåÁü¾w‡ Ÿ¾Â 7Â`B³3ÂhÂŽVÂ>wÂ8R”{Á¦7LÁ¡ýôÁœQìÁ”ýôÁ‹ÎÙÁ€™šÁfr°ÁGC–Á#º^ÀøƒÀ£C–ÀZ>õ?}@I™š@°Ôþ@í`BA $ÝA÷ÏA$Ý@×¥ã@ƒKÇ?¥ãÀ`ÔþÁvÉÁJZÁˆ÷ÏÁª+ÁÇ÷ÏÁâ(öÁøå`Â;dÂbÂPÂDœÂÄœÂ#²Â%bNÂ&©üÂ'VÂ&­Â%¡ËÁ±C–Á­xÕÁ¨‡Á ÙÁ—|îÁ‹¼jÁzÈ´ÁX›¦Á0áHÁãTÀ¤Äœ¿í/?Ãt¼@š§ð@û¥ãA&5?ABffAN\AG¡ËA,(ö@ù&é@mp¤¿–E¢ÀÑÛ#Á@ÐåÁŠ“uÁ±VÁÒó¶Áð-‘hÂ/Â#דuÂ%’oÂ*2-Â-ƒÂ/›¦Â0™šÂ0œ¬Â/Ç®Â.=qÁ¾ JÁº÷ÏÁ¶-Á¯XÁ¦ ÅÁš(öÁ‹"ÑÁq‘hÁEïžÁ‰7Àµûç¿ìÌÍ@ n˜@ÅÂA¥ãATjA| JAˆ²A‡ÊÁAtƒA@1@éÂ?Ƈ+À›l‹Á6^5ÁŒïžÁ¹•Áà =Â=q ß;ÂSøÂ"êÂ*ÊÁÂ1 JÂ5¾wÂ8õÃÂ:ÌÍÂ;gmÂ:ì‹Â9‰7Â7e`Á̲-ÁÊ©üÁÆÔþÁÀÐåÁ¸(öÁ¬jÁ ÅÁ‰å`ÁdéyÁ-…ÀÜIºÀ ƒ@ Û#@Ý‘hA9¸A|‡+A™XAªA‰A­Æ¨A¡× A…ûçA7‡@—•À6È´Á*MÓÁ÷ÏÁÃÌÍÁï\) Ÿ¾Ân˜Â$ÀƒÂ.ùÛÂ7JÁÂ=ƨÂB|îÂEƒÂFûçÂGuÂEûçÂCë…ÂAoÁÝKÇÁܲ-ÁÚC–ÁÕ‹DÁÍûçÁà Á´Á p¤Á‡ÙÁT“ÁƒÀ€´9? ƒ@×÷ÏAD ÅA‹éyA¯ë…AÉffAÓº^AË¥ãA¯ß;AjAÛ#¾ß¾wÁ Á“1'ÁÏvÉÂe`Â49Â$C–Â1}ôÂ1ÀѸ¿9™š@¬1A:MÓA;dA½©üAâbNAöÎÙAõó¶AÝ(öA¬PAO\)@$ýôÁ$ÝÁ•‹DÁÛĜ àBÂÊÁÂ1DœÂ?„ÂK"ÑÂTSøÂ["ÑÂ_²ÂaèsÂb;dÂ`Þ5Â^¸ÂZKÇÂU«Â/ÂûçÂð¤Â¾wÂÁþ©üÁòdZÁà7LÁÇ(öÁ¦“uÁ}VÁ —Àq‡@0QìAn˜A…A‰A¾ÌÍAñp¤B  B|îB®AÝ~úA’l‹@̼jÀÏ…Á•A‰Áç"ÑÂÂ+øÕÂ?-ÂN¥ãÂ[ ÂdÀƒÂk£×ÂoÙÂqbÂquÂn½qÂjð¤Âf1Â`X Ròˆ1ÂÂ_;Â5?Âûç šÂãTÁñQìÁϲ-Á¤¸RÁdE¢Àï;d¿'+@ÉVA^VA²t¼Aô\BÁ‰B"éyB "ÑB (öAÄ^5A1¡ËÀuÒòÁƒÁï£×Âs¶Â8¾ÂMŠ=Â^ŒJÂküîÂv ÅÂ} J€p!€ïžÂ€5?Â|öÉÂwøÕÂqÞ5Âk+Â;dÂÂ"\)Â%¡ËÂ'dZÂ'Â#²-˜“»dÁþVÁÎûçÁ•‘hÁ0¬ÀpõÃ@Gl‹A*A‰A`BAí•B²B5•B:±'B'@ƒAùÀƒA÷Ï¿9‡Á‡× Áô©üÂ$/ÂC©üÂ[ËÇÂn«Â}DœÂƒú^‡p!‰¸Â‰3¶Â‡îÂ…–‚qªÂ}„ÂuxÕÂ%´9Â,qªÂ2ËÇÂ8NÙÂ<[#Â>#×Â<©üÂ6ÀƒÂ+1ÂhÁùß;Áµ©üÁYº^À­Û#?¶È´A+Aˆ—Aâ JB!W BGDœBSå`BAwÂUzáÂ``BÂjVÂqwÂh«Â{ŽVˆ!Ë“,žeã¨ãT±0!µbѳ†¨Âª_¾Âš2°Â… Â]PÂ7{²ÂùÛÂ"Â8DœÂHŽVÂBˆ1Â*{ÂÛ#Â(ö %ÂKÇÂ2çmÂLk…ÂföÉ€©üÂ"ј2°Â¡+…§P«¬Â«ð!ª_;¦çð¢òœ\)–)üÂÈ´Ânl‹Â ÅÂŒ\—Ðå£ì¯{ç¹þ¾Ø¾å`¸(ö«o™»ç‡„œÂpØÂ`àBÂfA‰Â‚lš®­…¢Âªc×”²°ÂyÞ5ÂYjÂJ‰7ÂIPÂQð¤Â`t¼Âr÷ÏÂƒ× ÂŽ_¾Â˜"Ñ F¨Â¦-©‡+ªYšÂ¨ë…Â¥«¡þ›œ¬Â•£TÂr°Âq¼j‚ð!ÂŽ Çš¦a˲Rò¼„œÂÃB ÂÄäZÂÀP¶Ĝ©‘hœÂ’?}Â]/›Ùµ¢ÑÂÛëÂøQìÂñRoÂÏ„¬*Â’C‚&éÂsçmÂo^5Âs·LÂ~‘h†ÍÓÂ<î—t¼Âž‚£¸Õ¦ºá§}q¦3¶Â£9ÛžùX™ڠ”5ÃÂŽQhÂrœ¬Âƒ8RÂŽ¦Â™ÉºÂ¥Õ±{ç»”{®˜ÂÅu?ÂÃKD¼ȴ³ÎV«H´Â¦øR«hö½øÕÂãyÛà óøÃÃô9ÂýhsÂÑš Â±ošœ)ÂŒl„ë‚ÌÍ„Òo‰¦fÂð!–wÏœA‰Â œ)£%ã£Ö¢•ŸâNœ‰Â—IºÂ’ ÁÂŒ„Âq>w‚²ÂŒu×vÉ¢»d­˜“·¾ ÂÁ/ÂÁMP½Ţ¸´9´·Lµ@ƒÂ¾¨öÂÖožÃQhà æ¨Ã6¡Ã)@Åà +ÂêýqÂÇ{d­c×›SøÂ&fŠÅ‰÷LÂŒ\)Âb•\¬Â™ÊÁÂ/žÂŸ&fŸ‰ºÂžhs›ó¶Â˜n” ÅÂMÓŠ-Âmöɺ^‰q'“†%ÂÀ§ŽÙ°1ªÂ¶ÓøÂºÌÍ»öFºê¹#¸¾w¼¾wÂȾúÂá*Ã3uà âNÃ3ÓÃ)¢ÃýôÂø7ÏÂÕ¹ñ'¦&f˜ïžÂ‘gmÂŽqªÂŽÂ‘ P”.˜Â—C™©ü›ƒÂ›™ó¶Â—®˜Â”záÂåÂŒ'ð‡oÂi-Ây~úÂ…r-ÂŽ}——  F%§ûç®$ݲZ´™šÂµqªÂ¶߸7Ͼ'ðÂʉÂß÷ÏÃTÃÃà #ÃT9Ãt9ÂùyÛÂÙÔ{ÂÀ¦Â¬˜“ž߾–E¢Â‘Þ5ÂŽV‘7LÂ’Û#”°¤Â–%`–Û#– B•iy“E¢ÂVŒĜˆ½ô„hsÂcMÓÂr“€×ˆÝ/Âڠ˜wÏŸLJ¤øR©A‰Â¬;d®`Ű/´@ƒÂºãTÂÆ3¶Â×…¢ÂîÄœÃÉà *=à oßÃËÇÂïùXÂÖjÂÀJÁ®¹X¡Ö™ ºÂ“áË‘r°ÂØ‘BÂ’¨Â’¤Ý’ƨ’8ÕÂèsÂŽÙÂŒ Bˆۦ…-Â3¶Â\¼jÂj%ÂwàB‚ÿ}‰üî¥㖲-›æf %`£‹D¦|j©§m­ùX´€Â¾2°ÂË•ÂÜ JÂìäZÂøåãÂúbÂðÏ\ÂßëÂÍ49»Ö­ Å¡Ĝ™ B”Pb‘@ƒÂÈ´ÂG®Â49Â"NÂŽÅÂìÂŒ€ÂŠ}q‡ð!„ìŠÁÂ{ɺÂUÊÁÂa«Âmí‘ÂzVƒH´Â‰;ÂŽ}“C–—aËšöÉžNÙ¡æf¦]/¬X´X¾u?ÂÉýqÂÕÂÜËDÂÞH´ÂØÇ+ÂάÂÁ5?´J=¨ÍPŸfé˜C–“;dÂô9ÂûçÂŒÝ/ÂŒ-‹”{ŠÒo‰ºáˆ6F†ïžÂD\)ÂI§ðÂNÌÍÂSËÇÂX©üÂ]jÂbuÂf¦éÂk²ÂohsÂsk…ÂwÂyúáÂ|2-Â}‡+Â}êÂ}dZÂ|uÂz²Âw¶FÂu PÂrKÇÂoPÂlãTÂjPåÂgÏßÂeW ÂbÔþÂ`;dÂ]{çÂZŒJÂWe`ÂTÂPiyÂL—ÂH•Â#F¨Â(dZÂ-†%Â2 ÅÂ7¬Â<¡ËÂAzáÂF49ÂJÍÓÂOH´ÂS¤ÝÂWäZÂ\%Â`ÂcɺÂgIºÂjgmÂmÂo+ÂpYÂpñªÂpÔþÂpÂnÎÙÂm¾Âk+Âi DÂfØÂdž¸ÂbdZÂ`&éÂ]àBÂ[‡+ÂYoÂVvÉÂS®ÂP´9ÂM†%ÂJ$ÝÂF“uÂB× Á†`BÁƨÁx~úÁk|îÁ\n˜ÁKSøÁ8A‰Á#hsÁ  Àë®À¼›¦ÀޏRÀH1'¿üj¿‰X¿ J¾±&é¿$Z¿¶À+× ÀŒ“uÀÏdZÁ •Á6\Á`ÌÍÁ…`BÁ™•Á¬•Á¾‡ÁÍõÃÁÜ(öÁè²-Áó•ÁüãTÂRòÂvÉÂæf ­Â × Â p¤Â Š=ÁŒ Á‡C–ÁXÁtzáÁcÊÁÁPƒÁ:¬Á"n˜Á{ÀØIºÀž¸RÀKo¿¼ÌÍ=¥ã?¡ÊÁ@V@‹D@—?³t¼½\)À~úÀÄœÀëdZÁ&¬ÁXáHÁ… ÅÁœ¡ËÁ²l‹ÁÆ9XÁ×õÃÁç¥ãÁõZ“uÂŽV §ð êÂaH“ Å‹DÂgmÁ’ûçÁŽÁ‡ÊÁÁ€+Án{ÁX£×Á?ë…Á$Á&éÀǶFÀãT¿ìj>™‡@õÃ@zŸ¾@£¥ã@·33@´r°@™&é@Iûç?LIºÀ 33À²§ðÁ=qÁP9XÁ…IºÁ §ðÁ¹Ÿ¾ÁÏó¶Áã®ÁôéyÂéyÂC– ’oÂáHÂ:^­ÂH´Â ÅÂJÁÂÚÁ›7LÁ–A‰Áß;Á‡Ý/Á|¬Ád›¦ÁI Á)?}ÁÀ¼r°ÀPõÿ Oß@õÃ@•`B@Û¶FAÄœAƒA‡+A  @ßt¼@†§ð?$“À^éyÀýó¶ÁG%Á† Á¦Á‹DÁÛ²Áñhs² -Âû盦“€ áHÂ"PåÂ"æfÂ"»dÂ!êÁ¤ûçÁ =qÁ™ãTÁ‘®Á‡`BÁuxÕÁW&éÁ3PÁ °!À¹ÊÁÀ+÷Ï?áH@|j@å?}A áHAF1A^{Ae\)AY?}A8´9A¬@€9X¿|îÀ͇Á=xÕÁ‡çmÁ­ ÁÍ¡ËÁé—½q ð¤Âš ÂÝ/ ɺÂ%m‘Â(ÖÂ+Â,DœÂ,Â+éyÂ*ž¸Á°|îÁ¬7LÁ¦+Áž JÁ“ƒÁ†=qÁk× ÁD£×Á¬ÀÄ(öÀV?»¥ã@±²-APAUPAƒûçA•¶FA\)A˜çmA‡bNARffAV?øÔþÀ”ÔþÁ3ÊÁÁ‹bÁ¶vÉÁÛ^5ÁúG®Â ¬ÂuÂTþÂ& =Â,@ƒÂ1Â4ZÂ6bNÂ76FÂ6ýôÂ5Ý/Â3üîÁ½éyÁºl‹Áµ JÁ­bNÁ£Á•|îÁ„\)Á^ƒÁ+ÎÙÀá%À4zá?èb@×C–A;l‹AƒïžA¥‡+A¾ñªAÌAË+A¹A‰A–ïžAL£×@® JÀ&È´Á)ïžÁñªÁ²ÁìC– JÂúá «Â*„Â2©üÂ9$ÝÂ=õÃÂA)üÂBÞ5ÂC7LÂBffÂ@š Â>ÁÍjÁË ÁÆÒòÁÀ Á¶jÁ©/Á—ÎÙÁ´9ÁLÌÍÁ `BÀ}p¤?¯\)@äjAR$ÝA˜“uAÄZAçãTAþ%B‡Añ—AËñªA“p¤A1¾'ïžÁ;dÁ–¾wÁÒÂ`B®Â!{çÂ-Þ5Â8OßÂ@èsÂGž¸ÂLm‘ÂOaHÂP›¦ÂPQìÂN¿}ÂL¾ÂH±'Á߸ÁÞr°ÁÛÊÁÁÖ›¦ÁÎE¢Á =Á±&éÁšÌÍÁ|ƒÁ6“ÀÄÌ;1&é@ÌjAUl‹A£¥ãAÛ =BÇ®BïžB‹DBt¼BoAȧðAk²@8r°Á©üÁŸ(öÁä¼j zá ¬Â/»dÂ<ÐåÂGâNÂPî˜ÂWÖÂ\†%Â_hÂ_¥ãÂ^‡+Â\ ÂXbNÂSð¤ÁóoÁôPÁô"ÑÁñ33ÁêýôÁà©üÁÑ9XÁ»Ÿ¾ÁžÎÙÁsïžÁë…ÀEó¶@ƒ33A;÷ÏAž|îAá´9B)üB*ÒòB8‘hB7:^B%ƒB·LA¨¡Ë@ÜÄœÀù‰7Á§áHÁùýôÂ0!Â/5?Â?¶FÂM˜“ÂY[#ÂbÝ/ÂiàBÂnMÓÂp?}Âoô¼ÂmÇ®Âj“ÂeH´Â_«Â Å»dÂúáÂ%Âr°Â¼jÁø›¦Áäó¶ÁÉ JÁ£PÁhÀïdZ>!ÊÁAn˜A‚õÃAÏOßB_;B6bBObBVm‘BJ$ÝB) PAé|îAGhsÀ¯çmÁ­OßÂxÕÂ(€Â?gmÂQ0!Â`%ãÂl½qÂv³3Â}·L€ٚÂgm€³3Â}ë…ÂxÜ)Âr¨öÂk¶FÂފ=›¦Â˜“Â%ÂNÙ¾w ƒÁý9XÁ×ë…Á¥©üÁP£×À›Æ¨@4záA&Ÿ¾A¡{B¨öÂ+gm »dÁ½A‰Á2‡+¿³÷Ï@‰ÒòA å`A§™šB\BqöÉBžæfB®¥`B£3¶B÷LBáHA/¾wÁy‘h˜“ÂEQìÂk ŃŽÙÂŽu?Â–ÓøÂœ®ŸöÉ ɺŸu?œfé˜Â’öFÂ_;‡™Â9ÏßÂD\)ÂO"ÑÂY¤ÝÂc Âj`BÂmñªÂkÜ)Âa‘hÂKH´Â#²ÁÏÐåÁ&é@{t¼AùÛAG¡ËAœVB–‡B‚\¬B¹?}BÍ PB¹nB:^B2‹DAaÊÁÁZ¸R ¢ÑÂIûçÂuµ?‹)—œ¬Â ýô§Oߪ“øÂªüî¨õ?Â¥ ÁŸÏß™Ǯ“ZÂŒÒòÂH DÂURòÂcW Âq‘hÂ{Â…33ˆ¯ˆ‰ºÂ‚ÙÂj DÂ7‹DÁÖãTÀ¥ÒòA+ïžA„ A‰|îA¬p¤B³3B„£TB£TBÔ\B¶W B†ïžBŒJA1OßÁo¶F¹XÂO%Â~G®Â‘0¤ÂŸ0!©Ÿ¾Â°³Ú³ñ'±NV¬Ÿ;¦‘쟻d˜ß‘_¾ÂUÏßÂeêÂw[#„ÑhÂÝ/•æé›|þ–’o†`ÅÂQÞ5Á÷…ÀÚÀƒA.£×A‹´9ASøA¤¬Aü~úBU|îBš;dB§–‡BŽŠ=BJ†%AÖvÉ@…Áž‡+ÂÏßÂU›¦Â‚P•“øÂ¤µ?°øÂ·‰ºÂ»åºûd·éü²¦é«÷L¤‰ÂœÂ •VÂb‹DÂubNÂ…5ÂX›Ú¦›#Â®× Â±öF¬Ǯœ$ÝÂ|Â'$ÝÁ”&é¾ãSøA—A*5?A?¶FA„× AÖ=qBŽVB3+B}ôAÙ Aº^Áp¤ÁÖl‹Â)‡Â]º^Â…A˜C§ð!³ñªÂ»âÑ¿¦é¿ß¼LͶ¹Û¯­§ØŸ¾w—·ÏÂmŸ¾Âr-Âj𗍀ƒÂ¶ìÂÁRòÂÇ>wÂÄ33µ,‹Â™G+ÂfÂ%Áš§ðÁ§ðÀ†vÉÀ”“ÀêáHÁ\Àe?}@Féy@½X?Ñ&éÁ jÁ­V «Â:ÄœÂf‹D‡LÍ™a˨ì‹Âµ ŽYÂÁXÂÁeã¾2-¸/±‚©™¡fé™E¢Âvr°Â†Ê=“õ⮲ŒÍˆ´ÂГuÂÙjÂÙ$ÝÂÌâN´ß“cTÂ^ŒJ ÅÁåMÓÁÄ£×ÁçÀƒÂ$8RÂRÂMì‹ÂÅ¢ÁäïžÁÅë…Á޸ €Â+;dÂMšÂoRòˆÉ7™DœÂ¨1³ð!¼"NÂÀE¢ÂÀß½¢N¸Su±wÏ©Á‰Â¡·L™³¶Â|¢ÑŠq'˜Qh§ð!¸÷LÂÊiyÂÚBÂå>úÂç~wÂÞZÂÊ/žÂ®]/ÂøÂjdZÂGNÙÂD[#Ârr°Â¬ô¼ÂâÖÂÝŸ¾Â«J=Â~¡ËÂMØÂ<©üÂ>öÉÂKêÂ_ÂxuŠ˜l¥ܬ°øÕ¸ËǼéy½q'ºì¶¯·Ï¨qªÂ Ç®Â™oÂêÂŒ4¼Âš49©ò-»Â̺áÂÜïÂè·LÂì¤ÝÂæƒ–ÂÖàBÂÀë©[¦Â•²-ÂŒX“•åã¾gðÃ÷LÃ3Í‘Ã*ffÂÿ/¾G®Â—¶É‚]/ÂpVÂk+Âq²Â€P‹Su—g𣓬ú^´‡Â·÷L¸§ð¶‘ì²Ro¬‘hÂ¥äZžÁ‰Â—}€(öÂŒ)™¬¨ËD¹ BÂÉÖÂÙœÂäaHÂé!ËÂå®ÂÚ¥ãÂÊڠº\¯ ǯ DÂÄ]/Âþ™šÃ7Ãk¼¬ÃPüîÃ$Âí-Â¾ÓøÂ •ƒ÷Lº^Â…q'Â/–¬‹Â NÙ¨¢Ñ®½q²*²àB±(s­|î¨eã¢bÑ›ݲ•%ãÂ~ ÂŠ]/— J¥³և¼jÂÐG+ÂÚ†¨ÂߌÍÂÞVÂ׌ÍÂÍ“uÂľÂÀ%ÂǼîÂåVÃ]²ÃfªÁç¨öÃuT{Ã*/ÃØ“ÂÚñ'·¹XŸ}qÂÑhŠ|îŠÆ%Âzá–mÂÓøÂ¤ff©NV¬¬­‘«5è =£“už9X˜W Â’2°Ây¸R‡KÇÂ’ÓøÂŸMÓ¬V‡Â¹6ÉÂÄÑhÂÍÖÂÒÉ7ÂÓWÂГÂËÂÇ ÅÂȈ1ÂÔ¡ËÂóvFû¦ÃWËDÃŒÒNÃg[¦Ã1=qÃF¨ÂìÖÂǃ¬äZ›ªÂ’§mÂ.Â’&é–ˆ´Â›±ªÂ wL¤¦%`¦wÏÂ¥¾Â¢W žk™¬”dÝÂŽÒoÂs°!ƒIºÂŽV˜xR£®®— ¸aËÂÀ5ÂÅ®ÂÆå`ÂÆV‡ÂÄèöÂÄþwÂɹÛÂ× ºÂñãTÃìÃ1¾wÃPþÃMøRÃ0I7ËÂóiüÂÏ|îµT{£¥ã™Pb”ݲ”‹D–¡H™¹XœÏߟ4¼Â }ô yÛŸ%㜣י(s”ïžÂ4¼Â‹+ÂlŠ=Â}cT‡¶F‘$Ýš®˜Â£Þ5¬¸Â²× ·˜ºY»¦é¼±ªÂ¿:áÂÅ}ôÂÒ =Âç‡+ÃíPäZÃ+Ÿ;Ã/i7Ãî˜Ã OÂîQìÂϪ¸t9¨¢Â’o˜œÂ–´Â–JÁ—«…™Oßšœ¬Â›-‘šÌÍ™k— “ò°Â*‹éü‡\)Âd½qÂs¤Ý®˜Â‰ÉºÂ‘âÑ™£T ¥ã¦‹Ç«#®dݰÝ/³bÑ·2°Â½Æ%ÂȤÝÂÙ ÇÂï.ÃS3Ãö‡Ãªà j=ÂûvÉÂáÂÉ¥ã¶Ï\¨µÃŸ\™2°Â–\)ÂE’oÂLÀƒÂSÏßÂZ­ÂaH´Âgš Âm§ðÂs€ÂywÂ|‰7€å`ƒn˜Â… ‡¹Û‰/ŠŠ'm‰ Åˆ‰7‡Â…<îƒ\)€ƒÂ€Â|E¢ÂyQìÂv“uÂsñªÂqPåÂn•Âk©üÂh|îÂeÂa>wÂ]+ÂXÑìÂT;dÂ*äZÂ0µ?Â6Š=ÂÌIº@7®@¤´9@âMÓA¡ËA+A²A¡Ë@Åó¶@Zñª½@ƒÀ®Ál‹ÁGC–Á„ Á¢1Á¼Ý/ÁÔ‡+Áé/Áû¸ÂIºÂ Ý/ÂYÂÇ®Â49­ÂB 7„Á™dZÁ“å`ÁŒÒòÁƒõÃÁr1'ÁX JÁ933Á…ÀÚ5?À€¼j¿©ü@@¨bNAº^A-XAMdZA`1'Ab“uARbNA/%@ó…@VÈ´¿ÂMÓÀÖÙÁ>{Á…í‘Á¨ó¶ÁÇ•ÁáùÛÁø¡Ë 7ÂYÂ`BÂ,ÂÈ´Â#?}Â%¡ËÂ' Â'{çÂ''ðÂ&%ãÁ£dZÁž¬Á—VÁïžÁ‚xÕÁh´9ÁF§ðÁjÀß¾wÀm¸½¶E¢@på`@öÀƒA8ÙApƒAŽÄœAdZA¡ÂAš-A† AKãT@ðb?¸õÃÀ bÁ5|îÁ‰‡+Á²ƒÁÕ?}ÁòZÂn˜ÂÛ#½q 5?Â&PåÂ+{Â.‰7Â0ÀƒÂ1ÓøÂ1äZÂ1uÂ/†%Á¯E¢ÁªzáÁ£¾wÁš°!ÁŽïžÁ€ JÁ[KÇÁ.ÀƒÀôbÀtj>î{@¤ZA £×Ao/AœffA»•AÑ™šAÚõÃAÔýôA¾záA˜ AHáH@ “ÀBáHÁ.1'Á´9Á¿£×Áæ¡Ë“Â#×Â0!Â$ž¸Â,‹DÂ2ô¼Â7× Â;7LÂ=+Â=ÒòÂ=XÂ;æfÂ9¬Á½?}Á¹MÓÁ³G®Áª¼jÁŸ$ÝÁó¶Áy/ÁI%Á‡+À’‡+>ÐbN@¿ A?`BA‘%AÀë…Aër°BâNBcTB &éB“AÔí‘A•²-AÔþ¿HõÃÁ(áHÁ™ÁÑ‹DÁü°! J¢ÑÂ(5?Â2/Â:–‡ÂANÙÂFDœÂIxÕÂK%ÂK“ÂIçmÂG¬ÂDœ¬ÁÍ~úÁÊÛ#ÁÆbÁ¾•Á³È´Á¤ñªÁ‘MÓÁp¬Á0éyÀÈ1¿33@½%AP¬A¤¼jAá•B 8RB$ožB2¬B4²-B(½qBÖAÑ™šAi ?õ¡ËÁ%¾wÁ¨oÁ鬠6FÂOßÂ+¬Â7¸ÂA¯ÂJ²ÂQ£×ÂV˜“ÂY{çÂZt¼ÂY½qÂW ÅÂTffÂPSøÁà1'ÁßbNÁÜp¤ÁÖ¼jÁ͉7Á¿õÃÁ­Á“›¦ÁeC–ÁZÀ6Ù@KÇAKVA¬‡+AöáHB jBA#×BWÖB_vÉBUe`B9_;B $ÝA©r°@¬ ÅÁ#VÁ¼/—ÂKÇÂ.¬Â;ÌÍÂH7LÂSqªÂ\ó¶Âd›¦¿ý/@¾¬AAÒòAÂxÕB:¨öB†Ü)B¡ DB®>wB­$ZBš ºBfÜ)Aêí‘Àa©üÁÿl‹ÂAˆ1Â]çmÂmÌÍÂ|’oÂ…ÚÂŒÓøÂ’X“•ݲ—>w–£×”dZÂçmŒ߇³¶Â‚•Â!àBÂ(}ôÂ.ÊÁÂ4^5Â8©üÂ:ýôÂ:\Â6m‘Â-JÁœ¬Áÿt¼Á§“Á E¢¿¶éy¿Õ`B@“•A÷-Bk-B¡ožBÂú^BÒ-‘BÇRòB õ?B>²@ÜõÃÁãp¤ÂDýôÂkÚÂ2°ÂФÝ“zá›)ü áH¤²Â¤ÌÍ£1ªÂŸÅ› Ç•€ƒÂ†¨Â‰gmÂ0ð¤Â:?}ÂC¬ÂLɺÂTöÉÂ[_;Â_Â^Ý/ÂY§ðÂL‚ Â.ÑìÁè33Á!™š?ļj>aG®¿~vÉAH$ÝB$§ðBŸß;BçÒòC`ƒC|¬B×oBŠáËA¤hsÁ¬ffÂ;þúÂqô¼Â‰±ªÂ–ff¡"Ñ©Ôþ¯Ú²ȴ²©ü¯ê«,Â¥žA‰Â—#Âô9Â@‘hÂLêÂYô¼Âg>wÂt =Â7Lƒ¤ZÂ…@ƒq'ÂxbÂR·LÁù¥ã¿5?}AœŸ¾AœÊÁA)hs@ÓÎÙAýG®B´‘ìC¨´C4>5C–BûÛ#B¤´¼Aí7LÁj\Â-©üÂsbN hö­†%·¢Ñ¾7ÏÂÀõ?ÂÀ P¼ Ŷ¢Â®å¦ožÂž"Ñ•üjÂPRòÂ_þúÂq‡Â˜“йX“&f™«œ/™ȴŒÍÂ^ÔþÁÅ“A—dZB=¶FB0‚ Aä~úA¬ÎÙB$äZBÓ5ÃCQÒoC[‘hC!äÝBê¾wB‘²AÐA‰ÁP(öÂ%'ðÂröÉ“öF§ª·gmÂÃF¨ÂʸÕÂÍ}ÂËöÉÂÆû翡˶èö­œ)¤F%›=ôÂ_¢ÑÂrɺ„¾ÂÞ5œ-‘¨o±Ǯ¶‰7²|j ;dÂne`Á³ÔþAØhsBnjB^33BÇ®BOßB5m‘B³öÉCö‡C'§+BüyXB®wÏBEJÁAL£×Á+Â(ÀƒÂrff•JÁ«¿}½ñªÂË¢NÂÔ#×Â×3¶ÂÕPåÂÏ’oÂÇB½P³Tþ©0¤ÂŸxÕÂmÔþ‚1ªÂ"N·Ï­’ò½¢ÑÂ˧ðÂÓÄœÂЗ ¼ÂxR¤Ý@¶vÉB{çB'ô¼BAÿí‘B ÌÍBIØB”ýôB©\)B•ÕBW€AÑ9X¿àbNÁÌë…Â3þúÂs¿}•¾Â¬ÔþÂÀ¼îÂÏñªÂÙ~úÂÝ ÇÂÛ)yÂÕþÂÌC–ÂÁÿ}·>w¬²Â¢yXÂz)ü‰áHÂ˜× Âª;½‰7ÂÒ/ÂåbNÂò’òÂòÜ)Âßô¼Â·WÂw ÁÝA‰?Ý/A÷ÏA±?}A¥ñªALÙ@´bNAxÕA·bA÷PAÀG®@¯¥ãÁsß;ÂúáÂ@ò°ÂuÙÂ“× Â«D¿ܬÂÏýôÂÚZ ÂÞ|îÂÜô9Â× ÁÂÎCÂÃô¼Â¹5®cT¤!ËÂñªÂåã k…³ÔþÂÊ*ÂâªÂúãTÃÀƒÃ 3øÃgmÂÞs¶ÂªûçÂbë…Áò›¦Á" Å?Ï;d¾áG®Á²‹DÂITþÂS¬Áú JÁ7çmÀó ÁƒG®Áçå`Â"ûçÂMyÛÂw†%‘¹Û§Õ¼uÂÌT{Â×\ÂÛ¶FÂÚÇ®ÂÕyÛÂÍ@ƒÂÃiü¸ñ'®|j¤mÂ…C–“߾¥D¹ÙÂÑÇ®Âìr°ÃÁÃÂNÃþúà ìÂúƨÂ΂ Â7LÂ\ãT‡+ÁÔE¢Âµ?¦:^à ƨÃǮºøÂf–‡Â+VÂ!˜“Â-¬ÂAVÂYÌÍÂyQìÂ|j£š¶ŽVÂÆ{ÂМ)ÂÕßÂÕNÙÂÐå`ÂÉ›¦ÂÀ¢N¶åã­ ºÂ£q'†àB•姃»åÂÓ_¾ÂíÉ7Ã>úÃ5à ÃóøÃlÂâæf»"Ñ–r-Âx.Ânš ÂŸJ=Ã%`CúÃ’‘ÃiyÂÆ—–\¬Â{ɺÂd_;Â]ÚÂfs¶Â|‰7ÂŽƒÂŸª°–‡Â¾ ÅÂÈbNÂÍLÍÂÍž¸ÂÊ)yÂÃú^¼‡Â³RoªF¨Â¡W†ÎV•%Â¥¹X¹+ÂÏPbÂçbÑÂÿ.à 8Rà ÄÝà JÃ6FÂéÑìÂÌô¼Â´‚¨iü´ĜÂïÊÁÃCÀƒÃžgÃ…$¼Ã.Ô¼Ã;¦ÂÈLJ¢©ü‰ô¼ÂyuÃÂu¾Â{çÂŽbœÚ«,‹Â·)ü¿ªÂÄ/žÂÄ×ÂÂ6ɽ#¶W® Å¦‰ÂžXÂ…;dÂ’‰ºÂ¡ë³xÕÂÆüîÂÛš Âïc×Âÿ ÅÄÃ\)Âøñ'ÂçKÇÂÔïÂÇó¶ÂÈìÂáA‰Ã¶‡ÃˆÐbCúCúÃ/,‹ÃãÂëdZ¾PžB ŠɺƒÝ/†ò°Â =›¦Ðb°fé·Tþ»'m»ß;¹Ùµ§ð¯í©;d¢ ºÂš¯‚q'ÂŽÓœH1«— ¼%ãÂ;ÂÜøÕÂét9Âð9XÂïúáÂélÂß;dÂÕ{çÂÑH´ÂÙ'ðÂößÃH1ÃiMCúCúÃFòÃ!X“Ó¶ÂÒ`B¯¸Â˜ÓuÂŽ±ªÂŽ$Ý“u?›Qh£wLªŽV¯Ê=²ºá³F¨Â±/® B©D£záÂ&é–”{Â}ˆ1‰ß•‹Ç¢— °T{¾ DÂÊ–ÂÔ~úÂÚgmÂÛ±ªÂÙÂÔ]/ÂÐÏ\ÂÒIºÂݬ‹Âù5ÃÃ\ÃB/žÃ‡IyáÜîÃd/\Ã)!äÂÝ$ݺùX¤¨ö˜Û#•Pb—šÂ›Š= »dÂ¥~w©“««Ro©Òo¦Óu¢§m¢N˜oÂ’7LÂuV„ÂŽSu™NV¤š Â¯¥ã¹£TÂÁ¨sÂÆõ?ÂÉMÓÂÉH´ÂÈ\¬ÂÈÃÂÍMÓÂÙQhÂð²Ã ÊÁÃ)àBÃRwLÃcäœÃCŠ=Û#Ã:^ÂÝÞ5ÂÀ=ô¬¢Â ´ÂšŸ¾Â™»ç›höž'm ó3£;¤;d¤ߢ•ŸêœD—Þ5Â’õ?½qÂlÂ|…‡{ÂIºÂ™–‡Â¢Pª¤Ý±Oß¶)y¹+…ºÓu¼0!¾ÍÓÂÄåÂÏŽÙÂáËÇÂüƨÃóøÃ!mÓÃ'ÖFÞúà ´{Âô@ÂÖzá¿-‘®H1£F¨Â,‹Âš¬‹Âšr°Â›cTœ¨s©üžƒÂq'›ès™r-–/Â’H´Âë‰@ƒÂbÊÁÂq"Ñ€‡×ÂŽV–ð!¡Ë£Ro§Ïß«+­Ǯ°dZ´ 7¹çðÂÃ.˜ÂзÏÂâ‰ÂöšÃÓ3Ãô9ÃñìÂóüjÂÞáËÂʵ?¹˜“¬Rò¢ó3Â1Â™ÓøÂ˜|î˜:^˜g𘇮˜@—YšÂ•¼j“gðÂožÂŒî‰œÂ„ÒòÂY¼jÂf1'Âs Â€#†”{Œ ’k…—`B›ŒJŸ%¢šÂ¥H1©:ᮨs¶*ÂÀƒÂ˵?Â×±ªÂáÂä°!ÂáVÂ×ÂÊáH½¥`±’ò§– œÂšÅ¢Â—wL•—”ž5”ò““øÂ’ב­‘ÂýqÂÁ‰Â‹‡Óu„J=€}ÂQ%Â[àBÂg Âr6FÂ}9Xƒ߾ˆÀÂ#T‘”s¶Â—­‘›œÂžâN£¬‹Â©©ü°ؓ¸¿}ÂÀQhÂÆœÂÈZ ÂÆŸ;ÂÁG+¹ž5±–¨«¡[#›vÉ—\“üj‘ó3›¦Â¡HÂŽº^®˜ÂŒVŠšˆr°Â…ãT‚÷LÂ~úÂxš ÂHÖÂRDœÂ[ñªÂež¸Âo¦Âx6F€`B„MÓ‡ã׋3¶ÂŽcT‘©y•D™iüž6F£‘ì©5®2-±õó¤Ý²޸¯Ïß«#Â¥ƒŸËÇš†¨Â– ÁÂ’xÕÂÅ¢ÂɺŒMP‹‰ô¼Âˆ·Ï‡C–Â…ƒ–ƒp! ºÂ|¯ÂvɺÂp€ÂAÂIcTÂQÝ/ÂZPåÂb™šÂj”{Âr%ãÂy=qÂÜ)ƒ߆)‰4¼ÂŒ}qÂh“øR˜‡Âœ*Ÿɺ¢yX£ÍÓ£‘h¡Õžî˜Â›JÁ—dÝ“¡HÂDÂn‹#T‰O\‡Ñh†ƒ–Â…A‰Âƒë…‚j€®˜Â}`BÂxÞ5Âsß;Ânr°Âh¯Â9ƨÂA6FÂH´9ÂP'ðÂWwÏÂ^ŒJÂeSøÂkÂÂqÞ5Âw¸RÂ}p¤Â˜“„߇ªŠæéÂŽ-‘Oß” P–)—>ú—U–f锡HÂ’E¢ÂŸ¾ÂŒó3ŠqªÂˆ8R†NÙ„­‘ƒAÂñ'€¥`Â~ŽVÂ{Š=Âx&éÂtYÂp¦ÂkwÏÂfvÉÂa(öÂ3 =Â9°!Â@]/ÂGÂM…ÂSÝ/ÂYùÛÂ_ØÂewÏÂjçmÂp9XÂu…ÂzÝ/€&f‚äZÂ…•ˆ ÂŠIºÂ‹öFÂŒûçÂF%ŒًÍÓŠKDˆ†œ¬Â„ÀƒÂƒ–Âp!€Â}bNÂzÙÂxH´Âu“uÂrŸ¾Âo[#Âk½qÂgÖÂcqªÂ^ÑìÂYî˜Â,È´Â2ÂÂ8Á‰Â>¶FÂD“uÂJMÓÂOÛ#ÂU9XÂZhsÂ_p¤Âd\)Âi8RÂn PÂrÜ)Âw˜“Â|'ð€.‚ƒÂƒn˜Â„aË„ÍP„²°Â„!Hƒ0¤Âþw€¨sÂ~\Â{ÙÂyA‰ÂvÇ®ÂtbNÂqýôÂo‡+ÂlçmÂjVÂfð¤Âc…Â_ËÇÂ[Ç®ÂW€ÂRûçÂ&õÃÂ,`BÂ1ËÇÂ7.Â<}ôÂA²-ÂFÄœÂK±'ÂPyÛÂU¾ÂY«Â^¾ÂbƒÂfÎÙÂjùÛÂní‘ÂrŒJÂu²-Âx9XÂz%Â{+Â{>wÂz¼jÂyŸ¾Âx PÂv.Ât"ÑÂrÂoãTÂmÀƒÂk˜“Âi`BÂg DÂdŒJÂaÖÂ^âNÂ[«ÂX0!ÂTs¶ÂP{çÂLOßÁ‚MÓÁy¶FÁlŸ¾Á]7LÁKXÁ6õÃÁ ¬ÁýôÀ×ß;ÀŸ ÀIû翯¾w>˜“u?á&é@: J@hÄœ@v§ð@_ @ß;?dÝ/¿¢n˜ÀyhsÀÛoÁãTÁRñªÁ‚SøÁ™ÌÍÁ¯hsÁÂùÛÁÔr°ÁãçmÁñp¤Áý"щ7¨ö öÉ ~úÂLÍÂm‘ÂñªÂéyÁ‡ó¶Á‚-Áv9XÁeG®ÁQKÇÁ: ÅÁº^Á1'ÀÃ¥ãÀ|¼j¿Ù7L?bN@.éy@•ó¶@ɇ@ì9X@û =@ò@ÏKÇ@’Ù?ûdZ¿¡ÊÁÀœ¬Á “ÁJ JÁ‚º^Áž?}Á·{ÁÍ$ÝÁà‹DÁñ Âhs µ? JÂuÃÂþú´9¨öÂî˜Âš ÁŽÝ/Áˆß;ÁdZÁpr°ÁZn˜Á@jÁ"9XÀÿ²À²È´À=ãT¾>vÉ@*°!@¯oA A$jA>E¢AK…AI™šA6áHA¸@¿l‹?ü¬À#dZÀêáHÁAG®Á„VÁ¤›¦ÁÁ%ÁÙ°!Áï ¶F£×ÂcTÂÂŒJ =†%Â!{Â!Ç®Â!º^Â!Á—G®Á‘=qÁ‰~úÁ‘hÁg²-ÁJéyÁ(ÔþÁ7LÀ¨ ÅÀ ?¦$Ý@œbAº^A>¼jAo/AŠSøA•QìA–™šAŒ× AodZA0@¿ >‡®À·¥ãÁ9•Á‡å`Á­¸RÁÍó¶Áé+ Å  Âzá©üœ¬Â$TþÂ'ÚÂ*:^Â+Š=Â+å`Â+iyÂ*6FÁ¡n˜Á›•Á“ÎÙÁ‰Æ¨ÁzA‰Á[%Á5/Á9XÀ§®¿ÁG®@(A‰@â—A:ñªA£×A¢§ðA½AÎõÃAÓýôAÊvÉA±—AŠZA.éy@j~úÀ|ÌÍÁ4E¢ÁŽ~úÁº²-ÁÞÈ´Áü33 XÂÊÁÂÈ´Â%k…Â+±'Â0“uÂ4{Â6C–Â7:^Â7¬Â6hÂ4@ƒÁ­“uÁ¨;dÁ ÄœÁ–ÂÁ‰¼jÁrjÁIKÇÁ33À¶È´¿¬ÌÍ@g+A\)Ann˜A¦SøAÒïžAùB öÉBPB …Aú33AÉ¡ËAˆó¶@ùG®¿úáHÁ3 Á™£×ÁÍ Áô©ü ·LÂW Â!6FÂ*·LÂ2ÙÂ9{çÂ>„ÂAïžÂCÏßÂDIºÂCŠ=ÂAÅ¢Â?/Á»õÃÁ·…Á°ÎÙÁ§QìÁšp¤Á‰Ág‘hÁ1 ÀÜ‹D¿ñG®@}‘hA)\)AŽ“uAËoBIºBöÉB2E¢B<¾wB:ŒJB*LÍB záAÆáHAM™š>ŒIºÁ81'Á«•ÁçSøÂŠ=ÂÁ‰Â$?}Â/iyÂ9}ôÂB:^ÂIG®ÂNp¤ÂQ­ÂSÂRÞ5ÂQH´ÂN—ÂK DÁÌÒòÁÉÆ¨ÁÄffÁ¼bÁ° JÁŸ~úÁ‰l‹ÁY‰7Áí‘À\¼j@R~úA2bAŸn˜AëXB\BATþB_k…Bqt¼Brí‘Ba‰7B=¬B ;dA™C–@8bÁEãTÁÈ J—ÂñªÂ(}ôÂ41'Â?—ÂJm‘ÂSïžÂ[xÕÂ`³3Âc”{ÂdJÁÂc!ËÂ`qªÂ\’oÂWÖÁàXÁßKÇÁÛõÃÁÕŸ¾ÁËn˜Á¼ZÁ§"ÑÁŠZÁHÌÍÀÎùÛ?Š=qA!‘hA£‰7Aÿ"ÑB0Ÿ¾Bb7LB‡\B•ÌJB™½qB‘F%By>wB:È´AÚ…@ÈZÁ\VÁóOßÂ!MÓÂ25?Â<šÂFjÂR-Â^bÂhŠ=ÂpbÂu³3ÂwöÉÂw¥ãÂu1'ÂqhÂk¸RÂeˆ1Áö§ðÁøOßÁ÷Û#Áô‰7ÁíbNÁá7LÁΑhÁ³²ÁޏÁ7KÇÀR\@×…A’‹DAùKÇB6 =Bv¸RB›yÛB²ÖB»´9B´ô¼BŸ.˜Bw^5B 7A9®Ávå`ÂuÃÂDaHÂN¾wÂSÂ[›¦ÂhÂu@ƒÂ€cT„’ò†ð!‡P†§m„Ó‘ìÂ{öÉÂt =Âæf xÕ . ²Â G®ÂŠ=™šÁêÙÁÉ&éÁ˜IºÁ)%>‹Æ¨AH^5AÆß;B®Bf|îB¥|îBÊÙšBÙþwB׆%BÄöÉB¡_;BYãTA¤¾wÁr°ÂJJÁÂx PÂr‰7ÂnC–ÂuÂ/ˆƒÂŽ´9Â’ß;”ƨ””þÂ’¦fÂhö‹E†“u˜ÂØÂ™šÂÈ´Â!ýôÂ#¶FÂ#NÙ 7Âê r°Áï¾wÁ­× Á°!@C33A7¸A?KÇAÐB•üjBÕñªBꜬBò/Bì¼îBÑÔ{Bœ/B—Á…áH€Z—F¨Â‹»d†“u‰ÌJ‘/™ JŸqªÂ£J=¤cT£%Ÿ·L› 7•}ô€‰[#Â% PÂ,qªÂ3²-Â:gmÂ@ PÂDÂE¤ÝÂD[#Â?gmÂ4C–ÂöÉÁÅ|îÀèÔþÀ¸Áÿ—ÂÁ‰B7[#B¿49BÜ÷LC9XC ¢C ¢BéÛ#BˆŽÙ¾Å¡ËÂjì‹Â™µÃ–ÎÙ––›,‹Â£ß¬ Á²hsµž5µŠÁ² B­–‡Â§+Ÿýô˜ˆ´Â‘/Â5LÍÂ?ÎÙÂJ¾wÂU¾wÂ`@ƒÂiPÂpúáÂv^5ÂzɺÂûçÂ{˜“Â7\Á?\)@ÒòÁ¨|îÂTožCúCúB±!ËC—LC5žC³33CúCúB¡.CpÜjC³–Cq¥ãChDœC"1ªBDáHÁâ9XÂs®›e`­s¶Â»aËÂÈ÷ÏÂÔßÂÚæfÂÜ«…ÂÙ BÂÒÐåÂÉ‘h¿þ´?}©¢NŸåÂWxÕÂi{çÂ}´9‰÷Ï•À¡z^«ó¶Â³™·µ6FÂ¥MÓÂqªBŒ+C -ÓB¾¦Bgm?á&éA“uB¾}qCúCúCzÛdCAÐbBöéüB%Å¢Áe®ÂO{ç™å`±÷ÏÂÄÿ}ÂÖÜ)Â䯍ÂìܬÂîiyÂê ÇÂáNÙÂÕ÷LÂÉ€ƒÂ¼ð!°áËÂ¥¢NÂhH´Â~záÂŒ嚬ªɺ»„ÂÊáHÂÕm‘ÂÖ%`ÂÅĜ”)yÁ9xÕBìcTCVˆöC‰B„æéBG®B-¾wBÍë…CúCúC6p!B÷u?B…Û#Aƒë…Á¤éyÂF…ÂŽúá® BÂÉ 7Â߃Âð¤ÝÂú„Âü[#Â÷!ËÂìæfÂßß¾ÂÑÐåÂÃß;¶¬‹Âª€ƒÂwë…‰!H˜Á‰Â«%`ÂÀKÇÂ×iyÂíýôÂþ¦fÃc×ÂêZ°yX›¦BO(öBá B¿­‘BŠ™šB[ÒòBP;dB† BÃò-BãÀƒBØàBB¤ó¶BKÇ¿F§ðÁë ÅÂK•ˆ½q©r°ÂÇöÉÂâÂö,ÃûdÃH´Âÿ+…Âô6ÉÂæB Â×G®ÂȆ%º¤Z­ès‚¿}‘ƨ£ÿ}ºbÂÔuÃÂòî˜Ã •?Ã)ºÃ½qÃÌ‹ÂéI7‘ž5Á˜Æ¨AÏ;dBDbBs“uByl‹B.„ANvÉ@‰OßB¡ËB•¦fB|”{A¶(öÁ>b ÏßÂN ÅƒùÛ¢{çÂÁå`ÂÞ_;Âô­‘ðÃìÆ%ÂöZ Âèt9ÂÙlÂÊß¼ŽV¯°¤ÂˆÙ˜}¬¹XÂÅ·ÏÂä~wÃÌ‹ÃÊÃ-œ)Ã7WÏÃ-’-ÃÇ+ÂÕúáÂ|áHÁª%A| JBEt¼B‰$ZB —ÁþýôÂGùÛÁ§ðAùŸ¾Aä~ú>Ï\)ÁÀt¼Â šÂN>wÂ|ð¤Âš[#¸ÿ}ÂÕó¶ÂíÂû‡+Ã.VÂüÍPÂóKÇÂæl‹ÂØ5ÃÂÉõüdZÂ¯ÓøÂ‹™šÂœÏß²¦ÂÌ£×Âí´¼Ã $œÃ"½qÃ: ÓÃGXÃ?ãÃ$ñìÃ͑µçðÂQyÛÁs÷ÏA¡\B¶FÁ¡ÎÙà {à A˜:á¾wÁÆ{Áõ JÂŒJÂ2éyÂL¥ãÂr\)Â’¹X¯™ÂË5?Âá‹ÇÂï÷ÏÂõ«ÂóŸ¾ÂëçðÂàÖÂÔ =ÂÆúáºQì®nÂ-žk³¨sÂÍùÛÂî†%à ÿ¾Ã!€ÅÃ7ÃC%ãÃ=|)Ã(w à LÍÂÖ&f—e`Â>ožÁÓß;ÁÐ"ÑÂwçmCúCúà Œ½-Â"ÑÂm™šÂP-ÂBe`ÂK JÂjâNÂ#§‡®ÂÀr°ÂÔ§mÂâÂè$ZÂçxÕÂá«…ÂØŠÁÂÍ¥`ÂÂ/¶«…«·ÏÂŒÒòÂcT±†¨ÂÊ =Âç¢ÑÃ*âÃ)žÃ2IyÃ.Ò-ÃÝôà :^Âä޸¸âN—Ñì‹¶F¡B ­–CúCúÃ2¥ÃÚ ÂÏÎÙ¡ÓÂ{Ý/ÂRl‹ÂOoÂj­Š߾¢o·V‡ÂÈ€ÂÔ7LÂÚÂÚF%ÂÖ!HÂÎéüÂÅݲ»ô¼Â±Û#§ûdŠƨš/¬c×ÂÂåÂÛYšÂ÷³3à mÓÃáËÇmõ?îÃ\ÂçÖÂÍl¿œ¬ÂÈffÂôyÛÃ! CúCúÃ7S¶Ã,‹Âú(sÂÀؓ’ó¶ÂmïžÂaœ¬ÂvOßÂŒß;Ÿ­°\¾(sÂÇ­ÂÌ´¼ÂÍkÂÊ}qÂÄڠ½s¶Âµh¬JÁ£…‡bÑ•,‹Â¥49·¥`ÂÌ[#Ââˆ1Âø6FÃúáà ÊÁà /\ÃŽÂõ¶FÂãÓÂÖŸ¾ÂÕ¯žÂèÏßà 9šÃÃCúCúÃ[¤œÃ2õà ô9ÂØð¤Â©#T‹nÂuÆMÓÂ’1ªÂŸ’ò«Öµ¼î¼í‘ÂÀéüÂÁ¤Z¿yÛ»¨Â´÷L­çm¦Tþž›¦Âƒ\Â-‘œèö¬8Õ¼ÌJÂÍÕÂÝÖÂê£TÂñó3Âò}ôÂìêÂãÍPÂÚüjÂ×oÂÝ[#Âó÷LàÃ9I7CúCúú^Ã@sÃÁHÂçž5»—Ÿ­“6ÉÂ’‚ ˜<î 4¼Â¨øÂ®Ö³àB¶¸Õ·0!µk±ɺ¬ ¦È1 ?}™wLÂ|[#ˆ«…”DœÂ Ôþ®ƒÂ»#ÂÇÂШöÂÖ—ÂØZÂÖ…ÂÒܬÂÐ\ÂÑoÂÚÎÙÂð™à P¤Ã/‰7Ãl BÈK…Ãa)Ã0¥¢Ã Â雦ÂÅ2°Â­ß ›¦fœµÃ bѤÒò¨ûd¬/žÂ­ñªÂ®ƒÂ¬`Å©G®Â¥ŸäZš9Û”CÂr¦Â‚å‹ÍP–‡Â ™šÂªÑì´ P»†%ÂÀž¸ÂÃ+…ÂìÂÃ[#ÂÄ\ÂÈ´ÂÑɺÂãñ'ÃÃ%Ã, ‹Ã6°bÃ+ýqÃ#Ã=²Âá"NÂŲ-²<î¦9X Ròž²-Ÿß¡ŽV£¾wÂ¥xR¦E¢Â¥ãפDœÂ¡ÂÉ7™V”`ŬÂgÚÂwIºÂƒÑìÂŒI7”Æ%œéü¤@ƒÂªYšÂ®æé±çð³ŢµZ·Ý/¼ÀÂÅ|îÂÓO\Âæ¨öÂýêà ›#Ãl‹Ã ÏÃòÂê]²ÂÓhs¿ýq±'ð§´Â¡ßžB ŠÁÂô9ž¿}Ÿ\¬ÂŸféž Åœò°ÂšdÝ—øÂ“%`ÂŽÄŠÂ]å`Âk#×Âxò°Âƒ‚ŠyX‘)—!HœI7 p¤Â£¦é¦=ô¨É7¬h°öF¸AÂÂc×ÂÏÂܾúÂè(öÂíp¤Âêˆ1Âà¨öÂÓ‰ÂÄz^·4¼Â¬V‡Â¤LÍžúá›æfšk…™äݙޙœ¬Â™˜–DœÂ“Ü)ÂØÂRò‰iyÂ…9ÛÂTožÂ_ÚÂkš Âwr°ÂŠ=‡uÂŒ'm¢N”u׵Úž5Âå¡ ÁÂ¥‹Ç«wL²ãT»gðÂÃë…ÂʶÉÂÎÂÌÑìÂljºÂ¿ŠÁ¶bN­vFÂ¥²-ŸŽÙ›!˘7Ï–t¼Â•n”À”“0¤Â‘äZ¦ÂÏß‹ 7‡ؓ„Ro€ÓÂK‘hÂUzáÂ_“uÂi®Âs‘hÂ}‚áH†ÙŠbNÂb‹Ç“”þ–öÉš÷ÏŸÃÂ¥NÙ«A°çðµSu·›#·@´^5¯²Â©ÓøÂ£àBžhs™Ô{–IºÂ“¹X‘ò-±'²°ÂŽº^˜“ÂŒ+Š^¸Âˆ-Â…™šÂ‚¯žÂ~ùÛÂx&éÂCSøÂKþúÂTÄœÂ]Âf DÂn:^Âuì‹Â} DÂËD„Õ‡Á‰ÂжÉÂàÅ‘e`•SøÂ™™Âó3¡ó¶Â¥h¦ÎÙ¦äÝÂ¥[¦Â¢‡®Âžß;šê—“¼jÂöFÂŽÊÁ¾‹ÎVЍö‰†%ˆB †Ä„üj‚äÝ€~wÂ{ ÅÂuÊÁÂo”{Â;´9ÂCYÂK JÂR²-ÂZ.ÂadZÂh>wÂn±'Ât¿}Âz|î€1‚ÕÂ…¾wˆÖÂŒ;‡+’޸•áH˜=ô™­‘š¢Â™G®Â—¡H•UÂ’·ÏÂo²‹xR‰«…ˆ+†àBÂ…®˜Â„xRƒ&f¤ÝÂÏßÂ{ÖÂw[#ÂriyÂmbÂgcTÂ4©üÂ;vÉÂBIºÂI\ÂO³3ÂV!ËÂ\LÍÂb.ÂgÇ®Âm'ðÂrgmÂw¢ÑÂ|ô¼Â6É„†Òò‰‚ ‹åãÂÍPÂVÂŽVÂMPÂŽdZÂŒúá‹C–‰p!‡¦é†„…¢Âƒ2°Âûd€ÌÍÂ'ðÂ|‚ ÂyŠ=Âv1'Ârm‘Ân?}Âi­ÂdÂÂ_ŽVÂ.)üÂ4BÂ:]/Â@l‹ÂF_;ÂL+ÂQÖÂW%ãÂ\TþÂaXÂf>wÂk“Âoó¶ÂtÔþÂyµ?Â~xÕÂyÛƒvÉÂ…u†6F†ÎÙ†ۦ†k…Â…–‡Â„{dƒ:^Âî˜Â€©yÂ~çmÂ|™šÂz[#ÂxÂu¶FÂs¾ÂpA‰Âm\ÂiƒÂeœ¬ÂaaHÂ\ÚÂXoÂ('ðÂ-¨öÂ3)üÂ8 ÅÂ> ÂCDœÂHaHÂMTþÂR ÅÂVɺÂ[YÂ_ÖÂdF¨Âh«ÂlùÛÂq²ÂtùÛÂxe`Â{:^Â}TþÂ~¢Ñ¾Â~Û#Â}ô¼Â|“uÂzß;ÂxüîÂw1Âu JÂs PÂqÂnäZÂlž¸Âj#×ÂgffÂd`BÂa JÂ]jÂY€ÂUQìÂPë…Á€&éÁt›¦Áf—ÁV{ÁBí‘Á-VÁ~úÀòÙÀ¸jÀu¡Ë¿ï =™™š?ó33@`b@˜Z@±ó¶@¹hs@¬(ö@ˆí‘@ß;=ÎÙÀ3oÀÁVÁhsÁN“uÁçmÁšÂÁ±n˜ÁÅÆ¨Á×ÔþÁç¾wÁõ¡ËÂÏßÂæf ²Â |î PÂÝ/ÂøÕÂqªÂYÁ…®Á~í‘Áoº^Á]…ÁHÁ/ =Á‡+Àå‡ÀžÀƒÀ&ff¾ C–@E¢@—¥ã@ÜÔþA ÄœAA‰A&ZA!¸A hs@Ö‡+@pb> IºÀyÛ#Á“uÁF$ÝÁƒVÁ C–ÁºE¢ÁÑ Áå =ÁödZµ? %ãÂbÂþúÂwÏÂ+º^£×ÂØÂk…ÁŒ…Á† =Á{çmÁh¬ÁPMÓÁ4$ÝÁ\)ÀÛÆ¨À‡¾w¿®¸R?Ú¬@›ÎÙ@ÿÎÙA.vÉAV ÅAs33AA|îAiº^A@‡+A™š@që…¿«Æ¨ÀÖ^5Á>Ý/Á†“Á¨^5ÁÅõÃÁßC–ÁôñªÂÏß Ü)»dÂxÕš ¤ÝÂ##×Â$©üÂ%JÁÂ%!ËÂ$IºÁ”çmÁŽVÁ…ë…ÁvÄœÁ\ÙÁ=‰7ÁVÀÙÒòÀl¼j¾`A‰@e¸@ó A:£×Ay¸A˜7LA­§ðAº+A»bNA¯´9A–¾wAc&éA\)?ß;dÀ£+Á:vÉÁŒ=qÁ´IºÁÕvÉÁðçmÂýô âNÂl‹Âº^Â#ËÇÂ(²Â,0!Â.\Â/ÎÙÂ0 JÂ/iyÂ.+ÁŸ“Á˜°!Á33Á…A‰Ánå`ÁL¼jÁ#33Àã+À]Â?3÷Ï@«¶FA&È´A{/A§`BAÍÈ´Aí&éB¾wB‡+Aû+AÜë…A­—Aa\)@¯;dÀY™šÁ;•Á—IºÁŶFÁéûçÂZÂ@ƒÂˆ1Â"‹DÂ*PåÂ0Á‰Â5ÄœÂ9SøÂ;záÂ'ïžÁ]"ÑÁǰ!ÂöÉÂb SøÂ+oÂ5¶FÂ@ÂI>wÂPÅ¢ÂV:^ÂYŠ=ÂZÓøÂZTþÂX[#ÂU49ÂQ)üÁËKÇÁÇÀƒÁÁ²-Á¸l‹Á«“Á˜´9Á€oÁ?©üÀÚ$ݾ±©ü@ñÂA‡ffAÝ9XBËÇBNí‘B}ß;B’-‘B€BÖB‘aHBq“uB,vÉA¶G®@G®Á‚ ÅÁù&é‘hÂ*üîÂ2OßÂ;7LÂF>wÂQÜ)Â\ffÂd¿}Âjk…Âm_;ÂmÙÂl=qÂh÷ÏÂdp¤Â_+ÁßhsÁÝýôÁÚ¬ÁÒûçÁÇ¡ËÁ¶× ÁŸ¸Á}?}Á&ffÀT(ö@µxÕA…p¤AíQìB1¼jBr[#Bš&éB·;çBÊKDBÎ;dBÀ¨sB¢BBl B8R@q©üÁŸÂ.¸ÂNöÉÂG²ÂEÍÓÂLˆ1ÂXÒòÂf§ðÂs+Â|W ®‚'ðÂÆ¨Â€/Â{^5Âu‡ÂmúáÁö‰7Áø1Á÷IºÁót¼ÁëzáÁÞÁÉA‰Áªó¶Á€oÁ ãT?ž¸RA\jAæß;B9BB„ß;B²\)BÞQhBü‰ºCÄÝB÷ŽÙBÔ!HBžøÕB8oA 1Á¹›¦CúÂŽÙÂf‰7ÂZ}ôÂ_÷ÏÂnë…ÂäZ‡5ÃÂŒG®ÂŽô9Âp!ÂŽ;‹q'‡ÎVƒ\Â}ñªÂaH  Ţ 49 ÂÂÀƒÂA‰Áè1ÁÂ;dÁ‰r°ÀÜ@à›¦A½å`B(B}B»Ö‡C#CSøCÁCC-PBÒ 7B‡bÑA²VÁúMÓ®õ?­¹Û‡Ê=Ât;dÂy#×Â…Æ%Âéy˜“ÂC–ŸWž¾wœ\—çðÂ’ÏßÂ33‡`Å  D ŒJÂ$¬Â&49Â&-Â#>wÂ^5¸RÁò¾wÁ¤(öÀ õÃAZ=qAâáHBéyBybC(sC3ØÕC.PbC)}CBC‚NBư!B-®Â<‡+CúÉü£wÏÂŒº^ÂŽÊ=™.¤]²Â¬àB±ŒJ²m‘°'m«‘hÂ¥{dž‘h—PåÂbÂ' DÂ/Â6÷ÏÂ>PÂEC–ÂJ‹DÂMå`ÂOÂNÂHdZÂ0wÏÁÏ?}?XQìA<ýôÂVÎÙCúCúCJ÷LClÍC"Þ5C6ÅC4LJCˆöB¯<îÁ±%Ãi7Âôì·&é¦þ§ڠ²ff½¬‹ÂŶÉÂÉ,‹ÂÈ$Z ¼j³éüªÐ塬˜ÑìÂ8IºÂC½qÂOèsÂ\}ôÂiÂtêÂäZÂ…bÑÂŒÓu›î˜Â·49™ ÁÁéyA— JÁ§ðCúCúCúCúCúCUÃCxÄœCrNCFZCúCúCú¿¼jÂÀÍPÂÄ=ôÂÏœ¬ÂÚŸ¾ÂáÅ¢Â〃ÂßêÂØB ÂÎ{¸շ#T«éy¡[#ÂJdZÂYâNÂkoÂ}ֈ¾úÂ’¼îœwϦ6ɳ8RÂÓŸ;Ã/—LCú?VB‡¶ÉB\ƨCúCúCúCúCúC‹M²Cžg+CúCúB†üîCú–çmCúÂÏýôÂÛ¹XÂëwLÂ÷ãTÂþò°ÂÿÂø‰ÂíV‡ÂߨsÂÑ(öÂÂð¤Âµ’ò©OßÂ\Û#ÂpâNƒò-ÂûdŸY®t¼Â½3¶ÂÊ@ÂÕvÉÂå%à ‹…ÂòÀƒCúCúC ÿ¾CúCúÂDûçCúCúCúCõÃCúCúBBÀÄÌÍCúCúÂ×ð¤Âè¿}ÂÿÀÚà \à ™šÃí‘ÊÁÂïÖ‡ÂÞ:áÂÍxR¾#°J=Ânüîƒð!Â’³¶Â¤øÂ¸“ÂΚÂäÂöÂý«…Âòn¿·ÏÁšÔþCúCúCúB¨œ¬Bš Bˆ1CúCúCúCU?ÃL‹Ã@³3Ã8RÂÊ{çÁõ¾wB  B—…BÙÈ1BéwÏB‹oCúCúAÿí‘CúCØÕBbÁ˜ÊÁÂ3{ÂgɺŠ{d°ã×ÂÞ_;ÃBÄÝïßÊ=ü)ÃìÃüîÂò´ÂÝÖÂ˥㻯¨ŸÈ1·§ðÂÖ\Âÿ-‘Ã…ãÃ=áËÃhž¸Ã„PåÃx«…ÃI ƒÃ(´Â¦€Á«ÌÍB&ð¤B÷ƒCwz^CúÀÁÛ#CúB  CúBÞšA–t¼ÁÐ{Â/äZÂM·LÂv'ðŸƒÂÌ+…Âø$Ýà „œÃ”{È´Ãñìà iyÃ@ÅÂïð!ÂÜ¢ÑÂË-‘»¦fÂŤj½–‡ÂÞ{dÃ.VÃ"÷ÃKŸ}À2NÖ™ÛÃ<ÃeäÝÃ.YÛÂäO\Â\xÕ@öMÓBÁCúCúÂ÷Ñ쯩üÂ/œ¬?R-¿ÂÁÂxÕÂNÙÂ(ØÂ2wÏÂYVÂ<î»wÏÂåC–ÃG®Ã XÃG+à QªÃ‘hÂûýôÂéïžÂØ}ÂÈ`ŹËÇÂ’O\Â¥ïžÂ¾ñ'Âße`øÃ!¯\ÃG49Ãs€ƒÃ‰²°Ã„‘Ãa¯\Ã37ÏÃ=²ÂžéyÂ0!A–33B]ÊÁCúCúCúÂàV¹þ“PåÂqožÂ9m‘ÂMÓ£×ÂB!ˆþ®NVÂÓféÂðÇ+ëÇÃ+Dú^Âý¹XÂð/Âá%ãÂÒßÂó3¶hö‘³¶Â¤p!»ð¤ÂÙÇ®Âÿô9Ã=qÃ5½qÃT{çÃgÁÃb“ÃHÊ=Ã&ÜjÃ)ü¿‡®Â„Á‰Â45?Â#%ãCúCúCúÃ6höõÂâqªÂ¢ÅÂEKÇÁäß;Áî÷ÏÂ6ñªÂ‚ 7¦6FÂÅ<îÂÝr-ÂíZÂôs3Âó·LÂí#×ÂâæfÂÖÐåÂÊ'𽲰±ܬÂ8Õ kµz^ÂÏ^¸Âï Óà t¼Ã•Ã3h´Ã>ìÍÃ<šÃ,–ÃSuÂü¾úÂÑÆ%²ë…¨k¿’òÃsuCúCúÃN¼jÃ(áËÃ}ô¾Á‰Âd$ÝÂ.•ÂEYÂ…²-£²°Â»²ÂÎ1ÂÚ°¤Âá ÍÂáyÛÂÝ%`ÂÕ‡®ÂËú^ÂÁˆ´Â¶çð¬ˆ1‹KDš”þ¬Æ%ÂÂQhÂÛl‹Â÷‘ìà NÃÙXÃÙê=Ãâ Ã\Âð…ÂØÊ=ÂÌ™šÂÓßÂó"ÑÃh1CúÃaÒ-CúÃEšÃ@ÅÂÚTþ”^¸ÂQÞ5ÂG¯ÂmöÉÂbN¤ŢµDÂÂ%ãÂË“uÂÐÀÂÑŽÙÂΠÅÂÈçðÂÁYšÂ¸ÄœÂ¯Ã–¦ÀƒÂ†dZ“«¢ýô´vÉÂÇã×ÂÜyÛÂðm‘Ã`ƒÃòòÃÉ7Ã7 ÂñÙÂâßÂ×ÄÂÖí‘Âåñ'ëDÃ)<îÃvWâ$9CúCúÃËDÂî}qµÐbÂ’‘ì‡l‹Â{™AÂ¥»ç°#׸ÌÍ¿{çÂÃSøÂÄÂÁÙ½eã·Rò°:^¨˜“ ɺ€ò°ÂŒMÓ™+§ 7µüîÂÅ"ÑÂÓ2°ÂÞkÂåÂæ ÁÂâ+ÂÛ ÍÂÔ>wÂÑVÂÖoÂè"NÃ)üÃ&roÃX6ÃyRòÃg¬‹Ã=ÌÍÑìÂòp!ÂNjǫ BžZœŸËÇÂ¥±ªÂ«Å¢Â±W µ¾ú¸C¸ŽV¶¶É³ò®å¨5¡š ÂšÒòÂv¡Ë„ó3ÂuÚ¯žÂ¦H´Â±¨s»ô¼ÂÄ+…ÂÉk…ÂËWÂÊk…ÂÈ¢ÂÆ;çÂÇ–‡ÂÎß¾Â߉Âúß;ÃýqÃ)€BÃ6âÑÃ0ÀƒÃ³øÃÞwÂéÂÊ}qµV¨‡®Â£>w¢½q¤ÎV§æf«u­²Â®ñªÂ®¾w¬ýq©ÚÂ¥˜ …šæé”ûçÂk}ôÂ{ÎÙ†™šÂª˜ÍP¡”{©s3¯Ø´T{¶Ñì··L·ô¼Â¸ès¼3¶ÂÊÁÂÐgðÂ㉺ÂûŸ;à |¬Ãݲà ÏßÃÛçÂñ®ÂÙƒÂÄ»ç´ë…ªr°Â¤¹X¢ŒÍ¢œ¬Â£ËÇÂ¥F¨Â¦p!Â¦ÓøÂ¦-¤ff¡’òÂڠ™qªÂ”‹DÂW Â`ÍÓÂn§ðÂ}%ãÂ…ûçÂT{”NÙš“øÂŸÑhÂ£ÓøÂ¦¡H¨ŒÍª7Ϭ„°r-¶ò°ÂÀ¤ZÂÍgðÂÛÉ7ÂèŒJÂïÓÂî>úÂåYšÂ×èöÂÉV»A‰Â¯÷L§ÌJ¢­‘  JŸ#TŸ0!Ÿ‘ìŸÌÍŸ…¢Âž…œ³¶Âš–Ã’ݲŽŠÁ‰îÂVÀƒÂb•ÂnƨÂ{{ƒ“u‰IºÂŽwÏÂ’ï–›#™Š=›ûçž[#¡6FÂ¥"Ѫ²Â±Ø“º€ƒÂÈ´ÂË.˜ÂÏ€ƒÂÏKÇÂʵ?Âà =¹çð°ڠ¨ùÛ¢ܬž¤ÝœšŢš0¤Â™äZ™„œÂ˜ÌJ—Ó•´¼Â“>úÂ:^ÂŒ½qˆâÑ„ÅÂMjÂWš ÂaüîÂl^5Âv€Â€ P„uÈaH‹ƨޏR‘bN” D— ºÂš³3ŸB¤½ôªև°޸µۦ¸Ï\¹ Â¶½q²Qh¬±'¦ËD¡`Bœèö™”{—På•áË”øR”E“„œÂ’„‘¾ÂE¢ÂŒò°ÂŠ-‘‡¢ÂƒŽV·LÂDÎÙÂM¨öÂV²Â_…Âh1'Âpr°Âx"ÑÂ$Ý‚»dÂ…š ÂˆO\‹¨Âõ?‘H1• Â™aËÂáË¢,Â¥±'§æé¨s¶Â§På¤ɺ¡Tþƒ–™Òò–œ)” ÁÂ’5¸Õ©üÂŽ½ôÂĜŒ™‹ ʼnL͇šÂ„‹D«Â}VÂv`BÂ<çmÂD¬ÂL|îÂTØÂD ÂI49ÂN ÅÂRãTÂWƒÂ\1Â`€Âdó¶Âie`ÂmÎÙÂr²Âv33ÂyçmÂ}\Â…€— ǀÀ€33Â~öÉÂ}TþÂ{œ¬ÂyÛ#ÂxbÂv49Ât8RÂr 7Âo˜“ÂlØÂiÀƒÂfOßÂb†%Â^k…ÂZ+ÂUdZÁ{ïžÁo…Á`¬ÁO+Á:áHÁ#²-Á ¥ãÀÙÂÀ›…À3¥ã¿3¶F?°ƒ@U@¡Â@Ìýô@èQì@ï÷Ï@áV@º-@w|î?  Å¿óoÀ¬¼jÁXÁL$ÝÁ‚/Áœ33Á³¶FÁȧðÁÛ"ÑÁë^5Áù‡+ÂàBÂ\ ZÂƨÂ`BÂ0!ÂG®Â¶FÂ\ÁƒVÁyhsÁi?}ÁUß;Á? Á$n˜Á JÀÇÆ¨Ày‡¿­ó¶?¥`B@~$Ý@ÑÒòAbNA- AB$ÝAJ´9AD‹DA.r°AvÉ@¨Z?¤“ÀI%ÀøjÁDÐåÁ„ZÁ¢ë…Á½ÌÍÁÕ(öÁél‹Áû ¾ ©üÂ-®Â49ÂÈ´ÂyÛÂZÂ|îÂûçÁŠ1Áƒ‡ÁtáHÁ_¾wÁFQìÁ(5?Á À¹ÊÁÀ>¸R>o@]¸@ܼjA$ùÛAWó¶A¾wA‘©üA™¥ãA—ïžA‹záAhQìA%÷Ï@¨A‰¾Þ5?ÀÊ\Á@{Á‰A‰Á­VÁËbNÁäó¶Áú¶Fº^ÂÖÂÊÁŸ¾Â TþÂ#ì‹Â&n˜Â'ì‹Â(}ôÂ(5?Á7LÀ¶Ÿ¾¿ÞÙ@5p¤@ÿPAYÊÁAœ-AËQìAöß;B C–BÁ‰B©üBbNBdZAÌûçA…¥ã@ÖŸ¾À]‘hÁLMÓÁ£å`ÁÓ+ÁöE¢Â¨öÂêÂâNÂ&Ü)Â.ÀƒÂ5ZÂ:€Â> ÅÂ@C–ÂA%Â@’oÂ?šÂ<ɺÁ¨°!Á¢/Á™7LÁG®Á{‰7ÁTÁ"ƒÀË;d¿ß²@mA ‹DA‰;dAÇVByÛB"A‰B<ÔþBO’oBV× BO× B9l‹B‘hAȬA7/À¡ËÁiƨÁÁ"ÑÁõ1 KÇÂTþÂ!¾wÂ+¾wÂ5QìÂ=øÕÂE.ÂJ¡ËÂN5?ÂOùÛÂP²ÂNÝ/ÂLyÛÂI33Á·hsÁ±ÎÙÁ©“uÁžoÁŽ…Át1Á?‡À÷× À ´9@xõÃA8´9A£—Aó°!B$àBBP;dBwÁ‰BŠú^B’qªBÑhBñ'BRÐåBÞ5AŠå`¿ÐA‰ÁÄœÁðPÂC–ÂæfÂ'çmÂ0Š=Â:¾wÂE|îÂOjÂWŒJÂ]bNÂ`ÒòÂbÂaC–Â^êÂ[SøÂVÑìÁÈÛ#ÁļjÁ½çmÁ³—Á¤Ý/Á“uÁj§ðÁ"ùÛÀŒÌÍ@;¥ãA@A‰A·¾wBüîBH;dB‚cTBŸ/B·³¶BÅÇ+BÅ~wB´PB“ÂBLøÕAÇo¿¶‡+Á³ =´9Â7úáÂ8í‘Â8·LÂ>üîÂJn˜ÂW˜“Âc±'Âm+Âsp¤ÂvŠ=ÂvÐåÂtƨÂpî˜ÂkÅ¢Âeµ?ÁÝIºÁÛZÁÖÂÁΧðÁÁïžÁ¯;dÁ”È´Á`¸RÀüÝ/>gl‹A+²A¿ BSøBiÒòBžs3BÉ2-Bï C3ChöBøPBÌÈ´BLJB Å¢CúCúCúCúÂSÓøÂF8RÂKffÂZÓøÂlŽVÂ{÷σ’ò†ۦˆ+‡ožÂ…{d‚‹DÂ}ãTÂuß;ÁôçmÁõýôÁô¬Áð =ÁæáHÁשüÁÀVÁž ÁZE¢À¡ãT@Õ/A°ZB%SøB`BB¸ BBöDœC[çC- PC3†fC'¨öC á‰BÆšBJ‘hCúCúCúCúÂb³3ÂKäZÂUɺÂmÞ5ƒQhÂ;“‰ºÂ–±ªÂ—‡Â•WÂ’ÙÂÁˆØƒ¡ËÂæf p¤Â 1 6F `B¼jÁúxÕÁÞ°!Á³C–Áa+¿Ì‹DAoB-B„=ôBÉ¡HCÂÑC?#C[{#Cd‡mCVÐbC3¿;CáB ƒAÂïžÁLÌ̓–îÂdçmÂN¼jÂe¸Â„¥`”õଋ§r°Â©Þ¸Â¨ÙšÂ¥W 2-š“ˆ1ÂŒÜ)ÂùÛÂ\ š Â$,Â&5?Â%þúÂ"©üÂøÕ Š=ÁäÁ‚j@s Aó|îBqOßBĬC-+C‚"òC†ð¤C‚¹ºCv²CW‡+C+L‹BëT{B_ÚCúCúÂð.Â)yÂjB„ËÇšæf­¤Ýº;ÂÀ=qÂÀó¶Â½™·†%¯Ü)§s3ž޸–z^Â'–‡Â/ÎÙÂ8Â@hÂG>wÂMVÂQ1ÂRùÛÂRÂKQìÂ(©üÁ‡²-A1'BKïžB£Â CúCúC¢·mCuròCoeCrCY&¨Ã:>¸Ã.XÃòoÃG+ÃðbÂèܬÂÓr°ÂÁ1ªÂ‚r-Â’™šÂ¦ÄœÂÀ"NÂàÙšÃ"NÃ/®˜Ã;p!Ã4bÃ%¢ÂÜÇ+Âb‡+BZYBÅŒÍCýôBÌ©üBhCúCúCúCúB¼_;Cú‚ÊÁšm‘CúCúCúCúÃ'ðåÃ>¼jÃI^¸ÃE¥ãÃ8FÃ&ˆöÉÃI7Âï›#ÂØÑhÂÅ’òŠ;dœáH´ÍPÂÔ\Âý‘ìÃŒÍÃ>å¢Ãi ÅÃ3uÃyþ¸ÃOéyÃå` ÔþÀ;dBŸoC4p¤CúCúCúCúCúCúCúA˜ùÛÂ<‹D‚¡Ë„Ÿ;Ây&éµ;dÂÿp¤Ã ü)ÃVCúÂ;RòÂF¼j–‹ÇÂÞùXÃ[#Ã/¸“Ã>VÉÃ>ÃÃ3[#Ã#ì‹ÃÜîÃÛÂðm‘ÂÚXÂÇ|j”/©¸RÂÆoÂì’òÃu?Ã9²oÃyB õÇmCúÃçæ ‘Cúû爞¸AlvÉC ‘CúCúÂ,¹XœùÛÂ!Ÿ¾A ÅÀµÛ#Â"SøÂYèsCúÁõ§ðÂâN =ÂÅKDÃ|îÃDÃ+ˆöÃ-’oÃ&‡ðÃÂà qÃï\Âêî˜ÂÖ¾úÂÅ(s•´9«,‹ÂÇEÂí¸ÃóøÃ7>5Ãpí‘ã¤9ÃÎîwû5¢Ãš:Ãrï\Ão\±åãÁÖ{B41BñݲAT¼jCúà öà £TÂø£×ÂÏ Ó¢cTÂ0gmÁN5?ÁVÁëõÃÂl›¦Â³/žÂêNÙà £×Ãg+Ãý²ÃQ'ÃB ÃNVÂö¸Ââ­‘ÂÐò-ÂÁì”æf©NÙÂÉºÂæÃ '+Ã)Ú^ÃU2òÅԜÛ#×Ô.úÃz¶ÉÃH¯\ÃßÂÉð¤Âs’oÁÞãTÁM7LÂ;ØÃ§ðCúÃMG+Ã5kÇÇ·=ôÁ“í‘B33A‘ƨÁ“ÂiŠ=©³3ÂÕ‡Âö¢NÃò-à éyÄÝÂøªÂè¼îÂØÌÍÂɪ»¯žÂ’¤²°Â»ùXÂÙp!ÂþýqÃGmÃ43uÃRÄœÃfÑìÃaõÃI^5Ã)jÁÃDZÂÔõ?¦}Š÷Ï™šÂư¤CúCúCúÃ:†%ÃR-¼=ôÁU|îBAß;A÷ÏÁîMÓÂ|Ròª>úÂÈvÉÂßô9Âðr°Âø2°Â÷àBÂñ}ÂçJÁÂÛ/ÂÎE¢ÂÁ’òµwÏÂÞ)ü²1ÂʲÂçhÃsuÃß¾Ã'ѪÃ1ÂÃ/ñ'Ã#bÃáËÂú ÇÂ×G+¿õ?ºB ÂÌþwÂùÅ¢CúCúCúÃRþ5Ã!û#ÂÚÂQÁ]VÁ¶ ÂG‡+‘;±8RÂÁÂÏH1ÂÛ‰Ââ“ÂâÏ\ÂÞÈ1Â×qªÂÎ#ÂÃɺ¹49®Ï߈n˜Â–‹D§ߺ;dÂÐÂç»çÂÿm‘à ¬JÃ>¸Ã£×Ã,‹ÂûþúÂåæéÂÓÕÂË]/ÂÒ%`ÂîÁÃÚCúCúCúCúÃ&ˆsÂôýô­m‘€OßÂuŠl‹Âž¨Â®çm¸¥ã™ÂË ÅÂÐÅ¢ÂѤZÂÎãTÂÉiüÂÂ5¹ °ì¨‚”þÂŽˆ´Âœh«'ð»~wÂÌMPÂÜ/ÂèÅÂïéyÂðÂéÉ7ÂßO\ÂÔ6FÂÌŠ=ÂÌbÂØÙšÂ÷ ÁÃ!‰CúCúÃeßÃBÓ¶ÃàÂùäÝÂÊ…«bŸƒÂžñ'¤NÙ«|j²xR¹–¿¡HÂÃÂÜ)ÂÁq'½!H·B°aH¨ñ'¡JÁÂy-†¡H‘«ÂÓ©î¶&fÂÁ:áÂÉó3ÂÏ+ÂÐRoÂÍÕÂÉ+…ÂĘÂÂÕÂÆÔþÂÓ˜Âì Óà Hà ßÃ/ŒÍÃ.%ÃøRà “øÂîféÂκ^¸C«®§ P§nªz^®}²¤Ý¶·üj·ïµøR²]/­|j§¶F¡`ÅšÖÂmm‘Â~G®Âˆ*‘²Â›+…¤YšÂ¬‡+³œÂ·C–¹¸Ý/·’o¶­‘·ñªÂ½4¼ÂÈÂÙÂðˆ1Ã!à Ïßà î˜Ãü¬Âô6FÂÜÍPÂÇï·Ü)­vɨB¦ë§ès©éy¬ò­ȴ®„­ó3¬%¨ۦ¤­ŸºášDœÂ”‰Âb>wÂpožÂQì‡H´ÂŽÖ•ûdœSøÂ¡|îÂ¥4¼Â§uèb©-‘ª?}¬Þ5²º§mÂÆž¸ÂÔÖÂâ%ãÂêÄœÂë¾úÂåVÂÙ%`ÂËb½‚²NÙª`Å¥ƨ£ã×£ɺ¤\Â¥ƒ–¦'ð¦¸Â¥-£=ô ^¸Âœ±ªÂ˜aH“œ)ÂŽŒJÂWÎÙÂcØÂpBÂ|ƨ„ƒŠDœÂk“¾ú—#T™£T›|îÂ"NŸ-¢DœÂ¦ùÛ­˜µéü¿ ÂÇ7ÏÂÌ–‡ÂÍ»dÂÊxÕÂÃÓøÂ»V² ÅªýqÂ¥1ªÂ¡u?Ÿ†¨ÂžÝ²ÂžâNŸåŸ+ž~wÂKÇ›\)˜´¼Â•iy‘˜ÂaˈåãÂN.ÂX{çÂbúáÂms¶Âw¡Ë€š„ð!ˆµÃ‹޸Žzá¸RÂ’âN•YšÂ˜~wœ›¦Â¡Ç®Â§Æ¨Â­øÕ³k…·¸C¶Ã³ Ó­ò-¨hs£H´ÂŸ'mœ>úšz^™ß™;˜ÍÓ˜Ro—wÏ–)”0¤Â‘¶ÉÂŽ¹Û‹NÙ‡PƒPÂE\)ÂNE¢ÂWF¨Â`33ÂhÚÂq1ÂxŽVÂLÍ‚ž¸Â…>ú‡§ðŠ DÂŒ£×§ð“<î—bN›æé bN¤G+§ ¨)y§ ÅÂ¥Ÿ¾Â¢—Ÿ¬Â›¸Õ˜Òo–œ)•{”øÂ“aËÂ’ÀƒÂ‘ûçÂîÂ{çš‹G®ÂˆŒJÂ…uÂÂ|ýôÂ=MÓÂEšÂLí‘ÂT©üÂ\,ÂcPåÂiüîÂp¾Âu¹XÂzáHÂǮ‚Tþ„ès‡»dŠß;ÂŽKD‘ڠ•IºÂ˜B šn˜Â›‘h›•š™˜Ü)–¶F”}Â’{çÂÑh‡®ÂŽŠ=·LÂŒès‹ùXŠÍÓ‰Rò‡€Â…Qì‚ÎÙ€ÂyèsÂsl‹Â5ò°Â<× ÂC¼jÂJ‹DÂQ+ÂW…Â]ˆ1Âc,Âhr°Âmp¤ÂrBÂwhÂ|+€¡Ëƒiy†Qh‰<eãÂ9X‘U‘¬‹Â‘NÙÂaH“¬ÂŒH1‹ 7‰÷L‰ 7ˆ,‡F¨Â†A‰Â… ºÂƒåÂÏߊ=ÂzéyÂuɺÂp?}Âj`BÂ/9XÂ5`BÂ;…ÂA–‡ÂG„ÂM=qÂR¸RÂWïžÂ\èsÂa®ÂfVÂj÷ÏÂo¬Ât‚ Ây{çÂ~†%¼î„ P†o‡ªˆ¿}‰G+‰J=ˆß;ˆ%ã‡@ƒÂ†MPÂ…^5„{烢тÈ1Âܬ€ÐåÂ0!Â|PåÂxúáÂu(öÂpãTÂl2-Âg%ãÂaÎÙÂ)VÂ.˜“Â4 ÅÂ9˜“Â>ô¼ÂD+ÂI33ÂN JÂR¸RÂW@ƒÂ[²-Â`šÂd…ÂhûçÂmyÛÂqî˜Âv”zá@vÉ@‘V@ÊÐå@ø“A 5?A ß;A…@àÄœ@p¤@\)¿Ÿ¾wÀžñªÁ ÎÙÁKPÁƒoÁõÃÁ¶oÁËjÁÞ1'Áî£×Áüýô±' ô¼ÂOßÂÈ´ÂhsÂ;dÂNÙ´9€Á€÷ÏÁsïžÁbí‘ÁN“uÁ6\Á§ðÀõp¤À­¡ËÀ<Ì;ß;@!‡@«+A\)A(ýôAIp¤A_Ah ÅA`å`AH~úAo@̼j@§ðÀ)&éÀò5?ÁEÎÙÁ†^5Á¥ïžÁÁbNÁÙ1Áíp¤Áÿ$ÝÂA‰Â ß;Ât¼Â%˜“Â33ÂãT »d Ðå r°@ÉãT=ùÛ#ÀÇdZÁDbNÁbNÁ²33ÁÐÙÁê`B TþÂs¶ÂvÉÂ_;Â#&éÂ&ÊÁÂ)PåÂ*ɺÂ+LÍÂ*öÉÂ)äZÁƒÁ‡õÃÁ|°!Ád°!ÁG7LÁ#•Àò=qÀް!¿`ƒ@J~ú@ó|îAE…A‰…A®ùÛAÐA‰AêAø¡ËAù1Aé$ÝAÈ‹DA˜¾wA:^5@Y&éÀŸ¾wÁKïžÁšÌÍÁÅ JÁæ1Â'ð "ѸRÂ7LÂ$¥ãÂ*êÂ/ë…Â3š Â5úáÂ7!ËÂ7.Â6G®Â4“uÁ™r°Á‘ñªÁˆ¬Áw ÁW?}Á/ïžÀÿ÷ÏÀŒÌ;¬@˜záA%/AƒhsA¶õÃAê“uB 6FB ɺB-C–B0\B'ZB”{AådZA”\)@èÀƒïžÁdáHÁ³9XÁáñªÂ\) ²-Â!ËÂ!³3Â*˜“Â2–‡Â9YÂ>¡ËÂBTþÂDwÏÂE&éÂD‘hÂBéyÂ@dZÁ¥PÁžt¼Á”ÄœÁ‡ë…Án‡+ÁD$ÝÁ =À› =ó¶F@Á¸ANÝ/A¥õÃAêVBÖB;C–BY¾Bn JBu¸RBlÝ/BR5?B&øÕAÝxÕA=dZÀ‚éyÁG®ÁÞÂÂñªÂ5?‹DÂ&uÃÂ/í‘Â9‹DÂByÛÂJ ÂO±'ÂSaHÂU ÅÂU"ÑÂS¬ÂQÂMqªÁ´$ÝÁ­çmÁ¤ß;Á˜ZÁ‡ƒÁb´9Á)p¤ÀÁG®¾°£×@Õ¸Aq²AÈ ÅB$ÝBB ÅBsöÉB×B¢J=Bª©yB¦ó3B•ÌJBp{B Ç®AŒ-À°ZÁÊ\)ÂDœÂ'­Â+NÙÂ.¾Â4§ðÂ>œ¬ÂIïžÂT¥ãÂ]ožÂc¯ÂgF¨ÂhhsÂgm‘Âd¿}Â`ÄœÂ[ØÁÅ…ÁÀº^Á¹1Á­¡ËÁxÕÁ‡KÇÁS‡Á¬¿÷®@Å©üA‚²AåÊÁB-¨öBp\Bœ.B¿;çBÜJÁBí!ËBì´BÕñ'B¬EBg”{AÉ©üÁVÂ÷ÏÂ]-ÂT=qÂCŒJÂ;LÍÂ?ÄœÂL‹DÂ[ÖÂiÈ´Ât…Â{uÃÂ~½qÂ~Û#Â|l‹Âx\ÂrQìÂk©üÁÙó¶Á×SøÁÑÛ#ÁÈ™šÁºZÁ¥•ÁˆOßÁ?ûçÀ¥p¤@{ƨA}`BAø¸BGBB˜BüjBù"ÑCž5C$÷C(ÏCÞúB÷PB¦½qB“CúCúCúÂz}ôÂTÂÂ<…ÂC2-ÂXÓøÂp)ü°!ˆ\¬ÂŒ¾Â[#ÂŒ‘ìŠF%†í‚å`Â|ò°Áñ§ðÁò{ÁïçmÁê¬ÁßdZÁÎÁ³©üÁ¬Á+²-¿z^5AH-Aôß;BX1'B¦îBî ÓCÓøCEz^Cd¶Cq(sC^èsC0—LBî<îBaCúCúCúÂ…²ÂJuÂ!¦éÂ;¬ÂeJÁ„üjÂ’²Âš%`ÂÚž)ü›ýq˜¬Â“)üŸ¾Â‡Ô{ÂaHž¸Â Ñì vÉÂãTÂ33Áî\)ÁÎoÁ›ÐåÁ =@˜“uAÎ%BXŸ¾B¶kC ìCDYC}ªC—ÏžC©ù7Cž/Cq­‘C#ƒ–B³t9A”Ý/CúCúÂI~úÁÊí‘ÁÃSøÂ0ØÂ{ D—Ñh¨Y±³æé²iü® 7§áË È1™NÙ‘Ô{ ÅÂyÛ´9Â!ØÂ#A‰Â"#×Âp¤Âœ¬Â½qÁÂ÷ÏÁéyAcçmBA+B¹½qC~wCmÈöCœ„œC´ÁªCÎ×LCÃQ‰C“ÁHCPBCÃBsÜ)CúCúCú@%ó¶Á”ýôÂIæf•^¸Â´ÓuÂÆí‘ÂÎØÂÏJ=ÂÊ«ÂÂó¶Â¹ B¯´9Â¥ÑhœSuÂ&|îÂ.“uÂ6®Â>hsÂE5?ÂJl‹ÂMn˜ÂM·LÂJ33Â<× ÂTþÀÌA‰B"ÑB­éüC!CŽgmCºüîCµ`!C¹n5C¶¿;C¢9šCz¯\C,oBºž5CúCúCú ÍÓÂ:cTÂñ'¿ÁÂßÂïð!ÂôÎVÂðÕÂçB ÂÚ¿}ÂÍ,¿­‘²ãT§òÂ8ÖÂDÅ¢ÂQ³3Â_H´ÂmuÂzŠ=ƒ·LŠiü“_;¡KÇÂ¥XÂõÃB‚ B’e`C ÙÛC}(öC‘boCúCúC¨ ÇCúC—ßCKQìBÕÞ¸CúCúCúCúCúÂÏÒoÂýå`à ‘hÃ/žÃèsà n˜Ã1Âõ%ÂâœÂÐ7LÂÀ‡Â±¶ÉÂL¬Â\¼jÂo‰7‚=q¢N™£T¦³dÝÂÆ–Âì½ôÃ+ÛçCúCúB¹XCúCúCúCúCúCúCúC•`C CúCúCúCúCúCúCúCúÃ,í‘Ã1éüÃ-ØRÃ#`ÅÞÃ]qÂ÷2°Âà„ÂÌËD»Æ%Â`ÂuãT‡Ôþ–âN¨!Ë»2-ÂÏ$ZÂâð!Â÷Âà 4¼Ã,‡CúCúCúCúCúA‡?}CúCúB»~úCúCúCúCúCúCúCúCúCúCúÃ9[#ÃO{çÃUµÃÃLõÃÃ< Ã(Š=ÃïžÃ–FÂïs3ÂØ3¶Âİ!Âs«‡¥ã˜‡+­(öÂÆ¦ÂãQhËDÃožÃò°ÃÀÅæ¨Âä·ÏCúCúCúB^r°AÄÐåCúCúCúCúCúCúCúÃ$)üCúCúCúCúÃø“ÃKBÃo'mÃxk…ÃkmÃSjÁÃ9BÃ!¦fà ê=Âû¤ZÂákÂËݲƒ\“ÌJ¨ô¼ÂÄ–ÂæÇ®Ã nÙÃ#ÌÍÃ>QªÃN×ÃL­Ã8ôþÃ!/ÊCúCúC8îVCúÂZCúCúCúCúCúCúÂôG+Âç„CúCúCúCúÃT{#Àn¸ÃˆåÀøÃdjÁÃD×LÃ)yšÃeãÃÙÂ癚ÂÐÈ1‹“ž€ƒÂ·Â ÂÙiyð¤Ã#· ÃP\ÃU¢Ã–“uÃ’V¤ÃJqÃÇðÂhn˜CúCúCúCúCúCúCúCúBž#TCúµ–‡CúÂgÒòÁûãT–xÕà 0åÃJ’òÃ~µ?ÉÂÑÃe?Ãh]qÃG©7Ã+”þàÃOžÂê/žÂӚ‘SøÂ¦ÄÂÃ8ÕÂêKDà ÅÃ;dÃZ Ã¸"-Ã÷ ÃÎ,ÍCúÃ…=‘Ã#{¦Â‘Aé(öC?P¤CúCúCúCúÀI&éCúB3!ËÂ7=qCúCúÁ|ÌÍÁ'•Âg ÅÂí-‘Ã4zÃgCÃ}NÃu+ÇÃ\”¼Ã@’°Ã'„œÃÙXà BÂéÂÒÕV«ÖÂÉîÂó¿}ÃkÇÃH+DÃŒñ'ÃÙì¬CúCúCúCúÃ8ѱTþÁ ƨBž"NC5øRCúÁE¢Cú›Ÿ¾Â†o››#¸ØCúCúAKOßAPÂ2k…ÂÊB ûdÃC7LÃW‘ÃUÞ5ÃFËÃ2Zã×à PbÂýLÍÂä²-ÂÏþw–ۦ­EÂË ÓÂôá‰ÃDìJÇÚÃËNúCúCúCúCúÃ4'Âȉ7ÂäZA¨—BŸk…BÈB@ŒJÂàhsÃK~wÃc§ðCúCúÂV¬AždZAú´9¿…ãTÂ;>wµÃË…Ã"*Ã3qªÃ6 ƒÃ.eãÃ!…`ÃP!ÿ;Âó BÂÝÈ´ÂË>w•öÉ«5ÃÂÆéyÂì Pÿ;Ã4¹ÛÃl$á ¤ÃÛ³uÃÁ¨sÃ’x“Ãb>úà ÐbÂÒŒJÂrIºÁÆ9X@êMÓB<•CúCúá¾úCúÃPhsCúB ¤ÝCúBèöÀËt¼Â[JÁ«-Âå‰7à þúÃéüÃ@ƒÃ“Ã_;×LÂúÖÂç5?ÂÕ>wÂÅìÂ’ýô¦H´Â¾¹XÂÞ2°Ã©üý/ÃAß¾Ãk‹ÇÃ…Â ÃçðÃ`Æ%Ã7r-à ùÂÓ2-š!HÂeí‘Â7bÂ"œ¬CúCúÃ`¸“Ãdw“Ñh‘Ý/ÂeãÂŒxR‰&éÂ…†¨Â¬‹Â<Þ5ÂD•ÂLOßÂSêÂ[@ƒÂb.Âh•ÂnbNÂs–‡ÂxKÇÂ|±'€‡+‚ٚ…s3ˆk…‹ÃÂZ Â’ô¼Â–<î˜ٚš‚ ›øÂšž5™Y—ž5•Ê=”)yÂ’æfÂ’‘k…ÂïžÂdݤZÂŽåš‹7ψí†B ƒC–€Ây¬Â5‰7ÂwÂiüÂê‘«‘³3‘$ÝÂ49ÂÂŽ®ÂšÂŒV‡Â‹±ªÂ‹uŠ`B‰|îˆV†޸…h‚ïžÂ€~wÂ{bÂu°!ÂouÃÂ.ÙÂ4î˜Â:þúÂ@öÉÂFƨÂL\)ÂQ®ÂV·LÂ[|îÂ` PÂd€Âhò°ÂmÂr@ƒÂw:^Â|_;€ŢƒB Â…‡_¾ÂˆÂ‰›¦Â‰î‰Ï\‰^5ˆ¼îˆ D‡[¦Â†µ?†òÂ…ff„Ÿ;ƒ«…‚~úÂßÂ~´9Âz¼jÂvA‰ÂqQìÂkýôÂf\)Â(¹XÂ.5?Â3¬Â9bÂ>TþÂCp¤ÂH[#ÂMuÂQž¸ÂV%ÂZYÂ^¨öÂc+Âg}ôÂl PÂp¦éÂu0!Ây€Â}ff€Z Â¤Z‚‡+ƒƒ)yƒ®Â‚µ?‚DœÂÃÂ6É€/ÂÞ5Â~C–Â|VÂzÂw@ƒÂt+ÂpXÂl:^Âg¹XÂbâNÂ]ÄœÁsdZÁeÛ#ÁU¶FÁBÀƒÁ,ÌÍÁÂÀï;dÀ±¸À[ƨ¿›…?‡ïž@Sçm@­¡Ë@èÔþA Aº^AùÛA®@ú-@²ùÛ@)7L¿`ƒÀ˜ ÅÁ ÀƒÁLƒÁ„XÁŸÊÁÁ¸IºÁÍß;ÁàÎÙÁñdZÁÿáHÂ33 ‡+Âð¤ÂuìÂñªÂÂbNÂ#×Á};dÁn£×Á\õÃÁGÎÙÁ.éyÁÀáó¶À—®À t¼?¼j@^V@ÌÝ/A¥ãA<ƒA]ÒòAt1'A|n˜AtAY²A-l‹@â¸R@#¶FÀ Àò JÁH‡+Áˆ¼jÁ¨çmÁÄ£×ÁÜffÁðÙÂKǠ°!ÂVÂ÷Ï• 6FÂ!çmÂ"º^Â"Å¢Â""ÑÁ„× Áz=qÁg&éÁOãTÁ4ÁýôÀÙVÀ€Ý/¿lIº@ÎÙ@ÅXA¡ËA\$ÝAŠQìA¢ZA³®A»× A¸ÐåA©ffA‹DAMV@Û¶F>£SøÀË•ÁJ\Á‘¼jÁ·‡ÁÕÂÁïbÂ9X |§ð  ÅÂ%xÕÂ))üÂ+¶FÂ-.Â-§ðÂ-A‰Â, ÁŒ²Á„¥ãÁu‡Á[ó¶Á=&éÁïžÀ×SøÀ_ >€@ŽéyAº^A`ýôA™VAÀ?}AãAý´9B?}BAú-AÖ‡+A¢ÊÁAEdZ@_ß;À­OßÁXõÃÁ¢Ý/ÁÍ=qÁí|îÂjÂÂaHÂÍÓÂ'F¨Â- ÅÂ2·LÂ6uÃÂ8Ü)Â9üîÂ9ùÛÂ8úáÂ7(öÁ–?}ÁŽA‰ÁƒÙÁm¸ÁK¾wÁ"záÀàr°ÀO²?šÀƒ@ËÎÙAChsA• ÅAË\BoB^5B.öÉB;ÙB>33B4B÷ÏAóáHA›bN@ä9XÀ¥XÁïžÁÂr°ÁïÒòÂüî ¸RÂ$ß;Â-§ðÂ5¶FÂ<œ¬ÂB+ÂEÎÙÂGõÃÂH˜“ÂGèsÂF¬ÂCl‹Á¢1Áš^5Á Á‚ZÁap¤Á4¬ÀùXÀ^—?á&éA ÅAtõÃA¼ñªB÷ÏB)¬BN-Bn0!B‚&fB…Ø“B€hsBbuÃB2AçoA4bÀΗÁ¬$ÝÁü´9ÂÖÂKÇÂ#%Â*ˆ1Â3ožÂ=ÂF)üÂMöÉÂSÞ5ÂW©üÂYjÂYTþÂW³3ÂTÖÂQ%Á°KÇÁ©hsÁŸ™šÁ’ ÅÁ€¬ÁQ Á$ÝÀ²-?ϲA?}AÄœAåùÛB#ÀƒBY#×B‡çðB¡ =B´1B¼ž¸B·vÉB£H´B6ÉB(XA33Á+‡ÂH´Â6.Â;qªÂ56FÂ3aHÂ833ÂAàBÂM²ÂXó¶ÂbKÇÂhéyÂl¦éÂm¿}Âl˜“Âi¥ãÂeYÂ`{ÁÁVÁ»ÎÙÁ³9XÁ¦´9Á•(öÁz~úÁ:“uÀÍ%>Ðå`Aë…A \B0!BFÂBˆœ)B±BØüîBùñ'CîC™XBíäÝB¼¢ÑBuò°A¹1Á–áHÂr­–î˜Ârë…ÂJ7LÂ;êÂ@ÂN:^Â_VÂnÙÂz©ü‚Ñh‚Ï\Ân˜Â~bÂwØÂp²-ÁÕr°ÁÒÁ˃ÁÀ÷ÏÁ±“ÁšA‰Át›¦ÁõÃÀÛ#@ï;dA£²B¨öBhÀƒB§­‘BãYšC¾C.nCA²CD%`C1$œC nBµÝ/B"ÑÁÈIºCúCú–)üÂOdZÂ-”{Â9¯ÂVk…Âs P„ÒoÂŒp¤Â›¦Â‘ãTÂíÂŽUŠ¢N†=ôÂxRÁì× ÁìXÁé%ÁáÆ¨ÁÕ/ÁÁ^5Á£È´Áqß;Àï®@O;dAÊÁBýôBÒòBƺáC`ÅC@S¶Cr¤CÖC—šC‰åÃCPaCABkº^Á§²-CúCúCúÂäZÂBLÍÂB¦éÂ>èsÂ5LÍ DÁØ÷Ï?ªáHB<%BÚbNCIPC¢å`CÆçmCǃCúCúC¾£–C†u?C0E¢BéÄœCúCúBzuB¥KÇ@ãSøÂhÍÓÂÂH1ÂïüîÃúÃaÃ0¤Â÷²°Âè1'ÂØ JÂÈyXº ºÂ¬ïžÂ5ãTÂAPåÂM€ÂZ¬Âf“uÂr"ÑÂ|%ã‚u?‡”þÂ@ƒÂ—49ÂFLÍAn£×B/žC.+DCúCúCuœ)CúCúCúC—§ðC,þ5Bû33CúCúA› ÁÒ~úCúCúÃ" Ãö‡Ã%GmÃ#p¤ÃûdÈ´ÃmPÂïÌÍÂÚô9ÂÈ߸}ÂI.ÂY9XÂkH´ÂE¢ÂŠaH•wÏ s3«¤ÝºÁ‰ÂÞF%Ã,´þCúÂ#³3CúCúCúCúCúCúCúCúC6CúAù× B“ò-Bv­CúCúCúCúÃ#²-ÃK5ÃÃRÛ#ÃIÈ´Ã8íÃ%ÿ;ÃZÃ/Âíc×ÂÖ§ðÂÃ}ôÂ] DÂr]/Â…¶É”Qh¤úá·AÂÊÂÜZÂï¶Fà ÌJÃIíÓCú¼’òCúCúCúÁ²¬A7¸CúCúCúC G+CúCúÃñ'CúCúCúCúCúÃY¦fÃ…ñìÇ}PÃyãÃ[r-Ã>+Ã$ÈsÃþwÂþ|îÂãiüÂÍJ=Âp¶FÂ…åã–r°Âª®ÂÃ%ãÂßɺÂþåãÃúÃ#×Ã#m‘ÃÆfCúCúCúAMÂÀb- ¤ÝÂoAŸ¾BAp¤B×oCúCúÃ33øÃAyÛÂέ‘CúCúCúÉÅÃì™Ûêt¼Ã—9ÃÙÃU~¸Ã3ɺà yÃLÍÂíÉ7ÂÕ5ØÂ’ò¦ïÂÁ©yÂä“Ãú^Ã"bNÃ=,ÍÃNT{ÃNíÓÃAzÃ+IyCúCúCúBsËÇCúÀ­ûçCúCú?Ân˜BHcT@ ÷ÏCúÃ9XÂëäZЏCúCúÃ/ФÃÁhü)ÃÅHïÑ'ÃrÃg%Ã>.à ¿¾Ã ýqÂôÖÂڥ㉦fœÐbµÍÓÂ×2°Ã‚ Ã"±ìÃP …ÄÓuØæfÕàbCúÃ`™CúCúÁ­¬CúCúÁ‰SøCúCúÂáHÀd‹DÁËÆ¨CúCúCúÁý1CúÂ…£Tþ¸Ãƒí‘ÿÉÃн²Ã¹5ÃÔIºÃkÃÃAÑÃ"Îà ªÁÂ÷¦éÂÝ2°ÂçðÂ¥5ÂÁVÂè49ÃÃ:ÒoÀîúÃÄrNCúÃÏþ˜CúCúCúCúÂ=MÓCúCúCúCúCúÂb»dÂ=¬CúCúCúCúCúCúÁÇXÂíF¨Ãc´9矾÷fÉÃ¥L¬Ã‰7LÃ`²oÃ;aÃæ%à 4¼ÂöUÂÜÊÁ“ñªÂª:^ÂÈ“Âñ»çÃoÃG°¤ÃŽeãÃ딼CúCúCúCúCúÂÀÂÒòÂ?{çÂBCúÂÂCúÂá©yÉüÃ&>¸CúCúCúCúCúÁ#&éÂÇ6FÃ5t¼ÃzËËk¦Ã…SÃlmÃKhöÃ/ròÃùÛÃåÂñH1ÂÙ¯žÂ•~ú«²-ÂÉCÂò ÃžúÃD-È+dÃÎå¢CúCúCúCúCúCúÂ6IºÁÀzá@&vÉCúCúCúÃKß¾CúCúCúCúA¦ BjÖAò+ÁõZ±áHÃ#Ã>E¢ÃT¾5ÃTï\ÃGøÃ3öà ԼþúÃdÂékÂÔf锡˩¬ÂÅ&éÂê{ò-Ã3¾¸Ãk°bâѪÃä ¤ÃÈ— CúCúCúCúÂe¶FÁîÎÙ@ˆ¼jCúCúCúCúCúÃz/žCúÁJVCúB„NVCúCúŸßÂöCÃ_¾Ã+Z^Ã/H´Ã)³¶Ãì‹ÃOßÃÌÂôyXÂßÎVÂÍ“u‘²°Â¤È´Â¼ÿ}ÂÜ=qÕÞúÃ@ì‹Ãk]qÆ—ÏÄO;ÃjäœÃ<2-à YÛÂÅh†;çÂ;“ÂØÁ1Â?%ãÃ" Ã+˜“CúÃ>ìÃYšCúCúCúCúCú‡"NÂÓc×ÃXÑ'ÃÁ‰ÃÀà ™XÃCÂøTþÂæSøÂÕ_¾ÂÅÒòÂ4¼Âì‹Â²féÂËšÂꆨÃÝqÃÿ}Ã1¡Ã>¹XÃ=@ÅÃ-ÓuÃìÍÂñ¼j¾ËD˜#Tƒ-‘ƒÀƒÂ¢’oCúCúCúCúCúÃ}ÂîçmÂ3{CúCúCúCúCúÂêO\à ÍÃéyÃg+Âÿs¶ÂôšÂæ´9ÂØ¦éÂÊÎV½¤Ý‡¶É•üî¦Õº— ÂÑYšÂêŒÍøà !HÃBNÃVà mPÂöÞ¸ÂÖ¦é¹ Ç¤ÂBªIºÂÓ|jÃdÃ9ÌCúCúÃ2œÃdœÂý ÍÂÀhCúCúÂicTCúÂo¦ÂÏÂæT{ÂíÁÂíô9Âé7ÏÂá¸ÂÖþúÂËãTÂÀˆ1µgm¸Õ¶F›\)ª©ü»XÂÌœ¬ÂÜäÝÂé¾wÂðSøÂî«ÂäÎVÂÔò-ÂÂÌJ²°!¨øÕ©æé¹ڠÂÝeãà OžÃ'~wCúCúÃ5à jÂíËDÂÊ¡Hºê¶ Á¯m‘CúÂÀ DÂÊ¢ÂÕw—7LÂU»dÂas¶ÂmyÛÂy€Â‚ŽV‡åãÂŒ€ƒÂ¬Â’’o“äZ”KD”9X”Pb•H1—ÍPœW¢÷Ï«,‹Â³ÍÓ»A¿ïžÂÀÎV½Ç+·Â°xR©ڠ¥j£°¤Â¤6ÉÂ¥øR§ó3©ªKDª!˨즬‹Â£{矂šî•ì¦fÂL0!ÂV-Â`H´ÂjE¢ÂsØÂ|¥ã‚-Â…V‡½ô‰ožÂŠ™‹‹DÂŒ®˜ÂŽuÑDœÂ•SøÂš˜“ «…¦Ï߬쯇®Â°–¯-‘«Óu§ŒJ£~ú ˜Ÿ8ÕŸ3¶Â Â¡œÂ¡Ç+¡ùX¡p¤Â Âó¶Â›å—‹Ç“…¢Â¾ÂŠz^ÂC}ôÂL¦ÂT¿}Â];dÂeXÂlÛ#ÂsbÂyQìÂ~€û炞¸Â„,Â…çmˆ‡ÂŠò-ÂŽ‘ìÂ’àB—’òœ-‘ )Â¢ÓøÂ£üj£P¡ؓŸs¶Â Ó›33š(s™àÅššnš—šW™‰ºÂ˜)–Ù“k…ÂDœÂŒ²°ÂˆÍÓ„®˜Â;—ÂC¸ÂJ ÅÂQúáÂY%Â_²Âe ÅÂjþúÂo¶FÂsâNÂw¶FÂ{€Â”{‚$݄푈,‹ɺÂb“.–G+˜ˆ1™½ô™äZ™-‘—ð¤Â–“øÂ•m”¨s”F¨Â”%`”ß“Òo“C–Â’G+ÂÏßÂŽÚÂŒm‰”þ†bÑ‚éüÂ~yÛÂ4hsÂ;bÂA°!ÂH,ÂNjÂTSøÂYÓøÂ^ãTÂc‡+ÂgÔþÂkñªÂphÂtjÂy/Â~{ç‚(sÂ…BˆdÝ‹Z ÂçmÂٚ‘o‘ß‘ožÂæfÂ.˜Â|jÂŽî˜ÂŽˆ1ÂŽ8ÕÂâÑÂeãÂŒ¥ã‹\Šˆ:áÂ…ýqƒhs€ˆ´Âz× Ât?}Â-Ü)Â3ÐåÂ9»dÂ?Š=ÂE)üÂJ‹DÂO¤ÝÂTp¤ÂXöÉÂ]G®Âa}ôÂe»dÂj ÅÂnɺÂsÄœÂy+Â~qªÂå`„e`†‘ìˆKlj}Š,‹ÂŠdÝŠF¨Â‰ô¼Â‰ŽÙ‰)yˆÈ1ˆcT‡ê‡J=†p!Â…NÙƒÞ5‚¦Â€ =Â{`BÂv-ÂpbÂj¡ËÂ'Þ5Â-?}Â2˜“Â7Û#Â<üîÂAð¤ÂF²-ÂK@ƒÂO ÅÂSß;ÂX\Â\DœÂ`“uÂe DÂi®Ânr°Âs=qÂwå`Â|8R€Âå‚»dƒ}ƒéü„ =ƒ÷LƒÃƒz^ƒ"N‚¶É‚.Â|“Â~î˜Â|'ðÂxÚÂu1Âp¼jÂlÂfñªÂa•Áol‹ÁaÁPùÛÁ=™šÁ'33Á ²-Àâ-À£ À>¿9X?É™š@uÒò@¾áH@ú{AçmA!²-A$A‰A JAV@ºñª@3¶F¿L‹DÀ˜9XÁ ó¶ÁN¬Á…ƨÁ¡vÉÁº ÁÏÊÁÁâÎÙÁó|îÂ1ÂY »dÂ2-ÂÁ‰Âp¤ÂIºÂ[#¸RÂs¶Áx´9Ái©üÁWxÕÁAÎÙÁ(VÁ ÙÀÒ^5À†È´¿ÎvÉ?—®@ƒ²@â=qA§ðAG²AhÄœA~£×Aƒ A|bNA`r°A2r°@èÝ/@( ÅÀ{ÀöÐåÁL1'ÁŠýôÁ«`BÁÇ/ÁÞñªÁó`BÂ’o Rò DÂÁ‰ÂqªÂ¬Â!Å¢Â#yÛÂ$KÇÂ$QìÂ#¥ãÁ‚A‰Át‡+Á`ÐåÁHå`Á,A‰Á záÀÆffÀXå`¾k…@O¾w@ß =A-;dAj^5A‘²A©¡ËAº´9AÂSøA¾vÉA­ñªAƨAP§ð@Üýô>;dZÀÔÔþÁPùÛÁ•r°ÁºéyÁÙr°Áò…ÂØ PÂ+ÂDœÂ"NÙÂ'9XÂ*ùÛÂ-\Â/ 7Â/~úÂ/\Â-ÚÁ‰®Á\)ÁmÂÁSƨÁ4 JÁ ÒòÀÀå`À-‘h?V@¬ÄœA!ûçArƒA¢dZAÊ Aìó¶B¹XB ÊÁB ûçB>wAÚß;A¤ïžAEV@LzáÀ¾ñªÁd‹DÁ©9XÁÓjÁó1ÂÐå¸ÂOßÂ!°!Â)2-Â/¢ÑÂ4ÐåÂ8 ÅÂ;bÂ<2-Â<&éÂ;“Â92-Á’çmÁŠ~úÁ;dÁc‘hÁA Ár°ÀÅp¤À33@Äœ@ñ?}AX$ÝA ‹DAØB¿}B!YB5ùÛBB}ôBD+B8¯B 7Aö\AšMÓ@ÐzáÀÇC–ÁŠÔþÁÍÛ#Áú&é >wÂzáÂs¶Â'=qÂ/çmÂ8 Â?+ÂD‘hÂHp¤ÂJŸ¾ÂK?}ÂJ€ÂHœ¬ÂEÎÙÁž;dÁ–VÁ‹ Áy‘hÁTÌÍÁ&MÓÀؼjÀ¼j@D(öA¾wA‡ÊÁAËñªB bNB2vÉBXTþBxÂB‡KDBŠféBƒùÛBgšB3ïžAäPA í‘ÁÙÁÁ¶F oÂwÏÂ"¯Â'¦éÂ-ýôÂ6E¢Â?«ÂHéyÂPéyÂVýôÂZçmÂ\¯Â\PÂZÑìÂWÏßÂSÓøÁ«ûçÁ¤xÕÁ™í‘Á‹Ÿ¾ÁqG®Á?× ÁjÀ@´9@Oß;A/¸A¡ñªAù× B/IºBf‹DB–B©z^B¼–BÄMPB½dÝB§ ÍB‚¶FB&2-A^§ðÁq¸ÂÊÁÂKQìÂHÙÂ=A‰Â8þú¾wA'÷ÏAÀG®B%ùÛB~ožBµì‹BöÛ¦CÅ`C>HCP£–CNWC6©ºC!‰B¶XAõ¬Â:~úÃ$^wCúÂDãTÂ' ÅÂ)\Â:ÍÓÂX²ÂvÚ‡‚ §m”ß•[#”B‘s3Â~úˆևƒÎVÁæ—ÁäûçÁàOßÁ×jÁÈÌÍÁ²záÁ‘ÒòÁF~úÀ‡\)@äbAµÌÍB/jB.˜BÚÒòCô{CZ DCŒMqC òC¡¸ÕCŽSuCUgmC çmB`hsÂ:…Ã?åCúCúÁ–™šÁ‚ãTÂûçÂ[“ˆœ¬ÂšdZ¤— ¨î¨úá¦ì¡@ƒÂ›Qh”ÔþÂŽ-ÂNÙÂaH¸ÁýÛ#ÁóùÛÁâr°ÁÆXÁ›xÕÁ7Sø>“t¼A‹C–B'¶FB˜àBBù·LCA}²C‘¼CÑËçCúCúCöÈsCœã×CIúBÌÓuÁ¥È´CúCúCúCúB|•Á•°!ÂgTþžTþµևÂÁ1ÂÃìÂÁZ»iy³™ªí‘¢ P™]/‚  J™šÂ¯ÂËÇÁ雦Á²©üÁ61@ÁB DB‘Ú CkDC[e`C°/\CúCúCúCúCÂÜJCGLC#]ôBVïžCúCúCúCúCˆsÁn˜Â BÂÄùXÂÞܬÂè/žÂçœÂß•ÂÔÒòÂȬ‹Â¼O\°bÑÂ¥9XÂIºÂ%Û#Â,Â19XÂ4«Â5E¢Â1¯Â(/¬Áë7LÁcPAV=qBd7LBóçðCcóøCȇCúCúCúCúC¬°C†NVC?€BCšC.O\CúC'³øCúBÞ5Âf’oÂÐwÏÃßà vÉÃß}à 0åÃ\)Âò¥`Âàp!ÂÏ@¿‘h±}Â0ûçÂ;F¨ÂEýôÂP¬ÂZŽVÂb’oÂgr°Âh#×ÂdIºÂZ¡ËÂúÃp”þÃ\g+ÃCcÃ+ò°ÃïÃMÓÂó 7ÂÜœÂí¤µ?¾A‰Âà+ÃâÃ&‚ÃRLJÃ…=qÜäÛ¹yCúCúCúCú ÁžQìÁº¶FÁïffCúCúCúCúCúCúCúCúÂ{VCúCúCúà ýqÃ*²Ãwš_;¬ DÂźáÂâ]²ÂúhsÃXRÃÛÂï!ËÂÓÓøÂ·"Ѭl°ºÅÂÏ@ƒÂϼjÂÏEÂÓ/ÂÕp!ÂÔ¦éÂÑþÂËT{ÂÄ Í»Ô{³%`ª[¦ÂgSøÂw&éƒüjÂŒ²-•[#Âr°Â¤G®Â©«/žÂª@ƒÂ¦}ô ¸ÕšKÇ”çmÂ’På”"N›{d¨‰7¹äZÂÌdZÂÛÆ%Âã{çÂàSøÂÒ“øÂ¾Á¬c×£}ôÂ¥…®JÁ¸š Â¿LÍÂÃB ÂÆßÂÇ+…ÂÆ$ÝÂÃo¾O\¸I7±kªh¢…¢Â\•ÂiÓøÂw”{‚»ç‰wLÂ/”¼j˜bÑš9Ûš%`˜_;•~wÂ’l‹ÂDÂ'ð“ J™|j£Qh¯s¶Â»âNÂÆ´ÂË#×ÂÉ&éÂÀaË´ ¨þw£*£Â¨Ï\¯7Ï´/¸O\ºgmº߾¹®˜Â¶ïžÂ²Ý²Â­Ä§ïžÂ¡¤Ý›5ÂR™šÂ]È´Âi0!Ât}ôÂG®Â„„œÂˆš Â‹¤ZÂxRÂŽ±ªÂŒ¹Û‹ÍP‹¥`ÂŒ÷LÂO\•æfÂzá¦ú–m‘–Ðå—(s—:á–Û#•ð¤Â”q'Â’`BÂÉ7ÂŒ¾w‰T{Â…¡H¹ÛÂ2˜“Â9Â?aHÂE“uÂK‚ ÂQoÂV5?ÂZâNÂ_¾ÂcÂf¾wÂjÂnŽVÂs²ÂxW Â~?}‚\)Â…º^‰œÂ‹üîÂŽiyÂ"Ñ‘5‘uÑ\)‘bÂȴ¤Z£×¯žÂ¤ZÂ]²Â¾úÂŽ´¼Â6F‹DœÂˆçm†*ƒ²Â¢ÑÂx­Â,JÁÂ2\Â7ÄœÂ=YÂBº^ÂGÚÂL®ÂQ33ÂUqªÂY}ôÂ]uÃÂa}ôÂeÀƒÂj\)ÂocTÂtÒòÂzŒJ€+‚ò-Â…s¶Â‡‹D‰ BŠ-‘ŠÖŠþú‹Šð!ŠÚŠÂŠž¸ÂŠ[#‰àʼn5ˆœÂ†ŽÙ„¼j‚‘쀓Âz·LÂtÎÙÂn‘hÂ&„Â+¾wÂ0í‘Â6Â:õÃÂ?¸RÂDG®ÂH£×ÂLÓøÂPæfÂTñªÂYVÂ]RòÂaÒòÂf”{ÂkPÂp¥ãÂu²-Âz}ôÂ~ÒòÂA‚¶Éƒƨ„z^„âNÂ…òÂ…¾Â…øÂ„ò°Â„¶É„T{ƒ¿}‚ë…ÂÏ߀hsÂ}iyÂyp¤Âtó¶Âp Âj²-ÂeÁkƨÁ]¡ËÁLå`Á9SøÁ"È´Á +ÀÙVÀš¬À,‹D¾ï ?çl‹@X@Ä@ý™šAÌÍA!©üA#SøAE¢@ÿƨ@µ%@&¸R¿%ÀžÈ´Á‡ÁQ™šÁ‡$ÝÁ¢ÂÁ»\)ÁÑ%ÁäoÁôÊÁº^“ ˆ1 J¦éÂ_;Â=qÂQì¯ÂhsÁtvÉÁe¸ÁR§ðÁ<¸RÁ#%Á\)ÀÇ;dÀwl‹¿£33?À£×@Œå`@ê$ÝA!¾wAI¥ãAi•A~(öA‚¸Ayl‹A\ƒA-ß;@ß @›¦À0“uÀÿ\)ÁP JÁŒ¼jÁ¬ûçÁÈ®Áà`BÁôÎÙÂNÙ ¦ÂãT©üÂk… #×Â"ØÂ$“uÂ%gmÂ%m‘Â$½qÁ‘hÁo/Á[‡ÁBÌÍÁ%Û#ÁÎÙÀ¸´9À=`B>E¡Ë@ihs@ê¸RA25?An-A’È´A©ñªAºbAÀ¼jA¼AªÈ´A1'AI/@Î~ú¾o²Àà´9ÁV1'Á—ÀƒÁ¼ýôÁÛVÁôE¢Â°! å`ÂVÂ:^Â#[#Â(ZÂ,,Â.ÍÓÂ0OßÂ0Ç®Â0VÂ/¦Á†È´Á|n˜ÁfõÃÁLvÉÁ,E¢Á¥ãÀ¯ïžÀ  ?Ñhs@½/A)xÕAxå`A¤ÌÍAËffAí BšB n˜BñªAûZAÕ"ÑAŸ¬A:{@%p¤À϶FÁkÂÁ¬jÁÖOßÁõ¥ãÂúáÂ,ÂPåÂ"¸RÂ*NÙÂ0ÚÂ6"ÑÂ: 7Â<ˆ1Â=±'Â=§ðÂ<”{Â:¤ÝÁ…Á†Æ¨Áw ÁZÀƒÁ7…Á QìÀ°9X¿Ï @<‹DA;dAaë…A¤º^AÛ$ÝBœ¬B!PåB4àBB@;dB@¦éB4qªBYAí?}A‘Ôþ@³•Àß =ÁÙÁÒ~úÁþ©ü TþÂC–Âë…Â(„Â1$ÝÂ9SøÂ@yÛÂF%ãÂJ¾ÂL`BÂM%ÂLE¢ÂJYÂG|îÁšE¢Á‘©üÁ†?}ÁnáHÁI"ÑÁº^À½û翹™š@|ýôA%®AŽMÓAÑ“uB „B3Ÿ¾BX33BvþúB…t¼B‡•B€`BB_0!B,G®A×33A dZÁXÁÈbN ‡+Â{çÂ&¨öÂ*ãTÂ0ZÂ8 DÂA;dÂJ†%ÂR­ÂXì‹Â\õÃÂ^ÎÙÂ^±'Â\í‘ÂYÛ#ÂUɺÁ§XÁŸC–Á” Á…"ÑÁbéyÁ0{ÀÞÀƒ¿ðÄœ@XAAÂAªÈ´BËÇB2G®Bh?}B‹ÇB¨8RB¹·LB¿ÓB·+B BxIºBjA>9XÁƒƒÂ!A‰ÂOéyÂP«ÂEèsÂ?ÐåÂ@Ÿ¾ÂGÏßÂRÅ¢Â^RòÂh33ÂoG®ÂsJÁÂtp¤Âs)üÂo÷ÏÂkVÂe±'Á·%Á¯ýôÁ¥°!Á—33Áƒn˜ÁRbÁ ´9ÀKt¼@€“AQ33AÂ÷ÏBÊÁBZ÷ÏB“¼jB½oBæ“CÌÍC AHCàƒBæ¹XB³z^BaÝ/AMÓÁõ¸R˜.­¿}ƒ·LÂ^Å¢ÂP`BÂLÓøÂUêÂe¶FÂu´9Â-Â…=q‡‡ =Â…‚ ‚âÑÂ+ÂwTþÁÉ\ÁÄ=qÁ»‹DÁ®p¤Á›—ÁQìÁ:ùÛÀµº^@ÊÁAK&éAÑ~úB-¿}B‚^¸B¸$ÝBø5?CËC=1ªCJvÉCA{¦C'‰üCroB¨O\AÐ JÂL‰7Ã)ÿ¾CúCúÂKaHÂUyÛÂMk…Â_õÃÂ{#׉wL‘¸R–7Ï—†%–^5“t9Â^¸ÂŠ’oÂ…eãÁß-ÁÜXÁÖ7LÁË¡ËÁ» =Á¢vÉÁ~—Á5?¿¥?}A${AάB:¨öB”´9BÞ9XCæéC^ÆfC¸sCž|)CcuCr ‹C<€CoßBPŸ¾ÂgvÉÃJî˜CúCúCúÂ+aHÂ1ËÇÂf#׋ØÂbN§¤Z«÷Ï«æé¨ÎV£Ţ²–éü PÁ÷ûçÁøPÁö"ÑÁïvÉÁâ× ÁÎÁ®Á}dZÀéxÕ@œ9XA°™šB8m‘BŸ-BýÝ/CDÖFCšÃ–CúCúCʪ^C¢”ÝC©ÛCMÙBê»dÂ1‡+CúCúCúB&s¶AI|îÁóÄœÂw£ ÅºǮÂÅÅÂÈUÂÅ\)¾ÿ}¶ȴ­¿}¤ŒJ›’o ü ÎÙ A‰Â ò°Â¨öÁë\Á ÅÁ‚t¼ÀŠ5?AX\B±'BšÌÍCÛ#C[Å¢C½BCúCúCúC˜WÏC—òoCž}ÓC€boBL¡ËÂcïžÁÈvÉB3 7CúBJ‚ ÂH´Âœ?}ÂζFÂçŒÍÂïÉ7Âí‰7Âå ÅÂÙŠ=Â̲°Â¿Ã–³]²Â§Ï\€ÂÍÓÂ#bNÂ&•Â'wÏÂ$ÀƒÂ½q .Áå“uÁ¬¿k…AÌùÛB@ƒBó÷LCUäÝC¶KdCúCúCúCúCúC¢°bCúB易B™‰B—¨sB•–BŽÖ¿˜ÔþÂŽ1ÂæøRà ÖÉÃT¼Ã üÃfÃ0åÂøÐbÂå{çÂÓr-Âô€ƒÂ*TþÂ3 =Â;¹XÂCÇ®ÂJA‰ÂM¿}ÂLiyÂC÷ÏÂ1‚ ÂüîÁ¨Àƒ@Š JB$?}B²_¾C%mÓCúCúCrWCúCúCúCIf%CRòCúCúCúCúÁÜbN­‰Ã¯žÃ0WÏÃD¤ÃFXRÃ=éÃ.EÃÿ}Ãb ÃZÂèCÂÓ?}ÂÁ;dÂ<'ðÂHáHÂV‘hÂdÂÂrƒÂ~9X‚ƨ‚È1Â{Âa‡+Â,¯Á“A€VB!¾CúCúCúCúCúCúBÀDœBêuB†PåCúCúCúÁê1'­Úà íÓÃG5ÃÃÒoÃŒ¯;Æ×mÃsÒ°ÃUäÝÃ: DÃ"@ƒÃ¢ÂýA‰Âã\ÂÍm‘ÂNwÏÂ_Á‰Âs\)„ŽÙÂ"N›}¤øRªV§ÄšgðÂt†%Áé¬AGSøA å`CúCúCúCúCúCúCúB®0!B=øÕÁÔþÁ¯©üÁʧðÂt¥ãCúÃ$¢ Ãp!Ë÷ˆRÃÉÀƒÃ½õãßï;Ãq'ÃY‚ÑÃ6ÙØ“ÃzáÂñ‚ÂØbNÂ`’oÂvÍÓˆ‹Ç—ïžÂ©}ô¼dÝÂÎ^¸ÂÛ1ÂÜ4¼ÂËÂt9ÂŒJB3QìB…ÙCúCúÂÁÑhCúÃàƒÂTCúCúCúCúÂc»dÂ9¡Ë„šCúCúCúCúCúCúÃҰà8´Ãyº ÃIÝqÃ(°¤Ã¸RÂýc×ÂáW Âq‘h†dÝ—ß«ÂÄO\Âá\¬Ã0bà ;çÃÔ9ØÂÛêÂe£×B ›¦CúCúCúÂäÔ{CúÃ]/ÂdZCúCúCúÂDèsÂ|RòÂ4‹D©üÂ/«ÁÊ9XCúCúCúCúÄ)ÿGÏÊ´ÃWˆ´Ã0ò°ÃLJÃÃÂç—€6F¤{½ÓÂÞ0!ÃÉ7äZÃ5l‹ÃB8RÃ9RòÃJCúCúCúCúÃ×CúCúCúÂÓ¹XÂ\ÊÁÂ33ÂTúá•ò-“þúCúCúA¸oCúCúCúCúCúCúÃÎBNÃŽ,‹Ã[yÛÃ3qÃhsÊÁÂꬆ =—¤Z®8RÂ˽ôÂó PÃýqÃ7 yÃ_ÀƒÃy'ðÃn1hÃP0¤CúCúCúCúCúÃ>½ôCúCúÂëm¡\Â_†´9CúCúCúCúCúB@JÁAí‘ÃpùCúCúÄ4þóØ1Ã…‡mÃT%¢Ã0=ôÃáËÃó¶Âê{d‰éyœs¶Â´c×ÂÔÂþ³3÷ÏÃDÚáÃu»çË·+CúCúÃ81hCúCúCúCúCúCúCúÂÛ 7ªËÇCúCúCúCúCúCúCú¿ÀbNÂŒËDÃB×ÏãÈ1þÐbÃ­ÓøÃê^ÃkÇ®ÃDÜjÃ(þÃE¢ÃBÑÂçLJ‹™ž$ݵô¼ÂÕ&fÂþÊÁÃvÃ@aËÃjŸ;ÄoßCúCúCúCúCúBÓøCúCúCúCúCúÂÎDCúCúà suCúCúCúCúÁ#xÕCúà l‹Ã_ yÀ6‡Ã~=/ÃgÄÝÃL=²Ã2ѪÃVà œjÂùüîÂᰤ‹&fœÔþ³&fÂ϶ÉÂô›#Ãÿ}Ã/LÃMÞ¸Ãc‘'Ãg‘hÃVÇ+Ã'¬CúÂAõÃBÙCúAöÙÂ7QìCúCúCúCúCúCúCúÃ8"CúCúCúCúÃh´Ã1¹XÃEðbÃI–FÃ@ÏÃ1îVÃ!‰yÃîVÃô9Âï~úÂÚ\)ˆÚ™¬äZÂÅyÛÂãÈ1Ã(sÃÌÍÃ,ª=Ã9t¼Ã9¥`Ã+;#à œ¬ÂÆ&fÂ[]/ÁZA´9@Ч𠘓ÂÞ˜“CúCúÂç“uÃ5|jÃt\CúCúCúCúCúCúÃ\)ÃðbÃ'!Ã)ûçÃ%øÕÃJÁÃf¨ÃÝÂø.ÂäòÂÑùXÂ…"N“gð¤k…¸ BÂÐ>úÂêÑìÃ*ÁÃ9áËÃÀÃ,Âæò°Â²p¤ÂvqªÂH´Á³Ÿ¾ÁµŸ¾Âº^Ât²CúCúÂö(öÃ0ýôÃYFfCúCúCúCúCúCúCúÃRÃt¼Ãü)à (öäÂú)üÂèøÕÂØu?ÂÉò€xRÂŒÁ‰Âšê«´Â¼å`Âϱ'Âáž5Âï›#ÂõÎÙÂñåÂàZ ÂÅH´Â¤–‚ÂJ…Â'{ xÕÂ:RòÂ}ß;CúCúÂú— CúCúCúCúCúCúCúšc×ÂÐT{ÂüuÃÙÛÃŽVÃ)ºÃGðÂõmÂèmÂÚ¹ÛÂÍ)ÂÀ PÂv™šÂ…²°Â‘J=Âô¼Â«Pb¸\ÂÄRoÂÌ®Âψ1ÂËTþ¿ȴ®&é™o„+ÂebNÂP“uÂNQìÂbÜ)ˆès«ˆ1ÂÎ/žÂëùÛà ÆéÃÂï֕¸RCúCúºãTÂÓxÕÂÛ‹DÂçÂðøÂó!ËÂñ9XÂëqªÂâêÂØ­‘ÂÍ–‡ÂÂF¨Â·,ÂkñªÂ}e`ˆ BÂ’Vœ ¥߭ƒ–²Å´/±%©OßÂùÛ ƒçðÂsž¸Âi@ƒÂlKÇÂb‘ìªÖÂÇœ¬ÂåÖÂôÂá“¶>wƒt9Âc ʼn¾wª‰ÂÅ1'ÂÒœÂØîÂÞøÂßïÂÞKÇÂÙ·ÏÂÒïžÂʬÂÁÓ¸o®–‡ÂayÛÂp“Âvɇ”{Â=q–6É›ڠŸt9 dÝžZ Â™yXÂ’t9ŠyÛƒßÂ{©üÂx˜“Â`BˆÄ—ožÂªåÂÀr°ÂÔ›#ÂÙH1ÂÈ\«èö‘Pb‡LÍÂ’–Â¥ãT¸¦ÂÄÂË ÇÂÎÛ¦ÂÏèöÂÎX“ÂÊŠ=ÂÄú^¾)ü¶ŽV®ˆ´Â¦dÝÂW‚ ÂcÎÙÂpr°Â} =„„œÂ‰Û#ÂŽ²Âß;‘ÍÓÂÊÁÂŽ%Š1Â…¥ãÂí‘Â÷Ï€Ô{Â…6FÂl™¦Â§*µ²ÂÀ˜ÂÂ;ç¸àB©޸œ‰ºÂ—E¢Â›Ê=¦°÷Ϲhö¾ÖÂÁ¢ÑÂÂ$ÝÂÀ/½V‡Â¸¨ö²ð!¬‰Â¥¨sž¡ËÂN6FÂX¥ãÂc.Âm€Âw0!½qƒO\Â…«†É7†§mÂ…uÜ)µ?€{d€­‚푇ž¸ÂŽÁ‰Â—Ü)¡çð«@±˜“²¶É®gm§/ ºážÙ \Â¥MP«r°Â°¸R´Qì¶¶#×´œ)±¶É­²-¨Ðb£PbÂk—PåÂE¥ãÂNš ÂWˆ1Â`0!ÂhDœÂon˜ÂuYÂy¼jÂ|wÏÂ}ž¸Â}‰7Â|ÖÂ|cTÂ}/€ƒV‡¢Ñ±'”Áœ¢[¦Â¦“øÂ§Ïߦ2°Â£  ºÂžÊ=ŸÇ+¢}qÂ¥Ý/¨èö«–«ès«ŒJ©þw§aH£޸Ÿ¥ãšäZ•ƨÂr-Â=ÐåÂE™šÂMNÙÂT¾wÂ[²-Âað¤ÂgF¨Âk\ÂnÁ‰ÂpûçÂrˆ1Âsß;Âuœ¬ÂxgmÂ|Ö¤ÝÂ…åãŠþú‹D•÷Ïš•Âß'mžî˜ÂÜŽVœþœ¥ãžuŸß;¡~ú¢‰ºÂ¢Ã–¢ ƒ–ž5› —Oß“)yÂŽ°!Š Â6¬Â=ˆ1ÂDKÇÂJÒòÂPøÕÂV–‡Â[\Â_ÒòÂccTÂfaHÂi1Âk±'ÂnÄœÂr¯ÂwƨÂ~6F‚ô¼Â‡C‹¸ÕÂò-“†%–¾Â—˜˜o—ê—›#—ŠÁ—ë…˜­™“øÂšSøÂš¬šp¤Â™‹D—øR•Á‰Â’øR³¶ÂŒ ͈¬Âƒú^Â0&éÂ6F¨Â¨õÃ@l“@è“A.záAg™šAë…A£p¤A²A·ffA±× A hsAƒIºA7©ü@²$Ý¿`ÄœÀí©üÁYxÕÁ˜KÇÁ¼ñªÁÛ{Áô% ŠïžÂ5?Â}ôÂ#»dÂ(ÓøÂ,º^Â/n˜Â0üîÂ1}ôÂ1bÂ/ØÁ„Áv—Á`áHÁFA‰Á&{Àÿ\)À¥V¿ñÊÁ?ê~ú@¿|îA'ûçAtA KÇAĉ7Aã¶FAúVBr°BC–Aë²AÆ9XA’/A& J?à£×ÀÝ&éÁm`BÁ«Æ¨ÁÕ33Áô²Â—Âî˜Â9XÂ"ɺÂ*‰7Â1:^Â6¤ÝÂ:¦éÂ=;dÂ>s¶Â>t¼Â=gmÂ;yÛÁŒ33Áƒ;dÁo™šÁRùÛÁ/²Á\À¡²-¿V@NÙAG®A`ffA¡—AÔýôB¾wBqªB+øÕB5†%B4´9B(!ËB½qAÙ‹DAƒX@’ JÀèí‘ÁެÁÏ7LÁûáH qªÂ¹X”{Â(XÂ1'ðÂ9ˆ1Â@Þ5ÂF´9ÂJÏßÂM+ÂMäZÂM/ÂKH´ÂHm‘Á–G®ÁVÁ²Áe‡Á>ýôÁ…ÀªV¿féy@Œ ÅA)OßA¼jAÍ©üB W B,¬BMþúBiQìBzB{î˜Bl¼jBL`BB¨öAÁ…@îMÓÁVÁ¿1'Âô¼ÂaHÂ&RòÂ*ô¼Â0VÂ7ýôÂAG®ÂJÂÂS¾ÂYbÂ]Á‰Â_¸RÂ_°!Â]øÕÂZì‹ÂVÜ)Á¢PÁ™ýôÁŽ\)Á}çmÁUÒòÁ"—ÀÃ÷Ï¿V@¡ó¶AH(öAªÒòAüñªB,«B^G®B‡Ü)BwLB«íB¯iüB¥ýôB ÍB^\)B r°A'‰7Ái©ü†%ÂDIºÂR#×ÂKffÂC_;ÂB#×ÂHYÂSVÂ^±'ÂhÄœÂp PÂt¡Ëà CúCúCúCúÂOÂnÙ²žs¶Â¨†¨Â¬Óu¬È1©·Ï¤´¼Âž\—ٚÂ÷LÁî-ÁíbÁè²-ÁßÀƒÁÐ\Á¸ãTÁ•Ý/ÁG…ÀmVAïžAÆbNB;ËÇB™˜“BëIºC/›#CƒC¾ñCÏëÇC“×+C]¶FCEp¤C=BèNÙŠøRCúCúCúCúÁÈ“Â"V‚!˦š Â¼‘hÂÇøÂÉs¶ÂÆk…ÂÀ\·Ü)®Ô{Â¥²Âœœ)Â.•Â\Âl‹ÁüvÉÁéxÕÁÊ™šÁ›‰7Á,ùÛ?Å`BA— ÅB+e`B—r°Bó”þC>&éC—³×CúCúCŠqHCKúCj’°CúCúA[ÎÙCúCúCúB m‘AK¸Â-33Â¥ˆ1ÂÓ¾úÂê€Âñ£TÂîäZÂæRoÂÚ·LÂÍæfÂÀúá´’ò¨ûç¨ö†%ÂSøÂXÂ\Â’oŠ=ÁäVÁ£™šÁÂAÙB«B…]/BÞñ'C/›#C†‹dCÀQ'C³›…CúCúCúCúCúCúCúCúAå JAð§ðÁĠ¥l‹Âö’òÙÛý/Ã2òô{àÂùýôÂæÁ‰ÂÔÇ+ÂÄr-µÑìÂ"W Â)1'Â/ˆ1Â4¤ÝÂ7jÂ6C–Â/ÂÔþÂÁ§ JÀS Aª BNÌÍB¬½ôC¢C6/C[F%CúCúCúCúC%àÅBÁ±'CúCúCúCúCúCúëDÃCѪÃO ÃIñ'Ã=ü¬Ã.žÃKÇÃÙXÃ÷ÏÂé­ÂÔº^³3Â2æfÂ=C–ÂGå`ÂR"ÑÂZÑìÂ`Â_0!ÂTe`Â:Ú ýôÁ~{A7;dB$ožBb®CúBn“B«¹XB÷=ôCúBÒòBwÄœB¥ŒJBR_;CúCúCúÂ'8RCúCúÃv"NîݲÙ5È~˜ÃsHÃTÖÃ9–‡Ã"bNÃ'+Âþ³¶Âä«…ÂÏVÂCÞ5ÂR2-ÂaÙÂrVÂC–ˆ!Ë‹ó3Š Â}A‰ÂIqªÁÒ¶FAO¡ËBuÛ#B‰Ö‡CúCú¿UCúÁ®9XCúAÊPCúCúAºýôAÏÄœAw…Â> DCúCúCúCúÃÕ*^üÎ5ÜևÃ7ÃWs¶Ã6YÛÃîà 49ÂóB ÂÚ0¤ÂTš Âg0!Â|ožÂŠ¬Â–ٚ£I7­{°A§)üŠ7LÂs¶AϸRCúCúB„;@èIºÂTéyCúCúCúA¥ãCúCú@õ7L¿Ä›¦@¶¬Â ÅCúCúCúCúCúCúÃÇîÙÚBÃtË…ÃHvÃ(ÍPÃu?ÂÿPåÂãYšÂdLÍÂ{$Ý‹¦Âšýq­!ËÂÀœ)ÂÒ½qÂÝþúÂÚ#½§ðÂu¬Ab‡+CúCúCú²ÂéüÃoßÃæ%ÂɈ1ÂDœCúCúCúÂô¼AyXBg.Á+‡Â7šCúCúCúCúÃïíPð0åÃ…¶‡ÃUE¢Ã0ñìÃ5ÃÙÛÂéÙÂr J†_;–ž¸ÂªcTÂÂ!ËÂÝÓÂú+…Ã~úà \Âþ÷LÂÆøÂ@`BB ÖCúCúÂÁŸ;CúCúCúCú›´9CúCú©SøÂZ/CúCúB‘s¶CúCúCúCúCúÄ\Íø¢ÃˆùyÃY ƒÃ3Ê=ÃoÃÏßÂí9XÂ|î˜ÂIºÂŸ¤Z¶‚ ÂÒèöÂõ\¬Ã\ùÛÃ'޸à _}à ‡Â̦f‰Á‰CúCú¦éCúCúCúCú¹¨s‡­‘Cú¨î‘V‡CúCúCúBa;dBÃ5ÂÑÃähsCúÃÞožÃ¦û…ÃëÃRݲÃ0öFÃ?;ÃsøÂí]/‚+…‘ÑìÂ¥Rò½×Âܲ-ÃiüÃ}qÃ,ÄœÃ9e`Ã8ÄZÃ&HöÂýZ Â³˜“CúCúCúCúCúCúà ާMÓCúCúÂq’oÂÅ#CúCúCúCúÂÜ)ÃoÃŽúíQ‰Ã£C¶Ã‹?¾Ãi=/ÃEE¢Ã)”9ÞâÂꅢƒð¤Â“¨ö§)y¿†¨ÂÝî˜Ãˆ´Ã¶ÉÃ+Ã8$ZÃ;8ÕÃ,yšÃ|¬CúCúCúCúCúCúCúCúžwCúCúÂÏgðÃ(Ñ'CúCúÀ·+A.ýôÂ]?}à ©üÃQIyÃw€ƒÃy³øÃf°!ÃMF%Ã4ÑìÜjà ÒoÂþ‰Âå:^ƒÏßÂ’ã×Â¥Qì»æéÂ×]/Â÷Äà ”¼ÃÉ7Ã'¦¨Ã'ã×Âð/CúÁƒ^5BË}CúCú>åãTCúÞwCúŸoCúÃŒFCúCúCúCúCú—¢NÃå`Ã0™šÃGr°ÃL/ÃCìÍÃ53øÃ$²°ÃÑìÉÂóéüÂÞ%`‚œÂçm ~ú´=qÂËZ ÂåTþÃmà gðÃXÕíÃI7ÂÒ)„ÁöõÃAšdZBc‡+B(¹XAïƒBhµ?CúCúÂÙ…CúÃv49Ãzÿ}CúCúš*Âz¬ÂÃc×Ã!Ë÷Ã,¢ Ã/±ªÃ+ôÃ!ÅãÃ@à KDÂý¸ÕÂè¿}ÂÕéyÂ}Ø‹J=™©yª+…¼¦éÂÐJÁÂã$ZÂñÀÂ÷¤ÝÂðÞ¸ÂÛcT·æfŠ%Â-YÁ—\)À.ff@¨“AÄùÛBY‡+Aó¶ÂQìÂ-e`CúCúà s¶CúCúCúCúCúÃ2oÃû#Ã^¸Ã×Lã×Ã5à ±ìÄZÂî°¤ÂÝ9ÛÂÍ\ÂuÝ/Â…¬‹Â‘È1Ÿ,‹Â­{dÂ»× ÂȦéÂÑPÂÓÌÍÂÍ&f¼¸R£|î„F%ÂFvÉ ÀƒÁ¹ÌÍÁZ—À ƒ@G+ÁK…Áôn˜CúCúCúÂõPbÂ’oCúÂ< PCúÂÕvFÂô\à üà ‹Dà záà oÃ9ÛÂý¤ZÂï<îÂàaHÂÑÑhÂÃüjÂlÜ)Â6F‰¡Ë”QìŸ<î©/²@ƒÂ·—¸‰Â²H1¦²Â”_¾Â~‡ÂQ»dÂ)RòÂZÁÞ+ÁÁdZÁÕE¢ÂožÂ@p¤ÂxÂC$ÝÂGàBÂL'ðÂOøÕÂS`BÂV|îÂY…Â\¾wÂ`xÕÂeÂj‹DÂq'ðÂx°!€gm„ƒ–ˆff‹ÌJÂŽÂq'‘´9Â’{ç“ P“ B”O\•å• –4¼Â–>ú•Ô²°Â“ JÂٚŽ)y‹\‡ BƒñªÂ€ Â'š Â,Û#Â2Â7Â;ƨÂ@E¢ÂDwÏÂHaHÂL JÂO–‡ÂS%ãÂVì‹Â[²Â_æfÂe_;Âk‡+Âr7LÂy.€1ƒA† ˆlŠ6F‹„œÂŒr-Â#×·ÏÂŽ=ôÂŽ²°ÂœÂšÂŽÙÂŽ/Âo‹€Â‰}q‡{„RòÂI7Â| PÂu6FÂ"záÂ'LÍÂ, JÂ0¯Â5)üÂ9uÃÂ=‘hÂA~úÂELÍÂI\ÂLãTÂPéyÂU@ƒÂZÂ_;dÂdß;ÂjÌÍÂpÒòÂv²-Â|)ü€‚‚\„33Â…xÕ†n‡&釴9ˆ¸Âˆe㈀ˆ_;‡ô¼Â‡4¼Â† „›#‚Ö€˜Â|DœÂvÛ#ÂqVÂjõÃÁeƨÁW®ÁG Á3ãTÁïžÁ/ÀÓt¼À—•À/l‹¿)º^?·P@]ãT@ª§ð@Ý&éA&éA =A zá@ür°@˶F@ƒ²?›Æ¨À ¥ãÀ¼ƒÁ÷ÏÁXáHÁ‰VÁ£éyÁ»Ý/ÁÑ5?Áä(öÁôó¶ÂâNÂY ãTÂÂ33ÂþúÂî˜ÂbÂwÏÂ7LÁm7LÁ]ÒòÁKxÕÁ5Û#ÁÈ´Á{À¿t¼ÀoP¿§l‹?£o@{ƨ@ÒMÓAå`A3¡ËAN~úA^“uAa7LAT‹DA7²-A 7L@¡ë…?BMÓÀ{dZÁ “ÁVùÛÁŽ ÅÁ­ JÁÈVÁ߉7ÁôVÂV ÂöÉÂçmÂÎÙ ¨öÂ#yÛÂ%KÇÂ&2-Â&DœÂ%²ÁvÈ´Áf9XÁR ÅÁ:¬Á¾wÀùÀ­ÒòÀ0õÃ>A‰7@XÄœ@Ø“A"¼jAW¥ãAƒ´9A—A£Ÿ¾A§PA¡G®A AhƒAb@Чð¿ÙûçÀûC–ÁZýôÁ—;dÁºéyÁØÀƒÁñÐ寠. ÅÂuÂ#r°Â(¨öÂ,§ðÂ/p¤Â1bÂ1Ÿ¾Â1>wÂ0bÁvÉÁqhsÁ[¾wÁA\)Á!®ÀøA‰À ‹D¿î¸R?Ù7L@´bNA¬AdáHA•©üA¶ƒAÒ9XAå©üAíÆ¨Aè(öAÓ\A°33A¥ãA "Ñ?CoÀç¾wÁjE¢Á§¶FÁÐA‰ÁïãT–‡ÂV Â!âNÂ)áHÂ0ÄœÂ6W Â:yÛÂ=)üÂ>yÛÂ>PÂ=bÂ;°!Á‰VÁó¶Ái%ÁL‡+Á)™šÀþÙÀšMÓ¿‘&é@H@þVATn˜A—áHAÆÀƒAô1B ïžBÍÓB$8RB";dBÑìAþ+A¾\)Aa‡@Z=qÀèÌÍÁ‡¸ÁÄó¶Áñ©üÂ-Ân˜Â!ËÂ&\Â/Þ5Â8™šÂ@33ÂF=qÂJƒÂMÂM× ÂM;dÂKjÂH ÅÁ’hsÁ‰A‰ÁzÈ´Á\—Á6È´Á¬Àž—¿1hs@‹ =A#oA†©üAÁMÓAÿ‘hB =B;Ç®BR‚ B_TþB_BOèsB2MÓBÓøA¦bN@Æ=qÁß;Á«|îÁøÆ¨Â»dÂYÂ&1Â,àBÂ5“uÂ?’oÂI†%ÂR6FÂXå`Â]IºÂ_l‹Â_Š=Â]ô¼Â[ÂW 7ÁÊÁÁ”áHÁˆõÃÁr¸RÁJ§ðÁÀ±º^¿49X@¥xÕAB¼jA¢× Aí~úBæfBK+Bt´9B‹ÏßB–›#B—áËBŽt9BuãTB=JÁAëÙA‘hÁ8¸RÁïÂ+^5ÂB ÅÂA­Â<Ÿ¾Â=†%ÂEIºÂPò°Â]%ãÂg“uÂo!ËÂsŒJÂu1Ât 7ÂqVÂl–‡ÂgVÁ«n˜Á£/Á—©üÁˆVÁfÌÍÁ1 ÀØÝ/¿®Ù@«…AYPA¼(öB î˜BB¸RB}í‘BI7B¸e`BÊqªBÍÞ¸BÁuB¦ÖBÐåB$ŽVAR1Á„ûçÂ/²-‚޸‘µÃÂxÂU·LÂLšÂT49Âd"ÑÂt‚ €ÌÍÂ… ‡'m‡MÓÂ…ð¤Âƒt9€/žÂxÑìÁ»‹DÁ´záÁ©ó¶Á›Á†l‹ÁU¡ËÁ áHÀ:n˜@“•Aal‹AÎÒòB å`Be¼jBšÝ/BÆÈ´BñhsCü¬C õCp¤BÛjB®Be†%A1'Á²E¢ÂxšCúCú [¦ÂfÈ´ÂPÍÓÂ`IºÂzbNˆò-‘DœÂ•ñªÂ—yÛ–P“ÚÂñ'‹H1†49ÁÎG®ÁÉÁÀ7LÁ²ÂÁŸ;dÁƒãTÁ=/À²ùÛ@&AS¸AÕÙB/-B‚òB¶,Bô%Ci7C5úC9ÇmC#ÂNCqBØáHB¢A‰BcTÁÐvÉ™©üé7Cú”ÌJÂ8ãTÂ;=qÂjšÂŒ+œõ?§‰Â«m«›#¨Ï\¤hž(ö—¥`ÂêÁã¸RÁàùÛÁÚÄœÁÏÒòÁ¾‡+Á¤ÌÍÁ€bÁA‰¿hsA'AËí‘B3†%B‹eãBÊÅC  C>=qCjФCmÄZC>¯\CúCúBóxÕBbå`ÁÞ¬CúCúCúCúAÊÁ ’oÂÎÙ¤¿}º>úÂÄœ)ÂÇ-‘Âĉ7¾ Å¶ۦ®1ªÂ¥E¢Âœ|jÁûÒòÁüdZÁùÄœÁò‹DÁäß;ÁÎ\)Á«÷ÏÁsÊÁÀÍë…@³;dA­C–B*qªB‹#×BЇ®C6‡CMºáC‚ôCIüC4È´Bó¨BÿÐåC<-CúCúCúCúCúCúBgÂ"Ñ¢÷ÏÂÐq'Âæ:áÂí>úÂëÂã:áÂØqªÂÌYšÂÀ ´ ºÂ¨Ã 33 “u›¦Â ˆ1 På“uÁã1Á³ÊÁÁ[ë…¿´9XAu%BB€BÂféC Í‘C7ô¼CYcCA¯ßCúCúCúCúCúCúCúCúCúCú?¼(öŸïžÂòÈ´Ã ô¼Ã\)à =à E`Ã.˜ÂödÝÂäffÂÓXÂèöµz^‹DÂt¼Â"jÂ$¡ËÂ#ñªÂ»dÂÔþÁú÷ÏÁ¶¥ãÁ"ff@îMÓAï7LB^†%B¤Ý²BÛçðCìCµÃCúCúA. ÅCúBš— CúCúCúCúB ®CúCúÃ%MÓÃ>½qÃEŽÃ@?}Ã5»¦Ã(YšÃýqà 7Âþr°Âç£×ÂÓ¥ãÂÂ9ÛÂ(£×Â0…Â8 Â>QìÂB.ÂA®Â:“Â'ÏßÂF¨Á Sø¾NÙAÌ\)BQ#×BŒ×B›¦éB§:áB oB#ì‹ÁÿV?å`A€9XB%ÂAæbApZCúCúCúCúCúCúØ×+ÊÁÃzbÃa÷ ÃI‚NÃ2z^ÃÕà ©üÂûò-ÂãDÂÎvFÂ8bÂCBÂNÔþÂZbÂcœ¬Âi>wÂg|îÂYqªÂ8“uÁøãTÀÔ›¦Aé/B‹ÎÙB­ØB‡gðBR]/BŠ=@Œå`CúÁOßA{™šCúCúB-[#CúCú¿³•CúCúCúCúðhÞ¶ÃЧLÃn ÃL“Ã0 ÃžÃròÂñbÂÙ…ÂGÔ9Ãe‡®Ãk•?Ã]ò°ÃHÒoÃ3–Ã:^Ã#Âÿ>úÂæ­‘Âw{‡ß;–^¸Â§?}ºn˜ÂÏ5Âã&fÂòˆ1Âø DÂîÍÓÂÓ ¤™ÂJå`ÀʬBzÀƒCªBk%ã¦CúÂDLÍCúÂð6FCúCúÃYûdÃÙÂú‰CúCú‡B à èöÃ2ü¬ÃGÀƒÃK…ãÃC|îÃ5a‰Ã%c–ÃÌÍÖÉÂöVÂà%`Ât”{Â…ÁÂ’øÕ¡þw²ÓÂÿ}ÂÓ²ÂÞíÂá ÅÂØ‰Â¿ºá˜ëÂJÅ¢Á™¬AgAìÐåAb ÅB ÇCúCúÀ¨‹DCúCúCúÃ[àÅCúCú¨œ)ŸaHÂîWÕ?Ã)ëÃ3ôþÃ4Ô{Ã.ÎÙÃ$šÃPà ‡+À]¡Ë@Ò—B‘¾úCúCúBLúáCúCú®™šÃ3CúCúà ÇÂêóuÃBÃþwÃ#¿;Ã#éà Ã6à ܬÃãÂò¼jÂàŠÁÂÏÎVÂi>wÂ{cT‡Ÿ;Â’6É §(ö¯W ³ƨ²‹Dª“™Ï\‚[¦ÂK¡ËÂ0!Á¯× Á®@ÛÆ¨B¨öB„Ÿ;Bk5?BS\CúCúCúÂÇNÙCúCú§ðÂÀÐåÂö¾wà ýôÃþúÃøÃíÃܬà ´¼ÃOÂô¼jÂäÅ¢ÂÕ^5ÂÆäZÂa»dÂqhs Í‰¨öÂ’™œ¬ÂŸ:ᡵßÎV˜˜‹Ê=ÂsèsÂI\Â'ðÁÛÄœÁIºÀW;dA ÅAe©üAA}ÎÙCúCúÂ]m‘ÁõÐåCúCúB@ËǺ^ÂÛÁ‰Âû^¸ÃœÃPÃÂNÑhÂýk…Âñ˜Â䬋Â×m‘ÂÊc×½æéÂYÁ‰Âg.ÂušÂƒˆøÂ¯‘–Â’õ?‘‹5ÃÂožÂhA‰ÂH‰7Â&uÃÂ× ÁË&éÁ•ïžÁví‘Á˜~úÁïýôÂ=áHCúCúªž¸Â.¬AÏVB`‡ÁjbN§ðÂÊC–ÂæÂòùÛÂ÷ÓÂö“øÂñ©üÂéùÛÂàuÃÂÕâNÂÊٚ¿ÍPµ ÁÂQ¸RÂ]1'ÂhÐåÂt#×Â~ƒƒˆ1†aH‡AÂ…ªÂRòÂtt¼Âa~úÂKMÓÂ4(öÂå`«ÂwÂmoÂv¯€Ö†hsÂ‹× Âž5”aH–õ?˜‚ ™iüš.›4¼Âœ¡HžQhŸöF¡5áËǡߠvÉžŠ=›߾˜•”ËÇ¡HÂŒ49‡²Â)¹XÂ/¬Â4ZÂ9\)Â> JÂBVÂF.ÂI”{ÂL›¦ÂOhsÂR5?ÂUVÂY%ãÂ]ýôÂdšÂkƒÂtÂ} Ń(ö‡~ú‹NÙÂŽiy»dÂ’aË“\”†%•{d–ƒ–—ߘxÕ™ P™#T˜Ÿ¾Â—vÉ•«“J=Âgm‰vÉÂ…— ÂÓÂ$¤ÝÂ)–‡Â.l‹Â3‡Â7‡+Â;²-Â?“uÂC1'ÂFœ¬ÂIõÃÂMhsÂQ/ÂU„ÂZ›¦Â`bÂgZÂnÇ®Âv‚ Â~%ウfÂ…ÐåˆwLŠbÂŒ-‘ÂiüÂŽiyÂF¨ÂÙºá‘6F‘eã‘0!ƒÂV‡Âª‹‡+ˆøÕ†b‚޸Â~êÂwɺÂë…Â$€Â)Â-bNÂ1œ¬Â5©üÂ9Š=Â=DœÂ@èsÂDŽVÂHW ÂLiyÂPèsÂUñªÂ[ŽVÂa°!Âh.ÂnËÇÂuA‰Â{JÁ€X‚¦é„‹Ç†å‡DœÂˆ9Ûˆÿ}‰œ¬ÂŠ ÓŠH´ÂŠ=q‰ܬ‰¦Â‡ô¼Â†fé„xR‚1'Â;dÂy•ÂsŒJÂm9XÁc‰7ÁU²-ÁE|îÁ2ÌÍÁPÁ¶FÀÖÙÀÛ#ÀBÀƒ¿‹…?]ó¶@/ÎÙ@Ž~ú@¼1@ܬ@ìÄœ@éOß@Ð9X@ Äœ@7ÎÙ>$ÝÀD¬ÀÒ-Á#dZÁ];dÁŠC–Á£ïžÁ»OßÁÐVÁã(öÁóïžÂe`Âå` záÂ"ÑÂàB¶F¯ÂÛ#ÂJÁÂuÁj^5Á[7LÁI?}Á49XÁó¶ÁQìÀÂÀƒÀ}/¿Ô9X?BÐå@NÈ´@µ%@ýOßAÂA5C–AB\AC`BA6$ÝA=q@àj@g ¾È1'À—ïžÁûçÁZ^5ÁއÁ«ß;ÁÆG®ÁÝ\Áò Â(ö 7LÂBÂIºÂC– /Â#\Â$ð¤Â%äZÂ&Â%iyÁs+ÁbÐåÁO Á7®Á9XÀøí‘À°›¦À?;d¾V@1‰7@¼IºA¬A?Û#Aj=qA…Ý/AKÇA’¾wA‹÷ÏAvÝ/ABéy@üÝ/@5?}À+•Á+Á[®Á•&éÁ·záÁÔÝ/Áî J ½qÂiy =Â"\Â'ãTÂ+üîÂ.Ü)Â0bÂ133Â0äZÂ/ƨÁ~VÁlõÃÁW¡ËÁ=Û#Á¸ÀõûçÀ¢=qÀp¤? Äœ@G®A  AM+A† JA¢áHAº›¦AÊ‹DAÐ(öAÉ\AµÙA•bNASxÕ@Övɾě¦Àò¬ÁdÄœÁ¡‡+ÁÈ£×Áè^5ÂIºÂ ²ÂÒò ¸Â(m‘Â/‹DÂ5IºÂ9\Â<^5Â=ÊÁÂ=ùÛÂ=Â;KÇÁ†$ÝÁz-Ác|îÁG‰7Á%™šÀùãTÀ™ë…¿©xÕ@*-@ã®A?•AˆÐåA²33AÙZAúß;B iyB¬B »dAÿÎÙAÖÙAž¬A5ÊÁ@|îÀæÁ{OßÁ¶~úÁâ(öÂ@ƒÂ Þ5ÂçmÂ#bNÂ-k…Â6¢ÑÂ>ŽVÂDÒòÂIG®ÂKî˜ÂLì‹ÂLt¼ÂJÅ¢ÂH¦Á޾wÁ……ÁsdZÁU²Á0¸RÁ¥ãÀš¸R¿O\)@xÄœA5?At^5A®MÓAä~úB Å¢B$ffB69XB?6FB=%B.±'B°!AàÔþAˆ @™²-Àï Á“Û#ÁÙOßÂ9X¬ÂÖÂ&qªÂ1 ÂúB¨B‹ÀB/­AhffÁPÐåÂ33ÂeÂÂv/ÂD„Â,äZÂ9—ÂV%ãÂt D†@ƒÂ޾w“š•`Å”¾wÂ’WÂŽ¸RŠPåÂ…u?ÁÅ…Á¿;dÁµjÁ§%Á’ÌÍÁnjÁ$õÃÀŠ5?@V§ðAP$ÝALJ+B›¦Bb¬B˜B BÂZ BéŒJC8“CZ^Bå“CúCúCúAƒ‹DÁl5?Â#ÍÓÂs/ÂC;dÁžA‰Á·ÂÂÐåÂ_ PˆH1™9X£W¨¨™¦F%¢ƒÂœ†%–bNÂöFÁÙÁÔÈ´ÁÍÁÀvÉÁ­²-Á’ß;Á[•Àï¶F?3t¼A3º^AÃñªB#_;BrJÁB§t9BÚô9Cr°C6ÉCÜîBó¸CúCúCúA›‘hÁªº^ÂÈ´Â ÌÍCúCúAÞp¤Áì;dÂtffŸ;ç´iü¾å`ÂÁþúÂÀ/»´–¬£¡Ë›G+Áîß;Áí^5Áèl‹ÁÞ¶FÁ΃Áµ©üÁ‘‡+Á>{ÀUó¶@ûÎÙA±ffB§ðBuJÁB¬ÙšBä«C ýqCgmCßBÍó¶B_ß;B|”{BÉECú–¥ãÂ-ñªAÅ CúCúB‡Ú ÂþúšX“ÂÆ‹ÇÂÜ =ÂãÊÁÂâàBÂÜ›#ÂÓEÂÈn½¦Â±î§AÂqªÂiyÂÐåÂéyÁõn˜Áßë…Á¾$ÝÁŒZÁ Ý/@=`BAñªB‡BjÂB¦¾wBÚïCì‹C dÝBרöB?­CúCúCúCúCúCúCúC!æ¨CÇ+AXbNÂ_¾Âߙô9à ߾à ó¶ÃÄÂþ^¸ÂîûdÂß =Âω7ÂÀþw³¡HÂ\)ÂhsÂ&éÂÇ®Â/ÂÜ)ÁóÂÁÃÙÁy™šÀN{AOÊÁB²BYÙB™G+BøBár-BÕš B*¢ÑCú¤þwCúCúCúÂÍ6ÉCúAÑ—CúA÷n˜CúCúÃ&ŒÍÃ.ÖÉÃ..ÙÃ'»dÃå`ÃyXÃÇmÂ÷:áÂâ½qÂÐYÂÀ¢ÂçmÂ#_;Â'êÂ*°!Â*qªÂ%e`Â(ö»dÁ½C–Á%¡Ë@÷"ÑAîjBRâNB/BªÊÁBº[¦B¤QìAA‰CúCúCú@PƒAÔ{@VCúCúCúCúCúCúÃc~wÃbŠ=ÃXRòÃIÚ Ã8ÞwÃ'\)ÃÏ\ÃïÂõÔ{ÂßPåÂËêÂ+²-Â3ÚÂ;š ÂB¦ÂEþúÂE0!Â<º^Â(³3ÂOßÁ”hs@#ƨAïzáBiŠ=B™ 7B¡Ê=B¡¬‹B‡Æ¨A¨çmCúCúAZB;&éB+.B^5CúCúCúCúCúCúCúÆàÅÀ™yÃlÛ¦ÃTyXÃ<>wÃ&féß}ÃËDÂí ºÂÖ´¼Â9;dÂD:^ÂOwÏÂZ+ÂbéyÂg]/ÂcöÉÂSƨÂ0Š=Áån˜ÀAð‰7BЍöB´¦fB§bÑB¦uÃCúCúCúCúÂ/ŒJÀêÀ{Sø@‰¡ËB3ÙBŠã×A £×CúCúCúCúÃ¥ãÃÛ…Ã…‘ËÃm¨ÃN¢ Ã3ã×ÕÃà J=ÂøßÂßÁÂEì‹ÂS¸RÂb~úÂq˜“¨öÂ…šÂ†”þÂYšÂchsÂ&¼jÁ…ãTA dZB~=qBª9ÛB“p!CúCúCúCúCú½G®CúCúCú@ÍûçBÐVCúCúCúÃÝqÃS(sË1HÖÓÃ!ËÃ}ÇmÃ[mÃ=\îÃ$ª=ò-ÃÂæ|îÂQ!ËÂas¶ÂsyÛƒ^5•mšr°Â˜Ö‡ÂŒ/Âc Å ƨÀw+AäéyB2&éB2k…Bm-CúCúCúCúª,‹CúCú®®AãTBÙPbCúCúÁ¬CúÂàäZÃrdœÃ“‡ÃYºÃ"°Ã_âÃAIºÃ(ÂÑÃáÂêƒÂZ;dÂl†%€Ó‹Ú—¤Z¢Á«­¤ËÇÂŽß;ÂT =Á蟾ÀÈAn˜A³ÒòB5å`CúCúÂU¾ÂÆ<îCúCúCú \B ÓøBUÑìBq¡ËAå CúCúCúÃD©yÃ…öéÈ`!ÃygmÃ[r°Ã?[¦Ã'iºÃ›¦ÃPbÂë°!Â`ÓøÂtXÂ…>ú‘Pž¥`«p!µÏߺ€Âµ¢Ñ¤„ ÅÂ5Ü)Á¼ÂÀ2 JA£&éBí‘A—ûçÁÿQì§™šÃ¸“CúCúCúºšÁñXÁÈ´>Ù™šB¦éBÊDœCúÁç‹DÃ5{dÃok…Ãw²°Ãh ÍÃPƒÃ8¹ÛÃ#ròÃCÃó3Âê)yÂd£×Âxƒ‡…”+¡\)®yX¹c׿“¼ P­5?‘!HÂRÐåÁço¿ß|îAÌ"ÑA½ÐåCúÂÅ—ÂðyÛCúCúCúÃ:ŠÁú ÂÙ‡+½ÌJÁ“ûçCúCúÁÞÂCúÃAäœÃ]"NÃ`•ÃTãTÃB²òÃ/KÇÃ;à ¢Âþ/ÂæH´Âe¯Âyu‡m‘“bNŸöF¬&f¶&f»O߸’ò«DœÂ#ɺ²ÁÔ\)Á§$ÝÁ‘-Á¡× ÁïVÂARò‘qªÂµ—¹Á¦W –Âhí‘ÂfW ‘¸cTÂÕ+…Âæ1ÂíäZÂï‡+ÂìÖÂç;ÂßYšÂÖEÂÌvFÂÂ_;¸P宆¨ÂBÂJ‚ ÂRÅ¢ÂZl‹Â`ýôÂeãTÂhzáÂh¾ÂdJÁÂ\¤ÝÂQ.ÂBXÂ1C– ¦ÂyÛ ë…ÂuÂ&ÓøÂIýôÂ|²Â™Ø®#²üî«SuŸ‰Â–ۦ˜Š=¦®Â¸ BÂÉ 7ÂÔ1'ÂÚ ºÂÛ„ÂÙ¤ZÂÕF%ÂϾÂÇÅ¿­·5?®¤Ý¦/žÂ;¬ÂC"ÑÂJPåÂPêÂV”{ÂZäZÂ]l‹Â]ɺÂ[³3ÂW{ÂP!ËÂG€Â>r°Â7 PÂ40!Â8²-ÂEÏßÂZµ?Âv-‹7L›¬Â¦¬‹Â«(ö©–‡Â¥b£þÂ¥¬Â¬“µ¼î¾ûdÂÅÛ#Âɳ¶ÂʦéÂÉ$ZÂÅ«…ÂÀ·Lº²°Â³ùÛ¬ØÂ¥ˆ´Âž9XÂ5®ÂÁ‰ÂBž¸ÂE× ÂHe`ÂJYÂKâNÂMVÂO49ÂR$ÝÂVÜ)Â]êÂgs¶Âs¦é†)yÂŒh‘.•8Õ˜¦Âš ºÂ›f霨öž$ÝŸñ'¡âÑ£§ð¤éyÂ¥fé¤ýq£¦f¡r-ž{çšå`–ÒoÂ’dݺ^ˆî˜Â%î˜Â*êÂ/¼jÂ4OßÂ8\›¦BxG®B˜LJB¯Bº–B³ÐbB ºCúCúCúCúÁ “uÁ¡ZÁ´‹DÁ`‹DÁffÁ££×ÂZÂW­ƒǮ”.˜Âž2-£;¤.¢p!žÖ™ٚ”4¼ÂŽ5?ÁÎPÁÉ{ÁÀ{Á²vÉÁžïžÁƒõÃÁ?‘hÀÂ?½p¤A. JA²hsB9XBLþúBˆ/B©„œBIJBÐ =BÄDœBª=qCúCúCúCúÁB^5Á‹vÉ¿í/B ÌÍB+Y@›oœ¬Ân¢Ñ˜°¤Â¬¤Ý·ºÒo¹Û#µÖ¯·L¨ß æf™ ÅÁâ ÅÁÞ× ÁØ ÁÌp¤Áº—Á £×Áxå`ÁX¿¾ùÛA ÂA¨A‰B>wBSuBŽ™šB³ŒÍBÐÌÍBÙ@ƒBÀ¨sB†ò°CúCúCúAçÀƒÁÖ®ÁÙ A€ZB«Z B±B A/ÂxÕ“c׺c×ÂÎð¤Â×}ÂØ#TÂÓ§ðÂÌ Í¼!®‡®Â¤¦éÁ÷‘hÁ÷%Áó‡ÁêffÁÛ1'ÁÃG®Á ‡Á]|îÀ±xÕ@¥ÊÁA“éyB 0!BPúáBSøB¶“BÔ›#BاðB«“uCúCúCúCúCú·QhCúA°!B…­‘BbãTÁƨ…wLÂÉ;çÂí\Âý ÓÃ&%ÂûhsÂñ—Âå¾Â×’òÂÉñªÂ¼Óu°‡®ÂE¢Â¨ö DÂE¢ÁëÈ´ÁÊ©üÁ™Ÿ¾Á*“?=²-ApMÓAþõÃBJBŒKÇB´BBØQhBâzáBݲA%ûçCúCúCúCúCú ÅA¹VCúAƒÂÂm(öÂäLJà ÿ¾ÃòoÃÉÃ^¸Ãô9à z^Ã(sÂí/ÂÛÍÓÂËX“¼gmÂE¢Â•–‡ÂvÉÂh ß;ÁûçmÁ̇Á…‘hÀ‘ãTA0ZAëC–BD“Bˆ³3B°;BÝp!CöBÇCúCúCúCúB¨Â<ÔýôAÀÒòCúCúCúÂÕ/Ã&dœÃ8£Ã=[dÃ:†fÃ2ÁHÃ'²oà üÃ(´ÃëÂíxÕÂÙ{çÂÇÐåÂt¼Â$å`Â)[#Â+ùÛÂ+~úÂ&"ÑÂ\ÂêÁ¾$ÝÁ,Ù@θRAÙ‹DBBbB†Ÿ;B§|jBÍÜ)BæÙB'OßCúCúCúCúB‘féBÁ‰BfäZBhVCúÂ&­CúCúCúÃ_]²ÃWµ?ÃLAHÃ<öÉÃ,áÓuà g+ÂýëÂæ~wÂÒ9XÂ+ffÂ3hÂ:,Â?ÚÂB¿}Â@Þ5Â7s¶Â#1ÁÿZÁ“"Ñ>Ä“A¼ïžB=ÔþBƒ"NB™°¤B¬;çB=ôCúCúCúCúÁÔp¤Â¸]²CúB‰2°BKe`A G®CúCúCúCúÃo’°ÃlXÃa ÇÃO+DÃ:á‰Ã'*=ÃhöÃüjÂñ’oÂÛhÂ6œ¬Â@yÛÂJ?}ÂSÂY¡ËÂ[´9ÂV8RÂE2-Â$‡ÁÝ ÅÁ5?Ay%B!NÙBiF¨B‡O\B”¥`CúÀØ£×ÂÇ}qCúCúCúCúCúB(¦BX“B ?}CúCúCúÃC%Ãi-PÃtÃÃmç+Ã[½²ÃEHÃ/©7ÃXà C–ÂùûçÂáÚ Â@”{ÂLm‘ÂX¤ÝÂdyÛÂnbÂt¯Âs‰7ÂfÑìÂI½qÂÁ /@!©üAÎ× B27LBdáHBZB_ožA0ýôÂ(F¨ÁÄ-Â0VCúCúCúCúBá£×CúCúCúÂùXà è´ÃSÍPÃq»çÃq”{Ãa'ÃJ«ÇÃ4(1Ãß}Ãf¨Âÿ3¶Âæ7ÏÂHÌÍÂV:^ÂdiyÂr®Â¾w„±ªÂ†#T‚ÂkÅ¢Â?½qÁý× Á6£×A$ÌÍAô~úB?E¢BbLÍB0A ÌÍAh1CúCúCúCúCúCúBÑ ÁFbCúCúCúŠÌÍÃ>ìÃiõÃnBÃ_zÃJF¨Ã4yà ‘hÃC–ÖÂèÂNøÕÂ]p¤ÂléyÂ|ƨ…çð‹ò°ÂŽàÅŒӂ¨öÂ^Á‰Â$ožÁ³;d¿²MÓAhsBô¼Bu@ÿC–ÂÄœÂHÌÍCúCúCúCúA;¶FBz-@¹ó¶ÂXó¶Â¿ ÍCúCúÂÍ ÃE®VÃfËDÃgq'ÃY!ÃEpbÃ1/ßÃzáÃNÂÿ/ÂçO\ÂRÚÂa½qÂq±'Âbˆð¤ÂwL“#‘ٚ‰ŒJÂpì‹Â;æfÁìIºÁ~úA#ß;A£¿î5?CúÂÞ…CúCúCúCúCúCú•©ü±H1Âà CúCúCúCúCúÃh,JÃ_ëÇÃPžÃ=£TÃ+=/Ã-Pà ÷ÏÂû\¬ÂäZÂTs¶Âc&éÂrÍÓÂiy‰ ÁÂYÂ’î‘üÂvƒÂF‰7 7ÁxÐå?ŽV@ÌÌÍCúCúCúCúCúCúCúCúCúCúCúÃ:ƒTCúCúCúCúCúÃbýqÃU6FÃDÚáÃ3íPÃ#„ÃIyÃbÂôÒòÂßÂSõÃÂaõÃÂp¯Â…†±ªÂŒF%ÂDœÂŽ"чF%ÂrÊÁÂH ÂñªÁ¡ÀÄõþÍÒòÀà“CúCúCúÁHÐåÁ,ÄœCúCúÂäKÇCúCúCúCúCúÃþwCúÃd ‘ÃTóøÃF¼jÃ7ÝôÃ(þ5ñªÃ \jÃ4{Âì•ÂÙ,ÂQµ?Â^©üÂl JÂy=q‚/‡:á‰j‡çðÂiyÂiÔþÂDbÂë…Á¶záÁ´9¿Äzá¾íVCúBw ÅBˆ´B\l‹CúCúCúCúCúCúCúCúù7ÃjñªÃZ" ÃNX“ÃBnÃ6j=Ã)ö‡ÃroÃM‘Ã×Âö}ôÂã.˜ÂÑÖÂN¬ÂYÓøÂe±'ÂqÂ{ Â1ªÂ‚›¦Â€È1ÂujÂ_!ËÂ=éyÂF¨Á½-Á“u@MÒòA‘ß;B{ƒCúCúBèsCúCúCúCúCúCúÃ’-Ã;ãÃLæfÃC®VÃ<ÅÃ6tþÃ.Ë…Ã%ÔþÖÃÚÃÆfÂü-Âéô¼ÂÙ‡ÂɤZÂI•ÂTÂ^]/ÂhVÂpE¢ÂuçmÂw\Âs¬Âh®ÂU9XÂ8^5¢ÑÁÁûçÁ @ã+AÜ\)B9XC ÍBÿèsBGœ¬CúCúCúÂ…üî·È1CúCúÂþgmÃJ=à Ã"8Rà ™ÛÃMPÓïßè´ÂüèsÂìÂÂÝF%Âΰ¤ÂÁ BÂD€ÂM¸RÂV¯Â^âNÂe¢ÑÂj 7Âk Âg_;Â]ð¤ÂMŸ¾Â5záš ÁÓáHÁR^5@ýôA‘‹DAÿ?}B"ïžAÔ¬Á›™šCúCúÂ’‡CúCú˜›#CúÂÎÆ%Âõ5Ã*à äà ú Ã øÕÃß¾Ãl‹ÂøaËÂë0!ÂÝÜ)ÂÐÏ\ÂÄKD¸xÕÂ?(öÂGKÇÂOuÂVoÂ[¸RÂ_SøÂ`‡Â]#×ÂU¡ËÂHÌÍÂ5ô¼ÂyÛÁ÷ÊÁÁ©Ÿ¾Á/™šÀ^§ðÀ1'ÀÿC–Á¹\ÂLùÛ² ÂÎçð¸¹Û¯wϧr-¢-‘«ì‹ÂÂÂÛdZÂîÖÂùàÅÂý»dÂü6FÂöÛ¦ÂîâÑÂåBÂÚµ?ÂÏÄÂÄÒòº#ׯâÑÂ9ɺÂ@þúÂGÏßÂMãTÂRÇ®ÂUöÉÂVß;ÂTêÂOŽVÂF\)Â9VÂ'¨öÂÑìÁù¾wÁ×ZÁÑ× ÁõV JÂHX‚ð¤Â¢/´¶På²:á­…¬#±Ï\¾AÂÍ%ãÂÙÜ)Ââ‡Âå›#Âå ÂáyXÂÛŽÙÂÔþÂË BÂÂ¥ã¹|j°bѧ…¢Â4Š=Â:úáÂA 7ÂFn˜ÂJ× ÂMâNÂO-ÂN\)ÂK%ãÂEgmÂ==qÂ333Â(ž¸Â PåÂhÂ*9XÂBZÂ`‰7€ J‘ì¡h«ª¯™¯\)® B®˜²z^¹¬‹ÂÂV‡ÂÊ,ÂÏ¡HÂÒ(öÂÑâNÂÏ9XÂʲ°ÂÄÍP½ùÛ¶“u®äZ§$ZŸ{çÂ/€Â5PåÂ:ɺÂ?´9ÂCÓøÂFçmÂH±'ÂIÂG¼jÂDøÕÂA DÂ<¸RÂ9jÂ9m‘Â?¾wÂN™šÂdÊÁÂ}^5ŠE¢Â•‰Âž\)Â¥o¨©üªœÂª B«ïžÂ®Òo³C–¸n˜Â½-‘ÂÀ‘ì¾ÂÁÀ¿ž¸Â¼·E¢Â±°¤Â«ŒJÂ¥užuÃÂ—× Â*µ?Â0%Â5 JÂ9 ÅÂ=™šÂ@ËÇÂC‡ÂDffÂDÁ‰ÂDVÂC\ÂC'ðÂDG®ÂHt¼ÂQ=qÂ_NÙÂqaH‚E‹+Â’÷L™wLžZ¡ŒJ£}ô¤çm¦ƒ–¨Ç+«³3®äZ±Â³Ö´ŽV´²-¯3¶Â«KD¦ª¡„œÂœ´Â–\¬Â ÅÂ&.Â+“Â/ƨÂ4¬Â8Â;XÂ>{Â@5?ÂAÎÙÂC“ÂDvÉÂF€ÂJ ÂOãTÂXÝ/ÂeÂs`BÂ(sˆ(sÂŽKD“e`—cTšPbœqªÂž$ZŸËD¡¡H£«Â¥¶F§r°Â¨ß¨Óu¨"N¦{d£ó3 ©üœĜ˜hs“¹ÛŽ׉Û#Â!çmÂ&}ôÂ*æfÂ/VÂ2å`Â6^5Â9s¶Â<0!Â>­ÂA¸ÂCÖÂGA‰ÂKâNÂR:^ÂZ–‡ÂdÙÂpcTÂ|=qƒ½qˆ¾úÂŒþúÂr-“&f•G+—+˜šš!Ë› Bœúáž+ž–žƒ¸Õœ49š—/žÂ“ܬÂ"NÂŒ#‡߾ƒ…¢ÂÝ/Â",Â&[#Â*^5Â.(öÂ1¸RÂ5 PÂ849Â;G®Â>qªÂAïžÂF JÂKÂQSøÂXÝ/Âa\Âk Ât²Â}ÎÙƒò†²-‰¼îÂŒ8RÂŽ@ƒÂð¤Â‘eãÂ’±'“Ôþ”Õcו›#•Su”}q“‡Â‘#×ÂŽ²-‹Óuˆ›#Â…/Âm‘Â{9XÂ+ Â"Â%÷ÏÂ)µ?Â-NÙÂ0ɺÂ41'Â7²Â;/Â?bÂCs¶ÂH†%ÂNiyÂU$ÝÂ\—ÂdyÛÂln˜ÂtÂ{¾Â€¯žÂƒ_¾Â…¡H‡…‰Šk‹†¨ÂŒmÂÂt9ÂwLÂhÂŒ:^Šî˜Â‰1ªÂ‡ Í„‹Ç½ôÂ}cTÂvì‹Âp33Á`ÀƒÁS× ÁDå`Á3× Á §ðÁ hsÀèƒÀ· ÀƒKÇÀOß¿WKÇ?-Òò@X@F5?@t(ö@‚ñª@vùÛ@D¬?ÜÌ;!ÊÁÀ å`À§çmÁ©üÁ5ƨÁh1'ÁŒ§ðÁ£ûçÁ¹¾wÁÍÄœÁà1Áð‡+ÁÿG®Â!Ë º^ÂiyÂ1' ÅÂ`BÂæfÂÇ®ÁfzáÁXQìÁG¶FÁ4~úÁŸ¾Á JÀÕÒòÀšùÛÀ9‡¿`?’MÓ@EV@š\@Èýô@éãT@ù‘h@ôå`@Ùë…@¨ Å@A%>;dZÀG®À× Á'™šÁcl‹ÁŽp¤Á©KÇÁÁ÷ÏÁØffÁì²-Áþ÷Ï ÅÂƨÂæfÂ÷ÏÂúá ô¼Â"ò°Â$%Â$F¨Â#ÎÙÁmÛ#Á^záÁL5?Á6È´Á JÁß;ÀÄ“uÀ~$ݿУ×?Tzá@U‘h@¹?}AõÃA÷ÏA7%AC‰7AC\)A5%A“@Ú‡+@YX¿¾wÀŸçmÁjÁ_²Á‘ffÁ°1'ÁËó¶ÁäÝ/ÁûG®Â¹X¼j¢ÑÂ]/Â$Þ5Â)¾Â,&éÂ.+Â.ØÂ.º^Â-ÌÍÁw&éÁf´9ÁRÙÁ;7LÁÀþùÛÀ¶¬ÀIG®¾¶E¢@( Å@· A ùÛA;ÊÁAdÝ/A‚QìA‹Æ¨A=qA…®Ai‘hA6 J@æE¢@ûçÀC¶FÁ¬Á]•Á•ùÛÁ¸ûçÁ×ÔþÁó-ÂàB JÂ#ß;Â+XÂ1[#Â5Ý/Â8çmÂ:’oÂ;Â:bNÂ8Ý/Á`BÁql‹Á\ ÅÁBbNÁ#¶FÀÿdZÀ¬ ÅÀñª?_|î@ŽÀƒAbAAë…A}ÒòA™ãTA¯|îA½7LAÀÔþA¸ãTA¥A…áHA:9X@³ïž¿gïžÀñÊÁÁ^1Áœl‹ÁîÁåQìÂm‘ÂÚÂE¢Â&¢ÑÂ0®Â9¬Â?¾wÂD„ÂG~úÂHÓøÂHº^ÂGiyÂE¬Áˆ|îÁ =Áh—ÁLñªÁ+l‹ÁhsÀ¨¼j¿ð?ýOß@ÈbA-ÂAzvÉA£=qAÆVAãOßAö²Aý1AôzáAܰ!A· JA…¶FAj?¹7LÀÒÙÁa%Á¤dZÁÏVÁò÷Ï .ÂúáÂ&8RÂ3‰7Â?RòÂI\ÂPvÉÂU}ôÂXH´ÂY‡ÂX6FÂUøÕÂR©üÁ‘{Áˆ ÁxÈ´Á[™šÁ7‰7Á ²-À®vÉ¿ÌIº@6Ù@übNAV´9AšbNAÊbA÷1'B¼jBí‘B ƨB¿}B í‘Aì9XA²¸AXùÛ@}`BÀ´1'Ád›¦Á«°!ÁØÁü›¦ÂöÉ Â1_;ÂAÛ#ÂPBÂ[È´Âd¾ÂiTþÂk·LÂk±'Âi¹XÂf1Ár¼jÁÍÛ#Âp¤ÂT¸R¦Âލö˜DœÂT{žÖ°¤Âš¨ö–]²Â‘J=‹É7Áİ!Á¾G®Á´vÉÁ¦IºÁ’®ÁpÌÍÁ,5?À©Òò?¼‹DAùÛAšó¶AójB*9XB\KÇB…NÙB–%`Bšî˜BSøBh CúCúCú@xbÀÐbNÁ¸Àff@±xÕ?í²-Á‡Ý/ JÂm_;Â’hs¤O\®hs²›¦Â²…¯qªÂªgm¤,‹ÂOß–6ÉÁÖbÁÑXÁÉ"ÑÁ¼^5Á©ÀƒÁÎÙÁYÊÁÀýG®¿1©üA‡A–`BAøC–B2€BkËÇB‘V‡B¦/B«ÒòBšPåCúCúCúCúCúÁTzáÁP@ A‰A˜^5AH$ÝÁy‡Â;øÕÂŽž¸Â®¶ÉÂÁxÕÂÊhsÂÌ^¸ÂÉßÂès»çð³3¶Âª(ö¡/Áé%Áæp¤ÁàffÁÕ°!ÁÄÈ´Á«ñªÁ‰$ÝÁ4§ðÀl¼j@¹¡ËAŠ =Aôt¼B5àBBv“uBœÄœBºìBÈãTB±ÕCúCúCúCú>ixÕÁíbÁXÝ/@îAšƒ@³ß;Áêj‚±'·ÂÖäÝÂçDÂì²°ÂꮘÂãÕÂÚÂÎå`ÂÃ.˜Â·”þ¬vÉÁýA‰ÁýE¢ÁùõÃÁñõÃÁã‹DÁ̲Áª¼jÁv´9ÀðbN@%VAn1Aé‹DB5¬B}0!B©šBÞÌJC õÃCþB˜¸R??|îÁµ1B’&fA í‘ÁÓí‘À49XAzáHA‘C–Á =Â[ ŽèöÂïöÉÃ<îà suà 7Ã`ÅÃPbÂò%`ÂâÒoÂÓ£×ÂÅ.·»ç + ¬ ¤ÝÂTþÂÂÁñ^5ÁÑIºÁ¢oÁAxÕ¿³¶FA<Ý/AÙhsB0å`B}—B±„CãTCtŒCúBñ˜“B …CúCúC ÐbB¹XAº^Að`BA¢²Á½‹DCúCúïßÃ"»#Ã#;ÇðÃ[dÃB ÃWLÂöÐåÂãæéÂÒo–‡ÂØÂþúÂÎÙÂzáÂéy ®ÁüVÁÍùÛÁ‹MÓÀÅ/A¬AĬB)“BsÄœB¨å`CûdCúCúCúÁl“CúCúBŠÞ¸BruÃB‡«B–‡ASïžÂQìCúCúÃ>ÂÃ?ÿ;Ã;°bÃ4.VÃ)Ò-ôþÃFÃÞ¸Âó5ÂÞ¶FÂÌ\ÂMÓÂ#/Â&÷ÏÂ(ÔþÂ'”{Â!›¦ÂáHÁþ“Á»ƒÁ<Ù@L“A¦G®BÂBaffBøRB±‹ÇB¹ÐåCúCúCúCú¾å`CúCúCúCú¾­‘hÁ÷Ý/CúCúCúÃV49ÃO'ðÃEºáÃ9Ã*påÃlà &éÃ.ÙÂéYšÂÕ+…Â(%ãÂ.º^Â4€Â8Ÿ¾Â9Û#Â6r°Â, ÅÂ:^Áð%Á’®Àw³3Á‹®?–È´A»BGA‰B¢r°BÑüîBˆ7L@oB+ñªCúCúÁ¾‡?àå`CúCúBíò-¸ÃrÑhCúCúÃW´Ãd`ƒÃh‰yÃ` DÃPM‘Ã=·Ã+?ÃÑìà xÂú/žÂã{Â> ÅÂHffÂR–‡Â[î˜Âc6FÂfž¸Âcµ?ÂW†%Â?Ÿ¾Á¿ÒòÀ¼ÄœA‚ÙB,8RB‘­B³¿}BA:^Áõ Â8 CúCúÂíœ)ÁÖ`BBÉ7BÔÛ¦@2ñªÂ÷ìCúCúCúCúCúÃv½ôÃenVÃQt9Ã=s3Ã*‹ÇÃdœÃ ;dÂú ÓÂã3¶ÂB 7ÂLÂÂWyÛÂat¼Âi‰7ÂmúáÂluÃÂb+ÂL5?Â(²ÁèÒòÁC× AçmAð ÅB5…Aù—ÁÛ7LÂá²CúCúÂùÆ%CúCúÂiˆ1Â\æf¹ô9Ã%jÁCúCúCúCúCúCúÃi.˜ÃOpbÃ:0!Ã'v‡ÃáËÃQhÂ÷<îÂá-‘ÂD{ÂNÒòÂY‹DÂcŠ=Âk³3ÂpgmÂo‚ Âft¼ÂR¡ËÂ1ÔþÂáHÁŒÒò¾%ãTA€å`A¨r°Àô¬CúCúCúCúCúCúCúCúCúà ÀƒÃG´þÜTþCúCúCúCúCúÃbõ?ÃHÎÙÃ3÷ Ã"(sÛ#ÃúÂò ÂÝC–ÂDe`ÂNËÇÂY{Âb“uÂj>wÂnœ¬ÂmÁ‰ÂeqªÂSgmÂ5ȴ ƨÁ­$ÝÀÛ× @¼1A$‹DA‡ÊÁCúCú¤&éÂPœ¬Â‰»çCúÂÆ*CúCúCúÃ1RoCúóRCúCúCúÃlÜjÃS«DÃ=ÄÝÃ+&éà ‹Ã îÙÀÂëÂ×Ç®ÂC:^ÂM ÂVŽVÂ_9XÂf\Âi¿}Âh¡ËÂ`ÌÍÂPW Â5­ÂhÁÀÎÙÁ+p¤?¾ùÛ@ýG®@ݲ-CúCúCú½ÎÙCúCú­ÙCúCúCúÃU¾CúCúÊ+Ã};ÃihsÃTµ?ÃA¨1Ã09šÃ ™Ûí‘ÃDÂöcTÂâ¥ãÂÑoÂ@àBÂIâNÂR‰7ÂZ:^Â`¬Âc JÂa¢ÑÂZG®ÂK]/Â3r°ÂyÛÁÊ ÅÁ;× @X´9AŒÈ´AÈffB6FCúCúB†ÔþCúCú“e`Âȵ?CúCúCúȾÂßßÃdÎVÃU¥`ÃI¶‡Ã<·ÏÃ/'®Ã!Ô¼ÃAà ¡ËÂþÂê·LÂÙ?}ÂÉ|îÂ=©üÂEØÂM‘hÂTLÍÂYJÁÂ[–‡ÂZ =ÂSW ÂF²Â0ýôƒÁщ7ÁB“@à¼jBì‹BröÉB±‰CúCúAß›¦Âb™0!š ºCúCúCúCúÃ.æ¨Ã8Ì‹Ã8'ðÃ4iüÃ.©yÃ&Ó3ÑhøRà ã–ÃoÂïìÂÞˆ´ÂÏMPÂÁYšÂ9âNÂABÂH¸ÂNÂRE¢ÂT(öÂR»dÂLõÃÂA¸RÂ/È´Â’oÁá+Áp=q@†ñªAÿ•BuŽVBƒ]²BRÔþAÖó¶Áø{CúCúÂÁŒJCúCúCúCúÃE¢Ã·Ïâ Ã&éÃJÁÃáËà »çØÕÂþÂîøÕÂàG®ÂÒKÇÂÅ)ü¸ð!Â5ɺ²-Â0r°Â¬ÁýoÁ¬oÀó Aó¶A± JAq¸¿Ý‘hÁ³õÃÂk¼_¾ÂÕu?ÂÈî˜ÂÄ CúÂÆ´¼Â×¥`ÂêB Âû3¶Ã›çÃtþÃféÃãÂÿíÂõ ÅÂê²ÂÞ#ÂÒ{ÂÆZ»5°|jÂ1‘hÂ7”{Â=‡ÂAÅ¢ÂE;dÂG ÂF–‡ÂCl‹Â<úáÂ2²-Â#þúÂIºÁî©üÁµýôÁ‰ZÁ˜¸RÂSøÂ?å`Âg›¦Â”aH³ ÅÂÀöFÂÁ@ƒÂ¾çð¾”þÂÂiüÂʤÝÂÕÓuÂáNÙÂêaHÂÂðŒJÂíêÂènÂàéüÂØ“ÂÎßÂĽôºñªÂ±`Ũ-‘Â-ZÂ2× Â7ß;Â<33Â?†%ÂAƒÂAÒòÂ@¾Âw¡H´Â¨ D¬¨s¯å°V‡Â±®˜Â³öÉ·~w»þwÂÀ±ªÂÄ«…ÂÇ,‹ÂÇÔþÂÆ˜ÂÃ¥`¿LJ¹âN³ºá­¦Â¦>úŸQì˜vFÂ%>wÂ)õÃÂ.\)Â2MÓÂ5¥ãÂ8BÂ:%Â:äZÂ:éyÂ:JÁÂ9~úÂ9dZÂ;gmÂA²ÂN\)Âb­Â{ó¶ÂŠ Á“bÑšNÙŸ— £k…¦§Ù©‘h«¤Z®E±NÙ´Z¶߾¸iy¸®˜Â·˜“µ9Û±¾w­^5¨Rò¢Òo =—¾Â‘1ªÂ!jÂ%ÚÂ* DÂ-äZÂ1NÙÂ45?Â6\Â8aHÂ9ƨÂ:þúÂë…ÂCKÇÂJÁ‰ÂV@ƒÂeËÇÂwĜ„²-ÂŒ>wÂ’F¨Â–ú^š\Â>wŸ\)¡wÂ5¿}Âo²¿ØQìÁ?¶FÁòÌÍÂLF¨Â‰÷Ϥ-´æé½Ç+ÂÀ©ü¿7LºÌJ´z^­ßÂ¥ ÅÂòÁÛ©üÁ׉7ÁÐ1ÁÄ Á²‹DÁ™ñªÁq²-Á¥ãÀ=¡Ë@¨ÄœAo¶FAЛ¦BÁ‰BOûçB…2°B¢1'BµLÍB«öFB‚¢ÑB:‚ CúCúCú@åX@™Òò@»÷Ï?¿²Á_ÂÂt¼ÂH´Â¨¢ÑÂÄPbÂÔ BÂÚÆ%ÂÚÍPÂÖI7ÂÎÙÂŶF»Æ%±¤Z§µ?Áí`BÁë=qÁå¼jÁÛ¸RÁËÂÁ´9XÁ“OßÁN“uÀº§ð@;"ÑAU²-AËVB"ÑB[²-B–øBÎbCùÛClJBÀªB[YCúCúBA PAÁ¡ËA}"ÑAe…@Ÿl‹Á—jÂP(ö¦>wÂÒÈ´Âí0!ÂùPÂüÂ÷ìÂï^5Âä1ªÂ×¹XÂÊå`¾På²W ÁÿÈ´ÁÿïžÁü× Áõ5?Áçl‹ÁÑ“uÁ±Á…VÁÈ´½yÛ#A0áHA¿ ÅBÇ®B_E¢B¡ž¸C¥¢CwìÍCúCïBˆŽÙBº¯žCò°B½AB=$ÝCúAÉãTAC"ÑÁº`B‹Ç+ÂÚ0¤Ã|)ÃÃÕÃüà ZáòòÂùùÛÂéÑhÂÙÞ¸ÂÊ´9¼²Â 2- ‰7 ZÂð¤ÂgmÁñE¢ÁÒ¸RÁ¦‹DÁTáHÀhÄœA JA­SøBZBUXB˜UBú¸ÕCúCúCúAþ¡ËB¬ð!CPbBͼîCúCúB<³3AÏ&éÁ¾zá­ñ'à ŽVCúÃ+„œÃ'¾¸Ã"9XÃôÃs3ÇmÂû/ÂèœÂÖIºÂÆ#TÂRòÂûçÂBÂgmÂožÂ ¦ÁõçmÁÊÒòÁŽ ÅÀøA‰@“ß;A—G®BÀƒBDbBwß;BŽÝ/CúCúCúÁc?}BïžBŽ·LBãYšCúCúCúB2þúCúCúCúCúCúÃ<ðÃ2÷ÏÃ(¯Ã!‰ÃRÃS¶Âôœ¬Âà…ÂÎ~úÂò°ÂêÂ!¨öÂ"k… #×Âuà¾wÁðbNÁ´5?ÁEV? ƒA+B%BD"ÑBgyÛCúCúCúCúÂOuÃ@ =B]¦CƒTCúCúCúBwš CúCúCúCúCúÃLÏ\ÃATþÃ4ÄœÃ'Ã5à Å`ÂþøÕÂèäZÂÕQhÂ"¿}Â'êÂ, DÂ.YÂ-¾wÂ(ÊÁ¹X ŒJÁÚ™šÁˆ¶FÀl“AOp¤BG®Be¹XB¬LJBÃožCúCúCúÂÀƒA…È´B9¬BÌÄC8€C@+DBýjAs Âî/CúCúCúÃißÃ[8ÃMª=Ã>«…Ã.ÑìÃ/žÃ‹DÃGðÂïÂÚMPÂ)jÂ/—Â4ãTÂ8‰7Â9n˜Â6šÂ,´9Â!ËÁþp¤Á­éyÁçmA"ÑBr°Bˆ‡®Cè1CúCúCúÁú‡+B€MÓB]VAÌ`BBˆ*C /C:IºB–‡Â˜Þ¸Ã{ ƒÃ›Z=ÖÉÛÈ" CúÃlr-ÃY•ÃF©ºÃ4DœÃ#ÙÃm‘ÄÝÂò˜ÂÝ@ƒÂ.ÖÂ5³3Â;âNÂ@ŽVÂB¤ÝÂ@¬Â8ÍÓÂ(äZ®ÁÏÛ#ÁHÝ/@±xÕAó¥ãB‡ËDC%CúCúÁ‡\)Â-‡?ü¬ÁP¬Áò©ü@®ñªBZÐåB`$ÝÁ½Ã.w CúCú×ÔZCúCúÃ#×Ãf‘ÃLÓ3Ã7E`Ã$¡ËÃ[dÃ(1Âóš ÂÞ"NÂ2¤ÝÂ: =Â@ÂÂFÂHô¼ÂG÷ÏÂATþÂ2ùÛ±'Áì‹DÁ†©ü>° ÅA»t¼B[‚ B¼‰7BÚŠÁAš¥ã¬\à H´ÂÝ×¶ܬ§ևÂnÖÂ"TþÂIþúÂÍ)ÃG®Ùá\JCúÂÒòCúCúCúÃqÔ{ÃO›¦Ã7I7Ã#ÁËÃP¤Ã7ÂòÂÜûçÂ5%Â<•ÂCÂIÂLW ÂKî˜ÂF33Â99XÂ"úá€Á¥ãTÀ¬bNA`éyB…Ba)üA'ë…CúÃ<îÃ+…äZCúCúÂÈ“øÂ¶6FCúöFÃWVCúCúCúCúCúCúÃo-ÓÃLT¼Ã3°¤Ã `ÃeÃФÂî>úÂÙöÉÂ5þúÂ=uÃÂDF¨ÂIËÇÂMÂLí‘ÂGÑìÂ< PÂ'Ö ‰7Á¿ÎÙÁ*ff@¡™šA¤¶FAÔ\ÁÌÍCúCúà ŒÍÂõbÑÂø CúÂïÎÙCúCúCúÃc0!Ù·+Cúã†éáIyÔQÖÃ_x“ÃBÍPÃ,ŽÃ¯žÃ ÐåÂþIºÂèc×ÂÕOßÂ5¹XÂ<äZÂCdZÂH²ÂK¸RÂKœ¬ÂF÷ÏÂ1A^9XÁ¤p¤CúCúCú¶<îÕ?Cúà HCúCúCúÃamÖ2°Ã›Y7ÑbÊŸÀ%ãÃe‚ÑÃKÖÃ5r°Ã"ÐbÃ5?ÃîÂôíÂàéyÂÏRoÂ4ožÂ;-ÂA33ÂB•ÂE!ËÂE+ÂANÙÂ8àBÂ*}ôº^ÁëA‰Á“®À £×A¸²-BŒG®C¼BêÚAƒ‰7Af¸RÂG¦ÂÈ£×Â@þúÂA1Â=õÃÂ6àBÂ*¸RÂ#×Áú JÁª‹DÀº$ÝA¬¾wBG+CúCú@l‹ÀÚMÓ„hsÂÐÃÂä}ôÂÝ™CúCúCúÃ-Ãhsà b Ã$eãÃ$Ffà °åÃlÍÃzáà ÍPÃVÂñ>úÂá_¾ÂÒŸ¾ÂŜ¸…¢Â,ÀƒÂ2“Â6ÎÙÂ:ˆ1Â<ÏßÂ= ÅÂ:Ü)Â5PåÂ+®ÂäZÂOßÁÏÔþÁb@œ ÅB%ãB‡àÅBÞ5A‡`BA(öž®˜ÂÙ.Âß—ÂØ\ÂÒçmCúCúÂô ÃÛ#ÃŒJà ·Ïà üjà …¢ÃÒoË…Âú¯ÂíxRÂà+ÂÓ5?ÂÆ× Â».˜Â°H1Â)’oÂ.ˆ1Â2ì‹Â6t¼Â8Ç®Â9~úÂ8(öÂ4G®Â-TþÂ"±'‹DÁýÁÆ Á²-ÁÎÙÁ™šÂ‡úáÂä)y›ß½q'ÂÓ¸ÂÓ\)ÂÎÛ#ÂÌ/ÂÎxRÂÕ‰ºÂÝæfÂç§ðÂðíÂ÷ßÂúu?Âùp¤ÂôöFÂíÏ\Âä×ÂÚÒoÂÐUÂÅÌJ»zá±P¨¦Â&NÙÂ*ò°Â/šÂ2ˆ1Â4ûçÂ6.Â5ÏßÂ3š Â/H´Â(¦é¤Ý‘hÂꬠ¥ãÂFaH¢¿}ÂÕJ=ÂÇ%`ÂÁð!ÂÅÂįžÂÂÕÂÁûdÂÃožÂÇPbÂÌë…ÂÓožÂÙ³¶ÂÞr°ÂàÏßÂàyÛÂÝ”{ÂØŒÍÂÑìÂÊ:^ÂÁéü¹Tþ°¼î¨MP %ãÂ# =Â'k…Â+e`Â.ÊÁÂ1n˜Â3¾Â3²-Â3Â1+Â-ÖÂ)ÌÍÂ%Ü)Â$²Â(çmÂ;Ü)Âe֑ª‹Ç±ò°Â³¤Zµs3¶LͶ€Â·¸P»U¿*ÂÊ=ÂǹÛÂÊò°ÂÌ›#ÂÌgðÂÊWÂÆ¡HÂÁ— »“u´ê­ãT¦µ?ŸŠÁ˜‚ ÂÏßÂ#ûçÂ'ÔþÂ+;dÂ.oÂ0“ÂGE¢ÂUgmÂhzáÂ~1'‰>w‘5Öî› ÂùX ™‡>Ä›¦=ƒo¿/²¿ï;dÀ]¡ËÀ­‰7ÀõÒòÁ"n˜ÁLQìÁwoÁƨÁ¥hsÁ¹ ÁËŸ¾ÁÜÐåÁì‘hÁúƨ¯ "Ñ ¹XÂs¶ÂTþÂe`µ?ÂQìÂNÙÁeoÁXffÁI¾wÁ9%Á&9XÁp¤Àõ²-ÀÅ‘hÀ“l‹ÀAX¿¼(ö¼Ä›¦?ž¸R@ @8Qì@Eó¶@4(ö@´9?-V¿”Ý/À\záÀÂÐåÁ¡ËÁ@n˜ÁqûçÁ‘l‹Á¨ýôÁ¿SøÁÔ7LÁç‰7Áù-†% …‰7Š=ˆ1ˆ1• ÖÂ!'ð ÙÁk;dÁ]t¼ÁMOßÁ:§ðÁ%t¼Á ¶FÀç"ÑÀ®°!Àf5?¿×P>\(ö@7L@hbN@ž¬@ºÙ@Ço@À9X@¤¼j@hÄœ?Áhs¿“•À‡çmÀô1Á2Ý/Ál5?Á’&éÁ¬ùÛÁÆ;dÁÝÂÁózá§ð \ÂbN P †%Â$ÊÁÂ'äZÂ)âNÂ*Ý/Â*ò°Â*?}ÁrõÃÁd$ÝÁR‹DÁ=ó¶Á&=qÁ XÀÚ°!À˜ýôÀ%p¤¾— =@å`@‡ß;@ÈõÃ@ÿSøA&éAÀƒA¼jA J@á?}@’‡+?¼jÀ 7LÀÂÈ´Á#l‹Áe|îÁ’ƨÁ±(öÁͲÁè“ÂKǠ–‡ÂhsÂ%Ü)Â+ß;Â0ožÂ3˜“Â5t¼Â6$ÝÂ5ÎÙÂ4š Á|záÁlÄœÁYÎÙÁCSøÁ)oÁ å`Àщ7À…ÊÁ¿ÎV?‘h@xõÃ@Ô“A¼jA5AOXA]KÇA] =AMG®A.Ar°@p¤>`A‰À‹;dÁ¶FÁ];dÁ’áHÁµÁÔïžÁòÂÂJÁ Å³3Â)È´Â22-Â8× Â=µ?Â@àBÂB€ÂBÂÂAÜ)Â?þúÁ„ =Áw¡ËÁc|îÁK?}Á.~úÁ ýôÀÍ&éÀmOß¿;dZ@²-@¹G®A× AD(öApbAˆÎÙA’l‹A“OßAЧðAqC–A<—@ôbN@4›¦À¬ÀúE¢ÁR=qÁ‘“uÁ·|îÁÛ¬ÁüçmÂ~úÂzáÂ+1Â6ÄœÂ@bNÂGÂÂLêÂOþúÂQ;dÂPâNÂO:^ÂL†%ÁŠùÛÁ‚‡+ÁoûçÁV-Á7¸ÁVÀÏ"ÑÀZñª¼#× @m`B@ôzáA: ÅAw¡ËA—-A¬‹DA¹G®A»-A±1'A›éyAzéyA0@³…¾ƒoÀÉxÕÁB~úÁSøÁ¶´9ÁÞ`B˜“ÂbÂ'‘hÂ7Û#ÂEÖÂPáHÂYoÂ^s¶ÂaF¨ÂaæfÂ`²-Â^ 7ÂZA‰Á“&éÁŠ¥ãÁ²Ád—ÁC|îÁ©üÀÙG®ÀX“u>õÂ@˜ ÅA|îAaOßA•ÊÁA·p¤AÒ=qAâ—Aå\)AÙ A¾ÎÙA›=qAdí‘A^5@;dÀް!Á+/Áƒí‘Á°VÁÜSøÂ JÂH´Â2£×ÂF³3ÂWožÂdTþÂm[#ÂrÈ´ÂuoÂtÁ‰Âr]/ÂncTÂi?}Áœ§ðÁ”KÇÁ‰`BÁvéyÁT-Á)©üÀíG®Àjn˜?'ïž@°1'A,°!A‚¾wA¯A×éyAù/Bó¶BÅ¢BÂAߣ×A´ÐåAŠÌÍA9X@—oÀ´9Á ÁeûçÁ Ý/ÁÒñªÂr°Â#Â?‡+ÂX›¦ÂlÎÙÂ{¥ã‚ªÂ…9ÛÂ…áËÂ…%ƒœÂ€,‹Ây„Á§ƒÁŸ‰7Á”È´Á†¼jÁi¡ËÁ<í‘Á^5ÀŠE¢>âMÓ@»× A>1A’OßAÆvÉA÷ÊÁB‰7BÝ/B ˆ1BYAÿõÃAÇ/Aš¥ãAnå`@óƨ>ˆ´9À·KÇÁ2n˜ÁˆVÁÂÂÂãTÂ+gmÂP²ÂoYƒ®˜Â‹ú^Âçð“’ØÂûdÂã׉öFÂ…‰Á³¶FÁ¬`BÁ¢“Á”9XÁ‚‡ÁUó¶Án˜À­V¾gl‹@¸záAGãTAžhsAÛ7LB PåB%\)B7vÉB<…B0ž¸B“AÁÄœCúA‹DA4ff@RÐå¿ïß;ÀÛSøÁR¼jÁ±$ÝÂÈ´Â8ùÛÂg€Â†°¤Â”s¶Â@¡ËD¢ò-¡ˆ´ÂžH1™È1”‰ÂŽÍPÁÁ+ÁºÄœÁ±E¢Á£ñªÁ‘õÃÁtí‘Á933ÀÞŸ¾¿²-@¤9XAI =A¦=qAìzáB,BlÍÃ,ÃÂNà EÃ|)Âê|îÂÖÖÂ!¦Â%~úÂ(ÄœÂ*?}Â)+Â#ò°Âœ¬ÂhsÁÝ“Á“Ý/À¼r°A9 Bî˜BŸÞ5C%ì‹CúCúCúCúÂÊÁÂ2 ÅÁ¶FA´ =BG× B  ÅÁèA‰Ã/Ö‚CúCúÓÎúêÁÃ}ÓÃc\ÃGŒ‹Ã1C×ÃÔ¼Ã8ÕÃÑ'ÂìqªÂØKDÂ$ë…Â)Á‰Â-ŽVÂ/§ðÂ/,Â*÷ÏÂ!­Â³3Áò|îÁ¬QìÁP@õÒòBß;B“CF%CúCúCúÃ1CúCú”¡ËÂAüîÂ× ÂUbÂÒ‰ºÃ>üjÓ6%óÕCúCúCúÃ’¢òÃq‡ðÃMf%Ã3ŠÃ’-ÃPbëÂì¨Â×èöÂ'Š=Â, ÅÂ0¼jÂ3:^Â3BÂ/ÂÂ'n˜Âƨ¾Áà ÅÁR^5@ ÂA¾™šBdµ?BðÛ¦CúCúCúÃ2‰CúCúÂãC¼¾Â¯t¼ÂÒÇ®ÃH1ÃT5?Ãô9Ã¥@CúCúCúØkçÃtÅÃLì‹Ã1ô¼Ã®à |)à ÓÂéOßÂÕ²-Â)Â..Â2ffÂ5Â5qªÂ2~úÂ+ J¿} ÅÁ×5?Á†í‘Àk¶FASl‹B 9XBhó¶ByÙÂɺCúCúÃcÃ!Û¦ÃH´Âó9ÛÂéèsCúCúÃ_MPÈ¥`ÃÆCúCúè‡LÊæÃg6‡ÃE1ìÃ,JÃ/\à ÖÉÂú.˜Â䃖ÂÑÒòÂ)vÉÂ.ŽVÂ2¾wÂ5xÕÂ61Â3ˆ1Â,ès ÷ÏÂk…ÁçÙÁ QìÁÌÍ@§\)A–KÇA ÀƒCúCúCúCúÃ"7LËÃ{#à ÖFCúþCúÃUV‡Ã|9ÃŒ\ÔûdØ)šÃ‹¬¬Ãs§ðÃRþwÃ8iyÃ#dZɺì‹ÂñüîÂÝó3Ẩ7Â) 7Â-÷ÏÂ2%Â4¸RÂ5iyÂ3PåÂ-ƒÂ"ò°Âs¶Áõn˜Á´n˜Á<5?@PAœXBÓøA”§ðCúCúCúCúۦøÕüjà v‡CúÃ}²CúÃ]€ÅÃn„ZÃv{dÃu üÃgšáÃR¿}Ã<ñìÃ)T9Øà t¼Âü× ÂèšÂÖ%ÂÆ ÅÂ'êÂ, ÅÂ0…Â3&éÂ3øÕÂ2NÙÂ-^5Â$=qÂÛ#ÂÙÁÆ^5Ád-?Ñ%Aêí‘B¸¨öCúCúCúCúCúà ,ÃÃh1CúCúà LÍÃ'²-Ã:•ÃFTþÃK±'ÃJ{çÃB¸“Ã6E`Ã( Ãüîà "ÑîÂï ÂÝ"ÑÂÍ,¾éyÂ&DœÂ*ÀƒÂ.yÛÂ1bÂ2 JÂ0àBÂ,äZÂ%VÂBÂaHÁÛÁŽ{ÀVAã¬BÚŒJCúCúCúCúÃÅà êÃg®ÂóÂï7ÏCúCúÃF¨Ãp¤Ã&1'Ã*ªÁÃ*¥Ã&`ƒÃÚÃËà ™XÃéyÂñ¥`Âàì‹ÂѬÂÃÍP·2-Â$?}Â(ƒÂ,šÂ.¯Â/æfÂ/KÇÂ,\)Â&‚  ÂÚÁô´9Á¸ZÁ3™šA¥ãB>•BÌ}ôB=qCúCúÃQ)yÃlJÂûA‰ÂéÂâüjÂèéyCúÃÎV×LÔ¼Ã(´Ã̋Îà ð¤Ã¼)ÂýkÂîâÑÂà›#ÂÒú^ÂÆ-‘ºE¯>úÂ!úáÂ&\Â)Š=Â,.Â-­Â-³3Â+àBÂ'ÍÓÂ!Âó¶ÂɺÁꙚÁµÔþÁgVÁ‹DÁȬà 7CúCúÃ[¦ÃýqÂêxRÂÜ#Â×X“ÂÙÞ¸Âá)üÂé‰7Âò’òÂú°¤ÃZÃÎVÂÿ@ƒÂùl‹ÂðüîÂæâÑÂÛîÂйÛÂŬ»ƒÂ°Ú§H´ÂbÂ#|îÂ&èsÂ)¢ÑÂ+s¶Â, ÅÂ+iyÂ)Â$ïžÂÏ߯ ì‹Â0!Áþr°ÂMÓÂg2-ÂàÊÁÃ# Ã$ZÂëVÂß¹XÂÓ¸ÕÂÌuÃÂÉèsÂËF%ÂÏs¶ÂÕ!HÂÛG®ÂàÍPÂ䜬ÂåøÕÂä¡ËÂàÄœÂÚÖ‡ÂÓkÂË\ÂÂ8Õ¹>w°^¸Â§ÀŸzáÂb Ü)Â$A‰Â'šÂ)?}Â*‹DÂ*Ý/Â*²Â(JÁÂ%‡+Â"?}Â{ç‹DÂ'^5Â@#×ÂuáH£µÃÂÉÂÈ0!ÂÅ#×ÂÂ@ƒÂ¿ D¼Ô{¼bN½ËÇÂÀ¼îÂĤÝÂÈØÂÌš ÂÏ;dÂÐ6ÉÂÏRoÂÌ–‡ÂÈ@§m¼+µ¾Â­Ìͦf韗ó¶Â…Â8RÂ!š Â$“uÂ'1Â(äZÂ*¦Â*±'Â*¿}Â*ŽVÂ*®Â,,Â0ß;Â;¶FÂPcTÂq ÂŒž5·Ï§O\«‘h­k…®+®¸R¯¶É±lÂ³ÓøÂ¶±ªÂ¹¥`¼:á¾¾ B½éyÂ»× Â¸‡®Â´0¤Â¯Ù©_¾Â£YÂ'm–îÂÆ¨ÂöÉ•Â÷ÏÂ" JÂ$Å¢Â'¦Â)VÂ*®Â,#×Â-¾wÂ0Â3Ç®Â:8RÂD× ÂTí‘Âjr°Â[#ÂŒxR”Óušiüž\ ‰ºÂ¢r-¤=ô¦+¨LJª‹D¬µ?®„œÂ¯´¼Â° D¯eã­»d«#§¤Ý£€ƒÂžÙšÂ™Ø“”¡HÂPb‰ýôÂiyÂô¼ÂTþÂÂ"qªÂ%&éÂ'¦éÂ* 7Â,xÕÂ/;dÂ2»dÂ7‰7Â>YÂGß;ÂTÂcÞ5ÂtŠ=‚:^ˆûçÂŽH1Â’MP•aË—ؓ™þúœƒÂñ'ŸÊÁ¡s3¢ £P£°!£o¡¬‹ÂŸ…œ°!™H´Â•l‘8ÕÂŒËLjfff?5Â?På`>ýp¤¾ŽÙ¿Á%ÀJÀƒÀ¦ÀƒÀòE¢Á"~úÁNffÁ{dZÁ”"ÑÁª JÁ¿{ÁÒùÛÁå‡+Áö•Âýô ÍÓ­“u€Âwχ+½qÂ0!Âô¼ÁjéyÁ^{ÁO&éÁ> JÁ*ÄœÁXÀû÷ÏÀÊÀ•ÒòÀAº^¿³÷Ï=ãSø?¸Qì@l‹@K"Ñ@Z¬@HbN@¥ã?o²¿s÷ÏÀS33ÀÀ‹DÁë…ÁBffÁuãTÁ”‡+Á­ffÁÅ1'ÁÛ§ðÁð—Âès ’oÂ33·LÂ{Â"H´Â%]/Â'bNÂ(l‹Â(˜“Â( Áq÷ÏÁd$ÝÁSß;ÁA Á+t¼Á;dÀðýôÀ· Às¶F¿ëC–=÷ÎÙ?ýÒò@ixÕ@ “@½ÊÁ@Ê~ú@ÃP@§•@m¸?ÇKÇ¿ƒÀ‡÷ÏÀõ?}Á4^5ÁoVÁ”PÁ°®ÁË\Áäó¶Áü® ?}Âh¬Â"ò°Â(× Â-XÂ0Â2jÂ349Â2þúÂ1ò°ÁzŸ¾Ákë…ÁZ^5ÁEÂÁ-ë…ÁÈ´Àèå`À¦ffÀ>5?¿%¡Ë?ÙX@}²-@Àå`@÷çmA•A¸AéyA J@Ù?}@‹C–?¥`BÀ´9ÀÄ´9Á#ß;Áf5?Á“ÌÍÁ³r°ÁÑÄœÁî“uÂÓøÂTþ—Â&e`Â.–‡Â5{Â9âNÂ=uÂ>ËÇÂ?49Â>~úÂ<ÚÁ‚‰7Áu¥ãÁbõÃÁL°!Á2—ÁƒÀäÝ/À™/À ãT?@R J@ÀbNA§ðA+‡ADn˜AQ× AQoAA A"E¢@ìZ@{÷ϽuÂÀ‰7Á-ÁZ=qÁ‘‘hÁ´ñªÁ×"ÑÁø1 §ðÂ6FÂ'OßÂ2Ÿ¾Â;êÂCÂH.ÂKPåÂL´9ÂL”{ÂK33ÂHËÇÁˆÄœÁ€ÊÁÁmó¶ÁV5?Á9÷ÏÁùÛÀæ5?Àí‘¿ÌIº?ÆE¢@š{A A2$ÝA\¬A|È´A‡^5A‡Æ¨A}÷ÏAZõÃA);d@×× @ãTÀ¡ËÀðQìÁI|îÁŒÊÁÁ´VÁÚ²-ÂZ¿}Â$Â3Â@·LÂKSøÂS=qÂXPÂ[{çÂ\ZÂ[záÂY5?ÂU× ÁoÁ‡ùÛÁ{¥ãÁb¬ÁDƒÁ ¼jÀîE¢ÀKÇ¿•`B@¶F@Ç+A ùÛA[ÂA‡ÙA›í‘A§™šA¨ÙAžÙAЇ+A\ÔþA$Ý@Û#¾Z¬À´ƒÁ1²Á„‡Á¯bNÁÛdZ DÂ(öÂ/ JÂA©üÂQ;dÂ]\)ÂfÂkaHÂmáHÂmñªÂl DÂh›¦Âd+Á˜ƒÁvÉÁ†"ÑÁrffÁRŸ¾Á,^5ÀþffÀ•ãT¿}p¤@E/@íÒòA>r°A‚“A¡‹DAºzáAÉPAËéyAÀ9XA§ãTA‡\)AGP@÷\)@IºÀO¾wÁ²-ÁkÊÁÁ¥¥ãÁØ‹DÂ-Â"]/Â<\ÂRŸ¾ÂdúáÂr·LÂ{ð¤Â€ŒÍÂe`Â€× Â~aHÂys¶Âs]/Á¢¬ÁšKÇÁ Á‚ÔþÁd°!Áw«Šœ¬Á¸§ðÁ±õÃÁ¨t¼Á›\ÁŠ©üÁjE¢Á4Ý/ÀèƒÀ bN@=?}AÐåAzVA´SøAël‹B,B# =B,F¨B&„B±'Aâ1A«°!AÁÊÁAŸ‹DAEó¶@¨ÌÍÀ!hsÁC‘hÁÂ"ѧðÂNH´Â~‘hÂ’KDŸ¡Ë§¸R«k«­©bNÂ¥KÇ %š Á“µ?ÁÅffÁ¿™šÁ¶ß;ÁªPÁ™å`Á„+ÁQSøÁ ®Às33@ÌÍA SøA€A¾“uBB!5?B?"ÑBQÓøBO²B9A‰B¬B»dBŒJAýMÓAÁ‹DA€× @ГÀǶFÁ´ƒÂ#t¼ÂiïžÂ’l‹Â¨Vµï½‡+@žÀƒA[;dA¶•Aþ-B BB>qªBS…BHPB-]/B4¬B{ó¶B¼uBüßCIºBç‰7Bç B¦ƒ–AISøÂR‡+ÂÔ{Âø&fÃNVà ۦà Óÿ;ÂûÖÂî{dÂàp¤ÂÒlÂÄæé¸&fÁüÒòÁüjÁù%ÁñŸ¾ÁåÁÑÈ´Á¶‹DÁ‘ó¶ÁF1À¥Â@O®AI =A°$ÝAï‡+BçmAÓSø@â\Cú¿ä“A³ÔþBrDœC¹ÛCmqìC”î¸CúCúCs‹…BA†%Â…(öÂúƒ–Ã#Ã@ÅÃ]qÃïõÃþÂÿ¾wÂÂÝñ'ÂÎ\)¿õàJ²»dÂÜ)Áø©üÁæÆ¨ÁÌjÁ§ñªÁoïžÀîn˜?Ñë…AA¸A¹‡Bž¸B`BAMº^Â#9XCúCúCúB+´9CìCúCúCúCúCúBb‡ÂÛŒÍÃ+DÝÃ;j=Ã9ÎÙÃ2Ã(.VÅÚÃÜjÂû9XÂè/ÂÖ”{ÂÆª - zá dZ X¢ÑÁúãTÁá¬Á½°!Á Á¶F>9XAESøA× B-e`BbúáB…”Ô{CúCúCúCúB훦C³S¶CúCúCúCúÂI²-ÃR–Ãv•ÃhwLÃW"NÃG´þÃ8¨sÃ)êÁÃåãÃâ Ãþ5Âð}ôÂÝ6ÉẨ™šÂbÂ33Âí‘Â+ž¸ÁõhsÁÒQìÁ¡‘hÁ@´9¿®{AJ“uAü¡ËBi‡+BÁß;Bþ…CúCúCúCúCúCúC<)CTC.:^BߌÍÁr°ÃBևìƨêCÉ&%Ãs6FÃ^iºÃIqªÃ5Ÿ;Ã#þwÕÃ;Âö©yÂáõÃÂÏÁÂ:^¿}ÂÂl‹ÂF¨Â©ü‰7ÁådZÁµÁgÂÀX“uA>A‰B6FB‰£TBùz^C5G®BºßCúCúCúCúCúA§ÒòB6[#AÞ JÁç`BÂö%`ÃxF¨ÃÆ£TCúCúÃ…#Ãy=ôÃ[Ã@'mÃ*aHÚ Ã ÅãÂúVÂä¢ÑÂÑËÇÂð¤ÂãT¤Ý¤ÝÂ'ðÂNÙ VÁöZÁÈzáÁˆÀƒÀÅ/AzáBIºBc×Cˆ1CúCúCúCúCúCúÂAÂF8RÂ!(öÂgþúÂÐbNÃ.=/‡CúCúCúCúCúÃk¬ÍÃG½qÃ.-Ãp!à ®ÙÂû=qÂåÂÒ Jµ?ÂõÃÂ!{Â!‡+œ¬Â|îÂ'ðÂvÉÁÚ"ÑÁž‹DÁZ@Œ´9AÇ¥ãBop¤C üjCúCúCúCúCúCúÂæ›¦Âºò°Â´`BÂ×—ÃNÃGOÂÒ-Þ[CúCúCúCúÃr;¦ÃIkÃ-úê=à ³uÂùG®ÂãRoÂЈ1ÂP üîÂ#[#Â$#×Â"³3ÂA‰ÂãT‹DÁê{Á´%ÁVéy¿· =Ai%Bm‘BŽF%Bâ`ÅBô¼CúCúCúÃ4»çÃ-‘ÂîYšÂìÕÃ9XÃ&ï\ÃNï\Ã{óuÓݲñ{çCúöRÃ2°Ãh®ÃC¦%Ã)§mÃ0!ÃØRÂô’oÂßt9ÂÍ]/ÂŽVÂ"uÂ$–‡Â%Ÿ¾Â$™šÂ ÍÓÂiy ~úÁøoÁÇÐåÁ‡Û#Àج@±™šAº^Aªí‘CúCúCúCúÃF®ÙÃ$hà àƒÃŠÁÃ8ÕÊ=Ã(Q'ÃH`ÃjQ'Æ—ÏÚm²Ã¥×LÖ%Ã|›¦ÃUz^Ã8¢Ã!½/Ã]/ÃZáÂívÉÂÙ¾úÂȽôÂÑìÂ"ZÂ$ò°Â&.Â%ˆ1Â"`BÂüîÂPÂ&éÁÙ|îÁ =qÁ+®?o Ab1'A³§ðÀ¸CúCúCúCúÃæéÃ Ž˜ÃãTÃð¤ÃØRÃü)Ã8S3ÃQxRÃhLJÃz¯\À Ãq‹ÃXDZÃ>þúÃ)[¦ÃŒÃâ ÂùG+Âä|îÂÒ‘hÂÂî˜ÂwÏÂ!øÕÂ$œ¬Â&%Â%¾wÂ#>wÂçm·LÁéñªÁ¶l‹Á^Äœ¿“× A˜"ÑB\yÛBÓÓuCúCúCúCúÃâ à 7Là ÃwÏÃÜîþÃ%6‡Ã6vÉÃDµ?ÃMâNÃO,ÍÃGUÃÃ9LJÃ)V‡Ã¤Ã lJÃ…ÂìW ÂÚAÂÊW ¼<Â!Â#ÖÂ%YÂ%uÃÂ#§ðÂjÂ%ã ¾Áú²-ÁÎIºÁŽOßÀ«¶FA†?}B~0!CúCúCúCúÃXÃ#`BÙÂýJÁÂù\ÃîÃ*=Ã-‘ÃT¼Ã'ffÃ,ÉüÃ-WLÃ(Ý/à žÃMPà žwÃ`ÅÂïàÅÂÞÅ¢ÂÏ\)ÂÁzá´õ?ÂiyÂÑìÂ"‹DÂ$RòÂ$ÚÂ#Ţ ±'Â&陚ÂF¨ÁéÝ/Á¸`BÁ\“u?€ƒAÂA‰B+r°?õÃCúCúCúÃ0‰yÃïÂòSøÂë Âï´¼Âú„œÃú Ã é7üjÃ>5ûçà Åà úáÃ33ÂýT{ÂîœÂß4¼ÂÑB ÂÄMP¸Z­^5Âë…ÂIºÂ!oÂ#bÂ$+Â#³3Â!ÌÍÂ% DÂvÉÂÄœÁèPÁÀó¶Á”¸RÁ‚dZÂqªÂƘ“Ã!o\Ão\ÃIø“Ã7ÏÂöùXÂã9ÛÂÝOßÂß5ÃÂåÁ‰ÂîRòÂ÷>úÂþܬÃÎÃCóuÂúÀƒÂñ‚ Âæ²°ÂÛ/ÂÏ“øÂÄC–¹t9¯AÂ¥²°Â;d‘hÂl‹Â!£×Â# =Â#s¶Â"³3 Ÿ¾Â¬Â ÅÂÍÓ »dÂÒòº^Â^5ÂgúáÂÃèöÃ" Ãp¤Âþ;ÂìïÂÛ(öÂÑSøÂÎÂÏ@ƒÂÓk…ÂÙòÂ߉ÂäÂçV‡ÂèuÂæÂᘓÂÛ{ÂÓ&fÂÊbNÂÁ>w¸b¯ì¦eãž!HÂe`·L¦頇Â!éyÂ# Â#MÓÂ"Á‰Â!iyÂ{çÂt¼Âm‘°!Â(ØÂBå`Âv2-ŸùX¾vFÂÉ3¶ÂÊ”þÂÇ“øÂÂ÷Ï¿ÍP¿¢ÂÀp¤ÂÃxRÂÇcTÂËq'ÂÎåãÂÑ)ÂÑŸ;ÂÐ>úÂÍ DÂÈH1ÂÂQ컈´Â´D¬ȴ¥J=Âí‘–ɺÂvÉÂÄœÂÇ®Âl‹Â Ÿ¾Â"SøÂ#…Â$?}Â$¦éÂ% JÂ&%Â( ÅÂ.¤ÝÂ:ÊÁÂP[#Âq DÂŒB™šÂ¨^¸Â­ž¸Â¯œ¬Â° ǰQh±8Õ²ýqµ|j¸cT»D½©y¿)ü¿wL¾iy¼¸ff³ËÇ®r°Â¨™šÂ¢t¼Âœ0!•ì‹ÂÃÂs¶Â¾wÂÒò¤ÝÂ(öÂ!^5Â#IºÂ% Â&¶FÂ(¸RÂ+\Â0 DÂ7PåÂBÁ‰ÂS‡+Âi}ô =ÂŒhö•%`› ÇžÌÍ¡>w£/¤î˜Â¦ð!©&é«qªÂ­”{¯J=°Oß°qªÂ¯’o­¯ªٚ§3¶Â¢èsž"Ñ™ Ǔގm‘‰šÂaH§ðÂȴ½qƒ ¦Â"“uÂ%Â'ž¸Â*¦éÂ.ˆ1Â3ÎÙÂ;(öÂE;dÂR_;Âb)üÂs8R ˆ´¼ÂŽ(öÂ’E¢Â•eã—èöš¾Âœ6Fž;d !H¡Ê=£ Í£ÀƒÂ£Ã£¡uß*œ5ز°Â”ÁÂ~wÂŒ¨Â‡qªÂ‚ÒòÂB‚ «¸R¬ŒJÂ!gmÂ$VÂ'Â+¾Â/}ôÂ4÷ÏÂ;ì‹ÂD¦éÂO49Â[wÂH´Â„ ÂÙÁk&éÁ_XÁQ¶FÁB5?Á0ÙÁ¾wÁ  ÀævÉÀ¹OßÀŒÀ@r°¿ß²¿*Àƒ>$Ý/?)ûç?G+>éxÕ¾§ïž¿É™šÀP“uÀª§ðÀ÷t¼Á%ãTÁRå`Á€£×Á—÷ÏÁ®ó¶ÁÅ5?ÁÚp¤Áî`BÂdZ¶F PÂXŠ=£×Â"«Â$¯Â%ÄœÂ&Â%ˆ1Áq¥ãÁdéyÁV JÁDñªÁ1•Á1Ár°ÀÖn˜À¡©üÀX¿Ý²-¾F§ð?“•@ ó¶@:-@Ihs@7²@Àƒ?,1¿›"ÑÀcC–ÀÈr°Áó¶ÁFÝ/Á{KÇÁ—ýôÁ±ñªÁË Áã&éÁùÄœÂRò¿} %Â%¹XÂ*¦Â-:^Â/)üÂ0Â/ïžÂ/1Áy‰7Ák÷ÏÁ[ë…ÁI;dÁ3× Áº^ÁoÀÈbNÀ‹33Àr°¾Ú¬?·KÇ@EãT@Ž@«l‹@·× @°Ôþ@•&é@Ië…?‡ =¿ÈbÀ“l‹Àþ—Á8r°ÁsOßÁ—?}Á´xÕÁÐí‘ÁìC– JÂþúÂÂÂ##×Â*ýôÂ1@ƒÂ5î˜Â9Â:Ý/Â;e`Â:Ü)Â9k…ÁÁt¸RÁc™šÁOhsÁ8ÁOßÀþÙÀ½XÀn5?¿·l‹?_;d@F$Ý@£¶F@Ù`B@ÿt¼AÝ/A‹D@ð“@»C–@a©ü?ùÛÀ0 ÅÀÎéyÁ&å`ÁhZÁ•33Á¶%ÁÖE¢ÁõP «Â~úÂ#ì‹Â.§ðÂ7€Â>bNÂCSøÂFt¼ÂGò°ÂHÂFáHÂDÂÁ‡ ÁdZÁmXÁWƨÁ>n˜Á!/Á JÀ¶~úÀMOß¿°!@P@˜b@åë…Aë…A,{A8¸RA7ÒòA(—A ²@ÅOß@?\)¿/ À—dZÁoÁY Á‘‡Áµå`ÁÚ²ÁþÄœÂÈ´Â!Â/ƒÂ;äZÂEâNÂMjÂR’oÂUŠ=ÂV•ÂVÂT{ÂQ“Á¡ËÁ†bÁydZÁb£×ÁG‰7Á'× ÁxÕÀµ/À6§ð>P@PbN@ÊùÛAß;A;÷ÏAZ1'AkoAkûçA[ãTA;ó¶A‡@°ýô?Ñ&éÀ*áHÀê^5ÁC?}Á‰çmÁ³?}ÁÝp¤ÂèsÂŽVÂ+ÖÂ<ò°ÂKLÍÂV”{Â^¿}ÂcùÛÂf•Âfò°ÂewÏÂb†%Â^wÏÁ•$ÝÁ‹DÁƒõÃÁpA‰ÁS¡ËÁ1²-Á 9XÀº—À-Oß?-V@‡;d@ùÊÁA3²AdA„È´AïžA‘£×A‰-AnÔþA=‰7A¬@‰G®¾À ƒÁ${Á|¬Á­+ÁÞffÂ{çÂ!`BÂ8“uÂLãTÂ]…Âj#×ÂrÐåÂwâNÂyÓøÂy1'ÂvÂrA‰ÂlÞ5Á£×Á–+ÁŒ‡+Á€ffÁbùÛÁ?‡ÁÄœÀÇïžÀ41?t¼j@žáHA&éAQ&éA…—AœõÃA«ÊÁA¯‹DA¦ûçA“ Ao33A3ûç@ð“u@OÎÙ¿æÀí?}ÁY =Á¢•ÁÝ^5 €Â+ûçÂH²Â`;dÂs[#€œ¬Â…\‡P函ô†¶É„’ò ÅÂ|@ƒÁ§ ÁŸí‘Á–jÁŠ/Áuº^ÁPA‰Á#p¤ÀÞ$ÝÀMOß?pbN@­&éA!VAk7LA˜A‰AµxÕAÉ\AÐáHAÉMÓA³ÊÁA•jAp1'A?ƨA1'@<ÌÍÀIûçÁ"—Á‘ÀƒÁÚ(ö‹DÂ9gmÂ[¬Âx"цâNÂŽF¨Â’’o”A“ؓ‘ØÂŽ¯Š¹Û†BÁ±xÕÁªÄœÁ¡•Á•vÉÁ…õÃÁeKÇÁ6jÀýº^ÀzÐå?E¢@°A‰A+`BA€bA©VAÍ\Aé AöffAñÔþAÝ%A¿áHA§dZA–´9Aw`BA"bN@Zn˜ÀšÈ´Ámt¼ÁÓSøÂ JÂJÓøÂt¯Š÷Ï–å`žhs¢$Z¢Ø¡;çÂò°Â™‰Â”T{ÂŽ½ôÁ¼Ÿ¾Á¶“uÁ­ë…Á¢"ÑÁ’°!Á~¬ÁM¡ËÁdZÀž—½÷ÎÙ@¦ÐåA.È´A†ÀƒA¶oAâ¡ËBÄœBž¸BÈ´BÔþAõ9XAçÐåAá7LAÏ1'A¨ÔþA];d@w²Á;dÁÄ^5Â#ãTÂa|îŠkÂåª&fÃ+·LÃeà .ÙÃÐåÂìÂÙ ÁÂÈO\ h H´Â Ý/Âþ]²CúCúCúÜCu°Ãj„ÃNÝ/Ã6féÃ"<¬Ã­‘Ãß¾ÂðV‡ÂÜ6FÂʹX§ðÂG®Â±'Ân˜Â ïžÂ‹DÁöûçÁÙÌÍÁ±ÁváHÀÎvÉ@´ ÅA´ B=s¶B§4¼BÝu@‹|îCúCúCúCú¢ ÅÂauÃÂIˆ BÂÛk…Ã'bÑÃX¨CúCúCúÕC¶Ãƒ©šÃ^ªÃ>c×Ã&œjÃ(sÃRòÂòÂÝRòÂËyX€Âr°Â?}Âs¶Â‡+ Ôþ ÅÁè(öÁÂp¤Á®ÁÈ´?Ö‡+A‰ë…B"˜“BžÙBú®@_ÎÙCúÃ8²CúCúÂÝu?ºê¹¯žÂÛøÕÇ+Ã@·LÃ{‘hCúCúCúó\‹ÃŽì‹ÃfßÃALJÃ';Ã,Ã÷Âñ²ÂÜOßÂʉ7š ÂÌÍÂê‰7Â&éÂ+ÂèsÁõ;dÁÒãTÁ¤å`ÁQß;À`r°A Û#AÂn˜B*BB>49Á:IºÂ–ÕÇðÃA”9âÑÂþž5Âæ×Âê¸Ã6Éà QªÃFt9Ãq̋ÊvFCúCúÃÇSuÃŒÙyÃaH1Ã=t¼Ã$YšÃÃÅ`Âíp!ÂÙ>wÂÇüîÂÂe`ÂÄœÂÀƒÂâN¡ˠaHÂxÕÁâbNÁ¹£×Á…jÁ r°?MÓAbA,1'ÀÝÒòÂ)ÍÓÂŒ 7Âðl‹Ã.˜Ãœ)áËÂûô¼ÃŒÍà ÔþÃ"§mÃ?Ô{ÃaožÃƒÕãâäÝýBÑÞ Ã{éºÃQW Ã3’òÃ!à ‘Âý× ÂçV‡ÂÔSøÂÃüjÂÎÙÂQìÂçmÂ8RÂÜ)ÂYÂ&é³3Áð¾wÁÍ ÁŸ^5ÁNjÀÊÁ@b@5¸ÁzÈ´Âg¼jCúCúÃÚ^à ÍÓÃâNÃVÃsøÃ ¯\ÃÃTÃ25ÃÃJyšÃc× Ã|ÝÂÁÃt;ÃW!Ã<0bÃ&ÏÃIºÃÊÁÂó\ÂßI7ÂÍäݾÆ%Âb«ÂqªÂuÂ8RÂwÏÂ^5 l‹Áþ33ÁßPÁ·vÉÁ„ ÅÁ?}?”“Aí‘?¸ÔþÂ[CúCúÃtþà —ÏÃyÃ'Ã/žÃ’°ÃÛ¦Ã!ÓuÃ2¦ÃA>¸ÃL: ÃNµ?ÃF¢ÑÃ7½²Ã'" Ãßà ÛdÂü ºÂçœ)ÂÕÞ¸ÂÆV‡Â¸ BÂÞ5ÂPÂ~úÂqªÂšÂ ÅÂ(öÂËÇ“uÁñáHÁÐ1'Á£záÁNbNÀ)ë…A1AãTÂ*dZÂÏ¡HÃ!HÃ%¥`Ã<)ìÂùÕÂøMÓÃjþúÃÀÃJÃ%p¤Ã+IºÃ,,Ã'¦¨Ã!ÂÑà ¤ZÂþ¨sÂëÏßÂÚÛ¦Âˬ¾b±ÔþÂNÙÂ\Â,ÂožÂ›¦Ân˜Â ÅÂå` éyÂIºÁêùÛÁÉffÁ´9ÁOÂÀç|îÁIÂÂ%ãÂzæfà ÂNÃ:!ËÃÃÏžÂï\ÂëqªÂï×ÂùÔ{ÃkÇà )7ÃÚ^ÃT{ÃÈ1à Pà · ÿ}Âú'mÂê´9ÂÛàÅÂΉÂÁ2-µožÂª«Ât¼ÂE¢ÂP¾ÂÐåÂn˜Âȴ²- bÂPåÁòÊÁÁÝ~úÁÎ^5Á݅¨ö€#¯BÂü ÍÃf¨ÃiºÂîûçÂàÏßÂÜÔþÂßE¢ÂåµÃÂî+…ÂöàÅÂþ*ÃIºÃ“øÂÿ°!Âø°¤Âï$ÝÂä)ÂØwLÂÌÒoÂÁ‹DÂ¶ÓøÂ¬Â£\¬Â`BÂA‰Â²-Â’oÂÂÂ"Ñ—Â\Š=Â"ÑÂ2- ‘h KÇÂoÂ'`BÂ[DœÂ–·Ï½÷LÂÙÞ¸Âè2°ÂáäÝÂÖ€ƒÂÏoÂÍaËÂÏ0!ÂÓ‰ºÂÙ/žÂÞõ?ÂãÁ‰Âæ¦fÂç+Âä³3ÂßäÝÂÙ;ÂщÂȾ¾ïžÂµÄœÂ¬Ôþ¤AœÂ¦Â J£×ÂÍÓÂs¶Â…ÂøÕÂÔþÂ6FÂaHÂå`ÂÚ G®Â+ÖÂCPÂl‡ÂÇ+©ŒJ¹ÎVÂÁ¯†%ÂÀ,¾LJ¾F%ÂÀ"NÂÃbÑÂÇZÂËO\ÂÎŽVÂÐ}ôÂе?ÂÏ DÂË— ÂÆž¸ÂÀ¹Ÿ;²NÙªÓu£^¸Âœò•¢Â±'®ÂiyÂÓøÂâNÂPÂÛ#Âß;Âƨ çmÂ"× Â&bÂ-›¦Â:¸ÂNe`Âk7L†ž¸Â–|j¢*©:^¬«…®u®þú°[#²n˜Âµ²Â¸ºê½.˜Â¾~w¾”{½Oߺ¸R¶ó3²9Û¬ÍP¦éy Äš…¢Â”O\ÂŽ6ÉÂ&éÂ.Â%¦é JÂ7LÂ33 ¬Â"%ãÂ$ ÅÂ(bÂ-/Â4üîÂ@˜“ÂPØÂe|îÂ|qªÂ‰ ÅÂ’œÂ˜p¤Âœ½ôŸ£T¡ۦ£ô¼Â¦,‹Â¨ˆ1ªã×­®¦é¯ŽV¯‹D®†%¬€Â©ŒÍÂ¥Ðå¡vÉœ©ü—‘ìÂ’P击ç ÂŽVÂ|îÂH´ÂñªÂ}ôÂýô \Â#^5Â&³3Â*ð¤Â0˜“Â8@ƒÂBs¶ÂOn˜Â^ÌÍÂoTþÂP冢ÑÂŒC–›#“õ?–¬™å›MÓÂnŸcT¡Ù¢H´Â¢ëÂ¢× Â¡üî Z Âûçš÷L—iü“s¶Â0¤Âнq†0!œ¬Â ÖÂÒòÂÏߺ^”{ÂgmÂDœÂ C–Â#\Â']/Â+ô¼Â1¨öÂ8ÎÙÂA¤ÝÂL/ÂXšÂd¬ÂpúáÂ|5?‚ñªÂ†ùÛŠO\š†¨Â‘®˜Â“œ)•I7–¥`—™˜ Ó—ð!—49•ٚ“æf‘jÂŽxÕ‹(s‡\ƒÃ¯Âw¶F ñªÂ ýô ÂþúÂùÛÂúáÂhÂSøÂ"ãTÂ&çmÂ+bÂ1oÂ7›¦Â?E¢ÂHÂQ•Â[PÂecTÂnš ÂvâNÂ~ Â‚(ö„Òo‡#T‰'mŠäÝÂŒYšÂ|îÂŽ@ƒÂŽ–‡ÂŽs¶ÂÏßÂŒª‹1ˆó¶Â†yÛƒ¬€›¦Âz°!ÂsäZÂlí‘Ác%ÁZbÁOûçÁDÔþÁ8°!Á+¶FÁ“Á(öÁ=qÀ陚ÀÐÄœÀ»33Àª¬ÀžÐåÀš~úÀž$ÝÀª‡+ÀÀÀÞ\Áå`ÁvÉÁ5dZÁRéyÁr‹DÁ‰´9ÁšdZÁ« Á»C–ÁÊçmÁÙ²-ÁçvÉÁô1ÁÿG®ÂŽV»d )üÂÛ#ÂÖÂ$ÝÂÔþÂô¼Ág%Á]&éÁQ÷ÏÁEt¼Á7¶FÁ(Ý/Á¸ÁÐåÀð¬ÀÐr°À²5?À—\)ÀhsÀc÷ÏÀU¸ÀXÄœÀpÄœÀ À°ƒÀÜ“ÁvÉÁ&ÐåÁH(öÁkçmÁˆ‡+Á›dZÁ®&éÁÀ~úÁÒ¬ÁâÄœÁò9XÂ$ÝÂffÂ ÓøÂcTÂoÂæfÂæfÂ!Ë©üÂbÁkïžÁa/ÁTÝ/ÁFõÃÁ7…Á&§ðÁ›¦Á®ÀÜ´9À¶ffÀ‘ãTÀaº^À*^5À‰7¿Ö¿Ó¶FÀ“uÀ0QìÀy&éÀ¬Ý/ÀçïžÁ JÁ;™šÁcë…Á†éyÁœ-Á±ZÁÆ JÁÙñªÁì¼jÁþ&éÂùÛ öÉÂøÕÂô¼ÂèsÂÙÂ!ÖÂ"ñªÂ#@ƒÂ"Ü)ÁqïžÁfZÁXéyÁI•Á8^5Á%dZÁÝ/Àö-ÀÉ/ÀœÀ`´9Àr°¿—+¾·KÇ>\)>€ƒ½\)¿YXÀ`BÀpÀ¹²-ÁñªÁ-%ÁZ=qÁ„§ðÁœ—Á´t¼ÁËÔþÁâZÁ÷¥ã°!›¦Ât¼Â ÅÂ"“uÂ&ÌÍÂ)ÖÂ+ÂÂ,«Â,®Â+éyÁy+ÁlÌÍÁ^IºÁMPÁ:\Á%dZÁ9XÀêÈ´À¶ÙÀ‚{ÀÌÍ¿på`> J?µ¡Ë@ó¶@zá@áH?ž¸R½Àƒ¿öÀ†{ÀÚ\Á JÁNvÉÁ‰7Áœ`BÁ·=qÁѰ!ÁëG®ÂǮ +Â, %Â'vÉÂ-l‹Â1êÂ5Â6ɺÂ7iyÂ7%Â5Å¢Á€å`Át¼jÁe?}ÁS&éÁ>ffÁ&ýôÁ ‡Àâ JÀ¦§ðÀS33¿³÷Ï>Ç®?þ—@R-@…?}@‘‡@ŠMÓ@_¾w@9X=²-ÀÊÁÀ©‰7Á5?Á?ß;ÁzE¢Á›¸Á¹^5Á×dZÁô¥ãÂDœÂ5?Â ÓøÂ*áHÂ32-Â9¶FÂ>s¶ÂA„ÂCbÂCG®ÂB[#Â@~úÁ…ó¶Á~QìÁm÷ÏÁZ£×ÁD-Á*\Á ãTÀÜí‘À™©üÀ'l‹¾Õ?ÙX@g\)@¦vÉ@ÊvÉ@ÛÎÙ@×®@¼í‘@Œ9X@\)¾Þ5?Àc¶FÀáXÁ-p¤ÁmÂÁ˜E¢ÁºbNÁÜ¥ãÁþffÂbNÂhsÂ+ÔþÂ7MÓÂ@œ¬ÂG²-ÂLŸ¾ÂO\ÂP¹XÂP^5ÂNÁ‰ÂL¾Á‹ÐåÁ„ÙÁx§ðÁd9XÁL1'Á0r°Á =ÀÜr°À‘VÀdZ>ò°!@<“@¦¸R@äIºAÄœAÐåA‹DA?}@Û+@’V?ß;d¿Ç =À¨9XÁÁ[× Á“oÁ¹¶FÁá33ÂIºÂLÍÂ(í‘Â8‹DÂE¬ÂPhÂW²-Â\²-Â_SøÂ_èsÂ^ƨÂ\C–ÂX®Á’…Á‹xÕÁ‚¸RÁp ÅÁV¸RÁ9 ÁõÃÀᙚÀûç¿Ó•?›Æ¨@ë…@×33A‹DA,¬A<ùÛA?33A2vÉAÊÁ@ã…@†=q?S33À@1'Àê°!ÁAß;ÁŠjÁ¶¡ËÁäĜ ¶F VÂ59XÂGyÛÂV|îÂb ÂjoÂnñªÂqÂp¾wÂn’oÂjë…Âf(öÁšbÁ“oÁŠ5?Á~záÁcïžÁD~úÁ Àí?}À‘™š¿» ?áÊÁ@ (öA‘hA-AP=qAf1AkçmA`´9AE× A+@â-@so¼D›¦ÀÌÍÁ²Áy;dÁ°¬Áç¬Â±'Â+ÂCñªÂYPåÂjcTÂvô¼Â9XÂÒò‚gm©üÂÈ´Âz²-Ât„Á¢n˜Á›¡ËÁ’ÎÙÁ‡¬ÁsûçÁS‡Á,r°Á{ÀœÌÍ¿Áë…@1@¶°!A{AGÂArE¢A‡PA/A‰5?Ay?}ATzáA*~ú@÷ÎÙ@„Ôþ¾î—ÀÄ“uÁMÎÙÁ¤dZÁç£×ƒÂ7öÉÂUöÉÂnïžÂÙ‡¿}‹ƨ†%Âhs‹×‰0¤Â…ÄœÂÔ{Á«\Á¥“ÁœvÉÁ‘XÁƒjÁdÙÁ1'@ž§ðAE¢A]hsA‰|îA›-A£bNA¦r°A¯C–AÊÆ¨Aþ²-B ±'B<#×BAèsB)W Aâ =@ÂñªÁ¬‡ÂC–‡ÂŽçð®þwÂÂçmÂÍ2-ÂЋÇÂϲÂÊ}ôÂÃÑh»ë³cTª¦f¡ýôÁÕ-ÁÑ`BÁËbÁÁ´9Á´´9Á£ƒÁ¥ãÁe®Á&IºÀ¼zá¿G®@}A &éACXAcC–AbáHAJQìA8¬AZ~úA¨ÊÁB å`BTŠ=Bî˜BŸZB•~úBdÂAÆ-Á“Âe ¬®ÂИ“ÂãCÂê;dÂé¾wÂ䟾Âܰ¤ÂÓ$ÝÂÈÌ;7L³Ä©°!Áßå`ÁÝÁדuÁÏÁ®Á±çmÁœ¬Á€ë…Á@‡+Àê§ðÀ j@AxÕ@õ`BA+KÇA-/@åX?fffÀo =¿àA BYB€çmBÇݲBñáHBè‘ìB»B1ÖÁ®“šÚÂÞýôà Óà =ÃÃÚ^Âû‰7Âïn˜Ââ{dÂÕ`ÅÂÈ’o¼V°ÒoÁêE¢ÁèQìÁã× ÁÜ/ÁСËÁÀp¤Áªå`ÁvÉÁ[ƨÁ å`ÀS @Ÿ¾@ñ²-A*=qAff?ì‹DÁ&ÙÁ¤33Á±•Á(r°A–Ý/B~8RBèÖC1ìC äZBÚB¡ËÂ_ ÂûcTÙà è´ÃøÕÃcTÃó3à ¤ZÃþÂñQìÂá6ÉÂÒÂÄb·(sÁôbÁó JÁï‰7Áè× ÁÞ-ÁθRÁ¹¡ËÁž-Áw¡ËÁ$ÌÍÀŠ=q@ çmA©üAM\)A>V?Î5?Á‡Ÿ¾ÂãTÂ&Å¢ÂA‰Á¬B-B·BB÷¹XBÞ“B‚s3ÁµVà JÃiìÍÃ\XÕÃI¢Ã;)ºÃ.AÃ!¬Ã†fà Âÿ ÓÂëÏ\ÂÚaËÂÊ¥ã¼vÉÁýÁüçmÁúXÁô¡ËÁêí‘ÁÜXÁÇïžÁ¬Æ¨ÁŠÁ=÷ÏÀ­‰7@bNA°!A…+AŽë…@ÉXÁ¤ JÂ>ØÂuûçCúCúÁ›¦B 'ðBYs¶BÖÁBÝ/ÂÑšCúüjÃnŠÃWõÃÃCƒ–Ã1Jà ҰÃ:Ãs¶Âô–ÂáœÂÏÇ+ÂÀƒ–‚ ÂàB PÁÿ^5Áö²-Áé"ÑÁÕ°!Á»E¢Á˜ÌÍÁZMÓÀÜ“u?¢n˜A+KÇA¡`BAÆn˜AK`BÁêß;Cúº.˜CúCúÂE!ËÁ¬õÃÁVzáÁþIºÂíÃ~5CúCúCúúÃs¤ÃXR°Ã@¦Ã*ÙXÃö‡Ã Âû+ÂåªÂÓw´$ÝÂýô Å˜“Â33¹XÂð¤Â ž¸ÂŒJŠ=ÁðñªÁÚº^ÁÁ =Á¦?}Á’oÁ›QìÁóhsÂ`šÂ¯¶FÂã2°ÂüI7ÂúÏ\Âñí‘Âí’oÂðJÁÂùÍPÃx“à æ¨ÃÒ°Ã ‰yÃ&;Ã&è1Ã"}Ã9XÃ^ð!Â÷›#Âåˆ1ÂÕCÂÆ¯žÂ¹ž¸Â­áHÂò°Â:^Âð¤Âë…ÂÂÂǮ ,‡Â~úÁó%Áá¬ÁÏÒòÁƃÁØ ÂùÛÂ_½q ì‹ÂסËÂø”{Âõô9Âê|jÂä0!Â䓸Âê“øÂô·LÃqÃ×à höð!à Óà ZáÃ'mÃe`ÂóñªÂå ÂÖ®˜ÂÉI7¼ì‹Â±”{§2-œ¬Â+Â÷ÏÂOßÂïžÂ·LÂŽVÂdZÂ:^ .‘hÂ#×ÁýA‰Âå`Âk…Â9œ¬Âx@ƒÂ¡æéÂʧmÂäuÂä9ÛÂÜ9ÛÂ×2-ÂÖýôÂÚçmÂá¶ÉÂê JÂòkÂùPåÂýe`ÂýÄœÂú<îÂóPbÂéó3Âß,‹ÂÓÕÂȃ½ß³+…©k QìÂ%Âb¸RÂiy‹D PÂå`¼jÂu²ÂXÂ(öÂxÕÂ1m‘ÂV«Â…#T¡1¹ëÂÉTþÂÌ‹ÇÂÊ ÂȦÂÈ— ÂËŽÙÂÐXÂÖ 7ÂÛ¤ÝÂà/žÂâÒòÂãÂàŽVÂÛ¹ÛÂÕ–ÂÍ%ÂÄQh»V‡Â²e`©²-¡[#™p! 9XÂàBÂ;dÂ;dÂÓøÂþú½qÂ"ÑÂZ¶FÂËÇ›¦Â"ÊÁÂ.ÐåÂC•Âb³3„¾w˜G®Â¨O\²¦f·/¸\)¸ó¶Âºk½‡ÂÀ¶FÂÄÈ1ÂȬÂËÃÂ̓ÂÍ\ÂËÆ¨ÂÈC–ÂÃKǽ<î¶t¼Â¯G+§ô9 «…™ÓÂ’¯ >wÂüîƒÂɺÂÊÁ‡+ 7Âl‹Âå`ÂËÇ ¬Â%]/Â-‡Â9XÂKzáÂc¨ö¤݋D˜ñªÂ¡ ºÂ¦ ¨ë«1­8Õ¯Ñì²ȴµۦ¸­‘ºÚ¼ Á¼ƒÂº£T·ûç´2°Â¯}ª"N¤UžL͘/žÂ’)ÂŒ'ð  Â ë…–‡ÂÂn˜Â Å¾wÂçmÂOßÂ!E¢Â%?}Â*Ý/Â2êÂ>6FÂMDœÂ_Å¢Ât6F„ÂŒ»ç“{ç˜fé›÷ÏžǮ¡W £á˦p!¨ãT«¨Â¬ž5­qªÂ­Z¬Cª0¤Â§8Õ£}Ÿ/žÂšr°Â•ožÂG®Â‹{Â…ë Ñì °!ÂwÏÂ&é¿}ÂLÍÂàB—¡ËÂ#@ƒÂ'ÌÍÂ-µ?Â5t¼Â?p¤ÂKÍÓÂZ.Âiš Âx½qƒ/ˆåãÂ{ç‘$Ý”(ö–Ðå™A›„Œ͟=ô s¶Â¡ Ǡ렢ž[#›ùX˜öÉ•q'‘†¨ÂSøÂˆô9„|j€Âhs NÙÂ)üÂùÛÂÖ‘hÂvÉÂŒJÂùÛÂ#ñªÂ(µ?Â.‹DÂ5¹XÂ>n˜ÂH¨öÂT Â`(öÂl\Âw‡Â€eㄇ®ÂˆŠöFŠ=ÂÒò‘Ø“”{”÷L•ë…–\)–7Ï•vF” Â’#T©yÂŒ¾w‰wÏÂ…ì‚/Â|¨öÂt× ÂâN ËÇ ±'•Â~úÂwÏÂ\ÂÜ)Â|îÂ#˜“Â(YÂ-ë…Â4wÏÂ<\ÂD£×ÂMúáÂW²-ÂaRòÂjn˜Âr´9Âz€0¤Â‚ñªÂ…Z‡s3‰B ŠÃ‹í‘ÂŒ³¶Â ºÂŒäÝÂŒ>ú‹“‰wL‡eã„ò-‚-Â~MÓÂwáHÂq2-Âj[#Ád´9Á\£×ÁS²ÁI¶FÁ>ýôÁ3²Á'ÊÁÁÊÁÁó¶Á§ðÀôÌÍÀãdZÀÖ¬ÀÎ JÀÌ1'ÀÑXÀÞ{ÀòÀƒÁ¥ãÁ²-Á/7LÁG¾wÁbŸ¾Át¼ÁŽÆ¨Áž ÅÁ­~úÁ¼›¦ÁË7LÁÙ‡Áæ JÁñí‘Áü•ÂöÉÂò°Â :^ Ñì¼j¶FÂÝ/ÁhƒÁ_¥ãÁU¡ËÁJ‡+Á>jÁ1l‹Á#ÊÁÁÊÁÁÎÙÀô›¦ÀÛ¥ãÀÅó¶À´ÌÍÀ©xÕÀ¥/À¨õÃÀµ‰7ÀËKÇÀêE¢Á  Á å`Á‹DÁ/× Á =qÁ JÀÿ\)Àß\)ÀÁOßÀ¦§ðÀí‘À²-ÀtÝ/ÀxÔþÀˆ“uÀŸSøÀÀÄœÀìbNÁ£×Á/ ÁPÀƒÁu ÁxÕÁ Ý/Á´OßÁÇt¼ÁÙõÃÁë…ÁûÙÂZ ð¤ÂŸ¾ÂZ¾Âô¼ÂäZ  Z DÁrÀƒÁhQìÁ\QìÁN¼jÁ?²Á/ ÁdZÁ ÐåÀï®ÀʬÀ¦MÓÀ…ûçÀUãTÀ.5?ÀƒÀß;À.—À]ÒòÀ’È´ÀÂffÀü£×Á bÁEt¼ÁmãTÁŒ&éÁ¡çmÁ·Æ¨ÁÍ\)ÁâC–Áö ÂE¢Â  ÅÂþúÂG®ÂožÂ#uÃÂ&aHÂ(C–Â)33Â)IºÂ(¢ÑÁyp¤ÁnMÓÁaXÁRƒÁAÛ#Á/t¼Á‰7Án˜Àá7LÀµÀ‹KÇÀI‡ÀÙ¿¨´9¿XQì¿>¸R¿ˆb¿èõÃÀ@å`À”1ÀÓ®ÁñªÁ85?Áe =ÁŠ$ÝÁ¢~úÁ»“ÁÓzáÁë/ÂÞ5 TþÂǮ JÂ$Â)¡ËÂ-æfÂ0ß;Â2£×Â3QìÂ3 PÂ1øÕÁ€©üÁuPÁg¶FÁW¶FÁEÁ17LÁ Á7LÀÔÄœÀ¢^5Àb=qÀff¿Y‡> =q?D›¦?z^5?6È´½På`¿§ïžÀB\À¦$ÝÀöÙÁ(\ÁYë…Á‡(öÁ¢\)Á¾bÁÙ¸RÁô¾wÂC–Â9XÂøÕÂ'H´Â/%Â5¾Â9œ¬Â<‘hÂ> ÅÂ>s¶Â=¶FÂ<Á…A‰Á~=qÁo²Á^~úÁJÔþÁ4§ðÁ ÅÁ™šÀË"ÑÀ‘©üÀ1xÕ¿‹Æ¨>ÍÒò?ÍÒò@dZ@1xÕ@%Oß?éÛ#?× ¿¨QìÀfùÛÀÊ JÁÎÙÁK©üÁ‚¼jÁ¡ ÁÀdZÁßïžÁþýôÂ[# ÅÂ(k…Â2ò°Â;‰7ÂB ÅÂFƨÂIŸ¾ÂJÙÂJ¬ÂIRòÂGÁŠPÁ„;dÁy33Ág‡ÁRbÁ:{ÁC–Áó¶ÀÅOßÀ„jÀ¸R¾¾w?Í‘h@D(ö@ƒC–@“¥ã@Äœ@sSø@¡Ë?ß;¿ë"ÑÀ•ÊÁÀý™šÁ8ùÛÁxvÉÁž/ÁÁ´9ÁæÂÂQìÂ&KÇÂ4ožÂ@[#ÂIÛ#ÂPçmÂU²ÂX33ÂXë…ÂXhÂUí‘ÂRÄœÁ\ÁŠ&éÁ‚G®Áq¥ãÁ[dZÁAº^Á$¼jÁ°!ÀÄ9XÀw|î¿ÈõÃ?)ûç@-ó¶@ާð@¸@ÎáH@Ðr°@»P@‘/@'|î>:^5À.—ÀÃ\)Á¾wÁeOßÁ˜ÄœÁÁÁëÆ¨Â bÂl‹Â2²ÂBožÂOéyÂZW ÂaÀƒÂfZÂhuÃÂhqªÂf¯Âc‹DÂ_YÁ—KÇÁãTÁˆãTÁ~A‰ÁfýôÁK× Á,ÌÍÁ $ÝÀÈÄœÀqxÕ¿šŸ¾?¨Ôþ@k•@·dZ@éó¶AbNA1'@ÿP@×ÎÙ@œ£×@"~ú¾Ÿ¾wÀn5?Àù¡ËÁHõÃÁ§ðÁ¿ JÁñ“ÂÑìÂ*hÂ@“ÂR÷ÏÂb ÅÂml‹ÂtþúÂy7LÂzŒJÂy~úÂvPÂr)üÂl¶FÁžº^Á˜p¤Ál‹Á†|îÁtñªÁX‡+Á7²-Á£×ÀÓ¶FÀxÔþ¿‡ïž?à£×@²-@Ù‘hA ‡A A&ÐåA!©üAáH@íÂ@« @0“u¿`BÀ— ÁáHÁ€ùÛÁ¹/Áõ°!ÂŽVÂ6ÒòÂPò°Âf¼jÂwž¸ÂÊ=Â…}ô‡5ÇI7† ÓƒÒo€ۦÂzÇ®Á¦ÐåÁ ÂÁ˜Û#ÁŽß;Á‚›¦Ág× ÁExÕÁMÓÀå‰7À‡²¿•Â?õ¸@œ@ñp¤A× A4ƒA@¬A@“A4Ý/A"bNA zá@Õp¤@s× ¾±&éÀÀ£×ÁS¶FÁ®“Áù{Â"¨öÂF|îÂe¡ËÂ~©üˆ‘hÂŽ¬Â’œÂ“åÂ’IºÂ5ÂŒî˜Â‰ Ç„µ?Á¯xÕÁ©ÂÁ¢“Á˜7LÁ‹Û#Áy®ÁV¬Á-"ÑÀþvÉÀš°!¿ÇP?ß²@Â@úA#`BA?;dANùÛASxÕAP—AK;dADõÃA8IºA@»Æ¨¾hr°Á 1'Á›A‰Áúß;Â-áHÂZ[#ÂPÂú^—Ǯ£T 8Õ 7LžA‰ÂšàÅ–†¨Â‘ŒJÂŒ7LÁ¸“uÁ³SøÁ¬ =Á¢dZÁ–“Á†éyÁihsÁ>ýôÁ‡ÀµÀÙ?V@£×@î5?AÝ/A7t¼AFå`ANÙAV´9AfA}ó¶AŠ(öAŠvÉAi²-Aº^À…Á|“ÁûçmÂ=ÂtÅ¢Âs¶Â #T©ùX®÷ϰ3¶Â®¥ã«¦Â¦7L wÏš;ç“ɺÁÁýôÁ½OßÁ¶ƒÁ­=qÁ¡(öÁ‘÷ÏÁ~ýôÁS|îÁ!ë…À× ÀIë…>Æ$Ý@iÛ#@ËÆ¨A§ðA|îAïžA!ÊÁA5¸AaÒòA”xÕA¼å`AضFAÓÌÍA X@ë33Á.Âð¤ÂT}ôÂ"Ѧ›¦Â¶ò°Â¿ÄœÂÂèsÂÁüj¾B¸®˜Â±ò°Âª’ò¢í‘›E¢ÁË‹DÁǃÁÁOßÁ¸‹DÁ¬ÐåÁÈ´Á‹5?Áj“Á7"ÑÀýÒòÀˆ1¿(´9@ =@˜“@¸¬@¯t¼@ŽÐå@²@´ýôA)çmA˜E¢AëVBûçB$ PB vÉA“ÊÁÀΟ¾Â¦Â~³3©˜“ÂÄë…ÂÓÒoÂÙÀÂÙ™ÂÕyÛÂÎÙÂÆºá½Òo´œ)«l‹Â¢{çÁÕ JÁѺ^ÁÌ7LÁÄVÁ¸ÐåÁª{Á—PÁ¸ÁMûçÁÒòÀ­`B¿Ý²-?©X@EV@8´9??}À6ùÛÀ§¾wÀp¤@%Ar ÅAýÔþB<÷ÏBX°!B<úáAÐVÁ¸ÂCQì¨ÂÖ|jÂîÊ=Âø/ÂøF%Âòñ'ÂêdZÂàåÂÔæéÂɃ¾J=³z^©8ÕÁÞOßÁÛ¾wÁÖùÛÁÏ…ÁÄáHÁ¶•Á¤?}Á¬ÁeïžÁ)PÀÒffÀ*Ÿ¾?ƒ?ý/?(´9À~{Á*vÉÁ¾wÁ‰ÙÁ.‡+@ƒ¶FAË‘hB8®B_`BB;%A“¸RÁÛÆ¨Â¡uÃÂóã×à àBÃ^wÃFà ËÃ7 ÃÕÂñffÂâ½qÂÔ BÂÇH´ÂºÒo¯F%Áç ÅÁåXÁá\)ÁÚ¬ÁмjÁÃ%Á±VÁš…Á~¸RÁ@1À÷"ÑÀ\1>Ÿ¾?èQì¾%ãTÀá‰7Á$ÝÁÝE¢ÂÀƒÁòáHÁ;d@Ó+AÝÙB~úA¹n˜ÁM¥ãÂà °bÃ8µ?Ã=I7Ã5!ËÃ+mà LÍÃà ÃìÂï¨öÂÞ²°ÂÏ;dÂÁ-‘´lÁïOßÁîIºÁë Áå9XÁ܇ÁÏ“Á½´9Á§xÕÁŒ+ÁWãTÁhsÀ‡l‹;o@…>s¶FÁ §ðÁÃC–Â")üÂKøÕCúÂ,33Á­{À¿2ñªÁí‘Ân†%ÞwÃj3ÃŒ}ÓÃo˜“ÃX ÁÃDÍ‘Ã3IüÃ#†¨ÃRoç®Âúë…Âç-ÂÕº^ÂÆ>ú¸s3ÁöÄœÁö|îÁô ÁïoÁæÐåÁÚ´9ÁÊ$ÝÁ´—Á™¬Ár‹DÁ'ÊÁÀ­X¿ë…@"Ÿ¾?O²Á"VÁÿ{Â_™šÂŠ,‹Â“¢N‚áHÂHKÇ JÂ"±'ÂqÄœÂÐ JÃ:´CúCúÖiÛÃ{bÃ]M‘ÃE-ÓÃ0[çÃPbÃï\ÃåãÂí’òÂÚr°ÂÉÐå»7LÁý^5ÁýÈ´Áü-ÁøÁð¶FÁå£×ÁÖ/ÁÁÄœÁ§ïžÁˆxÕÁGKÇÀël‹Ào?£o¼å`BÁ>b„#פð¤Â®ô¼Â¥jÂ’øRˆß;“`BÂ»ÓøÃËDÃLkÇïðÃíÆ%ú£–ÃŒéÛÃqdÃTp¤Ã:¥`Ã$ïÃ2òñªÂñTþÂÝ ÁÂË©y¼’òÂ…Â Jž¸Áÿó¶Áù¬ÁïÈ´Áá´9ÁÎß;Á¶áHÁ™“uÁn§ðÁ#XÀ³®À õÃÀƒ®Á}©üÂ!Ì͉ձÎVÂÄ“ÂÀî¶4¼Â³‘hÂÁÏßÂç=ôÃÅãÃHpåË'ÃÕýôCúê ¿ßÃ_Ò-Ã@ƒÃ'öFÃÄÃ{dÂò ÓÂÝLJÂË«…¼vÉÂáHµ?¢ÑÂm‘ÂÑìÁùVÁì“uÁÛ¸RÁÆ1'Á¬Áí‘Á\5?Á#t¼Á\Á8jÁ¹ JÂ2dZ‹r°Â´CÂËÂÏq'ÂÌŠ=ÂÎõ?ÂÞÂþgðÃ{¦Ã?‚ ÃuÎVël¬CúìlÈ\îÃa^¸Ã?g®Ã&]/Ã6FÃÂÂÛ-‘ÂÉØ“ºçmÂƨÂß;Â#×Â^5ÂNÙ·LÁö¸RÁè ÁÕhsÁ¾ß;Á¥“uÁŒKÇÁr-Áo¾wÁœ JÁú;dÂI‹DÂó3¶|jÂÍ>úÂÕÎVÂØF%ÂÝ«…Âë÷ÏÃ7 ÃRòÃ2Ÿ}ÃUpbÃ~æ%ÃFfÃŒJ ÃwJÃS9šÃ6W à “Ã¦fáÂê2°ÂÖØÂÆQh·ÿ}Â:^Â’o )üÂÐåÂQìÂuà=ÁóÛ#Áä+ÁÑbNÁ¼²-Á¨ûçÁœKÇÁ¡ûçÁË‹DÂ-Â_`BšC–¼gmÂÏÏ\ÂØ«…ÂÝÂã7LÂïu?ÃåÃð¤Ã#÷Ã9ó¶ÃOü)Ã_}ôÃ`>wÃQ¨1Ã<;Ã(%Ãt{ÃÉ7Â÷ ÍÂâX“ÂÐ¥`ÂÁSøÂ³ìÂF¨Â Ø ¿} Ñì âNÂÅ¢ÂRòÁþå`ÁòIºÁã7LÁÒÌÍÁÓuÁºÀƒÁÂ7LÁê{Â"0!Âj 7žV‡Â¾ùÛÂÑ6ÉÂÙƒ–ÂÝ•Ââœ)ÂìoÂûxRÃiüÃoßÃ#xÃ0EÃ8˜“Ã9TþÃ2ÛÃ%é7ÃKÇà IºÂÿ7LÂê²°ÂØÄœÂÉ P»2°Â®çðÂô¼Â »d í‘ iy 7 ­Â6F—Áÿ¶FÁôhsÁèG®ÁÝt¼ÁØC–Áà÷ÏÂÈ´Â+H´ÂkŒJ›5?»kÂÏm‘Â× ÂÚŽVÂݹXÂäWÂïRoÂþLÍÃú^à =ÃÓ3ܬà ‹ÃùÃà {dà ‘Âî%ÂÝUÂÎ2°ÂÀŽV´F%©2- NÙ E¢Â ÀƒÂ ¢Ñ ÎÙ 0! ³3 W Â.ÂvÉÁý^5Á÷©üÁ÷—ÂbÂ0!Â8šÂnZ—@µjÂÉ·ÏÂÑÔ{ÂÓ³3ÂÕuÃÂÙãTÂáŒJÂëî˜Â÷âNÃàBÃÈsà ±ªÃ îÃf%ÜîÂøÍPÂëÂÝ8ÕÂÏ×ÂÃDœÂ·/¬âÑ£ 7 _; ƒ @ƒÂƒÂ8RÂNÙÂÖ ž¸Â   6FÂƨ¯ °!¯Â'µ?ÂH7LÂuŽV”çð­Ǯ¿3¶ÂÆØ“ÂÈýôÂʇ®ÂÍÌJÂÓF%ÂÚŠ=Ââ¶ÉÂê ÅÂñ Âô±ªÂôìÂñŠÁÂë 7ÂâC–ÂØ(sÂÍ}ôÂÂÏ߸r°Â®–‡Â¥Oßœ¤Z - yÛ uÃÂoÂDœÂ%Â[#ÂXÂ(öÂ#×ÂÜ)ÂE¢Âí‘Â%{Â8^5ÂUiyÂzº^‘¯žÂ¤J=±´¼Â¸ËD»äݾ ÇÂÀþwÂÅ6ÉÂÊ{çÂÐ6ÉÂÕ BÂÙå`ÂÜMÓÂÜ_¾ÂÙüjÂÕ]²ÂÎúáÂÇdZ¿²Â¶‘ì® JÂ¥¾wÂޖ0¤ÂÀƒÂ 1' e`ÂSøÂöÉÂOßÂl‹ÂffÂs¶Âí‘ÂaH«Â%Â1ÂC'ðÂ[äZÂyŠ=ÂŒ"Ñ™Ñh¤ ª“øÂ®q'±MÓ´LÍ·ٚ»ãTÂÀåÂÃäZÂÆ× ÂÈt9ÂÈmÂÆ§mÂÃ>ú¾vɸ¦f²&f«DœÂ¤>úÂB –lÂÑì Š°! uÂG®ÂLÍÂ'ðÂë…·LÂÁ‰Â^5 DÂ$xÕÂ,‰7Â88RÂH=qÂ\záÂs|îÂ…W®—ݲÂĜ¡ô9Â¥=ô¨Qì«|j® ±ó3´Ö¶ß;·ûç·äݶ†%³í°?}«´9¦‡+ ïžÂ›¸Â•:^Â^¸Â‰ ÅÂPå øÕ „ÂñªÂF¨ÂŒJÂÔþÂBÂ%Âk…Â"ÖÂ(È´Â0ÙÂ;“uÂI=qÂYˆ1ÂkdZÂ}2-†¬ÂiüÂ’»ç–åãšO\Â]²Â A‰Â£¨Â¥“u§»ç©Lͪ‡Â©öɨß;¦Ôþ£î˜Â Pbœ!H—ŠÁÂ’±'´9ˆ¬‹Âƒ®ÂV \ ¹XÂVÂèsÂ}ôÂ)ü DÂMÓ +Â$ñªÂ*ûçÂ2¤ÝÂ<49ÂG·LÂTàBÂbó¶ÂpñªÂ}ès„›#‰X“ÂG®Â™šÂ“†¨Â–-˜“øÂš°¤Âœhöž5ž2-žÙÂ)y›…™0!–@ƒÂ’ÒòœŠñ'†²°Â‚]²Â|1Â49ÂùÛ ¹X uÃÂ5?ÂÂõÃÂ"ѯ ȴÂ%¦éÂ+†%Â2š Â;ÂD½qÂOÂZÔþÂf“Âp¸RÂzJÁÂSu„푈®ÂŠÂ Â+ÂH1‘uÂ’}q“t9“äZ“ÀƒÂ“‘§m½qÂRoŠyX‡H´ÂƒÔþ€33ÂxçmÂqMÓÂð¤Â»d ‡+ XÂ5?Â(öÂC–š ÂJÁ t¼Â%?}Â*ÐåÂ1E¢Â8«Â@ð¤ÂIäZÂS2-Â\uÃÂeOßÂmxÕÂtËÇÂ{C–€vF‚ô9Â… ņþúˆŠÁ‰¼jІ¨ÂŠÞ¸ÂŠ»çŠšÂˆøÕ‡`BÂ…Z Â‚õÀB ÂzŸ¾Ât]/ÂmÚÂg1'ÁfŸ¾Á_t¼ÁW|îÁNÈ´ÁEl‹Á;•Á1p¤Á'?}ÁOßÁ÷ÏÁ ¥ãÁÈ´Àÿ¥ãÀúffÀú§ðÁ‡+ÁVÁ ÁffÁ/oÁBÌÍÁY/Áq¶FÁ†1Á“ÎÙÁ¡ë…Á°“Á¾‡ÁË©üÁزÁä¼jÁïáHÁùçmÂ\) ÅÂ?} ·L \ ÌÍÂ|î©üÁjQìÁbn˜ÁY•ÁO× ÁEG®Á:bÁ.bNÁ"ƒÁÌÍÁ ¥ãÁ…ÀñãTÀäÝ/ÀÝVÀÛt¼ÀàÝ/ÀíãTÁhsÁÒòÁ" JÁ7ÊÁÁP›¦ÁkçmÁ„§ðÁ”bÁ£Ý/Á³ÂÁÃr°ÁÒ¬Áá-Áîº^Áû"ѲÂõàVÂe`ÂûçÂÚ =š Â˜“Án¼jÁf$ÝÁ\jÁQ™šÁEƨÁ9 Á+ÂÁ{ÁffÁ7LÀî{ÀØõÃÀÈZÀ½À¹¡ËÀ½²-ÀÊvÉÀàQìÀÿ;dÁp¤Á+OßÁF¼jÁe =Á‚ãTÁ”‡Á¥ÄœÁ·—ÁÉ5?ÁÚOßÁê—ÁùƨÂÏß øÕÂLÍÂÀƒÂPåÂÂáHÂ÷ÏÂ[#¬ÁtÁj¼jÁ`$ÝÁT=qÁG¸Á8å`Á)ÊÁÁ$ÝÁ VÀõÊÁÀØÝ/À¿C–Àª~úÀœ“À•xÕÀ—ÎÙÀ¤1Àº—ÀÛPÁ;dÁKÇÁ;t¼Á\í‘Á€Ÿ¾Á“È´Á§PÁ»‰7ÁÏXÁ⛦Áôó¶Â ĜŸ¾Â|îÂRò ²Â"å`Â$·LÂ%§ðÂ%ÍÓÂ%@ƒÁz=qÁpQìÁdå`ÁWë…ÁIxÕÁ9®Á(¼jÁýôÁáHÀåó¶ÀÃ÷ÏÀ¥XÀ‹× ÀrŸ¾À^È´À_ ÀuÂÀ‘ë…À´´9ÀâÈ´Á ©üÁ.—ÁSXÁ{xÕÁ“Á©“Á¿…ÁÕÛ#Á럾Â/Â ÓøÂŒJÂ2- ©üÂ%çmÂ)éyÂ,¼jÂ.t¼Â/,Â/Â.bÁ€ÀƒÁw =ÁjÔþÁ\ÔþÁMoÁ;®Á(ÙÁí‘ÁbNÀ×¥ãÀ°“À‹ïžÀZMÓÀ+¶FÀ ÅÀ oÀùÛÀM/ÀŠéyÀ»ß;Àø“uÁçmÁG÷ÏÁt JÁ‘•Áª9XÁÃp¤Áܲ-Áõl‹Â‚ Ât¼ÂMÓÂ#Û#Â*üîÂ0¥ãÂ4ØÂ7§ðÂ91'Â9—Â9Â7“uÁ„õÃÁ~ýôÁr{Ác¸ÁR¬Á?"ÑÁ*jÁA‰ÀúVÀË¥ãÀž$ÝÀgß;À‡+¿Ê~ú¿G®¿St¼¿‰Û#¿äzáÀ<ÌÍÀ‘©üÀÑë…Á%Á:A‰ÁjZÁ/Áª²-ÁÇ"ÑÁãÛ#Â\ bÂbÂ%:^Â.ÏßÂ6©üÂ<¼jÂAoÂCÇ®ÂE%ÂDûçÂCÚÂAÑìÁ‰Æ¨Á„ ÅÁzÄœÁjõÃÁXÈ´ÁDMÓÁ-²-ÁKÇÀ÷;dÀÂÈ´ÀoÀ<¼j¿Í/¿`B>Z¬?ãT>¶E¢¾ Äœ¿½²-ÀHbÀ¦È´ÀöÈ´Á)p¤Á]Á‹dZÁª(öÁÊjÁëQìÂñªÂ†%Â#ãTÂ0—Â;TþÂCð¤ÂJcTÂNÄœÂQ?}ÂR JÂQiyÂO–‡ÂLÍÓÁ33Á‰t¼Á‚~úÁtr°Áa?}ÁK\)Á2ùÛÁbNÀøIºÀ½ûçÀƒß;Àå`¿T¼j>èõÃ?¯|î?ê~ú?ãt¼?— ==D›¦¿Ë"ÑÀlZÀÈ9XÁZÁL1'Á…‘hÁ¨ ÅÁÍ Áó Â ƒÂ¤ÝÂ/>wÂ=½qÂIÀƒÂS²ÂYÚÂ^¾Â`0!Â`YÂ^ì‹Â\8RÂX…Á•?}Á|îÁˆdZÁ²-Ák²ÁT~úÁ:vÉÁÎÙÀþ-À¾$ÝÀ{t¼¿þ{¾W =?¤ýô@ÊÁ@B^5@Hb@)G®?Î5?=ƒo¿ü1À(öÀò°!Á4‹DÁy¥ãÁ£ë…ÁΕÁû?}ÂùÛÂ)H´Â<”{ÂM ÅÂZ}ôÂd‹DÂke`ÂoTþÂp¹XÂoûçÂm‡+Âi»dÂdî˜Á›çmÁ–5?ÁoÁ†\)Áwó¶Á_ÊÁÁDMÓÁ%ƨÁÀƒÀÄ ÅÀ{dZ¿ä9X>LÌÍ?ó÷Ï@Mó¶@/@‰xÕ@~Ù@HQì?帼ě¦Àr°À­%Á$ÝÁ_ó¶Áœ²Áΰ!Âô¼Â®Â5ùÛÂL‚ Â_[#ÂnoÂx¡ËÂOßÂH´ÂxÕ€~wÂ}7LÂx{Âq÷ÏÁ£ Á“uÁ–Áº^Áƒ ÅÁmG®ÁP“uÁ0jÁ \)ÀЋDÀ„Äœ¿éûç>©ûç@ @l1@•X@£"Ñ@Ÿß;@©ü@]Â@>¸RÀ';dÀÐA‰Á; Á‘bÁÌáH¾wÂ'1'ÂEƒÂ_âNÂu6F‚å‡ë…Šñ'‹þw‹s3‰©ü†ó¶Âƒ“uƒÁªÌÍÁ¥‰7Áž¡ËÁ•éyÁ‹5?Á|å`Á_?}Á=¾wÁõÃÀã¾wÀ“¥ãÀ =q=ó¶F@ãT@i‡@–-@§…@« @¥`B@™ÊÁ@†~ú@C¶F?b JÀ6¸RÁ¾wÁ€7LÁÉ Å bÂ4“uÂY2-Âwûç‡áHÂ8R•Su—±'—×–H1“t9¹Û‹e`†³3Á²ãTÁ­ùÛÁ§ZÁžÌÍÁ”"ÑÁ‡;dÁp(öÁM¡ËÁ't¼Àý‘hÀªVÀ2Ðå¾øQì?º=q@: J@up¤@Š$Ý@‘ó¶@šÙ@ªŸ¾@½Òò@ÃÆ¨@¡G®?ãSøÀ‰`BÁT9XÁÄí‘ÂûçÂFñªÂsŠÀƒ?°A‰?îùÛ?ûçm@KÇ@3× @‹ïž@ÔÄœA "ÑAÂ@ã =?²Á%/ÁÆ{Â#ÑìÂbs¶Â‹¯ŸvF¬…³ÍÓ¶ŒJµë²áË®49¨uâ ›hö”¦éÁþwÁ¿ÌÍÁº%Á²$ÝÁ§éyÁ›"ÑÁ‹ÂÁsÂÁK¾wÁ í‘Àë;dÀšE¢À.Ù¿­/¿^5?¿›Æ¨¿ü1ÀV¿¿²?‘hs@¬záA!…AQdZA>1'@–\Á ñªÁÛzáÂA"чU¥ĺ>wÂÅâÑÂʹÛÂÊ´¼ÂÇ]/ÂÁևºõ?³Oß«Ro£F%›]²ÁÌ;dÁÈÝ/ÁáËÁ¼=qÁ²ffÁ¥áHÁ–•Á„—Á`\Á4ÙÁÈ´ÀÁVÀƒ\)ÀJ\À`ÄœÀ¢éyÀèÁ °!ÁIºÀ¤Ôþ?[¥ãA…AWº^AU•@Ÿ|îÁB1'ÂÛ#Âzê«´9ÂËâÑÂÝâÑÂå9XÂåt¼Âá)yÂÚÂÑcTÂÇݲ¾ D´EªÅ¡­ÁÔPÁÑÎÙÁÍ/ÁÆ\)Á½Á°ß;Á¡ÌÍÁÐåÁv‹DÁIë…ÁÀƒÀçÆ¨À­¸À›²ÀÃdZÁ%ÁT°!Á†(öÁŽKÇÁoçmÁº^?¼j@í‡@ìå`ÀEOßÁǸÂ^Ðå±–‡Âå¡ËÃ-ÃîÃZÃÔ{ÂùnÂí’oÂáßÂÔ‚ÂÈLJ¼¤Z±§ð§cTÁÜPÁÚt¼ÁÖ|îÁÐMÓÁÇPÁ»ë…Á­7LÁ›hsÁ†ÂÁ`bÁ1l‹ÁõÃÀÒ‡+ÀÈå`ÁOßÁPùÛÁœ¬ÁÎ&éÁê{ÁâbNÁ²$ÝÁX~úÀâáHÁçmÁ°;dÂE/°áËÃi7ÃE`Ã%lJÃ!¾úÉ7Çà CT Âð0¤ÂàZ ÂѦfÂĠ·­‘¬MÓÁäVÁ⟾ÁßXÁÙÛ#ÁÑÈ´ÁÆÌÍÁ¸£×Á§9XÁ’¸RÁw•ÁG²-Á7LÀ÷|îÀð›¦Á#¡ËÁ… =Áϲ ¡ËÂ'£×Â.KÇ»dÂm‘ÁàIºÂ%ÂCV¢ŽVÃ×Ã>ÝqÃ_=/ÃSn˜Ã@ÄZÃ0½ôÃ"nÃmPà šáÂýÜ)Âê¶ÉÂÙ˜ÂÊH´Â¼\°8ÕÁëÁê;dÁç©üÁâí‘ÁÛ£×ÁÑp¤ÁÄ JÁ³QìÁŸ\)Áˆ¸RÁadZÁ3ãTÁí‘ÁÊÁÁBñªÁ È´ÂÓøÂ3ÏßÂXdZÂgŸ¾Â`ß;ÂP/Ã(²-Ã?Ãl‹ÂøDÂãp¤Âѕ ´‚ ÁöÛ#Á÷VÁö/ÁóVÁí‘hÁåbNÁÚ9XÁËïžÁº¡ËÁ¦ÔþÁ‘× Á|Ÿ¾ÁbŸ¾Ág¶FÁ“‡+ÁݼjÂ(PåÂgËÇÂ’oœó3£å¥ɺ­®Â¿Æ¨Âã²ÃÝqÃ9þ¸Ãu*ߨõ(ÕÑU?ÃgC–ÃEŒÃ-ê=à ô¼ÂúuÂä~wÂÒ.ÂÂiy´«Áû£×Áü¶FÁüC–Áù÷ÏÁõzáÁî|îÁäÀƒÁØ-ÁÈë…Á·›¦Á¥´9Á–%ÁƨÁ•“uÁ¹t¼ÂøÕÂ949Âvæf– D¨‰Â±Â ¸49ÂÁÓøÂÔ/ÂóG®ÃoÃ1¶ÉÃ]e`Ëwý²Ã‰Ó×ÃeöÃD‡+Ã+ëÃ~¸ÃÛ¦Âø Ââº^ÂП¾ÂÁ P³}qÁÿ©ü¤Ý 7ÁüŸ¾Áöë…ÁîÀƒÁä Á×1'ÁÈÂÁºbNÁ¯ =Á«÷ÏÁ¹IºÁá=q³3ÂJ‡Â‚.˜Âœ®Â®¨sº_;ÂÃÂÍŒJÂÞCÂ÷÷Ïà BÃ%Ò°ÃB«DÃa,‹Ãr®VÃiMPÃRÅÃ9ðåÃ%ÅÙÛÃ8ÕÂò}ôÂÞLJÂÍ D¾/± PÂvÉŠ=Âýô°!€Áþ¡ËÁø"ÑÁï‡+Áå¬ÁÙ¬ÁÎÌÍÁÇp¤ÁÈ‘hÁÙ¬ÂÞ5Â&uÃÂXÊÁˆ(ö ¾w²Á‰Â¾ÎVÂÈ®ÂÒ0¤Âà†%Âôó3ÃuýqÃ+2òÃ5ÃDÓÃ9:áÃ)»#äà åãÂÿ&éÂéïÂ× BÂǹÛ¹ÍP­‰Â¿}ÂhÂ× Âô¼ÂMÓÂÌÍÂhsÁúOßÁòp¤Áé÷ÏÁâhsÁÞvÉÁâ—ÁõvÉÂ’oÂ2µ?Âb²Â‹¶É£$Z´iüÂÀÙÂÈÆ¨ÂѰ!ÂÝVÂí1ÃyÛà ÇÃöÃ"eãÃ({¦Ã(\¬Ã"YãTà ˜ÕùšÂñ_¾ÂßXÂÏO\ÂÁì´cש Ͳ-Â?}ÂSøÂÚº^ÂèsÂ_;Â.Áÿ%ÁùÁõ(öÁô`BÁû1ÂiyÂ`BÂ;ô¼ÂgõÃÂŒe`¢“øÂ³G®Â¾X“ÂÆ/ÂÍu?ÂÖŠÁÂâMPÂð®˜Ã[¦ÃJÃÝ/ñhÃÕÃOßà ìÃ^5ÂòvFÂâ’òÂÓ¬ÂÅúṂ®0!£èsÂW  ÂzáÂdZÂȴ ÅÂî˜ÂÇ®Â^5Â\Â~ú¹X ffÂäZÂ&öÉÂD‡+Âk„‹wLŸ·Ï¯[¦Â¹¤ZÂÀxRÂÆr°ÂÍqªÂÖ-‘Âà„œÂë®Âö\¬Âþô¼Ãò-Ã3Âÿ©yÂ÷LJÂìffÂàA‰ÂÓÓuÂdz¶Â¼33±s¶Â§}ôžLJ³3©üÂOß — yÛ ó¶Â V å` ® Ţ Ĝ›¦Â±'ÂãTÂ233ÂLÁ‰ÂnqªÂ‰»ç›(s¨ê²/žÂ¸U½mÂÂúáÂÉbÂÑþÂØó¶ÂàH1Âæ ÇÂéLÍÂép!Âæ`BÂàˆ´ÂØ¤ÝÂÏ€ƒÂÅȴ»ùÛ²eã©:á ŽÙ˜kÂÎÙÂò°ÂØ vÉ ËÇ Û# ²-ÂqªÂQì­ÂhÂQìÂ’oÂ*7LÂ;ŽVÂS PÂo„†ûç•8Õ ·Ï¨äZ®˜³9Û·æf½ß­ÂÈ[#ÂÍ‚ ÂÑxÕÂÓ©yÂÓ±ªÂÑ|jÂÍ?}ÂÇdZÂÀhö¸ÃÂ°ÓøÂ¨àB¡“™˜“Â’q'®ÂùÛ   ¿}ÂQìÂÏßÂYÂ&éÂbÂhÂ[#Â&LÍÂ1Ý/ÂAÈ´ÂVuÂm˜“ƒ =ÂŽiy—ևžúá¤Qh¨°¤Â¬Õ±{µp!¹¬½féÂÀ5?ÂÁ¶FÂÁ«…ÂÀ‰Â¼ÓøÂ¸_¾Â²ó¶Â¬àB¦lŸÑh™9XÂ’ÂÂŒ~úÂV h ?} RòÂW Â^5ÂP“ÂMÓ”{Â#xÕÂ+˜“Â6bÂD¸RÂUÜ)ÂiÂ|\‡`BÂ#ו`ÅšVžxÕ¢>úÂ¥áH©f鬭‘¯yX±†%²•²~w±2°Â®¾w«F¨Â¦þw¢¦ÂœÒò—P呸ÕÂŒ&醮˜ÂɺÂQìÂÈ´Â . ‰7ÂæfÂ\) =¾ÂÞ5 ˜“Â&´9Â.œ¬Â8©üÂDúáÂSH´ÂbÓøÂr‡+€ Å‡ ÂŒÓ‘”ó¶Â˜hö›˜ž‰ºÂ¡+£W ¤ã×Â¥¨öÂ¥‹Ç¤¢ßŸÎÙœ^5˜dZ”¨ÂgðŠ¥ãÂ…ØÂhÂ\¬Â@ƒÂ Ðå cTÂ%ÂËÇÂÓøÂDœÂQìÂ"wÂdZÂó¶ÂùÛÁp›¦ÁiVÁ`“uÁW7LÁMVÁB=qÁ6ýôÁ+‘hÁ QìÁ²Á ïžÁƨÀûSøÀô9XÀó33Àù%Á&éÁ ©üÁ{Á.E¢ÁC÷ÏÁ\ÌÍÁx5?ÁŠí‘ÁšPÁª§ðÁºñªÁË“ÁÚÐåÁéÒòÁ÷ÙÂTþ J  Â)ü‚  PÂÔþÂäZÂJÁ Áu²ÁmxÕÁd=qÁYó¶ÁN°!ÁB—Á5ãTÁ(Ý/Áß;Á\)Áß;ÀóçmÀäzáÀÚ§ðÀ×PÀÜ(öÀé‡ÀþÐåÁ´9Á"A‰Á9ÎÙÁTõÃÁs Á‰ïžÁ›E¢Á­7LÁ¿l‹Áч+Áã+ÁóýôÂÙÂýôÂQìÂÁ‰Â?}ÂËÇÂiyÂ!&éÂ"uÂ"C–Â!ÌÍÁ{t¼ÁrÄœÁhÐåÁ]™šÁQ;dÁCÒòÁ5™šÁ&áHÁ1Á •Àø1'ÀàzáÀÍp¤ÀÀzáÀºéyÀ½ãTÀÊ=qÀàjÁE¢Á"ÑÁ.‹DÁLbÁm =Áˆ\Á›ÂÁ¯ÀƒÁĸÁØt¼ÁìMÓÁÿ?}Âp¤Âm‘ÂqªÂffÂ">wÂ%ùÛÂ(¢ÑÂ*G®Â+Â*èsÂ*“Á¬Áy =ÁnjÁbQìÁTÝ/ÁF ÅÁ6^5Á%ß;Á Á\ÀéãTÀÍãTÀ¶ÙÀ¦MÓÀÛ#ÀžÐåÀª5?ÀÀzáÀáÒòÁùÛÁ" ÅÁAó¶ÁeÊÁÁ†®Á›çmÁ²(öÁÉÁßéyÁöXÂáHÂÑìÂŢ bÂ'Â,H´Â0-Â2ÐåÂ4LÍÂ4¾wÂ4F¨Â3+Á…Á€33Áu&éÁhA‰ÁY¾wÁI¶FÁ8ffÁ& ÅÁXÁ£×ÀÝÀ¼õÃÀ¡xÕÀŒýôÀ7LÀl‹À‰¡ËÀŸPÀÁ©üÀï¥ãÁvÉÁ6jÁ]‡Á„¸Á›‡+Á´XÁÎ%Áçó¶Â¸R âNÂ#×Â"33Â*Û#Â1úáÂ7†%Â;†%Â>oÂ?JÁÂ?YÂ>e`Â<›¦Á‰hsÁ„r°Á}&éÁo…Á`1ÁNÄœÁ;ó¶Á'çmÁ ÀübNÀÓß;À®~úÀŽ^5Àk ÀL1ÀC"ÑÀRñªÀ|ÌÍÀ ƒÀÏ…Á|îÁ)7LÁRzáÁ€£×ÁšjÁ¶ ÅÁÓ$ÝÁð¬ÂçmÂÏßÂ!œ¬Â,ò°Â6ŽVÂ>KÇÂD$ÝÂH)üÂJ€ÂKTþÂJÝ/ÂILÍÂFÙÁŽXÁ‰IºÁƒ9XÁx5?Ág× ÁUt¼ÁA7LÁ+t¼Á°!Àû ÀÍãTÀ£²À}?}ÀBn˜ÀC–À …À{À‡+À‹ïžÀÆÙÁbNÁ5SøÁk‡Á”¶FÁ·´9ÁÝPÂm‘ÂöÉÂ(Â9DœÂG«ÂS\)Â\:^ÂbZÂeô¼ÂgTþÂfÑìÂdÂÂaxÕÂ]=qÁ™ÎÙÁ”ÄœÁމ7Á‡1Á|n˜Áh5?ÁQ‰7Á8ÄœÁjÁC–ÀЋDÀ/À^E¢Àû翵`B¿q&é¿e¸¿¤¼jÀùÛÀVéyÀ¡ÒòÀèÔþÁ!™šÁZA‰Á^5Á·bÁâõÉ7Â|îÂ5²ÂH_;ÂX‰7Âe@ƒÂnyÛÂthsÂwiyÂwçmÂvW Âs!ËÂn¬ÂiIºÁ G®Á›^5Á•-Á›¦Á„²Át^5Á\ÄœÁBÌÍÁ' Á 1'ÀÚáHÀ¤1Àe?}À ¿¬‹D¿Iûç¿$Z¿e¡Ë¿Ã33À!G®À|1À½XÁ 5?ÁDÝ/Áˆ Áµp¤ÁèûçÂâNÂ+!ËÂD}ôÂZ—Âl”{Âz#׳3„`ÅÂ…`B„ýôƒƒÂ1'Â|„ÂuɺÁ§+Á¢vÉÁœhsÁ”ß;Á‹ÌÍÁ+ÁjbÁO"ÑÁ2-ÁbÀìÀ²ÙÀ|îÀ+Sø¿Ûƨ¿’Ðå¿t9X¿Š~ú¿»…À`BÀB\À’VÀàr°Á+p¤Á}ß;Á³t¼Áð× ÂcTÂ: ÂWÏßÂq‚U‰U´¼ÂÎV®ŽƨŒe`‰2°Â…nÂLJÁ®hsÁ©ûçÁ¤$ÝÁœÀƒÁ“¶FÁˆûçÁyC–Á]©üÁ?Û#Á ÙÁÀÊ JÀ—l‹À^È´À(QìÀ ¥ãÀ÷ÏÀ“uÀƒÀÄœÀ+oÀ`r°À®$ÝÁýôÁkPÁ³C–ÁýbNÂ&ÎÙÂN =Âpå`†åÂöÉ—Ǯ›vFœ’o›«™@ƒÂ•¾w‘}qŒ ‡ÂÁµãTÁ±ÒòÁ¬IºÁ¥"ÑÁœ;dÁ‘‡+Á…‡Án-ÁOÒòÁ0E¢Á+Àé¸À¹p¤À—33À„›¦À€r°À…`BÀ‹ ÀˆÝ/ÀwKÇÀSƨÀL›¦ÀŒÌÍÀúáHÁaÛ#Á¹ûç LÍÂ;hsÂjl‹Â‰>ú˜…¢Â¢Ü¬Â¨ÌJ«"Ѫ³¶Â¨:^¤Oߟm™ïžÂ”²ÂŽ+Á½ƒÁ¹ß;Á´¸RÁ­áHÁ¥9XÁš¬ÁŽA‰Á€/Áaº^ÁAïžÁ"õÃÁSøÀãïžÀË ÀÆÐåÀÔ“uÀëdZÀý‡Àû•Àà1'À²°!À7LÀ˜¼jÁ¸RÁr—ÁÑzá ŒJÂ\PŠƒÂ 2-¯¢N¸½q¼³3¼Ê=º5µ\¯ƨ©B ¢\¬Â›X”aHÁÅ$ÝÁÁûçÁ½IºÁ¶Ý/Á®‹DÁ¤?}Á—ûçÁ‰õÃÁu33ÁU\)Á6§ðÁA‰Á ÷ÏÁÁ í‘Á¼jÁ8jÁM…ÁSOßÁCó¶Á#p¤Á¸RÀû¶FÁ3PÁœ¥ã®ÙÃ*‡mÃC×à ¦fÂü†¨Âçk…ÂÕKÇÂÅ— ·ٚ«¸ÕÁõŸ¾Á÷Á÷C–Áö7LÁó²-Áï²Áé÷ÏÁâïžÁÛÁÓ“ÁÌÒòÁÊÈ´ÁÐÒòÁããTÂwÏÂ!$ÝÂF/Ân—Š'ð™½ô¦,±eã¾-‘ÂÏH´Âæ™Ã€BÃýqÃ)S3Ã;•ÃD†fÃ?ÔþÃ2t{Ã"á‰Ã°Ãã×ÂöÔ{ÂâöFÂѹX¬µo©³¶Áù¬ÁûÁûë…Áû®Áú$ÝÁ÷?}Áó =Áíº^ÁçÐåÁâ;dÁÞ\ÁßKÇÁèÁý;d¢ÑÂ-øÕÂQñªÂy =ÂŽãTžQìªٚ¶œÂÁöFÂÐÉ7ÂãÄÂûA‰Ã 0¤Ã?}Ã%3øÃ+|îÃ*´Ã"NÙÃs¶Ã åÃáHÂíÀÂÛí‘ÂÌ&é¾-‘±ÀƒÂ¦¦fÁûùÛÁþ`BÁÿë…Â;dÁÿéyÁþ9XÁûzáÁ÷ë…Áô =ÁðÂÁï\Áòº^Áýƒ ò°ÂÚÂ8A‰ÂZ ÅÂæf‘†¨Â bN¬r°Â¶ñªÂÁ“øÂÍúáÂÝ¢ÂîÆ%Ã)ºÃ Ï\÷ ÃVÃÁÃ5?à àBÃLÍÂó¦Ââm‘ÂÓ ÁÂÅ\¸n˜Â­ ºÂ¢¼îÁþ=qÂ\¡ËÂIºÂ}ôÂ?}š Â±'ÁÿƒÁþt¼Áÿ•ÂvɧðšÂ&iyÂ@C–Â`TþÂŒJÂ’ Ó «bN´éy¾{ÂÈ5ÃÂÓí‘Âá1'Âï:áÂü’òòØRß;ÃÊÂý–‡Âñ\Âã…¢ÂÖƒÂÉå¼ùX±ÎÙ§Óž'ðÁÿïžÂ ÅÂüî®ÂÂoÂþúÂ+‘hÂ;d éyÂÍÓÂVÂ.ÍÓÂF­ÂcÐ嫽ô¦é§ÿ}°}ô¸LÍÂÀ‰ÂÉ–ÂÓ{dÂÝ›¦Âæó3ÂîBÂòZ Âò…ÂîÄÂçÆ¨ÂÞ“øÂÔ-‘ÂÉ]²Â¾©y´_¾Âª§m¡ß™ ÂŒJÂiy 7ÂgmƒÂcT¦ÂÐå ÀƒÂ H´Â öÉÂP JÂ%‘hÂ6 JÂK¸RÂe’o€¥ãÂò-™p¤Â¢µ?ª<î°í‘·¢Ñ¾¼jÂÆ0!ÂÍ“uÂÔ8ÕÂÙRòÂÜ(öÂÜG+ÂÙ¤ÝÂÔšÂ;úÂŹX½#´Pb«¤Ý£E¢Â›KD“ÂÂáHÂë…ÂɺÂwÏÂùÛ X « Â ÓøÂ;dÂȴ¾Â! DÂ,]/Â;²-ÂO JÂeƒÂ}>w‰þú“ð!œ“¢Ç+¨›#®6F³âN¹›#¿ÂÃíÂÇŽÙÂÉ‹DÂÉ— ÂÇ¥ãÂÃæf¾±'¸qªÂ±ŒJªV‡Â£ß›äÝ”ñªÂŽG®ÂùÛÂ-Â@ƒÂ6F h àB ¸R¿}Â+ÂH´ÂƒÂ]/Â&qªÂ1PåÂ?PåÂPNÙÂczáÂwl‹Â…AµÃ”ÑìšÂŸéü¤¸R©`B­ãT²µ¬¸Q칻繸R¸:áµ]/±Tþ¬fé¦ؓ êšÏß”°!ÂŽ§ðˆÊ=ÂÙÂ.Âp¤Â¡Ë ɺ öÉÂ>wÂÖ·LÂ]/ 7Â"%ãÂ*¬Â4JÁÂ@× ÂOŠ=Â_¶FÂpQ쀬‡EÂr-Â’¹X—Q웄Ÿp¤Â£¦ff©%`« Ŭ'ð¬ªí¨®Â¥}¡ŒÍ´˜ ÅÂ’þúÂֈ‰7ƒbN„Âô¼Â\)¿} $Ý œ¬Â;d¾ÂuÃÂs¶Â\)Â$|îÂ,¸Â5uÃÂ@‹DÂM#×ÂZ¹XÂh‹DÂuÑì€ûd†X“‹¨Â!ËÂ’Õ–4¼Â™A‰Â›ìžŸ/ aË MÓŸZÂŽÙ›—ÌJ”‹©ü‡/žÂ‚¦éÂ|C–ÁÿùÛ‚ Â+Âb $Ý Ôþ³3ÂÚÂm‘š Â’oÂ%Š=Â,²-Â5$ÝÂ>Û#ÂIŸ¾ÂU DÂ`™šÂkÁ‰Âv Âl‹ÂƒÚ‡ƒŠÊ=¹XÂPbÂ’†%”G+•}q–þ•þw•5Ó¿}‘¨ö¨‹ñªÂˆƒ–„Ôþ€ûçÂz‡Âr&éÁþ‘hÂÜ)ÂuÚ Ïß ¦é®Âüî±'ÂêÂÎÙÂ%Â,¸Â3³3Â<1'ÂEiyÂOuÂXÎÙÂb@ƒÂk²Âs9XÂz†%€ƒ–ƒk…Â…üîˆ8RŠ‡Â‹ŠÁÂŒ‡®ÂŒÿ}ÂŒéyÂŒA‰Â‹ ljPå‡;„‰ºÂ¢ÑÂ|ùÛÂvVÂoxÕÂh}ôÁüÔþ«Â_; + šÂ7L™šÂTþ‚ ¼jÁNQìÁ`—ÁuG®Á…õÃÁ’(öÁžûçÁ¬/Á¹…ÁÆÂÁÓ©üÁàÁ뙚ÁöC–Áÿ× Â¸Â²-  Å í‘›¦Â´9Â@ƒÂLÍÁr¬Ál$ÝÁdÙÁ\ÙÁT9XÁK&éÁAÊÁÁ8jÁ/KÇÁ&È´ÁG®Á33ÁõÃÁýôÁ®ÁSøÁ1'Á(^5Á5çmÁF´9ÁZ‹DÁq&éÁ…Á’|îÁ °!Á¯XÁ¾1'ÁÌó¶ÁÛVÁé“ÁõùÛÂâNÂ'ð ¼j—µ?ÂÂÄœÂÈ´Â1' DÁwxÕÁpn˜Áh~úÁ_¶FÁV-ÁL1ÁA|îÁ6ÌÍÁ,MÓÁ"^5Áp¤ÁÁ ‹DÁ PÁ |îÁ ¸RÁ…ÁbÁ,bNÁ>^5ÁSÒòÁlr°ÁƒÛ#Á’°!Á¢bNÁ²©üÁÃ5?ÁÓ®ÁãÀƒÁó¬Âº^ÂC– hÂhÂ7LÂÂò°Â—Â{ç²-ÂMÓÁ}%ÁuÁlñªÁcdZÁXí‘ÁM¶FÁAïžÁ5ãTÁ)ë…ÁvÉÁÁ oÁ=qÁ“ÀþE¢ÁÎÙÁr°Á?}Á"E¢Á5hsÁLzáÁg&éÁ‚r°Á’º^Á¤bÁ¶$ÝÁÈ•ÁÛÁí Áþ33¦Â^5ÂÖÂ6F¨öÂ" Â$”{Â&#×Â&ÚÂ&ÏßÂ&¦Á°!Á{l‹ÁrMÓÁhÁ\§ðÁPZÁCSøÁ5ãTÁ(ffÁSøÁ7LÁ°!Àø¼jÀíÒòÀéÒòÀíÂÀún˜Á$ÝÁº^Á+ë…ÁDƒÁa7LÁ€ÀƒÁ’‘hÁ¥°!Á¹ÂÁÎ\)ÁãÁ÷=qÂF¨Â=qÂRòÂ_;Â#JÁÂ( =Â+²Â.hÂ/záÂ/ð¤Â/‘hÂ.xÕÁ…KÇÁ$ÝÁx§ðÁm²-ÁaxÕÁT ÅÁEß;Á7%Á'ûçÁ;dÁ l‹Àþ^5Àê~úÀܼjÀÖ^5ÀØ›¦ÀäQìÀú JÁ  Á" JÁ<ÁZ£×Á}p¤Á’$ÝÁ§5?Á½ƒÁÔ‘hÁëÒòÂQì 49ÂE¢ÂF¨Â' DÂ-uÃÂ2{çÂ6$ÝÂ8Â9­Â9ÊÁÂ8ýôÂ7k…Á‰^5Á…{Á€ =Át‡+ÁgÁY+ÁIº^Á9Á(éyÁƒÁñªÀõë…ÀÞ¸RÀÍÛ#ÀÄå`ÀÅ&éÀÏ…Àä¬Án˜ÁÁ3 =ÁS\)ÁxŸ¾Á‘bNÁ¨PÁÁbNÁÛMÓÁõ—»d PÂcTÂ)ožÂ1øÕÂ8âNÂ>$ÝÂAÍÓÂCøÕÂDÌÍÂDs¶ÂC¬Â@ò°Áå`Á‰‡+Á„SøÁ|—ÁnáHÁ_¥ãÁO‡Á=PÁ+xÕÁp¤Á-Àðå`ÀÖVÀÂ^5À¶°!À´¬À½XÀÑ`BÀñ%Á5?Á)ÒòÁKp¤ÁréyÁ5?Á©®ÁÅffÁâ¬ÂJÁ = PÂ)ÚÂ5 JÂ>e`ÂEƨÂK0!ÂNº^ÂPbÂPå`ÂOñªÂMì‹ÂK DÁ’å`ÁŽ|îÁ‰1'Á‚÷ÏÁw¥ãÁg¡ËÁV{ÁCXÁ/çmÁZÁ xÕÀðA‰ÀÒ‡+À»¥ãÀ­OßÀ¨õÃÀ¯¥ãÀÁó¶Àà(öÁC–Á ÌÍÁCoÁlZÁŽ—Áª“uÁÉ¥ãÁêë…—„Â'‡+Â5ýôÂBqªÂLš ÂT_;ÂYËÇÂ] JÂ^\)Â^ Â\E¢ÂYiyÂU®Á˜VÁ“÷ÏÁŽ¡ËÁˆIºÁ€í‘Áq7LÁ^ÐåÁK =Á6bNÁ!…Á ?}Àõ%ÀÔ›¦À»KÇÀªÈ´À¤r°À©‡À¹/ÀÔå`Àü¬ÁÐåÁ:ÔþÁe?}ÁŒ¡ËÁ«dZÁÎbNÁô|îÂ+Â!“uÂ3í‘ÂDF¨ÂR JÂ\ó¶ÂdñªÂj(öÂlß;Âmk…Âl&éÂijÂeŠ=Â`ËÇÁž1'Á™í‘Á”Ÿ¾ÁŽ=qÁ†ÀƒÁ|bNÁiXÁT¼jÁ?‡Á)"ÑÁƨÁÀÝãTÀÃ+À±Àª JÀ­7LÀºñªÀÓ33Àö‡+Á|îÁ3ó¶Á^\ÁЏRÁ¬‹DÁÔ5?¬Â$ÝÂ-ÙÂBì‹ÂURòÂddZÂoÜ)ÂwÊÁÂ|xÕÂ~OßÂ}ÄœÂ{KÇÂwRòÂr8RÂlMÓÁ¤jÁ QìÁ› ÅÁ”È´Á?}Á„\Áu¡ËÁ`jÁJ JÁ3XÁKÇÁ =Àï…ÀÔýôÀÄ1À½?}ÀÀZÀÌbNÀà“uÀý²-Á`BÁ0¼jÁZMÓÁ‰ÒòÁ¯“ÁÜdZÂØÂ"ÚÂ=RòÂUxÕÂiüîÂz'ð‚èö†ž5ˆs¶Âˆµ?‡±'Â…°!‚ñ'ÂVÂxoÁªïžÁ§‡Á¢{Á›Û#Á”`BÁ‹¥ãÁÊÁÁnÁW7LÁ@¬Á)ÒòÁ²-ÁVÀòÀäzáÀá`BÀç"ÑÀóSøÁÁ Ý/ÁjÁ5oÁ\QìÁ‹éyÁµ-Áé`BÂÔþÂ2¬ÂQ‚ ÂlñªÂ±'Š{¯’ȴ“È1“‘ÂŽ¸ÂŠwφ\)ÂøÕÁ±°!Á®"ÑÁ©dZÁ£`BÁœ1Á“bNÁ‰…Á}XÁfjÁO?}Á97LÁ%ß;ÁÐåÁ OßÁ Á VÁ°!Á´9Á"vÉÁ)ãTÁ3ãTÁFÈ´Ájí‘Á”l‹Á—ÁÿZÂ#VÂHèsÂl“uÂ…–‘r-™¨sž€Â } 9Xž9ÛšøR–ÖÂ’ BÂò‡ۦÁ¸“uÁµ`BÁ°÷ÏÁ«=qÁ¤ ÅÁ›¥ãÁ‘å`Á‡¬ÁwhsÁ`~úÁK Á9 Á,~úÁ&å`Á(í‘Á1¥ãÁ>VÁK/ÁTÝ/ÁZŸ¾Á` JÁm©üÁ‡§ðÁ¨‘hÁÝ“ÂDœÂ<™šÂh»dˆ«…™-‘¤þw¬8R¯‡®Â¯Á‰Â­°!©üjÂ¥-‘Ÿ«™ “¬‘hÁ¿~úÁ¼¶FÁ¸²-Á³SøÁ¬‰7Á¤QìÁšÊÁÁ1'Á„ó¶ÁsÁ_%ÁNÄœÁE?}ÁDŸ¾ÁMÊÁÁ_|îÁuÛ#Á…°!ÁxÕÁ‘bNÁ“n˜Á™ JÁª JÁΑhÂÅ¢Â0{ÂbNÙŠև¡dZ²MP¼ëÂÁùÛº^ÂÀbѻﶬ¯xR¨eã¡,‹Â™üjÂ’÷LÁÆXÁÄÁÀr°Á»ƒÁµ ÅÁ­IºÁ¤{Á™ÄœÁŽÒòÁƒùÛÁt\ÁfA‰Á`$ÝÁe+ÁvÌÍÁ‰Ý/Á›\Á¬ÌÍÁºÁÁ²ÁżjÁÌÙÁà—–‡Â)€Â[¬‹„©¬ÂÁwÏÂуÂÙLÍÂÚ­‘Âײ-ÂÑñ'Âʈ1ÂÂ8R¹ƒ°¿}¨$ZŸÔþ—å`ÁÍ1ÁË1'ÁȸÁîÁ½È´Á¶hsÁ­¥ãÁ£ÂÁ™9XÁŽ× Á…ƨÁ?}Á|Ÿ¾ÁƒÂÁ‘$ÝÁ¦Á¿‡+ÁÙ¬Áî¬Áü?}ÂËǼjÂ}ôÂ/ ÂY6FŠ+¬Ï\ÂλçÂèvÉÂö)üÂùC–ÂõbNÂí‹DÂã¦éÂØ×ÂÍÈ´ÂÂâN¸aË®ff¥œ33ÁÓn˜ÁÒ“ÁÏ\ÁË®ÁÆZÁ¿‹DÁ·ZÁ®%Á¤VÁšIºÁ‘ùÛÁŒå`ÁMÓÁ•›¦Á§‹DÁÂûçÁäå`Âå` ÂQìÂ&ÚÂ0„ÂAA‰Â_}ô‡߾©V‡ÂÑ)üÂ÷½ôà kãTà 2°Ã{Ã_;ÂôRòÂåò-ÂØ¬ÂËh¾èö³§ð©F%ŸµÃÁÙÁØ´9ÁÖ¾wÁÓvÉÁÎÈ´ÁȧðÁÁ+Á¸“uÁ¯bNÁ¦r°ÁŸ Á›C–Ár°Á¨záÁ¾¥ãÁà7LÂ1ÂÂ.È´Â>§ðÂK¡ËÂY©üÂnŸ¾Âˆ{d¢·LÂÆ¹ÛÂñöFÃ'mØ“à ²òÈöÃ@Åà ÀÅÃVFÂðîÂàŽVÂÑšÂÄ–·¯¬~w¢QhÁß+ÁÞçmÁ݉7ÁÚéyÁÖó¶ÁÑ™šÁÊ÷ÏÁÃKÇÁ»¬Á³KÇÁ­5?ÁªáHÁ®ùÛÁ¼™šÁÖffÁüïžÂ”{Â0KÇÂH¬Â\-Âmhs‡+‹úážX¹ÂÝ ÍÃ)î˜Ã)'Ã-‹…Ã( ÍÃkÇï\Ã–Âø§mÂæV‡ÂÕõÃÂÇSøÂº<î®|j£åãÁäZÁä¡ËÁãß;ÁáñªÁÞÂÁÚIºÁÔ£×ÁÎoÁÇ"ÑÁÀ´9Á¼7LÁ»´9ÁÁéyÁÒ Áî¶F [#Â&ŽVÂBɺÂ]“uÂt÷ÏÂ„ÓøÂs¶Âœ´¼Â¯-‘ÂȼjÂêþÃÔ{ÃÅÃ,ˆöÃ2'mÃ,÷Ã!¥ÃõÃñhÂü/Âèß;Â×ÅÂÈŸ;»)ü¯'ð¤cTÁé%Áé× Áé´9Áè~úÁæ"ÑÁ⟾ÁÞoÁØÄœÁÓA‰ÁÎvÉÁËÎÙÁÍZÁÕÆ¨Áè&é†%‰7Â4¾wÂR:^Ânµ?„²Â˜“›!˨¥`º?}ÂÑ]/Âîp!ÃjÃbÃ'LÃ->wÃ)”9ð!ÃÔ¼Ã2oÂû%ÂçàBÂÖß¾ÂÇÍÓºk…®{d£È1Áí&éÁîÁîûçÁîÁí ÁêƒÁç"ÑÁã33Áß?}ÁÜ9XÁÛ‡+Áß(öÁé²-ÁþÂ.Â%™šÂ@ýôÂ^¯Â{­‹ =— ¢È1¯ݲ¿èsÂÓë…Âìæ%ÃIºÃP!Ã!ŽÃ¥`ÃaçmÃròÂõe`Âã‚ÂÓdÝÂÄùX¸øÂ¬…¢Â¢ ÅÁð¼jÁò—Áó²-Áóó¶ÁóVÁñß;Áïº^Áí5?Áêß;Áé£×Áêß;Áðt¼ÁüÊÁ ;d¾wÂ0{ÂK =Âh1'‚dZ€›bѦÒò²øRÂÁøÂÑÔþÂå:^ÂúEÃZáÂNîÃô{ÓÃÄÝÂüìÂì6FÂÜYšÂͶFÂÀc×´SøÂ©jŸ‡®ÁóƨÁö¸Á÷ÐåÁøÊÁÁùVÁø£×Á÷º^Áö¡ËÁõéyÁön˜ÁùvÉÂ`BÂ;dÂr°Â"äZÂ8«ÂR¬Ân³3Â…¬Â‘¿}Â!˧և²¿}¾ÒòÂÌ„œÂÛ¼jÂë¥`ÂúŸ;Ã2-ÃZÃ2oÃTÂûbÑÂîs3Âà¿}ÂÓ9ÛÂÆbѺp!¯p!Â¥[#œ ÅÁöE¢Áù{ÁûXÁý%Áþ"ÑÁþÀƒÁÿ JÁÿX‡Â.†%ÂæfÂA‰Â”{Â*š Â?cTÂWñªÂrRò†¸Â’œ¢Ñ¦dݯøÕº¸ÂÅ&fÂÐó3ÂÜàBÂçËÇÂðBÂôéüÂõÂðÀƒÂéßÂß.˜ÂÔ9XÂÈÿ}¾³‰ºÂ©¶F å˜ Áø=qÁûzáÁþG®ÂPåÂG®ÂuÂÌÍœ¬Âž¸Â ¶Fµ?ÂjÂ!¦éÂ0þúÂDqªÂ["ÑÂsdZÂ…²ÂŽVšC–£ «O\³Ä¼šÂźáÂέ‘ÂÖ¬‹ÂÜÉ7Âà-‘Âà^5ÂÝe`Â×ÄœÂÐ;çÂÇ\¾_;µ¸Â¬£r-›DœÂ“–Áù¶FÁýVÂQìÂÍÓÂ%ãÂff¨öÂ{Âå` r°Â0!±'ž¸Â'œ¬Â6‡ÂGøÕÂ\ƒÂrNÙƒڠ±ªÂ–gðž(sÂ¥U¬cT³~úº™ÂÁ]/ÂÇG+ÂË»çÂÎ33ÂÎ[¦ÂÌ2-ÂÇýôÂÂ3¶Â»V‡Â³Ü)¬#T¤mœæé•«ÂŽÇ+Áú°!Áþ¬Â5?ÂøÕ¨öÂRòÂb + m‘‘hÂÖ¶FÂ!µ?Â,NÙÂ9Å¢ÂIöÉÂ\7LÂogm‰ƨ‘|î˜RožŠ=¤z^ªC–¯ܬµ Ó¹}ô¼É7¾–‡Â¾¯½ ͹ևµT{¯ݲ©Ç+£YœÌÍ–KDÂð¤Â‰ÍÓÁû5?Áÿ|îÂÐåÂÓøÂÐåÂÖ üî iyÂKÇÂæfÂŽV£×Â%‹DÂ/˜“Â;ð¤ÂJcTÂZ_;ÂjþúÂ{C–Â…-‹ïžÂ‘ò-—]/œl¡5?Â¥³¶Â©Ã­(ö¯£T°÷ϱ¯»ç­9Û©©yÂ¥F% JÁšï•aËÂÆ%Š7L„È1ÁûG®ÁÿÒòÂ%ãÂ]/›¦Âí‘ k…Â49ÂuÃÂffÂH´Â iyÂ(bÂ1r°Â<œ¬ÂI[#ÂW5?ÂezáÂsn˜Â€:ᆠŋgðÂ%㔂˜‰7œ7LŸuâ5¤¢Â¥¢Â¥%¤¢ƒÂŸ%`›”þ—z^Â’ÿ}ÂŽH1‰s¶Â„šÂš ÁúñªÁÿ°!Â6F™šÂ D š Â ZÂiyÂì‹Â\ 7Â"bÂ)VÂ1øÕÂ;õÃÂG²ÂS JÂ_@ƒÂk0!Âviy€W„ú^‰$ZÂŒî˜Â^¸Â“q'– ˜7Ï™·Lš|jšvF™Ÿ¾Â˜‰Â•®˜Â’Á‰ÂX“‹“øÂ‡bƒeãÂ~TþÂuÜ)Áú5?Áÿ¬Â+‹DÂ#× ß; ÎÙ Jµ?Âî˜ÂàBÂ"°!Â)€Â1]/Â:>wÂC÷ÏÂN=qÂX®ÂbæfÂl”{Âu†%Â}¨ö‚~wÂ…ÎÙˆÆ%‹aH•ÂSuˆ1‘#T‘šÂgðÂòÂ(sŠº^‡߾„¯Â@Â{KÇÂsæfÂlm‘Áù¬Áþ¬Â™šÂ5?Âéy Á‰Â ÏßÂ&éÂàB‡ÂèsÂ"n˜Â(¾wÂ/Û#Â7º^Â@33ÂI\ÂR%ÂZÎÙÂc-Âj÷ÏÂr¬ÂxŽVÂ~_;ÂքƒÂ…Þ5‡RoˆPbˆÍӈˆ-‡hÂ…wLƒnÂÂ|™šÂv±'ÂpqªÂi÷ÏÂc^5Á÷¬Áü¼jÂó¶Â²ÂaH JÁ gmÂÇ®Â}ôŸ¾Â@ƒÂ!r°Â'A‰Â-¬Â4¤ÝÂ< JÂC¸RÂKs¶ÂS 7ÂZKÇÂa“Âg]/Âm =Âr%ãÂv§ðÂzˆ1Â}»d€€í‘ÂTþÂJ=€ËD·LÂ}ÂybÂus¶ÂpɺÂk¯Âf=qÂ`PÂZ¶FÁmSøÁh¬Ác™šÁ^$ÝÁXn˜ÁR“uÁL¼jÁGoÁAÒòÁ=7LÁ9…Á6ùÛÁ5Û#Á6jÁ8Ý/Á=hsÁD$ÝÁM+ÁXr°Áeë…Áut¼ÁƒjÁŒÛ#Á–ùÛÁ¡“uÁ¬vÉÁ·vÉÁÂbNÁÍ =Á×C–ÁàãTÁéÊÁÁñÛ#ÁøýôÁÿ$ÝÂ"ÑÂ2-ÂÀƒÂÓøÂr°Â¦éÁpÔþÁk¶FÁf{Á`ÁY‘hÁRå`ÁL-ÁE™šÁ?hsÁ9Û#Á5;dÁ1Û#Á01Á0 JÁ2(öÁ6›¦Á=…ÁFýôÁS%ÁaPÁrffÁ‚²-Á JÁ˜33Á£å`Á¯ó¶Á¼$ÝÁÈ?}ÁÔbÁßbNÁê%ÁóÒòÁü§ðÂ49ƒÂ=q bN õàýô … •ÁtÝ/ÁoOßÁi¸ÁbbNÁ[33ÁS²-ÁL JÁDzáÁ=C–Á6¬Á1VÁ,ÀƒÁ*¬Á)|îÁ+/Á/p¤Á6záÁ@bNÁM&éÁ\ÀƒÁo Á× Á/Á™p¤Á¦ZÁ³°!ÁÁ33ÁΣ×ÁÛÂÁèOßÁô‡ÁþáHÂE¢Â{ç =Âë…Â"ѵ?¬ÂoÂõÃÁyÁsÁlÈ´ÁedZÁ]t¼ÁU‡ÁLzáÁCß;Á;PÁ3Û#Á-"ÑÁ'ÎÙÁ$A‰Á"å`Á$bÁ(“Á/+Á9p¤ÁFõÃÁW¡ËÁkOßÁ€áHÁC–Áš¶FÁ¨ñªÁ·²-Áư!ÁÕ¡ËÁä7LÁò(öÁÿ33ÂP ÙÂjÂ8RÂ@ƒÂ… PÂçmÂ!ËÂËÇÁ~ÌÍÁxffÁq+Ái&éÁ`r°ÁW33ÁM²ÁCïžÁ:vÉÁ1•Á)²-Á#?}Á°!Á~úÁVÁ ¼jÁ'ƨÁ2^5Á@‹DÁRIºÁghsÁ©üÁOßÁœ1Á«´9Á¼%Á̬ÁÝKÇÁíPÁýoÂŢ W Â"ÑÂÂ$ÝÂMÓ —Â" JÂ"¼jÂ"»dÂ"²Á‚hsÁ~bÁvZÁmº^ÁdIºÁZ-ÁO™šÁDÔþÁ:1'Á0{Á&õÃÁOßÁ®Á\ÁjÁ¡ËÁ \Á+\)Á:$ÝÁLÙÁc\)Á}p¤ÁSøÁjÁ®¥ãÁÀ´9ÁÓ7LÁåÄœÁ÷éyœ¬Â §ðÂéyÂA‰Â™šÂ#çmÂ')üÂ)l‹Â*¾wÂ+5?Â*èsÂ)ñªÁ…ÌÍÁ‚E¢Á|ffÁs;dÁi Á^(öÁRŸ¾ÁFÄœÁ:í‘Á/‘hÁ%/ÁQìÁ‰7ÁhsÁvÉÁ+ÁÛ#Á$ÀƒÁ3÷ÏÁG‰7Á_SøÁ{33Á\)Ážß;Á±ÎÙÁÅÎÙÁÚn˜Áï-¿} n˜ÂbNÂgmÂ#TþÂ){Â-š Â0ë…Â3Â42-Â4ZÂ3¬Â2G®Á‰•Á…ñªÁ´9Áy¾wÁnýôÁcG®ÁVÐåÁIçmÁ<í‘Á0VÁ$°!Á“uÁŸ¾Á xÕÁ ²-Á ƨÁ¬ÁñªÁ.r°ÁB§ðÁ[‘hÁy‡Ár°Á t¼Áµ?}ÁËl‹ÁâvÉÁù¾wÂIºÂ%ãÂ!ËÂ%üîÂ-‰7Â3¬Â8_;Â;¬Â=¨öÂ>t¼Â>49Â= DÂ;!ËÁƨÁŠbÁ…²-Á€©üÁv1Ái¡ËÁ\VÁNn˜Á@^5Á2›¦Á%ÂÁvÉÁdZÁ ?}Á›¦Á 1Áë…Á‹DÁ*“Á>°!ÁXn˜ÁwdZÁ²-Á¢C–Á¹{ÁѶFÁë‰7ÂâNÂÄœÂøÕÂ'¬Â0àBÂ9VÂ?‹DÂDXÂG…ÂI5?ÂI‘hÂHÇ®ÂG%ÂDzáÁ’^5ÁŽ£×ÁŠ1'Á…Á~MÓÁqOßÁcC–ÁTƒÁExÕÁ6¬Á(¼jÁbNÁQìÁ G®ÁçmÁ¸RÁ¬Á^5Á'¶FÁaHÂQ÷ÏÂb®ÂoöÉÂy©üÂïžÂŽÙÂÓuÂÂ~¡ËÂyí‘Ât?}ÂmàBÁ¨KÇÁ¥ JÁ ãTÁ›È´Á•¾wÁŽÒòÁ‡&éÁ}× ÁlÝ/Á\-ÁL§ðÁ?\)Á5?}Á/¸Á-p¤Á05?Á7 ÁAKÇÁNÌÍÁ`{ÁvéyÁ‹{Á ‹DÁ½|îÁâffÂDœÂÖÂ9@ƒÂQ¥ãÂg`BÂyJÁƒoˆ JŠ©ü‹\‹ 7‰dZ†äZƒĜ€5?Âx½qÁ®n˜Á«r°Á§…Á¢²Áœ¼jÁ•ë…ÁŽQìÁ†&éÁ{|îÁkVÁ\¬ÁOÎÙÁGG®ÁChsÁD“uÁJzáÁT9XÁ`¬ÁooÁïžÁŠÄœÁ™÷ÏÁ¯õÃÁϬÁøZÂbNÂ1®ÂNÍÓÂj>w€ô¼ÂŠDÂØ”Ö–b–ožÂ”ٚ’+ÂŽ±'Ь†NVÂÀÁ´²-Á²%Á®dZÁ©ÂÁ¤ Á~úÁ–oÁŽoÁ…Ý/Á{ãTÁmß;ÁcoÁ\ÙÁ\=qÁa‘hÁlIºÁzÙÁ…²-ÁŽ?}Á—9XÁ¢Á±IºÁÈXÁêp¤Â €Â)s¶ÂJ\Âk;dÂ„ÓøÂ‘\¬Âšå gð£>w£ž5¢þŸ!Ë›/–‘h‘‰ºÂŒJ=†øRÁ» Á¸²-ÁµjÁ±¬Á«Æ¨Á¥t¼ÁžMÓÁ–•Áް!Á‡1'Á€ÎÙÁx¼jÁuhsÁxí‘ÁÝ/ÁŠzáÁ•?}Á Æ¨Á«ñªÁ¶´9Á¡ËÁÓVÁì9X 1'Â#Á‰ÂEšÂj‘hˆ ˜ˆ´Â¥KÇ­»d²¬Â³$ݱŸ¾Â®D©¦é¤:^žT{˜3¶Â’œÂ‹çðÁÁIºÁ¿`BÁ¼Á¸—Á³£×Á­´9Á¦ë…ÁŸ“uÁ˜¬Á‘$ÝÁ‹ƒÁˆ/Áˆ-ÁŒSøÁ”÷ÏÁ¡›¦Á°çmÁÀ÷ÏÁÐ7LÁÞOßÁìùÛ JÂhsÂ$.ÂB ÅÂhð¤Â‰Ü)žÄ°Rò¼¯žÂÄÂÅ›#ÂÄ ÅÂÀ,‹Âºœ¬Â´ò­ Â¥»džu?—RòÂmÁÇr°ÁÅ÷ÏÁÉ7ÁÀ‡Á»—Á¶¸Á¯ÎÙÁ¨ó¶Á¢1Á›¶FÁ–í‘Á”ÎÙÁ–“uÁOßÁ©Áº²-ÁÏMÓÁäùÛÁù¡ËÂNÙÂÔþÂŽVÂ,ffÂE`BÂh+‰Á¡á˸ó3ÂË@ÂÖ“uÂÚþúÂÚ¨ÂÕl‹ÂΜ)ÂÆ‘ì½ó3µ+…¬}ô¤þœ1”cTÁÍ`BÁÌ\)ÁÊjÁÇxÕÁÃÁ¾“uÁ¸ÔþÁ²—Á¬SøÁ¦Æ¨Á¢ó¶Á¢ ÅÁ¥¶FÁ¯ =Á¾ÙÁÔ¾wÁîùÛÂffÂÒòÂE¢Â+—Â:VÂMÂÂiüîˆ@ E¢ÂºÙÂÓàBÂæ¸RÂð±'ÂòG+ÂíÖ‡ÂåÑhÂÛùÛÂÑeãÂÆ¶F¼F%²G+¨ÒoŸñªÂ—¥`ÁÓbÁÒ‡+ÁÑ ÁζFÁËXÁÇ JÁÁûçÁ¼xÕÁ·Á²bNÁ¯§ðÁ°5?Áµ¥ãÁÁÁÔ¾wÁï“Â]/ÂIºÂ(ØÂ8ffÂG»dÂY‡ÂoŒJ‡7L›ÍÓµB ÂÑ_¾Âë½ôÂÿ ÃïžÃu?Âÿ7LÂóô¼ÂçH´ÂÚbNÂÍØ“ÂÁô9¶Óu¬}ô¢î˜ÂšÁØjÁØ`BÁ×|îÁÕ²-ÁÒûçÁÏffÁ˸ÁÆxÕÁÁ÷ÏÁ¾jÁ¼ïžÁ¾ýôÁÆE¢ÁÔ|îÁê¾wÂs¶ÂŒJÂ*VÂ=`BÂOÂÂaÜ)ÂuÁ‰Â‡'m—Rò¬G+ÂÅÑhÂáð!ÂüoÃëà Bà äÝÃçðÂþ$ZÂïUÂà®ÂÒ ÂÅËD¹Ø®áˤØ›¥ãÁÝ`BÁÝÔþÁ݃ÁÜXÁÚVÁ׋DÁÔ$ÝÁÐzáÁÍoÁÊÂÁÊ©üÁÎMÓÁ×jÁç¾wÂ^5ÂGž¸ÂQVÂZcTÂc]/ÂkÏßÂs¤ÝÂzËÇ€¨öƒ–†'mˆQhŠ¨Â‹6É‹Ôþ‹Ù‹@ƒÂŠhˆV‡Â†!Hƒ…€— ÂzØÂt,ÂmJÁÂfOßÁóïžÁøÐåÁýÎÙÂyÛÂ)ü o j¾ÂH´ÂûçÂLÍÂ%G®Â+î˜Â35?Â:ûçÂC“ÂKQìÂSr°Â[H´Âb®ÂiPÂoÓøÂuˆ1Âzœ¬ÂÂYšÂ‚ȴƒŢ„G®Â„H´ÂƒÇ®Â‚È1ÂSuÂ~éyÂzwÏÂup¤Âoó¶Âj ÅÂdoÂ]àBÁò¾wÁ÷¬Áü¼jÂûç¸Rš Â ±' =µ?ÂÂÂC–ÂBÂ#ɺÂ)ÔþÂ0YÂ7;dÂ>YÂE‰7ÂL¡ËÂSzáÂYõÃÂ_þúÂeƒÂjƒÂnñªÂrÂÂuë…Âx]/Âz1ÂzáHÂzß;ÂzÂxQìÂuØÂr¦éÂn× Âj~úÂeº^Â`Ÿ¾Â[G®ÂUÅ¢Áo¥ãÁkÂÁg‰7Ác =Á^^5ÁY²ÁTõÃÁP‡+ÁL‡+ÁI&éÁFŸ¾ÁE&éÁDýôÁFQìÁISøÁN(öÁTí‘Á]®ÁhffÁu =Áº^Á‰ÀƒÁ’p¤Á›º^Á¥p¤Á¯l‹Á¹~úÁÃÁÍE¢ÁÖ§ðÁß~úÁç°!Áï¬Áõ´9ÁûdZÂuÂüîÂp¤Âr°Â 7ÂvÉÁ=/Á=®Á@9XÁDýôÁL(öÁUÎÙÁaïžÁp~úÁ€°!ÁŠ+Á”‰7ÁŸ´9Á«r°Á·“uÁÃÛ#ÁÐbÁÛýôÁçhsÁò¸ÁûõÃÂdZÂ>w  'ðÂ49©ü‘hÂó¶ÂÝ/Á{¡ËÁvŸ¾Áq%Ájí‘Ádn˜Á]¥ãÁVÄœÁPÁI•ÁCÎÙÁ>ýôÁ;p¤Á9…Á9Á;¶FÁ@bNÁG®ÁQ¾wÁ^“uÁn ÅÁ€"ÑÁŠjÁ•´9Á¡ë…Á®ÒòÁ¼/ÁÉÀƒÁ×C–Áät¼ÁñoÁüß;ÂÔþ¢ѠËÇÂC– = ÅÂPÂ[#•ÂJÁÁ€^5Á{dZÁu`BÁnÄœÁg¥ãÁ`-ÁX‡+ÁPéyÁI²ÁBñªÁ=?}Á8å`Á6=qÁ5©üÁ7|îÁ<ÁCdZÁMÎÙÁ[KÇÁk× ÁOßÁоwÁ—Á¤XÁ²ÁÁ9XÁÐ9XÁß1'ÁíÎÙÁûÂÂdZ NÙ‰7±'“u¬Â­²-Â'ðÁƒ;dÁ€jÁzn˜ÁsSøÁk¥ãÁc|îÁ[oÁR›¦ÁJn˜ÁBÙÁ<=qÁ7%Á3²Á2jÁ3ÊÁÁ8{Á?ÁJ=qÁXZÁi× Á~—Á‹7LÁ˜|îÁ§1Á¶\ÁÆÊÁÁ×bNÁçûçÁø33ÂÔþ ÂÂ/ÂûçÂÝ/Â"ÒòÂ$ãTÂ&¦Â&\Â&PåÂ%vÉÁ†p¤Áƒ~úÁ€ ÅÁx¸RÁp~úÁg²-Á^‡+ÁUC–ÁL1'ÁC²-Á<-Á6“Á1çmÁ0bÁ0õÃÁ4ùÛÁ<^5ÁGXÁUûçÁhZÁ~ZÁ‹í‘Áš=qÁªbÁ»{ÁÌùÛÁß\)ÁñÎÙÂê ~úÂm‘Š=²-Â$ÐåÂ(Þ5Â+Ü)Â-ÖÂ.Ý/Â/ 7Â.t¼Â-9XÁ‰ýôÁ†õÃÁƒt¼Á ÁvIºÁlå`ÁcVÁXýôÁO‡ÁE¶FÁ=OßÁ6ffÁ1p¤Á.ñªÁ/\)Á3VÁ:^5ÁEÁT›¦Ágº^Á~å`Á ÁœdZÁ­PÁÀ1'ÁÓñªÁèZÁüãTÂ{çÂÂƨÂ"ŽVÂ)33Â. ÅÂ2ÍÓÂ5ÖÂ7‘hÂ8QìÂ8!ËÂ7 ÅÂ5n˜Áå`ÁŠÐåÁ‡7LÁƒ¬Á} Ás33Áh¼jÁ]ûçÁSKÇÁI¸Á?ë…Á85?Á2\Á/|îÁ/p¤Á2Ý/Á:bÁEG®ÁT¸RÁhzáÁ€SøÁާðÁŸ Á±°!ÁƇÁÛë…ÁòŸ¾ÂƨÂûç”{Â$?}Â,»dÂ3Ü)Â9ŒJÂ=Ç®Â@œ¬ÂB$ÝÂB‚ ÂAÚÂ@RòÂ>uÁ’&éÁbÁ‹jÁ‡5?Á‚|îÁz§ðÁo©üÁdQìÁXùÛÁN¬ÁD9XÁ;ãTÁ5®Á2$ÝÁ1ƨÁ4ýôÁ<¬ÁG`BÁW%Ák?}Á‚"ÑÁ‘&éÁ¢©üÁ¶º^ÁÍoÁå=qÁþ‘h ¬Â¤ÝÂ$n˜Â/{Â8H´Â?Ü)ÂEº^ÂIçmÂLzáÂMš ÂMqªÂL1'ÂJ%ÂG¸Á–ÀƒÁ“´9Á JÁ‹ÊÁÁ†÷ÏÁ§ðÁwïžÁl ÅÁ`E¢ÁTáHÁJƒÁA¾wÁ;33Á7p¤Á6ùÛÁ:-ÁASøÁL°!Á\záÁpýôÁ…SøÁ”ó¶Á§záÁ½¸ÁÕ—ÁðhsÂ^5ÂÄœÂ"ËÇÂ/å`Â;’oÂEyÛÂMiyÂSSøÂWH´ÂYn˜ÂYøÕÂY ÅÂW ÅÂT0!ÂP„Á›©üÁ˜´9Á•“ÁÙÁ‹ýôÁ†™šÁ€È´Áut¼ÁiG®Á]‘hÁRñªÁJ1ÁC|îÁ?ãTÁ?²-ÁC;dÁJ´9ÁVMÓÁf=qÁzñªÁŠ…Áš¬Á®5?ÁÅÁàZÁþ/ÂûçÂ+Â.àBÂ=`BÂJÂTš Â\¾wÂbÂfÂg‚ Âg@ƒÂe†%Âb›¦Â^ÀƒÂZ1'Á Ý/Áž =Áš‰7Á–ZÁ‘‡+ÁŒ¸Á†E¢Á€(öÁtÁh=qÁ]©üÁTýôÁNáHÁKïžÁL\ÁPùÛÁYC–ÁexÕÁuƨÁ…VÁ’\Á£+Á·º^ÁÐÒòÁîXÂÑì±'Â+æfÂ=p¤ÂMe`Â[\Âf Ân“ÂsgmÂv,Âv·LÂue`Âr\ÂnŠ=Âi²Âd DÁ¦KÇÁ£©üÁ QìÁœC–Á—‰7Á’5?ÁŒffÁ†SøÁ€=qÁtéyÁj¼jÁb°!Á]PÁ[ß;Á^ JÁd ÅÁmûçÁ{p¤Á†IºÁýôÁžp¤Á¯‘hÁÅ=qÁà^5Âzá¸Â'A‰Â;µ?ÂO1'Â`PÂnøÕÂz1€ևƒ\ƒß;ƒ~w‚'m€ÙÂzÊÁÂt¥ãÂmò°Á«ë…Á©ƒÁ¦dZÁ¢‰7ÁùÛÁ˜ÊÁÁ“¸Á1'Á‡E¢Á¾wÁz JÁs Áo|îÁoÒòÁtffÁ}"ÑÁ„ÊÁÁŒ¥ãÁ–bÁ¡VÁ¯IºÁÁ$ÝÁØ5?Áõ¼j ó¶Â!ãTÂ8’oÂOwÏÂdèsÂwzáƒ#TˆxÕ‹ÌÍÂSuÂSuÂŒ‰çð‡ƒÂƒ— ¬Âw½qÁ±§ðÁ¯‹DÁ¬°!Á©{Á¤ÂÁŸÎÙÁš^5Á”¬Á JÁ‰çmÁ…º^ÁƒÁ‚A‰ÁƒÌÍÁ‡Æ¨ÁŽ%Á–/ÁŸÒòÁª¸RÁ·(öÁÆ ÁÙ(öÁò{ G®ÂxÕÂ51ÂNŠ=ÂgýôÂE¢Â‰W ¢N•m—çð˜iy—SøÂ•%‘ÑìÂüj‰»çÂ…wÂMÈ´ÂiçmÂ…Ro–®˜Â§h´wϽb®˜ÂÀ@ƒÂ»¿}µì‹Â¯Tþ¨]/¡H´ÂšD“m‘ÂŒ× ÁÈp¤ÁÇÐåÁÆ~úÁÄvÉÁÁÂÁ¾vÉÁºÆ¨Á·Á³‘hÁ±‡Á°VÁ²/Á·‰7ÁÁ"ÑÁÏSøÁáÊÁÁ÷‘h¨öÂô¼Â ‘hÂ.Â=Ç®ÂQ6FÂiøÕ„D•ñ'¨‹D¹ÑhÂÇe`ÂÏÆ%ÂÒÏ\ÂÑkÂÌã×ÂÆe`¾ÍÓ¶´9®z^¦\¬Âž€ƒÂ–ú^ÂÔþÁÍÄœÁÍ“uÁ̺^ÁË5?ÁÉ JÁÆXÁÃMÓÁÀ;dÁ½—Á¼1Á¼^5Á¿PÁÆ™šÁÒ\)ÁãC–Áù% OßÂE¢Â%¹XÂ4záÂDoÂU¼jÂk‚Á‰Â’Ý/Â¥U¸§mÂÊgmÂ×öÉÂß BÂáEÂÞbÂ×›¦ÂÏMPÂÆ B¼±ªÂ³`Bª`B¡ÎÙ™·ÏÂ’¸ÁÒÐåÁÓ{ÁÒº^ÁÑÀƒÁÐ/ÁÎ"ÑÁËÎÙÁɇ+ÁÇÈ´ÁÇ9XÁȶFÁÍE¢ÁÕ÷ÏÁã¼jÁ÷oÂÝ/ÂRòÂ& Â6xÕÂG$ÝÂXbÂkÛ#Â8RÂŽíŸF¨Â±ÌÍÂÅVÂÖ©üÂãñªÂë%Âë­Âç(sÂßH´ÂÕ¡ËÂËF%ÂÀڠ¶»d­ ¤›„œÂ“š Á׉7ÁØC–ÁØl‹ÁØÁ×{ÁÕ¼jÁÔ1'ÁÒÈ´ÁÒÁÒ…ÁÕ9XÁÛ&éÁåhsÁôñªÂ&é ÅÂ"_;Â3\ÂEiyÂWbÂjVÂ~±'Ší˜— ¨†%ºMPÂÌ¡HÂÝ[¦Âé÷LÂðŒJÂð·LÂë²ÂãÂØÆ¨ÂÍÑhÂÂâN¸V®Z Â¥ œOß”<îÁÛå`ÁÝ{ÁÝÂÁÝïžÁÝ©üÁÝbÁÜZÁÛÝ/ÁÜ ÁÝÀƒÁá®Áèí‘Áô•ÂÍÓÂ@ƒÂ‰7Â- ÅÂ?9XÂRÂeÂxŸ¾Â†¯Â’(sŸMP®=q¾˜ÂÏB ÂÞiüÂéâNÂïêÂðÂë JÂâ¯žÂØ|jÂÍ”{¨s¸#®5¤Åœò”ÁßÝ/ÁáÁâ´9ÁãxÕÁãß;Áä =Áä/Áä¥ãÁåïžÁè´9ÁíÒòÁöIºÂ’o ¦éœ¬Â%[#Â6]/ÂHÜ)Â\ DÂoqªÂP‹ÊÁ–ÏߣÙ°™¿ÂÍ¡HÂÚÁÂä·LÂêßÂêF¨ÂåöFÂÞiyÂÔùXÂʲ°ÂÀF¨Â¶²Â¬ožÂ£Vš×Â’ò-ÁãhsÁå|îÁç33Áè\Áé£×Áê“uÁë“uÁíÁïQìÁó-ÁùffÂvÉÂ^5ÂÓøÂ JÂ,éyÂ=ïžÂP]/Âcm‘Âvœ¬Â„ì‹ÂŽÀ™ ͤ(ö°¼‘hÂÈ× ÂÓÊÁÂÜ#Âà¬Âá1ÂÝ‹DÂ× BÂÎ× ÂÅ— ¼®Â²’ò©vF Òò˜´¼Â‘5Áæ…Áé%Áë;dÁí+ÁîéyÁð—Áòr°ÁôÊÁÁø“Áü÷χÂIºÂˆ1Â/Â$jÂ3 ÂCɺÂUÁ‰ÂhC–ÂzǮ†‘ìÂÈ1™2°Â£ì­`Å·߾ÂÁþúÂÊçmÂÑ¥`ÂÕk…ÂÕÜ)ÂÓ&fÂÍåãÂÆâѾضX“­ɺ¥l‹Âeã•ɺŽž¸Áé/Áì‡ÁîÄœÁñA‰Áó¡ËÁö =Áø²-Áûë…ÂoÂöÉÂûç †%Â÷Ï¡ËÂ)§ðÂ7æfÂGð¤ÂY²Âjº^Â|;d†´¼Â.—¤Z G®Â©V±ÅºÂÁ#TÂÆƒÂÉŽÙÂÉÿ}ÂÇêÂò°Â½å`·寮˜Â¨ Â “øÂ™B Â’=q‹‘hÁëffÁî®ÁñÌÍÁôÌÍÁ÷ƨÁúÛ#ÁþC–Â$Ý©üÂó¶Â P圬Â""ÑÂ-ÂÂ;YÂJÂZ ÅÂkuÂ{TþÂ…‘hÂ@”Öœ?}£©yªؓ±~ú·-‘»m½ؓ¾|îÂKiyÂX÷ÏÂf©üÂt€zᆛ#ÂŒj‘øÕ—=ôœ"Ñ ~ú¤²Â¦ÄœÂ¨E¢Â¨„§}Â¥Pb¢"Nž,™¤Ý”¾ú¦fŠ{dÂ…W€KÇÁïjÁó•Á÷ÄœÁü%Â7LÂbÂ#×Â\ t¼Â‚ Âe`ÂOßÂ!l‹Â)ÓøÂ3†%Â>_;ÂJÂVIºÂb\ÂnŒJÂz‚m‘‡ƒ–ÂŒO\ÂÇ+”Ú˜l›WÂuÞ¦fžÔ{Âÿ}œ6F™—–IºÂ’uÃÂŽD‰×Â…LJ€º^ÂxdZÁïå`ÁôG®Áø¸RÁýG®ÂÂPÂPå k… ùÛ ÅÂ+ÂÒòÂ" ÅÂ*‚ Â3p¤Â=IºÂGÐåÂR³3Â]›¦Âh=qÂrdZÂ{õÂn˜Â†•ŠdÝÂÐåÂÅ“'ð”Ý/•Ïß•ñªÂ•@ƒÂ“Ç+‘šÂŽÕ‹—‡þú„(ö€-Âx?}Âp"ÑÁïûçÁô‰7Áù/ÁýùÛÂ~úÂ,Â{ NÙ ô¼Â#×Âúá”{Â#%Â*YÂ2ƒÂ;dZÂDɺÂNqªÂX‡ÂazáÂjp¤ÂrÝ/Âz«€ð¤Â„6F‡/‰–‹ŽÙÂŒô¼Â¸ÕÂÐåÂwÂZ…ÂbiyÂiÓøÂp¬ÂvõÃÂ|ž¸Â€ÊÁ‚áË„ˆ´Â…±'†Qì†cTÂ…å`„Ü)ƒRoÂW Â}÷ÏÂx£×ÂrÚÂl¹XÂfaHÂ_êÁï%ÁóÊÁÁø°!ÁýÄœÂPÂaHÂm‘ ¾wÂhsÂzáÂ+ Â!¿}Â'ó¶Â.«Â5ÎÙÂ=:^ÂDÄœÂLA‰ÂS‹DÂZ~úÂaÂg 7Âl‰7Âqt¼Âu»dÂyNÙÂ| Â~V“Â33Â~[#Â|˜“ÂyùÛÂv—ÂrŠ=Âmî˜ÂháHÂc~úÂ]àBÂX¦Áî1Áò× Á÷ÊÁÁüïžÂ(öÂÂb ]/ öÉÂéyÂB D G®Â%ô¼Â,%Â2hsÂ8þúÂ?¨öÂFC–ÂL®ÂRÎÙÂXŽVÂ]ÙÂb­Âf÷ÏÂj®ÂmÖÂp(öÂqÐåÂr±'ÂrÅ¢Âr DÂp‰7ÂnJÁÂkaHÂgàBÂcß;Â_s¶ÂZµ?ÂU¸RÂP‘hÁqó¶ÁnÄœÁkXÁg¶FÁcûçÁ`=qÁ\£×ÁYKÇÁVbNÁT“ÁR—ÁRbÁR´9ÁT°!ÁX$ÝÁ]7LÁcûçÁlvÉÁv¬ÁE¢ÁˆÁl‹Á—l‹ÁŸõÃÁ¨Ý/Á²Á»7LÁÄ^5ÁÍMÓÁÕå`ÁÞÁåÁìQìÁò`BÁ÷²Áü Áÿ‹D¸Â\œ¬ÂÌÍÁup¤Áqó¶Án ÅÁj{ÁeÛ#Áa™šÁ]l‹ÁYÁVÁS"ÑÁQ ÁP ÅÁPffÁR$ÝÁUÁZ£×Áa©üÁj›¦Áu|îÁ¬Áˆ`BÁn˜Á™&éÁ¢záÁ¬=qÁ¶E¢ÁÀhsÁÊxÕÁÔMÓÁݺ^Á曦ÁîÌÍÁö1'Áü¸RÂ'ðÂwÏÂMÓ¨öÂb 7¬Áy`BÁu‘hÁq`BÁláHÁh-Ác\)Á^›¦ÁZ{ÁUó¶ÁRzáÁOãTÁNbNÁNA‰ÁO¶FÁRñªÁX ÅÁ_dZÁhÈ´ÁtVÁ€ýôÁˆÐåÁ‘‹DÁ›1Á¥9XÁ¯éyÁºí‘ÁÆoÁÑ&éÁÛ÷ÏÁæQìÁð =Áøùۀ Âûç iy JÁ £× {ç Ù ƨÁ}ÊÁÁy®Áu"ÑÁp5?Ák Áe©üÁ`MÓÁ["ÑÁV^5ÁRA‰ÁO =ÁM ÁLn˜ÁMPÁPŸ¾ÁUÎÙÁ]KÇÁg¸Ás\)Á€õÃÁ‰^5Á’ÎÙÁ¬Á¨;dÁ³ïžÁÀ%ÁÌIºÁØzáÁäbNÁïÂÁújÂ{Âl‹Â 1' YÂàBÂɺÂ“ÂØÂhÂÐåÁ^5Á~ZÁyxÕÁt$ÝÁnvÉÁh\Áb›¦Á\ÌÍÁW`BÁR›¦ÁNÀƒÁL(öÁK‡ÁKÛ#ÁN´9ÁSãTÁ[PÁeÎÙÁr´9Á ÁЬÁ”IºÁŸvÉÁ«‘hÁ¸^5ÁÅ¥ãÁÓ"ÑÁà“uÁí°!Áú33ÂïžÂ?} ò°ÂùÛÂMÓÂêÂÓøÂh®·LÂØÂB|îÂDÄœÂEɺÂE°!ÂD²ÂBº^Â@)üÁ–n˜Á”Á‘“Á¾wÁ‰ýôÁ…éyÁŸ¾Áz‡+ÁrÁj ÅÁcOßÁ^{ÁZå`ÁZ1'Á\bNÁaÂÁj—Áw‡Áƒ¾wÁŽ ÁšxÕÁ©IºÁºp¤ÁÎ%Áã¾wÁû$Ý Ĝ DÂ!ïžÂ-Â6àBÂ?E¢ÂF =ÂK¸ÂNŽVÂPs¶ÂP÷ÏÂPG®ÂNbÂL ÂHÇ®ÁšûçÁ˜£×Á•ÊÁÁ’xÕÁޏRÁŠŸ¾Á†IºÁÝ/Á{ Ás"ÑÁlQìÁg33Ád=qÁcë…Áf—Ál‹DÁvÁ“uÁЬÁ”ÄœÁ¡Æ¨Á±\)Áã×ÁØÌÍÁð‹DÂ,°! JÁÂ-gmÂ9{çÂDÂLå`ÂSÄœÂX®Â[¹XÂ]\Â\å`Â[t¼ÂXõÃÂUž¸ÂQž¸ÁŸÈ´Á‘hÁšÔþÁ—™šÁ“éyÁÙÁ‹‰7Á‡"ÑÁ‚Û#Á}ãTÁwXÁr›¦Áp=qÁp°!ÁtE¢Á{?}Á‚Ý/Á‰í‘Á’í‘ÁžbÁ«§ðÁ¼oÁÏ“uÁær°Â9XÂxÕÂuÃÂ,„Â:ë…ÂHÂS>wÂ\PåÂcÂgš ÂjÂj‘hÂi„Âg%ãÂc¸RÂ_wÏÂZ™šÁ¤ÌÍÁ¢ÂÁ -Á{Á™ƒÁ•\Á‘ZÁbÁˆë…Á…33Á‚1'Á€33Á =Á€\)Á‚ãTÁ‡+Á5?Á•Áž²-Áª|îÁ¸ÌÍÁÊ/ÁßVÁ÷ß; 2-Âô¼Â*‘hÂ;0!ÂJèsÂXì‹Âd¢ÑÂm¹XÂt¦ÂwêÂyhsÂxæfÂv»dÂs=qÂn·LÂin˜Âc™šÁ©ùÛÁ¨&éÁ¥È´Á¢áHÁŸ~úÁ›¸RÁ—°!Á“™šÁ²-ÁŒIºÁ‰²-ÁˆC–ÁˆMÓÁŠ =Á²Á“1Áš=qÁ£+Á­Û#Áº•ÁÉáHÁÜt¼Áòó¶Âþú±'Â(!ËÂ:ƒÂLÖÂ]ÄœÂlPÂxvÉ€›¦Âƒj„Ç+„ãTƒô9‚0!ÂbÂyËÇÂs\)Âl{çÁ¯C–Á­²-Á«•Á¨í‘Á¥ÊÁÁ¢A‰Áž|îÁš°!Á— ÅÁ”&éÁ’¸Á‘l‹Á’hsÁ•OßÁšE¢Á¡9XÁª1Á´ƒÁÀ¬ÁÎÀƒÁßhsÁó‹DÂÂÐåÂ& ÅÂ9jÂM®Âa•Âs¿}„œÂ‡bN‹]²ÂŽVÂŽ(öÂqªÂ‹­‰ Â…ñ'‚^¸Â}bÂuÁ´›¦Á³XÁ±…Á¯+Á¬VÁ©¸Á¥®Á¢A‰ÁŸ"ÑÁœ²-Á›\)Á›\Á°!Á¢%Á¨°!Á±‘hÁ¼l‹ÁÈ÷ÏÁדÁçVÁù‘hÂÛ#ÂH´Â%•Â8®ÂMò°Âd'ðÂy¦é†bÑÂŽ Â“¤Z–øR˜IºÂ—ès–.˜Â“oÂó3‹õǦfƒ)yÂ}6FÁ¹õÃÁ¹Á·‰7Áµ‡+Á³ JÁ°7LÁ­/Áª5?Á§Ÿ¾Á¥ÒòÁ¥KÇÁ¦…Á©ó¶Á¯í‘Á¸\ÁöFÁÑ1Áà¬Áð¾wÂŽV þúÂPåÂ'#×Â9uÂN PÂeXÂ}t¼ÂŠ49” Â›±' §ð£ì£G+¡¶ÉžÒošüj–„œÂ‘¨sÂŒ— ‡r°Â‚T{Á¿=qÁ¾§ðÁ½PÁ»ïžÁ¹ß;Á·xÕÁ´ë…Á²xÕÁ°~úÁ¯l‹Á¯È´Á²"ÑÁ¶ýôÁ¾¾wÁɇ+Á×-ÁçA‰Áù=qÂcTÂÂØÂ*–‡Â:ì‹ÂNˆ1ÂeYÂ~ˆ1ÂŒ/˜C–¢X“©²Â­ËǯšÂ®%«&f§ ¢ 7œb–Ö‘+‹BÂ…/ÁÄbNÁÄ-ÁÃxÕÁÂIºÁÀ®Á¾Æ¨Á¼ÄœÁºë…Á¹²Á¹XÁº¬Á¾33Áć+Á·ÁÛoÁëG®Áþ9X  ÅÂó¶Â!šÂ.qªÂ=¨öÂOwÏÂd˜“Â|öÉ‹և™höÂ¥æé°‰Â¶ÓøÂº Bº>w·Ù³§ð®I7¨7Ï¡ÌÍ›E”É7ÂŽt¼ÂˆXÁÉ^5ÁÉ\ÁÉIºÁÈ‘hÁÇvÉÁƬÁIJ-ÁÃÁÂ÷ÏÁÃPÁÅãTÁÊ¡ËÁÒn˜ÁÝÆ¨ÁìãTÁÿ“u ¤Ý£×Â#|îÂ1%ãÂ?ïžÂP„Âc”{ÂyÛ#‰ B—lÂ¥SøÂ±öF»ë…ÂÂw¦ žÊÁ—½ôÂò-Št9ÁθÁκ^ÁÎçmÁήÁθÁÍZÁÌ—ÁÌ ÅÁÌbNÁÍãTÁÑC–Á×7LÁàl‹Áíl‹ÁþvÉ ­ÂÁ‰Â#\Â1?}Â@9XÂP>wÂaäZÂuÌ͆Su“+… ùÛ®Ǯ»4¼ÂÄÓøÂÊ£TÂÌcTÂÊ‘hÂÆ\¿Ê=¸ƒ–°ƨ¨ïžÂ¡7Ï™Á‰Â’ B‹Ü)ÁÒ™šÁÓŸ¾ÁÔC–ÁÔPÁÔ\ÁÔl‹ÁÔZÁÔ©üÁÕÂÁØ33ÁܲÁã¼jÁî?}Áü¶F¯Â+ {Â.iyÂ=¤ÝÂM²Â^ÂpËÇ‚‚ÂâÑšvɧÐbµ =ÂÀÞ5ÂÉïÂÏ>úÂЄœÂÎ5ÃÂÉ4¼ÂÂs¶Âº»d²™šÂªl‹Â¢nš½ô“nÂŒ…¢ÁÖÄœÁØ5?ÁÙQìÁÚ ÅÁÚ¸RÁÛ=qÁÛãTÁÜûçÁÞó¶ÁâSøÁçÄœÁï÷ÏÁû¡Ë¥㛦š Â)SøÂ8YÂH?}ÂXÏßÂj#×Â|—ˆH1“H1Ÿ6É«°¤Â·ë…ÂÂÈ´ÂËòÂÏݲÂÐÛ#ÂÎlÂÉ\)‘hºÎV²¢Nªk¢cTš¬‹Â“XÂŒmÁÚ—ÁÜr°ÁÞ%Áß\)Áà‹DÁá¶FÁã“ÁäýôÁçÐåÁì¬Áò~úÁû¬Â$Ý ožÂÒòÂ#6FÂ1KÇÂ@£×ÂPÏßÂaPÂrÝ/‚~úÂŒ¦Â–vF¡uì÷³¶ÂÁYÂȯžÂÌìÂÍÖÂËyXÂÆ¶ÉÂÀD¸Ôþ°ñ'¨öÉ¡"N™–Â’e`‹˜“ÁÞ =ÁàKÇÁâSøÁä1'ÁåõÃÁçÈ´ÁéáHÁì\Áð9XÁõ`BÁüŸ¾ÂMÓ úá“uÂ0!Â)·LÂ7Û#ÂG-ÂW?}ÂgÖÂx§ðÂ…®ÂŽh—–‡Â¡{d«uôú^½JÁÂÙÂÇB ÂÈÂÆÂÁ޻­»ç¦8RžǮ—ߦfŠÁá“Áã¼jÁæ5?Áè“uÁêéyÁí`BÁð+Áó—Áø%ÁýõÃÂøÕÂJÁÂ8RÂ÷ÏÂ"›¦Â/1Â<ó¶ÂKó¶Â[–‡ÂkŒJÂ{°!†®ÂŽ]²Â–ô9Ÿ¯žÂ¨Ro°n·ožÂ¼º^¿ÑìÂÀ|j¾Òo»0!¶o¯øR©NV¢gð›€Â”¼jÂŽ5?‡÷ÏÁã¾wÁæÀƒÁé£×ÁìzáÁï\)Áòl‹ÁõÝ/ÁùûçÁÿ ÅÂÞ5Â+ ¹XÂɺ‰7Â'%Â3#×Â@š ÂOÂ]öÉÂmšÂ|@ƒÂ…²°ÂDœÂ”çðœ‰Â£àŪ¯žÂ°€Â´Þ¸Â·o¸¶§m³š¯8Õ©æé£þwÂÉ7—}ô‘B‹1'Â…XÁåûçÁéQìÁ왚ÁïãTÁóC–ÁöáHÁúë…Áÿ§ðµ?ÂLÍ Ôþ‰7 Š?}Â*n˜Â6hÂBâNÂP„Â^bÂl±'Âz´9„C–‹Ù‘Ǯ˜V‡Âž“øÂ¤?}©´Â¬›¦Â®´¼Â¯1'®«P§Ù£F¨Âž5˜²Â’öFÂL͇ºá‚PåÁçÌÍÁër°Áï{ÁòÂÁö—Áú´9ÁÿE¢ÂF¨Âiy ;d ì‹Â²-·LÂ#“Â,ÚÂ7Þ5ÂCæfÂPš Â]ž¸Âj¡ËÂwn˜Âõ?ˆÂâN“„˜Ç+Â|î¡j¤SøÂ¦1¦m‘Â¥…£k NÙœiy—ò°Â“;ÂŽšÂ‰ƒò°Â}öÉÁé5?Áí¸ÁñbÁõ ÁùSøÁýß;ÂqªÂNÙ¦頡ËÂk…Â, 7Â%Â.SøÂ8¡ËÂCÇ®ÂOyÛÂ[cTÂg;dÂrÎÙÂ}þú„YšÂ‰z^ÂŽNÙÂ’À–ª™äÝœDœÂ¥ãÂöFÂ5Ûvɘڠ•ŠÁ‘´9Â}‰儆%Âë…ÂváHÁê5?ÁîXÁòPÁöå`ÁûvÉÂ.ÂàBÂéy gm |îÂLÍÂ÷Ïš Â&BÂ.èsÂ8r°ÂB­ÂMRòÂX¸ÂbÎÙÂm2-Âw)ü€MÓ„ŢˆìÂŒ¯Âô¼Â’Ÿ;”b•°!•ï•MP“ב¤ÝÂŽÔþ‹ˆ´Â‡áHƒüîÂéyÂw¹XÂoŒJÁêÌÍÁï ÅÁó\Áø&éÁüûçÂÂë… ¬ÂËÇÂ’oÂÂqªÂ&¥ãÂ.¯Â7ožÂ@½qÂJ\)ÂThÂ]¤ÝÂfêÂoÖÂxÂàBƒ„†·Ï‰wÏ‹°!ÂJ=ÂŽ4¼ÂŽeãÂÝ/ÂŒ¢NŠƨˆaHÂ…ŒJ‚`ÅÂ}í‘ÂvɺÂoyÛÂh ÁëÁï|îÁô“ÁøáHÁýë…§ð–‡ÂÓøÂ uÓuÂA‰Â”{š Â&VÂ-½qÂ5¹XÂ> ÅÂFÅ¢ÂOt¼ÂWýôÂ`dZÂEF¨ÂLÂR€ÂX¡ËÂ^RòÂcŽVÂh@ƒÂlYÂoƨÂrxÕÂt`BÂuožÂuŸ¾Âtð¤ÂsiyÂqÂnVÂje`Âf6FÂa™šÂ\¨öÂWzáÂR#×ÁéƒÁî33Áó JÁø“ÁýdZ€€¼j >wÂhÂ?}ÂÍÓ¾wÂ"\Â'´9Â-ž¸Â3µ?Â9ß;Â?þúÂEùÛÂK¸RÂQ%ãÂV,ÂZƨÂ^ãTÂbuÃÂem‘ÂgÀƒÂibNÂjH´ÂjožÂi× Âh…ÂfƒÂcáHÂ`°!Â]%ÂXõÃÂT”{ÂOõÃÂK)üÁt-Áq¥ãÁnñªÁl¬Ái;dÁfffÁc¾wÁa\)Á_l‹Á^ JÁ]l‹Á]¶FÁ_ =ÁaPÁedZÁj£×Áq`BÁy™šÁ¬Á‡A‰Á‡+Á”jÁ›ÌÍÁ££×Á«ÎÙÁ´+Á¼—ÁÄó¶Á͸ÁÔõÃÁÜ\)Áã;dÁévÉÁïÁóÒòÁ÷Û#Áû¸Áý›¦ÁÿZÂ0!Â^5Áw®Átå`ÁqãTÁn´9Ákp¤Áh1'Áe‡ÁbA‰Á_ß;Á^{Á]oÁ]%Á^¬Á`ƒÁdVÁi¶FÁp¼jÁyl‹Áå`Á‡ãTÁŽ¥ãÁ–“Áž¸Á¦¬Á¯•Á¸¼jÁÁõÃÁ˸ÁÔVÁÜŸ¾Áä²-Áì&éÁòå`ÁøÙÁýó¶ÂšÂÇ®Â1ÂÝ/ÂMÓÂaHÁ{‘hÁx‹DÁu;dÁq¶FÁn JÁjbNÁfÐåÁc…Á`¬Á^n˜Á]%Á\Ÿ¾Á]t¼Á_®Ác|îÁhýôÁpIºÁyp¤Á‚;dÁˆ£×ÁéyÁ—÷ÏÁ ¬Á©ùÛÁ³¶FÁ½¶FÁÇÒòÁÑÛ#ÁÛ£×Áå ÁíÎÙÁõå`Áý-ÂÅ¢Âzá±'Âj ¦é m‘ Ţ ¶FÁçmÁ|£×Áy =Áu/Áq&éÁmVÁi =ÁeC–ÁaïžÁ_;dÁ]`BÁ\Ÿ¾Á]+Á_7LÁbõÃÁh“uÁp(öÁyƨÁ‚º^Á‰“uÁ‘bNÁšoÁ£Á­Ÿ¾Á¸?}ÁÃ/ÁÎ?}ÁÙ?}ÁãõÃÁî5?Á÷ÊÁÂH´Â49š Â uàÁ‰Â~ú²-ÂcT™šÂ`BÁ‚\)Á€Ÿ¾Á}`BÁy33ÁtÌÍÁpIºÁkÒòÁg•ÁcÂÁ`—Á^MÓÁ]+Á]hsÁ_C–ÁbõÃÁh¬Áp‡+Áz›¦ÁƒzáÁŠÄœÁ“ ÅÁœ|îÁ¦²-Á±°!Á½C–ÁÉ9XÁÕZÁáffÁí"ÑÁøVÂcTÂ$Ý [# øÕÂ÷ÏÂSøÂbÂ2-ÂÂÂÍÓÂaHÁ… Áƒ/Á$ÝÁ}ÒòÁyoÁt-ÁoG®Áj“uÁfIºÁb§ðÁ_ïžÁ^jÁ^^5Á`1Ác©üÁixÕÁq™šÁ|$ÝÁ„“uÁŒQìÁ•A‰ÁŸOßÁªVÁ¶C–ÁÂáHÁÏó¶ÁÝ;dÁêp¤Á÷MÓÂÅ¢Ât¼Â ˜“¦Âð¤Â\Ât¼Â&éÂ,Â’oÂgm»dÁ‡í‘Á† =Áƒå`Á‹DÁ~ JÁxÈ´ÁsÁn^5Ái¡ËÁe‘hÁbr°Á`“uÁ`=qÁaº^ÁeSøÁk;dÁs²Á~£×Á†+ÁŽ^5Á—áHÁ¢§ðÁ®‹DÁ»xÕÁÉ5?Á×~úÁæ =Áô‰7ÂOßÂÂ-¹X‹D“uÂɺÂ"/Â#ÊÁÂ$§ðÂ$ÖÂ$ffÂ#l‹Á‹¸Á‰/Á†ùÛÁ„‡+Áß;Á~1'Áx\ÁsVÁmïžÁixÕÁfÁcÒòÁcC–ÁdŸ¾Áh5?Án=qÁví‘Á7LÁˆffÁ‘VÁ›-Á¦²-Á³xÕÁÁxÕÁÐl‹Áà1ÁïùÛÁÿß;§ðÂô¼Â¨öŸ¾Â ½qÂ$ñªÂ(7LÂ*\Â,Â,©üÂ,ŽVÂ+ÊÁÂ*t¼ÁŽ“uÁŒ£×ÁŠdZÁ‡ß;Á… ÅÁ‚;dÁ~‹DÁx¼jÁsKÇÁn‡+ÁjÈ´Áh^5Ág©üÁhýôÁl£×ÁráHÁ{çmÁƒó¶Á‹|îÁ”›¦ÁŸSøÁ«²Á¹XÁÈxÕÁؼjÁéÌÍÁûG®Â\)ÂÐåÂÅ¢Â+Â$hsÂ)ÌÍÂ."ÑÂ1ffÂ3Ÿ¾Â4Ý/Â549Â4¼jÂ3’oÂ1ÎÙÁ’QìÁdZÁŽ$ÝÁ‹—ÁˆÊÁÁ…ÐåÁ‚ÂÁ|îÁyÒòÁtÝ/ÁpñªÁnn˜Ám¶FÁo¸ÁrõÃÁy|îÁxÕÁ‡ÂÁ©üÁ™E¢Á¤™šÁ±®ÁÀffÁоwÁân˜Áõ“Â!Ë ²-Âò°Âš Â'jÂ.2-Â3ÑìÂ88RÂ;ffÂ=hsÂ>TþÂ>F¨Â=\)Â;¶FÂ9r°Á–OßÁ”r°Á’9XÁ®ÁŒß;Á‰Ý/Á†ÂÁƒ²-Á€ÐåÁ|—Áx§ðÁv5?Áu¥ãÁwOßÁ{‰7ÁE¢Á†IºÁŒéyÁ•=qÁŸXÁ«QìÁ¹9XÁÈýôÁÚ¥ãÁíãTÂ$Ý §ðÂ$Ý >wÂ)Ÿ¾Â1üîÂ9 ÅÂ>çmÂCF¨ÂFBÂGð¤ÂHm‘ÂGÝ/ÂFe`ÂD,ÂATþÁšPÁ˜Æ¨Á–Ÿ¾Á”"ÑÁ‘\)ÁŽ`BÁ‹IºÁˆ;dÁ…^5Á‚å`ÁÁÛ#Á®Á€í‘ÁƒZÁ‡9XÁŒ¥ãÁ“¶FÁœ…Á§1'Á³Û#ÁÂ¥ãÁÓ‹DÁ曦Áû‹DÂî˜Ât¼ÂïžÂ*î˜Â5 =Â=ì‹ÂEVÂK(öÂO\)ÂRÂS5?ÂS¾ÂQì‹ÂOËÇÂLæfÂIffÁŸÁ^5Á›VÁ˜ñªÁ–?}Á“XÁSøÁZÁŠ™šÁˆC–Á†‘hÁ…¾wÁ…ýôÁ‡~úÁŠdZÁŽÌÍÁ”ÊÁÁœr°Á¥ß;Á±5?Á¾¥ãÁÎhsÁà‡+Áõ&éÂøÕÂ/ÂÎÙÂ+XÂ7BÂBhÂKaHÂRñªÂX¦éÂ\ƒÂ^¡ËÂ_.Â^]/Â\dZÂYxÕÂUÎÙÂQbÁ£©üÁ¢/Á MÓÁžbÁ›ƒÁ˜¼jÁ•Ý/Á“ JÁzáÁŽbNÁ ÁŒ“uÁQìÁjÁ“Á˜(öÁžïžÁ§bNÁ±™šÁ½ÂÁÌ ÅÁÜýôÁð~úÂjÂÖÂ2-Â*þúÂ8¡ËÂEs¶ÂPãTÂZ€Âb1ÂgiyÂj³3Âl{ÂkƨÂj JÂg%ãÂcRòÂ^ɺÂYº^Á¨t¼Á§/Á¥Á£t¼Á¡“Áž…Á›Û#Á™E¢Á–ûçÁ•=qÁ”IºÁ”ffÁ•ÐåÁ˜¶FÁ7LÁ£`BÁ«33Á´²-Á¿õÃÁÍ-ÁÜ®Áî× Âô¼Â¡ËÂ*:^Â9E¢ÂHÂU²-Âa ÅÂkVÂr—Âw`BÂyÖÂz9XÂxÙÂv%Âr PÂm33Âgµ?ÂaÖÁ­\)Á¬QìÁªãTÁ©{Á¦÷ÏÁ¤¥ãÁ¢A‰ÁŸýôÁžbÁœÂÁœ^5Á(öÁŸjÁ£QìÁ¨ûçÁ°jÁ¹“uÁÄr°ÁÑVÁß²ÁðƒÂ²Â PÂÀƒÂ)†%Â9n˜ÂIÀƒÂY•Âh Ât?}Â}ÍÓ‚>w„/„ٚ„kƒ =Â|å`Âvì‹ÂpffÂi‡+Á²QìÁ±PÁ°dZÁ®ß;Á­VÁ« JÁ© Á§¸Á¥¥ãÁ¤áHÁ¥$ÝÁ¦ÂÁªÁ¯¬Á¶&éÁ¿ ÅÁÉïžÁÖzáÁäÄœÁõ ÂÍÓ“uÂ1Â)ffÂ9wÏÂJº^Â\QìÂm'ðÂ|+„<îˆÊÁ‹¯žÂÂŒøÕ‹Ëlj¸R†÷Lƒ·Ï€"NÂx­ÂpÛ#Á·G®Á¶ÐåÁµ÷ÏÁ´Æ¨Á³MÓÁ±¬Á°%Á®—Á­£×Á­~úÁ®…Á±VÁµn˜Á»áHÁÄ~úÁÏ;dÁÛñªÁêvÉÁú¾wÂyÛÂƨ•Â*&éÂ9½qÂK¾Â]´9ÂpzáˆÊÁÂŽÚ“´Â•Su•æé•1“– BÂŒž5ˆ°!„~ú€)üÂw’oÁ¼1'Á¼VÁ»PÁºº^Á¹¥ãÁ¸l‹Á·=qÁ¶QìÁµõÃÁ¶ƒÁ¸\)Á»å`ÁÁ|îÁÉbNÁÓ°!ÁàXÁï"ÑÁÿ× Â )üÂ^5ÂÂÂ+¬Â:aHÂK)üÂ]Å¢ÂqŠ=‚©y‹Ù“Ÿ¾Â™xRÂ'ðž»çžvÉœ±ªÂ™É7–å‘ÌJÂ1'ˆhöƒ‘hÂ}ÁÀýôÁÁ33ÁÁoÁÀ£×Á¿ùÛÁ¿9XÁ¾‹DÁ¾1'Á¾xÕÁ¿ÄœÁÂ|îÁÇoÁÍçmÁ×G®ÁãOßÁñéyÂj ãTÂE¢Â œ¬Â-¬Â; ÂJÞ5Â\±'ÂpMÓ‚}qÂŒ½q–²ÂÙ£bN¦‚ §V¦49£ŠÁŸÆ%›B –G+‘ P‹»d†n˜Â:áÁŧðÁÆ;dÁÆ|îÁÆzáÁÆIºÁÆ =ÁÅéyÁÆ+ÁÇ"ÑÁÉ7LÁÌ× ÁÒ|îÁÚ‘hÁådZÁó“ÂÈ´Â DœÂÐåÂ!LÍÂ-·LÂ;>wÂJ2-ÂZÑìÂmhs€Ô{‹j•ÐbŸ3¶Â¦Ã–«î®}q®›#¬°!©9Û¤±ªÂŸ{ç™äZ”"ÑÂŽ]²Âˆ¯žÂƒ)üÁÊ ÅÁË{Á˾wÁÌ/ÁÌzáÁÌÂÁÍ9XÁÎ ÅÁÏÐåÁÒ²-Á×=qÁÝë…Áç/Áó\)ÂIºÂ ^5 A‰Â,²-Â:1ÂHffÂXhÂi>wÂ|2-ˆNÙÂ’àBÂ)y¦X“­/²`B´n˜Â³÷ϱm­Y¨ú”4¼Â$ZÂ¥”{¬ì²\¶1·%ã¶%³–®”{©.£49œó¶Â–£TÂhsŠZ„‡+ÁÙMÓÁÛ¼jÁÞoÁà\)Áâ²-Áå7LÁè ÅÁë²-Áð=qÁö(öÁýáHÂî˜Â ?}Â1ÂTþÂ&hÂ2VÂ? DÂLÖÂ[+ÂiÀƒÂxò°Â„KDÂŒ_¾Â”åœ/¤ Bªš Â¯P²”þ³…¢Â²t¼Â¯¨ö«‡+¦t¼Â ÍPšؓ”ËÇÂŽËLjð¤ÂƒIºÁÜC–Áß JÁáÄœÁä~úÁçOßÁê^5ÁíÛ#Áò%Á÷/Áý¶FÂÂw² Ÿ¾Â†%Â#¾wÂ.1'Â9²-ÂEýôÂRÐåÂ_ò°ÂmwÂÙ¢ÑÂ&ž¸Â0µ?Â;¸RÂGiyÂS‰7Â_Û#Âl6FÂx}ô‚IºÂˆ;çÂ÷Ï“YšÂ˜.˜Âœ;dŸE¡/¡¬ ô¼ÂŸuœ6F˜“øÂ”cTÂÔþ‹ì†:^ÂeãÂyKÇÁâãTÁæ\ÁêKÇÁî$ÝÁò7LÁö²Áû…Â\ÂÖ·L YÂß;Âe`ÂûçÂ( ÅÂ2=qÂ<¥ãÂG ÅÂRð¤Â^[#Âi·LÂtãTÂÀƒÂ…$ÝŠ'mŽɺ’å`–NV˜ؓšaËÂš× Âš9Û˜ž5–&fÂ’ûçÂJÁ‹wÂf¯Â`+ÁæSøÁêº^ÁïG®Áô =ÁùbÁþt¼Â&éÂ_;ÂñªÂ ñªÂn˜ÂwÏÂ{Â"DœÂ)Â02-Â7¿}Â?ƒÂGVÂO{ÂV²Â]ÖÂdŸ¾ÂjõÃÂp»dÂuØÂz2-Â}®€Â€×  ºÂ€±'¤ÝÂ|ñªÂycTÂu Âp;dÂjæfÂe:^Â_VÂYOßÁæE¢ÁêÄœÁïjÁôG®ÁùjÁþãTÂgm Š- “Âr°ÂBÂŽVÂ!TþÂ'PÂ.#×Â5Â<ÂC\ÂJÂP»dÂW(öÂ],ÂbÁ‰ÂgÍÓÂl>wÂpÂrüîÂu!ËÂvaHÂv´9Âv“Ât—Âr@ƒÂo(öÂkk…Âg"ÑÂbjÂ]]/ÂXuÂR¡ËÁåáHÁêl‹Áï"ÑÁôbÁù?}ÁþÄœÂW ‹D 1 ÙÂ+š Â“uÂñªÂ%©üÂ+¬Â1äZÂ86FÂ>ˆ1ÂD¾wÂJ¿}ÂPvÉÂUËÇÂZ¸RÂ_%ãÂc%ÂfG®ÂhÛ#Âj²-ÂkÂÂl%Âk|îÂj.Âh%ãÂes¶Âb,Â^ffÂZ7LÂU·LÂPøÕÂLVÁå+Áé¼jÁîzáÁójÁø²Áþ¬ÂýôÂ$Ý‹D ;dÂ:^ÂPÂ49Â+Â#jÂ(ãTÂ.ƒÂ433Â9Þ5Â?jÂDÅ¢ÂIÛ#ÂN•ÂRïžÂVÖÂZ:^Â]bÂ_LÍÂ`ãTÂaÌÍÂbÂaŒJÂ`hsÂ^ ÅÂ\DœÂYcTÂVVÂRXÂNSøÂJhÂE¡ËÁC–Á“uÁ‹…Á‰VÁ†=qÁƒoÁ33ÁwÊÁÁp{ÁhMÓÁ`´9ÁY²ÁSOßÁN-ÁJƒÁH´9ÁHéyÁK|îÁPbNÁW× ÁaPÁm‘hÁ{p¤Á…|îÁ× Á–¥ãÁŸ›¦Á¨›¦Á±hsÁ¹çmÁÁãTÁÉZÁиÁÖ9XÁÛ‰7Áà(öÁãõÃÁç“Áér°Áë/ÁìA‰Á”bÁ’ZÁ+Á‘hÁŠxÕÁ‡Áƒ Á}ß;ÁtýôÁlÁc%ÁZ“uÁRÐåÁLbNÁGt¼ÁD£×ÁD{ÁF9XÁKoÁRÔþÁ]G®ÁjVÁy™šÁ…ffÁޏRÁ˜xÕÁ¢t¼Á¬ffÁ¶ Á¿r°ÁÈ9XÁÐMÓÁן¾ÁÞ+Áã× Áè°!Áì²-Áï× Áò?}Áó× ÁôÊÁÁ™záÁ—ÄœÁ•‡+Á’ÄœÁzáÁ‹¬Á‡ffÁ‚º^Á{xÕÁq =Áf¬Á\‹DÁSOßÁK;dÁDõÃÁ@ÐåÁ?dZÁ@Ý/ÁE™šÁMPÁXÄœÁfí‘ÁwÎÙÁ…bNÁ´9ÁšƒÁ¥™šÁ°™šÁ»VÁÅ\ÁÏ&éÁ×éyÁß× ÁæÌÍÁìÔþÁñß;Áö%Áù33ÁûPÁýbÁýÐåÁŸ›¦ÁïžÁ›¶FÁ˜Û#Á•ffÁ‘QìÁŒ¬Á‡Áå`ÁxÁlÁ`5?ÁU&éÁKG®ÁCSøÁ=©üÁ:éyÁ;¥ãÁ?çmÁH“ÁSß;ÁcG®Áu¥ãÁ…SøÁº^ÁœÄœÁ© Áµ7LÁÁÁÌ=qÁÖ§ðÁà1'Áè°!Áð$ÝÁö|îÁûĜ˜“º^Âgm©üÁ¦záÁ¤õÃÁ¢ÊÁÁŸë…ÁœXÁ˜ =Á“1ÁbNÁ‡-Á€‘hÁsp¤ÁeÎÙÁX¼jÁLí‘ÁBñªÁ;²Á7dZÁ7VÁ:¸RÁBáHÁO7LÁ_ƨÁsÊÁÁ…p¤Á’%ÁŸXÁ¬Ý/ÁºSøÁÇQìÁÓ‘hÁÞïžÁé1'ÁòSøÁú7LÂvÉÂ-ÂVÂçmÂøÕ‡+«Á®7LÁ¬éyÁªå`Á¨“Á¤|îÁ %Áš¼jÁ”¥ãÁÝ/Á†Á}¥ãÁmûçÁ^Ý/ÁPÄœÁD¼jÁ;?}Á5hsÁ3•Á6\Á>ffÁK\)Á\ÙÁr§ðÁ…ë…Á“× Á¢t¼Á±jÁÀ$ÝÁÎ`BÁÛ¸RÁèÁó JÁüƨÂb 7ÂØ ûç †% yÛ éy Ý/Á¶ÒòÁµÐåÁ´VÁ±jÁ­áHÁ©XÁ£Û#ÁbNÁ–‡ÁŽ Á…vÉÁyKÇÁgó¶ÁWPÁI Á=`BÁ5|îÁ1ûçÁ3Û#Á;/ÁHZÁZÐåÁrA‰Á†ÎÙÁ•ûçÁ¦ =Á¶jÁƉ7ÁÖ1ÁäÁñÀƒÁý•Âó¶ÂRò ð¤ÂÈ´Âî˜Â`BÂ;dÂ{çÂC–ÁÀ9XÁ¿®Á¾E¢Á»ó¶Á¸™šÁ´ ÅÁ®‰7Á§ÎÙÁ  =Á—SøÁñªÁ„(öÁt°!ÁaãTÁPÔþÁB´9Á8VÁ3 =Á3C–Á9ë…ÁFáHÁZ9XÁrí‘ÁˆKÇÁ˜¸RÁª5?Á¼ =ÁÍŸ¾ÁÞbNÁî JÁü5?Âj ÖÂn˜Â¾Â+¦Â{çÂ&éÂ?}ÂÄœÁÊvÉÁÊxÕÁÉ—Áǰ!ÁħðÁÀ`BÁºÐåÁ³ïžÁ«ÐåÁ¢\Á˜n˜Á²-Á‚ÎÙÁpE¢Á\ÄœÁKß;Á?/Á7l‹Á6 JÁ;XÁH1Á[²Áu¾wÁŠ‘hÁœQìÁ¯(öÁÂvÉÁÕffÁç|îÁø5?¬ QìÂ+ÂÇ®Â\Ât¼Âs¶Â´9Â/Â\ÂVÁÕffÁÖoÁÕÛ#ÁÔƒÁÑó¶ÁÎ%ÁÈ£×ÁÁÂÁ¹hsÁ¯¼jÁ¤ïžÁ™dZÁt¼Á¶FÁmKÇÁYó¶ÁJ‹DÁ@—Á<ùÛÁ@ùÛÁL°!Á`záÁ{SøÁŽ;dÁ ùÛÁµ-ÁÉÎÙÁÞ JÁñVÂŒJ ‹DƒÂt¼ÂQìÂ,Â" Â#ïžÂ$ýôÂ%KÇÂ$âNÂ#ë…ÁàñªÁâxÕÁãÁâjÁàvÉÁÝVÁ×ûçÁÑA‰ÁÈÎÙÁ¾ÔþÁ³Á§9XÁšhsÁ›¦Ár°ÁmVÁ[KÇÁNÈ´ÁI/ÁKC–ÁV“Ái`BÁ‚n˜Á“‡+Á§9XÁ¼vÉÁÒ7LÁç§ðÁûí‘ÂRòÂ¥ãÂë…ÂÂ!ûçÂ%ÌÍÂ(™šÂ*[#Â+>wÂ+G®Â*¤ÝÂ)ZÁì÷ÏÁï`BÁðÙÁñ“Áï÷ÏÁí+Áè£×Áâ&éÁÙÒòÁÏ¥ãÁÃ÷ÏÁ·‡Á©PÁ›çmÁŽÆ¨Á‚áHÁq¶FÁc+Á[KÇÁ[ƨÁeOßÁw× Á‰©üÁ›oÁ¯^5ÁÅ`BÁÜÁòKDZ' dZÂþúÂt¼Â#§ðÂ(¢ÑÂ,s¶Â/“Â0¹XÂ1ZÂ1-Â05?Â.¨öÁùIºÁüÄœÁÿ=qÂC–Â$ÝÁþ`BÁúr°ÁôxÕÁì\)ÁâA‰ÁÖXÁÉ&éÁ»oÁ¬áHÁŸ =Á’p¤Á‡—Á~í‘Áu?}ÁtÁ{ÎÙÁ†¼jÁ”bÁ¥‡+Á¹÷ÏÁÐSøÁçjÁþ(ö àB¾w‰7Â$VÂ*TþÂ/E¢Â3Â5~úÂ6ì‹Â7PåÂ6Û#Â5š Â3½qÂçmÂ49ÂÂ8R¤ÝÂ)ü¡ËÂ÷ÏÂ"ÑÁöZÁê~úÁÝ“ÁÎÙÁÀA‰Á²/Á¥“Á™ë…Á‘¬Á‹¾wÁŠA‰Á‹DÁ•“uÁ¢p¤Á³ZÁlj7ÁݶFÁôº^ÂÀƒÂŒJÂwÏÂ#:^Â*Å¢Â0ñªÂ5ÓøÂ9^5Â;¶FÂ<ß;Â= =ÂãTÂ>ÖÂ=\Â;IºÂ8KÇÂ5Â1ÌÍÂ.ùÛÂ,³3Â*öÉÂ)¤ÝÂ(˜“Â'½qÂ'+Â'“Â'ɺÂ)t¼Â,49Â/ð¤Â4‚ Â9˜“Â>ð¤ÂD0!ÂIoÂMSøÂPÈ´ÂSIºÂTɺÂU>wÂT¹XÂSE¢ÂQÂN PÂJˆ1Â&ûçÂ-+Â2ß;Â8XÂ=:^ÂAVÂDs¶ÂFvÉÂGJÁÂG 7ÂEÝ/ÂD¬ÂB#×Â@RòÂ>ë…Â> 7Â=ŒJÂ=:^Â<Å¢Â< 7Â;1Â: =Â9cTÂ9n˜Â:`BÂwÂd0!Â`È´Â^,Â\gmÂ[XÂZØÂZ§ðÂZ•ÂZdZÂYïžÂY PÂW²-ÂUɺÂS_;ÂPožÂMoÂINÙÂ-£×Â41'Â:´9ÂAVÂG%ãÂLØÂR{ÂVɺÂ[Â^ÄœÂbF¨Âe®Âi&éÂlÚÂp»dÂt¥ãÂx+ÂzÜ)Â|1'Â{× ÂyØÂvqªÂr33Âm›¦Âi%ãÂe8RÂaøÕÂ_€Â]¸RÂ\yÛÂ[›¦ÂZãTÂZ&éÂY:^ÂWøÕÂVSøÂT>wÂQ°!ÂN¶FÂKSøÂG›¦Â,ÓøÂ3>wÂ9 ÅÂ?áHÂEêÂKž¸ÂPöÉÂUâNÂZbNÂ^bÂbƒÂfgmÂj^5Ânr°Âr¤ÝÂv¶FÂzXÂ}oÂ~m‘Â~5?Â|W Ây#×Âu%Âpp¤ÂkéyÂg¹XÂd$ÝÂa33Â^çmÂ]¦Â[²-ÂZuÃÂYC–ÂWî˜ÂV_;ÂTzáÂR:^ÂO”{ÂL‘hÂI2-ÂEˆ1Â+p¤Â1¦éÂ7× Â=ïžÂCÔþÂI}ôÂNÐåÂSÓøÂX}ôÂ\êÂa$ÝÂeTþÂi‡+ÂmÌÍÂr DÂv Âyž¸Â|A‰Â}š Â}~úÂ{Þ5ÂxúáÂu,ÂpâNÂl{çÂhZÂd£×Âa}ôÂ^Ü)Â\µ?ÂZáHÂYDœÂW²-ÂV\ÂT_;ÂBBÂFÂI›¦ÂM 7ÂPA‰ÂS5?ÂUÒòÂXÂYµ?ÂZÓøÂ[TþÂ[8RÂZ‰7ÂY]/ÂWÈ´ÂUêÂSÜ)ÂQ·LÂOŠ=ÂMbNÂK@ƒÂI'ðÂGoÂDùÛÂBÓøÂ@œ¬Â>KÇÂ;Ü)Â9JÁÂ6•Â3¾wÂ0ƨÂ/ÂxÕ Á‰Â%Â)6FÂ-VÂ1]/Â5H´Â9Â<Á‰Â@IºÂC«ÂFÞ5ÂIÛ#ÂL–‡ÂOÂQ 7ÂRŸ¾ÂS¸RÂTKÇÂTXÂSçmÂS+ÂQÈ´ÂPBÂNŠ=ÂL²-ÂJÇ®ÂHÔþÂFß;ÂDæfÂBêÂ@äZÂ>ÏßÂ<¨öÂ:hsÂ8 DÂ5bÂ2ô¼Â0:^Â-aHÂçmÂî˜Âô¼Â ó¶Â$æfÂ(ƨÂ,‘hÂ0A‰Â3ÖÂ7IºÂ:›¦Â=ÄœÂ@ÀƒÂC‡+ÂF\ÂHKÇÂJ0!ÂK±'ÂLÄœÂMe`ÂM”{ÂMVÂLµ?ÂK¿}ÂJ†%ÂIÂG…ÂEØÂDšÂBOßÂ@{çÂ>›¦Â<®Â:°!Â8œ¬Â6qªÂ4+Â1Ç®Â/G®Â,«Â)ò°Â¢ÑÂk…Â33Âò°Â ¦éÂ$JÁÂ'ÚÂ+QìÂ.¯Â1ì‹Â5+Â7ûçÂ:ÄœÂ=ZÂ?³3ÂAÇ®ÂCPÂDúáÂF =ÂF¶FÂFþúÂFéyÂF|îÂEÖÂDÊÁÂCœ¬ÂBF¨Â@ÑìÂ?E¢Â=¦éÂ;öÉÂ:6FÂ8dZÂ6~úÂ4ƒÂ2ožÂ0A‰Â-øÕÂ+”{Â)Â&}ôÁoÁŒéyÁŠKÇÁ‡5?Áƒ©üÁ`BÁv°!ÁmdZÁc¶FÁYë…ÁPZÁG`BÁ?hsÁ8å`Á4IºÁ1ûçÁ2^5Á5©üÁ<bÁE‰7ÁQûçÁa¸ÁrvÉÁ‚× Á{Á—©üÁ¢SøÁ¬ÔþÁ¶õÃÁÀ‹DÁÉr°ÁÑ•ÁØß;ÁßIºÁäÐåÁér°Áí5?Áð ÅÁòA‰Áó£×ÁôSøÁ”-Á‘ó¶Á33Á‹çmÁˆ JÁƒ¬Á}¡ËÁs¸Áh JÁ\¬ÁQdZÁFŸ¾Á<áHÁ4§ðÁ.~úÁ*éyÁ*ZÁ-&éÁ3‰7Á=‰7ÁK Á[¡ËÁnáHÁ‚$ÝÁ“uÁ™dZÁ¥G®Á°ñªÁ¼$ÝÁư!ÁÐn˜ÁÙE¢Áá$ÝÁè ÁíÝ/Áò¶FÁö—Áù‹DÁû›¦ÁüÝ/Áý^5Á™ùÛÁ—ÀƒÁ”éyÁ‘p¤ÁOßÁˆPÁƒ1'Áz£×ÁnbÁa ÁSÛ#ÁG Á;OßÁ1 Á)¸Á#÷ÏÁ"9XÁ$QìÁ*‹DÁ4õÃÁCxÕÁU®ÁjõÃÁdZÁŽ"ÑÁ›QìÁ¨‹DÁµzáÁÁÛ#ÁÍn˜ÁØoÁá§ðÁê¸Áñr°Á÷Ÿ¾Áü®ÂRòÂɺÂƨÂPåÂs¶Á ‹DÁž`BÁ›‡+Á—ïžÁ“—ÁŽzáÁˆ£×Á‚$ÝÁv1'ÁgXÁX-ÁI?}Á;33Á.¼jÁ$›¦Á•ÁZÁxÕÁ!OßÁ, JÁ;PÁOdZÁfÝ/Á€¥ãÁŽÔþÁÁ¬1'Áº…ÁÈ&éÁÔ× ÁàjÁêÆ¨ÁóÝ/Áû£×Âb­°!Â!Ë DÂxÕÂvÉÁ§ñªÁ¥í‘Á£"ÑÁŸ…Á›Á•Ÿ¾ÁXÁˆ?}Á€p¤Áp1'Á^å`ÁM¡ËÁ=‡Á.“Á!‰7ÁMÓÁ;dÁVÁE¢Á#¸Á3ÁHýôÁbÀƒÁ÷ÏÁ¸RÁ  Á°IºÁÀ ÁχÁÜó¶Áé‡+Áô°!ÁþdZÂNÙ²- aH e` ɺ ™šÂ ãT µ?Á°9XÁ®vÉÁ«× Á¨IºÁ£º^Áž ÅÁ—záÁÒòÁ‡G®Á|1Áh“uÁTÔþÁA¡ËÁ/Û#Á \ÁÄœÁ Á ©üÁë…ÁŸ¾Á+º^ÁBÌÍÁ^Ý/Á%Áå`Á¢éyÁ´å`ÁÆOßÁÖ¸RÁåÒòÁól‹ÁÿhsÂÝ/ 1' µ?ÂqªÂp¤ÂÀƒÂn˜ÂPÂ+Á¹n˜Á¸1Áµ´9Á²VÁ­ÔþÁ¨"ÑÁ¡5?Á™‡ÁÛ#Á…²-ÁuÂÁ_|îÁIxÕÁ4ÀƒÁ"r°ÁÊÁÁ ÷ÏÁbÁñªÁ&éÁ$¸RÁ=7LÁ[•Á~¸RÁ’xÕÁ¦MÓÁº‡ÁÍ/Áß“ÁïzáÁþ ÅÂwÏ î˜ÂvÉÂÂÙÂÌÍÂÂ…Ân˜ÂÐåÁÕÁ¬ÁÀÄœÁ½º^Á¹l‹Á³ÂÁ¬®Á¤/ÁšZÁ\)ÁƒxÕÁn(öÁUOßÁ=Á(Á5?Á xÕÁ‡Á1'Á xÕÁ+Á8ÔþÁY\)Át¼Á”—ÁªMÓÁ¿ó¶ÁÔÆ¨Áè;dÁùë…ÂÑì ¡ËÂcT ÂÐåÂ’oÂp¤Â~úÂÑìÂ~ú²ÁΧðÁÎdZÁÍbÁÊÁÆPÁÁ{Á¹ûçÁ±?}Á¦ë…Á›-ÁŽIºÁ€®Áe®ÁJÈ´Á21ÁéyÁ ùÛÁƨÁ£×Á \Áë…Á6jÁXÔþÁ€áHÁ—vÉÁ¯ JÁÆ“uÁÝ(öÁò(ö“u ô¼Â)üÂ1'Âh ÖÂ#\Â%PåÂ&1'Â&H´Â%±'Â$ƒÁÚŸ¾ÁÛ$ÝÁÚPÁØ¥ãÁÕ;dÁиÁÉ+ÁÀVÁµ£×Á©?}Á›t¼ÁŒ´9Á{VÁ]+ÁA33Á(¼jÁ|îÁ /Áp¤Á ‰7Á“Á6ùÛÁZéyÁƒ/Á›bNÁ´ÄœÁΠÁæbNÁüãTÂ’oÂr°Â%ÂKÇÂ$LÍÂ(Â*¾wÂ,ZÂ-Â,ØÂ+ò°Â*qªÁçbNÁèÙÁé+Áè ÁådZÁàÒòÁÚ33ÁÑn˜ÁƃÁ¹›¦Á«%Á›;dÁŠÒòÁu ÁVbÁ:n˜Á#ë…Ár°Á Û#ÁÂÁ!‡Á;× Á`ÐåÁ‡(öÁ ÂÁ»¾wÁÖ¸RÁð\Â8RÂì‹Â?} %ãÂ&Ÿ¾Â+·LÂ/}ôÂ2 7Â3uÃÂ3àBÂ3hsÂ21'Â0W ÁôÒòÁ÷bNÁøÆ¨Áø¸RÁöë…Áó‡ÁìùÛÁär°ÁÙxÕÁÌ1'Á¼ó¶Á¬E¢ÁšÎÙÁ‰KÇÁqoÁR°!Á9C–Á&ÌÍÁ`BÁå`Á,“uÁF´9Ál“Á|îÁ¨"ÑÁÄbNÁà´9ÁûÒò m‘š ÂLÍÂ't¼Â.uÂ35?Â6ì‹Â9SøÂ:ˆ1Â:¬Â9ãTÂ8QìÂ6 ÂcTÂH´Â˜“Â)üÂÎÙÂ[#§ðÁù7LÁî\)Áàå`ÁÑ-Á¿ÊÁÁ­|îÁ›bÁ‰SøÁr5?ÁV‡+ÁA™šÁ5©üÁ4ÐåÁ@§ðÁY²Á~°!Á—Á²33ÁÏ33Áì\)Â+Âo”{Â&†%Â.ØÂ5‰7Â:¥ãÂ>BÂ@záÂAp¤ÂAG®Â@(öÂ>°!ÂAɺÂC^5ÂC/ÂA&éÂ=]/Â8!ËÂ1öÉÂ+{çÂ%JÁÂØÂ[#ÂÏßÂb¯Â]/Âhs²ž¸ÂÈ´Â'DœÂ/š Â8LÍÂ@áHÂHì‹ÂP“ÂV#×ÂZÝ/Â^-Â`VÂ`ŒJÂ_Á‰Â]ÓøÂZïžÂWA‰ÂRô¼Â-úáÂ4µ?Â;(öÂA‡ÂF0!ÂJ$ÝÂL¥ãÂM{çÂL\ÂIûçÂF{ÂA]/“uÂF1'ÂM}ôÂT:^ÂZ'ðÂ_1Âbµ?Âe&éÂf€Âg{Âg[#ÂgÞ5Âi‡ÂkA‰Ân:^Âql‹Âsì‹ÂtÊÁÂs~úÂp&éÂkuÃÂfffÂaÑìÂ^ZÂ\IºÂ[¤ÝÂ\:^Â]º^Â_ÄœÂaöÉÂcøÕÂe}ôÂfNÙÂfIºÂe^5ÂcŽVÂ`éyÂ]ˆ1ÂYˆ1ÂU1Â7ØÂ? ÅÂGXÂNÎÙÂUËÇÂ\‡Âa}ôÂeàBÂi;dÂk¶FÂm›¦Âo[#Âqm‘Ât7LÂwäZÂ|:^€H´Âó¶Â‚Ÿ¾Â‚‰Â€&éÂzØÂt­Ân¶FÂi®ÂeõÃÂc¥ãÂb¡ËÂb¥ãÂc[#ÂddZÂek…Âf#×ÂfTþÂe× Âd—ÂbbÂ_ÍÓÂ\aHÂXdZÂSñªÂ7çmÂ?¡ËÂGQìÂNÎÙÂUæfÂ\hsÂb-Âg Âk49Ânž¸Âq²Ât’oÂwãTÂ{áH€På‚î˜Â…r-‡]/ˆ0¤Â‡¤Z… ‚áËÂVÂxKÇÂr@ƒÂm_;ÂiÐåÂgŠ=ÂfTþÂeæfÂeêÂf\Âf JÂe§ðÂd¹XÂc+Â`ó¶Â^“ÂZ§ðÂV´9ÂRTþÂ7¾Â>±'ÂF>wÂM¡ËÂT³3Â[IºÂaDœÂf“uÂk;dÂo\)Âs49ÂwoÂ{H´Â€´Â‚¸ÕÂ…Pˆ2-Š1ªÂ‹ ÂЧðˆáˆþ‚·ÏÂ~qªÂwð¤Âre`Ân1ÂjÚÂh¶FÂg^5Âfˆ1ÂeéyÂeA‰ÂdXÂcÂa0!Â^ÎÙÂ[àBÂXožÂTŠ=ÂPDœÂ5›¦Â<ð¤ÂDDœÂKwÏÂRgmÂXó¶Â_Âd‹DÂibÂn1'Ârž¸Âw“Â{Ü)€ˆ1ƒTþ†.˜ÂˆÇ®ÂŠ»d‹©y‹V‰Å‡5?„ Ç€ªÂzÖÂu{ÂpMÓÂl‘hÂiÈ´ÂgÀƒÂf>wÂe ÂcÎÙÂbs¶Â`ÊÁÂ^º^Â\5?ÂY9XÂUÌÍÂQùÛÂMÏßÂ3{çÂ:…ÂAŽVÂH~úÂO8RÂU¢ÑÂ[©üÂaF¨Âf~úÂkjÂp1'Âu Âz1ÂX‚p!Â…+‡›#‰n˜ÂŠV‡ÂŠ"ÑÂˆÓøÂ†šƒÇ+€­Â{8RÂu™šÂp¿}ÂlÂÂi–‡Âg“ÂešÂcbNÂaÁ‰Â` =Â^ Â[ÚÂY9XÂV5?ÂRÐåÂOuÂK 7Â0Ý/Â7bÂ>E¢ÂDæfÂK[#ÂQ‘hÂWxÕÂ] PÂbRòÂg^5ÂlJÁÂq9XÂvG®Â{|î€_¾Â‚çðÂ…!H†ɺ‡¥ã‡\†„œÂ„©y‚=ôÂ%ÂyzáÂt>wÂo‘hÂkbÂh;dÂexÕÂc&éÂašÂ_'ðÂ]+Â[ÂXž¸ÂUë…ÂRå`ÂOPÂKçmÂGþúÂ-Ü)Â449Â:ŽVÂ@ØÂGÂLó¶ÂR«ÂX¾Â]W Âb]/ÂgG®Âl,Âq“ÂvVÂzñªÂŒJÂփ@ƒÂ„V„åƒF¨ÂǮ‹DÂzæfÂv PÂqYÂmÂi,ÂeÙÂbûçÂ`{çÂ^8RÂ\\ÂYâNÂW•ÂUÂRZÂOW ÂLVÂH„ÂD½qÂ*”{Â0\Â6‹DÂuÂ;jÂ8ž¸Â5±'Â2¢ÑÂPÂÚÂ!&éÂ%m‘Â)¦éÂ-ÍÓÂ1ß;Â5ÔþÂ9­Â=ffÂ@ûçÂDk…ÂG­ÂJº^ÂM‡+ÂPÂR¾ÂSÌÍÂTþúÂU­ÂUÖÂUÂT¼jÂS—ÂR'ðÂPÂNµ?ÂLÒòÂJãTÂHí‘ÂFð¤ÂDë…ÂBÛ#Â@»dÂ>…Â<5?Â9È´Â7!ËÂ<¬Â: Â7ÌÍÂ5{çÂ3 PÂ0Â-ØÂ+{ÁŽbÁ‹‹DÁˆ~úÁ„éyÁ€ÊÁÁxVÁn-ÁcKÇÁWçmÁLQìÁ@í‘Á6$ÝÁ,záÁ$vÉÁ£×Á|îÁxÕÁå`Á%ó¶Á0£×Á>ÐåÁP“ÁcïžÁyß;Áˆ•Á”‘hÁ —Á¬ZÁ·¡ËÁÂ=qÁÌ =ÁÔïžÁÜß;ÁãÐåÁéÂÁî¶FÁò´9ÁõƨÁ÷ûçÁùbNÁú1Á“SøÁº^ÁƒÁ‰©üÁ…/Á€oÁtÄœÁhjÁ[OßÁMÎÙÁ@MÓÁ3SøÁ't¼ÁOßÁ‘hÁÐåÁ¡ËÁr°Á…Á$å`Á4bNÁG•Á]ÎÙÁv~úÁˆ`BÁ•áHÁ£`BÁ°‡+Á½oÁÈÊÁÁÓPÁÝA‰Áå× ÁíG®Áó•ÁøÆ¨ÁüáHÁÿ÷Ï J«ÂâNÁ™\)Á–¾wÁ“l‹Á^5ÁŠ‹DÁ„÷ÏÁ}XÁot¼Á`‹DÁPõÃÁA"ÑÁ1²-Á#G®Á§ðÁ —Áß;Á33Á"ÑÁ 1ÁÁ(ÙÁ>¬ÁVùÛÁr¼jÁˆ(öÁ—ZÁ¦|îÁµ/ÁìÁÐ JÁÛ× ÁædZÁï¥ãÁ÷™šÁþ?}ÂÒòÂë…Âr°Âr°ÂöÉ =Á C–Á´9ÁšZÁ–$ÝÁ‘ JÁ‹ JÁ„(öÁxéyÁh ÅÁVQìÁDÁ1ÎÙÁ ‡+Á =ÁA‰ÀöE¢Àí¸Àî~úÀûl‹Á ÅÁQìÁ3ƨÁO…Án°!Á‡ùÛÁ™ JÁªÁºffÁÉ× Á؇Áä÷ÏÁðhsÁú\)ÂhsÂæf±' ÎÙ KÇ 49 ”{ |îÁ¨“Á¥²-Á¢hsÁž(öÁ˜ß;Á’ƒÁ‹‡Á‚£×Ár›¦Á^~úÁI…Á4^5Áë…Á +Àú~úÀâ~úÀÔ›¦ÀÒŸ¾ÀÝó¶À÷33Á =Á(¼jÁGPÁjjÁ‡áHÁ›1Á® ÁÀ=qÁÑQìÁà÷ÏÁï Áû`BÂÂ|î #× þú¦†%ÂMÓƒÂ6FÁ°ïžÁ®ÐåÁ«¸RÁ§‰7Á¢+Á›\Á“¬ÁŠPÁ€IºÁj(öÁRjÁ: ÅÁ"=qÁ çmÀðÌÍÀÒ{À¾ffÀ¸1ÀÀÔþÀÙÂÁ`BÁG®Á?KÇÁf ÅÁ‡ñªÁ`BÁ²‰7ÁÆÆ¨ÁÙ²Áê¾wÁú ¨ö V PÂ× Â¾wÂÑìÂ!Ë¿}¿}Â49Áº× Á¹$ÝÁ¶bNÁ²hsÁ­¬Á¦`BÁž&éÁ”p¤Á‰QìÁy÷ÏÁ_p¤ÁCçmÁ(ffÁ1'ÀíxÕÀÇ À¬záÀ ‹DÀ¥²-À½XÀç¶FÁÎÙÁ7 =Áb JÁˆC–Á "ÑÁ·©üÁÎVÁâÄœÁõxÕÂýô !ËÂ'ðšÂÂì‹Âí‘“‚ ÂA‰Âm‘ÁÅÔþÁĸRÁÂt¼Á¾áHÁ¹ÐåÁ³ ÅÁª¶FÁ ‡+Á”§ðÁ‡A‰ÁqG®ÁR~úÁ3G®Á =Àò§ðÀÃÎÙÀ¡/ÀŽn˜ÀŽ\À£®ÀÎvÉÁå`Á/C–Á^~úÁˆõÃÁ£jÁ½t¼ÁÖ ÅÁìÎÙÂb wÏ“Âuܬ š Â#Â%ffÂ&aHÂ&ŒJÂ&Â$ÚÁÑë…ÁÑ\ÁÏýôÁÍÁÈ`BÁÁë…Á¹|îÁ¯ Á¢ƒÁ”$ÝÁ„=qÁf‡+ÁC¡ËÁ!KÇÁ33Àʇ+ÀŸ =À„9XÀ{× ÀoÀ¸õÃÀúÀƒÁ(“uÁ[÷ÏÁŠ33Á§VÁÃ÷ÏÁß Á÷¸RÂÛ#ÂiyÂ…Â6FÂ$‹DÂ(—Â+ožÂ-.Â-î˜Â-ÍÓÂ,ì‹Â+hsÁßVÁߣ×ÁÞ÷ÏÁÜÆ¨ÁØÎÙÁÒÎÙÁÊ‘hÁ¿÷ÏÁ²ýôÁ£ÊÁÁ’°!Á€33ÁYûçÁ3®ÁC–ÀÝp¤À¨‹DÀ„¼jÀm`BÀ‚MÓÀ©ÊÁÀìÔþÁ#ûçÁ[C–ÁŒG®Á¬{ÁËSøÁèÀƒÂÀƒÂ ”{Âƨ YÂ'XÂ,ÓøÂ0å`Â3¤ÝÂ51'Â5«Â55?Â3ó¶Â2 7Áí(öÁîáHÁïOßÁî&éÁëoÁåÂÁÝí‘ÁÓffÁƬÁ¶33Á¤Á¸ÁvƒÁLƒÁ$ JÀþ=qÀÀ1À’ÀƒÀxbÀ€Ý/À¤záÀç;dÁ"ñªÁ]•Á®Á±ùÛÁÓ¶FÁól‹Âh±'€Â(€Â/ÂÂ5\)Â9hsÂ<Â=RòÂ={çÂ<¦éÂ:üîÂ8¤ÝÁü“Áÿ"ÑÂqªÂ}ôÁÿ =Áú¥ãÁót¼Áé33ÁÛÆ¨ÁËIºÁ¸ ÅÁ¢ñªÁŒ“uÁkß;Á?ãTÁ"ÑÀç²À±XÀ‘º^ÀŽùÛÀ­Àî—Á'‘hÁdÀƒÁ• Á¹‡+ÁÝp¤Áÿ(öÂÎÙÂ#×Â'|îÂ0Ý/Â8W Â> ÂAûçÂDhsÂEqªÂE@ƒÂDÂAì‹Â? ÅÂÖ  ½q ˆ1 =q ÅÂxÕ–‡ÁóÈ´ÁâáHÁÎáHÁ¸PÁ ß;ÁˆáHÁcVÁ7dZÁÈ´ÀãÆ¨À¼1'À±ó¶ÀÊÐåÁr°Á4¸RÁsC–ÁPÁÃt¼ÁèñªÂ‡ÂüîÂ#ß;Â/£×Â9LÍÂ@êÂF˜“ÂJuÃÂL©üÂMcTÂLÒòÂK+ÂHŸ¾ÂE^5 ÐåÂéyÂffÂ1‹D¢ÑÂ1 ‚ ÂñªÁüÂÁè¸ÁÐß;Á¸1'ÁŸ?}Á‡oÁ`áHÁ8jÁ"ÑÁjÀðbNÁƨÁ´9ÁMÊÁÁ†1Áª1'ÁЛ¦ÁöĜ ^5 ÅÂ+ÓøÂ7× ÂA¦éÂIPåÂNî˜ÂR¡ËÂT•ÂTùÛÂTÂQð¤ÂNó¶ÂK?}ÂÖÂÑìÂ;dÂËÇÂ!5?Â!¾Â5?Â/ÂäZ ^5ÂæfÁìÁÒÈ´Á¹t¼Á¡$ÝÁŠPÁl°!ÁJí‘Á2í‘Á(£×Á/¡ËÁIÊÁÁv-Á™Á¼"ÑÁáĜ´9‹DÂ%¾wÂ3ð¤Â?ô¼ÂI¿}ÂQW ÂVÏßÂZLÍÂ[öÉÂ\ÂZ¬ÂX-ÂTÂÂP¢Ñ¸RÂ"ž¸Â'Â*’oÂ,ùÛÂ-ÓøÂ,»dÂ)^5Â#Š=ÂIºÂî˜Â{Áñ JÁجÁÀ…ÁªùÛÁ—áHÁ‡å`ÁxƒÁml‹Ár{Á„C–Á˜$ÝÁ³ÁÔ Á÷p¤Â ’o¨öÂ.OßÂ<¸ÂGÚÂQjÂXÊÁÂ^ 7Âa@ƒÂb›¦ÂbPåÂ`š Â]¹XÂYë…ÂUiyÂ%C–Â+Â0t¼Â5bÂ8…Â:ffÂ:C–Â7½qÂ2ž¸Â*ïžÂ!V§𠟾Áû§ðÁåÔþÁÒl‹ÁÁ£×Á³¶FÁ©bNÁ¤Á¥$ÝÁ­ãTÁ¾SøÁÕ®Áò&éÂÌÍÂõÃÂ(¨öÂ7=qÂD?}ÂObNÂX~úÂ_ÂdiyÂgNÙÂhXÂg·LÂe«Âbr°Â^NÙÂYwÏÂ,BÂ2õÃÂ9KÇÂ>ïžÂCxÕÂFqªÂGaHÂEâNÂAº^Â:õÃÂ1úáÂ'†%‹DÂùÛƒÂt¼Áó“uÁèÄœÁà\ÁÛ®ÁÛdZÁàãTÁì¶FÁþ¥ã ÀƒÂÏßÂ%²Â3[#Â@aHÂL0!ÂVl‹Â^ÙÂeRòÂiÍÓÂlTþÂm1ÂlÂi¾wÂf=qÂaÓøÂ\»dÂ2ƒÂ:ÂAwÂÏß ڠÊÁ †%²ÂMÓÂYÂ(1'Â3 ÅÂ>r°ÂIÂSƨÂ\ÖÂd^5Âj+Ân¸Âp:^Âp–‡Âo\)ÂlÖÂi 7Âdk…Â_$ÝÂ7ÏßÂ?ýôÂGúáÂOs¶ÂUûçÂ[ Â^TþÂ_C–Â]¯ÂY®ÂS´9ÂLPÂE;dÂ>½qÂ9ɺÂ6•Â4Å¢Â3‘hÂ2+Â049Â.Â,k…Â,]/Â.qªÂ2È´Â9¦Â@ãTÂI€ÂRTþÂZÓøÂbÂhùÛÂm÷ÏÂqOßÂr÷ÏÂrúáÂq}ôÂn±'ÂjÎÙÂfbÂ`®Â<bÂDÅ¢ÂM^5ÂU‰7Â\àBÂbí‘ÂgwÂAVÂJH´ÂS„Â\yÛÂdÓøÂl/Âr.Âvˆ1Ây"ÑÂz%ãÂz DÂy\Ây²Â{oÂ~xÕÂٚ„áH‡nˆƒ‡‰ºÂ„¢Ñ€Š=ÂxcTÂp¬Âjå`ÂgiyÂf$ÝÂf¿}Âh¸RÂk~úÂn‡+ÂqQìÂsxÕÂt²-ÂtÓøÂsÌÍÂq§ðÂn|îÂjqªÂe®Â`^5ÂAËÇÂKÂTG®Â]SøÂeÝ/ÂmŽVÂtÂy?}Â|÷ÏÂj€†%ÂF%‚^5„.˜Â†ïŠ‚ÂŽZ Â‘‚Â’î‘üîÂŽÐbŠ+…Â… Í€<îÂx’oÂrÞ5ÂoiyÂmð¤ÂnÂo¸Âp·LÂrQìÂs†%Ât1Âs¥ãÂrJÁÂoöÉÂlº^Âh´9ÂdÂ^ÓøÂAt¼ÂJ‡+ÂS¦éÂ\š Âe"ÑÂlöÉÂsÖÂy”{Â~.€çð‚q'„ƒÂ…͌ Å”^5—ɺ™bN˜Ó•gm¤Z‹:^Â…ð¤Â[#Â{‰7Âv}ôÂsjÂqò°Âqž¸Âqó¶ÂryÛÂrÍÓÂr¢ÑÂqÄœÂp“Âm™šÂjPåÂfTþÂaÁ‰Â\µ?Â@+ÂHõÃÂQÎÙÂZ‡+Âbå`Âj±'Âq¶FÂw× Â}u€ÌÍ‚âNÂ… Á‡ŽÙŠ«ÂŽt¼Â’½q–ûçš\¬Â›ýô›W ˜wL“øÕÂŽ´¼Â‰bÑ„–‡Â€ ÅÂ{=qÂwVÂtm‘ÂröÉÂrbÂF|îÂN÷ÏÂWXÂ_ožÂghÂn{ÂtffÂz DÂ,‚ Á„— ‡qªÂŠÅ¢ÂŽ™šÂ’»ç–´¼Â™ÓøÂ›bNšï˜~ú”‡+»dŠ»d†b‚ PÂ}¬ÂxØÂun˜Âs ÅÂq‘hÂpe`ÂoJÁÂmûçÂlJÁÂj‡ÂgQìÂcüîÂ`¾Â[ÌÍÂWÂ;MÓÂCMÓÂKYÂSOßÂ[ JÂbiyÂiLÍÂo¥ãÂu~úÂz÷Ï€'ð‚èöÂ…æé‰;çÂŒäZ±'”=ô—ƒÂ˜m˜)y–49Â’áËÂŽ¼jŠH´Â…ýô‚+Â}ð¤Âxß;ÂuÂr'ðÂoþúÂnú‡÷ψó¶Â‰bˆH1†µÃ„‹Ç‚–Â~³3Ây}ôÂt«Âp]/Âlž¸ÂiaHÂfŒJÂcûçÂaPÂ_ ÅÂ\˜“ÂYàBÂVë…ÂS±'ÂP2-ÂLqªÂHuÃÂ,záÂ2ž¸Â8Ç®Â>çmÂDïžÂJÑìÂP…ÂV1Â[[#Â`ˆ1Âe›¦Âj¡ËÂo£×Ât˜“ÂyhsÂ}âN€àB‚[#ƒ|îÂC{çÂHYÂMoÂQ©üÂV!ËÂZ{çÂ^µ?ÂbÖÂf’oÂjÂlõÃÂo>wÂpº^ÂqVÂq =ÂoçmÂnbÂk®Âhð¤Âf%ÂcoÂ`/Â]jÂZƨÂXBÂUÐåÂSffÂPõÃÂNp¤ÂKÌÍÂIÂFVÂBí‘Â?¡ËÂqªÂ;MÓÂ8%¾ ´9Â%H´Â)ØÂ.YÂ2Ç®Â7¸Â;ZÂ?wÏÂCt¼ÂGPåÂK+ÂN’oÂQêÂUÂWÖÂZ¾Â\ Â]XÂ^Â^>wÂ]ÓøÂ\éyÂ[’oÂYéyÂX+ÂVÂSçmÂQƨÂO¤ÝÂMÂKYÂI'ðÂFæfÂD\ÂB¦Â?ˆ1Â<ÑìÂ9øÕÂ6ûçÂ3àBÂ2-Âs¶Â ¶FÂ$ñªÂ)!ËÂ-@ƒÂ1JÁÂ5;dÂ9\Â<ÄœÂ@XÂCÅ¢ÂG+ÂJÂLäZÂOffÂQŽVÂSLÍÂT•ÂU`BÂU®ÂUÂTçmÂSí‘ÂR§ðÂQ'ðÂO}ôÂM·LÂKÝ/ÂIöÉÂHÂF%ÂCöÉÂAÔþÂ?š Â=DœÂ:ÏßÂ8;dÂ5†%Â2±'Â/¿}ÁŒáHÁ‰ùÛÁ†xÕÁ‚ZÁ{;dÁp“uÁdÔþÁX5?ÁJí‘Á=\)Á/çmÁ# Á‰7Á ÎÙÁ—Á~úÁÁ™šÁ p¤Á‰7Á)¶FÁ=|îÁT(öÁm+ÁƒÐåÁ‘\)ÁžÙÁ«÷ÏÁ¸vÉÁÄ"ÑÁÎÙÁØ…Áá“Áè\ÁîéyÁô+Áø`BÁû•ÁýÙÁÿ=qÁÿ× Á’IºÁG®Á‹“uÁ‡$ÝÁ÷ÏÁx¬ÁjéyÁ\‡+ÁM/Á=G®Á-G®ÁÊÁÁ|îÁ&éÀó ÀæéyÀã"ÑÀèÔþÀø£×Á SøÁ33Á1l‹ÁK"ÑÁg™šÁ‚Û#Á’=qÁ¡Á°C–Á¾9XÁË-ÁÖûçÁáPÁêÙÁòÛ#Áù—Áÿ“µ?ÂNÙÂcTÂüîÂ'ðÁ˜PÁ•ƒÁ‘©üÁŒùÛÁ‡dZÁ€í‘Ás/ÁbñªÁQhsÁ>ñªÁ,“ÁPÁ“ÀñG®ÀØIºÀÇ+À¿¥ãÀÃ+ÀÒ§ðÀîVÁ ÙÁ#ÊÁÁ@å`ÁaG®ÁÈ´Á“C–Á¤‡+Áµ¸ÁĶFÁÓbÁà1ÁëPÁõ•Áþ$Ý¡ËÂ}ô°! B A‰Â º^ »dÁŸÄœÁœÈ´Á˜ãTÁ”ÁŽ Á‡¸Á~$ÝÁl JÁX5?ÁC Á-VÁ‡Á1ÀÝãTÀ½ûçÀ¦¸RÀš^5ÀšÐåÀ©G®ÀÆMÓÀñ`BÁ‹DÁ5t¼ÁZE¢Á€£×Á”~úÁ¨ Áº£×ÁÌÁÛáHÁê“Áö›¦Â´9ÂBÂýô ð¤Â%ã¨öŠ=ÂÙÂ¥ãÁ¨ =Á¥9XÁ¡ffÁœvÉÁ–OßÁŽå`Á†1'ÁxzáÁbMÓÁJA‰Á0ùÛÁC–ÀüQìÀÍÛ#À¥ÒòÀ‡"ÑÀiG®Àa‰7Àz\À› =Àɲ-ÁƨÁ(ÙÁR›¦Á~ñªÁ•ûçÁ¬ ÁÀéyÁÔ;dÁåº^ÁõC–ÂhsÂ1' ÂéyÂì‹Â¦Â†%Â?}ÂXÂå`Á±r°Á®ó¶Á«XÁ¦záÁ ;dÁ˜Á=qÁ„r°Ápr°ÁU…Á8ÄœÁVÀû ÀÃSøÀ‘ûçÀTýôÀ £×À OßÀïžÀ[oÀŸC–ÀãdZÁ33ÁJ^5Á|Ÿ¾Á—ÌÍÁ°²ÁÈÁÝp¤Áð®ÂÍÓ¬ÂIºÂ^5ÂgmÂs¶Â“uÂÚÂ^5Â6FÂwÏÁ¼oÁºbÁ¶ÙÁ²=qÁ¬oÁ¤33Áš…Á Á¸RÁe²-ÁEl‹Á#•ÁhsÀÀõÃÀ…/À&éy¿À¿v‡+¿Œí‘¿üí‘ÀfE¢À½/Á ´9ÁA¶FÁzn˜Á™ûçÁµß;ÁÏõÃÁç°!Áüȴ•Âp¤ÂÂSøÂyÛÂ"„Â$‰7Â% ÅÂ%ãTÂ%k…Â$VÁÇõÃÁÆ¡ËÁÄ Á¿ß;ÁºÁ²1'Á¨KÇÁœ9XÁŽ Á{²ÁWçmÁ1çmÁ õÃÀÉxÕÀ‚n˜À ~ú¿6È´=ó¶F>Kƨ¿hsÀ ¡ËÀ–Àû\)Á8È´ÁxzáÁœ‘hÁ»ÌÍÁØÔþÁóÂ%ÂøÕÂbNÂSøÂ#àBÂ( Â+ Â,÷ÏÂ-ÐåÂ-ÖÂ,ïžÂ+t¼ÁÕ ÅÁÔ°!ÁÒçmÁÏzáÁÊ&éÁ§ðÁ¸ÄœÁ¬ZÁ^5Á‹÷ÏÁpùÛÁFéyÁ;dÀß\)ÀŒ¬Àff¾†§ð?mÒò?¦‡+?7KÇ¿c•À^éyÀÝOßÁ/ïžÁvñªÁŸ—ÁÂjÁâ“uÁÿV 7LÂñªÂë…Â'ß;À¾wÀÁ¸Á'ÎÙÁv=qÁ£-Áɺ^Áí+ÂOßÂêÂp¤Â(ùÛÂ0¤ÝÂ6ŽVÂ:ÓøÂ=–‡Â>ûçÂ?-Â>SøÂ<œ¬Â:/Áó Áõ(öÁõÐåÁô©üÁñKÇÁëIºÁâ;dÁÕÐåÁÅáHÁ²ƒÁœoÁƒC–ÁQó¶Ár°ÀÐ(öÀ\j¿EãT?£•@(ö@¡Ë?–$Ý¿»çmÀ©ó¶Á!²-ÁwC–Á§‘hÁÑÝ/Áø• `B JÂ(\)Â2qªÂ:p¤Â@{çÂD¶FÂGG®ÂH\)ÂH#×ÂFÏßÂD“uÂA²ÂØÂ®ÂÐåÂ+Âb§ðÁû“Áï JÁÞéyÁʸRÁ²çmÁ˜E¢Áwß;Á>1Á‡Àë…¿ñ&é?Û#@ ²-@(ƒ?Í‘h¿tzáÀ?}Áß;Á{ÂÁ­\)ÁÛ¬ÂuÃÂÔþÂ$„Â1“uÂ<,ÂDuÃÂJ–‡ÂNº^ÂQ PÂQÖÂQ‡ÂO>wÂLt¼ÂHî˜Â ‰7 JÁÂ_;„Âl‹ÂĜ 8RÂ}ôÁúÊÁÁåÝ/Á̬Á°=qÁ‘í‘Áf9XÁ)®Àßt¼ÀhõÿIxÕ?Ÿ;d@× ?©û翌ÌÍÀ£;dÁ%÷ÏÁƒKÇÁµ…ÁæV 49¨öÂ-7LÂ:î˜ÂE÷ÏÂN{çÂT¥ãÂX¦éÂZ±'Â[ÂYÖÂWr°ÂTÂOýôÂ|îÂBÂff²‹DÂɺÂñªÂ¡Ë š ÂÒòÁé$ÝÁÊõÃÁªÔþÁŠvÉÁV1Á{ÀÄ ÅÀB°!¿3÷Ï>ãSø¼#× À‡ÀÇ =Á8ÀƒÁ¼jÁÁbNÁó|îµ?Â$ãTÂ6\ÂD@ƒÂO™šÂXBÂ^ffÂb8RÂcð¤ÂcÓøÂb)üÂ_:^Â[NÙÂV¤ÝÂ…Â!bNÂ%¯Â)Â+,Â+wÏÂ)xÕÂ$º^ÂæfÂïžÂ(öÁè°!ÁÇ"ÑÁ¥ÄœÁ…ñªÁP ÅÁffÀÌÔþÀ{÷ÏÀ&À4¼jÀ›× Á MÓÁ]C–ÁŸ(öÁÒMÓÂ"ÑÂ.Â-ŒJÂ>ñªÂMYÂXÓøÂa‚ ÂgPÂk$ÝÂl‡+ÂkýôÂiÖÂfaHÂaë…Â\¹XÂ%iyÂ+k…Â0ñªÂ5Ÿ¾Â8úáÂ:xÕÂ9~úÂ5‚ Â. Â#7LÂ8RÂ1Áçß;ÁÆdZÁ§;dÁŠÂÁa`BÁ2“uÁ ÙÀíÒòÀï× Á$ÝÁJ¼jÁ‹²Á¸ñªÁéC– ~úÂ"Á‰Â6¢ÑÂGÅ¢ÂV+ÂagmÂiöÉÂoÐåÂs#×Ât/Âs JÂF 7ÂM[#ÂSs¶ÂW¨öÂYw‚LJ…޸ˆÐb‹<îÂgð¶FÂ’¤Ý–ªœV¢®©»ç¯³¶Â²Ç®Â±Ñì­ Â¥¢NÂMÓ•6FÂŽ.˜Âˆ–‡Â„ÂÎÙ€@ƒÂ PÂ~²Â~™šÂ~ƒÂ}øÕÂ|º^Âz¥ãÂw²-ÂsêÂoffÂjE¢Âd«ÂFûçÂP±'ÂZPÂd[#Âmß;ÂvÖƒ"цKlj‹¿}ÂŽ’o‘ïžÂ–,‹Â›p!¡ŠÁ§É7¬øÕ¯¹Û¯$Z«F%Â¥ Á¶É–Rò¦éŠ¦Â…Ô{‚À¹XÂ~ð¤Â}uÃÂ|}ôÂ{™šÂzožÂxÀƒÂvjÂs_;Âo ÅÂkA‰ÂfXÂ`þúÂCxÕÂL’oÂUËÇÂ^øÕÂgèsÂphsÂxLÍÂ}ôƒƒÂ†ˆð!ÂŒ®ÂŒÍ“µ?˜‘ìÂí£5?§„œÂ©Ý²Â©•¦¦f¡©ü›b•.˜Â5?Š JÂ…àB‚³3€gmÂ}›¦Â{_;Ây«Âx!ËÂvr°ÂtgmÂqÚÂn»dÂk 7ÂfÌÍÂbšÂ]Â?s¶ÂGí‘ÂP€ÂY+Âa\)ÂiYÂpÞ5ÂwÞ5Â~`B‚DœÂ…NVˆyX‹ò-ÂÙ”/˜À ™¢‹Ç¢yÛ Vœ—¢NÂ’\)Â>úˆ©ü„ÎÙ¹ÛÂ~´9Â{ ÅÂxe`Âv-Ât'ðÂr{Âo¿}Âm 7ÂiÝ/Âf8RÂb ÅÂ]¡ËÂXËÇÂ;‡ÂBñªÂJß;ÂRÂÂZ}ôÂaó¶Âi\ÂoƨÂv ÅÂ|wÂ_=qÂe%Âj¥ãÂp1'Âu¿}Â{`B€‰ºÂƒ_;†òˆwLŠSøÂ‹t¼Â‹³¶Â‹ 7‰‹Ç‡m‘„åã‚49Â{ÂzÂuš Âq¨öÂn7LÂk.Âhk…ÂeÌÍÂc/Â`xÕÂ]”{ÂZr°ÂW PÂSdZÂOyÛÂKVÂ-+Â3W Â9‹DÂ?·LÂEÎÙÂKÖÂQPÂW'ðÂ\–‡ÂaáHÂguÂl8RÂqW ÂvhsÂ{TþÂì‹Â÷Lƒ‡+„‚ „Ðb„k…ƒbNÂÕÂØÂ{£×ÂwZÂs5?ÂoZÂkÖÂh¨öÂeÁ‰Âc JÂ`m‘Â]ÎÙÂ[šÂXwÂDÀƒÂJ¸ÂOW ÂTiyÂYZÂ^.ÂbêÂg\Âl{ÂpbNÂtW ÂwÖÂzqªÂ|49Â|èsÂ|ˆ1Â{#×ÂxêÂvVÂrÎÙÂoe`ÂkýôÂh¸RÂe¢ÑÂbÀƒÂ` 7Â]p¤ÂZãTÂXOßÂU§ðÂRÜ)ÂOäZÂL¼jÂIbNÂE× ÂB¾Â#ýôÂ)>wÂ.ƒÂ3Á‰Â8ð¤Â>1ÂC ÂGÛ#ÂL’oÂQ'ðÂUŸ¾ÂYøÕÂ^0!Âb;dÂf 7Âi}ôÂlxÕÂnÓøÂpqªÂq9XÂq&éÂpG®Ân·LÂlš Âj¸Âgl‹Âd¥ãÂaäZÂ_7LÂ\¡ËÂZ!ËÂW¯ÂU=qÂRÀƒÂP.ÂMzáÂJŸ¾ÂGš ÂDhsÂA JÂ=ˆ1Â’oÂ$m‘Â)JÁÂ. ÅÂ2êÂ7Ÿ¾Â<;dÂ@º^ÂE ÂIZÂMyÛÂQwÏÂULÍÂXñªÂ\VÂ_ffÂb =Âd(öÂe©üÂfÂf©üÂf-Âe²Âc”{Âa²-Â_“uÂ]RòÂ[ÂXµ?ÂVjÂT"ÑÂQÛ#ÂOŒJÂM-ÂJµ?ÂH¾ÂEe`ÂB„Â?{çÂ1ÂAöÉÂEÄœÂIn˜ÂLî˜ÂP;dÂSJÁÂV DÂXk…ÂZZÂ[Ç®Â\©üÂ\ýôÂ\ÊÁÂ\¬Â[ÂYš ÂWñªÂV¾ÂT33ÂR6FÂP/ÂN¾ÂLÂIÜ)ÂGž¸ÂEG®ÂBÑìÂ@:^Â=~úÂ:Ÿ¾Â7²Â4záÁ‹ƒÁˆ5?Á„9XÁoÁtIºÁh¬ÁZ°!ÁL(öÁ<ÔþÁ-oÁ`BÁVÁŸ¾ÀéûçÀØr°ÀÎ JÀÌ(öÀÓ¶FÀå7LÁ^5ÁÔþÁ)t¼ÁC\)Á_× Á}ÊÁÁŽ$ÝÁ7LÁ«ÂÁ¹ƒÁÆC–ÁÑå`ÁÜVÁå‰7ÁíÁô=qÁùÊÁÁþ33ÂÂÂéy˜“ÂÛ#Á‘ JÁ›¦Á‰bNÁ„SøÁ|ÐåÁoG®Á`¬ÁO|îÁ=²-Á+¸ÁVÁÀéó¶ÀÌA‰À´ÔþÀ¥™šÀ 9XÀ¦ JÀ·ß;ÀÕÊÁÀÿ+Á\)Á7‡ÁWß;ÁzQìÁŽ¡ËÁŸÎÙÁ°E¢Á¿´9ÁÍçmÁÚÀƒÁæ+Áð&éÁø´9ÁÿÙÂÒòÂu¹XÂÎÙÂ`BÂzáÁ—…Á”%Á¡ËÁŠC–ÁƒÝ/ÁxÙÁgïžÁU‡Á@Ÿ¾Á*õÃÁ°!Àý7LÀÓKÇÀ­Û#À;dÀs•À_PÀfÀ„“uÀ¤ÔþÀÓoÁÙÁ(ùÛÁNÀƒÁvn˜ÁA‰Á¢ÙÁµvÉÁÆÆ¨ÁÖ\Áä²-Áñ(öÁûñªÂŠ=ÂNÙ Oß — 2-Â-–‡Â€ÁŸ =Á›™šÁ—"ÑÁ‘‹DÁŠÀƒÁ‚²-Ár¼jÁ]¥ãÁFbNÁ-`BÁC–ÀñÒòÀ¾áHÀA‰ÀQº^ÀKÇ¿î{¿ë¥ãÀéyÀ[dZÀ¡%ÀãPÁñªÁDvÉÁr5?Á Á¦n˜Á»záÁÎÛ#ÁàXÁïÝ/Áýj‚  ^5 QìÂhs®Â33Â1Â?}ÂêÁ§¼jÁ¤|îÁ ‡ÁšhsÁ“SøÁŠÀƒÁ€¡ËÁiûçÁOÛ#Á3OßÁ =ÀìÀ®ÐåÀk"ÑÀl‹¿gl‹¾¥ã=¥ã¾ÐbN¿Â\ÀR¬À´ ÅÁå`Á9 Ám®Á‘=qÁª¬ÁÂn˜ÁØoÁëhsÁübNˆ1 ¿}ÂäZÂÂ#×Â_;ÂÂÂe`Â[#»dÁ±¸RÁ®ÒòÁª©üÁ¥oÁÝ/Á”ë…ÁŠ ÅÁzí‘Á^Á=çmÁC–ÀîMÓÀ¥ãTÀAG®¿Š^5>üj?ÇP?þ{?Õ`B? ‹D¿®{À =À噚Á,VÁhí‘Á’¸RÁ¯©üÁÊn˜ÁâPÁ÷Û#Â/ šÂ»dÂ#×ÂcT ‹DÂ"®Â#ãTÂ$DœÂ#êÂ"ð¤Á½{Áº¾wÁ· =Á±¾wÁª¥ãÁ¡‡+Á–?}Áˆ¸RÁqë…ÁNMÓÁ'C–ÀûƨÀ§SøÀ)ë…¾’ñª?ÛC–@JáH@z^5@ráH@.éy?6È´À çmÀ¹G®ÁbNÁcãTÁ”“uÁµxÕÁÓ\Áî\)ÂâN ñªÂs¶Â~úÂ"&éÂ&€Â)Ÿ¾Â+œ¬Â,“uÂ,¡ËÂ+çmÂ*‚ ÁÉå`ÁÈZÁÅZÁÀ¡ËÁ¹å`Á°ãTÁ¥^5Á—/Á†MÓÁe¶FÁ:^5Á º^À¶¸RÀ-/>o@' @‘/@¶¬@¼@žŸ¾@8õþ‚\ÀˆýôÁ Á^záÁ–ÂÁ¼ JÁÝÐåÁû‰7 –‡Â{瘓Â& DÂ+í‘Â0VÂ3_;Â5%ãÂ5ÌÍÂ5uÃÂ4G®Â2gmÁØ1'Á×´9ÁÕ´9ÁÑÝ/ÁËÒòÁÃ=qÁ·ÊÁÁ©;dÁ—t¼Á‚PÁU¶FÁ!÷ÏÀ×33ÀRŸ¾<¼j@AÛ#@¯çm@åG®@ø¼j@ã¾w@£C–?âÐåÀ*-ÀüÔþÁXƒÁ™+ÁÃOßÁé¬ÂýôÂÂÇ®Â(ƒÂ0[#Â6ožÂ:Ü)Â=¿}Â?=qÂ?€Â>°!Â<üîÂ:\Áçó¶ÁèÎÙÁè ÅÁåƒÁà‰7ÁؾwÁ͸RÁ¿ Á¬²-Á–‰7Áyë…ÁA\)ÁG®À¶F¿7KÇ@4›¦@¼IºA£×AC–AX@è Å@u`B¿uÀÙ%ÁQïžÁ›°!ÁˬÁõE¢Â Å¢ÂVÂ(Á‰Â3 ÅÂ;\)ÂAš ÂEüîÂH©üÂIËÇÂI•ÂH:^ÂEí‘ÂBâNÁù“Áû™šÁü•Áû‘hÁø JÁñr°Áç9XÁØß;ÁƇÁ®ÒòÁ“t¼Ái¥ãÁ(-ÀÉÊÁÀ²?ô¼j@²^5A“uA& ÅA+G®ASø@º¬?;¥ãÀ´´9ÁK7LÁž\)ÁÓQì JÂúáÂ%›¦Â3G®Â>MÓÂFéyÂMH´ÂQ“uÂSøÕÂT¬ÂSêÂQïžÂNúáÂKB½qÂ÷Ï vÉ ó¶Â ¸Â²Â‡ÁöffÁãl‹ÁˬÁ­ß;ÁŒÈ´ÁR¸RÁ $ÝÀƒ|î>¦éy@ÌÍAÈ´A,~úA<¸RA,A‰@ðj@E¢À”í‘ÁF(öÁ¡¬Á܇»dÂ|îÂ/~úÂ>(öÂI× ÂRÎÙÂYDœÂ]jÂ_vÉÂ_«Â^LÍÂ[¤ÝÂWùÛÂS‹DÂn˜ÂÈ´Âs¶Â¾Âl‹ÂêÂ%ã ¬Â$ÝÁêÛ#ÁËÁ§Ÿ¾ÁKÇÁ4ýôÀÐõÿéº^@17L@àA‰A%®AA•A9©üAýô@IxÕÀƒçmÁFŸ¾Á¦Ý/Áæ%ÂÅ¢Â&6FÂ9ˆ1ÂI%ãÂUs¶Â^¾wÂe@ƒÂi5?ÂjÞ5Âj†%ÂhÂe!ËÂ`º^Â[‘hÂwÏÂoÂ"oÂ%¦Â&»dÂ&iyÂ#‘hž¸Â‡ÂÁ‰ÁëÀƒÁIJ-Á›+ÁcÒòÁƒÀ >/@A t¼A3`BA37LA=q@<ÌÍÀ‘?}ÁR£×Á¯ùÛÁòMÓÂe`Â/%ãÂC‰7ÂSõÃÂ`ÍÓÂj\)ÂpàBÂtš Âu× Âtí‘Âr=qÂn&éÂiÂc!ËÂ#¡ËÂ)˜“Â/bÂ3Ÿ¾Â6ÀƒÂ7ÎÙÂ6hÂ0È´Â'VÂjÂRòÁä`BÁ·®ÁŒA‰ÁG× À÷¥ãÀBÀƒ?Ï\)@¸ÔþAA ;d@Èb?r°!ÀÎñªÁqoÁ¿`BÂ,ÂñªÂ8SøÂMYÂ^OßÂkˆ1ÂuA‰Â{¹XÂ2-€Â~‰7Â{49Âvn˜Âp™šÂj DÂ-¬Â5\Â<‡ÂBLÍÂG“ÂI·LÂIG®ÂDàBÂ;¼jÂ-{çÂ|î²ÁÙ5?Á¬xÕÁ„vÉÁ@Ý/À÷C–À[o?Sø@MãT@m?¹º^À[SøÁ%…Á“ƒÁÖÙ ¢ÑÂ(­ÂAÈ´ÂVÓøÂgí‘ÂuF¨Â+‚°¤Â„JÁ„}ôƒ}‹DÂ}³3ÂwA‰Âp¦Â7MÓÂ@¸ÂH¼jÂP¬ÂW@ƒÂ[›¦Â\·LÂY‚ ÂQ‡ÂC PÂ/Ý/ ÂNÙÁÖ33Á°Á¥ãÁdéyÁ,ƒÀðÄœÀ¥ÊÁÀ“33ÀÊÐåÁ&Á‚IºÁºÔþÁöÎÙ±'Â3¬ÂK}ôÂ_ÑìÂp‘hÂ}¹Xƒ¨ö†¼jˆ2-ˆ6F‡„ÍPÂÛ¦Â|ƨÂu%ãÂ@2-ÂJaHÂT‹DÂ^1'Âf˜“ÂlÍÓÂo¬ÂnÂfÝ/ÂYÑìÂGr°Â1|î£×·LÁébÁÎ|îÁ¹9XÁ¦33Á”C–Á…ÌÍÁ©üÁ‡1Á ÁÀG®ÁìãT‡Â(Â?»dÂUNÙÂh1'Âx P‚T{†ñªÂ‰Ý²Â‹-‹1‰¦f‡F%„&f€€Ây1ÂH =ÂSp¤Â_Âj=qÂtcTÂ|qªÂ€™šÂ€´9Â|\ÂpÍÓÂ`MÓÂLcTÂ7ÎÙÂ%vÉÂr°ÂMÓÂð¤Â,ÂñªÁ÷r°ÁîMÓÁëïžÁôdZÂNÙÂG®Â%dZÂ8ë…ÂLxÕÂ_ÂoÐåÂ~JÁ„þw‰NVÂŒ–Â)yÂŒâN‹aˈå`Â…«ÂëÂ{®ÂN…ÂZéyÂg¡ËÂt0!Â× Â„ÉºÂˆ‰.‡— ƒ*Âx\Âg¼jÂV˜“ÂHšÂ>‘hÂ:èsÂ< 7Â>áHÂ?ƒÂ;bÂ4 ÅÂ,ÖÂ):^Â*öÉÂ1éyÂ<æfÂJyÛÂYRòÂhVÂv”{¡H†ܬŠÁ‰Â/žÂŽ'ðÂ֌0¤Â‰¨ö†fé‚¡ËÂ}bÂSxÕÂ`\ÂnšÂ{Ÿ¾Â„5ÉÀƒÂÙšÂæéÂu?ÂŒk…‡0!€³3Âtœ¬ÂkÂgšÂjVÂr§ðÂ|£×€ó3Â~=qÂr·LÂdk…ÂX†%ÂQº^ÂP›¦ÂTjÂ[î˜ÂeãTÂqšÂ|zჇ®Âˆ‹bÑÂz^ÂŽ=q¾wÂŒ"щ²Â†dZ‚«Â}=qÂV¼jÂd/Âr(ö€)†ؓŒÖ‘‰7”fé• Í“oÂùX‹˜“‡/Â……†£T‹Ÿ;“¼jœ3¶Â Óuž±'––‹÷Ï‚+ÂuÇ®ÂmSøÂjˆ1Âl]/Âqœ¬Ây P€¼j„ä݈‰7‹Oß ‰ºÂŒïžÂ‹Påˆ×Â…´¼Â‚Â|IºÂXIºÂeÄœÂsȴ€÷χÎVÂþú“b–P˜&é—ß;–%ã“Ü)Â’C–Â’ÌJ–Ǯžá˪?}µ’ò»¯¹ D®áH¡}q”³3Š`Ń0¤Â~Â{Â|bÂûç‚Ĝ…Ç+ˆ‰7Šª‹íÂŒ2°Â‹{d‰ۦ‡t¼Â„p!€õ?ÂzTþÂX9XÂem‘Âs#×€~ú‡8RÂc×Â’œ)–ƒ–˜àř֙™™2-™´9œn˜Â¢—¬ǮºhÂÆò°ÂÍ×ÂÊùÛ¿ؓ±‡Â¢¦f–p¤Â=q‡øÂƒ£T‚l‚ٚ„NV†8Rˆ‰’oŠ_¾ÂŠ_;‰ˆ1‡æéÂ…”{‚±ªÂ~ÂÂwˆ1ÂV¶FÂce`Âp‡+Â}ƨ…V‹Qhƒ–”¥ã—”þ™gðš‡+›ªÂÍÓ¢V©j´J=ÂÁ±'ÂÎX“ÂÕ/žÂÒÖÂÈPå¹øR«m‘žœ)”nÂåˆSøÂ…ÎÙ„ýqÂ…O\†;d‡KDˆ BˆyXˆ0¤Â‡7ÏÂ…’òƒT{€”þÂzâNÂt1ÂSûçÂ_ùÛÂlW Âxɺ‚vFˆ#×Â/žÂ‘fé”·L—wÂaÙÂAÍÓÂJ†%ÂS^5Â\1'ÂdÚÂm1'ÂuÂ|{ç´9Â…ˆE¢Â‹¯Âl‹Â“Ÿ;˜JÁÂ=q¢¢Â¥÷L¨T{¨b¦P¢§ðÂb—õ?Â’uÃÂ|î‰C…ؓƒ/Â%ãÂ$ÝÂ|ŽVÂz6FÂw× ÂugmÂE½qÂMVÂTA‰Â[C–ÂbÂh}ôÂn¶FÂtÀƒÂzº^€c׃ƒ†ÀŠ\ÂNVÂA‰Â’²Â”þ”p!“Ÿ;‘ÀƒÂ‹ó¶Âˆ¥`Â…o‚|îÂËÇÂ{\)Âw—Ât[#ÂqxÕÂnÂÂlVÂi:^Âf-Âb× Â_1'Â[:^ÂVùÛÂRwÏÂ1ÖÂ8{çÂ?-ÂEÙÂLk…ÂRØÂYhÂ_{ÂdäZÂjŒJÂp ÅÂu³3Â{Qì€~úƒNÙÂ…ýqˆaHŠH1‹}‹äÝ‹m‘Š+ˆH´Â…ùXƒvÉ€ð¤Â}‡Âxµ?ÂtÎÙÂqZÂnC–Âkk…Âh³3ÂeøÕÂc#×Â`¾Â\ß;ÂY\)ÂU•ÂQ\ÂMOßÂ,«Â2ÀƒÂ8Þ5Â>ô¼ÂDøÕÂJÜ)ÂP˜“ÂV'ðÂ[ŽVÂ`ÐåÂeùÛÂkuÂp!ËÂu¸Âyó¶Â~wÏÂ7Ï‚Ëǃؓ„F¨Â„\ƒ=qÂí€>wÂ|µ?ÂxƨÂtêÂqC–ÂmáHÂjƨÂgå`Âe+Âb‚ Â_ÒòÂ] =ÂZšÂVô¼ÂS—ÂPÂL2-ÂH2-Â'©üÂ-=qÂ2× Â8iyÂ=ë…ÂCSøÂH›¦ÂM¿}ÂR¾wÂWœ¬Â\^5ÂaÂe“uÂiýôÂn2-ÂrhÂur°Âx'ðÂz+ÂzñªÂzàBÂyß;ÂxuÂu§ðÂrÒòÂoÈ´Âl²-Âi«ÂfÄœÂd Âa^5Â^ÍÓÂ\A‰ÂY¨öÂV÷ÏÂT ÅÂQ¬ÂMçmÂJ~úÂFçmÂC"ÑÂ"× Â'öÉÂ-šÂ27LÂ7E¢Â<>wÂA¬ÂEÛ#ÂJxÕÂNöÉÂSVÂW–‡Â[³3Â_¤ÝÂcZÂf¼jÂi®ÂlbÂmÅ¢Ân½qÂnïžÂndZÂm49Âk|îÂicTÂg DÂd•ÂbÂ_œ¬Â].ÂZɺÂXgmÂVÂS†%ÂPñªÂN;dÂK[#ÂHNÙÂEÂA²-Â>'ðÂ7LÂ"ïžÂ'¨öÂ,\)Â1Â5˜“Â:Â>vÉÂBº^ÂFß;ÂJäZÂNÇ®ÂRƒÂV\ÂY^5Â\_;Â^üîÂa"ÑÂb»dÂc»dÂd²ÂcèsÂc+ÂaùÛÂ`n˜Â^¢ÑÂ\­ÂZž¸ÂX„ÂVbNÂT;dÂR =ÂOɺÂMt¼ÂK ÂHn˜ÂE´9ÂBÑìÂ?Ç®Â<–‡Â9BÁ‰ùÛÁ†?}ÁÂÁxõÃÁlÌÍÁ_ =ÁOÎÙÁ?G®Á-º^Á²Á xÕÀïïžÀÏ× À´ZÀŸ\)À’Ÿ¾À®À—¾wÀ«l‹ÀÊÀƒÀôõÃÁVÁ1ß;ÁR1'ÁsûçÁ‹VÁ›ÊÁÁ«ÒòÁº× ÁȬÁÕ33Áà^5Áê-Áò²Áù¸RÁÿ‡+ PÂÂÂë…•ÂËÇÁ›¦Á‹¸RÁ†ñªÁ;dÁuoÁe¶FÁTn˜ÁAhsÁ,í‘Át¼Á™šÀØIºÀ°“ÀŒ¼jÀa&éÀ;ƨÀ-‘hÀ9º^Àb=qÀ“¥ãÀÃ¥ãÀÿdZÁ" JÁG²-ÁnýôÁ‹;dÁžr°Á°¬ÁÁ—ÁÑ%ÁÞß;Áë Áõ¼jÁþÊÁÂ'ðÂ0!Â… 2- E¢Â ËÇÂ ÓøÁ–A‰Á’KÇÁOßÁ‡9XÁïžÁnùÛÁ[²ÁEó¶Á.E¢ÁoÀõó¶ÀÁÒòÀ÷ÏÀF{¿÷P¿Ž{¿5¿M‘h¿·®À'l‹ÀŠ5?ÀÏ;dÁ¥ãÁ;¥ãÁip¤Á‹•Á¡©üÁ¶dZÁÉl‹ÁÚ™šÁéÛ#Á÷33ÂVÂ, !Ë C–›¦Â9XÂ+‚ ÂNÙÁžVÁš$ÝÁ•bÁ޶FÁ†÷ÏÁ{…Áf“ÁMº^Á2¬Á`BÀí‡À®ffÀb~ú¿ã33¾‰º^?\¬?ÀbN?Ç+?t¼j¾¤ZÀ®À—…Àôí‘Á-ïžÁchsÁŒ?}Á¥²Á½(öÁÒ‡+Áå“uÁöQìÂhs“u µ?ÂÙ PÂ_;ÂàB£×¼jÂA‰Á§(öÁ£r°Ážn˜Á—õÃÁáHÁ† JÁtÀƒÁY¾wÁ;33Á‘hÀë+À ¬À-¸¿Z?´Z@;C–@x“u@„Ý/@hr°@ûç>%À/+ÀÄjÁzáÁ] ÁQìÁªxÕÁÅ1'ÁÝ Áò&éÂ8R V§ðÂuÂ_;›¦ÂÛ#Â!1'Â!¶FÂ! ­Á±²-Á®`BÁ©£×Á£A‰Á›%ÁÀƒÁ„G®ÁkoÁI"ÑÁ#oÀóC–À›ïžÀÙ?å`@?KÇ@ŸdZ@ËKÇ@Ý™š@ÑÛ#@¥º^@3C–¾ï ÀOßÁ "ÑÁV=qÁŽë…Á°hsÁΧðÁéSøÂ?} 1' ÅÂ¥ãÂVÂ#Á‰Â&úáÂ)“Â*33Â*ffÂ)ÐåÂ(‘hÁ½ÊÁÁ»¬Á¶å`Á°ß;Á¨ÂÁžMÓÁ‘C–Á|îÁ]Û#Á3xÕÁ~úÀ¤Iº¿ñhs?©7L@Š@Û÷ÏA QìA=qA‡+AC–@¸‹D@`BÀãTÀó33ÁNýôÁ‘‡Á·‡+ÁÙ´9Á÷\)Â`BÂ$ÝÂ/Â#ž¸Â)ŒJÂ. PÂ149Â3²Â3çmÂ3´9Â2§ðÂ0çmÁˉ7ÁÉÆ¨ÁÆdZÁÁVÁ¹jÁ¯¸Á¡ÔþÁ‘OßÁzÐåÁLn˜Á¬À¾5?À V?È1'@¥‘hA=qA.í‘AGïžALÄœA:^5AÎÙ@p¤¾ˆ1'ÀÆÙÁFáHÁ“´9Á¿ÌÍÁæ\) ÅÂ}ô²Â&ÖÂ.›¦Â4¿}Â9F¨ÂKÇÂ=™šÂ;þúÂ9§ðÁÛÁÚxÕÁØG®ÁÔ%ÁÍC–ÁÃPÁ¶p¤Á¥\Á§ðÁoxÕÁ65?ÀíÂÀMó¶?Œj@ª¸RA9XAI&éAmûçA|‹DAp{AF^5A~ú@ ÂÀ“•Á=¸Á–vÉÁÉÁôzá s¶Â“uÂ( Â2aHÂ:²Â@î˜ÂEm‘ÂH7LÂIt¼ÂIRòÂH+ÂEÅ¢ÂBÀƒÁì(öÁí;dÁì¡ËÁéçmÁäÁÛß;ÁÏn˜Á¾¥ãÁ©"ÑÁŽÌÍÁ_ß;Á´9À í‘¾hr°@’ÙA¶FAVMÓA„éyA’ýôA‘ÌÍA~jA69X@ bÀ/l‹Á0§ðÁ˜ÔþÁÒ§ðÂÓøÂÂ&…Â4Â>öÉÂG—ÂN DÂRn˜ÂTçmÂU¥ãÂTæfÂRå`ÂOâNÂLšÁþùÛ ¹XÂ\)Áÿ33Áø1'ÁìñªÁܾwÁÇÁ«ÁЇ+ÁJE¢ÀóPÀ J@7PA-ARŸ¾A‹›¦A¢‘hA¨ïžAšïžAn¼jAo¿Á ¼jÁšE¢ÁÜ(ö ©ü VÂ2¾Â@¶FÂL^5ÂUcTÂ[í‘Â`#×Âb2-ÂbYÂ`Ý/Â^ JÂZ1'ÂU\ £× W ÂKÇÂ/£נ8RÂs¶Áÿ¸RÁê =ÁÍffÁª‡Á…Á,À¦\>¾ùÛ@ÂMÓA=…A‰ïžA«‡+A»ë…A´Ý/A“‡+A3× ?Ü‹DÁbNÁšÀƒÁå¬Ât¼Â*IºÂ>šÂMå`ÂZSøÂc¾wÂjW ÂnLÍÂoÚÂoNÙÂlþúÂiH´ÂdÂ^öÉÂjÂ{çÂæfÂLÍÂ;dÂ)üÂ|îÂ\ÂÈ´Áó…ÁÍ-Á ffÁaXÁÀƒÀÐå@\jAÔþA€XA­oAÈýôAÊKÇA¬ A`ÌÍ@qG®Àü¬Á›\ÁíãT Â4p¤ÂJ“Â[0!ÂhqªÂrC–ÂxâNÂ|Š=Â}†%Â|5?ÂyÂtTþÂn–‡Âh¬Â¡ËÂ%>wÂ*VÂ.|îÂ1)üÂ1²-Â/OßÂ)$ÝÂ^5Â^5ÁòQìÁ¿çmÁŠxÕÁ.´9À¡`B?:Ÿ¾@á%A` JA¦ A̧ðAÕŸ¾Aº“Ayp¤@˜bÀô¬ÁŸÆ¨ÁøV ÔþÂ>aHÂUÅ¢Âh!ËÂv5?€6Fƒ‡+Â…0¤Â…aH„Qì‚BÂ~áHÂx+ÂpÂÂ+VÂ2[#Â9LÍÂ?m‘ÂD“ÂF{çÂE•Â@F¨Â5p¤Â$8R ”{Áà Á£õÃÁXŸ¾Àñp¤À-@}A/PA’;dA¿{AÌ´9A²²-Ai©ü@hr°Á§ðÁ«xÕÂõÃÂ)¸ÂH¦Â`ÐåÂtwÂÉ7Â|ÂYÔþÂf½qÂt&é€âч˜“Âó3“­‘˜ŒÍœwLŸŒJ¢/žÂ¥ò©"ѯožÂ¸ò-ÂÆ ÅÂÖ&éÂåÕÂï«…ÂïbÂäT{ÂÓæéÂÂhö²mÂ¥3¶Â›b“ã×ÂJÁÂŒ¹X‹—‹På‹gm‹vÉ‹6ÉŠ{d‰/‡Oß„èö‚VÂ}®Âv¸RÂTffÂ`+ÂlNÙÂx’o‚Pbˆ ÇÂKD‘éü•ܬ™C–œoŸãפI7ªRo²‰7½‰ÂÈå`ÂÔ%ÂÛ;ÂÛm‘ÂÔ¬‹ÂÉ#T»Û#®ô9£¹Xš±ªÂ“ð¤ÂA‰ÂŒF¨ÂŠ‹Ç‰ž¸Â‰ˆ¢Nˆ‡%Â…ž5ƒÁ‰ÂuÃÂ}\Âw‘hÂq“ÂN†%ÂY1'Âd ÅÂo¾Âyë…‚;†ê‹AÂ!HÂ’¦f–ß™º^ž£’òªožÂ²’ò»F%ÂÇÂÈuÂÈ¡ËÂÄp¤Â¼ž¸Â³ƒÂ©) ߘoÂ’mÂüîŠä݈Ö‡zᆂ…¨ö„¸ÕƒŒJ‚ Ó€3¶Â{þúÂvð¤ÂqXÂkQìÂHl‹ÂRhÂ[æfÂe¿}Âok…Âx¸R€»d„Ç+ˆÂŒƒÂqªÂ“—33œ®Â¡¬§ô¼Â®Tþ³Û#·^¸Â·ó¶Âµ[#°"Ñ©[#¢%šþú”ÌJ®˜Â‹¯ˆ²-†…¢Â„샫‚‹ÇÂcT€ìÂ}+ÂyZÂu¦ÂpTþÂkÂexÕÂBF¨ÂJûçÂSÒòÂ\§ðÂeVÂm¹XÂu³3Â}49‚!ËÂ…‰ÂˆÙÂŒQì ”G+˜æfÂǮ¢…¦‚ © Í©›¦Â¨¤ÓÂŸ× Âšƒ•/žÂIºÂŒ߈—…؃³¶Â‚ €˜“Â~œ¬Â|Ây2-ÂvÂrcTÂnNÙÂiÇ®ÂdÝ/Â_²Â<2-ÂDhÂL+ÂS÷ÏÂ[È´Âc^5Âj¤ÝÂq“uÂx0!Â~”{‚s¶Â…¯žÂ‰þÂŒ²-€ƒÂ”YšÂ—ô¼ÂšíœØÂaËœp!š(ö–çð“{Â#‹NV‡ãׄô¼Â‚ƒ€~úÂ}ž¸Âz­Âwî˜Âu/ÂrDœÂooÂk‡+Âgœ¬ÂcRòÂ^´9ÂYËÇÂ6F¨Â=ffÂD–‡ÂK¿}ÂRÎÙÂY°!Â`TþÂf¸RÂlÝ/ÂrÖÂx»dÂ~«‚_¾Â…}ˆª‹ÃÂŽ–‡ÂãTÂ’gmÂ’ð¤Â’m‘Âó3ÂŽ¸R‹þw‰V†$݃l€üjÂ}¸RÂz DÂvÑìÂsæfÂq²ÂnQìÂkcTÂh;dÂdɺÂa 7Â\ùÛÂX¡ËÂT =Â0\Â71Â=Š=ÂD%ÂJk…ÂP­ÂV¿}Â\Ÿ¾ÂbOßÂgÙÂmIºÂr´9Âx"ÑÂ}’oÂvÉ„–†L͈&é‰hö‰ó¶Â‰¼jˆÎV‡KÇÂ…^5ƒ5ÀþúÂ}±'Ây±'Âv PÂrÄœÂoÄœÂlõÃÂj9XÂguÃÂd’oÂa}ôÂ^-ÂZ™šÂVÂÂR­ÂN`BÂ+‡Â0ùÛÂ6äZÂ<È´ÂBš ÂHNÙÂMÞ5ÂSDœÂX„Â]Ÿ¾Âb ÅÂgPÂliyÂq/ÂuɺÂz‡Â}æf€}–‡Â‚$Z‚!Ë•€”þÂ~uÃÂ{OßÂwô¼Ât”{ÂqPåÂn;dÂkVÂh˜“Âeò°ÂcRòÂ`¥ãÂ]ÙÂZáHÂW´9ÂTMÓÂP¯ÂLØÂHÐåÂ%Ý/Â+?}Â0£×Â6Â;RòÂ@‹DÂE¤ÝÂJ›¦ÂOp¤ÂT%ãÂX¼jÂ]8RÂa—ÂeÐåÂiÖÂm‹DÂpÏßÂs|îÂup¤Âv’oÂvÖÂvG®ÂtþúÂs ÅÂpØÂnPåÂk¬ÂiÂfjÂcâNÂahsÂ^ó¶Â\xÕÂYêÂW=qÂTgmÂQbNÂN)üÂJÀƒÂG%ãÂC`B æfÂ%ÔþÂ*ÄœÂ/¯Â4PÂ9VÂ>ÂB—ÂG DÂK`BÂO–‡ÂS­ÂWŸ¾Â[hsÂ^öÉÂb9XÂeÂgwÏÂiC–ÂjhsÂjáHÂj²-Âiî˜Âh¬Âg1Âe¾ÂcVÂ`çmÂ^¶FÂ\‚ ÂZIºÂX1ÂU·LÂSMÓÂPÄœÂN{ÂK8RÂH/ÂDøÕÂA˜“Â>bÁˆE¢Á„¬Á~9XÁrr°ÁdÝ/ÁUt¼ÁDVÁ1²-ÁÒòÁ 33Àèå`ÀÀ›¦À›t¼ÀvÈ´ÀE`BÀ&¸RÀÈ´À01'À\¬À‘ûçÀÂ$ÝÀý¸Á ÅÁD£×Áj‹DÁˆC–Áš¸RÁ¬;dÁ¼~úÁË^5ÁؾwÁ䛦ÁîõÃÁ÷× ÁÿE¢Â¨öÂÂÂÂì‹ÂŽV¶FÁùÛÁ‰²Á„G®Á{ÂÁlÀƒÁ[xÕÁG÷ÏÁ2jÁ‡ÁzáÀÒ—À ÔþÀc× À´9¿›Æ¨¿•¾o²¾ß¾w¿”›¦À=qÀ„ÄœÀÉãTÁ ‡+Á7²Ád1'Áˆ?}Á•Á±•ÁÃõÃÁÔ\ÁãXÁðQìÁû‰7†%Ât¼Â ˜“ ýô ±'¾wÂ7LÂ(öÁ”ÄœÁOßÁЏRÁƒáHÁwl‹ÁdIºÁNQìÁ5¥ãÁƒÀúÙÀ¾E¢ÀG®À ¸¿ xÕ?Z¬?ìÌÍ@E¢@ƒ?Âñª>+¿ðA‰ÀXÀë Á(£×Á]?}ÁˆPÁ¡;dÁ¸bÁÌÄœÁß;dÁï~úÁýŸ¾ÂÜ) í‘Â\ÂKǰ!ÂKÇÂ1'Âp¤Â¾ÁœÎÙÁ˜bNÁ’¬Á‹…Á‚ƨÁp¬ÁXE¢Á<^5Á&éÀö=qÀ®{ÀH Å¿Z^5?¡ë…@EÂ@"Ñ@¨£×@«dZ@”£×@G ?K…À jÀµ™šÁ•ÁUãTÁ‰\)Á¥í‘Á¿õÃÁ×33Áë£×Áýn˜Â_; ÚÂ9X‡+ÂÒòÂ+¢ÑÂNÙÂE¢ÂŸ¾Á¦G®Á¢bÁœhsÁ• Á‹ó¶Á€ÄœÁfÝ/ÁGÂÁ$ZÀúÀ¥VÀ“u>ÍÒò@Cƨ@­@é¡ËAbA ®A¥ã@Ò5?@zŸ¾>ÎVÀo ÁIºÁNQìÁŠë…Á«ýôÁÉ—ÁãPÁú J³3Âð¤ÂÚÂÂô¼Â#C–Â%Â&ÂÂ'"ÑÂ&½qÂ%®Á±VÁ­\Á¨33Á ûçÁ—§ðÁ‹ó¶Á{OßÁY?}Á1©üÁÝ/À§+¿ø´9?µÂ@–Ÿ¾@öùÛA#PA?p¤AKKÇAD“A(MÓ@ð¬@ZŸ¾¿¿ß;ÀÝ/ÁF¼jÁÁ³Æ¨ÁÕQìÁò&éÂ^5ÂÐå¢ÑÂöÉÂ%àBÂ*n˜Â-²-Â/Á‰Â0·LÂ0´9Â/Û#Â.KÇÁ¾ ÅÁ»oÁ¶MÓÁ¯ƒÁ¦VÁšl‹Á‹vÉÁrffÁFýôÁÔþÀ¹7L¿üÌÍ@Äœ@ÀAE¢AP‹DAwº^A†A‰A…=qAo A:@ÜbN?Š~úÀ¬Á?"ÑÁ‘IºÁ½“uÁãvÉ¢ÑÂ÷ÏÂ-Â#bÂ+JÁÂ1m‘Â6 7Â9/Â:ùÛÂ;Š=Â;1Â9ž¸Â7vÉÁÌÊÁÁÊÈ´ÁÆýôÁÁÁ¸jÁ¬¾wÁ‹DÁŠp¤ÁfIºÁ/G®Àà¼jÀ+¥ã?øb@Õ&éA4“Av¸RA–“A¦º^Aª1Aß;A¶FA-©ü@‚^5Àf$ÝÁ6ñªÁ–=qÁÉ…Áô/ ‹DÂéyÂ%ß;Â/ÐåÂ7ì‹Â>@ƒÂBØÂEÈ´ÂG1'ÂGwÂx.Âr%Âk%ãÂRòÂ7LÂ"‡+Â%Þ5Â'¹XÂ'yÛÂ$bNš Â7LÂTþÁÕ"ÑÁž%ÁGhsÀµÊÁ?@åOßAw¶FAɺ^B ÄœB%ÌÍB,§ðB™šAáãTAUoÀgÎÙÁž‡Â\)Â,‘hÂJ2-Â`œ¬Âr‡Â¨ö„Ï߈¢Â‰ˆ1‰~úˆ$ÝÂ…½ô‚\Â}±'Âuš Â%ÎÙÂ,•Â2ýôÂ8”{Â<½qÂ>³3Â=~úÂ8Â,í‘ÂêšÁÁIºÁxÈ´Àÿ²¿ÿ²@rn˜A:A±º^B¬B0E¢B?–‡B/¥ãBš A†b¿ÖéyÁš• 7Â4ÌÍÂUüîÂnþúÂ!HˆxR²°Â߾’)‘/­ÂŒŸ¾ÂˆÆ¨Â„iy‡+Â2—Â;s¶ÂD5?ÂL\)ÂS/ÂW¯ÂX—ÂT[#ÂI0!Â5,ÂùÛÁßÒòÁŒƒÁ IºÀ)º^@¸RAÎÙA›ƒB†%B4‚ BH?}B6ÐåBƨA‰Sø¿ßß;Ážó¶Â ¸RÂöÉÂ#F¨Â=qÂ\)Â%—Â:¹XÂS‡ÂlŸ¾ÂƒÂ¨Â™¬‹Â¢Lͨgm«¿}¬iyª¸Õ§*¢DœÂœ–EÂÝ/ÂnbÂ:^ÂŒ49˜%¤:^¯î˜Â¹¹Û¿¼îÂÀ¹­‘¬ò°ÂœœÂŠO\ÂwÖÂjbÂrô¼Â‹Rò¦k» =·š ÂŸËDÂ…záÂfl‹ÂT«ÂQ¼jÂXÖÂf=qÂwÛ#Â…ß;¢™q'¡J=¦ó¶Âª²ÂªÊÁ©@Â¥ê¡D›À•½q†¨ÂqÞ5ƒ´ÂŽ.˜Âš5?¦«…²½ô½)ÂÄìÂÅó¶ÂÁ߾¸]/«z^žq'•G+”²Â¡€Â¿Ÿ;Âê¨ÃlJÃÀƒÂÜšµ`B˜§m†×Â{DœÂuožÂxÔþÂq'ˆ™³¶Â˜ BŸm‘¤n§E§å㦂£t¼ÂŸ%ã™ûç”NÙÂŽdZÂr¼jƒNÙÂŽ;ç™÷Ϧ±Ú¼ÂÃ`BÂÆZÂÄeã¾#µcT­@ƒÂ©œ)¯YÂÄxÕÂî~wÃÛ#Ã%ðåÃë…ÇÂÛÑì·•Ÿ\ÂÈ1‡¤ZÂ…†¿}‹B ‘B —‡®Â¡B£¤Ý¤#×¢Þ5 œ*—höÂ’"NÂŒ–Âq[#‚2-ÂŒ’o—ž¸Â¢ô9­çð·„¾¦éÂÂTþÂÂ/¾Ôþ¹üî¶X“·ƒÂÂ1ªÂÜ¢NÃÌ‹Ã&¹Ã1î˜Ã'vFÃH´Âõ‰ÂÍð¤Â±åž`BÂ’”þÂŒÍP‹¯ÂÌÍ‘Á‰Â–SušŽVÂÇ+Ÿš ÂŸâNž«œ%㘓øÂ”=qÂcTŠ=ôÂnbÂÞ5‰Š=“¨sÂï§Ï\°ˆ1·DœÂ»[¦Â¼¥`»¾wº¾Âº\¾œ)Â˸ÕÂæzáà ë…Ã%9ÛÃ,*=Ã$QhÃãTÃãÂÚó3½«…Â¨ÓøÂ› Ó“,‹Âò°Â1Â’¬Â• Ç—ó3š33›iy›höš0!—Ü)”²Â«…ÂŒ;ç‡~wÂiDœÂyž¸Â…‡+ÂŽœ)—½q yX¨>ú®{d²ƨµ;¶{¶Û#¹A¿ BÂÌÑhÂãú^ÇðÃàÃ#„œÃ!%Ã|¬ÃËÂÞ‹DÂÃ1'®Õ §m—Ĝ“%㑦fÂ’"Ñ“œ¬Â•KD–ž5—8R–çm•Ÿ;“n˜Âu?ŒܬˆÏß„vÉÂcbNÂr49€éyˆô¼ÂùÛ˜ BŸ€ƒÂ¥:^©“u¬ B®ܬ±8Õµ Ç»þúÂÇàBÂÚ;çÂó<îÃoÃBÞ¸Ã[#Âõ ÁÂÙÐb§𰀃£3¶ÂšA”ïÂ’Z Â‘/‘åãÂ’ŠÁ“ ͓’vɑŽýqÂŒ;çˆñ'Â…=qÂ@ƒÂ\ÍÓÂj¬ÂwýôƒòŠÂޖڠœ“ cףئڠª/®‘ìµNÙ¿[#ÂÍOßÂÞ¢ÑÂð‡®Âý^¸Âÿ+…ÂôÏßÂã‰ÂÏ|j½yÛ®yÛ¢âÑš••&f‘úáÂhsÂÍP¡HÂyX 7ÂŽ!HÂŒ¨öŠœ¬Âˆ1„þú™šÂ{áHÂUÚÂa¾wÂn%ÂzuÃ\)‰8RÂŽž¸Â“j—‘h›1'ž–¢?}¦ÍÓ¬ì‹Âµ!H¿‹ÇÂËzáÂ×¢Âß{Âà©yÂÚ÷ÏÂÏô9²-µ|î©Ê= >ú˜ÿ}“àÅÂ…ÂŽyXÂG+ÂŒ„œÂ‹Û#‹ Á‰çmˆX“†W ƒæéÂÂ{çmÂu+ÂNÇ®ÂYaHÂd@ƒÂo/Âyò°Â‚"N†ò°Â‹V‡ÂJ=Â’èö–jš$Ýž~ú£Úªs3²33º~úÂÂÂÇF%ÂÈ€ƒÂÅKD¾{dµª¬LJ£„œÂ›øÕ•ì‘]/ÂŽ)‹߾ŠV‰1'ˆ-‘‡‡Â…Ç+„'ð‚/žÂ¾wÂzzáÂt®ÂnvÉÂGÖÂQ9XÂZÜ)Âd„Ân Âw&éÂȴƒçð‡Ÿ¾Â‹¾ÂŽåÂ’*–*šÅ ÙÂ¥áË«Ǯ°õ?´qªÂµk³—¯U©€Â¢öFœ†%–·ÏÂ‘ÓøÂ푊ò°Âˆ¸R‡´Â…«…„oƒ)ü½q€Â|OßÂwæfÂröÉÂm“uÂgÒòÂ@ïžÂIe`ÂQ÷ÏÂZ‰7ÂbõÃÂk¬ÂrâNÂz9X€“uƒä݇+ЉºÂŽ#×Â’ò–YšÏߟ"Ñ¢ÑìÂ¥MP¦¾Â¥)¢p!ž’òš Ç•bÑÂÿ} Å‰âN‡A‰Â…'ðƒs¶Âþw€¤ZÂ~Š=Â{‘hÂx=qÂt{çÂpG®Âk¥ãÂf ÅÂaIºÂ:_;ÂAõÃÂIŸ¾ÂQC–ÂXɺÂ`“Âg¾ÂmÖÂt@ƒÂzs¶Â€H´ÂƒbN†™‰øRÂyXÂûç”E—˜å㙢љ!H—wÏ”éü‘ɺŽp¤Â‹(sˆ#TÂ…|jƒ9ÛÂQhÂ\)Â|m‘Ây£×ÂvÐåÂsÏßÂp†%ÂläZÂhäZÂdˆ1Â_ÙÂZâNÂ4²Â:ó¶ÂAÔþÂH°!ÂOqªÂV1Â\hsÂbŒJÂhvÉÂn6FÂsÝ/Ây„Â>w‚ˆ´Â…u?ˆKÇŠäZ ÇÂŽŒÍÂ>úÂìÂŽhÂŒe`Š?}‡ڠ…iyƒu€ïÂ~ DÂz¥ãÂw—ÂtÁ‰ÂqþúÂo0!Âl8RÂiÂe†%Âaº^Â] ÅÂY@ƒÂT¡ËÂ./Â4]/Â:“uÂ@ÂÂFÜ)ÂLÔþÂR¢ÑÂXBÂ]´9ÂcÂh2-ÂmVÂrs¶Âwˆ1Â|€œ¬Â‚¼î„€Â…Ĝ†r-†}ôÂ…î˜Â„ۦƒdݰ¤ÂÖÂ|+Âx¹XÂu„ÂrŠ=ÂoÀƒÂmoÂjiyÂg®ÂdÌÍÂa¶FÂ^aHÂZɺÂVïžÂRØÂNŠ=Â(”{Â.2-Â3ÓøÂ9n˜Â>øÕÂDhsÂIµ?ÂNÜ)ÂSÝ/ÂX½qÂ]Âb.ÂfÄœÂk?}ÂoŽVÂs•Âw.Âz-Â|gmÂ}¾wÂ~"ÑÂ}œ¬Â|JÁÂzSøÂwêÂu?}ÂrzáÂo¹XÂm DÂjuÃÂgñªÂet¼Âbî˜Â`QìÂ]\ÂZ²ÂWs¶ÂTbÂPs¶ÂL ÅÂH²Â#JÁÂ(jÂ-‹DÂ2¦éÂ7´9Â<«ÂA…ÂFA‰ÂJÜ)ÂOXÂS·LÂWùÛÂ\¬Â`¦ÂcæfÂgiyÂjŠ=Âm)üÂo.Âp‚ Âq ÂpþúÂp?}Ân÷ÏÂmG®ÂkPåÂi/ÂfùÛÂd½qÂbÂ`@ƒÂ]÷ÏÂ[›¦ÂY#×ÂV†%ÂS¼jÂP¿}ÂMbÂJ-ÂFš ÂBÝ/Á†jÁÒòÁx›¦Ák™šÁ\\ÁK|îÁ8r°Á#¡ËÁ \)ÀìIºÀ½OßÀ…ÀIûçÀA‰¿ó¶¿ 1¾Ç®¿0£×¿¼¬À/\)ÀŽ~úÀÑp¤Á£×Á7¥ãÁaçmÁ…ë…Áš Á­bÁ¾‡+ÁÎZÁÜÁèûçÁóÔþÁý“Âiy‰7ÂöÉ º^ áH yÛ ‘hÁŒ$ÝÁ‡QìÁffÁtŸ¾Ácó¶ÁP¸RÁ:éyÁ"¸RÁjÀÙVÀŸ¥ãÀM¸¿Á©ü»£× ?›¥ã@ñª@Äœ@ n˜?ª^5½å`BÀß;À“¥ãÀîn˜Á(E¢ÁZ~úÁ…ë…ÁdZÁ³¸ÁÆÙÁØÁè¬Áõ¾w¼j±' Ĝ  Âs¶Â'ðÂ.•Âp¤Á“ =ÁŽoÁ‡Ý/Á€A‰ÁnIºÁXå`Á@9XÁ$^5Á‘hÀÈ´9Àƒo¿ñë…>~ùÛ@ ?}@vff@¡G®@´“u@±‰7@•ûç@C ?-‘hÀt¼À·"ÑÁ›¦ÁR§ðÁ†|îÁ¡È´Áº¥ãÁÐÛ#Áär°Áõ\Â-Âzá ¿}ÂÂXÂÄœÂ\)Â1'ÂW ÂäZÁ›E¢Á–SøÁó¶Á‡÷ÏÁ|^5ÁdéyÁIdZÁ)¶FÁ JÀ½ÂÀT“¿(ö@‹D@’Ù@ØÌÍA"ÑA¬AzáA Ù@Ú~ú@&é>æffÀlZÁ›¦ÁJÈ´Á‡÷ÏÁ§ÀƒÁÄ ÁÜó¶ÁòƒÂb ‰7ÂE¢ÂÖÂF¨Â¤Ý ýôÂ"hsÂ"ùÛÂ"ÊÁÂ!öÉÁ¥VÁ SøÁ™ýôÁ‘ÎÙÁ‡‰7ÁuÛ#ÁW¡ËÁ4$ÝÁ hsÀ»PÀ01'?ff@vff@á²-AÐåAC®A[p¤Abn˜AVA5¸A§ð@nE¢¿¨ÔþÀØr°ÁC|îÁŠãTÁ¯ß;ÁÐ =Á땊= ‘h“Â>wÂ!Â%¨öÂ)Â+9XÂ,aHÂ,—Â+ûçÂ*­Á°‘hÁ¬OßÁ¦KÇÁž33Á“´9Á†záÁlr°ÁEhsÁ²ÀƇ+À$(ö?­p¤@­hsAýôAR\A‚C–A“ƨA›5?A–‰7A„ÄœAL~ú@ó =?¹XÀ¦ñªÁ=™šÁó¶Áºí‘Áß"ÑÁýIºÂ E¢Âô¼ÂÂ&‹DÂ,¡ËÂ1KÇÂ4“uÂ6ŽVÂ7YÂ7“Â5ò°Â4VÁ¾ Áº‹DÁµ1'Á­‘hÁ£?}Á•ÊÁÁ„ÀƒÁ_Á-oÀä9XÀ<›¦?Ó÷Ï@ÑVA7¥ãA°!A¢ë…A¼AÉC–AÇ£×AµdZA’•ABn˜@•¡ËÀ`bNÁ9çmÁ—ó¶ÁÉÎÙÁò"Ñ KÇÂ¥ãÂ!äZÂ+iyÂ3SøÂ9¡ËÂ>SøÂAp¤ÂC{ÂCaHÂB†%Â@³3Â>“Á͇+ÁË?}ÁÇÁÀVÁ¶¶FÁ©“uÁ˜OßÁ‚\)ÁN‡+Á ™šÀ„r°?’-@Û+ALbNA•bAÀ7LAã7LAøñªAüÄœAëÎÙAʼn7A‹ñªA¿ÆÁ8IºÁ£bNÁÝ5?ÂÍÓÂó¶Â#ÓøÂ/‰7Â9ÂAÄœÂH>wÂLãTÂO¸RÂPÝ/ÂPƒÂNäZÂL=qÂHÇ®Áß=qÁÞ›¦ÁÜÁÖãTÁΣ×Á‰7Á±ÐåÁ›®Á~áHÁ9?}À͇¿Sø@¾E¢ALMÓAéyAÔ ÅBÛ#B½qB:^B1Aþ¶FA½ãTAQ…?dZÁ6{Á±™šÁô÷ÏÂÍÓÂ$®Â2î˜Â? DÂIp¤ÂR+ÂXž¸Â]Â_záÂ_ó¶Â^Á‰Â\.ÂX„ÂT =Áó7LÁô¾wÁôbNÁñ‰7Áër°ÁáIºÁÒ‡Á¼ÐåÁ r°Áxr°Á bÀfùÛ@Z¬A- A”®AÕr°B "ÑB#t¼B1PåB049BxÕAø33A–Ôþ@‡\)Á-`BÁÀ‰7ÂàBÂ"­Â5RòÂCõÃÂP„Â[]/Âd@ƒÂjÙÂnþúÂp¾wÂpPåÂn DÂjKÇÂeožÂ_Ǯ¶FÂØÂ ÅÂ:^º^Â!ËÁù¼jÁæ“uÁË`BÁ¦Ý/ÁqC–ÁvÉ¿q&é@ϲAc‘hA¸ÂB+B(ïžBB>wBJÇ®B?H´B¸AÑn˜AÁãTÁ̸RÂr°Â3ˆ1ÂGjÂV¾wÂcí‘ÂoLÍÂxp¤Â~éyÂDœÂ³3€éyÂ~:^Ây‡ÂrÔþÂk× ÂÞ5«ÂÈ´Â× Â_;ÂÎÙÂ{ç œ¬ÂDœÁÜÙÁ¬ÊÁÁd¬ÀÓ®>¡G®@Ø“Aqº^AÖSøB…BGTþB`W Ba_;BE²-B ‘hAzVÀ̬ÁÐÌÍ ÔþÂCÖÂZVÂjÍÓÂxøÕ‚}ô‡,ŠG+‹¸Õ‹–‡ÂЇ„„#×€:áÂwþúÂð¤Â#¸RÂ) DÂ-‚ Â0“uÂ1“uÂ/¸RÂ*oÂt¼ÂDœÁ陚Á§ ÁAÂÀ©©ü¿NÙ@»"ÑAŸ~úB jBA|îBrB‚ñ'Br€B8¨öA¿“¿ðƒÁÉt¼Â'çmÂQ®ÂlVÂ8R‡ožÂݲ’¬•š–— •ȴ“yX–‹À†ýqÂú^Â+»dÂ3ɺÂ;³3ÂC%ÂI¾ÂM-ÂN+ÂJäZÂAÑìÂ0 ÅÂÁÕ…Át¬ÀÞáHÀU‘h@– JBN¾wBs…BFÄœB‡É7Bš]²B[#Baµ?Aý¥ã@4“Áºó¶Â*²-Â\XÂ|šÂ‰KDÂ’%`™,ž/ ò°Â¡r-Ÿèsœ¶É˜Oß“¸Â|˜Â9ò°ÂD‹DÂOffÂZ1Âc¯ÂkDœÂo\)Ân2-Âe\ÂR'ðÂ/ÁòVÁk¥ãÀS•?È´AéyB˜/BŸŽVBlì‹BÔH´BØÈ´B¤ÕBuÅ¢B Äœ@œÌÍÁ±›¦Â+49Âc>w„W ‘国ô£™¨ùX«©y«µÃ©s3Â¥bN  P™ó¶Â“yÛÂŒéüÂH0!ÂU‡+Âc¢ÑÂr½qÂ…µÃ‰}‰áHÂ…$ZÂr PÂE1'Âp¤Á<(ö@K @àÄœ@ß A‡VAêë…B©üCD„ZC&‚ÑB¨»dB_1AîE¢@XÁ¹IºÂ,º^ÂgwŠvÉ—1ªÂ¥6É´(sÂÃ6FÂÐ÷LÂÛzáÂàËDÂßÛ¦ÂÙTþÂϨsÂÆ²°ÂàÅÂÍÅÂñÙÃÞwBô-CúCúÂ,aHà šÂçaH¿6F¤ÌJ•ìÂŽ\ÂÇ+‘øR˜qªÂŸlÂ¥ž¸Âª7ϬÅ­+«‘h¨LÍ£Ĝž]²Â˜r-Â’G+Ây؇bNÂ’ó¶ÂŸ{d¬˜“¹”þÂÅTþÂÎu?ÂÓ®ÂÔp!ÂÑffÂÌ‘hÂɸÂËhsÂÙßÂý0¤Ã»çB˜›¦CúCúÁ—ÃèöÂøÂÎ0¤Â±ƒ–ŸSu•¼jÂ’ÍP”\)˜YšÂ#T¡“u¤ì‹Â¦Á¦èöÂ¥r-¢“už—™ÍP”}qÂŽäÝÂsËǃ\¬Â¨s˜²Â£áË®޸¸ÃÂÀž5ÂÅ©üÂǬ‹ÂÇG®ÂÆbÂÆ€ÂËéüÂÚº^Âøú^ÃT{Ã2-B ñªBJÊ=ÃB ÂüqªÂÔî˜Â¹¾Â¦§m›ܬ—b–l˜2-šüjÂɺŸð¤Â¡®Â Þ5ŸožÂœÙšÂ™Oß• PÂKD‹;çÂl¢ÑÂ}„‡ÌJ‘Bšև¤øÂ¬eã³2°Â¸ Dºæé¼Tþ½Š=ÂÀW ÂÇþÂÔ— Âì\Ãó¶ÃsøÃ+á‰Ã0–Ã%íÓÃJ=Âô‘ìÂÓ´¼Â»`Ū_;Ÿ•™Æ%—ŽV—“øÂ˜·Lš!Ë›;d›£T›#T™ª—F%”ÂDœÂ‹ýô‡k…ÂdÑìÂs¿}ÂÀƒÂ‰áHÂ’ ™ËÇ ڠ¦ÎV«n˜Â®ËD±[#´¸¾äÝÂÊRòÂÛ»çÂóŽVÞwÃ&éÃ{Ã?}ÃßÂäò-ÂÌp¤Â¸ñªÂªxR •šŠÁ—iy–:á–$Ý–yÛ–¹Û–ŒJ•ºá”/žÂ‘냋ŒJ‡°!ƒ‹DÂ\»dÂiàBÂw’o‚ʼn±ªÂPb–^¸Â›¤Z ¨Â£Ÿ¾Â¦ËDª)ü®’ò´ùÛ¾>úÂÊâNÂÚz^Âêß;Â÷Š=Âû ÅÂóÀƒÂä´9ÂÒûçÂÁã׳7L§/Ÿ Å™m•ô¼Â”u“,‹Â’ºáÂ’V‘±ªÂœ)ÂŽüîÂŒÎVІò°Âƒp¤ÂXÂT¦éÂ`7LÂl#×Âx1'‚ ºÂ‡¹XÂŒü°Â•Òo™u?œß; }q¤ٚª€Â±Ý/»ÂÅ]²ÂÏm‘ÂÖÏ\ÂÙ¬ÂÕmÂÌèsÂÁݲ¶MP«­‘¢Á‰Â›Ï\–Æ%“\)‘,‹ÂËÇÂŽØÂŽÂœÂ‹»dŠ Í‡ïÂ…fé‚~úÂ~“uÂw²-ÂLÖÂVô¼ÂaaHÂkÙÂv#×€„£TˆàÅÂŒ¹ÛÂDœÂ“±ªÂ—G+›Z 7L¦ D¬¾w³Ô{ºV‡Â¾ú^ÂÀ”{¾©y¹­²»çªýô£t¼ÂœÇ+—G+“%Âåã«…ÂŒåŠÑh‰¯ˆyÛ‡VÂ…V‡ÂƒH´Â€åãÂ|iyÂvƒÂp49ÂE2-ÂN6FÂW_;Â`‰7Âi‰7Âr6FÂzm‘ J„ž5‡üî‹IºÂް¤Â’c×–Š=›1' 7ÏÂ¥A‰Â©µ?¬Ú®o­ª¾Â¥¸R ‹D›@ƒÂ–TþÂ’oÂŽ–‹ؓ‰»dˆo†®Â…bÑ„ Ç‚ŒJ€ÒòÂ}­Ây+Ât'ðÂn´9ÂhæfÂ> ÂF%ÂN ÅÂV6FÂ^'ðÂeÙÂm33Ât(öÂzÀƒÂ€‰7ƒ£T†ËÇŠ)¨s‘n˜Â•På™VœG+ž‘hŸ”{Ÿ(öÂdZš–‡Â— B“nÂևŒ”þ‰Ç+‡qªÂ……ƒçm‚z^²Âm‘Â|aHÂxùÛÂu&éÂpãTÂl6FÂg(öÂaÍÓÂ7;dÂ>e`ÂE²ÂLÍÓÂSàBÂZÀƒÂa_;Âg¶FÂmÇ®Âs¥ãÂyhsÂ2-‚ŽÙÂ…œ¬Âˆ¼î‹ÖÂŽ¼j‘33Â’ûç“âN“ÎÙÂ’ËD‘¢Â޶FÂŒ#T‰‡®Â‡\„Ô{‚ß;Â*ÂNÙÂ|ƒÂyÈ´Âv÷ÏÂsñªÂp ÅÂl÷ÏÂhñªÂd’oÂ_âNÂZì‹Â0ß;Â7OßÂ=È´ÂD8RÂJbÂPÁ‰ÂVÀƒÂ\Š=Âb¸ÂgŠ=ÂlÚÂr ÅÂwk…Â|½q–ƒåÂ…ès‡ã׉\)Š2-ŠW‰Ñhˆ¸Õ‡2-Â…iyƒ…¢Â§ðÂÇ®Â|‡+ÂyPÂvÈ´Ât ÅÂqxÕÂn¸RÂkƨÂh•ÂešÂaNÙÂ]9XÂXÝ/ÂTE¢Â*êÂ0¼jÂ6’oÂ<`BÂB¦ÂG·LÂM,ÂRwÏÂW™šÂ\—ÂayÛÂfH´Âk 7Âo¹XÂtH´Âxš Â|‡+ÂÛ#Â2-Âþú‚IºÂ‚ÂqªÂ€t9Â~r°Â{¸RÂxæfÂv¬Âsl‹ÂpØÂnYÂkÞ5ÂiXÂf³3ÂcáHÂ`ÔþÂ]‰7ÂYøÕÂV'ðÂR ÂM× Â%W Â*Ÿ¾Â/ë…Â50!Â:dZÂ?€ÂD|îÂIXÂNbÂR¨öÂW%ãÂ[‰7Â_ÓøÂdÂhÂkÁ‰Âo#×Âr+ÂtKÇÂu× Âvž¸Âv¢ÑÂuøÕÂt»dÂs\Âq“Ân÷ÏÂlÖÂjŠ=ÂhQìÂf{ÂcÌÍÂan˜Â^í‘Â\@ƒÂY^5ÂVBÂRì‹ÂO]/ÂK—ÂG¢ÑÁ„n˜Á~ÐåÁr¼jÁd‡+ÁTbÁAOßÁ,ZÁ`BÀù`BÀź^À‘7LÀ;•¿·KǾ%?e¸?Ÿ?Üí‘?²MÓ? J¿lÌÍÀ7 À§ =Àü“Á+ÂÁZr°Á„-Áš =Á®\)ÁÀéyÁÑ•ÁàhsÁíl‹Áø´9Â&éÂ$ÝÂ[# Ôþ œ¬Â ¿}ÂMÓÂSøÁŠ$ÝÁ„× Á|´9Ám"ÑÁZÐåÁE™šÁ-ÁŸ¾Àê—À¬“ÀVÙ¿«"Ñ? =@Iº@nE¢@•ãT@¢§ð@šŸ¾@xb@ ¡Ë½ÊÀƒÀ=VÀÅë…ÁZÁRvÉÁ„t¼ÁûçÁµQìÁÊA‰ÁÜÎÙÁí ÁûE¢Â·LÂÖ 7Â[#Â× Â‹D†%ÂÜ)ž¸Á‘{Á‹²Á„ÄœÁxÄœÁd§ðÁLñªÁ1‰7Án˜Àß¶FÀ”´9À o>²°!@3÷Ï@¢\@ß× A=qA²Aß;@ÿdZ@Á©ü@QxÕ¾Y‡À…¡ËÁ‹DÁJ~úÁ…´9Á£‰7Á¾9XÁÕ²-Áê+Áûë…œ¬Â ¾ÂŽVÂñªÂVÂÇ®ÂX Â%ãÂ\Á™r°Á“ùÛÁŒë…Á„{ÁrvÉÁXbNÁ9²Á1ÀÛt¼À‚E¢¿ˆÔþ@¥ã@¥ÒòA9XA+™šAKdZA]ó¶A`bAO•A+çm@ìr°@F§ð¿æÈ´ÀàõÃÁCl‹Áˆ•Á«n˜ÁÉÂÁãÊÁÁú“²ÂÍÓº^Âr°Â Â#k…Â%ÖÂ'²Â'‘hÂ'9XÂ&49Á£xÕÁž33Á—+ÁŽ{Á‚£×Ái"ÑÁG/ÁoÀáhsÀq&é¾+ @jáH@ó"ÑA6°!AmûçAOßA›¾wAŸéyA˜¬Aƒ®AF‡+@ãt¼?{"ÑÀ±/Á>ÐåÁŽ1'Á¶Æ¨ÁØÙÁõ9X‹D³3Â_; °!Â&®Â+[#Â.¿}Â0êÂ1ô¼Â1ýôÂ1'ðÂ/–‡Á¯\)Áª•Á£ß;ÁšÝ/Á&éÁ€SøÁ[ûçÁ/¡ËÀöE¢Àyûç>¶È´@ bAAlAšƒA¹dZAÏ AØ+AÑáHAº÷ÏA“ýôA>áH@‡;dÀKÇÁ?;dÁ˜MÓÁÇKÇÁìÊÁÂiyÂÔþÂiyÂ%‚ Â-1'Â3ožÂ82-Â;{çÂ=_;Â=úáÂ=vÉÂ;þúÂ9¿}Á½XÁ¹n˜Á³r°ÁªñªÁŸhsÁMÓÁz{ÁJ-Á1À–ff>‰7@¸Ý/A;t¼AŽ—A½ùÛAçýôBéyB 33B ¾wAüÐåAΛ¦AÀƒ@ÿïžÀÁH“uÁ©›¦ÁßÂ¥ãÂÇ®Â2-Â)øÕÂ3jÂ;vÉÂAïžÂF¹XÂIÎÙÂKF¨ÂKIºÂJ JÂGÈ´ÂD³3ÁͲÁË ÁÆC–Á¾× Á´¸Á¥dZÁ‘å`Áq®Á3 ÀÍ¿LÌÍ@³¥ãAJŸ¾A ß;AÜÄœB SøB! ÅB/VB0ÔþB$PB þúAÅA‰AG;d¿r°!Á]+ÁÄ33ÂÙÂûçÂ#!ËÂ.å`Â9²ÂC^5ÂKƨÂRs¶ÂW,ÂYçmÂZÂÂYøÕÂWÌÍÂTˆ1ÂPn˜ÁàVÁß\ÁÜ®Á×VÁÍ÷ÏÁÀ‹DÁ­ÎÙÁ”°!Áh5?ÁZÀLzá@€ÌÍAASøA¦ JAîn˜B/B; ÅBQk…BXë…BN°!B2BøÕA$Ý?…ÂÁv5?Áå JÂffÂ*ƒÂ6§ðÂA,ÂK¨öÂU´9Â^wÏÂeF¨ÂiÈ´ÂkñªÂkð¤Âj{Âf¹XÂb8RÂ\å`Áõ•Á÷C–Áö÷ÏÁô Áí\Á⛦ÁÑûçÁºOßÁš‡Á_¾wÀëß;>ð ÅASøA”IºAäIºBÖBIÂBl–‡B}ÒòBy~úB^A‰B,#×AË›¦@Œí‘Á…§ðÂyÛÂ0¢ÑÂCçmÂMVÂVNÙÂ`ƒÂjÛ#Âsë…Âzµ?Â~ÀƒÂ€%Â~Û#Â{›¦ÂvÂÂpÂÂiýô¯ “ ¨ö   °!Â%ãÁÿr°Áë7LÁÍ¡ËÁ¤n˜Á\-À° Å@ZÐåAA;dA§ÒòB8RB??}BtÖBŠùÛBYB†9ÛB\SøB‹DA!ïžÁŠ¸Â”{ÂOÇ®Â`¶FÂg&éÂn¥ãÂx²Âš Â†5?‰u?‹‹ Â‰·Ï‡5ÃáHÂüîÂwŽVÂËÇÂ$ÝÂÞ5—ÂÓøÂûçÂ_;Â%ãÂ-Áë‡+ÁµïžÁ`n˜À zá?ªáH@«|îAŒG®B!ˆ1BedZBŠó¶B›aËB2-B‹BF)üAœzáÁnýôÂ.ÖÂkÀƒÂ~o¼jÂ…!ËŠ\Âj“öF–æf—ì—”µ?‘¾ÂŒ¸R‡Ñh‚«Â"Â(¨öÂ/ 7Â4·LÂ9/Â;ËÇÂ;ÙÂ8•Â1Â"öÉ ýôÁÅbNÁ^í‘ÁÈ´Á" JAÛ =CGO\C/ DB™TþB§49B·%ãB®üîB‰ÀƒB ]/ÀΧðÂð¤Âu‹*²”¦Â™$Zž…¢Â¢èöÂ¥aHÂ¥œ¬Â£»d "N›LÍ•®˜Â§m‰}Â1{Â:p¤ÂCó¶ÂM33ÂU˜“Â\^5Â`¯ÂaËÇÂ_uÂV•Â@+ÂoÁ–…Á\)Àú¸RC«ü‹CúCúC†å`C¼¬Ca‰Bè/žBÑî˜B„AcÎÙÀgÎÙÂLµ?ÂŽ–›ɺ¢½ô¨fé® ²NV´G®Â³œ)°ˆ´Â«–Â¥`Bžt9—?}ÂVÂ@¸RÂM"ÑÂZF¨Âgº^Âtɺ€6F„ª‡)‡ ºÂƒ[#ÂkÖÂp¤ÀèÄœA\bNA4bCúCúCúCúCúCúCi}C ÙBÛ¬‹A¼xÕÀÔí‘Â2(öÂon˜Âž;®€Âµûd¼p¤ÂÁÂÂ¥ãÂÁ²Â¼Ñì¶{ç®áH¦§mžIºÂ–“ÂP}ôÂ`=qÂqs¶ÂàB‹(ö“Ü)š߾žɺÂûç•éüÂ|®Áè‡+B©¬C6ïžBq/B {çCúCúCúCúCúCúBühsB™åãA-+Áâ?}Â;«ÂRgmž³3µÐbÂÀ)ÂÈJÁÂÍ­ÂÏMÓÂÍ)ÂÇ»dÂÀ!H·?}­×¤ožÂ›[¦Â_ÑìÂsV„SøÂ/žÂœ®˜Â¨å`³)y¸ð!¶á˨ B†þÁªVCADZCÎï¾BÛ2-AÅ;dA¨ãTBxøÕCúCúCúCüB‡ÓøAüùÛÀ„¬ÂÎÙÂYA‰Â‰wL¥긛¦ÂÅò°ÂÐiüÂ× ÇÂÙ+ÂÖ~úÂÐYšÂÇǮ½çð³“u©\)Ÿ—Ân+‚WÂ\)žu®'m¾—ÂÍ>úÂÖiyÂÕÂô¼ÂgmÂ,yÛBYBÕbB:™šAPA-PA_‘hB˜š C„!hC=TþB|~úBKÇAÊÁÁxbN‚ Â]º^‹î˜Â£©y·:áÂÇ~wÂÔ0!ÂÜ2-ÂÞÎVÂÜSøÂÕÝ/ÂÌÊÁÂÂ[¦Â·}q¬Ê=¢™Âz_;Š´Â™ª„¾0¤ÂÓ8RÂç=ôÂõ–‡Â÷ƒÂæçðÂÁ¬‰éü î˜ÀÚ-@œÄœ@ð(ö@ÂÁKÇÀ p¤A¡º^A •A~ùÛA‡Á =ÁÏ+Â(6FÂ_¿}ˆDž²Â³33ÂÅJ=ÂÓ™ÂÜÃÂà5ÂÞbÂ×ÌJÂÎÇ+ÂÄOß¹]/®\¤A‰Â‚ ÍÂÙ ¬‹Â´@ƒÂÊáHÂãçmÂý ÃxRà »çÃË…Âç ͵®˜Â|æfÂ[#ÁŸ Á0áHÁhõÃÂêÂc%ãÂle`ÂF6FÁÐffÁ¡¶FÁÚ§ð¬Â?ÂebNÂ…Õ™ÌÍ­èsÂÀjÂÏ\¬ÂÙ,ÂÝ/žÂÛÎVÂÖ0!Â;wÂÃÁ‰Â¹.®§m¤‹ÇÂ…^5”´Â¥…ºE¢ÂÒ‚ ÂíºáÃÝqÃŽÙÖFÃZÃ*ÂÖܬ¦Ÿ;ÂsÛ#Â1 ÅÂÂ,øÕBfk…CúCxËÂÀĜ“«Â[\ÂE¶FÂJ%ÂX›¦Âm¡Ë„Ðb•ñªÂ¨ƒº*ÂȯÂÒxÕÂÖâNÂÖ=ôÂÑŒÍÂÊåÂÀô9·¾Â­2°Â£ŽÙ†ú^•¸R§>w»÷LÂÔ\ÂîùÛÃC–ÃÕÃÃYXÃÍPÖÂé’òÂÂhsŸ{ç‰Á›¦ÂZ’oCúCúCúÁý"ÑÂä&鬭‘Âq'Â|ÓøÂrk…ÂwĜ…V“•£ñªÂ³È1ÂÀöÉÂÊåÂ΀ÂÎxRÂÊÂÂÄeã¼bN³ˆ´Âªm‘¡s¶Â†æf•)üÂ¥ñªÂ¹†%ÂÏæéÂè`BÃh1à {¦Ã…`à p¤Ã˜RÂîß¾ÂҌͻ¶F´´ÂÉ›#«E¢CúCúCúCˆjÃLÂÞª±¨Â”æfÂ…ï‚Y‡߾“'ð ÎÙ®'ð¹YÂÁ:áÂÅJ=ÂÅž5 ½}q¶/®Òò¦¥`žr-Â…QhÂ’©y¢¦Â³ÅÂÇvFÂÜ\¬Âð“øÃqhô{ÃФÂü:^ÂêæéÂÙ#ÂÍ™ÂѹÛÂóÐbÂÁ JCúCúCúCúÂõ$ZÃËÇÂÌþ¨hÂ’ó¶ÂŠÒoÂŒ¾ú”Á‰ÂŸ=q©©ü²{ç¸ÍP¼-‘¼”þºW¶°,‹Â©hö¢+šÇ+‚„ÂŽ¨öœp¤Â«ÓøÂ¼ƒÂÍ­ÂÝÊ=ÂꜬÂñÁÂñÛ#Â똓Âá¹XÂØ„œÂÕ“uÂàº^ìJ¿“øCúCúCúCúþà ½qÂÞqªÂ·†%Ÿ¸R”¡Ë“6É—³3žÂ¦ B¬€Â±&鳫³ë…²\®p!©|ZÂE–ªÂ}¨ö‰¦é•¬‹Â¢Ç+°š¾ožÂË$ZÂÕAÂÛbNÂÜæfÂÚr°ÂÖoÂÒùÛÂÕk…Âã"Nà Ã|)CúCúCúCÅâÃ,?ÃáËÂæÞ5ÂÁ¬‹Âª)›#™z^š¯žƒ£ß§6FªMÓ«í‘«ãת6ɧ Â¢ÚÂÇ+˜-‘Â’KÇÂu)ü„ÂŽn™s¶Â¤ÎV¯îºÂÂ)yÂÇ™šÂÊ“ÂÊ>wÂɉºÂÊIºÂÏ€ÂÜô¼Â÷wLß}Ã#ž¸ÂåoÂö)ÃA´¼Ã'9XÃç+ÂäÝ/ÂÅ2°Â°øÂ£›¦ÂÐ圉7ÂŢ  ºÂ¢\)¤ Ťï¤ŒJ¢ì‹Â 'ðœp!—þw“ PÂÏ\ÂlÂ|¤Ý‡)üÂff™½q¢Á‰Âªéy±¨s¶™¹´¼Â»{ç½ Â¿Þ¸ÂÆbÂÑÞ¸Âå°¤ÃÀBÃ/ßÃ'þúÃ//Ã$t9ÃÈsÂû´ÂÛ{ B±(öÂ¥ÕŸ{dœ¸Rœ2-œÍP½qžt¼ÂžåÂל1'™¦f–TþÂ’dÝÂŽƒÂ‰PbÂbß;Âqw˜jœŒÍ :á¢öɤSøÂ¤¢\)ŸožÂ›Ä—և” ÁÂ¥`ÂǮ‹s¶Â‰–‡Âˆ\†¸RÂ…m„\‚‡®Â€Å¢Â}†%ÂxûçÂsöÉÂn†%Âh¾wÂ9ÎÙÂA@ƒÂHÀƒÂP6FÂWŠ=Â^¡ËÂem‘ÂkáHÂrÂwãTÂ}£×¶É„³¶Â‡Ô{‹ÂŽfé‘‘ì”W–m—”{—­–¾w”öÉÂ’—Âí‘ÂÀƒÂDŸ¾ÂJ\)ÂOë…ÂULÍÂZ~úÂ_Š=ÂdzáÂi[#Ân5?Âs =ÂwÌÍÂ|bN€NV‚#Tƒ“øÂ„‰7„öF„Ü)„J=ƒX“‚$Ý€ÍPÂ~ÓøÂ|šÂy|îÂvüîÂt‘hÂr'ðÂo«Âm+Âj)üÂg+Âc˜“Â_Ü)Â[ÔþÂWŠ=ÂSÂ&úáÂ,e`Â1ÒòÂ76FÂ<ˆ1ÂA¾wÂFÑìÂKÀƒÂP‹DÂU49ÂYÂÂ^;dÂb ÅÂfñªÂk ÅÂo“Âr»dÂuäZÂxožÂz>wÂ{A‰Â{xÕÂzöÉÂyÙÂxE¢ÂvcTÂtTþÂr49ÂpVÂmèsÂk¼jÂi€Âg&éÂd£×Âaë…Â^ô¼Â[º^ÂX=qÂT~úÂP…ÂLXÁ‚XÁyÎÙÁlÀƒÁ]XÁKÁ7&éÁ ZÁC–À؃ÀŸ¾wÀK¶F¿³¶F>†$Ý?Ûçm@7 @ep¤@rñª@[o@dZ?Qhs¿­VÀ ÀÞ¬Á!|îÁT\Áƒ ÅÁš\Á°¸ÁÙšÁÕÁä`BÁñ× ÁývɬÂŢ V ’oÂ]/ÂzáÂüîÂò°ÁˆÁ‚;dÁvZÁep¤ÁQÁ:^5Á Á‡+ÀÄr°À~§ð¿Ý²-?ãT@+ƨ@”(ö@Ço@éë…@ør°@ï+@Ì Å@Sø?ëçm¿²ÐåÀ¡OßÁ“uÁL—ÁƒýôÁŸr°Á¸-ÁΓÁá\)Áò/ÂbN¡ˠãTÂ1'”{ÂÂȴ¹XÂûç¤ÝÁŽë…ÁˆñªÁxÕÁp§ðÁZ¬Á@´9Á"“uÁ=qÀ³× À@r°¾o²@' @¬í‘@ÿ¶FA"ùÛA<£×AI²-AG‰7A4\A‡+@¹¡Ë?ân˜À2¬ÀòéyÁE…Á†p¤Á¦•ÁÂÈ´ÁÛ/Áð=qÂ5? 1²-ÂA‰Â¾wÂ1'Â¥ãÂ!-Â!Ü)Â!ɺÂ!bÁ—XÁ‘SøÁ‰—ÁÎÙÁhÁKKÇÁ)KÇÁƨÀ©À ~ú?Òò@™‘hA=qA<ùÛAm"ÑA‰$ÝA“ùÛA•{A‹ ÅAkA+‰7@´£×½ï²Àʼn7ÁA‡Á‹§ðÁ±1'ÁÐïžÁ뙚 ¾w D“Âð¤Â$•Â( JÂ*aHÂ+¨öÂ+üîÂ+|îÂ*E¢Á¡ƒÁ›°!Á“ïžÁ‰í‘Áz£×Á[Á5ÊÁÁõÃÀ©‰7¿ÊŸ¾@"~ú@ßoA8ÐåA€\)A¡"ÑA»¾wAÌïžAÑ´9AÇß;A®Ÿ¾A†× A&Qì@?ß;À˜ ÅÁB¸RÁ•È´ÁÁ?}Áä"ÑÂ%ã Ü)Âçm˜“Â&Â,!ËÂ0èsÂ4TþÂ6s¶Â7_;Â79XÂ6'ðÂ4RòÁ­¬Á¨XÁ éyÁ–ñªÁ‰ùÛÁs%ÁJ{Á1'À¹Oß¿¹™š@_ =AÐåAkG®A¤ffAЛ¦AöE¢BbNB ÄœB Aõ\AÄA©ü@Ò5?Àc•ÁQKÇÁ¨ýôÁÚffÁþ E¢ÂÇ®Â"äZÂ+ãTÂ3¬Â:uÂ>ò°ÂBA‰ÂD PÂDwÏÂC­ÂAáHÂ?DœÁ¼oÁ·§ðÁ°ýôÁ§‹DÁš¼jÁ‰å`Áh—Á2r°Àà1Àº^@qÊÁA%•AŒ+AÈ =Bk…B¹XB/®B9ÔþB7OßB&›¦BïžAºn˜A)VÀ=Áw¥ãÁˬÂ@ƒÂ>wÂùÛÂ()üÂ1î˜Â;)üÂC\)ÂJhÂOÂR{ÂSaHÂSÂQs¶ÂN¸RÂK#×ÁÌó¶ÁÉñªÁIJÁ¼ZÁ°n˜Á ÁЬÁ[`BÁdZÀiûç@@å`A,=qA›—AæSøB\)B=gmBZÚBlhsBm}ôB[‹DB6dZAÿÊÁArÄœÀ A‰Á‰ùÛÁÖãT²Â+–‡Â2ô¼Â:MÓÂCKÇÂLƨÂUzáÂ\ƒÂak…Âd‡Âd§ðÂcffÂ`£×Â\¹XÂWò°Áà~úÁß~úÁÜ9XÁÕùÛÁËë…Á½Á¨bÁ‹£×ÁLbNÀØí‘?'+A5?A¸AöOßB*«BZž¸B‚ž¸B‘®B”ß;BŒCBmÅ¢B*éyA®xÕ@‚V@-¡ËB1 DÁSSøÂE49ÂL.ÂOyÛÂWvÉÂaNÙÂj›¦Âqì‹Âvž¸Âx™šÂx“Âu„ÂqMÓÂkå`Âe©üÁöÔþÁø‹DÁø-ÁôùÛÁîÁâ“ÁÏ× ÁµvÉÁÒòÁ?"ÑÀKÇ@·ß;A‡9XAè§ðB)áHBfe`B‘Û¦B¨× B²6ÉB¬ B–¬B`§ðAüA‰A]xÕAš~úBÇIº¿!‰7Âh²ÂiɺÂhcTÂo^5Ây©üÂÂÂ…t¼Â‡…¢Â‡ò°Â†í‘„ÀµÃÂ|+Ât1' œ¬Â _; äZ ­Â¾Â{çÁí“uÁÍffÁžÔþÁ<›¦¿À£×AƒA¦QìB1BPBšB·¶ÉBÆdÝBÆ´9BµÙBüjB/©üAVÁ¤1'—„}q‘5Æɺƒk†IºÂ‹ƒÂ…¢Â”•ƒ•ìÂ’ûd¤Z‹o†±ªÂ®˜ÂöÉÂÖÂÂ"SøÂ$6FÂ${Â!C–Âô¼ÂêÁûr°ÁÀ~úÁUÊÁ¿øõÃ@‚éyA{"ÑC:úáC²Ÿ\Cô{BÜå`BÜ™šBÒž5B¸5B}cTA•~úÁ¸¥ã \ŸH1ªð!œ–˜“˜bÑÂ0!¡ܬ¤ÁÂ¥NÙ£ž¸Â ²Â›NÙ•¯¢Ñ‰t9Â%0!Â,¢ÑÂ3øÕÂ:ÏßÂ@®ÂE%ÂGXÂGgmÂE+Â? Â,@ƒÁú\)Á„n˜ÁS¶FB±p¤CúCúCúCúCÈ dC/žBöçmBû{B‘LÍB«ˆ´C݉ÛA©?}™CÂ¥× Â¬½q®h±ƨµš·yÛ¶¬‹Â³X“®\§|j 5ذ!‘9XÂ5t¼Â@+ÂKoÂV-‘ÃL§+ÃF3Ã-Påà «ÇÂÈu?Â| PÁån˜Bb,CúCúCúCúB˜íÁXÁÉ`BÂ9}ôÂR‡+ÂaÄœÂu¿}‰ÙŸX¸±'ÂÑ‹ÇÂåë…ÂòýôÂ÷ÀÂõ ÁÂìܬÂágmÂÔxRÂÇE¢Âº…®’oÂKÇž›¦Â³úáÂÎPÂà “Ã#«Ã:ÔþÃHQ'ÃCð!Ã/ ÃÂäcT§xÕÂl\)ÂàBCúCúCúCúCúÂÑõõ’o”Ro€æfÂm±'ÂoÊÁƒùÛ˜´Â¯|îÂÆÂØ— ÂäÐbÂéÿ}Âè»çÂâ†%ÂÙ¸ÂÎ ºÂÂbN¶ۦ«ÚÂŒïžÂß±ÐbÂÊŠ=ÂèPà ºÃ¨sÃ+ÙÛÃ6PåÃ3ÐbÃ%G+Ã…ãÂïC–ÂÄäݪ4¼Â¥ZCÒîúCúCúCúCúÂÉüjÂõ}q¼dÝ”$ÝÂy“uÂp­‚Ïß•0!©Ä¼àBÂÌSøÂÖÊ=ÂÛ¶ÉÂÛjÂÖåãÂÏn˜ÂÆ8R¼3¶Â²®Â¨#ŠàBšDœÂ¬¢ÑÂÂxÕÂÜ PÂøð¤Ã ‰Ãžúà HÃÄZÃ_¾Ãö‡Âîð¤ÂÖ(sÂÍÎVÂàÖB¸áËCúCúCúCúÁôl‹Ãý/ÂÙٚ¦™šÂˆ3¶Âü}–àB§j¶:^®ÂÊ1ªÂÎRòÂÎwLÂË.˜ÂÅRo½ŢµJÁ¬s3£¢N‡yX•MÓÂ¥gm·öFÂÌݲÂã]/Âù‹DÃü)à ,‹Ã äZÃ{¦ÂùãTÂèCÂÜÔþÂà<îÂümAˆ¬CúCúCúCúBg¹XÃ<)Âîð!¹š Â™àÅÂŽgð‘ožÂ›zá§ D±X¹‡®Â¿WÂÂl™ÂÀ“»q'µ@® Â¦yXžµÃƒ"NÂI7Âh¬vF½)yÂÎbÑÂÞ¨öÂëÎVÂó‰ÂôkÂï*ÂæaHÂÞÂÛ^5Âä´9ÃEÃíPCúCúCúCúCXÕÃwLÂøõ?ÂÈ;ªŽÙÂ)ü›qªÂ  Á¦°¤Â­²6ɶ+¸\¸®Âµ÷L²'m­¦õ? `B™ŽÙÂ|zሠ”dZ¡®B»z^ÂÇž5ÂÑ^¸Â׃–ÂÙ~wÂ×ãTÂÔ€ÂÒ¸ÂÔTþÂß—ÂùÀà ÃÏßB0æfCdÄœÂÈó3ÖÃ*ÂõÁ‰ÂÍë´“u§¢5¢…¢Â¥Pb¨£×«¨s­ï¯ P®¶F¬Ø©˜Â¥:^  ÇšV‡Â”XÂr6F‚#T‹æf–9X É7«u´e`»ú^ÂÁ33ÂÃãTÂÄ‹ÇÂÄn˜ÂÅp¤ÂÉô¼ÂÔÅ¢ÂéþÃ!ËÞúÃ5aËÃ@•ÃÃ5HÃÝôÃòoÂèºáÂËbN·+…ªÒo¤¡Ë¢š Â¢èö¤3¶Â¥©y¦ƨ§"N¦uä¦éÂ¡ÄœÂøR™wÏ”yÛÂ/ÂgïžÂwgmƒåãÂŒc×”éy“¤}qª§ð¯I7²aH´[#¶øÂ¸ËǾÂÇT{ÂÖ'ðÂë+…Ãe¢ÃF%ÃÂÃàÅÃ/\Âðm‘Â×ß;ÂÃ\´MÓ©õãËD ¼îŸ®Ÿ­‘  D I7  ÁŸhÂAšœ)—;d“BŽٚŠ&fÂ]÷ÏÂkwÂ¥èö±ÎV¶\)¸»d¸ffµ{d°§ðªȴ¤ÁŸ8Õš•–ûd”YšÂ’~w‘(sÂ{´ÂÕÂŒZŠ‚ˆH´Â…¯‚ÀÂuÂx:^ÂC_;ÂL JÂTÔþÂ]”{Âf#×ÂnYÂvhÂ}7LÂæf„öF‡èöŠåãÂŽšÂ‘©ü•§m™ýôžk¢~wÂ¥­§vF§‘h¦¨Â£,‹ÂŸ{d›|є;d‘k…Â49Â|îÂŒ¸ÂŠì‹Â‰¼îˆn†æéÂ…‚ú^€\Â{¼jÂuàBÂo¥ãÂ;½qÂCdZÂKšÂRÂÂZBÂa{çÂh[#ÂnÓøÂtèsÂz®€%ã‚øRÂ…çð‰+ÂŒYÂÊÁ“-–:^˜Ÿ¾ÂššqªÂ™´9˜ D•»ç“Ân˜Âó3‹Ǯ‰ó3ˆk‡…ݲ„ BƒF¨Â¾úÂúáÂ{÷ÏÂwvÉÂr€Âm!ËÂgqªÂ4²-Â;€ÂBTþÂI¬ÂOÖÂV5?Â\cTÂbH´ÂgçmÂmMÓÂr”{Âw× Â}1'ÂZ„-‘‡ ‰·LÂŒ!HÂŽ ÓÂRòÂÕ”þÂŽ«Â@‹†%‰¯‡áˆ6É„·Lƒ_;‚"N€î˜ÂbNÂ|²-Ây³3ÂvQìÂr‰7ÂnTþÂi¿}ÂdÐåÂ_š Â.1'Â4JÁÂ:ffÂ@vÉÂFl‹ÂL:^ÂQÖÂW;dÂ\m‘Âat¼Âf`BÂk?}Âp ÅÂu 7Âyð¤Â~¼jŸ;ƒŸ¾Â…?}†d݆þú‡ ͆œ)Â…Æ%„©yƒff‚€ÏßÂ.Â|ÙÂz”{ÂxIºÂuáHÂsC–Âp`BÂm(öÂi˜“Âe¯Âap¤Â\æfÂX¬Â(-Â-¯Â32-Â8©üÂ> PÂCPåÂHožÂMe`ÂR49ÂVáHÂ[r°Â_ó¶ÂdhsÂhÑìÂm%ãÂqNÙÂu/ÂxŸ¾Â{xÕÂ}–‡Â~æfÂcT¾Â~8RÂ|ÔþÂ{²Ây8RÂw?}Âu?}Âs;dÂq.Âo 7Âl¾wÂj?}Âg~úÂdt¼Âa²Â]xÕÂY‹DÂU\)ÂPô¼Á€1'Át´9Áf¸RÁV9XÁC Á-C–ÁÀƒÀól‹À¹‡Àw;d¿òÐå='ïž?î5?@]/@–¸R@°“@·\)@©ãT@†ff@MÓ;Ä›¦À9©üÀÄ›¦ÁG®ÁP~úÁ‚ÙÁ›©üÁ²C–ÁƃÁØxÕÁèIºÁö‡ÂÂV =q –‡Â"ÑÂî˜Â+Â|îÂcTÁ…º^Á =Áoß;Á]²-ÁH9XÁ/KÇÁÔþÀåÒòÀŸ²À(ƒ¾333@Sø@•ó¶@ÚÙA ²AñªA$å`AxÕA ‘h@ÒvÉ@fùÛ¼£× À‚vÉÁPÁI?}Á„™šÁ¡¸RÁ»—ÁÒA‰Áæ Á÷/Â1 hsÂÅ¢Â(ö™šÂ!ËÂÏß¶FÂæfÂwÏÁŒ“uÁ†¬Á|{ÁhQìÁP\Á4vÉÁ¾wÀÜ´9Àˆå`¿´9X?Ót¼@™Òò@ýp¤A-oATƒAqXAãTA}‡Ag%A=xÕA¬@aûç¿Ð ÅÀàzáÁD9XÁˆÈ´ÁªáHÁÈ-Áá¸Áör°Âhs RòÂÂÀƒÂQì ÐåÂ#F¨Â$ÄœÂ%`BÂ%33Â$XÁ”ùÛÁŽl‹Á†1Áw%Á]+Á=ïžÁÔþÀÛ =ÀoÎÙ¾Òò@`ƒ@ð9XA8õÃAw A—1A¬E¢A¸—A¹•A­§ðA”dZA]¡Ë@ý‘h?  ÅÀµ¡ËÁD›¦Á‘ZÁ¸ùÛÁÙn˜ÁôbÂ5?ÂÌͦÂ=qÂ$.Â(çmÂ,iyÂ.º^Â/ð¤Â0&éÂ/}ôÂ.ÁŸ/Á˜ÊÁÁSøÁ…jÁoOßÁM?}Á#× ÀäÌÍÀaÛ#?|î@¨záA$È´Ax¸RA¥ãTAËýôAë JAÿVB!ËA÷ûçAÙ7LA©¬AV@‘ÊÁÀ‘ó¶ÁQoÁ¢33ÁÏ`BÁñ¡ËÂ.ÂE¢ÂöÉÂ#\Â+ DÂ1G®Â6'ðÂ9²Â;²-Â<Â<,Â:áHÂ8È´Á«záÁ¥•ÁhsÁ’xÕÁ„=qÁdA‰Á7 =ÀÿC–Àt“?‹ @ÖÐåAOÂAÄœAÔÛ#B·LB>wB+uB1H´B+–‡Bò°AóÌÍA¡$ÝAVÀ†éyÁxZÁçðÁôáH cTÂÞ5½qÂ)bÂ1Û#Â9¿}Â@W ÂE[#ÂH´9ÂJjÂJ¤ÝÂI–‡ÂGvÉÂD}ôÁº$ÝÁµ+Á­ÄœÁ£VÁ•5?Á‚•ÁU/Á£×À›dZ?Q©ü@ðÝ/As¥ãA¾oB(öB'hBGs¶B` =Bl;dBh7LBQûçB)ÑìAä33A>ñªÀ£;dÁ™‹DÁí…ÂvÉÂ$ožÂ*E¢Â0áHÂ9:^ÂB:^ÂJ±'ÂQ¾wÂVçmÂZÂ[+ÂZ•ÂX‹DÂUYÂQE¢ÁËn˜ÁÇïžÁÁí‘Á¸¼jÁ«ƒÁ™C–Á€ÔþÁA¾wÀ߯¨¿E¢@çl‹Aƒë…AØ\B¯BJÛ#Bx¿}B¸Bš DB™üjB*Bfî˜B!ËA’p¤AœbBžâÑCf˜ÕB@qªÂ7²-ÂC÷ÏÂDÈ´ÂK²ÂUhÂ^hsÂfVÂkLÍÂmúáÂnG®ÂlŒJÂi1'Âd›¦Â_'ðÁß‘hÁÞ5?ÁÚhsÁÓ`BÁÈ+Á·•Á +Á€¬Á*—Àk× @¤õÃAl‹AåMÓB,Bj‚ B”ýôB±BÃkBÇoB¹:áB™ŠÁBT˜“B‡æfCúCúCúCúAÐåÂ`ŒJÂ[]/Â`Á‰Âk2-ÂuƨÂ~u™šÂ‚Š=‚ D€_¾Â{£×ÂuIºÂn ÅÁöº^ÁøIºÁ÷£×ÁóñªÁì-ÁÞýôÁʸRÁ­ ÅÁƒQìÁ>ºáHAHIºAØ33B.0!By$ÝB§;BнqBí©üBöïBéÓuBÆB ÇC…ãCúCúCúCúBIð¤Â€­‘ÂuŒJÂzA‰Âƒ¬Â‰òÂm‘°!Âì‹ÂŽs¶Â‹¬‡øRƒ­‘Â~²Â}ô , ûç ‚  5?Âk…ÂJÁÁëSøÁÇPÁ‘ñªÁ¬@“²A¡KÇBÍÓBfB×ÄCÜjCÁËCNVC NBò­B¸`BB—ÃCî»CúCúCúÂqÔþ–@‹æéÂÝ/”YšÂš¢ÑžÈ1 J=ŸZ ÂœwL˜.˜Â“ÂV‡yÛÂ"ÑÂ9X ÎÙÂ$}ôÂ&Ç®Â'{Â$»dÂñªÂW ˜“Á¿G®Á Ù@ÌbNAžéyC-1ªCúCúCúC…dCMôC á‰Bé!ËB›xÕB¬ÄœCúCúCúÂ1E¢Â§˜“¤DÂ¥33ªÊ=°ff³‘ì³¥`°ë…¬åÂ¥ÐbžËD—yXÂ-‘Â'2-Â/9XÂ7G®Â?ÂEýôÂK¾wÂP ÂS¾ÂV@ƒÂXˆ1ÂEbÁç§ðÀø´9ASøCúCúCúCúCúCúC£ÆFC=!‰CÕÌJC¼`ƒCúCúCúCúCÌ?Â¥#×ÂÃÿ}ÂÇ0¤ÂʨöÂËÝ/Âɳ¶ÂÄuý´O\«þ¡ڠ˜ò°Â8t¼ÂCüîÂPF¨Â]\Âií‘ÂvzáÂeãˆhs“¥ã££×A(§ðCúC¶®B„ñªCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA¥ãTÂÜÔ{Âçp¤Âè}ôÂçÂáàBÂÙl‹ÂÎÍÓÂÃ/žÂ·qªÂ¬5¡}ÂJ–‡ÂZ,Âk‚ Â~s¶Â‰Oß“¹Ûž[¦ÂªQ켋ǯhsCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúBÑhÂÒŽVèæéé7ÂúäÝÂî¼îÂà‚ÂѲ-ÂÃH´ÂµÍÓ©xRÂ]uÂq6F„3¶Â‘dÝ  D¯°¤Â¿ŒÍÂÏ=qÂàn˜Â°ú^CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúAÿº^ÃÃöÉùšÃ°Ã Q'ÃZ^ÂðÏßÂÞÔ{ÂÍÚ¾[#°u?Âo:^„¾Â“¤“u¸öFÂÏ«Âç ÍÂûàÅÃïžÂù²CuþúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC7Bà S3ÃxÕÆ%Ã÷ ÃLà Š=Âþ PÂégðÂÖQhÂÅ2°Â¶\€ D¡[¦Â·ÓøÂÓ/Âóåà ™šÃöÃ$ß;ÃW ÂßMPCúCúCúCúCCìC±þ˜CúCúCúCúCúCúCúB°Ý²B†=qCúCúCúCÀ™ºÃ ¤Ã²Ã".Và f¨Ã$÷ ÃDÝÂðIºÂÛì‹ÂÉÒò¹î˜Â‡qªÂ˜²Â®*ÂÉ„œÂìxRà s3Ã'ŒÍÃC¨sÃS˜“ÃKYšÃ,i7ÂÅs¶C‚w+CúC)UÃC³æ‡CúCúCúCúCúCúCúCú 7Â8ÀƒBnBDœB– =Ÿ¾wà çmÀBÃ!søÃ ñìÃ<)ÃúáÉyÂò´9ÂÞ/ÂËë…»ݲÂ, ¢Â¸{Â×_;Ãp¤ÃqìÃAâNÃi× Ãcƒ×ÃU½qÃ?jþ5ÂÎŽÙÂ/ɺAýjCúCúCúCúCúCúCúCúC¤Þ˜AžQìB†q'ÂQõØÚ·záÂà>úÃ:áÃ/ßðbÚÃFfà =qÃÃTÂð’òÂÝ =ÂËq'Â»ÓøÂꤨö¾¢ÂßTþàÃ% ƒÃOÁÃsQìÂÙº^ÂÛbNÃ8RÂè=qÂÿ;d•.˜?3t¼CúCúCúCúCúCúCúCúÁÄ?}AèÙBæq'Â*ÊÁ‹ß¨áHÂ̧ðÂð¥ãêÃè´ÃÅÃr°ÃIüÂüæéÂê„ÂØàBÂȠŹöÉÂ’s3¦+¿[#Âà33ÃûdÃ#­ÃK)7Ão®˜ÃOÉ7Ã:¥ãÃ4Z^Ã8“à Þú¼/Â?¿}C1ØÕCúCúCúCúCú¼Ÿ;ŸդçðÂn”{ ‰7ÂO|îÂ~C–œqªÂ½áHÂÝ× Â÷§ðÃîæfð¤ÂþöÉÂðûçÂá«ÂÒgmÂÃî˜Â¶‘h‘Ôþ¤¦f¼NVÂÚwLíÃÀÅÃ8ãTÃXãÃhÇðÃcþ¸ÃPÛÃ0.Ùà HöÂÔ5à=ôÂm²CúCúCúCúCúÁ6-ÃDÝÂÎ+…Âm÷ÏÁ¥OßÂSøÂo¿}˜cT¶QhÂÐI7ÂäßÂñÁ‰Â÷+…Âõk…Âî9XÂãšÂ×F¨ÂÊvɽès²ÂV šµȴÂÏéyÂðoà søÃ!„ÝÃ6ÇðÃCÓ¶ÃBRoÃ3‡mÃ#×ÃÑìÂߌJÂÆ…ÂÈ;dB÷„CúCúCúCúCá¾ÃêÂêƒÂgØÀPr°Â»dÂz¡Ë›äZ³{çÂÇkÂÕ×ÂßCÂ㮘Âã ÁÂÞ/ÂÖ&fÂÌcTÂÁÏ\·“¬ª‹dÝš¼j­œÂ¹XÂÜ;ÂøÌÍà _¾Ã–‡Ã ]qÃÙÃqªÃ ;dÂø“Âá²°ÂÚ8RÂìI7Â|PCúCúCúCúCú™höî«ÂÂbiyÂo¤Ý»d¢:^¯iü¿íÂÊ0¤ÂÐ-ÂÓE¢ÂÒþúÂÏ~wÂÉt9ÂÁ¶F¹–¯ïžÂ¦ß¾Â†yÛ“ËD£.˜Â´ÂÂÈ\¬ÂÝ;dÂñž¸ÃDÝÃ.˜ÃW Ã×ÂõÑìÂç DÂÝ~úÂàÙÂ÷Ţà WC¹3øCúCúCúCúAÅXéüÂ͵?¨s3œu? õ?©޸±;ºNVÂÀ{Âß;ÂÅ“uÂÅI7š Â½àB·£×°qªÂ¨¿} å`ÂÂŒgm™,‹Â§@ƒÂ¶O\ÂŲÂÓåãÂßffÂæSøÂç¯ÂãûdÂÝSuÂÖýqÂÕ¢ÂÜG®Âó%ãÃ{#ÃPCòsuCúCúCúà þÃbNÂ×]²Âº|î­–ªSu¬èö°¦é´49¶ès¸úáºøÂ¹š Â·Z³{d®V‡Â¨NV¡¼jšë…ÂvÀƒÂ…®Â’ošؓ¦‚ ±øÕ¼dZÂÄ ÂÊ.ÂÌJ=ÂË‘ìÂÉiüÂÇú^ÂÉõÃÂÒ~úÂå?}Ã/ÃÇ®Ã(ÏÃ!ÇðÃI7ÖÃiyÂõO\ÂԜ½ð!±hs«÷LªáË«Óu­LÍ®º^¯޸°J=¯\­ª/žÂ¥Òò ®›œÂ•hÂk—Â{ïžÂ†°!Âȴ˜öF¡ËÇ©¼î°7Ï´ÎV·iy¸qªÂ¸Ú Âº J½¼jÂÅÃÂÓÞ¸Âé0¤ÃOÃÈöÃFéÃ4¼Ã ôÂúøÕÂàMPÂÊI7ºì¯©¡Ë§¦P¦åã§|î§çm§Å¦È1¤Ì͡؞ D™“øÂ”¤ZÂiüÂ`âNÂnÂÂ}H´Â†òÂr°Â”vÉšÇ+ ì¤%`§%©´ÂªÑì­G+±r°Â¸Ròš ÂÐB Âß×ÂíæfÂõÌJÂôŽVÂêð¤ÂÜ{dÂÌǮ¾{d²öFª­‘Â¥l¢b¡Qh ò°Â ã× ¼j *žõÉšLJ–éüÂ’ú^ÂŽ B‰þwÂVÑìÂb«ÂnãTÂ{8Rƒ©ü‰féÂŽœ)“/Â–ÓøÂ™ÐbœQìžŢ¡»dÂ¥ÍP«|j³¼ DÂʼnºÂͤÝÂÒH´ÂÒ&fÂÍdZÂÅo¼œÂ²ÃªÁ‰Â¤ŒJ 9X‡®Âœ¢Â›8Rš²°Âš¸Â™wƒÂÉ7€I7Â}¬Ây)üÂt¾wÂoãTÂj¦éÂe¦Â/Â5-Â;W ÂAqªÂGm‘ÂM;dÂRÐåÂX)üÂ]JÁÂbãTÂD'ðÂIC–ÂN33ÂRøÕÂW›¦Â\$ÝÂ`¡ËÂešÂibÂnÂrTþÂvp¤Âz)üÂ}W ÂÏ߀¾wÂ*Â33€æé€YÂ?}Â}™šÂ{Ý/Âz‡ÂxF¨ÂvdZÂtbNÂr.Âo¸RÂlò°ÂiØÂfcTÂb–‡Â^xÕÂZoÂUn˜Á|Áo²Á`ÌÍÁOSøÁ;VÁ#çmÁ çmÀÚ^5ÀœA‰À5`B¿;¥ã?«Æ¨@RÐå@ 1'@Ë;d@æMÓ@í²-@Þ‡+@·\)@q7L?’n˜À%À°ÄœÁxÕÁNQìÁƒE¢Á=qÁ´©üÁÉ~úÁÛÝ/ÁëûçÁú =ÂÂ:^ |îÂãTÂvÉÂC–ÂW ™šÁƒdZÁy‰7ÁidZÁVbÁ?;dÁ$´9Á^5ÀÈ“uÀzñª¿²\? @zñª@Ï÷ÏA KÇA+Û#A@´9AIoAB´9A,bNA(ö@£+?Œí‘ÀUÒòÀÿ\)ÁHr°Á†(öÁ¤£×Á¿ZÁÖÁê‹DÁûë…Â}ô ô¼ÂgmÂÝ/ÂYÂæf‘hÂl‹ÂŒJÂ1ÁЇÁƒ(öÁuoÁ_÷ÏÁF—Á(‹DÁ…ÀºÈ´ÀA&é=¥ãT@YxÕ@Ú\A#©üAVjA€× A²A˜p¤A–“uA‰í‘AdÈ´A!ë…@žéy¿E`BÀÖ§ðÁF—ÁŒ‡+Á°¸ÁÎ{Áç1'ÁüÂm‘Â`BÂ5?Âð¤Â “uÂ$¬Â&”{Â( =Â(•Â(NÙÂ'SøÁ’`BÁ‹OßÁ‚IºÁnÁRA‰Á0´9ÁÀƒÀ´À7L?Àå`@´¬A §ðAhIºA–¡ËAµ5?AÌÙAÚhsAÛ{AÍA¯¾wA„ƒA‡+@ VÀ²ffÁMÒòÁ™VÁÂQìÁâ¾wÁü¾w 8R›¦ÂÜ)Â"%Â( DÂ,ÙÂ0dZÂ2´9Â3ÚÂ3ô¼Â3&éÂ1“uÁœƒÁ•\ÁŒhsÁ€Ÿ¾ÁcPÁ>ÀƒÁë…À¸bN¿çÎÙ@/ÎÙ@üAW‘hAšÌÍAÉŸ¾AôÐåB =BQìB ByÛB(öAǃA}"Ñ@°ÌÍÀ (öÁiPÁ²ãTÁàZÂC– \)Â~ú©üÂ(Â/œ¬Â5öÉÂ:ñªÂ>s¶Â@ÂA49Â@¶FÂ?49Â<ß;Á¨ÊÁÁ¢OßÁ™bNÁ~úÁ|{ÁT´9Á#l‹ÀÍ™š¿ëçm@e‘hAûçA‡—AÄ÷ÏB'ðB œ¬B:ÔþBM2-BTBL­B5³3BÙA»XAå`À¿²Á˜Û#Áæ+ n˜Â¢ÑŸ¾Â&QìÂ.¥ãÂ733Â?8RÂF1ÂK9XÂN¡ËÂPH´ÂPXÂO 7ÂLš ÂIKÇÁ·‡+Á±õÃÁ©Æ¨ÁžVÁŽÝ/ÁtõÃÁ@QìÀûoÀ)X@mA4éyA¡‡AðffB"º^BMxÕBtJÁBˆáËBB ÇB}r°BJ~úB =AC?}À¾{Á MÓÁŽýôÂ"šÂ7× Â6ƒÂ8¶FÂ?vÉÂHVÂQ5?ÂX·LÂ^-Âa_;ÂbhsÂaŒJÂ_¾Â[{çÂVïžÁÉÁÄí‘Á¾&éÁ³í‘Á¥OßÁ‘/ÁlQìÁ%C–À“ =@*\A:n˜A³ÄœB F¨BD‹DBÐåBœbNB³²-BÁBÀC–B®½qBŒožB6êB ì‹C®ˆsCúCúCú å`ÂS§ðÂM&éÂQïžÂ[ÖÂf:^ÂnÖÂt{çÂw?}ÂwOßÂu¾Âq/Âkô¼ÂeÙÁÝvÉÁÛ“uÁ×oÁÏoÁÂ…Á° JÁ•í‘ÁcûçÁ ¾B\A"1'A¸xÕBž¸BcbB™ ÅBšBæ±'BþJÁCþBí‰7BÀ0¤B…áËCúCúCúCúCúCŸå¢Âm¸RÂbgmÂfNÙÂrµ?„¦f‡‹Dˆ{d‡¾úÂ…²°Â‚²°Â~¬Âv 7Áõ ÁöC–Áõ JÁð\Áç¡ËÁØÀƒÁÁñªÁ ‡+Áa²À·÷Ï@´“uA¤|îB™šBut¼B®}BèC>5C"n˜C) 7Cœ¬C\¬B¿£TCúCúCúCúCúCúÂýqÂxQìÂ~¹X‡²-Âb”üj—˜—«…•ºáÂ’RòÂð¤ÂˆùÛƒº^ š Â B ‹D Ý/ÂyÛÁüÈ´Áân˜Á¹jÁu7LÀc¶FAPVBËÇBm²B¼ˆ1C& CbÖCT¶CZACL–C#b Bé.˜CädCúCúCúCúC+ÀƒÂŒhs‹ƒÂ× Â›7Ϥò©gm« P©˜Â¥Óu …¢ÂšPå“°!ÂŒøÕ¬Â@ƒÂ âNÂ$•Â&ÖÂ'Â$YÂò°Â DÁø+Á£õÃÀ®A«²BHgmC™žCúCúCúCÅ®C˜óuCB‚ CBNBÍ$ÝCúCúCúCúCúÂSožÂ£ËD­&é·¿ÂÂí‘„œÂ¾ŽV¸!˰A‰Â§·LŸ Ó–š Â'¿}Â0 =Â8m‘Â@”{ÂH PÂNhsÂSvÉÂWÖÂ\£×Â^33Â'ûçAG®Aù JBV33CúCúCúCúCúCúCâó×Cj0bCñ3×CúCúCúCúCúCú@Â^5ÂÌš ÂÜÜ)Âá¥ãÂâ:^ÂÞKDÂÖ˜“ÂÌ‚ ÂÁL͵á˪Ðb e`Â9·LÂEËÇÂRÒòÂ`•Ân»dÂ|úá…ؓŽÍPÂ2-–CúCúCúCª·ÏCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC¹XÂúìü¬Ã‘ªÂþ¬ÂñLÍÂâvFÂÓ%ãÂÄY¶’òªœÂL¬Â]/ÂoÎÙ‚DœÂ噞5¦†¨Â¶ 7ÂÌ‹ÇB*ÒòCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÕµÃõ?Ã-Ãa‰ÃÄœÂø÷LÂäíÂÒhsÂÁÈ1³ ÓÂ`“Âu Å‡l‹Â–ì¦Ç+¹DÂÌøÕÂáýqÂøp!Bå¯CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃåãÃ3ÃÃ,ïžÃ!ÍÓÔ{Ã(´ÂõWÂß;ÂË»Âs@ƒÂ‡¬Â—vÉ«DœÂÂýqÂÞÓÂü˜“à ç®Ã_;Â×r-CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂZÃCf%ÃG ‘Ã?9XÃ1ßà gðÃ-ÃbÑÂéc×ÂÓÆ%ÂÁgð‚—Â’Õ§+ÂÀÜ)Âágðà ºÃXÃ5[dÃEF%ÃB~5¨ßCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁöƨÃL\ÃQõ?ÃJÙšÃ; =Ã(}ÃÛdÃÂNÂð(öÂÙ(sÂÅÊÁŠc×Â#×µDÂÔô9ÂÿwLøRÃC[#ÃhzÃS Ã0^¸ÃƨÂÌ ÅC¢<¬CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃzÃGv‡ÃQ-ÃL1Ã<Ó3Ã)áÃp¤Ã,ÍÂò¶ÉÂÛyÛÂÇçmÂp¤Â¥“ÂÀ-ÂäÅà ßÃ1¾wÃeÞ¸Â@ß;CúCúCúCúˆó3Áì•C,±ªCúCúCúCúCúCúCúCúCúCúCúCúB»˜“Â6~úÂðmùXÃ8`BÃDR°ÃBøÃ5ÉüÃ%M‘áËÊÂðô9ÂÚ¬ÂDz°Â”YªƒÂÆ™šÂí¯žÃË…Ã=ðÃo›çCúCúCúCúCúC,¼)²åAõXCúCúCúCúCúCúCúCúC·iyCúCúCúB£éüÂ… 7Ââ·Là µÃÃ$ PÃ0)üÃ0¥Ã(qhÃäÃFfÃSøÂëiüÂ× ÓÂÅ\)•ܬ«qªÂÇÆ%Âî+…Ã3uÃ:[#Ãm¨1Ckñ'CúCúCúCúÁ+ë…ÂÒ«Â?ÔþCúCúCúCúCúCò\JÂÅåCŠaËCúCúCúC‚NÁ¥`B‘ßÂÐVÂýß¾ÃÉyÃEÃlJÃÑìÃ+ÇÃÜjÂöÍÓÂã¬ÂÑ:^ÂÁB • Ç©PÂÃûdÂæâNà #TÃ,6ÉÃY;dÃng+@ZñªB‰¬»çÂö˜Ã…ãÂå"N¡„œÂ<¨öC$CCúCúCúCúC$œB*záCúCúCúCúÁ ýô‰$ÝÂÂã×Âé£×Ã`à Ǯà ;#à îÙÃHsÂù›¦ÂéTþÂÙ/ÂÉë…»Ü)Â’8Õ¤ès¼V‡ÂÚ5Ã.˜ÃÁ‰Ã7NÃW¼¬Ãk BÃgÕÃÃR¥Ã4—ÏÃ}ôÂê¯ÂÁRo´½ôÁæ¶FCúCúCúCúCú>A‰7Áô¸RCúCúCú@ÕûçÂOßA§¼j¬=ôÂík…ÂøàÅÂüƒÂú2-ÂòÕÂè#ÂÛ¡HÂΜ)ÂÁÍPµ BÂß;žV‡Â²QhÂÊœ¬ÂçøRÃMÃwÏÃ*™ÛÃ6‰Ã5ƒ–Ã)³3ÃR-ÃG+ÂäQhÂÑ#×ÂØÂÒ”þCúCúCúCúCúCúÂÏhCŽ|ÍCúC®æ%AÇ+Ck[#CúBwDœÂÖ’oÂäIºÂæ[#Âäô¼ÂßøRÂØ'ðÂÎŽVÂĹgð®ó¶Âˆ†¨Â–¯§G®Âº•ÂК Âè·LÇ+à õÃçÃìà œÃ¤ÂìiüÂÛlÂÖA‰ÂæuÃsøCúCúCúCúCúCúÃh1ÂÅàÅÂK+B\”{AÎ¥ãBEáHCµ²Áª× ÂËs¶ÂÓš ÂÔ•ÂÓˆ1ÂÏë…ÂÊ+‚ ºœÂ±¨$Z‚¨öÂŽ¥`œ;ç«hs»àÅÂÌäZÂÝ ÂêìÂñ²°ÂòcTÂì„ÂâoÂ×ÒoÂÑ)ÂÓ`ÅÂå"ÑÃ/žC%`CúCúCúCú¾2°Ã *Âæ BÂÄ PŸ¤Ý¢ Á¬ð!›æf· ºÂÄ ÅÂŶÉÂÆ ÂÅ$ZÂÂLJ½¥`·—°š Â©¡féÂyMÓ†¸R‘ËD»çª0¤Â¶†%ÂÁÂÂÊ­‘ÂÐ!HÂщºÂÏO\ÂÊî˜ÂÆ¿}ÂÅ«…ÂË+ÂÚ°¤Âùà ±ªAŒ$ÝCEÁõ&éÃ0!Ãu?Ã¥ãÂÞ¨sÂÈt9¼^5¸6É·âN·éü¹‰Â¹¬º¨ÂºøÂ¹¶¤Ý²É7­Ã§æf¡ƒšÜ)Âmˆ1Â~k…ˆC–‘¿}›Z¤™šÂ¬Ý²Â³vÉ·և¹ÎV¹¾ú¸¦é¸ 7¹½ô¿Æ%ÂÌìÂàÂû5Ãà HsÃwÃó3à QìùšÂæÄœÂÐÂÀk¶hö±J=¯s¶Â¯J=¯–¯äZ°)¯âѮŬˆ´Â©1'¤æfŸãTšaH”–‡ÂbTþÂpPÂxÕ‡bNÂŽ÷Ï–'ðœŽV¡È1Â¥“øÂ§ì©!Ë©áË«#T®+³¬¼ìÂÉô¼ÂÙ BÂèÈ1ÂòÊÁÂô Âì/ÂßféÂÐ>wÂÂ&f¶Òò®èsª6F¨§Z Â§`B§‰7§‚§¥¾ú£ž¸Â  Åœ߾˜‚“´9ÂŽž5ÂWáHÂcî˜Âp`BÂ|î˜Â„œ)ŠdÝ“øÂ“ó3—dZ™ó¶Â›ß¾Âœ¬ÂŸÆ¨Â£´Â§ùۮFÂÁaËÂÊ2°ÂÐ =ÂÑZÂÍïÂÆô¼Â¾#Tµ8Õ­z^§œ)£Â¡¡Ë °¤Â \¬Â 0!ŸևŸb±'›£T˜æé•Ó‘³3ÂuÈõ?ÂN=qÂXŽVÂcuÂm’oÂwǮ€²-Â…VˆÛ#ÂŒ PÂŽ³¶Âýq“7ϕÙ ÂB ¢š¨Ðb¯A´ñªÂ¸ÎVºb¸ŒJ´Á‰Â¯ŠÁ©ê¤¸Õ …¢Â‡+›¤Zš’o™õÙwÏÂ˜ÓøÂ—Ø–bÑ”dÝ‘Ý/Žև‹dZ‡²ÂƒšÂEhsÂNVÂWZÂ`KÇÂh÷ÏÂq-Âx¼j„‚ÁÂ…hs‡ÚŠH1Œ푓«…—éyœ‰ºÂ¡#TÂ¥$Z§õ?©)ü¨£×¦/£ŒJ %œ—™¤Z—^¸Â•Ĝ”®“ãד*Â’Pb‘/žÂ®ÂÀƒÂ‹d݈¢ÑÂ…‡+‚#TÂ}oÂ=XÂE&éÂLýôÂT½qÂ\C–Âcm‘Âj¾ÂpIºÂuì‹Â{¸Â€´Â‚‰Â…/‡úá‹*ÂŽ¤ÝÂ’C–• ˜É7›œ+œ2°Â›5?™t9—I7• DÂ’ÿ}‘KDÂõÃÂŽë…ÂŽ ÁÂ.ÂŒ2-Šûd‰wL‡œ)Â…hs‚àÅ€ÙÂyýôÂs~úÂ5ûçÂ<âNÂCɺÂJš ÂQ=qÂW›¦Â]£×ÂcLÍÂh™šÂmž¸ÂryÛÂwRòÂ|Tþ€Ï\ƒž¸Â†ŽV‰ƒÂŒNÙÂŽ¼j–‡Â‘·LÂ’呲°ÂÖÂwÏÂŽ+ÂŒž5‹X“Š>ú‰I7ˆcׇvF†iyÂ…*ƒ«…Âå`­Â{ÂuàBÂpQìÂjn˜Â/@ƒÂ5iyÂ;\ÂA£×ÂG’oÂMNÙÂRÌÍÂX 7Â]%ÂaÑìÂf~úÂk'ðÂoäZÂtÖÂyƨÂ~Ü)Âí‘„C†L͇ès‰‰‰7‰ŒJ‰ ňe`‡}ô††¨Â…“u„­ƒÎÙ‚î˜Âýô€í‘Â`BÂ|xÕÂy¦ÂuDœÂpøÕÂlDœÂg5?ÂaÛ#Â){Â.Ÿ¾Â4(öÂ9¢ÑÂ?ÂD9XÂIDœÂN¾ÂRÏßÂW\)Â[ÑìÂ`>wÂd¯Âi,Âm°!Âr,ÂvÂz‡+Â~\€xRÂ…¢Â‚)y‚gm‚NVÂñ'ÂdÝ€¼î€+Â~’oÂ}%Â{^5Âyˆ1Âwp¤Âu1ÂrA‰Âo{Âk‚ Âg‹DÂc;dÂ^œ¬ÂY»dÁw®Áj¬Á[¸ÁHÔþÁ3²ÁdZÁ(öÀÄ1'Àƒ ¿ùX>ƒ•@÷Ï@²@É&é@ö-A ¸A £×A Å@ݲ-@š J?ÿ¾w¿°A‰À£dZÁ(öÁM÷ÏÁ„E¢ÁŸ¬Á·"ÑÁÌZÁßÁïQìÁý‹DÂë… #×ÂuÃÂçmÂÂNÙÂ^5ÂÁ‰Â‹DÁÁt{Ác‡ÁNÄœÁ6È´Áí‘Àö¬À®vÉÀ>È´¾£Sø@5?@©xÕAZA'ÎÙAH{A]ïžAfVA^áHAF9XAƒ@Ç ?ó•À7l‹ÀúÁIãTÁˆjÁ§áHÁÃ"ÑÁÚ‹DÁî´9©üÂ1'µ?Â9XÂÀƒÂRòÂüî ÎÙ áH IºÁ‡ƒÁ€+Án“ÁW× Á=oÁ`BÀðÝ/Àœ“¿ò°!?±ÊÁ@&éA %AC =Ay33A“®A¤jA¬ƒAª%A›ÊÁA¸RA9çm@¿Sø¾„›¦ÀÕ/ÁK× Á‘(öÁµÀƒÁÓ÷ÏÁì÷ÏÂ1 !ËÂbÂ푹XÂ#k…Â&þúÂ)yÛÂ*éyÂ+e`Â+ =Â)ô¼Á—ÁˆVÁ|í‘ÁdýôÁG•Á$1Àó\)À“¿n—@F$Ý@ðÌÍACß;AˆA­¾wAÎÆ¨Aè=qAö“uAö©üAæl‹AÅdZA•A1KÇ@,›¦Àº\Á[oÁ¢\ÁÌ33Áì1‚  æf Â%ãÂ%RòÂ+iyÂ0H´Â3ß;Â6/Â7IºÂ7MÓÂ6_;Â4¥ãÁ™‰7Á’bÁˆA‰Áw\)ÁW²-Á0ƒÁ´9Àް!¾hr°@•xÕA#G®A‚7LAµt¼Aè´9B \Be`B+œ¬B.#×B%"ÑBúáAß =AŒ"Ñ@»®À¾—Á„‡Áʼn7Áò1'³3ÂA‰ÂF¨Â#ÖÂ, DÂ3”{Â: =Â? ÅÂB°!ÂD»dÂEYÂD·LÂC%Â@záÁ¥©üÁž—Á”ñªÁˆ$ÝÁo ÁDáHÁÀ™š<‹C–@¼å`AL¬A¤-Aè1BJÁB9e`BVÍÓBk=qBrl‹BibBMÁ‰B!aHAÍÀƒA l‹Á33Á¸jÂÝ/Âå`Â"È´Â&êÂ,DœÂ3†%Â;ÎÙÂCñªÂJûçÂP]/ÂSÚÂUwÏÂUbNÂSÛ#ÂQ'ðÂMPÁ´E¢Á®bÁ¥‡Á˜¡ËÁ‡áHÁc®Á*¼jÀÄ´9¾ú^5@ÎùÛAm…AÅffBRòB?³3BpÂBŽÆ%BŸ¶FB§˜“B£r-B‘É7Beô¼BiyA7hsÀj JB–‘ìBŸs¶Â"ÑÂJéyÂAÊÁÂ?ÂD­ÂMvÉÂVÊÁÂ^ÌÍÂd•ÂgäZÂh× Âg½qÂdùÛÂ`ïžÂ[÷ÏÁÅ©üÁÀë…Á¹KÇÁ­ùÛÁïžÁ‡ïžÁTÔþÁoÀ ‡@¼ƒA~í‘Aár°B*¥ãBl[#B™B B»@ƒB×BæËÇBäàBBÎ,‹B¢ùÛBLwÏBp¤CúCúCúCúÂC„Âa§ðÂS…ÂV“uÂa:^ÂláHÂvgmÂ|©ü‹DÂhsÂ|ÎÙÂxVÂr…ÂkÐåÁÚ ÅÁבhÁÒ-ÁÉ =Áºó¶Á¦n˜Á‰…ÁCp¤À¯\)@_KÇAs7LAðß;BB+BŒÁB¾ ÇBðß¾Cð!CèsC }ôC$ZB曦B˜…¢CúCúCúCúCúBè^5ÂvÎÙÂd²-Âh¼jÂx+ƒàB‰¦fÂŒíÂàÅŒ녊„‡“ƒœÂ}¾ÁñÝ/Áò^5ÁðKÇÁê§ðÁà/ÁÏ+Áµ^5Á¬Á3xÕ¿ÛC–A6§ðAç÷ÏBN”{BŸƒBâ^5CñìC9DZCZiüCQhCiAËC%9XBßyÛCúCúCúCúCúCúÂ+‘hÂlhÂ}#׊ •+…›äÝžéüÂž× Âœo˜iy“_;ÂŇïÂÂÊÁ \ ÏßÂffÂùÛÁðÊÁÁÒ Á¢KÇÁ29X@+SøA´ÀƒBE¡ËB§‚ BÿݲC:!‰CtÝqCÌÄÝCúCúC‘éÛC—ÏCúCúCúCúCúCúBìDÂdð¤ÂŽ›¦Â ¦Â¬¦f³~wµRo³KD®™šÂ¨A¡´Â™{d‘ô9ÂŢ­ÂþúÂ"F¨Â#ë…Â#2-Â5?¼jÂ}ôÁØ =Ác¶F@ò—B|îBT{C+½qCúCúCúCúCúCúC1³3C-*ÁCúCúCúCúCúC—‰Â€ùÛ­ùÛÂÁMPÂÍAÂÒ;dÂÑ8ÕÂËÒòÂìº ° ¦%œxRÂ&§ðÂ.ÐåÂ7 7Â>ò°ÂFbÂKÚÂOüîÂR¶FÂT±'ÂPƒÂA€¡ËB7gmB˜}ôCúCúCúCúCúCúCúCÉZ=C@s¶CúCúCúCúCúCúB‰Su¨¶FÂïî˜Âù²°Âù Âó†%ÂèÎVÂÛ­ÂÍ¿}ÂÀ J³!˧=qÂ8õÃÂEVÂR ÅÂ_ó¶Ân,Â|n˜Â…ƒÂŽ@›üÕCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÍÁÃVÉ×ÏÃWÏüÂö9ÛÂâ»dÂШsÂÀ_;±æéÂLTþÂ]hÂp J‚§mÂŽSøÂšß¾Â¨iü¸ÂÂÐÏßA½©üCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCOo\Ã;;#Ã3DÝÃ&úÃ}²Ã #×ÂøøÂá ºÂÍ5»ûçÂ`?}ÂvE¢Âˆ#×—e`©¢Â¼ÒòÂÒRòÂéÓøÃpbBŸ×CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂùÛÃ`½²ÃTt9Ã?àBÃ*vÉÃêÁÃ/Âð PÂØåÂÄëÂsò°Â‡Þ¸Â˜å`­ÍPÂÇI7Âå”þÃÌà Ã$*=ÃÇðCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃPÛdÃ{5Ãt ƒÃXyÛÃ;¶‡Ã"ÕÃÃ…¢ÂüOßÂáÏßÂ̬ƒ7L” Í©e`ÂÄÔ{Âèhsà *=Ã'z^ÃE¢ÃX‚ ÃWbÂÑ}qCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁ´9Ã}'®Ã‡é7݃ÃjáÃG©ºÃ*ËÇÃÃ49Âè–ÂÑ ºÂ‹C–žÉ7¸EÂÚožÃÓ¶Ã&qhÃT‘hÃ\Š=C,µCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃJô9Â/Ç`Ã…°ƒÃm¿¾ÃJx“Ã,ç+ÃÂÑêÁÂꙚÂÓ[#‘§ìÂÃËÇÂë‚Ü)Ã?ìÃkè1CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂé<îÃHò°Ãqþ5À³–ÃzèöÃa#×ÃBùÃ(±ìÃt{ÃvFÂé|jÂÓ•ƒ–¬%`Âʆ¨Âõ ÓÃÉÃL ºÃ:›çCúCúCúCúCúCúCúC1žwCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÓâNÃ+3øÃO`Ã_xÃ[\)ÃIá‰Ã4-ÙÛÃ × ÂýèsÂåhÂÐ;d—®Â­‘hÂËŸ;ÂõRoÃ/ßÃH±'Ã]ƨCúCúCúCúCúCúCúBNÙC:²°CúCúCúCúCúCúCúCúCúCúCúCúCÔ}¤Ô{ïßÃ,âNÃ: …Ã:)7Ã0Å¢Ã"Þ5Ã3Ã0¤Âó©yÂÞ¸ÂËvÉ–¸Â«z^ÂÇhöÂíÃõÃÃ7ÃTÃlò°ÀÜ‹DCúCúCúCúCúCúÂCÍÓÂ\'ðC¦ƒCúCúCúCúCúCúCúCúCúCúCúCúB§ JÂè߾ñhÃMäÃóøÃmPÃ5ÂûƒÂç­ÂÕ‹DÂÅE“!˦ƒ–¿!ËÂÞûdÃ~5à Ÿ}ÃEí‘Ão>5Ãz'ÃW‡®ÂÈ´ÂÆT{Âþ ÂȺì‹Â¦ 7Áßl‹CúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÙt9à ú^à )üà \Ã=qÂúeãÂêÖÂÛ)yÂÌ'ð¾1ªÂŽ“øÂŸ‘ì´gðÂÎÂíÇ+à /à O\Ã6ŽVÃE€ÅÃD²-Ã3mÓÃ…¢ÃV‡Ââl‹ÂÅz^ÂÁ±ªÂÎþúCúCúCúCúCúCúCócuCúCúCúCúCúCúCú@ã× Â÷ËDÂûoÂ÷ð¤Âðì‹ÂæüîÂÛNVÂÎì‹ÂÂ’o¶±'‰—‹Ç¨µÃ¼âNÂÔ6FÂî6ÉÇ®ÃWLÃ|îÃt¼Ã)yÃãTÂëìÂÔ\ÂDzÂÏ^5Âî‘hCúCúCúCúCúCú ¿}Á&QìCúCúCúCúCúCúÁ¼¸Âã#×ÂåÂât¼Â݇+ÂÖ=qÂÍF%ÂÃc×¹1'¯šÂ‚õ?Â-‘¬¬Ǯ½í‘ÂÏÍÓÂàâÑÂîÆ¨Âö±ªÂö·LÂîþúÂáäÝÂÓVÂÈ%ÂÅ&fÂÑ ÓÂñ”þCœîCúCúCúCúCúÃàÂýúÂŒñ'ÂF%”JÁ˜Ú—¡øRÂ¥bN§W§/¦Qì£Ý/Â × Âڠ›\¬Â™–‡Â˜‚—î˜Â—”þ—2-–b•‹D” DÂ’´Â‡+ÂŒ‘h‰9ÛÂ…”þ¸RÂ<éyÂD¢ÑÂL`BÂSþúÂ[ZÂbLÍÂhº^ÂnbÂsÍÓÂxŽVÂ}€¸Rƒ{Â…¹ÛˆÀƒÂŒ'ðÂÐå“}qÂ–× Â™‚›5?›ÌJ›V‡ÂšÙ˜NV–r°Â”ȴ“yXÂ’‰ºÂ‘߾‘Rò·LÂæéÂŽÅ¢ÂC‹X‰%†UƒRò€VÂy/Â5’oÂbNÂC€ÂHm‘ÂM(öÂQ¸RÂV#×ÂZ{çÂ^ÐåÂc5?Âg³3ÂlIºÂpë…Âu{çÂyÒòÂ}ÀƒÂ€Š=ÂÖ‚º^ƒ8Rƒ\)ƒ9X‚äÝ‚qªÂíÂ]/€À€ ÓÂ~xÕÂ|„Âz+ÂwaHÂt"ÑÂpožÂlMÓÂgɺÂbïžÂ]ÏßÁs|îÁe÷ÏÁU× ÁBéyÁ,ýôÁûçÀïÆ¨À±ÂÀ]`B¿Ÿ;d?ƒt¼@QX@¬ Å@çoA záA\A©üA1'@öáH@¯Sø@!&é¿ë…ÀœÝ/ÁC–ÁO Á…¡ËÁ¡1Á¹l‹ÁÎáHÁá¬Áò¸ÂE¡Ë@Œ¬AVA_?}A—ùÛA¾ïžAájAûÌÍB¾B¶FA÷+AÓ JAž´9A;‰7@/ÎÙÀÊ5?ÁiXÁ«ZÁÕ+Áô;dÂoÂÂÒòÂ × Â(Â.)üÂ3¦Â6ÀƒÂ9uÂ:&éÂ: Â9uÂ7“uBs°!B…Á‰Â='ðÂ\2-ÂL%ãÂEäZÂISøÂQÌÍÂ[k…ÂcÔþÂièsÂmSøÂn7LÂlí‘ÂiäZÂe‡+Â`6FÁÁ|îÁ¼Á³~úÁ§bÁ•£×Á{ÊÁÁ<^5ÀÑë…>H´9A 7LAKÇBéyBC‹DB†LÍB­¾úBÔ0!BóaËCþúBÿäÝBäB±¸RBW‚ Aˆ“uCÞ¬îCúCúCúÂVl‹ÂlŸ¾ÂZ$ÝÂ[+ÂeãTÂrvÉÂ|ÍÓÂփBƒ)¤ZÂ~]/Âx\ÂpÛ#ÁÕ¡ËÁÒ=qÁË× ÁÁjÁ±¸RÁ›¸ÁwVÁ vÉÀ-ó¶@àÄœAžl‹BæfBc6FB£vFBܼjC T9C&éüC8`ƒC;‚C([¦C!Bœ²-B¤UCúCúCúCúC…aËÂR33ÂfiyÂkLÍÂ|ñªÂ‡gðÂê‘‚Â’wL‘O\ÂŽ™ŠÑh†_¾ÂbÁí JÁì£×Áél‹ÁâVÁÕûçÁ‡+Á¥~úÁvýôÀÿ+@ r°Aˆ1Br°By§ðB¾º^C¬ÍC5×LCiE`C¡k#CúCúCZRoBæ…C]ý²CúCúCúCúCúCFÚáÂHOßÂzÓøÂiyš¡ð¤Â¥F¨Â¥+¢/œ)—þú‘Ø‹‚ Âò°Â½qÂ`BÂPåÂ× ÁõùÛÁÞïžÁºÐåÁƒÎÙÀÃKÇAß;AýÝ/BzÀƒBÐCàÅCiTCÞ9šCúCúCúCúC+NÙCúCúCúCúCúCúCúA!Š$Z¤bÑ´yÛ¼/¾wÏ»Ðå¶8ծ녦Ê=žm–2°Â‡ÂuÓÂ|îÂñªÂ”{ÂDœÂ k…Áê¡ËÁ¦°!ÀÇPAŸ¾BSÚBËÀC0”9C­Ÿ¾CúCúCúCúCúCm¢ CÝõãCúCúCúCúCúCúB‚)yªbÑÂÊÊ=ÂÚÔþÂà—ÂÞ´¼Â×»çÂÍÚ¦é·)ü¬¡|jÂ#Ý/Â+vÉÂ2öÉÂ9í‘Â?Á‰ÂC·LÂE¾ÂCŒJÂ>˜“Â2H´ÂËÇÀ±7LB9%C‡mCܹCúCúCúCúCúCúCúC#yšCúCúCúCúCúCúCúÂî˜Ã'®ÃæfÃkÇÃÖ‡ÂùbÂéIºÂضÉÂÈäZºO\­5Â6ÂAš ÂMð¤ÂZÊÁÂg¬Ât—…ñªÂ;盲Á€…C½þÙCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÞÃ.¨1Ã(UÀBÃß}Ã*=Âð¦fÂÛvÉÂÈáH¸´¼ÂIhsÂYbÂkÎÙ€V‹{–²°Â¢Å¢Â°…¢ÂÅ—ÂÉr°CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA„%Ã^‚ÃQ«DÃ<ðåÃ'øRÃÝøÕÂîÂ×+Âú^Â]LÍÂrÁ‰Â†+Â”× Â¥âN¸ã×ÂÍ8RÂâÏßÂý™Âó^¸CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÒ`BÃ!ÃaŸ¾ÃAbÃ& ƒÃ©üÂÿ6ÉÂãÖÂÍŒÍÂq† B–Óu«V‡ÂÄ[#ÂâúáÖÃ!òòÃ)ò-C |jCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ…õì‹ÃYxRÃ5€ƒÃÕöÂî@ÂÕ}ôÂÁÂ’U§bÑ€ÂåÆ%à Ã×Ã&2òÃD5?ÃXsuÃT¨sÂŽBCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúØËdÃk¼jÃ@*=Ã!¡‰Ã nVÂõ@ƒÂÚð¤Â‰ÒoÂ#¶UÂØAîÙÃ%†¨ÃTç+Ã^®ÙC8aHCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC¼G ÂRuCúCúCœÃÎÃpféÃC×Ã#°åà )Âø$ÝÂÝ~w‡¥nÂÁíÂéuÃòÃ>«Ãn§mCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁË;dÃC¤CúCúÃ:‚NÉ÷LÃdŸ;Ã=}à ´{à Ÿ}ÂöÎVÂÝ{” Bª‹ÇÂȶFÂóÃ(´ÃKÅ`Ã?8“CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCú@àQìÃJÅãÃrXRÃÐåÃ…F%ÃqòÃN?}Ã0͑è1Ãp!Âñ·ÏÂÙõ?•¬¬ÂÉÙšÂóbNÃúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCëŒîܬÃqhÃòoû¦ÃæfÂùÂæÍPÂÕ®ÂÆ¨ÂT{ž;²»dÂÌ1'Âë¤ZÃú Ã@BÃ5ðbÃE’oÃ;ÂìÂþ0!ÃRòÂÔÔ{´1ª©+CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÓ!ËÃ~wÃk…ô9Âõ.ÂçYšÂÙ\ÂËò½Óu‡Ñh–%`§»ÂÒ\ÂëËÇÃ8ÃNÃBNÃEãÃz Ã$œÂâ¢ÑÂÅœ)³`Å´ž5ÂÊ£×CúCúCúCúCúCúBtoCúCúCúCúCúCúCúCúÂÙXÂö´Âñs¶ÂêáËÂâ1Â׊ÁÂÌúÂ¥ýô¯¾w½‡ÂÌ&fÂÙ‹DÂás3ÂáÂÂÛÂÏÌÍÂ÷ϹǮ³º^±¥`²X“´ ºÂµSøÂµÕµÑìµ2-³ Å°ñ'­.¨ƒ–£)üÂ\)—MPÂUÏßÂaPÂm›¦Ây¬‚«ˆ DÂŒ°¤ÂZ Â’áH”F¨Â”ޔÒo•b–=q™ ÇÂüjÂ¥)ü®{·‡+¿¿}ÂÄíÂÅåã«…¼c×´øÕ®]²Â©í¨¨ B©E¢Âª‡+«\¬Â«ŽVª÷Ï©yÛ§ Ç£½ôŸ°¤Â›\–œÂ¸ÕÂL@ƒÂVA‰Â`cTÂjgmÂtÂ|Ý/‚OßÂ…‚‡õ?‰´9Šî‹ô¼Â1ªÂÂ’øÂ–[#›äZ¢I7¨Ĝ®V²³(s±ºá®NÙ©ô¼Â¥Ø¢ۦ¡W ¡šÂ¡²Â¢Qì¢Ţ¢´9¡öF xRž7L›A‰Â—¯žÂ“Ÿ¾Â3¶ÂЉºÂCŒJÂL-ÂTÔþÂ]VÂeyÛÂmÂsÄœÂy“uÂ~ffÂ-‚ۦ„vɆCˆ‡+‹|jÂ:á“®˜ˆ1ÂKÇ¡^5¤1'Â¥gm¤úá£@ Ñhž^5œr-›O\šèsšøÕ›)y›-šÊÁ™àŘ]²Â–?}“ßÂ`BÂŒÇ+ˆݲ„ºáÂ;¢ÑÂC-ÂJ²-ÂRbÂY¾Â_¾wÂeÈ´Âk/ÂoñªÂt+Âx\Â{ë…€ D‚s3Â…KLjœ)ÂŒMÓÂ)y“Ü)—+™Vš“uš¼jš–˜Á—[¦Â–(ö•Tþ”áË”¬”‰Â”/žÂ“ŽVÂ’‚ ÂýqÂŽýqÂŒˆ´Â‰©ü†s¶Â‚÷LÂ~ŽVÂ4qªÂ;¬ÂA¾wÂH=qÂN€ÂTm‘ÂYò°Â_ 7Âc´9Âh DÂl33Âp`BÂtÈ´Ây²Â~þú‚t¼Â…š ÂˆÈ´Â‹É7ÂŽ_¾ÂYšÂ‘–‡Â’‘ô9‘gmªÂñ'ÂYšÂŽèöÂŽÓÂŽ+…¢ÑŒؓ‹¸RŠ8RˆTþ†oƒyX€–Âzë…ÂtPåÂ-äZÂ3ÚÂ9Ç®Â?—ÂE:^ÂJŸ¾ÂO¼jÂTŽVÂYšÂ]qªÂa¯ÂeõÃÂjdZÂošÂt ÅÂyp¤Â~éy‚'ð„®†àBˆž5‰ÔþŠ‚Šº^ŠšŠDœÂ‰Ú‰o‰+ˆ›¦Âˆ¦Â‡t9†’òÂ…lƒõÂ/€Â{yÛÂvBÂp¡ËÂj°!Â'å`Â-G®Â2¢ÑÂ7çmÂ= =ÂBÂFÅ¢ÂKW ÂO»dÂSþúÂX49Â\ožÂ`Å¢ÂeDœÂið¤Ân½qÂsbÂx@ƒÂ|›¦Â€7ÏÂÈ1‚ô9ƒ¸Õ„"Ñ„B „,‹Âƒõ?ƒ©yƒLÍ‚ܬ‚Oßš Â€±ªÂ“Â|KÇÂx÷ÏÂu ÅÂpÐåÂlÂgÂa ÅÁo…Áa¡ËÁQ Á=ÂÁ'dZÁ ë…ÀâÀƒÀ£Æ¨À?²¿@Äœ?Ÿ@s33@½Oß@øA‰AÙA záA"áHA~úA›¦@·"Ñ@+Sø¿q&éÀ&éÁ\ÁQ\)Á‡¬Á¢ÀƒÁ»IºÁÐ× Áã¶FÁô=qÂW ™šÂ î˜Â[#ÂãT‹DÂ_;Âl‹ÂÅ¢Â~úÁxÐåÁiÊÁÁW¡ËÁBÁ(“uÁ "ÑÀÓoÀ‡¥ã¿Ò\?’°!@‚¬@àjA‘hAFVAgC–A|å`A‚Az{A]× A/‰7@âV@™šÀ.{Àÿ…ÁPÀƒÁIºÁ­“uÁÉ/Áà¬ÁôÐåÂ&é ȴÂgm 7©üÂH´Â!èsÂ#•Â$aHÂ$cTÂ#³3Á‚SøÁt°!Áa ÁI"ÑÁ,\Á ÙÀÇKÇÀ["Ѿ‹Æ¨@LZ@ÜõÃA+ûçAhÔþA°!A¨‡+A¹dZAÀÌÍA¼´9A«í‘AŽ|îAKp¤@Ñ%¾yÛ#Àä1'ÁYKÇÁ™²-Á¾ûçÁÝoÁõ‹D P ûçÂÞ5ÂËÇÂ"´9Â'†%Â+33Â-»dÂ/+Â/™šÂ/#×Â-ë…Á‰ÂÁt¼ÁnÁT{Á4jÁIºÀÂ{À0r°?…Â@ª~úA \Ap¼jA¡G®AÈ¡ËAëE¢B¶FB –‡B“uAý=qA×"ÑA —A:Äœ@"ÑÀÜ9XÁu&éÁ±ïžÁÛ´9Áú33«ÂBÂÜ)Â"ÊÁÂ)úáÂ033Â59XÂ8î˜Â;IºÂ<^5ÂwÂu'ðƒüjÂX–øÂž/§÷ϸ³3¯þwB§gðCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ(SuÃt¦fÃl¨1ÃPÂÑÃ5{¦Ãg®Ã vFÂøÂÞ³¶ÂÉÄÂWRòÂk.Â'ðÂŽzáÂwÏ­/½޸ÂÍ,‹ÂܧðÂñO\Â×DœC¯îCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃq‰Ã=²ÃTÃ2JÁÃäZÃyÛÂì•ÂÔLJÂjzáÂì‘LJ£ì‹Âº7LÂÔ ºÂïæfà Ì‹Ãý²Â܇®CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCèTÔí‘Ãs`ÅÃD¬‹Ã$€Bà \jÂ÷ð!ÂÜÛ¦Â|yÛ·Ï¡*¹ܬÂÙ_;ÔþÃvÉÃ0ÿ}ÃB+DÃDiºÂÕ¯žCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃoÏ\Ã…óøÃQÒòÃ,^¸Ã¤ÝÂÿ ÅÂâĆ˜ ůu?ÂÎWÂøDÃDÃAUÃÃie¢ÃPïB…LÍCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB™ÖɼÃUpbÃ.È´ÃŒÃl‹Âå“uÂŒ6É 2-ºŽÙÂÞ€ÃÑ'Ã/9Ãg ÁB‹âÑCúCúCúCúCúCúCúCúCúCúCúCúC•|‹CúCúCúCúCúCúCúCúCúCúCúCúCúÃ{ÁÃ6fÃN!Ã+Q'Ãé7ú Âå2°Â49Â¥7LÂÁ#×Âç¦fùÛÃ:ËDÃqФCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC-;¦Ã(ìCuRC¼zÃNYšÃˆª^ÃdºÃ>ô¼Ã#3¶ÃH1ÂûüîÂáê‘ÎV¦ÄÂÂp¤ÂèAÃ" Ã7ÉyÃmñ'C0× CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ^³uÃ{²°Ãwz^Ãa(1ÃEãÃ-49ØRíÂózáÂÜKÇ‘‡Â¤úá¾ÀÂá%ÉÃ)CÃW³uÃr49C˜CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÔí‘ÃGÃEìÃ;?Ã,åÃ=ôà bÃ!‰Âé¬ÂÕ´ÂŽ_; s3·6FÂÔMÓÂùøRÃ}qÃ4­‘ÃW—LÃ^ŒÍCúCúCúCúCÚÚ ÂâNÁ ¡ËB¦–CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÕÃÃ&ëÇà ËDÃݲà oßô{ÂðÙÂÝåãÂÌɺŠ%`š ­NÙÂÄÝ/Âá|îÃÆéÃõ?Ã'Þ5Ã4¸“Ã#HÂ5På®ãTÂåߺ±ªÂ—cTŠÓÂq =CúCúCúCúCúCúCúCúCúCúCúCúCúCúCú?ºáHÃ&éÃðÃ&éÃñìÂòbÂâ®ÂÒ‘hÂÄ„ð¤Â’‰Â¢k…´ò°ÂʸÂá[¦ÂøêÃ¥à ÁËà yÛÃÙšÂïKÇÂΘ“®×˜›¦Â”£T™²°CúCúCúCúCúCúCúCúCúCúCúCúCúCúCú§³3ÃÂÿ¤ZÂ÷_;ÂìëÂàëÂÔ=qÂÇß»SøÂ~wÏŠ¥`—ßÂ¥ó3µ‚ÂÅyÛÂÔffÂà{ÂåþwÂä7ÏÂÚ`ÅÂÊ P¶¨s¤¼j™B™©üªéyÂÏßCúCúCúCúC]úABQìCúCúCúCúCúCúCúCµ›dÂ醨Âí× Âé BÂãÂÛ-‘ÂÑÎVÂÇš Â½5²¾úÂrÐå‚í‘ÂZ Â˜†%¤\¯JÁ¹1ªÂÀs¶ÂÃÅÂÂNV¼"Ѳk…§KÇŒ͘DœÂš¯¨/žÂ†¨ÂÞ…‘!ËCâ#3Ct5Üjà úáÂæÅ¢B³éüCúCúCúCúCú­r°ÂÜ·ÏÂÚ¢ÂÖÏ\ÂÒ7LÂËüîÂÄvF¼šÂ³T{ª|îÂgqªÂwOß„“Œٚ•’oÂÀ¤²°Â©§m«ò-«ú—n˜Â•À™å¢ó3´'ðÂËTþÂâš ÂïÖÂùxRÂùÇ+ÂëŽVÂØYÂÃöF›ŒÍœÃºß«LJÂÀšÂÌ{ÂËNÙÂÉÙšÂÇ’oÂÃäZ¾Ï߸œ¬Â±£Tª8R¢¡ËÂ\®Âiô¼ÂwÀƒÂ‚ٚ‰Ÿ;ÂÒò•˜Á‰Âš´¼ÂšÂ™%ã–xÕ“«‘áHÂ’NV•þwž5©)ü·PÂÆvFÂÒ“øÂØs¶ÂÖ ºÂÌ~úÂÀ\µ’o°"N°G®Â³÷ϸ8R»B ¼²-½ D¼lºœ¬Â·ƒ–³=ô®¨¬Â¡Å›5ÃÂR®Â]ãTÂiQìÂt«Â‚ „«ˆÌÍ‹äÝÂËDÂŽ~wÂŽ5ÃÂ`ÅÂŒ¡HÂŒµ?ÂŽXÂ’5˜H´Â /ªC–³Ðå»r-¿Rò¾gð¹G+²)y«É7¨!˧¶É©°¤Â¬š Â¯3¶Â°áH±}ô°ÿ}¯_¾Â¬¨s¨øR¤}ôŸj™ïžÂ”9ÛÂIƒÂS{Â\µ?Âf&éÂo¬Âw™š@f@è£×A0ñªAlŸ¾A‘ÙA¨ÐåA¸¸RA¿(öAº+A¨°!AŠÎÙACÎÙ@ÂV¿)xÕÀïïžÁ^ffÁ›ó¶ÁÁ1ÁÞ÷ÏÁ÷SøÂèsÂØÂÅ¢ÂÖÂ#Á‰Â(§ðÂ,gmÂ.ûçÂ0r°Â0ãTÂ0k…Â/-Á†Ý/Á|Ÿ¾Ág33ÁLÄœÁ,£×Á¬À±‡À ó¶?ʬ@ºáHA( JAw A£®AÊ AëdZBVB.BxÕA÷ïžAÑ9XAš²A/¥ã?é7LÀì1'Á{ÎÙÁ´çmÁÞ…ÁüÛ# áHÂ\)ÂæfÂ#ÙÂ+¬Â1m‘Â6ŽVÂ:XÂ<ÖÂ=Þ5Â=ɺÂ<¯Â:¹XÁ²Á†å`ÁwdZÁ[¸Á7ûçÁ éyÀ±º^¿ÖÈ´@7²A©üA_ë…A£p¤AÙ|îBPBöÉB3/B>&éB>)üB1ˆ1BûçAån˜Aˆƒ@…©üÁ =qÁ¡=qÁåȴ¿}ÂTþÂJÁÂ$“Â+JÁÂ2øÕÂ:‹DÂAMÓÂFº^ÂJ‰7ÂL­ÂM?}ÂLp¤ÂJyÛÂG–‡ÁšbNÁ‘ÌÍÁ†l‹ÁoXÁIº^ÁzáÀ¿ïž¿Ã× @vVA#AŒß;AÏ®B @ƒB1ñªBU÷ÏBtuBƒš B…RòB{p¤BYoB%/AÅå`@¼(öÁWº^ÁñõÃÂ%Â7¦éÂ:‡+Â8°!Â8å`Â= ÂD?}ÂLaHÂSß;ÂY¹XÂ]ƒÂ_2-Â^ùÛÂ]#×ÂZÂUèsÁ§xÕÁŸn˜Á”QìÁ…jÁc¥ãÁ1VÀáX¿þvÉ@ˆ¼jA>¬A¨°!Aþº^B0LÍBewÏB”þB¥}qB¶øB»B±·LBš JBjɺB çm@ÄõÃÁȼjÂNm‘Âq-Âfó¶Âj¸Â_+ÂRÄœÂQ;dÂWÄœÂa&éÂiéyÂpaHÂt+Âtò°Âs†%Âp:^Âk‡+ÂeÖÁ·-Á°1'Á¥ó¶Á—PÁƒçmÁSSøÁjÀTÝ/@sSøAL¼jA¿Û#B–‡BWÂB‘SuB¹·ÏBàhöBýyXC ÍBûÑhBÚ%B¥õ?BAÚ@™OßÂ6Û#@Û#CúCúCN%¸RÂl{çÂfýôÂmÍÓÂyê‚bÑÂ…üj‡’o‡^5Â…¼jƒ JÂBÂwÁɾwÁÄzáÁ»ß;Á®ß;Áœ/Á‚"ÑÁ=C–À¼1'?þÙAD—AÌÂB*A‰BcTB³ËDBð¸ÕCïßC5ýqCB C5š^C0¤Bé/B‰\)@¡ûçÂ|îCúCúCúCúCúÂ(öÂ{L̓ÃÂŒ€ƒÂ“eã—:^˜*–ËD“¾w‘슶ÉÂ…€ƒÁßdZÁÜŸ¾ÁÖ›¦ÁÌ+Á»ÌÍÁ£‰7Á€ÙÁ ¼j¿ÚŸ¾A(öAÇ=qB4øÕB"NBÖ;çCë…CkG®CúCúCúC•—®C,*ÁBáËDB PB½èsCúCúCúCúCúB憉”¡Ë¡›¦Â©ñªÂ­Tþ¬Á©[¦Â¤#×Âݲ—‡Â-Áø;dÁøå`Áö›¦Áð ÅÁãÌÍÁÏl‹Á° ÁéyÀýX@z\A¤záB.ɺB—&éBïaËC>‹DCúCúCúCúCúCúCúCúCúCúCúCúCúCúAýKÇ”öF¯yÛÂÀž¸ÂÈ÷LÂÊ4¼ÂÆ¿¸Õ·A®\¤ ›·Ï !Ë ³3 ¬ ŽV–‡Áîr°ÁƼjÁ‰ûçÀ¼1A/7LB vÉBŒ/BðC`g+CúCúCúCúCúCúCúCúCúCúCúCúCúCú@&E¢Â¼çmÂß(sÂð1Âôr°Âð6ÉÂæ¶ÉÂÚÂÍMPÂÀ&鳟;§ûç« =Â#¹XÂ'Â(=qÂ%õó3ÂxÕÁñ =Á¤~úÀ®¸RAÄœBR†%BÚp!CטÕCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁž“uÃŒÍÃŒJÃ33ÃÄÃøÃWLÂú#TÂæEÂÓîÂÃhs´´¼Â*…Â3PåÂwÂêÓuŠþœ¼j´çðÂÕÃyXÃmÓÃJ¿;Ão PCVÖCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCÍt9Â-¿}CúCúÂvÉÃŽ±'Ãp¾ÃF× Ã)ÿ¾Ã‡ðÂ矾‹Ãžk…¶s3ÂÖ BÃvFÃÑÃFwÃjÅCÑÈöCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃa¾ú¹Âr°Ãm1'ÃOîÃ4=ôÃ3à ¢ÂúyXÂáýô‹MP³—ÂÐ\Âö^5ÃýôÃ3­‘ÃUå¢Ãô9CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂñ ÃR`ÅÃP–ÃDÃ3ã×Ã"˜ÕƨÃMÓÂïì‹Âڡˈýq™;d­C–ÂÆ&fÂåÃóuÃ2©yÃ?ò@€bNCúCúCúCþwC#¥CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ$›dÃ/ëÃ(ÝqÃÌ‹Ã=qÂ ÂøÆ%Âär°ÂÒ7LÂ…@ƒÂ“— ¤¸R¹"ÑÂÑ(öÂ솨ÃÍÃ2òÃ'ÃC–Ã=qÂè‡®ÂÆ›¦Â˜;çÂY[#Â$üîÂACúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÏÑìÃKÃ5Ãf%Ã@ƒÂúú^ÂéyÛÂØÈ1ÂÉIºÂ€‘ìÂŒçð›&f«hö½„œÂоúÂãmÂò¯ÂúÚ Âø²ÂêBÂÑ,±p!‘\Ârž¸ÂauÂpCK‡+CúCúCúCúCúCúCúCúCúCúCúCúCúCúÂôhsà !‰Ã6ÃKDÂöPÂéÂÛ&éÂÍcTÂÀ=qÂvĜ…Ñì‘xÕž:᫼î¹9XÂÅ\)ÂÎG®ÂÑëÂΰ¤ÂÄ)y³|jŸr°Â‹üîÂ{Âp´9€^¸Â„#×B‘r-CúCúCúCúCúCúCúCúCúCúCúCúÁ̲ÂûíÂúÂôW Âí´ÂãÑìÂÙ:áÂÍñ'ƒ·TþÂlÂ}—ˆDÂ’B œbÑÂ¥þú®%`³­µs3²º^«ƒ ½q”=ôˆuÀÂ{ž¸Â„P啸հ#ºÛ#Â{ÚC‘¥`CÛÆfˆ1ºoBäc×CúCúCñªCúBŒí‘ÂÝ ÓÂçLJÂä^5Âà|jÂÚèsÂÓ£×ÂË/ÂÁظDœÂ®¹ÛÂa—ÂpA‰Â¯‡ºáÂs¶Â–‚ œC– –¡%ãŸXšÀƒÂ” ÂŒ—…ݲªµÃ‡\”xÕ¨ÑìÂÂÔ{ÂÕzá±'Ân+ÂÙÂÍ"N®uʦ•™šÂ»åãÂÄ©yÂÏ+ÂÓïÂÓáËÂÒ‘hÂÏÏßÂËffÂѾƒ¶Ê=®²-¦‚ÂWš ÂcïžÂp²Â}DœÂ„¬‹ÂŠåÂŽe`‘>wÂ’J=‘l‹ÂŽ× ‹þ‡–ƒºá‚eㄦ‰µÃ“¦é¡½ô²éüÂÄO\ÂÏ)üÂÐxÕÂÈ»d¹™šÂ¬s3§¨Âª0!²¾Âº6FÂÀÂÃ%`ÂÄDÂøÕÂÁ“øÂ½ò°Â¹Ù³5?¬±ªÂ¥ÊÁžº^ÂNJÁÂX¿}ÂcPåÂm­Âwk…€¢Âƒ‚ …푇;‡†„Qh‚Ÿ;«…‚:á„õÊF¨Â’7ÏœW§›#²4¼Â¹m‘ºº^¶øÂ®xR§ÎV¤Ö¦.˜Âªu?¯ˆ1³Ä¶wL·‹D·šÂµ>ú²$Ý­ýô©¢Â£vF†¨Â—e`ÂE·LÂN°!ÂW£×Â`SøÂhr°Âo©üÂu£×Âz¬Â|ò°Â~:^Â~NÙÂ}ÑìÂ}£×Â~Ǯ¦„W‰@ƒÂ²°Â—5?žó¶Â¥ÂªMÓ«£T©ñ'¦˜“£xR¢ƒÂ¢«¤õçàBªz^¬/žÂ¬Á‰Â¬&fªl§¯¤ ŸÎV›•Ý/ƒÂ=ß;ÂE¬ÂMdZÂTÚÂ[ÔþÂb²Âg€Âk× Âo¦Âql‹ÂsÂtbÂvzáÂy|îÂ~/‚yX†çðÂŒ3¶Â‘õ×—œdÝŸ²°Â¡#× å㟪ž^5Â֞)üŸc× ÷Ï¢`Å£9Û£J=¢zá ÎVžV›+…—o“AŽ Š\Â6¸RÂ=—ÂD^5ÂJéyÂQ{ÂV¹XÂ[»dÂ`1Âc¥ãÂf´9Âin˜Âl/ÂoaHÂsn˜Âx¯ÂMÓƒšˆÂŒ“uÂå㔎ٗ6ɘµ?™.˜ýô˜ Å˜~w˜Ǯ™n˜Âš8RšÜ)›šǮ™ÎÙ˜,‹Â•éy“ ÂËÇÂŒ¾Âˆ+„¢Â00!Â6QìÂ<]/ÂB8RÂGÈ´ÂLøÕÂQ·LÂUþúÂYÙÂ]bNÂ`ɺÂdLÍÂh33Âl¿}Âr¸Âx^5Â_;ƒhö‡#׊›¦ÂåÂÓu‘PbÂ’;Â’s¶Â’\Â’¬Â’æé“<쓼 “–‘ñ'Â[#ÂŽE‹»dˆÍPÂ…ŒÍ‚ ÍÂ|¿}Â*8RÂ/ÀƒÂ56FÂ:‡+Â?¡ËÂDwÏÂI ÂM>wÂQ9XÂU 7ÂXÏßÂ\º^Â`ó¶Âe¤ÝÂjâNÂp«Âvß;Â}A‰ÂÀƒÂ„£T‡ B‰¦ÂŠ‹D‹}ÂŒoÂŒjÂŒ¦fŒؓÂ ÂøÂŒ÷ÏÂŒ–‡Â‹Ü¬Âоú‰8R‡KD„ÿ}‚`BÂ~ô¼Âxº^Âr-Â$º^Â)ƨÂ.ÖÂ3¤ÝÂ8`BÂ<í‘ÂAF¨ÂEp¤ÂIs¶ÂMaHÂQRòÂUe`ÂY³3Â^RòÂcMÓÂhš Ân¬Âs¦éÂyÂ}ì‹Â¬Â‚áH„=qÂ…;dÂ…éy†\¬Â†¦éÂ†ÓøÂ†ã׆Ï߆‹Ç† ºÂ…=q„;‚«…€äZÂ}²ÂxæfÂs¶FÂn$ÝÂhF¨ÁhŸ¾ÁZr°ÁI¶FÁ69XÁß;Á‹DÀÔ´9À–éyÀ)X¾õ?}?ÜIº@wP@»\)@ñº^A ;dA—A A ‡@è“u@ž J?öE¢¿Ð ÅÀ°“ÁjÁW®Á‰£×Á¤ÒòÁ½‡ÁÒ…ÁåffÁö%ÂPå­²¤ÝÂC–ÂýôÂàBÂõÃÂRò DÁp´9ÁaG®ÁNÄœÁ8å`ÁdZÁ JÀÁ™šÀo ¿š~ú?¾Ù@‰?}@â¸RA× AAdZA^éyAq7LAu`BAi7LAK²-AG®@¿÷Ï?¹Û#À`bNÁ PÁX JÁ÷ÏÁ¯Ÿ¾ÁÊãTÁâ?}Áön˜Â = ɺÂPÂSøÂÂ ÓøÂ#ŒJÂ%JÁÂ&¾Â&$ÝÂ%s¶Á{oÁj‡+ÁVZÁ>bÁ!C–Àÿ À±`BÀ2=q>“t¼@hÄœ@æ JA-;dAfbAŒûçA¢OßA°©üAµÌÍA¯ùÛAžE¢A€Ý/A2=q@¦{¿¥ÂÀüA‰ÁaC–ÁœG®ÁÀÈ´ÁÞ‹DÁöõÃÂÏßÂÛ#ÂèsÂÂ$ ÅÂ) ÅÂ,õÃÂ/›¦Â1¾Â1™šÂ1%ãÂ/éyÁ„“ÁvÈ´Áa¸ÁF‹DÁ&n˜Á$ÝÀ¦5?¿÷P?ãt¼@½?}A&“uArA‰AŸ1'AÃ(öAâ Aø=qB/Aý…Aè AÂ1'A²A²-?‚\À÷ïžÁ|IºÁ³¥ãÁÜß;Áûl‹Â \) 7ÂÂÂ#ãTÂ+QìÂ1ËÇÂ7VÂ:ô¼Â=uÃÂ> ÅÂ>–‡Â=‚ Â;ŽVÁŒIºÁƒXÁoãTÁSSøÁ0bÁ"ÑÀ£+¿¤zá@J¬AÂA^r°A VAÓ`BB´9B¦B*F¨B3iyB2"ÑB%{B 33AÑr°Atb@L›¦ÁÈ´ÁÈ´Áà¶F£×ÂùÛÂxÕÂ#™šÂ+1Â2ïžÂ:¹XÂA¯ÂGF¨ÂK8RÂMwÏÂN¬ÂMZÂKiyÂH‡+Á–dZÁxÕÁÊÁÁe‰7Á?‘hÁA‰À¬9X¿zŸ¾@ˆí‘A'7LAŒZAËÔþB¸B+ DBKÏßBfn˜BvF¨Bw>wBg\BE¼jBVA¯ó¶@˜å`ÁMº^Áã‹D°!Â3m‘Â9VÂ89XÂ8²Â<èsÂD8RÂL”{ÂTLÍÂZZÂ^MÓÂ`¬Â_øÕÂ^/Â[{ÂVúáÁ¢®Áš(öÁŽ“uÁ~r°ÁV‹DÁ#…ÀÆn˜¿š¬@™šAE;dA¨ÙAú=qB*ɺB[¡ËB…ûdBšÒòB¨TþBªÁ‰B @ƒB‰NVBO Aò¸@¢MÓÁ±KÇÂ7¿}ÂJJÁÂ(m‘Â\àBÂ`1'ÂSÚÂQ‘hÂWð¤ÂavÉÂjt¼Âq#×ÂtöÉÂvÂt®ÂqožÂlÁ‰Âg\Á±jÁ©ÄœÁžÐåÁ¸RÁvÔþÁAOßÀ÷× À ¼j@™‘hAX5?AÁ“uB;dBP™šBŠ[¦B®>wBÏgmBævÉBëÆ%BÜožB»‡+BŒÙšB"h@b=qÂPåÁÎ =CúCúCúÀÞVÂlµ?Âh²-ÂnƒÂzƒ‚ĆxRˆ$݈‰Â†jƒÀ€V‡ÂxçmÁÂ× Á¼§ðÁ³1Á¤÷ÏÁ‘1'ÁlE¢Á#¾wÀˆ“@aÊÁAXr°AѾwB(e`Bv‹DBª‡Bß_¾C æ%C ŠÁC%¿¾CÎVBÿ?}BÁØ“B[}ô?ÛçmÂPOßCúCúCúCúCúAãTÂ~—„›#Âß“÷L—ݲ˜àB—ŽÙ”‹DÂbÑ‹‡®Â†MPÁ×$ÝÁÓ¸ÁË®Á¿§ðÁ­‘hÁ“‹DÁ^bNÀõûç?+…A¢ÐåA‡E¢BW BŒSuBß«C6PåCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂ\¸ÂÆMPÂãàÅÂòãTÂöI7Âñ“øÂçë…ÂÛ±'Â΃ÂÁ_¾Â´Õ©(öÂÑì¿}Â¥ãÂÏßÂA‰Â£×Â5?Áél‹Á¬xÕÁ#²-@¾ñªAà²-BcâNB¾r°C%8CúCúCúCúCúCúCúCúCúCúCúCúCúCúÂ`²-ÃtþÃWÔ{ÃëÇÃÃTÃêÂûT{ÂçPÂÕEÂ͍Â"†%Â)s¶Â/êÂ56FÂ8H´Â7Ÿ¾Â16FÂ"~úÂXÁ½¾wÁ{A; Br°B¹ŒÍC«òCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ+/Ãa„œÃV4{ÃD›¦Ã1üjà ÙÃÉ7Ã}²ÂêJ=ÂÕ#ÂÂñ'Â3¦Â=bÂHXÂRÑìÂ[äZÂaÏßÂb PÂYQìÂC¶FÂÄœÁÀñªÀfVB'uCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁ¥®ÃZ Ãz“øÃZÄÃ<_}Ã#¶‡ÃÖÂÿuÃÂå5ÂÏUÂDšÂRŠ=Âb`BÂs(öÂî‰;dÂÒoÂMP„¸RÂa‡+»dAÚA‰CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCAŸ¾Ã„ˆÃ[Å`Ã849ÃÍPà ¨sÂóÆ%ÂÚ€ƒÂTÜ)Âg”{Â} JŠ›¦Â—­‘¤¶F¯–‡Â´ÄœÂ¯¡H›(öÂE¿}CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÖ  ÃzÄZÃJã×Ã)ܬÃûdÂÿã×Âã°¤Âd”{Â{”{‹u?›”{®*ÂÂ|îÂÖ8RÂä€ƒÂæjÂÕ+…Âxn˜CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃŽÞÙÈúáÃX¾Ã2"Nð!Ã(sÂê4¼ÂrY†œ)—«uÂÃgmÂàÂÿhà SøÃ0¤Ã DB›øRCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃBÌËۅÃ\Ã4ÿ¾Ã–þÂí–‡Â}=q‰ºÂ å·F%ÂÔdÝÂøjÃOžÃ&cTÃ0/\²iüCÔöCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúñ‰Ã„ôÃUdÝÃ2°ÃÌ‹ÃÁ‰Âí¸Õ‚SuÂ’o¥ ¾¤ZÂÞH1ÃáØ“ÂPäZÂ| ÅÂmÊÁCúCúCúCúAÝ\)CúCúCúÂŒÂ̓–ÂæåãÂñ¯Âñ‡®ÂîÍPÂê JÂã;çÂÚ¼îÂÑ/ÂÆå㼆¨Â²QhÂZ?}ÂgiyÂu JÂ[¦Â‡ß;š‘øR”[¦Â”8Õ‘E¢Â‹œ)ƒÑìÂuí‘Âdð¤ÂWàBÂQî˜ÂVn˜Âil‹Â‡¹Û¡l‹@}²-CúCúBó½q³™šÂO‹DÁî=q‡ð!¶Á‰ÂË`BÂÖ{dÂÛ„ÂÜÆ¨ÂÛÂØ ºÂÒ¬ÂËÏßÂÃéü»e㲞¸Â©ÙšÂQDœÂ\n˜Âg¿}ÂrÖÂ}+ƒ®Â†_¾Âˆ:áˆNV†}ô‚ð¤Â|DœÂq»dÂh`BÂb“uÂb±'Âjß;Â} ÂIºÂ¡É7µ޸¤‘hÂò°ÂÀò³E¢ºá£ÿ}°©y¼¶ÉÂÅLÍÂÊ;ÂËâÑÂË7ÏÂȉ7ÂÄ1'¾ŽV·ýqÂ°ÓøÂ©Z¡Ê=ÂHÖÂRaHÂ[çmÂe‡ÂmŠ=ÂtÇ®ÂzMÓÂ}«Â~’oÂ|þúÂyJÁÂtBÂo²ÂkiyÂjÔþÂnë…ÂxǮ„yÛ˜Â1ªá˵NÙ¸t9´+«Ìͤçm¢´9Â¥Óu¬Oß³^¸Â¹ =¼\½èö½Rò»øÂ·t9²¼j­5ç!H ¸Õš,ÂAÂIF¨ÂQl‹ÂY8RÂ`^5ÂfŽVÂkuÃÂnÓøÂp‹DÂp±'ÂoŸ¾ÂmüîÂl³3Âlß;Âo²ÂuÑìÂéy†߾ÂC–˜W  Ñh§–©å¨åÂ¥«£øÂ¢p¤Â¤:á§À«Á‰Â¯'m±Oß²±MP¯JÁ¬,‹Â¨'ð£qªÂž;瘴9“ Â9ÔþÂAhÂH)üÂNð¤ÂU0!ÂZ³3Â_G®ÂbÍÓÂe?}Âf¿}ÂgŸ¾Âh_;Âi­ÂlG®Âpß;Âwå`€µÃ††¨ÂŒþw“‚ ™KÇ“øÂŸÝ²Â QhŸ°¤ÂŸŸ Â D¢?}¤{d¦_;§}ô§¢N¦¾w¤޸¢¾Âž¤Zš“u–ò‘EÂŒJ=Â3=qÂ9«Â?ô¼ÂEúáÂK–‡ÂP§ðÂUbÂXÄœÂ[ËÇÂ^IºÂ`‚ ÂbÖÂe¿}Âi¹XÂo&éÂv;dÂ~Û#„NÙ‰n˜ÂŽaHÂ’´9––˜¾Â™)y™‚ ™¬‹ÂšþšèsœßÂF¨Âž9Xž¤Ýž_¾ÂX“›‘왦– ÍÂ’ÂŽ“øÂŠ`ņƒÂ-2-Â2ùÛÂ8£×Â>‡ÂC;dÂGûçÂLIºÂP"ÑÂS”{ÂV½qÂYÔþÂ] ÅÂ`ñªÂe“uÂkw”Þ5•ŽV–.–ŽÙ–‰7•ÿ}”âÑ“2°Â÷ÏÂŽA‰Â‹"N‡¯ƒýq€ BÂ'¢ÑÂ,å`Â2\Â7bÂ;ØÂ@\)ÂD“uÂH‚ ÂL49ÂOÇ®ÂSaHÂW49Â[s¶Â`LÍÂeØÂloÂr× ÂyàB€iüƒ©ü†…ˆÞ5Š©y‹öÉÂŒáHÂPÂŽÂŽ—ÂÂJ=ÂTþ ÁÂŽYÂ4¼Â‹œ)‰“øÂ‡&f„aËÂTþÂ| ÅÂuE¢Â"Â'TþÂ,‡Â0»dÂ58RÂ9ˆ1Â=¥ãÂA˜“ÂEk…ÂI49ÂM\ÂQ²ÂU~úÂZKÇÂ_\Âe>wÂk8RÂqIºÂw2-Â|³3€Ê=‚ؓ„|î… †µ?‡j‡ó3ˆYˆšˆ®˜Âˆ‡®Âˆ‡Qì†0!„¯žÂ‚Ô{€¥ãÂ|[#Âví‘Âq²Âk Áeß;ÁWÊÁÁG;dÁ4 JÁ¬ÁhsÀÔÀ˜A‰À1%¿1&é?³33@[C–@©¸@Û\)A¬A ÒòA o@ùOß@È1'@|î?‹ À¬ÀÁ?}Án˜Á[`BÁŠ‘hÁ¥“Á¼ó¶ÁÒ/Áå Áõ©üÂ-–‡Â¨öÂSøÂšÂÂ!ˆ%ÂC–ÁmSøÁ]ó¶ÁK²Á6 JÁ%Á^5ÀÀ(öÀq7L¿«…?ž5?@xÔþ@ЃA× A2^5ALýôA\ÌÍA_&éAR-A5%A9X@›\)? xÕÀ…G®Á{Á[‡Á-Á¯ÁÉÙÁá¬Áõ`B˜“ r°ÂOßÂ-Â%Â ÓøÂ#›¦Â%gmÂ&G®Â&VÂ%¬ÁvéyÁfbNÁRQìÁ:VÁ1Àú5?À®°!À3o>“u@U‘h@Ö¬A!…AV(öA‚ÌÍA•éyA¢KÇA¥÷ÏAŸn˜AùÛAc¶FA¸R@}ó¶ÀVÁjÁb¬Áš× Á¾bNÁÛå`ÁôÂƨ 7ÂIºÂ“uÂ#ÓøÂ(ò°Â,áHÂ/œ¬Â12-Â1º^Â1SøÂ0!ËÁ‰7Áq•Á[÷ÏÁA¥ãÁ"1Àù&éÀ¡©ü¿ô9X?ÒMÓ@²=qAÄœAc33A”™šAµ/AБhAã²AëE¢Aå$ÝAÐ A¬ ÅAvƒA ==‹C–Á“ÁwPÁ®¡ËÁÖýôÁõçmÂ\Â>wÂk…Â"èsÂ*Ÿ¾Â1NÙÂ6½qÂ:Å¢Â=cTÂ>¤ÝÂ>°!Â=«Â;ÄœÁ‰$ÝÁ€‡ÁiKÇÁLÝ/Á* JÀÿ÷ÏÀ›¶F¿˜1'@Ct¼@ûl‹AR“uA–°!AÅ7LAò =B ¦éB'ðB"!ËB¢ÑB¬AöÊÁA¶1AN£×@Á Û#Á”“uÁÓ¾wÂ1'ž¸Âm‘ ²-Â(ýôÂ1Â9·LÂ@øÕÂFɺÂJèsÂMKÇÂN\ÂMffÂKŠ=ÂHº^Á’ƒÁ‰dZÁ{¸Á]%Á7SøÁÐåÀ bN¿D“@ˆA! A…^5A¿—AýIºB‚ B9¸RBO¾wB[¨öBZ7LBIÙB+ Aÿ A”G®@k"ÑÁ7çmÁÉdZ úáÂ%®Â.× Â17LÂ4%Â9ïžÂB>wÂK6FÂSRòÂY¦éÂ]ÐåÂ_ÍÓÂ_ÑìÂ^(öÂ[+ÂW&éÁéyÁ• =Á‰(öÁs?}ÁKSøÁáHÀ´1¿L‹D@¡hsA@A¡ Aë B-BH›¦BqE¢B‰^¸B“+B“;BˆòBeð¤B+/AÅj@ïžÁƨšÂ+þúÂñªÂRG®ÂU8RÂLzáÂMLÍÂUTþÂ_³3Âi(öÂp+Ât@ƒÂu‡+ÂtcTÂqPåÂlÇ®Âg2-Á«“uÁ£`BÁ—éyÁˆ`BÁg¡ËÁ29XÀÛß;¿¿ @¦AUƨA¹PB B@oBzBšLJB³ÒòBÑìBÃÍÓB³BB–üîBazáAúp¤@l‹Áï?}ÁÁ\)CúCúCúÂ1ÊÁÂfÂÂb—Âk.ÂxKÇÂëÂ…ËLJž¸Â‡Ÿ¾Â†)üƒ/€MPÂxýôÁ»¶FÁ´´9Áª?}Á›dZÁ†ó¶ÁWVÁÔþÀE?}@ŒbA\$ÝAËbB(öBaœ¬B—œ)BÁgðBè}ôCÿ;C²òBõPC=„ÝCIB’ŠÁ@$jÂ/“C¹(RCúCúCúCúÂ<€ÂwuÂ’ò‹­‘Â’Òo–æf˜–÷Ï”"ÑÂ$Z‹l‹Â†NÙÁÎzáÁÉG®ÁÀ‘hÁ³;dÁŸãTÁ„ÌÍÁ?¾wÀº5?@XAK¥ãAÐ^5B+VB}²-B°Æ¨Bêu?Cú C18C6‚C¸ëdCúCúCúB¸ ÍBÜ/CúCúCúCúCúA^ ÅÂ…}q“ڠ É7©&鬹X¬n©Z¤n˜Âžhs—Ñì‘ =ÁãñªÁáG®ÁÛ/ÁÐhsÁ¿VÁ¥ó¶Áº^Á¸¿ºŸ¾AÐåAÃ× B-A‰B†WBÂ1CïC@‰CØšCúCúCúCúCúCúCúCúCúCúCúCúÀ ‹D–a˯Ro¿/ÂÇž5ÂÈøÕÂŦf¿W ·Rò®‰Â¥{眡ËÁü{ÁüÀƒÁúC–Áó?}ÁåáHÁÏÔþÁ®"ÑÁzMÓÀáÛ#@”bNA¡"ÑB ¼jBƒ#×B²°C ­PCjbNCúCúCúCúCúCúCúCúCúCúCúCúCú¾È´9ÂÁhÂߥãÂî)yÂñ©yÂí”{ÂäÅÂÙdZÂÌò°ÂÀe`´KǨïžÂ Y ɺÂæf ô¼Â ïžÂ€Áå× Á¸(öÁiƨÀ3× AP{B•Bf!ËB¬TþBïÄœC2QìCúCúCúCúCúCúCúCúCúCúCúCúCúCô9íÓÃçÃևÈsÃ5?ÃH1Â÷®˜Âå-‘ÂÓÓøÂÃøÕµ¯Â¶F³3Â"ÖÂ%#×Â$³3ÂãT£×ÂbNÁÀ9XÁC%@xƒA¼ÄœB3/B…Þ¸B»»dBê;çCµ"òCúCúCúCúCúCúCúCúCúCúCúCúCúBê›#ÃVïÃKÀÅÃ;· Ã+q'Ãqà ëÇÂÿt¼Âè=qÂÔÂÂwÏÂ(ÔþÂ0ËÇÂ8iyÂ>ì‹ÂC ÂC¸ÂwÂX÷ÏÂZ¢ÑÂ[ffÂ[™šÂ[ÌÍÂ\ƨÂ_k…Âd‘hÂl´9ÂwĜ‚߉äZ‘w¡éü ¼îžÀƒÂœ ºÂ˜¶F”äÝ´¼ÂŒC‡©yÂ)ÖÂ/(öÂ4iyÂ9n˜Â>"ÑÂBqªÂFPåÂIÀƒÂLÑìÂO¬ÂR‹DÂUÀƒÂY©üÂ^ ÅÂdß;Âln˜ÂuhÂ~TþƒÓuˆ6ÉÂŒbÂ1'‘†%“)ü”På•<î–#T—šÂ˜o˜çm™iy™o˜ܬ—§m•Ñì“iy€Â,‹Â‰…¢Â…¢Ñ—Â$­Â) ÅÂ.xÕÂ3%ãÂ7™šÂ;È´Â?¯ÂCRòÂFƨÂJ'ðÂM¦éÂQ{çÂUáHÂ[ DÂa{Âgô¼ÂovÉÂwE¢Â~ú჆G®Âˆñ'‹ ÁÂŒ¦éÂß;Žؓ­‘Âl‘ P‘}ô‘¢Ñ‘cT­‘ÂyXÂÆ¨Â‹²Â‰ D†;‚êÂ~ýôÂwÚÂò°Â$ˆ1Â) =Â-n˜Â1«Â5¼jÂ9Ÿ¾Â=_;ÂA1ÂD´9ÂH†%ÂL ÅÂQ+ÂV?}Â[èsÂbÂh¢ÑÂoKÇÂuËÇÂ{Ý/€£×‚ô9„ٚ†]²Â‡ŽÙˆ€ƒÂ‰A‰Â‰ÙŠDŠxRŠffЉ9Ûˆ Ó†{焉7‚?}ÂRòÂy¨öÂs›¦ÂmE¢Ác¡ËÁUÎÙÁE²Á2õÃÁ¾wÁïžÀ×\)ÀžvÉÀDIº¿ ?U@-Oß@%@ºE¢@ÚŸ¾@ên˜@柾@Í/@`B@0bN;£× ÀM?}ÀÖ§ðÁ%®Á_‰7Á‹ffÁ¥Á¼MÓÁÑ;dÁãïžÁô—¬¾ ©üÂIºÂþúÂÏßÂÄœÂì‹ÂY¾ÁjzáÁ[XÁIhsÁ4ffÁ-Á—ÀÃdZÀ~È´¿Øb?9X@K÷Ï@³\)@ûC–A‹DA3ÎÙA@ÙAAdZA3Û#A¥ã@ÚŸ¾@Z~ú¿Û#ÀŸ Á¥ãÁ^“Áí‘Á­Ÿ¾ÁÇãTÁÞ÷ÏÁóMÓ§ð ²Â•‹DÂwÏ YÂ#0!Â% =Â%ùÛÂ&Â%vÉÁsKÇÁbùÛÁOKÇÁ7çmÁ~úÀù™šÀ±p¤ÀAG®¾|í‘@.vÉ@ºffAõÃA>n˜AhƒA„ÐåA%A‘9XAŠ+Ar¸RA>A‰@ò—@+ÀC Á KÇÁaûçÁ˜MÓÁº~úÁ×—ÁðffÂøÕ ‚ ÂÂÂ"êÂ()üÂ,33Â/%Â0±'Â1MÓÂ0øÕÂ/× Á~záÁm"ÑÁWÛ#Á> ÅÁxÕÀöÐåÀ£C–Àb?š=q@›;dA ¾wAK•A… JA¡Ÿ¾A¹ =AÈ—A;wAƲA²\)A‘^5AJ“u@ÃC–¿‚ÐåÁß;Áp ÅÁ§OßÁÎ7LÁí\)Â^5Â@ƒÂ\Â! 7Â) Â0 DÂ5¨öÂ9ØÂ<•Â=õÃÂ> Â=/Â;`BÁ†;dÁzbNÁcÂÁGß;Á&ÀúñªÀ›C–¿° Å@%ãT@àõÃA=Û#A‡´9A°ÄœA×~úAøvÉBÛ#B ¨öB +AùvÉAÏXA–KÇA#ß;?o²Á?}Áˆ¡ËÁ¸Áí\ÂE¢ÂÚÂÔþÂ%qªÂ.ÚÂ7¢ÑÂ?C–ÂEVÂI¦éÂL6FÂM!ËÂL²ÂJå`ÂH49ÁŽÙÁ…¥ãÁs¶FÁV1Á1;dÁMÓÀœj¿`Äœ@s33AbNAqûçA¬¼jAâjB `BB"ƒB3¤ÝB;®B85?B(PåB ÍÓAÏoAkKÇ@Ý/ÁÊÁÁªÄœÁó1Â/ÂÜ)Â%\Â+ýôÂ4¨öÂ>•ÂHp¤ÂQ\ÂW¸RÂ\#×Â^ZÂ^“uÂ]¸ÂZOßÂVvÉÁ™OßÁ9XÁ„?}Ái•ÁB^5Ál‹Àªn˜¿DZ@•p¤A0—A’§ðAÓ£×B ž¸B/ƨBP‡Bi\Bu‡+Bq@ƒB[oB5ƨBõÃA•´9@+SøÁ_&éÁëVÂ!@ƒÂ5Ç®Â@ožÂ>¸RÂ>°!ÂEl‹ÂP`BÂ\oÂf0!Âm˜“ÂqþúÂs’oÂr¹XÂoí‘Âk¦éÂfLÍÁ¥ÔþÁ9XÁ‘t¼ÁÈ´ÁZÄœÁ&‹DÀɡ˿šÀƒ@ “AGG®A©¸RAúoB)‚ BX-B‚r-B”hsBt9B™–‡B‹œB\BXPAà9X?¯ Á®¬ÂäZAÛbNCÌÍÁÖMÓÂV1ÂQÇ®ÂVèsÂd›¦Âs˜“Âæf„V††KÇÂ… D‚±ªÂ¸ÂwÓøÁ´•Á¬çmÁ¡× Á’…Á{ÊÁÁEÀþÀƒÀG®@‘ÒòAQ‰7A»“BuBE’oBVBŸ]/B¸¬BÅ ºB¿[#CíPCúCúCúBó¦Áú¸ÁôƨCúCúC¿<ÍÂ+Â[ ÂgÏßÂ|´9ˆ˜“Â!Ë”z^•ô¼Â•"ÑÂ’/ÂŽéüŠs¶Â…ŽÙÁÅ´9Á¿záÁµ¼jÁ§vÉÁ“dZÁp JÁ'7LÀƒ@DÝ/AIÎÙAÂõÃB=qB\úáB”+…B»}ôBÝ©üBíáHBòÑhCúCúCúCúCúALå`C¡‰CúCúCúB½5ÂF‚ Âyt¼ÂŽŽVœ‰7Â¥E©5?©^5¦ȴ¢YœÖ–PÂþÁÙ;dÁÕoÁÍbNÁÀýôÁ®l‹Á“å`Á^záÀ÷÷Ï>§l‹A*ùÛA½t¼BvÉBj¤ÝB¡4¼BÐ0!Bú^5C C“øCúCúCúCúCúCúCúCúCúCúCúÁÉQìÂŒˆ1¨)y¹#TÂÁ/ÂÃ¥ãÂÁ&é»°¤Â´t¼Â¬O\£և›k…Áï¬Áí²-ÁèáHÁßZÁÏhsÁ¶ïžÁ“`BÁC…ÀvE¢@ã|îA¨ Br°BiÚB£s¶BÔ–‡BÿAC ž5C ;CúCúCúCúCúCúCúCúCúCúCú¿9™šÂ³ñ'ÂÓâÑÂã#×ÂçÌJÂå;dÂÞ 7ÂÔ(öÂÈÿ}½zá².§l‹Â•š Â{ÂIºÁöƒÁáÁÀ|îÁãTÁº^?òñªAƒ~úBNÙBYOßB˜u?BÃ;Bàr-BßêCNµCúCúCúCúCúCúCúCúCúCúCúCkþÂëØ“Ã ˜Õð!à þÂÑÃ0¤Âð-ÂßÅÂÏÿ}ÂÁKD³Ô{„ ÅÂuÃÂ:^ÂÖ ÔþÁö¸RÁÈl‹Á„oÀ–ffA(bNAä(öB>YB‚í‘BŸO\B¨¾úB£aHCúCúCúCúCúCúCúCúCúCúCúCúCúC°x1Ã>øÕÃ8OßÃ,ß;à !ÃèsÔþÂø*ÂãNÙÂд¼ÂÀAÂ{Â#Ÿ¾Â(E¢Â+6FÂ+9XÂ&”{©üÁÆéyÁFŸ¾@‚^5Aº°!B'ƒB\MÓBy¹XBš…CpåCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ-ƨÃh …ÃRI7Ã<óøÃ)eãÃàÅÆfÂö„œÂß¼jÂÌ.˜Â+ãTÂ4!ËÂ<ÂB·LÂFë…ÂFž¸Â?Â,iy ž¸Á«VÀ0ÔþA§ûçBO?}B“*Bå±'CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ…_¾Ãy2°ÃZkDÃ?öÃ'Ç+ÃXÕÃ33Â턜Â׉Â9qªÂD‰7ÂOí‘ÂZÞ5ÂcþúÂi{Âf¿}ÂXjÂ8›¦Â¯Á8ÐåAÕ™šCR¹Cð+çCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ.VÃŒïžÃtÃ×ÃR-ÓÃ5¤Ãoà ÀƒÂùÂàþÂF%ãÂTVÂcÂrbN€t¼Â†²ÂˆD„5ÃÂmwÏÂ9ožÁˬA´9Cä/\CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÁÔXÃÒo× jÃF%Ã_}²Ã?AÃ%šáÃ2òÃÊÁÂæÖÂQ_;ÂaÎÙÂt%ƒÌͶɖ™šÂœr°ÂœMÓÂ’¼jÂyØÂ3bNÁpBÎ"ÑCU`CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂê´Ãœ¶é×éXÃ…ˆ“Ãd¶ÃCAÃ(ûdôÃ-PÂêß;ÂZyÛÂläZ€×ÂŒOߘgð¤Ù­F¨Â±V«øÕ›yX”{Â92-Á^ffCjÁCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCæŠÁÑv‡Ã=²Ã€Þ5Ã_nÃACTÃ(_¾Ã ƒÃœjÂì ÇÂaoÂt·LÂ…‰7Â’Ÿn˜Â¬ËD¸8Õ¾ڠ½gm±;™Þ5Âv•Â!ËByC[ˆ1CúCúCúCúCúCúCúCúCúCúB4¡ËCúCúCúCúCúCúÃo͑Ão¾Ão¹ÃT#TÃ:|¬Ã$Z ÃÁËÃ<¬Âê‚ÂdàBÂxÞ5‡ÌÍ”zᢲ¯Ç+»´9ÂÃF%ÂÃu?¹\¬Â£Û¦ÂƒµÃÂ7SøÁ¥éyCjÚáCúCúCúCúCúCúCúCúCúAѾwCúCúCúCúCúCúCúÁÜÂÃlÜjÃ[Ò-ÃEïßÃ0àBÃò-à záÂþ¸ÕÂæ²ÂeèsÂyiy‡¯žÂ“ËÇ £×­L͸%`¾Óu¾©üµ)y ܬÂñªÂ8ì‹ÁÒÛ#C“E`CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúšùXÃXbÃHø“Ã7=/Ã&¤Ã+ÇÃêÂö»dÂàÖ‡ÂdqªÂvƨ…Š=ƒ–›ܬ¦°¤Â¯…¢Â´T{²ۦ© Å–¬Âul‹Â6ÙÁý"ÑC—Ç®CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCÔÝÃ>LÍÃEtþÃ7^5Ã)Ëâà ÈöÚáÂí>úÂÙ®Â`ïžÂq¤ÝÂáH‹k…”öF¬¤F%§²Â¤nšÂ‰‹DÂc½qÂ/‡+Â\Cß}CúCúCúCúCúCúCúCúCúCúCúCúCúCúC¿;ÂÄð¤Ã%× Ã;ѪÃ2`ƒÃ'ÕÃ=ôÃEãÂõæfÂâàÅÂÑš Â[êÂjɺÂz‰7Â…PåÂo“ËD˜p!™¹X–ZÂO\Â|–‡ÂT]/Â'ÂúáÁ‹XCù¾wCúCúCúCúCúCúCúCúCúCúCúCúCë³uÃ&µ?Ã5G+Ã/EÃ(ƒà ‘ìÃbþÃú ÂùÜ)ÂèvFÂØ/ÂÈýôÂUèsÂbïžÂpe`Â}¾wÂ…åŠ&éÂOßš ÂŠ‚ ÂjÓøÂI¦Â" ÅÁ÷%Á¶ ÁB ÅB33C”…`Cš«…CúCúCúCúCúCúCúCúCú ¸ÃÕ?ÃëDü¬Ãò-ÃÐbà ¡Hô¼ÂøÀƒÂéàÅÂÛH1ÂÍMÓÂÀ%ãÂOaHÂZ²-Âf¬Âq¾ÂzþúÂ]/ƒŠ=ƒYšÂ€'mÂr÷ÏÂ^`BÂCÂ"ÓøÂ·LÁ¬ÁŒ× Á#+>Ù™šÀqxÕCúCúCúCúCúC›xÕCúCúCúÂÇ;çÃQ'ÃyXè´ÃPbÃ'®ÂýffÂò¼jÂçœÂÚÔ{ÂΞ5´¼Â·OßÂH°!ÂR~úÂ\0!ÂeTþÂmOßÂs]/Âv—Âv JÂpãTÂf‰7ÂVÙÂBIºÂ*0!Â&éÁöó¶ÁÜ÷ÏÁÝl‹Â¦Â2ɺÁ†t¼CúCúCúB8ÄœÂO›¦ÂvÉÀ‰™šÂ•ØÂÏÙÂãµÃÂîåÂó)ÂòËDÂîçmÂèqªÂà4¼ÂÖÕÂÌ× Â Å¸~ú®¦éÂB‡ÂJž¸ÂRì‹ÂZ ÅÂaC–ÂfA‰ÂhùÛÂhÍÓÂe9XÂ]ô¼ÂShÂE&éÂ5—Â&êÂ\ÂŒJÂ(\)ÂA¶FÂkA‰Â‘O\ üîžÄ°SuÂÃyXºå±•¯„·ǮÂĉºÂÐ}ôÂØèsÂÝÂ݈1ÂÚûdÂÖ,ÂÏ»dÂÈ/žÂ¿öÉ·hö®ɺ¦J=Â;¾wÂC;dÂJp¤ÂQ{ÂVËÇÂ[-Â]ÍÓÂ^KÇÂ\dZÂX1ÂQyÛÂIr°ÂASøÂ;[#Â:†%ÂAž¸ÂQ‰7Âiuƒ“u•Y§-´,‹Â¹,·\)²±ªÂ¯.¯hs´¨Â»`BÂÂÙšÂȀˆ%ÂËêÂÊÂÆH´ÂÁ%ã»´2-­ƒÂ¥¦fžNÙÂ5¾wÂwÂJ©üÂJ˜“ÂNùÛÂY)üÂhùÛÂ|¾w‰Tþ”ž¸ÂŸ‰Â¦¾úª¹Û«yÛª­‘ª7Ï«k…®Ÿ¾Â³)·¤Ý»%㽜½»}q¸r°Â´?}¯-©{ç£ffÂ#–ÀƒÂ0²Â6Â;ÍÓÂA¬ÂEÒòÂIÂÂLÅ¢ÂNÂÂO¾wÂOäZÂO–‡ÂOzáÂP‚ ÂSÓøÂZ†%Âe ÅÂs!Ë“øÂ‰Ù‘˜°!Âüj¡NÙ¢õ㳶¤r°Â¥Ü)¨;ªès­Ÿ¾Â¯¬°§m°ff®ë…¬V¨Ñh¤ßŸÁ‰Âš’o•(s£×Â*Þ5Â0KÇÂ5…Â:jÂ>Ý/ÂBÂÂFÂHž¸ÂJ¢ÑÂLA‰ÂMÑìÂOØÂRúáÂWò°Â_LÍÂi+ÂuV€þw‡qªÂoÂ’š Â–°!™–‡Â›€ƒÂœÐbÂú^ŸT{ øR¢¾ú¤\)Â¥yÛÂ¥ÙÂ¥V‡Â£ì¡§ðž¥`›¢Â–ë…Â’wÏÂɺˆú^Â%øÕÂ*öÉÂ/ËÇÂ4bNÂ8¥ãÂ<ˆ1Â?þúÂCbÂEÒòÂHr°ÂK7LÂN~úÂR¹XÂXPåÂ_‡+ÂhSøÂrSøÂ|Ü)ƒšˆ_;ÂŒƒ–ÂäÝÂ’{ç”k…•æf—)y˜`Å™›#šŢ›·ÏœA‰Âœ;盎ٚ1ªÂ˜,•PÂ’l‹ÂŽâÑ‹´Â†õÂÀÂ!e`Â&1Â*‹DÂ.ãTÂ3Â6ß;Â:záÂ=Ý/ÂA¬ÂD^5ÂG× ÂKɺÂPzáÂV%ãÂ\äZÂd¡ËÂmÂuÊÁÂ~G®Âƒb†„‰j‹ÀšÂ{ÂNÙ‘aHÂ’SøÂ“/“§m“ד”þÂ’Ïß‘‚ ®˜Â`BŠ¥`‡å„5?€¤ZÂyàB Â!ožÂ%°!Â)ÑìÂ-ÎÙÂ1¢ÑÂ5PåÂ8âN­B)aHB Ÿ¾AIJAT“u?¥?}Á-&éÁ°záÁø´9ÂzáÂe`Â&ð¤Â05?Â<Š=ÂJ@ƒÂW5?Âaì‹Âiµ?ÂnožÂpZÂoÛ#ÂmjÂiyÛÂdr°Á dZÁ—\Á‹¶FÁxn˜ÁP°!Á§ðÀÁ`B¿©xÕ@Šn˜A/`BA”“uAØ`BBgmB4¼jBUBmPåBu†%Bhß;B`Û#B°ÓøB› JAñ¸R?¿²Áw®ÁåZÂiyÂ)€Â1¬Â3ÓøÂ; ÅÂJ× Â\ËÇÂmXÂzIºÂwLƒ¶F„)üƒ,ÂøÂ|`BÂu†%Á­¾wÁ¥—Áš/ÁŠÂÁlÔþÁ8MÓÀët¼À •@„¬A;©üA¤å`AõÙB'E¢BUBXB#×B“:áBöÉCúCúCúCúCï^wÁƒV‚  ë… àBÂ#H´Â1„Â@©üÂXñªÂs P„„ÂŒT{ÂîÂ’¹ÛÂ’G®Â&éÂŒÔ{ˆ¸R„!ËÁ½1'Á¶(öÁ«´9ÁœçmÁˆ°!Á[•Á©üÀrŸ¾@I‰7A:1A­õÃB÷ÏB:‰7BqþúB“2-B¦,‹B©&fBÎÑìCúCúCúCúCúB¬cTÂ#º^ÀªÀƒB›B7Å¢ÁÏÙÂ:Ÿ¾ÂiÎÙˆ‹D–åãŸڠ¤.¤àB¢çðŸ‡Âšò”]²ÂŽRoÁÎÀƒÁÉXÁÀn˜Á²ïžÁŸ•Á„Û#ÁBbÀÉ%?•A&å`A­1'B ^5BG#×Bƒ€ƒB¡àÅB·øB¶¾úBòòCúCúCúCúCúC_iyAø$ÝC±ˆ“CúCúC¼Â+€Â„ߟ¦é°“u¹t¼Â¼I7ºËD¶`Ű B¨×¡™DÁâ\)Áß$ÝÁØl‹ÁÍÁ»`BÁ¡¼jÁ|Á× ¿óSøA ÅA¡bB ÌÍBJ£×B‡Ú B¨C–B¼ß;B¶wÏCˆuCúCúCúCúCúCúCúCúCúCúCúÂFk…§<îÂÅ&éÂÔò°ÂÚûçÂÚ9ÛÂÔñ'ÂÌܬÂÃC¹ 7®Ä¤ÐbÁ÷ÒòÁ÷`BÁó‘hÁëbÁÜ"ÑÁÄŸ¾Á¢1Ác7LÀ—@‹× A‰ó¶Bl‹BD¬B…LÍB¥oB¶àBB©9ÛC“'CúCúCúCúCúCúCúCúCúCúCQ ‘Âm =Âåk…Âÿm‘ÉÃÞ5ÂþxÕÂó`ÅÂæ3¶ÂØ>wÂÊ_¾Â½¦Â°¸RÂjÂÛ#ÂƨÂn˜ÂÔþÁíhsÁÍbÁ=qÁ533¾±&éAT‹DAè\B7ÌÍBz%B™öFB·¦C-Á‰CúCúCúCúCúCúCúCúCúCúCúCúCúÂÔOßÃ&t9Ã#Ì‹ÃÆéÃ=ôà ¹ÛÃÞ¸ÂîvFÂÜSøÂË®˜Â¼ BÂn˜ÂÎÙÂæfÂéy¹X ØÁþÒòÁЗÁŒ²-ÀÀ9XA ¶FAÊ©üB(¥ãBbº^BŠËÇC#±ªCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúžÃG33Ã9Ì‹Ã+åÃÀÅÃÃÃroÂî ÂÙàÅÂÈh¡ËÂ%#×Â)µ?Â,|îÂ,A‰Â'G®ÂPå®ÁǸÁK¸@IÛ#A« JB 7BK»dB•gmCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃW!ÃV€ÃA¥¢Ã.[¦Ã½/à ÁÂþ¨sÂæñªÂÒ‚ Â+–‡Â3VÂ:bÂ@m‘ÂCž¸ÂB2-Â9ˆ1Â&\)Â-Á¦$ÝÀyÊÁA€¬B éyB@ãTCON˜CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃY³3ÃmöÃUÃÃ=¦éÃ(ŽÃ&éÃgðÂòoÂÛaHÂ6ÏßÂ@ÖÂJ¬ÂS»dÂZ›¦Â]9XÂX¡ËÂI“Â*—Áó¶FÁYº^@Ô9XAÙ|îB$“uC©ÉCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃLjÃ|*ÁÃb€ƒÃH¬JÃ1;#Ãì‹Ã ¹XÂú†%Ââ/žÂ@ÊÁÂL»dÂYšÂe)üÂo¡ËÂv_;Âv@ƒÂkC–ÂQ%ãÂ$ÀƒÁÌŸ¾Àå/A"=qA§—CÉCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃl¯žÃ€p!ÃhXÃNXÃ5ØRà ÀƒÃâÑÂÿÄœÂæbÂIÂVŠ=ÂdâNÂsgm€ožÂ…™šÂ‡œ¬Â„m‘ÂsØÂM:^š Á§ñªÀ´ƒ@²§ðB‘‡+CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC½kdÃr,ÍÃ}Ý/ÃgR°ÃMçðÃ69ÛÃ!xRÃÂNÃÌÍÂè\)ÂO/Â]ÀƒÂmbNÂ}€Â†z^Œ޸Âc×ÂÙ†ÍÓÂlPåÂ:^5ÁúSøÁ€ ÅÀ‹l‹A²SøCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúAÛVÃiÑìÃacTÃI@BÃ2õ?Ã_¾Ã~¸ÃÉÂç§mÂS\Âb DÂr%ãÂiü‰}ôÂZ”P”;çÂt¼Â}{çÂO­ÂhsÁ²ÙÁ>ÐåBÈMÓCúCúCúCúCúCúCúCúCúCúCäçðCúCúCúCúCúCúCúÃ^wÃWNVÃAr°Ã,óøÃmà nÂûæfÂ䮘ÂT¥ãÂcožÂs:^¼j‰‹ÇÂ%ã”7L”ìÂöÉ€ˆ´ÂVéy æfÁÔí‘ÁãTC¤¹šCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃû¦ÃK§®Ã7[¦Ã%\Ã\Ãü¬ÂõRoÂßÏ\ÂT#×Âb9XÂqh€ ͇"NÂŒõ?ÂV‡ÂÒò‰êÂzõÃÂTœ¬Â$.ÁêÁ°C¢ßßCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúA§ðÃM&%Ã=æ%Ã+· ÃùšÃ%Ó¶Âí+ÂÙs3ÂQàBÂ^æfÂlbNÂy½q‚ûç‡ɺŠDœÂ‰5?ƒeãÂoÞ5ÂMcTÂ"6FÁï¬Á¼éyBÈ =CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ:~wÃ>¢Ã. JÃeãÃKDÃb Â÷¸Âã‘hÂÒÂNBÂZ 7ÂeúáÂqƒÂ{¶F¤ZƒDœÂÖÂxXÂcŠ=ÂDĜµ?Áçå`Á§‘hÁí‘C¦fÉCúCúCúCúCúCúCúCúCúCúCúCúCúÃ/¹ÛÃ2ò°Ã9™XÃ6ð!Ã*£×ÆéÃ.ÙÂÂý¨ÂêxÕÂÙiüÂÉÛ#ÂI·LÂT33Â^œ¬ÂhgmÂpÖÂv›¦Âx“uÂu&éÂjØÂXwÏÂ=qªÂ1'Áá× ÁŽ%Á¼jA£33CúCúCúCúCúCúCúCúCúCúCúCú¼ïÃ4c×Ã.ÇmÃ(5Ãà éºÃÉyÃ<)ÃŽÙÂýú^ÂíjÂݰ¤ÂÎõÃÂÁNVÂDœ¬ÂMß;ÂVãTÂ_+Âf1Âj–‡ÂkÊÁÂh|îÂ_ŽVÂP1Â9BÂùÛÁë`BÁ—5?Á¸R@‡\)BwÂøÓøÂð,‹Âæ#ÂÛDœÂÐ$ÝÂÅ{ºQh°Â9ß;ÂA ÂGô¼ÂN{ÂS1ÂVOßÂWXÂU‘hÂPyÛÂG²-Â;Â*ð¤Âl‹ÂÍÓÁùÔþ Â|îÂEW ÂvOß—„œÂŒSu•PbÂÇTþ Ö„Õ±[#ÂÅWÂÐiüÂÙ¾Âà÷LÂæq'ÂèiüÂæùÛÂâ½ôÂÜl‹ÂÔ­ÂÌ 7ÂÂï¹°!°‡®Â§ BÂ4œ¬Â;oÂA'ðÂF–‡ÂK DÂN'ðÂO‹DÂNÜ)ÂK× ÂFdZÂ>³3Â5r°Â,;dÂ&=qÂ(¤ÝÂ8¼jÂVÂw²-ÂŒYšÂ¸R®(s¹…¢Â¾Qh¾xÕ½4¼Â¼Ý²Â¾Z ÂÂG+ÂÈoÂÍëÂÒ;ÂÓܬÂÓhÂÐ\ÂËJ=ÂÅ8Õ¾F¨Â¶ÊÁ¯ J§A‰ÂŸ‘ìÂ/\Â5dZÂ:âNÂ?ÔþÂCýôÂG¸ÂHùÛÂIbNÂHA‰ÂE²-ÂB{Â>=qÂ;³3Â<æfÂDð¤ÂVÂn~ú„bÑÂNV› =¤e`«9Û®þú°…¢Â±¦Â±ð!³߾·)ü»H´Â¿7Ï®ÂÃ-„ÂÀ-‘¼m‘·’ò±éy«¶FÂ¥33žP—èöÂ*ÂÂ0Â5!ËÂ9»dÂ=»dÂ@÷ÏÂCOßÂD±'ÂE$ÝÂDÝ/ÂDIºÂD.ÂEº^ÂJƒÂT¦Âc$ÝÂv33Â… ÍÂŽ¸Â•ïžÂœiy¡LJ¤„¦xR§Ðb©7L« Å­ Å°gð²ë…´¤Ýµ8Õ´ƒ–²ŽV¯}q«ƒ¦Ô{¡¤Ýœ!H–ožÂ¯Â&9XÂ+%ãÂ/ØÂ433Â8¦Â;{çÂ>A‰Â@n˜ÂBšÂC{çÂDúáÂG1'ÂJð¤ÂQ#×ÂZ‚ ÂgÂuå`‚•‰®ÂØ”ò-˜î˜Â›ÙšÂõ?Ÿ›#¡(s¢ؓ¤´¼Â¦‘ì¨#T©)©B ¨xR¦¾w¤'m Òoœãט“ÍPÂŽæf‰æéÂ!ñªÂ&‰7Â*ô¼Â/¾Â2ûçÂ6yÛÂ9–‡Â<\)Â>å`ÂAgmÂD49ÂGº^ÂL~úÂSÂ[’oÂf JÂqÊÁÂ}ÎÙ„“u‰›¦ÂÝ/‘Pb” –5—Ö™[¦ÂšÑhœ9ÛÂ~wžu?žð!žÌJÂô9œcך%ã—MP“ô9Â5?ÂŒ)ü‡ë…ƒ\ÂäZÂ"6FÂ&gmÂ*l‹Â.;dÂ1ÎÙÂ5(öÂ8W Â;r°Â>§ðÂB33ÂF`BÂKÂQÖÂYzáÂbIºÂk× Âu‰7Â~ɺƒ”þ‡6FŠAÂŒºáÂŽÀÂk…‘ؓ“ Â”33••ªÂ•× Â•…”¦f“8R‘?}Žȴ‹å`ˆ©üÂ…(öÂvÉÂ{H´Â PÂ"ÑÂ"!ËÂ&Â)ÄœÂ-aHÂ0ß;Â4KÇÂ7¾wÂ;W Â?A‰ÂC¯ÂHÎÙÂNÀƒÂU‹DÂ]VÂdþúÂmÂt°!Â{Á‰Â‰Âƒ²-Â…ò°Â‡Ô{‰dÝŠ³3‹ɺŒ©üÂKÇ£T BÂ49ÂŒW‹¨Â‰F%‡²Â„šÂÉ7Â}uÃÂvûçÂp@ƒÁ`ÙÁSïžÁE%Á3ûçÁ ÔþÁ ²ÀèýôÀ·•Àƒ÷ÏÀéy¿^ùÛ?$Ý/?ýp¤@C"Ñ@p“u@€å`@r=q@?\)?Ñ%¾„›¦À'¾wÀ«|îÁ…Á7¥ãÁj1ÁPÁ¤ÔþÁº…ÁÎxÕÁà¥ãÁñbÁÿ¼jÂRò âN‹DÂLÍÂ,Â33ÂožÂó¶ÂÑìÁf“uÁXn˜ÁG× Á4¬ÁÔþÁMÓÀÖn˜À›®À:Ðå¿h1'?p¤@B¬@˜ÌÍ@ÆáH@çdZ@ö—@ñp¤@Õó¶@£¥ã@7+<‹C–ÀRÐåÀܼjÁ*záÁfE¢ÁÐåÁª—ÁÃ&éÁÙt¼Á훦Áÿ¼jÂò°Â =¬Â#׸Â!hÂ# =Â$šÂ$W Â#Ü)Ám÷ÏÁ^›¦ÁL^5Á6ýôÁIºÁ-ÀÅOßÀïž¿Ôýô?Iûç@R^5@·KÇ@ÿ…A~úA57LAA\)A@¼jA1ïžA‡+@Ò\@Hb¿gïžÀ©&éÁVÁd-Á“™šÁ²A‰ÁÍÐåÁæ~úÁü§ðÂJÁÂ1'§ðÂ%“Â)MÓÂ,KÇÂ.$ÝÂ.ïžÂ.ÌÍÂ-Ü)ÁwKÇÁfáHÁSVÁ;t¼ÁÎÙÀÿ¶FÀ· ÀK…¾ÌIº@$¬@´õÃA ¥ãA: ÅAbÄœA AŠ ÅA‹1'Aƒ+Ac‘hA//@×Sø?å¡ËÀc"ÑÁvÉÁe33Á™¥ãÁ¼hsÁÚçmÁõÌÍÂó¶Âß;¶FÂ$cTÂ+½qÂ1¨öÂ6šÂ9‡Â:¸RÂ; ÅÂ:yÛÂ8ïžÁt¼Áq²Á\^5ÁB¬Á$bÁ$ÝÀ­?}ÀÒò?Q&é@ŒzáA£×A@“A{|îA˜bNA­‰7Aº¥ãA½vÉA´ƒAŸ~úA~´9A+ãT@–§ð¿æE¢Á§ðÁkSøÁ¢ÒòÁÉ¡ËÁê“uœ¬Â“u•Â'²Â1hsÂ9§ðÂ@&éÂDÓøÂG»dÂIÂHÞ5ÂG†%ÂE2-Áˆ“uÁC–ÁhÝ/ÁMKÇÁ+ß;Á÷ÏÀª$Ý¿÷+?ô“@ŇA+× Aw÷ÏA¡™šAÄ$ÝAàVAò~úA÷5?Aì7LAÑZA¨ÐåAkçm@îÙ¾¦éyÁ33ÁyC–Á°1ÁÚ1'ÁüdZ ô¼ÂÏßÂ(DœÂ5Â@^5ÂIÏßÂQÂUæfÂX–‡ÂYQìÂXcTÂV¦ÂRÄœÁ‘/Áˆ$ÝÁy¸Á\Á8{Á bNÀ°A‰¿Õ@0Ôþ@øzáAT ÅA˜©üAǾwAóûçB s¶BŠ=BBG®B DAÊÎÙAŒA‰AdZ=›¥ãÁ p¤Á‰7LÁÁPÁìñªÂÂ¥ãÂ$Á‰Â4˜“ÂD 7ÂQÀƒÂ\ÒòÂdÜ)ÂiÝ/Âl¦ÂkûçÂið¤ÂfffÂa¿}Á›jÁ’‰7Á†× Áo•ÁI™šÁ‡+ÀÂV¿ã÷Ï@PÄœAñªAxÌÍA´•Aî“uB#×B*ÍÓB:;dB<¢ÑB.`BB)uB—#BdNÙAvr°¿ Á4 JÁhsÁÕ+Áüƒ ^5ÂÎÙÂ,ÐåÂAA‰ÂU@ƒÂft¼Âs¨öÂ|ŽV€¶ÉÂhs€±'Â}Å¢Âx\Âr;dÁ§hsÁžýôÁ“ƒÁ„QìÁa\)Á/‘hÀã\)À£×@P´9Aß;A‹1'AÍ¥ãB ÐåB,šBI¤ÝB\p¤B\]/BU DCúCúCúCúB­VÁd¼jÁ»l‹ÁãÁúMÓ¡ËÂ’oÂ1YÂNÖÂj²Â€ì‡äZÂŒ£TÂŽ¹XÂŽ©yÂŒô¼ÂŠ߆Z‚ ÅÁµ9XÁ­¡ËÁ¢È´Á“ãTÁ€VÁL\Á %ÀeÒò@'PA ¬A”PAá\)BÓøBBÜ)Bf•B|qªBwúáB™MÓCúCúCúCúCúA7ûçÁãº^ÁÝ›¦ÁÁG®ÁÊÂì‹Â3¢ÑÂ`hsƒÂÌÍ™¤Ýž=qŸs3ž)šô9–’ò‘p!‹äÝÁÄÝ/Á¾…Á´Æ¨Á¦¶FÁ“A‰ÁrZÁ.ZÀ¯¾w?›dZA¸A–ÂAíKÇB%¥ãBU2-B~ùÛB‹¹XB†»çB½^¸CúCúCúCúCúCúÁöA‰Á¨"Ñ@×o@“®Áд9Â=ñªÂ~Ü)—‰ºÂ§ožÂ°_;³Þ5³X¯þwªÇ+¤nÂ}ô–WÁÖE¢ÁѲÁÉÁ¼Ý/Áªp¤ÁÀƒÁ\jÁ^5¿ƒSø@öÐåA¾wAïÙB, DBa€Bˆ¬‹B–œ)B‘-CàÅCúCúCúCúCúCúÀ™p¤À7LB>¶FB! 7ÁÌå`ÂhŒJœT{¶ÕÂÆOßÂÍSøÂÎ)yÂʯžÂÄaH¼aH³…ª`Å¡VÁéA‰ÁæÀƒÁàÒòÁÖC–ÁÅ—Á­{ÁŠÀƒÁ9KÇÀƒçm@¥‰7A‚záAè× B,¬Bg=qB9XB£bB®)yCúCúCúCúCúCúCúBÀ›¦B˜Ü¬CHsBˆ–Â&éy¤SøÂΨöÂå>úÂïl‹ÂñG+ÂíNVÂåcTÂÛ ÓÂÏ~úÂÃ’o·×¬£×Áý…ÁýŸ¾Áúp¤ÁòŸ¾Áä~úÁÍ÷ÏÁ¬°!Á|n˜ÁÀƒ?áë…AYÒòAÙB'ãTBeå`B”p!Cˆ´CúCúCúCúCúCúCúCúB‰OßCúCúCúCM BSOßÂôٚÎVÃÈ´Ã ÷LÃT¼ÃcTÂódZÂã“uÂÔ²ÂÅ}q·ð¤Â Oß Þ5 ê·LÂMÓÁòó¶ÁÓ²Á¥\ÁL ÅÀ‹DA"$ÝAÃn˜BbBZØBšò-CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂñIºÃ.ƒ×Ã%›#Ã9X÷ÏÃ$ZÂ÷ÀÂäxRÂÒËDÂÂÒòÂþúÂ6F¬Âéy‰7 ˜“ÁþÊÁÁÒ$ÝÁ‘ÎÙÀîéy@»;dA¦ÌÍB.BBãTB¤ZCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ4ÁHÃ=ÅÃ-ÌJÛ¦ÃÃnVÂóÈ1Âß¾ÂÌÒòÂwÏÂ#jÂ'LÍÂ)NÙÂ(G®Â"¥ãÂs¶ÂzáÁÃ5?ÁV?ïžA?}Aö¼jB"éyB€yÛCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúœ5?ÃPAÃ>!HÃ,Æfܬà ÎÃßÂéÏ\ÂÕvFÂ(RòÂ.ùÛÂ4Û#Â9$ÝÂ: ÅÂ7š Â-æfÂüîÁøÒòÁ¡$ÝÀÀ“uA ZAÇ…BñªB”!ËCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCîqìÃ];dÃJ©7Ã7¶Ã$áHÃcÃÏ\Âò=qÂÜKÇÂ1(öÂ9\)ÂAÂG‡+ÂKvÉÂK¸ÂD)üÂ3àB”{ÁÚí‘ÁWt¼@/²A•ë…AúãTBž@CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB© ÃgâÃSwÃ=èsÃ*Roüîà QªÂ÷õ?Âá‰Â8bÂB+ÂKE¢ÂS†%ÂY’oÂ[Ÿ¾ÂWNÙÂIÌÍÂ0SøÂéyÁ¦å`À–n˜AJ$ÝBvÉC\§+CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC'.˜Ãi#×ÃXWÏÃAR-Ã,Äíà ð!Âú»dÂãiüÂ>PåÂH«ÂRùÛÂ\ÂduÂgñªÂeÖÂZ¾wÂDšÂÀƒÁÚVÁ9V@¼ýôAÈoC‹DCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúAaC–ÃX üÃAš Ã,]/ÃG+à ´¼Âú™šÂ㈴ÂB7LÂMÂWÙÂbÂj^5ÂoA‰Ânm‘Âe=qÂQ%Â/º^¹XÁŒ%¿áë…A)¥ãB&vÉCúCúCúCúCúCúCúCúCúCúC´ 7CúCúCúCúCúCúCúCúÃFòòÃ>\Ã)P!ÃÁHÃÇ+Â÷ÄÂá€ÂD@ƒÂOhÂYæfÂd\ÂlxÕÂq“uÂqLÍÂi9XÂVì‹Â8‘h ƨÁ²²Áº^À VB÷MÓCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃDŽÃ8Ã#Ý/ÃiyÃgmÂò˜“ÂÝåÂD\ÂOÂYgmÂc JÂjïžÂo¤ÝÂoPåÂgÏßÂW =Â;vÉÂ%ÁÍë…ÁrMÓÁ(n˜C‚ã3CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃBÑÃD Ã.Z^Ãtþà  ƒÃàƒÂë‡+ÂØ ÓÂC`BÂM7LÂVØÂ_¢ÑÂf¨öÂj ÅÂiïžÂbÁ‰ÂSOßÂ:Oß°!ÁÜZÁŽPÁ\¼jB—I7CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ3 ÃJÀÃ5hÃ"ÏßþúÃÓ¶Â÷%Âã´ÂÑPåÂA ÂJhÂRɺÂZ–‡Â`ž¸ÂcÇ®Âb´9Â[Ü)ÂM¾wÂ7)ü§ðÁàÒòÁ;dÁß;@¡ë…CúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ^´¼Ã'–ÃB™šÃEx“Ã4 BÃ$¢Ññ'à féÂþã×Âëw¨öÂÁÂPÁU× A ©üBØüjCE‰C‚NCQÕÃ@Z JCúCúC̾VCúCúCúCúÂ7}ôÃò°Ã Á‰Ã ñhÃ’°ÃqìÃçðÂöàÅÂêñªÂÞ§ðÂÒs3ÂÆ›#»KD°œ)Â1¤ÝÂ7®Â=9XÂAó¶ÂExÕÂGTþÂG+ÂD JÂ=áHÂ4\Â&33Â%ãÁývÉÁÓÆ¨Á¾È´Á×VÁõƒA-OßÀÈ표âN¼lÂÇ8ÕÂͨöÁ ¼jC ¨öBÇڠ« ÓÂææéÂìò°ÂðýqÂóƒ–Âó¸Âï§mÂ韾Âá½qÂØ«ÂÎõÃÂÅ»$Z±…¨G+Â-k…Â2í‘Â7ûçÂwÂ;.Â;MÓÂ:ÖÂ:DœÂ:‚ Â=\ÂDÂRÂgÎÙÂPbÂæf—NVÂíÂ¢× Â¦r°Â¨øRª×¬ˆ´Â®gm°¤Z³6FµÐå·ú^¹=ô¹Nٸ쵖²œÂ­“u¨{ç¢ñ'Â!Ë—1ªÂ‘?}Â!uÃÂ%èsÂ*¦Â-øÕÂ1iyÂ4XÂ6»dÂ8š Â:oÂ;cTÂ=Â?¨öÂDRòÂL-ÂX0!ÂhRòÂzàB†s¶ÂŽb” ºÂ˜£×œ$ZžǮ Ý/¢±'¤€ƒÂ¦iü¨bNª7Ï«£T¬^¸Â¬8Õ«#© 7¦ Â¢s3ž9X™“u”¥ãÂŽÙŠféÂÈ´Â!þúÂ&1Â)ÑìÂ-PåÂ0záÂ3PåÂ5àBÂ8JÁÂ:ÌÍÂ=ÖÂA¯ÂG+ÂNÑìÂXüîÂen˜Âs-€cT†‰Â‹©yÂÚ“1ªÂ•× Â˜Â™Û#›\Â.ž±ªÂŸüî åã¡C ó¶ÂŸæéž5›¥`˜”{•‘þÂŒÞ5ˆzáƒþwÂBÂE¢Â"(öÂ%âNÂ)jÂ,¾wÂ/äZÂ2ì‹Â5öÉÂ933Â<æfÂAffÂGVÂN'ðÂVÍÓÂ`Ç®Âk€Âv0!€h„s¶Âˆ-‘‹EÂÎÙÂ쑸R“J=”­‘•޸–ÍP—`Å—}—–”„œÂ’dÝÂÆ¨ÂŒ½q‰^5Â…¼îÂîÂ|%Âß;µ?ÂvÉÂ"²Â%¦éÂ)uÂ,k…Â/½qÂ3%ãÂ6È´Â:ÔþÂ?‚ ÂEÂK{çÂRí‘Â[+ÂcÚÂl…Ât½qÂ|2-Â]²Â„*††%ˆ„œÂŠ3¶Â‹¡HÂŒÓøÂÊ=ÂŽz^ŽևŽÎÙÂŽW ÂgmŒŠ%`‡âNÂ…C–‚YÂ~e`ÂwÀƒÂpß;Á`MÓÁT JÁEó¶Á5ó¶Á${ÁjÀöE¢ÀÉ&éÀš^5ÀV‡+¿õãT¿b?Ù?ºŸ¾@©ü@ Z?ó•?¾w¾Ÿ¾¿ò\Àº^Àщ7ÁQìÁB9XÁp¸RÁ9XÁ¥/Á¹å`ÁÍ+ÁÞãTÁï Áýzá Š¥ãÂG®Â+ÂèsÂô¼Â:^Âɺ·LÁe‘hÁX¬ÁHn˜Á6r°Á"{Á dZÀå%À¯•ÀnÈ´¿÷ÎÙ¾#× ?ÂMÓ@@£×@†áH@ í‘@«t¼@£÷Ï@‰%@4‹D?F§ð¿ä“À—çmÀÿSøÁ5ãTÁlZÁ®Á©ÔþÁÁKÇÁÖñªÁê¼jÁü¬Â^5 n˜Â|î„ÂÂ{çÂ!~úÂ"œ¬Â"ì‹Â"†%ÁlMÓÁ]²-ÁLr°Á8bNÁ!`BÁdZÀÕ‡À–5?À&E¢¾×P?âMÓ@xb@¹Oß@ìIºAE¢AùÛA\@ÿ÷Ï@Ê{@yº^?[dZÀ+¥ãÀÐýôÁ(§ðÁhr°Á’ß;Á¯\ÁÊÁâ/Áø7L‡Â+ÂÞ5ÂŒJÂ#Â'BÂ*NÙÂ,:^Â-¬Â-uÂ,@ƒÁtÌÍÁe¸ÁRZÁ<5?Á"vÉÁùÛÀÇ•À|Iº¿ºÀƒ?”¼j@uãT@ÏoA‹DA/× AH~úAU©üAU AE¸A%º^@ïÎÙ@vÙ¾½p¤ÀžffÁ Áe…Á– Á¶záÁÔÁîÙ©üÂÎÙÂÒòÂ!›¦Â) 7Â/Â3…Â6˜“Â8W Â8áHÂ8aHÂ6þúÁXÁnÀƒÁZ“uÁBjÁ%ë…ÁÐåÀ½ó¶ÀR J¾¹Û#@1%@À¬AZAE•Ap\Aˆ´9A’ A’ÒòA‰áHAnr°A7|î@ãïž@VÀT“Á çmÁd$ÝÁš+Á¾p¤ÁßÁü• èsÂwÏÂ#Ü)Â-ÚÂ66FÂ<ËÇÂA‘hÂDš ÂF JÂFšÂDöÉÂBÛ#Á† ÁzõÃÁe™šÁK•Á,n˜Á©üÀ¹ûçÀ1xÕ?;d@Š^5AÒòACPA€A›çmA±\)A¾¸A¿ÂA´Û#A›¦AwÎÙA$áH@ó¶¿éXÁ ÁdÙÁŸbÁƲ-ÁéýôÂ2-ÂÂ"ùÛÂ0BÂ;âNÂEr°ÂL¾wÂQÄœÂT¥ãÂUž¸ÂTöÉÂRûçÂOñªÁÙÁ… JÁsß;ÁXMÓÁ6°!ÁbNÀ½º^ÀKÇ?µ?}@·¾wA&^5As…AŸ¬A¸AÝ•Aî‡AïÙAà^5AÀ?}A”—AFV@º^5¿&éÀý©üÁhIºÁ£©üÁÍG®Áò²Â &éÂàBÂ.6FÂ>F¨ÂL)üÂWH´Â_e`Âd”{Âg ÂgVÂe²-Âb”{Â^XÁ—%ÁŽA‰Á‚ë…Ái¸ÁEt¼ÁçmÀË\)À Ôþ?õ@݇AEïžA‘%A¿¬Aéº^BbB>wB5?B_;AÛ—A Aº^@­ãTÀ&éÁ áHÁoïžÁ¥ÐåÁÎZÁôƨš Â$TþÂ:C–ÂN{çÂ_~úÂlˆ1ÂuxÕÂz™šÂ|jÂ{†%ÂxÂsâNÂn ÅÁ¡¸RÁ™?}Áó¶Á~›¦ÁYhsÁ+¸Àå/À;ƨ@hs@ö=qA` JA¦¸AÝ33B€Bœ¬B)¬B'F¨BƨB{dZCÞöC”ÐBB -ÀŸ¾Á5oÁ€oÁ¢²-ÁÄ\Áë;dšÂ*ÍÓÂH DÂb9XÂw:^ƒ0!‡ó¶ÂŠAЉ7‰>ú†È1ƒ~wÂQìÁ®Á¦¬Á›1'ÁŒ—Ás+ÁBÔþÁ§ðÀu`B?Ïß;@þñªAr{A·n˜AøVBõÃB4{çBB‘hB<¤ÝB&8RC‘BòCúCúCúC\ J?“oÁt¼Á™r°Á¬Ý/ÁÔ\) ’oÂ2›¦ÂZXÂ|‡Âнq“33—æé™†¨Â˜Ã––>wÂ’}Âô9ˆð¤Á»ÙÁ´áHÁª¶FÁœ“uÁ‰—Áa©üÁ"°!À¨ýô?"Ðå@ó¥ãAy©üAÃt¼Bò°B+^5BJ2-B[NÙBRF¨B>yÛC¢CúCúCúCúCúÁb JÁŽÊÁÁޏRÁ» 1'ÂB°!ÂvÓøÂ¾ÂžÓ§9X«(ö«q'© P¤ÐåŸc×™F%Â’ÕÁË1'ÁÅÁ¼~úÁ¯G®ÁœÔþÁƒýôÁG7LÀê=q¿€@Ñë…Au+AÉoB¬B9;dB_IºBvïžBoæfB´%ãCúCúCúCúCúCú¿òMÓÁ‹p¤ÁE¢Á¿£×ÂäZÂfùÛÂ’õê D¸¤ZÂÀ"ÑÂÂ'ðÂÀ,‹Â»l‹Â´å`­X“Â¥RòÂ6ÉÁÛß;Á×ÐåÁÐhsÁÄ›¦Á³;dÁšçmÁt^5Ál‹ÀSC–@™%AdAÇ®B§ðBCüîBtØBÖB¡KDBòaHCúCúCúCúCúCúÁ‹DÁ‚C–ÁlÈ´Áê•ÂSšÂ–Z Â¸Ý/ÂÎÚÂÚxÕÂÞz^ÂÜúáÂךÂÏ«ÂÆ=q¼;±àŧß;Á훦ÁëPÁæ(öÁÜKÇÁÌ\ÁµXÁ”çmÁS&éÀÈ1@33AFvÉA¿%B{BIaHB…p!Bú CúCúCúCúCúCúCúB«$ÝB| JAs™šAªKÇÁ›å`ÂVyÛ¦·ÏÂèVÞÃåÃÕÂû)yÂñ.ÂåC–ÂØbNÂËQ쾘²‡+ÂÂ#×ÁýOßÁõÝ/ÁèVÁÒß;Á³^5Á‡È´Áí‘¿V‡+A\)A¯"ÑB ¼jBCñªBmCúCúCúCúCúCúCúCúCúCúCúBîßB„ìCúCúCúÂhÝ/Ã$œÃÉà ¾¸ÃíPÂûX“Âê¡HÂÚ_¾Âˮ¼Ô{ V ¹X œ¬ÂMÓÂë…Áò¾wÁÔáHÁ©¾wÁ^“uÀ’§ð@ÓKÇA˜¬AþÊÁB.ÑìB‰àÅCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂðt¼Ã)oßÃ÷ ÃÃb ÂüÂ蛦ÂÖ¨öÂÆaHÂwÏÂ0!Š=ÂÌÍ î˜ÁøVÁÎzáÁ“ÀƒÁ ó¶@2MÓA{hsAàÈ´B­C+DCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúB(—Ã;‘Ã,ÿ;Ã}Ã;Ãæ%ÂõI7Âàð!ÂÎÖ  ÅÂ!õÃÂ"Ø Á‰Â]/‡Áôr°ÁºƒÁY?}¿½²-ABùÛAÊÌÍB |îCöPÅCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC\ ÅÃJøÃ9ó3Ã)nÙÃQhà l‹Âÿ¹ÛÂéYšÂÕ›#Â"èsÂ(#×Â,[#Â.ËÇÂ.e`Â)ÀƒÂ)ü ¼jÁájÁ“¬À¿ß;A ZAÄÀƒB6W CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂ!‚ ÃZ7 ÃDòoÃ1¨´Ã ’-ÃF%ñ'Âï~wÂÚ›#Â)“uÂ/ÐåÂ56FÂ8þúÂ: Â7“Â.2-ÂiyÂÄœÁ¹OßÁ(n˜@¨QìAÂB–ûçCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ\H´ÃN!Ã7ÁËÃ$¦éÃ: Ãô¼Âó ÂÝåÂ.í‘Â5í‘Â<49ÂAÂCPåÂA¬Â:LÍÂ+-Â;dÁÛ=qÁohs?‰7LA©ƒB‡:áCúCúCúCúCúCúCúCúCB2°CúCúCr°CúCúCúCúCúCúCúCxËÃR'+Ã;€ƒÃ&lJÃ5?Û¦Âô;ÂÞr°Â2ÌÍÂ:BÂAoÂFˆ1ÂIœ¬ÂHî˜ÂBƨÂ5,šÁ÷r°Á™1'ÀÎÙAcçmBbNC”.úCúCúCúCúCúCúCúCúCÜø´CúB•:^C׃CúCúCúCúCúCúCúÃ<\Ã;ÜîÃ%¢ Ã,‹Ã©ºÂò—ÂÝJÁÂ5-Â<ÊÁÂCÌÍÂI‚ ÂLó¶ÂLÔþÂGŠ=Â;@ƒÂ&¬Â†%Á·{ÁxÕ@¨bA¦ÐåC‚?}CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ@ÙXÃ7úáÃ" ƒÃ2°Ã;¦Âî¸ÕÂÚAÂ6#×Â=§ðÂDPÂJ/ÂM¤ÝÂM½qÂI%Â=Ü)Â*Ÿ¾ÂÁÏ?}ÁeÎÙÀF—@Y™šCÙCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÑ PÃI ÍÃ/õ?Ã"Nà ‚NÂÿ+ÂèÑìÂÕ“øÂ5Û#Â=oÂC£×ÂHöÉÂL7LÂLSøÂHÂ=ÚÂ,n˜Â ÅÁàQìÁޏÁå`À™Û#Bv¯CúCúCúCúCúCúCúCúCúCúCúCúCúCœ•¢CjÈsCúCs°!Ã^-ÃULÍÃ: ÅÃ% ÅÃK…Ã}/ÂõPÂáI7ÂÏŽÙÂ4PÂ;W ÂAt¼ÂF[#ÂILÍÂI[#ÂEiyÂ<>wÂ,–‡ÂRòÁë~úÁœ¸RÁ ó¶?4¼jBªùÛCúCúCúCúCúCúCúCúCúCúCúCúCúÂÖz^ÂÀ!Ãk Ãc$ÝÃRã–Ã<øÕÃ)w Ã$Ýà e`Âÿ33Âê¦fÂØŽÙÂÈ…¢Â2wÏÂ8ÄœÂ>e`ÂBÚÂE€ÂEŒJÂBVÂ9úáÂ,/ÂyÛÁõ JÁ§Á‰7Aœ´9CúCúCúCúCúCúCúCúCúCúCúCúCúCúÂûÎVÃU^úÃLe¢ÃA!Ã4‡ðÃ&§+ÃP!à  Ã Âð“øÂÞïÂÏòÂÀÊÁÂ/ÓøÂ5¤ÝÂ:ÌÍÂ>Þ5ÂANÙÂAxÕÂ>”{Â7Ç®Â,šÂaHÂ1Áºí‘Á)+AÈ CúCúCúCúCúCúBîKÇC'×CúCúCúCúCúCùøöÃ$ã×Ã-ˆöÃ)»dÃ$>¸ÃÆfÃþ¸Ã Á‰Ã¦¨ÂñþúÂáÚÂÒð!ÂÅ:ḪÂ,ÖÂ25?Â6ó¶Â:¹XÂ=uÂ=|îÂ;_;Â6 PÂ,ɺ« p¤ÁÜSøÁ|î>t¼C©CúCúCúCúCú®5ÃÂÏÎVA°=qCúCúCúCú ÅÃ¥`Ãð¤ÃÑÃxà !ËÃnÂûÞ¸ÂîCÂà²-ÂÓåÂÇ»YšÂ°féÂ)¤ÝÂ. ÅÂ3 JÂ6ž¸Â9Â9ËÇÂ8’oÂ4Þ5Â.49Â$\ÂÝ/¾ÁØvÉÁ©KÇÁO\)B ÖCúCúCúC£–ÂàV‡ÂëkÂà/žÂ˜“CúCúA·n˜Âô"NÂû0¤ÂýNÙÂýò-Âû¼îÂö‹ÇÂîëÂåž5ÂÛ\¬ÂжÉÂÆb»«…±°!¨4¼Â&_;Â+1Â/49Â2«Â5+Â6l‹Â6$ÝÂ4hÂ/ô¼Â)­Â!KÇÂr°Â[# ~úÂ!†%Âf+ŠݲAï¼j@£×¶’òÂÓ´¼ÂÑgðÂÏœ)ÂÏdÝÂËìÂÌ*ÂÖë…ÂÛ/ÂÞÂÂá”{ÂâܬÂáâÑÂÞ”þÂÙE¢ÂÒr-ÂÊ›¦ÂÂ0¤Â¹ˆ1°âN¨hö :^Â#Â'|îÂ+{çÂ.èsÂ1”{Â3QìÂ3õÃÂ3aHÂ1‹DÂ.•Â*ò°Â'µ?Â'=qÂ.]/ÂEbNÂur°Âœ…µ B¼½A‰Â¼þw¼dݼU½E¢Â¿!ËÂÁƒ–ÂÄ6FÂÇ4¼ÂÊAÂ̰¤ÂÍÖÂÍKDÂÊþúÂDzÂÁó¶Â»Ø“µ5® ºÂ¦ÒoŸ Å˜’oÂÛ#Â$ =Â'çmÂ+SøÂ.2-Â0dZÂ1ÙÂ2Š=Â2bÂ2-Â1î˜Â2Þ5Â6È´Â@uÃÂSH´Âq 7Š­‘šV£‘h¨ª¡Ë¬Oß­¨s¯ °Ø²÷Lµc×·ô9ºX“¼#T¼ïžÂ¼~wº¼j·ÀƒÂ³¸R®Ý/©hö£‘서—dZ‘MÓ°! ²-Â$vÉÂ'çmÂ*ó¶Â-ŒJÂ/¬Â1_;Â2ËÇÂ4:^Â6-Â9qªÂ?0!ÂHÔþÂW–‡Âkj€ð!‹T{“Ro˜áHœ½qŸ‰7¡´¼Â£›¦Â¥yÛ§n˜Â©xR«yX­9X®t¼Â®ì‹Â®vÉ­ª/§]²Â£k…žïžÂšì”õ?¸ÕŠt9—Âs¶Â!#×Â$™šÂ'ÊÁÂ*³3Â-VÂ/Ç®Â2/Â4ÎÙÂ8 J‰7>©xÕ;ƒo¿@Äœ¿ø´9ÀbÀƒÀ°9XÀø›¦Á#Û#ÁM¶FÁxn˜Á‘n˜Á¦%Á¹®ÁÌ$ÝÁÝG®Áì÷ÏÁû ÅÂÔþ B ÔþŠ=ÂgmÂuÃÂÂÂ]/ÂXÁe&éÁXƒÁIÛ#Á9+Á&ffÁ¥ãÀö5?ÀÆ$ÝÀ” ÅÀC ¿ÀA‰½}ó¶?˜Ôþ@ ¥ã@4Iº@A7L@.¸R?ôýô?&é¿£÷ÏÀd‹DÀÆùÛÁ¾wÁBƒÁtÁ’dZÁ©ãTÁÀ&éÁÔó¶Áè/Áù¼jÂÖ ¸R´9®¥ãŸ¾Â©üÂ ÓøÂ!5? äZÁkSøÁ]‘hÁMt¼Á:ÔþÁ%©üÁ ÷ÏÀç¾wÀ¯l‹Àh¿Ûçm>2-?ü1@dzá@›Æ¨@¸1@öF@¼9X@ b@^{?©Û#¿¬¬ÀŽffÀú\Á6bÁoC–Á“—Á®OßÁÇp¤ÁÞÔþÁôhs J ãT¦éÂE¢Â ´9Â$ð¤Â( Â)úáÂ*ñªÂ+Â*LÍÁsoÁdIºÁR¸RÁ>(öÁ&~úÁ ¥ãÀÛl‹À™ë…À'¾w¾­‘h?úáH@…Â@Æ^5@ü“A&éAIºA²-Aff@Ø´9@ˆå`?’ñªÀ‡+ÀÍG®Á(vÉÁjA‰Á”ýôÁ³/ÁÏl‹Áé©üÂõà\ =ÂƨÂ&&éÂ,¦Â0Ÿ¾Â3¿}Â5“uÂ6=qÂ5âNÂ4©üÁ|Ÿ¾Álí‘ÁZÁC•Á)`BÁ C–ÀÒvÉÀ†ùÛ¿Ô“?†ff@tzá@ÑG®AõÃA3?}ALvÉAY™šAXMÓAGKÇA&°!@ïïž@v$ݾ¸ÔþÀVÁ1ÁdÝ/Á–ZÁ¸$ÝÁ×®Áõ¬ÂDœÂê SøÂ*G®Â2–‡Â9%ãÂ=ò°ÂAhÂB¦éÂBáHÂAó¶Â@oÁ„¬ÁwÒòÁcº^ÁK‰7Á.áHÁ t¼ÀÎMÓÀp1'¿Iûç@‡@¶^5A÷ÏAAº^Alå`A†´9A™šAxÕA…xÕAcƨA,Iº@мj?Ü(öÀZÐåÁ p¤Á^ÐåÁ—"ÑÁ¼dZÁßZÂ:^Âî˜Â²Â+êÂ7r°Â@èsÂH)üÂM9XÂPÇ+@”ZA A]ûçA“‰7A´MÓAͼjAÛÌÍAÚ‘hAÇSøA£?}AlE¢A|î@YÊÁÀXÀð´9ÁOë…Á’—Á¼KÇÁæ ÅÂn˜Â4þúÂHqªÂX·LÂeF¨ÂnVÂsMÓÂuuÃÂu JÂr•ÂnPÂi`BÁœÆ¨Á”r°Á‰‘hÁwdZÁTÌÍÁ*vÉÀïdZÀp? Àƒ@«\)A)p¤A€‰7A«ñªAÓ‡+Aò¥ãBÖAÿ¼jAá…A®“A…‘hA(Ù@G®Àct¼Á5?ÁISøÁŠŸ¾Á³éyÁâ~ú ”{Â'¡ËÂBì‹Â[hÂn•Â|푃!HÂ…b†!HÂ…5?ƒ&é€F¨Ây«Á§¥ãÁŸ´9Á• Á‡Áj^5Á=çmÁ¥ãÀ²->™‡@µ©üA9ÎÙA`BAÂKÇAñ®B ÙB$ÝBŽVA÷›¦AǬBÇÚ CòCA½/Aú²ÀÊùÛÁEC–Á|jÁ¥;dÁڇ ýôÂ21'ÂU1ÂrÜ)„í‘ÂŒÜ)‘‡®Â“qªÂ“)y‘5ÃÂŽVŠÂ…˜“Á³Ý/Á¬“uÁ¢ZÁ”\Á‚‡+ÁW¸ÁûçÀ±?}¾ÎÙ@°£×ABjAšƒAÕ‰7B1Bž¸B,&éB'È´B 49B„]²CúCúCúCúBàÒòÁ&´9Á[¥ãÁ“ÔþÁÓ~úÂ@ƒÂCoÂnÒò‰I7–Bž~ú¢¦f£‰7¡ñªÂž‘ì™üéÂŽèsÁÁVÁºýôÁ±‘hÁ¤SøÁ’xÕÁvIºÁ;VÀã¶F¿ÎvÉ@šE¢AAïžA¡ JAä§ðB =B29XBFKÇBDó¶B'F¨C"^wCúCúCúCúCúÀ¨›¦Á1%Á…“uÁØë…Â$l‹Â`¬ÂŠ‹DžÓu¬dZ´¶ÎVµõòzá­7Ϧןݲ˜§mÁÏïžÁÊÐåÁÂ…Á¶7LÁ¤ñªÁ²-Á^éyÁ¬ÀUó¶@ct¼A7A¢/Aî?}Bò°BFjBh 7BwáHB^ýôB¼†%CúCúCúCúC0ö‡À/PÀí/ÁxÈ´ÁñçmÂDÊÁˆ?}§¢Â¼#×ÂÈnÂÍÓu·ÂÊ BÂÄ™šÂ¼ó¶Â´j«†¨Â¢¦éÁßjÁÛÊÁÁÔõÃÁÉ÷ÏÁ¹¸RÁ£Á„—Á:È´À²§ð?ܬA"Ý/A(öAïéyB$âNBVô¼B“YC!¥ãC„C3BÒñªCúCúCúCúB0¬B7L@¯¥ãÁ[&éÂPÂxäZ¬iüÂÎ}qÂã8RÂ뀃Âì¸Âè;dÂá&éÂ×çmÂÍgmÂÂ`B·Y¬©üÁït¼Áí“uÁèƒÁß33ÁÐbNÁº©üÁœ\ÁiÁ—¿ A—A‘¶FAæí‘B ~úBWèsCçmCúCúCúB½«…CúCúC) ÇCúCúCú@ö Jˆ1ÂuG®Á^ÐåCæé«W à YÛÃ;çÃBÂøÒoÂëÄÂÞ´ÂÐF¨ÂÂöF¶bÑÁÿ¬Áÿ¸RÁü§ðÁõVÁèXÁÔbÁ¶ÂÁŽÒòÁ6(öÀZMÓ@½VA"ÑAÓ× BuÃB>÷ÏC‹9ÛCúCúCúC‹ÖFBƒÑhCuCî@ÅCúCúCúCètZCúCúCúCúCúÃΘÃ|)ÃÚáÃPbÂÿ\)Âî,‹ÂÝ’òÂÍñ'¿{dÂËÇÂÓøÂaHÂÓøÂe`ÁîZÁÒVÁªÈ´ÁljÀЋD@OÎÙA^~úA¿“uAó BûuCúCúCúCúCúBräZC:‘ìCúCúCúCúCúCúCúCúCúCú¹‡+Ã+}²Ã Åø“Ãã–ÂýÂ鱪Â×Ô{ÂÇšÂ[#Âe` DÂ¥ã aHÂ;dÁî$ÝÁÇÁ’—ÁÈ´? 7LAAë…A¹Û#A÷¸RCÕQCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÃ"_¾Ã<ÿ;Ã,ŠÁÃ*ÁÃà ÂôoÂà2-ÂÎiyÂDœÂ>wÂïžÂ¬Â“u“uÂm‘Áã²Á®õÃÁRÀ|îA/× AË&éBB ÅCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC/ï\ÃX¶‡ÃN¦éÃ97Ã'dœÃõÃà G+Âü9ÛÂæ«ÂÓ¢NÂF¨Â bÂ"¬Â#l‹Â!l‹ÂŽVÂ}ôÁý‘hÁÉçmÁƒ(öÀš¬AA‰AäE¢B¿¤ÝCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÀ"ÑÃ]Ø“ÃE…¢Ã/33Ã/žÃ ýôÃá‰Âêô9Â× PÂ!?}Â%°!Â) 7Â* ÅÂ)‘hÂ$»d #×ÁâzáÁœ£×Àú^5@öéyAäº^B·ƒCúCúCúCúCúCúCúCúAe33B; B RòÂj =ÂùßCúCúCúCúCúCúÃ(ªÃOËÇÃ5²Ã w ÃÃ;dÂììÂØ•Â%VÂ)ñªÂ-ÑìÂ0%Â/²-Â+º^Â"ËÇÂcTÁ÷¼jÁ´ë…Á4-@t¬A¿bNB–:áCúCúCúCúCúCúCúCúÂ*œ¬Âg J /¼TþÃ@ÌJCúCúCúCúCúCúC̹šÃRKÇÃ7ÖFÃ!MÓÃ)üÂì~úÂØ2°Â'¬Â,ÎÙÂ0ûçÂ3“uÂ3ÂÂ0záÂ(|îÂ]/™šÁËG®Áo™š¿¿²AuÒòBŠøCúCúCúCúCúCúCúCúC;dCÜ’NCúCúCÖà¤CúCúCúCúCúCúClãTÃR†éÃ6ÃPåÃ<¬ÃqìÂé ÂÕøRÂ)#×Â.YÂ2¡ËÂ5hsÂ5çmÂ3'ðÂ,Â49 dZÁÞ´9Á”l‹Àã•@©ûçAÀ`BCúCúCúCúCúCúCßî¸CúCúCúCúCúCúCcACúCúCúCúCúÃPÃL†¨Ã/€ÅÃŒ‹Ã ~5ÂúáHÂäëÂÒòÂ)”{Â.¶FÂ2õÃÂ5Å¢Â6s¶Â4 ÅÂ-ƨÂ"DœÂr°Áî\Á¬xÕÁ:=q¿ô›¦@@1'C¡ý/CúCúCúCúCúC’½CúCúCúCúCúCúA²33ÃÌ‹CúCúCúÃeÍPÃ\~wÃ=\)Ã%•?Ñ'Ã3øÂò”{ÂÞMPÂÌÂÂ)$ÝÂ.¬Â28RÂ4ûçÂ5È´Â3ØÂ.E¢Â${Â8RÁûQìÁ¿1'ÁhŸ¾À‰%@ç®C­¹ºCúCúCúCúCúCúCúCúCúCúCúCúCúÃiÂa‰ÃqÌÍÃo¿;Ã[ÿ;ÃB\îÃ, Ãüjà /ßÂý§ðÂè”{ÂÖRoÂÆQìÂ(Â,Á‰Â0±'Â3cTÂ4KÇÂ2ÂÂ.%Â%6FÂ^5Â`BÁ϶FÁ…ãTÀ‰VB$Û#CúCúCúCúCúCúCú‰Þ5CúCúCúCúCúCúÃCÎVÃWå`ÃSl‹ÃIB Ã:¤ZÃ*©7ÄZÃNÃ0!Âï³3ÂÝ„ÂÍk¿øÂ&[#Â*Ý/Â. ÅÂ1DœÂ2SøÂ1DœÂ-r°Â&&é‡+ }ôÁâÒòÁžÛ#ÀäQìB]ffCúCúCúCúCúCúB-yÛÃwÏCYê=CúCúCúCú¤¼îÃ/ß¾Ã1ž5Ã/!‰Ã)|)à úáÃç®Ã |¬ÃxÂòYšÂá`BÂÑ÷ÏÂÄ·TþÂ$RòÂ(²Â,;dÂ.Ü)Â0"ÑÂ/Ÿ¾Â,ÒòÂ'/ DÂŽVÁúå`ÁÅIºÁq\)A õÃCúCúCúCúCúCúŸ¾ÃyšÂØ#CúCúCúCúÃ6FðåÃ.VÃHsñ'ÂU"ÑÂx\)‘¥`£›¦Â­°E¢Â°üj°ûç±6ɲ"N³ÍÓ¶ D¸— »'ð½bѾáH¿JÁ¾l¼;ç¸Õ´l‹Â¯=q©ƒ–£t¼Â<î–þúÂÓu¡ËÂ%Â"¾Â$Þ5Â';dÂ)7LÂ*ãTÂ,k…Â. ÅÂ0PÂ4Š=Â;RòÂFožÂW49Âm‘hƒW ÂŽ¸Õ—òœl‹ÂŸÄ¢ £Ç+Â¥€ƒÂ§^¸Â©hö«†%­ˆ1¯0¤Â°>ú°xÕ¯¼î®ƒÂ«Qì§Ðb£¢Ñžô¼Â™î”²-Â]²ÂŠ´ÂqªÂþúÂbN‘hÂ"†%Â%?}Â'ƨÂ*33Â,¯Â/ƒÂ3 Â8 7Â?+ÂHÈ´ÂU´9ÂecTÂv\)ƒ;çŠ ÂA‰Â“1ªÂ–2-˜ššµÃœ­žb YšÂ¡ïžÂ£+…£å`£øR£MÓ¡ܬŸ¬‹ÂœÏß™bN•€ƒÂ‘IºÂŒÙˆF¨Âƒ§mÂå`Â_;½qÂúá ‡Â#uÂ%üîÂ(êÂ,Â/~úÂ3¬Â8èsÂ?™šÂHoÂRe`Â^;dÂjƨÂvùÛ€øÕÂ…ž5‰m‘ÂŒ‰7‘NÙ“A”ÿ}–‰7—Ðå˜Á™@™7Ϙ˜“—\)•‡+“$ZÂG+‰r-Â…¦fµ?Â{]/Â[#ÂÀƒÂÂ[#ÂŽV µ?Â#Ý/Â'¦Â*PÂ._;Â2ÄœÂ7÷ÏÂ>0!ÂE‘hÂN{ÂWzáÂaLÍÂj÷ÏÂsöÉÂ{øÕÂqªÂ„bцàB‰œÂŠÝ²ÂŒu?ÂÌJŽۦ–‡ÂîÂÓøÂ>úÂŽ*ÂŒ™šÂŠ“øÂˆ%ãÂ…_¾Â‚QìÂ~šÂwA‰Âp7LÁ`ÌÍÁV“ÁIë…ÁwÂâN¶FÂÂÂoµ?¾wÁeOßÁY‰7ÁLÁ<°!Á+™šÁÙÁŸ¾ÀÞ\À²\À†‡+À8 Å¿ÔZ¿ó¶>6E¢?'®?@ƒ>×P¾¹X¿Ìí‘ÀQ&éÀª$ÝÀõÂÁ$=qÁP ÅÁ}VÁ”í‘ÁªÊÁÁ¿ÂÁÓ•ÁæoÁ÷VÂ2- ùÛÂÑì²-™šÂP˜“ÂÌÍÂ9XÁ*õÃÁ•ÀüƒÀʰ!À–Ÿ¾ÀC¶F¿¸“u=‰7L?±‰7@Sø@FE¢@TZ@A™š@ × ?LIº¿p¤À]p¤ÀÅÛ#Á\ÁDùÛÁxZÁ•®Á®vÉÁÆ(öÁ܃ÁñXÂ;d ØÂm‘ÂçmÂwÂ>í‘Â?OßÂ>”{Â<ë…Á‚›¦ÁuÒòÁc/ÁLõÃÁ2í‘ÁéyÀåãTÀšvÉÀ‡>àA‰@MV@½7LAŸ¾A(záAA =AM`BAK7LA9A¼j@ÕãT@Ko¿Rn˜À¤QìÁ^5Ác;dÁ•ƒÁ¸ffÁÚ ÅÁú‘h µ?ÂhÂ(Â3+ÂwÂ%33Â4qªÂAs¶ÂKå`ÂS¯ÂXäZÂ[¿}Â\ŽVÂ[£×ÂYTþÂUïžÁ+Áˆ“Á{ïžÁc =ÁDùÛÁ!SøÀïÆ¨À‘?}¿Ÿ;d@?}@à A9XAX“A…\)A˜vÉA¢Ÿ¾A¡xÕA“ÄœAtÌÍA2=q@ÓdZ@ƒÀ+t¼Àñë…ÁIC–ÁÁ·&éÁáÛ#²-ÂIºÂ0¸RÂBô¼ÂR9XÂ^²Âf“uÂkÑìÂn6FÂn33ÂlhsÂTjÂfSøÂsº^Â|²-€Ôþ›¦Â€ÿ}Â~²Ây¡ËÂsÁ¢;dÁšr°Á33Áƒ{ÁeSøÁ=&éÁ  À©¸¿Ÿ @På`A=qAShsA‘ÄœA¶IºAÓ(öAã9XAà¶FAÆ;dA•²A›XB&1'A‹§ð¿¾ùÛ@é©üAn(öA·‡+AúKÇB§ðB>bBW5?BQl‹BF¨B<¡ËC‘NwCãIšB•;AÑhsA{AÀΗÁáÄœÂS±'–u÷xÕÂËùÛÂÖ)üÂÙJ=Â׫ÂÒ¶FÂË~wÂÂàŹŠ=¯û禌JÁá1ÁݶFÁ×^5ÁÍ(öÁ¾"ÑÁ©A‰Á‹DÁT^5Àúñª¿¶@»¶FA\\A¯÷ÏAð¥ãBÂB:iyBŽr-B·Ý²BEÜ)AíQìB<›¦B‚"NB`äZB§ÍÓC´9B^ÀƒA5\)ÁÊÙÂxÓøÂ°àBÂÊ9XÂí¯Âù5ÂöøRÂð½qÂçýqÂ݇®ÂÒ BÂÆgmÂºÓøÂ¯³3Áï&éÁíIºÁèhsÁß•ÁÑÀƒÁ½¶FÁ¢KÇÁ}%Á#…ÀaÛ#@‚ÙACƨA¡7LAÓ°!Aîß;B2èsCyºCúC…Œ‹AËZBµ?B‡´9C9„CúCúCúCØ5B‹ß;A`¬Aù¡ËC£ñ€޸ÃÍÓà ҰâÑÂýÙšÂï£TÂá#×ÂÒÝ/ÂÅ0!¸XÁý JÁü¸RÁùn˜Áò/ÁåÄœÁÒÝ/Á¸{Á”-ÁL°!ÀºV@ ¬A+²A“—A³vÉAÕ1'C¼HRCúCúCúCúB›CXSuCúCúCúCúCúCúCúCúCúB‰àÅÃ!ò-ÃþúÃ-à ÄÝÓuÂïZÂÞs3ÂίÂÀ,‹Â+ÂÅ¢Âò°Â&éÁùzáÁçïžÁÎ{ÁªbNÁwOßÁÝ/>ÖA33A”1AµbB5SøCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúC‰æÉÞ¸Ã<;Ã.¢Nà £TÃ-ô¼Âü/žÂè°¤ÂÖð!ÂÆæf KÇ ¤Ý œ¬Â ¥ãÂhÁü Áãn˜ÁÀIºÁ‘Á(ƒ¿™xÕAýôA©‡BLÍC-’-CúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCWФÃe5ÃÃX ºÃA4¼Ã-ú ÃÞ5ÃäÝË…Âñ!ËÂÝš ÂÌA¹Xº^Âm‘Â>wÂvÉÂ?}Á÷9XÁÕ1Á¥ÀƒÁNQìÀ7;dAÐåAÆéyBQxÕCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúCúÂÀcTÃi`BÃU;dÃ;8RÃ&€ƒÃÈ1þwÂ÷[#Ââ_¾ÂÐÂYÂéyÂ;d½q·LÂJÁÂs¶Áè ÅÁ¹ÄœÁuÊÁÀžÀƒA ÔþAÔí‘Bu)üCúCúCúCúCúCúCúCúCúB\5?Aƒ¬ÂEC–³ؓCúCúCúCúCúCž'LÃ\ô¼ÃG”þÃ-€ƒÃú Ã r°ÂûåÂåßÂÒ\Â\ PÂÞ5Âò°Â–‡Âì‹Â ó¶Áù =Á̰!Á¾wÀø(ö@»;dAà ÅB¥9XCúCúCúCúCúCúCúCúAKo‡©ü¤‚Ã?¾Ã)ñhCúCúCúCúCúCúÁóA‰ÃO›dÃ1•?Ãæéà `ÅÂûùXÂå„ÂÒNÙÂÒò²Â!JÁÂ!Ñì %ÂoÂÂÀƒÁÞ-Á¥KÇÁ3‡?•¡ËAŒ+BºêCúCúCúCúCúCúCúCúÂÚBÂÎì‹ÂZRòÂ-‚ ÃN|)C˜“CúCúCúCúCúBÌbNÃPµ?Ã1VÉÞà \jÂùúáÂã¹ÛÂÐǮ©üÂ!"ÑÂ#ŽVÂ$jÂ#‡ÂÍÓ¯ ¾wÁíÛ#ÁºXÁn“À²-@ó33BKÇCúCúCúCúCúCúCúÂÔožÃÛÂ8jCÀsCúËÇÃ}?}C¸æfCúCúCúCúÃUQªÃJ%Ã,ZáÃ^wÃlÍÂõ33ÂßÒoÂ͗§ðÂ"6FÂ$Å¢Â%áHÂ$ó¶Â!MÓÂ#×–‡ÁûÁÍ“uÁ’l‹Á¥ã¿3t¼@’^5CƒÕCúCúCúCúCúÂ|îÃ'Ñ'Ã|îA™-C Õ?CLsøÃ *=ÃXÆËçC¡'CúB;dÃuPÃ]°bÃ<9Ã# ÅÃDÝÃÔ9ÂîÂÚhÂÈò-ÂêÂ"yÛÂ%²Â&iyÂ%ÚÂ"Òò£×†%®ÁÞ¡ËÁ©´9ÁRÐåÀ˜´9@ ÊÁC4ÑìCúCúCúCúCúCúÃ{Ã7ÏC¢#CúÁŸG®ÂæfÃD¢NÃyÿ¾ÃƒðƒÃ‚ËÇÃzüîÃ`lÍÃC¬ÍÃ+ÁHÃŢà ‰7ÂúÂäì‹ÂÒ×ÂìÂPÂ"‡Â$ÖÂ&:^Â&+Â#¤ÝÂxÕÂÚ JÁîn˜Á¾ÀƒÁ€ùÛÀÍ%A†ó¶CúCúCúCúCúCúCúà 7§T{CúCúC¼ùÛÂj7LÃ0ŠÁÃOÃTÃWéÃVŽÃLóuÃ=Ã+¨1ÃiºÃ 3uÃúÂìäÝÂÚšÂÊå¼c×´9Â!/Â#å`Â%ˆ1Â%µ?Â$ÂçmÂàBÂBÁþ~úÁÕXÁ\)ÁjA©“CúCúCúCúCúCú?,1ÃôþÂïŽVCÐ PCúCú‰¾wÃ&SøÃ.àÃ1½/Ã0æ¨Ã+záÃ"f¨Ã‡mà h1ÃàÅÂðƒ–Âß.˜ÂÏ¡HÂÁ©üµÂ{çÂèsÂ"©üÂ$záÂ%bÂ$hÂ!¦ÂÖŠ=ÂÓøÁïƒÁÄ ÁŠ JÀgß;C„§mCúCúCúCúCúÂPöÉÙÛÃÃ×ÂÅqªBÓX“CÓ¾®Ã~5ÃdœÃ/ïÇ+à üjÃèsÂþMÓÂî®Âß§mÂÑßÂ㸀­xÕÂûçÂ^5Â!-Â#33Â$5?Â#ò°Â"%ã†%ÂÌÍ®Âå`ÁðÙÁÓ“Á½1ÁŸ =BW;dCúCúCúCúÃò-Ã’°Âñ PÂéâNÂÙwÏÂÒ›¦Âôr°ÂÿËÇìÃ~úÃiºÃ‡+Âûõ?ÂòbÑÂçT{ÂÛ¢NÂÏåãÂÄ}ô¹ž5¯_;¥ȴÂH´Â¢ÑƒÂ!Á‰Â#2-Â#¨öÂ"ûçÂ!+´9 JÂTþ xÕ )ü¾wÂ2^5‚¨ÁÔ;dCúCÈÝôžBÂ÷èöÂäZÂØÏßÂÕÞ5Â×r-ÂÛÂßiüÂã~wÂç ÓÂéUÂé|jÂç¾Ââ]/ÂÛ§mÂÓ“øÂʳ3ÂÁyÛ¸¼j¾Û"Ñ¿×ïžÀXbNÀ®È´Àû®Á(ÁTñªÁŸ¾Á˜ãTÁ¯ÌÍÁÅûçÁÛ"ÑÁîûç§ðÂïžÂ>w‚ ­ÂÀƒÂ"ÂÂ$ÂÂ%ÔþÂ&hÂ%“uÁq¾wÁe =ÁV1'ÁE¸Á1ÊÁÁE¢ÁÄœÀ×+À¢\ÀZ-¿âñª¾yÛ#?‹çm@ G®@4‹D@BŸ¾@/P?òÐå?G®¿²ÐåÀoÎÙÀÎáHÁ¸ÁIçmÁ~(öÁ™OßÁ³&éÁÌ/Áä Áú—® JÂDœÂ ;dÂ%å`Â*@ƒÂ-XÂ/A‰Â0šÂ0Â/Áy¥ãÁl¬Á\“ÁIp¤Á4{Á1Át¼ÀÉG®ÀŒQìÀ33¾õ?}?¯ @@Äœ@ŠáH@§…@³ =@ªùÛ@Ž{@9hs?C× ¿ïß;À‰7Á1'Á=VÁwPÁ™+Á¶1'ÁÒt¼Áí—²ÂzáÂ(öÂ#wÏÂ+C–Â1yÛÂ6¦Â9©üÂCPÂF¢ÑÂHÂH ÅÂFøÕÂDÔþÁ‡-Á‘hÁm‘hÁXbÁ>È´Á!¡ËÁ—À·ß;ÀP´9¿#× @¬@”›¦@áxÕAVA(QìA3ÂA1?}Aó¶A£×@« @¿ÉÛ#À±©üÁ‹DÁbÌÍÁ•C–Á¹xÕÁÝ®®ÂÞ5Â!äZÂ0;dÂÅ¡Ë@§\)A%¸Aw+A¢‡+AÃïžAÚÒòAá =AÑ&éA­"ÑA³‡B¬A½G®A p¤@z¬¿xbÁOßÁ‹•ÁäÊÁÂ"jÂPô¼ÂyŸ¾ÂŒàŘPbŸm‘¢Ý/£Z Â¡˜ž49™°¤Â”vÉÂŽ× Á¼Æ¨Á¶ÄœÁ®+Á¢t¼Á“¬Á?}ÁO&éÁt¼À¤A‰¾¼j@›²A&§ðA€º^A¬ë…AÔ—AòE¢Aþ1'Añ¸RAχ+A¹G®Aà$ÝAÇ¡ËA‹ÄœAUë…@û¥ã¿eãTÁP‹DÁß7LÂ/ffÂk=qÂŽ_¾Â “u¬cT²Æ%´àB³À°I7«7ÏÂ¥!HžwL—ŽÙÁÈ‘hÁÃdZÁ»‡+Á°bNÁ¡\)ÁÔþÁj—Á.ÔþÀГu¿½²-@‚n˜A¶FA€oA®éyAÙ(öAùxÕBë…Aýå`Aâ5?AÍ+AÙÒòAñ AòE¢AáoA®ÐåA.í‘À¨ ÅÁÐ`BÂ@ÓøÂ‡ì¦œÂ¹ÎVÂÄÓøÂÉRòÂÉ'ðÂÅ´¼ÂÀ¸âѰñªÂ¨¥ã QìÁÔÂÁБhÁɲÁ¿C–Á°ÊÁÁ|îÁ„¼jÁL-Áí‘À:^5@:MÓA“uAqt¼A¤‰7AÆ\AÙn˜AÛ“A̾wA¹G®AÅdZAÿxÕB)§ðBK&éBR²-B<>wB–‡A!&éÁ¯°!ÂZ™šÂ¢ŽVÂÆC–ÂÚ2-ÂâbNÂã8ÕÂߎVÂØó¶ÂÐwÏÂÆæé¼Û#²Ã¨éüÁá‡ÁÞÁظÁμjÁÁ JÁ®7LÁ•~úÁl£×Á!VÀ’ff?¿²@ø´9AY+AŽ/A–…Aƒ®AÁÄœBn“A´AnéyB{çBpJÁBÍþwC*ÒoCW\¬CaožBÖõÃÀëß;€PÂÈ™šÂîäZÃéüÃ'mÂ÷·LÂíoÂá;dÂÔàBÂÈ„¼ƒ–±ÁíE¢ÁëZÁæ§ðÁÞdZÁѧðÁ¿…Á§bÁ‡‘hÁAhsÀË|î=+@ÒÐåACÎÙAmt¼A5 A4E¢CÈsCúCúCØÈB|ÖBÔ-‘CúCúCúCúCúC ÂØ“Âüp¤Ã{dÃmPðbà ÇÃŽ˜ÃÃTÂñËÇÂâZ ÂÓŠ=Âป¦ÁøùÛÁøC–ÁôÌÍÁíÀƒÁâ¸ÁÐÝ/Á¸å`Á™G®ÁbÔþÁ´9¿¦§ð@½/AB£×Ae× AƨAÐí‘CúCúCúCúCúC—xRCúCúCúCúCúCú¾höÃ!ùÛÃ<œ¬Ã8Ó¶Ã-G+Ã!!ٚà Ý/ÃÌJÂî× Â݃–ÂÍ£T¿.˜Âô¼Â/ÂhÁüSøÁñå`Áá¬ÁÊjÁªñªÁ‚A‰Á•À+@» =A]ÊÁA“¸AŽÝ/B²$ÝCúCúCúCúCúCúCúCúCúCúCúCâ)šCúBKÙÃZÂNÃ\EÃF¾wÃ3CÃ"Ã×Ã…`ÉÂùÎVÂæ–ÂÔYÂÄ‘hÂß;¤Ý¬ÂÑìÂ8RÁñ^5ÁÛ JÁ¼{Á“1Á=7LÀnE¢@½7LAƒ|îAÍéyB6NÙCyXCúCúCúCúCúCúCúCúCúC¾¿;Cœ…ãCúCúCúCúÃK`BÃaLJÃF½ôÃ/ºáÃIüÃ" ÃSøÂ웦ÂÙffÂȉºÂ - m‘ l‹Â ¶F¹XÁÿ¡ËÁêƒÁÌ…Á£í‘Á]©üÀ«÷Ï@§®AÀƒB­B­k…CúCúCúCúCúCúCúCúAÞ+Án~ú€/CúCúCúCúCúCúÃ4ƨÃXdZÃ;ÄZÃ$ßÃÖÃnÂðõÃÂÜ”þÂÊô¼ÂÂÂk…ÂáH°! KÇ JÁøp¤ÁÛùÛÁ´å`ÁoÀ÷"Ñ@CoA…¸B#·LCúCúCúCúCúCúCúCúCB ‡ܬ«áËÂþÞ¸C7»çCúCúCúCúCúCúÃJ9ÃD‰7Ã)5ÃÃOžÃå¢Âò¸RÂݱ'ÂË´9™šÂ•Âm‘³3Âß; QìÂTþÁêC–ÁżjÁ•-Á,Àƒ¿`A6å`BjCúCúCúCúCúCúCúCúÂÐÅ¢ÂÛÆ¨Âú 7Ã!·LÃ8ýqCúCúCúCúCúCúÃ@Å¢ÃG3øÃ*ÃG®Ã„Âñ¶ÉÂܪÂÊÁ‰Â´9Â푇ÂÄœÂyÛŸ¾Â’oÁ÷7LÁÖ Áª‡Ád¼jÀ¼j@X1'At\CW¸CúCúCúCúCúCúŸÃ™šÃ3ÃÙšÃ-¾wÃXûçÂÿz^CúCúCúCúÂ&PÃe{çÃBMÃ&lJÃHÃB ÂíúáÂÙ‘hÂÈ1'¬„Âî˜ÂøÕÂ0!ÂV þúÂcTÁåC–Á¾n˜ÁŽbÁ,áHÀ‡dZ¿Ò\AjCúCúCúCúCúÃõÃÃîVà þ5ÃqìÃãÃ0eãÃP6‡ÃmëÂÃþCúCúÃtÙÛÂG®ÃX(öÃ6ΘÃbà LÍÂþ¥`ÂçÍÓÂÔ/ÂÄ+…ÂäZÂn˜Â PÂl‹Â"Ñ»dµ?‡+ÁóVÁÑl‹Á§(öÁmhsÁ‡Àíó¶À«•C¦ çCúCúCúCúÂéyÃ?;ïßà û#Ã|)Ã)ØÃ?IüÃWqhÃo{çÃ*=ÆhsÃ}ÑìÃ]ã×Ã?çmÃ(×ÃKDÃWÂô1ªÂ߬ÂÎ#T¾ïÂ#×ÂޓuÂA‰ÂwÏÂÏßÂÜ) 'ðÂ=qÁãZÁ¾XÁ‘ùÛÁE…ÀãPAé¶FCúCúCúCúCúÁéÌÍþ5à {ÃÉ7ÙÛÃT¼Ã,?¾Ã;hÃHæ¨ÃSçÃTµ?ÃKBÑÃ:ØRÃ)sÃ®à ƒÂüÒoÂèÂÖ-‘ÂÆŠ=¸ÃÂïžÂ¤Ý²š ÂPåÂn˜Â—Ân˜ÂŽVÁõ ÅÁÖVÁ¯OßÁ‚oÁïžBG­CúCúCúCúCÞu?Ü)óøÃýôÃõÃÄZà iyÚáÃ"šáÃ)üîÃ.ÆfÃ.ò-Ã)Æéà •?Éyà OÂÿ„Âì]²ÂÛ8RÂËéü¾:^±ò°Â_;Â#×ÂG®Â“uÂËDZ'ÂþúÂn˜Â ¼jŸ¾Áï¶FÁÒº^Á²MÓÁ”× ÀÛ+B÷ßCúCúCúCúÃ…`à c×ÂüûdÂø»dÂû›¦ÃAHÃíPÃP¤Ã¨´ÃQªÃE¢Ã.Và ŒÍÃXRÂúüîÂëG+ÂÜEÂÎF¨ÂÁbNµ‘ìªÖƒÂY¤ÝÂ?}Âúá¦éÂÂ#׫ Ÿ¾Â¾Áù‹DÁëZÁìA‰Â 7Â+33BÙ‰ºCúCú@—à ÑìÂú3¶ÂéZ Âå}ôÂèA‰ÂîøÂõ¾ÂûÞ¸ÃÉ7Ã|îÃv‡ÃƒÂù²-Âïã×Âä§ðÂØÜ)ÂÍ#ÂÁ¿}¶ùÛ¬ݲ£q'Âl‹ÂQìÂƨÂ®ÂæfÂRòÂÙÂl‹ÂhÂò°Â„ÂÝ/ÂbÂbNÂ7ffÂu Å˜ÙÂf“r°Âé¢NÂì¨ÂÝ ÂÔl‹ÂÒ*ÂÔÙÂØÂÜó3ÂáÄœÂåÇ®Âè ÅÂè"NÂå‹DÂàŠ=ÂÙ/ÂÑ`ÅÂÈfé¿$Zµì¬ò°Â¤W œ+Â&éš¶FÂäZ‘h­Â/¾Ÿ¾ÂüîÂÔþÂ\)Â"ÑìÂ0)üÂK&éÂxŽV™ƒ²æf°!ÂÉQhÂÇÕÂÃÖÂÁ¸ÂÀܬ£×ÂÅ´¼ÂÉSøÂÌáHÂÏÃÂÑiüÂÑk…ÂÏ™ÂÌ¢ÂÆô¼ÂÀĹÒo²vFªñªÂ£uÜ$Ý•u»dº^ÂxÕÂçmÂûç¯Â+  Â!ZÂ#~úÂ'ŒJÂ/¸ÂúŠȴ†9Û¤Z ÊÁÂÛ#ÂÚÂƨ¢ÑÂyÛÂZ `BÂ#³3Â'Š=Â,/Â1ó¶Â9/ÂB²ÂLÅ¢ÂXËÇÂewÏÂqØÂ}ƒ_¾Â‡aËŠ°!Âs3Âڠ‘üî“äZ•‹D–àB—ÍP˜:ᘇ—U•õ?“ýô‘}ôÂŽ‰7‹5Çš ÂƒÌJ½qÂw ÷Ï Â = 7 7Â"ÑÂjÂ"þúÂ' 7Â+º^Â1F¨Â7Ü)Â?“uÂH`BÂRÂ\ÂeäZÂo¾ÂwffÂ~›¦Â‚ffÂ… ͇Z Â‰[#‹þÂŒ†%Â¥`ÂŽdZÂŽ¶FÂŽ\ÂçðÂŒ¾ú‹šÂ‰††%ƒ¶É€¤ZÂz¿}Âsð¤Âl÷ÏÁc‡ÁZ$ÝÁPbÁDí‘Á8ÐåÁ+Û#ÁA‰ÁVÁr°Àê¬ÀÑXÀ»ß;ÀªáHÀŸ®À›|îÀŸC–À«Æ¨ÀÁ`BÀà1Á®ÁG®Á69XÁSÂÁs`BÁŠ ÁšÆ¨Á«`BÁ»›¦ÁË7LÁÙùÛÁç¶FÁôA‰Áÿzá£×ÂÎÙ :^ÂéyÂâNÂ/ÂÞ5ÂûçÁg‡Á];dÁRbÁE‘hÁ7× Á)%ÁOßÁ =Àñ7LÀчÀ²ñªÀ˜1'À‚ffÀfE¢ÀW®À[¶FÀt(öÀõÃÀ²\ÀÞE¢Á ™šÁ'ûçÁISøÁmVÁ‰‡Á›ë…Á®¥ãÁÀó¶ÁÒ‡+Áã"ÑÁòPÂIºÂ‡+ ïžÂzáÂ&éÂöÉÂô¼Â.´9˜“ÁlÁaG®ÁTùÛÁG‡Á7®Á&ÙÁÔþÁó¶ÀÝXÀ·+À’È´Àc× À,Ý/Àzá¿Üí‘¿ÛÆ¨À/À5À~éyÀ¯÷ÏÀë33Áº^Á=C–Áe‰7Á‡°!ÁœéyÁ²1ÁÆ©üÁÚ~úÁí9XÁþ•Â)ü Å¬ÂoÂÂî˜Â!èsÂ#Â#LÍÂ"æfÁr1ÁfvÉÁY =ÁI¾wÁ8\Á%¡ËÁ"ÑÀöÐåÀÉó¶ÀœõÃÀc À"Ñ¿²-¾Ö‡+=‰7L>)ûç¾.{¿vÈ´À ¡ËÀy%À¾vÉÁ`BÁ/l‹Á\\Á…ÂÁ²ÁµdZÁÌ®Áã ÁøMÓÂùÛÂÛ#©üÂMÓÂ"¹XÂ&ì‹Â)ïžÂ+ØÂ,½qÂ,¼jÂ+õÃÁyG®Álí‘Á^r°ÁM¾wÁ:È´Á%©üÁ‹DÀë•À·ÎÙÀƒC–À®¿~¸R> A‰?«dZ?ÿ\)@ í‘?ó¶F?‰X¾‘hsÀƒÀ?}ÀáÛ#Á¡ËÁQ× Áƒ ÁÎÙÁ¸‰7ÁÒÙÁìKÇÂ8R hsÂ}ô JÁÂ'°!Â-›¦Â2oÂ5 ÅÂ6äZÂ7~úÂ7Â5ÓøÁ€ó¶ÁtáHÁel‹ÁS`BÁ>§ðÁ'OßÁ |îÀã À§× ÀV$Ý¿»C–>£× ?ó•@KSø@%@‹ÎÙ@ƒ× @Pb?㕾|í‘À0À´ÄœÁ ²ÁDå`Á~ÐåÁ&éÁ»-ÁØùÛÁö1ÂÜ)¶FÂ!?}Â+;dÂ3{çÂ9ñªÂ>£×ÂA¬ÂC0!ÂCaHÂBp¤Â@bÁ†Á~~úÁn-ÁZáHÁDzáÁ*í‘ÁZÀÞ¬À›"ÑÀ+ ¾ùÛ#?Íó¶@`1'@¡ó¶@Ä´9@Ôzá@Î^5@±G®@|“?Ý/¿|í‘Àƒ®Àò-Á5 Átn˜Á›-Á¼çmÁÞÔþÂ"ÑÂ.Â{Â,cTÂ7ÂÂ@úáÂGþúÂLÝ/ÂOÀƒÂPàBÂP}ôÂNÚÂL49Á‹ãTÁ„ñªÁxáHÁdƒÁL\Á0å`Á™šÀÝÛ#À’ÙÀß;>Ÿ@4ÌÍ@¢{@ÞMÓAÝ/A¶FA × @ýV@Ň@oß;?VÀ‘hÀÂáHÁ!VÁe²Á—33Á½7LÁä1'ÂbÂ_;Â)ÒòÂ9G®ÂFDœÂP‹DÂXuÂ]Â_‘hÂ`“Â^ì‹Â\aHÂXÅ¢Á’™šÁ‹•Á‚ÙÁpvÉÁW"ÑÁ9‰7Á¡ËÀãKÇÀ(ö¿Þ¸R?‘h@z\@Ñ&éA “uA'hsA5ë…A5¥ãA%‰7A§ð@¸¼j@,1¿,IºÀŠÀƒÁùÛÁP ÅÁ=qÁ»|îÁèß; qªÂ!ɺÂ6l‹ÂHs¶ÂWF¨Âb ÅÂj\ÂoSøÂqPåÂpùÛÂn¿}ÂkVÂfDœÁš(öÁ“1'ÁŠ\)Á~Ý/Ádn˜ÁE Á ÐåÀïKÇÀ”9X¿È´9?Ð@š=q@ûKÇA(E¢AI+A\^5A^‹DANA+ûç@úñª@”Iº?°ÄœÀE¢ÀÅ‘hÁ0bÁ„¾wÁ¶ÌÍÁìº^ÂbÂ,ûçÂE”{ÂZ¢ÑÂkožÂwƨÂÛ#‚å‚–‡ÂÍÓÂþúÂzÝ/Ât¤ÝÁ¢‹DÁ›ÄœÁ’ùÛÁ‡å`Át‹DÁSÎÙÁ-`BÁKÇÀŸ÷ϿҰ!?ñÊÁ@¯33AýôA@ÔþAhÀƒA€ùÛA„Ax‡+AT´9A#Û#@ã®@†vÉ?\)À3t¼Àý`BÁd1'Á­™šÁïhsÂÍÓÂ:¹XÂX;dÂpÁ‰ÂވKDÂŒ0¤ÂÔþ£×ÂŒ–‰Qì…ݲÂçmÁ«®Á¥?}Áœ§ðÁ‘—Áƒ¼jÁe®Á=xÕÁÌÍÀ´“ÀbN?ìí‘@¹ÒòAí‘ASó¶A§ðA‘º^A—…A‘‘hAAU©üA,\A Oß@öF@33ÀDÝ/Á'ë…Á¸ÁðVÂ#¸ÂL\Âo§ð†ÂDœÂ–ۦšB ›VÂ™ÓøÂ—“H1މÎVÁµ|îÁ¯‰7Á§OßÁœn˜ÁŽ‹DÁzŸ¾ÁQ =Á 1'ÀÐÔþÀ*\?¼¬@·× AXA^A‰PAœjA¤Æ¨A¡›¦A•\A‡¸AzffAoVAZ¸RA't¼@ïžÀÂÁ€¡ËÁí%Â.¦éÂb‹D†Ðå–ó¶Â¡ÀƒÂ§æfªH´Â©Å§/¢ò-ÂÇ+˜‘éyÁ¿ÔþÁº|îÁ²È´Á¨G®Áš‹DÁ‰/ÁgÒòÁ5;dÀõÒòÀg|î?@A‰@§ß;A(öAZ5?A‡l‹A™KÇA ÐåAŸ(öAšffA›XA§hsAºAÃÙA´ASø@§KÇÁ!ó¶Áä‰7Â=úá€}qš{d¬JÁ¶Þ5»»d¼Z¹ë…µ_;¯m‘¨¤Z¡l‹ÂšøÁÊ…ÁÅë…Á¾áHÁ´ë…Á§‡+Á–=qÁ€²-ÁMxÕÁ Àšn˜¾ŽV@ŠÐåA áHAE%AlMÓA{dZAt¬AhbAp5?A’¶FAÆ®Bò°BdZB ÐåB”{A£7L¿ ƒÁØ&éÂUɺ–ƒµ/ÂÇu?ÂÐSøÂÒ˜“ÂÐp¤ÂËZÂÄbѼLͳ¦fªÔþ¢¸ÁÕXÁÑ•ÁËXÁÂoÁµ33Á¤-ÁŽ\Áh9XÁ)çmÀÇo¿Á&é@Kt¼@é‰7A! =A)/A?}@ŽŸ¾?çKÇ@.ffA$záAÃl‹B+BpbNBŠ´B€‚BBKÇA}hsÁÔí‘Â{d¸÷LÂÚ<îÂê0¤ÂîÉ7Âì•Âæ`ÅÂÝÉ7ÂÓ×ÂÉA‰Â¾…³ùX©ÔþÁàoÁÝ9XÁ×ß;ÁÏjÁÃ5?Á²Ÿ¾Á¬Á‚VÁDŸ¾ÀöéyÀ2~ú@Sø@À“@÷KÇ@®—¿ÜIºÁffÁÛ#¿Ø“uAi7LAš1BFî˜BÎÅ¢C(YXC‰üC&‹…B—/Áû…²PbÂòlÃ|¬Ã )ºÃ S¶ÃÈöÂýÔ{ÂðÏßÂãTþÂÕëÂÈ켑ì°ûdÁêt¼ÁèPÁä&éÁÜ™šÁÑ1'ÁÁ5?Á«ùÛÁ‘ Á`QìÁ× ÀP?ž5?@­¡Ë@Ó¶F?å`BÁ-ë…Áº‰7À› CúCúC F¨Bw¹XCK¥¢CúC¯5`Cß‚NCEKDÂm®ÃàBÃ'¼Ã,nVÃ&ÄÃöٚà %ÃòòÂòYÂá×ÂÒ}qÂÄRò·TþÁô?}ÁóIºÁïÛ#ÁéE¢ÁÞÄœÁχ+ÁºÆ¨ÁŸÒòÁ|\Á,~úÀ£•?J~ú@»o@ól‹?ØÔþÁqƨÁèÆ¨Bb†%CúCúCúCúCL9XC³±'C[MÓC;ôB3ÚCWŠ=CúCˆ1ÃE ÃGF¨Ã5q'Ã%z^É7à ,ÍÃ$Âìˆ1ÂÚÓuÂÊfÁý33Áý&éÁú¬ÁõbÁë‡+ÁÝ-ÁɸÁ®ÁŒ¡ËÁFE¢ÀÉ>Ó÷Ï@ÙVA"~ú@ŸdZÁ‡C}W CúCúCúCúCúCúBvøÕA÷ãTÁ£ JCx;CúCúCúCÖ[çÃ\VÃN¹Ã6ñªÃ#‹ÇÖÉÃ,‹ÂõeãÂဃÂÐøÂÀµÃš ÂþúÂ7LÁÿÎÙÁ÷KÇÁéùÛÁÖãTÁ½1Á›~úÁbùÛÀúvɾöÈ´@ä1AHffA,£×BãTCúCúCúCúCúCúCúÁ½ÄœÂ;LͯïCúCúCúCúCúÂ!ËÃd/ÃH‰Ã.gmٚà ÝôÂûèsÂæ-ÂÓ‹ÇÂÃ]/ JÂÑìÂwÏ¡ËÂçmÁõ©üÁãÐåÁËA‰Áªó¶ÁïžÁí‘À@´QìAL¬AÌ$ÝCT{CúCúCúCúCúCúÁì¸Â—œ¬Â»Ã–Ã<)CÌ‚CúCúCúCúCúÃZN˜ÃU`BÃ6{#ÃCTà ®Âÿq'Âè{dÂÕ¬ÂÄyÛÂès   =©üÂzá JÁïÆ¨ÁÙÁºÝ/Á”vÉÁJ§ðÀ¸Z?Íp¤AÎÙAñÒòCk™XCúCúCúCúCúCŸ³øÂÐAÂÔ°¤ÂöDœÃO\Ã0ÈöCúCúCúCúCúÃJ¨sÃ\: Ã9ª=à /Ã*=Âÿ‘hÂè5?ÂÔ¬‹ÂÃþú - ŽV ïžÂ ýô [#²Áú©üÁæ ÅÁÊÙÁ¨IºÁ};dÁ¥ãÀ‹Æ¨¿•¸>/Aò“C¨´CøÃøCúCúCú»#×Âó&éÂ÷ Jà ¥ãÃ'ŽÃPLJÂ{£×CúCúCúCúÃyYšÃY— Ã6ƒTÃ!à !‰Âü+ÂåWÂÒBÂÁ÷Ï àBÂ~úÂ/§ð ’oÂŽVÂ:^Áòl‹ÁÚjÁ¼5?Á˜‘hÁeSøÁ'•Á%|îÁ–‘h Ý/À†E¢CÕàCÁÆé¤B Ã;Ã9XÃ" ÀBÃ0bÃ%ã×ÃDg+Ã_w B¤I7CúCúÃUÜ)ÃtDœÃK‡Ã-ˆsÃ" ÃÊÂõ‰ºÂà¦ÂÎ Á¾†% PÂß;ÂÙ¸RÂ/ ì‹Â™šÁýÒòÁé=qÁÏdZÁ±-Á‘× ÁtùÛÁ%ÁÌýôÂ+r°CqWLCúCúCX ºÃÄZëDÃËÃÙÃüîæ¨Ã3`ÅÃKÿ}Ãc5ÃÃpÍÃ{ üÃo6ÉÃR&%Ã6ØRà þ¸Ã­Ã²°ÂìUÂØíÂÈNV¹ß;ÂÁ‰ÂÁ‰ÂþúÂA‰ÂE¢ÂÈ´Â Â/Á÷KÇÁáº^ÁÈVÁ­—Á˜záÁšxÕÁÓ\«CG"ÑCúCúC eçðÃÀÂÿ™šÃYà ‘'Ã{#Ã"Ã17ÏÃ?ÓuÃJ9ÛÃK¿;ÃB¾¸Ã3VÉÃ"¯ßÃ\)ÃÑÂõ#ÂágmÂÐV‡ÂÁk…´DÂVÂ6F´9ÂW ÂêÂ49 ýô ‡Â\)Áó•ÁßC–ÁÉ~úÁ·ffÁ¶QìÁÞ™šÂÖÁ¢ÐåCAOßCž¸ÂåX“ÃÄZÂÿ‘hÂ÷›¦ÂùÓuÃÂÑà #Ãé7Ã$œÃ#\jÃ(˜“Ã)Ã$&fÃkÇÃëDÃ:ÂøPbÂåþúÂÕ’oÂÆå`¹Ä­ûdÂÂMÓ 7 JÂ,Â=qš ¢ÑÂǮ—Áöº^Áçß;ÁÝ+Áâ{˜“Â7ÐåÂUãTÁñ\)†°¤ÃIºÃåÂôŒJÂë’oÂë‹DÂñ¡ËÂûX“Ãhsà 5à BÃ'Ã+…ÃØÂI(öÂT±'Â`ÓøÂlƨÂwÑì€Á‰Â„޸ˆSøÂ‹A‰ÂÐbÂøÂ’{“ËD•(ö––‚–YšÂ•’ò”/žÂ’7ϺáÂŒÌ͉„Â…õÂ7ÏÂ|·LÂtâNÂçm Ñì ¸Rž¸ÂŠ=…Ÿ¾Âð¤Â–‡Â#·LÂ(~úÂ. Â4±'‹DÁ1‘hÁ#÷ÏÁûçÁ JÀõ&éÀÜIºÀư!Àµ¡ËÀªn˜À¦E¢Àª5?À¶éyÀÌÔþÀëïžÁ ãTÁ!ÒòÁ=;dÁ[XÁ{¶FÁŽÀƒÁ Á±C–ÁÂ;dÁÒŸ¾Áâ-Áð¬Áýå`ÂÚ ûçÂOßÂÒò‡+ÂvɬÂ8RÂ+Ám;dÁc•ÁX“uÁLA‰Á>°!Á0Á r°ÁIºÀÿïžÀà1ÀÂ{À§•À’À‚ñªÀw¾wÀ|(öÀŠn˜À¡hsÀÃoÀîÐåÁë…Á0jÁR JÁvIºÁŽ{Á¡r°Á´Û#ÁÇó¶ÁÚhsÁëë…Áü33‚  u½qÂs¶Â5?Â+Âó¶Â J e` {ÁrÔþÁhn˜Á\r°ÁNáHÁ?ÊÁÁ/KÇÁ¡ËÁ  ÀðbNÀÊéyÀ§KÇÀ‡"ÑÀX£×À1xÕÀIºÀIºÀ3¥ãÀc•À•ûçÀÅÒòÁ ÅÁ!ë…ÁGG®Áo©üÁŒýôÁ¢²-Á¸ÁÎÁâÛ#Áö¡ËÂÂ ÓøÂ+Âm‘Â\Â#bÂ&wÏÂ(VÂ)BÂ)W Â(®Áy‰7ÁnjÁaxÕÁR°!ÁBbÁ/²-ÁÒòÁÄœÀâ{À¶~úÀŒƒÀL1À ^5¿±&é¿lIº¿VE¢¿•ãT¿øõÃÀIë…À˜õÃÀØå`Á•Á:ÐåÁg‰7Á‹OßÁ£“uÁ¼{ÁÔ^5Áë÷ÏÂ6F ¡Ë =ÂDœÂ$49Â)ɺÂ.+Â0úáÂ2º^Â3e`Â3²Â2Á€¸RÁu²-Ágß;ÁWçmÁE¾wÁ1ÁXÁ¡ËÀÕÂÀ£²Àe?}À J¿k =LÌÍ?)ûç?Z^5?bN¾hr°¿ÁÊÁÀPå`À­º^Àþ‡+Á,QìÁ]t¼ÁˆÊÁÁ£× Á¿dZÁÚçmÁõÊÁ¸R²ÂMÓÂ'‘hÂ/A‰Â5PåÂ9Å¢Â<³3Â>Š=Â=È´Â<$ÝÁ…QìÁ~ffÁoÊÁÁ^¸RÁK Á4ýôÁ‹DÁ“ÀÌbNÀ“+À5?}¿”ýô> A‰?¿²@Ÿ¾@&§ð@b?ÉÛ#>dZ¿Òn˜À}ÀÕp¤ÁKÇÁP¼jÁ…%Á£$ÝÁÂ1'Áá…Â0!Âó¶Â¢ÑÂ(ÚÂ3NÙÂ;ÔþÂB_;ÂFùÛÂIÈ´ÂJúáÂJÇ®ÂIhsÂG{ÁŠŸ¾Á„QìÁyhsÁgXÁR^5Á:vÉÁÂÁ‹DÀÆÐåÀ†E¢À dZ¾|í‘?¾Ù@:ñª@zñª@ŒQì@‡²@\¬@n˜=•ÀKÇÀ¦ÐåÁÙÁ@=qÁ~áHÁ ûçÁÄ$ÝÁè¸ÂïžÂ¦Â&÷ÏÂ4þúÂ@ÑìÂJž5?¿•`B½Æ§ð@˜í‘AV=qA¾²B=qB $ÝAÞùÛAA/Á@¼jÂ"»d‡ Ó¯ô¼ÂÉùÛÂ×™šÂÜhöÂÛeãÂÖ¬ÂϤZÂÇB¾.´Û#«˜“¢›#ÁÕ33ÁÑí‘ÁÌvÉÁÄdZÁ¹A‰Áª¬Á˜\)Á‚=qÁQ/Á~úÀ»\)À=q>t¼j?¨1'<‹C–ÀzMÓÁÁ[‘hÁZ°!Àãïž@ºVA¸oBŠ=B5 DB£×A‰÷ÏÁ‚jÂ_ì‹Â´W Âà½qÂö¹ÛÂýÄœÂü\ÂõbÑÂëò°ÂáÙÂÕ‹DÂÉï¾’o³¬©[¦ÁÞvÉÁÛñªÁ×=qÁÏÝ/ÁÅXÁ·7LÁ¥¸ÁŽçmÁi|îÁ.ÐåÀâ§ðÀ^¸R¿Z¬¾ª~úÀR~úÁ'•Á¤¸RÁë“uÁÝ`BÁéy¿jA[ÒòB üîB8 ÅBqªA 33ÂMÓµiyÃn˜ÃðbÃßÃ/ÃP!ÃèsòÂò£×Âã‚ÂÕ²ÂÇš Â» ºÂ¯k…ÁçIºÁåPÁá¡ËÁÛ1ÁÑ7LÁîÁ±ùÛÁ›ÒòÁG®ÁE× ÁÀƒÀŒr°¿¿ ¿ŽùÛÀ¬Ý/Á€\Áý‹DÂ+ÎÙBÙ CúCúB$õÃA„²-AÇÌÍA@1ÁÃ1'¡B ¼bNÁ†33à üÃ;‚Ã2¤Ã$´þÃïžÃ ]²Ã×ÏÂð’òÂßB ÂÏ–‡ÂÁhö´“øÁïxÕÁî~úÁë`BÁå—ÁÜ•ÁÏÆ¨Á¾©üÁ¨ÙÁŽ33Á^$ÝÁ…À©ë…¿ö§ð¿£oÀ͉7Á¡õÃÂW @¤ZCúCúCúCÄ4œÀ¶FÁ@¬ÁãXµ?›VCúCúCúøÃNúÃ:<)Ã'ãÚà ™ÛÂûúáÂçÌÍÂÖ¬ÂÆ~w¸/Áöí‘Áö²-Áô`BÁïp¤ÁçOßÁÛffÁ˸Á¶Á›Æ¨Áy¸Á2—ÀÓ À/¾w¿Ñë…Àå7LÁ°5?BcCúCúCúCúC•$þÂÑìÂJA‰ÂŠÉºÂáäÝB]–‡CúCúCúCÎ~ÙÃRþwÃN¨sÃ5&%à ŽÃ Ã}²Âî?}ÂÚÚÂÊo»bNÁý‡+ÁýýôÁür°ÁøbNÁñ5?ÁæSøÁ×&éÁÃ-ÁªVÁ‹ÐåÁRjÁ p¤À”1ÀS Á VÁÂMÓAß¾wCúCÁÛ…CúCúÁñýôœ~w£õ?ÂÊ|îÃÂÞ.˜CúCúCúCúB—£TÃ[féÃ@`ÅÃ'}ôÃh1ÃPåÂò¢ÂÝs¶ÂËë¼½ô˜“Â&éÂÁ‰Â'ðÁú&éÁðt¼Áâ¥ãÁÐ?}Á¸÷ÏÁœß;Áy®Á6ùÛÀþ$ÝÀâ¸RÁI®ÁåÒòÂFËÇÂDMÓC<)CúCú¨‘ìÂÆ§ðÂÎùÛÂó+…ÃÖÃLÔ{ÁãÎÙCúCúCúCúÃ_šáÃF2-Ã*|îÃñìÃÂò¸RÂݱªÂËë¼ BÂô¼ÂÍÓÂÖ™šÂ PÁù²-Áí|îÁÝ =ÁÈ/Á¯+Á“1'ÁnÔþÁFA‰ÁKPÁš9X¹XÂt¬ƨ§¹ÛAã`BÂf¨öÂÜ\ÂÝNVÂè}qÃ\ô¼ÃHõ?ÃV^CúCúCúBèƒÃe[¦ÃDÃ(|)Ã;çß;Âð6FÂÛŠ=ÂÊu» ÓÂÙÂöÉÂC–‡+†%ÂÁ÷“uÁéXÁ×E¢ÁÁÐåÁªvÉÁ”ÒòÁˆ´9Á•(öÁѼjÂ)Òò‚¤Ýª#TÂηÏÂç2°ÂêÙÂç²-ÂèZ ÂôeãÃ;¦ÃøRÃ9!HÃ[ΘÃ;QhCJ=Â>ûçÃl+…ÃXó¶Ã9~5Ã!¤ÃròÃìÂê¶ÉÂ×)yÂÆ…¢Â¸"ÑÂKǧð F¨Â÷Ï…¼jÂn˜ÁôýôÁåáHÁÔbÁÁ¬Á°¥ãÁª(öÁ»¬ÁúVÂ<‚^¸ÂHzá‚–‡Âßu?ÂêPåÂèÐbÂë™Âö€ƒÃqìÀÅÃ(*=Ã?aHÃUâ Ãc`ÅÃdФÃVÃ×Ã?ÝqÃ)äZÃz Ã]²Â÷»çÂâÄœÂÐéüÂÁ‰Â´ DÂW  ì‹Â Ù ô¼Â h­ÁÿéyÁóÐåÁ噚ÁÖ¶FÁÊQìÁÆñªÁØÒò ¥ãÂDF¨Â…¬Â_9XÂŒ¢ÑÂÝœ¬Âç¹ÛÂææfÂéiüÂñ÷ÏÃ!à 6‡ÃIºÃ&‹ÇÃ3±ìÃ<,JÃ<–FÃ4œ¬Ã'™ÛÃ[¦Ã ñ'ÃTÂë6FÂÙšÂÉE¢Â»YšÂ¯  ÍÓ  ‰7 49 æf†% =Â…ÁövÉÁë¡ËÁã33Áâ—Áô JÂ\ÂGǮˆˆ1ªKÇÂÉ_¾Âßc×Âã ÅÂáå`Âã%ãÂéÂóݲÃQªÃ HÃñ'äÝÃS¶Ã\Ã.ÙÃròà šÃxÕÂî•ÂݶFÂÎt9ÂÀ»ç´ff©I7 \) W  Ö ¾w ô¼Â cT øÕ ¹X¿}ÂSøÂhÁüOßÁÿÈ´Â s¶Â!@ƒÂMV…ڠ§Ÿ¾ÂÄöÉÂÖ6FÂÚ8RÂÙ2°ÂÙ’òÂÝ}ôÂäõ?Âï;Âú¿}Ã!HÃáHà ¦¨Ã ¾¸Ãßà BÂùßÂë¤ÝÂÝ/ÂиÂÃwL·Á‰Â¬ü j ‘h SøÂœ¬ÂYÂzáÂþú ò°Â zá ê ß; xÕ´9ÂàBÂ0~úÂV„WŸÍÓ¸"NÂÇuÃẨ7ÂÌÛ¦ÂÍxÕÂÐ\¬ÂÕ©üÂÜÀÂä«…ÂìMPÂòk…ÂõáËÂõèöÂòYÂë­ÂâÂ ÂØˆ1ÂÍÅÂø™šÂ®³3Â¥e`œ´9 7L ‡+ ‡+Â(öÂaHÂ,ÂPœ¬Â‹D³3²-”{ÂÂ(wÏÂ=ÂÂ]†%‚×—þwªZ¶²Â¼X¾r-ÂÀ Ç»dÂÆÏ\ÂËò-ÂÑ‚ÂÖ¼jÂÚÔ{ÂÝ{ÂÝÂÚƒÂÕÊ=ÂÏPåÂǧm¿Qh¶¹X®*Â¥ÕÂ× Â–=ôÂÊÁ =q t¼ÂffÂ\ÂožÂ•ž¸ÂÁ‰Â\)˜“Â&k…Â3"ÑÂFMÓÂ`XÂKÇÂgmƒ¦ȴ¬«° P²²Âµr°Â¸å`Â¼× ÂÀéüÂÄ BÂÇvÉÂÈùÛÂÈÜ)ÂÇÂɺ¾³3¸և²LJ«bѤVÂSøÂ–z^ÂÝ/Â(ö º^ ÅÂXÂaHÂBÂVÂäZÂþú²-€Â%²Â-t¼Â9‡+ÂJVÂ^äZÂvuÆþw‘Oß™Qhžú^¢ó¶Â¦©o¬+…¯aH²‚ µ@ƒÂ·KD¸W¸2-¶ƨ´"N°k«Ø¦£×¡¨Â›1'•H´Âj‰©üÂX  \ÂÂX¡ËÂð¤ÂffÂ6F«Â#+Â);dÂ1t¼Â·KÇ> Äœ¿ ÌÍ¿àÄœÀ[…À±&éÁ£×Á.‡+Áb=qÁ‹DÁ¬“ÁÌ"ÑÁìÙ²¬Â$dZÂ1Â;±'ÂD=qÂJ¢ÑÂNøÕÂQiyÂR.ÂQ…ÂO­ÂLàBÁE¢Á‰‹DÁ‚™šÁt´9ÁaPÁKÂÁ3t¼ÁýôÀùÂÀ¿× À†5?À¸R¿q©ü> Äœ?™‡?ÎùÛ?Á©ü?\¬¾¦ffÀr°À„›¦ÀÖÐåÁSøÁR›¦Áˆt¼Áª²-ÁÏG®Áõ Â cTÂgmÂ/äZÂ>IºÂJ6FÂS~úÂZ(öÂ^`BÂ`cTÂ`‚ Â_ PÂ\QìÂXš Á•SøÁ•ÁˆÁûçÁk÷ÏÁTñªÁ;%ÁƒÀÿïžÀÀbNÀ€‹DÀ5?¾´9X?Ž{@ dZ@0r°@1ë…@V?ŽV¿%À%/À£÷ÏÁÄœÁ="ÑÁ€§ðÁ§MÓÁÑ‘hÁýß;¾Â*F¨Â=m‘ÂM× Â[{Âe+ÂkÈ´Âo£×Âp÷ÏÂp.Âm¯ÂiÚÂe+Á›ûçÁ–OßÁ33Á†…Áx^5Á`MÓÁDñªÁ&›¦ÁÎÙÀÆÐåÀ&é¿õãT<¼j?ÖÈ´@;t¼@k"Ñ@v$Ý@[ƨ@§ð?†¿St¼ÀLIºÀŲ-ÁdZÁiûçÁ¡bÁÒŸ¾Â±'Â2-Â7H´ÂMž¸Â`IºÂnÖÂy?}ÂÌÍÂyÛŸ;€œ)Â}e`Âx8RÂruÁ£33Á²-Á–§ðÁéyÁƒ\)Ámß;ÁQSøÁ1`BÁ—ÀÓÆ¨Àˆõÿÿß;=ß;d?õÂ@T“@†=q@j@‰/@f{@!‰7?Š~ú¿^vÉÀeó¶Àí?}ÁH ÅÁ–ó¶ÁÒ"Ñ hÂ):^ÂGE¢Âa`BÂvr°ÂƒåˆPå‹@ƒÂŒ;d‹¡Ë‰ÍÓ‡Ùƒ¨s¢ÑÁªçmÁ¥©üÁžÊÁÁ–¬Á‹xÕÁ}‘hÁ`¬Á>Ý/ÁjÀç•À˜¼jÀ¾w¾&éy?Ü1@Ië…@‚=q@ŽÐå@¡Ë@ƒl‹@hA‰@=V?å`B¾´9XÀ€ÌÍÁ&éÁˆ/ÁÐMÓÂÀƒÂ7^5Â[™šÂzˆ¶FÂá˕ט˜#T–‰Â“Ÿ;ÂÚ‹}ô†ŢÁ²ýôÁ®¸Á§‡+ÁŸ%Á”l‹Á‡™šÁq"ÑÁNå`Á)&éÁ =À°záÀCt¼¿WKÇ?x“u@£×@?¾w@Qhs@T¬@\Z@tÝ/@‹²@Ôþ@]V>aG®À¹7LÁj“uÁÏbÂyÛÂJÜ)Âv—ŒÙX¡YÂ¥xR¦‰Â¥2°Â¢.ÂøR˜øÕ“€ÂÊÁÁ»^5Á¶í‘Á°º^Á¨ƒÁžoÁ‘C–Á‚bÁa33Á:~úÁSøÀÏl‹À€Ôþ¿õ`B¾·ÎÙ?MÓ?5?>»çm?\j@j@‘ãT@Öñª@ëSø@ûç¿É™šÁE²ÁÔÎÙÂ*OßÂhuÂŽþ¡qªÂ®µ‰Â·ožÂ¶ß³X®ˆ´Â¨²°Â¢B›ˆ´Â”¾wÁÃß;Á¿õÃÁº9XÁ²hsÁ¨?}Á›•ÁŒ\)Áu`BÁM÷ÏÁ$ÀóïžÀ¦ÀƒÀS À "ÑÀÀƒÀ6Àƒ33Àž^5À²-¿öff@;d@äIºA!ÂA X?Ñ%Á<“ÁðýôÂJ§ð‹|j©LJ½¾ÂȬÂÌ_;ÂËáËÂÈ/žÂÂhö»[#³—«„œÂ£j›wÏÁÌ\)ÁÉ1ÁÃÙÁ¼…Á²ÂÁ¦^5Á—=qÁ…|îÁc =Á8^5Á ß;ÀÐbÀ™Û#À‡33À£ Àì“Á&1'ÁLÐåÁQhsÁ!º^Ày‰7@mãTA‡AõÃ?MOßÁ— #ׄŒJ²)yÂÑt¼ÂâRòÂè‚ÂçÄÂâ¼îÂÛ#×ÂÒ“ÂÈW¾^5´~úªí‘¡Ê=ÁÔ°!ÁÑùÛÁÍhsÁƧðÁ½ffÁ±dZÁ¢ÁÊÁÁyG®ÁMß;Á"“uÀùÀÈ“uÀÆ—Á ÁE²ÁŽí‘Á·¥ãÁÉó¶Á´…Áw™šÀ¼ýô?çl‹@E¢Á›¦ÁïÔþÂs»d¼r°ÂðVÃÞ5à «…Ãð¤Ã„œÂû”{Âîð¤ÂáïžÂÕøÂȬ‹Â¼äݱÔ{§‚Áܰ!ÁÚ¡ËÁÖ¸RÁЛ¦ÁÇó¶Á¼vÉÁ­õÃÁœp¤Áˆ=qÁdbNÁ7÷ÏÁ+Àó+ÀýÊÁÁ0$ÝÁŠl‹ÁÐ- ØÂKÇÁŒÄœÁš9XÁ©oÁ`§ðÁdA‰ÁÛÌÍÂ\‰7¾ffÃ^à Õ?Ã*ÙšÃ(ãÃÓøÃ¥`à  ÃdÝÂñBÂáÂÒuÂÄbN·ݲ¬ožÁä33ÁâÌÍÁß“uÁÚ(öÁÒ33ÁÇ\)Á¹jÁ¨MÓÁ”IºÁ|=qÁNÝ/Á&£×Á~úÁ²-ÁXMÓÁ°KÇ {Â9KÇÁú¸CÖÉBBÏßÂŽVÂ|îÂRòÂXY¯¦Ã̋ÚáÂέ‘Ã/E`ÃGAHÃ7\Ã&I7Ã}/à »¦Âÿ$ÝÂëyXÂÚbÂÊ–¼Â°[¦Áë(öÁêjÁççmÁã=qÁÜVÁÒ ÁÄÔþÁ´n˜Á ùÛÁ‹(öÁi Á@=qÁ'®Á3hsÁ€oÁÓ¡ËÂ%¦éÂ^XÂO’oB)¡ËÀë…Âe~úÂiŽVÂW-Ât¶F‰ãט\£)üªØ°"N´~w¹¾bÂØÂÉ/žÂÎ?}ÂÒ;ÂÔ9ÛÂÔ-ÂÑäZÂÍ”þÂÇ©yÂÀŸ¾Â¸î°ô¼Â¨ùÛ¡,™§ðÂ’|î¶F $Ý { ÔþÂm‘Âó¶Â‰7ÂgmÂèsÂP DÂ'H´Â3A‰ÂCµ?ÂXœ¬Âp±'„À™W <îÂ¥[#©‘ì­›¦Â±È1¶øÂº@½ëÂÀ¨ö ÂÂÂÀIºÂ½߸峦­¦…¢ÂŸå`™I7Â’ÎÙÂŒ‰7Â]/ÂËÇ ¬Â NÙ e`Âm‘Â|î´9ÂLÍÂ’oÂò°Â#÷ÏÂ,F¨Â7{çÂEî˜ÂWdZÂjÒòÂ~Š=ˆ\¬Â Í–,‹Â›%Ÿo¢È1¦^5©Ù­þ¯ÖÂ±× Â²Ü)²»d±ff®éü«k§)¢49œæf—`Å‘ŢŒ1'†·LÂÐåÂZÂÑì :^ ˜“ÂùÛÂt¼Â)üÂH´Âo Þ5Â'bÂ/Â9E¢ÂE¿}ÂT7LÂcçmÂs°!Â6F‡¨sÂ\‘‹Ç•\¬Â˜Ç®Â›ïžٚ¡s¶Â£˜“Â¥²Â¥Û¦Â¥·Ï¤¦é¢°!Ÿéyœt¼Â˜vÉ”Ât¼Âа!Â…àų3ÂIºÂ Û# p¤ÂÂàBÂí‘ÂdZÂzáÂ"p¤Â(ŒJÂ0bÂ9,ÂCÝ/ÂOàBÂ\¦éÂit¼Âub€;d„øR‰ ÇŒ屪’}•—'ð˜áËšòš¢Nš~w™Ÿ;˜ 7•ÊÁÂ’ùX¯ÂŒ 7ˆ Å„VÂÊÁÂwm‘Â/ÂÚ†% 5? ñªÂÇ®ÂǮ Jµ?Âë…Â"Ü)Â(¶FÂ/¢ÑÂ7µ?Â@áHÂJí‘ÂUwÏÂ`ÂjšÂs_;Â{¨öÂ{d„­‘‡‚ŠÂŒ/ÂŽÂq'ÂgmÂ×µ?ÂûçÂŽ®ŒՊ€ƒÂ‡Ã„°¤Â^5Â{¾wÂt‡+Âm33Â!ËÂÓøÂŒJ NÙ $ÝÂÂ7L˜“ÂTþ‰7Â"W Â'Û#Â.,Â5OßÂ=8RÂE¶FÂNˆ1ÂWYÂ_ÙÂgÈ´ÂoÂu€Â{wÂiô¼Âc…ÁhÌÍÁbƒÁ[PÁTÁK÷ÏÁC•Á; Á2záÁ*MÓÁ"¼jÁ-ÁùÛÁÁ ÅÁ33ÁõÃÁ™šÁ'?}Á3ß;ÁC`BÁU‰7ÁjbÁ€?}ÁŒKÇÁ˜éyÁ¥Û#Á²å`Á¿ÌÍÁÌZÁØZÁ㟾ÁîÁ÷\)Áÿ›¦ÂW ÂE¢Â›¦Â [# ŒJ 7L gmÁlffÁe|îÁ]ƨÁUXÁLE¢ÁB¸RÁ8Ý/Á.õÃÁ%SøÁIºÁIºÁ ¶FÁ =Á´9ÁoÁ ƒÁ;dÁ\)Á(å`Á9¾wÁM¥ãÁdA‰Á}‡Á‹ë…Á™÷ÏÁ¨ffÁ¶õÃÁÅ`BÁÓhsÁàÌÍÁíXÁøÛ#—  ïžÂ oƒÂH´Âm‘ÂúáÂÁp¬Ái"ÑÁ`¬ÁWOßÁM+ÁBbNÁ7&éÁ+ÂÁ ‡+ÁÛ#Á 9XÁ¬Àü“Àõ‡Àô1'Àú$ÝÁÂÁVÁÌÍÁ/%ÁDÀƒÁ]²Áy Á‹SøÁšïžÁ«%Á»IºÁËjÁÛ¬Áê‡Áø‡Âp¤Â$Ý ‡Â/Â?cTÂ?l‹Â>uÃÂ<©üÁ‰vÉÁ„ƒÁ}OßÁo¶FÁ`A‰ÁOVÁˆ1ÂDXÂHTþÂJ£×ÂKqªÂJô¼ÂI`BÂFéyÁŽhsÁ‰\)ÁƒOßÁxn˜Áh¬ÁUÊÁÁA²Á+ó¶ÁKÇÀü£×ÀϾwÀ¥ë…ÀhsÀI7LÀ#t¼À`BÀ!º^ÀIÛ#À†áHÀ¶n˜Àó+Á~úÁIÛ#Á|Áš5?Á¹‡ÁÙéyÁû¥ãŠ=ÂuÃÂ-Â9¹XÂDJÁÂL“uÂR–‡ÂVuÃÂXcTÂX ÅÂWp¤ÂUÂQÎÙÁ“ãTÁŽÐåÁˆ¥ãÁOßÁq²Á^IºÁHÔþÁ1™šÁ‡Á1ÀθRÀ A‰ÀnE¢À+çm¿üIº¿Òn˜¿ß\)ÀÐåÀRn˜À–éyÀÒvÉÁIºÁ;VÁp~úÁ—5?Á¹ùÛÁß›¦ÂYÂÇ®Â)8RÂ9âNÂH2-ÂSÍÓÂ\˜“Âb§ðÂf33Âg‡+ÂfúáÂdãTÂa’oÂ]QìÁ™ãTÁ”Ý/ÁŽ¥ãÁ‡-Á|È´Áh£×ÁR{Á9p¤ÁC–ÁVÀÓ;dÀ “uÀfÈ´À›¦¿Ï|Q쿘“u¿Ñ&éÀ bNÀráHÀ°£×À÷× Á(í‘Áa/Á’‘hÁ¹ýôÁ囦 ¹X ‹DÂ6 7ÂI+ÂY6FÂeÐåÂnïžÂtÈ´Âw¶FÂx$ÝÂv‡+ÂsG®ÂnÊÁÂibNÁ \)Á›vÉÁ•MÓÁÄœÁ„ÎÙÁtÝ/Á]dZÁC•Á(Á t¼ÀÞ¬À¨(öÀo¾wÀ A‰¿Í‘h¿p¤¿‚°!¿«dZÀ©üÀDjÀ“uÀÐ1'Ál‹ÁM¥ãÁŒ¬Á¹7LÁìl‹Ân˜Â,ÂE²-Â[ ÅÂmr°ÂzÜ)Âýô„œ)Â…\Â…"уŸ¾ÂG®Â|¦éÂuå`Á§C–Á¢“uÁœ‹DÁ• JÁŒ%Áp¤ÁjÄœÁP1Á3SøÁ‘hÀïß;À·ß;À†5?À;÷ÏÀáH¿Æ§ð¿¸r°¿ÒñªÀffÀ1‰7ÀpÔþÀ©ÊÁÀ÷²Á6Ÿ¾Á„=qÁ¸ffÁõ^5Ân˜Â;ÒòÂYffÂr]/‚æé‰ËÇÂŽu“ÂA‰ÂŽò°ÂŒ‡®Â‰LÍÂ…‚ Â[¦Á®Áª Á¤KÇÁœñªÁ“ó¶Á‰IºÁz JÁ^°!ÁA/Á"—ÁMÓÀÐ ÅÀŸl‹ÀsƨÀCC–À-`BÀ,ÌÍÀ7ïžÀE/ÀQ7LÀe‘hÀÒòÀË•Ál‹Áyt¼Á¹Ôþ¹XÂ)PÂPzáÂs%‡xR‘¶F˜aË›ïœïžÂ›ñªÂ™uÕæé‘›¦ÂŒÙ‡Ô{ÁµýôÁ±ó¶Á¬t¼Á¥VÁœ|îÁ‘ß;Á…‡+ÁoSøÁQXÁ2IºÁãTÀðzáÀÃSøÀ¤r°À–À–°!À ´9ÀªéyÀ¬IºÀ¡/ÀA‰ÀŒ´9À³ =Á^5ÁtVÁÂÎÙÂgmÂ?$ÝÂmв°Â™¿}£ܬ©–‡Â«½q«'ð¨å¤\Ÿœ)šò”7ÏÂŽ>wÁ½²Áº Á´å`Á® Á¥Á› =Á޼jÁ€ÔþÁcp¤ÁDA‰Á& ÅÁ ¶FÀð“ÀÛÎÙÀÝ`BÀò=qÁVÁÀƒÁ´9Á ZÀçSøÀÀ¬ÀË"ÑÁ•Á……ÁÝE¢Â&²Âaµ?ÂŒV‡Â¢=ô±Xº¦Â½¿}½’oº°¤ÂµøÕ°ò©xÕ¢„œÂ›uÔwLÁÅA‰Á ÅÁ½xÕÁ·“Á®ÙÁ¤£×Á˜ƒÁŠ©üÁw¸ÁWûçÁ:QìÁ!p¤ÁSøÁ ë…ÁxÕÁ2záÁR¬Ám&éÁw¶FÁj\ÁIG®Á&“ÁñªÁS\)Á¬9X àBÂP‡+ÂŒp¤Â«ô¼ÂÂŒJÂϧmÂÕÙÂÕÂÑMÓÂËKDÂÃãT»¹X³<ۢaËšTþÁÌÈ´ÁÊ/ÁÆ JÁÀ(öÁ¸ZÁ®…Á¢¬Á• Á† ÁmVÁOãTÁ8vÉÁ+ë…Á/ƨÁGïžÁsp¤Á”ùÛÁ®G®Á½$ÝÁ»\)Á©¶FÁ“¡ËÁ¬Á«{Áû—Â@!ËŠŸ¾Â¶cTÂÙVÂíñªÂõ©yÂôÖ‡Âï ÇÂæ€ÂÜ‚ÂÑâNÂÇ"Ѽ–‡Â²n¨Æ%Ÿ¬ÁÔ{ÁÒ =ÁÎvÉÁÉ$ÝÁÁÝ/Á¸…Á­‡ÁŸÀƒÁûçÁ¬Áf§ðÁPjÁG ÁQ× Áw7LÁ›ó¶ÁÅffÁÂ÷Ï ÑìÂ{çÁò‰7ÁîX G®Â;^5†NV»5ÃÂðèöà nVÃÅÚ^à UÃÃ|¬ÂüLÍÂíšÂß[¦ÂÑÔ{ÂÅ#×¹Tþ®ff¤NÙÁÛÁÙ‰7ÁÖ‘hÁÑÛ#ÁË33ÁÂr°Á·•ÁªÀƒÁœhsÁt¼Á~å`Ái× ÁcoÁt“Á“bÁ¾G®Á÷‡ÂñªÂ/iyÂ8-Â7.Â1ÍÓÂ3ÚÂLÊÁƒu?³„œÂôPbéºÃ0Z^Ã3¨Ã*ѪÃ-‘Ã}/äZÂýzáÂë|jÂÛ/ÂÌp!¿³–¨ ÍÁáÁàŸ¾ÁÞIºÁÚ?}ÁÔKÇÁÌG®ÁÂ&éÁ¶ JÁ¨hsÁš¸ÁŒÊÁÁƒ{ÁbÁŒSøÁª× Áß²-Â&éÂ8XÂV@ƒÂeçmÂjƒÂj±'Âr× Âˆñ'©>úÂÞÃÍÃ;†%ÃRþúÃR¤ÝÃCÈ´Ã1K…à ^¸Ãå`Ã|¬Âõs¶Ââ£×ÂÒÂÃuöoªŢÁçxÕÁç/Áå~úÁâ-ÁÝÁÕÙÁÌ£×ÁÁ…Á´ë…Á§ÀƒÁ›Ÿ¾Á“IºÁ“1Á çmÁã×Áÿ ÅÂ'cTÂQ°!Âu\Â…®ŠÒòÂê•7ϦþwÂÈÂüVÃ"GðÃKF¨Ãg·ÃiݲÃW´{Ã?Ò-Ã*Påûçà EÂü>wÂç‰7ÂÕ®˜ÂÆ!˸vF¬XÁìÛ#Áí&éÁì ÅÁé\Áå?}ÁßVÁÖñªÁÍoÁÁß;Á¶G®Á«õÃÁ¥¶FÁ§Ý/Á¸xÕÁÞ1'ÂcTÂ7ÒòÂd‡Â…"NÂ’r-šs¶Â Æ¨Âªºá½_¾ÂÜ‚ ÀÅÃ$ø“ÃIÚÃi:Ãpó3Ã`MÃFФÃ/$ZÃðåà c–Âÿ =Âé`ÅÂÖå`ÂÆî¸ýq¬²-Áñ²ÁòxÕÁò¬ÁðSøÁìïžÁçÎÙÁàó¶Á؇+ÁÏ1ÁÅjÁ½hsÁ¹ÌÍÁ¾Ý/ÁÒSøÁú+«ÂE¦éÂqƒÂŒ9ÛšÜ)Â¥\­Õ¹VÂËwÏÂçÃãTà FÃ=¡ÃYwÃdFÃXÃ×ÃBæ¨Ã-²Ã¬Jà lJÂýiüÂçô9ÂÕ¢NÂÅÏ\·ÿ}«ÓuÁõ¼jÁ÷$ÝÁ÷p¤Áör°Áô Áð%Áê‡+Áã¸RÁܬÁÔ¶FÁÏ=qÁÎvÉÁÖvÉÁì~ú ÚÂ*¸ÂQÒòÂ|2-‘9Û JÁ«¬‹ÂµÀÂÁ¡ËÂÒ9XÂér-ÃwÃôÃ,SuÃ?ŠÁÃHÖÉÃC½²Ã5^¸Ã$³øÃ!HÃÂ÷‘hÂãlÂÒÂÂ޸µ‘ì©ËÇÁù5?Áû$ÝÁü‡Áûå`Áún˜Á÷¡ËÁó\Áîr°Áè× Áã¸RÁàÆ¨Á⟾Áí{Âp¤Â?}Â5È´Â[õÂDœÂ”²°Â£ˆ1¯$ݹožÂĽqÂÓ1ªÂæåÂý´9à ¢ Ã\Ã'mPÃ-èsÃ,>5Ã$×Ïà žwÃUÂîSøÂÜMÓÂÌfé¾Y±ß;¦¼jÁüoÁþ 7ÂTþ‡Áþ“uÁûõÃÁø“uÁô÷ÏÁò“Áñ‡+Áõ®ÂùÛ F¨Â!³3Â>ò°Âc#ׄÈ1–Tþ¤ž5¯äݹ°!ÂÃÔþÂÏó3ÂÞß¾Âð£×Ã)7à ì‹Ãò°ÃS¶ÃêÁÃ%¢Ã bÃƨÂóÀƒÂâÝ/ÂÓV‡ÂÅD¸“øÂ­$Z¢ÐbÁþSøÂ²Â´9ÂaH²ÂhsÂÑìÂûçÂ)üÁÿ¡ËÂ¥ã»d ŒJÂçmÂ*t¼ÂEɺÂgF¨Â…r-•æf£u?®!H·¦Â¿åãÂÉÍPÂÕgmÂ➸Âð§ðÂþ¨ÃYÛÃOžÃE`ÃUÂþoÂñ°!ÂãùÛÂÖSuÂÉLJ½#ױ푧¤Zž8Õ ® PÂÂɺÂ'ðÂC–Â@ƒÂbNÂoÂô¼Â ÷ÏÂ[#™šÂ2ÂJýôÂi(ö„¢N“©y :^ª5²5?¹»çÂÁÖÂʽqÂÔ‘ìÂÞ¥ãÂçó3Âï5ÃÂó=ôÂóOßÂïp!ÂèQìÂ߃ÂÔ€ÂÉ›#¾×´‰ÂªÀƒÂ¡¢Ñ™(ö–‡ÂuÓÂyÛ›¦ÂƒÂE¢Â 7 P ´9ÂŽVÂgmÂE¢Â'NÙÂ8uÃÂNå`Âip¤Â‚ƨ D›På¤H1«‰7²¨Â¸š Â¿ž5ÂljÂÎW ÂÔîÂÙùÛÂÜ¿}ÂÜÌJÂÚÂÔ÷ÏÂÎ =ÂÅô¼Â½H´Â´s¶Â«À£Z›[#“ÎVÂéyÂöÉÂ× Âˆ1Â\ t¼Â ÎÙ E¢Â{“uÂBÂɺÂ!øÕÂ-¤ÝÂ=l‹ÂQC–Âh(ö€ì‹n•>wÂ7Ï£º^©l®ð!´‹Dº6F¿¨öÂÄožÂÈœÂÉô9ÂÉò°ÂÇô9ÂÄ'ð¾çm¸/±¯ªr-£%`›õÔþúÂŽQìÂÂ6FÂLÍÂDœÂ #× ÷ÏÂ × ÂçmÂ_;Â\ÂâNÂß;Â' ÅÂ2;dÂ@ƒÂQËÇÂe9XÂyPå†2°ÂŽ–‡Â•™›ožÂ ‚ Â¥@ƒÂ©Ü)®U²}q¶ Á¸¦éº¨Â¹ùX¸s3µŒÍ±|+¦ó3 ÿ}šàÅ”½ôÂŽ³3ˆÒòÂàBÂ7LÂzᯠڠDÂXÂäZÂâN”{ÂRòÂ"†%Â*›¦Â4î˜ÂA¥ãÂP…Â`× Âqˆ1€¸Õ‡ٚÂùÛ“2-—¾ú›æéŸÊÁ£m¦²-©iü«^5¬^¸Â¬IºÂ«¨ÑhÂ¥/¡¥ãÂ/˜1ªÂ“ JÂÎÙˆ’oƒiyŠ=ÂûçÂe`Âɺ 33 ®ÂPåÂ;d—Ÿ¾Â”{Â$ÄœÂ,yÛÂ5èsÂAÂMɺÂ[s¶ÂiRòÂvœ¬Â]²Â†´9‹[#Âo“¬Â–uÙ}qœ"ÑžH1ŸÊ= Š= q'ŸxÕ¨ö›‡Â—ß;”%ã P‹µ?‡8Õ‚®Â|Oß ‰7Â\™šÂ 1' ãTÂÄœÂïžÂ‰7¼j¼jÂ%¿}Â,ó¶Â5t¼Â?:^ÂJVÂU†%Âa¦ÂlF¨Âv²Âê„þ‡¹ÛŠýqÂèsÂ|jÂ’®˜Â”l•ž¸Â–2°Â–•MP“Óu‘º^‹þwˆŽV„ݲÂÂz"ÑÂr1'Áþ™šÂáHÂ{çÂ!Ë Ú ³3¼jÂ\ÂƨÂÂïžÂ%¨öÂ,NÙÂ3ì‹ÂNÙÂAð¤ÂDÂDäZÂDˆ1ÂC-ÂAÁó¶Á‰—Á„hsÁ|È´Áo Á_ë…ÁOl‹Á=÷ÏÁ+ûçÁbÁéyÀò°!ÀØzáÀÄõÃÀ¹º^À¸9XÀÁxÕÀÖÀö-ÁýôÁ,ÀƒÁNjÁu× Á‘Ÿ¾Á«ÁÆ£×ÁãÐåÂÎÙ‚ ÂwÏÂ*7LÂ5^5Â>«ÂF ÂKbNÂNäZÂP³3ÂQ ÂP 7ÂMþúÂK Á’ó¶ÁŽ‘hÁ‰G®ÁƒoÁwçmÁgó¶ÁVzáÁC× Á0~úÁoÁ ^5Àòn˜ÀÕ&éÀ¾È´À±‡À­hsÀ´ÔþÀÇÎÙÀæ°!ÁÌÍÁ$ƒÁFÙÁp{ÁbNÁ¬C–ÁË7LÁì\)Â>w Â( JÂ6r°ÂB× ÂLñªÂT§ðÂZ1Â]=qÂ^…Â^#×Â\`BÂY€ÂUÀƒÁ˜ffÁ” JÁŽº^ÁˆhsÁ{Áq‘hÁ_G®ÁK™šÁ7oÁ"^5ÁIºÀ÷²À×ÎÙÀ¿+À¯t¼À©ûçÀ¯PÀÀ‹DÀÝVÁÄœÁt¼Á?PÁiçmÁŽß;Á­ÁÐ\)ÁöMÓÂÚÂ"PåÂ4–‡ÂDÙÂR‹DÂ]_;ÂeJÁÂjr°Âm¦Âm›¦ÂlMÓÂiŠ=Âe¢ÑÂ`àBÁžC–ÁšÁ”¼jÁŽ^5Á†éyÁ|ÌÍÁiÛ#ÁU`BÁ?ãTÁ*$ÝÁ%Á•ÀáÊÁÀÇïžÀ·KÇÀ°õÃÀµG®ÀÄ(öÀÝ`BÁÄœÁ;dÁ9ÊÁÁdZÁ…Á¯33ÁÖ²-ÂBÂ1'Â.ÊÁÂCÂÂV PÂeÂpbNÂx:^Â|ÒòÂ~˜“Â}þúÂ{yÛÂwwÏÂrTþÂldZÁ¤|îÁ jÁ›?}Á”í‘Án˜Á„ÊÁÁv5?Áa"ÑÁJõÃÁ4ƒÁÄœÁ éyÀô9XÀÚÙÀË;dÀÅë…ÀÊ~úÀ×ïžÀíXÁ²-Á~úÁ7÷ÏÁa|îÁQìÁ²p¤ÁßP NÙÂ$2-Â>ˆ1ÂV‹DÂjêÂzñªÂƒ<î†ãTˆ«ˆáH‡ÓuÂ…ÊÁƒ%ÂvÉÂx-Á«%Á§/Á¢5?ÁœÁ”“uÁ‹çmÁ‚¬ÁnÔþÁXA‰ÁAt¼Á+‘hÁë…ÁçmÀù?}ÀíxÕÀìIºÀôÁ Á ¬Á|îÁ%SøÁ>{ÁeC–ÁKÇÁ¹hsÁíff¶FÂ4ffÂShÂnSøÂ‚J=Š•Â“5” Ç“JÁ‘>úÂŽ>wŠb†n˜Â‚®Á±Æ¨Á®?}Á©‡+Á£PÁœA‰Á“§ðÁ‰áHÁ~E¢Ág™šÁPÌÍÁ;;dÁ(ƒÁ=qÁ¾wÁ²ÁC–ÁõÃÁ$5?Á,ñªÁ4ùÛÁ?;dÁR$ÝÁv-Á™ïžÁÇó¶Â>wÂ%ÂÂK'ðÂnž¸Â†~wÂ’:^šO\Ÿ®Â ê ŒJžyX›(s–ú^Â’;çÂ'ð‡ë…Á¸©üÁµ~úÁ±¬Á«l‹Á¤\)Á›ñªÁ’IºÁ‡²Áx¼jÁbA‰ÁMp¤Á<5?Á0Ÿ¾Á,QìÁ/ó¶Á:~úÁI‡ÁW²-Áb¼jÁi?}ÁnÔþÁ|5?Á޼jÁ¯vÉÁãÎÙ„Â?·LÂk¯Š1še`¦ ºÂ­{°6F°H´Â®ªH´Â¥ffŸÔþ™áH“Ö£TÁ¿—Á¼ÔþÁ¸ÙÁ³…Á¬È´Á¤¥ãÁ›7LÁ¾wÁ…°!Áut¼Áa©üÁRZÁJ ÅÁK/ÁV~úÁj¸RÁë…ÁýôÁ–ÎÙÁ›=qÁ;dÁ¢hsÁ²áHÁ×  Þ5Â4¬ÂfKÇÂŒÌJ£C³þú¾[¦ÂÃ"NÂß;ÂÁ Ó¼l¶wϯº^¨–¡Oßš‡Â“ ÁÁÆr°ÁÄ$ÝÁÀ›¦Á»¸RÁµdZÁ­Ÿ¾Á¤‡+Áš^5ÁŸ¾Á…VÁw‰7ÁjZÁeÒòÁlùÛÁ€´9ÁãTÁ¤‰7Á·¼jÁÆ‹DÁÎïžÁÒ¾wÁØÊÁÁë^5 bÂ.MÓÂ`†%ÂŽ Ó«ŢÂÄ!ËÂÓ÷LÂÛ[¦ÂÜH1ÂØáHÂÒÊÁÂË"N¤Z¹Ï\°õèKDŸñ'—ú^ÁÍ"ÑÁËQìÁÈG®ÁÃå`Á¾VÁ¶ÄœÁ®¸Á¤dZÁš{ÁÁ‡hsÁë…Á‹DÁˆKÇÁ—p¤Á®‰7Áʲ-Áç =ÁþdZÂÎÙ !ËÂ{ÂɺÂ4š Â^–‡ÂŒÜ)°ÂÒbÑÂìV‡ÂùÊÁÂüB Â÷Ÿ¾Âï¸ÂäºáÂÙ’oÂÎG®ÂÃ9X¸ž5®åÂ¥¸ÂœI7ÁÓ‰7ÁÒ;dÁϺ^ÁËå`ÁÆ¡ËÁ¿éyÁ·× Á®®Á¤õÃÁ›‰7Á“º^ÁdZÁáHÁš¶FÁ®¾wÁÌéyÁò{ 7LÂÊÁÂ(º^Â0¯Â8éyÂH'ðÂen˜ÂŠ»d¬€ÂÕ ÓÂübà ôÃ7ÏÃMÓà š Ãe¢Âõ¨sÂæÏ\ÂØ­ÂËqªÂ¿*³Ôþ©eãŸÌÍÁÙ›¦ÁØ× ÁÖéyÁÓ°!ÁÏbÁÉ1ÁÁ©üÁ¹?}Á°OßÁ§¾wÁ ñªÁçmÁ¡C–Á®ÁÆÁë Â G®Â$¸Â9aHÂIƨÂUùÛÂbTþÂu›¦Â‹p¤Â¥— ÂÊ DÂöPbÃãÃöÃ$ÃCTÃ1ìà Ã}ÂñèsÂá-ÂÒ‰ÂÄH1·Þ5¬Ÿ;¢höÁßC–Áß =ÁÝ´9ÁÛ ÅÁ×;dÁÑùÛÁËvÉÁÃùÛÁ¼ JÁ´›¦Á¯{Á­•Á²éyÁÂMÓÁÞ…ÂbÂïžÂ9]/ÂRjÂfÖÂw²ÂƒÏ\Â=ô¡5»ÎÙÂàA‰ÃEáHÃ,«…Ã1;dÃ+(öã–ÃÃ^úÂù±ªÂæûçÂÖ_¾ÂÇšºl®²Â£üîÁär°ÁäÂÁä =Áâ(öÁß1ÁÚ§ðÁÕ ÅÁξwÁÈVÁ Á¾oÁ¾dZÁÅÐåÁ×£×Áö§ðÂÂÂ-ÂK¸ÂfÅ¢Â~0!‰ Â’ó3Ÿå±¥ãÂË,‹Âìïà »¦Ã/Ã/ѪÃ5¢Ã/ý/Ã#ÕÃZáà ÉyÂý3¶Âé€ƒÂØ,ÂÈâÑ»X¯H1¤z^Áé¸Áé÷ÏÁéÝ/Áè²-ÁæffÁâùÛÁÞ‹DÁÙhsÁÔ$ÝÁϸRÁÍ™šÁÏí‘ÁÙÁí|îÂ?}ÂÂ:ûçÂY€Âv~ú‡í‘“¢Âž%«\¼^¸ÂÓt9ÂðÑhà ¢ÑÃlÃ)ÛçÃ0Ã, DÃ!„ÝîÃð!Âûð!Âès3Â×>úÂÈ Íº–‡Â®™£ݲÁí?}Áî²Áï"ÑÁî´9ÁíC–ÁêÙÁç—ÁãÎÙÁà“ÁÝhsÁÝ5?Áá‘hÁí(öÂs¶ÂŽVÂ* 7ÂFuÃÂdçmÂþÂŽ$Ý™Æ%Â¥"ѱ޸ÂÁ±ªÂÕ©üÂíýqÃËÇû¦Ã¤Ã#oßÃ!Z Ã²oÃ\à yÂö&éÂãÿ}ÂÓ·ÏÂÅ1'¸:ᬡH¢4¼ÁðÒòÁò¶FÁó× Áô"ÑÁó‘hÁò1'Áð$ÝÁíÆ¨Áë§ðÁê¼jÁìjÁò§ðÁÿë… m‘½qÂ3÷ÏÂOÄœÂm|îÂ…Â’ Ç¢N¨¾ú´ BÂÂåÂÓCÂæ¸ÕÂûò°ÃTþß;Ã×Ã`Ãô{ÃeÂýɺÂìÌJÂܾúÂÍûçÂÀ”{´vF©ƒŸ™šÁóÛ#Áö9XÁ÷ñªÁø÷ÏÁùE¢ÁøïžÁø¬Á÷&éÁö²Á÷jÁúÙÂ[#²Â_;Â%|îÂ< ÂV²-Âs(ö‡]/“מøÕ©iü´/ÂÀ ÍÂÍ®ÂÜæfÂìß;Âûñ'ÃæfÃÃØ“ÃŽÂü8ÕÂïbÂá/žÂÓ‰ºÂÆ›#º˜“¯PÂ¥p¤Âœ0¤ÁöZÁù-ÁûvÉÁý/ÁþXÁÿÁÿdZÁÿÎÙÂgm² Å¿}ÂqªÂ7LÂ,ÊÁÂB-Â[DœÂuùÛ‡ó¶Â“µÃž B§­±‡Â»;ÂÆÂÑÛ¦ÂÝÈ´Âè·LÂñ.˜ÂõÎVÂõÔþÂñr-ÂéŸ;Âß/ÂÔŒJÂÉw£× ¨ö l‹Â€Â1Â33Â6FÂ"H´Â)š Â2LÍÂwÂ)}ôÂ*ÌÍÂ+A‰Â*ò°Â)ùÛÁ…× Á‚OßÁ|ƒÁs\)ÁiC–Á^ZÁRÙÁG%Á;;dÁ/ïžÁ%²ÁÐåÁ¬ÁbÁ;dÁ1ÁÐåÁ%ÒòÁ5"ÑÁHÀƒÁ`›¦Á|~úÁŽ ÁŸÁ²jÁÆbNÁÚ÷ÏÁï¬ÂùÛ ¢Ñ‘h‘hÂ#yÛÂ)49Â-¶FÂ1Â3+Â4C–Â4hsÂ3¸RÂ2QìÁ‰Ÿ¾Á…ýôÁÄœÁyçmÁo+Ác|îÁWoÁJ5?Á=G®Á0ÀƒÁ%/Á+ÁSøÁIºÁ Ÿ¾ÁÔþÁOßÁ E¢Á/çmÁD5?Á]/Áz¸RÁŽA‰Á¡?}Á¶ ÁÌ"ÑÁã ÅÁú\)Â’oÂffÂ[#Â&0!Â-µ?Â3ÒòÂ8Â;È´Â=Á‰Â>‰7Â>DœÂ=šÂ;-ÁÒòÁЏÁ…ÄœÁ€ÀƒÁv=qÁiß;Á\Ÿ¾ÁNÈ´Á@È´Á3 Á&ZÁ+Á9XÁ 9XÁ ¾wÁ XÁhsÁ5?Á+çmÁ@Ÿ¾ÁZr°Áyp¤Á޶FÁ£?}Áº%ÁÒ›¦Áì^5ÂDœÂ¬ÂH´Â'dZÂ1¸Â9DœÂ?º^ÂD€ÂG¦éÂIPåÂI¨öÂHÛ#ÂG‡ÂDˆ1Á’l‹ÁŽ´9ÁŠE¢Á…¬Á~‡+Áq•Ác™šÁTéyÁEó¶Á7?}Á)p¤Á7LÁSøÁ záÁ KÇÁ QìÁïžÁjÁ)ó¶Á>¸RÁY Áy Á\Á¥®Á¾¬ÁÚ =Á÷ = SøÂß;Â&”{Â2öÉÂ=£×ÂFcTÂM¬ÂQÙÂT¸RÂUë…ÂU§ðÂT+ÂQ©üÂN\)Á—hsÁ“º^ÁE¢ÁŠ1Á„1Áz¬Ál“Á\´9ÁLñªÁ=dZÁ.¼jÁ!¶FÁ¸Á²-Á bÁ ´9ÁûçÁbÁ+/Á?²ÁYÛ#Áz—Á‘+Á¨çmÁÄVÁâïžÂß;µ?Â#;dÂ2°!Â@s¶ÂL‡ÂUYÂ\0!Â`²-Âc{Âc™šÂbŠ=Â`.Â\ɺÂX˜“ÁœÂÁ™+Á”ÀƒÁ~úÁ‰jÁ‚“uÁv(öÁf=qÁUãTÁEº^Á6~úÁ)%Á ÅÁ\Áí‘Á¡ËÁÙÁ"§ðÁ1/ÁDÙÁ^záÁG®Á”33Á­‘hÁ˸RÁîo ±'Âî˜Â/¾wÂA%ãÂP]/Â\áHÂfzáÂm/Âq0!ÂrÍÓÂraHÂpG®ÂlØÂhcTÂc+Á¢n˜ÁžûçÁš®Á•xÕÁdZÁˆ|îÁ€áHÁq…Á`ÐåÁPQìÁ@å`Á3hsÁ(ÀƒÁ!º^ÁÔþÁ MÓÁ&{Á/ûçÁ=ûçÁP—ÁiVÁ„©üÁ™º^Á´Æ¨ÁÖ Áüȴ¸RÂ)Ç®Â?33ÂR³3ÂcRòÂp…Âz"Ñ€)ü¸RÂõ?Â)Â~ÌÍÂzbÂtZÂmöÉÁ¨^5Á¥"ÑÁ¡Á›ë…Á•éyÁ1Á‡hsÁ~~úÁm²-Á]33ÁM÷ÏÁ@ýôÁ7G®Á1¡ËÁ0~úÁ3ÒòÁ;33ÁFÁSó¶Áe‰7Á|‡+Áë…Á£^5ÁÀA‰Áå{ÂPÂ! JÂ:`BÂR­ÂhKÇÂzšÂƒÇ®ÂˆV‡ÂŠçm‹Á‹1'‰ƒ–†üîƒØ€DœÂxÔþÁ®Á«‹DÁ§£×Á¢ÂÁœéyÁ–&éÁŽ›¦Á†ƒÁ|ffÁl=qÁ]²ÁQ¶FÁI²-ÁFn˜ÁHIºÁNñªÁYp¤Áf‹DÁu|îÁƒ\)ÁŽ?}Át¼Á³hsÁÒ|îÁû¡ËÂõÃÂ3.ÂP5?ÂkŠ=Š=Šƨ‘G®Â•2-–ۦ–«…•´Â’O\ÂŽÍPŠ †_;ÂÍPÁ´Æ¨Á²¸Á®…Á©éyÁ¤MÓÁ¾wÁ–bNÁŽxÕÁ†`BÁ}7LÁo•ÁeG®Á_®Á_ÒòÁfbÁqÂÁ€©üÁ‰bNÁ’KÇÁ›|îÁ¦XÁµ“uÁ̇+Áî…ÂzáÂ+_;ÂKéyÂlþúÂ…¦éÂ’¦Â›8R ô¼Â£±ªÂ£ùÛ¢\¬ÂŸY›YšÂ–±ªÂ‘¢NÂŒ]/‡¨Á»“Á¸ÌÍÁµPÁ±G®Á«ûçÁ¥¸RÁž£×Á—Á?}Á‡í‘ÁÄœÁ{?}Áx°!Á}+Á„\ÁÐåÁ™C–Á¥hsÁ± JÁ¼oÁÈ%ÁØMÓÁñA‰Â ›¦Â&šÂGgmÂl× Â‰¸Â™˜“¦E®”{²Ñh³µÃ²b®š©çð¤kžxÕ˜NÙÂ’šÂ‹÷ÏÁÁ`BÁ¿záÁ¼¡ËÁ¸ÂÁ³Û#Á­ùÛÁ§G®Á  =Á˜¸RÁ‘ó¶ÁŒ“uÁ‰—ÁŠ JÁŽÊÁÁ˜$ÝÁ¥²ÁµÌÍÁƲ-ÁÖ—ÁåÁó²Â49Â[#Â&öÉÂESøÂk£×‹=q ,±¶F½ùXÂÄ¢NÂÆ…ÂÄ× ÂÀ¶F»´^5­9XÂ¥äZž“u—iyÂ}ôÁlj7ÁÆ{ÁîÁÀC–Á»ÐåÁ¶hsÁ°/Á©r°Á¢®Áœ“uÁ˜‡Á–^5Á˜¬Á “Á­(öÁ¿bNÁÕ ÁëÛ#¬ YÂɺÂ9XÂ/»dÂHuÃÂk%‹JÁ£†¨Âº¶ÉÂÍVÂØH1ÂÜwÏÂÛ3¶ÂÖPåÂÏC–ÂÇ =¾I7µhö¬«¤5ܾ”u?ÁÍvÉÁÌxÕÁÊ\ÁÇ¥ãÁüjÁ¾ß;Á¹9XÁ³“Á­Á§°!Á¤/Á£ÌÍÁ§ýôÁ²¬ÁÂéyÁÚ Áõ\ RòÂ:^Â#Þ5Â0 7Â>ÂQYÂmB‰Ø¡õ?¼½qÂÖÂèýqÂòß;Âô'ðÂïOßÂææéÂܾúÂÑïžÂǼ‰7²vɨô¼Â  Á—·ÏÁÓ&éÁÒ£×ÁÑ=qÁÎå`ÁË“uÁÇXÁÂ`BÁ¼ýôÁ·¶FÁ³SøÁ°ñªÁ±÷ÏÁ¸VÁÄÄœÁÙ“ÁôÀƒÂ å`Â{çÂ-†%Â==qÂL[#Â]wÂºÓøÂ¯ˆ1Â¥A‰Â›åãÁæbÁç‰7ÁèbNÁè‘hÁè¸Áç¬ÁåÄœÁän˜Áã¬ÁäSøÁçPÁîÌÍÁûƨ DÂbNÂ(ÍÓÂ>l‹ÂU¶FÂm{ÂÊ=ÂŒª—Ä£ì‹Â²u¦fÂÕs¶ÂéZ Âü/ÃJÃáÃAËÃ(öÂûïžÂíÇ®Âß_¾Âу–ÂÄÓ¸›¦Â­¬£®˜ÂšŽÙÁé§ðÁ뛦ÁíÁíÝ/Áî/ÁîoÁíÀƒÁí‘hÁî‡Áð¸ÁôÂÁýbNÂÈ´ÂdZÂõÃÂ1_;ÂFÊÁÂ]ÏßÂtïžÂ…œ)ÂQh›%¦X“²þúÂÁ@ÂÐâÑÂàþúÂïçðÂûc×ïÃyXÂúáËÂðöFÂåÂØc×ÂËèsÂÀ´ß;ª‘졘\¬ÁìÂÁï-Áñ ÅÁòŸ¾Áó´9Áô|îÁõ-Áö"ÑÁ÷çmÁû=q•Âzá ÂÖÂ&QìÂ8YÂM#×ÂcffÂy¾w‡/‘ڠ›á˦&f±2-½.ÂÉäZÂÖŸ¾Ââ)üÂëÂïÃÂïÌÍÂëu?ÂãÎÙÂÚ¸ÂÏxRÂIJº¯ì¦qªÂ²Â•nÁïbNÁò9XÁô´9ÁöÒòÁø£×ÁúG®Áûó¶Áþ ÂyÛ¿}ÂG®Â ¤ÝÂuÃÂF¨Â,hsÂ=¸RÂQ‚ Âf™šÂ{»d‡þú‘ßšÀƒÂ£ãT­_¾Â·NÙÂÁƒ–ÂËt¼ÂÔH1ÂÚüjÂÞ­‘ÂÞå`ÂÛÈ1ÂÕô9ÂÎA‰ÂÅ{ç¼E¢Â³ Pª ¡‰ºÂ™wL‘åãÁñƒÁôÂÁ÷º^Áún˜Áüó¶ÁÿffŠ=ÂŽVÂ]/ bN  PÂ#¯Â1=qÂA’oÂT DÂg£×Â{:^†ú^ÂÀ˜ ºÂ å¨$Z°Su¸záÂÀ8ÕÂÆöFÂÌ1ÂÎÙÂÏÂÌÎÙÂÈZ ÂÂF%»"ѳn˜Â«‰7£´9œšÂ”ÒoÂêÁó+ÁöÈ´Áú33Áýr°ÂMÓÂçm Å Å¾ ffÂÏßÂȴ¼jÂ( 7Â4ÙÂDÂTó¶ÂfÐåÂx Å„ÐåÂŒ¼î”!Ë›#סþú¨½ô¯F¨ÂµT{º¾YšÂÀ{çÂÀ°!¾öÉ»…¶´¼Â°êª„œÂ£Ðå D–[#Âܬ‰Ÿ;Áô\)ÁøKÇÁü¸ÁÿÛ#ÂËǺ^ÂÒòÂ:^ "ÑÂɺÂ~úš Â!r°Â+KÇÂ7=qÂE ÂTiyÂdm‘Ât\)ÂÈ1ˆÚÂe`•›W ïžÂ¦6ɪþw¯±ó3³‘ì³·L²`B¯¬‹Â«Ô{§;¡Ðåœ'm–T{Â}qмîÂ…$ZÁõ ÁùSøÁý~úÂÓøÂñªÂ)ü“u På ‹DÂ|îÂbNÂ…Â$#×Â-n˜Â8n˜ÂDõÃÂR›¦Â`ɺÂnÛ#Â|IºÂ„e`Š*Â}ô”}q™,Â|î¡Pb¤wϦÀƒÂ§ýô¨§¤Ü)¡ÃÂèö™€ƒÂ”¸R¹XФÝÂ…’ò€”þÁõjÁùß;ÁþVÂl‹ÂÀƒÂ49Âß; ß;ÂXÂxÕÂs¶Â€Â%ÌÍÂ.wÏÂ8}ôÂC´9ÂOÂÂ\2-ÂhƒÂtJÁÂJÁ„·Ï‰^¸Â­‘‘£×•7ϘT{šÚœ¦éÂ/«œËÇ› ͘†%•Y‘«ž¸Â‰V‡Â„ì€vÉÂxVÁõOßÁùõÃÁþ§ðº^Â8RÂÛ# ·L æf‡+¿}·L–‡Â&}ôÂ.}ôÂ7PÂA„ÂL ÂVô¼Âa¯ÂkùÛÂuž¸Â~‡+ƒV‡oŠu?ÂwL ºÂ’ “‰7”KÇ”Q쓚Â’*ÂÂqªÂŠYšÂ†éüƒ;dÂ~ÊÁÂvõÃÂoÁôÒòÁù²Áþ|îÂÀƒÂ\)Â!Ë ¸Â k… ÅÂ[#Â:^ÂÚÂ&PåÂ-£×Â5Ç®Â>š ÂGàBÂQSøÂZ©üÂc¤ÝÂlÂsèsÂ{ J€Ǯƒ²°Â†B ˆjŠ²Â‹LJ‹ès‹ê‹PbŠ;ˆbц+…ƒŽV€Ÿ;Âzå`Ât7LÂmTþÂfXÁó÷ÏÁøÙÁýÙÂÂ2- J ²Â wÏÂ/Â[#ÂoÂgmÂ%ffÂ,oÂ3]/Â;(öÂCH´ÂK…ÂS¦éÂ[|îÂbâNÂi¿}ÂpÂu¶FÂzÇ®Â.Âm‚ڠƒև„W „V‡ÂƒÓøÂ‚ÓuÂ]/Â~úáÂz†%Âu|îÂoþúÂj)üÂdšÂ]çmÁòƨÁ÷´9Áüƨ¾w¢Ѡº^ ÂÂÂÑìÂTþÂXÂ#áHÂ)ð¤Â0vÉÂ7\)Â>|îÂE¯ÂLÈ´ÂS¡ËÂZ¬Â`%ãÂe§ðÂj¦éÂouÂrãTÂv =ÂxxÕÂz!ËÂzøÕÂzõÃÂzÂxcTÂuçmÂrµ?ÂnâNÂj‰7ÂeÂÂ`§ðÂ[NÙÂUËÇÁo²-ÁkÎÙÁg•Ác Á^n˜ÁY²-ÁU =ÁPŸ¾ÁLŸ¾ÁIC–ÁF¼jÁEKÇÁE"ÑÁFzáÁI…ÁNZÁU"ÑÁ]çmÁh£×ÁuG®ÁÛ#Á‰áHÁ’‘hÁ›Ý/Á¥‘hÁ¯‹DÁ¹²ÁòÁÍ`BÁÖÀƒÁß—ÁçÆ¨Áï1'ÁõÄœÁûr°Â ÂÂvÉÂwÏÂVÂ?}Ás/ÁnéyÁj=qÁe7LÁ_ó¶ÁZ\ÁU33ÁP JÁKKÇÁG33ÁCûçÁAë…ÁA?}ÁB5?ÁE =ÁIãTÁPáHÁZ¬ÁePÁs&éÁbNÁŠ ÅÁ“Ÿ¾ÁÐåÁ¨~úÁ³|îÁ¾™šÁÉ¥ãÁÔl‹ÁÞÂÁèzáÁñr°Áù‰7ÂSøÂ_;ÂâNÂÞ5 Tþ LÍ ÌÍ Þ5Áw+ÁrƒÁm`BÁgÒòÁaó¶Á[ãTÁUƨÁO× ÁJIºÁEdZÁAl‹Á>§ðÁ=hsÁ=ïžÁ@~úÁEKÇÁLzáÁV(öÁbMÓÁpáHÁ€ãTÁŠ^5Á”¼jÁŸçmÁ«£×Á·ÂÁÄ1ÁÐ;dÁÜ&éÁçPÁòA‰Áü‡Âr°ÂKÇ ŒJ 1'ÂwÂÐåÂ$uÃÂ,ë…Â4%Â9±'Â=æfÂ@·LÂB;dÂB•ÂAêÂ@`BÂ>¸Á’33Á¸Á‹záÁ‡IºÁ‚•ÁzáHÁoó¶Ád£×ÁY`BÁN“uÁDÈ´Á<‹DÁ6r°Á3VÁ2ÐåÁ6-Á=l‹ÁHÔþÁX—ÁléyÁƒÁ’1Á£‰7Á·—ÁÍçmÁæ%ÁÿOß t¼ÂõÃÂ$¸RÂ/VÂ8ƒÂ@VÂEå`ÂJ JÂLš ÂMµ?ÂMˆ1ÂLC–ÂJÂG+Á–ÌÍÁ“ÄœÁ¸Á‹áHÁ‡oÁÈ´ÁxA‰Ál~úÁ`¸RÁUl‹ÁK&éÁBƒÁ<¬Á8ƒÁ89XÁ;™šÁBí‘ÁNr°Á^bNÁs Á†`BÁ–Á¨‹DÁ¾(öÁÖ™šÁñ^5ÂÑìÂ/Â#.Â0=qÂ;áHÂE¿}ÂM¥ãÂSˆ1ÂWt¼ÂY”{ÂZ“ÂY:^ÂW6FÂTBÂP’oÁ›¸RÁ˜ÄœÁ•-ÁñªÁŒ Á†¼jÁ€õÃÁuß;ÁiÊÁÁ^1'ÁS®ÁJñªÁD“uÁA+ÁA/ÁDí‘ÁL£×ÁXn˜Áh‹DÁ}dZÁ‹È´Á›ó¶Á¯|îÁÆÂÁá‘hÁÿX‡+­Â/W Â=ÌÍÂJuÃÂTî˜Â]+Âb¿}Âf9XÂg®ÂgdZÂe£×Âb³3Â^ÔþÂZ@ƒÁ ë…Áž¬ÁšŸ¾Á–t¼Á‘§ðÁŒG®Á†vÉÁ€dZÁt—ÁhõÃÁ^‡+ÁV1ÁP$ÝÁMp¤ÁNQìÁS%Á[•Áh JÁx‹DÁ†ÎÙÁ”{Á¤¶FÁ¹C–ÁÒVÁïÐåÂ…Â[#Â,„Â>ÂMèsÂ[„ÂfhsÂnp¤Âs²-ÂviyÂvêÂu\Âr±'Ân¥ãÂi´9Âd¬Á¦\)Á£¼jÁ hsÁœbNÁ—®Á’`BÁŒ²Á†•Á€\Áu¶FÁk¶FÁcçmÁ_%Á]©üÁ`(öÁf“uÁpÈ´Á~\Á‡÷ÏÁ’ÂÁ E¢Á±jÁLJÁâ/Â\)ÂõÃÂ(VÂwƒz^ˆĜŒ ͈1Â~wÂŒ:ኖ‡‡Âƒ¨sÂÇ®ÂwÒòÁ±º^Á¯Ÿ¾Á¬ÊÁÁ©5?Á¤ë…Á  Áš²Á”ýôÁr°ÁŠhsÁ†ZÁƒÎÙÁƒ?}Á…%Á‰?}ÁƨÁ˜7LÁ¢“Á­/Á¹¾wÁȾwÁÛÌÍÁô¬ ŒJ³3Â69XÂO±'Âi“€&é‰Ïß‘ P•É7˜5?˜¨s—‡+•.˜Â‘ñªÂŽþ‰Ï\Â…KD€©üÁ·…Áµ¾wÁ³;dÁ¯ùÛÁ«ýôÁ§bNÁ¢QìÁ1Á—çmÁ“bNÁ =ÁŽzáÁA‰Á’ÊÁÁ™7LÁ¢IºÁ­jÁ¹í‘ÁÇ\)ÁÕçmÁæ¥ãÁû— |îÂ~úÂ4‡ÂNŽVÂkƒŠ=Âՠt9¤2°Â¥X¤hö¡æfžB™Ù”ñªÂ֊vFÂ…(sÁ½MÓÁ»ãTÁ¹¾wÁ¶Û#Á³A‰Á¯1Áª\)Á¥…Á å`ÁÁšÁšoÁœdZÁ¡÷ÏÁª÷ÏÁ·“ÁÅ—ÁÕ…Áæ+Á÷™šÂ‚ ÂY ¬Â4ÎÙÂN¬Âk½qÂ…¸Õ”úá¡ú^«P±Tþ³Ÿ;³{°l¬I7§-‘¡z^›wÏ•X“Â@‰F¨ÁÃÁÁùÛÁÀ=qÁ½Æ¨Áº›¦Á¶× Á²§ðÁ®XÁªVÁ§/Á¥²Á¦l‹ÁªhsÁ²1'Á¾ÁÍ‹DÁßå`ÁóÛ#Â#×ÂLLÍÂ[=qÂj_;Ây9XƒĜŠ¢N‘;d—ªÂäZ£ÌJ©(s­«±‰Â²åã³2-±çð¯.˜Â«G®Â¦~ú¡5›ff•‰7¬‰èö„QìÁî\ÁòzáÁö^5ÁúE¢ÁþKÇÂG®Â ÅÂPå „ k…ÂA‰ÂC–©üÂ(˜“Â3‡Â>ûçÂKöÉÂYŽVÂgC–Ât­€Ö†àBÂŒ«Â’5×vÉœX“ ²-¤MP¦ñ'¨n˜Â¨©y§ ÅÂ¥m¢:ážA™¶F”ÍP²-Š…Â…_;€RoÁït¼Áó¡ËÁ÷ÒòÁü“ÂC–Ÿ¾Â6FÂ$Ý b£×Â\ƒÂ!«Â*¸Â3Þ5Â>ÂÂJ„ÂV½qÂc%Âo Âzu¤Z‡¶ÉÂŒ}Âô¼Â•œÂ˜“øÂ›}q˜“žÆ%žñªÂžœMP™«…–Z Â’„ÂŽO߉áHÂ…T{€ÁÂxožÁïïžÁôSøÁøÆ¨ÁýXÂV™šÂ`B ~ú hÂ=qÂ)üÂüîÂ"ÒòÂ*½qÂ3µ?Â=–‡ÂH$ÝÂS JÂ]öÉÂh˜“Âr½qÂ|JÁ‚— †»dЉ7Âò°ÂäÝ“E”øÕ•èö–1•Tþ“Ù‘©üÂŽâÑ‹¢Ñˆ´Â„1'€3¶ÂxKÇÂp,ÁðÁô“uÁù;dÁþ1ˆ1Â6FÂ!Ë _;Â1Â;d‡¶FÂ#.Â*‡+Â2¸RÂ;Ÿ¾ÂE =ÂN¶FÂX\)ÂaÀƒÂjµ?Âs¸ÂzéyÂV„Rò‡7ω¯‹¥ã =ÂÌJÂâÑÂLJÂŒ\Š;d‡ã×Â… Å‚´Â}ffÂvhsÂo;dÂgúáÁï¶FÁôffÁù33Áþ/³3ÂyÛÂ{ç ÊÁÂ{çÂ¥ãÂaHÂÀƒÂ"ÑìÂ)˜“Â1 7Â9%ÂAe`ÂIñªÂRs¶ÂZ¹XÂb²Âj%ÂpÝ/Âw$ÝÂ|ÊÁ€߾‚õÄ›#…†aˆqªÂ…ò-„çmƒ\¬Â`BÂ~+Âx±'Ârå`ÂlÖÂfiyÂ_ñªÁïVÁóÒòÁøº^ÁýÐå“uÂiyÂvÉ ɺÂuÊ=šÂ0!Â!ØÂ(\Â.ÊÁÂ5ð¤Â=_;ÂDë…ÂLjÂS³3ÂZ¦éÂa-Âg/Âl®Âq—ÂuÝ/Âym‘Â|7LÂ~(öÂ1'ÂIºÂ~ožÂ|©üÂz =Âv¥ãÂr–‡ÂmùÛÂhë…Âc‡+Â]çmÂX!ËÁîVÁòÝ/Á÷ÒòÁüùÛÂ/ =“ ffÂÂõÃÂQ쬠[#Â& =Â,¸Â2ƒÂ9¦Â?ƨÂFbNÂLÍÓÂRí‘ÂX­Â]öÉÂbÈ´ÂguÂjÈ´ÂmÜ)Âp?}ÂqæfÂrÅ¢Âr× Âr¦Âp—ÂnXÂkm‘Âgë…ÂcèsÂ_{çÂZ¼jÂU¾wÂP–‡ÁqûçÁnÐåÁk`BÁgÂÁd1Á`MÓÁ\´9ÁY`BÁVzáÁT1'ÁR°!ÁR-ÁRÔþÁTÔþÁXMÓÁ]dZÁd(öÁl§ðÁváHÁ`BÁˆ Á‡+Á—‰7Á bÁ¨÷ÏÁ² Á»OßÁÄvÉÁÍffÁÕùÛÁÞoÁå“uÁìdZÁòp¤Á÷¬ÁüVÁÿ—Â#×Â{ ÅÂÐåÁu|îÁqûçÁn-Áj ÅÁeë…Áa©üÁ]ÁY•ÁV¬ÁS?}ÁQ;dÁPA‰ÁP\ÁRMÓÁU²-ÁZÙÁaãTÁjÔþÁuº^Á=qÁˆÁ\Á™IºÁ¢›¦Á¬^5Á¶ffÁÀ‡+ÁÊ—ÁÔhsÁÝÔþÁæ²-ÁîáHÁöE¢ÁüÊÁÂ0!€ÂSøÂ¯Â•ÂV ÅÁyl‹Áu²Áqp¤ÁlñªÁh=qÁcp¤Á^´9ÁZ-ÁV{ÁR›¦ÁP1ÁN\ÁNr°ÁOë…ÁS+ÁX^5Á_¥ãÁiVÁtŸ¾Á$ÝÁˆ÷ÏÁ‘´9Á›1'Á¥bNÁ°oÁ»{ÁÆ7LÁÑIºÁÜ“Áæp¤Áð&éÁù{‹D J qªÂ Rò «  Þ5 ËÇÁ}× Áyº^Áu33ÁpIºÁk‡Áe¾wÁ`jÁ[C–ÁVƒÁRjÁO7LÁM7LÁL§ðÁMÎÙÁPáHÁV¬Á]™šÁgxÕÁs¶FÁ&éÁ‰\Á“ÁOßÁ¨l‹Á´ ÅÁÀ5?ÁÌvÉÁØ¥ãÁä‹DÁïéyÁúPÂ#×Âzá =q dZÂêÂÑì ÅÂß;ÂÂÖÁdZÁ~jÁy‰7Át9XÁn\Áh¬Áb¼jÁ\ñªÁW‰7ÁRÈ´ÁNõÃÁLbNÁKXÁL$ÝÁO =ÁT=qÁ[ïžÁf9XÁs&éÁVÁŠZÁ”‡+ÁŸ´9Á«ÎÙÁ¸™šÁÅß;ÁÓXÁàÆ¨Áíß;Áú`BÂÂQì Â 7Â[#ÂõÃÂÞ5 µ?¾wÂBÁ„$ÝÁÙÁ~ƒÁxÐåÁr´9ÁlIºÁeƨÁ_\)ÁYOßÁSãTÁOp¤ÁLE¢ÁJ¼jÁK+ÁM× ÁS ÁZáHÁe‘hÁs&éÁÌÍÁ‹l‹Á–\)Á¢r°Á¯›¦Á½™šÁÌ(öÁÛÁéÌÍÁø=qÂþú aHÂ'ðÂ8RÂÂúá£נ‚ Â!Ÿ¾Â" DÂ!× Â!{Á‡1'Á„ÎÙÁ‚‡Á~$ÝÁw²Áp¼jÁi©üÁb§ðÁ[ó¶ÁUçmÁPÔþÁM‡ÁKoÁK¸ÁM‘hÁR°!ÁZ´9ÁeƨÁsûçÁ‚¬ÁŒçmÁ˜Ÿ¾Á¥§ðÁ³ó¶ÁÃ;dÁÓ5?Áã\Áóå`Âéy {çÂyÛÂÀƒÂ2- »dÂ$VÂ'Â(ɺÂ)º^Â)çmÂ)e`Â(KÇÁŠPÁˆ Á…G®Á‚ ÅÁ}`BÁvbÁn~úÁfí‘Á_¥ãÁY ÁSXÁO‡ÁLŸ¾ÁLVÁN“uÁS©üÁ[ÎÙÁg;dÁv1Á„"ÑÁŽõÃÁ›vÉÁ©záÁ¸ùÛÁɧðÁÛ5?Áí=qÁÿIºÂp¤ÂÅ¢Âl‹Â:^Â% JÂ)ÐåÂ-Â0!ËÂ1ÀƒÂ2p¤Â2JÁÂ1iyÂ/çmÁŽ9XÁ‹¾wÁˆÛ#Á…™šÁ‚Á|ZÁt^5ÁlQìÁd‡+Á]\)ÁW7LÁRƒÁO®ÁO¸ÁQ;dÁVQìÁ^£×ÁjffÁyÂÁ†jÁ‘ÐåÁŸ Á®"ÑÁ¾çmÁѬÁäffÁøMÓÂ"ÑÂÛ#Â%Â!aHÂ(¹XÂ.èsÂ3Ü)Â7‘hÂ:hÂ;ožÂ;Ç®Â;8RÂ9áHÂ7âNÁ’33Áº^ÁŒÐåÁ‰~úÁ…ÎÙÁÔþÁ{XÁrí‘Áj¼jÁc+Á\£×ÁW¡ËÁT\ÁSãTÁUûçÁ[/Ácº^ÁoãTÁƨÁ‰ÎÙÁ•ÄœÁ£ÒòÁ³çmÁÆ%ÁÙçmÁï¸Â\ ²Â\)Â"ožÂ+ˆ1Â3hsÂ9éyÂ>ùÛÂBš ÂDÝ/ÂEß;ÂEÂÂD­ÂBƨÂ@5?Á–záÁ” JÁ‘(öÁÐåÁŠ{Á†%ÁÀƒÁzÔþÁr^5Áj‹DÁcÒòÁ^¬Á[•ÁZýôÁ]KÇÁbÌÍÁk¾wÁxZÁ„jÁޏRÁ›5?Áª =Á»1'ÁÎÂÁävÉÁûÔþ ÂYÂ"7LÂ-BÂ7 Â?yÛÂF8RÂKF¨ÂN°!ÂP‘hÂQhÂP\)ÂN¡ËÂLhÂHÒòÁ›1Á˜²-Á•Ý/Á’PÁŽÒòÁмjÁ†l‹Á‚1Á{Ás²ÁléyÁgãTÁeVÁdÝ/Ág®ÁmƨÁw`BÁ‚SøÁŠéyÁ•²Á¢¥ãÁ²A‰Áć+ÁÙ¬ÁñdZ”{Âu ¦éÂ-½qÂ9ɺÂD[#ÂM#×ÂSúáÂXÝ/Â[áHÂ]1'Â] Â[ŒJÂY 7ÂU¯ÂQ¬ÁŸ× Á¡ËÁšéyÁ—°!Á”ÁùÛÁ‹°!Á‡SøÁƒ‡Á~r°ÁxÁshsÁq/ÁqÊÁÁuPÁ|´9Áƒ®ÁŠÐåÁ“áHÁŸbÁ¬²-Á½ ÅÁП¾Áç|îº^Âô¼Âë…Â,ò°Â;QìÂH^5ÂS’oÂ\š ÂcXÂgÑìÂj33Âj¸RÂi¤ÝÂg@ƒÂcÍÓÂ_‰7ÂZ§ðÁ¤ÙÁ¢ÒòÁ A‰Á-Á™¡ËÁ•´9Á‘…ÁE¢Á‰-Á…ƒÁ‚‘hÁ€§ðÁ€VÁÁƒ¡ËÁˆÁŽ(öÁ–oÁŸÒòÁ«¬Áº%ÁËl‹ÁàIºÁù‡Â ɺ‡+Â+¬Â;³3ÂKbNÂY[#Âe+ÂnhÂtgmÂx,Âyž¸ÂyuÂvàBÂs[#ÂnÐåÂi‚ Âc©üÁª1Á¨9XÁ¥Ý/Á¢ûçÁŸ²Á›ß;Á—ß;Á“ÒòÁûçÁŒ¡ËÁЏÁˆÆ¨Áˆë…ÁŠÆ¨ÁŽzáÁ”1Á›^5Á¤hsÁ¯1'Á»ûçÁËQìÁÝçmÁôdZ´9ÂaHÂ(ÌÍÂ;%ãÂM^5Â^TþÂmhÂxí‘€Ï߃— „íÂ…„V‚E²-ÂyçmÂsr°ÂlŽVÁ¯QìÁ­ÄœÁ«¬Á© =Á¥ë…Á¢l‹Áž°!ÁšïžÁ—p¤Á”‡+Á’—Á’Á“ Á–(öÁ›E¢Á¢bNÁ«XÁµ÷ÏÁÂ;dÁÐdZÁá‡Áõ9XÂÔþ¡ËÂ&ì‹Â:0!ÂNl‹ÂbKÇÂtiyÂÓu‡¨ö‹›¦ÂÃÂŽTþ–‹ÊÁ‰2-†‚nÂ}(öÂu(öÁ´¬Á³jÁ±²Á¯G®Á¬xÕÁ©IºÁ¥å`Á¢…ÁŸvÉÁ¬Á›ß;Áœ33ÁžxÕÁ¢ùÛÁ©ÒòÁ²å`Á½ñªÁʧðÁØéyÁèõÃÁû~úÂÑìÂ;dÂ&‚ Â9”{ÂNÓøÂeÂz{ç†ǮŽxR“øR—A‰Â˜‡+˜¦Â–X“b ÓÂŒ Á‡·Lƒ6ÉÂ}JÁÁº%Á¹“Á·¡ËÁµ¥ãÁ³33Á°ffÁ­jÁª~úÁ§ùÛÁ¦E¢Á¥ÙÁ§7LÁªÐåÁ°ýôÁ¹× ÁÅ7LÁÒÄœÁâ =ÁòÒò£נÂe`Â(1'Â:šÂOVÂfTþÂ~n˜ÂŠ®˜Â”bœ;¡ Á£gð£ŽÙ¡ñªÂŸ‰Â›!Ë–¡Ë‘¿}ÂŒ¨ö‡€ƒÂ‚_¾Á¿MÓÁ¾¼jÁ½¥ãÁ¼VÁº%Á·§ðÁµ&éÁ²ÄœÁ°ß;Á¯å`Á°bNÁ²ãTÁ·í‘Á¿çmÁÊí‘ÁØ× Áé-ÁûdZÂŒJÂ49 PÂ+Å¢Â<hÂO£×Âfn˜Âœ¬ÂŒ¹X˜ÍÓ¢߾ª¬Â®>w¯|j®X“«hs§6É¢2-œ°!–î˜Â‘‹QhÂ…¨sÁÄr°ÁÄA‰ÁÑhÁÂhsÁÀ× Á¾÷ÏÁ½ Á»9XÁº Á¹× Á»KÇÁ¾ýôÁÅ…ÁÏSøÁÜ“uÁí{Â&é ÊÁÂ49Â"dZÂ/»dÂ>éyÂP¬ÂeÁ‰Â~ ÂŒhs™ýô¦~ú°˜·bѺ¡Hº®¸4¼Â³ð¤Â®‚ ¨cסî˜Â›^¸Â”Ý/ÂŽ„ˆc×ÁÉn˜ÁÉ£×ÁÉbNÁȰ!ÁÇŸ¾ÁÆMÓÁÄñªÁÃÒòÁÃ\)ÁÄbÁƉ7ÁËr°ÁÓvÉÁßbÁît¼Â¹X º^ÂÚÂ$ɺÂ2{çÂAC–ÂQËÇÂdÌÍÂ{+Š49˜ ¥ﲖ‡Â¼ŒJÂÂ× ÂÅ:^ÂÄ,‹ÂÀ|´€ƒÂ­l¦$Ýžå`—Òo‘ Š€ÁÎ/ÁÎÎÙÁÏÁÎÌÍÁÎE¢ÁÍ‹DÁÌ× ÁÌp¤ÁÌÈ´ÁÎdZÁÑéyÁØ =ÁávÉÁîº^Â% ž¸ÂØÂ$E¢Â2Š=ÂAŒJÂQŒJÂc%ãÂvþú†æf“¼j¡Ó¯aH»ÔþÂÅvÉÂË@ƒÂÌó3ÂË ÍÂÆt9ÂÀšÂ¸ÀƒÂ°ô¼Â©o¡Qì™ÕÂ’¯žÂ‹çðÁÒ©üÁÓ´9ÁÔ\)ÁÔ¬ÁÔ¶FÁÔ²ÁÔ—ÁÔ÷ÏÁÖ&éÁØ´9ÁÝC–ÁäPÁïG®ÁýýôÂwÏÂó¶Â!#×Â/•Â>ãTÂNáHÂ_¿}ÂqüîƒuÂŽn˜Â›ƒÂ¨\¬Âµœ¬ÂÁvFÂÊŠÁÂÏÖÂÑ\Âέ‘ÂÉ–‡ÂÂÁºöɲƨªŽÙ¢‡®ÂšÑh“}qÂŒ‘hÁÖÔþÁØIºÁÙjÁÚ?}ÁÚß;ÁÛl‹ÁܸÁÝG®ÁßVÁâÐåÁèdZÁðÂÁüŸ¾ÂC–Â[#Â{çÂ*TþÂ9qªÂIgmÂYûçÂkH´Â}°!ˆÍÓ“ȴŸµ?¬0¤Â¸p!ÂÃRoÂËž¸ÂÐeãÂÑYÂÎÙÂɵÃÂÂØ“»¢Â²ÌJª‹D¢{çš¿}“ffÂŒxRÁÚ¥ãÁÜ…ÁÞ¬ÁßxÕÁà°!Ááå`ÁãQìÁåE¢Áè/Áì“uÁó‡Áüjœ¬Â Â…Â$+Â28RÂA£×ÂQÜ)Âb›¦ÂsäZ‚ýqÂŒ“øÂ–éy¡æé­4¼Â¸'ðÂÁÐbÂÉ'mÂÍ`ÅÂÎ/ÂË×ÂÇ¢ÂÀƒ–¹¨Â±©{¡8Õ™¦éÂ’r°Â‹£TÁÞ“Áà^5ÁâjÁäKÇÁæ“Áçó¶Áê“ÁìÔþÁð\ÁõÎÙÁý+¦é j¦ÂÒòÂ*t¼Â8¯ÂHoÂX.Âh³3Ây‘hÂ…wLÂŽ{d—ûç¡Þ5«Øµ]/½®˜ÂÃüjÂÇ¡ËÂÈYšÂÆPb®¼#×µA‰Â­Ý²Â¦RožÜ)—Ÿ¾Â²°ÂŠ;Áá&éÁãÎÙÁæKÇÁè®Áë =Áí‡+Áð^5Áó× ÁøXÁþ\)Â9X›¦Âœ¬ÂqªÂ#-Â/°!Â=¯ÂL¼jÂ\gmÂl\)Â|zá†hsÂŽ¹Û—LJ ¨¥ã°ÀƒÂ·Á‰Â½ ÁÂÀ¸ÂÀÿh»eã¶>ú°)©k¢~ú›‘ì”Ê=ÂŽ@ƒÂˆƒÁãÊÁÁæÎÙÁé¸RÁì“uÁïzáÁò‘hÁö JÁú5?Áÿhs JÂdZ Â!ËÂô¼Â'…Â3¶FÂA=qÂO³3Â^©üÂmËÇÂ|푆%“øÂ•33œÊ=¤&fªó¶Â°Âµ;·¬¸:á¶Ù³Ţ¯]/ªœÂ¤‡Âܬ—P‘O\‹:áÂ…`BÁæ1Áé`BÁì¬ÁïùÛÁó`BÁ÷ Áû‡ÁÿÝ/ÂÖÂuà1ÂÈ´Âí‘ œ¬Â*Ü)Â6PÂCk…ÂQ‡Â_&éÂmG®Â{F¨Â„‰ºÂ‹QhÂ’+˜“užÍÓ¤wL©>w¬ÎÙ®äݯ]/®=q«¯žÂ§öÉ£_;ž2-˜®“–ÂW‡Ö‚XÁçÙÁë~úÁï$ÝÁò× Áö°!ÁúÒòÁÿl‹Â^5‡+ _;šÂèsÂøÕÂ#gmÂ-6FÂ8F¨ÂDXÂQuÂ^¦Âk²Âwçm‚/žÂˆ8ÕÂŽ “¶F˜÷Lª¡–¤|î¦.¦bÂ¥¤Z£†¨Â ffœ}q˜–“-ÂŽ$݉ ǃú^Â~Áé?}Áí+Áñ¸Áõ-ÁùjÁýùÛƒÂcT¿} ÀƒÂ‘hÂZÂA‰Â%XÂ.ž¸Â8öÉÂD$ÝÂOÜ)Â[È´Âg ÅÂs2-Â~^5„‡+‰¥ãÂŽxRÂ’æé–Ïßš1œe`ÂĜžoÂNÙ›ŒÍ˜í‘•›#‘ ŠÁ‰„ÓÂ÷ÏÂvì‹Áê=qÁîdZÁò›¦ÁöõÃÁû‰7Â:^Âî˜Âúá }ô —Âl‹Â¸ÂÇ®Â&wÏÂ/%ãÂ8·LÂB÷ÏÂM¢ÑÂXp¤Âc ÅÂm‚ ÂwwÏ€s3„èö‰ ÓÂŒÎÙÂòÂ’»d”«•È1–•aH“èö‘´9ÂŽâN‹”{‡ë„ÂöÉÂwÄœÂo•Áê× Áï+Áó›¦Áø5?ÁýV ÅÂøÕÂ$Ý ¾wÂâN­Â7L–‡Â&ÑìÂ.àBÂ7¦éÂ@øÕÂJ›¦ÂTQìÂ]æfÂg)üÂp ÂxPå€ ÍƒŸ;†Ñh‰b‹ƨÂ_;ÂŽH1ÂŽwÏÂíÂŒ°!ŠÓuˆl‹Â…•‚hsÂ}ûçÂvÖÂoƒÂh"ÑÁë JÁï‡+Áô"ÑÁøí‘ÁýùÛ±'¡ËÂáH †%Â¥ãÂX¯¸RÂ&xÕÂ-å`Â5äZÂ>OßÂFöÉÂO¦éÂX1'Â`n˜ÂhDœÂo–‡ÂvcTÂ|‘h¢ƒYšÂ…5?†‰7‡I7‡n†÷ÏÂ…ë…„V‚H´Â­Âz(öÂt,ÂmÛ#ÂgSøÂ`²-ÁêãTÁïxÕÁô5?Áù"ÑÁþSøÂî˜Âî˜Â6F ÚÂéyÂwÏ‘hÂ@ƒÂ%ƒÂ,PåÂ3bÂ;#×ÂBâNÂJ ÅÂR8RÂYˆ1Â`vÉÂféyÂlÞ5Âr>wÂvõÃÂzð¤Â~‡Â€(ö€ȴ€å Â6FÂ|‚ ÂxûçÂtÁ‰Âoô¼Âj´9Âe²Â_MÓÂYYÁê`BÁï1Áó× ÁøÛ#Áþ"ÑÂß;ÂãTÂ)ü Á‰Â·L“ÂïžÂ@ƒÂ$1Â*>wÂ0ÌÍÂ7˜“Â>‚ ÂEffÂL#×ÂRž¸ÂXÀƒÂ^p¤Âc«Âh\)Âls¶ÂoàBÂrbÂtuÃÂu„Âu²-Âu ÂswÏÂq$ÝÂn Âjp¤Âf?}Âa¡ËÂ\°!ÂWÂR(öÁé‰7Áî9XÁóoÁø ÅÁýn˜Â†%‡+ÂÖ G®Â¬ÂKÇÂÛ#ÂÍÓÂ" ÅÂ'Ç®Â-³3Â3ËÇÂ9öÉÂ@‡ÂFoÂKÐåÂQ>wÂVC–ÂZÞ5Â^ùÛÂbŠ=Âe‚ ÂgÓøÂis¶ÂjYÂj~úÂiå`Âh‘hÂfŽVÂcë…Â`¹XÂ] PÂXüîÂTš ÂOúáÂK/Át1'Áq®ÁnýôÁl(öÁiG®ÁfvÉÁcÎÙÁap¤Á_|îÁ^$ÝÁ]…Á]ÎÙÁ_&éÁa®Áe…ÁjÈ´Áq…ÁyÂÁÀƒÁ‡XÁ²Á”Á›ãTÁ£º^Á«å`Á´A‰Á¼®ÁÅ1ÁÍ1'ÁÕ1ÁÜn˜ÁãIºÁé…ÁïbÁóÝ/Á÷çmÁû(öÁý¥ãÁÿbNÂ49ÂaHÁw¶FÁtí‘Áqë…ÁnÀƒÁk|îÁhA‰Áe&éÁbVÁ_ó¶Á^-Á]/Á]&éÁ^A‰Á`§ðÁd~úÁiãTÁpéyÁy²ÁýôÁ‡ýôÁŽÀƒÁ–5?Áž;dÁ¦Æ¨Á¯°!Á¸ÔþÁÂVÁË7LÁÔ$ÝÁܶFÁ䯍Áì9XÁòõÃÁøçmÁþ ¾ÂÍÓ PÂâNÂQìÂdZÁ{²Áx—ÁuG®ÁqÂÁn¬Ájr°Áfå`Ác²Á`ÄœÁ^‹DÁ]&éÁ\ÄœÁ]™šÁ_Û#Ác©üÁi/Áp~úÁy®Á‚ZÁˆÄœÁ =Á˜“Á ÌÍÁª Á³× Á½× ÁÇïžÁÑ÷ÏÁÛ¾wÁå ÁíçmÁõûçÁýA‰ÂÎÙƒ¸RÂp¤Â ­ r°Â ɺ º^Áó¶Á|°!Áy Áu?}Áq7LÁm"ÑÁi"ÑÁe`BÁb JÁ_\)Á]‰7Á\È´Á]XÁ_l‹Ác/ÁhÐåÁpjÁz JÁ‚ß;Á‰¸RÁ‘‰7Áš9XÁ£©üÁ­È´Á¸ffÁÃVÁÎdZÁÙbNÁä‡ÁîQìÁ÷çmÂVÂ?}¤ݠ~ú ɺ‡+¹XÂhsž¸ÂdZÁ‚`BÁ€¥ãÁ}p¤ÁyG®ÁtáHÁpbNÁkïžÁg²-ÁcçmÁ`¼jÁ^záÁ]\)Á]²Á_Ác;dÁhõÃÁpÔþÁzñªÁƒ¥ãÁŠñªÁ“OßÁœ¬Á¦áHÁ±áHÁ½r°ÁÉhsÁÕ…Áá\ÁíIºÁøxÕÂt¼Â33 hsÂ%ÂÂ^5“Â9XÂɺÂÓøÂffÁ…1Áƒ7LÁ-Á}çmÁy+ÁtIºÁohsÁj¸RÁfr°ÁbÔþÁ`$ÝÁ^£×Á^›¦Á`QìÁcûçÁiÎÙÁqó¶Á|‡+Á„È´ÁŒ‰7Á•záÁŸ‰7Áª\Á¶|îÁÓÁÐ(öÁÝn˜Áê¡ËÁ÷záÂÛ#ˆ1 ©üÂ,Âþú¦€Â0!Â5?š Ân˜ÂÀƒÁ‡õÃÁ†oÁƒïžÁ•Á~$ÝÁxéyÁs¡ËÁn‡+ÁiÎÙÁeƨÁb¬Á`ÔþÁ`‡+ÁbbÁe²-Ák¡ËÁtbÁ Á†jÁŽŸ¾Á˜&éÁ¢í‘Á®ÐåÁ»¾wÁÉxÕÁ×ÀƒÁæG®ÁôÂÂk…“ÂDœÂÍÓ²£×ÂØÂ"ffÂ>TþÂ=hsÂ;ÀƒÂ9{çÁ–ZÁ”|îÁ’G®Á¾wÁŒñªÁ‰ó¶Á†Ý/ÁƒÐåÁ€õÃÁ|í‘ÁyVÁv¬Áv1'ÁwïžÁ|9XÁ§ðÁ†¶FÁ`BÁ•º^ÁŸÛ#Á«ÙÁ¹ÂÁɉ7ÁÛ-ÁîffÂe` å`Â]/ s¶Â)ÐåÂ2)üÂ9H´Â? DÂCe`ÂF]/ÂH+ÂHÂGí‘ÂFs¶ÂD8RÂA_;Áš—Á˜ÒòÁ–°!Á”5?Á‘r°ÁŽxÕÁ‹ffÁˆ^5Á…‰7Áƒ‡Á=qÁ€1'Á€&éÁG®ÁƒÀƒÁ‡¬Á$ÝÁ”?}Á“Á§ÊÁÁ´záÁÃE¢ÁÔ-Áç;dÁü$Ý 9X¼j 33Â+-Â5DœÂ>¾ÂE…ÂKQìÂOÂR ÅÂSOßÂS6FÂRÂOÛ#ÂLó¶ÂIqªÁŸVÁjÁ›dZÁ™Á–XÁ“r°Át¼ÁÁŠÆ¨ÁˆzáÁ†ÒòÁ† JÁ†XÁ‡å`ÁŠÛ#ÁQìÁ•^5ÁoÁ¦‰7Á±çmÁ¿`BÁÏ$ÝÁáC–ÁõáHÂRò†%Â!ËÂ+¥ãÂ7‹DÂBSøÂK²ÂS'ðÂX× Â\­Â^Å¢Â_LÍÂ^vÉÂ\yÛÂY‹DÂUÝ/ÂQœ¬Á£¶FÁ¢=qÁ ^5Áž$ÝÁ››¦Á˜ÙÁ–Á“5?Á®ÁŽŸ¾ÁKÇÁŒéyÁ¸RÁáHÁ“‰7Á˜ÂÁŸ™šÁ¨¬Á²`BÁ¾“uÁÌ÷ÏÁÝ× ÁñXÂÖÂ?}—Â+`BÂ8üîÂEɺÂQ2-ÂZƨÂbG®Âg ÅÂjãTÂl=qÂkéyÂj(öÂg>wÂcgmÂ^ÚÂYÇ®Á¨ƒÁ§=qÁ¥“uÁ£‹DÁ¡33Áž¥ãÁœ Á™t¼Á—5?Á•Á”›¦Á”È´Á–C–Á™=qÁÒòÁ¤bÁ«÷ÏÁµ‰7ÁÀÛ#ÁάÁÝ£×ÁïÐåÂqªÂbšÂ*®Â9µ?ÂHn˜ÂV{ÂaûçÂk¨öÂráHÂw ÅÂz JÂzgmÂyÂv%ãÂr'ðÂmIºÂgƨÂaÑìÁ­hsÁ¬bNÁªõÃÁ©+Á§{Á¤Æ¨Á¢l‹Á /ÁžMÓÁVÁœ¶FÁ•ÁŸë…Á£éyÁ©¬Á±33Áºt¼ÁÅhsÁÒ{Áà°!Áñ²Â¬Â ÂJÁÂ* PÂ9ò°ÂJ?}ÂZ\Âht¼Ât¨öÂ~.‚hö„SøÂ„øÕ„…¢Âƒ,Â)Â}ÂwÂpyÛÂi–‡Á²^5Á±²Á°xÕÁ®÷ÏÁ­-Á«1'Á©-Á§SøÁ¥çmÁ¥1'Á¥‡+Á§9XÁª‘hÁ¯ÄœÁ¶ë…ÁÀÁÊí‘ÁבhÁåïžÁö9XÂl‹Â2-Â¥ãÂ*Â:\ÂKNÙÂ\áHÂm²-Â|­„yÛ‰ ‹àBÂ.¬‹éy‰Ðå‡ ÁƒǮ€/ÂxÁ‰Âpë…Á·VÁ¶áHÁ¶ JÁ´ß;Á³l‹Á±ÐåÁ°5?Á®ÐåÁ­éyÁ­ÔþÁ®í‘Á±\Á¶ =Á¼›¦ÁÅXÁÐ7LÁÝ JÁë®Áü =Â&éÂuÃÂDœÂ*ÓøÂ:ffÂKÅ¢Â^W ÂqšÂe`‰{Â;“G+•ŠÁ–‡Â•0!“$ZÂ:áÂŒ³¶ÂˆÁ„ŒÍ€4¼Âw¤ÝÁ¼?}Á¼ ÅÁ»£×ÁºÒòÁ¹ÄœÁ¸“uÁ·n˜Á¶PÁ¶?}Á¶Ý/Á¸ÊÁÁ¼n˜ÁÂ"ÑÁÊ+ÁÔ›¦ÁáhsÁðV”{ Þ5 ÂÂ,iyÂ; ÂKÞ5Â^vÉÂr9XƒŒ.“ñªÂ™ÅÂm‘žùXž«…œݲ™í–-‘‘ãTÂC–ˆwLƒ/Â}“uÁÁ JÁÁC–ÁÁ&éÁÀ¼jÁÀ Á¿`BÁ¾¼jÁ¾n˜Á¾ÄœÁÀ ÅÁÂñªÁÇŸ¾ÁΗÁØ ÁäIºÁó =ÂV —Â%Â!cTÂ-äZÂ;àBÂKŸ¾Â]m‘Âq+‚Ù–xRž1ªÂ£¶F¦ÎV§™¦m£¹ÛŸì‹Â›`B–_;‘ B‹ÊÁ†záÂDÁŶFÁÆKÇÁÆ“uÁÆ•ÁÆjÁÆ1'ÁÆ ÁÆjÁÇp¤ÁÉ—ÁÍMÓÁÓbÁÛE¢Áæ=qÁô Â_; í‘‹DÂ"oÂ.„Â< DÂJúáÂ[•Ân&éÂ2°Â‹È1–.˜ÂŸ‘h§ B¬F%®ÍÓ®áˬì©k¤ٚŸ›¦Â™ýq”6FÂŽmˆ»çƒ33ÁÊ/ÁË$ÝÁËÔþÁÌIºÁÌ›¦ÁÌéyÁÍjÁÎ^5ÁиÁÓoÁ×´9ÁÞ~úÁçå`Áô7LÂËÇ ô¼Âl‹Â ûçÂ-vÉÂ:ÒòÂI0!ÂXØÂiþúÂ|푈«“wÂ*ŒJÂ7ÂÂEÊÁÂT¹XÂdÅ¢ÂvšÂ„xRÂŽ}ô˜Á‰Â¢¨ö«k…²A¶•¸4¼Â·NV´UÂ¯× ÂªX“¤DœÂë…—…‘5ËþÂ…0¤ÁÒbNÁÔ“ÁÕŸ¾Á× ÁØXÁÙÆ¨ÁÛÁÝÌÍÁáÁå“uÁëïžÁô—ÂÂ=qÂuÂožÂ&%ãÂ2ó¶Â@Ÿ¾ÂO =Â^7LÂnNÙÂhsˆÚÂ’p!œ#TÂ¥fé­‡®Â³Ï\·¶F¹®Â·ì‹Â´Ï\°6Fª¡H¤{džo—ž¸Â‘E‹¬Â…2°ÁÖ1ÁظÁÚbÁÛéyÁÝÂÁßÂÁâ ÁåoÁéÁîKÇÁõl‹ÁþÛ#ƒ ²ÂKÇ øÕÂ,öÉÂ:ÂGÚÂVW ÂeožÂu9X‚ݲ‹‹D”}Ân˜Â¥Þ¸Â­5òضMÓ·ff¶?}³4¼Â®½q©O\£NÙ 7–´9ÂuÊdÝ„\ÁÙZÁÛÌÍÁÞ$ÝÁàr°ÁâÌÍÁåZÁèMÓÁëçmÁðÁözáÁþG®Â- ‹DÂcT¿}Â&Š=Â2”{Â?š ÂMYÂ[ž¸ÂjW Ây…„‘hÂŒ£×”Òòœ޸¤`ŪÛ#¯ËDzÐb³¼î²¥ãÂ¯ÓøÂ««¦’o å`šì”Û#Ž׈ú^ƒQhÁÜOßÁß Áá× Áä“uÁçjÁê~úÁîÁò7LÁ÷l‹Áþ Â/ÂuÃÂÂ÷Ï ZÂ+{Â6õÃÂC»dÂQ¾Â^í‘ÂmÂ{]/„ñªÂŒRo“­šËD¡Z¦ô¼Â«5?­ÌJ®”{­š Â«§T{¢¯Ât9—äÝÂ’49ÂŒ…¢Â†ñªÂ‰ºÁÞçmÁâÁå¸ÁèE¢Áë\Áï"ÑÁó-Á÷í‘Áý¬ÂaHÂǮ 9XÂÝ/ÂÏßÂ$oÂ.‘hÂ: ÂFm‘ÂSDœÂ`gmÂm¯Â{ 7„-ÂŠÓøÂ‘Y—ßÂ6É¡þwÂ¥š§ËD¨s¶Â§šÂ¥gm¢Âò°Â™9X”%ãÂŽæé‰ž5„dÝÂ~•Áá¬Áä…ÁçõÃÁë|îÁï1'Áó7LÁ÷¼jÁüõÕÂTþ äZÂk…Â\ÂãTÂ&èsÂ1+Â<oÂGɺÂSì‹Â`?}Âl˜“ÂxÝ/‚xRˆhsÂŽ"Ñ“ƒ˜V‡ÂœaHŸhö¡>ú¡ËD¡åŸ,‹ÂœKǘ¦f”r°ÂáË‹¬Â†CÂmÂyW Áâí‘Á曦ÁêZÁî7LÁòKÇÁö¶FÁû£×¢ÑÂì‹ÂÒò záÂ+”{ 33Â(ß;Â2„Â<ò°ÂGò°ÂSC–Â^°!Âj =Âu5?€®Â…JÁŠKDÂŽì‹Â“¨Â–n˜öFš}qšð!šP嘲-–7Ï“ DÂX‹G+†üj‚”{Â|KÇÂsƒÁäZÁèE¢ÁìG®Áðp¤Áô× Áù™šÁþÝ/ÂiyÂ× Â × Âˆ1Â1Âm‘Â!ÂÂ*Â3Â<× ÂG JÂQ~úÂ[øÕÂfOßÂpe`Âz°¤Â† ÇŠ%‚ Â_;Â’|j“Á”5“•Â’3¶ÂoÂRoІ}q‚¨sÂ}`BÂuOßÂmBÁåffÁéƒÁí¾wÁò(öÁöÒòÁûÝ/³3ÂËÇÂQì _; DÂp¤Â²Â"›¦Â*bNÂ2ÚÂ;àBÂEBÂNÏßÂXXÂa±'Âj¿}Âs_;Â{PÂå„üî‡ó¶ÂŠ]²ÂŒ"NÂ0!Â{d‹ևЇ¢N„Ï\Â¥`Â|{çÂu]/ÂnoÂf»dÁæbÁêXÁîÂÁó^5Áø?}Áý~ú²ÂËÇÂ^5 k…Â+ÂDœÂ/Â"ÊÁÂ*VÂ1å`Â:.ÂB¾wÂKjÂT+Â\ožÂdˆ1Âl0!ÂsbNÂyûçÂãT‚yÛ„„œÂ†‰Â†áˇ¸Â†¸RÂ…´¼Â„"N‚øÂwÂ5¬ÂŸ¾ÂDÖÂJØÂPŽVÂUãTÂZÎÙÂ_wÂU½qÂPýôÂLuÁå1'ÁéÂÁîÁór°Áø¥ãÁþ&éÂÂ,“u DœÂDœÂ˜“Â@ƒÂ9XÂ#yÛÂ(ó¶Â.”{Â4E¢Â9ð¤Â?}ôÂDÙÂIî˜ÂN¨öÂS ÂVçmÂZKÇÂ] ÅÂ_\)Â`ñªÂaÚÂbhÂa—Â`r°Â^«Â\MÓÂYk…ÂVÂR^5ÂNYÂJÂE¥ãmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Tests/1ak3.C.map0000644000175000017500000306775310064121656027745 0ustar debiandebianGRID_PARAMETER_FILE 1ak3.gpf GRID_DATA_FILE 1ak3.maps.fld MACROMOLECULE 1ak3.pdbqs SPACING 0.500 NELEMENTS 30 60 40 CENTER 7.700 31.600 69.000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001052 -0.002186 -0.002305 -0.003814 -0.003896 -0.003882 -0.002817 -0.001345 -0.001289 -0.001201 -0.001104 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001120 -0.002248 -0.005053 -0.004383 -0.004786 -0.005134 -0.005359 -0.005468 -0.005466 -0.005337 -0.005089 -0.004734 -0.003355 -0.003036 -0.001374 -0.001193 -0.001023 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002358 -0.002656 -0.005470 -0.006204 -0.006908 -0.007586 -0.008146 -0.008576 -0.008845 -0.010528 -0.009454 -0.009289 -0.008907 -0.008337 -0.007627 -0.005331 -0.003700 -0.003181 -0.001384 -0.001160 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002288 -0.002681 -0.004418 -0.007655 -0.008694 -0.009752 -0.010791 -0.010509 -0.013014 -0.013956 -0.014589 -0.014924 -0.014870 -0.014424 -0.012670 -0.011762 -0.010683 -0.009449 -0.008232 -0.006037 -0.003610 -0.002964 -0.002283 -0.002053 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001172 -0.004946 -0.006783 -0.007570 -0.012324 -0.013759 -0.016864 -0.017282 -0.018147 -0.019875 -0.021454 -0.021185 -0.020944 -0.021467 -0.021430 -0.020817 -0.019582 -0.016852 -0.015108 -0.013194 -0.011262 -0.009480 -0.008854 -0.006701 -0.004253 -0.002466 0.000000 0.000000 0.000000 0.000000 -0.003624 -0.006518 -0.007552 -0.009803 -0.013848 -0.017491 -0.019678 -0.021936 -0.025943 -0.028555 -0.031000 -0.031144 -0.033749 -0.035420 -0.034713 -0.033392 -0.032434 -0.030289 -0.027495 -0.023177 -0.018584 -0.015606 -0.013856 -0.011527 -0.008569 -0.007131 -0.004403 0.000000 0.000000 -0.001116 -0.004961 -0.005839 -0.009188 -0.010664 -0.014982 -0.019177 -0.022093 -0.025149 -0.030211 -0.034154 -0.039623 -0.044130 -0.048323 -0.052103 -0.052872 -0.054517 -0.052799 -0.050700 -0.047381 -0.042694 -0.037199 -0.029579 -0.025452 -0.022047 -0.016103 -0.013189 -0.009915 -0.007261 -0.001567 -0.004276 -0.005942 -0.010288 -0.013807 -0.015487 -0.019791 -0.022865 -0.026169 -0.028560 -0.033739 -0.039079 -0.047807 -0.054850 -0.066855 -0.075614 -0.082277 -0.086024 -0.088607 -0.088283 -0.083658 -0.076956 -0.067019 -0.058304 -0.047760 -0.038277 -0.030987 -0.023854 -0.017956 -0.013584 -0.010114 -0.004991 -0.006599 -0.011295 -0.014891 -0.016900 -0.019006 -0.025934 -0.029610 -0.033777 -0.040270 -0.046501 -0.056017 -0.068884 -0.080665 -0.093127 -0.104713 -0.116057 -0.119766 -0.117594 -0.112655 -0.109794 -0.102844 -0.094684 -0.085129 -0.070072 -0.055591 -0.044501 -0.033926 -0.025969 -0.019488 -0.013911 -0.011245 -0.013493 -0.016384 -0.020554 -0.022903 -0.026891 -0.031206 -0.035738 -0.042377 -0.051082 -0.064757 -0.077835 -0.091068 -0.106877 -0.123173 -0.135022 -0.139446 -0.140643 -0.142170 -0.138226 -0.132595 -0.128559 -0.123453 -0.115143 -0.102779 -0.087421 -0.064925 -0.051910 -0.038867 -0.030219 -0.020480 -0.015323 -0.019308 -0.023430 -0.024956 -0.027699 -0.033577 -0.039685 -0.046343 -0.054413 -0.067228 -0.082794 -0.099463 -0.117266 -0.137646 -0.152232 -0.157353 -0.161326 -0.140132 -0.083384 -0.018681 -0.011918 -0.069158 -0.118025 -0.134686 -0.128755 -0.116376 -0.098902 -0.077810 -0.061332 -0.047795 -0.039816 -0.018926 -0.023492 -0.028250 -0.030069 -0.034755 -0.041556 -0.048172 -0.056295 -0.069970 -0.085491 -0.101582 -0.125377 -0.148747 -0.166944 -0.175930 -0.178607 -0.120586 0.119123 0.722890 1.498061 1.565211 0.825368 0.173711 -0.097576 -0.152685 -0.150133 -0.132897 -0.108793 -0.087303 -0.070756 -0.055585 -0.024647 -0.029983 -0.036787 -0.040189 -0.042730 -0.050033 -0.058723 -0.070398 -0.085784 -0.101648 -0.124229 -0.152417 -0.177695 -0.196478 -0.199706 -0.139726 0.225713 1.841741 7.367743 16.444847 18.377550 8.946460 2.312387 0.263078 -0.138098 -0.184074 -0.165962 -0.142860 -0.119557 -0.096830 -0.079399 -0.032619 -0.037614 -0.043807 -0.047672 -0.056407 -0.060707 -0.071067 -0.085026 -0.102659 -0.124050 -0.152090 -0.180266 -0.210307 -0.223731 -0.196017 0.035844 1.412874 9.706989 53.886562 166.755341 191.312469 73.284515 12.684672 1.567247 -0.035567 -0.214030 -0.207132 -0.180292 -0.151188 -0.130290 -0.109217 -0.041597 -0.048450 -0.054330 -0.061195 -0.068507 -0.078999 -0.090151 -0.106169 -0.123304 -0.147708 -0.175963 -0.215218 -0.243964 -0.250567 -0.181779 0.303274 3.404101 29.757164 257.036957 1189.536987 1401.131348 367.594879 43.478603 4.317990 0.154287 -0.246714 -0.256704 -0.230413 -0.197556 -0.168902 -0.147111 -0.060232 -0.063693 -0.070542 -0.077321 -0.089762 -0.095632 -0.103604 -0.122100 -0.143317 -0.170097 -0.210073 -0.245393 -0.279629 -0.294815 -0.203235 0.409885 4.547354 43.385773 431.131775 2544.098145 3029.587158 626.833679 64.092705 5.412807 0.193758 -0.299528 -0.317980 -0.288057 -0.252953 -0.223824 -0.195593 -0.081872 -0.084478 -0.090290 -0.097926 -0.107952 -0.115294 -0.126148 -0.148638 -0.165581 -0.197685 -0.233919 -0.279646 -0.318811 -0.344939 -0.285717 0.188663 3.105510 25.403233 194.554276 862.546143 1010.535645 273.957520 35.882183 3.468621 -0.048560 -0.396648 -0.393702 -0.354333 -0.318133 -0.280154 -0.251700 -0.102594 -0.107181 -0.112357 -0.117750 -0.127048 -0.133499 -0.149580 -0.169661 -0.191062 -0.225820 -0.268083 -0.322281 -0.360386 -0.392173 -0.375528 -0.112567 1.253561 8.039245 38.461285 111.957634 126.971230 49.843399 9.280302 0.938866 -0.363945 -0.501387 -0.476710 -0.433056 -0.389182 -0.348005 -0.314665 -0.125974 -0.131746 -0.135423 -0.136609 -0.145944 -0.156142 -0.171774 -0.193841 -0.219091 -0.258680 -0.304377 -0.356292 -0.399896 -0.430891 -0.357786 0.069055 1.505861 5.290940 12.316290 18.194160 15.682682 7.225921 1.562291 -0.195998 -0.553785 -0.574663 -0.536700 -0.485545 -0.442618 -0.409535 -0.376073 -0.156871 -0.156267 -0.159492 -0.162635 -0.168924 -0.179796 -0.195709 -0.222005 -0.254842 -0.290880 -0.344058 -0.394163 -0.438735 -0.397807 0.060842 2.096473 10.225074 37.461704 84.011566 89.333939 41.719788 10.626904 1.959731 0.054021 -0.390010 -0.511105 -0.500683 -0.464144 -0.440063 -0.442078 -0.427737 -0.192117 -0.188486 -0.190175 -0.195541 -0.195800 -0.211936 -0.233406 -0.258691 -0.292627 -0.338470 -0.386593 -0.427479 -0.450063 -0.216272 1.367638 9.642590 57.411514 345.084229 1224.243164 1318.156982 418.437714 63.980831 12.018064 5.117660 2.557719 0.764814 0.073730 -0.099746 -0.211265 -0.293178 -0.315150 -0.231504 -0.230080 -0.226957 -0.230468 -0.241841 -0.253218 -0.270589 -0.297615 -0.339137 -0.383554 -0.421219 -0.460608 -0.448173 0.078392 3.486921 25.516310 215.833984 2659.699707 17567.564453 19289.755859 3121.969727 289.644135 83.978500 77.279953 40.881405 12.787727 4.553413 2.622283 1.436895 0.842410 0.974915 -0.278509 -0.273105 -0.269653 -0.273236 -0.280100 -0.293855 -0.312395 -0.340628 -0.376977 -0.414829 -0.455308 -0.482509 -0.436479 0.225023 4.664541 36.096882 384.255157 6590.493164 69800.187500 77571.406250 7988.051758 826.571960 1439.190552 2249.406250 808.241882 125.218819 39.769634 28.439907 15.185482 8.543036 10.502128 -0.331212 -0.320581 -0.317751 -0.312731 -0.306562 -0.307237 -0.329530 -0.354280 -0.396260 -0.438054 -0.444326 -0.383156 -0.253507 0.260081 3.309997 24.637348 241.152435 2888.524170 21301.541016 23983.189453 5423.157715 4055.260010 56945.457031 100283.453125 20299.746094 1085.612183 385.152374 310.597260 124.115082 54.742977 80.348373 -0.386363 -0.366583 -0.347372 -0.298703 -0.175131 0.013025 0.106932 -0.024298 -0.250652 -0.338434 -0.179337 0.263209 0.819380 1.203389 2.224544 9.946371 64.461182 448.689240 1852.091797 4532.175781 10915.437500 16765.099609 101707.531250 107900.812500 116112.390625 7945.822266 4214.786621 3720.888184 977.255249 272.948822 463.235962 -0.444367 -0.402097 -0.282979 0.164019 1.489738 4.110695 5.450742 3.797395 1.377072 0.589621 1.431630 3.326331 5.439250 6.157649 5.128489 5.195197 15.427453 75.186836 440.973389 3223.128174 11374.949219 12183.368164 112017.187500 200159.140625 163432.546875 104350.906250 23338.144531 21554.007813 3901.204346 1465.789673 1516.237427 -0.484761 -0.322546 0.325890 3.340816 17.210445 60.308514 94.153656 56.253788 16.162535 5.764024 9.933434 18.730085 23.537878 22.380924 16.832602 12.529124 13.579374 26.850983 139.708511 804.353821 2197.162109 2916.581543 41688.273438 112787.507812 103544.109375 102755.468750 26395.201172 18609.111328 21029.496094 26828.261719 7696.853027 -0.437231 0.215437 3.097657 20.398083 165.358643 1074.755981 2224.863525 990.567383 141.921371 26.384562 49.773022 92.519814 80.133949 53.609760 44.427250 56.672108 77.352180 58.855366 47.669556 121.179642 355.619232 3594.630859 72886.906250 196294.078125 108545.953125 100953.007813 7165.417480 17399.955078 106643.773437 151370.265625 73219.703125 -0.106828 2.303019 14.043087 85.144218 1030.684204 18048.296875 70572.515625 16325.796875 919.737610 76.159409 130.798584 281.908722 191.791458 95.645752 146.941803 431.380676 884.215332 565.203125 133.871964 42.577690 302.985443 12445.100586 101069.898438 109322.859375 62568.582031 6437.218262 1305.942993 16815.320313 112252.976562 200073.281250 134612.812500 0.717653 8.246148 51.253517 263.830078 2520.093750 70749.304688 100051.265625 56618.375000 1887.926147 103.934303 140.559402 280.601471 198.634644 251.408264 1513.953125 6208.922852 10590.297852 4975.365723 633.032349 70.745476 178.346222 4766.891113 100079.664063 100279.132813 15494.464844 699.794739 308.420776 2948.843750 24860.890625 51682.742188 27522.773438 1.982257 18.509222 131.817169 733.404541 2232.461426 15529.209961 56754.128906 13446.904297 788.816345 59.023594 51.971832 103.733948 172.424118 1647.648804 46638.710938 103157.265625 115736.390625 18039.656250 1282.954834 140.928848 74.369720 469.618500 3034.263428 4349.531738 950.588318 108.844856 58.062637 294.621613 1196.776611 2390.524170 5103.871094 5.427675 21.775402 166.536469 859.713684 1926.575562 1756.196289 2058.861084 808.872681 125.892349 17.832043 17.179306 77.590065 625.838684 8342.274414 101995.585938 102108.554688 105015.625000 89114.593750 1736.243774 292.224792 115.162247 55.049763 105.780281 118.089577 50.558620 12.970976 9.945429 32.277382 94.358116 288.159546 1752.262085 47.747139 26.620358 80.802612 342.763123 648.868652 413.482147 165.831970 60.662918 15.224922 4.780266 21.534567 319.724609 7125.581543 104539.570313 188490.093750 107158.734375 101929.890625 63898.453125 1420.404175 442.521027 179.835892 38.168983 10.763769 6.982429 3.979581 3.439201 9.453910 22.048235 33.301399 67.031212 289.928467 794.035583 129.329544 33.898193 66.707970 101.306686 68.857033 26.514147 7.781519 2.032469 2.919804 35.556694 749.045837 36965.613281 101102.914063 121258.492187 133409.390625 87166.273438 5831.309082 465.865967 228.673767 105.837791 24.711235 5.122847 2.179829 3.077885 13.532300 61.348957 175.894119 215.211227 108.425850 55.457233 12344.583008 794.296082 49.833981 11.991854 12.600199 9.044136 3.878426 0.831423 -0.034364 2.109865 28.516171 518.559875 16375.148438 100152.125000 100714.570313 18292.222656 1832.067993 366.351379 88.574356 54.136044 28.774597 9.977929 4.415415 4.733527 9.174661 50.641502 364.666901 1532.716675 2086.826172 681.442688 103.086243 34798.957031 1402.666138 64.625069 4.952909 1.219074 0.557138 -0.089895 -0.532296 -0.555958 0.775753 11.352260 117.533997 1382.689087 8382.647461 8400.678711 1331.583130 166.916458 41.411922 15.926594 9.895795 6.519200 4.555014 6.772280 11.971016 20.237377 107.735199 983.883850 6033.172363 8522.681641 2086.885498 228.038422 6934.473633 541.760620 36.466045 2.418813 -0.289771 -0.615058 -0.722388 -0.783510 -0.751405 -0.260143 2.503817 17.801561 83.794800 234.535934 235.563965 89.569382 29.261354 15.637548 10.235148 8.758920 6.186145 5.890287 12.004529 22.424599 30.742622 102.372597 805.134583 4696.049805 6574.291016 1655.776001 200.209900 429.190857 84.825058 10.665735 0.794858 -0.535286 -0.756950 -0.809406 -0.818307 -0.819359 -0.705037 -0.124579 1.863104 7.016346 13.766495 15.345782 13.690267 17.451481 29.922791 76.117805 129.229736 80.408791 24.649620 15.293059 24.163294 31.162487 66.617188 271.799255 882.760315 1070.604370 394.320648 70.441444 74.896248 30.569717 7.739654 0.994341 -0.465503 -0.738534 -0.806217 -0.817336 -0.822930 -0.821270 -0.744733 -0.485547 0.043303 0.835247 2.218584 6.520999 27.749895 221.430206 1981.693726 6293.996094 2336.605469 258.598755 27.880358 16.375393 25.227951 62.629173 142.907181 200.971725 159.747772 66.014099 17.264584 988.133667 379.576630 62.150047 6.642982 0.090299 -0.685639 -0.773930 -0.769496 -0.766616 -0.784713 -0.822619 -0.845475 -0.793657 -0.562980 0.539174 7.310475 79.660408 2016.724487 96118.085938 100107.093750 100043.523438 2549.988281 87.782333 12.619274 29.903278 139.220764 435.086304 499.415771 202.940186 46.109451 9.117282 100216.992188 15106.791992 680.562683 33.739010 1.708142 -0.550073 -0.663126 -0.587366 -0.521718 -0.524480 -0.634800 -0.786149 -0.871172 -0.773146 0.388575 10.618004 146.220535 5396.960937 100480.945313 100448.421875 100145.953125 7610.851562 159.021225 13.135502 42.839733 262.751556 981.972778 1225.358643 419.171631 70.105331 9.840168 100449.375000 100052.070313 3963.404541 89.237457 3.921969 -0.291767 -0.332885 0.013321 0.341802 0.367867 -0.028445 -0.452394 -0.663372 -0.639066 0.505205 10.534702 114.863617 2245.114258 96795.585938 100744.554688 100220.398438 2809.359131 94.888702 9.752641 32.866356 200.290543 731.526062 845.041077 296.902924 54.324402 7.857403 100299.203125 100040.828125 3962.366943 89.109497 4.100074 0.377770 1.195473 2.530653 3.197452 2.769196 1.486863 0.438332 0.094466 0.041379 0.795202 8.213692 59.499546 405.548920 2631.354980 6753.358398 2719.179199 313.908051 29.142414 4.889920 13.417613 65.253731 175.883255 200.150421 88.336632 22.173746 5.362351 100084.437500 18493.156250 678.231750 33.603619 3.057300 5.219810 15.033341 24.560246 21.654699 11.776280 4.906547 2.230930 2.148655 2.176999 2.067407 8.625268 58.642525 338.714508 1439.930542 2257.282471 989.373596 189.564209 25.118917 3.530966 4.310237 14.914350 32.640701 36.082558 22.427153 12.309043 22.279209 1022.860046 429.630920 64.256355 7.735683 7.993467 48.244118 213.720566 448.378143 301.012207 88.104843 18.955862 5.823551 5.519945 5.654923 4.524610 15.536904 157.945328 2527.579102 38065.343750 100136.031250 23342.138672 1430.536377 84.611923 7.572535 6.849909 30.467154 86.398628 124.875137 82.418266 62.401073 250.941147 33.940941 18.759312 5.535674 4.153302 38.072453 446.142120 4307.045410 16005.201172 7813.842285 985.896729 94.959854 13.340753 7.130987 6.650192 5.934306 25.804327 387.101379 13393.201172 100113.953125 100083.257813 100029.195313 6573.882324 201.074890 16.195896 41.316605 363.492340 2087.959961 3973.469727 1694.147217 495.799011 3446.453857 3.090603 2.244895 1.599106 7.816854 112.491013 2643.746338 86130.734375 100004.281250 100011.156250 8536.503906 329.210358 24.444050 5.665643 3.845763 5.709314 37.342972 448.760345 12620.782227 100744.820313 100374.367188 100082.671875 6041.731445 202.526611 25.701813 213.868362 4680.769043 100007.187500 100060.406250 63303.707031 4393.200195 27070.597656 3.979249 3.500611 2.904882 10.314106 154.414307 4306.306152 100000.796875 100005.062500 100013.390625 17577.189453 460.398285 30.498745 4.145294 1.784343 6.954381 64.437668 671.279175 6239.103027 34157.687500 80591.414063 17948.625000 1170.151489 78.802208 32.014057 550.488586 28231.814453 100029.250000 100450.937500 108559.617187 97934.695313 124341.382812 6.823960 6.398009 4.456954 8.003799 88.165741 1653.581299 37883.609375 100003.367188 95839.140625 4693.844727 239.430191 22.882082 4.693591 1.862224 8.513766 96.722267 1341.443970 14772.128906 38670.882813 11590.110352 1479.468018 182.061874 23.534248 25.179096 478.605316 21188.216797 100071.476563 101941.335938 200041.937500 109565.070312 104228.687500 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001132 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001197 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001248 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001001 -0.001008 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001266 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001001 -0.001097 -0.002170 -0.002338 -0.003946 -0.004120 -0.004198 -0.004181 -0.004098 -0.002920 -0.002759 -0.001253 -0.001144 -0.001030 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001248 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001116 -0.002295 -0.002519 -0.003753 -0.005626 -0.006101 -0.006503 -0.006805 -0.006984 -0.005959 -0.005952 -0.005779 -0.005506 -0.005116 -0.004644 -0.003248 -0.002867 -0.001244 -0.001066 -0.001037 -0.001081 -0.001104 -0.001214 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001180 -0.002391 -0.003988 -0.004388 -0.007443 -0.009830 -0.010579 -0.008494 -0.009118 -0.009599 -0.011586 -0.011775 -0.011664 -0.010251 -0.009832 -0.009163 -0.008378 -0.007485 -0.006567 -0.004426 -0.003977 -0.002403 -0.001253 -0.001289 -0.001156 0.000000 0.000000 0.000000 0.000000 -0.001116 -0.002612 -0.004099 -0.005823 -0.009133 -0.011846 -0.013172 -0.014405 -0.015513 -0.017003 -0.018073 -0.018872 -0.018102 -0.016855 -0.016707 -0.016193 -0.015273 -0.013083 -0.011855 -0.010438 -0.010086 -0.008844 -0.006835 -0.004522 -0.002741 -0.002509 0.000000 0.000000 0.000000 0.000000 -0.002427 -0.004083 -0.007031 -0.009601 -0.013268 -0.015092 -0.016973 -0.018815 -0.020589 -0.024139 -0.025934 -0.026490 -0.027724 -0.028959 -0.029189 -0.026093 -0.025290 -0.023761 -0.021661 -0.018308 -0.015685 -0.013669 -0.011744 -0.010048 -0.007665 -0.006559 -0.002998 0.000000 0.000000 0.000000 -0.003759 -0.004469 -0.007683 -0.010563 -0.013634 -0.016983 -0.020702 -0.023332 -0.026528 -0.029677 -0.032844 -0.037383 -0.040301 -0.042669 -0.043147 -0.042675 -0.043272 -0.038707 -0.036298 -0.032833 -0.028871 -0.024928 -0.021389 -0.016818 -0.014098 -0.012406 -0.009774 -0.008492 0.000000 -0.001156 -0.003840 -0.005796 -0.008040 -0.009621 -0.014420 -0.019642 -0.022915 -0.026482 -0.031986 -0.036521 -0.042733 -0.047972 -0.052270 -0.057497 -0.061806 -0.066837 -0.068540 -0.066938 -0.063274 -0.056011 -0.050313 -0.043837 -0.038213 -0.031063 -0.028875 -0.023142 -0.018402 -0.015718 -0.011810 -0.001180 -0.002747 -0.006149 -0.008544 -0.011342 -0.016387 -0.020455 -0.024370 -0.028832 -0.035406 -0.041394 -0.050898 -0.058780 -0.068532 -0.079297 -0.088358 -0.100068 -0.105234 -0.107123 -0.104218 -0.097507 -0.090976 -0.078239 -0.069936 -0.058163 -0.046154 -0.039358 -0.032688 -0.027231 -0.020222 -0.016166 -0.003155 -0.007770 -0.010311 -0.013190 -0.017733 -0.023897 -0.029153 -0.032690 -0.038490 -0.045997 -0.056320 -0.069591 -0.083689 -0.098757 -0.114325 -0.130405 -0.134757 -0.135635 -0.134424 -0.131188 -0.123981 -0.117676 -0.107604 -0.099558 -0.086308 -0.071531 -0.055052 -0.041936 -0.033895 -0.027786 -0.021303 -0.007043 -0.011641 -0.013642 -0.018396 -0.023212 -0.029813 -0.035254 -0.041594 -0.052183 -0.062119 -0.078938 -0.092202 -0.113211 -0.132457 -0.149768 -0.155389 -0.156061 -0.157392 -0.150634 -0.142159 -0.140618 -0.138663 -0.134997 -0.126437 -0.114650 -0.099943 -0.078917 -0.060762 -0.045970 -0.036393 -0.030121 -0.013284 -0.016490 -0.020044 -0.024454 -0.029882 -0.036550 -0.043220 -0.051494 -0.064846 -0.083017 -0.101553 -0.124038 -0.143156 -0.162672 -0.173856 -0.176434 -0.162224 -0.089657 0.074502 0.232583 0.238509 0.069602 -0.080841 -0.139276 -0.144449 -0.131724 -0.114932 -0.088373 -0.067238 -0.054645 -0.042700 -0.016036 -0.019772 -0.023960 -0.028955 -0.036723 -0.045347 -0.053451 -0.065443 -0.082278 -0.102826 -0.128174 -0.152176 -0.175887 -0.193578 -0.185165 -0.125140 0.099167 0.810640 2.635304 5.149354 5.268814 2.743282 0.738396 0.012793 -0.157290 -0.164801 -0.149647 -0.126157 -0.098109 -0.077538 -0.063359 -0.020446 -0.023469 -0.028295 -0.033941 -0.044673 -0.052426 -0.061859 -0.082743 -0.100205 -0.123558 -0.153016 -0.181715 -0.203937 -0.201609 -0.100759 0.285692 1.589417 7.088300 30.667208 80.931023 91.019730 36.617397 8.069301 1.053160 -0.061266 -0.188384 -0.181004 -0.156908 -0.131348 -0.104169 -0.086508 -0.024015 -0.030215 -0.034468 -0.040712 -0.052454 -0.060702 -0.075894 -0.095603 -0.119401 -0.145476 -0.179233 -0.211011 -0.229929 -0.165086 0.206328 1.606578 7.014233 43.393959 380.308563 2149.053711 2547.690186 582.031799 60.633072 5.305811 0.284377 -0.201011 -0.217984 -0.195263 -0.162119 -0.134372 -0.110757 -0.031003 -0.037483 -0.041359 -0.049460 -0.061968 -0.073084 -0.092089 -0.113571 -0.138722 -0.171818 -0.207075 -0.241854 -0.251948 -0.112133 0.704979 3.721944 17.764477 174.919983 3659.568848 67828.429688 96023.273438 6904.374512 295.537323 15.342463 0.912146 -0.202111 -0.262914 -0.237303 -0.201689 -0.174533 -0.149896 -0.041857 -0.045681 -0.049791 -0.058667 -0.069885 -0.087631 -0.107375 -0.129768 -0.158019 -0.192446 -0.231394 -0.272862 -0.285957 -0.116800 0.868915 4.859164 24.929392 286.062103 9267.475586 100088.906250 100048.640625 20499.031250 498.985962 22.100025 1.149074 -0.245058 -0.320494 -0.295600 -0.259260 -0.224361 -0.201352 -0.060463 -0.065304 -0.072587 -0.075939 -0.088229 -0.105024 -0.122232 -0.147626 -0.175057 -0.213668 -0.260911 -0.305120 -0.333674 -0.223168 0.444713 3.271528 16.924278 151.424942 2598.001709 34850.199219 48365.160156 4761.280762 221.963196 13.627119 0.664544 -0.357850 -0.397427 -0.368830 -0.323552 -0.283142 -0.250959 -0.077048 -0.082022 -0.086999 -0.090843 -0.103960 -0.120171 -0.143074 -0.165632 -0.194264 -0.235271 -0.290624 -0.335592 -0.370754 -0.346436 -0.039707 1.278734 6.831398 38.228817 244.438629 1121.481812 1304.092041 346.138428 41.855396 4.108830 -0.073322 -0.488370 -0.489830 -0.449791 -0.398763 -0.352112 -0.310810 -0.102356 -0.103589 -0.106085 -0.108659 -0.120628 -0.135783 -0.161305 -0.184284 -0.217794 -0.263413 -0.314791 -0.365118 -0.406692 -0.376211 -0.002780 1.303595 5.172193 15.333869 37.971001 68.389328 62.137001 26.052477 5.775889 0.540187 -0.462569 -0.583765 -0.568683 -0.523586 -0.470165 -0.419715 -0.373856 -0.125598 -0.124071 -0.125912 -0.128480 -0.140939 -0.155192 -0.175204 -0.205252 -0.243300 -0.288984 -0.343969 -0.394030 -0.400558 -0.090304 1.765598 8.901574 31.937637 110.527382 284.450531 282.889679 116.997391 26.620001 4.445640 0.517761 -0.275840 -0.529346 -0.597453 -0.577856 -0.524266 -0.468726 -0.410247 -0.153294 -0.152859 -0.150393 -0.156756 -0.166362 -0.185337 -0.199565 -0.229975 -0.269923 -0.320553 -0.373575 -0.416683 -0.320973 0.920180 9.046289 50.347183 237.662567 1726.895630 9332.245117 10175.670898 2091.235352 204.962128 23.321669 7.659177 3.486488 0.893011 -0.201429 -0.457903 -0.432415 -0.291031 -0.107749 -0.188086 -0.179969 -0.183702 -0.190808 -0.199457 -0.217117 -0.233171 -0.265272 -0.308228 -0.361328 -0.410307 -0.436628 -0.198009 2.513862 24.634701 176.918549 1239.875122 28571.488281 100097.414063 100040.453125 37935.261719 1195.564087 152.393219 123.117668 61.664120 14.777756 2.900665 0.735803 0.612908 1.598957 3.412240 -0.230722 -0.220570 -0.221861 -0.229439 -0.232830 -0.247652 -0.264644 -0.302996 -0.348908 -0.400422 -0.443085 -0.469569 -0.173128 3.246701 31.880074 255.348206 2412.841309 100546.695313 100203.351563 100436.484375 101017.101563 3524.906982 3121.516113 5324.355957 1487.271973 169.465195 22.358509 7.731383 7.380260 17.657175 43.353279 -0.280731 -0.267851 -0.261265 -0.259034 -0.265452 -0.274351 -0.296724 -0.332598 -0.379196 -0.430208 -0.476212 -0.509841 -0.303619 1.947602 19.092203 134.840988 1148.386230 34567.761719 100694.671875 107829.648437 84363.859375 26844.244141 101876.125000 100217.210938 70691.062500 1681.291870 114.626488 46.350803 43.790413 162.971298 594.109802 -0.335675 -0.310434 -0.298558 -0.275756 -0.226395 -0.159147 -0.147876 -0.222214 -0.340750 -0.438077 -0.473201 -0.455673 -0.329879 0.505207 5.742573 34.160622 221.463196 2233.180664 15980.638672 110451.531250 103122.398438 133465.609375 111406.031250 101618.703125 102124.648438 6696.163086 436.345795 208.302734 190.525497 1189.704834 9341.840820 -0.388959 -0.356594 -0.302553 -0.126750 0.360532 1.134340 1.544416 0.998171 0.215980 -0.215011 -0.230665 -0.052623 0.141511 0.402815 1.577541 7.141536 37.505825 245.411865 3209.270264 100386.625000 100462.023438 116485.398437 113724.585937 117998.023437 141914.062500 12577.596680 1253.157837 569.788757 673.203979 4387.017578 63488.753906 -0.446285 -0.371542 -0.126219 0.901925 4.506829 12.486078 17.638992 11.621104 4.075265 0.954758 0.848305 1.487553 1.895838 2.151197 3.380393 8.156230 18.431023 70.361763 755.698853 11152.347656 56842.941406 29733.597656 22293.714844 100097.593750 107051.226562 31702.660156 1990.645752 1053.650024 5468.812500 31881.794922 60303.031250 -0.481790 -0.249079 0.676717 5.144486 27.817595 101.117294 171.853241 100.401039 25.386631 5.034117 3.801643 5.587246 6.208852 8.069754 25.097561 98.196739 213.888580 172.577454 147.206100 566.410706 1475.429077 1384.572388 3713.209961 21735.308594 47002.863281 10332.743164 1074.981689 2633.180176 81570.132813 105265.015625 104689.710938 -0.430913 0.200859 2.840306 16.376907 105.788109 582.995850 1160.697266 537.613831 94.432793 13.236482 8.293444 11.842035 13.756660 32.879810 224.451279 2245.680176 10219.241211 5752.601074 599.809753 87.080925 121.385834 715.769531 5061.401367 8339.114258 3746.688232 1117.738770 369.880615 3476.631348 104005.132813 105313.289063 102967.640625 -0.269888 1.222054 7.219526 32.493732 193.358932 1174.589600 2423.896973 1072.417114 150.368515 18.070726 9.076358 14.350236 31.476259 192.617020 1918.904297 46380.500000 102100.406250 100456.296875 5775.221680 179.716614 49.485508 378.444519 2362.243164 3121.619873 861.962830 158.033829 127.552834 1324.380981 35340.773438 101926.906250 123672.882812 0.014353 2.460344 12.952187 45.965073 145.451416 573.391724 1084.072754 501.576294 88.759293 12.096492 7.426156 22.682648 119.302040 1385.287598 29742.449219 200064.718750 200044.843750 106595.406250 11485.245117 263.146667 26.732004 75.666153 276.345337 347.723969 126.459381 30.583265 32.126564 216.069931 1828.836792 9468.338867 93347.507813 1.000613 3.059775 14.349573 44.606594 85.197380 131.207855 164.486847 91.334373 23.090782 5.775067 14.316368 106.286102 1036.648437 9174.965820 104546.640625 113172.367187 200140.515625 94660.289063 3196.085693 154.078888 17.451149 11.884748 23.342077 26.229723 13.688390 4.571751 6.164035 29.445955 141.293671 1012.571228 23501.089844 8.845826 4.936561 9.137017 23.796486 38.115307 35.366402 24.709505 12.529044 4.406949 5.290702 44.626122 633.918091 22394.837891 104252.101563 200185.671875 120468.304687 102082.406250 35392.906250 935.287292 71.655571 13.865761 3.845083 1.938158 1.580253 0.673625 0.489920 2.321193 7.625986 26.481413 170.187668 1545.659912 68.243347 19.729280 5.805196 7.524026 10.317469 8.172102 4.329003 1.650312 0.969609 7.534335 85.314438 1846.041504 100896.867188 101767.171875 113652.718750 195928.265625 52655.238281 3756.554199 244.645447 30.218153 8.087047 1.843752 -0.090634 -0.483374 -0.131579 1.937918 8.603349 19.696808 26.548559 34.625732 104.741875 341.042542 68.238525 8.655394 1.981570 1.598632 1.195661 0.309724 -0.218611 0.295570 7.185728 77.115036 1251.557373 71484.140625 101145.679688 100862.976563 64664.144531 1996.252808 293.615875 48.499630 9.996161 2.979954 0.487784 -0.282772 -0.234757 0.938573 6.950222 31.908161 82.595413 93.892982 50.735237 21.215393 581.084900 102.143013 10.940458 0.814638 -0.257273 -0.432467 -0.576688 -0.642088 -0.183200 3.718941 32.966389 290.767181 3443.466797 27343.765625 27172.039063 2984.240967 281.697906 81.949226 26.873539 6.782843 1.647438 0.344318 0.155223 0.578934 2.386544 12.825811 61.552113 175.654175 213.188416 99.631714 23.489269 258.002411 53.459141 6.783362 0.174658 -0.630965 -0.735446 -0.768520 -0.760909 -0.558803 0.813957 8.758088 44.940742 186.672531 471.774597 462.972595 225.714264 229.567276 181.456390 64.514442 18.717869 7.740808 3.034171 1.440451 1.568817 3.295998 12.663566 55.990704 155.703033 176.123566 82.935013 20.588772 53.272400 16.279823 3.019525 -0.142221 -0.715470 -0.794381 -0.818529 -0.816603 -0.760949 -0.405391 1.188374 6.157598 18.005848 33.314457 50.454498 120.222046 273.822174 256.624268 165.541718 169.633652 98.510925 25.742476 5.801553 2.450079 3.173655 8.536655 26.845247 58.095608 67.114326 34.818176 9.973701 68.255463 27.608681 6.845895 0.708906 -0.597051 -0.797229 -0.827823 -0.836149 -0.827156 -0.776605 -0.490775 0.329606 2.217852 5.904771 16.914383 58.474739 158.853882 404.412933 2702.999023 7700.813965 3075.906982 307.084503 27.164219 4.028676 3.234568 7.530138 15.681101 22.127523 19.071634 10.217369 3.872376 948.328064 321.233002 53.193615 6.127841 -0.042550 -0.755055 -0.827545 -0.838323 -0.841392 -0.847196 -0.824565 -0.692996 -0.293595 0.917305 5.620326 27.520905 176.892075 2874.403809 101681.070313 101435.320313 100395.679688 3364.718506 103.615906 7.522212 4.667311 12.756086 26.524530 30.032421 17.143240 6.124019 2.234157 50802.425781 8522.875000 475.244263 27.537350 1.421062 -0.643965 -0.804849 -0.816123 -0.810077 -0.822310 -0.843034 -0.822005 -0.708896 -0.183337 3.160638 31.857130 411.244171 9656.993164 119298.679687 116017.867187 102263.734375 10321.054687 182.386627 11.327165 6.989834 19.801800 41.503883 46.099449 24.410772 7.171429 1.842677 107831.476562 100326.593750 2560.004883 69.879021 3.311035 -0.482768 -0.714530 -0.672174 -0.649022 -0.666302 -0.646921 -0.420391 -0.004281 0.471536 3.496632 37.167187 532.583618 8941.656250 151305.046875 141926.953125 104335.257813 3592.296631 118.323029 10.402436 7.520561 17.911024 35.174500 38.421680 20.242695 5.849757 1.359415 103977.484375 100231.421875 2554.823242 74.073601 3.351431 -0.182910 -0.067488 0.218728 0.196864 -0.003114 0.249298 2.040819 5.317997 6.490392 6.694175 31.477819 310.467468 3077.575928 16928.908203 20251.382813 5028.016113 488.255127 44.750050 7.248990 6.054419 9.954943 15.400479 16.034266 8.682696 3.470717 2.669216 54634.179688 10197.374023 502.893890 28.357412 2.115934 1.766416 5.123137 7.783041 6.767240 3.386025 3.335181 12.413988 31.306501 38.569237 21.805777 32.721031 259.901367 2278.647217 9483.827148 8676.148437 2364.065430 338.846710 39.662788 6.254301 3.938633 5.506949 7.577557 8.139976 6.421895 8.758697 27.733866 795.867493 306.236847 51.490288 6.571687 3.403670 15.165331 50.931259 93.447136 69.197220 26.585897 11.516091 32.373653 102.128571 126.350990 57.802544 45.828671 404.921753 7021.900391 107695.460937 104501.648438 70385.835938 2700.715088 134.419846 10.439401 5.177423 15.196345 37.469296 53.521832 40.803738 65.892654 422.580627 34.310074 19.784042 6.986383 3.314538 12.665131 93.335518 478.009918 1133.318726 731.216553 176.865219 32.654133 41.372585 117.434174 145.368393 66.647583 59.118668 706.877258 34922.585938 101562.421875 101033.148438 100207.765625 14623.657227 321.193481 19.253149 20.708923 128.141068 551.705811 917.496155 464.582916 482.666077 7874.722168 15.907768 14.563193 10.109544 6.949710 33.097046 339.366333 3103.796631 10168.007812 5538.129395 786.971375 77.667267 25.345741 50.190544 61.396515 36.950569 83.666634 1058.387573 34286.191406 106159.203125 102356.578125 100330.617188 13359.724609 301.753052 23.112072 78.953957 978.353516 9312.869141 21249.544922 6466.433594 3147.369629 87600.710938 51.439842 49.278770 31.758030 14.870255 42.990147 512.925720 5537.210449 21183.511719 10168.729492 1222.676270 95.916283 13.630348 11.716121 13.494673 21.583563 217.243286 4503.299805 103987.851563 186165.781250 162911.203125 53667.828125 2209.946289 122.909424 21.208561 176.221558 3655.031738 69803.742188 100460.664063 50449.566406 99017.812500 191781.750000 102.816803 105.237320 62.575035 22.301130 29.419189 243.404480 1929.641724 5537.583496 3105.164307 515.543518 58.985886 11.322264 5.333580 4.462051 22.542471 394.862152 16041.840820 100279.359375 101451.710938 102670.562500 8952.646484 418.188171 36.398777 15.084641 165.182724 2870.486816 51299.554688 102005.164063 131395.625000 102406.726563 109586.992187 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001180 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001284 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001358 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001417 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001023 -0.001023 -0.001001 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001023 -0.001044 -0.001437 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001116 -0.002245 -0.002356 -0.003450 -0.005065 -0.004191 -0.004354 -0.004443 -0.004432 -0.004310 -0.004119 -0.002892 -0.001271 -0.001160 -0.001044 -0.001008 -0.001104 -0.001176 -0.001236 -0.001262 -0.001427 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001188 -0.002329 -0.002613 -0.004484 -0.007236 -0.007832 -0.008323 -0.008672 -0.007389 -0.007549 -0.007554 -0.006319 -0.006130 -0.007409 -0.005407 -0.004912 -0.003393 -0.004059 -0.002455 -0.002389 -0.001404 -0.001475 -0.001518 -0.001377 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001205 -0.002726 -0.006931 -0.007650 -0.008303 -0.011669 -0.012588 -0.013372 -0.012863 -0.013337 -0.014114 -0.014414 -0.012832 -0.012736 -0.012298 -0.010587 -0.009882 -0.008999 -0.009123 -0.008273 -0.006555 -0.004521 -0.002882 -0.002742 -0.001779 -0.001302 0.000000 0.000000 0.000000 0.000000 -0.002719 -0.005573 -0.009207 -0.010317 -0.013862 -0.015389 -0.016841 -0.018171 -0.019320 -0.020987 -0.021989 -0.022628 -0.021807 -0.020511 -0.021454 -0.019153 -0.016704 -0.015305 -0.013825 -0.012499 -0.011140 -0.009870 -0.009164 -0.008374 -0.004932 -0.004759 -0.001214 0.000000 0.000000 -0.003564 -0.005430 -0.007315 -0.010335 -0.011888 -0.015994 -0.018184 -0.020412 -0.022533 -0.026345 -0.028494 -0.030468 -0.033529 -0.033632 -0.034456 -0.033242 -0.033548 -0.030985 -0.027523 -0.025190 -0.023640 -0.020026 -0.017879 -0.017368 -0.015632 -0.012242 -0.011174 -0.007270 0.000000 0.000000 -0.002641 -0.005765 -0.006891 -0.011166 -0.013172 -0.016839 -0.020738 -0.023827 -0.027086 -0.032175 -0.035739 -0.040926 -0.044366 -0.047506 -0.051511 -0.053887 -0.053242 -0.052075 -0.048859 -0.044181 -0.039657 -0.035394 -0.032563 -0.029069 -0.025660 -0.019933 -0.017603 -0.014655 -0.012204 -0.001140 -0.002726 -0.005874 -0.007207 -0.011583 -0.014007 -0.018133 -0.022743 -0.026793 -0.031284 -0.037846 -0.044753 -0.052321 -0.058651 -0.067626 -0.074480 -0.081559 -0.083281 -0.084235 -0.080605 -0.075792 -0.070046 -0.062759 -0.052943 -0.047176 -0.039388 -0.033655 -0.028826 -0.024815 -0.019973 -0.016750 -0.002691 -0.005718 -0.007172 -0.009970 -0.014207 -0.017405 -0.023896 -0.028857 -0.034549 -0.042679 -0.053163 -0.063280 -0.074156 -0.086367 -0.098285 -0.110606 -0.118360 -0.123975 -0.124365 -0.119826 -0.113596 -0.104866 -0.098650 -0.081947 -0.070900 -0.056236 -0.045747 -0.038059 -0.033101 -0.028251 -0.021706 -0.003260 -0.008300 -0.010187 -0.015365 -0.018805 -0.024449 -0.031128 -0.036427 -0.047113 -0.060888 -0.073759 -0.088816 -0.104470 -0.122786 -0.140188 -0.149688 -0.153803 -0.153645 -0.152566 -0.151376 -0.143928 -0.136922 -0.126600 -0.117937 -0.100066 -0.082432 -0.066027 -0.051286 -0.042181 -0.034157 -0.028750 -0.008002 -0.009936 -0.014772 -0.019854 -0.024305 -0.032406 -0.039522 -0.049486 -0.063684 -0.080333 -0.096992 -0.119503 -0.140782 -0.160005 -0.171546 -0.176163 -0.175722 -0.171213 -0.153101 -0.132844 -0.138015 -0.150111 -0.154653 -0.146299 -0.129373 -0.115043 -0.096112 -0.075247 -0.054351 -0.044473 -0.037064 -0.010951 -0.013404 -0.018566 -0.024625 -0.031566 -0.039992 -0.051855 -0.065089 -0.084209 -0.104712 -0.127144 -0.152667 -0.174075 -0.189029 -0.188044 -0.160497 -0.089188 0.071701 0.320179 0.560179 0.524103 0.218979 -0.044077 -0.151723 -0.160625 -0.149002 -0.129131 -0.102969 -0.080782 -0.062618 -0.050946 -0.014084 -0.018108 -0.023105 -0.030011 -0.038339 -0.050942 -0.061432 -0.082218 -0.104768 -0.129987 -0.158112 -0.183868 -0.202277 -0.193094 -0.081469 0.249115 0.931485 2.413360 5.584203 9.949676 9.752610 4.978318 1.347437 0.094594 -0.165485 -0.180945 -0.167153 -0.139881 -0.108976 -0.082937 -0.066862 -0.018650 -0.023287 -0.028104 -0.035874 -0.047673 -0.058800 -0.075361 -0.098669 -0.127480 -0.155455 -0.183129 -0.208954 -0.218043 -0.073304 0.613002 2.797225 7.312127 19.633604 69.556030 195.509430 215.348999 76.751038 14.341648 1.846974 0.008654 -0.200150 -0.197585 -0.178378 -0.143137 -0.114212 -0.092981 -0.021394 -0.026662 -0.032081 -0.040620 -0.053948 -0.067466 -0.091902 -0.115592 -0.145204 -0.177050 -0.208987 -0.238543 -0.194043 0.318026 3.066689 13.820323 39.473652 139.408249 1222.473022 9339.115234 12411.554688 1819.283936 129.056168 9.452978 0.583477 -0.194040 -0.235203 -0.214144 -0.176927 -0.145124 -0.119125 -0.025449 -0.029940 -0.038822 -0.050886 -0.063594 -0.079988 -0.105605 -0.131772 -0.164762 -0.200971 -0.234010 -0.258808 -0.153461 0.891539 7.809916 40.539410 128.365189 660.712341 21244.066406 100983.476563 100418.343750 48401.015625 802.878723 29.369982 1.717820 -0.165809 -0.276829 -0.255230 -0.219386 -0.182591 -0.156149 -0.035016 -0.037900 -0.044404 -0.056906 -0.069349 -0.092308 -0.117821 -0.144463 -0.177715 -0.218553 -0.257081 -0.293005 -0.176287 1.148456 9.951484 53.079384 187.196396 1174.850952 77998.757813 102872.000000 100980.726563 100147.445313 1538.472778 43.022514 2.246158 -0.175051 -0.335655 -0.306299 -0.270618 -0.230550 -0.202134 -0.046184 -0.049097 -0.055911 -0.063987 -0.082980 -0.103109 -0.127389 -0.157557 -0.195269 -0.235997 -0.281160 -0.325311 -0.260028 0.601026 5.984122 30.291842 110.338135 643.364258 13674.078125 101935.898438 100684.421875 28179.201172 595.135071 25.547518 1.525507 -0.278494 -0.410080 -0.380270 -0.336578 -0.289690 -0.254197 -0.060534 -0.065439 -0.071096 -0.080583 -0.095431 -0.114064 -0.138793 -0.170324 -0.207478 -0.258164 -0.308570 -0.358464 -0.359834 -0.012762 1.895898 9.602471 34.072929 150.766098 883.154785 4351.428711 4928.989746 971.302307 91.563522 8.035137 0.414374 -0.436100 -0.500500 -0.465719 -0.413572 -0.355531 -0.313190 -0.078538 -0.081724 -0.084815 -0.092641 -0.108452 -0.126230 -0.155692 -0.186411 -0.225457 -0.275809 -0.336100 -0.389599 -0.406958 -0.193166 1.040949 4.883144 14.485338 36.895061 90.883865 155.097916 141.129913 53.765953 11.795467 1.664997 -0.268251 -0.578222 -0.589941 -0.547285 -0.490983 -0.428700 -0.379878 -0.104526 -0.099935 -0.101887 -0.108749 -0.121903 -0.140476 -0.168128 -0.205123 -0.244420 -0.298213 -0.356288 -0.407560 -0.326170 0.653876 6.845238 33.472786 93.581596 190.927780 392.364807 378.416321 154.894806 33.953815 6.107215 0.845878 -0.296671 -0.572423 -0.630337 -0.614175 -0.547475 -0.470036 -0.398872 -0.127486 -0.123193 -0.122721 -0.125365 -0.144087 -0.161225 -0.188570 -0.222208 -0.264512 -0.314549 -0.375895 -0.403524 -0.020944 4.193136 47.504066 383.891846 1598.524048 3535.255615 16224.014648 17587.169922 3112.921875 249.737061 27.381744 6.548956 2.481461 0.416820 -0.399454 -0.574021 -0.460637 -0.197069 0.130758 -0.154916 -0.148984 -0.146996 -0.154655 -0.170021 -0.188905 -0.211273 -0.245792 -0.289899 -0.347500 -0.404253 -0.394110 0.431811 11.824080 180.716110 3077.250000 23951.730469 73407.500000 101533.640625 100135.828125 77572.992188 1734.228516 143.313507 78.822350 37.963074 9.972448 1.416738 0.035430 0.577601 2.974026 6.629580 -0.192309 -0.182319 -0.179825 -0.191619 -0.199445 -0.213749 -0.239242 -0.275985 -0.320920 -0.383110 -0.439228 -0.421356 0.626468 15.100569 258.439178 5797.263672 63133.281250 138785.281250 102684.781250 101031.812500 102480.328125 5513.701660 1590.074951 1934.836670 682.017395 96.870224 11.524835 3.025365 8.201177 36.337727 105.960297 -0.239782 -0.224103 -0.219704 -0.217651 -0.226315 -0.243564 -0.266808 -0.307812 -0.358668 -0.417655 -0.475830 -0.483153 0.181039 8.728502 120.372864 1453.417969 9667.951172 76124.414063 102217.437500 134400.515625 195986.125000 104061.867188 46624.769531 100273.843750 14839.541016 691.216797 46.198414 14.228148 58.700943 516.064819 2866.427002 -0.293560 -0.268069 -0.250517 -0.247931 -0.236528 -0.236140 -0.254784 -0.305844 -0.373611 -0.447697 -0.512083 -0.550041 -0.308796 2.294723 23.219563 154.141098 634.372437 3659.994141 31916.998047 125719.757812 104359.601563 108842.812500 151364.750000 100989.539063 100207.406250 2149.107178 108.527679 44.935230 302.908539 6602.484863 100030.648438 -0.347373 -0.314019 -0.278244 -0.234752 -0.119531 0.022110 0.094691 -0.041334 -0.260004 -0.437182 -0.519883 -0.548409 -0.518939 0.050967 3.284833 16.479895 64.886101 391.963287 9779.875000 100585.179688 100618.648438 104797.750000 163162.531250 101533.843750 46549.937500 1687.810181 167.302200 118.151222 999.673767 38580.804688 100643.000000 -0.401554 -0.357264 -0.277935 -0.031797 0.633544 1.693842 2.256605 1.612863 0.434999 -0.239036 -0.411886 -0.422859 -0.349454 0.137201 2.535006 9.688588 24.734829 114.264389 1828.030884 51305.894531 100242.804688 100821.312500 12323.932617 10637.072266 4238.271973 1030.401733 209.724701 452.889069 6152.463867 65211.433594 137922.781250 -0.457158 -0.379862 -0.154710 0.698235 3.415921 9.373892 13.146225 8.662672 2.952188 0.420049 -0.128683 -0.051632 0.503021 3.932828 26.621954 137.472107 346.070465 278.401001 256.901062 1353.948486 4034.542969 2589.104004 849.441895 961.611816 1131.975708 490.709686 193.475281 2014.715942 100293.703125 102607.570313 131323.421875 -0.493931 -0.345923 0.171954 2.156032 9.908855 28.979002 41.319241 26.766750 8.147655 1.484101 0.311394 0.778375 3.406468 23.706518 275.990143 4372.832520 28095.974609 13649.524414 1117.187744 135.165283 138.484177 146.377548 196.365952 283.265533 238.769363 123.644028 150.258865 3428.309814 100175.710938 100549.234375 103660.390625 -0.501920 -0.232637 0.658076 3.689524 14.234073 42.604645 64.477943 41.207973 11.608479 2.269681 1.084898 3.421921 14.992230 106.997299 1902.460327 100593.703125 100448.242188 100129.398438 13656.057617 264.158936 26.387838 35.631752 85.204018 103.583473 62.365551 29.998886 72.029091 1347.885742 51329.500000 101495.453125 169837.171875 -0.492564 -0.127856 1.094433 4.162938 12.295710 29.526863 42.317043 25.487368 8.267391 2.239880 4.691190 20.168844 78.303894 433.532806 5492.380371 111149.773437 107167.992187 101055.687500 31319.960938 377.205475 17.309299 10.079628 21.561003 25.053329 14.503219 6.956295 21.195183 199.691574 2031.932129 13048.291992 109315.562500 -0.335729 -0.059927 1.035964 3.478039 6.968868 11.232181 12.996060 8.559818 3.268247 4.006490 26.083803 154.000427 750.654114 2871.850342 17251.111328 131036.976562 151268.250000 103973.539063 4964.827148 171.523682 9.868861 1.803249 2.917729 3.151425 1.796120 0.845431 4.084703 27.048227 159.816193 1665.627563 69999.789063 0.704062 0.234950 0.559480 1.812317 2.995342 3.375289 2.848397 1.684007 1.539241 11.339053 116.722374 1212.679321 11063.135742 94594.625000 100843.429688 77120.804688 41190.402344 5346.911621 497.044891 42.066505 3.820379 -0.107676 -0.485069 -0.511467 -0.624738 -0.554770 0.389089 4.506540 27.433184 256.955139 3116.822021 5.085491 1.804514 0.354186 0.379052 0.648531 0.605404 0.215928 0.007864 1.692814 22.208010 308.253387 5409.858398 83167.164063 156947.546875 108836.445312 39721.035156 4755.952148 776.174316 97.475655 12.093469 1.228707 -0.582635 -0.927423 -0.975439 -0.882893 -0.490181 0.533844 2.382293 6.659738 31.056301 146.349686 15.677881 5.068543 0.648047 -0.239714 -0.332045 -0.381870 -0.484318 -0.392174 1.504417 23.061804 321.064636 5591.548340 73065.382813 169849.234375 108761.226562 15719.847656 812.218811 170.866928 41.679989 8.079695 1.060913 -0.251123 -0.631328 -0.794743 -0.673879 0.186433 2.454096 5.450222 6.890122 7.139131 12.155695 21.855717 7.130057 0.889058 -0.426159 -0.641565 -0.667871 -0.688399 -0.572446 0.666761 12.353262 129.560501 1334.130615 7856.283691 16293.541992 9707.293945 1913.799316 1043.948608 758.732422 179.229156 27.126154 5.159564 2.221833 0.993950 -0.002607 -0.237173 0.857517 4.458592 9.655993 11.189270 7.570331 3.872726 16.252550 5.629745 0.857729 -0.471872 -0.725620 -0.758816 -0.762060 -0.690325 -0.181666 3.507999 28.305454 157.325485 533.763977 881.388123 886.003723 1834.197510 7707.743164 6360.888672 934.608948 89.977531 20.671492 11.611718 6.257902 1.973697 0.409712 0.965162 4.144552 8.885665 10.457064 7.530325 4.096882 26.531559 10.409657 2.324422 -0.132453 -0.694507 -0.781949 -0.797727 -0.777985 -0.639926 0.283687 4.577192 20.430220 60.314308 140.722687 366.083466 2553.420166 14861.344727 12262.616211 1480.057129 227.881012 86.542107 40.717033 17.842159 5.561587 1.273890 0.816457 2.402134 4.752279 5.892450 5.111224 4.203706 177.082169 52.048668 10.941882 1.286350 -0.498023 -0.785904 -0.816706 -0.822615 -0.800920 -0.621616 0.176079 2.879260 10.988832 33.495419 123.230469 828.616333 3492.327637 3010.653076 1710.788940 1983.524292 822.132446 165.280426 35.954704 9.333426 2.569295 1.359042 1.669853 2.336388 2.676067 2.737435 2.898792 1460.353027 269.360565 42.497696 5.376955 -0.037866 -0.752854 -0.828440 -0.841808 -0.843439 -0.828919 -0.686443 -0.144854 1.611795 7.016445 28.702469 138.493759 603.319275 4055.776123 27143.359375 58078.414063 13334.696289 882.384033 73.043365 12.993857 6.230127 4.545998 3.433822 2.590796 1.703529 1.157234 1.462160 16330.685547 1469.114746 150.467484 14.712986 0.796827 -0.675030 -0.819977 -0.847751 -0.851629 -0.862768 -0.806329 -0.592687 -0.055944 1.516892 9.574948 85.992126 1524.353760 58046.222656 138976.265625 200136.953125 76604.539063 2515.948730 116.638138 22.043276 19.417221 14.858665 8.255682 4.370898 1.936030 0.510229 0.444692 95384.101563 6279.472168 397.427887 26.507713 1.585572 -0.616316 -0.793753 -0.802885 -0.819910 -0.758485 -0.359406 0.965683 3.266368 4.714614 10.302938 100.383095 2523.797119 100766.039063 109738.984375 143671.796875 98572.414063 2174.002197 113.292786 38.967766 47.202461 35.767906 15.643426 5.617808 1.798024 0.228427 -0.001061 53560.511719 6376.092773 376.862396 24.781065 1.473834 -0.520909 -0.592319 -0.530511 -0.517804 -0.179700 2.680847 15.592553 43.506752 54.637436 33.987503 88.276451 1374.509277 38485.707031 122653.859375 112554.085937 21073.664063 834.010925 69.761520 43.816460 62.545704 47.156296 18.416588 5.362530 1.440730 0.537866 1.399895 4814.288086 1019.025696 123.975716 11.759936 0.950145 0.095813 0.732318 1.329525 1.132532 1.912340 15.842504 125.190681 537.837585 683.997620 237.983841 117.980293 1483.885254 58489.609375 108775.695312 108289.601562 9603.750977 496.920929 52.342976 29.202961 39.886272 29.537563 13.665586 5.253668 2.741709 5.305289 19.369408 296.170532 101.163124 24.628252 5.654404 1.854478 3.116280 8.550956 13.420815 11.010578 8.342068 44.409889 536.707703 3962.759766 5224.605469 1129.270508 206.914383 1580.578491 65300.167969 128551.789062 177727.781250 26000.001953 1397.404053 97.460770 16.269585 14.719783 15.235014 15.419195 15.259322 14.520750 39.659954 230.577332 37.401810 28.407513 19.820114 10.419277 6.018287 13.589008 45.277378 77.514900 57.642826 25.318441 54.146072 678.232788 5214.001465 7604.424316 1565.078613 219.295853 843.145386 16299.283203 137307.281250 118253.921875 101540.039063 5191.079102 185.141739 14.942024 9.536866 27.984200 76.981422 106.562279 90.576637 232.445496 3134.149658 109.380135 128.428833 83.198410 30.338562 13.269326 35.356270 135.843323 277.153564 199.588959 59.841526 34.226826 206.688095 1096.916138 1412.202393 428.513672 172.784088 1206.754761 16308.902344 115574.632812 105345.601563 100678.929688 4749.444824 183.748917 13.964602 18.899576 114.375618 452.672241 766.205872 547.084656 1094.849121 21618.193359 693.966553 870.750916 458.461731 102.178993 23.244030 47.782272 187.124237 388.547455 277.303009 78.524208 19.542475 33.882286 97.126144 122.979446 77.859695 356.576141 10352.431641 101913.539063 119812.851562 157122.281250 18528.945313 1186.180420 83.725082 10.378014 32.924728 262.516968 1339.823242 2645.535400 2977.217041 10269.269531 32702.828125 2192.511963 3407.622803 1429.328003 232.786942 32.355072 30.181543 105.885498 199.537033 145.199509 47.045216 12.659143 8.315042 10.844587 12.910621 37.424362 696.784180 41941.414063 100478.968750 101418.281250 101687.734375 19975.597656 492.799408 35.581070 6.683941 29.446163 235.155212 1210.827515 3027.152832 15347.003906 104334.273438 104809.609375 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001180 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001311 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001427 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001510 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001037 -0.001089 -0.001112 -0.001576 -0.001124 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001015 -0.001008 0.000000 -0.001015 -0.001015 -0.000994 0.000000 0.000000 0.000000 0.000000 -0.001097 -0.001201 -0.001289 -0.001355 -0.001384 -0.001598 -0.001140 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001124 -0.001222 -0.003952 -0.004167 -0.004311 -0.005378 -0.006998 -0.005570 -0.005654 -0.004585 -0.004571 -0.004454 -0.004241 -0.003957 -0.002726 -0.002196 -0.002230 -0.001336 -0.001475 -0.001585 -0.001667 -0.001703 -0.001587 -0.001132 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001214 -0.004333 -0.006966 -0.007512 -0.007923 -0.010767 -0.011301 -0.010587 -0.009632 -0.009815 -0.009806 -0.011217 -0.009491 -0.008088 -0.007765 -0.007292 -0.007767 -0.005724 -0.004485 -0.002861 -0.002853 -0.003327 -0.003489 -0.003581 -0.001532 0.000000 0.000000 0.000000 0.000000 -0.002445 -0.005657 -0.006405 -0.009481 -0.010393 -0.012633 -0.013573 -0.014579 -0.015373 -0.015977 -0.018001 -0.018232 -0.017143 -0.015783 -0.015360 -0.013108 -0.012347 -0.011403 -0.010673 -0.009878 -0.009035 -0.008756 -0.006771 -0.005229 -0.005217 -0.004336 -0.001447 0.000000 0.000000 0.000000 -0.005051 -0.007527 -0.009737 -0.011136 -0.012511 -0.016401 -0.018205 -0.019839 -0.021247 -0.024170 -0.025287 -0.025031 -0.026864 -0.027060 -0.026653 -0.023553 -0.023527 -0.022080 -0.020112 -0.017434 -0.016281 -0.016595 -0.015533 -0.013530 -0.011855 -0.008222 -0.008046 -0.001339 0.000000 -0.002455 -0.005479 -0.008185 -0.010728 -0.012607 -0.014578 -0.019204 -0.021818 -0.024420 -0.026909 -0.031062 -0.034926 -0.040132 -0.041887 -0.042973 -0.041628 -0.041383 -0.040215 -0.038643 -0.035961 -0.031765 -0.029219 -0.027083 -0.023474 -0.021488 -0.018442 -0.016894 -0.014794 -0.013834 -0.001214 -0.002594 -0.005702 -0.006980 -0.011344 -0.013703 -0.016280 -0.020638 -0.025291 -0.029105 -0.036121 -0.040547 -0.047817 -0.052145 -0.056045 -0.059152 -0.063616 -0.066183 -0.065995 -0.061641 -0.057560 -0.054944 -0.049120 -0.042706 -0.038479 -0.033222 -0.029710 -0.027569 -0.022187 -0.019276 -0.017694 -0.002612 -0.005682 -0.007116 -0.010580 -0.014219 -0.017396 -0.022491 -0.028079 -0.033263 -0.042150 -0.048577 -0.058483 -0.065758 -0.073988 -0.081743 -0.090274 -0.095021 -0.097718 -0.097645 -0.094121 -0.089618 -0.083632 -0.076213 -0.068171 -0.055975 -0.048952 -0.041601 -0.036598 -0.032447 -0.028866 -0.021116 -0.004358 -0.006925 -0.008783 -0.014152 -0.017714 -0.021971 -0.029814 -0.036396 -0.045424 -0.057127 -0.068670 -0.081871 -0.093357 -0.104823 -0.120246 -0.131172 -0.137899 -0.140639 -0.139587 -0.135330 -0.132904 -0.123789 -0.113846 -0.098597 -0.082283 -0.068531 -0.058109 -0.048868 -0.039960 -0.034765 -0.030375 -0.006463 -0.008360 -0.012450 -0.017243 -0.021892 -0.029191 -0.037758 -0.048398 -0.060893 -0.077593 -0.093884 -0.113052 -0.130126 -0.149612 -0.160967 -0.168086 -0.172654 -0.172700 -0.170111 -0.170645 -0.167054 -0.159597 -0.147170 -0.135935 -0.120268 -0.099733 -0.081504 -0.064453 -0.054774 -0.045942 -0.038598 -0.008983 -0.011419 -0.017430 -0.022259 -0.028314 -0.038689 -0.048881 -0.064185 -0.082314 -0.101930 -0.125492 -0.147660 -0.167596 -0.183446 -0.195042 -0.196162 -0.188441 -0.172150 -0.145869 -0.129393 -0.137202 -0.166368 -0.178576 -0.166450 -0.149668 -0.136578 -0.110496 -0.090479 -0.071126 -0.057775 -0.048019 -0.010506 -0.013513 -0.020540 -0.026513 -0.035741 -0.047251 -0.063108 -0.083928 -0.105670 -0.132980 -0.155587 -0.179780 -0.198868 -0.207006 -0.175432 -0.063326 0.130186 0.374629 0.671265 0.825983 0.658919 0.261617 -0.046336 -0.169746 -0.182567 -0.166233 -0.148008 -0.119333 -0.093970 -0.077442 -0.060930 -0.012136 -0.018162 -0.025382 -0.032614 -0.043914 -0.059064 -0.079418 -0.102453 -0.129781 -0.158027 -0.184748 -0.206399 -0.216880 -0.131638 0.294006 1.573856 3.560941 5.990560 9.400853 12.716321 10.521262 5.047841 1.400778 0.102969 -0.184546 -0.201540 -0.184927 -0.158355 -0.126370 -0.099138 -0.080258 -0.016590 -0.022052 -0.030139 -0.039886 -0.055248 -0.071151 -0.096679 -0.124115 -0.151325 -0.179501 -0.203982 -0.230547 -0.171216 0.393759 3.550676 15.356812 38.613083 59.902588 117.358383 206.249969 187.700729 69.103325 13.290603 1.807976 0.007287 -0.222714 -0.217451 -0.192319 -0.159082 -0.131596 -0.105238 -0.018756 -0.024853 -0.034860 -0.046177 -0.062255 -0.080804 -0.111774 -0.138666 -0.164587 -0.194672 -0.223600 -0.230247 0.018071 2.265557 20.931091 129.881805 434.060181 639.960999 1818.517822 6183.758789 6828.801270 1188.680420 102.298592 9.434912 0.681917 -0.198131 -0.259069 -0.236208 -0.198704 -0.161580 -0.135606 -0.023060 -0.029605 -0.039296 -0.054385 -0.069388 -0.094611 -0.122131 -0.150357 -0.179902 -0.215505 -0.247028 -0.232062 0.264470 5.863109 69.363594 689.862122 3465.087402 4879.081055 29837.541016 137927.968750 107170.460937 21044.636719 542.423645 27.570206 2.013033 -0.104249 -0.298256 -0.280772 -0.245508 -0.203240 -0.168786 -0.031121 -0.034817 -0.044948 -0.058297 -0.078502 -0.100642 -0.132032 -0.159456 -0.190572 -0.231680 -0.271859 -0.259696 0.323163 7.404218 90.653046 1113.237915 6049.221680 12368.125000 128742.679687 200068.578125 134349.453125 77380.031250 1019.499634 42.649155 3.256596 -0.007527 -0.339540 -0.337118 -0.295331 -0.250305 -0.215362 -0.039455 -0.042811 -0.053577 -0.065352 -0.089198 -0.110781 -0.138818 -0.165819 -0.203659 -0.248456 -0.295109 -0.311519 0.067793 4.306746 44.693222 383.935455 1758.979004 5799.656738 69415.992188 200048.453125 117609.523437 13369.863281 482.002991 32.721973 3.105617 -0.036860 -0.407996 -0.402157 -0.359741 -0.309520 -0.263816 -0.050012 -0.052055 -0.061327 -0.078115 -0.095410 -0.115260 -0.140339 -0.175091 -0.220302 -0.267960 -0.322887 -0.361787 -0.239268 1.182959 11.269242 60.562325 221.783340 846.000061 4748.721680 8921.608398 4599.346191 852.688232 107.306892 15.151418 1.909336 -0.217082 -0.495116 -0.488413 -0.428701 -0.373097 -0.322721 -0.065748 -0.068272 -0.073805 -0.085438 -0.107617 -0.127289 -0.154587 -0.183183 -0.232661 -0.290593 -0.345906 -0.406439 -0.377779 0.201508 3.353033 13.711597 38.021606 100.925209 274.809967 368.053741 238.433365 85.659492 24.129349 5.279164 0.529624 -0.451059 -0.598647 -0.573863 -0.502376 -0.439438 -0.383922 -0.086460 -0.083481 -0.089456 -0.097564 -0.114467 -0.137434 -0.162292 -0.202037 -0.252704 -0.309970 -0.371460 -0.417763 -0.247595 1.652670 16.322372 92.280663 253.934143 278.673218 243.605606 210.261536 95.093925 28.952995 7.745087 1.648638 -0.126902 -0.587376 -0.666660 -0.637295 -0.567237 -0.478340 -0.398563 -0.107877 -0.102253 -0.106355 -0.110498 -0.123698 -0.150173 -0.181646 -0.218006 -0.265600 -0.322094 -0.387728 -0.394695 0.329426 9.680694 144.479355 2145.140625 13730.973633 10976.750000 4975.221191 4380.242187 1065.154541 127.393280 17.414061 4.071869 1.031118 -0.190799 -0.598106 -0.630245 -0.483579 -0.177081 0.185802 -0.131368 -0.129685 -0.123412 -0.134855 -0.148042 -0.166503 -0.200809 -0.235200 -0.284861 -0.343365 -0.406867 -0.356100 1.259099 29.461273 794.146057 48356.636719 100478.421875 110170.320312 115084.585937 100353.492188 13403.404297 654.785950 78.949997 29.377987 12.563354 3.317768 0.165527 -0.274819 0.552967 3.097904 7.387672 -0.163413 -0.154775 -0.151057 -0.159547 -0.172210 -0.189383 -0.221251 -0.258533 -0.312324 -0.371215 -0.433108 -0.358251 1.672382 37.968521 1290.449829 100045.406250 100909.867188 131126.734375 134887.531250 101072.914063 47885.761719 2309.927734 491.878540 281.392700 116.479118 23.905607 3.554302 1.514285 8.365147 40.446602 119.863228 -0.202626 -0.189857 -0.184095 -0.186481 -0.193810 -0.214991 -0.240038 -0.283544 -0.335276 -0.398727 -0.467517 -0.439929 0.848048 20.216394 428.357513 15105.559570 100517.890625 111179.843750 106650.750000 116352.406250 110983.984375 43395.808594 4883.868652 2664.448242 875.825806 112.630371 13.313297 8.123657 62.379032 591.600952 3653.353760 -0.250644 -0.228920 -0.219965 -0.213287 -0.218144 -0.237767 -0.265102 -0.308069 -0.365574 -0.431045 -0.500696 -0.540809 -0.093079 5.152043 60.620571 591.161926 2449.927734 3006.333252 9801.861328 106421.773437 105589.000000 106280.429688 30048.531250 10817.921875 2694.603027 241.366730 26.319382 26.042419 349.854828 9322.002930 100016.484375 -0.305063 -0.274683 -0.255222 -0.240911 -0.225913 -0.216277 -0.236309 -0.297900 -0.375122 -0.460544 -0.536293 -0.604703 -0.548869 0.394366 6.270264 31.447212 92.834038 303.044769 5063.368652 101886.171875 112307.289062 116441.960937 31631.949219 6212.674805 1695.182007 192.989395 32.196774 65.200905 953.550842 56985.324219 100244.757813 -0.356769 -0.320671 -0.289687 -0.238488 -0.144753 -0.033863 0.013613 -0.104906 -0.301921 -0.459980 -0.557948 -0.623682 -0.624401 -0.213180 1.733657 7.414450 20.278908 98.835007 1260.114258 22148.111328 104749.867188 69037.960938 5925.261719 1066.196533 357.097900 91.715881 38.428642 182.947571 2106.485107 40892.355469 106038.757813 -0.410886 -0.371024 -0.314866 -0.172844 0.150387 0.598665 0.827656 0.514729 -0.037965 -0.390589 -0.547493 -0.576667 -0.288479 1.886956 14.513514 69.307968 158.305023 143.630386 225.518600 1100.551636 2940.857666 2160.723633 620.054626 174.909042 84.842979 41.530376 52.729477 654.449158 13507.995117 103130.976563 146370.437500 -0.466084 -0.420785 -0.309839 -0.036541 0.644364 1.806842 2.379579 1.570950 0.385843 -0.258312 -0.420154 -0.172863 1.255160 12.151860 130.428085 1296.021118 5723.188477 3318.721924 466.225616 155.884903 205.857483 164.790848 76.874672 38.437443 24.221281 16.722078 57.644688 987.983826 31163.115234 100344.257813 102229.843750 -0.511727 -0.456228 -0.302777 0.071070 0.987310 2.496478 3.233179 2.160796 0.646481 -0.018959 0.417799 2.540272 8.426816 43.881519 665.653809 20555.714844 100055.125000 96019.843750 3322.362305 150.161011 39.700172 24.254101 14.703853 10.073876 6.507677 5.886721 32.686466 452.695007 7205.163086 63582.281250 74322.695313 -0.554987 -0.483132 -0.316095 0.061333 0.759756 1.808125 2.267509 1.459095 0.531819 1.036189 6.500729 27.505135 71.853981 152.257202 1163.518799 48759.906250 100321.531250 100100.742188 6294.313965 171.841614 13.574813 4.357016 2.701897 2.015620 1.118840 1.357810 10.527883 92.828514 690.020508 3576.197754 64971.789063 -0.580929 -0.531303 -0.379958 -0.103365 0.249492 0.656352 0.772828 0.419187 0.640332 6.230958 50.379616 355.097534 1407.059326 1749.171265 1477.406128 7648.589355 49258.968750 22961.396484 1553.171753 82.216560 5.521835 0.249989 -0.311877 -0.412152 -0.561462 -0.375770 1.900756 14.699482 86.967506 786.709412 17664.316406 -0.502422 -0.537881 -0.483178 -0.337161 -0.174351 -0.096784 -0.129198 -0.097496 1.702784 23.305473 345.657501 6090.555176 70320.710938 98337.367188 13061.418945 2531.563965 1890.808472 887.451111 165.993942 19.838858 1.443631 -0.699701 -0.958716 -0.983389 -0.982595 -0.878659 -0.301681 2.422032 17.305666 143.667664 1323.668213 -0.174070 -0.432367 -0.548328 -0.520777 -0.467572 -0.453676 -0.470324 -0.219536 3.168178 51.980999 1231.183228 63000.089844 101495.750000 110161.945312 110317.156250 4133.564453 511.476562 138.207886 33.296059 5.934889 0.370539 -0.616176 -0.837240 -0.965306 -1.002683 -0.924280 -0.667367 0.091662 3.247035 20.138086 88.820709 0.462309 -0.158209 -0.529974 -0.625194 -0.616498 -0.611626 -0.600777 -0.266701 3.334434 55.075153 1325.467773 77584.484375 101005.929688 105809.093750 106550.859375 4490.980957 682.460205 303.091888 83.384445 15.148074 3.413599 1.766814 0.723631 -0.256289 -0.746304 -0.792832 -0.506081 0.119745 1.315174 4.062499 9.431004 1.560515 0.397727 -0.390509 -0.643464 -0.691070 -0.683159 -0.664924 -0.415930 1.772160 27.539757 422.688782 9361.096680 100503.148438 103502.671875 26041.595703 8330.534180 11939.595703 8437.355469 1176.713867 100.490738 22.650743 18.152136 10.705713 3.558273 0.265844 -0.491583 -0.168477 0.941718 3.477360 7.657263 10.540147 8.921019 3.828035 0.615501 -0.430953 -0.686536 -0.723969 -0.713827 -0.593600 0.274572 7.765737 69.180412 554.723450 2527.874512 6833.268066 19018.517578 39347.097656 101167.960938 100147.304688 13521.912109 454.497681 116.097809 118.436066 65.704750 19.122252 3.192280 0.089185 0.107994 1.973769 7.968877 20.580732 30.294422 99.741371 33.887314 6.915468 0.579362 -0.556352 -0.736120 -0.753340 -0.719817 -0.462513 1.224657 10.799562 55.907372 276.459167 1556.319824 5517.730957 73237.031250 100554.960938 100549.843750 27947.861328 1170.940186 453.011719 472.122009 232.195984 55.770264 9.164502 1.341879 0.428422 2.497663 11.168452 32.068409 48.133038 1286.363037 273.284180 36.262486 3.955973 -0.199746 -0.720008 -0.781776 -0.789519 -0.741188 -0.390273 1.418846 9.884702 50.985897 217.861008 829.483948 10398.609375 100516.328125 91680.468750 13355.259766 4350.008789 1209.948486 827.605225 356.448029 80.950699 17.015835 5.046765 1.768394 2.237794 8.335958 23.903887 33.887611 14184.729492 1513.520996 117.294960 10.608634 0.384080 -0.690424 -0.808980 -0.828545 -0.828780 -0.767507 -0.384903 1.308499 7.958850 28.824018 106.840561 646.206299 3018.680420 12736.102539 54587.519531 38522.355469 5000.060059 743.127319 237.045074 78.150078 43.780914 25.839815 9.624638 3.141713 3.924503 9.112875 12.934792 46590.589844 3117.621826 192.335541 15.606806 0.871238 -0.653152 -0.819799 -0.845844 -0.850155 -0.835367 -0.669841 -0.092402 1.400974 5.081957 21.080645 151.376190 2639.732178 102263.664063 105831.937500 103965.609375 70999.195313 1565.266479 163.255249 160.801498 238.735275 157.944992 46.698029 9.076729 2.113193 2.088383 2.761177 72534.195313 2208.242676 163.811279 15.203865 0.929487 -0.658235 -0.820314 -0.843897 -0.840370 -0.656615 0.398984 4.239528 11.004798 14.750487 20.298700 147.198792 4447.979980 100746.828125 102020.890625 101822.367188 100643.992188 2390.236328 209.017929 532.323120 1141.752441 638.101318 147.841599 21.955751 3.100701 0.308638 0.083811 26794.105469 944.553711 90.324875 10.183531 0.743424 -0.578667 -0.766689 -0.789000 -0.676960 0.416398 8.908610 60.320488 223.721252 287.473328 134.554016 156.415924 2324.300537 92370.757813 200148.671875 156783.375000 44819.406250 1158.310059 209.755112 796.773437 1794.444214 1062.818848 209.506836 32.406586 4.678259 0.544403 0.362952 2265.674072 228.727112 36.956192 8.504926 1.857853 -0.047742 -0.412407 -0.414052 -0.096820 3.994843 59.844929 860.800842 8364.713867 12411.958008 2126.620605 408.649414 3856.007812 103247.890625 115035.054687 112508.656250 32009.662109 683.362671 125.580299 397.672363 744.420532 470.893768 137.229858 30.105986 6.388488 2.881773 6.663713 175.669891 64.475456 46.130421 25.119299 8.293551 1.897133 0.904453 1.168909 1.514215 10.890492 220.336777 7590.215820 100051.210938 100245.117188 28673.496094 1340.399048 4672.238281 102532.781250 103406.867188 103518.882813 38240.339844 732.324402 70.600616 87.125786 144.006561 121.134338 62.729084 24.277807 9.386536 14.290513 58.677494 88.460648 148.750076 169.761612 93.627686 26.872328 6.538917 4.492264 5.736377 5.538517 14.129015 255.219223 11184.373047 100065.085938 100342.007813 49196.136719 1771.352783 2543.486816 28164.478516 111486.242187 117367.328125 9728.442383 734.908264 63.772648 20.036158 28.518183 36.747795 34.516994 25.345234 21.778366 60.705894 398.009277 679.704773 1087.277222 707.728333 238.871689 52.971874 11.877056 10.191444 14.298753 11.765295 11.200715 97.159706 1965.181641 28098.921875 43429.914063 5593.245605 736.790344 1494.609375 6808.818359 17575.123047 20845.492188 5917.734375 611.625305 57.806240 8.597552 8.979715 20.448875 39.991798 57.038960 79.468643 210.017914 1497.395264 10741.139648 23483.824219 7340.165039 781.388306 84.535805 14.490895 12.666157 17.919685 14.349239 7.959113 18.851568 145.939575 636.784912 832.560425 349.249329 348.896576 4280.870605 82760.476563 122814.140625 61009.761719 4589.540039 403.346069 39.791019 5.128082 5.996045 24.477474 76.110458 177.751511 449.429840 966.917297 2102.122070 93047.937500 100218.609375 62955.066406 2483.796875 134.015137 14.350155 8.493387 11.546338 9.478730 5.104198 4.630897 12.070482 29.512943 38.618252 50.952602 406.635437 12834.001953 109385.296875 151382.671875 125848.796875 8588.291992 396.057892 30.780846 3.342617 5.055936 26.740694 138.747833 1061.072754 8451.048828 18332.521484 7025.488281 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001132 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001284 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001427 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001553 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001059 -0.001112 -0.001136 -0.001645 -0.001172 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001030 -0.001144 -0.001253 -0.001345 -0.001414 -0.001444 -0.001717 -0.001214 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001641 -0.001619 -0.001030 -0.001052 -0.001044 -0.001023 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001112 -0.001271 -0.001434 -0.001574 -0.001703 -0.001792 -0.001832 -0.001742 -0.001231 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002789 -0.003085 -0.003333 -0.005704 -0.004842 -0.004984 -0.006472 -0.007649 -0.007695 -0.007637 -0.007416 -0.004607 -0.004497 -0.004279 -0.003980 -0.003874 -0.002475 -0.002571 -0.001766 -0.001956 -0.003606 -0.003784 -0.003886 -0.001729 -0.001222 0.000000 0.000000 0.000000 0.000000 -0.005198 -0.005903 -0.006536 -0.008248 -0.008884 -0.009383 -0.012267 -0.012787 -0.013104 -0.013201 -0.011952 -0.012206 -0.012043 -0.011647 -0.009524 -0.007948 -0.008591 -0.008214 -0.007794 -0.006345 -0.006368 -0.006798 -0.006104 -0.006330 -0.004856 -0.001668 -0.001180 0.000000 0.000000 -0.002447 -0.005863 -0.007995 -0.010039 -0.011264 -0.012366 -0.014793 -0.016959 -0.017950 -0.018689 -0.019671 -0.020132 -0.021746 -0.021548 -0.019842 -0.017935 -0.015565 -0.016500 -0.014131 -0.012323 -0.014821 -0.013394 -0.012013 -0.011784 -0.008717 -0.007843 -0.008948 -0.001576 -0.001124 0.000000 -0.004997 -0.007665 -0.009044 -0.011581 -0.013348 -0.015063 -0.018305 -0.021336 -0.023217 -0.026405 -0.031064 -0.032315 -0.034424 -0.033665 -0.033518 -0.032226 -0.031051 -0.027168 -0.026622 -0.026475 -0.023439 -0.021211 -0.018871 -0.018027 -0.017167 -0.016611 -0.015101 -0.012007 -0.001457 -0.001132 -0.005305 -0.008150 -0.009863 -0.012849 -0.015213 -0.017728 -0.021876 -0.027660 -0.030877 -0.035522 -0.040170 -0.044391 -0.046613 -0.048168 -0.049872 -0.049847 -0.049263 -0.047572 -0.044565 -0.042418 -0.041092 -0.039792 -0.034300 -0.031100 -0.029049 -0.024663 -0.023383 -0.021336 -0.018791 -0.002534 -0.004290 -0.006741 -0.010279 -0.013639 -0.016617 -0.019968 -0.025180 -0.032301 -0.037255 -0.045427 -0.052179 -0.057281 -0.061847 -0.066693 -0.070706 -0.074124 -0.074831 -0.073763 -0.071253 -0.070421 -0.068549 -0.058896 -0.054243 -0.048001 -0.043178 -0.038825 -0.035898 -0.032101 -0.028481 -0.024407 -0.005423 -0.006721 -0.010287 -0.012917 -0.017346 -0.021433 -0.027679 -0.036292 -0.043153 -0.052151 -0.063337 -0.071771 -0.080950 -0.088587 -0.099018 -0.104953 -0.108522 -0.109898 -0.110116 -0.107161 -0.102985 -0.098675 -0.089148 -0.077847 -0.069314 -0.060130 -0.051200 -0.045228 -0.041012 -0.037253 -0.030646 -0.006417 -0.008287 -0.012601 -0.017221 -0.021899 -0.027617 -0.038806 -0.047661 -0.059236 -0.073650 -0.087371 -0.101275 -0.115453 -0.131296 -0.143726 -0.152351 -0.156800 -0.158822 -0.161191 -0.157672 -0.152414 -0.143839 -0.130321 -0.112946 -0.095869 -0.081616 -0.070618 -0.058323 -0.051589 -0.045952 -0.039923 -0.007682 -0.011744 -0.016355 -0.021321 -0.027471 -0.036936 -0.049835 -0.062247 -0.081382 -0.100497 -0.119476 -0.138255 -0.159424 -0.173683 -0.184109 -0.190815 -0.198149 -0.196787 -0.196110 -0.193395 -0.190338 -0.183583 -0.171243 -0.156599 -0.137738 -0.115842 -0.096223 -0.079619 -0.067799 -0.058359 -0.051516 -0.009098 -0.013901 -0.019566 -0.025942 -0.034215 -0.049213 -0.063444 -0.084330 -0.107268 -0.131041 -0.152890 -0.175863 -0.192617 -0.208006 -0.215244 -0.210455 -0.192657 -0.172489 -0.148224 -0.141642 -0.159296 -0.188447 -0.201145 -0.191969 -0.174809 -0.155972 -0.128657 -0.106159 -0.085213 -0.070685 -0.062173 -0.010590 -0.017665 -0.024656 -0.032735 -0.045025 -0.062281 -0.081403 -0.107725 -0.133916 -0.158127 -0.183021 -0.203967 -0.218959 -0.210879 -0.129941 0.113399 0.458382 0.760369 0.952124 0.954722 0.641292 0.211866 -0.096626 -0.205574 -0.211480 -0.193891 -0.172706 -0.141524 -0.113894 -0.092310 -0.076960 -0.013780 -0.021381 -0.028749 -0.038758 -0.053903 -0.075790 -0.103347 -0.128301 -0.154643 -0.177762 -0.202098 -0.214955 -0.186529 0.032137 1.103687 4.144888 8.819939 11.836495 13.860839 14.405460 9.792869 4.213957 1.119526 0.038590 -0.217318 -0.230838 -0.211285 -0.181123 -0.146504 -0.116810 -0.098377 -0.015624 -0.024117 -0.032772 -0.044797 -0.064612 -0.088137 -0.116669 -0.141516 -0.166263 -0.194772 -0.205762 -0.170611 0.061543 1.538043 11.499479 57.881863 165.326019 188.678772 211.819031 241.967163 134.418274 43.025303 9.499655 1.567937 0.001718 -0.243890 -0.243708 -0.218379 -0.179890 -0.149141 -0.122322 -0.018467 -0.027844 -0.039344 -0.054363 -0.074799 -0.100740 -0.127397 -0.148884 -0.177463 -0.201484 -0.187691 -0.049011 0.704879 7.413222 84.392967 1015.592834 5287.861816 5137.211914 5432.871094 7752.125977 2680.126221 432.452423 57.377724 7.825239 0.941059 -0.159679 -0.279282 -0.260996 -0.225693 -0.186710 -0.156679 -0.021586 -0.031726 -0.042736 -0.060175 -0.083673 -0.109183 -0.135651 -0.157777 -0.175996 -0.190332 -0.163992 0.051733 1.573946 19.957178 397.641174 13656.188477 100421.929688 112230.976562 107695.554687 106527.117187 77443.281250 3463.117676 239.034393 26.534037 3.398697 0.125511 -0.296970 -0.310244 -0.268936 -0.225747 -0.188430 -0.027945 -0.037601 -0.047754 -0.064796 -0.088317 -0.116622 -0.141218 -0.157535 -0.168104 -0.172071 -0.163852 0.021265 1.733355 25.268667 628.839844 31266.142578 101059.585938 169869.359375 115309.187500 117134.101562 123191.148437 9889.370117 554.502502 63.937183 7.729047 0.624388 -0.294858 -0.368304 -0.326403 -0.276887 -0.233894 -0.033675 -0.040097 -0.053584 -0.068731 -0.092688 -0.121470 -0.143016 -0.154535 -0.157927 -0.172005 -0.198148 -0.128454 0.897255 14.514978 238.573120 5242.392578 61223.601563 77638.757813 103439.703125 104765.367188 106437.820312 6768.895020 732.605408 93.755928 11.192431 0.900805 -0.329235 -0.431165 -0.388681 -0.337012 -0.286843 -0.042396 -0.047251 -0.060044 -0.080424 -0.099284 -0.123712 -0.148027 -0.163710 -0.174150 -0.201377 -0.258044 -0.289865 0.063279 3.866499 39.416458 330.628906 1364.399292 3890.294434 31455.386719 63466.808594 11420.451172 1931.518433 454.260437 75.620499 9.374361 0.638292 -0.422165 -0.511980 -0.457164 -0.394637 -0.343251 -0.054904 -0.056278 -0.065953 -0.087635 -0.104088 -0.125221 -0.154235 -0.182919 -0.209252 -0.256656 -0.322104 -0.394303 -0.329105 0.689606 6.606310 28.890999 83.441612 231.137604 729.272644 1016.380310 618.130981 359.490326 132.815979 28.752865 4.069658 0.041454 -0.563900 -0.595776 -0.523972 -0.457219 -0.396457 -0.069456 -0.067690 -0.075950 -0.094460 -0.111160 -0.132289 -0.166152 -0.203415 -0.250907 -0.302911 -0.369223 -0.426704 -0.245727 1.792225 17.431726 98.233803 284.261017 270.528839 141.516113 105.321884 79.468185 53.038502 24.232330 6.789324 0.938854 -0.429935 -0.673962 -0.658810 -0.582723 -0.496032 -0.410907 -0.089857 -0.087426 -0.092434 -0.101374 -0.117686 -0.146084 -0.175179 -0.215873 -0.270547 -0.328794 -0.400100 -0.405241 0.350653 10.193974 154.171906 2542.054687 16707.876953 12467.044922 1579.340698 474.980621 162.276245 42.208504 14.702004 5.392341 1.215180 -0.311790 -0.678856 -0.675687 -0.535176 -0.295813 -0.012297 -0.110984 -0.107583 -0.108978 -0.120635 -0.135702 -0.157007 -0.191557 -0.226786 -0.279751 -0.342920 -0.413413 -0.365842 1.327227 31.215839 929.940674 67788.039063 100082.867188 100681.937500 21349.193359 3493.615723 849.151733 171.497940 79.213318 33.866238 9.075200 1.381219 -0.364443 -0.499846 0.147289 1.777772 4.246644 -0.137899 -0.131106 -0.128532 -0.140744 -0.153589 -0.174380 -0.206685 -0.245376 -0.297930 -0.362709 -0.431913 -0.360308 1.770668 40.290638 1521.234253 100012.875000 100136.921875 101324.703125 55534.316406 8567.512695 2223.216309 872.117065 563.301331 201.024673 43.907196 7.601429 0.743981 0.436112 4.639852 21.449228 57.602547 -0.175257 -0.163756 -0.159706 -0.163100 -0.173051 -0.198040 -0.223613 -0.266763 -0.317931 -0.386658 -0.457435 -0.426454 0.914990 21.369759 496.820496 18487.187500 100091.210938 100762.554688 10296.029297 6045.381348 10784.914063 10418.252930 3500.538330 715.335693 124.134140 20.055882 3.052231 3.989708 32.332024 228.010925 1052.737549 -0.217471 -0.198111 -0.191240 -0.188375 -0.197211 -0.217393 -0.241644 -0.286093 -0.337425 -0.408902 -0.488986 -0.528654 -0.064787 5.404169 68.281601 629.900391 2805.918945 2364.973389 1870.105103 19230.611328 142177.250000 119983.617187 28631.679688 1690.868896 207.636810 32.629082 5.731117 12.768876 139.043091 2091.629883 23298.582031 -0.266341 -0.242397 -0.224847 -0.219685 -0.221086 -0.237018 -0.263986 -0.310249 -0.368125 -0.442010 -0.528125 -0.604280 -0.542006 0.399626 6.305481 31.249796 82.195663 174.468628 1569.125366 43787.070313 146476.093750 123525.562500 102381.117188 2454.650635 187.178970 28.571358 7.219590 27.099575 341.938751 7856.049805 100048.531250 -0.319332 -0.286539 -0.263181 -0.250553 -0.244341 -0.248476 -0.268445 -0.326965 -0.395582 -0.474734 -0.553654 -0.632991 -0.668359 -0.461013 0.644113 4.080424 14.201734 82.352295 881.236511 13903.778320 107200.062500 104053.750000 31812.921875 1255.174561 95.037712 15.894421 9.188470 49.564968 425.207458 5985.325684 100419.718750 -0.373023 -0.334698 -0.306033 -0.276600 -0.249327 -0.226494 -0.228897 -0.301857 -0.403512 -0.490659 -0.563964 -0.624232 -0.565624 0.204377 4.063457 16.502630 35.761032 83.666100 559.169495 3661.247070 10131.679687 9006.943359 2130.287598 235.899948 30.740665 7.351807 12.983267 102.226463 765.302185 3560.067871 9626.606445 -0.424996 -0.392293 -0.352413 -0.308093 -0.242893 -0.175494 -0.165791 -0.261070 -0.395424 -0.484187 -0.485256 -0.347382 0.206030 3.443425 25.400164 145.195007 345.132446 288.788177 365.555847 1579.366089 2304.863525 864.069763 203.027313 39.058067 7.829270 3.108092 13.954183 130.956955 1154.776733 4810.915527 4837.723633 -0.472166 -0.446856 -0.403748 -0.347356 -0.259182 -0.171401 -0.151091 -0.255309 -0.372636 -0.285995 0.367618 2.085780 5.349751 14.405615 90.764046 740.391846 2778.916504 1668.906738 326.247009 276.986450 319.819275 141.560898 34.901623 7.322262 1.365619 0.947322 8.498536 75.184151 493.664764 1791.114624 2775.383301 -0.522291 -0.499985 -0.458537 -0.399574 -0.327992 -0.255628 -0.245169 -0.307135 -0.233065 0.912654 7.101997 29.366558 68.795357 87.051674 161.426163 1221.887573 4773.195312 2783.909180 380.321075 58.893188 35.138466 17.613579 5.283413 0.772349 -0.424865 -0.260501 2.896689 21.985435 111.331123 441.940582 2657.071533 -0.581701 -0.554694 -0.518595 -0.466908 -0.418905 -0.379031 -0.381865 -0.339426 0.386346 6.668882 61.621777 449.471863 1799.061523 2123.406982 693.664978 544.232361 1241.911865 812.128845 160.701767 20.772066 4.817608 1.637504 0.001393 -0.714158 -0.917355 -0.773700 0.164228 4.675775 24.771296 151.979675 1245.529663 -0.620278 -0.608730 -0.577294 -0.528907 -0.501442 -0.482776 -0.454220 -0.222584 2.018497 27.153822 418.015137 9314.475586 100043.921875 100120.281250 16162.213867 888.866455 217.618958 114.007874 32.433331 5.943633 0.631366 -0.443618 -0.809096 -0.983728 -1.007746 -0.940525 -0.665894 0.569306 6.261357 38.567528 215.706161 -0.628137 -0.648511 -0.631108 -0.588907 -0.566405 -0.535257 -0.435217 0.019485 4.013856 61.615395 1656.769653 100021.500000 100125.289063 100445.625000 100726.984375 3833.439697 264.349335 59.508656 16.658236 3.778240 0.674979 0.075355 -0.328788 -0.727192 -0.922305 -0.952232 -0.813666 -0.282356 1.580146 8.234984 27.488365 -0.485676 -0.589902 -0.638853 -0.643805 -0.614242 -0.551841 -0.383154 0.190077 4.483989 65.788269 1935.274170 100047.218750 100501.523438 104828.242188 119452.890625 14041.769531 1814.966797 513.107117 128.142578 23.164549 9.401670 8.784040 5.490904 1.566226 -0.281375 -0.763841 -0.592782 0.561008 4.293107 11.916524 18.255743 1.014659 0.158285 -0.406429 -0.606538 -0.645622 -0.576488 -0.402443 0.088499 2.749857 33.189072 558.619751 14707.435547 102282.507813 177557.640625 125933.335937 105055.164063 42563.085938 24722.958984 2271.149170 174.708740 93.351463 107.887375 61.156902 17.845892 3.023880 -0.093997 0.107864 4.014166 22.593924 73.202965 112.769135 18.968018 7.542941 1.586137 -0.222821 -0.610021 -0.632725 -0.518363 -0.236964 0.807437 9.301265 87.427559 821.439026 6779.203125 103749.882813 102434.171875 200151.218750 117632.250000 100698.546875 41397.140625 1055.345825 1061.976074 1544.419434 682.572693 120.811554 16.674784 1.796802 1.336010 12.083152 77.647339 339.273560 590.006042 323.227997 89.431007 15.483537 1.690297 -0.386802 -0.655733 -0.632391 -0.535594 -0.208428 1.891315 15.634990 114.140274 1343.231689 25850.994141 102329.500000 169851.968750 104830.906250 104538.906250 111243.476562 7076.854492 9197.295898 19341.621094 5550.201660 521.131897 48.086384 6.429564 3.092698 18.189671 127.438637 633.271484 1316.279175 10206.916992 1141.819214 94.868996 8.322852 0.234137 -0.607284 -0.686557 -0.678641 -0.629672 -0.127611 3.138189 25.093227 193.589966 1283.121460 4131.326172 32172.787109 103785.687500 196011.000000 113854.398437 102402.031250 25612.154297 51440.003906 11172.669922 893.595764 95.234695 21.475391 7.624987 15.078785 93.518860 416.245880 730.579834 100286.101563 12206.956055 394.155518 22.004322 1.196140 -0.516655 -0.673288 -0.702081 -0.740660 -0.665927 0.106134 4.341952 23.306887 85.419701 243.245605 1338.656738 11215.031250 105208.671875 109189.343750 108031.945312 15902.252930 12632.753906 4145.313965 661.840088 291.297729 148.334274 42.589134 13.972375 31.380894 99.315865 164.268372 102122.796875 31266.273438 647.430298 29.952280 1.694925 -0.474460 -0.659912 -0.703238 -0.766008 -0.779977 -0.500184 0.639133 3.683520 10.632697 34.185532 222.812851 3462.116455 74628.070313 200108.062500 163092.703125 16831.468750 1714.698730 933.249939 1755.966797 3772.706543 1958.324463 324.105377 39.530869 10.604831 16.543385 22.514177 106061.593750 8810.275391 339.244171 21.593418 1.324460 -0.502185 -0.699215 -0.745631 -0.757662 -0.502414 0.974813 6.842494 18.794807 27.076242 32.946793 127.083000 1890.186646 72124.375000 105748.945313 102741.429688 34869.371094 1155.285400 1280.869263 14769.432617 62967.796875 21219.785156 1807.709839 122.914574 12.815181 3.155575 2.422637 8928.359375 998.385986 94.871216 11.264128 1.536188 -0.294344 -0.692167 -0.771731 -0.602712 1.002203 13.625283 105.371254 445.835999 615.363464 342.584625 251.672043 1190.903687 20674.884766 133517.500000 116501.601562 10736.272461 659.939880 1736.984741 34380.316406 100073.359375 51332.695313 2978.267090 203.048752 22.979322 2.942051 0.291558 722.402161 148.419220 55.669632 26.939318 8.422822 1.344691 -0.393008 -0.670774 -0.119461 6.194236 103.811646 1973.987061 28184.181641 49116.113281 7674.459473 2281.621094 3333.257568 93401.265625 107211.671875 104243.453125 10952.492188 423.921082 769.836426 7849.288574 28399.564453 11598.685547 1612.393677 252.910431 38.181499 5.474126 1.797206 145.456879 284.564758 424.831787 215.585693 54.620380 8.633564 0.684534 -0.351059 0.618624 15.573457 399.294434 28098.501953 100449.140625 105545.898438 128288.984375 19873.611328 19741.533203 200267.078125 163184.218750 104615.375000 12584.473633 354.640533 158.162628 724.632202 1664.193481 1576.137573 907.046631 267.999390 44.464352 8.750925 10.127677 411.932739 2040.973267 3718.130127 1552.430176 231.471771 26.032330 2.707019 0.245711 1.107855 17.816385 500.917908 48371.214844 100636.703125 109315.085937 162967.578125 37812.996094 54904.671875 108883.164062 157418.328125 38896.632813 2615.770264 201.030838 41.604397 79.593040 211.140472 421.845520 385.278473 134.564957 30.512663 15.267122 40.961273 2611.261719 8761.686523 12652.656250 4192.702148 473.488617 43.606087 4.612822 0.918668 1.106890 9.517619 168.419861 5234.401855 100279.539063 102871.476563 27863.490234 9208.862305 17762.640625 105938.726563 87954.148438 19293.488281 2168.846924 213.421097 27.157942 15.676540 40.860317 79.942833 79.968994 44.429428 28.494606 40.683609 105.570694 99276.804688 102972.414063 68431.195313 4904.163086 425.647827 39.878906 4.534385 1.018472 0.762998 2.818662 27.380817 262.534424 1457.209351 2120.645020 1312.714355 965.853333 4494.367187 106902.671875 109015.937500 102956.007813 16441.281250 540.349609 35.066460 5.215270 7.062784 14.960398 25.900854 67.695175 189.716141 295.909119 258.299133 118622.750000 100797.992188 100815.281250 14991.356445 408.065887 30.423771 3.178617 0.697690 0.574001 0.912131 3.878345 17.371677 50.084061 77.128944 96.625771 296.970581 5762.867187 109494.359375 121349.000000 106643.664062 34978.496094 790.180115 40.486870 3.160134 1.769211 9.439149 68.121735 648.607544 4723.654297 8622.592773 3012.741699 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001197 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001358 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001510 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001037 -0.001081 -0.001104 -0.001645 -0.001172 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001023 -0.001144 -0.001253 -0.001345 -0.001414 -0.001444 -0.001754 -0.001239 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001136 -0.001298 -0.003247 -0.003402 -0.001741 -0.001832 -0.001872 -0.001832 -0.001284 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001700 -0.001836 -0.003105 -0.003202 -0.003248 -0.004212 -0.004123 -0.003985 -0.002723 -0.001037 0.000000 0.000000 0.000000 -0.001008 -0.001201 -0.001414 -0.003438 -0.003716 -0.003943 -0.005577 -0.005710 -0.004022 -0.001858 -0.001302 0.000000 0.000000 0.000000 0.000000 0.000000 -0.004048 -0.005786 -0.006284 -0.006695 -0.008041 -0.008285 -0.008341 -0.009676 -0.008279 -0.008277 -0.008148 -0.007865 -0.007451 -0.004438 -0.005214 -0.005143 -0.004128 -0.004206 -0.005328 -0.005875 -0.007925 -0.008274 -0.008456 -0.005195 -0.001845 -0.001293 0.000000 0.000000 0.000000 -0.004191 -0.006131 -0.006972 -0.007790 -0.009644 -0.010418 -0.011003 -0.012902 -0.014381 -0.014611 -0.014603 -0.015927 -0.017125 -0.014400 -0.013856 -0.011572 -0.011897 -0.008909 -0.011630 -0.013089 -0.014069 -0.011439 -0.010538 -0.010049 -0.011308 -0.009663 -0.001780 -0.001257 0.000000 -0.002426 -0.005840 -0.008157 -0.009419 -0.011755 -0.013248 -0.014599 -0.017215 -0.021092 -0.022257 -0.024714 -0.026823 -0.026064 -0.025935 -0.026779 -0.025862 -0.023055 -0.021878 -0.020825 -0.021361 -0.019534 -0.019511 -0.021218 -0.019710 -0.019706 -0.015896 -0.015162 -0.012218 -0.001680 -0.001188 -0.003728 -0.007474 -0.009029 -0.010730 -0.013670 -0.015810 -0.017971 -0.023293 -0.026751 -0.030666 -0.034290 -0.036038 -0.038538 -0.039166 -0.039036 -0.038360 -0.037221 -0.035492 -0.038775 -0.034703 -0.034992 -0.035048 -0.031279 -0.027547 -0.027110 -0.026678 -0.024308 -0.022073 -0.016901 -0.001553 -0.003949 -0.007770 -0.009582 -0.011696 -0.015221 -0.018186 -0.021348 -0.028002 -0.032980 -0.038594 -0.044038 -0.048907 -0.051854 -0.053826 -0.055972 -0.056221 -0.057137 -0.056624 -0.056027 -0.055034 -0.053803 -0.047347 -0.044925 -0.040852 -0.038851 -0.035909 -0.034647 -0.032066 -0.028750 -0.026564 -0.005375 -0.006240 -0.009755 -0.012213 -0.016233 -0.019965 -0.024186 -0.032390 -0.039172 -0.047078 -0.055033 -0.062800 -0.068444 -0.074133 -0.078754 -0.082747 -0.083806 -0.084524 -0.082699 -0.085203 -0.081977 -0.077356 -0.071175 -0.062356 -0.058908 -0.051996 -0.047809 -0.043815 -0.041613 -0.037995 -0.033575 -0.007309 -0.009513 -0.012185 -0.015556 -0.020873 -0.026144 -0.035665 -0.044582 -0.054926 -0.067778 -0.077953 -0.088882 -0.097759 -0.107999 -0.116819 -0.124079 -0.127625 -0.129233 -0.129955 -0.126956 -0.121060 -0.111638 -0.102896 -0.092382 -0.081408 -0.073872 -0.065314 -0.056346 -0.051478 -0.048004 -0.043523 -0.007427 -0.011588 -0.015118 -0.020763 -0.026772 -0.035983 -0.048072 -0.059700 -0.077348 -0.093269 -0.108440 -0.126008 -0.141999 -0.154289 -0.166245 -0.175671 -0.180167 -0.182423 -0.181058 -0.176979 -0.170621 -0.160817 -0.148891 -0.130670 -0.114361 -0.098814 -0.086459 -0.075599 -0.067799 -0.062226 -0.055747 -0.009000 -0.014016 -0.019638 -0.025947 -0.034234 -0.048185 -0.062966 -0.080919 -0.104047 -0.126132 -0.145344 -0.164611 -0.183807 -0.198786 -0.208937 -0.218803 -0.224953 -0.229127 -0.224749 -0.220021 -0.214953 -0.205939 -0.193776 -0.179819 -0.160216 -0.136174 -0.114315 -0.100646 -0.085359 -0.074440 -0.066953 -0.012393 -0.016723 -0.023805 -0.032132 -0.044957 -0.062402 -0.081030 -0.109523 -0.134503 -0.153784 -0.177351 -0.201503 -0.217691 -0.230257 -0.241422 -0.239105 -0.213382 -0.189974 -0.177315 -0.178877 -0.194815 -0.220541 -0.230161 -0.218025 -0.204796 -0.184587 -0.153438 -0.131815 -0.111802 -0.093029 -0.080123 -0.014386 -0.019765 -0.028412 -0.039346 -0.057204 -0.077652 -0.103824 -0.133160 -0.155579 -0.179792 -0.203595 -0.205087 -0.189596 -0.158625 -0.057490 0.238448 0.633921 0.890051 0.937635 0.845896 0.466863 0.099118 -0.154503 -0.244031 -0.248410 -0.229279 -0.203479 -0.169893 -0.143629 -0.118180 -0.101320 -0.016307 -0.023899 -0.034867 -0.048236 -0.069943 -0.094356 -0.121873 -0.146670 -0.169933 -0.187981 -0.165856 -0.062105 0.157564 0.572550 1.940341 6.256904 13.259818 15.073522 14.277382 12.813757 7.876073 3.352716 0.846482 -0.003902 -0.236854 -0.265354 -0.244215 -0.210680 -0.177255 -0.142279 -0.122023 -0.019767 -0.028627 -0.040176 -0.056150 -0.081217 -0.105741 -0.134707 -0.157636 -0.169046 -0.145127 0.014663 0.502604 1.566163 4.179717 18.939758 104.393898 304.703613 306.154205 231.063248 219.787354 105.263474 32.156445 8.095503 1.696245 0.091340 -0.249662 -0.282277 -0.257555 -0.220919 -0.178396 -0.147509 -0.021617 -0.031671 -0.044687 -0.065542 -0.089949 -0.114324 -0.140040 -0.144489 -0.115453 0.003510 0.395106 1.646044 4.961822 17.057091 159.706039 2548.322266 20564.191406 17471.839844 6221.222656 7960.774902 2182.181152 314.725372 56.271603 11.387695 1.757097 -0.035651 -0.298675 -0.307128 -0.261613 -0.220178 -0.184017 -0.023153 -0.035101 -0.049433 -0.070048 -0.094205 -0.117970 -0.125946 -0.076277 0.051745 0.304329 0.867445 2.773968 8.754356 41.826881 939.280273 76060.031250 100419.179688 112179.250000 128147.992187 100825.539063 70659.140625 3000.948730 424.238495 66.263573 8.317944 0.725012 -0.261172 -0.351800 -0.311564 -0.260939 -0.222366 -0.028486 -0.038303 -0.054054 -0.075406 -0.098677 -0.119600 -0.093786 0.056033 0.363458 0.734458 1.162585 2.634582 7.785834 49.388412 1529.637329 100043.515625 101055.898438 169795.609375 176247.640625 102605.101563 111458.265625 22674.318359 3560.663330 309.415039 26.610018 2.217146 -0.171024 -0.398183 -0.367933 -0.314989 -0.264451 -0.032098 -0.043952 -0.059424 -0.076506 -0.099264 -0.116513 -0.066069 0.163003 0.640935 1.073771 1.184551 1.512621 4.016335 25.617001 501.406342 20520.603516 100734.367188 134348.062500 109555.109375 106421.265625 177645.171875 104366.179688 14743.544922 741.381531 46.382744 3.407742 -0.130203 -0.452695 -0.424367 -0.363583 -0.313035 -0.038136 -0.046850 -0.064214 -0.081786 -0.104550 -0.121542 -0.073776 0.136259 0.526901 0.903508 0.794002 0.560055 1.083570 6.782849 70.199776 691.245544 3486.029053 5425.978027 31798.367188 66922.437500 56486.457031 70469.671875 9358.561523 555.146423 38.583790 2.933309 -0.246648 -0.527208 -0.485236 -0.422734 -0.368236 -0.048154 -0.050958 -0.065556 -0.086274 -0.105210 -0.126156 -0.111666 -0.017494 0.177011 0.307997 0.210528 -0.064346 -0.093448 1.036630 7.943440 38.609604 108.030037 261.720001 793.437744 1656.523193 4027.500732 4755.610352 1328.278687 156.039368 16.295710 1.267375 -0.452219 -0.604158 -0.545155 -0.455378 -0.383720 -0.057276 -0.062262 -0.072753 -0.086599 -0.104580 -0.131602 -0.145932 -0.141010 -0.106190 -0.113553 -0.205196 -0.356692 -0.305606 0.899883 8.827626 43.801563 105.179787 109.242912 89.248940 134.295609 258.955139 271.890808 116.876648 26.870481 4.228337 0.004233 -0.634668 -0.660463 -0.567930 -0.428530 -0.299471 -0.073836 -0.076977 -0.085821 -0.099551 -0.117097 -0.140129 -0.172793 -0.207222 -0.244184 -0.294780 -0.373396 -0.429087 -0.003329 5.128286 59.645206 536.935181 2333.496826 1819.926025 357.848022 82.220062 49.325062 45.490097 35.190048 15.910072 3.763573 0.085841 -0.647042 -0.664051 -0.484432 -0.172726 0.156273 -0.093997 -0.094045 -0.098424 -0.111450 -0.124405 -0.150467 -0.184169 -0.226405 -0.282998 -0.349666 -0.426596 -0.424990 0.587062 14.674046 253.544769 5716.303711 60499.574219 38819.996094 2658.962891 261.652802 156.911514 355.854340 443.322235 170.558823 28.786173 3.183213 -0.281700 -0.512012 -0.045205 0.929798 2.185841 -0.122017 -0.115091 -0.113802 -0.123069 -0.138347 -0.162959 -0.196736 -0.237116 -0.295778 -0.360224 -0.436038 -0.420203 0.774399 18.804092 366.562744 11177.774414 100016.218750 100079.007813 4553.784668 547.017822 1169.523682 7361.456543 12518.712891 2366.699219 184.178284 13.416953 0.682055 -0.002039 1.794760 6.957413 16.349134 -0.152787 -0.142013 -0.133356 -0.140776 -0.155109 -0.180225 -0.207688 -0.254294 -0.306025 -0.377086 -0.450526 -0.464245 0.282400 10.111406 153.904892 2540.496094 16695.716797 12409.081055 1507.759766 2517.811279 19051.230469 81854.093750 104023.757813 15429.243164 567.961426 28.375107 2.000888 1.382505 9.245970 46.216789 136.859848 -0.189715 -0.171479 -0.163676 -0.162740 -0.177442 -0.199723 -0.226982 -0.269477 -0.323980 -0.395699 -0.469067 -0.526699 -0.278864 2.620235 27.613356 191.615280 635.448486 568.552612 1154.374268 38391.691406 102557.851563 135290.640625 176175.765625 11664.657227 497.378265 30.133499 2.666977 3.996313 31.327791 214.740662 979.019897 -0.228651 -0.210544 -0.197817 -0.195580 -0.203660 -0.221427 -0.247695 -0.287044 -0.343925 -0.419500 -0.501974 -0.580885 -0.577026 -0.007312 3.157015 15.147305 39.262768 127.560577 2069.658203 101294.882813 102287.132813 103083.976563 103510.476563 6431.591309 258.156067 19.038252 2.473384 7.331136 62.034447 520.110352 3111.330811 -0.277726 -0.257946 -0.240273 -0.227013 -0.234930 -0.253731 -0.278195 -0.320788 -0.372641 -0.450516 -0.541188 -0.614301 -0.678852 -0.592375 -0.032641 2.259568 14.742934 167.033203 3060.624512 73401.781250 151077.875000 106629.968750 100573.320313 2742.711670 118.417702 9.432936 2.194859 10.329927 65.042328 449.411560 2289.877197 -0.332341 -0.307569 -0.283007 -0.267128 -0.271257 -0.290762 -0.312510 -0.355909 -0.407923 -0.478024 -0.562824 -0.634451 -0.668009 -0.511903 0.308998 3.238145 18.597219 264.023254 7810.598145 102481.031250 121248.960937 61480.207031 6034.618164 441.362579 36.279873 3.596875 2.363760 13.798753 62.918945 221.579697 577.359497 -0.384021 -0.361075 -0.328042 -0.305714 -0.308763 -0.327129 -0.348494 -0.388416 -0.442712 -0.491340 -0.512314 -0.477880 -0.335438 0.302425 3.224977 12.955111 33.280754 184.579544 3748.600586 79054.500000 100443.859375 15333.967773 789.670105 74.449875 8.754846 0.903270 2.109756 14.673128 64.029915 164.553223 210.083374 -0.432201 -0.417011 -0.380358 -0.364522 -0.353702 -0.361378 -0.379495 -0.420929 -0.454539 -0.364297 0.041197 1.060079 2.617247 4.132301 10.860500 39.069931 81.951286 106.918434 491.971466 3146.005127 4458.745605 1193.871948 141.151428 16.850929 1.734575 -0.230549 1.172433 9.132296 37.711601 93.795830 158.057556 -0.489062 -0.472702 -0.434043 -0.411024 -0.393986 -0.393744 -0.407814 -0.427709 -0.321684 0.488848 4.186579 16.255939 36.567677 41.067451 32.949928 59.068050 110.986763 97.246811 77.368324 146.443939 171.797653 80.421097 19.284636 2.948352 -0.248093 -0.710591 -0.013368 3.378983 14.670173 46.181839 148.873779 -0.543236 -0.534838 -0.492908 -0.454705 -0.435052 -0.423986 -0.384868 -0.285966 0.287145 4.341181 32.158253 200.254517 635.777039 736.960999 274.217499 81.969788 73.895157 61.238869 32.109585 19.980759 16.212896 8.783630 2.656975 -0.048076 -0.825873 -0.910514 -0.623851 0.538322 4.806475 21.188644 81.658150 -0.586363 -0.580403 -0.543108 -0.512283 -0.471385 -0.369861 -0.111447 0.401320 2.091385 16.915850 187.900589 2444.782959 17569.742188 21215.244141 3704.114502 348.472412 63.792912 31.480076 15.553927 7.156471 4.023053 1.851899 0.143754 -0.684201 -0.939952 -0.940143 -0.798262 -0.307224 1.389837 7.214153 26.520014 -0.626693 -0.628846 -0.592642 -0.550529 -0.457298 -0.169833 0.677347 2.234742 5.746130 36.573986 592.942322 17572.068359 100089.070313 100459.195313 32180.835938 1800.357300 251.112030 50.272087 13.439472 4.625254 2.575048 1.669115 0.616309 -0.303861 -0.773688 -0.835917 -0.617033 0.139097 2.156496 6.331272 11.528103 -0.488896 -0.575512 -0.600356 -0.571217 -0.410029 0.139772 1.834225 5.050752 9.655395 41.716125 687.757874 21245.578125 100923.257813 114629.804687 124065.242187 39210.007813 3154.862305 381.217590 82.636559 21.815792 19.731443 21.743099 14.201221 4.611433 0.473931 -0.416041 0.167447 3.787263 17.582319 55.036152 84.058846 1.370922 0.321246 -0.310043 -0.509331 -0.396586 0.224763 2.115469 5.921884 9.984594 24.939205 257.712311 3566.001709 34872.648438 138133.546875 105926.023438 102074.601563 46284.082031 7042.024414 993.230530 180.986771 311.896454 448.889069 227.967834 51.206089 8.283018 0.972787 2.271952 18.681601 136.827835 681.538818 1318.028076 23.644798 9.171889 2.030298 -0.072399 -0.379992 0.009696 1.242335 3.436796 5.524033 10.115085 60.111721 551.250671 12371.489258 102452.343750 102388.984375 122429.593750 177619.781250 101379.539063 10021.034180 1727.280884 8637.387695 17576.921875 5095.156250 517.001587 45.506771 5.460201 6.266469 61.853432 786.624207 7809.437988 23296.269531 460.479248 115.203079 18.423594 2.146893 -0.164804 -0.207799 0.282961 1.002486 1.544471 2.978456 17.433355 179.177414 3258.330566 101745.148438 102750.671875 146107.515625 114504.703125 115038.500000 69579.671875 27302.164063 101344.593750 100112.812500 100046.968750 3695.145020 168.899109 18.536119 11.123591 100.439430 1654.843994 28231.511719 100002.593750 19350.998047 1796.201538 121.167503 9.876814 0.614977 -0.080285 0.106508 0.190119 0.075066 0.452866 5.552328 48.046066 448.068420 3350.448242 11028.919922 13570.577148 89886.421875 156744.859375 104258.898438 121430.125000 114656.671875 100493.265625 100416.226563 7626.345215 418.285522 70.675255 21.570976 76.568497 978.506531 11119.566406 37884.539063 100243.390625 23321.242188 553.270447 25.819710 1.856271 0.347956 0.530878 0.415487 -0.073373 -0.290837 0.922105 9.380891 50.186184 173.384964 362.114471 1043.373413 24997.074219 101632.265625 101224.382813 106664.460937 134585.625000 101229.210938 80692.265625 6639.584473 1807.693237 534.953003 119.004875 42.068302 202.329178 1133.945190 2442.293213 100420.218750 62929.832031 914.061829 36.648579 2.480619 0.648364 0.972907 0.704369 0.059137 -0.369862 -0.135672 1.563670 6.863386 17.681061 42.189812 285.445374 6782.871094 101289.929688 105182.242188 105298.210938 13868.089844 9566.064453 11265.523438 19818.841797 36613.230469 13561.423828 1347.651978 106.310974 37.188938 89.050476 135.905579 100462.296875 16059.533203 453.747711 24.142303 2.014840 0.507260 0.643643 0.502249 0.060561 0.087587 1.460965 6.223384 17.443733 32.268261 47.885319 108.985527 845.627136 7880.487793 27267.906250 16029.910156 2556.171143 1373.320923 9833.163086 104728.382813 101277.234375 100259.476563 12294.823242 414.642059 34.617168 10.971226 10.521420 9581.567383 1180.463379 108.720703 15.478235 3.398548 0.635491 0.104474 -0.009715 0.198184 2.183333 12.809408 70.999573 275.338165 520.183411 743.782104 570.847595 573.678772 2143.954346 5914.616699 4748.784668 1069.339966 586.585754 12709.944336 100661.617188 100676.539063 101698.562500 27294.785156 960.944153 90.009949 10.414352 1.405373 370.515808 194.790939 170.332794 95.850746 27.076126 4.618476 0.335148 -0.184024 0.998323 8.326839 71.468987 906.011169 8045.192871 17230.931641 33128.816406 18126.337891 7045.021973 26493.564453 27197.572266 9003.494141 1074.461792 279.126465 3735.237305 100284.664063 102895.015625 117569.359375 24721.302734 3125.903320 243.880447 20.644943 1.790112 373.304291 2102.844238 3971.558594 1655.729370 243.279968 26.767286 2.454482 0.086220 2.227456 17.922596 226.954361 7706.681152 102679.609375 200067.515625 128238.585937 103537.468750 121473.429687 103759.187500 114911.437500 34060.492188 1523.474487 151.377609 430.519867 3713.231445 14400.442383 50963.492188 46872.511719 5598.020996 346.123047 26.697065 3.136553 2949.316650 51321.730469 100065.265625 34336.769531 1789.791504 99.744118 7.258969 0.540601 2.424374 19.562632 278.619507 11336.204102 104345.437500 200081.859375 143514.546875 108001.578125 146473.171875 101874.898438 103131.804688 102093.804688 1654.313599 116.326103 64.442520 314.179047 2175.576172 11286.842773 11170.567383 1941.535400 178.508133 18.600433 5.790025 10277.473633 103378.976563 101421.757813 100227.898438 4705.834961 178.073898 11.083024 0.785501 1.590767 10.932755 109.897301 1886.572266 26685.607422 81188.492188 104901.976563 103188.531250 110036.601562 110646.046875 156969.078125 56919.082031 3383.669922 223.311386 27.854483 54.162575 274.054565 856.517639 851.523621 264.864838 49.670441 15.053765 13.056614 91538.117188 200070.750000 156741.046875 72219.484375 2765.941406 136.553223 9.511147 0.592701 0.665259 3.871408 22.848057 158.332123 832.161987 2459.213379 5825.182617 4583.407227 10090.405273 123514.187500 114821.507812 101918.320313 38061.898438 752.620056 38.641388 10.611610 28.489223 59.792412 67.131050 48.123306 64.475693 80.827110 55.409683 105499.539063 105094.921875 110419.460937 17061.558594 731.805359 58.883808 5.131942 0.332501 0.414417 1.477862 4.345953 15.243448 49.542049 116.120651 210.760590 406.920319 9611.662109 100718.671875 100733.414063 100322.968750 95902.257813 1145.819336 45.008083 4.005565 3.674537 8.447884 30.017298 169.458710 737.306641 1148.320312 547.022949 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001239 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001407 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.001896 -0.001909 -0.001896 -0.002840 -0.001030 -0.001565 -0.001116 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003215 -0.003378 -0.003478 -0.003206 -0.003340 -0.003397 -0.003391 -0.003310 -0.001717 -0.001214 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001449 -0.003328 -0.003566 -0.004837 -0.005114 -0.005290 -0.005372 -0.004008 -0.004017 -0.003949 -0.001818 -0.001284 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001664 -0.001748 -0.001810 -0.001823 -0.001797 -0.001736 -0.001630 0.000000 0.000000 0.000000 -0.001459 -0.001590 -0.004607 -0.005064 -0.005456 -0.005791 -0.006029 -0.006167 -0.007621 -0.006249 -0.006224 -0.001899 -0.001330 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001862 -0.003178 -0.004580 -0.004788 -0.004885 -0.003791 -0.003730 -0.004630 -0.004446 -0.004179 -0.002833 -0.003026 -0.001567 -0.004505 -0.005071 -0.005594 -0.006080 -0.007935 -0.008420 -0.008781 -0.008982 -0.009029 -0.007607 -0.001927 -0.001348 0.000000 0.000000 0.000000 -0.001585 -0.003105 -0.006038 -0.006715 -0.007331 -0.007818 -0.009199 -0.009477 -0.009532 -0.009377 -0.010555 -0.011625 -0.010235 -0.009873 -0.010823 -0.007736 -0.008911 -0.009271 -0.008646 -0.011003 -0.010908 -0.011667 -0.012270 -0.012652 -0.012750 -0.012306 -0.001913 -0.001339 0.000000 0.000000 -0.002954 -0.006109 -0.007111 -0.008144 -0.010286 -0.012310 -0.013207 -0.015483 -0.016372 -0.019543 -0.019889 -0.019783 -0.020993 -0.020354 -0.017881 -0.016290 -0.016699 -0.018950 -0.020674 -0.019554 -0.020174 -0.019786 -0.016462 -0.017307 -0.017958 -0.018232 -0.015389 -0.001845 -0.001302 -0.001164 -0.004495 -0.007965 -0.009436 -0.010997 -0.013625 -0.015399 -0.018698 -0.021760 -0.025934 -0.027435 -0.028362 -0.030447 -0.030438 -0.030348 -0.029539 -0.029404 -0.030407 -0.029616 -0.032109 -0.032052 -0.031880 -0.028077 -0.026925 -0.027364 -0.027743 -0.023950 -0.022351 -0.020907 -0.001742 -0.002427 -0.005905 -0.008601 -0.010453 -0.012535 -0.015886 -0.020106 -0.023035 -0.027418 -0.033143 -0.035914 -0.039741 -0.042944 -0.044008 -0.044264 -0.044718 -0.043548 -0.043481 -0.048742 -0.047383 -0.046327 -0.044438 -0.043689 -0.040849 -0.039641 -0.038034 -0.035348 -0.034420 -0.032664 -0.027163 -0.003954 -0.005627 -0.008907 -0.011095 -0.013723 -0.017760 -0.023032 -0.027347 -0.033360 -0.041034 -0.046006 -0.052077 -0.057414 -0.060329 -0.062980 -0.063708 -0.067178 -0.068534 -0.070676 -0.068943 -0.067093 -0.064595 -0.061171 -0.056286 -0.055650 -0.052677 -0.050815 -0.047210 -0.045093 -0.041857 -0.039279 -0.005976 -0.008847 -0.011284 -0.014293 -0.018975 -0.025278 -0.030959 -0.038984 -0.049087 -0.056973 -0.067792 -0.075396 -0.082440 -0.088179 -0.094217 -0.095829 -0.099634 -0.098022 -0.099836 -0.096858 -0.094258 -0.090957 -0.086063 -0.081655 -0.072786 -0.069639 -0.063618 -0.061786 -0.057193 -0.054161 -0.049649 -0.008163 -0.010992 -0.014233 -0.018322 -0.024791 -0.033387 -0.043304 -0.055881 -0.067487 -0.082768 -0.096021 -0.107408 -0.120098 -0.130974 -0.136965 -0.143035 -0.145110 -0.146577 -0.146332 -0.142725 -0.136271 -0.128692 -0.118483 -0.109322 -0.102220 -0.095581 -0.085514 -0.079287 -0.072950 -0.068471 -0.061113 -0.011324 -0.013518 -0.017865 -0.024612 -0.034050 -0.044039 -0.058074 -0.075729 -0.095856 -0.114575 -0.133756 -0.150278 -0.165988 -0.177837 -0.190497 -0.198749 -0.204477 -0.207117 -0.203780 -0.198149 -0.189493 -0.179825 -0.165804 -0.153643 -0.137643 -0.122505 -0.111293 -0.100305 -0.092246 -0.085370 -0.078514 -0.012237 -0.016456 -0.023146 -0.031222 -0.043754 -0.059388 -0.079987 -0.103700 -0.128029 -0.149589 -0.166260 -0.187741 -0.205217 -0.225147 -0.239945 -0.247849 -0.255452 -0.257260 -0.257947 -0.251396 -0.242576 -0.233248 -0.220626 -0.204795 -0.188997 -0.165361 -0.143974 -0.127171 -0.114191 -0.101404 -0.092092 -0.014438 -0.019835 -0.028410 -0.040869 -0.055666 -0.076644 -0.102328 -0.132549 -0.155403 -0.175258 -0.198359 -0.211545 -0.210795 -0.218801 -0.239505 -0.258354 -0.265691 -0.253143 -0.245039 -0.246202 -0.251571 -0.261999 -0.266081 -0.253741 -0.238976 -0.217969 -0.192745 -0.164221 -0.143645 -0.128407 -0.112138 -0.016861 -0.023623 -0.034484 -0.050297 -0.071030 -0.095563 -0.127464 -0.150977 -0.170373 -0.181722 -0.156721 -0.059637 0.099131 0.208282 0.191774 0.234590 0.404129 0.513769 0.488256 0.376275 0.152645 -0.069979 -0.219302 -0.283114 -0.288013 -0.268361 -0.240485 -0.209821 -0.180067 -0.154231 -0.134708 -0.019284 -0.028553 -0.040925 -0.060281 -0.084292 -0.110840 -0.140944 -0.158920 -0.155579 -0.083219 0.192607 0.970144 2.389921 3.625659 3.827202 5.666952 9.448073 10.515508 8.765428 7.328409 4.725660 2.053924 0.611738 -0.031643 -0.255446 -0.306720 -0.288573 -0.255732 -0.220020 -0.185073 -0.158134 -0.021660 -0.032556 -0.047253 -0.069114 -0.094478 -0.121363 -0.144758 -0.127034 -0.015665 0.361746 1.558686 5.306964 14.808133 24.410284 28.924894 71.311935 172.747375 179.112488 116.249405 91.305756 52.912922 21.843204 7.669341 2.135188 0.200434 -0.258870 -0.328587 -0.300941 -0.263155 -0.221693 -0.187746 -0.023704 -0.037351 -0.054179 -0.077345 -0.102336 -0.123917 -0.102728 0.054476 0.511174 1.588649 4.734704 17.468197 62.466286 115.703171 168.702332 1211.510376 6936.430664 5960.738281 1797.100098 1641.667725 679.210144 241.537323 77.918411 19.005489 2.960299 0.128244 -0.320564 -0.349131 -0.311046 -0.265361 -0.221753 -0.026679 -0.040267 -0.057848 -0.082945 -0.104840 -0.103694 0.042161 0.666442 2.106257 4.528329 9.458225 32.314899 119.601494 248.355850 611.231812 18529.300781 100162.203125 102097.406250 29613.371094 38829.476563 10835.552734 5238.497559 1264.507202 158.786743 16.738836 1.429452 -0.221603 -0.392583 -0.362367 -0.313118 -0.264806 -0.030950 -0.043317 -0.059054 -0.084340 -0.102309 -0.058396 0.319322 1.927244 6.138445 10.824368 14.303651 29.076017 94.078735 201.396805 841.362488 43314.378906 100326.046875 107190.812500 118938.460937 112562.281250 134363.421875 101437.593750 31191.623047 1140.427124 61.939590 4.339314 -0.033917 -0.427428 -0.416834 -0.363657 -0.308373 -0.034756 -0.049189 -0.065535 -0.085689 -0.101468 -0.018600 0.592589 3.283681 10.259535 18.971525 17.777180 16.970516 31.489389 63.221996 309.050659 6924.081055 85635.882813 64852.296875 74640.429688 177707.453125 119360.968750 101013.375000 100067.898438 3972.025146 120.836105 7.134062 0.130979 -0.466374 -0.471684 -0.411777 -0.353249 -0.039611 -0.051122 -0.067984 -0.087207 -0.100841 -0.025622 0.548637 3.059196 9.499443 16.206539 13.735520 8.260275 7.802222 12.727079 50.350124 377.742889 1480.215942 1926.154541 5503.816895 52991.882813 102049.859375 100282.007813 100037.117188 2649.553223 100.406738 6.391817 0.023639 -0.526379 -0.511712 -0.435378 -0.361112 -0.046855 -0.054517 -0.069882 -0.086480 -0.109223 -0.071059 0.236265 1.515687 4.481719 7.086405 6.115199 2.977344 1.463269 1.838071 6.529566 26.011065 72.675430 164.369125 548.895996 4051.112793 38108.417969 56796.480469 8537.776367 553.723755 38.933605 3.059130 -0.274904 -0.582685 -0.494257 -0.323388 -0.160192 -0.054698 -0.058417 -0.076333 -0.088534 -0.110425 -0.116543 -0.023850 0.334006 1.060987 1.689610 1.358393 0.494273 -0.067842 0.266584 3.061885 13.684175 37.686214 77.807144 129.263260 309.117340 895.803955 1001.197876 372.711456 64.666733 9.380713 0.736872 -0.511121 -0.560205 -0.262918 0.278911 0.892052 -0.065983 -0.067343 -0.078450 -0.095598 -0.108071 -0.136424 -0.147031 -0.104553 -0.003568 0.029912 -0.078269 -0.301251 -0.300871 1.210638 11.493800 59.508106 160.340530 174.313675 110.554108 68.888931 72.129028 89.602203 75.262024 33.995159 7.686375 0.825429 -0.439064 -0.321469 0.477079 2.085599 4.123301 -0.082394 -0.084425 -0.090765 -0.107100 -0.121995 -0.144631 -0.185013 -0.215309 -0.254704 -0.307185 -0.389334 -0.458851 -0.151923 3.368898 33.739204 238.076294 801.466797 700.942383 191.338150 73.242424 234.490005 1207.702515 1971.036865 582.674438 68.815781 6.305573 0.262270 0.323407 1.972344 5.586819 10.077693 -0.107832 -0.099521 -0.101943 -0.112785 -0.134990 -0.156337 -0.190210 -0.233953 -0.295953 -0.362355 -0.439647 -0.478284 -0.070395 4.126686 43.474033 368.096924 1292.562012 1107.339966 261.740784 246.177155 3550.215088 96262.367188 100122.570313 20511.205078 629.762085 28.161524 1.989965 1.580617 4.194914 9.244050 16.194212 -0.130805 -0.120475 -0.114913 -0.125933 -0.143482 -0.166638 -0.204479 -0.246499 -0.301522 -0.370573 -0.445015 -0.491963 -0.199284 2.598136 23.612032 156.056366 465.188934 415.623688 237.088348 1488.602295 29916.824219 109323.398437 102093.992188 100229.734375 2347.973877 61.942234 3.921280 3.170174 6.917713 14.276416 25.125340 -0.165577 -0.145972 -0.140241 -0.141641 -0.160588 -0.183100 -0.214566 -0.258255 -0.313696 -0.383162 -0.456396 -0.527498 -0.397222 0.808189 7.170462 31.437668 73.444893 101.972221 626.916199 16380.112305 113782.562500 200080.687500 141878.046875 101322.031250 1719.659912 54.268341 4.078089 3.981907 10.022349 26.617702 60.109684 -0.201569 -0.180249 -0.167800 -0.171050 -0.184333 -0.206274 -0.235392 -0.274217 -0.327749 -0.398131 -0.474562 -0.559966 -0.544394 -0.037147 2.161035 8.218444 21.570587 108.339157 1574.582275 60228.335938 106523.281250 116369.710937 131373.468750 7630.340820 381.024323 23.896059 2.546142 3.670904 12.022676 41.013309 109.836266 -0.242833 -0.221132 -0.207091 -0.202936 -0.216866 -0.237536 -0.264095 -0.298666 -0.354623 -0.427013 -0.507127 -0.591928 -0.618963 -0.385936 0.696506 4.205972 22.607700 302.228302 9781.633789 117630.890625 200180.421875 145976.296875 52745.597656 1637.677124 101.326332 8.639901 1.125299 2.951198 11.136033 38.311066 93.315575 -0.290530 -0.272005 -0.254612 -0.243146 -0.254042 -0.272384 -0.297460 -0.339489 -0.389358 -0.455798 -0.539713 -0.613900 -0.662467 -0.552013 0.110235 3.015209 27.619665 646.186340 56776.636719 101573.218750 109614.718750 112427.062500 6137.001953 349.044128 31.912098 2.865539 0.371793 2.404734 8.844204 22.662901 42.979248 -0.336718 -0.325900 -0.303082 -0.289174 -0.296247 -0.312444 -0.338879 -0.372433 -0.418859 -0.479527 -0.532791 -0.552827 -0.550022 -0.348605 0.714392 4.982110 27.733084 420.961823 22084.419922 100280.929688 100677.203125 100620.515625 2115.779541 107.990242 10.633370 0.622063 -0.091668 1.700829 6.268870 13.505172 19.270376 -0.384477 -0.379322 -0.354374 -0.336965 -0.328119 -0.339950 -0.365844 -0.393964 -0.431389 -0.427075 -0.282028 0.097202 0.623757 1.240368 4.172630 18.260454 58.843243 171.137421 1549.101807 16459.955078 27210.033203 4601.199707 342.470001 34.163567 3.593050 -0.288276 -0.468776 0.730799 3.570253 8.310596 13.213652 -0.443280 -0.431499 -0.401247 -0.379723 -0.368837 -0.362876 -0.344747 -0.315329 -0.265206 0.020994 1.321426 5.244335 10.447276 12.241502 15.520150 61.705624 244.765152 368.891327 262.375549 428.359711 516.571472 226.537216 51.887943 8.826025 0.686951 -0.716139 -0.734988 -0.145661 1.437445 4.551184 11.038701 -0.503120 -0.489500 -0.451100 -0.421125 -0.375464 -0.260276 0.031449 0.465581 0.934045 2.182734 10.195658 43.128304 106.699852 115.809341 65.795616 106.539719 434.957367 640.759583 283.207916 139.571564 104.563255 48.754444 14.222555 2.422977 -0.376907 -0.858499 -0.804408 -0.505030 0.266479 2.207394 6.770300 -0.554645 -0.533770 -0.495957 -0.427844 -0.240611 0.342883 2.102770 5.593367 7.981411 10.575154 42.884735 261.832733 915.396973 1072.856323 402.989960 136.696976 225.837509 304.410675 146.391724 64.536484 43.217800 19.798096 5.207601 0.465959 -0.680550 -0.761979 -0.518481 -0.068194 0.573509 1.779147 3.897725 -0.594674 -0.578001 -0.519854 -0.361648 0.152034 2.143622 9.842216 29.005360 45.036053 37.166588 109.470673 920.518921 4746.329102 5844.087402 1963.532471 622.134827 182.879211 80.282471 39.090107 19.475611 12.960633 7.067722 2.649572 0.277409 -0.489257 -0.302800 0.676779 2.575836 5.942186 11.847789 16.060247 -0.463719 -0.536705 -0.505662 -0.234473 0.798874 5.098727 25.335354 89.334625 141.686996 93.920486 132.448135 1033.489014 5689.846680 12741.428711 29810.460938 14841.376953 1612.388062 176.314957 36.616005 18.817587 26.368589 29.814056 18.324211 6.131657 1.147375 0.805164 3.691023 12.824681 49.377510 160.590637 266.027710 1.198415 0.184406 -0.254262 -0.097049 1.198944 6.618178 31.051273 109.103508 185.297348 107.704430 86.883560 528.040894 4952.224609 105381.828125 104811.343750 101047.062500 15263.387695 972.086548 198.518250 152.616867 456.156830 682.677979 340.413452 69.705193 11.192708 3.248862 9.180939 54.843159 490.780548 3981.448975 10187.540039 17.797287 6.551007 1.466985 0.234182 1.057857 4.737463 18.263258 54.770470 83.757080 53.496609 46.964622 412.373383 10443.416016 196159.359375 200171.015625 108600.492187 30398.109375 4585.248047 1245.749512 1990.659546 19359.500000 46295.156250 11130.756836 856.101013 64.853340 9.834598 17.294310 196.557999 4696.288086 100030.671875 100042.179688 238.358032 66.563927 12.310566 1.721303 1.028870 2.917056 7.046938 14.539111 18.782188 13.852681 25.463278 327.239502 9252.911133 137910.250000 200144.750000 112710.078125 15401.330078 13202.698242 22598.058594 29073.687500 100864.570313 100128.421875 100162.328125 7337.180664 294.527802 35.617645 25.169041 346.232788 14609.455078 100033.796875 100048.976563 4959.389648 702.485535 67.191902 6.952839 2.072204 3.952819 6.616150 6.728879 4.860714 3.292638 10.054830 117.971146 1614.137085 13878.673828 19830.384766 5549.078613 7777.395020 101835.664063 101148.968750 156780.750000 106660.335937 100980.101563 103679.070313 20710.296875 1574.282837 187.785660 41.877975 234.691742 6575.360840 100017.593750 100025.515625 101139.507813 5593.639648 247.405762 17.436314 4.339919 9.103856 14.756395 12.542701 5.920370 1.829234 2.696830 21.186085 138.968445 512.798218 645.453247 613.691223 10434.625000 100229.312500 100501.078125 113404.515625 115011.085937 108194.843750 200114.453125 105493.859375 18528.648438 1339.205200 170.736755 88.747795 791.191711 8526.509766 23301.056641 101548.718750 12234.824219 394.501495 23.087479 6.002580 13.019731 22.614437 19.091064 8.358068 2.502576 1.352774 3.841070 13.418945 31.700796 47.358551 187.827927 3409.656006 95931.062500 100272.039063 101174.054688 13629.982422 43467.835938 106103.671875 113861.890625 128765.656250 21096.402344 1636.976685 134.828247 82.453018 280.284088 514.260315 70346.960938 4006.031494 204.943375 16.593378 4.988125 10.401119 16.964956 14.495339 7.324587 3.972909 5.163325 8.706885 16.474371 33.173260 52.764069 84.434616 443.550568 3244.948486 8114.246582 3708.599609 1248.048096 10810.291016 108026.023437 200094.687500 123470.093750 101402.976563 16478.287109 579.049805 58.270603 23.507454 24.767405 2763.645752 473.415741 68.977753 16.421858 6.072888 5.433847 7.082366 6.744447 5.749829 11.269818 28.037266 55.425091 144.043915 453.876587 1046.501343 801.497620 420.475739 628.502014 740.285461 440.339691 269.165283 1442.384033 21584.482422 107389.539062 104445.507813 117761.320312 55474.046875 3286.977539 258.093658 22.998737 3.278997 206.823257 245.326935 326.810760 176.898987 45.970749 8.562662 2.718611 2.860716 9.291135 39.411560 128.594879 308.408020 1347.354126 12087.754883 70356.015625 38375.519531 7387.458008 17898.679688 11428.687500 1654.969849 224.372345 286.707642 4968.341309 101322.250000 141988.390625 200067.812500 109352.742187 42171.179688 1156.843384 53.719074 3.753614 801.142761 6575.922363 16006.074219 5090.335937 550.058105 45.466270 4.500568 2.686844 16.342262 88.527306 332.531372 1040.984375 8472.148437 106528.687500 102997.062500 103006.468750 151304.375000 101048.156250 100329.703125 19506.171875 626.608582 96.667763 568.568909 6118.154785 113361.007812 105610.226563 100805.187500 100099.226563 1944.695068 71.178932 4.673429 10204.573242 100043.953125 100028.554688 100009.492188 5539.371094 187.252747 11.948997 3.524862 17.370821 91.005241 345.817627 1231.949463 12583.779297 109361.234375 104191.585938 106235.085938 200126.312500 101548.312500 100535.609375 70146.640625 1168.456543 76.737457 92.867302 948.890930 23596.695313 100242.039063 100108.843750 23328.927734 794.317017 44.614849 3.577207 42322.363281 100735.789063 100390.351563 100083.117188 19291.169922 364.831482 18.102627 4.239522 12.392969 48.872837 147.784760 467.441071 3524.489014 97817.984375 101199.851563 102731.617188 117940.039062 103934.570313 113373.218750 29012.117188 1651.654297 129.084503 29.772411 149.832642 1340.659302 6597.308594 6592.483887 1329.104126 140.985092 16.458221 3.109854 23298.759766 117592.304687 105556.812500 100598.742188 8574.434570 248.639420 15.775082 4.952806 9.794453 22.930769 45.743122 98.755745 425.624664 2845.888916 10335.580078 7064.959473 6817.826172 68883.609375 111143.156250 101432.117188 9430.040039 375.959656 26.443857 20.812077 81.680626 205.415466 206.098602 85.599655 29.200466 17.774677 11.202264 64924.976563 119687.085937 93413.789063 15521.147461 1112.294922 80.981674 8.664518 4.623353 7.509430 12.373729 16.684706 21.042803 45.238850 133.629929 270.902527 353.604828 3352.684570 100415.984375 100318.570313 100106.867188 19301.636719 517.537354 29.285124 6.030060 9.323131 15.791608 19.476007 32.947903 77.030190 105.042747 70.682579 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.001883 -0.001936 -0.001963 -0.001936 -0.001870 0.000000 -0.001257 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001399 -0.003385 -0.003558 -0.003656 -0.003677 -0.002301 -0.002269 -0.002192 -0.002060 -0.001427 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001439 -0.003338 -0.003651 -0.003915 -0.004131 -0.004243 -0.005249 -0.005289 -0.005214 -0.003737 -0.003619 -0.001587 -0.001132 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001480 -0.003454 -0.005656 -0.006065 -0.006353 -0.007577 -0.006014 -0.006187 -0.006229 -0.006159 -0.005980 -0.004354 -0.001729 -0.001231 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001470 -0.003503 -0.005694 -0.006211 -0.006666 -0.008148 -0.008568 -0.008821 -0.007173 -0.007286 -0.007210 -0.007031 -0.006703 -0.001845 -0.001302 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001641 -0.001810 -0.001956 -0.002069 -0.002143 -0.002159 -0.002128 -0.002040 -0.001928 -0.003161 -0.003220 -0.003744 -0.006109 -0.007679 -0.008408 -0.009034 -0.009527 -0.009878 -0.011578 -0.010073 -0.010158 -0.010081 -0.009797 -0.001927 -0.001348 0.000000 0.000000 0.000000 0.000000 -0.001688 -0.003103 -0.003436 -0.004911 -0.005270 -0.005511 -0.005636 -0.005631 -0.005500 -0.005133 -0.004907 -0.006088 -0.006677 -0.007631 -0.008054 -0.008262 -0.009099 -0.009849 -0.013603 -0.014403 -0.015059 -0.013711 -0.014001 -0.013970 -0.014611 -0.001955 -0.001368 0.000000 0.000000 0.000000 -0.003132 -0.004929 -0.006877 -0.007669 -0.008396 -0.008979 -0.010426 -0.012329 -0.014080 -0.014058 -0.015197 -0.014696 -0.015413 -0.014235 -0.015852 -0.016980 -0.016152 -0.017963 -0.017267 -0.018665 -0.019816 -0.019165 -0.019124 -0.019704 -0.019850 -0.019539 -0.001941 -0.001358 0.000000 -0.002847 -0.004799 -0.006960 -0.009254 -0.010564 -0.011810 -0.015600 -0.016885 -0.019528 -0.021706 -0.021177 -0.022381 -0.022206 -0.023165 -0.023923 -0.024763 -0.026556 -0.027909 -0.031433 -0.031085 -0.030315 -0.031208 -0.029650 -0.027684 -0.027039 -0.024207 -0.024641 -0.024446 -0.001872 -0.001320 -0.004199 -0.007426 -0.008986 -0.010711 -0.012580 -0.017074 -0.019472 -0.021744 -0.025456 -0.028886 -0.031440 -0.032411 -0.034309 -0.034059 -0.033618 -0.035216 -0.036521 -0.043291 -0.044503 -0.043841 -0.042584 -0.042901 -0.041669 -0.039768 -0.036391 -0.037423 -0.032568 -0.033161 -0.030814 -0.001767 -0.005106 -0.007837 -0.009715 -0.011911 -0.014411 -0.019893 -0.023380 -0.026934 -0.033826 -0.037575 -0.041851 -0.045994 -0.049124 -0.050058 -0.050885 -0.053926 -0.055577 -0.057144 -0.057047 -0.062996 -0.062243 -0.059350 -0.058567 -0.057054 -0.053740 -0.052587 -0.048796 -0.047195 -0.044283 -0.041485 -0.005598 -0.009071 -0.010073 -0.012684 -0.015752 -0.022130 -0.026978 -0.032240 -0.041245 -0.048461 -0.054381 -0.062679 -0.067055 -0.069941 -0.073792 -0.079187 -0.078511 -0.082138 -0.081342 -0.079587 -0.081112 -0.078044 -0.077832 -0.075052 -0.073769 -0.070450 -0.068228 -0.067474 -0.065901 -0.060331 -0.057869 -0.008107 -0.009986 -0.012855 -0.016467 -0.023531 -0.029540 -0.036743 -0.048154 -0.058525 -0.068341 -0.080809 -0.089518 -0.098594 -0.106787 -0.112470 -0.113385 -0.116058 -0.117933 -0.114510 -0.112319 -0.110935 -0.106576 -0.104014 -0.100421 -0.095455 -0.090914 -0.088087 -0.086816 -0.084036 -0.080253 -0.075473 -0.010758 -0.012454 -0.016337 -0.021324 -0.030859 -0.039759 -0.053302 -0.066352 -0.081608 -0.099703 -0.115030 -0.130971 -0.143187 -0.152471 -0.158985 -0.163953 -0.166884 -0.166369 -0.164491 -0.158433 -0.152705 -0.149355 -0.142435 -0.134175 -0.127045 -0.120107 -0.115345 -0.108043 -0.106016 -0.100713 -0.093222 -0.012650 -0.015409 -0.020627 -0.030437 -0.040430 -0.053052 -0.072211 -0.092102 -0.115192 -0.138154 -0.155155 -0.169296 -0.182568 -0.198782 -0.209748 -0.221986 -0.229127 -0.229994 -0.227114 -0.221125 -0.210608 -0.202032 -0.191230 -0.179377 -0.169043 -0.155802 -0.149053 -0.139120 -0.129275 -0.123224 -0.113855 -0.013870 -0.018909 -0.025917 -0.038697 -0.052539 -0.073679 -0.096958 -0.124432 -0.149168 -0.165444 -0.184444 -0.201782 -0.219561 -0.237567 -0.254897 -0.274031 -0.282927 -0.287902 -0.291088 -0.282654 -0.274702 -0.263926 -0.250785 -0.236606 -0.223201 -0.205591 -0.188779 -0.170378 -0.159890 -0.146452 -0.134375 -0.016503 -0.022978 -0.034978 -0.048831 -0.067472 -0.094378 -0.122739 -0.151261 -0.168971 -0.181333 -0.183105 -0.164638 -0.126831 -0.120236 -0.169257 -0.250844 -0.306440 -0.323642 -0.326776 -0.321771 -0.320760 -0.318194 -0.312540 -0.299376 -0.281244 -0.261218 -0.237036 -0.210916 -0.191266 -0.171649 -0.156452 -0.019358 -0.027518 -0.042478 -0.060339 -0.085361 -0.112091 -0.142816 -0.161268 -0.155530 -0.097185 0.081471 0.471857 1.149925 1.509768 1.141045 0.480335 0.129656 0.026990 -0.024033 -0.077166 -0.147980 -0.229408 -0.300337 -0.334766 -0.332866 -0.314907 -0.285490 -0.257824 -0.226567 -0.200685 -0.182249 -0.022293 -0.033376 -0.050435 -0.072282 -0.097869 -0.127192 -0.151932 -0.128725 0.012662 0.471511 1.745759 5.285308 12.822518 19.384953 14.690970 7.039851 4.437738 3.804096 3.139004 2.643808 1.861312 1.046725 0.341080 -0.119809 -0.304378 -0.349077 -0.338294 -0.309358 -0.270047 -0.236217 -0.206097 -0.025082 -0.038135 -0.058150 -0.081206 -0.106847 -0.134696 -0.109475 0.095768 0.813421 2.923403 9.609878 35.552284 127.824287 245.520142 165.237000 58.856991 46.941814 41.860847 29.937613 25.146772 20.132210 13.026243 6.470603 1.928661 0.176625 -0.301228 -0.371651 -0.352501 -0.315956 -0.278975 -0.238023 -0.027581 -0.042510 -0.064105 -0.085794 -0.111791 -0.106970 0.110818 1.095011 4.041373 11.646937 34.753887 167.464188 1090.190674 2874.774902 1625.130127 393.352386 569.313782 507.875214 250.146759 228.128845 227.879822 187.336380 82.550377 19.095596 3.216609 0.117135 -0.363900 -0.402326 -0.366835 -0.323986 -0.278491 -0.029406 -0.045395 -0.066828 -0.092453 -0.102764 0.011709 0.884363 5.094986 18.274630 41.031570 86.155952 391.734528 3756.207275 13448.406250 5870.846680 1512.888672 4823.852051 4161.715332 1409.563599 1969.075928 5125.291504 6115.477051 1546.801270 178.248672 18.783911 1.680955 -0.233410 -0.443255 -0.417114 -0.370537 -0.317687 -0.032194 -0.048411 -0.067576 -0.094223 -0.079171 0.240559 2.822428 17.375547 76.132469 166.669434 176.929565 330.003174 2278.551514 6965.034668 3241.939209 1927.440063 10222.563477 8050.912598 3640.965332 19363.843750 101184.625000 100230.820313 46315.382813 1427.185547 70.675606 5.167596 0.047771 -0.456049 -0.460482 -0.419183 -0.360227 -0.035686 -0.051320 -0.073007 -0.093139 -0.059047 0.464373 4.846855 34.726093 185.980270 439.982086 330.612518 171.943634 382.183502 800.910400 522.533936 597.384949 2200.631104 2214.738525 3661.828613 103284.859375 102158.250000 100536.179688 100087.265625 5105.238281 139.825531 8.776537 0.308237 -0.467390 -0.500847 -0.450220 -0.384477 -0.040832 -0.054934 -0.071231 -0.091620 -0.059329 0.437115 4.304192 32.462566 161.193939 375.170990 269.100555 87.296593 50.460640 62.624725 55.859806 88.687759 224.130905 435.620667 2315.866943 73848.843750 104153.601563 100958.914063 100133.648438 3676.837891 118.845665 8.172950 0.344750 -0.480071 -0.488051 -0.359146 -0.230335 -0.046388 -0.055143 -0.069378 -0.091494 -0.084432 0.186512 2.183342 13.310340 53.088654 108.002342 84.363457 28.447721 9.666800 6.615616 7.573852 21.684965 102.269234 419.599274 1266.438232 7411.403809 65206.929688 96444.710938 11218.923828 656.183777 49.600407 5.024633 0.199109 -0.412438 -0.192104 0.413952 1.116485 -0.053597 -0.061728 -0.077134 -0.091532 -0.106174 -0.025749 0.574257 3.189083 9.916697 16.751434 13.360401 5.853743 1.603414 0.923990 3.906036 28.384901 222.302063 1197.014648 2057.557861 1304.379761 1468.564941 1386.593140 459.142944 83.968872 15.511122 2.750720 0.171799 0.010539 1.250314 4.597825 9.361471 -0.064179 -0.063725 -0.081685 -0.093028 -0.115547 -0.121095 -0.025716 0.378678 1.181885 1.889570 1.505794 0.492182 -0.010416 0.649914 5.206514 32.484253 227.476669 1179.824463 1916.674805 741.233459 198.544449 122.254898 84.458328 37.289692 11.652278 2.624670 0.612376 1.531126 6.392154 22.418020 48.709003 -0.077423 -0.073930 -0.082933 -0.098279 -0.116191 -0.142603 -0.166890 -0.154445 -0.109663 -0.105045 -0.205200 -0.308074 -0.101459 1.358584 7.206243 29.968657 113.364479 333.027008 483.664337 231.388824 242.201492 1111.615356 1663.287109 501.235138 66.421700 7.481133 2.426965 6.118807 18.993914 66.313423 156.901138 -0.094622 -0.086381 -0.090066 -0.107825 -0.124098 -0.146699 -0.187401 -0.230702 -0.283880 -0.349211 -0.404582 -0.362739 0.129998 2.267446 9.362774 28.841999 61.720196 84.473022 85.219711 179.625824 3102.712646 76109.343750 100037.531250 16692.626953 538.420898 27.827545 7.239780 18.299437 40.850636 102.651093 236.771133 -0.117201 -0.106708 -0.104768 -0.118015 -0.137338 -0.161122 -0.194514 -0.241823 -0.294825 -0.366770 -0.417268 -0.351788 0.273401 2.931981 10.873248 29.502026 53.080673 53.024410 76.175163 539.167542 19334.421875 100984.085938 100365.726563 100061.835938 1968.208374 59.218887 14.453471 36.448845 73.463562 95.774574 148.524887 -0.145997 -0.129849 -0.123327 -0.130000 -0.148439 -0.171323 -0.206582 -0.247268 -0.304066 -0.373066 -0.433566 -0.382417 0.197541 2.998253 14.542495 50.629833 100.229500 95.142166 204.705704 1760.711914 20596.296875 112223.515625 102660.429688 100263.156250 1422.406982 50.810371 15.515606 42.944805 77.008789 76.236717 60.392025 -0.180260 -0.155277 -0.151021 -0.155657 -0.167071 -0.191010 -0.220474 -0.262417 -0.312954 -0.380993 -0.456791 -0.456295 -0.020742 2.640254 15.960575 66.754951 142.142853 172.776733 665.376343 5489.359375 32778.785156 55213.355469 31950.849609 4422.437988 290.342651 20.921087 9.568619 25.970905 47.842422 48.592331 34.786446 -0.215539 -0.194200 -0.184926 -0.183201 -0.195090 -0.219158 -0.248102 -0.285771 -0.336565 -0.401479 -0.480382 -0.527254 -0.305783 1.426218 10.057688 40.886662 91.641541 306.966309 6065.570312 102172.195313 111786.570312 39016.589844 4277.313477 494.566498 57.419044 6.957914 4.555511 14.280053 31.197227 39.435307 30.516453 -0.259504 -0.234957 -0.224062 -0.220734 -0.233370 -0.255214 -0.285642 -0.322440 -0.369272 -0.434421 -0.511803 -0.581378 -0.521115 0.189364 3.485655 14.281063 46.753506 525.716309 27372.099609 103396.375000 113168.773437 109049.578125 3709.268555 239.520554 24.343740 2.722886 2.150450 8.976287 23.182552 32.558823 25.062513 -0.308823 -0.290504 -0.271765 -0.260888 -0.272450 -0.284973 -0.313083 -0.350429 -0.395934 -0.460696 -0.528821 -0.589419 -0.562771 -0.077932 2.811985 14.873982 57.850170 415.848969 12678.057617 104794.046875 121328.289062 82842.117188 2839.365479 183.074936 16.070932 1.222387 0.683965 4.155752 11.090291 16.729174 12.946766 -0.359567 -0.340205 -0.319089 -0.304370 -0.301656 -0.309265 -0.329052 -0.347957 -0.382515 -0.436848 -0.458479 -0.399691 -0.179913 1.156038 13.435879 110.735550 549.922791 985.821533 1764.743774 11151.927734 19969.857422 6141.741211 811.358398 83.965576 8.446803 0.264869 -0.275835 0.945876 3.305693 5.087970 4.311352 -0.410356 -0.386911 -0.361142 -0.327446 -0.298080 -0.244186 -0.141191 0.013211 0.055538 0.000188 0.132078 0.829365 2.036768 5.544337 47.484833 733.643188 7595.506348 16782.849609 4006.889893 2736.632080 2818.946289 954.823792 187.177704 27.963118 3.187101 -0.406173 -0.689789 -0.331172 0.282211 0.869994 1.183084 -0.463893 -0.436352 -0.387917 -0.281569 -0.086430 0.386128 1.566731 3.606668 4.697451 3.641164 3.184520 6.743103 13.019585 19.329844 81.743233 1525.030884 25256.292969 67870.523438 8990.573242 2899.521484 2327.315430 586.840149 87.661537 11.804834 0.952646 -0.555663 -0.504863 -0.182764 0.036846 0.219246 0.560569 -0.513345 -0.477037 -0.363647 -0.037129 0.823101 3.532944 13.231543 39.761574 56.859161 37.672138 17.822775 27.198418 61.642670 73.394806 86.787109 645.149475 6908.240723 13673.816406 2999.916260 887.598877 651.802124 217.520599 37.586651 5.008877 0.146257 0.055129 1.392037 3.065032 3.493869 3.091984 3.033187 -0.555775 -0.492928 -0.259883 0.596611 3.463163 15.166636 83.987419 376.861053 728.875854 348.738007 81.666168 69.102058 173.834732 249.265167 242.602356 233.496613 506.213776 697.007690 298.924591 135.362793 99.710793 40.184162 10.301885 1.791360 0.373065 2.716588 9.815319 19.666941 24.563669 24.939823 26.379313 -0.471617 -0.456206 -0.091297 1.657193 8.603544 40.635609 300.164978 2432.627441 5789.365234 2227.200439 259.877441 112.242371 393.662354 1346.337036 2589.424561 1585.431152 336.853790 86.317238 35.772739 24.845673 26.687046 24.991831 14.076998 4.758827 2.368735 8.941891 35.475937 80.107697 129.672928 254.147095 389.686188 0.707621 0.006802 0.153317 2.538365 12.688777 56.918354 411.033813 3736.484131 9177.348633 3125.097656 342.017761 219.489380 2877.250000 33226.722656 56001.078125 14454.870117 1537.704956 160.980850 48.582977 78.642845 232.912079 341.647430 176.990875 44.541214 10.478637 16.432163 67.742104 197.868027 802.269104 6226.546387 17821.468750 10.798485 3.306334 1.073069 2.754428 11.784766 42.335251 184.771133 1014.715698 2054.958496 920.122437 158.763657 650.494507 43961.464844 108540.000000 141874.453125 89023.679688 2934.967041 352.006805 234.160263 818.401733 5565.610840 11131.691406 3670.201416 407.612274 49.289494 21.027153 68.517555 371.748749 7370.501953 100556.867188 100993.695313 103.424881 24.631594 5.295327 3.358526 9.642240 24.600929 55.098049 134.065582 192.321518 111.390862 53.979130 765.004700 76332.750000 102447.265625 108538.921875 105178.921875 2140.258301 1117.627197 1956.777466 6951.013672 100197.421875 100132.070313 70096.945313 2813.337158 264.696350 51.023067 50.280262 505.521759 25799.603516 100652.250000 101228.562500 895.371338 145.119736 21.650587 6.281222 13.770524 39.051697 66.022408 60.898094 35.252804 16.018604 17.750391 245.785156 6954.067871 100279.679688 100647.507813 10669.916992 1196.136597 6697.252930 21580.638672 21150.240234 101005.117188 102016.304688 113367.695312 22291.931641 3571.117187 331.481903 56.402328 320.197968 10238.609375 100264.226563 100448.164063 5307.349121 561.584534 57.531376 11.602345 31.572939 116.399986 246.794312 190.142654 63.568150 14.576573 6.797969 36.768429 325.352997 1548.992065 1708.863281 519.514221 1211.904541 14636.958008 51429.511719 21914.294922 88307.656250 138046.593750 142077.812500 102142.531250 100473.492188 2308.474121 158.361755 101.212357 1072.908325 13369.916016 41931.207031 8906.448242 885.858459 80.447899 14.554024 47.029392 214.365204 479.466614 390.147064 114.509300 22.769890 8.729586 10.033709 22.617241 50.082291 58.698776 73.131058 526.297180 4323.288574 12231.668945 5615.619629 5416.921387 105756.562500 102694.296875 103424.562500 108053.203125 9267.529297 699.181824 90.734634 97.250000 372.270508 690.389343 3142.870361 442.006134 51.380226 11.623681 34.993286 154.735519 340.079559 261.394714 87.645401 28.934624 29.002029 32.922905 29.664320 35.661484 42.979935 47.017910 120.665581 501.074860 944.347473 621.488525 1330.757690 51633.757813 102404.726563 142345.125000 200411.562500 66220.304688 4120.792480 397.583130 62.284412 27.308950 30.405621 448.858856 107.143074 29.124578 13.767717 17.465382 49.225029 88.814575 76.550957 43.946461 71.010048 186.213699 252.588989 229.888718 435.589111 640.592102 439.481140 193.682098 190.900192 181.857529 118.532753 259.845154 3074.719727 26813.005859 131585.593750 109902.406250 138437.109375 44086.980469 4986.372070 347.580780 29.499130 4.244010 94.197144 170.097839 231.222321 128.835205 39.244076 15.617757 17.237688 19.831427 55.440411 375.105164 1814.160034 2775.598145 2179.683838 8565.916016 19152.503906 9712.216797 2113.566162 2384.992920 1686.620850 387.736755 91.065041 248.300812 1801.315063 21689.339844 186613.953125 131957.250000 102943.187500 100407.687500 1842.259277 76.146561 4.947966 556.667053 3967.789062 8521.691406 3104.280273 389.286438 37.457314 7.041670 13.221883 111.237556 1232.719360 10208.486328 17951.404297 13548.457031 146780.984375 200122.625000 110638.078125 18354.082031 42276.671875 25680.197266 2462.936035 191.133484 58.097740 319.625793 4340.174805 103180.070313 103472.859375 102367.734375 100583.125000 3185.884033 103.346886 6.150363 5546.931641 100010.523438 100006.757813 100002.304688 3366.585693 145.458847 12.384335 15.935815 119.416595 1347.630493 10234.649414 18088.529297 17944.503906 200530.093750 200148.812500 115867.773437 40941.464844 100621.437500 95945.171875 6101.878418 306.404266 36.796227 88.646004 1353.496338 51676.097656 101306.304688 101344.523438 57118.406250 1283.419678 65.302177 4.429341 19345.099609 100089.789063 100058.382813 100017.367188 10171.791992 262.108185 23.255457 27.433758 94.317886 497.012085 2086.339600 3150.619629 4178.631836 37676.273438 122099.421875 73203.382813 12742.627930 42516.238281 26563.658203 3126.150391 352.918549 43.192917 28.350063 213.741150 2188.785400 12432.306641 12428.329102 2186.854492 209.225189 20.882292 1.875448 9721.084961 100652.414063 100352.289063 100083.843750 5103.625488 193.794708 32.136345 59.254879 109.604630 263.038757 457.825989 426.947479 488.576813 1700.540161 3859.791260 2615.082275 1506.548584 4402.387695 8820.436523 5046.089355 780.912842 80.777466 13.736937 28.264397 123.830688 310.968597 312.510040 124.216545 28.278925 6.313625 1.998569 2432.725098 12682.877930 24532.095703 7399.293945 717.485535 65.163170 32.830376 73.086342 105.002945 167.285034 211.511978 138.253387 75.850929 107.983658 164.387680 163.507294 471.681580 3790.534668 14704.365234 8561.835937 1145.411743 105.266487 15.808656 11.358617 20.025358 28.077406 24.137003 14.461526 11.032338 11.187953 9.860260 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.001794 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002004 -0.002103 -0.002177 -0.002192 -0.002162 -0.002088 -0.001976 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.005130 -0.005465 -0.005728 -0.005877 -0.004171 -0.004215 -0.004146 -0.003996 -0.002518 -0.002365 -0.001239 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.003426 -0.005512 -0.006016 -0.006414 -0.006742 -0.006926 -0.006964 -0.006869 -0.004938 -0.005760 -0.005547 -0.003885 -0.001417 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.003535 -0.003919 -0.006334 -0.006919 -0.007419 -0.007807 -0.008026 -0.009126 -0.009128 -0.008970 -0.006965 -0.006681 -0.006284 -0.001576 -0.001124 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003496 -0.003960 -0.006360 -0.007103 -0.007823 -0.008397 -0.009913 -0.010345 -0.010617 -0.010663 -0.010478 -0.010110 -0.007993 -0.007527 -0.001717 -0.001214 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001736 -0.001797 -0.001810 -0.001785 -0.001724 -0.004936 -0.003823 -0.006160 -0.007002 -0.007865 -0.008674 -0.010473 -0.011185 -0.011783 -0.012129 -0.012248 -0.013599 -0.013342 -0.011148 -0.010655 -0.001832 -0.001293 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001688 -0.001901 -0.002098 -0.002269 -0.002402 -0.002489 -0.002507 -0.002471 -0.002385 -0.005775 -0.006164 -0.008442 -0.009201 -0.008497 -0.012154 -0.013321 -0.014257 -0.016366 -0.017080 -0.019028 -0.019115 -0.017353 -0.016865 -0.014574 -0.001913 -0.001339 0.000000 0.000000 0.000000 -0.001653 -0.003127 -0.003561 -0.003977 -0.006794 -0.007241 -0.007535 -0.007679 -0.007643 -0.007863 -0.009094 -0.011034 -0.010212 -0.011283 -0.011946 -0.015452 -0.016443 -0.014515 -0.020405 -0.021884 -0.023064 -0.023795 -0.024127 -0.025001 -0.022972 -0.019240 -0.001941 -0.001358 0.000000 0.000000 -0.003016 -0.003601 -0.006717 -0.007708 -0.008623 -0.009481 -0.011858 -0.012484 -0.015710 -0.016038 -0.016002 -0.017083 -0.020165 -0.018650 -0.020437 -0.023237 -0.024847 -0.025492 -0.027420 -0.026224 -0.026389 -0.027970 -0.030203 -0.031004 -0.030261 -0.029982 -0.025994 -0.001927 -0.001348 -0.001164 -0.003245 -0.005408 -0.007780 -0.010323 -0.011881 -0.015078 -0.017651 -0.020930 -0.022283 -0.023213 -0.025196 -0.024103 -0.026232 -0.027721 -0.028773 -0.036368 -0.039729 -0.038272 -0.041920 -0.041665 -0.040893 -0.039705 -0.042214 -0.037046 -0.038482 -0.039208 -0.038235 -0.034736 -0.001858 -0.002532 -0.004715 -0.008220 -0.009981 -0.011983 -0.015779 -0.018418 -0.022169 -0.026723 -0.029365 -0.033121 -0.034787 -0.036763 -0.038524 -0.040921 -0.046081 -0.045681 -0.054048 -0.054390 -0.057735 -0.057114 -0.056839 -0.055755 -0.055946 -0.054549 -0.054188 -0.054094 -0.050153 -0.050355 -0.048697 -0.002994 -0.007179 -0.008627 -0.010806 -0.013320 -0.017925 -0.021581 -0.026797 -0.033057 -0.037662 -0.043600 -0.048405 -0.052859 -0.057482 -0.060757 -0.063185 -0.063391 -0.070361 -0.071600 -0.072957 -0.072832 -0.072789 -0.072501 -0.073579 -0.072934 -0.072924 -0.073304 -0.072404 -0.071415 -0.066569 -0.066248 -0.005926 -0.009882 -0.011168 -0.014136 -0.019436 -0.025188 -0.030984 -0.039229 -0.048059 -0.055692 -0.063605 -0.072875 -0.079171 -0.084710 -0.087420 -0.092427 -0.092966 -0.097251 -0.098327 -0.098399 -0.095836 -0.094843 -0.093950 -0.092422 -0.093235 -0.092937 -0.092109 -0.092671 -0.092943 -0.090489 -0.085058 -0.008825 -0.011029 -0.014321 -0.018539 -0.025848 -0.034059 -0.044539 -0.056282 -0.067843 -0.080557 -0.094756 -0.105309 -0.115612 -0.124487 -0.129942 -0.133440 -0.135498 -0.135378 -0.135047 -0.134209 -0.130507 -0.127313 -0.125704 -0.123066 -0.119885 -0.118429 -0.118224 -0.116923 -0.115823 -0.113031 -0.105030 -0.011703 -0.013838 -0.018343 -0.026067 -0.035481 -0.046223 -0.061201 -0.078598 -0.096716 -0.116084 -0.133985 -0.147399 -0.159772 -0.169909 -0.176719 -0.181797 -0.186125 -0.187635 -0.184120 -0.179069 -0.175396 -0.171444 -0.165838 -0.159846 -0.156619 -0.153091 -0.150871 -0.145428 -0.141994 -0.136363 -0.126277 -0.013857 -0.017220 -0.024964 -0.034757 -0.046826 -0.064249 -0.085338 -0.108443 -0.134465 -0.153417 -0.165387 -0.181019 -0.196841 -0.212939 -0.226525 -0.240803 -0.246721 -0.253830 -0.252050 -0.245621 -0.239108 -0.228702 -0.219577 -0.210727 -0.203138 -0.193395 -0.189782 -0.184449 -0.170618 -0.161217 -0.150889 -0.015400 -0.021317 -0.031341 -0.044668 -0.061686 -0.086661 -0.112066 -0.141086 -0.160091 -0.173767 -0.191256 -0.203506 -0.210772 -0.225732 -0.256001 -0.290384 -0.309307 -0.319932 -0.329856 -0.326478 -0.314463 -0.303524 -0.292194 -0.280044 -0.264646 -0.251857 -0.237199 -0.222311 -0.201369 -0.185812 -0.171956 -0.018405 -0.025994 -0.039973 -0.056697 -0.080839 -0.109515 -0.139940 -0.160718 -0.168578 -0.158272 -0.109379 -0.014131 0.083536 0.116668 -0.008802 -0.191265 -0.324570 -0.376417 -0.384106 -0.387168 -0.380819 -0.372715 -0.357601 -0.346540 -0.330988 -0.312954 -0.289808 -0.264598 -0.233927 -0.212803 -0.190951 -0.021707 -0.032797 -0.048763 -0.070385 -0.098807 -0.126627 -0.151929 -0.149973 -0.067804 0.192306 0.782621 1.793972 3.422866 4.384765 3.094925 1.184558 0.097039 -0.254872 -0.341433 -0.353034 -0.357077 -0.372864 -0.386553 -0.391474 -0.380948 -0.363496 -0.339011 -0.311618 -0.274530 -0.239797 -0.217247 -0.025036 -0.038604 -0.058192 -0.083352 -0.111376 -0.138468 -0.139424 -0.003626 0.583493 2.477970 6.965253 17.927149 44.013203 70.638145 47.539112 16.252607 3.623115 0.998385 0.556915 0.501940 0.478593 0.282608 -0.022782 -0.269214 -0.379444 -0.401100 -0.383859 -0.356947 -0.320603 -0.282232 -0.250189 -0.028310 -0.045131 -0.066902 -0.090705 -0.120253 -0.129283 0.012616 0.784935 3.851104 14.873165 47.948433 163.254150 823.702271 2059.304443 1075.199219 187.437881 25.784330 8.555695 6.307181 6.784011 7.620516 6.728915 3.766732 1.191365 0.008032 -0.348882 -0.423797 -0.402593 -0.372503 -0.328229 -0.286568 -0.031123 -0.049979 -0.072546 -0.096492 -0.116924 -0.018264 0.726951 4.523402 19.100346 75.267387 288.871552 1311.337402 20154.080078 100066.289063 36879.574219 1900.119263 124.233650 44.377094 36.032501 52.097649 86.409569 85.997528 41.444759 11.806615 2.371964 0.107278 -0.390420 -0.450520 -0.417398 -0.378786 -0.329716 -0.033222 -0.053270 -0.075070 -0.098976 -0.082377 0.342701 3.727875 26.421885 127.520302 393.663391 1052.327026 4569.016602 100917.195313 100178.296875 100032.687500 6992.483398 316.272430 152.724670 164.054962 470.012787 1447.691162 1590.297729 530.715576 89.377731 13.010432 1.712292 -0.166316 -0.470610 -0.467987 -0.426418 -0.375128 -0.036095 -0.054296 -0.075892 -0.095670 -0.010794 1.132542 12.874253 133.609360 1181.398804 4219.180664 3395.044434 4011.041504 71649.289063 100204.890625 100038.234375 4119.101074 322.524323 275.168549 817.154968 5401.153320 36460.519531 51793.160156 7263.171387 541.346313 45.401161 5.375659 0.306590 -0.441245 -0.502294 -0.468268 -0.418094 -0.038010 -0.055473 -0.075129 -0.090068 0.058805 1.983649 24.143427 373.735779 5297.538086 29995.574219 15160.489258 2168.279785 3561.842773 11172.809570 4855.507324 539.469788 157.220627 463.244659 5708.953613 60966.996094 151278.921875 106646.265625 42353.304688 1418.172974 93.069847 10.574003 0.988994 -0.378926 -0.516376 -0.458877 -0.387557 -0.039012 -0.055384 -0.077080 -0.090549 0.052258 1.762318 22.630215 322.773773 4426.771484 22033.039063 11140.225586 1114.321899 269.797791 306.006927 181.099152 68.267235 134.160110 977.768982 20100.068359 109502.703125 200092.562500 125809.289062 26824.498047 1281.333008 113.665703 14.783001 1.783660 -0.200095 -0.349578 -0.093802 0.211641 -0.046614 -0.054903 -0.076479 -0.091823 -0.019131 0.930529 10.000684 94.294014 727.468384 2048.751465 1368.087036 256.819275 42.565670 20.421162 18.174934 64.137764 669.514771 5759.392578 19512.515625 103963.968750 108795.429687 24519.910156 3523.606201 487.613647 86.959877 16.478178 2.798392 0.376394 0.793334 3.038139 5.980529 -0.050392 -0.059979 -0.076725 -0.092552 -0.083390 0.218770 2.436100 14.914407 64.027061 131.375183 95.048767 31.819769 7.530231 4.125206 15.138448 152.195160 3170.616943 70715.726563 101093.843750 29575.958984 6774.042480 1855.399658 456.803680 167.567642 67.396118 19.657829 4.569322 2.345287 7.180193 27.578169 61.430347 -0.058778 -0.063097 -0.081958 -0.093635 -0.111065 -0.062491 0.312216 1.775777 5.560787 9.297824 7.398070 3.265744 1.596912 4.296265 20.735388 168.926132 3197.230469 78990.765625 100123.328125 24628.408203 1197.640015 209.826752 113.393631 99.135040 61.033375 21.455223 6.940938 9.367772 38.175453 192.105087 635.809814 -0.070533 -0.069039 -0.082454 -0.094006 -0.111150 -0.137340 -0.127596 0.000515 0.280023 0.466673 0.346800 0.374002 1.993703 9.182946 29.513525 99.356262 748.974976 5852.842285 12231.710938 2899.308594 326.754761 276.391602 346.753021 175.152145 55.893230 17.562029 14.086619 40.287838 148.642319 947.016541 4695.033691 -0.082714 -0.078851 -0.082433 -0.097774 -0.117228 -0.145383 -0.184317 -0.219325 -0.251980 -0.294998 -0.256211 0.387455 4.037495 18.249847 53.568985 95.218697 155.036758 340.705841 433.912750 227.449753 548.110840 4356.348633 6911.107422 1667.303955 154.552353 22.893875 45.141659 189.864685 500.796082 1792.732910 9383.571289 -0.103257 -0.089834 -0.093637 -0.104869 -0.124942 -0.151372 -0.191185 -0.237216 -0.295230 -0.352220 -0.285922 0.519798 5.275322 24.780523 86.591568 225.309464 403.526184 291.001129 128.405884 166.845535 1898.867187 31317.839844 67824.171875 8359.528320 372.508514 36.400822 117.085892 645.310486 1614.436523 1691.161133 3335.738037 -0.126730 -0.109302 -0.106722 -0.115568 -0.133406 -0.162213 -0.200915 -0.244458 -0.299741 -0.353882 -0.320896 0.318575 4.055247 23.664707 140.056839 890.899414 2902.811768 1800.875854 461.285828 409.678680 1727.947144 18903.298828 38933.757813 5244.802246 301.599182 36.250214 132.442551 798.163086 2133.243652 1469.542725 664.691040 -0.158247 -0.135288 -0.131746 -0.143726 -0.151764 -0.177496 -0.214618 -0.254733 -0.304798 -0.366269 -0.386158 -0.042684 2.376266 19.496422 182.562180 1614.689575 6369.167969 3886.589844 1121.648071 1496.316284 2150.696289 2712.334961 2545.842529 701.225281 84.789841 18.940098 72.539856 352.901489 805.234070 681.851929 275.064941 -0.191495 -0.170619 -0.166792 -0.171359 -0.179945 -0.203815 -0.237006 -0.276042 -0.320036 -0.383601 -0.441476 -0.337588 0.853087 10.293560 90.802895 680.837036 2085.643066 1543.987549 2103.500488 11358.484375 32330.216797 17008.673828 2080.165527 222.899521 28.868093 8.243954 29.232157 135.944809 439.978302 713.831421 396.117065 -0.231421 -0.213391 -0.206103 -0.205597 -0.212030 -0.235719 -0.267952 -0.306297 -0.353929 -0.412410 -0.481268 -0.499454 -0.059463 3.121809 23.525873 107.059753 265.216888 481.722809 4673.002441 113549.757812 151045.250000 106474.937500 13754.212891 486.212921 31.391699 4.798353 15.354912 90.764114 375.806763 690.658386 394.095032 -0.277500 -0.257786 -0.244730 -0.238777 -0.242549 -0.256068 -0.284561 -0.323897 -0.372365 -0.435916 -0.506951 -0.566567 -0.429377 0.875528 8.586331 43.681641 147.214371 419.817596 4824.916504 112760.859375 120407.289062 103581.656250 23575.953125 615.646606 33.105057 3.145566 7.379407 38.885147 146.052017 244.063248 145.422562 -0.325799 -0.306527 -0.281213 -0.252492 -0.234762 -0.235792 -0.251562 -0.266188 -0.309233 -0.388534 -0.485025 -0.536261 -0.310431 2.464631 33.927670 429.828186 3645.284424 7176.008301 4857.000000 32506.724609 110684.421875 88219.226563 5305.840820 281.751282 19.351303 1.433672 1.911162 10.131002 28.392422 42.699135 30.098728 -0.370899 -0.344016 -0.284623 -0.165130 0.000273 0.179615 0.382658 0.649946 0.737413 0.400034 -0.048751 -0.217624 0.331171 7.820503 154.216309 5210.923340 100041.195313 100613.242188 67527.335938 102210.289063 103223.179688 12296.180664 904.753662 83.282646 8.233991 0.243430 -0.039294 1.486648 4.121258 5.482428 4.140780 -0.421309 -0.358486 -0.151145 0.380629 1.337082 2.655104 5.524742 11.541233 15.216791 9.928867 3.676948 1.343807 2.064066 12.119052 274.231171 16685.318359 100041.242188 100684.156250 116021.218750 102604.757813 100189.460938 12266.041992 585.444275 39.916294 3.599771 0.148172 0.679792 1.718621 2.145239 1.682010 1.397497 -0.463727 -0.322099 0.252790 2.032428 6.454049 16.012951 51.666130 178.706177 302.570312 161.124588 37.365589 8.477822 6.825102 15.029301 140.654449 4755.050781 100022.078125 100243.898438 46128.945313 18570.572266 16048.614258 2451.057373 202.930679 18.077034 1.954717 2.824926 10.070596 19.188282 20.069359 12.052367 9.040206 -0.490177 -0.230775 0.958768 5.872418 22.953770 81.261520 495.585846 4464.790039 12205.147461 4053.157959 374.341370 35.899029 22.058168 38.528934 70.344452 367.177673 2786.758301 5253.318848 1547.869751 856.608154 742.422974 229.497528 38.778393 5.532173 3.124053 17.910791 77.895576 189.122101 184.065048 92.593445 59.940426 -0.449370 -0.135839 1.838122 12.549431 66.516418 313.700836 3208.141602 100201.296875 100051.632813 88325.320313 2228.327881 110.394463 123.127045 395.827850 478.281647 236.022629 137.204391 126.000809 77.109947 57.972580 50.159439 27.477068 10.218493 3.584436 8.833448 68.997894 447.945496 1432.733521 1386.761230 623.984375 517.788330 0.244558 0.130074 2.533759 19.265043 125.796700 651.268372 5336.727539 100480.828125 100106.718750 100016.492188 3412.813232 220.183640 1713.497314 16915.310547 18960.451172 2671.781982 242.339996 37.376984 16.740818 26.692236 59.307789 76.210457 44.919621 16.686325 17.484148 137.354034 1140.091309 4743.063477 4881.878906 4632.883789 8810.621094 5.658058 1.609865 3.176228 19.961218 118.667862 500.789917 1910.162720 22440.675781 88413.031250 18035.740234 936.347839 489.450867 22797.265625 100299.054688 100682.804688 35259.921875 757.819702 66.893280 45.530308 143.222519 558.342651 854.133789 432.814911 101.886154 33.855892 112.522324 860.860107 3562.052002 6172.510254 54571.597656 163005.796875 45.582836 9.203194 4.765587 19.648302 83.240082 233.618469 428.656250 910.430359 1529.853760 686.383911 130.760040 554.793396 38804.746094 100145.632813 100298.906250 60709.914063 888.814880 127.233788 178.139160 632.894165 4009.230469 7254.168457 2698.148682 609.154114 167.373474 75.169075 239.747055 884.882446 7620.132324 125811.039062 200044.703125 313.946106 36.073135 9.220957 23.294214 107.258614 373.562775 737.658569 557.536987 197.406204 60.401718 26.031099 182.770554 4345.379883 76066.921875 96055.867188 6334.145508 342.814331 290.615295 562.169006 1201.366211 8020.903809 17342.421875 12569.076172 10177.535156 2302.716553 266.839996 73.923729 253.672455 3256.051758 67589.687500 113330.453125 1246.721436 93.246094 16.185278 32.969364 256.421783 2137.139160 7199.228516 4700.075195 796.312439 86.703712 18.660418 35.856468 241.962173 1099.829956 1196.716797 315.307861 129.783554 401.057220 784.728149 904.490540 3633.109863 23346.771484 105597.132813 105387.578125 47679.394531 1634.142456 111.327454 73.188484 513.344910 3758.975098 8539.954102 1697.696289 120.019691 18.568098 40.816395 486.400391 6041.738770 28242.480469 16014.000977 1800.026489 160.443771 54.217789 45.551479 36.843578 45.002602 44.208435 29.149502 57.455288 204.432938 385.215393 388.286530 1785.991211 72562.031250 119609.328125 128570.343750 105652.195313 3858.352051 255.841095 50.992519 65.344055 198.613403 326.175476 651.086243 71.098381 13.546211 31.011673 319.288452 3107.716064 13327.897461 7823.487793 1166.463013 188.390396 213.801956 227.906219 114.905754 55.485073 38.239174 24.543100 25.661684 54.643986 89.308701 116.574028 882.076172 25159.708984 113577.484375 120711.117187 70228.203125 4111.462891 808.982361 199.659317 44.703430 20.786144 20.791708 123.796722 26.531570 10.753579 15.833981 90.213974 515.132568 1323.328125 997.814636 298.235931 378.068939 1259.937988 1684.678223 814.839111 737.107605 679.784485 260.856934 73.327835 42.483727 36.500450 41.231869 214.845291 2249.795898 14318.340820 20734.876953 11713.414063 13285.620117 10482.332031 2131.276611 237.336853 25.552027 3.659386 34.885426 52.887482 70.249969 45.739735 28.650936 58.499596 105.356476 107.470947 236.051193 2754.596191 31376.837891 63338.746094 14688.553711 42074.609375 46561.117188 5130.712891 508.353882 223.436386 154.474472 60.515129 48.984703 201.583145 740.072388 2545.913818 25376.712891 129591.757812 128506.054687 23283.871094 1032.704224 63.987652 4.950583 138.417786 634.134399 1052.312988 513.012512 107.828293 21.102283 15.400581 43.815613 540.391968 17624.683594 100145.156250 100969.351563 163431.968750 104668.453125 106702.328125 103345.492188 2255.663086 1100.010864 745.568787 192.503616 37.133450 37.012016 175.436447 2006.946289 63752.308594 200247.406250 200075.671875 65822.671875 1856.992310 92.764847 6.321634 787.562439 7159.891113 16003.279297 5089.564941 550.501343 48.802452 19.087408 61.391338 603.999023 19540.693359 100419.945313 101302.578125 200337.765625 105986.257813 111257.085937 107923.320312 3416.356445 2084.840332 1445.508667 330.028900 50.348328 16.422850 75.231796 946.917847 17194.742188 162916.718750 169784.453125 19327.544922 967.170410 64.352547 4.800862 1940.475098 25644.257813 77491.304688 17560.927734 1223.479370 91.110626 84.887779 259.770844 730.192871 4857.411621 37719.199219 71458.117188 23597.916016 101868.117188 103171.281250 17131.769531 1316.495972 1092.945068 801.691772 242.029007 53.067482 14.662169 26.647322 210.602432 1695.173706 7309.051270 7619.053223 1753.463013 218.590668 22.688925 1.769834 1179.554199 11168.509766 28261.085938 8532.515625 737.552551 99.340889 352.584564 1476.531616 2107.488037 6547.298828 13261.736328 5265.829102 1502.491089 2723.600830 2783.011475 886.021973 266.518341 305.432709 364.713684 224.561096 77.274506 23.402344 12.288777 33.555958 136.975220 333.774902 345.483887 144.296478 32.210861 5.177628 0.288464 610.588989 1505.327881 2213.132812 1018.262207 178.925003 78.600914 543.785461 2593.758545 2882.455811 3816.833740 6678.784180 2383.388672 411.880096 161.336594 115.127846 70.348251 67.045990 173.860046 323.658600 255.013794 104.595238 41.485165 23.762222 23.231268 34.140629 42.102039 32.076221 15.371698 5.045441 1.751915 1.107186 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.001870 -0.001883 -0.001857 -0.001794 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.003639 -0.005208 -0.003565 -0.003677 -0.002333 -0.002365 -0.002333 -0.002253 -0.002117 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.001949 -0.003554 -0.005723 -0.006106 -0.006379 -0.006544 -0.006570 -0.006474 -0.004529 -0.004367 -0.002777 -0.002607 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.003552 -0.003932 -0.006299 -0.006872 -0.007357 -0.007713 -0.007915 -0.007975 -0.007846 -0.007574 -0.005341 -0.005043 -0.004644 -0.001205 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.003678 -0.004160 -0.006649 -0.007433 -0.008137 -0.008742 -0.009176 -0.009477 -0.009538 -0.010398 -0.010133 -0.009688 -0.007292 -0.006813 -0.001368 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.003638 -0.004219 -0.006724 -0.007650 -0.008606 -0.009479 -0.010200 -0.010803 -0.012205 -0.012436 -0.012403 -0.012132 -0.011589 -0.010876 -0.008296 -0.001521 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003440 -0.004073 -0.004747 -0.007574 -0.008696 -0.009795 -0.012406 -0.014423 -0.015366 -0.016006 -0.016336 -0.016315 -0.014339 -0.013755 -0.014327 -0.013336 -0.001656 -0.001180 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001724 -0.001862 -0.001969 -0.002026 -0.002040 -0.003843 -0.005697 -0.006302 -0.008812 -0.008367 -0.011240 -0.012670 -0.015087 -0.016471 -0.017626 -0.018495 -0.020312 -0.020548 -0.020335 -0.019669 -0.017114 -0.016026 -0.001767 -0.001248 0.000000 0.000000 0.000000 0.000000 -0.001641 -0.001901 -0.002143 -0.003548 -0.003777 -0.003958 -0.004022 -0.004014 -0.006154 -0.006730 -0.008940 -0.011652 -0.014390 -0.015735 -0.016599 -0.016860 -0.018484 -0.021287 -0.025697 -0.026782 -0.027353 -0.027253 -0.026679 -0.025225 -0.023818 -0.001845 -0.001293 0.000000 0.000000 0.000000 -0.003017 -0.003498 -0.004007 -0.004481 -0.007451 -0.007959 -0.009937 -0.011813 -0.012020 -0.015439 -0.014731 -0.015124 -0.018112 -0.019196 -0.018896 -0.020529 -0.024727 -0.028240 -0.028943 -0.030919 -0.032436 -0.032173 -0.033592 -0.033333 -0.032440 -0.030924 -0.001872 -0.001311 0.000000 -0.002797 -0.003393 -0.005329 -0.007368 -0.008459 -0.009524 -0.012304 -0.014908 -0.015941 -0.017632 -0.018013 -0.021495 -0.021847 -0.021918 -0.027184 -0.029145 -0.032684 -0.036044 -0.036505 -0.038077 -0.038789 -0.041039 -0.038972 -0.040665 -0.041748 -0.041856 -0.041216 -0.042021 -0.001858 -0.001302 -0.002936 -0.004934 -0.005988 -0.009659 -0.011314 -0.014832 -0.016843 -0.020461 -0.023503 -0.025134 -0.026285 -0.028139 -0.030631 -0.030785 -0.037235 -0.042286 -0.046674 -0.049657 -0.051678 -0.052609 -0.053265 -0.052821 -0.052489 -0.053519 -0.056791 -0.055961 -0.058623 -0.057865 -0.056862 -0.001792 -0.004231 -0.005193 -0.008894 -0.010859 -0.013128 -0.017569 -0.020649 -0.026631 -0.030203 -0.033427 -0.037466 -0.039489 -0.040380 -0.049377 -0.053396 -0.056403 -0.060091 -0.062704 -0.066719 -0.068078 -0.068386 -0.070525 -0.073656 -0.074463 -0.072846 -0.073434 -0.075160 -0.075758 -0.074085 -0.073200 -0.003060 -0.007645 -0.009353 -0.011739 -0.016212 -0.019940 -0.024248 -0.032004 -0.037592 -0.043169 -0.049850 -0.054148 -0.059792 -0.066515 -0.072336 -0.074824 -0.079131 -0.083618 -0.083998 -0.084617 -0.085235 -0.087689 -0.089792 -0.091181 -0.093960 -0.094343 -0.096504 -0.099261 -0.100348 -0.096410 -0.091928 -0.007943 -0.010523 -0.012108 -0.015476 -0.021631 -0.027222 -0.036689 -0.044880 -0.053676 -0.064025 -0.071978 -0.084354 -0.091188 -0.097916 -0.104940 -0.111863 -0.113190 -0.115121 -0.115308 -0.114095 -0.112585 -0.114635 -0.114462 -0.115007 -0.115829 -0.119656 -0.122790 -0.126418 -0.123613 -0.119225 -0.109701 -0.009383 -0.011922 -0.015657 -0.022307 -0.028978 -0.038418 -0.050796 -0.063272 -0.078272 -0.091319 -0.107856 -0.117314 -0.127791 -0.139693 -0.145086 -0.150266 -0.156182 -0.155999 -0.156066 -0.154175 -0.152150 -0.148913 -0.148480 -0.150410 -0.150724 -0.153621 -0.160448 -0.155033 -0.151635 -0.141563 -0.130542 -0.012489 -0.015056 -0.021764 -0.029132 -0.039849 -0.054451 -0.070413 -0.090353 -0.108772 -0.130246 -0.146156 -0.160675 -0.176100 -0.185026 -0.193326 -0.200599 -0.206308 -0.209429 -0.210478 -0.204866 -0.202457 -0.198972 -0.195961 -0.195979 -0.195429 -0.196034 -0.197447 -0.187511 -0.177050 -0.165979 -0.153916 -0.013817 -0.018795 -0.027640 -0.038893 -0.053105 -0.073515 -0.097816 -0.120636 -0.145303 -0.159609 -0.172761 -0.181460 -0.186234 -0.197508 -0.222107 -0.251469 -0.268427 -0.275936 -0.279734 -0.278360 -0.272324 -0.266464 -0.259630 -0.253640 -0.250030 -0.247276 -0.236088 -0.221073 -0.200649 -0.184122 -0.166200 -0.016703 -0.024919 -0.034946 -0.050186 -0.071630 -0.097093 -0.124079 -0.148430 -0.167283 -0.173765 -0.165655 -0.129968 -0.081974 -0.083559 -0.151317 -0.250162 -0.319309 -0.353156 -0.360495 -0.366597 -0.361944 -0.349206 -0.336777 -0.327952 -0.317085 -0.302589 -0.280899 -0.258042 -0.233859 -0.207087 -0.180649 -0.020006 -0.030383 -0.043616 -0.063882 -0.091648 -0.120353 -0.146817 -0.163126 -0.143282 -0.053599 0.146543 0.451253 0.735654 0.802815 0.468694 0.025866 -0.272763 -0.398296 -0.426807 -0.434363 -0.432473 -0.422338 -0.410726 -0.398448 -0.381399 -0.362263 -0.333890 -0.305078 -0.272630 -0.234950 -0.203052 -0.023574 -0.036457 -0.054536 -0.079208 -0.109377 -0.135353 -0.154403 -0.104036 0.165211 0.967266 2.507592 4.676774 6.756885 7.923032 5.443619 2.165173 0.276513 -0.329673 -0.470358 -0.480776 -0.474247 -0.466544 -0.458477 -0.447109 -0.433076 -0.414868 -0.387010 -0.350947 -0.310674 -0.269244 -0.237153 -0.027357 -0.042760 -0.064862 -0.092565 -0.120785 -0.144073 -0.101129 0.287800 1.999245 7.957160 22.010281 43.796024 82.028992 124.552284 81.048737 23.515089 4.140018 0.344634 -0.228746 -0.221402 -0.170213 -0.179184 -0.261802 -0.341957 -0.407040 -0.443893 -0.431142 -0.390756 -0.351449 -0.310082 -0.270780 -0.030951 -0.048970 -0.074037 -0.098706 -0.127273 -0.108562 0.230513 2.138394 11.952127 61.963650 239.215500 582.798218 1833.076538 5350.624023 2430.508057 324.686218 31.351629 3.636203 1.535689 2.159624 3.001795 2.808762 1.951077 0.986251 0.242905 -0.243369 -0.427291 -0.434672 -0.398440 -0.355928 -0.319085 -0.034115 -0.053986 -0.079187 -0.104914 -0.111783 0.097882 1.792671 11.409654 65.550438 445.154694 3224.562256 9879.732422 91979.710938 100482.882813 100050.375000 4429.595703 153.731430 14.164969 12.169977 22.801777 32.011311 29.529900 17.911314 9.591156 4.083029 0.965740 -0.190092 -0.451365 -0.458438 -0.418938 -0.379982 -0.036343 -0.058392 -0.082719 -0.104460 -0.045046 0.831467 8.737287 80.827637 600.219360 3025.358398 29304.396484 107791.960937 134346.156250 102091.625000 100129.859375 24376.074219 356.726593 42.243053 108.045998 291.794037 406.476501 299.236053 134.758377 56.112499 20.955685 5.345183 0.594169 -0.392208 -0.506612 -0.471144 -0.430639 -0.039040 -0.059339 -0.081888 -0.095931 0.092038 2.528198 35.153820 632.682373 13540.144531 101938.031250 78980.867188 106845.421875 151330.812500 102652.976563 100147.281250 11094.541992 267.748657 173.682693 1587.727783 8832.540039 10565.482422 3587.438965 922.045532 265.304901 76.206024 16.177975 2.165249 -0.209070 -0.528997 -0.513172 -0.464634 -0.039219 -0.061191 -0.080210 -0.086082 0.212385 4.345719 78.039391 2422.763672 100051.828125 100636.914063 106064.195313 32894.789063 15808.122070 41779.175781 14866.180664 1087.099731 129.446381 960.986511 34450.000000 100837.398438 104152.468750 52358.460938 4763.542480 1326.874512 251.483856 36.791363 4.673132 0.154462 -0.458509 -0.449083 -0.363967 -0.039933 -0.059571 -0.077957 -0.085088 0.198100 4.085386 68.411461 2047.353638 100014.070313 100094.554688 100423.265625 11969.378906 1000.678223 619.087708 322.566711 102.635323 254.887054 3066.412354 101338.835938 101107.398438 103453.937500 108350.234375 16612.433594 5367.549316 642.527710 68.477837 8.277000 1.033099 0.066975 0.429566 0.996528 -0.043055 -0.057936 -0.081012 -0.091727 0.068373 1.967180 25.448397 400.477417 6335.485840 36875.765625 18052.734375 1412.350586 129.263977 40.573093 38.109497 171.701309 2585.190918 47127.320313 177563.312500 116548.445312 101795.781250 105421.640625 14456.488281 5413.851562 757.145874 103.738647 16.158998 3.708931 3.198455 8.590736 17.227982 -0.052717 -0.059189 -0.077618 -0.094310 -0.052590 0.530292 5.664027 43.935123 242.891266 625.413269 433.261230 98.525513 19.303944 12.636247 61.089447 580.978455 22720.382813 100962.093750 104530.617188 134404.187500 41859.332031 6385.674805 2956.012939 2428.891602 1056.812378 206.225449 33.250484 11.420554 23.066641 101.480331 297.503540 -0.055377 -0.062983 -0.080122 -0.093711 -0.105934 0.000640 0.734318 4.217092 14.015940 23.887861 19.031002 8.378760 6.094869 21.858812 121.597954 957.832092 23970.894531 101975.078125 100717.703125 100714.921875 4791.504395 576.864014 1042.320068 2550.753418 1519.180420 281.389771 49.036633 36.170898 152.946411 1334.850708 7815.262695 -0.064348 -0.069035 -0.081479 -0.095383 -0.111201 -0.129525 -0.062696 0.224726 0.830675 1.295654 1.254542 2.281345 12.909748 70.468956 274.360809 804.609558 4188.224609 58073.492188 100414.085938 18114.296875 846.517517 150.596909 406.281128 950.094421 641.671448 152.723206 74.153496 208.310593 835.838745 13565.611328 100069.429688 -0.076753 -0.072862 -0.081570 -0.095226 -0.115451 -0.142319 -0.183813 -0.206670 -0.212987 -0.195127 0.162127 3.526514 29.490461 206.539062 889.386108 1533.221802 1166.522583 1372.722778 1540.057251 554.589905 144.757355 196.811447 301.669556 221.521423 121.376007 69.455345 285.036743 2315.011963 8013.391113 35082.410156 100635.625000 -0.094301 -0.084199 -0.087537 -0.097568 -0.116873 -0.151309 -0.192537 -0.236729 -0.294455 -0.301510 0.147995 4.391858 39.584518 292.113831 1463.583008 3367.836914 5274.437500 2889.103271 630.731628 255.108353 211.551056 534.239502 695.180054 270.432007 57.815819 83.626762 1074.626709 19329.847656 100414.093750 54109.269531 103119.710938 -0.112266 -0.099981 -0.099089 -0.107126 -0.120648 -0.157520 -0.194549 -0.241718 -0.294663 -0.314724 0.013012 2.914233 25.609776 183.996948 1376.480103 22868.263672 100425.000000 79397.609375 5365.075684 2846.121826 1016.024353 554.896667 580.766846 202.632568 42.427113 89.710747 1337.424438 28294.089844 100245.257813 78427.242188 7576.196289 -0.138459 -0.123087 -0.120919 -0.132569 -0.141187 -0.171084 -0.207891 -0.249447 -0.300355 -0.339266 -0.209348 1.160692 11.152910 92.539795 1581.119873 70711.914063 100241.109375 102293.382813 26997.130859 31883.412109 6878.832031 1503.355347 388.918060 95.302681 22.514898 48.960999 513.993408 5374.201172 22984.802734 15135.916992 3287.928955 -0.170835 -0.153824 -0.151268 -0.156871 -0.167826 -0.191985 -0.224179 -0.269093 -0.313717 -0.366876 -0.366245 0.114773 3.965365 40.487118 639.621704 13459.920898 100230.820313 49032.550781 37645.769531 71650.617188 109590.054687 51950.800781 3743.137695 233.035294 21.854763 19.758118 148.517990 1326.634888 12098.302734 34956.386719 12329.393555 -0.209394 -0.190651 -0.181252 -0.184111 -0.195925 -0.217471 -0.248537 -0.292194 -0.334988 -0.392696 -0.456041 -0.344617 0.841383 10.709827 103.713036 742.288147 2544.588867 2804.711914 13083.408203 110694.390625 103096.132813 100509.171875 51288.261719 856.109802 40.883862 11.092848 83.692284 1084.709351 12220.173828 41896.375000 13337.544922 -0.250695 -0.231084 -0.214428 -0.207958 -0.204549 -0.216192 -0.250366 -0.299067 -0.347249 -0.411532 -0.478718 -0.508657 -0.198867 2.254579 16.990452 81.237938 246.658798 666.107117 9727.180664 102656.265625 102187.164063 100623.835938 95929.437500 1234.090088 47.312855 6.764756 37.253998 342.184784 2445.939941 5540.855469 2645.376221 -0.294470 -0.269188 -0.218009 -0.127400 -0.030034 0.000204 -0.056765 -0.149555 -0.237390 -0.351328 -0.454987 -0.537065 -0.297335 2.788352 39.382172 503.612732 4803.015625 9868.296875 15580.568359 186429.140625 200126.906250 109355.789062 15053.324219 477.090912 28.205769 3.007652 9.265985 54.216202 213.145416 388.828461 227.346634 -0.329575 -0.263716 -0.029681 0.571597 1.389640 1.882525 1.722307 1.531592 1.353606 0.695957 0.003834 -0.366459 0.030603 7.971176 177.488373 6901.395508 100086.617188 102469.890625 185653.203125 103558.843750 108582.101562 105100.039063 2633.298340 152.326660 12.403201 0.972716 1.527037 7.218702 19.362257 28.612543 20.344267 -0.361118 -0.122349 0.899786 4.143575 10.316959 14.500090 15.196017 20.503073 24.108965 15.141374 4.864474 0.802629 0.569554 11.743917 316.259644 22735.751953 100088.562500 102648.468750 200024.921875 103127.187500 100274.171875 100158.742188 2138.094482 83.885216 6.062705 1.214295 3.148105 6.243862 7.167685 5.933662 4.783093 -0.365656 0.246888 3.539810 17.501400 50.189632 86.650703 134.477448 380.218964 635.612732 324.471191 60.313797 8.536736 1.907342 8.852338 155.256271 5718.348633 100043.171875 100731.289063 87060.335938 101192.070313 100053.703125 14606.349609 594.464600 35.357582 4.499549 9.767261 37.858620 82.857170 79.383575 39.243271 26.042561 -0.345465 0.736492 7.653422 43.424633 176.676575 519.029846 1562.794922 15129.064453 56689.246094 13438.266602 786.261230 48.075024 7.653762 10.673410 42.340282 432.691254 3629.908447 6375.067383 2305.950928 3248.141357 2875.918945 681.879700 83.136391 10.303344 9.602224 73.031288 478.369171 1656.349976 1544.861328 459.502380 190.324142 -0.329259 1.030099 10.656277 78.586342 612.781433 4272.175293 17709.351563 103665.914063 100480.703125 100045.968750 6944.522461 167.361526 39.098213 86.201851 98.241600 68.831429 101.706825 138.558304 105.933731 113.571892 102.715965 42.173176 11.162518 4.498221 28.755442 388.857788 6030.626953 51231.488281 41977.054688 5279.254395 1726.007935 -0.060458 1.103036 11.803636 112.655434 1482.846802 19592.222656 84612.125000 119293.679687 101319.945313 100088.945313 11088.532227 230.586273 287.802246 1303.250854 1422.381592 361.994141 54.118568 13.643223 9.334929 11.618935 15.189065 14.941204 9.535804 7.932559 52.574005 978.444824 31120.826172 100092.382813 101373.703125 38989.304688 71365.820313 2.023271 1.661509 12.366359 117.731552 1289.902954 14997.057617 44917.195313 113381.171875 101064.851563 99041.484375 2432.119629 185.564423 1664.937012 15090.863281 16710.474609 2158.087646 145.108688 14.675771 8.153148 19.307436 48.873119 67.945183 50.573383 27.898914 53.549194 735.670471 17576.728516 100287.054688 108750.281250 113607.242187 103896.085938 14.821619 4.323878 16.142237 137.667465 1048.745117 3781.522705 5438.949707 3841.529785 4397.935059 1642.455933 210.697922 137.511978 2140.410889 25255.166016 28080.068359 3040.930176 174.828918 21.080778 20.229969 55.739555 172.399246 277.233795 272.620361 212.181015 110.521828 214.258499 1955.903564 9666.403320 21133.666016 104906.242188 108731.765625 72.501457 11.903081 18.942099 178.572693 1402.870483 5082.903320 7683.304687 4139.543945 799.268433 140.028915 32.705822 56.913921 582.499084 3311.547363 3622.790527 738.025146 72.863312 24.735079 36.829708 94.335571 333.313446 1047.912354 3241.291504 3823.893555 1190.459106 212.328354 182.044846 535.193726 3481.988281 71822.390625 104339.875000 221.170273 23.239225 17.345703 147.944397 1785.658813 35492.371094 100699.015625 100163.132813 7206.668457 351.655975 60.568604 46.529423 81.290428 210.109238 222.021255 75.824333 20.956932 25.005142 41.901676 96.380638 599.396118 7994.730469 98403.687500 116051.343750 19144.345703 1152.850464 101.936302 76.078575 379.132904 2258.537598 4901.355957 270.177704 27.163715 14.318327 146.263092 3726.541504 100147.500000 100123.585938 100103.257813 28350.447266 860.474915 415.842010 401.663635 155.899582 45.110569 19.862066 9.501843 7.553174 15.357135 27.459009 86.300720 1146.154175 42245.660156 146352.453125 163062.796875 108829.179687 3378.106201 218.822205 42.690636 47.308105 123.335228 194.351074 127.324593 16.207552 9.431728 97.092941 2096.697998 77509.429688 100073.203125 100215.828125 13687.612305 1446.658203 3778.476562 4063.151611 1036.965454 147.953064 37.601082 14.187892 7.085742 8.271467 13.841545 57.957371 857.716553 27754.818359 116219.468750 122497.679687 102879.585938 4288.699707 717.485657 168.556412 37.874958 15.302856 14.099206 32.380383 6.968101 5.319079 33.890324 366.602112 3979.534424 17630.587891 10419.382812 1862.545166 2904.798584 16573.062500 18894.677734 3756.451660 810.464905 510.994812 165.871384 35.275002 15.882412 13.753896 28.553787 256.552063 3255.631592 27474.767578 48461.941406 23468.529297 15716.766602 9350.631836 1962.232300 213.986618 22.690760 2.975536 9.690901 11.054840 13.169526 15.463304 47.646034 208.810822 484.407562 474.405823 689.293518 8191.472656 108561.523437 109466.882812 38534.394531 25991.500000 27138.531250 3184.781494 235.679382 50.547165 32.417133 19.629843 48.472847 285.914185 1316.815430 5691.154297 40933.597656 110308.000000 105801.187500 39087.769531 1187.339722 64.333603 4.722717 22.335527 64.826134 93.321602 55.096294 22.511765 21.430044 40.882172 101.517265 1103.819824 70227.695313 101304.515625 101925.312500 133602.718750 107964.140625 100397.617188 50956.382813 936.611328 108.420837 59.052689 25.951666 15.151088 46.834274 281.545258 3228.691895 103633.843750 112122.335937 111327.054687 101959.148438 2822.908447 104.610245 6.634122 74.175484 296.700134 446.035797 242.979004 59.177174 19.744003 53.244030 190.798843 1452.667603 71783.281250 103506.265625 102273.289063 156875.359375 107963.945312 100467.929688 88539.484375 1271.200439 131.296143 71.427650 30.913502 13.092448 16.753792 99.646584 1506.731323 70767.062500 103470.125000 103400.007813 86981.335938 1754.327881 80.080185 5.089233 131.785019 592.353516 978.661194 478.980194 104.770325 74.939461 595.029602 2967.005127 6224.870117 64351.000000 200080.781250 125960.117187 50274.617188 101699.000000 100220.960938 9290.001953 438.775116 80.017693 54.416122 40.412968 36.234814 25.984453 38.616814 317.136353 4124.382812 31512.490234 34711.070313 4452.511230 344.482025 27.907360 1.994828 112.736107 402.890656 641.110229 321.034149 88.257042 266.300812 6917.969727 100369.062500 96556.109375 104762.281250 102508.226563 103702.164063 5850.215820 2213.622559 1976.868652 468.829712 78.662270 37.319267 55.712898 116.765976 172.415604 117.349541 43.287128 49.593830 221.448181 628.805481 670.656494 231.657181 42.999039 6.012043 0.064566 279.338837 249.203735 196.390717 98.668640 46.986973 432.576263 15090.122070 100260.835938 106037.906250 110187.656250 100596.515625 71252.171875 4747.303711 863.335144 171.839005 43.077557 16.696400 25.546793 88.431046 313.596863 563.453796 358.632355 115.543297 45.765041 41.466583 50.439255 40.224598 18.494871 5.150095 0.566740 -0.382624 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001819 -0.001870 -0.001896 -0.001870 -0.001807 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.001883 -0.001963 -0.003834 -0.005416 -0.005543 -0.005554 -0.002398 -0.002415 -0.002398 -0.002301 -0.002177 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002004 -0.002177 -0.005606 -0.006103 -0.006506 -0.006791 -0.006974 -0.006997 -0.006874 -0.006628 -0.004576 -0.004305 -0.002738 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002162 -0.003921 -0.006184 -0.006904 -0.007522 -0.008065 -0.008470 -0.008688 -0.008722 -0.008573 -0.008253 -0.007769 -0.005405 -0.004977 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002222 -0.004160 -0.006557 -0.007469 -0.008362 -0.009150 -0.009875 -0.010380 -0.010689 -0.010749 -0.010572 -0.010160 -0.009563 -0.009782 -0.007161 -0.001140 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002192 -0.004207 -0.004896 -0.007737 -0.008867 -0.009999 -0.011014 -0.011908 -0.012607 -0.013003 -0.014104 -0.014006 -0.013618 -0.012914 -0.012007 -0.010920 -0.001293 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002074 -0.004056 -0.004841 -0.007661 -0.009006 -0.010368 -0.013363 -0.014796 -0.015987 -0.017930 -0.018670 -0.018997 -0.018790 -0.018235 -0.017304 -0.014541 -0.013236 -0.001437 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001596 -0.003502 -0.005351 -0.004554 -0.005448 -0.008656 -0.011840 -0.013674 -0.015540 -0.017258 -0.019906 -0.021317 -0.022247 -0.022665 -0.022550 -0.023408 -0.022305 -0.020825 -0.017554 -0.001565 -0.001116 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001724 -0.001901 -0.002054 -0.002174 -0.002253 -0.004272 -0.006333 -0.007157 -0.009991 -0.013128 -0.014981 -0.015464 -0.017672 -0.020919 -0.023038 -0.024731 -0.027420 -0.028209 -0.028452 -0.029480 -0.028427 -0.026731 -0.023078 -0.001668 -0.001180 0.000000 0.000000 0.000000 0.000000 -0.001810 -0.002098 -0.003573 -0.003912 -0.004167 -0.004371 -0.004458 -0.007969 -0.010386 -0.010180 -0.014906 -0.016799 -0.018833 -0.020996 -0.024384 -0.026611 -0.027676 -0.033287 -0.035338 -0.036781 -0.037341 -0.037008 -0.037028 -0.035252 -0.034449 -0.001742 -0.001231 0.000000 0.000000 -0.001700 -0.003294 -0.003850 -0.004428 -0.006256 -0.008031 -0.010328 -0.012517 -0.013079 -0.016989 -0.017899 -0.017417 -0.022213 -0.023801 -0.023446 -0.031692 -0.033012 -0.039158 -0.042468 -0.043902 -0.044830 -0.044419 -0.046590 -0.046790 -0.047596 -0.046666 -0.044511 -0.001767 -0.001248 0.000000 -0.003058 -0.003715 -0.005780 -0.007915 -0.009117 -0.012138 -0.013488 -0.016553 -0.017707 -0.018561 -0.023707 -0.024616 -0.026904 -0.031319 -0.034947 -0.039520 -0.043678 -0.045727 -0.048377 -0.050412 -0.053872 -0.056353 -0.061367 -0.061665 -0.063144 -0.062597 -0.061857 -0.059489 -0.001742 -0.002354 -0.003210 -0.005318 -0.006522 -0.010298 -0.013869 -0.016156 -0.020120 -0.022649 -0.025860 -0.027855 -0.029225 -0.033620 -0.037543 -0.042356 -0.045649 -0.049692 -0.056044 -0.061114 -0.063062 -0.065262 -0.070695 -0.074407 -0.073709 -0.074541 -0.079091 -0.080087 -0.081437 -0.078635 -0.075854 -0.002856 -0.004437 -0.005593 -0.009443 -0.011588 -0.015951 -0.019161 -0.024389 -0.028385 -0.033560 -0.037296 -0.040495 -0.045458 -0.052001 -0.057033 -0.063440 -0.068160 -0.071323 -0.073354 -0.078673 -0.081395 -0.087234 -0.091007 -0.095200 -0.098245 -0.097424 -0.099483 -0.103692 -0.102978 -0.101011 -0.097077 -0.004718 -0.008003 -0.009905 -0.012504 -0.017515 -0.021761 -0.028345 -0.035314 -0.041825 -0.048402 -0.054347 -0.062443 -0.067619 -0.080025 -0.085403 -0.088252 -0.095256 -0.097400 -0.098614 -0.101768 -0.105460 -0.110408 -0.114039 -0.116189 -0.120247 -0.127828 -0.130703 -0.132137 -0.126121 -0.118759 -0.115848 -0.008225 -0.009966 -0.012877 -0.018373 -0.023512 -0.029821 -0.040396 -0.050052 -0.060308 -0.071650 -0.082003 -0.093980 -0.101305 -0.109322 -0.121636 -0.125255 -0.131043 -0.132926 -0.133959 -0.133977 -0.136922 -0.139067 -0.141532 -0.145967 -0.151293 -0.160373 -0.163664 -0.159893 -0.156363 -0.144697 -0.137149 -0.009795 -0.012631 -0.018349 -0.024134 -0.031627 -0.044036 -0.056564 -0.070990 -0.087189 -0.101046 -0.116293 -0.127279 -0.141170 -0.152215 -0.162242 -0.167695 -0.173225 -0.176773 -0.179176 -0.178266 -0.179173 -0.178494 -0.183319 -0.188048 -0.191842 -0.200116 -0.200539 -0.191770 -0.179523 -0.156951 -0.128324 -0.014177 -0.015999 -0.023531 -0.031684 -0.045176 -0.060320 -0.078832 -0.099875 -0.117728 -0.136728 -0.153393 -0.166053 -0.170952 -0.180500 -0.198122 -0.215927 -0.225092 -0.232635 -0.234232 -0.236453 -0.238133 -0.238643 -0.238640 -0.241921 -0.246600 -0.245587 -0.236359 -0.220278 -0.184658 -0.120287 -0.053328 -0.015776 -0.021695 -0.029901 -0.041392 -0.060061 -0.081502 -0.105747 -0.128292 -0.146519 -0.160936 -0.153564 -0.112327 -0.058329 -0.049153 -0.114070 -0.204152 -0.266838 -0.294013 -0.304367 -0.309875 -0.310984 -0.310280 -0.308580 -0.306593 -0.305585 -0.298292 -0.276906 -0.248174 -0.172098 -0.019568 0.128684 -0.018912 -0.026736 -0.037846 -0.054617 -0.079052 -0.106298 -0.130261 -0.152482 -0.165961 -0.129625 0.018062 0.308961 0.695394 0.840366 0.526944 0.073868 -0.223692 -0.349430 -0.389330 -0.398132 -0.400396 -0.397050 -0.390608 -0.383577 -0.372545 -0.353381 -0.324342 -0.276904 -0.161406 0.060123 0.291626 -0.022423 -0.032593 -0.047251 -0.071351 -0.099954 -0.126098 -0.150462 -0.154284 -0.053559 0.292647 1.107628 2.602244 4.441836 5.058020 3.351476 1.288359 0.076801 -0.342534 -0.451127 -0.479680 -0.482030 -0.474346 -0.469042 -0.452673 -0.436685 -0.404136 -0.354696 -0.276632 -0.134406 0.093294 0.314348 -0.027864 -0.039058 -0.059021 -0.087501 -0.116250 -0.140905 -0.145679 0.004837 0.735841 3.024078 7.536327 13.605956 20.082769 22.082159 13.883200 5.283051 1.065272 -0.177945 -0.478553 -0.529823 -0.547765 -0.536981 -0.505546 -0.485709 -0.469569 -0.428841 -0.346757 -0.222775 -0.082839 0.100163 0.246912 -0.031820 -0.045807 -0.069876 -0.101126 -0.124360 -0.146271 -0.037263 0.785861 5.013523 21.335270 61.230782 102.650101 114.825699 117.399895 70.667412 22.613806 4.628230 0.356034 -0.365514 -0.446196 -0.409012 -0.327754 -0.193045 -0.149213 -0.254607 -0.345215 -0.310376 -0.165253 -0.024292 0.076099 0.124245 -0.035562 -0.052315 -0.079345 -0.108811 -0.130047 -0.094286 0.436625 3.884983 26.510702 170.373093 842.649414 1772.894653 1652.704712 2254.476318 1115.210571 193.622238 21.887846 2.315361 0.532312 0.884611 1.435712 2.107092 3.312019 3.795475 2.258727 0.539421 -0.123665 -0.146292 -0.051116 -0.022509 -0.056524 -0.037595 -0.057669 -0.084266 -0.112488 -0.112252 0.164160 2.452868 17.699392 136.174744 1652.520874 25939.611328 101237.507813 51167.558594 102128.179688 36998.253906 1897.087280 90.639671 8.492736 7.439221 14.233157 18.092960 21.838881 36.022606 42.337490 24.551291 6.758742 0.950527 -0.130621 -0.226114 -0.224561 -0.250905 -0.039867 -0.060884 -0.087659 -0.111218 -0.036041 1.031237 11.412481 111.103951 1013.008789 12443.629883 101626.242188 103335.109375 200137.734375 116032.156250 100395.882813 6961.057129 189.010651 28.803209 82.228333 225.644745 249.384415 189.231644 304.372589 411.986084 191.751190 36.721245 4.624606 0.119627 -0.392216 -0.413329 -0.406971 -0.040645 -0.062842 -0.087735 -0.099936 0.116023 3.021206 45.345089 932.990479 30237.005859 113342.882812 200118.046875 105848.515625 170757.437500 121203.414062 100449.710938 4074.301758 157.182892 148.775513 1432.642090 7205.212402 8012.056641 2491.285889 2352.214844 2507.129883 816.701782 109.130341 11.206199 0.729652 -0.438008 -0.526331 -0.493638 -0.042149 -0.063068 -0.084520 -0.088242 0.268204 5.451139 101.403061 4432.673828 100137.414063 102869.921875 169802.093750 133483.515625 99420.554688 15063.141602 5012.554199 519.788513 101.684906 885.503967 28287.685547 100149.656250 101282.578125 52769.777344 53349.863281 17881.318359 2006.534912 181.327896 18.045057 1.711233 -0.206717 -0.412411 -0.357111 -0.042282 -0.061855 -0.081668 -0.085201 0.249710 4.839200 88.574974 3405.026123 100029.070313 100261.000000 101791.960938 28359.279297 2462.406738 596.880676 219.452087 98.568481 283.289337 2822.808838 101121.710938 100650.015625 105718.679688 200191.203125 103215.398438 100619.562500 6857.640625 297.992035 28.982790 4.972317 1.183099 0.954400 1.623887 -0.042280 -0.059802 -0.079810 -0.092687 0.085129 2.465521 32.407913 579.747803 12195.492188 98983.578125 36943.210938 2346.591309 200.021393 54.827637 76.758087 411.837036 3090.551025 35339.488281 151500.546875 112457.937500 106219.250000 186325.093750 102625.773438 102988.554688 8495.519531 562.803406 73.418320 19.468597 8.410861 14.178550 27.217867 -0.046315 -0.058432 -0.079203 -0.095436 -0.042250 0.637896 6.707292 56.441269 346.638763 917.865356 629.648926 139.112701 26.826813 32.529896 272.523499 3427.357666 35647.917969 119563.468750 106537.804687 128550.843750 35515.464844 20947.859375 68134.687500 105916.703125 38235.417969 2432.311523 231.147125 64.919777 49.063702 192.574219 635.288330 -0.052770 -0.060861 -0.078839 -0.094258 -0.104274 0.020555 0.885907 5.003599 17.744184 30.500381 24.417387 11.806902 15.811748 89.442955 760.457214 13861.365234 116445.039062 200075.921875 111322.414062 101129.359375 3961.258789 1931.014771 31280.681641 100707.437500 100236.218750 4676.936523 421.701294 155.688477 317.083710 3696.059082 34333.320313 -0.060067 -0.065118 -0.078235 -0.093187 -0.113951 -0.128054 -0.052846 0.277364 1.024454 1.619128 1.942817 6.483908 54.363182 479.884552 3132.627930 12944.006836 89790.695313 127316.757812 107851.984375 13883.463867 774.543396 497.190643 7011.183105 41040.488281 19999.763672 1686.534058 410.559021 698.309753 2489.909424 70568.250000 100189.625000 -0.071443 -0.068743 -0.076763 -0.093552 -0.114940 -0.146550 -0.181786 -0.200135 -0.198555 -0.105410 1.009404 13.247500 166.476196 2662.010010 34482.984375 78856.500000 19312.486328 7349.784668 2444.093750 607.298218 123.580086 102.515106 485.412750 1380.266602 896.796082 357.491699 1180.122070 16314.682617 88326.320313 137912.765625 102871.414063 -0.085727 -0.080386 -0.079846 -0.096155 -0.118243 -0.146975 -0.190284 -0.236684 -0.288905 -0.208560 1.104124 16.452730 229.868347 4705.256348 86453.539063 104161.914063 48454.898438 11866.045898 1771.585937 885.336548 348.927643 110.052742 70.854668 81.234894 85.757057 304.091492 5876.013184 100426.414063 101039.750000 134410.203125 125677.101562 -0.100763 -0.093631 -0.090265 -0.099940 -0.118992 -0.157881 -0.192316 -0.236455 -0.287259 -0.247270 0.678764 10.745858 124.341393 1727.195068 18230.197266 131137.187500 107355.507812 103021.156250 36816.183594 34774.058594 6275.890137 609.587402 89.934563 27.356028 33.704525 285.079926 8016.928711 100363.859375 100925.585938 103098.218750 53706.695313 -0.121937 -0.112833 -0.110786 -0.119071 -0.133403 -0.162691 -0.201271 -0.242211 -0.293510 -0.301929 0.125687 3.996364 37.533871 335.232941 5813.770508 101455.289063 101274.593750 125751.750000 141102.875000 101008.023438 101002.343750 3092.557129 270.725677 40.173096 19.069227 122.766884 2067.294922 58204.101563 121232.421875 177586.843750 30713.796875 -0.154097 -0.137929 -0.138428 -0.146651 -0.159489 -0.183562 -0.215093 -0.257208 -0.306180 -0.346923 -0.256406 0.897821 9.277913 84.443298 1802.407959 88439.976563 100959.226563 151272.875000 109684.648437 106390.320312 131288.843750 21292.623047 1926.672485 148.821716 18.228645 42.501465 465.219116 9471.240234 104688.085938 102872.937500 100492.734375 -0.187581 -0.169922 -0.165677 -0.168623 -0.182349 -0.201361 -0.234759 -0.271267 -0.318290 -0.374240 -0.413002 -0.157981 1.878975 19.347239 204.599915 2078.412354 8754.649414 14261.903320 103270.085938 200150.156250 131228.531250 101277.007813 16083.978516 521.182556 29.931059 21.339733 282.769562 9384.244141 100145.718750 100106.578125 100036.921875 -0.225289 -0.204136 -0.185872 -0.160419 -0.134804 -0.144339 -0.194288 -0.263653 -0.327300 -0.389751 -0.454968 -0.461241 -0.013714 3.133692 22.060850 102.689857 309.197510 1019.748291 7573.223633 106366.250000 102871.718750 100593.726563 28312.253906 643.624329 33.968987 10.820701 108.148338 1935.368896 34325.476563 100006.398438 37885.832031 -0.265971 -0.216447 -0.089099 0.186423 0.548109 0.685018 0.404363 0.047759 -0.183790 -0.334136 -0.435541 -0.519226 -0.343482 1.650662 19.023785 175.138474 987.136353 2192.918945 12969.717773 125858.656250 200087.250000 108543.804687 6479.911621 307.122009 20.871901 4.025894 24.131989 187.276749 1052.560181 2256.667725 1133.230957 -0.280920 -0.090270 0.727168 3.252577 7.732641 8.974066 6.016541 2.941978 1.456763 0.607657 -0.059770 -0.407853 -0.196459 4.008407 68.457512 1293.444824 20571.574219 50606.375000 107069.414062 101598.492188 103679.796875 102446.421875 2265.385986 123.606895 10.019987 1.200711 3.838078 17.617840 54.703838 82.952888 57.849220 -0.248021 0.528662 5.108936 26.065437 80.053268 100.645340 58.355209 27.931652 20.114620 11.310276 3.692001 0.478138 0.042764 5.832026 109.100044 2776.121338 85473.320313 102647.460938 122748.125000 100742.218750 100159.843750 100101.695313 2122.716797 81.489517 5.978417 1.980625 5.595915 11.404772 13.438736 11.272130 9.219856 -0.123881 2.243528 20.753149 165.593124 751.977600 1075.117187 513.165527 323.560303 375.597809 189.292114 41.866982 5.800571 0.726540 4.012559 59.908222 1095.818115 15116.025391 35507.222656 23274.332031 100320.734375 100027.046875 14603.124023 593.533752 35.390324 5.767974 17.191236 73.018837 175.680328 166.501236 72.635216 49.471371 0.021416 4.251309 47.480190 531.611816 3683.205322 6976.600098 5406.791016 7568.800293 16594.902344 4864.897949 433.703644 32.646530 3.262190 2.998465 16.608912 135.918228 743.123962 1285.248169 1180.633423 3160.322266 2870.301758 681.199707 83.088196 11.012224 16.268816 154.177780 1419.868286 6569.849121 6043.243164 1191.135742 419.971710 0.013703 4.621428 51.913898 578.097229 5741.284668 67436.148438 104876.781250 156848.968750 102656.015625 100137.250000 2874.263428 102.616951 10.843269 12.363420 14.426272 19.016886 41.968224 60.610466 71.620384 106.064323 100.658722 40.686314 10.282866 5.657673 54.349178 1133.251099 37884.996094 100018.757813 100141.859375 26426.876953 3531.047119 -0.016318 3.546077 38.455399 490.357635 13943.859375 101027.203125 106171.390625 200075.265625 112177.078125 100319.000000 4440.146484 129.414597 35.010227 74.290894 79.586357 33.868385 9.906491 5.324087 5.499801 7.186213 6.999659 4.854708 3.039970 7.444491 106.368027 3366.694336 100007.562500 100101.625000 101799.445313 131217.843750 104735.015625 0.491919 3.303746 35.762836 459.477966 10843.584961 104568.437500 103632.335938 130259.156250 108558.953125 24627.492188 1176.202271 74.758904 87.825676 294.936462 317.638031 103.281647 16.800249 2.469934 1.088331 2.601208 6.129651 10.198593 13.442474 17.441616 94.687073 2445.575928 100017.414063 100322.289063 113347.164062 200124.921875 102700.562500 3.206931 4.703428 55.983189 1017.627014 23473.589844 119437.656250 108899.093750 20859.291016 3375.727783 895.223389 135.528931 30.954351 103.965294 367.484863 396.155853 117.570847 19.718369 2.880020 2.175571 6.831008 22.366924 67.244858 148.843643 165.407883 111.066589 501.607880 7831.960449 70166.804688 84102.914063 106173.039063 100716.804688 11.573715 6.654119 69.538895 1521.539795 57055.613281 103961.234375 114472.375000 13213.632813 1468.278687 183.684921 35.738506 19.924147 48.140106 126.687935 134.490219 52.703712 10.328979 2.587845 4.010128 16.551922 104.269577 836.862061 4401.887695 5640.426758 1591.963135 248.725952 374.869629 1236.498901 5312.089355 100369.187500 100201.484375 26.343500 7.254223 42.670551 687.959900 12950.561523 150820.625000 119994.304687 101403.468750 19523.302734 683.406311 165.182159 129.014297 61.668560 34.282928 25.132553 10.718922 2.991761 2.075629 5.734327 37.703682 545.827087 14737.578125 100412.335938 100498.781250 51482.121094 1635.214844 126.571640 93.593292 416.515137 2691.855957 6617.979492 31.180485 6.466193 20.710386 283.289368 9063.180664 101396.367188 101032.007813 101295.875000 101756.750000 2539.980957 3022.751465 2885.303467 791.794434 104.057526 14.175826 3.115790 1.562958 2.665898 7.394484 62.681038 1572.850586 100236.523438 100935.195313 101759.234375 102258.781250 7237.776855 394.090393 56.347221 42.847565 108.161224 173.541550 17.992844 3.810542 10.702439 155.119019 4720.757812 100143.156250 100952.632813 106074.390625 52507.675781 13838.000000 100402.507813 100094.015625 12207.262695 609.052612 47.595097 9.730899 8.723761 14.184738 17.118246 59.087421 1254.724121 86355.421875 101674.015625 119817.273437 196130.343750 35703.136719 2639.306396 245.898071 36.926102 12.160209 10.487490 6.176938 1.688001 4.366303 47.484276 644.656311 9402.669922 57782.957031 38980.601563 17439.353516 55269.816406 101357.429688 101462.765625 70365.804688 1741.919434 195.068146 62.482735 52.056900 104.345619 98.211990 55.294289 344.404510 6237.658203 90934.429688 200287.203125 117625.078125 109379.234375 19578.806641 2133.529785 201.457932 19.603022 2.121659 2.259242 1.774620 2.691519 10.666670 70.783623 386.098816 1154.563599 2435.918945 4066.396973 32348.867188 138050.046875 177557.750000 46890.078125 3725.630859 2156.198975 533.675476 194.797607 435.260590 399.083099 110.331993 72.024689 486.790680 5038.780273 102668.789063 134952.843750 200271.593750 107996.625000 42201.851563 1167.506470 58.257011 3.744546 3.272887 6.502898 8.410917 7.078631 10.413066 33.812153 106.220154 282.993042 1086.287109 23938.191406 116305.937500 117851.359375 105320.320313 25637.464844 27148.212891 3166.255127 370.765442 556.169617 504.057770 131.699173 31.662907 90.463959 872.808838 11829.991211 134451.640625 113591.687500 101579.023438 100193.601563 3132.708740 97.406860 5.786325 8.833134 19.129602 24.436047 16.543587 8.806767 20.126770 103.715019 363.398895 1610.595337 27462.166016 112677.726562 104363.640625 103983.078125 40317.625000 45749.433594 4457.941406 321.662537 215.387436 179.298492 69.630943 30.751696 33.903580 156.430557 1968.044189 87035.710938 100650.312500 100256.335938 100075.890625 1802.240723 75.571854 4.553612 18.279547 34.670479 41.257515 27.068933 17.987005 128.947769 1982.612183 15454.299805 23663.148438 104788.195313 142025.328125 186413.906250 19666.656250 6392.254395 5882.072266 1091.954102 122.817665 51.600697 68.462296 137.234375 220.290421 152.035568 76.486237 336.778107 4366.313965 34384.554688 37930.953125 5109.364746 344.728546 26.302839 1.992664 37.806557 47.004902 41.395329 24.712563 33.784725 735.445679 48359.242188 100790.250000 156764.296875 128371.406250 102136.351563 105742.812500 22273.251953 2611.599609 537.883240 136.689621 29.525335 34.534615 222.054352 1324.529907 3111.342285 1661.797607 290.219757 78.089226 225.843903 690.291931 687.910828 231.229034 41.449219 5.374597 0.393131 130.727188 113.000641 60.102489 24.679405 42.212124 1290.371582 100025.531250 100551.476563 125648.203125 185551.187500 104260.820313 179014.203125 107221.648437 22265.599609 823.121460 53.091663 12.916369 61.078320 735.571289 8530.056641 28252.154297 11167.645508 1194.105225 128.384857 42.833389 42.434631 35.192905 16.712585 4.309387 0.422855 -0.185488 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.001819 -0.001794 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.001963 -0.002031 -0.003879 -0.004049 -0.004151 -0.004181 -0.002349 -0.002382 -0.002349 -0.002269 -0.002132 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001909 -0.002132 -0.002317 -0.005750 -0.006237 -0.006656 -0.006957 -0.007106 -0.007136 -0.007003 -0.006725 -0.006337 -0.002937 -0.002757 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002060 -0.002349 -0.004160 -0.006497 -0.007225 -0.007886 -0.008447 -0.008861 -0.009078 -0.009084 -0.008948 -0.008595 -0.008069 -0.007420 -0.005087 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002132 -0.003892 -0.004507 -0.007041 -0.008033 -0.009013 -0.009877 -0.010623 -0.011160 -0.011479 -0.011555 -0.011343 -0.010874 -0.010188 -0.009346 -0.008392 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.003929 -0.004670 -0.007330 -0.008564 -0.009832 -0.011081 -0.012261 -0.013213 -0.013978 -0.014437 -0.014531 -0.014255 -0.014655 -0.013850 -0.012747 -0.011531 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001990 -0.002415 -0.004604 -0.005515 -0.008692 -0.010241 -0.011852 -0.015157 -0.016794 -0.018214 -0.019313 -0.019941 -0.021176 -0.020933 -0.020210 -0.018934 -0.015881 -0.014325 -0.001197 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002222 -0.004343 -0.005320 -0.008410 -0.010153 -0.013754 -0.015972 -0.018233 -0.020358 -0.022205 -0.024791 -0.025747 -0.026194 -0.025883 -0.024972 -0.023412 -0.021503 -0.019214 -0.001330 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001585 -0.001676 -0.003686 -0.005644 -0.006573 -0.007683 -0.009546 -0.013400 -0.015977 -0.018722 -0.021551 -0.025183 -0.027803 -0.029942 -0.031298 -0.031904 -0.033117 -0.032078 -0.030435 -0.027988 -0.025355 -0.001447 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001862 -0.002054 -0.002221 -0.002351 -0.004539 -0.006727 -0.007768 -0.010870 -0.014597 -0.017174 -0.019942 -0.023091 -0.025933 -0.029413 -0.032708 -0.036863 -0.040227 -0.043180 -0.043276 -0.042260 -0.040199 -0.039009 -0.035432 -0.001542 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001956 -0.003440 -0.003837 -0.004195 -0.004495 -0.004720 -0.010087 -0.012875 -0.014104 -0.019191 -0.020536 -0.023354 -0.024895 -0.029358 -0.035721 -0.040857 -0.046447 -0.050272 -0.052143 -0.054020 -0.053006 -0.052059 -0.051866 -0.050679 -0.047350 -0.001598 -0.001140 0.000000 0.000000 -0.002975 -0.003532 -0.004133 -0.004782 -0.006662 -0.010219 -0.012645 -0.015333 -0.017936 -0.019251 -0.022166 -0.024640 -0.027008 -0.032320 -0.036973 -0.041407 -0.047752 -0.054105 -0.059193 -0.062236 -0.066637 -0.068418 -0.072505 -0.069852 -0.068724 -0.066115 -0.059970 -0.001621 -0.001156 0.000000 -0.003262 -0.003983 -0.006119 -0.007202 -0.011397 -0.012966 -0.016323 -0.017926 -0.021112 -0.024115 -0.025689 -0.028702 -0.036416 -0.041177 -0.045593 -0.048155 -0.055765 -0.062439 -0.067295 -0.075240 -0.078686 -0.081788 -0.085208 -0.089019 -0.089057 -0.088496 -0.082118 -0.078405 -0.001610 -0.002336 -0.003427 -0.005624 -0.006912 -0.011272 -0.014731 -0.017255 -0.021697 -0.024525 -0.027139 -0.030325 -0.035656 -0.040478 -0.044226 -0.049612 -0.055055 -0.060193 -0.065731 -0.074889 -0.079296 -0.086560 -0.091691 -0.094990 -0.099117 -0.104020 -0.108630 -0.111097 -0.110022 -0.107941 -0.098892 -0.002776 -0.003468 -0.005890 -0.009815 -0.013780 -0.016850 -0.020412 -0.026243 -0.030841 -0.036317 -0.040849 -0.045821 -0.053784 -0.060931 -0.064854 -0.074365 -0.077144 -0.082722 -0.089434 -0.098055 -0.104584 -0.110520 -0.116079 -0.122978 -0.127959 -0.133247 -0.137812 -0.139147 -0.137039 -0.129595 -0.124859 -0.004805 -0.007137 -0.010298 -0.014680 -0.018539 -0.023181 -0.030484 -0.037161 -0.045441 -0.052922 -0.061177 -0.069866 -0.078975 -0.089209 -0.097610 -0.102661 -0.109386 -0.112009 -0.118348 -0.124218 -0.129291 -0.136314 -0.143121 -0.149416 -0.162606 -0.170579 -0.172962 -0.168828 -0.164666 -0.156192 -0.147047 -0.008397 -0.010293 -0.013342 -0.019368 -0.025001 -0.033677 -0.042711 -0.054150 -0.065606 -0.077624 -0.087429 -0.098018 -0.114064 -0.122206 -0.130644 -0.140463 -0.146663 -0.154111 -0.156365 -0.161169 -0.164612 -0.170929 -0.176982 -0.184364 -0.198272 -0.209021 -0.208291 -0.200251 -0.186629 -0.156012 -0.118048 -0.011226 -0.013064 -0.019260 -0.025495 -0.033758 -0.046273 -0.061191 -0.076899 -0.092920 -0.105948 -0.121104 -0.137950 -0.149892 -0.164073 -0.172750 -0.182263 -0.189655 -0.198402 -0.208254 -0.211646 -0.215075 -0.218452 -0.226691 -0.236534 -0.251597 -0.250937 -0.246016 -0.225119 -0.151001 0.001294 0.176962 -0.013481 -0.018193 -0.024656 -0.033488 -0.047368 -0.064771 -0.084624 -0.105258 -0.122124 -0.137993 -0.148275 -0.137310 -0.116729 -0.122222 -0.157515 -0.203061 -0.238892 -0.252801 -0.261592 -0.271742 -0.277815 -0.284303 -0.289556 -0.298193 -0.304704 -0.292696 -0.276423 -0.208426 0.054672 0.669996 1.420292 -0.017496 -0.022609 -0.031372 -0.043867 -0.064077 -0.087145 -0.110754 -0.130046 -0.147601 -0.141292 -0.055404 0.166080 0.477456 0.562740 0.339242 0.022706 -0.205165 -0.301960 -0.332151 -0.343242 -0.351269 -0.356219 -0.361867 -0.361727 -0.358871 -0.342736 -0.302668 -0.142545 0.509565 2.247565 4.542823 -0.020774 -0.027808 -0.039680 -0.058615 -0.083721 -0.110810 -0.131446 -0.153082 -0.133029 0.048079 0.655057 2.296498 4.621789 5.923324 4.015546 1.527133 0.199843 -0.259693 -0.386017 -0.423082 -0.439912 -0.444132 -0.437997 -0.432920 -0.417210 -0.375844 -0.283244 0.014890 1.016243 3.615666 7.393962 -0.026150 -0.033897 -0.049553 -0.075020 -0.104415 -0.128976 -0.151154 -0.119081 0.170457 1.275391 4.631007 13.887088 31.964804 41.388226 25.983892 9.067119 1.822759 0.050572 -0.352108 -0.460664 -0.508180 -0.519653 -0.511147 -0.498056 -0.461018 -0.354194 -0.112629 0.398377 1.524177 4.019903 7.155724 -0.030203 -0.040587 -0.060378 -0.091497 -0.120324 -0.140577 -0.122958 0.204557 2.011747 8.936275 27.335035 71.008644 179.905991 234.592621 130.566055 35.169964 6.192883 0.848336 -0.119796 -0.389422 -0.519705 -0.557190 -0.522007 -0.485588 -0.426156 -0.212968 0.340974 1.296870 2.461864 4.062231 5.767587 -0.034132 -0.047455 -0.071496 -0.105340 -0.127790 -0.144003 0.056063 1.662078 12.015847 65.950165 243.387497 414.696411 616.677124 738.727356 361.665222 80.520248 12.514752 1.967492 0.305548 -0.180126 -0.329975 -0.177685 0.218954 0.418234 0.257204 0.261236 1.103312 2.634735 3.793941 4.367589 4.765072 -0.037824 -0.053935 -0.082010 -0.112770 -0.134308 -0.090469 0.612180 6.153133 53.888714 482.215454 2913.407471 5190.069824 2519.641602 1175.405151 515.175842 115.621475 18.745619 3.094169 0.973055 0.697358 1.293450 4.087173 10.174182 14.231615 8.733642 2.979677 1.934823 3.199696 4.320130 3.706203 2.971596 -0.040831 -0.059118 -0.087497 -0.115738 -0.121047 0.113543 2.251792 18.532616 189.574951 2737.397461 43533.835938 120104.820312 47121.656250 5821.008301 1745.310669 269.879852 31.796520 5.122860 4.298568 7.498595 14.032922 46.093117 172.245895 277.371368 135.768188 28.462093 4.672897 2.526681 2.701388 2.112764 1.251001 -0.040644 -0.062147 -0.092288 -0.115956 -0.065626 0.728486 7.715744 71.120216 670.891296 14723.357422 106309.195313 111503.257812 106075.226563 32969.945313 5743.940430 568.696167 47.056786 13.444333 36.079109 85.618401 127.277199 466.186279 3721.238525 9255.030273 2559.247559 223.873291 17.998449 2.108454 0.934291 0.542843 0.140825 -0.041346 -0.064182 -0.090711 -0.108684 0.046398 1.980335 25.584982 365.917694 5668.127441 47625.406250 114172.382812 102546.445313 102557.750000 32647.773438 3611.437988 399.434631 45.176880 60.753559 370.042694 1352.014282 1725.921875 3641.395020 57211.031250 101542.171875 28324.619141 960.487610 44.260487 3.084203 0.069720 -0.263111 -0.378083 -0.042286 -0.062551 -0.087402 -0.100160 0.142098 3.326939 53.920044 1265.980103 50929.230469 103387.210938 195897.875000 105921.398438 100560.960938 5055.734863 623.640259 117.629692 51.973080 273.610535 3401.972656 25790.072266 31178.146484 75546.304688 154347.968750 177524.156250 34606.414063 1101.662476 58.439598 5.177439 0.428884 -0.284617 -0.374199 -0.042128 -0.062537 -0.083690 -0.096569 0.128820 3.104041 47.113350 1074.526367 33224.828125 100299.398438 101936.984375 9529.304687 2465.239502 434.555237 97.299850 102.993660 266.499542 853.521851 10519.272461 100531.000000 119346.632812 113754.328125 105113.437500 110497.375000 26308.478516 770.294678 77.394897 17.521292 4.520656 1.419878 1.403556 -0.042603 -0.059537 -0.083250 -0.100733 0.020897 1.565256 18.961510 243.370346 2869.376221 12215.529297 6416.631348 864.816284 149.957962 53.144375 143.286499 1145.369385 5311.428711 8202.769531 11503.145508 58728.207031 82367.281250 107501.023437 104664.179688 120279.523437 33631.062500 1777.091553 373.035645 115.023254 26.121998 14.441548 22.099394 -0.044211 -0.061372 -0.078403 -0.100404 -0.073046 0.391681 4.270241 30.488338 150.450943 348.375916 248.339035 72.727654 22.942825 62.569386 888.856934 23497.226563 102158.218750 127711.109375 85350.257813 14361.919922 7409.738281 80480.906250 200137.843750 186246.406250 104346.070313 16242.362305 2761.342041 660.941345 115.488289 150.093124 419.419312 -0.047707 -0.055972 -0.078087 -0.098721 -0.115214 -0.037184 0.548513 3.168915 10.510236 17.892172 14.788597 9.530175 28.016161 217.998444 3136.651123 100824.539063 102259.476563 127378.796875 170778.484375 12396.573242 1151.151855 5700.276367 103404.812500 101824.843750 102054.507813 46225.750000 9835.500000 1780.597900 425.779144 2151.348877 16021.618164 -0.055912 -0.062889 -0.076196 -0.095323 -0.114404 -0.137960 -0.099115 0.131468 0.570003 1.074637 1.896468 12.054935 141.180832 2004.601074 21217.126953 141909.078125 108975.039062 103826.609375 101208.140625 3170.157227 323.202179 1566.926636 70681.218750 100198.609375 101273.210938 13330.405273 6458.586914 2468.112305 2612.618652 29205.761719 100209.234375 -0.063146 -0.063469 -0.073028 -0.093022 -0.115637 -0.145032 -0.186505 -0.213438 -0.224465 -0.073761 1.806978 27.324450 552.904724 21215.623047 100411.921875 106672.578125 156994.156250 61388.914063 6530.607910 580.662720 135.936050 214.203415 1756.840332 6395.075195 4066.720947 2318.669678 7035.321289 26757.492188 103149.984375 123972.585937 103128.140625 -0.072971 -0.072544 -0.075051 -0.094510 -0.118782 -0.145545 -0.189048 -0.241461 -0.283932 -0.127952 2.195289 34.201790 787.694153 51236.281250 100248.914063 102546.648438 110186.335937 13856.717773 2026.619141 1596.843018 1033.844971 343.695648 124.093956 170.559708 300.748291 2085.151123 19978.416016 119364.906250 104615.867188 116421.976562 134398.156250 -0.087642 -0.084728 -0.083187 -0.098981 -0.119634 -0.152626 -0.194122 -0.232525 -0.282310 -0.168891 1.453960 21.805843 366.934113 10222.227539 101262.375000 156647.296875 186417.328125 106485.312500 58135.410156 90682.296875 19489.609375 2653.768066 222.835007 38.266926 112.542900 1086.071655 14428.615234 107373.484375 103027.242188 103694.757813 57991.492188 -0.107470 -0.099058 -0.102468 -0.112006 -0.135691 -0.164203 -0.201395 -0.239263 -0.288286 -0.257233 0.462848 7.411257 77.667259 863.338684 7723.949219 109350.109375 103703.476563 163234.421875 117165.507812 110530.835937 122891.507812 8413.771484 443.041046 40.015694 39.894176 281.238647 2976.033691 72946.351563 157015.859375 200120.359375 71597.515625 -0.133801 -0.128368 -0.126301 -0.135978 -0.152634 -0.175662 -0.208075 -0.250072 -0.294330 -0.328426 -0.138165 1.632322 13.593348 101.369858 1169.245483 33473.242188 101537.296875 200071.703125 104883.234375 103383.281250 106692.046875 9174.366211 587.793701 62.013115 16.084755 65.187210 658.117798 19549.814453 105571.453125 103380.710938 100563.140625 -0.170050 -0.153221 -0.150013 -0.151916 -0.168841 -0.189666 -0.221792 -0.255874 -0.304578 -0.360373 -0.374213 -0.040465 2.238935 17.379633 152.625504 1299.199951 4613.707520 20025.029297 100830.781250 104593.148438 95416.359375 12257.021484 1430.262817 123.252312 13.770295 26.997284 444.646118 21271.919922 100157.859375 100114.257813 100039.179688 -0.201544 -0.180598 -0.149974 -0.092078 -0.043626 -0.043647 -0.114699 -0.218454 -0.304021 -0.369797 -0.434872 -0.425888 -0.012187 2.645102 16.696436 71.658760 227.357986 1150.704956 6747.698730 15020.592773 33669.890625 17953.283203 1984.431152 143.172195 13.468554 12.285551 157.074585 3372.225342 95838.609375 100006.890625 100002.773438 -0.230494 -0.149275 0.102929 0.778982 1.723277 1.947552 1.220608 0.351312 -0.127714 -0.334761 -0.434865 -0.502956 -0.437141 0.441021 5.725324 32.441692 122.258385 392.980865 2378.615967 12182.958984 15431.780273 5643.425293 839.704468 84.650543 9.000060 3.879855 30.324736 277.677887 1786.336426 4306.528320 1929.745605 -0.220885 0.192817 2.261036 10.033750 25.645996 31.011017 17.643837 5.693203 1.482027 0.268980 -0.229659 -0.461748 -0.427739 0.888803 12.666811 105.409416 535.194824 1394.653442 13670.351563 100268.125000 100490.210938 10534.791016 585.510254 49.530037 5.645344 1.218986 4.825138 23.160418 73.640289 120.053078 78.140030 -0.079866 1.850730 16.878830 123.353172 501.758270 680.506104 270.769592 52.050980 13.889047 5.284513 1.477048 -0.058347 -0.330572 1.296202 17.955170 180.226044 1048.308594 2335.790771 15138.368164 100090.609375 100045.859375 12199.212891 564.485962 37.308750 4.815894 2.409227 5.373119 10.847568 13.413276 12.169529 10.988301 0.255876 6.694137 89.100258 1365.756836 16354.092773 27087.458984 5002.217773 446.540192 122.939110 51.284790 14.114961 2.212623 -0.042873 0.810703 11.636987 96.858887 480.034393 919.614014 3118.492676 17600.925781 16010.693359 2445.969482 202.891312 20.437561 6.011931 16.270323 65.032692 154.578400 146.456223 64.949890 51.886257 0.603338 12.856533 246.802261 7649.977051 100391.195313 102656.992188 51725.328125 4252.800293 1481.401489 538.006226 92.209595 10.706633 0.888277 0.307378 3.766937 22.222534 78.507233 138.026367 289.146423 742.093933 732.768311 228.442215 39.687836 8.190091 15.904700 136.585648 1133.562622 5091.013184 4690.017090 953.155090 419.850769 0.620430 12.863276 239.556931 7142.731934 104693.242188 200048.203125 137276.406250 104705.421875 14425.520508 3580.430908 358.133759 27.900105 2.705096 1.153899 1.629628 3.817485 8.972990 15.869969 27.250021 44.599079 43.144337 20.547806 6.245472 5.390086 49.022228 908.585327 25634.486328 100011.156250 100073.851563 17922.960938 2857.955566 0.270259 7.718466 99.663597 1505.499268 34988.253906 116762.593750 103919.109375 106087.000000 41341.140625 5734.716797 484.106812 34.318378 5.074315 5.107643 4.976788 2.784971 1.355614 1.349477 2.170000 3.271566 3.272984 2.036925 1.502112 6.570108 93.934212 2644.251465 100004.585938 100054.718750 100640.273438 106127.375000 22477.662109 0.117167 5.308860 60.875465 903.113342 23668.488281 127442.000000 111456.773437 102429.492188 19473.552734 1729.977905 203.331940 20.517700 7.083994 11.668340 12.221087 5.790942 1.169613 -0.238664 -0.343366 0.089519 1.137779 3.307840 6.469326 11.312752 77.275764 1932.053711 100010.101563 100145.625000 103372.492188 158777.156250 102561.796875 0.538224 6.463766 105.642746 3533.121094 102296.265625 137992.468750 200224.906250 48249.410156 2624.547119 277.314026 45.414017 8.661674 7.190376 14.051107 13.780858 6.441264 1.228768 -0.350542 -0.307916 1.284951 8.112768 32.312366 80.863144 93.355217 76.444115 403.431183 6042.801270 46454.429688 46164.628906 104333.328125 100493.820313 1.660947 7.331761 145.073975 6376.064941 100354.265625 102382.921875 106762.429687 28619.500000 1177.962646 142.540802 33.766186 15.356750 9.683707 9.024984 7.785384 3.358529 0.436527 -0.384751 0.319064 6.631192 53.476376 394.796967 1797.372314 2272.098633 750.586975 163.405182 300.748077 930.745117 2105.671387 17811.525391 69843.171875 3.021725 5.213375 74.051880 1955.752563 89649.703125 131178.171875 200213.359375 105918.210938 8195.230469 744.164429 279.241821 211.880417 85.294624 20.300383 4.729617 1.025387 -0.046481 0.020469 1.832043 20.409578 281.947845 5105.435059 69815.843750 100107.695313 13471.625977 841.703796 101.836563 68.413628 203.868134 928.498291 1797.599976 3.665022 2.997373 24.684977 318.333557 5113.157227 105914.242188 104655.789063 117946.515625 59523.628906 9216.698242 8392.122070 7854.934082 1659.144531 165.860229 16.073040 2.351469 2.960639 5.964596 8.452895 40.098072 739.073181 31156.851563 100310.406250 101967.757813 105113.093750 4914.840820 521.423767 62.830990 27.160191 57.490204 84.758148 4.646059 2.688947 9.556418 106.699951 2021.224609 70318.609375 112257.617187 200071.562500 113150.367187 130602.796875 102483.031250 100128.867188 41874.152344 1140.416626 58.477062 13.033879 38.560627 95.463051 91.836189 63.607666 652.061829 21332.162109 103130.507813 195867.968750 177540.781250 102029.945313 6208.252441 293.778961 29.166872 7.735065 6.453845 7.895038 4.698914 4.697896 33.973087 393.152954 4449.918457 32015.710938 110255.148437 103973.468750 200174.890625 103302.882813 100366.968750 100135.617188 3412.954102 132.747391 64.977478 463.636322 1962.306885 1658.240479 334.758301 227.607407 2768.861084 35797.054688 131189.312500 106025.039063 102209.929688 43820.703125 1152.385376 103.670097 11.542586 1.565569 11.204165 6.459632 2.819889 8.158275 57.257202 388.000671 3556.640869 42269.511719 88071.859375 115039.234375 103116.109375 103436.953125 101182.460938 2528.334717 227.175537 233.132111 3041.823486 28076.074219 20500.308594 1814.880981 150.606186 465.422607 12826.198242 101107.695313 105393.781250 141919.015625 77408.929688 6094.319824 391.122925 29.498589 2.543528 8.342824 5.660049 2.429477 2.119650 9.355412 51.774883 309.577789 1294.151855 2473.662598 8923.054687 76507.250000 93199.742188 13507.081055 1331.166138 545.265686 379.413300 4370.896484 48360.785156 34821.449219 2570.863770 150.601685 125.690880 1862.515503 35040.003906 117586.015625 162901.421875 103380.539063 21355.636719 799.684570 44.606495 3.605169 10.056582 9.182156 5.398624 2.499727 3.450557 18.728746 97.364799 311.699066 923.592224 5274.504395 20898.873047 28915.761719 6319.600098 1111.673096 640.583313 277.441132 1053.480957 5258.064941 4406.032715 699.733215 120.535995 68.586250 192.214752 1299.164673 11242.500000 101143.015625 100236.585938 10201.734375 555.182556 34.970486 3.396698 53.875622 51.136597 24.331036 7.743260 9.200606 97.413559 1307.071899 7854.862793 12991.622070 101413.210938 102659.898438 73945.742188 4240.399414 760.643066 288.574646 106.263031 125.335548 321.986847 392.074036 630.102844 1100.613770 656.894836 167.959503 182.969177 1122.666992 5141.599609 5558.244629 1227.139526 137.397110 13.887291 3.391739 324.209656 302.818512 103.996330 22.830353 24.143433 498.329987 22756.158203 100552.976563 125654.765625 113800.546875 102271.664063 127290.242187 70486.851563 9450.774414 518.832397 51.560307 26.380917 106.073967 1100.241089 14659.690430 56787.699219 19318.966797 1556.052368 136.409821 104.459740 233.386826 245.596024 94.384048 20.676691 4.267595 4.450139 1106.266724 951.991272 284.646362 51.149609 35.406597 859.990051 67799.679688 100365.062500 112186.984375 135172.156250 120512.132812 200120.750000 104378.882813 100184.375000 2885.218506 89.214348 21.094227 209.160065 6053.832031 100059.156250 100102.203125 100167.742188 11298.873047 412.061096 52.692642 23.644690 17.247730 8.605796 2.504344 1.477019 4.305423 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.001949 -0.002017 -0.002045 -0.003928 -0.004007 -0.004015 -0.002207 -0.002222 -0.002192 -0.002117 -0.002004 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002162 -0.002349 -0.003919 -0.006117 -0.006490 -0.006775 -0.006924 -0.006914 -0.006778 -0.006523 -0.006154 -0.002796 -0.002644 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002147 -0.002449 -0.004199 -0.006519 -0.007241 -0.007879 -0.008429 -0.008830 -0.009033 -0.009028 -0.008882 -0.008522 -0.007993 -0.007358 -0.004947 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001909 -0.002269 -0.004033 -0.004690 -0.007247 -0.008258 -0.009237 -0.010132 -0.010884 -0.011442 -0.011752 -0.011790 -0.011543 -0.011069 -0.010379 -0.009496 -0.008507 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001883 -0.002285 -0.004177 -0.004964 -0.007714 -0.009024 -0.010386 -0.011733 -0.012928 -0.013982 -0.014734 -0.015201 -0.015260 -0.014967 -0.014323 -0.013321 -0.012151 -0.010829 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002207 -0.004119 -0.005012 -0.007838 -0.009400 -0.011110 -0.012926 -0.016353 -0.018196 -0.019724 -0.020896 -0.021552 -0.021648 -0.021175 -0.021270 -0.019868 -0.016696 -0.014903 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002045 -0.002536 -0.004837 -0.005948 -0.009353 -0.011338 -0.015261 -0.017801 -0.020349 -0.022786 -0.024957 -0.026439 -0.028519 -0.028863 -0.028402 -0.027189 -0.025416 -0.023030 -0.020498 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002285 -0.004454 -0.005573 -0.008823 -0.012567 -0.015279 -0.018334 -0.021620 -0.024934 -0.028236 -0.032058 -0.034433 -0.036041 -0.036523 -0.035986 -0.034409 -0.032007 -0.030514 -0.027157 -0.001205 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001676 -0.003736 -0.005740 -0.006832 -0.008125 -0.013398 -0.016147 -0.017834 -0.021600 -0.025743 -0.030056 -0.035345 -0.039212 -0.042456 -0.044537 -0.046842 -0.046379 -0.044580 -0.041675 -0.039598 -0.035600 -0.001311 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001736 -0.001969 -0.002174 -0.002351 -0.004606 -0.006847 -0.008092 -0.009544 -0.017155 -0.020429 -0.024274 -0.028598 -0.033315 -0.038128 -0.044817 -0.050147 -0.055702 -0.060496 -0.062042 -0.061650 -0.061291 -0.057542 -0.055022 -0.050274 -0.001387 0.000000 0.000000 0.000000 0.000000 -0.001748 -0.002069 -0.003607 -0.004025 -0.004437 -0.006355 -0.008931 -0.013276 -0.014831 -0.020253 -0.023302 -0.025752 -0.031031 -0.037401 -0.046646 -0.053322 -0.061578 -0.068260 -0.073660 -0.076062 -0.077560 -0.080032 -0.077390 -0.074694 -0.070024 -0.063372 -0.001437 0.000000 0.000000 0.000000 -0.003122 -0.003709 -0.004365 -0.005020 -0.008675 -0.009587 -0.013362 -0.018012 -0.019796 -0.023241 -0.027479 -0.030436 -0.035809 -0.043105 -0.050620 -0.057814 -0.068691 -0.075379 -0.082321 -0.088707 -0.096180 -0.100616 -0.101384 -0.101287 -0.096984 -0.091418 -0.085462 -0.001457 0.000000 -0.002761 -0.003412 -0.004190 -0.006361 -0.009175 -0.011902 -0.015239 -0.017212 -0.019055 -0.024316 -0.026554 -0.030439 -0.039014 -0.043889 -0.049523 -0.056186 -0.064220 -0.073320 -0.081041 -0.093746 -0.103845 -0.112440 -0.116867 -0.120776 -0.124773 -0.121232 -0.119363 -0.115346 -0.108045 -0.001447 -0.002829 -0.003594 -0.005811 -0.007153 -0.011721 -0.015241 -0.019607 -0.022825 -0.025971 -0.028846 -0.035066 -0.039461 -0.047923 -0.053298 -0.058794 -0.063254 -0.073824 -0.080569 -0.092852 -0.101922 -0.110933 -0.120965 -0.129846 -0.140380 -0.144986 -0.149698 -0.150273 -0.147532 -0.144258 -0.135589 -0.002672 -0.003610 -0.006107 -0.008899 -0.014219 -0.017506 -0.022957 -0.027665 -0.032631 -0.037753 -0.044796 -0.054194 -0.061626 -0.067293 -0.074489 -0.081166 -0.091742 -0.098556 -0.109562 -0.120413 -0.129909 -0.141053 -0.151561 -0.164208 -0.169947 -0.179469 -0.179950 -0.180586 -0.177609 -0.169599 -0.161233 -0.004813 -0.007266 -0.009321 -0.015078 -0.019134 -0.025665 -0.032008 -0.039291 -0.047092 -0.057756 -0.065265 -0.077554 -0.087962 -0.097300 -0.107880 -0.113412 -0.125225 -0.134685 -0.141353 -0.149202 -0.159201 -0.172210 -0.181898 -0.196668 -0.209042 -0.218142 -0.218693 -0.214205 -0.206919 -0.184542 -0.159057 -0.009527 -0.009347 -0.015288 -0.019877 -0.025825 -0.035223 -0.044795 -0.057035 -0.070601 -0.081355 -0.091890 -0.106579 -0.121142 -0.130885 -0.142741 -0.155114 -0.164704 -0.175992 -0.183661 -0.191803 -0.201120 -0.211809 -0.225695 -0.239429 -0.252781 -0.259981 -0.257944 -0.239763 -0.169556 -0.026181 0.139073 -0.012503 -0.013229 -0.019671 -0.026213 -0.036575 -0.048318 -0.063931 -0.081708 -0.095457 -0.110260 -0.126482 -0.139114 -0.151944 -0.162431 -0.177550 -0.194908 -0.213808 -0.223472 -0.236057 -0.248064 -0.255742 -0.270712 -0.283369 -0.300544 -0.309064 -0.303685 -0.285208 -0.189252 0.224390 1.283579 2.556973 -0.014968 -0.018531 -0.025235 -0.034448 -0.049111 -0.067250 -0.087667 -0.106714 -0.121975 -0.137906 -0.123845 -0.063478 0.019612 0.042689 -0.039434 -0.148099 -0.232904 -0.270981 -0.290346 -0.309660 -0.323359 -0.335626 -0.348748 -0.362278 -0.358738 -0.344977 -0.283964 0.101537 1.891183 7.926630 18.269596 -0.017976 -0.023009 -0.032119 -0.046643 -0.065175 -0.089769 -0.112227 -0.129246 -0.143929 -0.087549 0.184954 0.881592 1.916427 2.361370 1.579557 0.560034 -0.031686 -0.263871 -0.337015 -0.369475 -0.396054 -0.410296 -0.415085 -0.421493 -0.409030 -0.372758 -0.192790 0.787358 6.211569 30.523239 79.330803 -0.024261 -0.028308 -0.040357 -0.059999 -0.085685 -0.111348 -0.131554 -0.146572 -0.068966 0.405097 2.403604 8.429494 20.782520 27.326303 17.431990 6.220708 1.358597 0.080357 -0.238575 -0.365903 -0.442262 -0.477163 -0.484563 -0.480241 -0.427345 -0.273825 0.179293 1.964676 10.940573 53.732586 150.974335 -0.028033 -0.035317 -0.050103 -0.075292 -0.105223 -0.130024 -0.144438 -0.065089 0.541064 3.198724 15.132604 73.038971 245.862579 364.658875 187.945099 46.142376 8.271728 1.624739 0.411445 -0.060987 -0.371279 -0.512360 -0.546428 -0.510357 -0.340178 0.193735 1.637409 5.113878 14.566690 49.063782 114.744865 -0.030697 -0.041881 -0.060748 -0.092087 -0.121164 -0.140874 -0.093847 0.508498 4.294842 21.983318 97.334602 509.457062 2899.296631 5548.500488 1933.792480 262.262665 29.862246 5.943734 2.704888 1.013802 -0.042324 -0.429070 -0.476582 -0.377962 0.014256 1.508496 6.402309 15.767564 26.698517 45.838448 80.532196 -0.034429 -0.048481 -0.073044 -0.105748 -0.129951 -0.135117 0.158748 2.917442 26.808041 228.312790 1286.432129 3298.626709 18207.988281 41950.746094 10186.693359 793.959717 65.013100 13.066435 7.269504 3.127684 0.741379 0.254074 0.720460 1.236496 1.404433 3.810747 15.010098 37.693573 52.973431 52.469208 62.026394 -0.037892 -0.053562 -0.082440 -0.114382 -0.136377 -0.091013 0.768003 9.867604 134.939392 2710.131836 51184.910156 101938.679688 31134.626953 38662.968750 9381.790039 807.078430 70.570320 17.875530 10.737342 5.151821 2.887093 6.976312 19.378399 27.994263 16.842482 9.262959 19.408676 49.283463 64.937653 48.471558 35.189388 -0.040594 -0.058416 -0.088734 -0.117145 -0.133831 0.022251 1.825018 20.089712 334.080078 12755.632813 105143.273438 115003.085937 108530.609375 7317.694824 1872.321899 286.495453 41.468365 14.484639 10.341504 7.595675 15.332748 93.671234 501.053986 861.259338 368.723358 63.334084 19.148256 31.283411 39.486347 26.452644 13.890017 -0.042245 -0.061276 -0.092220 -0.119043 -0.110244 0.276905 3.801421 33.851498 404.409912 10153.916016 156811.218750 200109.375000 156705.343750 5492.965820 536.669128 102.345001 21.308182 9.933995 13.403199 25.796036 91.914040 1342.465454 28134.726563 100046.132813 15089.817383 681.096802 38.586586 12.205330 12.643711 8.583689 4.190759 -0.041554 -0.064907 -0.093711 -0.117926 -0.061610 0.771357 8.086605 71.876678 581.443115 5011.067871 95927.343750 118188.289062 103834.835938 4772.157227 334.504608 54.843994 15.303756 18.622795 58.191219 158.289520 470.824036 11034.092773 101800.781250 100911.765625 100176.859375 3982.024658 99.582863 7.138451 2.751190 1.579081 0.516125 -0.042748 -0.063612 -0.089231 -0.112822 -0.016765 1.216642 13.320533 147.553925 1331.092529 5399.964844 13061.289063 35070.851563 12391.782227 1217.652588 126.278702 36.818134 49.469429 89.804543 266.635010 849.086304 2620.222168 38623.859375 200053.312500 131132.515625 101944.875000 4458.533691 112.299660 9.830387 1.714551 0.162302 -0.276271 -0.042600 -0.063361 -0.084019 -0.111540 -0.022438 1.110980 12.122306 124.978600 1089.005127 3527.455566 2649.771240 1562.484375 728.815002 163.743912 54.695190 169.057159 632.321289 976.907776 858.536438 2125.140869 10531.645508 101977.070313 131428.109375 200300.515625 29841.455078 1189.499268 162.210175 51.094604 11.159481 2.157880 0.698827 -0.043104 -0.061188 -0.083833 -0.106617 -0.070829 0.510731 5.400184 44.428799 245.793091 592.771057 441.833771 157.273590 60.127254 35.575253 176.328461 1770.369751 12482.689453 18920.792969 4622.437012 1836.781372 10607.858398 100709.093750 103768.812500 115899.406250 19793.728516 3614.781494 2532.152588 600.340881 81.378914 14.290230 9.990912 -0.045300 -0.059348 -0.078289 -0.100886 -0.108999 0.075381 1.436657 8.436196 30.772352 57.798889 47.355564 21.384338 13.923792 66.737061 1006.466492 29677.890625 125375.382812 168303.656250 33367.957031 1843.600708 2080.251709 30086.564453 199038.343750 131601.796875 110484.273437 106043.117188 86422.945313 7842.273437 469.147675 77.055298 116.855545 -0.046148 -0.056534 -0.076489 -0.098267 -0.121993 -0.108163 0.122253 1.075862 3.148537 5.375585 4.802593 5.745503 29.765421 242.406342 3459.476074 101426.242188 107350.984375 115645.968750 103838.929688 3059.590820 434.382507 4346.517090 101995.984375 102125.398438 146497.515625 124479.984375 100633.164063 42157.132813 1247.887573 487.306824 1549.372437 -0.051529 -0.060743 -0.075089 -0.094425 -0.118619 -0.150414 -0.156647 -0.092157 0.071082 0.297808 1.275490 12.337545 150.241776 2336.323730 27733.662109 151318.234375 110712.765625 101689.304688 100580.265625 1963.409058 176.822723 1225.932007 45719.507813 100851.320313 123416.585937 106784.992187 105792.281250 29233.621094 3296.701660 2828.903564 17670.486328 -0.057002 -0.065171 -0.074301 -0.092701 -0.115202 -0.146395 -0.189940 -0.233160 -0.264704 -0.118504 1.867853 28.878567 592.976990 28260.035156 100427.031250 107200.304687 169867.953125 68093.906250 6855.365234 564.151245 220.051407 238.156555 1403.777710 5520.865723 5803.675781 23752.220703 112573.054687 105478.210938 45886.832031 12115.453125 42767.328125 -0.066895 -0.070351 -0.076542 -0.092325 -0.114798 -0.143228 -0.183236 -0.230697 -0.282800 -0.118750 2.325353 38.311626 909.856873 62894.929688 100107.976563 100666.289063 101863.953125 11047.480469 1489.003052 4175.489746 7796.376953 1858.079712 228.935669 203.194458 1043.269775 31644.808594 101959.148438 134488.500000 200204.765625 99854.343750 15390.305664 -0.077691 -0.078419 -0.082599 -0.097273 -0.115654 -0.139841 -0.184341 -0.225629 -0.277905 -0.168135 1.537246 22.932503 418.230530 13339.504883 100217.898438 102451.328125 110244.335937 10245.688477 15317.619141 114663.625000 103375.523438 48648.601563 1128.506592 80.444588 444.231110 10289.717773 101969.984375 156853.062500 134870.453125 102427.531250 8559.651367 -0.096223 -0.091910 -0.099845 -0.112597 -0.129911 -0.161239 -0.190266 -0.231089 -0.277718 -0.250594 0.499411 7.666887 84.706940 868.775635 6377.558594 16431.974609 33478.644531 26117.945313 111326.765625 200093.593750 141879.703125 101437.820313 2041.828247 78.287323 104.187294 1034.724243 6293.632812 17382.951172 51985.488281 61369.738281 16459.712891 -0.121909 -0.116426 -0.119119 -0.128490 -0.143692 -0.168467 -0.196762 -0.240603 -0.286581 -0.315328 -0.118476 1.617062 12.432809 72.853424 361.369598 2010.578613 7664.164551 25369.509766 103292.000000 176139.218750 186254.578125 24911.132813 854.492371 47.981438 21.286711 99.658401 512.967468 5883.044922 101430.132813 100936.789063 100209.117188 -0.148977 -0.136740 -0.140185 -0.146308 -0.156729 -0.176027 -0.207613 -0.246757 -0.294245 -0.348845 -0.354602 -0.059673 1.711890 10.103385 51.052784 243.133072 770.835754 5060.029297 63230.097656 101728.250000 17559.089844 1899.359497 238.795471 30.138414 6.668948 21.530815 238.956482 6083.984375 100077.507813 100057.414063 100021.328125 -0.177011 -0.159539 -0.121411 -0.059922 0.019814 0.024471 -0.073069 -0.189796 -0.282696 -0.352714 -0.410625 -0.418065 -0.169768 1.186500 6.852975 27.111744 92.056824 465.036011 2037.600586 2992.374268 1496.290161 576.358276 144.161041 24.064375 3.993267 8.368421 90.299873 1320.879272 19284.220703 77488.351563 23295.416016 -0.200708 -0.108533 0.236869 1.209077 2.574393 2.883130 1.819420 0.524367 -0.092362 -0.328808 -0.426800 -0.483527 -0.491358 -0.204832 1.245111 6.517182 23.771385 87.009003 304.604065 737.246826 765.144043 358.225708 93.151245 18.386198 3.871490 3.056766 20.533394 154.461319 785.516235 1653.674561 844.307739 -0.171019 0.380397 3.386721 15.867289 44.080853 53.317921 27.486773 7.546822 1.458587 0.015107 -0.356322 -0.488622 -0.528608 -0.294125 1.403290 9.044709 32.823360 111.304527 621.906738 2125.887695 1984.611816 557.556335 91.125565 19.849009 7.566607 3.277244 3.948300 15.648587 45.550594 68.951736 48.508728 0.039897 2.815790 28.693380 243.149704 1257.020630 1887.571655 585.212524 82.967598 11.209446 2.183914 0.221502 -0.369273 -0.517922 -0.234705 1.836859 11.992105 43.650547 132.083099 659.055420 2268.136475 2266.609863 561.729004 90.547318 31.094736 19.373316 8.375007 4.720771 6.071496 7.525675 7.602192 7.976749 0.510218 10.541208 172.309982 4426.933105 100018.554688 100055.296875 19994.583984 788.474365 65.105217 13.544158 3.214994 0.249059 -0.431619 -0.343433 1.129870 7.699236 25.770542 66.653381 242.984436 685.459412 636.957458 208.097900 58.337261 41.399750 30.514822 18.593061 29.811487 54.808228 55.263958 29.085138 32.204166 1.046841 21.433096 540.176880 41003.488281 100188.359375 100981.000000 101943.421875 4137.625000 318.661713 64.192947 14.082711 2.033873 -0.181915 -0.454616 0.104056 2.407949 7.802327 18.191238 47.537399 95.341019 89.902939 44.453297 26.098236 29.522694 28.583683 60.051891 298.949280 909.357605 848.713928 265.724335 201.715515 0.970327 20.742846 507.603912 33296.363281 101663.093750 123312.578125 186172.953125 24183.363281 1821.877808 220.877853 36.581532 4.943428 0.201196 -0.421762 -0.366258 0.061718 1.111029 2.913112 6.436844 10.862044 11.375665 8.409472 9.357725 12.856133 29.359575 246.960449 2865.447266 16006.489258 14616.605469 2356.853027 910.057434 0.419765 10.469653 158.746597 3379.052490 62788.652344 200306.171875 112427.156250 100747.859375 5855.789551 353.204468 49.265121 6.174964 0.454360 -0.160943 -0.257452 -0.386923 -0.408074 -0.198282 0.276608 0.863083 1.305531 1.700214 2.627335 5.845833 38.393375 551.172546 11120.290039 100014.789063 95934.187500 8342.587891 2406.520020 0.019571 5.210430 57.842865 681.611084 9516.362305 117400.562500 107336.953125 100806.632813 4487.787109 249.697708 30.799526 4.170251 0.425456 0.185658 0.078445 -0.309980 -0.624379 -0.732347 -0.624847 -0.255059 0.516527 1.757568 3.239885 5.884333 32.434315 417.625366 7161.972168 56758.054688 51534.238281 7384.833008 6396.952637 -0.026025 5.308185 86.343109 2305.512451 100881.937500 108583.000000 123366.179687 14811.345703 1014.783142 95.031189 14.380398 2.734703 0.628591 0.348537 0.177678 -0.299874 -0.673867 -0.809400 -0.650151 0.209488 3.197804 11.486681 25.525894 29.586523 28.735584 125.661217 1057.826172 4346.187012 4044.420410 3904.236084 8019.094727 0.088826 5.749588 110.353912 4445.578125 100142.414063 100639.804688 101294.164063 15663.140625 560.901672 90.036324 26.253014 11.299351 5.106052 1.590402 0.179489 -0.447329 -0.747446 -0.773805 -0.363987 2.251292 17.868202 89.747139 263.263184 323.443817 146.563766 56.727825 103.974075 252.118057 380.616547 996.203125 1965.867676 0.616581 4.153924 59.048267 1384.229736 45822.324219 101849.242188 106879.945312 9050.708008 2814.033936 866.640625 256.963348 143.496307 59.400017 13.844987 2.015089 -0.164309 -0.272900 0.139359 0.950786 7.525291 70.203735 555.190918 2884.590088 3712.244141 1154.065918 209.025742 50.748928 31.176197 54.161156 137.700775 219.200912 4.931051 4.302513 19.267527 187.878876 1718.932251 9384.552734 32362.978516 92391.367188 101777.375000 26550.138672 4599.636719 3722.958496 914.070007 113.109062 11.823255 2.695041 6.594172 13.947448 14.385686 18.683601 149.412201 1809.522827 13510.301758 20415.150391 6299.191406 1852.766846 308.656677 41.485271 12.235023 16.881413 24.178230 33.482388 19.500742 10.376901 44.775997 389.593781 3809.604004 62406.953125 107215.414062 101607.382813 113416.718750 107171.132812 100192.437500 16016.114258 682.660156 43.448387 22.622139 117.827591 368.752441 319.807220 102.941696 142.064178 1516.551147 10961.482422 47643.179688 102875.781250 57022.078125 3150.599365 179.093826 17.210213 4.963093 5.882124 154.159225 72.897079 17.612963 17.522102 127.400650 1461.677612 71000.335938 100968.781250 101651.234375 177527.484375 109333.906250 100244.820313 100029.781250 1795.759033 87.689346 173.316284 2779.071777 22748.638672 18502.517578 1676.623901 159.746109 561.966675 8582.443359 101802.570313 100664.335938 100281.429688 16201.524414 496.747070 41.051361 8.060237 5.924224 294.839691 125.799286 25.215443 7.789261 35.728046 391.519775 9408.926758 100128.898438 101019.445313 100819.007813 102064.156250 100263.164063 46372.550781 1253.852783 98.999901 809.008728 54080.648438 100128.539063 100188.265625 22840.072266 446.991333 256.473450 5674.615723 100199.984375 100409.140625 101239.320313 13486.208008 754.034912 83.365089 14.090602 7.056471 158.936523 76.580711 17.841314 3.836817 8.489957 67.333267 563.348328 3141.077637 5358.389160 4904.135254 21796.304688 23832.015625 3889.834961 348.155914 84.878212 1040.014526 96135.812500 100592.960938 100914.054688 39226.925781 610.607178 116.988899 1080.883301 14702.626953 63620.906250 26663.296875 5153.832520 965.919128 117.832672 16.427450 6.902039 65.645264 47.516411 18.970789 4.813305 2.772159 13.569175 61.072407 180.903137 367.447937 930.159607 1789.239624 1483.029785 523.596252 129.516418 60.393681 357.686371 8550.729492 100987.734375 97687.648438 5633.594727 446.321411 126.021339 145.067856 626.812683 1648.518066 2611.355713 2241.764893 572.921387 82.808929 13.520959 9.587255 425.551331 369.369446 130.198380 23.664154 6.608611 29.635128 214.708557 814.505249 1544.570679 6811.727051 13599.230469 4536.331543 1064.056763 288.062775 66.538696 72.514206 468.517670 1917.803955 2238.891113 1833.308838 2344.368408 1258.443115 255.782486 87.695152 180.746841 400.462555 377.362823 140.653107 30.216358 11.534317 25.178841 7170.440430 6037.353027 1137.455322 114.427879 19.134872 103.682899 1409.491943 9329.412109 10443.413086 29336.898438 71241.875000 30971.179688 34203.648438 5863.558105 385.607452 40.837643 66.117752 281.011139 2266.517578 35550.917969 101453.726563 51744.945313 2964.973145 182.209549 38.714615 47.869190 45.270840 23.613098 9.114089 13.100261 55.610321 69872.257813 51273.281250 5111.928711 303.953735 32.939037 156.590485 2779.277588 22831.890625 21822.919922 15594.507813 43534.414063 108012.835937 100770.515625 100094.382813 2061.308594 75.145996 33.129475 375.804871 13622.069336 101080.820313 101400.195313 100724.085938 26010.775391 662.284851 58.945286 12.564707 6.317700 4.054219 3.675268 12.090396 58.184338 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002103 -0.002285 -0.002432 -0.004337 -0.006076 -0.006319 -0.006438 -0.006433 -0.006299 -0.006065 -0.002663 -0.002553 -0.002415 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.002132 -0.002432 -0.002719 -0.004503 -0.006941 -0.007556 -0.008033 -0.008382 -0.008561 -0.008560 -0.008386 -0.008063 -0.007555 -0.006950 -0.003219 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001936 -0.002301 -0.002700 -0.004630 -0.007134 -0.008105 -0.009053 -0.009892 -0.010609 -0.011110 -0.011389 -0.011379 -0.011151 -0.010675 -0.010001 -0.009160 -0.008188 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001963 -0.002382 -0.002856 -0.005031 -0.007790 -0.009088 -0.010446 -0.011746 -0.012963 -0.013965 -0.014677 -0.015070 -0.015154 -0.014834 -0.014099 -0.013172 -0.012005 -0.010694 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002349 -0.004274 -0.005214 -0.008108 -0.009755 -0.011524 -0.013368 -0.016752 -0.018580 -0.020121 -0.021263 -0.021890 -0.022014 -0.021496 -0.020413 -0.017354 -0.015669 -0.013817 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002222 -0.002777 -0.005152 -0.006368 -0.009914 -0.012039 -0.016110 -0.018837 -0.021559 -0.024193 -0.026340 -0.027965 -0.028946 -0.029064 -0.029471 -0.028103 -0.026055 -0.023582 -0.020780 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002553 -0.004843 -0.006111 -0.009633 -0.013562 -0.016619 -0.020028 -0.023685 -0.027447 -0.030990 -0.034092 -0.036522 -0.039077 -0.039463 -0.038609 -0.036754 -0.033953 -0.030597 -0.026848 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002238 -0.004346 -0.005577 -0.007114 -0.012918 -0.016214 -0.020064 -0.024436 -0.029320 -0.034408 -0.039246 -0.046038 -0.049732 -0.051665 -0.052448 -0.051287 -0.047324 -0.045043 -0.042290 -0.037540 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001596 -0.003620 -0.004276 -0.006732 -0.008200 -0.013562 -0.016744 -0.020676 -0.023788 -0.029373 -0.035545 -0.043591 -0.051465 -0.057359 -0.062173 -0.066416 -0.068425 -0.067177 -0.065725 -0.061169 -0.053088 -0.048765 -0.001156 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001797 -0.002026 -0.002253 -0.004468 -0.006653 -0.008009 -0.009679 -0.017427 -0.021245 -0.025912 -0.031660 -0.040826 -0.048429 -0.057605 -0.065955 -0.072160 -0.083622 -0.087512 -0.086890 -0.086698 -0.083155 -0.081264 -0.075738 -0.068975 -0.001231 0.000000 0.000000 0.000000 0.000000 -0.001797 -0.002128 -0.003703 -0.004144 -0.004561 -0.008762 -0.013034 -0.014908 -0.018793 -0.023987 -0.028210 -0.033465 -0.043173 -0.052338 -0.064345 -0.073001 -0.085884 -0.094687 -0.103711 -0.108481 -0.110711 -0.109307 -0.106293 -0.100853 -0.094185 -0.086796 -0.001275 0.000000 0.000000 -0.001619 -0.003186 -0.003804 -0.004459 -0.006777 -0.007742 -0.011522 -0.014865 -0.019412 -0.021617 -0.026056 -0.031444 -0.039253 -0.048024 -0.056264 -0.065759 -0.079524 -0.092902 -0.106401 -0.115627 -0.119163 -0.127450 -0.128730 -0.128972 -0.127521 -0.122508 -0.117216 -0.111202 -0.001293 0.000000 -0.002816 -0.003506 -0.004288 -0.005202 -0.009429 -0.012139 -0.015679 -0.017777 -0.021951 -0.026033 -0.030574 -0.039794 -0.044523 -0.051145 -0.060931 -0.070458 -0.082721 -0.096379 -0.112137 -0.124458 -0.133948 -0.146151 -0.148670 -0.151737 -0.152505 -0.152579 -0.152390 -0.148258 -0.140295 -0.001284 -0.002895 -0.003679 -0.004631 -0.007248 -0.010797 -0.014376 -0.020094 -0.023447 -0.026793 -0.032055 -0.038668 -0.047202 -0.052514 -0.059144 -0.068901 -0.076219 -0.090186 -0.103253 -0.117759 -0.131790 -0.143926 -0.155176 -0.167234 -0.176364 -0.178719 -0.183628 -0.189283 -0.187583 -0.178867 -0.169333 -0.002514 -0.003705 -0.006143 -0.010493 -0.014302 -0.017673 -0.023425 -0.028273 -0.033491 -0.038936 -0.047737 -0.057551 -0.066395 -0.075160 -0.082710 -0.092892 -0.105999 -0.117170 -0.132935 -0.149440 -0.163652 -0.177646 -0.190983 -0.202820 -0.211393 -0.217448 -0.221844 -0.222626 -0.219079 -0.209457 -0.199161 -0.004741 -0.006159 -0.009297 -0.015163 -0.019288 -0.026092 -0.032558 -0.040209 -0.048533 -0.058645 -0.071989 -0.083100 -0.091720 -0.102429 -0.118520 -0.131852 -0.141621 -0.155528 -0.165931 -0.180830 -0.197735 -0.213137 -0.228462 -0.245105 -0.256303 -0.267300 -0.268776 -0.259633 -0.235324 -0.179102 -0.117702 -0.009545 -0.009282 -0.015270 -0.019966 -0.027610 -0.035702 -0.045686 -0.057283 -0.072240 -0.084057 -0.097599 -0.112561 -0.127468 -0.140744 -0.155480 -0.169383 -0.184607 -0.203045 -0.216115 -0.233102 -0.246510 -0.263862 -0.283050 -0.301209 -0.315472 -0.317851 -0.310242 -0.254395 -0.023831 0.521927 1.184420 -0.011622 -0.014711 -0.019655 -0.026283 -0.036931 -0.048959 -0.063960 -0.082515 -0.095961 -0.113320 -0.129907 -0.138459 -0.140924 -0.151562 -0.177157 -0.204324 -0.229892 -0.246647 -0.266486 -0.289054 -0.310788 -0.330006 -0.350094 -0.367658 -0.372386 -0.367155 -0.317808 0.014160 1.704276 7.354709 16.044956 -0.016421 -0.019527 -0.025104 -0.035895 -0.049319 -0.066668 -0.089338 -0.107907 -0.124806 -0.130122 -0.085150 0.027118 0.182559 0.252425 0.113351 -0.082631 -0.218250 -0.282185 -0.317612 -0.352783 -0.379362 -0.395977 -0.414140 -0.425958 -0.419885 -0.396580 -0.191606 1.258100 11.337791 68.756805 205.285004 -0.021072 -0.023954 -0.031786 -0.046483 -0.065111 -0.089372 -0.112230 -0.130094 -0.133543 -0.009564 0.486465 1.945333 4.079960 5.027184 3.446999 1.423459 0.244437 -0.146108 -0.274177 -0.352927 -0.423058 -0.459275 -0.473616 -0.473795 -0.428838 -0.296412 0.315153 4.762754 45.236012 430.818024 2335.016602 -0.024502 -0.030250 -0.039811 -0.059284 -0.083862 -0.110667 -0.132178 -0.137141 0.000723 0.852070 4.832553 20.942812 58.139095 78.308311 45.972012 15.153773 3.505376 1.049377 0.435862 -0.006974 -0.326634 -0.473369 -0.510815 -0.454451 -0.253116 0.356125 2.231200 10.795330 89.395752 1124.174683 7645.792480 -0.028127 -0.035927 -0.049043 -0.073890 -0.103123 -0.129901 -0.140384 -0.024392 0.834312 5.520664 34.625004 248.157684 1224.958862 2088.745605 846.948120 147.897247 22.476078 7.758708 4.835324 2.216209 0.369844 -0.302318 -0.419906 -0.215728 0.499929 3.094403 11.294979 32.824486 110.752930 741.665710 3422.170654 -0.031789 -0.042074 -0.060722 -0.088708 -0.118903 -0.141259 -0.081780 0.650031 5.508149 34.986710 223.775146 2954.082520 46324.699219 100017.890625 25647.007813 1434.612427 104.181549 36.903179 26.441677 11.628164 2.965379 0.360760 0.038612 0.576514 2.491222 11.711059 54.285664 165.161255 287.193207 597.881470 1663.423462 -0.035220 -0.046988 -0.070800 -0.102541 -0.132352 -0.133010 0.174532 3.359517 34.935455 370.790527 2646.846436 19723.728516 101085.968750 100152.304688 100064.460938 6627.023437 274.205841 129.860001 101.393257 38.336246 8.969975 1.983327 1.878986 3.187297 6.184305 28.637989 168.261978 740.658752 1113.980713 854.125671 1339.581299 -0.038197 -0.052474 -0.079465 -0.113574 -0.140887 -0.101071 0.759684 11.425584 189.381439 5324.254395 100469.171875 114677.250000 145668.875000 101249.718750 100204.773438 6184.678223 330.286957 235.449142 190.065811 65.570290 14.562567 8.593266 18.801567 26.211374 21.295515 41.276009 246.712402 1138.994019 1812.985840 860.873352 466.019775 -0.039210 -0.058518 -0.087475 -0.119619 -0.143558 -0.047935 1.414203 21.161972 478.112915 36960.121094 100511.125000 102943.492188 134759.671875 100852.296875 19596.851563 1414.381592 209.725952 173.448334 139.316391 53.447926 21.504267 76.968292 370.359589 680.568176 299.516693 72.959869 143.393906 552.680542 792.849976 388.301605 127.460075 -0.042329 -0.061288 -0.094435 -0.119864 -0.141412 0.018555 1.769761 21.231855 406.004181 20165.728516 101569.070313 103575.000000 102582.703125 4989.790039 910.417358 230.848511 78.660278 59.962067 47.216496 26.613293 63.263294 948.642517 16707.210938 54056.636719 10140.308594 545.922363 66.552666 108.385490 137.444092 81.731621 27.836927 -0.041561 -0.062128 -0.093790 -0.121900 -0.128373 0.114285 2.159427 17.271767 149.007156 2057.100342 26187.978516 60949.039063 10494.317383 887.329590 135.673050 49.182747 26.518154 21.775183 21.506874 34.116215 206.811615 6469.992676 100320.164063 100201.218750 100056.031250 2783.420898 86.493576 18.497416 17.719320 11.433897 4.676125 -0.040546 -0.060686 -0.090666 -0.119718 -0.113904 0.182978 2.608208 17.086189 83.818962 321.090881 1099.272095 1786.324463 906.034119 192.334869 41.468727 38.277058 94.025391 138.709808 87.715172 94.098251 484.728424 9003.523437 104690.468750 102266.460938 100352.046875 3077.374512 95.245415 12.560658 4.062133 1.481668 0.276488 -0.040629 -0.059897 -0.085653 -0.115921 -0.114315 0.144831 2.061357 12.981438 53.656395 127.224922 178.956894 190.831741 113.401192 39.768253 46.731197 400.122467 3094.722900 5790.806641 1590.092163 296.707275 1112.095337 13218.694336 60385.761719 81207.601563 12462.849609 895.924377 250.716003 84.568130 18.464188 2.925350 0.215150 -0.041326 -0.060121 -0.080891 -0.111129 -0.127830 0.007929 0.955104 5.858903 20.185888 39.297512 38.869682 27.230303 16.208689 20.939318 194.958893 4700.400391 101227.789063 101238.539063 54419.906250 1279.578613 1176.505249 12353.641602 42846.960938 15894.627930 4059.035156 8214.325195 7881.827148 1436.206787 149.108597 16.042124 3.742016 -0.044621 -0.057482 -0.079129 -0.101577 -0.129167 -0.111681 0.194906 1.410737 4.352484 7.208374 6.939773 4.662655 6.671916 41.796196 548.121765 17957.007813 131132.875000 131141.218750 104007.726563 3119.866943 460.038330 2467.104248 10472.391602 30401.888672 51884.542969 101456.398438 100209.492188 37938.851563 999.071350 63.114246 23.375874 -0.045938 -0.058810 -0.074995 -0.096864 -0.127734 -0.155872 -0.125904 0.065949 0.448353 0.848958 0.970017 2.562798 16.523037 115.397705 1133.252441 23892.343750 200144.484375 200057.625000 71634.757813 1900.759521 180.703644 809.514099 12666.280273 91741.445313 137246.046875 102719.562500 100663.109375 100526.070313 3088.284180 181.915894 127.943451 -0.049757 -0.059465 -0.074305 -0.091241 -0.119152 -0.154535 -0.191280 -0.211217 -0.214816 -0.161898 0.510294 7.033648 68.246315 672.415100 4926.890625 20847.322266 105399.093750 106547.625000 12816.427734 691.398010 88.720467 310.188934 3265.129150 16996.167969 108694.437500 103128.007813 117720.453125 125703.929687 7119.130371 663.170227 502.718140 -0.057216 -0.063229 -0.070580 -0.088653 -0.112558 -0.146228 -0.188557 -0.240888 -0.291055 -0.214581 1.031681 15.523154 229.215927 4322.966309 77655.156250 101685.679688 33541.664063 9182.686523 1612.307861 343.851532 269.214600 169.511963 374.825684 1274.612305 8588.962891 100936.117188 162980.812500 106859.546875 101016.664063 3523.454834 953.602661 -0.063353 -0.067476 -0.074424 -0.088826 -0.109328 -0.141806 -0.182665 -0.226587 -0.286777 -0.196962 1.342156 19.294281 317.979248 7813.092285 100034.656250 100161.789063 63293.101563 2392.468994 984.326660 7708.368652 16735.146484 3331.488281 277.457214 172.017181 1997.574707 101017.929688 101082.351563 101440.398438 103182.992188 8631.644531 879.531799 -0.072370 -0.073603 -0.080605 -0.092396 -0.114495 -0.139231 -0.177154 -0.222561 -0.275085 -0.219676 0.842291 12.355498 165.063370 2648.105225 31140.720703 69894.000000 12469.995117 1369.992676 10038.674805 100994.546875 100366.445313 100067.335938 1815.812988 105.722420 873.746643 37946.757813 100245.445313 101470.671875 104077.750000 5502.775879 732.374756 -0.087986 -0.087400 -0.093344 -0.109467 -0.124478 -0.151531 -0.185299 -0.223368 -0.270825 -0.275097 0.183500 4.350710 38.706253 301.444550 1453.520752 2438.824707 1341.581665 1578.359131 27501.685547 106582.476562 101790.195313 100202.140625 3639.957031 99.992897 172.657562 2104.712158 17676.484375 26312.982422 6812.622070 3110.583252 1206.342896 -0.109937 -0.107128 -0.109989 -0.121755 -0.133942 -0.161880 -0.191935 -0.228981 -0.279508 -0.318942 -0.204319 0.837930 6.712581 31.846460 103.972115 210.912750 368.659698 1434.720459 13062.161133 111131.804687 102654.062500 60755.218750 1213.983276 49.788216 25.630823 128.963013 460.621429 1042.389282 4648.690430 12319.988281 5135.177246 -0.134439 -0.123945 -0.127257 -0.137389 -0.147015 -0.169613 -0.196415 -0.236089 -0.286016 -0.338565 -0.364334 -0.206365 0.716778 4.026259 13.188296 36.710964 106.717056 510.079254 2444.607178 5651.618652 6138.586426 1544.780640 156.842972 15.511937 4.440952 14.720354 74.549118 582.410889 5118.344727 13337.812500 5544.418457 -0.158848 -0.151751 -0.123255 -0.068030 -0.001391 -0.003631 -0.087991 -0.191891 -0.279685 -0.348379 -0.407114 -0.438382 -0.327223 0.175034 1.833857 6.749712 22.930710 94.707397 276.998566 392.727509 270.446991 105.161957 28.484566 6.498794 2.148448 4.055417 26.081879 202.338577 1223.809082 2645.616699 1317.222290 -0.181224 -0.103915 0.180461 0.950304 2.038867 2.416507 1.413706 0.396273 -0.128756 -0.326823 -0.413461 -0.470483 -0.512328 -0.456322 -0.097780 1.183497 5.344653 18.606319 46.502659 74.016739 66.629524 38.922234 19.764540 14.440323 9.693065 5.205916 7.905102 38.340557 135.903946 227.487473 144.895813 -0.162434 0.310274 2.694125 12.546105 32.371490 38.971313 21.429890 5.789088 1.015653 -0.134479 -0.399867 -0.487748 -0.536510 -0.549303 -0.343416 0.571951 3.412003 12.420644 39.273792 80.642426 83.441399 51.437222 56.111538 84.845589 61.225357 22.751720 6.255381 6.140708 14.474586 20.280313 15.167659 0.001639 2.237383 21.232744 171.896255 785.309937 1072.731934 374.351807 58.279388 7.308638 0.843669 -0.216347 -0.470935 -0.552345 -0.559460 -0.336346 0.604364 3.351588 11.778113 38.223434 85.633957 87.213577 81.388481 209.195023 418.259308 296.701660 82.762054 15.311296 3.645510 2.696400 3.002052 5.310767 0.405910 8.345123 122.791801 2419.418213 36870.699219 70578.664063 9191.075195 479.855774 34.488739 4.350511 0.468994 -0.339379 -0.542281 -0.585587 -0.429301 0.212734 2.005760 6.932096 20.670324 40.860664 50.672878 97.218903 395.194946 909.754211 590.626099 146.766342 29.138857 14.499187 11.673860 8.898414 22.470020 0.856013 15.840133 347.273254 16330.935547 100043.500000 100155.414063 100245.046875 1883.098145 105.501968 14.134028 2.438494 0.020454 -0.508536 -0.611168 -0.569128 -0.299937 0.440235 2.279097 6.318894 12.719542 21.663103 66.615471 263.935699 551.549805 391.095428 116.902344 60.116264 96.003899 89.847961 50.659412 125.592346 0.762771 15.167651 325.438538 13453.456055 100217.375000 101227.835938 101410.015625 2741.693115 266.983795 35.082142 5.557970 0.498627 -0.459892 -0.630630 -0.650516 -0.602322 -0.397554 0.138626 1.507113 4.288380 9.803781 26.601328 77.232780 138.176437 105.135216 70.168686 207.050674 552.243530 518.924194 201.304306 501.341187 0.251112 7.716680 107.485680 1794.881592 20465.818359 41254.636719 16011.640625 4338.644531 551.364868 56.566296 7.696983 0.740861 -0.430985 -0.641384 -0.679390 -0.708005 -0.684934 -0.481835 0.211248 2.050476 5.396957 10.425832 17.759293 23.615633 25.600365 76.513954 449.053314 1424.524902 1334.020508 438.012787 855.928772 -0.158346 3.091395 31.398874 246.233170 1524.745728 5514.912598 8901.070312 3302.040039 447.883759 48.501274 6.212687 0.499408 -0.477458 -0.653382 -0.701735 -0.748322 -0.774321 -0.656262 -0.086505 1.666397 5.318406 9.251595 10.341137 8.222901 11.326390 56.463505 342.828552 1064.695068 1018.935547 402.525391 556.555420 -0.314269 2.510384 31.413944 399.971283 5446.416992 22681.017578 10413.870117 1434.553589 194.717056 27.428711 4.678073 0.638162 -0.286926 -0.586092 -0.714946 -0.790298 -0.815080 -0.713901 -0.096414 2.220752 8.079029 15.886153 17.738850 12.505545 9.324430 24.715612 106.321823 266.717072 288.861816 229.753632 287.467377 -0.188665 2.467947 37.630913 586.569031 11112.209961 56717.406250 22195.642578 1516.193115 168.209030 44.271992 14.817377 5.389331 1.913571 0.178875 -0.558433 -0.786747 -0.825553 -0.698447 -0.052572 2.483016 10.331875 25.831106 41.508175 42.643330 24.486031 15.332690 28.075243 61.624714 89.143974 101.176849 112.934181 1.869616 2.872058 22.363161 266.275208 2897.545898 10216.800781 5259.719727 1507.791138 1241.556519 481.592621 123.751480 52.011513 20.476471 5.211462 0.462245 -0.426228 -0.210224 0.274158 0.802418 3.183096 14.654066 56.567261 149.661697 178.466446 107.250275 44.971428 19.970053 20.869041 29.825521 31.195335 31.744480 29.341305 17.518198 11.794413 55.419033 298.825104 944.651672 3438.332031 28652.050781 63023.667969 11303.177734 1212.174438 564.572388 179.752502 34.180836 4.918873 2.305448 7.794524 16.369104 15.184564 10.052792 22.608322 110.598824 373.941833 592.365906 601.675049 312.981995 86.065216 19.604736 10.856286 11.208155 16.645681 460.206421 190.780426 35.696182 17.617378 80.033859 729.774597 21507.210938 100264.757813 100203.421875 101148.789063 9683.740234 6165.653809 1325.459595 145.854370 17.317669 22.913761 138.135162 434.682098 377.858765 112.234238 37.950684 121.557693 557.467102 2574.958496 6705.376953 3138.283691 487.638916 54.398380 14.371614 18.109180 29.843464 6279.431641 1656.309204 155.607376 17.470171 46.430538 681.969482 28316.300781 100090.687500 100287.773438 103373.953125 29943.976563 28378.007813 3976.249756 299.501953 38.026230 187.560638 3342.487549 31327.697266 25391.816406 2044.958740 147.416794 107.553322 934.636353 11220.745117 41913.292969 16033.855469 1553.017944 121.062332 31.625607 48.909889 65.123016 20502.458984 4344.204102 276.539490 20.982824 21.064859 237.065079 4696.852539 77514.710938 100207.726563 25557.943359 15739.870117 16084.148438 2657.218262 233.999847 57.227982 967.744812 76318.578125 101430.031250 102651.320313 32363.902344 646.629028 105.112686 754.196960 8547.478516 31151.060547 13381.985352 1284.746704 129.907364 45.505516 77.699181 95.437531 5756.570312 1546.319458 153.190903 14.728269 6.784798 44.530212 366.975464 1798.144653 2713.562256 1442.390381 1829.428711 1700.561890 498.154449 83.843147 57.550610 1299.169922 101545.429688 117576.929687 146301.390625 65193.859375 1577.046631 131.108200 231.815308 1435.565552 3411.243896 1886.625854 425.002838 90.692551 39.289433 59.635971 72.821991 544.588135 272.336609 71.109116 13.427017 3.073717 7.467127 33.791248 92.794907 142.567444 173.920135 244.458191 207.128632 92.558983 30.516752 38.485199 527.476807 14052.541016 151249.671875 200151.187500 37333.566406 2448.260010 367.838867 100.422714 146.809875 263.503021 233.434692 126.568405 52.824142 28.036217 39.676319 69.709747 2002.661987 1834.478638 462.966644 65.119293 8.138392 6.447627 26.190346 68.982430 136.195709 319.249939 450.372314 328.573425 195.700348 79.666107 31.638193 146.176788 1728.153564 15104.179688 37028.242188 17802.980469 12665.409180 2983.397705 367.751831 57.375797 35.935528 43.957157 40.957058 31.808252 27.764339 57.387421 251.849319 100074.023438 100053.226563 7827.888672 393.922363 27.923088 15.696584 75.902031 228.150986 335.536407 694.434998 1204.582397 1918.537354 2518.688232 805.014465 109.790794 46.038017 260.940033 1438.799072 7705.314941 79878.703125 134461.937500 25514.841797 1878.689697 143.437881 19.722139 12.604002 21.040657 32.157848 35.330711 98.843102 802.637024 100210.875000 100118.843750 77522.671875 1325.344116 57.868309 20.876123 111.842278 336.973663 420.771881 638.186157 2047.786011 16850.970703 33417.421875 5851.198242 392.677307 41.392540 60.493149 501.472107 9090.677734 156797.062500 195903.437500 112324.187500 8027.240723 391.887604 42.527668 9.734725 13.406651 23.699930 27.936840 95.138412 852.547729 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002031 -0.002301 -0.002571 -0.002796 -0.006346 -0.006886 -0.007305 -0.007610 -0.007769 -0.007756 -0.007588 -0.007270 -0.006833 -0.004913 -0.002856 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001883 -0.002238 -0.002607 -0.004388 -0.004972 -0.007567 -0.008423 -0.009188 -0.009819 -0.010259 -0.010497 -0.010467 -0.010248 -0.009772 -0.009160 -0.008384 -0.007532 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002365 -0.002836 -0.004869 -0.005712 -0.008717 -0.009985 -0.011185 -0.012295 -0.013219 -0.013825 -0.014164 -0.014216 -0.013845 -0.013211 -0.012307 -0.011187 -0.009961 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002382 -0.002937 -0.005192 -0.006231 -0.009585 -0.011288 -0.013024 -0.014778 -0.018041 -0.019396 -0.020454 -0.021013 -0.021068 -0.020489 -0.017936 -0.016557 -0.014940 -0.013248 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001819 -0.002301 -0.002896 -0.005230 -0.006462 -0.010037 -0.012160 -0.014579 -0.018802 -0.021518 -0.024065 -0.026132 -0.027774 -0.028590 -0.028572 -0.027891 -0.026410 -0.024297 -0.021799 -0.017502 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002132 -0.002719 -0.005057 -0.006369 -0.009959 -0.012459 -0.017163 -0.020665 -0.024455 -0.028251 -0.031902 -0.035130 -0.037432 -0.038691 -0.038852 -0.038897 -0.036810 -0.033886 -0.030428 -0.026476 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001883 -0.002449 -0.004632 -0.005979 -0.007638 -0.013665 -0.017188 -0.021427 -0.026225 -0.031384 -0.036756 -0.042110 -0.048010 -0.052469 -0.054563 -0.054919 -0.053440 -0.049103 -0.045023 -0.041784 -0.036556 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.002757 -0.005327 -0.006953 -0.012644 -0.016338 -0.020819 -0.026307 -0.032672 -0.041082 -0.048773 -0.055942 -0.063241 -0.068374 -0.072439 -0.072403 -0.069988 -0.069027 -0.063835 -0.057943 -0.048623 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001607 -0.004052 -0.006380 -0.007895 -0.009831 -0.016532 -0.020897 -0.026470 -0.031647 -0.041427 -0.050664 -0.061334 -0.071762 -0.081059 -0.088530 -0.092532 -0.091266 -0.089535 -0.087165 -0.081232 -0.075147 -0.067293 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001810 -0.002040 -0.004139 -0.004937 -0.007570 -0.009332 -0.018466 -0.022657 -0.027970 -0.034485 -0.044229 -0.054351 -0.067126 -0.079372 -0.092725 -0.101629 -0.109105 -0.112461 -0.112197 -0.109244 -0.106979 -0.100092 -0.093109 -0.085593 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001823 -0.002159 -0.003704 -0.004167 -0.008181 -0.009344 -0.014243 -0.018260 -0.023472 -0.028222 -0.035372 -0.045344 -0.055576 -0.070256 -0.085878 -0.099993 -0.111222 -0.119652 -0.126342 -0.130487 -0.130725 -0.130338 -0.127101 -0.125163 -0.117915 -0.107628 0.000000 0.000000 0.000000 -0.001630 -0.003183 -0.003802 -0.004480 -0.006882 -0.007868 -0.012550 -0.015857 -0.019525 -0.022967 -0.029825 -0.038300 -0.047035 -0.057824 -0.072315 -0.086287 -0.104339 -0.120767 -0.132294 -0.141380 -0.144161 -0.147852 -0.150487 -0.148507 -0.145215 -0.144628 -0.144234 -0.134535 -0.001124 0.000000 -0.002812 -0.003501 -0.004303 -0.006784 -0.009442 -0.011069 -0.015797 -0.019914 -0.024213 -0.029024 -0.036918 -0.043969 -0.053048 -0.061366 -0.074426 -0.087435 -0.106177 -0.124934 -0.138064 -0.152373 -0.163143 -0.167389 -0.171406 -0.173089 -0.172806 -0.168054 -0.169722 -0.172815 -0.168147 0.000000 -0.002890 -0.003673 -0.004624 -0.008824 -0.010824 -0.014261 -0.018967 -0.023403 -0.028906 -0.035780 -0.043603 -0.049339 -0.058445 -0.067417 -0.079204 -0.090424 -0.109397 -0.131780 -0.147592 -0.164110 -0.176703 -0.186143 -0.193176 -0.199883 -0.203538 -0.206176 -0.208062 -0.206730 -0.206347 -0.200969 -0.002842 -0.003697 -0.006053 -0.009361 -0.013012 -0.017423 -0.023262 -0.028156 -0.033552 -0.042510 -0.052793 -0.061757 -0.070256 -0.080587 -0.094609 -0.104665 -0.119283 -0.138195 -0.158979 -0.176500 -0.198264 -0.213610 -0.224961 -0.231409 -0.243264 -0.252471 -0.253006 -0.251060 -0.250060 -0.244672 -0.229084 -0.005904 -0.006044 -0.010675 -0.014840 -0.018910 -0.025716 -0.032329 -0.039990 -0.049942 -0.060709 -0.075811 -0.088841 -0.099128 -0.113222 -0.128217 -0.143544 -0.163014 -0.181753 -0.200209 -0.222663 -0.241731 -0.262442 -0.278336 -0.285147 -0.299699 -0.311207 -0.312039 -0.300761 -0.250700 -0.138627 -0.024109 -0.008459 -0.009021 -0.014938 -0.019473 -0.027139 -0.035203 -0.045158 -0.058190 -0.072637 -0.086923 -0.101587 -0.115865 -0.131046 -0.150649 -0.168506 -0.184729 -0.206164 -0.230232 -0.254232 -0.277439 -0.299830 -0.320971 -0.340853 -0.360539 -0.368756 -0.368850 -0.353648 -0.234992 0.270215 1.572498 3.354464 -0.012934 -0.014398 -0.019100 -0.025538 -0.036070 -0.047988 -0.062846 -0.082224 -0.098087 -0.114248 -0.128712 -0.137466 -0.136225 -0.150248 -0.175963 -0.214297 -0.247366 -0.277678 -0.306874 -0.339695 -0.365992 -0.392207 -0.415263 -0.431806 -0.432269 -0.421254 -0.314987 0.463002 4.798054 24.603262 59.942398 -0.015378 -0.019154 -0.024311 -0.034992 -0.047917 -0.064933 -0.087931 -0.105916 -0.125511 -0.124096 -0.068941 0.075759 0.267342 0.325187 0.182996 -0.057806 -0.210276 -0.288957 -0.336734 -0.386384 -0.429596 -0.455430 -0.473052 -0.484534 -0.458387 -0.388383 0.053241 3.743192 41.203606 396.813416 1802.089966 -0.021012 -0.024479 -0.030596 -0.044820 -0.062915 -0.088874 -0.109449 -0.128383 -0.125774 0.015455 0.625818 2.280898 5.062171 6.262760 4.349564 1.812943 0.520300 0.108608 -0.064786 -0.247469 -0.400863 -0.485404 -0.503387 -0.459020 -0.298997 0.111929 1.547840 14.075540 225.647339 5731.808105 100032.617188 -0.024297 -0.029375 -0.038031 -0.056761 -0.080340 -0.107890 -0.128784 -0.136558 0.014304 0.951872 5.848821 26.082500 78.480286 106.679588 62.409084 19.975016 6.087535 3.582179 2.683048 1.185585 0.104829 -0.313375 -0.347059 -0.063189 0.792286 2.875540 8.407860 35.912128 505.582642 25428.835938 100481.890625 -0.027676 -0.034634 -0.048126 -0.070054 -0.099393 -0.125800 -0.141380 -0.036645 0.756438 5.876856 43.539791 343.323822 2090.304932 3657.961670 1428.801758 225.533432 44.530663 34.254349 27.607327 12.386574 3.342512 0.662359 0.617581 1.735440 5.043686 15.864932 52.115200 163.453903 616.319397 10226.825195 109332.031250 -0.030924 -0.040088 -0.058281 -0.083629 -0.116133 -0.139737 -0.101727 0.459297 4.264904 29.190165 267.306274 5141.801270 100038.031250 100046.820313 62961.605469 2538.194824 276.482086 332.433411 279.667664 88.517105 17.897888 4.099395 4.007017 8.031985 16.838463 62.646736 390.553955 1982.433594 3645.396973 10370.984375 89934.031250 -0.034025 -0.045308 -0.066804 -0.100338 -0.132802 -0.140177 0.083713 2.393430 22.336426 201.436615 1530.304565 39252.207031 100516.312500 100348.257813 100752.640625 14068.173828 1317.534790 2688.140381 2262.485596 480.058716 63.134804 11.357718 13.172662 25.630804 41.013252 179.289795 2296.073975 25688.492188 57186.367188 18969.572266 78411.007813 -0.036474 -0.050737 -0.075746 -0.109896 -0.141328 -0.122572 0.454223 7.048762 103.506165 1915.230225 30558.046875 108471.585937 110236.218750 101725.843750 104732.617188 16034.194336 3095.821777 8614.756836 6579.202637 1137.339600 110.051460 19.813768 29.438499 56.533108 69.191246 249.753601 3995.232666 69802.710938 100161.984375 27061.601563 8519.230469 -0.040246 -0.054706 -0.082679 -0.118861 -0.146379 -0.102658 0.812877 12.475401 230.119919 8373.754883 100231.296875 104369.703125 184377.125000 103398.359375 54165.027344 8118.001953 2395.013428 4789.640137 3666.848633 737.330750 86.940506 40.637302 109.784058 182.991196 120.242126 151.951279 1548.019043 14606.812500 31144.796875 7306.667480 999.260925 -0.040232 -0.056966 -0.088705 -0.122287 -0.147499 -0.100066 0.780858 11.046047 189.505035 5311.530762 100106.039063 100396.640625 42685.156250 4509.900879 3453.389893 2018.203857 698.662048 739.888489 601.746765 173.692642 52.750221 189.843796 1301.822510 2789.866699 1027.972290 155.980148 243.201019 1056.206055 1658.753052 647.733459 143.551926 -0.040356 -0.057385 -0.091290 -0.121773 -0.148774 -0.109398 0.540738 6.105300 59.833698 700.631897 5865.450684 11225.744141 2802.201904 449.175018 337.851013 258.795502 121.838341 94.104179 70.226189 38.822193 66.190147 762.720276 10172.798828 31256.207031 6911.198242 437.839142 51.545193 72.145546 88.905426 52.703926 17.671354 -0.038420 -0.058302 -0.088787 -0.123233 -0.147912 -0.117240 0.335002 2.870780 15.417328 74.666008 255.031174 363.147766 181.531036 62.315701 42.722069 56.481533 113.074234 157.640671 83.849518 39.216854 92.640686 874.152405 11393.357422 34920.085938 6950.751465 453.176208 44.814880 14.789597 9.178210 4.791811 1.740281 -0.036331 -0.056452 -0.086041 -0.119018 -0.145520 -0.128621 0.149997 1.487170 5.428256 14.140709 26.824480 31.265068 21.675961 12.954729 39.255836 437.984985 3634.701172 7602.369141 1816.318970 193.423996 125.319580 565.736206 2221.971924 3473.743652 1334.397461 374.535156 206.338272 77.940117 17.972486 3.055406 0.094809 -0.041014 -0.059876 -0.081474 -0.112668 -0.142939 -0.150694 -0.027770 0.500043 1.875095 3.729351 4.854698 4.660195 3.953363 11.610313 169.080292 5776.633301 100145.921875 100138.398438 76096.609375 1433.575928 147.695740 423.554871 898.336365 1001.541382 2025.626587 5351.066406 4690.793945 1052.877319 125.430374 14.065336 1.555690 -0.044997 -0.058092 -0.077757 -0.101566 -0.135024 -0.168871 -0.152335 -0.020746 0.312414 0.651216 0.724324 0.707146 2.388648 20.469162 328.763062 20807.646484 101056.406250 100980.875000 100301.617188 3678.944092 145.764343 250.977219 701.980225 2565.484863 26299.162109 108639.710937 102129.765625 17800.187500 715.565002 46.337200 6.415919 -0.046203 -0.055857 -0.072676 -0.096293 -0.126731 -0.169458 -0.200425 -0.213981 -0.198441 -0.196423 -0.146078 0.572362 5.394335 34.223000 294.313354 6551.437988 103395.390625 103114.757813 86121.039063 1503.093506 113.825432 287.408783 1070.810913 5009.395508 114067.210937 117794.429687 103923.507813 100624.710938 1947.524658 107.834015 19.992304 -0.049914 -0.058645 -0.069645 -0.090794 -0.118935 -0.159674 -0.202126 -0.250235 -0.306310 -0.333156 -0.093663 2.102377 17.535179 105.853378 433.967255 1506.321411 6428.430664 10649.634766 2561.238525 269.277893 80.462059 316.422150 1036.762451 2972.108398 61199.128906 106315.601563 108597.039062 67067.046875 3694.363281 318.782043 54.990620 -0.055652 -0.062671 -0.071361 -0.088002 -0.111276 -0.148897 -0.188256 -0.243406 -0.303025 -0.310685 0.167633 4.566860 43.523895 344.919525 1691.070190 2839.214844 1560.095581 751.952393 270.229065 130.746429 144.458405 192.814499 375.399475 716.587769 4974.111328 43367.691406 128442.929687 103718.187500 46604.910156 1600.731079 119.162659 -0.063231 -0.066990 -0.073816 -0.087385 -0.107999 -0.136407 -0.181677 -0.231160 -0.285255 -0.282454 0.275474 5.672554 54.496300 480.018585 2872.994629 4713.303223 1603.813599 295.302521 318.810730 1824.600830 3324.446289 961.479919 170.414413 152.761719 1183.501709 46964.187500 100674.992188 100280.179688 100142.765625 3200.627197 163.992920 -0.072439 -0.073217 -0.082909 -0.089137 -0.112836 -0.139569 -0.175316 -0.220717 -0.275799 -0.286106 0.114530 3.836146 32.165920 243.845718 1056.139526 1666.319580 663.105408 233.594879 2211.956787 48392.960938 100034.859375 16695.927734 591.325134 71.784683 503.574982 13360.176758 100053.132813 100086.554688 46417.617188 1532.458984 127.869598 -0.088802 -0.087830 -0.095544 -0.102207 -0.118950 -0.147387 -0.178437 -0.219959 -0.263983 -0.304096 -0.139767 1.312889 10.484793 54.982445 168.179123 225.705536 148.758057 235.511429 4500.550781 100190.671875 100089.523438 48349.171875 1098.523437 52.536201 110.874565 1139.199951 7175.848633 10224.378906 2565.969482 389.829681 107.394516 -0.107011 -0.106740 -0.111657 -0.117943 -0.132327 -0.153905 -0.184853 -0.222658 -0.270656 -0.319461 -0.300140 0.079683 2.054619 8.387431 21.790646 32.181618 44.492573 151.953751 1604.747437 25490.443359 67893.773438 9219.610352 431.261902 26.078920 17.421389 80.056465 254.655746 330.941254 308.332367 319.420532 186.673630 -0.124882 -0.120505 -0.126513 -0.141497 -0.152383 -0.170390 -0.195634 -0.235469 -0.280627 -0.334197 -0.375305 -0.335334 -0.037648 0.984591 3.077526 6.697931 16.290930 59.153992 246.323059 980.125671 1462.296631 476.967041 67.757187 7.776744 2.738208 8.191583 22.809065 63.181404 188.184845 302.897186 190.192886 -0.149794 -0.146139 -0.136691 -0.115298 -0.086673 -0.093558 -0.144500 -0.221805 -0.287823 -0.342880 -0.396708 -0.438940 -0.437663 -0.292008 0.163509 1.326934 4.799914 15.232850 40.302498 69.518867 68.944069 34.965031 12.653414 6.629391 4.516260 3.100876 6.339615 24.479254 74.826851 121.506325 80.120316 -0.175717 -0.136824 0.010429 0.362078 0.880711 0.983791 0.561427 0.067235 -0.216070 -0.339684 -0.404649 -0.461738 -0.508866 -0.523408 -0.430503 -0.074453 0.983632 3.432867 7.804446 11.461369 12.426419 16.965317 38.091946 65.178413 47.971508 18.162317 5.866634 7.140962 17.620811 26.678539 20.853100 -0.177131 0.061138 1.184850 4.752259 11.172159 13.302326 7.949043 2.401707 0.296850 -0.259766 -0.408671 -0.468429 -0.520745 -0.569997 -0.568071 -0.425514 0.038556 1.249707 3.836316 7.668592 17.830252 82.066078 418.114624 908.539307 633.153259 154.011078 22.850597 3.965553 3.210216 4.839840 5.929634 -0.106140 0.958305 7.900962 43.929043 150.056107 184.283554 83.236130 18.211346 2.871537 0.118921 -0.363474 -0.479803 -0.531828 -0.579472 -0.601709 -0.509534 -0.146304 0.953031 3.809247 10.264688 42.882282 396.004089 3655.817139 13321.457031 7158.168457 977.117676 82.594284 7.696505 1.143146 1.497393 6.142686 0.075072 3.332394 34.348331 322.469849 1884.475342 2867.680908 851.559937 103.803307 10.887735 1.220761 -0.201243 -0.471562 -0.548029 -0.592114 -0.614069 -0.564557 -0.288454 0.688360 3.957681 14.610956 75.327248 864.300476 12177.115234 62885.433594 28230.097656 2256.754639 155.200897 13.377447 2.805939 3.613357 20.858101 0.245854 6.238276 82.918411 1160.802979 12197.977539 22031.654297 3735.124512 297.175507 25.883642 3.443722 0.181079 -0.431937 -0.565173 -0.609237 -0.636741 -0.621279 -0.407521 0.577654 4.865885 21.188225 83.921104 600.978638 6058.918457 25642.810547 13322.706055 1421.621338 110.989906 18.390678 10.558251 13.660735 99.790916 0.166655 5.925193 78.277115 1076.232788 11101.867188 18090.458984 3509.396484 313.020508 41.569920 6.543817 0.710546 -0.356846 -0.584772 -0.635121 -0.656188 -0.656376 -0.495176 0.479785 5.467166 24.048912 74.740517 202.345123 828.397339 2100.642334 1320.587280 282.830048 52.041779 35.780865 32.918137 36.854324 424.954773 -0.107760 2.904608 30.306654 270.874359 1410.980103 2203.437012 878.040833 227.316620 51.018356 8.831065 1.063015 -0.316271 -0.599389 -0.664398 -0.683786 -0.687789 -0.566902 0.242845 4.323370 18.582638 50.347797 86.644089 120.607048 146.589401 106.090981 43.030975 38.325817 67.268341 72.849541 67.861877 705.911865 -0.356937 0.994766 9.711508 52.736526 186.854553 353.711823 324.946777 163.194138 43.371185 7.885332 0.959241 -0.369356 -0.625840 -0.699863 -0.728719 -0.741405 -0.653138 -0.000135 3.342294 17.235300 58.516270 116.859062 110.207466 52.851822 20.290375 15.263186 44.175072 130.524567 212.796280 145.901352 350.818329 -0.469521 0.473247 6.813390 46.413795 222.287354 490.322235 338.330780 115.194954 28.386967 6.339118 1.054027 -0.206513 -0.558431 -0.699496 -0.759949 -0.778606 -0.714676 -0.101697 3.611154 22.827627 102.445374 247.095016 231.313354 85.865639 20.761629 14.155930 72.688843 388.749725 880.931213 483.243500 156.988159 -0.158639 0.556435 6.922207 54.962257 286.684235 691.260681 428.527313 119.729851 36.712322 15.413471 5.198597 1.599997 0.200025 -0.450859 -0.713521 -0.792418 -0.732512 -0.221475 3.026220 21.657328 94.441811 229.956589 217.209396 82.671982 21.283579 15.397526 82.133835 509.485199 1199.069458 637.236145 127.549316 5.150545 3.646860 5.433501 30.126949 146.339417 301.989441 255.732910 237.685181 243.601303 120.031746 36.533222 12.553657 4.563789 0.969335 -0.347929 -0.572479 -0.290733 0.318395 2.134573 10.916112 42.088959 93.472046 89.769112 50.025620 22.920849 17.344244 47.865330 192.307602 408.206787 230.042267 65.030258 109.294449 56.320095 14.385826 11.971889 39.339142 111.863510 475.336487 2118.746582 3383.839600 1159.256470 213.554779 66.669014 26.034338 6.645439 1.067873 1.330759 4.962463 9.582540 9.901606 8.254308 14.111006 28.724894 44.105526 57.721596 59.862057 42.667736 30.602592 47.041065 72.838730 62.706440 65.339066 4339.234863 1290.686401 126.776855 14.192150 19.632135 144.815063 1808.703369 16022.181641 31138.589844 6657.481934 778.190857 283.757050 97.140030 20.786030 5.388985 14.420064 64.949364 157.184418 151.721237 57.751362 18.107937 18.768904 53.976707 154.197327 270.508179 170.692841 59.947777 32.370251 72.069908 179.274994 259.593018 100042.828125 34798.828125 936.624512 41.228489 16.721228 150.686630 2094.821777 21194.591797 41886.816406 8686.562500 1146.959473 558.789612 191.489807 35.544571 15.615734 95.929756 848.823303 3954.610352 3527.104736 746.175781 105.604263 28.815857 82.769844 347.820374 686.214294 421.272675 114.912964 56.629147 236.653900 920.157227 1285.579712 100260.921875 100120.882813 2162.320312 65.529221 11.285047 66.799309 636.293274 3970.753418 6055.770508 2067.131104 592.285461 414.465881 148.264694 32.031048 33.875507 380.916534 7477.290039 95750.335938 83872.046875 10208.451172 798.334412 75.766678 73.982483 300.556335 594.116882 369.179443 105.871803 76.205200 426.208557 2100.264648 2687.226562 100857.320313 31575.314453 924.506409 48.685982 5.972250 16.988684 94.545486 320.308868 429.519226 248.321609 152.826904 123.094009 51.590965 16.783762 49.754925 728.662048 20590.285156 200379.312500 200182.109375 105315.085938 5379.514648 238.509064 52.928860 104.595924 179.788574 127.837822 53.044376 58.428543 281.634308 1177.855591 1489.974487 5018.118164 1651.550293 234.711639 32.192589 4.602880 3.264674 12.024710 28.596914 40.713535 39.555702 38.243790 32.383415 17.373409 9.718556 44.678867 717.570862 30049.982422 111444.843750 109735.234375 103208.007813 13851.069336 1139.544189 146.675674 35.966984 35.888725 33.700008 38.637531 67.621964 152.302490 392.991486 609.401001 3680.187988 2905.551514 670.814514 93.653893 10.839262 1.899291 3.807306 10.387320 23.075787 44.680275 59.519810 52.680241 34.417450 17.382488 28.146290 335.340759 8717.495117 100843.914063 108225.031250 200184.531250 104125.335938 21440.294922 1020.122314 65.572441 13.695054 28.074806 115.670555 293.883850 296.528229 482.297028 2081.277832 101591.859375 101011.898438 12376.300781 543.996826 34.339130 4.004722 6.588789 20.126932 57.077232 156.253983 232.745834 227.098007 179.008865 81.082687 30.258383 84.339005 796.679871 7208.613770 83259.703125 105102.343750 102136.546875 100953.375000 3848.407227 148.640213 17.243610 45.514687 296.296570 806.589355 621.942993 701.198975 11413.007813 101887.906250 101105.851563 100228.593750 1818.152588 69.231682 6.141493 8.773603 30.776903 116.670235 433.838074 769.540527 882.922241 745.861511 313.772247 109.728249 60.886105 119.607063 1300.260986 57490.210938 104135.195313 112227.429687 105142.453125 4052.252930 199.963913 25.330013 38.590107 220.645889 585.822693 442.591553 597.056824 13410.069336 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002088 -0.002415 -0.002777 -0.004496 -0.006781 -0.007496 -0.008159 -0.008670 -0.009048 -0.009219 -0.009180 -0.008972 -0.008586 -0.008042 -0.007357 -0.006630 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002253 -0.002681 -0.003152 -0.005235 -0.007932 -0.009037 -0.010137 -0.011080 -0.011860 -0.012391 -0.012667 -0.012639 -0.012298 -0.011738 -0.010926 -0.009965 -0.008904 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001870 -0.002317 -0.002836 -0.004902 -0.005861 -0.008960 -0.010515 -0.012083 -0.013651 -0.015077 -0.016212 -0.017043 -0.017491 -0.017433 -0.017007 -0.016113 -0.014971 -0.013556 -0.011972 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002285 -0.002876 -0.005079 -0.006257 -0.009631 -0.011649 -0.013835 -0.017774 -0.020261 -0.022492 -0.024366 -0.025687 -0.026371 -0.026349 -0.025579 -0.024240 -0.022312 -0.018426 -0.016165 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002162 -0.002777 -0.005008 -0.006335 -0.009831 -0.012265 -0.016750 -0.020113 -0.023800 -0.027352 -0.030737 -0.033627 -0.035734 -0.036840 -0.036762 -0.035698 -0.033642 -0.030746 -0.027411 -0.023718 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002536 -0.004717 -0.006091 -0.007804 -0.012236 -0.017330 -0.021529 -0.026282 -0.031583 -0.036826 -0.041781 -0.047655 -0.050811 -0.052593 -0.052592 -0.052019 -0.047606 -0.043497 -0.038602 -0.034969 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002238 -0.002937 -0.005556 -0.007276 -0.011505 -0.016867 -0.021683 -0.027407 -0.033922 -0.042749 -0.050290 -0.057538 -0.063847 -0.069538 -0.074565 -0.074372 -0.071849 -0.067239 -0.063221 -0.056739 -0.048555 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002518 -0.004848 -0.006450 -0.008533 -0.015557 -0.020468 -0.026604 -0.035639 -0.044586 -0.054527 -0.064268 -0.073491 -0.084936 -0.090724 -0.092614 -0.091061 -0.088589 -0.085601 -0.078856 -0.071773 -0.066739 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003659 -0.004488 -0.007268 -0.009150 -0.015511 -0.020056 -0.026012 -0.035232 -0.043415 -0.055839 -0.067963 -0.080041 -0.091478 -0.100891 -0.104064 -0.107901 -0.111104 -0.107084 -0.104379 -0.099504 -0.092606 -0.085112 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001785 -0.002011 -0.004459 -0.006857 -0.008539 -0.014082 -0.021342 -0.026966 -0.036712 -0.046518 -0.056971 -0.071690 -0.089134 -0.100333 -0.109327 -0.119882 -0.121590 -0.125434 -0.124213 -0.118053 -0.114701 -0.113950 -0.111207 -0.105059 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001797 -0.002113 -0.003627 -0.004061 -0.008528 -0.011446 -0.015413 -0.020296 -0.026774 -0.035671 -0.046099 -0.056730 -0.074525 -0.092472 -0.105903 -0.118718 -0.129186 -0.132650 -0.134135 -0.128592 -0.116722 -0.097724 -0.087346 -0.098498 -0.116292 -0.125050 0.000000 0.000000 0.000000 -0.001607 -0.003115 -0.003721 -0.004385 -0.006821 -0.007816 -0.012919 -0.016656 -0.021258 -0.026132 -0.036442 -0.045805 -0.057436 -0.073697 -0.090067 -0.107473 -0.122995 -0.140030 -0.147033 -0.141963 -0.125724 -0.101872 -0.066996 -0.030873 -0.014009 -0.050051 -0.107510 -0.141859 0.000000 0.000000 -0.001664 -0.003424 -0.004179 -0.006737 -0.008077 -0.010860 -0.014467 -0.020012 -0.024663 -0.032649 -0.039341 -0.049577 -0.059775 -0.074132 -0.088044 -0.108684 -0.128725 -0.144650 -0.158963 -0.160112 -0.137518 -0.097535 -0.050772 -0.000767 0.042870 0.050746 -0.013990 -0.105075 -0.165651 0.000000 -0.002825 -0.003591 -0.004519 -0.008613 -0.010570 -0.014397 -0.018527 -0.021866 -0.027606 -0.036034 -0.045095 -0.053683 -0.064538 -0.077349 -0.090659 -0.107939 -0.135347 -0.155724 -0.173586 -0.186742 -0.180025 -0.139809 -0.072550 -0.017726 0.017126 0.044107 0.028743 -0.045713 -0.139221 -0.202422 -0.002353 -0.003601 -0.004640 -0.009129 -0.011522 -0.016752 -0.022521 -0.027287 -0.032539 -0.041965 -0.054738 -0.065024 -0.074906 -0.090469 -0.102910 -0.118078 -0.141108 -0.165141 -0.189900 -0.205913 -0.221358 -0.214303 -0.176169 -0.112107 -0.069413 -0.063776 -0.070908 -0.100730 -0.162798 -0.216951 -0.245475 -0.005980 -0.005805 -0.009235 -0.013222 -0.018123 -0.024775 -0.031085 -0.038554 -0.048496 -0.064182 -0.077846 -0.090713 -0.102946 -0.120792 -0.136730 -0.157660 -0.182450 -0.210897 -0.240923 -0.261962 -0.282784 -0.286516 -0.266347 -0.236245 -0.212880 -0.221286 -0.241689 -0.250651 -0.223606 -0.123700 0.009218 -0.009779 -0.009712 -0.013226 -0.018603 -0.025927 -0.033633 -0.043218 -0.057946 -0.070661 -0.086696 -0.103510 -0.117687 -0.135827 -0.155511 -0.175188 -0.202526 -0.232482 -0.262398 -0.294390 -0.322512 -0.347273 -0.370551 -0.377706 -0.367707 -0.365042 -0.370040 -0.366628 -0.230029 0.422344 2.261338 4.481971 -0.012853 -0.013987 -0.018142 -0.024229 -0.034241 -0.045613 -0.063129 -0.079337 -0.095697 -0.112345 -0.132935 -0.139942 -0.145398 -0.165454 -0.193777 -0.232681 -0.271511 -0.308420 -0.348135 -0.387044 -0.414957 -0.441374 -0.463242 -0.473308 -0.466705 -0.448017 -0.322637 0.695252 6.864685 38.189404 102.156837 -0.016767 -0.019447 -0.022882 -0.033001 -0.045153 -0.063183 -0.084206 -0.101387 -0.123700 -0.127306 -0.090378 0.010653 0.144018 0.203511 0.075006 -0.100017 -0.222446 -0.289592 -0.342000 -0.411342 -0.462531 -0.493489 -0.513885 -0.501216 -0.426234 -0.252254 0.373858 5.566518 65.022942 795.085022 4754.457031 -0.019515 -0.023382 -0.029731 -0.041986 -0.060379 -0.083865 -0.104645 -0.126264 -0.127546 -0.029605 0.417387 1.645763 3.514631 4.394361 3.300805 1.512575 0.682882 0.494036 0.301616 -0.041446 -0.309814 -0.434506 -0.419328 -0.209500 0.366836 1.490607 3.892831 23.029968 438.394379 18517.611328 100083.562500 -0.023569 -0.027766 -0.038002 -0.052641 -0.076622 -0.103141 -0.124689 -0.140290 -0.037148 0.634081 4.004120 17.686905 46.309978 62.762600 40.751297 16.174221 8.753152 8.853133 7.674132 3.715403 1.120201 0.305073 0.489093 1.671594 5.440107 13.390020 26.730801 71.957764 1122.047729 100608.179688 102263.929688 -0.026595 -0.032389 -0.045579 -0.066116 -0.094414 -0.118540 -0.142429 -0.092197 0.399975 3.728709 27.071331 189.736862 850.070496 1434.171631 659.872498 156.566025 86.831558 132.796371 107.026833 43.684414 10.806679 4.208201 5.691780 11.905325 30.457439 86.113007 211.116074 507.738922 1736.399658 44810.714844 200067.390625 -0.029443 -0.037125 -0.055174 -0.080250 -0.111046 -0.139043 -0.133180 0.142789 2.081360 14.901887 132.272903 1949.806641 23336.814453 63050.996094 13724.481445 1437.723389 1086.966187 3131.333740 2447.314941 516.387146 67.095863 19.626493 33.329235 71.480339 132.734497 412.532135 1989.549072 14940.826172 33356.847656 108572.445312 111823.453125 -0.033911 -0.043543 -0.064781 -0.091811 -0.124835 -0.147995 -0.064954 0.916721 7.937868 55.448723 442.728912 9489.023437 100321.421875 102665.796875 112214.328125 13217.286133 14792.875977 100133.664063 77503.921875 5550.498047 313.563507 61.124481 157.474548 425.171448 504.511566 1040.513184 18425.960938 100523.929688 102041.820313 200086.703125 104718.507813 -0.036330 -0.046749 -0.071641 -0.101840 -0.138479 -0.147789 0.095985 2.578318 25.632900 230.482910 1461.743774 11098.793945 101759.289063 131201.437500 200087.156250 105439.953125 81036.914063 100466.312500 100053.296875 21220.570313 669.070251 106.151596 396.113281 1384.508057 1264.495239 1289.387817 42369.085938 100296.640625 100580.890625 110197.234375 108803.054687 -0.039042 -0.049948 -0.076762 -0.113459 -0.146285 -0.141460 0.217751 4.175919 48.073784 548.178589 4543.916504 9340.070312 21260.943359 109349.117187 111192.750000 101980.539063 47574.656250 100658.804688 100086.109375 11191.501953 499.738953 96.716064 329.834412 1020.005737 971.766479 662.952759 10306.420898 100081.523438 100092.101563 100490.992188 4628.372559 -0.039981 -0.051813 -0.082918 -0.117830 -0.151645 -0.153471 0.175704 3.563474 39.863964 405.638062 2895.006836 5035.567383 2679.475586 12325.687500 86679.000000 57053.304688 6956.560059 10468.687500 7884.161133 1300.671265 171.064178 69.269455 171.244247 348.841980 274.337219 169.202744 815.911804 6043.610840 11131.591797 3138.135742 424.239899 -0.038783 -0.054116 -0.086844 -0.122100 -0.151647 -0.169765 0.024273 1.798652 14.965273 103.835579 440.842133 707.683899 410.501068 832.613586 2301.195801 1832.071533 570.955078 415.250641 356.547272 190.453369 99.495865 88.547356 278.998932 459.548737 222.061371 62.952892 69.845299 191.168228 261.861694 139.099792 40.895390 -0.038746 -0.057758 -0.087352 -0.119918 -0.151777 -0.178631 -0.110944 0.513635 3.865771 16.841442 48.292213 64.893021 50.331165 65.309288 107.860847 107.730659 91.921059 101.708916 112.833672 157.581573 129.141769 105.211372 282.021118 452.434143 235.147125 71.245110 32.730347 22.899870 17.688421 9.787241 3.561732 -0.039395 -0.055044 -0.082549 -0.114866 -0.148682 -0.177694 -0.180037 -0.001568 0.732303 2.556473 5.558321 6.927619 6.230223 7.947700 23.380449 152.659271 801.114868 1304.864868 511.915039 171.268814 106.033348 83.866432 148.884247 268.728485 428.540344 482.242676 257.597656 88.809540 23.110338 4.383866 0.314041 -0.046054 -0.054442 -0.078267 -0.112074 -0.145261 -0.180334 -0.210208 -0.192173 -0.052666 0.224949 0.497199 0.590583 0.815748 4.975523 62.928856 1100.984497 16697.556641 43282.101563 6921.243652 407.533264 75.728600 102.172844 281.986115 1589.536133 9605.098633 14110.572266 3705.406494 625.989197 98.887131 13.221868 1.101255 -0.047198 -0.057754 -0.074660 -0.105716 -0.139769 -0.178943 -0.219370 -0.250829 -0.273653 -0.280340 -0.297579 -0.287215 0.396390 7.528564 109.583397 2797.335205 85436.953125 100053.015625 25274.472656 756.520142 125.080826 593.301819 2297.807129 16068.111328 102082.273438 109498.148437 51535.667969 3317.000977 290.722412 29.784060 3.156593 -0.045925 -0.058328 -0.073861 -0.095892 -0.129390 -0.172010 -0.216989 -0.266661 -0.323290 -0.387571 -0.421807 -0.256337 1.032675 8.861831 76.809219 1145.142578 16785.873047 43365.179688 6943.195801 403.840729 336.075897 4482.598145 27824.841797 49520.343750 107439.851562 151420.343750 151464.015625 8171.129395 503.938965 48.469429 6.388010 -0.050244 -0.060395 -0.071086 -0.092221 -0.122849 -0.159064 -0.206019 -0.260937 -0.323498 -0.387179 -0.364099 0.129692 2.866413 14.405220 51.765667 214.317581 960.490967 1489.925903 539.812256 110.002838 451.812073 8391.006836 63574.839844 42020.656250 105931.718750 125987.054687 49758.457031 5424.351562 688.365356 93.945503 13.800288 -0.056212 -0.065395 -0.072380 -0.089009 -0.113803 -0.148900 -0.195578 -0.244200 -0.304495 -0.360067 -0.271451 0.629034 6.087968 28.363169 80.826614 124.625748 128.084366 111.029083 62.680641 51.199360 216.580185 2075.075439 9268.433594 6566.679199 5132.245117 8220.564453 12010.055664 11870.124023 2744.094238 275.330627 29.204062 -0.064650 -0.066264 -0.079462 -0.090150 -0.111677 -0.142394 -0.182168 -0.234793 -0.284802 -0.335436 -0.224280 0.882368 7.053274 34.334034 101.401649 133.989029 81.926895 40.754139 58.787266 181.820526 278.734924 313.365387 539.179443 458.336121 493.642975 2978.917725 23530.552734 34407.644531 6054.170410 456.238007 39.166252 -0.075470 -0.080718 -0.086458 -0.092046 -0.118572 -0.139088 -0.174859 -0.223994 -0.271009 -0.323323 -0.259308 0.501350 4.753833 21.611744 54.971394 71.337341 47.172592 38.565205 193.549026 1109.852661 1815.880737 648.385925 113.331444 51.018017 139.920410 1247.063721 8542.118164 11132.780273 2655.620605 269.175140 29.647528 -0.089109 -0.090355 -0.096506 -0.106994 -0.124630 -0.141631 -0.175592 -0.219486 -0.263823 -0.319929 -0.313263 0.018957 1.646033 7.193288 17.028055 23.109064 20.673819 42.748680 315.640228 2161.255615 3977.035889 1102.220825 121.922714 17.225975 37.369572 215.819824 789.051270 983.863098 373.666443 76.753990 17.218666 -0.102729 -0.105570 -0.112632 -0.123960 -0.138414 -0.155338 -0.184271 -0.224180 -0.270356 -0.322279 -0.355178 -0.289236 0.141583 1.495477 4.165631 7.471081 12.402428 31.529806 157.885117 759.431152 1204.711914 434.028229 62.022549 7.600066 6.673235 25.880690 66.682648 79.052818 50.986858 28.501604 16.234745 -0.125565 -0.124193 -0.129595 -0.140869 -0.156367 -0.171169 -0.197988 -0.232542 -0.279103 -0.328936 -0.375167 -0.399556 -0.328425 0.085806 1.357162 4.423015 9.720471 18.423662 44.688633 111.827194 145.366226 68.734665 15.961858 2.973740 1.451461 3.232343 7.343204 12.119940 17.578552 21.905516 22.056261 -0.151495 -0.146386 -0.148829 -0.148930 -0.148613 -0.164046 -0.195257 -0.238240 -0.288766 -0.336921 -0.388798 -0.433061 -0.443614 -0.275432 0.509233 2.592706 5.970922 9.117372 11.811595 16.209597 16.866009 11.776927 10.196087 11.924578 9.171800 4.612994 2.731020 4.930730 10.846126 20.026577 31.710512 -0.176175 -0.169130 -0.125796 -0.017380 0.123444 0.144600 0.014557 -0.160097 -0.272853 -0.344846 -0.391921 -0.447573 -0.484600 -0.424555 -0.087087 0.817453 2.240061 3.077427 3.232210 3.846619 7.654006 30.317955 113.147171 212.987045 153.994003 48.081238 10.502997 3.809457 6.618389 16.925600 38.167755 -0.196718 -0.117233 0.191689 1.103981 2.387669 2.670234 1.659257 0.439980 -0.128604 -0.323646 -0.401825 -0.455199 -0.507889 -0.516613 -0.414785 -0.164817 0.215735 0.642915 1.400590 5.068232 30.731346 281.477844 2258.857666 7158.911621 4306.187500 633.160950 64.971832 7.401894 4.005102 10.933657 26.546896 -0.189991 0.131884 1.665812 7.447221 17.765696 21.254801 11.875215 3.581814 0.503164 -0.232747 -0.407163 -0.463815 -0.517206 -0.554595 -0.561711 -0.519588 -0.336546 0.358742 3.486756 18.139299 123.714104 2116.209473 62899.390625 100005.578125 100000.703125 7807.111816 296.411163 18.411711 2.868265 6.033706 18.992376 -0.156315 0.651277 5.914047 30.407497 94.330467 123.001472 56.930698 13.716448 2.163714 0.013078 -0.387829 -0.478650 -0.526640 -0.566154 -0.594419 -0.583801 -0.325647 1.461715 11.798678 66.772171 355.046906 6245.148437 100114.835938 100029.289063 100004.679688 31113.046875 633.316528 28.704912 2.861647 5.146356 25.497557 -0.137799 1.240226 11.120989 72.889488 261.202515 348.101624 142.700745 28.945852 4.658020 0.419166 -0.344726 -0.499572 -0.550572 -0.587951 -0.606919 -0.572508 -0.114340 3.517558 30.314283 199.244049 914.622375 4496.630859 100482.484375 100090.671875 100012.218750 13321.914063 417.083588 23.889732 3.471651 7.519635 54.959713 -0.200486 1.126576 11.188721 68.865959 245.275970 328.119965 138.718246 31.248358 5.974869 0.826240 -0.272332 -0.519535 -0.582715 -0.617138 -0.634087 -0.582333 -0.007885 4.470008 40.341438 307.050079 1359.079712 2592.787109 6830.816406 23432.031250 12184.409180 1319.771729 109.072578 15.624231 10.940811 17.171595 148.360352 -0.328882 0.455546 5.511788 28.477106 82.860336 111.861099 61.348618 21.482800 5.958579 1.085937 -0.232942 -0.535219 -0.611387 -0.649892 -0.664767 -0.622257 -0.128876 3.504753 29.616520 186.917542 726.367371 1149.015015 811.116699 658.157959 389.940887 106.898705 35.682274 70.479500 122.034554 93.203888 225.608124 -0.459045 -0.083731 1.829298 8.668402 23.459278 33.315273 29.247999 15.800113 5.513824 1.125568 -0.238750 -0.560278 -0.644353 -0.682159 -0.699482 -0.683287 -0.332665 2.186488 19.283445 127.338432 681.796631 2103.418457 1892.448608 496.689087 88.699554 30.622538 134.231110 1016.404175 3034.150635 1411.185425 302.216614 -0.524593 -0.285186 1.031488 5.969941 18.320196 31.996878 31.324921 17.388105 6.514010 1.588640 -0.043948 -0.519831 -0.654119 -0.721229 -0.735814 -0.724954 -0.456722 1.697651 20.249105 207.799210 1948.442261 9327.866211 8537.431641 1428.734741 144.271912 54.143959 601.323181 12369.716797 67805.578125 20498.697266 1037.514893 -0.119501 -0.044758 1.032120 6.293355 21.165350 40.538239 40.598629 24.840853 11.439149 4.388795 1.220842 -0.042607 -0.503145 -0.686116 -0.748267 -0.745639 -0.532376 1.299496 17.378899 188.318161 1788.995605 8525.383789 7813.042969 1321.775024 137.389542 73.099731 929.472290 22851.625000 100089.539063 38802.144531 1535.421021 6.744144 4.014273 2.137442 5.023228 15.883154 32.876965 43.114342 42.815517 37.420822 19.669983 7.071388 2.144315 0.320157 -0.414050 -0.645353 -0.566572 -0.215123 1.030842 9.142665 73.750351 479.612854 1535.203857 1425.315918 369.794373 66.177032 64.074326 404.095734 3864.506348 13803.517578 5269.284668 499.916992 167.060623 79.039322 16.861568 4.819453 8.845595 23.370337 61.582973 146.788300 180.880188 92.060829 28.048016 9.055056 3.095449 0.563410 0.077063 1.289326 3.983930 6.504813 8.042574 18.611687 67.040314 148.002701 141.730545 62.704479 25.942684 41.154617 149.757812 417.917877 670.512512 431.963898 289.044342 9216.034180 2341.063721 194.934814 16.354332 6.639095 24.890659 126.726974 422.196594 594.951538 267.773193 69.190865 22.610790 8.817798 2.679757 3.550292 15.653324 48.435009 77.568604 65.506668 32.871456 17.710428 18.274334 19.868382 19.936014 22.109154 29.156704 63.257866 156.352890 506.714111 1870.343628 2589.444336 100341.156250 100145.656250 1686.036133 58.580769 7.956424 25.283932 132.623581 483.088348 685.950317 309.243317 85.625145 33.130169 13.465218 5.700791 18.379911 128.598709 561.733826 1090.834595 978.762024 386.601105 80.617203 15.552535 10.655130 21.295765 30.883465 29.868217 49.605663 261.676941 3182.618164 31185.238281 51656.871094 105543.617188 101535.546875 4146.673340 103.673500 9.225425 15.949091 67.016220 192.714737 248.647537 130.974075 50.133415 25.828581 11.572405 8.751312 62.054409 706.151794 6012.088867 21267.773438 36776.531250 9661.280273 828.642456 67.075432 13.236958 18.301497 27.968256 25.655481 42.899128 375.481476 7860.046875 100070.867188 100252.390625 151247.843750 104543.632813 2122.201172 93.421005 8.843932 7.588367 20.577740 43.134655 49.990887 34.035503 18.943472 12.087964 6.326206 9.984210 107.614624 1684.722046 29734.523438 128279.945312 105551.390625 100629.507813 6721.644531 270.144348 29.526999 12.022235 13.696489 15.593093 38.199974 274.184967 3779.181152 46664.304688 78068.898438 65566.289063 11608.082031 871.619019 76.209229 8.591007 3.118163 5.463836 9.422783 13.749755 18.737833 20.020899 13.939745 6.550474 8.801147 84.463387 1373.658203 47270.648438 108780.562500 102774.078125 102906.367188 19398.835938 1300.327271 154.864517 18.933691 8.547837 30.783859 158.578018 488.458771 1323.458374 5913.172852 9217.546875 17516.865234 7380.044922 1105.627808 122.742668 13.958344 2.046501 2.418877 9.580833 43.070370 131.070648 191.738327 117.999672 35.341354 12.038874 38.608833 462.145752 11665.093750 101140.203125 110458.500000 200070.437500 105116.265625 31315.208984 1150.663452 65.041641 17.347479 155.926605 1970.506714 9303.558594 6039.598633 12033.974609 26479.468750 131538.640625 69764.476563 6008.811523 384.444763 30.060841 3.075205 4.366204 35.258595 280.360840 1539.240234 2880.998535 1250.271851 217.640930 45.909595 29.624651 105.971428 1003.384521 9890.734375 119325.742187 105603.960938 100645.992188 100111.851563 4707.523926 143.621017 32.252247 427.357513 10138.594727 85466.734375 35664.058594 8907.142578 66992.382813 200061.578125 151247.109375 22394.171875 811.724731 49.041039 4.412632 8.232004 89.744415 1140.975220 12202.682617 28386.404297 8185.258301 1085.725220 295.259460 287.316284 198.852722 162.005661 1482.221558 86537.656250 100356.656250 100330.335938 100192.226563 4368.516602 144.667084 30.275934 317.213165 6278.425293 43292.671875 20713.203125 3126.329590 78774.640625 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002045 -0.002432 -0.002856 -0.003265 -0.005253 -0.007836 -0.008709 -0.009514 -0.010161 -0.010537 -0.010756 -0.010694 -0.010441 -0.009949 -0.009268 -0.008481 -0.007606 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002162 -0.002626 -0.003174 -0.005289 -0.007958 -0.009302 -0.010686 -0.011929 -0.013110 -0.014059 -0.014739 -0.015049 -0.014921 -0.014566 -0.013820 -0.012795 -0.011620 -0.010327 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002177 -0.002719 -0.003359 -0.005767 -0.008773 -0.010567 -0.012498 -0.014470 -0.016464 -0.019809 -0.021381 -0.022436 -0.022953 -0.022887 -0.022207 -0.021000 -0.017856 -0.016029 -0.014126 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.002681 -0.003408 -0.005980 -0.007447 -0.011441 -0.013943 -0.018486 -0.021642 -0.024797 -0.027707 -0.030078 -0.031847 -0.032633 -0.032462 -0.031539 -0.029601 -0.027072 -0.024160 -0.020984 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001936 -0.002536 -0.003265 -0.005906 -0.007543 -0.011753 -0.016452 -0.020368 -0.024759 -0.029445 -0.034292 -0.038737 -0.042530 -0.045108 -0.048061 -0.046467 -0.044898 -0.041989 -0.038103 -0.033617 -0.028971 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002269 -0.003000 -0.005545 -0.007245 -0.011356 -0.016498 -0.021119 -0.026654 -0.032987 -0.041340 -0.048335 -0.054973 -0.060809 -0.065864 -0.069686 -0.069608 -0.067984 -0.063541 -0.057953 -0.053154 -0.045299 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001963 -0.002626 -0.004940 -0.006562 -0.008733 -0.015687 -0.020590 -0.026841 -0.035843 -0.044731 -0.054146 -0.063284 -0.073026 -0.081448 -0.088418 -0.091192 -0.089890 -0.085766 -0.082641 -0.075464 -0.068359 -0.061239 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.002958 -0.005698 -0.007676 -0.014093 -0.018897 -0.025287 -0.034940 -0.045321 -0.056500 -0.066952 -0.079281 -0.088884 -0.096685 -0.099487 -0.101738 -0.103767 -0.102936 -0.099830 -0.092525 -0.086715 -0.077881 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002415 -0.006380 -0.008159 -0.012233 -0.018179 -0.024067 -0.033652 -0.044108 -0.056129 -0.068185 -0.083261 -0.093857 -0.104731 -0.109900 -0.113678 -0.117348 -0.110672 -0.103255 -0.096444 -0.100335 -0.102037 -0.097943 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001724 -0.003851 -0.004751 -0.007515 -0.009568 -0.015965 -0.024610 -0.033338 -0.044526 -0.057424 -0.074100 -0.086651 -0.100698 -0.110883 -0.116125 -0.115416 -0.111184 -0.094528 -0.056541 -0.003836 0.014265 -0.018198 -0.068711 -0.104759 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001724 -0.002040 -0.002368 -0.005897 -0.008750 -0.013652 -0.018234 -0.024184 -0.032807 -0.041729 -0.054155 -0.071910 -0.091162 -0.106103 -0.118473 -0.126654 -0.110686 -0.072783 -0.010045 0.074186 0.212345 0.405272 0.452266 0.308796 0.078784 -0.070942 0.000000 0.000000 0.000000 0.000000 -0.001915 -0.003565 -0.004180 -0.006620 -0.009618 -0.013108 -0.017219 -0.022509 -0.030371 -0.042211 -0.052720 -0.069381 -0.088278 -0.106432 -0.120964 -0.138535 -0.132144 -0.066542 0.073764 0.289495 0.547414 0.884329 1.322319 1.547729 1.066379 0.412881 0.011851 0.000000 0.000000 -0.001607 -0.003256 -0.004000 -0.006506 -0.007799 -0.010814 -0.016012 -0.020167 -0.025358 -0.033711 -0.044918 -0.053934 -0.068370 -0.084435 -0.104476 -0.124753 -0.146740 -0.161052 -0.129214 0.008905 0.336542 0.859039 1.390943 1.901180 2.518101 2.819320 1.940172 0.748610 0.092817 0.000000 -0.001596 -0.003422 -0.004293 -0.007108 -0.010089 -0.013806 -0.016610 -0.022849 -0.028306 -0.037728 -0.045807 -0.059040 -0.072124 -0.087273 -0.104769 -0.128875 -0.157301 -0.175564 -0.189150 -0.145333 0.054061 0.583309 1.477107 2.210806 2.526974 2.895416 3.019536 2.020651 0.752045 0.061819 -0.002396 -0.003444 -0.004423 -0.008689 -0.010942 -0.015257 -0.021250 -0.025697 -0.034069 -0.044729 -0.056137 -0.065271 -0.081202 -0.095502 -0.111119 -0.133055 -0.165212 -0.192811 -0.213624 -0.230967 -0.195367 0.005209 0.551192 1.462340 2.123271 2.165490 2.030785 1.886063 1.162879 0.365331 -0.093430 -0.007232 -0.004325 -0.008774 -0.011318 -0.015800 -0.023266 -0.029148 -0.039189 -0.049663 -0.063446 -0.076690 -0.090954 -0.108541 -0.125382 -0.146264 -0.174276 -0.204902 -0.240916 -0.269636 -0.287896 -0.276969 -0.154745 0.187039 0.772352 1.155277 1.045474 0.812216 0.562781 0.286906 0.051874 -0.034315 -0.008547 -0.009723 -0.012401 -0.017246 -0.024165 -0.031252 -0.041994 -0.054645 -0.069581 -0.085996 -0.102647 -0.117907 -0.139777 -0.161065 -0.190004 -0.219070 -0.254737 -0.297826 -0.329398 -0.355152 -0.372249 -0.325663 -0.166572 0.053948 0.201406 0.143654 -0.010741 -0.052561 0.305571 1.546688 3.081068 -0.012534 -0.013275 -0.015719 -0.022282 -0.031657 -0.043847 -0.058868 -0.074634 -0.091943 -0.109667 -0.130948 -0.147764 -0.166145 -0.184080 -0.214076 -0.257653 -0.301544 -0.347630 -0.390220 -0.422692 -0.450004 -0.453963 -0.414040 -0.343192 -0.286106 -0.288629 -0.253757 0.426015 4.794319 23.161663 60.044903 -0.016338 -0.017266 -0.022192 -0.030310 -0.043047 -0.059423 -0.078390 -0.098583 -0.118297 -0.134311 -0.126579 -0.089471 -0.029846 -0.026140 -0.093502 -0.188576 -0.252339 -0.299022 -0.353877 -0.420853 -0.474154 -0.508461 -0.500690 -0.416861 -0.214718 0.124715 0.697014 4.366697 39.534779 370.057495 1805.276611 -0.018856 -0.023084 -0.027305 -0.039960 -0.055235 -0.077020 -0.098746 -0.121663 -0.133189 -0.093336 0.101254 0.654303 1.432922 1.859347 1.479511 0.905878 0.701495 0.750551 0.590973 0.172303 -0.129028 -0.191836 -0.066769 0.479990 2.166251 5.475558 8.802351 20.744270 219.382828 5252.932617 96090.382813 -0.021377 -0.026951 -0.034675 -0.049179 -0.070682 -0.095718 -0.117613 -0.138641 -0.103850 0.216688 1.613370 6.472012 15.534040 20.323790 16.031624 9.853045 10.297815 13.877299 12.030411 6.279617 2.810688 2.399498 3.243125 6.874764 22.033039 61.658623 95.340843 107.958359 600.199219 23483.988281 102872.867188 -0.025115 -0.030952 -0.044701 -0.061358 -0.087806 -0.113784 -0.137486 -0.139137 0.068379 1.426838 9.135443 47.529366 152.095428 235.983185 158.140793 92.820229 134.460571 265.675140 215.732590 77.102341 24.126598 18.746111 27.096399 52.267456 175.015060 712.117065 1349.296875 1135.831421 1794.268433 26241.271484 200084.593750 -0.029513 -0.037063 -0.051759 -0.072288 -0.102798 -0.128761 -0.154920 -0.073956 0.598921 4.860250 35.647362 271.236328 1380.094116 2623.241211 1978.726685 1242.928467 2690.649170 11158.882813 8535.379883 1336.428955 164.535126 106.875648 230.055374 587.408569 1211.518799 6828.679687 19372.394531 25405.613281 45190.109375 109949.031250 104136.937500 -0.033068 -0.039868 -0.058581 -0.082309 -0.115775 -0.146772 -0.144031 0.134579 1.931267 12.432450 85.400635 842.484192 6629.278320 21479.757813 73819.250000 48625.382813 90480.140625 100285.976563 100080.726563 25738.714844 841.497803 441.953003 2110.166016 12361.125000 11537.119141 21192.927734 86284.765625 117660.109375 103677.109375 200147.718750 105875.539063 -0.035295 -0.042250 -0.064264 -0.093477 -0.128632 -0.158360 -0.113872 0.499582 4.550402 26.253277 125.458412 916.958374 8941.289062 111137.226562 103799.406250 105957.007813 169826.484375 101237.929688 100418.273438 100551.421875 2074.590820 849.489929 9503.803711 100175.609375 100843.140625 14340.744141 82409.921875 106623.960937 101278.773438 113409.859375 112059.468750 -0.036819 -0.046793 -0.070687 -0.104342 -0.141087 -0.169828 -0.090600 0.794577 6.801609 38.744289 153.896606 533.807251 6749.658203 101955.062500 100960.843750 103253.828125 200053.031250 101918.578125 101290.218750 58548.105469 1902.487061 671.962830 6533.216309 78991.921875 63362.460938 5628.833496 14955.253906 100756.015625 100219.148438 100585.468750 6035.568359 -0.037636 -0.050581 -0.077655 -0.110753 -0.146783 -0.176207 -0.111477 0.622823 5.563654 30.548096 107.870323 239.807373 1834.952271 63075.871094 100139.031250 100544.781250 29030.949219 57615.550781 39116.746094 5467.187500 1065.921143 308.820312 921.122253 4085.036865 3440.628174 775.740295 1133.444580 7878.022461 14625.755859 4007.868408 506.742889 -0.039868 -0.054712 -0.079640 -0.113088 -0.152032 -0.181485 -0.163388 0.213502 2.473082 11.842300 34.525295 65.506027 247.183182 1953.388062 8540.956055 6629.378906 1373.789551 1041.390015 1440.178833 2112.502686 1325.412598 307.686340 126.858536 198.192459 179.633835 82.807953 88.755020 224.164856 301.917786 158.939377 45.541481 -0.041638 -0.056025 -0.082004 -0.113210 -0.152032 -0.186728 -0.209074 -0.096178 0.553601 2.711316 6.933967 11.822967 27.893515 97.316086 217.087387 187.426193 108.152611 208.740265 1449.237183 5866.532715 4101.457520 654.837280 84.932190 50.537243 56.799324 64.954605 65.299911 47.699528 26.732426 12.327637 4.357583 -0.041484 -0.054147 -0.080571 -0.111274 -0.151168 -0.189788 -0.225010 -0.242316 -0.139049 0.210049 0.775007 1.452401 3.002179 7.326236 15.497940 33.708046 95.270096 217.576233 980.510010 3741.700439 2662.808594 471.159729 110.118576 214.638977 693.507935 998.614197 914.108276 452.606598 87.845184 11.708209 1.104051 -0.046378 -0.056062 -0.079629 -0.108921 -0.150813 -0.189857 -0.233061 -0.278404 -0.311122 -0.317374 -0.295347 -0.272030 -0.067012 1.420849 12.070145 97.155777 466.160309 767.104614 476.092773 600.102173 494.404846 300.633148 603.400635 3663.434814 34616.519531 53425.453125 17065.896484 4877.655762 503.698181 38.104797 2.880248 -0.052489 -0.058970 -0.078105 -0.104550 -0.141895 -0.183114 -0.231549 -0.281594 -0.343400 -0.411131 -0.470593 -0.530012 -0.374323 1.473066 17.639154 167.575943 1012.647522 1665.388916 612.106201 156.855911 354.371246 3832.804932 21017.460938 67868.531250 101609.632813 105627.148438 128409.953125 15825.688477 995.966980 63.649662 4.699470 -0.052763 -0.060052 -0.074909 -0.099308 -0.133175 -0.175467 -0.222999 -0.279113 -0.341112 -0.408085 -0.476658 -0.512053 -0.291553 1.383536 13.524639 99.544350 467.762756 743.752991 315.382935 138.032410 1684.145386 88505.289063 101760.726563 200091.921875 113862.351562 102914.718750 107707.687500 9592.730469 600.756348 46.812069 4.644007 -0.053882 -0.062493 -0.076339 -0.095485 -0.124335 -0.164705 -0.213805 -0.269474 -0.329428 -0.398197 -0.457347 -0.430402 -0.055758 1.565044 7.270494 29.561153 88.696838 128.318314 95.532417 140.573883 2731.469482 100182.062500 100846.273438 128311.546875 127234.296875 101273.000000 101064.679688 2626.080078 227.241577 30.665775 4.394717 -0.062471 -0.065634 -0.081896 -0.095521 -0.123496 -0.157831 -0.203768 -0.254373 -0.312071 -0.379398 -0.420857 -0.322996 0.334963 2.299721 6.308789 12.074573 21.612263 39.425884 75.814888 128.832718 932.562805 27081.646484 100189.570313 101460.015625 15542.461914 13776.586914 3324.654297 700.290283 190.868118 39.047813 5.894810 -0.070478 -0.072982 -0.084619 -0.099142 -0.125190 -0.153530 -0.190888 -0.245004 -0.295014 -0.354299 -0.391293 -0.257968 0.484550 2.710870 6.554278 9.674380 13.736005 32.824600 78.142708 116.025841 190.720108 965.568115 3161.134766 2143.914062 629.032166 504.638885 635.089294 633.377319 237.332870 47.674526 7.250180 -0.082348 -0.082313 -0.091347 -0.104398 -0.127504 -0.152543 -0.181543 -0.230994 -0.280469 -0.341525 -0.383521 -0.299418 0.232942 1.890479 4.756990 8.506696 14.642166 36.444008 97.325058 184.758835 170.287842 114.182732 109.469009 86.777885 57.359276 111.158501 290.498718 345.202637 147.267715 33.398655 5.706990 -0.094687 -0.094876 -0.102707 -0.115656 -0.131739 -0.156880 -0.184964 -0.229732 -0.277575 -0.333247 -0.381653 -0.366169 -0.063586 1.027991 4.271787 13.032331 31.234848 62.355804 161.688232 317.719513 279.003296 108.192230 28.927011 9.710055 10.126914 29.128393 70.616341 79.802101 43.145096 14.349484 5.779838 -0.106013 -0.104486 -0.118845 -0.132833 -0.148258 -0.167054 -0.201618 -0.234514 -0.282496 -0.321291 -0.379502 -0.397160 -0.188142 1.008198 6.842223 28.390882 79.380898 119.112595 174.880295 277.324249 226.608276 84.281319 19.047684 3.471748 1.953953 5.729097 12.587881 16.823631 15.538655 15.645091 21.047014 -0.129336 -0.131518 -0.135045 -0.147272 -0.166131 -0.181944 -0.211736 -0.246479 -0.286048 -0.327356 -0.378453 -0.409748 -0.228084 1.116737 8.879586 40.940926 115.592758 159.542419 123.583832 112.404594 85.009064 33.883369 9.103903 2.372391 1.036901 1.751836 5.194943 13.552458 25.598989 48.826340 114.628639 -0.149821 -0.151718 -0.156080 -0.165612 -0.183338 -0.198516 -0.228136 -0.259563 -0.294035 -0.335386 -0.377201 -0.411214 -0.288301 0.782391 6.607494 28.661051 78.788750 97.806931 62.989773 33.511532 20.630558 12.070440 11.948462 14.942927 11.677369 6.265650 7.221886 19.961058 45.043522 125.153900 458.821381 -0.177307 -0.180130 -0.175377 -0.163065 -0.151228 -0.157054 -0.204031 -0.259494 -0.306302 -0.340439 -0.385890 -0.422586 -0.377743 0.127348 2.596140 10.316900 24.215946 29.441423 19.575235 9.960669 11.218443 38.923462 146.066711 296.859039 213.080368 65.805527 17.527851 19.029346 45.559532 166.580353 746.121643 -0.207167 -0.191687 -0.134828 0.013656 0.187924 0.243913 0.049358 -0.157650 -0.293985 -0.357960 -0.394990 -0.437947 -0.453788 -0.317238 0.347843 2.123772 4.717769 6.030811 5.728312 10.124894 45.370243 401.499146 3972.607666 14597.692383 7807.818848 977.829407 90.401283 16.555334 26.004059 103.541176 394.658966 -0.228388 -0.171787 0.077962 0.764125 1.747585 2.085802 1.181253 0.263272 -0.202352 -0.364398 -0.415346 -0.453479 -0.489051 -0.489221 -0.383630 -0.047456 0.540971 2.127983 10.588516 53.144573 266.420746 3819.546387 100089.656250 100023.210938 100003.890625 14595.303711 417.160950 25.707874 11.958681 42.865395 161.680252 -0.249487 -0.104218 0.595488 2.785407 6.252294 7.449306 4.468194 1.357388 0.038614 -0.342096 -0.434049 -0.471169 -0.507416 -0.534867 -0.550398 -0.453465 0.237353 5.672686 50.610798 405.380188 2322.358643 15218.708008 101128.695313 100167.171875 100019.640625 69772.328125 908.436218 36.842529 7.428040 27.044645 129.493988 -0.282367 -0.034492 1.165790 5.256200 12.555115 15.062239 8.597959 2.663333 0.339481 -0.300068 -0.455886 -0.495050 -0.531480 -0.562490 -0.581576 -0.464666 0.760414 13.464387 168.314713 2420.684082 27074.591797 59467.984375 110747.968750 100787.632813 100056.296875 28234.367188 590.646118 29.446819 5.279616 17.693628 85.091080 -0.328738 -0.099075 1.068530 5.057539 12.204204 14.955378 8.987256 3.178077 0.659495 -0.216282 -0.468575 -0.531909 -0.565483 -0.591495 -0.599611 -0.454919 1.067047 17.964540 248.180008 4985.269043 80644.976563 100843.234375 38069.398438 58056.539063 25719.972656 2094.544678 148.913101 20.500700 16.619139 18.662172 55.990589 -0.403240 -0.243661 0.523533 3.055152 7.500552 10.678427 8.627097 4.772807 1.598107 0.090512 -0.427121 -0.564590 -0.608628 -0.626919 -0.627990 -0.520125 0.772342 12.993236 155.765854 1976.120361 18904.525391 37215.925781 9739.501953 1739.408813 650.318481 153.244781 59.549335 183.854721 370.165527 225.818130 86.175011 -0.473556 -0.353256 0.307801 2.869307 10.019958 21.495644 26.856348 17.761127 6.545570 1.210470 -0.231399 -0.570526 -0.643983 -0.668051 -0.672918 -0.598464 0.235355 7.151112 69.909897 717.116211 7878.668945 48196.785156 38692.562500 4474.309570 327.620789 69.511559 423.744019 6309.352051 28087.619141 9203.597656 700.264343 -0.507750 -0.339797 0.741589 6.616658 30.085226 90.054832 129.621567 79.019798 23.284540 4.398391 0.260129 -0.530642 -0.678210 -0.704826 -0.707394 -0.664476 -0.087334 5.420749 68.511208 1348.765259 51306.625000 100125.812500 100082.554688 28268.279297 874.262390 173.258453 3211.990234 100342.765625 100228.625000 100066.226563 6294.238770 -0.214200 -0.057756 1.528912 12.157486 66.260826 245.138031 365.389740 201.315887 49.350597 8.467972 0.985872 -0.397103 -0.671678 -0.733454 -0.734998 -0.688374 -0.235919 4.113523 62.382282 1226.314453 46292.730469 100034.140625 100052.203125 25679.814453 836.933411 345.640137 5984.035156 103110.562500 101790.328125 100321.476563 10177.718750 4.433474 2.904400 2.569581 12.342081 70.340927 262.184906 392.528931 217.555328 55.374474 11.087980 1.916113 -0.048767 -0.559070 -0.699702 -0.668380 -0.454947 0.062538 2.600252 27.737841 365.786652 4690.869141 34352.500000 28296.027344 3427.024902 294.614441 469.049622 4476.243164 48963.246094 105124.625000 68495.789063 2260.602539 82.676712 43.581482 12.146907 8.934297 34.320557 104.222565 153.798721 101.821800 39.845139 13.605364 4.002605 0.836628 -0.190639 -0.440368 0.142140 2.420774 6.325829 9.003329 12.596123 55.235088 304.376678 930.332642 883.676941 282.050049 86.270149 309.290497 2249.017578 6585.115723 5759.204102 1968.116455 833.957764 2396.437744 767.843445 100.162338 13.676792 13.715925 33.066380 50.909275 52.119194 39.548897 20.268541 7.107566 2.022527 0.435474 0.590468 6.210839 33.638313 106.404205 144.857315 78.585732 32.069874 32.280743 54.687050 56.343296 33.594147 26.498617 105.366943 582.089417 1855.999146 3364.109619 10059.917969 16032.051758 101675.195313 14229.246094 631.753052 42.520054 13.946122 31.918022 56.592556 62.599644 44.890656 22.514139 8.107870 2.737669 1.069440 4.121208 45.154232 473.602631 3172.241943 4999.514648 1494.176147 264.899261 50.325226 12.919716 7.436218 6.261749 9.788877 44.183571 320.934631 2027.480469 23667.640625 100888.515625 102209.656250 200064.187500 67379.968750 1977.116699 95.831535 20.943293 48.790134 89.882652 83.213234 42.018673 17.341412 5.977071 2.293051 1.468732 11.657436 202.257401 5835.334473 100461.210938 103135.953125 35975.273438 3119.361572 345.011261 36.648888 5.286957 2.237416 4.371583 22.372618 164.698593 1738.938232 96667.015625 100467.757813 100998.671875 200139.046875 112408.359375 3925.806152 155.945526 22.906507 44.571037 80.210999 69.803734 30.614405 11.917418 5.712966 3.020275 2.159110 17.882133 384.286224 20077.310547 103121.726563 156766.125000 200054.734375 36422.890625 1772.246826 125.215019 15.833245 2.803294 2.882448 15.128199 90.889290 854.848511 28849.412109 102727.664063 104468.664063 103968.445313 101834.398438 3972.852295 170.336288 18.978781 20.586752 33.066608 30.809128 24.123232 32.769943 41.693443 26.003626 9.945704 15.148332 242.374374 7201.682129 106580.203125 200051.875000 137094.484375 101783.023438 4389.702637 511.627625 74.878342 9.831215 8.369646 71.802330 611.423218 2196.646484 8220.190430 112062.546875 125885.132812 200217.906250 68938.562500 4071.738525 243.732224 20.955975 7.106255 10.502924 26.322615 131.258148 551.606445 909.607178 447.895874 90.159355 19.909100 64.105522 727.019897 6710.541016 48972.789063 103859.890625 45076.019531 29665.326172 5175.131348 423.933777 34.610867 30.557426 627.792114 18506.681641 100500.867188 104798.710938 103603.539063 103728.234375 103484.359375 101868.218750 26044.435547 609.553772 33.641899 4.247070 9.957165 107.194977 1533.412231 17561.861328 46288.304688 12185.685547 929.106445 85.450500 37.578899 95.977966 503.534668 2739.218262 15898.435547 101554.085938 100237.570313 37914.671875 1321.784790 68.981239 64.475357 2328.680176 100020.773438 100344.117188 109344.992187 119088.406250 125949.945312 105627.000000 105136.500000 29220.617188 699.030090 38.338341 4.400799 18.546501 340.176941 11123.455078 100031.445313 100147.968750 100371.703125 5894.438477 506.892395 531.072144 333.065125 137.045792 571.442200 11283.328125 100100.140625 100041.281250 31129.900391 1228.110474 65.854530 54.260090 1521.105347 100008.242188 100095.890625 101166.343750 21162.308594 52096.980469 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002333 -0.002796 -0.003289 -0.005284 -0.007868 -0.008951 -0.010006 -0.010868 -0.011625 -0.012104 -0.012311 -0.012243 -0.011899 -0.011305 -0.010515 -0.009571 -0.008523 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002466 -0.003021 -0.005075 -0.006081 -0.009140 -0.010714 -0.012323 -0.013868 -0.015273 -0.016400 -0.017146 -0.017468 -0.017373 -0.016848 -0.015948 -0.014661 -0.013267 -0.011743 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002483 -0.003130 -0.005374 -0.006661 -0.010124 -0.012276 -0.014665 -0.017035 -0.021143 -0.023458 -0.025368 -0.026642 -0.027212 -0.026998 -0.026085 -0.024495 -0.022554 -0.018630 -0.016306 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.002398 -0.003086 -0.005452 -0.006911 -0.010679 -0.013362 -0.018135 -0.021944 -0.025911 -0.029900 -0.033466 -0.036370 -0.038556 -0.039551 -0.039255 -0.037805 -0.035376 -0.032127 -0.028480 -0.024587 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.002896 -0.005243 -0.006824 -0.010637 -0.013729 -0.019394 -0.024323 -0.029916 -0.035844 -0.043231 -0.048915 -0.053737 -0.058083 -0.061477 -0.061296 -0.058939 -0.055039 -0.050002 -0.042890 -0.037162 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002607 -0.003456 -0.006366 -0.008465 -0.014964 -0.019529 -0.025369 -0.032412 -0.041829 -0.050380 -0.058417 -0.068223 -0.074964 -0.080483 -0.083869 -0.083498 -0.080804 -0.074765 -0.069811 -0.062623 -0.055006 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002238 -0.003021 -0.005661 -0.007649 -0.013815 -0.018507 -0.024690 -0.034070 -0.043756 -0.054196 -0.063301 -0.074849 -0.084273 -0.092128 -0.096464 -0.099588 -0.099777 -0.100402 -0.095329 -0.087067 -0.079292 -0.072278 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002518 -0.004821 -0.006554 -0.008974 -0.016555 -0.022521 -0.032141 -0.042799 -0.054706 -0.064763 -0.078288 -0.091446 -0.098175 -0.103253 -0.106230 -0.109894 -0.106314 -0.101148 -0.098350 -0.098367 -0.098011 -0.091504 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002031 -0.002777 -0.005383 -0.009081 -0.013949 -0.021111 -0.030110 -0.040629 -0.052917 -0.065962 -0.080965 -0.091591 -0.092450 -0.086799 -0.078777 -0.078832 -0.072701 -0.042042 0.014048 0.040665 0.003726 -0.057766 -0.093695 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.004000 -0.005025 -0.008123 -0.012291 -0.019800 -0.029428 -0.040020 -0.052848 -0.069898 -0.082908 -0.096888 -0.096806 -0.069736 -0.000342 0.077127 0.132910 0.221956 0.437183 0.754032 0.890625 0.654046 0.239894 -0.012000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001630 -0.001928 -0.002237 -0.004828 -0.010269 -0.014150 -0.019368 -0.026363 -0.036804 -0.048515 -0.066512 -0.083561 -0.102663 -0.110707 -0.093310 0.008455 0.244698 0.579903 0.969832 1.471248 2.498512 4.071965 4.943488 3.538704 1.496203 0.326514 0.000000 0.000000 0.000000 0.000000 -0.001810 -0.003321 -0.003892 -0.006274 -0.009482 -0.014560 -0.019273 -0.024616 -0.034238 -0.046816 -0.061472 -0.080039 -0.100601 -0.116967 -0.126419 -0.080194 0.150653 0.727983 1.811736 3.571312 5.602625 8.767570 14.737069 17.914564 11.992482 4.548476 1.104927 0.000000 0.000000 0.000000 -0.003054 -0.003723 -0.006156 -0.007363 -0.010253 -0.014314 -0.018629 -0.025170 -0.034831 -0.046224 -0.057304 -0.073835 -0.096703 -0.119147 -0.140339 -0.150021 -0.080105 0.273125 1.381064 4.420749 10.231587 15.767599 20.575396 32.933239 39.561668 25.969557 9.065871 1.988896 0.000000 0.000000 -0.003199 -0.003992 -0.006716 -0.008242 -0.012921 -0.015500 -0.020566 -0.028521 -0.040404 -0.049315 -0.062240 -0.076476 -0.095082 -0.121395 -0.149925 -0.172756 -0.186045 -0.116824 0.301301 1.954076 7.472238 19.420492 30.519930 31.646418 38.034412 45.074997 27.561152 9.532021 2.047361 -0.001339 -0.003204 -0.004110 -0.006984 -0.010170 -0.012610 -0.017559 -0.022606 -0.032728 -0.044794 -0.053602 -0.064740 -0.081228 -0.099128 -0.121723 -0.149688 -0.183828 -0.212273 -0.233590 -0.184464 0.189589 1.835037 7.610184 20.145086 30.907513 27.468676 24.805582 23.769691 15.040889 5.497973 1.145460 -0.007132 -0.005206 -0.006946 -0.010500 -0.013406 -0.021280 -0.028351 -0.036389 -0.047397 -0.061747 -0.073719 -0.091860 -0.110624 -0.130623 -0.155768 -0.188391 -0.230373 -0.263448 -0.287224 -0.276338 -0.044063 1.013247 4.464514 11.156446 16.753166 13.929738 9.765415 7.780201 4.609116 1.787898 0.305535 -0.008414 -0.009208 -0.010299 -0.014737 -0.021984 -0.030162 -0.038364 -0.049972 -0.066375 -0.083229 -0.100358 -0.119833 -0.143003 -0.169170 -0.200601 -0.237315 -0.288267 -0.326486 -0.355268 -0.372782 -0.272862 0.209919 1.592391 3.925091 5.472198 4.596469 2.797049 1.632341 1.006485 0.818868 1.071366 -0.011011 -0.012377 -0.015422 -0.020048 -0.030351 -0.039710 -0.053381 -0.069023 -0.086495 -0.107463 -0.130464 -0.150836 -0.173728 -0.201937 -0.237854 -0.279303 -0.327711 -0.375979 -0.414108 -0.446918 -0.429819 -0.237097 0.248500 0.973307 1.370096 1.061597 0.523406 0.373866 1.700930 6.961798 15.134671 -0.015614 -0.014955 -0.020112 -0.027230 -0.038858 -0.053518 -0.070753 -0.091862 -0.112380 -0.135829 -0.150322 -0.157721 -0.153068 -0.167504 -0.210901 -0.267868 -0.305004 -0.338328 -0.386259 -0.438204 -0.446372 -0.368416 -0.166582 0.161294 0.593727 0.989018 1.283147 2.438100 11.696870 65.996880 193.727844 -0.017896 -0.020265 -0.024467 -0.035852 -0.049298 -0.068759 -0.090627 -0.117210 -0.135622 -0.135395 -0.093229 0.066220 0.302040 0.465298 0.417594 0.354913 0.451745 0.602976 0.489280 0.276937 0.327422 0.619548 0.931235 1.809243 5.355816 12.140282 17.598394 18.393602 53.034302 420.495483 2005.761719 -0.020180 -0.024622 -0.032824 -0.045516 -0.064329 -0.087827 -0.116263 -0.137399 -0.140237 -0.058681 0.346077 1.558836 3.614120 5.365366 5.634108 5.696023 8.115358 11.799871 10.704677 6.962050 6.510911 9.325712 11.145697 16.790699 56.563297 191.473923 325.866150 202.762924 184.223526 1226.551880 7126.873047 -0.025175 -0.030044 -0.040546 -0.054506 -0.077760 -0.105594 -0.131916 -0.153608 -0.109791 0.289097 2.187126 8.702535 24.271166 42.147938 53.789577 58.243767 103.433838 193.052826 170.437973 76.192993 56.556004 88.065514 107.974297 149.991623 660.270386 5128.092773 12236.250000 4528.193359 1106.512329 4330.180176 28457.449219 -0.028885 -0.035564 -0.046626 -0.063693 -0.090923 -0.124147 -0.150922 -0.156357 0.012279 1.138582 7.226395 35.115017 130.064835 392.754974 814.941467 798.018677 1836.988525 6610.574707 5132.170410 1007.030396 444.518250 998.622131 1346.504517 2654.999756 7463.695801 100472.515625 100658.085938 103732.132813 11756.579102 25663.792969 100684.625000 -0.031242 -0.039226 -0.052333 -0.074111 -0.105405 -0.138343 -0.164621 -0.132936 0.257287 2.445574 15.168452 88.629990 635.403564 6311.894531 38103.449219 26991.189453 40773.718750 100315.859375 100482.125000 14158.584961 2767.609863 8368.958008 20030.361328 101503.390625 114719.437500 108585.328125 104651.875000 169900.750000 113011.507812 49763.781250 101898.765625 -0.033231 -0.040070 -0.059250 -0.085621 -0.120996 -0.155334 -0.176130 -0.091619 0.567004 3.774909 19.935730 153.109238 2447.781738 100286.226563 100258.992188 103698.539063 134407.640625 101826.406250 107224.906250 83397.335938 8492.639648 21320.367188 114650.289062 102150.710938 106206.421875 179245.984375 109485.937500 200136.906250 104993.476563 80588.187500 22472.691406 -0.034676 -0.047073 -0.065027 -0.093700 -0.132336 -0.166653 -0.182653 -0.063602 0.721537 4.266201 18.880152 144.983643 3731.252197 100107.398438 100147.726563 102118.945313 165805.687500 105107.140625 162970.875000 128450.210937 25528.425781 7972.025391 93083.015625 100911.125000 100789.546875 51315.980469 18214.634766 43050.632813 96499.960938 16310.439453 1920.752563 -0.040541 -0.051288 -0.070151 -0.101291 -0.138938 -0.175943 -0.197422 -0.102683 0.522521 3.017777 11.872942 74.564331 1241.480469 34342.664063 100045.375000 100408.890625 17040.890625 32414.416016 76408.468750 103463.875000 22507.117188 2141.394043 5001.088867 41144.664063 33284.574219 3129.025635 874.440186 2013.938843 2935.175293 1089.808472 244.312622 -0.042161 -0.054594 -0.076042 -0.106878 -0.145821 -0.184952 -0.217547 -0.180839 0.106731 1.239704 4.646765 21.667953 169.345856 1424.722412 5547.586914 4362.536133 1110.086060 1806.128540 12362.397461 66939.703125 36129.445313 2835.321533 400.494904 616.824280 554.851440 179.119217 86.608940 126.430611 140.294006 75.365173 27.332788 -0.046086 -0.059204 -0.079766 -0.108555 -0.148905 -0.191922 -0.232402 -0.247325 -0.187647 0.112904 0.993332 4.177982 19.135479 78.704117 166.637619 156.010513 126.497131 1125.771118 45972.054688 100532.546875 100335.351563 11243.438477 377.886810 68.414108 63.680454 104.563255 155.986130 110.053886 37.543793 11.315822 3.488683 -0.049036 -0.061965 -0.081070 -0.108681 -0.150259 -0.194641 -0.238848 -0.284043 -0.310881 -0.306830 -0.198143 0.244719 1.822162 5.428223 10.295002 14.539920 49.719585 752.265625 24417.906250 100156.390625 100368.132813 7331.747070 422.606995 195.809647 533.203857 2104.956299 6464.964844 3066.256592 373.807861 31.139530 3.196350 -0.053007 -0.061071 -0.081635 -0.107322 -0.149375 -0.191610 -0.239567 -0.290900 -0.345434 -0.410939 -0.460840 -0.470703 -0.351341 0.153236 1.965822 9.160757 36.548626 194.762115 1784.230835 8528.763672 6342.353027 1557.262573 892.209717 2086.181885 13361.965820 65906.226563 103660.390625 100321.054688 3986.435791 128.999146 9.782114 -0.058439 -0.064406 -0.082954 -0.106888 -0.146845 -0.187457 -0.237981 -0.293374 -0.353717 -0.423601 -0.494295 -0.566769 -0.599441 -0.284729 1.840768 11.635770 38.310299 71.631409 161.166626 419.932922 1053.672119 5837.148926 31093.570313 35820.636719 103837.203125 200112.031250 162908.203125 101664.578125 10212.850586 212.870712 16.063711 -0.058107 -0.067002 -0.085785 -0.107772 -0.142060 -0.179654 -0.230824 -0.282902 -0.347666 -0.419290 -0.494358 -0.565931 -0.605447 -0.348896 1.329953 8.897140 28.808315 59.867222 117.989372 362.928375 3373.972168 103762.218750 103451.726563 146774.781250 120907.656250 135216.937500 200052.921875 102883.382813 3138.627686 119.585060 13.363567 -0.063168 -0.068402 -0.086335 -0.109741 -0.138913 -0.179315 -0.223601 -0.272925 -0.329970 -0.400653 -0.479195 -0.539476 -0.558614 -0.343459 0.784536 5.858496 28.075695 132.647354 452.007690 847.288696 5311.430176 105176.093750 103565.382813 111686.671875 145788.843750 101708.546875 34784.976563 3115.137207 323.885712 31.483870 6.190109 -0.070605 -0.076623 -0.092959 -0.114396 -0.140593 -0.175146 -0.213211 -0.259058 -0.313333 -0.377026 -0.450651 -0.497989 -0.482630 -0.254330 0.739851 6.057290 43.863289 305.188751 1449.341553 2088.898682 2371.262939 42529.644531 101083.570313 101079.210938 11967.924805 6324.847656 1662.635376 265.193726 50.566650 9.626514 2.099661 -0.079614 -0.084841 -0.098086 -0.119522 -0.141684 -0.171847 -0.209452 -0.250886 -0.301245 -0.359407 -0.422262 -0.468686 -0.415183 -0.079090 1.253627 7.334228 46.863518 327.520050 1431.120972 2180.194824 1058.389160 1505.802979 4597.987305 2973.272949 611.148315 247.152176 123.017975 52.258564 20.672419 5.781395 1.084497 -0.091082 -0.096191 -0.108843 -0.120593 -0.142776 -0.172770 -0.207139 -0.250311 -0.294623 -0.347708 -0.406726 -0.445131 -0.332820 0.398359 3.697876 16.501232 62.467285 261.114716 1171.244507 2580.520508 1774.814331 435.918579 173.773026 101.689285 44.169800 25.612629 24.942316 21.964745 12.444915 4.970799 2.196677 -0.100352 -0.103486 -0.114921 -0.128609 -0.148851 -0.175609 -0.209526 -0.247094 -0.290346 -0.339371 -0.394201 -0.415274 -0.136608 1.943799 15.065287 81.771957 275.773499 635.535767 3065.907959 10273.239258 6619.506348 1001.830750 102.330605 16.921131 5.523872 5.103223 8.801017 12.767740 13.767961 12.466068 13.162854 -0.112442 -0.120816 -0.130932 -0.144165 -0.161912 -0.184049 -0.216222 -0.257470 -0.296915 -0.338523 -0.388303 -0.378848 0.173848 5.045528 45.739368 342.278381 1558.864746 2538.126953 3236.007812 9437.614258 5565.386719 858.088318 90.588020 11.237848 2.056139 2.814046 11.463020 34.727589 64.816833 78.385048 111.067345 -0.128281 -0.139161 -0.149244 -0.158982 -0.183646 -0.202281 -0.230569 -0.263883 -0.304955 -0.340147 -0.379360 -0.354670 0.350809 7.017895 69.044075 634.904480 3664.802734 5637.808594 2124.184814 1735.987671 1079.862183 253.563583 40.472240 7.408884 2.218256 5.855330 32.621445 139.338486 324.276947 427.873230 1297.622681 -0.152843 -0.163886 -0.166647 -0.180949 -0.197068 -0.216489 -0.245553 -0.278719 -0.315018 -0.348825 -0.377604 -0.358980 0.214476 5.006423 48.189598 363.698364 1789.664185 2461.477051 918.562622 274.531616 131.415344 48.857925 17.920681 12.154691 9.410504 12.045406 59.224159 304.190765 763.603394 1614.022217 12311.402344 -0.182926 -0.181685 -0.194875 -0.207748 -0.216439 -0.236984 -0.267375 -0.294216 -0.325668 -0.357766 -0.390625 -0.389436 -0.123851 2.076526 16.158598 87.944550 297.316254 366.326752 173.318253 53.641701 24.029409 31.153206 86.723099 155.710266 113.730598 45.451393 57.147160 223.692001 599.962341 2458.120361 31252.666016 -0.211846 -0.212554 -0.219532 -0.214617 -0.198251 -0.217564 -0.258304 -0.304426 -0.345864 -0.372597 -0.401241 -0.421098 -0.350445 0.281298 3.310701 13.630461 34.044071 41.339581 26.789066 20.567833 47.182243 227.563370 1437.249878 3970.538086 2443.576172 449.818420 67.251328 81.200699 210.913055 1053.233643 8789.093750 -0.240915 -0.244735 -0.226380 -0.155384 -0.070320 -0.061221 -0.159378 -0.275345 -0.356982 -0.396085 -0.423698 -0.450907 -0.458339 -0.344550 0.135264 1.471640 3.671390 6.756240 23.312115 122.248917 493.479584 1869.021851 28492.263672 100055.484375 69779.203125 3966.673828 218.076050 31.630701 55.976078 293.582581 1877.261353 -0.278865 -0.270828 -0.193067 0.005458 0.235224 0.317263 0.085022 -0.185540 -0.352998 -0.424076 -0.449229 -0.478766 -0.502018 -0.506653 -0.457763 -0.212939 1.015150 11.847899 131.120941 1648.269043 15517.101563 30262.878906 106394.062500 100552.234375 100043.960938 13324.657227 417.715942 26.860731 23.853727 187.843185 2000.171997 -0.313824 -0.294349 -0.171669 0.182564 0.653765 0.827809 0.486583 0.020440 -0.298190 -0.435134 -0.483141 -0.505929 -0.526679 -0.546445 -0.556390 -0.350629 1.897180 29.530607 553.123535 20281.953125 100097.171875 101936.000000 156728.937500 103889.687500 100148.406250 6576.916992 278.676056 19.138903 13.210777 98.381142 866.708801 -0.362074 -0.335188 -0.160161 0.351155 1.262751 2.041375 2.052456 1.244313 0.271317 -0.276425 -0.482108 -0.542540 -0.565969 -0.579003 -0.579968 -0.348806 2.425943 39.546555 909.427307 53450.753906 100080.679688 100469.554688 103460.171875 19425.371094 6270.207031 860.543579 83.327805 17.097502 18.470039 37.637341 164.452469 -0.416173 -0.361727 0.014311 1.523911 5.914408 13.665776 17.654427 11.848489 4.315237 0.724666 -0.316563 -0.554974 -0.608165 -0.616814 -0.618223 -0.427995 1.757975 27.700039 493.685730 14161.200195 100916.171875 103409.046875 103043.585938 4102.117187 480.720459 106.085785 60.764252 178.518463 349.019135 213.752502 75.980186 -0.457108 -0.282503 0.922039 8.006889 43.131462 136.266281 213.387665 119.994301 32.069527 5.584857 0.383694 -0.503229 -0.648354 -0.663691 -0.666524 -0.544029 0.787939 13.092627 150.336395 2038.634888 33905.394531 114068.601562 103930.148438 15040.962891 644.147888 127.407623 473.031158 5853.505371 25340.916016 8377.658203 639.900696 -0.464523 -0.042134 3.394268 32.167553 259.920593 1420.208374 2644.266602 1133.593384 187.207642 21.463448 2.131150 -0.337837 -0.659770 -0.702001 -0.708945 -0.630945 0.202367 8.522153 127.773567 3736.420654 100270.664063 100443.460938 100386.367188 100240.210938 2247.903320 483.863129 4182.413086 103397.562500 101793.101563 100341.242188 5756.312012 -0.290730 0.313699 6.407043 73.627617 845.528015 7809.225586 17560.123047 5538.851074 550.628113 48.381947 4.194806 -0.169296 -0.666561 -0.735326 -0.734574 -0.670524 -0.050956 6.356091 108.872711 3383.022217 100087.773438 100435.367188 101069.468750 100825.226563 2331.963867 1812.129395 30124.101563 200053.828125 146296.000000 102873.140625 9365.867187 1.807682 1.768098 7.510088 79.213379 912.205261 8528.004883 19287.339844 6034.345215 592.817078 49.136505 4.416441 -0.102267 -0.670416 -0.742957 -0.668941 -0.423058 0.205886 3.858000 44.892838 744.065857 17658.843750 100635.226563 101791.773438 12465.944336 1027.939453 4211.886719 101135.859375 131372.468750 200163.812500 64305.492188 2196.660156 25.156523 14.936566 9.057571 40.130234 307.154236 1808.597900 3133.262939 1336.910034 222.533630 27.149380 3.139620 -0.142726 -0.649922 -0.577154 0.241591 2.902681 7.328129 10.246364 17.387056 98.777809 695.421448 2574.371826 2874.378174 1128.371338 369.992950 2370.815674 63363.812500 103043.570313 106102.195313 8104.644043 1220.405151 298.807648 143.086945 34.793659 20.773209 76.554459 249.100235 381.176758 241.100327 74.713219 16.171240 2.639052 -0.082248 -0.499085 0.437746 7.447064 43.950214 151.365311 200.828339 95.159943 35.130245 58.753208 147.773331 219.246750 149.442368 99.169273 544.255249 6214.604492 53299.371094 107510.476562 25858.625000 18552.701172 4375.199707 1428.900269 204.644196 35.700703 76.677071 346.504517 767.061157 574.638062 155.610672 27.725067 3.904831 0.144333 -0.108214 4.540935 60.030121 787.142578 6345.511719 10106.616211 2269.934082 228.026566 32.075634 18.912075 23.385969 20.083986 25.823841 204.242798 3945.125244 100983.718750 121456.890625 133369.359375 103889.601563 105936.835938 27049.359375 1286.665527 91.885971 145.613937 915.265991 2651.513916 1791.849854 366.593384 47.160069 5.822748 0.481858 0.567163 14.590502 301.193604 12203.979492 100074.015625 100279.234375 88764.242188 1703.763672 113.130890 14.484025 3.837486 2.628237 8.042266 82.589111 1225.378784 14684.360352 125829.523437 106040.625000 101737.125000 103817.367188 100890.703125 5660.877441 184.234665 131.721603 787.619507 2258.215332 1533.607666 341.619049 46.218410 8.479468 2.807640 2.044156 22.752632 627.753540 56643.183594 100297.890625 101657.234375 102871.523438 5284.274414 295.540527 35.834518 5.497364 1.019213 3.624078 27.802151 200.885849 1492.797363 33055.375000 107561.578125 112391.664062 103110.078125 101525.195313 6324.419922 209.497162 62.194805 228.984528 513.619629 392.600098 127.554703 57.724285 56.974514 34.225437 11.973075 18.570894 351.306305 14846.748047 100480.578125 103114.812500 106072.703125 4104.295898 484.671478 95.258057 19.524714 3.743450 8.366280 79.603317 627.846924 2565.634033 17861.806641 117803.414062 128339.976562 200114.265625 104136.539063 4983.979980 262.584900 30.307646 40.283543 72.081841 78.630821 208.925659 849.930115 1533.196045 681.056824 128.953247 23.296606 74.801514 1024.331055 9433.533203 16152.437500 5791.334961 2187.506104 1316.091797 410.924225 71.370743 11.007851 31.365002 680.532104 20528.169922 101002.710938 173609.515625 103784.093750 101145.453125 103445.367188 101118.367188 34491.414063 657.935547 33.908352 8.200419 18.930952 151.446106 2647.352783 41855.785156 100005.468750 28239.339844 1543.304810 101.111786 31.607607 80.192917 274.444611 552.231323 1107.779541 3565.394775 4727.203125 1229.638306 155.655212 19.495028 65.775909 2541.066895 100031.250000 100637.578125 131134.984375 120659.992187 102574.750000 100272.726563 100197.507813 37956.167969 695.864929 31.586872 4.547176 25.064692 513.788086 25636.316406 100015.484375 100065.437500 100139.218750 11268.337891 435.865631 265.107117 169.245941 77.457733 125.793945 679.661682 3130.190918 3974.233154 1136.076538 145.629776 18.232803 50.667439 1654.386353 100011.601563 100155.664063 102455.851563 42454.371094 72652.085938 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002132 -0.002607 -0.003130 -0.003713 -0.005935 -0.008786 -0.010016 -0.011218 -0.012203 -0.013019 -0.013571 -0.013784 -0.013684 -0.013275 -0.012592 -0.011624 -0.010546 -0.009356 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.002757 -0.003408 -0.005669 -0.006844 -0.010261 -0.012096 -0.013973 -0.015760 -0.017430 -0.018708 -0.021166 -0.021505 -0.021324 -0.019045 -0.017928 -0.016500 -0.014783 -0.013029 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002177 -0.002796 -0.003531 -0.006040 -0.007550 -0.011382 -0.013942 -0.016690 -0.021383 -0.024392 -0.027109 -0.029357 -0.030795 -0.031398 -0.031171 -0.029957 -0.028039 -0.025550 -0.022704 -0.018318 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002060 -0.002681 -0.003481 -0.006129 -0.007854 -0.012048 -0.015279 -0.020827 -0.025385 -0.030171 -0.034851 -0.039269 -0.044296 -0.047726 -0.048939 -0.048545 -0.048148 -0.043688 -0.038271 -0.033754 -0.029096 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002466 -0.003265 -0.005878 -0.007737 -0.012053 -0.017465 -0.022401 -0.028474 -0.035176 -0.043879 -0.050704 -0.058200 -0.065103 -0.069569 -0.072064 -0.071982 -0.069375 -0.064390 -0.058228 -0.052824 -0.044264 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002177 -0.002917 -0.005382 -0.007208 -0.009689 -0.017097 -0.022595 -0.029789 -0.039799 -0.048998 -0.057447 -0.067378 -0.075473 -0.083158 -0.089096 -0.092053 -0.092922 -0.090485 -0.087201 -0.079461 -0.071210 -0.064921 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.002501 -0.003408 -0.006349 -0.008686 -0.015703 -0.021397 -0.030415 -0.040241 -0.050975 -0.059966 -0.072175 -0.082916 -0.092441 -0.097403 -0.101366 -0.105285 -0.107569 -0.107209 -0.104156 -0.098266 -0.090852 -0.082387 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002060 -0.002816 -0.005378 -0.007419 -0.012045 -0.019011 -0.027732 -0.038036 -0.050027 -0.060211 -0.076331 -0.086021 -0.082066 -0.068444 -0.059257 -0.066676 -0.083688 -0.081406 -0.057613 -0.048189 -0.062959 -0.087050 -0.096257 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002253 -0.003130 -0.006042 -0.010073 -0.015900 -0.023875 -0.033313 -0.045961 -0.060555 -0.075359 -0.085364 -0.067658 0.001279 0.120259 0.217597 0.228100 0.206224 0.292929 0.468398 0.559997 0.404883 0.137565 -0.039798 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.004120 -0.006634 -0.008676 -0.013494 -0.020285 -0.032989 -0.045715 -0.061588 -0.077666 -0.091499 -0.079771 0.014220 0.329967 0.917700 1.429272 1.655962 1.738645 2.602870 4.445622 5.463102 3.735696 1.592257 0.389587 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001772 -0.003886 -0.004871 -0.009347 -0.013528 -0.019319 -0.029961 -0.039838 -0.056571 -0.075820 -0.092350 -0.104925 -0.057543 0.217725 1.138022 3.051893 5.316955 7.084778 8.974397 15.409483 32.375568 41.255527 27.390846 9.108799 2.056817 0.000000 0.000000 0.000000 0.000000 -0.001664 -0.002011 -0.003532 -0.007689 -0.009240 -0.014453 -0.019528 -0.025524 -0.039382 -0.052470 -0.068802 -0.089673 -0.110847 -0.117286 -0.033066 0.462936 2.249253 6.870061 15.503316 28.270027 42.872940 71.447868 184.728134 262.130524 145.493301 38.447628 6.928493 0.000000 0.000000 0.000000 -0.001760 -0.003395 -0.005690 -0.006790 -0.009841 -0.013711 -0.018132 -0.025175 -0.035751 -0.050261 -0.063947 -0.084802 -0.110053 -0.132830 -0.143858 -0.047286 0.546546 2.963561 11.229462 40.643181 115.529594 197.738953 242.050201 584.864136 915.657715 479.512299 93.831017 13.933336 -0.001164 0.000000 -0.002924 -0.003636 -0.006187 -0.007585 -0.009178 -0.014778 -0.019208 -0.030736 -0.038576 -0.049363 -0.062651 -0.080330 -0.106154 -0.132358 -0.161052 -0.179961 -0.107531 0.404514 2.909233 15.314852 78.811615 324.705658 613.769653 477.047119 717.112488 1065.891357 514.767944 106.169456 14.665709 -0.001407 -0.002941 -0.003741 -0.006425 -0.008121 -0.011405 -0.015900 -0.023050 -0.029430 -0.042655 -0.051412 -0.064721 -0.082899 -0.104888 -0.130519 -0.163519 -0.197796 -0.224800 -0.199100 0.151397 2.224974 14.103024 85.865173 368.433655 647.976562 452.453674 316.784058 377.704132 201.768387 48.516159 7.967818 -0.005830 -0.004891 -0.006384 -0.009491 -0.012024 -0.017098 -0.023492 -0.032963 -0.043399 -0.057708 -0.070783 -0.090014 -0.109160 -0.134325 -0.164100 -0.208587 -0.250521 -0.281931 -0.290209 -0.113454 1.153252 7.863029 41.060268 150.725830 252.969803 174.319077 87.967575 69.996338 39.528294 12.464298 2.576150 -0.008131 -0.005943 -0.009303 -0.012089 -0.018614 -0.027179 -0.035841 -0.044905 -0.060287 -0.077059 -0.101176 -0.119605 -0.144674 -0.175041 -0.213940 -0.257895 -0.305815 -0.344858 -0.375025 -0.306331 0.316840 3.288223 14.025030 36.373077 53.022617 39.532192 20.100084 11.443262 6.015870 2.199169 0.550310 -0.009407 -0.010321 -0.013900 -0.016675 -0.027214 -0.035400 -0.047482 -0.063017 -0.083586 -0.105563 -0.127447 -0.148397 -0.179554 -0.209926 -0.250408 -0.299262 -0.355081 -0.397533 -0.431777 -0.425349 -0.134998 1.178444 4.778162 11.025367 14.888104 11.086047 5.107958 2.030060 1.029352 1.390418 2.401000 -0.013622 -0.014866 -0.016996 -0.025857 -0.034420 -0.047300 -0.062193 -0.084751 -0.104680 -0.132001 -0.155462 -0.178922 -0.202585 -0.230878 -0.276840 -0.319428 -0.356209 -0.397396 -0.434209 -0.407695 -0.171831 0.493022 1.977018 4.181396 5.500515 4.634660 2.969510 1.866182 2.756042 8.287222 17.365765 -0.016691 -0.017368 -0.022251 -0.031640 -0.042976 -0.059853 -0.083463 -0.107198 -0.130557 -0.153755 -0.167813 -0.153134 -0.107300 -0.073337 -0.059972 -0.046823 0.031356 0.134548 0.191387 0.564336 1.659903 3.332026 4.060758 4.568840 8.095588 16.166193 21.915913 17.658705 15.230931 35.763954 81.700600 -0.019716 -0.022971 -0.029689 -0.040379 -0.056425 -0.078512 -0.106775 -0.130904 -0.149960 -0.159592 -0.086154 0.173308 0.677891 1.343287 1.874527 2.472965 3.830960 5.504107 6.156909 7.924026 18.127129 32.952152 34.617397 30.074085 77.675781 282.938568 454.448975 275.196747 95.324257 116.152740 250.905579 -0.023895 -0.029173 -0.036427 -0.047804 -0.067712 -0.094646 -0.127525 -0.148511 -0.167055 -0.096868 0.292812 1.624431 4.997522 11.087230 17.907784 22.735125 39.721504 66.460777 65.468803 65.103157 173.496979 418.005554 401.045074 265.662415 996.970215 9346.613281 25686.947266 8623.406250 939.672607 462.477051 1088.810913 -0.026253 -0.032629 -0.041651 -0.055494 -0.082975 -0.114215 -0.142060 -0.167839 -0.163175 0.066451 1.271373 6.455659 27.082003 91.889915 201.222107 229.617325 404.463196 949.414795 884.458435 545.382751 2593.598877 11365.238281 9205.215820 3720.705078 12199.032227 100472.773438 100336.765625 100757.796875 9389.491211 1554.639038 4448.820801 -0.028392 -0.035850 -0.048324 -0.066140 -0.096577 -0.128949 -0.160864 -0.188059 -0.147731 0.309951 3.033066 19.058975 131.809433 926.015747 3138.894775 2728.579346 3661.892090 15004.977539 12024.766602 5629.022461 39142.511719 100775.851563 113604.453125 115199.023437 134897.312500 107802.265625 101376.812500 103749.750000 29841.640625 2683.961426 4317.706055 -0.030321 -0.041047 -0.054924 -0.078511 -0.109540 -0.145144 -0.178002 -0.202594 -0.123534 0.523542 4.634469 39.496410 458.343170 6585.235352 41904.917969 28839.464844 13517.332031 82780.539063 147151.453125 106405.710937 134644.781250 103068.507813 200143.500000 138226.921875 112055.382812 170804.890625 102278.343750 105593.171875 16554.455078 2656.825195 1295.547607 -0.040766 -0.045600 -0.062365 -0.086457 -0.121206 -0.155923 -0.192269 -0.215866 -0.128809 0.514931 4.705126 43.965897 640.287842 11129.083008 86169.742188 57173.101563 10901.107422 65722.664063 121296.359375 103444.632813 123599.687500 108367.695312 179121.750000 110264.226562 101516.281250 52233.480469 32429.062500 12294.240234 3426.889648 1060.962646 327.447693 -0.045816 -0.050953 -0.068352 -0.096142 -0.132569 -0.168932 -0.208308 -0.236415 -0.189411 0.235021 2.892420 25.719772 280.004547 2868.235596 13337.161133 10306.529297 2906.829346 33785.562500 102876.062500 104329.773438 104032.328125 12797.042969 8597.598633 37740.437500 30090.593750 3229.528076 832.092651 685.666138 488.139557 202.839569 71.216370 -0.049128 -0.057701 -0.075453 -0.104526 -0.138761 -0.179724 -0.223601 -0.263387 -0.265697 -0.089827 0.999048 8.009471 54.979187 318.480927 849.665100 715.545410 508.386169 5001.654297 96221.898438 200114.906250 123505.093750 9910.694336 739.958984 678.456421 528.177551 178.774170 94.520813 104.259918 82.031898 38.011322 14.037049 -0.051426 -0.061636 -0.080470 -0.108035 -0.143181 -0.186877 -0.236029 -0.283147 -0.322812 -0.307827 -0.037647 1.466122 8.410599 28.774235 55.705624 59.299576 140.360367 3148.623779 101288.609375 102328.531250 102218.703125 64973.871094 1251.288818 139.802277 64.145905 114.538788 210.897858 147.077011 51.069908 13.664351 4.224492 -0.052964 -0.065503 -0.083252 -0.112226 -0.147194 -0.192382 -0.240840 -0.295514 -0.348255 -0.397744 -0.399659 -0.196305 0.593509 2.415017 4.652221 8.867159 69.825027 2083.792480 100222.625000 102007.453125 113383.968750 47842.531250 3193.532471 338.507507 344.362335 2882.309814 12391.719727 5225.301758 541.896606 43.164742 12.192084 -0.060222 -0.071821 -0.088342 -0.116114 -0.152505 -0.193851 -0.242627 -0.299746 -0.360126 -0.424442 -0.491025 -0.531464 -0.488858 -0.327710 0.109000 2.631231 25.527552 346.742096 6026.915039 48756.531250 50516.550781 31015.222656 4979.207520 911.746460 3016.724609 101432.617188 100480.562500 100078.976563 6908.610352 180.886520 54.341061 -0.066346 -0.076021 -0.096880 -0.123771 -0.155036 -0.193727 -0.239717 -0.294281 -0.355633 -0.427055 -0.503260 -0.580065 -0.645976 -0.644289 -0.306037 1.648542 11.048359 65.293488 389.827057 2025.040039 9515.023437 20644.023438 13810.367188 5695.985840 15617.445313 114648.023437 103110.421875 100298.531250 20515.833984 329.838806 145.783752 -0.072441 -0.084423 -0.099939 -0.125519 -0.156527 -0.195782 -0.235018 -0.284447 -0.344299 -0.411483 -0.488101 -0.560811 -0.638682 -0.637222 -0.116432 3.291615 24.557392 151.700821 600.335815 2375.061035 39239.246094 114021.234375 200388.093750 72468.812500 28378.816406 119873.773437 106042.046875 100449.085938 5245.799316 180.518723 151.183456 -0.080505 -0.088986 -0.110881 -0.131220 -0.159752 -0.193050 -0.230184 -0.273750 -0.324573 -0.383349 -0.445790 -0.512147 -0.586244 -0.542152 0.425035 9.552547 101.136925 1143.581543 8627.027344 16590.339844 67494.570313 130308.656250 200159.265625 110379.882812 12847.521484 10394.430664 8376.976562 3523.512939 390.688141 47.063347 51.909016 -0.086000 -0.095337 -0.116550 -0.139366 -0.166166 -0.196933 -0.228739 -0.269547 -0.310889 -0.354831 -0.395181 -0.462794 -0.520038 -0.394576 1.197096 18.018246 246.740036 5106.201172 86215.265625 100723.984375 33004.042969 52726.515625 60260.285156 22339.722656 2359.362305 898.756042 413.407104 137.298386 33.704510 8.795141 9.793256 -0.093724 -0.101388 -0.120769 -0.148155 -0.174071 -0.205133 -0.237413 -0.268025 -0.306543 -0.341557 -0.376209 -0.424929 -0.437842 -0.070113 2.609795 22.192856 265.060638 4786.477051 70341.773438 101641.968750 22886.339844 3204.583740 2227.074707 1059.358032 241.502304 84.840187 39.301239 14.890489 4.945420 1.746073 1.553043 -0.102424 -0.114939 -0.130808 -0.149618 -0.177864 -0.205341 -0.238911 -0.271913 -0.311227 -0.340411 -0.380640 -0.403149 -0.240136 1.242072 10.617415 58.409466 264.589294 1823.505249 16817.519531 73089.085938 34039.875000 3057.433838 321.231506 85.563133 28.007717 10.462349 6.164212 5.138358 5.101918 4.435729 4.557206 -0.114403 -0.125883 -0.139475 -0.159611 -0.180631 -0.210158 -0.242133 -0.271341 -0.313232 -0.347747 -0.389081 -0.360885 0.269476 5.990588 58.521812 487.933228 2768.531250 6200.975586 101588.273438 100659.015625 100276.054688 14715.560547 507.665710 47.677368 8.509139 3.520132 8.842649 26.464611 45.172192 44.259815 39.510658 -0.128928 -0.140017 -0.149116 -0.167589 -0.193830 -0.217690 -0.248824 -0.277305 -0.316573 -0.354283 -0.388328 -0.294617 1.101355 16.227270 228.131927 4313.564453 56826.042969 102268.570313 93517.367188 100899.781250 100156.429688 12313.174805 507.202667 53.799828 8.867564 8.990879 54.558102 261.369629 603.005310 522.541199 439.998749 -0.144036 -0.153470 -0.167040 -0.182390 -0.205912 -0.229469 -0.256326 -0.287106 -0.325550 -0.360450 -0.387357 -0.248042 1.544112 24.062195 416.735168 11122.001953 100040.828125 100514.570313 69455.757813 36128.328125 17721.685547 2057.294922 215.124664 38.093620 9.004414 26.508295 260.178436 2262.995361 8590.131836 6002.278809 9347.837891 -0.167668 -0.175903 -0.189149 -0.203332 -0.222568 -0.245000 -0.275618 -0.304245 -0.338807 -0.374728 -0.400500 -0.284704 1.189027 17.131536 243.052032 4681.233887 69779.929688 100069.382813 19644.757813 1832.780518 721.026794 216.351944 61.025711 19.227612 9.942767 44.909611 591.751892 8536.222656 42113.625000 31107.550781 102301.960938 -0.197566 -0.209089 -0.217552 -0.229365 -0.246258 -0.271761 -0.296860 -0.321643 -0.359655 -0.387560 -0.410773 -0.355995 0.333542 6.640775 64.874947 590.285645 3367.643799 4688.101562 1445.393311 234.853180 66.880737 37.018864 36.158466 41.095383 33.113800 48.147453 450.729218 5110.792969 23713.681641 32621.800781 101653.898438 -0.227818 -0.234552 -0.245521 -0.261932 -0.282656 -0.299540 -0.328188 -0.351806 -0.380871 -0.405095 -0.425357 -0.417770 -0.199186 1.423193 10.923471 54.210556 154.555756 201.136780 104.876495 39.759689 41.000401 79.332771 219.735657 423.920898 299.965820 97.810883 135.905426 802.871338 2483.527344 7215.456055 101854.484375 -0.263762 -0.267991 -0.279912 -0.289327 -0.302512 -0.316991 -0.347962 -0.380642 -0.408857 -0.429204 -0.446518 -0.461179 -0.429598 -0.131957 1.111653 4.993380 11.311290 16.279068 30.994152 135.788651 504.003204 869.374817 1616.707520 4027.673584 2266.941650 421.659943 69.657524 91.378975 243.803467 1301.288818 22284.191406 -0.298327 -0.310180 -0.319922 -0.313707 -0.302548 -0.308971 -0.340588 -0.390801 -0.434421 -0.460188 -0.478036 -0.494086 -0.508137 -0.484452 -0.338727 0.130388 1.764629 13.156014 148.503235 2066.058350 20308.230469 39989.152344 11917.989258 12847.289063 6617.062012 913.498047 86.366318 20.021404 67.572006 1037.628296 42044.554688 -0.331928 -0.347929 -0.346163 -0.288622 -0.168626 -0.037283 -0.031870 -0.165339 -0.334097 -0.452443 -0.510232 -0.530606 -0.546265 -0.558853 -0.556542 -0.315122 2.062624 33.098061 681.955200 26900.154297 100028.507813 100264.703125 102091.085938 11004.113281 3820.881592 601.414368 63.018581 9.929141 32.166180 453.467529 10195.605469 -0.374325 -0.375589 -0.280406 0.131928 1.219295 2.801702 3.462054 2.407049 0.800567 -0.122343 -0.467549 -0.560805 -0.585635 -0.601139 -0.600419 -0.339323 2.561411 44.295059 1130.646729 80572.507813 100046.468750 100152.171875 100438.187500 11562.708008 824.876343 156.506027 28.684916 10.458910 17.577545 100.164642 802.817810 -0.413131 -0.339161 0.253786 3.072630 14.579015 38.210514 54.306328 33.957527 10.948904 2.180043 -0.088600 -0.536885 -0.626609 -0.637589 -0.637880 -0.426219 1.945368 30.592314 562.549133 20357.718750 100595.648438 101950.210938 101840.929688 4427.006348 297.440460 88.077446 61.714367 80.246277 111.256363 83.017387 86.600960 -0.432087 -0.117509 2.391530 21.554644 154.470032 730.977539 1221.375610 590.232178 112.613861 15.280495 1.427644 -0.388618 -0.643102 -0.683536 -0.686797 -0.557147 0.768663 13.450978 153.925751 1902.910522 21883.855469 120359.726562 100980.984375 7835.484863 718.232056 535.658752 540.214661 1135.450684 2324.636963 1151.328613 175.420654 -0.410456 0.433442 8.885463 112.980911 1654.739014 21185.255859 56725.156250 14596.142578 1052.781738 69.037689 5.550126 -0.024450 -0.644352 -0.726971 -0.727875 -0.653015 0.130410 7.610501 100.788467 2192.180176 100436.304688 101372.375000 103318.335938 65387.417969 3033.194092 3918.705078 6053.080566 20876.662109 49333.503906 13074.295898 866.248840 -0.275238 1.120095 17.626036 319.319061 9311.615234 100013.234375 100014.156250 100008.320313 5092.496582 176.256073 11.051132 0.331761 -0.626355 -0.747679 -0.761299 -0.710370 -0.134769 5.697273 83.650665 1980.257935 100606.531250 109328.382812 156768.718750 88190.843750 7020.407715 12760.297852 105007.601563 115722.859375 185464.562500 32916.882813 1535.444580 1.124675 2.140306 19.921713 325.074768 11149.958984 100075.984375 100086.757813 100044.289063 5550.984375 190.277985 11.507788 0.438229 -0.638325 -0.753753 -0.719704 -0.542427 -0.012468 3.238272 38.973019 571.328430 9499.600586 98671.429688 162906.515625 91883.742188 7471.943848 18577.169922 102261.179688 103205.289063 109667.210937 55030.042969 1171.843750 15.870741 8.928698 15.495283 147.727127 2183.432617 28516.816406 86475.648438 19448.125000 1265.926392 87.230545 7.909587 0.235081 -0.659239 -0.642795 -0.102386 1.565397 4.372951 6.645659 15.241440 106.517174 895.301819 7449.638672 32343.611328 19686.031250 2582.274414 8492.949219 101507.000000 113709.742187 130364.656250 29437.103516 1266.445923 220.407974 75.016304 25.033920 60.444561 385.783112 1680.990601 2915.720947 1595.749146 338.051147 50.377365 6.265193 0.194286 -0.581447 0.027202 4.437114 26.469408 77.365280 101.279846 50.330307 31.370546 124.554565 648.492554 1710.749634 1261.258057 390.021271 1344.017212 28070.601563 169848.812500 126077.210937 104072.820313 6064.476074 4671.784668 798.905151 115.735703 66.323204 501.083069 4919.417480 21466.445313 12303.099609 1457.568481 127.166794 11.568675 0.629310 -0.303221 2.605412 33.829609 322.196411 1884.923218 2869.417725 854.202148 108.251495 27.301929 53.496964 97.772697 79.302841 62.405632 532.162476 30353.517578 101126.460938 103966.093750 138076.265625 68675.195313 110104.828125 8706.070312 579.652466 118.254776 1342.122559 31160.056641 100053.257813 100029.335938 6038.188477 279.814789 18.652170 1.298304 0.234427 8.859034 149.668915 3403.604736 63178.882813 100023.890625 14830.252930 601.190308 41.956131 8.465688 7.477393 7.728608 16.605228 197.930664 5336.089355 100437.085938 109379.375000 150947.656250 101936.710938 200088.718750 60828.894531 1950.787354 161.833450 1144.463379 23301.875000 100008.359375 86135.164063 5092.154785 262.118073 19.633629 2.909086 1.285367 13.045960 279.714661 10078.934570 100025.476563 100073.632813 63276.828125 1322.297119 71.625107 8.870942 1.974870 2.605615 10.142168 50.201500 416.171997 2745.888916 9300.306641 55694.660156 101602.046875 115493.148437 64408.230469 1968.863037 133.633148 306.428741 2865.859131 11119.779297 6570.285156 987.302856 117.924057 42.541496 22.259615 8.092402 11.505647 161.628464 3717.991211 88351.609375 100115.898438 18180.976563 780.369324 74.767395 15.961334 4.380736 4.782125 16.866148 57.111797 228.838455 834.544739 6982.043457 102990.601563 104011.875000 61760.359375 16581.662109 1583.092529 135.900284 57.190891 214.601578 480.616425 379.797577 205.537766 434.942657 682.904175 339.878113 73.822609 15.343405 42.885780 411.696167 2454.476074 3797.228516 1191.804077 225.382050 86.867729 35.303936 10.553009 6.758211 26.511845 201.823364 2374.194092 11746.956055 29628.496094 100785.718750 100276.093750 101171.250000 100462.695313 5172.954102 240.601868 22.795912 19.391087 36.080647 107.110519 1063.083130 10171.404297 25635.441406 7161.494629 684.177490 60.249630 21.790056 68.080414 184.984665 222.148163 156.041473 150.405502 146.436554 67.602318 17.563868 6.949973 32.993835 507.898499 13660.692383 100394.070313 65165.839844 102360.976563 100252.937500 100069.304688 100040.242188 6042.790527 246.868073 16.853975 4.112959 17.809847 261.855652 7160.234863 100004.750000 100014.570313 100029.609375 3684.688477 184.050827 73.782043 112.328972 242.653778 216.974121 114.352219 124.116371 132.833099 63.093746 16.401962 5.060022 23.771399 369.824432 7594.025391 60594.832031 29383.205078 12665.418945 21427.146484 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001883 -0.002333 -0.002856 -0.003456 -0.005536 -0.006522 -0.009597 -0.010927 -0.012239 -0.013407 -0.014292 -0.014887 -0.015124 -0.014912 -0.014440 -0.013590 -0.012564 -0.011372 -0.010081 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002415 -0.003021 -0.003766 -0.006241 -0.007550 -0.011228 -0.013354 -0.015439 -0.017469 -0.020941 -0.022464 -0.023484 -0.023813 -0.023520 -0.022636 -0.019696 -0.017941 -0.016125 -0.014074 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002382 -0.003064 -0.003905 -0.006655 -0.008343 -0.012569 -0.015505 -0.020376 -0.023934 -0.027418 -0.030544 -0.032964 -0.034678 -0.036340 -0.035944 -0.034434 -0.032231 -0.029376 -0.026059 -0.022675 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002238 -0.002937 -0.003849 -0.006716 -0.008733 -0.013400 -0.018734 -0.023422 -0.028708 -0.034119 -0.040994 -0.046958 -0.051193 -0.055744 -0.057097 -0.056731 -0.054401 -0.050805 -0.045998 -0.039250 -0.033676 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002700 -0.003608 -0.006438 -0.008552 -0.013352 -0.019470 -0.025366 -0.032236 -0.041413 -0.049210 -0.057357 -0.064856 -0.070845 -0.076165 -0.079682 -0.080571 -0.077701 -0.073352 -0.067922 -0.060225 -0.052189 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002382 -0.003219 -0.005877 -0.007957 -0.012637 -0.019083 -0.025590 -0.035273 -0.044969 -0.053719 -0.063965 -0.072597 -0.081759 -0.089775 -0.096602 -0.098398 -0.098454 -0.098626 -0.096041 -0.089050 -0.079642 -0.070816 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002738 -0.003766 -0.006995 -0.009688 -0.017486 -0.024067 -0.034548 -0.045531 -0.054975 -0.066881 -0.078518 -0.082866 -0.078907 -0.076892 -0.082808 -0.096174 -0.108427 -0.105499 -0.101825 -0.102548 -0.099807 -0.090815 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002253 -0.003108 -0.005869 -0.008188 -0.013415 -0.021244 -0.031530 -0.043058 -0.054313 -0.068477 -0.079457 -0.065915 -0.002523 0.100844 0.174106 0.149065 0.062277 0.024437 0.048192 0.072383 0.028517 -0.047679 -0.091882 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002466 -0.003432 -0.006648 -0.011157 -0.017711 -0.026961 -0.037976 -0.053569 -0.067456 -0.079789 -0.058035 0.084891 0.484697 1.267985 1.882333 1.746580 1.215722 1.162570 1.677115 1.916270 1.366590 0.581710 0.093877 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001909 -0.002663 -0.006859 -0.009149 -0.014517 -0.023734 -0.034240 -0.050569 -0.066060 -0.082847 -0.082043 0.036356 0.606235 2.643577 7.239604 11.483474 10.491173 7.910041 9.381697 17.570976 22.097570 14.876240 5.653171 1.342662 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001596 -0.003825 -0.004880 -0.009470 -0.013992 -0.021604 -0.032156 -0.045067 -0.062357 -0.081558 -0.099250 -0.072803 0.231512 1.921204 8.948972 28.769814 51.246155 51.354862 43.781010 75.974228 206.514282 319.195007 176.017227 43.170494 7.730505 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001810 -0.002143 -0.007315 -0.008877 -0.014127 -0.019653 -0.027763 -0.042625 -0.056435 -0.076236 -0.096573 -0.115008 -0.062175 0.451385 3.676044 19.645952 72.798866 159.317703 243.845795 319.197418 579.065063 2688.638184 5546.099609 2087.731445 297.007843 30.498335 0.000000 0.000000 0.000000 -0.001596 -0.001956 -0.003615 -0.006137 -0.009206 -0.012929 -0.019059 -0.026607 -0.039256 -0.052387 -0.068009 -0.094553 -0.118428 -0.140428 -0.084786 0.476632 4.068089 22.840733 102.727776 380.765930 1648.083740 3795.488525 3448.569336 21462.935547 62914.281250 14598.762695 1052.794922 73.429352 -0.001188 0.000000 -0.001607 -0.003245 -0.005600 -0.006808 -0.008210 -0.013650 -0.018479 -0.028324 -0.037736 -0.047907 -0.062643 -0.084664 -0.111924 -0.140816 -0.170234 -0.140597 0.263243 2.884460 17.475925 102.178551 908.570862 10232.263672 31256.179688 13055.748047 26687.882813 77562.710938 19285.845703 1221.915161 77.964424 -0.001447 0.000000 -0.003313 -0.005797 -0.007262 -0.009000 -0.015953 -0.021181 -0.028132 -0.039085 -0.050307 -0.064295 -0.083904 -0.108377 -0.139782 -0.175366 -0.207295 -0.211520 -0.012024 1.451630 10.418293 85.611359 1000.417236 12199.791992 41933.425781 13925.465820 5533.023926 9389.261719 3373.700439 417.232666 38.229797 -0.003049 -0.004507 -0.005754 -0.007357 -0.010626 -0.016994 -0.021131 -0.029307 -0.038258 -0.051975 -0.067784 -0.086836 -0.108890 -0.137166 -0.175293 -0.221113 -0.260504 -0.290638 -0.226315 0.491126 5.318286 40.955334 363.526703 2504.539795 6122.339355 2773.295654 743.744568 593.956543 282.454559 65.437111 10.453022 -0.007730 -0.005461 -0.007152 -0.010613 -0.017214 -0.021989 -0.031701 -0.040498 -0.053787 -0.073396 -0.094546 -0.115166 -0.143090 -0.178234 -0.218028 -0.269447 -0.319703 -0.359627 -0.358926 -0.003591 2.462101 17.612959 96.777725 348.780426 584.351746 347.276123 118.263451 51.738266 26.467051 8.586767 1.823446 -0.008906 -0.008260 -0.011343 -0.016347 -0.023045 -0.030990 -0.041325 -0.057113 -0.074653 -0.098518 -0.121839 -0.149363 -0.180998 -0.218808 -0.261327 -0.316362 -0.377716 -0.416700 -0.439108 -0.257802 1.157867 8.749775 41.956947 120.345016 175.946609 105.945992 33.666920 9.784348 3.186849 0.988028 0.622156 -0.010087 -0.012343 -0.016667 -0.021852 -0.030042 -0.041021 -0.055646 -0.074371 -0.098542 -0.124511 -0.152732 -0.181493 -0.212885 -0.252027 -0.299203 -0.354944 -0.401008 -0.448615 -0.451060 -0.219392 0.821448 4.431830 16.485172 43.191948 57.735146 35.319954 13.013472 4.067265 1.714231 1.463337 2.411661 -0.014285 -0.015519 -0.021634 -0.029558 -0.038959 -0.055326 -0.073807 -0.097979 -0.122779 -0.152492 -0.179202 -0.206639 -0.225635 -0.249387 -0.265353 -0.280816 -0.276493 -0.225828 0.069858 1.522505 5.904351 12.953298 16.127998 16.482769 17.563360 19.147806 18.729038 15.421985 11.442247 9.138549 9.291532 -0.020208 -0.021734 -0.025626 -0.035491 -0.048954 -0.068194 -0.094014 -0.122123 -0.149690 -0.179784 -0.198864 -0.167241 -0.064122 0.113369 0.318755 0.545568 0.998978 1.836231 3.754427 14.301960 59.527737 153.188339 162.833176 72.604195 58.005718 155.301987 248.505783 177.980453 92.899811 50.763275 33.070065 -0.022549 -0.024854 -0.032686 -0.041768 -0.060486 -0.083785 -0.115572 -0.145722 -0.173381 -0.190425 -0.135186 0.144993 0.949530 2.564690 4.443172 5.982001 9.628598 16.111139 26.136574 93.304611 590.111084 2293.191162 2221.335449 601.245911 517.591614 2924.520508 6753.185059 3055.461182 756.096741 241.912354 110.854034 -0.024798 -0.028993 -0.037221 -0.053245 -0.073857 -0.101735 -0.135178 -0.166263 -0.194333 -0.180769 0.068019 1.234861 5.599799 16.634638 31.854912 39.077080 61.801033 123.945740 191.078354 637.161560 7190.080078 46272.824219 37585.980469 5012.891113 3871.583252 77915.320313 102309.960938 70822.890625 7217.506348 1038.182129 261.228363 -0.028770 -0.033516 -0.045329 -0.061963 -0.085853 -0.117612 -0.154050 -0.186755 -0.213536 -0.140784 0.469421 4.087480 21.533718 90.108788 194.533096 208.883530 295.354675 855.146851 2583.432617 6420.278809 102111.789063 106025.632813 108045.406250 68072.281250 18257.742188 102453.906250 121327.984375 200154.281250 63522.449219 4076.521973 399.783661 -0.034964 -0.040116 -0.053243 -0.071500 -0.098332 -0.132112 -0.174524 -0.205720 -0.233713 -0.106490 0.913444 8.151046 55.536224 299.314240 796.797607 717.152832 811.954041 7121.281250 100998.859375 105794.390625 146512.687500 102816.125000 109181.843750 200368.218750 93720.343750 92923.859375 134635.796875 170000.921875 103115.093750 5371.701172 358.369781 -0.040853 -0.047697 -0.062775 -0.084204 -0.111905 -0.149235 -0.194599 -0.226033 -0.253837 -0.123047 0.988703 9.310782 65.849648 391.118500 1143.992920 992.409180 1291.211060 47008.437500 100669.781250 102322.976563 200120.875000 108876.546875 106061.179688 91012.304688 46939.945313 7683.647461 14326.750977 29492.195313 14291.125000 1628.350464 170.356522 -0.049294 -0.054672 -0.072119 -0.093635 -0.125657 -0.161745 -0.207309 -0.248137 -0.282499 -0.210529 0.545609 5.621733 38.697750 188.654739 453.239197 441.765717 933.285339 42115.902344 100705.195313 102227.312500 104628.710938 24204.617188 13220.890625 5222.208008 3336.969482 936.597961 1446.377441 3197.702148 2052.717529 427.977783 65.265259 -0.051940 -0.062234 -0.080649 -0.104702 -0.136279 -0.176046 -0.221385 -0.269772 -0.312820 -0.310716 0.001765 1.987912 11.253551 41.269497 86.170616 96.492165 299.870636 5216.077148 98378.320313 200207.375000 110679.257812 6398.105469 833.633606 327.428467 193.650284 147.664124 499.257843 1241.564331 845.466125 175.089371 27.246401 -0.058424 -0.071993 -0.085681 -0.113081 -0.144013 -0.183087 -0.235851 -0.289762 -0.335347 -0.373898 -0.325241 0.153487 2.038724 6.598917 12.366993 19.108614 100.478470 1916.964600 101625.304688 104914.460938 120171.718750 43439.097656 4196.396973 365.304535 59.452888 77.831757 185.676315 278.985107 175.102936 53.383297 15.334036 -0.065552 -0.079204 -0.095281 -0.120542 -0.151363 -0.189776 -0.240752 -0.296309 -0.348962 -0.412014 -0.455209 -0.413926 -0.132015 0.460653 1.430246 5.158210 53.291710 1137.273315 57515.890625 131211.546875 200124.734375 112376.203125 51688.160156 1403.690674 186.030258 820.000793 2351.279541 1426.066528 228.824020 46.883606 74.502579 -0.073913 -0.086197 -0.104527 -0.128493 -0.158134 -0.193712 -0.240900 -0.294958 -0.359437 -0.419862 -0.485970 -0.555338 -0.568352 -0.532519 -0.312796 1.679593 21.083309 268.794769 4108.815918 81012.671875 111664.601562 102751.437500 101149.242188 2425.654297 748.481140 13743.603516 100051.289063 34793.523438 1672.961914 211.755859 803.024475 -0.083640 -0.092241 -0.111078 -0.133388 -0.166550 -0.202768 -0.240920 -0.289439 -0.346998 -0.400423 -0.454283 -0.526276 -0.607875 -0.660407 -0.475905 1.273956 12.861300 89.958015 759.236145 12541.838867 117920.070312 200227.843750 69100.054688 4748.220703 1714.840942 48744.191406 100167.914063 100037.414063 3657.385010 581.960571 5222.960449 -0.089750 -0.106264 -0.118083 -0.146820 -0.176804 -0.206572 -0.242049 -0.283689 -0.312470 -0.321245 -0.326376 -0.369328 -0.478762 -0.539725 -0.003255 5.373847 50.602715 411.885956 2204.171143 9648.739258 104432.679688 104659.031250 102759.703125 43305.191406 1963.917603 9844.571289 68012.632813 22779.101563 1328.859741 564.535889 5725.690918 -0.101993 -0.111118 -0.131738 -0.160670 -0.187176 -0.213151 -0.239598 -0.269446 -0.260575 -0.186694 -0.077186 -0.066960 -0.217839 -0.302222 1.050219 18.183992 279.123566 6044.112305 100218.031250 108589.828125 131348.734375 102243.625000 103013.781250 71764.664063 1619.155273 886.735474 1654.364258 960.053894 173.345169 161.945770 934.015564 -0.110184 -0.120178 -0.144189 -0.167809 -0.198521 -0.215846 -0.247764 -0.259018 -0.212911 -0.057086 0.187027 0.255458 0.046220 -0.001935 2.499312 37.120846 849.617249 51238.753906 100158.375000 102218.078125 169923.859375 105905.617188 101100.992188 10830.212891 567.651245 131.929047 92.335197 50.889977 18.831636 23.521887 73.904175 -0.118446 -0.133499 -0.148724 -0.176971 -0.205685 -0.224074 -0.254911 -0.261070 -0.209098 -0.034848 0.202521 0.321622 0.176963 0.461093 4.682142 45.605877 820.934448 42049.945313 101352.546875 104203.617188 104456.437500 11702.037109 3986.801758 747.320068 106.144218 24.399870 10.903870 5.177360 2.559216 3.207704 6.767679 -0.129759 -0.144214 -0.164355 -0.190127 -0.212015 -0.232239 -0.262678 -0.279396 -0.247038 -0.144345 0.005033 0.084855 0.280308 2.432385 18.355967 117.109230 623.251587 6724.776367 128882.195312 200089.453125 121374.773437 9900.121094 639.003906 112.671204 23.275389 5.474214 3.384509 5.837356 8.720950 9.069370 9.463124 -0.141665 -0.156428 -0.173590 -0.193701 -0.220862 -0.242472 -0.269054 -0.295489 -0.304211 -0.270040 -0.228303 -0.119800 0.811337 10.552375 121.237900 1435.423340 12406.503906 27385.437500 105744.437500 102449.312500 101403.000000 78926.648438 1806.790771 201.524612 26.884222 6.807750 20.615000 73.467995 146.977448 122.973061 82.988846 -0.157509 -0.167366 -0.182360 -0.204693 -0.233763 -0.255006 -0.278073 -0.312140 -0.336088 -0.351640 -0.350765 -0.169669 2.037415 30.320385 590.986023 23304.697266 100181.187500 106593.617187 200088.203125 103470.453125 102238.179688 67990.523438 3423.275635 402.702454 43.273689 24.806547 187.560852 1421.471069 4320.864258 2964.710205 990.256348 -0.172709 -0.180422 -0.200021 -0.219151 -0.242105 -0.265384 -0.291089 -0.318804 -0.354693 -0.378182 -0.388355 -0.163920 2.701131 45.446686 1221.554321 95835.382813 100069.890625 101226.242188 128260.570312 108055.226562 101844.195313 9201.242187 2208.848145 336.412384 41.255123 77.249954 1420.580322 34324.710938 100088.750000 101233.390625 21350.802734 -0.195516 -0.207568 -0.221996 -0.241305 -0.265246 -0.289884 -0.315504 -0.340554 -0.366974 -0.394691 -0.406492 -0.226364 1.998541 32.035484 633.536255 28230.964844 100014.687500 100121.750000 100798.328125 5706.293945 2041.765503 1056.743896 461.133606 106.296112 25.385412 147.373322 4307.897949 100018.132813 100340.851563 113334.179687 131280.531250 -0.225218 -0.237068 -0.250157 -0.270964 -0.292536 -0.312671 -0.343963 -0.369968 -0.399041 -0.413441 -0.428871 -0.338142 0.759103 11.585089 135.894852 1786.268311 16004.770508 28241.888672 5582.045410 569.290344 147.316605 107.689781 65.843010 27.668848 17.297119 115.990295 2866.418213 100024.625000 100554.710938 131149.781250 117796.976562 -0.257557 -0.266125 -0.281883 -0.303212 -0.324885 -0.343784 -0.372552 -0.399835 -0.423737 -0.442779 -0.457946 -0.435215 -0.086663 2.503972 19.153214 112.562340 389.180664 514.478516 218.971786 59.816566 32.504532 36.126221 39.657139 43.361031 34.136799 52.736446 517.136230 6585.909180 31410.074219 26323.617188 105450.437500 -0.295892 -0.305117 -0.318417 -0.340692 -0.354565 -0.374480 -0.402408 -0.428924 -0.452175 -0.471862 -0.484808 -0.491351 -0.423808 0.041483 2.049343 8.736344 19.421392 24.907158 27.334526 69.031052 209.035446 285.953369 209.031433 178.659393 112.936035 45.494507 66.282616 307.634033 800.227478 2615.711182 77069.867188 -0.334865 -0.347410 -0.359385 -0.375596 -0.385910 -0.390269 -0.405008 -0.438105 -0.473832 -0.504855 -0.514722 -0.526196 -0.531539 -0.479492 -0.241516 0.366841 1.856473 8.982175 71.908173 682.834595 4223.263672 6995.535645 2198.677002 540.660400 226.571793 65.452545 18.119213 27.071342 116.042862 2342.379639 100231.882813 -0.365388 -0.388794 -0.389438 -0.350519 -0.230691 -0.080188 -0.019594 -0.141550 -0.347132 -0.482602 -0.541882 -0.561731 -0.580765 -0.588296 -0.572552 -0.385843 1.250265 17.825863 262.984375 4973.649414 89474.507813 100028.015625 29700.085938 1599.314819 217.256927 53.403744 11.259331 6.843945 47.149521 916.470520 37907.546875 -0.401541 -0.409093 -0.292860 0.201559 1.565937 3.818541 4.769315 3.371750 1.129865 -0.041161 -0.468502 -0.585993 -0.607747 -0.628925 -0.634280 -0.464336 1.488973 23.545527 420.414978 10748.870117 100016.500000 100039.203125 89529.265625 2677.975586 171.499161 39.503761 16.170418 8.609092 17.874290 157.833481 1798.415039 -0.432931 -0.334330 0.371821 4.269594 20.352953 57.651833 82.763588 51.168583 16.211262 2.952766 0.040965 -0.537178 -0.641090 -0.660241 -0.675601 -0.529441 0.972497 16.402653 235.368286 3916.810059 59275.820313 100381.695313 20629.621094 1305.156738 224.979080 220.007767 158.285873 67.256836 36.339741 37.089638 108.514664 -0.430913 -0.025040 3.415782 32.224266 260.076752 1420.503540 2644.637695 1133.924805 187.441498 21.577482 2.177755 -0.316638 -0.648789 -0.705526 -0.719990 -0.643212 0.220852 7.458963 71.512573 633.531494 3876.007324 9207.529297 6669.495117 1778.189575 2180.048584 5605.538086 2991.003662 743.829102 306.477844 132.350342 47.881329 -0.383106 0.724168 12.569065 188.420364 3968.599854 86137.585938 100008.632813 51218.312500 2258.825439 113.365631 8.006437 0.199676 -0.632960 -0.738687 -0.752693 -0.718691 -0.209362 3.991977 41.293056 469.656403 6114.867187 43594.886719 59521.246094 22892.089844 36528.402344 100470.890625 72277.562500 10478.619141 4422.842285 848.830078 130.929092 -0.209966 1.693174 26.980125 558.288696 31147.154297 100083.421875 100094.953125 100047.531250 14609.427734 320.829956 16.139853 0.827587 -0.585327 -0.752585 -0.776658 -0.761783 -0.401482 2.811260 35.716854 480.685303 7963.632324 134338.265625 128373.593750 106744.226562 126001.234375 103311.507813 177588.734375 109667.281250 101130.171875 6488.443848 335.177765 1.123115 2.900926 32.535793 629.220093 34579.410156 100982.632813 101230.132813 100426.679688 16079.189453 330.234833 18.668690 1.116225 -0.556386 -0.764993 -0.774201 -0.705031 -0.399911 1.769267 22.230040 282.614532 6591.149414 103972.070313 103741.976563 102453.335938 104409.812500 109606.171875 169918.843750 104058.476563 100838.234375 25991.146484 602.678955 18.443033 9.748584 27.791100 337.149597 6013.866211 108579.757812 111235.031250 80021.593750 2927.617920 161.789429 14.233770 1.069916 -0.545999 -0.728604 -0.528634 0.129829 1.181586 2.588064 11.079211 112.675491 2199.338135 77764.453125 100271.125000 100359.085938 18123.843750 10771.075195 104137.242188 110585.945312 122119.609375 16651.314453 799.067993 386.559021 93.741081 35.066662 223.999405 2591.561768 19311.687500 30914.664063 8287.866211 1053.853149 112.334061 13.075982 1.127233 -0.511497 -0.449797 1.155404 6.847597 18.293205 22.423689 15.631033 33.053974 289.428558 2665.059570 11143.774414 7204.198730 1233.622314 1239.845825 18042.316406 131177.281250 113398.085937 101510.671875 2689.325928 18158.908203 1232.016968 102.935524 186.533585 2291.666992 42642.425781 106143.757813 101601.179688 7359.207031 341.884094 23.926918 1.752796 -0.380282 0.575567 8.754619 55.792137 196.612244 260.419464 115.737976 28.007063 33.153210 129.871201 262.422455 220.481796 105.039925 442.022247 20246.466797 100679.125000 100682.062500 101178.242188 5322.246582 101321.921875 12708.794922 341.137543 224.779160 6178.553711 100483.914063 100557.515625 100219.242188 56769.996094 916.344299 39.504436 2.495603 -0.135395 2.419301 29.801424 279.014984 1598.968018 2419.666260 729.225708 90.782494 12.654553 9.641348 14.753582 17.674845 29.955721 191.274200 4465.290039 100097.062500 100519.820313 39364.195313 4572.491699 107171.570312 21849.773438 550.219360 195.922653 5110.604980 100041.273438 100043.617188 100023.617188 46285.324219 847.098938 37.353233 2.962346 0.321541 3.803865 49.365635 579.428955 4052.185059 6944.671387 1605.090210 165.456589 16.034966 3.186901 4.283318 19.859060 82.403847 187.811218 436.725128 2139.133545 3829.367432 2840.993652 2443.135986 107902.437500 5867.554199 388.766479 97.474960 983.557068 19282.843750 100004.070313 69774.046875 4311.109375 251.945145 27.545195 8.803473 2.911248 3.723274 35.282455 326.526276 1893.333984 2645.362793 797.471130 103.395653 15.136023 5.352661 8.144217 46.056370 258.109863 639.131165 422.716003 271.748016 897.839355 4972.353027 8839.231445 4382.074707 1401.462402 248.988174 48.622375 110.640205 634.435303 1787.358276 1227.402222 306.474030 121.178284 124.426811 73.682968 21.687063 6.601482 19.504059 109.459846 354.357635 423.778687 174.348267 42.806393 15.305417 10.107499 12.253811 52.138382 281.674011 655.628479 515.544373 549.280823 1917.408813 17653.041016 34368.156250 4190.233887 2359.172852 414.099976 49.759003 16.077398 34.967918 64.287544 75.591393 196.109894 849.660767 1420.944946 634.147461 120.987816 21.683157 48.383591 377.626526 1547.375488 1434.533691 321.688965 51.526733 21.069902 15.347798 12.763026 26.740511 100.805817 234.889740 494.152863 1217.480103 1791.669556 8661.936523 16034.331055 4326.631348 2453.939209 420.911407 46.919445 6.187632 3.598752 9.900694 61.208908 635.484863 4681.627441 10170.528320 3370.559326 422.503632 52.620766 128.025253 1664.171265 12357.578125 10168.531250 1228.223877 115.432068 31.189005 19.628635 11.991154 10.800412 23.958691 70.897575 295.909210 830.944519 765.517334 1165.304565 1680.151611 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002483 -0.003064 -0.003713 -0.005931 -0.006956 -0.010195 -0.011680 -0.013102 -0.014320 -0.015280 -0.015896 -0.016063 -0.015891 -0.015331 -0.014398 -0.013248 -0.011953 -0.010572 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002571 -0.003242 -0.004078 -0.006682 -0.009950 -0.012036 -0.014330 -0.016653 -0.020488 -0.022587 -0.024203 -0.025263 -0.025566 -0.026116 -0.025191 -0.023659 -0.020162 -0.018020 -0.014813 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002536 -0.003289 -0.004229 -0.007130 -0.010823 -0.013593 -0.016714 -0.022069 -0.025968 -0.029869 -0.033242 -0.038416 -0.040194 -0.040927 -0.041797 -0.038809 -0.036178 -0.032877 -0.027894 -0.024097 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002398 -0.003152 -0.004168 -0.007237 -0.009384 -0.014429 -0.020292 -0.025523 -0.031294 -0.038840 -0.045950 -0.051239 -0.057243 -0.060573 -0.062266 -0.062152 -0.059650 -0.055337 -0.049927 -0.043875 -0.037853 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002162 -0.002896 -0.003877 -0.006907 -0.009256 -0.016059 -0.021238 -0.027679 -0.036901 -0.045159 -0.053721 -0.061468 -0.068133 -0.074688 -0.080177 -0.084110 -0.086654 -0.084921 -0.079350 -0.074767 -0.066733 -0.058093 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001870 -0.002536 -0.003456 -0.006298 -0.008604 -0.015255 -0.020713 -0.029442 -0.038705 -0.048426 -0.058433 -0.066999 -0.076310 -0.084921 -0.092628 -0.098729 -0.102688 -0.103987 -0.104873 -0.102320 -0.095195 -0.085856 -0.077553 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002132 -0.002937 -0.005437 -0.007508 -0.012128 -0.018948 -0.027863 -0.037936 -0.048919 -0.059979 -0.071363 -0.074554 -0.057820 -0.026079 -0.000534 -0.014447 -0.063466 -0.093867 -0.100478 -0.098644 -0.102089 -0.106189 -0.098111 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002398 -0.003336 -0.006287 -0.008850 -0.016409 -0.024698 -0.034672 -0.046845 -0.060558 -0.071910 -0.067449 0.009170 0.240889 0.651117 0.911216 0.827971 0.460970 0.219247 0.200687 0.216826 0.135618 -0.001296 -0.081848 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002644 -0.003686 -0.007127 -0.012045 -0.020659 -0.029547 -0.041700 -0.058881 -0.071361 -0.071852 0.027142 0.548552 2.240289 6.041649 9.295477 7.768232 4.367891 2.817889 3.433892 3.803251 2.720618 1.148708 0.250263 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002031 -0.002836 -0.005531 -0.011121 -0.015303 -0.025444 -0.038255 -0.054533 -0.070214 -0.083374 -0.036451 0.400157 2.896085 14.159773 48.967484 84.428802 68.797638 31.774534 23.518826 43.240803 58.486759 36.384186 11.913703 2.681322 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003762 -0.004836 -0.007945 -0.014247 -0.022336 -0.034918 -0.048086 -0.067581 -0.086746 -0.095242 0.038631 1.233308 9.710299 65.773888 342.583130 743.513489 550.468689 211.064117 223.234818 802.242615 1423.501221 681.064819 127.927612 17.415674 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001596 -0.001888 -0.004351 -0.007367 -0.012592 -0.019404 -0.028232 -0.042827 -0.060242 -0.083073 -0.104635 -0.109058 0.125658 2.213911 20.911072 189.758896 1334.397217 4093.974121 3085.906006 1796.286621 2818.875488 31263.888672 95850.343750 21186.111328 1316.862671 82.912933 0.000000 0.000000 0.000000 0.000000 -0.001724 -0.002084 -0.005425 -0.008503 -0.011996 -0.019994 -0.027620 -0.041320 -0.053687 -0.075658 -0.100056 -0.125332 -0.130761 0.114242 2.346731 22.512417 220.576126 1615.688354 5999.647461 20444.851563 70674.906250 35838.191406 101538.820313 100100.539063 100008.132813 7808.164062 227.703873 -0.001188 0.000000 0.000000 -0.001785 -0.003443 -0.006018 -0.007195 -0.014225 -0.017199 -0.027046 -0.037810 -0.049351 -0.066382 -0.089049 -0.118798 -0.149840 -0.166743 -0.010532 1.545480 13.761607 108.306801 758.262268 9037.171875 100880.765625 100635.367188 117599.156250 110176.539062 100298.429688 100016.593750 9306.207031 259.769440 -0.001447 0.000000 -0.002896 -0.003610 -0.006385 -0.007855 -0.013305 -0.018166 -0.024570 -0.036510 -0.049542 -0.061282 -0.083915 -0.113248 -0.143861 -0.183863 -0.213087 -0.158841 0.537792 5.431411 38.038124 346.505188 9501.740234 100252.953125 100393.179688 103474.320313 81965.085938 100322.695313 41871.292969 2087.716309 105.955231 -0.003011 -0.004105 -0.003611 -0.006475 -0.008175 -0.014007 -0.018763 -0.026307 -0.033351 -0.051272 -0.064410 -0.084054 -0.105532 -0.139445 -0.180605 -0.225223 -0.266181 -0.278661 -0.032185 1.907531 15.370905 143.736557 2146.352051 38878.433594 101694.484375 42813.382813 4224.407715 3248.729492 1328.184326 200.808655 24.389566 -0.004629 -0.004936 -0.006265 -0.008083 -0.013844 -0.019468 -0.025860 -0.035006 -0.048557 -0.068163 -0.085077 -0.108652 -0.139545 -0.175464 -0.220373 -0.277421 -0.327256 -0.367644 -0.283523 0.725037 8.711573 77.106285 715.018738 4502.578613 9015.916992 3503.189941 594.177307 155.898453 67.523262 19.987114 4.513875 -0.008290 -0.007470 -0.008786 -0.013461 -0.019193 -0.025861 -0.036547 -0.049985 -0.066563 -0.090234 -0.115241 -0.143871 -0.177983 -0.219960 -0.269202 -0.331398 -0.388118 -0.429597 -0.406142 0.230182 5.614616 49.835083 435.636963 2702.682617 4775.470215 1850.347290 269.233154 38.025928 8.159673 2.339661 2.541753 -0.009343 -0.008714 -0.013834 -0.017612 -0.024991 -0.038917 -0.049805 -0.066140 -0.087068 -0.117463 -0.147064 -0.178139 -0.214320 -0.258369 -0.312486 -0.374088 -0.432598 -0.479169 -0.422272 0.202364 3.476534 23.009853 131.889969 556.088013 915.522827 422.402557 86.640892 15.061417 4.558712 2.657665 4.484123 -0.013041 -0.014554 -0.019575 -0.025234 -0.032850 -0.048307 -0.063954 -0.087277 -0.112225 -0.147709 -0.178117 -0.211842 -0.246850 -0.290327 -0.342309 -0.387391 -0.436508 -0.395826 0.163146 3.293285 15.047071 38.386223 56.381977 81.405464 100.227562 61.257793 28.824778 28.385166 36.456348 25.632643 13.149722 -0.017844 -0.020095 -0.023114 -0.030108 -0.044706 -0.058941 -0.083015 -0.111412 -0.141008 -0.172747 -0.209171 -0.236252 -0.248617 -0.245341 -0.231072 -0.198709 -0.093653 0.457217 3.717448 30.138855 215.923477 879.425659 880.469055 240.212036 57.385723 60.120335 115.450867 273.883270 510.652679 312.599792 73.108521 -0.021132 -0.023964 -0.026892 -0.039779 -0.054747 -0.073955 -0.103250 -0.135697 -0.166863 -0.199427 -0.224534 -0.199797 -0.058448 0.210109 0.558587 0.986708 1.915982 4.793320 19.366388 202.210236 3464.785156 48717.890625 48671.972656 4092.488281 314.500793 457.929535 1249.978638 3060.641602 6068.773926 2973.663574 376.602661 -0.025223 -0.027032 -0.034924 -0.050544 -0.066514 -0.089049 -0.125280 -0.160147 -0.192039 -0.220752 -0.203087 0.015001 0.767528 2.320391 4.227070 5.870361 10.934180 27.197994 87.177643 772.140991 28139.716797 114610.812500 111148.890625 32975.359375 1153.755371 3423.510010 19931.105469 91700.640625 53280.957031 9802.126953 769.426758 -0.031582 -0.033604 -0.045077 -0.059603 -0.078307 -0.105608 -0.144254 -0.182928 -0.212816 -0.232287 -0.130123 0.521833 2.906520 9.105341 16.768957 21.579704 44.649082 187.168518 741.453308 2705.833496 66681.039063 200100.296875 200140.156250 38172.292969 2240.796875 11739.172852 114760.593750 106237.171875 104593.328125 30263.097656 925.890869 -0.038838 -0.042535 -0.056873 -0.070957 -0.093929 -0.123091 -0.167111 -0.205876 -0.234958 -0.242390 -0.032468 1.201224 6.378500 21.128799 41.031708 51.236351 144.220612 1472.607544 13459.435547 28384.535156 107327.125000 110727.515625 111546.335937 53861.296875 2741.808594 10808.402344 105975.664063 103577.906250 101268.742188 46657.292969 863.042664 -0.046611 -0.050314 -0.066475 -0.082562 -0.107344 -0.139257 -0.189256 -0.227761 -0.259438 -0.263192 -0.015721 1.539972 8.037458 26.858027 52.520927 68.786705 318.008301 6614.014648 100100.851563 101181.484375 82433.648438 102216.507813 100616.484375 14283.585938 1524.421387 3051.293457 68837.906250 127372.250000 113542.906250 9006.686523 405.598907 -0.054208 -0.060649 -0.077274 -0.094916 -0.121406 -0.157565 -0.206993 -0.251665 -0.288581 -0.306753 -0.105984 1.153624 6.234478 19.775209 39.100895 55.494480 288.555634 6072.500000 100151.453125 100483.835938 48218.425781 8517.812500 5321.585449 1214.512939 356.137054 1256.678955 26223.773438 105590.437500 102360.820313 4282.674316 218.274933 -0.061574 -0.072149 -0.087774 -0.108790 -0.135766 -0.173619 -0.219819 -0.273606 -0.317266 -0.355206 -0.256292 0.469223 3.166306 9.806562 19.304359 28.518976 116.857101 1253.950562 10346.130859 23634.148438 8682.996094 2500.424561 919.512695 239.318756 96.796776 622.431885 11175.250000 88489.164063 33332.222656 2107.113037 127.544426 -0.071305 -0.081951 -0.096329 -0.117196 -0.146942 -0.184207 -0.233793 -0.286146 -0.334684 -0.389311 -0.383284 -0.096970 0.996914 3.537383 7.072684 11.390588 43.884300 388.646393 4482.478516 28308.740234 72559.453125 74629.429688 10465.748047 894.280029 92.692245 144.650360 1018.176208 3434.437500 2077.065674 349.736420 61.237354 -0.081109 -0.093557 -0.106841 -0.128810 -0.158563 -0.194848 -0.240474 -0.291680 -0.348950 -0.406500 -0.452641 -0.407898 -0.108761 0.608712 1.551624 3.790945 23.412237 258.875641 3989.278564 113566.984375 109585.937500 106759.515625 104453.929688 3297.047607 171.110718 118.954315 259.686920 265.224640 156.234177 120.102287 351.484833 -0.090910 -0.101515 -0.115199 -0.139775 -0.166751 -0.194254 -0.235128 -0.292040 -0.345045 -0.382606 -0.420609 -0.461786 -0.464542 -0.381038 -0.143650 1.173282 12.272206 140.217667 2838.033936 101396.585938 101796.117188 102855.851563 102003.179688 4418.051758 253.623367 520.379150 1412.214111 877.020996 209.126984 850.305908 11268.956055 -0.101772 -0.113114 -0.129246 -0.149560 -0.167427 -0.178401 -0.213189 -0.259436 -0.277472 -0.232090 -0.140701 -0.147476 -0.284399 -0.465458 -0.393726 1.187949 11.885480 87.942726 1022.940552 32093.027344 113502.781250 177677.734375 85677.851563 4358.024902 378.290466 1048.855713 3322.420410 1814.834839 378.269684 4829.166992 100158.234375 -0.114877 -0.131427 -0.147293 -0.162248 -0.162969 -0.155913 -0.175039 -0.192956 -0.092769 0.273050 0.840922 1.128938 0.687792 0.052596 0.192054 5.356946 53.348000 439.683380 2551.932617 9476.455078 108879.289062 108718.742187 101874.523438 28487.595703 752.227417 488.225037 1204.456543 690.675293 271.222595 5266.488281 100108.000000 -0.127266 -0.138985 -0.160951 -0.176792 -0.166600 -0.151294 -0.158581 -0.108880 0.251046 1.392334 3.439656 4.475935 3.096960 1.258435 1.614584 19.308374 298.192535 7172.732422 100195.578125 106648.945312 134533.296875 101674.445313 100238.976563 46374.386719 840.864685 123.750870 147.015060 103.054939 77.655922 878.063477 13667.976563 -0.142266 -0.152273 -0.175399 -0.195083 -0.188725 -0.176878 -0.174834 -0.045590 0.616863 2.701380 6.400491 8.804004 6.249856 2.699073 3.397838 39.318665 912.804016 62903.636719 100134.687500 101750.843750 146367.687500 106631.437500 100232.500000 7858.651855 339.743835 35.725185 18.220360 12.440022 13.903003 77.312775 374.018158 -0.154450 -0.167231 -0.191920 -0.212198 -0.220886 -0.223730 -0.211345 -0.041844 0.692972 2.914157 6.820891 9.354569 6.715502 3.155637 5.336053 46.884167 939.220947 51361.058594 100879.421875 102661.515625 103232.945313 11125.268555 3131.599854 554.336060 68.382210 10.070520 2.731824 1.599122 2.309869 7.249054 19.265265 -0.170036 -0.184657 -0.206978 -0.228637 -0.246510 -0.255526 -0.248327 -0.115289 0.378227 1.716031 3.996544 5.157896 3.916574 4.044004 18.011875 105.591896 581.459595 6932.572754 117189.578125 200181.640625 103877.789063 7372.213867 1202.236328 216.450348 32.892445 5.023352 2.917681 6.983006 11.219798 11.246308 12.622417 -0.183993 -0.201136 -0.221589 -0.240220 -0.267305 -0.279667 -0.281117 -0.210416 0.018552 0.516769 1.286919 1.738039 2.181091 10.136676 107.327744 1235.138672 9493.837891 19225.156250 104968.000000 103576.125000 112985.601562 73097.320313 15297.788086 1354.270142 97.866539 12.396589 26.030773 105.843178 214.643906 173.589249 102.680428 -0.197347 -0.216935 -0.242246 -0.262635 -0.280341 -0.300634 -0.309217 -0.294935 -0.231362 -0.101516 0.055451 0.291330 2.163465 27.224037 513.578552 17567.253906 100134.210938 103685.367188 200206.296875 105881.906250 195970.875000 125652.757812 100637.015625 4711.639648 204.721863 38.863762 278.466034 2443.069336 9314.282227 5597.223633 1185.097656 -0.217043 -0.233743 -0.253372 -0.278266 -0.297472 -0.317379 -0.336796 -0.352926 -0.354209 -0.342334 -0.322532 -0.100521 2.609997 40.461456 977.779968 62885.968750 100052.664063 100796.710938 113452.429687 86161.750000 104902.671875 103114.898438 86318.171875 3667.534668 184.111023 117.749260 2443.133789 100004.437500 100046.710938 100496.953125 18351.187500 -0.237661 -0.251487 -0.271991 -0.295710 -0.319935 -0.339464 -0.366046 -0.386229 -0.403310 -0.422768 -0.423502 -0.232556 1.897754 28.596588 550.068604 19280.091797 100012.109375 100098.320313 100561.625000 4511.219727 6173.451172 14830.260742 6061.683594 685.403442 73.029526 219.147491 9306.171875 100010.992188 100156.046875 103123.562500 165907.625000 -0.267195 -0.286483 -0.306728 -0.330502 -0.350550 -0.369158 -0.387772 -0.416834 -0.434099 -0.448617 -0.453434 -0.336327 0.703469 10.455134 119.907120 1532.181274 12167.622070 19289.802734 4349.655762 509.149750 356.408356 535.437622 323.326630 80.535789 23.538631 166.730850 5538.717285 100014.085938 100231.695313 106597.585937 146499.093750 -0.297743 -0.318437 -0.341433 -0.362480 -0.381614 -0.400313 -0.426113 -0.451288 -0.471908 -0.485892 -0.482117 -0.413295 -0.034833 2.355780 17.243231 99.489273 339.686279 418.004211 192.480362 54.414818 34.370518 38.076553 28.493828 13.513212 9.884613 56.167038 845.795349 14606.353516 95972.835938 48886.546875 47167.156250 -0.329877 -0.353748 -0.377269 -0.394302 -0.411454 -0.429470 -0.458280 -0.477273 -0.499240 -0.520143 -0.518268 -0.476168 -0.338080 0.125913 2.056185 7.876975 18.232096 21.257082 17.179985 22.561235 45.415207 57.679829 37.428226 19.859821 11.267392 14.877524 84.344398 453.164032 1208.108765 1834.576294 27767.105469 -0.366183 -0.393936 -0.408363 -0.427259 -0.432839 -0.435495 -0.458284 -0.489650 -0.525914 -0.549476 -0.554141 -0.531470 -0.486333 -0.394342 -0.190349 0.340955 1.320009 3.935627 18.850212 102.250778 367.493958 484.561310 239.921860 66.711288 19.413477 7.678821 9.853876 28.890682 100.669106 1290.172119 63005.746094 -0.397381 -0.426639 -0.441420 -0.400020 -0.305668 -0.176439 -0.130168 -0.236439 -0.404598 -0.521574 -0.583831 -0.582604 -0.569693 -0.564392 -0.543492 -0.436581 0.270882 5.629794 49.611877 419.720337 2063.426758 3310.496338 1137.038574 190.047592 30.440447 7.965027 3.316762 5.346236 36.210506 556.460693 14608.644531 -0.433523 -0.449220 -0.360734 0.030916 1.109379 2.862045 3.607755 2.553448 0.882229 -0.131083 -0.499647 -0.607951 -0.620414 -0.629305 -0.633090 -0.529612 0.305769 7.339786 70.940132 682.860291 4221.447266 6402.834961 2074.758545 277.833344 46.822529 27.288082 17.894567 8.950781 14.137060 109.471954 985.789490 -0.455013 -0.390609 0.193503 3.218135 14.601341 40.623608 57.900517 36.360020 11.940093 2.396435 0.011059 -0.526163 -0.635822 -0.657040 -0.677404 -0.584753 0.062126 5.126801 45.559933 350.138611 1666.906616 2667.012451 1053.049072 246.768936 263.730621 487.407684 323.698822 91.433311 27.574120 32.473381 88.619934 -0.459190 -0.119685 2.596192 23.107367 165.543762 787.324829 1318.841797 635.772095 121.520714 17.143238 1.931091 -0.260232 -0.609426 -0.684151 -0.710288 -0.676542 -0.284636 2.475717 19.599472 109.377281 414.521973 834.957336 1063.494141 1190.304077 7323.520996 25678.328125 12217.564453 1297.139404 164.497986 79.624672 96.129639 -0.415543 0.560395 9.928087 122.837021 1795.874023 25654.609375 69795.531250 16018.769531 1141.504883 76.798431 7.149793 0.349562 -0.549239 -0.706446 -0.745038 -0.748789 -0.519285 1.223552 12.858220 93.807182 786.752686 7886.969727 38715.597656 29030.660156 102315.484375 100291.679688 100511.234375 16958.785156 1064.330566 266.731049 178.217896 -0.244259 1.579585 21.480207 361.445831 11239.160156 100365.906250 100424.187500 100189.835938 5588.793457 201.853607 15.624453 1.341527 -0.445509 -0.719999 -0.760994 -0.772952 -0.616089 0.875430 13.867434 164.742935 3884.251221 100652.179688 100890.960938 114793.367187 134425.703125 101307.000000 104524.453125 65932.851563 8027.002441 973.378052 187.366669 0.834583 2.984014 32.218082 485.334686 13822.460938 111128.445312 116030.914062 103160.039063 6365.550293 253.625061 23.000769 2.592198 -0.285490 -0.712431 -0.752496 -0.728128 -0.610339 0.600820 13.073637 195.002579 7247.407715 100210.695313 100364.578125 105620.906250 195965.468750 102479.515625 116362.742187 93718.156250 31698.718750 2376.472412 192.050674 13.761557 8.746951 44.387062 730.322327 19833.310547 134389.390625 200156.250000 74708.468750 2899.629639 221.624451 28.836407 3.763162 -0.138448 -0.680185 -0.657235 -0.485230 -0.236723 0.509764 7.853542 104.707085 2460.490479 100038.148438 100081.609375 100659.828125 28433.929688 29683.857422 21096.400391 36877.660156 16773.123047 2176.312744 226.504135 263.237396 65.470726 55.989700 956.048645 42233.277344 102284.093750 105628.195313 103399.828125 3193.916260 228.501617 30.196398 3.929118 -0.132244 -0.618713 -0.269155 0.796882 2.460092 3.299626 4.619953 30.161312 320.108368 3371.776367 14608.458984 9367.115234 1501.797119 860.233521 2669.456787 19079.804688 38428.652344 6637.597656 526.491638 9184.359375 797.035156 88.818863 504.300476 10857.327148 137940.218750 200095.171875 123390.906250 8854.715820 404.246490 33.417694 3.480705 -0.220789 -0.415939 1.091076 6.465289 17.171406 20.710365 12.045773 8.656451 32.935825 136.650253 298.997314 252.617676 112.031517 175.953293 2166.973877 33367.968750 88455.867188 12285.619141 736.687683 100073.992188 6373.502441 214.500031 271.305023 7301.747559 103658.140625 104691.359375 101236.804688 56892.843750 933.278625 42.803417 3.081261 -0.293220 -0.050785 3.856115 21.929565 63.481579 82.307060 38.669403 10.685166 5.236458 10.561760 19.143715 33.574398 97.456451 226.592010 795.028198 6382.644531 12241.959961 2963.457031 375.396973 100189.546875 10170.346680 261.963135 182.261856 5593.921387 100145.765625 100166.226563 100075.914063 46298.539063 849.677612 37.366596 2.541140 -0.254922 0.298249 5.939709 34.548332 108.339287 141.354050 65.152527 16.756756 6.195701 6.989485 18.088535 133.477905 1196.383301 3636.471924 1893.442139 648.765747 642.222046 350.890228 179.905090 50991.144531 2326.759766 133.138763 74.836319 983.615784 19288.039063 100010.117188 69776.968750 4683.629883 245.822037 18.854307 2.837282 0.414084 0.776737 6.977457 34.148796 89.953514 109.429214 52.464249 19.745790 18.663094 27.392212 51.215828 489.121826 9227.581055 54065.753906 16705.156250 1054.235840 161.847366 244.609039 309.980896 1290.639893 263.555939 48.415478 21.709122 107.607948 634.420898 1787.093994 1223.162720 283.172272 50.859879 19.938620 10.803445 3.949582 3.734434 26.499939 173.460861 600.342285 563.430542 154.790955 41.358517 55.179993 81.707581 97.749619 568.315247 10218.244141 60549.308594 18510.285156 1134.251953 188.224396 432.425934 598.547302 185.406067 114.595261 37.845184 9.819487 11.796239 36.331715 65.828102 55.860840 41.051476 62.749641 83.644608 51.294991 16.187685 14.547364 178.916718 3312.695068 34793.089844 28095.701172 2366.523437 173.023239 102.494751 141.341660 117.799278 233.139450 1498.911499 4820.036133 2174.591797 324.255310 133.931122 290.609894 393.113281 134.071426 97.095917 31.719145 7.025824 1.956183 2.759320 5.303735 12.944720 50.102737 165.268036 260.039886 145.447067 38.258511 32.214256 630.524170 38791.500000 100113.960938 100321.015625 20840.234375 583.645386 190.693710 174.640854 105.341797 79.916840 153.995712 241.592346 161.323456 68.860023 56.274757 91.968773 108.878822 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002088 -0.002607 -0.003197 -0.003905 -0.006176 -0.007291 -0.010556 -0.012111 -0.013624 -0.014880 -0.015861 -0.016504 -0.016647 -0.016413 -0.015777 -0.014792 -0.013566 -0.012240 -0.010772 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.002681 -0.003408 -0.004291 -0.006965 -0.010317 -0.012550 -0.014950 -0.017375 -0.021356 -0.023575 -0.025340 -0.027343 -0.027694 -0.027329 -0.026263 -0.024562 -0.022435 -0.018604 -0.016295 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002031 -0.002663 -0.003456 -0.004451 -0.007448 -0.011237 -0.014186 -0.019146 -0.023216 -0.027279 -0.031389 -0.037386 -0.040461 -0.043861 -0.044660 -0.044150 -0.042192 -0.039255 -0.034414 -0.030453 -0.026370 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001883 -0.002501 -0.003312 -0.004386 -0.007561 -0.009880 -0.015096 -0.021386 -0.026907 -0.034596 -0.042040 -0.048300 -0.055062 -0.059868 -0.063404 -0.065565 -0.065231 -0.062643 -0.058035 -0.052278 -0.045842 -0.040876 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002253 -0.003021 -0.004078 -0.007241 -0.009728 -0.016793 -0.022271 -0.030688 -0.039056 -0.048417 -0.056554 -0.063102 -0.070004 -0.076853 -0.082652 -0.087775 -0.089388 -0.088556 -0.086447 -0.078998 -0.070283 -0.061291 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002644 -0.003634 -0.006561 -0.008981 -0.015946 -0.021841 -0.031129 -0.040845 -0.052416 -0.060005 -0.068885 -0.077242 -0.080232 -0.085516 -0.092920 -0.101887 -0.110215 -0.110191 -0.107510 -0.102090 -0.091787 -0.081065 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002222 -0.003064 -0.005668 -0.007873 -0.012727 -0.019983 -0.029476 -0.040109 -0.052837 -0.062938 -0.071636 -0.062445 -0.010817 0.075510 0.135175 0.095447 -0.000198 -0.070509 -0.099468 -0.102644 -0.106526 -0.114509 -0.106112 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002501 -0.003481 -0.006546 -0.010831 -0.017161 -0.026174 -0.036681 -0.051013 -0.062435 -0.072650 -0.042524 0.145393 0.691509 1.723033 2.482468 2.138592 1.131026 0.473718 0.278563 0.251200 0.154530 0.012244 -0.086323 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002757 -0.003877 -0.007424 -0.012562 -0.021876 -0.031345 -0.045465 -0.060807 -0.073236 -0.052333 0.182692 1.472166 6.335656 18.553701 30.779345 26.265858 11.698302 4.939484 4.288935 4.484912 3.172788 1.336633 0.275942 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002979 -0.005752 -0.009925 -0.015783 -0.025088 -0.038859 -0.056262 -0.069359 -0.080551 0.039977 1.063458 8.237544 54.702587 243.801727 551.927734 393.410889 114.912994 39.784180 52.886158 70.116943 43.276569 14.004255 2.961364 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002222 -0.004715 -0.007914 -0.012756 -0.021190 -0.035992 -0.049964 -0.071748 -0.087985 -0.082916 0.238055 3.365352 34.369099 389.767029 3968.387695 16018.757813 8570.192383 1155.269165 356.016785 1159.967285 2091.222412 909.282898 164.812088 20.544628 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.004144 -0.006974 -0.012304 -0.019394 -0.028357 -0.043108 -0.065147 -0.087664 -0.107784 -0.084645 0.443786 6.310616 83.324265 1656.772583 41876.445313 100188.679688 101064.343750 8979.462891 4516.141602 56955.601563 100027.328125 37886.261719 1930.290649 105.974792 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001797 -0.003725 -0.006657 -0.009485 -0.019171 -0.027018 -0.041118 -0.057129 -0.078817 -0.103152 -0.130465 -0.104912 0.483065 7.029436 94.612549 1939.443481 56844.429688 102260.632813 146306.281250 108325.851562 82678.273438 102885.359375 100147.179688 100010.773438 13321.365234 296.786957 -0.001172 0.000000 0.000000 0.000000 -0.001901 -0.005217 -0.006210 -0.013103 -0.015864 -0.024198 -0.036490 -0.050054 -0.066535 -0.092820 -0.122459 -0.154438 -0.152923 0.238377 4.183792 47.241856 653.093262 8175.756836 53907.328125 119356.429687 102594.343750 134497.375000 123319.273437 100450.421875 100022.226563 16003.984375 339.560364 -0.001417 0.000000 0.000000 -0.003076 -0.005523 -0.008528 -0.011890 -0.016468 -0.022427 -0.034233 -0.046017 -0.063336 -0.084087 -0.114124 -0.148429 -0.189134 -0.210457 -0.061192 1.547990 14.392503 116.859100 929.850525 22606.679688 101768.132813 101946.507813 105799.687500 128353.843750 100529.226563 86154.921875 3105.931641 136.209793 -0.001692 -0.001239 -0.003080 -0.005590 -0.008839 -0.010961 -0.015426 -0.022249 -0.033338 -0.048931 -0.060510 -0.078877 -0.107050 -0.138001 -0.182321 -0.226760 -0.268337 -0.251045 0.257460 4.058094 31.831617 311.586884 5501.718750 121238.820312 151276.218750 112536.109375 7847.788574 4929.844238 1804.377808 261.430878 29.550013 -0.003342 -0.004395 -0.005415 -0.008757 -0.011127 -0.015837 -0.021240 -0.033006 -0.045703 -0.061302 -0.080426 -0.103296 -0.134989 -0.172002 -0.220692 -0.278139 -0.329907 -0.363771 -0.162092 1.921457 21.469452 314.086273 7462.559570 102096.578125 104695.093750 98121.226563 3294.533936 295.185120 91.276955 24.605076 7.720530 -0.004981 -0.005147 -0.007682 -0.010728 -0.016777 -0.021457 -0.031042 -0.041816 -0.059180 -0.082793 -0.106771 -0.132453 -0.170724 -0.213743 -0.266477 -0.336812 -0.396025 -0.438690 -0.336931 1.076885 15.797658 233.895737 5565.550293 100090.289063 100137.617188 62973.535156 2478.096924 127.249496 15.341919 4.343919 9.979231 -0.007360 -0.007719 -0.011171 -0.016189 -0.022463 -0.033493 -0.042510 -0.059594 -0.079850 -0.106250 -0.137326 -0.169327 -0.212306 -0.258958 -0.320600 -0.385769 -0.448781 -0.493972 -0.375824 0.712793 8.693446 82.017563 985.228516 8533.042969 17573.025391 5100.644043 519.721191 49.501888 11.627174 7.245205 17.554617 -0.012435 -0.012879 -0.016765 -0.022375 -0.030901 -0.041327 -0.057024 -0.077661 -0.100171 -0.137781 -0.173431 -0.209742 -0.249806 -0.296126 -0.358916 -0.420558 -0.486835 -0.459174 0.177438 4.247741 21.849392 63.135220 151.703339 388.436493 600.301331 285.455536 80.531792 78.045555 129.826508 92.162865 39.300461 -0.015719 -0.016269 -0.021925 -0.029783 -0.039604 -0.052420 -0.074224 -0.098080 -0.128772 -0.169005 -0.200226 -0.237146 -0.277370 -0.326031 -0.376644 -0.420354 -0.426228 -0.015903 3.684344 39.710278 345.527283 1664.518066 1817.876831 427.121094 85.148026 53.904591 188.629089 1454.818115 5248.925293 2555.682617 328.714294 -0.020507 -0.022276 -0.025630 -0.036480 -0.051599 -0.066477 -0.093794 -0.122333 -0.155656 -0.190272 -0.228383 -0.263319 -0.263895 -0.242684 -0.209089 -0.156162 0.103311 1.783933 16.858152 285.986938 8392.131836 100094.664063 100085.812500 11218.472656 355.880371 185.010651 1490.666138 36028.570313 100856.132813 100203.078125 3341.063721 -0.025273 -0.027039 -0.035347 -0.044944 -0.062219 -0.081566 -0.113631 -0.148615 -0.183288 -0.219540 -0.248945 -0.223445 -0.047639 0.322196 0.751420 1.188836 2.502824 8.269626 46.155804 939.864502 96420.843750 101225.492188 101057.828125 100295.453125 1240.598022 1191.719116 18144.562500 195942.312500 141888.796875 103112.953125 7762.945801 -0.032466 -0.034306 -0.046472 -0.057056 -0.075347 -0.099122 -0.131418 -0.171517 -0.206398 -0.245030 -0.235757 -0.011196 0.829600 2.775357 5.171402 6.666608 11.613788 37.242886 136.543472 1057.474487 56747.929688 113341.710937 110183.179687 69350.781250 1178.078979 6312.631836 101090.945313 123022.859375 200130.765625 98929.828125 3016.377686 -0.040342 -0.044994 -0.057444 -0.071109 -0.090746 -0.120267 -0.155629 -0.200564 -0.236947 -0.260875 -0.163407 0.545681 3.493016 12.241614 24.833908 29.253645 40.286812 175.710220 677.216492 1512.816772 8727.200195 65631.046875 60441.253906 6230.139648 662.290588 8843.734375 101658.445313 105813.367188 105681.750000 53153.023438 1108.875732 -0.052649 -0.059739 -0.069625 -0.086735 -0.107711 -0.137679 -0.183482 -0.224252 -0.263169 -0.275434 -0.051042 1.510751 9.646828 38.086372 91.706970 108.423035 100.372643 435.427338 2471.411865 4203.493164 3634.202637 9934.738281 7631.841797 1407.906982 330.453400 3407.631592 120628.375000 200115.125000 200168.921875 14437.361328 563.025452 -0.061411 -0.071592 -0.082271 -0.099521 -0.124189 -0.153385 -0.204358 -0.249120 -0.291623 -0.301467 0.028002 2.344393 15.941380 74.621391 202.414368 235.347534 145.078842 446.074585 2289.691162 3759.459961 1710.472778 1181.306152 828.749634 264.799713 182.035858 4301.296875 101827.085938 105676.757813 103671.507813 30730.814453 588.005188 -0.070224 -0.083590 -0.094381 -0.111985 -0.137072 -0.175183 -0.220686 -0.272249 -0.317945 -0.331828 -0.059920 1.963012 13.959195 65.492706 176.684753 191.317581 108.309158 175.357819 655.089661 1195.041260 2054.972168 6364.911621 4217.659668 649.597961 139.515244 2456.039062 100123.882813 100347.515625 100605.539063 13890.611328 451.245300 -0.085288 -0.096783 -0.106057 -0.124911 -0.152668 -0.187420 -0.232764 -0.286612 -0.336655 -0.368700 -0.231577 0.889500 6.319533 25.574081 61.466183 70.789665 45.463997 77.597832 425.231476 3158.422119 30006.437500 117658.125000 103126.679688 5982.649414 240.073700 368.133636 4872.283203 27117.103516 12470.404297 1327.001465 208.423065 -0.098504 -0.111020 -0.121051 -0.135353 -0.150852 -0.165761 -0.203962 -0.271138 -0.333782 -0.379080 -0.347959 0.008437 1.588425 6.212707 12.946444 14.546549 14.925047 68.385437 876.421753 24300.785156 138999.437500 200087.421875 141881.250000 12407.167969 341.148102 62.306389 207.300156 480.354614 434.198364 355.835724 850.363953 -0.108813 -0.123931 -0.129764 -0.119098 -0.084806 -0.037087 -0.059642 -0.157044 -0.234950 -0.231429 -0.145918 -0.040195 0.170951 0.796226 1.649745 2.369113 6.961499 61.437092 1111.936279 51597.375000 105922.703125 160808.453125 125132.273437 4396.526367 212.296600 47.957764 74.374260 114.575348 240.994339 1901.100464 33188.800781 -0.122860 -0.141493 -0.131506 -0.071119 0.084286 0.253788 0.283897 0.148007 0.127027 0.581581 1.479489 1.959947 1.407525 0.461551 0.046607 0.833160 7.007986 49.374027 518.844788 9630.630859 102139.773438 106737.429687 19181.535156 1465.220581 140.916733 54.523979 86.513687 103.399834 353.869171 12131.911133 105109.242188 -0.143432 -0.153676 -0.130491 -0.006046 0.295289 0.640114 0.741384 0.625008 1.211545 4.015718 9.903120 13.693360 9.723580 3.687672 0.965341 3.184138 26.924612 178.780548 773.002625 2376.359863 18084.257813 89611.515625 42749.492188 3237.503174 212.484772 41.977036 48.086315 58.439964 300.070221 12943.303711 102872.101563 -0.160510 -0.176165 -0.149427 -0.005170 0.331023 0.725533 0.901627 1.119206 3.633888 14.869036 40.605522 61.167274 40.343853 13.665371 3.774595 10.888391 120.777374 1539.776123 13399.083984 24398.521484 26398.509766 100581.328125 69872.039063 4329.974609 235.927002 24.503624 14.922575 19.020296 99.017662 1660.188965 39217.859375 -0.181015 -0.197005 -0.186268 -0.087929 0.149120 0.447726 0.692712 1.462715 6.458424 30.981310 99.932487 154.523712 99.433380 28.638653 7.390614 20.672117 319.692719 7168.816895 100055.179688 100426.625000 42230.062500 19007.179688 10263.101562 1234.827637 109.741081 11.594877 3.173594 3.887080 18.202694 122.973778 674.627014 -0.200198 -0.218542 -0.224255 -0.186622 -0.081840 0.076796 0.366131 1.488734 7.195527 33.429619 106.857834 165.001328 105.937881 30.632793 8.548196 24.717783 311.133240 6620.819336 100208.140625 100514.195313 35088.386719 2401.644775 781.623230 194.359253 31.853418 4.230243 0.447131 0.518212 2.709076 10.614565 29.459139 -0.218911 -0.237813 -0.260118 -0.255485 -0.232067 -0.150191 0.119425 1.167843 4.988945 18.254313 49.758572 74.008064 48.626896 17.686415 11.986793 44.987030 217.767487 1559.213257 12190.534180 22912.835938 10220.240234 6633.710937 2789.060059 416.180267 45.798157 5.243278 1.857411 4.567517 7.664387 8.201534 10.495731 -0.239256 -0.260815 -0.283851 -0.296741 -0.301809 -0.261708 -0.060281 0.616420 2.436998 6.598180 13.688398 17.921885 13.109673 9.827658 42.555874 324.708893 1488.397095 2701.915527 10619.022461 55326.914063 125927.179687 102502.242188 100176.484375 5105.540039 201.970337 16.407919 18.019810 61.058296 120.566292 98.671761 68.940727 -0.257356 -0.285750 -0.311301 -0.323030 -0.334021 -0.323492 -0.221733 0.101608 0.760493 1.783445 2.702579 3.236331 3.304910 13.439281 155.121506 2090.888672 21231.417969 38503.570313 15358.378906 59960.644531 121245.039062 102097.203125 100156.484375 28242.427734 515.751770 40.189545 155.895248 1052.727661 3107.861084 2109.462402 582.985779 -0.278732 -0.308282 -0.335605 -0.350519 -0.368367 -0.368173 -0.340278 -0.244220 -0.062786 0.138600 0.245660 0.334165 1.689620 18.459820 259.970581 5091.623535 86150.937500 100192.476563 22799.582031 17527.599609 102927.289063 100518.375000 100058.148438 19285.300781 422.155945 82.893799 1053.816284 21185.156250 100014.039063 69869.171875 5298.125488 -0.300625 -0.327838 -0.354888 -0.378437 -0.392563 -0.406026 -0.412368 -0.402553 -0.374123 -0.346432 -0.312408 -0.117352 1.190602 13.424864 164.932755 2442.828369 25639.345703 46317.707031 8035.282227 2522.176514 31369.398438 100072.710938 37896.496094 2259.038330 135.575790 129.942673 3105.077148 100003.578125 100037.250000 100331.984375 21441.052734 -0.322291 -0.351834 -0.379947 -0.399251 -0.416250 -0.430924 -0.456914 -0.468902 -0.473089 -0.464421 -0.378588 -0.048667 1.040901 6.170188 46.428299 363.896332 1787.456787 2448.727539 875.698120 293.625702 817.964844 1541.612915 846.972595 176.460602 29.464182 96.330269 2086.881104 69775.257813 100050.367188 100528.210938 14882.740234 -0.343886 -0.375045 -0.404864 -0.425620 -0.439692 -0.458262 -0.483917 -0.502032 -0.519169 -0.500276 -0.351450 0.123678 1.111116 3.056766 9.939329 39.028313 106.337959 137.154434 73.466774 33.438820 42.285950 60.359295 41.896835 15.535645 6.553651 34.554405 416.779968 4684.215332 19315.345703 11428.669922 3181.209717 -0.371831 -0.398715 -0.430591 -0.448362 -0.454239 -0.464736 -0.492316 -0.522084 -0.548196 -0.532585 -0.371869 0.073669 0.973383 1.771868 2.608687 4.787441 8.821242 10.367651 7.587083 6.710845 9.861280 11.535272 8.139814 3.838882 2.114526 7.766394 48.384159 230.367279 537.509399 605.407898 2129.423584 -0.394321 -0.425095 -0.452030 -0.463930 -0.448772 -0.439661 -0.467711 -0.517229 -0.561637 -0.567241 -0.461247 -0.163004 0.372844 0.773357 0.834370 0.787843 1.033795 1.568144 3.890370 13.221840 29.848701 37.629612 23.088135 8.409014 2.390460 1.533818 5.550206 18.289234 47.794888 260.429840 3403.179443 -0.423844 -0.457021 -0.470240 -0.441853 -0.349106 -0.247225 -0.227370 -0.302649 -0.418021 -0.523147 -0.539805 -0.408588 -0.189680 -0.010932 0.054392 0.172890 0.544717 1.701188 7.880331 33.322620 90.143486 115.360092 63.634876 20.171450 5.049030 1.990924 1.520451 2.924093 14.692849 131.897507 1322.891968 -0.451834 -0.473369 -0.424954 -0.195565 0.400331 1.287574 1.758555 1.404838 0.628831 -0.018017 -0.379477 -0.448626 -0.391523 -0.330737 -0.210881 0.097932 0.708269 2.322909 10.539289 47.489906 131.332977 180.522919 93.724571 31.763250 17.547098 19.562681 14.561810 8.112085 10.566512 45.905659 217.901947 -0.478106 -0.450142 -0.127566 1.335463 5.938179 15.263196 20.768560 15.465018 7.115968 2.526359 0.522724 -0.129548 -0.241157 -0.274055 -0.264743 0.025638 0.596822 1.890598 7.739984 31.810343 86.394730 116.929092 83.799660 79.139923 199.449966 369.734467 249.894943 80.168777 45.052101 129.421997 246.587189 -0.490451 -0.301087 1.047679 9.364944 47.219776 158.298935 250.319153 146.676880 46.741993 12.942231 3.224819 0.607481 0.064749 -0.125089 -0.290933 -0.225522 0.069583 0.826496 4.278735 18.123505 61.521839 162.326035 317.344391 650.496765 4762.311035 16053.603516 7220.200195 975.470093 249.616119 967.998230 2343.592041 -0.464522 0.096961 4.416056 40.041065 311.185791 1689.068726 3150.919189 1364.558594 251.215805 44.365677 9.602415 1.916242 0.310982 -0.143900 -0.366475 -0.441463 -0.375030 0.204443 3.806942 27.795752 221.273926 1699.550903 6208.154785 7645.200195 100776.710938 100494.125000 100706.093750 10606.034180 817.067993 2925.321777 8390.810547 -0.350832 0.870500 11.363162 113.856499 1242.336304 10861.308594 24129.191406 7580.078613 828.905090 126.291115 25.200869 4.315650 0.455677 -0.250453 -0.361548 -0.357012 -0.380960 0.088477 5.311321 62.817940 994.784790 19321.234375 100259.007813 94704.148438 106014.023438 103738.554688 107226.265625 30742.402344 1581.457764 1655.480713 3709.584961 0.287309 2.321243 24.899733 311.737976 4711.081055 49043.003906 77085.718750 16420.033203 2190.697021 441.550232 70.090782 9.712852 0.863053 -0.190327 0.025618 0.264064 0.095102 0.256305 6.087535 85.156181 1662.075928 51236.675781 100162.781250 103717.109375 111919.156250 108867.054687 118564.851562 15436.522461 1646.320190 602.197998 467.088898 5.773345 6.119012 53.860943 1175.085571 63239.027344 102192.984375 104696.906250 105066.687500 7677.218262 1275.317261 157.023300 16.761446 1.390020 0.020841 0.648538 1.307517 0.945422 0.425371 3.912268 48.873005 733.361511 12173.701172 86177.539063 46793.929688 8717.299805 18924.865234 13042.572266 3217.948242 913.932434 296.323181 99.742218 68.731247 25.725803 68.367134 1807.702393 100132.632813 100641.898438 101822.945313 104166.140625 10053.853516 1313.018677 158.367447 16.621428 1.290937 0.010881 0.757801 1.587709 1.343091 0.627393 1.556226 15.416719 136.453918 910.316406 2873.586914 2143.870361 679.969849 716.888855 843.209473 832.451050 760.879700 307.997925 77.927116 917.720459 164.742218 60.713470 770.014099 28658.890625 105144.335938 121435.921875 99156.312500 4446.230469 568.368530 78.074295 9.393146 0.613296 -0.269805 0.335543 1.324349 1.895464 1.574284 1.124980 3.304293 17.695778 66.049751 130.873566 117.981125 77.854042 95.325043 201.835953 636.175354 949.250061 367.737885 86.631493 8354.605469 732.092163 68.701141 206.580338 2739.678955 40429.449219 112208.625000 102745.359375 6940.980469 374.749634 35.673473 4.047717 -0.101989 -0.510721 0.076817 1.623960 3.825120 4.492758 2.923753 2.443777 4.908982 10.400881 19.402893 61.609589 309.006592 697.197510 464.454254 329.066925 366.033661 168.918976 69.950394 13437.126953 997.752380 70.525787 87.165276 1217.542114 25878.542969 100283.476563 95961.703125 5576.913574 271.231201 21.319946 1.756119 -0.449162 -0.552349 0.383363 2.956565 6.921997 8.291001 6.681465 9.610636 22.092825 36.363338 65.207100 548.523926 10203.063477 60537.269531 18510.355469 1143.686401 122.364166 54.492237 49.232616 2643.523682 354.171661 36.861755 34.465042 324.224976 3117.015381 12180.358398 7167.832031 1056.796387 95.412277 9.163725 0.761526 -0.380258 -0.012279 3.303151 14.997229 34.000828 34.535511 23.804541 48.572807 168.812469 294.158234 318.230164 3116.049316 100559.210938 100319.625000 100081.953125 8368.052734 185.288452 35.907658 35.683987 221.284103 60.218815 12.076880 9.429677 46.429203 214.225983 479.443298 364.360107 107.091560 19.921402 4.328899 1.247004 0.387488 3.223718 33.640812 255.360306 1012.834351 868.962830 235.279572 199.933853 924.719482 1823.141602 1259.583008 4348.364258 102466.976563 101225.453125 100230.906250 9225.343750 194.982864 35.179642 32.999439 26.304432 13.417706 4.828186 2.356092 5.993982 17.314814 28.840525 24.935522 12.866317 7.726272 6.824385 4.277834 2.482970 14.572946 274.346954 6905.208008 100039.226563 85484.679688 4891.702148 545.514465 1905.625366 4427.612305 2382.670654 2325.616699 16774.164063 97534.109375 28326.726563 1324.763550 80.183624 25.153553 23.573061 9.129599 6.814668 3.028666 0.816618 0.547127 1.371145 2.438609 3.134368 5.492128 10.803048 13.788569 9.387207 5.305339 35.300533 1100.994141 100073.843750 100552.187500 102268.406250 63017.621094 1950.270874 2412.470459 3247.879150 1477.778687 751.296387 1243.994141 1413.412231 652.056213 116.610985 20.574316 11.099811 9.958649 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002132 -0.002663 -0.003289 -0.003990 -0.006260 -0.007392 -0.010695 -0.012250 -0.013708 -0.015055 -0.016000 -0.016529 -0.016714 -0.017431 -0.016834 -0.015814 -0.014604 -0.013195 -0.010702 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002738 -0.003481 -0.004386 -0.007062 -0.010455 -0.012672 -0.015152 -0.017604 -0.021635 -0.023825 -0.026659 -0.027708 -0.028036 -0.027632 -0.026485 -0.024725 -0.022633 -0.018730 -0.016340 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002074 -0.002700 -0.003531 -0.004550 -0.007598 -0.009630 -0.014339 -0.019469 -0.023577 -0.027819 -0.034364 -0.038281 -0.042774 -0.044757 -0.045384 -0.044822 -0.042977 -0.039901 -0.036199 -0.030816 -0.026723 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001909 -0.002553 -0.003383 -0.004483 -0.007668 -0.010091 -0.015353 -0.021727 -0.028733 -0.036199 -0.042940 -0.050592 -0.055967 -0.060475 -0.064055 -0.066257 -0.066272 -0.064791 -0.060273 -0.054332 -0.050706 -0.044310 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002301 -0.003086 -0.004168 -0.007343 -0.009874 -0.017093 -0.022650 -0.031302 -0.040722 -0.050440 -0.056948 -0.063499 -0.070472 -0.077227 -0.084306 -0.088553 -0.090411 -0.091505 -0.088724 -0.081087 -0.072038 -0.062706 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002700 -0.003713 -0.006651 -0.009167 -0.016219 -0.023672 -0.031827 -0.042748 -0.052871 -0.060481 -0.070334 -0.074992 -0.076307 -0.079014 -0.088039 -0.101581 -0.112359 -0.113405 -0.110651 -0.106953 -0.095601 -0.084526 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002269 -0.003130 -0.005743 -0.007983 -0.012929 -0.021798 -0.030144 -0.041019 -0.053315 -0.063548 -0.069794 -0.049813 0.027467 0.150864 0.233683 0.196163 0.056247 -0.057908 -0.104996 -0.116612 -0.120882 -0.123288 -0.113094 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002553 -0.003557 -0.006633 -0.011053 -0.018911 -0.026770 -0.037659 -0.053270 -0.063244 -0.069212 -0.021423 0.243986 1.068882 2.747475 3.952688 3.387663 1.755283 0.615014 0.228907 0.145983 0.062616 -0.048002 -0.112791 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002816 -0.003961 -0.007523 -0.012822 -0.022281 -0.032058 -0.048834 -0.061643 -0.073311 -0.038394 0.318150 2.354872 10.751262 34.337521 61.595604 48.858177 19.171581 6.057775 3.303941 3.000579 2.060947 0.880892 0.146860 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002162 -0.003042 -0.005834 -0.010107 -0.016215 -0.025700 -0.039813 -0.057448 -0.072052 -0.074560 0.102608 1.717220 14.073713 112.984810 680.887024 1655.161133 1136.685303 249.331741 47.714718 34.374222 39.337009 25.877884 9.059076 2.008557 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002269 -0.003197 -0.006242 -0.014030 -0.019719 -0.033072 -0.052087 -0.070865 -0.090033 -0.068268 0.414138 5.383024 69.312416 1134.039429 21186.164063 100011.000000 62913.023438 4024.896484 350.378174 472.870667 735.246582 389.701172 82.969109 12.475200 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003902 -0.005074 -0.011825 -0.017425 -0.029928 -0.043095 -0.068501 -0.088697 -0.110039 -0.063871 0.768804 10.718500 187.649612 6569.377441 100014.960938 100107.132813 100486.554688 42845.578125 2297.323975 10321.093750 25653.390625 7809.934570 680.622925 54.413158 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001785 -0.006090 -0.009439 -0.017113 -0.026155 -0.037639 -0.055741 -0.079427 -0.103361 -0.130558 -0.083913 0.790137 11.324640 214.028015 8527.360352 100070.265625 100982.117188 111140.250000 94842.945313 19708.992188 101172.437500 100086.179688 100007.562500 3366.788086 144.939636 -0.001124 0.000000 0.000000 0.000000 -0.001607 -0.001942 -0.004163 -0.010531 -0.014520 -0.024075 -0.035117 -0.050170 -0.068226 -0.095486 -0.123956 -0.160354 -0.141462 0.442045 6.655824 94.944298 1943.315430 56918.210938 105125.617188 200122.656250 108197.187500 106969.007812 106612.046875 100234.460938 100014.898438 3966.005127 154.511368 -0.001358 0.000000 0.000000 -0.001630 -0.002011 -0.007607 -0.009127 -0.014832 -0.019035 -0.033265 -0.045778 -0.059566 -0.084735 -0.113173 -0.151493 -0.192115 -0.207087 0.025917 2.336369 23.437963 231.405289 1794.987427 11158.916992 105742.093750 106163.453125 103522.062500 27355.294922 57012.875000 13340.102539 1054.216064 69.492630 -0.001621 -0.001188 0.000000 -0.003180 -0.007865 -0.009704 -0.013574 -0.018498 -0.030919 -0.044602 -0.057118 -0.076098 -0.102916 -0.136095 -0.180987 -0.228824 -0.270625 -0.226719 0.474274 5.732374 44.001774 424.143616 8133.315430 121309.562500 186222.250000 111968.828125 5506.532227 1658.623535 700.004700 130.563507 19.496201 -0.003163 -0.001377 -0.003127 -0.007778 -0.009824 -0.013912 -0.019307 -0.028304 -0.041516 -0.056308 -0.074870 -0.097316 -0.126617 -0.166187 -0.216783 -0.275137 -0.330110 -0.359201 -0.073601 2.831963 34.270687 711.582214 42049.222656 100921.812500 101894.164063 101059.734375 13580.086914 375.761322 65.372513 18.645596 12.129247 -0.003569 -0.004507 -0.008480 -0.009479 -0.012088 -0.019386 -0.027417 -0.037192 -0.054853 -0.074671 -0.096248 -0.122178 -0.161346 -0.205648 -0.260778 -0.332042 -0.398671 -0.437510 -0.276609 1.864425 27.645540 561.422485 28280.515625 100151.000000 100235.929688 100149.796875 9357.869141 262.907837 24.426653 9.644047 28.065928 -0.006113 -0.005165 -0.011945 -0.013458 -0.021940 -0.027648 -0.036517 -0.050746 -0.071835 -0.096336 -0.127043 -0.157110 -0.199215 -0.250499 -0.315369 -0.391130 -0.461230 -0.503751 -0.376729 1.112134 13.900040 173.494003 3134.722412 51291.597656 100107.085938 25700.234375 1445.973267 97.596809 22.535542 16.451479 50.780334 -0.011665 -0.013138 -0.015381 -0.020742 -0.027907 -0.037936 -0.050587 -0.068850 -0.088891 -0.125686 -0.161913 -0.198380 -0.242503 -0.297420 -0.362985 -0.430449 -0.495513 -0.504015 -0.054643 2.968131 16.288116 61.032707 247.844284 1032.960449 1704.447388 761.958557 158.767410 118.447952 212.696259 152.157745 77.826492 -0.013469 -0.016486 -0.019468 -0.024914 -0.034813 -0.047766 -0.067109 -0.090089 -0.118020 -0.159128 -0.192065 -0.231270 -0.278321 -0.333543 -0.391433 -0.452336 -0.512899 -0.298799 2.186552 23.496889 180.020386 687.112793 711.775757 266.264954 116.964859 74.964699 252.066162 3055.708008 13653.236328 6286.759766 600.687927 -0.019036 -0.019187 -0.027520 -0.036086 -0.046823 -0.061057 -0.086670 -0.112615 -0.146668 -0.185084 -0.223006 -0.256606 -0.260400 -0.225370 -0.200179 -0.233626 -0.269244 0.509059 9.509698 137.038589 2547.759766 28080.869141 31249.726563 3054.155029 186.201447 122.518227 2155.118164 100393.343750 100279.671875 100084.421875 7605.227539 -0.025556 -0.026442 -0.035535 -0.044069 -0.057534 -0.077522 -0.104899 -0.137409 -0.173257 -0.208722 -0.233077 -0.180678 0.131892 0.869831 1.727710 1.872950 1.436099 2.695479 20.397350 381.017456 16726.669922 100089.976563 100087.023438 20527.322266 510.251221 418.870453 6995.057129 109319.125000 105546.140625 100789.296875 22807.142578 -0.032184 -0.038238 -0.048236 -0.059220 -0.074510 -0.100344 -0.128293 -0.164692 -0.198977 -0.228774 -0.173898 0.341528 2.684379 9.439260 19.383068 20.761339 13.374648 10.275443 31.040001 338.158203 10285.431641 100367.578125 100320.914063 12454.337891 473.427979 1413.146973 29701.740234 185502.625000 177574.984375 104340.515625 5444.938477 -0.047063 -0.053926 -0.063338 -0.074938 -0.092521 -0.121334 -0.153929 -0.190824 -0.227130 -0.228740 0.076438 2.266150 15.492098 73.419235 199.981812 228.544052 97.931923 39.975552 57.532482 174.343506 1253.185791 7458.276367 8068.057617 1345.503784 228.034515 1825.695801 47620.652344 105758.226563 108783.296875 10327.282227 711.824890 -0.058871 -0.067821 -0.076829 -0.090764 -0.112997 -0.145238 -0.183195 -0.220061 -0.255993 -0.211413 0.539671 6.782087 57.712696 446.377045 1786.408081 2087.765625 640.999084 125.701408 107.088402 164.095703 258.451935 534.604553 483.111694 181.885818 141.059341 1780.164429 48229.742188 134756.906250 118737.156250 7935.012695 583.685059 -0.068906 -0.081428 -0.091688 -0.106443 -0.134334 -0.162952 -0.205224 -0.249628 -0.288499 -0.202449 0.928272 11.687668 119.925423 1221.315186 7158.668945 9306.493164 1937.225098 232.436386 110.977768 152.365433 220.315796 398.366791 333.970917 114.639183 138.599304 3840.434082 100756.507813 103592.703125 111981.578125 33094.996094 1854.168945 -0.086074 -0.101382 -0.108237 -0.123036 -0.150945 -0.183717 -0.228598 -0.274094 -0.313063 -0.231198 0.780166 10.435141 105.840508 1052.393555 5537.852539 6568.508301 1536.948730 195.389984 81.322319 276.952972 3167.756348 22860.291016 15136.320313 1424.007690 166.026520 2099.056152 100392.492188 104400.968750 125727.437500 30414.527344 2748.151367 -0.103640 -0.115920 -0.126367 -0.135148 -0.142096 -0.157504 -0.194728 -0.254753 -0.319603 -0.304029 0.274214 5.066185 40.443943 259.736877 977.800598 1134.309570 366.543732 76.539307 110.180519 1438.316528 86539.820313 101231.765625 100393.328125 22795.878906 430.928101 343.774139 4651.546387 23954.689453 17545.791016 7297.128906 1320.123901 -0.112675 -0.132103 -0.131296 -0.085581 0.009803 0.110830 0.113946 -0.033798 -0.211952 -0.278996 -0.058466 1.391532 8.876826 38.228912 99.675400 106.403282 53.816788 32.401295 203.188385 3347.981445 108536.304687 110178.734375 102092.335938 60690.761719 605.184753 72.895493 316.167419 1232.665894 2663.898926 2350.867432 3108.486084 -0.134190 -0.145446 -0.090818 0.138662 0.661127 1.336217 1.387094 0.852935 0.314742 0.277203 0.671293 1.203997 2.214938 5.206419 9.460064 10.156268 7.993522 21.334467 218.838287 2850.715576 38764.273438 117603.617187 103138.781250 8619.673828 266.003845 36.982094 167.398849 1045.431885 3243.695312 7570.355469 75901.796875 -0.157329 -0.147047 0.023020 0.709954 2.359862 4.733384 5.280935 3.428392 2.120426 3.708462 8.463243 11.037704 8.492167 3.709772 1.498275 1.160708 3.091113 16.770481 116.998260 965.074097 4850.183594 7934.432617 3900.471680 596.891296 67.686783 21.002502 91.671967 490.872009 1826.160522 22842.029297 200213.437500 -0.177479 -0.140852 0.160151 1.422651 5.001396 10.064215 11.347326 7.483016 7.444654 25.053013 73.557899 112.643471 73.176559 22.662746 4.600842 1.654560 7.715240 37.486404 125.638397 341.800568 991.804199 1822.957275 1130.322754 269.523834 40.989918 10.902238 28.234543 120.033173 661.461853 11430.182617 200060.562500 -0.201215 -0.159852 0.176598 1.573362 5.556046 11.901791 13.685557 10.528366 21.156616 129.603424 591.183533 1133.696777 590.120605 119.747360 17.414694 5.357852 25.969263 167.303421 652.960327 968.072083 1034.662476 1764.055664 1165.725342 268.385773 36.201530 5.960533 6.570418 26.041960 156.393921 1575.270752 12941.473633 -0.227938 -0.209382 0.027308 1.020201 3.613376 7.443346 9.171607 11.073682 43.878918 368.638214 2445.628662 5539.038574 2442.228271 339.395660 36.587540 9.753266 55.405777 449.604645 2270.690186 3431.703125 1408.213013 759.361328 443.368591 118.449493 20.399664 2.694130 0.981670 4.726818 26.118986 137.893509 501.215729 -0.258117 -0.258816 -0.153019 0.265413 1.323059 2.908118 4.519033 10.473548 51.890732 403.463470 2874.824951 6571.543457 2644.956787 363.498901 39.169594 10.812733 55.841156 429.019409 2123.259766 3192.874268 1221.041260 393.223114 183.559921 57.143497 11.831923 1.431156 -0.245875 0.355287 3.330957 12.860784 30.253141 -0.282580 -0.306962 -0.277773 -0.156582 0.162779 0.807226 2.639999 9.726486 38.443241 180.490448 749.410339 1426.807861 732.661682 145.626526 22.016087 14.103132 46.463005 199.642715 720.361023 1275.874023 2304.945312 4444.665039 2117.986328 347.158905 39.693794 4.054608 0.668748 1.627200 3.214069 4.176261 6.228262 -0.304192 -0.332565 -0.344959 -0.326271 -0.234654 0.126847 1.631553 6.933679 21.657276 53.589951 116.163216 161.099472 101.373657 30.551447 15.411648 48.796753 144.203644 253.038651 601.251221 3759.094238 78087.562500 100170.320313 95858.281250 3968.761475 176.084488 13.528051 6.795681 19.171444 32.452312 29.425545 25.012403 -0.329714 -0.361819 -0.384202 -0.390498 -0.369130 -0.189826 0.576637 3.213291 8.488907 15.177658 18.938225 18.916594 12.548482 8.246358 28.536911 166.375412 644.747742 923.087830 962.334412 14075.913086 100528.328125 100139.539063 100023.429688 21186.611328 447.258514 27.666594 39.639729 175.647186 364.544464 284.907684 132.544022 -0.347962 -0.385544 -0.414225 -0.426065 -0.432424 -0.364366 -0.099136 0.718322 2.117438 3.394657 3.429817 2.769423 2.465464 6.028879 41.396458 297.847137 1322.581299 1827.346191 1000.588440 9625.502930 100178.546875 100056.070313 100011.054688 14596.519531 365.393768 38.622677 176.824585 1316.945190 3967.961426 2661.858887 590.579102 -0.364809 -0.402263 -0.436029 -0.460500 -0.472523 -0.463744 -0.397703 -0.222675 0.060236 0.283859 0.503725 1.159942 2.911600 7.296968 31.757725 177.416443 683.064453 922.318359 472.383759 1525.497681 23332.125000 95843.632813 28232.630859 1930.514282 122.989723 41.073845 364.007233 3965.524170 16008.657227 9340.337891 1380.118286 -0.373084 -0.415623 -0.453359 -0.478967 -0.489438 -0.501073 -0.501625 -0.484514 -0.434514 -0.276881 0.410843 2.843340 8.073274 14.082588 20.786350 56.185966 147.155960 191.194733 108.947464 155.724548 641.816467 1319.053711 731.356262 154.540329 24.111820 29.580410 277.674469 2644.865723 9313.005859 5581.378418 1007.704651 -0.368128 -0.416581 -0.459920 -0.476787 -0.457833 -0.445613 -0.476097 -0.523293 -0.527624 -0.311825 0.849933 5.237174 16.236843 26.095970 23.393740 18.374557 23.882412 26.060661 17.341152 17.380844 35.851242 51.701172 36.080479 13.002652 4.097481 11.316123 82.618599 479.084229 1227.958496 879.040649 334.435577 -0.333545 -0.419632 -0.453053 -0.404885 -0.263081 -0.155662 -0.237843 -0.416865 -0.519550 -0.327465 0.887274 5.510887 17.101044 27.251566 22.754520 11.871361 7.029671 5.006935 3.211893 2.555589 3.468391 4.209552 2.996282 1.069286 0.325460 2.486000 15.125818 54.848717 111.352791 113.461205 167.622086 -0.281253 -0.419347 -0.410835 -0.225224 0.163335 0.431235 0.262777 -0.167876 -0.447571 -0.405136 0.347388 3.080859 9.273110 14.805297 12.835690 7.974840 5.670411 4.395566 3.008203 2.494703 3.212410 3.390750 2.122666 0.540838 -0.212796 -0.013607 1.763336 6.032281 13.988067 38.985783 173.620636 -0.249982 -0.409666 -0.350301 -0.010572 0.647959 1.136130 0.957838 0.349084 -0.075057 -0.260652 -0.039509 0.978402 2.916426 4.622368 5.135865 6.184125 8.805095 9.212382 6.685194 5.808795 7.676428 8.028084 4.980093 1.827071 0.510402 0.292239 0.375925 1.164212 4.745314 21.993553 98.460732 -0.289074 -0.409144 -0.265018 0.226044 1.124069 2.012765 2.620677 2.848064 2.334971 1.341142 0.672725 0.948630 1.667417 2.248722 3.209378 6.990054 13.708735 15.465652 11.201148 8.736073 10.791430 11.619730 7.952500 5.137085 6.438219 8.659841 7.775665 6.651694 14.931802 46.680214 90.816147 -0.395422 -0.412313 -0.121790 0.835783 2.999357 7.009384 12.736461 19.416124 19.204189 10.967654 4.741927 3.574367 4.389885 3.950515 3.529732 6.464068 12.697412 14.454459 10.651286 8.322057 10.388909 12.582010 14.134386 25.770250 67.356255 115.542198 93.821938 59.218868 140.519547 880.199768 2147.965576 -0.476295 -0.381179 0.313393 3.186450 12.317013 33.890137 70.018921 112.747032 117.434059 56.430439 17.877197 8.449284 8.596089 6.939252 3.971208 4.060112 6.428482 7.574090 5.968874 6.318421 13.211602 33.089184 66.691162 174.386368 785.428284 1927.787109 1275.484253 497.453247 1257.538574 22937.958984 100063.195313 -0.498893 -0.217467 1.591833 10.944910 49.798885 153.147949 302.384247 486.570251 488.936920 205.776733 47.732136 13.615564 9.150534 6.731339 3.478400 2.363515 2.466106 2.421176 2.654529 8.213161 43.803097 195.530655 471.308990 1013.848572 7724.485352 31979.441406 19282.390625 4419.941406 5946.420898 101958.789063 100366.960938 -0.445141 0.226216 5.015405 36.619061 207.746399 744.855652 1259.644653 1567.261353 1515.049072 538.762207 105.593430 19.054665 6.643540 4.124587 3.424879 3.712423 2.795562 1.496354 2.164629 15.349101 129.689224 853.392029 2728.458984 3313.370850 26000.513672 200093.468750 142294.656250 52624.324219 18719.773438 51861.109375 101141.023438 -0.189355 1.231055 15.306170 160.598724 1887.950684 12666.980469 18653.246094 19874.175781 21840.574219 4130.112305 374.670441 34.772980 5.432089 3.840997 8.725793 13.627234 10.100740 3.846475 2.718171 19.562752 188.354202 1426.535034 5151.716309 4261.338867 18875.185547 128340.093750 113719.875000 105028.601563 16263.480469 8918.784180 5737.623047 1.226807 3.145356 33.926922 601.180115 19350.554688 100613.023438 113531.867187 156894.640625 101631.601563 31224.054688 1150.403442 61.256454 6.010736 6.209945 20.285887 35.662880 26.088799 8.783425 2.914189 13.482535 107.083504 684.708557 1956.027588 1679.984253 4508.626465 90168.015625 101202.523438 30919.164063 3004.180664 1358.857788 398.126007 10.606742 7.101108 45.227066 916.783264 46332.839844 100595.031250 113465.539062 200113.546875 102492.101563 31221.867188 1143.767334 59.223026 5.576860 6.547288 22.668125 40.235836 29.325560 9.114664 2.395708 5.819859 31.646990 125.853951 270.787750 264.763489 433.849396 2176.701172 3831.824707 1304.624756 341.544861 166.769943 75.869743 64.130363 22.314709 30.913666 428.514038 10250.356445 100497.476563 103048.250000 43786.835938 24429.078125 4386.946777 347.818756 27.926067 2.848878 3.137451 10.605536 18.731403 13.833082 5.075557 1.800175 3.613070 11.449498 26.623985 37.979954 40.805347 60.754299 119.908691 149.959030 107.545471 76.296234 69.255623 141.403625 226.628143 57.746342 19.148474 101.339828 872.086914 4975.559082 8154.421387 3927.898926 1388.854370 362.110626 61.550877 8.194351 0.610257 0.464590 2.482701 4.192533 3.557793 1.951335 2.603561 6.746472 14.904668 22.751373 30.349516 81.561600 349.252808 821.217773 483.202698 114.135254 62.711105 117.779709 533.190491 300.625092 69.101532 14.004863 29.004629 183.578415 994.736572 2624.482422 1772.837524 403.914825 72.112358 12.326865 1.621913 -0.368990 -0.493799 0.030729 0.962859 1.813123 3.188704 9.137395 33.601742 102.839417 173.839951 198.472870 870.893494 12791.145508 76313.257813 22806.029297 1217.168457 113.526054 144.455338 634.288208 123.392151 35.046185 7.284250 10.138764 56.449787 253.493164 562.088501 425.892395 125.685722 23.122143 3.487493 0.023059 -0.597309 -0.342815 1.707043 8.234324 18.098021 21.771965 41.569916 258.727905 1551.145752 3424.725342 2253.777344 7893.052246 111152.984375 104688.671875 100599.031250 10205.102539 241.071228 101.327652 224.901291 24.674101 8.992463 2.440619 2.718716 11.629380 39.095924 70.082993 58.541901 22.192492 5.500230 0.818784 -0.269239 -0.359103 1.685206 19.074169 118.072502 372.618042 359.605408 210.617447 1582.004761 23344.500000 95983.164063 30581.939453 51829.703125 200120.375000 151237.343750 102663.765625 11348.103516 245.147491 63.288963 56.441093 4.094105 1.980411 0.530051 0.392163 1.789712 4.905207 7.601495 6.871880 3.366459 1.157554 0.342358 -0.052161 0.358812 8.752892 127.051941 1973.208008 13694.370117 12508.896484 1643.266602 3685.753418 96241.562500 100489.289063 102793.710938 67890.492188 116885.781250 177525.562500 38175.007813 1711.615234 129.578079 51.084751 25.287844 0.808194 0.449297 0.027769 -0.174642 -0.058044 0.293015 0.589179 0.577207 0.522543 0.607864 0.621312 0.349957 1.231716 20.267208 438.127045 15186.958008 101056.875000 105568.671875 15551.908203 5795.872559 41730.480469 111199.617187 36899.921875 10829.423828 26205.785156 10432.123047 1515.333130 203.865402 54.323246 32.659733 14.328718 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002644 -0.003265 -0.003990 -0.006209 -0.007331 -0.010471 -0.012003 -0.013485 -0.014681 -0.015614 -0.017181 -0.017351 -0.017138 -0.016508 -0.015569 -0.014316 -0.012918 -0.011467 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002132 -0.002738 -0.003481 -0.004354 -0.007005 -0.008550 -0.012476 -0.014833 -0.017220 -0.021271 -0.024496 -0.026220 -0.027288 -0.027581 -0.028505 -0.027360 -0.025743 -0.023528 -0.018315 -0.016033 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002060 -0.002700 -0.003506 -0.004550 -0.007493 -0.009493 -0.014127 -0.019090 -0.023073 -0.029709 -0.033940 -0.039121 -0.042173 -0.044066 -0.044807 -0.044080 -0.042226 -0.039351 -0.035715 -0.031666 -0.026241 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001909 -0.002536 -0.003383 -0.004451 -0.007594 -0.009931 -0.015049 -0.021326 -0.028434 -0.035787 -0.043848 -0.050044 -0.055280 -0.059785 -0.063164 -0.065101 -0.066152 -0.063621 -0.060706 -0.055071 -0.050233 -0.043822 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002285 -0.003086 -0.004168 -0.007241 -0.009793 -0.016781 -0.023774 -0.030974 -0.040377 -0.050104 -0.056409 -0.062677 -0.069354 -0.077157 -0.084175 -0.087234 -0.090947 -0.091039 -0.088513 -0.080924 -0.071805 -0.063809 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002700 -0.003686 -0.006596 -0.009037 -0.014181 -0.023390 -0.031500 -0.042275 -0.052551 -0.061165 -0.069629 -0.074255 -0.076357 -0.079520 -0.091162 -0.104130 -0.114481 -0.115340 -0.114267 -0.110384 -0.099028 -0.088075 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002269 -0.003130 -0.004354 -0.007916 -0.012804 -0.021526 -0.029857 -0.041565 -0.054213 -0.063068 -0.069515 -0.052347 0.014916 0.136024 0.211104 0.159562 0.030673 -0.076685 -0.124195 -0.134591 -0.133357 -0.131453 -0.117387 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002553 -0.003557 -0.006576 -0.010904 -0.016982 -0.026461 -0.038164 -0.053100 -0.062823 -0.069287 -0.027305 0.225688 1.010463 2.470506 3.742284 3.194547 1.534198 0.467808 0.078407 -0.023469 -0.071341 -0.118395 -0.141087 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002816 -0.003961 -0.007456 -0.014121 -0.022142 -0.033013 -0.048829 -0.061462 -0.075592 -0.041601 0.295899 2.118990 10.181019 32.404278 54.640896 43.323833 17.806908 4.762495 1.723198 1.238671 0.773008 0.260131 -0.044357 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.003021 -0.005740 -0.009983 -0.016097 -0.026629 -0.042063 -0.058771 -0.073163 -0.077272 0.091657 1.541745 13.319978 99.788025 550.407166 1420.560669 979.023010 216.043213 35.786480 13.257279 11.919781 8.199698 3.080392 0.674274 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002253 -0.003197 -0.006139 -0.012453 -0.019073 -0.031257 -0.049496 -0.067076 -0.088685 -0.070365 0.384891 5.102892 61.467960 977.882629 16003.674805 95834.476563 46288.824219 3124.232178 225.714340 101.648865 122.647385 73.805466 21.712698 4.201145 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002317 -0.003289 -0.009723 -0.016743 -0.027536 -0.043487 -0.067620 -0.088428 -0.111755 -0.068882 0.678579 9.612074 164.900406 5090.432129 100005.734375 100029.476563 100097.156250 28406.884766 879.318359 743.933411 1230.171509 591.510193 112.857193 15.473214 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.004016 -0.008798 -0.016036 -0.025123 -0.036402 -0.057156 -0.078795 -0.103097 -0.131185 -0.091063 0.736865 10.693373 187.688873 6570.085449 100021.593750 100168.367188 100920.273438 43696.132813 2193.196045 3588.900146 6595.214844 2445.485107 339.929535 34.087646 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001596 -0.005326 -0.008563 -0.010530 -0.022485 -0.033362 -0.048453 -0.069736 -0.093386 -0.125160 -0.161356 -0.148593 0.375334 6.261167 83.587975 1659.778687 41905.921875 100544.265625 104404.070313 18371.435547 5954.226074 4596.831055 7870.179687 2871.664795 364.490784 36.307961 -0.001266 0.000000 0.000000 0.000000 -0.001653 -0.005685 -0.008064 -0.011668 -0.016089 -0.033267 -0.044968 -0.058265 -0.083964 -0.111445 -0.150552 -0.192569 -0.211177 0.006186 2.155725 21.664185 185.851105 1414.461182 4618.837402 9652.568359 19076.980469 7843.756836 1894.635010 1879.965088 858.903259 148.227081 20.585270 -0.001510 -0.001116 0.000000 -0.001641 -0.006948 -0.008530 -0.010331 -0.018430 -0.028487 -0.041677 -0.055616 -0.073007 -0.100729 -0.131720 -0.178996 -0.226858 -0.273303 -0.238984 0.408268 5.202800 37.214718 316.663666 5083.778809 101672.585938 103324.750000 52918.179688 2538.938477 360.897552 143.135971 39.890305 11.279489 -0.001767 -0.001284 0.000000 -0.006870 -0.008607 -0.010701 -0.017278 -0.027217 -0.036490 -0.054019 -0.070393 -0.090893 -0.122281 -0.158302 -0.211184 -0.272772 -0.330650 -0.360860 -0.087650 2.763018 32.517109 595.457336 25942.560547 101574.414063 103135.500000 101404.640625 8831.571289 340.118835 72.892708 31.305738 23.953259 -0.003282 -0.001457 -0.004981 -0.008320 -0.010584 -0.017328 -0.023199 -0.032166 -0.049919 -0.067758 -0.089348 -0.114358 -0.150555 -0.197292 -0.253690 -0.324257 -0.396303 -0.434808 -0.260102 2.069352 28.617912 494.390198 17990.675781 102897.195313 106070.468750 102300.539063 6944.709961 307.097260 95.522820 68.227127 68.152809 -0.005740 -0.007486 -0.012201 -0.013475 -0.018749 -0.024976 -0.035572 -0.047155 -0.066001 -0.090640 -0.116784 -0.148399 -0.185602 -0.238644 -0.303440 -0.384285 -0.456380 -0.504252 -0.368505 1.346939 16.487867 178.591309 2542.609375 32459.593750 88671.500000 18655.900391 1344.720215 151.614532 116.995766 117.140724 122.930771 -0.008860 -0.011133 -0.014659 -0.018619 -0.024759 -0.033662 -0.047355 -0.062307 -0.083173 -0.114649 -0.149635 -0.184856 -0.229310 -0.290239 -0.359921 -0.439247 -0.505917 -0.542007 -0.292263 1.671702 12.732686 77.013336 438.971771 1541.248779 1942.160645 844.708130 190.394180 106.869766 170.226624 149.254089 117.595276 -0.013487 -0.016118 -0.019518 -0.022589 -0.032835 -0.047706 -0.063817 -0.083587 -0.107635 -0.147231 -0.186378 -0.223041 -0.264704 -0.315295 -0.373167 -0.437872 -0.518775 -0.462060 0.490414 7.123808 40.279850 145.855118 399.563660 884.922546 675.131226 208.428940 162.216370 1030.268433 3643.296875 1827.274292 296.908142 -0.017359 -0.020471 -0.024880 -0.032307 -0.043571 -0.060693 -0.080463 -0.105182 -0.141041 -0.176031 -0.212830 -0.231523 -0.194187 -0.073215 0.052727 0.015304 -0.175699 0.005669 3.038971 29.037540 241.450394 1035.192749 1136.281738 563.034302 288.214996 122.950340 725.777588 20551.212891 100053.015625 60511.644531 2152.551758 -0.025987 -0.030732 -0.037566 -0.047831 -0.062815 -0.080514 -0.104468 -0.133730 -0.165633 -0.201140 -0.203762 -0.030642 0.680769 2.472665 4.793993 5.029090 3.134655 1.880109 6.929914 64.250618 740.549194 4351.250488 4785.116699 851.025146 126.549248 128.396469 1637.102905 76553.640625 100370.101563 100103.914063 5229.855469 -0.038341 -0.045643 -0.055047 -0.065702 -0.080093 -0.102001 -0.130205 -0.163153 -0.197088 -0.209660 -0.036126 1.127047 7.165139 28.646097 68.963554 77.887459 38.630779 12.175364 11.900450 64.807884 556.379089 3054.022461 3334.901611 653.273865 105.007294 205.772064 1532.309448 16141.674805 101594.578125 35128.035156 1707.200195 -0.051823 -0.056416 -0.068231 -0.081306 -0.102237 -0.127330 -0.159472 -0.191227 -0.224390 -0.180536 0.500510 6.107920 51.246429 363.317749 1419.877441 1654.022949 551.141541 86.970192 22.741432 41.095940 157.960693 499.196289 497.864594 183.239044 117.902275 311.681030 1689.696655 4893.328613 4922.203613 1922.655396 347.594543 -0.066047 -0.075521 -0.086199 -0.103384 -0.124739 -0.150045 -0.188472 -0.223150 -0.253020 -0.109760 1.594761 20.439417 277.611298 4680.448242 46278.093750 62882.808594 8522.947266 518.645447 48.865044 32.053524 51.516510 77.654427 85.843910 108.680595 210.893066 538.383301 4272.895508 18737.501953 20641.703125 11271.155273 1639.195801 -0.082762 -0.097131 -0.106599 -0.122079 -0.143999 -0.175747 -0.213774 -0.250462 -0.276982 -0.061333 2.653988 38.271317 731.068970 25634.152344 100002.187500 100003.773438 56727.917969 1538.945923 83.550034 36.527897 90.857269 199.619324 183.186172 126.041336 221.723297 884.564148 16370.311523 142221.750000 145841.015625 102503.742188 19415.501953 -0.100044 -0.116020 -0.126114 -0.137497 -0.155394 -0.175624 -0.213671 -0.267606 -0.299256 -0.098851 2.348061 34.117935 590.631958 17559.878906 100004.632813 100007.468750 37890.636719 1229.257812 80.826736 131.540436 1311.088867 7605.139160 5226.827148 712.829590 149.298828 601.849060 9313.121094 141193.046875 120192.539062 101668.664063 51369.285156 -0.117162 -0.133017 -0.135400 -0.108223 -0.037237 0.039752 0.032205 -0.094616 -0.239951 -0.196675 1.194913 14.675577 176.022324 2258.772461 16008.125977 21192.410156 3660.718018 305.764771 62.751602 576.301758 22812.964844 100085.484375 100041.203125 7601.695312 250.840714 196.880112 1913.088257 29301.464844 106071.781250 103197.179688 12954.941406 -0.141622 -0.146702 -0.075223 0.206065 0.847387 1.676788 1.843832 1.056840 0.288629 -0.027498 0.413291 4.196295 29.198471 166.138382 553.823547 639.072144 233.148666 51.392086 59.298141 955.406860 54300.457031 100279.304688 100113.929688 16708.050781 330.615417 104.481407 1131.805054 16249.669922 102069.085938 52826.242188 13627.752930 -0.162549 -0.122231 0.215047 1.613286 5.569365 11.198995 12.476133 7.704802 2.913111 1.541981 2.313558 3.618866 6.201784 15.475107 32.084545 34.326393 19.727779 11.462689 42.866879 438.947845 7927.066895 96364.687500 60637.023438 3338.675537 145.814713 92.210136 1448.737061 34450.761719 100895.460938 125887.523437 107025.218750 -0.178953 -0.037778 0.945072 5.562266 22.965261 54.480907 65.224976 34.740051 12.201674 12.219244 27.518646 40.641304 27.514141 11.327651 4.713449 3.079929 2.373452 4.614017 21.922815 118.285065 574.687622 1596.562866 1281.096436 244.753769 33.576317 49.815228 640.561768 8587.966797 47964.886719 123531.742187 104144.328125 -0.193438 0.053034 1.866555 12.483633 57.811447 164.849228 200.491287 96.544502 37.720539 104.743584 417.936707 785.784668 416.522095 93.512077 13.861268 2.007875 1.556720 5.924213 17.631859 44.133919 98.380203 144.037766 104.980965 38.407543 9.920178 15.300643 116.086533 776.404419 2929.755371 52775.714844 102219.109375 -0.218033 0.075483 2.067454 13.926528 69.233490 213.804077 245.247803 122.589600 101.085487 856.346436 8526.639648 25635.462891 8521.066406 844.365051 64.838806 6.241068 4.284151 16.789886 44.019779 63.185558 69.683006 79.590637 56.744125 22.106716 5.158840 3.457438 15.932405 71.715546 322.868195 3266.132812 31604.980469 -0.259491 -0.047291 1.358524 8.531862 38.545696 100.805496 125.095787 82.825981 224.010269 4012.030273 100031.148438 100011.093750 100002.289063 3964.917236 164.552261 12.099022 7.663515 32.775097 85.598160 115.237366 82.286659 53.355247 32.647015 13.092899 2.847501 0.385797 1.687394 8.594863 38.579247 196.774338 653.475220 -0.303618 -0.210810 0.391718 3.042456 11.487601 27.563004 38.592628 70.084869 331.233337 4910.481445 100145.429688 100040.500000 100007.359375 4307.355957 175.675186 13.086971 8.537381 32.769871 89.825272 118.679237 97.581139 75.987473 47.609917 17.189959 3.598598 0.053413 -0.307725 0.815208 4.626733 15.492731 34.809296 -0.342657 -0.326604 -0.158815 0.514638 2.488686 6.399732 18.610544 85.257202 398.309387 1684.874390 13660.419922 41935.941406 12178.760742 1054.120605 78.552628 8.658653 7.982372 23.430704 63.251194 155.862717 457.488312 860.912842 483.470032 113.947670 16.299999 1.699212 0.063858 0.805322 2.087538 3.261535 4.551450 -0.371730 -0.385128 -0.365829 -0.219591 0.296060 2.188319 12.061001 68.698921 279.132660 606.693787 911.436768 1290.493408 645.503906 129.696030 19.138193 8.228806 15.197309 29.564728 88.823570 636.060242 6063.584961 17572.777344 7162.172363 785.968018 64.819038 6.216017 2.091895 4.907228 8.369728 8.371447 7.772385 -0.392122 -0.429675 -0.448317 -0.428833 -0.271815 0.641184 5.424685 26.396614 91.466621 159.100891 132.157074 86.801628 44.756180 15.316030 7.166148 14.914880 36.668179 55.774677 149.253174 1825.960205 34346.261719 100011.671875 46280.328125 2442.213867 135.999100 11.337040 8.081737 22.069307 39.565342 33.885864 24.685331 -0.397070 -0.458540 -0.488601 -0.502946 -0.464856 -0.146319 1.292802 6.432979 17.652437 25.707008 20.835991 12.479738 8.003167 6.918849 9.140549 22.561546 53.445023 72.406189 137.373199 1557.242065 23308.392578 100005.570313 31114.123047 1929.930420 120.254768 13.207810 21.500526 79.173248 157.263153 125.846680 62.494812 -0.356890 -0.461959 -0.516463 -0.534970 -0.539573 -0.469439 -0.153478 0.756166 2.259884 3.595383 4.281301 7.981187 20.001076 31.311134 28.414652 25.410934 40.201725 48.951187 63.624889 375.347626 2648.975098 7160.128906 3104.374023 446.137421 46.055428 10.412014 36.544044 154.992706 319.247589 248.790817 98.635780 -0.265592 -0.423768 -0.511202 -0.525748 -0.494690 -0.466598 -0.430333 -0.346601 -0.108471 0.646467 4.796023 25.592663 93.588081 176.148865 130.699600 51.499195 25.146044 19.784777 19.396093 52.813229 188.685684 339.766907 213.003342 57.430458 10.335714 6.074678 28.599464 120.029709 244.417358 192.456482 77.319138 -0.042409 -0.333609 -0.439320 -0.314265 0.023659 0.274850 0.130151 -0.238399 -0.342868 0.720594 8.673155 57.468788 259.696564 551.053650 393.079926 115.991035 31.127308 13.787221 7.212877 7.754941 15.891213 22.741180 16.020922 6.074275 1.478830 2.304322 12.039043 42.817841 78.812828 65.382523 35.972546 0.412582 -0.156030 -0.202207 0.502642 2.279621 3.781165 3.057811 0.982751 -0.056584 0.715093 8.627114 61.021584 277.707581 635.379333 423.924316 131.513931 43.129822 21.220238 8.749056 3.452361 2.125928 1.890871 1.072921 0.092145 -0.383283 0.099566 2.690659 8.650919 14.478258 15.547927 17.320942 1.093868 0.075797 0.286354 2.457908 7.988837 14.287996 11.068526 3.864521 0.603202 0.422792 4.978138 30.325283 113.180809 230.235947 174.910507 79.090126 53.909832 41.264385 21.747425 8.775768 4.088127 1.867430 0.414625 -0.410351 -0.714284 -0.624495 -0.125510 0.956122 2.483238 5.383661 13.549883 1.658923 0.291865 0.937082 4.714313 15.123686 24.812969 19.300959 7.429985 2.037809 0.827867 2.227709 9.242854 26.514475 45.014324 46.350872 59.007980 115.357201 123.286392 66.216705 26.698029 13.928143 6.878784 2.135633 0.109489 -0.415948 -0.400468 -0.183943 0.393211 2.052396 6.237980 13.226396 1.450762 0.400101 1.584824 6.135917 15.333324 23.246357 20.497425 14.619490 11.110674 6.671720 5.499218 10.394462 17.936644 19.884859 26.737473 85.982887 234.019485 303.394348 140.423187 55.360947 31.035084 15.960864 5.036942 1.679394 1.739583 2.954656 4.083489 7.501830 21.930264 69.348305 114.176178 0.590667 0.311223 2.010230 6.875777 15.180567 25.203695 48.019482 99.451508 115.890648 58.935093 27.014578 39.782410 66.682419 54.488857 36.311512 81.388870 217.680984 265.262421 135.343826 59.607002 39.617001 20.263174 8.197158 7.649610 17.522289 31.249842 42.110352 77.188271 286.966461 2021.737427 5738.175781 -0.089090 0.145004 2.066146 7.974570 21.685223 66.858444 318.322388 1236.598511 1544.155518 565.564941 119.921944 97.748947 166.646820 127.315727 48.853226 43.132206 88.442871 98.428459 58.510464 33.140865 26.093204 17.258591 16.111599 36.876842 135.752533 364.095795 524.347046 977.265076 4101.339844 101227.453125 100278.546875 -0.394028 -0.003540 2.129674 10.435480 39.945736 191.124100 1609.084839 11217.498047 16100.914063 3432.124023 376.573669 124.218697 162.304565 120.574768 43.664661 23.020308 24.687077 24.021906 16.089092 12.236829 14.232849 24.861580 48.710896 157.321594 1181.957642 9913.457031 21340.927734 20675.716797 103757.515625 141883.328125 103108.343750 -0.470605 0.033805 3.018116 18.082081 83.366211 385.493683 3270.878174 27796.558594 40356.417969 7330.246582 631.829529 103.165306 69.668358 50.644508 35.265133 36.005489 27.764313 13.669778 5.860849 5.448173 16.084423 55.254013 120.951897 445.216309 11667.312500 101461.281250 104161.648438 200274.671875 105979.554688 200099.015625 116014.304687 -0.405053 0.366936 6.439730 48.678146 329.837921 1603.189331 11711.747070 107037.273437 109392.164062 23468.066406 1163.199951 97.756721 26.947741 35.283394 116.875336 244.148743 151.930252 41.069595 8.208361 5.050293 20.261881 74.102531 165.720978 613.933533 33560.507813 100811.812500 103321.140625 200155.437500 106722.828125 104496.617188 28867.699219 -0.093974 1.032966 12.585882 134.426117 1486.050049 10767.730469 112348.625000 103247.250000 100998.375000 100308.015625 4027.144287 135.901962 19.775309 67.301506 463.096130 1191.428833 683.158020 121.206192 15.190211 7.064625 21.687483 61.578751 107.794128 304.170288 8458.624023 100190.812500 100743.734375 107866.843750 40000.039063 19513.861328 2049.220703 1.132811 1.761481 15.385301 180.968170 2502.510254 20827.642578 125668.867187 104739.234375 100424.750000 100060.945313 3978.469482 124.312752 16.266907 73.948273 536.894897 1522.887329 795.179443 136.523376 17.763300 13.793182 47.814106 99.359917 96.930458 90.427185 565.552185 4870.467285 9267.380859 2839.748047 1179.946533 714.330383 277.587036 4.904566 2.957894 10.565026 103.964630 942.865356 5532.378906 16781.992188 101695.343750 100207.531250 23319.371094 981.704407 55.535488 8.162708 33.646954 177.259399 395.625214 254.634918 58.253227 15.032013 27.555935 96.492088 201.790939 154.601242 58.069778 59.508102 146.653900 206.410736 162.382996 167.847122 309.134979 1514.050049 11.686469 4.868709 5.229869 29.523605 176.192703 627.031006 1192.065430 2558.677979 2935.152344 798.882935 114.753044 12.609894 2.245615 7.005228 25.651247 48.954670 34.140305 15.290153 18.187860 46.687344 105.310661 185.828644 146.485229 100.336678 178.432388 272.518127 187.006760 131.707504 376.966400 1283.699585 15592.316406 13.947752 5.385157 2.433620 7.774123 33.206692 94.337303 161.209045 167.801865 121.424644 50.598213 12.950484 1.898216 -0.080413 0.478754 2.557467 4.550915 5.255142 10.407831 39.223866 124.630844 320.502625 483.706146 453.753204 1026.757324 3470.183838 7130.515137 2973.755859 481.332245 815.154724 2577.271240 21809.980469 7.816630 3.134836 0.981657 2.180756 8.872773 25.469290 41.372898 36.575722 19.214436 6.606941 1.502921 -0.208876 -0.623957 -0.460708 0.484482 2.972461 8.001945 25.194679 127.964378 876.873962 6789.624512 19477.300781 9652.584961 32585.351563 116771.203125 137932.890625 36927.566406 1801.503052 723.824829 1512.612183 3652.473145 2.330548 0.887659 0.140527 0.376096 2.125122 5.677590 9.138948 7.872890 3.849463 1.036577 -0.154563 -0.560996 -0.603146 0.198843 5.016772 24.420258 63.725521 95.887123 394.708893 7028.437012 100483.726563 100491.101563 112240.437500 109277.500000 118851.507812 200266.796875 55050.257813 2371.929199 782.652771 742.320801 502.200226 0.305257 -0.004729 -0.216095 -0.188668 0.155255 0.776849 1.320410 1.078870 0.411271 -0.137332 -0.430574 -0.551008 -0.319275 2.537820 26.047779 187.658447 626.418274 677.011169 769.579590 19885.460938 100907.710938 100996.757813 116206.640625 128486.015625 102879.445313 108343.132812 25501.347656 1397.632446 1227.463501 953.292053 283.728912 -0.170383 -0.236847 -0.303064 -0.320746 -0.272250 -0.192439 -0.120452 -0.164190 -0.253525 -0.351086 -0.414815 -0.458763 0.052970 5.910820 68.534256 704.886780 3666.335205 5465.164062 3940.555664 13401.222656 134514.765625 128421.726562 106749.265625 96584.015625 100634.312500 100877.507813 4694.233398 617.815857 721.823914 559.563660 159.866638 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002060 -0.002571 -0.003174 -0.003877 -0.004617 -0.007017 -0.010055 -0.011484 -0.012828 -0.013954 -0.015809 -0.016412 -0.016570 -0.016366 -0.015728 -0.014856 -0.013742 -0.012406 -0.011020 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002088 -0.002663 -0.003383 -0.004229 -0.006718 -0.008240 -0.011901 -0.014115 -0.016368 -0.021234 -0.023259 -0.024986 -0.025890 -0.027634 -0.027305 -0.026158 -0.024636 -0.022651 -0.018936 -0.015294 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002626 -0.003408 -0.004386 -0.007215 -0.009131 -0.013453 -0.016618 -0.021954 -0.028368 -0.032459 -0.037419 -0.040374 -0.042287 -0.042726 -0.042166 -0.040311 -0.037573 -0.034187 -0.030442 -0.025189 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002483 -0.003289 -0.004322 -0.007280 -0.009491 -0.014330 -0.020322 -0.028060 -0.034287 -0.042077 -0.048189 -0.053263 -0.057420 -0.060614 -0.063290 -0.063163 -0.060715 -0.057971 -0.052641 -0.048284 -0.042359 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002222 -0.003000 -0.004048 -0.006972 -0.009360 -0.016027 -0.022648 -0.030541 -0.039957 -0.048370 -0.055027 -0.060907 -0.067208 -0.075528 -0.081234 -0.086671 -0.089246 -0.088296 -0.085536 -0.078197 -0.070787 -0.061879 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002626 -0.003582 -0.006327 -0.008640 -0.013565 -0.022412 -0.031010 -0.042043 -0.051429 -0.059635 -0.067931 -0.076120 -0.080236 -0.085796 -0.097071 -0.108102 -0.115826 -0.116955 -0.116251 -0.110520 -0.100363 -0.088928 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.003042 -0.004198 -0.007574 -0.012257 -0.020674 -0.028469 -0.041370 -0.053191 -0.061650 -0.070148 -0.066390 -0.029710 0.034929 0.077680 0.051245 -0.036996 -0.108835 -0.143416 -0.146846 -0.143555 -0.135058 -0.120666 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002483 -0.003456 -0.006342 -0.008928 -0.016375 -0.025359 -0.037705 -0.051819 -0.061502 -0.073267 -0.051621 0.095107 0.539664 1.378999 1.990145 1.683692 0.809027 0.187765 -0.068816 -0.137701 -0.155305 -0.164949 -0.159895 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002738 -0.003849 -0.007134 -0.013658 -0.021286 -0.031651 -0.047171 -0.061793 -0.075375 -0.062208 0.137059 1.182132 5.114096 14.053301 23.075701 19.542841 8.263609 2.345594 0.614328 0.221321 0.064650 -0.082334 -0.167237 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.002937 -0.004168 -0.009618 -0.015555 -0.025693 -0.039689 -0.058585 -0.072027 -0.082551 0.016865 0.846062 6.640968 38.455482 164.841827 339.821136 260.279663 78.857018 15.362877 4.216179 2.581784 1.610959 0.611047 0.002953 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002192 -0.003108 -0.005919 -0.012066 -0.018534 -0.030067 -0.049167 -0.068044 -0.084655 -0.085813 0.182945 2.715760 25.801218 259.949585 2086.809814 7159.545410 3967.455811 638.199219 72.370628 19.553514 15.902871 10.180636 3.767400 0.802183 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002253 -0.003197 -0.007803 -0.013022 -0.023283 -0.042850 -0.062649 -0.083865 -0.109221 -0.095477 0.356103 5.070285 61.436558 977.919556 16003.950195 95835.851563 41868.359375 3128.395508 219.616364 68.786934 72.350624 43.626637 13.968982 2.813727 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002253 -0.005106 -0.015121 -0.022230 -0.034942 -0.054675 -0.077729 -0.101180 -0.129098 -0.123011 0.346183 5.319056 69.285210 1134.378540 21188.439453 100021.679688 62948.578125 4077.547607 321.768158 160.188583 195.703949 108.203873 31.027300 5.580363 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.007819 -0.009635 -0.021021 -0.032493 -0.046380 -0.067651 -0.092346 -0.122180 -0.157491 -0.171540 0.137760 3.266162 34.446171 391.184052 3977.283203 14656.376953 8732.522461 1399.819214 354.120453 217.177917 224.276901 122.086983 35.423576 6.693122 -0.001164 0.000000 0.000000 0.000000 0.000000 -0.003611 -0.006140 -0.009429 -0.015211 -0.029825 -0.042477 -0.058629 -0.081094 -0.106998 -0.144125 -0.188107 -0.222930 -0.106709 1.120606 10.129924 70.303101 352.705902 936.224304 1282.766968 1409.916504 737.527100 291.712128 189.772995 99.480606 31.332846 7.951866 -0.001377 0.000000 0.000000 0.000000 -0.003718 -0.006418 -0.009000 -0.016651 -0.024659 -0.038879 -0.054996 -0.071191 -0.094636 -0.127360 -0.173181 -0.224011 -0.276877 -0.272318 0.126193 3.056048 21.176489 149.283707 1246.065430 9330.208008 19025.644531 6608.437500 1155.742798 554.682556 227.740723 64.189522 23.051268 -0.001610 -0.001180 0.000000 -0.003659 -0.007558 -0.011303 -0.015472 -0.022511 -0.033539 -0.050513 -0.066426 -0.088317 -0.118716 -0.155290 -0.204947 -0.267623 -0.328755 -0.369689 -0.159530 2.126207 23.718145 305.739807 5304.038574 93100.398438 200076.875000 55824.699219 4258.838379 1656.022583 683.382385 254.556213 109.306641 -0.002944 -0.002532 -0.003221 -0.008564 -0.014294 -0.017183 -0.024119 -0.033589 -0.048985 -0.066682 -0.087852 -0.114577 -0.148282 -0.190744 -0.247711 -0.321150 -0.390513 -0.433323 -0.248061 2.137642 26.807880 376.747192 7676.591797 128345.835937 177610.562500 116298.632812 5798.183105 1804.038574 1625.966431 1453.275269 494.196716 -0.006307 -0.006822 -0.009041 -0.014677 -0.017836 -0.023284 -0.033562 -0.046025 -0.064633 -0.089433 -0.115238 -0.146946 -0.179786 -0.231755 -0.296020 -0.372657 -0.446819 -0.498392 -0.321458 1.956533 23.646053 262.929047 3316.035156 43037.742188 106918.179687 30676.638672 2191.458740 1046.730591 3563.652832 4108.030273 1053.728271 -0.009007 -0.008471 -0.014137 -0.018032 -0.022011 -0.030678 -0.045191 -0.061933 -0.085897 -0.114404 -0.146163 -0.177799 -0.218871 -0.278428 -0.345007 -0.427689 -0.495237 -0.536328 -0.302149 2.310640 28.181995 350.691589 5214.457031 32053.443359 22292.382813 3443.984619 467.640594 452.551666 1791.194946 2089.044678 666.701782 -0.012618 -0.015801 -0.020731 -0.025076 -0.033610 -0.047701 -0.063316 -0.083244 -0.109173 -0.141647 -0.173687 -0.209153 -0.249065 -0.292041 -0.343491 -0.421955 -0.481890 -0.438368 0.094797 3.688619 32.722996 452.770233 8411.410156 70706.507813 37066.425781 2540.712646 209.374695 226.148880 523.792664 468.062012 220.457321 -0.017653 -0.023360 -0.027897 -0.036924 -0.044833 -0.063020 -0.083901 -0.106583 -0.136077 -0.164321 -0.198843 -0.202825 -0.137014 0.046696 0.232062 0.212311 0.057512 0.315193 2.047079 8.738283 38.800713 237.750793 2114.782227 10130.041992 6373.265137 816.260925 175.513336 819.600708 2573.105957 1433.023193 244.817001 -0.030556 -0.035571 -0.041543 -0.052421 -0.064501 -0.089151 -0.110700 -0.134462 -0.164418 -0.190779 -0.173953 0.071487 1.111707 3.914274 7.508143 7.952351 5.014680 4.096981 10.378745 28.693493 66.189316 159.533737 325.042053 570.574890 441.422302 142.348267 208.076401 1573.243286 5757.466309 3047.365479 353.016541 -0.042418 -0.051479 -0.060456 -0.069819 -0.090846 -0.112590 -0.135988 -0.166267 -0.195806 -0.196770 0.048926 1.729603 11.139122 51.290779 127.808853 145.223343 66.542160 24.493341 38.400154 101.900604 150.093674 160.505463 151.794189 146.400864 167.744247 161.417892 265.309113 889.978394 1984.605225 1173.656128 190.685608 -0.057513 -0.067051 -0.078387 -0.091166 -0.113777 -0.140457 -0.170012 -0.198198 -0.227962 -0.150030 0.831194 9.483952 93.749634 844.982788 4307.492676 5091.245117 1320.430054 171.078430 91.836014 235.743362 297.306183 185.331100 147.578476 455.897614 1307.012085 1197.451294 1155.709106 1944.614868 1639.810913 854.011536 227.643250 -0.074424 -0.089382 -0.102943 -0.116789 -0.139254 -0.167283 -0.198796 -0.232685 -0.250314 -0.039616 2.416779 34.204151 590.850281 17560.431641 100006.257813 100010.187500 37894.406250 1242.833374 143.718185 243.861923 293.315155 162.268204 210.739838 1771.912354 7680.889160 5878.303223 4950.090332 14361.311523 41094.679688 28726.250000 3424.793945 -0.097133 -0.111173 -0.120330 -0.139766 -0.162185 -0.191294 -0.228194 -0.262584 -0.272955 0.033496 3.968123 65.343414 1931.786499 100008.195313 100026.359375 100044.726563 100038.796875 4338.803711 186.272751 122.949806 145.582611 117.117043 209.703247 1630.608521 7683.261719 5507.325195 7698.799316 109682.273437 103880.921875 100573.015625 62953.640625 -0.119308 -0.133137 -0.145603 -0.149193 -0.141901 -0.135984 -0.168694 -0.229426 -0.281320 -0.007372 3.761676 58.282658 1535.648560 100018.757813 100066.570313 100122.875000 100099.875000 3419.264160 162.682343 100.147919 230.439056 566.967285 522.891602 489.519775 1215.494507 1229.437622 6571.589355 102764.812500 101890.125000 100738.789063 100174.484375 -0.142290 -0.157386 -0.128807 -0.001909 0.313596 0.670856 0.685483 0.367764 -0.044433 -0.076285 1.940778 24.846060 367.642792 7180.763184 95909.859375 100157.484375 13446.302734 736.448364 93.185349 139.446655 1041.372437 5226.285156 3975.419678 627.034546 160.083298 260.042542 2729.334473 103961.492188 138104.953125 119408.195312 40170.570313 -0.171438 -0.141333 0.116257 1.136518 4.033568 8.078495 8.973622 5.206514 1.832259 0.438525 0.829301 6.595208 51.473335 353.368683 1360.864014 1612.140747 543.141357 109.148842 40.874649 151.593475 1679.669312 10150.219727 7593.777344 866.201599 85.403893 180.862366 4269.761230 103148.468750 116128.289062 113231.906250 33467.437500 -0.188589 -0.009933 1.191337 7.262838 32.255989 78.011330 93.715805 48.553547 13.739032 4.038833 3.920748 6.033733 10.500147 29.305679 64.725479 75.796211 47.365993 18.890125 15.690537 73.385262 599.390686 2346.977051 1810.116943 320.418610 44.311501 196.705750 7841.587891 100170.375000 100894.656250 116315.195312 163086.015625 -0.180621 0.309189 4.234524 32.248581 213.313995 785.714844 978.117859 364.847321 69.756523 27.190002 52.772133 78.344910 52.217583 19.336399 9.702656 7.915847 5.645045 3.335180 5.164286 20.565559 85.266846 203.406601 161.561447 49.270004 15.620731 107.751022 2448.547852 100057.898438 101242.031250 177534.937500 113783.843750 -0.162810 0.736248 8.989841 88.127701 844.802612 5090.349121 6570.157715 1793.648682 231.060089 224.213928 1138.568359 2257.957520 1133.688965 199.953690 24.647579 3.294775 0.701238 0.761130 2.308415 6.257631 13.910666 21.066525 17.697098 7.370096 4.163071 28.772562 319.973846 2901.233154 11855.073242 37725.175781 101711.179688 -0.179569 0.816875 10.567453 112.867233 1222.027710 7810.706543 11128.922852 2472.675781 430.167480 2704.774414 56750.375000 100009.390625 51214.875000 2442.058105 127.496498 9.266191 0.876578 1.364712 3.341255 5.314482 6.393888 6.687340 4.747669 1.903668 0.702942 4.827603 31.249540 141.780746 427.319824 2481.325928 17946.345703 -0.231140 0.479579 6.492563 58.003304 447.863312 2093.597656 2891.802002 953.314636 803.529358 19720.529297 100264.242188 100065.656250 100010.945313 17559.296875 388.823578 18.136824 1.832883 2.616282 6.011013 8.031742 7.009284 5.369740 3.186122 1.065319 -0.196507 0.098531 3.003235 12.067132 39.640923 155.998047 513.801941 -0.294181 0.037565 2.300452 15.846997 84.902077 253.565170 351.795288 521.082642 2945.086182 28848.287109 102647.898438 100389.531250 100040.375000 21187.556641 416.731812 19.317251 2.147707 3.310666 7.220984 10.880982 13.297344 14.002552 9.502764 3.611039 0.416371 -0.402902 0.266917 2.529799 7.212509 16.389404 33.569141 -0.352355 -0.247688 0.368058 3.150624 12.431583 35.037144 109.573952 954.638245 10354.919922 37978.554688 107998.132812 101052.617188 95907.984375 3372.890869 154.937744 10.711988 1.803024 3.364191 9.093260 24.492823 62.108105 89.956558 61.674099 20.200729 3.973829 0.453656 1.532701 6.571637 14.090820 15.834311 11.371390 -0.391633 -0.393182 -0.261034 0.360097 2.430208 9.975919 65.713165 742.834900 7846.251953 23593.582031 10307.782227 4809.568359 1855.345215 283.963379 31.216610 3.879348 1.983339 4.416493 15.491035 78.180695 320.737030 591.677429 363.517792 87.718941 13.523849 2.216343 4.438407 16.587435 36.718639 41.322601 22.818405 -0.363130 -0.460937 -0.466824 -0.296557 0.409744 3.711458 25.986565 202.465973 1227.583008 2669.060059 1390.421997 341.117218 103.515602 27.984060 6.951588 2.764870 3.255691 6.128955 23.554169 158.159653 846.981201 1787.043457 977.523743 186.895721 23.983742 3.834201 6.449302 23.814875 51.693398 57.797741 30.341799 -0.177666 -0.450922 -0.535180 -0.511730 -0.273449 0.764554 6.340834 32.544281 113.545082 189.722092 126.192108 47.383156 24.556633 22.812639 16.914743 9.082974 6.087928 7.180511 22.161703 138.486267 681.617126 1420.203979 785.294067 164.264008 21.455448 3.641201 6.254624 19.943499 40.464256 43.216431 25.016470 0.247092 -0.326944 -0.540577 -0.583624 -0.521659 -0.269402 0.743690 4.001570 10.489199 15.544487 17.114611 37.201218 129.382721 243.950806 177.460114 58.796135 17.208248 8.507819 12.194701 49.888298 200.242950 339.429077 212.894623 57.325161 9.765909 2.190796 4.878596 15.145120 26.489119 25.014341 15.434032 1.041469 -0.011199 -0.432865 -0.436226 -0.210712 0.006215 0.061228 0.181751 0.864549 3.319432 21.324505 187.624588 1316.847900 3654.142822 2094.678467 409.205322 72.883675 23.575350 10.030471 12.548355 32.435902 48.093853 33.701149 11.987622 2.545516 0.765012 3.150775 9.460425 15.394700 14.062000 8.698163 2.956842 0.747483 0.045679 0.769885 3.052814 5.410267 4.160487 1.494803 0.386342 3.813098 45.344139 590.070679 7159.114258 31119.541016 14627.519531 1632.862183 251.180878 90.245186 26.193512 6.974519 4.953259 5.459836 4.080959 1.368286 -0.033683 -0.168075 1.059064 3.800564 6.307703 5.868846 4.018943 7.113340 2.156043 1.465054 6.688748 26.266043 49.230408 37.880634 12.224522 2.393327 4.185194 48.045177 633.497864 8522.420898 37896.644531 17638.486328 1939.801636 554.474060 259.135559 65.744820 15.207875 4.993507 2.157207 0.553318 -0.300936 -0.674580 -0.634716 -0.208653 0.639253 1.375172 1.528591 1.595245 13.127074 3.780917 4.602319 26.755630 137.131409 296.306671 205.714844 49.478813 7.516012 3.183573 24.319935 228.272797 1789.177734 5106.413574 3201.076172 896.140381 721.214233 479.587494 170.331558 53.276699 25.942223 11.645748 3.218501 0.121918 -0.667760 -0.726910 -0.533069 -0.253011 0.042102 0.394218 1.007861 19.184740 4.945209 9.462545 54.212776 291.465576 747.830505 468.079712 98.923698 14.198070 3.944785 9.682790 49.644764 187.971481 387.048431 357.308228 593.664612 1990.254272 2555.140137 860.554016 245.490387 142.426620 62.621449 15.222238 2.080947 -0.237104 -0.372227 0.080939 0.695323 1.641540 3.084582 4.364441 16.692543 5.374304 15.388130 67.029160 236.881195 489.769928 308.656525 92.924385 35.982098 20.129457 23.177794 69.846245 144.108551 133.435928 182.579132 1273.540039 8570.513672 12217.625977 3018.005615 777.063721 575.977234 202.139801 40.475918 5.660241 0.987953 1.533345 3.956378 8.855542 19.590904 47.422749 71.400200 7.789422 5.042303 20.563988 80.039940 193.632156 236.933472 242.725082 427.011932 492.873566 225.774643 138.240417 524.009460 1373.621582 943.679016 325.541199 1197.747681 7842.622559 11164.467773 2847.241455 991.366943 868.805664 299.081024 54.802025 8.768927 6.320342 13.981754 32.982658 93.846283 257.514069 959.176086 2171.300537 2.221069 3.834306 18.532003 75.164322 203.025970 428.925781 1972.620728 13386.089844 19322.947266 4079.162354 679.593872 2181.892090 8390.654297 4460.467773 687.015259 446.837158 1373.941040 1823.290771 706.997131 433.928680 400.993958 156.357895 34.522434 14.925832 43.863605 150.657257 388.916046 1784.463623 6123.604980 28357.070313 100515.562500 0.338448 2.117251 12.731317 66.934273 335.020020 1362.687012 19905.916016 100215.070313 100169.320313 70164.250000 2602.387207 2209.789062 7045.447266 4094.471680 623.135742 193.908081 199.413116 188.562378 113.960251 90.120773 82.298775 41.079975 18.415998 48.994820 429.852417 2999.811768 7408.519043 71482.734375 102981.054688 200046.484375 108536.921875 -0.251917 0.939381 8.487563 58.334332 363.709869 1902.670776 47363.406250 101829.328125 102054.804688 101123.000000 4236.700195 1047.875977 1214.031372 727.138794 283.408661 273.351135 206.340988 88.599854 31.678265 17.315870 14.415271 12.391412 20.053995 156.973297 3447.094727 99242.828125 110230.429687 133349.937500 102675.257813 148553.296875 162950.171875 -0.425507 0.317030 5.355113 35.858067 198.427185 1117.109863 17645.113281 195948.203125 200078.203125 49146.929688 2381.649170 416.815613 181.417557 231.338760 1463.676392 4862.770508 2462.621826 346.175079 45.534504 10.421129 11.667287 20.409473 32.152699 246.237549 8386.565430 100255.132813 107882.187500 200260.156250 102877.890625 102426.265625 51667.246094 -0.416039 0.116305 4.081205 29.148148 173.215424 1625.094360 70910.382813 104460.968750 106079.820313 101589.773438 3377.548828 189.851242 68.560570 644.082642 15108.335938 100090.343750 34890.214844 1583.065186 89.605354 26.669683 82.575027 196.047211 157.776306 163.811264 2655.238037 56706.453125 101385.546875 50523.765625 101583.046875 78216.054688 5025.128906 -0.269914 0.146676 3.692299 27.898830 182.018143 1656.405762 70313.289063 100346.492188 100230.687500 100102.937500 3138.705078 121.616631 48.258720 797.732056 22744.644531 100034.226563 54081.679688 1988.289062 101.707962 102.248856 697.100708 2551.958252 1662.566406 304.091187 293.861938 1770.526367 3330.608643 2051.147949 2527.268311 1728.840210 656.264038 0.076359 0.175599 2.382843 17.209934 99.647980 568.018921 7410.754395 100119.664063 100037.812500 16015.010742 790.193298 51.617027 21.500668 237.264038 3029.487549 12345.410156 5218.962891 513.321716 90.404015 283.961151 2466.633789 12405.503906 6916.985840 744.393860 82.147377 107.995682 259.509399 639.356873 1197.982910 1962.650269 8562.300781 0.516909 0.194537 0.999235 6.413827 28.740314 110.243446 477.576080 1819.295288 2268.391357 683.494995 100.307487 12.240731 5.426481 33.470245 177.583801 427.651428 259.149902 84.584496 158.021530 599.618591 1983.559570 6550.580078 4037.045654 553.759277 121.429436 102.106308 197.041000 914.787292 6536.843750 27934.406250 114630.062500 0.635461 0.154131 0.177649 1.618927 6.601635 18.551910 42.984055 79.009567 82.258614 39.436893 10.585532 1.702995 0.426845 3.160173 11.492950 21.074394 21.861296 55.131641 303.166016 1117.114746 1666.489990 1480.031372 920.839050 988.720947 1809.021973 1139.484131 469.202667 1439.732788 25907.085938 102664.054688 177524.687500 0.322574 -0.014016 -0.165876 0.178390 1.397291 3.721373 6.555781 7.980501 6.567955 3.391232 0.833821 -0.300287 -0.573494 -0.333886 0.535216 2.534359 12.281879 104.326851 1007.559692 5838.385254 11340.238281 18813.177734 8529.459961 31957.884766 100628.562500 35779.792969 3174.886719 1605.571167 14720.703125 71415.859375 51262.503906 -0.049944 -0.199644 -0.291189 -0.229798 0.076924 0.611409 1.072408 1.029291 0.596863 0.010497 -0.401875 -0.606288 -0.672005 -0.460906 0.653216 4.860676 22.267803 201.218781 3104.485352 33105.671875 130039.703125 103785.937500 112404.609375 108018.437500 102084.742188 108172.273437 22849.074219 5850.530762 22718.167969 18973.876953 4892.993164 -0.233993 -0.279366 -0.314337 -0.316044 -0.260921 -0.161285 -0.074562 -0.126288 -0.254124 -0.403336 -0.519661 -0.594875 -0.556780 0.101981 3.840312 18.610065 56.830788 215.823227 2322.721680 32509.531250 116656.656250 102857.804688 116272.250000 123653.468750 106404.203125 156971.375000 67656.468750 16086.120117 96140.210938 56961.191406 4497.999023 -0.262955 -0.279440 -0.296111 -0.306079 -0.308937 -0.301916 -0.293656 -0.319870 -0.372722 -0.435946 -0.492145 -0.531487 -0.411368 1.012987 10.292947 58.444042 222.434814 533.188171 1181.986572 10019.805664 109923.843750 108306.359375 104486.734375 95816.875000 104737.179688 136950.562500 31393.638672 8144.922363 28397.988281 19314.150391 2280.161621 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002449 -0.003021 -0.003660 -0.004354 -0.006581 -0.007561 -0.010645 -0.011844 -0.012869 -0.014733 -0.015261 -0.015477 -0.015254 -0.014727 -0.013902 -0.012860 -0.011635 -0.010347 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001990 -0.002536 -0.003197 -0.003990 -0.004935 -0.007661 -0.011015 -0.013060 -0.015083 -0.018138 -0.021641 -0.023087 -0.026753 -0.027182 -0.026739 -0.024466 -0.023073 -0.019739 -0.017782 -0.015744 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002501 -0.003242 -0.004137 -0.006726 -0.008481 -0.012455 -0.015233 -0.021199 -0.026327 -0.031372 -0.034816 -0.037393 -0.039104 -0.039535 -0.039012 -0.037507 -0.034995 -0.031854 -0.028474 -0.024973 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002349 -0.003108 -0.004078 -0.006827 -0.008867 -0.013258 -0.018678 -0.026055 -0.031695 -0.039122 -0.044828 -0.049676 -0.053634 -0.056475 -0.058925 -0.058289 -0.057557 -0.053926 -0.049127 -0.043897 -0.040115 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002132 -0.002856 -0.003821 -0.006540 -0.008691 -0.011598 -0.020968 -0.028235 -0.037170 -0.045331 -0.052658 -0.058399 -0.065088 -0.071965 -0.076831 -0.082254 -0.084631 -0.082831 -0.079706 -0.074322 -0.068136 -0.059994 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.002501 -0.003408 -0.004617 -0.008078 -0.012609 -0.020745 -0.028686 -0.039188 -0.048876 -0.057417 -0.064936 -0.074334 -0.083094 -0.091935 -0.100605 -0.108455 -0.115475 -0.116224 -0.115060 -0.108023 -0.098359 -0.085631 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.002896 -0.003990 -0.007099 -0.011408 -0.019207 -0.027405 -0.038622 -0.050818 -0.059356 -0.069744 -0.077731 -0.068904 -0.051015 -0.039918 -0.063131 -0.103826 -0.137982 -0.151356 -0.151396 -0.145019 -0.134182 -0.120837 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002365 -0.003265 -0.004583 -0.008293 -0.015333 -0.023542 -0.036554 -0.049087 -0.060383 -0.072828 -0.074244 -0.019993 0.138873 0.408209 0.614552 0.496608 0.190355 -0.045074 -0.155831 -0.185919 -0.187876 -0.181333 -0.164831 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001870 -0.002607 -0.003634 -0.006689 -0.012856 -0.018121 -0.030362 -0.044323 -0.060147 -0.073109 -0.079751 -0.010130 0.366490 1.608782 3.913132 5.945551 5.061029 2.400641 0.654587 0.030883 -0.132956 -0.178502 -0.204050 -0.214230 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002796 -0.003933 -0.008981 -0.014640 -0.023994 -0.037207 -0.055871 -0.069930 -0.085816 -0.062206 0.255908 1.980941 9.107558 28.868584 48.503506 38.473827 15.747386 4.097935 0.929936 0.284713 0.061268 -0.116615 -0.218711 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002088 -0.002937 -0.005556 -0.011447 -0.017515 -0.027141 -0.046618 -0.065889 -0.083431 -0.098637 -0.006013 0.816256 6.611795 38.424885 164.815109 339.826019 260.333740 78.871529 15.187879 3.716837 2.034488 1.180399 0.362259 -0.116028 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.003021 -0.005782 -0.013454 -0.022125 -0.040505 -0.056787 -0.078353 -0.103279 -0.116326 0.037391 1.479071 13.250754 99.732613 550.458740 1420.913940 910.705566 216.846039 35.099400 10.026977 7.239829 4.566759 1.796111 0.242423 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002162 -0.004938 -0.011298 -0.018402 -0.031010 -0.048896 -0.073484 -0.099377 -0.127107 -0.146856 0.014091 1.615238 13.978831 113.030144 634.763184 1657.628418 1141.962524 255.832306 49.209175 22.722397 21.001945 13.888687 5.337979 1.200304 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.004309 -0.007164 -0.018779 -0.030757 -0.041212 -0.064449 -0.088122 -0.118395 -0.153022 -0.187067 -0.083949 0.922026 8.184846 52.187866 247.475357 565.738831 427.689301 162.071198 77.221909 77.548508 83.211121 50.107082 16.633350 4.094962 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001990 -0.002449 -0.008461 -0.014150 -0.026922 -0.038597 -0.056144 -0.076340 -0.101157 -0.138847 -0.181656 -0.230630 -0.208379 0.211629 3.100516 17.011547 65.808655 191.851700 478.567139 696.162109 520.354004 620.686279 692.349731 291.860718 68.384789 16.645962 -0.001231 0.000000 0.000000 0.000000 -0.002074 -0.002607 -0.008894 -0.014225 -0.021846 -0.039463 -0.053744 -0.072536 -0.095179 -0.125482 -0.164285 -0.219768 -0.273653 -0.303552 -0.128648 1.443496 12.224423 110.219742 1231.601074 12510.708984 31720.835938 10792.243164 9417.879883 11298.368164 2767.564941 355.307312 90.338402 -0.002516 -0.001168 -0.001218 -0.003304 -0.003907 -0.010410 -0.015279 -0.023227 -0.035875 -0.052769 -0.068504 -0.087110 -0.115281 -0.151349 -0.200841 -0.264690 -0.325506 -0.370660 -0.215635 1.791357 22.672234 369.727295 12366.408203 100883.882813 101717.421875 105741.968750 77100.328125 100576.523438 14725.545898 2523.632568 745.283630 -0.003047 -0.002715 -0.003559 -0.004202 -0.012565 -0.017888 -0.024657 -0.037044 -0.050676 -0.067989 -0.086171 -0.111105 -0.141697 -0.185854 -0.242708 -0.315255 -0.383202 -0.430342 -0.236898 2.341030 32.682049 642.896912 34625.378906 101073.296875 101696.718750 105284.492188 76280.382813 89638.750000 56755.078125 64002.257813 7382.315918 -0.006528 -0.007176 -0.006773 -0.013181 -0.020329 -0.024276 -0.034512 -0.046369 -0.065832 -0.086012 -0.110356 -0.141920 -0.173514 -0.225295 -0.285831 -0.362205 -0.432693 -0.484899 -0.224195 2.966788 38.661560 591.383423 13944.616211 122234.523437 113826.968750 102339.710938 12036.098633 19566.271484 101822.945313 100396.421875 31340.660156 -0.009525 -0.010538 -0.010369 -0.020914 -0.026627 -0.034993 -0.047605 -0.061119 -0.084416 -0.110749 -0.140891 -0.172414 -0.209699 -0.268158 -0.329836 -0.408504 -0.476984 -0.488275 -0.086616 4.287346 66.390594 1563.450806 99859.296875 107912.546875 119394.320312 21523.640625 1523.375732 5722.999023 99138.281250 100141.921875 11765.058594 -0.013655 -0.014228 -0.021532 -0.029065 -0.034482 -0.050085 -0.065845 -0.081705 -0.107795 -0.138629 -0.168895 -0.203568 -0.242946 -0.278056 -0.328157 -0.399117 -0.404036 -0.195550 0.843233 6.578117 83.329063 2469.111328 100215.445313 100547.750000 100613.195313 30214.941406 643.993042 606.717163 3162.419678 3764.127441 1082.165771 -0.023689 -0.027156 -0.036579 -0.044535 -0.053214 -0.074381 -0.087589 -0.108846 -0.136302 -0.167973 -0.199633 -0.199894 -0.143422 0.009138 0.168800 0.196411 0.355022 1.857575 7.475505 20.000607 67.216934 863.450806 24646.914063 100580.773438 100418.835938 5414.446289 244.322220 102.344032 203.950592 204.458435 135.812531 -0.034162 -0.040318 -0.052770 -0.062110 -0.078066 -0.096551 -0.113959 -0.144758 -0.169728 -0.196124 -0.176433 0.033119 0.937251 3.169393 6.113917 7.033957 5.865886 13.235269 58.582523 168.819000 226.487457 277.758911 1126.858276 3562.928955 2360.249512 498.182098 112.310745 121.475464 157.999634 105.859261 45.261143 -0.050164 -0.056989 -0.069363 -0.082054 -0.099752 -0.121252 -0.147664 -0.176603 -0.201119 -0.203973 0.010359 1.469794 9.539304 40.829109 100.188980 107.414223 57.599247 59.941677 367.689575 1660.119629 2285.854492 926.249878 564.144958 772.258179 964.943481 740.025757 717.230164 993.173401 596.122925 187.466415 48.365421 -0.067856 -0.078793 -0.091615 -0.105758 -0.130455 -0.152865 -0.180209 -0.213816 -0.237456 -0.164397 0.688781 8.151634 73.934662 592.364136 2649.349121 3113.465820 862.072937 226.521133 1156.437134 8538.118164 12207.297852 3309.436768 1202.808838 5521.904297 33529.910156 21102.859375 13959.935547 34629.289063 10629.740234 1247.755371 199.041016 -0.087361 -0.103968 -0.116137 -0.134704 -0.157227 -0.182617 -0.215113 -0.245924 -0.263098 -0.080633 2.084145 27.588245 419.356903 9318.037109 100041.851563 100077.023438 19353.294922 931.083191 1249.659058 7894.313965 12238.904297 3044.362793 1826.446167 51212.531250 100390.578125 106089.148438 111353.046875 102818.859375 112313.375000 13365.876953 1725.318359 -0.116389 -0.130191 -0.144523 -0.156987 -0.181337 -0.208529 -0.240136 -0.282475 -0.291715 -0.000547 3.483637 52.571411 1230.782837 69833.390625 100300.148438 100684.414063 100502.109375 2911.415771 751.861877 1878.875366 2173.799316 815.173035 1279.578735 50906.054688 100297.656250 106649.546875 112334.289062 142229.812500 200118.359375 104379.351563 17749.427734 -0.140709 -0.159454 -0.170347 -0.154306 -0.111795 -0.065765 -0.090473 -0.182005 -0.269849 -0.040151 3.209739 47.942566 998.873657 46467.664063 101308.992188 103587.859375 102438.031250 2734.030518 976.967834 1383.387939 709.906982 242.216599 358.335022 4090.899902 27098.371094 17848.189453 19808.640625 146701.640625 114039.945312 101475.984375 46493.796875 -0.175580 -0.178859 -0.107865 0.189182 0.869652 1.736964 1.915421 1.162290 0.262340 -0.009392 1.764771 22.093012 284.950256 4195.551758 43622.320313 56620.062500 10766.105469 1227.478760 743.150818 943.862610 459.731934 219.121704 162.774216 254.437576 615.910645 686.142517 2420.371338 34691.156250 142461.406250 121336.085937 14337.295898 -0.206244 -0.130937 0.435846 2.897412 10.584925 24.244961 27.140999 15.498787 4.954972 1.091053 1.005701 7.090372 53.915718 358.389221 1590.229248 2618.694092 1478.581299 372.739563 212.674637 248.951385 191.577591 210.722244 164.455750 61.997917 47.416500 190.222321 4181.242676 101487.000000 106108.062500 104955.945313 27539.261719 -0.204660 0.173813 3.044416 21.675253 127.790321 416.707306 513.142883 200.304840 43.862743 7.911846 4.187865 6.042110 13.242348 47.945248 149.280975 259.891541 193.253464 73.935966 41.687286 44.316345 57.708626 91.338249 70.577499 26.678919 17.692129 207.010757 7833.461426 100105.882813 100358.562500 102117.250000 84563.859375 -0.157677 0.941760 11.782856 127.795822 1532.227295 11119.290039 16004.813477 3370.556641 324.420349 44.347713 46.741810 65.938133 44.818668 21.300694 20.554594 26.066126 21.248583 10.785977 6.413766 7.377004 12.299263 18.727243 15.505899 6.552338 8.464893 106.588036 2647.905273 100027.585938 100291.554688 105128.296875 85047.664063 -0.092362 2.042426 27.165737 478.544495 13321.630859 100005.101563 100015.671875 46308.351563 1468.918945 251.018417 921.584412 1657.153687 845.390930 165.421158 23.356678 4.835398 2.116275 1.015268 0.659359 1.004210 1.873206 2.540126 1.981691 0.695180 2.384040 28.292919 318.545990 3120.158447 11321.551758 10063.435547 27773.607422 -0.026054 2.366179 32.390163 634.271912 21187.357422 100020.468750 100083.546875 86314.171875 2392.795166 2170.318604 31198.273438 100024.953125 31117.625000 1786.684814 105.845085 7.955321 0.616797 0.243239 0.650462 0.820088 0.620627 0.229844 -0.209374 -0.573150 -0.117638 4.580694 30.661093 134.321030 319.492432 669.862671 2652.234863 0.084112 1.809981 18.852751 261.280884 4688.850098 62934.507813 100271.609375 14157.199219 2812.191406 15203.745117 101446.898438 100246.562500 100030.539063 11121.440430 296.781891 16.211214 1.538515 1.814449 3.584592 3.797708 2.215803 0.738186 -0.183405 -0.670499 -0.750603 0.050840 3.264642 11.587831 28.092863 70.826714 218.390717 0.224033 1.201752 7.109684 56.806072 427.906738 2000.261719 2857.019531 3678.694824 42897.054688 114773.312500 146304.765625 102445.492188 100136.203125 13330.351563 317.979431 17.431398 2.677733 5.181072 9.730032 10.292875 6.693862 3.380484 1.280273 -0.015920 -0.555587 -0.086752 2.803921 11.775562 26.820932 33.355350 34.786991 0.245918 0.775250 2.326076 10.239449 44.730518 142.464890 512.944458 8904.339844 100395.195313 102725.085938 156739.250000 111120.507812 51530.421875 2459.244385 128.903519 9.825042 2.896211 7.682026 15.490219 17.548923 14.278506 11.740569 6.973190 2.580774 0.381034 1.635869 12.611105 60.913765 164.682098 188.130341 85.202003 0.064741 0.241369 0.722776 2.929235 10.537732 37.224010 261.514313 6641.446289 100083.710938 100249.164063 101321.656250 10672.491211 1576.627319 243.470230 28.464457 3.351654 2.184712 6.424788 13.123840 19.448029 27.926622 33.998024 22.956888 8.583413 2.117303 4.340269 33.673576 212.894760 730.828430 908.812805 318.251770 0.229389 -0.109654 -0.040091 0.871235 3.921464 14.222138 84.934334 1065.656616 13334.073242 46302.199219 14657.864258 1316.350952 152.090698 30.421082 7.852985 2.378980 1.619226 3.511178 8.158939 18.307211 43.372215 62.056187 42.841045 15.127321 3.618895 5.712539 45.340134 317.287445 1221.555054 1532.689209 479.454254 1.545397 -0.002296 -0.358126 -0.096219 0.994881 3.922734 17.497908 108.423279 480.412964 911.406250 519.850464 129.422165 54.041821 58.777328 44.355923 17.901241 5.836765 3.198955 4.736020 13.980628 36.809578 54.407482 37.939205 13.464407 3.267926 4.191900 28.656103 175.847305 590.971985 681.357910 244.456238 4.858465 0.769260 -0.326084 -0.450742 -0.141356 0.565610 2.604416 10.256345 28.963884 44.725456 42.253311 110.646072 553.147644 1318.490967 850.152039 213.068039 43.899204 15.312506 6.539284 7.118602 15.596931 22.604229 16.878525 6.377838 1.414382 1.544049 10.017045 43.554108 106.981644 121.165443 59.070709 10.795808 2.683641 0.229509 0.020754 0.815494 1.678889 1.525405 1.337225 2.390219 7.724795 63.368111 909.383667 14596.255859 77492.468750 31155.697266 2587.141357 354.761749 125.226654 32.357075 7.594132 4.892903 5.567441 3.992671 1.445322 -0.015075 -0.008695 1.948560 7.591671 15.458485 16.422070 10.068882 27.990299 8.103937 2.313026 4.714816 16.791355 29.282804 22.694654 7.950163 2.069332 9.567609 154.310791 4306.556152 100003.593750 100035.921875 100278.000000 19092.283203 3126.770264 1162.901367 181.077713 23.006104 4.070444 1.480773 0.510505 -0.238917 -0.621008 -0.606026 -0.148828 0.852182 1.864907 2.070319 1.703811 72.728455 19.148014 8.771223 37.775143 221.453674 580.227173 367.177124 83.110130 10.924742 10.791466 164.444122 5089.874512 100007.554688 100083.781250 101058.281250 30511.705078 21754.783203 6125.332031 593.225891 66.131905 16.486712 6.383022 1.665316 -0.182706 -0.678481 -0.693599 -0.469048 -0.179908 -0.043554 -0.035432 0.059065 132.056061 29.625845 24.358675 217.167023 2790.371826 12353.654297 6282.544434 580.773071 41.357101 8.758307 74.086792 1223.353271 23304.613281 100101.007813 52476.906250 14764.055664 27044.740234 8714.388672 1230.919312 252.467545 143.542511 59.207138 14.370323 2.067501 -0.212911 -0.207810 0.418319 0.916853 0.719231 0.194370 -0.095925 167.484497 31.684731 53.599060 550.838562 10319.883789 85540.617188 31277.847656 1667.137817 82.591209 10.430246 24.782299 156.886703 885.040588 2347.830811 2041.411133 6200.067383 46209.753906 71486.054688 10786.090820 2313.339111 1975.643066 593.928528 87.974281 10.174873 1.133666 1.427104 4.167856 6.536271 5.755982 3.415941 1.958817 131.324356 31.223454 115.361969 792.986694 5763.003906 23798.060547 11457.625977 930.374023 94.843903 38.483490 70.701530 325.797882 847.356812 689.314758 909.500061 21540.373047 100410.570313 100366.648438 98132.968750 19822.488281 23388.183594 3970.758545 317.467194 26.998489 3.424488 5.490222 14.595879 24.503407 24.659246 22.561815 21.005684 47.217724 31.761415 194.821136 1504.138306 5190.912598 4753.583008 1682.520020 886.612183 845.918884 419.943695 610.411438 6451.566895 41039.503906 18191.246094 2517.689453 18301.226563 100351.296875 100337.187500 81464.929688 43785.636719 56811.511719 7812.984863 478.518036 34.665581 6.717264 14.149443 41.465122 91.067894 148.418243 206.179718 265.087982 12.596522 24.147589 164.634659 1175.151245 4407.248535 6427.507324 6310.270508 34816.000000 51457.851563 9004.614258 4468.295410 80260.867188 100289.734375 100365.343750 10068.755859 5129.003906 24247.019531 38169.445313 8120.681641 9786.388672 12201.958008 2445.048584 243.637604 24.915028 17.822763 56.972839 211.687012 985.364014 2624.797119 2653.798828 3099.700439 3.381346 12.393200 76.883560 622.449036 7577.834473 58074.320313 86796.921875 102337.328125 100938.906250 109384.632812 35847.136719 75463.226563 101185.093750 100402.437500 8449.588867 2807.766113 1760.196411 1159.943359 615.659851 802.276978 854.427734 318.724426 56.244904 20.140156 85.879272 389.787079 1710.091797 23651.726563 100592.156250 66429.171875 14181.184570 0.706279 4.901602 37.144413 505.180145 9296.026367 80634.960938 141139.093750 103106.046875 101804.000000 117769.593750 84416.507813 30233.945313 23838.875000 11375.187500 1893.520874 2021.307495 1843.003052 688.766846 159.051666 77.805000 66.408607 33.915283 14.632384 38.281075 341.548279 2413.916992 8900.925781 102289.500000 103990.062500 104646.117188 28311.203125 -0.173078 1.524554 15.734855 169.934296 1790.413696 8416.385742 32067.785156 107292.882812 109094.859375 106626.242187 17112.492188 6356.241211 1277.617065 915.341187 8976.988281 51279.449219 21408.912109 2558.817383 262.899261 39.189564 32.200333 50.693104 44.056602 63.378059 599.450745 5469.714844 14127.534180 107773.156250 134635.328125 125871.851562 21064.460938 -0.425389 0.163608 4.419963 32.823307 190.655121 805.995178 7153.768066 79178.195313 109262.406250 14436.322266 1830.201904 637.117126 229.766479 2859.950928 100433.476563 102268.335938 103375.046875 10421.164062 367.390656 95.000076 439.474854 1405.472046 1012.828247 208.278046 311.941986 1841.537842 4381.466309 17904.626953 95028.867188 56901.734375 5694.088867 -0.456641 -0.251750 1.199048 8.339608 46.043571 354.908447 5657.373047 70037.382813 100297.195313 12335.049805 726.913269 95.606300 114.044006 3984.265625 100130.031250 100480.742188 100685.781250 13944.006836 346.861176 516.355164 10254.203125 100061.796875 48344.109375 2339.682129 165.012604 307.960663 1175.698853 5676.762207 11645.577148 6718.781250 1519.850342 -0.410048 -0.347053 0.270490 3.452789 19.166191 130.042679 1243.740601 7180.905273 9324.971680 2100.034912 222.243362 28.128790 43.122936 863.788940 25267.798828 100062.968750 60574.988281 2231.345459 465.329926 2623.127930 87322.289063 100637.164063 100101.875000 11192.817383 258.314514 182.447891 2510.534180 27445.599609 39583.214844 12904.243164 9819.157227 -0.341958 -0.361418 -0.133956 1.069254 6.102990 29.836006 134.123123 421.408936 481.121094 188.737900 39.084743 6.608951 8.677240 78.589592 581.922302 1662.828369 883.800598 311.364532 2017.123901 16871.886719 60483.882813 105128.062500 100437.437500 5771.842285 211.558578 161.230103 2008.318359 20312.054688 101941.867188 104964.289063 200246.312500 -0.297638 -0.346766 -0.304545 0.045847 1.338093 5.032598 14.904462 29.978788 32.763012 17.387106 5.036517 0.792072 0.851769 6.642976 24.878891 46.774334 56.704094 280.801697 3825.977783 39942.621094 73698.210938 19116.027344 6044.101562 907.027588 541.302246 396.271637 722.826721 9203.293945 102564.117188 102610.296875 200148.000000 -0.284189 -0.324489 -0.347957 -0.277631 -0.016661 0.613165 1.627122 2.590792 2.607442 1.380920 0.181133 -0.425859 -0.521509 -0.064397 1.365433 5.077549 31.789356 428.295837 9061.723633 110376.656250 117226.242187 15213.908203 2551.546631 4351.364258 10728.891602 6268.118164 2618.054687 7247.993652 110370.007812 107679.195312 112324.265625 -0.280831 -0.307597 -0.328904 -0.333802 -0.298015 -0.202738 -0.080859 -0.031818 -0.109803 -0.286854 -0.482039 -0.608398 -0.664355 -0.616408 -0.131855 2.960898 37.070057 889.674622 56905.277344 101927.406250 115668.851562 130632.703125 20740.451172 43793.617188 112316.093750 146405.125000 104373.703125 69455.632813 108799.085937 141943.546875 37573.031250 -0.264992 -0.279777 -0.297242 -0.305809 -0.313168 -0.310439 -0.310903 -0.327406 -0.375375 -0.438884 -0.516611 -0.574299 -0.608188 -0.500608 0.245995 4.052095 33.284794 604.564270 27154.085938 102538.007813 151358.828125 137094.109375 66341.531250 61345.226563 200175.734375 169926.250000 107434.640625 151012.984375 101036.593750 100833.859375 70410.140625 -0.232560 -0.247207 -0.263940 -0.274550 -0.282754 -0.287671 -0.302652 -0.324660 -0.357530 -0.408150 -0.462533 -0.515179 -0.527243 -0.235525 1.404174 8.496249 35.276821 190.651169 2222.526611 17832.669922 36327.289063 65854.796875 22331.773438 10546.924805 102308.039063 109406.570312 103002.726563 125836.812500 100625.031250 100202.554688 21358.820313 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.002285 -0.002796 -0.003383 -0.004019 -0.004686 -0.006880 -0.009643 -0.010665 -0.012598 -0.013378 -0.013870 -0.014076 -0.013859 -0.013427 -0.012701 -0.011777 -0.010696 -0.009551 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002365 -0.002958 -0.003686 -0.004516 -0.006970 -0.008251 -0.011729 -0.014473 -0.016321 -0.017927 -0.020779 -0.024355 -0.024766 -0.024523 -0.022348 -0.019587 -0.018134 -0.016416 -0.014599 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002333 -0.003000 -0.003821 -0.004826 -0.007660 -0.009433 -0.013667 -0.019105 -0.023703 -0.028372 -0.031340 -0.033769 -0.035198 -0.035676 -0.035194 -0.033840 -0.031776 -0.029179 -0.027545 -0.021574 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002192 -0.002876 -0.003766 -0.004898 -0.008004 -0.010249 -0.016690 -0.023447 -0.029739 -0.035199 -0.040212 -0.044763 -0.048421 -0.050821 -0.052925 -0.052380 -0.051938 -0.048950 -0.044906 -0.040371 -0.037054 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002644 -0.003531 -0.004686 -0.007895 -0.010346 -0.018901 -0.025408 -0.033455 -0.040888 -0.048408 -0.054866 -0.061364 -0.067525 -0.071981 -0.076788 -0.077952 -0.074955 -0.072118 -0.067860 -0.062697 -0.056775 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002333 -0.003152 -0.004260 -0.007301 -0.009885 -0.018709 -0.025842 -0.035202 -0.044442 -0.054529 -0.061341 -0.070863 -0.078988 -0.088274 -0.095856 -0.101839 -0.107102 -0.110300 -0.110235 -0.102826 -0.092910 -0.081456 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001963 -0.002681 -0.003660 -0.006465 -0.008853 -0.015763 -0.024672 -0.034618 -0.046686 -0.057444 -0.065896 -0.078521 -0.085784 -0.091369 -0.098285 -0.113564 -0.133527 -0.147422 -0.151549 -0.149876 -0.144596 -0.131101 -0.118215 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.003021 -0.004198 -0.007537 -0.013931 -0.021135 -0.033108 -0.044721 -0.059063 -0.069186 -0.081422 -0.079268 -0.048665 0.008999 0.040698 0.006059 -0.083464 -0.155648 -0.189182 -0.193815 -0.190547 -0.181386 -0.163137 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002415 -0.003359 -0.006094 -0.011776 -0.016429 -0.027509 -0.041117 -0.056731 -0.068663 -0.084301 -0.080013 0.003956 0.260831 0.718454 0.994582 0.866972 0.351244 -0.015441 -0.180939 -0.225135 -0.231063 -0.228386 -0.215646 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001870 -0.002607 -0.003634 -0.006700 -0.013417 -0.020223 -0.036296 -0.050508 -0.066961 -0.084407 -0.093873 -0.031721 0.338974 1.572020 3.872740 5.905792 5.027003 2.371264 0.618415 -0.007027 -0.175286 -0.223859 -0.257354 -0.269733 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001949 -0.002738 -0.003849 -0.010532 -0.016143 -0.026497 -0.044490 -0.061477 -0.079796 -0.100839 -0.095867 0.088339 1.120069 5.045231 13.974090 23.009163 18.439133 8.228621 2.368822 0.763830 0.428474 0.193168 -0.097431 -0.271892 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002816 -0.003961 -0.012522 -0.021025 -0.038044 -0.052789 -0.074050 -0.097353 -0.121877 -0.106766 0.215995 2.026701 10.073391 30.532362 54.648903 43.500401 17.362957 6.102106 4.724128 5.444699 3.866660 1.430495 0.079566 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.004661 -0.010603 -0.017377 -0.027741 -0.042895 -0.063218 -0.090766 -0.119839 -0.152192 -0.142119 0.198093 2.096123 10.663383 34.523808 62.495995 51.124477 23.829597 18.433224 39.816776 59.803978 38.002453 12.232425 2.239007 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.004108 -0.005258 -0.014567 -0.027055 -0.035526 -0.058938 -0.080697 -0.109709 -0.143843 -0.185292 -0.194212 0.016177 1.340338 6.595308 20.574791 38.687485 45.479679 49.525238 99.036072 364.168213 681.588989 366.124207 74.468353 11.910290 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001936 -0.002382 -0.006436 -0.013462 -0.026899 -0.038343 -0.056483 -0.075454 -0.098409 -0.132947 -0.174243 -0.225469 -0.260178 -0.168018 0.585282 4.158092 19.435858 86.622116 319.750244 566.107605 874.034485 3508.566650 6185.875977 2374.612549 322.381134 47.916992 -0.001023 -0.001089 -0.001136 -0.001160 -0.003177 -0.005301 -0.008120 -0.016243 -0.021841 -0.038911 -0.052701 -0.069064 -0.090376 -0.119092 -0.157404 -0.214545 -0.271154 -0.319263 -0.259331 0.587646 7.934378 77.570053 991.459290 9353.656250 23701.119141 15130.177734 101983.718750 103715.421875 25081.962891 1359.476807 298.871826 -0.002593 -0.001444 -0.001518 -0.003555 -0.005787 -0.008893 -0.017405 -0.022301 -0.035505 -0.050943 -0.065283 -0.084585 -0.108845 -0.145679 -0.189766 -0.255446 -0.320988 -0.370529 -0.276943 1.232733 18.766855 304.287598 9334.145508 100103.937500 101208.828125 169868.656250 105934.937500 101666.492188 105690.468750 10333.509766 3936.540039 -0.003196 -0.001914 -0.003924 -0.007985 -0.013012 -0.020272 -0.025558 -0.034651 -0.049965 -0.066935 -0.084122 -0.106731 -0.135934 -0.176345 -0.233072 -0.301554 -0.369034 -0.418267 -0.258168 2.048487 28.308296 515.962646 25825.537109 100547.156250 101377.789063 156872.140625 113781.656250 115189.054687 200127.468750 104604.671875 66756.718750 -0.007266 -0.007374 -0.008951 -0.015671 -0.021463 -0.026968 -0.036454 -0.050788 -0.066748 -0.087731 -0.109950 -0.138710 -0.171411 -0.216317 -0.278280 -0.349124 -0.418769 -0.462581 -0.178353 3.156791 39.715820 595.461060 12686.329102 133291.765625 118369.085937 106752.585937 75474.859375 199157.468750 113426.179687 102529.140625 151366.984375 -0.010391 -0.011606 -0.017017 -0.019846 -0.029539 -0.040416 -0.051983 -0.066298 -0.087602 -0.114272 -0.139399 -0.171413 -0.209153 -0.260498 -0.318828 -0.393933 -0.445848 -0.413513 0.184192 5.780824 81.302910 2023.475098 101099.406250 106887.039062 115199.210937 27176.988281 2696.969971 31519.740234 100606.937500 100783.375000 97853.328125 -0.014669 -0.018422 -0.025650 -0.033965 -0.043608 -0.057962 -0.071821 -0.087147 -0.111358 -0.139345 -0.170349 -0.204180 -0.240970 -0.280751 -0.332726 -0.377713 -0.294856 0.229130 2.295309 11.540167 120.310905 3477.097900 102931.343750 110393.992187 105871.218750 46550.070313 863.105225 1701.637573 14851.275391 20037.550781 3681.472900 -0.029422 -0.035435 -0.039038 -0.053358 -0.065709 -0.080939 -0.096330 -0.117089 -0.145283 -0.172176 -0.202437 -0.216683 -0.192085 -0.128361 -0.035683 0.058273 0.753016 4.870101 21.166750 59.859581 158.741852 1685.672974 44750.753906 134402.671875 116059.492187 9294.621094 394.114197 122.311264 298.796753 351.029480 227.155167 -0.038605 -0.048475 -0.058331 -0.075794 -0.089620 -0.106244 -0.125176 -0.151107 -0.178070 -0.203471 -0.205559 -0.088448 0.405565 1.560143 2.974829 3.686595 6.613075 37.176567 244.654755 987.551392 1400.630371 1246.613892 5599.888672 18317.302734 9571.288086 1455.779175 209.992554 131.234375 115.974731 72.087425 41.908367 -0.058807 -0.070325 -0.083605 -0.099132 -0.114603 -0.135533 -0.156800 -0.185814 -0.214338 -0.225013 -0.111139 0.669807 4.399124 16.180143 35.753506 39.793144 36.786026 196.264526 3110.833984 34337.488281 56886.761719 10950.954102 10563.716797 12986.519531 4753.655762 1823.935059 1644.895386 2877.007324 1685.140503 565.640381 113.941635 -0.081522 -0.090645 -0.111654 -0.128605 -0.147980 -0.170824 -0.196064 -0.227591 -0.251908 -0.224599 0.266739 3.810147 27.046066 150.652924 462.911865 542.643311 254.202637 614.045471 19329.806641 100072.789063 100279.468750 99538.640625 34051.644531 58381.667969 105780.070313 102754.281250 74342.234375 101237.468750 54926.312500 4659.544434 467.370056 -0.106501 -0.121582 -0.140256 -0.157136 -0.180190 -0.206971 -0.234362 -0.266447 -0.287466 -0.187987 1.040730 12.274340 120.498734 1180.567871 6770.737305 8262.019531 2157.726807 932.679810 18146.451172 100804.445313 100523.140625 97760.585938 17304.230469 114721.421875 103172.257813 125899.062500 150982.265625 102280.039063 106285.562500 18532.857422 978.788818 -0.138905 -0.154306 -0.173717 -0.196537 -0.213545 -0.234060 -0.263857 -0.302861 -0.326353 -0.156008 1.832042 22.748478 293.174774 4307.653320 45161.042969 68473.601563 14216.726563 2607.303711 10582.414062 40246.644531 50293.574219 8587.816406 4351.723633 101386.250000 100936.976563 128322.578125 145871.140625 103044.750000 111299.828125 24556.570313 1806.308594 -0.173764 -0.192293 -0.202399 -0.181006 -0.118777 -0.046017 -0.052474 -0.164075 -0.283826 -0.155910 1.977206 23.903345 312.597504 4743.768066 64155.484375 137896.625000 105717.289063 9679.758789 42397.433594 96699.906250 18705.925781 1462.014038 762.429321 13549.507813 100235.945313 83252.257813 104408.125000 104297.453125 101113.210938 20673.316406 2476.253174 -0.215881 -0.218579 -0.111661 0.287189 1.281207 2.535563 2.802095 1.640101 0.429533 -0.029181 1.330022 16.168602 186.252731 2862.156494 68361.546875 103663.398438 101123.320313 12049.805664 23717.845703 51282.679688 11177.184570 776.551453 132.863907 421.170624 1301.534546 1349.094238 2505.045166 6869.583496 13202.217773 9161.076172 1573.772217 -0.247530 -0.137549 0.624362 4.180612 16.368748 38.283329 45.616207 24.266474 7.234668 1.438622 0.896951 7.527182 71.639755 859.162842 11941.078125 59366.824219 29746.125000 3288.489502 2626.141846 3984.442383 1429.330078 211.145615 36.087872 27.626183 53.543159 123.634773 1110.738281 17912.658203 100708.828125 57333.093750 4240.205078 -0.237170 0.277535 4.406368 36.126549 243.202332 908.738220 1134.280884 417.908417 74.817230 10.972159 3.199195 4.605093 20.247660 138.711517 801.574585 2081.377441 1430.398437 357.629456 207.409912 233.687271 123.248299 35.160549 9.731827 4.454177 9.561899 83.964088 1546.333618 41888.910156 100080.859375 100199.585938 7728.744629 -0.151402 1.420385 18.317652 259.880859 4307.154785 56726.300781 95838.773438 12180.282227 695.460388 59.415268 24.473732 27.155176 21.871510 23.817436 55.770893 97.676788 77.673790 34.188393 19.997829 17.631575 11.246179 4.811235 1.720554 0.596193 4.004664 48.716507 682.195801 10176.306641 51259.835938 28510.958984 3798.335693 0.072379 3.200228 45.908306 1053.208252 69774.648438 100022.046875 100089.242188 100179.937500 4126.603516 246.040894 253.010193 368.704712 214.742264 59.678333 13.927338 8.077142 6.052612 3.723882 2.532780 2.001388 1.088213 0.142069 -0.431269 -0.577078 0.942567 14.202229 120.187584 789.751770 2118.797852 1630.356812 1430.053833 0.817517 4.675760 56.027782 1535.150635 100016.273438 100130.476563 100916.234375 102678.281250 8099.842285 1153.123901 3270.960449 7197.376465 2870.920410 389.949890 40.833195 4.499485 1.630114 3.442129 6.146790 6.049068 3.053809 0.468885 -0.623652 -0.892527 -0.464445 2.284798 15.446422 56.719814 119.813316 152.592575 428.470032 3.217609 7.443316 35.829643 558.091125 17599.013672 100459.429688 105583.718750 98377.187500 22090.199219 9574.502930 26308.740234 86559.562500 21225.259766 1536.218872 93.952682 8.427082 5.524294 17.900574 37.777512 37.752560 17.747831 4.339820 0.172046 -0.792612 -0.807818 0.035620 3.071498 10.425998 21.756960 33.285667 79.869797 7.464780 13.637815 21.140671 108.122665 970.262268 6177.332520 16546.263672 57478.777344 128555.421875 104672.273438 128419.085937 105104.226563 25847.787109 1666.978882 100.758392 10.334489 15.067067 60.958855 144.553589 144.574478 60.955795 13.568837 1.894047 -0.420315 -0.539904 1.199831 10.904846 51.619591 137.580048 158.515060 80.211739 8.855689 15.285450 16.365896 31.200914 128.973297 535.433044 2975.017822 31959.464844 106112.554688 101427.796875 104395.515625 41289.941406 4478.511230 501.346161 47.530685 7.933798 21.899599 105.766235 277.439117 277.614288 106.270119 22.165186 3.656825 0.139206 0.192862 6.707821 64.651039 512.832336 2257.724854 2647.402588 791.545532 5.527898 8.483133 9.220882 18.289293 66.835670 212.923065 739.571594 16666.609375 100510.203125 100217.781250 100340.906250 21736.958984 734.632324 94.303352 13.872226 4.493959 17.451944 77.955757 187.392166 187.911942 79.543358 19.529343 4.284656 0.810441 1.275917 16.877796 227.291061 3366.275391 31114.818359 41859.371094 6577.374023 3.964894 2.957239 3.497118 8.937462 33.987320 86.383995 216.557465 2010.793213 37932.265625 100027.273438 41883.609375 2480.319336 155.549545 23.405334 7.029299 3.698693 8.089300 27.525421 58.155167 58.904797 29.886108 11.001460 4.009957 1.176277 1.819622 22.525263 339.188263 6567.525391 86132.218750 100007.023438 13332.622070 11.761006 2.359655 0.903282 2.815688 9.953597 22.895163 43.797512 169.838013 852.226685 1657.934204 914.322021 191.950302 70.998184 82.214424 59.638935 24.928362 10.481170 9.238201 12.028018 11.864179 8.310040 5.100081 2.681014 0.840050 1.227787 14.300817 175.225937 2256.743408 17559.693359 23298.427734 4314.613281 37.573448 5.863393 0.667244 0.371640 1.739000 3.974511 7.121752 15.861357 39.633400 60.090187 58.156620 159.894653 912.365967 2445.759277 1433.721680 332.950287 87.068779 35.758698 12.212687 4.216975 2.343739 1.814030 0.961191 0.103947 0.190796 5.092185 42.644726 296.688904 1134.103882 1318.855225 451.538605 79.423790 14.927075 2.646952 1.044901 2.516292 4.287430 3.970665 2.697796 3.503470 9.659369 85.428223 1533.378296 34320.503906 100022.554688 95984.367188 5360.725586 1361.577026 529.086792 101.462349 14.490292 2.059612 0.385546 -0.106817 -0.462395 -0.481005 0.659118 6.797874 30.169140 73.531982 84.002724 44.831692 257.557098 50.751698 10.903986 11.902489 43.706944 83.252426 63.628510 18.945196 4.127951 12.758466 227.549545 9305.505859 100009.046875 100119.781250 101786.695313 67463.835938 57460.195313 12205.264648 916.101746 68.548500 7.343702 1.366872 -0.059017 -0.583435 -0.717874 -0.465677 0.528939 2.807975 5.781651 7.063910 6.920754 1100.819946 151.161011 36.627125 118.087975 1014.197510 3621.524170 2136.705811 273.226715 26.798700 15.030571 243.055481 10169.299805 100019.390625 100364.812500 111127.070312 156759.687500 100945.007813 100150.226563 4751.236816 203.518707 37.729557 14.861432 3.851389 0.284863 -0.486999 -0.269700 0.401819 1.023698 1.145735 0.986858 1.916570 1965.736084 245.943893 97.016258 984.383667 34856.835938 100069.429688 100026.953125 3963.850830 126.612610 14.109564 100.781898 2090.000732 62906.296875 100399.906250 114664.195312 107712.687500 103147.632813 104007.531250 6896.890625 788.444275 540.582214 202.212509 38.102432 5.150582 0.828236 2.271576 6.352972 9.566565 7.684870 3.367230 1.180767 1381.690308 206.728409 221.110138 3384.666504 101662.054688 101224.625000 100299.140625 16724.644531 261.621735 17.593266 33.048199 232.200104 1491.339722 4541.284180 5552.412598 53463.613281 200088.109375 123483.015625 45428.679688 17500.738281 21258.822266 3970.344482 317.476288 25.708887 4.816279 13.044018 42.830528 69.057541 51.382813 18.510715 4.472431 678.731567 166.481552 694.289124 9980.085937 136629.906250 131144.640625 102895.312500 6492.793457 212.482681 51.324326 126.077202 669.100708 1986.179932 1594.744019 2388.470215 102011.875000 102452.273438 101757.281250 128393.335937 106048.101563 100166.640625 69779.359375 1654.151978 74.197418 12.711020 44.324738 177.786133 343.229279 232.287827 69.938660 15.894283 193.522781 199.391144 1711.829712 46611.078125 102601.906250 111874.195312 16927.259766 1404.497803 546.280518 531.608826 1519.854126 24769.146484 100203.312500 100167.453125 14269.207031 102354.835938 104456.382813 101693.843750 169821.656250 105544.210938 100154.960938 100008.054688 2864.494141 101.334656 20.338499 86.924477 383.367584 765.053772 523.593262 155.600403 50.281425 54.764130 150.704712 1287.993530 26108.226563 106457.945312 151096.203125 35600.839844 11767.089844 14255.945313 12283.840820 35446.449219 112209.718750 101383.656250 105201.250000 129373.023437 107682.367187 128349.953125 101910.945313 37976.113281 101060.843750 100058.320313 34321.839844 1133.866089 61.181232 25.662212 107.537926 399.693817 816.631042 814.558960 473.735229 210.514786 17.231979 60.928703 366.527832 4561.900879 110212.273437 107650.351562 114396.109375 122324.851562 105996.054688 146411.312500 105158.000000 200101.906250 109547.984375 105016.640625 104745.632813 101722.710938 28646.023438 4135.365723 1878.127075 5221.183105 6582.667969 1533.670288 176.482285 24.476982 45.811703 223.079407 788.877319 2770.408447 7115.567871 4393.885742 1023.256287 4.270021 17.230808 117.113632 2409.576172 100430.273438 101057.218750 131251.890625 130265.570312 110746.296875 200145.281250 103179.335938 114959.609375 119404.054687 52350.621094 11952.869141 32056.255859 45567.812500 9014.331055 782.604553 242.408188 209.351456 92.415337 24.770178 16.429829 79.713173 434.251831 2086.243652 17323.431641 104415.304688 68890.703125 6861.667480 0.590023 4.405460 38.731628 596.839478 16373.422852 100382.820313 96249.632813 104532.890625 103692.921875 107588.164062 101252.859375 100561.164063 5927.874512 1734.703003 14637.236328 135353.359375 112601.898437 57598.585938 2018.010498 127.451202 56.242573 81.500168 60.124016 31.936544 85.116943 448.053986 3354.235107 106724.421875 125913.179687 113403.500000 52673.921875 -0.277260 0.698083 8.240779 75.822243 553.329224 1854.765869 2192.174316 4781.035156 6009.498535 4380.394043 6904.113770 3212.508301 590.292053 2678.666504 105582.601563 200045.390625 200056.468750 44852.410156 1756.227905 214.543274 827.360962 3041.211914 2140.225830 324.709198 77.075478 269.490601 2939.239990 102581.804688 104659.070313 102394.117188 63323.292969 -0.447445 -0.247467 1.161279 8.275491 35.230270 112.154221 395.147491 1294.974854 1616.916504 649.960815 305.144714 162.528809 133.960754 3126.649414 100984.312500 107173.546875 113368.304687 13885.525391 770.649231 1168.323486 31716.214844 100202.078125 100041.062500 5724.245605 193.222900 295.941132 5546.479004 92398.609375 200350.812500 106312.632813 7866.730957 -0.433435 -0.420493 -0.159360 1.091448 5.922293 26.284740 121.705818 352.153473 404.412476 181.435135 51.777699 19.731480 41.701820 695.539307 18579.574219 100350.664063 39297.347656 2111.686035 1954.304932 15942.307617 121211.101562 104313.515625 100365.242188 34809.589844 457.740540 615.019653 36999.675781 100948.601563 104979.203125 112043.328125 8090.617676 -0.390525 -0.414911 -0.370736 -0.052281 1.341559 6.672797 24.104916 55.759346 62.723721 31.927496 10.432480 3.352586 8.363790 75.523102 507.313324 1322.000122 837.950806 886.339233 19596.576172 101737.367188 200122.109375 195874.531250 102270.296875 16785.525391 332.790070 532.143005 24498.265625 102700.851563 200120.265625 170906.531250 105533.562500 -0.344997 -0.374964 -0.384620 -0.314430 0.006073 1.088923 3.691384 6.915651 7.610898 4.347682 1.380483 0.077692 0.755458 6.255251 25.228479 53.234913 113.854172 1110.357788 52012.480469 103484.218750 107130.109375 125951.968750 18044.365234 1387.479614 186.669479 267.063416 2549.626709 33855.535156 133587.812500 104648.226563 106055.523438 -0.299924 -0.328397 -0.346977 -0.356334 -0.301203 -0.124829 0.184965 0.531905 0.516697 0.134619 -0.294344 -0.534464 -0.513092 0.047105 1.964643 9.427645 65.697365 927.733154 27042.931641 200101.703125 200271.625000 69787.960938 2611.686035 549.585876 1123.754150 2777.332031 2757.563721 9622.934570 118160.359375 112480.609375 102709.203125 -0.258349 -0.284026 -0.300211 -0.322405 -0.332880 -0.324004 -0.302437 -0.292330 -0.323108 -0.411192 -0.513917 -0.599034 -0.637603 -0.584009 0.000202 4.332764 52.948845 1362.723022 100940.984375 105672.109375 109127.164062 103260.546875 2701.848145 1801.947388 18614.527344 101245.554688 102720.867188 109144.726562 111492.656250 163093.750000 56718.058594 -0.224223 -0.244444 -0.263108 -0.278112 -0.286394 -0.299252 -0.318744 -0.340130 -0.373734 -0.425786 -0.492239 -0.547805 -0.588556 -0.589004 -0.258785 2.538158 36.385895 867.055969 63265.218750 100383.914063 101376.367188 81488.125000 2594.177979 3378.660400 102905.171875 101591.992188 106830.679687 179063.187500 101606.828125 102196.734375 101960.820313 -0.191384 -0.203832 -0.218866 -0.229562 -0.242039 -0.253340 -0.270244 -0.296322 -0.328212 -0.370520 -0.430594 -0.483112 -0.521156 -0.492855 -0.152289 1.846404 15.510526 194.187775 3156.880615 33363.539063 37572.636719 5011.631348 1059.736694 2057.692383 100816.187500 100564.296875 103225.523438 145738.828125 101832.156250 105152.859375 46974.554688 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002074 -0.002536 -0.003042 -0.003608 -0.004198 -0.004755 -0.006800 -0.009407 -0.011250 -0.011895 -0.012343 -0.012497 -0.012398 -0.011995 -0.011379 -0.010595 -0.009673 -0.007321 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002681 -0.003312 -0.004048 -0.004862 -0.007290 -0.010274 -0.012802 -0.014330 -0.015726 -0.016769 -0.018867 -0.019248 -0.019076 -0.018470 -0.017554 -0.016298 -0.014879 -0.013279 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002719 -0.003432 -0.004322 -0.006786 -0.008314 -0.011858 -0.015234 -0.020911 -0.025064 -0.027664 -0.029637 -0.031002 -0.031500 -0.031131 -0.030156 -0.028370 -0.026167 -0.025017 -0.019629 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002607 -0.003383 -0.004354 -0.007085 -0.008895 -0.013048 -0.020602 -0.026123 -0.030699 -0.035092 -0.039098 -0.042326 -0.044302 -0.046409 -0.045915 -0.045869 -0.043470 -0.040274 -0.036504 -0.032428 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002398 -0.003174 -0.004168 -0.006939 -0.009034 -0.016601 -0.022270 -0.029338 -0.035744 -0.042333 -0.048686 -0.055363 -0.061312 -0.064853 -0.068594 -0.068937 -0.067459 -0.063910 -0.060591 -0.057839 -0.051998 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002836 -0.003794 -0.005084 -0.008639 -0.014754 -0.022642 -0.030874 -0.038878 -0.048893 -0.057995 -0.066069 -0.073022 -0.081477 -0.088073 -0.094783 -0.099777 -0.101666 -0.100547 -0.094013 -0.084657 -0.074711 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002432 -0.003312 -0.004483 -0.007754 -0.013874 -0.021686 -0.030386 -0.040988 -0.052469 -0.063128 -0.073150 -0.083247 -0.095428 -0.106299 -0.119925 -0.129464 -0.140430 -0.143633 -0.142820 -0.135043 -0.121869 -0.108463 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002738 -0.003766 -0.006630 -0.012385 -0.017854 -0.029196 -0.040413 -0.053949 -0.064981 -0.077070 -0.089228 -0.098327 -0.104967 -0.112603 -0.134171 -0.163702 -0.182528 -0.189913 -0.188481 -0.183484 -0.174031 -0.158124 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.003021 -0.004198 -0.009030 -0.014520 -0.024341 -0.037816 -0.050900 -0.064709 -0.078227 -0.093337 -0.096804 -0.072554 -0.021358 0.005620 -0.036497 -0.122791 -0.192195 -0.224528 -0.231904 -0.228922 -0.220928 -0.205982 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002365 -0.003265 -0.005938 -0.011979 -0.017965 -0.032701 -0.044996 -0.060544 -0.079141 -0.096318 -0.107569 -0.065048 0.082697 0.339415 0.534135 0.419176 0.118920 -0.101865 -0.188946 -0.210315 -0.224206 -0.254203 -0.260115 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002483 -0.003456 -0.009548 -0.014521 -0.024033 -0.039299 -0.055250 -0.074922 -0.094677 -0.115530 -0.110217 0.018453 0.447634 1.270823 1.877843 1.581831 0.784814 0.392258 0.569363 0.779642 0.543151 0.049046 -0.224626 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002553 -0.003557 -0.011405 -0.018458 -0.033328 -0.047875 -0.067253 -0.090524 -0.113664 -0.142379 -0.120455 0.114187 0.875377 2.334399 3.446913 3.092979 2.302306 4.101723 10.518660 15.550690 10.787415 3.890492 0.564125 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002553 -0.008625 -0.017749 -0.027460 -0.039591 -0.058154 -0.080500 -0.110198 -0.142431 -0.178278 -0.155033 0.087193 0.917343 2.572011 4.299106 4.902327 8.213291 38.195232 171.762222 347.114319 194.483139 44.844173 6.258098 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.005611 -0.006784 -0.014383 -0.026768 -0.035483 -0.052792 -0.075028 -0.104264 -0.138215 -0.174543 -0.215698 -0.223494 -0.045657 0.702254 2.542373 6.457929 13.893599 41.467739 338.059387 3713.924072 13745.155273 4804.461914 442.210266 34.555092 0.000000 0.000000 -0.001015 -0.001037 -0.001037 -0.004633 -0.004251 -0.004909 -0.015335 -0.024424 -0.037687 -0.050308 -0.070061 -0.092464 -0.124173 -0.164902 -0.213465 -0.269221 -0.286657 -0.089917 1.081536 7.053165 32.978146 106.156303 268.530029 2073.269043 56929.238281 103660.195313 86445.312500 2284.637695 121.599800 -0.001227 -0.001317 -0.001374 -0.002989 -0.005174 -0.005916 -0.012201 -0.015610 -0.021897 -0.036276 -0.050037 -0.066672 -0.084925 -0.114468 -0.148500 -0.199123 -0.259181 -0.313523 -0.318101 0.090602 3.511848 31.316111 247.385635 1452.244507 3149.961426 13775.676758 167974.453125 200058.937500 131220.671875 3734.988525 610.095093 -0.001643 -0.001779 -0.001858 -0.005671 -0.008167 -0.013389 -0.015603 -0.023245 -0.033588 -0.052348 -0.068138 -0.083753 -0.105227 -0.136322 -0.178020 -0.240993 -0.308208 -0.361840 -0.330270 0.504819 8.617952 102.738861 1431.854248 17625.386719 47734.609375 113672.843750 105782.601563 119089.445312 109456.968750 10085.208008 13192.355469 -0.004829 -0.003897 -0.007684 -0.012210 -0.017736 -0.021827 -0.028420 -0.036552 -0.049920 -0.066055 -0.083468 -0.104789 -0.133113 -0.170691 -0.219248 -0.285809 -0.351999 -0.406594 -0.305472 1.073992 14.103571 165.419678 2731.648437 51441.476563 101376.757813 120554.195312 102281.546875 108886.617187 200418.187500 109458.960937 120083.289062 -0.008047 -0.008952 -0.014759 -0.020473 -0.025029 -0.030368 -0.042110 -0.048102 -0.066950 -0.089608 -0.108315 -0.136744 -0.166392 -0.211067 -0.269190 -0.332168 -0.400739 -0.437339 -0.194196 2.353954 24.674927 243.492218 2510.571045 18027.406250 41286.628906 17883.976563 101539.945313 141081.937500 119502.640625 109391.460937 200166.406250 -0.012568 -0.017851 -0.020850 -0.027346 -0.033027 -0.044789 -0.055669 -0.069428 -0.089118 -0.115667 -0.141209 -0.171525 -0.208817 -0.253692 -0.310819 -0.377722 -0.415015 -0.348740 0.335025 5.858841 61.999599 865.088440 14855.625000 108927.648437 69530.632813 5405.105469 2283.597168 16775.744141 100743.554688 102383.523438 123190.914062 -0.020882 -0.028019 -0.037549 -0.042363 -0.053762 -0.066678 -0.076737 -0.094356 -0.116423 -0.145664 -0.176782 -0.208404 -0.247341 -0.287333 -0.340145 -0.367881 -0.229929 0.530754 3.313801 15.811428 145.920166 2892.153564 87312.687500 200177.578125 200230.187500 13087.862305 651.424072 1180.170654 7679.555664 10364.403320 4274.757324 -0.037078 -0.042949 -0.050484 -0.061701 -0.071421 -0.092502 -0.108912 -0.127504 -0.153750 -0.178686 -0.209052 -0.234157 -0.252954 -0.245426 -0.229097 -0.080534 0.988014 7.185377 33.451748 97.454063 301.926239 5523.533691 105082.890625 130221.773437 116494.750000 22720.607422 642.412415 116.535522 224.294601 272.886322 240.487274 -0.052808 -0.062185 -0.074282 -0.086088 -0.103047 -0.116760 -0.137854 -0.161823 -0.190950 -0.219590 -0.236210 -0.211216 -0.036020 0.384636 0.923594 1.729920 7.078490 58.527931 480.950470 2463.163330 3606.173340 4970.353516 93175.429688 108770.539062 102513.742188 8924.117187 435.932434 200.045029 291.311890 208.390930 73.239876 -0.072664 -0.085777 -0.099634 -0.113794 -0.132583 -0.151620 -0.173817 -0.202738 -0.233154 -0.253646 -0.224434 0.081751 1.343489 4.783478 9.795587 13.142874 31.751671 370.390594 8532.120117 100046.531250 100675.609375 55844.804688 105453.234375 113718.406250 39125.617188 2800.899658 1355.900757 3647.501221 10922.832031 5356.175293 602.025879 -0.097446 -0.115335 -0.131116 -0.147523 -0.171429 -0.192022 -0.220746 -0.250593 -0.274910 -0.279509 -0.086933 1.290548 7.988153 32.516396 81.639702 112.157349 124.492538 1285.600464 86252.648438 100201.718750 101403.632813 169857.406250 107096.156250 106336.210938 141381.203125 29169.273438 37259.859375 131354.359375 125654.367187 101544.375000 4433.671875 -0.130187 -0.151522 -0.167136 -0.186799 -0.210506 -0.234510 -0.264565 -0.294680 -0.320232 -0.288642 0.281224 4.367169 32.518665 189.638687 794.103821 1635.222534 1135.517578 1856.077393 89032.921875 105132.906250 102389.484375 123561.445312 107320.945312 170768.484375 146669.187500 115959.562500 115879.007812 148713.828125 200089.750000 108591.015625 6547.188477 -0.167180 -0.192345 -0.211094 -0.231893 -0.253654 -0.274060 -0.304241 -0.341253 -0.371381 -0.287439 0.771269 9.780687 97.186867 1188.743896 17584.984375 100315.320313 44338.871094 10542.970703 107383.500000 200031.078125 151371.937500 34876.425781 13691.185547 76583.664063 103041.937500 116269.414062 113767.445312 105654.765625 135074.093750 26234.835938 1536.244995 -0.213007 -0.235083 -0.251223 -0.237848 -0.178677 -0.114994 -0.140830 -0.243715 -0.354492 -0.293355 1.090016 15.314839 220.717346 6581.515137 100592.382813 100711.500000 100946.179688 74040.359375 101267.710938 101971.406250 102670.101563 7609.164551 933.805298 5233.385742 33487.988281 22593.519531 53034.812500 100560.335938 35544.273438 2848.963623 353.118195 -0.260471 -0.272253 -0.194079 0.150875 1.007824 2.080864 2.179112 1.306909 0.263736 -0.163290 0.935561 15.176807 260.231445 9903.780273 100177.289063 100225.593750 100596.867188 99867.664063 101159.351563 100114.453125 100089.187500 4740.516602 225.199570 278.264008 716.351257 741.441284 1408.998047 2740.051514 1650.617676 673.811218 195.797516 -0.298309 -0.210182 0.437702 3.493346 13.817424 30.381132 34.146019 19.434793 6.166207 1.138026 0.704865 8.633291 118.889244 2618.912842 99480.968750 100041.515625 100161.429688 14930.230469 26085.900391 56753.132813 11126.250977 790.898682 62.135395 23.365473 36.650616 63.094868 190.597992 795.248352 2043.383423 1396.313232 342.766174 -0.293310 0.149170 3.709430 28.709311 175.696548 634.222046 787.158691 299.329803 56.809273 9.131269 2.031377 3.795892 30.826235 302.329071 2609.842773 8272.507812 4998.009277 941.056030 713.707703 917.075500 417.664429 78.375786 12.086514 4.046977 7.389394 25.844072 163.974380 1146.352173 3383.756348 2285.137451 494.640350 -0.136805 1.291811 14.844257 187.681717 2645.493652 25640.009766 37903.746094 6603.874512 509.948792 50.119694 11.708652 8.000334 9.895408 30.135859 109.042755 217.228302 170.756760 68.543198 43.997440 42.337585 24.237020 7.729663 1.567585 1.070680 3.584982 14.873324 91.053345 516.251465 1324.201294 936.025635 326.998962 0.780507 3.853944 38.024441 733.766174 28239.720703 100062.664063 100318.914063 100788.500000 3040.199219 276.917328 72.722321 54.682491 33.901836 14.771338 10.099275 12.086108 10.792467 7.631582 6.999506 6.118660 3.321550 0.807023 -0.283534 -0.107083 1.218531 5.547810 25.736536 101.528870 192.752167 168.057816 169.877579 6.635840 13.841601 54.385715 990.660645 51260.746094 100522.750000 107170.281250 137908.109375 27018.160156 2707.912598 437.410706 353.850952 193.137924 52.259804 9.694200 2.957894 5.939930 18.459930 35.968899 35.808151 17.816036 4.320691 0.193854 -0.524018 -0.080745 1.385949 5.656321 15.449501 26.410089 31.833998 69.468063 39.047020 74.353271 84.430176 436.049591 9455.102539 102713.101563 200088.359375 128462.992187 102294.406250 25927.029297 2493.929199 1394.046021 619.874512 131.201324 18.348698 6.684826 29.065771 144.868622 416.283783 416.105774 144.341751 28.058636 3.326992 -0.211292 -0.276923 0.892819 4.533442 13.454361 27.373461 32.864349 33.029419 135.505417 281.182343 199.553970 187.147705 967.369873 7606.219238 105007.437500 103224.640625 131328.109375 142011.937500 35845.468750 3441.750977 803.333130 145.757019 20.918936 14.244770 106.979156 909.163269 3652.562256 3652.057617 844.113770 105.375008 10.592623 0.645505 0.249907 3.932673 26.564173 146.679489 450.184875 521.891663 215.471146 178.813675 403.295197 268.578857 181.404007 785.173340 4235.182129 31964.830078 108139.742187 200149.421875 107885.968750 100584.835938 8931.871094 507.433807 74.113419 13.752524 20.020144 189.230179 2088.660645 12167.398438 12166.234375 2086.258545 186.884415 15.974566 1.290269 1.379154 15.767678 188.074081 2444.726074 19289.871094 25667.835938 4368.408203 80.042572 159.234329 117.144241 140.241318 950.977844 4500.653320 6523.999023 10380.728516 103026.765625 100582.359375 100110.304688 6639.854492 271.991699 29.556631 6.500798 15.251837 138.849533 1320.274292 6031.646484 6029.981445 1221.538574 135.898941 12.853050 1.177314 2.801207 40.569317 845.222717 34321.867188 100023.046875 100088.351563 96006.367188 25.874498 29.825871 29.097269 63.662720 373.750671 1447.764893 1792.930664 1563.211792 10364.001953 34372.542969 12182.648438 1063.306885 86.577225 13.118238 5.318734 8.677448 45.992603 263.265961 788.371765 786.817688 243.482452 42.975834 5.307421 0.478935 3.278514 54.160206 1420.285889 100004.250000 100027.304688 100106.945313 100215.882813 58.484703 11.326530 6.365233 16.847570 71.099388 192.522949 235.154449 199.545319 447.796051 794.683716 451.050598 116.292778 45.168236 51.278431 38.456440 20.525158 17.791273 37.754421 71.946785 70.099503 32.395500 8.385921 1.105993 -0.174400 1.985845 33.721722 633.660217 21186.361328 100016.023438 100057.203125 51321.398438 238.450668 22.406805 3.476530 3.353369 10.342457 21.684805 25.644381 23.709436 31.590050 41.510658 39.354641 92.969406 449.329132 982.064209 699.730774 219.501114 99.433571 50.689018 21.638144 9.855038 3.906611 0.906312 -0.313806 -0.575112 0.438205 10.696063 119.811562 1222.394043 7164.486328 9324.957031 2129.863770 533.593140 57.089142 9.027412 2.846352 4.037878 6.532334 6.360628 4.167709 3.489089 7.404513 53.251637 731.929443 9308.594727 41884.996094 19521.724609 3102.758789 2384.941895 920.005920 156.460999 20.223160 2.377788 -0.129720 -0.649737 -0.759802 -0.443235 1.808017 15.177629 78.185196 215.459595 251.883072 135.481003 1960.210937 232.761215 41.596561 19.441267 48.181362 95.904533 68.399002 20.397720 4.161427 8.825129 127.609581 3104.878906 100012.656250 100186.945313 103652.562500 88604.742188 100368.039063 37910.527344 1792.396729 97.118256 9.567135 1.499279 -0.126648 -0.639707 -0.676768 -0.165312 1.650138 6.413951 13.562779 17.541824 27.819220 21466.759766 1138.519409 204.274155 157.191711 1201.103516 4342.978516 2331.012207 316.842773 28.292358 10.997100 136.003983 3653.908203 100027.070313 100634.726563 134324.359375 113348.046875 100459.164063 100108.445313 11176.550781 318.469940 48.440250 18.447144 4.857136 0.505022 -0.142735 0.766297 2.953025 4.919998 4.846265 4.334780 10.254357 57646.851563 2709.361572 648.360474 1193.045532 48517.074219 100147.218750 100051.320313 4344.361816 135.973282 12.230597 62.406818 912.236816 14629.200195 78174.687500 73020.406250 102812.195313 101816.750000 102132.210938 14240.399414 1036.649292 758.867065 279.929687 48.188892 6.796554 2.739623 10.779569 33.698318 54.071537 40.390961 15.855683 6.213035 14887.379883 2331.577148 1107.788940 5019.294922 106612.460937 104689.656250 100788.296875 20569.349609 303.701660 17.193739 24.330683 137.455536 741.615662 1973.032349 7444.048828 105415.242188 177585.046875 186392.531250 22302.238281 35282.800781 46337.347656 7162.867187 446.473694 35.253086 14.424375 78.130554 363.463623 785.661316 478.408173 120.021774 18.731985 2096.829102 1546.240112 3689.412842 65289.828125 200175.343750 200049.390625 113350.843750 8080.450684 224.139282 47.472015 98.467216 392.416016 1094.579224 1141.954712 3328.353271 43232.050781 105788.968750 103075.820313 163143.484375 103131.765625 100115.492188 100007.070313 2864.609619 103.265129 43.229511 392.210175 3657.392822 11124.315430 5093.483887 682.562256 66.138733 684.756836 2890.857910 12651.937500 102700.734375 103417.437500 114459.812500 102719.125000 2075.535156 290.577881 528.613831 1388.125488 8922.083008 56997.304688 29965.855469 102506.406250 131314.437500 134526.578125 103429.687500 200101.843750 102874.570313 100106.859375 100006.500000 5090.222656 142.629471 76.450699 936.986511 12229.802734 51281.347656 19319.093750 1672.289795 120.679558 359.808044 2079.589111 8647.070312 102209.218750 108728.015625 163453.734375 88455.117188 4230.458008 2290.496826 16457.773438 71744.156250 123351.398437 102581.046875 146417.687500 111342.656250 104036.234375 142058.437500 77208.609375 41491.792969 100649.015625 100044.296875 77487.617188 1787.188843 88.250717 97.733215 872.848450 7430.817383 24263.416016 10564.255859 1204.070312 142.215775 101.739929 470.801819 1532.311279 14782.567383 186234.421875 146401.671875 104967.976563 33511.523438 19212.849609 102346.656250 102282.398438 188524.859375 118332.367187 142338.890625 109781.617187 103601.929688 106102.195313 9682.995117 2419.631836 10281.889648 12179.771484 2645.646973 244.997467 40.716087 211.084351 2250.290527 13131.355469 16000.811523 5708.321289 2384.606201 554.250366 19.210342 66.053200 225.093079 3101.314941 101163.429688 100988.039063 101906.320313 53564.531250 37619.656250 105222.750000 104310.789063 107116.390625 71483.250000 20414.847656 87355.085938 200224.031250 125792.203125 64245.828125 2308.038086 372.748260 292.101196 124.058182 30.153721 32.673542 376.254669 6111.997070 57655.574219 74688.453125 107260.164062 100843.609375 9460.256836 2.791087 9.953983 50.173038 704.942261 19966.150391 100121.710938 100721.546875 8725.584961 10346.478516 105304.664063 111387.585937 103576.437500 9480.018555 1943.077026 59060.300781 104468.218750 102264.281250 100745.484375 8849.809570 310.374268 61.491989 52.961735 38.967747 33.699909 258.623230 3242.080078 27038.574219 123614.546875 103958.335938 100659.921875 100132.976563 0.026349 1.362594 9.507938 80.701836 632.014771 2076.333008 1622.091309 778.067505 1229.714478 6058.570801 15836.183594 6963.707520 922.388672 1245.348999 44863.093750 134954.718750 113112.507812 102935.789063 7912.614746 492.795868 437.898468 1114.788208 799.067200 164.946976 101.983391 687.388611 6300.789062 103907.000000 102938.242188 100782.476563 100126.132813 -0.408857 -0.180546 1.173353 7.787660 32.482372 70.100052 88.081192 115.569275 177.697128 385.409393 591.986572 348.693390 125.445610 714.871765 12862.884766 117331.695312 119307.789062 22945.638672 2834.948242 1270.713501 7642.755371 60775.453125 28115.623047 1810.990479 123.089134 376.674927 8803.014648 128394.468750 200139.156250 118159.148437 15272.999023 -0.422258 -0.417249 -0.250564 0.519798 2.728792 7.129184 15.969769 30.235268 39.282375 42.328568 42.146061 28.100044 26.850700 189.884140 1891.275513 6762.367187 4515.545898 2717.295898 5117.325195 27579.505859 90362.875000 107184.046875 100516.460938 7624.336426 240.519897 879.388184 70719.234375 101120.546875 104450.945313 105207.742188 4194.965820 -0.377668 -0.407414 -0.408252 -0.313605 0.063852 1.120717 3.605265 6.808584 8.135782 6.384745 4.301940 2.701360 4.852074 29.555828 149.441666 358.355042 809.028259 4957.861816 51271.664063 104055.500000 120979.031250 200061.906250 103662.750000 4458.899414 180.973938 693.937439 45667.125000 100847.437500 112294.890625 169907.500000 32911.867188 -0.325027 -0.358742 -0.382292 -0.389046 -0.324714 -0.085529 0.397931 0.965227 1.057355 0.645446 0.089894 -0.220141 0.265327 3.610878 15.993233 69.259872 521.305237 4833.799316 107420.640625 103903.671875 102709.828125 106579.804687 10822.363281 652.249023 83.525787 212.352356 3550.036133 47623.320313 126234.460937 106511.843750 100559.968750 -0.270379 -0.302934 -0.329023 -0.345563 -0.353375 -0.329102 -0.261921 -0.190615 -0.216253 -0.341564 -0.484825 -0.581743 -0.533463 0.064444 3.238588 24.315548 191.113754 1488.151855 29980.824219 130570.359375 133404.265625 103913.484375 3007.191650 210.096313 250.450089 695.878723 939.885803 3318.055176 33379.382813 103434.109375 86893.734375 -0.222577 -0.248334 -0.275744 -0.294636 -0.313157 -0.329682 -0.344665 -0.359374 -0.387658 -0.442852 -0.510940 -0.565115 -0.594127 -0.476138 0.572551 7.747132 57.894245 634.366150 16341.908203 110260.984375 116066.546875 23345.326172 930.229187 306.180969 2723.102783 18135.119141 15710.297852 19529.175781 102953.984375 95196.437500 11954.743164 -0.186095 -0.204373 -0.223393 -0.243264 -0.258554 -0.276459 -0.300213 -0.323298 -0.353658 -0.394378 -0.450462 -0.512691 -0.555646 -0.546935 -0.209053 2.332546 24.067265 347.296509 9266.775391 100286.593750 100375.445313 11309.994141 534.212341 641.613037 16424.699219 100146.882813 101985.679688 77749.640625 105134.648438 138236.218750 57403.339844 -0.152888 -0.164792 -0.178325 -0.193068 -0.206615 -0.222963 -0.247339 -0.264439 -0.289378 -0.329286 -0.380909 -0.440012 -0.487452 -0.510993 -0.403211 0.551438 8.183158 86.812180 928.002502 5814.009766 5839.847656 1144.634766 169.598160 483.378662 10126.434570 100093.773438 100074.218750 29438.994141 125886.695312 200047.921875 107833.039062 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002253 -0.002700 -0.003174 -0.003660 -0.004137 -0.004583 -0.006384 -0.009835 -0.010398 -0.010801 -0.010929 -0.010842 -0.010553 -0.010040 -0.009378 -0.007277 -0.006573 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002382 -0.002917 -0.003531 -0.004229 -0.004935 -0.007203 -0.011073 -0.012388 -0.013525 -0.014418 -0.016442 -0.016715 -0.016700 -0.016262 -0.015490 -0.014502 -0.013278 -0.011930 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002398 -0.003021 -0.003766 -0.004617 -0.007096 -0.008455 -0.013048 -0.016481 -0.021663 -0.023813 -0.025617 -0.026681 -0.027190 -0.027040 -0.026220 -0.024877 -0.023097 -0.019560 -0.017616 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002317 -0.002979 -0.003794 -0.004826 -0.007626 -0.010385 -0.016160 -0.021129 -0.026308 -0.029890 -0.033321 -0.035891 -0.037761 -0.039625 -0.039597 -0.039849 -0.038041 -0.035518 -0.032397 -0.030514 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002796 -0.003660 -0.004755 -0.007695 -0.011234 -0.019090 -0.025009 -0.030378 -0.035924 -0.041356 -0.046145 -0.051530 -0.055754 -0.059034 -0.058019 -0.058312 -0.055654 -0.052965 -0.050279 -0.047180 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002518 -0.003336 -0.004418 -0.007366 -0.011114 -0.019411 -0.026252 -0.032904 -0.041559 -0.050576 -0.059374 -0.066346 -0.074105 -0.079677 -0.085258 -0.088314 -0.088402 -0.088523 -0.083550 -0.075857 -0.067719 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002162 -0.002917 -0.003905 -0.006667 -0.010467 -0.016986 -0.025929 -0.034919 -0.045311 -0.056771 -0.067534 -0.076216 -0.087118 -0.099355 -0.109218 -0.117440 -0.127973 -0.130543 -0.127776 -0.120874 -0.111196 -0.100042 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002432 -0.003289 -0.004483 -0.009279 -0.015468 -0.025282 -0.034644 -0.046734 -0.058701 -0.070963 -0.082208 -0.096806 -0.113896 -0.129188 -0.144473 -0.163426 -0.171757 -0.174996 -0.174047 -0.167241 -0.156173 -0.144236 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001963 -0.002681 -0.003660 -0.007903 -0.012594 -0.019476 -0.032970 -0.043934 -0.057553 -0.072212 -0.085673 -0.104436 -0.121148 -0.136171 -0.154871 -0.179284 -0.200584 -0.215099 -0.219146 -0.218308 -0.216802 -0.206486 -0.192578 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002103 -0.002896 -0.003961 -0.010505 -0.015574 -0.027056 -0.039158 -0.052926 -0.071697 -0.088351 -0.111315 -0.130826 -0.137754 -0.136994 -0.144855 -0.168369 -0.204881 -0.216807 -0.196514 -0.175814 -0.194654 -0.227848 -0.243772 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002207 -0.003042 -0.005689 -0.012787 -0.021451 -0.034823 -0.047419 -0.067775 -0.087390 -0.107715 -0.135303 -0.150834 -0.136050 -0.089969 -0.055407 -0.076748 -0.062995 0.209874 0.816550 1.226292 0.917194 0.226578 -0.168978 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002269 -0.004715 -0.010712 -0.018280 -0.029186 -0.042656 -0.059481 -0.081263 -0.104702 -0.134341 -0.165563 -0.175604 -0.135851 -0.026614 0.058601 0.170500 0.992815 5.064251 17.245579 26.377686 18.176485 6.145799 0.967625 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001810 -0.004211 -0.008435 -0.019173 -0.026402 -0.038242 -0.055984 -0.075233 -0.101662 -0.131476 -0.167841 -0.207320 -0.219278 -0.163432 -0.000216 0.270439 1.242359 8.107750 66.147758 399.000275 861.812378 462.236450 84.216408 9.619517 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001849 -0.002084 -0.004184 -0.008588 -0.014486 -0.027936 -0.035843 -0.051830 -0.068542 -0.092570 -0.121884 -0.162915 -0.207850 -0.255973 -0.273525 -0.165043 0.236877 1.478411 6.005465 46.452900 754.707092 18527.125000 100054.796875 25273.783203 1195.365356 59.752949 -0.001074 -0.001144 -0.001201 -0.002915 -0.003202 -0.003494 -0.007487 -0.010146 -0.016337 -0.024529 -0.036042 -0.047660 -0.061345 -0.084990 -0.114356 -0.151015 -0.197601 -0.252806 -0.303981 -0.280275 0.067893 1.801646 8.232783 28.249140 167.974106 5452.216309 100851.335938 101055.484375 100393.429688 9267.094727 199.742676 -0.001454 -0.001562 -0.003343 -0.003719 -0.005880 -0.010224 -0.015217 -0.018868 -0.023418 -0.036221 -0.050980 -0.062225 -0.082975 -0.105549 -0.136797 -0.179763 -0.243483 -0.302169 -0.336588 -0.215354 0.881833 7.464010 40.525642 148.768433 473.043701 7763.659668 121217.515625 131132.765625 105579.625000 10655.871094 620.340759 -0.001985 -0.003767 -0.005713 -0.007864 -0.014227 -0.018329 -0.019431 -0.024253 -0.035889 -0.050935 -0.063881 -0.081942 -0.101656 -0.129465 -0.165854 -0.219194 -0.287719 -0.344908 -0.361752 -0.047837 2.535109 19.902893 134.093964 586.506287 1505.831909 13579.244141 125363.656250 200142.390625 73142.593750 3957.031982 10507.655273 -0.004450 -0.006704 -0.010090 -0.016675 -0.023001 -0.026136 -0.032932 -0.040926 -0.046781 -0.064539 -0.082682 -0.105465 -0.129289 -0.161470 -0.209491 -0.268452 -0.334105 -0.384804 -0.356579 0.327479 5.057220 36.554863 237.245758 1071.250488 2273.075928 12075.460938 100731.882813 102064.953125 37678.804688 13291.507813 101832.671875 -0.011792 -0.013576 -0.020461 -0.025478 -0.029172 -0.034965 -0.045222 -0.053797 -0.070147 -0.089496 -0.108675 -0.133095 -0.162607 -0.202364 -0.256764 -0.319529 -0.383013 -0.411628 -0.242505 1.460473 14.166948 92.911346 476.367493 1395.236450 1753.860596 2327.163818 13610.124023 20044.066406 30873.388672 44499.828125 105531.781250 -0.018408 -0.024375 -0.031359 -0.035609 -0.041889 -0.051534 -0.061534 -0.072813 -0.094515 -0.114747 -0.143858 -0.175569 -0.210048 -0.250457 -0.300887 -0.362810 -0.402081 -0.334327 0.260794 5.074735 52.825348 584.155090 5916.238281 24692.763672 13748.460938 2283.389404 828.786011 1927.764404 10450.888672 15754.176758 73374.125000 -0.030664 -0.037055 -0.046622 -0.054055 -0.061131 -0.073963 -0.087636 -0.100681 -0.125260 -0.149765 -0.184281 -0.215504 -0.249468 -0.291575 -0.340490 -0.367713 -0.254496 0.396421 2.874468 15.679294 175.201996 4451.358887 101286.648438 106409.078125 107483.375000 19078.785156 680.972473 282.713470 929.919250 1360.886841 2927.262451 -0.045726 -0.054210 -0.062087 -0.071601 -0.084973 -0.102396 -0.118359 -0.139460 -0.165111 -0.195778 -0.221948 -0.251871 -0.287446 -0.311121 -0.321066 -0.207082 0.694560 5.801476 25.755281 79.677315 381.235413 13542.521484 100845.312500 102440.343750 102528.125000 70405.851563 1002.843506 86.909996 102.864502 143.974747 237.010757 -0.064142 -0.075207 -0.090448 -0.102995 -0.118285 -0.131845 -0.150127 -0.176546 -0.208929 -0.240520 -0.264718 -0.279140 -0.241067 -0.109320 0.102055 0.788224 5.336015 43.657887 320.401337 1342.736328 2141.169189 8277.321289 114786.914062 117821.609375 103378.960938 23692.501953 648.676086 266.369110 564.949768 390.577637 112.974167 -0.086621 -0.106343 -0.119295 -0.133349 -0.154873 -0.171817 -0.194657 -0.225185 -0.256293 -0.281367 -0.295624 -0.196524 0.254037 1.441548 3.415133 6.168674 22.177235 249.210815 4319.093750 56783.855469 101036.546875 61561.125000 109391.218750 138019.031250 115280.757812 3913.168945 792.142090 7258.893555 48530.257813 22781.345703 1532.610840 -0.121420 -0.139302 -0.155526 -0.173292 -0.195896 -0.219533 -0.248462 -0.279130 -0.303299 -0.327005 -0.261713 0.275287 2.857795 11.951755 32.644653 57.050114 84.468857 793.925110 31258.244141 100262.867188 102366.390625 200094.968750 103718.382813 101298.648438 102206.875000 6523.065430 5230.864746 106070.031250 102262.046875 100319.164063 18511.068359 -0.157919 -0.178678 -0.195440 -0.215196 -0.242391 -0.266581 -0.300807 -0.333776 -0.361600 -0.368894 -0.106411 1.867229 14.857864 93.550194 467.672089 1157.626221 896.079224 1508.398804 32570.283203 107214.070312 103481.101563 163180.218750 103345.742188 102569.765625 112329.859375 11471.632813 23057.138672 156805.765625 114607.437500 101139.609375 28139.625000 -0.204167 -0.225723 -0.245649 -0.268978 -0.294194 -0.319440 -0.355398 -0.400375 -0.426362 -0.393760 0.220114 5.663529 63.407631 858.945007 12872.188477 65555.000000 32970.425781 13207.137695 103845.265625 146310.625000 182190.453125 17929.544922 26663.208984 33403.183594 16281.934570 9658.098633 22806.667969 92581.203125 117580.257812 101237.492188 3704.689941 -0.256855 -0.282599 -0.303191 -0.307234 -0.287051 -0.260839 -0.294238 -0.372841 -0.447698 -0.411049 0.543242 11.027332 171.274170 4985.937988 100031.117188 100068.968750 100929.500000 92523.117188 100942.984375 101172.968750 101564.031250 10890.437500 909.322693 1043.998413 1865.478271 1686.362061 3689.492676 8431.258789 4852.993652 1575.116333 267.274506 -0.313245 -0.334500 -0.296242 -0.105474 0.310227 0.795739 0.894648 0.415817 -0.129738 -0.348670 0.545936 12.484494 218.244644 7589.674316 100015.187500 100044.429688 100689.312500 87760.476563 100996.359375 100093.781250 100067.570313 7206.313477 247.094910 97.892433 150.487335 186.250488 332.726898 503.822906 335.038849 139.617004 134.962082 -0.352988 -0.315680 0.040951 1.509570 5.699749 12.354810 13.874303 8.077392 2.681255 0.365239 0.344687 7.463489 108.656769 2230.386475 65501.242188 100016.851563 100177.765625 12944.143555 42247.101563 100027.179688 17564.330078 1056.967163 72.415977 24.394573 40.340923 54.206680 61.379726 85.037445 105.962402 98.372139 371.185608 -0.356100 -0.072209 1.676523 11.165037 54.613663 155.245163 177.583771 85.917015 23.226496 4.935606 1.008332 2.838122 26.589218 263.264587 2063.343018 6965.215820 4244.664062 868.989319 919.827515 1228.954468 513.740112 94.424393 16.668423 19.354454 47.285454 63.222313 54.368015 71.525948 109.502571 109.125832 402.137177 0.017810 1.016192 7.317470 58.988949 448.925934 2095.137451 2669.977783 893.215271 161.005051 31.024881 6.810475 2.595350 5.587768 26.897871 101.978508 190.931244 151.419861 64.808029 49.293686 50.440914 29.040009 9.324295 4.972239 13.859601 34.690434 47.168743 42.917377 48.619087 66.722458 65.541946 146.257446 3.242882 7.595324 22.228624 174.686462 2274.931396 19361.865234 31594.259766 6761.307129 1397.354980 280.196106 43.708824 11.242659 5.730064 4.720070 8.074174 11.938789 11.794971 11.065934 13.248114 12.493916 6.718945 2.255426 1.636120 5.571392 14.676035 21.040609 24.026573 27.065287 27.696766 23.810350 38.602646 39.912632 78.501419 88.421417 285.842468 3473.435547 35141.324219 71345.703125 108540.585937 57298.605469 4379.168945 281.095032 46.157589 18.578505 7.270283 3.659161 5.088844 15.919774 62.280502 145.223267 144.817413 60.889618 13.448606 2.355879 1.883720 4.826527 9.697474 15.251020 18.050056 14.993395 11.087812 14.306533 465.069519 1219.668091 776.196106 534.963379 1559.836792 12237.489258 109668.781250 102447.632813 100462.914063 57102.261719 1213.038086 141.516678 43.863342 15.141209 7.906196 16.611031 110.146202 911.257935 3653.760986 3652.583008 844.236755 99.107666 11.100116 2.337028 4.037516 9.258572 17.700645 27.163683 37.432755 39.372066 28.896782 3967.406738 15144.006836 6094.540039 1637.875610 2412.843018 15673.434570 110001.953125 102456.796875 101907.796875 104003.632813 3284.344238 395.037964 72.080200 20.952932 14.316461 45.381546 561.450867 12177.045898 100008.039063 100003.242188 12166.226563 549.914978 34.504333 5.083995 6.332823 14.206478 44.096905 182.203781 573.724304 689.424927 339.349976 6905.127441 31292.398438 11569.276367 2098.182129 11049.728516 102169.593750 169911.531250 120001.476562 107432.281250 35342.875000 8343.639648 839.546143 88.823128 19.921461 16.840998 73.722015 1340.928345 56757.527344 100027.234375 100011.328125 51215.519531 1221.570679 55.028774 6.850511 7.658862 25.954433 224.833939 3124.297119 28310.367188 38276.960938 7009.319824 1528.760986 4783.111328 2297.264893 1168.508179 19554.382813 100319.585938 102024.070313 46295.816406 11441.357422 15514.496094 5633.627441 652.084473 68.379776 14.723175 13.364874 59.381683 821.382446 21242.554688 100048.296875 100018.945313 21187.898438 731.451050 40.915104 4.943356 6.831903 50.157162 1059.411255 56751.230469 100232.664063 101791.359375 106034.195313 159.138184 286.486084 212.273285 362.698242 4731.235352 46332.750000 63039.968750 8249.798828 1610.600708 1898.327515 997.706177 193.104126 29.285351 8.528829 8.359443 28.372698 206.277100 1838.133667 10208.670898 10185.166016 1790.081787 165.070435 15.400708 1.980689 5.023380 66.501457 1790.087891 100027.617188 100281.507813 102450.898438 109325.609375 176.324936 36.555252 25.562874 69.050995 426.060791 1670.341187 1976.790771 689.542664 238.603928 176.817261 106.826370 35.576477 16.471155 17.211390 15.590942 16.880472 42.087536 143.425034 357.893280 347.734894 121.907158 24.247477 3.176688 0.150218 2.533798 38.374962 787.419128 31128.650391 100132.968750 100868.265625 79822.945313 938.582214 55.607388 8.671322 11.158845 37.003780 89.104774 108.912659 68.311829 37.544571 22.751883 16.042938 28.612537 95.192917 168.189133 141.434525 78.843300 63.566555 45.276535 34.147694 23.704145 10.744387 2.571109 -0.068556 -0.579227 0.567932 12.097063 136.642136 1538.188110 10204.716797 13486.744141 3079.708496 2334.713623 130.364807 20.642990 6.529325 6.911417 10.978065 12.693395 10.066380 6.422455 5.073086 17.803528 128.394836 788.214233 1951.393066 1366.129639 893.659180 1087.632812 484.509735 96.522118 15.115037 2.383633 -0.082283 -0.698613 -0.798737 -0.438949 2.120611 17.318302 90.171768 272.466614 356.163727 366.041840 6388.458984 684.776428 157.113297 36.716755 26.456944 40.434582 31.355782 11.302841 3.096981 4.081630 34.505627 389.873657 3661.543945 12278.170898 8221.234375 20188.312500 51293.113281 11128.932617 847.852356 63.455429 6.715475 0.851169 -0.333873 -0.706054 -0.635022 0.053511 2.289068 8.294834 19.572939 40.505726 130.959579 103363.968750 8615.609375 1986.764648 259.149384 345.439575 868.098938 539.778748 103.052689 13.204586 5.118620 36.737083 418.327271 3984.320312 14935.185547 18929.093750 100988.484375 100107.914063 100037.515625 4331.497070 188.421860 30.432215 11.799233 2.961665 0.252727 0.169145 2.286405 7.063218 11.157378 11.026631 12.607221 40.409199 136985.453125 104750.390625 18269.486328 1197.790283 4548.088867 25379.242188 11221.722656 867.677612 54.304806 6.355814 19.431267 157.184814 1075.198242 3013.300781 14997.365234 100417.546875 100344.445313 100389.046875 5354.795898 506.748291 355.726807 137.375153 30.193611 5.044904 5.445158 28.379936 105.591743 187.048294 127.970642 42.418766 17.082247 137327.421875 102729.601563 24092.927734 3988.667480 24228.826172 103678.687500 68463.546875 2612.854004 104.012321 9.512176 10.535353 43.161942 158.960846 435.309662 2975.669922 38720.218750 103729.648438 26418.294922 4073.317139 8061.596191 10192.597656 2258.858887 227.795227 23.388523 30.741919 297.145538 2257.120605 6029.172363 3104.422852 478.689789 52.803600 9795.657227 30705.548828 67583.250000 60048.003906 108838.054687 148426.750000 31624.052734 1713.135498 101.977150 25.848177 41.601490 100.361603 231.379639 571.063904 2400.923584 6784.607422 26465.244141 39396.335938 20051.667969 100498.703125 100038.132813 28232.687500 1053.043335 66.136497 118.887901 2448.073975 62892.699219 100011.125000 100006.273438 5091.750488 228.422073 5579.692383 100613.468750 105311.070313 200146.515625 105002.500000 102224.890625 71066.546875 1308.416260 141.637665 240.180206 492.766022 938.913879 2397.565186 7421.998535 100434.992188 102352.398438 57294.625000 33484.875000 33862.414063 100456.117188 100034.992188 77487.070313 1787.402588 88.522346 235.091385 7886.182617 100200.929688 100202.695313 100082.320313 19300.287109 483.703217 3414.280518 86285.593750 103410.343750 169946.843750 104394.867188 106569.593750 42030.281250 1487.079834 657.479492 4425.806641 13665.572266 8747.410156 16280.326172 53965.460938 100889.234375 100680.648438 102808.210938 11250.312500 8422.038086 100161.500000 100018.343750 14596.876953 732.961304 68.973442 294.881317 5530.731445 106038.250000 106594.265625 101365.992188 10358.835937 352.425446 642.590027 5590.055664 13998.349609 14952.223633 70719.234375 134395.046875 73756.625000 4265.622559 3463.268311 79018.695313 103562.476563 103855.929688 17807.320313 48456.917969 101236.054688 102778.023438 104533.171875 8326.839844 1153.860352 2934.725342 3663.775635 979.557312 131.447525 59.450134 840.672546 23939.677734 107222.101562 125950.367187 37618.375000 2724.655273 368.456757 71.417404 291.821686 585.980896 1305.112549 19071.988281 100763.976563 100312.265625 5003.054687 7139.193848 148492.265625 200112.281250 135336.937500 11428.239258 6279.496094 92930.609375 200079.937500 125822.101562 47869.917969 2152.007324 298.813141 169.625549 70.163651 22.367016 74.446983 1802.226562 100101.992188 100677.257813 105697.093750 131529.031250 27845.441406 3209.992432 7.719294 22.050911 51.226318 255.151413 2916.146484 14848.512695 9251.886719 1359.752563 5863.400879 131205.593750 200035.531250 146341.640625 5596.096191 1355.384277 43395.058594 102609.515625 103352.617188 109346.703125 12057.481445 770.661133 85.083336 25.316721 15.892458 57.172142 1146.145752 46373.414063 101406.531250 146422.359375 151336.468750 101279.976563 23370.458984 0.553157 2.221402 7.620079 38.225380 201.933289 545.776611 426.936798 232.566971 1943.335205 49774.085938 103376.679688 40566.093750 1530.868286 789.197266 28550.076172 101492.546875 124723.562500 200147.609375 75772.945313 3130.903320 236.801743 160.571030 109.435112 53.393875 245.101959 2974.583740 21014.482422 78561.656250 103833.156250 100495.250000 28294.578125 -0.358736 -0.141030 0.708596 4.415285 15.450235 29.001581 30.147480 41.576614 228.034378 1605.494263 3755.745605 1378.676880 203.396713 244.948273 3177.471680 43531.300781 129564.695312 116888.914062 101511.093750 4509.492676 1021.544312 1566.633789 1042.394409 188.447098 65.435410 323.225739 2682.620117 23994.734375 78948.359375 45038.992188 4545.453125 -0.404915 -0.413944 -0.316218 0.080762 1.023030 2.252959 3.628694 7.110905 22.038553 68.102516 104.602180 63.552746 24.131411 55.496918 326.602356 1430.667480 6583.696777 36246.765625 71587.781250 22962.031250 11885.758789 8066.175781 3869.710693 485.900940 62.176926 327.942047 9272.480469 100506.062500 101551.804688 23457.255859 1113.098755 -0.357437 -0.394138 -0.405350 -0.384076 -0.294367 -0.087768 0.283363 0.987732 2.271365 4.541158 5.594568 4.009272 3.028465 10.940114 52.730286 340.077423 6351.916016 100946.445313 108908.351562 200216.109375 105590.429688 37833.789063 3469.375488 388.951019 51.191872 270.986420 6969.786133 100147.976563 100708.304688 16518.964844 1709.174194 -0.300991 -0.338372 -0.365845 -0.388355 -0.397723 -0.370989 -0.299013 -0.215168 -0.125260 -0.054551 -0.098739 -0.236030 -0.058939 2.115723 17.941259 213.775314 5143.832031 100634.343750 119365.718750 200184.937500 104276.718750 96454.578125 2577.651367 173.270599 30.628950 98.410805 968.318787 6579.644043 9941.776367 6744.671387 3283.169189 -0.240375 -0.274362 -0.302352 -0.325423 -0.354948 -0.369561 -0.373223 -0.379074 -0.411234 -0.461241 -0.514389 -0.568991 -0.514908 0.246237 6.914967 76.671814 1003.645569 10504.155273 34518.535156 105374.179688 101821.609375 19668.759766 1053.819580 85.196793 49.385410 114.519722 246.486496 665.433960 1840.162231 3465.600830 2205.874023 -0.190910 -0.215550 -0.239027 -0.266862 -0.286977 -0.314782 -0.343490 -0.364880 -0.388757 -0.430859 -0.482836 -0.532577 -0.545808 -0.322802 1.683902 16.864845 113.282097 577.840820 2055.697754 6694.789551 8119.632324 1974.704834 256.872162 64.777687 212.705841 671.609802 766.609436 1349.734253 4537.638184 7269.463379 5237.021973 -0.152970 -0.169516 -0.186954 -0.211385 -0.225807 -0.250205 -0.271918 -0.297800 -0.322022 -0.359147 -0.411291 -0.465508 -0.513190 -0.474163 0.015374 2.853099 16.991585 91.028404 552.147766 2381.117187 2588.385498 625.490784 93.183380 80.397331 550.423218 2269.424561 2211.182617 3461.857422 32244.611328 106455.867187 101177.359375 -0.123522 -0.131786 -0.142709 -0.161748 -0.178596 -0.194492 -0.216436 -0.236359 -0.256923 -0.290309 -0.337532 -0.395337 -0.446408 -0.483897 -0.407077 0.208995 3.536490 22.762325 122.714470 385.421631 386.983643 134.600967 34.203876 64.090591 438.176788 1629.814941 1620.833984 4171.206055 104253.460938 103153.492188 100669.234375 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001963 -0.002333 -0.002738 -0.003130 -0.003531 -0.003877 -0.004168 -0.005428 -0.008938 -0.009286 -0.009432 -0.009406 -0.009146 -0.007398 -0.006959 -0.006407 -0.005810 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002074 -0.002536 -0.003042 -0.003582 -0.004168 -0.004755 -0.007824 -0.010492 -0.011447 -0.012201 -0.012686 -0.014412 -0.014389 -0.014071 -0.013493 -0.012672 -0.011643 -0.009194 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002088 -0.002607 -0.003219 -0.003933 -0.004720 -0.007001 -0.009286 -0.012635 -0.015620 -0.018761 -0.021747 -0.022717 -0.023249 -0.023166 -0.022611 -0.020085 -0.018728 -0.017223 -0.015644 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002571 -0.003265 -0.004078 -0.005046 -0.007754 -0.011902 -0.016156 -0.022095 -0.025081 -0.027792 -0.030000 -0.031556 -0.032327 -0.033561 -0.034228 -0.032952 -0.030990 -0.029947 -0.025752 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001870 -0.002432 -0.003130 -0.004019 -0.005084 -0.008102 -0.012847 -0.021087 -0.025279 -0.029714 -0.034148 -0.038091 -0.042714 -0.046212 -0.049358 -0.048907 -0.049732 -0.047957 -0.047394 -0.043982 -0.043292 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002192 -0.002876 -0.003739 -0.004862 -0.009330 -0.014758 -0.022040 -0.027348 -0.034386 -0.042047 -0.049764 -0.056103 -0.062959 -0.067650 -0.073593 -0.075241 -0.075888 -0.076700 -0.073000 -0.067103 -0.060580 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002518 -0.003336 -0.004418 -0.008827 -0.014291 -0.021847 -0.030021 -0.037586 -0.047618 -0.058146 -0.067550 -0.077805 -0.089112 -0.097620 -0.105140 -0.110746 -0.114446 -0.112329 -0.107329 -0.098616 -0.089826 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002836 -0.003794 -0.007911 -0.013191 -0.018775 -0.029224 -0.039197 -0.049473 -0.062308 -0.074039 -0.087931 -0.102091 -0.115645 -0.131295 -0.145977 -0.154060 -0.156133 -0.153174 -0.147170 -0.138947 -0.128152 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002333 -0.003130 -0.004229 -0.010688 -0.016602 -0.024994 -0.037151 -0.048363 -0.062892 -0.077251 -0.093718 -0.111945 -0.131481 -0.153935 -0.174150 -0.185274 -0.194443 -0.198703 -0.198008 -0.192099 -0.184871 -0.175184 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001845 -0.002501 -0.003383 -0.006207 -0.013305 -0.023527 -0.033514 -0.044541 -0.059955 -0.078425 -0.100095 -0.122054 -0.148259 -0.174911 -0.199103 -0.218061 -0.227009 -0.216778 -0.189881 -0.173182 -0.186083 -0.212590 -0.226673 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002626 -0.004971 -0.009965 -0.018818 -0.027264 -0.040885 -0.054600 -0.076390 -0.098320 -0.123908 -0.153987 -0.184538 -0.211324 -0.231190 -0.239647 -0.178190 0.107046 0.643057 0.993753 0.683867 0.137089 -0.169839 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001772 -0.003877 -0.004697 -0.007327 -0.016873 -0.026560 -0.035117 -0.051691 -0.070036 -0.090771 -0.119322 -0.152694 -0.190755 -0.226477 -0.247018 -0.256105 -0.152866 0.609792 3.839915 12.597401 20.448051 14.157750 4.519431 0.769030 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001849 -0.002084 -0.002301 -0.004447 -0.007034 -0.015864 -0.025088 -0.034661 -0.049434 -0.066117 -0.089704 -0.118411 -0.156408 -0.191707 -0.236804 -0.270934 -0.281610 -0.210262 0.461355 5.761772 46.902824 254.991562 537.180786 294.425751 56.328655 7.444100 0.000000 0.000000 -0.001001 -0.002746 -0.003048 -0.003352 -0.004240 -0.004795 -0.010915 -0.015566 -0.026457 -0.033819 -0.049338 -0.061999 -0.082783 -0.109910 -0.145007 -0.190446 -0.237069 -0.288936 -0.302698 -0.233056 0.182667 2.755419 30.323713 466.443573 7595.896973 34790.062500 10139.762695 679.777771 39.940571 -0.001236 -0.001326 -0.003156 -0.003542 -0.003939 -0.009105 -0.012034 -0.013356 -0.020346 -0.028247 -0.035551 -0.047091 -0.060479 -0.075306 -0.102092 -0.133251 -0.177031 -0.231345 -0.285127 -0.318932 -0.257532 0.118730 1.592489 8.290377 86.625343 2584.224365 100121.242188 100136.921875 100066.882813 4355.858887 124.848045 -0.001703 -0.003567 -0.004071 -0.005990 -0.010275 -0.013651 -0.017538 -0.021401 -0.024128 -0.038609 -0.049574 -0.061924 -0.075099 -0.096775 -0.125088 -0.163622 -0.218824 -0.275260 -0.327454 -0.328831 -0.084009 1.196079 5.778185 21.454321 130.418579 3025.186523 100913.617188 101138.406250 100429.296875 4860.383789 273.621948 -0.005579 -0.006314 -0.009503 -0.014172 -0.017940 -0.022374 -0.025268 -0.030983 -0.036724 -0.050072 -0.061828 -0.077940 -0.098967 -0.121488 -0.155547 -0.204052 -0.263189 -0.318638 -0.366460 -0.297929 0.411845 3.845847 16.336575 47.510994 159.824631 1249.717285 13799.244141 53029.199219 15018.946289 1255.640381 1925.708496 -0.008402 -0.010965 -0.015926 -0.020086 -0.025096 -0.030249 -0.037896 -0.043011 -0.054101 -0.070245 -0.082734 -0.103632 -0.126036 -0.154490 -0.194840 -0.247202 -0.311087 -0.360029 -0.376374 -0.058595 2.082609 12.634917 55.014584 151.420380 258.065155 782.391418 3458.008789 4721.532227 1792.598022 1632.797363 17593.304688 -0.012436 -0.018088 -0.024349 -0.029957 -0.035937 -0.041055 -0.051767 -0.060396 -0.076002 -0.090499 -0.112309 -0.136945 -0.161100 -0.194269 -0.241928 -0.301058 -0.359665 -0.390343 -0.302089 0.846738 9.540179 68.496231 501.584839 2591.738037 3549.627441 1071.180542 817.732971 1025.631348 978.801514 2959.900391 54190.367188 -0.024239 -0.030453 -0.038463 -0.046203 -0.053505 -0.063245 -0.073288 -0.083947 -0.100184 -0.121751 -0.150542 -0.176927 -0.211428 -0.251435 -0.295709 -0.352072 -0.395276 -0.360088 0.047995 3.661710 37.517426 430.520203 6247.183105 102628.812500 104030.914063 12989.035156 600.255920 266.602661 761.274170 3040.022949 48631.804688 -0.036940 -0.045608 -0.055514 -0.065946 -0.074004 -0.086409 -0.098940 -0.113678 -0.138002 -0.163842 -0.192902 -0.225549 -0.261708 -0.300077 -0.340073 -0.376754 -0.326829 0.017350 1.482862 10.243677 110.678864 2182.113281 61389.488281 200082.781250 200067.531250 44828.875000 1080.945923 159.744537 614.309326 1967.541504 7999.847168 -0.056246 -0.066931 -0.079060 -0.090501 -0.101062 -0.116045 -0.134461 -0.152785 -0.179286 -0.210188 -0.242132 -0.270805 -0.306329 -0.338685 -0.370282 -0.318104 0.145976 2.503725 10.547284 34.449078 201.642181 4890.822754 102970.375000 154261.375000 196108.656250 27657.894531 835.522217 95.722847 236.800629 571.483459 852.615845 -0.077886 -0.092998 -0.106864 -0.122837 -0.136984 -0.153813 -0.171585 -0.195133 -0.233345 -0.262990 -0.287295 -0.316100 -0.324193 -0.293955 -0.217956 0.127930 2.272314 15.859334 85.050056 278.223846 526.728455 3338.770996 74744.859375 106841.351562 103127.851563 8459.918945 400.299622 167.803986 338.214111 302.751709 151.857437 -0.101730 -0.126219 -0.139417 -0.155060 -0.175653 -0.198061 -0.222831 -0.252442 -0.283867 -0.307540 -0.333962 -0.319552 -0.145854 0.341745 1.226103 2.686406 9.334464 68.810638 598.779236 3404.905029 5196.296875 12908.416992 103564.203125 111200.132812 25389.953125 1757.860596 371.858917 2829.343018 15108.456055 8365.129883 745.491394 -0.142872 -0.159565 -0.176095 -0.195232 -0.220620 -0.245859 -0.274188 -0.308997 -0.337593 -0.364563 -0.354271 -0.131543 0.984287 4.691247 13.731604 22.940516 36.538105 188.533173 2331.702637 21318.923828 35353.746094 48478.125000 100657.515625 100422.179688 86474.445313 2012.737427 1293.906494 54328.031250 100156.351563 100042.000000 6285.564453 -0.182811 -0.201635 -0.224203 -0.245771 -0.271686 -0.301063 -0.337586 -0.373845 -0.404236 -0.423327 -0.303997 0.622657 6.301982 36.015285 149.646118 307.242340 280.852753 503.924225 3419.648682 21399.962891 32450.207031 20759.000000 100527.265625 100153.523438 25898.347656 1332.189819 1910.252808 96918.195313 100448.312500 100094.742188 9208.781250 -0.235646 -0.259159 -0.276297 -0.294643 -0.323447 -0.363989 -0.403786 -0.443827 -0.472105 -0.469673 -0.148785 2.498495 25.432634 247.647064 1913.175171 5892.447754 3757.708008 3341.477539 34940.136719 80367.484375 18688.878906 3449.868896 7401.555664 8642.189453 2181.306885 522.270569 989.980408 8573.249023 68260.453125 28164.830078 1675.693359 -0.294521 -0.317829 -0.329440 -0.337835 -0.350769 -0.379344 -0.431582 -0.483726 -0.524370 -0.509666 0.023729 5.061913 63.190994 976.493774 16856.054688 99474.375000 44109.394531 13766.957031 100290.164063 100246.687500 96127.906250 2867.673340 414.242187 334.543640 215.073608 165.185257 283.427643 643.931641 1109.299927 679.906738 182.837585 -0.352854 -0.370942 -0.358205 -0.287711 -0.162812 -0.034844 -0.069200 -0.242674 -0.457086 -0.525961 0.035563 5.927709 80.014389 1309.588257 26899.125000 100018.554688 89747.203125 11974.184570 100271.500000 100037.898438 51239.117188 1952.450195 123.768639 65.817551 115.705704 149.559875 113.424118 92.229874 77.669594 72.987335 552.592346 -0.397608 -0.391692 -0.251013 0.238678 1.392586 2.873950 3.246239 1.930735 0.502032 -0.242424 -0.050506 3.906848 42.101601 516.110046 5878.076172 24468.636719 14135.715820 2617.417725 7938.627441 14608.662109 3968.913574 394.781677 58.927074 127.138115 483.029907 686.739929 328.584503 81.368721 29.350510 99.948090 3032.832764 -0.349939 -0.170650 0.482104 3.070482 10.855217 23.524900 27.003838 16.690620 6.429758 1.726937 0.366943 1.846171 13.826120 97.005600 516.851562 1218.278442 860.832092 296.575806 371.109711 482.885925 229.440521 56.489761 41.436958 230.333435 1055.090698 1661.671143 701.639221 144.961624 43.365185 108.380775 3622.502686 0.447773 1.543665 4.262755 14.098516 55.308411 143.078354 181.841614 106.982155 43.701824 14.680304 3.611758 1.673675 4.267134 14.729949 44.495396 73.677376 60.025818 32.675259 28.313887 29.221083 17.868437 9.662628 26.567736 166.382507 685.391052 1076.273193 531.639038 209.729279 92.242928 62.529243 738.169861 8.785892 17.804449 29.729858 60.952515 181.663757 576.359009 867.542786 795.957153 466.417664 135.852463 23.838030 4.734854 3.241574 5.469413 9.646878 12.755888 12.121986 12.950466 16.894926 16.082085 8.795740 4.599839 11.158697 53.156536 173.540634 258.183716 283.761383 300.378937 153.454437 44.814835 75.798393 140.639679 312.920898 360.370392 497.314484 584.261536 1183.272339 4867.989258 19621.845703 12234.153320 1547.662476 134.785477 15.985099 5.840743 8.348548 15.345516 22.374172 34.908020 112.241066 279.864380 278.216278 99.560387 22.055605 6.641323 14.592903 40.039181 89.788170 189.344025 231.173630 129.614975 36.321053 15.870051 3979.988037 15303.158203 7656.441406 7723.071777 5141.312988 3569.221191 58059.179688 100481.289063 100112.406250 12214.410156 475.600128 40.769108 14.251430 23.328909 49.033211 77.124344 227.277557 2109.296875 12177.879883 12170.419922 2087.484375 187.834900 20.295286 17.796091 42.603832 101.014694 208.787704 224.713867 123.276855 62.800850 46.618160 100046.007813 100636.648438 110193.281250 67135.320313 42809.839844 51891.679688 163162.984375 107901.718750 100601.570313 21391.410156 705.591187 75.457359 36.216434 58.060253 123.716507 212.492462 1345.267334 51326.699219 100081.656250 100029.054688 51219.386719 1223.471069 63.091484 42.816784 93.649200 155.480789 271.305450 331.438843 388.300293 543.504761 672.470642 100044.210938 100638.015625 109361.640625 71102.460938 112017.398437 103925.250000 114887.914062 200235.890625 65857.757813 4825.907715 489.522858 104.171150 78.642212 104.341629 160.748840 312.138611 3431.579834 100612.179688 100450.562500 100128.585938 100020.750000 3108.734863 105.280281 56.867867 115.825066 140.635010 250.406387 1149.513794 5565.901855 10930.891602 19120.246094 25272.669922 100205.906250 44982.960938 9616.100586 104398.757813 100928.117188 101398.648438 103756.195313 7129.902832 988.669006 281.548920 90.871826 89.389595 108.515450 109.113594 249.476776 2420.726318 101666.445313 101224.187500 100278.593750 100038.804688 1791.901855 76.183212 31.547255 59.394180 83.166199 443.446259 8658.253906 101844.273438 156784.625000 117603.437500 732.502747 1846.901001 1134.342163 1241.574463 23604.148438 100234.328125 101152.523438 55053.804688 3795.213135 551.365479 119.122940 43.695488 45.683968 50.193069 47.645447 130.425186 830.781494 6315.163574 42762.957031 42081.550781 5122.175781 321.929230 26.604462 9.267927 15.526837 46.373608 609.527893 17675.087891 102474.789063 195894.687500 146425.718750 320.258698 88.272102 66.929924 163.260788 1176.381226 6679.441895 8464.416992 3700.907715 1373.715698 253.484238 42.537029 13.645288 13.646716 15.638333 17.120729 45.284309 181.245148 526.704529 909.029419 754.253723 241.766586 40.276409 5.511407 1.412510 3.539916 24.126375 303.873016 5595.898437 63696.812500 109336.828125 98401.117188 1397.932739 81.907280 17.213306 28.856565 92.511185 228.557632 348.337677 375.028564 217.787369 63.065491 13.607060 8.086400 15.360737 23.880621 24.703712 28.803139 45.284676 66.586624 68.844810 46.172836 18.353952 4.526902 0.335011 -0.430908 0.382177 7.311225 67.460518 569.229797 2607.396729 4079.798584 7667.562500 3157.549805 165.459824 35.074444 19.143967 24.829481 35.892319 49.343060 49.538967 32.711052 13.946040 8.716884 19.608595 59.648266 114.224312 118.899864 156.356964 197.310318 113.264580 35.223259 9.393639 2.283992 0.015941 -0.687263 -0.810478 -0.544756 1.274055 10.625058 52.688377 168.520523 662.720764 4576.729004 5459.677246 1260.163574 404.606506 74.697830 21.905787 19.487230 18.147654 13.200088 9.259923 9.218260 14.113216 41.086689 150.312729 329.229675 473.029999 1485.305176 2454.794678 980.684814 166.104980 20.347563 2.691915 0.015194 -0.613634 -0.765987 -0.637441 -0.014467 1.976517 7.935412 30.620684 174.959229 1033.397827 97044.156250 80463.664063 13510.804688 699.580322 87.458664 83.172318 61.150116 20.824276 8.798780 11.361922 17.546862 45.660419 164.082367 396.105927 1137.174683 7875.439941 17576.296875 5098.198730 520.053833 50.584396 10.664962 3.984116 0.816746 -0.187161 0.318140 2.982458 8.856724 14.930358 17.076153 38.576168 147.806961 200084.765625 102986.781250 100291.093750 4231.816406 403.818024 596.794250 362.827332 84.317207 14.596953 9.140128 12.648119 25.611950 79.652344 218.897217 1153.457886 10219.689453 21230.312500 6078.062500 640.878845 114.293968 74.750008 34.364758 9.188354 2.346581 6.421163 37.987148 144.679382 277.572021 188.326950 59.891041 32.163261 142309.578125 104342.179688 107301.945312 8137.430664 1947.982544 2177.333740 1063.124878 185.832794 21.970745 6.170811 6.667780 11.735460 28.813080 85.037506 434.763214 2204.759277 3872.230225 1688.720703 508.574219 683.915283 737.636902 278.124695 51.360313 10.571858 39.167515 446.738037 3965.444336 13321.183594 6029.203125 786.418945 72.154007 70229.210938 200245.703125 127403.351562 105391.562500 23967.732422 13093.626953 2169.089844 227.373474 26.984375 9.972853 13.021838 21.172235 47.912174 178.449738 642.221130 1135.271484 1160.402466 957.931824 1155.071655 4739.962891 5545.768555 1420.585815 165.332306 26.870474 168.578217 4313.819824 100013.695313 100013.796875 100007.179688 10170.563477 340.399811 26748.802734 101849.101563 101717.460938 119620.687500 121427.859375 86755.671875 5686.987793 324.026276 46.541241 59.232758 98.463081 115.888206 221.743179 1395.911621 11175.075195 19444.333984 5168.628906 1185.067383 1707.859253 8575.357422 11126.200195 2442.845459 229.047943 39.384708 340.199310 16102.847656 100261.117188 100261.921875 100108.312500 51236.433594 735.372681 16066.681641 100160.804688 100959.453125 111632.867187 91263.312500 47015.148438 3942.236572 311.511963 147.010147 516.292603 1025.878906 728.924561 654.670654 5748.182129 100080.781250 100108.070313 34539.332031 1831.455322 777.105225 2901.591309 3374.039795 979.035400 130.316345 42.280704 406.066864 10455.769531 111130.601562 111139.015625 102108.351563 23497.361328 503.311554 1943.924927 31181.652344 100372.687500 27458.482422 7436.122070 5295.023926 1736.648437 371.923401 682.197144 5764.763184 15247.483398 5760.734863 1189.585815 5798.490234 100206.648438 100619.984375 32020.113281 1905.818848 365.712860 416.894653 411.777161 159.501648 37.232712 63.050488 1209.385864 47283.925781 114684.421875 169942.578125 77054.117188 3394.265381 241.627182 149.808655 755.505554 1411.749146 973.367249 1045.066406 2142.468018 1453.554565 435.741425 4113.754883 103980.203125 111132.914062 105138.554688 3585.233398 1349.822266 9694.972656 23980.109375 21968.933594 6234.415039 1411.673340 432.730988 125.005653 33.852398 13.558231 93.703644 2895.402832 100210.289063 100937.570313 102069.562500 102424.703125 4894.894531 471.906433 13.744143 39.960197 67.939751 95.056557 241.123657 525.375366 425.628632 329.643219 12592.160156 101428.984375 103371.781250 101798.804688 7929.354980 510.680634 4780.988770 71056.289063 115145.382812 122707.843750 38950.746094 2717.369629 259.951965 34.856602 10.946204 70.603462 1690.394409 100287.578125 101543.750000 104231.812500 109466.835937 9260.124023 1415.031006 1.139880 3.324617 6.682657 13.916446 37.191704 67.913261 63.102734 141.038223 4014.893799 100203.242188 100365.007813 100231.007813 2852.215576 304.160004 3253.306152 50396.683594 200127.593750 117973.765625 101795.695313 18655.212891 488.770203 57.474796 19.007898 31.929197 350.487610 4920.250000 39179.808594 45806.753906 16080.375000 9038.127930 1474.187744 -0.279852 -0.051489 0.454135 1.642098 4.096535 7.187231 8.701806 30.360737 350.079102 3639.347168 10163.638672 3051.419189 290.883820 99.556480 762.460632 8452.967773 106954.250000 104460.507813 105166.132813 24190.765625 825.863831 154.197647 63.528221 25.974127 58.935192 320.759888 1207.505737 2356.889160 3315.506592 2122.742920 502.165863 -0.389047 -0.403831 -0.372086 -0.238137 0.048233 0.355695 0.946263 4.428498 25.909294 104.231102 168.253922 91.701180 25.623068 23.275623 140.295792 1359.484131 31652.933594 200228.828125 170841.093750 103816.453125 4649.643555 612.410828 167.851913 40.784775 19.514982 81.643394 556.583984 2597.882812 3382.960693 951.328369 174.968414 -0.337907 -0.372909 -0.405241 -0.419071 -0.410650 -0.383508 -0.287390 0.148198 1.704978 4.867902 6.951458 4.593532 2.228371 5.800467 42.942184 596.193848 26346.462891 102015.437500 101979.679688 104457.992188 25027.607422 2084.490234 296.757751 47.328693 14.448067 55.648682 405.818634 2100.114746 2497.137207 725.709778 146.344421 -0.280148 -0.314470 -0.351377 -0.377074 -0.402113 -0.414967 -0.425597 -0.402267 -0.298550 -0.132502 -0.074945 -0.213671 -0.186297 1.828882 24.521151 459.136475 21234.371094 100211.726563 101523.132813 108241.335937 28127.457031 3335.720215 363.587646 41.824249 18.462620 80.948723 310.346802 619.784973 624.269043 350.385803 167.472824 -0.216762 -0.247846 -0.278587 -0.308754 -0.337174 -0.359054 -0.376571 -0.402401 -0.428410 -0.458217 -0.494292 -0.538527 -0.483877 0.469652 10.252337 138.546814 2659.233154 51318.929688 100722.492188 49518.343750 6469.416016 1443.442749 194.049103 28.934998 38.303577 290.329773 1346.301270 1618.078613 910.709900 744.501282 384.131866 -0.169462 -0.189688 -0.211042 -0.235397 -0.267497 -0.290089 -0.311536 -0.337981 -0.361972 -0.400490 -0.448887 -0.499829 -0.499649 -0.172676 2.709514 26.410782 206.222549 1091.464722 2269.505371 1489.987671 793.458252 278.343597 62.215523 18.178476 59.022324 471.213409 2472.743652 3499.362305 5435.425781 7979.736328 4401.798340 -0.130070 -0.145312 -0.161357 -0.180406 -0.202243 -0.221395 -0.244641 -0.268846 -0.294256 -0.327469 -0.373475 -0.422472 -0.464617 -0.407704 0.190516 3.729818 18.732719 61.397995 120.712814 166.719772 141.209427 64.070778 18.711103 13.000703 54.948601 263.019470 1015.660767 3631.607422 31028.919922 119485.929687 103439.015625 -0.101820 -0.108993 -0.118892 -0.134801 -0.151710 -0.169541 -0.185029 -0.206760 -0.230015 -0.259392 -0.295310 -0.343170 -0.398292 -0.433414 -0.367283 0.134032 2.031688 7.233074 18.604166 32.650818 32.775452 16.320362 5.898790 8.151784 34.097397 104.752434 357.296021 3583.606689 107988.828125 110295.054687 102307.890625 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001990 -0.002317 -0.002644 -0.002958 -0.003242 -0.003456 -0.004645 -0.004863 -0.004967 -0.006799 -0.006779 -0.006663 -0.006391 -0.006012 -0.005558 -0.005060 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002553 -0.003000 -0.003456 -0.003905 -0.005359 -0.005878 -0.009560 -0.010188 -0.010614 -0.010809 -0.012260 -0.012028 -0.011595 -0.009586 -0.008876 -0.006743 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002222 -0.002719 -0.003265 -0.003877 -0.004516 -0.007722 -0.008728 -0.011688 -0.015700 -0.016856 -0.017702 -0.018192 -0.018216 -0.017871 -0.017143 -0.014784 -0.013617 -0.012306 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002192 -0.002738 -0.003383 -0.004137 -0.004971 -0.008643 -0.011603 -0.016873 -0.020798 -0.022940 -0.024771 -0.026114 -0.026779 -0.028052 -0.029064 -0.028122 -0.026641 -0.024736 -0.022746 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002060 -0.002644 -0.003336 -0.004198 -0.005199 -0.010670 -0.012848 -0.020788 -0.024372 -0.027812 -0.030961 -0.033767 -0.038016 -0.040944 -0.043040 -0.041853 -0.041932 -0.041070 -0.038628 -0.035557 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001870 -0.002432 -0.003130 -0.004019 -0.005084 -0.010877 -0.016608 -0.022438 -0.028051 -0.034254 -0.039446 -0.045604 -0.051656 -0.055493 -0.061140 -0.062815 -0.064095 -0.062745 -0.060592 -0.058622 -0.053349 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002796 -0.003660 -0.004755 -0.010486 -0.016609 -0.023897 -0.030789 -0.037595 -0.047516 -0.055456 -0.064447 -0.074826 -0.081752 -0.088153 -0.093009 -0.095607 -0.096226 -0.092750 -0.086070 -0.079343 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001807 -0.002398 -0.003174 -0.004168 -0.008651 -0.014339 -0.022614 -0.032382 -0.040571 -0.051076 -0.061595 -0.075344 -0.088529 -0.100513 -0.114126 -0.124922 -0.132469 -0.134033 -0.132513 -0.128578 -0.122508 -0.113608 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001976 -0.002644 -0.003531 -0.006264 -0.013911 -0.021069 -0.031016 -0.039859 -0.051761 -0.064448 -0.081146 -0.098311 -0.116371 -0.134840 -0.152130 -0.163632 -0.169998 -0.172185 -0.171159 -0.168230 -0.162296 -0.155700 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002856 -0.005270 -0.011163 -0.020255 -0.026712 -0.037083 -0.048338 -0.065190 -0.084455 -0.106562 -0.129012 -0.153416 -0.176311 -0.191707 -0.204339 -0.205781 -0.193784 -0.182801 -0.191134 -0.204526 -0.207291 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001772 -0.004084 -0.004915 -0.007683 -0.018237 -0.025266 -0.034591 -0.045658 -0.062801 -0.083334 -0.108356 -0.135127 -0.163994 -0.195115 -0.217869 -0.231211 -0.204803 -0.073484 0.167170 0.327903 0.184607 -0.060024 -0.207343 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001760 -0.001983 -0.002189 -0.002351 -0.004756 -0.008764 -0.015969 -0.025900 -0.033037 -0.045778 -0.061441 -0.080736 -0.103804 -0.134324 -0.168334 -0.205491 -0.234801 -0.259952 -0.221877 0.121445 1.494329 4.531630 6.871002 5.089922 1.786911 0.195931 0.000000 0.000000 0.000000 -0.001688 -0.001983 -0.002285 -0.002598 -0.004551 -0.005003 -0.007687 -0.013073 -0.025545 -0.033928 -0.043896 -0.058385 -0.078051 -0.101743 -0.134869 -0.171891 -0.209599 -0.251243 -0.283504 -0.283713 0.008165 2.096185 14.266837 56.232304 102.120796 63.957638 16.990673 2.809778 -0.001008 -0.001081 -0.002900 -0.003280 -0.003677 -0.007127 -0.007905 -0.010394 -0.012031 -0.016901 -0.026857 -0.034695 -0.047503 -0.059114 -0.074882 -0.096202 -0.126514 -0.166489 -0.213949 -0.261637 -0.302120 -0.315429 -0.211805 0.825823 9.791698 90.289284 627.894165 1522.941406 793.694092 117.608932 13.259820 -0.001404 -0.003269 -0.003763 -0.005733 -0.008166 -0.011073 -0.012418 -0.015731 -0.020909 -0.029085 -0.033660 -0.047673 -0.060546 -0.073197 -0.094082 -0.119632 -0.156407 -0.206320 -0.255243 -0.307415 -0.324417 -0.279730 0.052836 2.263682 24.124777 322.931305 3971.183350 15088.023438 5216.982422 431.589905 36.020195 -0.003642 -0.005734 -0.008027 -0.012408 -0.014135 -0.017686 -0.021843 -0.023025 -0.029307 -0.041723 -0.051122 -0.061671 -0.074454 -0.090386 -0.113348 -0.148390 -0.194785 -0.246725 -0.294871 -0.337337 -0.321632 -0.073962 0.844615 4.233628 29.437815 339.278839 4389.356934 16744.396484 5751.640137 486.239227 86.796043 -0.007685 -0.010334 -0.015120 -0.017287 -0.021440 -0.026252 -0.031425 -0.037038 -0.043223 -0.057220 -0.065858 -0.077633 -0.094925 -0.116771 -0.143723 -0.183478 -0.235942 -0.288330 -0.333644 -0.349852 -0.106866 1.099783 4.846566 13.106147 32.164822 152.316544 916.002747 2102.122803 1020.010193 274.564301 630.029541 -0.011767 -0.015291 -0.019528 -0.024176 -0.029746 -0.035825 -0.042497 -0.051496 -0.060796 -0.073525 -0.088752 -0.101599 -0.126265 -0.148476 -0.183368 -0.230479 -0.286097 -0.329235 -0.362152 -0.197414 1.183526 9.733478 51.509590 176.019089 211.344772 140.673325 196.298141 283.095245 277.551453 932.513672 12881.425781 -0.020368 -0.026993 -0.030707 -0.038646 -0.044304 -0.052729 -0.061624 -0.070271 -0.084879 -0.099928 -0.119822 -0.139659 -0.166215 -0.192151 -0.232021 -0.279807 -0.332410 -0.374549 -0.334052 0.398534 6.896514 71.193245 892.268860 8404.945312 12390.268555 2177.282715 212.046204 203.588135 1171.431152 6927.999512 102854.812500 -0.031904 -0.036872 -0.044899 -0.055011 -0.063673 -0.073275 -0.087618 -0.098883 -0.114642 -0.134352 -0.154495 -0.182658 -0.214142 -0.248011 -0.289594 -0.334614 -0.384806 -0.391496 -0.180522 1.910538 22.497334 359.886322 15393.498047 100685.312500 100484.578125 67909.937500 1072.446533 566.263489 10237.962891 74956.437500 130277.460937 -0.046119 -0.053151 -0.068092 -0.078536 -0.088542 -0.102621 -0.115139 -0.130593 -0.154799 -0.180532 -0.203981 -0.235607 -0.268466 -0.309211 -0.348150 -0.384389 -0.390019 -0.274954 0.351148 4.563062 47.111828 817.181396 56301.625000 107167.000000 103971.710938 100640.453125 2237.347168 798.104248 18100.683594 101256.148438 101135.132813 -0.067839 -0.082242 -0.096462 -0.109390 -0.120463 -0.137610 -0.154734 -0.174160 -0.202746 -0.228990 -0.258911 -0.285310 -0.315152 -0.348467 -0.387774 -0.398271 -0.250684 0.445445 2.745498 10.481339 65.342361 790.375366 16205.750000 123342.078125 111145.023437 44589.910156 916.035828 307.759552 3434.874756 16497.384766 9689.737305 -0.091711 -0.112111 -0.124892 -0.139825 -0.159172 -0.179647 -0.200937 -0.226866 -0.252890 -0.280123 -0.307334 -0.330345 -0.352955 -0.364502 -0.363012 -0.254273 0.413787 3.599386 14.820610 39.800495 100.310822 537.611816 3886.068604 13815.632813 11005.408203 1958.241455 191.635895 92.966690 330.129181 744.734863 559.377075 -0.122622 -0.139729 -0.158503 -0.176423 -0.197897 -0.223157 -0.250726 -0.280893 -0.311415 -0.332649 -0.352936 -0.359111 -0.316525 -0.158770 0.124596 0.595873 2.525293 13.135211 61.104012 189.733658 320.876678 1033.887329 4778.045410 6168.089844 1975.258667 357.517700 97.142769 311.454926 883.423950 621.891785 163.325287 -0.160479 -0.179543 -0.192521 -0.209216 -0.236408 -0.271453 -0.306244 -0.338938 -0.371760 -0.390180 -0.375663 -0.283489 0.097662 1.295935 3.574367 6.260841 10.139032 33.623913 156.793869 516.138794 772.054871 2209.179932 12264.777344 14689.446289 2936.110107 289.911469 187.115540 1821.299805 8361.091797 4762.684570 566.413269 -0.203176 -0.209374 -0.200484 -0.187913 -0.226237 -0.293711 -0.361733 -0.411776 -0.439758 -0.435108 -0.350477 0.045022 1.853025 8.945486 26.855677 49.091858 51.326080 93.050613 308.801361 685.724426 817.139893 1328.659912 5601.300293 6050.928711 1441.627563 200.479065 226.291977 2368.491699 12362.781250 6290.466309 710.829956 -0.252789 -0.223126 -0.134252 -0.043697 -0.075790 -0.240798 -0.392070 -0.481422 -0.506492 -0.477324 -0.274346 0.760819 6.631006 39.843193 168.319382 347.695160 301.273193 369.021362 1387.048828 2247.979004 1020.211487 422.471863 676.641357 746.900452 280.172699 78.672050 116.510292 620.528748 1986.147217 1301.511353 231.442078 -0.298550 -0.223401 -0.005752 0.198253 0.167814 -0.143988 -0.406624 -0.538117 -0.574527 -0.526071 -0.196516 1.701727 14.967306 109.111137 593.876831 1527.631226 1115.150757 930.234436 4354.634277 7842.504883 2484.385010 325.246185 98.910858 95.865990 98.281425 99.543602 75.209129 97.545952 160.805328 124.333122 111.709152 -0.344023 -0.244186 0.020411 0.280946 0.280541 -0.052143 -0.349433 -0.524659 -0.610944 -0.562428 -0.085108 2.397804 17.568676 132.430679 788.313904 2069.747803 1465.451782 834.458008 3148.771729 5100.972656 1664.505859 242.769043 65.470985 214.412384 853.711975 1323.374634 559.090515 113.550224 32.492180 59.604275 942.399109 -0.337684 -0.232731 -0.013241 0.254285 0.412583 0.396853 0.253896 -0.075345 -0.369378 -0.419467 0.302026 3.158466 15.056381 77.187881 348.113525 791.544739 575.352417 293.227264 575.496826 853.588562 375.865204 97.290428 130.741257 1331.798828 12175.520508 25643.115234 6047.345703 537.672974 66.247398 144.919846 6904.166016 -0.024385 0.308971 0.757530 1.357784 2.314372 3.459156 3.771297 2.641727 1.211417 0.450201 1.387994 6.021904 16.638687 36.234226 80.134506 130.810852 104.802383 59.749443 75.282379 91.148972 65.667114 47.556450 223.343781 3673.237061 62901.027344 100048.453125 23479.191406 1522.587891 241.244339 196.918503 8354.680664 1.736280 3.818563 6.850072 10.235791 13.312274 17.414112 19.777189 17.065897 10.995178 4.866491 3.596775 9.906618 24.955837 37.268421 40.440701 40.838730 28.923943 15.107391 11.890294 14.293006 17.782780 27.626945 161.692276 2275.819580 25669.265625 56973.550781 12860.591797 4503.299316 1535.871826 245.992935 1306.034546 13.909625 30.789455 61.418308 101.824951 97.702324 76.675201 91.280190 119.275528 89.098679 34.008186 9.912716 10.474602 24.352512 41.896034 66.630966 85.358543 57.902626 24.887154 16.404335 14.357888 10.768820 12.719629 54.108547 402.674652 2143.420166 3939.407471 7075.313965 16568.359375 4477.253418 421.885376 126.706779 194.952896 490.528503 980.586304 2204.321289 1642.062500 504.316559 537.923584 1178.720825 857.718384 217.150772 35.257614 11.760177 22.211815 59.009243 151.686844 226.798767 151.481598 115.963257 198.097092 190.486282 75.067810 19.976406 18.697208 70.713676 236.450882 799.069580 3959.954346 8369.663086 2671.540771 310.978973 43.719810 6333.999512 32147.390625 29465.564453 100848.437500 77888.132813 6072.685547 3167.360596 8123.098633 5598.266113 858.441467 95.713120 24.637863 53.057671 187.795044 657.658325 959.245056 587.366333 1363.080811 5596.957031 5558.063477 1226.664429 132.355942 40.982380 154.904526 466.152527 1449.852539 5558.482910 5844.252441 1524.789429 256.139832 100.940781 100131.125000 103976.304688 200057.000000 107244.195312 103939.382813 73327.281250 45614.210938 18308.160156 8289.815430 1194.852051 132.539185 93.881721 312.140137 759.124329 2988.712891 4834.407715 2701.197998 22299.191406 100658.453125 100180.601563 21213.626953 743.337708 126.236694 752.199829 2717.853027 3455.511230 10459.400391 9471.130859 2142.903076 998.086060 1492.524902 100131.515625 103660.429688 200062.640625 113423.734375 151475.531250 138123.484375 102351.968750 104747.601563 5431.902344 748.767273 130.623932 337.500031 1717.943726 2554.535889 4152.057617 6518.563477 7689.925781 117789.609375 110198.515625 101327.804688 100120.593750 1809.067505 196.880081 1302.785156 5302.749512 3765.495850 3286.563721 3250.996338 2716.071777 17594.474609 100651.484375 54108.957031 100853.406250 112060.703125 104081.687500 163015.781250 105231.328125 109565.867187 163502.515625 30351.908203 1940.978760 178.064148 515.007996 3060.873291 3865.357422 1846.353027 2630.024658 20971.980469 141963.031250 169793.468750 104698.359375 38139.332031 1080.788330 114.070580 467.441956 1425.778198 1069.339722 613.063049 1273.797729 9013.814453 104323.070313 101481.734375 1194.818115 2892.541016 2073.140137 2582.879639 17415.404297 101527.835938 145754.343750 134431.281250 101190.531250 5868.859863 221.555756 206.080963 869.066162 1057.397339 462.173584 962.051392 12491.567383 80155.679688 59424.316406 19383.193359 2854.476074 234.185242 34.012768 66.616768 139.813126 130.262375 183.367661 1182.241455 13598.727539 106183.859375 102398.093750 1127.161011 147.021576 111.578377 242.763596 1122.461792 5627.128906 22815.687500 101723.570313 51028.363281 2667.945312 136.091263 43.878227 98.464912 118.335815 79.681709 232.090378 1697.742310 5698.061523 4103.710937 1086.076660 228.347931 37.979424 7.294667 6.976222 13.065817 19.235374 74.092705 545.152222 4013.732178 80794.789063 116697.718750 2506.573975 128.880035 59.288017 196.718231 397.035889 735.964722 1991.514038 4302.704590 2374.695312 376.979156 45.276310 12.183460 12.332749 13.735030 14.981215 38.336018 136.765488 292.982697 238.426743 93.797974 26.138828 5.754635 0.710808 0.107316 0.765096 3.839187 22.557871 121.390686 656.591003 6903.685547 106743.531250 1839.553467 148.261642 75.832962 206.242722 345.593018 347.077087 490.978821 422.910889 195.170700 73.983109 39.681835 20.917208 11.666911 11.694397 15.073809 25.695379 35.487438 36.138977 23.758844 10.317721 3.035174 0.220048 -0.597173 -0.721457 -0.549223 0.371370 4.901322 28.040825 215.454224 4431.849609 100298.515625 1805.930786 984.143799 409.617432 143.475464 132.636429 109.440796 105.177757 85.767113 69.423744 103.373459 115.893318 61.873466 26.032562 23.668978 43.302143 93.704994 130.279388 75.252052 21.974524 4.744983 0.532298 -0.455183 -0.645016 -0.585384 -0.433568 -0.055587 1.335565 8.450989 71.651268 924.445007 12277.291992 28816.673828 70925.632813 12233.684570 651.022278 67.811920 31.236902 24.929516 27.518354 68.136826 178.091080 214.904556 104.049332 35.078003 32.340130 82.355247 249.219193 365.765839 201.203735 49.638802 9.044499 2.120217 0.495452 -0.030430 0.031434 0.678390 2.518591 6.291414 10.920636 22.098566 107.451653 558.086975 109360.445312 100619.515625 100199.195313 3825.204834 159.578812 49.080898 28.068495 19.793764 48.346455 120.861000 146.305710 72.713699 27.297777 26.331022 87.690445 284.243286 422.788696 219.750656 58.890656 18.524298 11.068546 5.683329 2.029156 1.521114 5.184400 24.681110 82.979218 145.265747 108.347939 46.110844 49.530327 103478.468750 102735.281250 105157.484375 6781.325195 584.257996 174.081360 70.128716 22.675711 19.985830 39.323669 47.284813 27.541952 14.060184 17.583113 50.326881 131.759216 186.379730 116.878212 57.141739 56.287575 55.611069 27.091913 8.405866 4.843572 25.468941 228.631180 1532.811523 3965.371094 2257.234375 364.849579 47.483936 60981.269531 200135.921875 124706.007812 97602.070313 4403.418457 753.575439 184.727036 35.164265 10.029181 10.453211 12.922601 10.992006 13.102371 35.603008 92.929382 137.687897 113.672516 77.979103 85.020744 162.151886 176.943298 77.976418 20.016081 10.930233 96.279045 1659.132690 34326.585938 100009.156250 62886.804688 3367.998535 176.370743 18622.271484 102060.632813 103039.804688 107259.593750 19505.826172 2149.627197 374.372040 53.618237 12.521422 14.227234 19.342646 20.208004 34.298771 144.248291 558.330444 802.938538 373.027924 116.035553 108.715439 237.455139 262.279022 106.347336 25.335861 17.124613 189.403961 4736.598145 100131.304688 100140.546875 100061.031250 12180.491211 366.272064 11220.551758 100750.953125 107922.898437 128723.812500 21659.812500 2410.503906 365.850861 56.711052 35.800251 91.282990 145.099091 102.751076 85.269775 380.377045 1941.538086 2883.475098 1087.341797 212.176498 114.048943 156.884171 149.728943 64.531197 17.803493 22.227209 225.717514 3610.917725 89275.414063 103160.328125 100822.671875 6142.577637 257.937134 1580.248413 21672.968750 74487.429688 32290.480469 8207.491211 1152.355347 198.960098 60.108318 203.545013 1395.883179 3217.064941 1224.846924 225.387909 398.995331 1821.196411 2735.438721 1150.773926 493.323883 622.709595 436.147919 143.076035 36.304428 11.186848 38.535992 539.980408 9920.333984 105273.703125 115513.078125 17790.601563 1462.595215 128.699341 138.413422 720.943542 1742.293701 2111.957520 1089.532837 295.374084 95.127922 92.333878 1443.260620 38915.750000 100261.671875 31396.082031 1084.472046 208.332047 575.919189 1139.136230 1528.606812 3767.147461 9091.720703 4804.794434 703.447205 75.265381 12.605504 58.320053 1149.575195 38989.027344 109529.070312 121641.125000 52667.359375 1840.312378 146.195023 15.449428 51.684666 114.547005 156.300629 112.824844 60.197132 37.748173 118.069336 3642.965332 100078.875000 100128.390625 100090.453125 2578.853027 147.047668 368.876587 1901.823730 12754.435547 76088.539063 81221.148438 27258.117188 2183.024414 145.562576 16.833529 53.086189 822.841797 19664.304688 169807.656250 200123.968750 53843.445313 2606.813477 215.256165 1.577608 5.116273 10.340446 13.939808 13.146841 10.976836 11.244306 64.954483 1407.462158 43284.804688 100032.164063 31249.685547 1107.462036 91.909637 333.594330 3910.032959 102133.406250 109196.148437 138109.015625 29855.814453 1975.380127 146.979568 17.748730 28.741419 320.317688 4401.742676 54826.425781 108636.570312 27541.130859 1715.124268 184.724976 -0.185642 0.155288 0.672881 1.137248 1.307339 1.359732 2.405322 16.941065 179.113632 1402.596924 3312.547363 1190.136108 148.283783 34.666992 181.404755 3718.485596 100798.828125 103054.375000 106659.054687 18375.851563 1055.917603 142.796432 26.937054 14.314813 82.473419 709.045166 4288.940918 8188.020996 2901.279785 476.703339 82.996849 -0.370773 -0.367242 -0.349961 -0.324640 -0.297566 -0.271643 0.027062 2.430137 16.017759 56.296638 89.439659 52.896301 14.461085 10.398024 69.782089 977.402100 20982.482422 156981.812500 146424.593750 50556.402344 4147.715820 593.796082 86.993301 14.940406 18.866776 88.412521 298.578217 474.323608 308.247406 110.148804 34.281513 -0.330171 -0.363987 -0.400148 -0.428031 -0.446550 -0.457365 -0.425730 -0.127587 0.932652 3.149734 4.597397 2.953149 1.213528 3.217249 30.502403 451.046967 15173.208984 101816.750000 104672.539063 123640.453125 32511.738281 3252.256592 269.479156 26.699261 12.561365 48.467365 141.865845 198.649323 145.904785 65.169762 26.557909 -0.265776 -0.303481 -0.334875 -0.365884 -0.390107 -0.412087 -0.428186 -0.422054 -0.355882 -0.249820 -0.199606 -0.309639 -0.307300 1.281614 19.464609 329.428833 12230.935547 100547.218750 108636.554687 177710.484375 79330.054688 6945.221680 408.272675 36.458130 47.427837 465.627777 2562.168457 3104.712402 783.213257 223.735245 84.492401 -0.203319 -0.228870 -0.260690 -0.288789 -0.316997 -0.341767 -0.360959 -0.381366 -0.407822 -0.435075 -0.476515 -0.515963 -0.468555 0.384648 8.766758 109.256302 1812.314087 25907.537109 89281.492188 42692.128906 19119.382813 2603.889404 226.624863 31.855753 180.950821 4344.292969 85468.695313 100649.273438 10034.352539 3982.744385 1047.439209 -0.153256 -0.172670 -0.192262 -0.212988 -0.240112 -0.266177 -0.284545 -0.309347 -0.337156 -0.370887 -0.415807 -0.462612 -0.464014 -0.177193 2.351860 21.547569 163.429901 797.345459 1825.596436 2033.135254 1399.101562 380.521271 61.827690 22.454681 277.284058 9220.708984 100398.812500 108565.734375 115290.585937 101016.937500 18206.423828 -0.113156 -0.130491 -0.142756 -0.156797 -0.175247 -0.199199 -0.216727 -0.239931 -0.264433 -0.294872 -0.337482 -0.383146 -0.423198 -0.369999 0.186305 3.233799 16.164503 50.223511 98.242729 129.169113 101.166374 43.354290 12.057115 10.915664 130.596222 2376.043213 28994.044922 73265.125000 105265.468750 110416.179687 110287.265625 -0.084824 -0.093816 -0.104969 -0.115884 -0.129783 -0.148281 -0.163143 -0.183827 -0.204390 -0.228241 -0.262686 -0.304430 -0.351901 -0.384962 -0.323389 0.091380 1.483397 4.633032 9.108593 12.564809 10.739361 5.630775 2.049278 3.500129 29.244970 230.880493 1461.765747 20664.597656 108070.585937 186242.156250 132540.093750 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001936 -0.002192 -0.002432 -0.002663 -0.002836 -0.002958 -0.004120 -0.004215 -0.004241 -0.004172 -0.004022 -0.003808 -0.003531 -0.003216 -0.001355 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002132 -0.002483 -0.002836 -0.003174 -0.003481 -0.004908 -0.005259 -0.005541 -0.007497 -0.007656 -0.007683 -0.007536 -0.007264 -0.006850 -0.006345 -0.005772 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002253 -0.002681 -0.003152 -0.003634 -0.005196 -0.005876 -0.007912 -0.010433 -0.012696 -0.013368 -0.015182 -0.013878 -0.013709 -0.013235 -0.012500 -0.010263 -0.009365 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002269 -0.002777 -0.003359 -0.003990 -0.005803 -0.008221 -0.010806 -0.015678 -0.017326 -0.018760 -0.021451 -0.022105 -0.022231 -0.020370 -0.022291 -0.021261 -0.021375 -0.019535 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002192 -0.002738 -0.003383 -0.004137 -0.006131 -0.010465 -0.013820 -0.019717 -0.022430 -0.024943 -0.027160 -0.031031 -0.033653 -0.033401 -0.034969 -0.036510 -0.035330 -0.033441 -0.029620 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002571 -0.003265 -0.004078 -0.007574 -0.010961 -0.016543 -0.022774 -0.026678 -0.030611 -0.036752 -0.040349 -0.044966 -0.050257 -0.051986 -0.053623 -0.052007 -0.050241 -0.049009 -0.046367 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002317 -0.002979 -0.003794 -0.007333 -0.010903 -0.018002 -0.023988 -0.030276 -0.037272 -0.044377 -0.051900 -0.060636 -0.066458 -0.073445 -0.077005 -0.078338 -0.079633 -0.077832 -0.074085 -0.067964 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.002607 -0.003383 -0.005824 -0.010228 -0.017650 -0.025287 -0.032930 -0.040036 -0.049331 -0.060640 -0.071759 -0.083222 -0.093513 -0.101493 -0.108687 -0.112961 -0.113037 -0.110682 -0.105917 -0.098866 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002192 -0.002876 -0.005175 -0.009206 -0.017643 -0.024166 -0.032557 -0.040801 -0.051690 -0.064115 -0.080183 -0.096305 -0.112176 -0.126004 -0.137251 -0.143892 -0.146265 -0.147953 -0.146360 -0.142527 -0.138099 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001585 -0.003447 -0.004049 -0.004819 -0.007461 -0.016185 -0.022457 -0.028971 -0.039310 -0.051220 -0.065781 -0.088971 -0.108108 -0.128153 -0.148412 -0.164178 -0.176082 -0.184293 -0.185481 -0.185413 -0.187065 -0.188734 -0.185643 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001810 -0.001983 -0.002143 -0.004110 -0.004784 -0.007106 -0.012040 -0.022167 -0.028269 -0.039703 -0.053279 -0.067156 -0.089256 -0.111835 -0.138769 -0.166881 -0.189542 -0.210632 -0.212129 -0.179308 -0.112550 -0.074416 -0.113467 -0.186450 -0.228728 0.000000 0.000000 0.000000 0.000000 -0.001849 -0.002128 -0.002402 -0.002655 -0.004528 -0.006779 -0.007629 -0.011512 -0.021118 -0.029832 -0.038709 -0.050643 -0.066929 -0.087567 -0.114275 -0.140862 -0.176760 -0.209990 -0.234355 -0.240394 -0.154009 0.176292 0.803976 1.302428 0.920937 0.241014 -0.155717 0.000000 0.000000 -0.001688 -0.002026 -0.002402 -0.004194 -0.006394 -0.007097 -0.009347 -0.011875 -0.015447 -0.022150 -0.031832 -0.041768 -0.049664 -0.066001 -0.084588 -0.110724 -0.143081 -0.182664 -0.224509 -0.253889 -0.277047 -0.216718 0.292222 2.461543 7.746001 11.777157 8.198668 2.933472 0.424133 -0.001112 -0.002920 -0.003373 -0.005330 -0.006026 -0.008593 -0.011373 -0.012569 -0.013593 -0.017134 -0.026048 -0.033541 -0.044553 -0.054595 -0.066731 -0.086157 -0.109122 -0.141995 -0.181213 -0.227363 -0.272381 -0.298005 -0.305219 -0.061858 1.713995 11.231359 40.811703 73.080177 46.276310 13.446115 2.443223 -0.003251 -0.005174 -0.006024 -0.008544 -0.011629 -0.013357 -0.015100 -0.016764 -0.022345 -0.028899 -0.038474 -0.047394 -0.058783 -0.069974 -0.084482 -0.107330 -0.135544 -0.176212 -0.223943 -0.269607 -0.310507 -0.336028 -0.294057 0.208430 3.848889 26.878368 118.118584 237.516022 144.986755 35.140484 7.573997 -0.007247 -0.009411 -0.012332 -0.015984 -0.018186 -0.020493 -0.024805 -0.031236 -0.036254 -0.041230 -0.053234 -0.061818 -0.075802 -0.086744 -0.106259 -0.132212 -0.172630 -0.217315 -0.262113 -0.307717 -0.336481 -0.293129 -0.057991 0.771110 4.837917 28.638947 129.373505 258.921448 149.394699 44.782051 34.856281 -0.010729 -0.013960 -0.018054 -0.020853 -0.023892 -0.031003 -0.037044 -0.043476 -0.050127 -0.061151 -0.073269 -0.082457 -0.097360 -0.112722 -0.134257 -0.164479 -0.211867 -0.258011 -0.302727 -0.333970 -0.236222 0.401127 2.489700 6.223665 9.751626 19.324074 55.688892 96.366928 79.211891 107.040459 425.172913 -0.014084 -0.020224 -0.023601 -0.027323 -0.036896 -0.042633 -0.049025 -0.060561 -0.069544 -0.083979 -0.095810 -0.109706 -0.127778 -0.144051 -0.172224 -0.208923 -0.259646 -0.299562 -0.340020 -0.264587 0.574286 6.112339 32.477699 103.635170 128.265427 60.558537 32.384838 64.959511 252.681885 1030.982666 8912.379883 -0.026021 -0.030386 -0.036830 -0.045325 -0.055050 -0.064111 -0.073118 -0.086102 -0.097970 -0.112872 -0.126821 -0.146972 -0.169071 -0.192622 -0.225129 -0.261689 -0.307472 -0.344827 -0.347205 0.038759 3.900677 42.980209 466.049744 3316.626221 4758.115723 1015.958557 126.888702 396.160431 5893.305664 35663.832031 116397.046875 -0.037904 -0.044276 -0.053564 -0.065272 -0.075888 -0.087597 -0.102489 -0.115512 -0.131706 -0.148364 -0.166514 -0.188814 -0.216960 -0.245341 -0.285046 -0.322947 -0.361641 -0.395548 -0.322964 0.667237 11.604068 188.005722 5746.941406 100054.750000 100043.851563 20506.779297 616.950134 2461.934570 100142.125000 103431.570313 200091.718750 -0.057736 -0.066739 -0.083349 -0.095097 -0.106043 -0.122371 -0.137264 -0.154294 -0.172705 -0.190641 -0.208820 -0.232593 -0.264596 -0.299647 -0.342917 -0.381326 -0.413448 -0.406472 -0.206144 1.503014 19.041697 347.286377 15194.365234 100228.921875 100165.906250 76089.726563 1116.386353 3773.541260 100136.500000 101137.359375 125781.445312 -0.079785 -0.095003 -0.113324 -0.126907 -0.143027 -0.163435 -0.183796 -0.201716 -0.218694 -0.235878 -0.259391 -0.283552 -0.312277 -0.347593 -0.389078 -0.420676 -0.418135 -0.280827 0.238467 2.455780 18.294872 204.337814 4165.386230 96420.335938 100301.640625 12425.745117 492.738739 1038.247559 33305.730469 100328.093750 101209.859375 -0.106871 -0.126899 -0.141488 -0.157491 -0.178698 -0.206775 -0.229781 -0.254447 -0.273373 -0.289818 -0.306822 -0.316328 -0.339959 -0.371863 -0.405096 -0.417441 -0.297705 0.260260 1.948504 5.684754 18.527834 86.171890 496.448059 2105.228760 2748.988037 691.841064 96.555267 141.567123 1051.445801 3237.835937 2207.512207 -0.138709 -0.157202 -0.171701 -0.189416 -0.213875 -0.248737 -0.280717 -0.307595 -0.329122 -0.329861 -0.302688 -0.265043 -0.253495 -0.260151 -0.259919 -0.206179 0.168650 1.708468 6.529101 15.690304 30.857397 87.015274 230.333344 305.485931 205.828659 74.343567 25.180422 43.691360 107.190796 163.616440 214.666962 -0.169733 -0.166316 -0.129431 -0.090327 -0.130811 -0.225639 -0.315259 -0.368172 -0.373062 -0.318863 -0.158630 0.070128 0.263185 0.413423 0.645555 1.017515 1.772603 4.867290 14.418988 30.229963 50.240768 119.942154 292.785004 334.371277 142.311020 37.112881 23.251385 77.648216 176.319290 170.015839 450.541718 -0.184738 -0.057032 0.270022 0.582281 0.549150 0.113886 -0.249729 -0.409638 -0.405838 -0.218476 0.262187 0.996147 1.733314 2.736480 4.560544 6.608331 7.800261 13.552311 29.553349 48.622864 57.003414 90.541840 195.265198 204.074753 91.958122 25.032366 23.553740 87.025055 197.424362 196.453110 546.891968 -0.141801 0.337187 1.671090 3.297472 3.060269 1.349409 0.056035 -0.404116 -0.428202 -0.102777 0.856659 2.518535 4.681246 8.845974 18.257477 26.454926 27.095621 36.504871 77.501328 107.551872 71.433350 48.180824 59.973995 61.886562 39.318798 23.420813 20.795624 43.950413 83.381821 88.074173 228.739380 -0.065770 1.016966 4.206537 8.647017 8.093573 3.593290 0.604906 -0.366201 -0.467249 -0.046408 1.273757 3.944298 8.590645 19.820042 44.359150 66.461182 61.351391 66.104393 143.711288 195.141357 112.159492 43.311234 33.753407 70.413521 175.907608 233.011169 124.907051 40.842529 22.600595 27.014742 91.081360 -0.018389 1.382625 5.407726 11.050175 10.334711 4.604830 0.782475 -0.382512 -0.536544 -0.065409 1.694680 6.133265 15.520083 33.123478 63.933613 90.036201 72.587746 62.925186 123.402054 174.992020 131.155060 83.335075 123.353638 779.785156 4709.390137 8531.825195 2650.312744 303.723938 37.071476 35.921970 388.757263 0.212989 1.311323 3.900812 6.866800 6.663158 2.938720 0.461574 -0.397352 -0.462023 0.288489 4.103368 17.354206 44.988918 69.782753 72.201653 67.557823 46.121292 34.179039 57.495049 126.260269 244.778412 260.679077 529.501526 9503.163086 100110.187500 100045.414063 86191.453125 2525.855957 167.491211 92.450150 1975.592041 2.012391 3.802585 5.057693 5.275611 4.226274 2.265960 0.798864 0.167474 0.158890 1.699066 11.013290 59.531353 181.886581 260.283752 160.698563 72.704239 34.659821 17.980659 30.161043 130.382889 389.327820 448.674530 1086.767212 42258.449219 100221.703125 100246.078125 101264.335938 10441.085937 1289.630127 230.693008 2156.806641 10.696608 18.670795 23.494303 26.219687 21.718267 11.685283 5.498841 3.473303 2.805144 4.180231 20.743206 122.138153 453.583160 666.280090 419.713287 280.607666 146.359634 40.425743 20.282970 72.779083 204.232315 259.953430 734.996094 17871.048828 100242.015625 101932.265625 145622.359375 104327.914063 30073.349609 1299.437744 559.898560 37.173038 80.499840 148.874039 269.393829 240.254456 97.795753 31.616816 19.790056 14.376476 9.691726 21.191374 110.444839 407.328491 684.820679 1070.501221 1973.094238 1019.307312 172.119598 28.901947 25.165773 47.144611 68.899254 198.361954 1762.289429 17814.490234 40799.589844 108152.742187 100974.867188 100178.546875 3749.513672 174.905838 143.280869 407.134521 1526.209595 4516.212891 3750.905029 907.932312 160.655304 92.230347 64.232414 28.637678 18.170755 51.351643 174.293030 504.926849 2527.373535 6912.111328 2891.156982 408.836670 99.876900 65.043236 34.372406 22.078568 50.705044 224.126572 888.974976 6071.521484 110497.265625 110241.234375 80712.585938 2246.941895 122.272728 1632.936401 5785.850586 37241.972656 105555.773438 105883.476563 9809.442383 783.673767 341.169067 206.501297 70.741943 26.078978 61.549164 249.857178 1438.371338 9750.904297 18908.488281 5441.738770 975.697205 902.054932 781.350098 257.493378 55.632717 131.347397 1244.973999 5593.939941 24415.826172 104446.093750 110170.226562 22591.177734 1312.579712 271.387177 22921.707031 106113.265625 139419.562500 105013.945313 104469.515625 90070.296875 5066.017578 1460.240234 454.182007 127.083473 71.168831 560.608704 3614.100342 11161.342773 100999.601563 100649.093750 48080.953125 8308.411133 12784.786133 9931.303711 1876.398315 209.811859 648.079102 20543.050781 101142.023438 131706.921875 103231.289063 100852.976563 44720.054688 6265.453613 2574.615967 48507.449219 106060.507813 196161.890625 103266.562500 104915.921875 119710.140625 59839.683594 14282.015625 4610.723145 621.472900 248.994400 5234.838867 100342.257813 109317.484375 110231.453125 101929.484375 111983.843750 106966.132812 138067.171875 46571.589844 5154.062500 409.889832 1127.155273 54073.292969 100514.984375 110184.375000 106436.750000 102495.265625 38222.031250 72725.234375 63493.425781 6381.546387 32461.957031 38407.675781 101096.078125 107325.867187 94849.273438 179341.546875 112292.265625 100690.664063 8422.089844 508.881958 10156.256836 100146.632813 102266.460938 46286.582031 57269.644531 110425.218750 103365.750000 116235.382812 73130.679688 3814.813965 337.596222 426.800507 8359.169922 67874.500000 28809.449219 4951.581543 6214.598633 50766.578125 200223.656250 119431.468750 795.517639 960.620605 1310.476196 2966.802002 4321.983887 20042.748047 119044.812500 104289.164063 100499.304688 36928.910156 624.242920 2351.209717 31258.730469 43498.691406 5147.319336 5709.760742 100672.906250 100586.054688 101695.773438 32969.187500 1359.703003 154.526215 74.834557 430.219727 1301.010376 857.327637 391.642700 1324.188232 13113.050781 116399.968750 105915.992188 4107.224609 188.407227 217.525223 904.303467 2121.245117 8272.940430 118613.500000 109659.320312 101201.609375 13539.115234 338.806183 209.211121 864.914612 1033.334106 379.306824 789.922424 11176.977539 69844.804688 34480.402344 3300.590088 296.251648 45.908314 13.106706 24.029846 47.954449 45.015999 56.938168 270.588959 2181.586670 37897.609375 177897.968750 11192.697266 254.520615 601.745239 6341.469238 15854.833008 13833.575195 55584.769531 45373.921875 13207.607422 1172.426147 121.086578 40.758244 43.198387 42.932789 31.938795 83.609428 423.757935 1062.417725 803.885559 222.558517 45.586609 9.566477 2.001048 1.481167 2.554384 3.996704 12.088185 62.606941 557.845215 15990.044922 104372.046875 3601.518311 187.957657 753.489563 9231.145508 23127.289063 8022.180176 13770.755859 7544.613281 1328.937256 445.571106 367.016357 160.065430 37.481525 8.965662 5.526402 10.872849 27.513607 45.943401 38.940739 18.178186 5.481081 1.165253 -0.004484 -0.019111 0.125411 0.428225 2.992607 23.431156 323.706421 13402.759766 100182.945313 664.754456 304.987518 343.110535 1692.105469 3114.322998 1381.973267 1184.040039 782.465820 652.223206 2135.215820 2877.055908 912.490784 130.172028 17.471193 6.206861 8.526843 10.821424 8.911651 4.842187 1.764499 0.265979 -0.050586 0.474042 1.476078 1.802630 1.369731 1.532864 9.183373 109.656273 2096.277100 46327.335938 2934.026855 5349.192871 1643.992065 317.544861 210.017868 137.493896 107.516251 161.144302 1011.465027 6043.908203 8529.141602 2263.597412 233.644684 28.381142 10.429557 15.613261 18.426901 12.395392 4.354366 0.891770 0.057029 0.526581 2.381683 5.582186 7.185380 5.779428 4.584109 6.394523 25.072660 179.516144 1072.069702 30285.021484 88422.687500 14876.146484 787.628845 76.921593 25.404068 21.041748 78.400940 640.457458 3373.205078 4318.502441 1332.914185 178.581985 26.027163 11.564177 17.014938 20.003618 13.582187 5.288292 2.003118 1.261818 1.777715 4.816508 11.302736 15.547768 16.941431 27.651632 39.608585 32.266769 27.551962 56.329353 41296.851563 100595.687500 19047.820313 1429.108276 266.976959 64.003990 19.781067 28.980030 148.120041 519.955627 650.664856 285.519775 69.545456 18.257931 9.751285 12.067306 13.286875 9.645228 5.890652 4.972046 4.539970 3.814629 5.890206 12.409365 22.460199 60.954330 231.604187 447.532318 278.285950 79.723358 17.762667 5255.463867 16057.682617 21925.453125 10636.809570 2956.759521 452.817657 61.421543 15.113618 25.717766 59.552284 78.803513 55.984200 27.899679 14.211209 13.366656 15.697499 12.755143 9.022289 8.405073 10.599025 10.806391 6.790615 4.989828 9.542311 34.160366 250.637482 1659.718628 4310.943359 2444.491699 390.009796 43.590374 2502.658936 40480.785156 146599.640625 131243.562500 79497.320313 3814.561035 219.226242 21.124460 9.275972 16.247665 23.618895 22.013889 15.897471 19.183840 36.444454 45.701656 30.929092 17.536924 16.903196 18.464142 15.955978 8.556696 3.914014 7.713825 51.052563 498.753693 4719.742676 16042.842773 7180.375488 851.717285 74.973686 1781.181396 27849.542969 177589.421875 119354.125000 101485.328125 14730.601563 417.165985 28.967312 12.286857 26.206097 37.375637 28.677563 18.135170 31.486267 76.126801 100.164230 73.831642 84.828888 129.610519 97.479210 39.108631 11.493302 3.808693 9.019286 63.888069 492.501373 3297.829346 8283.672852 4171.297363 638.398071 66.392502 507.296448 6248.804687 105122.250000 102115.250000 100345.171875 7863.356934 293.029388 26.852171 40.779125 166.121964 290.114624 148.848862 42.569614 33.865635 77.037071 119.925896 253.704544 1351.009888 3383.488037 2095.041748 393.642792 47.916183 7.491951 16.690733 147.259109 1191.051392 5785.151367 8523.453125 3153.075928 484.220367 59.487598 100.102440 804.408752 6834.856934 23455.916016 9356.741211 1068.484863 90.914780 25.917130 170.704758 1196.437134 2786.177734 1105.409302 143.440109 30.993504 53.517998 175.725037 1804.774170 38098.535156 100144.320313 95873.507813 4690.185059 230.082443 18.707142 32.208729 385.724335 7085.561035 108573.343750 108612.734375 64603.640625 2635.066895 136.833252 15.968163 79.452080 297.499786 565.187561 370.929962 92.311172 19.070108 26.789503 318.999268 3032.246582 8354.435547 2545.713135 258.965485 30.842045 53.878315 390.441376 7266.449707 103770.375000 102095.804688 100338.703125 25681.738281 558.856140 31.915110 40.732796 703.848511 32093.087891 104314.515625 104695.906250 101071.437500 10303.226562 279.651062 2.090757 7.855777 20.139460 28.647320 21.556612 9.411964 4.102487 15.857789 166.094040 1289.515381 3029.021484 1095.170288 136.321564 21.450235 61.366451 707.612610 13123.425781 150948.156250 120226.109375 101634.039063 17748.179688 513.080017 33.580074 32.282291 514.933899 21384.238281 100637.015625 100642.453125 100228.046875 7859.522461 226.587753 -0.084906 0.477289 1.388847 1.929499 1.497179 0.616862 0.542968 4.743450 35.691422 165.426605 273.215179 143.961334 32.270264 9.773918 49.083569 636.671997 11090.022461 76086.507813 82883.617188 28972.955078 2887.031982 326.020599 45.303291 18.443024 153.095810 2471.852295 37947.773438 100068.664063 19318.078125 1238.212646 82.955208 -0.340363 -0.316287 -0.262410 -0.255703 -0.320444 -0.396622 -0.329628 0.558657 4.561821 14.774602 21.429413 13.912378 4.385026 3.636465 26.283770 261.954407 2445.820801 10993.383789 17128.205078 21986.226563 15636.916016 2383.060303 203.576996 22.118757 29.897627 184.444092 863.708313 1339.174316 607.137817 122.011452 23.531736 -0.311299 -0.345100 -0.371105 -0.408482 -0.440771 -0.467983 -0.465755 -0.353255 0.069662 0.873962 1.298663 0.765118 0.144942 1.313155 14.292238 142.645691 1790.322998 23073.222656 121909.148437 120008.828125 101537.093750 34449.214844 992.486816 49.686554 18.481117 84.543869 278.882263 315.728485 132.669205 41.905155 17.560499 -0.255460 -0.286529 -0.316381 -0.345655 -0.377346 -0.403287 -0.420250 -0.429797 -0.415069 -0.383265 -0.389485 -0.451922 -0.433529 0.491659 9.279603 106.142189 1535.184692 20076.890625 156859.093750 114721.031250 101192.296875 100096.867188 1798.035278 73.400246 100.384720 1524.728760 13650.823242 16761.480469 2341.550049 368.933472 116.864319 -0.198675 -0.221080 -0.246633 -0.271811 -0.297941 -0.321772 -0.342514 -0.357691 -0.380730 -0.415109 -0.456563 -0.492845 -0.470660 0.023167 4.416771 43.659588 422.217621 3401.524658 42993.136719 102109.375000 100333.640625 28269.685547 851.770569 62.173664 464.091125 28075.025391 100121.187500 101321.031250 61860.585938 10938.397461 2166.969727 -0.149074 -0.164837 -0.179666 -0.201198 -0.220911 -0.242880 -0.260186 -0.281030 -0.304406 -0.336893 -0.377165 -0.423483 -0.438003 -0.268516 1.199272 10.849045 69.536461 376.697235 2230.728027 10348.954102 9355.495117 1664.880493 158.055618 39.099857 796.274719 85423.593750 100733.554688 128245.445312 200085.750000 101630.562500 70412.507813 -0.110572 -0.118955 -0.130529 -0.145555 -0.160099 -0.180090 -0.194163 -0.213078 -0.232754 -0.261761 -0.300468 -0.347751 -0.381792 -0.357125 -0.012008 1.902032 10.007380 39.013073 128.680923 293.798309 266.761383 95.953712 20.776873 17.504820 298.144836 11241.458984 101936.179688 200046.515625 118814.000000 102530.921875 104772.015625 -0.077141 -0.084813 -0.093785 -0.105464 -0.117519 -0.134440 -0.145473 -0.161318 -0.178011 -0.201708 -0.233740 -0.273201 -0.310248 -0.345227 -0.307952 -0.009374 1.087368 4.100702 10.144067 16.448547 15.606786 7.481824 2.457259 4.732488 49.813114 548.766296 4351.844727 80865.914063 101276.640625 103613.101563 108123.148437 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.001990 -0.002162 -0.002285 -0.002382 -0.003452 -0.003550 -0.003577 -0.003549 -0.003434 -0.003264 -0.001374 -0.001326 -0.001253 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002285 -0.002553 -0.002777 -0.004060 -0.004361 -0.004586 -0.004726 -0.004783 -0.004734 -0.004605 -0.004369 -0.004074 -0.003729 -0.001766 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002177 -0.002536 -0.002896 -0.004274 -0.004809 -0.005314 -0.005735 -0.006063 -0.009596 -0.009963 -0.010105 -0.010059 -0.009767 -0.009308 -0.008694 -0.007963 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002253 -0.002681 -0.003152 -0.004700 -0.005434 -0.006181 -0.011180 -0.014101 -0.015238 -0.016133 -0.016703 -0.016916 -0.016769 -0.016218 -0.016861 -0.014670 -0.014741 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002222 -0.002719 -0.003265 -0.004958 -0.005890 -0.009871 -0.012935 -0.016567 -0.020018 -0.021764 -0.023173 -0.025270 -0.027200 -0.028861 -0.029162 -0.028512 -0.027284 -0.025674 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002088 -0.002607 -0.003219 -0.004977 -0.007520 -0.012030 -0.014263 -0.021426 -0.024457 -0.027435 -0.031250 -0.035062 -0.039927 -0.041544 -0.043493 -0.043382 -0.043673 -0.041710 -0.038306 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001896 -0.002398 -0.003021 -0.003766 -0.007487 -0.012268 -0.017834 -0.023185 -0.028516 -0.035478 -0.040114 -0.048762 -0.053478 -0.059942 -0.063099 -0.064792 -0.065150 -0.063938 -0.061767 -0.058257 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002117 -0.002700 -0.003432 -0.007098 -0.013007 -0.017982 -0.024834 -0.032059 -0.039193 -0.047031 -0.057308 -0.066544 -0.075258 -0.082158 -0.087115 -0.091910 -0.094378 -0.093195 -0.089412 -0.082828 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002333 -0.003000 -0.006412 -0.010794 -0.019941 -0.024851 -0.032716 -0.041128 -0.050814 -0.065154 -0.076585 -0.089745 -0.101100 -0.112691 -0.119456 -0.125711 -0.126996 -0.126865 -0.125752 -0.120403 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001585 -0.001736 -0.001862 -0.001956 -0.003934 -0.004512 -0.006669 -0.010327 -0.020491 -0.025488 -0.030175 -0.040995 -0.052305 -0.068606 -0.084779 -0.102445 -0.119641 -0.136065 -0.146827 -0.155925 -0.161916 -0.164090 -0.165401 -0.165411 -0.161628 0.000000 0.000000 0.000000 0.000000 -0.001653 -0.001901 -0.002128 -0.002351 -0.002543 -0.002674 -0.006411 -0.007122 -0.010873 -0.018519 -0.026030 -0.033630 -0.043213 -0.055985 -0.069405 -0.089653 -0.110159 -0.133934 -0.156812 -0.173098 -0.188625 -0.193616 -0.191377 -0.189363 -0.199214 -0.213503 -0.217513 0.000000 0.000000 0.000000 -0.001849 -0.002189 -0.002525 -0.004276 -0.006353 -0.006887 -0.007307 -0.009642 -0.013018 -0.018544 -0.027006 -0.032950 -0.041963 -0.056328 -0.071529 -0.092419 -0.115096 -0.141325 -0.174022 -0.198760 -0.219392 -0.221786 -0.174203 -0.085310 -0.034194 -0.087596 -0.188940 -0.253565 0.000000 -0.001619 -0.001983 -0.003784 -0.004428 -0.006739 -0.007660 -0.010170 -0.011122 -0.011877 -0.015506 -0.022719 -0.028407 -0.037574 -0.044598 -0.052346 -0.069243 -0.090928 -0.116179 -0.148011 -0.185497 -0.218056 -0.245276 -0.258773 -0.191487 0.083143 0.612749 0.964441 0.708690 0.128253 -0.203210 -0.002831 -0.003320 -0.005441 -0.006270 -0.008953 -0.011927 -0.013489 -0.014962 -0.016297 -0.016383 -0.024981 -0.030960 -0.042455 -0.051842 -0.060375 -0.075033 -0.094398 -0.119543 -0.149345 -0.188306 -0.230455 -0.262812 -0.289477 -0.273081 -0.039018 0.884578 2.934507 4.492033 3.113525 1.136887 0.145598 -0.005059 -0.006024 -0.008522 -0.014218 -0.016261 -0.018373 -0.019180 -0.020379 -0.022416 -0.032542 -0.041482 -0.048806 -0.057699 -0.066778 -0.078007 -0.096732 -0.118515 -0.150420 -0.187065 -0.232222 -0.272142 -0.300896 -0.326717 -0.272507 0.170781 2.048019 6.156650 9.934407 7.089657 3.056622 1.690235 -0.009498 -0.011002 -0.016167 -0.018783 -0.021594 -0.024608 -0.027829 -0.036545 -0.042089 -0.048389 -0.057820 -0.064253 -0.075314 -0.085713 -0.099747 -0.119519 -0.147815 -0.185750 -0.228676 -0.267783 -0.309618 -0.319148 -0.275138 -0.129151 0.411450 2.298622 6.893128 10.671039 9.342916 7.859007 13.307833 -0.012497 -0.018084 -0.021257 -0.024754 -0.028721 -0.034614 -0.043763 -0.049676 -0.057412 -0.068957 -0.079935 -0.089254 -0.100490 -0.114496 -0.129954 -0.151518 -0.186679 -0.226153 -0.266154 -0.303687 -0.289958 -0.045594 0.706358 1.899612 2.522963 2.864765 5.059812 10.027976 20.411388 48.198513 133.922379 -0.021623 -0.025557 -0.029927 -0.034706 -0.041764 -0.052377 -0.058646 -0.071433 -0.081811 -0.095787 -0.106729 -0.117057 -0.133692 -0.146325 -0.167019 -0.194948 -0.231802 -0.272657 -0.310854 -0.313422 0.009119 2.023757 9.876475 26.190418 29.874043 16.436489 11.022094 43.124390 220.325897 665.153748 1683.008179 -0.030485 -0.035881 -0.041821 -0.051089 -0.064853 -0.076037 -0.088190 -0.101410 -0.111464 -0.124673 -0.139497 -0.152168 -0.172680 -0.190773 -0.215406 -0.249628 -0.287365 -0.321546 -0.349941 -0.209883 1.244854 12.059525 83.951706 341.441345 427.352448 146.846298 52.314724 392.315063 5869.603027 33797.820313 24942.673828 -0.044219 -0.053380 -0.063613 -0.078677 -0.091880 -0.104805 -0.121315 -0.134006 -0.150601 -0.162424 -0.174979 -0.187665 -0.207722 -0.230960 -0.272175 -0.305637 -0.342941 -0.367766 -0.374798 -0.020453 3.635577 41.892891 499.510284 3312.077881 4753.720703 1014.846130 178.639938 2494.860840 100405.429688 101545.234375 112825.296875 -0.067559 -0.080272 -0.095096 -0.112051 -0.125938 -0.142064 -0.162050 -0.175530 -0.190337 -0.200702 -0.211574 -0.226507 -0.246534 -0.281635 -0.319267 -0.361143 -0.400091 -0.427533 -0.398332 0.129243 5.321303 63.108654 937.945251 8358.750977 12349.077148 2146.763672 270.435028 3923.623779 101556.960938 105354.406250 106319.640625 -0.091806 -0.111024 -0.128531 -0.144851 -0.163444 -0.187400 -0.207122 -0.219993 -0.233951 -0.242522 -0.247793 -0.254097 -0.270828 -0.301940 -0.350948 -0.398337 -0.444004 -0.449733 -0.374484 0.201762 4.309577 40.883591 408.705688 2558.865723 3323.773682 804.763977 149.704468 1241.982788 35290.507813 107871.851562 105006.140625 -0.122050 -0.138466 -0.158995 -0.177130 -0.202011 -0.233604 -0.255642 -0.273808 -0.285980 -0.272833 -0.223237 -0.162089 -0.134481 -0.189271 -0.295519 -0.405031 -0.458596 -0.414862 -0.215847 0.424881 2.981788 15.289254 77.580780 238.539825 287.368011 110.757301 44.554310 231.671570 1679.316772 5101.455078 3715.760986 -0.152468 -0.155859 -0.142038 -0.136294 -0.167003 -0.236410 -0.294970 -0.325238 -0.313696 -0.200630 0.093320 0.439166 0.630528 0.449025 0.058820 -0.255736 -0.382518 -0.246230 0.251866 1.242579 3.379760 9.370942 21.428186 33.546967 30.440033 15.397545 11.084392 40.708447 164.335754 402.304779 1228.346069 -0.151975 -0.021853 0.306724 0.621181 0.584435 0.152185 -0.208432 -0.342607 -0.260794 0.222065 1.491284 3.306865 4.121720 3.115083 1.511137 0.461493 0.056703 0.252969 1.082043 2.430568 4.604418 9.272899 16.929394 18.531286 11.357961 4.666327 3.689530 11.163122 39.067421 281.071655 5910.917969 -0.007443 0.907846 3.593004 6.884321 6.446128 3.074137 0.557865 -0.225241 -0.080049 1.282239 5.776800 13.489109 16.736843 12.414329 6.593269 3.343885 1.689062 1.571138 2.781011 4.230127 5.268578 7.759483 12.449654 12.870094 7.739889 3.555687 2.675463 7.033339 26.447939 297.119354 9206.646484 0.524030 4.569674 20.430780 46.180279 46.125004 17.934381 3.395158 0.208277 0.208495 3.012033 12.600541 31.947365 43.774426 36.066807 25.231890 14.751751 7.228597 4.746349 6.595543 8.726299 9.097031 8.973828 10.988411 14.001535 16.533838 15.970922 10.287027 6.922609 14.891835 124.177467 2079.125488 1.416816 12.643888 68.454979 190.726410 177.617035 56.070503 9.703527 0.910970 0.303103 3.484331 16.539959 44.245529 71.935165 94.483597 102.321243 61.791843 22.654331 10.042556 13.595839 26.177147 43.829460 48.077511 55.512646 104.080025 211.459473 268.276428 138.520660 36.413654 12.843067 35.490105 226.875778 2.049142 16.506424 96.146149 294.827301 273.866943 78.245865 12.470390 1.132700 0.217156 2.939317 13.677318 43.418964 108.068069 251.252838 325.879669 189.454788 53.112614 16.389143 33.918114 176.515320 599.448242 589.307495 509.812897 1309.641968 6797.776855 12222.306641 3379.636475 372.374359 44.087772 31.230309 122.153366 2.902729 12.375547 49.605946 128.144653 118.840042 41.459583 7.458310 0.754384 0.457418 3.698442 21.401838 108.142662 396.848206 714.757568 637.809326 285.039429 73.316139 22.794483 101.575607 1297.071655 8398.472656 7364.965820 3962.957275 18479.458984 101796.765625 100284.609375 100115.703125 3501.751465 213.762527 62.617317 225.673828 13.377079 24.755053 31.986441 36.114017 30.380342 12.493779 3.269144 1.373530 2.703081 9.514398 66.826431 603.495300 3697.499512 6172.765137 2335.091553 459.284088 113.291977 36.697338 171.420685 3035.628662 28154.000000 23819.281250 12349.028320 84186.273438 106067.203125 100875.421875 102912.859375 17458.972656 2473.394043 282.846039 250.728821 90.457588 172.609970 162.183044 101.080421 66.995506 28.236921 8.076967 5.452877 9.622432 21.830692 140.934036 1802.948730 19312.847656 42021.375000 9486.471680 2936.772461 1132.953979 186.774490 109.873787 1194.647827 6967.073730 7033.414062 6987.166016 36826.429688 103805.476563 104858.382813 200069.140625 105574.101563 100194.859375 2658.349854 177.725510 428.848938 1103.441406 1043.054199 1403.458984 1331.320801 346.117798 53.011425 15.603588 20.221472 32.742558 139.711090 1565.023437 14669.015625 29175.025391 27122.066406 100653.851563 27066.087891 1492.793335 99.426323 154.009003 487.819641 613.940735 1110.599609 3445.293945 24241.818359 69598.726563 111923.257812 101575.351563 100302.156250 10129.282227 216.003418 905.380676 2746.662598 5802.470703 46995.093750 57501.171875 5510.094238 303.646118 37.574425 26.102365 31.448586 75.347664 408.537842 2080.407715 5981.692383 102194.625000 101712.945313 100618.414063 4173.847168 176.515106 39.286469 43.266502 64.021080 136.743561 397.553894 1470.450928 14896.999023 146700.765625 146373.296875 105587.359375 5246.270020 275.900299 778.864258 2608.835693 28147.890625 138154.359375 123347.015625 32397.337891 883.631958 83.300507 33.119267 23.782888 41.722095 161.132339 679.905151 5523.755859 93801.062500 200068.406250 72062.687500 3298.488037 363.672485 147.992783 60.519009 38.156746 255.993759 3715.298096 22499.048828 110955.460937 110977.476562 133421.156250 108318.140625 3463.792236 1298.288574 1038.051636 4072.053223 75016.203125 200213.140625 200108.734375 28353.746094 1240.368164 280.773651 130.145966 49.512741 106.226883 1569.540894 15841.104492 62570.285156 104306.117188 105208.867188 104049.125000 13027.261719 4637.444824 1311.876587 394.991272 135.226181 1673.237549 100098.070313 103115.781250 200070.078125 112727.796875 102932.429688 125918.031250 66245.710938 14900.829102 1142.836426 4714.782227 59122.316406 107171.117187 107891.859375 15746.461914 2819.438477 4822.559570 2708.291748 432.186218 503.026520 28107.414063 100915.007813 162910.890625 167957.390625 102955.437500 163065.734375 108924.429687 102374.507813 17237.152344 3053.750000 458.665375 3348.933350 100058.382813 101224.476563 146308.109375 128590.406250 121590.296875 146499.062500 102557.390625 105310.585938 437.030609 1257.357300 6550.047852 31475.130859 19960.431641 4755.339844 38849.449219 100775.851563 100158.984375 4883.346191 854.971252 76064.257813 100341.648438 109317.289062 200193.453125 108572.437500 169876.203125 102679.601563 106856.226562 116475.289062 13485.495117 1101.677734 998.507874 43285.015625 100178.132813 101817.445313 16062.314453 44689.613281 102406.601563 108069.257812 142201.796875 436.236267 203.741653 494.019012 1244.078979 1716.518433 7959.021973 115209.335937 108037.507812 101032.062500 20026.017578 660.856262 10156.679687 100063.585938 100559.234375 24006.310547 11128.452148 101846.257813 100605.492188 104189.031250 64415.718750 8505.845703 787.867249 167.599106 1100.593140 3980.239014 2438.955078 843.108643 6897.154785 100857.851563 112360.984375 127442.148437 3193.002686 181.465500 727.953125 9374.547852 25731.234375 106041.164063 179313.890625 200113.390625 110257.312500 8776.183594 319.344116 485.789856 2783.355957 3069.326172 843.922729 1055.807617 14693.934570 100124.476563 51822.070313 5590.344727 1143.514771 182.348465 31.730112 43.795033 86.458260 77.125687 92.065643 532.427856 3263.133545 9383.913086 38415.324219 7821.393555 338.852142 5740.005371 100183.859375 106057.992188 200265.625000 104587.148438 112477.765625 34976.417969 1655.206787 284.620850 112.296806 89.249069 80.961723 50.265503 98.983459 489.147919 1336.145264 968.534058 328.645569 104.618301 27.477139 6.658482 4.276242 5.379487 5.776875 12.903533 60.285774 387.378693 6993.946777 100765.984375 3002.598877 304.640320 8364.207031 100108.523438 102263.179688 177525.765625 102363.726563 100847.390625 10066.858398 3258.042725 3496.819336 1073.877197 152.194107 20.991964 6.559518 10.454681 28.721209 51.319927 46.700695 25.126717 11.358788 4.806056 3.472146 4.078781 4.079951 2.816824 3.342859 17.746735 215.956238 6065.106934 100061.500000 558.952148 149.010132 1425.871460 28099.832031 96316.882813 15218.866211 9950.422852 5746.738281 6466.458984 77904.421875 100097.601563 16026.256836 855.185669 57.254200 7.624030 2.962224 3.088581 3.653980 3.338991 2.183277 1.993917 3.908643 9.287781 18.099897 21.172766 13.260285 5.578050 8.001509 80.085007 1225.895630 17571.792969 280.810974 279.099030 248.232117 662.585022 1134.179687 572.017761 381.491882 845.016785 17774.468750 100123.234375 100068.875000 77552.968750 1980.305664 111.060043 16.446131 5.454606 2.219073 0.857313 0.107468 0.118192 1.646227 7.693262 28.449362 75.306145 100.381279 58.068535 18.047571 6.256060 17.842009 121.344681 638.952759 683.286560 1120.565186 490.924774 132.765671 66.980034 41.455463 52.374519 395.237518 8558.854492 100056.429688 100154.421875 28512.365234 1328.059570 131.280426 26.683353 8.846332 3.043682 0.855133 -0.076344 0.004358 2.083807 12.173150 56.480484 188.696350 260.769836 146.851303 40.655437 13.129157 8.867210 14.574658 38.525497 851.373169 1490.521729 955.466858 494.442047 224.411209 62.623062 23.856480 101.277245 994.680786 6101.361816 8811.790039 2818.152344 616.589600 128.752274 28.839794 8.929087 2.828341 0.732711 0.024779 0.161143 1.914495 11.335595 58.641930 188.128677 279.779663 153.617523 60.567455 44.703655 30.038515 12.537962 5.953824 689.203308 2502.954102 6150.910156 12063.261719 5264.964844 707.503967 69.108986 26.609127 104.277222 342.085693 559.707520 539.260132 291.256317 83.833862 20.405846 6.463691 2.515269 1.141204 0.858584 0.952138 1.666128 6.345429 27.475769 78.833481 111.055122 87.865410 113.448372 169.868683 114.292274 36.655064 7.522658 999.547119 8565.636719 105867.750000 102018.843750 100306.031250 9345.531250 304.596252 26.652531 40.203163 127.328903 231.658325 205.430878 105.618851 35.179420 11.381164 6.154721 5.240138 7.087533 9.073426 7.890835 4.234272 3.251773 7.623899 18.742279 32.282166 64.195938 182.496841 332.652466 222.429474 64.830070 11.999145 869.738953 19984.298828 103395.937500 101275.968750 100231.218750 46311.597656 686.794617 36.408417 35.481068 114.550751 192.119232 133.435654 50.366096 16.300282 8.924160 10.996649 27.507088 90.229332 155.474243 120.667107 38.851566 8.699713 2.968917 5.948002 20.817030 84.048752 259.305878 403.806122 253.353271 76.190994 14.620088 408.935211 9779.028320 100643.171875 100322.078125 100078.398438 21198.773438 482.114105 28.135988 23.526545 67.556038 107.172401 72.184258 28.428614 9.814782 9.749515 33.385807 266.818085 2092.358398 6033.080566 3368.700928 551.178589 58.103416 6.831698 8.473501 63.698185 508.522308 3017.906738 5279.007812 2030.210449 291.157654 33.724426 104.288620 1283.630371 17636.128906 86180.382813 28247.126953 2091.217773 129.444000 14.149128 20.845499 67.697388 104.990295 66.975998 21.428511 7.384242 13.622993 123.650009 2666.622314 86165.218750 100034.656250 100021.359375 8529.475586 319.968262 21.513399 20.115242 262.514526 6114.989258 100221.914063 100226.117188 77582.539063 2668.448486 124.813721 18.187279 107.913841 488.351929 1059.453003 636.842590 145.999008 21.126347 6.449574 23.270782 92.174980 148.359695 82.113289 22.012989 6.392456 20.208374 288.369507 11227.208008 100269.601563 100339.039063 100224.390625 56800.589844 861.485291 39.373260 33.940121 647.839844 37944.917969 100155.843750 100156.765625 100067.531250 12182.145508 281.185364 2.696423 10.188087 27.079998 41.642204 30.898783 11.212336 2.860242 2.674556 15.069624 52.856701 83.962578 49.948399 13.273756 4.684524 22.208351 281.648285 8935.534180 101738.476563 104416.773438 103490.750000 38653.148438 777.200745 45.407990 30.812248 556.273926 25654.978516 100045.812500 100049.109375 100023.992188 8528.038086 230.306137 0.164150 0.877324 2.012467 2.647556 1.983853 0.702994 -0.024429 0.590522 4.532757 13.889015 20.206928 13.154599 4.311024 2.516097 17.405054 166.727264 2055.763184 31904.548828 163590.906250 108588.718750 8838.886719 634.899414 65.371071 19.790873 156.921432 2869.331787 41862.687500 100009.890625 23299.855469 1319.243408 80.918839 -0.240301 -0.203134 -0.140162 -0.138186 -0.243934 -0.390500 -0.462804 -0.294378 0.456518 1.874176 2.835850 1.875139 0.499528 1.048649 10.969992 95.149796 1034.566284 16012.912109 106119.359375 129526.429687 33727.882813 3795.979736 274.720886 25.861977 30.450724 191.964005 918.006104 1542.594971 686.721191 122.987602 19.705229 -0.279436 -0.309732 -0.335079 -0.371041 -0.413020 -0.450877 -0.474519 -0.457732 -0.362679 -0.202455 -0.143946 -0.258220 -0.384610 0.315949 6.765094 57.112278 542.450928 6370.515137 124355.320312 118124.664062 102567.742188 69978.703125 1335.474243 58.118927 17.117039 68.744560 207.545319 236.676483 107.484703 33.408745 12.889029 -0.243569 -0.267970 -0.295441 -0.322661 -0.353888 -0.376666 -0.396566 -0.419372 -0.435366 -0.443061 -0.470140 -0.502880 -0.499941 -0.034819 3.876330 32.795212 288.214417 4527.095703 101985.898438 101504.492188 100380.406250 100059.132813 2450.413574 89.444740 78.560150 932.908936 7597.526367 8401.408203 1429.314453 249.498062 89.324883 -0.188728 -0.209109 -0.232525 -0.256191 -0.275550 -0.296085 -0.313671 -0.331767 -0.351619 -0.385109 -0.426996 -0.461625 -0.465013 -0.237314 1.648185 14.758055 122.568314 1721.951294 77797.843750 100211.375000 100068.851563 51227.824219 1136.939575 66.792496 344.823181 13639.997070 100083.523438 100735.726563 26413.425781 4938.641602 1393.623169 -0.145364 -0.161652 -0.175305 -0.191436 -0.208458 -0.219728 -0.237363 -0.255763 -0.279974 -0.305983 -0.343853 -0.385091 -0.408080 -0.340036 0.375804 4.664855 32.047577 274.127258 2908.269043 17589.435547 14607.845703 2260.106934 189.030258 35.849396 539.404358 34803.410156 100448.351563 110191.265625 168076.984375 104172.328125 31350.330078 -0.106612 -0.115853 -0.125946 -0.137424 -0.149033 -0.161880 -0.175231 -0.189926 -0.210560 -0.238162 -0.268694 -0.310445 -0.338222 -0.345506 -0.173606 0.882222 6.218463 31.523853 141.812805 367.715363 341.548492 120.584488 23.689077 14.786542 223.190033 6321.057617 101057.156250 151285.046875 111003.476562 176372.828125 200040.609375 -0.073887 -0.082741 -0.086757 -0.095166 -0.105334 -0.116690 -0.128538 -0.140633 -0.156577 -0.177903 -0.204266 -0.241061 -0.272797 -0.300161 -0.302823 -0.116840 0.692327 3.360359 10.123448 17.806185 17.480852 8.427081 2.696453 4.029750 38.433136 403.333588 2536.190674 27682.365234 103253.570313 200097.718750 162935.031250 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.001896 -0.001922 -0.002967 -0.002985 -0.001193 -0.001236 -0.001253 -0.001244 -0.001201 -0.001136 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002031 -0.002207 -0.002349 -0.003568 -0.003772 -0.003900 -0.003944 -0.003936 -0.003843 -0.003675 -0.001741 -0.001679 -0.001585 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002017 -0.002285 -0.002553 -0.003889 -0.004296 -0.004648 -0.004918 -0.005115 -0.006641 -0.006716 -0.006636 -0.006409 -0.006102 -0.005656 -0.002218 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.002132 -0.002483 -0.002836 -0.004376 -0.004946 -0.005506 -0.007459 -0.008076 -0.009978 -0.012162 -0.012390 -0.010994 -0.010762 -0.010277 -0.011016 -0.011692 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002553 -0.003000 -0.004701 -0.005467 -0.009173 -0.011729 -0.012959 -0.015995 -0.017055 -0.017827 -0.018171 -0.022304 -0.023387 -0.023993 -0.021882 -0.019517 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002074 -0.002518 -0.003042 -0.004809 -0.007232 -0.010070 -0.014276 -0.017957 -0.021756 -0.023825 -0.026718 -0.032395 -0.033866 -0.035710 -0.037297 -0.035235 -0.033014 -0.029924 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.002382 -0.002917 -0.004691 -0.007383 -0.013020 -0.017022 -0.019855 -0.025967 -0.030444 -0.039222 -0.042918 -0.048641 -0.051433 -0.051708 -0.051163 -0.050425 -0.050306 -0.046120 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002147 -0.002681 -0.004356 -0.008201 -0.013112 -0.017693 -0.023926 -0.030075 -0.037228 -0.045505 -0.053056 -0.060153 -0.065687 -0.070089 -0.074429 -0.075873 -0.075054 -0.072829 -0.069501 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001630 -0.001676 -0.003533 -0.003990 -0.004543 -0.007749 -0.011268 -0.020271 -0.024646 -0.031645 -0.040250 -0.051881 -0.060618 -0.070881 -0.080175 -0.088694 -0.097116 -0.103109 -0.107322 -0.108422 -0.106026 -0.101225 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001810 -0.001997 -0.002143 -0.002253 -0.002318 -0.004324 -0.004821 -0.009211 -0.013847 -0.021418 -0.026034 -0.030066 -0.041404 -0.053249 -0.065797 -0.080638 -0.094218 -0.107319 -0.121678 -0.127817 -0.135951 -0.139980 -0.142206 -0.143248 -0.140554 0.000000 0.000000 0.000000 -0.001619 -0.001901 -0.002189 -0.002471 -0.002733 -0.002960 -0.006201 -0.005067 -0.007261 -0.010455 -0.015587 -0.021614 -0.027509 -0.033077 -0.047315 -0.057208 -0.071207 -0.086610 -0.105388 -0.125108 -0.143116 -0.154287 -0.167187 -0.177323 -0.184211 -0.188874 -0.189539 -0.188104 0.000000 0.000000 -0.001772 -0.002143 -0.003936 -0.004512 -0.006681 -0.007418 -0.008078 -0.008572 -0.008894 -0.012226 -0.016246 -0.020704 -0.030673 -0.036377 -0.045941 -0.059238 -0.075239 -0.092247 -0.110447 -0.135643 -0.161715 -0.180702 -0.199539 -0.211085 -0.212925 -0.215584 -0.229403 -0.243308 -0.246965 0.000000 -0.001862 -0.004743 -0.005487 -0.006268 -0.008880 -0.009059 -0.011883 -0.013021 -0.013967 -0.014610 -0.021169 -0.025982 -0.033202 -0.041002 -0.047780 -0.060446 -0.073723 -0.092292 -0.114354 -0.146984 -0.178991 -0.206090 -0.231936 -0.245855 -0.236168 -0.200568 -0.179801 -0.210803 -0.261475 -0.293005 -0.003124 -0.005296 -0.006229 -0.008898 -0.010397 -0.013831 -0.015787 -0.017629 -0.019288 -0.020657 -0.021750 -0.031019 -0.034806 -0.047042 -0.057742 -0.066976 -0.077781 -0.097860 -0.119380 -0.151354 -0.185659 -0.226535 -0.252860 -0.277957 -0.278285 -0.217035 -0.077618 0.020699 -0.069782 -0.197808 -0.260425 -0.007191 -0.009519 -0.012595 -0.016291 -0.018795 -0.021500 -0.024283 -0.026984 -0.028065 -0.030928 -0.041262 -0.049010 -0.055936 -0.064586 -0.072875 -0.086247 -0.102582 -0.127235 -0.155395 -0.191688 -0.229716 -0.267286 -0.293757 -0.320457 -0.302162 -0.168374 0.082688 0.272135 0.218036 0.091767 0.218126 -0.010794 -0.014220 -0.018553 -0.021734 -0.025287 -0.029161 -0.033287 -0.039325 -0.047405 -0.054339 -0.059662 -0.070693 -0.075736 -0.084050 -0.093084 -0.111573 -0.128418 -0.159692 -0.192810 -0.230695 -0.270820 -0.305249 -0.317046 -0.323669 -0.293095 -0.163796 0.170535 0.584639 1.106034 2.074207 4.002166 -0.014310 -0.020725 -0.024586 -0.029058 -0.034174 -0.041425 -0.049816 -0.058668 -0.067145 -0.078942 -0.089263 -0.095511 -0.106125 -0.113771 -0.127403 -0.142438 -0.165680 -0.196050 -0.230587 -0.268790 -0.296283 -0.265223 -0.092680 0.125512 0.207444 0.162820 0.700832 2.972091 8.740310 18.299520 31.715870 -0.024696 -0.029478 -0.034890 -0.041044 -0.049906 -0.060130 -0.073758 -0.083329 -0.093157 -0.103029 -0.116307 -0.124199 -0.136888 -0.148827 -0.164098 -0.182070 -0.208923 -0.244540 -0.276705 -0.303623 -0.245550 0.189702 1.589159 3.886681 4.435757 2.979147 4.762250 23.285273 93.547012 205.191223 249.806168 -0.035012 -0.041688 -0.049232 -0.060498 -0.072450 -0.087696 -0.101110 -0.112721 -0.122525 -0.136019 -0.147310 -0.154960 -0.165658 -0.184539 -0.203270 -0.232927 -0.262888 -0.293886 -0.321068 -0.319739 -0.007645 1.977902 9.790918 26.025858 29.673321 17.100727 22.596458 164.860641 1226.277100 3977.349365 2809.325684 -0.049149 -0.059966 -0.074278 -0.087841 -0.107472 -0.122743 -0.136429 -0.149990 -0.161760 -0.165900 -0.168316 -0.174629 -0.192252 -0.217198 -0.245552 -0.280033 -0.316606 -0.346488 -0.373605 -0.305793 0.463113 5.764435 33.680199 102.119659 125.696304 57.886005 71.682556 864.856628 13735.831055 86641.226563 40547.261719 -0.076245 -0.091539 -0.109045 -0.128159 -0.146827 -0.163874 -0.182668 -0.193822 -0.192166 -0.177214 -0.159218 -0.152177 -0.170827 -0.210867 -0.265833 -0.323285 -0.374068 -0.405232 -0.422373 -0.325613 0.684669 7.929844 49.712715 166.060806 205.733795 86.807220 129.882538 2261.747314 64305.660156 200054.546875 163428.234375 -0.103796 -0.124098 -0.142624 -0.164537 -0.186817 -0.208485 -0.230137 -0.231432 -0.212988 -0.151112 -0.055275 0.026229 0.059503 -0.000813 -0.151168 -0.293047 -0.399481 -0.455368 -0.479192 -0.393556 0.416629 5.422294 28.664726 90.238106 103.511528 52.099689 123.370644 2349.485107 80898.031250 116418.914062 108987.843750 -0.136185 -0.153294 -0.170078 -0.185957 -0.215159 -0.247413 -0.273739 -0.276170 -0.217124 -0.031420 0.328904 0.797958 1.099215 0.982849 0.467120 -0.052170 -0.354910 -0.483780 -0.517430 -0.452768 -0.005401 1.978427 8.743119 20.416958 24.393156 16.998075 57.458202 727.088806 11403.143555 70723.804688 38014.710938 -0.156403 -0.124618 -0.031839 0.058730 0.008240 -0.146899 -0.274302 -0.303491 -0.137513 0.493895 2.013999 4.289993 5.973702 4.862432 2.626209 0.762524 -0.160581 -0.470348 -0.509425 -0.432880 -0.177541 0.596636 2.198406 3.919523 4.015197 3.572108 14.968372 114.799568 733.775330 2261.312988 8249.524414 -0.066784 0.423871 1.767786 3.405486 3.170239 1.457182 0.173637 -0.196437 0.258145 2.704163 10.693745 26.249222 34.415821 23.386202 10.041408 3.266799 0.547724 -0.286890 -0.431892 -0.346576 -0.134961 0.303286 0.877517 1.118219 0.714163 0.379217 2.637830 16.032364 83.766273 768.917725 34586.851563 0.579325 4.649111 20.552670 46.336300 43.413231 16.991085 3.507128 0.436004 1.378183 10.054602 52.044998 157.281693 220.203323 117.902634 39.992062 13.131055 3.766606 0.598459 -0.050537 0.052332 0.394904 0.802153 1.279227 1.432616 1.086051 0.533305 0.575129 3.926906 35.203171 717.490112 63373.371094 2.933269 28.174479 205.282059 733.206421 677.718506 165.851669 21.792374 2.462048 3.063839 24.286240 155.694443 640.356689 935.615662 465.976257 188.797913 81.053978 22.267059 4.686142 1.672027 3.378552 6.972999 9.047771 10.762145 12.686339 12.532032 10.244903 5.810052 4.538866 20.557238 281.718658 7701.602539 7.689952 103.318459 1291.215210 9197.695312 7588.678711 1010.242065 73.648575 5.876271 3.872446 29.106735 203.485764 869.504395 1487.715088 1306.095703 1519.092773 695.432251 130.368881 19.234837 11.531124 47.894859 123.825409 142.646133 144.956741 174.005753 167.467758 143.342865 70.304497 24.935667 34.354279 117.407524 588.772644 10.644820 147.629227 2337.122803 18494.671875 16696.537109 1660.727051 103.891975 7.577621 3.121464 19.233980 112.106010 449.199951 1225.397827 5433.149902 12275.828125 4332.217773 484.155823 50.506512 83.190414 863.112671 4790.553711 4702.296387 2804.505859 4340.694824 3081.906006 2861.201660 1007.738159 175.492004 103.575371 255.252594 458.876129 12.167274 81.426750 752.703857 3644.668701 3330.860352 546.390015 52.552540 5.990550 4.502039 14.963691 77.158508 486.373535 2791.723877 12223.765625 24366.640625 7323.942383 706.575317 78.439812 433.266541 18491.613281 100188.492188 103665.546875 81114.585938 103168.375000 72231.187500 87809.898438 16154.322266 1079.235474 207.963638 345.915527 559.382324 59.253471 128.225128 189.265457 310.402405 265.479828 85.475838 17.746374 11.731469 22.860838 42.786526 249.987946 4046.350586 70192.164063 102680.406250 33860.132813 3735.081299 498.129669 95.121109 867.963501 76053.859375 100390.726563 113341.710937 139095.687500 109869.531250 200078.218750 105285.820313 87474.742188 4687.884277 1076.784912 277.973450 265.148865 738.953125 1950.205444 1476.778442 418.905304 156.430557 57.222210 21.810820 52.360958 134.452332 180.556183 706.298645 23471.812500 100191.804688 100603.179688 103117.164063 13702.432617 3631.370850 411.404572 431.208130 15093.431641 100298.375000 107825.132812 109430.281250 104972.789063 195968.453125 105005.937500 71352.554688 101571.390625 24471.779297 1113.444824 123.568672 7843.438965 41936.156250 23944.013672 5686.272461 3885.736816 808.643066 102.141258 144.456802 444.322876 484.796387 912.898865 18132.871094 100389.156250 102971.367188 200089.000000 104040.515625 100183.898438 4860.318359 222.667160 748.495239 3701.466553 4368.263672 9918.982422 21948.533203 10938.955078 13839.945313 103008.992188 100818.453125 100213.781250 3460.661133 157.474075 28474.244141 100490.265625 114897.703125 106192.328125 100409.742188 22082.541016 611.159302 157.378998 387.841858 465.117157 689.140320 2968.503662 26198.021484 67078.859375 111982.570312 102013.984375 100538.726563 18121.601563 329.301422 62.159279 117.136803 189.675369 405.058777 732.065857 1025.276489 6719.274414 120349.789062 121245.304687 66341.507813 2326.351562 811.223267 13765.381836 71316.203125 138483.281250 104647.804688 101325.968750 100280.734375 1789.727905 103.125519 127.407768 156.398651 258.323090 533.076416 1341.956421 8567.657227 134842.156250 177598.718750 113378.335937 8546.946289 345.772003 109.109947 63.209473 43.770229 187.142120 1892.908936 8870.916992 55948.152344 103939.875000 108587.335937 49848.164063 4226.646973 18684.142578 5203.671387 5030.883301 61078.304688 107625.562500 105157.210938 99777.023438 1285.050537 106.676666 56.462631 48.318092 118.427765 958.567688 7588.500488 34500.757813 107774.203125 124569.695312 108963.617187 6999.245117 2084.093018 2179.268066 1123.428101 230.048218 959.265076 38848.566406 101939.828125 200049.718750 105058.515625 103473.726563 142173.859375 107641.203125 117701.421875 2520.191406 1075.540527 5036.256348 37150.976563 41589.460938 4938.915527 622.537476 694.109863 453.654449 125.446762 320.469238 11221.074219 100746.023438 137931.406250 122948.375000 101478.179688 108791.726562 58770.156250 50477.324219 102505.289063 50975.207031 2294.716309 1627.767212 100050.757813 100789.109375 121217.515625 110774.367187 134563.625000 121382.664062 104559.664063 188580.078125 796.013672 437.895081 707.755127 1832.135010 1597.567261 956.500366 3130.140869 10531.828125 5909.149414 723.966431 495.490540 25274.390625 100281.687500 106577.351562 160581.171875 102666.898438 98724.828125 105110.359375 200195.953125 110285.031250 100443.984375 11142.331055 785.528687 15099.813477 100131.523438 61655.984375 8923.142578 62378.109375 101249.750000 100956.882813 104872.812500 556.341553 285.566833 213.267288 560.593872 1345.482544 8588.982422 46325.421875 74229.203125 26087.197266 1932.410645 330.480652 4783.080566 96053.343750 100452.851563 10859.004883 5608.805664 32545.589844 102490.968750 200207.687500 107358.093750 100402.656250 6988.143066 278.358307 595.356018 1980.135254 1275.443359 721.649414 9514.414062 100162.328125 100502.125000 97160.445313 829.063782 200.019684 1140.701904 18665.236328 59169.277344 108654.460937 104243.195313 118447.273437 33178.156250 1936.564575 299.236938 355.266541 1418.967163 1692.740967 555.156677 500.856354 3227.081543 12623.320313 13247.262695 25564.351563 10241.984375 877.796936 74.712669 43.098877 64.280159 57.545696 88.618164 656.705017 4040.078857 7619.129883 4587.579590 1739.474976 317.913055 11203.553711 100264.687500 112180.390625 200115.156250 103974.796875 105656.539063 89492.265625 5745.534180 932.934570 227.105377 93.003326 63.474831 38.548016 61.970417 223.930344 516.519775 588.712402 583.402405 326.568573 84.920486 25.094568 18.678400 13.634621 9.011286 12.818243 52.401730 201.590042 1000.827209 10333.287109 2032.797241 355.022644 16700.439453 100156.343750 104315.625000 200098.562500 105322.093750 117824.882812 81822.929688 27382.349609 14692.036133 3212.128174 315.938293 35.495289 10.022520 10.145721 21.832006 37.528488 44.446201 40.852440 28.200624 21.770376 26.299799 29.811380 25.306934 14.403726 6.334119 10.543391 68.525269 746.964905 8538.305664 1017.734070 156.866638 2550.393311 76075.382813 100485.234375 33677.289063 23054.554688 21964.416016 55639.132813 110284.828125 100955.710938 100127.367188 2313.065674 128.793304 29.654499 11.464289 5.169992 4.227694 4.771913 6.395663 13.605297 33.802273 75.026329 151.764648 185.594681 102.481224 28.042955 8.254330 27.381844 229.526566 1535.344238 248.387833 62.508179 188.438797 1024.977051 1851.982422 844.624268 752.071167 3024.592529 102739.296875 101402.296875 100558.492188 100719.070313 7055.620117 360.907104 110.943016 39.322422 9.272308 1.638346 0.665116 3.470307 17.002243 65.147217 289.859894 1251.288696 1940.339233 846.955627 136.574371 18.382971 8.960661 38.734303 145.989944 118.157242 162.047363 178.213089 117.420120 80.991875 54.081787 100.463104 1035.806396 46495.195313 100454.843750 102909.296875 108552.687500 8045.885254 954.852173 269.245422 84.992508 17.123747 2.398785 0.223664 2.577421 15.815643 93.349831 816.065063 6048.209961 11125.413086 3654.018066 389.851837 37.183815 5.356936 5.645989 14.287277 526.713684 2329.740479 2986.657959 1071.088135 235.092941 53.269672 30.975380 208.315689 2949.033936 28981.503906 54898.984375 42208.988281 15208.384766 1651.240723 287.272552 80.122536 17.149014 2.531236 0.059941 1.251666 10.449682 77.961288 796.597778 6036.275879 12168.773438 3654.032227 419.381317 39.871067 6.554513 2.173723 1.691429 4359.580566 51499.855469 87830.898438 15456.401367 2904.257324 411.894226 51.916988 52.157814 306.907013 1516.579590 5948.598633 15395.397461 7366.750000 941.011719 153.226425 40.798298 10.004163 1.990457 0.306473 0.616263 4.755446 34.252834 262.130341 1318.355225 2258.139893 911.590759 152.466461 29.032053 10.542275 3.732352 0.888493 13446.533203 102135.023438 146347.421875 141907.312500 78825.312500 3725.739990 198.685226 50.916603 345.612518 2227.775146 5756.915527 3886.407959 1290.221680 247.800949 50.129974 14.863907 5.980490 4.694091 5.699082 4.566425 3.499460 9.333149 43.375389 145.449127 201.653122 112.485992 44.331795 26.689968 17.193733 6.886473 1.651314 5752.358398 84091.601563 200065.250000 114650.101562 100812.351563 14652.553711 398.903412 58.543781 370.557800 2667.540039 7230.623535 3226.034912 538.865601 83.153511 17.588228 8.412873 16.699549 48.907593 82.859413 64.948441 23.037748 6.665154 6.679796 14.902224 23.032236 34.584068 64.601364 81.961662 50.578762 17.562403 3.956154 843.205505 7637.540039 104712.757813 101347.570313 100181.578125 7830.420410 283.349030 36.714943 158.138382 853.554871 1809.883911 944.976196 219.258118 39.957382 10.852858 19.553165 138.031723 787.672729 1932.528198 1223.417480 260.833954 34.558167 5.028980 5.099226 27.904905 171.990952 743.252747 1234.982422 559.176208 109.681969 14.874470 117.643867 818.599182 6781.059570 23401.070313 9336.210937 1059.597290 85.166245 14.107964 35.332207 121.264420 220.536072 157.563736 63.748844 19.505529 11.017153 68.725471 985.469727 16022.916992 86164.382813 34349.109375 2658.117676 158.384186 13.405998 10.178418 101.886925 1426.701660 14607.354492 34331.074219 8528.312500 733.687805 55.065201 20.641117 83.405083 299.020630 565.881714 370.543549 90.357430 15.358437 3.595073 7.543068 20.390827 33.824749 31.460873 19.318014 8.702056 12.549091 137.853851 3422.073730 100270.960938 100740.234375 100638.414063 11320.381836 396.611420 27.796556 17.220772 229.431808 5094.409180 100008.968750 100009.609375 62886.859375 2258.537354 113.184792 6.069856 11.904427 24.410252 32.274731 23.175274 9.323316 2.125613 0.523086 1.858015 5.477792 8.727803 8.561055 5.247897 3.298630 12.323180 148.726212 3077.192139 92187.953125 141881.093750 131134.875000 11903.194336 568.623169 40.303341 17.110077 200.793976 3966.865234 77488.015625 100003.789063 41855.378906 1786.931152 94.062798 2.293071 2.727474 3.546680 3.695905 2.445599 0.841622 -0.111362 -0.311768 0.130420 1.193514 2.013611 1.750905 0.932747 1.211411 10.888458 132.300201 2621.179199 106081.367188 123413.929687 111358.429687 52746.855469 1236.140503 75.864059 13.688557 69.953865 731.554382 6029.859863 12166.888672 3652.967285 416.903137 39.040565 0.552758 0.525140 0.461157 0.330812 0.033105 -0.263105 -0.451725 -0.498529 -0.394278 -0.192972 -0.045595 -0.123189 -0.254672 0.461708 8.807900 121.640617 3460.516602 100469.570313 102027.906250 106494.218750 105657.234375 2726.547607 177.408539 18.190214 15.868106 84.656830 300.272858 450.208679 230.022629 55.486786 9.909396 -0.077199 -0.119809 -0.172187 -0.243449 -0.325123 -0.401868 -0.449846 -0.464712 -0.463999 -0.462236 -0.467404 -0.490260 -0.493161 0.054679 5.405046 70.053993 1282.483521 38616.859375 116080.609375 200055.859375 119299.593750 11757.537109 548.237488 36.056301 8.588295 25.866850 67.324501 75.459381 41.938316 15.699773 6.487424 -0.201721 -0.229550 -0.257138 -0.290892 -0.320258 -0.350621 -0.372142 -0.387000 -0.405912 -0.432566 -0.467267 -0.491375 -0.482818 -0.196758 2.442026 24.407829 244.671371 2782.026367 52884.562500 105564.468750 101062.796875 31221.509766 919.815613 46.603516 25.426455 167.096207 683.016235 812.510132 265.626160 84.878311 44.050392 -0.174265 -0.193511 -0.214268 -0.235840 -0.257543 -0.274342 -0.292126 -0.308224 -0.325327 -0.352666 -0.390301 -0.417239 -0.434605 -0.321720 0.726249 7.745106 63.292286 686.348145 12370.071289 100187.828125 100070.070313 9320.310547 449.338837 34.952042 80.650978 1096.515869 8373.442383 10292.062500 2048.346680 913.319397 717.977905 -0.139776 -0.151117 -0.164858 -0.179425 -0.196035 -0.205092 -0.218164 -0.232663 -0.250373 -0.275891 -0.310615 -0.345251 -0.369000 -0.353980 0.002390 2.242812 16.490091 130.080383 993.079529 3978.432617 3659.206787 846.659668 94.550385 17.523134 111.040527 1969.528320 20593.382813 23743.876953 8985.259766 17897.705078 49991.339844 -0.104832 -0.112660 -0.118591 -0.130294 -0.138475 -0.147103 -0.157481 -0.168920 -0.187507 -0.210744 -0.238848 -0.273384 -0.300631 -0.319469 -0.245067 0.313544 3.349058 17.747896 70.980827 166.245438 155.262634 61.487228 14.183007 6.662480 54.234123 642.336121 4163.758789 7518.780762 29867.201172 131187.718750 105097.898438 -0.072220 -0.079214 -0.083422 -0.086064 -0.096646 -0.103761 -0.115710 -0.125471 -0.138216 -0.158542 -0.180869 -0.208064 -0.243656 -0.263748 -0.272983 -0.189565 0.305434 2.082747 6.005733 10.680179 10.560674 5.406230 1.629739 1.724171 13.846880 91.524857 424.820435 2234.691650 20608.515625 114614.328125 103109.539063 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001001 -0.001059 -0.001097 -0.001112 -0.001104 -0.001066 -0.001008 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001832 -0.002904 -0.003066 -0.003193 -0.003231 -0.001465 -0.001518 -0.001540 -0.001529 -0.001475 -0.001394 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001794 -0.001990 -0.002162 -0.003453 -0.003737 -0.003966 -0.004139 -0.004232 -0.004252 -0.004181 -0.004023 -0.002122 -0.002045 -0.001914 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001936 -0.002192 -0.003498 -0.003952 -0.004387 -0.004776 -0.006519 -0.006919 -0.007199 -0.007337 -0.007322 -0.007134 -0.006792 -0.006354 -0.004242 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001990 -0.002317 -0.003748 -0.004332 -0.004933 -0.006965 -0.009189 -0.009996 -0.010664 -0.011115 -0.013163 -0.013211 -0.015950 -0.016499 -0.016139 -0.013795 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001963 -0.002333 -0.003827 -0.004513 -0.006723 -0.009315 -0.011629 -0.014351 -0.015689 -0.018664 -0.023348 -0.025919 -0.027796 -0.029507 -0.027033 -0.026480 -0.025371 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.002253 -0.003730 -0.004510 -0.008016 -0.011136 -0.014376 -0.016406 -0.021895 -0.026544 -0.033356 -0.037037 -0.039325 -0.040912 -0.041631 -0.039857 -0.038788 -0.037381 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002074 -0.002536 -0.005697 -0.008115 -0.011496 -0.015215 -0.022232 -0.028427 -0.034831 -0.042300 -0.047975 -0.052350 -0.055943 -0.058382 -0.059565 -0.059460 -0.058490 -0.054588 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001630 -0.001748 -0.001836 -0.001875 -0.001888 -0.003693 -0.004057 -0.008020 -0.007897 -0.011405 -0.019792 -0.023596 -0.030080 -0.038669 -0.047921 -0.055924 -0.063013 -0.069661 -0.075197 -0.082533 -0.086036 -0.086704 -0.086859 -0.083321 0.000000 0.000000 0.000000 0.000000 -0.001585 -0.001823 -0.002040 -0.002253 -0.002436 -0.002561 -0.002636 -0.002636 -0.004556 -0.006002 -0.009651 -0.015564 -0.020151 -0.025636 -0.030130 -0.040952 -0.051836 -0.062130 -0.072339 -0.082761 -0.093989 -0.105279 -0.111871 -0.117772 -0.119719 -0.120323 -0.116677 0.000000 0.000000 0.000000 -0.001823 -0.002143 -0.002471 -0.004263 -0.004669 -0.006664 -0.007056 -0.007294 -0.007358 -0.010391 -0.012251 -0.017995 -0.022456 -0.027879 -0.034024 -0.043342 -0.056658 -0.066502 -0.080550 -0.096310 -0.111107 -0.127129 -0.137391 -0.148935 -0.155870 -0.159618 -0.162254 -0.160976 0.000000 -0.001630 -0.001997 -0.003889 -0.004526 -0.005195 -0.007636 -0.008532 -0.009295 -0.009883 -0.011847 -0.013033 -0.016779 -0.021621 -0.023790 -0.030508 -0.037029 -0.047783 -0.058500 -0.073805 -0.089580 -0.105641 -0.125149 -0.147976 -0.164319 -0.177908 -0.190847 -0.201925 -0.210120 -0.214326 -0.212377 -0.001664 -0.003529 -0.005333 -0.006206 -0.008835 -0.010144 -0.012092 -0.013647 -0.015045 -0.016163 -0.016826 -0.018335 -0.023860 -0.029553 -0.035586 -0.042787 -0.051566 -0.061588 -0.075349 -0.091279 -0.113301 -0.138796 -0.166352 -0.187697 -0.210921 -0.231466 -0.246903 -0.257318 -0.266909 -0.272400 -0.271531 -0.004928 -0.005911 -0.007057 -0.010095 -0.013513 -0.015781 -0.018067 -0.020370 -0.022448 -0.024151 -0.025361 -0.029194 -0.037052 -0.043213 -0.048615 -0.056165 -0.068069 -0.078932 -0.097123 -0.119755 -0.144938 -0.178483 -0.211479 -0.236169 -0.262243 -0.282787 -0.290562 -0.292537 -0.304432 -0.311963 -0.303482 -0.009067 -0.010629 -0.014173 -0.018406 -0.021399 -0.024713 -0.028133 -0.031553 -0.034828 -0.037700 -0.041370 -0.049388 -0.055923 -0.063186 -0.069075 -0.078813 -0.089124 -0.104760 -0.125043 -0.154438 -0.186352 -0.219721 -0.254143 -0.286570 -0.313386 -0.325763 -0.324156 -0.324249 -0.307747 -0.270104 -0.206941 -0.012014 -0.015982 -0.020901 -0.024685 -0.029085 -0.033998 -0.040895 -0.046495 -0.051412 -0.060053 -0.067274 -0.074779 -0.079154 -0.084250 -0.090458 -0.102736 -0.115460 -0.134712 -0.161300 -0.193127 -0.226264 -0.264148 -0.301217 -0.330127 -0.352041 -0.368786 -0.329757 -0.181436 0.115916 0.489927 0.907912 -0.017701 -0.023255 -0.027925 -0.033388 -0.039790 -0.048654 -0.056741 -0.066220 -0.074482 -0.083545 -0.091544 -0.100381 -0.105473 -0.116568 -0.124114 -0.134166 -0.148466 -0.172912 -0.199733 -0.231955 -0.266840 -0.294035 -0.301790 -0.288661 -0.302461 -0.282688 0.056928 1.326728 3.966485 6.978691 8.601613 -0.027619 -0.033296 -0.039905 -0.047508 -0.058374 -0.069561 -0.083061 -0.092681 -0.100219 -0.112820 -0.121976 -0.128758 -0.134384 -0.144721 -0.156970 -0.170237 -0.191176 -0.218980 -0.242610 -0.269050 -0.291239 -0.258987 -0.090106 0.124857 0.209135 0.384643 2.621117 13.205976 42.940842 79.133728 74.335930 -0.039209 -0.047314 -0.057451 -0.070223 -0.082779 -0.100511 -0.112623 -0.122957 -0.132570 -0.134416 -0.134518 -0.140036 -0.151824 -0.171418 -0.193486 -0.212277 -0.239040 -0.265304 -0.289926 -0.309761 -0.287893 -0.054835 0.681634 1.784291 2.215763 2.939722 15.335620 108.453171 602.806152 1624.793701 1145.148437 -0.057352 -0.068241 -0.083060 -0.101303 -0.121521 -0.137496 -0.150111 -0.159787 -0.142719 -0.101677 -0.052121 -0.044386 -0.082887 -0.147094 -0.204786 -0.252508 -0.287722 -0.318916 -0.341286 -0.357073 -0.263454 0.290147 2.182223 5.281310 6.430764 8.636093 62.240116 965.390320 16351.233398 101003.125000 57395.250000 -0.083546 -0.102921 -0.123530 -0.144821 -0.165827 -0.181050 -0.195606 -0.175230 -0.078035 0.115211 0.345725 0.434704 0.336244 0.147000 -0.059474 -0.213304 -0.315806 -0.375259 -0.399612 -0.403971 -0.284355 0.484075 3.001786 7.183887 8.879411 14.446008 163.897537 5163.181641 100505.601563 101408.031250 101176.468750 -0.114254 -0.135719 -0.156885 -0.181776 -0.207824 -0.229346 -0.231481 -0.161962 0.095401 0.666543 1.482082 2.086987 2.077694 1.636138 0.887772 0.182417 -0.228423 -0.396407 -0.455501 -0.479141 -0.386796 0.177093 1.873728 4.674813 6.095768 13.566625 193.129608 7846.336426 100221.820313 100784.468750 104642.914063 -0.147056 -0.162461 -0.174214 -0.188617 -0.216767 -0.253942 -0.257922 -0.137896 0.361488 1.743503 3.989602 6.706554 8.829212 8.666531 5.338649 1.928493 0.190600 -0.361297 -0.504610 -0.552379 -0.523102 -0.285917 0.387223 1.277542 1.986260 7.242177 90.211929 1943.877197 69868.101563 101503.078125 163028.281250 -0.156014 -0.070940 0.134736 0.362303 0.301160 0.029786 -0.196846 -0.102263 0.753089 3.564172 10.719169 23.928745 37.660130 37.925617 21.367895 7.133391 1.360143 -0.190023 -0.540184 -0.607293 -0.619341 -0.556424 -0.387844 -0.202156 0.028552 2.078883 22.169411 220.361740 1871.343628 8599.787109 105678.109375 0.067031 1.194410 4.438481 8.918715 8.367854 3.839515 0.861334 0.186078 1.875275 11.433555 54.763733 165.166382 250.784943 169.827072 67.941910 18.963369 3.725427 0.246106 -0.507627 -0.640107 -0.645317 -0.613025 -0.557032 -0.553572 -0.558561 -0.112672 3.720567 26.025187 141.126648 1193.487183 29538.255859 1.575061 12.238657 69.115967 191.753174 178.629501 56.711174 9.530603 1.645648 5.563738 49.669121 422.308624 2278.193115 3426.164795 1310.534912 243.863800 51.268463 11.437668 1.930675 -0.130332 -0.332123 -0.086851 0.165980 0.407589 0.498180 0.251006 -0.055560 0.444645 5.192844 39.987167 586.356262 25248.492188 7.904863 104.135452 1293.785889 8356.216797 7593.299316 1012.472717 74.462402 6.836771 11.671727 145.793762 2091.326660 23318.304688 51322.468750 10520.624023 1266.324463 336.720734 71.209984 11.269524 2.120757 3.419345 7.746119 10.635661 12.835332 13.748174 10.436492 5.763144 3.273855 7.636867 41.812714 273.462341 4272.118164 22.415222 506.083984 22764.828125 100065.375000 100061.515625 13657.000977 322.703003 17.389429 15.088113 188.421661 3374.926514 46357.828125 100922.601563 26096.851563 22172.960938 6633.496094 640.037903 56.377510 15.553772 57.624634 163.421234 192.592438 214.179733 247.274002 153.391785 63.582729 26.365429 39.194271 263.352905 1086.010986 1653.457275 33.547127 820.543152 60610.800781 100279.812500 100244.312500 31313.326172 513.882385 23.217693 11.169780 97.600433 1157.973267 9586.980469 22678.662109 104453.929688 100496.460938 100058.945313 4315.041992 173.159485 106.401436 1294.353516 8410.931641 7579.344727 6037.303223 10313.155273 3586.225830 667.205994 186.966553 148.586533 1537.794434 11298.527344 11997.835938 34.050865 356.213196 8570.447266 100528.062500 100452.421875 5861.578613 232.066742 20.841803 16.970499 46.934521 254.573318 1480.509033 15211.377930 105960.101563 101869.468750 100244.671875 7190.144531 256.980682 640.766418 34795.417969 100318.640625 110178.484375 120558.148437 100813.664063 101560.289063 6173.095215 991.630432 296.649170 2369.805176 20659.042969 21606.914063 158.645996 410.067413 811.151306 2214.604004 1964.299194 419.214508 65.042854 67.704941 176.352676 219.625092 532.841858 8917.469727 103275.851563 162961.750000 177564.250000 48837.597656 2267.555664 177.373474 1302.187378 100031.718750 100733.429688 151234.218750 185558.812500 101968.546875 104468.960938 22535.833984 2491.779785 590.228516 802.300049 3432.743164 4262.966797 3146.585937 12296.354492 8070.322266 1360.537231 314.937744 97.304779 80.323051 632.949707 3065.133057 2872.584473 2964.816895 65834.101563 101500.664063 102451.031250 105804.000000 16958.927734 2388.895020 325.424713 608.843994 28091.513672 100553.281250 125656.695312 116869.742187 101544.515625 103599.757813 12729.818359 2915.679932 3088.379883 1264.696411 388.940765 422.612457 100138.179688 100216.828125 100617.617188 17902.054688 2423.177734 517.501465 240.538254 3040.838135 31321.148438 23984.218750 15033.960938 70206.320313 107271.132812 102342.781250 150994.093750 108634.453125 79152.859375 2659.508789 188.011368 1025.803345 6414.475586 7478.460937 31989.683594 86577.765625 18443.683594 2394.041992 4922.066406 11277.875000 3486.835205 400.140411 168.691071 101835.234375 100653.187500 106496.851562 161939.703125 101020.820313 8413.591797 518.400757 2800.724121 25360.142578 22154.396484 19575.484375 45946.753906 80106.882813 105706.578125 128514.750000 101627.039063 100228.289063 8394.585937 218.250397 66.521851 153.916397 279.962921 746.198486 1154.446289 728.548584 1030.363892 4419.354492 7250.739746 2481.661621 777.373901 2476.333740 141923.203125 103357.515625 141205.203125 123404.046875 100665.531250 63234.195313 1053.310425 541.075745 2193.355469 2516.251709 4063.431641 7496.216797 3872.195068 5131.660156 104154.312500 105671.507813 101817.367188 3973.323242 220.939224 107.675354 75.867661 45.092300 80.621201 309.283936 934.487915 3888.039795 21645.683594 21894.056641 3979.699219 6386.368164 100991.750000 106213.820313 36644.605469 36330.546875 101999.976563 100296.484375 29987.326172 703.320496 90.860062 143.209763 206.962540 410.313416 710.267273 1141.547241 3754.933350 37696.378906 87625.296875 17482.496094 1603.608032 1417.037109 3483.702881 1910.514893 301.589630 180.610855 1688.627075 7266.602051 9516.810547 51793.945313 52309.132813 13280.438477 47262.667969 104908.734375 98148.765625 5915.040039 2447.563965 12523.663086 13611.598633 2123.210205 213.336899 91.821899 70.566185 55.965633 116.175529 926.053894 6516.032227 11282.802734 52642.636719 100432.335938 18337.949219 4070.613770 52116.980469 100480.835938 100134.312500 4094.994385 355.782104 3055.655518 15253.054688 9533.220703 11167.126953 16278.934570 102337.039063 118389.000000 151610.828125 24263.820313 6985.437500 718.248596 419.850555 421.072174 315.224396 457.020874 519.595032 329.312988 177.234299 201.547836 1453.245728 13733.671875 17743.390625 9975.820312 13688.082031 5419.659668 12287.601563 105195.562500 102530.203125 100624.609375 24467.335938 489.004974 959.715210 3357.564941 2224.183350 1399.733765 10076.491211 100357.210938 101700.718750 108254.929687 27342.472656 7706.743652 609.027954 248.339340 578.210083 3034.354736 9611.288086 5851.467285 1501.288330 964.274292 828.489136 700.609985 2829.555664 3451.520996 1218.956299 1016.305786 1794.981812 9073.372070 109048.984375 107648.554687 101599.945313 14992.831055 346.534485 148.532074 264.521973 221.991760 248.318130 2323.823242 28282.767578 63022.359375 12643.044922 3978.926025 1459.408325 597.468018 3734.328369 9527.402344 53244.886719 100685.882813 102699.437500 12394.465820 4846.103516 3004.062744 734.954529 283.804596 261.891876 145.083633 211.329727 645.517822 2342.430176 15949.880859 67999.703125 23186.677734 1530.588379 181.440659 134.415253 85.952286 40.149105 48.790325 252.254974 1237.299194 1842.717041 900.237610 1655.184814 312.761078 2586.759766 76184.523438 103978.382813 128228.953125 104272.492188 186306.937500 116482.851562 79740.960938 5247.451660 734.940369 109.468437 33.061695 28.298874 80.940094 220.908386 464.647308 1106.738647 1493.349365 715.925781 200.199875 197.224274 247.237457 130.456482 38.327511 13.760105 27.990034 78.236900 157.605591 374.479950 2352.828613 226.049500 3327.163330 100091.164063 101671.679688 81488.750000 114430.976562 200164.343750 106553.671875 106088.437500 20321.833984 2535.221680 284.066681 49.642368 26.020542 30.082947 50.421764 75.036995 107.810509 116.370911 95.806229 154.152985 267.411316 277.712921 167.141373 62.385063 17.003801 7.022832 16.585642 76.218811 302.746796 1297.951538 115.665161 742.892151 10159.418945 25502.916016 6924.722168 14180.912109 104156.570313 113892.875000 200120.015625 107308.328125 51677.765625 1760.360474 299.064301 180.031708 74.418335 22.119141 12.658192 14.224652 28.229683 119.162918 459.441284 840.031677 1103.196533 1236.918335 534.268677 103.526703 14.658949 7.683006 31.189341 106.685921 287.103119 50.399300 94.432823 383.130859 616.635864 424.014832 1350.176025 13381.615234 100845.242188 112459.054687 103155.007813 106175.476563 8159.641113 2304.663574 1714.745239 424.460022 63.411678 8.817295 4.901679 25.074539 176.140594 855.535095 3016.512939 19839.804688 46390.855469 11135.172852 787.974792 58.228447 6.670744 7.996070 21.707355 149.467804 290.353485 353.326233 171.799103 64.910591 47.056534 145.185577 1071.284912 24143.546875 102528.054688 156865.625000 200202.062500 103800.804688 12996.212891 7398.752930 1338.375854 141.251663 14.760123 3.860791 18.073168 125.860130 735.233459 9940.485352 100319.203125 100070.281250 100010.382813 3653.652832 145.113541 9.297861 1.871654 3.138223 1550.038208 11136.795898 16043.197266 3422.876709 339.885773 47.047279 31.947411 193.961533 2225.893066 22374.994141 123907.937500 105168.250000 101900.679688 24180.771484 6497.945312 1265.516479 141.254318 16.511620 2.968924 8.112433 50.050186 433.706055 10296.426758 100078.250000 100021.750000 100004.203125 3652.972656 145.263229 9.703185 0.772934 0.151603 28248.277344 100083.265625 100335.531250 96423.414063 2478.646973 194.448914 34.497082 90.643448 900.964478 9815.720703 119803.328125 107435.789062 101201.250000 9831.821289 1470.470947 396.125610 73.747307 12.895608 2.275638 2.608875 16.353312 142.724701 1948.536499 23306.267578 56727.890625 12166.984375 909.307068 62.261166 5.956584 0.551350 -0.202298 100042.476563 100352.187500 102448.867188 106867.734375 8819.282227 670.778931 76.288002 159.415680 3159.783691 86671.437500 105137.375000 117622.062500 12923.237305 1316.431519 252.133957 91.901649 32.044094 9.427029 3.550280 2.338303 4.763588 27.787630 189.602463 846.254089 1317.551025 591.565552 108.329933 17.685116 3.841287 0.982081 -0.025542 37953.304688 100759.781250 108112.421875 128715.023437 14026.345703 1296.934204 116.279274 176.558517 3979.437012 100079.289063 100324.250000 100639.343750 6003.349121 379.178925 74.528809 32.331062 18.369600 18.568769 23.648779 18.400177 8.276374 5.933211 16.884111 45.995411 62.944576 42.082794 24.827219 19.483316 11.408332 4.263892 0.829215 2502.339111 21722.679688 35971.210938 19950.091797 7140.684082 860.683899 86.661667 87.256836 1142.991577 16056.844727 56982.898438 19894.773438 1892.745117 251.278625 50.859955 22.388762 38.822632 130.925186 262.402374 189.418076 58.926453 11.341844 3.262062 4.638834 11.352993 35.810593 101.914764 146.490036 83.731384 23.246046 4.212752 182.838318 627.341064 1333.213745 1862.568726 1017.910217 214.424377 33.371853 24.300882 152.903152 834.758301 1898.834229 1438.360840 628.061340 160.687012 38.002499 29.254103 163.245529 996.920593 2680.402100 1564.315063 312.305725 42.572681 5.370193 3.491506 23.357283 155.175980 681.381287 1053.365234 513.484741 99.785622 13.106550 71.911316 104.982376 190.540100 228.295822 130.873032 40.431786 9.101143 5.118815 19.799160 71.642151 167.670227 252.175247 184.120056 62.001980 20.434414 44.234310 416.602356 3664.217041 11964.027344 6760.422852 999.368164 109.932747 12.603974 5.680785 40.668926 363.622772 2086.927490 3965.352783 1420.180420 213.300262 24.163603 61.613800 55.098286 65.387283 62.433578 32.478348 10.668723 2.272690 0.732342 2.883269 10.470059 26.026165 40.537685 32.807945 15.046209 10.473093 62.960262 745.028259 9603.253906 59024.722656 46165.148438 4945.247559 327.811615 27.396530 6.648931 36.272591 317.376007 1653.934570 2864.193848 1221.318237 187.192047 21.596619 28.357872 22.110949 20.565754 17.609503 9.100929 2.796617 0.330041 -0.266061 0.063229 1.286737 3.550951 5.186687 4.562350 2.907887 8.513120 108.021736 2746.570801 100521.726563 101246.359375 100835.187500 70004.093750 1270.589722 60.985592 7.133533 16.720377 99.488594 388.948730 590.216431 296.690247 64.947975 10.021692 7.041182 5.773307 4.659217 3.577234 1.757942 0.408355 -0.251316 -0.453277 -0.429424 -0.248454 0.007007 0.215611 0.174460 0.575769 7.616278 124.794235 4331.525391 100101.765625 100291.132813 100563.117188 100477.664063 2091.500488 95.227135 9.040676 5.072204 18.638191 51.975769 69.846581 43.498718 13.340752 2.969033 1.167079 0.903145 0.612598 0.351816 0.036527 -0.229034 -0.375237 -0.426305 -0.446513 -0.445049 -0.435826 -0.427167 -0.408314 0.010769 4.922746 67.628593 1435.990479 51335.417969 100858.453125 103377.007813 28742.744141 1463.510132 126.859993 12.672461 2.738372 6.085663 13.312472 15.690332 10.245303 4.699109 2.240987 -0.023556 -0.063140 -0.122317 -0.185902 -0.246760 -0.304743 -0.344385 -0.358269 -0.367553 -0.392194 -0.421422 -0.448239 -0.443839 -0.235030 1.867689 20.447893 204.465485 2097.833984 10178.555664 14968.909180 8381.220703 1437.148926 148.142105 14.196580 5.289664 18.630327 51.096275 54.553101 32.962936 21.344261 17.663761 -0.154216 -0.174274 -0.193255 -0.214973 -0.237912 -0.252948 -0.265407 -0.280399 -0.298026 -0.320300 -0.350321 -0.381279 -0.395906 -0.324383 0.359648 4.884700 32.553448 194.821091 1000.684814 3052.760498 2713.816406 648.611267 85.458611 10.524094 11.494464 64.845467 210.507080 244.679474 153.046356 208.610321 301.934723 -0.133834 -0.143303 -0.154783 -0.169795 -0.182877 -0.189521 -0.202274 -0.212087 -0.229226 -0.248409 -0.278426 -0.312110 -0.331501 -0.332227 -0.143989 0.998312 6.884261 35.968674 156.975983 400.262299 369.298431 129.639313 24.716743 5.184779 13.997443 91.517670 311.099213 443.115570 662.906067 4218.297363 12445.690430 -0.103077 -0.112357 -0.116559 -0.121944 -0.134898 -0.139889 -0.148376 -0.155217 -0.171322 -0.187166 -0.213181 -0.244688 -0.265263 -0.280395 -0.261472 -0.001196 1.264956 6.251040 19.412380 37.139992 36.695213 17.458614 4.727495 1.829005 8.268942 47.226582 164.061768 366.790741 2826.288086 100523.109375 100201.437500 -0.071693 -0.077950 -0.082990 -0.085901 -0.090634 -0.098638 -0.105687 -0.114000 -0.126726 -0.140326 -0.161723 -0.187234 -0.210304 -0.228127 -0.245673 -0.220768 -0.011280 0.700099 2.258877 3.828247 3.560639 1.863406 0.474405 0.281113 2.717202 14.010571 51.591160 236.172745 3659.789795 100392.507813 100155.335938 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001097 -0.001193 -0.001262 -0.001308 -0.001326 -0.001317 -0.001271 -0.001201 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001015 -0.002996 -0.003180 -0.003318 -0.003402 -0.001728 -0.001792 -0.001818 -0.001805 -0.001741 -0.001631 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001857 -0.003137 -0.003473 -0.003773 -0.004045 -0.004252 -0.004379 -0.005911 -0.005901 -0.004027 -0.003957 -0.003814 -0.002235 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002004 -0.003407 -0.003859 -0.004312 -0.004741 -0.006693 -0.007158 -0.007525 -0.007742 -0.007779 -0.007636 -0.009874 -0.009440 -0.009313 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001782 -0.002060 -0.003542 -0.004122 -0.004701 -0.008381 -0.010364 -0.011280 -0.012050 -0.012652 -0.015731 -0.019711 -0.020623 -0.020753 -0.019162 -0.017013 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.002045 -0.003517 -0.004194 -0.008939 -0.010332 -0.011749 -0.013169 -0.015709 -0.021035 -0.026049 -0.028976 -0.030385 -0.031226 -0.031369 -0.030878 -0.028743 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001922 -0.003351 -0.006532 -0.009247 -0.010965 -0.012811 -0.014757 -0.022080 -0.030623 -0.037215 -0.041611 -0.044423 -0.045399 -0.043573 -0.042566 -0.045022 -0.044749 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001630 -0.001785 -0.001915 -0.002011 -0.002069 -0.002069 -0.002040 -0.001956 -0.003940 -0.008044 -0.009192 -0.011146 -0.015983 -0.022902 -0.029051 -0.034839 -0.043141 -0.049521 -0.054529 -0.058813 -0.063615 -0.068360 -0.069308 -0.065993 -0.061502 0.000000 0.000000 0.000000 0.000000 -0.001736 -0.001997 -0.002253 -0.002489 -0.002694 -0.002833 -0.002917 -0.004557 -0.004551 -0.006291 -0.010183 -0.011320 -0.014438 -0.018180 -0.022500 -0.030995 -0.037940 -0.047772 -0.056291 -0.064017 -0.072941 -0.080766 -0.088224 -0.092282 -0.094118 -0.095444 -0.094163 0.000000 0.000000 -0.001664 -0.001997 -0.003769 -0.004295 -0.004800 -0.006868 -0.007419 -0.007854 -0.008115 -0.008212 -0.008097 -0.010983 -0.014122 -0.018468 -0.021039 -0.025804 -0.035459 -0.041324 -0.050240 -0.062594 -0.074524 -0.085686 -0.097821 -0.109735 -0.118241 -0.124885 -0.130632 -0.131846 -0.129595 0.000000 -0.001785 -0.003665 -0.004349 -0.005102 -0.007523 -0.008574 -0.009586 -0.010464 -0.011173 -0.013226 -0.013406 -0.014389 -0.019198 -0.022585 -0.024561 -0.028965 -0.039067 -0.046740 -0.057798 -0.070842 -0.081597 -0.096434 -0.112805 -0.130663 -0.145034 -0.158446 -0.168446 -0.176151 -0.178879 -0.178017 -0.003199 -0.004952 -0.005867 -0.006879 -0.009801 -0.011324 -0.013570 -0.015356 -0.016939 -0.018272 -0.019120 -0.020461 -0.020493 -0.027796 -0.032397 -0.036250 -0.044177 -0.052493 -0.058993 -0.071270 -0.089282 -0.106057 -0.125569 -0.148044 -0.168637 -0.185986 -0.201906 -0.216136 -0.227602 -0.233045 -0.233394 -0.005382 -0.006516 -0.008838 -0.012288 -0.016084 -0.018709 -0.021415 -0.024146 -0.025588 -0.027592 -0.027934 -0.029675 -0.036111 -0.040958 -0.045565 -0.049833 -0.056947 -0.064695 -0.077453 -0.091977 -0.112149 -0.136622 -0.163577 -0.190527 -0.214107 -0.238055 -0.257573 -0.270087 -0.275545 -0.280466 -0.279201 -0.009883 -0.011673 -0.015652 -0.020351 -0.023907 -0.027870 -0.031970 -0.036091 -0.041484 -0.043300 -0.046396 -0.049889 -0.052400 -0.059721 -0.064362 -0.071218 -0.077307 -0.087909 -0.102241 -0.120892 -0.145279 -0.174287 -0.205244 -0.237524 -0.265440 -0.286922 -0.303789 -0.313994 -0.316357 -0.303520 -0.292212 -0.013155 -0.019198 -0.023031 -0.027561 -0.032793 -0.038784 -0.046779 -0.053343 -0.058907 -0.062697 -0.070053 -0.072520 -0.082027 -0.085771 -0.088092 -0.095781 -0.101634 -0.114145 -0.130265 -0.156012 -0.184364 -0.215645 -0.250152 -0.284512 -0.312484 -0.331095 -0.324200 -0.259082 -0.116687 0.017866 0.064895 -0.020998 -0.027195 -0.032718 -0.039249 -0.045344 -0.055834 -0.064988 -0.071949 -0.078885 -0.089315 -0.094998 -0.102794 -0.107249 -0.110695 -0.118352 -0.125367 -0.134461 -0.150470 -0.171192 -0.197318 -0.221891 -0.254689 -0.293078 -0.322142 -0.344527 -0.324969 -0.100707 0.637305 2.139566 3.488043 3.330642 -0.030177 -0.036683 -0.044563 -0.053954 -0.066689 -0.079325 -0.089166 -0.099066 -0.109334 -0.114754 -0.114902 -0.119001 -0.128602 -0.135688 -0.145226 -0.156031 -0.171855 -0.192833 -0.214530 -0.235653 -0.258253 -0.288481 -0.304687 -0.312621 -0.308269 -0.040518 1.523673 8.302235 26.278328 46.556862 40.302635 -0.042892 -0.052216 -0.064365 -0.079411 -0.093966 -0.108553 -0.121322 -0.127683 -0.115734 -0.072825 -0.031427 -0.029953 -0.072269 -0.124268 -0.169521 -0.194688 -0.212719 -0.235965 -0.260975 -0.277171 -0.300889 -0.310632 -0.269755 -0.201341 -0.070464 1.130584 10.493619 76.048920 397.382935 992.533875 746.062927 -0.062837 -0.075270 -0.092931 -0.113967 -0.131252 -0.146619 -0.155175 -0.120694 0.010294 0.298670 0.640996 0.705867 0.463295 0.143515 -0.071422 -0.192808 -0.251595 -0.284544 -0.309477 -0.329904 -0.345807 -0.319381 -0.202764 -0.025808 0.393051 4.029749 46.717548 686.258789 10188.481445 56765.351563 31166.054688 -0.089657 -0.109655 -0.135279 -0.157479 -0.177207 -0.191890 -0.173197 -0.014255 0.565035 1.963867 3.826089 4.505286 3.264665 1.740878 0.714917 0.097344 -0.195994 -0.316690 -0.363606 -0.381959 -0.396771 -0.351865 -0.202828 0.068511 0.752533 7.930731 129.064758 3659.775146 100031.679688 100102.726563 100402.539063 -0.126226 -0.147336 -0.169825 -0.196492 -0.219296 -0.232088 -0.157149 0.273022 2.154148 7.541228 15.766327 19.414440 15.094279 10.403517 5.598503 1.894531 0.273005 -0.266071 -0.408767 -0.449632 -0.467773 -0.446373 -0.334101 -0.137338 0.561048 9.058261 155.389465 5096.285156 100045.718750 100537.625000 109338.851562 -0.155468 -0.174020 -0.183385 -0.193249 -0.217852 -0.240077 -0.125654 0.678941 4.475692 16.761507 41.491905 59.603390 67.651085 66.421043 36.454502 11.628839 2.281626 0.029200 -0.427385 -0.520809 -0.551578 -0.565641 -0.537079 -0.447488 0.031693 5.314188 73.878525 1426.839844 34410.632813 102456.140625 200058.671875 -0.158420 -0.046238 0.212261 0.499722 0.433110 0.130268 -0.006038 0.930118 5.926305 24.760218 68.768723 154.184952 338.112823 445.505585 222.258469 53.352173 8.357477 0.809314 -0.392310 -0.577797 -0.625958 -0.664958 -0.676930 -0.672297 -0.473217 1.422780 18.514795 182.274109 1426.629639 7990.803711 103134.625000 0.145832 1.548856 5.852283 11.694650 11.009527 4.862924 1.319716 1.170301 6.882845 37.524475 191.205032 791.445251 1855.052856 2000.749268 804.239441 140.273010 18.617519 2.056407 -0.290132 -0.621238 -0.667081 -0.679663 -0.682968 -0.711385 -0.687244 -0.219729 3.136104 22.708858 131.000824 1355.078003 39165.363281 2.115180 16.394505 92.473061 278.675903 259.280090 80.927200 13.020939 3.034330 13.248194 144.304855 1969.510254 21438.458984 43090.804688 10481.802734 1566.494019 220.995468 31.387066 4.440609 0.139060 -0.421096 -0.303662 -0.091364 0.109856 0.124136 -0.096652 -0.285517 0.410474 5.212424 33.426601 285.441315 3198.412598 11.239261 143.315445 2167.347900 18539.779297 15132.138672 1678.954346 102.188011 10.455401 27.073280 516.684509 19299.775391 100121.398438 100518.625000 101181.640625 5314.755859 723.446960 124.779137 16.719292 2.302695 1.971578 4.443419 6.756350 9.255870 10.181448 7.265543 3.469450 2.751287 15.432044 93.381233 339.377625 997.972229 35.688141 844.443359 54336.472656 100788.195313 100684.046875 31427.835938 532.111328 26.680651 34.399700 733.295715 37898.628906 100138.820313 101856.632813 125727.320312 92752.679688 19483.425781 1330.948608 85.061127 12.777725 29.238907 75.543114 99.082718 133.343033 169.553726 103.202576 36.317257 17.791183 119.990013 1663.849731 12443.314453 12522.325195 58.790775 1494.996582 101940.281250 109314.937500 107166.906250 86612.000000 915.099243 39.124195 24.324875 323.094604 7839.083008 100446.710938 119354.773437 156817.953125 101985.843750 100110.789063 11129.460938 283.166779 62.157154 401.107300 1846.436768 1944.496216 2793.248047 4838.951172 1849.343018 362.392853 85.303955 549.391907 25265.671875 100344.804688 112207.679687 75.614594 860.353394 21459.371094 128296.296875 121209.554687 13829.039063 499.630951 45.371613 40.750404 105.829544 691.943909 4546.551758 45256.058594 103870.734375 101033.531250 100155.523438 21205.644531 404.708740 239.506516 4765.156250 60692.609375 52667.144531 99431.851563 102231.968750 50405.539063 3496.555664 349.074615 775.973755 54070.265625 100516.687500 125652.679687 272.063812 1084.780029 4035.802246 13788.340820 11422.428711 1941.985352 207.899734 239.046616 816.924255 891.142517 939.417969 4209.270020 46287.492188 196014.359375 116059.757812 101015.906250 5179.175781 218.989838 411.228729 15099.130859 100457.609375 117651.539062 110696.835937 127315.773437 188458.453125 23054.998047 1097.633423 357.035553 6315.224609 96248.359375 91975.382813 4013.827393 17112.757813 14929.655273 5068.119141 1451.152222 345.936523 272.477386 5224.286133 60603.195313 50005.441406 23014.062500 61087.578125 111783.203125 105995.117188 111423.382812 8122.569336 895.828247 128.167862 220.577667 4357.476562 48659.359375 48190.082031 104853.804688 145785.531250 200111.171875 31086.853516 1358.445190 222.160904 393.093903 1378.943848 1827.845093 100654.960938 103736.468750 110302.492187 22191.556641 1398.839111 233.836105 892.488831 67804.359375 100365.523438 112188.234375 131598.828125 111653.171875 200126.765625 105123.109375 102838.031250 10635.485352 3284.271729 367.493134 76.361214 358.363190 1510.608398 2473.856445 13026.477539 32027.458984 23532.126953 4768.278320 563.847534 269.226318 178.166306 218.599777 391.471344 106794.710937 102071.953125 103343.843750 82041.015625 5016.848633 831.264465 879.098938 54069.132813 100448.804688 119294.695312 128218.226562 102128.351563 116277.015625 38357.937500 15781.773438 33850.457031 11153.875000 801.300232 67.210236 43.438839 96.933479 190.470657 509.990814 962.207031 911.777283 443.259094 301.863129 314.525360 359.933685 1525.253906 5175.437500 200129.437500 110486.320312 102530.062500 44766.535156 18713.107422 2472.270508 368.609161 3644.747559 34968.320313 32042.580078 79901.171875 100562.226563 38985.878906 3227.969238 4439.068359 12559.669922 4996.381348 514.668030 80.925453 68.058632 64.130257 59.105339 71.109772 95.538094 131.947769 257.823486 581.566406 682.684082 1119.773682 12100.633789 120838.921875 107310.046875 81066.039063 21312.886719 11165.548828 10239.986328 1622.162476 162.514191 179.360703 594.051453 825.800415 2124.501953 3634.603271 1775.130249 727.086304 1326.008301 2077.700195 1010.817200 312.410248 557.130859 1177.897217 738.160828 186.280624 89.546478 113.231049 213.423889 390.631683 876.293457 1120.796753 2206.681396 31172.025391 170158.859375 141274.250000 30987.746094 1872.236938 1116.474854 1029.824707 298.571594 65.896927 61.075562 108.705475 153.475723 187.442215 261.838898 355.201599 477.512054 1102.525757 1523.226807 744.690430 1181.489380 11037.140625 52748.332031 18607.980469 1397.219971 169.983490 148.121277 277.366089 306.479401 488.246460 977.822083 3587.812256 17415.804688 111740.968750 119381.367187 101703.875000 4219.171875 222.135529 102.696632 89.674118 118.027077 181.177963 396.976685 875.423706 829.905762 334.644470 294.717377 373.655823 483.292236 642.791687 951.029114 7649.880371 135806.734375 162960.203125 107899.507812 5859.245605 305.492432 125.236351 139.887054 127.086540 172.307999 724.004272 3885.258057 7973.255859 13817.531250 101227.515625 100194.421875 4875.008789 179.797028 125.639915 389.150635 831.313049 898.110168 2631.304687 20289.441406 22154.576172 3185.695801 312.099121 155.979752 191.458389 882.731934 4033.508545 31939.525391 141451.343750 200116.171875 142021.953125 4813.738281 511.981537 357.077179 187.160645 69.343910 59.533218 267.448730 1172.234497 1898.500000 1083.907593 92737.859375 20128.722656 1068.289185 318.615875 667.360413 2309.548828 7123.947754 8322.354492 20087.765625 103825.296875 100540.093750 16393.996094 568.690369 64.513519 180.239990 2193.760986 14316.500000 24637.550781 103605.453125 110192.085937 28295.710938 1852.510986 1723.363403 2686.093506 1145.539062 182.393982 33.475903 54.330860 161.211990 228.311172 143.460861 7682.652832 874.047302 317.234161 1339.275024 2759.492920 5316.805664 22152.289063 108815.796875 107440.789062 200176.859375 105630.398438 10331.931641 432.265869 42.778103 113.129616 1207.511475 5891.273437 5927.433594 11799.094727 12520.171875 2761.545166 1023.521667 4844.044922 9384.960937 3131.118652 372.001740 38.651234 11.900930 20.055347 28.557266 33.834614 2565.350830 240.854523 269.652985 1683.852295 3557.281250 3273.772949 33889.050781 103225.382813 101518.343750 105744.937500 32489.896484 1990.564697 233.292755 90.560837 90.103897 209.546188 530.737061 546.887634 527.713196 513.595337 450.208618 1510.073364 4555.372559 6337.970703 2303.464600 345.816254 46.750347 7.495265 4.102474 8.514104 19.090147 782.785828 118.005920 108.692062 439.317780 808.521301 918.184082 16652.234375 100535.867188 101710.570313 111376.296875 32539.970703 4424.992676 975.052917 1316.573608 1241.196045 360.402344 91.748558 49.712112 46.168774 127.545410 1262.352661 11292.861328 26467.683594 9658.672852 3887.415283 1265.036865 192.126221 22.624041 3.335183 3.673874 9.007574 214.116074 58.663239 40.761383 66.474571 94.589622 175.542343 1730.615479 25922.468750 99858.445313 77313.023438 92134.078125 27233.775391 13389.373047 42812.863281 37973.457031 4698.620117 306.326447 29.557564 17.235590 150.687073 2465.396484 38122.000000 104742.507813 119359.304687 101270.625000 46365.976563 1938.927734 100.566528 7.473314 1.448252 2.423473 130.035950 275.214691 308.472290 142.917084 45.709404 34.747944 150.905685 816.091187 3571.116455 24219.701172 131354.328125 107222.265625 138352.703125 112225.593750 100421.859375 31198.978516 944.471191 56.813034 14.029227 97.915825 1256.583496 12856.042969 70095.843750 107170.164062 100640.281250 100053.765625 11123.502930 260.151764 13.820088 0.925039 0.247346 1332.014282 9330.593750 12229.819336 2960.683105 321.502686 48.805862 28.292398 118.650269 895.670654 17201.929688 103974.648438 102624.914063 131421.250000 156850.625000 101069.789063 26006.841797 942.700623 77.794601 12.291912 33.035812 247.497757 1739.810425 43646.460938 100735.515625 100137.953125 100017.789063 12167.644531 277.708588 13.756460 0.704270 -0.257885 21207.527344 100147.601563 100664.710938 78666.585938 2372.981445 210.509720 36.038315 133.219025 2047.213745 41605.156250 200183.234375 142227.921875 106165.914063 46933.859375 24511.826172 3982.806885 587.196655 81.530838 11.499969 8.683426 43.386063 309.305542 5647.139648 100063.320313 100019.031250 56727.152344 2086.971924 106.003922 7.573752 0.316801 -0.352327 95892.507813 100627.226563 104812.171875 111349.968750 8802.091797 662.576599 77.743256 331.639343 13392.865234 100949.804688 112311.945312 157079.796875 43095.367188 3388.071045 1466.870972 953.044434 326.317657 58.881920 9.265362 2.898839 8.456853 48.440586 372.721039 1936.310913 3368.740479 1317.344482 200.252060 22.104477 2.578820 0.073034 -0.328022 31209.185547 101054.460938 110444.710937 128740.578125 11110.856445 968.446045 101.693695 400.698700 19308.917969 100244.140625 101615.093750 104772.078125 31699.554688 1446.259399 480.501038 289.124542 110.153915 29.460884 8.609572 4.376699 3.047953 6.817686 26.654778 74.070251 100.171394 58.906082 19.631405 6.216802 2.301437 0.622506 -0.108558 2199.325195 16644.722656 27398.517578 12714.780273 3795.585449 504.903534 67.045067 164.421188 3690.897217 100454.039063 106052.148438 131163.046875 24477.369141 2552.546143 458.269226 160.037842 49.066349 27.240412 28.920189 22.044617 9.327300 3.092756 2.628894 5.163475 7.147547 9.088002 12.915736 15.181264 9.532398 3.498552 0.677626 488.442047 1011.580688 2396.045654 2300.243896 863.174866 171.812210 29.842295 41.149548 354.220551 2736.012451 11569.758789 33769.980469 19716.503906 2250.591553 299.981567 83.632790 41.378025 76.103012 131.826813 100.289185 37.247627 8.997125 1.555986 0.863899 3.906836 15.755038 40.672493 54.407398 34.054733 11.064720 2.196453 1457.008179 1103.537842 2575.373047 2534.165039 688.571472 101.823059 15.020095 8.995895 44.768742 258.538513 1471.979248 4410.310059 3149.018555 627.713196 100.510170 35.238247 66.216225 249.451675 540.354858 453.403748 148.249008 29.030392 4.384202 1.224283 5.688601 26.993654 82.726784 112.621635 64.957504 19.255005 3.655803 1787.674072 859.229370 1128.490234 1068.304687 324.551361 51.165672 7.429858 2.115989 7.530064 36.654720 144.868652 304.369202 248.936890 84.472374 23.270433 28.906506 206.389435 1767.455811 7372.569336 6184.425293 1183.029053 123.000015 13.010145 2.008047 5.136559 24.042704 68.920517 99.433609 57.599194 17.187628 3.249976 514.648682 253.611038 208.909958 169.817047 70.279594 15.802175 2.413046 0.243557 0.928057 4.780596 13.685995 23.470158 21.103716 10.122139 7.342453 49.582588 745.022522 16047.342773 100077.664063 100061.859375 8548.381836 425.448212 29.377220 2.893137 2.761384 10.954415 28.544172 38.122280 24.080315 7.895123 1.604685 67.392357 41.217640 28.687307 22.014929 10.766720 3.152309 0.381183 -0.282351 -0.249528 0.217217 1.068832 1.794730 1.628474 1.180050 4.769606 58.982670 1138.345337 31128.310547 100034.437500 100050.398438 16044.256836 609.293579 37.403797 3.571508 0.957927 2.921669 6.787447 8.465679 5.763377 2.200777 0.354624 7.247309 5.265980 3.604641 2.508982 1.237193 0.247215 -0.212259 -0.371751 -0.385892 -0.350122 -0.276956 -0.222164 -0.232060 -0.031250 2.709587 32.788532 449.722443 7174.351074 56780.542969 41983.105469 4427.757812 308.703308 31.393019 3.659317 0.428753 0.792111 1.861810 2.282201 1.597916 0.837681 0.332387 0.633196 0.471987 0.275317 0.095403 -0.080834 -0.216889 -0.300854 -0.326219 -0.335998 -0.351654 -0.369032 -0.385123 -0.396606 -0.264295 0.957942 10.481414 86.182068 609.238525 2008.700317 1841.743164 604.335083 127.128944 22.180002 3.213903 0.628809 1.634458 3.933306 4.693741 4.307448 4.789637 4.962016 -0.088061 -0.115482 -0.144945 -0.173873 -0.206874 -0.228186 -0.245750 -0.258175 -0.270526 -0.287484 -0.309363 -0.334775 -0.352365 -0.319032 0.064201 2.399312 14.287666 55.887924 145.404633 196.001236 140.381744 54.337017 12.129941 2.057801 1.143838 4.407866 10.362840 14.328732 19.804380 40.417168 55.929741 -0.125213 -0.135078 -0.144215 -0.146477 -0.167071 -0.178918 -0.186654 -0.198083 -0.206548 -0.222473 -0.242570 -0.272447 -0.293479 -0.302594 -0.219237 0.284325 2.424919 8.800426 23.234907 38.687901 33.897747 15.843039 4.422629 0.863209 1.340412 5.889571 14.776314 27.576860 84.252541 383.236420 740.730957 -0.097745 -0.105536 -0.112264 -0.115232 -0.123314 -0.132295 -0.136607 -0.144872 -0.152606 -0.167503 -0.187691 -0.210100 -0.233042 -0.247685 -0.251878 -0.157807 0.279982 1.516665 4.025455 6.442426 6.168336 3.112140 0.911335 0.118043 0.810262 4.099384 12.079678 37.520679 279.560883 2564.034180 6909.150879 -0.070222 -0.077241 -0.079721 -0.083261 -0.085601 -0.090867 -0.096541 -0.105253 -0.112701 -0.123219 -0.136814 -0.160158 -0.183802 -0.203159 -0.215994 -0.216057 -0.151607 0.050745 0.442421 0.784657 0.689452 0.270457 -0.104953 -0.212143 0.146591 1.733464 6.875041 34.273884 335.967438 3636.739014 11186.245117 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001008 -0.001066 -0.001104 -0.001120 -0.001112 -0.001074 -0.001023 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001128 -0.001253 -0.001355 -0.001444 -0.001497 -0.001518 -0.001507 -0.001454 -0.001374 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001128 -0.001308 -0.001486 -0.001667 -0.001818 -0.001942 -0.002029 -0.002060 -0.002029 -0.001956 -0.001845 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001008 -0.003025 -0.003377 -0.003693 -0.003988 -0.005645 -0.005922 -0.006102 -0.004404 -0.004458 -0.004380 -0.006699 -0.006571 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001015 -0.003211 -0.003657 -0.004096 -0.006057 -0.006645 -0.007178 -0.007587 -0.009002 -0.010720 -0.014795 -0.013412 -0.013601 -0.013473 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.003248 -0.003800 -0.006834 -0.009291 -0.010335 -0.011358 -0.013423 -0.017344 -0.022014 -0.023118 -0.023873 -0.024118 -0.019940 -0.019772 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001585 0.000000 0.000000 0.000000 0.000000 -0.003166 -0.004865 -0.008693 -0.010070 -0.011530 -0.014166 -0.017390 -0.022014 -0.026795 -0.029042 -0.030791 -0.032037 -0.032546 -0.033701 -0.032352 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001748 -0.001915 -0.002069 -0.002174 -0.002237 -0.002237 -0.002189 -0.002098 -0.001969 -0.005764 -0.006424 -0.008850 -0.010479 -0.013762 -0.018563 -0.024997 -0.029739 -0.034422 -0.038085 -0.041291 -0.047228 -0.049146 -0.048930 -0.049006 -0.046456 0.000000 0.000000 0.000000 -0.001596 -0.001875 -0.002159 -0.002436 -0.004114 -0.004387 -0.004572 -0.006251 -0.006294 -0.004862 -0.004720 -0.005577 -0.008741 -0.011053 -0.013955 -0.017141 -0.021021 -0.027200 -0.034673 -0.042322 -0.047806 -0.056556 -0.062838 -0.067293 -0.070738 -0.071069 -0.071551 -0.068106 0.000000 0.000000 -0.001785 -0.003551 -0.004125 -0.004714 -0.005271 -0.007466 -0.008094 -0.008567 -0.008882 -0.008947 -0.008812 -0.009541 -0.012107 -0.014172 -0.018173 -0.020282 -0.025673 -0.032143 -0.035596 -0.045914 -0.054901 -0.064716 -0.074018 -0.081914 -0.090484 -0.097319 -0.099445 -0.100774 -0.099809 0.000000 -0.003307 -0.003997 -0.004777 -0.005635 -0.008228 -0.009399 -0.010511 -0.011524 -0.012323 -0.014391 -0.014628 -0.015422 -0.015153 -0.020575 -0.022427 -0.024133 -0.027795 -0.033345 -0.042706 -0.052434 -0.063362 -0.071726 -0.085077 -0.098008 -0.111345 -0.123008 -0.131700 -0.138139 -0.140240 -0.139835 -0.003491 -0.004338 -0.006336 -0.007500 -0.010640 -0.012381 -0.014864 -0.016899 -0.018676 -0.020159 -0.021069 -0.021303 -0.022267 -0.023085 -0.028435 -0.030733 -0.037923 -0.042964 -0.048791 -0.054558 -0.069169 -0.081818 -0.095280 -0.111510 -0.130125 -0.145212 -0.160389 -0.174650 -0.184138 -0.191169 -0.189348 -0.005771 -0.008067 -0.011208 -0.013346 -0.017489 -0.020466 -0.023628 -0.026647 -0.029463 -0.030740 -0.031176 -0.032884 -0.035671 -0.038103 -0.041807 -0.045377 -0.049942 -0.053708 -0.062163 -0.074875 -0.084957 -0.102199 -0.121649 -0.147262 -0.167920 -0.189253 -0.210564 -0.223888 -0.234068 -0.236086 -0.238588 -0.010553 -0.014137 -0.016931 -0.022016 -0.026125 -0.030609 -0.035559 -0.040249 -0.046040 -0.048206 -0.050398 -0.052461 -0.053515 -0.055526 -0.058637 -0.062912 -0.067716 -0.072558 -0.080531 -0.096266 -0.114485 -0.133753 -0.156834 -0.185283 -0.211781 -0.233976 -0.253894 -0.267888 -0.273737 -0.275610 -0.273047 -0.014109 -0.020545 -0.024853 -0.030039 -0.036239 -0.043158 -0.052203 -0.059074 -0.064398 -0.067350 -0.070332 -0.075284 -0.076396 -0.081055 -0.084064 -0.087913 -0.091175 -0.096736 -0.108262 -0.128143 -0.146862 -0.170720 -0.197562 -0.228283 -0.258104 -0.280025 -0.286567 -0.263365 -0.205796 -0.149983 -0.151976 -0.023986 -0.029205 -0.035509 -0.043091 -0.052069 -0.062127 -0.071333 -0.077403 -0.082720 -0.090476 -0.095745 -0.099180 -0.106719 -0.108742 -0.112441 -0.115645 -0.124237 -0.132365 -0.141847 -0.161936 -0.185634 -0.209361 -0.235793 -0.266894 -0.293318 -0.291755 -0.186377 0.177469 0.871826 1.404902 1.290987 -0.032222 -0.039602 -0.048624 -0.059454 -0.073851 -0.086224 -0.094676 -0.103792 -0.105865 -0.091000 -0.077454 -0.076913 -0.098956 -0.119947 -0.134442 -0.144164 -0.155964 -0.170688 -0.185023 -0.202353 -0.218551 -0.242985 -0.277123 -0.304788 -0.307687 -0.169833 0.620482 3.586002 10.756153 17.738186 15.233502 -0.045579 -0.056299 -0.070083 -0.087268 -0.102459 -0.116358 -0.126338 -0.105929 -0.018939 0.156772 0.346024 0.370262 0.203459 0.007715 -0.119215 -0.168612 -0.190021 -0.208167 -0.231143 -0.248143 -0.262691 -0.290874 -0.313847 -0.334234 -0.278057 0.378381 4.662501 27.391035 113.606781 244.880524 190.036072 -0.066467 -0.081017 -0.100689 -0.124052 -0.139866 -0.152196 -0.131050 0.026201 0.598241 1.976196 3.749223 4.019961 2.618972 1.113754 0.258656 -0.080685 -0.202920 -0.248618 -0.272479 -0.293754 -0.312550 -0.335213 -0.355207 -0.353261 -0.149070 1.724176 18.349674 176.213333 1318.938965 4313.493164 2882.880371 -0.094985 -0.117416 -0.144487 -0.167850 -0.181752 -0.184649 -0.068639 0.613188 3.716113 13.386422 29.244162 31.598970 19.400677 7.692035 2.772395 0.779336 0.003798 -0.246737 -0.318404 -0.343566 -0.365156 -0.388510 -0.408669 -0.390120 -0.039837 3.621942 45.669247 634.796265 9312.047852 51252.488281 28438.597656 -0.131281 -0.153886 -0.180835 -0.202855 -0.221598 -0.199251 0.124896 2.187232 14.198612 69.897324 189.970673 222.432678 114.800804 50.649830 21.560322 6.798732 1.359192 -0.037950 -0.337275 -0.407846 -0.433888 -0.460729 -0.482575 -0.468678 -0.078029 3.981027 51.378853 787.837341 13343.511719 86394.046875 49417.679688 -0.161594 -0.183320 -0.197510 -0.204762 -0.225568 -0.182867 0.410362 4.772656 35.074821 216.373138 746.150818 989.436890 598.273071 476.756165 222.534241 49.720814 8.188464 0.858589 -0.285519 -0.475118 -0.516313 -0.547761 -0.570973 -0.570736 -0.305054 2.255980 28.833229 321.353729 3159.586426 13224.899414 45785.421875 -0.166164 -0.087637 0.109804 0.331387 0.289730 0.142866 0.674251 5.702554 43.105423 288.949463 1128.454346 1983.379395 5167.946289 9403.362305 2881.907715 342.804657 32.692055 3.120811 -0.121299 -0.528392 -0.596598 -0.624598 -0.648619 -0.668237 -0.562413 0.495210 8.523776 62.277470 363.156586 2161.613037 63515.871094 0.091088 1.199091 4.041731 7.810315 7.460080 3.744391 1.686807 4.720137 30.460176 175.997467 758.858032 4058.656006 47531.125000 100489.031250 23385.029297 1330.414185 80.229263 6.372313 0.121139 -0.563391 -0.650472 -0.665269 -0.673556 -0.687386 -0.674606 -0.393630 1.522874 11.021505 62.211514 575.192871 10318.282227 1.750568 11.718853 54.410572 132.006668 123.640472 46.653633 10.422307 4.906861 23.032930 212.173141 2911.158691 37774.886719 140417.484375 113353.203125 31988.892578 1609.948120 100.041458 8.543110 0.452051 -0.494304 -0.502748 -0.374802 -0.229307 -0.170892 -0.266948 -0.350326 0.206792 3.812342 21.558203 124.212410 765.981445 9.631135 87.509827 784.574951 3866.867432 3252.287842 625.886108 70.550415 10.959557 34.543388 694.330933 34409.125000 100934.898438 107903.007812 116344.875000 11300.271484 971.859131 120.057892 15.839106 1.709851 0.481256 1.349563 2.655400 4.282979 5.206813 4.239418 2.286436 2.728622 18.769436 122.400726 404.210175 549.000671 34.528770 483.592987 9377.223633 107833.734375 106085.531250 6390.749512 322.807098 28.177284 41.824604 913.280334 69798.203125 100201.085938 101459.343750 110038.882812 36166.718750 8109.529785 755.023499 60.386810 6.924794 7.935640 18.159565 29.079596 46.998772 64.079002 51.974495 25.717680 17.365181 156.335571 2779.810303 28167.875000 26694.517578 84.701134 1579.593384 47830.558594 200064.937500 200124.156250 25874.386719 878.305786 53.350880 28.656752 395.055969 12190.923828 100285.453125 107214.882812 200071.093750 102906.523438 100135.070313 4691.543457 178.019272 21.499084 56.591034 165.749039 256.991913 530.974304 962.139404 886.831787 351.130951 91.861298 802.899536 60508.394531 100365.484375 114610.445312 167.028778 2889.464111 103800.679688 135093.453125 128220.773437 53630.789063 1209.346680 74.913063 47.822807 122.662132 868.803894 5997.953125 22863.705078 102937.171875 100438.656250 100065.156250 7817.421387 248.096786 48.848976 283.740662 1088.947876 1609.526245 5376.835449 22728.400391 48281.613281 9501.146484 651.085083 1136.635864 100029.742188 100552.820313 131133.421875 681.456238 6471.706055 52817.644531 107006.875000 101556.773438 17838.470703 666.997314 314.166260 1040.210449 1146.374512 1220.415771 2228.027100 6337.858887 80825.140625 101183.007813 56901.121094 2467.246338 129.496170 64.730736 516.344177 2496.854980 3984.187744 24640.503906 134700.421875 109416.796875 100759.828125 4131.724609 466.256927 12363.980469 100286.023438 107867.265625 4307.216797 98711.398438 104063.101563 111526.570312 12918.064453 1648.593384 420.922821 7609.354004 100167.265625 88260.414063 50715.605469 101224.570313 33855.148438 18304.833984 8762.445312 2396.483643 344.365540 49.076801 44.700840 286.050476 1113.975098 2442.975098 24207.701172 118070.320312 105228.289063 100545.289063 6394.025391 202.314117 488.948303 2236.947021 2794.145996 17419.181641 177563.953125 138032.937500 103451.351563 7655.562500 399.332153 1133.354858 100032.203125 100592.570313 131128.687500 154171.046875 101721.445313 106488.750000 21633.236328 3916.699463 665.544128 194.875488 48.840599 36.128185 115.225822 335.227570 762.650146 4406.858887 90359.046875 100864.773438 45754.386719 1510.118164 102.945068 129.029877 522.538574 1303.606567 52137.734375 126238.796875 200115.093750 39780.339844 2575.734375 234.874222 1033.807373 96030.421875 100735.906250 146313.171875 143645.906250 103676.812500 108024.781250 18722.417969 1463.172852 593.104370 287.525787 73.121407 48.836823 132.336716 363.078278 516.466919 561.699646 1719.679565 2979.850098 1113.164551 184.279388 156.028107 885.959045 10353.778320 57284.921875 117838.281250 107830.179687 65888.796875 5922.681641 775.653992 168.738846 248.160660 5235.260254 60782.058594 56206.753906 104252.726563 113625.179687 141110.406250 13367.542969 997.338318 351.719147 186.827209 65.716385 58.615417 142.217163 360.403870 523.886292 463.654510 267.386841 141.939865 83.115379 156.002182 916.742737 6334.193359 101505.367188 103710.929688 102670.421875 31307.429688 3885.262207 913.508423 318.894684 107.569069 68.193771 248.254578 834.896973 1285.549805 4475.616699 13587.220703 22395.189453 5630.294922 546.446350 151.254883 96.385254 115.224892 259.539734 374.947906 391.134216 809.187195 1443.674438 656.796509 131.913757 63.803612 370.804230 4190.759766 22358.751953 107249.015625 118587.117187 200142.812500 36757.667969 1696.490723 202.926270 96.818336 81.543182 139.527481 356.814178 993.922485 1083.361694 689.821655 1045.441162 1620.712769 690.328247 167.877090 117.499123 232.640808 1284.624634 6569.466309 8012.701172 2529.070068 1316.749023 1789.036865 841.200195 150.661041 58.152393 333.988434 3761.295166 15348.886719 44222.371094 111619.484375 112346.132812 101261.929688 8464.458984 202.304657 54.203445 171.522339 456.767365 1391.034912 6065.065430 8485.853516 4011.819824 865.464661 210.799637 92.297363 110.062386 613.292297 2785.537598 27356.720703 102032.593750 105604.671875 42230.281250 4221.893555 1581.572266 522.316956 145.545609 48.585209 108.579826 697.735718 1863.859009 2472.333008 5251.074219 102821.539063 100238.046875 10106.233398 212.478989 61.944431 234.525314 642.754150 2233.111328 18781.068359 108613.523437 101693.671875 18220.285156 576.347107 66.523308 415.666138 11266.764648 102466.992188 176197.562500 104944.625000 104488.046875 106620.812500 12788.408203 4589.686035 3251.838623 1181.697754 187.055618 43.113083 84.292633 182.447678 240.861130 271.915588 121314.281250 51307.113281 1775.775391 100.799973 74.914261 227.269913 689.772156 3206.131348 103986.539063 103693.867188 100824.984375 100115.914063 1754.559570 95.166901 1018.709717 76101.765625 101663.945313 200055.890625 115371.757812 101324.445313 103626.054688 10720.924805 39937.632813 100283.945313 21218.722656 1227.314087 82.797134 19.050432 27.131351 33.954609 30.210609 37219.082031 1719.144165 214.020752 75.890266 117.836502 329.832245 2483.492920 35380.062500 151104.515625 134587.390625 102046.515625 99105.312500 1276.885010 79.887054 591.067871 22760.394531 100367.226563 106580.093750 76099.195313 77891.765625 9501.242187 10870.941406 100766.656250 100277.992188 100062.554688 3664.361816 148.196106 11.916910 4.799964 5.335241 5.236462 9847.341797 976.066650 118.605606 69.888817 114.629807 384.750824 7374.767090 100330.390625 103223.640625 133312.109375 47663.093750 4725.829590 328.850006 139.296921 218.977554 1238.027466 6332.088867 4635.795898 1605.320557 1296.787476 1507.423340 12845.869141 114672.468750 104746.164063 63429.234375 2521.860840 129.426086 11.382018 1.456711 0.954786 1.496671 4838.328125 794.264465 94.889442 35.744202 53.683537 235.242905 4366.700684 100082.523438 100282.820313 100961.187500 5512.746582 855.799866 1121.305054 3707.869141 3391.003418 851.441895 245.420105 157.612549 103.671799 380.947601 9419.098633 100842.726563 106801.859375 114308.000000 9615.886719 1272.666870 168.204376 20.227537 2.119734 0.213182 0.442760 1203.288818 279.889923 51.629288 18.023479 18.473465 69.279686 695.409668 6614.385254 17827.626953 7700.547852 3735.342529 6423.697266 26241.234375 100474.273438 100089.328125 17610.742188 713.025085 55.808430 37.872246 564.272461 25685.863281 100285.726563 102977.101563 138325.843750 109525.796875 19575.050781 1155.208618 75.524796 5.864715 0.241597 -0.105405 184.726135 145.230774 125.520660 74.962128 31.350334 21.892132 81.241158 334.192444 780.408264 2817.279053 47177.769531 103432.328125 195921.171875 104837.382813 100728.601563 100649.117188 2703.787354 131.831055 33.525021 332.568481 9379.000000 100567.132813 117696.710937 200075.593750 103680.468750 100153.007813 5548.919922 188.258041 10.475454 0.511913 -0.309334 367.418457 1488.873169 2160.668457 1024.289917 308.375916 65.488174 22.740456 58.530006 372.645721 6325.934570 101475.976563 103415.367188 200272.453125 117088.382812 106995.234375 109331.742187 4531.887695 318.124878 36.944679 93.371223 975.219116 7711.707031 33668.304688 104730.640625 100491.648438 100043.437500 6033.071289 187.623199 11.035229 0.512504 -0.346117 2708.294678 26316.833984 43916.601563 19355.058594 5131.225098 587.354004 61.146706 106.479782 1458.745972 22178.970703 173413.937500 126369.117187 115408.289062 110729.828125 138253.234375 74057.882813 9830.330078 625.085754 46.520557 23.275579 100.961647 451.244263 3270.869629 46486.851563 100052.000000 23302.769531 1222.555908 78.023132 6.029605 0.198148 -0.357549 7376.198730 105548.562500 200021.625000 119305.273437 100925.710938 3711.699463 176.019592 277.281921 8576.121094 100576.750000 105248.695313 117663.265625 22629.964844 6629.717773 23952.152344 35106.933594 6153.981934 494.227997 38.846188 7.246435 15.632895 55.483135 271.833862 1151.779541 1936.620972 787.145508 136.350952 17.339264 1.775155 -0.118105 -0.359701 3736.538086 46569.601563 151405.640625 108005.375000 100603.070313 7870.772949 267.463379 317.364014 12223.875000 100784.093750 112392.000000 186662.062500 70048.101563 10097.336914 8613.566406 4687.372070 1163.292236 155.744583 18.334249 2.926490 2.634612 7.376416 23.698753 56.531124 74.319809 45.980446 14.207351 3.050809 0.470547 -0.158893 -0.315394 981.572083 7159.358398 102377.585938 104232.023438 70749.835938 2984.882324 159.923676 146.865723 2759.206543 65992.546875 200027.062500 186282.546875 105104.484375 40652.683594 12032.994141 2680.635498 326.185425 47.571663 9.332186 3.497421 1.523262 1.067889 2.031529 4.117091 4.882806 3.978513 2.519996 1.719882 0.943183 0.197649 -0.179936 6295.418457 8990.537109 73157.882813 76430.671875 9828.449219 735.636292 68.813095 42.769493 373.517914 4759.513672 103973.820313 102005.726563 100911.453125 33800.710938 4115.409668 959.356934 135.513092 25.697403 15.605039 11.731064 5.661045 1.633029 0.199962 0.083133 0.525814 1.609671 3.217634 3.912756 2.620132 0.990895 0.045578 100646.984375 27132.150391 100648.023438 100249.406250 14729.218750 669.760742 44.108227 12.814084 71.853462 864.057800 13443.750000 95932.773438 51346.671875 4630.594727 593.963684 166.636398 44.097260 41.324234 68.523064 59.139740 26.450281 6.807323 1.021488 -0.065649 0.393540 2.136842 5.073492 6.356506 4.335762 1.637779 0.227512 100319.203125 21417.703125 38472.753906 37927.425781 4691.856445 321.447113 25.526194 4.202899 14.321101 99.114059 598.384155 1663.448364 1238.020996 328.293427 74.204124 28.935535 45.406948 196.423416 490.620483 426.426086 140.596100 26.961424 3.740019 0.242185 0.323370 1.991592 4.523627 5.679042 4.086136 1.523604 0.154780 14871.830078 3144.481689 1984.200806 1802.365356 515.126587 69.574776 8.133204 1.109579 2.136496 10.935893 36.788769 70.116203 59.616039 26.185253 10.239580 15.391361 108.683136 789.963928 2650.284668 2262.494873 516.188477 70.388359 7.899024 0.642214 0.097999 0.900731 2.268034 2.887857 1.928501 0.665629 -0.063541 548.055481 240.206818 132.200439 104.155190 43.596886 10.601248 1.660436 -0.004825 -0.024696 0.847080 2.790347 4.412843 4.066330 2.315275 2.390375 15.222188 136.947937 1135.588135 4310.475098 3657.305176 735.104858 90.272636 9.665268 0.862426 -0.137225 0.069511 0.490769 0.701435 0.426903 -0.001365 -0.259327 30.178522 19.176733 11.515638 8.148584 4.127226 1.201953 0.046188 -0.289603 -0.325621 -0.235917 -0.091222 0.028185 -0.008435 -0.033255 0.902655 9.043229 73.923622 480.342224 1424.943237 1325.182983 347.586517 52.633137 7.229120 0.720173 -0.239767 -0.258321 -0.103864 -0.034660 -0.085418 -0.176022 -0.238345 2.127363 1.597386 1.040552 0.624662 0.233453 -0.081396 -0.233116 -0.291541 -0.303960 -0.310800 -0.310502 -0.315043 -0.335573 -0.296023 0.181173 3.243654 21.010933 90.232552 205.973404 186.478302 75.367218 19.356581 4.003830 0.427602 -0.246364 -0.204235 -0.008074 0.162745 0.327888 0.594728 0.705135 0.039990 -0.004461 -0.063183 -0.111912 -0.160200 -0.198603 -0.224956 -0.235453 -0.243901 -0.254644 -0.270905 -0.286881 -0.308840 -0.305577 -0.158736 0.673084 3.981171 13.454392 26.184595 28.014322 16.977964 6.730805 1.751084 0.101241 -0.201354 0.021883 0.465219 1.112702 2.484570 5.481401 7.247361 -0.110386 -0.121803 -0.131000 -0.136181 -0.149875 -0.165063 -0.172900 -0.179058 -0.186901 -0.196691 -0.212289 -0.232865 -0.256182 -0.269746 -0.248714 -0.066773 0.591416 2.108345 4.215588 5.225897 4.221882 2.014845 0.466070 -0.145543 -0.190099 0.165129 0.950660 2.784701 9.428174 27.483168 41.388306 -0.091289 -0.100267 -0.106240 -0.109901 -0.113823 -0.121378 -0.125446 -0.132085 -0.138231 -0.146660 -0.161657 -0.178767 -0.204352 -0.216526 -0.228396 -0.202237 -0.093374 0.198521 0.622437 0.925743 0.753927 0.321677 -0.095065 -0.266686 -0.220190 0.101669 1.044892 4.522545 22.407648 85.081139 144.741455 -0.070256 -0.074031 -0.078501 -0.081463 -0.081800 -0.084476 -0.089784 -0.092731 -0.101714 -0.107495 -0.119191 -0.135046 -0.159350 -0.177628 -0.183042 -0.197730 -0.191788 -0.152486 -0.078520 -0.029953 -0.059134 -0.163267 -0.252402 -0.290616 -0.254862 -0.046720 0.759448 4.687560 26.145844 103.431618 178.233948 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001037 -0.001120 -0.001185 -0.001236 -0.001244 -0.001236 -0.001193 -0.001128 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001081 -0.001227 -0.001364 -0.001486 -0.001574 -0.001643 -0.001667 -0.001643 -0.001585 -0.001497 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001008 -0.001193 -0.001394 -0.001596 -0.001779 -0.001956 -0.002090 -0.002186 -0.002218 -0.002186 -0.002106 -0.002986 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001044 -0.001262 -0.001507 -0.001779 -0.002060 -0.003805 -0.004154 -0.004439 -0.004619 -0.008322 -0.009977 -0.010074 -0.009969 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001030 -0.001280 -0.001562 -0.004784 -0.006813 -0.007480 -0.008066 -0.012582 -0.013362 -0.013420 -0.015577 -0.015141 -0.015398 -0.015341 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001619 -0.001653 -0.001664 -0.001630 0.000000 0.000000 0.000000 0.000000 -0.001236 -0.004480 -0.006559 -0.008969 -0.010035 -0.013804 -0.016590 -0.019080 -0.023160 -0.024588 -0.023873 -0.024540 -0.023361 -0.025596 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001641 -0.001836 -0.002026 -0.002174 -0.002285 -0.002351 -0.002351 -0.002301 -0.002205 -0.002069 -0.001888 -0.003917 -0.004523 -0.008226 -0.009560 -0.013505 -0.015469 -0.020447 -0.026332 -0.029055 -0.031538 -0.033726 -0.036593 -0.036015 -0.036579 -0.036327 0.000000 0.000000 0.000000 -0.001676 -0.001969 -0.003642 -0.004042 -0.004407 -0.004699 -0.004873 -0.006626 -0.006655 -0.006551 -0.004948 -0.004702 -0.006539 -0.006671 -0.010283 -0.012955 -0.015709 -0.019452 -0.023826 -0.030779 -0.034779 -0.040255 -0.045152 -0.048613 -0.050339 -0.052088 -0.051494 -0.051541 0.000000 0.000000 -0.001875 -0.003790 -0.004415 -0.005055 -0.005654 -0.007954 -0.008603 -0.009152 -0.009446 -0.009545 -0.009355 -0.008963 -0.009562 -0.010256 -0.013585 -0.016161 -0.021470 -0.024080 -0.027067 -0.030959 -0.040042 -0.045880 -0.052992 -0.058784 -0.064152 -0.071159 -0.074411 -0.073381 -0.073484 -0.001607 -0.003533 -0.004300 -0.005142 -0.006067 -0.008787 -0.010078 -0.011271 -0.012374 -0.013229 -0.015294 -0.015498 -0.015196 -0.015759 -0.015041 -0.016947 -0.020464 -0.024192 -0.026465 -0.029714 -0.036603 -0.047565 -0.054216 -0.062572 -0.071122 -0.079406 -0.089139 -0.096212 -0.100175 -0.101708 -0.102473 -0.003732 -0.004652 -0.005726 -0.007984 -0.011336 -0.012250 -0.015865 -0.018066 -0.020043 -0.021645 -0.022597 -0.022818 -0.023550 -0.022740 -0.023969 -0.024877 -0.029300 -0.033342 -0.035702 -0.042609 -0.053030 -0.063010 -0.070959 -0.080093 -0.092195 -0.107481 -0.119494 -0.130090 -0.136820 -0.140536 -0.144502 -0.007075 -0.008514 -0.011845 -0.014232 -0.018549 -0.021788 -0.025225 -0.028708 -0.031770 -0.033034 -0.033732 -0.034257 -0.034745 -0.036465 -0.037133 -0.040036 -0.044076 -0.045655 -0.050945 -0.058966 -0.065930 -0.079293 -0.094077 -0.108846 -0.123715 -0.139394 -0.155369 -0.170538 -0.182375 -0.188431 -0.187640 -0.011065 -0.014877 -0.017863 -0.023285 -0.027763 -0.032906 -0.038316 -0.043637 -0.048122 -0.051854 -0.053935 -0.055667 -0.053165 -0.054734 -0.055922 -0.057854 -0.058004 -0.060267 -0.066848 -0.077318 -0.087256 -0.101165 -0.116108 -0.136441 -0.158319 -0.178674 -0.195857 -0.210576 -0.224282 -0.232163 -0.233542 -0.014769 -0.019934 -0.026323 -0.032022 -0.038947 -0.046705 -0.054650 -0.063317 -0.067615 -0.070524 -0.072359 -0.074280 -0.075961 -0.074395 -0.077693 -0.083103 -0.081806 -0.082405 -0.090179 -0.101441 -0.116266 -0.134808 -0.154264 -0.177620 -0.197928 -0.219358 -0.232920 -0.233435 -0.221622 -0.210995 -0.213028 -0.023389 -0.030636 -0.037504 -0.046016 -0.056071 -0.066890 -0.075237 -0.081578 -0.087249 -0.089642 -0.091370 -0.096674 -0.098761 -0.102913 -0.105618 -0.107781 -0.110123 -0.110953 -0.121039 -0.134672 -0.151793 -0.168709 -0.192013 -0.218216 -0.239201 -0.253627 -0.220853 -0.102602 0.123251 0.297525 0.227086 -0.033542 -0.041590 -0.051509 -0.063872 -0.079236 -0.090848 -0.099623 -0.103738 -0.086592 -0.040371 0.004990 0.015259 -0.030525 -0.088491 -0.119102 -0.135568 -0.137978 -0.147859 -0.155744 -0.172465 -0.185077 -0.204845 -0.230067 -0.251183 -0.270571 -0.227701 0.047611 0.919280 2.707209 4.239839 3.866538 -0.047276 -0.058798 -0.074132 -0.092626 -0.107387 -0.120071 -0.116367 -0.055718 0.166221 0.666945 1.233585 1.306058 0.847028 0.294260 -0.024225 -0.139598 -0.172194 -0.184832 -0.200122 -0.212110 -0.223573 -0.244639 -0.267517 -0.291197 -0.280532 -0.051734 1.236091 6.460208 19.463451 34.493626 29.627033 -0.067398 -0.084052 -0.106146 -0.128569 -0.142501 -0.146187 -0.077841 0.340622 1.993567 6.670018 14.128346 15.013558 8.966496 3.370235 0.850384 0.070729 -0.153580 -0.214116 -0.235538 -0.254511 -0.272770 -0.288329 -0.308067 -0.331214 -0.270972 0.382229 4.363456 27.202782 113.294739 229.974838 182.714767 -0.097382 -0.122099 -0.151225 -0.172054 -0.181955 -0.157434 0.161367 2.260133 13.483875 65.564896 176.455734 201.772491 97.317001 26.086691 6.692615 1.678254 0.230770 -0.178819 -0.272294 -0.304512 -0.323848 -0.341406 -0.363764 -0.384939 -0.261633 0.866371 9.385916 69.380188 365.773071 922.173584 737.620483 -0.132862 -0.159571 -0.186164 -0.202541 -0.212493 -0.105273 0.862370 8.293565 70.447548 592.559021 2869.505859 3670.473877 1023.856079 189.622940 51.291420 13.532533 2.646038 0.198903 -0.267483 -0.359026 -0.382569 -0.409460 -0.435300 -0.451448 -0.312290 0.940889 10.483417 78.838631 454.397552 1198.125122 1280.317383 -0.164112 -0.189419 -0.209029 -0.219696 -0.219629 0.022466 2.047157 19.660727 233.472366 3376.635742 34351.980469 46494.289063 8138.555176 2133.929443 766.013306 131.162582 16.758890 1.705039 -0.144275 -0.411343 -0.462863 -0.490362 -0.509226 -0.531447 -0.439997 0.401334 6.400098 42.201965 204.239136 598.619995 2238.658447 -0.179895 -0.140578 -0.028172 0.101383 0.141898 0.401189 3.209496 26.534725 313.565704 5572.121094 69955.710938 102886.890625 58467.441406 100648.031250 23342.281250 1321.561768 78.568077 6.100891 0.163984 -0.453880 -0.541224 -0.567644 -0.588399 -0.601800 -0.555601 -0.178521 2.065822 13.551193 60.593235 293.980713 2640.458496 -0.012002 0.645426 2.164012 3.941531 4.324254 3.078243 4.275278 21.803274 172.055435 1725.278198 11733.690430 39599.289063 103495.078125 100466.234375 100068.632813 7817.750000 214.887497 11.901441 0.527960 -0.484225 -0.596555 -0.615058 -0.607582 -0.572533 -0.492825 -0.318652 0.350918 3.454379 18.248493 121.116562 909.906860 1.202912 6.558864 23.125988 47.673145 50.632935 29.069201 11.757554 13.630853 61.437321 345.274353 2243.759277 38594.316406 112487.796875 103432.562500 100358.242188 9345.905273 249.577209 14.194213 0.695241 -0.495772 -0.566994 -0.471198 -0.303711 -0.046272 0.242249 0.484366 0.664443 2.118461 9.331942 39.178890 151.437820 7.162535 48.461403 248.881058 681.511597 703.142761 306.488831 74.760506 17.031162 32.176846 322.415283 6838.241699 104745.875000 200056.593750 146369.328125 52996.597656 2096.693848 129.043701 12.291888 1.000625 -0.182001 0.207594 1.155404 2.451336 3.578148 4.266942 4.168708 4.106635 11.465918 55.329926 169.272415 214.855087 31.540558 347.178040 4096.844727 23234.845703 19044.417969 3690.452881 463.524841 48.609226 29.054060 373.119080 11168.262695 100393.546875 102277.625000 100461.960938 5851.004395 1098.658203 175.873123 22.529842 2.727746 1.850936 5.539409 13.219193 25.323055 35.092449 36.497562 24.131710 16.445135 72.381821 797.904175 4381.248535 4410.833984 99.476929 2183.282959 100764.351563 104149.578125 108264.242187 47064.820313 1698.264282 101.846535 23.287123 180.719589 2880.541992 37981.019531 87004.804688 21871.970703 18535.412109 5619.885742 599.405090 49.605484 6.778326 10.378035 35.837261 110.782684 255.437286 510.844666 655.544189 307.727997 77.685303 284.208344 8357.916016 100145.968750 102650.468750 255.169373 5720.595215 101440.531250 102169.273438 104235.945313 102748.710938 2540.621582 121.708115 31.690355 68.181953 361.094330 1663.763062 3626.745850 13118.001953 34477.941406 10193.230469 848.536987 62.737724 11.995046 35.658188 175.344543 884.216248 3113.356934 16382.613281 46016.554688 9251.060547 612.559692 408.344543 13648.343750 100216.234375 105113.023438 1531.577271 25772.605469 195910.796875 128466.359375 102423.437500 57213.062500 1174.523193 168.096588 339.913177 394.945801 572.596680 862.899536 1030.797607 3625.621826 7261.581543 2890.722168 369.288055 40.283596 18.597511 76.542686 555.633301 5481.810059 30751.052734 111723.312500 101604.343750 100186.500000 4082.943604 263.774902 2556.550537 22855.292969 22362.000000 12313.200195 100611.164063 105286.453125 131199.031250 40905.652344 3323.333740 336.071228 1427.820068 9288.166016 8811.069336 13207.857422 25849.066406 7570.823242 1371.056641 812.379578 367.846161 86.931625 28.191494 47.064209 164.944397 945.195007 9173.592773 57066.082031 121636.828125 102312.570313 100203.703125 5810.744629 172.521637 203.530014 720.596313 1215.365601 21836.755859 101712.890625 101340.218750 100778.585938 31602.826172 720.412109 370.111237 10154.904297 100300.468750 107831.523437 105926.984375 101632.406250 103090.703125 4840.057617 475.941895 100.848213 40.009922 70.795578 208.907532 686.943298 2997.093994 6171.307617 13016.641602 84692.218750 100872.937500 45699.984375 1381.404053 100.427727 158.399689 730.294617 2946.766846 6737.836914 104136.648438 102684.820313 100548.148438 6656.918457 281.323578 316.242310 8370.208008 100376.523438 112277.632812 107466.734375 156853.484375 200095.640625 45391.394531 1707.048340 113.606964 49.742538 173.944778 554.019409 2240.745361 13494.327148 18027.851563 4788.069824 2296.613770 3067.817627 1114.477783 205.374634 399.330688 1799.333862 19817.300781 102987.695313 10488.772461 6522.041016 10820.243164 4305.535156 571.701172 76.055550 108.478462 1127.446533 6487.987793 8165.166504 51163.414063 200271.312500 123389.734375 101356.000000 5388.595703 160.289429 46.032822 157.177948 490.737183 1946.038574 11465.257813 16870.458984 8961.198242 2794.960205 397.976746 109.105118 564.667969 10338.028320 61213.164063 115194.867187 102233.984375 38532.429688 3139.159912 670.806824 250.073273 82.234596 68.426826 137.718597 315.151917 813.943176 1425.014404 7471.508789 103399.679688 101249.875000 100214.531250 3156.843994 119.435555 40.955559 115.522148 298.599487 725.495483 3115.184326 26575.914063 100749.570313 27111.466797 1282.765747 145.647247 2560.478027 100234.296875 110188.062500 200115.968750 105797.875000 32373.312500 6869.073242 584.148987 77.031929 95.444397 600.545166 1712.724976 3136.320312 14842.928711 15225.438477 4896.219727 8720.527344 18500.484375 5370.513184 458.867523 89.778618 206.472336 947.760132 4088.603271 4780.132324 4149.168945 39436.855469 101013.273438 37053.636719 1633.906616 149.324646 2343.494873 100112.789063 102460.914063 186211.250000 104644.234375 101686.554688 88622.296875 2268.314941 117.480225 327.834869 4377.751953 21223.654297 28820.746094 101046.625000 102013.531250 28374.021484 2221.456543 657.708740 247.426361 144.690369 1053.323730 4931.780762 17651.386719 100685.507813 102643.046875 56011.531250 101187.031250 31198.259766 6121.370605 631.093445 99.971313 440.189758 6927.501465 31497.537109 12252.057617 7326.250488 101937.375000 100176.289063 2656.633057 122.284615 407.381470 6330.791992 32231.052734 45780.535156 107777.320312 200120.359375 146407.875000 12342.941406 558.085022 85.557915 749.481506 34845.593750 101659.125000 200034.390625 108718.359375 109640.429687 200199.031250 103407.648438 105683.101563 13802.555664 3560.587891 412.092896 82.851799 246.679306 525.707336 392.757355 240.941559 48370.199219 8912.707031 678.992310 62.741867 146.266937 1232.044678 4416.877930 9361.495117 126962.671875 170002.296875 107877.546875 100474.445313 1407.647095 107.866493 2145.296875 100053.156250 101224.187500 156746.171875 154302.281250 106618.812500 186502.890625 111003.703125 163000.500000 102294.007813 100117.828125 3976.211914 150.237595 23.053442 24.286478 22.295120 17.112700 37383.546875 2532.738770 240.980560 32.836048 36.147747 154.795975 589.085999 2737.477051 35252.324219 103472.218750 100815.781250 56721.921875 1011.503479 81.746658 1103.383179 85409.960938 100279.648438 104315.914063 51085.890625 43129.421875 13530.473633 61539.257813 104817.367188 100696.437500 100096.226563 14609.166992 299.377502 16.837433 2.713700 1.778564 1.405256 104755.281250 11365.716797 449.443298 34.459660 17.183819 75.429207 635.805420 5286.448242 15639.008789 27203.716797 25008.455078 3203.111084 249.607788 112.785645 251.313812 2580.476074 16729.753906 10363.942383 1764.863647 1063.838257 2343.204346 34952.921875 125888.890625 107239.867187 100668.007813 8585.827148 237.913742 14.181793 0.964910 -0.202508 -0.258342 100415.570313 13376.464844 458.569885 31.038937 10.648441 48.945690 456.348267 3396.465576 7951.214355 3545.227295 949.791992 339.338837 661.466187 2280.823975 2114.889893 655.037842 319.557495 219.901016 119.130768 494.021912 14822.102539 102419.703125 131312.218750 177758.312500 23407.550781 1407.368774 121.604172 13.706540 1.186855 -0.336488 -0.444402 25674.750000 2658.086914 183.283081 19.422779 6.846425 19.706501 122.927383 599.457214 1088.114990 670.946960 498.832794 1234.127319 12577.374023 100143.257813 100131.226563 10303.536133 554.563843 60.863457 49.549278 785.595215 51521.320313 101104.898438 102029.804688 104014.726563 21213.113281 2072.360107 257.649292 28.611689 2.661905 -0.161365 -0.445139 925.086548 272.139526 76.366402 44.949841 24.725950 12.731229 23.771580 69.809357 141.833160 387.182343 2406.554199 8543.950195 103445.773438 101108.179688 102920.945313 99801.953125 2755.218994 219.504166 53.564774 514.517212 16801.406250 103777.289063 105215.078125 116951.828125 44050.679688 9513.875977 745.744385 55.763374 4.649782 0.048932 -0.402588 118.786850 251.068680 576.993896 755.102905 382.124207 87.127022 17.622673 22.096519 104.395325 779.886047 6955.498535 25308.052734 107381.265625 109687.359375 200117.781250 177504.468750 29654.314453 1194.179321 87.440346 188.182739 1962.866821 15383.941406 33251.929688 25564.115234 42595.015625 10232.490234 791.781433 54.996071 4.611394 0.089207 -0.364518 298.387909 2051.097900 16913.847656 46619.398438 13383.241211 986.671814 78.901810 43.864315 359.632050 2666.226318 8992.961914 14160.362305 14830.481445 122124.281250 163351.531250 106730.242187 100396.593750 3684.070557 137.992615 59.722836 302.413635 1046.624023 1688.180542 3350.969727 5190.784668 1945.294312 245.216522 27.329277 2.633623 -0.057724 -0.348345 733.067505 16141.329102 101955.523438 100659.000000 100112.960938 9321.673828 269.164917 101.682472 1252.854492 17797.271484 71215.984375 25414.021484 7073.770996 39569.027344 113474.921875 102993.875000 100298.835938 2672.789795 110.977806 18.479420 43.979328 113.078674 174.054459 296.592804 355.249176 178.943375 43.548012 7.224242 0.757952 -0.226274 -0.338574 878.199829 38993.042969 101570.460938 100904.320313 100246.179688 23336.542969 430.744812 119.703468 1602.455444 26874.353516 131200.890625 131742.109375 116964.250000 110650.921875 128635.375000 80643.375000 8300.719727 572.365540 43.363232 5.466431 6.097211 12.107038 18.803638 26.819647 28.062252 16.974646 5.900497 1.194065 -0.025988 -0.297656 -0.322136 1366.829834 14239.391602 125886.570312 125733.289062 103676.898438 6832.317383 241.337311 70.476234 679.856812 10714.414063 113365.343750 106336.359375 128901.218750 186382.203125 101912.382813 78377.671875 2130.108887 140.230988 14.408711 1.872556 0.706263 1.133825 1.799002 2.357058 2.391127 1.504138 0.572384 0.066152 -0.174355 -0.269241 -0.295291 58109.828125 85292.882813 108181.523437 119317.851562 75806.531250 2055.457764 115.660782 30.852097 248.821091 6394.559082 100704.164063 100758.039063 106671.945312 181990.500000 101256.257813 14679.910156 706.194275 51.333858 6.794754 2.003995 0.717140 0.073653 -0.146548 -0.159737 -0.104126 -0.048769 0.020442 0.050911 -0.052057 -0.181310 -0.263192 102656.531250 200064.546875 102114.304688 100426.000000 100204.453125 2494.170166 92.586037 14.268648 80.516853 1346.359619 34371.269531 100101.656250 100602.750000 11169.155273 3470.876221 934.996277 125.832520 19.263775 9.931384 7.790222 3.878225 0.998119 -0.095169 -0.370518 -0.327633 -0.145583 0.091635 0.191838 0.096449 -0.118431 -0.243332 101135.203125 141858.875000 102430.820313 100085.992188 41868.921875 1057.632568 52.813435 5.959013 17.152151 139.086639 983.080750 3117.261963 2303.855713 559.858276 182.940552 69.224129 21.361177 20.938545 35.452274 32.982525 15.010518 4.008155 0.508898 -0.280131 -0.334877 -0.180509 0.043105 0.161236 0.045230 -0.141244 -0.258604 100175.859375 19950.224609 10793.530273 10201.840820 1933.321045 176.228180 15.674805 1.890007 2.643610 14.136234 48.974155 95.275581 82.305161 38.351185 15.949383 8.632573 14.031937 46.469524 94.281769 88.594299 36.437023 8.555939 1.287480 -0.153508 -0.345967 -0.266377 -0.130940 -0.061930 -0.116074 -0.230713 -0.295556 2245.139648 724.104797 337.579926 268.032837 100.523376 20.588045 3.176947 0.232933 0.111572 1.153001 3.554817 5.613433 5.311408 3.108942 1.739027 3.098729 14.968944 58.013935 128.170609 113.237831 46.002144 10.750760 1.634221 -0.075741 -0.349475 -0.338769 -0.282509 -0.243625 -0.257467 -0.296708 -0.321567 66.543755 38.317467 21.671740 15.364930 7.469884 2.324079 0.291456 -0.207847 -0.272750 -0.168495 0.008430 0.155155 0.143105 -0.000023 0.110587 1.640695 9.019335 34.333244 69.585243 62.033684 27.826668 7.242546 1.178950 -0.111423 -0.352438 -0.365384 -0.339710 -0.322741 -0.319542 -0.314887 -0.316380 3.728295 2.781758 1.828024 1.180969 0.530713 0.055328 -0.177403 -0.257218 -0.274290 -0.273186 -0.267772 -0.263741 -0.282225 -0.293343 -0.165092 0.524007 3.431905 10.808303 19.945387 18.218824 9.376550 2.937991 0.496992 -0.201027 -0.347282 -0.350040 -0.327170 -0.304186 -0.255763 -0.195833 -0.168242 0.153238 0.095171 0.014957 -0.054666 -0.116022 -0.170699 -0.203755 -0.215085 -0.218401 -0.227545 -0.236168 -0.250994 -0.266987 -0.277104 -0.238928 -0.025216 0.691006 2.262427 4.040774 3.913594 2.395334 0.877182 0.032590 -0.266452 -0.331042 -0.316115 -0.276608 -0.179635 0.031653 0.356532 0.570090 -0.093802 -0.107296 -0.121129 -0.126841 -0.136552 -0.150022 -0.157616 -0.163179 -0.170475 -0.178446 -0.188210 -0.204199 -0.218105 -0.231929 -0.237636 -0.193734 -0.045770 0.268264 0.595951 0.686913 0.426684 0.068092 -0.180750 -0.291708 -0.310320 -0.284980 -0.204798 0.056424 0.780997 2.055140 2.884269 -0.088482 -0.092174 -0.098524 -0.103800 -0.107403 -0.111154 -0.116112 -0.119421 -0.126063 -0.132949 -0.139883 -0.154661 -0.172083 -0.184715 -0.193849 -0.198202 -0.182761 -0.135824 -0.074412 -0.042440 -0.085752 -0.177647 -0.248355 -0.279444 -0.284005 -0.261564 -0.149838 0.292532 1.791644 4.717690 6.613179 -0.067551 -0.072210 -0.073409 -0.074143 -0.076481 -0.078626 -0.081147 -0.085338 -0.086188 -0.093659 -0.104280 -0.113268 -0.127949 -0.145173 -0.156365 -0.168007 -0.175007 -0.180809 -0.174121 -0.177866 -0.193176 -0.219840 -0.246090 -0.259501 -0.258749 -0.244045 -0.134946 0.339739 2.008387 5.299692 7.887941 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001001 -0.001015 -0.001001 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001097 -0.001193 -0.001262 -0.001308 -0.001326 -0.001317 -0.001271 -0.001201 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001120 -0.001271 -0.001414 -0.001540 -0.001643 -0.001716 -0.001741 -0.001716 -0.001655 -0.001562 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001023 -0.001218 -0.001414 -0.001619 -0.001818 -0.001985 -0.002137 -0.002218 -0.002252 -0.003229 -0.004734 -0.004782 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001037 -0.001253 -0.001497 -0.001766 -0.002045 -0.003798 -0.004146 -0.007147 -0.010079 -0.010670 -0.011070 -0.012623 -0.012641 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001585 -0.001653 -0.001700 -0.001712 -0.001676 -0.001607 0.000000 0.000000 0.000000 -0.001001 -0.001244 -0.002562 -0.002975 -0.004913 -0.006938 -0.009022 -0.011450 -0.013543 -0.015944 -0.016953 -0.017560 -0.016861 -0.017935 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001688 -0.001888 -0.002084 -0.002237 -0.002351 -0.002419 -0.002419 -0.002385 -0.002269 -0.002128 -0.001942 -0.001748 -0.002234 -0.002692 -0.003189 -0.006725 -0.010463 -0.011919 -0.014991 -0.017716 -0.022116 -0.025221 -0.027838 -0.027642 -0.028342 -0.028422 0.000000 0.000000 0.000000 -0.001724 -0.002026 -0.003804 -0.004240 -0.004601 -0.004905 -0.005110 -0.006840 -0.006877 -0.006752 -0.006505 -0.004788 -0.004456 -0.006284 -0.004842 -0.005096 -0.008505 -0.011297 -0.016517 -0.020228 -0.024861 -0.030598 -0.032928 -0.035761 -0.036821 -0.038632 -0.039667 -0.038363 0.000000 0.000000 -0.003349 -0.003974 -0.004616 -0.005299 -0.005953 -0.008263 -0.008968 -0.009481 -0.009816 -0.009855 -0.009689 -0.009273 -0.009669 -0.009107 -0.009748 -0.008325 -0.014464 -0.017049 -0.019307 -0.023130 -0.028649 -0.035699 -0.041234 -0.045667 -0.048038 -0.050522 -0.054333 -0.056134 -0.056748 -0.001653 -0.003698 -0.004501 -0.005397 -0.006368 -0.009149 -0.010490 -0.011799 -0.012928 -0.013785 -0.014324 -0.016016 -0.015740 -0.016001 -0.013672 -0.013745 -0.014517 -0.017256 -0.019473 -0.024323 -0.028449 -0.033989 -0.039806 -0.045962 -0.052298 -0.059811 -0.064179 -0.069613 -0.075685 -0.077603 -0.078661 -0.003922 -0.004889 -0.006043 -0.007373 -0.010792 -0.012861 -0.015022 -0.018771 -0.020850 -0.022457 -0.023453 -0.023713 -0.023242 -0.023266 -0.021825 -0.022649 -0.022969 -0.027909 -0.027510 -0.031243 -0.038834 -0.046344 -0.054061 -0.058772 -0.068864 -0.078144 -0.085657 -0.093986 -0.100962 -0.105679 -0.108437 -0.007286 -0.008816 -0.012277 -0.014775 -0.019182 -0.022680 -0.026313 -0.029833 -0.033141 -0.034596 -0.035260 -0.035721 -0.036062 -0.034279 -0.033262 -0.033149 -0.035161 -0.037305 -0.039725 -0.043317 -0.051389 -0.061329 -0.071389 -0.080293 -0.090000 -0.104778 -0.115773 -0.128602 -0.138716 -0.144693 -0.148888 -0.011299 -0.015248 -0.018442 -0.024010 -0.028854 -0.034210 -0.040060 -0.045554 -0.050334 -0.053928 -0.055805 -0.055273 -0.054575 -0.053996 -0.050507 -0.051488 -0.053858 -0.052311 -0.053930 -0.060462 -0.069409 -0.078959 -0.090237 -0.104234 -0.120384 -0.131517 -0.145933 -0.160949 -0.173486 -0.183895 -0.189174 -0.015106 -0.020474 -0.027031 -0.033237 -0.040676 -0.049041 -0.057306 -0.065566 -0.069453 -0.072510 -0.074103 -0.074164 -0.073519 -0.074032 -0.071117 -0.074074 -0.072341 -0.071625 -0.073015 -0.077215 -0.089655 -0.100811 -0.118824 -0.134033 -0.154859 -0.170352 -0.184829 -0.193504 -0.203457 -0.213797 -0.222829 -0.023823 -0.031290 -0.038656 -0.047767 -0.058673 -0.069806 -0.077652 -0.084114 -0.088874 -0.088309 -0.084800 -0.084891 -0.092497 -0.095959 -0.098900 -0.099932 -0.101383 -0.100215 -0.100466 -0.104395 -0.116970 -0.133270 -0.151534 -0.172328 -0.187522 -0.207432 -0.214428 -0.194327 -0.151075 -0.119993 -0.132472 -0.034009 -0.042479 -0.053077 -0.066337 -0.082101 -0.093056 -0.100563 -0.095590 -0.059683 0.019494 0.107226 0.115814 0.036240 -0.052733 -0.101892 -0.123353 -0.126242 -0.131470 -0.135437 -0.141516 -0.150034 -0.164735 -0.186812 -0.204241 -0.226467 -0.231429 -0.177416 0.024168 0.345423 0.649620 0.541346 -0.047738 -0.059721 -0.076020 -0.095414 -0.108544 -0.117149 -0.105147 0.004588 0.391174 1.246175 2.347313 2.478034 1.552368 0.611558 0.069362 -0.112286 -0.153998 -0.161527 -0.173172 -0.178243 -0.187990 -0.203536 -0.224587 -0.243440 -0.260963 -0.217710 0.046973 0.933745 2.729287 4.304168 3.886780 -0.065483 -0.083916 -0.106532 -0.127795 -0.138979 -0.135083 -0.000806 0.738228 4.020092 14.183673 32.533550 34.510548 19.857698 6.355750 1.483113 0.188006 -0.123232 -0.189872 -0.205970 -0.216437 -0.229599 -0.245836 -0.264001 -0.287401 -0.291364 -0.151961 0.583437 3.366023 10.142160 17.091698 16.224609 -0.096737 -0.122435 -0.150572 -0.167906 -0.176895 -0.102815 0.525390 4.550683 31.507799 188.676575 681.882446 787.739990 300.695465 58.863857 10.518903 2.187401 0.299522 -0.142266 -0.241641 -0.265065 -0.279139 -0.295608 -0.313823 -0.338978 -0.329216 -0.083273 1.282868 6.876025 22.332537 41.743923 45.921741 -0.131239 -0.161394 -0.185283 -0.198723 -0.188664 0.093208 2.271887 19.562719 220.740540 3114.638184 28240.197266 41873.976563 6616.640137 511.968658 75.164764 15.709580 2.930641 0.262440 -0.232095 -0.314502 -0.335516 -0.355294 -0.374599 -0.397343 -0.386247 -0.109692 1.422433 8.230810 27.626793 57.389729 97.297546 -0.163459 -0.187301 -0.207568 -0.218105 -0.151475 0.586889 6.514979 57.657593 962.081238 41934.683594 100072.367188 100239.843750 101136.578125 4373.176758 879.843445 142.338745 17.940771 1.851825 -0.095619 -0.366453 -0.408321 -0.430008 -0.445052 -0.463722 -0.452506 -0.262077 0.802108 5.307842 18.469927 49.950958 184.382797 -0.183366 -0.173698 -0.107609 0.006553 0.194840 1.540148 13.126546 115.646255 1502.225586 77928.281250 100375.710938 103411.218750 156736.312500 103657.921875 28344.578125 1427.591553 83.587730 6.468415 0.234350 -0.406194 -0.485976 -0.499931 -0.497860 -0.461222 -0.400516 -0.259756 0.224619 2.189812 8.868473 36.171719 195.312469 -0.095006 0.298242 1.307056 2.848027 4.030053 5.034774 18.001192 144.363953 1018.909058 14268.954102 101012.406250 128351.609375 134399.500000 101263.421875 100074.492188 9312.627930 244.108337 13.145006 0.588275 -0.436991 -0.541750 -0.529686 -0.434112 -0.156171 0.371414 0.845512 0.884071 1.161576 3.952713 18.848070 89.996025 0.677864 3.854966 14.286275 35.688694 59.150841 47.436108 29.240543 86.181305 416.115509 1334.251221 5294.735352 43978.230469 102158.195313 100485.156250 100085.437500 11131.926758 262.141388 14.154588 0.640473 -0.467024 -0.509998 -0.337860 0.168020 1.593103 4.581801 7.404266 6.661407 3.794063 3.597135 8.950644 27.349150 4.543738 28.419693 148.667007 560.254150 1402.057373 1088.775269 225.516495 51.536343 90.600822 219.508469 920.386108 8582.475586 104762.078125 101565.046875 63103.417969 2291.660645 120.017418 8.994003 0.479317 -0.294210 0.198754 1.523261 3.764418 8.675927 20.423985 35.198025 29.435198 16.119410 16.030323 31.203222 43.503487 20.272663 197.108994 1932.111084 11829.777344 66075.593750 44260.363281 2882.191162 141.573486 27.708784 91.379448 744.112488 4713.642578 10095.316406 6639.211426 1916.585693 320.385284 47.619930 6.850725 0.761985 1.132694 6.241172 19.454224 36.403973 46.626842 69.687798 99.964104 83.685280 46.552097 98.067139 286.217682 324.537354 65.978821 1034.880981 28921.339844 134874.812500 200077.734375 112192.648437 14149.833984 324.620148 22.477068 43.476429 307.956879 1464.717529 2412.375488 1209.507690 595.232300 250.695648 60.257935 9.755380 2.334669 9.032310 57.263050 269.856293 632.584717 553.411133 362.260437 224.481674 127.482178 84.991684 407.499817 1685.860718 1767.039429 179.346756 2528.614990 101228.562500 115555.710937 200139.671875 146308.390625 7258.764160 253.643433 21.206091 21.507463 76.039337 217.951523 359.626770 481.057770 590.486206 305.531738 70.791138 11.725031 7.126918 43.581608 525.011841 6070.423828 25923.925781 15262.551758 5671.655762 1573.223999 248.160080 93.437798 547.641663 2580.498291 2707.306152 1039.512939 13312.486328 76268.320313 115613.179687 106944.875000 19022.062500 1189.267334 105.062897 54.258686 72.588455 116.847382 168.709473 159.090790 214.870773 277.386078 150.221924 41.422203 15.518386 28.152485 154.332779 2948.778809 100168.054688 101443.437500 124476.539062 93636.132813 15340.449219 849.801636 84.627380 201.659470 715.068176 907.404663 7192.535645 100236.687500 102116.335938 109374.226562 18133.703125 1655.903564 198.849518 140.888016 395.574738 508.749634 1022.190369 1513.968018 772.773010 240.662155 98.501732 45.614166 30.310421 87.469124 251.640152 664.017700 6264.597656 101896.289063 102515.867188 141159.562500 128363.718750 25075.316406 1049.614380 68.300056 49.850231 156.838028 869.501221 11173.334961 100101.773438 100177.460938 100323.523438 17832.162109 489.844818 85.811516 378.978455 1591.087402 2000.923828 5656.183594 12261.750977 8224.067383 2146.745605 266.528015 40.863850 96.816689 879.942505 3591.592041 7309.478516 64863.863281 137780.218750 111748.218750 106478.281250 21465.707031 4388.424316 385.335846 61.413982 112.220078 501.341064 6665.280762 3246.942871 86272.593750 100109.617188 100052.546875 3989.672607 202.071198 58.835049 355.090302 1504.930664 2293.870117 10992.476563 116200.945312 104751.828125 99462.203125 2274.846436 107.335182 263.868103 4373.708008 32014.208984 49423.011719 101479.484375 102135.953125 105957.609375 6240.830566 1309.246704 355.002319 138.310989 544.660706 1750.742065 6066.274414 32722.447266 733.739258 2433.912109 5621.627930 2675.119385 400.766571 55.696556 43.914982 145.964859 502.443146 1724.562134 21459.544922 106251.570313 101958.609375 100284.953125 9205.961914 205.948120 233.366333 3656.916748 23471.144531 38036.222656 101957.929688 116489.062500 148232.328125 19960.626953 1147.849365 133.182388 877.873474 25347.367188 102268.695313 108719.710937 106215.554688 902.784668 344.965149 225.902237 126.181778 70.944504 192.311630 454.218262 621.570801 1628.719360 7547.711914 55221.660156 142242.375000 104499.851563 100340.500000 5327.997559 147.933044 87.675156 578.806458 2237.944580 4648.673828 35560.234375 142090.296875 106688.890625 100487.078125 7658.858398 281.534332 4767.400391 100121.617188 102870.031250 200052.625000 111746.750000 1255.921021 508.085175 103.861816 43.769825 348.239563 5236.456055 25637.945313 16393.292969 78770.226563 98423.890625 109424.148437 112741.078125 49626.796875 9673.912109 699.576111 83.757332 106.672546 316.128723 905.768311 1816.411987 13713.833008 109551.562500 102999.734375 100391.039063 10124.929687 306.620789 4349.597168 100059.031250 100911.375000 114608.960937 96326.335938 4615.595215 1793.108398 229.496078 87.860779 2141.878662 100069.710938 101934.500000 200040.453125 105588.554688 104121.726563 123727.265625 22187.953125 3404.720703 635.821350 193.132263 436.277008 1560.574463 2904.678467 10710.982422 20550.322266 103743.132813 145882.281250 200162.250000 54068.894531 1974.394897 149.689423 689.213989 16698.755859 96125.078125 26034.542969 3284.287354 5834.613281 2163.262451 276.762909 100.700020 2778.910645 100084.351563 102653.617188 200089.859375 108497.882812 105847.484375 107582.046875 5729.132324 682.408569 239.895493 391.983582 6936.848633 76377.375000 49326.183594 66212.468750 121120.664062 108014.257812 101879.187500 105185.609375 20343.791016 2515.519531 314.383057 91.815071 373.002380 873.267212 509.428314 173.976089 4721.355957 1173.878418 215.997543 63.884701 684.357849 16728.826172 100866.156250 59650.167969 104561.765625 136988.031250 80006.312500 5982.215332 396.362946 112.234093 823.875000 38797.093750 100281.007813 103992.859375 44103.109375 66370.664063 105363.109375 105952.468750 200101.359375 107857.789062 69999.585938 2458.827881 118.898247 24.630627 28.431355 22.389111 12.491267 99362.593750 6786.009766 463.181488 54.597801 77.053062 516.799133 1454.020142 2039.545776 8506.989258 28143.244141 28338.113281 3566.971680 245.545563 54.293518 471.684021 13644.536133 100084.750000 100692.820313 7596.693359 6200.776855 39299.070313 121722.335937 119511.914062 101253.156250 100102.476563 8533.122070 229.642517 13.482034 2.235351 1.143447 0.626131 101491.023438 70297.015625 1186.601562 68.937920 16.467663 37.221760 104.743576 302.821564 824.559265 2216.566650 2165.304443 533.066650 85.392288 48.752884 122.857483 947.876343 3978.640869 2849.318848 646.594971 489.714874 1708.702637 17715.626953 106107.687500 102216.890625 100304.062500 5125.160156 180.523117 11.198184 0.561614 -0.384162 -0.466589 100301.570313 95992.937500 1275.638550 64.494690 10.206321 12.039489 44.648567 151.893921 263.946838 249.466827 171.512085 96.954964 175.827042 428.237152 437.318817 204.583176 152.524017 118.411209 70.900909 273.959442 4080.209473 72262.960938 117021.156250 76122.562500 11049.066406 910.004333 74.008965 7.431197 0.421934 -0.448493 -0.512752 100047.804688 10203.092773 409.946228 34.957458 7.844462 6.306177 17.041706 48.363464 77.769608 68.893982 73.482704 209.034332 1473.148071 6634.728027 6178.633301 1401.257446 217.697388 43.068359 47.805824 567.636108 12432.892578 123419.210937 126159.882812 104851.507813 4526.571289 354.829803 53.862545 8.035510 0.670259 -0.350255 -0.460975 2875.556885 567.573303 89.534950 33.447289 17.670549 7.483109 5.707332 11.529943 22.255148 49.408482 160.937439 619.164307 6276.109375 52106.679688 51378.820313 12251.026367 2105.123779 241.061707 72.851372 824.617798 21216.105469 169798.390625 200138.734375 61655.894531 3333.452393 464.669586 81.658379 11.269745 1.130292 -0.246371 -0.398088 119.092659 116.282837 267.510406 399.988739 216.961472 55.509548 10.274427 6.202088 20.932219 85.180763 287.766541 823.710388 5910.073242 54000.843750 137934.484375 104327.062500 63184.960938 1812.620483 124.934250 648.344116 15076.791016 103123.625000 106143.507813 21814.298828 1691.181885 390.519867 75.958595 11.235918 1.177417 -0.199584 -0.347174 85.186974 723.779541 6075.123535 14620.244141 5097.501953 551.967407 49.822342 13.670667 52.695477 205.028397 484.329132 714.606689 2905.789307 105124.367188 104826.554688 101228.695313 100154.609375 6587.226074 184.000351 194.861313 2134.475586 13484.929688 14857.116211 2727.325684 488.248871 153.283417 35.153549 5.796323 0.596679 -0.226538 -0.320702 258.315857 5609.496582 100095.437500 100060.007813 100022.515625 3970.813965 167.871597 28.174980 127.179428 645.869629 1574.210083 2216.531006 6218.280762 105279.773438 157025.015625 107912.757812 100534.187500 4346.676758 144.533066 40.470173 181.488647 526.784058 576.156738 239.725052 80.671310 32.110813 9.422597 1.905668 0.056967 -0.270848 -0.298162 416.554687 12409.041016 100602.406250 100576.687500 100195.140625 8556.842773 250.763809 35.839195 170.935715 1231.619873 9900.598633 53201.648438 101319.703125 107590.898437 163093.812500 200025.453125 16429.423828 892.611572 56.097855 9.077246 15.671480 32.033730 35.614346 21.915716 10.847821 4.975562 1.620349 0.202582 -0.209390 -0.293914 -0.277359 1096.969116 7859.243164 128283.585937 125648.101562 81140.359375 3142.869141 160.070435 28.534163 156.693527 2504.999023 96343.984375 102215.007813 200108.390625 119537.031250 101531.843750 101346.882813 5570.677246 214.580978 18.001001 2.199293 1.404939 2.360256 2.757766 1.985938 1.101242 0.421388 -0.024253 -0.224911 -0.287975 -0.288581 -0.263490 47175.058594 83717.875000 103430.335938 107182.218750 80130.859375 1783.916626 98.853523 18.193441 110.426086 2308.283691 95942.453125 100783.609375 128251.984375 119300.601562 100591.851563 69849.875000 1683.693726 82.026428 7.209125 0.671578 -0.062349 -0.132984 -0.122924 -0.166562 -0.230901 -0.275386 -0.291853 -0.287905 -0.283658 -0.271249 -0.252244 102652.226563 200041.281250 101735.328125 100270.250000 100131.328125 2678.591553 90.105400 10.909090 46.625790 598.587341 9326.701172 56858.835938 32433.308594 11387.473633 10358.674805 2274.920898 231.610855 22.143482 3.171810 0.875326 0.188139 -0.178161 -0.350933 -0.385543 -0.376484 -0.347971 -0.309116 -0.275484 -0.259365 -0.258527 -0.247200 101134.765625 146281.781250 102055.218750 100076.640625 41865.785156 1056.272461 52.494278 5.208708 11.369975 84.133194 482.081665 1333.265747 1056.299683 456.951843 277.843903 110.883118 25.775898 5.796187 3.485197 2.741734 1.288171 0.221217 -0.239719 -0.365823 -0.370978 -0.341568 -0.304434 -0.272743 -0.259306 -0.258254 -0.247403 100187.515625 16728.603516 11698.370117 11148.207031 1932.978638 176.153137 16.539484 1.765855 1.893494 9.602990 30.973606 59.731152 54.494308 32.547935 17.720980 8.581443 3.969363 4.235970 6.241524 5.802828 2.977197 0.745372 -0.093312 -0.323852 -0.359759 -0.338051 -0.311450 -0.289621 -0.274985 -0.271421 -0.263335 1904.938721 643.487183 346.098175 267.594757 100.487190 21.782993 3.200677 0.244352 0.053946 0.801360 2.456256 4.178990 4.130312 2.659325 1.480729 0.958001 1.648006 4.263242 7.231456 6.845534 3.558889 0.975399 -0.009372 -0.287707 -0.337973 -0.329527 -0.315802 -0.300848 -0.289610 -0.277931 -0.273723 58.960766 36.551094 21.272968 15.313846 7.888136 2.350900 0.349823 -0.181131 -0.249500 -0.166059 -0.024408 0.097199 0.085497 -0.023727 -0.101102 0.082078 0.890962 2.871464 4.717575 4.493692 2.343599 0.698238 -0.072998 -0.285430 -0.319968 -0.317642 -0.311678 -0.294888 -0.281189 -0.272268 -0.268449 3.555356 2.720102 1.804737 1.191872 0.555739 0.079323 -0.155482 -0.233207 -0.246490 -0.245301 -0.238153 -0.237248 -0.246981 -0.268478 -0.256479 -0.130113 0.259848 1.040684 1.795314 1.722482 0.919849 0.204685 -0.167640 -0.286662 -0.307452 -0.304766 -0.293529 -0.276179 -0.265361 -0.258910 -0.258135 0.163483 0.100171 0.022736 -0.039906 -0.100231 -0.152390 -0.185240 -0.193475 -0.196977 -0.201731 -0.209070 -0.218398 -0.227779 -0.236757 -0.235808 -0.207457 -0.083625 0.145889 0.355276 0.348768 0.129765 -0.098713 -0.227987 -0.276010 -0.285648 -0.285402 -0.275675 -0.260002 -0.232940 -0.202012 -0.180923 -0.089666 -0.100036 -0.107519 -0.114431 -0.125003 -0.135578 -0.142139 -0.148104 -0.153584 -0.158953 -0.165754 -0.173627 -0.186499 -0.195915 -0.205522 -0.203340 -0.179711 -0.135306 -0.089241 -0.088037 -0.139839 -0.199777 -0.241378 -0.258201 -0.264245 -0.261388 -0.251556 -0.225109 -0.152376 -0.055922 0.002461 -0.084144 -0.087311 -0.093229 -0.095815 -0.099866 -0.098731 -0.103593 -0.104715 -0.108162 -0.111734 -0.119858 -0.131037 -0.141405 -0.155434 -0.160015 -0.168881 -0.173656 -0.172431 -0.171739 -0.173851 -0.187344 -0.204067 -0.222828 -0.237468 -0.245275 -0.235085 -0.225132 -0.181763 -0.059804 0.138784 0.245399 -0.063523 -0.068903 -0.070973 -0.071588 -0.068969 -0.068904 -0.070514 -0.072834 -0.075301 -0.079181 -0.086087 -0.093870 -0.105541 -0.117992 -0.127235 -0.138723 -0.144955 -0.148231 -0.156583 -0.164118 -0.170608 -0.185442 -0.200282 -0.214788 -0.218962 -0.212924 -0.202984 -0.155636 -0.024199 0.197301 0.317578 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001001 -0.001037 -0.001052 -0.001037 -0.001008 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001008 -0.001120 -0.001210 -0.001289 -0.001336 -0.001355 -0.001336 -0.001289 -0.001218 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001112 -0.001262 -0.001404 -0.001529 -0.001631 -0.001703 -0.001716 -0.001703 -0.001643 -0.002588 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001176 -0.001374 -0.001574 -0.001753 -0.001928 -0.002060 -0.004755 -0.007365 -0.007728 -0.007962 -0.008014 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001585 -0.001664 -0.001712 -0.001712 -0.001676 -0.001619 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001193 -0.001424 -0.002682 -0.002980 -0.006190 -0.007981 -0.010011 -0.011758 -0.011408 -0.011907 -0.013556 -0.014611 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001688 -0.001901 -0.002084 -0.002253 -0.002368 -0.002436 -0.002436 -0.002385 -0.002285 -0.002128 -0.001956 -0.001748 0.000000 -0.002167 -0.002547 -0.002944 -0.006207 -0.008310 -0.009322 -0.011877 -0.014168 -0.015314 -0.020260 -0.021264 -0.021915 -0.021144 0.000000 0.000000 0.000000 -0.001724 -0.003427 -0.003893 -0.004318 -0.004704 -0.005013 -0.005195 -0.006916 -0.006948 -0.006816 -0.006528 -0.006136 -0.004440 -0.004032 -0.004323 -0.004453 -0.003105 -0.006655 -0.009074 -0.011898 -0.015058 -0.017957 -0.023862 -0.027203 -0.027844 -0.029357 -0.030363 -0.030636 0.000000 -0.001585 -0.003432 -0.004060 -0.004727 -0.005424 -0.006063 -0.008393 -0.009084 -0.009614 -0.009927 -0.009975 -0.009796 -0.009353 -0.008728 -0.008948 -0.008312 -0.007619 -0.007497 -0.011672 -0.014152 -0.014423 -0.018170 -0.023224 -0.030033 -0.033487 -0.036670 -0.038089 -0.040268 -0.040409 -0.042149 -0.003074 -0.003793 -0.004614 -0.005532 -0.006544 -0.009314 -0.010672 -0.011994 -0.013129 -0.013987 -0.014455 -0.014588 -0.014203 -0.013557 -0.013525 -0.012537 -0.012503 -0.011734 -0.012860 -0.017858 -0.019380 -0.022814 -0.025248 -0.034289 -0.039068 -0.042842 -0.048561 -0.052757 -0.056126 -0.057004 -0.058364 -0.004025 -0.005017 -0.006193 -0.007586 -0.011005 -0.013109 -0.015235 -0.019016 -0.021048 -0.022685 -0.023604 -0.023885 -0.023298 -0.023114 -0.021536 -0.019705 -0.020221 -0.018842 -0.022816 -0.023657 -0.026670 -0.032062 -0.040007 -0.042558 -0.052068 -0.059129 -0.065848 -0.072094 -0.076091 -0.079823 -0.081756 -0.007324 -0.008901 -0.012402 -0.014949 -0.017869 -0.022909 -0.026576 -0.030214 -0.032549 -0.034941 -0.035581 -0.035910 -0.035082 -0.034023 -0.031357 -0.029761 -0.027892 -0.029848 -0.031860 -0.032394 -0.039038 -0.045225 -0.052750 -0.061360 -0.067036 -0.076626 -0.084864 -0.095493 -0.105487 -0.110469 -0.112936 -0.011331 -0.015297 -0.018541 -0.024146 -0.029071 -0.034601 -0.040502 -0.046090 -0.050829 -0.052719 -0.056031 -0.055439 -0.054339 -0.052118 -0.048077 -0.044671 -0.042284 -0.045316 -0.047244 -0.048919 -0.053733 -0.059716 -0.065874 -0.075860 -0.088111 -0.098803 -0.114104 -0.125254 -0.136521 -0.143557 -0.148698 -0.015144 -0.020553 -0.027127 -0.033482 -0.041066 -0.049598 -0.057967 -0.066212 -0.069985 -0.072781 -0.074526 -0.073073 -0.072951 -0.069920 -0.067544 -0.064587 -0.067572 -0.063931 -0.060704 -0.063912 -0.071017 -0.080913 -0.089469 -0.100857 -0.115149 -0.127561 -0.139984 -0.154247 -0.166763 -0.178396 -0.187014 -0.023695 -0.031161 -0.038737 -0.047999 -0.059291 -0.069088 -0.078336 -0.084457 -0.088542 -0.087132 -0.082379 -0.082689 -0.086776 -0.089351 -0.088076 -0.088245 -0.089537 -0.086582 -0.087061 -0.088930 -0.096483 -0.105792 -0.117371 -0.128951 -0.147526 -0.163670 -0.178466 -0.185844 -0.194879 -0.196192 -0.202969 -0.033520 -0.042117 -0.053045 -0.066667 -0.082554 -0.091705 -0.098304 -0.092053 -0.051863 0.038423 0.125002 0.148738 0.063542 -0.036402 -0.093660 -0.112217 -0.116577 -0.120826 -0.114491 -0.114857 -0.122447 -0.133248 -0.147767 -0.167196 -0.179489 -0.196217 -0.204056 -0.186477 -0.141202 -0.105844 -0.122123 -0.046625 -0.058953 -0.074371 -0.094829 -0.105917 -0.110741 -0.098019 0.028718 0.460416 1.408121 2.624187 2.758451 1.820372 0.645088 0.093609 -0.100484 -0.141240 -0.144946 -0.151163 -0.155261 -0.156215 -0.167059 -0.183697 -0.198587 -0.214738 -0.229138 -0.198788 -0.078196 0.133456 0.313342 0.321573 -0.063625 -0.082103 -0.104668 -0.122268 -0.132320 -0.123821 0.050773 0.920721 4.634996 16.902912 36.606750 40.989929 22.087837 6.903609 1.542215 0.184102 -0.115280 -0.172823 -0.183432 -0.188088 -0.195785 -0.207381 -0.220792 -0.238226 -0.257085 -0.256652 -0.150179 0.192095 0.800882 1.454736 1.695808 -0.092733 -0.117011 -0.145315 -0.159117 -0.163217 -0.036418 0.850211 6.216457 39.371845 231.704086 847.719177 1054.664795 366.008179 64.220009 10.570044 1.822092 0.201068 -0.149453 -0.214071 -0.228528 -0.242013 -0.254424 -0.270352 -0.284735 -0.301434 -0.281600 -0.094988 0.519350 1.741088 3.290512 5.164598 -0.126171 -0.157134 -0.179742 -0.191102 -0.144989 0.412736 4.383331 32.210117 296.629425 4356.967773 51244.417969 69789.390625 9331.340820 623.168091 59.246628 10.829082 1.954108 0.104328 -0.222378 -0.280213 -0.294914 -0.306622 -0.320268 -0.340401 -0.351428 -0.323312 -0.117962 0.594781 2.164670 4.975043 12.991026 -0.157316 -0.184464 -0.202086 -0.203929 -0.023241 1.801576 17.534924 163.315674 1671.221313 70688.671875 100416.820313 100164.046875 100371.820313 3917.708984 390.921082 68.548882 10.119305 1.121658 -0.150453 -0.329548 -0.355177 -0.372343 -0.385216 -0.377307 -0.365887 -0.330397 -0.184943 0.329219 1.751446 5.560999 23.351564 -0.181477 -0.189379 -0.141248 -0.013613 0.467077 4.569718 57.052528 788.216736 9263.586914 118027.218750 104501.718750 101256.148438 107185.578125 21095.498047 4817.379883 486.920319 41.313217 3.779113 0.037825 -0.383079 -0.428505 -0.428964 -0.377541 -0.214753 0.059941 0.309617 0.308321 0.326522 1.100254 4.753594 24.450012 -0.142914 0.098747 0.890137 2.511340 4.504003 9.931934 92.641037 1769.377808 33828.910156 120160.148437 115015.507812 105415.335938 152604.703125 101541.570313 46354.003906 1935.938843 100.188873 7.166994 0.230664 -0.428339 -0.487221 -0.404169 -0.037616 1.172719 3.771328 6.252706 5.595588 2.784430 1.287734 2.778363 12.606662 0.270896 2.241094 10.465869 37.093807 78.514687 71.468124 81.673035 862.777283 10182.633789 28056.937500 12070.644531 13783.982422 102007.578125 100231.578125 62911.093750 2261.160645 106.633316 7.558096 0.208167 -0.456339 -0.417301 0.004325 1.793931 9.082113 32.250710 57.654564 51.104492 21.542696 5.549747 2.336230 4.845228 2.182811 14.511817 98.082436 735.790894 3360.152588 2564.217041 450.591064 184.399872 803.876892 1438.130127 849.319458 1705.933350 13564.503906 31215.894531 7834.464844 686.651428 52.684887 4.543518 0.014407 -0.284098 0.427829 2.531088 9.672395 46.483578 215.912949 514.309387 417.138245 120.512421 23.481939 7.224239 6.772180 8.691483 70.548019 798.800293 23414.722656 100593.710938 100177.742188 9225.899414 275.395386 65.697716 91.362740 118.250069 313.880096 879.360107 1155.587769 513.561462 104.693909 16.354126 2.050560 0.065821 1.249297 7.507986 25.890982 57.266541 161.760086 813.132812 2657.994629 1935.218262 419.897614 63.291050 25.456861 26.570915 24.118513 230.000305 3324.377441 107172.726562 105545.546875 101055.390625 67886.539063 689.145691 28.154320 13.529224 35.838276 93.361412 141.740097 121.325058 69.522942 28.249403 8.039588 1.568513 1.387318 10.955261 79.882370 398.126312 1023.210693 914.850098 1349.503540 3763.535889 2676.336426 561.242615 88.573494 64.337875 73.160858 60.237560 462.657288 4848.689453 97346.234375 116040.890625 102265.156250 28239.984375 441.748901 20.176472 5.660646 12.327360 26.181566 37.579849 38.732098 33.220520 19.035017 6.954265 3.026561 7.553323 60.048744 796.531433 12197.594727 69927.265625 35004.707031 4402.402344 1895.936401 1054.373291 254.495224 64.331894 76.162445 96.614601 247.636734 1632.040039 5056.801758 12233.275391 29576.214844 17848.070313 1637.782715 103.352104 13.504335 11.308671 18.140560 25.490339 24.565102 21.984056 18.871988 12.294485 8.668791 20.222754 51.403278 234.853012 5659.693848 100168.960938 100432.476563 102269.906250 42604.179688 2971.408936 511.599762 94.155640 30.697584 46.061245 111.055733 987.087036 12224.836914 42170.187500 15542.750000 2246.514160 555.812195 117.011444 26.880480 27.050863 43.776154 83.744797 130.195847 109.437347 54.254971 20.142502 11.644073 48.848286 325.298950 1097.397827 1585.498169 13675.050781 104372.734375 101532.406250 102534.148438 91170.750000 3304.882080 404.876129 54.155830 19.134651 67.253975 625.437378 1427.100342 21199.304688 86170.304688 25710.669922 1860.301514 151.628281 24.802563 25.306412 60.165836 124.344971 341.983368 963.473145 1519.813965 621.877441 105.266945 34.427715 399.253479 9222.604492 85905.484375 53485.679688 105008.757813 200139.359375 138078.343750 101950.390625 15881.843750 1113.457886 172.610535 40.829006 50.633453 239.821716 4802.013184 525.941833 4692.095703 13331.443359 5547.389648 641.541260 63.414993 13.931035 29.101679 97.789085 375.830200 1811.180664 17196.433594 56953.832031 12267.474609 745.011353 94.300484 1528.343750 100058.281250 101657.703125 200038.562500 115465.250000 103757.695313 111950.437500 12165.598633 1283.612549 208.331512 80.652702 224.780502 563.175171 961.098511 12234.052734 122.178848 432.355103 793.388916 482.531525 111.036896 29.685907 29.780046 66.513123 388.915070 4514.700684 31759.820313 125796.000000 103210.210938 99238.007813 2267.373779 137.002594 1299.040527 96052.242188 101426.421875 200059.531250 112061.742187 115165.242187 163435.718750 20833.591797 1125.284790 107.040985 354.798370 4777.541992 18747.367188 9307.932617 11668.186523 59.014118 56.956482 62.926888 45.638458 54.971668 244.886124 582.390137 635.842529 2516.042480 87028.445313 102348.820313 156758.390625 151420.562500 42319.019531 1510.914795 111.157433 268.861389 4367.368164 31614.361328 24686.511719 107640.382812 200233.296875 119385.968750 100882.328125 7002.873047 232.217148 1411.454834 60519.179688 100321.335938 102905.812500 13194.886719 74.132233 44.058922 19.960751 32.775799 463.602997 9213.901367 48629.285156 21083.208984 38118.179688 137978.562500 105482.843750 103602.843750 107899.406250 5677.206055 799.736267 117.104378 63.044968 233.144028 645.480957 1454.907837 12980.456055 107042.570312 102427.898438 100343.367188 9211.624023 252.086746 1299.634033 48344.402344 100145.914063 96912.507813 4818.473145 172.351913 109.021149 37.404789 90.743797 3312.059326 100054.585938 101225.726563 156781.531250 110342.117187 138115.296875 177678.453125 102729.468750 29117.486328 6887.281250 1506.200195 232.918427 200.692581 281.611511 699.773254 6075.024902 101825.351563 141095.875000 156805.656250 47749.863281 1878.222412 116.170341 281.715973 3313.392090 13663.532227 4878.391602 692.833008 778.989441 494.682129 136.873520 117.910332 4341.363770 100065.601563 101657.312500 200029.453125 113877.242187 102098.359375 108151.281250 10191.471680 5398.540527 4835.768555 1125.010132 563.185852 1582.073364 1493.311890 1751.494995 29327.953125 100497.539063 101035.062500 102606.296875 9570.173828 771.095337 114.970856 46.062012 156.718826 321.048279 205.181625 67.325226 9147.298828 4997.119141 787.378845 119.242729 941.467224 31261.089844 100594.921875 82402.867188 102309.562500 100761.515625 18452.126953 1381.572388 907.914551 832.411987 388.332764 1147.798340 5254.494629 3868.385986 1645.322388 16841.949219 100350.796875 100931.984375 106635.429687 19727.826172 4495.750488 460.328522 44.916374 13.299660 15.875427 11.936240 6.139559 102629.828125 29984.201172 2521.021484 183.188858 111.295898 693.512939 1900.546143 1819.819214 3654.975342 4116.770020 1410.185669 342.248291 153.421448 113.263039 113.794685 639.865784 2557.084961 1883.423462 625.511536 2031.461792 19519.082031 48596.234375 42290.484375 86951.359375 17628.312500 1141.478149 74.500366 6.392133 1.122706 0.456510 0.093124 134428.437500 53950.195313 2499.697754 198.212051 46.932308 48.340935 73.135757 104.927635 184.747070 251.301407 185.408524 85.999611 44.931965 30.513309 34.899006 116.515564 300.030792 253.707291 118.358376 210.966721 799.765442 2805.951416 16978.076172 42224.265625 10247.710937 798.746826 59.731464 5.054385 0.076012 -0.443990 -0.483924 103432.070313 53418.765625 1431.639160 168.895264 57.722656 33.662720 19.538948 19.390169 28.872368 34.384323 30.684563 25.809040 36.717514 57.595493 59.592758 41.331791 35.633465 28.752987 30.903851 150.923233 1164.876343 5548.386230 8697.699219 5380.959473 1547.331177 227.272675 26.994444 2.966387 -0.094277 -0.468281 -0.479733 100262.054688 6838.712891 502.963959 112.062370 49.198059 27.955183 12.403440 7.088064 8.092970 9.024865 12.592026 32.738365 119.649384 311.456360 357.278961 194.935211 71.540771 22.229183 47.301018 698.776062 16647.480469 104725.273438 109440.125000 24487.617188 1264.206909 117.234558 16.070179 2.169879 -0.084334 -0.413193 -0.424399 2128.154297 514.885864 125.259674 53.895035 27.294537 14.115438 5.673169 2.480923 3.008929 6.448140 17.850950 66.765503 320.601562 1156.025879 2442.941162 2501.570557 772.719788 123.842796 92.316216 2129.316162 100365.523438 102094.015625 103672.328125 101457.234375 3115.833008 140.456421 16.292280 2.316889 0.014007 -0.339321 -0.360760 98.759972 70.583611 86.467522 100.635307 64.075729 21.457457 4.856633 1.439507 3.169059 10.216284 27.871613 89.311447 517.695679 5071.590332 51922.941406 86372.882813 12209.332031 742.277344 117.825012 1948.966553 100083.804688 100320.445313 100489.132813 100267.585938 2733.600830 117.477989 13.733009 2.010923 0.022870 -0.292264 -0.313922 30.747194 155.382614 689.085693 1226.762573 592.773682 120.833862 16.713112 3.351972 7.020075 21.929699 48.378410 125.001709 866.720276 19984.900391 100767.414063 100297.046875 86190.804688 2098.256836 118.884430 456.091064 9319.134766 100035.664063 100051.132813 12206.748047 615.061340 48.843567 7.367327 1.132793 -0.074620 -0.274726 -0.278815 64.366989 646.261780 5108.069824 12182.066406 4314.560059 515.321350 46.439930 7.196004 14.995309 55.731255 160.716507 443.655273 3078.789551 31541.001953 125682.281250 104326.031250 46622.378906 1561.272095 83.772087 67.583611 448.768768 1658.171387 1792.657471 520.183594 79.623672 12.743691 2.355789 0.265266 -0.195186 -0.267503 -0.252866 113.073174 1140.111084 11311.293945 31302.835938 9379.362305 861.308411 64.588570 10.110413 25.475885 148.924637 820.948914 2920.943848 32790.226563 101904.500000 112217.203125 95050.679688 5440.158203 418.211823 35.679466 10.519949 27.631750 61.817841 65.993256 31.657999 9.242664 2.260617 0.359739 -0.138769 -0.252145 -0.255642 -0.230828 330.226746 1495.901367 7946.428223 12489.053711 4013.411377 522.860352 50.206028 9.341525 34.693481 317.970612 3179.353516 13409.529297 78321.437500 101352.101563 100523.867188 100560.765625 3093.095947 145.571320 13.396155 2.032955 2.225377 3.947328 4.024593 2.422111 0.877887 0.090511 -0.182247 -0.256961 -0.260699 -0.239415 -0.215048 3864.264648 8755.213867 78025.375000 78225.046875 8197.664062 499.778961 41.796871 7.423400 30.186348 304.979645 3141.098633 13840.352539 21847.382813 101233.585938 100132.085938 31151.996094 1070.109375 63.292446 5.439808 0.354684 -0.115470 -0.028799 0.007223 -0.100391 -0.209124 -0.272533 -0.278829 -0.268614 -0.247454 -0.227858 -0.200253 51463.832031 23905.320313 100386.921875 100079.187500 17596.232422 693.185547 41.448475 5.161856 14.173657 115.093620 742.348572 2351.946289 2499.686035 5045.218262 5588.270020 1427.950195 166.890472 17.148212 1.747892 -0.055764 -0.304997 -0.338775 -0.342924 -0.336528 -0.323508 -0.308215 -0.280511 -0.258438 -0.236627 -0.216951 -0.190816 88656.007813 14707.082031 46712.003906 46306.707031 5095.104492 341.396637 24.819532 2.775758 4.297789 23.432335 96.131004 212.764511 222.859085 212.657745 187.836945 80.194107 18.797407 3.439390 0.497416 -0.011695 -0.178795 -0.292057 -0.338564 -0.335693 -0.317422 -0.295583 -0.271296 -0.248558 -0.227830 -0.210729 -0.190789 8422.570312 2284.930664 2080.441895 1943.220337 514.495667 73.715324 8.565423 0.925288 0.762202 3.630018 10.974045 19.005239 20.503756 16.994040 12.239300 6.338950 2.148203 0.598730 0.333964 0.208498 -0.006505 -0.198485 -0.293606 -0.313800 -0.300000 -0.277622 -0.261437 -0.238717 -0.222651 -0.212603 -0.198097 411.494843 195.770889 133.215973 109.866516 46.177547 11.255642 1.843343 0.056173 -0.106521 0.243736 0.995181 1.740338 1.883986 1.467843 0.928856 0.421668 0.138941 0.187156 0.331008 0.290078 0.067406 -0.150643 -0.255328 -0.283162 -0.276118 -0.264227 -0.250506 -0.235949 -0.224581 -0.215274 -0.206234 24.134882 16.364058 11.346934 8.490453 4.409003 1.363888 0.151058 -0.194201 -0.242241 -0.199380 -0.129911 -0.061053 -0.055647 -0.105674 -0.167426 -0.190975 -0.120443 0.041009 0.191795 0.175138 0.006922 -0.156353 -0.235578 -0.262324 -0.258935 -0.258957 -0.249123 -0.236104 -0.226864 -0.217589 -0.210585 1.873328 1.456995 1.056614 0.708800 0.301777 0.006464 -0.159472 -0.210559 -0.219660 -0.220562 -0.216361 -0.214944 -0.219279 -0.230224 -0.243094 -0.231912 -0.186032 -0.100746 -0.018849 -0.028635 -0.103410 -0.187091 -0.231605 -0.243014 -0.246317 -0.245106 -0.238528 -0.230328 -0.219672 -0.214833 -0.207670 0.051037 0.015201 -0.029716 -0.069893 -0.104896 -0.139738 -0.165883 -0.171785 -0.175271 -0.179434 -0.179950 -0.184340 -0.194431 -0.202584 -0.210184 -0.215104 -0.198935 -0.171457 -0.142188 -0.143056 -0.172454 -0.201963 -0.215003 -0.221034 -0.230789 -0.232678 -0.226565 -0.216877 -0.208312 -0.204820 -0.198763 -0.089537 -0.097370 -0.104123 -0.109109 -0.116369 -0.118778 -0.125876 -0.126593 -0.128911 -0.132147 -0.139595 -0.147119 -0.155641 -0.166025 -0.172647 -0.178558 -0.177098 -0.171654 -0.170777 -0.171279 -0.177156 -0.186862 -0.194636 -0.206329 -0.216857 -0.214577 -0.208719 -0.199712 -0.193382 -0.185781 -0.177112 -0.078886 -0.082668 -0.087819 -0.089560 -0.088364 -0.089084 -0.091378 -0.092655 -0.094060 -0.096217 -0.101697 -0.109461 -0.118010 -0.127348 -0.135720 -0.143094 -0.147536 -0.148054 -0.153198 -0.155185 -0.157283 -0.163000 -0.175532 -0.187871 -0.194365 -0.193762 -0.188407 -0.185741 -0.177112 -0.160938 -0.151995 -0.058802 -0.062464 -0.065602 -0.064601 -0.061999 -0.060518 -0.058996 -0.064175 -0.064469 -0.067502 -0.070747 -0.078540 -0.085152 -0.094511 -0.100901 -0.111601 -0.116483 -0.121555 -0.128841 -0.130653 -0.136558 -0.144274 -0.155164 -0.164002 -0.170567 -0.173661 -0.166481 -0.166262 -0.157177 -0.141545 -0.131830 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.000994 -0.001030 -0.001044 -0.001037 -0.001001 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001089 -0.001176 -0.001244 -0.001289 -0.001308 -0.001298 -0.001253 -0.001185 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001059 -0.001201 -0.001336 -0.001454 -0.001540 -0.001608 -0.003050 -0.003078 -0.004119 -0.004116 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001641 -0.001676 -0.001688 -0.001653 -0.001585 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001097 -0.001271 -0.001444 -0.001619 -0.003278 -0.004725 -0.005076 -0.007929 -0.008327 -0.008576 -0.008655 0.000000 0.000000 0.000000 0.000000 0.000000 -0.001664 -0.001862 -0.002054 -0.002205 -0.002318 -0.002385 -0.002385 -0.002351 -0.002237 -0.002098 -0.001915 -0.001724 0.000000 0.000000 -0.001081 -0.002305 -0.002586 -0.004393 -0.006105 -0.006727 -0.011267 -0.012171 -0.012874 -0.014956 -0.015490 -0.015755 0.000000 0.000000 0.000000 -0.001700 -0.003428 -0.003875 -0.004315 -0.004689 -0.004993 -0.005196 -0.005270 -0.006837 -0.006714 -0.006426 -0.006028 -0.004312 -0.002385 -0.002084 -0.003874 -0.002437 -0.004191 -0.005973 -0.008300 -0.009336 -0.012981 -0.015794 -0.018410 -0.021247 -0.022411 -0.023195 -0.022532 0.000000 0.000000 -0.003423 -0.004058 -0.004721 -0.005413 -0.006073 -0.008298 -0.008972 -0.009486 -0.009746 -0.009824 -0.009607 -0.009162 -0.008548 -0.007785 -0.007925 -0.006012 -0.006680 -0.006373 -0.007974 -0.008943 -0.010299 -0.014443 -0.019054 -0.021461 -0.025312 -0.027502 -0.030452 -0.031672 -0.031101 -0.003090 -0.003797 -0.004616 -0.005530 -0.006535 -0.009227 -0.010545 -0.011837 -0.012887 -0.013737 -0.014212 -0.014326 -0.013959 -0.013232 -0.012263 -0.012049 -0.010945 -0.010884 -0.011519 -0.011290 -0.013237 -0.014122 -0.018830 -0.023825 -0.027146 -0.033162 -0.036654 -0.037084 -0.040995 -0.042976 -0.043907 -0.004019 -0.005023 -0.006196 -0.007582 -0.010913 -0.012968 -0.015088 -0.017130 -0.020657 -0.022138 -0.023062 -0.023147 -0.022620 -0.021391 -0.020636 -0.018758 -0.016831 -0.014557 -0.016415 -0.017361 -0.019576 -0.024039 -0.028765 -0.031291 -0.038690 -0.044902 -0.049972 -0.054636 -0.056687 -0.056915 -0.058500 -0.006274 -0.008807 -0.010664 -0.014711 -0.017614 -0.022407 -0.025986 -0.028663 -0.031806 -0.034067 -0.034616 -0.034865 -0.033990 -0.031763 -0.030020 -0.026941 -0.023684 -0.024795 -0.024334 -0.024945 -0.030356 -0.032600 -0.038623 -0.046187 -0.050534 -0.057821 -0.063976 -0.070768 -0.076440 -0.082110 -0.083491 -0.011086 -0.013435 -0.018212 -0.022044 -0.028383 -0.033901 -0.039560 -0.045102 -0.048232 -0.051456 -0.052162 -0.053887 -0.051749 -0.049922 -0.045871 -0.040775 -0.038345 -0.036119 -0.033628 -0.035385 -0.042598 -0.045047 -0.050886 -0.059300 -0.065892 -0.074859 -0.083472 -0.094178 -0.103526 -0.110938 -0.114032 -0.014764 -0.020034 -0.026402 -0.032633 -0.040093 -0.048437 -0.056953 -0.063741 -0.069027 -0.071605 -0.072993 -0.071555 -0.069183 -0.067775 -0.063546 -0.059412 -0.055439 -0.051095 -0.050434 -0.050844 -0.056771 -0.060425 -0.067487 -0.076176 -0.087949 -0.098348 -0.110473 -0.121046 -0.130054 -0.138309 -0.145311 -0.021461 -0.028583 -0.035944 -0.045290 -0.056413 -0.067804 -0.077220 -0.082843 -0.086902 -0.086877 -0.084909 -0.084524 -0.087589 -0.085661 -0.083059 -0.078489 -0.078641 -0.074422 -0.075968 -0.077512 -0.077729 -0.085872 -0.095635 -0.101727 -0.116396 -0.129499 -0.139132 -0.151055 -0.162945 -0.173472 -0.179722 -0.032249 -0.040557 -0.051386 -0.064729 -0.079057 -0.089154 -0.093845 -0.091054 -0.061955 -0.001368 0.067223 0.076725 0.020508 -0.049835 -0.092490 -0.103529 -0.103598 -0.103583 -0.100574 -0.097594 -0.098746 -0.106073 -0.117595 -0.133368 -0.143163 -0.156621 -0.169882 -0.184176 -0.191703 -0.194326 -0.194333 -0.043052 -0.055020 -0.070301 -0.087446 -0.100267 -0.106104 -0.095766 -0.004467 0.312864 0.991076 1.749780 1.828173 1.194103 0.425798 0.030027 -0.106613 -0.128968 -0.127859 -0.132367 -0.132097 -0.130741 -0.136215 -0.151676 -0.165054 -0.177313 -0.189805 -0.206363 -0.205988 -0.193102 -0.180417 -0.174863 -0.059881 -0.077814 -0.097974 -0.115753 -0.124741 -0.113973 0.042726 0.760219 3.354510 10.207211 21.089460 23.336670 12.770924 4.264787 0.952173 0.059886 -0.127492 -0.158086 -0.161928 -0.164695 -0.164563 -0.170209 -0.184371 -0.202050 -0.217449 -0.234443 -0.238569 -0.213980 -0.156494 -0.098548 -0.018767 -0.085136 -0.108043 -0.131691 -0.147092 -0.145717 0.009391 0.990103 5.625123 26.814211 113.837257 344.825226 391.561951 166.172638 35.433167 6.171056 0.969915 0.020780 -0.165233 -0.194665 -0.204142 -0.207734 -0.218721 -0.228124 -0.240939 -0.256701 -0.274688 -0.269957 -0.217479 -0.106632 0.066222 0.474180 -0.116517 -0.146845 -0.167549 -0.177858 -0.098512 0.715883 6.574933 41.863117 220.841324 1466.903198 8599.497070 11141.000977 2452.854980 253.010406 28.292158 4.755043 0.755618 -0.065290 -0.219907 -0.250322 -0.258927 -0.262933 -0.276172 -0.286224 -0.298119 -0.310851 -0.309991 -0.247268 -0.099883 0.285274 1.549011 -0.146867 -0.172411 -0.192594 -0.184455 0.123484 3.229719 36.641491 427.464844 3567.308350 17108.292969 102050.703125 100233.000000 25712.919922 1137.390625 103.381615 19.285591 3.508656 0.327350 -0.218487 -0.298215 -0.312293 -0.324834 -0.319512 -0.288543 -0.227697 -0.196804 -0.205417 -0.225768 -0.111991 0.415175 2.861391 -0.174763 -0.192613 -0.168306 -0.049903 0.682982 9.253276 162.976700 4865.749512 100590.648438 117560.734375 178918.703125 101847.617188 51728.101563 2155.781982 409.456573 78.749832 11.082170 1.219968 -0.165872 -0.358641 -0.378015 -0.352023 -0.222091 0.172584 0.893618 1.498750 1.395825 0.609581 0.106487 0.385596 2.813619 -0.173646 -0.049837 0.437478 1.613938 3.614716 16.104494 303.007019 16343.002930 100260.460938 104311.421875 146318.921875 74944.734375 11359.193359 3923.589355 1356.063110 203.464661 22.001671 2.231933 -0.124962 -0.417641 -0.418147 -0.227647 0.661319 4.096537 13.029224 22.774368 19.198675 8.797895 2.321994 0.570854 1.513670 0.002793 1.060251 5.793342 23.171442 48.194443 53.657829 201.000122 6342.931152 100055.703125 100394.656250 101698.921875 4702.501465 2972.422119 4066.260254 1545.097168 215.049957 24.393953 2.283132 -0.174845 -0.458208 -0.327857 0.543057 5.382236 34.406586 154.736603 363.458252 296.691376 93.469475 18.162544 2.606647 0.715618 0.764529 6.496211 49.128784 376.477509 1407.798340 1194.182007 281.670441 607.051819 5296.900879 12229.444336 3230.273926 535.008850 757.834717 1073.102051 483.540100 94.768372 13.248043 1.261558 -0.297042 -0.305402 0.475190 3.764127 24.912741 232.083496 2261.146484 8523.521484 6568.372559 1052.594238 99.669792 9.770020 1.439773 2.858057 24.718588 323.126617 6954.105957 96047.671875 60511.761719 3320.011475 186.361237 159.845108 232.417191 131.756866 73.353371 112.444145 137.234039 77.277176 22.888794 4.176465 0.278282 -0.221509 0.906371 5.868594 22.151440 91.002670 1029.765991 21238.742188 100033.296875 100011.671875 6570.028809 318.449982 23.178654 3.904182 6.684637 53.857861 895.789490 48557.398438 100201.398438 100074.031250 18494.166016 346.074066 24.131596 12.856175 11.350817 13.385062 19.456867 19.762980 12.177985 4.824116 1.105882 -0.010638 0.803563 7.835821 49.161991 235.719528 615.386047 2012.415283 35266.566406 100466.390625 100103.007813 10184.571289 420.217804 27.930204 7.112127 13.913588 73.835281 690.085388 20922.421875 100371.718750 100122.046875 8367.637695 239.521835 12.858003 1.896924 2.033390 3.500194 4.713124 4.699761 3.284861 1.693362 0.788382 1.526835 6.049294 39.794109 403.399414 4045.563232 16841.318359 17610.972656 31012.513672 46513.988281 24091.992188 2711.314209 183.696381 20.025515 10.533763 37.011589 145.328506 395.571198 1651.014404 7145.333984 5799.517578 749.316772 58.854610 5.216272 1.600691 2.499109 3.689105 3.813236 2.919527 1.838438 1.573751 5.456451 22.153803 52.555649 162.092896 2187.029297 70026.750000 103187.218750 177623.812500 109829.429687 87937.757813 4447.959473 435.959229 51.401009 13.175305 29.166822 90.319168 400.172607 830.841614 575.640686 334.920929 195.459259 55.041328 10.563597 3.598765 5.747452 11.779625 18.461449 19.560892 12.046784 4.950724 6.737630 56.772079 432.827911 1461.509766 1448.562988 5213.885254 102270.867188 103782.187500 177646.156250 117661.742187 78101.007813 3200.097168 184.967514 21.276730 25.709288 181.834610 113.804764 553.111755 1060.718872 606.210999 146.368210 31.697514 8.028909 3.986104 9.231095 27.063681 68.548965 132.123062 165.835495 94.569298 28.702169 30.744251 498.985931 15095.208984 100302.210938 81641.335938 74030.960938 125833.015625 112942.250000 85367.625000 24038.947266 7427.739258 759.571594 71.467598 21.051373 75.503761 926.677307 59.034821 244.433624 418.235992 261.805328 71.224846 13.033647 4.077075 9.442227 49.928417 266.515717 818.865601 1328.292725 1479.913330 647.662781 135.933502 84.470024 2143.149170 100041.414063 100911.140625 137907.796875 125452.773437 101722.234375 103974.437500 5222.860352 1306.295288 458.981873 113.288010 54.260708 84.889694 170.596100 1736.516113 18.756716 52.781364 78.705933 55.093632 20.560326 10.994225 15.776902 45.156990 411.463806 5584.670898 42138.308594 36412.238281 8910.538086 2205.384033 409.289093 151.558105 1819.462036 100041.015625 100788.937500 131139.812500 120735.140625 102280.687500 100827.796875 3951.162354 407.948456 71.387100 67.742836 301.725128 707.642761 553.444641 1066.600708 7.394800 10.262699 11.870893 11.207472 24.076891 98.900978 211.350861 282.016418 2309.101074 100221.367188 100334.625000 101675.023438 81609.164063 4194.421387 1054.790527 241.940506 376.328827 6919.316895 60725.210938 31498.980469 37149.042969 64438.578125 95522.585938 20408.712891 1115.812134 79.881912 150.306396 1191.797607 3649.278564 1792.687744 586.131531 13.510732 10.734419 6.537115 16.226246 178.704407 1809.285889 6364.406250 3564.293945 6615.997559 102921.945313 101087.093750 105012.171875 142313.875000 53847.500000 6922.595215 528.679565 86.227936 238.391022 694.585632 898.825989 2623.614746 26216.097656 100730.742188 27126.794922 1277.741943 79.161659 139.354324 1096.166504 3324.984619 1582.493164 335.210297 130.855286 94.734024 37.096989 45.745193 860.606201 25265.306641 100264.171875 57752.390625 31351.447266 87963.601563 105120.312500 123662.937500 134417.734375 100991.218750 37992.773438 1174.032471 82.349052 47.627029 130.060791 933.564819 6977.358887 16777.583984 14073.240234 4146.067383 420.351898 42.926247 47.055016 254.979172 541.225098 332.292969 93.947731 3399.203125 2103.177734 397.869965 94.048019 1100.970703 38794.285156 100341.726563 90494.804688 49026.468750 53446.468750 16898.486328 25835.273438 101704.101563 100222.921875 23338.607422 944.906677 112.896263 80.949440 206.018311 2497.045898 34397.136719 86387.679688 18053.578125 1379.192871 171.040894 30.195169 12.267889 30.212681 50.139019 36.480682 15.514693 100281.710938 95930.007813 5122.334473 276.848633 342.158722 4769.767090 20633.304688 9122.959961 9183.880859 8724.656250 2377.684570 2824.019287 12787.517578 14818.133789 2696.619873 281.517303 136.114197 117.815002 184.739456 1829.453979 19317.595703 46378.718750 10491.884766 1249.321899 291.874542 60.845226 10.088709 3.884477 4.327996 3.374201 1.708556 104017.312500 100830.359375 28428.171875 680.553650 129.748566 284.661652 586.270813 510.694305 635.644592 662.335999 450.933441 849.676086 1192.614746 743.053040 244.098312 75.088776 81.553169 72.702591 78.439018 387.602966 2125.119873 3822.902832 2012.988770 1262.392578 538.729614 103.144669 13.522713 1.595189 0.085194 -0.147082 -0.281619 138106.921875 104158.242188 20494.900391 981.263184 396.933807 268.693604 99.962891 50.185093 56.845242 71.928459 134.424057 303.027100 348.776855 159.114655 46.409676 20.471014 23.155182 22.114515 22.924555 67.077690 218.480331 457.395538 730.151306 829.577271 388.699829 83.039940 11.850463 1.186661 -0.294423 -0.476376 -0.475928 103068.007813 32975.906250 6840.528320 1705.985596 1084.236328 745.532043 164.706924 25.719212 9.619287 13.086910 29.761835 62.563690 67.847229 39.566723 18.232561 9.723666 6.635018 5.799256 14.242473 97.550812 685.800537 2794.661621 3130.587646 996.529785 222.922409 44.602158 7.322491 0.722758 -0.324490 -0.442452 -0.435579 8200.788086 5125.356934 4622.214355 1518.387695 943.695190 595.926147 141.904419 19.361433 3.238535 2.662670 6.024907 13.033957 22.081388 34.372410 41.400620 34.125896 17.497923 8.710029 35.390953 560.662292 12214.998047 100155.335938 100235.570313 16151.665039 730.104309 53.783417 6.171511 0.508166 -0.307118 -0.392553 -0.378190 753.199951 1000.687378 1052.688232 454.384155 252.158890 159.559570 47.616341 8.209754 1.023757 0.721237 2.790686 9.738140 34.962479 109.976509 249.016327 277.077209 125.474045 34.323532 75.252892 1793.575317 100031.046875 100095.476563 100140.046875 100083.468750 2468.722656 95.329201 7.299313 0.551097 -0.251843 -0.329741 -0.318016 124.750153 171.170975 159.304504 90.345001 49.185734 26.669809 9.469212 1.904291 0.218236 0.950042 3.880185 14.963394 75.463127 460.322388 1974.036621 2666.327393 851.873840 125.764908 76.150627 1536.599854 95841.585938 100029.187500 100039.593750 100026.492188 2097.290283 81.762543 6.426084 0.456783 -0.217682 -0.283516 -0.269823 32.462795 52.072685 80.799141 95.152977 60.418579 20.325691 4.688627 0.666374 0.619851 2.678299 8.290930 29.324860 161.507767 1198.583252 7310.319336 10241.264648 2461.297852 265.682770 52.315155 392.373016 7810.422363 86135.687500 95838.054688 9311.363281 516.391907 35.812355 3.358462 0.195469 -0.217519 -0.252872 -0.234831 16.689781 63.128109 208.090103 323.416626 190.452667 49.426140 8.213553 1.314859 1.975143 7.744161 24.634724 90.450569 523.758850 2645.274902 6773.994629 7204.118652 1881.017212 225.680283 28.928885 60.197136 389.694824 1420.828125 1533.369751 447.652954 66.052719 8.639392 1.034172 -0.069553 -0.232699 -0.235591 -0.209843 22.193312 98.370644 353.215607 547.749512 294.303772 69.874001 11.514391 2.066879 4.037289 19.649548 73.382721 295.993530 2385.094482 17807.390625 24088.251953 5361.002930 729.188354 96.741341 13.524586 7.907060 25.807028 54.522690 57.942631 27.385090 7.842803 1.443459 0.070784 -0.204429 -0.233597 -0.214214 -0.187739 56.397774 167.520645 457.388184 538.455200 260.739716 62.406551 10.854572 2.242347 5.946745 33.826576 157.070679 543.403198 4201.158691 37994.140625 51311.058594 7260.686035 527.314880 48.308189 5.714511 1.201631 2.048987 3.520486 3.754278 2.182759 0.664636 0.009312 -0.198293 -0.230010 -0.218695 -0.193046 -0.169361 240.595337 539.826355 1591.312134 1596.014771 487.452332 78.433174 10.766440 2.005395 5.469923 32.327568 149.020401 425.841827 1561.673462 8603.284180 11141.648438 2268.299072 233.771713 22.690145 2.474479 0.057817 -0.122167 -0.001796 0.012643 -0.072716 -0.176899 -0.234017 -0.238482 -0.223698 -0.206019 -0.182478 -0.159487 815.879028 994.647644 2912.975342 2878.714111 688.019897 91.075478 10.864233 1.477555 2.927087 16.249872 62.477219 145.501587 281.524658 668.560669 794.769592 280.104858 52.213055 7.135207 0.716128 -0.224425 -0.331881 -0.315244 -0.296151 -0.279853 -0.269037 -0.250757 -0.229296 -0.212455 -0.187748 -0.167375 -0.146351 970.539490 640.215088 1181.518066 1140.392822 341.288696 55.004375 7.010626 0.776009 0.908223 4.622265 14.301245 28.770912 42.499973 57.713017 57.251297 27.844734 8.200528 1.470155 -0.010402 -0.277386 -0.312853 -0.312607 -0.295531 -0.275737 -0.260433 -0.238813 -0.215763 -0.196132 -0.177211 -0.159845 -0.143331 317.504944 188.411942 210.209122 190.740494 74.003281 16.528336 2.590865 0.188688 0.037564 0.750039 2.394308 4.470091 5.521633 6.068430 5.119612 2.876622 0.916264 0.038531 -0.206668 -0.260601 -0.275391 -0.279064 -0.269583 -0.256572 -0.240970 -0.222385 -0.203304 -0.182930 -0.171181 -0.154902 -0.143854 47.590511 32.699203 27.631519 22.916048 11.413064 3.456321 0.579276 -0.131224 -0.211140 -0.086396 0.146086 0.391670 0.516645 0.509804 0.337693 0.088793 -0.114306 -0.206370 -0.224996 -0.222864 -0.233975 -0.244219 -0.238989 -0.230678 -0.218740 -0.207111 -0.188812 -0.176618 -0.168417 -0.155934 -0.147185 5.715133 4.663989 3.567037 2.685012 1.435355 0.421658 -0.058034 -0.206478 -0.232086 -0.214739 -0.188580 -0.162912 -0.155143 -0.168159 -0.193690 -0.215237 -0.225912 -0.222504 -0.204457 -0.201193 -0.210615 -0.213908 -0.212225 -0.207685 -0.201244 -0.190860 -0.181644 -0.175126 -0.167744 -0.156238 -0.150587 0.565982 0.465388 0.334831 0.201331 0.039387 -0.091565 -0.167429 -0.188632 -0.191608 -0.193553 -0.189947 -0.192121 -0.193151 -0.199631 -0.207107 -0.209856 -0.212769 -0.202851 -0.191722 -0.186370 -0.189435 -0.188629 -0.186684 -0.186155 -0.185057 -0.179628 -0.174339 -0.170820 -0.164578 -0.157791 -0.153223 -0.048402 -0.064192 -0.083929 -0.099406 -0.114364 -0.135592 -0.145473 -0.150027 -0.154241 -0.152011 -0.151968 -0.156521 -0.164011 -0.170688 -0.174325 -0.180988 -0.183644 -0.181044 -0.174354 -0.170370 -0.168719 -0.164264 -0.171158 -0.171226 -0.171396 -0.170061 -0.167834 -0.165084 -0.160737 -0.152558 -0.149305 -0.086872 -0.093249 -0.096604 -0.101964 -0.105953 -0.106996 -0.108748 -0.113400 -0.110682 -0.112309 -0.115265 -0.121281 -0.128371 -0.135049 -0.143218 -0.144220 -0.149720 -0.149811 -0.148275 -0.149277 -0.147429 -0.147784 -0.151917 -0.155138 -0.157520 -0.157490 -0.157826 -0.154495 -0.149781 -0.145694 -0.140735 -0.074991 -0.078066 -0.082473 -0.082584 -0.080600 -0.078695 -0.076753 -0.077933 -0.078260 -0.080613 -0.084572 -0.087176 -0.092614 -0.100060 -0.107397 -0.113426 -0.122493 -0.122081 -0.121939 -0.122760 -0.128264 -0.128663 -0.130900 -0.134539 -0.138004 -0.140791 -0.142834 -0.141780 -0.139236 -0.132785 -0.128611 -0.054556 -0.056482 -0.058252 -0.058599 -0.056337 -0.053083 -0.051909 -0.052817 -0.056245 -0.058535 -0.059148 -0.060805 -0.068010 -0.072761 -0.078592 -0.083436 -0.089595 -0.097093 -0.100931 -0.105516 -0.105667 -0.107554 -0.111351 -0.111534 -0.118417 -0.124111 -0.127639 -0.125971 -0.125357 -0.121647 -0.120974 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Tests/__init__.py0000644000175000017500000000000110064121656030401 0ustar debiandebian mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Tests/test.py0000644000175000017500000001271210653444130027634 0ustar debiandebian## Automatically adapted for numpy.oldnumeric Jul 30, 2007 by # test for isocontour Python extension . From ../ : # tester Tests.test import sys import unittest import numpy.oldnumeric as Numeric from Pmv import Grid from UTpackages import UTisocontour class TestIsocontour(unittest.TestCase): auC = None def setUp(self): from UTpackages import UTisocontour print UTisocontour.__file__ if not self.auC: self.auC = Grid.AutoGrid('1ak3.C.map') def test_loadDataset(self): the_data = UTisocontour.loadDataset(UTisocontour.CONTOUR_FLOAT, UTisocontour.CONTOUR_REG_3D, 3, 1, ["pot-2eti-glucose-3fields.raw"]); isovar = 0 timestep = 0 isovalue = 0.23 isoc = UTisocontour.getContour3d(the_data, isovar, timestep, isovalue, UTisocontour.NO_COLOR_VARIABLE) print "nvert:", isoc.nvert print "ntri:", isoc.ntri #assert isoc.nvert == 12816 assert isoc.nvert == 3204 assert isoc.ntri == 6392 vert = Numeric.zeros((isoc.nvert,3)).astype('f') norm = Numeric.zeros((isoc.nvert,3)).astype('f') col = Numeric.zeros((isoc.nvert)).astype('f') tri = Numeric.zeros((isoc.ntri,3)).astype('i') UTisocontour.getContour3dData(isoc, vert, norm, col, tri, 0) # signature stuff nsig = UTisocontour.getNumberOfSignatures(the_data) sig0 = UTisocontour.getSignatureFunctions(the_data, 0, 0) sig1 = UTisocontour.getSignatureFunctions(the_data, 1, 0) sig2 = UTisocontour.getSignatureFunctions(the_data, 2, 0) print sig0.name, sig0.nval print sig1.name, sig1.nval print sig2.name, sig2.nval print "signatureValues:", UTisocontour.getSignatureValues(the_data, 0, 0, 0.23) def test_newDatasetRegFloat3D(self): # we have to swap axes because in a grid object z varies faster then y which # in turn varies faster then x sh = (1,3,self.auC.NELEMENTS[0],self.auC.NELEMENTS[1], self.auC.NELEMENTS[2]) da = Numeric.zeros(sh).astype('f') da[0][0] = Numeric.array( Numeric.reshape( Numeric.swapaxes( self.auC.array, 0, 2), self.auC.NELEMENTS ) ).astype('f') center = Numeric.array(self.auC.CENTER).astype('f') dim = Numeric.array(self.auC.NELEMENTS).astype('f') span = Numeric.array(self.auC.SPACING).astype('f') print "span: ", span orig = center - ((dim-1)/2)*span print "orig: ", orig the_data = UTisocontour.newDatasetRegFloat3D(da, orig.astype('f'), (span,)*3 ) ## the_data = UTisocontour.newDatasetRegFloat3D(da) ## UTisocontour.setOrig3D(the_data, orig.astype('f')) ## UTisocontour.setSpan3D(the_data, (span,)*3) isovar = 0 timestep = 0 isovalue = 0.23 isoc = UTisocontour.getContour3d(the_data, isovar, timestep, isovalue, UTisocontour.NO_COLOR_VARIABLE) vert = Numeric.zeros((isoc.nvert,3)).astype('f') norm = Numeric.zeros((isoc.nvert,3)).astype('f') col = Numeric.zeros((isoc.nvert)).astype('f') tri = Numeric.zeros((isoc.ntri,3)).astype('i') print "nvert:", isoc.nvert print "ntri:", isoc.ntri #assert isoc.nvert == 28478 assert isoc.nvert ==7394 assert isoc.ntri == 14220 UTisocontour.getContour3dData(isoc, vert, norm, col, tri, 1) nsig = UTisocontour.getNumberOfSignatures(the_data) sig0 = UTisocontour.getSignatureFunctions(the_data, 0, 0) sig1 = UTisocontour.getSignatureFunctions(the_data, 1, 0) sig2 = UTisocontour.getSignatureFunctions(the_data, 2, 0) print sig0.name, sig0.nval print sig1.name, sig1.nval print sig2.name, sig2.nval print "signatureValues:", UTisocontour.getSignatureValues(the_data, 0, 0, 0.23) datainfo = UTisocontour.getDatasetInfo(the_data) orig=datainfo._orig() span=datainfo._span() print "orig: ", orig print "span: ", span def test_getSliceArray(self): assert hasattr(UTisocontour, 'getSliceArray') isovar=0 timestep=0 axis='x' sliceNum=10 step=1 sh = (1,1, self.auC.NELEMENTS[0], self.auC.NELEMENTS[1], self.auC.NELEMENTS[2]) da = Numeric.zeros(sh).astype('f') da[0][0] = Numeric.array( Numeric.reshape( Numeric.swapaxes( self.auC.array, 0, 2), self.auC.NELEMENTS ) ).astype('f') daSmall = Numeric.array(da[:,:,::step,::step,::step]).astype('f') center = Numeric.array(self.auC.CENTER).astype('f') dim = Numeric.array(self.auC.NELEMENTS).astype('f') span = Numeric.array(self.auC.SPACING).astype('f') print "span:", span orig = center - ((dim-1)/2)*span print "orig: ", orig the_data = UTisocontour.newDatasetRegFloat3D(daSmall, orig.astype('f'), (span*step,)*3 ) #the_data = UTisocontour.newDatasetRegFloat3D(daSmall) sld = UTisocontour.getSliceArray(the_data, isovar, timestep, axis, sliceNum) print 'sld.shape' ,sld.shape assert sld.shape == (61, 41) if __name__ == '__main__': unittest.main(argv=([__name__,]) ) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/__init__.py0000644000175000017500000000014610133613276027312 0ustar debiandebian#this is __init__.py of isocontour module from isocontour import * __MGLTOOLSVersion__ = '1.3alpha2' mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/UTisocontour/Misc.i0000644000175000017500000000564510064121655026255 0ustar debiandebian/* # AUTHOR Michel F. SANNER # # Permission to use, copy, modify, and distribute this software and its # documentation for any purpose and without fee is hereby granted, # provided that the above copyright notice appear in all copies and that # both that copyright notice and this permission notice appear in # supporting documentation, and that the name of TSRI not be used in # advertising or publicity pertaining to distribution of the software # without specific, written prior permission. # # TSRI DISCLAIMS ALL WARRANTIES WITH REGARD TO # THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND # FITNESS, IN NO EVENT SHALL TSRI BE LIABLE # FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. # # Copyright (C) Michel F. SANNER, TSRI, 1999 # Unpublished work. All Rights Reserved. # */ /************************************************************************** Type maps for char ** <==> list of strings **************************************************************************/ /************************************************************************** char ** <==> list of strings **************************************************************************/ /************************************************************************** Python file object ==> FILE * **************************************************************************/ // This tells SWIG to treat char ** as a special case %typemap(in) char ** { /* Check if is a list */ if ($input==Py_None) { $1=NULL; } else if (PyList_Check($input)) { int size = PyList_Size($input); int i = 0; $1 = (char **) malloc((size+1)*sizeof(char *)); for (i = 0; i < size; i++) { /* memory is allocated by PyList_GetItem */ PyObject *o = PyList_GetItem($input,i); if (PyString_Check(o)) $1[i] = PyString_AsString(PyList_GetItem($input,i)); else { PyErr_SetString(PyExc_TypeError,"list must contain strings"); free($1); return NULL; } } $1[i] = 0; } else { PyErr_SetString(PyExc_TypeError,"not a list"); return NULL; } } // This cleans up the char ** array we malloc'd before the function call %typemap(freearg) char ** { if ($1) { free((char *) $1); } } // This allows a C function to return a char ** as a Python list %typemap(out) char ** { int len,i; len = 0; while ($1[len]) len++; $result = PyList_New(len); for (i = 0; i < len; i++) { PyList_SetItem($result,i,PyString_FromString($1[i])); } } // This allows a C function to receive Python File object %typemap(in) FILE * { if (!PyFile_Check($input)) { PyErr_SetString(PyExc_ValueError, "Need a file!"); return NULL; } $1 = PyFile_AsFile($input); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/setup.cfg0000644000175000017500000000003210064121654024334 0ustar debiandebian[build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/0000755000175000017500000000000012146213517023312 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplotreg3.h0000644000175000017500000000406210064121655025722 0ustar debiandebian//------------------------------------------------------------------------ // // conPlot2d.h - class for preprocessing and extraction of surfaces from // 3d data // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: conplotreg3.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef CONPLOT_RECT_3D_H #define CONPLOT_RECT_3D_H #include #include "contour3d.h" #include "dataset.h" #include "segtree.h" #include "seedcells.h" #include "cellqueue.h" #include "edgehash.h" #include "range.h" #include "datasetreg3.h" #include "conplot.h" //------------------------------------------------------------------------ // // conPlotreg3.h // //------------------------------------------------------------------------ class Conplotreg3 : public Conplot { public: Conplotreg3(Datasetreg3 *d); ~Conplotreg3(); protected: // extract in 3d (from memory) or slice-by-slice (swap from disk) u_int ExtractAll(float isovalue); void interpRect3Dpts_x(int, int, int, float *, float *, float [3][8], int, int, float, float *, float *, float *); void interpRect3Dpts_y(int, int, int, float *, float *, float [3][8], int, int, float, float *, float *, float *); void interpRect3Dpts_z(int, int, int, float *, float *, float [3][8], int, int, float, float *, float *, float *); int InterpEdge(float *, float *, float [3][8], float, int, int, int, int); // track a contour from a seed cell void TrackContour(float, int); // enqueue faces for propagation of surface inline void EnqueueFaces(int, u_int, u_int, u_int, CellQueue &); void Reset(int t) { con3[t].Reset(); } int Size(int t) { return(con3[t].getSize()); } int isDone(int t) { return(con3[t].isDone()); } void Done(int t) { con3[t].Done(); } private: Datasetreg3 *reg3; Datareg3 *curreg3; public : // modified by Emilio Contour3d *con3, *curcon; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedchkr3.h0000644000175000017500000000073110064121655025335 0ustar debiandebian // $Id: seedchkr3.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef SEED_CHKR3_H #define SEED_CHKR3_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class Datavol; class Dataslc; class seedChkr3 { public: seedChkr3(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~seedChkr3() {} void compSeeds(void); private: Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedcells.h0000644000175000017500000000227110064121655025426 0ustar debiandebian//---------------------------------------------------------------- // // seedCells.h - maintain a list of seed cells // // Copyright (c) 1997 Dan Schikore //---------------------------------------------------------------- // $Id: seedcells.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef SEED_CELLS_H #define SEED_CELLS_H #include #ifdef WIN32 typedef unsigned int u_int; #endif typedef struct SeedCell { float min, max; u_int cell_id; } *SeedCellP; class SeedCells { public: SeedCells(); ~SeedCells(); int getNCells(void) { return(ncells); } u_int getCellID(int i) { return(cells[i].cell_id); } float getMin(int i) { return(cells[i].min); } float getMax(int i) { return(cells[i].max); } void Clear(void) { ncells = 0; } SeedCell *getCellPointer(){ return(cells); } int AddSeed(u_int, float, float); void AddToRange(u_int i, float mn, float mx) { if (mn < cells[i].min) cells[i].min = mn; if (mx > cells[i].max) cells[i].max = mx; } private: int ncells; int cell_size; SeedCellP cells; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/inttree.cpp0000644000175000017500000001670411065020741025472 0ustar debiandebian//---------------------------------------------------------------- // // intTree.C - interval Tree manipulation // // Copyright (c) 1997 Dan Schikore // //---------------------------------------------------------------- // $Id: inttree.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #endif #include "inttree.h" IntTree *global_tree = NULL; #define DEBUG_TREENo extern int verbose; //---------------------------------------------------------------- // // IntTree() - construct a segment tree for the given range of values // //---------------------------------------------------------------- IntTree::IntTree(u_int n, float *val) { nseed=0; seedsize=0; cellid = NULL; min = NULL; max = NULL; if (n==0) { nleaf=0; vals=NULL; minlist = NULL; maxlist = NULL; return; } Init(n, val); } //---------------------------------------------------------------- // // Init() - Initialize the segment tree for the given set of values // //---------------------------------------------------------------- void IntTree::Init(u_int n, float *val) { nleaf = n; vals = (float *)malloc(sizeof(float)*nleaf); memcpy(vals, val, sizeof(float)*nleaf); minlist = new CellBucket[nleaf]; maxlist = new CellBucket[nleaf]; } //---------------------------------------------------------------- // // ~IntTree() - free storage for a segment tree // //---------------------------------------------------------------- IntTree::~IntTree() { if (verbose) printf("IntTree destructor\n"); free(vals); /* should free inside buckets here */ delete [] minlist; delete [] maxlist; if (min) { free(min); min = NULL; } if (max) { free(max); max = NULL; } if (cellid) { free(cellid); cellid = NULL; } } int IntTree::mincmp(const void *p1, const void *p2) { u_int s1 = *((u_int*)p1); u_int s2 = *((u_int*)p2); if (global_tree->seedMin(s1) < global_tree->seedMin(s2)) return(-1); if (global_tree->seedMin(s1) > global_tree->seedMin(s2)) return(1); return(0); } int IntTree::maxcmp(const void *p1, const void *p2) { u_int s1 = *((u_int*)p1); u_int s2 = *((u_int*)p2); if (global_tree->seedMax(s1) > global_tree->seedMax(s2)) return(-1); if (global_tree->seedMax(s1) < global_tree->seedMax(s2)) return(1); return(0); } void IntTree::Done(void) { int i; global_tree = this; for (i=0; i> 1; #ifdef DEBUG_TREE printf("comparing with split value %f (node %d)\n", vals[root], root); #endif if (min <= vals[root] && vals[root] <= max) { minlist[root].insert(n); maxlist[root].insert(n); return; } if (min > vals[root]) { left=root+1; #ifdef DEBUG_TREE printf("left->root+1\n"); #endif } else /* max < vals[root] */ { right=root-1; #ifdef DEBUG_TREE printf("right->root-1\n"); #endif } #ifdef DEBUG_TREE sleep(1); #endif } // left == right minlist[left].insert(n); maxlist[left].insert(n); } void IntTree::travFun(u_int n, void *data) { IntTree *tree = (IntTree *)data; tree->travCB(tree->seedID(n), tree->travData); } //---------------------------------------------------------------- // // Traverse() - Traverse the tree, calling the given function for // each stored segment containing the given value // //---------------------------------------------------------------- void IntTree::Traverse(float val, void (*f)(u_int, void *), void *data) { int left, right, root; left = 0; right = nleaf-1; travCB = f; travData = data; while (left < right) { root = (left + right) >> 1; if (vals[root] > val) { minlist[root].traverseCells(travFun, this); right=root-1; } else { maxlist[root].traverseCells(travFun, this); left=root+1; } } } //---------------------------------------------------------------- // // getCells() - traverse the tree, storing the cell id's of all // segments containing the given value in a list // //---------------------------------------------------------------- u_int IntTree::getCells(float val, u_int *cells) { int left, right, root; u_int ncells; int i; left = 0; right = nleaf-1; ncells=0; while (left < right) { root = (left + right) >> 1; if (vals[root] > val) { // for all cells in minlist, we know max > val // search the minlist for all cells with min < val for (i=0; i val for (i=0; i val) cells[ncells++] = seedID(maxlist[root].getCell(i)); else break; left=root+1; } } // map the seed numbers to cell id's // for (i=0; i max) max = minlist[i].nCells(); if (maxlist[i].nCells() > max) max = maxlist[i].nCells(); } printf("total labels in tree: %d\n", total); printf("maximum labels in one list: %d\n", max); printf("______INTERVAL TREE STATS_____\n"); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datareg3.cpp0000644000175000017500000005311511065020741025507 0ustar debiandebian//------------------------------------------------------------------------ // // datareg3.C - class for a regular 3d grid of scalar data // //------------------------------------------------------------------------ // $Id: datareg3.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #endif #include "datareg3.h" #include "compute.h" #include "endian_io.h" #define TRUE 1 #define FALSE 0 #define FUNSTEP 1 #define SQR(x) ((x)*(x)) #define FSAMPLES 256 #define FSAMPLES_TOPO 128 extern int verbose; int Datareg3::cellFaceVert[6][4] = { { 0, 1, 2, 3 }, { 0, 3, 4, 7 }, { 4, 5, 6, 7 }, { 1, 2, 5, 6 }, { 2, 3, 6, 7 }, { 0, 1, 4, 5 }, }; //------------------------------------------------------------------------ // // bitsize - return the number of bits in an int (easier way?) // //------------------------------------------------------------------------ static int bitsize(unsigned int i) { u_int b = 1, size=0; while (b <= i) { b<<=1; size++; } return(size); } //------------------------------------------------------------------------ // // Datareg3() - the regular object constructor // //------------------------------------------------------------------------ Datareg3::Datareg3(DataType t, int ndata, char *fn) : Data(t, ndata, fn) { if (verbose) printf("reading dimensions\n"); fread_int( dim, sizeof(u_int), 3, fp); fread_float(orig, sizeof(float), 3, fp); fread_float(span, sizeof(float), 3, fp); if (verbose) { printf("dim: %d %d %d\n", dim[0], dim[1], dim[2]); printf("orig: %f %f %f\n", orig[0], orig[1], orig[2]); printf("span: %f %f %f\n", span[0], span[1], span[2]); } xbits = bitsize(dim[0] - 2); ybits = bitsize(dim[1] - 2); zbits = bitsize(dim[2] - 2); if (xbits == 0) xbits = 1; if (ybits == 0) ybits = 1; if (zbits == 0) zbits = 1; yshift = xbits; zshift = xbits+ybits; xmask = (1<= dim[0]) { error = TRUE; break; } size = dim[1] * dim[2]; switch (type) { case UCHAR : if (!buffer->ucdata) buffer->ucdata = new u_char[size]; bc = buffer->ucdata; dc = data[v].ucdata + index; for (z = 0; z < dim[2]; z++) for (y = 0; y < dim[1]; y++) { (*bc++) = *dc; dc += dim[0]; } break; case USHORT : if (!buffer->usdata) buffer->usdata = new u_short[size]; bs = buffer->usdata; ds = data[v].usdata + index; for (z = 0; z < dim[2]; z++) for (y = 0; y < dim[1]; y++) { (*bs++) = *ds; ds += dim[0]; } break; case FLOAT : if (!buffer->fdata) buffer->fdata = new float[size]; bf = buffer->fdata; df = data[v].fdata + index; for (z = 0; z < dim[2]; z++) for (y = 0; y < dim[1]; y++) { (*bf++) = *df; df += dim[0]; } break; } break; case 'y' : if (index < 0 || index >= dim[1]) { error = TRUE; break; } size = dim[2] * dim[0]; switch (type) { case UCHAR : if (!buffer->ucdata) buffer->ucdata = new u_char[size]; bc = buffer->ucdata; for (x = 0; x < dim[0]; x++) { dc = data[v].ucdata + index * dim[0] + x; for (z = 0; z < dim[2]; z++) { (*bc++) = *dc; dc += dim[0] * dim[1]; } } break; case USHORT : if (!buffer->usdata) buffer->usdata = new u_short[size]; bs = buffer->usdata; for (x = 0; x < dim[0]; x++) { ds = data[v].usdata + index * dim[0] + x; for (z = 0; z < dim[2]; z++) { (*bs++) = *ds; ds += dim[0] * dim[1]; } } break; case FLOAT : if (!buffer->fdata) buffer->fdata = new float[size]; bf = buffer->fdata; for (x = 0; x < dim[0]; x++) { df = data[v].fdata + index * dim[0] + x; for (z = 0; z < dim[2]; z++) { (*bf++) = *df; df += dim[0] * dim[1]; } } break; } break; case 'z' : if (index < 0 || index >= dim[2]) { error = TRUE; break; } size = dim[0] * dim[1]; switch (type) { case UCHAR : if (!buffer->ucdata) buffer->ucdata = new u_char[size]; memcpy(buffer->ucdata, data[v].ucdata + index * size, size * sizeof(u_char)); break; case USHORT : if (!buffer->usdata) buffer->usdata = new u_short[size]; memcpy(buffer->usdata, data[v].usdata + index * size, size * sizeof(u_short)); break; case FLOAT : if (!buffer->fdata) buffer->fdata = new float[size]; memcpy(buffer->fdata, data[v].fdata + index * size, size * sizeof(float)); break; } break; default : error = TRUE; break; } return error; } //------------------------------------------------------------------------ // // compLength() - // //------------------------------------------------------------------------ float *Datareg3::compLength(u_int &len, float **funx) { float *val = (float *)malloc(sizeof(float)*FSAMPLES); float *fx = (float *)malloc(sizeof(float)*FSAMPLES); float p[8][3]; u_int i, j, k; len = FSAMPLES; memset(val, 0, sizeof(float)*len); *funx = fx; for (i=0; i #endif #include "basic.h" inline void sortVerts(float* &x0, float* &x1, float* &x2, float* &x3, float &v0, float &v1, float &v2, float &v3/*, float f[4]*/) { float *_t, t; if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; //t = f[3]; f[3] = f[2]; f[2] = t; } if (v2 < v1) { _t = x2; x2 = x1; x1 = _t; t = v2; v2 = v1; v1 = t; //t = f[2]; f[2] = f[1]; f[1] = t; } if (v1 < v0) { _t = x1; x1 = x0; x0 = _t; t = v1; v1 = v0; v0 = t; //t = f[1]; f[1] = f[0]; f[0] = t; } if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; //t = f[3]; f[3] = f[2]; f[2] = t; } if (v2 < v1) { _t = x2; x2 = x1; x1 = _t; t = v2; v2 = v1; v1 = t; //t = f[2]; f[2] = f[1]; f[1] = t; } if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; //t = f[3]; f[3] = f[2]; f[2] = t; } //float epsilon = MIN((p_fun->getFuncMax()-p_fun->getFuncMin())/(p_fun->getVertCount()*100), (v[3]-v[0])/400); //epsilon = 0.1*MAX(epsilon, (v[3]-v[0])/4000); #define MAX(a,b) ((a) > (b)) ? (a) : (b) float epsilon = MAX(1e-5, (v3-v1)/4000); if (v1 <= v0+epsilon) v1 += epsilon; if (v2 <= v1+epsilon) v2 += 2 * epsilon; if (v3 <= v2+epsilon) v3 += 4 * epsilon; } inline void triSurfIntegral(double *x1, double *x2, double *x3, float v1, float v2, float v3, float *fx, float *val, int nbucket, float min, float max, float scaling) { double *_t; float mid[2]; float dist[2]; float ival; float maxlen; float t; u_int first; if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; } if (v2 < v1) { _t = x2; x2 = x1; x1 = _t; t = v2; v2 = v1; v1 = t; } if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; } // need to compute point along v[0]->v[2] // a cell with constant value will not contribute to the length if (v3 == v1) return; ival = (v3-v2)/(v3-v1); mid[0] = (float)((1.0-ival)*x3[0] + (ival)*x1[0]); mid[1] = (float)((1.0-ival)*x3[1] + (ival)*x1[1]); dist[0] = (float)(mid[0]-x2[0]); dist[1] = (float)(mid[1]-x2[1]); maxlen = (float)sqrt(sqr(dist[0]) + sqr(dist[1])) * scaling; first=(unsigned int)ceil(((float)(nbucket-1) * (v1-min))/(max-min)); // compute the for (; fx[first] < v2; first++) { if (v1 == v2) val[first] += maxlen; else val[first]+=((fx[first]-v1)/(float)(v2-v1)) * maxlen; } for (; fx[first] < v3; first++) { if (v3==v2) val[first] += maxlen; else val[first]+=((v3-fx[first])/(float)(v3-v2)) * maxlen; } } inline void triVolIntegral(double *x1, double *x2, double *x3, float v1, float v2, float v3, float *fx, float *val, float *cum, u_int nbucket, float min, float max, float scaling) { double *_t; float mid[2]; float dist[2], dist2[2], dist3[2]; float ival; float midarea, maxarea; float t; u_int first; if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; } if (v2 < v1) { _t = x2; x2 = x1; x1 = _t; t = v2; v2 = v1; v1 = t; } if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; } dist[0] = (float)(x2[0]-x1[0]); dist[1] = (float)(x2[1]-x1[1]); dist2[0] = (float)(x3[0]-x1[0]); dist2[1] = (float)(x3[1]-x1[1]); if (v3 == v1) midarea = maxarea = 0.5f * (float)fabs(dist2[0]*dist[1]-dist2[1]*dist[0]); else { ival = (v3-v2)/(v3-v1); mid[0] = (float)((1.0-ival)*x3[0] + (ival)*x1[0]); mid[1] = (float)((1.0-ival)*x3[1] + (ival)*x1[1]); dist3[0] = (float)(mid[0]-x1[0]); dist3[1] = (float)(mid[1]-x1[1]); midarea = 0.5f * (float)(fabs(dist3[0]*dist[1]-dist3[1]*dist[0])); maxarea = 0.5f * (float)(fabs(dist2[0]*dist[1]-dist2[1]*dist[0])); } first=(unsigned int)ceil(((nbucket-1) * (v1-min))/(max-min)); // compute the for (; fx[first] < v2; first++) { if (v1 == v2) val[first] += midarea; else val[first]+=sqr((fx[first]-v1)/(float)(v2-v1)) * midarea; } for (; fx[first] < v3; first++) { if (v3==v2) val[first] += maxarea; else val[first]+= midarea + (1.0f-sqr((v3-fx[first])/(v3-v2))) * (maxarea-midarea); } if (first < nbucket) cum[first] += maxarea; } inline void tetSurfIntegral(float *x1, float *x2, float *x3, float *x4, float v1, float v2, float v3, float v4, float *fx, float *val, int nbucket, float min, float max, float scaling) { //float *_t; float mid[3], mid2[3]; float vec1[3], vec2[3]/*, vec3[3]*/; float ival; float s; float area1, area2, midarea/*, volume*/; //float t; float cp[3]; u_int first; /*if (v4 < v3) { _t = x4; x4 = x3; x3 = _t; t = v4; v4 = v3; v3 = t; } if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; } if (v2 < v1) { _t = x2; x2 = x1; x1 = _t; t = v2; v2 = v1; v1 = t; } if (v4 < v3) { _t = x4; x4 = x3; x3 = _t; t = v4; v4 = v3; v3 = t; } if (v3 < v2) { _t = x3; x3 = x2; x2 = _t; t = v3; v3 = v2; v2 = t; } if (v4 < v3) { _t = x4; x4 = x3; x3 = _t; t = v4; v4 = v3; v3 = t; }*/ sortVerts(x1,x2,x3,x4, v1,v2,v3,v4); // need to compute point along v[0]->v[2] // a cell with constant value will not contribute to the length if (v4 == v1) return; // compute the first area if (v1 != v3) ival = (v3-v2)/(v3-v1); else ival = 0.0; mid[0] = (1.0f-ival)*x3[0] + (ival)*x1[0]; mid[1] = (1.0f-ival)*x3[1] + (ival)*x1[1]; mid[2] = (1.0f-ival)*x3[2] + (ival)*x1[2]; if (v1 != v4) ival = (v4-v2)/(v4-v1); else ival = 0.0; mid2[0] = (1.0f-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0f-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0f-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x2[0]; vec1[1] = mid[1]-x2[1]; vec1[2] = mid[2]-x2[2]; vec2[0] = mid2[0]-x2[0]; vec2[1] = mid2[1]-x2[1]; vec2[2] = mid2[2]-x2[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area1 = (float)(0.5 * fabs(sqrt(sqr(cp[0]) + sqr(cp[1]) + sqr(cp[2]))) * scaling); // compute the second area if (v2 != v4) ival = (v4-v3)/(v4-v2); else ival = 0.0; mid[0] = (1.0f-ival)*x4[0] + (ival)*x2[0]; mid[1] = (1.0f-ival)*x4[1] + (ival)*x2[1]; mid[2] = (1.0f-ival)*x4[2] + (ival)*x2[2]; if (v4 != v1) ival = (v4-v3)/(v4-v1); else ival = 0.0; mid2[0] = (1.0f-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0f-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0f-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x3[0]; vec1[1] = mid[1]-x3[1]; vec1[2] = mid[2]-x3[2]; vec2[0] = mid2[0]-x3[0]; vec2[1] = mid2[1]-x3[1]; vec2[2] = mid2[2]-x3[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area2 = (float)(0.5 * fabs(sqrt(sqr(cp[0]) + sqr(cp[1]) + sqr(cp[2]))) * scaling); if (v2-v1 != 0.0) midarea = area1 * (1.0f+(v3-v2)/(v2-v1)); else if (v4-v3 != 0.0) midarea = area2 * (1.0f+(v3-v2)/(v4-v3)); else { // have to compute the midarea /*vec1[0] = x2[0]-x1[0]; vec1[1] = x2[1]-x1[1]; vec1[2] = x2[2]-x1[2]; vec2[0] = x3[0]-x1[0]; vec2[1] = x3[1]-x1[1]; vec2[2] = x3[2]-x1[2]; vec3[0] = x4[0]-x1[0]; vec3[1] = x4[1]-x1[1]; vec3[2] = x4[2]-x1[2]; cp[0] = vec3[0]*(vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = vec3[1]*(vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = vec3[2]*(vec1[0]*vec2[1]-vec1[1]*vec2[0]); volume = (float)(fabs(sqrt(sqr(cp[0]) + sqr(cp[1]) + sqr(cp[2])))/6.0); midarea = volume * 3.0f;*/ vec1[0] = (x2[0]-x1[0])/2; vec1[1] = (x2[1]-x1[1])/2; vec1[2] = (x2[2]-x1[2])/2; vec2[0] = (x4[0]-x3[0])/2; vec2[1] = (x4[1]-x3[1])/2; vec2[2] = (x4[2]-x3[2])/2; cp[0] = (vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = (vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = (vec1[0]*vec2[1]-vec1[1]*vec2[0]); midarea = 2*(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])) - (area1+area2)/2; #ifdef DEBUG_VOLSURF printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); //return; #endif } //if (midarea > 3) { //printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); //printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); // sleep(5); //} first=(unsigned int)ceil(((nbucket-1) * (v1-min))/(max-min)); #ifdef DEBUG_VOLSURF printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); #endif // compute the for (; first < (unsigned int)nbucket && fx[first] < v2; first++) { if (v1 == v3) val[first] += area1; else { s = (fx[first]-v1)/(v2-v1); val[first] += s*s * area1; #ifdef DEBUG_VOLSURF printf("val[%d] (%f) += %f\n", first, fx[first], s*s*area1); #endif } } for (; first < (unsigned int)nbucket && fx[first] < v3; first++) { // val[first]+=sqr(1.0-((v4-fx[first])/(float)(v4-v2))) * maxlen; s = (fx[first]-v2)/(float)(v3-v2); val[first] += (1-s)*(1-s)*area1 + s*(1-s)*midarea + s*s*area2; #ifdef DEBUG_VOLSURF printf("val[%d] (%f) += %f\n", first, fx[first], (1-s)*(1-s)*area1 + s*(1-s)*midarea + s*s*area2); #endif } for (; first < (unsigned int)nbucket && fx[first] < v4; first++) { if (v4==v2) val[first] += area2; else { s = (fx[first]-v3)/(float)(v4-v3); val[first]+=(1.0f-s)*(1.0f-s) * area2; #ifdef DEBUG_VOLSURF printf("val[%d] (%f) += %f\n", first, fx[first], (1.0-s)*(1.0-s) * area2); #endif } } } /* // This is the old version. // It wasn't working for a very simple test case (a sphere). inline void tetVolIntegral(float *x1, float *x2, float *x3, float *x4, float v1, float v2, float v3, float v4, float *fx, float *val, float *cum, u_int nbucket, float min, float max, float scaling) { float *_t; float mid[3], mid2[3]; float vec1[3], vec2[3], vec3[3]; float ival; float s, s2, s3; float area1, area2, midarea, volume; float cum1; float t; float cp[3]; u_int first; sortVerts(x1,x2,x3,x4, v1,v2,v3,v4); // need to compute point along v[0]->v[2] // a cell with constant value will not contribute to the length //if (v4 == v1) // return; // compute the first area if (v1 != v3) ival = (v3-v2)/(v3-v1); else ival = 0.0; mid[0] = (1.0f-ival)*x3[0] + (ival)*x1[0]; mid[1] = (1.0f-ival)*x3[1] + (ival)*x1[1]; mid[2] = (1.0f-ival)*x3[2] + (ival)*x1[2]; if (v1 != v4) ival = (v4-v2)/(v4-v1); else ival = 0.0; mid2[0] = (1.0f-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0f-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0f-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x2[0]; vec1[1] = mid[1]-x2[1]; vec1[2] = mid[2]-x2[2]; vec2[0] = mid2[0]-x2[0]; vec2[1] = mid2[1]-x2[1]; vec2[2] = mid2[2]-x2[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area1 = (float)(0.5 * fabs(sqrt(sqr(cp[0]) + sqr(cp[1]) + sqr(cp[2]))) * scaling); // compute the second area if (v2 != v4) ival = (v4-v3)/(v4-v2); else ival = 0.0; mid[0] = (1.0f-ival)*x4[0] + (ival)*x2[0]; mid[1] = (1.0f-ival)*x4[1] + (ival)*x2[1]; mid[2] = (1.0f-ival)*x4[2] + (ival)*x2[2]; if (v4 != v1) ival = (v4-v3)/(v4-v1); else ival = 0.0; mid2[0] = (1.0f-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0f-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0f-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x3[0]; vec1[1] = mid[1]-x3[1]; vec1[2] = mid[2]-x3[2]; vec2[0] = mid2[0]-x3[0]; vec2[1] = mid2[1]-x3[1]; vec2[2] = mid2[2]-x3[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area2 = (float)(0.5 * fabs(sqrt(sqr(cp[0]) + sqr(cp[1]) + sqr(cp[2]))) * scaling); if (v2-v1 != 0.0) midarea = area1 * (1.0f+(v3-v2)/(v2-v1)); else if (v4-v3 != 0.0) midarea = area2 * (1.0f+(v3-v2)/(v4-v3)); else { // have to compute the midarea //vec1[0] = x2[0]-x1[0]; //vec1[1] = x2[1]-x1[1]; //vec1[2] = x2[2]-x1[2]; //vec2[0] = x3[0]-x1[0]; //vec2[1] = x3[1]-x1[1]; //vec2[2] = x3[2]-x1[2]; //vec3[0] = x4[0]-x1[0]; //vec3[1] = x4[1]-x1[1]; //vec3[2] = x4[2]-x1[2]; //cp[0] = vec3[0]*(vec1[1]*vec2[2]-vec1[2]*vec2[1]); //cp[1] = vec3[1]*(vec1[2]*vec2[0]-vec1[0]*vec2[2]); //cp[2] = vec3[2]*(vec1[0]*vec2[1]-vec1[1]*vec2[0]); //volume = (float)(fabs(sqrt(sqr(cp[0]) + sqr(cp[1]) + sqr(cp[2])))/6.0); //midarea = volume * 3.0f; vec1[0] = (x2[0]-x1[0])/2; vec1[1] = (x2[1]-x1[1])/2; vec1[2] = (x2[2]-x1[2])/2; vec2[0] = (x4[0]-x3[0])/2; vec2[1] = (x4[1]-x3[1])/2; vec2[2] = (x4[2]-x3[2])/2; cp[0] = (vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = (vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = (vec1[0]*vec2[1]-vec1[1]*vec2[0]); midarea = 2*(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])) - (area1+area2)/2; #ifdef DEBUG_VOLVOL printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); //return; #endif } //if (midarea > 3) { //printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); //printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); // sleep(5); //} first=(unsigned int)(ceil(((nbucket-1) * (v1-min))/(max-min))); #ifdef DEBUG_VOLVOL printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); #endif // compute the for (; fx[first] < v2; first++) { if (v1 == v3) val[first] += area1; else { s = (fx[first]-v1)/(v2-v1); val[first] += s*s*s*area1*(v2-v1)/3.0f; } } cum1 = area1*(v2-v1)/3.0f; for (; fx[first] < v3; first++) { s = (fx[first]-v2)/(float)(v3-v2); s2 = sqr(s); s3 = s2*s; val[first] += cum1 + (area1*(s - s2 + s3/3.0f) + midarea*(s2/2.0f - s3/3.0f) + area2*(s3/3.0f)) * (v3-v2); } cum1 += (area1/3.0f + midarea/6.0f + area2/3.0f) * (v3-v2); for (; fx[first] < v4; first++) { if (v4==v2) val[first] += area2; else { s = (fx[first]-v3)/(float)(v4-v3); s2 = sqr(s); s3 = s2*s; val[first] += cum1 + (area2*(s - s2 + s3/3.0f)) * (v4-v3); #ifdef DEBUG_VOLVOL printf("val[%d] (%f) += %f\n", first, fx[first], (1.0-s)*(1.0-s) * area2); #endif } } cum1 += area2/3.0f * (v4-v3); if (first < nbucket) cum[first] += cum1; }*/ // this version appears to work inline void tetVolIntegral(float *x1, float *x2, float *x3, float *x4, float v1, float v2, float v3, float v4, float *fx, float *val, float *cum, u_int nbucket, float min, float max, float scaling) { //float *_t; float mid[3], mid2[3]; float vec1[3], vec2[3], vec3[3]; float ival, tmpval; float s, s2, s3; float area1, area2, midarea, volume; float cum1; //float t; float cp[3]; u_int first=0; sortVerts(x1,x2,x3,x4, v1,v2,v3,v4); vec1[0] = x2[0]-x1[0]; vec1[1] = x2[1]-x1[1]; vec1[2] = x2[2]-x1[2]; vec2[0] = x3[0]-x1[0]; vec2[1] = x3[1]-x1[1]; vec2[2] = x3[2]-x1[2]; vec3[0] = x4[0]-x1[0]; vec3[1] = x4[1]-x1[1]; vec3[2] = x4[2]-x1[2]; cp[0] = vec3[0]*(vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = vec3[1]*(vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = vec3[2]*(vec1[0]*vec2[1]-vec1[1]*vec2[0]); volume = fabs(cp[0] + cp[1] + cp[2])/6.0; // compute the first area if (v1 != v3) ival = (v3-v2)/(v3-v1); else ival = 0.0; mid[0] = (1.0-ival)*x3[0] + (ival)*x1[0]; mid[1] = (1.0-ival)*x3[1] + (ival)*x1[1]; mid[2] = (1.0-ival)*x3[2] + (ival)*x1[2]; if (v1 != v4) ival = (v4-v2)/(v4-v1); else ival = 0.0; mid2[0] = (1.0-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x2[0]; vec1[1] = mid[1]-x2[1]; vec1[2] = mid[2]-x2[2]; vec2[0] = mid2[0]-x2[0]; vec2[1] = mid2[1]-x2[1]; vec2[2] = mid2[2]-x2[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area1 = 0.5 * fabs(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])); // compute the second area if (v2 != v4) ival = (v4-v3)/(v4-v2); else ival = 0.0; mid[0] = (1.0-ival)*x4[0] + (ival)*x2[0]; mid[1] = (1.0-ival)*x4[1] + (ival)*x2[1]; mid[2] = (1.0-ival)*x4[2] + (ival)*x2[2]; if (v4 != v1) ival = (v4-v3)/(v4-v1); else ival = 0.0; mid2[0] = (1.0-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x3[0]; vec1[1] = mid[1]-x3[1]; vec1[2] = mid[2]-x3[2]; vec2[0] = mid2[0]-x3[0]; vec2[1] = mid2[1]-x3[1]; vec2[2] = mid2[2]-x3[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area2 = 0.5 * fabs(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])); if (v2-v1 >= v4-v3) midarea = area1 * (1.0+(v3-v2)/(v2-v1)); else if (v4-v3 > v2-v1) midarea = area2 * (1.0+(v3-v2)/(v4-v3)); else { //assert(0); // This formula is wrong -- xiaoyu // have to compute the midarea vec1[0] = (x2[0]-x1[0])/2; vec1[1] = (x2[1]-x1[1])/2; vec1[2] = (x2[2]-x1[2])/2; vec2[0] = (x4[0]-x3[0])/2; vec2[1] = (x4[1]-x3[1])/2; vec2[2] = (x4[2]-x3[2])/2; cp[0] = (vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = (vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = (vec1[0]*vec2[1]-vec1[1]*vec2[0]); midarea = 2*(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])) - (area1+area2)/2; #ifdef DEBUG_VOLVOL printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); #endif } #ifdef DEBUG_VOLVOL printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); #endif float vol2 = ((v3-v1)*area1 + (v3-v2)*midarea + (v4-v2)*area2)/3; float factor = volume / vol2; //if (fx <= v1) return 0; for (; first < nbucket && fx[first] <= v1; first++) val[first] += 0.0; // compute the for (; first < nbucket && fx[first] < v2; first++) { if (v1 == v2) val[first] += 0.0; else { s = (fx[first]-v1)/(v2-v1); val[first] += factor*s*s*s*area1*(v2-v1)/3.0; } } cum1 = area1*(v2-v1)/3.0; for (; first < nbucket && fx[first] < v3; first++) { s = (fx[first] - v2)/(float)(v3-v2); s2 = s*s; s3 = s2*s; tmpval = cum1 + (area1*(s - s2 + s3/3.0) + 2*midarea*(s2/2.0 - s3/3.0) + area2*(s3/3.0)) * (v3-v2); val[first] += factor*tmpval; } cum1 += (area1/3.0 + midarea/3.0 + area2/3.0) * (v3-v2); for (; first < nbucket && fx[first] < v4; first++) { if (v4==v2) tmpval = area2; else { s = (fx[first]-v3)/(float)(v4-v3); s2 = s*s; s3 = s2*s; tmpval = cum1 + (area2*(s - s2 + s3/3.0)) * (v4-v3); #ifdef DEBUG_VOLVOL printf("val (%f) = %f\n", fx[first], (1.0-s)*(1.0-s) * area2); #endif } val[first] += factor * tmpval; } for (; first < nbucket; first++) val[first] += volume; } /** * Calculate the volume of the portion of a tetrahedron with f < fx * @note Assume v1 < v2 < v3 < v4 */ #if 0 float tetVolume(float x1[3], float x2[3], float x3[3], float x4[3], float v1, float v2, float v3, float v4, float fx) { float *_t; float mid[3], mid2[3]; float vec1[3], vec2[3], vec3[3]; float ival, val; float s, s2, s3; float area1, area2, midarea, volume; float cum1; float t; float cp[3]; unsigned int first; //assert(v1 < v2 && v2 < v3 && v3 < v4); //normalize the values to [0, 1]; /* v2 = (v2-v1)/(v4-v1); v3 = (v3-v1)/(v4-v1); fx = (fx-v1)/(v4-v1); v1 = 0; v4 = 1; */ if (fx <= v1) return 0; vec1[0] = x2[0]-x1[0]; vec1[1] = x2[1]-x1[1]; vec1[2] = x2[2]-x1[2]; vec2[0] = x3[0]-x1[0]; vec2[1] = x3[1]-x1[1]; vec2[2] = x3[2]-x1[2]; vec3[0] = x4[0]-x1[0]; vec3[1] = x4[1]-x1[1]; vec3[2] = x4[2]-x1[2]; cp[0] = vec3[0]*(vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = vec3[1]*(vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = vec3[2]*(vec1[0]*vec2[1]-vec1[1]*vec2[0]); //volume = sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])/6.0; volume = fabs(cp[0] + cp[1] + cp[2])/6.0; if (fx >= v4) return volume; // compute the first area if (v1 != v3) ival = (v3-v2)/(v3-v1); else ival = 0.0; mid[0] = (1.0-ival)*x3[0] + (ival)*x1[0]; mid[1] = (1.0-ival)*x3[1] + (ival)*x1[1]; mid[2] = (1.0-ival)*x3[2] + (ival)*x1[2]; if (v1 != v4) ival = (v4-v2)/(v4-v1); else ival = 0.0; mid2[0] = (1.0-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x2[0]; vec1[1] = mid[1]-x2[1]; vec1[2] = mid[2]-x2[2]; vec2[0] = mid2[0]-x2[0]; vec2[1] = mid2[1]-x2[1]; vec2[2] = mid2[2]-x2[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area1 = 0.5 * fabs(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])); // compute the second area if (v2 != v4) ival = (v4-v3)/(v4-v2); else ival = 0.0; mid[0] = (1.0-ival)*x4[0] + (ival)*x2[0]; mid[1] = (1.0-ival)*x4[1] + (ival)*x2[1]; mid[2] = (1.0-ival)*x4[2] + (ival)*x2[2]; if (v4 != v1) ival = (v4-v3)/(v4-v1); else ival = 0.0; mid2[0] = (1.0-ival)*x4[0] + (ival)*x1[0]; mid2[1] = (1.0-ival)*x4[1] + (ival)*x1[1]; mid2[2] = (1.0-ival)*x4[2] + (ival)*x1[2]; vec1[0] = mid[0]-x3[0]; vec1[1] = mid[1]-x3[1]; vec1[2] = mid[2]-x3[2]; vec2[0] = mid2[0]-x3[0]; vec2[1] = mid2[1]-x3[1]; vec2[2] = mid2[2]-x3[2]; cp[0] = vec1[1]*vec2[2]-vec1[2]*vec2[1]; cp[1] = vec1[2]*vec2[0]-vec1[0]*vec2[2]; cp[2] = vec1[0]*vec2[1]-vec1[1]*vec2[0]; area2 = 0.5 * fabs(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])); if (v2-v1 >= v4-v3) midarea = area1 * (1.0+(v3-v2)/(v2-v1)); else if (v4-v3 > v2-v1) midarea = area2 * (1.0+(v3-v2)/(v4-v3)); else { assert(0); // This formula is wrong -- xiaoyu // have to compute the midarea vec1[0] = (x2[0]-x1[0])/2; vec1[1] = (x2[1]-x1[1])/2; vec1[2] = (x2[2]-x1[2])/2; vec2[0] = (x4[0]-x3[0])/2; vec2[1] = (x4[1]-x3[1])/2; vec2[2] = (x4[2]-x3[2])/2; cp[0] = (vec1[1]*vec2[2]-vec1[2]*vec2[1]); cp[1] = (vec1[2]*vec2[0]-vec1[0]*vec2[2]); cp[2] = (vec1[0]*vec2[1]-vec1[1]*vec2[0]); midarea = 2*(sqrt(cp[0]*cp[0] + cp[1]*cp[1] + cp[2]*cp[2])) - (area1+area2)/2; #ifdef DEBUG_VOLVOL printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); #endif } #ifdef DEBUG_VOLVOL printf("1: %f 2: %f mid: %f\n", area1, area2, midarea); printf("v1: %f v2: %f v3: %f v4: %f\n", v1, v2, v3, v4); #endif float vol2 = ((v3-v1)*area1 + (v3-v2)*midarea + (v4-v2)*area2)/3; float factor = volume / vol2; // compute the if (fx < v2) { if (v1 == v2) return 0; else { s = (fx-v1)/(v2-v1); return factor*s*s*s*area1*(v2-v1)/3.0; } } cum1 = area1*(v2-v1)/3.0; if (fx < v3) { s = (fx - v2)/(float)(v3-v2); s2 = s*s; s3 = s2*s; val = cum1 + (area1*(s - s2 + s3/3.0) + 2*midarea*(s2/2.0 - s3/3.0) + area2*(s3/3.0)) * (v3-v2); return factor*val; } cum1 += (area1/3.0 + midarea/3.0 + area2/3.0) * (v3-v2); if (fx < v4) { if (v4==v2) val = area2; else { s = (fx-v3)/(float)(v4-v3); s2 = s*s; s3 = s2*s; val = cum1 + (area2*(s - s2 + s3/3.0)) * (v4-v3); #ifdef DEBUG_VOLVOL printf("val (%f) = %f\n", fx, (1.0-s)*(1.0-s) * area2); #endif } return factor * val; } cum1 += area2/3.0 * (v4-v3); return factor * cum1; } #endif /* add by Fan: signature: volume of the region where two variables are intercepted with area ..... */ inline void intVolIntegral(float **p, float *u, float *v, float fx1[], float **val1,float fx2[], float **val2, int nbucket, float min1, float max1, float min2, float max2, float scaling) { u_int first1, first2; //float alph0, beta0; float alph, beta; int i,j; alph = 0.; beta = 0.; for(i=0; i<8; i++){ alph = alph + u[i]; beta = beta + v[i]; } alph = alph/8.0f; beta = beta/8.0f; #if 1 first1 = (unsigned int)( ceil(((nbucket-1) * (alph-min1))/(max1-min1)) ); first2 = (unsigned int)( ceil(((nbucket-1) * (beta-min2))/(max2-min2)) ); /* for alph > alph0 and beta > beta0 */ for(i=first1; i=0; i--){ for(j=first2-1; j>=0; j--){ val2[i][j] += 1.0; } } #endif /* this part will be handeled later */ #if 0 /* for alph > alph0 and beta < beta0 */ for(i=first1; i=0; j--){ val1[i][j] -= 1.0; val2[i][j] -= 1.0; } } /* for alph < alph0 and beta > beta0 */ for(i=first1; i>=0; i--){ for(j=first2; j //------------------------------------------------------------------------ // // convert_short() - convert a short int to big endian format // //------------------------------------------------------------------------ inline short convert_short(short i) { return (((i & 0xff) << 8) | ((i & 0xff00) >> 8)); } //------------------------------------------------------------------------ // // convert_long() - convert a long int to big endian format // //------------------------------------------------------------------------ inline int convert_int(int i) { return (((i & 0xff) << 24) | ((i & 0xff00) << 8) | ((i & 0xff0000) >> 8) | ((i & 0xff000000) >> 24)); } inline long convert_long(long i) { long f; unsigned char *iptr = (unsigned char*)&i; unsigned char *optr = (unsigned char*)&f; *(optr+7) = *iptr; *(optr+6) = *(iptr+1); *(optr+5) = *(iptr+2); *(optr+4) = *(iptr+3); *(optr+3) = *(iptr+4); *(optr+2) = *(iptr+5); *(optr+1) = *(iptr+6); *optr = *(iptr+7); return f; } //------------------------------------------------------------------------ // // convert_float() - convert a single precision float to big endian format // //------------------------------------------------------------------------ inline float convert_float(float i) { float f; unsigned char *iptr = (unsigned char*)&i; unsigned char *optr = (unsigned char*)&f; *(optr+3) = *iptr; *(optr+2) = *(iptr+1); *(optr+1) = *(iptr+2); *optr = *(iptr+3); return f; } //------------------------------------------------------------------------ // // convert_double() - convert double precision real to big endian format // //------------------------------------------------------------------------ inline double convert_double(double i) { double d; unsigned char *iptr = (unsigned char*)&i; unsigned char *optr = (unsigned char*)&d; *(optr+7) = *iptr; *(optr+6) = *(iptr+1); *(optr+5) = *(iptr+2); *(optr+4) = *(iptr+3); *(optr+3) = *(iptr+4); *(optr+2) = *(iptr+5); *(optr+1) = *(iptr+6); *optr = *(iptr+7); return d; } //------------------------------------------------------------------------ // // fread_short() - read (and possibly convert) short integer data // //------------------------------------------------------------------------ inline size_t fread_short(void *ptr, size_t size, size_t nitems, FILE *stream) { #ifdef _LITTLE_ENDIAN unsigned int i; // an item index variable short *item; // an item pointer index size_t ret_size; // number of items read ret_size = fread(ptr, size, nitems, stream); item = (short *)ptr; for (i = 0; i < ret_size; i++) { *item = convert_short(*item); item++; } return ret_size; #else return fread(ptr, size, nitems, stream); #endif } //------------------------------------------------------------------------ // // fread_int() - read (and possibly convert) long integer data // //------------------------------------------------------------------------ inline size_t fread_int(void *ptr, size_t size, size_t nitems, FILE *stream) { #ifdef _LITTLE_ENDIAN unsigned int i; // an item index variable int *itemInt; // an item pointer index long *itemLong; // an item pointer index size_t ret_size; // number of items read ret_size = fread(ptr, size, nitems, stream); if (size == 4) { itemInt = (int *)ptr; for (i = 0; i < ret_size; i++) { *itemInt = convert_int(*itemInt); itemInt++; } } else if (size == 8) { itemLong = (long *)ptr; for (i = 0; i < ret_size; i++) { *itemLong = convert_long(*itemLong); itemLong++; } } else { } return ret_size; #else return fread(ptr, size, nitems, stream); #endif } //------------------------------------------------------------------------ // // fread_float() - read (and possibly convert) single precision data // //------------------------------------------------------------------------ inline size_t fread_float(void *ptr, size_t size, size_t nitems, FILE *stream) { #ifdef _LITTLE_ENDIAN unsigned int i; // an item index variable float *item; // an item pointer index size_t ret_size; // number of items read ret_size = fread(ptr, size, nitems, stream); item = (float *)ptr; for (i = 0; i < ret_size; i++) { *item = convert_float(*item); item++; } return ret_size; #else return fread(ptr, size, nitems, stream); #endif } //------------------------------------------------------------------------ // // fread_double() - read (and possibly convert) double precision data // //------------------------------------------------------------------------ inline size_t fread_double(void *ptr, size_t size, size_t nitems, FILE *stream) { #ifdef _LITTLE_ENDIAN unsigned int i; // an item index variable double *item; // an item pointer index size_t ret_size; // number of items read ret_size = fread(ptr, size, nitems, stream); item = (double *)ptr; for (i = 0; i < ret_size; i++) { *item = convert_double(*item); item++; } return ret_size; #else return fread(ptr, size, nitems, stream); #endif } #endif /* of _ENDIAN_IO_H_ */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/contour3d.h0000644000175000017500000000605010352632600025377 0ustar debiandebian// ______________________________________________________________________ // // FILE // contour3d.h - class for a 3d isocontour surface // // Copyright (c) 1998 Emilio Camahort, Dan Schikore // // DESCRIPTION // contour3d is a class for representing a contour surface (or any // 3d triangular mesh). // ______________________________________________________________________ // $Id: contour3d.h,v 1.2 2005/12/22 23:23:44 annao Exp $ #ifndef _CONTOUR_3D_H #define _CONTOUR_3D_H #include #include #ifdef USEDICT #include "dict.h" // added by Joe Rivera - 12/21/2005 #endif #ifdef WIN32 typedef unsigned int u_int; #endif class Contour3d { public: // constructor Contour3d(int fn=0); // destructor ~Contour3d(); // to color isosurface using another variable (for multivariate data) void colorByFun(int c) { color = c; } void minmaxFun(float mn, float mx) { fmin=mn; fmax=mx; } // reset (delete all vertices and triangles) void Reset(void); void Done(void); int isDone(void) { return(done); } // add a vertex with the given position and normal int AddVert(float p[3], float n[3], float f=0.0) { return(AddVert(p[0], p[1], p[2], n[0], n[1], n[2], f)); } int AddVert(float, float, float, float, float, float, float f=0.0); int AddVertUnique(float p[3], float n[3], float f=0.0) { return(AddVertUnique(p[0], p[1], p[2], n[0], n[1], n[2], f)); } int AddVertUnique(float, float, float, float, float, float, float f=0.0); // add a triangle indexed by the given 3 vertices int AddTri(u_int v[3]) { return(AddTri(v[0], v[1], v[2])); } int AddTri(u_int, u_int, u_int); // get the number of vertices or triangles int getSize(void) { return(ntri); } int getNVert(void) { return(nvert); } int getNTri(void) { return(ntri); } // write vertices and triangles to a file int write(char *filename); void setExtent(float min[3], float max[3]) { memcpy(minext, min, sizeof(float[3])); memcpy(maxext, max, sizeof(float[3])); } protected: int done; // done with isocontour?? // the size of the vertex and triangle arrays int vsize, tsize; // the number of vertices and triangles int nvert, ntri; float minext[3], maxext[3]; /* Added by Joe R - 12/21/2005, used for fast searching of duplicate vertices */ #ifdef USEDICT dict_t vertex_dict; #endif public : // made public by Emilio // true if colored by function on contour int color; int vf; // variable used for coloring float fmin, fmax; // min and max color values // arrays of vertices, vertex normals, and triangles float (*vert)[3]; // isosurface vertex array float (*vnorm)[3]; // array of vertex normals float (*vfun); // color values at vertices unsigned int (*tri)[3]; // triangle mesh array }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplotreg2.cpp0000644000175000017500000001563211065020741026255 0ustar debiandebian//------------------------------------------------------------------------ // // conplotreg2.C - preprocess and extract contours from 2d scalar data // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: conplotreg2.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #include #ifndef WIN32 #include #endif #include "conplot.h" #include "contour2d.h" #include "range.h" #include "segtree.h" #include "conplotreg2.h" extern int verbose; extern void (*errorHandler)(char *, int); //------------------------------------------------------------------------ // // rect2d - a local static variable // //------------------------------------------------------------------------ static int rect2d[16][5] = { {0}, {1, 3, 0}, {1, 0, 1}, {1, 3, 1}, {1, 1, 2}, {2, 3, 2, 1, 0}, {1, 0, 2}, {1, 3, 2}, {1, 2, 3}, {1, 2, 0}, {2, 0, 3, 2, 1}, {1, 2, 1}, {1, 1, 3}, {1, 1, 0}, {1, 0, 3}, {0} }; //------------------------------------------------------------------------ // // Conplotreg2() - create a contour plot for the given image. // //------------------------------------------------------------------------ Conplotreg2::Conplotreg2(Datasetreg2 *d) : Conplot(d) { float min[3], max[3]; int i; reg2 = d; if (verbose > 1) { printf("***** Data Characteristics\n"); printf("cells: %d\n", reg2->getNCells()); printf("*****\n"); } contour2d = con2 = new Contour2d[reg2->nTime()]; contour3d = NULL; data->getData(0)->getExtent(min, max); if (verbose) { printf("minextent: %f %f %f\n", min[0], min[1], min[2]); printf("maxextent: %f %f %f\n", max[0], max[1], max[2]); } for (i=0; inTime(); i++) con2[i].setExtent(min,max); if (verbose > 1) printf("contour3d is %x, contour2d is %x\n", contour3d, con2); } //------------------------------------------------------------------------ // // ~Conplotreg2() - destroy a plot // //------------------------------------------------------------------------ Conplotreg2::~Conplotreg2() { } //------------------------------------------------------------------------ // // InterpEdge() - interpolate .... // //------------------------------------------------------------------------ int Conplotreg2::InterpEdge(int edge, float *val, float isovalue, int i, int j) { float ival; float pt[2]; switch (edge) { case 0: ival = (isovalue-val[1])/(val[0]-val[1]); pt[0] = (1.0f-ival) * curreg2->xCoord(i+1) + ival * curreg2->xCoord(i+0); pt[1] = curreg2->yCoord(j); break; case 1: ival = (isovalue-val[2])/(val[1]-val[2]); pt[0] = curreg2->xCoord(i+1); pt[1] = (1.0f-ival) * curreg2->yCoord(j+1) + ival * curreg2->yCoord(j+0); break; case 2: ival = (isovalue-val[3])/(val[2]-val[3]); pt[0] = (1.0f-ival) * curreg2->xCoord(i+0) + ival * curreg2->xCoord(i+1); pt[1] = curreg2->yCoord(j+1); break; case 3: ival = (isovalue-val[0])/(val[3]-val[0]); pt[0] = curreg2->xCoord(i); pt[1] = (1.0f-ival) * curreg2->yCoord(j+0) + ival * curreg2->yCoord(j+1); break; } return(curcon->AddVert(pt)); } //------------------------------------------------------------------------ // // EnqueueFaces() - enqueue adjacent faces for propagation of contour // code = case table lookup code for current cell // i,j,k = index of current cell // thisslice = queue of cells to be processed on current slice // nextslice = queue of cells to be processed on next slice // trackinz = flag indicating whether to propagate in z-dir // 0 -> don't track in z, but queue cells in nextslice // 1 -> propagate contour in all 3 dim // //------------------------------------------------------------------------ inline void Conplotreg2::EnqueueFaces(int code, int c, CellQueue &thisslice) { } //------------------------------------------------------------------------ // // TrackContour() - compute and track a contour by table lookup and propagation // through adjacent cells // isovalue = surface value of interest // i,j,k = index of seed cell // nextslice = queue of seeds for next slice (used only if tracking in 2d) // //------------------------------------------------------------------------ void Conplotreg2::TrackContour(float isovalue, int cell) { float val[4]; int i, j; u_int v1, v2; int code; int adj; int e; int nvert=0, nedge=0; // to save isocontour components queue.Add(cell); curreg2 = (Datareg2*)data->getData(curtime); curcon = &con2[curtime]; if (filePrefix) // keep track of current nvert, nedge { nvert = curcon->getNVert(); nedge = curcon->getNEdge(); } while (queue.Get(cell) > 0) { curreg2->getCellValues(cell, val); curreg2->cell2index(cell, i, j); code = 0; if (val[0] < isovalue) code += 0x01; if (val[1] < isovalue) code += 0x02; if (val[2] < isovalue) code += 0x04; if (val[3] < isovalue) code += 0x08; for (e=0; eAddEdge(v1, v2); adj = curreg2->getCellAdj(cell, rect2d[code][2*e+1]); if (adj != -1 && !CellTouched(adj)) { TouchCell(adj); queue.Add(adj); } adj = curreg2->getCellAdj(cell, rect2d[code][2*e+2]); if (adj != -1 && !CellTouched(adj)) { TouchCell(adj); queue.Add(adj); } } EnqueueFaces(code, cell, queue); } if (filePrefix) // write this isocontour component { if (curcon->getNEdge() - nedge > 25) // more than 25 edges { FILE *fp; int v, e; char filename[200]; sprintf(filename, "%s%04d.ipoly", filePrefix, ncomponents); if ( (fp = fopen(filename, "w")) ) { fprintf(fp, "%d %d 0 0 0 0 0\n0 0 0\n", curcon->getNVert() - nvert, curcon->getNEdge() - nedge); for (v = nvert; v < curcon->getNVert(); v++) fprintf(fp, "%g %g %g\n", curcon->vert[v][0], curcon->vert[v][1], 0.0); fprintf(fp, "0 0\n"); for (e = nedge; e < curcon->getNEdge(); e++) fprintf(fp, "%d %d\n", curcon->edge[e][0], curcon->edge[e][1]); fclose(fp); ncomponents++; } else { char str[256]; sprintf(str, "Conplotreg2::TrackContour: couldn't open file: %s", filename); errorHandler(str, FALSE); } } } } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/respprop2.h0000644000175000017500000000073110064121655025416 0ustar debiandebian // $Id: respprop2.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef RESP_PROP2_H #define RESP_PROP2_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class Datavol; class Dataslc; class respProp2 { public: respProp2(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~respProp2() {} void compSeeds(void); private: Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/rangesweep.h0000644000175000017500000000171310064121655025623 0ustar debiandebian // $Id: rangesweep.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef RANGE_SWEEP_H #define RANGE_SWEEP_H #include "range.h" // #include "spqueue.h" #include "ipqueue.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class RangeSweepRec { public: // operator <(RangeSweepRec&r2) { return(this->cellid < r2.cellid); } // operator >(RangeSweepRec&r2) { return(this->cellid > r2.cellid); } // operator ==(RangeSweepRec&r2) { return(this->cellid == r2.cellid); } int cellid; Range range; }; class rangeSweep { public: rangeSweep(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~rangeSweep() {} void compSeeds(void); private: void PropagateRegion(int cellid, float min, float max); // SortedPriorityQueue queue; IndexedPriorityQueue queue; Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/rangeprop.cpp0000644000175000017500000001127610064121655026020 0ustar debiandebian // $Id: rangeprop.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include #include "rangeprop.h" #define DEBUGNo extern int verbose; void rangeProp::compSeeds(void) { RangePropRec rpr, *item, *qitem; Range fullrange, added, outgoing; int index; float min, max; int adjc; int done; u_int c; if (verbose) printf("------- computing seeds\n"); // clear the array of mark bits plot.ClearTouched(); seeds.Clear(); // insert cell 0 into queue to begin rpr.cellid = 0; data.getCellRange(0, min, max); rpr.resp.Set(min, max); rpr.comp.MakeEmpty(); queue.enqueue(rpr); done = 0; // process queue of cells while (! queue.isEmpty() ) { // get the item item = queue.dequeue(); done++; if (verbose) if (done % 1000 == 0) printf("%g%% done\n", 100.0*done/(float)data.getNCells()); #ifdef DEBUG { int i; sleep(1); printf("processing cell %d\n", item->cellid); printf(" verts: "); for (i=0; icellid, i)); printf(" values: "); for (i=0; icellid, i))); printf("\nresp: "); item->resp.Print(); printf("comp: "); item->comp.Print(); } #endif // mark this cell as processed plot.TouchCell(item->cellid); #ifdef DEBUG printf("touched cell %d\n", item->cellid); #endif // compute the outgoing range (range which can be further propagated) outgoing.MakeEmpty(); #ifdef DEBUG printf("%d adjacencies\n", data.getNCellFaces()); #endif for (c=0; ccellid, c); #ifdef DEBUG printf("adj cell %d\n", adjc); #endif if (adjc != -1 && !plot.CellTouched(adjc)) { // the range of the shared face may be propagated data.getFaceRange(item->cellid, c, min, max); outgoing += Range(min,max); } } #ifdef DEBUG printf("outgoing range: "); outgoing.Print(); #endif // this is the full range of responsibility fullrange = (item->resp + outgoing) - item->comp; #ifdef DEBUG printf("fullrange: "); fullrange.Print(); #endif if (fullrange.Empty() || (!outgoing.Empty() && (outgoing.MinAll() <= fullrange.MinAll() && outgoing.MaxAll() >= fullrange.MaxAll()))) { #ifdef DEBUG printf("propagated\n"); #endif // propagate entire range for (c=0; ccellid, c); if (adjc != -1 && !plot.CellTouched(adjc)) { data.getFaceRange(item->cellid, c, min, max); // compute the range which should be propagated to this cell added = Range(min,max) - item->comp; item->comp += Range(min,max); #ifdef DEBUG printf(" adj %d:\n", adjc); #endif rpr.cellid = adjc; if ((index=queue.find(rpr)) != -1) { qitem=queue.getItem(index); qitem->resp += added; qitem->comp = Range(min,max) - added; #ifdef DEBUG printf(" found cell, new resp: "); qitem->resp.Print(); printf(" new comp: "); qitem->comp.Print(); #endif } else { rpr.resp = added; rpr.comp = Range(min,max) - added; queue.enqueue(rpr); #ifdef DEBUG printf(" new cell, resp: "); rpr.resp.Print(); printf(" comp: "); rpr.comp.Print(); #endif } } } } else { #ifdef DEBUG printf("seed cell\n"); #endif // cell is a seed cell seeds.AddSeed(item->cellid, fullrange.MinAll(), fullrange.MaxAll()); // set range of faces to the _complement_ of adjacent cells for (c=0; ccellid, c); if (adjc != -1 && !plot.CellTouched(adjc)) { data.getFaceRange(item->cellid, c, min, max); rpr.cellid = adjc; if ((index=queue.find(rpr)) != -1) { qitem=queue.getItem(index); qitem->comp.Set(min,max); // qitem->comp += Range(min,max); // note : can we ADD to the comp here? } else { rpr.resp.MakeEmpty(); rpr.comp.Set(min,max); queue.enqueue(rpr); } } } } } // for (c=0; c #include "contour3d.h" #include "dataset.h" #include "segtree.h" #include "seedcells.h" #include "cellqueue.h" #include "edgehash.h" #include "range.h" #include "datasetvol.h" #include "conplot.h" //------------------------------------------------------------------------ // // conplot3d.h // //------------------------------------------------------------------------ class Conplot3d : public Conplot { public: Conplot3d(Datasetvol *d); ~Conplot3d(); protected: // extract in 3d (from memory) or slice-by-slice (swap from disk) u_int ExtractAll(float isovalue); int InterpEdge(int, float *, u_int *, float, int); // track a contour from a seed cell void TrackContour(float, int); // enqueue faces for propagation of surface inline void EnqueueFaces(int, int, CellQueue &); void Reset(int t) { con3[t].Reset(); } int Size(int t) { return(con3[t].getSize()); } int isDone(int t) { return(con3[t].isDone()); } void Done(int t) { con3[t].Done(); } private: Datasetvol *vol; Datavol *curvol; Contour3d *con3, *curcon; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/ipqueue.h0000644000175000017500000001617511066274451025156 0ustar debiandebian/*****************************************************************************\ * * ipqueue.h -- * * * Author: Dan Schikore * * Adapted from pqueue.h * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: ipqueue.h,v 1.4 2008/09/23 23:18:01 annao Exp $ #ifndef __IPQUEUE_H #define __IPQUEUE_H #include #include "basic.h" #include "bin.h" #include "hash.h" extern int verbose; template class IndexedPriorityQueue; template class IPqueuerec; template class IPhashrec; // a wrapper for the items template class IPqueuerec { public: IPqueuerec() {} // IPqueuerec(IPhashrec &r, P p, K k) : rec(r), priority(p), key(k) { } T* getItem(void) { return(rec->getItem()); } const K& getKey(void) { return(key); } private: friend class IndexedPriorityQueue; IPhashrec *rec; P priority; K key; }; // a wrapper for the hash template class IPhashrec { public: IPhashrec(T t) { item=t; } T* getItem(void) { return(&item); } void setLoc(int l) { qloc = l; } int getLoc(void) const { return(qloc); } bool eq(const K &k) const { return(k == (*bin)[qloc].getKey()); } private: friend class IndexedPriorityQueue; // DATA T item; int qloc; Bin< IPqueuerec > *bin; }; /** A templated indexed priority queue. a priority queue which is searchable for a given item The number of #Pqueuerecs# that can be put into this queue is given as a parameter when the object is created ( or a default is used when no parameter is given). This number does not change. */ template class IndexedPriorityQueue { public: /// Constructor. IndexedPriorityQueue( int blocksize=0 ); /// Reinitialize. void cleanUp(); /// Insert #item# into the queue with priority #priority#. void insert( const T& item, const P &priority, const K &key ); /// Removes the element with highest priority from the queue. P extract(T& item); /// Return the element with highest priority from the queue. P max(T& item); /// Return #true# if the queus is empty, false otherwise. bool isEmpty(); void remove(K); int numItems(void) { return(_q.numItems()); } T *find(const K &); int updatePriority(K k, P p); protected: // int hashFun(const K&); static bool eqFun(const K &, const IPhashrec&); // Used by extract to keep the tree partially ordered. void sink(int i); private: // DATA HashTable < IPhashrec, K > _h; // hash table for finding items Bin < IPqueuerec > _q; }; #define frac(x) ((x) - floor(x)) static int hashFun(const int &i) { static double A = (sqrt(5.0)-1)/2.0; return(int(floor(30011 * frac(A*i)))); } template bool IndexedPriorityQueue::eqFun(const K &k, const IPhashrec&hr) { return(hr.eq(k)); } //template //inline //int IndexedPriorityQueue::hashFun(const int &i) //{ // static double A = (sqrt(5)-1)/2.0; // // return(floor(30011 * frac(A*i))); //} //template //inline //bool IndexedPriorityQueue::eqFun(const K &k, const IPhashrec&hr) //{ // return(k == _q[hr.getLoc()].key); //} /*****************************************************************************\ * \*****************************************************************************/ template inline IndexedPriorityQueue::IndexedPriorityQueue( int blocksize ) : _h(30011, hashFun, eqFun) { _q.setBlocksize(blocksize); } template inline void IndexedPriorityQueue::cleanUp() { _q.cleanUp(); } template inline void IndexedPriorityQueue::insert(const T& new_item, const P& priority, const K& key) { IPhashrec *inserted; int i, p; // if (_h.fetch(key) != NULL) { // printf("reinserting item!\n"); // sleep(20); // } // add the item to the hash _h.add(key, IPhashrec(new_item), inserted); inserted->bin = &_q; // insert the item into the priority queue i = _q.numItems(); _q.add(); p = (i-1)/2; while( i > 0 && _q[p].priority < priority ) { _q[i] = _q[p]; _q[i].rec->setLoc(i); i = p; p = (i-1)/2; } _q[i].rec = inserted; _q[i].rec->setLoc(i); _q[i].priority = priority; _q[i].key = key; } template inline void IndexedPriorityQueue::sink(int i) { int l, r, max; while( 1 ) { l = 2*i+1; r = 2*i+2; max = ( (l < _q.numItems()) && (_q[l].priority > _q[i].priority) ? l : i ); max = ( (r < _q.numItems()) && (_q[r].priority > _q[max].priority) ? r : max ); if( max == i ) { break; } else { swap(_q[max], _q[i]); _q[max].rec->setLoc(max); _q[i].rec->setLoc(i); i = max; } } } template inline P IndexedPriorityQueue::extract(T& item) { P p = _q[0].priority; #ifdef SP2 // modified by Emilio: it appears to be a bug!! K key = _q[0].key; #else K key = this->q[0].key; #endif // return the item #ifdef SP2 // modified by Emilio: it appears to be a bug!! item = *(_q[0].rec->getItem()); #else item = _q[0].rec.getItem(); #endif // remove the item from the hash if (verbose) if (!_h.remove(key)) { printf("failed removing from hash\n"); sleep(5); } // remove the item from the priority queue _q[0] = _q[_q.numItems()-1]; _q[0].rec->setLoc(0); _q.removeLast(); sink(0); return p; } template inline void IndexedPriorityQueue::remove(K k) { IPhashrec *hr; int i; hr = _h.fetch(k); i = hr->getLoc(); // remove the item from the hash if (verbose) if (!_h.remove(k)) { printf("failed removing from hash\n"); #ifndef WIN32 sleep(5); #endif } // remove the item from the priority queue _q[i] = _q[_q.numItems()-1]; _q[i].rec->setLoc(i); _q.removeLast(); sink(i); } template inline P IndexedPriorityQueue::max(T& item) { item = *(_q[0].rec->getItem()); return _q[0].priority; } template inline T *IndexedPriorityQueue::find(const K &k) { IPhashrec *hr; hr = _h.fetch(k); if (hr == NULL)// { // int i; // //for (i=0; i<_q.numItems(); i++) // if (_q[i].key == k) { // printf("didn't fetch but I found it!\n"); // sleep(5); // } return(NULL); //} return(hr->getItem()); } template inline int IndexedPriorityQueue::updatePriority(K k, P p) { IPhashrec *hr; hr = _h.fetch(k); if (hr == NULL) return(-1); // change the priority and sink the item _q[hr->getLoc()].priority = p; sink(hr->getLoc()); return(1); } template inline bool IndexedPriorityQueue::isEmpty() { return _q.numItems() == 0; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dirseedsreg2.h0000644000175000017500000000100410064121655026036 0ustar debiandebian // $Id: dirseedsreg2.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef DIR_SEEDS_REG2_H #define DIR_SEEDS_REG2_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class Datareg2; class dirSeedsReg2 { public: dirSeedsReg2(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~dirSeedsReg2() {} void compSeeds(void); private: void dirSweep(Datareg2 ®); Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/bucketsearch.h0000644000175000017500000000215310064121655026125 0ustar debiandebian//---------------------------------------------------------------------------- // // bucketSearch.h - segment tree data structure // //---------------------------------------------------------------------------- // $Id: bucketsearch.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef BUCKET_SEARCH_H #define BUCKET_SEARCH_H #include #include "cellsearch.h" //---------------------------------------------------------------------------- // // Bucket search structure // //---------------------------------------------------------------------------- class BucketSearch : public CellSearch { public: BucketSearch(u_int n = 0, float *v = NULL); ~BucketSearch(); void Init(u_int n, float *v); void InsertSeg(u_int cellid, float min, float max); void Dump(void); void Info(void); void Traverse(float, void (*f)(u_int, void*), void *); u_int getCells(float, u_int *); void Done(void); protected: u_int whichBucket(float f) { return u_int(f-minval); } private: int nbuckets; float minval, maxval; CellBucket *buckets; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/rangesweep.cpp0000644000175000017500000001656210064121655026166 0ustar debiandebian // $Id: rangesweep.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include "rangesweep.h" //#include "squeue.h" #include "iqueue.h" #define DEBUGNo #define DEBUGSLEEPNo #define MAXQUEUESIZE extern int verbose; class QueueRec { public: QueueRec(int c=0) { init(c); } void init(int c) { cellid=c; #if 0 nfc=0; #endif range[0].MakeEmpty(); range[1].MakeEmpty(); range[2].MakeEmpty(); range[3].MakeEmpty(); range[4].MakeEmpty(); range[5].MakeEmpty(); } int operator ==(QueueRec &qr) { return(cellid == qr.cellid); } #if 0 int isFromCell(int c) { int i; for (i=0; i q; static IndexedQueue q; QueueRec qr, current, *old; RangeSweepRec rsr, *rsritem; u_int c; int adjc, cindex; // int index; // int entry; qr.init(cellid); qr.fullrange.Set(min, max); // q.enqueue(qr); q.enqueue(qr, cellid); //if (cellid == 777) { // sleep(5); //} while (!q.isEmpty()) { #ifdef MAXQUEUESIZE if (q.getLength() > maxqsize) { maxqsize = q.getLength(); if (verbose) if (maxqsize%10000 == 0) printf("qsize: %d\n", maxqsize); } #endif q.dequeue(current); // item = q.dequeue(); // current = *item; #ifdef DEBUG printf("propagating from cell %d: ", current.cellid); current.fullrange.Print(); printf("(%d %d %d) (%f %f %f)\n", data.getCellVert(current.cellid, 0), data.getCellVert(current.cellid, 1), data.getCellVert(current.cellid, 2), data.getValue(data.getCellVert(current.cellid, 0)), data.getValue(data.getCellVert(current.cellid, 1)), data.getValue(data.getCellVert(current.cellid, 2))); #endif // if cell is done, remove from heap and continue; if (plot.CellTouched(current.cellid)) { #ifdef DEBUG printf("cell touched\n"); #endif rsr.cellid = current.cellid; // if ((entry=queue.find(rsr)) != -1) // queue.remove(entry); if (queue.find(rsr.cellid) != NULL) queue.remove(rsr.cellid); continue; } // if cell not in heap, add it rsr.cellid = current.cellid; // if ((entry=queue.find(rsr)) == -1) { if ((rsritem=queue.find(current.cellid)) == NULL) { #ifdef DEBUG printf("adding cell to heap\n"); #endif data.getCellRange(rsr.cellid, min, max); rsr.range.Set(min, max); queue.insert(rsr, max-min, rsr.cellid); rsritem=queue.find(rsr.cellid); } // rsritem = queue.nthEntry(entry); #ifdef DEBUG printf("heap item range: "); rsritem->range.Print(); current.fullrange.Print(); #endif if (rsritem->range.Disjoint(current.fullrange)) { #ifdef DEBUG printf("ranges are disjoint\n"); #endif continue; } // subtract off the propagated range rsritem->range -= current.fullrange; // update priority, possibly removing item from queue if (rsritem->range.Empty()) { #ifdef DEBUG printf("cell is now empty, removing\n"); #endif queue.remove(current.cellid); // queue.remove(entry); plot.TouchCell(current.cellid); } else { #ifdef DEBUG printf("new priority is %f-%f\n", rsritem->range.MaxAll(), rsritem->range.MinAll()); #endif queue.updatePriority(current.cellid, rsritem->range.MaxAll()- rsritem->range.MinAll()); } // don't use rsritem after this point.. may be deleted rsritem = NULL; // propagate ranges to shared faces // current = *item; for (c=0; cfullrange += qr.fullrange; old->range[cindex] += qr.fullrange; // if (!old->isFromCell(current.cellid)) // old->addFromCell(current.cellid); } else if (!qr.fullrange.Empty()) { qr.range[cindex] = qr.fullrange; // qr.addFromCell(current.cellid); // q.enqueue(qr); q.enqueue(qr, adjc); } } else { #ifdef DEBUG printf("cell %d (adj %d to %d) skipped, must be -1 or touched\n", adjc, c, current.cellid); #endif } } } } void rangeSweep::compSeeds(void) { RangeSweepRec rsr, item; Range fullrange, added, outgoing; float min, max; //double p; if (verbose) printf("------- computing seeds\n"); // clear the array of mark bits plot.ClearTouched(); seeds.Clear(); // insert cell 0 into queue to begin rsr.cellid = 0; data.getCellRange(0, min, max); rsr.range.Set(min, max); // queue.insert(rsr, max-min); queue.insert(rsr, max-min, rsr.cellid); // process queue of cells while (! queue.isEmpty() ) { // get the item //p = queue.max(item); queue.max(item); // cell is a seed cell seeds.AddSeed(item.cellid, item.range.MinAll(), item.range.MaxAll()); #ifdef DEBUG printf("*\n*\n*\ncell %d is a seed\n*\n*\n*\n", item.cellid); #endif #ifdef DEBUGSLEEP sleep(3); #endif // mark this cell as processed // plot.TouchCell(item.cellid); PropagateRegion(item.cellid, item.range.MinAll(), item.range.MaxAll()); } if (verbose) printf("computed %d seeds\n", seeds.getNCells()); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/inttree.h0000644000175000017500000000443110064121655025135 0ustar debiandebian//---------------------------------------------------------------------------- // // intTree.h - interval tree data structure // // Copyright (c) 1997 Dan Schikore //---------------------------------------------------------------------------- // $Id: inttree.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef INT_TREE_H #define INT_TREE_H #include #include "cellsearch.h" //---------------------------------------------------------------------------- // // Interval Tree Class // //---------------------------------------------------------------------------- class IntTree : public CellSearch { public: IntTree(u_int n = 0, float *v = NULL); ~IntTree(); void Init(u_int n, float *v); void InsertSeg(u_int cellid, float min, float max); void Dump(void); void Info(void); void Traverse(float, void (*f)(u_int, void*), void *); u_int getCells(float, u_int *); void Done(void); protected: u_int addSeed(u_int id, float mn, float mx) { u_int n = nseed++; if (n >= seedsize) { if (seedsize == 0) { seedsize=5; cellid = (u_int *)malloc(sizeof(u_int) * seedsize); min = (float *)malloc(sizeof(float) * seedsize); max = (float *)malloc(sizeof(float) * seedsize); } else { seedsize*=2; cellid = (u_int *)realloc(cellid, sizeof(u_int) * seedsize); min = (float *)realloc(min, sizeof(float) * seedsize); max = (float *)realloc(max, sizeof(float) * seedsize); } } cellid[n]=id; min[n]=mn; max[n]=mx; return(n); } u_int seedID(u_int n) { return(cellid[n]); } float seedMin(u_int n) { return(min[n]); } float seedMax(u_int n) { return(max[n]); } static int mincmp(const void *, const void *); static int maxcmp(const void *, const void *); static void travFun(u_int n, void *data); private: u_int nseed; u_int seedsize; u_int *cellid; float *min; float *max; int nleaf; float *vals; CellBucket *minlist; CellBucket *maxlist; void (*travCB)(u_int, void *); void *travData; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplot.cpp0000644000175000017500000000741111065020741025471 0ustar debiandebian//------------------------------------------------------------------------ // // conplot.C - preprocess and extract contours from 3d scalar data // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: conplot.cpp,v 1.5 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #include #ifndef WIN32 #include #include #endif #include "range.h" #include "segtree.h" #include "inttree.h" #include "bucketsearch.h" #include "conplot.h" extern int verbose; //#define NQUERY 10000 //#define TIME_SEARCH //#define WRITE //------------------------------------------------------------------------ // // Conplot() - create a contour plot for the given volume. // //------------------------------------------------------------------------ //int Conplot::funcontour; //int Conplot::funcolor; Conplot::Conplot(Dataset *d) { data = d; contour2d = NULL; contour3d = NULL; filePrefix = NULL; if (verbose) { printf("***** Data Characteristics\n"); printf("cells: %d\n", data->getNCells()); printf("*****\n"); } // initialize the bit array of 'touched' (visited) cells touched = (u_char *)malloc(sizeof(u_char) * (data->maxCellIndex()+7)>>3); int_cells = (u_int *)malloc(sizeof(u_int) * data->maxCellIndex()); if (verbose) printf("initializing %d trees\n", data->nTime()); tree = NULL; #ifdef USE_SEG_TREE tree = new SegTree[data->nTime()]; #elif defined USE_INT_TREE tree = new IntTree[data->nTime()]; #elif defined USE_BUCKETS tree = new BucketSearch[data->nTime()]; #endif // tree = new IntTree[data->nTime()]; seeds = new SeedCells[data->nTime()]; // initialize seed data array curtime = 0; } //------------------------------------------------------------------------ // // ~Conplot() - destroy a plot // //------------------------------------------------------------------------ Conplot::~Conplot() { if (verbose) printf("Conplot destructor\n"); delete [] tree; delete [] seeds; if (int_cells) { free(int_cells); int_cells = NULL; } if (touched) { free(touched); touched = NULL; } } void Conplot::setTime(int t) { curtime = t; } //------------------------------------------------------------------------ // // ExtractAll() - extract an isosurface by propagation in 3d. Data is // assumed to reside in memory. // isovalue = surface value of interest // //------------------------------------------------------------------------ u_int Conplot::ExtractAll(float isovalue) { int n; int cur; #ifdef TIME_SEARCH time_t start, finish; int t; #endif if (isDone(curtime)) return(Size(curtime)); #ifdef TIME_SEARCH start = clock(); for (t=0; tgetNCells()>>3); // loop through the seeds in order for (cur = 0; cur < n; cur++) { if (!CellTouched(int_cells[cur])) { TouchCell(int_cells[cur]); TrackContour(isovalue, int_cells[cur]); } } if (verbose) if (contour3d) printf("%d triangles\n", contour3d->getNTri()); Done(curtime); #ifdef WRITE if (contour3d) contour3d->write("output.tmesh"); #endif return(Size(curtime)); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/rangeprop.h0000644000175000017500000000134510064121655025461 0ustar debiandebian // $Id: rangeprop.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef RANGE_PROP_H #define RANGE_PROP_H #include "range.h" #include "squeue.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class RangePropRec { public: int operator <(RangePropRec&r2) { return(this->cellid < r2.cellid); } int operator ==(RangePropRec&r2) { return(this->cellid == r2.cellid); } int cellid; Range resp; Range comp; }; class rangeProp { public: rangeProp(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~rangeProp() {} void compSeeds(void); private: SQueue queue; Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/iqueue.cpp0000644000175000017500000000102110335221374025303 0ustar debiandebian/*****************************************************************************\ * * squeue.cc -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: iqueue.cpp,v 1.2 2005/11/11 23:02:20 annao Exp $ #include #include #include #include #include "squeue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datareg3.h0000644000175000017500000002721010352632600025152 0ustar debiandebian//-------------------------------------------------------------------- // // Datareg3d - class for a 3d regular grid of scalar data // // Copyright (c) 1997 Dan Schikore - updated by Emilio Camahort, 1999 // //-------------------------------------------------------------------- // $Id: datareg3.h,v 1.2 2005/12/22 23:23:44 annao Exp $ #ifndef DATAREG3D_H #define DATAREG3D_H #include "data.h" // added by Emilio: these are forward declarations necessary to avoid // complaints by the new SGI C++ compiler class seedChkr3; class regProp; class seedDirReg3; class Conplotreg3; //-------------------------------------------------------------------- // // Datareg3d - a volume of scalar data. // //-------------------------------------------------------------------- class Datareg3 : public Data { private: // data members friend class regProp; friend class seedDirReg3; u_int dim[3]; // nr of elements in x,y,z float orig[3]; // position of first cell float span[3]; // size in world coords int xbits, ybits, zbits; int xmask, ymask, zmask; int yshift, zshift; public: // constructors and destructors Datareg3(Data::DataType, int ndata=1, char *rawfile=NULL); Datareg3(Data::DataType, int ndata, int *dim, u_char *data); ~Datareg3() {} // member access methods void getDim(u_int *v) { memcpy(v, dim, 3 * sizeof(u_int)); } void getOrig(float *v) { memcpy(v, orig, 3 * sizeof(float)); } void getSpan(float *v) { memcpy(v, span, 3 * sizeof(float)); } void setOrig(float *v) { memcpy(orig, v, 3 * sizeof(float)); } void setSpan(float *v) { memcpy(span, v, 3 * sizeof(float)); } int getSlice(int variable, char axis, u_int index, datatypes *buffer); int maxCellIndex(void) { return(index2cell(dim[0]-2, dim[1]-2, dim[2]-2)); } // signature function methods int getNFunctions(void) { return(4); } float *compFunction(int, u_int &, float **); float *compFunction(int, u_int &, float ***, float ***, float ***); // add by fan char *fName(int); // signature function name protected : // signature functions: currently 4 float *compLength(u_int &, float **); float *compArea(u_int &, float **); float *compMaxArea(u_int &, float **); float *compGradient(u_int &, float **); public : // get data or gradient approximations (by differencing) // modify fan : f==0 is not set void getCellValues(int c, float *val, int f) { int i,j,k; cell2index(c,i,j,k); getCellValues(i,j,k,val,f); } void getCellValues(int i, int j, int k, float *val, int f) { val[0] = getValue(i, j, k , f); val[1] = getValue(i+1, j, k , f); val[2] = getValue(i+1, j, k+1, f); val[3] = getValue(i, j, k+1, f); val[4] = getValue(i, j+1, k , f); val[5] = getValue(i+1, j+1, k , f); val[6] = getValue(i+1, j+1, k+1, f); val[7] = getValue(i, j+1, k+1, f); } float getValue(int i, int j, int k, int f) { return(Data::getValue(index2vert(i,j,k), f)); } // add by fan void getCellValues(int c, float *val) { int i,j,k; cell2index(c,i,j,k); getCellValues(i,j,k,val,funcontour); } void getCellValues(int i, int j, int k, float *val) { val[0] = getValue(i, j, k , funcontour); val[1] = getValue(i+1, j, k , funcontour); val[2] = getValue(i+1, j, k+1, funcontour); val[3] = getValue(i, j, k+1, funcontour); val[4] = getValue(i, j+1, k , funcontour); val[5] = getValue(i+1, j+1, k , funcontour); val[6] = getValue(i+1, j+1, k+1, funcontour); val[7] = getValue(i, j+1, k+1, funcontour); } float getValue(int i, int j, int k) { return(Data::getValue(index2vert(i,j,k), funcontour)); } // end fan void getCellGrad(int c, float val[3][8]) { int i,j,k; cell2index(c,i,j,k); getVertGrad(i, j, k , val[0][0], val[1][0], val[2][0]); getVertGrad(i+1, j, k , val[0][1], val[1][1], val[2][1]); getVertGrad(i+1, j, k+1, val[0][2], val[1][2], val[2][2]); getVertGrad(i, j, k+1, val[0][3], val[1][3], val[2][3]); getVertGrad(i, j+1, k , val[0][4], val[1][4], val[2][4]); getVertGrad(i+1, j+1, k , val[0][5], val[1][5], val[2][5]); getVertGrad(i+1, j+1, k+1, val[0][6], val[1][6], val[2][6]); getVertGrad(i, j+1, k+1, val[0][7], val[1][7], val[2][7]); } #if 0 { int i,j,k; cell2index(c,i,j,k); if (i == 0) { val[0][0] = getValue(index2vert(1, j, k)) - getValue(index2vert(0, j, k )); val[0][1] = 0.5*(getValue(index2vert(2, j, k)) - getValue(index2vert(0, j, k ))); val[0][2] = 0.5*(getValue(index2vert(2,j,k+1))-getValue(index2vert(0, j, k+1))); val[0][3] = getValue(index2vert(1,j,k+1)) - getValue(index2vert(0, j, k+1)); val[0][4] = getValue(index2vert(1,j+1,k)) - getValue(index2vert(0, j+1, k )); val[0][5] = 0.5*(getValue(index2vert(2,j+1,k)) - getValue(index2vert(0, j+1, k))); val[0][6] = 0.5*(getValue(index2vert(2,j+1,k+1))-getValue(index2vert(2, j+1, k+1))); val[0][7] = getValue(index2vert(1,j+1,k+1))-getValue(index2vert(0, j+1, k+1)); } else if (i == dim[0]-2) { int n = dim[0]-1; int m = dim[0]-2; int l = dim[0]-3; val[0][0] = 0.5*(getValue(index2vert(n, j, k)) - getValue(index2vert(l, j, k))); val[0][1] = getValue(index2vert(2, j, k)) - getValue(index2vert(0, j, k ))); val[0][2] = 0.5*(getValue(index2vert(2,j,k+1))-getValue(index2vert(0, j, k+1))); val[0][3] = getValue(index2vert(1,j,k+1)) - getValue(index2vert(0, j, k+1)); val[0][4] = getValue(index2vert(1,j+1,k)) - getValue(index2vert(0, j+1, k )); val[0][5] = 0.5*(getValue(index2vert(2,j+1,k)) - getValue(index2vert(0, j+1, k))); val[0][6] = 0.5*(getValue(index2vert(2,j+1,k+1))-getValue(index2vert(2, j+1, k+1))); val[0][7] = getValue(index2vert(1,j+1,k+1))-getValue(index2vert(0, j+1, k+1)); } else { } } #endif u_int getCellVert(int c, int v) { int i, j, k; cell2index(c,i,j,k); switch (v) { case 0: return(index2vert(i,j,k)); case 1: return(index2vert(i+1,j,k)); case 2: return(index2vert(i+1,j,k+1)); case 3: return(index2vert(i,j,k+1)); case 4: return(index2vert(i,j+1,k)); case 5: return(index2vert(i+1,j+1,k)); case 6: return(index2vert(i+1,j+1,k+1)); case 7: return(index2vert(i,j+1,k+1)); } return(BAD_INDEX); } u_int getNCellVerts(void) { return(8); } u_int getNCellFaces(void) { return(6); } int getCellAdj(int c, int f) { int i, j, k; cell2index(c,i,j,k); switch (f) { case 0: return(j==0? -1 : index2cell(i,j-1,k)); case 1: return(i==0? -1 : index2cell(i-1,j,k)); case 2: return(j==(signed int)dim[1]-2? -1 : index2cell(i,j+1,k)); case 3: return(i==(signed int)dim[0]-2? -1 : index2cell(i+1,j,k)); case 4: return(k==(signed int)dim[2]-2? -1 : index2cell(i,j,k+1)); case 5: return(k==0? -1 : index2cell(i,j,k-1)); } return(-1); } float xCoord(int i) { return(orig[0] + i*span[0]); } float yCoord(int j) { return(orig[1] + j*span[1]); } float zCoord(int k) { return(orig[2] + k*span[2]); } void getCellRange(int c, float &min, float &max) { // float t; float v[8]; u_int i; getCellValues(c, v); max = min = v[0]; for (i=1; i max) max = v[i]; // max = min = getValue(getCellVert(c,0)); // for (i=1; i max) // max = t; } void getFaceRange(u_int c, u_int f, float &min, float &max) { float t; int i; min = max = Data::getValue(getCellVert(c,cellFaceVert[f][0])); for (i=1; i<4; i++) if ((t=Data::getValue(getCellVert(c,cellFaceVert[f][i]))) < min) min = t; else if (t > max) max = t; } protected: // called by the constructor functions friend class Conplotreg3; friend class seedChkr3; void getVertGrad(u_int i, u_int j, u_int k, float &gx, float &gy, float &gz) { if (i==0) { /* use right difference */ gx = getValue(i+1, j, k) - getValue(i, j, k); } else if (i==dim[0]-1) { /* use left difference */ gx = getValue(i, j, k) - getValue(i-1, j, k); } else { /* use central difference */ gx = (getValue(i+1, j, k) - getValue(i-1, j, k)) * 0.5f; } if (j==0) { gy = getValue(i, j+1, k) - getValue(i, j, k); } else if (j==dim[1]-1) { gy = getValue(i, j, k) - getValue(i, j-1, k); } else { gy = (getValue(i, j+1, k) - getValue(i, j-1, k)) * 0.5f; } if (k==0) { gz = getValue(i, j, k+1) - getValue(i, j, k); } else if (k==dim[2]-1) { gz = getValue(i, j, k) - getValue(i, j, k-1); } else { gz = (getValue(i, j, k+1) - getValue(i, j, k-1)) * 0.5f; } gx = -gx; gy = -gy; gz = -gz; } static int cellFaceVert[6][4]; // add by fan: compute topology float *compVolRelation(u_int &, float ***, float ***, float ***); void cell2index(int c, int &i, int &j, int &k) { int _left; i = c&xmask; _left = c>>xbits; j = _left&ymask; _left = _left>>ybits; k = _left&zmask; } int index2cell(int i, int j, int k) { return((k << zshift) | (j << yshift) | i); } void _cell2index(int c, u_int &i, u_int &j, u_int &k) { int _left; i = c%(dim[0]-1); _left = c/(dim[0]-1); j = _left%(dim[1]-1); _left = _left/(dim[1]-1); k = _left; } int _index2cell(int i, int j, int k) { return(k*(dim[1]-1)*(dim[0]-1) + j*(dim[0]-1) + i); } int index2vert(int i, int j, int k) { return(k*dim[1]*dim[0] + j*dim[0] + i); } }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dirseeds.cpp0000644000175000017500000000427610064121655025627 0ustar debiandebian // $Id: dirseeds.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include #include "dirseeds.h" #include "datavol.h" #include "dataslc.h" #define DEBUGNo #define DEBUGSLEEPNo #define sgn(x) ((x)>0 ? 1 : ((x)<0?-1:0)) extern int verbose; void dirSeeds::dirSweep(Dataslc &slc) { u_int c, f; Range resp; float g1[3], g2[3]; float norm[2]; int adjc; float min, max; for (c=0; c= 0.0) { slc.getCellGrad(adjc, g2); #ifdef DEBUG printf("adj grad: %f %f\n", g2[0], g2[1]); #endif if (sgn(g1[0])==sgn(g1[1]) && g1[1] * g2[1] < 0.0) { slc.getFaceRange(c,f,min,max); #ifdef DEBUG printf("seed range: %f %f\n", min, max); sleep(10); #endif resp += Range(min,max); } } } else { // boundary case... do something special? slc.normalToFace(c,f,norm); // first condition: all left boundary cells are selected // second: top/bottom sides *may* be selected // right hand cells should never be selected (sgn==0.0) if ((fabs(norm[1]) < 0.0000001 && norm[0] < 0.0) || // (sgn(norm[1])*g1[0] > 0.0)) { (sgn(norm[1]) * (sgn(g1[0]*g1[1])) > 0.0)) { slc.getFaceRange(c,f,min,max); resp += Range(min,max); } } } if (!resp.Empty()) seeds.AddSeed(c, resp.MinAll(), resp.MaxAll()); } } void dirSeeds::dirSweep(Datavol &vol) { u_int c; for (c=0; c #include #ifdef WIN32 typedef unsigned int u_int; #endif class Contour2d { public: // constructor Contour2d(); // destructor ~Contour2d(); // reset (delete all vertices and triangles) void Reset(void); void Done(void); int isDone(void) { return(done); } // add a vertex with the given position and normal int AddVert(float p[2]) { return(AddVert(p[0], p[1])); } int AddVert(float, float); // add an edge indexed by the given 2 vertices int AddEdge(u_int v[2]) { return(AddEdge(v[0], v[1])); } int AddEdge(u_int, u_int); // get the number of vertices or edges int getSize(void) { return(nedge); } int getNVert(void) { return(nvert); } int getNEdge(void) { return(nedge); } // write vertices and triangles to a file int write(char *filename); void setExtent(float min[3], float max[3]) { memcpy(minext, min, sizeof(float[3])); memcpy(maxext, max, sizeof(float[3])); } protected : int done; // done with isocontour ?? // the size of the vertex and edge arrays int vsize, tsize; // the number of vertices and edges int nvert, nedge; float minext[3], maxext[3]; public : // made public by Emilio // arrays of vertices, and edges float (*vert)[2]; // polyline vertex array unsigned int (*edge)[2]; // array of polyline edges }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplotreg2.h0000644000175000017500000000311610064121655025720 0ustar debiandebian//------------------------------------------------------------------------ // // conplotreg2.h - class for preprocessing and extraction of isocurves // from 2d rectilinear data // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: conplotreg2.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef CONPLOT_RECT_2D_H #define CONPLOT_RECT_2D_H #include #include "contour2d.h" #include "dataset.h" #include "segtree.h" #include "seedcells.h" #include "cellqueue.h" #include "edgehash.h" #include "range.h" #include "datasetreg2.h" #include "conplot.h" //------------------------------------------------------------------------ // // conplotreg2.h // //------------------------------------------------------------------------ class Conplotreg2 : public Conplot { public: Conplotreg2(Datasetreg2 *d); ~Conplotreg2(); protected: // extract in 3d (from memory) or slice-by-slice (swap from disk) u_int ExtractAll(float isovalue); int InterpEdge(int, float *, float, int, int); // track a contour from a seed cell void TrackContour(float, int); // enqueue faces for propagation of surface inline void EnqueueFaces(int, int, CellQueue &); void Reset(int t) { con2[t].Reset(); } int Size(int t) { return(con2[t].getSize()); } int isDone(int t) { return(con2[t].isDone()); } void Done(int t) { con2[t].Done(); } private: Datasetreg2 *reg2; Datareg2 *curreg2; Contour2d *con2, *curcon; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/Isocontour-license.txt0000644000175000017500000000643710334435233027647 0ustar debiandebianTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 1. This software is the copyright of THE UNIVERSITY OF TEXAS AT AUSTIN, 2005. 2. The software is available under multiple licenses. 3. For non commercial educational and non commercial academic use, the software including source code, interface definitions and compile scripts are freely available. Any distribution of code, library or executables which contains any modules from this software should contain, conspicously and appropriately, on each copy, this copyright and license notice and should be freely distributed. 4. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation. 5. For any other purpose, including commercial purposes, please contact The University of Texas at Austin for a different license. 6. Credits: This software has been developed at the Computational and Visualization center under Dr Chandrajit Bajaj, Computational Applied Mathematics Chair in Visualization, Professor of Computer Sciences, Director of Center for Computational Visualization, Department of Computer Sciences & The Institute of Computational Engineering and Sciences , Center for Computational Visualization, 201 East 24th Street, ACES 2.324A, 1 University Station, C0200, Austin, TX 78712-0027. We request that you agree to acknowledge the use of the software that results in any published work, including scientific papers, films and videotapes by citing the references listed below C. Bajaj, V. Pascucci, D. Schikore Accelerated IsoContouring of Scalar Fields Data Visualization Techniques, edited by C. Bajaj, John Wiley and Sons (1998). C. Bajaj, V. Pascucci, D. Schikore Fast Isocontouring for Improved Interactivity Proceedings: ACM Siggraph/IEEE Symposium on Volume Visualization, ACM Press, (1996), San Francisco, CA. Pages: 39-46 99 7. No warranty 7a. Because the library is licensed free of charge, there is no warranty for the library, to the extent permitted by applicable law. except when otherwise stated in writing the copyright holders and/or other parties provide the library "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. the entire risk as to the quality and performance of the library is with you. should the library prove defective, you assume the cost of all necessary servicing, repair or correction. 7b. In no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute the library as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use the library (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the library to operate with any other software), even if such holder or other party has been advised of the possibility of such damages. END OF TERMS AND CONDITIONS mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedchkr3.cpp0000644000175000017500000000372711065020741025674 0ustar debiandebian//------------------------------------------------------------------------ // // seedChkr3.C - preprocessing of 3d volumes for seed set extraction // //------------------------------------------------------------------------ // $Id: seedchkr3.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #ifndef WIN32 #include #endif #include "seedchkr3.h" #include "datareg3.h" #define VERBOSE #define DEBUGNo //------------------------------------------------------------------------ // //------------------------------------------------------------------------ void seedChkr3::compSeeds(void) { Datareg3 ®3 = (Datareg3&)data; int i, j, k; int xdim, ydim, zdim; float val[8]; float min8, max8; int nseed; if (verbose) printf("***** Seed Creation\n"); xdim = reg3.dim[0]; ydim = reg3.dim[1]; zdim = reg3.dim[2]; // proceed through the slices computing seeds nseed=0; // process the k'th slab for (i=0; i #endif typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; /*------------------------------------------------------------------------ * * constant definitions * *----------------------------------------------------------------------*/ #define CONTOUR_UCHAR 0 /* supported types of raw data */ #define CONTOUR_USHORT 1 #define CONTOUR_FLOAT 2 #define CONTOUR_2D 2 /* supported types of meshes */ #define CONTOUR_3D 3 #define CONTOUR_REG_2D 4 #define CONTOUR_REG_3D 5 #define NO_COLOR_VARIABLE -1 /* do not color an isocontour */ /*------------------------------------------------------------------------ * * data structures * *----------------------------------------------------------------------*/ /*------------------------------------------------------------------------ * data structures for storing some dataset information *----------------------------------------------------------------------*/ typedef struct DatasetInfo { int datatype; /* the dataset's base type */ int meshtype; /* type of mesh (see defs above) */ int nvars; /* number of variables */ int ntime; /* number of timesteps */ u_int dim[3]; /* dataset's x, y, z dimensions */ float orig[3]; /* coordinates of dataset's origin */ float span[3]; /* how far does the dataset go */ float minext[3]; /* min corner of dataset */ float maxext[3]; /* max corner of dataset */ float *minvar; /* min value for each variable */ float *maxvar; /* max value for each variable */ } DatasetInfo; /*------------------------------------------------------------------------ * data structures for storing seed cells *----------------------------------------------------------------------*/ typedef struct Seed /* store one seed cell (see seedCells.h) */ { float min; /* cell minimum value */ float max; /* cell maximum value */ u_int cell_id; /* cell identifier */ } Seed; typedef struct SeedData /* structure to store seeds */ { int nseeds; /* number of seed cells */ Seed *seeds; /* array of seed cells */ } SeedData; /*------------------------------------------------------------------------ * data structure for storing signature functions *----------------------------------------------------------------------*/ typedef struct Signature /* a single signature function */ { char *name; /* fuction name */ u_int nval; /* number of function values */ float *fx; /* x-values of function */ float *fy; /* y-values of function */ } Signature; /*------------------------------------------------------------------------ * a slice of a 3D regular grid *----------------------------------------------------------------------*/ typedef struct SliceData /* structure to store a 2d scalar data slice */ { int width; /* slice width */ int height; /* slice height */ int datatype; /* type of data: uchar, ushort, float */ u_char *ucdata; /* slice data for uchar datatype */ u_short *usdata; /* slice data for ushort datatype */ float *fdata; /* slice data for float datatype */ } SliceData; /*------------------------------------------------------------------------ * store a 2D isocontour *----------------------------------------------------------------------*/ typedef struct Contour2dData /* structure to store a 2d isocontour */ { int nvert; /* size of vertex array */ int nedge; /* size of edge array */ float (*vert)[2]; /* polyline vertex array */ u_int (*edge)[2]; /* array of edge indices */ } Contour2dData; /*------------------------------------------------------------------------ * store a 3D isocontour *----------------------------------------------------------------------*/ typedef struct Contour3dData /* structure to store a 3d isocontour */ { int nvert; /* number of vertices in vertex array */ int ntri; /* triangles in triangle array */ float (*vert)[3]; /* isosurface vertex array */ float (*vnorm)[3]; /* array of vertex normals */ float (*vfun); /* color values at vertices */ u_int (*tri)[3]; /* triangle mesh array */ int colorvar; /* color variable (-1 if no color) */ float fmin, fmax; /* min and max color values */ } Contour3dData; /*------------------------------------------------------------------------ * a structure to store a dataset of scalar data *----------------------------------------------------------------------*/ class Dataset; class Conplot; typedef struct ConDataset // structure to store and entire dataset { char **vnames; // variable names int nsfun; // number of signature functions Signature ***sfun; // signature functions Dataset *data; // input data/dataset Conplot *plot; // isocontouring algorithm and data } ConDataset; /*------------------------------------------------------------------------ * * library routines * *----------------------------------------------------------------------*/ /* set the library's level of verbosity, default is 1 */ void setVerboseLevel(int level); /* set the library's error handler */ void setErrorHandler(void (*handler)(char *, int)); /* create a new dataset for unstructured data */ ConDataset *newDatasetUnstr(int datatype, int meshtype, int nvars, int ntime, int nverts, int ncells, double *verts, u_int *cells, int *celladj, u_char *data); /* create a new dataset for a regular grid of data */ ConDataset *newDatasetReg(int datatype, int meshtype, int nvars, int ntime, int *dim, u_char *data); /* load from disk a new dataset */ ConDataset *loadDataset(int datatype, int meshtype, int nvars, int ntime, char **files); /* get the dataset's basic information */ DatasetInfo *getDatasetInfo(ConDataset *dataset); /* get variable names for multi-variate datasets */ char **getVariableNames(ConDataset *dataset); /* extract seed cells for variable and timestep */ SeedData *getSeedCells(ConDataset *dataset, int variable, int timestep); /* return the number of signature functions */ int getNumberOfSignatures(ConDataset *dataset); /* compute signature functions for variable and timestep */ Signature *getSignatureFunctions(ConDataset *dataset, int variable, int timestep); /* get signature values for isovalue, variable and timestep */ float *getSignatureValues(ConDataset *dataset, int variable, int timestep, float isovalue); /* extract a dataset slice */ SliceData *getSlice(ConDataset *dataset, int variable, int timestep, char axis, u_int index); /* extract a 2d isocontour */ Contour2dData *getContour2d(ConDataset *dataset, int variable, int timestep, float isovalue); /* extract a 3d isocontour */ Contour3dData *getContour3d(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar); /* extract a 2d isocontour and write it to a file */ void saveContour2d(ConDataset *dataset, int variable, int timestep, float isovalue, char *filename); /* extract a 3d isocontour and write it to a file */ void saveContour3d(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar, char *filename); /* write isocontour connected components to ipoly files */ void writeIsoComponents(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar, char *fprefix); /* clear (delete) dataset from memory */ void clearDataset(ConDataset *dataset); #endif /* of _CONTOUR_H_ */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplotreg3.cpp0000644000175000017500000003126311065020741026254 0ustar debiandebian//------------------------------------------------------------------------ // // conPlotReg3.C - preprocess and extract contours from 3d scalar data // //------------------------------------------------------------------------ // $Id: conplotreg3.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #include #ifndef WIN32 #include #endif #include "conplot.h" #include "contour3d.h" #include "range.h" #include "segtree.h" #include "conplotreg3.h" #include "vtkmarchingcubescases.h" #include "cubes.h" #define UNIQUE extern int verbose; extern void (*errorHandler)(char *, int); //------------------------------------------------------------------------ // // edgeinfo - table of information about cube edges. // dir = direction of edge (x=0, y=1, z=2) // di,dj,dk = the index of the lowermost point in reference // to the cube // d1,d2 = the vertices of the edge // //------------------------------------------------------------------------ typedef struct { int dir; int di,dj,dk; int d1,d2; } EdgeInfo; static EdgeInfo edgeinfo[12] = { { 0, 0, 0, 0, 0, 1 }, { 2, 1, 0, 0, 1, 2 }, { 0, 0, 0, 1, 3, 2 }, { 2, 0, 0, 0, 0, 3 }, { 0, 0, 1, 0, 4, 5 }, { 2, 1, 1, 0, 5, 6 }, { 0, 0, 1, 1, 7, 6 }, { 2, 0, 1, 0, 4, 7 }, { 1, 0, 0, 0, 0, 4 }, { 1, 1, 0, 0, 1, 5 }, { 1, 0, 0, 1, 3, 7 }, { 1, 1, 0, 1, 2, 6 } }; //------------------------------------------------------------------------ // // Conplot() - create a contour plot for the given volume. // //------------------------------------------------------------------------ Conplotreg3::Conplotreg3(Datasetreg3 *d) : Conplot(d) { int i; float min[3], max[3]; reg3 = d; if (verbose > 1) { printf("***** Data Characteristics\n"); //printf("cells: %d\n", curreg3->getNCells()); printf("*****\n"); } filePrefix = NULL; contour2d = NULL; contour3d = con3 = new Contour3d[reg3->nTime()]; data->getData(0)->getExtent(min, max); if (verbose) { printf("minextent: %f %f %f\n", min[0], min[1], min[2]); printf("maxextent: %f %f %f\n", max[0], max[1], max[2]); } for (i = 0; i < reg3->nTime(); i++) con3[i].setExtent(min, max); if (verbose > 1) printf("contour2d is %x contour3d is %x\n", contour2d, con3); } //------------------------------------------------------------------------ // // ~Conplotreg3() - destroy a plot // //------------------------------------------------------------------------ Conplotreg3::~Conplotreg3() { if (verbose) printf ("Conplotreg3 destructor\n"); if (contour3d) { delete [] contour3d; contour3d=NULL; } } //------------------------------------------------------------------------ // // interpRect3Dpts_x() - interpolate along an edge in the x direction // //------------------------------------------------------------------------ void Conplotreg3::interpRect3Dpts_x(int i1, int j1, int k1, float *data, float *data2, float grad[3][8], int d1, int d2, float val, float *pt, float *norm, float *fval) { double ival; ival = (val - data[d1])/(data[d2] - data[d1]); pt[0] = (float)(curreg3->orig[0] + curreg3->span[0]*(i1 + ival)); pt[1] = (float)(curreg3->orig[1] + curreg3->span[1]*j1); pt[2] = (float)(curreg3->orig[2] + curreg3->span[2]*k1); norm[0] = (float)(grad[0][d1]*(1.0-ival) + grad[0][d2]*ival); norm[1] = (float)(grad[1][d1]*(1.0-ival) + grad[1][d2]*ival); norm[2] = (float)(grad[2][d1]*(1.0-ival) + grad[2][d2]*ival); *fval = (float)(data2[d1]*(1.0-ival) + data2[d2]*ival); } //------------------------------------------------------------------------ // // interpRect3Dpts_y() - interpolate along an edge in the y direction // //------------------------------------------------------------------------ void Conplotreg3::interpRect3Dpts_y(int i1, int j1, int k1, float *data, float *data2, float grad[3][8], int d1, int d2, float val, float *pt, float *norm, float *fval) { double ival; ival = (val - data[d1])/(data[d2] - data[d1]); pt[0] = curreg3->orig[0] + curreg3->span[0]*i1; pt[1] = (float)(curreg3->orig[1] + curreg3->span[1]*(j1 + ival)); pt[2] = curreg3->orig[2] + curreg3->span[2]*k1; norm[0] = (float)(grad[0][d1]*(1.0-ival) + grad[0][d2]*ival); norm[1] = (float)(grad[1][d1]*(1.0-ival) + grad[1][d2]*ival); norm[2] = (float)(grad[2][d1]*(1.0-ival) + grad[2][d2]*ival); *fval = (float)(data2[d1]*(1.0-ival) + data2[d2]*ival); } //------------------------------------------------------------------------ // // interpRect3Dpts_z() - interpolate along an edge in the z direction // //------------------------------------------------------------------------ void Conplotreg3::interpRect3Dpts_z(int i1, int j1, int k1, float *data, float *data2, float grad[3][8], int d1, int d2, float val, float *pt, float *norm, float *fval) { double ival; ival = (val - data[d1])/(data[d2] - data[d1]); pt[0] = curreg3->orig[0] + curreg3->span[0]*i1; pt[1] = curreg3->orig[1] + curreg3->span[1]*j1; pt[2] = (float)(curreg3->orig[2] + curreg3->span[2]*(k1+ival)); norm[0] = (float)(grad[0][d1]*(1.0-ival) + grad[0][d2]*ival); norm[1] = (float)(grad[1][d1]*(1.0-ival) + grad[1][d2]*ival); norm[2] = (float)(grad[2][d1]*(1.0-ival) + grad[2][d2]*ival); *fval = (float)(data2[d1]*(1.0-ival) + data2[d2]*ival); } //------------------------------------------------------------------------ // // InterpEdge() - interpolate ..... // //------------------------------------------------------------------------ int Conplotreg3::InterpEdge(float *val, float *val2, float grad[3][8], float isovalue, int i, int j, int k, int edge) { float pt[3]; float norm[3]; float fval; EdgeInfo *ei = &edgeinfo[edge]; int v; // do the interpolation switch (ei->dir) { case 0: interpRect3Dpts_x(i+ei->di, j+ei->dj, k+ei->dk, val, val2, grad, ei->d1, ei->d2, isovalue, pt, norm, &fval); break; case 1: interpRect3Dpts_y(i+ei->di, j+ei->dj, k+ei->dk, val, val2, grad, ei->d1, ei->d2, isovalue, pt, norm, &fval); break; case 2: interpRect3Dpts_z(i+ei->di, j+ei->dj, k+ei->dk, val, val2, grad, ei->d1, ei->d2, isovalue, pt, norm, &fval); break; } // add to the coordinate list { double len = sqrt(norm[0]*norm[0] + norm[1]*norm[1] + norm[2]*norm[2]); norm[0] = (float)(norm[0]/len); norm[1] = (float)(norm[1]/len); norm[2] = (float)(norm[2]/len); } #ifdef UNIQUE v = curcon->AddVertUnique(pt, norm, fval); #else v = curcon->AddVert(pt, norm, fval); #endif return(v); } //------------------------------------------------------------------------ // // EnqueueFaces() - enqueue adjacent faces for propagation of contour // code = case table lookup code for current cell // i,j,k = index of current cell // queue = queue of cells to be processed on current slice // nextslice = queue of cells to be processed on next slice // trackinz = flag indicating whether to propagate in z-dir // 0 -> don't track in z, but queue cells in nextslice // 1 -> propagate contour in all 3 dim // //------------------------------------------------------------------------ inline void Conplotreg3::EnqueueFaces(int code, u_int i, u_int j, u_int k, CellQueue &queue) { int f; int id; for (f=0; f= 1) { id = curreg3->index2cell(i, j-1, k); if (!CellTouched(id)) { TouchCell(id); queue.Add(id); } } break; case 1: if (i >= 1) { id = curreg3->index2cell(i-1, j, k); if (!CellTouched(id)) { TouchCell(id); queue.Add(id); } } break; case 2: if (j <= curreg3->dim[1]-3) { id = curreg3->index2cell(i, j+1, k); if (!CellTouched(id)) { TouchCell(id); queue.Add(id); } } break; case 3: if (i <= curreg3->dim[0]-3) { id = curreg3->index2cell(i+1, j, k); if (!CellTouched(id)) { TouchCell(id); queue.Add(id); } } break; case 4: if (k <= curreg3->dim[2]-3) { id = curreg3->index2cell(i, j, k+1); if (!CellTouched(id)) { TouchCell(id); queue.Add(id); } } break; case 5: if (k >= 1) { id = curreg3->index2cell(i, j, k-1); if (!CellTouched(id)) { TouchCell(id); queue.Add(id); } } break; } } } //------------------------------------------------------------------------ // // TrackContour() - compute and track a contour by table lookup and propagation // through adjacent cells // isovalue = surface value of interest // i,j,k = index of seed cell // nextslice = queue of seeds for next slice (used only if tracking in 2d) // //------------------------------------------------------------------------ void Conplotreg3::TrackContour(float isovalue, int cell) { int edge_v[12]; float val[8]; float val2[8]; float grad[3][8]; u_int v1, v2, v3; int i, j, k; int e, t; int code; int edge; int nvert=0, ntri=0; // to save isocontour components queue.Add(cell); curreg3 = (Datareg3*)data->getData(curtime); curcon = &con3[curtime]; if (filePrefix) // keep track of current nvert, ntri { nvert = curcon->getNVert(); ntri = curcon->getNTri(); } if (curreg3->getColorFun() != -1) curcon->minmaxFun(data->getMinFun(curreg3->getColorFun()), data->getMaxFun(curreg3->getColorFun())); while (queue.Get(cell) > 0) { // select contour for contour function // printf("track contour at cell:%d\n", cell); // by fan curreg3->getCellValues(cell, val /*,0*/); // Emilio: curreg3->getCellValues(cell, val, funcontour); curreg3->getCellValues(cell, val, curreg3->getContourFun()); // use color of color function if (curreg3->getColorFun() != -1) //if (curreg3->getNData() > 1) // by fan curreg3->getCellValues(cell, val2, 1); // Emilio: curreg3->getCellValues(cell, val2, funcolor); curreg3->getCellValues(cell, val2, curreg3->getColorFun()); curreg3->getCellGrad(cell, grad); curreg3->cell2index(cell, i, j, k); code = 0; if (val[0] < isovalue) code |= 0x01; if (val[1] < isovalue) code |= 0x02; if (val[2] < isovalue) code |= 0x04; if (val[3] < isovalue) code |= 0x08; if (val[4] < isovalue) code |= 0x10; if (val[5] < isovalue) code |= 0x20; if (val[6] < isovalue) code |= 0x40; if (val[7] < isovalue) code |= 0x80; for (e = 0; e < cubeedges[code][0]; e++) { edge = cubeedges[code][1+e]; edge_v[edge] = InterpEdge(val, val2, grad, isovalue, i, j, k, edge); } for (t=0; triCases[code].edges[t] != -1; ) { v1 = edge_v[triCases[code].edges[t++]]; v2 = edge_v[triCases[code].edges[t++]]; v3 = edge_v[triCases[code].edges[t++]]; curcon->AddTri(v1, v2, v3); } EnqueueFaces(code, i, j, k, queue); } if (filePrefix) // write this isocontour component { if (curcon->getNTri() - ntri > 25) // more than 25 triangles { FILE *fp; int v, t; char filename[200]; sprintf(filename, "%s%04d.ipoly", filePrefix, ncomponents); if ( (fp = fopen(filename, "w")) ) { fprintf(fp, "%d 0 %d 0 0 0 0\n0 0 0\n", curcon->getNVert() - nvert, curcon->getNTri() - ntri); for (v = nvert; v < curcon->getNVert(); v++) fprintf(fp, "%g %g %g\n", curcon->vert[v][0], curcon->vert[v][1], curcon->vert[v][2]); fprintf(fp, "0 0\n"); for (t = ntri; t < curcon->getNTri(); t++) fprintf(fp, "3\n%d %d %d\n", curcon->tri[t][0], curcon->tri[t][1], curcon->tri[t][2]); fclose(fp); ncomponents++; } else { char str[256]; sprintf(str, "Conplotreg3::TrackContour: couldn't open file: %s", filename); errorHandler(str, FALSE); } } } } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/cellqueue.h0000644000175000017500000000720010352632577025456 0ustar debiandebian//------------------------------------------------------------------------ // // cellQueue.h - queue of cell identifiers. The circular queue dyanmically // resizes itself when full. Elements in the queue are of // type and size specified by the user. Not even template'd // yet, just using a void *. // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: cellqueue.h,v 1.2 2005/12/22 23:23:43 annao Exp $ #ifndef CELL_QUEUE_H #define CELL_QUEUE_H #include #include #include #ifdef WIN32 typedef unsigned int u_int; #endif class CellQueue { public: // constructor/destructor inline CellQueue(int size=100); ~CellQueue(); // add item to the queue inline void Add(u_int cell); // remove and return the first item in queue inline int Get(int &cell); // return the first item in queue inline int Peek(int &cell); // remove the first item in queue inline void Pop(); // reset to empty void Reset(void) { nel = 0; } // check if queue is empty int Empty(void) { return(nel == 0); } protected: private: int nel; int cellsize; /* # of elements in cell array */ int start; u_int *cells; }; //------------------------------------------------------------------------ // // CellQueue() - create a new cell queue with elements of specified size // //------------------------------------------------------------------------ inline CellQueue::CellQueue(int size) { nel = 0; start = 0; cellsize = size; cells = (u_int *)malloc(sizeof(u_int) * cellsize); } //------------------------------------------------------------------------ // // ~CellQueue() - free storage // //------------------------------------------------------------------------ inline CellQueue::~CellQueue() { if (cells != NULL) free(cells); } //------------------------------------------------------------------------ // // Add() - add an item to the queue // //------------------------------------------------------------------------ inline void CellQueue::Add(u_int c) { int n; int oldsize; int atend; n = nel++; // resize the queue if needed if (nel > cellsize) { oldsize = cellsize; cellsize *= 2; cells = (u_int *)realloc(cells, sizeof(int) * cellsize); // move everything from 'start' to the end if (start != 0) { atend = oldsize - start; memmove(&cells[cellsize-atend], &cells[start], sizeof(u_int)*atend); start = cellsize-atend; } } n += start; if (n >= cellsize) n-=cellsize; cells[n] = c; } //------------------------------------------------------------------------ // // Get() - return the top item from the queue // //------------------------------------------------------------------------ inline int CellQueue::Get(int &c) { if (Peek(c) == -1) return(-1); Pop(); return(1); } //------------------------------------------------------------------------ // // Peek() - return the top item, but don't remove it // //------------------------------------------------------------------------ inline int CellQueue::Peek(int &c) { if (nel == 0) return(-1); c = cells[start]; return(1); } //------------------------------------------------------------------------ // // Pop() - delete the top item in the queue // //------------------------------------------------------------------------ inline void CellQueue::Pop(void) { start++; if (start == cellsize) start=0; nel--; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/basic.h0000644000175000017500000000242210064121655024542 0ustar debiandebian/*****************************************************************************\ * * basic.h -- basic definitions * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * \*****************************************************************************/ // $Id: basic.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef __BASIC_H #define __BASIC_H // modified by Emilio: these are defined by default in SGI's new compiler #if !defined(_BOOL) && !defined(SP2) && !defined(WIN32) typedef int bool; const bool true = 1; const bool false = 0; #endif /// Constant used to designate NULL when indexing into an array. const int INDEX_NULL = -1; /// Swap the contents of two variables. template inline void swap(T &a, T &b) { T tmp = a; a = b; b = tmp; } /// Return the square of #x#. template inline T sqr(T x) { return x*x; } /// Return the cube of #x#. template inline T cub(T x) { return x*x*x; } /// Return the minimum between #x# and #y#. template inline T min(T x, T y) { return x <= y ? x : y; } /// Return the maximum between #x# and #y#. template inline T max(T x, T y) { return x >= y ? x : y; } /// Return the sign of #x#. template inline double sign( T x ) { return ((x >= 0.0) ? 1.0 : -1.0); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dict.h0000644000175000017500000001122210352633120024375 0ustar debiandebian/* * Dictionary Abstract Data Type * Copyright (C) 1997 Kaz Kylheku * * Free Software License: * * All rights are reserved by the author, with the following exceptions: * Permission is granted to freely reproduce and distribute this software, * possibly in exchange for a fee, provided that this copyright notice appears * intact. Permission is also granted to adapt this software to produce * derivative works, as long as the modified versions carry this copyright * notice and additional notices stating that the work has been modified. * This source code may be translated into executable form and incorporated * into proprietary software; there is no requirement for such software to * contain a copyright notice related to this source. * * $Id: dict.h,v 1.1 2005/12/22 23:27:12 annao Exp $ * $Name: $ */ #ifndef DICT_H #define DICT_H #include #ifdef KAZLIB_SIDEEFFECT_DEBUG #include "sfx.h" #endif /* * Blurb for inclusion into C++ translation units */ #ifdef __cplusplus extern "C" { #endif typedef unsigned long dictcount_t; #define DICTCOUNT_T_MAX ULONG_MAX /* * The dictionary is implemented as a red-black tree */ typedef enum { dnode_red, dnode_black } dnode_color_t; typedef struct dnode_t { #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) struct dnode_t *dict_left; struct dnode_t *dict_right; struct dnode_t *dict_parent; dnode_color_t dict_color; const void *dict_key; void *dict_data; #else int dict_dummy; #endif } dnode_t; typedef int (*dict_comp_t)(const void *, const void *); typedef dnode_t *(*dnode_alloc_t)(void *); typedef void (*dnode_free_t)(dnode_t *, void *); typedef struct dict_t { #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) dnode_t dict_nilnode; dictcount_t dict_nodecount; dictcount_t dict_maxcount; dict_comp_t dict_compare; dnode_alloc_t dict_allocnode; dnode_free_t dict_freenode; void *dict_context; int dict_dupes; #else int dict_dummmy; #endif } dict_t; typedef void (*dnode_process_t)(dict_t *, dnode_t *, void *); typedef struct dict_load_t { #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) dict_t *dict_dictptr; dnode_t dict_nilnode; #else int dict_dummmy; #endif } dict_load_t; extern dict_t *dict_create(dictcount_t, dict_comp_t); extern void dict_set_allocator(dict_t *, dnode_alloc_t, dnode_free_t, void *); extern void dict_destroy(dict_t *); extern void dict_free_nodes(dict_t *); extern void dict_free(dict_t *); extern dict_t *dict_init(dict_t *, dictcount_t, dict_comp_t); extern void dict_init_like(dict_t *, const dict_t *); extern int dict_verify(dict_t *); extern int dict_similar(const dict_t *, const dict_t *); extern dnode_t *dict_lookup(dict_t *, const void *); extern dnode_t *dict_lower_bound(dict_t *, const void *); extern dnode_t *dict_upper_bound(dict_t *, const void *); extern void dict_insert(dict_t *, dnode_t *, const void *); extern dnode_t *dict_delete(dict_t *, dnode_t *); extern int dict_alloc_insert(dict_t *, const void *, void *); extern void dict_delete_free(dict_t *, dnode_t *); extern dnode_t *dict_first(dict_t *); extern dnode_t *dict_last(dict_t *); extern dnode_t *dict_next(dict_t *, dnode_t *); extern dnode_t *dict_prev(dict_t *, dnode_t *); extern dictcount_t dict_count(dict_t *); extern int dict_isempty(dict_t *); extern int dict_isfull(dict_t *); extern int dict_contains(dict_t *, dnode_t *); extern void dict_allow_dupes(dict_t *); extern int dnode_is_in_a_dict(dnode_t *); extern dnode_t *dnode_create(void *); extern dnode_t *dnode_init(dnode_t *, void *); extern void dnode_destroy(dnode_t *); extern void *dnode_get(dnode_t *); extern const void *dnode_getkey(dnode_t *); extern void dnode_put(dnode_t *, void *); extern void dict_process(dict_t *, void *, dnode_process_t); extern void dict_load_begin(dict_load_t *, dict_t *); extern void dict_load_next(dict_load_t *, dnode_t *, const void *); extern void dict_load_end(dict_load_t *); extern void dict_merge(dict_t *, dict_t *); static dnode_t *dnode_alloc(void *context); static void dnode_free(dnode_t *node, void *context); #if defined(DICT_IMPLEMENTATION) || !defined(KAZLIB_OPAQUE_DEBUG) #ifdef KAZLIB_SIDEEFFECT_DEBUG #define dict_isfull(D) (SFX_CHECK(D)->dict_nodecount == (D)->dict_maxcount) #else #define dict_isfull(D) ((D)->dict_nodecount == (D)->dict_maxcount) #endif #define dict_count(D) ((D)->dict_nodecount) #define dict_isempty(D) ((D)->dict_nodecount == 0) #define dnode_get(N) ((N)->dict_data) #define dnode_getkey(N) ((N)->dict_key) #define dnode_put(N, X) ((N)->dict_data = (X)) #endif #ifdef __cplusplus } #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/contour3d.cpp0000644000175000017500000002141311065020741025731 0ustar debiandebian// ______________________________________________________________________ // // NAME // Contour3d - Class for a contour surface // // Copyright (c) 1998 Emilio Camahort, Dan Schikore // // SYNOPSIS // #include // ______________________________________________________________________ // $Id: contour3d.cpp,v 1.5 2008/09/19 22:04:17 annao Exp $ #include #include #if ! defined (__APPLE__) #include #else #include #endif #include "contour3d.h" //#define WRITE_TMESH //#define WRITE_IPOLY #define WRITE_RAW extern int verbose; /******** Added by Joe R - 12/21/2005, used for fast searching of duplicate vertices ********/ #ifdef USEDICT struct vertex_dict_entry { float x, y, z; // vertex coords int i; // vertex index }; static int VertexCompare(const void *a, const void *b) { const vertex_dict_entry *v1 = (vertex_dict_entry*)a; const vertex_dict_entry *v2 = (vertex_dict_entry*)b; if(fabs(v1->x-v2->x) >= 0.00001) return v1->x < v2->x ? -1 : 1; if(fabs(v1->y-v2->y) >= 0.00001) return v1->y < v2->y ? -1 : 1; if(fabs(v1->z-v2->z) >= 0.00001) return v1->z < v2->z ? -1 : 1; return 0; } static dnode_t *VertexNodeAlloc(void *c) { return dnode_create(NULL); } static void VertexNodeDelete(dnode_t *n, void *c) { free((vertex_dict_entry*)dnode_get(n)); free(n); } #endif /********************************************************************************************/ //------------------------------------------------------------------------ // // Contour3d() - basic constructor // //------------------------------------------------------------------------ Contour3d::Contour3d(int _vf) { done = 0; nvert = 0; ntri = 0; vf = _vf; vsize = 500; tsize = 1000; vert = (float (*)[3])malloc(sizeof(float[3]) * vsize); vnorm = (float (*)[3])malloc(sizeof(float[3]) * vsize); tri = (u_int (*)[3])malloc(sizeof(u_int[3]) * tsize); vfun = (float *)malloc(sizeof(float)*vsize); color = (vf>1); #ifdef USEDICT /* added by Joe R. 12/21/2005 */ dict_init(&vertex_dict,DICTCOUNT_T_MAX,VertexCompare); dict_set_allocator(&vertex_dict,VertexNodeAlloc,VertexNodeDelete,NULL); #endif } //------------------------------------------------------------------------ // // ~Contour3d() - free allocated memory // //------------------------------------------------------------------------ Contour3d::~Contour3d() { if (verbose) { printf ("Contour3d destructor\n"); } free(vert); free(vnorm); free(tri); free(vfun); #ifdef USEDICT dict_free(&vertex_dict); /* added by Joe R. 12/21/2005 - Deletes all vertex dictionary entries */ #endif } //------------------------------------------------------------------------ // // AddVert() - add a vertex with the given (unit) normal // //------------------------------------------------------------------------ int Contour3d::AddVert(float x, float y, float z, float nx, float ny, float nz, float f) { int n = nvert++; if (nvert > vsize) { vsize<<=1; vert = (float (*)[3])realloc(vert, sizeof(float[3]) * vsize); vnorm = (float (*)[3])realloc(vnorm, sizeof(float[3]) * vsize); vfun = (float *)realloc(vfun, sizeof(float)*vsize); } vert[n][0] = x; vert[n][1] = y; vert[n][2] = z; vnorm[n][0] = nx; vnorm[n][1] = ny; vnorm[n][2] = nz; vfun[n] = f; // printf("f = %f\n", f); #ifdef USEDICT /* added by Joe R. 12/21/2005 */ vertex_dict_entry *vde = (vertex_dict_entry*)malloc(sizeof(vertex_dict_entry)); vde->x = x; vde->y = y; vde->z = z; vde->i = n; dict_alloc_insert(&vertex_dict, vde, vde); #endif return(n); } //------------------------------------------------------------------------ // // AddVertUnique() - add a vertex with the given (unit) normal // //------------------------------------------------------------------------ int Contour3d::AddVertUnique(float x, float y, float z, float nx, float ny, float nz, float f) { #ifdef USEDICT /* added by Joe R. 12/21/2005 */ vertex_dict_entry vde; vde.x = x; vde.y = y; vde.z = z; dnode_t *n = dict_lookup(&vertex_dict,&vde); if(n != NULL) return ((vertex_dict_entry*)dnode_get(n))->i; else return(AddVert(x,y,z,nx,ny,nz,f)); #else int i; for (i=nvert-1; i>=0; i--) { if ((fabs(vert[i][0]-x) < 0.00001) && (fabs(vert[i][1]-y) < 0.00001) && (fabs(vert[i][2]-z) < 0.00001)) return(i); } #endif return(AddVert(x,y,z,nx,ny,nz,f)); } //------------------------------------------------------------------------ // // AddTri() - add a triangle indexed by it's 3 vertices // //------------------------------------------------------------------------ int Contour3d::AddTri(u_int v1, u_int v2, u_int v3) { int n = ntri++; if (ntri > tsize) { tsize<<=1; tri = (u_int (*)[3])realloc(tri, sizeof(u_int[3]) * tsize); } tri[n][0] = v1; tri[n][1] = v2; tri[n][2] = v3; return(n); } //------------------------------------------------------------------------ // // Reset() - clear vertex and surface info // //------------------------------------------------------------------------ void Contour3d::Reset(void) { nvert = 0; ntri = 0; done = 0; #ifdef USEDICT dict_free(&vertex_dict); /* added by Joe R. 12/21/2005 - Deletes all vertex dictionary entries */ #endif } void Contour3d::Done(void) { done = 1; } //------------------------------------------------------------------------ // // write() - write vertex and triangles to a file // //------------------------------------------------------------------------ int Contour3d::write(char *filename) { #ifdef WRITE_IPOLY FILE *fp; int v, t; fp = fopen(filename, "w"); // silent failure: changed by Emilio --> return 1 = ERROR if (fp == NULL) return 1; fprintf(fp, "%d 0 %d 0 0 0 0\n0 0 0\n", nvert, ntri); for (v=0; v return 1 = ERROR if (fp == NULL) return 1; nvf = 1; nmat = 0; fwrite(&nvert, sizeof(int), 1, fp); fwrite(&ntri, sizeof(int), 1, fp); fwrite(&nvf, sizeof(int), 1, fp); fwrite(&nmat, sizeof(int), 1, fp); fwrite(vert, sizeof(float[3]), nvert, fp); for (t=0; t #if ! defined (__APPLE__) #include #else #include #endif #include #include "data.h" int Data::funtopol1; int Data::funtopol2; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/range.cpp0000644000175000017500000002051410064121655025112 0ustar debiandebian // $Id: range.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include #include #ifndef WIN32 #include #endif #include "range.h" #define MIN2(x,y) ((x)<(y)?(x):(y)) #define MAX2(x,y) ((x)>(y)?(x):(y)) //----------------------------------------------------------- // // Check - check for consistency in range // //----------------------------------------------------------- void Range::Check(void) { int i; for (i=0; i max[i]) { printf("invalid range!\n"); #ifndef WIN32 sleep(3); #endif } if (i min[i+1]) { printf("invalid range(s)!\n"); #ifndef WIN32 sleep(3); #endif } } } //----------------------------------------------------------- // // Compress - compress a range // //----------------------------------------------------------- void Range::Compress(void) { int i, j; #ifdef DBG printf("compressing range:"); Print(r); #endif for (i=0; i max[i]) max[i] = max[j]; } if (j != i+1) { memcpy(&min[i+1], &min[j], sizeof(float)*(j-(i+1))); memcpy(&max[i+1], &max[j], sizeof(float)*(j-(i+1))); nrange -= (j-(i+1)); } } #ifdef DBG printf("resulting range:"); Print(r); #endif } //----------------------------------------------------------- // // Print - print a range // //----------------------------------------------------------- void Range::Print() { int i; if (Empty()) { printf("empty\n"); return; } for (i=0; i%f%s", min[i], max[i], (i==(nrange-1))?"\n":", "); } //----------------------------------------------------------- // // AddRange - add a range to a Range // //----------------------------------------------------------- void Range::AddRange(float min_val, float max_val) { int i; for (i=nrange-1; i>=0 && min[i] > min_val; i--) { min[i+1] = min[i]; max[i+1] = max[i]; } min[i+1] = min_val; max[i+1] = max_val; nrange++; } //----------------------------------------------------------- // // += - add the given range // //----------------------------------------------------------- Range & Range::operator+=(const Range &r) { int i; for (i=0; inrange = 0; if (nrange != 0) { curmin = min[0]; while (i < nrange && j < r2.nrange) { if (curmin <= r2.min[j]) { if (max[i] < r2.min[j]) { /* the remainder of this can be taken */ n = result->nrange++; result->min[n] = curmin; result->max[n] = max[i]; i++; if (i < nrange) curmin = min[i]; } else { if (max[i] < r2.max[j]) { if (curmin != r2.min[j]) { n = result->nrange++; result->min[n] = curmin; result->max[n] = r2.min[j]; } i++; if (i < nrange) curmin = min[i]; } else { if (curmin != r2.min[j]) { n = result->nrange++; result->min[n] = curmin; result->max[n] = r2.min[j]; } curmin = r2.max[j]; j++; if (curmin == max[i]) { i++; if (i < nrange) curmin = min[i]; } } } } else { if (max[i] <= r2.max[j]) { i++; if (i < nrange) curmin = min[i]; } else if (r2.max[j] <= curmin) { j++; } else { curmin = r2.max[j]; j++; if (curmin == max[i]) { i++; if (i < nrange) curmin = min[i]; } } } } /* anything left in this remains in result */ while (i < nrange) { n = result->nrange++; result->min[n] = curmin; result->max[n] = max[i]; if (i+1 < nrange) curmin = min[i+1]; i++; } } #ifdef CHECK result->Check(); #endif *this = *result; return(*this); } //----------------------------------------------------------- // // Intersect -- ***** WARNING - this is broken // //----------------------------------------------------------- Range& Range::operator^(const Range &r2) { static Range r; Range *result = &r; int i, j, n; i = 0; j = 0; result->nrange = 0; while (i < nrange && j < r2.nrange) { if (min[i] <= r2.min[j]) { if (max[i] >= r2.min[j]) { if (max[i] < r2.max[j]) { n = result->nrange++; result->min[n] = r2.min[j]; result->max[n] = max[i]; i++; } else { n = result->nrange++; result->min[n] = r2.min[j]; result->max[n] = r2.max[j]; j++; } } else i++; } else { if (r2.max[j] >= min[i]) { if (r2.max[j] < max[i]) { n = result->nrange++; result->min[n] = min[i]; result->max[n] = r2.max[j]; j++; } else { n = result->nrange++; result->min[n] = min[i]; result->max[n] = max[i]; } } else j++; } } #ifdef CHECK RangeCheck(result); #endif return(*result); } //----------------------------------------------------------- // // Equal - test for equivalence of two ranges // //----------------------------------------------------------- int Range::operator==(const Range &r2) const { int i; if (nrange != r2.nrange) return(0); for (i=0; inrange = 1; result->min[0] = min_val; result->max[0] = max_val; return(*result); } result->nrange = 0; if (min_val < min[0]) { n = result->nrange++; result->min[n] = min_val; result->max[n] = min[0]; } for (i=0; inrange++; result->min[n] = max[i]; result->max[n] = min[i+1]; } if (max_val > max[nrange-1]) { n = result->nrange++; result->min[n] = max[nrange-1]; result->max[n] = max_val; } #ifdef CHECK result->Check(); #endif return(r); } //----------------------------------------------------------- // // Disjoint - test if two ranges are disjoint // //----------------------------------------------------------- int Range::Disjoint(const Range &r2) const { static Range diff; diff = (*this) - r2; return((diff == *this)); #if 0 /* don't use RangeIntersect for now.. it's broken */ RangeIntersect(&intr, r1, r2); if (intr.nrange > 20) { printf("intersection has %d ranges\n", intr.nrange); sleep(5); } if (RangeEmpty(intr)) return(1); /* if result has a nonzero width range, ranges were not disjoint */ for (i=0; i #include "contour2d.h" #include "dataset.h" #include "segtree.h" #include "seedcells.h" #include "cellqueue.h" #include "edgehash.h" #include "range.h" #include "datasetslc.h" #include "conplot.h" //------------------------------------------------------------------------ // // conplot2d.h // //------------------------------------------------------------------------ class Conplot2d : public Conplot { public: Conplot2d(Datasetslc *d); virtual ~Conplot2d(); protected: // extract in 3d (from memory) or slice-by-slice (swap from disk) u_int ExtractAll(float isovalue); int InterpEdge(int, float *, u_int *, float, int); // track a contour from a seed cell void TrackContour(float, int); // enqueue faces for propagation of surface inline void EnqueueFaces(int, int, CellQueue &); void Reset(int t) { con2[t].Reset(); } int Size(int t) { return(con2[t].getSize()); } int isDone(int t) { return(con2[t].isDone()); } void Done(int t) { con2[t].Done(); } private: Datasetslc *slc; Dataslc *curslc; Contour2d *con2, *curcon; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dataset.h0000644000175000017500000000631311065020741025105 0ustar debiandebian//-------------------------------------------------------------------- // // Dataset - representation for a time-varying dataset // // Copyright (c) 1997 Dan Schikore - updated by Emilio Camahort, 1999 // //-------------------------------------------------------------------- // $Id: dataset.h,v 1.2 2008/09/19 22:04:17 annao Exp $ #ifndef DATASET_H #define DATASET_H #include "data.h" //-------------------------------------------------------------------- // // Dataset - a scalar time-varying dataset // //-------------------------------------------------------------------- class Dataset { private: // data members Data::DataType type; // data type: uchar, ushort, float // Made ntime protected, Anthony Thane 3-26-02 //int ntime; // number of timesteps int ndata; // add by fan char **filenames; // data filenames protected: // Made ntime protected, Anthony Thane 3-26-02 int ntime; // number of timesteps u_int ncells; // number of cells int meshtype; // 2d unstr, reg2, 3d unstr, reg3 int maxcellindex; // maximum number of cells float *min, *max; // min/max values for each variable public: // constructors and destructors Dataset(Data::DataType t, int ndata, int ntime, char *files[]); Dataset(Data::DataType t, int ndata, int ntime, u_char *data); virtual ~Dataset() { if (verbose) printf("Dataset destructor\n"); } // member access methods Data::DataType dataType(void) const { return(type); } int meshType(void) const { return(meshtype); } int nTime(void) const { return(ntime); } int nData(void) const { return(ndata); } char **fileNames(void) const { return(filenames); } virtual float getMin(int t) const = 0; // min, max for "0" variable virtual float getMax(int t) const = 0; // at time step "t" virtual float getMin() const = 0; // min, max for "0" variable virtual float getMax() const = 0; // over all times // add by fan virtual float getMinFun(int f) const = 0; // min, max for "j" variable virtual float getMaxFun(int f) const = 0; // over all times (reg3 only) // end fan virtual Data *getData(int i) = 0; u_int getNCells(void) { return(ncells); } int maxCellIndex(void) { return(maxcellindex); } }; //------------------------------------------------------------------------ // // Dataset() - the usual constructor, initializes some data // //------------------------------------------------------------------------ inline Dataset::Dataset(Data::DataType t, int nd, int nt, char *fn[]) { type = t; // base type of the data ntime = nt; // number of time step ndata = nd; // number of data: add by fan filenames = fn; // filenames containing the data } //------------------------------------------------------------------------ // // Dataset() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ inline Dataset::Dataset(Data::DataType t, int nd, int nt, u_char *data) { type = t; ntime = nt; ndata = nd; filenames = NULL; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedchkr2.h0000644000175000017500000000073110064121655025334 0ustar debiandebian // $Id: seedchkr2.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef SEED_CHKR2_H #define SEED_CHKR2_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class Datavol; class Dataslc; class seedChkr2 { public: seedChkr2(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~seedChkr2() {} void compSeeds(void); private: Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/range.h0000644000175000017500000001006110064121655024553 0ustar debiandebian//------------------------------------------------------------------------------- // // range.h - class for performing range arithmetic. A single range consists of // a sorted list of non-overlapping (min,max) pairs. For simplificity, // we cap the number of pairs at 40. This should be dynamic, though // for our usage ranges are not so fragmented. // //------------------------------------------------------------------------------- // $Id: range.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef RANGE_H #define RANGE_H #include class Range { public: // default constructor Range(void) { nrange = 0; } // simple range constructor Range(float mn, float mx) { nrange = 1; min[0] = mn; max[0] = mx; } // copy constructor Range(const Range &r) { nrange = r.nrange; memcpy(min, r.min, sizeof(float)*nrange); memcpy(max, r.max, sizeof(float)*nrange); } // destructor virtual ~Range() {} // return number of closed segments int NSegs(void) { return(nrange); } // return min value for a given segment float Min(int i) { return(min[i]); } // return max value for a given segment float Max(int i) { return(max[i]); } // return min value of all segments float MinAll(void) { return(min[0]); } // return max value of all segments float MaxAll(void) { return(max[nrange-1]); } // true if range is empty int Empty(void) { return(NSegs()==0); } // set the min value for a segment void SetMin(int i, float m) { min[i] = m; } // set the max value for a segment void SetMax(int i, float m) { max[i] = m; } // empty the range void MakeEmpty(void) { nrange=0; } // reset to a simple range void Set(float mn, float mx) { nrange=1, min[0]=mn, max[0]=mx; } // compress a list of segments which may contain (a,b),(b,c) -> (a,c) void Compress(void); // print a range (useful for debugging) void Print(void); // add the given (min,max) segment to the range void AddRange(float, float); // union operator Range operator+(const Range &rhs) const { Range result(*this); result+=rhs; return(result); } // in-place union operator Range& operator+=(const Range &); // eq Range& operator=(const Range &r) { nrange = r.nrange; memcpy(min, r.min, sizeof(float)*nrange); memcpy(max, r.max, sizeof(float)*nrange); return(*this); } // difference operator Range operator-(const Range &rhs) const { Range result(*this); result-=rhs; return(result); } void diff(const Range &op1, const Range &op2) { *this = op1; *this += op2; } // in-place difference operator Range& operator-=(const Range &); // intersection operator Range& operator^(const Range &); // equivalence int operator==(const Range &) const; // complement Range Complement(float min, float max); // Emilio: the following commented out, since it's poor style (gives a // warning and is not used anywhere in the code #ifdef EMILIO // complement Range& Complement(const Range &r, float min, float max) { Range result(r); result.Complement(min,max); return(result); } #endif /* of EMILIO */ // true if the given range is disjoint from "this" int Disjoint(const Range &) const; protected: // check to see if the current range is "valid" (no min>max, etc) void Check(void); private: // number of segments in the range int nrange; // sorted (min,max) for each segment float min[40], max[40]; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dirseedsreg2.cpp0000644000175000017500000001433410064121655026403 0ustar debiandebian // $Id: dirseedsreg2.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include "dirseedsreg2.h" #include "datareg2.h" #include "basic.h" #define DEBUGNo #define DEBUGSLEEPNo #define sgn(x) ((x)>0 ? 1 : ((x)<0?-1:0)) extern int verbose; void dirSeedsReg2::dirSweep(Datareg2 ®2) { u_int i, j; Range resp; float min, max, t; float gradx; float grad1ya, grad1yb; float grad2ya, grad2yb; int keepflat; int prev; for (i=0; i max) max = t; if (min != max) resp += Range(min,max); } else { // never do anything other than on boundary } // right if (i == reg2.dim[0]-2) { // never keep a right boundary seed } else { // never keep a right boundary seed } // general case: bottom edge in middle // cell (i,j) and (i,j-1) share this x-grad gradx = reg2.getValue(reg2.index2vert(i+1,j)) - reg2.getValue(reg2.index2vert(i,j)); // compute y-grad at (i,j) and (i+1,j) grad1ya = reg2.getValue(reg2.index2vert(i,j+1)) - reg2.getValue(reg2.index2vert(i,j)); grad1yb = reg2.getValue(reg2.index2vert(i+1,j+1)) - reg2.getValue(reg2.index2vert(i+1,j)); if (keepflat) { // check to see if gradient has 'turned' // only a seed if gradx & grady disagree in sign // note that 0 gradient is not considered opposite if (sgn(grad1ya) == 0 && sgn(grad1yb) == 0) { // flat cell (in y dim) - continue } else if (sgn(gradx) == -sgn(grad1ya) || sgn(gradx) == -sgn(grad1yb)) { // extreme occurs if y components oppose each other // note that 0 gradient is not considered opposite min = max = reg2.getValue(reg2.index2vert(i,j)); if ((t=reg2.getValue(reg2.index2vert(i+1,j))) < min) min = t; if (t > max) max = t; resp += Range(min,max); keepflat = 0; } } // top if (j == reg2.dim[1]-2) { if (keepflat) { min = max = reg2.getValue(reg2.index2vert(i,j+1)); if ((t=reg2.getValue(reg2.index2vert(i+1,j+1))) < min) min = t; if (t > max) max = t; resp += Range(min,max); } } else { // only consider the top at the boundary if (!keepflat) { gradx = reg2.getValue(reg2.index2vert(i+1,j+1)) - reg2.getValue(reg2.index2vert(i,j+1)); grad2ya = reg2.getValue(reg2.index2vert(i,j+1)) - reg2.getValue(reg2.index2vert(i,j)); grad2yb = reg2.getValue(reg2.index2vert(i+1,j+1)) - reg2.getValue(reg2.index2vert(i+1,j)); if (sgn(gradx) != 0 && (sgn(gradx) == sgn(grad2ya) || sgn(gradx) == sgn(grad2yb))) keepflat=1; } else { gradx = reg2.getValue(reg2.index2vert(i+1,j+1)) - reg2.getValue(reg2.index2vert(i,j+1)); grad2ya = reg2.getValue(reg2.index2vert(i,j+1)) - reg2.getValue(reg2.index2vert(i,j)); grad2yb = reg2.getValue(reg2.index2vert(i+1,j+1)) - reg2.getValue(reg2.index2vert(i+1,j)); if (sgn(gradx) == -sgn(grad2ya) || sgn(gradx) == -sgn(grad2yb)) keepflat=0; } } if (!resp.Empty()) { if (prev == -1) { if (i!=0) prev = seeds.AddSeed(reg2.index2cell(i,j), resp.MinAll(), resp.MaxAll()); else seeds.AddSeed(reg2.index2cell(i,j), resp.MinAll(), resp.MaxAll()); } else { seeds.AddToRange(prev, resp.MinAll(), resp.MaxAll()); prev = -1; } } else prev = -1; } } #if 0 for (c=0; c= 0.0) { slc.getCellGrad(adjc, g2); #ifdef DEBUG printf("adj grad: %f %f\n", g2[0], g2[1]); #endif if (sgn(g1[0])==sgn(g1[1]) && g1[1] * g2[1] < 0.0) { slc.getFaceRange(c,f,min,max); #ifdef DEBUG printf("seed range: %f %f\n", min, max); sleep(10); #endif resp += Range(min,max); } } } else { // boundary case... do something special? slc.normalToFace(c,f,norm); // first condition: all left boundary cells are selected // second: top/bottom sides *may* be selected // right hand cells should never be selected (sgn==0.0) if ((fabs(norm[1]) < 0.0000001 && norm[0] < 0.0) || (sgn(norm[1]) * (sgn(g1[0]*g1[1])) > 0.0)) { slc.getFaceRange(c,f,min,max); resp += Range(min,max); } } } if (!resp.Empty()) seeds.AddSeed(c, resp.MinAll(), resp.MaxAll()); } #endif } void dirSeedsReg2::compSeeds(void) { if (verbose) printf("------- computing seeds\n"); // clear the array of mark bits seeds.Clear(); dirSweep((Datareg2&)data); if (verbose) printf("computed %d seeds\n", seeds.getNCells()); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/hash.h0000644000175000017500000001125410064121655024407 0ustar debiandebian/*****************************************************************************\ * * hash.h -- a simple hash table * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * \*****************************************************************************/ // $Id: hash.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef __HASH_H #define __HASH_H #include "basic.h" #include "shelf.h" /** A simple templated hash table. This is an implementation of a simple, general-purpose hash table. Collision resolution is by chaining. The hash function must be provided by the programmer, and is installed by the constructor. An equality operator must also be provided. A hash function that is likely to work well is the following [Cormen, Leiserson, Rivest]: $h(k) = floor( m * frac( k * A ) )$ where $k$ is the key, $m$ is the size of the index, and $A$ is $(\sqrt(5)-1)/2$. #T# is the templated type of a data item. It must contain a key of type #K#. For example: struct HashKey { int i, j; }; struct HashItem { HashKey k; double p; } */ template class HashTable { public: /** Constructor. #sz#: Size of the index. #hf#: Hash function. Takes a key, returns an int. #eq#: Equal. returns true if the key matches the item. */ HashTable(int sz, int (*hf)(const K&), bool (*eq)(const K&, const T&)); /// Destructor. ~HashTable(); /// Reinitializes the table. void cleanUp(); /** Add an item to the table. Result is #true# if the item has been added, #false# if it was already present. A pointer to the item in the table is returned in #ptr#. */ bool add(const K& key, const T& item, T*& ptr); /// Delete item with key. return false if item is not in the table bool remove(const K& key); /** Returns a pointer to the item with #key#. NULL if not in the table. */ T* fetch(const K& key); //@name Iterator //@{ void first(int& i) const; bool more(const int& i) const; void next(int& i) const; //@} const T& operator[](int i) const; T& operator[](int i); private: struct HashItem { T data; int next; }; bool lookup(const K& key, int& index) const; // DATA int _sz; int (*_hf)(const K&); bool (*_eq)(const K&, const T&); int* _index; Shelf _buffer; }; /*****************************************************************************\ * inline functions \*****************************************************************************/ template HashTable::HashTable(int sz, int (*hf)(const K&), bool (*eq)(const K&, const T&)) { _sz = sz; _hf = hf; _eq = eq; _index = new int[_sz]; for( int i = 0; i < _sz; ++i ) { _index[i] = INDEX_NULL; } } template HashTable::~HashTable() { delete[] _index; } template void HashTable::cleanUp() { _buffer.cleanUp(); for( int i = 0; i < _sz; ++i ) { _index[i] = INDEX_NULL; } } template bool HashTable::lookup(const K& key, int& index) const { int h = _hf(key); for( int i = _index[h]; i != INDEX_NULL; i = _buffer[i].next ) { if( _eq( key, _buffer[i].data ) ) { index = i; return true; } } index = h; return false; } template T* HashTable::fetch(const K& key) { int i; if( lookup( key, i ) ) { return &(_buffer[i].data); } else { return NULL; } } template bool HashTable::add(const K& key, const T& item, T*& ptr) { int i; if( lookup(key, i) ) { ptr = &_buffer[i].data; return false; } else { int tmp = _index[i]; _index[i] = _buffer.put(); _buffer[_index[i]].data = item; _buffer[_index[i]].next = tmp; ptr = &_buffer[_index[i]].data; return true; } } template bool HashTable::remove(const K& key) { int i, p, h = _hf(key); for( i = _index[h], p = -1; i != INDEX_NULL; p = i, i = _buffer[i].next ) { if( _eq( key, _buffer[i].data ) ) { if( i == _index[h] ) { _index[h] = _buffer[i].next; } else { _buffer[p].next = _buffer[i].next; } _buffer.remove(i); return true; } } return false; } template void HashTable::first(int& i) const { _buffer.first(i); } template bool HashTable::more(const int& i) const { return !_buffer.end(i); } template void HashTable::next(int& i) const { _buffer.next(i); } template const T& HashTable::operator[](int i) const { return _buffer[i].data; } template T& HashTable::operator[](int i) { return _buffer[i].data; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/ipqueue.cpp0000644000175000017500000000070610064121655025474 0ustar debiandebian/*****************************************************************************\ * * ipqueue.cc -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: ipqueue.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include "ipqueue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/cellsearch.h0000644000175000017500000000540010352632577025577 0ustar debiandebian//---------------------------------------------------------------------------- // // cellSearch.h - cell search structure // //---------------------------------------------------------------------------- // $Id: cellsearch.h,v 1.2 2005/12/22 23:23:43 annao Exp $ #ifndef CELL_SEARCH_H #define CELL_SEARCH_H #include #include #include #ifdef WIN32 typedef unsigned int u_int; #endif extern int verbose; //---------------------------------------------------------------------------- // // list of cells which cross a given segment // //---------------------------------------------------------------------------- class CellBucket { public: CellBucket(); ~CellBucket(); void insert(u_int cellid); int nCells(void) { return(ncells); } u_int getCell(u_int i) { return(cells[i]); } void getCells(u_int *, u_int &); void traverseCells(void (*f)(u_int, void *), void*); void dump(char *str); u_int *getCells(void) { return(cells); } private: int ncells; int cellsize; u_int *cells; }; inline CellBucket::CellBucket() { ncells = 0; cellsize = 0; cells = NULL; } inline CellBucket::~CellBucket() { if (cells != NULL) free(cells); } inline void CellBucket::insert(u_int cellid) { int n = ncells++; if (n >= cellsize) { if (cellsize == 0) { cellsize = 5; cells = (u_int *)malloc(sizeof(u_int)*cellsize); } else { cellsize *= 2; cells = (u_int *)realloc(cells, sizeof(u_int)*cellsize); } } cells[n] = cellid; } inline void CellBucket::getCells(u_int *a, u_int &n) { memcpy(&a[n], cells, sizeof(u_int)*ncells); n += ncells; } inline void CellBucket::traverseCells(void (*f)(u_int, void *), void *data) { int i; for (i=0; i #include #include #ifndef WIN32 #include #endif #if ! defined (__APPLE__) #include #else #include #endif #include #include "bucketsearch.h" #define DEBUG_TREENo #ifdef WIN32 typedef unsigned int u_int; #endif extern int verbose; //---------------------------------------------------------------- // // BucketSearch() - construct a segment tree for the given range of values // //---------------------------------------------------------------- BucketSearch::BucketSearch(u_int n, float *val) { if (n==0) { minval = maxval = 0; nbuckets = 0; buckets = NULL; return; } Init(n, val); } //---------------------------------------------------------------- // // Init() - Initialize the segment tree for the given set of values // //---------------------------------------------------------------- void BucketSearch::Init(u_int n, float *val) { minval = val[0]; maxval = val[n-1]; nbuckets = int(val[n-1] - val[0]); buckets = new CellBucket[nbuckets]; } //---------------------------------------------------------------- // // ~BucketSearch() - free storage for a segment tree // //---------------------------------------------------------------- BucketSearch::~BucketSearch() { if (verbose) printf("BucketSearch destructor\n"); /* should free inside buckets here */ delete [] buckets; } void BucketSearch::Done(void) { } //---------------------------------------------------------------- // // InsertSet() - recursively insert a segment into the tree // //---------------------------------------------------------------- void BucketSearch::InsertSeg(u_int cellid, float min, float max) { u_int first, last; u_int b; first = whichBucket(min); last = whichBucket(max); for (b=first; b max) max = buckets[i].nCells(); } printf("total labels in buckets: %d\n", total); printf("maximum labels in one list: %d\n", max); printf("______BUCKET STATS_____\n"); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplot_p.cpp0000644000175000017500000001213611065020741026010 0ustar debiandebian//------------------------------------------------------------------------ // // conPlot_p.C - preprocessing of 3d volumes for seed set extraction // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: conplot_p.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #include #ifndef WIN32 #include #include #endif #include "conplot.h" #include "range.h" #include "segtree.h" #include "rangeprop.h" #include "rangesweep.h" #include "dirseeds.h" #include "dirseedsreg2.h" #include "regprop.h" #include "regprop2.h" #include "respprop2.h" #include "seedchkr2.h" #include "seedchkr3.h" #include "seeddirreg3.h" #include "seedall.h" #define TREE_INFO #define TREE_DUMPNo //#define ALL //#define RESPPROP2 // general propagation //#define RANGEPROP // regular propagation (regular grids 3d & 2d) #define REGPROP //#define REGPROP2 // climbing (dimension independent) //#define RANGESWEEP // checkerboard (regular grids 2d & 3d) //#define CHKR2 //#define CHKR3 // directional sweep (unst 2d, str 3d & 2d) //#define DIRSEEDS //#define DIRSEEDSREG3 //#define DIRSEEDSREG2 extern int verbose; //------------------------------------------------------------------------ // // fltcmp() - comparison function for two floats for sorting // //------------------------------------------------------------------------ static int fltcmp(const void *v1, const void *v2) { const float *f1 = (float *)v1; const float *f2 = (float *)v2; if (*f1 < *f2) return(-1); if (*f1 > *f2) return(1); return(0); } //------------------------------------------------------------------------ // // BuildSegTree() - build a segment tree for O(log n) queries // //------------------------------------------------------------------------ void Conplot::BuildSegTree(int t) { float *val; int i, nval; #ifdef USE_BUCKETS u_int totalsize=0; #endif // get the full list of values val = (float *)malloc(sizeof(float) * seeds[t].getNCells()*2); for (i=0; i 1) { printf("minimum seed val: %f\n", val[0]); printf("maximum seed val: %f\n", val[seeds[t].getNCells()*2-1]); } // get rid of duplicates nval=1; for (i=1; i 1) printf("there are %d distinct seed values\n", nval); // initialize the tree and add each segment if (verbose) printf("initializing tree %d\n", t); tree[t].Init(nval, val); for (i=0; igetData(t)), seeds[t], *this); sweep.compSeeds(); #elif defined DIRSEEDS dirSeeds dir(*(data->getData(t)), seeds[t], *this); dir.compSeeds(); #elif defined DIRSEEDSREG2 dirSeedsReg2 dir(*(data->getData(t)), seeds[t], *this); dir.compSeeds(); #elif defined DIRSEEDSREG3 seedDirReg3 dir(*(data->getData(t)), seeds[t], *this); dir.compSeeds(); #elif defined RANGEPROP rangeProp prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #elif defined REGPROP2 regProp2 prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #elif defined REGPROP regProp prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #elif defined CHKR2 seedChkr2 prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #elif defined CHKR3 seedChkr3 prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #elif defined ALL seedAll prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #elif defined RESPPROP2 respProp2 prop(*(data->getData(t)), seeds[t], *this); prop.compSeeds(); #endif last=clock(); if (verbose) printf("seed search %d clocks, (%f sec)\n", (last-first), (last-first)/(float)CLOCKS_PER_SEC); first=clock(); BuildSegTree(t); last=clock(); if (verbose) printf("search build %d clocks, (%f sec)\n", (last-first), (last-first)/(float)CLOCKS_PER_SEC); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/cellqueue.cpp0000644000175000017500000000121611065020741025774 0ustar debiandebian//------------------------------------------------------------------------ // // cellQueue.C - queue of cell identifiers. The circular queue dyanmically // resizes itself when full. Elements in the queue are of // indicies of i,j,k (specialized for 3d structured grids) // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: cellqueue.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #include "cellqueue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/spectrumtest.cpp0000644000175000017500000000175110352633120026555 0ustar debiandebian#include "contour.h" // uchar_data : volume data which has unsigned char values as an array // dim : integer array with 3 elements. dim[0]:x,dim[1]:y,dim[2]:z // array_size : will be set as the array size of isoval,area,...,gradient // usually 256 // isoval : array with regularly increasing from min to max values // area,min_vol,max_vol,gradient : array of quantitative properties // : needs to be normalized void getContourSpectrum(unsigned char* uchar_data, int* dim, int& array_size, float* isoval , float* area, float* min_vol, float* max_vol, float* gradient) { int i; array_size=256; ConDataset* the_data; the_data = newDatasetReg(CONTOUR_UCHAR, CONTOUR_REG_3D, 1, 1, dim,uchar_data); Signature *sig; sig=getSignatureFunctions(the_data, 0,0); for (i=0;i # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=libcontour - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "libcontour.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "libcontour.mak" CFG="libcontour - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "libcontour - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "libcontour - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "libcontour - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "libcontour - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "libcontour - Win32 Release" # Name "libcontour - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\bin.cpp # End Source File # Begin Source File SOURCE=.\bucketsearch.cpp # End Source File # Begin Source File SOURCE=.\cellqueue.cpp # End Source File # Begin Source File SOURCE=.\conplot.cpp # End Source File # Begin Source File SOURCE=.\conplot2d.cpp # End Source File # Begin Source File SOURCE=.\conplot3d.cpp # End Source File # Begin Source File SOURCE=.\conplot_p.cpp # End Source File # Begin Source File SOURCE=.\conplotreg2.cpp # End Source File # Begin Source File SOURCE=.\conplotreg3.cpp # End Source File # Begin Source File SOURCE=.\contour.cpp # End Source File # Begin Source File SOURCE=.\contour2d.cpp # End Source File # Begin Source File SOURCE=.\contour3d.cpp # End Source File # Begin Source File SOURCE=.\cubes.cpp # End Source File # Begin Source File SOURCE=.\data.cpp # End Source File # Begin Source File SOURCE=.\datareg2.cpp # End Source File # Begin Source File SOURCE=.\datareg3.cpp # End Source File # Begin Source File SOURCE=.\dataslc.cpp # End Source File # Begin Source File SOURCE=.\datavol.cpp # End Source File # Begin Source File SOURCE=.\dirseeds.cpp # End Source File # Begin Source File SOURCE=.\dirseedsreg2.cpp # End Source File # Begin Source File SOURCE=.\edgehash.cpp # End Source File # Begin Source File SOURCE=.\hash.cpp # End Source File # Begin Source File SOURCE=.\inttree.cpp # End Source File # Begin Source File SOURCE=.\ipqueue.cpp # End Source File # Begin Source File SOURCE=.\iqueue.cpp # End Source File # Begin Source File SOURCE=.\queue.cpp # End Source File # Begin Source File SOURCE=.\range.cpp # End Source File # Begin Source File SOURCE=.\rangeprop.cpp # End Source File # Begin Source File SOURCE=.\rangesweep.cpp # End Source File # Begin Source File SOURCE=.\regprop.cpp # End Source File # Begin Source File SOURCE=.\regprop2.cpp # End Source File # Begin Source File SOURCE=.\respprop2.cpp # End Source File # Begin Source File SOURCE=.\seedall.cpp # End Source File # Begin Source File SOURCE=.\seedcells.cpp # End Source File # Begin Source File SOURCE=.\seedchkr2.cpp # End Source File # Begin Source File SOURCE=.\seedchkr3.cpp # End Source File # Begin Source File SOURCE=.\seeddirreg3.cpp # End Source File # Begin Source File SOURCE=.\segtree.cpp # End Source File # Begin Source File SOURCE=.\shelf.cpp # End Source File # Begin Source File SOURCE=.\squeue.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\basic.h # End Source File # Begin Source File SOURCE=.\bin.h # End Source File # Begin Source File SOURCE=.\bucketsearch.h # End Source File # Begin Source File SOURCE=.\cellqueue.h # End Source File # Begin Source File SOURCE=.\cellsearch.h # End Source File # Begin Source File SOURCE=.\commdata.h # End Source File # Begin Source File SOURCE=.\compute.h # End Source File # Begin Source File SOURCE=.\conplot.h # End Source File # Begin Source File SOURCE=.\conplot2d.h # End Source File # Begin Source File SOURCE=.\conplot3d.h # End Source File # Begin Source File SOURCE=.\conplotreg2.h # End Source File # Begin Source File SOURCE=.\conplotreg3.h # End Source File # Begin Source File SOURCE=.\contour.h # End Source File # Begin Source File SOURCE=.\contour2d.h # End Source File # Begin Source File SOURCE=.\contour3d.h # End Source File # Begin Source File SOURCE=.\cubes.h # End Source File # Begin Source File SOURCE=.\data.h # End Source File # Begin Source File SOURCE=.\datareg2.h # End Source File # Begin Source File SOURCE=.\datareg3.h # End Source File # Begin Source File SOURCE=.\dataset.h # End Source File # Begin Source File SOURCE=.\datasetreg2.h # End Source File # Begin Source File SOURCE=.\datasetreg3.h # End Source File # Begin Source File SOURCE=.\datasetslc.h # End Source File # Begin Source File SOURCE=.\datasetvol.h # End Source File # Begin Source File SOURCE=.\dataslc.h # End Source File # Begin Source File SOURCE=.\datavol.h # End Source File # Begin Source File SOURCE=.\dirseeds.h # End Source File # Begin Source File SOURCE=.\dirseedsreg2.h # End Source File # Begin Source File SOURCE=.\edgehash.h # End Source File # Begin Source File SOURCE=.\endian_io.h # End Source File # Begin Source File SOURCE=.\hash.h # End Source File # Begin Source File SOURCE=.\inttree.h # End Source File # Begin Source File SOURCE=.\ipqueue.h # End Source File # Begin Source File SOURCE=.\iqueue.h # End Source File # Begin Source File SOURCE=.\queue.h # End Source File # Begin Source File SOURCE=.\range.h # End Source File # Begin Source File SOURCE=.\rangeprop.h # End Source File # Begin Source File SOURCE=.\rangesweep.h # End Source File # Begin Source File SOURCE=.\regprop.h # End Source File # Begin Source File SOURCE=.\regprop2.h # End Source File # Begin Source File SOURCE=.\respprop2.h # End Source File # Begin Source File SOURCE=.\seedall.h # End Source File # Begin Source File SOURCE=.\seedcells.h # End Source File # Begin Source File SOURCE=.\seedchkr2.h # End Source File # Begin Source File SOURCE=.\seedchkr3.h # End Source File # Begin Source File SOURCE=.\seeddirreg3.h # End Source File # Begin Source File SOURCE=.\segtree.h # End Source File # Begin Source File SOURCE=.\shelf.h # End Source File # Begin Source File SOURCE=.\squeue.h # End Source File # Begin Source File SOURCE=.\utilities.h # End Source File # Begin Source File SOURCE=.\vtkmarchingcubescases.h # End Source File # End Group # End Target # End Project mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/data.h0000644000175000017500000003264411065020741024377 0ustar debiandebian//-------------------------------------------------------------------- // // Data - representation for a single timestep of data // - data elements can be scalar or vector // - ndata/nvars gives dimension of each element (1 for scalar) // // Copyright (c) 1997 Dan Schikore - updated by Emilio Camahort, 1998 // //-------------------------------------------------------------------- // $Id: data.h,v 1.4 2008/09/19 22:04:17 annao Exp $ #ifndef DATA_H #define DATA_H #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #ifdef __APPLE__ #include #endif #else typedef unsigned char u_char; typedef unsigned short u_short; typedef unsigned int u_int; #endif #include "endian_io.h" #define TRUE 1 #define FALSE 0 const unsigned int BAD_INDEX = 0xFFFFFFFF; extern int verbose; extern void (*errorHandler)(char *, int); //-------------------------------------------------------------------- // // Data - a scalar dataset // //-------------------------------------------------------------------- class Data { public: // DataType - supported types of raw data typedef enum { UCHAR=0, USHORT, FLOAT } DataType; // datatypes - a union to hold all of the above types typedef union { u_char *ucdata; u_short *usdata; float *fdata; } datatypes; // constructors and destructors Data(DataType t, int ndata, char *rawfile) { commonConstructor(t, ndata, rawfile); } Data(DataType t, int _ndata, u_char *data); virtual ~Data() { unsigned int f; if (verbose) { printf ("Data destructor\n"); } /****** this part results in Segmentation fault A.O for (f=0; f 1) // default setup add by fan { funcolor = 1; funcontour = 0; funtopol1 = 0; funtopol2 = 1; } else { funcontour = 0; funcolor = 0; } // end fan #ifdef WIN32 if (filename != NULL && (fp = fopen(filename, "rb"))) #else if (filename != NULL && (fp = fopen(filename, "r"))) #endif { if (verbose) printf("reading extent\n"); fread_float(minext, sizeof(float), 3, fp); fread_float(maxext, sizeof(float), 3, fp); if (verbose) printf(" min = %f %f %f max = %f %f %f\n", minext[0], minext[1], minext[2], maxext[0], maxext[1], maxext[2]); fread_int(&nverts, sizeof(int), 1, fp); fread_int(&ncells, sizeof(int), 1, fp); if (verbose) printf("%d verts, %d cells\n", nverts, ncells); } else { char str[256]; sprintf(str, "Data::commonConstructor: couldn't open file: %s", filename); errorHandler(str, TRUE); fp = NULL; } } //------------------------------------------------------------------------ // // Data() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ inline Data::Data(Data::DataType t, int _ndata, u_char *data) { type = t; ndata = _ndata; filename = NULL; min = NULL; max = NULL; if (ndata > 1) // default setup add by fan { funcolor = 1; funcontour = 0; funtopol1 = 0; funtopol2 = 1; } else { funcontour = 0; funcolor = 0; } // end fan } //------------------------------------------------------------------------ // // readData() - a function to read and preprocess an array of scalar data // //------------------------------------------------------------------------ inline void Data::readData(void) { u_int i; u_int f; float v; static float min_cutoff; // add by fan data = (datatypes *)malloc(sizeof(datatypes)*ndata); if (verbose) printf("reading data values\n"); switch (type) { case UCHAR: for (f=0; f v) { min_cutoff = v; funcontour = f; funcolor = f; } // end fan #endif } if (v > max[f]) max[f] = v; } if (verbose) printf("min = %f, max = %f\n", min[f], max[f]); } } //------------------------------------------------------------------------ // // preprocessData() - a function to preprocess an array of scalar data // //------------------------------------------------------------------------ inline void Data::preprocessData(u_char *data) { u_int i; u_int f; float v; static float min_cutoff; // add by fan Data::data = (datatypes *)malloc(sizeof(datatypes)*ndata); switch (type) { case UCHAR: for (f = 0; f < ndata; f++) Data::data[f].ucdata = ((u_char *)data) + f * nverts; break; case USHORT: for (f = 0; f < ndata; f++) Data::data[f].usdata = ((u_short *)data) + f * nverts; break; case FLOAT: for (f = 0; f < ndata; f++) Data::data[f].fdata = ((float *)data) + f * nverts; break; } min = (float *)malloc(sizeof(float)*ndata); max = (float *)malloc(sizeof(float)*ndata); min_cutoff = 1e10; // add by fan for (f = 0; f < ndata; f++) { if (verbose) printf("preprocessing size %d into %x\n", getDataSize(), getValues(f)); min[f] = 1e10; max[f] = -1e10; // fread(getValues(f), getDataSize(), nverts, fp); for (i=0; i v) { min_cutoff = v; funcontour = f; funcolor = f; } // end fan #endif } if (v > max[f]) max[f] = v; } if (verbose) printf("min = %f, max = %f\n", min[f], max[f]); } } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/segtree.cpp0000644000175000017500000001461711065020742025460 0ustar debiandebian//---------------------------------------------------------------- // // segTree.C - segment Tree manipulation // // Copyright (c) 1997 Dan Schikore // //---------------------------------------------------------------- // $Id: segtree.cpp,v 1.3 2008/09/19 22:04:18 annao Exp $ #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #include "segtree.h" extern int verbose; //---------------------------------------------------------------- // // SegTree() - construct a segment tree for the given range of values // //---------------------------------------------------------------- SegTree::SegTree(u_int n, float *val) { if (verbose) printf("seg tree constructor\n"); if (n==0) { nleaf=0; vals=NULL; leqthan = NULL; lessthan = NULL; grtrthan = NULL; return; } Init(n, val); } //---------------------------------------------------------------- // // Init() - Initialize the segment tree for the given set of values // //---------------------------------------------------------------- void SegTree::Init(u_int n, float *val) { nleaf = n; vals = (float *)malloc(sizeof(float)*nleaf); memcpy(vals, val, sizeof(float)*nleaf); leqthan = new CellBucket[nleaf]; lessthan = new CellBucket[nleaf]; grtrthan = new CellBucket[nleaf]; } //---------------------------------------------------------------- // // ~SegTree() - free storage for a segment tree // //---------------------------------------------------------------- SegTree::~SegTree() { if (verbose) printf("SegTree destructor\n"); free(vals); /* should free inside buckets here */ delete [] leqthan; delete [] lessthan; delete [] grtrthan; } //---------------------------------------------------------------- // // leftmostbit() - find the leftmost bit of an int // //---------------------------------------------------------------- static int leftmostbit(unsigned int i) { u_int b = 1; while (b <= i) b<<=1; return(b>>1); } //---------------------------------------------------------------- // // InsertSetR() - recursively split and insert a segment into // the tree // //---------------------------------------------------------------- void SegTree::InsertSegR(u_int cellid, float min, float max, int left, int right, float minval, float maxval) { int root, diff; #ifdef DEBUG_TREE printf("inserting cell %d (%d %d) (%f %f) (%f %f)\n", cellid, left, right, min, max, minval, maxval); #endif if (left == right) { if (min < maxval) { #ifdef DEBUG_TREE printf(" add to < bucket\n"); #endif /* insert in the lessthan bucket */ lessthan[left].insert(cellid); } else { #ifdef DEBUG_TREE printf(" add to > bucket\n"); #endif /* insert in the grtrthan bucket */ grtrthan[left].insert(cellid); } return; } /* compute the index of the root */ diff = right-left; root = leftmostbit(diff) - 1; root += left; #ifdef DEBUG_TREE printf("root of tree is at %d\n", root); #endif /* see if cell spans the current range */ if (min <= minval && max >= maxval) { #ifdef DEBUG_TREE printf(" spans whole cell\n"); #endif leqthan[root].insert(cellid); return; } if (min <= vals[root]) InsertSegR(cellid, min, MIN2(vals[root],max), left, root, minval, vals[root]); if (max > vals[root]) InsertSegR(cellid, MAX2(vals[root],min), max, root+1, right, vals[root], maxval); } //---------------------------------------------------------------- // // Traverse() - Traverse the tree, calling the given function for // each stored segment containing the given value // //---------------------------------------------------------------- void SegTree::Traverse(float val, void (*f)(u_int, void *), void *data) { int left, right, diff, root; left = 0; right = nleaf-1; while (left != right) { /* compute the index of the root */ diff = right-left; root = leftmostbit(diff) - 1; root += left; leqthan[root].traverseCells(f, data); if (val <= vals[root]) right=root; else left=root+1; } lessthan[left].traverseCells(f, data); if (val == vals[left]) grtrthan[left].traverseCells(f, data); } //---------------------------------------------------------------- // // getCells() - traverse the tree, storing the cell id's of all // segments containing the given value in a list // //---------------------------------------------------------------- u_int SegTree::getCells(float val, u_int *cells) { int left, right, diff, root; u_int ncells; left = 0; right = nleaf-1; ncells=0; while (left != right) { /* compute the index of the root */ diff = right-left; root = leftmostbit(diff) - 1; root += left; leqthan[root].getCells(cells, ncells); if (val <= vals[root]) right=root; else left=root+1; } lessthan[left].getCells(cells, ncells); if (val == vals[left]) grtrthan[left].getCells(cells, ncells); return(ncells); } //---------------------------------------------------------------- // // Dump() - dump the tree // //---------------------------------------------------------------- void SegTree::Dump(void) { int i; for (i=0; i max) max = leqthan[i].nCells(); if (lessthan[i].nCells() > max) max = lessthan[i].nCells(); if (grtrthan[i].nCells() > max) max = grtrthan[i].nCells(); } printf("total labels in tree: %d\n", total); printf("maximum labels in one list: %d\n", max); printf("______SEGMENT TREE STATS______\n"); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datareg2.cpp0000644000175000017500000002520311065020741025503 0ustar debiandebian//------------------------------------------------------------------------ // // datareg2.C - class for a regular 2d grid of scalar data // // Copyright (c) 1997 Dan Schikore - modified by Emilio Camahort, 1999 // //------------------------------------------------------------------------ // $Id: datareg2.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #endif #include "datareg2.h" #include "compute.h" #include "endian_io.h" #define SQR(x) ((x)*(x)) #define FSAMPLES 256 extern int verbose; //------------------------------------------------------------------------ // // bitsize - return the number of bits in an int (easier way?) // //------------------------------------------------------------------------ static int bitsize(unsigned int i) { u_int b = 1, size=0; while (b <= i) { b<<=1; size++; } return(size); } //------------------------------------------------------------------------ // // Datareg2() - constructor to initialize the data // //------------------------------------------------------------------------ Datareg2::Datareg2(Data::DataType t, int ndata, char *fn) : Data(t, ndata, fn) { if (verbose) printf("reading dimensions\n"); fread_int(dim, sizeof(u_int), 2, fp); fread_float(orig, sizeof(float), 2, fp); fread_float(span, sizeof(float), 2, fp); if (verbose) { printf("dim: %d %d\n", dim[0], dim[1]); printf("orig: %f %f\n", orig[0], orig[1]); printf("span: %f %f\n", span[0], span[1]); } xbits = bitsize(dim[0] - 2); ybits = bitsize(dim[1] - 2); if (xbits == 0) xbits = 1; if (ybits == 0) ybits = 1; yshift = xbits; xmask = (1< #if ! defined (__APPLE__) #include #endif #include #ifndef WIN32 #include #endif #include "seedchkr2.h" #include "datareg2.h" #define DEBUGNo extern int verbose; //------------------------------------------------------------------------ // //------------------------------------------------------------------------ void seedChkr2::compSeeds(void) { Datareg2 ®2 = (Datareg2&)data; int i, j; int xdim, ydim; float val[4]; float min4, max4; int nseed; if (verbose) printf("***** Seed Creation\n"); xdim = reg2.dim[0]; ydim = reg2.dim[1]; // proceed through the slices computing seeds nseed=0; // process the k'th slab for (i=0; igetMin()); } float getMax(int t) const { return(reg2[t]->getMax()); } float getMin() const { return(min[0]); } float getMax() const { return(max[0]); } // add by fan float getMinFun(int j) const { return(min[j]); } float getMaxFun(int j) const { return(max[j]); } Data *getData(int i) { return(reg2[i]); } Datareg2 *getMesh(int i) { return(reg2[i]); } }; //------------------------------------------------------------------------ // // Datasetreg2() - usual constructor, reads data from one or more files // //------------------------------------------------------------------------ inline Datasetreg2::Datasetreg2(Data::DataType t, int nd, int nt, char *fn[]) : Dataset(t, nd, nt, fn) { int i,j; meshtype = 4; reg2 = (Datareg2 **)malloc(sizeof(Datareg2 *)*nt); // allocate memory for min , max min = (float *)malloc(sizeof(float)*nd); max = (float *)malloc(sizeof(float)*nd); for (j = 0; j < nd; j++) { min[j] = 1e10; max[j] = -1e10; } ncells = 0; maxcellindex = 0; for (i=0; igetMin() < min[j]) min[j] = reg2[i]->getMin(); if (reg2[i]->getMax() > max[j]) max[j] = reg2[i]->getMax(); } if (reg2[i]->getNCells() > ncells) ncells = reg2[i]->getNCells(); if (reg2[i]->maxCellIndex() > maxcellindex) maxcellindex = reg2[i]->maxCellIndex(); } } //------------------------------------------------------------------------ // // Datasetreg2() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ inline Datasetreg2::Datasetreg2(Data::DataType t, int ndata, int ntime, int *dim, u_char *data) : Dataset(t, ndata, ntime, data) { int i; // timestep index variable int j; // a variable index int size = 0; // size of single timestep of data meshtype = 4; reg2 = (Datareg2 **)malloc(sizeof(Datareg2 *)*ntime); // allocate memory for min , max min = (float *)malloc(sizeof(float)*ndata); max = (float *)malloc(sizeof(float)*ndata); for (j = 0; j < ndata; j++) { min[j] = 1e10; max[j] = -1e10; } ncells = 0; maxcellindex = 0; switch (t) { case Data::UCHAR : size = dim[0] * dim[1] * ndata * sizeof(u_char); break; case Data::USHORT : size = dim[0] * dim[1] * ndata * sizeof(u_short); break; case Data::FLOAT : size = dim[0] * dim[1] * ndata * sizeof(float); break; } for (i=0; igetMin() < min[j]) min[j] = reg2[i]->getMin(); if (reg2[i]->getMax() > max[j]) max[j] = reg2[i]->getMax(); } if (reg2[i]->getNCells() > ncells) ncells = reg2[i]->getNCells(); if (reg2[i]->maxCellIndex() > maxcellindex) maxcellindex = reg2[i]->maxCellIndex(); } } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/contour.cpp0000644000175000017500000010170211065020741025502 0ustar debiandebian//------------------------------------------------------------------------ // // contour.cpp - isocontouring library implementation // // Copyright (c) 1998 Emilio Camahort // //------------------------------------------------------------------------ // $Id: contour.cpp,v 1.4 2008/09/19 22:04:17 annao Exp $ #include #include #ifndef WIN32 #include #endif #include #include #include "data.h" // basic data and algorithm clases #include "dataset.h" #include "conplot.h" #include "contour.h" #include "conplot2d.h" // isocontouring algorithms and data #include "conplot3d.h" #include "conplotreg2.h" #include "conplotreg3.h" #include "datasetslc.h" // time-varying data set classes #include "datasetvol.h" #include "datasetreg2.h" #include "datasetreg3.h" //------------------------------------------------------------------------ // // defaultHandler() - contour library default error handler // //------------------------------------------------------------------------ void defaultHandler(char *str, int fatal) { if (fatal) { fprintf(stderr, "libcontour: fatal error: %s\n", str); #ifndef WIN32 if (errno) #endif perror("libcontour"); exit(0); } else { fprintf(stderr, "libcontour: error: %s\n", str); #ifndef WIN32 if (errno) #endif perror("libcontour"); } } //------------------------------------------------------------------------ // // verbose, errorHandler - global variables // //------------------------------------------------------------------------ int verbose = 1; // verbose level void (*errorHandler)(char *, int) = defaultHandler; // error handler //------------------------------------------------------------------------ // // setPreprocessing() - display the progress of preprocessing // //------------------------------------------------------------------------ void setPreprocessing(int percent, void *data) { fprintf(stderr, "Preprocessing: %d done\n", percent); } //------------------------------------------------------------------------ // // setVerboseLevel() - set the library's verbose level, default is 1 // //------------------------------------------------------------------------ void setVerboseLevel(int level) { verbose = level; } //------------------------------------------------------------------------ // // setErrorHandler() - set the library's error handler // //------------------------------------------------------------------------ void setErrorHandler(void (*handler)(char *, int)) { errorHandler = handler; } //------------------------------------------------------------------------ // // newDatasetUnstr() - create a new dataset for unstructured data // //------------------------------------------------------------------------ ConDataset *newDatasetUnstr(int datatype, int meshtype, int nvars, int ntime, int nverts, int ncells, double *verts, u_int *cells, int *celladj, u_char *data) { int t; // a timestep index variable int var; // a variable index variable Data::DataType type; // data set parmeters Datasetslc *slc; // different dataset pointers Datasetvol *vol; ConDataset *dataset; type = Data::DataType(datatype); // miscellaneous initializations dataset = new ConDataset; dataset->vnames = NULL; switch (meshtype) // create big objects: data and `plot' { case CONTOUR_2D : dataset->data = slc = new Datasetslc(type, nvars, ntime, nverts, ncells, verts, cells, celladj, data); // create the plot dataset->plot = new Conplot2d(slc); break; case CONTOUR_3D : dataset->data = vol = new Datasetvol(type, nvars, ntime, nverts, ncells, verts, cells, celladj, data); // create the plot dataset->plot = new Conplot3d(vol); break; default : errorHandler("newDatasetUnstr: incorrect mesh type", FALSE); return NULL; }; // allocate and init signature data dataset->sfun = new (Signature**[dataset->data->nData()]); for (var = 0; var < dataset->data->nData(); var++) { dataset->sfun[var] = new (Signature*[dataset->data->nTime()]); for (t = 0; t < dataset->data->nTime(); t++) dataset->sfun[var][t] = NULL; } // check for errors, return if (!dataset->data) { errorHandler("newDatasetUnstr: couldn't create dataset", FALSE); return NULL; } if (!dataset->plot) { errorHandler("newDatasetUnstr: couldn't create plot", FALSE); return NULL; } if (verbose) printf("libcontour:newDatasetUnstr: data set created\n"); return dataset; } //------------------------------------------------------------------------ // // newDatasetReg() - create a new dataset structure for a regular grid // //------------------------------------------------------------------------ ConDataset *newDatasetReg(int datatype, int meshtype, int nvars, int ntime, int *dim, u_char *data) { int t; // a timestep index variable int var; // a variable index variable Data::DataType type; // data set parmeters Datasetreg2 *reg2; // different dataset pointers Datasetreg3 *reg3; ConDataset *dataset; type = Data::DataType(datatype); // miscellaneous initializations dataset = new ConDataset; dataset->vnames = NULL; switch (meshtype) // create big objects: data and `plot' { case CONTOUR_REG_2D : dataset->data = reg2 = new Datasetreg2(type, nvars, ntime, dim, data); // create the plot dataset->plot = new Conplotreg2(reg2); break; case CONTOUR_REG_3D : dataset->data = reg3 = new Datasetreg3(type, nvars, ntime, dim, data); // create the plot dataset->plot = new Conplotreg3(reg3); break; default : errorHandler("newDatasetReg: incorrect mesh type", FALSE); return NULL; }; // allocate and init signature data dataset->sfun = new (Signature**[dataset->data->nData()]); for (var = 0; var < dataset->data->nData(); var++) { dataset->sfun[var] = new (Signature*[dataset->data->nTime()]); for (t = 0; t < dataset->data->nTime(); t++) dataset->sfun[var][t] = NULL; } // check for errors, return if (!dataset->data) { errorHandler("newDatasetReg: couldn't create dataset", FALSE); return NULL; } if (!dataset->plot) { errorHandler("newDatasetReg: couldn't create plot", FALSE); return NULL; } if (verbose) printf("libcontour:newDatasetReg: data set created\n"); return dataset; } //------------------------------------------------------------------------ // // loadDataset() - load data set from disk // //------------------------------------------------------------------------ ConDataset *loadDataset(int datatype, int meshtype, int nvars, int ntime, char **files) { int i; // a variable name index variable int t; // a timestep index variable int var; // a variable index variable FILE *vnfd; // variable name file descriptor char filename[256]; // variable name file name Data::DataType type; // data set parmeters Datasetslc *slc; // different dataset pointers Datasetvol *vol; Datasetreg2 *reg2; Datasetreg3 *reg3; ConDataset *dataset; type = Data::DataType(datatype); // miscellaneous initializations dataset = new ConDataset; switch (meshtype) // create big objects: data and `plot' { case CONTOUR_2D : dataset->data = slc = new Datasetslc(type, nvars, ntime, files); // create the plot dataset->plot = new Conplot2d(slc); break; case CONTOUR_3D : dataset->data = vol = new Datasetvol(type, nvars, ntime, files); // create the plot dataset->plot = new Conplot3d(vol); break; case CONTOUR_REG_2D : dataset->data = reg2 = new Datasetreg2(type, nvars, ntime, files); // create the plot dataset->plot = new Conplotreg2(reg2); break; case CONTOUR_REG_3D : dataset->data = reg3 = new Datasetreg3(type, nvars, ntime, files); // create the plot dataset->plot = new Conplotreg3(reg3); break; default : errorHandler("loadDataset: incorrect mesh type", FALSE); return NULL; }; // read variable name file strcpy(filename, files[0]); strcpy(strrchr(filename, int('.')), ".var"); vnfd = fopen(filename, "r"); // open file if (vnfd) { dataset->vnames = new char*[nvars]; // allocate memory to names for (i = 0; i < nvars; i++) { // read variable names dataset->vnames[i] = new char[80]; fgets(dataset->vnames[i], 80, vnfd); dataset->vnames[i][strlen(dataset->vnames[i])-1] = 0; } fclose(vnfd); } else // no variable names available dataset->vnames = NULL; // allocate and init signature data dataset->sfun = new (Signature**[dataset->data->nData()]); for (var = 0; var < dataset->data->nData(); var++) { dataset->sfun[var] = new (Signature*[dataset->data->nTime()]); for (t = 0; t < dataset->data->nTime(); t++) dataset->sfun[var][t] = NULL; } // check for errors, return if (!dataset->data) { errorHandler("loadDataset: couldn't create dataset", FALSE); return NULL; } if (!dataset->plot) { errorHandler("loadDataset: couldn't create plot", FALSE); return NULL; } if (verbose) printf("libcontour:loadDataset: Data set loaded\n"); return dataset; } //------------------------------------------------------------------------ // // getVariableNames() - get variable names for multi-variate data // //------------------------------------------------------------------------ char **getVariableNames(ConDataset *dataset) { if (!dataset) { errorHandler("getVariableNames: invalid dataset", FALSE); return NULL; } return dataset->vnames; } //------------------------------------------------------------------------ // // getDatasetInfo() - get the dataset's basic information // //------------------------------------------------------------------------ DatasetInfo *getDatasetInfo(ConDataset *dataset) { int var; // a variable index DatasetInfo *datainfo; // pointer to dataset's information if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getDatasetInfo: invalid dataset", FALSE); return NULL; } datainfo = new DatasetInfo; datainfo->datatype = int(dataset->data->dataType()); datainfo->meshtype = dataset->data->meshType(); datainfo->nvars = dataset->data->nData(); datainfo->ntime = dataset->data->nTime(); memset(datainfo->dim, 0, 3 * sizeof(u_int)); memset(datainfo->orig, 0, 3 * sizeof(float)); memset(datainfo->span, 0, 3 * sizeof(float)); switch (dataset->data->meshType()) // not very orthodox, but ... { case CONTOUR_REG_2D : ((Datareg2 *)dataset->data->getData(0))->getDim( datainfo->dim); ((Datareg2 *)dataset->data->getData(0))->getOrig(datainfo->orig); ((Datareg2 *)dataset->data->getData(0))->getSpan(datainfo->span); break; case CONTOUR_REG_3D : ((Datareg3 *)dataset->data->getData(0))->getDim( datainfo->dim); ((Datareg3 *)dataset->data->getData(0))->getOrig(datainfo->orig); ((Datareg3 *)dataset->data->getData(0))->getSpan(datainfo->span); break; default : break; } dataset->data->getData(0)->getExtent(datainfo->minext, datainfo->maxext); datainfo->minvar = new float[dataset->data->nData()]; datainfo->maxvar = new float[dataset->data->nData()]; for (var = 0; var < dataset->data->nData(); var++) { datainfo->minvar[var] = dataset->data->getMinFun(var); datainfo->maxvar[var] = dataset->data->getMaxFun(var); } return datainfo; } //------------------------------------------------------------------------ // // getSeedCells() - get seed cell data // //------------------------------------------------------------------------ SeedData *getSeedCells(ConDataset *dataset, int variable, int timestep) { SeedData *seeddata; // pointer to seed data structure // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getSeedCells: Couldn't find dataset", FALSE); return NULL; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("getSeedCells: variable out of range", FALSE); return NULL; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("getSeedCells: timestep out of range", FALSE); return NULL; } // extract seeds seeddata = new SeedData; dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); dataset->plot->setTime(timestep); // determine if seeds computed if (dataset->plot->getSeeds()->getNCells() == 0) dataset->plot->Preprocess(timestep, setPreprocessing, NULL); seeddata->nseeds = dataset->plot->getSeeds()->getNCells(); seeddata->seeds = (Seed *)dataset->plot->getSeeds()->getCellPointer(); if (verbose > 1) for (int i = 0; i < seeddata->nseeds; i++) printf("seed cell %d --> min = %f max = %f id = %d\n", i, seeddata->seeds[i].min, seeddata->seeds[i].max, seeddata->seeds[i].cell_id); if (verbose) printf("libcontour:getSeedCells: seed data extracted\n"); return seeddata; } //------------------------------------------------------------------------ // // getNumberOfSignatures() - get number of signature functions // //------------------------------------------------------------------------ int getNumberOfSignatures(ConDataset *dataset) { if (!dataset) { errorHandler("getNumberOfSignatures: invalid dataset", FALSE); return -1; } return dataset->data->getData(0)->getNFunctions(); } //------------------------------------------------------------------------ // // getSignatureFunctions() - get signature functions // //------------------------------------------------------------------------ Signature *getSignatureFunctions(ConDataset *dataset, int variable, int timestep) { int t; // a timestep index variable int fun; // signature function index // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getSignatureFunctions: Couldn't find dataset", FALSE); return NULL; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("getSignatureFunctions: variable out of range", FALSE); return NULL; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("getSignatureFunctions: timestep out of range", FALSE); return NULL; } // obtain signature functions dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); dataset->plot->setTime(timestep); // compute signature functions if (verbose) printf("libcontour: computing signature functions ...\n"); dataset->nsfun = dataset->data->getData(0)->getNFunctions(); #ifdef COMPUTE_FUNCTIONS_FOR_ALL_TIMES for (t = 0; t < dataset->data->nTime(); t++) // per time step t { dataset->sfun[variable][t] = new Signature[dataset->nsfun]; for (fun = 0; fun < dataset->nsfun; fun++) { dataset->sfun[variable][t][fun].name = strdup(dataset->data->getData(0)->fName(fun)); dataset->sfun[variable][t][fun].fy = dataset->data->getData(t)->compFunction(fun, dataset->sfun[variable][t][fun].nval, &dataset->sfun[variable][t][fun].fx); } } #endif /* of COMPUTE_FUNCTIONS_FOR_ALL_TIMES */ if (!dataset->sfun[variable][timestep]) // have signatures already? { t = timestep; dataset->sfun[variable][t] = new Signature[dataset->nsfun]; for (fun = 0; fun < dataset->nsfun; fun++) { dataset->sfun[variable][t][fun].name = strdup(dataset->data->getData(0)->fName(fun)); dataset->sfun[variable][t][fun].fy = dataset->data->getData(t)->compFunction(fun, dataset->sfun[variable][t][fun].nval, &dataset->sfun[variable][t][fun].fx); } } //sfundata.minvalue = data[id]->getMinFun(variable); //sfundata.maxvalue = data[id]->getMaxFun(variable); if (verbose) printf("libcontour::getSignatureData: signature data computed \n"); return dataset->sfun[variable][timestep]; } //------------------------------------------------------------------------ // // getSignatureValues() - get signature values for isovalue // //------------------------------------------------------------------------ float *getSignatureValues(ConDataset *dataset, int variable, int timestep, float isovalue) { int t; // a timestep index variable int fun; // signature function index float *svalues; // signature values // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getSignatureValues: Couldn't find dataset", FALSE); return NULL; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("getSignatureValues: variable out of range", FALSE); return NULL; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("getSignatureValues: timestep out of range", FALSE); return NULL; } // obtain signature values dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); dataset->plot->setTime(timestep); dataset->nsfun = dataset->data->getData(0)->getNFunctions(); // do we have signatures for timestep? if (!dataset->sfun[variable][timestep]) { t = timestep; dataset->sfun[variable][t] = new Signature[dataset->nsfun]; for (fun = 0; fun < dataset->nsfun; fun++) { dataset->sfun[variable][t][fun].name = strdup(dataset->data->getData(0)->fName(fun)); dataset->sfun[variable][t][fun].fy = dataset->data->getData(t)->compFunction(fun, dataset->sfun[variable][t][fun].nval, &dataset->sfun[variable][t][fun].fx); } } svalues = new float[dataset->nsfun]; for (fun = 0; fun < dataset->nsfun; fun++) { int l, r, m; // binary search from SIoXtSpectrum.h m = 0; l = 0; r = dataset->sfun[variable][timestep][fun].nval; while (l < r) { m = (l + r) >> 1; if (isovalue < dataset->sfun[variable][timestep][fun].fx[m]) r = m - 1; else l = m + 1; } svalues[fun] = dataset->sfun[variable][timestep][fun].fy[m]; if (verbose > 1) printf("function %d %s\t --> %d values: (55, %f)\n", fun, dataset->sfun[variable][timestep][fun].name, dataset->sfun[variable][timestep][fun].nval, dataset->sfun[variable][timestep][fun].fy[55]); } if (verbose) printf("libcontour:getSignatureValues: signature values computed\n"); return svalues; } //------------------------------------------------------------------------ // // getSlice() - extract a 2d slice from a 3d regular data grid // //------------------------------------------------------------------------ SliceData *getSlice(ConDataset *dataset, int variable, int timestep, char axis, u_int index) { u_int dim[3]; // dataset dimensions SliceData *slice; // slice data Data::datatypes buffer; // buffer to hold actual slice // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getSlice: Couldn't find dataset", FALSE); return NULL; } if (dataset->data->meshType() != CONTOUR_REG_3D) { errorHandler("getSlice: invalid mesh type: must be 3D regular", FALSE); return NULL; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("getSlice: variable out of range", FALSE); return NULL; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("getSlice: timestep out of range", FALSE); return NULL; } if (axis != 'x' && axis != 'y' && axis != 'z') { errorHandler("getSlice: invalid slice axis", FALSE); return NULL; } slice = new SliceData; ((Datareg3 *)dataset->data->getData(0))->getDim(dim); // check index range and switch (axis) // determine width and height { case 'x' : if (index >= dim[0]) { errorHandler("getSlice: x-index out of range", FALSE); return NULL; } else { slice->width = dim[1]; slice->height = dim[2]; } break; case 'y' : if (index >= dim[1]) { errorHandler("getSlice: y-index out of range", FALSE); return NULL; } else { slice->width = dim[2]; slice->height = dim[0]; } break; case 'z' : if (index >= dim[2]) { errorHandler("getSlice: z-index out of range", FALSE); return NULL; } else { slice->width = dim[0]; slice->height = dim[1]; } break; } dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); dataset->plot->setTime(timestep); slice->datatype = int(dataset->data->dataType()); // allocate memory for slice switch (slice->datatype) { case CONTOUR_UCHAR : buffer.ucdata = new u_char[slice->width * slice->height]; break; case CONTOUR_USHORT : buffer.usdata = new u_short[slice->width * slice->height]; break; case CONTOUR_FLOAT : buffer.fdata = new float[slice->width * slice->height]; break; } // extract slice from dataset if (((Datareg3 *)dataset->data->getData(timestep))->getSlice( variable, axis, index, &buffer)) { errorHandler("Datareg3::getSlice(): Couldn't extract slice", FALSE); return NULL; } // // void getSlice(int variable, char axis, int index, // Data::datatypes *buffer) if (verbose) printf("libcontour::extractSlice: slice %d along axis %c \n", index, axis); switch (slice->datatype) // assign buffer to slice data { case CONTOUR_UCHAR : slice->ucdata = buffer.ucdata; break; case CONTOUR_USHORT : slice->usdata = buffer.usdata; break; case CONTOUR_FLOAT : slice->fdata = buffer.fdata; break; } if (verbose) printf("libcontour::extractSlice: slice extracted\n"); return slice; } //------------------------------------------------------------------------ // // getContour2d() - extract a 2d isocontour from a 2d data set // //------------------------------------------------------------------------ Contour2dData *getContour2d(ConDataset *dataset, int variable, int timestep, float isovalue) { Contour2d *isocontour; // new isocontour Contour2dData *contour2d; // 2d isocontour data structure // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getContour2d: Couldn't find dataset", FALSE); return NULL; } if (dataset->data->meshType() != CONTOUR_2D && dataset->data->meshType() != CONTOUR_REG_2D) { errorHandler("getContour2d: invalid mesh type: must be 2D", FALSE); return NULL; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("getContour2d: variable out of range", FALSE); return NULL; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("getContour2d: timestep out of range", FALSE); return NULL; } dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); --> should depend on dataset dataset->plot->setTime(timestep); contour2d = new Contour2dData; if (verbose) printf("libcontour:getContour2d: isovalue = %f\n", isovalue); // determine if seeds computed if (dataset->plot->getSeeds()->getNCells() == 0) dataset->plot->Preprocess(timestep, setPreprocessing, NULL); // extract isocontour dataset->plot->ResetAll(); dataset->plot->Extract(isovalue); isocontour = dataset->plot->getContour2d(); contour2d->nvert = isocontour->getNVert(); contour2d->nedge = isocontour->getNEdge(); contour2d->vert = isocontour->vert; contour2d->edge = isocontour->edge; if (verbose) { printf("libcontour:getContour2d: nr of vertices: %d\n", contour2d->nvert); printf("libcontour:getContour2d: nr of edges: %d\n", contour2d->nedge); } return contour2d; } //------------------------------------------------------------------------ // // getContour3d() - extract a 3d isocontour from a 3d data set // //------------------------------------------------------------------------ Contour3dData *getContour3d(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar) { Contour3d *isocontour; // new isocontour Contour3dData *contour3d; // 3d isocontour data structure // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("getContour3d: Couldn't find dataset", FALSE); return NULL; } if (dataset->data->meshType() != CONTOUR_3D && dataset->data->meshType() != CONTOUR_REG_3D) { errorHandler("getContour3d: invalid mesh type: must be 3D", FALSE); return NULL; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("getContour3d: variable out of range", FALSE); return NULL; } if (colorvar != NO_COLOR_VARIABLE) if (colorvar < 0 || colorvar >= dataset->data->nData()) { errorHandler("getContour3d: invalid color variable", FALSE); return NULL; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("getContour3d: timestep out of range", FALSE); return NULL; } dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); --> should depend on dataset dataset->data->getData(timestep)->setColorFun(colorvar); //plot[id]->setColorFun(colorvar, timestep); //Conplot::setColorFun(colorvar); --> should depend on dataset dataset->plot->setTime(timestep); contour3d = new Contour3dData; if (verbose) printf("libcontour::getContour3d: isovalue = %f\n", isovalue); // determine if seeds computed if (dataset->plot->getSeeds()->getNCells() == 0) dataset->plot->Preprocess(timestep, setPreprocessing, NULL); // extract isocontour dataset->plot->ResetAll(); dataset->plot->Extract(isovalue); isocontour = dataset->plot->getContour3d(); contour3d->nvert = isocontour->getNVert(); contour3d->ntri = isocontour->getNTri(); contour3d->vert = isocontour->vert; contour3d->vnorm = isocontour->vnorm; contour3d->vfun = isocontour->vfun; contour3d->tri = isocontour->tri; contour3d->colorvar = colorvar; contour3d->fmin = isocontour->fmin; contour3d->fmax = isocontour->fmax; return contour3d; } //------------------------------------------------------------------------ // // saveContour2d() - extract a 2d isocontour and save it to a file // //------------------------------------------------------------------------ void saveContour2d(ConDataset *dataset, int variable, int timestep, float isovalue, char *filename) { // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("saveContour2d: Couldn't find dataset", FALSE); return; } if (dataset->data->meshType() != CONTOUR_2D && dataset->data->meshType() != CONTOUR_REG_2D) { errorHandler("saveContour2d: invalid mesh type: must be 2D", FALSE); return; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("saveContour2d: variable out of range", FALSE); return; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("saveContour2d: timestep out of range", FALSE); return; } dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); --> should depend on dataset dataset->plot->setTime(timestep); if (verbose) printf("libcontour:saveContour2d: isovalue = %f\n", isovalue); // determine if seeds computed if (dataset->plot->getSeeds()->getNCells() == 0) dataset->plot->Preprocess(timestep, setPreprocessing, NULL); // extract isocontour dataset->plot->ResetAll(); dataset->plot->Extract(isovalue); // save contour to iPoly file if (dataset->plot->getContour2d()->write(filename)) { char str[256]; sprintf(str, "saveContour2d: couldn't save to file: %s\n", filename); errorHandler(str, FALSE); } else if (verbose) fprintf(stderr, "libcontour:saveContour2d: saved to: %s\n", filename); } //------------------------------------------------------------------------ // // saveContour3d() - extract a 3d isocontour and save it to a file // //------------------------------------------------------------------------ void saveContour3d(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar, char *filename) { // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("saveContour3d: Couldn't find dataset", FALSE); return; } if (dataset->data->meshType() != CONTOUR_3D && dataset->data->meshType() != CONTOUR_REG_3D) { errorHandler("saveContour3d: invalid mesh type: must be 3D", FALSE); return; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("saveContour3d: variable out of range", FALSE); return; } if (colorvar != NO_COLOR_VARIABLE) if (colorvar < 0 || colorvar >= dataset->data->nData()) { errorHandler("saveContour3d: invalid color variable", FALSE); return; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("saveContour3d: timestep out of range", FALSE); return; } dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); --> should depend on dataset dataset->data->getData(timestep)->setColorFun(colorvar); //plot[id]->setColorFun(colorvar, timestep); //Conplot::setColorFun(colorvar); --> should depend on dataset dataset->plot->setTime(timestep); if (verbose) printf("libcontour::saveContour3d: isovalue = %f\n", isovalue); // determine if seeds computed if (dataset->plot->getSeeds()->getNCells() == 0) dataset->plot->Preprocess(timestep, setPreprocessing, NULL); // extract isocontour dataset->plot->ResetAll(); dataset->plot->Extract(isovalue); // save contour to iPoly file if (dataset->plot->getContour3d()->write(filename)) { char str[256]; sprintf(str, "saveContour3d: couldn't save to file: %s\n", filename); errorHandler(str, FALSE); } else if (verbose) fprintf(stderr, "libcontour:saveContour3d: saved to: %s\n", filename); } //------------------------------------------------------------------------ // // writeIsoComponents() - extract and write isocontour components to disk // //------------------------------------------------------------------------ void writeIsoComponents(ConDataset *dataset, int variable, int timestep, float isovalue, int colorvar, char *fprefix) { // sanity checks if (!dataset || !dataset->data || !dataset->plot) { errorHandler("writeIsoComponents: Couldn't find dataset", FALSE); return; } if (variable < 0 || variable >= dataset->data->nData()) { errorHandler("writeIsoComponents: variable out of range", FALSE); return; } if (colorvar != NO_COLOR_VARIABLE) if (colorvar < 0 || colorvar >= dataset->data->nData()) { errorHandler("writeIsoComponents: invalid color variable", FALSE); return; } if (timestep < 0 || timestep >= dataset->data->nTime()) { errorHandler("writeIsoComponents: timestep out of range", FALSE); return; } dataset->data->getData(timestep)->setContourFun(variable); //plot[id]->setContourFun(variable, timestep); //Conplot::setContourFun(variable); --> should depend on dataset dataset->data->getData(timestep)->setColorFun(colorvar); //plot[id]->setColorFun(colorvar, timestep); //Conplot::setColorFun(colorvar); --> should depend on dataset dataset->plot->setTime(timestep); if (verbose) printf("libcontour::writeIsoComponents: isovalue = %f\n", isovalue); // determine if seeds computed if (dataset->plot->getSeeds()->getNCells() == 0) dataset->plot->Preprocess(timestep, setPreprocessing, NULL); // extract isocontour dataset->plot->ResetAll(); dataset->plot->BeginWrite(fprefix); dataset->plot->Extract(isovalue); dataset->plot->EndWrite(); if (verbose) printf("libcontour:writeIsoComponents: components saved\n"); } //------------------------------------------------------------------------ // // clearDataset() - clear (remove) dataset from memory // //------------------------------------------------------------------------ void clearDataset(ConDataset *dataset) { int t; // timestep index variable int v; // variable index variable if (dataset == NULL) return; if (dataset->data && dataset->plot) // sanity check { for (v = 0; v < dataset->data->nData(); v++) // delete signatures { for (t = 0; t < dataset->data->nTime(); t++) if (dataset->sfun[v][t]) delete [] dataset->sfun[v][t]; delete [] dataset->sfun[v]; } delete [] dataset->sfun; delete dataset->data; // delete data, set to NULL delete dataset->plot; } } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/squeue.h0000644000175000017500000000334710267550241025001 0ustar debiandebian/*****************************************************************************\ * * squeue.h -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: squeue.h,v 1.2 2005/07/20 22:30:57 annao Exp $ #ifndef __SQUEUE_H #define __SQUEUE_H #include "queue.h" //@ManMemo: A templated FIFO queue /*@Doc: Implementation of a FIFO queue based on a circular array. Memory is allocated in blocks, given as a parameter when the object is created, or if no parameter is given, using the default block size. Note: Currently, when a new block of memory is allocated, all of the current SQueue is recopied (because it is circular you cannot just increase the array size), so use caution when picking the block size. */ template class SQueue : public Queue { public: //@ManDoc: Constructor with user define block size. SQueue(int blocksize=0); //@ManDoc: Destructor. virtual ~SQueue(); int find(T&); private: }; /*****************************************************************************\ * inline functions \*****************************************************************************/ template inline SQueue< T >::SQueue(int blocksize) : Queue(blocksize) { } template inline SQueue< T >::~SQueue() { } template inline int SQueue< T >::find(T&e) { int i, j; for ( j = Queue< T >::head, i = 0; i < Queue< T >::length; i++ ) { if (Queue< T >::q[j] == e) return(j); j++; if( j == Queue< T >::room ) { j = 0; } } return(-1); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedall.h0000644000175000017500000000065610064121655025101 0ustar debiandebian // $Id: seedall.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef SEED_ALL_H #define SEED_ALL_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class seedAll { public: seedAll(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~seedAll() {} void compSeeds(void); private: Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/libcontour.pro0000644000175000017500000000337210352633120026212 0ustar debiandebian# General settings TEMPLATE = lib CONFIG += warn_off staticlib create_prl TARGET += contour DEFINES += _BOOL SP2 USEDICT NDEBUG # Don't define _LITTLE_ENDIAN on MacOS X (it's big endian) !macx { DEFINES += _LITTLE_ENDIAN } else { DEFINES += MACOS_X } # Input SOURCES = \ bin.cpp \ contour.cpp \ inttree.cpp \ seedall.cpp \ bucketsearch.cpp \ cubes.cpp \ ipqueue.cpp \ seedcells.cpp \ cellqueue.cpp \ data.cpp \ iqueue.cpp \ seedchkr2.cpp \ conplot2d.cpp \ datareg2.cpp \ seedchkr3.cpp \ conplot3d.cpp \ datareg3.cpp \ queue.cpp \ seeddirreg3.cpp \ conplot.cpp \ dataslc.cpp \ range.cpp \ segtree.cpp \ conplot_p.cpp \ datavol.cpp \ rangeprop.cpp \ shelf.cpp \ conplotreg2.cpp \ dirseeds.cpp \ rangesweep.cpp \ spectrumtest.cpp \ conplotreg3.cpp \ dirseedsreg2.cpp \ regprop2.cpp \ squeue.cpp \ contour2d.cpp \ edgehash.cpp \ regprop.cpp \ contour3d.cpp \ hash.cpp \ respprop2.cpp \ dict.c HEADERS = \ basic.h \ contour3d.h \ dirseeds.h \ regprop.h \ bin.h \ contour.h \ dirseedsreg2.h \ respprop2.h \ bucketsearch.h \ cubes.h \ edgehash.h \ seedall.h \ cellqueue.h \ data.h \ endian_io.h \ seedcells.h \ cellsearch.h \ datareg2.h \ hash.h \ seedchkr2.h \ commdata.h \ datareg3.h \ inttree.h \ seedchkr3.h \ compute.h \ dataset.h \ ipqueue.h \ seeddirreg3.h \ conplot2d.h \ datasetreg2.h \ iqueue.h \ segtree.h \ conplot3d.h \ datasetreg3.h \ queue.h \ shelf.h \ conplot.h \ datasetslc.h \ range.h \ squeue.h \ conplotreg2.h \ datasetvol.h \ rangeprop.h \ utilities.h \ conplotreg3.h \ dataslc.h \ rangesweep.h \ vtkmarchingcubescases.h \ contour2d.h \ datavol.h \ regprop2.h \ dict.h mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/vtkmarchingcubescases.h0000644000175000017500000004507110064121655030046 0ustar debiandebian // $Id: vtkmarchingcubescases.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ // // marching cubes case table for generating isosurfaces // typedef int EDGE_LIST; typedef struct { EDGE_LIST edges[16]; } TRIANGLE_CASES; // // Edges to intersect. Three at a time form a triangle. Comments at end of line // indicate case number (0->255) and base case number (0->15). // static TRIANGLE_CASES triCases[] = { {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 0 0 */ {{ 0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 1 1 */ {{ 0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 2 1 */ {{ 1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 3 2 */ {{ 1, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 4 1 */ {{ 0, 3, 8, 1, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 5 3 */ {{ 9, 11, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 6 2 */ {{ 2, 3, 8, 2, 8, 11, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 7 5 */ {{ 3, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 8 1 */ {{ 0, 2, 10, 8, 0, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 9 2 */ {{ 1, 0, 9, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 10 3 */ {{ 1, 2, 10, 1, 10, 9, 9, 10, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 11 5 */ {{ 3, 1, 11, 10, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 12 2 */ {{ 0, 1, 11, 0, 11, 8, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 13 5 */ {{ 3, 0, 9, 3, 9, 10, 10, 9, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 14 5 */ {{ 9, 11, 8, 11, 10, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 15 8 */ {{ 4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 16 1 */ {{ 4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 17 2 */ {{ 0, 9, 1, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 18 3 */ {{ 4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 19 5 */ {{ 1, 11, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 20 4 */ {{ 3, 7, 4, 3, 4, 0, 1, 11, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 21 7 */ {{ 9, 11, 2, 9, 2, 0, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 22 7 */ {{ 2, 9, 11, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1}}, /* 23 14 */ {{ 8, 7, 4, 3, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 24 3 */ {{10, 7, 4, 10, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 25 5 */ {{ 9, 1, 0, 8, 7, 4, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 26 6 */ {{ 4, 10, 7, 9, 10, 4, 9, 2, 10, 9, 1, 2, -1, -1, -1, -1}}, /* 27 9 */ {{ 3, 1, 11, 3, 11, 10, 7, 4, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 28 7 */ {{ 1, 11, 10, 1, 10, 4, 1, 4, 0, 7, 4, 10, -1, -1, -1, -1}}, /* 29 11 */ {{ 4, 8, 7, 9, 10, 0, 9, 11, 10, 10, 3, 0, -1, -1, -1, -1}}, /* 30 12 */ {{ 4, 10, 7, 4, 9, 10, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 31 5 */ {{ 9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 32 1 */ {{ 9, 4, 5, 0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 33 3 */ {{ 0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 34 2 */ {{ 8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 35 5 */ {{ 1, 11, 2, 9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 36 3 */ {{ 3, 8, 0, 1, 11, 2, 4, 5, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 37 6 */ {{ 5, 11, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 38 5 */ {{ 2, 5, 11, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1}}, /* 39 9 */ {{ 9, 4, 5, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 40 4 */ {{ 0, 2, 10, 0, 10, 8, 4, 5, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 41 7 */ {{ 0, 4, 5, 0, 5, 1, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 42 7 */ {{ 2, 5, 1, 2, 8, 5, 2, 10, 8, 4, 5, 8, -1, -1, -1, -1}}, /* 43 11 */ {{11, 10, 3, 11, 3, 1, 9, 4, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 44 7 */ {{ 4, 5, 9, 0, 1, 8, 8, 1, 11, 8, 11, 10, -1, -1, -1, -1}}, /* 45 12 */ {{ 5, 0, 4, 5, 10, 0, 5, 11, 10, 10, 3, 0, -1, -1, -1, -1}}, /* 46 14 */ {{ 5, 8, 4, 5, 11, 8, 11, 10, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 47 5 */ {{ 9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 48 2 */ {{ 9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 49 5 */ {{ 0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 50 5 */ {{ 1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 51 8 */ {{ 9, 8, 7, 9, 7, 5, 11, 2, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 52 7 */ {{11, 2, 1, 9, 0, 5, 5, 0, 3, 5, 3, 7, -1, -1, -1, -1}}, /* 53 12 */ {{ 8, 2, 0, 8, 5, 2, 8, 7, 5, 11, 2, 5, -1, -1, -1, -1}}, /* 54 11 */ {{ 2, 5, 11, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 55 5 */ {{ 7, 5, 9, 7, 9, 8, 3, 2, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 56 7 */ {{ 9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 10, 7, -1, -1, -1, -1}}, /* 57 14 */ {{ 2, 10, 3, 0, 8, 1, 1, 8, 7, 1, 7, 5, -1, -1, -1, -1}}, /* 58 12 */ {{10, 1, 2, 10, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 59 5 */ {{ 9, 8, 5, 8, 7, 5, 11, 3, 1, 11, 10, 3, -1, -1, -1, -1}}, /* 60 10 */ {{ 5, 0, 7, 5, 9, 0, 7, 0, 10, 1, 11, 0, 10, 0, 11, -1}}, /* 61 7 */ {{10, 0, 11, 10, 3, 0, 11, 0, 5, 8, 7, 0, 5, 0, 7, -1}}, /* 62 7 */ {{10, 5, 11, 7, 5, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 63 2 */ {{11, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 64 1 */ {{ 0, 3, 8, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 65 4 */ {{ 9, 1, 0, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 66 3 */ {{ 1, 3, 8, 1, 8, 9, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 67 7 */ {{ 1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 68 2 */ {{ 1, 5, 6, 1, 6, 2, 3, 8, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 69 7 */ {{ 9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 70 5 */ {{ 5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1}}, /* 71 11 */ {{ 2, 10, 3, 11, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 72 3 */ {{10, 8, 0, 10, 0, 2, 11, 5, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 73 7 */ {{ 0, 9, 1, 2, 10, 3, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 74 6 */ {{ 5, 6, 11, 1, 2, 9, 9, 2, 10, 9, 10, 8, -1, -1, -1, -1}}, /* 75 12 */ {{ 6, 10, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 76 5 */ {{ 0, 10, 8, 0, 5, 10, 0, 1, 5, 5, 6, 10, -1, -1, -1, -1}}, /* 77 14 */ {{ 3, 6, 10, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1}}, /* 78 9 */ {{ 6, 9, 5, 6, 10, 9, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 79 5 */ {{ 5, 6, 11, 4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 80 3 */ {{ 4, 0, 3, 4, 3, 7, 6, 11, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 81 7 */ {{ 1, 0, 9, 5, 6, 11, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 82 6 */ {{11, 5, 6, 1, 7, 9, 1, 3, 7, 7, 4, 9, -1, -1, -1, -1}}, /* 83 12 */ {{ 6, 2, 1, 6, 1, 5, 4, 8, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 84 7 */ {{ 1, 5, 2, 5, 6, 2, 3, 4, 0, 3, 7, 4, -1, -1, -1, -1}}, /* 85 10 */ {{ 8, 7, 4, 9, 5, 0, 0, 5, 6, 0, 6, 2, -1, -1, -1, -1}}, /* 86 12 */ {{ 7, 9, 3, 7, 4, 9, 3, 9, 2, 5, 6, 9, 2, 9, 6, -1}}, /* 87 7 */ {{ 3, 2, 10, 7, 4, 8, 11, 5, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 88 6 */ {{ 5, 6, 11, 4, 2, 7, 4, 0, 2, 2, 10, 7, -1, -1, -1, -1}}, /* 89 12 */ {{ 0, 9, 1, 4, 8, 7, 2, 10, 3, 5, 6, 11, -1, -1, -1, -1}}, /* 90 13 */ {{ 9, 1, 2, 9, 2, 10, 9, 10, 4, 7, 4, 10, 5, 6, 11, -1}}, /* 91 6 */ {{ 8, 7, 4, 3, 5, 10, 3, 1, 5, 5, 6, 10, -1, -1, -1, -1}}, /* 92 12 */ {{ 5, 10, 1, 5, 6, 10, 1, 10, 0, 7, 4, 10, 0, 10, 4, -1}}, /* 93 7 */ {{ 0, 9, 5, 0, 5, 6, 0, 6, 3, 10, 3, 6, 8, 7, 4, -1}}, /* 94 6 */ {{ 6, 9, 5, 6, 10, 9, 4, 9, 7, 7, 9, 10, -1, -1, -1, -1}}, /* 95 3 */ {{11, 9, 4, 6, 11, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 96 2 */ {{ 4, 6, 11, 4, 11, 9, 0, 3, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 97 7 */ {{11, 1, 0, 11, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 98 5 */ {{ 8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 11, 1, -1, -1, -1, -1}}, /* 99 14 */ {{ 1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 100 5 */ {{ 3, 8, 0, 1, 9, 2, 2, 9, 4, 2, 4, 6, -1, -1, -1, -1}}, /* 101 12 */ {{ 0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 102 8 */ {{ 8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 103 5 */ {{11, 9, 4, 11, 4, 6, 10, 3, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 104 7 */ {{ 0, 2, 8, 2, 10, 8, 4, 11, 9, 4, 6, 11, -1, -1, -1, -1}}, /* 105 10 */ {{ 3, 2, 10, 0, 6, 1, 0, 4, 6, 6, 11, 1, -1, -1, -1, -1}}, /* 106 12 */ {{ 6, 1, 4, 6, 11, 1, 4, 1, 8, 2, 10, 1, 8, 1, 10, -1}}, /* 107 7 */ {{ 9, 4, 6, 9, 6, 3, 9, 3, 1, 10, 3, 6, -1, -1, -1, -1}}, /* 108 11 */ {{ 8, 1, 10, 8, 0, 1, 10, 1, 6, 9, 4, 1, 6, 1, 4, -1}}, /* 109 7 */ {{ 3, 6, 10, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 110 5 */ {{ 6, 8, 4, 10, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 111 2 */ {{ 7, 6, 11, 7, 11, 8, 8, 11, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 112 5 */ {{ 0, 3, 7, 0, 7, 11, 0, 11, 9, 6, 11, 7, -1, -1, -1, -1}}, /* 113 11 */ {{11, 7, 6, 1, 7, 11, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1}}, /* 114 9 */ {{11, 7, 6, 11, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 115 5 */ {{ 1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1}}, /* 116 14 */ {{ 2, 9, 6, 2, 1, 9, 6, 9, 7, 0, 3, 9, 7, 9, 3, -1}}, /* 117 7 */ {{ 7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 118 5 */ {{ 7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 119 2 */ {{ 2, 10, 3, 11, 8, 6, 11, 9, 8, 8, 7, 6, -1, -1, -1, -1}}, /* 120 12 */ {{ 2, 7, 0, 2, 10, 7, 0, 7, 9, 6, 11, 7, 9, 7, 11, -1}}, /* 121 7 */ {{ 1, 0, 8, 1, 8, 7, 1, 7, 11, 6, 11, 7, 2, 10, 3, -1}}, /* 122 6 */ {{10, 1, 2, 10, 7, 1, 11, 1, 6, 6, 1, 7, -1, -1, -1, -1}}, /* 123 3 */ {{ 8, 6, 9, 8, 7, 6, 9, 6, 1, 10, 3, 6, 1, 6, 3, -1}}, /* 124 7 */ {{ 0, 1, 9, 10, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 125 4 */ {{ 7, 0, 8, 7, 6, 0, 3, 0, 10, 10, 0, 6, -1, -1, -1, -1}}, /* 126 3 */ {{ 7, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 127 1 */ {{ 7, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 128 1 */ {{ 3, 8, 0, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 129 3 */ {{ 0, 9, 1, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 130 4 */ {{ 8, 9, 1, 8, 1, 3, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 131 7 */ {{11, 2, 1, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 132 3 */ {{ 1, 11, 2, 3, 8, 0, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 133 6 */ {{ 2, 0, 9, 2, 9, 11, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 134 7 */ {{ 6, 7, 10, 2, 3, 11, 11, 3, 8, 11, 8, 9, -1, -1, -1, -1}}, /* 135 12 */ {{ 7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 136 2 */ {{ 7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 137 5 */ {{ 2, 6, 7, 2, 7, 3, 0, 9, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 138 7 */ {{ 1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1}}, /* 139 14 */ {{11, 6, 7, 11, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 140 5 */ {{11, 6, 7, 1, 11, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1}}, /* 141 9 */ {{ 0, 7, 3, 0, 11, 7, 0, 9, 11, 6, 7, 11, -1, -1, -1, -1}}, /* 142 11 */ {{ 7, 11, 6, 7, 8, 11, 8, 9, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 143 5 */ {{ 6, 4, 8, 10, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 144 2 */ {{ 3, 10, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 145 5 */ {{ 8, 10, 6, 8, 6, 4, 9, 1, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 146 7 */ {{ 9, 6, 4, 9, 3, 6, 9, 1, 3, 10, 6, 3, -1, -1, -1, -1}}, /* 147 11 */ {{ 6, 4, 8, 6, 8, 10, 2, 1, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 148 7 */ {{ 1, 11, 2, 3, 10, 0, 0, 10, 6, 0, 6, 4, -1, -1, -1, -1}}, /* 149 12 */ {{ 4, 8, 10, 4, 10, 6, 0, 9, 2, 2, 9, 11, -1, -1, -1, -1}}, /* 150 10 */ {{11, 3, 9, 11, 2, 3, 9, 3, 4, 10, 6, 3, 4, 3, 6, -1}}, /* 151 7 */ {{ 8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 152 5 */ {{ 0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 153 8 */ {{ 1, 0, 9, 2, 4, 3, 2, 6, 4, 4, 8, 3, -1, -1, -1, -1}}, /* 154 12 */ {{ 1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 155 5 */ {{ 8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 11, -1, -1, -1, -1}}, /* 156 14 */ {{11, 0, 1, 11, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 157 5 */ {{ 4, 3, 6, 4, 8, 3, 6, 3, 11, 0, 9, 3, 11, 3, 9, -1}}, /* 158 7 */ {{11, 4, 9, 6, 4, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 159 2 */ {{ 4, 5, 9, 7, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 160 3 */ {{ 0, 3, 8, 4, 5, 9, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 161 6 */ {{ 5, 1, 0, 5, 0, 4, 7, 10, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 162 7 */ {{10, 6, 7, 8, 4, 3, 3, 4, 5, 3, 5, 1, -1, -1, -1, -1}}, /* 163 12 */ {{ 9, 4, 5, 11, 2, 1, 7, 10, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 164 6 */ {{ 6, 7, 10, 1, 11, 2, 0, 3, 8, 4, 5, 9, -1, -1, -1, -1}}, /* 165 13 */ {{ 7, 10, 6, 5, 11, 4, 4, 11, 2, 4, 2, 0, -1, -1, -1, -1}}, /* 166 12 */ {{ 3, 8, 4, 3, 4, 5, 3, 5, 2, 11, 2, 5, 10, 6, 7, -1}}, /* 167 6 */ {{ 7, 3, 2, 7, 2, 6, 5, 9, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 168 7 */ {{ 9, 4, 5, 0, 6, 8, 0, 2, 6, 6, 7, 8, -1, -1, -1, -1}}, /* 169 12 */ {{ 3, 2, 6, 3, 6, 7, 1, 0, 5, 5, 0, 4, -1, -1, -1, -1}}, /* 170 10 */ {{ 6, 8, 2, 6, 7, 8, 2, 8, 1, 4, 5, 8, 1, 8, 5, -1}}, /* 171 7 */ {{ 9, 4, 5, 11, 6, 1, 1, 6, 7, 1, 7, 3, -1, -1, -1, -1}}, /* 172 12 */ {{ 1, 11, 6, 1, 6, 7, 1, 7, 0, 8, 0, 7, 9, 4, 5, -1}}, /* 173 6 */ {{ 4, 11, 0, 4, 5, 11, 0, 11, 3, 6, 7, 11, 3, 11, 7, -1}}, /* 174 7 */ {{ 7, 11, 6, 7, 8, 11, 5, 11, 4, 4, 11, 8, -1, -1, -1, -1}}, /* 175 3 */ {{ 6, 5, 9, 6, 9, 10, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 176 5 */ {{ 3, 10, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1}}, /* 177 9 */ {{ 0, 8, 10, 0, 10, 5, 0, 5, 1, 5, 10, 6, -1, -1, -1, -1}}, /* 178 14 */ {{ 6, 3, 10, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 179 5 */ {{ 1, 11, 2, 9, 10, 5, 9, 8, 10, 10, 6, 5, -1, -1, -1, -1}}, /* 180 12 */ {{ 0, 3, 10, 0, 10, 6, 0, 6, 9, 5, 9, 6, 1, 11, 2, -1}}, /* 181 6 */ {{10, 5, 8, 10, 6, 5, 8, 5, 0, 11, 2, 5, 0, 5, 2, -1}}, /* 182 7 */ {{ 6, 3, 10, 6, 5, 3, 2, 3, 11, 11, 3, 5, -1, -1, -1, -1}}, /* 183 3 */ {{ 5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1}}, /* 184 11 */ {{ 9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 185 5 */ {{ 1, 8, 5, 1, 0, 8, 5, 8, 6, 3, 2, 8, 6, 8, 2, -1}}, /* 186 7 */ {{ 1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 187 2 */ {{ 1, 6, 3, 1, 11, 6, 3, 6, 8, 5, 9, 6, 8, 6, 9, -1}}, /* 188 7 */ {{11, 0, 1, 11, 6, 0, 9, 0, 5, 5, 0, 6, -1, -1, -1, -1}}, /* 189 3 */ {{ 0, 8, 3, 5, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 190 4 */ {{11, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 191 1 */ {{10, 11, 5, 7, 10, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 192 2 */ {{10, 11, 5, 10, 5, 7, 8, 0, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 193 7 */ {{ 5, 7, 10, 5, 10, 11, 1, 0, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 194 7 */ {{11, 5, 7, 11, 7, 10, 9, 1, 8, 8, 1, 3, -1, -1, -1, -1}}, /* 195 10 */ {{10, 2, 1, 10, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 196 5 */ {{ 0, 3, 8, 1, 7, 2, 1, 5, 7, 7, 10, 2, -1, -1, -1, -1}}, /* 197 12 */ {{ 9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 10, -1, -1, -1, -1}}, /* 198 14 */ {{ 7, 2, 5, 7, 10, 2, 5, 2, 9, 3, 8, 2, 9, 2, 8, -1}}, /* 199 7 */ {{ 2, 11, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 200 5 */ {{ 8, 0, 2, 8, 2, 5, 8, 5, 7, 11, 5, 2, -1, -1, -1, -1}}, /* 201 11 */ {{ 9, 1, 0, 5, 3, 11, 5, 7, 3, 3, 2, 11, -1, -1, -1, -1}}, /* 202 12 */ {{ 9, 2, 8, 9, 1, 2, 8, 2, 7, 11, 5, 2, 7, 2, 5, -1}}, /* 203 7 */ {{ 1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 204 8 */ {{ 0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 205 5 */ {{ 9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 206 5 */ {{ 9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 207 2 */ {{ 5, 4, 8, 5, 8, 11, 11, 8, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 208 5 */ {{ 5, 4, 0, 5, 0, 10, 5, 10, 11, 10, 0, 3, -1, -1, -1, -1}}, /* 209 14 */ {{ 0, 9, 1, 8, 11, 4, 8, 10, 11, 11, 5, 4, -1, -1, -1, -1}}, /* 210 12 */ {{11, 4, 10, 11, 5, 4, 10, 4, 3, 9, 1, 4, 3, 4, 1, -1}}, /* 211 7 */ {{ 2, 1, 5, 2, 5, 8, 2, 8, 10, 4, 8, 5, -1, -1, -1, -1}}, /* 212 11 */ {{ 0, 10, 4, 0, 3, 10, 4, 10, 5, 2, 1, 10, 5, 10, 1, -1}}, /* 213 7 */ {{ 0, 5, 2, 0, 9, 5, 2, 5, 10, 4, 8, 5, 10, 5, 8, -1}}, /* 214 7 */ {{ 9, 5, 4, 2, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 215 4 */ {{ 2, 11, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1}}, /* 216 9 */ {{ 5, 2, 11, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 217 5 */ {{ 3, 2, 11, 3, 11, 5, 3, 5, 8, 4, 8, 5, 0, 9, 1, -1}}, /* 218 6 */ {{ 5, 2, 11, 5, 4, 2, 1, 2, 9, 9, 2, 4, -1, -1, -1, -1}}, /* 219 3 */ {{ 8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 220 5 */ {{ 0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 221 2 */ {{ 8, 5, 4, 8, 3, 5, 9, 5, 0, 0, 5, 3, -1, -1, -1, -1}}, /* 222 3 */ {{ 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 223 1 */ {{ 4, 7, 10, 4, 10, 9, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 224 5 */ {{ 0, 3, 8, 4, 7, 9, 9, 7, 10, 9, 10, 11, -1, -1, -1, -1}}, /* 225 12 */ {{ 1, 10, 11, 1, 4, 10, 1, 0, 4, 7, 10, 4, -1, -1, -1, -1}}, /* 226 11 */ {{ 3, 4, 1, 3, 8, 4, 1, 4, 11, 7, 10, 4, 11, 4, 10, -1}}, /* 227 7 */ {{ 4, 7, 10, 9, 4, 10, 9, 10, 2, 9, 2, 1, -1, -1, -1, -1}}, /* 228 9 */ {{ 9, 4, 7, 9, 7, 10, 9, 10, 1, 2, 1, 10, 0, 3, 8, -1}}, /* 229 6 */ {{10, 4, 7, 10, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 230 5 */ {{10, 4, 7, 10, 2, 4, 8, 4, 3, 3, 4, 2, -1, -1, -1, -1}}, /* 231 3 */ {{ 2, 11, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1}}, /* 232 14 */ {{ 9, 7, 11, 9, 4, 7, 11, 7, 2, 8, 0, 7, 2, 7, 0, -1}}, /* 233 7 */ {{ 3, 11, 7, 3, 2, 11, 7, 11, 4, 1, 0, 11, 4, 11, 0, -1}}, /* 234 7 */ {{ 1, 2, 11, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 235 4 */ {{ 4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 236 5 */ {{ 4, 1, 9, 4, 7, 1, 0, 1, 8, 8, 1, 7, -1, -1, -1, -1}}, /* 237 3 */ {{ 4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 238 2 */ {{ 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 239 1 */ {{ 9, 8, 11, 11, 8, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 240 8 */ {{ 3, 9, 0, 3, 10, 9, 10, 11, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 241 5 */ {{ 0, 11, 1, 0, 8, 11, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 242 5 */ {{ 3, 11, 1, 10, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 243 2 */ {{ 1, 10, 2, 1, 9, 10, 9, 8, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 244 5 */ {{ 3, 9, 0, 3, 10, 9, 1, 9, 2, 2, 9, 10, -1, -1, -1, -1}}, /* 245 3 */ {{ 0, 10, 2, 8, 10, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 246 2 */ {{ 3, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 247 1 */ {{ 2, 8, 3, 2, 11, 8, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 248 5 */ {{ 9, 2, 11, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 249 2 */ {{ 2, 8, 3, 2, 11, 8, 0, 8, 1, 1, 8, 11, -1, -1, -1, -1}}, /* 250 3 */ {{ 1, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 251 1 */ {{ 1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 252 2 */ {{ 0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 253 1 */ {{ 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 254 1 */ {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}}; /* 255 0 */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/regprop2.cpp0000644000175000017500000001170611065020741025555 0ustar debiandebian//------------------------------------------------------------------------ // // regProp2.C - preprocessing of 2d volumes for seed set extraction // //------------------------------------------------------------------------ // $Id: regprop2.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #endif #include "regprop2.h" #include "datareg2.h" #define DEBUGNo extern int verbose; //------------------------------------------------------------------------ // // Preprocess() - build a segment tree for O(log n) queries // //------------------------------------------------------------------------ void regProp2::compSeeds(void) { Datareg2 ®2 = (Datareg2&)data; int i, j; int xdim, ydim; float val[4]; Range *_prop_x, *prop_x; Range prop_y; Range propagated; Range c_prop; Range responsibility, c_respons; Range delay; Range y_comp; float min_x, min_y, max_x, max_y; float min_in, max_in, min4, max4; int nseed; if (verbose) printf("***** Seed Creation\n"); xdim = reg2.dim[0]; ydim = reg2.dim[1]; _prop_x = new Range[ydim]; // proceed through the slices computing seeds nseed=0; // process the k'th slab for (i=0; iSet(min_x, max_x); if (j==0) prop_y.Set(min_y, max_y); #ifdef DEBUG printf("prop_x: "); prop_x.Print(); printf("prop_y: "); (*prop_y).Print(); #endif // merge incoming information y_comp = prop_y.Complement(min_y, max_y); propagated = prop_y + ((*prop_x)-y_comp); // propagated = prop_x; // propagated += *prop_y; // propagated += *prop_z; // propagated -= x_comp; #ifdef DEBUG printf("x_comp: "); x_comp.Print(); printf("total propagated: "); propagated.Print(); #endif // compute complement of incoming ranges min_in = MIN2(min_x, min_y); // max_in = MAX2(min_x, min_y); max_in = MAX2(max_x, max_y); // c_prop = Range(min_in,max_in) - propagated; c_prop.Set(min_in,max_in); c_prop -= propagated; #ifdef DEBUG printf("complement: "); c_prop.Print(); #endif // compute responsibility ranges min4 = MIN2(min_in, val[2]); max4 = MAX2(max_in, val[2]); // responsibility = Range(min4, max4) - c_prop; responsibility.Set(min4, max4); responsibility-=c_prop; c_respons = responsibility.Complement(min4, max4); #ifdef DEBUG printf("respon: "); responsibility.Print(); printf("c_respon: "); c_respons.Print(); #endif // determine range which can be delayed delay.MakeEmpty(); if (i < xdim-2) delay+=Range(MIN2(val[1], val[2]), MAX2(val[1], val[2])); if (j < ydim-2) delay+=Range(MIN2(val[2], val[3]), MAX2(val[2], val[3])); #ifdef DEBUG printf("delay: "); delay.Print(); #endif // test for propagation of entire responsibility range if (responsibility.Empty() || (!delay.Empty() && delay.MinAll() <= responsibility.MinAll() && delay.MaxAll() >= responsibility.MaxAll())) { #ifdef DEBUG printf("DELAY ALL\n"); #endif // propagate first to the next x-slice if (i == xdim-2) prop_x->MakeEmpty(); else { prop_x->Set(MIN2(val[1], val[2]), MAX2(val[1], val[2])); *prop_x-=c_respons; } c_respons += *prop_x; // all remaining propagated in y-dir if (j == ydim-2) prop_y.MakeEmpty(); else { prop_y.Set(MIN2(val[2], val[3]), MAX2(val[2], val[3])); prop_y-= c_respons; } } else { #ifdef DEBUG printf("ADD SEED\n"); #endif // can't propagate all responsiblity, cell must be a seed seeds.AddSeed(reg2.index2cell(i,j), responsibility.MinAll(), responsibility.MaxAll()); #ifdef DEBUG printf("seed at %d %d %d\n", i, j, k); #endif nseed++; prop_y.MakeEmpty(); prop_x->MakeEmpty(); } #ifdef DEBUG sleep(1); #endif } if (verbose) printf("computed %d seeds\n", nseed); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/commdata.h0000644000175000017500000001553310064121655025255 0ustar debiandebian//------------------------------------------------------------------------ // // commdata.h - client/server data communication structures // - this module defines the client/server DATA interface // - this, data.h and seedCells.h are the only modules common // to both the server and the client programs // // Description: these are the data structures produced at the server, sent // and received by the client. They are structs and NOT // classes because: // * they have no methods associated: no processing is // done on them at the client side // * they are read only: neither of their members is ever // modified by the client's user interface // Hence having classes instead of structs greatly simplifies // building, sending and accessing these data structures. // // Copyright (c) 1998 Emilio Camahort - ecamahor@cs.utexas.edu // //------------------------------------------------------------------------ // $Id: commdata.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef COMMDATA_H #define COMMDATA_H #include "data.h" #include "seedcells.h" //------------------------------------------------------------------------ // a constant that says use no variable for coloring an isocontour //------------------------------------------------------------------------ #define NO_COLOR_VARIABLE -1 //------------------------------------------------------------------------ // data set parameters (some parameters unused for some dataset types) //------------------------------------------------------------------------ typedef struct DatasetParams // structure to store a dataset parameters { int data_id; // dataset identifier int nvars; // number of variables int ntime; // number of time steps u_int dim[3]; // data set x, y, z dimensions float orig[3]; // coords of data set origin float span[3]; // how far does the data set go float minext[3]; // min corner of data set float maxext[3]; // max corner of data set char *error; // client/server error string } DatasetParams; //------------------------------------------------------------------------ // data structure for storing variable names //------------------------------------------------------------------------ typedef struct VariableNames // structure to store variable names { int data_id; // dataset identifier int nvars; // number of variables char **names; // array of variable names char *error; // client/server error string } VariableNames; //------------------------------------------------------------------------ // data structure for storing seed cells //------------------------------------------------------------------------ typedef struct SeedData // structure to store seeds (see seedCells.h) { int data_id; // dataset identifier int variable; // dataset variable int timestep; // dataset timestep int nseeds; // number of seed cells SeedCell *seeds; // array of seed cells char *error; // client/server error string } SeedData; //------------------------------------------------------------------------ // data structures for storing signature functions //------------------------------------------------------------------------ typedef struct Signature // a single signature function { char *name; // fuction name int nval; // number of function values float *fx; // x-values of function float *fy; // y-values of function } Signature; typedef struct SignatureData // a structure for signature function data { int data_id; // dataset identifier int variable; // dataset variable int timestep; // dataset timestep float minvalue; // minimum value for dataset variable float maxvalue; // maximum value for dataset variable int nsfun; // number of signature functions Signature *sfun; // signature function array char *error; // client/server error string } SignatureData; //------------------------------------------------------------------------ // a data structure for storing a set of signature function values //------------------------------------------------------------------------ typedef struct SignatureValues { int data_id; // dataset identifier int variable; // dataset variable int timestep; // dataset timestep float isovalue; // x-value (isovalue) int nsfun; // number of signature functions float *yvalues; // array of signature function values char *error; // client/server error string } SignatureValues; //------------------------------------------------------------------------ // a slice of a 3D regular grid //------------------------------------------------------------------------ typedef struct SliceData // structure to store a 2d scalar data slice { int data_id; // dataset identifier int variable; // dataset variable int timestep; // dataset timestep char axis; // either x, y or z int index; // index of slice along axis int width, height; // slice width and height float minvalue; // minimum isovalue for this variable float maxvalue; // maximum isovalue for this variable Data::DataType type; // type of data: uchar, ushort, float Data::datatypes data; // slice data char *error; // client/server error string } SliceData; //------------------------------------------------------------------------ // store a 2D isocontour //------------------------------------------------------------------------ typedef struct Contour2dData // structure to store a 2d isocontour { int data_id; // dataset identifier int variable; // dataset variable int timestep; // dataset timestep float isovalue; // isovalue for this isocontour int nvert; // size of vertex array int nedge; // size of edge array float (*vert)[2]; // polyline vertex array u_int (*edge)[2]; // array of edge indices char *error; // client/server error string } Contour2dData; //------------------------------------------------------------------------ // store a 3D isocontour //------------------------------------------------------------------------ typedef struct Contour3dData // structure to store a 3d isocontour { int data_id; // dataset identifier int variable; // dataset variable int timestep; // dataset timestep float isovalue; // isovalue for this isocontour int nvert; // number of vertices in vertex array int ntri; // triangles in triangle array float (*vert)[3]; // isosurface vertex array float (*vnorm)[3]; // array of vertex normals float (*vfun); // color values at vertices u_int (*tri)[3]; // triangle mesh array int colorvar; // color variable (-1 if no color) float fmin, fmax; // min and max color values char *error; // client/server error string } Contour3dData; #endif /* of COMMDATA_H */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/contour2d.cpp0000644000175000017500000000651711065020741025740 0ustar debiandebian// ______________________________________________________________________ // // NAME // Contour2d - Class for a 2d contour curve // // Copyright (c) 1998 Emilio Camahort, Dan Schikore // // SYNOPSIS // #include // ______________________________________________________________________ // $Id: contour2d.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #else #include #endif #include "contour2d.h" //------------------------------------------------------------------------ // // Contour2d() - basic constructor // //------------------------------------------------------------------------ Contour2d::Contour2d() { done = 0; nvert = 0; nedge = 0; vsize = 500; tsize = 1000; vert = (float (*)[2])malloc(sizeof(float[2]) * vsize); edge = (u_int (*)[2])malloc(sizeof(u_int[2]) * tsize); } //------------------------------------------------------------------------ // // ~Contour2d() - free allocated memory // //------------------------------------------------------------------------ Contour2d::~Contour2d() { free(vert); free(edge); } //------------------------------------------------------------------------ // // AddVert() - add a vertex with the given (unit) normal // //------------------------------------------------------------------------ int Contour2d::AddVert(float x, float y) { int n = nvert++; if (nvert > vsize) { vsize<<=1; vert = (float (*)[2])realloc(vert, sizeof(float[2]) * vsize); } vert[n][0] = x; vert[n][1] = y; return(n); } //------------------------------------------------------------------------ // // AddEdge() - add an edge indexed by its 2 vertices // //------------------------------------------------------------------------ int Contour2d::AddEdge(u_int v1, u_int v2) { int n = nedge++; if (nedge > tsize) { tsize<<=1; edge = (u_int (*)[2])realloc(edge, sizeof(u_int[2]) * tsize); } edge[n][0] = v1; edge[n][1] = v2; return(n); } //------------------------------------------------------------------------ // // Reset() - clear vertex and edge info // //------------------------------------------------------------------------ void Contour2d::Reset(void) { nvert = 0; nedge = 0; done = 0; } void Contour2d::Done(void) { done = 1; } //------------------------------------------------------------------------ // // write() - write vertex and triangles to a file // //------------------------------------------------------------------------ int Contour2d::write(char *filename) { FILE *fp; int v, t; fp = fopen(filename, "w"); // silent failure --> changed by Emilio: return 1 = ERROR if (fp == NULL) return 1; fprintf(fp, "%d %d 0 0 0 0 0\n0 0 0\n", nvert, nedge); // Emilio: following construct gives an out-of-bounds warning, I'll just // write a zero instead for the time being, since writing nothing // would screw up the file format #ifdef EMILIO for (v=0; v max) max = t; if ((t=getValue(cells[c][2])) < min) min = t; if (t > max) max = t; } void getFaceRange(u_int c, u_int f, float &min, float &max) { float t; min = max = getValue(cells[c][f]); if ((t=getValue(cells[c][f==2?0:f+1])) < min) min = t; if (t > max) max = t; } }; //------------------------------------------------------------------------ // // ~Dataslc() - destroy a volume // //------------------------------------------------------------------------ inline Dataslc::~Dataslc() { if (filename) { free(verts); free(cells); free(celladj); } } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/regprop.cpp0000644000175000017500000001453511065020741025476 0ustar debiandebian//------------------------------------------------------------------------ // // regProp.C - preprocessing of 3d volumes for seed set extraction // //------------------------------------------------------------------------ // $Id: regprop.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #endif #include "regprop.h" #include "datareg3.h" #define DEBUGNo extern int verbose; //------------------------------------------------------------------------ // // Preprocess() - build a segment tree for O(log n) queries // //------------------------------------------------------------------------ void regProp::compSeeds(void) { Datareg3 ®3 = (Datareg3&)data; int i, j, k; int xdim, ydim, zdim; float val[8]; Range *_prop_z, *prop_z; Range *_prop_y, *prop_y; Range prop_x; Range propagated; Range c_prop; Range responsibility, c_respons; Range delay; Range x_comp; float min_x, min_y, min_z, max_x, max_y, max_z; float min_in, max_in, min8, max8; int nseed; if (verbose) printf("***** Seed Creation\n"); xdim = reg3.dim[0]; ydim = reg3.dim[1]; zdim = reg3.dim[2]; _prop_z = new Range[xdim * ydim]; _prop_y = new Range[xdim]; // proceed through the slices computing seeds nseed=0; for (k=0; kSet(min_y, max_y); if (k==0) prop_z->Set(min_z, max_z); #ifdef DEBUG printf("prop_x: "); prop_x.Print(); printf("prop_y: "); (*prop_y).Print(); printf("prop_z: "); (*prop_z).Print(); #endif // merge incoming information x_comp = prop_x.Complement(min_x, max_x); propagated = prop_x + ((*prop_y)+(*prop_z)-x_comp); // propagated = prop_x; // propagated += *prop_y; // propagated += *prop_z; // propagated -= x_comp; #ifdef DEBUG printf("x_comp: "); x_comp.Print(); printf("total propagated: "); propagated.Print(); #endif // compute complement of incoming ranges min_in = MIN3(min_x, min_y, min_z); // max_in = MAX3(min_x, min_y, min_z); max_in = MAX3(max_x, max_y, max_z); // c_prop = Range(min_in,max_in) - propagated; c_prop.Set(min_in,max_in); c_prop -= propagated; #ifdef DEBUG printf("complement: "); c_prop.Print(); #endif // compute responsibility ranges min8 = MIN2(min_in, val[6]); max8 = MAX2(max_in, val[6]); // responsibility = Range(min8, max8) - c_prop; responsibility.Set(min8, max8); responsibility-=c_prop; c_respons = responsibility.Complement(min8, max8); #ifdef DEBUG printf("respon: "); responsibility.Print(); printf("c_respon: "); c_respons.Print(); #endif // determine range which can be delayed delay.MakeEmpty(); if (i < xdim-2) delay+=Range(MIN4(val[1], val[2], val[5], val[6]), MAX4(val[1], val[2], val[5], val[6])); if (j < ydim-2) delay+=Range(MIN4(val[4], val[5], val[6], val[7]), MAX4(val[4], val[5], val[6], val[7])); if (k < zdim-2) delay+=Range(MIN4(val[2], val[3], val[6], val[7]), MAX4(val[2], val[3], val[6], val[7])); #ifdef DEBUG printf("delay: "); delay.Print(); #endif // test for propagation of entire responsibility range if (responsibility.Empty() || (!delay.Empty() && delay.MinAll() <= responsibility.MinAll() && delay.MaxAll() >= responsibility.MaxAll())) { #ifdef DEBUG printf("DELAY ALL\n"); #endif // propagate first to the next z-slice if (k == zdim-2) prop_z->MakeEmpty(); else { prop_z->Set(MIN4(val[2], val[3], val[6], val[7]), MAX4(val[2], val[3], val[6], val[7])); *prop_z -= c_respons; } c_respons += *prop_z; // propagate in y-direction next if (j == ydim-2) prop_y->MakeEmpty(); else { prop_y->Set(MIN4(val[4], val[5], val[6], val[7]), MAX4(val[4], val[5], val[6], val[7])); *prop_y-=c_respons; } c_respons += *prop_y; // all remaining propagated in x-dir if (i == xdim-2) prop_x.MakeEmpty(); else { prop_x.Set(MIN4(val[1], val[2], val[5], val[6]), MAX4(val[1], val[2], val[5], val[6])); prop_x-= c_respons; } } else { #ifdef DEBUG printf("ADD SEED\n"); #endif // can't propagate all responsiblity, cell must be a seed seeds.AddSeed(reg3.index2cell(i,j,k), responsibility.MinAll(), responsibility.MaxAll()); #ifdef DEBUG printf("seed at %d %d %d\n", i, j, k); #endif nseed++; prop_z->MakeEmpty(); prop_y->MakeEmpty(); prop_x.MakeEmpty(); } #ifdef DEBUG sleep(1); #endif } } delete [] _prop_z; delete [] _prop_y; if (verbose) printf("computed %d seeds\n", nseed); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dict.c0000644000175000017500000010604410354314075024406 0ustar debiandebian/* * Dictionary Abstract Data Type * Copyright (C) 1997 Kaz Kylheku * * Free Software License: * * All rights are reserved by the author, with the following exceptions: * Permission is granted to freely reproduce and distribute this software, * possibly in exchange for a fee, provided that this copyright notice appears * intact. Permission is also granted to adapt this software to produce * derivative works, as long as the modified versions carry this copyright * notice and additional notices stating that the work has been modified. * This source code may be translated into executable form and incorporated * into proprietary software; there is no requirement for such software to * contain a copyright notice related to this source. * * $Id: dict.c,v 1.2 2005/12/27 19:38:37 annao Exp $ * $Name: $ */ /* This version was modified by Anna Omelchenko (TSRI) to compile it * with C++ compiler: * -- replaced 'new', 'template', 'delete' variables by '_new', * '_template' and '_delete' respectively. * -- added type_casting for malloc(). */ #include #include #include #define DICT_IMPLEMENTATION #include "dict.h" #ifdef KAZLIB_RCSID static const char rcsid[] = "$Id: dict.c,v 1.2 2005/12/27 19:38:37 annao Exp $"; #endif /* * These macros provide short convenient names for structure members, * which are embellished with dict_ prefixes so that they are * properly confined to the documented namespace. It's legal for a * program which uses dict to define, for instance, a macro called ``parent''. * Such a macro would interfere with the dnode_t struct definition. * In general, highly portable and reusable C modules which expose their * structures need to confine structure member names to well-defined spaces. * The resulting identifiers aren't necessarily convenient to use, nor * readable, in the implementation, however! */ #define left dict_left #define right dict_right #define parent dict_parent #define color dict_color #define key dict_key #define data dict_data #define nilnode dict_nilnode #define nodecount dict_nodecount #define maxcount dict_maxcount #define compare dict_compare #define allocnode dict_allocnode #define freenode dict_freenode #define context dict_context #define dupes dict_dupes #define dictptr dict_dictptr #define dict_root(D) ((D)->nilnode.left) #define dict_nil(D) (&(D)->nilnode) #define DICT_DEPTH_MAX 64 //static dnode_t *dnode_alloc(void *context); //static void dnode_free(dnode_t *node, void *context); /* * Perform a ``left rotation'' adjustment on the tree. The given node P and * its right child C are rearranged so that the P instead becomes the left * child of C. The left subtree of C is inherited as the new right subtree * for P. The ordering of the keys within the tree is thus preserved. */ static void rotate_left(dnode_t *upper) { dnode_t *lower, *lowleft, *upparent; lower = upper->right; upper->right = lowleft = lower->left; lowleft->parent = upper; lower->parent = upparent = upper->parent; /* don't need to check for root node here because root->parent is the sentinel nil node, and root->parent->left points back to root */ if (upper == upparent->left) { upparent->left = lower; } else { assert (upper == upparent->right); upparent->right = lower; } lower->left = upper; upper->parent = lower; } /* * This operation is the ``mirror'' image of rotate_left. It is * the same procedure, but with left and right interchanged. */ static void rotate_right(dnode_t *upper) { dnode_t *lower, *lowright, *upparent; lower = upper->left; upper->left = lowright = lower->right; lowright->parent = upper; lower->parent = upparent = upper->parent; if (upper == upparent->right) { upparent->right = lower; } else { assert (upper == upparent->left); upparent->left = lower; } lower->right = upper; upper->parent = lower; } /* * Do a postorder traversal of the tree rooted at the specified * node and free everything under it. Used by dict_free(). */ static void free_nodes(dict_t *dict, dnode_t *node, dnode_t *nil) { if (node == nil) return; free_nodes(dict, node->left, nil); free_nodes(dict, node->right, nil); dict->freenode(node, dict->context); } /* * This procedure performs a verification that the given subtree is a binary * search tree. It performs an inorder traversal of the tree using the * dict_next() successor function, verifying that the key of each node is * strictly lower than that of its successor, if duplicates are not allowed, * or lower or equal if duplicates are allowed. This function is used for * debugging purposes. */ static int verify_bintree(dict_t *dict) { dnode_t *first, *next; first = dict_first(dict); if (dict->dupes) { while (first && (next = dict_next(dict, first))) { if (dict->compare(first->key, next->key) > 0) return 0; first = next; } } else { while (first && (next = dict_next(dict, first))) { if (dict->compare(first->key, next->key) >= 0) return 0; first = next; } } return 1; } /* * This function recursively verifies that the given binary subtree satisfies * three of the red black properties. It checks that every red node has only * black children. It makes sure that each node is either red or black. And it * checks that every path has the same count of black nodes from root to leaf. * It returns the blackheight of the given subtree; this allows blackheights to * be computed recursively and compared for left and right siblings for * mismatches. It does not check for every nil node being black, because there * is only one sentinel nil node. The return value of this function is the * black height of the subtree rooted at the node ``root'', or zero if the * subtree is not red-black. */ static unsigned int verify_redblack(dnode_t *nil, dnode_t *root) { unsigned height_left, height_right; if (root != nil) { height_left = verify_redblack(nil, root->left); height_right = verify_redblack(nil, root->right); if (height_left == 0 || height_right == 0) return 0; if (height_left != height_right) return 0; if (root->color == dnode_red) { if (root->left->color != dnode_black) return 0; if (root->right->color != dnode_black) return 0; return height_left; } if (root->color != dnode_black) return 0; return height_left + 1; } return 1; } /* * Compute the actual count of nodes by traversing the tree and * return it. This could be compared against the stored count to * detect a mismatch. */ static dictcount_t verify_node_count(dnode_t *nil, dnode_t *root) { if (root == nil) return 0; else return 1 + verify_node_count(nil, root->left) + verify_node_count(nil, root->right); } /* * Verify that the tree contains the given node. This is done by * traversing all of the nodes and comparing their pointers to the * given pointer. Returns 1 if the node is found, otherwise * returns zero. It is intended for debugging purposes. */ static int verify_dict_has_node(dnode_t *nil, dnode_t *root, dnode_t *node) { if (root != nil) { return root == node || verify_dict_has_node(nil, root->left, node) || verify_dict_has_node(nil, root->right, node); } return 0; } /* * Dynamically allocate and initialize a dictionary object. */ dict_t *dict_create(dictcount_t maxcount, dict_comp_t comp) { dict_t *_new = (dict_t *)malloc(sizeof *_new); if (_new) { _new->compare = comp; _new->allocnode = dnode_alloc; _new->freenode = dnode_free; _new->context = NULL; _new->nodecount = 0; _new->maxcount = maxcount; _new->nilnode.left = &_new->nilnode; _new->nilnode.right = &_new->nilnode; _new->nilnode.parent = &_new->nilnode; _new->nilnode.color = dnode_black; _new->dupes = 0; } return _new; } /* * Select a different set of node allocator routines. */ void dict_set_allocator(dict_t *dict, dnode_alloc_t al, dnode_free_t fr, void *context) { assert (dict_count(dict) == 0); assert ((al == NULL && fr == NULL) || (al != NULL && fr != NULL)); dict->allocnode = al ? al : dnode_alloc; dict->freenode = fr ? fr : dnode_free; dict->context = context; } /* * Free a dynamically allocated dictionary object. Removing the nodes * from the tree before deleting it is required. */ void dict_destroy(dict_t *dict) { assert (dict_isempty(dict)); free(dict); } /* * Free all the nodes in the dictionary by using the dictionary's * installed free routine. The dictionary is emptied. */ void dict_free_nodes(dict_t *dict) { dnode_t *nil = dict_nil(dict), *root = dict_root(dict); free_nodes(dict, root, nil); dict->nodecount = 0; dict->nilnode.left = &dict->nilnode; dict->nilnode.right = &dict->nilnode; } /* * Obsolescent function, equivalent to dict_free_nodes */ void dict_free(dict_t *dict) { #ifdef KAZLIB_OBSOLESCENT_DEBUG assert ("call to obsolescent function dict_free()" && 0); #endif dict_free_nodes(dict); } /* * Initialize a user-supplied dictionary object. */ dict_t *dict_init(dict_t *dict, dictcount_t maxcount, dict_comp_t comp) { dict->compare = comp; dict->allocnode = dnode_alloc; dict->freenode = dnode_free; dict->context = NULL; dict->nodecount = 0; dict->maxcount = maxcount; dict->nilnode.left = &dict->nilnode; dict->nilnode.right = &dict->nilnode; dict->nilnode.parent = &dict->nilnode; dict->nilnode.color = dnode_black; dict->dupes = 0; return dict; } /* * Initialize a dictionary in the likeness of another dictionary */ void dict_init_like(dict_t *dict, const dict_t *_template) { dict->compare = _template->compare; dict->allocnode = _template->allocnode; dict->freenode = _template->freenode; dict->context = _template->context; dict->nodecount = 0; dict->maxcount = _template->maxcount; dict->nilnode.left = &dict->nilnode; dict->nilnode.right = &dict->nilnode; dict->nilnode.parent = &dict->nilnode; dict->nilnode.color = dnode_black; dict->dupes = _template->dupes; assert (dict_similar(dict, _template)); } /* * Remove all nodes from the dictionary (without freeing them in any way). */ static void dict_clear(dict_t *dict) { dict->nodecount = 0; dict->nilnode.left = &dict->nilnode; dict->nilnode.right = &dict->nilnode; dict->nilnode.parent = &dict->nilnode; assert (dict->nilnode.color == dnode_black); } /* * Verify the integrity of the dictionary structure. This is provided for * debugging purposes, and should be placed in assert statements. Just because * this function succeeds doesn't mean that the tree is not corrupt. Certain * corruptions in the tree may simply cause undefined behavior. */ int dict_verify(dict_t *dict) { dnode_t *nil = dict_nil(dict), *root = dict_root(dict); /* check that the sentinel node and root node are black */ if (root->color != dnode_black) return 0; if (nil->color != dnode_black) return 0; if (nil->right != nil) return 0; /* nil->left is the root node; check that its parent pointer is nil */ if (nil->left->parent != nil) return 0; /* perform a weak test that the tree is a binary search tree */ if (!verify_bintree(dict)) return 0; /* verify that the tree is a red-black tree */ if (!verify_redblack(nil, root)) return 0; if (verify_node_count(nil, root) != dict_count(dict)) return 0; return 1; } /* * Determine whether two dictionaries are similar: have the same comparison and * allocator functions, and same status as to whether duplicates are allowed. */ int dict_similar(const dict_t *left, const dict_t *right) { if (left->compare != right->compare) return 0; if (left->allocnode != right->allocnode) return 0; if (left->freenode != right->freenode) return 0; if (left->context != right->context) return 0; if (left->dupes != right->dupes) return 0; return 1; } /* * Locate a node in the dictionary having the given key. * If the node is not found, a null a pointer is returned (rather than * a pointer that dictionary's nil sentinel node), otherwise a pointer to the * located node is returned. */ dnode_t *dict_lookup(dict_t *dict, const void *key) { dnode_t *root = dict_root(dict); dnode_t *nil = dict_nil(dict); dnode_t *saved; int result; /* simple binary search adapted for trees that contain duplicate keys */ while (root != nil) { result = dict->compare(key, root->key); if (result < 0) root = root->left; else if (result > 0) root = root->right; else { if (!dict->dupes) { /* no duplicates, return match */ return root; } else { /* could be dupes, find leftmost one */ do { saved = root; root = root->left; while (root != nil && dict->compare(key, root->key)) root = root->right; } while (root != nil); return saved; } } } return NULL; } /* * Look for the node corresponding to the lowest key that is equal to or * greater than the given key. If there is no such node, return null. */ dnode_t *dict_lower_bound(dict_t *dict, const void *key) { dnode_t *root = dict_root(dict); dnode_t *nil = dict_nil(dict); dnode_t *tentative = 0; while (root != nil) { int result = dict->compare(key, root->key); if (result > 0) { root = root->right; } else if (result < 0) { tentative = root; root = root->left; } else { if (!dict->dupes) { return root; } else { tentative = root; root = root->left; } } } return tentative; } /* * Look for the node corresponding to the greatest key that is equal to or * lower than the given key. If there is no such node, return null. */ dnode_t *dict_upper_bound(dict_t *dict, const void *key) { dnode_t *root = dict_root(dict); dnode_t *nil = dict_nil(dict); dnode_t *tentative = 0; while (root != nil) { int result = dict->compare(key, root->key); if (result < 0) { root = root->left; } else if (result > 0) { tentative = root; root = root->right; } else { if (!dict->dupes) { return root; } else { tentative = root; root = root->right; } } } return tentative; } /* * Insert a node into the dictionary. The node should have been * initialized with a data field. All other fields are ignored. * The behavior is undefined if the user attempts to insert into * a dictionary that is already full (for which the dict_isfull() * function returns true). */ void dict_insert(dict_t *dict, dnode_t *node, const void *key) { dnode_t *where = dict_root(dict), *nil = dict_nil(dict); dnode_t *parent = nil, *uncle, *grandpa; int result = -1; node->key = key; assert (!dict_isfull(dict)); assert (!dict_contains(dict, node)); assert (!dnode_is_in_a_dict(node)); /* basic binary tree insert */ while (where != nil) { parent = where; result = dict->compare(key, where->key); /* trap attempts at duplicate key insertion unless it's explicitly allowed */ assert (dict->dupes || result != 0); if (result < 0) where = where->left; else where = where->right; } assert (where == nil); if (result < 0) parent->left = node; else parent->right = node; node->parent = parent; node->left = nil; node->right = nil; dict->nodecount++; /* red black adjustments */ node->color = dnode_red; while (parent->color == dnode_red) { grandpa = parent->parent; if (parent == grandpa->left) { uncle = grandpa->right; if (uncle->color == dnode_red) { /* red parent, red uncle */ parent->color = dnode_black; uncle->color = dnode_black; grandpa->color = dnode_red; node = grandpa; parent = grandpa->parent; } else { /* red parent, black uncle */ if (node == parent->right) { rotate_left(parent); parent = node; assert (grandpa == parent->parent); /* rotation between parent and child preserves grandpa */ } parent->color = dnode_black; grandpa->color = dnode_red; rotate_right(grandpa); break; } } else { /* symmetric cases: parent == parent->parent->right */ uncle = grandpa->left; if (uncle->color == dnode_red) { parent->color = dnode_black; uncle->color = dnode_black; grandpa->color = dnode_red; node = grandpa; parent = grandpa->parent; } else { if (node == parent->left) { rotate_right(parent); parent = node; assert (grandpa == parent->parent); } parent->color = dnode_black; grandpa->color = dnode_red; rotate_left(grandpa); break; } } } dict_root(dict)->color = dnode_black; assert (dict_verify(dict)); } /* * Delete the given node from the dictionary. If the given node does not belong * to the given dictionary, undefined behavior results. A pointer to the * deleted node is returned. */ dnode_t *dict_delete(dict_t *dict, dnode_t *_delete) { dnode_t *nil = dict_nil(dict), *child, *delparent = _delete->parent; /* basic deletion */ assert (!dict_isempty(dict)); assert (dict_contains(dict, _delete)); /* * If the node being deleted has two children, then we replace it with its * successor (i.e. the leftmost node in the right subtree.) By doing this, * we avoid the traditional algorithm under which the successor's key and * value *only* move to the deleted node and the successor is spliced out * from the tree. We cannot use this approach because the user may hold * pointers to the successor, or nodes may be inextricably tied to some * other structures by way of embedding, etc. So we must splice out the * node we are given, not some other node, and must not move contents from * one node to another behind the user's back. */ if (_delete->left != nil && _delete->right != nil) { dnode_t *next = dict_next(dict, _delete); dnode_t *nextparent = next->parent; dnode_color_t nextcolor = next->color; assert (next != nil); assert (next->parent != nil); assert (next->left == nil); /* * First, splice out the successor from the tree completely, by * moving up its right child into its place. */ child = next->right; child->parent = nextparent; if (nextparent->left == next) { nextparent->left = child; } else { assert (nextparent->right == next); nextparent->right = child; } /* * Now that the successor has been extricated from the tree, install it * in place of the node that we want deleted. */ next->parent = delparent; next->left = _delete->left; next->right = _delete->right; next->left->parent = next; next->right->parent = next; next->color = _delete->color; _delete->color = nextcolor; if (delparent->left == _delete) { delparent->left = next; } else { assert (delparent->right == _delete); delparent->right = next; } } else { assert (_delete != nil); assert (_delete->left == nil || _delete->right == nil); child = (_delete->left != nil) ? _delete->left : _delete->right; child->parent = delparent = _delete->parent; if (_delete == delparent->left) { delparent->left = child; } else { assert (_delete == delparent->right); delparent->right = child; } } _delete->parent = NULL; _delete->right = NULL; _delete->left = NULL; dict->nodecount--; assert (verify_bintree(dict)); /* red-black adjustments */ if (_delete->color == dnode_black) { dnode_t *parent, *sister; dict_root(dict)->color = dnode_red; while (child->color == dnode_black) { parent = child->parent; if (child == parent->left) { sister = parent->right; assert (sister != nil); if (sister->color == dnode_red) { sister->color = dnode_black; parent->color = dnode_red; rotate_left(parent); sister = parent->right; assert (sister != nil); } if (sister->left->color == dnode_black && sister->right->color == dnode_black) { sister->color = dnode_red; child = parent; } else { if (sister->right->color == dnode_black) { assert (sister->left->color == dnode_red); sister->left->color = dnode_black; sister->color = dnode_red; rotate_right(sister); sister = parent->right; assert (sister != nil); } sister->color = parent->color; sister->right->color = dnode_black; parent->color = dnode_black; rotate_left(parent); break; } } else { /* symmetric case: child == child->parent->right */ assert (child == parent->right); sister = parent->left; assert (sister != nil); if (sister->color == dnode_red) { sister->color = dnode_black; parent->color = dnode_red; rotate_right(parent); sister = parent->left; assert (sister != nil); } if (sister->right->color == dnode_black && sister->left->color == dnode_black) { sister->color = dnode_red; child = parent; } else { if (sister->left->color == dnode_black) { assert (sister->right->color == dnode_red); sister->right->color = dnode_black; sister->color = dnode_red; rotate_left(sister); sister = parent->left; assert (sister != nil); } sister->color = parent->color; sister->left->color = dnode_black; parent->color = dnode_black; rotate_right(parent); break; } } } child->color = dnode_black; dict_root(dict)->color = dnode_black; } assert (dict_verify(dict)); return _delete; } /* * Allocate a node using the dictionary's allocator routine, give it * the data item. */ int dict_alloc_insert(dict_t *dict, const void *key, void *data) { dnode_t *node = dict->allocnode(dict->context); if (node) { dnode_init(node, data); dict_insert(dict, node, key); return 1; } return 0; } void dict_delete_free(dict_t *dict, dnode_t *node) { dict_delete(dict, node); dict->freenode(node, dict->context); } /* * Return the node with the lowest (leftmost) key. If the dictionary is empty * (that is, dict_isempty(dict) returns 1) a null pointer is returned. */ dnode_t *dict_first(dict_t *dict) { dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *left; if (root != nil) while ((left = root->left) != nil) root = left; return (root == nil) ? NULL : root; } /* * Return the node with the highest (rightmost) key. If the dictionary is empty * (that is, dict_isempty(dict) returns 1) a null pointer is returned. */ dnode_t *dict_last(dict_t *dict) { dnode_t *nil = dict_nil(dict), *root = dict_root(dict), *right; if (root != nil) while ((right = root->right) != nil) root = right; return (root == nil) ? NULL : root; } /* * Return the given node's successor node---the node which has the * next key in the the left to right ordering. If the node has * no successor, a null pointer is returned rather than a pointer to * the nil node. */ dnode_t *dict_next(dict_t *dict, dnode_t *curr) { dnode_t *nil = dict_nil(dict), *parent, *left; if (curr->right != nil) { curr = curr->right; while ((left = curr->left) != nil) curr = left; return curr; } parent = curr->parent; while (parent != nil && curr == parent->right) { curr = parent; parent = curr->parent; } return (parent == nil) ? NULL : parent; } /* * Return the given node's predecessor, in the key order. * The nil sentinel node is returned if there is no predecessor. */ dnode_t *dict_prev(dict_t *dict, dnode_t *curr) { dnode_t *nil = dict_nil(dict), *parent, *right; if (curr->left != nil) { curr = curr->left; while ((right = curr->right) != nil) curr = right; return curr; } parent = curr->parent; while (parent != nil && curr == parent->left) { curr = parent; parent = curr->parent; } return (parent == nil) ? NULL : parent; } void dict_allow_dupes(dict_t *dict) { dict->dupes = 1; } #undef dict_count #undef dict_isempty #undef dict_isfull #undef dnode_get #undef dnode_put #undef dnode_getkey dictcount_t dict_count(dict_t *dict) { return dict->nodecount; } int dict_isempty(dict_t *dict) { return dict->nodecount == 0; } int dict_isfull(dict_t *dict) { return dict->nodecount == dict->maxcount; } int dict_contains(dict_t *dict, dnode_t *node) { return verify_dict_has_node(dict_nil(dict), dict_root(dict), node); } static dnode_t *dnode_alloc(void *context) { return (dnode_t *)malloc(sizeof *dnode_alloc(NULL)); } static void dnode_free(dnode_t *node, void *context) { free(node); } dnode_t *dnode_create(void *data) { dnode_t *_new = (dnode_t *)malloc(sizeof *_new); if (_new) { _new->data = data; _new->parent = NULL; _new->left = NULL; _new->right = NULL; } return _new; } dnode_t *dnode_init(dnode_t *dnode, void *data) { dnode->data = data; dnode->parent = NULL; dnode->left = NULL; dnode->right = NULL; return dnode; } void dnode_destroy(dnode_t *dnode) { assert (!dnode_is_in_a_dict(dnode)); free(dnode); } void *dnode_get(dnode_t *dnode) { return dnode->data; } const void *dnode_getkey(dnode_t *dnode) { return dnode->key; } void dnode_put(dnode_t *dnode, void *data) { dnode->data = data; } int dnode_is_in_a_dict(dnode_t *dnode) { return (dnode->parent && dnode->left && dnode->right); } void dict_process(dict_t *dict, void *context, dnode_process_t function) { dnode_t *node = dict_first(dict), *next; while (node != NULL) { /* check for callback function deleting */ /* the next node from under us */ assert (dict_contains(dict, node)); next = dict_next(dict, node); function(dict, node, context); node = next; } } static void load_begin_internal(dict_load_t *load, dict_t *dict) { load->dictptr = dict; load->nilnode.left = &load->nilnode; load->nilnode.right = &load->nilnode; } void dict_load_begin(dict_load_t *load, dict_t *dict) { assert (dict_isempty(dict)); load_begin_internal(load, dict); } void dict_load_next(dict_load_t *load, dnode_t *newnode, const void *key) { dict_t *dict = load->dictptr; dnode_t *nil = &load->nilnode; assert (!dnode_is_in_a_dict(newnode)); assert (dict->nodecount < dict->maxcount); #ifndef NDEBUG if (dict->nodecount > 0) { if (dict->dupes) assert (dict->compare(nil->left->key, key) <= 0); else assert (dict->compare(nil->left->key, key) < 0); } #endif newnode->key = key; nil->right->left = newnode; nil->right = newnode; newnode->left = nil; dict->nodecount++; } void dict_load_end(dict_load_t *load) { dict_t *dict = load->dictptr; dnode_t *tree[DICT_DEPTH_MAX] = { 0 }; dnode_t *curr, *dictnil = dict_nil(dict), *loadnil = &load->nilnode, *next; dnode_t *complete = 0; dictcount_t fullcount = DICTCOUNT_T_MAX, nodecount = dict->nodecount; dictcount_t botrowcount; unsigned baselevel = 0, level = 0, i; assert (dnode_red == 0 && dnode_black == 1); while (fullcount >= nodecount && fullcount) fullcount >>= 1; botrowcount = nodecount - fullcount; for (curr = loadnil->left; curr != loadnil; curr = next) { next = curr->left; if (complete == NULL && botrowcount-- == 0) { assert (baselevel == 0); assert (level == 0); baselevel = level = 1; complete = tree[0]; if (complete != 0) { tree[0] = 0; complete->right = dictnil; while (tree[level] != 0) { tree[level]->right = complete; complete->parent = tree[level]; complete = tree[level]; tree[level++] = 0; } } } if (complete == NULL) { curr->left = dictnil; curr->right = dictnil; curr->color = (dnode_color_t)(level % 2); complete = curr; assert (level == baselevel); while (tree[level] != 0) { tree[level]->right = complete; complete->parent = tree[level]; complete = tree[level]; tree[level++] = 0; } } else { curr->left = complete; curr->color = (dnode_color_t)((level + 1) % 2); complete->parent = curr; tree[level] = curr; complete = 0; level = baselevel; } } if (complete == NULL) complete = dictnil; for (i = 0; i < DICT_DEPTH_MAX; i++) { if (tree[i] != 0) { tree[i]->right = complete; complete->parent = tree[i]; complete = tree[i]; } } dictnil->color = dnode_black; dictnil->right = dictnil; complete->parent = dictnil; complete->color = dnode_black; dict_root(dict) = complete; assert (dict_verify(dict)); } void dict_merge(dict_t *dest, dict_t *source) { dict_load_t load; dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source); assert (dict_similar(dest, source)); if (source == dest) return; dest->nodecount = 0; load_begin_internal(&load, dest); for (;;) { if (leftnode != NULL && rightnode != NULL) { if (dest->compare(leftnode->key, rightnode->key) < 0) goto copyleft; else goto copyright; } else if (leftnode != NULL) { goto copyleft; } else if (rightnode != NULL) { goto copyright; } else { assert (leftnode == NULL && rightnode == NULL); break; } copyleft: { dnode_t *next = dict_next(dest, leftnode); #ifndef NDEBUG leftnode->left = NULL; /* suppress assertion in dict_load_next */ #endif dict_load_next(&load, leftnode, leftnode->key); leftnode = next; continue; } copyright: { dnode_t *next = dict_next(source, rightnode); #ifndef NDEBUG rightnode->left = NULL; #endif dict_load_next(&load, rightnode, rightnode->key); rightnode = next; continue; } } dict_clear(source); dict_load_end(&load); } #ifdef KAZLIB_TEST_MAIN #include #include #include #include typedef char input_t[256]; static int tokenize(char *string, ...) { char **tokptr; va_list arglist; int tokcount = 0; va_start(arglist, string); tokptr = va_arg(arglist, char **); while (tokptr) { while (*string && isspace((unsigned char) *string)) string++; if (!*string) break; *tokptr = string; while (*string && !isspace((unsigned char) *string)) string++; tokptr = va_arg(arglist, char **); tokcount++; if (!*string) break; *string++ = 0; } va_end(arglist); return tokcount; } static int comparef(const void *key1, const void *key2) { return strcmp(key1, key2); } static char *dupstring(char *str) { int sz = strlen(str) + 1; char *_new = malloc(sz); if (_new) memcpy(_new, str, sz); return _new; } static dnode_t *new_node(void *c) { static dnode_t few[5]; static int count; if (count < 5) return few + count++; return NULL; } static void del_node(dnode_t *n, void *c) { } static int prompt = 0; static void construct(dict_t *d) { input_t in; int done = 0; dict_load_t dl; dnode_t *dn; char *tok1, *tok2, *val; const char *key; char *help = "p turn prompt on\n" "q finish construction\n" "a add new entry\n"; if (!dict_isempty(d)) puts("warning: dictionary not empty!"); dict_load_begin(&dl, d); while (!done) { if (prompt) putchar('>'); fflush(stdout); if (!fgets(in, sizeof(input_t), stdin)) break; switch (in[0]) { case '?': puts(help); break; case 'p': prompt = 1; break; case 'q': done = 1; break; case 'a': if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) { puts("what?"); break; } key = dupstring(tok1); val = dupstring(tok2); dn = dnode_create(val); if (!key || !val || !dn) { puts("out of memory"); free((void *) key); free(val); if (dn) dnode_destroy(dn); } dict_load_next(&dl, dn, key); break; default: putchar('?'); putchar('\n'); break; } } dict_load_end(&dl); } int main(void) { input_t in; dict_t darray[10]; dict_t *d = &darray[0]; dnode_t *dn; int i; char *tok1, *tok2, *val; const char *key; char *help = "a add value to dictionary\n" "d delete value from dictionary\n" "l lookup value in dictionary\n" "( lookup lower bound\n" ") lookup upper bound\n" "# switch to alternate dictionary (0-9)\n" "j merge two dictionaries\n" "f free the whole dictionary\n" "k allow duplicate keys\n" "c show number of entries\n" "t dump whole dictionary in sort order\n" "m make dictionary out of sorted items\n" "p turn prompt on\n" "s switch to non-functioning allocator\n" "q quit"; for (i = 0; i < sizeof darray / sizeof *darray; i++) dict_init(&darray[i], DICTCOUNT_T_MAX, comparef); for (;;) { if (prompt) putchar('>'); fflush(stdout); if (!fgets(in, sizeof(input_t), stdin)) break; switch(in[0]) { case '?': puts(help); break; case 'a': if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) { puts("what?"); break; } key = dupstring(tok1); val = dupstring(tok2); if (!key || !val) { puts("out of memory"); free((void *) key); free(val); } if (!dict_alloc_insert(d, key, val)) { puts("dict_alloc_insert failed"); free((void *) key); free(val); break; } break; case 'd': if (tokenize(in+1, &tok1, (char **) 0) != 1) { puts("what?"); break; } dn = dict_lookup(d, tok1); if (!dn) { puts("dict_lookup failed"); break; } val = dnode_get(dn); key = dnode_getkey(dn); dict_delete_free(d, dn); free(val); free((void *) key); break; case 'f': dict_free(d); break; case 'l': case '(': case ')': if (tokenize(in+1, &tok1, (char **) 0) != 1) { puts("what?"); break; } dn = 0; switch (in[0]) { case 'l': dn = dict_lookup(d, tok1); break; case '(': dn = dict_lower_bound(d, tok1); break; case ')': dn = dict_upper_bound(d, tok1); break; } if (!dn) { puts("lookup failed"); break; } val = dnode_get(dn); puts(val); break; case 'm': construct(d); break; case 'k': dict_allow_dupes(d); break; case 'c': printf("%lu\n", (unsigned long) dict_count(d)); break; case 't': for (dn = dict_first(d); dn; dn = dict_next(d, dn)) { printf("%s\t%s\n", (char *) dnode_getkey(dn), (char *) dnode_get(dn)); } break; case 'q': exit(0); break; case '\0': break; case 'p': prompt = 1; break; case 's': dict_set_allocator(d, new_node, del_node, NULL); break; case '#': if (tokenize(in+1, &tok1, (char **) 0) != 1) { puts("what?"); break; } else { int dictnum = atoi(tok1); if (dictnum < 0 || dictnum > 9) { puts("invalid number"); break; } d = &darray[dictnum]; } break; case 'j': if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) { puts("what?"); break; } else { int dict1 = atoi(tok1), dict2 = atoi(tok2); if (dict1 < 0 || dict1 > 9 || dict2 < 0 || dict2 > 9) { puts("invalid number"); break; } dict_merge(&darray[dict1], &darray[dict2]); } break; default: putchar('?'); putchar('\n'); break; } } return 0; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/bin.cpp0000644000175000017500000000104110064121655024560 0ustar debiandebian/*****************************************************************************\ * * bin.cc -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: bin.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include #include #ifndef WIN32 #include #endif #include "bin.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/utilities.h0000644000175000017500000000576010352632600025501 0ustar debiandebian/*****************************************************************************\ * * utilities.h -- some utility functions & macros * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: utilities.h,v 1.3 2005/12/22 23:23:44 annao Exp $ #ifndef __UTILITIES_H #define __UTILITIES_H #include #include #include #include #include "basic.h" /*****************************************************************************\ * doc \*****************************************************************************/ //@Man: Utilities //@Memo: Miscellaneous utility functions //@Doc: Miscellaneous utility functions. //@{ /*****************************************************************************\ * Misc \*****************************************************************************/ //@ManDoc: Issue a warning message. void warning( const char *msg ); //@ManDoc: Print an error message and exit. void panic( const char *msg ); //@ManDoc: Initialize random numebr generator (based on current clock). void initrand( void ); //@ManDoc: Print date, time, host. void run_stamp( char *msg, int sz ); /*****************************************************************************\ * read gzip'ed files \*****************************************************************************/ class gzifstream: public std::ifstream { public: //@ManDoc: Default c'tor gzifstream(); /*@ManDoc: Open file #name# for reading. If the file name ends with a ".gz" extension, it is assumed to be a gzip'ed file and will be piped through zcat */ gzifstream(const char* name); //@ManDoc: D'tor ~gzifstream(); //@ManDoc: Open file #name# for reading. void open(const char* name); private: int gzopen(const char* name); int gzclose(); bool pipe; FILE* fp; }; /*****************************************************************************\ * timing \*****************************************************************************/ //@ManDoc: Time elapsed between two instants of time. double diffclock( clock_t t2, clock_t t1 ); /*****************************************************************************\ * brakes !! (used to stop execution) \*****************************************************************************/ //@ManDoc: When a -c is hit, the variable brakes is set to true. extern bool brakes; //@ManDoc: Initialize #brake#. void brake_init( void ); /*****************************************************************************\ * Check Bool condition \*****************************************************************************/ //@ManDoc: Check Boolean condition. void check( int cond, const char *msg ); //@ManDoc: Reset check counter. void check_reset( void ); //@ManDoc: Return number of failed checks. int check_count( void ); //@} #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/cubes.cpp0000644000175000017500000007256510064121655025134 0ustar debiandebian/* * cubes.cpp - marching cubes table of cubes and associated tables * this file has been automatically generated * DO NOT EDIT * Copyright (c) 1997 Dan Schikore */ // $Id: cubes.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include "contour.h" /* table of intersected edges (complete with holes) */ u_char cubes[256][14] = { {0}, {1, 0, 3, 8}, {1, 9, 1, 0}, {2, 1, 3, 8, 1, 8, 9}, {1, 1, 11, 2}, {2, 0, 3, 8, 1, 11, 2}, {2, 9, 11, 2, 9, 2, 0}, {3, 2, 3, 11, 3, 8, 11, 11, 8, 9}, {1, 2, 10, 3}, {2, 0, 2, 10, 0, 10, 8}, {2, 3, 2, 10, 0, 9, 1}, {3, 1, 2, 9, 2, 10, 9, 9, 10, 8}, {2, 3, 1, 11, 3, 11, 10}, {3, 0, 1, 8, 1, 11, 8, 8, 11, 10}, {3, 3, 0, 10, 0, 9, 10, 10, 9, 11}, {2, 10, 8, 9, 10, 9, 11}, {1, 4, 8, 7}, {2, 3, 7, 4, 3, 4, 0}, {2, 4, 8, 7, 9, 1, 0}, {3, 4, 9, 7, 9, 1, 7, 7, 1, 3}, {2, 4, 8, 7, 2, 1, 11}, {3, 3, 7, 4, 3, 4, 0, 11, 2, 1}, {3, 9, 11, 2, 9, 2, 0, 7, 4, 8}, {4, 3, 7, 4, 3, 4, 9, 2, 3, 9, 11, 2, 9}, {2, 8, 7, 4, 3, 2, 10}, {3, 10, 7, 2, 7, 4, 2, 2, 4, 0}, {3, 1, 0, 9, 8, 7, 4, 2, 10, 3}, {4, 10, 7, 4, 10, 4, 2, 2, 4, 9, 2, 9, 1}, {3, 3, 1, 11, 3, 11, 10, 4, 8, 7}, {4, 1, 11, 10, 1, 10, 0, 0, 10, 7, 0, 7, 4}, {4, 4, 9, 7, 7, 9, 10, 9, 11, 10, 3, 0, 8}, {3, 4, 9, 7, 7, 9, 10, 9, 11, 10}, {1, 5, 9, 4}, {2, 8, 0, 3, 4, 5, 9}, {2, 5, 1, 0, 5, 0, 4}, {3, 8, 4, 3, 4, 5, 3, 3, 5, 1}, {2, 1, 11, 2, 9, 4, 5}, {3, 5, 9, 4, 0, 3, 8, 11, 2, 1}, {3, 5, 11, 4, 11, 2, 4, 4, 2, 0}, {4, 2, 5, 11, 2, 3, 5, 3, 4, 5, 3, 8, 4}, {2, 2, 10, 3, 4, 5, 9}, {3, 0, 2, 10, 0, 10, 8, 5, 9, 4}, {3, 0, 4, 5, 0, 5, 1, 10, 3, 2}, {4, 2, 10, 8, 2, 8, 1, 1, 8, 4, 1, 4, 5}, {3, 11, 10, 3, 11, 3, 1, 4, 5, 9}, {4, 0, 1, 8, 1, 11, 8, 8, 11, 10, 5, 9, 4}, {4, 10, 5, 11, 10, 4, 5, 3, 4, 10, 0, 4, 3}, {3, 5, 11, 4, 4, 11, 8, 11, 10, 8}, {2, 7, 5, 9, 7, 9, 8}, {3, 9, 0, 5, 0, 3, 5, 5, 3, 7}, {3, 0, 8, 1, 8, 7, 1, 1, 7, 5}, {2, 3, 7, 5, 3, 5, 1}, {3, 9, 8, 7, 9, 7, 5, 2, 1, 11}, {4, 9, 0, 5, 0, 3, 5, 5, 3, 7, 2, 1, 11}, {4, 11, 2, 0, 11, 0, 5, 5, 0, 8, 5, 8, 7}, {3, 2, 3, 11, 11, 3, 5, 3, 7, 5}, {3, 7, 5, 9, 7, 9, 8, 2, 10, 3}, {4, 0, 2, 10, 0, 10, 7, 9, 0, 7, 5, 9, 7}, {4, 0, 8, 1, 8, 7, 1, 1, 7, 5, 10, 3, 2}, {3, 10, 7, 2, 2, 7, 1, 7, 5, 1}, {4, 1, 11, 10, 1, 10, 3, 7, 5, 9, 7, 9, 8}, {3, 5, 10, 7, 5, 11, 10, 0, 1, 9}, {3, 10, 5, 11, 10, 7, 5, 0, 8, 3}, {2, 5, 10, 7, 5, 11, 10}, {1, 11, 5, 6}, {2, 0, 3, 8, 6, 11, 5}, {2, 9, 1, 0, 5, 6, 11}, {3, 1, 3, 8, 1, 8, 9, 6, 11, 5}, {2, 6, 2, 1, 6, 1, 5}, {3, 1, 5, 6, 1, 6, 2, 8, 0, 3}, {3, 9, 5, 0, 5, 6, 0, 0, 6, 2}, {4, 3, 6, 2, 3, 8, 6, 8, 5, 6, 8, 9, 5}, {2, 2, 10, 3, 11, 5, 6}, {3, 10, 8, 0, 10, 0, 2, 5, 6, 11}, {3, 6, 11, 5, 1, 0, 9, 10, 3, 2}, {4, 1, 2, 9, 2, 10, 9, 9, 10, 8, 6, 11, 5}, {3, 6, 10, 5, 10, 3, 5, 5, 3, 1}, {4, 8, 6, 10, 8, 5, 6, 0, 5, 8, 1, 5, 0}, {4, 3, 6, 10, 3, 0, 6, 0, 5, 6, 0, 9, 5}, {3, 6, 10, 5, 5, 10, 9, 10, 8, 9}, {2, 7, 4, 8, 6, 11, 5}, {3, 4, 0, 3, 4, 3, 7, 11, 5, 6}, {3, 7, 4, 8, 9, 1, 0, 6, 11, 5}, {4, 4, 9, 7, 9, 1, 7, 7, 1, 3, 11, 5, 6}, {3, 6, 2, 1, 6, 1, 5, 8, 7, 4}, {4, 6, 3, 7, 6, 2, 3, 0, 5, 4, 0, 1, 5}, {4, 7, 6, 8, 8, 6, 0, 6, 2, 0, 9, 5, 4}, {3, 7, 2, 3, 7, 6, 2, 9, 5, 4}, {3, 8, 7, 4, 6, 11, 5, 3, 2, 10}, {4, 10, 7, 2, 7, 4, 2, 2, 4, 0, 5, 6, 11}, {4, 0, 8, 3, 7, 6, 10, 11, 1, 2, 4, 9, 5}, {3, 4, 9, 5, 11, 1, 2, 7, 6, 10}, {4, 6, 10, 5, 10, 3, 5, 5, 3, 1, 8, 7, 4}, {3, 5, 0, 1, 5, 4, 0, 10, 7, 6}, {3, 3, 0, 8, 4, 9, 5, 10, 7, 6}, {2, 6, 10, 7, 5, 4, 9}, {2, 4, 6, 11, 4, 11, 9}, {3, 4, 6, 11, 4, 11, 9, 3, 8, 0}, {3, 11, 1, 6, 1, 0, 6, 6, 0, 4}, {4, 4, 6, 11, 4, 11, 1, 8, 4, 1, 3, 8, 1}, {3, 1, 9, 2, 9, 4, 2, 2, 4, 6}, {4, 1, 9, 2, 9, 4, 2, 2, 4, 6, 8, 0, 3}, {2, 2, 0, 4, 2, 4, 6}, {3, 8, 4, 3, 3, 4, 2, 4, 6, 2}, {3, 11, 9, 4, 11, 4, 6, 3, 2, 10}, {4, 2, 10, 8, 2, 8, 0, 4, 6, 11, 4, 11, 9}, {4, 3, 0, 10, 10, 0, 6, 0, 4, 6, 11, 1, 2}, {3, 6, 8, 4, 6, 10, 8, 1, 2, 11}, {4, 9, 3, 1, 9, 4, 3, 4, 10, 3, 4, 6, 10}, {3, 8, 6, 10, 8, 4, 6, 1, 9, 0}, {3, 3, 0, 10, 10, 0, 6, 0, 4, 6}, {2, 6, 8, 4, 6, 10, 8}, {3, 7, 6, 8, 6, 11, 8, 8, 11, 9}, {4, 0, 3, 7, 0, 7, 9, 9, 7, 6, 9, 6, 11}, {4, 7, 0, 8, 7, 6, 0, 6, 1, 0, 6, 11, 1}, {3, 11, 1, 6, 6, 1, 7, 1, 3, 7}, {4, 9, 8, 7, 9, 7, 6, 1, 9, 6, 2, 1, 6}, {3, 2, 7, 6, 2, 3, 7, 9, 0, 1}, {3, 7, 6, 8, 8, 6, 0, 6, 2, 0}, {2, 7, 2, 3, 7, 6, 2}, {4, 2, 11, 3, 3, 11, 8, 11, 9, 8, 7, 6, 10}, {3, 2, 9, 0, 2, 11, 9, 7, 6, 10}, {3, 0, 8, 3, 10, 7, 6, 1, 2, 11}, {2, 10, 7, 6, 2, 11, 1}, {3, 8, 1, 9, 8, 3, 1, 6, 10, 7}, {2, 6, 10, 7, 0, 1, 9}, {2, 7, 6, 10, 8, 3, 0}, {1, 6, 10, 7}, {1, 6, 7, 10}, {2, 7, 10, 6, 8, 0, 3}, {2, 6, 7, 10, 0, 9, 1}, {3, 8, 9, 1, 8, 1, 3, 6, 7, 10}, {2, 10, 6, 7, 2, 1, 11}, {3, 0, 3, 8, 10, 6, 7, 1, 11, 2}, {3, 2, 0, 9, 2, 9, 11, 7, 10, 6}, {4, 2, 3, 11, 3, 8, 11, 11, 8, 9, 7, 10, 6}, {2, 7, 3, 2, 7, 2, 6}, {3, 7, 8, 6, 8, 0, 6, 6, 0, 2}, {3, 2, 6, 7, 2, 7, 3, 9, 1, 0}, {4, 9, 7, 8, 9, 6, 7, 1, 6, 9, 2, 6, 1}, {3, 11, 6, 1, 6, 7, 1, 1, 7, 3}, {4, 7, 8, 0, 7, 0, 6, 6, 0, 1, 6, 1, 11}, {4, 0, 7, 3, 0, 9, 7, 9, 6, 7, 9, 11, 6}, {3, 7, 8, 6, 6, 8, 11, 8, 9, 11}, {2, 6, 4, 8, 6, 8, 10}, {3, 3, 10, 0, 10, 6, 0, 0, 6, 4}, {3, 8, 10, 6, 8, 6, 4, 1, 0, 9}, {4, 9, 1, 3, 9, 3, 4, 4, 3, 10, 4, 10, 6}, {3, 6, 4, 8, 6, 8, 10, 1, 11, 2}, {4, 3, 10, 0, 10, 6, 0, 0, 6, 4, 11, 2, 1}, {4, 2, 8, 10, 2, 0, 8, 4, 11, 6, 4, 9, 11}, {3, 11, 4, 9, 11, 6, 4, 3, 10, 2}, {3, 8, 3, 4, 3, 2, 4, 4, 2, 6}, {2, 2, 4, 0, 2, 6, 4}, {4, 1, 2, 9, 9, 2, 4, 2, 6, 4, 8, 3, 0}, {3, 1, 2, 9, 9, 2, 4, 2, 6, 4}, {4, 4, 11, 6, 4, 1, 11, 8, 1, 4, 3, 1, 8}, {3, 11, 6, 1, 1, 6, 0, 6, 4, 0}, {3, 4, 11, 6, 4, 9, 11, 3, 0, 8}, {2, 4, 11, 6, 4, 9, 11}, {2, 6, 7, 10, 5, 9, 4}, {3, 3, 8, 0, 4, 5, 9, 10, 6, 7}, {3, 5, 1, 0, 5, 0, 4, 10, 6, 7}, {4, 6, 5, 10, 10, 5, 3, 5, 1, 3, 8, 4, 7}, {3, 4, 5, 9, 11, 2, 1, 7, 10, 6}, {4, 0, 3, 8, 7, 10, 6, 11, 2, 1, 4, 5, 9}, {4, 10, 2, 7, 7, 2, 4, 2, 0, 4, 5, 11, 6}, {3, 8, 4, 7, 6, 5, 11, 3, 10, 2}, {3, 7, 3, 2, 7, 2, 6, 9, 4, 5}, {4, 7, 8, 6, 8, 0, 6, 6, 0, 2, 9, 4, 5}, {4, 6, 7, 3, 6, 3, 2, 0, 4, 5, 0, 5, 1}, {3, 6, 1, 2, 6, 5, 1, 8, 4, 7}, {4, 4, 7, 9, 9, 7, 1, 7, 3, 1, 11, 6, 5}, {3, 7, 8, 4, 9, 0, 1, 6, 5, 11}, {3, 4, 3, 0, 4, 7, 3, 11, 6, 5}, {2, 7, 8, 4, 6, 5, 11}, {3, 6, 5, 10, 5, 9, 10, 10, 9, 8}, {4, 3, 10, 6, 3, 6, 0, 0, 6, 5, 0, 5, 9}, {4, 8, 10, 6, 8, 6, 5, 0, 8, 5, 1, 0, 5}, {3, 6, 5, 10, 10, 5, 3, 5, 1, 3}, {4, 1, 9, 2, 2, 9, 10, 9, 8, 10, 6, 5, 11}, {3, 6, 5, 11, 1, 9, 0, 10, 2, 3}, {3, 10, 0, 8, 10, 2, 0, 5, 11, 6}, {2, 2, 3, 10, 11, 6, 5}, {4, 3, 2, 6, 3, 6, 8, 8, 6, 5, 8, 5, 9}, {3, 9, 0, 5, 5, 0, 6, 0, 2, 6}, {3, 1, 6, 5, 1, 2, 6, 8, 3, 0}, {2, 6, 1, 2, 6, 5, 1}, {3, 1, 8, 3, 1, 9, 8, 6, 5, 11}, {2, 9, 0, 1, 5, 11, 6}, {2, 0, 8, 3, 6, 5, 11}, {1, 11, 6, 5}, {2, 5, 7, 10, 5, 10, 11}, {3, 10, 11, 5, 10, 5, 7, 0, 3, 8}, {3, 5, 7, 10, 5, 10, 11, 0, 9, 1}, {4, 1, 10, 11, 1, 3, 10, 7, 9, 5, 7, 8, 9}, {3, 10, 2, 7, 2, 1, 7, 7, 1, 5}, {4, 0, 1, 8, 8, 1, 7, 1, 5, 7, 10, 2, 3}, {4, 0, 10, 2, 0, 7, 10, 9, 7, 0, 5, 7, 9}, {3, 7, 9, 5, 7, 8, 9, 2, 3, 10}, {3, 2, 11, 3, 11, 5, 3, 3, 5, 7}, {4, 11, 0, 2, 11, 5, 0, 5, 8, 0, 5, 7, 8}, {4, 9, 5, 0, 0, 5, 3, 5, 7, 3, 2, 11, 1}, {3, 9, 7, 8, 9, 5, 7, 2, 11, 1}, {2, 3, 5, 7, 3, 1, 5}, {3, 0, 1, 8, 8, 1, 7, 1, 5, 7}, {3, 9, 5, 0, 0, 5, 3, 5, 7, 3}, {2, 7, 9, 5, 7, 8, 9}, {3, 5, 4, 11, 4, 8, 11, 11, 8, 10}, {4, 10, 11, 5, 10, 5, 4, 3, 10, 4, 0, 3, 4}, {4, 0, 8, 1, 1, 8, 11, 8, 10, 11, 5, 4, 9}, {3, 11, 3, 10, 11, 1, 3, 4, 9, 5}, {4, 2, 8, 10, 2, 1, 8, 1, 4, 8, 1, 5, 4}, {3, 0, 5, 4, 0, 1, 5, 10, 2, 3}, {3, 0, 10, 2, 0, 8, 10, 5, 4, 9}, {2, 2, 3, 10, 4, 9, 5}, {4, 2, 11, 5, 2, 5, 3, 3, 5, 4, 3, 4, 8}, {3, 5, 4, 11, 11, 4, 2, 4, 0, 2}, {3, 5, 4, 9, 0, 8, 3, 11, 1, 2}, {2, 1, 2, 11, 9, 5, 4}, {3, 8, 3, 4, 4, 3, 5, 3, 1, 5}, {2, 5, 0, 1, 5, 4, 0}, {2, 8, 3, 0, 4, 9, 5}, {1, 5, 4, 9}, {3, 4, 7, 9, 7, 10, 9, 9, 10, 11}, {4, 4, 7, 9, 7, 10, 9, 9, 10, 11, 3, 8, 0}, {4, 1, 10, 11, 1, 0, 10, 0, 7, 10, 0, 4, 7}, {3, 3, 11, 1, 3, 10, 11, 4, 7, 8}, {4, 10, 4, 7, 10, 2, 4, 2, 9, 4, 2, 1, 9}, {3, 1, 9, 0, 8, 4, 7, 2, 3, 10}, {3, 10, 2, 7, 7, 2, 4, 2, 0, 4}, {2, 8, 4, 7, 3, 10, 2}, {4, 3, 4, 7, 3, 9, 4, 2, 9, 3, 11, 9, 2}, {3, 9, 2, 11, 9, 0, 2, 7, 8, 4}, {3, 3, 4, 7, 3, 0, 4, 11, 1, 2}, {2, 4, 7, 8, 2, 11, 1}, {3, 4, 7, 9, 9, 7, 1, 7, 3, 1}, {2, 4, 7, 8, 9, 0, 1}, {2, 3, 4, 7, 3, 0, 4}, {1, 4, 7, 8}, {2, 10, 9, 8, 10, 11, 9}, {3, 3, 10, 0, 0, 10, 9, 10, 11, 9}, {3, 0, 8, 1, 1, 8, 11, 8, 10, 11}, {2, 3, 11, 1, 3, 10, 11}, {3, 1, 9, 2, 2, 9, 10, 9, 8, 10}, {2, 3, 10, 2, 0, 1, 9}, {2, 0, 10, 2, 0, 8, 10}, {1, 2, 3, 10}, {3, 2, 11, 3, 3, 11, 8, 11, 9, 8}, {2, 9, 2, 11, 9, 0, 2}, {2, 0, 8, 3, 1, 2, 11}, {1, 1, 2, 11}, {2, 1, 8, 3, 1, 9, 8}, {1, 9, 0, 1}, {1, 0, 8, 3}, {0}, }; /* table of adjacent faces to visit in contour propagation */ u_char adjfaces[256][7] = { {0}, {3, 0, 1, 5}, {3, 3, 0, 5}, {4, 0, 1, 3, 5}, {3, 3, 4, 0}, {5, 0, 1, 3, 4, 5}, {4, 3, 4, 5, 0}, {5, 4, 1, 5, 3, 0}, {3, 4, 1, 0}, {4, 0, 4, 5, 1}, {5, 0, 4, 5, 3, 1}, {5, 3, 4, 1, 5, 0}, {4, 0, 3, 1, 4}, {5, 5, 3, 4, 1, 0}, {5, 1, 5, 3, 4, 0}, {4, 4, 1, 5, 3}, {3, 5, 1, 2}, {4, 1, 2, 0, 5}, {5, 5, 1, 3, 0, 2}, {5, 2, 3, 0, 1, 5}, {6, 5, 1, 4, 3, 0, 2}, {6, 1, 2, 3, 0, 4, 5}, {6, 3, 4, 1, 5, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {5, 1, 2, 0, 4, 5}, {5, 4, 2, 5, 0, 1}, {6, 1, 4, 3, 5, 0, 2}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 3, 2, 1, 5, 4}, {6, 3, 4, 1, 5, 2, 0}, {6, 5, 1, 4, 3, 0, 2}, {5, 5, 1, 4, 3, 2}, {3, 3, 5, 2}, {5, 5, 0, 2, 3, 1}, {4, 3, 0, 2, 5}, {5, 1, 2, 3, 0, 5}, {5, 3, 4, 5, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 2, 4, 0, 5, 3}, {6, 0, 4, 2, 5, 3, 1}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {6, 5, 2, 4, 0, 1, 3}, {6, 4, 1, 5, 3, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {6, 5, 3, 4, 1, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 3, 5, 1, 4, 2}, {4, 2, 3, 1, 5}, {5, 3, 0, 1, 2, 5}, {5, 0, 1, 2, 3, 5}, {4, 0, 1, 2, 3}, {6, 5, 1, 4, 3, 0, 2}, {6, 3, 0, 1, 2, 4, 5}, {6, 4, 0, 5, 2, 1, 3}, {5, 0, 3, 2, 1, 4}, {6, 2, 3, 0, 1, 4, 5}, {6, 3, 0, 1, 2, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {5, 1, 0, 3, 2, 4}, {6, 0, 4, 2, 5, 3, 1}, {6, 2, 1, 0, 3, 5, 4}, {6, 4, 3, 5, 1, 0, 2}, {4, 2, 1, 3, 4}, {3, 3, 2, 4}, {6, 0, 1, 2, 3, 4, 5}, {5, 3, 0, 2, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {4, 4, 0, 2, 3}, {6, 3, 2, 1, 0, 5, 4}, {5, 5, 2, 4, 0, 3}, {6, 0, 4, 2, 5, 3, 1}, {5, 4, 1, 3, 2, 0}, {6, 1, 5, 3, 4, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {6, 3, 4, 1, 5, 2, 0}, {5, 2, 1, 0, 3, 4}, {6, 0, 1, 2, 3, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {5, 4, 3, 5, 1, 2}, {5, 2, 5, 4, 3, 1}, {6, 5, 0, 4, 2, 3, 1}, {6, 3, 4, 1, 5, 2, 0}, {6, 2, 3, 0, 1, 4, 5}, {6, 4, 0, 5, 2, 1, 3}, {6, 4, 1, 5, 3, 2, 0}, {6, 2, 5, 0, 4, 3, 1}, {6, 1, 0, 3, 2, 5, 4}, {6, 4, 0, 5, 2, 1, 3}, {6, 4, 2, 5, 0, 3, 1}, {6, 0, 1, 2, 3, 4, 5}, {6, 4, 1, 5, 3, 2, 0}, {6, 2, 1, 0, 3, 5, 4}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 4, 0, 5, 1, 3}, {5, 2, 1, 3, 5, 4}, {4, 2, 4, 5, 3}, {6, 2, 4, 0, 5, 1, 3}, {5, 4, 0, 5, 2, 3}, {6, 1, 2, 3, 0, 4, 5}, {5, 0, 5, 2, 4, 3}, {6, 0, 5, 2, 4, 1, 3}, {4, 4, 0, 5, 2}, {5, 5, 0, 4, 2, 1}, {6, 3, 5, 1, 4, 0, 2}, {6, 0, 1, 2, 3, 4, 5}, {6, 0, 4, 2, 5, 3, 1}, {6, 2, 5, 0, 4, 3, 1}, {6, 3, 0, 1, 2, 4, 5}, {6, 1, 4, 3, 5, 0, 2}, {5, 0, 4, 2, 5, 1}, {4, 2, 5, 4, 1}, {5, 1, 4, 3, 5, 2}, {6, 0, 1, 2, 3, 4, 5}, {6, 2, 1, 0, 3, 5, 4}, {5, 3, 2, 1, 0, 4}, {6, 0, 5, 2, 4, 1, 3}, {6, 4, 2, 5, 0, 3, 1}, {5, 2, 5, 0, 4, 1}, {4, 1, 0, 2, 4}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 5, 2, 4, 1, 3}, {6, 4, 3, 5, 1, 0, 2}, {5, 4, 2, 0, 3, 1}, {6, 5, 3, 4, 1, 2, 0}, {6, 2, 1, 0, 3, 5, 4}, {5, 1, 4, 5, 0, 2}, {3, 2, 1, 4}, {3, 2, 1, 4}, {5, 1, 4, 5, 0, 2}, {6, 2, 1, 0, 3, 5, 4}, {6, 5, 3, 4, 1, 2, 0}, {5, 4, 2, 0, 3, 1}, {6, 4, 3, 5, 1, 0, 2}, {6, 0, 5, 2, 4, 1, 3}, {6, 4, 1, 5, 3, 2, 0}, {4, 1, 0, 2, 4}, {5, 2, 5, 0, 4, 1}, {6, 4, 2, 5, 0, 3, 1}, {6, 0, 5, 2, 4, 1, 3}, {5, 3, 2, 1, 0, 4}, {6, 2, 1, 0, 3, 5, 4}, {6, 0, 1, 2, 3, 4, 5}, {5, 1, 4, 3, 5, 2}, {4, 2, 5, 4, 1}, {5, 0, 4, 2, 5, 1}, {6, 1, 4, 3, 5, 0, 2}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 5, 0, 4, 3, 1}, {6, 0, 4, 2, 5, 3, 1}, {6, 0, 1, 2, 3, 4, 5}, {6, 3, 5, 1, 4, 0, 2}, {5, 5, 0, 4, 2, 1}, {4, 4, 0, 5, 2}, {6, 0, 5, 2, 4, 1, 3}, {5, 0, 5, 2, 4, 3}, {6, 1, 2, 3, 0, 4, 5}, {5, 4, 0, 5, 2, 3}, {6, 2, 4, 0, 5, 1, 3}, {4, 2, 4, 5, 3}, {5, 2, 1, 3, 5, 4}, {6, 2, 4, 0, 5, 1, 3}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 1, 0, 3, 5, 4}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {6, 4, 2, 5, 0, 3, 1}, {6, 4, 0, 5, 2, 1, 3}, {6, 1, 0, 3, 2, 5, 4}, {6, 2, 5, 0, 4, 3, 1}, {6, 4, 1, 5, 3, 2, 0}, {6, 4, 0, 5, 2, 1, 3}, {6, 2, 3, 0, 1, 4, 5}, {6, 3, 4, 1, 5, 2, 0}, {6, 5, 0, 4, 2, 3, 1}, {5, 2, 5, 4, 3, 1}, {5, 4, 3, 5, 1, 2}, {6, 0, 1, 2, 3, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {5, 2, 1, 0, 3, 4}, {6, 3, 4, 1, 5, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {6, 1, 5, 3, 4, 2, 0}, {5, 4, 1, 3, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 5, 2, 4, 0, 3}, {6, 3, 2, 1, 0, 5, 4}, {4, 4, 0, 2, 3}, {6, 0, 1, 2, 3, 4, 5}, {5, 3, 0, 2, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {3, 3, 2, 4}, {4, 2, 1, 3, 4}, {6, 4, 3, 5, 1, 0, 2}, {6, 2, 1, 0, 3, 5, 4}, {6, 0, 4, 2, 5, 3, 1}, {5, 1, 0, 3, 2, 4}, {6, 0, 1, 2, 3, 4, 5}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 3, 0, 1, 4, 5}, {5, 0, 3, 2, 1, 4}, {6, 4, 0, 5, 2, 1, 3}, {6, 3, 0, 1, 2, 4, 5}, {6, 5, 1, 4, 3, 0, 2}, {4, 0, 1, 2, 3}, {5, 0, 1, 2, 3, 5}, {5, 3, 0, 1, 2, 5}, {4, 2, 3, 1, 5}, {5, 3, 5, 1, 4, 2}, {6, 0, 4, 2, 5, 3, 1}, {6, 5, 3, 4, 1, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {6, 5, 2, 4, 0, 1, 3}, {6, 0, 4, 2, 5, 3, 1}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 2, 4, 0, 5, 3}, {6, 0, 4, 2, 5, 3, 1}, {5, 3, 4, 5, 2, 0}, {5, 1, 2, 3, 0, 5}, {4, 3, 0, 2, 5}, {5, 5, 0, 2, 3, 1}, {3, 3, 5, 2}, {5, 5, 1, 4, 3, 2}, {6, 5, 1, 4, 3, 0, 2}, {6, 3, 4, 1, 5, 2, 0}, {6, 0, 3, 2, 1, 5, 4}, {6, 4, 1, 5, 3, 2, 0}, {6, 1, 4, 3, 5, 0, 2}, {5, 4, 2, 5, 0, 1}, {5, 1, 2, 0, 4, 5}, {6, 4, 1, 5, 3, 2, 0}, {6, 3, 4, 1, 5, 2, 0}, {6, 1, 2, 3, 0, 4, 5}, {6, 5, 1, 4, 3, 0, 2}, {5, 2, 3, 0, 1, 5}, {5, 5, 1, 3, 0, 2}, {4, 1, 2, 0, 5}, {3, 5, 1, 2}, {4, 4, 1, 5, 3}, {5, 1, 5, 3, 4, 0}, {5, 5, 3, 4, 1, 0}, {4, 0, 3, 1, 4}, {5, 3, 4, 1, 5, 0}, {5, 0, 4, 5, 3, 1}, {4, 0, 4, 5, 1}, {3, 4, 1, 0}, {5, 4, 1, 5, 3, 0}, {4, 3, 4, 5, 0}, {5, 0, 1, 3, 4, 5}, {3, 3, 4, 0}, {4, 0, 1, 3, 5}, {3, 3, 0, 5}, {3, 0, 1, 5}, {0}, }; /* table of cube vertices involved in triangulation */ u_char cubeverts[256][9] = { {0}, {4, 0, 1, 3, 4}, {4, 1, 5, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {4, 2, 1, 6, 3}, {6, 0, 1, 2, 3, 4, 6}, {6, 2, 1, 5, 6, 3, 0}, {7, 3, 2, 6, 0, 1, 5, 4}, {4, 3, 2, 7, 0}, {6, 3, 0, 1, 2, 7, 4}, {6, 3, 0, 1, 2, 7, 5}, {7, 2, 1, 5, 3, 0, 4, 7}, {6, 2, 3, 0, 1, 6, 7}, {7, 1, 0, 4, 2, 3, 7, 6}, {7, 0, 3, 7, 1, 2, 6, 5}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {4, 4, 5, 0, 7}, {6, 4, 0, 3, 7, 5, 1}, {6, 4, 5, 1, 0, 7, 2}, {7, 5, 4, 7, 1, 0, 3, 2}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {6, 4, 0, 3, 7, 5, 2}, {7, 7, 3, 2, 4, 0, 1, 5}, {7, 7, 4, 0, 3, 5, 1, 2}, {7, 3, 2, 7, 0, 1, 5, 4}, {8, 2, 3, 0, 1, 6, 7, 4, 5}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {7, 4, 5, 1, 7, 6, 2, 3}, {4, 5, 6, 1, 4}, {6, 0, 4, 5, 1, 3, 6}, {6, 1, 5, 6, 2, 0, 4}, {7, 4, 0, 3, 5, 1, 2, 6}, {6, 2, 1, 5, 6, 3, 4}, {7, 3, 0, 1, 2, 4, 5, 6}, {7, 6, 5, 4, 2, 1, 0, 3}, {7, 3, 0, 2, 7, 4, 5, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 5, 1, 0, 4, 6, 2, 3, 7}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {7, 5, 6, 2, 4, 7, 3, 0}, {6, 5, 4, 7, 6, 1, 0}, {7, 1, 5, 6, 0, 4, 7, 3}, {7, 0, 1, 2, 4, 5, 6, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {7, 2, 3, 0, 6, 7, 4, 5}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 3, 7, 4, 2, 6, 5, 1}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 6, 7, 3, 2, 5, 4, 0, 1}, {6, 7, 6, 5, 4, 3, 2}, {4, 6, 2, 5, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {6, 1, 5, 6, 2, 0, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {6, 2, 6, 7, 3, 1, 5}, {8, 6, 2, 1, 5, 7, 3, 0, 4}, {7, 5, 1, 0, 6, 2, 3, 7}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {6, 3, 2, 6, 7, 0, 5}, {8, 0, 3, 7, 4, 1, 2, 6, 5}, {7, 0, 1, 2, 3, 5, 6, 7}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {7, 7, 6, 5, 3, 2, 1, 0}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 0, 1, 3, 4, 5, 6, 7}, {7, 6, 7, 3, 5, 4, 0, 1}, {6, 4, 7, 6, 5, 0, 2}, {8, 0, 4, 5, 1, 3, 7, 6, 2}, {7, 2, 1, 5, 6, 0, 4, 7}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 3, 7, 4, 0, 2, 6, 5, 1}, {7, 2, 6, 7, 3, 5, 4, 0}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 3, 2, 6, 7, 1, 5, 4}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {7, 6, 5, 4, 7, 1, 0, 3}, {6, 7, 6, 5, 4, 3, 1}, {6, 6, 5, 4, 7, 2, 1}, {8, 6, 5, 4, 7, 2, 1, 0, 3}, {7, 2, 6, 7, 1, 5, 4, 0}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {7, 1, 2, 3, 5, 6, 7, 4}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {7, 0, 4, 5, 3, 7, 6, 2}, {8, 5, 6, 2, 1, 4, 7, 3, 0}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 7, 4, 0, 3, 6, 5, 1, 2}, {7, 3, 0, 1, 7, 4, 5, 6}, {6, 4, 7, 6, 5, 0, 3}, {7, 7, 4, 0, 6, 5, 1, 2}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 7, 6, 4, 3, 2, 1, 0}, {7, 6, 2, 1, 7, 3, 0, 4}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {7, 4, 7, 6, 0, 3, 2, 1}, {6, 3, 7, 4, 0, 2, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {7, 6, 7, 3, 2, 4, 0, 1}, {6, 7, 3, 2, 6, 4, 1}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {6, 7, 4, 0, 3, 6, 1}, {4, 7, 6, 4, 3}, {4, 7, 6, 4, 3}, {6, 7, 4, 0, 3, 6, 1}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {6, 7, 3, 2, 6, 4, 1}, {7, 6, 7, 3, 2, 4, 0, 1}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {6, 3, 7, 4, 0, 2, 6}, {7, 4, 7, 6, 0, 3, 2, 1}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {7, 6, 2, 1, 7, 3, 0, 4}, {7, 7, 6, 4, 3, 2, 1, 0}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 7, 4, 0, 6, 5, 1, 2}, {6, 4, 7, 6, 5, 0, 3}, {7, 3, 0, 1, 7, 4, 5, 6}, {8, 7, 4, 0, 3, 6, 5, 1, 2}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 5, 6, 2, 1, 4, 7, 3, 0}, {7, 0, 4, 5, 3, 7, 6, 2}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {7, 1, 2, 3, 5, 6, 7, 4}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {7, 2, 6, 7, 1, 5, 4, 0}, {8, 6, 5, 4, 7, 2, 1, 0, 3}, {6, 6, 5, 4, 7, 2, 1}, {6, 7, 6, 5, 4, 3, 1}, {7, 6, 5, 4, 7, 1, 0, 3}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {7, 3, 2, 6, 7, 1, 5, 4}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {7, 2, 6, 7, 3, 5, 4, 0}, {8, 3, 7, 4, 0, 2, 6, 5, 1}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {7, 2, 1, 5, 6, 0, 4, 7}, {8, 0, 4, 5, 1, 3, 7, 6, 2}, {6, 4, 7, 6, 5, 0, 2}, {7, 6, 7, 3, 5, 4, 0, 1}, {7, 0, 1, 3, 4, 5, 6, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 7, 6, 5, 3, 2, 1, 0}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {7, 0, 1, 2, 3, 5, 6, 7}, {8, 0, 3, 7, 4, 1, 2, 6, 5}, {6, 3, 2, 6, 7, 0, 5}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {7, 5, 1, 0, 6, 2, 3, 7}, {8, 6, 2, 1, 5, 7, 3, 0, 4}, {6, 2, 6, 7, 3, 1, 5}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {6, 1, 5, 6, 2, 0, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {4, 6, 2, 5, 7}, {6, 7, 6, 5, 4, 3, 2}, {8, 6, 7, 3, 2, 5, 4, 0, 1}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {7, 3, 7, 4, 2, 6, 5, 1}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {7, 2, 3, 0, 6, 7, 4, 5}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 0, 1, 2, 4, 5, 6, 7}, {7, 1, 5, 6, 0, 4, 7, 3}, {6, 5, 4, 7, 6, 1, 0}, {7, 5, 6, 2, 4, 7, 3, 0}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 5, 1, 0, 4, 6, 2, 3, 7}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {7, 3, 0, 2, 7, 4, 5, 6}, {7, 6, 5, 4, 2, 1, 0, 3}, {7, 3, 0, 1, 2, 4, 5, 6}, {6, 2, 1, 5, 6, 3, 4}, {7, 4, 0, 3, 5, 1, 2, 6}, {6, 1, 5, 6, 2, 0, 4}, {6, 0, 4, 5, 1, 3, 6}, {4, 5, 6, 1, 4}, {7, 4, 5, 1, 7, 6, 2, 3}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 2, 3, 0, 1, 6, 7, 4, 5}, {7, 3, 2, 7, 0, 1, 5, 4}, {7, 7, 4, 0, 3, 5, 1, 2}, {7, 7, 3, 2, 4, 0, 1, 5}, {6, 4, 0, 3, 7, 5, 2}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {7, 5, 4, 7, 1, 0, 3, 2}, {6, 4, 5, 1, 0, 7, 2}, {6, 4, 0, 3, 7, 5, 1}, {4, 4, 5, 0, 7}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {7, 0, 3, 7, 1, 2, 6, 5}, {7, 1, 0, 4, 2, 3, 7, 6}, {6, 2, 3, 0, 1, 6, 7}, {7, 2, 1, 5, 3, 0, 4, 7}, {6, 3, 0, 1, 2, 7, 5}, {6, 3, 0, 1, 2, 7, 4}, {4, 3, 2, 7, 0}, {7, 3, 2, 6, 0, 1, 5, 4}, {6, 2, 1, 5, 6, 3, 0}, {6, 0, 1, 2, 3, 4, 6}, {4, 2, 1, 6, 3}, {6, 0, 1, 2, 3, 4, 5}, {4, 1, 5, 2, 0}, {4, 0, 1, 3, 4}, {0}, }; /* table of cube edges involved in triangulation */ u_char cubeedges[256][13] = { {0}, {3, 0, 3, 8}, {3, 9, 1, 0}, {4, 1, 3, 8, 9}, {3, 1, 11, 2}, {6, 0, 1, 2, 3, 8, 11}, {4, 9, 11, 2, 0}, {5, 2, 11, 9, 8, 3}, {3, 2, 10, 3}, {4, 0, 2, 10, 8}, {6, 3, 0, 1, 2, 10, 9}, {5, 1, 9, 8, 10, 2}, {4, 3, 1, 11, 10}, {5, 0, 8, 10, 11, 1}, {5, 3, 10, 11, 9, 0}, {4, 11, 10, 9, 8}, {3, 4, 8, 7}, {4, 3, 7, 4, 0}, {6, 4, 9, 0, 8, 7, 1}, {5, 4, 7, 3, 1, 9}, {6, 4, 8, 11, 2, 7, 1}, {7, 3, 7, 1, 11, 4, 0, 2}, {7, 9, 11, 8, 7, 2, 0, 4}, {6, 2, 11, 9, 4, 3, 7}, {6, 8, 3, 10, 7, 4, 2}, {5, 10, 2, 0, 4, 7}, {9, 7, 8, 3, 10, 9, 1, 4, 2, 0}, {6, 2, 10, 9, 4, 1, 7}, {7, 3, 1, 7, 4, 11, 10, 8}, {6, 1, 11, 7, 10, 0, 4}, {8, 4, 9, 0, 8, 11, 10, 7, 3}, {5, 4, 9, 11, 10, 7}, {3, 5, 9, 4}, {6, 8, 4, 9, 0, 3, 5}, {4, 5, 1, 0, 4}, {5, 8, 3, 1, 5, 4}, {6, 1, 9, 5, 11, 2, 4}, {9, 3, 0, 1, 2, 4, 5, 8, 11, 9}, {5, 5, 4, 0, 2, 11}, {6, 3, 2, 4, 5, 8, 11}, {6, 2, 10, 9, 4, 3, 5}, {7, 0, 2, 4, 5, 10, 8, 9}, {7, 0, 4, 2, 10, 5, 1, 3}, {6, 2, 10, 4, 8, 1, 5}, {7, 11, 10, 9, 4, 3, 1, 5}, {8, 0, 8, 4, 9, 10, 11, 1, 5}, {6, 3, 0, 4, 5, 10, 11}, {5, 5, 11, 10, 8, 4}, {4, 7, 5, 9, 8}, {5, 9, 5, 7, 3, 0}, {5, 0, 1, 5, 7, 8}, {4, 1, 3, 5, 7}, {7, 9, 8, 11, 2, 7, 5, 1}, {8, 9, 5, 11, 1, 7, 3, 0, 2}, {6, 11, 2, 8, 0, 5, 7}, {5, 2, 3, 7, 5, 11}, {7, 7, 5, 3, 2, 9, 8, 10}, {6, 9, 5, 7, 10, 0, 2}, {8, 0, 1, 2, 3, 5, 7, 8, 10}, {5, 10, 7, 5, 1, 2}, {8, 3, 1, 7, 5, 10, 8, 11, 9}, {7, 5, 7, 1, 0, 10, 11, 9}, {7, 10, 11, 8, 0, 5, 7, 3}, {4, 5, 7, 10, 11}, {3, 11, 5, 6}, {6, 0, 3, 5, 6, 8, 11}, {6, 9, 5, 11, 1, 0, 6}, {7, 1, 3, 5, 6, 8, 9, 11}, {4, 6, 2, 1, 5}, {7, 1, 5, 3, 8, 6, 2, 0}, {5, 9, 0, 2, 6, 5}, {6, 3, 2, 5, 6, 8, 9}, {6, 2, 11, 6, 10, 3, 5}, {7, 10, 8, 11, 5, 0, 2, 6}, {9, 0, 1, 2, 3, 5, 6, 9, 10, 11}, {8, 1, 9, 5, 11, 8, 10, 2, 6}, {5, 6, 5, 1, 3, 10}, {6, 0, 1, 5, 6, 8, 10}, {6, 0, 3, 5, 6, 9, 10}, {5, 6, 10, 8, 9, 5}, {6, 7, 6, 5, 4, 8, 11}, {7, 4, 0, 6, 11, 3, 7, 5}, {9, 1, 9, 5, 11, 8, 7, 0, 6, 4}, {8, 4, 7, 6, 5, 3, 1, 9, 11}, {7, 6, 2, 4, 8, 1, 5, 7}, {8, 2, 6, 0, 4, 3, 1, 7, 5}, {8, 7, 6, 5, 4, 2, 0, 8, 9}, {7, 7, 3, 5, 9, 2, 6, 4}, {9, 11, 6, 10, 2, 4, 8, 5, 3, 7}, {8, 10, 2, 11, 6, 0, 4, 7, 5}, {12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {9, 2, 11, 6, 10, 9, 4, 1, 7, 5}, {8, 6, 5, 4, 7, 1, 3, 10, 8}, {7, 5, 1, 7, 10, 0, 4, 6}, {9, 5, 4, 7, 6, 0, 3, 9, 10, 8}, {6, 6, 5, 4, 7, 10, 9}, {4, 4, 6, 11, 9}, {7, 4, 6, 0, 3, 11, 9, 8}, {5, 11, 6, 4, 0, 1}, {6, 8, 3, 1, 11, 4, 6}, {5, 1, 2, 6, 4, 9}, {8, 1, 2, 3, 0, 6, 4, 9, 8}, {4, 6, 2, 4, 0}, {5, 8, 4, 6, 2, 3}, {7, 11, 9, 10, 3, 4, 6, 2}, {8, 0, 2, 4, 6, 8, 9, 10, 11}, {8, 3, 0, 1, 2, 4, 6, 10, 11}, {7, 6, 4, 2, 1, 8, 10, 11}, {6, 9, 1, 10, 3, 4, 6}, {7, 8, 10, 9, 1, 6, 4, 0}, {5, 3, 0, 4, 6, 10}, {4, 6, 4, 8, 10}, {5, 7, 8, 9, 11, 6}, {6, 0, 3, 6, 7, 9, 11}, {6, 6, 7, 1, 0, 11, 8}, {5, 11, 1, 3, 7, 6}, {6, 1, 2, 6, 7, 9, 8}, {7, 2, 6, 0, 9, 7, 3, 1}, {5, 7, 6, 2, 0, 8}, {4, 7, 3, 2, 6}, {8, 2, 11, 6, 10, 9, 8, 3, 7}, {7, 2, 0, 6, 7, 9, 11, 10}, {9, 6, 10, 2, 11, 8, 0, 7, 1, 3}, {6, 10, 2, 11, 6, 7, 1}, {7, 8, 9, 10, 6, 1, 3, 7}, {6, 6, 7, 1, 0, 10, 9}, {6, 7, 8, 3, 10, 6, 0}, {3, 6, 7, 10}, {3, 6, 7, 10}, {6, 7, 8, 3, 10, 6, 0}, {6, 6, 7, 1, 0, 10, 9}, {7, 8, 9, 10, 6, 1, 3, 7}, {6, 10, 2, 11, 6, 7, 1}, {9, 6, 10, 2, 11, 8, 0, 7, 1, 3}, {7, 2, 0, 6, 7, 9, 11, 10}, {8, 2, 11, 6, 10, 9, 8, 3, 7}, {4, 7, 3, 2, 6}, {5, 7, 6, 2, 0, 8}, {7, 2, 6, 0, 9, 7, 3, 1}, {6, 1, 2, 6, 7, 9, 8}, {5, 11, 1, 3, 7, 6}, {6, 6, 7, 1, 0, 11, 8}, {6, 0, 3, 6, 7, 9, 11}, {5, 7, 8, 9, 11, 6}, {4, 6, 4, 8, 10}, {5, 3, 0, 4, 6, 10}, {7, 8, 10, 9, 1, 6, 4, 0}, {6, 9, 1, 10, 3, 4, 6}, {7, 6, 4, 2, 1, 8, 10, 11}, {8, 3, 0, 1, 2, 4, 6, 10, 11}, {8, 0, 2, 4, 6, 8, 9, 10, 11}, {7, 11, 9, 10, 3, 4, 6, 2}, {5, 8, 4, 6, 2, 3}, {4, 6, 2, 4, 0}, {8, 1, 2, 3, 0, 6, 4, 9, 8}, {5, 1, 2, 6, 4, 9}, {6, 8, 3, 1, 11, 4, 6}, {5, 11, 6, 4, 0, 1}, {7, 4, 6, 0, 3, 11, 9, 8}, {4, 4, 6, 11, 9}, {6, 6, 5, 4, 7, 10, 9}, {9, 5, 4, 7, 6, 0, 3, 9, 10, 8}, {7, 5, 1, 7, 10, 0, 4, 6}, {8, 6, 5, 4, 7, 1, 3, 10, 8}, {9, 2, 11, 6, 10, 9, 4, 1, 7, 5}, {12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {8, 10, 2, 11, 6, 0, 4, 7, 5}, {9, 11, 6, 10, 2, 4, 8, 5, 3, 7}, {7, 7, 3, 5, 9, 2, 6, 4}, {8, 7, 6, 5, 4, 2, 0, 8, 9}, {8, 2, 6, 0, 4, 3, 1, 7, 5}, {7, 6, 2, 4, 8, 1, 5, 7}, {8, 4, 7, 6, 5, 3, 1, 9, 11}, {9, 1, 9, 5, 11, 8, 7, 0, 6, 4}, {7, 4, 0, 6, 11, 3, 7, 5}, {6, 7, 6, 5, 4, 8, 11}, {5, 6, 10, 8, 9, 5}, {6, 0, 3, 5, 6, 9, 10}, {6, 0, 1, 5, 6, 8, 10}, {5, 6, 5, 1, 3, 10}, {8, 1, 9, 5, 11, 8, 10, 2, 6}, {9, 0, 1, 2, 3, 5, 6, 9, 10, 11}, {7, 10, 8, 11, 5, 0, 2, 6}, {6, 2, 11, 6, 10, 3, 5}, {6, 3, 2, 5, 6, 8, 9}, {5, 9, 0, 2, 6, 5}, {7, 1, 5, 3, 8, 6, 2, 0}, {4, 6, 2, 1, 5}, {7, 1, 3, 5, 6, 8, 9, 11}, {6, 9, 5, 11, 1, 0, 6}, {6, 0, 3, 5, 6, 8, 11}, {3, 11, 5, 6}, {4, 5, 7, 10, 11}, {7, 10, 11, 8, 0, 5, 7, 3}, {7, 5, 7, 1, 0, 10, 11, 9}, {8, 3, 1, 7, 5, 10, 8, 11, 9}, {5, 10, 7, 5, 1, 2}, {8, 0, 1, 2, 3, 5, 7, 8, 10}, {6, 9, 5, 7, 10, 0, 2}, {7, 7, 5, 3, 2, 9, 8, 10}, {5, 2, 3, 7, 5, 11}, {6, 11, 2, 8, 0, 5, 7}, {8, 9, 5, 11, 1, 7, 3, 0, 2}, {7, 9, 8, 11, 2, 7, 5, 1}, {4, 1, 3, 5, 7}, {5, 0, 1, 5, 7, 8}, {5, 9, 5, 7, 3, 0}, {4, 7, 5, 9, 8}, {5, 5, 11, 10, 8, 4}, {6, 3, 0, 4, 5, 10, 11}, {8, 0, 8, 4, 9, 10, 11, 1, 5}, {7, 11, 10, 9, 4, 3, 1, 5}, {6, 2, 10, 4, 8, 1, 5}, {7, 0, 4, 2, 10, 5, 1, 3}, {7, 0, 2, 4, 5, 10, 8, 9}, {6, 2, 10, 9, 4, 3, 5}, {6, 3, 2, 4, 5, 8, 11}, {5, 5, 4, 0, 2, 11}, {9, 3, 0, 1, 2, 4, 5, 8, 11, 9}, {6, 1, 9, 5, 11, 2, 4}, {5, 8, 3, 1, 5, 4}, {4, 5, 1, 0, 4}, {6, 8, 4, 9, 0, 3, 5}, {3, 5, 9, 4}, {5, 4, 9, 11, 10, 7}, {8, 4, 9, 0, 8, 11, 10, 7, 3}, {6, 1, 11, 7, 10, 0, 4}, {7, 3, 1, 7, 4, 11, 10, 8}, {6, 2, 10, 9, 4, 1, 7}, {9, 7, 8, 3, 10, 9, 1, 4, 2, 0}, {5, 10, 2, 0, 4, 7}, {6, 8, 3, 10, 7, 4, 2}, {6, 2, 11, 9, 4, 3, 7}, {7, 9, 11, 8, 7, 2, 0, 4}, {7, 3, 7, 1, 11, 4, 0, 2}, {6, 4, 8, 11, 2, 7, 1}, {5, 4, 7, 3, 1, 9}, {6, 4, 9, 0, 8, 7, 1}, {4, 3, 7, 4, 0}, {3, 4, 8, 7}, {4, 11, 10, 9, 8}, {5, 3, 10, 11, 9, 0}, {5, 0, 8, 10, 11, 1}, {4, 3, 1, 11, 10}, {5, 1, 9, 8, 10, 2}, {6, 3, 0, 1, 2, 10, 9}, {4, 0, 2, 10, 8}, {3, 2, 10, 3}, {5, 2, 11, 9, 8, 3}, {4, 9, 11, 2, 0}, {6, 0, 1, 2, 3, 8, 11}, {3, 1, 11, 2}, {4, 1, 3, 8, 9}, {3, 9, 1, 0}, {3, 0, 3, 8}, {0}, }; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/queue.cpp0000644000175000017500000000101610352632600025133 0ustar debiandebian/*****************************************************************************\ * * queue.cc -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: queue.cpp,v 1.3 2005/12/22 23:23:44 annao Exp $ #include #include #include #include #include "queue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplot2d.cpp0000644000175000017500000001567011065020741025725 0ustar debiandebian//------------------------------------------------------------------------ // // conPlot2d.C - preprocess and extract contours from 2d scalar data // // Copyright (c) 1997 Dan Schikore - modified by Emilio Camahort, 1999 // //------------------------------------------------------------------------ // $Id: conplot2d.cpp,v 1.4 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #include #ifndef WIN32 #include #endif #include "conplot.h" #include "contour2d.h" #include "range.h" #include "segtree.h" #include "conplot2d.h" extern int verbose; extern void (*errorHandler)(char *, int); //------------------------------------------------------------------------ // // unst2d - local static variable // //------------------------------------------------------------------------ static int unst2d[8][3] = { {0}, {1, 2, 0}, {1, 0, 1}, {1, 1, 2}, {1, 2, 1}, {1, 1, 0}, {1, 0, 2}, {0} }; //------------------------------------------------------------------------ // // Conplot() - create a contour plot for the given image. // //------------------------------------------------------------------------ Conplot2d::Conplot2d(Datasetslc *d) : Conplot(d) { float min[3], max[3]; int i; slc = d; if (verbose > 1) { printf("***** Data Characteristics\n"); printf("cells: %d\n", slc->getNCells()); printf("*****\n"); } contour2d = con2 = new Contour2d[slc->nTime()]; contour3d = NULL; data->getData(0)->getExtent(min, max); if (verbose) { printf("minextent: %f %f %f\n", min[0], min[1], min[2]); printf("maxextent: %f %f %f\n", max[0], max[1], max[2]); } for (i=0; inTime(); i++) con2[i].setExtent(min,max); if (verbose) printf("contour3d is %x, contour2d is %x\n", contour3d, con2); } //------------------------------------------------------------------------ // // ~Conplot2d() - destroy a plot // //------------------------------------------------------------------------ Conplot2d::~Conplot2d() { if(contour2d) delete [] contour2d; } //------------------------------------------------------------------------ // // InterpEdge() - interpolate .... // //------------------------------------------------------------------------ int Conplot2d::InterpEdge(int edge, float *val, u_int *v, float isovalue, int cell) { double ival; float pt[2]; switch (edge) { case 0: ival = (isovalue-val[1])/(val[0]-val[1]); pt[0] = (float)(curslc->getVert(v[1])[0]*(1.0-ival) + curslc->getVert(v[0])[0]*ival); pt[1] = (float)(curslc->getVert(v[1])[1]*(1.0-ival) + curslc->getVert(v[0])[1]*ival); break; case 1: ival = (isovalue-val[2])/(val[1]-val[2]); pt[0] = (float)(curslc->getVert(v[2])[0]*(1.0-ival) + curslc->getVert(v[1])[0]*ival); pt[1] = (float)(curslc->getVert(v[2])[1]*(1.0-ival) + curslc->getVert(v[1])[1]*ival); break; case 2: ival = (isovalue-val[0])/(val[2]-val[0]); pt[0] = (float)(curslc->getVert(v[0])[0]*(1.0-ival) + curslc->getVert(v[2])[0]*ival); pt[1] = (float)(curslc->getVert(v[0])[1]*(1.0-ival) + curslc->getVert(v[2])[1]*ival); break; } //printf("pt %f %f\n", pt[0], pt[1]); return(curcon->AddVert(pt)); } //------------------------------------------------------------------------ // // EnqueueFaces() - enqueue adjacent faces for propagation of contour // code = case table lookup code for current cell // i,j,k = index of current cell // thisslice = queue of cells to be processed on current slice // nextslice = queue of cells to be processed on next slice // trackinz = flag indicating whether to propagate in z-dir // 0 -> don't track in z, but queue cells in nextslice // 1 -> propagate contour in all 3 dim // //------------------------------------------------------------------------ inline void Conplot2d::EnqueueFaces(int code, int c, CellQueue &thisslice) { switch (code) { case 0: break; case 1: break; case 2: break; } } //------------------------------------------------------------------------ // // TrackContour() - compute and track a contour by table lookup and propagation // through adjacent cells // isovalue = surface value of interest // i,j,k = index of seed cell // nextslice = queue of seeds for next slice (used only if tracking in 2d) // //------------------------------------------------------------------------ void Conplot2d::TrackContour(float isovalue, int cell) { float val[3]; u_int *verts; u_int v1, v2; int code; int adj; int e; int nvert = 0, nedge = 0; // to save isocontour components queue.Add(cell); curslc = (Dataslc*)data->getData(curtime); curcon = &con2[curtime]; if (filePrefix) // keep track of current nvert, nedge { nvert = curcon->getNVert(); nedge = curcon->getNEdge(); } while (queue.Get(cell) > 0) { curslc->getCellValues(cell, val); verts = curslc->getCellVerts(cell); code = 0; if (val[0] < isovalue) code += 0x01; if (val[1] < isovalue) code += 0x02; if (val[2] < isovalue) code += 0x04; for (e=0; eAddEdge(v1, v2); adj = curslc->getCellAdj(cell, unst2d[code][2*e+1]); if (adj != -1 && !CellTouched(adj)) { TouchCell(adj); queue.Add(adj); } adj = curslc->getCellAdj(cell, unst2d[code][2*e+2]); if (adj != -1 && !CellTouched(adj)) { TouchCell(adj); queue.Add(adj); } } EnqueueFaces(code, cell, queue); } if (filePrefix) // write this isocontour component { if (curcon->getNEdge() - nedge > 25) // more than 25 edges { FILE *fp; int v, e; char filename[200]; sprintf(filename, "%s%04d.ipoly", filePrefix, ncomponents); if ( (fp = fopen(filename, "w")) ) { fprintf(fp, "%d %d 0 0 0 0 0\n0 0 0\n", curcon->getNVert() - nvert, curcon->getNEdge() - nedge); for (v = nvert; v < curcon->getNVert(); v++) fprintf(fp, "%g %g %g\n", curcon->vert[v][0], curcon->vert[v][1], 0.0); fprintf(fp, "0 0\n"); for (e = nedge; e < curcon->getNEdge(); e++) fprintf(fp, "%d %d\n", curcon->edge[e][0], curcon->edge[e][1]); fclose(fp); ncomponents++; } else { char str[256]; sprintf(str, "Conplot2d::TrackContour: couldn't open file: %s", filename); errorHandler(str, FALSE); } } } } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datasetvol.h0000644000175000017500000000761010064121655025633 0ustar debiandebian//-------------------------------------------------------------------- // // Datasetvol - representation for a time-varying volume // // Copyright (c) 1997 Dan Schikore - updated by Emilio Camahort, 1999 // //-------------------------------------------------------------------- // $Id: datasetvol.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef DATASET_VOL_H #define DATASET_VOL_H #include "data.h" #include "dataset.h" #include "datavol.h" //-------------------------------------------------------------------- // // Datasetvol - a scalar time-varying dataset // //-------------------------------------------------------------------- class Datasetvol : public Dataset { private: // data members Datavol **vol; public: // constructors and destructors Datasetvol(Data::DataType t, int ndata, int ntime, char *files[]); Datasetvol(Data::DataType t, int ndata, int ntime, u_int nverts, u_int ncells, double *verts, u_int *cells, int *celladj, u_char *data); ~Datasetvol() {} // member access methods float getMin(int t) const { return(vol[t]->getMin()); } float getMax(int t) const { return(vol[t]->getMax()); } float getMin() const { return(min[0]); } float getMax() const { return(max[0]); } // add by fan float getMinFun(int j) const { return(min[j]); } float getMaxFun(int j) const { return(max[j]); } Data *getData(int i) { return(vol[i]); } Datavol *getVol(int i) { return(vol[i]); } }; //------------------------------------------------------------------------ // // Datasetvol() - usual constructor, reads data from one or more files // //------------------------------------------------------------------------ inline Datasetvol::Datasetvol(Data::DataType t, int nd, int nt, char *fn[]) : Dataset(t, nd, nt, fn) { int i, j; meshtype = 3; vol = (Datavol **)malloc(sizeof(Datavol *)*nt); for (j = 0; j < nd; j++) { min[j] = 1e10; max[j] = -1e10; } ncells = 0; for (i=0; igetMin() < min[j]) min[j] = vol[i]->getMin(); if (vol[i]->getMax() > max[j]) max[j] = vol[i]->getMax(); } if (vol[i]->getNCells() > ncells) ncells = vol[i]->getNCells(); } maxcellindex=ncells; } //------------------------------------------------------------------------ // // Datasetvol() - called by the constructors to initialize the data // //------------------------------------------------------------------------ inline Datasetvol::Datasetvol(Data::DataType t, int ndata, int ntime, u_int nverts, u_int ncells, double *verts, u_int *cells, int *celladj, u_char *data) : Dataset(t, ndata, ntime, data) { int i; // timestep index variable int j; // a variable index int size = 0; // size of single timestep of data meshtype = 3; vol = (Datavol **)malloc(sizeof(Datavol *)*ntime); for (j = 0; j < ndata; j++) { min[j] = 1e10; max[j] = -1e10; } // ncells = 0; this was here to allow different ncells for different // times, for now we don't allow it with this constructor Datasetvol::ncells = ncells; switch (t) { case Data::UCHAR : size = nverts * ndata * sizeof(u_char); break; case Data::USHORT : size = nverts * ndata * sizeof(u_short); break; case Data::FLOAT : size = nverts * ndata * sizeof(float); break; } for (i=0; igetMin() < min[j]) min[j] = vol[i]->getMin(); if (vol[i]->getMax() > max[j]) max[j] = vol[i]->getMax(); } if (vol[i]->getNCells() > ncells) ncells = vol[i]->getNCells(); } maxcellindex=ncells; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/Makefile.linux0000644000175000017500000000370310352633120026104 0ustar debiandebian.SUFFIXES: .cpp PROGNAME = testlib LIBNAME = libcontour.a # # To debug with purify set the following variable to: purify # PURIFY = #PURIFY = purify -purify-home=/lusr/pure/purify-4.1-irix6/ # # CCVHOME is the ccv repository, I have a environment variable for it # C++FILES = contour.cpp edgehash.cpp cellqueue.cpp range.cpp seedcells.cpp \ data.cpp dataslc.cpp datavol.cpp segtree.cpp contour2d.cpp \ contour3d.cpp conplot_p.cpp conplot.cpp conplot2d.cpp queue.cpp \ squeue.cpp rangeprop.cpp conplot3d.cpp rangesweep.cpp \ datareg2.cpp conplotreg2.cpp dirseeds.cpp inttree.cpp \ bucketsearch.cpp datareg3.cpp conplotreg3.cpp regprop.cpp \ dirseedsreg2.cpp regprop2.cpp seedchkr2.cpp seedchkr3.cpp \ seedall.cpp respprop2.cpp seeddirreg3.cpp cubes.cpp O++FILES = contour.o contour2d.o contour3d.o range.o data.o \ dataslc.o datavol.o edgehash.o cellqueue.o queue.o squeue.o \ seedcells.o segtree.o conplot_p.o conplot.o conplot2d.o \ rangeprop.o conplot3d.o rangesweep.o datareg2.o conplotreg2.o \ dirseeds.o inttree.o bucketsearch.o datareg3.o conplotreg3.o \ regprop.o dirseedsreg2.o regprop2.o seedchkr2.o seedchkr3.o \ seedall.o respprop2.o seeddirreg3.o cubes.o CXXINCLUDES = CXXFLAGS = -Wall -Wno-non-template-friend -O2 -D_BOOL -D_LITTLE_ENDIAN -DSP2 -DUSEDICT CFLAGS = -O2 -DNDEBUG CC = gcc $(CFLAGS) CXX = g++ $(CXXFLAGS) default: all all: $(LIBNAME) $(PROGNAME) $(PROGNAME): main.o $(LIBNAME) $(PURIFY) $(CXX) -o $(PROGNAME) main.o $(LIBNAME) -lm # this creates an archive in which all templates are instanciated $(LIBNAME): $(O++FILES) dict.o ar rv $(LIBNAME) $(O++FILES) dict.o rmobj: rm -f $(O++FILES) dict.o main.o .cpp.o: $(PURIFY) $(CXX) -c $(CXXINCLUDES) $*.cpp dict.o: $(CC) -c dict.c clean: rm -f $(O++FILES) dict.o main.o $(LIBNAME) $(PROGNAME) depend: mkdepend -c "$(CXX) -M $(CXXINCLUDES)" Makefile $(C++FILES) dict.c mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/respprop2.cpp0000644000175000017500000000523611065020741025752 0ustar debiandebian//------------------------------------------------------------------------ // // respProp2.C - preprocessing of 2d volumes for seed set extraction // //------------------------------------------------------------------------ // $Id: respprop2.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #ifndef WIN32 #include #endif #include "respprop2.h" #include "datareg2.h" #define DEBUGNo extern int verbose; //------------------------------------------------------------------------ // // //------------------------------------------------------------------------ void respProp2::compSeeds(void) { Datareg2 ®2 = (Datareg2&)data; int i, j; int xdim, ydim; float val[4]; Range prop, c_prop, done, resp, out; float min_x, min_y, max_x, max_y; int nseed; if (verbose) printf("***** Seed Creation\n"); xdim = reg2.dim[0]; ydim = reg2.dim[1]; // proceed through the slices computing seeds nseed=0; // process the k'th slab for (i=0; i= resp.MaxAll())) { prop = out - done; c_prop = out - prop; } else { #ifdef DEBUG printf("ADD SEED\n"); #endif // can't propagate all responsiblity, cell must be a seed seeds.AddSeed(reg2.index2cell(i,j), resp.MinAll(), resp.MaxAll()); #ifdef DEBUG printf("seed at %d %d %d\n", i, j, k); #endif nseed++; prop.MakeEmpty(); c_prop = out; } #ifdef DEBUG sleep(1); #endif } if (verbose) printf("computed %d seeds\n", nseed); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/README0000644000175000017500000000024510352633120024164 0ustar debiandebianTo compile libcontour: For big endean architectures: 1. cp Makefile.sgi Makefile 2. make For little endean architectures: 1. cp Makefile.linux Makefile 2. make mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplot.h0000644000175000017500000000744210064121655025146 0ustar debiandebian//------------------------------------------------------------------------ // // conplot.h - class for preprocessing and extraction of isocontours // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ // $Id: conplot.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef CONPLOT_H #define CONPLOT_H #include #include "dataset.h" #include "segtree.h" #include "inttree.h" #include "bucketsearch.h" #include "seedcells.h" #include "cellqueue.h" #include "edgehash.h" #include "range.h" #include "contour2d.h" #include "contour3d.h" //#define USE_SEG_TREE #define USE_INT_TREE //#define USE_BUCKETS //------------------------------------------------------------------------ // // conplot.h // //------------------------------------------------------------------------ class Conplot { public: Conplot(Dataset *v); virtual ~Conplot(); // preprocess the volume to compute the seed set void Preprocess(int t, void (*func)(int, void*) = NULL, void * = NULL); // extract an isosurface of the given value u_int Extract(float isovalue) { return(ExtractAll(isovalue)); } // select a timestep void setTime(int t); // mark a cell or test whether a cell is marked inline void TouchCell(u_int); inline int CellTouched(u_int); inline void ClearTouched(void); void ResetAll(void) { for (int t=0; tnTime(); t++) Reset(t); } int getCells(float val) { return(tree[curtime].getCells(val, int_cells)); } SeedCells *getSeeds() { return &seeds[curtime]; } Contour2d *getContour2d() { return &contour2d[curtime]; } Contour3d *getContour3d() { return &contour3d[curtime]; } // routines to support isocontour component output inline void BeginWrite(char *fprefix) { ncomponents = 0; filePrefix = fprefix; } inline void EndWrite() { filePrefix = NULL; } protected: // extract an isosurface u_int ExtractAll(float isovalue); // build the segment tree for the seed set void BuildSegTree(int t); virtual void Reset(int) = 0; virtual int Size(int) = 0; virtual int isDone(int) = 0; virtual void Done(int) = 0; // track a contour from a seed cell virtual void TrackContour(float, int) = 0; Dataset *data; CellQueue queue; SeedCells *seeds; Contour2d *contour2d; Contour3d *contour3d; int curtime; int ncomponents; // number of isocontour components char *filePrefix; // isocontour component file prefix private: // CellSearch *tree; #ifdef USE_SEG_TREE SegTree *tree; #elif defined USE_INT_TREE IntTree *tree; #elif defined USE_BUCKETS BucketSearch *tree; #endif u_int *int_cells; u_char *touched; }; //------------------------------------------------------------------------ // // CellTouched() - test if a cell has been visited // //------------------------------------------------------------------------ int Conplot::CellTouched(u_int id) { int byte; int bit; byte = id>>3; bit = id &0x7; return(touched[byte] & (1<>3; bit = id &0x7; touched[byte] |= (1<maxCellIndex()+7)>>3)); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/main.cpp0000644000175000017500000000402610352632600024737 0ustar debiandebian#include #include #include #include #include #include #include #include "contour.h" #include "datasetreg3.h" //#include "cellqueue.h" int main(){ //char*file[]={{"pot-2eti-glucose-3fields.raw"}}; char *file="/work/transfix/data/engine.rawiv"; int fd; ConDataset* the_data; //ConDataset* the_data; u_char *buf, *start; struct stat st; // the_data = loadDataset(CONTOUR_UCHAR, CONTOUR_REG_3D, 1, 1, file); int dim[3] = { 256,256,110 }; fd = open(file,O_RDONLY); if(fd == -1) { fprintf(stderr,"Error opening file '%s'!\n",file); return -1; } fstat(fd, &st); start = buf = (u_char*)mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,fd,0); if(buf == NULL) { fprintf(stderr,"mmap() failed!\n"); return -1; } start+=68; /* skip the header */ the_data = newDatasetReg(CONTOUR_UCHAR, CONTOUR_REG_3D, 1, 1, dim,start); float span[3] = {1.0,1.0,1.0}, orig[3] = {0.0,0.0,0.0}; ((Datareg3 *)the_data->data->getData(0))->setOrig(orig); ((Datareg3 *)the_data->data->getData(0))->setSpan(span); //int isovar = 0; //int timestep = 0; float isovalue = 91.636f; //Contour3dData* isocontour; //int i; /* isocontour = getContour3d(the_data, isovar , timestep , isovalue, NO_COLOR_VARIABLE ); printf("%d\n", isocontour->nvert); for (i=0; i < isocontour->nvert; i++) { printf("%7.3f %7.3f %7.3f %7.3f %7.3f %7.3f\n", isocontour->vert[i][0], isocontour->vert[i][1], isocontour->vert[i][2], isocontour->vnorm[i][0], isocontour->vnorm[i][1], isocontour->vnorm[i][2]); } printf("%d\n", isocontour->ntri); for (i=0; i < isocontour->ntri; i++) { printf("%d %d %d\n", isocontour->tri[i][0], isocontour->tri[i][1], isocontour->tri[i][2] ); } */ saveContour3d(the_data,0,0,isovalue,NO_COLOR_VARIABLE,"test.raw"); munmap(buf,st.st_size); //delete isocontour; delete the_data; return 0; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/squeue.cpp0000644000175000017500000000102010335221374025314 0ustar debiandebian/*****************************************************************************\ * * queue.cc -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: squeue.cpp,v 1.2 2005/11/11 23:02:20 annao Exp $ #include #include #include #include #include "squeue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datasetreg3.h0000644000175000017500000001252211065020741025665 0ustar debiandebian//-------------------------------------------------------------------- // // Datasetreg3 - representation for a 3D time-varying regular grid // // Updated by Emilio Camahort, 1999 // //-------------------------------------------------------------------- // $Id: datasetreg3.h,v 1.4 2008/09/19 22:04:17 annao Exp $ #ifndef DATASET_REG3_H #define DATASET_REG3_H #include "dataset.h" #include "datareg3.h" extern int verbose; //-------------------------------------------------------------------- // // Datasetreg3 - a 3D scalar time-varying regular grid of data // //-------------------------------------------------------------------- class Datasetreg3 : public Dataset { private: // data member Datareg3 **reg3; public: // constructors and destructors Datasetreg3(Data::DataType t, int ndata, int ntime, char *files[]); Datasetreg3(Data::DataType t, int ndata, int ntime, int *dim, u_char *data); ~Datasetreg3() { int i; if (verbose) printf ("Datasetreg3 destructor \n"); if (reg3) { for (i=0; igetNData()); } // min, max for "0" variable at time step "t" float getMin(int t) const { return(reg3[t]->getMin()); } float getMax(int t) const { return(reg3[t]->getMax()); } // min, max for "0" variable, over all times float getMin() const { return(min[0]); } float getMax() const { return(max[0]); } // min, max for "j" variable, over all times float getMinFun(int j) const { return(min[j]); } float getMaxFun(int j) const { return(max[j]); } // "i" time step Data *getData(int i) { return(reg3[i]); } Datareg3 *getMesh(int i) { return(reg3[i]); } }; //------------------------------------------------------------------------ // // Datasetreg3() - usual constructor, reads data from one or more files // //------------------------------------------------------------------------ inline Datasetreg3::Datasetreg3(Data::DataType t, int nd, int nt, char *fn[]) : Dataset(t, nd, nt, fn) { int i, j; meshtype = 5; // may be bug here: Fan modify // min = (float *)malloc(sizeof(float)*nt); // max = (float *)malloc(sizeof(float)*nt); min = (float *)malloc(sizeof(float)*nd); max = (float *)malloc(sizeof(float)*nd); for (i=0; igetMin(j) < min[j]) min[j] = reg3[i]->getMin(j); if (reg3[i]->getMax(j) > max[j]) max[j] = reg3[i]->getMax(j); // modify fan // May be bug fan // max[j] = reg3[i]->getMax(); } if (reg3[i]->getNCells() > ncells) ncells = reg3[i]->getNCells(); if (reg3[i]->maxCellIndex() > maxcellindex) maxcellindex = reg3[i]->maxCellIndex(); } if (verbose) for (i = 0; i < nd; i++) printf("variable[%d]: min=%f, max=%f\n",i, min[i],max[i]); } //------------------------------------------------------------------------ // // Datasetreg3() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ inline Datasetreg3::Datasetreg3(Data::DataType t, int ndata, int ntime, int *dim, u_char *data) : Dataset(t, ndata, ntime, data) { int i, j; // timestep and variable indices int size = 0; // size of single timestep of data meshtype = 5; // may be bug here: Fan modify // min = (float *)malloc(sizeof(float)*ntime); // max = (float *)malloc(sizeof(float)*ntime); min = (float *)malloc(sizeof(float)*ndata); max = (float *)malloc(sizeof(float)*ndata); for (i=0; igetMin(j) < min[j]) min[j] = reg3[i]->getMin(j); if (reg3[i]->getMax(j) > max[j]) max[j] = reg3[i]->getMax(j); // modify fan // May be bug fan // max[j] = reg3[i]->getMax(); } if (reg3[i]->getNCells() > ncells) ncells = reg3[i]->getNCells(); if (reg3[i]->maxCellIndex() > maxcellindex) maxcellindex = reg3[i]->maxCellIndex(); } if (verbose) for (i = 0; i < ndata; i++) printf("variable[%d]: min=%f, max=%f\n",i, min[i],max[i]); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/edgehash.cpp0000644000175000017500000000524411065020741025565 0ustar debiandebian//---------------------------------------------------------------------- // // edgeHash.C - hash to lookup vertices which are already computed // // This is a *very* basic hash class to aid in finding vertices which // have already been computed, avoiding recomputation and duplication // // Copyright (c) 1997 Dan Schikore //---------------------------------------------------------------------- // $Id: edgehash.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include "edgehash.h" // use a small prime # of buckets #define NBUCKETS 3001 extern int verbose; //---------------------------------------------------------------------- // // EdgeHash - construct a new hash // //---------------------------------------------------------------------- EdgeHash::EdgeHash() { int b; nbuckets = NBUCKETS; nitems = (int *)malloc(sizeof(int) * nbuckets); buckets = (EdgeHashBucket *)malloc(sizeof(EdgeHashBucket) * nbuckets); // initialize each bucket for (b=0; bitems[i].key == key) { // found the requested key vnum = b->items[i].vnum; if (++(b->items[i].nref) == 4) { // edges referenced 4 times will not be used again if ((*nitems) > 1) b->items[i] = b->items[(*nitems)-1]; (*nitems)--; } return(vnum); } } return(-1); } //---------------------------------------------------------------------- // // InsertBucket - insert an item in the given bucket // //---------------------------------------------------------------------- void EdgeHash::InsertBucket(int *nitems, EdgeHashBucket *b, int key, int vnum) { int n = (*nitems)++; if (n >= b->elsize) { b->elsize*=2; b->items = (EdgeHashEl *)realloc(b->items, sizeof(EdgeHashEl)* b->elsize); if (verbose > 1) printf("hash size: %d\n", b->elsize); } b->items[n].key = key; b->items[n].vnum = vnum; b->items[n].nref = 1; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datasetslc.h0000644000175000017500000001073410064121655025615 0ustar debiandebian//-------------------------------------------------------------------- // // Datasetslc - representation for a time-varying volume // // Copyright (c) 1997 Dan Schikore - modified by Emilio Camahort, 1999 // //-------------------------------------------------------------------- // $Id: datasetslc.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef DATASET_SLC_H #define DATASET_SLC_H #include "dataset.h" #include "dataslc.h" //-------------------------------------------------------------------- // // Datasetslc - a scalar time-varying dataset // //-------------------------------------------------------------------- class Datasetslc : public Dataset { private: // data member Dataslc **slc; public: // constructors and destructors Datasetslc(Data::DataType t, int ndata, int ntime, char *files[]); Datasetslc(Data::DataType t, int ndata, int ntime, u_int nverts, u_int ncells, double *verts, u_int *cells, int *celladj, u_char *data); virtual ~Datasetslc() {} // member access methods float getMin(int t) const { return(slc[t]->getMin()); } float getMax(int t) const { return(slc[t]->getMax()); } float getMin() const { return(min[0]); } float getMax() const { return(max[0]); } // add by fan float getMinFun(int j) const { return(min[j]); } float getMaxFun(int j) const { return(max[j]); } Data *getData(int i) { return(slc[i]); } Dataslc *getSlc(int i) { return(slc[i]); } }; //------------------------------------------------------------------------ // // Datasetslc() - usual constructor, reads data from one or more files // //------------------------------------------------------------------------ inline Datasetslc::Datasetslc(Data::DataType t, int nd, int nt, char *fn[]) : Dataset(t, nd, nt, fn) { int i, j; meshtype = 2; slc = (Dataslc **)malloc(sizeof(Dataslc *)*nt); for (j = 0; j < nd; j++) { min[j] = 1e10; max[j] = -1e10; } ncells = 0; for (i=0; igetMin() < min[j]) min[j] = slc[i]->getMin(); if (slc[i]->getMax() > max[j]) max[j] = slc[i]->getMax(); } if (slc[i]->getNCells() > ncells) ncells = slc[i]->getNCells(); if (verbose) { printf("step %d: min : %f max : %f\n", i, min[0], max[0]); printf("step %d: tmin : %f tmax : %f\n", i, slc[i]->getMin(), slc[i]->getMax()); } } maxcellindex=ncells; if (verbose) for (i = 0; i < nd; i++) printf("variable[%d]: min=%f, max=%f\n",i, min[i],max[i]); } //------------------------------------------------------------------------ // // Datasetslc() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ inline Datasetslc::Datasetslc(Data::DataType t, int ndata, int ntime, u_int nverts, u_int ncells, double *verts, u_int *cells, int *celladj, u_char *data) : Dataset(t, ndata, ntime, data) { int i; // timestep index variable int j; // a variable index int size = 0; // size of single timestep of data meshtype = 2; slc = (Dataslc **)malloc(sizeof(Dataslc *)*ntime); for (j = 0; j < ndata; j++) { min[j] = 1e10; max[j] = -1e10; } // ncells = 0; this was here to allow different ncells for different // times, for now we don't allow it with this constructor Datasetslc::ncells = ncells; switch (t) { case Data::UCHAR : size = nverts * ndata * sizeof(u_char); break; case Data::USHORT : size = nverts * ndata * sizeof(u_short); break; case Data::FLOAT : size = nverts * ndata * sizeof(float); break; } for (i = 0; i < ntime; i++) { slc[i] = new Dataslc(t, ndata, nverts, ncells, verts, cells, celladj, data + i*size); for (j = 0; j < ndata; j++) { if (slc[i]->getMin() < min[j]) min[j] = slc[i]->getMin(); if (slc[i]->getMax() > max[j]) max[j] = slc[i]->getMax(); } if (slc[i]->getNCells() > ncells) ncells = slc[i]->getNCells(); if (verbose) { printf("step %d: min : %f max : %f\n", i, min[0], max[0]); printf("step %d: tmin : %f tmax : %f\n", i, slc[i]->getMin(), slc[i]->getMax()); } } maxcellindex=ncells; if (verbose) for (i = 0; i < ndata; i++) printf("variable[%d]: min=%f, max=%f\n",i, min[i],max[i]); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/cubes.h0000644000175000017500000000114210064121655024560 0ustar debiandebian/* * cubes.h - marching cubes table of cubes and associated tables * this file has been automatically generated * DO NOT EDIT * Copyright (c) 1997 Dan Schikore */ // $Id: cubes.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ /* table of intersected edges (complete with holes) */ extern u_char cubes[256][14]; /* table of adjacent faces to visit in contour propagation */ extern u_char adjfaces[256][7]; /* table of cube vertices involved in triangulation */ extern u_char cubeverts[256][9]; /* table of cube edges involved in triangulation */ extern u_char cubeedges[256][13]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/Makefile.sgi0000644000175000017500000000363510352633120025533 0ustar debiandebian.SUFFIXES: .cpp PROGNAME = testlib LIBNAME = libcontour.a # # To debug with purify set the following variable to: purify # PURIFY = #PURIFY = purify -purify-home=/lusr/pure/purify-4.1-irix6/ # # CCVHOME is the ccv repository, I have a environment variable for it # C++FILES = contour.cpp edgehash.cpp cellqueue.cpp range.cpp seedcells.cpp \ data.cpp dataslc.cpp datavol.cpp segtree.cpp contour2d.cpp \ contour3d.cpp conplot_p.cpp conplot.cpp conplot2d.cpp queue.cpp \ squeue.cpp rangeprop.cpp conplot3d.cpp rangesweep.cpp \ datareg2.cpp conplotreg2.cpp dirseeds.cpp inttree.cpp \ bucketsearch.cpp datareg3.cpp conplotreg3.cpp regprop.cpp \ dirseedsreg2.cpp regprop2.cpp seedchkr2.cpp seedchkr3.cpp \ seedall.cpp respprop2.cpp seeddirreg3.cpp cubes.cpp O++FILES = contour.o contour2d.o contour3d.o range.o data.o \ dataslc.o datavol.o edgehash.o cellqueue.o queue.o squeue.o \ seedcells.o segtree.o conplot_p.o conplot.o conplot2d.o \ rangeprop.o conplot3d.o rangesweep.o datareg2.o conplotreg2.o \ dirseeds.o inttree.o bucketsearch.o datareg3.o conplotreg3.o \ regprop.o dirseedsreg2.o regprop2.o seedchkr2.o seedchkr3.o \ seedall.o respprop2.o seeddirreg3.o cubes.o CXXINCLUDES = CXXFLAGS = -LANG:std -n32 -O -D_BOOL -DSP2 -DUSEDICT CFLAGS = -O -DNDEBUG CC = cc $(CFLAGS) CXX = CC $(CXXFLAGS) default: all all: $(LIBNAME) $(PROGNAME) $(PROGNAME): main.o $(LIBNAME) $(PURIFY) $(CXX) -o $(PROGNAME) main.o $(LIBNAME) -lm # this creates an archive in which all templates are instanciated $(LIBNAME): $(O++FILES) dict.o ar rv $(LIBNAME) $(O++FILES) dict.o rmobj: rm -f $(O++FILES) dict.o main.o .cpp.o: $(PURIFY) $(CXX) -c $(CXXINCLUDES) $*.cpp dict.o: $(CC) -c dict.c clean: rm -f $(O++FILES) dict.o main.o $(LIBNAME) $(PROGNAME) depend: mkdepend -c "$(CXX) -M $(CXXINCLUDES)" Makefile $(C++FILES) dict.c mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seeddirreg3.cpp0000644000175000017500000002440710064121655026223 0ustar debiandebian // $Id: seeddirreg3.cpp,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #include #include "seeddirreg3.h" #include "datareg3.h" #include "basic.h" //#define DEBUG //#define DEBUGSLEEP #define sgn(x) ((x)>0 ? 1 : ((x)<0?-1:0)) extern int verbose; void seedDirReg3::dirSweep(Datareg3 ®3) { u_int i, j, k; Range resp; float min, max, t; float gradz; float grad1xa, grad1xb; float grad1ya, grad1yb; float grad2xa, grad2xb; float grad2ya, grad2yb; int keepflat, *keepflat_y; keepflat_y = (int *)malloc(sizeof(int)*reg3.dim[0]); for (k=0; k max) max = t; if ((t=reg3.getValue(i+1,j+1,k)) < min) min = t; if (t > max) max = t; if ((t=reg3.getValue(i+1,j,k)) < min) min = t; if (t > max) max = t; if (min != max) resp += Range(min,max); #ifdef DEBUG printf(" leftmost cell, responsibility (%f,%f)\n", min, max); #endif } else { // never do anything other than on boundary } // maximum z if (k == reg3.dim[2]-2) { // never keep a top boundary seed } else { // never keep a top boundary seed } // general case: bottom edge in middle // cell (i,j) and (i,j-1) share this x-grad gradz = reg3.getValue(i,j,k+1) - reg3.getValue(i,j,k); // compute grad at (i,j,k) and (i,j,k+1) grad1xa = reg3.getValue(i+1,j,k) - reg3.getValue(i,j,k); grad1xb = reg3.getValue(i+1,j,k+1) - reg3.getValue(i,j,k+1); grad1ya = reg3.getValue(i,j+1,k) - reg3.getValue(i,j,k); grad1yb = reg3.getValue(i,j+1,k+1) - reg3.getValue(i,j,k+1); if (keepflat && keepflat_y[i]) { #ifdef DEBUG printf("at a flat: checking central edge\n"); #endif // check to see if gradient has 'turned' // only a seed if gradx & grady disagree in sign // note that 0 gradient is not considered opposite if (sgn(grad1xa) == 0 && sgn(grad1xb) == 0) { // flat cell (in x dim) - continue #ifdef DEBUG printf(" still flat (x)\n"); #endif } else if (sgn(grad1ya) == 0 && sgn(grad1yb) == 0) { // flat cell (in y dim) - continue #ifdef DEBUG printf(" still flat (y)\n"); #endif } else if ((sgn(gradz) == -sgn(grad1xa) && sgn(gradz) == -sgn(grad1ya)) || (sgn(gradz) == -sgn(grad1xb) && sgn(gradz) == -sgn(grad1yb))) { // extreme occurs if y components oppose each other // note that 0 gradient is not considered opposite min = max = reg3.getValue(i,j,k); if ((t=reg3.getValue(i,j,k+1)) < min) min = t; if (t > max) max = t; resp += Range(min,max); #ifdef DEBUG printf(" added resp (%f %f)\n", min, max); #endif keepflat = 0; keepflat_y[i] = 0; } #ifdef DEBUG else { printf(" not a seed.. gradz=%f grad1xa=%f grad1ya=%f grad1xb=%f grad1yb=%f\n", gradz, grad1xa, grad1ya, grad1xb, grad1yb); } #endif } else { } // top if (i == reg3.dim[0]-2) { if (keepflat && keepflat_y[i]) { // reached end at a flat.. add the edge values min = max = reg3.getValue(i+1,j,k); if ((t=reg3.getValue(i+1,j,k+1)) < min) min = t; if (t > max) max = t; resp += Range(min,max); } if (j == reg3.dim[1]-2) { if (keepflat && keepflat_y[i]) { // reached end at a flat.. add the edge values min = max = reg3.getValue(i+1,j+1,k); if ((t=reg3.getValue(i+1,j+1,k+1)) < min) min = t; if (t > max) max = t; resp += Range(min,max); } } else { // do we need to set keepflat_y[i]? gradz = reg3.getValue(i,j+1,k+1) - reg3.getValue(i,j+1,k); grad2xa = reg3.getValue(i+1,j+1,k+1) - reg3.getValue(i,j+1,k+1); grad2xb = reg3.getValue(i+1,j+1,k) - reg3.getValue(i,j+1,k); grad2ya = reg3.getValue(i,j+1,k+1) - reg3.getValue(i,j,k+1); grad2yb = reg3.getValue(i,j+1,k) - reg3.getValue(i,j,k); keepflat_y[i] = (sgn(gradz) != 0 && ((sgn(gradz) == -sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == sgn(grad2yb)))); #if 0 if (!keepflat_y[i]) { if (sgn(gradz) != 0 && ((sgn(gradz) == -sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == sgn(grad2yb)))) keepflat_y[i]=1; } else { if (sgn(gradz) != 0 && ((sgn(gradz) == sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == -sgn(grad2yb)))) keepflat_y[i]=0; } #endif } } else { if (j == reg3.dim[1]-2) { if (keepflat && keepflat_y[i]) { // reached end at a flat.. add the edge values min = max = reg3.getValue(i+1,j+1,k); if ((t=reg3.getValue(i+1,j+1,k+1)) < min) min = t; if (t > max) max = t; resp += Range(min,max); } } else { // do we need to set keepflat_y[i]? gradz = reg3.getValue(i,j+1,k+1) - reg3.getValue(i,j+1,k); grad2xa = reg3.getValue(i+1,j+1,k+1) - reg3.getValue(i,j+1,k+1); grad2xb = reg3.getValue(i+1,j+1,k) - reg3.getValue(i,j+1,k); grad2ya = reg3.getValue(i,j+1,k+1) - reg3.getValue(i,j,k+1); grad2yb = reg3.getValue(i,j+1,k) - reg3.getValue(i,j,k); #ifdef DEBUG printf("checking keepflat[%d]:\n", i); printf(" gradz: %1.1f grad2xa: %1.1f grad2xb: %1.1f grad2ya: %1.1f grad2yb: %1.1f\n", gradz, grad2xa, grad2xb, grad2ya, grad2yb); #endif keepflat_y[i] = (sgn(gradz) != 0 && ((sgn(gradz) == -sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == sgn(grad2yb)))); #if 0 if (!keepflat_y[i]) { if (sgn(gradz) != 0 && ((sgn(gradz) == -sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == sgn(grad2yb)))) keepflat_y[i]=1; } else { if (sgn(gradz) != 0 && ((sgn(gradz) == sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == -sgn(grad2yb)))) keepflat_y[i]=0; } #endif } // do we need to set keepflat? gradz = reg3.getValue(i+1,j,k+1) - reg3.getValue(i+1,j,k); grad2xa = reg3.getValue(i+1,j,k+1) - reg3.getValue(i,j,k+1); grad2xb = reg3.getValue(i+1,j,k) - reg3.getValue(i,j,k); grad2ya = reg3.getValue(i+1,j+1,k+1) - reg3.getValue(i+1,j,k+1); grad2yb = reg3.getValue(i+1,j+1,k) - reg3.getValue(i+1,j,k); #ifdef DEBUG printf("checking keepflat:\n"); printf(" gradz: %1.1f grad2xa: %1.1f grad2xb: %1.1f grad2ya: %1.1f grad2yb: %1.1f\n", gradz, grad2xa, grad2xb, grad2ya, grad2yb); #endif keepflat = (sgn(gradz) != 0 && ((sgn(gradz) == sgn(grad2xa) && sgn(gradz) == -sgn(grad2ya)) || (sgn(gradz) == sgn(grad2xb) && sgn(gradz) == -sgn(grad2yb)))); #if 0 if (!keepflat) { if (sgn(gradz) != 0 && ((sgn(gradz) == sgn(grad2xa) && sgn(gradz) == -sgn(grad2ya)) || (sgn(gradz) == sgn(grad2xb) && sgn(gradz) == -sgn(grad2yb)))) keepflat=1; } else { if (sgn(gradz) != 0 && ((sgn(gradz) == sgn(grad2xa) && sgn(gradz) == sgn(grad2ya)) || (sgn(gradz) == -sgn(grad2xb) && sgn(gradz) == -sgn(grad2yb)))) keepflat=0; } #endif } if (!resp.Empty()) seeds.AddSeed(reg3.index2cell(i,j,k), resp.MinAll(), resp.MaxAll()); } } } } void seedDirReg3::compSeeds(void) { if (verbose) printf("------- computing seeds\n"); // clear the array of mark bits seeds.Clear(); dirSweep((Datareg3&)data); if (verbose) printf("computed %d seeds\n", seeds.getNCells()); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/bin.h0000644000175000017500000001414710064121655024240 0ustar debiandebian/*****************************************************************************\ * * bin.h -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: bin.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef __BIN_H #define __BIN_H #include #include #include //@ManMemo: A templated dynamic array /*@Doc: A #Bin# is basically a dynamic array. Elements can be added to the #Bin# using the #add# method. Memory is allocated automatically upon need. */ template class Bin { public: //@ManDoc: Contructor. Creates a Bin with block size equal to blocksize. Bin(int blocksize=0); //@ManDoc: Copy constructor. Copies the bin and its contents. Bin(const Bin &bin) { *this = bin; } //@ManDoc: Assignment. Returns a copy of the bin and its contents. Bin &operator=(const Bin &bin); //@ManDoc: Destructor. ~Bin(); //@ManDoc: Change the blocksize to be used from now on. void setBlocksize(int blocksize=0); //@ManDoc: Set the offset. void setOffset(int off); //@ManDoc: Add T to the end of the Bin. int add(const T &e); /*@ManDoc: Add an element to the Bin. The default constructor is used to create the element. */ int add() { return add(T()); } //@ManDoc: Remove last #num# items. int removeLast(int num=1); int removePos(int pos=0); //@ManDoc: Returns the number of items in the Bin. int numItems() const; //@ManDoc: Returns the T stored at position k in the bin. T& operator[](unsigned int k) const; /*@ManDoc: Resizes memory and returns a pointer to the array. The Bin is reinitialized */ T* done(); //@ManDoc: Returns a pointer without resizing memory. T* array() const; //@ManDoc: Frees memory and reinitializes the Bin. void cleanUp(); //@ManDoc: Transfer the contents of this to newbin and clean this. void moveTo(Bin &newbin); private: int offset; // Position of zero-th element int nitems; // Number of items in the Bin int block; // Size of chunks for each realloc int room; // Size of alloc'd memory T *a; // Array of Ts void init(int blocksize); // init the bin void destroy(); // destroy the bin and its contents void grow(); // create additional space }; /*****************************************************************************\ * inline functions \*****************************************************************************/ template inline void Bin::init(int blocksize) { if( blocksize == 0 ) { block = (size_t(1) > size_t(4096/sizeof(T)) ? size_t(1) : size_t(4096/sizeof(T))); } else { block = blocksize; } offset = 0; nitems = 0; room = 0; a = 0; } template inline void Bin::destroy() { for( int i = 0; i < nitems; i++ ) { a[i].~T(); } free(a); } template inline Bin::Bin(int blocksize) // // Bin constructor // // blocksize: the number of Ts to allocate memory for // { init(blocksize); } template inline Bin &Bin::operator=(const Bin &bin) { block = bin.block; offset = bin.offset; nitems = bin.nitems; room = bin.room; if( nitems > 0 ) { a = (T*)malloc( room*sizeof(T) ); for( int i = 0; i < nitems; i++ ) { a[i] = bin.a[i]; } } else { a = NULL; } return *this; } template inline Bin::~Bin() // // Bin destructor // { destroy(); } template inline void Bin::cleanUp() { int bs = block; destroy(); init(bs); } template inline int Bin::numItems() const // // returns the number of items in the bin // { return nitems; } template inline T& Bin::operator[](unsigned int k) const // // returns a data object from the bin // // k: the int in the bin of the T to return // { return a[k+offset]; } template inline int Bin::add(const T &e) // // adds a new data object to the bin, returns the index // where it was added to the bin // // &e reference to the T that is to be added to the bin // { if(nitems == room) grow(); a[nitems] = e; return (nitems++)-offset; } template inline int Bin::removeLast(int num) // // remove last num items from the Bin // returns the index of the last element in the bin // // num : number of items to remove // { assert( num <= nitems ); for( int i = nitems-num; i < nitems; i++ ) a[i].~T(); nitems -= num; return nitems-offset; } template inline int Bin::removePos(int pos) { #ifdef SP2 // modified by Emilio: looks like a real bug!! a[pos].~T(); #else delete a[pos]; #endif for ( int i=pos+1; i < nitems; i++ ) a[i-1] = a[i]; nitems--; return nitems-offset; } template inline T* Bin::array() const // // returns a pointer to the data objects in the bin // { //@@ cast needed by g++ 2.7.2 (why?) return (T*)(&a[offset]); } template inline void Bin::setBlocksize(int blocksize) { if( blocksize == 0 ) { block = (size_t(1) > size_t(4096/sizeof(T)) ? size_t(1) : size_t(4096/sizeof(T))); } else { block = blocksize; } } template inline void Bin::setOffset(int off) { offset = off; } template inline T* Bin::done() // // reallocates memory to exactly fit the data objects in the bin // and returns a pointer to the data objects. The Bin is reinitialized // { T *tmp; if( nitems == 0 ) { free( a ); tmp = 0; } else { tmp = (T*)realloc( a, nitems*sizeof(T) ); assert(tmp); } init(block); return tmp; } template inline void Bin::moveTo(Bin &newbin) // transfer the contents of this to newbin and cleanUp this { memcpy( &newbin, this, sizeof( Bin ) ); // do not use operator= ! init(block); } template inline void Bin::grow() { room += block; if(a == 0) { a = (T*)malloc( room*sizeof(T) ); } else { a = (T*)realloc( a, room*sizeof(T) ); } assert(a); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/regprop.h0000644000175000017500000000071510064121655025142 0ustar debiandebian // $Id: regprop.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef REG_PROP_H #define REG_PROP_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class Datavol; class Dataslc; class regProp { public: regProp(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~regProp() {} void compSeeds(void); private: Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/dataslc.cpp0000644000175000017500000002436611065020741025436 0ustar debiandebian//------------------------------------------------------------------------ // // dataslc.C - class for a triangular slice of scalar data // // Copyright (c) 1997 Dan Schikore - updated by Emilio Camahort, 1999 // //------------------------------------------------------------------------ // $Id: dataslc.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #include #include #if ! defined (__APPLE__) #include #else #include #endif #include #ifndef WIN32 #include #endif #include "dataslc.h" #include "compute.h" #include "endian_io.h" #define SQR(x) ((x)*(x)) #define FSAMPLES 256 extern int verbose; //------------------------------------------------------------------------ // // Dataslc() - create a volume with the specified type and dimensions with // data taken from the given file // //------------------------------------------------------------------------ Dataslc::Dataslc(DataType t, int ndata, char *fn) : Data(t, ndata, fn) { u_int i; float grad[3]; float len; verts = (double (*)[2])malloc(sizeof(double[2])*getNVerts()); vgrad = (float (*)[3])malloc(sizeof(float[3])*getNVerts()); cells = (u_int (*)[3])malloc(sizeof(u_int[3])*getNCells()); celladj = (int (*)[3])malloc(sizeof(int[3])*getNCells()); if (verbose) printf("reading verts\n"); //fread(verts, sizeof(double[2]), getNVerts(), fp); fread_double(verts, sizeof(double), 2 * getNVerts(), fp); if (verbose) printf("reading cells\n"); for (i=0; i 1) printf("scaling vgrad %d\n", i); len = (float)sqrt(vgrad[i][0]*vgrad[i][0] + vgrad[i][1]*vgrad[i][1] + vgrad[i][2]*vgrad[i][2]); if (len != 0.0) { vgrad[i][0] /= len; vgrad[i][1] /= len; vgrad[i][2] /= len; } } } //------------------------------------------------------------------------ // // Dataslc() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ Dataslc::Dataslc(Data::DataType t, int ndata, u_int nverts, u_int ncells, double *_verts, u_int *_cells, int *_celladj, u_char *data) : Data(t, ndata, data) { u_int i; float grad[3]; float len; Dataslc::nverts = nverts; // initializations Dataslc::ncells = ncells; verts = (double (*)[2])_verts; cells = (u_int (*)[3])_cells; celladj = (int (*)[3])_celladj; if (verbose) printf("computing extent\n"); // compute data extents minext[0] = minext[1] = maxext[0] = maxext[1] = minext[2] = maxext[2] = 0.0; for (i = 0; i < nverts; i++) { if (verts[i][0] < minext[0]) minext[0] = (float)(verts[i][0]); if (verts[i][0] > maxext[0]) maxext[0] = (float)(verts[i][0]); if (verts[i][1] < minext[1]) minext[1] = (float)(verts[i][1]); if (verts[i][1] > maxext[1]) maxext[1] = (float)(verts[i][1]); } //fread(minext, sizeof(float[3]), 1, fp); //fread(maxext, sizeof(float[3]), 1, fp); if (verbose) printf(" min = %f %f %f max = %f %f %f\n", minext[0], minext[1], minext[2], maxext[0], maxext[1], maxext[2]); //fread(&nverts, sizeof(int), 1, fp); //fread(&ncells, sizeof(int), 1, fp); if (verbose) printf("%d verts, %d cells\n", Dataslc::nverts, Dataslc::ncells); // compute gradients vgrad = (float (*)[3])malloc(sizeof(float[3])*getNVerts()); if (verbose) printf("processing cells\n"); for (i=0; i 1) printf("scaling vgrad %d\n", i); len = (float)sqrt(vgrad[i][0]*vgrad[i][0] + vgrad[i][1]*vgrad[i][1] + vgrad[i][2]*vgrad[i][2]); if (len != 0.0) { vgrad[i][0] /= len; vgrad[i][1] /= len; vgrad[i][2] /= len; } } } //------------------------------------------------------------------------ // // compLength() - // //------------------------------------------------------------------------ float *Dataslc::compLength(u_int &len, float **funx) { float *val = (float *)malloc(sizeof(float)*FSAMPLES); float *fx = (float *)malloc(sizeof(float)*FSAMPLES); u_int c; u_int *v; len = FSAMPLES; memset(val, 0, sizeof(float)*len); *funx = fx; for (c=0; c #include "utilities.h" //@ManMemo: A templated FIFO queue /*@Doc: Implementation of a FIFO queue based on a circular array. Memory is allocated in blocks, given as a parameter when the object is created, or if no parameter is given, using the default block size. Note: Currently, when a new block of memory is allocated, all of the current Queue is recopied (because it is circular you cannot just increase the array size), so use caution when picking the block size. */ template class Queue { public: //@ManDoc: Constructor with user define block size. Queue(int blocksize=0); //@ManDoc: Destructor. virtual ~Queue(); //@ManDoc: Returns whether the Queue is empty or not. inline bool isEmpty(); //@ManDoc: Returns the element at the head, or NULL if the Queue is empty. inline T* first(); //@ManDoc: Places an item at the end of the queue. int enqueue(T &e ); //@ManDoc: Remove \& return the item at the head of the array. T* dequeue(); T* getItem(int i) { return(&q[i]); } int getHead(void) {return(head);} int getLength(void) {return(length);} int getRoom(void) { return(room); } protected: int head; // Beginning of the circular array int tail; // End of the circular array int length; // Length of the array int block; // Number of Ts to allocate memory for int room; // Total number of Ts memory is allocated for T *q; // Actual array that contains memory }; /*****************************************************************************\ * inline functions \*****************************************************************************/ template inline bool Queue< T >::isEmpty() { return (bool)(length == 0); } template inline T* Queue< T >::first() { if( length == 0 ) return 0; return &q[head]; } template inline Queue< T >::Queue(int blocksize) { head = 0; tail = 0; length = 0; if( blocksize == 0 ) { block = (size_t(1) > size_t(4096/sizeof(T)) ? size_t(1) : size_t(4096/sizeof(T))); } else { block = blocksize; } room = block; q = (T*)malloc(room*sizeof( T ) ); // assert(q); } template inline Queue< T >::~Queue() { free(q); } template inline int Queue< T >::enqueue(T &e ) { int i, j; int loc; T* t; // enough room ? if( length == room ) { t = (T*)malloc( (room+block)*sizeof(T) ); // assert(t); for( j = head, i = 0; i < length; i++ ) { t[i] = q[j]; j++; if( j == room ) { j = 0; } } room += block; free( q ); q = t; head = 0; tail = length; } /* insert new element */ q[loc=tail] = e; length++; tail++; if( tail == room ) { tail = 0; } return(loc); } template inline T* Queue< T >::dequeue() { T* t; if( length == 0 ) { return (T*)0; } else { t = &q[head]; length--; head++; if( head == room ) { head = 0; } return t; } } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/shelf.cpp0000644000175000017500000000061010335221374025112 0ustar debiandebian/*****************************************************************************\ * * shelf.cc -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - Dec. 14, 1995 * \*****************************************************************************/ // $Id: shelf.cpp,v 1.2 2005/11/11 23:02:20 annao Exp $ #include #include #include "shelf.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedcells.cpp0000644000175000017500000000272511065020741025761 0ustar debiandebian//------------------------------------------------------------ // // seedCells.C - maintain the list of seed cells // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------ // $Id: seedcells.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #if ! defined (__APPLE__) #include #else #include #endif #include "seedcells.h" #include extern int verbose; //------------------------------------------------------------ // // SeedCells() - initialize the list // //------------------------------------------------------------ SeedCells::SeedCells() { ncells = 0; cell_size = 10000; cells = (SeedCellP)malloc(sizeof(struct SeedCell) * cell_size); } //------------------------------------------------------------ // // ~SeedCells() - free storage // //------------------------------------------------------------ SeedCells::~SeedCells() { if (verbose) { printf ("SeedCells destructor\n"); } free(cells); } //------------------------------------------------------------ // // AddSeed() - add a seed cell, increasing storage as necessary // //------------------------------------------------------------ int SeedCells::AddSeed(u_int id, float min, float max) { int n = ncells++; if (n >= cell_size) { cell_size *= 2; cells = (SeedCellP)realloc(cells, sizeof(struct SeedCell) * cell_size); } cells[n].cell_id = id; cells[n].min = min; cells[n].max = max; return(n); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/seedall.cpp0000644000175000017500000000210011065020741025412 0ustar debiandebian//------------------------------------------------------------------------ // // seedAll.C - preprocessing of 2d volumes for seed set extraction // //------------------------------------------------------------------------ // $Id: seedall.cpp,v 1.3 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #ifndef WIN32 #include #endif #include "seedall.h" #include "datareg2.h" #define DEBUGNo extern int verbose; //------------------------------------------------------------------------ // //------------------------------------------------------------------------ void seedAll::compSeeds(void) { u_int c; float min, max; int nseed; if (verbose) printf("***** Seed Creation\n"); // proceed through the slices computing seeds nseed=0; for (c=0; c #ifndef WIN32 #include #endif #include "data.h" #include "endian_io.h" extern int verbose; #define normalize(v) { \ float len; \ len = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]); \ if (len != 0.0) { \ v[0] /= len; \ v[1] /= len; \ v[2] /= len; \ } \ } //-------------------------------------------------------------------- // // Datavol - a volume of scalar data. // //-------------------------------------------------------------------- class Datavol : public Data { private: // data members float (*grad)[3]; // gradients for each vertex float (*verts)[3]; // array of mesh vertices u_int (*cells)[4]; // cells (tetrahedra) in the mesh int (*celladj)[4]; // indices to adjacent mesh cells public: // constructors and destructors inline Datavol(Data::DataType, int nd=1, char *rawfile=NULL); Datavol(Data::DataType t, u_int ndata, u_int nverts, u_int ncells, double *verts, u_int *cells, int *celladj, u_char *data); virtual inline ~Datavol(); // signature function methods int getNFunctions(void) { return(4); } float *compFunction(int, u_int &, float **); float *compFunction(int, u_int &, float ***, float ***, float ***){return(NULL);} // add by fan char *fName(int); protected: float *compLength(u_int&, float**); // signature functions float *compArea(u_int&, float**); float *compMaxArea(u_int&, float**); float *compGradient(u_int&, float**); void compGrad(void); // to compute gradients (?) public : // get data or gradient approximations (by differencing) u_int *getCell(int c) const { return(cells[c]); } int *getCellAdjs(int c) const { return(celladj[c]); } float *getVert(int v) const { return(verts[v]); } float *getGrad(int v) const { return(grad[v]); } void getCellValues(int c, float *val) { val[0] = getValue(cells[c][0]); val[1] = getValue(cells[c][1]); val[2] = getValue(cells[c][2]); val[3] = getValue(cells[c][3]); } u_int *getCellVerts(int c) { return(cells[c]); } u_int getCellVert(int c, int v) {return(cells[c][v]); } void getCellGrad4(int c, float grad[4]) { float u[4], v[4], w[4]; u[0] = verts[cells[c][1]][0] - verts[cells[c][0]][0]; u[1] = verts[cells[c][1]][1] - verts[cells[c][0]][1]; u[2] = verts[cells[c][1]][2] - verts[cells[c][0]][2]; u[3] = getValue(cells[c][1]) - getValue(cells[c][0]); v[0] = verts[cells[c][2]][0] - verts[cells[c][0]][0]; v[1] = verts[cells[c][2]][1] - verts[cells[c][0]][1]; v[2] = verts[cells[c][2]][2] - verts[cells[c][0]][2]; v[3] = getValue(cells[c][2]) - getValue(cells[c][0]); w[0] = verts[cells[c][3]][0] - verts[cells[c][0]][0]; w[1] = verts[cells[c][3]][1] - verts[cells[c][0]][1]; w[2] = verts[cells[c][3]][2] - verts[cells[c][0]][2]; w[3] = getValue(cells[c][3]) - getValue(cells[c][0]); grad[0] = u[1]*(v[2]*w[3]-v[3]*w[2]) + u[2]*(v[3]*w[1]-v[1]*w[3]) + u[3]*(v[1]*w[2]-v[2]*w[1]); grad[1] = u[0]*(v[2]*w[3]-v[3]*w[2]) + u[2]*(v[3]*w[0]-v[0]*w[3]) + u[3]*(v[0]*w[2]-v[2]*w[0]); grad[2] = u[0]*(v[1]*w[3]-v[3]*w[1]) + u[1]*(v[3]*w[0]-v[0]*w[3]) + u[3]*(v[0]*w[1]-v[1]*w[0]); grad[3] = u[0]*(v[1]*w[2]-v[2]*w[1]) + u[1]*(v[2]*w[0]-v[0]*w[2]) + u[2]*(v[0]*w[1]-v[1]*w[0]); if (verbose) if (grad[3] == 0.0) { printf("hmm\n"); printf("u = %f %f %f %f\n", u[0], u[1], u[2], u[3]); printf("v = %f %f %f %f\n", v[0], v[1], v[2], v[3]); printf("w = %f %f %f %f\n", w[0], w[1], w[2], w[3]); printf("v0 = %f %f %f %f\n", verts[cells[c][0]][0], verts[cells[c][0]][1], verts[cells[c][0]][2], getValue(cells[c][0])); printf("v1 = %f %f %f %f\n", verts[cells[c][1]][0], verts[cells[c][1]][1], verts[cells[c][1]][2], getValue(cells[c][1])); printf("v2 = %f %f %f %f\n", verts[cells[c][2]][0], verts[cells[c][2]][1], verts[cells[c][2]][2], getValue(cells[c][2])); printf("v3 = %f %f %f %f\n", verts[cells[c][3]][0], verts[cells[c][3]][1], verts[cells[c][3]][2], getValue(cells[c][3])); printf("tet=%d %d %d %d\n", cells[c][0], cells[c][1], cells[c][2], cells[c][3]); #ifndef WIN32 sleep(4); #endif } } virtual u_int getNCellVerts(void) { return(4); } virtual u_int getNCellFaces(void) { return(4); } virtual int getCellAdj(int c, int f) { return(celladj[c][f]); } virtual void getCellRange(int c, float &min, float &max) { float t; max = min = getValue(cells[c][0]); if ((t=getValue(cells[c][1])) < min) min = t; if (t > max) max = t; if ((t=getValue(cells[c][2])) < min) min = t; if (t > max) max = t; if ((t=getValue(cells[c][3])) < min) min = t; if (t > max) max = t; } virtual void getFaceRange(u_int c, u_int f, float &min, float &max) { float t; u_int i; min = 1e10; max = -1e10; for (i=0; i max) max = t; } } }; //------------------------------------------------------------------------ // // compGrad() - compute gradients // //------------------------------------------------------------------------ inline void Datavol::compGrad(void) { u_int i; float u[4], v[4], w[4], x[4], y[4], z[4], g[4]; int v0, v1, v2, v3; float len; float weight; memset(grad, 0, sizeof(float[3])*getNVerts()); for (i=0; i 1) printf("grad for cell %d\n", i); v0 = cells[i][0]; v1 = cells[i][1]; v2 = cells[i][2]; v3 = cells[i][3]; u[0] = verts[v1][0] - verts[v0][0]; u[1] = verts[v1][1] - verts[v0][1]; u[2] = verts[v1][2] - verts[v0][2]; u[3] = getValue(v1) - getValue(v0); v[0] = verts[v2][0] - verts[v0][0]; v[1] = verts[v2][1] - verts[v0][1]; v[2] = verts[v2][2] - verts[v0][2]; v[3] = getValue(v2) - getValue(v0); w[0] = verts[v3][0] - verts[v0][0]; w[1] = verts[v3][1] - verts[v0][1]; w[2] = verts[v3][2] - verts[v0][2]; w[3] = getValue(v3) - getValue(v0); x[0] = verts[v3][0] - verts[v1][0]; x[1] = verts[v3][1] - verts[v1][1]; x[2] = verts[v3][2] - verts[v1][2]; y[0] = verts[v3][0] - verts[v2][0]; y[1] = verts[v3][1] - verts[v2][1]; y[2] = verts[v3][2] - verts[v2][2]; z[0] = verts[v2][0] - verts[v1][0]; z[1] = verts[v2][1] - verts[v1][1]; z[2] = verts[v2][2] - verts[v1][2]; g[0] = u[1] * (v[2]*w[3] - v[3]*w[2]) + u[2] * (v[3]*w[1] - v[1]*w[3]) + u[3] * (v[1]*w[2] - v[2]*w[1]); g[1] = u[0] * (v[2]*w[3] - v[3]*w[2]) + u[2] * (v[3]*w[0] - v[0]*w[3]) + u[3] * (v[0]*w[2] - v[2]*w[0]); g[2] = u[0] * (v[1]*w[3] - v[3]*w[1]) + u[1] * (v[3]*w[0] - v[0]*w[3]) + u[3] * (v[0]*w[1] - v[1]*w[0]); if (verbose > 1) printf(" grad %f %f %f\n", g[0], g[1], g[2]); #if 0 { len = sqrt(g[0]*g[0] + g[1]*g[1] + g[2]*g[2]); if (len != 0.0) { g[0]/=len; g[1]/=len; g[2]/=len; } } normalize(u); normalize(v); normalize(w); normalize(x); normalize(y); normalize(z); #endif if (verbose) if (v0 == 101 || v1 == 101 || v2 == 101 || v3 == 101) printf("v100: %f %f %f\n", g[0], g[1], g[2]); weight = u[0]*(v[1]*w[2] - v[2]*w[1]) - u[1]*(v[2]*w[0] - v[0]*w[2]) + u[2]*(v[0]*w[1] - v[1]*w[0]); weight=1; grad[v0][0] += g[0] * weight; grad[v0][1] += g[1] * weight; grad[v0][2] += g[2] * weight; weight = (-u[0])*(x[1]*z[2] - x[2]*z[1]) - (-u[1])*(x[2]*z[0] - x[0]*z[2]) + (-u[2])*(x[0]*z[1] - x[1]*z[0]); weight=1; grad[v1][0] += g[0] * weight; grad[v1][1] += g[1] * weight; grad[v1][2] += g[2] * weight; weight = (-v[0])*((-z[1])*y[2] - (-z[2])*y[1]) - (-v[1])*((-z[2])*y[0] - (-z[0])*y[2]) + (-v[2])*((-z[0])*y[1] - (-z[1])*y[0]); weight=1; grad[v2][0] += g[0] * weight; grad[v2][1] += g[1] * weight; grad[v2][2] += g[2] * weight; weight = (-w[0])*((-y[1])*(-x[2]) - (-y[2])*(-x[1])) - (-w[1])*((-y[2])*(-x[0]) - (-y[0])*(-x[2])) + (-w[2])*((-y[0])*(-x[1]) - (-y[1])*(-x[0])); weight=1; grad[v3][0] += g[0] * weight; grad[v3][1] += g[1] * weight; grad[v3][2] += g[2] * weight; } for (i=0; i 1) printf("scaling vgrad %d\n", i); len = (float)(sqrt(grad[i][0]*grad[i][0] + grad[i][1]*grad[i][1] + grad[i][2]*grad[i][2])); if (len != 0.0) { grad[i][0] /= len; grad[i][1] /= len; grad[i][2] /= len; } } if (verbose) printf("grad101 = %f %f %f\n", grad[101][0], grad[101][1], grad[101][2]); } //------------------------------------------------------------------------ // // Datavol() - create a volume with the specified type and dimensions with // data taken from the given file // //------------------------------------------------------------------------ inline Datavol::Datavol(Data::DataType t, int nd, char *fn) : Data(t, nd, fn) { u_int i; verts = (float (*)[3])malloc(sizeof(float[3])*getNVerts()); cells = (u_int (*)[4])malloc(sizeof(u_int[4])*getNCells()); celladj = (int (*)[4])malloc(sizeof(int[4])*getNCells()); grad = (float (*)[3])malloc(sizeof(float[3])*getNVerts()); //fread(verts, sizeof(float[3]), getNVerts(), fp); fread_float(verts, sizeof(float), 3 * getNVerts(), fp); for (i=0; i 1) printf("cell %d: %d %d %d %d (%d %d %d %d)\n", i, cells[i][0], cells[i][1], cells[i][2], cells[i][3], celladj[i][0], celladj[i][1], celladj[i][2], celladj[i][3]); } for (i=0; i #if ! defined (__APPLE__) #include #else #include #endif #include #include "datavol.h" #include "compute.h" #include "endian_io.h" #define FSAMPLES 256 extern int verbose; //------------------------------------------------------------------------ // // Datavol() - alternative constructor for the libcontour library // //------------------------------------------------------------------------ Datavol::Datavol(Data::DataType t, u_int ndata, u_int nverts, u_int ncells, double *_verts, u_int *_cells, int *_celladj, u_char *data) : Data(t, ndata, data) { u_int i; Datavol::nverts = nverts; // initializations Datavol::ncells = ncells; verts = (float (*)[3])_verts; cells = (u_int (*)[4])_cells; celladj = (int (*)[4])_celladj; if (verbose) printf("computing extent\n"); // compute data extents minext[0] = minext[1] = minext[2] = 1e10; maxext[0] = maxext[1] = maxext[2] = -1e10; for (i = 0; i < nverts; i++) { if (verts[i][0] < minext[0]) minext[0] = verts[i][0]; if (verts[i][0] > maxext[0]) maxext[0] = verts[i][0]; if (verts[i][1] < minext[1]) minext[1] = verts[i][1]; if (verts[i][1] > maxext[1]) maxext[1] = verts[i][1]; if (verts[i][2] < minext[2]) minext[2] = verts[i][2]; if (verts[i][2] > maxext[2]) maxext[2] = verts[i][2]; } //fread(minext, sizeof(float[3]), 1, fp); //fread(maxext, sizeof(float[3]), 1, fp); if (verbose) printf(" min = %f %f %f max = %f %f %f\n", minext[0], minext[1], minext[2], maxext[0], maxext[1], maxext[2]); //fread(&nverts, sizeof(int), 1, fp); //fread(&ncells, sizeof(int), 1, fp); if (verbose) printf("%d verts, %d cells\n", Datavol::nverts, Datavol::ncells); // compute gradients grad = (float (*)[3])malloc(sizeof(float[3])*getNVerts()); //fread(verts, sizeof(float[3]), getNVerts(), fp); for (i=0; i 1) printf("cell %d: %d %d %d %d (%d %d %d %d)\n", i, cells[i][0], cells[i][1], cells[i][2], cells[i][3], celladj[i][0], celladj[i][1], celladj[i][2], celladj[i][3]); } for (i=0; i #define MIN2(x,y) ((x)<(y)?(x):(y)) #define MAX2(x,y) ((x)>(y)?(x):(y)) #define MIN3(x,y,z) ((x)<(y)?((x)<(z)?(x):(z)):((y)<(z)?(y):(z))) #define MAX3(x,y,z) ((x)>(y)?((x)>(z)?(x):(z)):((y)>(z)?(y):(z))) #define MIN4(x,y,z,w) ((x)<(y)?((x)<(z)?((x)<(w)?(x):(w)):((w)<(z)?(w):(z))):\ ((y)<(z)?((y)<(w)?(y):(w)):((z)<(w)?(z):(w)))) #define MAX4(x,y,z,w) ((x)>(y)?((x)>(z)?((x)>(w)?(x):(w)):((w)>(z)?(w):(z))):\ ((y)>(z)?((y)>(w)?(y):(w)):((z)>(w)?(z):(w)))) #define MIN6(min,a1,a2,a3,a4,a5,a6) \ do { \ float __min1, __min2; \ __min1 = MIN3(a1,a2,a3); \ __min2 = MIN3(a4,a5,a6); \ min = MIN2(__min1, __min2); \ } while (0) #define MAX6(max,a1,a2,a3,a4,a5,a6) \ do { \ float __max1, __max2; \ __max1 = MAX3(a1,a2,a3); \ __max2 = MAX3(a4,a5,a6); \ max = MAX2(__max1, __max2); \ } while (0) #define MIN7(min,a1,a2,a3,a4,a5,a6,a7) \ do { \ float __min1, __min2; \ __min1 = MIN3(a1,a2,a3); \ __min2 = MIN4(a4,a5,a6,a7); \ min = MIN2(__min1, __min2); \ } while (0) #define MAX7(max,a1,a2,a3,a4,a5,a6,a7) \ do { \ float __max1, __max2; \ __max1 = MAX3(a1,a2,a3); \ __max2 = MAX4(a4,a5,a6,a7); \ max = MAX2(__max1, __max2); \ } while (0) #define MIN8(min,a1,a2,a3,a4,a5,a6,a7,a8) \ do { \ float __min1, __min2; \ __min1 = MIN4(a1,a2,a3,a4); \ __min2 = MIN4(a5,a6,a7,a8); \ min = MIN2(__min1, __min2); \ } while (0) #define MAX8(max,a1,a2,a3,a4,a5,a6,a7,a8) \ do { \ float __max1, __max2; \ __max1 = MAX4(a1,a2,a3,a4); \ __max2 = MAX4(a5,a6,a7,a8); \ max = MAX2(__max1, __max2); \ } while (0) #define MIN4MERGE(min,a1,a2,a3,a4) \ do { \ float __min; \ __min = MIN4(a1,a2,a3,a4); \ if (__min < min) min = __min; \ } while (0) #define MAX4MERGE(max,a1,a2,a3,a4) \ do { \ float __max; \ __max = MAX4(a1,a2,a3,a4); \ if (__max > max) max = __max; \ } while (0) #include "cellsearch.h" //---------------------------------------------------------------------------- // // Segment Tree Class // //---------------------------------------------------------------------------- class SegTree : public CellSearch { public: SegTree(u_int n = 0, float *v = NULL); ~SegTree(); void Done(void) {} void Init(u_int n, float *v); void Dump(void); void Info(void); void Traverse(float, void (*f)(u_int, void*), void *); u_int getCells(float, u_int *); void InsertSeg(u_int cellid, float min, float max) { InsertSegR(cellid, min, max, 0, nleaf-1, -1e10, 1e10); } protected: void InsertSegR(u_int, float, float, int, int, float, float); private: int nleaf; float *vals; CellBucket *leqthan; CellBucket *lessthan; CellBucket *grtrthan; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/regprop2.h0000644000175000017500000000072310064121655025223 0ustar debiandebian // $Id: regprop2.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef REG_PROP2_H #define REG_PROP2_H #include "range.h" #include "seedcells.h" #include "conplot.h" #include "data.h" class Datavol; class Dataslc; class regProp2 { public: regProp2(Data &d, SeedCells &s, Conplot &p) : data(d), seeds(s), plot(p) {} ~regProp2() {} void compSeeds(void); private: Data &data; SeedCells &seeds; Conplot &plot; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/shelf.h0000644000175000017500000002030710352632600024561 0ustar debiandebian/*****************************************************************************\ * * shelf.h -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - Dec. 14, 1995 * \*****************************************************************************/ // $Id: shelf.h,v 1.4 2005/12/22 23:23:44 annao Exp $ #ifndef __SHELF_H #define __SHELF_H #include #include #include "basic.h" #ifdef sparc #define INLINE inline #else #define INLINE #endif template class Shelf; template class ShelfItem { friend class Shelf; friend std::ostream& operator<<(std::ostream &os, const Shelf& s); private: T data; int prev; int next; }; /** A templated double-linked list with direct access. Shelf is a simple templated container class. Objects of the templated class T can be added or removed from the Shelf. When an object is created, an integer index is returned, and this index is guaranteed not to change until deletion. Memory for objects in the shelf is allocated upon need. Memory previously used by removed objects is reused. Notice however that a shelf never returns allocated memory to the free store. Objects are kept in a double-linked list, so sequencing through all objects in the shelf is efficiently supported. Two Shelf objects to which exactly the same sequence of add/remove operations is applied, are guaranteed to return the same index i at the next add operation. */ template class Shelf { public: /// Constructor. Shelf(int blocksize=0); /// Copy constructor. Shelf(const Shelf &shelf); /// Destructor. ~Shelf(); /// Assignment (returns a copy of the shelf and its contents). Shelf& operator=(const Shelf &s); /// Add an item to the shelf (return index). int put(const T& data); /// Add an uninitialized item to the shelf (return index). int put(); /// Remove item #index#. void remove(int index); /// Reinitialize data structure. void cleanUp(); /// Move content of the shelf to a new shelf. void moveTo(Shelf& newshelf); /// Return the number of items currently in the shelf. int numItems() const; /// Return item #index#. T& operator[](int index); /// Return item #index#. const T& operator[](int index) const; /// Iterator. Init #index# to first item. void first(int &index) const; /// Iterator. Init #index# to last item. void last(int &index) const; /// Iterator. Test last-item condition. int end(int index) const; /// Iterator. Update #index# to next item. void next(int &index) const; /// Iterator. Update #index# to previous item. void prev(int &index) const; // for debugging friend std::ostream& operator<<(std::ostream &os, const Shelf& s); private: void grow(); // allocate more memory void init(int); void copy(const Shelf &s); void destroy(); ShelfItem& item(int index); const ShelfItem& item(int index) const; // DATA ShelfItem** _shelfbuffer; int _blockSize; int _first; int _last; int _freeList; int _nItems; int _nBuffers; int _lastBuffer; }; /*****************************************************************************\ * inline functions \*****************************************************************************/ template inline Shelf::Shelf(const Shelf &shelf) { copy(shelf); } template inline Shelf& Shelf::operator=(const Shelf &s) { if (&s == this) return *this; destroy(); copy(s); return *this; } template inline ShelfItem& Shelf::item(int index) { return _shelfbuffer[index / _blockSize][index % _blockSize]; } template inline const ShelfItem& Shelf::item(int index) const { return _shelfbuffer[index / _blockSize][index % _blockSize]; } template inline T& Shelf::operator[](int index) { return _shelfbuffer[index / _blockSize][index % _blockSize].data; } template inline const T& Shelf::operator[](int index) const { return _shelfbuffer[index / _blockSize][index % _blockSize].data; } template inline int Shelf::numItems() const { return _nItems; } template inline void Shelf::first(int &index) const { index = _first; } template inline void Shelf::last(int &index) const { index = _last; } template inline int Shelf::end(int index) const { return (index == INDEX_NULL ); } template inline void Shelf::next(int &index) const { index = item(index).next; } template inline void Shelf::prev(int &index) const { index = item(index).prev; } template inline Shelf::Shelf(int bs) { init(bs); } template inline Shelf::~Shelf() { destroy(); } template inline void Shelf::cleanUp() { int bs = _blockSize; destroy(); init(bs); } template inline void Shelf::moveTo(Shelf& newshelf) { memcpy( &newshelf, this, sizeof( Shelf ) ); // do not use operator= ! init(_blockSize); } template INLINE void Shelf::init(int bs) { if( bs == 0 ) { _blockSize = (size_t(1) > size_t(4096/sizeof(T)) ? size_t(1) : size_t(4096/sizeof(T))); } else { _blockSize = bs; } _nItems = 0; _shelfbuffer = 0; _first = INDEX_NULL; _last = INDEX_NULL; _freeList = INDEX_NULL; _nBuffers = 0; _lastBuffer = -1; } template INLINE void Shelf::copy(const Shelf &shelf) { int i; init(shelf._blockSize); for( shelf.first(i); !shelf.end(i); shelf.next(i) ) { put(shelf[i]); } } template INLINE void Shelf::destroy() { int i; for( first(i); !end(i); next(i) ) { item(i).data.~T(); } for( i = 0; i <= _lastBuffer; i++ ) { ::operator delete(_shelfbuffer[i]); } delete[] _shelfbuffer; } template INLINE int Shelf::put(const T& data) { // get one chunk of memory if( _freeList == INDEX_NULL ) { grow(); } int index = _freeList; _freeList = item(_freeList).next; // copy data item(index).data = data; // update pointers if( _nItems == 0 ) { _first = index; } else { item(_last).next = index; } item(index).prev = _last; item(index).next = INDEX_NULL; _last = index; ++_nItems; return _last; } template INLINE int Shelf::put() // leave data uninitialized { // get one chunk of memory if( _freeList == INDEX_NULL ) { grow(); } int index = _freeList; _freeList = item(_freeList).next; // update pointers if( _nItems == 0 ) { _first = index; } else { item(_last).next = index; } item(index).prev = _last; item(index).next = INDEX_NULL; _last = index; ++_nItems; return _last; } template INLINE void Shelf::remove(int index) { if( item(index).prev == INDEX_NULL ) { _first = item(index).next; } else { item(item(index).prev).next = item(index).next; } if( item(index).next == INDEX_NULL ) { _last = item(index).prev; } else { item(item(index).next).prev = item(index).prev; } item(index).data.~T(); item(index).next = _freeList; _freeList = index; --_nItems; } template INLINE void Shelf::grow() { // do we have room for a new buffer pointer? if( ++_lastBuffer == _nBuffers ) { if( _shelfbuffer != 0 ) { ShelfItem** tmp = _shelfbuffer; _shelfbuffer = new ShelfItem*[_nBuffers+10]; for(int i = 0; i < _nBuffers; i++) { _shelfbuffer[i] = tmp[i]; } delete[] tmp; _nBuffers+=10; } else { _shelfbuffer = new ShelfItem*[_nBuffers+=10]; } } // allocate buffer and initialize free list _shelfbuffer[_lastBuffer] = (ShelfItem*) ::operator new(size_t(_blockSize*sizeof(ShelfItem))); for( int i = 0; i < _blockSize-1; i++ ) { _shelfbuffer[_lastBuffer][i].next = _lastBuffer*_blockSize+i+1; } _shelfbuffer[_lastBuffer][_blockSize-1].next = _freeList; _freeList = _lastBuffer*_blockSize; } template INLINE std::ostream& operator<<(std::ostream& os, const Shelf& s ) { int i; os << "Data" << std::endl; for( s.first(i); !s.end(i); s.next(i) ) { os << s[i] << ' '; } os << std::endl << "Free" << std::endl; for( i = s._freeList; i != INDEX_NULL; i = s.item(i).next ) { os << i << ' '; } return os << std::endl; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/iqueue.h0000644000175000017500000001107411066274450024766 0ustar debiandebian/*****************************************************************************\ * * iqueue.h -- * * * Author: Fausto Bernardini (fxb@cs.purdue.edu) * * Created - June 15, 1993 * Ported to C++ by Raymund Merkert - June 1995 * Changes by Fausto Bernardini - Sept 1995 * \*****************************************************************************/ // $Id: iqueue.h,v 1.5 2008/09/23 23:18:00 annao Exp $ #ifndef __IQUEUE_H #define __IQUEUE_H #include "utilities.h" #include "queue.h" extern int verbose; template class IndexedQueue; template class Ihashrec { public: Ihashrec(T t, K k) { item=t; key=k; } void setLoc(int l) { qloc = l; } int getLoc(void) const { return(qloc); } bool eq(const K &k) const { return(k == key); } private: friend class IndexedQueue; // DATA T item; int qloc; K key; }; template class Iqueuerec { public: Iqueuerec(Ihashrec *r) { rec=r; } private: friend class IndexedQueue; // DATA Ihashrec *rec; }; //@ManMemo: A templated FIFO queue /*@Doc: Implementation of a FIFO queue based on a circular array. Memory is allocated in blocks, given as a parameter when the object is created, or if no parameter is given, using the default block size. Note: Currently, when a new block of memory is allocated, all of the current Queue is recopied (because it is circular you cannot just increase the array size), so use caution when picking the block size. */ template class IndexedQueue : public Queue< Iqueuerec > { public: //@ManDoc: Constructor with user define block size. IndexedQueue(int blocksize=0); //@ManDoc: Destructor. virtual ~IndexedQueue(); //@ManDoc: Returns the element at the head, or NULL if the Queue is empty. #ifdef SP2 // modified by Emilio: bug!! inline T* first() { return(Queue< Iqueuerec >::length == 0 ? 0 : &Queue< Iqueuerec >::q[Queue< Iqueuerec >::head].rec->item); } #else inline T* first() { return(&(Queue >::first()->rec->t)); } #endif //@ManDoc: Places an item at the end of the queue. void enqueue(T &e, K k); //@ManDoc: Remove \& return the item at the head of the array. int dequeue(T &e); T* find(K k); protected: static bool eqFun(const K &, const Ihashrec&); HashTable < Ihashrec, K > _h; }; /*****************************************************************************\ * inline functions \*****************************************************************************/ #define frac(x) ((x) - floor(x)) static int hashFun_iq(const int &i) { static double A = (sqrt(5.0)-1)/2.0; return((int)floor(30011 * frac(A*i))); } template bool IndexedQueue::eqFun(const K &k, const Ihashrec&hr) { return(hr.eq(k)); } template inline IndexedQueue< T, K >::IndexedQueue(int blocksize) : Queue< Iqueuerec >(blocksize), _h(30011, hashFun_iq, eqFun) { } template inline IndexedQueue< T, K >::~IndexedQueue() { } template inline void IndexedQueue< T, K >::enqueue(T &e, K key) { int pos; Ihashrec *inserted; if (verbose > 1) if (_h.fetch(key) != NULL) printf("adding same key!!\n"); _h.add(key, Ihashrec(e, key), inserted); // Emilio: the following line was giving a warning: parameter to enqueue // had to be an lvalue, substituted by code directly below it #ifdef EMILIO pos = Queue< Iqueuerec >::enqueue( Iqueuerec(inserted) ); #endif Iqueuerec inserted_rec(inserted); pos = Queue< Iqueuerec >::enqueue( inserted_rec ); inserted->setLoc(pos); } template inline int IndexedQueue< T, K >::dequeue(T &e) { Iqueuerec *item; item=Queue< Iqueuerec >::dequeue(); if (item == NULL) return(0); e = item->rec->item; _h.remove(item->rec->key); return(1); // return(&item->rec->item); } template inline T* IndexedQueue::find(K key) { Ihashrec *hr; hr = _h.fetch(key); if (hr == NULL) { if (verbose > 1) { int a, cur; cur=Queue< Iqueuerec >::head; for (a=0, cur=Queue< Iqueuerec >::head; a< Queue< Iqueuerec >::length; a++, cur=(cur==Queue< Iqueuerec >::room-1)?0:cur+1) { if (Queue< Iqueuerec >::q[cur].rec->key == key) { printf("ah-ha! I found it\n"); #ifndef WIN32 sleep(5); #endif } } } return(NULL); } return(&hr->item); } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/datareg2.h0000644000175000017500000001210710064121655025153 0ustar debiandebian//-------------------------------------------------------------------- // // Datareg2d - class for a 2d regular grid of scalar data // // Copyright (c) 1997 Dan Schikore - updated by Emilio Camahort, 1999 // //-------------------------------------------------------------------- // $Id: datareg2.h,v 1.1.1.1 2004/06/16 19:46:53 annao Exp $ #ifndef DATAREG2D_H #define DATAREG2D_H #include "data.h" // added by Emilio: these are forward declarations necessary to avoid // complaints by the new SGI C++ compiler class dirSeedsReg2; class regProp2; class respProp2; class seedChkr2; class Conplotreg2; //-------------------------------------------------------------------- // // Datareg2d - a volume of scalar data. // //-------------------------------------------------------------------- class Datareg2 : public Data { private: friend class dirSeedsReg2; // private friends friend class regProp2; friend class respProp2; friend class seedChkr2; u_int dim[2]; // data members float orig[2]; float span[2]; int xbits, ybits; int xmask, ymask; int yshift; public: // constructors and destructors Datareg2(Data::DataType, int ndata, char *rawfile); Datareg2(Data::DataType, int ndata, int *dim, u_char *data); inline ~Datareg2() {} // member access methods void getDim(u_int *v) { memcpy(v, dim, 2 * sizeof(u_int)); } void getOrig(float *v) { memcpy(v, orig, 2 * sizeof(float)); } void getSpan(float *v) { memcpy(v, span, 2 * sizeof(float)); } void setOrig (float _orig[2]) { orig[0] = _orig[0]; orig[1] = _orig[1]; } void setSpan (float _span[2]) { span[0] = _span[0]; span[1] = _span[1]; } float xCoord(int i) { return(orig[0] + i*span[0]); } float yCoord(int j) { return(orig[1] + j*span[1]); } int maxCellIndex(void) { return(index2cell(dim[0]-2, dim[1]-2)); } // signature function methods int getNFunctions(void) { return(4); } float *compFunction(int, u_int &, float **); float *compFunction(int, u_int &, float ***, float ***, float ***){return(NULL);} // add by fan char *fName(int); protected : // signature functions float *compLength(u_int &, float **); float *compArea(u_int &, float **); float *compMaxArea(u_int &, float **); float *compGradient(u_int &, float **); public : // get data or gradient approximations (by differencing) void getCellValues(int c, float *val) { int i,j; cell2index(c,i,j); getCellValues(i,j,val); } void getCellValues(int i, int j, float *val) { val[0] = getValue(index2vert(i,j)); val[1] = getValue(index2vert(i+1,j)); val[2] = getValue(index2vert(i+1,j+1)); val[3] = getValue(index2vert(i,j+1)); } u_int getCellVert(int c, int v) { int i, j; cell2index(c,i,j); switch (v) { case 0: return(index2vert(i,j)); case 1: return(index2vert(i+1,j)); case 2: return(index2vert(i+1,j+1)); case 3: return(index2vert(i,j+1)); } return(BAD_INDEX); } u_int getNCellVerts(void) { return(4); } u_int getNCellFaces(void) { return(4); } int getCellAdj(int c, int f) { int i, j; cell2index(c,i,j); switch (f) { case 0: return(j==0? -1 : index2cell(i,j-1)); case 1: return(i==(signed int)dim[0]-2? -1 : index2cell(i+1,j)); case 2: return(j==(signed int)dim[1]-2? -1 : index2cell(i,j+1)); case 3: return(i==0? -1 : index2cell(i-1,j)); } return(-1); } void getCellRange(int c, float &min, float &max) { float t; u_int i; max = min = getValue(getCellVert(c,0)); for (i=1; i max) max = t; } void getFaceRange(u_int c, u_int f, float &min, float &max) { float t; min = max = getValue(getCellVert(c,f)); if ((t=getValue(getCellVert(c,f<3?f+1:0))) < min) min = t; else if (t > max) max = t; } protected: friend class Conplotreg2; void cell2index(int c, int &i, int &j) { int _left; i = c&xmask; _left = c>>xbits; j = _left&ymask; } int index2cell(int i, int j) { return((j << yshift) | i); } int index2vert(int i, int j) { return(i*dim[1] + j); } }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/src/conplot3d.cpp0000644000175000017500000002604411065020741025723 0ustar debiandebian//------------------------------------------------------------------------ // // conPlot3d.C - preprocess and extract contours from 3d scalar data // // Copyright (c) 1997 Dan Schikore - modified by Emilio Camahort, 1999 // //------------------------------------------------------------------------ // $Id: conplot3d.cpp,v 1.4 2008/09/19 22:04:17 annao Exp $ #include #if ! defined (__APPLE__) #include #endif #include #include #ifndef WIN32 #include #endif #include "conplot.h" #include "contour3d.h" #include "range.h" #include "segtree.h" #include "conplot3d.h" extern int verbose; extern void (*errorHandler)(char *, int); //------------------------------------------------------------------------ // // unst3d, tetadj - static local variables // //------------------------------------------------------------------------ static int unst3d[16][7] = { {0}, {1, 0, 2, 3}, {1, 0, 4, 1}, {2, 2, 3, 1, 3, 4, 1}, {1, 2, 1, 5}, {2, 3, 1, 5, 3, 0, 1}, {2, 2, 0, 5, 0, 4, 5}, {1, 3, 4, 5}, {1, 3, 5, 4}, {2, 2, 5, 0, 0, 5, 4}, {2, 3, 5, 1, 3, 1, 0}, {1, 2, 5, 1}, {2, 2, 1, 3, 3, 1, 4}, {1, 0, 1, 4}, {1, 0, 3, 2}, {0} }; static int tetadj[16][5] = { {0}, {3, 1, 2, 3}, {3, 0, 2, 3}, {4, 0, 1, 2, 3}, {3, 0, 1, 3}, {4, 0, 1, 2, 3}, {4, 0, 1, 2, 3}, {3, 0, 1, 2}, {3, 0, 1, 2}, {4, 0, 1, 2, 3}, {4, 0, 1, 2, 3}, {3, 0, 1, 3}, {4, 0, 1, 2, 3}, {3, 0, 2, 3}, {3, 1, 2, 3}, {0}, }; //------------------------------------------------------------------------ // // Conplot() - create a contour plot for the given volume. // //------------------------------------------------------------------------ Conplot3d::Conplot3d(Datasetvol *d) : Conplot(d) { float min[3], max[3]; int i; vol = d; if (verbose > 1) { printf("***** Data Characteristics\n"); //printf("cells: %d\n", vol->getNCells()); printf("*****\n"); } contour2d = NULL; contour3d = con3 = new Contour3d[vol->nTime()]; data->getData(0)->getExtent(min, max); if (verbose) { printf("minextent: %f %f %f\n", min[0], min[1], min[2]); printf("maxextent: %f %f %f\n", max[0], max[1], max[2]); } for (i=0; inTime(); i++) con3[i].setExtent(min,max); if (verbose > 1) printf("contour2d is %x, contour3d is %x\n", contour2d, con3); } //------------------------------------------------------------------------ // // ~Conplot3d() - destroy a plot // //------------------------------------------------------------------------ Conplot3d::~Conplot3d() { if (verbose) printf("Conplot3d destructor: delete contour3d\n"); if (contour3d) delete [] contour3d; } //------------------------------------------------------------------------ // // InterpEdge() - // //------------------------------------------------------------------------ int Conplot3d::InterpEdge(int edge, float *val, u_int *v, float isovalue, int cell) { float ival; float pt[3]; float norm[3]; switch (edge) { case 0: ival = (isovalue-val[1])/(val[0]-val[1]); pt[0] = curvol->getVert(v[1])[0]*(1.0f-ival) + curvol->getVert(v[0])[0]*ival; pt[1] = curvol->getVert(v[1])[1]*(1.0f-ival) + curvol->getVert(v[0])[1]*ival; pt[2] = curvol->getVert(v[1])[2]*(1.0f-ival) + curvol->getVert(v[0])[2]*ival; norm[0] = curvol->getGrad(v[1])[0]*(1.0f-ival) + curvol->getGrad(v[0])[0]*ival; norm[1] = curvol->getGrad(v[1])[1]*(1.0f-ival) + curvol->getGrad(v[0])[1]*ival; norm[2] = curvol->getGrad(v[1])[2]*(1.0f-ival) + curvol->getGrad(v[0])[2]*ival; break; case 1: ival = (isovalue-val[2])/(val[1]-val[2]); pt[0] = curvol->getVert(v[2])[0]*(1.0f-ival) + curvol->getVert(v[1])[0]*ival; pt[1] = curvol->getVert(v[2])[1]*(1.0f-ival) + curvol->getVert(v[1])[1]*ival; pt[2] = curvol->getVert(v[2])[2]*(1.0f-ival) + curvol->getVert(v[1])[2]*ival; norm[0] = curvol->getGrad(v[2])[0]*(1.0f-ival) + curvol->getGrad(v[1])[0]*ival; norm[1] = curvol->getGrad(v[2])[1]*(1.0f-ival) + curvol->getGrad(v[1])[1]*ival; norm[2] = curvol->getGrad(v[2])[2]*(1.0f-ival) + curvol->getGrad(v[1])[2]*ival; break; case 2: ival = (isovalue-val[0])/(val[2]-val[0]); pt[0] = curvol->getVert(v[0])[0]*(1.0f-ival) + curvol->getVert(v[2])[0]*ival; pt[1] = curvol->getVert(v[0])[1]*(1.0f-ival) + curvol->getVert(v[2])[1]*ival; pt[2] = curvol->getVert(v[0])[2]*(1.0f-ival) + curvol->getVert(v[2])[2]*ival; norm[0] = curvol->getGrad(v[0])[0]*(1.0f-ival) + curvol->getGrad(v[2])[0]*ival; norm[1] = curvol->getGrad(v[0])[1]*(1.0f-ival) + curvol->getGrad(v[2])[1]*ival; norm[2] = curvol->getGrad(v[0])[2]*(1.0f-ival) + curvol->getGrad(v[2])[2]*ival; break; case 3: ival = (isovalue-val[0])/(val[3]-val[0]); pt[0] = curvol->getVert(v[0])[0]*(1.0f-ival) + curvol->getVert(v[3])[0]*ival; pt[1] = curvol->getVert(v[0])[1]*(1.0f-ival) + curvol->getVert(v[3])[1]*ival; pt[2] = curvol->getVert(v[0])[2]*(1.0f-ival) + curvol->getVert(v[3])[2]*ival; norm[0] = curvol->getGrad(v[0])[0]*(1.0f-ival) + curvol->getGrad(v[3])[0]*ival; norm[1] = curvol->getGrad(v[0])[1]*(1.0f-ival) + curvol->getGrad(v[3])[1]*ival; norm[2] = curvol->getGrad(v[0])[2]*(1.0f-ival) + curvol->getGrad(v[3])[2]*ival; break; case 4: ival = (isovalue-val[1])/(val[3]-val[1]); pt[0] = curvol->getVert(v[1])[0]*(1.0f-ival) + curvol->getVert(v[3])[0]*ival; pt[1] = curvol->getVert(v[1])[1]*(1.0f-ival) + curvol->getVert(v[3])[1]*ival; pt[2] = curvol->getVert(v[1])[2]*(1.0f-ival) + curvol->getVert(v[3])[2]*ival; norm[0] = curvol->getGrad(v[1])[0]*(1.0f-ival) + curvol->getGrad(v[3])[0]*ival; norm[1] = curvol->getGrad(v[1])[1]*(1.0f-ival) + curvol->getGrad(v[3])[1]*ival; norm[2] = curvol->getGrad(v[1])[2]*(1.0f-ival) + curvol->getGrad(v[3])[2]*ival; break; case 5: ival = (isovalue-val[2])/(val[3]-val[2]); pt[0] = curvol->getVert(v[2])[0]*(1.0f-ival) + curvol->getVert(v[3])[0]*ival; pt[1] = curvol->getVert(v[2])[1]*(1.0f-ival) + curvol->getVert(v[3])[1]*ival; pt[2] = curvol->getVert(v[2])[2]*(1.0f-ival) + curvol->getVert(v[3])[2]*ival; norm[0] = curvol->getGrad(v[2])[0]*(1.0f-ival) + curvol->getGrad(v[3])[0]*ival; norm[1] = curvol->getGrad(v[2])[1]*(1.0f-ival) + curvol->getGrad(v[3])[1]*ival; norm[2] = curvol->getGrad(v[2])[2]*(1.0f-ival) + curvol->getGrad(v[3])[2]*ival; break; } //printf("pt %f %f\n", pt[0], pt[1]); { float len = (float)sqrt(norm[0]*norm[0] + norm[1]*norm[1] + norm[2]*norm[2]); if (len != 0.0) { norm[0]/=len; norm[1]/=len; norm[2]/=len; } } return(curcon->AddVert(pt, norm)); } //------------------------------------------------------------------------ // // EnqueueFaces() - enqueue adjacent faces for propagation of contour // code = case table lookup code for current cell // i,j,k = index of current cell // thisslice = queue of cells to be processed on current slice // nextslice = queue of cells to be processed on next slice // trackinz = flag indicating whether to propagate in z-dir // 0 -> don't track in z, but queue cells in nextslice // 1 -> propagate contour in all 3 dim // //------------------------------------------------------------------------ inline void Conplot3d::EnqueueFaces(int code, int c, CellQueue &thisslice) { switch (code) { case 0: break; case 1: break; case 2: break; } } //------------------------------------------------------------------------ // // TrackContour() - compute and track a contour by table lookup and propagation // through adjacent cells // isovalue = surface value of interest // i,j,k = index of seed cell // nextslice = queue of seeds for next slice (used only if tracking in 2d) // //------------------------------------------------------------------------ void Conplot3d::TrackContour(float isovalue, int cell) { float val[4]; u_int *verts; u_int v1, v2, v3; int code; int adj; int e, a; int nvert=0, ntri=0; // to save isocontour components queue.Add(cell); curvol = (Datavol*)data->getData(curtime); curcon = &con3[curtime]; if (filePrefix) // keep track of current nvert, ntri { nvert = curcon->getNVert(); ntri = curcon->getNTri(); } while (queue.Get(cell) > 0) { curvol->getCellValues(cell, val); verts = curvol->getCellVerts(cell); code = 0; if (val[0] < isovalue) code += 0x01; if (val[1] < isovalue) code += 0x02; if (val[2] < isovalue) code += 0x04; if (val[3] < isovalue) code += 0x08; for (e=0; eAddTri(v1, v2, v3); for (a=0; agetCellAdj(cell, tetadj[code][a+1]); if (adj != -1 && !CellTouched(adj)) { TouchCell(adj); queue.Add(adj); } } } } if (filePrefix) // write this isocontour component { if (curcon->getNTri() - ntri > 25) // more than 25 triangles { FILE *fp; int v, t; char filename[200]; sprintf(filename, "%s%04d.ipoly", filePrefix, ncomponents); if ( (fp = fopen(filename, "w")) ) { fprintf(fp, "%d 0 %d 0 0 0 0\n0 0 0\n", curcon->getNVert() - nvert, curcon->getNTri() - ntri); for (v = nvert; v < curcon->getNVert(); v++) fprintf(fp, "%g %g %g\n", curcon->vert[v][0], curcon->vert[v][1], curcon->vert[v][2]); fprintf(fp, "0 0\n"); for (t = ntri; t < curcon->getNTri(); t++) fprintf(fp, "3\n%d %d %d\n", curcon->tri[t][0], curcon->tri[t][1], curcon->tri[t][2]); fclose(fp); ncomponents++; } else { char str[256]; sprintf(str, "Conplot3d::TrackContour: couldn't open file: %s", filename); errorHandler(str, FALSE); } } } } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/setup.py0000644000175000017500000001563310675045472024255 0ustar debiandebian# setup.py is used with Distutils for building isocontouring library # the "build" command builds the C++ library libisocontour.a # and the python extension _isocontour.so import sys, os from os import path from distutils.core import setup, Extension from distutils.command.build_clib import build_clib from distutils.command.build import build from distutils.command.install_data import install_data from distutils.command.sdist import sdist pack_name = "UTpackages.UTisocontour" ext_name = "_isocontour" platform = sys.platform # Lists of include dirs, pre-processor macros, libraries at link-time # (build_ext). import numpy numpy_include = numpy.get_include() incl_dir = [path.join(".", "src"), numpy_include] lib_dir = path.join(".", "lib", platform) macros = [("SP2", None), ("_BOOL", None), ("USEDICT", None)] comp_args = [] link_args = [] libs = [] if platform == "sunos5": #libs = ["contour", "Crun", "Cstd"] libs = ["Crun", "Cstd"] # 'contour' will be included by build_ext command #comp_args.extend(['-Kpic', '-mt']) macros = [("SP2", None), ("USEDICT", None)] elif platform == "win32": comp_args.append("/MT") macros.append(("WIN32", None)) elif platform == "irix6": libs = ["C",] comp_args.append( "-LANG:std" ) link_args.append( "-LANG:std" ) elif platform == "linux2": macros.append(("_LITTLE_ENDIAN", None)) elif platform == "darwin": macros.append(("MACOS_X", None)) # HACK: replace cc with CC (gcc with g++) CC_exe = 'CC' cc_exe = 'cc' if platform == "linux2" or platform == "darwin": CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to',`g[n]` if platform in ('sunos5', 'linux2', 'irix6', 'darwin'): sysconfig._init_posix = my_init_posix # Overwrite the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. class modified_sdist(sdist): def prune_file_list(self): build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) # Overwrite command build_clib with a derived "modified_build_clib" class # to use 'CC' for building static C++ library on irix platform # (instead of 'ar'). class modified_build_clib(build_clib): def build_libraries(self, libraries): if sys.platform == "irix6": self.compiler.archiver = ['CC', '-ar', '-o'] build_clib.build_libraries(self, libraries) # Change the order of commands that are called by "build" # so that 'build_py' comes after 'build_ext'. In this case # 'build_py' will install python modules generated by # 'build_ext'. class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] # Overwrite the run method of the install_data to install the data files # in the package. class modified_install_data(install_data): def run(self): install_cmd = self.get_finalized_command('install') self.install_dir = getattr(install_cmd, 'install_lib')+"UTpackages" print "install_dir", self.install_dir return install_data.run(self) # List of source files - to build C lib (build_clib). src_list = ["contour.cpp", "edgehash.cpp", "cellqueue.cpp", "range.cpp", "seedcells.cpp", "data.cpp", "dataslc.cpp", "datavol.cpp", "segtree.cpp", "contour2d.cpp", "contour3d.cpp", "conplot_p.cpp", "conplot.cpp", "conplot2d.cpp", "queue.cpp", "squeue.cpp", "rangeprop.cpp", "conplot3d.cpp", "rangesweep.cpp", "datareg2.cpp", "conplotreg2.cpp", "dirseeds.cpp", "inttree.cpp", "bucketsearch.cpp", "datareg3.cpp", "conplotreg3.cpp", "regprop.cpp", "dirseedsreg2.cpp", "regprop2.cpp", "seedchkr2.cpp", "seedchkr3.cpp", "seedall.cpp", "respprop2.cpp", "seeddirreg3.cpp", "cubes.cpp", "dict.c"] for i in range(len(src_list)): src_list[i] = path.join(".", "src", src_list[i] ) src_list.append(path.join("UTisocontour", "isocontour.i")) #print "sorce list:" ,src_list data_files = [( path.join("UTisocontour", "Tests"), [path.join("UTisocontour", "Tests", "1ak3.C.map"), path.join("UTisocontour", "Tests", "pot-2eti-glucose-3fields.raw")] )] # the setup() does all the work: dist = setup(name = pack_name, #version="?", description = "Isocontour library extension module", author = "Molecular Graphics Laboratory", author_email = "mgltools@scripps.edu", url = "http://www.scripps.edu/~sanner/python/packager.html", packages = [pack_name, pack_name+".Tests"], package_dir = {pack_name: "UTisocontour"}, ext_package = pack_name, # use the derived command classes: data_files = data_files, cmdclass = {"build_clib" : modified_build_clib, "build" : modified_build, "install_data" : modified_install_data, "sdist" : modified_sdist}, ## libraries = [('contour', ## {'sources': src_list, ## 'macros': macros, ## 'include_dirs': incl_dir, ## #'library_dirs': library_dirs, ## #'extra_compile_args': # comp_args doesn't work ## } ),] , ext_modules = [Extension (ext_name, src_list, #[path.join("UTisocontour", "isocontour.i")], include_dirs = incl_dir, define_macros = macros, #library_dirs = [lib_dir], libraries = libs, extra_compile_args = comp_args, extra_link_args = link_args ) ] ,) # cp built .so from ./build/lib.platform to ./pack_name/ - for testing. ## from distutils.util import get_platform ## from distutils.file_util import copy_file ## plat_specifier = ".%s-%s" % (get_platform(), sys.version[0:3]) ## orig_ext = path.join(".", "build", "lib"+plat_specifier , pack_name, ext_name+".so") ## cp_ext = path.join(pack_name, ext_name+".so") ## if path.isfile(orig_ext): ## copy_file(orig_ext, cp_ext, update=1) ## else: ## print "file %s does not exist" % (orig_ext,) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/README0000644000175000017500000000245010223375661023407 0ustar debiandebianThis module builds a python extension of the isocontouring library developed in Chandrajit Bajaj's group at UT Austin (http://ccvweb.csres.utexas.edu/software). This distribution contains source code of the library (see src/Isocontour-license.txt). Distutils are used to wrap the library with SWIG (version 1.3.20 or higher), build the C++ library (libcontour.a) and build the python extension (_isocontour.so). To build and install the extension: python2.3 setup.py install This will: - build static library libcontour.a in ./build/temp.; - generate a python shadow class module isocontour.py in ./build/lib./UTpackages/UTisocontour - build _isocontour.so in ./build/lib./UTpackages/UTisocontour; - copy the package from ./build/lib. to sys.exec_prefix/lib/python2.3/site-packages/; The install command can be called with the following options: --install-platlib=INSTALL_DIR installs the package in specified INSTALL_DIR --no-compile do not compile .py to .pyc Example: python2.3 setup.py install --install-platlib=/home/myname/myinstalldir To build the extension only: python2.3 setup.py build To build source distribution: python2.3 setup.py sdist To build binary distribution: python2.3 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTisocontourDIST/MANIFEST.in0000644000175000017500000000073610234502452024262 0ustar debiandebianinclude MANIFEST.in include src/*.h include src/bin.cpp include src/hash.cpp include src/iqueue.cpp include src/ipqueue.cpp include src/shelf.cpp include src/main.cpp include src/Isocontour-license.txt include UTisocontour/Tests/*.map include UTisocontour/Tests/*.raw include UTisocontour/*.i include UTisocontour/*.hpp include UTisocontour/doc.tar.gz exclude UTisocontour/isocontour.py include CVS/* include UTisocontour/CVS/* include UTisocontour/Tests/CVS/* include src/CVS/*mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/0000755000175000017500000000000012146213523021765 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/setup.cfg0000644000175000017500000000014110223377127023607 0ustar debiandebian# Important : this instructs distutils to build SWIG wrappers for C++ [build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/0000755000175000017500000000000012146213527022560 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/PalettedImpl.cpp0000644000175000017500000001554710223377127025665 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // PalettedImpl.cpp: implementation of the PalettedImpl class. // ////////////////////////////////////////////////////////////////////// #include "PalettedImpl.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// PalettedImpl::PalettedImpl() { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; } PalettedImpl::~PalettedImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool PalettedImpl::initRenderer() { if (!UnshadedBase::initRenderer() || !initExtensions() || !initTextureNames()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool PalettedImpl::checkCompatibility() const { MyExtensions tempExtensions; if (!tempExtensions.initExtensions("GL_VERSION_1_2 ") && !tempExtensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return tempExtensions.initExtensions( "GL_EXT_texture3D " "GL_EXT_paletted_texture " ); } // Uploads colormapped data bool PalettedImpl::uploadColormappedData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); if (width!=m_Width || height!=m_Height || depth!=m_Depth) { m_Extensions.glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_COLOR_INDEX8_EXT, width, height, depth, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, data); } else { m_Extensions.glTexSubImage3DEXT(GL_TEXTURE_3D_EXT, 0, 0,0,0, width, height, depth, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, data); } glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // save the width height and depth m_Width = width; m_HintDimX = width; m_Height = height; m_HintDimY = height; m_Depth = depth; m_HintDimZ = depth; // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Tests to see if the given parameters would return an error bool PalettedImpl::testColormappedData(int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // nothing above 512 if (width>512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; m_Extensions.glTexImage3DEXT(GL_PROXY_TEXTURE_3D_EXT, 0, GL_COLOR_INDEX8_EXT, width, height, depth, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Uploads the transfer function for the colormapped data bool PalettedImpl::uploadColorMap(const GLubyte* colorMap) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); m_Extensions.glColorTableEXT(GL_TEXTURE_3D_EXT, GL_RGBA8, 256, GL_RGBA, GL_UNSIGNED_BYTE, colorMap); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Performs the actual rendering. bool PalettedImpl::renderVolume() { // bail if we haven't been initialized properly if (!m_Initialized) return false; // set up the state glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColor4f(1.0, 1.0, 1.0, 1.0); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glEnable(GL_COLOR_TABLE); // This is for the paletted_texture color table //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDepthMask( GL_FALSE ); glEnable(GL_TEXTURE_3D_EXT); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); computePolygons(); convertToTriangles(); renderTriangles(); // restore the state glPopAttrib(); return true; } // Initializes the necessary extensions. bool PalettedImpl::initExtensions() { if (!m_Extensions.initExtensions("GL_VERSION_1_2 ") && !m_Extensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return m_Extensions.initExtensions( "GL_EXT_texture3D " "GL_EXT_paletted_texture " ); } // Gets the opengl texture IDs bool PalettedImpl::initTextureNames() { // clear previous errors GLenum error = glGetError(); // get the names glGenTextures(1, &m_DataTextureName); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Render the actual triangles void PalettedImpl::renderTriangles() { // set up the client render state glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); //glEnableClientState(GL_COLOR_ARRAY); glTexCoordPointer(3, GL_FLOAT, 0, m_TextureArray); glVertexPointer(3, GL_FLOAT, 0, m_VertexArray); //glColorPointer(3, GL_FLOAT, 0, m_TextureArray); // render the triangles glDrawElements(GL_TRIANGLES, m_NumTriangles*3, GL_UNSIGNED_INT, m_TriangleArray); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); //glDisableClientState(GL_COLOR_ARRAY); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Extent.cpp0000644000175000017500000000331710223377127024540 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Extent.cpp: implementation of the Extent class. // ////////////////////////////////////////////////////////////////////// #include "Extent.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Extent::Extent() { setExtents(0, 0, 0, 1, 1, 1); } Extent::Extent( double xMin, double yMin, double zMin, double xMax, double yMax, double zMax ) { setExtents(xMin, yMin, zMin, xMax, yMax, zMax); } Extent::~Extent() { } void Extent::setExtents( double minX, double minY, double minZ, double maxX, double maxY, double maxZ ) { m_MinX = minX; m_MaxX = maxX; m_MinY = minY; m_MaxY = maxY; m_MinZ = minZ; m_MaxZ = maxZ; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/ClipCube.h0000644000175000017500000000504010223377127024417 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // ClipCube.h: interface for the ClipCube class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_CLIPCUBE_H__01A55CB5_9394_4F10_81A4_444B72A44AF9__INCLUDED_) #define AFX_CLIPCUBE_H__01A55CB5_9394_4F10_81A4_444B72A44AF9__INCLUDED_ #include "Polygon.h" #include "Plane.h" namespace OpenGLVolumeRendering { /** A simple class to aid in intersecting a plane and a cube */ class ClipCube { public: ClipCube(); ClipCube(double ratioX, double ratioY, double ratioZ, double minX=0, double minY=0, double minZ=0, double maxX=1, double maxY=1, double maxZ=1); virtual ~ClipCube(); /** Sets the aspect ratio of the cube. The cubes longest edge has length 1. */ bool setAspectRatio(double ratioX, double ratioY, double ratioZ); /** Sets teh texture coordinates of the cube. */ bool setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ); /** * Clips the given plane againts the cube. Returns true if the plane intersects the * cube. The result is returned in result. */ bool clipPlane(Polygon& result, const Plane& plane) const; protected: double m_RatioX; double m_RatioY; double m_RatioZ; double m_TexCoords[8*3]; unsigned char getCaseAndCalculateSignedDistances(double* distances, const Plane& plane) const; double getAlphaForEdge(double * distances, unsigned int edgeIndex) const; void interpVertCoords(double * vert, double alpha, unsigned int edgeIndex) const; void interpTexCoords(double * texCoord, double alpha, unsigned int edgeIndex) const; }; }; #endif // !defined(AFX_CLIPCUBE_H__01A55CB5_9394_4F10_81A4_444B72A44AF9__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/RendererBase.cpp0000644000175000017500000002567110223377127025641 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // RendererBase.cpp: implementation of the RendererBase class. // ////////////////////////////////////////////////////////////////////// #include "RendererBase.h" #include "Polygon.h" #include "ClipCube.h" #include using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// RendererBase::RendererBase() : m_PolygonArray(100) { initFlags(); initAspectRatio(); m_NumberOfPlanesRendered = 0; m_VertexArray = 0; m_TextureArray = 0; m_VertexArraySize = 0; m_TriangleArray = 0; m_TriangleArraySize = 0; m_NumVertices = 0; m_NumTriangles = 0; } RendererBase::~RendererBase() { deallocateMemory(); } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool RendererBase::initRenderer() { m_BaseInitialized = true; setQuality(1.0); setNearPlane(0.0); setTextureSubCube(0,0,0,1,1,1); setDataSubVolume(0,0,0,1,1,1); setHintDimensions(0,0,0); return true; } // Sets the aspect ratio of the dataset. bool RendererBase::setAspectRatio(double ratioX, double ratioY, double ratioZ) { double maxratio; if (ratioX!=0.0 && ratioY!=0.0 && ratioZ!=0.0) { m_RatioX = ratioX; m_RatioY = ratioY; m_RatioZ = ratioZ; // find the maximum ratio maxratio = ( m_RatioX > m_RatioY ? m_RatioX : m_RatioY ); maxratio = ( maxratio > m_RatioZ ? maxratio : m_RatioZ ); // normalize so the max ratio is 1.0 m_RatioX /= maxratio; m_RatioY /= maxratio; m_RatioZ /= maxratio; return true; } else { return false; } } // Specifies the portion of the uploaded texture that should be rendered. // The extenst should range from 0 to 1. bool RendererBase::setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { m_TextureSubCubeExtent.setExtents(minX, minY, minZ, maxX, maxY, maxZ); return true; } // Specifies that we are rendering a subportion of the full data. // Used for out of core rendering. The extents should range from 0 to 1. bool RendererBase::setDataSubVolume(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { m_DataSubCubeExtent.setExtents(minX, minY, minZ, maxX, maxY, maxZ); return true; } // Used for out of core rendering. The dimensions of the full dataset bool RendererBase::setHintDimensions(unsigned int hintDimX, unsigned int hintDimY, unsigned int hintDimZ) { m_HintDimX = hintDimX; m_HintDimY = hintDimY; m_HintDimZ = hintDimZ; return true; } // Quality is a number from 0 to 1. Lower means faster. bool RendererBase::setQuality(double quality) { m_Quality = (quality>0.0?quality:0.0); m_Quality = (m_Quality<1.0?m_Quality:1.0); return true; } double RendererBase::getQuality() const { return m_Quality; } // nearPlane is a number from 0 to 1. 0 means no clipping takes place. // 1 means the entire volume is clipped. bool RendererBase::setNearPlane(double nearPlane) { m_NearPlane = (nearPlane>0.0?nearPlane:0.0); m_NearPlane = (m_NearPlane<1.0?m_NearPlane:1.0); return true; } double RendererBase::getNearPlane() { return m_NearPlane; } // Returns the number of planes rendered in the last call to // renderVolume. int RendererBase::getNumberOfPlanesRendered() const { return m_NumberOfPlanesRendered; } // Allocates memory for the vertices and triangles bool RendererBase::allocateMemory(unsigned int numVerts, unsigned int numTriangles) { // only allocate new memory if the old arrays aren't already // big enough if (numVerts>m_VertexArraySize) { if (!allocateVertexArray(numVerts)) { m_NumVertices = 0; m_NumTriangles = 0; return false; } } if (numTriangles>m_TriangleArraySize) { if (!allocateTriangleArray(numTriangles)) { m_NumVertices = 0; m_NumTriangles = 0; return false; } } m_NumVertices = numVerts; m_NumTriangles = numTriangles; return true; } // Deallocates the memory for vertices and triangles void RendererBase::deallocateMemory() { delete [] m_VertexArray; m_VertexArraySize = 0; delete [] m_TriangleArray; m_TriangleArraySize = 0; } // Allocate the vertex array bool RendererBase::allocateVertexArray(unsigned int numVerts) { delete [] m_VertexArray; delete [] m_TextureArray; m_VertexArray = new float[numVerts*3]; m_TextureArray = new float[numVerts*3]; if (m_VertexArray && m_TextureArray) { m_VertexArraySize = numVerts; return true; } else { m_VertexArraySize = 0; m_VertexArray = 0; m_TextureArray = 0; return false; } } // Allocate the triangle array bool RendererBase::allocateTriangleArray(unsigned int numTriangles) { delete [] m_TriangleArray; m_TriangleArray = new unsigned int[numTriangles*3]; if (m_TriangleArray) { m_TriangleArraySize = numTriangles; return true; } else { m_TriangleArraySize = 0; return false; } } // Converts the polygon array to traingle and vertex arrays void RendererBase::convertToTriangles() { // determine the number of triangles and vertices unsigned int numTriangles = 0; unsigned int numVerts = 0; unsigned int c; for (c=0; cgetNumTriangles(); numVerts+=m_PolygonArray.getPolygon(c)->getNumVerts(); } // set up the space for the triangles allocateMemory(numVerts, numTriangles); // fill up the arrays numTriangles = 0; numVerts = 0; unsigned int d; double * vertex; double * texture; // for each polygon for (c=0; cgetNumVerts(); d++) { vertex = m_PolygonArray.getPolygon(c)->getVert(d); texture = m_PolygonArray.getPolygon(c)->getTexCoord(d); m_VertexArray[(numVerts+d)*3+0] = (float)vertex[0]; m_VertexArray[(numVerts+d)*3+1] = (float)vertex[1]; m_VertexArray[(numVerts+d)*3+2] = (float)vertex[2]; m_TextureArray[(numVerts+d)*3+0] = (float)texture[0]; m_TextureArray[(numVerts+d)*3+1] = (float)texture[1]; m_TextureArray[(numVerts+d)*3+2] = (float)texture[2]; } // fill in the triangles for (d=0; dgetNumTriangles()*3; d++) { m_TriangleArray[(numTriangles*3)+d] = numVerts + m_PolygonArray.getPolygon(c)->getVertexForTriangles(d); } numTriangles+=m_PolygonArray.getPolygon(c)->getNumTriangles(); numVerts+=m_PolygonArray.getPolygon(c)->getNumVerts(); } } // Sets the aspectRatio to a default value. bool RendererBase::initAspectRatio() { m_RatioX = 1.0; m_RatioY = 1.0; m_RatioZ = 1.0; return true; } // Sets all flags to default values. bool RendererBase::initFlags() { m_BaseInitialized = false; return true; } // static helper function to concat two matrices static void concatMatrices(double* result, float* m1, float* m2) { int i; double mb00, mb01, mb02, mb03, mb10, mb11, mb12, mb13, mb20, mb21, mb22, mb23, mb30, mb31, mb32, mb33; double mai0, mai1, mai2, mai3; mb00 = m2[0]; mb01 = m2[1]; mb02 = m2[2]; mb03 = m2[3]; mb10 = m2[4]; mb11 = m2[5]; mb12 = m2[6]; mb13 = m2[7]; mb20 = m2[8]; mb21 = m2[9]; mb22 = m2[10]; mb23 = m2[11]; mb30 = m2[12]; mb31 = m2[13]; mb32 = m2[14]; mb33 = m2[15]; for (i = 0; i < 4; i++) { mai0 = m1[i*4+0]; mai1 = m1[i*4+1]; mai2 = m1[i*4+2]; mai3 = m1[i*4+3]; result[i*4+0] = (mai0 * mb00 + mai1 * mb10 + mai2 * mb20 + mai3 * mb30); result[i*4+1] = (mai0 * mb01 + mai1 * mb11 + mai2 * mb21 + mai3 * mb31); result[i*4+2] = (mai0 * mb02 + mai1 * mb12 + mai2 * mb22 + mai3 * mb32); result[i*4+3] = (mai0 * mb03 + mai1 * mb13 + mai2 * mb23 + mai3 * mb33); } } // Returns a plane parallel to the view plane. Plane RendererBase::getViewPlane() { GLfloat modelview[16], projection[16]; double combined[16]; // inverse transform the plane normal using the opengl matrices // the view plane is 0.0, 0.0, -1.0, 0.0 in clip coordinate // first, get the modelview and projection matrices glGetFloatv (GL_MODELVIEW_MATRIX, modelview); glGetFloatv (GL_PROJECTION_MATRIX, projection); // then concatinate the projection and modelview matrices concatMatrices(combined, modelview, projection); // then calculate the plane equation in object space // See http://www.opengl.org/developers/faqs/technical/viewcull.c // for how this operation was simplified Plane plane( combined[3]+combined[2], combined[7]+combined[6], combined[11]+ combined[10], 0.0); plane.normalizeNormal(); return plane; } // Returns the distance between planes. double RendererBase::getIntervalWidth() const { double cellWidthX = m_RatioX / m_HintDimX; double cellWidthY = m_RatioY / m_HintDimY; double cellWidthZ = m_RatioZ / m_HintDimZ; // find the minimum cell width double minWidth = ( cellWidthX < cellWidthY ? cellWidthX : cellWidthY ); minWidth = ( minWidth < cellWidthZ ? minWidth : cellWidthZ ); return minWidth / 2.0 * ((1.0-m_Quality)*(1.0-m_Quality) * 10.0 + 1.0); } // Returns a distance that is past the entire volume. double RendererBase::getFurthestDistance() const { return 0.5 * sqrt( m_RatioX*m_RatioX + m_RatioY*m_RatioY + m_RatioZ*m_RatioZ ); } // Returns a distance that is before the entire volume. double RendererBase::getNearestDistance() const { double diagonal = sqrt( m_RatioX*m_RatioX + m_RatioY*m_RatioY + m_RatioZ*m_RatioZ ); return (-0.5 * diagonal) + (m_NearPlane * diagonal); } // Computes the polygons that need to be rendered void RendererBase::computePolygons() { m_PolygonArray.clearPolygons(); Plane plane = getViewPlane(); ClipCube cube(m_RatioX, m_RatioY, m_RatioZ, m_TextureSubCubeExtent.m_MinX, m_TextureSubCubeExtent.m_MinY, m_TextureSubCubeExtent.m_MinZ, m_TextureSubCubeExtent.m_MaxX, m_TextureSubCubeExtent.m_MaxY, m_TextureSubCubeExtent.m_MaxZ); Polygon polygon(0); double z; for (z = getFurthestDistance(); z>getNearestDistance(); z-=getIntervalWidth()) { plane[3] = z; if (cube.clipPlane(polygon, plane)) { m_PolygonArray.addPolygon(polygon); } } m_NumberOfPlanesRendered = m_PolygonArray.getNumPolygons(); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/StaticExtensionPointers.h0000644000175000017500000022604710223377127027615 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef STATICEXTENSIONPOINTERS_H #define STATICEXTENSIONPOINTERS_H #if !defined(_WIN32) && !defined(GLX_ARB_get_proc_address) static bool staticPointersInitialized = false; // GL_VERSION_1_2 static MYPFNGLBLENDCOLORPROC staticPointerglBlendColor = 0; static MYPFNGLBLENDEQUATIONPROC staticPointerglBlendEquation = 0; static MYPFNGLDRAWRANGEELEMENTSPROC staticPointerglDrawRangeElements = 0; static MYPFNGLCOLORTABLEPROC staticPointerglColorTable = 0; static MYPFNGLCOLORTABLEPARAMETERFVPROC staticPointerglColorTableParameterfv = 0; static MYPFNGLCOLORTABLEPARAMETERIVPROC staticPointerglColorTableParameteriv = 0; static MYPFNGLCOPYCOLORTABLEPROC staticPointerglCopyColorTable = 0; static MYPFNGLGETCOLORTABLEPROC staticPointerglGetColorTable = 0; static MYPFNGLGETCOLORTABLEPARAMETERFVPROC staticPointerglGetColorTableParameterfv = 0; static MYPFNGLGETCOLORTABLEPARAMETERIVPROC staticPointerglGetColorTableParameteriv = 0; static MYPFNGLCOLORSUBTABLEPROC staticPointerglColorSubTable = 0; static MYPFNGLCOPYCOLORSUBTABLEPROC staticPointerglCopyColorSubTable = 0; static MYPFNGLCONVOLUTIONFILTER1DPROC staticPointerglConvolutionFilter1D = 0; static MYPFNGLCONVOLUTIONFILTER2DPROC staticPointerglConvolutionFilter2D = 0; static MYPFNGLCONVOLUTIONPARAMETERFPROC staticPointerglConvolutionParameterf = 0; static MYPFNGLCONVOLUTIONPARAMETERFVPROC staticPointerglConvolutionParameterfv = 0; static MYPFNGLCONVOLUTIONPARAMETERIPROC staticPointerglConvolutionParameteri = 0; static MYPFNGLCONVOLUTIONPARAMETERIVPROC staticPointerglConvolutionParameteriv = 0; static MYPFNGLCOPYCONVOLUTIONFILTER1DPROC staticPointerglCopyConvolutionFilter1D = 0; static MYPFNGLCOPYCONVOLUTIONFILTER2DPROC staticPointerglCopyConvolutionFilter2D = 0; static MYPFNGLGETCONVOLUTIONFILTERPROC staticPointerglGetConvolutionFilter = 0; static MYPFNGLGETCONVOLUTIONPARAMETERFVPROC staticPointerglGetConvolutionParameterfv = 0; static MYPFNGLGETCONVOLUTIONPARAMETERIVPROC staticPointerglGetConvolutionParameteriv = 0; static MYPFNGLGETSEPARABLEFILTERPROC staticPointerglGetSeparableFilter = 0; static MYPFNGLSEPARABLEFILTER2DPROC staticPointerglSeparableFilter2D = 0; static MYPFNGLGETHISTOGRAMPROC staticPointerglGetHistogram = 0; static MYPFNGLGETHISTOGRAMPARAMETERFVPROC staticPointerglGetHistogramParameterfv = 0; static MYPFNGLGETHISTOGRAMPARAMETERIVPROC staticPointerglGetHistogramParameteriv = 0; static MYPFNGLGETMINMAXPROC staticPointerglGetMinmax = 0; static MYPFNGLGETMINMAXPARAMETERFVPROC staticPointerglGetMinmaxParameterfv = 0; static MYPFNGLGETMINMAXPARAMETERIVPROC staticPointerglGetMinmaxParameteriv = 0; static MYPFNGLHISTOGRAMPROC staticPointerglHistogram = 0; static MYPFNGLMINMAXPROC staticPointerglMinmax = 0; static MYPFNGLRESETHISTOGRAMPROC staticPointerglResetHistogram = 0; static MYPFNGLRESETMINMAXPROC staticPointerglResetMinmax = 0; static MYPFNGLTEXIMAGE3DPROC staticPointerglTexImage3D = 0; static MYPFNGLTEXSUBIMAGE3DPROC staticPointerglTexSubImage3D = 0; static MYPFNGLCOPYTEXSUBIMAGE3DPROC staticPointerglCopyTexSubImage3D = 0; // End OpenGL version 1.2 // OpenGL version 1.3 static MYPFNGLACTIVETEXTUREPROC staticPointerglActiveTexture = 0; static MYPFNGLCLIENTACTIVETEXTUREPROC staticPointerglClientActiveTexture = 0; static MYPFNGLMULTITEXCOORD1DPROC staticPointerglMultiTexCoord1d = 0; static MYPFNGLMULTITEXCOORD1DVPROC staticPointerglMultiTexCoord1dv = 0; static MYPFNGLMULTITEXCOORD1FPROC staticPointerglMultiTexCoord1f = 0; static MYPFNGLMULTITEXCOORD1FVPROC staticPointerglMultiTexCoord1fv = 0; static MYPFNGLMULTITEXCOORD1IPROC staticPointerglMultiTexCoord1i = 0; static MYPFNGLMULTITEXCOORD1IVPROC staticPointerglMultiTexCoord1iv = 0; static MYPFNGLMULTITEXCOORD1SPROC staticPointerglMultiTexCoord1s = 0; static MYPFNGLMULTITEXCOORD1SVPROC staticPointerglMultiTexCoord1sv = 0; static MYPFNGLMULTITEXCOORD2DPROC staticPointerglMultiTexCoord2d = 0; static MYPFNGLMULTITEXCOORD2DVPROC staticPointerglMultiTexCoord2dv = 0; static MYPFNGLMULTITEXCOORD2FPROC staticPointerglMultiTexCoord2f = 0; static MYPFNGLMULTITEXCOORD2FVPROC staticPointerglMultiTexCoord2fv = 0; static MYPFNGLMULTITEXCOORD2IPROC staticPointerglMultiTexCoord2i = 0; static MYPFNGLMULTITEXCOORD2IVPROC staticPointerglMultiTexCoord2iv = 0; static MYPFNGLMULTITEXCOORD2SPROC staticPointerglMultiTexCoord2s = 0; static MYPFNGLMULTITEXCOORD2SVPROC staticPointerglMultiTexCoord2sv = 0; static MYPFNGLMULTITEXCOORD3DPROC staticPointerglMultiTexCoord3d = 0; static MYPFNGLMULTITEXCOORD3DVPROC staticPointerglMultiTexCoord3dv = 0; static MYPFNGLMULTITEXCOORD3FPROC staticPointerglMultiTexCoord3f = 0; static MYPFNGLMULTITEXCOORD3FVPROC staticPointerglMultiTexCoord3fv = 0; static MYPFNGLMULTITEXCOORD3IPROC staticPointerglMultiTexCoord3i = 0; static MYPFNGLMULTITEXCOORD3IVPROC staticPointerglMultiTexCoord3iv = 0; static MYPFNGLMULTITEXCOORD3SPROC staticPointerglMultiTexCoord3s = 0; static MYPFNGLMULTITEXCOORD3SVPROC staticPointerglMultiTexCoord3sv = 0; static MYPFNGLMULTITEXCOORD4DPROC staticPointerglMultiTexCoord4d = 0; static MYPFNGLMULTITEXCOORD4DVPROC staticPointerglMultiTexCoord4dv = 0; static MYPFNGLMULTITEXCOORD4FPROC staticPointerglMultiTexCoord4f = 0; static MYPFNGLMULTITEXCOORD4FVPROC staticPointerglMultiTexCoord4fv = 0; static MYPFNGLMULTITEXCOORD4IPROC staticPointerglMultiTexCoord4i = 0; static MYPFNGLMULTITEXCOORD4IVPROC staticPointerglMultiTexCoord4iv = 0; static MYPFNGLMULTITEXCOORD4SPROC staticPointerglMultiTexCoord4s = 0; static MYPFNGLMULTITEXCOORD4SVPROC staticPointerglMultiTexCoord4sv = 0; static MYPFNGLLOADTRANSPOSEMATRIXFPROC staticPointerglLoadTransposeMatrixf = 0; static MYPFNGLLOADTRANSPOSEMATRIXDPROC staticPointerglLoadTransposeMatrixd = 0; static MYPFNGLMULTTRANSPOSEMATRIXFPROC staticPointerglMultTransposeMatrixf = 0; static MYPFNGLMULTTRANSPOSEMATRIXDPROC staticPointerglMultTransposeMatrixd = 0; static MYPFNGLSAMPLECOVERAGEPROC staticPointerglSampleCoverage = 0; static MYPFNGLCOMPRESSEDTEXIMAGE3DPROC staticPointerglCompressedTexImage3D = 0; static MYPFNGLCOMPRESSEDTEXIMAGE2DPROC staticPointerglCompressedTexImage2D = 0; static MYPFNGLCOMPRESSEDTEXIMAGE1DPROC staticPointerglCompressedTexImage1D = 0; static MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC staticPointerglCompressedTexSubImage3D = 0; static MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC staticPointerglCompressedTexSubImage2D = 0; static MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC staticPointerglCompressedTexSubImage1D = 0; static MYPFNGLGETCOMPRESSEDTEXIMAGEPROC staticPointerglGetCompressedTexImage = 0; // End OpenGL version 1.3 // OpenGL version 1.4 static MYPFNGLBLENDFUNCSEPARATEPROC staticPointerglBlendFuncSeparate = 0; static MYPFNGLFOGCOORDFPROC staticPointerglFogCoordf = 0; static MYPFNGLFOGCOORDFVPROC staticPointerglFogCoordfv = 0; static MYPFNGLFOGCOORDDPROC staticPointerglFogCoordd = 0; static MYPFNGLFOGCOORDDVPROC staticPointerglFogCoorddv = 0; static MYPFNGLFOGCOORDPOINTERPROC staticPointerglFogCoordPointer = 0; static MYPFNGLMULTIDRAWARRAYSPROC staticPointerglMultiDrawArrays = 0; static MYPFNGLMULTIDRAWELEMENTSPROC staticPointerglMultiDrawElements = 0; static MYPFNGLPOINTPARAMETERFPROC staticPointerglPointParameterf = 0; static MYPFNGLPOINTPARAMETERFVPROC staticPointerglPointParameterfv = 0; static MYPFNGLPOINTPARAMETERIPROC staticPointerglPointParameteri = 0; static MYPFNGLPOINTPARAMETERIVPROC staticPointerglPointParameteriv = 0; static MYPFNGLSECONDARYCOLOR3BPROC staticPointerglSecondaryColor3b = 0; static MYPFNGLSECONDARYCOLOR3BVPROC staticPointerglSecondaryColor3bv = 0; static MYPFNGLSECONDARYCOLOR3DPROC staticPointerglSecondaryColor3d = 0; static MYPFNGLSECONDARYCOLOR3DVPROC staticPointerglSecondaryColor3dv = 0; static MYPFNGLSECONDARYCOLOR3FPROC staticPointerglSecondaryColor3f = 0; static MYPFNGLSECONDARYCOLOR3FVPROC staticPointerglSecondaryColor3fv = 0; static MYPFNGLSECONDARYCOLOR3IPROC staticPointerglSecondaryColor3i = 0; static MYPFNGLSECONDARYCOLOR3IVPROC staticPointerglSecondaryColor3iv = 0; static MYPFNGLSECONDARYCOLOR3SPROC staticPointerglSecondaryColor3s = 0; static MYPFNGLSECONDARYCOLOR3SVPROC staticPointerglSecondaryColor3sv = 0; static MYPFNGLSECONDARYCOLOR3UBPROC staticPointerglSecondaryColor3ub = 0; static MYPFNGLSECONDARYCOLOR3UBVPROC staticPointerglSecondaryColor3ubv = 0; static MYPFNGLSECONDARYCOLOR3UIPROC staticPointerglSecondaryColor3ui = 0; static MYPFNGLSECONDARYCOLOR3UIVPROC staticPointerglSecondaryColor3uiv = 0; static MYPFNGLSECONDARYCOLOR3USPROC staticPointerglSecondaryColor3us = 0; static MYPFNGLSECONDARYCOLOR3USVPROC staticPointerglSecondaryColor3usv = 0; static MYPFNGLSECONDARYCOLORPOINTERPROC staticPointerglSecondaryColorPointer = 0; static MYPFNGLWINDOWPOS2DPROC staticPointerglWindowPos2d = 0; static MYPFNGLWINDOWPOS2DVPROC staticPointerglWindowPos2dv = 0; static MYPFNGLWINDOWPOS2FPROC staticPointerglWindowPos2f = 0; static MYPFNGLWINDOWPOS2FVPROC staticPointerglWindowPos2fv = 0; static MYPFNGLWINDOWPOS2IPROC staticPointerglWindowPos2i = 0; static MYPFNGLWINDOWPOS2IVPROC staticPointerglWindowPos2iv = 0; static MYPFNGLWINDOWPOS2SPROC staticPointerglWindowPos2s = 0; static MYPFNGLWINDOWPOS2SVPROC staticPointerglWindowPos2sv = 0; static MYPFNGLWINDOWPOS3DPROC staticPointerglWindowPos3d = 0; static MYPFNGLWINDOWPOS3DVPROC staticPointerglWindowPos3dv = 0; static MYPFNGLWINDOWPOS3FPROC staticPointerglWindowPos3f = 0; static MYPFNGLWINDOWPOS3FVPROC staticPointerglWindowPos3fv = 0; static MYPFNGLWINDOWPOS3IPROC staticPointerglWindowPos3i = 0; static MYPFNGLWINDOWPOS3IVPROC staticPointerglWindowPos3iv = 0; static MYPFNGLWINDOWPOS3SPROC staticPointerglWindowPos3s = 0; static MYPFNGLWINDOWPOS3SVPROC staticPointerglWindowPos3sv = 0; // End OpenGL version 1.4 // GL_EXT_paletted_texture static MYPFNGLCOLORTABLEEXTPROC staticPointerglColorTableEXT = (MYPFNGLCOLORTABLEEXTPROC) 0; static MYPFNGLGETCOLORTABLEEXTPROC staticPointerglGetColorTableEXT = (MYPFNGLGETCOLORTABLEEXTPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC staticPointerglGetColorTableParameterivEXT = (MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC staticPointerglGetColorTableParameterfvEXT = (MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) 0; // End GL_EXT_paletted_texture // GL_ARB_multitexture static MYPFNGLACTIVETEXTUREARBPROC staticPointerglActiveTextureARB = (MYPFNGLACTIVETEXTUREARBPROC) 0; static MYPFNGLCLIENTACTIVETEXTUREARBPROC staticPointerglClientActiveTextureARB = (MYPFNGLCLIENTACTIVETEXTUREARBPROC) 0; static MYPFNGLMULTITEXCOORD1DARBPROC staticPointerglMultiTexCoord1dARB = (MYPFNGLMULTITEXCOORD1DARBPROC) 0; static MYPFNGLMULTITEXCOORD1DVARBPROC staticPointerglMultiTexCoord1dvARB = (MYPFNGLMULTITEXCOORD1DVARBPROC) 0; static MYPFNGLMULTITEXCOORD1FARBPROC staticPointerglMultiTexCoord1fARB = (MYPFNGLMULTITEXCOORD1FARBPROC) 0; static MYPFNGLMULTITEXCOORD1FVARBPROC staticPointerglMultiTexCoord1fvARB = (MYPFNGLMULTITEXCOORD1FVARBPROC) 0; static MYPFNGLMULTITEXCOORD1IARBPROC staticPointerglMultiTexCoord1iARB = (MYPFNGLMULTITEXCOORD1IARBPROC) 0; static MYPFNGLMULTITEXCOORD1IVARBPROC staticPointerglMultiTexCoord1ivARB = (MYPFNGLMULTITEXCOORD1IVARBPROC) 0; static MYPFNGLMULTITEXCOORD1SARBPROC staticPointerglMultiTexCoord1sARB = (MYPFNGLMULTITEXCOORD1SARBPROC) 0; static MYPFNGLMULTITEXCOORD1SVARBPROC staticPointerglMultiTexCoord1svARB = (MYPFNGLMULTITEXCOORD1SVARBPROC) 0; static MYPFNGLMULTITEXCOORD2DARBPROC staticPointerglMultiTexCoord2dARB = (MYPFNGLMULTITEXCOORD2DARBPROC) 0; static MYPFNGLMULTITEXCOORD2DVARBPROC staticPointerglMultiTexCoord2dvARB = (MYPFNGLMULTITEXCOORD2DVARBPROC) 0; static MYPFNGLMULTITEXCOORD2FARBPROC staticPointerglMultiTexCoord2fARB = (MYPFNGLMULTITEXCOORD2FARBPROC) 0; static MYPFNGLMULTITEXCOORD2FVARBPROC staticPointerglMultiTexCoord2fvARB = (MYPFNGLMULTITEXCOORD2FVARBPROC) 0; static MYPFNGLMULTITEXCOORD2IARBPROC staticPointerglMultiTexCoord2iARB = (MYPFNGLMULTITEXCOORD2IARBPROC) 0; static MYPFNGLMULTITEXCOORD2IVARBPROC staticPointerglMultiTexCoord2ivARB = (MYPFNGLMULTITEXCOORD2IVARBPROC) 0; static MYPFNGLMULTITEXCOORD2SARBPROC staticPointerglMultiTexCoord2sARB = (MYPFNGLMULTITEXCOORD2SARBPROC) 0; static MYPFNGLMULTITEXCOORD2SVARBPROC staticPointerglMultiTexCoord2svARB = (MYPFNGLMULTITEXCOORD2SVARBPROC) 0; static MYPFNGLMULTITEXCOORD3DARBPROC staticPointerglMultiTexCoord3dARB = (MYPFNGLMULTITEXCOORD3DARBPROC) 0; static MYPFNGLMULTITEXCOORD3DVARBPROC staticPointerglMultiTexCoord3dvARB = (MYPFNGLMULTITEXCOORD3DVARBPROC) 0; static MYPFNGLMULTITEXCOORD3FARBPROC staticPointerglMultiTexCoord3fARB = (MYPFNGLMULTITEXCOORD3FARBPROC) 0; static MYPFNGLMULTITEXCOORD3FVARBPROC staticPointerglMultiTexCoord3fvARB = (MYPFNGLMULTITEXCOORD3FVARBPROC) 0; static MYPFNGLMULTITEXCOORD3IARBPROC staticPointerglMultiTexCoord3iARB = (MYPFNGLMULTITEXCOORD3IARBPROC) 0; static MYPFNGLMULTITEXCOORD3IVARBPROC staticPointerglMultiTexCoord3ivARB = (MYPFNGLMULTITEXCOORD3IVARBPROC) 0; static MYPFNGLMULTITEXCOORD3SARBPROC staticPointerglMultiTexCoord3sARB = (MYPFNGLMULTITEXCOORD3SARBPROC) 0; static MYPFNGLMULTITEXCOORD3SVARBPROC staticPointerglMultiTexCoord3svARB = (MYPFNGLMULTITEXCOORD3SVARBPROC) 0; static MYPFNGLMULTITEXCOORD4DARBPROC staticPointerglMultiTexCoord4dARB = (MYPFNGLMULTITEXCOORD4DARBPROC) 0; static MYPFNGLMULTITEXCOORD4DVARBPROC staticPointerglMultiTexCoord4dvARB = (MYPFNGLMULTITEXCOORD4DVARBPROC) 0; static MYPFNGLMULTITEXCOORD4FARBPROC staticPointerglMultiTexCoord4fARB = (MYPFNGLMULTITEXCOORD4FARBPROC) 0; static MYPFNGLMULTITEXCOORD4FVARBPROC staticPointerglMultiTexCoord4fvARB = (MYPFNGLMULTITEXCOORD4FVARBPROC) 0; static MYPFNGLMULTITEXCOORD4IARBPROC staticPointerglMultiTexCoord4iARB = (MYPFNGLMULTITEXCOORD4IARBPROC) 0; static MYPFNGLMULTITEXCOORD4IVARBPROC staticPointerglMultiTexCoord4ivARB = (MYPFNGLMULTITEXCOORD4IVARBPROC) 0; static MYPFNGLMULTITEXCOORD4SARBPROC staticPointerglMultiTexCoord4sARB = (MYPFNGLMULTITEXCOORD4SARBPROC) 0; static MYPFNGLMULTITEXCOORD4SVARBPROC staticPointerglMultiTexCoord4svARB = (MYPFNGLMULTITEXCOORD4SVARBPROC) 0; // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table static MYPFNGLCOLORTABLESGIPROC staticPointerglColorTableSGI = (MYPFNGLCOLORTABLESGIPROC) 0; static MYPFNGLCOLORTABLEPARAMETERFVSGIPROC staticPointerglColorTableParameterfvSGI = (MYPFNGLCOLORTABLEPARAMETERFVSGIPROC) 0; static MYPFNGLCOLORTABLEPARAMETERIVSGIPROC staticPointerglColorTableParameterivSGI = (MYPFNGLCOLORTABLEPARAMETERIVSGIPROC) 0; static MYPFNGLCOPYCOLORTABLESGIPROC staticPointerglCopyColorTableSGI = (MYPFNGLCOPYCOLORTABLESGIPROC) 0; static MYPFNGLGETCOLORTABLESGIPROC staticPointerglGetColorTableSGI = (MYPFNGLGETCOLORTABLESGIPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC staticPointerglGetColorTableParameterfvSGI = (MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) 0; static MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC staticPointerglGetColorTableParameterivSGI = (MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) 0; // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D static MYPFNGLTEXIMAGE3DEXTPROC staticPointerglTexImage3DEXT = (MYPFNGLTEXIMAGE3DEXTPROC) 0; static MYPFNGLTEXSUBIMAGE3DEXTPROC staticPointerglTexSubImage3DEXT = (MYPFNGLTEXSUBIMAGE3DEXTPROC) 0; // End GL_EXT_texture3D // GL_NV_fragment_program static MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC staticPointerglProgramNamedParameter4fNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) 0; static MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC staticPointerglProgramNamedParameter4dNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) 0; static MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC staticPointerglProgramNamedParameter4fvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) 0; static MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC staticPointerglProgramNamedParameter4dvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) 0; static MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC staticPointerglGetProgramNamedParameterfvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) 0; static MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC staticPointerglGetProgramNamedParameterdvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) 0; // GL_NV_fragment_program // GL_NV_vertex_program static MYPFNGLAREPROGRAMSRESIDENTNVPROC staticPointerglAreProgramsResidentNV = (MYPFNGLAREPROGRAMSRESIDENTNVPROC) 0; static MYPFNGLBINDPROGRAMNVPROC staticPointerglBindProgramNV = (MYPFNGLBINDPROGRAMNVPROC) 0; static MYPFNGLDELETEPROGRAMSNVPROC staticPointerglDeleteProgramsNV = (MYPFNGLDELETEPROGRAMSNVPROC) 0; static MYPFNGLEXECUTEPROGRAMNVPROC staticPointerglExecuteProgramNV = (MYPFNGLEXECUTEPROGRAMNVPROC) 0; static MYPFNGLGENPROGRAMSNVPROC staticPointerglGenProgramsNV = (MYPFNGLGENPROGRAMSNVPROC) 0; static MYPFNGLGETPROGRAMPARAMETERDVNVPROC staticPointerglGetProgramParameterdvNV = (MYPFNGLGETPROGRAMPARAMETERDVNVPROC) 0; static MYPFNGLGETPROGRAMPARAMETERFVNVPROC staticPointerglGetProgramParameterfvNV = (MYPFNGLGETPROGRAMPARAMETERFVNVPROC) 0; static MYPFNGLGETPROGRAMIVNVPROC staticPointerglGetProgramivNV = (MYPFNGLGETPROGRAMIVNVPROC) 0; static MYPFNGLGETPROGRAMSTRINGNVPROC staticPointerglGetProgramStringNV = (MYPFNGLGETPROGRAMSTRINGNVPROC) 0; static MYPFNGLGETTRACKMATRIXIVNVPROC staticPointerglGetTrackMatrixivNV = (MYPFNGLGETTRACKMATRIXIVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBDVNVPROC staticPointerglGetVertexAttribdvNV = (MYPFNGLGETVERTEXATTRIBDVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBFVNVPROC staticPointerglGetVertexAttribfvNV = (MYPFNGLGETVERTEXATTRIBFVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBIVNVPROC staticPointerglGetVertexAttribivNV = (MYPFNGLGETVERTEXATTRIBIVNVPROC) 0; static MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC staticPointerglGetVertexAttribPointervNV = (MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC) 0; static MYPFNGLISPROGRAMNVPROC staticPointerglIsProgramNV = (MYPFNGLISPROGRAMNVPROC) 0; static MYPFNGLLOADPROGRAMNVPROC staticPointerglLoadProgramNV = (MYPFNGLLOADPROGRAMNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4DNVPROC staticPointerglProgramParameter4dNV = (MYPFNGLPROGRAMPARAMETER4DNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4DVNVPROC staticPointerglProgramParameter4dvNV = (MYPFNGLPROGRAMPARAMETER4DVNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4FNVPROC staticPointerglProgramParameter4fNV = (MYPFNGLPROGRAMPARAMETER4FNVPROC) 0; static MYPFNGLPROGRAMPARAMETER4FVNVPROC staticPointerglProgramParameter4fvNV = (MYPFNGLPROGRAMPARAMETER4FVNVPROC) 0; static MYPFNGLPROGRAMPARAMETERS4DVNVPROC staticPointerglProgramParameters4dvNV = (MYPFNGLPROGRAMPARAMETERS4DVNVPROC) 0; static MYPFNGLPROGRAMPARAMETERS4FVNVPROC staticPointerglProgramParameters4fvNV = (MYPFNGLPROGRAMPARAMETERS4FVNVPROC) 0; static MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC staticPointerglRequestResidentProgramsNV = (MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC) 0; static MYPFNGLTRACKMATRIXNVPROC staticPointerglTrackMatrixNV = (MYPFNGLTRACKMATRIXNVPROC) 0; static MYPFNGLVERTEXATTRIBPOINTERNVPROC staticPointerglVertexAttribPointerNV = (MYPFNGLVERTEXATTRIBPOINTERNVPROC) 0; static MYPFNGLVERTEXATTRIB1DNVPROC staticPointerglVertexAttrib1dNV = (MYPFNGLVERTEXATTRIB1DNVPROC) 0; static MYPFNGLVERTEXATTRIB1DVNVPROC staticPointerglVertexAttrib1dvNV = (MYPFNGLVERTEXATTRIB1DVNVPROC) 0; static MYPFNGLVERTEXATTRIB1FNVPROC staticPointerglVertexAttrib1fNV = (MYPFNGLVERTEXATTRIB1FNVPROC) 0; static MYPFNGLVERTEXATTRIB1FVNVPROC staticPointerglVertexAttrib1fvNV = (MYPFNGLVERTEXATTRIB1FVNVPROC) 0; static MYPFNGLVERTEXATTRIB1SNVPROC staticPointerglVertexAttrib1sNV = (MYPFNGLVERTEXATTRIB1SNVPROC) 0; static MYPFNGLVERTEXATTRIB1SVNVPROC staticPointerglVertexAttrib1svNV = (MYPFNGLVERTEXATTRIB1SVNVPROC) 0; static MYPFNGLVERTEXATTRIB2DNVPROC staticPointerglVertexAttrib2dNV = (MYPFNGLVERTEXATTRIB2DNVPROC) 0; static MYPFNGLVERTEXATTRIB2DVNVPROC staticPointerglVertexAttrib2dvNV = (MYPFNGLVERTEXATTRIB2DVNVPROC) 0; static MYPFNGLVERTEXATTRIB2FNVPROC staticPointerglVertexAttrib2fNV = (MYPFNGLVERTEXATTRIB2FNVPROC) 0; static MYPFNGLVERTEXATTRIB2FVNVPROC staticPointerglVertexAttrib2fvNV = (MYPFNGLVERTEXATTRIB2FVNVPROC) 0; static MYPFNGLVERTEXATTRIB2SNVPROC staticPointerglVertexAttrib2sNV = (MYPFNGLVERTEXATTRIB2SNVPROC) 0; static MYPFNGLVERTEXATTRIB2SVNVPROC staticPointerglVertexAttrib2svNV = (MYPFNGLVERTEXATTRIB2SVNVPROC) 0; static MYPFNGLVERTEXATTRIB3DNVPROC staticPointerglVertexAttrib3dNV = (MYPFNGLVERTEXATTRIB3DNVPROC) 0; static MYPFNGLVERTEXATTRIB3DVNVPROC staticPointerglVertexAttrib3dvNV = (MYPFNGLVERTEXATTRIB3DVNVPROC) 0; static MYPFNGLVERTEXATTRIB3FNVPROC staticPointerglVertexAttrib3fNV = (MYPFNGLVERTEXATTRIB3FNVPROC) 0; static MYPFNGLVERTEXATTRIB3FVNVPROC staticPointerglVertexAttrib3fvNV = (MYPFNGLVERTEXATTRIB3FVNVPROC) 0; static MYPFNGLVERTEXATTRIB3SNVPROC staticPointerglVertexAttrib3sNV = (MYPFNGLVERTEXATTRIB3SNVPROC) 0; static MYPFNGLVERTEXATTRIB3SVNVPROC staticPointerglVertexAttrib3svNV = (MYPFNGLVERTEXATTRIB3SVNVPROC) 0; static MYPFNGLVERTEXATTRIB4DNVPROC staticPointerglVertexAttrib4dNV = (MYPFNGLVERTEXATTRIB4DNVPROC) 0; static MYPFNGLVERTEXATTRIB4DVNVPROC staticPointerglVertexAttrib4dvNV = (MYPFNGLVERTEXATTRIB4DVNVPROC) 0; static MYPFNGLVERTEXATTRIB4FNVPROC staticPointerglVertexAttrib4fNV = (MYPFNGLVERTEXATTRIB4FNVPROC) 0; static MYPFNGLVERTEXATTRIB4FVNVPROC staticPointerglVertexAttrib4fvNV = (MYPFNGLVERTEXATTRIB4FVNVPROC) 0; static MYPFNGLVERTEXATTRIB4SNVPROC staticPointerglVertexAttrib4sNV = (MYPFNGLVERTEXATTRIB4SNVPROC) 0; static MYPFNGLVERTEXATTRIB4SVNVPROC staticPointerglVertexAttrib4svNV = (MYPFNGLVERTEXATTRIB4SVNVPROC) 0; static MYPFNGLVERTEXATTRIB4UBNVPROC staticPointerglVertexAttrib4ubNV = (MYPFNGLVERTEXATTRIB4UBNVPROC) 0; static MYPFNGLVERTEXATTRIB4UBVNVPROC staticPointerglVertexAttrib4ubvNV = (MYPFNGLVERTEXATTRIB4UBVNVPROC) 0; static MYPFNGLVERTEXATTRIBS1DVNVPROC staticPointerglVertexAttribs1dvNV = (MYPFNGLVERTEXATTRIBS1DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS1FVNVPROC staticPointerglVertexAttribs1fvNV = (MYPFNGLVERTEXATTRIBS1FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS1SVNVPROC staticPointerglVertexAttribs1svNV = (MYPFNGLVERTEXATTRIBS1SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS2DVNVPROC staticPointerglVertexAttribs2dvNV = (MYPFNGLVERTEXATTRIBS2DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS2FVNVPROC staticPointerglVertexAttribs2fvNV = (MYPFNGLVERTEXATTRIBS2FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS2SVNVPROC staticPointerglVertexAttribs2svNV = (MYPFNGLVERTEXATTRIBS2SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS3DVNVPROC staticPointerglVertexAttribs3dvNV = (MYPFNGLVERTEXATTRIBS3DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS3FVNVPROC staticPointerglVertexAttribs3fvNV = (MYPFNGLVERTEXATTRIBS3FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS3SVNVPROC staticPointerglVertexAttribs3svNV = (MYPFNGLVERTEXATTRIBS3SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4DVNVPROC staticPointerglVertexAttribs4dvNV = (MYPFNGLVERTEXATTRIBS4DVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4FVNVPROC staticPointerglVertexAttribs4fvNV = (MYPFNGLVERTEXATTRIBS4FVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4SVNVPROC staticPointerglVertexAttribs4svNV = (MYPFNGLVERTEXATTRIBS4SVNVPROC) 0; static MYPFNGLVERTEXATTRIBS4UBVNVPROC staticPointerglVertexAttribs4ubvNV = (MYPFNGLVERTEXATTRIBS4UBVNVPROC) 0; // GL_NV_vertex_program // GL_ARB_vertex_program static MYPFNGLVERTEXATTRIB1DARBPROC staticPointerglVertexAttrib1dARB = (MYPFNGLVERTEXATTRIB1DARBPROC) 0; static MYPFNGLVERTEXATTRIB1DVARBPROC staticPointerglVertexAttrib1dvARB = (MYPFNGLVERTEXATTRIB1DVARBPROC) 0; static MYPFNGLVERTEXATTRIB1FARBPROC staticPointerglVertexAttrib1fARB = (MYPFNGLVERTEXATTRIB1FARBPROC) 0; static MYPFNGLVERTEXATTRIB1FVARBPROC staticPointerglVertexAttrib1fvARB = (MYPFNGLVERTEXATTRIB1FVARBPROC) 0; static MYPFNGLVERTEXATTRIB1SARBPROC staticPointerglVertexAttrib1sARB = (MYPFNGLVERTEXATTRIB1SARBPROC) 0; static MYPFNGLVERTEXATTRIB1SVARBPROC staticPointerglVertexAttrib1svARB = (MYPFNGLVERTEXATTRIB1SVARBPROC) 0; static MYPFNGLVERTEXATTRIB2DARBPROC staticPointerglVertexAttrib2dARB = (MYPFNGLVERTEXATTRIB2DARBPROC) 0; static MYPFNGLVERTEXATTRIB2DVARBPROC staticPointerglVertexAttrib2dvARB = (MYPFNGLVERTEXATTRIB2DVARBPROC) 0; static MYPFNGLVERTEXATTRIB2FARBPROC staticPointerglVertexAttrib2fARB = (MYPFNGLVERTEXATTRIB2FARBPROC) 0; static MYPFNGLVERTEXATTRIB2FVARBPROC staticPointerglVertexAttrib2fvARB = (MYPFNGLVERTEXATTRIB2FVARBPROC) 0; static MYPFNGLVERTEXATTRIB2SARBPROC staticPointerglVertexAttrib2sARB = (MYPFNGLVERTEXATTRIB2SARBPROC) 0; static MYPFNGLVERTEXATTRIB2SVARBPROC staticPointerglVertexAttrib2svARB = (MYPFNGLVERTEXATTRIB2SVARBPROC) 0; static MYPFNGLVERTEXATTRIB3DARBPROC staticPointerglVertexAttrib3dARB = (MYPFNGLVERTEXATTRIB3DARBPROC) 0; static MYPFNGLVERTEXATTRIB3DVARBPROC staticPointerglVertexAttrib3dvARB = (MYPFNGLVERTEXATTRIB3DVARBPROC) 0; static MYPFNGLVERTEXATTRIB3FARBPROC staticPointerglVertexAttrib3fARB = (MYPFNGLVERTEXATTRIB3FARBPROC) 0; static MYPFNGLVERTEXATTRIB3FVARBPROC staticPointerglVertexAttrib3fvARB = (MYPFNGLVERTEXATTRIB3FVARBPROC) 0; static MYPFNGLVERTEXATTRIB3SARBPROC staticPointerglVertexAttrib3sARB = (MYPFNGLVERTEXATTRIB3SARBPROC) 0; static MYPFNGLVERTEXATTRIB3SVARBPROC staticPointerglVertexAttrib3svARB = (MYPFNGLVERTEXATTRIB3SVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NBVARBPROC staticPointerglVertexAttrib4NbvARB = (MYPFNGLVERTEXATTRIB4NBVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NIVARBPROC staticPointerglVertexAttrib4NivARB = (MYPFNGLVERTEXATTRIB4NIVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NSVARBPROC staticPointerglVertexAttrib4NsvARB = (MYPFNGLVERTEXATTRIB4NSVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUBARBPROC staticPointerglVertexAttrib4NubARB = (MYPFNGLVERTEXATTRIB4NUBARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUBVARBPROC staticPointerglVertexAttrib4NubvARB = (MYPFNGLVERTEXATTRIB4NUBVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUIVARBPROC staticPointerglVertexAttrib4NuivARB = (MYPFNGLVERTEXATTRIB4NUIVARBPROC) 0; static MYPFNGLVERTEXATTRIB4NUSVARBPROC staticPointerglVertexAttrib4NusvARB = (MYPFNGLVERTEXATTRIB4NUSVARBPROC) 0; static MYPFNGLVERTEXATTRIB4BVARBPROC staticPointerglVertexAttrib4bvARB = (MYPFNGLVERTEXATTRIB4BVARBPROC) 0; static MYPFNGLVERTEXATTRIB4DARBPROC staticPointerglVertexAttrib4dARB = (MYPFNGLVERTEXATTRIB4DARBPROC) 0; static MYPFNGLVERTEXATTRIB4DVARBPROC staticPointerglVertexAttrib4dvARB = (MYPFNGLVERTEXATTRIB4DVARBPROC) 0; static MYPFNGLVERTEXATTRIB4FARBPROC staticPointerglVertexAttrib4fARB = (MYPFNGLVERTEXATTRIB4FARBPROC) 0; static MYPFNGLVERTEXATTRIB4FVARBPROC staticPointerglVertexAttrib4fvARB = (MYPFNGLVERTEXATTRIB4FVARBPROC) 0; static MYPFNGLVERTEXATTRIB4IVARBPROC staticPointerglVertexAttrib4ivARB = (MYPFNGLVERTEXATTRIB4IVARBPROC) 0; static MYPFNGLVERTEXATTRIB4SARBPROC staticPointerglVertexAttrib4sARB = (MYPFNGLVERTEXATTRIB4SARBPROC) 0; static MYPFNGLVERTEXATTRIB4SVARBPROC staticPointerglVertexAttrib4svARB = (MYPFNGLVERTEXATTRIB4SVARBPROC) 0; static MYPFNGLVERTEXATTRIB4UBVARBPROC staticPointerglVertexAttrib4ubvARB = (MYPFNGLVERTEXATTRIB4UBVARBPROC) 0; static MYPFNGLVERTEXATTRIB4UIVARBPROC staticPointerglVertexAttrib4uivARB = (MYPFNGLVERTEXATTRIB4UIVARBPROC) 0; static MYPFNGLVERTEXATTRIB4USVARBPROC staticPointerglVertexAttrib4usvARB = (MYPFNGLVERTEXATTRIB4USVARBPROC) 0; static MYPFNGLVERTEXATTRIBPOINTERARBPROC staticPointerglVertexAttribPointerARB = (MYPFNGLVERTEXATTRIBPOINTERARBPROC) 0; static MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC staticPointerglEnableVertexAttribArrayARB = (MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC) 0; static MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC staticPointerglDisableVertexAttribArrayARB = (MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) 0; static MYPFNGLPROGRAMSTRINGARBPROC staticPointerglProgramStringARB = (MYPFNGLPROGRAMSTRINGARBPROC) 0; static MYPFNGLBINDPROGRAMARBPROC staticPointerglBindProgramARB = (MYPFNGLBINDPROGRAMARBPROC) 0; static MYPFNGLDELETEPROGRAMSARBPROC staticPointerglDeleteProgramsARB = (MYPFNGLDELETEPROGRAMSARBPROC) 0; static MYPFNGLGENPROGRAMSARBPROC staticPointerglGenProgramsARB = (MYPFNGLGENPROGRAMSARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4DARBPROC staticPointerglProgramEnvParameter4dARB = (MYPFNGLPROGRAMENVPARAMETER4DARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4DVARBPROC staticPointerglProgramEnvParameter4dvARB = (MYPFNGLPROGRAMENVPARAMETER4DVARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4FARBPROC staticPointerglProgramEnvParameter4fARB = (MYPFNGLPROGRAMENVPARAMETER4FARBPROC) 0; static MYPFNGLPROGRAMENVPARAMETER4FVARBPROC staticPointerglProgramEnvParameter4fvARB = (MYPFNGLPROGRAMENVPARAMETER4FVARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC staticPointerglProgramLocalParameter4dARB = (MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC staticPointerglProgramLocalParameter4dvARB = (MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC staticPointerglProgramLocalParameter4fARB = (MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC) 0; static MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC staticPointerglProgramLocalParameter4fvARB = (MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) 0; static MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC staticPointerglGetProgramEnvParameterdvARB = (MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC) 0; static MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC staticPointerglGetProgramEnvParameterfvARB = (MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC) 0; static MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC staticPointerglGetProgramLocalParameterdvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) 0; static MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC staticPointerglGetProgramLocalParameterfvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) 0; static MYPFNGLGETPROGRAMIVARBPROC staticPointerglGetProgramivARB = (MYPFNGLGETPROGRAMIVARBPROC) 0; static MYPFNGLGETPROGRAMSTRINGARBPROC staticPointerglGetProgramStringARB = (MYPFNGLGETPROGRAMSTRINGARBPROC) 0; static MYPFNGLGETVERTEXATTRIBDVARBPROC staticPointerglGetVertexAttribdvARB = (MYPFNGLGETVERTEXATTRIBDVARBPROC) 0; static MYPFNGLGETVERTEXATTRIBFVARBPROC staticPointerglGetVertexAttribfvARB = (MYPFNGLGETVERTEXATTRIBFVARBPROC) 0; static MYPFNGLGETVERTEXATTRIBIVARBPROC staticPointerglGetVertexAttribivARB = (MYPFNGLGETVERTEXATTRIBIVARBPROC) 0; static MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC staticPointerglGetVertexAttribPointervARB = (MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC) 0; static MYPFNGLISPROGRAMARBPROC staticPointerglIsProgramARB = (MYPFNGLISPROGRAMARBPROC) 0; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program void initStaticPointers() { if (staticPointersInitialized==true) return; staticPointersInitialized = true; #if defined(GL_VERSION_1_2) && GL_VERSION_1_2 staticPointerglBlendColor = (MYPFNGLBLENDCOLORPROC)glBlendColor; staticPointerglBlendEquation = (MYPFNGLBLENDEQUATIONPROC)glBlendEquation; staticPointerglDrawRangeElements = (MYPFNGLDRAWRANGEELEMENTSPROC)glDrawRangeElements; staticPointerglColorTable = (MYPFNGLCOLORTABLEPROC)glColorTable; staticPointerglColorTableParameterfv = (MYPFNGLCOLORTABLEPARAMETERFVPROC)glColorTableParameterfv; staticPointerglColorTableParameteriv = (MYPFNGLCOLORTABLEPARAMETERIVPROC)glColorTableParameteriv; staticPointerglCopyColorTable = (MYPFNGLCOPYCOLORTABLEPROC)glCopyColorTable; staticPointerglGetColorTable = (MYPFNGLGETCOLORTABLEPROC)glGetColorTable; staticPointerglGetColorTableParameterfv = (MYPFNGLGETCOLORTABLEPARAMETERFVPROC)glGetColorTableParameterfv; staticPointerglGetColorTableParameteriv = (MYPFNGLGETCOLORTABLEPARAMETERIVPROC)glGetColorTableParameteriv; staticPointerglColorSubTable = (MYPFNGLCOLORSUBTABLEPROC)glColorSubTable; staticPointerglCopyColorSubTable = (MYPFNGLCOPYCOLORSUBTABLEPROC)glCopyColorSubTable; staticPointerglConvolutionFilter1D = (MYPFNGLCONVOLUTIONFILTER1DPROC)glConvolutionFilter1D; staticPointerglConvolutionFilter2D = (MYPFNGLCONVOLUTIONFILTER2DPROC)glConvolutionFilter2D; staticPointerglConvolutionParameterf = (MYPFNGLCONVOLUTIONPARAMETERFPROC)glConvolutionParameterf; staticPointerglConvolutionParameterfv = (MYPFNGLCONVOLUTIONPARAMETERFVPROC)glConvolutionParameterfv; staticPointerglConvolutionParameteri = (MYPFNGLCONVOLUTIONPARAMETERIPROC)glConvolutionParameteri; staticPointerglConvolutionParameteriv = (MYPFNGLCONVOLUTIONPARAMETERIVPROC)glConvolutionParameteriv; staticPointerglCopyConvolutionFilter1D = (MYPFNGLCOPYCONVOLUTIONFILTER1DPROC)glCopyConvolutionFilter1D; staticPointerglCopyConvolutionFilter2D = (MYPFNGLCOPYCONVOLUTIONFILTER2DPROC)glCopyConvolutionFilter2D; staticPointerglGetConvolutionFilter = (MYPFNGLGETCONVOLUTIONFILTERPROC)glGetConvolutionFilter; staticPointerglGetConvolutionParameterfv = (MYPFNGLGETCONVOLUTIONPARAMETERFVPROC)glGetConvolutionParameterfv; staticPointerglGetConvolutionParameteriv = (MYPFNGLGETCONVOLUTIONPARAMETERIVPROC)glGetConvolutionParameteriv; staticPointerglGetSeparableFilter = (MYPFNGLGETSEPARABLEFILTERPROC)glGetSeparableFilter; staticPointerglSeparableFilter2D = (MYPFNGLSEPARABLEFILTER2DPROC)glSeparableFilter2D; staticPointerglGetHistogram = (MYPFNGLGETHISTOGRAMPROC)glGetHistogram; staticPointerglGetHistogramParameterfv = (MYPFNGLGETHISTOGRAMPARAMETERFVPROC)glGetHistogramParameterfv; staticPointerglGetHistogramParameteriv = (MYPFNGLGETHISTOGRAMPARAMETERIVPROC)glGetHistogramParameteriv; staticPointerglGetMinmax = (MYPFNGLGETMINMAXPROC)glGetMinmax; staticPointerglGetMinmaxParameterfv = (MYPFNGLGETMINMAXPARAMETERFVPROC)glGetMinmaxParameterfv; staticPointerglGetMinmaxParameteriv = (MYPFNGLGETMINMAXPARAMETERIVPROC)glGetMinmaxParameteriv; staticPointerglHistogram = (MYPFNGLHISTOGRAMPROC)glHistogram; staticPointerglMinmax = (MYPFNGLMINMAXPROC)glMinmax; staticPointerglResetHistogram = (MYPFNGLRESETHISTOGRAMPROC)glResetHistogram; staticPointerglResetMinmax = (MYPFNGLRESETMINMAXPROC)glResetMinmax; staticPointerglTexImage3D = (MYPFNGLTEXIMAGE3DPROC)glTexImage3D; staticPointerglTexSubImage3D = (MYPFNGLTEXSUBIMAGE3DPROC)glTexSubImage3D; staticPointerglCopyTexSubImage3D = (MYPFNGLCOPYTEXSUBIMAGE3DPROC)glCopyTexSubImage3D; #else staticPointerglBlendColor = 0; staticPointerglBlendEquation = 0; staticPointerglDrawRangeElements = 0; staticPointerglColorTable = 0; staticPointerglColorTableParameterfv = 0; staticPointerglColorTableParameteriv = 0; staticPointerglCopyColorTable = 0; staticPointerglGetColorTable = 0; staticPointerglGetColorTableParameterfv = 0; staticPointerglGetColorTableParameteriv = 0; staticPointerglColorSubTable = 0; staticPointerglCopyColorSubTable = 0; staticPointerglConvolutionFilter1D = 0; staticPointerglConvolutionFilter2D = 0; staticPointerglConvolutionParameterf = 0; staticPointerglConvolutionParameterfv = 0; staticPointerglConvolutionParameteri = 0; staticPointerglConvolutionParameteriv = 0; staticPointerglCopyConvolutionFilter1D = 0; staticPointerglCopyConvolutionFilter2D = 0; staticPointerglGetConvolutionFilter = 0; staticPointerglGetConvolutionParameterfv = 0; staticPointerglGetConvolutionParameteriv = 0; staticPointerglGetSeparableFilter = 0; staticPointerglSeparableFilter2D = 0; staticPointerglGetHistogram = 0; staticPointerglGetHistogramParameterfv = 0; staticPointerglGetHistogramParameteriv = 0; staticPointerglGetMinmax = 0; staticPointerglGetMinmaxParameterfv = 0; staticPointerglGetMinmaxParameteriv = 0; staticPointerglHistogram = 0; staticPointerglMinmax = 0; staticPointerglResetHistogram = 0; staticPointerglResetMinmax = 0; staticPointerglTexImage3D = 0; staticPointerglTexSubImage3D = 0; staticPointerglCopyTexSubImage3D = 0; #endif // End OpenGL version 1.2 #if defined(GL_VERSION_1_3) && GL_VERSION_1_3 staticPointerglActiveTexture = (MYPFNGLACTIVETEXTUREPROC) glActiveTexture; staticPointerglClientActiveTexture = (MYPFNGLCLIENTACTIVETEXTUREPROC) glClientActiveTexture; staticPointerglMultiTexCoord1d = (MYPFNGLMULTITEXCOORD1DPROC) glMultiTexCoord1d; staticPointerglMultiTexCoord1dv = (MYPFNGLMULTITEXCOORD1DVPROC) glMultiTexCoord1dv; staticPointerglMultiTexCoord1f = (MYPFNGLMULTITEXCOORD1FPROC) glMultiTexCoord1f; staticPointerglMultiTexCoord1fv = (MYPFNGLMULTITEXCOORD1FVPROC) glMultiTexCoord1fv; staticPointerglMultiTexCoord1i = (MYPFNGLMULTITEXCOORD1IPROC) glMultiTexCoord1i; staticPointerglMultiTexCoord1iv = (MYPFNGLMULTITEXCOORD1IVPROC) glMultiTexCoord1iv; staticPointerglMultiTexCoord1s = (MYPFNGLMULTITEXCOORD1SPROC) glMultiTexCoord1s; staticPointerglMultiTexCoord1sv = (MYPFNGLMULTITEXCOORD1SVPROC) glMultiTexCoord1sv; staticPointerglMultiTexCoord2d = (MYPFNGLMULTITEXCOORD2DPROC) glMultiTexCoord2d; staticPointerglMultiTexCoord2dv = (MYPFNGLMULTITEXCOORD2DVPROC) glMultiTexCoord2dv; staticPointerglMultiTexCoord2f = (MYPFNGLMULTITEXCOORD2FPROC) glMultiTexCoord2f; staticPointerglMultiTexCoord2fv = (MYPFNGLMULTITEXCOORD2FVPROC) glMultiTexCoord2fv; staticPointerglMultiTexCoord2i = (MYPFNGLMULTITEXCOORD2IPROC) glMultiTexCoord2i; staticPointerglMultiTexCoord2iv = (MYPFNGLMULTITEXCOORD2IVPROC) glMultiTexCoord2iv; staticPointerglMultiTexCoord2s = (MYPFNGLMULTITEXCOORD2SPROC) glMultiTexCoord2s; staticPointerglMultiTexCoord2sv = (MYPFNGLMULTITEXCOORD2SVPROC) glMultiTexCoord2sv; staticPointerglMultiTexCoord3d = (MYPFNGLMULTITEXCOORD3DPROC) glMultiTexCoord3d; staticPointerglMultiTexCoord3dv = (MYPFNGLMULTITEXCOORD3DVPROC) glMultiTexCoord3dv; staticPointerglMultiTexCoord3f = (MYPFNGLMULTITEXCOORD3FPROC) glMultiTexCoord3f; staticPointerglMultiTexCoord3fv = (MYPFNGLMULTITEXCOORD3FVPROC) glMultiTexCoord3fv; staticPointerglMultiTexCoord3i = (MYPFNGLMULTITEXCOORD3IPROC) glMultiTexCoord3i; staticPointerglMultiTexCoord3iv = (MYPFNGLMULTITEXCOORD3IVPROC) glMultiTexCoord3iv; staticPointerglMultiTexCoord3s = (MYPFNGLMULTITEXCOORD3SPROC) glMultiTexCoord3s; staticPointerglMultiTexCoord3sv = (MYPFNGLMULTITEXCOORD3SVPROC) glMultiTexCoord3sv; staticPointerglMultiTexCoord4d = (MYPFNGLMULTITEXCOORD4DPROC) glMultiTexCoord4d; staticPointerglMultiTexCoord4dv = (MYPFNGLMULTITEXCOORD4DVPROC) glMultiTexCoord4dv; staticPointerglMultiTexCoord4f = (MYPFNGLMULTITEXCOORD4FPROC) glMultiTexCoord4f; staticPointerglMultiTexCoord4fv = (MYPFNGLMULTITEXCOORD4FVPROC) glMultiTexCoord4fv; staticPointerglMultiTexCoord4i = (MYPFNGLMULTITEXCOORD4IPROC) glMultiTexCoord4i; staticPointerglMultiTexCoord4iv = (MYPFNGLMULTITEXCOORD4IVPROC) glMultiTexCoord4iv; staticPointerglMultiTexCoord4s = (MYPFNGLMULTITEXCOORD4SPROC) glMultiTexCoord4s; staticPointerglMultiTexCoord4sv = (MYPFNGLMULTITEXCOORD4SVPROC) glMultiTexCoord4sv; staticPointerglLoadTransposeMatrixf = (MYPFNGLLOADTRANSPOSEMATRIXFPROC) glLoadTransposeMatrixf; staticPointerglLoadTransposeMatrixd = (MYPFNGLLOADTRANSPOSEMATRIXDPROC) glLoadTransposeMatrixd; staticPointerglMultTransposeMatrixf = (MYPFNGLMULTTRANSPOSEMATRIXFPROC) glMultTransposeMatrixf; staticPointerglMultTransposeMatrixd = (MYPFNGLMULTTRANSPOSEMATRIXDPROC) glMultTransposeMatrixd; staticPointerglSampleCoverage = (MYPFNGLSAMPLECOVERAGEPROC) glSampleCoverage; staticPointerglCompressedTexImage3D = (MYPFNGLCOMPRESSEDTEXIMAGE3DPROC) glCompressedTexImage3D; staticPointerglCompressedTexImage2D = (MYPFNGLCOMPRESSEDTEXIMAGE2DPROC) glCompressedTexImage2D; staticPointerglCompressedTexImage1D = (MYPFNGLCOMPRESSEDTEXIMAGE1DPROC) glCompressedTexImage1D; staticPointerglCompressedTexSubImage3D = (MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) glCompressedTexSubImage3D; staticPointerglCompressedTexSubImage2D = (MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) glCompressedTexSubImage2D; staticPointerglCompressedTexSubImage1D = (MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) glCompressedTexSubImage1D; staticPointerglGetCompressedTexImage = (MYPFNGLGETCOMPRESSEDTEXIMAGEPROC) glGetCompressedTexImage; #else staticPointerglActiveTexture = 0; staticPointerglClientActiveTexture = 0; staticPointerglMultiTexCoord1d = 0; staticPointerglMultiTexCoord1dv = 0; staticPointerglMultiTexCoord1f = 0; staticPointerglMultiTexCoord1fv = 0; staticPointerglMultiTexCoord1i = 0; staticPointerglMultiTexCoord1iv = 0; staticPointerglMultiTexCoord1s = 0; staticPointerglMultiTexCoord1sv = 0; staticPointerglMultiTexCoord2d = 0; staticPointerglMultiTexCoord2dv = 0; staticPointerglMultiTexCoord2f = 0; staticPointerglMultiTexCoord2fv = 0; staticPointerglMultiTexCoord2i = 0; staticPointerglMultiTexCoord2iv = 0; staticPointerglMultiTexCoord2s = 0; staticPointerglMultiTexCoord2sv = 0; staticPointerglMultiTexCoord3d = 0; staticPointerglMultiTexCoord3dv = 0; staticPointerglMultiTexCoord3f = 0; staticPointerglMultiTexCoord3fv = 0; staticPointerglMultiTexCoord3i = 0; staticPointerglMultiTexCoord3iv = 0; staticPointerglMultiTexCoord3s = 0; staticPointerglMultiTexCoord3sv = 0; staticPointerglMultiTexCoord4d = 0; staticPointerglMultiTexCoord4dv = 0; staticPointerglMultiTexCoord4f = 0; staticPointerglMultiTexCoord4fv = 0; staticPointerglMultiTexCoord4i = 0; staticPointerglMultiTexCoord4iv = 0; staticPointerglMultiTexCoord4s = 0; staticPointerglMultiTexCoord4sv = 0; staticPointerglLoadTransposeMatrixf = 0; staticPointerglLoadTransposeMatrixd = 0; staticPointerglMultTransposeMatrixf = 0; staticPointerglMultTransposeMatrixd = 0; staticPointerglSampleCoverage = 0; staticPointerglCompressedTexImage3D = 0; staticPointerglCompressedTexImage2D = 0; staticPointerglCompressedTexImage1D = 0; staticPointerglCompressedTexSubImage3D = 0; staticPointerglCompressedTexSubImage2D = 0; staticPointerglCompressedTexSubImage1D = 0; staticPointerglGetCompressedTexImage = 0; #endif // End OpenGL version 1.3 #if defined(GL_VERSION_1_4) && GL_VERSION_1_4 //staticPointerglBlendFuncSeparate = (MYPFNGLBLENDFUNCSEPARATEPROC) glBlendFuncSeparate; //staticPointerglFogCoordf = (MYPFNGLFOGCOORDFPROC) glFogCoordf; //staticPointerglFogCoordfv = (MYPFNGLFOGCOORDFVPROC) glFogCoordfv; //staticPointerglFogCoordd = (MYPFNGLFOGCOORDDPROC) glFogCoordd; //staticPointerglFogCoorddv = (MYPFNGLFOGCOORDDVPROC) glFogCoorddv; //staticPointerglFogCoordPointer = (MYPFNGLFOGCOORDPOINTERPROC) glFogCoordPointer; //staticPointerglMultiDrawArrays = (MYPFNGLMULTIDRAWARRAYSPROC) glMultiDrawArrays; //staticPointerglMultiDrawElements = (MYPFNGLMULTIDRAWELEMENTSPROC) glMultiDrawElements; // Stupid apple does not like to be compatible so I had to comment these // out temporarily //staticPointerglPointParameterf = (MYPFNGLPOINTPARAMETERFPROC) glPointParameterf; //staticPointerglPointParameterfv = (MYPFNGLPOINTPARAMETERFVPROC) glPointParameterfv; //staticPointerglPointParameteri = (MYPFNGLPOINTPARAMETERIPROC) glPointParameteri; //staticPointerglPointParameteriv = (MYPFNGLPOINTPARAMETERIVPROC) glPointParameteriv; //staticPointerglSecondaryColor3b = (MYPFNGLSECONDARYCOLOR3BPROC) glSecondaryColor3b; //staticPointerglSecondaryColor3bv = (MYPFNGLSECONDARYCOLOR3BVPROC) glSecondaryColor3bv; //staticPointerglSecondaryColor3d = (MYPFNGLSECONDARYCOLOR3DPROC) glSecondaryColor3d; //staticPointerglSecondaryColor3dv = (MYPFNGLSECONDARYCOLOR3DVPROC) glSecondaryColor3dv; //staticPointerglSecondaryColor3f = (MYPFNGLSECONDARYCOLOR3FPROC) glSecondaryColor3f; //staticPointerglSecondaryColor3fv = (MYPFNGLSECONDARYCOLOR3FVPROC) glSecondaryColor3fv; //staticPointerglSecondaryColor3i = (MYPFNGLSECONDARYCOLOR3IPROC) glSecondaryColor3i; //staticPointerglSecondaryColor3iv = (MYPFNGLSECONDARYCOLOR3IVPROC) glSecondaryColor3iv; //staticPointerglSecondaryColor3s = (MYPFNGLSECONDARYCOLOR3SPROC) glSecondaryColor3s; //staticPointerglSecondaryColor3sv = (MYPFNGLSECONDARYCOLOR3SVPROC) glSecondaryColor3sv; //staticPointerglSecondaryColor3ub = (MYPFNGLSECONDARYCOLOR3UBPROC) glSecondaryColor3ub; //staticPointerglSecondaryColor3ubv = (MYPFNGLSECONDARYCOLOR3UBVPROC) glSecondaryColor3ubv; //staticPointerglSecondaryColor3ui = (MYPFNGLSECONDARYCOLOR3UIPROC) glSecondaryColor3ui; //staticPointerglSecondaryColor3uiv = (MYPFNGLSECONDARYCOLOR3UIVPROC) glSecondaryColor3uiv; //staticPointerglSecondaryColor3us = (MYPFNGLSECONDARYCOLOR3USPROC) glSecondaryColor3us; //staticPointerglSecondaryColor3usv = (MYPFNGLSECONDARYCOLOR3USVPROC) glSecondaryColor3usv; //staticPointerglSecondaryColorPointer = (MYPFNGLSECONDARYCOLORPOINTERPROC) glSecondaryColorPointer; //staticPointerglWindowPos2d = (MYPFNGLWINDOWPOS2DPROC) glWindowPos2d; //staticPointerglWindowPos2dv = (MYPFNGLWINDOWPOS2DVPROC) glWindowPos2dv; //staticPointerglWindowPos2f = (MYPFNGLWINDOWPOS2FPROC) glWindowPos2f; //staticPointerglWindowPos2fv = (MYPFNGLWINDOWPOS2FVPROC) glWindowPos2fv; //staticPointerglWindowPos2i = (MYPFNGLWINDOWPOS2IPROC) glWindowPos2i; //staticPointerglWindowPos2iv = (MYPFNGLWINDOWPOS2IVPROC) glWindowPos2iv; //staticPointerglWindowPos2s = (MYPFNGLWINDOWPOS2SPROC) glWindowPos2s; //staticPointerglWindowPos2sv = (MYPFNGLWINDOWPOS2SVPROC) glWindowPos2sv; //staticPointerglWindowPos3d = (MYPFNGLWINDOWPOS3DPROC) glWindowPos3d; //staticPointerglWindowPos3dv = (MYPFNGLWINDOWPOS3DVPROC) glWindowPos3dv; //staticPointerglWindowPos3f = (MYPFNGLWINDOWPOS3FPROC) glWindowPos3f; //staticPointerglWindowPos3fv = (MYPFNGLWINDOWPOS3FVPROC) glWindowPos3fv; //staticPointerglWindowPos3i = (MYPFNGLWINDOWPOS3IPROC) glWindowPos3i; //staticPointerglWindowPos3iv = (MYPFNGLWINDOWPOS3IVPROC) glWindowPos3iv; //staticPointerglWindowPos3s = (MYPFNGLWINDOWPOS3SPROC) glWindowPos3s; //staticPointerglWindowPos3sv = (MYPFNGLWINDOWPOS3SVPROC) glWindowPos3sv; #else staticPointerglBlendFuncSeparate = 0; staticPointerglFogCoordf = 0; staticPointerglFogCoordfv = 0; staticPointerglFogCoordd = 0; staticPointerglFogCoorddv = 0; staticPointerglFogCoordPointer = 0; staticPointerglMultiDrawArrays = 0; staticPointerglMultiDrawElements = 0; staticPointerglPointParameterf = 0; staticPointerglPointParameterfv = 0; staticPointerglPointParameteri = 0; staticPointerglPointParameteriv = 0; staticPointerglSecondaryColor3b = 0; staticPointerglSecondaryColor3bv = 0; staticPointerglSecondaryColor3d = 0; staticPointerglSecondaryColor3dv = 0; staticPointerglSecondaryColor3f = 0; staticPointerglSecondaryColor3fv = 0; staticPointerglSecondaryColor3i = 0; staticPointerglSecondaryColor3iv = 0; staticPointerglSecondaryColor3s = 0; staticPointerglSecondaryColor3sv = 0; staticPointerglSecondaryColor3ub = 0; staticPointerglSecondaryColor3ubv = 0; staticPointerglSecondaryColor3ui = 0; staticPointerglSecondaryColor3uiv = 0; staticPointerglSecondaryColor3us = 0; staticPointerglSecondaryColor3usv = 0; staticPointerglSecondaryColorPointer = 0; staticPointerglWindowPos2d = 0; staticPointerglWindowPos2dv = 0; staticPointerglWindowPos2f = 0; staticPointerglWindowPos2fv = 0; staticPointerglWindowPos2i = 0; staticPointerglWindowPos2iv = 0; staticPointerglWindowPos2s = 0; staticPointerglWindowPos2sv = 0; staticPointerglWindowPos3d = 0; staticPointerglWindowPos3dv = 0; staticPointerglWindowPos3f = 0; staticPointerglWindowPos3fv = 0; staticPointerglWindowPos3i = 0; staticPointerglWindowPos3iv = 0; staticPointerglWindowPos3s = 0; staticPointerglWindowPos3sv = 0; #endif // End OpenGL version 1.4 #if defined(GL_EXT_paletted_texture) && GL_EXT_paletted_texture staticPointerglColorTableEXT = (MYPFNGLCOLORTABLEEXTPROC)glColorTableEXT; staticPointerglGetColorTableEXT = (MYPFNGLGETCOLORTABLEEXTPROC)glGetColorTableEXT; staticPointerglGetColorTableParameterivEXT = (MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glGetColorTableParameterivEXT; staticPointerglGetColorTableParameterfvEXT = (MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glGetColorTableParameterfvEXT; #else staticPointerglColorTableEXT = (MYPFNGLCOLORTABLEEXTPROC) 0; staticPointerglGetColorTableEXT = (MYPFNGLGETCOLORTABLEEXTPROC) 0; staticPointerglGetColorTableParameterivEXT = (MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) 0; staticPointerglGetColorTableParameterfvEXT = (MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) 0; #endif // End GL_EXT_paletted_texture #if defined(GL_ARB_multitexture) && GL_ARB_multitexture staticPointerglActiveTextureARB = (MYPFNGLACTIVETEXTUREARBPROC)glActiveTextureARB; staticPointerglClientActiveTextureARB = (MYPFNGLCLIENTACTIVETEXTUREARBPROC)glClientActiveTextureARB; staticPointerglMultiTexCoord1dARB = (MYPFNGLMULTITEXCOORD1DARBPROC)glMultiTexCoord1dARB; staticPointerglMultiTexCoord1dvARB = (MYPFNGLMULTITEXCOORD1DVARBPROC)glMultiTexCoord1dvARB; staticPointerglMultiTexCoord1fARB = (MYPFNGLMULTITEXCOORD1FARBPROC)glMultiTexCoord1fARB; staticPointerglMultiTexCoord1fvARB = (MYPFNGLMULTITEXCOORD1FVARBPROC)glMultiTexCoord1fvARB; staticPointerglMultiTexCoord1iARB = (MYPFNGLMULTITEXCOORD1IARBPROC)glMultiTexCoord1iARB; staticPointerglMultiTexCoord1ivARB = (MYPFNGLMULTITEXCOORD1IVARBPROC)glMultiTexCoord1ivARB; staticPointerglMultiTexCoord1sARB = (MYPFNGLMULTITEXCOORD1SARBPROC)glMultiTexCoord1sARB; staticPointerglMultiTexCoord1svARB = (MYPFNGLMULTITEXCOORD1SVARBPROC)glMultiTexCoord1svARB; staticPointerglMultiTexCoord2dARB = (MYPFNGLMULTITEXCOORD2DARBPROC)glMultiTexCoord2dARB; staticPointerglMultiTexCoord2dvARB = (MYPFNGLMULTITEXCOORD2DVARBPROC)glMultiTexCoord2dvARB; staticPointerglMultiTexCoord2fARB = (MYPFNGLMULTITEXCOORD2FARBPROC)glMultiTexCoord2fARB; staticPointerglMultiTexCoord2fvARB = (MYPFNGLMULTITEXCOORD2FVARBPROC)glMultiTexCoord2fvARB; staticPointerglMultiTexCoord2iARB = (MYPFNGLMULTITEXCOORD2IARBPROC)glMultiTexCoord2iARB; staticPointerglMultiTexCoord2ivARB = (MYPFNGLMULTITEXCOORD2IVARBPROC)glMultiTexCoord2ivARB; staticPointerglMultiTexCoord2sARB = (MYPFNGLMULTITEXCOORD2SARBPROC)glMultiTexCoord2sARB; staticPointerglMultiTexCoord2svARB = (MYPFNGLMULTITEXCOORD2SVARBPROC)glMultiTexCoord2svARB; staticPointerglMultiTexCoord3dARB = (MYPFNGLMULTITEXCOORD3DARBPROC)glMultiTexCoord3dARB; staticPointerglMultiTexCoord3dvARB = (MYPFNGLMULTITEXCOORD3DVARBPROC)glMultiTexCoord3dvARB; staticPointerglMultiTexCoord3fARB = (MYPFNGLMULTITEXCOORD3FARBPROC)glMultiTexCoord3fARB; staticPointerglMultiTexCoord3fvARB = (MYPFNGLMULTITEXCOORD3FVARBPROC)glMultiTexCoord3fvARB; staticPointerglMultiTexCoord3iARB = (MYPFNGLMULTITEXCOORD3IARBPROC)glMultiTexCoord3iARB; staticPointerglMultiTexCoord3ivARB = (MYPFNGLMULTITEXCOORD3IVARBPROC)glMultiTexCoord3ivARB; staticPointerglMultiTexCoord3sARB = (MYPFNGLMULTITEXCOORD3SARBPROC)glMultiTexCoord3sARB; staticPointerglMultiTexCoord3svARB = (MYPFNGLMULTITEXCOORD3SVARBPROC)glMultiTexCoord3svARB; staticPointerglMultiTexCoord4dARB = (MYPFNGLMULTITEXCOORD4DARBPROC)glMultiTexCoord4dARB; staticPointerglMultiTexCoord4dvARB = (MYPFNGLMULTITEXCOORD4DVARBPROC)glMultiTexCoord4dvARB; staticPointerglMultiTexCoord4fARB = (MYPFNGLMULTITEXCOORD4FARBPROC)glMultiTexCoord4fARB; staticPointerglMultiTexCoord4fvARB = (MYPFNGLMULTITEXCOORD4FVARBPROC)glMultiTexCoord4fvARB; staticPointerglMultiTexCoord4iARB = (MYPFNGLMULTITEXCOORD4IARBPROC)glMultiTexCoord4iARB; staticPointerglMultiTexCoord4ivARB = (MYPFNGLMULTITEXCOORD4IVARBPROC)glMultiTexCoord4ivARB; staticPointerglMultiTexCoord4sARB = (MYPFNGLMULTITEXCOORD4SARBPROC)glMultiTexCoord4sARB; staticPointerglMultiTexCoord4svARB = (MYPFNGLMULTITEXCOORD4SVARBPROC)glMultiTexCoord4svARB; #else staticPointerglActiveTextureARB = (MYPFNGLACTIVETEXTUREARBPROC) 0; staticPointerglClientActiveTextureARB = (MYPFNGLCLIENTACTIVETEXTUREARBPROC) 0; staticPointerglMultiTexCoord1dARB = (MYPFNGLMULTITEXCOORD1DARBPROC) 0; staticPointerglMultiTexCoord1dvARB = (MYPFNGLMULTITEXCOORD1DVARBPROC) 0; staticPointerglMultiTexCoord1fARB = (MYPFNGLMULTITEXCOORD1FARBPROC) 0; staticPointerglMultiTexCoord1fvARB = (MYPFNGLMULTITEXCOORD1FVARBPROC) 0; staticPointerglMultiTexCoord1iARB = (MYPFNGLMULTITEXCOORD1IARBPROC) 0; staticPointerglMultiTexCoord1ivARB = (MYPFNGLMULTITEXCOORD1IVARBPROC) 0; staticPointerglMultiTexCoord1sARB = (MYPFNGLMULTITEXCOORD1SARBPROC) 0; staticPointerglMultiTexCoord1svARB = (MYPFNGLMULTITEXCOORD1SVARBPROC) 0; staticPointerglMultiTexCoord2dARB = (MYPFNGLMULTITEXCOORD2DARBPROC) 0; staticPointerglMultiTexCoord2dvARB = (MYPFNGLMULTITEXCOORD2DVARBPROC) 0; staticPointerglMultiTexCoord2fARB = (MYPFNGLMULTITEXCOORD2FARBPROC) 0; staticPointerglMultiTexCoord2fvARB = (MYPFNGLMULTITEXCOORD2FVARBPROC) 0; staticPointerglMultiTexCoord2iARB = (MYPFNGLMULTITEXCOORD2IARBPROC) 0; staticPointerglMultiTexCoord2ivARB = (MYPFNGLMULTITEXCOORD2IVARBPROC) 0; staticPointerglMultiTexCoord2sARB = (MYPFNGLMULTITEXCOORD2SARBPROC) 0; staticPointerglMultiTexCoord2svARB = (MYPFNGLMULTITEXCOORD2SVARBPROC) 0; staticPointerglMultiTexCoord3dARB = (MYPFNGLMULTITEXCOORD3DARBPROC) 0; staticPointerglMultiTexCoord3dvARB = (MYPFNGLMULTITEXCOORD3DVARBPROC) 0; staticPointerglMultiTexCoord3fARB = (MYPFNGLMULTITEXCOORD3FARBPROC) 0; staticPointerglMultiTexCoord3fvARB = (MYPFNGLMULTITEXCOORD3FVARBPROC) 0; staticPointerglMultiTexCoord3iARB = (MYPFNGLMULTITEXCOORD3IARBPROC) 0; staticPointerglMultiTexCoord3ivARB = (MYPFNGLMULTITEXCOORD3IVARBPROC) 0; staticPointerglMultiTexCoord3sARB = (MYPFNGLMULTITEXCOORD3SARBPROC) 0; staticPointerglMultiTexCoord3svARB = (MYPFNGLMULTITEXCOORD3SVARBPROC) 0; staticPointerglMultiTexCoord4dARB = (MYPFNGLMULTITEXCOORD4DARBPROC) 0; staticPointerglMultiTexCoord4dvARB = (MYPFNGLMULTITEXCOORD4DVARBPROC) 0; staticPointerglMultiTexCoord4fARB = (MYPFNGLMULTITEXCOORD4FARBPROC) 0; staticPointerglMultiTexCoord4fvARB = (MYPFNGLMULTITEXCOORD4FVARBPROC) 0; staticPointerglMultiTexCoord4iARB = (MYPFNGLMULTITEXCOORD4IARBPROC) 0; staticPointerglMultiTexCoord4ivARB = (MYPFNGLMULTITEXCOORD4IVARBPROC) 0; staticPointerglMultiTexCoord4sARB = (MYPFNGLMULTITEXCOORD4SARBPROC) 0; staticPointerglMultiTexCoord4svARB = (MYPFNGLMULTITEXCOORD4SVARBPROC) 0; #endif // End GL_ARB_multitexture #if defined(GL_SGI_texture_color_table) && GL_SGI_texture_color_table // No new functions. #endif // End GL_SGI_texture_color_table #if defined(GL_SGI_color_table) && GL_SGI_color_table staticPointerglColorTableSGI = (MYPFNGLCOLORTABLESGIPROC)glColorTableSGI; staticPointerglColorTableParameterfvSGI = (MYPFNGLCOLORTABLEPARAMETERFVSGIPROC)glColorTableParameterfvSGI; staticPointerglColorTableParameterivSGI = (MYPFNGLCOLORTABLEPARAMETERIVSGIPROC)glColorTableParameterivSGI; staticPointerglCopyColorTableSGI = (MYPFNGLCOPYCOLORTABLESGIPROC)glCopyColorTableSGI; staticPointerglGetColorTableSGI = (MYPFNGLGETCOLORTABLESGIPROC)glGetColorTableSGI; staticPointerglGetColorTableParameterfvSGI = (MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glGetColorTableParameterfvSGI; staticPointerglGetColorTableParameterivSGI = (MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glGetColorTableParameterivSGI; #else staticPointerglColorTableSGI = (MYPFNGLCOLORTABLESGIPROC) 0; staticPointerglColorTableParameterfvSGI = (MYPFNGLCOLORTABLEPARAMETERFVSGIPROC) 0; staticPointerglColorTableParameterivSGI = (MYPFNGLCOLORTABLEPARAMETERIVSGIPROC) 0; staticPointerglCopyColorTableSGI = (MYPFNGLCOPYCOLORTABLESGIPROC) 0; staticPointerglGetColorTableSGI = (MYPFNGLGETCOLORTABLESGIPROC) 0; staticPointerglGetColorTableParameterfvSGI = (MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) 0; staticPointerglGetColorTableParameterivSGI = (MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) 0; #endif // End GL_SGI_color_table #if defined(GL_SGIS_texture_edge_clamp) && GL_SGIS_texture_edge_clamp // No new functions. #endif // End GL_SGIS_texture_edge_clamp #if defined(GL_EXT_texture3D) && GL_EXT_texture3D staticPointerglTexImage3DEXT = (MYPFNGLTEXIMAGE3DEXTPROC)glTexImage3DEXT; staticPointerglTexSubImage3DEXT = (MYPFNGLTEXSUBIMAGE3DEXTPROC)glTexSubImage3DEXT; #else staticPointerglTexImage3DEXT = (MYPFNGLTEXIMAGE3DEXTPROC) 0; staticPointerglTexSubImage3DEXT = (MYPFNGLTEXSUBIMAGE3DEXTPROC) 0; #endif // End GL_EXT_texture3D #if defined(GL_NV_fragment_program) && GL_NV_fragment_program staticPointerglProgramNamedParameter4fNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glProgramNamedParameter4fNV; staticPointerglProgramNamedParameter4dNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glProgramNamedParameter4dNV; staticPointerglProgramNamedParameter4fvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glProgramNamedParameter4fvNV; staticPointerglProgramNamedParameter4dvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glProgramNamedParameter4dvNV; staticPointerglGetProgramNamedParameterfvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glGetProgramNamedParameterfvNV; staticPointerglGetProgramNamedParameterdvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glGetProgramNamedParameterdvNV; #else staticPointerglProgramNamedParameter4fNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) 0; staticPointerglProgramNamedParameter4dNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) 0; staticPointerglProgramNamedParameter4fvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) 0; staticPointerglProgramNamedParameter4dvNV = (MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) 0; staticPointerglGetProgramNamedParameterfvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) 0; staticPointerglGetProgramNamedParameterdvNV = (MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) 0; #endif // GL_NV_fragment_program #if defined(GL_NV_vertex_program) && GL_NV_vertex_program staticPointerglAreProgramsResidentNV = (MYPFNGLAREPROGRAMSRESIDENTNVPROC)glAreProgramsResidentNV; staticPointerglBindProgramNV = (MYPFNGLBINDPROGRAMNVPROC)glBindProgramNV; staticPointerglDeleteProgramsNV = (MYPFNGLDELETEPROGRAMSNVPROC)glDeleteProgramsNV; staticPointerglExecuteProgramNV = (MYPFNGLEXECUTEPROGRAMNVPROC)glExecuteProgramNV; staticPointerglGenProgramsNV = (MYPFNGLGENPROGRAMSNVPROC)glGenProgramsNV; staticPointerglGetProgramParameterdvNV = (MYPFNGLGETPROGRAMPARAMETERDVNVPROC)glGetProgramParameterdvNV; staticPointerglGetProgramParameterfvNV = (MYPFNGLGETPROGRAMPARAMETERFVNVPROC)glGetProgramParameterfvNV; staticPointerglGetProgramivNV = (MYPFNGLGETPROGRAMIVNVPROC)glGetProgramivNV; staticPointerglGetProgramStringNV = (MYPFNGLGETPROGRAMSTRINGNVPROC)glGetProgramStringNV; staticPointerglGetTrackMatrixivNV = (MYPFNGLGETTRACKMATRIXIVNVPROC)glGetTrackMatrixivNV; staticPointerglGetVertexAttribdvNV = (MYPFNGLGETVERTEXATTRIBDVNVPROC)glGetVertexAttribdvNV; staticPointerglGetVertexAttribfvNV = (MYPFNGLGETVERTEXATTRIBFVNVPROC)glGetVertexAttribfvNV; staticPointerglGetVertexAttribivNV = (MYPFNGLGETVERTEXATTRIBIVNVPROC)glGetVertexAttribivNV; staticPointerglGetVertexAttribPointervNV = (MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC)glGetVertexAttribPointervNV; staticPointerglIsProgramNV = (MYPFNGLISPROGRAMNVPROC)glIsProgramNV; staticPointerglLoadProgramNV = (MYPFNGLLOADPROGRAMNVPROC)glLoadProgramNV; staticPointerglProgramParameter4dNV = (MYPFNGLPROGRAMPARAMETER4DNVPROC)glProgramParameter4dNV; staticPointerglProgramParameter4dvNV = (MYPFNGLPROGRAMPARAMETER4DVNVPROC)glProgramParameter4dvNV; staticPointerglProgramParameter4fNV = (MYPFNGLPROGRAMPARAMETER4FNVPROC)glProgramParameter4fNV; staticPointerglProgramParameter4fvNV = (MYPFNGLPROGRAMPARAMETER4FVNVPROC)glProgramParameter4fvNV; staticPointerglProgramParameters4dvNV = (MYPFNGLPROGRAMPARAMETERS4DVNVPROC)glProgramParameters4dvNV; staticPointerglProgramParameters4fvNV = (MYPFNGLPROGRAMPARAMETERS4FVNVPROC)glProgramParameters4fvNV; staticPointerglRequestResidentProgramsNV = (MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC)glRequestResidentProgramsNV; staticPointerglTrackMatrixNV = (MYPFNGLTRACKMATRIXNVPROC)glTrackMatrixNV; staticPointerglVertexAttribPointerNV = (MYPFNGLVERTEXATTRIBPOINTERNVPROC)glVertexAttribPointerNV; staticPointerglVertexAttrib1dNV = (MYPFNGLVERTEXATTRIB1DNVPROC)glVertexAttrib1dNV; staticPointerglVertexAttrib1dvNV = (MYPFNGLVERTEXATTRIB1DVNVPROC)glVertexAttrib1dvNV; staticPointerglVertexAttrib1fNV = (MYPFNGLVERTEXATTRIB1FNVPROC)glVertexAttrib1fNV; staticPointerglVertexAttrib1fvNV = (MYPFNGLVERTEXATTRIB1FVNVPROC)glVertexAttrib1fvNV; staticPointerglVertexAttrib1sNV = (MYPFNGLVERTEXATTRIB1SNVPROC)glVertexAttrib1sNV; staticPointerglVertexAttrib1svNV = (MYPFNGLVERTEXATTRIB1SVNVPROC)glVertexAttrib1svNV; staticPointerglVertexAttrib2dNV = (MYPFNGLVERTEXATTRIB2DNVPROC)glVertexAttrib2dNV; staticPointerglVertexAttrib2dvNV = (MYPFNGLVERTEXATTRIB2DVNVPROC)glVertexAttrib2dvNV; staticPointerglVertexAttrib2fNV = (MYPFNGLVERTEXATTRIB2FNVPROC)glVertexAttrib2fNV; staticPointerglVertexAttrib2fvNV = (MYPFNGLVERTEXATTRIB2FVNVPROC)glVertexAttrib2fvNV; staticPointerglVertexAttrib2sNV = (MYPFNGLVERTEXATTRIB2SNVPROC)glVertexAttrib2sNV; staticPointerglVertexAttrib2svNV = (MYPFNGLVERTEXATTRIB2SVNVPROC)glVertexAttrib2svNV; staticPointerglVertexAttrib3dNV = (MYPFNGLVERTEXATTRIB3DNVPROC)glVertexAttrib3dNV; staticPointerglVertexAttrib3dvNV = (MYPFNGLVERTEXATTRIB3DVNVPROC)glVertexAttrib3dvNV; staticPointerglVertexAttrib3fNV = (MYPFNGLVERTEXATTRIB3FNVPROC)glVertexAttrib3fNV; staticPointerglVertexAttrib3fvNV = (MYPFNGLVERTEXATTRIB3FVNVPROC)glVertexAttrib3fvNV; staticPointerglVertexAttrib3sNV = (MYPFNGLVERTEXATTRIB3SNVPROC)glVertexAttrib3sNV; staticPointerglVertexAttrib3svNV = (MYPFNGLVERTEXATTRIB3SVNVPROC)glVertexAttrib3svNV; staticPointerglVertexAttrib4dNV = (MYPFNGLVERTEXATTRIB4DNVPROC)glVertexAttrib4dNV; staticPointerglVertexAttrib4dvNV = (MYPFNGLVERTEXATTRIB4DVNVPROC)glVertexAttrib4dvNV; staticPointerglVertexAttrib4fNV = (MYPFNGLVERTEXATTRIB4FNVPROC)glVertexAttrib4fNV; staticPointerglVertexAttrib4fvNV = (MYPFNGLVERTEXATTRIB4FVNVPROC)glVertexAttrib4fvNV; staticPointerglVertexAttrib4sNV = (MYPFNGLVERTEXATTRIB4SNVPROC)glVertexAttrib4sNV; staticPointerglVertexAttrib4svNV = (MYPFNGLVERTEXATTRIB4SVNVPROC)glVertexAttrib4svNV; staticPointerglVertexAttrib4ubNV = (MYPFNGLVERTEXATTRIB4UBNVPROC)glVertexAttrib4ubNV; staticPointerglVertexAttrib4ubvNV = (MYPFNGLVERTEXATTRIB4UBVNVPROC)glVertexAttrib4ubvNV; staticPointerglVertexAttribs1dvNV = (MYPFNGLVERTEXATTRIBS1DVNVPROC)glVertexAttribs1dvNV; staticPointerglVertexAttribs1fvNV = (MYPFNGLVERTEXATTRIBS1FVNVPROC)glVertexAttribs1fvNV; staticPointerglVertexAttribs1svNV = (MYPFNGLVERTEXATTRIBS1SVNVPROC)glVertexAttribs1svNV; staticPointerglVertexAttribs2dvNV = (MYPFNGLVERTEXATTRIBS2DVNVPROC)glVertexAttribs2dvNV; staticPointerglVertexAttribs2fvNV = (MYPFNGLVERTEXATTRIBS2FVNVPROC)glVertexAttribs2fvNV; staticPointerglVertexAttribs2svNV = (MYPFNGLVERTEXATTRIBS2SVNVPROC)glVertexAttribs2svNV; staticPointerglVertexAttribs3dvNV = (MYPFNGLVERTEXATTRIBS3DVNVPROC)glVertexAttribs3dvNV; staticPointerglVertexAttribs3fvNV = (MYPFNGLVERTEXATTRIBS3FVNVPROC)glVertexAttribs3fvNV; staticPointerglVertexAttribs3svNV = (MYPFNGLVERTEXATTRIBS3SVNVPROC)glVertexAttribs3svNV; staticPointerglVertexAttribs4dvNV = (MYPFNGLVERTEXATTRIBS4DVNVPROC)glVertexAttribs4dvNV; staticPointerglVertexAttribs4fvNV = (MYPFNGLVERTEXATTRIBS4FVNVPROC)glVertexAttribs4fvNV; staticPointerglVertexAttribs4svNV = (MYPFNGLVERTEXATTRIBS4SVNVPROC)glVertexAttribs4svNV; staticPointerglVertexAttribs4ubvNV = (MYPFNGLVERTEXATTRIBS4UBVNVPROC)glVertexAttribs4ubvNV; #else staticPointerglAreProgramsResidentNV = (MYPFNGLAREPROGRAMSRESIDENTNVPROC) 0; staticPointerglBindProgramNV = (MYPFNGLBINDPROGRAMNVPROC) 0; staticPointerglDeleteProgramsNV = (MYPFNGLDELETEPROGRAMSNVPROC) 0; staticPointerglExecuteProgramNV = (MYPFNGLEXECUTEPROGRAMNVPROC) 0; staticPointerglGenProgramsNV = (MYPFNGLGENPROGRAMSNVPROC) 0; staticPointerglGetProgramParameterdvNV = (MYPFNGLGETPROGRAMPARAMETERDVNVPROC) 0; staticPointerglGetProgramParameterfvNV = (MYPFNGLGETPROGRAMPARAMETERFVNVPROC) 0; staticPointerglGetProgramivNV = (MYPFNGLGETPROGRAMIVNVPROC) 0; staticPointerglGetProgramStringNV = (MYPFNGLGETPROGRAMSTRINGNVPROC) 0; staticPointerglGetTrackMatrixivNV = (MYPFNGLGETTRACKMATRIXIVNVPROC) 0; staticPointerglGetVertexAttribdvNV = (MYPFNGLGETVERTEXATTRIBDVNVPROC) 0; staticPointerglGetVertexAttribfvNV = (MYPFNGLGETVERTEXATTRIBFVNVPROC) 0; staticPointerglGetVertexAttribivNV = (MYPFNGLGETVERTEXATTRIBIVNVPROC) 0; staticPointerglGetVertexAttribPointervNV = (MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC) 0; staticPointerglIsProgramNV = (MYPFNGLISPROGRAMNVPROC) 0; staticPointerglLoadProgramNV = (MYPFNGLLOADPROGRAMNVPROC) 0; staticPointerglProgramParameter4dNV = (MYPFNGLPROGRAMPARAMETER4DNVPROC) 0; staticPointerglProgramParameter4dvNV = (MYPFNGLPROGRAMPARAMETER4DVNVPROC) 0; staticPointerglProgramParameter4fNV = (MYPFNGLPROGRAMPARAMETER4FNVPROC) 0; staticPointerglProgramParameter4fvNV = (MYPFNGLPROGRAMPARAMETER4FVNVPROC) 0; staticPointerglProgramParameters4dvNV = (MYPFNGLPROGRAMPARAMETERS4DVNVPROC) 0; staticPointerglProgramParameters4fvNV = (MYPFNGLPROGRAMPARAMETERS4FVNVPROC) 0; staticPointerglRequestResidentProgramsNV = (MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC) 0; staticPointerglTrackMatrixNV = (MYPFNGLTRACKMATRIXNVPROC) 0; staticPointerglVertexAttribPointerNV = (MYPFNGLVERTEXATTRIBPOINTERNVPROC) 0; staticPointerglVertexAttrib1dNV = (MYPFNGLVERTEXATTRIB1DNVPROC) 0; staticPointerglVertexAttrib1dvNV = (MYPFNGLVERTEXATTRIB1DVNVPROC) 0; staticPointerglVertexAttrib1fNV = (MYPFNGLVERTEXATTRIB1FNVPROC) 0; staticPointerglVertexAttrib1fvNV = (MYPFNGLVERTEXATTRIB1FVNVPROC) 0; staticPointerglVertexAttrib1sNV = (MYPFNGLVERTEXATTRIB1SNVPROC) 0; staticPointerglVertexAttrib1svNV = (MYPFNGLVERTEXATTRIB1SVNVPROC) 0; staticPointerglVertexAttrib2dNV = (MYPFNGLVERTEXATTRIB2DNVPROC) 0; staticPointerglVertexAttrib2dvNV = (MYPFNGLVERTEXATTRIB2DVNVPROC) 0; staticPointerglVertexAttrib2fNV = (MYPFNGLVERTEXATTRIB2FNVPROC) 0; staticPointerglVertexAttrib2fvNV = (MYPFNGLVERTEXATTRIB2FVNVPROC) 0; staticPointerglVertexAttrib2sNV = (MYPFNGLVERTEXATTRIB2SNVPROC) 0; staticPointerglVertexAttrib2svNV = (MYPFNGLVERTEXATTRIB2SVNVPROC) 0; staticPointerglVertexAttrib3dNV = (MYPFNGLVERTEXATTRIB3DNVPROC) 0; staticPointerglVertexAttrib3dvNV = (MYPFNGLVERTEXATTRIB3DVNVPROC) 0; staticPointerglVertexAttrib3fNV = (MYPFNGLVERTEXATTRIB3FNVPROC) 0; staticPointerglVertexAttrib3fvNV = (MYPFNGLVERTEXATTRIB3FVNVPROC) 0; staticPointerglVertexAttrib3sNV = (MYPFNGLVERTEXATTRIB3SNVPROC) 0; staticPointerglVertexAttrib3svNV = (MYPFNGLVERTEXATTRIB3SVNVPROC) 0; staticPointerglVertexAttrib4dNV = (MYPFNGLVERTEXATTRIB4DNVPROC) 0; staticPointerglVertexAttrib4dvNV = (MYPFNGLVERTEXATTRIB4DVNVPROC) 0; staticPointerglVertexAttrib4fNV = (MYPFNGLVERTEXATTRIB4FNVPROC) 0; staticPointerglVertexAttrib4fvNV = (MYPFNGLVERTEXATTRIB4FVNVPROC) 0; staticPointerglVertexAttrib4sNV = (MYPFNGLVERTEXATTRIB4SNVPROC) 0; staticPointerglVertexAttrib4svNV = (MYPFNGLVERTEXATTRIB4SVNVPROC) 0; staticPointerglVertexAttrib4ubNV = (MYPFNGLVERTEXATTRIB4UBNVPROC) 0; staticPointerglVertexAttrib4ubvNV = (MYPFNGLVERTEXATTRIB4UBVNVPROC) 0; staticPointerglVertexAttribs1dvNV = (MYPFNGLVERTEXATTRIBS1DVNVPROC) 0; staticPointerglVertexAttribs1fvNV = (MYPFNGLVERTEXATTRIBS1FVNVPROC) 0; staticPointerglVertexAttribs1svNV = (MYPFNGLVERTEXATTRIBS1SVNVPROC) 0; staticPointerglVertexAttribs2dvNV = (MYPFNGLVERTEXATTRIBS2DVNVPROC) 0; staticPointerglVertexAttribs2fvNV = (MYPFNGLVERTEXATTRIBS2FVNVPROC) 0; staticPointerglVertexAttribs2svNV = (MYPFNGLVERTEXATTRIBS2SVNVPROC) 0; staticPointerglVertexAttribs3dvNV = (MYPFNGLVERTEXATTRIBS3DVNVPROC) 0; staticPointerglVertexAttribs3fvNV = (MYPFNGLVERTEXATTRIBS3FVNVPROC) 0; staticPointerglVertexAttribs3svNV = (MYPFNGLVERTEXATTRIBS3SVNVPROC) 0; staticPointerglVertexAttribs4dvNV = (MYPFNGLVERTEXATTRIBS4DVNVPROC) 0; staticPointerglVertexAttribs4fvNV = (MYPFNGLVERTEXATTRIBS4FVNVPROC) 0; staticPointerglVertexAttribs4svNV = (MYPFNGLVERTEXATTRIBS4SVNVPROC) 0; staticPointerglVertexAttribs4ubvNV = (MYPFNGLVERTEXATTRIBS4UBVNVPROC) 0; #endif // GL_NV_vertex_program #if defined(GL_ARB_vertex_program) && GL_ARB_vertex_program staticPointerglVertexAttrib1dARB = (MYPFNGLVERTEXATTRIB1DARBPROC) glVertexAttrib1dARB; staticPointerglVertexAttrib1dvARB = (MYPFNGLVERTEXATTRIB1DVARBPROC) glVertexAttrib1dvARB; staticPointerglVertexAttrib1fARB = (MYPFNGLVERTEXATTRIB1FARBPROC) glVertexAttrib1fARB; staticPointerglVertexAttrib1fvARB = (MYPFNGLVERTEXATTRIB1FVARBPROC) glVertexAttrib1fvARB; staticPointerglVertexAttrib1sARB = (MYPFNGLVERTEXATTRIB1SARBPROC) glVertexAttrib1sARB; staticPointerglVertexAttrib1svARB = (MYPFNGLVERTEXATTRIB1SVARBPROC) glVertexAttrib1svARB; staticPointerglVertexAttrib2dARB = (MYPFNGLVERTEXATTRIB2DARBPROC) glVertexAttrib2dARB; staticPointerglVertexAttrib2dvARB = (MYPFNGLVERTEXATTRIB2DVARBPROC) glVertexAttrib2dvARB; staticPointerglVertexAttrib2fARB = (MYPFNGLVERTEXATTRIB2FARBPROC) glVertexAttrib2fARB; staticPointerglVertexAttrib2fvARB = (MYPFNGLVERTEXATTRIB2FVARBPROC) glVertexAttrib2fvARB; staticPointerglVertexAttrib2sARB = (MYPFNGLVERTEXATTRIB2SARBPROC) glVertexAttrib2sARB; staticPointerglVertexAttrib2svARB = (MYPFNGLVERTEXATTRIB2SVARBPROC) glVertexAttrib2svARB; staticPointerglVertexAttrib3dARB = (MYPFNGLVERTEXATTRIB3DARBPROC) glVertexAttrib3dARB; staticPointerglVertexAttrib3dvARB = (MYPFNGLVERTEXATTRIB3DVARBPROC) glVertexAttrib3dvARB; staticPointerglVertexAttrib3fARB = (MYPFNGLVERTEXATTRIB3FARBPROC) glVertexAttrib3fARB; staticPointerglVertexAttrib3fvARB = (MYPFNGLVERTEXATTRIB3FVARBPROC) glVertexAttrib3fvARB; staticPointerglVertexAttrib3sARB = (MYPFNGLVERTEXATTRIB3SARBPROC) glVertexAttrib3sARB; staticPointerglVertexAttrib3svARB = (MYPFNGLVERTEXATTRIB3SVARBPROC) glVertexAttrib3svARB; staticPointerglVertexAttrib4NbvARB = (MYPFNGLVERTEXATTRIB4NBVARBPROC) glVertexAttrib4NbvARB; staticPointerglVertexAttrib4NivARB = (MYPFNGLVERTEXATTRIB4NIVARBPROC) glVertexAttrib4NivARB; staticPointerglVertexAttrib4NsvARB = (MYPFNGLVERTEXATTRIB4NSVARBPROC) glVertexAttrib4NsvARB; staticPointerglVertexAttrib4NubARB = (MYPFNGLVERTEXATTRIB4NUBARBPROC) glVertexAttrib4NubARB; staticPointerglVertexAttrib4NubvARB = (MYPFNGLVERTEXATTRIB4NUBVARBPROC) glVertexAttrib4NubvARB; staticPointerglVertexAttrib4NuivARB = (MYPFNGLVERTEXATTRIB4NUIVARBPROC) glVertexAttrib4NuivARB; staticPointerglVertexAttrib4NusvARB = (MYPFNGLVERTEXATTRIB4NUSVARBPROC) glVertexAttrib4NusvARB; staticPointerglVertexAttrib4bvARB = (MYPFNGLVERTEXATTRIB4BVARBPROC) glVertexAttrib4bvARB; staticPointerglVertexAttrib4dARB = (MYPFNGLVERTEXATTRIB4DARBPROC) glVertexAttrib4dARB; staticPointerglVertexAttrib4dvARB = (MYPFNGLVERTEXATTRIB4DVARBPROC) glVertexAttrib4dvARB; staticPointerglVertexAttrib4fARB = (MYPFNGLVERTEXATTRIB4FARBPROC) glVertexAttrib4fARB; staticPointerglVertexAttrib4fvARB = (MYPFNGLVERTEXATTRIB4FVARBPROC) glVertexAttrib4fvARB; staticPointerglVertexAttrib4ivARB = (MYPFNGLVERTEXATTRIB4IVARBPROC) glVertexAttrib4ivARB; staticPointerglVertexAttrib4sARB = (MYPFNGLVERTEXATTRIB4SARBPROC) glVertexAttrib4sARB; staticPointerglVertexAttrib4svARB = (MYPFNGLVERTEXATTRIB4SVARBPROC) glVertexAttrib4svARB; staticPointerglVertexAttrib4ubvARB = (MYPFNGLVERTEXATTRIB4UBVARBPROC) glVertexAttrib4ubvARB; staticPointerglVertexAttrib4uivARB = (MYPFNGLVERTEXATTRIB4UIVARBPROC) glVertexAttrib4uivARB; staticPointerglVertexAttrib4usvARB = (MYPFNGLVERTEXATTRIB4USVARBPROC) glVertexAttrib4usvARB; staticPointerglVertexAttribPointerARB = (MYPFNGLVERTEXATTRIBPOINTERARBPROC) glVertexAttribPointerARB; staticPointerglEnableVertexAttribArrayARB = (MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC) glEnableVertexAttribArrayARB; staticPointerglDisableVertexAttribArrayARB = (MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) glDisableVertexAttribArrayARB; staticPointerglProgramStringARB = (MYPFNGLPROGRAMSTRINGARBPROC) glProgramStringARB; staticPointerglBindProgramARB = (MYPFNGLBINDPROGRAMARBPROC) glBindProgramARB; staticPointerglDeleteProgramsARB = (MYPFNGLDELETEPROGRAMSARBPROC) glDeleteProgramsARB; staticPointerglGenProgramsARB = (MYPFNGLGENPROGRAMSARBPROC) glGenProgramsARB; staticPointerglProgramEnvParameter4dARB = (MYPFNGLPROGRAMENVPARAMETER4DARBPROC) glProgramEnvParameter4dARB; staticPointerglProgramEnvParameter4dvARB = (MYPFNGLPROGRAMENVPARAMETER4DVARBPROC) glProgramEnvParameter4dvARB; staticPointerglProgramEnvParameter4fARB = (MYPFNGLPROGRAMENVPARAMETER4FARBPROC) glProgramEnvParameter4fARB; staticPointerglProgramEnvParameter4fvARB = (MYPFNGLPROGRAMENVPARAMETER4FVARBPROC) glProgramEnvParameter4fvARB; staticPointerglProgramLocalParameter4dARB = (MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC) glProgramLocalParameter4dARB; staticPointerglProgramLocalParameter4dvARB = (MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) glProgramLocalParameter4dvARB; staticPointerglProgramLocalParameter4fARB = (MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC) glProgramLocalParameter4fARB; staticPointerglProgramLocalParameter4fvARB = (MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) glProgramLocalParameter4fvARB; staticPointerglGetProgramEnvParameterdvARB = (MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC) glGetProgramEnvParameterdvARB; staticPointerglGetProgramEnvParameterfvARB = (MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC) glGetProgramEnvParameterfvARB; staticPointerglGetProgramLocalParameterdvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) glGetProgramLocalParameterdvARB; staticPointerglGetProgramLocalParameterfvARB = (MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) glGetProgramLocalParameterfvARB; staticPointerglGetProgramivARB = (MYPFNGLGETPROGRAMIVARBPROC) glGetProgramivARB; staticPointerglGetProgramStringARB = (MYPFNGLGETPROGRAMSTRINGARBPROC) glGetProgramStringARB; staticPointerglGetVertexAttribdvARB = (MYPFNGLGETVERTEXATTRIBDVARBPROC) glGetVertexAttribdvARB; staticPointerglGetVertexAttribfvARB = (MYPFNGLGETVERTEXATTRIBFVARBPROC) glGetVertexAttribfvARB; staticPointerglGetVertexAttribivARB = (MYPFNGLGETVERTEXATTRIBIVARBPROC) glGetVertexAttribivARB; staticPointerglGetVertexAttribPointervARB = (MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC) glGetVertexAttribPointervARB; staticPointerglIsProgramARB = (MYPFNGLISPROGRAMARBPROC) glIsProgramARB; #else staticPointerglVertexAttrib1dARB = 0; staticPointerglVertexAttrib1dvARB = 0; staticPointerglVertexAttrib1fARB = 0; staticPointerglVertexAttrib1fvARB = 0; staticPointerglVertexAttrib1sARB = 0; staticPointerglVertexAttrib1svARB = 0; staticPointerglVertexAttrib2dARB = 0; staticPointerglVertexAttrib2dvARB = 0; staticPointerglVertexAttrib2fARB = 0; staticPointerglVertexAttrib2fvARB = 0; staticPointerglVertexAttrib2sARB = 0; staticPointerglVertexAttrib2svARB = 0; staticPointerglVertexAttrib3dARB = 0; staticPointerglVertexAttrib3dvARB = 0; staticPointerglVertexAttrib3fARB = 0; staticPointerglVertexAttrib3fvARB = 0; staticPointerglVertexAttrib3sARB = 0; staticPointerglVertexAttrib3svARB = 0; staticPointerglVertexAttrib4NbvARB = 0; staticPointerglVertexAttrib4NivARB = 0; staticPointerglVertexAttrib4NsvARB = 0; staticPointerglVertexAttrib4NubARB = 0; staticPointerglVertexAttrib4NubvARB = 0; staticPointerglVertexAttrib4NuivARB = 0; staticPointerglVertexAttrib4NusvARB = 0; staticPointerglVertexAttrib4bvARB = 0; staticPointerglVertexAttrib4dARB = 0; staticPointerglVertexAttrib4dvARB = 0; staticPointerglVertexAttrib4fARB = 0; staticPointerglVertexAttrib4fvARB = 0; staticPointerglVertexAttrib4ivARB = 0; staticPointerglVertexAttrib4sARB = 0; staticPointerglVertexAttrib4svARB = 0; staticPointerglVertexAttrib4ubvARB = 0; staticPointerglVertexAttrib4uivARB = 0; staticPointerglVertexAttrib4usvARB = 0; staticPointerglVertexAttribPointerARB = 0; staticPointerglEnableVertexAttribArrayARB = 0; staticPointerglDisableVertexAttribArrayARB = 0; staticPointerglProgramStringARB = 0; staticPointerglBindProgramARB = 0; staticPointerglDeleteProgramsARB = 0; staticPointerglGenProgramsARB = 0; staticPointerglProgramEnvParameter4dARB = 0; staticPointerglProgramEnvParameter4dvARB = 0; staticPointerglProgramEnvParameter4fARB = 0; staticPointerglProgramEnvParameter4fvARB = 0; staticPointerglProgramLocalParameter4dARB = 0; staticPointerglProgramLocalParameter4dvARB = 0; staticPointerglProgramLocalParameter4fARB = 0; staticPointerglProgramLocalParameter4fvARB = 0; staticPointerglGetProgramEnvParameterdvARB = 0; staticPointerglGetProgramEnvParameterfvARB = 0; staticPointerglGetProgramLocalParameterdvARB = 0; staticPointerglGetProgramLocalParameterfvARB = 0; staticPointerglGetProgramivARB = 0; staticPointerglGetProgramStringARB = 0; staticPointerglGetVertexAttribdvARB = 0; staticPointerglGetVertexAttribfvARB = 0; staticPointerglGetVertexAttribivARB = 0; staticPointerglGetVertexAttribPointervARB = 0; staticPointerglIsProgramARB = 0; #endif // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program } #else void initStaticPointers() { // do nothing } #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/sunos5/0000755000175000017500000000000012146213527024014 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/sunos5/Makefile0000644000175000017500000000173410223377127025462 0ustar debiandebian# Makefile for Sun CFLAGS = -Kpic -mt -fast VPATH = ../ CC = CC LINK = ar INCLUDE = LIBRARY = libVolume.a OBJS = ClipCube.o Extent.o MyExtensions.o PalettedImpl.o \ Plane.o Polygon.o PolygonArray.o Renderer.o RendererBase.o\ RGBABase.o SGIColorTableImpl.o SimpleRGBAImpl.o \ UnshadedBase.o VolumeRenderer.o FragmentProgramImpl.o \ SimpleRGBA2DImpl.o Paletted2DImpl.o HDRS = ClipCube.h ExtensionPointers.h Extent.h LookupTables.h \ MyExtensions.h PalettedImpl.h Plane.h Polygon.h PolygonArray.h \ Renderer.h RendererBase.h RGBABase.h SGIColorTableImpl.h \ SimpleRGBAImpl.h StaticExtensionPointers.h UnshadedBase.h \ VolumeRenderer.h FragmentProgramImpl.h SimpleRGBA2DImpl.h \ Paletted2DImpl.h ######## # Build rules ######## all: library library:$(OBJS) $(LINK) rv $(LIBRARY) $(OBJS) example: cd testdir; make cleanobj: rm *.o cleanlib: cleanobj rm libVolume.a ######## # Implicit rules ######## %.o : %.cpp $(HDRS) $(CC) -c $(CFLAGS) $(INCLUDE) -o $@ $< mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/MyExtensions.h.ori0000644000175000017500000014353410223377127026201 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.h: interface for the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) #define AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN 1 #include #endif #if defined(__APPLE__) # include # define GL_GLEXT_PROTOTYPES # include #else # define GL_GLEXT_PROTOTYPES # include # include # if defined(WIN32) # include # else # define GLX_GLXEXT_PROTOTYPES # include # endif #endif #ifndef APIENTRY #define APIENTRY #endif #ifndef GLAPI #define GLAPI extern #endif #include "ExtensionPointers.h" #ifdef DECLARE_STATIC_POINTERS #include "StaticExtensionPointers.h" #undef DECLARE_STATIC_POINTERS #endif class MyExtensions { public: MyExtensions(); ~MyExtensions(); static bool checkExtensions(const char* requestedExtensions); bool extensionExists(const char* extension, const char* allExtensions); bool initExtensions(const char* requestedExtensions); bool initExtension(const char* extension); // OpenGL version 1.2 MYPFNGLBLENDCOLORPROC glBlendColor; MYPFNGLBLENDEQUATIONPROC glBlendEquation; MYPFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements; MYPFNGLCOLORTABLEPROC glColorTable; MYPFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv; MYPFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv; MYPFNGLCOPYCOLORTABLEPROC glCopyColorTable; MYPFNGLGETCOLORTABLEPROC glGetColorTable; MYPFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv; MYPFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv; MYPFNGLCOLORSUBTABLEPROC glColorSubTable; MYPFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable; MYPFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D; MYPFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D; MYPFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf; MYPFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv; MYPFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri; MYPFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv; MYPFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D; MYPFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D; MYPFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter; MYPFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv; MYPFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv; MYPFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter; MYPFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D; MYPFNGLGETHISTOGRAMPROC glGetHistogram; MYPFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv; MYPFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv; MYPFNGLGETMINMAXPROC glGetMinmax; MYPFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv; MYPFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv; MYPFNGLHISTOGRAMPROC glHistogram; MYPFNGLMINMAXPROC glMinmax; MYPFNGLRESETHISTOGRAMPROC glResetHistogram; MYPFNGLRESETMINMAXPROC glResetMinmax; MYPFNGLTEXIMAGE3DPROC glTexImage3D; MYPFNGLTEXSUBIMAGE3DPROC glTexSubImage3D; MYPFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D; // End OpenGL version 1.2 // OpenGL version 1.3 MYPFNGLACTIVETEXTUREPROC glActiveTexture; MYPFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture; MYPFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d; MYPFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv; MYPFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f; MYPFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv; MYPFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i; MYPFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv; MYPFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s; MYPFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv; MYPFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d; MYPFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv; MYPFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f; MYPFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv; MYPFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i; MYPFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv; MYPFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s; MYPFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv; MYPFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d; MYPFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv; MYPFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f; MYPFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv; MYPFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i; MYPFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv; MYPFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s; MYPFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv; MYPFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d; MYPFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv; MYPFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f; MYPFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv; MYPFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i; MYPFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv; MYPFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s; MYPFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv; MYPFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf; MYPFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd; MYPFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf; MYPFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd; MYPFNGLSAMPLECOVERAGEPROC glSampleCoverage; MYPFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D; MYPFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; MYPFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D; MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; MYPFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage; // End OpenGL version 1.3 // OpenGL version 1.4 MYPFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate; MYPFNGLFOGCOORDFPROC glFogCoordf; MYPFNGLFOGCOORDFVPROC glFogCoordfv; MYPFNGLFOGCOORDDPROC glFogCoordd; MYPFNGLFOGCOORDDVPROC glFogCoorddv; MYPFNGLFOGCOORDPOINTERPROC glFogCoordPointer; MYPFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays; MYPFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements; MYPFNGLPOINTPARAMETERFPROC glPointParameterf; MYPFNGLPOINTPARAMETERFVPROC glPointParameterfv; MYPFNGLPOINTPARAMETERIPROC glPointParameteri; MYPFNGLPOINTPARAMETERIVPROC glPointParameteriv; MYPFNGLSECONDARYCOLOR3BPROC glSecondaryColor3b; MYPFNGLSECONDARYCOLOR3BVPROC glSecondaryColor3bv; MYPFNGLSECONDARYCOLOR3DPROC glSecondaryColor3d; MYPFNGLSECONDARYCOLOR3DVPROC glSecondaryColor3dv; MYPFNGLSECONDARYCOLOR3FPROC glSecondaryColor3f; MYPFNGLSECONDARYCOLOR3FVPROC glSecondaryColor3fv; MYPFNGLSECONDARYCOLOR3IPROC glSecondaryColor3i; MYPFNGLSECONDARYCOLOR3IVPROC glSecondaryColor3iv; MYPFNGLSECONDARYCOLOR3SPROC glSecondaryColor3s; MYPFNGLSECONDARYCOLOR3SVPROC glSecondaryColor3sv; MYPFNGLSECONDARYCOLOR3UBPROC glSecondaryColor3ub; MYPFNGLSECONDARYCOLOR3UBVPROC glSecondaryColor3ubv; MYPFNGLSECONDARYCOLOR3UIPROC glSecondaryColor3ui; MYPFNGLSECONDARYCOLOR3UIVPROC glSecondaryColor3uiv; MYPFNGLSECONDARYCOLOR3USPROC glSecondaryColor3us; MYPFNGLSECONDARYCOLOR3USVPROC glSecondaryColor3usv; MYPFNGLSECONDARYCOLORPOINTERPROC glSecondaryColorPointer; MYPFNGLWINDOWPOS2DPROC glWindowPos2d; MYPFNGLWINDOWPOS2DVPROC glWindowPos2dv; MYPFNGLWINDOWPOS2FPROC glWindowPos2f; MYPFNGLWINDOWPOS2FVPROC glWindowPos2fv; MYPFNGLWINDOWPOS2IPROC glWindowPos2i; MYPFNGLWINDOWPOS2IVPROC glWindowPos2iv; MYPFNGLWINDOWPOS2SPROC glWindowPos2s; MYPFNGLWINDOWPOS2SVPROC glWindowPos2sv; MYPFNGLWINDOWPOS3DPROC glWindowPos3d; MYPFNGLWINDOWPOS3DVPROC glWindowPos3dv; MYPFNGLWINDOWPOS3FPROC glWindowPos3f; MYPFNGLWINDOWPOS3FVPROC glWindowPos3fv; MYPFNGLWINDOWPOS3IPROC glWindowPos3i; MYPFNGLWINDOWPOS3IVPROC glWindowPos3iv; MYPFNGLWINDOWPOS3SPROC glWindowPos3s; MYPFNGLWINDOWPOS3SVPROC glWindowPos3sv; // End OpenGL version 1.4 // GL_EXT_paletted_texture MYPFNGLCOLORTABLEEXTPROC glColorTableEXT; MYPFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; // End GL_EXT_paletted_texture // GL_ARB_multitexture MYPFNGLACTIVETEXTUREARBPROC glActiveTextureARB; MYPFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB; MYPFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB; MYPFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB; MYPFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB; MYPFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB; MYPFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB; MYPFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB; MYPFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB; MYPFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB; MYPFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB; MYPFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB; MYPFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB; MYPFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB; MYPFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB; MYPFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB; MYPFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB; MYPFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB; MYPFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB; MYPFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB; MYPFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB; MYPFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB; MYPFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB; MYPFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB; MYPFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB; MYPFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB; MYPFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB; MYPFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB; MYPFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB; MYPFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB; MYPFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB; MYPFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB; MYPFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB; MYPFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB; // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table MYPFNGLCOLORTABLESGIPROC glColorTableSGI; MYPFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; MYPFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; MYPFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; MYPFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D MYPFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; MYPFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; // End GL_EXT_texture3D // GL_NV_fragment_program MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; // End GL_NV_fragment_program // GL_NV_vertex_program MYPFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; MYPFNGLBINDPROGRAMNVPROC glBindProgramNV; MYPFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; MYPFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; MYPFNGLGENPROGRAMSNVPROC glGenProgramsNV; MYPFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; MYPFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; MYPFNGLGETPROGRAMIVNVPROC glGetProgramivNV; MYPFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; MYPFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; MYPFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; MYPFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; MYPFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; MYPFNGLISPROGRAMNVPROC glIsProgramNV; MYPFNGLLOADPROGRAMNVPROC glLoadProgramNV; MYPFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; MYPFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; MYPFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; MYPFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; MYPFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; MYPFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; MYPFNGLTRACKMATRIXNVPROC glTrackMatrixNV; MYPFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; MYPFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; MYPFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; MYPFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; MYPFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; MYPFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; MYPFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; MYPFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; MYPFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; MYPFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; MYPFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; MYPFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; MYPFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; MYPFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; MYPFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; MYPFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; MYPFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; MYPFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; MYPFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; MYPFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; MYPFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; MYPFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; MYPFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; MYPFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; MYPFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; MYPFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; MYPFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; MYPFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; MYPFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; MYPFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; MYPFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; MYPFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; MYPFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; MYPFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; MYPFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; MYPFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; MYPFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; MYPFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; MYPFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; MYPFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; // End GL_NV_vertex_program // GL_ARB_vertex_program MYPFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; MYPFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; MYPFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; MYPFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; MYPFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; MYPFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; MYPFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; MYPFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; MYPFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; MYPFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; MYPFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; MYPFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; MYPFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; MYPFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; MYPFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; MYPFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; MYPFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; MYPFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; MYPFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; MYPFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; MYPFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; MYPFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; MYPFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; MYPFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; MYPFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; MYPFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; MYPFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; MYPFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; MYPFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; MYPFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; MYPFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; MYPFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; MYPFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; MYPFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; MYPFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; MYPFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; MYPFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; MYPFNGLPROGRAMSTRINGARBPROC glProgramStringARB; MYPFNGLBINDPROGRAMARBPROC glBindProgramARB; MYPFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; MYPFNGLGENPROGRAMSARBPROC glGenProgramsARB; MYPFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; MYPFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; MYPFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; MYPFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; MYPFNGLGETPROGRAMIVARBPROC glGetProgramivARB; MYPFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; MYPFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; MYPFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; MYPFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; MYPFNGLISPROGRAMARBPROC glIsProgramARB; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program #if defined(WIN32) /// WGL extensions follows // WGL_ARB_pixel_format MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB; MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC wglGetPixelFormatAttribfvARB; MYPFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer MYPFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB; MYPFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB; MYPFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB; MYPFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB; MYPFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB; // End WGL_ARB_pbuffer // WGL_ARB_render_texture MYPFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB; MYPFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB; MYPFNWGLSETPBUFFERATTRIBARBPROC wglSetPbufferAttribARB; // End WGL_ARB_render_texture // WGL_ARB_extensions_string MYPFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB; // End WGL_ARB_extensions_string #endif // defined(WIN32) protected: void initPointersToZero(); static const char* EatWhiteSpace(const char* str); static const char* EatNonWhiteSpace(const char* str); static const char* getExtensionStringPrivate(); static const char* getSystemExtensions(); }; // declare the extensions that we support and prepare the constants #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_RESCALE_NORMAL 0x803A #define GL_TEXTURE_BINDING_3D 0x806A #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_TEXTURE_3D 0x806F #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_CLAMP_TO_EDGE 0x812F #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_SINGLE_COLOR 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E #endif #ifndef GL_VERSION_1_3 #define GL_VERSION_1_3 1 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_MULTISAMPLE 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLES 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_MULTISAMPLE_BIT 0x20000000 #define GL_NORMAL_MAP 0x8511 #define GL_REFLECTION_MAP 0x8512 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_CLAMP_TO_BORDER 0x812D #define GL_CLAMP_TO_BORDER_SGIS 0x812D #define GL_COMBINE 0x8570 #define GL_COMBINE_RGB 0x8571 #define GL_COMBINE_ALPHA 0x8572 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_RGB 0x8582 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE2_ALPHA 0x858A #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_RGB 0x8592 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND2_ALPHA 0x859A #define GL_RGB_SCALE 0x8573 #define GL_ADD_SIGNED 0x8574 #define GL_INTERPOLATE 0x8575 #define GL_SUBTRACT 0x84E7 #define GL_CONSTANT 0x8576 #define GL_PRIMARY_COLOR 0x8577 #define GL_PREVIOUS 0x8578 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #endif #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_MIRRORED_REPEAT 0x8370 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORDINATE 0x8451 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_COLOR_SUM 0x8458 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_INCR_WRAP 0x8507 #define GL_DECR_WRAP 0x8508 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_R_TO_TEXTURE 0x884E #endif #ifndef GL_ARB_imaging #define GL_CONSTANT_COLOR 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_CONSTANT_ALPHA 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_BLEND_COLOR 0x8005 #define GL_FUNC_ADD 0x8006 #define GL_MIN 0x8007 #define GL_MAX 0x8008 #define GL_BLEND_EQUATION 0x8009 #define GL_FUNC_SUBTRACT 0x800A #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_CONVOLUTION_1D 0x8010 #define GL_CONVOLUTION_2D 0x8011 #define GL_SEPARABLE_2D 0x8012 #define GL_CONVOLUTION_BORDER_MODE 0x8013 #define GL_CONVOLUTION_FILTER_SCALE 0x8014 #define GL_CONVOLUTION_FILTER_BIAS 0x8015 #define GL_REDUCE 0x8016 #define GL_CONVOLUTION_FORMAT 0x8017 #define GL_CONVOLUTION_WIDTH 0x8018 #define GL_CONVOLUTION_HEIGHT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH 0x801A #define GL_MAX_CONVOLUTION_HEIGHT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F #define GL_POST_CONVOLUTION_RED_BIAS 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 #define GL_HISTOGRAM 0x8024 #define GL_PROXY_HISTOGRAM 0x8025 #define GL_HISTOGRAM_WIDTH 0x8026 #define GL_HISTOGRAM_FORMAT 0x8027 #define GL_HISTOGRAM_RED_SIZE 0x8028 #define GL_HISTOGRAM_GREEN_SIZE 0x8029 #define GL_HISTOGRAM_BLUE_SIZE 0x802A #define GL_HISTOGRAM_ALPHA_SIZE 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C #define GL_HISTOGRAM_SINK 0x802D #define GL_MINMAX 0x802E #define GL_MINMAX_FORMAT 0x802F #define GL_MINMAX_SINK 0x8030 #define GL_TABLE_TOO_LARGE 0x8031 #define GL_COLOR_MATRIX 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB #define GL_COLOR_TABLE 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 #define GL_PROXY_COLOR_TABLE 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 #define GL_COLOR_TABLE_SCALE 0x80D6 #define GL_COLOR_TABLE_BIAS 0x80D7 #define GL_COLOR_TABLE_FORMAT 0x80D8 #define GL_COLOR_TABLE_WIDTH 0x80D9 #define GL_COLOR_TABLE_RED_SIZE 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF #define GL_CONSTANT_BORDER 0x8151 #define GL_REPLICATE_BORDER 0x8153 #define GL_CONVOLUTION_BORDER_COLOR 0x8154 #endif #ifndef GL_EXT_paletted_texture #define GL_EXT_paletted_texture 1 #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED #endif #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 #define GL_TEXTURE2_ARB 0x84C2 #define GL_TEXTURE3_ARB 0x84C3 #define GL_TEXTURE4_ARB 0x84C4 #define GL_TEXTURE5_ARB 0x84C5 #define GL_TEXTURE6_ARB 0x84C6 #define GL_TEXTURE7_ARB 0x84C7 #define GL_TEXTURE8_ARB 0x84C8 #define GL_TEXTURE9_ARB 0x84C9 #define GL_TEXTURE10_ARB 0x84CA #define GL_TEXTURE11_ARB 0x84CB #define GL_TEXTURE12_ARB 0x84CC #define GL_TEXTURE13_ARB 0x84CD #define GL_TEXTURE14_ARB 0x84CE #define GL_TEXTURE15_ARB 0x84CF #define GL_TEXTURE16_ARB 0x84D0 #define GL_TEXTURE17_ARB 0x84D1 #define GL_TEXTURE18_ARB 0x84D2 #define GL_TEXTURE19_ARB 0x84D3 #define GL_TEXTURE20_ARB 0x84D4 #define GL_TEXTURE21_ARB 0x84D5 #define GL_TEXTURE22_ARB 0x84D6 #define GL_TEXTURE23_ARB 0x84D7 #define GL_TEXTURE24_ARB 0x84D8 #define GL_TEXTURE25_ARB 0x84D9 #define GL_TEXTURE26_ARB 0x84DA #define GL_TEXTURE27_ARB 0x84DB #define GL_TEXTURE28_ARB 0x84DC #define GL_TEXTURE29_ARB 0x84DD #define GL_TEXTURE30_ARB 0x84DE #define GL_TEXTURE31_ARB 0x84DF #define GL_ACTIVE_TEXTURE_ARB 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 #endif #ifndef GL_SGI_texture_color_table #define GL_SGI_texture_color_table 1 #define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC #define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD #endif #ifndef GL_SGI_color_table #define GL_SGI_color_table 1 #define GL_COLOR_TABLE_SGI 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 #define GL_PROXY_COLOR_TABLE_SGI 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 #define GL_COLOR_TABLE_SCALE_SGI 0x80D6 #define GL_COLOR_TABLE_BIAS_SGI 0x80D7 #define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 #define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF #endif #ifndef GL_SGIS_texture_edge_clamp #define GL_SGIS_texture_edge_clamp 1 #define GL_CLAMP_TO_EDGE_SGIS 0x812F #endif #ifndef GL_EXT_texture3D #define GL_EXT_texture3D 1 #define GL_PACK_SKIP_IMAGES_EXT 0x806B #define GL_PACK_IMAGE_HEIGHT_EXT 0x806C #define GL_UNPACK_SKIP_IMAGES_EXT 0x806D #define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E #define GL_TEXTURE_3D_EXT 0x806F #define GL_PROXY_TEXTURE_3D_EXT 0x8070 #define GL_TEXTURE_DEPTH_EXT 0x8071 #define GL_TEXTURE_WRAP_R_EXT 0x8072 #define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 #endif #ifndef GL_NV_fragment_program #define GL_NV_fragment_program 1 #define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 #define GL_FRAGMENT_PROGRAM_NV 0x8870 #define GL_MAX_TEXTURE_COORDS_NV 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 #define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 #define GL_PROGRAM_ERROR_STRING_NV 0x8874 #endif #ifndef GL_NV_vertex_program #define GL_NV_vertex_program 1 #define GL_VERTEX_PROGRAM_NV 0x8620 #define GL_VERTEX_STATE_PROGRAM_NV 0x8621 #define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 #define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 #define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 #define GL_CURRENT_ATTRIB_NV 0x8626 #define GL_PROGRAM_LENGTH_NV 0x8627 #define GL_PROGRAM_STRING_NV 0x8628 #define GL_MODELVIEW_PROJECTION_NV 0x8629 #define GL_IDENTITY_NV 0x862A #define GL_INVERSE_NV 0x862B #define GL_TRANSPOSE_NV 0x862C #define GL_INVERSE_TRANSPOSE_NV 0x862D #define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E #define GL_MAX_TRACK_MATRICES_NV 0x862F #define GL_MATRIX0_NV 0x8630 #define GL_MATRIX1_NV 0x8631 #define GL_MATRIX2_NV 0x8632 #define GL_MATRIX3_NV 0x8633 #define GL_MATRIX4_NV 0x8634 #define GL_MATRIX5_NV 0x8635 #define GL_MATRIX6_NV 0x8636 #define GL_MATRIX7_NV 0x8637 #define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 #define GL_CURRENT_MATRIX_NV 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 #define GL_PROGRAM_PARAMETER_NV 0x8644 #define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 #define GL_PROGRAM_TARGET_NV 0x8646 #define GL_PROGRAM_RESIDENT_NV 0x8647 #define GL_TRACK_MATRIX_NV 0x8648 #define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 #define GL_VERTEX_PROGRAM_BINDING_NV 0x864A #define GL_PROGRAM_ERROR_POSITION_NV 0x864B #define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 #define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 #define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 #define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 #define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 #define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 #define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 #define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 #define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 #define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 #define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A #define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B #define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C #define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D #define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E #define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F #define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 #define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 #define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 #define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 #define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 #define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 #define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 #define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 #define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 #define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 #define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A #define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B #define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C #define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D #define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E #define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F #define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 #define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 #define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 #define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 #define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 #define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 #define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 #define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 #define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 #define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 #define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A #define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B #define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C #define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D #define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E #define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F #endif #ifndef GL_ARB_vertex_program #define GL_ARB_vertex_program 1 #define GL_COLOR_SUM_ARB 0x8458 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF #endif #ifndef GL_ARB_fragment_program #define GL_ARB_fragment_program 1 #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #endif /// WGL extensions follow #if defined(WIN32) #ifndef WGL_ARB_pixel_format #define WGL_ARB_pixel_format 1 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 #define WGL_DRAW_TO_WINDOW_ARB 0x2001 #define WGL_DRAW_TO_BITMAP_ARB 0x2002 #define WGL_ACCELERATION_ARB 0x2003 #define WGL_NEED_PALETTE_ARB 0x2004 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 #define WGL_SWAP_METHOD_ARB 0x2007 #define WGL_NUMBER_OVERLAYS_ARB 0x2008 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009 #define WGL_TRANSPARENT_ARB 0x200A #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B #define WGL_SHARE_DEPTH_ARB 0x200C #define WGL_SHARE_STENCIL_ARB 0x200D #define WGL_SHARE_ACCUM_ARB 0x200E #define WGL_SUPPORT_GDI_ARB 0x200F #define WGL_SUPPORT_OPENGL_ARB 0x2010 #define WGL_DOUBLE_BUFFER_ARB 0x2011 #define WGL_STEREO_ARB 0x2012 #define WGL_PIXEL_TYPE_ARB 0x2013 #define WGL_COLOR_BITS_ARB 0x2014 #define WGL_RED_BITS_ARB 0x2015 #define WGL_RED_SHIFT_ARB 0x2016 #define WGL_GREEN_BITS_ARB 0x2017 #define WGL_GREEN_SHIFT_ARB 0x2018 #define WGL_BLUE_BITS_ARB 0x2019 #define WGL_BLUE_SHIFT_ARB 0x201A #define WGL_ALPHA_BITS_ARB 0x201B #define WGL_ALPHA_SHIFT_ARB 0x201C #define WGL_ACCUM_BITS_ARB 0x201D #define WGL_ACCUM_RED_BITS_ARB 0x201E #define WGL_ACCUM_GREEN_BITS_ARB 0x201F #define WGL_ACCUM_BLUE_BITS_ARB 0x2020 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 #define WGL_DEPTH_BITS_ARB 0x2022 #define WGL_STENCIL_BITS_ARB 0x2023 #define WGL_AUX_BUFFERS_ARB 0x2024 #define WGL_NO_ACCELERATION_ARB 0x2025 #define WGL_GENERIC_ACCELERATION_ARB 0x2026 #define WGL_FULL_ACCELERATION_ARB 0x2027 #define WGL_SWAP_EXCHANGE_ARB 0x2028 #define WGL_SWAP_COPY_ARB 0x2029 #define WGL_SWAP_UNDEFINED_ARB 0x202A #define WGL_TYPE_RGBA_ARB 0x202B #define WGL_TYPE_COLORINDEX_ARB 0x202C #endif #ifndef WGL_ARB_pbuffer #define WGL_ARB_pbuffer 1 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 #define WGL_PBUFFER_LARGEST_ARB 0x2033 #define WGL_PBUFFER_WIDTH_ARB 0x2034 #define WGL_PBUFFER_HEIGHT_ARB 0x2035 #define WGL_PBUFFER_LOST_ARB 0x2036 #endif #ifndef WGL_ARB_render_texture #define WGL_ARB_render_texture 1 #define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 #define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 #define WGL_TEXTURE_FORMAT_ARB 0x2072 #define WGL_TEXTURE_TARGET_ARB 0x2073 #define WGL_MIPMAP_TEXTURE_ARB 0x2074 #define WGL_TEXTURE_RGB_ARB 0x2075 #define WGL_TEXTURE_RGBA_ARB 0x2076 #define WGL_NO_TEXTURE_ARB 0x2077 #define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 #define WGL_TEXTURE_1D_ARB 0x2079 #define WGL_TEXTURE_2D_ARB 0x207A #define WGL_MIPMAP_LEVEL_ARB 0x207B #define WGL_CUBE_MAP_FACE_ARB 0x207C #define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 #define WGL_FRONT_LEFT_ARB 0x2083 #define WGL_FRONT_RIGHT_ARB 0x2084 #define WGL_BACK_LEFT_ARB 0x2085 #define WGL_BACK_RIGHT_ARB 0x2086 #define WGL_AUX0_ARB 0x2087 #define WGL_AUX1_ARB 0x2088 #define WGL_AUX2_ARB 0x2089 #define WGL_AUX3_ARB 0x208A #define WGL_AUX4_ARB 0x208B #define WGL_AUX5_ARB 0x208C #define WGL_AUX6_ARB 0x208D #define WGL_AUX7_ARB 0x208E #define WGL_AUX8_ARB 0x208F #define WGL_AUX9_ARB 0x2090 #endif #ifndef WGL_ARB_extensions_string #define WGL_ARB_extensions_string 1 #endif #endif // defined(WIN32) #endif // !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SGIColorTableImpl.cpp0000644000175000017500000001571710223377127026513 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // SGIColorTableImpl.cpp: implementation of the SGIColorTableImpl class. // ////////////////////////////////////////////////////////////////////// #include "SGIColorTableImpl.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// SGIColorTableImpl::SGIColorTableImpl() { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; } SGIColorTableImpl::~SGIColorTableImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool SGIColorTableImpl::initRenderer() { if (!UnshadedBase::initRenderer() || !initExtensions() || !initTextureNames()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool SGIColorTableImpl::checkCompatibility() const { MyExtensions tempExtensions; if (!tempExtensions.initExtensions("GL_VERSION_1_2 ") && !tempExtensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return tempExtensions.initExtensions( "GL_EXT_texture3D " "GL_SGI_texture_color_table " "GL_SGI_color_table " ); } // Uploads colormapped data bool SGIColorTableImpl::uploadColormappedData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); if (width!=m_Width || height!=m_Height || depth!=m_Depth) { m_Extensions.glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_INTENSITY8, width, height, depth, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); } else { m_Extensions.glTexSubImage3DEXT(GL_TEXTURE_3D_EXT, 0, 0,0,0, width, height, depth, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); } glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // save the width height and depth m_Width = width; m_HintDimX = width; m_Height = height; m_HintDimY = height; m_Depth = depth; m_HintDimZ = depth; // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Tests to see if the given parameters would return an error bool SGIColorTableImpl::testColormappedData(int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // nothing above 512 if (width>512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; m_Extensions.glTexImage3DEXT(GL_PROXY_TEXTURE_3D_EXT, 0, GL_INTENSITY, width, height, depth, 0, GL_INTENSITY, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Uploads the transfer function for the colormapped data bool SGIColorTableImpl::uploadColorMap(const GLubyte* colorMap) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); m_Extensions.glColorTableSGI(GL_TEXTURE_COLOR_TABLE_SGI, GL_RGBA8, 256, GL_RGBA, GL_UNSIGNED_BYTE, colorMap); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Performs the actual rendering. bool SGIColorTableImpl::renderVolume() { // bail if we haven't been initialized properly if (!m_Initialized) return false; // set up the state glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColor4f(1.0, 1.0, 1.0, 1.0); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glEnable(GL_TEXTURE_COLOR_TABLE_SGI); //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDepthMask( GL_FALSE ); glEnable(GL_TEXTURE_3D_EXT); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); computePolygons(); convertToTriangles(); renderTriangles(); // restore the state glPopAttrib(); return true; } // Initializes the necessary extensions. bool SGIColorTableImpl::initExtensions() { if (!m_Extensions.initExtensions("GL_VERSION_1_2 ") && !m_Extensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return m_Extensions.initExtensions( "GL_EXT_texture3D " "GL_SGI_texture_color_table " "GL_SGI_color_table " ); } // Gets the opengl texture IDs bool SGIColorTableImpl::initTextureNames() { // clear previous errors GLenum error = glGetError(); // get the names glGenTextures(1, &m_DataTextureName); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Render the actual triangles void SGIColorTableImpl::renderTriangles() { // set up the client render state glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); //glEnableClientState(GL_COLOR_ARRAY); glTexCoordPointer(3, GL_FLOAT, 0, m_TextureArray); glVertexPointer(3, GL_FLOAT, 0, m_VertexArray); //glColorPointer(3, GL_FLOAT, 0, m_TextureArray); // render the triangles glDrawElements(GL_TRIANGLES, m_NumTriangles*3, GL_UNSIGNED_INT, m_TriangleArray); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); //glDisableClientState(GL_COLOR_ARRAY); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/ClipCube.cpp0000644000175000017500000001231210223377127024752 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // ClipCube.cpp: implementation of the ClipCube class. // ////////////////////////////////////////////////////////////////////// #include "ClipCube.h" #include ////////////////////////////////////////////////////////////////////// // Lookup tables ////////////////////////////////////////////////////////////////////// #include "LookupTables.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// ClipCube::ClipCube() { setAspectRatio(1.0, 1.0, 1.0); setTextureSubCube(0,0,0,1,1,1); } ClipCube::ClipCube(double ratioX, double ratioY, double ratioZ, double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { setAspectRatio(ratioX, ratioY, ratioZ); setTextureSubCube(minX, minY, minZ, maxX, maxY, maxZ); } ClipCube::~ClipCube() { // do nothing in the destructor } bool ClipCube::setAspectRatio(double ratioX, double ratioY, double ratioZ) { // sets the aspect ratio of the volume render double maxratio; if (ratioX!=0.0 && ratioY!=0.0 && ratioZ!=0.0) { m_RatioX = ratioX; m_RatioY = ratioY; m_RatioZ = ratioZ; // find the maximum ratio maxratio = ( m_RatioX > m_RatioY ? m_RatioX : m_RatioY ); maxratio = ( maxratio > m_RatioZ ? maxratio : m_RatioZ ); // normalize so the max ratio is 1.0 m_RatioX /= maxratio; m_RatioY /= maxratio; m_RatioZ /= maxratio; return true; } else { return false; } } bool ClipCube::setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { for (int i=0; i<8; i++) { m_TexCoords[i*3+0] = (TexCoords[i*3+0]<0.5?minX:maxX); m_TexCoords[i*3+1] = (TexCoords[i*3+1]<0.5?minY:maxY); m_TexCoords[i*3+2] = (TexCoords[i*3+2]<0.5?minZ:maxZ); } return true; } bool ClipCube::clipPlane(Polygon& result, const Plane& plane) const { double distances[8]; unsigned caseIndex; unsigned int numIntersections; // calculate the lookup table index and fill the signed distance table caseIndex = getCaseAndCalculateSignedDistances(distances, plane); // determine the number of intersections and initialize the result polygon numIntersections = EdgeCases[caseIndex][0]; if (numIntersections==0) return false; result.setNumVerts(numIntersections); unsigned int c; double alpha; // for each intersection for (c=0; c 0.0) { index |= 1< Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // PolygonArray.h: interface for the PolygonArray class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_POLYGONARRAY_H__9F01EA71_FDFE_47B4_A507_826834CEF66A__INCLUDED_) #define AFX_POLYGONARRAY_H__9F01EA71_FDFE_47B4_A507_826834CEF66A__INCLUDED_ namespace OpenGLVolumeRendering { class Polygon; /** Encapsulates an array of polygons */ class PolygonArray { public: PolygonArray(unsigned int sizeGuess); virtual ~PolygonArray(); void clearPolygons(); void addPolygon(const Polygon& polygon); Polygon* getPolygon(unsigned int i); unsigned int getNumPolygons(); protected: void doubleArray(); void allocateArray(unsigned int sizeGuess); Polygon* m_PolygonArray; unsigned int m_ArraySize; unsigned int m_NumPolygons; }; }; #endif // !defined(AFX_POLYGONARRAY_H__9F01EA71_FDFE_47B4_A507_826834CEF66A__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/darwin/0000755000175000017500000000000012146213527024044 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/darwin/Makefile0000644000175000017500000000220110223377127025500 0ustar debiandebian# VolumeLibrary Makefile for linux CFLAGS = -Wall -O3 VPATH = ../ CC = g++ LINK = libtool INCLUDE = -I../ -I/System/Library/Frameworks/OpenGL.framework/Headers/ LIBRARY = libVolume.a OBJS = ClipCube.o Extent.o MyExtensions.o PalettedImpl.o \ Plane.o Polygon.o PolygonArray.o Renderer.o RendererBase.o\ RGBABase.o SGIColorTableImpl.o SimpleRGBAImpl.o \ UnshadedBase.o VolumeRenderer.o FragmentProgramImpl.o \ SimpleRGBA2DImpl.o Paletted2DImpl.o VolumeRendererFactory.o \ FragmentProgramARBImpl.o HDRS = ClipCube.h ExtensionPointers.h Extent.h LookupTables.h \ MyExtensions.h PalettedImpl.h Plane.h Polygon.h PolygonArray.h \ Renderer.h RendererBase.h RGBABase.h SGIColorTableImpl.h \ SimpleRGBAImpl.h StaticExtensionPointers.h UnshadedBase.h \ VolumeRenderer.h FragmentProgramImpl.h SimpleRGBA2DImpl.h \ Paletted2DImpl.h FragmentProgramARBImpl.h VolumeRendererFactory.h # Build rules all: library library : $(OBJS) ($(LINK) -static -o $(LIBRARY) $(OBJS)) example: cd testdir; make cleanobj: rm *.o clean: cleanobj rm libVolume.a # Implicit rules %.o : %.cpp $(HDRS) $(CC) -c $(CFLAGS) $(INCLUDE) -D__APPLE__ -o $@ $< mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeLibrary.dep0000644000175000017500000000161710223377127026054 0ustar debiandebian# Microsoft Developer Studio Generated Dependency File, included by VolumeLibrary.mak .\OpenGLVolumeClipCube.cpp : \ ".\LookupTables.h"\ ".\OpenGLVolumeClipCube.h"\ ".\OpenGLVolumePlane.h"\ ".\OpenGLVolumePolygon.h"\ .\OpenGLVolumePlane.cpp : \ ".\OpenGLVolumePlane.h"\ .\OpenGLVolumePolygon.cpp : \ ".\OpenGLVolumePolygon.h"\ .\OpenGLVolumeRenderer.cpp : \ ".\glh_extensions.h"\ ".\glh_genext.h"\ ".\OpenGLVolumeClipCube.h"\ ".\OpenGLVolumePlane.h"\ ".\OpenGLVolumePolygon.h"\ ".\OpenGLVolumeRenderer.h"\ "c:\program files\microsoft visual studio\vc98\include\basetsd.h"\ "c:\program files\microsoft visual studio\vc98\include\gl\glext.h"\ "c:\program files\microsoft visual studio\vc98\include\gl\wglext.h"\ .\VolumeRenderer.cpp : \ ".\OpenGLVolumePlane.h"\ ".\OpenGLVolumeRenderer.h"\ ".\VolumeRenderer.h"\ "c:\program files\microsoft visual studio\vc98\include\basetsd.h"\ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SimpleExample.h0000644000175000017500000000115010223377127025474 0ustar debiandebian#ifndef SIMPLEEXAMPLE_H #define SIMPLEEXAMPLE_H #define ROTATE 1 #define TRANSLATE 2 int BeginGraphics (int* argc, char** argv, const char* name); void RegisterCallbacks(); void init(); void InitProjection(); void InitModelMatrix(); void InitLighting(); void InitState(); void InitVolumeRenderer(); void InitData(); void Display(); void Idle(); void MouseButton(int button, int mstate, int x, int y); void MouseMove(int x, int y); void Keyboard(unsigned char key, int x, int y); void Rotate(int dx, int dy); void Translate(int dx, int dy, int dz); #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/PalettedImpl.h0000644000175000017500000000557010223377127025325 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // PalettedImpl.h: interface for the PalettedImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_PALETTEDIMPL_H__0A257040_7C0E_44A2_BF71_58D906390F88__INCLUDED_) #define AFX_PALETTEDIMPL_H__0A257040_7C0E_44A2_BF71_58D906390F88__INCLUDED_ #include "UnshadedBase.h" #include "MyExtensions.h" namespace OpenGLVolumeRendering { /// A volume renderer which uses the paletted textures extension to do color /// mapping. Requires support for 3D textures class PalettedImpl : public UnshadedBase { public: PalettedImpl(); virtual ~PalettedImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadColormappedData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testColormappedData(int width, int height, int depth); // Uploads the transfer function for the colormapped data virtual bool uploadColorMap(const GLubyte* colorMap); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; // The opengl texture ID GLuint m_DataTextureName; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(); // Render the actual triangles void renderTriangles(); }; }; #endif // !defined(AFX_PALETTEDIMPL_H__0A257040_7C0E_44A2_BF71_58D906390F88__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/UnshadedBase.cpp0000644000175000017500000000312610223377127025615 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // UnshadedBase.cpp: implementation of the UnshadedBase class. // ////////////////////////////////////////////////////////////////////// #include "UnshadedBase.h" #include "Polygon.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// UnshadedBase::UnshadedBase() { } UnshadedBase::~UnshadedBase() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool UnshadedBase::initRenderer() { return RendererBase::initRenderer(); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/MyExtensions.cpp.cvs0000644000175000017500000012231010223377127026523 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.cpp: implementation of the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #define DECLARE_STATIC_POINTERS #include "MyExtensions.h" #include #define STATIC_POINTER_PREFIX staticPointer #define CREATESTATICNAME2(a,b) a##b #define CREATESTATICNAME(a,b) CREATESTATICNAME2(a,b) // define a macro for getting the address of a function #if defined(_WIN32) // use the windows technique #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) wglGetProcAddress(#procName) ; if (procName==0) return false #elif defined(GLX_ARB_get_proc_address) // use glXGetProcAddress #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) glXGetProcAddressARB( (const GLubyte *) #procName) ; if (procName==0) return false #else // try to get the static location of the function #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) CREATESTATICNAME(STATIC_POINTER_PREFIX,procName) ; if (procName==0) return false #endif // define a macro for getting addresses of wgl functions #if defined(_WIN32) #define INIT_WGL_PROC_POINTER(pointerType,procName) procName = (pointerType) wglGetProcAddress(#procName) ; if (procName==0) return false #else // wgl functions are only supported in windows #define INIT_WGL_PROC_POINTER(pointerType,procName) procName = 0 ; return false #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// MyExtensions::MyExtensions() { initPointersToZero(); initStaticPointers(); } MyExtensions::~MyExtensions() { } bool MyExtensions::extensionExists(const char* extension, const char* allExtensions) { int extLen = strlen(extension); char* padExtName = new char[extLen + 2]; strcpy(padExtName, extension); padExtName[extLen] = ' '; padExtName[extLen+1] = 0; if (0 == strcmp(extension, "GL_VERSION_1_2")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_3")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_4")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version || strstr(version, "1.3") == version) { return false; } else { return true; } } if (strstr(allExtensions, padExtName)) { delete [] padExtName; return true; } else { delete [] padExtName; return false; } } bool MyExtensions::checkExtensions(const char* requestedExtensions) { MyExtensions myExtensions; return myExtensions.initExtensions(requestedExtensions); } bool MyExtensions::initExtensions(const char* requestedExtensions) { if (!requestedExtensions) { return false; } // get the extensions string and pad it const char *extensions = getExtensionStringPrivate(); int normalExtsLen = strlen(extensions); const char* systemExtensions = getSystemExtensions(); int systemExtsLen; char* paddedExtensions; if (systemExtensions) { systemExtsLen = strlen(systemExtensions); paddedExtensions = new char[normalExtsLen + 1 + systemExtsLen + 2]; strcpy(paddedExtensions, extensions); paddedExtensions[normalExtsLen] = ' '; strcpy(paddedExtensions+normalExtsLen+1, systemExtensions); paddedExtensions[normalExtsLen + 1 + systemExtsLen] = ' '; paddedExtensions[normalExtsLen + 1 + systemExtsLen+1] = 0; } else { systemExtsLen = 0; paddedExtensions = new char[normalExtsLen+2]; strcpy(paddedExtensions, extensions); paddedExtensions[normalExtsLen] = ' '; paddedExtensions[normalExtsLen+1] = 0; } // duplicate the requested string int reqExtsLen = strlen(requestedExtensions); char* reqExts = new char[reqExtsLen+1]; strcpy(reqExts, requestedExtensions); char* currentExt; bool success = true; // Parse requested extension list for (currentExt = reqExts; (currentExt = (char*)EatWhiteSpace(currentExt)) && *currentExt; currentExt = (char*)EatNonWhiteSpace(currentExt)) { char *extEnd = (char*)EatNonWhiteSpace(currentExt); char saveChar = *extEnd; *extEnd = (char)0; if (!extensionExists(currentExt, paddedExtensions) || !initExtension(currentExt)) { // failed success = false; } *extEnd = saveChar; } delete [] paddedExtensions; delete [] reqExts; return success; } bool MyExtensions::initExtension(const char* extension) { if (0 == extension) { return false; } #ifdef GL_VERSION_1_2 else if (0 == strcmp(extension, "GL_VERSION_1_2")) { INIT_PROC_POINTER(MYPFNGLBLENDCOLORPROC, glBlendColor); INIT_PROC_POINTER(MYPFNGLBLENDEQUATIONPROC, glBlendEquation); INIT_PROC_POINTER(MYPFNGLDRAWRANGEELEMENTSPROC, glDrawRangeElements); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPROC, glColorTable); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERFVPROC, glColorTableParameterfv); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERIVPROC, glColorTableParameteriv); INIT_PROC_POINTER(MYPFNGLCOPYCOLORTABLEPROC, glCopyColorTable); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPROC, glGetColorTable); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVPROC, glGetColorTableParameterfv); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVPROC, glGetColorTableParameteriv); INIT_PROC_POINTER(MYPFNGLCOLORSUBTABLEPROC, glColorSubTable); INIT_PROC_POINTER(MYPFNGLCOPYCOLORSUBTABLEPROC, glCopyColorSubTable); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONFILTER1DPROC, glConvolutionFilter1D); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONFILTER2DPROC, glConvolutionFilter2D); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERFPROC, glConvolutionParameterf); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERFVPROC, glConvolutionParameterfv); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERIPROC, glConvolutionParameteri); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERIVPROC, glConvolutionParameteriv); INIT_PROC_POINTER(MYPFNGLCOPYCONVOLUTIONFILTER1DPROC, glCopyConvolutionFilter1D); INIT_PROC_POINTER(MYPFNGLCOPYCONVOLUTIONFILTER2DPROC, glCopyConvolutionFilter2D); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONFILTERPROC, glGetConvolutionFilter); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONPARAMETERFVPROC, glGetConvolutionParameterfv); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONPARAMETERIVPROC, glGetConvolutionParameteriv); INIT_PROC_POINTER(MYPFNGLGETSEPARABLEFILTERPROC, glGetSeparableFilter); INIT_PROC_POINTER(MYPFNGLSEPARABLEFILTER2DPROC, glSeparableFilter2D); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPROC, glGetHistogram); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPARAMETERFVPROC, glGetHistogramParameterfv); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPARAMETERIVPROC, glGetHistogramParameteriv); INIT_PROC_POINTER(MYPFNGLGETMINMAXPROC, glGetMinmax); INIT_PROC_POINTER(MYPFNGLGETMINMAXPARAMETERFVPROC, glGetMinmaxParameterfv); INIT_PROC_POINTER(MYPFNGLGETMINMAXPARAMETERIVPROC, glGetMinmaxParameteriv); INIT_PROC_POINTER(MYPFNGLHISTOGRAMPROC, glHistogram); INIT_PROC_POINTER(MYPFNGLMINMAXPROC, glMinmax); INIT_PROC_POINTER(MYPFNGLRESETHISTOGRAMPROC, glResetHistogram); INIT_PROC_POINTER(MYPFNGLRESETMINMAXPROC, glResetMinmax); INIT_PROC_POINTER(MYPFNGLTEXIMAGE3DPROC, glTexImage3D); INIT_PROC_POINTER(MYPFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D); INIT_PROC_POINTER(MYPFNGLCOPYTEXSUBIMAGE3DPROC, glCopyTexSubImage3D); return true; } #endif // GL_VERSION_1_2 #ifdef GL_VERSION_1_3 else if (0 == strcmp(extension, "GL_VERSION_1_3")) { INIT_PROC_POINTER(MYPFNGLACTIVETEXTUREPROC, glActiveTexture); INIT_PROC_POINTER(MYPFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv); INIT_PROC_POINTER(MYPFNGLLOADTRANSPOSEMATRIXFPROC, glLoadTransposeMatrixf); INIT_PROC_POINTER(MYPFNGLLOADTRANSPOSEMATRIXDPROC, glLoadTransposeMatrixd); INIT_PROC_POINTER(MYPFNGLMULTTRANSPOSEMATRIXFPROC, glMultTransposeMatrixf); INIT_PROC_POINTER(MYPFNGLMULTTRANSPOSEMATRIXDPROC, glMultTransposeMatrixd); INIT_PROC_POINTER(MYPFNGLSAMPLECOVERAGEPROC, glSampleCoverage); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE3DPROC, glCompressedTexImage3D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE2DPROC, glCompressedTexImage2D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE1DPROC, glCompressedTexImage1D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D); INIT_PROC_POINTER(MYPFNGLGETCOMPRESSEDTEXIMAGEPROC, glGetCompressedTexImage); return initExtension("GL_VERSION_1_2"); } #endif // GL_VERSION_1_3 #ifdef GL_VERSION_1_4 else if (0 == strcmp(extension, "GL_VERSION_1_4")) { INIT_PROC_POINTER(MYPFNGLBLENDFUNCSEPARATEPROC, glBlendFuncSeparate); INIT_PROC_POINTER(MYPFNGLFOGCOORDFPROC, glFogCoordf); INIT_PROC_POINTER(MYPFNGLFOGCOORDFVPROC, glFogCoordfv); INIT_PROC_POINTER(MYPFNGLFOGCOORDDPROC, glFogCoordd); INIT_PROC_POINTER(MYPFNGLFOGCOORDDVPROC, glFogCoorddv); INIT_PROC_POINTER(MYPFNGLFOGCOORDPOINTERPROC, glFogCoordPointer); INIT_PROC_POINTER(MYPFNGLMULTIDRAWARRAYSPROC, glMultiDrawArrays); INIT_PROC_POINTER(MYPFNGLMULTIDRAWELEMENTSPROC, glMultiDrawElements); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERFPROC, glPointParameterf); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERFVPROC, glPointParameterfv); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERIPROC, glPointParameteri); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERIVPROC, glPointParameteriv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BPROC, glSecondaryColor3b); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BVPROC, glSecondaryColor3bv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DPROC, glSecondaryColor3d); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DVPROC, glSecondaryColor3dv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FPROC, glSecondaryColor3f); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FVPROC, glSecondaryColor3fv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IPROC, glSecondaryColor3i); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IVPROC, glSecondaryColor3iv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SPROC, glSecondaryColor3s); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SVPROC, glSecondaryColor3sv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBPROC, glSecondaryColor3ub); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBVPROC, glSecondaryColor3ubv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIPROC, glSecondaryColor3ui); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIVPROC, glSecondaryColor3uiv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USPROC, glSecondaryColor3us); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USVPROC, glSecondaryColor3usv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLORPOINTERPROC, glSecondaryColorPointer); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2DPROC, glWindowPos2d); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2DVPROC, glWindowPos2dv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2FPROC, glWindowPos2f); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2FVPROC, glWindowPos2fv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2IPROC, glWindowPos2i); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2IVPROC, glWindowPos2iv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2SPROC, glWindowPos2s); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2SVPROC, glWindowPos2sv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3DPROC, glWindowPos3d); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3DVPROC, glWindowPos3dv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3FPROC, glWindowPos3f); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3FVPROC, glWindowPos3fv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3IPROC, glWindowPos3i); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3IVPROC, glWindowPos3iv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3SPROC, glWindowPos3s); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3SVPROC, glWindowPos3sv); return initExtension("GL_VERSION_1_3"); } #endif // GL_VERSION_1_4 #ifdef GL_EXT_paletted_texture else if (0 == strcmp(extension, "GL_EXT_paletted_texture")) { INIT_PROC_POINTER(MYPFNGLCOLORTABLEEXTPROC, glColorTableEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEEXTPROC, glGetColorTableEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC, glGetColorTableParameterivEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC, glGetColorTableParameterfvEXT); return true; } #endif // GL_EXT_paletted_texture #ifdef GL_ARB_multitexture else if (0 == strcmp(extension, "GL_ARB_multitexture")) { INIT_PROC_POINTER(MYPFNGLACTIVETEXTUREARBPROC, glActiveTextureARB); INIT_PROC_POINTER(MYPFNGLCLIENTACTIVETEXTUREARBPROC, glClientActiveTextureARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DARBPROC, glMultiTexCoord1dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DVARBPROC, glMultiTexCoord1dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FARBPROC, glMultiTexCoord1fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FVARBPROC, glMultiTexCoord1fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IARBPROC, glMultiTexCoord1iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IVARBPROC, glMultiTexCoord1ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SARBPROC, glMultiTexCoord1sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SVARBPROC, glMultiTexCoord1svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DARBPROC, glMultiTexCoord2dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DVARBPROC, glMultiTexCoord2dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FARBPROC, glMultiTexCoord2fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FVARBPROC, glMultiTexCoord2fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IARBPROC, glMultiTexCoord2iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IVARBPROC, glMultiTexCoord2ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SARBPROC, glMultiTexCoord2sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SVARBPROC, glMultiTexCoord2svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DARBPROC, glMultiTexCoord3dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DVARBPROC, glMultiTexCoord3dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FARBPROC, glMultiTexCoord3fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FVARBPROC, glMultiTexCoord3fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IARBPROC, glMultiTexCoord3iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IVARBPROC, glMultiTexCoord3ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SARBPROC, glMultiTexCoord3sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SVARBPROC, glMultiTexCoord3svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DARBPROC, glMultiTexCoord4dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DVARBPROC, glMultiTexCoord4dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FARBPROC, glMultiTexCoord4fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FVARBPROC, glMultiTexCoord4fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IARBPROC, glMultiTexCoord4iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IVARBPROC, glMultiTexCoord4ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SARBPROC, glMultiTexCoord4sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SVARBPROC, glMultiTexCoord4svARB); return true; } #endif // GL_ARB_multitexture #ifdef GL_SGI_texture_color_table else if (0 == strcmp(extension, "GL_SGI_texture_color_table")) { return true; } #endif // GL_SGI_texture_color_table #ifdef GL_SGI_color_table else if (0 == strcmp(extension, "GL_SGI_color_table")) { INIT_PROC_POINTER(MYPFNGLCOLORTABLESGIPROC, glColorTableSGI); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERFVSGIPROC, glColorTableParameterfvSGI); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERIVSGIPROC, glColorTableParameterivSGI); INIT_PROC_POINTER(MYPFNGLCOPYCOLORTABLESGIPROC, glCopyColorTableSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLESGIPROC, glGetColorTableSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC, glGetColorTableParameterfvSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC, glGetColorTableParameterivSGI); return true; } #endif // GL_SGI_color_table #ifdef GL_SGIS_texture_edge_clamp else if (0 == strcmp(extension, "GL_SGIS_texture_edge_clamp")) { return true; } #endif // GL_SGIS_texture_edge_clamp #ifdef GL_EXT_texture3D else if (0 == strcmp(extension, "GL_EXT_texture3D")) { INIT_PROC_POINTER(MYPFNGLTEXIMAGE3DEXTPROC, glTexImage3DEXT); INIT_PROC_POINTER(MYPFNGLTEXSUBIMAGE3DEXTPROC, glTexSubImage3DEXT); return true; } #endif // GL_EXT_texture3D #ifdef GL_NV_fragment_program else if (0 == strcmp(extension, "GL_NV_fragment_program")) { INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC, glProgramNamedParameter4fNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC, glProgramNamedParameter4dNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC, glProgramNamedParameter4fvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC, glProgramNamedParameter4dvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC, glGetProgramNamedParameterfvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC, glGetProgramNamedParameterdvNV); return true; } #endif // GL_NV_fragment_program #ifdef GL_NV_vertex_program else if (0 == strcmp(extension, "GL_NV_vertex_program")) { INIT_PROC_POINTER(MYPFNGLAREPROGRAMSRESIDENTNVPROC, glAreProgramsResidentNV); INIT_PROC_POINTER(MYPFNGLBINDPROGRAMNVPROC, glBindProgramNV); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMSNVPROC, glDeleteProgramsNV); INIT_PROC_POINTER(MYPFNGLEXECUTEPROGRAMNVPROC, glExecuteProgramNV); INIT_PROC_POINTER(MYPFNGLGENPROGRAMSNVPROC, glGenProgramsNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMPARAMETERDVNVPROC, glGetProgramParameterdvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMPARAMETERFVNVPROC, glGetProgramParameterfvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVNVPROC, glGetProgramivNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMSTRINGNVPROC, glGetProgramStringNV); INIT_PROC_POINTER(MYPFNGLGETTRACKMATRIXIVNVPROC, glGetTrackMatrixivNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVNVPROC, glGetVertexAttribdvNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVNVPROC, glGetVertexAttribfvNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVNVPROC, glGetVertexAttribivNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC, glGetVertexAttribPointervNV); INIT_PROC_POINTER(MYPFNGLISPROGRAMNVPROC, glIsProgramNV); INIT_PROC_POINTER(MYPFNGLLOADPROGRAMNVPROC, glLoadProgramNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4DNVPROC, glProgramParameter4dNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4DVNVPROC, glProgramParameter4dvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4FNVPROC, glProgramParameter4fNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4FVNVPROC, glProgramParameter4fvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETERS4DVNVPROC, glProgramParameters4dvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETERS4FVNVPROC, glProgramParameters4fvNV); INIT_PROC_POINTER(MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC, glRequestResidentProgramsNV); INIT_PROC_POINTER(MYPFNGLTRACKMATRIXNVPROC, glTrackMatrixNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERNVPROC, glVertexAttribPointerNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DNVPROC, glVertexAttrib1dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVNVPROC, glVertexAttrib1dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FNVPROC, glVertexAttrib1fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVNVPROC, glVertexAttrib1fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SNVPROC, glVertexAttrib1sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVNVPROC, glVertexAttrib1svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DNVPROC, glVertexAttrib2dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVNVPROC, glVertexAttrib2dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FNVPROC, glVertexAttrib2fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVNVPROC, glVertexAttrib2fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SNVPROC, glVertexAttrib2sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVNVPROC, glVertexAttrib2svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DNVPROC, glVertexAttrib3dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVNVPROC, glVertexAttrib3dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FNVPROC, glVertexAttrib3fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVNVPROC, glVertexAttrib3fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SNVPROC, glVertexAttrib3sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVNVPROC, glVertexAttrib3svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DNVPROC, glVertexAttrib4dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVNVPROC, glVertexAttrib4dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FNVPROC, glVertexAttrib4fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVNVPROC, glVertexAttrib4fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SNVPROC, glVertexAttrib4sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVNVPROC, glVertexAttrib4svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBNVPROC, glVertexAttrib4ubNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVNVPROC, glVertexAttrib4ubvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1DVNVPROC, glVertexAttribs1dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1FVNVPROC, glVertexAttribs1fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1SVNVPROC, glVertexAttribs1svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2DVNVPROC, glVertexAttribs2dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2FVNVPROC, glVertexAttribs2fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2SVNVPROC, glVertexAttribs2svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3DVNVPROC, glVertexAttribs3dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3FVNVPROC, glVertexAttribs3fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3SVNVPROC, glVertexAttribs3svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4DVNVPROC, glVertexAttribs4dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4FVNVPROC, glVertexAttribs4fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4SVNVPROC, glVertexAttribs4svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4UBVNVPROC, glVertexAttribs4ubvNV); return true; } #endif // GL_NV_vertex_program #ifdef GL_ARB_vertex_program else if (0 == strcmp(extension, "GL_ARB_vertex_program")) { INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DARBPROC, glVertexAttrib1dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVARBPROC, glVertexAttrib1dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FARBPROC, glVertexAttrib1fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVARBPROC, glVertexAttrib1fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SARBPROC, glVertexAttrib1sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVARBPROC, glVertexAttrib1svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DARBPROC, glVertexAttrib2dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVARBPROC, glVertexAttrib2dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FARBPROC, glVertexAttrib2fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVARBPROC, glVertexAttrib2fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SARBPROC, glVertexAttrib2sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVARBPROC, glVertexAttrib2svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DARBPROC, glVertexAttrib3dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVARBPROC, glVertexAttrib3dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FARBPROC, glVertexAttrib3fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVARBPROC, glVertexAttrib3fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SARBPROC, glVertexAttrib3sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVARBPROC, glVertexAttrib3svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NBVARBPROC, glVertexAttrib4NbvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NIVARBPROC, glVertexAttrib4NivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NSVARBPROC, glVertexAttrib4NsvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBARBPROC, glVertexAttrib4NubARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBVARBPROC, glVertexAttrib4NubvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUIVARBPROC, glVertexAttrib4NuivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUSVARBPROC, glVertexAttrib4NusvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4BVARBPROC, glVertexAttrib4bvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DARBPROC, glVertexAttrib4dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVARBPROC, glVertexAttrib4dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FARBPROC, glVertexAttrib4fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVARBPROC, glVertexAttrib4fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4IVARBPROC, glVertexAttrib4ivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SARBPROC, glVertexAttrib4sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVARBPROC, glVertexAttrib4svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVARBPROC, glVertexAttrib4ubvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UIVARBPROC, glVertexAttrib4uivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4USVARBPROC, glVertexAttrib4usvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointerARB); INIT_PROC_POINTER(MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArrayARB); INIT_PROC_POINTER(MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArrayARB); INIT_PROC_POINTER(MYPFNGLPROGRAMSTRINGARBPROC, glProgramStringARB); INIT_PROC_POINTER(MYPFNGLBINDPROGRAMARBPROC, glBindProgramARB); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMSARBPROC, glDeleteProgramsARB); INIT_PROC_POINTER(MYPFNGLGENPROGRAMSARBPROC, glGenProgramsARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4DARBPROC, glProgramEnvParameter4dARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4DVARBPROC, glProgramEnvParameter4dvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4FARBPROC, glProgramEnvParameter4fARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4FVARBPROC, glProgramEnvParameter4fvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC, glProgramLocalParameter4dARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC, glProgramLocalParameter4dvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC, glProgramLocalParameter4fARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC, glProgramLocalParameter4fvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC, glGetProgramEnvParameterdvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC, glGetProgramEnvParameterfvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC, glGetProgramLocalParameterdvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC, glGetProgramLocalParameterfvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVARBPROC, glGetProgramivARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMSTRINGARBPROC, glGetProgramStringARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVARBPROC, glGetVertexAttribdvARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVARBPROC, glGetVertexAttribfvARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVARBPROC, glGetVertexAttribivARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC, glGetVertexAttribPointervARB); INIT_PROC_POINTER(MYPFNGLISPROGRAMARBPROC, glIsProgramARB); return true; } #endif // GL_ARB_vertex_program #ifdef GL_ARB_fragment_program else if (0 == strcmp(extension, "GL_ARB_fragment_program")) { return true; } #endif // GL_ARB_fragment_program /// WGL extensions follows #if defined(WIN32) #ifdef WGL_ARB_pixel_format else if (0 == strcmp(extension, "WGL_ARB_pixel_format")) { INIT_WGL_PROC_POINTER(MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB); INIT_WGL_PROC_POINTER(MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC, wglGetPixelFormatAttribfvARB); INIT_WGL_PROC_POINTER(MYPFNWGLCHOOSEPIXELFORMATARBPROC, wglChoosePixelFormatARB); return true; } #endif // WGL_ARB_pixel_format #ifdef WGL_ARB_pbuffer else if (0 == strcmp(extension, "WGL_ARB_pbuffer")) { INIT_WGL_PROC_POINTER(MYPFNWGLCREATEPBUFFERARBPROC, wglCreatePbufferARB); INIT_WGL_PROC_POINTER(MYPFNWGLGETPBUFFERDCARBPROC, wglGetPbufferDCARB); INIT_WGL_PROC_POINTER(MYPFNWGLRELEASEPBUFFERDCARBPROC, wglReleasePbufferDCARB); INIT_WGL_PROC_POINTER(MYPFNWGLDESTROYPBUFFERARBPROC, wglDestroyPbufferARB); INIT_WGL_PROC_POINTER(MYPFNWGLQUERYPBUFFERARBPROC, wglQueryPbufferARB); return true; } #endif // WGL_ARB_pbuffer #ifdef WGL_ARB_render_texture else if (0 == strcmp(extension, "WGL_ARB_render_texture")) { INIT_WGL_PROC_POINTER(MYPFNWGLBINDTEXIMAGEARBPROC, wglBindTexImageARB); INIT_WGL_PROC_POINTER(MYPFNWGLRELEASETEXIMAGEARBPROC, wglReleaseTexImageARB); INIT_WGL_PROC_POINTER(MYPFNWGLSETPBUFFERATTRIBARBPROC, wglSetPbufferAttribARB); return true; } #endif // WGL_ARB_render_texture #ifdef WGL_ARB_extensions_string else if (0 == strcmp(extension, "WGL_ARB_extensions_string")) { INIT_WGL_PROC_POINTER(MYPFNWGLGETEXTENSIONSSTRINGARBPROC, wglGetExtensionsStringARB); return true; } #endif // WGL_ARB_extensions_string #endif // defined(WIN32) else { return false; } } void MyExtensions::initPointersToZero() { // OpenGL version 1.2 glBlendColor = 0; glBlendEquation = 0; glDrawRangeElements = 0; glColorTable = 0; glColorTableParameterfv = 0; glColorTableParameteriv = 0; glCopyColorTable = 0; glGetColorTable = 0; glGetColorTableParameterfv = 0; glGetColorTableParameteriv = 0; glColorSubTable = 0; glCopyColorSubTable = 0; glConvolutionFilter1D = 0; glConvolutionFilter2D = 0; glConvolutionParameterf = 0; glConvolutionParameterfv = 0; glConvolutionParameteri = 0; glConvolutionParameteriv = 0; glCopyConvolutionFilter1D = 0; glCopyConvolutionFilter2D = 0; glGetConvolutionFilter = 0; glGetConvolutionParameterfv = 0; glGetConvolutionParameteriv = 0; glGetSeparableFilter = 0; glSeparableFilter2D = 0; glGetHistogram = 0; glGetHistogramParameterfv = 0; glGetHistogramParameteriv = 0; glGetMinmax = 0; glGetMinmaxParameterfv = 0; glGetMinmaxParameteriv = 0; glHistogram = 0; glMinmax = 0; glResetHistogram = 0; glResetMinmax = 0; glTexImage3D = 0; glTexSubImage3D = 0; glCopyTexSubImage3D = 0; // End OpenGL version 1.2 // OpenGL version 1.3 glActiveTexture = 0; glClientActiveTexture = 0; glMultiTexCoord1d = 0; glMultiTexCoord1dv = 0; glMultiTexCoord1f = 0; glMultiTexCoord1fv = 0; glMultiTexCoord1i = 0; glMultiTexCoord1iv = 0; glMultiTexCoord1s = 0; glMultiTexCoord1sv = 0; glMultiTexCoord2d = 0; glMultiTexCoord2dv = 0; glMultiTexCoord2f = 0; glMultiTexCoord2fv = 0; glMultiTexCoord2i = 0; glMultiTexCoord2iv = 0; glMultiTexCoord2s = 0; glMultiTexCoord2sv = 0; glMultiTexCoord3d = 0; glMultiTexCoord3dv = 0; glMultiTexCoord3f = 0; glMultiTexCoord3fv = 0; glMultiTexCoord3i = 0; glMultiTexCoord3iv = 0; glMultiTexCoord3s = 0; glMultiTexCoord3sv = 0; glMultiTexCoord4d = 0; glMultiTexCoord4dv = 0; glMultiTexCoord4f = 0; glMultiTexCoord4fv = 0; glMultiTexCoord4i = 0; glMultiTexCoord4iv = 0; glMultiTexCoord4s = 0; glMultiTexCoord4sv = 0; glLoadTransposeMatrixf = 0; glLoadTransposeMatrixd = 0; glMultTransposeMatrixf = 0; glMultTransposeMatrixd = 0; glSampleCoverage = 0; glCompressedTexImage3D = 0; glCompressedTexImage2D = 0; glCompressedTexImage1D = 0; glCompressedTexSubImage3D = 0; glCompressedTexSubImage2D = 0; glCompressedTexSubImage1D = 0; glGetCompressedTexImage = 0; // End OpenGL version 1.3 // OpenGL version 1.4 glBlendFuncSeparate = 0; glFogCoordf = 0; glFogCoordfv = 0; glFogCoordd = 0; glFogCoorddv = 0; glFogCoordPointer = 0; glMultiDrawArrays = 0; glMultiDrawElements = 0; glPointParameterf = 0; glPointParameterfv = 0; glPointParameteri = 0; glPointParameteriv = 0; glSecondaryColor3b = 0; glSecondaryColor3bv = 0; glSecondaryColor3d = 0; glSecondaryColor3dv = 0; glSecondaryColor3f = 0; glSecondaryColor3fv = 0; glSecondaryColor3i = 0; glSecondaryColor3iv = 0; glSecondaryColor3s = 0; glSecondaryColor3sv = 0; glSecondaryColor3ub = 0; glSecondaryColor3ubv = 0; glSecondaryColor3ui = 0; glSecondaryColor3uiv = 0; glSecondaryColor3us = 0; glSecondaryColor3usv = 0; glSecondaryColorPointer = 0; glWindowPos2d = 0; glWindowPos2dv = 0; glWindowPos2f = 0; glWindowPos2fv = 0; glWindowPos2i = 0; glWindowPos2iv = 0; glWindowPos2s = 0; glWindowPos2sv = 0; glWindowPos3d = 0; glWindowPos3dv = 0; glWindowPos3f = 0; glWindowPos3fv = 0; glWindowPos3i = 0; glWindowPos3iv = 0; glWindowPos3s = 0; glWindowPos3sv = 0; // End OpenGL version 1.4 // GL_EXT_paletted_texture glColorTableEXT = 0; glGetColorTableEXT = 0; glGetColorTableParameterivEXT = 0; glGetColorTableParameterfvEXT = 0; // End GL_EXT_paletted_texture // GL_ARB_multitexture glActiveTextureARB = 0; glClientActiveTextureARB = 0; glMultiTexCoord1dARB = 0; glMultiTexCoord1dvARB = 0; glMultiTexCoord1fARB = 0; glMultiTexCoord1fvARB = 0; glMultiTexCoord1iARB = 0; glMultiTexCoord1ivARB = 0; glMultiTexCoord1sARB = 0; glMultiTexCoord1svARB = 0; glMultiTexCoord2dARB = 0; glMultiTexCoord2dvARB = 0; glMultiTexCoord2fARB = 0; glMultiTexCoord2fvARB = 0; glMultiTexCoord2iARB = 0; glMultiTexCoord2ivARB = 0; glMultiTexCoord2sARB = 0; glMultiTexCoord2svARB = 0; glMultiTexCoord3dARB = 0; glMultiTexCoord3dvARB = 0; glMultiTexCoord3fARB = 0; glMultiTexCoord3fvARB = 0; glMultiTexCoord3iARB = 0; glMultiTexCoord3ivARB = 0; glMultiTexCoord3sARB = 0; glMultiTexCoord3svARB = 0; glMultiTexCoord4dARB = 0; glMultiTexCoord4dvARB = 0; glMultiTexCoord4fARB = 0; glMultiTexCoord4fvARB = 0; glMultiTexCoord4iARB = 0; glMultiTexCoord4ivARB = 0; glMultiTexCoord4sARB = 0; glMultiTexCoord4svARB = 0; // End GL_ARB_multitexture // GL_NV_fragment_program glProgramNamedParameter4fNV = 0; glProgramNamedParameter4dNV = 0; glProgramNamedParameter4fvNV = 0; glProgramNamedParameter4dvNV = 0; glGetProgramNamedParameterfvNV = 0; glGetProgramNamedParameterdvNV = 0; // End GL_NV_fragment_program // GL_NV_vertex_program glAreProgramsResidentNV = 0; glBindProgramNV = 0; glDeleteProgramsNV = 0; glExecuteProgramNV = 0; glGenProgramsNV = 0; glGetProgramParameterdvNV = 0; glGetProgramParameterfvNV = 0; glGetProgramivNV = 0; glGetProgramStringNV = 0; glGetTrackMatrixivNV = 0; glGetVertexAttribdvNV = 0; glGetVertexAttribfvNV = 0; glGetVertexAttribivNV = 0; glGetVertexAttribPointervNV = 0; glIsProgramNV = 0; glLoadProgramNV = 0; glProgramParameter4dNV = 0; glProgramParameter4dvNV = 0; glProgramParameter4fNV = 0; glProgramParameter4fvNV = 0; glProgramParameters4dvNV = 0; glProgramParameters4fvNV = 0; glRequestResidentProgramsNV = 0; glTrackMatrixNV = 0; glVertexAttribPointerNV = 0; glVertexAttrib1dNV = 0; glVertexAttrib1dvNV = 0; glVertexAttrib1fNV = 0; glVertexAttrib1fvNV = 0; glVertexAttrib1sNV = 0; glVertexAttrib1svNV = 0; glVertexAttrib2dNV = 0; glVertexAttrib2dvNV = 0; glVertexAttrib2fNV = 0; glVertexAttrib2fvNV = 0; glVertexAttrib2sNV = 0; glVertexAttrib2svNV = 0; glVertexAttrib3dNV = 0; glVertexAttrib3dvNV = 0; glVertexAttrib3fNV = 0; glVertexAttrib3fvNV = 0; glVertexAttrib3sNV = 0; glVertexAttrib3svNV = 0; glVertexAttrib4dNV = 0; glVertexAttrib4dvNV = 0; glVertexAttrib4fNV = 0; glVertexAttrib4fvNV = 0; glVertexAttrib4sNV = 0; glVertexAttrib4svNV = 0; glVertexAttrib4ubNV = 0; glVertexAttrib4ubvNV = 0; glVertexAttribs1dvNV = 0; glVertexAttribs1fvNV = 0; glVertexAttribs1svNV = 0; glVertexAttribs2dvNV = 0; glVertexAttribs2fvNV = 0; glVertexAttribs2svNV = 0; glVertexAttribs3dvNV = 0; glVertexAttribs3fvNV = 0; glVertexAttribs3svNV = 0; glVertexAttribs4dvNV = 0; glVertexAttribs4fvNV = 0; glVertexAttribs4svNV = 0; glVertexAttribs4ubvNV = 0; // End GL_NV_vertex_program // GL_ARB_vertex_program glVertexAttrib1dARB = 0; glVertexAttrib1dvARB = 0; glVertexAttrib1fARB = 0; glVertexAttrib1fvARB = 0; glVertexAttrib1sARB = 0; glVertexAttrib1svARB = 0; glVertexAttrib2dARB = 0; glVertexAttrib2dvARB = 0; glVertexAttrib2fARB = 0; glVertexAttrib2fvARB = 0; glVertexAttrib2sARB = 0; glVertexAttrib2svARB = 0; glVertexAttrib3dARB = 0; glVertexAttrib3dvARB = 0; glVertexAttrib3fARB = 0; glVertexAttrib3fvARB = 0; glVertexAttrib3sARB = 0; glVertexAttrib3svARB = 0; glVertexAttrib4NbvARB = 0; glVertexAttrib4NivARB = 0; glVertexAttrib4NsvARB = 0; glVertexAttrib4NubARB = 0; glVertexAttrib4NubvARB = 0; glVertexAttrib4NuivARB = 0; glVertexAttrib4NusvARB = 0; glVertexAttrib4bvARB = 0; glVertexAttrib4dARB = 0; glVertexAttrib4dvARB = 0; glVertexAttrib4fARB = 0; glVertexAttrib4fvARB = 0; glVertexAttrib4ivARB = 0; glVertexAttrib4sARB = 0; glVertexAttrib4svARB = 0; glVertexAttrib4ubvARB = 0; glVertexAttrib4uivARB = 0; glVertexAttrib4usvARB = 0; glVertexAttribPointerARB = 0; glEnableVertexAttribArrayARB = 0; glDisableVertexAttribArrayARB = 0; glProgramStringARB = 0; glBindProgramARB = 0; glDeleteProgramsARB = 0; glGenProgramsARB = 0; glProgramEnvParameter4dARB = 0; glProgramEnvParameter4dvARB = 0; glProgramEnvParameter4fARB = 0; glProgramEnvParameter4fvARB = 0; glProgramLocalParameter4dARB = 0; glProgramLocalParameter4dvARB = 0; glProgramLocalParameter4fARB = 0; glProgramLocalParameter4fvARB = 0; glGetProgramEnvParameterdvARB = 0; glGetProgramEnvParameterfvARB = 0; glGetProgramLocalParameterdvARB = 0; glGetProgramLocalParameterfvARB = 0; glGetProgramivARB = 0; glGetProgramStringARB = 0; glGetVertexAttribdvARB = 0; glGetVertexAttribfvARB = 0; glGetVertexAttribivARB = 0; glGetVertexAttribPointervARB = 0; glIsProgramARB = 0; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program /// WGL extensions follows #if defined(WIN32) // WGL_ARB_pixel_format wglGetPixelFormatAttribivARB = 0; wglGetPixelFormatAttribfvARB = 0; wglChoosePixelFormatARB = 0; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer wglCreatePbufferARB = 0; wglGetPbufferDCARB = 0; wglReleasePbufferDCARB = 0; wglDestroyPbufferARB = 0; wglQueryPbufferARB = 0; // End WGL_ARB_pbuffer // WGL_ARB_render_texture wglBindTexImageARB = 0; wglReleaseTexImageARB = 0; wglSetPbufferAttribARB = 0; // End WGL_ARB_render_texture #endif // defined(WIN32) } const char* MyExtensions::EatWhiteSpace(const char* str) { for (; *str && (' ' == *str || '\t' == *str || '\n' == *str); str++); return str; } const char* MyExtensions::EatNonWhiteSpace(const char* str) { for (; *str && (' ' != *str && '\t' != *str && '\n' != *str); str++); return str; } const char* MyExtensions::getExtensionStringPrivate() { const char* normalExtensions = (const char*)glGetString(GL_EXTENSIONS); return normalExtensions; } const char* MyExtensions::getSystemExtensions() { // for now, we only do wgl extensions, not glx extensions #if defined(_WIN32) MYPFNWGLGETEXTENSIONSSTRINGARBPROC mywglGetExtensionsStringARB = 0; mywglGetExtensionsStringARB = (MYPFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB"); if(mywglGetExtensionsStringARB) { return mywglGetExtensionsStringARB(wglGetCurrentDC()); } else { return 0; } #else return 0; #endif } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/FragmentProgramImpl.cpp0000644000175000017500000001730110223377127027204 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // FragmentProgramImpl.cpp: implementation of the FragmentProgramImpl class. // ////////////////////////////////////////////////////////////////////// #include "FragmentProgramImpl.h" #include using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// FragmentProgramImpl::FragmentProgramImpl() { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; } FragmentProgramImpl::~FragmentProgramImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool FragmentProgramImpl::initRenderer() { if (!UnshadedBase::initRenderer() || !initExtensions() || !initTextureNames() || !initFragmentProgram()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool FragmentProgramImpl::checkCompatibility() const { return MyExtensions::checkExtensions( "GL_VERSION_1_2 " "GL_NV_vertex_program " "GL_NV_fragment_program " "GL_ARB_multitexture " ); } // Uploads colormapped data bool FragmentProgramImpl::uploadColormappedData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_3D, m_DataTextureName); if (width!=m_Width || height!=m_Height || depth!=m_Depth) { m_Extensions.glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE, width, height, depth, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); } else { m_Extensions.glTexSubImage3D(GL_TEXTURE_3D, 0, 0,0,0, width, height, depth, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); } glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // save the width height and depth m_Width = width; m_HintDimX = width; m_Height = height; m_HintDimY = height; m_Depth = depth; m_HintDimZ = depth; // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Tests to see if the given parameters would return an error bool FragmentProgramImpl::testColormappedData(int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // nothing above 512 if (width>512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; m_Extensions.glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_LUMINANCE, width, height, depth, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Uploads the transfer function for the colormapped data bool FragmentProgramImpl::uploadColorMap(const GLubyte* colorMap) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_1D, m_TransferTextureName); glTexImage1D(GL_TEXTURE_1D, 0, 4, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, colorMap); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Performs the actual rendering. bool FragmentProgramImpl::renderVolume() { // bail if we haven't been initialized properly if (!m_Initialized) return false; // set up the state glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColor4f(1.0, 1.0, 1.0, 1.0); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); // get the fragment program ready glEnable(GL_FRAGMENT_PROGRAM_NV); m_Extensions.glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, m_FragmentProgramName); //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDepthMask( GL_FALSE ); // bind the transfer function m_Extensions.glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_1D); glBindTexture(GL_TEXTURE_1D, m_TransferTextureName); // bind the data texture m_Extensions.glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_3D); glBindTexture(GL_TEXTURE_3D, m_DataTextureName); computePolygons(); convertToTriangles(); renderTriangles(); // unbind the fragment program m_Extensions.glBindProgramNV(GL_FRAGMENT_PROGRAM_NV, 0); // restore the state glPopAttrib(); return true; } // Initializes the necessary extensions. bool FragmentProgramImpl::initExtensions() { return m_Extensions.initExtensions( "GL_VERSION_1_2 " "GL_NV_vertex_program " "GL_NV_fragment_program " "GL_ARB_multitexture " ); } // Gets the opengl texture IDs bool FragmentProgramImpl::initTextureNames() { // clear previous errors GLenum error = glGetError(); // get the names glGenTextures(1, &m_DataTextureName); glGenTextures(1, &m_TransferTextureName); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Gets the fragment program ready bool FragmentProgramImpl::initFragmentProgram() { // clear previous errors GLenum error = glGetError(); m_Extensions.glGenProgramsNV(1, &m_FragmentProgramName); const GLubyte program[] = "!!FP1.0\n" "TEX R0.x, f[TEX0].xyzx, TEX0, 3D;\n" "TEX o[COLR], R0.x, TEX1, 1D;\n" "END\n"; int len = strlen((const char*)program); m_Extensions.glLoadProgramNV(GL_FRAGMENT_PROGRAM_NV, m_FragmentProgramName, len, program); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Render the actual triangles void FragmentProgramImpl::renderTriangles() { // set up the client render state glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, 0, m_TextureArray); glVertexPointer(3, GL_FLOAT, 0, m_VertexArray); // render the triangles glDrawElements(GL_TRIANGLES, m_NumTriangles*3, GL_UNSIGNED_INT, m_TriangleArray); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/RGBABase.h0000644000175000017500000000374010223377127024244 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // OpenGLVolumeRGBABase.h: interface for the OpenGLVolumeRGBABase class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_OPENGLVOLUMERGBABASE_H__2615681E_5453_4C3E_A370_4FF06C85BD9F__INCLUDED_) #define AFX_OPENGLVOLUMERGBABASE_H__2615681E_5453_4C3E_A370_4FF06C85BD9F__INCLUDED_ #include "RendererBase.h" namespace OpenGLVolumeRendering { /// The base class for non-colormapped volume renderers class RGBABase : public RendererBase { public: RGBABase(); virtual ~RGBABase(); /// Initializes the renderer. Should be called again if the renderer is /// moved to a different openGL context. If this returns false, do not try /// to use it to do volumeRendering virtual bool initRenderer(); /// Uploads colormapped data virtual bool uploadRGBAData(const GLubyte* data, int width, int height, int depth) = 0; /// Tests to see if the given parameters would return an error virtual bool testRGBAData(int width, int height, int depth) = 0; }; }; #endif // !defined(AFX_OPENGLVOLUMERGBABASE_H__2615681E_5453_4C3E_A370_4FF06C85BD9F__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/FragmentProgramARBImpl.h0000644000175000017500000000616210223377127027201 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // FragmentProgramARBImpl.h: interface for the FragmentProgramARBImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_FRAGMENTPROGRAMARBIMPL_H__E403D488_A932_4024_88F8_014799D35828__INCLUDED_) #define AFX_FRAGMENTPROGRAMARBIMPL_H__E403D488_A932_4024_88F8_014799D35828__INCLUDED_ #include "UnshadedBase.h" #include "MyExtensions.h" namespace OpenGLVolumeRendering { /// A volume renderer which uses ARB fragment programs to perform color mapping class FragmentProgramARBImpl : public UnshadedBase { public: FragmentProgramARBImpl(); virtual ~FragmentProgramARBImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadColormappedData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testColormappedData(int width, int height, int depth); // Uploads the transfer function for the colormapped data virtual bool uploadColorMap(const GLubyte* colorMap); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; // The opengl texture ID GLuint m_DataTextureName; // The transfer function texture ID GLuint m_TransferTextureName; // The ID of the fragment program GLuint m_FragmentProgramName; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(); // Gets the fragment program ready bool initFragmentProgram(); // Render the actual triangles void renderTriangles(); }; }; #endif // !defined(AFX_FRAGMENTPROGRAMARBIMPL_H__E403D488_A932_4024_88F8_014799D35828__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolRenLib-license.txt0000644000175000017500000000616110334435502026575 0ustar debiandebianTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 1. This software is the copyright of THE UNIVERSITY OF TEXAS AT AUSTIN, 2005. 2. The software is available under multiple licenses. 3. For non commercial educational and non commercial academic use, the software including source code, interface definitions and compile scripts are freely available. Any distribution of code, library or executables which contains any modules from this software should contain, conspicously and appropriately, on each copy, this copyright and license notice and should be freely distributed. 4. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation. 5. For any other purpose, including commercial purposes, please contact The University of Texas at Austin for a different license. 6. Credits: This software has been developed at the Computational and Visualization center under Dr Chandrajit Bajaj, Computational Applied Mathematics Chair in Visualization, Professor of Computer Sciences, Director of Center for Computational Visualization, Department of Computer Sciences & The Institute of Computational Engineering and Sciences , Center for Computational Visualization, 201 East 24th Street, ACES 2.324A, 1 University Station, C0200, Austin, TX 78712-0027. We request that you agree to acknowledge the use of the software that results in any published work, including scientific papers, films and videotapes by citing the references listed below C. Bajaj, Z. Yu, M. Auer Volumetric Feature Extraction and Visualization of Tomographic Molecular Imaging. Journal of Structural Biology, Volume 144, Issues 1-2, October 2003, Pages 132-143 7. No warranty 7a. Because the library is licensed free of charge, there is no warranty for the library, to the extent permitted by applicable law. except when otherwise stated in writing the copyright holders and/or other parties provide the library "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. the entire risk as to the quality and performance of the library is with you. should the library prove defective, you assume the cost of all necessary servicing, repair or correction. 7b. In no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute the library as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use the library (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the library to operate with any other software), even if such holder or other party has been advised of the possibility of such damages. END OF TERMS AND CONDITIONS mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SGIColorTableImpl.h0000644000175000017500000000563310223377127026154 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // OpenGLVolumeSGIColorTableImpl.h: interface for the OpenGLVolumeSGIColorTableImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_OPENGLVOLUMESGICOLORTABLEIMPL_H__4EBB934A_B53C_4057_92BA_83BC07C67CDD__INCLUDED_) #define AFX_OPENGLVOLUMESGICOLORTABLEIMPL_H__4EBB934A_B53C_4057_92BA_83BC07C67CDD__INCLUDED_ #include "UnshadedBase.h" namespace OpenGLVolumeRendering { /** A volume renderer which uses SGI's color table extension to do color mapping */ class SGIColorTableImpl : public UnshadedBase { public: SGIColorTableImpl(); virtual ~SGIColorTableImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadColormappedData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testColormappedData(int width, int height, int depth); // Uploads the transfer function for the colormapped data virtual bool uploadColorMap(const GLubyte* colorMap); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; // The opengl texture ID GLuint m_DataTextureName; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(); // Render the actual triangles void renderTriangles(); }; }; #endif // !defined(AFX_OPENGLVOLUMESGICOLORTABLEIMPL_H__4EBB934A_B53C_4057_92BA_83BC07C67CDD__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Extent.h0000644000175000017500000000330010223377127024175 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Extent.h: interface for the Extent class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_OPENGLEXTENT_H__DAAEF2B3_F7FE_48F8_88CF_41B8BF38BA02__INCLUDED_) #define AFX_OPENGLEXTENT_H__DAAEF2B3_F7FE_48F8_88CF_41B8BF38BA02__INCLUDED_ namespace OpenGLVolumeRendering { /** encapsulates a 3d min and max */ class Extent { public: Extent(); Extent( double xMin, double yMin, double zMin, double xMax, double yMax, double zMax ); ~Extent(); void setExtents( double xMin, double yMin, double zMin, double xMax, double yMax, double zMax ); double m_MinX; double m_MinY; double m_MinZ; double m_MaxX; double m_MaxY; double m_MaxZ; }; }; #endif // !defined(AFX_OPENGLEXTENT_H__DAAEF2B3_F7FE_48F8_88CF_41B8BF38BA02__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeRendererFactory.cpp0000644000175000017500000000513310223377127027555 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // VolumeRendererFactory.cpp: implementation of the VolumeRendererFactory class. // ////////////////////////////////////////////////////////////////////// #include "VolumeRendererFactory.h" #include "RGBABase.h" #include "UnshadedBase.h" #include "SimpleRGBAImpl.h" #include "PalettedImpl.h" #include "FragmentProgramImpl.h" #include "SGIColorTableImpl.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// OpenGLVolumeRendering::VolumeRendererFactory::VolumeRendererFactory() { } OpenGLVolumeRendering::VolumeRendererFactory::~VolumeRendererFactory() { } OpenGLVolumeRendering::RGBABase* OpenGLVolumeRendering::VolumeRendererFactory::getRGBARenderer() { RGBABase* renderer; // this should work on most platforms renderer = new SimpleRGBAImpl; if (renderer->initRenderer()) { return renderer; } // failed delete renderer; renderer = 0; return 0; } OpenGLVolumeRendering::UnshadedBase* OpenGLVolumeRendering::VolumeRendererFactory::getUnshadedRenderer() { UnshadedBase* renderer; // first we try the paletted version which we know works on // Nvidia renderer = new PalettedImpl; if (renderer->initRenderer()) { return renderer; } //failed delete renderer; renderer = 0; // looks like NVIDIA might not support the paletted texture // extension any more, this is the alternative renderer = new FragmentProgramImpl; if (renderer->initRenderer()) { return renderer; } // failed delete renderer; renderer = 0; // next we try the sgi version renderer = new SGIColorTableImpl; if (renderer->initRenderer()) { return renderer; } // out of options delete renderer; renderer = 0; return 0; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Renderer.cpp0000644000175000017500000002761510223377127025046 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Renderer.cpp: implementation of the Renderer class. // ////////////////////////////////////////////////////////////////////// #include "Renderer.h" #include #include "Polygon.h" #include "ClipCube.h" #include "PalettedImpl.h" #include "FragmentProgramImpl.h" #include "FragmentProgramARBImpl.h" #include "SGIColorTableImpl.h" #include "SimpleRGBAImpl.h" #include "SimpleRGBA2DImpl.h" #include "Paletted2DImpl.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Renderer::Renderer() { m_RGBA = 0; m_Colormapped = 0; initFlags(); } Renderer::~Renderer() { delete m_Colormapped; delete m_RGBA; } bool Renderer::initFlags() { m_UseColormapped = false; m_DataLoaded = false; return true; } bool Renderer::initRenderer() { bool colormapped = initColormappedRenderer();; bool rgba = initRGBARenderer(); if (colormapped && rgba) { m_DataLoaded = false; return true; } else { return false; } } bool Renderer::setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { if (m_Colormapped) m_Colormapped->setTextureSubCube(minX, minY, minZ, maxX, maxY, maxZ); if (m_RGBA) m_RGBA->setTextureSubCube(minX, minY, minZ, maxX, maxY, maxZ); return true; } bool Renderer::setQuality(double quality) { if (m_Colormapped) m_Colormapped->setQuality(quality); if (m_RGBA) m_RGBA->setQuality(quality); return true; } double Renderer::getQuality() const { if (m_UseColormapped && m_Colormapped) return m_Colormapped->getQuality(); else if (m_RGBA) return m_RGBA->getQuality(); else return 0; } bool Renderer::setNearPlane(double nearPlane) { if (m_Colormapped) m_Colormapped->setNearPlane(nearPlane); if (m_RGBA) m_RGBA->setNearPlane(nearPlane); return true; } double Renderer::getNearPlane() { if (m_Colormapped) return m_Colormapped->getNearPlane(); else if (m_RGBA) return m_RGBA->getNearPlane(); else return 1.0; } bool Renderer::setAspectRatio(double ratioX, double ratioY, double ratioZ) { if (m_Colormapped) m_Colormapped->setAspectRatio(ratioX, ratioY, ratioZ); if (m_RGBA) m_RGBA->setAspectRatio(ratioX, ratioY, ratioZ); return true; } bool Renderer::isShadedRenderingAvailable() const { return false; } bool Renderer::enableShadedRendering() { return false; } bool Renderer::disableShadedRendering() { return true; } bool Renderer::uploadColorMappedData(const GLubyte* data, int width, int height, int depth) { if (m_Colormapped && m_Colormapped->uploadColormappedData(data, width, height, depth)) { m_UseColormapped = true; m_DataLoaded = true; return true; } else { return false; } } bool Renderer::uploadColorMappedDataWithBorder(const GLubyte* data, int width, int height, int depth) { return false; /* #ifdef GL_EXT_paletted_texture // clear previous errors GLenum error = glGetError(); // save the width height and depth m_Width = width; m_Height = height; m_Depth = depth; glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBindTexture(GL_TEXTURE_3D, m_DataTextureName); m_Extensions.glTexImage3D(GL_TEXTURE_3D, 0, GL_COLOR_INDEX8_EXT, width, height, depth, 1, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, data); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // test for error error = glGetError(); if (error == GL_NO_ERROR) { m_UsingColorMap = true; m_DataLoaded = true; return true; } else { m_DataLoaded = false; return false; } #elif GL_SGI_texture_color_table // use SGI's color table system // clear previous errors GLenum error = glGetError(); // save the width height and depth m_Width = width; m_Height = height; m_Depth = depth; glBindTexture(GL_TEXTURE_3D, m_DataTextureName); glTexImage3D(GL_TEXTURE_3D, 1, GL_INTENSITY, width, height, depth, 0, GL_INTENSITY, GL_UNSIGNED_BYTE, data); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // test for error error = glGetError(); if (error == GL_NO_ERROR) { glEnable(GL_TEXTURE_COLOR_TABLE_SGI); m_UsingColorMap = true; m_DataLoaded = true; return true; } else { m_DataLoaded = false; return false; } #else return false; #endif // GL_EXT_paletted_texture */ } bool Renderer::testColorMappedData(int width, int height, int depth) { return m_Colormapped->testColormappedData(width, height, depth); } bool Renderer::testColorMappedDataWithBorder(int width, int height, int depth) { return false; /* #ifdef GL_EXT_paletted_texture // nothing above 512 if (width>514 || height>514 || depth>514) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; m_Extensions.glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_COLOR_INDEX8_EXT, width, height, depth, 1, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } #elif GL_SGI_texture_color_table // use SGI's color table system // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; glTexImage3D(GL_PROXY_TEXTURE_3D_EXT, 1, GL_INTENSITY, width, height, depth, 0, GL_INTENSITY, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } #else return false; #endif // GL_EXT_paletted_texture */ } bool Renderer::uploadRGBAData(const GLubyte* data, int width, int height, int depth) { if (m_RGBA && m_RGBA->uploadRGBAData(data, width, height, depth)) { m_UseColormapped = false; m_DataLoaded = true; return true; } else { return false; } } bool Renderer::uploadGradients(const GLubyte* data, int width, int height, int depth) { return false; } bool Renderer::calculateGradientsFromDensities(const GLubyte* data, int width, int height, int depth) { return false; /* GLubyte* grads = new GLubyte[width*height*depth*4]; double dx,dy,dz,length; int k, j, i, inputindex, outputindex; int negXOffset, posXOffset; int negYOffset, posYOffset; int negZOffset, posZOffset; for (k=0; kuploadColorMap(colorMap)); } int Renderer::getNumberOfPlanesRendered() const { if (m_UseColormapped && m_Colormapped) return m_Colormapped->getNumberOfPlanesRendered(); else if (m_RGBA) return m_RGBA->getNumberOfPlanesRendered(); else return 0; } bool Renderer::renderVolume() { if (m_UseColormapped) return (m_Colormapped?m_Colormapped->renderVolume():false); else return (m_RGBA?m_RGBA->renderVolume():false); } bool Renderer::initColormappedRenderer() { // first we try the paletted version which we know works on // Nvidia m_Colormapped = new PalettedImpl; if (m_Colormapped->initRenderer()) { return true; } // failed delete m_Colormapped; m_Colormapped = 0; // looks like NVIDIA might not support the paletted texture // extension any more, this is the alternative m_Colormapped = new FragmentProgramImpl; if (m_Colormapped->initRenderer()) { return true; } // failed delete m_Colormapped; m_Colormapped = 0; // This should work on ATI's and NVidia cards m_Colormapped = new FragmentProgramARBImpl; if (m_Colormapped->initRenderer()) { return true; } // failed delete m_Colormapped; m_Colormapped = 0; // try a 2d paletted version m_Colormapped = new Paletted2DImpl; if (m_Colormapped->initRenderer()) { return true; } // failed delete m_Colormapped; m_Colormapped = 0; // next we try the sgi version m_Colormapped = new SGIColorTableImpl; if (m_Colormapped->initRenderer()) { return true; } // failed, out of options delete m_Colormapped; m_Colormapped = 0; return false; } bool Renderer::initRGBARenderer() { // this should work on most platforms m_RGBA = new SimpleRGBAImpl; if (m_RGBA->initRenderer()) { return true; } // failed delete m_RGBA; m_RGBA = 0; m_RGBA = new SimpleRGBA2DImpl; if (m_RGBA->initRenderer()) { return true; } // failed delete m_RGBA; m_RGBA = 0; return false; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/ExtensionPointers.h0000644000175000017500000010552010223377127026435 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef EXTENSIONPOINTERS_H #define EXTENSIONPOINTERS_H // This file supports the following extensions: // GL_EXT_paletted_texture GL_ARB_multitexture // GL_SGI_color_table GL_SGI_texture_color_table GL_EXT_texture3D // OpenGL version 1.2 typedef void (APIENTRY * MYPFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); typedef void (APIENTRY * MYPFNGLBLENDEQUATIONPROC) (GLenum mode); typedef void (APIENTRY * MYPFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); typedef void (APIENTRY * MYPFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRY * MYPFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); typedef void (APIENTRY * MYPFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); typedef void (APIENTRY * MYPFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); typedef void (APIENTRY * MYPFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); typedef void (APIENTRY * MYPFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); typedef void (APIENTRY * MYPFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRY * MYPFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); typedef void (APIENTRY * MYPFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); typedef void (APIENTRY * MYPFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); typedef void (APIENTRY * MYPFNGLRESETHISTOGRAMPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLRESETMINMAXPROC) (GLenum target); typedef void (APIENTRY * MYPFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * MYPFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * MYPFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); // End OpenGL version 1.2 // OpenGL version 1.3 typedef void (APIENTRY * MYPFNGLACTIVETEXTUREPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m); typedef void (APIENTRY * MYPFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m); typedef void (APIENTRY * MYPFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m); typedef void (APIENTRY * MYPFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m); typedef void (APIENTRY * MYPFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); typedef void (APIENTRY * MYPFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, GLvoid *img); // End OpenGL version 1.3 // OpenGL version 1.4 typedef void (APIENTRY * MYPFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); typedef void (APIENTRY * MYPFNGLFOGCOORDFPROC) (GLfloat coord); typedef void (APIENTRY * MYPFNGLFOGCOORDFVPROC) (const GLfloat *coord); typedef void (APIENTRY * MYPFNGLFOGCOORDDPROC) (GLdouble coord); typedef void (APIENTRY * MYPFNGLFOGCOORDDVPROC) (const GLdouble *coord); typedef void (APIENTRY * MYPFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); typedef void (APIENTRY * MYPFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); typedef void (APIENTRY * MYPFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); typedef void (APIENTRY * MYPFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); typedef void (APIENTRY * MYPFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2DVPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2FVPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS2IPROC) (GLint x, GLint y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2IVPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLWINDOWPOS2SVPROC) (const GLshort *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3DVPROC) (const GLdouble *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3FVPROC) (const GLfloat *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3IVPROC) (const GLint *v); typedef void (APIENTRY * MYPFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLWINDOWPOS3SVPROC) (const GLshort *v); // End OpenGL version 1.4 // GL_EXT_paletted_texture typedef void (APIENTRY * MYPFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); // End GL_EXT_paletted_texture // GL_ARB_multitexture typedef void (APIENTRY * MYPFNGLACTIVETEXTUREARBPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); typedef void (APIENTRY * MYPFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table typedef void (APIENTRY * MYPFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params); typedef void (APIENTRY * MYPFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params); typedef void (APIENTRY * MYPFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); typedef void (APIENTRY * MYPFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params); // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D typedef void (APIENTRY * MYPFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); typedef void (APIENTRY * MYPFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); // End GL_EXT_texture3D // GL_NV_fragment_program typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v); typedef void (APIENTRY * MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v); typedef void (APIENTRY * MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params); // End GL_NV_fragment_program // GL_NV_vertex_program typedef GLboolean (APIENTRY * MYPFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint *programs, GLboolean *residences); typedef void (APIENTRY * MYPFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); typedef void (APIENTRY * MYPFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRY * MYPFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat *params); typedef void (APIENTRY * MYPFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *programs); typedef void (APIENTRY * MYPFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte *program); typedef void (APIENTRY * MYPFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRY * MYPFNGLISPROGRAMNVPROC) (GLuint id); typedef void (APIENTRY * MYPFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRY * MYPFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, const GLubyte *v); // End GL_NV_vertex_program // GL_ARB_vertex_program typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort *v); typedef void (APIENTRY * MYPFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); typedef void (APIENTRY * MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (APIENTRY * MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); typedef void (APIENTRY * MYPFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); typedef void (APIENTRY * MYPFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); typedef void (APIENTRY * MYPFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs); typedef void (APIENTRY * MYPFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); typedef void (APIENTRY * MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params); typedef void (APIENTRY * MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid* *pointer); typedef GLboolean (APIENTRY * MYPFNGLISPROGRAMARBPROC) (GLuint program); // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program /// WGL extensions follows #if defined(WIN32) // WGL_ARB_pixel_format typedef BOOL (WINAPI * MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues); typedef BOOL (WINAPI * MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues); typedef BOOL (WINAPI * MYPFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); // End WGL_ARB_pixel_format // WGL_ARB_pbuffer typedef HPBUFFERARB (WINAPI * MYPFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); typedef HDC (WINAPI * MYPFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); typedef int (WINAPI * MYPFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); typedef BOOL (WINAPI * MYPFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); typedef BOOL (WINAPI * MYPFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue); // End WGL_ARB_pbuffer // WGL_ARB_render_texture typedef BOOL (WINAPI * MYPFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); typedef BOOL (WINAPI * MYPFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); typedef BOOL (WINAPI * MYPFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList); // End WGL_ARB_render_texture // WGL_ARB_extensions_string typedef const char * (WINAPI * MYPFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); // End WGL_ARB_extensions_string #endif // defined(WIN32) #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeLibrary.dsp0000644000175000017500000001305210223377127026066 0ustar debiandebian# Microsoft Developer Studio Project File - Name="VolumeLibrary" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=VolumeLibrary - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "VolumeLibrary.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "VolumeLibrary.mak" CFG="VolumeLibrary - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "VolumeLibrary - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "VolumeLibrary - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "VolumeLibrary - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "VolumeLibrary - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "VolumeLibrary - Win32 Release" # Name "VolumeLibrary - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\ClipCube.cpp # End Source File # Begin Source File SOURCE=.\Extent.cpp # End Source File # Begin Source File SOURCE=.\FragmentProgramARBImpl.cpp # End Source File # Begin Source File SOURCE=.\FragmentProgramImpl.cpp # End Source File # Begin Source File SOURCE=.\MyExtensions.cpp # End Source File # Begin Source File SOURCE=.\Paletted2DImpl.cpp # End Source File # Begin Source File SOURCE=.\PalettedImpl.cpp # End Source File # Begin Source File SOURCE=.\Plane.cpp # End Source File # Begin Source File SOURCE=.\Polygon.cpp # End Source File # Begin Source File SOURCE=.\PolygonArray.cpp # End Source File # Begin Source File SOURCE=.\Renderer.cpp # End Source File # Begin Source File SOURCE=.\RendererBase.cpp # End Source File # Begin Source File SOURCE=.\RGBABase.cpp # End Source File # Begin Source File SOURCE=.\SGIColorTableImpl.cpp # End Source File # Begin Source File SOURCE=.\SimpleRGBA2DImpl.cpp # End Source File # Begin Source File SOURCE=.\SimpleRGBAImpl.cpp # End Source File # Begin Source File SOURCE=.\UnshadedBase.cpp # End Source File # Begin Source File SOURCE=.\VolumeRenderer.cpp # End Source File # Begin Source File SOURCE=.\VolumeRendererFactory.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\ClipCube.h # End Source File # Begin Source File SOURCE=.\ExtensionPointers.h # End Source File # Begin Source File SOURCE=.\Extent.h # End Source File # Begin Source File SOURCE=.\FragmentProgramARBImpl.h # End Source File # Begin Source File SOURCE=.\FragmentProgramImpl.h # End Source File # Begin Source File SOURCE=.\LookupTables.h # End Source File # Begin Source File SOURCE=.\MyExtensions.h # End Source File # Begin Source File SOURCE=.\Paletted2DImpl.h # End Source File # Begin Source File SOURCE=.\PalettedImpl.h # End Source File # Begin Source File SOURCE=.\Plane.h # End Source File # Begin Source File SOURCE=.\Polygon.h # End Source File # Begin Source File SOURCE=.\PolygonArray.h # End Source File # Begin Source File SOURCE=.\Renderer.h # End Source File # Begin Source File SOURCE=.\RendererBase.h # End Source File # Begin Source File SOURCE=.\RGBABase.h # End Source File # Begin Source File SOURCE=.\SGIColorTableImpl.h # End Source File # Begin Source File SOURCE=.\SimpleRGBA2DImpl.h # End Source File # Begin Source File SOURCE=.\SimpleRGBAImpl.h # End Source File # Begin Source File SOURCE=.\StaticExtensionPointers.h # End Source File # Begin Source File SOURCE=.\UnshadedBase.h # End Source File # Begin Source File SOURCE=.\VolumeRenderer.h # End Source File # Begin Source File SOURCE=.\VolumeRendererFactory.h # End Source File # End Group # End Target # End Project mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Renderer.h0000644000175000017500000000545710223377127024513 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Renderer.h: interface for the Renderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_RENDERER_H__458FC25A_6D79_4B38_AF34_B758C4C43596__INCLUDED_) #define AFX_RENDERER_H__458FC25A_6D79_4B38_AF34_B758C4C43596__INCLUDED_ #include "Plane.h" #include "MyExtensions.h" #include "UnshadedBase.h" #include "RGBABase.h" namespace OpenGLVolumeRendering { /// Automatically initializes a colormapped and non-colormapped volume renderer. class Renderer { public: Renderer(); virtual ~Renderer(); bool initRenderer(); bool setAspectRatio(double ratioX, double ratioY, double ratioZ); bool setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ); bool setQuality(double quality); double getQuality() const; bool setNearPlane(double nearPlane); double getNearPlane(); bool isShadedRenderingAvailable() const; bool enableShadedRendering(); bool disableShadedRendering(); bool uploadColorMappedData(const GLubyte* data, int width, int height, int depth); bool uploadColorMappedDataWithBorder(const GLubyte* data, int width, int height, int depth); bool testColorMappedData(int width, int height, int depth); bool testColorMappedDataWithBorder(int width, int height, int depth); bool uploadRGBAData(const GLubyte* data, int width, int height, int depth); bool uploadGradients(const GLubyte* data, int width, int height, int depth); bool calculateGradientsFromDensities(const GLubyte* data, int width, int height, int depth); bool uploadColorMap(const GLubyte* colorMap); int getNumberOfPlanesRendered() const; bool renderVolume(); protected: bool initColormappedRenderer(); bool initRGBARenderer(); bool m_UseColormapped; bool m_DataLoaded; bool initFlags(); UnshadedBase* m_Colormapped; RGBABase* m_RGBA; }; }; #endif // !defined(AFX_RENDERER_H__458FC25A_6D79_4B38_AF34_B758C4C43596__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/FragmentProgramARBImpl.cpp0000644000175000017500000001607410223377127027537 0ustar debiandebian// FragmentProgramARBImpl.cpp: implementation of the FragmentProgramARBImpl class. // ////////////////////////////////////////////////////////////////////// #include "FragmentProgramARBImpl.h" #include using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// FragmentProgramARBImpl::FragmentProgramARBImpl() { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; } FragmentProgramARBImpl::~FragmentProgramARBImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool FragmentProgramARBImpl::initRenderer() { if (!UnshadedBase::initRenderer() || !initExtensions() || !initTextureNames() || !initFragmentProgram()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool FragmentProgramARBImpl::checkCompatibility() const { return MyExtensions::checkExtensions( "GL_VERSION_1_3 " "GL_ARB_vertex_program " "GL_ARB_fragment_program " "GL_ARB_multitexture " ); } // Uploads colormapped data bool FragmentProgramARBImpl::uploadColormappedData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_3D, m_DataTextureName); if (width!=m_Width || height!=m_Height || depth!=m_Depth) { m_Extensions.glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE, width, height, depth, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); } else { m_Extensions.glTexSubImage3D(GL_TEXTURE_3D, 0, 0,0,0, width, height, depth, GL_LUMINANCE, GL_UNSIGNED_BYTE, data); } glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // save the width height and depth m_Width = width; m_HintDimX = width; m_Height = height; m_HintDimY = height; m_Depth = depth; m_HintDimZ = depth; // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Tests to see if the given parameters would return an error bool FragmentProgramARBImpl::testColormappedData(int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // nothing above 512 if (width>512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; m_Extensions.glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_LUMINANCE, width, height, depth, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Uploads the transfer function for the colormapped data bool FragmentProgramARBImpl::uploadColorMap(const GLubyte* colorMap) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); glBindTexture(GL_TEXTURE_1D, m_TransferTextureName); glTexImage1D(GL_TEXTURE_1D, 0, 4, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, colorMap); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Performs the actual rendering. bool FragmentProgramARBImpl::renderVolume() { // bail if we haven't been initialized properly if (!m_Initialized) return false; // set up the state glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColor4f(1.0, 1.0, 1.0, 1.0); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); // get the fragment program ready glEnable(GL_FRAGMENT_PROGRAM_ARB); m_Extensions.glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_FragmentProgramName); //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDepthMask( GL_FALSE ); // bind the transfer function m_Extensions.glActiveTextureARB(GL_TEXTURE1_ARB); glEnable(GL_TEXTURE_1D); glBindTexture(GL_TEXTURE_1D, m_TransferTextureName); // bind the data texture m_Extensions.glActiveTextureARB(GL_TEXTURE0_ARB); glEnable(GL_TEXTURE_3D); glBindTexture(GL_TEXTURE_3D, m_DataTextureName); computePolygons(); convertToTriangles(); renderTriangles(); // unbind the fragment program m_Extensions.glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0); // restore the state glPopAttrib(); return true; } // Initializes the necessary extensions. bool FragmentProgramARBImpl::initExtensions() { return m_Extensions.initExtensions( "GL_VERSION_1_3 " "GL_ARB_vertex_program " "GL_ARB_fragment_program " "GL_ARB_multitexture " ); } // Gets the opengl texture IDs bool FragmentProgramARBImpl::initTextureNames() { // clear previous errors GLenum error = glGetError(); // get the names glGenTextures(1, &m_DataTextureName); glGenTextures(1, &m_TransferTextureName); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Gets the fragment program ready bool FragmentProgramARBImpl::initFragmentProgram() { // clear previous errors GLenum error = glGetError(); m_Extensions.glGenProgramsARB(1, &m_FragmentProgramName); const GLubyte program[] = "!!ARBfp1.0\n" "PARAM c0 = {0.5, 1, 2.7182817, 0};\n" "TEMP R0;\n" "TEX R0.x, fragment.texcoord[0].xyzx, texture[0], 3D;\n" "TEX result.color, R0.x, texture[1], 1D;\n" "END\n"; int len = strlen((const char*)program); m_Extensions.glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, m_FragmentProgramName); m_Extensions.glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, len, program); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Render the actual triangles void FragmentProgramARBImpl::renderTriangles() { // set up the client render state glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); glTexCoordPointer(3, GL_FLOAT, 0, m_TextureArray); glVertexPointer(3, GL_FLOAT, 0, m_VertexArray); // render the triangles glDrawElements(GL_TRIANGLES, m_NumTriangles*3, GL_UNSIGNED_INT, m_TriangleArray); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SimpleRGBA2DImpl.h0000644000175000017500000000666510223377127025644 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // SimpleRGBA2DImpl.h: interface for the SimpleRGBA2DImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_SIMPLERGBA2DIMPL_H__8C4198A4_07E0_410D_8D89_F33349061124__INCLUDED_) #define AFX_SIMPLERGBA2DIMPL_H__8C4198A4_07E0_410D_8D89_F33349061124__INCLUDED_ #include "RGBABase.h" namespace OpenGLVolumeRendering { /// A non-colormapped volume renderer which only requires 2D texturing. class SimpleRGBA2DImpl : public RGBABase { public: SimpleRGBA2DImpl(); virtual ~SimpleRGBA2DImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadRGBAData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testRGBAData(int width, int height, int depth); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; unsigned int m_NumAllocated[3]; GLuint* m_DataTextureNameX; GLuint* m_DataTextureNameY; GLuint* m_DataTextureNameZ; unsigned int m_RenderDirection; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Computes the polygons that need to be rendered virtual void computePolygons(); // Renders the computed polygons virtual void renderPolygons(); // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(unsigned int x, unsigned int y, unsigned int z); // Render the actual triangles void renderTriangles(); // Sets the currently bound texture parameters void setTextureParameters(); // Gets a single slice along the y-axis void getYSlice(GLubyte* dest, const GLubyte* source, unsigned int sliceNum, unsigned int width, unsigned int height, unsigned int depth); // Gets a single slice along the x-axis void getXSlice(GLubyte* dest, const GLubyte* source, unsigned int sliceNum, unsigned int width, unsigned int height, unsigned int depth); }; }; #endif // !defined(AFX_SIMPLERGBA2DIMPL_H__8C4198A4_07E0_410D_8D89_F33349061124__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Paletted2DImpl.h0000644000175000017500000000723310223377127025511 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Paletted2DImpl.h: interface for the Paletted2DImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_PALETTED2DIMPL_H__92BAADF9_254C_4539_9BDA_4D1D50EBBFBC__INCLUDED_) #define AFX_PALETTED2DIMPL_H__92BAADF9_254C_4539_9BDA_4D1D50EBBFBC__INCLUDED_ #include "UnshadedBase.h" #include "MyExtensions.h" namespace OpenGLVolumeRendering { /// A volume renderer which uses the paletted textures extension to do color /// mapping. Only requires support for 2D textures class Paletted2DImpl : public UnshadedBase { public: Paletted2DImpl(); virtual ~Paletted2DImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadColormappedData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testColormappedData(int width, int height, int depth); // Uploads the transfer function for the colormapped data virtual bool uploadColorMap(const GLubyte* colorMap); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; // The opengl texture IDs unsigned int m_NumAllocated[3]; bool m_ColorMapDirty[3]; GLubyte m_ColorMap[256*4]; GLuint* m_DataTextureNameX; GLuint* m_DataTextureNameY; GLuint* m_DataTextureNameZ; unsigned int m_RenderDirection; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Computes the polygons that need to be rendered virtual void computePolygons(); // Renders the computed polygons virtual void renderPolygons(); // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(unsigned int x, unsigned int y, unsigned int z); // Sets the currently bound texture parameters void setTextureParameters(); // Gets a single slice along the y-axis void getYSlice(GLubyte* dest, const GLubyte* source, unsigned int sliceNum, unsigned int width, unsigned int height, unsigned int depth); // Gets a single slice along the x-axis void getXSlice(GLubyte* dest, const GLubyte* source, unsigned int sliceNum, unsigned int width, unsigned int height, unsigned int depth); }; }; #endif // !defined(AFX_PALETTED2DIMPL_H__92BAADF9_254C_4539_9BDA_4D1D50EBBFBC__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeRenderer.cpp0000644000175000017500000001063710223377127026232 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // VolumeRenderer.cpp: implementation of the VolumeRenderer class. // ////////////////////////////////////////////////////////////////////// #include "VolumeRenderer.h" #include "Renderer.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// VolumeRenderer::VolumeRenderer() { m_PrivateRenderer = new OpenGLVolumeRendering::Renderer; } VolumeRenderer::VolumeRenderer(const VolumeRenderer& copy) : m_PrivateRenderer(new OpenGLVolumeRendering::Renderer(*(copy.m_PrivateRenderer))) { } VolumeRenderer& VolumeRenderer::operator=(const VolumeRenderer& copy) { if (this != & copy) { delete m_PrivateRenderer; m_PrivateRenderer = new OpenGLVolumeRendering::Renderer(*(copy.m_PrivateRenderer)); } return *this; } VolumeRenderer::~VolumeRenderer() { delete m_PrivateRenderer; } bool VolumeRenderer::initRenderer() { return m_PrivateRenderer->initRenderer(); } bool VolumeRenderer::setAspectRatio(double ratioX, double ratioY, double ratioZ) { return m_PrivateRenderer->setAspectRatio(ratioX, ratioY, ratioZ); } bool VolumeRenderer::setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ) { return m_PrivateRenderer->setTextureSubCube(minX, minY, minZ, maxX, maxY, maxZ); } bool VolumeRenderer::setQuality(double quality) { return m_PrivateRenderer->setQuality(quality); } double VolumeRenderer::getQuality() const { return m_PrivateRenderer->getQuality(); } bool VolumeRenderer::setNearPlane(double nearPlane) { return m_PrivateRenderer->setNearPlane(nearPlane); } double VolumeRenderer::getNearPlane() { return m_PrivateRenderer->getNearPlane(); } bool VolumeRenderer::isShadedRenderingAvailable() const { return m_PrivateRenderer->isShadedRenderingAvailable(); } bool VolumeRenderer::enableShadedRendering() { return m_PrivateRenderer->enableShadedRendering(); } bool VolumeRenderer::disableShadedRendering() { return m_PrivateRenderer->disableShadedRendering(); } bool VolumeRenderer::uploadColorMappedData(const GLubyte* data, int width, int height, int depth) { return m_PrivateRenderer->uploadColorMappedData(data, width, height, depth); } bool VolumeRenderer::uploadColorMappedDataWithBorder(const GLubyte* data, int width, int height, int depth) { return m_PrivateRenderer->uploadColorMappedDataWithBorder(data, width, height, depth); } bool VolumeRenderer::testColorMappedData(int width, int height, int depth) { return m_PrivateRenderer->testColorMappedData(width, height, depth); } bool VolumeRenderer::testColorMappedDataWithBorder(int width, int height, int depth) { return m_PrivateRenderer->testColorMappedDataWithBorder(width, height, depth); } bool VolumeRenderer::uploadRGBAData(const GLubyte* data, int width, int height, int depth) { return m_PrivateRenderer->uploadRGBAData(data, width, height, depth); } bool VolumeRenderer::uploadGradients(const GLubyte* data, int width, int height, int depth) { return m_PrivateRenderer->uploadGradients(data, width, height, depth); } bool VolumeRenderer::calculateGradientsFromDensities(const GLubyte* data, int width, int height, int depth) { return m_PrivateRenderer->calculateGradientsFromDensities(data, width, height, depth); } bool VolumeRenderer::uploadColorMap(const GLubyte* colorMap) { return m_PrivateRenderer->uploadColorMap(colorMap); } int VolumeRenderer::getNumberOfPlanesRendered() const { return m_PrivateRenderer->getNumberOfPlanesRendered(); } bool VolumeRenderer::renderVolume() { return m_PrivateRenderer->renderVolume(); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/FragmentProgramImpl.h0000644000175000017500000000614710223377127026657 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // FragmentProgramImpl.h: interface for the FragmentProgramImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_FRAGMENTPROGRAMIMPL_H__D8FF5B4D_CD18_4685_A07C_EFD3D788F54A__INCLUDED_) #define AFX_FRAGMENTPROGRAMIMPL_H__D8FF5B4D_CD18_4685_A07C_EFD3D788F54A__INCLUDED_ #include "UnshadedBase.h" #include "MyExtensions.h" namespace OpenGLVolumeRendering { /// A volume renderer which uses NVidias fragment programming to perform /// color mapping class FragmentProgramImpl : public UnshadedBase { public: FragmentProgramImpl(); virtual ~FragmentProgramImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadColormappedData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testColormappedData(int width, int height, int depth); // Uploads the transfer function for the colormapped data virtual bool uploadColorMap(const GLubyte* colorMap); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; // The opengl texture ID GLuint m_DataTextureName; // The transfer function texture ID GLuint m_TransferTextureName; // The ID of the fragment program GLuint m_FragmentProgramName; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(); // Gets the fragment program ready bool initFragmentProgram(); // Render the actual triangles void renderTriangles(); }; }; #endif // !defined(AFX_FRAGMENTPROGRAMIMPL_H__D8FF5B4D_CD18_4685_A07C_EFD3D788F54A__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SimpleExample.cpp0000644000175000017500000001231710223377127026036 0ustar debiandebian#include "SimpleExample.h" #include #include #ifdef __APPLE__ #include #else #include #endif // header file for the volume renderer #include /* Global Variables */ int W=640; int H=480; int mousex; int mousey; int cdx = 0; int cdy = 0; int whichbutton; int state = ROTATE; VolumeRenderer volumeRenderer; GLdouble rotMatrix[16]; GLdouble transMatrix[16]; /// the following 3 functions show the interaction with the volume renderer void InitVolumeRenderer() { if (!volumeRenderer.initRenderer()) { printf("Warning, there was an error initializing the volume renderer\n"); } } void InitData() { // load the colormap from a file unsigned char byte_map[256*4]; FILE* fp; // load the data from a file fp = fopen( "/home/annao/python/work/vh4.rawiv", "rb" ); if (!fp) { printf("There was an error loading the data file\n"); exit(1); } unsigned char* data = new unsigned char[128*128*128]; // skip the header fread(data, sizeof(unsigned char), 68, fp); printf("Reading the data file\n"); // load the data fread(data, sizeof(unsigned char), 128*128*128, fp); // send the data to the volume renderer if (!volumeRenderer.uploadColorMappedData(data, 128, 128, 128)) { // woops, maybe color mapped data wasnt supported } // commenting this out since shaded rendering isnt finished yet //printf("Calculating gradients\n"); //volumeRenderer.calculateGradientsFromDensities(data, 128, 128, 128); delete [] data; fclose(fp); fp = fopen( "/home/annao/python/work/colormap.map", "rb" ); if (!fp) { printf("There was an error loading the color map\n"); exit(1); } fread(byte_map, sizeof(unsigned char), 256*4, fp); fclose(fp); volumeRenderer.uploadColorMap(byte_map); } void Display() { // Clear the buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Set up the modelview matrix glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslated(0.0, 0.0, -4.0); glMultMatrixd(transMatrix); glMultMatrixd(rotMatrix); // the volume is rendered volumeRenderer.renderVolume(); glutSwapBuffers(); } int BeginGraphics (int* argc, char** argv, const char* name) { int win; glutInit(argc,argv); glutInitWindowSize(W,H); glutInitWindowPosition(100,100); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); win = glutCreateWindow(name); glutSetWindow(win); init(); RegisterCallbacks(); glutMainLoop(); return 0; } void RegisterCallbacks() { glutDisplayFunc(Display); glutIdleFunc(Idle); glutMouseFunc(MouseButton); glutMotionFunc(MouseMove); glutKeyboardFunc(Keyboard); } void init() { InitProjection(); InitModelMatrix(); InitLighting(); InitState(); InitVolumeRenderer(); InitData(); } void InitProjection() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective( 30.0, (GLdouble) W / (GLdouble) H, 0.01, 20.0 ); } void InitModelMatrix() { glMatrixMode(GL_MODELVIEW); glLoadIdentity(); /* initialize rotMatrix and transMatrix to the identity */ glGetDoublev(GL_MODELVIEW_MATRIX, rotMatrix); glGetDoublev(GL_MODELVIEW_MATRIX, transMatrix); } void InitLighting() { GLfloat lightdir[] = {-1.0, 1.0, 1.0, 0.0}; glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glLightfv(GL_LIGHT0, GL_POSITION, lightdir); glEnable(GL_NORMALIZE); } void InitState() { glClearColor(0.2, 0.2, 0.2, 1.0); glColor4d(1.0, 1.0, 1.0, 1.0); glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); glEnable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); } void Idle() { Rotate(cdx, cdy); glutPostRedisplay(); } /* Callback function for the mouse button */ void MouseButton(int button, int mstate, int x, int y) { /* sets the initial positions for mousex and mousey */ if (mstate == GLUT_DOWN) { mousex = x; mousey = y; whichbutton = button; cdx = 0; cdy = 0; } } /* Callback function for the mouse motion */ void MouseMove(int x, int y) { int dx = x-mousex; int dy = y-mousey; switch (state) { case ROTATE: Rotate(dx, dy); break; case TRANSLATE: if (whichbutton == GLUT_LEFT_BUTTON) Translate(dx, -dy,0); else Translate(0,0,-dy); break; } mousex = x; mousey = y; glutPostRedisplay(); } void Keyboard(unsigned char key, int x, int y) { switch (key) { case 'r': case 'R': state = ROTATE; break; case 't': case 'T': state = TRANSLATE; break; } } void Rotate(int dx, int dy) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glRotated(((double)dy), 1.0, 0.0, 0.0); glRotated(((double)dx), 0.0, 1.0, 0.0); glMultMatrixd(rotMatrix); glGetDoublev(GL_MODELVIEW_MATRIX, rotMatrix); glPopMatrix(); } void Translate(int dx, int dy, int dz) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glTranslated(((double)dx)/100.0, ((double)dy)/100.0, ((double)dz)/10.0); glMultMatrixd(transMatrix); glGetDoublev(GL_MODELVIEW_MATRIX, transMatrix); glPopMatrix(); } int main(int argc, char** argv) { BeginGraphics(&argc, argv, "Simple Example"); // glEnable(GL_TEXTURE_COLOR_TABLE_SGI); // GLenum errCode; // errCode = glGetError(); // if (errCode!=GL_NO_ERROR) // printf ("GL ERROR-%d %s \n", errCode, gluErrorString(errCode)); // if (!glIsEnabled(GL_TEXTURE_COLOR_TABLE_SGI)) // printf ("drawPolygon: GL_TEXTURE_3D is *NOT* enabled\n"); return 0; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Plane.h0000644000175000017500000000561410223377127023777 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Plane.h: interface for the Plane class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_PLANE_H__04F216E9_22AB_4373_9CF5_754D66B0F950__INCLUDED_) #define AFX_PLANE_H__04F216E9_22AB_4373_9CF5_754D66B0F950__INCLUDED_ namespace OpenGLVolumeRendering { /** Encapsulates a plane */ class Plane { public: Plane(); Plane(double a, double b, double c, double d); virtual ~Plane(); double signedDistance(double x, double y, double z) const; void normalizeNormal(); inline double& operator[](unsigned int index); inline const double& operator[](unsigned int index) const; inline double& a(); inline double& b(); inline double& c(); inline double& d(); inline const double& a() const; inline const double& b() const; inline const double& c() const; inline const double& d() const; protected: double m_A, m_B, m_C, m_D; }; }; inline double& OpenGLVolumeRendering::Plane::operator[](unsigned int index) { if (index == 0) { return m_A; } else if (index == 1) { return m_B; } else if (index == 2) { return m_C; } else { return m_D; } } inline const double& OpenGLVolumeRendering::Plane::operator[](unsigned int index) const { if (index == 0) { return m_A; } else if (index == 1) { return m_B; } else if (index == 2) { return m_C; } else { return m_D; } } inline double& OpenGLVolumeRendering::Plane::a() { return m_A; } inline double& OpenGLVolumeRendering::Plane::b() { return m_B; } inline double& OpenGLVolumeRendering::Plane::c() { return m_C; } inline double& OpenGLVolumeRendering::Plane::d() { return m_D; } inline const double& OpenGLVolumeRendering::Plane::a() const { return m_A; } inline const double& OpenGLVolumeRendering::Plane::b() const { return m_B; } inline const double& OpenGLVolumeRendering::Plane::c() const { return m_C; } inline const double& OpenGLVolumeRendering::Plane::d() const { return m_D; } #endif // !defined(AFX_OPENGLVOLUMEPLANE_H__04F216E9_22AB_4373_9CF5_754D66B0F950__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeLibrary.mak0000644000175000017500000001141510223377127026051 0ustar debiandebian# Microsoft Developer Studio Generated NMAKE File, Based on VolumeLibrary.dsp !IF "$(CFG)" == "" CFG=VolumeLibrary - Win32 Debug !MESSAGE No configuration specified. Defaulting to VolumeLibrary - Win32 Debug. !ENDIF !IF "$(CFG)" != "VolumeLibrary - Win32 Release" && "$(CFG)" != "VolumeLibrary - Win32 Debug" !MESSAGE Invalid configuration "$(CFG)" specified. !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "VolumeLibrary.mak" CFG="VolumeLibrary - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "VolumeLibrary - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "VolumeLibrary - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE !ERROR An invalid configuration is specified. !ENDIF !IF "$(OS)" == "Windows_NT" NULL= !ELSE NULL=nul !ENDIF !IF "$(CFG)" == "VolumeLibrary - Win32 Release" OUTDIR=.\Release INTDIR=.\Release # Begin Custom Macros OutDir=.\Release # End Custom Macros ALL : "$(OUTDIR)\VolumeLibrary.lib" CLEAN : -@erase "$(INTDIR)\OpenGLVolumeClipCube.obj" -@erase "$(INTDIR)\OpenGLVolumePlane.obj" -@erase "$(INTDIR)\OpenGLVolumePolygon.obj" -@erase "$(INTDIR)\OpenGLVolumeRenderer.obj" -@erase "$(INTDIR)\vc60.idb" -@erase "$(INTDIR)\VolumeRenderer.obj" -@erase "$(OUTDIR)\VolumeLibrary.lib" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe CPP_PROJ=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /Fp"$(INTDIR)\VolumeLibrary.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /c .c{$(INTDIR)}.obj:: $(CPP) @<< $(CPP_PROJ) $< << .cpp{$(INTDIR)}.obj:: $(CPP) @<< $(CPP_PROJ) $< << .cxx{$(INTDIR)}.obj:: $(CPP) @<< $(CPP_PROJ) $< << .c{$(INTDIR)}.sbr:: $(CPP) @<< $(CPP_PROJ) $< << .cpp{$(INTDIR)}.sbr:: $(CPP) @<< $(CPP_PROJ) $< << .cxx{$(INTDIR)}.sbr:: $(CPP) @<< $(CPP_PROJ) $< << RSC=rc.exe BSC32=bscmake.exe BSC32_FLAGS=/nologo /o"$(OUTDIR)\VolumeLibrary.bsc" BSC32_SBRS= \ LIB32=link.exe -lib LIB32_FLAGS=/nologo /out:"$(OUTDIR)\VolumeLibrary.lib" LIB32_OBJS= \ "$(INTDIR)\OpenGLVolumeClipCube.obj" \ "$(INTDIR)\OpenGLVolumePlane.obj" \ "$(INTDIR)\OpenGLVolumePolygon.obj" \ "$(INTDIR)\OpenGLVolumeRenderer.obj" \ "$(INTDIR)\VolumeRenderer.obj" "$(OUTDIR)\VolumeLibrary.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS) $(LIB32) @<< $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS) << !ELSEIF "$(CFG)" == "VolumeLibrary - Win32 Debug" OUTDIR=.\Debug INTDIR=.\Debug # Begin Custom Macros OutDir=.\Debug # End Custom Macros ALL : "$(OUTDIR)\VolumeLibrary.lib" CLEAN : -@erase "$(INTDIR)\OpenGLVolumeClipCube.obj" -@erase "$(INTDIR)\OpenGLVolumePlane.obj" -@erase "$(INTDIR)\OpenGLVolumePolygon.obj" -@erase "$(INTDIR)\OpenGLVolumeRenderer.obj" -@erase "$(INTDIR)\vc60.idb" -@erase "$(INTDIR)\vc60.pdb" -@erase "$(INTDIR)\VolumeRenderer.obj" -@erase "$(OUTDIR)\VolumeLibrary.lib" "$(OUTDIR)" : if not exist "$(OUTDIR)/$(NULL)" mkdir "$(OUTDIR)" CPP=cl.exe CPP_PROJ=/nologo /MLd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /Fp"$(INTDIR)\VolumeLibrary.pch" /YX /Fo"$(INTDIR)\\" /Fd"$(INTDIR)\\" /FD /GZ /c .c{$(INTDIR)}.obj:: $(CPP) @<< $(CPP_PROJ) $< << .cpp{$(INTDIR)}.obj:: $(CPP) @<< $(CPP_PROJ) $< << .cxx{$(INTDIR)}.obj:: $(CPP) @<< $(CPP_PROJ) $< << .c{$(INTDIR)}.sbr:: $(CPP) @<< $(CPP_PROJ) $< << .cpp{$(INTDIR)}.sbr:: $(CPP) @<< $(CPP_PROJ) $< << .cxx{$(INTDIR)}.sbr:: $(CPP) @<< $(CPP_PROJ) $< << RSC=rc.exe BSC32=bscmake.exe BSC32_FLAGS=/nologo /o"$(OUTDIR)\VolumeLibrary.bsc" BSC32_SBRS= \ LIB32=link.exe -lib LIB32_FLAGS=/nologo /out:"$(OUTDIR)\VolumeLibrary.lib" LIB32_OBJS= \ "$(INTDIR)\OpenGLVolumeClipCube.obj" \ "$(INTDIR)\OpenGLVolumePlane.obj" \ "$(INTDIR)\OpenGLVolumePolygon.obj" \ "$(INTDIR)\OpenGLVolumeRenderer.obj" \ "$(INTDIR)\VolumeRenderer.obj" "$(OUTDIR)\VolumeLibrary.lib" : "$(OUTDIR)" $(DEF_FILE) $(LIB32_OBJS) $(LIB32) @<< $(LIB32_FLAGS) $(DEF_FLAGS) $(LIB32_OBJS) << !ENDIF !IF "$(NO_EXTERNAL_DEPS)" != "1" !IF EXISTS("VolumeLibrary.dep") !INCLUDE "VolumeLibrary.dep" !ELSE !MESSAGE Warning: cannot find "VolumeLibrary.dep" !ENDIF !ENDIF !IF "$(CFG)" == "VolumeLibrary - Win32 Release" || "$(CFG)" == "VolumeLibrary - Win32 Debug" SOURCE=.\OpenGLVolumeClipCube.cpp "$(INTDIR)\OpenGLVolumeClipCube.obj" : $(SOURCE) "$(INTDIR)" SOURCE=.\OpenGLVolumePlane.cpp "$(INTDIR)\OpenGLVolumePlane.obj" : $(SOURCE) "$(INTDIR)" SOURCE=.\OpenGLVolumePolygon.cpp "$(INTDIR)\OpenGLVolumePolygon.obj" : $(SOURCE) "$(INTDIR)" SOURCE=.\OpenGLVolumeRenderer.cpp "$(INTDIR)\OpenGLVolumeRenderer.obj" : $(SOURCE) "$(INTDIR)" SOURCE=.\VolumeRenderer.cpp "$(INTDIR)\VolumeRenderer.obj" : $(SOURCE) "$(INTDIR)" !ENDIF mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeRendererFactory.h0000644000175000017500000000310010223377127027212 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // VolumeRendererFactory.h: interface for the VolumeRendererFactory class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_VOLUMERENDERERFACTORY_H__565249A1_B920_4AFE_8A52_D1099907333C__INCLUDED_) #define AFX_VOLUMERENDERERFACTORY_H__565249A1_B920_4AFE_8A52_D1099907333C__INCLUDED_ namespace OpenGLVolumeRendering { class RGBABase; class UnshadedBase; class VolumeRendererFactory { public: VolumeRendererFactory(); virtual ~VolumeRendererFactory(); static RGBABase* getRGBARenderer(); static UnshadedBase* getUnshadedRenderer(); }; }; #endif // !defined(AFX_VOLUMERENDERERFACTORY_H__565249A1_B920_4AFE_8A52_D1099907333C__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/PolygonArray.cpp0000644000175000017500000000447610223377127025726 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // PolygonArray.cpp: implementation of the PolygonArray class. // ////////////////////////////////////////////////////////////////////// #include "PolygonArray.h" #include "Polygon.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// PolygonArray::PolygonArray(unsigned int sizeGuess) { m_PolygonArray = 0; m_ArraySize = 0; m_NumPolygons = 0; allocateArray(sizeGuess); } PolygonArray::~PolygonArray() { delete [] m_PolygonArray; } void PolygonArray::clearPolygons() { m_NumPolygons = 0; } void PolygonArray::addPolygon(const Polygon& polygon) { doubleArray(); m_PolygonArray[m_NumPolygons] = polygon; m_NumPolygons++; } Polygon* PolygonArray::getPolygon(unsigned int i) { if (i Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Polygon.h: interface for the Polygon class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_POLYGON_H__84933946_6F6C_4BA9_9FED_C87A6E762B30__INCLUDED_) #define AFX_POLYGON_H__84933946_6F6C_4BA9_9FED_C87A6E762B30__INCLUDED_ namespace OpenGLVolumeRendering { /** Encapsulates a polygon. */ class Polygon { public: Polygon(unsigned int numVerts); Polygon(); virtual ~Polygon(); double* getVert(unsigned int index); double* getTexCoord(unsigned int index); unsigned int getNumVerts() const; void setNumVerts(unsigned int numVerts); unsigned int getNumTriangles() const; // Used to break the polygon up into triangles // Gives the vertex numbers for each vertex of each triangle inline unsigned int getVertexForTriangles(unsigned int i) const; protected: // this is not a general polygon, // it can have at most 6 verts double m_Verts[6*3]; double m_TexCoords[6*3]; unsigned int m_NumVerts; }; } // Used to break the polygon up into triangles // Gives the vertex numbers for each vertex of each triangle inline unsigned int OpenGLVolumeRendering::Polygon::getVertexForTriangles(unsigned int i) const { unsigned int vertices[] = { 0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5}; if (i<12) return vertices[i]; else return 0; } #endif // !defined(AFX_POLYGON_H__84933946_6F6C_4BA9_9FED_C87A6E762B30__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SimpleRGBAImpl.h0000644000175000017500000000534510223377127025450 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // OpenGLVolumeSimpleRGBAImpl.h: interface for the OpenGLVolumeSimpleRGBAImpl class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_OPENGLVOLUMESIMPLERGBAIMPL_H__D437055A_0A8E_4750_A9AD_3475D43DB261__INCLUDED_) #define AFX_OPENGLVOLUMESIMPLERGBAIMPL_H__D437055A_0A8E_4750_A9AD_3475D43DB261__INCLUDED_ #include "RGBABase.h" namespace OpenGLVolumeRendering { /// A non-colormapped volume renderer which requires 3D texturing class SimpleRGBAImpl : public RGBABase { public: SimpleRGBAImpl(); virtual ~SimpleRGBAImpl(); // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering virtual bool initRenderer(); // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on virtual bool checkCompatibility() const; // Uploads colormapped data virtual bool uploadRGBAData(const GLubyte* data, int width, int height, int depth); // Tests to see if the given parameters would return an error virtual bool testRGBAData(int width, int height, int depth); // Performs the actual rendering. virtual bool renderVolume(); protected: // Remembers the uploaded width height and depth int m_Width, m_Height, m_Depth; // The opengl texture ID GLuint m_DataTextureName; // Holds the pointers to the extension functions MyExtensions m_Extensions; // Flag indicating if we were successfully initialized bool m_Initialized; // Initializes the necessary extensions. virtual bool initExtensions(); // Gets the opengl texture IDs bool initTextureNames(); // Render the actual triangles void renderTriangles(); }; }; #endif // !defined(AFX_OPENGLVOLUMESIMPLERGBAIMPL_H__D437055A_0A8E_4750_A9AD_3475D43DB261__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Polygon.cpp0000644000175000017500000000340610223377127024717 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Polygon.cpp: implementation of the Polygon class. // ////////////////////////////////////////////////////////////////////// #include "Polygon.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Polygon::Polygon(unsigned int numVerts) { setNumVerts(numVerts); } Polygon::Polygon() { setNumVerts(0); } Polygon::~Polygon() { } double* Polygon::getVert(unsigned int index) { return &(m_Verts[index*3]); } double* Polygon::getTexCoord(unsigned int index) { return &(m_TexCoords[index*3]); } unsigned int Polygon::getNumVerts() const { return m_NumVerts; } void Polygon::setNumVerts(unsigned int numVerts) { m_NumVerts = (numVerts<=6 ? numVerts : 6); } unsigned int Polygon::getNumTriangles() const { return m_NumVerts-2; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeLibrary.pro0000644000175000017500000000201610223377127026076 0ustar debiandebian# qmake project generated by QMsDev # # General settings TEMPLATE = lib CONFIG += warn_off staticlib opengl create_prl TARGET += VolumeLibrary # Input SOURCES = \ ClipCube.cpp \ Extent.cpp \ FragmentProgramARBImpl.cpp \ FragmentProgramImpl.cpp \ MyExtensions.cpp \ Paletted2DImpl.cpp \ PalettedImpl.cpp \ Plane.cpp \ Polygon.cpp \ PolygonArray.cpp \ Renderer.cpp \ RendererBase.cpp \ RGBABase.cpp \ SGIColorTableImpl.cpp \ SimpleRGBA2DImpl.cpp \ SimpleRGBAImpl.cpp \ UnshadedBase.cpp \ VolumeRenderer.cpp \ VolumeRendererFactory.cpp HEADERS = \ ClipCube.h \ ExtensionPointers.h \ Extent.h \ FragmentProgramARBImpl.h \ FragmentProgramImpl.h \ LookupTables.h \ MyExtensions.h \ Paletted2DImpl.h \ PalettedImpl.h \ Plane.h \ Polygon.h \ PolygonArray.h \ Renderer.h \ RendererBase.h \ RGBABase.h \ SGIColorTableImpl.h \ SimpleRGBA2DImpl.h \ SimpleRGBAImpl.h \ StaticExtensionPointers.h \ UnshadedBase.h \ VolumeRenderer.h \ VolumeRendererFactory.h mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SimpleRGBA2DImpl.cpp0000644000175000017500000003210710223377127026165 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // SimpleRGBA2DImpl.cpp: implementation of the SimpleRGBA2DImpl class. // ////////////////////////////////////////////////////////////////////// #include "SimpleRGBA2DImpl.h" #include #include "ClipCube.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// SimpleRGBA2DImpl::SimpleRGBA2DImpl() { m_Width = -1; m_Height = -1; m_Depth = -1; m_Initialized = false; m_NumAllocated[0] = 0; m_NumAllocated[1] = 0; m_NumAllocated[2] = 0; m_DataTextureNameX = 0; m_DataTextureNameY = 0; m_DataTextureNameZ = 0; } SimpleRGBA2DImpl::~SimpleRGBA2DImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool SimpleRGBA2DImpl::initRenderer() { if (!RGBABase::initRenderer() || !initExtensions()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool SimpleRGBA2DImpl::checkCompatibility() const { MyExtensions tempExtensions; if (!tempExtensions.initExtensions("GL_VERSION_1_2 ") && !tempExtensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return true; } // Uploads colormapped data bool SimpleRGBA2DImpl::uploadRGBAData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); if (width!=m_Width || height!=m_Height || depth!=m_Depth) { if (!initTextureNames(width, height, depth)) { return false; } int c; for (c=0; c512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, depth, width, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_RGBA, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Performs the actual rendering. bool SimpleRGBA2DImpl::renderVolume() { // bail if we haven't been initialized properly if (!m_Initialized) return false; // set up the state glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColor4f(1.0, 1.0, 1.0, 1.0); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glEnable(GL_COLOR_TABLE); // This is for the paletted_texture color table //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDepthMask( GL_FALSE ); computePolygons(); renderPolygons(); // restore the state glPopAttrib(); return true; } // Initializes the necessary extensions. bool SimpleRGBA2DImpl::initExtensions() { if (!m_Extensions.initExtensions("GL_VERSION_1_2 ") && !m_Extensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return true; } // Computes the polygons that need to be rendered void SimpleRGBA2DImpl::computePolygons() { m_PolygonArray.clearPolygons(); // chose a plane with normal parallel to the primary viewing direction Plane plane = getViewPlane(); if (fabs(plane.a())>fabs(plane.b()) && fabs(plane.a())>fabs(plane.c())) { plane.b()=0.0; plane.c()=0.0; plane.d()=0.0; plane.normalizeNormal(); m_RenderDirection = 0; } else if (fabs(plane.b())>fabs(plane.c())) { plane.a()=0.0; plane.c()=0.0; plane.d()=0.0; plane.normalizeNormal(); m_RenderDirection = 1; } else { plane.a()=0.0; plane.b()=0.0; plane.d()=0.0; plane.normalizeNormal(); m_RenderDirection = 2; } ClipCube cube(m_RatioX, m_RatioY, m_RatioZ, m_TextureSubCubeExtent.m_MinX, m_TextureSubCubeExtent.m_MinY, m_TextureSubCubeExtent.m_MinZ, m_TextureSubCubeExtent.m_MaxX, m_TextureSubCubeExtent.m_MaxY, m_TextureSubCubeExtent.m_MaxZ); Polygon polygon(0); double z; for (z = getFurthestDistance(); z>getNearestDistance(); z-=getIntervalWidth()) { plane[3] = z; if (cube.clipPlane(polygon, plane)) { m_PolygonArray.addPolygon(polygon); } } m_NumberOfPlanesRendered = m_PolygonArray.getNumPolygons(); } // Renders the computed polygons void SimpleRGBA2DImpl::renderPolygons() { GLuint* textureNamesArray[] = {m_DataTextureNameX, m_DataTextureNameY, m_DataTextureNameZ}; GLuint* textureNames = textureNamesArray[m_RenderDirection]; unsigned int numTexturesArray[] = {m_Width, m_Height, m_Depth}; unsigned int numTextures = numTexturesArray[m_RenderDirection]; unsigned int coordSwitchArray[3][3] = { {1, 2}, {2, 0}, {0, 1} }; unsigned int* coordSwitch = coordSwitchArray[m_RenderDirection]; glEnable(GL_TEXTURE_2D); unsigned int c; for (c=0; cgetTexCoord(0)[m_RenderDirection]; z = z*numTextures; int texnum = (int)z; texnum = (texnum<0?0:texnum); texnum = ((unsigned int)texnum>numTextures-1?numTextures-1:texnum); glBindTexture(GL_TEXTURE_2D, textureNames[texnum]); glBegin(GL_POLYGON); unsigned int d; for (d=0; dgetNumVerts(); d++) { double* texCoord = m_PolygonArray.getPolygon(c)->getTexCoord(d); double xCoord = texCoord[coordSwitch[0]]; double yCoord = texCoord[coordSwitch[1]]; glTexCoord2d(xCoord, yCoord); glVertex3dv(m_PolygonArray.getPolygon(c)->getVert(d)); } glEnd(); } } // Gets the opengl texture IDs bool SimpleRGBA2DImpl::initTextureNames(unsigned int x, unsigned int y, unsigned int z) { // clear previous errors GLenum error = glGetError(); // x dimension if (x>m_NumAllocated[0]) { GLuint* temp = new GLuint[x]; // delete old if (m_NumAllocated[0]>0) glDeleteTextures(m_NumAllocated[0], m_DataTextureNameX); //unsigned int c; //for (c=0; cm_NumAllocated[1]) { GLuint* temp = new GLuint[y]; // delete old if (m_NumAllocated[1]>0) glDeleteTextures(m_NumAllocated[1], m_DataTextureNameY); //unsigned int c; //for (c=0; cm_NumAllocated[2]) { GLuint* temp = new GLuint[z]; // delete old if (m_NumAllocated[2]>0) glDeleteTextures(m_NumAllocated[2], m_DataTextureNameZ); //unsigned int c; //for (c=0; c Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // RGBABase.cpp: implementation of the RGBABase class. // ////////////////////////////////////////////////////////////////////// #include "RGBABase.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// RGBABase::RGBABase() { } RGBABase::~RGBABase() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool RGBABase::initRenderer() { return RendererBase::initRenderer(); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Paletted2DImpl.cpp0000644000175000017500000003443610223377127026051 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Paletted2DImpl.cpp: implementation of the Paletted2DImpl class. // ////////////////////////////////////////////////////////////////////// #include "Paletted2DImpl.h" #include #include "ClipCube.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Paletted2DImpl::Paletted2DImpl() { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; m_NumAllocated[0] = 0; m_NumAllocated[1] = 0; m_NumAllocated[2] = 0; m_DataTextureNameX = 0; m_DataTextureNameY = 0; m_DataTextureNameZ = 0; m_ColorMapDirty[0] = true; m_ColorMapDirty[1] = true; m_ColorMapDirty[2] = true; unsigned int c; for (c=0; c<256*4; c++) { m_ColorMap[c] = 255; } } Paletted2DImpl::~Paletted2DImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool Paletted2DImpl::initRenderer() { if (!UnshadedBase::initRenderer() || !initExtensions()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool Paletted2DImpl::checkCompatibility() const { MyExtensions tempExtensions; if (!tempExtensions.initExtensions("GL_VERSION_1_2 ") && !tempExtensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return tempExtensions.initExtensions( "GL_EXT_paletted_texture " ); } // Uploads colormapped data bool Paletted2DImpl::uploadColormappedData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); if (width!=m_Width || height!=m_Height || depth!=m_Depth) { if (!initTextureNames(width, height, depth)) { return false; } int c; for (c=0; c512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, width, height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, 0); glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, depth, width, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, 0); glTexImage2D(GL_PROXY_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, height, depth, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Uploads the transfer function for the colormapped data bool Paletted2DImpl::uploadColorMap(const GLubyte* colorMap) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); /* int c; for (c=0; cfabs(plane.b()) && fabs(plane.a())>fabs(plane.c())) { plane.b()=0.0; plane.c()=0.0; plane.d()=0.0; plane.normalizeNormal(); m_RenderDirection = 0; } else if (fabs(plane.b())>fabs(plane.c())) { plane.a()=0.0; plane.c()=0.0; plane.d()=0.0; plane.normalizeNormal(); m_RenderDirection = 1; } else { plane.a()=0.0; plane.b()=0.0; plane.d()=0.0; plane.normalizeNormal(); m_RenderDirection = 2; } ClipCube cube(m_RatioX, m_RatioY, m_RatioZ, m_TextureSubCubeExtent.m_MinX, m_TextureSubCubeExtent.m_MinY, m_TextureSubCubeExtent.m_MinZ, m_TextureSubCubeExtent.m_MaxX, m_TextureSubCubeExtent.m_MaxY, m_TextureSubCubeExtent.m_MaxZ); Polygon polygon(0); double z; for (z = getFurthestDistance(); z>getNearestDistance(); z-=getIntervalWidth()) { plane[3] = z; if (cube.clipPlane(polygon, plane)) { m_PolygonArray.addPolygon(polygon); } } m_NumberOfPlanesRendered = m_PolygonArray.getNumPolygons(); } // Renders the computed polygons void Paletted2DImpl::renderPolygons() { GLuint* textureNamesArray[] = {m_DataTextureNameX, m_DataTextureNameY, m_DataTextureNameZ}; GLuint* textureNames = textureNamesArray[m_RenderDirection]; unsigned int numTexturesArray[] = {m_Width, m_Height, m_Depth}; unsigned int numTextures = numTexturesArray[m_RenderDirection]; unsigned int coordSwitchArray[3][3] = { {1, 2}, {2, 0}, {0, 1} }; unsigned int* coordSwitch = coordSwitchArray[m_RenderDirection]; glEnable(GL_TEXTURE_2D); unsigned int c; for (c=0; cgetTexCoord(0)[m_RenderDirection]; z = z*numTextures; int texnum = (int)z; texnum = (texnum<0?0:texnum); texnum = ((unsigned int)texnum>numTextures-1?numTextures-1:texnum); glBindTexture(GL_TEXTURE_2D, textureNames[texnum]); if (m_ColorMapDirty[m_RenderDirection]) { m_Extensions.glColorTableEXT(GL_TEXTURE_2D, GL_RGBA8, 256, GL_RGBA, GL_UNSIGNED_BYTE, m_ColorMap); } glBegin(GL_POLYGON); unsigned int d; for (d=0; dgetNumVerts(); d++) { double* texCoord = m_PolygonArray.getPolygon(c)->getTexCoord(d); double xCoord = texCoord[coordSwitch[0]]; double yCoord = texCoord[coordSwitch[1]]; glTexCoord2d(xCoord, yCoord); glVertex3dv(m_PolygonArray.getPolygon(c)->getVert(d)); } glEnd(); } m_ColorMapDirty[m_RenderDirection] = false; } // Initializes the necessary extensions. bool Paletted2DImpl::initExtensions() { if (!m_Extensions.initExtensions("GL_VERSION_1_2 ") && !m_Extensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return m_Extensions.initExtensions( "GL_EXT_paletted_texture " ); } // Gets the opengl texture IDs bool Paletted2DImpl::initTextureNames(unsigned int x, unsigned int y, unsigned int z) { // clear previous errors GLenum error = glGetError(); // x dimension if (x>m_NumAllocated[0]) { GLuint* temp = new GLuint[x]; // delete old if (m_NumAllocated[0]>0) glDeleteTextures(m_NumAllocated[0], m_DataTextureNameX); //unsigned int c; //for (c=0; cm_NumAllocated[1]) { GLuint* temp = new GLuint[y]; // delete old if (m_NumAllocated[1]>0) glDeleteTextures(m_NumAllocated[1], m_DataTextureNameY); //unsigned int c; //for (c=0; cm_NumAllocated[2]) { GLuint* temp = new GLuint[z]; // delete old if (m_NumAllocated[2]>0) glDeleteTextures(m_NumAllocated[2], m_DataTextureNameZ); //unsigned int c; //for (c=0; c Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // VolumeRenderer.h: interface for the VolumeRenderer class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_VOLUMERENDERER_H__ADD2CDB1_7261_4BA2_8E20_865DD924B4D0__INCLUDED_) #define AFX_VOLUMERENDERER_H__ADD2CDB1_7261_4BA2_8E20_865DD924B4D0__INCLUDED_ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN 1 #include #endif #if defined(__APPLE__) # include #else # include #endif namespace OpenGLVolumeRendering { class Renderer; } /** Users of the volume library should use this class. It uses Renderer to create * colormapped and non-colormapped renderers. */ class VolumeRenderer { public: VolumeRenderer(); VolumeRenderer(const VolumeRenderer& copy); VolumeRenderer& operator=(const VolumeRenderer& copy); virtual ~VolumeRenderer(); bool initRenderer(); bool setAspectRatio(double ratioX, double ratioY, double ratioZ); bool setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ); bool setQuality(double quality); double getQuality() const; bool setNearPlane(double nearPlane); double getNearPlane(); bool isShadedRenderingAvailable() const; bool enableShadedRendering(); bool disableShadedRendering(); bool uploadColorMappedData(const GLubyte* data, int width, int height, int depth); bool uploadColorMappedDataWithBorder(const GLubyte* data, int width, int height, int depth); bool testColorMappedData(int width, int height, int depth); bool testColorMappedDataWithBorder(int width, int height, int depth); bool uploadRGBAData(const GLubyte* data, int width, int height, int depth); bool uploadGradients(const GLubyte* data, int width, int height, int depth); bool calculateGradientsFromDensities(const GLubyte* data, int width, int height, int depth); bool uploadColorMap(const GLubyte* colorMap); int getNumberOfPlanesRendered() const; bool renderVolume(); private: OpenGLVolumeRendering::Renderer* m_PrivateRenderer; }; #endif // !defined(AFX_VOLUMERENDERER_H__ADD2CDB1_7261_4BA2_8E20_865DD924B4D0__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/MyExtensions.h.cvs0000644000175000017500000014423610223377127026203 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.h: interface for the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) #define AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN 1 #include #endif #if defined(__APPLE__) # include # define GL_GLEXT_PROTOTYPES # include /** A.O. 09/24/04 **/ /**** #else # define GL_GLEXT_PROTOTYPES # include # include # if defined(WIN32) # include # else # define GLX_GLXEXT_PROTOTYPES # include # endif #endif ****/ #else # if defined(UNIX) # define GLX_GLXEXT_PROTOTYPES # include # else # define GL_GLEXT_PROTOTYPES # include # if defined(WIN32) # include # endif # endif #endif #ifndef APIENTRY #define APIENTRY #endif #ifndef GLAPI #define GLAPI extern #endif #include "ExtensionPointers.h" #ifdef DECLARE_STATIC_POINTERS #include "StaticExtensionPointers.h" #undef DECLARE_STATIC_POINTERS #endif class MyExtensions { public: MyExtensions(); ~MyExtensions(); static bool checkExtensions(const char* requestedExtensions); bool extensionExists(const char* extension, const char* allExtensions); bool initExtensions(const char* requestedExtensions); bool initExtension(const char* extension); // OpenGL version 1.2 MYPFNGLBLENDCOLORPROC glBlendColor; MYPFNGLBLENDEQUATIONPROC glBlendEquation; MYPFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements; MYPFNGLCOLORTABLEPROC glColorTable; MYPFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv; MYPFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv; MYPFNGLCOPYCOLORTABLEPROC glCopyColorTable; MYPFNGLGETCOLORTABLEPROC glGetColorTable; MYPFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv; MYPFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv; MYPFNGLCOLORSUBTABLEPROC glColorSubTable; MYPFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable; MYPFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D; MYPFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D; MYPFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf; MYPFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv; MYPFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri; MYPFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv; MYPFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D; MYPFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D; MYPFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter; MYPFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv; MYPFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv; MYPFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter; MYPFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D; MYPFNGLGETHISTOGRAMPROC glGetHistogram; MYPFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv; MYPFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv; MYPFNGLGETMINMAXPROC glGetMinmax; MYPFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv; MYPFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv; MYPFNGLHISTOGRAMPROC glHistogram; MYPFNGLMINMAXPROC glMinmax; MYPFNGLRESETHISTOGRAMPROC glResetHistogram; MYPFNGLRESETMINMAXPROC glResetMinmax; MYPFNGLTEXIMAGE3DPROC glTexImage3D; MYPFNGLTEXSUBIMAGE3DPROC glTexSubImage3D; MYPFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D; // End OpenGL version 1.2 // OpenGL version 1.3 MYPFNGLACTIVETEXTUREPROC glActiveTexture; MYPFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture; MYPFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d; MYPFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv; MYPFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f; MYPFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv; MYPFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i; MYPFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv; MYPFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s; MYPFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv; MYPFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d; MYPFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv; MYPFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f; MYPFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv; MYPFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i; MYPFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv; MYPFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s; MYPFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv; MYPFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d; MYPFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv; MYPFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f; MYPFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv; MYPFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i; MYPFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv; MYPFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s; MYPFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv; MYPFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d; MYPFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv; MYPFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f; MYPFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv; MYPFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i; MYPFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv; MYPFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s; MYPFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv; MYPFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf; MYPFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd; MYPFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf; MYPFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd; MYPFNGLSAMPLECOVERAGEPROC glSampleCoverage; MYPFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D; MYPFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; MYPFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D; MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; MYPFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage; // End OpenGL version 1.3 // OpenGL version 1.4 MYPFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate; MYPFNGLFOGCOORDFPROC glFogCoordf; MYPFNGLFOGCOORDFVPROC glFogCoordfv; MYPFNGLFOGCOORDDPROC glFogCoordd; MYPFNGLFOGCOORDDVPROC glFogCoorddv; MYPFNGLFOGCOORDPOINTERPROC glFogCoordPointer; MYPFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays; MYPFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements; MYPFNGLPOINTPARAMETERFPROC glPointParameterf; MYPFNGLPOINTPARAMETERFVPROC glPointParameterfv; MYPFNGLPOINTPARAMETERIPROC glPointParameteri; MYPFNGLPOINTPARAMETERIVPROC glPointParameteriv; MYPFNGLSECONDARYCOLOR3BPROC glSecondaryColor3b; MYPFNGLSECONDARYCOLOR3BVPROC glSecondaryColor3bv; MYPFNGLSECONDARYCOLOR3DPROC glSecondaryColor3d; MYPFNGLSECONDARYCOLOR3DVPROC glSecondaryColor3dv; MYPFNGLSECONDARYCOLOR3FPROC glSecondaryColor3f; MYPFNGLSECONDARYCOLOR3FVPROC glSecondaryColor3fv; MYPFNGLSECONDARYCOLOR3IPROC glSecondaryColor3i; MYPFNGLSECONDARYCOLOR3IVPROC glSecondaryColor3iv; MYPFNGLSECONDARYCOLOR3SPROC glSecondaryColor3s; MYPFNGLSECONDARYCOLOR3SVPROC glSecondaryColor3sv; MYPFNGLSECONDARYCOLOR3UBPROC glSecondaryColor3ub; MYPFNGLSECONDARYCOLOR3UBVPROC glSecondaryColor3ubv; MYPFNGLSECONDARYCOLOR3UIPROC glSecondaryColor3ui; MYPFNGLSECONDARYCOLOR3UIVPROC glSecondaryColor3uiv; MYPFNGLSECONDARYCOLOR3USPROC glSecondaryColor3us; MYPFNGLSECONDARYCOLOR3USVPROC glSecondaryColor3usv; MYPFNGLSECONDARYCOLORPOINTERPROC glSecondaryColorPointer; MYPFNGLWINDOWPOS2DPROC glWindowPos2d; MYPFNGLWINDOWPOS2DVPROC glWindowPos2dv; MYPFNGLWINDOWPOS2FPROC glWindowPos2f; MYPFNGLWINDOWPOS2FVPROC glWindowPos2fv; MYPFNGLWINDOWPOS2IPROC glWindowPos2i; MYPFNGLWINDOWPOS2IVPROC glWindowPos2iv; MYPFNGLWINDOWPOS2SPROC glWindowPos2s; MYPFNGLWINDOWPOS2SVPROC glWindowPos2sv; MYPFNGLWINDOWPOS3DPROC glWindowPos3d; MYPFNGLWINDOWPOS3DVPROC glWindowPos3dv; MYPFNGLWINDOWPOS3FPROC glWindowPos3f; MYPFNGLWINDOWPOS3FVPROC glWindowPos3fv; MYPFNGLWINDOWPOS3IPROC glWindowPos3i; MYPFNGLWINDOWPOS3IVPROC glWindowPos3iv; MYPFNGLWINDOWPOS3SPROC glWindowPos3s; MYPFNGLWINDOWPOS3SVPROC glWindowPos3sv; // End OpenGL version 1.4 // GL_EXT_paletted_texture MYPFNGLCOLORTABLEEXTPROC glColorTableEXT; MYPFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; // End GL_EXT_paletted_texture // GL_ARB_multitexture MYPFNGLACTIVETEXTUREARBPROC glActiveTextureARB; MYPFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB; MYPFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB; MYPFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB; MYPFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB; MYPFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB; MYPFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB; MYPFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB; MYPFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB; MYPFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB; MYPFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB; MYPFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB; MYPFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB; MYPFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB; MYPFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB; MYPFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB; MYPFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB; MYPFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB; MYPFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB; MYPFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB; MYPFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB; MYPFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB; MYPFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB; MYPFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB; MYPFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB; MYPFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB; MYPFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB; MYPFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB; MYPFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB; MYPFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB; MYPFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB; MYPFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB; MYPFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB; MYPFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB; // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table MYPFNGLCOLORTABLESGIPROC glColorTableSGI; MYPFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; MYPFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; MYPFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; MYPFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D MYPFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; MYPFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; // End GL_EXT_texture3D // GL_NV_fragment_program MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; // End GL_NV_fragment_program // GL_NV_vertex_program MYPFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; MYPFNGLBINDPROGRAMNVPROC glBindProgramNV; MYPFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; MYPFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; MYPFNGLGENPROGRAMSNVPROC glGenProgramsNV; MYPFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; MYPFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; MYPFNGLGETPROGRAMIVNVPROC glGetProgramivNV; MYPFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; MYPFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; MYPFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; MYPFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; MYPFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; MYPFNGLISPROGRAMNVPROC glIsProgramNV; MYPFNGLLOADPROGRAMNVPROC glLoadProgramNV; MYPFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; MYPFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; MYPFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; MYPFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; MYPFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; MYPFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; MYPFNGLTRACKMATRIXNVPROC glTrackMatrixNV; MYPFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; MYPFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; MYPFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; MYPFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; MYPFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; MYPFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; MYPFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; MYPFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; MYPFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; MYPFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; MYPFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; MYPFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; MYPFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; MYPFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; MYPFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; MYPFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; MYPFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; MYPFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; MYPFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; MYPFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; MYPFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; MYPFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; MYPFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; MYPFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; MYPFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; MYPFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; MYPFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; MYPFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; MYPFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; MYPFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; MYPFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; MYPFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; MYPFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; MYPFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; MYPFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; MYPFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; MYPFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; MYPFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; MYPFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; MYPFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; // End GL_NV_vertex_program // GL_ARB_vertex_program MYPFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; MYPFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; MYPFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; MYPFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; MYPFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; MYPFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; MYPFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; MYPFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; MYPFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; MYPFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; MYPFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; MYPFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; MYPFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; MYPFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; MYPFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; MYPFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; MYPFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; MYPFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; MYPFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; MYPFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; MYPFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; MYPFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; MYPFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; MYPFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; MYPFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; MYPFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; MYPFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; MYPFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; MYPFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; MYPFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; MYPFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; MYPFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; MYPFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; MYPFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; MYPFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; MYPFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; MYPFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; MYPFNGLPROGRAMSTRINGARBPROC glProgramStringARB; MYPFNGLBINDPROGRAMARBPROC glBindProgramARB; MYPFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; MYPFNGLGENPROGRAMSARBPROC glGenProgramsARB; MYPFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; MYPFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; MYPFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; MYPFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; MYPFNGLGETPROGRAMIVARBPROC glGetProgramivARB; MYPFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; MYPFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; MYPFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; MYPFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; MYPFNGLISPROGRAMARBPROC glIsProgramARB; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program #if defined(WIN32) /// WGL extensions follows // WGL_ARB_pixel_format MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB; MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC wglGetPixelFormatAttribfvARB; MYPFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer MYPFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB; MYPFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB; MYPFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB; MYPFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB; MYPFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB; // End WGL_ARB_pbuffer // WGL_ARB_render_texture MYPFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB; MYPFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB; MYPFNWGLSETPBUFFERATTRIBARBPROC wglSetPbufferAttribARB; // End WGL_ARB_render_texture // WGL_ARB_extensions_string MYPFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB; // End WGL_ARB_extensions_string #endif // defined(WIN32) protected: void initPointersToZero(); static const char* EatWhiteSpace(const char* str); static const char* EatNonWhiteSpace(const char* str); static const char* getExtensionStringPrivate(); static const char* getSystemExtensions(); }; // declare the extensions that we support and prepare the constants #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_RESCALE_NORMAL 0x803A #define GL_TEXTURE_BINDING_3D 0x806A #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_TEXTURE_3D 0x806F #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_CLAMP_TO_EDGE 0x812F #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_SINGLE_COLOR 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E #endif #ifndef GL_VERSION_1_3 #define GL_VERSION_1_3 1 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_MULTISAMPLE 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLES 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_MULTISAMPLE_BIT 0x20000000 #define GL_NORMAL_MAP 0x8511 #define GL_REFLECTION_MAP 0x8512 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_CLAMP_TO_BORDER 0x812D #define GL_CLAMP_TO_BORDER_SGIS 0x812D #define GL_COMBINE 0x8570 #define GL_COMBINE_RGB 0x8571 #define GL_COMBINE_ALPHA 0x8572 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_RGB 0x8582 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE2_ALPHA 0x858A #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_RGB 0x8592 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND2_ALPHA 0x859A #define GL_RGB_SCALE 0x8573 #define GL_ADD_SIGNED 0x8574 #define GL_INTERPOLATE 0x8575 #define GL_SUBTRACT 0x84E7 #define GL_CONSTANT 0x8576 #define GL_PRIMARY_COLOR 0x8577 #define GL_PREVIOUS 0x8578 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #endif #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_MIRRORED_REPEAT 0x8370 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORDINATE 0x8451 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_COLOR_SUM 0x8458 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_INCR_WRAP 0x8507 #define GL_DECR_WRAP 0x8508 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_R_TO_TEXTURE 0x884E #endif #ifndef GL_ARB_imaging #define GL_CONSTANT_COLOR 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_CONSTANT_ALPHA 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_BLEND_COLOR 0x8005 #define GL_FUNC_ADD 0x8006 #define GL_MIN 0x8007 #define GL_MAX 0x8008 #define GL_BLEND_EQUATION 0x8009 #define GL_FUNC_SUBTRACT 0x800A #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_CONVOLUTION_1D 0x8010 #define GL_CONVOLUTION_2D 0x8011 #define GL_SEPARABLE_2D 0x8012 #define GL_CONVOLUTION_BORDER_MODE 0x8013 #define GL_CONVOLUTION_FILTER_SCALE 0x8014 #define GL_CONVOLUTION_FILTER_BIAS 0x8015 #define GL_REDUCE 0x8016 #define GL_CONVOLUTION_FORMAT 0x8017 #define GL_CONVOLUTION_WIDTH 0x8018 #define GL_CONVOLUTION_HEIGHT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH 0x801A #define GL_MAX_CONVOLUTION_HEIGHT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F #define GL_POST_CONVOLUTION_RED_BIAS 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 #define GL_HISTOGRAM 0x8024 #define GL_PROXY_HISTOGRAM 0x8025 #define GL_HISTOGRAM_WIDTH 0x8026 #define GL_HISTOGRAM_FORMAT 0x8027 #define GL_HISTOGRAM_RED_SIZE 0x8028 #define GL_HISTOGRAM_GREEN_SIZE 0x8029 #define GL_HISTOGRAM_BLUE_SIZE 0x802A #define GL_HISTOGRAM_ALPHA_SIZE 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C #define GL_HISTOGRAM_SINK 0x802D #define GL_MINMAX 0x802E #define GL_MINMAX_FORMAT 0x802F #define GL_MINMAX_SINK 0x8030 #define GL_TABLE_TOO_LARGE 0x8031 #define GL_COLOR_MATRIX 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB #define GL_COLOR_TABLE 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 #define GL_PROXY_COLOR_TABLE 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 #define GL_COLOR_TABLE_SCALE 0x80D6 #define GL_COLOR_TABLE_BIAS 0x80D7 #define GL_COLOR_TABLE_FORMAT 0x80D8 #define GL_COLOR_TABLE_WIDTH 0x80D9 #define GL_COLOR_TABLE_RED_SIZE 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF #define GL_CONSTANT_BORDER 0x8151 #define GL_REPLICATE_BORDER 0x8153 #define GL_CONVOLUTION_BORDER_COLOR 0x8154 #endif #ifndef GL_EXT_paletted_texture #define GL_EXT_paletted_texture 1 #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED #endif #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 #define GL_TEXTURE2_ARB 0x84C2 #define GL_TEXTURE3_ARB 0x84C3 #define GL_TEXTURE4_ARB 0x84C4 #define GL_TEXTURE5_ARB 0x84C5 #define GL_TEXTURE6_ARB 0x84C6 #define GL_TEXTURE7_ARB 0x84C7 #define GL_TEXTURE8_ARB 0x84C8 #define GL_TEXTURE9_ARB 0x84C9 #define GL_TEXTURE10_ARB 0x84CA #define GL_TEXTURE11_ARB 0x84CB #define GL_TEXTURE12_ARB 0x84CC #define GL_TEXTURE13_ARB 0x84CD #define GL_TEXTURE14_ARB 0x84CE #define GL_TEXTURE15_ARB 0x84CF #define GL_TEXTURE16_ARB 0x84D0 #define GL_TEXTURE17_ARB 0x84D1 #define GL_TEXTURE18_ARB 0x84D2 #define GL_TEXTURE19_ARB 0x84D3 #define GL_TEXTURE20_ARB 0x84D4 #define GL_TEXTURE21_ARB 0x84D5 #define GL_TEXTURE22_ARB 0x84D6 #define GL_TEXTURE23_ARB 0x84D7 #define GL_TEXTURE24_ARB 0x84D8 #define GL_TEXTURE25_ARB 0x84D9 #define GL_TEXTURE26_ARB 0x84DA #define GL_TEXTURE27_ARB 0x84DB #define GL_TEXTURE28_ARB 0x84DC #define GL_TEXTURE29_ARB 0x84DD #define GL_TEXTURE30_ARB 0x84DE #define GL_TEXTURE31_ARB 0x84DF #define GL_ACTIVE_TEXTURE_ARB 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 #endif #ifndef GL_SGI_texture_color_table #define GL_SGI_texture_color_table 1 #define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC #define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD #endif #ifndef GL_SGI_color_table #define GL_SGI_color_table 1 #define GL_COLOR_TABLE_SGI 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 #define GL_PROXY_COLOR_TABLE_SGI 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 #define GL_COLOR_TABLE_SCALE_SGI 0x80D6 #define GL_COLOR_TABLE_BIAS_SGI 0x80D7 #define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 #define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF #endif #ifndef GL_SGIS_texture_edge_clamp #define GL_SGIS_texture_edge_clamp 1 #define GL_CLAMP_TO_EDGE_SGIS 0x812F #endif #ifndef GL_EXT_texture3D #define GL_EXT_texture3D 1 #define GL_PACK_SKIP_IMAGES_EXT 0x806B #define GL_PACK_IMAGE_HEIGHT_EXT 0x806C #define GL_UNPACK_SKIP_IMAGES_EXT 0x806D #define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E #define GL_TEXTURE_3D_EXT 0x806F #define GL_PROXY_TEXTURE_3D_EXT 0x8070 #define GL_TEXTURE_DEPTH_EXT 0x8071 #define GL_TEXTURE_WRAP_R_EXT 0x8072 #define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 #endif #ifndef GL_NV_fragment_program #define GL_NV_fragment_program 1 #define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 #define GL_FRAGMENT_PROGRAM_NV 0x8870 #define GL_MAX_TEXTURE_COORDS_NV 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 #define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 #define GL_PROGRAM_ERROR_STRING_NV 0x8874 #endif #ifndef GL_NV_vertex_program #define GL_NV_vertex_program 1 #define GL_VERTEX_PROGRAM_NV 0x8620 #define GL_VERTEX_STATE_PROGRAM_NV 0x8621 #define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 #define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 #define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 #define GL_CURRENT_ATTRIB_NV 0x8626 #define GL_PROGRAM_LENGTH_NV 0x8627 #define GL_PROGRAM_STRING_NV 0x8628 #define GL_MODELVIEW_PROJECTION_NV 0x8629 #define GL_IDENTITY_NV 0x862A #define GL_INVERSE_NV 0x862B #define GL_TRANSPOSE_NV 0x862C #define GL_INVERSE_TRANSPOSE_NV 0x862D #define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E #define GL_MAX_TRACK_MATRICES_NV 0x862F #define GL_MATRIX0_NV 0x8630 #define GL_MATRIX1_NV 0x8631 #define GL_MATRIX2_NV 0x8632 #define GL_MATRIX3_NV 0x8633 #define GL_MATRIX4_NV 0x8634 #define GL_MATRIX5_NV 0x8635 #define GL_MATRIX6_NV 0x8636 #define GL_MATRIX7_NV 0x8637 #define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 #define GL_CURRENT_MATRIX_NV 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 #define GL_PROGRAM_PARAMETER_NV 0x8644 #define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 #define GL_PROGRAM_TARGET_NV 0x8646 #define GL_PROGRAM_RESIDENT_NV 0x8647 #define GL_TRACK_MATRIX_NV 0x8648 #define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 #define GL_VERTEX_PROGRAM_BINDING_NV 0x864A #define GL_PROGRAM_ERROR_POSITION_NV 0x864B #define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 #define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 #define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 #define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 #define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 #define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 #define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 #define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 #define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 #define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 #define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A #define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B #define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C #define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D #define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E #define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F #define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 #define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 #define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 #define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 #define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 #define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 #define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 #define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 #define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 #define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 #define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A #define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B #define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C #define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D #define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E #define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F #define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 #define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 #define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 #define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 #define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 #define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 #define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 #define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 #define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 #define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 #define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A #define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B #define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C #define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D #define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E #define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F #endif #ifndef GL_ARB_vertex_program #define GL_ARB_vertex_program 1 #define GL_COLOR_SUM_ARB 0x8458 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF #endif #ifndef GL_ARB_fragment_program #define GL_ARB_fragment_program 1 #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #endif /// WGL extensions follow #if defined(WIN32) #ifndef WGL_ARB_pixel_format #define WGL_ARB_pixel_format 1 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 #define WGL_DRAW_TO_WINDOW_ARB 0x2001 #define WGL_DRAW_TO_BITMAP_ARB 0x2002 #define WGL_ACCELERATION_ARB 0x2003 #define WGL_NEED_PALETTE_ARB 0x2004 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 #define WGL_SWAP_METHOD_ARB 0x2007 #define WGL_NUMBER_OVERLAYS_ARB 0x2008 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009 #define WGL_TRANSPARENT_ARB 0x200A #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B #define WGL_SHARE_DEPTH_ARB 0x200C #define WGL_SHARE_STENCIL_ARB 0x200D #define WGL_SHARE_ACCUM_ARB 0x200E #define WGL_SUPPORT_GDI_ARB 0x200F #define WGL_SUPPORT_OPENGL_ARB 0x2010 #define WGL_DOUBLE_BUFFER_ARB 0x2011 #define WGL_STEREO_ARB 0x2012 #define WGL_PIXEL_TYPE_ARB 0x2013 #define WGL_COLOR_BITS_ARB 0x2014 #define WGL_RED_BITS_ARB 0x2015 #define WGL_RED_SHIFT_ARB 0x2016 #define WGL_GREEN_BITS_ARB 0x2017 #define WGL_GREEN_SHIFT_ARB 0x2018 #define WGL_BLUE_BITS_ARB 0x2019 #define WGL_BLUE_SHIFT_ARB 0x201A #define WGL_ALPHA_BITS_ARB 0x201B #define WGL_ALPHA_SHIFT_ARB 0x201C #define WGL_ACCUM_BITS_ARB 0x201D #define WGL_ACCUM_RED_BITS_ARB 0x201E #define WGL_ACCUM_GREEN_BITS_ARB 0x201F #define WGL_ACCUM_BLUE_BITS_ARB 0x2020 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 #define WGL_DEPTH_BITS_ARB 0x2022 #define WGL_STENCIL_BITS_ARB 0x2023 #define WGL_AUX_BUFFERS_ARB 0x2024 #define WGL_NO_ACCELERATION_ARB 0x2025 #define WGL_GENERIC_ACCELERATION_ARB 0x2026 #define WGL_FULL_ACCELERATION_ARB 0x2027 #define WGL_SWAP_EXCHANGE_ARB 0x2028 #define WGL_SWAP_COPY_ARB 0x2029 #define WGL_SWAP_UNDEFINED_ARB 0x202A #define WGL_TYPE_RGBA_ARB 0x202B #define WGL_TYPE_COLORINDEX_ARB 0x202C #endif #ifndef WGL_ARB_pbuffer #define WGL_ARB_pbuffer 1 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 #define WGL_PBUFFER_LARGEST_ARB 0x2033 #define WGL_PBUFFER_WIDTH_ARB 0x2034 #define WGL_PBUFFER_HEIGHT_ARB 0x2035 #define WGL_PBUFFER_LOST_ARB 0x2036 #endif #ifndef WGL_ARB_render_texture #define WGL_ARB_render_texture 1 #define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 #define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 #define WGL_TEXTURE_FORMAT_ARB 0x2072 #define WGL_TEXTURE_TARGET_ARB 0x2073 #define WGL_MIPMAP_TEXTURE_ARB 0x2074 #define WGL_TEXTURE_RGB_ARB 0x2075 #define WGL_TEXTURE_RGBA_ARB 0x2076 #define WGL_NO_TEXTURE_ARB 0x2077 #define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 #define WGL_TEXTURE_1D_ARB 0x2079 #define WGL_TEXTURE_2D_ARB 0x207A #define WGL_MIPMAP_LEVEL_ARB 0x207B #define WGL_CUBE_MAP_FACE_ARB 0x207C #define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 #define WGL_FRONT_LEFT_ARB 0x2083 #define WGL_FRONT_RIGHT_ARB 0x2084 #define WGL_BACK_LEFT_ARB 0x2085 #define WGL_BACK_RIGHT_ARB 0x2086 #define WGL_AUX0_ARB 0x2087 #define WGL_AUX1_ARB 0x2088 #define WGL_AUX2_ARB 0x2089 #define WGL_AUX3_ARB 0x208A #define WGL_AUX4_ARB 0x208B #define WGL_AUX5_ARB 0x208C #define WGL_AUX6_ARB 0x208D #define WGL_AUX7_ARB 0x208E #define WGL_AUX8_ARB 0x208F #define WGL_AUX9_ARB 0x2090 #endif #ifndef WGL_ARB_extensions_string #define WGL_ARB_extensions_string 1 #endif #endif // defined(WIN32) #endif // !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/irix6/0000755000175000017500000000000012146213527023621 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/irix6/Makefile0000644000175000017500000000175110223377127025266 0ustar debiandebian# libVolume.a Makefile for irix CFLAGS = -O3 VPATH = ../ CC = CC LINK = ar INCLUDE = -I./ MAKE = gmake LIBRARY = libVolume.a OBJS = ClipCube.o Extent.o MyExtensions.o PalettedImpl.o \ Plane.o Polygon.o PolygonArray.o Renderer.o RendererBase.o\ RGBABase.o SGIColorTableImpl.o SimpleRGBAImpl.o \ UnshadedBase.o VolumeRenderer.o FragmentProgramImpl.o \ SimpleRGBA2DImpl.o Paletted2DImpl.o HDRS = ClipCube.h ExtensionPointers.h Extent.h LookupTables.h \ MyExtensions.h PalettedImpl.h Plane.h Polygon.h PolygonArray.h \ Renderer.h RendererBase.h RGBABase.h SGIColorTableImpl.h \ SimpleRGBAImpl.h StaticExtensionPointers.h UnshadedBase.h \ VolumeRenderer.h FragmentProgramImpl.h SimpleRGBA2DImpl.h \ Paletted2DImpl.h ######## # Build rules ######## all: library library:$(OBJS) $(LINK) rv $(LIBRARY) $(OBJS) example: cd testdir; make cleanobj: rm *.o clean: cleanobj rm libVolume.a ######## # Implicit rules ######## %.o : %.cpp $(HDRS) $(CC) -c $(CFLAGS) $(INCLUDE) -o $@ $< mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/SimpleRGBAImpl.cpp0000644000175000017500000001372710223377127026006 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // SimpleRGBAImpl.cpp: implementation of the SimpleRGBAImpl class. // ////////////////////////////////////////////////////////////////////// #include "SimpleRGBAImpl.h" using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// SimpleRGBAImpl::SimpleRGBAImpl() { m_Width = -1; m_Height = -1; m_Depth = -1; m_Initialized = false; } SimpleRGBAImpl::~SimpleRGBAImpl() { } // Initializes the renderer. Should be called again if the renderer is // moved to a different openGL context. If this returns false, do not try // to use it to do volumeRendering bool SimpleRGBAImpl::initRenderer() { if (!RGBABase::initRenderer() || !initExtensions() || !initTextureNames()) { m_Initialized = false; m_Width = -1; m_Height = -1; m_Depth = -1; return false; } else { m_Initialized = true; return true; } } // Makes the check necessary to determine if this renderer is // compatible with the hardware its running on bool SimpleRGBAImpl::checkCompatibility() const { MyExtensions tempExtensions; if (!tempExtensions.initExtensions("GL_VERSION_1_2 ") && !tempExtensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return tempExtensions.initExtensions( "GL_EXT_texture3D " ); } // Uploads colormapped data bool SimpleRGBAImpl::uploadRGBAData(const GLubyte* data, int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // clear previous errors GLenum error = glGetError(); // save the width height and depth m_Width = width; m_HintDimX = width; m_Height = height;m_HintDimY = height; m_Depth = depth; m_HintDimZ = depth; glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); m_Extensions.glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, GL_RGBA, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, GL_CLAMP_TO_EDGE_SGIS); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Tests to see if the given parameters would return an error bool SimpleRGBAImpl::testRGBAData(int width, int height, int depth) { // bail if we haven't been initialized properly if (!m_Initialized) return false; // nothing above 512 if (width>512 || height>512 || depth>512) { return false; } // clear previous errors GLenum error; int c =0; while (glGetError()!=GL_NO_ERROR && c<10) c++; m_Extensions.glTexImage3DEXT(GL_PROXY_TEXTURE_3D_EXT, 0, GL_RGBA, width, height, depth, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0); // test for error error = glGetError(); if (error == GL_NO_ERROR) { return true; } else { return false; } } // Performs the actual rendering. bool SimpleRGBAImpl::renderVolume() { // bail if we haven't been initialized properly if (!m_Initialized) return false; // set up the state glPushAttrib( GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glColor4f(1.0, 1.0, 1.0, 1.0); glDisable(GL_CULL_FACE); glDisable(GL_LIGHTING); glEnable(GL_BLEND); //glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); //glBlendFunc( GL_SRC_ALPHA, GL_ONE ); glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); glDepthMask( GL_FALSE ); glEnable(GL_TEXTURE_3D_EXT); glBindTexture(GL_TEXTURE_3D_EXT, m_DataTextureName); computePolygons(); convertToTriangles(); renderTriangles(); // restore the state glPopAttrib(); return true; } // Initializes the necessary extensions. bool SimpleRGBAImpl::initExtensions() { if (!m_Extensions.initExtensions("GL_VERSION_1_2 ") && !m_Extensions.initExtensions("GL_SGIS_texture_edge_clamp ")) { // if neither is available, we have to bail return false; } return m_Extensions.initExtensions( "GL_EXT_texture3D " ); } // Gets the opengl texture IDs bool SimpleRGBAImpl::initTextureNames() { // clear previous errors GLenum error = glGetError(); // get the names glGenTextures(1, &m_DataTextureName); // test for error error = glGetError(); if (error==GL_NO_ERROR) { return true; } else { return false; } } // Render the actual triangles void SimpleRGBAImpl::renderTriangles() { // set up the client render state glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY); //glEnableClientState(GL_COLOR_ARRAY); glTexCoordPointer(3, GL_FLOAT, 0, m_TextureArray); glVertexPointer(3, GL_FLOAT, 0, m_VertexArray); //glColorPointer(3, GL_FLOAT, 0, m_TextureArray); // render the triangles glDrawElements(GL_TRIANGLES, m_NumTriangles*3, GL_UNSIGNED_INT, m_TriangleArray); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); //glDisableClientState(GL_COLOR_ARRAY); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/Plane.cpp0000644000175000017500000000315610223377127024331 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // Plane.cpp: implementation of the Plane class. // ////////////////////////////////////////////////////////////////////// #include "Plane.h" #include using namespace OpenGLVolumeRendering; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Plane::Plane() { } Plane::Plane(double a, double b, double c, double d) { m_A = a; m_B = b; m_C = c; m_D = d; } Plane::~Plane() { } double Plane::signedDistance(double x, double y, double z) const { return m_A*x+m_B*y+m_C*z-m_D; } void Plane::normalizeNormal() { double length = sqrt(m_A*m_A+m_B*m_B+m_C*m_C); m_A/=length; m_B/=length; m_C/=length; m_D/=length; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/UnshadedBase.h0000644000175000017500000000421610223377127025263 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // OpenGLVolumeUnshadedBase.h: interface for the OpenGLVolumeUnshadedBase class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_OPENGLVOLUMEUNSHADEDBASE_H__46F9B18E_A365_4CE9_9596_12017FC75BA2__INCLUDED_) #define AFX_OPENGLVOLUMEUNSHADEDBASE_H__46F9B18E_A365_4CE9_9596_12017FC75BA2__INCLUDED_ #include "RendererBase.h" namespace OpenGLVolumeRendering { /// The base class for colormapped volume renders class UnshadedBase : public RendererBase { public: UnshadedBase(); virtual ~UnshadedBase(); /// Initializes the renderer. Should be called again if the renderer is /// moved to a different openGL context. If this returns false, do not try /// to use it to do volumeRendering virtual bool initRenderer(); /// Uploads colormapped data virtual bool uploadColormappedData(const GLubyte* data, int width, int height, int depth) = 0; /// Tests to see if the given parameters would return an error virtual bool testColormappedData(int width, int height, int depth) = 0; /// Uploads the transfer function for the colormapped data virtual bool uploadColorMap(const GLubyte* colorMap) = 0; protected: }; }; #endif // !defined(AFX_OPENGLVOLUMEUNSHADEDBASE_H__46F9B18E_A365_4CE9_9596_12017FC75BA2__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/VolumeLibrary.plg0000644000175000017500000000245310223377127026065 0ustar debiandebian

Build Log

--------------------Configuration: VolumeLibrary - Win32 Debug--------------------

Command Lines

Creating temporary file "f:\TEMP\RSPE0.tmp" with contents [ /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /Fp"Debug/VolumeLibrary.pch" /YX /Fo"Debug/" /Fd"Debug/" /FD /GZ /c "F:\users\anthony\NewVolume\VolumeLibrary\Renderer.cpp" ] Creating command line "cl.exe @f:\TEMP\RSPE0.tmp" Creating temporary file "f:\TEMP\RSPE1.tmp" with contents [ /nologo /out:"Debug\VolumeLibrary.lib" .\Debug\ClipCube.obj .\Debug\Extent.obj .\Debug\FragmentProgramImpl.obj .\Debug\MyExtensions.obj .\Debug\Paletted2DImpl.obj .\Debug\PalettedImpl.obj .\Debug\Plane.obj .\Debug\Polygon.obj .\Debug\PolygonArray.obj .\Debug\Renderer.obj .\Debug\RendererBase.obj .\Debug\RGBABase.obj .\Debug\SGIColorTableImpl.obj .\Debug\SimpleRGBA2DImpl.obj .\Debug\SimpleRGBAImpl.obj .\Debug\UnshadedBase.obj .\Debug\VolumeRenderer.obj .\Debug\VolumeRendererFactory.obj .\Debug\FragmentProgramARBImpl.obj ] Creating command line "link.exe -lib @f:\TEMP\RSPE1.tmp"

Output Window

Compiling... Renderer.cpp Creating library...

Results

VolumeLibrary.lib - 0 error(s), 0 warning(s)
mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/MyExtensions.h0000644000175000017500000014442610223377127025412 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.h: interface for the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) #define AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) #define WIN32_LEAN_AND_MEAN 1 #include #endif #if defined(__APPLE__) # include # define GL_GLEXT_PROTOTYPES # include #else # if defined(UNIX) # define GLX_GLXEXT_PROTOTYPES # include # else # define GL_GLEXT_PROTOTYPES # include # include # if defined(WIN32) # include # else # define GLX_GLXEXT_PROTOTYPES # include # endif # endif #endif /***** #else # if defined(UNIX) # define GLX_GLXEXT_PROTOTYPES # include # else # if defined(WIN32) # include # else # define GL_GLEXT_PROTOTYPES # include # endif # endif #endif ****/ #ifndef APIENTRY #define APIENTRY #endif #ifndef GLAPI #define GLAPI extern #endif #include "ExtensionPointers.h" #ifdef DECLARE_STATIC_POINTERS #include "StaticExtensionPointers.h" #undef DECLARE_STATIC_POINTERS #endif class MyExtensions { public: MyExtensions(); ~MyExtensions(); static bool checkExtensions(const char* requestedExtensions); bool extensionExists(const char* extension, const char* allExtensions); bool initExtensions(const char* requestedExtensions); bool initExtension(const char* extension); // OpenGL version 1.2 MYPFNGLBLENDCOLORPROC glBlendColor; MYPFNGLBLENDEQUATIONPROC glBlendEquation; MYPFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements; MYPFNGLCOLORTABLEPROC glColorTable; MYPFNGLCOLORTABLEPARAMETERFVPROC glColorTableParameterfv; MYPFNGLCOLORTABLEPARAMETERIVPROC glColorTableParameteriv; MYPFNGLCOPYCOLORTABLEPROC glCopyColorTable; MYPFNGLGETCOLORTABLEPROC glGetColorTable; MYPFNGLGETCOLORTABLEPARAMETERFVPROC glGetColorTableParameterfv; MYPFNGLGETCOLORTABLEPARAMETERIVPROC glGetColorTableParameteriv; MYPFNGLCOLORSUBTABLEPROC glColorSubTable; MYPFNGLCOPYCOLORSUBTABLEPROC glCopyColorSubTable; MYPFNGLCONVOLUTIONFILTER1DPROC glConvolutionFilter1D; MYPFNGLCONVOLUTIONFILTER2DPROC glConvolutionFilter2D; MYPFNGLCONVOLUTIONPARAMETERFPROC glConvolutionParameterf; MYPFNGLCONVOLUTIONPARAMETERFVPROC glConvolutionParameterfv; MYPFNGLCONVOLUTIONPARAMETERIPROC glConvolutionParameteri; MYPFNGLCONVOLUTIONPARAMETERIVPROC glConvolutionParameteriv; MYPFNGLCOPYCONVOLUTIONFILTER1DPROC glCopyConvolutionFilter1D; MYPFNGLCOPYCONVOLUTIONFILTER2DPROC glCopyConvolutionFilter2D; MYPFNGLGETCONVOLUTIONFILTERPROC glGetConvolutionFilter; MYPFNGLGETCONVOLUTIONPARAMETERFVPROC glGetConvolutionParameterfv; MYPFNGLGETCONVOLUTIONPARAMETERIVPROC glGetConvolutionParameteriv; MYPFNGLGETSEPARABLEFILTERPROC glGetSeparableFilter; MYPFNGLSEPARABLEFILTER2DPROC glSeparableFilter2D; MYPFNGLGETHISTOGRAMPROC glGetHistogram; MYPFNGLGETHISTOGRAMPARAMETERFVPROC glGetHistogramParameterfv; MYPFNGLGETHISTOGRAMPARAMETERIVPROC glGetHistogramParameteriv; MYPFNGLGETMINMAXPROC glGetMinmax; MYPFNGLGETMINMAXPARAMETERFVPROC glGetMinmaxParameterfv; MYPFNGLGETMINMAXPARAMETERIVPROC glGetMinmaxParameteriv; MYPFNGLHISTOGRAMPROC glHistogram; MYPFNGLMINMAXPROC glMinmax; MYPFNGLRESETHISTOGRAMPROC glResetHistogram; MYPFNGLRESETMINMAXPROC glResetMinmax; MYPFNGLTEXIMAGE3DPROC glTexImage3D; MYPFNGLTEXSUBIMAGE3DPROC glTexSubImage3D; MYPFNGLCOPYTEXSUBIMAGE3DPROC glCopyTexSubImage3D; // End OpenGL version 1.2 // OpenGL version 1.3 MYPFNGLACTIVETEXTUREPROC glActiveTexture; MYPFNGLCLIENTACTIVETEXTUREPROC glClientActiveTexture; MYPFNGLMULTITEXCOORD1DPROC glMultiTexCoord1d; MYPFNGLMULTITEXCOORD1DVPROC glMultiTexCoord1dv; MYPFNGLMULTITEXCOORD1FPROC glMultiTexCoord1f; MYPFNGLMULTITEXCOORD1FVPROC glMultiTexCoord1fv; MYPFNGLMULTITEXCOORD1IPROC glMultiTexCoord1i; MYPFNGLMULTITEXCOORD1IVPROC glMultiTexCoord1iv; MYPFNGLMULTITEXCOORD1SPROC glMultiTexCoord1s; MYPFNGLMULTITEXCOORD1SVPROC glMultiTexCoord1sv; MYPFNGLMULTITEXCOORD2DPROC glMultiTexCoord2d; MYPFNGLMULTITEXCOORD2DVPROC glMultiTexCoord2dv; MYPFNGLMULTITEXCOORD2FPROC glMultiTexCoord2f; MYPFNGLMULTITEXCOORD2FVPROC glMultiTexCoord2fv; MYPFNGLMULTITEXCOORD2IPROC glMultiTexCoord2i; MYPFNGLMULTITEXCOORD2IVPROC glMultiTexCoord2iv; MYPFNGLMULTITEXCOORD2SPROC glMultiTexCoord2s; MYPFNGLMULTITEXCOORD2SVPROC glMultiTexCoord2sv; MYPFNGLMULTITEXCOORD3DPROC glMultiTexCoord3d; MYPFNGLMULTITEXCOORD3DVPROC glMultiTexCoord3dv; MYPFNGLMULTITEXCOORD3FPROC glMultiTexCoord3f; MYPFNGLMULTITEXCOORD3FVPROC glMultiTexCoord3fv; MYPFNGLMULTITEXCOORD3IPROC glMultiTexCoord3i; MYPFNGLMULTITEXCOORD3IVPROC glMultiTexCoord3iv; MYPFNGLMULTITEXCOORD3SPROC glMultiTexCoord3s; MYPFNGLMULTITEXCOORD3SVPROC glMultiTexCoord3sv; MYPFNGLMULTITEXCOORD4DPROC glMultiTexCoord4d; MYPFNGLMULTITEXCOORD4DVPROC glMultiTexCoord4dv; MYPFNGLMULTITEXCOORD4FPROC glMultiTexCoord4f; MYPFNGLMULTITEXCOORD4FVPROC glMultiTexCoord4fv; MYPFNGLMULTITEXCOORD4IPROC glMultiTexCoord4i; MYPFNGLMULTITEXCOORD4IVPROC glMultiTexCoord4iv; MYPFNGLMULTITEXCOORD4SPROC glMultiTexCoord4s; MYPFNGLMULTITEXCOORD4SVPROC glMultiTexCoord4sv; MYPFNGLLOADTRANSPOSEMATRIXFPROC glLoadTransposeMatrixf; MYPFNGLLOADTRANSPOSEMATRIXDPROC glLoadTransposeMatrixd; MYPFNGLMULTTRANSPOSEMATRIXFPROC glMultTransposeMatrixf; MYPFNGLMULTTRANSPOSEMATRIXDPROC glMultTransposeMatrixd; MYPFNGLSAMPLECOVERAGEPROC glSampleCoverage; MYPFNGLCOMPRESSEDTEXIMAGE3DPROC glCompressedTexImage3D; MYPFNGLCOMPRESSEDTEXIMAGE2DPROC glCompressedTexImage2D; MYPFNGLCOMPRESSEDTEXIMAGE1DPROC glCompressedTexImage1D; MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glCompressedTexSubImage3D; MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glCompressedTexSubImage2D; MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glCompressedTexSubImage1D; MYPFNGLGETCOMPRESSEDTEXIMAGEPROC glGetCompressedTexImage; // End OpenGL version 1.3 // OpenGL version 1.4 MYPFNGLBLENDFUNCSEPARATEPROC glBlendFuncSeparate; MYPFNGLFOGCOORDFPROC glFogCoordf; MYPFNGLFOGCOORDFVPROC glFogCoordfv; MYPFNGLFOGCOORDDPROC glFogCoordd; MYPFNGLFOGCOORDDVPROC glFogCoorddv; MYPFNGLFOGCOORDPOINTERPROC glFogCoordPointer; MYPFNGLMULTIDRAWARRAYSPROC glMultiDrawArrays; MYPFNGLMULTIDRAWELEMENTSPROC glMultiDrawElements; MYPFNGLPOINTPARAMETERFPROC glPointParameterf; MYPFNGLPOINTPARAMETERFVPROC glPointParameterfv; MYPFNGLPOINTPARAMETERIPROC glPointParameteri; MYPFNGLPOINTPARAMETERIVPROC glPointParameteriv; MYPFNGLSECONDARYCOLOR3BPROC glSecondaryColor3b; MYPFNGLSECONDARYCOLOR3BVPROC glSecondaryColor3bv; MYPFNGLSECONDARYCOLOR3DPROC glSecondaryColor3d; MYPFNGLSECONDARYCOLOR3DVPROC glSecondaryColor3dv; MYPFNGLSECONDARYCOLOR3FPROC glSecondaryColor3f; MYPFNGLSECONDARYCOLOR3FVPROC glSecondaryColor3fv; MYPFNGLSECONDARYCOLOR3IPROC glSecondaryColor3i; MYPFNGLSECONDARYCOLOR3IVPROC glSecondaryColor3iv; MYPFNGLSECONDARYCOLOR3SPROC glSecondaryColor3s; MYPFNGLSECONDARYCOLOR3SVPROC glSecondaryColor3sv; MYPFNGLSECONDARYCOLOR3UBPROC glSecondaryColor3ub; MYPFNGLSECONDARYCOLOR3UBVPROC glSecondaryColor3ubv; MYPFNGLSECONDARYCOLOR3UIPROC glSecondaryColor3ui; MYPFNGLSECONDARYCOLOR3UIVPROC glSecondaryColor3uiv; MYPFNGLSECONDARYCOLOR3USPROC glSecondaryColor3us; MYPFNGLSECONDARYCOLOR3USVPROC glSecondaryColor3usv; MYPFNGLSECONDARYCOLORPOINTERPROC glSecondaryColorPointer; MYPFNGLWINDOWPOS2DPROC glWindowPos2d; MYPFNGLWINDOWPOS2DVPROC glWindowPos2dv; MYPFNGLWINDOWPOS2FPROC glWindowPos2f; MYPFNGLWINDOWPOS2FVPROC glWindowPos2fv; MYPFNGLWINDOWPOS2IPROC glWindowPos2i; MYPFNGLWINDOWPOS2IVPROC glWindowPos2iv; MYPFNGLWINDOWPOS2SPROC glWindowPos2s; MYPFNGLWINDOWPOS2SVPROC glWindowPos2sv; MYPFNGLWINDOWPOS3DPROC glWindowPos3d; MYPFNGLWINDOWPOS3DVPROC glWindowPos3dv; MYPFNGLWINDOWPOS3FPROC glWindowPos3f; MYPFNGLWINDOWPOS3FVPROC glWindowPos3fv; MYPFNGLWINDOWPOS3IPROC glWindowPos3i; MYPFNGLWINDOWPOS3IVPROC glWindowPos3iv; MYPFNGLWINDOWPOS3SPROC glWindowPos3s; MYPFNGLWINDOWPOS3SVPROC glWindowPos3sv; // End OpenGL version 1.4 // GL_EXT_paletted_texture MYPFNGLCOLORTABLEEXTPROC glColorTableEXT; MYPFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; // End GL_EXT_paletted_texture // GL_ARB_multitexture MYPFNGLACTIVETEXTUREARBPROC glActiveTextureARB; MYPFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB; MYPFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB; MYPFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB; MYPFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB; MYPFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB; MYPFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB; MYPFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB; MYPFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB; MYPFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB; MYPFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB; MYPFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB; MYPFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB; MYPFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB; MYPFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB; MYPFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB; MYPFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB; MYPFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB; MYPFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB; MYPFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB; MYPFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB; MYPFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB; MYPFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB; MYPFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB; MYPFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB; MYPFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB; MYPFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB; MYPFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB; MYPFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB; MYPFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB; MYPFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB; MYPFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB; MYPFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB; MYPFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB; // End GL_ARB_multitexture // GL_SGI_texture_color_table // No new functions. // End GL_SGI_texture_color_table // GL_SGI_color_table MYPFNGLCOLORTABLESGIPROC glColorTableSGI; MYPFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; MYPFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; MYPFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; MYPFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; // End GL_SGI_color_table // GL_SGIS_texture_edge_clamp // No new functions. // End GL_SGIS_texture_edge_clamp // GL_EXT_texture3D MYPFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; MYPFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; // End GL_EXT_texture3D // GL_NV_fragment_program MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; // End GL_NV_fragment_program // GL_NV_vertex_program MYPFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; MYPFNGLBINDPROGRAMNVPROC glBindProgramNV; MYPFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; MYPFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; MYPFNGLGENPROGRAMSNVPROC glGenProgramsNV; MYPFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; MYPFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; MYPFNGLGETPROGRAMIVNVPROC glGetProgramivNV; MYPFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; MYPFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; MYPFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; MYPFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; MYPFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; MYPFNGLISPROGRAMNVPROC glIsProgramNV; MYPFNGLLOADPROGRAMNVPROC glLoadProgramNV; MYPFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; MYPFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; MYPFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; MYPFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; MYPFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; MYPFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; MYPFNGLTRACKMATRIXNVPROC glTrackMatrixNV; MYPFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; MYPFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; MYPFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; MYPFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; MYPFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; MYPFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; MYPFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; MYPFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; MYPFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; MYPFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; MYPFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; MYPFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; MYPFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; MYPFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; MYPFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; MYPFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; MYPFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; MYPFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; MYPFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; MYPFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; MYPFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; MYPFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; MYPFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; MYPFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; MYPFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; MYPFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; MYPFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; MYPFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; MYPFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; MYPFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; MYPFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; MYPFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; MYPFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; MYPFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; MYPFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; MYPFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; MYPFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; MYPFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; MYPFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; MYPFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; // End GL_NV_vertex_program // GL_ARB_vertex_program MYPFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; MYPFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; MYPFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; MYPFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; MYPFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; MYPFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; MYPFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; MYPFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; MYPFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; MYPFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; MYPFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; MYPFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; MYPFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; MYPFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; MYPFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; MYPFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; MYPFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; MYPFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; MYPFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; MYPFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; MYPFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; MYPFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; MYPFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; MYPFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; MYPFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; MYPFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; MYPFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; MYPFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; MYPFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; MYPFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; MYPFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; MYPFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; MYPFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; MYPFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; MYPFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; MYPFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; MYPFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; MYPFNGLPROGRAMSTRINGARBPROC glProgramStringARB; MYPFNGLBINDPROGRAMARBPROC glBindProgramARB; MYPFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; MYPFNGLGENPROGRAMSARBPROC glGenProgramsARB; MYPFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; MYPFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; MYPFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; MYPFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; MYPFNGLGETPROGRAMIVARBPROC glGetProgramivARB; MYPFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; MYPFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; MYPFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; MYPFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; MYPFNGLISPROGRAMARBPROC glIsProgramARB; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program #if defined(WIN32) /// WGL extensions follows // WGL_ARB_pixel_format MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC wglGetPixelFormatAttribivARB; MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC wglGetPixelFormatAttribfvARB; MYPFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer MYPFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB; MYPFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB; MYPFNWGLRELEASEPBUFFERDCARBPROC wglReleasePbufferDCARB; MYPFNWGLDESTROYPBUFFERARBPROC wglDestroyPbufferARB; MYPFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB; // End WGL_ARB_pbuffer // WGL_ARB_render_texture MYPFNWGLBINDTEXIMAGEARBPROC wglBindTexImageARB; MYPFNWGLRELEASETEXIMAGEARBPROC wglReleaseTexImageARB; MYPFNWGLSETPBUFFERATTRIBARBPROC wglSetPbufferAttribARB; // End WGL_ARB_render_texture // WGL_ARB_extensions_string MYPFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB; // End WGL_ARB_extensions_string #endif // defined(WIN32) protected: void initPointersToZero(); static const char* EatWhiteSpace(const char* str); static const char* EatNonWhiteSpace(const char* str); static const char* getExtensionStringPrivate(); static const char* getSystemExtensions(); }; // declare the extensions that we support and prepare the constants #ifndef GL_VERSION_1_2 #define GL_VERSION_1_2 1 #define GL_UNSIGNED_BYTE_3_3_2 0x8032 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 #define GL_UNSIGNED_INT_8_8_8_8 0x8035 #define GL_UNSIGNED_INT_10_10_10_2 0x8036 #define GL_RESCALE_NORMAL 0x803A #define GL_TEXTURE_BINDING_3D 0x806A #define GL_PACK_SKIP_IMAGES 0x806B #define GL_PACK_IMAGE_HEIGHT 0x806C #define GL_UNPACK_SKIP_IMAGES 0x806D #define GL_UNPACK_IMAGE_HEIGHT 0x806E #define GL_TEXTURE_3D 0x806F #define GL_PROXY_TEXTURE_3D 0x8070 #define GL_TEXTURE_DEPTH 0x8071 #define GL_TEXTURE_WRAP_R 0x8072 #define GL_MAX_3D_TEXTURE_SIZE 0x8073 #define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 #define GL_UNSIGNED_SHORT_5_6_5 0x8363 #define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 #define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 #define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 #define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 #define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 #define GL_BGR 0x80E0 #define GL_BGRA 0x80E1 #define GL_MAX_ELEMENTS_VERTICES 0x80E8 #define GL_MAX_ELEMENTS_INDICES 0x80E9 #define GL_CLAMP_TO_EDGE 0x812F #define GL_TEXTURE_MIN_LOD 0x813A #define GL_TEXTURE_MAX_LOD 0x813B #define GL_TEXTURE_BASE_LEVEL 0x813C #define GL_TEXTURE_MAX_LEVEL 0x813D #define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 #define GL_SINGLE_COLOR 0x81F9 #define GL_SEPARATE_SPECULAR_COLOR 0x81FA #define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 #define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 #define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 #define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 #define GL_ALIASED_POINT_SIZE_RANGE 0x846D #define GL_ALIASED_LINE_WIDTH_RANGE 0x846E #endif #ifndef GL_VERSION_1_3 #define GL_VERSION_1_3 1 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_TEXTURE2 0x84C2 #define GL_TEXTURE3 0x84C3 #define GL_TEXTURE4 0x84C4 #define GL_TEXTURE5 0x84C5 #define GL_TEXTURE6 0x84C6 #define GL_TEXTURE7 0x84C7 #define GL_TEXTURE8 0x84C8 #define GL_TEXTURE9 0x84C9 #define GL_TEXTURE10 0x84CA #define GL_TEXTURE11 0x84CB #define GL_TEXTURE12 0x84CC #define GL_TEXTURE13 0x84CD #define GL_TEXTURE14 0x84CE #define GL_TEXTURE15 0x84CF #define GL_TEXTURE16 0x84D0 #define GL_TEXTURE17 0x84D1 #define GL_TEXTURE18 0x84D2 #define GL_TEXTURE19 0x84D3 #define GL_TEXTURE20 0x84D4 #define GL_TEXTURE21 0x84D5 #define GL_TEXTURE22 0x84D6 #define GL_TEXTURE23 0x84D7 #define GL_TEXTURE24 0x84D8 #define GL_TEXTURE25 0x84D9 #define GL_TEXTURE26 0x84DA #define GL_TEXTURE27 0x84DB #define GL_TEXTURE28 0x84DC #define GL_TEXTURE29 0x84DD #define GL_TEXTURE30 0x84DE #define GL_TEXTURE31 0x84DF #define GL_ACTIVE_TEXTURE 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 #define GL_MAX_TEXTURE_UNITS 0x84E2 #define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 #define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 #define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 #define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 #define GL_MULTISAMPLE 0x809D #define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E #define GL_SAMPLE_ALPHA_TO_ONE 0x809F #define GL_SAMPLE_COVERAGE 0x80A0 #define GL_SAMPLE_BUFFERS 0x80A8 #define GL_SAMPLES 0x80A9 #define GL_SAMPLE_COVERAGE_VALUE 0x80AA #define GL_SAMPLE_COVERAGE_INVERT 0x80AB #define GL_MULTISAMPLE_BIT 0x20000000 #define GL_NORMAL_MAP 0x8511 #define GL_REFLECTION_MAP 0x8512 #define GL_TEXTURE_CUBE_MAP 0x8513 #define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 #define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 #define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 #define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A #define GL_PROXY_TEXTURE_CUBE_MAP 0x851B #define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C #define GL_COMPRESSED_ALPHA 0x84E9 #define GL_COMPRESSED_LUMINANCE 0x84EA #define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB #define GL_COMPRESSED_INTENSITY 0x84EC #define GL_COMPRESSED_RGB 0x84ED #define GL_COMPRESSED_RGBA 0x84EE #define GL_TEXTURE_COMPRESSION_HINT 0x84EF #define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 #define GL_TEXTURE_COMPRESSED 0x86A1 #define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 #define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 #define GL_CLAMP_TO_BORDER 0x812D #define GL_CLAMP_TO_BORDER_SGIS 0x812D #define GL_COMBINE 0x8570 #define GL_COMBINE_RGB 0x8571 #define GL_COMBINE_ALPHA 0x8572 #define GL_SOURCE0_RGB 0x8580 #define GL_SOURCE1_RGB 0x8581 #define GL_SOURCE2_RGB 0x8582 #define GL_SOURCE0_ALPHA 0x8588 #define GL_SOURCE1_ALPHA 0x8589 #define GL_SOURCE2_ALPHA 0x858A #define GL_OPERAND0_RGB 0x8590 #define GL_OPERAND1_RGB 0x8591 #define GL_OPERAND2_RGB 0x8592 #define GL_OPERAND0_ALPHA 0x8598 #define GL_OPERAND1_ALPHA 0x8599 #define GL_OPERAND2_ALPHA 0x859A #define GL_RGB_SCALE 0x8573 #define GL_ADD_SIGNED 0x8574 #define GL_INTERPOLATE 0x8575 #define GL_SUBTRACT 0x84E7 #define GL_CONSTANT 0x8576 #define GL_PRIMARY_COLOR 0x8577 #define GL_PREVIOUS 0x8578 #define GL_DOT3_RGB 0x86AE #define GL_DOT3_RGBA 0x86AF #endif #ifndef GL_VERSION_1_4 #define GL_VERSION_1_4 1 #define GL_BLEND_DST_RGB 0x80C8 #define GL_BLEND_SRC_RGB 0x80C9 #define GL_BLEND_DST_ALPHA 0x80CA #define GL_BLEND_SRC_ALPHA 0x80CB #define GL_POINT_SIZE_MIN 0x8126 #define GL_POINT_SIZE_MAX 0x8127 #define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 #define GL_POINT_DISTANCE_ATTENUATION 0x8129 #define GL_GENERATE_MIPMAP 0x8191 #define GL_GENERATE_MIPMAP_HINT 0x8192 #define GL_DEPTH_COMPONENT16 0x81A5 #define GL_DEPTH_COMPONENT24 0x81A6 #define GL_DEPTH_COMPONENT32 0x81A7 #define GL_MIRRORED_REPEAT 0x8370 #define GL_FOG_COORDINATE_SOURCE 0x8450 #define GL_FOG_COORDINATE 0x8451 #define GL_FRAGMENT_DEPTH 0x8452 #define GL_CURRENT_FOG_COORDINATE 0x8453 #define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 #define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 #define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 #define GL_FOG_COORDINATE_ARRAY 0x8457 #define GL_COLOR_SUM 0x8458 #define GL_CURRENT_SECONDARY_COLOR 0x8459 #define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A #define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B #define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C #define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D #define GL_SECONDARY_COLOR_ARRAY 0x845E #define GL_MAX_TEXTURE_LOD_BIAS 0x84FD #define GL_TEXTURE_FILTER_CONTROL 0x8500 #define GL_TEXTURE_LOD_BIAS 0x8501 #define GL_INCR_WRAP 0x8507 #define GL_DECR_WRAP 0x8508 #define GL_TEXTURE_DEPTH_SIZE 0x884A #define GL_DEPTH_TEXTURE_MODE 0x884B #define GL_TEXTURE_COMPARE_MODE 0x884C #define GL_TEXTURE_COMPARE_FUNC 0x884D #define GL_COMPARE_R_TO_TEXTURE 0x884E #endif #ifndef GL_ARB_imaging #define GL_CONSTANT_COLOR 0x8001 #define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 #define GL_CONSTANT_ALPHA 0x8003 #define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 #define GL_BLEND_COLOR 0x8005 #define GL_FUNC_ADD 0x8006 #define GL_MIN 0x8007 #define GL_MAX 0x8008 #define GL_BLEND_EQUATION 0x8009 #define GL_FUNC_SUBTRACT 0x800A #define GL_FUNC_REVERSE_SUBTRACT 0x800B #define GL_CONVOLUTION_1D 0x8010 #define GL_CONVOLUTION_2D 0x8011 #define GL_SEPARABLE_2D 0x8012 #define GL_CONVOLUTION_BORDER_MODE 0x8013 #define GL_CONVOLUTION_FILTER_SCALE 0x8014 #define GL_CONVOLUTION_FILTER_BIAS 0x8015 #define GL_REDUCE 0x8016 #define GL_CONVOLUTION_FORMAT 0x8017 #define GL_CONVOLUTION_WIDTH 0x8018 #define GL_CONVOLUTION_HEIGHT 0x8019 #define GL_MAX_CONVOLUTION_WIDTH 0x801A #define GL_MAX_CONVOLUTION_HEIGHT 0x801B #define GL_POST_CONVOLUTION_RED_SCALE 0x801C #define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D #define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E #define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F #define GL_POST_CONVOLUTION_RED_BIAS 0x8020 #define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 #define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 #define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 #define GL_HISTOGRAM 0x8024 #define GL_PROXY_HISTOGRAM 0x8025 #define GL_HISTOGRAM_WIDTH 0x8026 #define GL_HISTOGRAM_FORMAT 0x8027 #define GL_HISTOGRAM_RED_SIZE 0x8028 #define GL_HISTOGRAM_GREEN_SIZE 0x8029 #define GL_HISTOGRAM_BLUE_SIZE 0x802A #define GL_HISTOGRAM_ALPHA_SIZE 0x802B #define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C #define GL_HISTOGRAM_SINK 0x802D #define GL_MINMAX 0x802E #define GL_MINMAX_FORMAT 0x802F #define GL_MINMAX_SINK 0x8030 #define GL_TABLE_TOO_LARGE 0x8031 #define GL_COLOR_MATRIX 0x80B1 #define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 #define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 #define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 #define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 #define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 #define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 #define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 #define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 #define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA #define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB #define GL_COLOR_TABLE 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 #define GL_PROXY_COLOR_TABLE 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 #define GL_COLOR_TABLE_SCALE 0x80D6 #define GL_COLOR_TABLE_BIAS 0x80D7 #define GL_COLOR_TABLE_FORMAT 0x80D8 #define GL_COLOR_TABLE_WIDTH 0x80D9 #define GL_COLOR_TABLE_RED_SIZE 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF #define GL_CONSTANT_BORDER 0x8151 #define GL_REPLICATE_BORDER 0x8153 #define GL_CONVOLUTION_BORDER_COLOR 0x8154 #endif #ifndef GL_EXT_paletted_texture #define GL_EXT_paletted_texture 1 #define GL_COLOR_INDEX1_EXT 0x80E2 #define GL_COLOR_INDEX2_EXT 0x80E3 #define GL_COLOR_INDEX4_EXT 0x80E4 #define GL_COLOR_INDEX8_EXT 0x80E5 #define GL_COLOR_INDEX12_EXT 0x80E6 #define GL_COLOR_INDEX16_EXT 0x80E7 #define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED #endif #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 #define GL_TEXTURE2_ARB 0x84C2 #define GL_TEXTURE3_ARB 0x84C3 #define GL_TEXTURE4_ARB 0x84C4 #define GL_TEXTURE5_ARB 0x84C5 #define GL_TEXTURE6_ARB 0x84C6 #define GL_TEXTURE7_ARB 0x84C7 #define GL_TEXTURE8_ARB 0x84C8 #define GL_TEXTURE9_ARB 0x84C9 #define GL_TEXTURE10_ARB 0x84CA #define GL_TEXTURE11_ARB 0x84CB #define GL_TEXTURE12_ARB 0x84CC #define GL_TEXTURE13_ARB 0x84CD #define GL_TEXTURE14_ARB 0x84CE #define GL_TEXTURE15_ARB 0x84CF #define GL_TEXTURE16_ARB 0x84D0 #define GL_TEXTURE17_ARB 0x84D1 #define GL_TEXTURE18_ARB 0x84D2 #define GL_TEXTURE19_ARB 0x84D3 #define GL_TEXTURE20_ARB 0x84D4 #define GL_TEXTURE21_ARB 0x84D5 #define GL_TEXTURE22_ARB 0x84D6 #define GL_TEXTURE23_ARB 0x84D7 #define GL_TEXTURE24_ARB 0x84D8 #define GL_TEXTURE25_ARB 0x84D9 #define GL_TEXTURE26_ARB 0x84DA #define GL_TEXTURE27_ARB 0x84DB #define GL_TEXTURE28_ARB 0x84DC #define GL_TEXTURE29_ARB 0x84DD #define GL_TEXTURE30_ARB 0x84DE #define GL_TEXTURE31_ARB 0x84DF #define GL_ACTIVE_TEXTURE_ARB 0x84E0 #define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 #define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 #endif #ifndef GL_SGI_texture_color_table #define GL_SGI_texture_color_table 1 #define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC #define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD #endif #ifndef GL_SGI_color_table #define GL_SGI_color_table 1 #define GL_COLOR_TABLE_SGI 0x80D0 #define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 #define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 #define GL_PROXY_COLOR_TABLE_SGI 0x80D3 #define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 #define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 #define GL_COLOR_TABLE_SCALE_SGI 0x80D6 #define GL_COLOR_TABLE_BIAS_SGI 0x80D7 #define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 #define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 #define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA #define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB #define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC #define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD #define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE #define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF #endif #ifndef GL_SGIS_texture_edge_clamp #define GL_SGIS_texture_edge_clamp 1 #define GL_CLAMP_TO_EDGE_SGIS 0x812F #endif #ifndef GL_EXT_texture3D #define GL_EXT_texture3D 1 #define GL_PACK_SKIP_IMAGES_EXT 0x806B #define GL_PACK_IMAGE_HEIGHT_EXT 0x806C #define GL_UNPACK_SKIP_IMAGES_EXT 0x806D #define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E #define GL_TEXTURE_3D_EXT 0x806F #define GL_PROXY_TEXTURE_3D_EXT 0x8070 #define GL_TEXTURE_DEPTH_EXT 0x8071 #define GL_TEXTURE_WRAP_R_EXT 0x8072 #define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 #endif #ifndef GL_NV_fragment_program #define GL_NV_fragment_program 1 #define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 #define GL_FRAGMENT_PROGRAM_NV 0x8870 #define GL_MAX_TEXTURE_COORDS_NV 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 #define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 #define GL_PROGRAM_ERROR_STRING_NV 0x8874 #endif #ifndef GL_NV_vertex_program #define GL_NV_vertex_program 1 #define GL_VERTEX_PROGRAM_NV 0x8620 #define GL_VERTEX_STATE_PROGRAM_NV 0x8621 #define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 #define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 #define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 #define GL_CURRENT_ATTRIB_NV 0x8626 #define GL_PROGRAM_LENGTH_NV 0x8627 #define GL_PROGRAM_STRING_NV 0x8628 #define GL_MODELVIEW_PROJECTION_NV 0x8629 #define GL_IDENTITY_NV 0x862A #define GL_INVERSE_NV 0x862B #define GL_TRANSPOSE_NV 0x862C #define GL_INVERSE_TRANSPOSE_NV 0x862D #define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E #define GL_MAX_TRACK_MATRICES_NV 0x862F #define GL_MATRIX0_NV 0x8630 #define GL_MATRIX1_NV 0x8631 #define GL_MATRIX2_NV 0x8632 #define GL_MATRIX3_NV 0x8633 #define GL_MATRIX4_NV 0x8634 #define GL_MATRIX5_NV 0x8635 #define GL_MATRIX6_NV 0x8636 #define GL_MATRIX7_NV 0x8637 #define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 #define GL_CURRENT_MATRIX_NV 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 #define GL_PROGRAM_PARAMETER_NV 0x8644 #define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 #define GL_PROGRAM_TARGET_NV 0x8646 #define GL_PROGRAM_RESIDENT_NV 0x8647 #define GL_TRACK_MATRIX_NV 0x8648 #define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 #define GL_VERTEX_PROGRAM_BINDING_NV 0x864A #define GL_PROGRAM_ERROR_POSITION_NV 0x864B #define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 #define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 #define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 #define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 #define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 #define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 #define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 #define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 #define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 #define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 #define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A #define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B #define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C #define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D #define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E #define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F #define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 #define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 #define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 #define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 #define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 #define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 #define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 #define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 #define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 #define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 #define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A #define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B #define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C #define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D #define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E #define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F #define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 #define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 #define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 #define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 #define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 #define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 #define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 #define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 #define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 #define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 #define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A #define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B #define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C #define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D #define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E #define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F #endif #ifndef GL_ARB_vertex_program #define GL_ARB_vertex_program 1 #define GL_COLOR_SUM_ARB 0x8458 #define GL_VERTEX_PROGRAM_ARB 0x8620 #define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 #define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 #define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 #define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 #define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 #define GL_PROGRAM_LENGTH_ARB 0x8627 #define GL_PROGRAM_STRING_ARB 0x8628 #define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E #define GL_MAX_PROGRAM_MATRICES_ARB 0x862F #define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 #define GL_CURRENT_MATRIX_ARB 0x8641 #define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 #define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 #define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 #define GL_PROGRAM_ERROR_POSITION_ARB 0x864B #define GL_PROGRAM_BINDING_ARB 0x8677 #define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 #define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A #define GL_PROGRAM_ERROR_STRING_ARB 0x8874 #define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 #define GL_PROGRAM_FORMAT_ARB 0x8876 #define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 #define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 #define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 #define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 #define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 #define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 #define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 #define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 #define GL_PROGRAM_PARAMETERS_ARB 0x88A8 #define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 #define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA #define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB #define GL_PROGRAM_ATTRIBS_ARB 0x88AC #define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD #define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE #define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF #define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 #define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 #define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 #define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 #define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 #define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 #define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 #define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 #define GL_MATRIX0_ARB 0x88C0 #define GL_MATRIX1_ARB 0x88C1 #define GL_MATRIX2_ARB 0x88C2 #define GL_MATRIX3_ARB 0x88C3 #define GL_MATRIX4_ARB 0x88C4 #define GL_MATRIX5_ARB 0x88C5 #define GL_MATRIX6_ARB 0x88C6 #define GL_MATRIX7_ARB 0x88C7 #define GL_MATRIX8_ARB 0x88C8 #define GL_MATRIX9_ARB 0x88C9 #define GL_MATRIX10_ARB 0x88CA #define GL_MATRIX11_ARB 0x88CB #define GL_MATRIX12_ARB 0x88CC #define GL_MATRIX13_ARB 0x88CD #define GL_MATRIX14_ARB 0x88CE #define GL_MATRIX15_ARB 0x88CF #define GL_MATRIX16_ARB 0x88D0 #define GL_MATRIX17_ARB 0x88D1 #define GL_MATRIX18_ARB 0x88D2 #define GL_MATRIX19_ARB 0x88D3 #define GL_MATRIX20_ARB 0x88D4 #define GL_MATRIX21_ARB 0x88D5 #define GL_MATRIX22_ARB 0x88D6 #define GL_MATRIX23_ARB 0x88D7 #define GL_MATRIX24_ARB 0x88D8 #define GL_MATRIX25_ARB 0x88D9 #define GL_MATRIX26_ARB 0x88DA #define GL_MATRIX27_ARB 0x88DB #define GL_MATRIX28_ARB 0x88DC #define GL_MATRIX29_ARB 0x88DD #define GL_MATRIX30_ARB 0x88DE #define GL_MATRIX31_ARB 0x88DF #endif #ifndef GL_ARB_fragment_program #define GL_ARB_fragment_program 1 #define GL_FRAGMENT_PROGRAM_ARB 0x8804 #define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 #define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 #define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 #define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 #define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 #define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A #define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B #define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C #define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D #define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E #define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F #define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 #define GL_MAX_TEXTURE_COORDS_ARB 0x8871 #define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 #endif /// WGL extensions follow #if defined(WIN32) #ifndef WGL_ARB_pixel_format #define WGL_ARB_pixel_format 1 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 #define WGL_DRAW_TO_WINDOW_ARB 0x2001 #define WGL_DRAW_TO_BITMAP_ARB 0x2002 #define WGL_ACCELERATION_ARB 0x2003 #define WGL_NEED_PALETTE_ARB 0x2004 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 #define WGL_SWAP_METHOD_ARB 0x2007 #define WGL_NUMBER_OVERLAYS_ARB 0x2008 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009 #define WGL_TRANSPARENT_ARB 0x200A #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B #define WGL_SHARE_DEPTH_ARB 0x200C #define WGL_SHARE_STENCIL_ARB 0x200D #define WGL_SHARE_ACCUM_ARB 0x200E #define WGL_SUPPORT_GDI_ARB 0x200F #define WGL_SUPPORT_OPENGL_ARB 0x2010 #define WGL_DOUBLE_BUFFER_ARB 0x2011 #define WGL_STEREO_ARB 0x2012 #define WGL_PIXEL_TYPE_ARB 0x2013 #define WGL_COLOR_BITS_ARB 0x2014 #define WGL_RED_BITS_ARB 0x2015 #define WGL_RED_SHIFT_ARB 0x2016 #define WGL_GREEN_BITS_ARB 0x2017 #define WGL_GREEN_SHIFT_ARB 0x2018 #define WGL_BLUE_BITS_ARB 0x2019 #define WGL_BLUE_SHIFT_ARB 0x201A #define WGL_ALPHA_BITS_ARB 0x201B #define WGL_ALPHA_SHIFT_ARB 0x201C #define WGL_ACCUM_BITS_ARB 0x201D #define WGL_ACCUM_RED_BITS_ARB 0x201E #define WGL_ACCUM_GREEN_BITS_ARB 0x201F #define WGL_ACCUM_BLUE_BITS_ARB 0x2020 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 #define WGL_DEPTH_BITS_ARB 0x2022 #define WGL_STENCIL_BITS_ARB 0x2023 #define WGL_AUX_BUFFERS_ARB 0x2024 #define WGL_NO_ACCELERATION_ARB 0x2025 #define WGL_GENERIC_ACCELERATION_ARB 0x2026 #define WGL_FULL_ACCELERATION_ARB 0x2027 #define WGL_SWAP_EXCHANGE_ARB 0x2028 #define WGL_SWAP_COPY_ARB 0x2029 #define WGL_SWAP_UNDEFINED_ARB 0x202A #define WGL_TYPE_RGBA_ARB 0x202B #define WGL_TYPE_COLORINDEX_ARB 0x202C #endif #ifndef WGL_ARB_pbuffer #define WGL_ARB_pbuffer 1 #define WGL_DRAW_TO_PBUFFER_ARB 0x202D #define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E #define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F #define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 #define WGL_PBUFFER_LARGEST_ARB 0x2033 #define WGL_PBUFFER_WIDTH_ARB 0x2034 #define WGL_PBUFFER_HEIGHT_ARB 0x2035 #define WGL_PBUFFER_LOST_ARB 0x2036 #endif #ifndef WGL_ARB_render_texture #define WGL_ARB_render_texture 1 #define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 #define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 #define WGL_TEXTURE_FORMAT_ARB 0x2072 #define WGL_TEXTURE_TARGET_ARB 0x2073 #define WGL_MIPMAP_TEXTURE_ARB 0x2074 #define WGL_TEXTURE_RGB_ARB 0x2075 #define WGL_TEXTURE_RGBA_ARB 0x2076 #define WGL_NO_TEXTURE_ARB 0x2077 #define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 #define WGL_TEXTURE_1D_ARB 0x2079 #define WGL_TEXTURE_2D_ARB 0x207A #define WGL_MIPMAP_LEVEL_ARB 0x207B #define WGL_CUBE_MAP_FACE_ARB 0x207C #define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 #define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 #define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 #define WGL_FRONT_LEFT_ARB 0x2083 #define WGL_FRONT_RIGHT_ARB 0x2084 #define WGL_BACK_LEFT_ARB 0x2085 #define WGL_BACK_RIGHT_ARB 0x2086 #define WGL_AUX0_ARB 0x2087 #define WGL_AUX1_ARB 0x2088 #define WGL_AUX2_ARB 0x2089 #define WGL_AUX3_ARB 0x208A #define WGL_AUX4_ARB 0x208B #define WGL_AUX5_ARB 0x208C #define WGL_AUX6_ARB 0x208D #define WGL_AUX7_ARB 0x208E #define WGL_AUX8_ARB 0x208F #define WGL_AUX9_ARB 0x2090 #endif #ifndef WGL_ARB_extensions_string #define WGL_ARB_extensions_string 1 #endif #endif // defined(WIN32) #endif // !defined(AFX_MYEXTENSIONS_H__49343774_A350_4447_88BB_ACEDB50325AD__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/LookupTables.h0000644000175000017500000002051410223377127025340 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef LOOKUPTABLES_H #define LOOKUPTABLES_H /** Lookup tables for calculating the intersection between a * plane and a cube. */ // the coordinates for each of the eight verts of the cube static double VertCoords[8*3] = { -0.5, -0.5, -0.5, 0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5, -0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5, }; // the texture coordinates for each of the eight verts of the cube static double TexCoords[8*3] = { 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0 }; // the indices of the vertices for each edge of the cube static unsigned int Edges[12*2] = { 0,1, 1,3, 3,2, 2,0, 4,5, 5,7, 7,6, 6,4, 0,4, 1,5, 3,7, 2,6 }; // I'll explain later... static unsigned int EdgeCases[256][7] = { { 0, 0, 0, 0, 0, 0, 0 }, { 3, 3, 0, 8, 0, 0, 0 }, { 3, 1, 0, 9, 0, 0, 0 }, { 4, 3, 1, 9, 8, 0, 0 }, { 3, 2, 11, 3, 0, 0, 0 }, { 4, 2, 11, 8, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 8, 11, 2, 1, 9, 0 }, { 3, 2, 10, 1, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 2, 10, 9, 0, 0, 0 }, { 5, 9, 10, 2, 3, 8, 0 }, { 4, 10, 11, 3, 1, 0, 0 }, { 5, 8, 11, 10, 1, 0, 0 }, { 5, 9, 10, 11, 3, 0, 0 }, { 4, 10, 11, 8, 9, 0, 0 }, { 3, 7, 4, 8, 0, 0, 0 }, { 4, 3, 7, 4, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 7, 3, 1, 9, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 0, 2, 11, 7, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 6, 1, 9, 4, 7, 11, 2 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 9, 10, 11, 7, 4, 0 }, { 3, 5, 9, 4, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 1, 5, 4, 0, 0, 0 }, { 5, 3, 1, 5, 4, 8, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 0, 2, 10, 5, 4, 0 }, { 6, 3, 8, 4, 5, 10, 2 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 8, 11, 10, 5, 4, 0 }, { 4, 5, 7, 8, 9, 0, 0 }, { 5, 5, 7, 3, 0, 9, 0 }, { 5, 1, 5, 7, 8, 0, 0 }, { 4, 3, 1, 5, 7, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 1, 5, 7, 11, 2, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 5, 7, 3, 2, 10, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 10, 11, 7, 5, 0, 0 }, { 3, 6, 11, 7, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 2, 6, 7, 3, 0, 0 }, { 5, 0, 2, 6, 7, 8, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 7, 3, 1, 10, 6, 0 }, { 6, 1, 0, 8, 7, 6, 10 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 9, 10, 6, 7, 8, 0 }, { 4, 6, 11, 8, 4, 0, 0 }, { 5, 4, 6, 11, 3, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 4, 6, 2, 3, 8, 0 }, { 4, 2, 6, 4, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 4, 6, 2, 1, 9, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 4, 6, 10, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 10, 6, 4, 9, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 8, 11, 6, 5, 9, 0 }, { 6, 3, 0, 9, 5, 6, 11 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 3, 1, 5, 6, 11, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 0, 2, 6, 5, 9, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 2, 6, 5, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 3, 10, 6, 5, 0, 0, 0 }, { 3, 10, 6, 5, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 2, 6, 5, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 0, 2, 6, 5, 9, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 3, 1, 5, 6, 11, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 6, 3, 0, 9, 5, 6, 11 }, { 5, 8, 11, 6, 5, 9, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 10, 6, 4, 9, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 4, 6, 10, 1, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 4, 6, 2, 1, 9, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 2, 6, 4, 0, 0, 0 }, { 5, 4, 6, 2, 3, 8, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 4, 6, 11, 3, 0, 0 }, { 4, 6, 11, 8, 4, 0, 0 }, { 5, 9, 10, 6, 7, 8, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 6, 1, 0, 8, 7, 6, 10 }, { 5, 7, 3, 1, 10, 6, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 0, 2, 6, 7, 8, 0 }, { 4, 2, 6, 7, 3, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 3, 6, 11, 7, 0, 0, 0 }, { 4, 10, 11, 7, 5, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 5, 7, 3, 2, 10, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 1, 5, 7, 11, 2, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 3, 1, 5, 7, 0, 0 }, { 5, 1, 5, 7, 8, 0, 0 }, { 5, 5, 7, 3, 0, 9, 0 }, { 4, 5, 7, 8, 9, 0, 0 }, { 5, 8, 11, 10, 5, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 6, 3, 8, 4, 5, 10, 2 }, { 5, 0, 2, 10, 5, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 3, 1, 5, 4, 8, 0 }, { 4, 1, 5, 4, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 3, 5, 9, 4, 0, 0, 0 }, { 5, 9, 10, 11, 7, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 6, 1, 9, 4, 7, 11, 2 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 0, 2, 11, 7, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 5, 7, 3, 1, 9, 4, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 3, 7, 4, 0, 0, 0 }, { 3, 7, 4, 8, 0, 0, 0 }, { 4, 10, 11, 8, 9, 0, 0 }, { 5, 9, 10, 11, 3, 0, 0 }, { 5, 8, 11, 10, 1, 0, 0 }, { 4, 10, 11, 3, 1, 0, 0 }, { 5, 9, 10, 2, 3, 8, 0 }, { 4, 2, 10, 9, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 3, 2, 10, 1, 0, 0, 0 }, { 5, 8, 11, 2, 1, 9, 0 }, { 0, 0, 0, 0, 0, 0, 0 }, { 4, 2, 11, 8, 0, 0, 0 }, { 3, 2, 11, 3, 0, 0, 0 }, { 4, 3, 1, 9, 8, 0, 0 }, { 3, 1, 0, 9, 0, 0, 0 }, { 3, 3, 0, 8, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0, 0 } }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/linux2/0000755000175000017500000000000012146213527024001 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/linux2/Makefile0000644000175000017500000000205311112570425025434 0ustar debiandebian# VolumeLibrary Makefile for linux CFLAGS = -Wall -O3 -fpermissive VPATH = ../ CC = g++ LINK = ar INCLUDE = -I../ LIBRARY = libVolume.a OBJS = ClipCube.o Extent.o MyExtensions.o PalettedImpl.o \ Plane.o Polygon.o PolygonArray.o Renderer.o RendererBase.o\ RGBABase.o SGIColorTableImpl.o SimpleRGBAImpl.o \ UnshadedBase.o VolumeRenderer.o FragmentProgramImpl.o \ SimpleRGBA2DImpl.o Paletted2DImpl.o HDRS = ClipCube.h ExtensionPointers.h Extent.h LookupTables.h \ MyExtensions.h PalettedImpl.h Plane.h Polygon.h PolygonArray.h \ Renderer.h RendererBase.h RGBABase.h SGIColorTableImpl.h \ SimpleRGBAImpl.h StaticExtensionPointers.h UnshadedBase.h \ VolumeRenderer.h FragmentProgramImpl.h SimpleRGBA2DImpl.h \ Paletted2DImpl.h # Build rules all: library library : $(OBJS) ($(LINK) rv $(LIBRARY) $(OBJS)) example: cd testdir; make cleanobj: rm *.o clean: cleanobj rm libVolume.a # Implicit rules #%.o : %.cpp $(HDRS) # $(CC) -c $(CFLAGS) $(INCLUDE) -DGL_GLEXT_PROTOTYPES -o $@ $< %.o : %.cpp $(HDRS) $(CC) -c $(CFLAGS) $(INCLUDE) -o $@ $<mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/RendererBase.h0000644000175000017500000001323610223377127025300 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 Volume Rover; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // OpenGLVolumeRendererBase.h: interface for the OpenGLVolumeRendererBase class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_OPENGLVOLUMERENDERERBASE_H__71ABAABC_1CAE_4AE1_BC1E_7AFA7F1A65F5__INCLUDED_) #define AFX_OPENGLVOLUMERENDERERBASE_H__71ABAABC_1CAE_4AE1_BC1E_7AFA7F1A65F5__INCLUDED_ #include "Plane.h" #include "Extent.h" #include "PolygonArray.h" #include "MyExtensions.h" namespace OpenGLVolumeRendering { /** The base class for all volume renderers. */ class RendererBase { public: RendererBase(); virtual ~RendererBase(); /// Initializes the renderer. Should be called again if the renderer is /// moved to a different openGL context. If this returns false, do not try /// to use it to do volumeRendering virtual bool initRenderer(); /// Makes the check necessary to determine if this renderer is /// compatible with the hardware its running on virtual bool checkCompatibility() const = 0; /// Sets the aspect ratio of the dataset. bool setAspectRatio(double ratioX, double ratioY, double ratioZ); /// Specifies the portion of the uploaded texture that should be rendered. /// The extenst should range from 0 to 1. bool setTextureSubCube(double minX, double minY, double minZ, double maxX, double maxY, double maxZ); /// Specifies that we are rendering a subportion of the full data. /// Used for out of core rendering. The extents should range from 0 to 1. bool setDataSubVolume(double minX, double minY, double minZ, double maxX, double maxY, double maxZ); /// Used for out of core rendering. The dimensions of the full dataset bool setHintDimensions(unsigned int hintDimX, unsigned int hintDimY, unsigned int hintDimZ); /// Quality is a number from 0 to 1. Lower means faster. bool setQuality(double quality); double getQuality() const; /// nearPlane is a number from 0 to 1. 0 means no clipping takes place. /// 1 means the entire volume is clipped. bool setNearPlane(double nearPlane); double getNearPlane(); /// Returns the number of planes rendered in the last call to /// renderVolume. int getNumberOfPlanesRendered() const; /// Performs the actual rendering. virtual bool renderVolume() = 0; protected: // data /// stores the polygons needed to render the volume PolygonArray m_PolygonArray; /// the number of planes rendered in the last call to renderVolume int m_NumberOfPlanesRendered; /// a flag which specifies if the renderer has been initialized bool m_BaseInitialized; /// Specifies the portion of the uploaded texture that should be rendered. /// The extenst should range from 0 to 1. Extent m_TextureSubCubeExtent; /// Specifies that we are rendering a subportion of the full data. /// Used for out of core rendering. The extents should range from 0 to 1. Extent m_DataSubCubeExtent; /// The aspect ratio of the dataset double m_RatioX, m_RatioY, m_RatioZ; /// Used for out of core rendering. The dimensions of the full dataset unsigned int m_HintDimX, m_HintDimY, m_HintDimZ; /// Quality is a number from 0 to 1. Lower means faster. double m_Quality; /// nearPlane is a number from 0 to 1. 0 means no clipping takes place. /// 1 means the entire volume is clipped. double m_NearPlane; /// Vertex array float* m_VertexArray; /// Texture coordinate array float* m_TextureArray; /// Vertex array size unsigned int m_VertexArraySize; /// Actual number of vertices in array unsigned int m_NumVertices; /// Triangle array unsigned int* m_TriangleArray; /// Triangle array size unsigned int m_TriangleArraySize; /// Actual number of triangles in array unsigned int m_NumTriangles; /// Allocates memory for the vertices and triangles bool allocateMemory(unsigned int numVerts, unsigned int numTriangles); /// Deallocates the memory for vertices and triangles void deallocateMemory(); /// Allocate the vertex array bool allocateVertexArray(unsigned int numVerts); /// Allocate the triangle array bool allocateTriangleArray(unsigned int numTriangles); /// Converts the polygon array to traingle and vertex arrays void convertToTriangles(); /// Sets the aspectRatio to a default value. bool initAspectRatio(); /// Sets all flags to default values. bool initFlags(); /// Returns a plane parallel to the view plane. Plane getViewPlane(); /// Returns the distance between planes. double getIntervalWidth() const; /// Returns a distance that is past the entire volume. double getFurthestDistance() const; /// Returns a distance that is before the entire volume. double getNearestDistance() const; /// Computes the polygons that need to be rendered virtual void computePolygons(); }; }; #endif // !defined(AFX_OPENGLVOLUMERENDERERBASE_H__71ABAABC_1CAE_4AE1_BC1E_7AFA7F1A65F5__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/src/MyExtensions.cpp0000644000175000017500000012271311007714667025745 0ustar debiandebian/* Copyright 2002-2003 The University of Texas at Austin Authors: Anthony Thane Advisor: Chandrajit Bajaj This file is part of Volume Rover. Volume Rover 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 of the License, or (at your option) any later version. Volume Rover 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 iotree; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ // MyExtensions.cpp: implementation of the MyExtensions class. // ////////////////////////////////////////////////////////////////////// #define DECLARE_STATIC_POINTERS #include "MyExtensions.h" #include #define STATIC_POINTER_PREFIX staticPointer #define CREATESTATICNAME2(a,b) a##b #define CREATESTATICNAME(a,b) CREATESTATICNAME2(a,b) // define a macro for getting the address of a function #if defined(_WIN32) // use the windows technique #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) wglGetProcAddress(#procName) ; if (procName==0) return false #elif defined(GLX_ARB_get_proc_address) // use glXGetProcAddress #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) glXGetProcAddressARB( (const GLubyte *) #procName) ; if (procName==0) return false #else // try to get the static location of the function #define INIT_PROC_POINTER(pointerType,procName) procName = (pointerType) CREATESTATICNAME(STATIC_POINTER_PREFIX,procName) ; if (procName==0) return false #endif // define a macro for getting addresses of wgl functions #if defined(_WIN32) #define INIT_WGL_PROC_POINTER(pointerType,procName) procName = (pointerType) wglGetProcAddress(#procName) ; if (procName==0) return false #else // wgl functions are only supported in windows #define INIT_WGL_PROC_POINTER(pointerType,procName) procName = 0 ; return false #endif ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// MyExtensions::MyExtensions() { initPointersToZero(); initStaticPointers(); } MyExtensions::~MyExtensions() { } bool MyExtensions::extensionExists(const char* extension, const char* allExtensions) { int extLen = strlen(extension); char* padExtName = new char[extLen + 2]; strcpy(padExtName, extension); padExtName[extLen] = ' '; padExtName[extLen+1] = 0; if (0 == strcmp(extension, "GL_VERSION_1_2")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version) { return false; } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_3")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version ) { return false; } else if (strstr(version, "1.2") == version) { //added by A.O. const char *glrenderer = (const char*)glGetString(GL_RENDERER); if (strstr(glrenderer, "Intel") && strstr(glrenderer, "GMA")) { //std::cout << "IT IS Intel GMA" << "\n"; return true; } else { return false; } } else { return true; } } if (0 == strcmp(extension, "GL_VERSION_1_4")) { const char *version = (const char*)glGetString(GL_VERSION); if (strstr(version, "1.0") == version || strstr(version, "1.1") == version || strstr(version, "1.2") == version || strstr(version, "1.3") == version) { return false; } else { return true; } } if (strstr(allExtensions, padExtName)) { delete [] padExtName; return true; } else { delete [] padExtName; return false; } } bool MyExtensions::checkExtensions(const char* requestedExtensions) { MyExtensions myExtensions; return myExtensions.initExtensions(requestedExtensions); } bool MyExtensions::initExtensions(const char* requestedExtensions) { if (!requestedExtensions) { return false; } // get the extensions string and pad it const char *extensions = getExtensionStringPrivate(); int normalExtsLen = strlen(extensions); const char* systemExtensions = getSystemExtensions(); int systemExtsLen; char* paddedExtensions; if (systemExtensions) { systemExtsLen = strlen(systemExtensions); paddedExtensions = new char[normalExtsLen + 1 + systemExtsLen + 2]; strcpy(paddedExtensions, extensions); paddedExtensions[normalExtsLen] = ' '; strcpy(paddedExtensions+normalExtsLen+1, systemExtensions); paddedExtensions[normalExtsLen + 1 + systemExtsLen] = ' '; paddedExtensions[normalExtsLen + 1 + systemExtsLen+1] = 0; } else { systemExtsLen = 0; paddedExtensions = new char[normalExtsLen+2]; strcpy(paddedExtensions, extensions); paddedExtensions[normalExtsLen] = ' '; paddedExtensions[normalExtsLen+1] = 0; } // duplicate the requested string int reqExtsLen = strlen(requestedExtensions); char* reqExts = new char[reqExtsLen+1]; strcpy(reqExts, requestedExtensions); char* currentExt; bool success = true; // Parse requested extension list for (currentExt = reqExts; (currentExt = (char*)EatWhiteSpace(currentExt)) && *currentExt; currentExt = (char*)EatNonWhiteSpace(currentExt)) { char *extEnd = (char*)EatNonWhiteSpace(currentExt); char saveChar = *extEnd; *extEnd = (char)0; if (!extensionExists(currentExt, paddedExtensions) || !initExtension(currentExt)) { // failed success = false; } *extEnd = saveChar; } delete [] paddedExtensions; delete [] reqExts; return success; } bool MyExtensions::initExtension(const char* extension) { if (0 == extension) { return false; } #ifdef GL_VERSION_1_2 else if (0 == strcmp(extension, "GL_VERSION_1_2")) { INIT_PROC_POINTER(MYPFNGLBLENDCOLORPROC, glBlendColor); INIT_PROC_POINTER(MYPFNGLBLENDEQUATIONPROC, glBlendEquation); INIT_PROC_POINTER(MYPFNGLDRAWRANGEELEMENTSPROC, glDrawRangeElements); #ifndef WIN32 INIT_PROC_POINTER(MYPFNGLCOLORTABLEPROC, glColorTable); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERFVPROC, glColorTableParameterfv); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERIVPROC, glColorTableParameteriv); INIT_PROC_POINTER(MYPFNGLCOPYCOLORTABLEPROC, glCopyColorTable); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPROC, glGetColorTable); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVPROC, glGetColorTableParameterfv); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVPROC, glGetColorTableParameteriv); INIT_PROC_POINTER(MYPFNGLCOLORSUBTABLEPROC, glColorSubTable); INIT_PROC_POINTER(MYPFNGLCOPYCOLORSUBTABLEPROC, glCopyColorSubTable); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONFILTER1DPROC, glConvolutionFilter1D); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONFILTER2DPROC, glConvolutionFilter2D); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERFPROC, glConvolutionParameterf); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERFVPROC, glConvolutionParameterfv); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERIPROC, glConvolutionParameteri); INIT_PROC_POINTER(MYPFNGLCONVOLUTIONPARAMETERIVPROC, glConvolutionParameteriv); INIT_PROC_POINTER(MYPFNGLCOPYCONVOLUTIONFILTER1DPROC, glCopyConvolutionFilter1D); INIT_PROC_POINTER(MYPFNGLCOPYCONVOLUTIONFILTER2DPROC, glCopyConvolutionFilter2D); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONFILTERPROC, glGetConvolutionFilter); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONPARAMETERFVPROC, glGetConvolutionParameterfv); INIT_PROC_POINTER(MYPFNGLGETCONVOLUTIONPARAMETERIVPROC, glGetConvolutionParameteriv); INIT_PROC_POINTER(MYPFNGLGETSEPARABLEFILTERPROC, glGetSeparableFilter); INIT_PROC_POINTER(MYPFNGLSEPARABLEFILTER2DPROC, glSeparableFilter2D); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPROC, glGetHistogram); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPARAMETERFVPROC, glGetHistogramParameterfv); INIT_PROC_POINTER(MYPFNGLGETHISTOGRAMPARAMETERIVPROC, glGetHistogramParameteriv); INIT_PROC_POINTER(MYPFNGLGETMINMAXPROC, glGetMinmax); INIT_PROC_POINTER(MYPFNGLGETMINMAXPARAMETERFVPROC, glGetMinmaxParameterfv); INIT_PROC_POINTER(MYPFNGLGETMINMAXPARAMETERIVPROC, glGetMinmaxParameteriv); INIT_PROC_POINTER(MYPFNGLHISTOGRAMPROC, glHistogram); INIT_PROC_POINTER(MYPFNGLMINMAXPROC, glMinmax); INIT_PROC_POINTER(MYPFNGLRESETHISTOGRAMPROC, glResetHistogram); INIT_PROC_POINTER(MYPFNGLRESETMINMAXPROC, glResetMinmax); #endif // ifndef WIN32 INIT_PROC_POINTER(MYPFNGLTEXIMAGE3DPROC, glTexImage3D); INIT_PROC_POINTER(MYPFNGLTEXSUBIMAGE3DPROC, glTexSubImage3D); INIT_PROC_POINTER(MYPFNGLCOPYTEXSUBIMAGE3DPROC, glCopyTexSubImage3D); return true; } #endif // GL_VERSION_1_2 #ifdef GL_VERSION_1_3 else if (0 == strcmp(extension, "GL_VERSION_1_3")) { INIT_PROC_POINTER(MYPFNGLACTIVETEXTUREPROC, glActiveTexture); INIT_PROC_POINTER(MYPFNGLCLIENTACTIVETEXTUREPROC, glClientActiveTexture); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DPROC, glMultiTexCoord1d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DVPROC, glMultiTexCoord1dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FPROC, glMultiTexCoord1f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FVPROC, glMultiTexCoord1fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IPROC, glMultiTexCoord1i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IVPROC, glMultiTexCoord1iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SPROC, glMultiTexCoord1s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SVPROC, glMultiTexCoord1sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DPROC, glMultiTexCoord2d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DVPROC, glMultiTexCoord2dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FPROC, glMultiTexCoord2f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FVPROC, glMultiTexCoord2fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IPROC, glMultiTexCoord2i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IVPROC, glMultiTexCoord2iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SPROC, glMultiTexCoord2s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SVPROC, glMultiTexCoord2sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DPROC, glMultiTexCoord3d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DVPROC, glMultiTexCoord3dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FPROC, glMultiTexCoord3f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FVPROC, glMultiTexCoord3fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IPROC, glMultiTexCoord3i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IVPROC, glMultiTexCoord3iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SPROC, glMultiTexCoord3s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SVPROC, glMultiTexCoord3sv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DPROC, glMultiTexCoord4d); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DVPROC, glMultiTexCoord4dv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FPROC, glMultiTexCoord4f); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FVPROC, glMultiTexCoord4fv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IPROC, glMultiTexCoord4i); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IVPROC, glMultiTexCoord4iv); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SPROC, glMultiTexCoord4s); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SVPROC, glMultiTexCoord4sv); INIT_PROC_POINTER(MYPFNGLLOADTRANSPOSEMATRIXFPROC, glLoadTransposeMatrixf); INIT_PROC_POINTER(MYPFNGLLOADTRANSPOSEMATRIXDPROC, glLoadTransposeMatrixd); INIT_PROC_POINTER(MYPFNGLMULTTRANSPOSEMATRIXFPROC, glMultTransposeMatrixf); INIT_PROC_POINTER(MYPFNGLMULTTRANSPOSEMATRIXDPROC, glMultTransposeMatrixd); INIT_PROC_POINTER(MYPFNGLSAMPLECOVERAGEPROC, glSampleCoverage); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE3DPROC, glCompressedTexImage3D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE2DPROC, glCompressedTexImage2D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXIMAGE1DPROC, glCompressedTexImage1D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC, glCompressedTexSubImage3D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC, glCompressedTexSubImage2D); INIT_PROC_POINTER(MYPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC, glCompressedTexSubImage1D); INIT_PROC_POINTER(MYPFNGLGETCOMPRESSEDTEXIMAGEPROC, glGetCompressedTexImage); return initExtension("GL_VERSION_1_2"); } #endif // GL_VERSION_1_3 #ifdef GL_VERSION_1_4 else if (0 == strcmp(extension, "GL_VERSION_1_4")) { INIT_PROC_POINTER(MYPFNGLBLENDFUNCSEPARATEPROC, glBlendFuncSeparate); INIT_PROC_POINTER(MYPFNGLFOGCOORDFPROC, glFogCoordf); INIT_PROC_POINTER(MYPFNGLFOGCOORDFVPROC, glFogCoordfv); INIT_PROC_POINTER(MYPFNGLFOGCOORDDPROC, glFogCoordd); INIT_PROC_POINTER(MYPFNGLFOGCOORDDVPROC, glFogCoorddv); INIT_PROC_POINTER(MYPFNGLFOGCOORDPOINTERPROC, glFogCoordPointer); INIT_PROC_POINTER(MYPFNGLMULTIDRAWARRAYSPROC, glMultiDrawArrays); INIT_PROC_POINTER(MYPFNGLMULTIDRAWELEMENTSPROC, glMultiDrawElements); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERFPROC, glPointParameterf); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERFVPROC, glPointParameterfv); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERIPROC, glPointParameteri); INIT_PROC_POINTER(MYPFNGLPOINTPARAMETERIVPROC, glPointParameteriv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BPROC, glSecondaryColor3b); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3BVPROC, glSecondaryColor3bv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DPROC, glSecondaryColor3d); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3DVPROC, glSecondaryColor3dv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FPROC, glSecondaryColor3f); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3FVPROC, glSecondaryColor3fv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IPROC, glSecondaryColor3i); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3IVPROC, glSecondaryColor3iv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SPROC, glSecondaryColor3s); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3SVPROC, glSecondaryColor3sv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBPROC, glSecondaryColor3ub); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UBVPROC, glSecondaryColor3ubv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIPROC, glSecondaryColor3ui); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3UIVPROC, glSecondaryColor3uiv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USPROC, glSecondaryColor3us); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLOR3USVPROC, glSecondaryColor3usv); INIT_PROC_POINTER(MYPFNGLSECONDARYCOLORPOINTERPROC, glSecondaryColorPointer); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2DPROC, glWindowPos2d); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2DVPROC, glWindowPos2dv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2FPROC, glWindowPos2f); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2FVPROC, glWindowPos2fv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2IPROC, glWindowPos2i); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2IVPROC, glWindowPos2iv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2SPROC, glWindowPos2s); INIT_PROC_POINTER(MYPFNGLWINDOWPOS2SVPROC, glWindowPos2sv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3DPROC, glWindowPos3d); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3DVPROC, glWindowPos3dv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3FPROC, glWindowPos3f); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3FVPROC, glWindowPos3fv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3IPROC, glWindowPos3i); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3IVPROC, glWindowPos3iv); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3SPROC, glWindowPos3s); INIT_PROC_POINTER(MYPFNGLWINDOWPOS3SVPROC, glWindowPos3sv); return initExtension("GL_VERSION_1_3"); } #endif // GL_VERSION_1_4 #ifdef GL_EXT_paletted_texture else if (0 == strcmp(extension, "GL_EXT_paletted_texture")) { INIT_PROC_POINTER(MYPFNGLCOLORTABLEEXTPROC, glColorTableEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEEXTPROC, glGetColorTableEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVEXTPROC, glGetColorTableParameterivEXT); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVEXTPROC, glGetColorTableParameterfvEXT); return true; } #endif // GL_EXT_paletted_texture #ifdef GL_ARB_multitexture else if (0 == strcmp(extension, "GL_ARB_multitexture")) { INIT_PROC_POINTER(MYPFNGLACTIVETEXTUREARBPROC, glActiveTextureARB); INIT_PROC_POINTER(MYPFNGLCLIENTACTIVETEXTUREARBPROC, glClientActiveTextureARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DARBPROC, glMultiTexCoord1dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1DVARBPROC, glMultiTexCoord1dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FARBPROC, glMultiTexCoord1fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1FVARBPROC, glMultiTexCoord1fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IARBPROC, glMultiTexCoord1iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1IVARBPROC, glMultiTexCoord1ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SARBPROC, glMultiTexCoord1sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD1SVARBPROC, glMultiTexCoord1svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DARBPROC, glMultiTexCoord2dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2DVARBPROC, glMultiTexCoord2dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FARBPROC, glMultiTexCoord2fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2FVARBPROC, glMultiTexCoord2fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IARBPROC, glMultiTexCoord2iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2IVARBPROC, glMultiTexCoord2ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SARBPROC, glMultiTexCoord2sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD2SVARBPROC, glMultiTexCoord2svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DARBPROC, glMultiTexCoord3dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3DVARBPROC, glMultiTexCoord3dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FARBPROC, glMultiTexCoord3fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3FVARBPROC, glMultiTexCoord3fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IARBPROC, glMultiTexCoord3iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3IVARBPROC, glMultiTexCoord3ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SARBPROC, glMultiTexCoord3sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD3SVARBPROC, glMultiTexCoord3svARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DARBPROC, glMultiTexCoord4dARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4DVARBPROC, glMultiTexCoord4dvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FARBPROC, glMultiTexCoord4fARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4FVARBPROC, glMultiTexCoord4fvARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IARBPROC, glMultiTexCoord4iARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4IVARBPROC, glMultiTexCoord4ivARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SARBPROC, glMultiTexCoord4sARB); INIT_PROC_POINTER(MYPFNGLMULTITEXCOORD4SVARBPROC, glMultiTexCoord4svARB); return true; } #endif // GL_ARB_multitexture #ifdef GL_SGI_texture_color_table else if (0 == strcmp(extension, "GL_SGI_texture_color_table")) { return true; } #endif // GL_SGI_texture_color_table #ifdef GL_SGI_color_table else if (0 == strcmp(extension, "GL_SGI_color_table")) { INIT_PROC_POINTER(MYPFNGLCOLORTABLESGIPROC, glColorTableSGI); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERFVSGIPROC, glColorTableParameterfvSGI); INIT_PROC_POINTER(MYPFNGLCOLORTABLEPARAMETERIVSGIPROC, glColorTableParameterivSGI); INIT_PROC_POINTER(MYPFNGLCOPYCOLORTABLESGIPROC, glCopyColorTableSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLESGIPROC, glGetColorTableSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERFVSGIPROC, glGetColorTableParameterfvSGI); INIT_PROC_POINTER(MYPFNGLGETCOLORTABLEPARAMETERIVSGIPROC, glGetColorTableParameterivSGI); return true; } #endif // GL_SGI_color_table #ifdef GL_SGIS_texture_edge_clamp else if (0 == strcmp(extension, "GL_SGIS_texture_edge_clamp")) { return true; } #endif // GL_SGIS_texture_edge_clamp #ifdef GL_EXT_texture3D else if (0 == strcmp(extension, "GL_EXT_texture3D")) { INIT_PROC_POINTER(MYPFNGLTEXIMAGE3DEXTPROC, glTexImage3DEXT); INIT_PROC_POINTER(MYPFNGLTEXSUBIMAGE3DEXTPROC, glTexSubImage3DEXT); return true; } #endif // GL_EXT_texture3D #ifdef GL_NV_fragment_program else if (0 == strcmp(extension, "GL_NV_fragment_program")) { INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4FNVPROC, glProgramNamedParameter4fNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4DNVPROC, glProgramNamedParameter4dNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC, glProgramNamedParameter4fvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC, glProgramNamedParameter4dvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC, glGetProgramNamedParameterfvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC, glGetProgramNamedParameterdvNV); return true; } #endif // GL_NV_fragment_program #ifdef GL_NV_vertex_program else if (0 == strcmp(extension, "GL_NV_vertex_program")) { INIT_PROC_POINTER(MYPFNGLAREPROGRAMSRESIDENTNVPROC, glAreProgramsResidentNV); INIT_PROC_POINTER(MYPFNGLBINDPROGRAMNVPROC, glBindProgramNV); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMSNVPROC, glDeleteProgramsNV); INIT_PROC_POINTER(MYPFNGLEXECUTEPROGRAMNVPROC, glExecuteProgramNV); INIT_PROC_POINTER(MYPFNGLGENPROGRAMSNVPROC, glGenProgramsNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMPARAMETERDVNVPROC, glGetProgramParameterdvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMPARAMETERFVNVPROC, glGetProgramParameterfvNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVNVPROC, glGetProgramivNV); INIT_PROC_POINTER(MYPFNGLGETPROGRAMSTRINGNVPROC, glGetProgramStringNV); INIT_PROC_POINTER(MYPFNGLGETTRACKMATRIXIVNVPROC, glGetTrackMatrixivNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVNVPROC, glGetVertexAttribdvNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVNVPROC, glGetVertexAttribfvNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVNVPROC, glGetVertexAttribivNV); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVNVPROC, glGetVertexAttribPointervNV); INIT_PROC_POINTER(MYPFNGLISPROGRAMNVPROC, glIsProgramNV); INIT_PROC_POINTER(MYPFNGLLOADPROGRAMNVPROC, glLoadProgramNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4DNVPROC, glProgramParameter4dNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4DVNVPROC, glProgramParameter4dvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4FNVPROC, glProgramParameter4fNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETER4FVNVPROC, glProgramParameter4fvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETERS4DVNVPROC, glProgramParameters4dvNV); INIT_PROC_POINTER(MYPFNGLPROGRAMPARAMETERS4FVNVPROC, glProgramParameters4fvNV); INIT_PROC_POINTER(MYPFNGLREQUESTRESIDENTPROGRAMSNVPROC, glRequestResidentProgramsNV); INIT_PROC_POINTER(MYPFNGLTRACKMATRIXNVPROC, glTrackMatrixNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERNVPROC, glVertexAttribPointerNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DNVPROC, glVertexAttrib1dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVNVPROC, glVertexAttrib1dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FNVPROC, glVertexAttrib1fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVNVPROC, glVertexAttrib1fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SNVPROC, glVertexAttrib1sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVNVPROC, glVertexAttrib1svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DNVPROC, glVertexAttrib2dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVNVPROC, glVertexAttrib2dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FNVPROC, glVertexAttrib2fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVNVPROC, glVertexAttrib2fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SNVPROC, glVertexAttrib2sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVNVPROC, glVertexAttrib2svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DNVPROC, glVertexAttrib3dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVNVPROC, glVertexAttrib3dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FNVPROC, glVertexAttrib3fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVNVPROC, glVertexAttrib3fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SNVPROC, glVertexAttrib3sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVNVPROC, glVertexAttrib3svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DNVPROC, glVertexAttrib4dNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVNVPROC, glVertexAttrib4dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FNVPROC, glVertexAttrib4fNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVNVPROC, glVertexAttrib4fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SNVPROC, glVertexAttrib4sNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVNVPROC, glVertexAttrib4svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBNVPROC, glVertexAttrib4ubNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVNVPROC, glVertexAttrib4ubvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1DVNVPROC, glVertexAttribs1dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1FVNVPROC, glVertexAttribs1fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS1SVNVPROC, glVertexAttribs1svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2DVNVPROC, glVertexAttribs2dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2FVNVPROC, glVertexAttribs2fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS2SVNVPROC, glVertexAttribs2svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3DVNVPROC, glVertexAttribs3dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3FVNVPROC, glVertexAttribs3fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS3SVNVPROC, glVertexAttribs3svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4DVNVPROC, glVertexAttribs4dvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4FVNVPROC, glVertexAttribs4fvNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4SVNVPROC, glVertexAttribs4svNV); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBS4UBVNVPROC, glVertexAttribs4ubvNV); return true; } #endif // GL_NV_vertex_program #ifdef GL_ARB_vertex_program else if (0 == strcmp(extension, "GL_ARB_vertex_program")) { INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DARBPROC, glVertexAttrib1dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1DVARBPROC, glVertexAttrib1dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FARBPROC, glVertexAttrib1fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1FVARBPROC, glVertexAttrib1fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SARBPROC, glVertexAttrib1sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB1SVARBPROC, glVertexAttrib1svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DARBPROC, glVertexAttrib2dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2DVARBPROC, glVertexAttrib2dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FARBPROC, glVertexAttrib2fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2FVARBPROC, glVertexAttrib2fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SARBPROC, glVertexAttrib2sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB2SVARBPROC, glVertexAttrib2svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DARBPROC, glVertexAttrib3dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3DVARBPROC, glVertexAttrib3dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FARBPROC, glVertexAttrib3fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3FVARBPROC, glVertexAttrib3fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SARBPROC, glVertexAttrib3sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB3SVARBPROC, glVertexAttrib3svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NBVARBPROC, glVertexAttrib4NbvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NIVARBPROC, glVertexAttrib4NivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NSVARBPROC, glVertexAttrib4NsvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBARBPROC, glVertexAttrib4NubARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUBVARBPROC, glVertexAttrib4NubvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUIVARBPROC, glVertexAttrib4NuivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4NUSVARBPROC, glVertexAttrib4NusvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4BVARBPROC, glVertexAttrib4bvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DARBPROC, glVertexAttrib4dARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4DVARBPROC, glVertexAttrib4dvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FARBPROC, glVertexAttrib4fARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4FVARBPROC, glVertexAttrib4fvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4IVARBPROC, glVertexAttrib4ivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SARBPROC, glVertexAttrib4sARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4SVARBPROC, glVertexAttrib4svARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UBVARBPROC, glVertexAttrib4ubvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4UIVARBPROC, glVertexAttrib4uivARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIB4USVARBPROC, glVertexAttrib4usvARB); INIT_PROC_POINTER(MYPFNGLVERTEXATTRIBPOINTERARBPROC, glVertexAttribPointerARB); INIT_PROC_POINTER(MYPFNGLENABLEVERTEXATTRIBARRAYARBPROC, glEnableVertexAttribArrayARB); INIT_PROC_POINTER(MYPFNGLDISABLEVERTEXATTRIBARRAYARBPROC, glDisableVertexAttribArrayARB); INIT_PROC_POINTER(MYPFNGLPROGRAMSTRINGARBPROC, glProgramStringARB); INIT_PROC_POINTER(MYPFNGLBINDPROGRAMARBPROC, glBindProgramARB); INIT_PROC_POINTER(MYPFNGLDELETEPROGRAMSARBPROC, glDeleteProgramsARB); INIT_PROC_POINTER(MYPFNGLGENPROGRAMSARBPROC, glGenProgramsARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4DARBPROC, glProgramEnvParameter4dARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4DVARBPROC, glProgramEnvParameter4dvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4FARBPROC, glProgramEnvParameter4fARB); INIT_PROC_POINTER(MYPFNGLPROGRAMENVPARAMETER4FVARBPROC, glProgramEnvParameter4fvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4DARBPROC, glProgramLocalParameter4dARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4DVARBPROC, glProgramLocalParameter4dvARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4FARBPROC, glProgramLocalParameter4fARB); INIT_PROC_POINTER(MYPFNGLPROGRAMLOCALPARAMETER4FVARBPROC, glProgramLocalParameter4fvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMENVPARAMETERDVARBPROC, glGetProgramEnvParameterdvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMENVPARAMETERFVARBPROC, glGetProgramEnvParameterfvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC, glGetProgramLocalParameterdvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC, glGetProgramLocalParameterfvARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMIVARBPROC, glGetProgramivARB); INIT_PROC_POINTER(MYPFNGLGETPROGRAMSTRINGARBPROC, glGetProgramStringARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBDVARBPROC, glGetVertexAttribdvARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBFVARBPROC, glGetVertexAttribfvARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBIVARBPROC, glGetVertexAttribivARB); INIT_PROC_POINTER(MYPFNGLGETVERTEXATTRIBPOINTERVARBPROC, glGetVertexAttribPointervARB); INIT_PROC_POINTER(MYPFNGLISPROGRAMARBPROC, glIsProgramARB); return true; } #endif // GL_ARB_vertex_program #ifdef GL_ARB_fragment_program else if (0 == strcmp(extension, "GL_ARB_fragment_program")) { return true; } #endif // GL_ARB_fragment_program /// WGL extensions follows #if defined(WIN32) #ifdef WGL_ARB_pixel_format else if (0 == strcmp(extension, "WGL_ARB_pixel_format")) { INIT_WGL_PROC_POINTER(MYPFNWGLGETPIXELFORMATATTRIBIVARBPROC, wglGetPixelFormatAttribivARB); INIT_WGL_PROC_POINTER(MYPFNWGLGETPIXELFORMATATTRIBFVARBPROC, wglGetPixelFormatAttribfvARB); INIT_WGL_PROC_POINTER(MYPFNWGLCHOOSEPIXELFORMATARBPROC, wglChoosePixelFormatARB); return true; } #endif // WGL_ARB_pixel_format #ifdef WGL_ARB_pbuffer else if (0 == strcmp(extension, "WGL_ARB_pbuffer")) { INIT_WGL_PROC_POINTER(MYPFNWGLCREATEPBUFFERARBPROC, wglCreatePbufferARB); INIT_WGL_PROC_POINTER(MYPFNWGLGETPBUFFERDCARBPROC, wglGetPbufferDCARB); INIT_WGL_PROC_POINTER(MYPFNWGLRELEASEPBUFFERDCARBPROC, wglReleasePbufferDCARB); INIT_WGL_PROC_POINTER(MYPFNWGLDESTROYPBUFFERARBPROC, wglDestroyPbufferARB); INIT_WGL_PROC_POINTER(MYPFNWGLQUERYPBUFFERARBPROC, wglQueryPbufferARB); return true; } #endif // WGL_ARB_pbuffer #ifdef WGL_ARB_render_texture else if (0 == strcmp(extension, "WGL_ARB_render_texture")) { INIT_WGL_PROC_POINTER(MYPFNWGLBINDTEXIMAGEARBPROC, wglBindTexImageARB); INIT_WGL_PROC_POINTER(MYPFNWGLRELEASETEXIMAGEARBPROC, wglReleaseTexImageARB); INIT_WGL_PROC_POINTER(MYPFNWGLSETPBUFFERATTRIBARBPROC, wglSetPbufferAttribARB); return true; } #endif // WGL_ARB_render_texture #ifdef WGL_ARB_extensions_string else if (0 == strcmp(extension, "WGL_ARB_extensions_string")) { INIT_WGL_PROC_POINTER(MYPFNWGLGETEXTENSIONSSTRINGARBPROC, wglGetExtensionsStringARB); return true; } #endif // WGL_ARB_extensions_string #endif // defined(WIN32) else { return false; } } void MyExtensions::initPointersToZero() { // OpenGL version 1.2 glBlendColor = 0; glBlendEquation = 0; glDrawRangeElements = 0; glColorTable = 0; glColorTableParameterfv = 0; glColorTableParameteriv = 0; glCopyColorTable = 0; glGetColorTable = 0; glGetColorTableParameterfv = 0; glGetColorTableParameteriv = 0; glColorSubTable = 0; glCopyColorSubTable = 0; glConvolutionFilter1D = 0; glConvolutionFilter2D = 0; glConvolutionParameterf = 0; glConvolutionParameterfv = 0; glConvolutionParameteri = 0; glConvolutionParameteriv = 0; glCopyConvolutionFilter1D = 0; glCopyConvolutionFilter2D = 0; glGetConvolutionFilter = 0; glGetConvolutionParameterfv = 0; glGetConvolutionParameteriv = 0; glGetSeparableFilter = 0; glSeparableFilter2D = 0; glGetHistogram = 0; glGetHistogramParameterfv = 0; glGetHistogramParameteriv = 0; glGetMinmax = 0; glGetMinmaxParameterfv = 0; glGetMinmaxParameteriv = 0; glHistogram = 0; glMinmax = 0; glResetHistogram = 0; glResetMinmax = 0; glTexImage3D = 0; glTexSubImage3D = 0; glCopyTexSubImage3D = 0; // End OpenGL version 1.2 // OpenGL version 1.3 glActiveTexture = 0; glClientActiveTexture = 0; glMultiTexCoord1d = 0; glMultiTexCoord1dv = 0; glMultiTexCoord1f = 0; glMultiTexCoord1fv = 0; glMultiTexCoord1i = 0; glMultiTexCoord1iv = 0; glMultiTexCoord1s = 0; glMultiTexCoord1sv = 0; glMultiTexCoord2d = 0; glMultiTexCoord2dv = 0; glMultiTexCoord2f = 0; glMultiTexCoord2fv = 0; glMultiTexCoord2i = 0; glMultiTexCoord2iv = 0; glMultiTexCoord2s = 0; glMultiTexCoord2sv = 0; glMultiTexCoord3d = 0; glMultiTexCoord3dv = 0; glMultiTexCoord3f = 0; glMultiTexCoord3fv = 0; glMultiTexCoord3i = 0; glMultiTexCoord3iv = 0; glMultiTexCoord3s = 0; glMultiTexCoord3sv = 0; glMultiTexCoord4d = 0; glMultiTexCoord4dv = 0; glMultiTexCoord4f = 0; glMultiTexCoord4fv = 0; glMultiTexCoord4i = 0; glMultiTexCoord4iv = 0; glMultiTexCoord4s = 0; glMultiTexCoord4sv = 0; glLoadTransposeMatrixf = 0; glLoadTransposeMatrixd = 0; glMultTransposeMatrixf = 0; glMultTransposeMatrixd = 0; glSampleCoverage = 0; glCompressedTexImage3D = 0; glCompressedTexImage2D = 0; glCompressedTexImage1D = 0; glCompressedTexSubImage3D = 0; glCompressedTexSubImage2D = 0; glCompressedTexSubImage1D = 0; glGetCompressedTexImage = 0; // End OpenGL version 1.3 // OpenGL version 1.4 glBlendFuncSeparate = 0; glFogCoordf = 0; glFogCoordfv = 0; glFogCoordd = 0; glFogCoorddv = 0; glFogCoordPointer = 0; glMultiDrawArrays = 0; glMultiDrawElements = 0; glPointParameterf = 0; glPointParameterfv = 0; glPointParameteri = 0; glPointParameteriv = 0; glSecondaryColor3b = 0; glSecondaryColor3bv = 0; glSecondaryColor3d = 0; glSecondaryColor3dv = 0; glSecondaryColor3f = 0; glSecondaryColor3fv = 0; glSecondaryColor3i = 0; glSecondaryColor3iv = 0; glSecondaryColor3s = 0; glSecondaryColor3sv = 0; glSecondaryColor3ub = 0; glSecondaryColor3ubv = 0; glSecondaryColor3ui = 0; glSecondaryColor3uiv = 0; glSecondaryColor3us = 0; glSecondaryColor3usv = 0; glSecondaryColorPointer = 0; glWindowPos2d = 0; glWindowPos2dv = 0; glWindowPos2f = 0; glWindowPos2fv = 0; glWindowPos2i = 0; glWindowPos2iv = 0; glWindowPos2s = 0; glWindowPos2sv = 0; glWindowPos3d = 0; glWindowPos3dv = 0; glWindowPos3f = 0; glWindowPos3fv = 0; glWindowPos3i = 0; glWindowPos3iv = 0; glWindowPos3s = 0; glWindowPos3sv = 0; // End OpenGL version 1.4 // GL_EXT_paletted_texture glColorTableEXT = 0; glGetColorTableEXT = 0; glGetColorTableParameterivEXT = 0; glGetColorTableParameterfvEXT = 0; // End GL_EXT_paletted_texture // GL_ARB_multitexture glActiveTextureARB = 0; glClientActiveTextureARB = 0; glMultiTexCoord1dARB = 0; glMultiTexCoord1dvARB = 0; glMultiTexCoord1fARB = 0; glMultiTexCoord1fvARB = 0; glMultiTexCoord1iARB = 0; glMultiTexCoord1ivARB = 0; glMultiTexCoord1sARB = 0; glMultiTexCoord1svARB = 0; glMultiTexCoord2dARB = 0; glMultiTexCoord2dvARB = 0; glMultiTexCoord2fARB = 0; glMultiTexCoord2fvARB = 0; glMultiTexCoord2iARB = 0; glMultiTexCoord2ivARB = 0; glMultiTexCoord2sARB = 0; glMultiTexCoord2svARB = 0; glMultiTexCoord3dARB = 0; glMultiTexCoord3dvARB = 0; glMultiTexCoord3fARB = 0; glMultiTexCoord3fvARB = 0; glMultiTexCoord3iARB = 0; glMultiTexCoord3ivARB = 0; glMultiTexCoord3sARB = 0; glMultiTexCoord3svARB = 0; glMultiTexCoord4dARB = 0; glMultiTexCoord4dvARB = 0; glMultiTexCoord4fARB = 0; glMultiTexCoord4fvARB = 0; glMultiTexCoord4iARB = 0; glMultiTexCoord4ivARB = 0; glMultiTexCoord4sARB = 0; glMultiTexCoord4svARB = 0; // End GL_ARB_multitexture // GL_NV_fragment_program glProgramNamedParameter4fNV = 0; glProgramNamedParameter4dNV = 0; glProgramNamedParameter4fvNV = 0; glProgramNamedParameter4dvNV = 0; glGetProgramNamedParameterfvNV = 0; glGetProgramNamedParameterdvNV = 0; // End GL_NV_fragment_program // GL_NV_vertex_program glAreProgramsResidentNV = 0; glBindProgramNV = 0; glDeleteProgramsNV = 0; glExecuteProgramNV = 0; glGenProgramsNV = 0; glGetProgramParameterdvNV = 0; glGetProgramParameterfvNV = 0; glGetProgramivNV = 0; glGetProgramStringNV = 0; glGetTrackMatrixivNV = 0; glGetVertexAttribdvNV = 0; glGetVertexAttribfvNV = 0; glGetVertexAttribivNV = 0; glGetVertexAttribPointervNV = 0; glIsProgramNV = 0; glLoadProgramNV = 0; glProgramParameter4dNV = 0; glProgramParameter4dvNV = 0; glProgramParameter4fNV = 0; glProgramParameter4fvNV = 0; glProgramParameters4dvNV = 0; glProgramParameters4fvNV = 0; glRequestResidentProgramsNV = 0; glTrackMatrixNV = 0; glVertexAttribPointerNV = 0; glVertexAttrib1dNV = 0; glVertexAttrib1dvNV = 0; glVertexAttrib1fNV = 0; glVertexAttrib1fvNV = 0; glVertexAttrib1sNV = 0; glVertexAttrib1svNV = 0; glVertexAttrib2dNV = 0; glVertexAttrib2dvNV = 0; glVertexAttrib2fNV = 0; glVertexAttrib2fvNV = 0; glVertexAttrib2sNV = 0; glVertexAttrib2svNV = 0; glVertexAttrib3dNV = 0; glVertexAttrib3dvNV = 0; glVertexAttrib3fNV = 0; glVertexAttrib3fvNV = 0; glVertexAttrib3sNV = 0; glVertexAttrib3svNV = 0; glVertexAttrib4dNV = 0; glVertexAttrib4dvNV = 0; glVertexAttrib4fNV = 0; glVertexAttrib4fvNV = 0; glVertexAttrib4sNV = 0; glVertexAttrib4svNV = 0; glVertexAttrib4ubNV = 0; glVertexAttrib4ubvNV = 0; glVertexAttribs1dvNV = 0; glVertexAttribs1fvNV = 0; glVertexAttribs1svNV = 0; glVertexAttribs2dvNV = 0; glVertexAttribs2fvNV = 0; glVertexAttribs2svNV = 0; glVertexAttribs3dvNV = 0; glVertexAttribs3fvNV = 0; glVertexAttribs3svNV = 0; glVertexAttribs4dvNV = 0; glVertexAttribs4fvNV = 0; glVertexAttribs4svNV = 0; glVertexAttribs4ubvNV = 0; // End GL_NV_vertex_program // GL_ARB_vertex_program glVertexAttrib1dARB = 0; glVertexAttrib1dvARB = 0; glVertexAttrib1fARB = 0; glVertexAttrib1fvARB = 0; glVertexAttrib1sARB = 0; glVertexAttrib1svARB = 0; glVertexAttrib2dARB = 0; glVertexAttrib2dvARB = 0; glVertexAttrib2fARB = 0; glVertexAttrib2fvARB = 0; glVertexAttrib2sARB = 0; glVertexAttrib2svARB = 0; glVertexAttrib3dARB = 0; glVertexAttrib3dvARB = 0; glVertexAttrib3fARB = 0; glVertexAttrib3fvARB = 0; glVertexAttrib3sARB = 0; glVertexAttrib3svARB = 0; glVertexAttrib4NbvARB = 0; glVertexAttrib4NivARB = 0; glVertexAttrib4NsvARB = 0; glVertexAttrib4NubARB = 0; glVertexAttrib4NubvARB = 0; glVertexAttrib4NuivARB = 0; glVertexAttrib4NusvARB = 0; glVertexAttrib4bvARB = 0; glVertexAttrib4dARB = 0; glVertexAttrib4dvARB = 0; glVertexAttrib4fARB = 0; glVertexAttrib4fvARB = 0; glVertexAttrib4ivARB = 0; glVertexAttrib4sARB = 0; glVertexAttrib4svARB = 0; glVertexAttrib4ubvARB = 0; glVertexAttrib4uivARB = 0; glVertexAttrib4usvARB = 0; glVertexAttribPointerARB = 0; glEnableVertexAttribArrayARB = 0; glDisableVertexAttribArrayARB = 0; glProgramStringARB = 0; glBindProgramARB = 0; glDeleteProgramsARB = 0; glGenProgramsARB = 0; glProgramEnvParameter4dARB = 0; glProgramEnvParameter4dvARB = 0; glProgramEnvParameter4fARB = 0; glProgramEnvParameter4fvARB = 0; glProgramLocalParameter4dARB = 0; glProgramLocalParameter4dvARB = 0; glProgramLocalParameter4fARB = 0; glProgramLocalParameter4fvARB = 0; glGetProgramEnvParameterdvARB = 0; glGetProgramEnvParameterfvARB = 0; glGetProgramLocalParameterdvARB = 0; glGetProgramLocalParameterfvARB = 0; glGetProgramivARB = 0; glGetProgramStringARB = 0; glGetVertexAttribdvARB = 0; glGetVertexAttribfvARB = 0; glGetVertexAttribivARB = 0; glGetVertexAttribPointervARB = 0; glIsProgramARB = 0; // End GL_ARB_vertex_program // GL_ARB_fragment_program // No new functions. // End GL_ARB_fragment_program /// WGL extensions follows #if defined(WIN32) // WGL_ARB_pixel_format wglGetPixelFormatAttribivARB = 0; wglGetPixelFormatAttribfvARB = 0; wglChoosePixelFormatARB = 0; // End WGL_ARB_pixel_format // WGL_ARB_pbuffer wglCreatePbufferARB = 0; wglGetPbufferDCARB = 0; wglReleasePbufferDCARB = 0; wglDestroyPbufferARB = 0; wglQueryPbufferARB = 0; // End WGL_ARB_pbuffer // WGL_ARB_render_texture wglBindTexImageARB = 0; wglReleaseTexImageARB = 0; wglSetPbufferAttribARB = 0; // End WGL_ARB_render_texture #endif // defined(WIN32) } const char* MyExtensions::EatWhiteSpace(const char* str) { for (; *str && (' ' == *str || '\t' == *str || '\n' == *str); str++); return str; } const char* MyExtensions::EatNonWhiteSpace(const char* str) { for (; *str && (' ' != *str && '\t' != *str && '\n' != *str); str++); return str; } const char* MyExtensions::getExtensionStringPrivate() { const char* normalExtensions = (const char*)glGetString(GL_EXTENSIONS); return normalExtensions; } const char* MyExtensions::getSystemExtensions() { // for now, we only do wgl extensions, not glx extensions #if defined(_WIN32) MYPFNWGLGETEXTENSIONSSTRINGARBPROC mywglGetExtensionsStringARB = 0; mywglGetExtensionsStringARB = (MYPFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB"); if(mywglGetExtensionsStringARB) { return mywglGetExtensionsStringARB(wglGetCurrentDC()); } else { return 0; } #else return 0; #endif } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/setup.py0000644000175000017500000001613311004171524023477 0ustar debiandebian####################################################################### ### This file contains Distutil setup() for building ### _UTVolumeLibrary.so - opengl based volume rendering library developed at Univ. of Texas; ########################################################################### from distutils.core import setup, Extension from distutils.command.sdist import sdist from distutils.command.install_data import install_data from distutils.command.install_lib import install_lib from distutils.command.install import install from distutils.command.build import build from distutils.command.bdist_dumb import bdist_dumb from glob import glob import os, sys from os import path platform = sys.platform # HACK: replace cc with CC (gcc with g++) CC_exe = 'CC' cc_exe = 'cc' if platform in ("linux2", "darwin"): CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to',`g[n]` if platform in ('sunos5', 'linux2', 'irix6', 'darwin'): sysconfig._init_posix = my_init_posix # Change the order of commands that are called by "build" # so that 'byuld_py' comes after 'build_ext'. In this case # 'build_py' will install python modules generated by # 'build_ext'. class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] # Overwrite the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. class modified_sdist(sdist): def prune_file_list(self): """ Prune off branches that might slip into the file list as created by 'read_template()', but really don't belong there: * the build tree (typically 'build') * the release tree itself (only an issue if we ran 'sdist previously with --keep-temp, or it aborted) """ build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) # Overwrite the run method of the install_data to install the data files # in the package. class modified_install_data(install_data): def run(self): install_cmd = self.get_finalized_command('install') self.install_dir = getattr(install_cmd, 'install_lib')+"UTpackages" #print "install_dir", self.install_dir return install_data.run(self) packFullName = "UTpackages.UTvolrend" packName = "UTvolrend" # List of the python packages to be included in this distribution. # sdist does not go recursively into subpackages so they need to be # explicitly listed. # From these packages only the python modules will be taken packages = [packFullName, packFullName+".Tests"] # List of the other (not python) files included in the distribution . # MANIFEST.in lists these files, so they are included in the distribution. data_files = [( path.join(packName, 'Tests'), [ path.join(packName, 'Tests', 'ct_head.rawiv'), path.join(packName, 'Tests', 'colormap.map') ] ) ] # libVolume.a source_files = ["ClipCube.cpp", "Extent.cpp", "FragmentProgramARBImpl.cpp", "FragmentProgramImpl.cpp", "MyExtensions.cpp", "PalettedImpl.cpp", "Plane.cpp", "Polygon.cpp", "PolygonArray.cpp", "Renderer.cpp", "RendererBase.cpp", "RGBABase.cpp", "SGIColorTableImpl.cpp", "SimpleRGBAImpl.cpp", "UnshadedBase.cpp", "VolumeRenderer.cpp", "VolumeRendererFactory.cpp", "SimpleRGBA2DImpl.cpp", "Paletted2DImpl.cpp"] for i in range(len(source_files)): source_files[i] = path.join("src", source_files[i]) source_files.append(path.join(packName, "utvollib.i")) import numpy numpy_include = numpy.get_include() source_include = ["src", numpy_include] source_macros = [] if platform == "darwin": source_macros = [("__APPLE__", None)] source_include.append("/System/Library/Frameworks/OpenGL.framework/Headers") elif platform in ["sunos5", "irix6"]: source_macros = [("UNIX", None)] elif platform == "win32": source_macros = [("WIN32", None)] # describe the extensions: extensions = [] # _UTVolumeLibrary.so #utlibraries = ["GL"] # libVolume is included automatically utlibraries = {'posix': ['GL'], 'nt': ['OPENGL32']}.get( os.name, []) utlibdirs = [] utcflags = [] utmacros = [] #utincludedirs = ["src"] utincludedirs = source_include if platform in ('sunos5', 'irix6'): utlibraries.append({'sunos5':'Crun', 'irix6':'C'}.get(platform)) utmacros.append(('UNIX', None)) elif platform == 'darwin': utlibdirs.append('/usr/X11R6/lib') utincludedirs.append('/usr/X11R6/include') utmacros.append(('__APPLE__', None)) elif platform == "win32": utmacros.append(('WIN32', None)) utcflags = {'sunos5':['-Kpic', '-mt'] }.get(platform, []) extra_link_args = [] if platform == "darwin": (osname, host, release, version, machine) = os.uname() if release[0]== '9': # leopard extra_link_args=['-Wl,-dylib_file,/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib'] utvollib_ext = Extension ( "_UTVolumeLibrary", source_files, #[path.join(packName, "utvollib.i"),], include_dirs = utincludedirs, define_macros = utmacros, library_dirs = utlibdirs, libraries = utlibraries, extra_compile_args = utcflags, extra_link_args = extra_link_args ) extensions.append(utvollib_ext) # description of what is going to be included in the distribution and # installed. dist = setup (name = packFullName, version = '1.0', description = "Volume Rendering Library python package", author = 'Molecular Graphics Laboratory', author_email = 'mgltools@scripps.edu', download_url = 'http://www.scripps.edu/~sanner/software/packager.html', url = 'http://www.scripps.edu/~sanner/software/index.html', packages = packages, package_dir = {packFullName: packName}, data_files = data_files, ## libraries = [('Volume', ## {'sources': source_files, ## 'macros': source_macros, ## 'include_dirs': source_include, ## } ),] , ext_modules = extensions, ext_package = packFullName, cmdclass = {'sdist': modified_sdist, 'install_data': modified_install_data, 'build': modified_build, }, ) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/README0000644000175000017500000000264010260341050022637 0ustar debiandebianThis file contains Distutils interface for building a python extension of opengl based volume rendering library (VolRenLib) developed at University of Texas Austin (http://ccvweb.csres.utexas.edu/software) Building the extension requires SWIG (version 1.3.20 or higher). This distribution contains source code of the UT Volume Rendering Library (see ./src/VolRenLib-license.txt). To build the extension and install the package: python2.4 setup.py install This will: 1. build static library libVolume.a in ./build/temp.; 2. build _UTVolumeLibrary.so in ./build/lib./UTpackages/UTvolrend; 3. copy SWIG generated python module UTVolumeLibrary.py into .build/lib./UTPackages/UTvolrend; 3. install UTvolrend package into sys.exec_prefix/lib/python2.4/site-packages/UTpackages. The install command can be called with the following options: --install-platlib=INSTALL_DIR installs built extensions in specified INSTALL_DIR --no-compile do not compile .py to .pyc Example: python2.4 setup.py install --install-platlib=/home/somename/dev --no-compile To build the extensions only: python2.4 setup.py build_ext or python2.4 setup.py build To build the source distribution: python2.4 setup.py sdist This will create a .tar file containing the source in the subdirectory "dist". To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/MANIFEST.in0000644000175000017500000000076210223377127023535 0ustar debiandebian# This list all other files to be included in the distribution # which are not python modules # include, exclude.... which are not described in the setup.py. include MANIFEST.in # list of the non python module to be included in the distribution include UTvolrend/*.i include UTvolrend/CVS/* include UTvolrend/Tests/*.py include UTvolrend/Tests/CVS/* include UTvolrend/Tests/*.rawiv include UTvolrend/Tests/*.map exclude UTvolrend/UTVolumeLibrary.py include src/* include src/CVS/* include CVS/* mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/0000755000175000017500000000000012146213517023712 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/utvollib.i0000644000175000017500000001465411165234135025735 0ustar debiandebian/* * Copyright_notice */ %module UTVolumeLibrary %init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #ifdef _MSC_VER #include #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif #include "VolumeRenderer.h" #include "MyExtensions.h" #include "numpy/arrayobject.h" #include #include using namespace OpenGLVolumeRendering; static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } static void InitTexParameteri() { glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); } static bool QueryExtension(char *extName) { /* ** Search for extName in the extensions string. */ char *p; char *end; int extNameLen; extNameLen = strlen(extName); p = (char *)glGetString(GL_EXTENSIONS); if (NULL == p) { return false; } end = p + strlen(p); while (p < end) { int n = strcspn(p, " "); if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) { return true; } p += (n + 1); } return false; } /*** static bool check_size(int x, int y, int z) { GLint format ; glEnable(GL_TEXTURE_3D); //glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_RGBA8, x, y, z, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glGetTexLevelParameteriv( GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); if (format) { return true; } else { return false; } } ***/ %} %include "typemaps.i" /***************************** %typemap(python,in) (const GLubyte* data, int width, int height, int depth)(PyArrayObject *array) { if ($input != Py_None) { //we only check number of dimesion and not value of each dim int expected_dims[3] = {0,0,0}; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_UBYTE,3, expected_dims); if (! array) return NULL; $1 = (GLubyte *) array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; $3 = ((PyArrayObject *)(array))->dimensions[1]; $4 = ((PyArrayObject *)(array))->dimensions[2]; } else { array = NULL; $1 = NULL; $2 = 0; $3 = 0; $4 = 0; } } ******************/ %typemap(python,in) (const GLubyte* data)(PyArrayObject *array) { if ($input != Py_None) { array = contiguous_typed_array($input, PyArray_UBYTE,1, NULL); if (! array) return NULL; $1 = (GLubyte *) array->data; } else { array = NULL; } } %typemap(python,in) (const GLubyte* colorMap)(PyArrayObject *array) { if ($input != Py_None) { /* we only check number of dimesion and not value of each dim*/ int expected_dims[2] = {256,4}; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_UBYTE,2, expected_dims); if (! array) return NULL; $1 = (GLubyte *) array->data; } else { array = NULL; $1 = NULL; } } /* %include VolumeRenderer_i.h */ %include "src/VolumeRenderer.h" %extend VolumeRenderer { bool uploadZeroPaddedData(const void* data, int width, int height, int depth) { return self->uploadColorMappedData((GLubyte*)data, width, height, depth); } } void InitTexParameteri(); bool QueryExtension(char *extName); //bool check_size(int x, int y, int z); %native(createNumArr)PyObject *Py_createNumArr(PyObject *self, PyObject *args); %{ static PyObject *Py_createNumArr(PyObject *self, PyObject *args) { PyObject * swigPt = 0 ; npy_intp dim[1]; unsigned char *pixels; PyArrayObject *out; if(!PyArg_ParseTuple(args, "Oi", &swigPt, &dim[0])) return NULL; if (swigPt) { //swig_type_info *ty = SWIG_TypeQuery("void *"); //if ((SWIG_ConvertPtr(swigPt, (void **) &pixels, ty,1)) == -1) if ((SWIG_ConvertPtr(swigPt, (void **) &pixels, 0,0)) == -1) { printf("utvollib, createNumArr: failed to convert a pointer \n"); return NULL; } } out = (PyArrayObject *)PyArray_SimpleNewFromData(1, dim, PyArray_UBYTE, (char *)pixels); if (!out) { PyErr_SetString(PyExc_RuntimeError, "Failed to allocate memory for normals"); return NULL; } #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: out->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected out->flags |= NPY_OWNDATA; #endif return Py_BuildValue("O", (PyObject *)out); } %} mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/Tests/0000755000175000017500000000000012146213523025011 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/Tests/ct_head.rawiv0000644000175000017500000100010410223377127027453 0ustar debiandebianB|B|B|п@@@?€?€?€ +#       !*-,&    &28;:6,#   '6>@@@?9-%   *8?@@@@A?8+(    )9@?@@AA@@?8(,   & #8@@@BGIGCAA?4#1   /?@@COX[XNC@A=+0  "6@@AJ[dif\IA@?2 '!9@BCQbkemeLBA@5 *#:@ADSeohkiUDAA6 *$;A@BRepiojTCA@7&%;@ABObmlggQB@@4  #$;@ABJ\gfb`MA@?0  ."8@@ADR^\[YF@@<+41>A@@EPRSJA??6$   *#)8?@@@BDEA?@;,   0.9?@?@@@?@>2  - /9>@@@???7'  "6".7??>>??@@@<(  2@@AFJHDA@7#   0?ACO[`^TGA@3 .>@DPdmqpiYGA>*   .(   9AATp‚Œ‰‚††}mRAA3 #=@C`{Š•–’Ž‘“‘v\C@;! +>@Cb{‡‚z|‹‹…|fD?:4/?@Dbz„}tyŒy€‡ycC?;#00??Ecx‚{t€’…x„waC?;$.??Dbr}~wvŠ€ƒt\B@; !,?@C_p|{txŠy~~oWA@: '>@AWivwtwŒŠs|yhOA@7 %<@@K_juy‚Ž‹}yn^GA@2  6A?CNanv†Š„qaLAA>+ -??@EP`mv{rfTC@@8$  *8@@@FQalplf]G@@<. %2;@@AEPZ\\UHA@>1'  )3=@@ABHOJEA@?5) +3=@@??????@8+  (5;@??>???7+  '08=>??=4$ 28585-"  05'# %    ! & $<# &16)$ &6=?==:1!/AE[pzzxo]HA<#";AG]r}€€ƒs`HA56@DYoyxrsu}|pXC?)   *?AQkxti_cfpzxhMB9;AIewwh`adhkpxt^E@.  *AC]wyj_^gimlkt{nOA< 5ANu†vd]_ikjhhkwxaDA. :Cb…”Œ~jfomhhhmv„tOA9  +@ItދЂsiqsx‚Š‘YC> 4AOy„nmv~rgcmrvˆ‹‡„dC@%:@Sz€jfkl_^]a`bsu}€cC@*!=AWx|khne[Y\\SWkt~aC@0">AYxzkkmaTTZZMTgqwy_B?8#>AWtxhmnbWTTWUXhqtw^B@2/#>@Tswhip_WTPUSVepvv[B@)4 #>@Moyjeo[WUY^XXcpusVA@' !<@Efxrhph[]kf^\hxxmOA>'";AAZt{sopgnxpcgy~tbGA;! 8A@Ljx{vtoo€otƒzjQAA46@@CZqy}xonƒ…yz|pXDA>,/2  !3=A@@A@BDA@@A=/ .9@@@@?@A@=7,  )48<>A94.'#$37     " / .:*5;====3" 4==>@B@?>;-  "9??IZdgdZJ@>2 8?CVo|~|pXB@. 5?B[uzqhpy~t[C?&  *?CYqzrmjjielwrWB::APqyljhdjijekwmMA0  .AFdymhl`acegldlvbD=   Dm~kje\LEDEEEDCG\vz}}RA3 '@Eqxgi`SGDEDDEDDG\mnpzRA7 ,@Gsqbi`PEDEDDEDDEXjqtxQ@:,@Fuq[icNDDEDDEDDERiprwQ@:+AFss`hhREDEDEEDDEQilqvP@: /AEpsbhlZFDDDDEEEEPhdqvN@=3@DjwfjqcKEDDEEEEEOeisrJ@?%6@B\xigojTFEEEFEEERlivkE@124AASvqfmpaJEEFFEEG`ojx`A@- 1@@JnxiholYIFILJGRkjqvS@?) /A@Dd{shksl\TW^ZWcwvyiFA;  )@@@Ts|pjknfagmgjtw|rR@A5:A?Fdzzqgegl}z}xw{x_C@=(  ,@@@Nl}€wkdk„…‚r|xaG@@48A?@Qky€{}ŠŠ€{xp\GAA8"  (?A?AN]gmt|tbOB@A:(/>A?@BFMVZUMHB@@A:');@@???@A@@@@@=4!  !7>AAAAAC<;7.'**202>      0"-220*!-0  4:>>????>9)  %8>>CMUWUMC>1 ! :B`qadm]GDDDDDJbmbluW@1 $@LneVkeLDDDDDDENhh_lgE=  1B^t]_fTEDCCCDDDENh_cqRA.  ;Hrn`i]HDDCCCCDDDDXg`scC9 @Qƒ€ziREDDCCCACDDDSlq|vI@ 2C]‡†kWHDDCCCCBCCDDNj„„RB*=FkufXHEDCCCCCCCCCDFUo€ˆ]B2'AJtb\UFDDDCCCCCCCCDEVoc|aB8 -AMw_gXEDDDCCCCCCCCDDRjgyaA< .AOyag[FDDCCCCCDCCCDENklwcB> .APx_i`HEDCCCCCDCCDDEMjmvbB?4AQ|blgMEDCDCDCDDDDDDOhhw]A?9@R{lmiUEDCDDCCDDDDDDTlfyV@?<@QynmgWFDDDCCCDDDDDFdngvO?<=@NsnhfVGEDCCCDDDDDEKlhhrK@<=@Krrgi\KEDDDDDDCCDDRrfomFAC!:?FmwfjaVHDEDDEEDDEF]ldsgCA7.8@B`qhglfVGEEEEEEEFNkgdu\A@+&5@>QoqelphXKFEFFFFJckevsM@?& -@?Dhzjfksl`QKMKJNcodt|_AA;"=@?Pqxggptme\d^_dpgn~mI?@/4A?A\wvjjqokmymlnip}rR@@8!=@>C^z|tndhpƒ€hmwzmRB@>(  +@@>BYt~€zrˆ…yxm[H@@?.)?@>?HQ]glmkjdTFA@A?. &>?@??>=7+ 8@>DSbjmkbPB?<' ;=CYs~usrw}oS@>) :>Ij{vj_de^_iw|cC7AYs]fLDDCCCCCCCCCCCCDDF_ptjC?:A\|dgODDCCCCCCCCCCCCDDGbjrgC@Ilp^gk_NFEEEFEEEH^kdj|iC?;'>>?Pul[imbUIEFGHHL_le_trN?A1 2@>AZuibjoo`OOZ\chk`dszZ@@==@?B[wpbclljgqidjnu|uZB?@+ %0  3>AA@A@ABAD@@=2 %239;>>749       #.59872' .!0@DDB@?=5*8 /=>BQbouxvl[H>>;  .>?SouljddlmvxdH>8 .>Cbxsf^_bdb`ekyxU@7#>Cfub`dkrjhkjonip|[A5:B`t``nqcVHEHLSjndjyV@. &?Qwf^gnRDDCCDDDTljbruL>9Elt__hODCCCCCCCF[jecjhB3 '@VtfigSDCCCCCBCCCH_kabvN> 7FnejiTECCCCCCCCCCCJ`l^keB, ?Ul]jUECCCCCBCCCCCCCJda]rK9   +Bc^aYFCCCCCBCBCCCCCCDMeTlY@  :Hp[eMDCCCCBBBBBCCCCCCEZ\_gC) 'AL|xZFCCCBBBBBC@BBCCCCCLfkrF6  7C\€mJDCCCCBBBBBCBBCCCCCEZ}}J? >FogTDCCCCCCBBBBBCCCCCCCDJsPB$  AIp[ODCCCCCCCCBBBBCCCCCCDIl|bC. )AMrcRDCCCCCCCCBBBCCCCCCCDJdigD3  /AQre[DDCCCCBCBCBBCCCCCCCDMbehC9  4BTvb`EDCCCCCCBCCCCCCCCCDDNhfjC; 8AYngaEDCCCCCCCCBCCCCCCCCDOnmlD=:A_vo`EDCCCCCCCCBBCCCCCCDDTlfkD>BeoeYEDDCCCCCCCCCCCCDDDDN`eriC@=A`q_^GDDDCCCCCCCCCCCCDDESa]qcB?;?YuZ_NEDDDCCCCCCCCCCDDDI[edxZ@? :?N{^]XHDDDDCCCCDCCCDDDFUfgnsOA<4?DtlX`TFDDDDCDDDDDDDDENbjeugDA4 ,@@Z}`agRFDDDDDDEDDDDDH`icetQ?D(?>Eps]dcREEDDDDEEDEEH\l\YpfB?D 6??Jql[fhYJFEEEEEEFJ]je`orK??7!@?@OtjYdmfXKGGGJM[ksefuwT@A4 0A?@Nqtfciokf_^b`mqjqysSAA=3A?@Jj{xonqci|khsyyhM@A<0A@@CUn}}|xy„†~wk_NB@@6 8@@@BJU[`c]TOJDAAA;( 3>A@@AABBAAE??:* &18:=>?<07+    +2563+  1ACDB@?=5# :7<=DWhrx{yn]J?>=A7>D_typiefeju|kP?=& 8?Qruca[`edebbfnxdC=$  4=TtfafnrthdhnvsdksmE;$>Nrc[jof`SFDEGNcpfeplF8:AmfZbpYGDCCCCCCCOihfueC/ '@ZmY`k]FCBCCCCCCCEVmg^yT>:JrbeeTECCBCBCCCCCCF[l]joB0 $BamaeODCCCBCBBBCCCCDHcd\rT=  6Jt[jQDCCCCBBBBBBBBCCDOh[ckC( ?Yi]aFCCCCBBBBBBBBBCCCDYcYtL6  0@f^_MDCCCBBBBBBBBBBBCCCI`WcY> >Fpc_ECCCCBBBBBBABBBBCCCCOa`fC$  +BQyrPDCCCBBBBBBB@BBBCBCCCEZpqE3 6C_w`ECCCCBBBBBBBBBBBCBCCCDNuwF;<@cicIDDCCCCCCCCCCBCCCCCCCDDMilmD? ;AclcWEDDCCCCCCCCCCCCCCCCDDEV[hjB> 5@]vabGDDCCCCCCCCCCCCCCDDDDH_atdA<.AQ}\cOEDDDCCCCCCCCCCCCDDDEQca{X@9 %@E{g]]GDDDDDCCCCCCCCCDDDDL__g}I@3@?dw[cUEDDDDDCCCDCDCDDDDJ\^WtkA@&=>I{hZcPEDDDDDDDDDDDDDDGYcX^tN?<3?@[{_[dQFEDDDDDDDDDDDGZj[\vY?A) ??C]y`flZKEDDDDEEDEEL^mf[thB@D 2@@C^zhhoiWJFEEFGHS^kj_\rlF>;5:A@C^ylhnnmgc\WY`smf^duhF@@$;A?BSrztnmlcw|fbkuyrXB@@( 1AAAEYr€‚|t‡Ž‹…ywiSDAA=#  5@@@BL\eij_d[MEBAA>/ 2=@AAAAAABABD=:-  *25;;;;5$8    !(++' *9>??@A@?>;/ ,>5#! :?>IfypmJbfknxzkN??=;@\yuQDeKffdefer{iF>- ;Bev``jxvukklltla^pxM?) 3A`s\\kbTNIDDEEMkudZjwO="@SuYUkZECCCCCDCCETmk\`sH8 9Aqh_c^GCCCBCCCCCCCF`k\pi?-#A^k\hXGCCCBBCBCBCCCCGdcayP< 6KtXhXECCBBBBBBBBBBCCCMg\cnC*@blV]ECCBBBBBBBBBBBCCCEd]UpR9 /ErZaMCCCBBBBBBBABBBCCCCRdR_jB >NrX`ECCBBBBBBBBBBBBBCCCDZ\SrI, .CYy_NDCCBBBBBBBBBBBBBBCCCGaTmS:>Do~cECCCBBBBBBBBBBBBBBBCCCK_i^@ BI{sOCCCCBBBBBBBB?BBBBBBBCCCYqdA( .BQn_GCCCBBBBBBBBBBBBBBBBCCCCMugD6 8CWaYECCCCBBBBBBBBBBBBBBBCCCCHfvL>=D`^aECCCCBBBBBBBBBBBBBBBCCCCGbnPA?DheXDCCCCBBBBBBBBBBBBBBCCCCCEfpSB#AEmnPDCCCBBBBBBBBABBBBBBCCCCCGerWB+AFspMDCCCCCCBBBBBBBBBBBCBCCCDJhpYB0#AGyqODCCCCCCCBBBBBBBCBBBCCCCDNmo^B2'AHznODCCCCCCCBBBBCCBCBCCCCCCCTdpaB6 )AKziLDCCCCCCBBBBBCCBBBCCCCCCDScneC8 *AOtdJDCCCCCCBCBBBCCCCCCCCCCCDOfjjC8 *@TtdKDDCCCCCCCCBCCBBCCCCCCCCDNfhkB9 +@VuhKDDCCCCCCCCCCCCCCCCCCCCDDLdfhC8 *@WwdMDDDCCCCCCCCCCCCCCCCCCCDDNdfgC9 #@QzdTEDDCCCCCCCCCCCCCCCCCCCDDS`laA6@H~a_LDDDCCCCCCBCCCCCCCCCDDDF[\sU@3?BxeaZEDDDCCCCCCCCCCCCCCCDDEP_\zHA(G{`b[GDDDDCCCCCCCCDDDCDDI^]V}Q?9 "?@[y\cZFDDDDDDDCDDDDDDDDG]bXshB@)=7A@BQs|somjbxŒ†hdiu|qSBA@",?AADTm~„€v‘‘ŠvdOC@B; />BABFNWcga_UKCAAB>, '7>AAAAAAAB@D80% '.4364-      0;+5>F\qnUBWpbt~w_G?<0) 3@B^}]* G\?adi_{dE@8DbqVDCCCBBBBBBBBBABBBBBBBCCCCXxRA!AEeZNDCCBBBBBBBBBB@BBBBBBBCCCCQxeD,&BFh\OCCCBBBBBBBBBBBBBBBBBBCCCCPgjE8 0CIkdLCCCBBBBBBBBBAABBBBBBBCCCCU_kE>6CNojFCCCCBBBBBBBBABBBBBBBBCCCCQgpF@ 8CSt^DCCCCBBBBBBBBABBBBBBBBCCCDRhtGA ;CYuUDCCCCBBBBBBBBBBBBBBBBBCCCD[duIB=C`rWDCCCCCBBBBBBBBBBBBBBBCCCCCZerLC?Cfm]DCCCCCCBBBBBBBBBBBBBCCCCCD[kzPB!?AllYDCCCCCCBBBBBBBCBBBBCCCCCCDZgvTB'?CrjRDCCCCCBBBBBBBCBBBBCCCCCCCDUgsVB,?CthMDCCCCCCCBBBBCCBCBBCCCCCCCDNcqYB-@DvbHDDCCCCCCBBBBCCCBBBCCCCCCDDKdoZA,>DxdHDDCCCCCCCCBCCCBCCCBCCCCCDDKcoZB*eofODDDCCCCCCCCCBBCCCCCCCDDDK`[vC@->N{[cHDDCCCCCCCCCCCCCCCCCCDDF\[pc@; >AtdeXEDDCCCCCCCCCCCCCCCCDDEUcYyJ?.;>Q}]hPEDCBDDCCCCDCCCCDDDDEOe[pfA>-?AhsbfNDDDDDDDDDDCCDDDDDELe]jzG@3>?EruckREEDDDDDDDDDDDDEELdfjwL@?+@@Gotdr`MEEEEEDEEDEEEHViinxM@@( 8@@Dh|kim`LFEFFFFGPV`jtjqoJ@A' 6A@CZ{qbjspjafYddsqpiq{bE@F/ 1A@AGd||vlhcuŒznt|cKAA9; $;AABJYm{‚‚‚‘Œ†yhVFAAA3'8ACEEDHPYTNICAAAA8"+6>AABBBBA>7?!  #')+' /8;;<:4+ 0=??DGKMIC@?;/   +>@L`je[d{fms`JA?2 7@RvjD" + hztoU@=-+-ACfjY +NaC^zO(^jH@. 9Bjh%:?CJPPOOUNTl$EyN? 4?bg\WhYFCBBBBCBCJagKVj{N=@Rq`kXGBBBBBBBBBBBCKal__tG6 6Ht`pUDBBBBBBBBBBBBBCCPfWgjA%?fkfZDCBBBBBBBBBBBBBBCCSe\sQ:3FydeECCBBBBBBBBBBBBBBCCDc]ZpD$ @VrlPCCBBBBBBBBB@BBBBBBBCUaWoV64AeifECCBBBBBBBBB@BBBBBBBCF`T_l@ AFjjTDCCBBBBBBBBBABBBBBBBBCL^TpF+-BSvhHBBBBBBBBBBBBABBBBBBBCCC[ViR8  =Dcu]CCCBBBBBBBBBB?ABBBBBBBCCG`jbAADpxMCCBBBBBBBBBBB@AABBBBBBCCCQuiC-)BFkdDCCBCBBBBBBBBB@BBBBBBBBCCCFuxE;4CHc_DCCBBBBBBBBBBBABBBBBBBBCCCD`yI@ ,>IveECCCCCCBBBBBBBBBBBBBBCCCCCCDQisD?.AQ{_EDCCCBCCBBBBBA@BBBBBBBBCCCCDThtD?0AWtUDCCCCCCBBBBBABBBBBBCCBBCCCCDOgtE@.A]oPDDCCCCCCBBBBBBBBBBBBCCCCCCCDJgvF@*A^sNDDCCCCCCBBBBBBBCBCBBCCCCCCDDMcxE?%@ZsQDDCCCCCCCCBBCCCBBBCBCCCCCCDDX_uC> @Ow^EDDCCCCCCCCCCCBACCCCCCCCCDDE`^rA< @C~jNDDDCCCCCCCCCCCCCCCCCCCCCDDMfkd@8>?uaaGDDDCCCCCCCCCCCCCCCCCCCCDEZc~P@) 5=ZtfTEDDDCCCCCCCCCCCCCCCCCCCDN`_tC?'>C}fhJDDDDCCCCCCCCCCCCCCDDDDKd^|U@5 =>V€gfKDDDDDCCCCCCCCCDDDDDDHcfsqB@ .?BisciNEDDDDDDCCDCCCDDDDDG]hnJ@5 >?EpydkWGEDDDDDDDDCDDDDEIbjnxN@?)@@DfwfmgRGEEEDDEEEEEEHWjhssH@B) 0A?B\}i_fn_QJGFGGKV^hskl|iE@?+  1A@AMn{jcjqujghzxtoptwsTBA=  +?A@CQn||unim‰‹uu}}jPCA@F 2@A@BHUer‚Š…uqbOEAAA;/% ,;@AB@@CGEBA@AD=9')18>@AAA?8$>   $'&%! 3=@@??@@@?;-5?@GVckjtpcSF??6   *?B[oV;'F(dgrZD@/  8APhl0 + &>EfXB;(#!?B]j)$@DeJCCBBBBBBBBBBB@BBBBBBBBCCE`]hB'!AErtGCCBBBBBBBBBBBBBBBBBBBBBCCKctD6 0CFveDCCBBBBBBBBBBBBBBBBBBBBBBCCdsH@ 9DKpXDCCBBBBBBBBBBBBBBBBBBBBBBCCRxPC) @DWdTDCBBBBBBBBBBBBBBBBBBBBBBBBCTgWC4  BDcdMCCCBBBBBBBBBBBBBBBBBBBBBBCBV`YD;)BEkfGCCBBBBBBBBBBBBBBBBBBBBBBBB@OaaE@.BFthFCCCBBBBBBBBBBBBBBBBBBBBBBCCKghEA3BHrhECCCBBBBBBBBBBBBBBBBBBBBBCBCLilFB6BMwgECCCBBBBBBBBBBBBBBBBBBBBBCCCIgpGA% 9BS|_DCCCBBBBBBBBBBBBBBBBBBBBCCCCEguJA' ;A\NDCCCCBBBBBBBBBBBBBBBBBBCCCCCDbzNB& =?bjFDCCCCBBBBBBBBBBBBBBBBBBCCCCCDawRB& =AiiEDCCCCBBBBBBBBBABBBBBBBBBCCCCD`rUB+ =BmaEDCCCCBBBBBBBBBBBBBBBBBBCCCCDD\pZB, =BrbEDCCCCCCBBBBBBBBBBBBBBCCCCCCCDUs^B, H{iHDDDCCCCCCCCCCCCCBCCCCCCCDDE]dsA=>?zhTEDDCCCCCCCCCCCCCCCCCCCCCCDJarZ@2 8>]xfLDDDCCCCCCCCCCCCCCCCCDCDCE_d{D?)>C~kgJEDDDCCCCCCCCCCCCCCCCDDF_f|X?8 =?T‚cfJEDDDDDCCCCDCCCCDCCDDF_junB@!/?AdtcfNEDDDDDDDCDDCDDDDDDGbkrxG@3 =?Bfyal_JEDDDDDDDDDDDEEEKfkvqHA<$@@B]x_]kbQGEEDEEDEEGJTdkmzjD@? *AABNut`epn_XOIIS]muvtjzyVBA= '?AADVt|qeadgiyŠ€gku~tXEAA57AAABMfw|yyƒ‹‚|tePDAAD%#7@BA@BEJZkibXIB@AB>B)  *6>@A@@@@@@A>H."' "058:94%        #3<>>?><:7. ->?>CIMOQKDA@><(  ;@G[i_UE7eqse^RC?:  /?C^dS ) Vb\EA-   4AKj6(  I%** +cR@5,=?M|;[GEMPPQ_SWOQ _B5 ?K{d+?RMCBBBBBBBBDPH lfdDBBBBBBBBBBBBBBBBBBD^fgxD(  ANpoKCBBBBBBBBBBBBBBBBBBCFc`nT;9A_m\CCBBBBBBBBBBBBBBBBBBBCMcci?$@CijFCBBBBBBBBBBBBBBBBBBBBCD]eqC6  4BPrLCCBBBBBBBBBBB@BBBBBBBBCCOhiQA@CeoECCBBBBBBBBBBA>BBBBBBBBBCD\_d@0 'AEopDCBBBBBBBBBBBBBBBBBBBBBBCCHhuE>7CF{eDCBBBBBBBBBBBBBBBBBBBBBBBCCa{LB @DKtQCCBBBBBBBBBBBAABBBBBBBBBCCCPUC. BDVmJCCBBBBBBBBBBBABBBBBBBBBBBCCGt_D8&BDceECCBBBBBBBBBBB@ABBBBBBBBBBBCGc`E?1CEj[DCCBBBBBBBBBBB@@BBBBBBBBBCCCEe`EB7CGpYDCCBBBBBBBBBBBBBBBBBBBBBBCCBCadEC& CVq^DCCBBBBBBBBBBBBABBBBBBBBBCCCDYpJB/ ?D^s[DCCBBBBBBBBBBBBBBBBBBBBBBBCCDUsPB4 @DfyODCCCBBBBBBBBBBBBBBBBBBBBBCCCDTtYB8 @AloFDCCCCBBBBBBBBBBBBBBBBBBBBBCCDOvaC9 ADo]ECCCCBBBBBBBBBBABBBBBBBBBBCCCDLsgC: ADyZDDCCCBBBBBBBBBBBBBBBBBBBCCCCCDLnmA< AD~WDDCCCCBBBBBBBBBBBBBBBBBBCCCCCDHmqC; @DSDDCCCCCBBBBBBCCBBBBBBBBBCCCCCDFgpC; @C~SDDCCCCCCBBBBCBBBBCBBBBBBCCCCDDGhtC: @A{YDDCCCCCCCBBBBBBBBBBBBBCCCCCCDDKkqB6 ?AwfEDCCCCCCCCBCCCBBBCCBBBCCCCCCCDMnjA1=?mnGDDCCCCCCCCCCCCCBCCCBCCCCCCDDDVy\@' 8>_wRDDDCCCCCCCCCCCCBBCCCCCCCCCDDGf~I@->H}gFDDDCCCCCCCCCCCCCCCCCCCCCCDDTcwA=>@vkSEDDCCCCCCCCCCCCCCCCBCCCCCDIfuY@/ 9>Y|lNEDDDCCCCCCCCCCCCCCCCCDDDFakxC?*>AyhkKDDDDDCCCCCCCCCCCCCCDDDHej~Q?4 =>LgfIDDDDDDCCCCCCCCDDDDDDHfg|cA?.?@W†khPFEDDDDDCCDDDDDDDDEJiizmD@+:?AY…slfVHEEDDDDEDDDDEEIYmkz`CA5>@APw{lkp`PGFEFEEFJTahppwuQBA7">@AE[xxollokZOYlutiier|aFAA47A@AEVp~|uxrq|ƒmkx}r\GBB?( %:BA@BGT^j‹…‚oVGA@A@/  4?BA@@@EMEDD@?B>=6  '05;?@AAA@;)=)3 %+*#;8#   ".5642/+& #7>>?@BBA?@??>28?AISRJ;BYBBdF@&)dyI9 8>e_kFBBBBBBBBBBABBBBBBBIa_lrB"@DliQCBBBBBBBBBBBBBBBBBBBEbXtL98AUp\CBBBBBBBBBBBBBBBBBBBBCJef]A$ ?BcgFCBBBBBBBBBBBABBBBBBBBBCRckA63AHmYCCBBBBBBBBBBA@BBBBBBBBBCDbrI@@CWkECCBBBBBBBBBB>?BBBBBBBBBCCSmY@1  &ADleDCBBBBBBABBBB@BBBBBBBBBBBCFmmC@8CEvdDCBBBBBBBBBBB?BBBBBBBBBBBCC^}JB(ADH|VCCBBBBBBBBBBB@BBBBBBBBBBBCCLTB3 BDQyICBBBBBBBBBBBBAABBBBBBBBBBCCFy\D=+CD\gECCBBBBBBBBBBBBABBABBBBBBBCCDpeEB4CDg]DCCBBBBBBBBBBBBBBBBBBBBBBBCCDccEC( ;DEuUDCCBBBBBBBBBBBBBBBBBBBBBBBBCC]gFC/ ?DMwMDCCBBBBBBBBBBBBBBBBBBBBBBBBCCXkID5 ADYsSDCBBBBBBBBBBBBBBBBBBBBBBBBCCCMwMD7 ADcrSCCBBBBBBBBBBBBBBBBBBBBBBBBCCCJtUD; !AEltKCCCBBBBBBBBBBBAABBBBBBBBBBBCCIp_D=%@DqrFCCCBBBBBBBBBBBBBBBBBBBBBBBCCCFofD?+AEsdECCCBBBBBBBBBBBBBBBBBBBBBBBCCCDckD@,@Ev_DCCCBBBBBBBBBBBBBBBBBBBBBBCCCCD^pD@.AG{XDCCCCBBBBBBBBBBBBBBBBBBBBBCCCCDZpDA/AI~LDCCCCBBBBBBBBBBBBBBBBBBBCBCCCCDUtEA-@J€GDCCCCCBBBBBBBBBBBBBBBBBBBCCCCCDR|EA+@I€GDDCCCCCBBBBBBBBBBBBBBBBBBCCCCCDXyDA&?F~MDCCCCCCCBBBBBCBBBBBBBBBBCCCCCCD[uB? @C}XDDCCCCCCBBBBBCBCBBCCBBCBACCCCDD]uA: @Aw^EDCCCCCCCCBBBCCCBBCBCBBBBCCCDDFqq@3 >?nqFDDCCCCCCCBCCCCCCBBBCCCCCCCCDDQ{]@* 8>Y~RDDDCCCCCCCCCCCCCCCCCCCCCCCDDGf{H@.>E{gFDDCCCCCCCCCCCCCCCCCBCCCCDDDWksA<>@qn\EDDDCCCCCCCCCCCCCCCCBCCDDDLhyR@,;>M|fUEDDDDCCCCCCCCCCCCCCCCDDDJhqqA>,?AjvpLEDDDDDCCCCCCCCCCCDDDDDLko‚I?+>>E~vjJEDDDDDDDCCDCCDDDDDDENll…T@<,?@J€vkQHFEDDDDDDDDDDDDDEGXlo‚XA@#9?AJ~pmgXHEDDDEDDDEEGM_mkwvOAA, <@AGd{{jnpk]OGFFJMR^mkgv}aFAA* 9ABAG\w|wpgq^`j{ohgoyxdJBA>$ )=AAADNbw{vy†w{hQEBAA3*9ABAACGLc{ffjSCAAB@2 -;@AA@@?>???:>&  $.5;<:47B11  $51 %%! 1;>?A@@????<3"4?@BFJIKRVNGDCA?<-;@HOC2 Rzj2/GQC@;<@RE@PB> ;>P4 7VD=:>Y>*?B>YI?0 +gE<3&?=[j5EFCBAAAGCELYP2 BoC;>Qp#"HPGBBBBBBAAAABBDT6ll?04>`XANCBBBBBBBAAABBBBBBDA4tcA==eraCBBBBBBBBAAABBBBBBBCQUXtC64?GkkFBBBBBBBBBBABBBBBBBBBCQclM@ ??YqJCBBBBBBBBBAABBBBBBBBBCC\i^A4 /AClYDCBBBBBBBBBBBAABBBBBBBBBEejB= >BMuHCCBBBBBBBBBB@@BBBBBBBBBCCLsN<, "AC^bDCBBBBBBBBBBB:AABBBBBBBBCCDa]A> 6BDl^DCBBBBABBBBBB?BBBBBBBBBBBCC`wEA @CEu^CBBBBAABBBBBBABBBBBBBBBBBCCO…MB1 !ADHwQCCBBBBBBBBABBBBBBBBBBBBBBBCEyWC>/BDTsFCBBBBBBBBBAABBBBBABBBBBBBBCDm\DB  9DD\bDCCBBBBBBBBBBBBBBAABBBBBBBBCDkbDB+>DEg\DCBBBBBBBBBBBBABBABBBBBBBBBCD\bEC3 ADGuKCCCBBBBBBBBBBAAAABBBBBBBBBBCC`jGD9ADSwGCCBBBBBBBBBBBABABBBBBBBBBBBCCOrMD>'BDamGCCBBBBBBBBBBAABAABBBBBBBBBBCCFsUD@+BEinFCCCBBBBBBBBBBABBAABBBBBBBBBCCEr`DA/BEpmECCCBBBBBBBBBBBBBBBBBBBBBBBBCCElhEA2>EuhECCBCBBBBBBBBBBBBBBBBBBBBBBCCCDdoEA 5AGweECCBBBBBBBBBBBBBBBBBBBBBBBCCCCDZyFA$ 9AKvhDCCCCBBBBBBBBBBBBBBBBBBBBBBCCCDP€GA( :AQx_DCCCCCBBBBBBBBBBBBBBBBBBBCCCCCDOzF@' 9AUIDCCCCCBBBBBBBBBBBBBBBBBBBCCCCCDH{IB& 8AV|EDCCCCCBBBBBBBBBBBBBBBBBBBBCCCCDG€JB# 6@TwFDCCCCCCBBBBBBBBBBBBBBBBBBCCCCCDL‚JB1?O~FDCCCCCBCBBBBBBBCBBBBBBBCCCCCCCDO|FA,?G‚KDDCCCCCBBBBBCBCBBBCBBBBCBBBCCDD[|C@(?BUDDCCCCCBBBCBBCCCBCBBCBCCCCCCCDEfwA< @@ubEDCCCCCCCCBCCCCCBCCBCCCCCCCCDDGnl@5 ??gtHDDDCCCCCCCCCCCCCCCCCCCCCCCCDD[vT?* 8>N{ZEDDCCCCCCCCCCCCCCCCCCCCCCCDDLj~E@*>AynMDDDCCCCCCCCCCCCCCCCCCCBCDDEajhA9 ??_piGDDDCCCCCCCCCCCCCCCCCCDDDEQnH@$6>D}m^EDDCCDCCCCCCCCCCCCCDDDDDPo\@:#>@R†rPEDCDDDDCCCCCCCCCDDDDDEOmwpB@  :>BbƒpQEEDDDDDDDDDCDDDDDDEGXktzF@6  ??Bh…xjWLFEDDDDDCDDDDDEI\kkytF@=0@@B`…zsel`PHEEEEDEEGQftor~`D@= 3AACLe{yoppl[NT]fchlomw~iMAA: +?B@BFWn|{mcnx„lijuzo]JCBA00>A@BDHVo…‡ƒƒ…|]GCAAA5  *7>BA@BDDDHKHA@@>:+  $1;@@@?>==6(9 "!0E6     #19=??=:6770$  )=@@@CDBCCA@?@@>9*5?DL`]J>O<-Ig[TOHB@;9@JF 43"IYQA<7>N?  1PA:2=H6$U@7 )>GT  ,=EGXa>8* IY?90 9>Gm&7IDBBBABBACGNT(sS?'.?cE $DMFBBBBBABABAABBJ<W~K<??_=?HBBBBBBBBBBABBBBBBBHMZpl?-.<@_mTCBBBBBBABBAABBBBBBBBKjblA>=;FehDBBBBBBBBBBAABBBBBBBBBJggL>,);AXlIBBBBBBBBBBBAABBBBBBBBBCJi]?=  % ACPmDCBBBBBBBBBBB?ABBBBBBBBBBCIuO?83AD`WCCBBBBBBBBBBA<=ABBBBBBBBBCCXdCA>BDgYCBBBBBBBBBABAAABBBABBBBBBCCP|FA)  ACDn[CBBA@@ABBAABBBBBBABBBBBBBBCF}KC9 -BDFhNCBBBBABBBAAABBABAABBBBBBBBCDsRCA 7CDPiFCBBBBBBBBBBAAAAAAABBBBBBBBCCnXDB'>DD[aDCBBBBBBBBBBBAAAABBBBBBBBBBCD`[DC1 ADEjXDCBBBBBBBBBBBAAABBBBBBBBBBBCD]`ED9!BDIxJCCBBBBBBBBBBBAAAABBBBBBBBBBCC[mHD?*BDXoFCCBBBBBBBBBBBAAAABBBBBBBBBBBCIxODB0BDdjFCCBBABBBBBBBBAAAABBBBBBBBBBCCEtYDB 5CEmnECCBBBBBBBBBBBAAA@BBBBBBBBBBCCDmeEB 9CGsmECCBBBBBBBBBBBABA@ABBBBBBBBBCCDhjEB! ;>KwgECCCBBBBBBBBBBBBAAABBBBBBBBBCCDfrFB(=COtmECCCBBBBBBBBBBBBABABBBBBBBBBCCD[~FB,?CUnqECCCCBBBBBBBABBBBBABBBBBBBBBCCDI…JB. ?B[tcDCCCCBBBBBBABBBBBBBABBBBBBBCCCDHƒN@.?B`}KDCCCCCBBBBBBBBBBBBBBBBBBBBCBCCCG~QA,>AbwEDCCCCBBBBBBBBBBBBBBBBBBBBBCCCCDF}RA* =AapEDCCCCBBBBBBBBBBBBBBBBBBBBBCCCCDF{OA& :@\yIDCCCCCBBBBBBBBBBBBBBBBBCCCCCCCDIJA! 7?RJDCCCCCCBBBBBBBBCBBBBBBBBCCCCCCDTEA2?G„JDDCCCCCBBBBBBCBBCBBBBBBBCCCCCDD^vB@)?BzXDDCCCCCCCBBCCCCCCBCCBCCCCCCCDDFkt@; @@noEDDCCCCCCCCCCCCCCCCCCCCCCCCCDDUv`?2=>W{REDDCCCCCCCBCCCCCCCCCCCCCCCDDFi{J?$2>D{nHDDDCCCCCCCCCCCCCCCCCCBCCDDDRhtA?#?@mv`EDDDCCCCCCCCCCCCCCCCCCDDDDGj}S@0<>J„qKEDDDCCCCCCCCCCCCCCCCCDDDFezqA@0>@d~gFEDDDDDCCCCCCCCCCDDDCDDE\u‚H?1 >@Dyy\FEDDDDDDDCDCCDDDDDDCEG_t†PA>/?AI€wo_KEEDDDDDDCDDDDDDEHUktƒT@@%;?@I{ulwp^KFEDDEDDDDEEMfuox€RA@. =@AFkxkpuh]IFIONLR\hqnu~lHAA, 9A@CK`u|qcfcrqbfkkq{wgNBA@$ -?B@BENe~‚|…‰|qv€zePFCAB3 .2$  %/67346/*6   ## (7IRFWB8&=C_.P@2 >?^' :?^3 1>=EJZK1dH?@2@Xc /KDBBBBBABDHMG,  ]vE9 =Ah4 -DLKBBBBBBBABBBBBIK;68rg@!#??]@ZkNCBBBBBBBBBBBBBBBBBBBDWagCA!@?D]gDBBBBBBBBBBBBBBBBBBBBBDaiL@9 7;BSuLCBBBBBBBBBBBBBBBBBBBBBBDaZA@@@DkQCCBBBBBBBBBBBBBBBBBBBBBCC]cD?1 ,=CJdCCBBBBBBBBBBB@@BBBBBBBBBBCRoM??  <@CVWCCBBBBBBBBBBB?7ABBBBBBBBBCC\cDA&  ABD]`DCBBBBBBBBBBBBBBBBBBBBBBBCCItFB4%BCDbaCCBBBBBBBBABBBBBBAABBBBBBBCDtHC> 3BDEdRBBBB@ABBBBBBBBBAAABBBBBBBBCDrLDB=CDMeGCBBBBBBBBBBBBAAAABBBBBBBBBCDgQDC, ADD[bECCBBBBBBBBBBBA@BBBBBBBBBBBCD]XEC6BDEe`DCCBBBBBBBBBBBAABBBBBBBBBBBCDebED>(CDIyUDCCBBBBBBBBBBAAABBBBBBBBBBCCDVqHDA0CDZ|NDCCBBBBBBBBBBAAAABBBBBBBBBCCCGuPEC 6CEnoKDCCBBBBBBBBBBBA@@BBBBBBBBBBCCEp]EC#;CGwmICCCCBBBBBBBBBBBB>BBBBBBBBBBCCDlfEC% >@KxrGCCCBBBBBBBBBBBBBBBBBBBBBBBCCCDijEC) @CRsnECCCCBBBBBBBBBBBBBBBBBBBBBCBCCDfuFC. @DVmkECCCCBBBBBBBBBBBBBBBBBBBCBBCCCD\~JC2 AD`phDCCCBCBCBBBBBBBBBBBBBBBBCCCCCCDH}RC4 ACeuZDCCCCCCBBBBBABBBBBBBBBBBBBCCCCDF}X@5 AChsHDCCCCCCCBBBBABBBBBBABBBBBCCCCCDEy\B4 @BkmEDCCCCCCCBBBBBBBBBBBBBBBBCCCCCCDEt]B1 ?BjsGDCCCCCCCBBBBBBBCBBBBBBBCCCCCCCDEqXA-=BctNDDCCCCCCBBBBBBCCBBBBBBCCCCCCCCDFtR@' 9@YyMDDCCCCCCCBBBBBCCCCCBBBCCCCCCCDDJ…L@3?K†JDDCCCCCCCBBCCCCCBCBCBBCCCCCCCDD\„D@+@CUEDDCCCCCCBCCCCCCCCCCBCCCCCCCDDEitA>@AokFDDDCCCCCCCCCCCCCCCCCCCCCCCDDDHui@6 >?]WEDDDCCCCCCCCCBCCCCCCCCCCCCDDE_ƒQ?) 6>FsFDDDCCCCCCCCCBCCCCCCCCBCDDDDJr}C@&>Ar}TEDDDDDCCCCCCCCCCCCCCCCDDDDEg~`@9 >>N†oGEDDDDDCCCCCCCCCCCCCDCDDDEWt{C@# 4>Ao|\EEDDDDCDCCCDCCCCCDDDCDDEOzƒP@:?AF{VFEDDDDDDDCDCCDCDDDDDEEOp~]A@ 4>AP‚ugUHEEDDDDCDCDDDDDDEEI`u~fB@/ >?BT‚mvwfOFEEDDECDDDDEEOhvu‚cB@9#@@BP€{fiulVHEFGGEEFITgunqXBA9#>@AE]}nghkjipnfiknrp{hHAB36BAAEQj{~ty„Šujjpz|oXGBB?% #7AAACGXsƒ€‰‹Š|\HCBB?,1>BABCDFHJHEB@AA:&  ,9?A@AAAA?57  "%$  $ !)6MPMKIFEDCA5+" :AJ[UQ5'#&<(=XORVCA0 <@[< aSA4 Q,  PK>$1@I[  hB>@Dt) 7HAJQUK3 `i@B)9Ai\  $FEDCCBBBBCJF<:&)3v]@,?@i59AKLCBBBBBCBBBBBCCOY81xD6 1@@ZFJDCCCCBBBBBBBBBBBCCCCHC-kCA @>BSpLCCCCCBBBBBBBBCBBCCCCCMhpF@6 +??D]jDCCCCBCBBBBBBBBBBBCCCCCJwQ@@ ==BIsSCCCCBBBBBBBBBBBBBBBCCCCDc]C@. !?@D`hECCCCCBBBBBBBBBBBBBCBCCCDbbEA? 6@CEiGDCCCBBBBBBBBBBBBBBBBBCCCCUlLCB#  @=DIfEDCCCCCBBBBBBA9BBBBBBCBCCCD^aE>5   ACDKrHDCCCCCBBBBBBB=BBBBBBCBCCCDMrFC?   *BDDWlFCCCCCCBBBBBBBBBBABBBBBCCCDHnFDB  6BDEhXDBCBABCBBCBBBBBBBBBBBBCBCCCHnIEC) ?DDLvMCBCCBCBBCBBBBBBBBBCBBCBBCCCEeOEC6 BDEZwKDCCCBBCBCBBBBBBBCBCCCBBBCCCEn\ED? BDFonFDCCBCBCBBCCBBBBCBBBCCBCCCCCDdhFEB*CEPˆlFDCCCCCCCCCBBBBABBBCCCCCCCCCDQpIEC 2DE`gECCCCCBCCCCBBBBAABCCCBCCCCCCDFnUED%  :CFk]ECCCBCCCCCCBBB>@BBBCCCCCCCCCDEleED) ?AFw†QDDCCCCCCBBCBCCBBCBBBCCCC@BCCDEmkFC- ADI€HDDCCCCCCBCCCCCBBCCBBCCCCCCCCDDkrGC1 BEQ„nFDCCCCCCCBBCCCCBBCCCBBCCCCCCCCDazLC6 BEY[EDCCCCCCCCCCCCCABCCCCCCCCCCCCCDU|UB: BEfzPEDDCCCCCCCCCCCBABCCCCCCCCCCCCDDIy]C< BDlqHDDDCCCCCCCCCCCBBBCBCCCCCCCCCDCDEqcD< BDlkEDDDCCCCCCCBABCCCCBBBCCCCCCCCCDDEjgC< BDlqFDDDCCCCCCCBBCCCCCCBBBCCCCCCCDDDEiiB9 ABlpHDDDDCCCCCBBCCCCCCCCCBCCCCCCCDDDEkeB4 >BgrMDDDDCCCCCCCCCCCCCCCCCCCCCCCDDDDEs_A.  8@YOEDDDCCCCCCCCCCCCCCCCCCCCCCCDDDDI…U@$ /?JŠOEDDDCCCCCCCCCCCCCCCCCCCCCCDDDDEZˆIA%@C„ZEEDDDDCCCCCCCCCCCCCCCCCCCCDDDEEduBA@AqvGEDDDDCCCCCCCCCCCCCCCCCCCDDDDEEmmA< ?@F„{\FEEEDDDDDDDDDDDDDDEEEEIr~lCA# 0?AP…vfMFEEEEEEDDDDDDEEEEEFSuyuE@2<@CW…pyoTGEEEEEEDDEEEEEFTmtzrE@;?@BU…‰fsoWIFFFGFEFFFHXnlbiD@>>@BE^~seheleXZiffkosni|qUCB;2BACIgy~pyŠ€zy€‚~sy~sVEBC06BBCFOi„†€…މtYHDBC9  7CBCDGXipwiUJDBBB7  -/@B>%Ue@=%?AE  `a>:>@g= - 'mS?. 1AW{9/FQb^@4{FA+ @Ew[0 9JKICCVCBHJA4,JpC* @AEoJ;CCIOSMCBBBEBBBCDHMXQ+wF> CKbJDCCCCBBBBBBBBBBBCCCCCIdoC>>  :?@CYhDCCCCBBBBBBBBBCBBBCCCCCEsI?@" A?BDoTDCCCCBBBBBBBBBCBBBBBCCDDdPC@7 /A@DKpGDCCCCBBBBBBBBBCBBBBBCCCDeWEAA  ?ABDYaECCCCCCBBBBBBBBCBBBBCCCCD^aGCA* BACDd\ECCCBCBBBBBBBABBBBBBBBCCDHfPD@;  )?BDEo^DCCCCBBBBBBBA;BBBBBCBCCCCEh]EB@  3?EDTsQDCCBBBBBBBBBB?BBBBBCBCCCCEc\EDA"  ;CDEjnFCCABBBBBCCBBBBBBBBBBCBCCCDYeFEB/ ADDM}cDCB>BBBCCCBBBBBBBCBBCCCCCCCLwKEC: BEEa†XDCCBCBCCCCCCBBBBCCCCBBCCCCCK„YEDA "CEGv|GDCCCCBCBCCCBBBBBCBCCCCABCCCF{mFEC  +CEL†hEDCCCCCCBCCCBBBBBCCCBCCBCCCCEdyJEC  4DEV†YDDCCCCCCCCCBCBBBBBBCBBCCCCCCDYvYED) =DFbƒSDCCCCCCCBCCBBBBBBBCCCCCCCBCCDTweFD,ACFsˆJDCCCCCCCBBCBCCBCBBBCCCCCCCCCDJ€pGD/ BEI„oFDCCCCCCCCCCCCCCCCCCCCCCCCCCCDEnzID4 BER‰UDDCCCCCCCBCCCCCCCCCCCCCCCCCCCDE]ƒME9  BE]‡KDDCCCCCCCCBCCCCCCCCCCCCCCCCCCDEWŽXC< "AEkwEDDCCCCCCCCCCCCCABCCCCCCCCCCCCDDMaE= "BEsjEDDDCCCCCCCCCCCBABCCCCCCCCCCCCDDEreE>  AExeEDDDCCCCCCCCCCBBBBBBCCCCCCCCCCDDEjhD> BDwcEDDDCCCCCCBABBCCCCCBBCCCCCCCCDDDEgkC< BCoaEDDDCCCCCCBBBCCCCCCCBBCCCCCDCDDDEhiB7 @BmnFDDDDCCCCCDCCCCCCCCCCBCCCCCCDDDDF|cA1  :AdyGDDDDDCCCCCCCCCCCCCCCCCCCCCCDDDEI‡XA'  1?S‰NEDDDDCCCCCCCCCCCCCCCCCCCCCDDDDET…JA'?F…_EEDDDDCCCCCCCCCCCCCCCCCCCCDDDDE]ƒCA@BuzIEDDDDCCCCCCCCCCCCCCCCCCCDDDDEEfs@= ;@`njFEDDDDCCDCCCCCCCCCCCCCCDDDDDEHt[?2 /?H}~IEEDDDCDDBBCCCCCDCCCCCCDDDDEFe~E?$@Ar|YFEDDDDDCDDDCCCDDDDDDDDDDDEF\ƒlA@ :?PmGEEDDDDDDDDDCDDDDDDDDDDDEELs…I@2 )?Cvw[FEEDDDDDDDDCDDDDDDDDDEEEHssaA@=@Lˆr\FEEEDDDDDDCDDDDDDDDEEEHqnqC@+ )?A\…ygIFEEDDDDDDDDDDDDEEEFLsyH@67@Be…qqSGEEEEEEEDEEEEEEFH_ws€J@= 0BBEW{‰ˆ|~~neft…}v€€mJCB9  =BCFRlŒ…mZ_{‰Ž‡}_JDCB+ -ABBEJ^||~‚ŠpXICBC2  .?CABCCEGGCACB=0  -9?ABBB=1'0    !)3ENZFC8OYEG<*#  -@ADKM])0[PBA;(9ACM\0.shQB@5 ;@FD !#rbD@0  6@NX   YC@$&AJxX-!; 1o@=( >Croe/)7€MA@@EeX^\ZbS(-ABBBEBBBCJU]`[O79fC@7 4@?COYaZ[WOGBBBCBBBBBCBFINLI[_bB?A @?@CNnLEIICCCCBCCBBBBCBBCCCDEOiD?@. +A>BCWdFDCCCBCBBBBBBBBCBBCCCDDDgEB?>  DDh[EDCCCBCBBBBBBBCCBBCCCCDDmMDAB A@BDFuZEDCCCCCBBBBBBBCBCBCCCCDD`XEBA1  $A@DDOw\ECCCBBBBBBBBBBBBBCCCCCCD[lGDA?  0AAEC\wZDCCBBBBBBBBBABBBBBCCCCCDYtJDCB  9@DELrnNDCCBBBBBBBB@=BBBBBCCBCCCUlQED?* >>DFqwUCCBCCCBBBBBBBBCBBBBCCBBCCHhcFDA5 ACEP„pFCC?BCCCCCCBBBBBCCBCBCCBBCDitHEC= CEEb‚[DCCCBCCBCCCBBBBBBCCBCBCABCCZ€REDB  %CEFr|HCCCABBCBCBCBBBBBCCCCCCBACCCK„gFEC  -CEG|iECCC>CCCBCCCBBBBBCCCBBCCCCCDE~~IEC  6CENTDCCCCCCCCBCCBBBBBCCCBBCCCACDDl…PED* =BF]{HDCCBBCCBBCCBBBBBBBCCCCCCCACCDe†_ED. AEFpiEDCCCCCCCCBBBBBBCCBCBCCCC@BCDDP†jFD0 BEIaDCCCCCCCCCBCCCCCCCCCCCCCCCCCDDEu}HD6 AER‰UDCCCCCCCCCCCCCCCCCCCBCCCCCCCCCEZˆND< #AF_‚GDCCCCCCCCCBCCCCBCCCCCCCCCCCCCDDJ…WB= $AEplEDCCCCCCCCCCCCCBBCCCCCCCCCCCCCDDEzcE> $AE}SDDDCCCCCCCCCCCCAABCCCCCCCCCCCCDDDnhE? #AE‚LDDCCCCCCCCCCCCCBBBCCCCCCCCCCCDDDEikD?  AD~LDDDCCCCCCCBBBBCCCCBBCBCCCCCCCDDDEclC> BCxODDDCCCCCCCDBBCCCCCCBBBBCCCCCCDDDEqiB; AAt]EDDDCCCCCEICCCCCCCCCCDBCCCCCDDDDFzdA4  ;@nvFDDDDCCCCCCCCCCCDCCCCEDCCCCDDDDDG‚Z@+  1?`ƒMDDDDDDCCCCCCCCCCCCCCCCCCCCDDDDEIŠM@'?LeEDDDDCCCCCCCCCCCCCCCCCCCCDDDDDER†DA@Cw}MEDDDDCCCCCCBCCCCCCCCCCCDDDDDDE`pA= ;AcfmFDDDDCCCDDB@CCCCCDCCCCCDDDDDEGv[?2 -?Kw|IEDDDDCCDCCCCBDCDCCCCCDDDDDEFi‚F?%@AtuWEEDDDDDDDDDCCDCCDDDDDDDDDEE^„nA@ 5@UsnFEDDDDDDDDDDDDDDDDDDDDDDEEHr„K@3 !@Bz{[FEEDDDDDDDDDDCCDDDDDDDEEGfƒiBA9@R‹|[FEEEDDDDDDDDDDDDDDDDEEGn{E@2 @AfƒzaFEEEDDDDDCDDDDDDDEDEHls†L@< -?CrŒ}WFEEEDDDDEDDDDDEEEDQvl„Q@?5@Cb~sZJEEEEEEFEEEEEEEIav|„PA@7@CW}jvcOHFGHHHFEFHSgql}uLA@ 3AAR|…‰xpnkdkolip}‚ŠxQDA> )AAEU{ˆ|tcYWW_niiu…[GBB4 9BADOfx|||wy„†xaHCB>! $) 0=ABAABBB?7/  "# # !(1AAHMLJF9&0 'J^mTDA=>AMgVKE<3$  5  6F:&\OA7 4B^|YDBE>0 !CF 4441NzMA2 ASa@?@CB@4!8bf^L'/===>MqsB@3CsrN@@AABBF>JXSESC":ADGFCAFf{V@ /DFwjO??AA@C1>DEQJD )IHFEBC]obB, !BBZp^>>ABC7,BBBMECC/&FGIFG[mH@?  BBErndXOGDBCBBCBBBCCCCDRX[S\ZDB@B A?>CBKtoiWJCBBCCCBBBCCCCCCCFGEXbED@B(  "A>@DBQmjVECCCBBBBBBBCCBCCBBBCDUuJEAA9  .@>DDBXdbJCBBBBBBBBBBBBCBBBBCCDQxVED@A  7@@EBL`^UGCBBBBCBBBBBBCBBBBBBCDTmbEDAB" >?BEJqgQECBBBBBBBBB8=BBBBBBBCCCRooJEDA1 @?DFpwXCCABBCBBBBBBB>BBBBBBBBAAD^wYEDA=  @AFK€dECC>ABBBBBBBBBBBBCBBCBB@@CEd_EDCA %ACEVSDCC?BBBBBBBBBBBCCBBBBBBBACCZpPEDC  +CDEiwGCCC>BCCBABBBBBBBCBBBBBCBACCK~`EEC 2BEFqaDCCCBBBBABBBBBBBBCCBABBCA@CCErrFDC!  9CEJ}MDCCCBCBBBBCBBBBBBCCBBBCC>BCCDf~HDC, ?@E[wFDCCCBCCCCBBBBBBBBCBBCCBC=CCCD]„SED2 ADFlbEDCCCCCCCBBBBBBBCBBBCCCCC>CCCCI€fFD5 AEH€ZDCCCCCCCBBBBBBBBCBCBBCCCCCCCCCEnuGD: AEQ‚LDCCCCCCCCBBBCBCBBCBBCCCCCCCCCDDT‡JC? "@E`sEDCCCCCCCCCBCCCCBCCCCCCCCCCCCCDDG…TDA  %AElaEDCCCCCCCCCCCCCBCBCCCCBCCCCCCCCDEx]E@ &@EyLDDCCCCCCCCCCCCBBDBCCCCCCCCCCCCCDEghE@%AEvFDDCCCCCCCCCCCCAACACCCCCCCCCCCCCDE`nDA#ADqEDDCCCCCCBCCCCCBBCBCCCBCCCCCCCCDDEhjC@ADxFDDCCCCCCCCBCCCCBBCCCCBCCCCCCDDDDEqiB= AB|MDDDCCCCCCECBCCCCCCCCCCCCCCCCDDDDEpdA7 =ArnEDDDDCCCBCCCCCCCCCCCCEECCCCCCDDDF}[@-  2@f{LDDDDDCCCCCCCCCCCCCCCCDCCCCCDDDDGŠN@!$@P}hEDDDDDCCCCCCCCCCCCCCCCCCCDDDDDEPˆEA@CvxLEDDDDCCCCCCCCCCCCCCCCCCCDDDDDEer@>  9AeblFDDDDDCCCCCCCBCCCCCCCCCDDDDDEI{^@3 (@MuwIEDDDDDCCCCCCCCBCCCCCCCDDDDEFoG@%?BsrWEDDDDDCCDCCCCCBDCDCDDCDDDEE^~mB@ 0@W~lFEEDDDDCDDDDCCADCDCDDDDDDEGqL@2 @C|vWFEDDDDDDDDDDDCDDDDDDDDDEFZmBA 1@U‰|UFEDDDDDDDDDDDDDDDDDDEEF^~„G@3 ?Al…ƒRFEEDDDDDDDDDDDDDDDEEFay‡Q@> (@Dw‹tHEEEEDDDDEDDDDDDEEEGgvƒX@@5@DjseJEEEEEDEEDDDEEEEFJm~ŠYA@ 9@Dfsw[GEEEEFFEEEEEFMgonwPAA7ABa€woa^djdbaVOOWew†|jFA@ /BAMi€qeb[XX_hjgcbztLCB; #?AAIdu||vsv{‚‚sXDBB, -@ABDEHMV\\VKCBAA3  '8ABBAABABB=6(   (,-("*  )2>BBGGBCKJB3+# 5@BBBBHM]P^nbHICABBA9 :CBBBBAGR8]wd"1DGABABC9?A@?>>>@RM$h|Z LM@@BA?A>>@@@AAAABKIDaIRQH@>?FOB@= 7@KJCCBBB@G>?D57'JBAA@@LqTA4 BUqEBBBBA>DH;;S18O;?JB?BBA?[€NB$9EzgCBBBB??B>@5RDSC (JA@ABB@GtpC%5CO‚kCAAA@>=="VGLNF &A??@BA?Gm{F8 &BGvwG?=>>>;=!=GBWGP@0=>AA??Rt^BB ?B@Mc`@<=AA>CDCBBECDHG3=AB@=Cf^E@B3 +B@ACCgX>=BBAIMCBBBBBBKVHFC@APiKC@?A  ?A=ABCUoR>ADGKDCBBBBBBCMYOQK_niJBB>A%  A?=BBCSmvZJGGKBCBBBBBBBCJJXerxzPBC>@6  ,@=?CBDVcmdNEDBBBBBBBBBBBCCDK[lwZCD?@?  6?=CCBKUT[TJDCBBBCBBBBBBBCBCCLfztFDC?B =?>EBDWVLJ[\DBBBBBBBBBBBBBBCCFThtVDD@A( A>@EIgVDCBBC@BBBCBA=ABCCBBBCBCCL_mDEB@4  A>DElpECCB?:?  %@?EE{RCCBCABBBBBBBA?BBBBBBBB>ABCD`iFD?B  +@@DMGCCBBABB@>BBA@ABBBBBBBBABCCDX}IEBC  1@AD\lDCCCBCBBB?@@ABABBBAABBBB=BCDJREDC  8BCElXDCCCCBBBBBBABBBBBBBABBBB9ACCDn^EDB$  ACxGDDDCCCCCCBCCCCCABBCCBBBBCCCCCDDDEe`A8 >A{]EDDDDCCCCCCCCCCBBCCCCBCCCCCCDDDDF{ZA-  1@ixHDDDDCCCCCCCACCABCCCCCDCCCCCDDDEIŠMA" #@PaEDDCDCCCCCCACCCBCCCCCBCCCCDDDDEVDA@CvrHDDDDDCCCCCCCCCBCCCCCCCCCCDDDDFnsB>  6AfejEDDDDCCCCCBCCCBCCCCCCCCDDDDDEQ|^@2  #ANwxJEDDDCCCCCCCDCCCCCCCCCCDDDDEFmzF@$>BrwXEDDDDDCCCDCDCCCCCCCCCCDDDDEXykB? *@VykFEDDDDCCCDCCACCDDDCDDDDDDEGvyL@/ >B|xMEEDDDDDCDCDCDDDDDDDDDDDDF]€nBA +AT‹wOEEDDDDDDDDDDDDDDDDDDDEEZy…G@2 =Aoƒ}JEEDDDDDDDDDDDDDDDDEEFZ{…S@= $@D€„cFEEDEDDDDDDDDDDDDEEFW{ƒ[C>2@Hyk]FEEEDEDEEDDDDDDEEFWzˆ_A> 7@FmtjIEEEEEFEEDEEEEFOehpPB?7ADi„}]RMSc^XHEEFFTg~{xIA> 2ABPvvnkhb[_e`[_fiq~VDB:'@ABRn|‚€xmmmv~ƒ}gGAB0 1AABCGPX`feaTGBAB8  *:ABAAAAAAA?=1  $,11,'8  1?CCA?@AC@2& $+/29BCDETi[IECCC?7-!5BBAAAAACKfƒ|‚oVJ@ABBBCA1>A??@?>>?G[wy{|ofY@?>>>?AB=<@@CCCCB??LfYBTRv[ZC@@BBA@@A= 4@ADBBAAA@>JHSF6OZ3MB@ABBBCDB@2ABEDBAAAA@=F?@PPPEDR@>ABAABDfJC39BcJBAAAAB?>C<<;?DQDBKB*GC;=?=<>LqQ@B9 1BABCJYB=<<=;>LPDBGB>8UD=??=BCCJX?<<>>?JHCBHBBITK@A?=@dbCBB>A/  %@?=ABCD[T=;>AKLDBBDBBBFOJB@Faw[BBB>?> 5?=>BBCJVVQ??EQOCBBBBBBCJEFTbc_]DBC?>A  =><@DADUPRWJLPOGBBBBBBBBCEKPQX]\OBCA?@& @>=DCBT\KBCM\ZLDBBBBBBBBBDJGECE]dDCD??1  @=@EGm]FCBBBMQICBBBABBBBBCBAABCDa\CE@?:  &@?BEZ€FCCCB?:AFCBBB==BBBBBBA@ACCCqQEB?@  -?@DDpeDCCCBA83CDBB?7=BBBBBB?;BCCC_fED=A 3?@DFJCCCBBBB==A;=:=@@AABA>?:BCCCTsDE@@  8@@DQpDCCBBBBBBB@.>BAA>7=ABBB=@CCCI|GDBA' >@AEh^DCCBBBBCCBBAAABBBBBBBBCBBCCCDxQDBC, ?@CF|IDCCCCBBBBBBB@ABBABBBBBCCCCCCDahECB2 AADUhDCCCCCBBBCBBBBBBBAABBBBBCCCCCDLyIDC7 ABEeLCCCCCCBBBBBBBBBABBBAABBBCCCCCCDj[EC9 ADFfECCCCCBBCBBBBBBBBBBBBBBCBCCCCCCD`jFB> @EI\DCCCCCCCBCBBBCBBBCBBBBABCCCCCCDDQyFAA "BERXDCCCCCCCCBCABBCBBBBBBBBBBCCCCCDDGIDB !AE`hDCCCCCCCCCCBBBCBBCBBBBBBBCCCCCCDE€PDB "AEnnECCCCCCCCCCCBABCBCBBABCCCCCCCCDDE‚XDB #ADyTDCCCCCCCCCCCCBBBBBBBBCCCCCCCCCDDEq^DA !ACwGDDCCCCCCCCCCBCB@AABCBCCBBCCCCCDDD`dC@ ACpFDCCCCCCCCCCCBCCAA?BCCCCBCCCCCCDDD^aC> ACqFDDCCCCCCCCCCCCCCCBCCCCBCCCCCDCDDEg\B8 ?BySDDDCCCCCCCCBCABCCCCCCCCCCCCCDDDDF€UA.  4@g{HDDCCCCCCCCACBABCBCCCCCCCCCCDDDDMŒKB" %@O}cEDDDDCCCCCCCCBBCCCCCCCCCCCDDDDEXDA@CwtHDDDDDCCCCCCCCCCCCCCCCCCCCDDDDFoqB<  6AenkFDDDDCCCCCCCCDCCCCCCCCCCDDDDEN„[@/  #AMv~OEDDDDCCCCCCCDCCCCCCCCCDDDDEFk}FA ?Bpp\FEDDDDCCCCCCDCCDDCCCCDDDDDE^ngB= *@V|iFEDDDDCCDCCCDDDDCCCCDDDDDEM{{J@* ?B}uKEEDDDDCDDDCCDDDDCDDDDDDEFj~iB@ +@SŒsKEEDDDDDDDDDDDDDDDDDDDEE`u„FA+  >Ap„}IEEDDDDDDDDDDDDDDDDEEFSyˆRA9 $?Eƒ…dFEEDDDDDDDDDDDDDDEEFUy‰[C<1?J€w[FEEEDEDEEDEDDDDEEFRlƒ\B98AK^GEEEEEGEDDEEEEFKdmwSB< :BEiˆq^KFFW^IEEEEFId‚ƒrJA; 4CCT€~rhhg\^XQPXdln…YDB8'@ADWv~‚xoikruz€nIAB. 2ABBDJV`hllh\LCAB:  ,:ABAABABAA@@6# '043.($3   "?BDAA6  $ABB:$ 5BABBAA@AAF^Yjn|KCB@?@@@@B8 6ABBBCBC@>A`3.\QnoF??BCCCC@A9*AACABBABA>BaGDR@S^O>@BAAABCA@/ >ABBAAAAAB>CCCAF=BDM>AAAAAACD@A8  '@BCBAAAAAB=9/DAA88$9;@AAAAABHUA-5CD^HCAAAAA?><40#;:=AAAAACItE<  B_tdCABBB?>?8 )H0);<<=ABAAB[‚PB >BmnsE@=<>CqOC8 6BASO[^C?;>@;<>\\IBAB AB>BCCDSC><@* 0P9%+>=:=<:>NWCBA>B3  1@>=ABCBTLA=>@>8!#?SH33E>>=;ENS^THCEQNVVCBC?=?/  !?=:  *?=>DCgjJCBBBBNMRERWHGMFPQ\EBBBCF_OCEA>? 1>=AEI}GCCCBBBGPREFNMICHNQEBBBBCCKvGD@>A  7>>BD^`DCCCCC@ANP8BDBBBJOKABBBBCCEsQDB>A  ;??BDpGCCCCBBBBDP*?BBB>AGAABBBBCCDw^CD>@  >@?CIuECCCCBBBBBC7@ABA;9BBBBBCCCCCauDD@?( @??D^eDCCCBCBBBBBAAAAA@BBCBBCCBCCCDmLDAA. AAAErIDCCCCBBBBBCBA@AAABCBBBBCCCCCCJdEBB4  AACMtECCCCCBBBBBCBAA@ABBBBBBBCCCCCCCiHCC7  ABD_eDCCCCCCBBBBBABBABBBBBCBBCCCCCCCTYEB8  @CEoTDCCCCCCCBBB?BBCBBBBBBCBBBCCCCCCIfE?<  AEFvIDCCCCCCCCBBBBCBBBCBBBBBCCCCCCCCFkEC@"BEJlECCCCCCCBCBBBBCCBCCBBBCBCCCCCCCCFyFCA4BEQlECCCCCCCCCCCCBCBCCBBBCCCCCCCCCCCG€HDA -?BE`‚GDCCCCCCCCCBCBCCBCBBCCCCCCCCCCCDH‰NCA 1ABDprFDDCCCCCCCCCCCBBBB@BCCCCCCCCCCDDG‡UCA +?CCzVEDCCCCCCCCCCCCC@AACCCCCCCCCCCCDDExWCA5CC}ODDDCCCCCCCCCCCCBBCCCCCCCCCCCCCDDEpWB>  AByUDDDDCCCCCCCCCCCCCCCCCCCCCCCCDCDDEvVB8  @ArgEDDDCCCCCCCCCBCCCCBCCCCCCCCCDDDDG‡OA.  7@_JDDDCCCCCCCCCCCCCBBCCCCCCCCCCDDDQ‡GB! '@IycEDDDDCCCCCCCCCCCCCCCCCCCCCCCDDEaxCA@BpoKDDDDCCCCCCCCACCCCCCCCCCCCDDDDFqlA8  7A_qrFDDDDCCCDCCCBCCCCCCCCCCCDDDDESvS@*  %AJ}yZEDDDDCDDDCCCDCCCCCDCCCDDDDDGq{DA?CtwkFEDDDDDDDDDCDDDCCCCCDDDDDEEhqaB8  +@S„lHEDDDDDCDDDDDDDCCCCCDDDDDEZx‚FA"?BxnVFEDDDDDDDDDDDDDCCDDDDDEEHtbA< +@P‹|PEEDDDDDDDDDDDDDCDDDDDEFguDA#  >BpŽ€LEEDDDDDDDDDDDDDDDDEEF\r‡N@3 %@E~…rGEEEDDDDEDDDDDDDDEEFY‚WA82AIh†eFEEEEEEFDDDDDEEEEFRp^B6:AJ{ˆ^GEEEEEFEEDEEEEFNjxqSB5 ;AEl‡lcIFEU]HEEEEFF^veGB44AC\…~pdfh[^YMN\diuƒ]DB2'@BE]x~ƒwkijsuvƒ„mIAA( 4AABELXdijmi`OCAA:  0=BBBBA@AA@@A7$  &042-$4#  0LtlG>hv€X. ,1, ,Gk^_a<$283$5@BBA@:,'C]BBCCC>!& 3BCBAAAAAC??ADCC?D?@>BAAAAABCAA6.7BODBAAAAA@>2 #=DCA0>>@AAAAACERA7 AXv_CAAAA=??1$?C2-0??>AAABC^yTB >Cp`aC@<<=>?BooeC1  :BAf]baE@<;=?B$0#@ %A?<><>A_k^NBA %AA>CBCDRC@;<>B!'?#%A>?==BPPCCA?B3  :@>=ABCCQTC><@I[CCBB=@@ ?><=@CCCIOPB>?B#CHA#1@A@<@LPNBBCB<>A$  !?=<>BCBFXQVQG?AD1 %QB>@OYQ[FCBB==?5  -><=@CBJcQEBBKCC2 DA@FCBCMYDBD@=>> 5>=>CCR|QCBBBBAG$)?HCBBBCCMcFDB=>A ;==?DCnMCCBBBBBE6,!6 +:GHABBBBCDzgDC@>A >=?>DOfDCCCCBBBB6>>OICB.BEABBCBCDcwEDA?@ ?>A?C_HCCCCBBBBCILHDAC;GKCBBBBCCCN~JDA>@$ @??BDiDCCCBCBBBCCEFCBA=ACBBBCBCCCDpaDB??( A@=CTiDCCCCCBBCCCIGKHG>ACBCCBCCCCCEkGC?@, AB?DnLCCCCCCBBCBBC9?A@:BBBBBCCCCCCCL`DAB3  AABGjECCCCBCBBBBB@9@@@8BBBBBBCCCCCCDpFBC6  AACQlECCCCCCBBBBA;AAAB>>BBBBBCCCCCCC[NCA6  (ACEa`DCCCCBCBCCCABBBBBBBBBBCCCCCCCCCJYD?: 3BDEn_DCCCCCCCCBCABCBBCBBBBBCCCCCCCCCE_DB=  $>BEFyWDDCCCCCCCCC@BBBBCBBBBCCCCCCCCCCEkEB? 9CCEJ€KDCCCCCCCCCCCBCBCCBBCCCCCCCCCCCDFwFC@?CBDWŽUDCCCCCCCCCCCBBCBB@ACCCCCCCCCCCDF‚HB?8BCDg[DDDCCCCCCCCCCB?BACCCCCCCCCCCCCDJŽKB?  7@CDu€HDDDCCCCCCCCCCCBCBCCCCCCCCCCCCDDINB?  0BCDvrFDDDCCCCCCCCCCCCCCCCCCCCCCCCCCDDE~NB? >CBmxFDDDCCCCCCCBCCCCCCCCCCCCCCCCCDDDF…MA:  >@dvHDDDDCCCCCCBBCCCCCCCCCCCCCCCCDDEJHA0  :@S|ODDDDCCCCCCCCCCCCCCCCCCCCCCCCDDE[DB  +@FtXEDDDDDCCCCBCCCCCCCCCCCCCCDDDDDEhsBA ABpnKDDDDDDDCCCCCBCC@CCCBBCCCDDDDEGwcA6 :A`tpIEDDDDDCDDCCCABBCCCBCCDDDDDDEZwJA'  &AJ‹iFEDDDDCDDCCCBCCCCDCDCCDDDDEPtrC@?Ct€|JEDDDDDDDDDCDCCCDCDDDDDDDEKz}YB2  )@Nˆs`FEDDDDDDDDDDDCDDDDDDDDDEFl~‚EA?Bm|sIEEDDDDDDDDDDDDDDDDDDDDEOt[A8  +AJŒŠ]FEEDDDDDDDDDDDDDDDDDDEJt|{CA  =B_v|TFEEDDDDDDDDDDDDDDEEEKwˆKA.  #@C^z|IFEEEEDDEDDDDDDDEEFGr~‰UB51@FrˆdFEEEDEEFDDDDDDEEFGc„wRB3 :AJ„‰`HFEEEFGDDEEEEEFMq‚vMB- :@GyˆpjQHNgeOFEEFFGYl}fFB,3AD`…tnjcXaaSP[dpw€\DB,'@AE_{ƒƒ{mkmnr~†ƒiHBA% 3@ABEMZ`egif\MBAB8  1>BCCAA@@@?A@6" #-2/*"7  4`bo]'D]UT_4-RYOIg>   '452)!!2Ji3GMMS0'9@B:#  "=BBBCCCCCZH@DEdEA@BCCCCB1 ,@CBBBBCBBCDACB)?ACCCADDBCB2 )ACCAAAABB@CED?A@07?@CAAAABBC@$  >@BBAAAABA=C2.@BAFC?>BAAAAABCB6: !?AAAAACCF>."BRxZ@@AA?<<=4&58CB10=>=AAABC^wL; ?BocfB=<<<;;>552CCD%,>>:;==@BfddC( >A@qbXXA=<=>=@()3?B%.%@>;9@??+B2#-C?<:>BYQDCB@B4 >?>=@BCCI\D>AA< =AQSCCBB=A@  >><=?CCCBSWE?A@73>AGDD8>@?ALTECCBA><=ACCDOWQ]K>@E"!>!+4G@@ESUOKCCCA==>:  7>==>CBCXVEBBJ?C(B@TNLS]JCCC>==@ ====@CEl`DCBBBBA $CABBCEQhSCD?==@ ?===BC^]ECBBBBBB2 5BBBBCCCVKCB>=@ ?=> 4,BBBBCCCHuXCCA=?% ?=?=DTWDCCBBBBBB%EPHEDEB6BBBBBCCCXmDD@>?' @>@?CdICCCCCCBBC;?DCCCB@BBBBBBCCCDtOD@>>& A@=AIcDCCCCCCBBCCDJHGHGCCBCBCCBCCCJlEB?@' AA=C]NCCCCCCCBBCCC@7@ACCCBBCCCCCCCC^RC?A/  AA?E[DCCCCCCCCBCECA@@@@BCBBBCCCCCCCJfE@C4  #BAAGcDCCCCCCCBBCCBBBBBBBCBBCBCCCCCCDeEA?6  6BBCTqEDCCCCCCBCBBBBBBBBBCBCCBCCCCCCD_KC?9 ADCEesIDCCCCCCCCA@BBBCCBBCCBCCCCCCCCDXXCB;  .ABEFvyIDDCCCCCCCC@BBCCBCAACCBCCCCCCCDMdDB;  23CEH‚aEDCCCCCCCCCCBBCCCB?ABCCCCCCCCCDGhEC8  @CDR”cEDDCCCCCCCCCCBCCBBBCBCCCCCCCCCDFqFB5  CCDb•xFDDDCCCCCCCCCBBBBCCCCCCCCCCCCCDK…GC4  ?CDs˜tIEDDCCCCBCCCCCCCCCCCCCCCCCCCCDDQIC6 3CDp‰fKEDCCCCCBCCCCCCCCCCCCCCCCCCCDDDM‘JB7 &?CBX‹fJEDDCCCBCCCCCCCCCCCCCCCCCCCCCDEKŠGA6 :AA[ƒgIEDDDDCACCCCCCCCCCCCCCCCCCCDDDEV„EA/  ;@Q{nHEDDDDCBDBBCCCCCCCCDCCCCCDDDDDEfvCB  1@FtJEECDDCDDCBCCCCCCCCCCCCCDDDDDEFujAB ACwZEEDDDDCCCBCCCCCCBCCCCCDDDDDDEK„U@6 =BdytOEEDDCBDCCCCCCCBCDCBCDDDDDDEGh€FA$  &AI„vnGEDDDDDCCCDCCCCDDDCDDDDDDEGn‚mC?>Bh†‚YFEDDDDDDDCCBCDCDDDDDDDDEFcvQB/  $AHˆwIEEDDDDDDDDDDDDDDDDDDDDEL|‚|DB=AVŒv\FEEDDDDDDDDDDDDDDDDDDEGkr‘RA3  &@Eiy{JFEEEDDDDDDDDDDDDDDEEFaƒ‰rBA    .?ACEHPW[[\ZSFAAA4  ,;ABCBAAA>@@<0  '-*"0!    IOOQX< .SKPGZF  'BgNKD`N/ *=BBBA==CVkMFE[dB0!$'% >CB@AA@@EStFCCCF|WDCCCCCA1@BBCCCCA@CCHB?CC9K)@BCBBCCC65A?ACBBBA@?BCB3BBADC?ACAABBDC4$/@>>ABAABA><8)/5?@GC@<<' 0@A>B7><=ABAABBCC9  9BQx]>=>?@=;?23ACBD@!,<;<@ABA@`sE+ &AAnkkA<;<@?<@#>DBG<+1>:<=<<=AegZC$@AA~^FD><=ACE>$4CCB?B19?A><<>ZapcCA6@A=CBBCYI>CA/9498?BA783GDB?>?BCCFiNJ3/-,8?DCE:=>B??[KCCCA=A@  $>>=>=BECANNUC9/?:4C;A64BABROBCCB@=?@.  2==<=>DCDDVNTWA856>1 .-/)7=ASIMACCC?===> ;==<=CCBH\TMN`G@#0%BBaWPTLDCC@===??==>=DCUmQDCBCH5 ! DIFFRYk^DBB==<> ?==>>CJo[DCBBBB=  $FCBCCKWw^CC>=<>& ?<>>?ChUDCBBBBBC0@CBBBCCHnlFD?>=>) @=??BFrGCCCBBBBCGP(8;BBBBBCDYpVC@@=?) @>@?CYfDCCBCCCCC1B7/4;J+>BBBBBCCCSqED>=>& A@>@D^FCCCCCCCCBBLKGJLMCCCBBCBCCCCUXE>?A$ AB>CGRCCCCCCCCCCMLF;BCBBBCCCCCCDlND@B2  &ABAEpNDCCCCCCDECAABCBCB@DCBBCCCCCCDQ\E@@2 9BBBMqTDDCCCCCFGBABBCCCCB@CBCCCCCCCDMqEBB6 BBAD\LNFDDDCCEPEABCCCCCCB@CCCCCCCCCDGHCB;  "90CErRPIDDQJEMKCCBCCCCCBBACCCCCCCCCDDrQDC; ;DG‡ePGFGTKEDCCCBCCCCCCCCCCCCCCCCCDDdaEC7  9DCQ‘qJEISXIDCCCCCCCCCCCCCCCCCCCCCDDE]pEC;8 B?Dh“‹UEGVJCCCCCCCCCBBCCCCBCCCCCCCDDEdzFC@ABBDxšqHEECDDCDDCCCCCCCCCCCBBCCCCCDDEr†FC@A@BJ`|‹‰ˆ‚‚‡ˆmOC@;  (;ACDEGLPOLJFBAA?/ %4;?BCBA?;>;3%   2   .WAVLRP BdDRFKU5  0CJaCLDG_C)  !9ACCBCDGjUDFB:dHC9034/#9CB@?@BM_w]6BBBBNwVCBBBBCA(=BAAAAABORH,;CBEDC<[E@BBCBBC-8A??BCBA@?H@0ABBE>8B?>@BCCCA@B@A?=>AAA@?>LC?B?BBB<===ABBBB@>@5 -@@TT==?@?>@NB=CBDABEF@<>ABBA?@@@$@ARmj?<G=ACBDCDABK==A??>>goC8   8@@pngJ<<@>*.G;8>?DE3:K@@A=<?A(2@?BBBC()@' 7B=<BRCBDD?A:  @@>J@ABCBDE:=FA359 8J_FCBB@=AA  &?>>D=@?2  3>>>@=DCCBJKSIC!/A /@) 8DUDJBCDC=<>=> =>=@?ACCCHTWRVF=0<9EFXLHMCCCD====?  @>=A@CCEXi_\RSW?bYTT`aDCC@===C@CDiqkbNCCD# 9`QEElvnICA===>'  @=>BADVkTFDCCBCL'  $IHGFCCEYf]CB=>=?*  @=?BCCjbFCCBCBCIQJ  FICBBBBCNgfGC=>=?(  @>?BEGsaHCCCBCCB>:48BBBBBBCCFp`D@@>@&  A?@CEZoWDCCCCCCC>H.+@O@ABBBCCCCCHnHC>=A!  AAADEm]ECCCCCCCGRYJDEHU[CBBCCCCCCCYUE>>A$  ABBD`yLDCCCCCEKN`HA7?ADXFCBCCCCCCDYkE@AB*  'AACFSdJDDEDDDVZZVABCCCCFGKJCCCCCCDLuHC?B)  9DCDL45OGNNDGTYf`CCCCCCCCCUKDCCCCDDDj[EAA5  B?CDRH[MRL_Zm†_DCCCCCCCCBNUDCCCCCDDWuFCA? 2BCDgSOPVJ†Šw}VDCCCCCCCCCBCOQDCCCCDDOƒHCBB0  DDD‰rP@KIxrPGDCCCCCCCCCCCCCHEDDCDDDG€SDCC@ =CBU–fbOOKSTEDCCCCCCCCCCCCCCCDCDCCDDGyfDBB@$ ,B>Ck™y^\M^SDDCCDCCCCBBCCCCCCCCCCCDDDK@XDBC;, -A7Cq™~eHSQEDCCDCCCCCBBCCCCCCBCCCCCDDJh|DBC5+ BACj™…@1OEDDCDDDCCCCCCCCCCCCCCDDDDDEHƒ‹DBC9$ 2AAT‰t$OGEDDDDDDCCCCCCCCCCCCCCCDDDDENƒ{CBB@ 3>BAHwZSEDDDCDCDCCCCDCCCCCCCCCDDDDEHmfBB8& 6@@Dq€xNFDDDDDDDCCCDCCCCCCDDCDDDDDEX}‚aBB  7@CqxLFEDDDDDDDDDDCCCCDDDDDDDDDDF_ƒ‘RAA %AC^˜ŒZGEDDDDDDDDDDDDCDCCDDDDDDDEIm…FA4 >AGŽwcGEEDDDCDDDDDDDCDDDDDCDDEEFW|‚oCC  "ACeqsMFEEDDCDDDDDDDDDDDCCCCDCENs††NB;9BFƒ‚mHFEEEDDDDDDCCCCDDDDDDDEMn‰lEB&  AB[‹xfGFEEDDDDDDDCDDDDDDDEEFf€…‚LB? 2AE€pwaGEEEEDDDDEDDDDDDDDEEFr…ˆZDA(  ?BT–~vMFEEEEEEEEDDDDDDDEEENp’mFA= /@Cn‘nPFFEEEFFEEDDDDDEEEFHmˆˆJBA >AFƒkLFEEEFFEEDDEEEEEFFY}’VDA(  !@BKŽ‚gHFFEObXEEEEEEEFGYy”aDA+  'AAU’ƒjVLPd]bIFFFFFFH^|–jCA$  %ABV–qh\XY`MGGGHSp‰“aC?  *@AHiŽ˜‰xlf]mljk{ˆŒlHA=  !;ABFUo†““Ž‹Œˆw\FAA6  "7BCDDEFGGEECBAA9# */6<@?:2::4+  *  A_>WHHX2:IZ?WE@\C #1ADSJCSD9RDDCDE|iPDAABD<?B@?G[]O<3BEBDJAQCXTC??@BA;?A@@DIPM0?:DAAA@@A??AASWC@CI+?=EDDIF?CB8=ACA02B@==HrlBA ?A@tod`EB$ /?.=C@AA>!4B==StpPA9 .?AP„\CAB/ 1@0BCB797 :>>BIzfBB >??fhCBB?7 -@ECCCCD(3CBBAKR?A=  A@>nJ@BB@>( +<@BEBBC'>?BBAB@=AA  (?>Cj?@ECABG,44>CPBB=4GDBCBA>=@?2  3>?WNAECCBBMC' *&@BFGC@.' ARCBCCA==>=>  =>@@@@]DCDCAR^^UYW=+;*S\V`[[FBBD<>==@  A?AXDDDMiwi_X]W\" ?V`ch{wWCD>?>=@#  A??XDDGkmnOGENO\EE 4@IV__RUcegKD??>=?%  A?@THE[`]TDCCDG]ZCCX]LJFDDEdYbDB?@>@#  A>@NQKoV_IDCCCCGM:GIHCCCCCCIXoID@A>A  @?AJevhf\DCDDCBG2F#8K7EBCCCCDDJj_E@@>B  @BBGy~oh]DDDDCDJIKPOMNNMJCCCCCDDEUoFB>>B  ABDFtk]fPJFDJIHOQD7@BMVOFEDCCCDDQWKD?BB  ACDGVrrgiKW^ihTQaCCCDCB^\LKNDDCDDRNhF@?B  2DFEHV{…t[;mžxbXDBCCCCCGl\YfKDDDDQJGLDBA4  =38FKˆ{W;2X‹zvlNCBBCCCBBCGnvŠnIGDEMJL`EBB@ +)%F\‹`J0CŠ›…vNCCCCCCCCCCCEikhfLKGHKsECCB5  ?62G{UR$R‚—vODDCCCCCCCCCCDEQk‡rUTGEHQLD?)> *CBDL“wU%EfpXEDDCDDCCCCCCCDDDDHfOBOEEPQaDC)=@BBS‹LGS[WEDDDDDCCCCBBCCCCCDDDERNGDHB=jCBC>A@B‚iHEDEDDDDDDDDDDDDDDDDDDDEELn{“QCC "AAYu‡[FEEEDDDDDDDCDDDDDDDDDDEIj~wEB7 7@CtŽ|RFEEEDDDDDDCCDDDDDDDEEFdy}NBC  @AU‹emMFEEDDDDDDDCDDDDDDEEEK|†‘aEA; ,@Cu†lhKFFEEDDDDDDDEEEDDEEF^r„‹ICB"  =AK…ijJGGFFEDDEEDDEEEEEFNi}–]E@7 "@CX”zi\JFFFGGGEEDEEEEEFHdw”rF@@ 9@Be’qkVHGMW^]GEEEEEFFGUvŠzFAA  ?@Cl‘zgSNXb`dKFFFFFFGTr„ŽJA@!  @@Dm—„ohd[[^_NGFFHP^|‘’SA?  @ADa–Švjec_Yd[UQ[qˆšyKB<  @ACMu—œ’„znowx‚•—UBA6  7BBDI[o†‘“‘ƒyhNCA?* 2AACDDCDDCBBAA@1  %*-6:0%77/%  4  +EM?HD@O;  AMH8LD?TC' '3>CCSC@PD=NFA00>BCDDDI^^CCIC;HYDDCB>3"  +ABBBELJ9,$IC=CABAq]SHDCCC?$"2ABBPhuVBBBBDHB? 1^ZFAAB/ >@ACdlkg,BBBEBHIBA 2`TF?AA)&@@Ci`\O;FBFDB9FD4 7MPTTD@@?@Af`R;9AEDCAGAB (>DNenI@=6 7?AXhKL+ 3AJ\akA@)@@Ctk\aQ hc@CB?#?ABLD:=?ABBZu@A?  @??mM?BB?:!ADBMC@@=ABBAc?AA  -??NiDBFCBB<"CBDHBBC 9@ACB>M@@?.  8>@iUCFDCBB??C@@HM;AD7 2?ABCD>CC>><  >>@vHCFCBBA=?FHFEEEWbNHEJ86DD@ABBCA?B=>A A?AmECECA?CJS[^QKPQECDMBOUV\VLD@BBB@C=>A @@ApFEEBFTXY_WXQVW# (CMNU\_ohTBBC?C>>@ A?@{WFEbqs`che\VZM  LVFFXhu‚wjdCD@B>>A A>?urXl^Y{i]_iqWYM RTP]dfopdWcODAB??A  A>?a~vkS^omVPJ[RRP VUZLEOWSPdTcECB??A A@AHeh_elfbXQSKA@N@A5FL4KCCDDCE]ejJEC@>B ABCFGKMJ[d\SUP=4EJIJKIKBJCECCDDFdf^FDA@B @BCDEJJHLjpR>EDJIKK>ELQG<+HDDDEO>`MCBBB @ABDP„ƒtbg0BYh]RZHD?CCEXP)JGDHIVIVmEB@B BDFEGWnhJX„¨—iXICCCCCCI^hŠvNMMWCCXHDBB.  ,CEFEMIGN2$v{—ƒVCCCCCCBBBJj‚“ŠeMFWGDSREDDA (2FEkz^^_\p“IDCCCCCCCCDDCJ]Œ–o.T=?7iEDA@'   (EY‘q<*™š‡WBCCCCCCDDCCCCEg•œr+?MJ?aJCB(  )< :EwˆY2?lƒ[EDCDDDCCCCDDDDDDEQySC4?H81YBD @?CEF„bL][LEEDDDDDDDCCCCDDCDDDDDLM8KZ;9g@B@ A?BAO“]95GEDDDDDDCDCCCCCCCCCDDDDDJF27=}€B=B) >B:AU‘;;IEDDCDDCCCCDDCCCCCCCDDDDDER+6sŽyC?B  A?@N‚'FEDDDDDCCCCCDDDCBCCCCDDDDDEGFE\B@8  .?B@D‰eIFDDDDDCCCCCDDDDCCCCCDDDDDDDNOHAB:3  &8AAB{eRFDDDDDDDCCCDDDDCCCCCDDDDDDDJczDA>:" <@B`‚mMEDDDDDCCCCDDDDCCCCDDDDDDDEK_ƒtC@7  (AAEƒpgFEEDDDDCCCDDDDDCDDDDDDDEEGjxš]DA+  =@Aa†wOEEEEDDDDDDDDDDDDDDDDDEEF]|‹‘HBB AADs€nKEEEEDDDDDDDDDDDDDEEEEEQ|†vcCB2 3@A_•nmMFEEEEDDDDDCDEDDDEEEEJw{Š€FAC @@E…ƒgjLFEEEEDDDDDDEEEDEEEGdm‰”WD@7 &ACUqecJFEEEEDDDDDEEEEEFFXks–yEAB 8ADf‡nf_LHGFEFQ]FEEEEEEFOrkŒMB@4  @ABouhgWQPZmqgMFFEEFFIim~’VB?< )AAFqŽthkhgbhfbUIFFHGHYsx–_B@9  9@AHj‰~na`\[]]^TKO]]_q…˜lCA6  :@BG`ƒ†piec\Zfgddks}’˜dDA6 8ACFW€“މzlacklt}Œœ…TCB2 3CCDMjŠ™˜‘Ž”››‡_EAA& "=BBCGQf{‚zm[MEAA;  $;AA@AAA?A@@AB=)  %*./)21+  2/  3EFEFDDE?+BJE:ECCNC1 *4=CCBP?;DCANEB9( 4ABCCCDEWUCCFAAHTCCDDB;) .AAABAAFE70OCCCAAKoXJEDDCBA)  0A@?BAEFE' >BBCA>N1 8TUOBBA5  6??AQdjb0 3PBDDBAK80tslJA@6  1??Ccm^ FFBGBBAF6:ZZlNA@* !@@Ag\L KCBKCDBDB URqF@?;  <@@`eT=+ABDBGCDD;  8Pfe@@4 '@@FodXP7ABCAFB@2 R`csM@A" <>@WjGA@C 1AADADB? 'JCL|kA@8  @?@e_?BBA+ABBCCB? :ABBYu@@A &@@BpMABB@6 &@CBCC@< @ABBCuD@@" 3?@NhCCEDBC3)ABCDBB@  7BBDB@bK@?+  =?@WXCEDCBC@A CBBDD@CC 3ABBDEAK]>>7 A?@LFCDCCCA==DDMUD@HIACJH32>? A??DDCDCB@ACCDKZ\JDX[KONMU[IABBBCDCDc@?A $@?>DCCEC@BDDEFSVT\SZZXWPPOc^RHE?CCDD]@?A  )@>=HKGJOMIFEDPh^X\Q>=L[UTQg^_infJBDE_@@A  ,?==Xj|yeefUGEfl`[\O*%8YFRfabskZjFDLZ??B -@=?Phmibnvq[N^WXQTZ0">UPVfR^u_P\dGYO@?B *?@@JYaZWir„ugMPIIVSTPNNDKb^Ve`d`QraeF??A +@ADFYpde\f„mEILKNJIIHGK>:9[]_jdjj‚jDDA=  +BDDFFLWOJ\OCKUOQQTJ6@IRUO65:Sfnq|`lDCA4  =<92--CII-7}}gWaTECCCCBRnu‹p)V|q`vpDDCA  5AB9 [ˆ}qXGCCCCCCBB[¦ˆvL4HdwCfIFFD9  2FDEDUnkoO{†HCCCCCCDCDDCLt|UN9IY?> >@6EFy3DPRQEEEDCDDDDDCCDDDDDDDDENSGEE--\BCC& -@>ABOu  9BBAK‰jRFEDEDDCCCCCCDDDCCCCCCCDDDDDHF‹DAA3 -ABB‚gnTEEEEDDDCCCDDDDCCCCCCCDDDDDF+XxBA@@, >ABW‹wjFEEEEDDCCCDDDDDDCCDDDDDDEEUP}_C@1  &@ACx‚€MFEEEEDDDCCDCCCCCCDDDDEEFJ~tIBB%  9?ANŠxgGFEEEDDDDDDDDDDDDDDEEEEFe‚ŽxDAA@@Bg†hXFEEEEDDDDDCDDDDDDEEEEFYpŠ{PBB*  .?AJ‘ciZFEEEDEEDDDDDDDEEEEEFRhdaCAA =@Ag‡eiaHFEEEEEDDDEDEEEEFFNolyFB@0  ABEtŒsnjNFFFEEFaHEEEEEFGRnh}‹OB@A 2ADGiŒzjmeWNMSkqlRHFGIO^kewŽ_D@A,  <@AGfŒ~finrpl_^pnfa`_dok{‘mD?A4 BBEHX€ƒrfb[]^afkfinfhn€”wF@B, 2@CEEOjƒ~r\ce]^cfjjnxŽ“sHAB) 5@BDEI[zŠŠ€lfgeip{ˆ’ƒcFBB( .AADEGUpŒ–†~~}„š“qODAA% $AACCEM^{“œž’jREBA? .AAABDEPfk]JDCA@B4  +>AA@@<:>?AAA5  $'$!5,+(   3   8BDEFEDCA /CD?5EDADC6  .8>ABABLC?CBCKCB=/%  "=BA@BBBDNZDCCBCVLBBCCC@.'1A??BABCHK\XCBBBCZiQEDCCCBA+  #EA>@@?ABE) QDBBBF\$#AGDBACA@9  8??@>?DI93HDCBCFL! &E\UKBA@: 3@?AF]_$ A>DEDAE?6JpeGA@1"A?@Pd`$:DBEC>E;C =]oD@@@>@AMiU@ >GBDA?B=B W^i@?9+@@Abd[K GEABA?>F &fdqU@@* >?AHmT>?A;CABA>=B A@Kqk@?= @?CWjDAB@'2AAAA@?C =BB@Tm?@A *@@AeTCCBA9 -@AABAA:BBBAHlC@@' 6??@OCCGEBC4 8>ABDAB;  9BCECCdP@?. ??>AECEGDCC@=/!FBBDD?@@$2ACCFECTc?>5 A?=BECDDCCA==CFSSCBED=BEH:3?;ACCCFCLv@>>  &@>>DECDDCAACCCCPfC-OI?DDCDB@CDDDCLT`B:`Q@GWPVICDB@ADEDFkA?A 7?=>DDCBACDEDDGcVRDGdZFJSZUQDEDEDCDDQo?@A ;?=>DHGCDDEEDDNGJKFGRPGMTVfZDGR_lrTRqn?@AASTdKEEPOMEACDEN`bgaTGKG^u‚s`fjo{zE@?B ;@ACHSW^]XSm`CCGHP_]KLOSIUJFe„rl]SNSLD@@B 8AACBFRZZSG_PFKRLYMLRNIONTGKT~zQNQGEDCD@? =DDBEDKXKAGv]F^PVKRWKLRRTQ?F?ioMHQ[UECBA: ;9&.^€€…\>)VWIRV@2@?O^ecgc1ED5Svƒ{akNxDEJDCCCCC@CD[…ƒn2/lSYUZDEC@  ECEnOFXufapECCCCCCCCCCCC^Š“Œzi7KA_ME* FDnŠVVEYojSEDDDDDCCCDDDDDDQw‹{B07=FfD.:%  62(EJ‰k[^>WPFDDDDDDDDCCDDDDDDDDFOPG< :eFC8A; 8@>ABYQ<$NFEEDDDDDDDDDCCDDDDDCDDCCEK7UKAB?@ *A7<@W"/EDDDDDDCCCDDDCCDDDDCCDDDDDF/pTANFEDDDDDDCCDDDDCDCCCCCCCDDDDP&$|NA7A 8>BCGnmYFEDDDDDCDDDDDBACCCCCDDDDDEJ->FAB1 ABBuiuHEEEDDDCDDDDDDCCDCCCDDDEEET@ixCBC@2 >ABJ…‡‡TFEEEDDDCDDDDDDDDCCDDDEEEFh\…RCA3' $@ABUŠŒnGFEEEDDDDDDDDCDCDDDEEEEFZ„}vCAB  5?ADi‚TFEEEEDDDDDCCDDDDDDEEFFK{‹PB?<@AAK}qmIEEEEDDDEDDDDDDDDEEEFFdn’gDAA  &ABCaciIFEEEDEEEGDEEDDEEEFFZcwƒHA?< :@CHp‚wrQGFEEEEFbIEEEEEFGG[kw‘OBAA)  BBDH^‚~ygPGFFGWz_GEEFFHYno}ŽhBB@? 2AEEGUy…wtnedjfWfi`[^fqon†ŒlEB?C  >ACEFOm‡~pkU\[Y\bhkniis‹…cEB@B' ABEEFL`{†jc`]abdjoxƒ‹xWFBAB! 2ACCCFHM]mxzlju{‡ˆzePEDAB 8@ABADGHMWiŠru†„xfRHFDAA 2A@BBCEGJYxŠ„s^MGDCA@ #@@?ABDFIYš{WJFDBAB;  *=A@@AAAHPC@@@@AA+  !4@AA@:;@ABA:)  .C!  !   A@>AFE4 D>HDDDC9>FE@>A@@:  .A>@@FU=%6/DIHB6)*&GPBA?@4 !A?@@Lo4&2EIDB0#: LhXA>AD>?@BUbQ+)2EDBB4@ Sh\@>;-@?BMhi[*>>CCBCC=0#idmM?@.>?BC]eC=@ ?EBBBCDB+??Ul_A??  A?BEcLBB?:GEBB@BEH DBB?aeA@A  ,???EICBCBC GCCB?BDK  ABCBQlC@?*  8>?@DDCVGCD:DCCC>CCE >BDDF]ECC?@98FCCCDCCBB= 1CCDFDCVR??7  A?=CDDDICCB@ABF[ECAFA;;A`R=@;@CCDDCLO@?>  .@>>DDCCCCACCCCFXP1A@5?NjJDDC@BDDDCDD??A 9>=@DDCCA@CDDCDSHN:8BCBASSYDDDCABDDCCC>?B??=@DDCA@DDDDCJICDCCCCCCGIdFDDCDACDCDB=?A@>=@CDCBDDDEDCBBCDCCCCCCDBYTDDDEEN]Z]E=?A#@>@AFUbGDEEEDBBDCCCCCDDDCCBMEEDPZh~oiF=>A*  ?>?AI`eRDDDDB@BDACDHLKHDDDCIZQM][]eg[B>>A(  @AACEV^`]IDGEBCCBG_gfcnXEDCBZudR^ahiKC@?@'  C39|š‘‡aKH[RXcI@B@BK_cc_bEG< -3:6  EDMib{YnJFMgsPCCCCBAGWOiM=;e[4&;8A@ACUpV4:FEDDCDDDDDDDCACDDDCDDDCDN6):vFCC?B )A4=@P-:8SEEDDCDCDDDDDCBCCDDCDDDDDDI,(LLA?AA,A=BBIpfR[IEDECDDDDDDDCCDDCCCDDCDDDDO,*tOB7B( /5ACBŠc`VEEDDDDDDDDDCCCBDCCDDDDDDDM‡FBB7  @BBU‰vwgFEEDDDDDDDCCCCCDCDDDDDDDGiG^CBC@0ABDI|l\GEEEEDEEERGEEEDEEEEFVizzMB@B  !ABDEYswgJFEEEEEGvSFEDEEFFFSnk„RAC@6 6@CDGWw„z[KGGFI\tfHEEFFFI^yˆcCCAB"  AADDEK]{†thbeidQccPIHK[u‚…y\FDBA8 1@CDDEFUw}spj_QLM]konrtƒcMFCA@@ ?@CCEEFOlzxorgUUcjmt}Š}YHECA@?  #A@BCEEFIQU[goos{zqdSGDCA@= 2?ACCADFFFEHPhud^TNIGFCBC@>  9?@AAACEFEFEXh^JGFFECCB@>  6@?AAAABDEHx”[IFDDCB@A;  %?@???ABCE_kJDCBA@@B4  &9BA??>>@@??@?AB:!  )7=?:96@CA>?@ACDGCACCBECA@@ABB?$  @B@=<@A@BDEYEDBDCDHTDC@@C??B2:?<=?ACCBLOWGGCICKDA?GDC@B?>A8 .A=>?@ACHA"IIHFNDL;(DCA?@@?@7 &B>>A?CI;1AHEFHEJ8$+ BBQgjB '@?CBBDC??1^cXB@A.>>@CDYJ>=6BCEBCCCB/ :?PooFB?? A>@AEHCA=EEDDCBCCB-AB@FtQC?A!  -@>>CDDBCAB"!PGCCBCFF5ABCC[[C@?, 9?>@DDCLGCCD$ HRECDCCDT(CCEECDL@?>2 @??CDDDjHCC@EBWgKDCCCCCP]?>8  #A>@DDDDgDCCCCCNfFCCC=BCFaGGC?BCCFDCDA>?? 5@=@DDDDRDCCCDGOJD>666;8GQJDCC@BDCCCDB>?B?>=?DDDCCADDDDNHE=5>BBB@FDODDDDABDCDDC=>A @>>=DDDBBDDDDCJCBCBBBBBCCCPFCDDDAACCDC=>A' &?>@ACDCOEDDDCBCBCCBCCCBBDCKLDDDDCBBDDB?>@1  (??ACCDkoEEEDC@BCCCCCCCCCCCB@CDDDDDFQMA>=?7  &??@BC\gqGEDCAAC<>CCCCCCCCDC?BDDDEEU^^B>=?9  @@ABDIjjXDC?@BCACDDDLFDECDCBCFDENgnVRCA>?:  ?@CBCCEMFA??CABBBFKYd^[TGCABEUDO^ggZGDC?@5  ;DCECDCB@==A@9CCEQ__ZXWYQGC;VA>EPSLEDDCAA'  9EEDCJOlkVEEDGWKQ^_`aWPWI@\PG\iVC?21BD*   5EEFGh„vjHDDLGYd]ED@G\cWZF`qœš†R 1  "EDQYT…]W_TDJ`OHCCCCBCbt_L`ay‘‘f-->. 0FPQ2Lgg^^SFEobCCCCCCBDaeTe"1^aQgaFCE8    CDphJH HIEGU\NIDCCCCBCDDFMU"/0?&&5fDCC  '=59CE\S9DIEEJblODDCCCCCDDDDCUO<+/'*>ZBD+.1BAABF€]ZROFFIY]VFDDDDCCDDDDCCDEJF%7&+tFDBAB',B:@ADƒlh_QSJFEEECDDDDCCDDDCCDDDDCET „HAAAB% 4@?BCBx~g\_^FDDDDDCDDDDDDDCCCDDDDDCIK)JEA9B6!2ABAV„pis^FEEDDDDCDDCCCCCDDDDDEEDRH >gCBBA  AB@D[l{ˆcFEEEDDDCCBBBBCCDDDEDDEFaf7oJDBBA,8AABEJ[siFDDDDDDDDBBBCDDDDEEDEFT„r‹`DB@4" @A@DEGbwPEDDDDDEDCFHDEEEDDEEEFn‹aEBBB!  .@ABEESviLEEEEDEEKcfGEEEEDEEFTx‚WEAB@6=@ACEHewrQFEEEEI]vpKFEEEEEFOpzhFCBAB  AAADEIfxu_QMOT`i_q_HFFFFGStxvLDCC@2 4@ABDCFLcxvz}fReqaRMOYs‰kNFDC@B  A?BADDDG\sxwsmfT[hqvw{†„gNGEDEAA1 /@ACBDBEFR`a]ajghootw{t\HEECDA@; ??BCDCEEEFFEGPhd\^eibOEDDCB@A6  #A?CCDEEEEECDDLKDDDDEEEDBC@@7  0@?BBCDDEEEEDCCDDDEDCBBAA?:  7??BCABCEEEDHLEEEDCAAB@@;  3@>?AAAABCDPYFCBBAAA?@8  "??@@ABB@@@???@B.  2?BA@@ABBA@@ABB3  %.1+1*153,! (   -D@'8GF6DB! .BBDDEDDBB&   /:==87CAB?BDDDBB>+-/,% 2B@>>@@BDCECENEBCCB@@@@BA1 0EA====?BDCPIBH\ECSHDC@?@?>B<8?<<=?@AAH\dCCEU?BKHOFCC@A?=A< ,A=<=@BABH5HDFCGCDA >GBA@A?>A5!B?=?A?AH3=EGBCEFA&DG@BA?>A0?@?AABIJ(7EGCDEF>?WEA@@C9  9@?BCAVR'BEFEDEGB)EiEB@@5$A=BCBEMO1 AEGCCDE?7P]aDA?B)  A>?AECC?@@YYCB>A# /@>?DDCCB>=> 9DECACCDB'@ACBCECB>@. :??CDCCDECCIF (LDDCCCCC?? -CCFDCDD@>>2 A>?CCCC`NDC@ESmmECC?>BCBaT.6CCCHaDDDB??7  )@>ACCCDnTDCCCHQSDC>1?>BEXHCCACCEZDDDC>??:>=CDDDDkGDDDEQDI>;5*>7?JHKDCCCCDKDDDC=?B @==CDDDDaCDDDLJDB<>AAAAACCGEDDCBBBCDDC>=A% +?>?ACDDGYDDDDEDC@AAAABBC@BDHCDDD@ACDDC>=@1 0?@ABACDdSDDDCCBBBCBBABBBCBCICDDDDACDCBA??: 2?BBB@B^„KDDDB@ACCCCCBCCBCCBABDDDDCCEEA@>>?1?ABBBCspHDBA@@C=BDDCBCCCCCCA@CDDEEgi\C@?>@ +@AABDCamDA@?@BBCCDDDCCCDCCCC@>DEGll]RCAA@A @BBBBCDAA>=>AAABBCCBDBCCCB@B@AADXhkWBDBA@; 9DCBBCBBB>>A>=CCCENSJRVECCA<>>=?ENHDBCCCA&  ?DCBCBBC^JDDDFPOJNedr^PPOECIoS??KECC>-=D! #-6DECCCHNRFDDGVRMPcSEIde]WJHLt…_cD?:50 ;:,?ECQe`JEJPbPW^eiFDCCBJYOYab_i™ŠZ?DE! ?>)ADGkT[LNSUdc^yRC>CCCBBEq^[M'itF]YFD;  ?A9DCY_U^S[ZWX[slKDCCCCCBDdkkJ"!#9!.oEE7  CDBBCheeXXla[ZRbVLDCDCCBDDHKa^S&--[`DD  BBABCfw[V^ud^YQgVQDDDDDDDDDJUIHQE(."DtsDD@BB) )A@BCCY{MZe`deXU\QEDDCDDDCCDEDEDDNSA 7oDB@@B* =?BACI`Pes‚a`YQQXPDDDDDDCCCDEDDDFP_eGs_BA3?? 0AABCJH\k{cSGEEFLIEDCDCCDDDDDEEG^hhRƒKCCBA5  AB@DDBFQomNFEEEKRJCCDFDDDDDDDEIuqt„nCCB@3) 5AABEEDFbnTFEEEPYXXT]_GEEDDDEERˆŠƒjEBB@5  @A@CDCCSthNFFIX`bjjqoNFEEEEEHl}hSFBAAA  *@A@DDCGdpcWQVeiqukrvSFEEEEGY{iMED@B@5;@@ADCDL[dbeipbiji\i_LFFFJ`xoRFEBB@B  @?ACDDDEJUcpq]Y^jU[ndaafswp[FEBBB@1  4?@@CDDDDELWYNGSkSSer€~mPHCEBCB@A @>@ADDDDEEECB@H`SPX]cbXHDCBBCCAA*  +@?ABDCDDEEBABCNHCCCCEDDB@BCD@A2 =>@ADEDEEEEDEDBCDCCDDDDACCC@A,  A>ABCCDEEEEEECDEEEEEDDCBB@@1  +@=ACBCDDEEEEDDEEEEDDCBC@?7  1@>@CBBCDDECEFEDDCBBBB??9  -A>>?@@ACCCDEDCBBAA@?A6  ;A?>=>>>???>>>>>?AA*  -9ACBBCCDCCCCB;,  !    &DDCFGFEEB(  (CCCELEDCC*  $0685)*,* ',@A???@CCBCDUpNCCBCB@@@A@&  #FA><;=?CCBEVIRdRTODCC@@>>>A14@<<<=@?@CUsUDEMAJTGOBBA@A==A2 )A=<<>@??FL>NCCBC??%GA@A@?=>B) A?=>@?@BG- BBCCEC@.=I??B@>?A%>?>AA>?AN*DBCDGCB9 HIAAA?AA3 6@?BB=<=N< ECCCGCA:@B>@>;F3BBBEGCB<;k_DCA>B ;?>@ACEA:=@ ?ABFICC@ A@DOKBB??; #@>>ACCD@;;F6ECCKJCCD.%@=?CFDBA>A  2???EDDCA;?, =@@BDCCCD@A@O#2VCC@HGCA:FB?BECCCD@>>.  A?ACCCCOSDC?BbsnJB>N=58>dJ3D@CCRQCCDB>?4  1@?CCCCC_rDCCG`KXG>3==5*HXcGCBCD\[DDCC>?>>>>CCCCDb^DCDNGEGA;6=:91DDFGCCCDTXDDCC??B $@=>CDCDDhPDCDIDDA@AA=@+  />?ABCCDFsECCDDDC@BA?<@@B@BDKECDDCEDDDA@>?9 5>@BAABCdlBBBCDBBBCBA>BBCBBCECDDDCFDDD@A?>@9?ABAA@XuV?BABBACBBBBACCCCCCBBCDDDYUCC@A@?A 9@ABAAAjpD=@@B?A@ACCCBCCDBCCAACDDEk~hGCA@>A%5@ABBBCL_==>>@B?BCCCCCCCDCCCB??@DEtZgEBA@?A#0@BBBBAA@A><=AA@CCCCBCBCDCCA@@>@ADjhJCCBA@= %ABBAABABBBGA;>BCCCAAEB@BDCB@B><=?BBDCCDCA% ADCBABABBUXCCCEGOOZNVN`VPNHCCEJ@>AABBEB;=4BDCBBBABBBDDDHRRLPRCEDVSNTZIEE]rEBCCDEA  @BCDBBFWIACDDG]WVX_OEDDEenqU^LDF^u_GEEE=   @CCCBDWTWACDEPTc`rU>CCCBASz`USJDO\>GbGE<   ?DCAAFfbMBCJLLShkdAADCDCBGve_MC16R3mCE%  8CABBHmTDBNSMCJ_kgDCDCCBAHwddWS, ?"$wLBA!! BCBCCGEFGVWFDCEbnKDDCCDEOaUc_`W]I[ej†NBB<=B(0:B@CDDCCDRSKMKJVh_DCCDDGRUSNKP[j`_Rs}FBC12B ,A@BDDCBDNOUZZYckrQBCDM_XJFEEFSv~rR{iBCCA/> AB@DDBBCENV[Y^pmjt_PatpaKEDDEVz{nReHABA@ 3A@ADDBBDKRYXezqfo||uhpiWFFFJbtVLKGD?BA3@?@BDDACEHRYeumbc`meezr[KGIZqdGDEDBAAA  (@A@DDBCDCFMXc]NKN^NOfg_WQUkqQDEED@B@29?@ADDDDDDDFKGDEFGEFKZcc\]^UFDEDAA@A  A?@ADDDDDDDDDBBEDEEDFY[SKEDDBD@A@@2  1??@ADDDDEDB@@>BBD@??DEDCDDBD?AA>A ?>??CDDDEDD@@@@?@@@BCDDDDCCAAA@B#  $A>?@DCDEDDDDDDAADDCDDDDCDBBA?B) 8?>@ADEDDDDDDEBDEDDDEDDDDCB>A&  @>?@BBDDDDEEEDDEEEDDDDB?C?A-  %A=?BAACDDEEDDEEEEEDDBBA?@6  +@>>@BBCDDDCEFEDDDCCBA?@8 &@?==>@ABBBBBBAA@@???A3 7B@?>=>=>>>>>>>@@B>%  (3=BCCCBBA@?<70$    .BCDBDEEA)   -ABCDECBB@  %/5>CCBBBERBAAC>2*(% )!8A@??ACABCBRfDACADC@@@A; EA>=<<@AAACKhkdkUDDBCA><<>A*  1@<<;?AQplf\[akXTIA?>?>=>A) *A=;<===?BRmcbTUYWZ 4K@??@>=>B  $A>>@@=>@BLI;ZXPZ_OV LC>>?>=?????CA==?AM&9bRMZ`MQLD?>@@>A>/4@=A@<;<>EL 'aMKW_MN-.[B<>B@?B##A>>?<;;;;C8ZOLV_QOP(MA=>@B?>A8?==@CE?;;@=0]RTceSL[:@:@DBAC>@5 @=>ACCD@;;BQRPSWmjRQX@ @<<@DCCA?>@ 1>?@CCDDB;;B^,4TEGTmnTGEZB<=BCCDB>>A<@@BECCDC>>?WBKhXNOdcNMO_/@>>@DCCDD@=?$ AABCDCCFQBB>F^luZIHLKDPil[VD>CCSECCDA=?+ .?ABCCCCPŒEBCHfS\EDCCB@?^YnRAACD|GCCDB?>9 =>?CCCCCT~BBDIGEJACCBBAAIEHPCCCDrGCCCCA?A "?>?CCCCCcl@BDDEE@BBBBBBBADELECCBhGDDCCA@A)  .>?ABCCCGuQ@CDDEBBCBABABCABEEDCCC^JDDCCA@?; 6>@BBBC@dj?ADDDBCCCB??=ABCCCDCCCCM_EDCAAA?@:?AAAAAMsV?CCDB@CBBCC@CBBCCBCDCDDH‰SDBAAAA@ =@ABAAATE?BCC@@:BCCCCCDCCBD@CBCDDwsL?AA@@@&ABAAAA?ACA>=?AACCCCCJGCCCCC??>=?@WZBBBAA@?@ACBA@AABBDNC:?AEO[^l~zh`ZMCAB?=<@BAA@AABA. :BCBAAAABBFNDCBIZdcSdfaQbgdREDCG>@AABAADC5  /AABAAAAAABDDCBRhb]KLwPGcgd^NDEFD@AAAABE@   :A@BBBCEBBCDDBD^eb_IFPFG]bfkWCDDB@BDABCE3  >B@BBBEQDCDDBFHfe]REDDDDLfonYA@CDABeWDDD%  =BAAADEIDB@A>ATkgUDCCCDC:NpkMD>ERFD-MBD4  ;ABBCD@DDABB?HNJL.UdDCC36, >@BACDBCDADCA<>CKOCBCCCCCVkeP?BI\UI[|dDBCCBC!:?BBDDCD@ACCB>@CEPE@BBBCEccMGFKVc\NHz]DAB8;B# .AACDDDACCCCCCDCEEDCBCDJiVQXSOX_\OFwRCCC3)A! 'BABDDDBBCCBCCDBICCDDDFX`kcWQRY]UDG`DBBC@;AAADDCAADDCCCA>LNCBEDT``icVQR\NEAADD?@A< 0@AADDCBCCBCC@?DNGCGBOVTadVQUTFBCCDC>AA,?@@BDDABCBACB>>ACDDDDFLX]SNOJDACDDAAA? %@@ADDCCDDCBCB?BDDDDDECDHGDCDD@DDBAB@0 4?@BDDDDDDCCDCBBDCDDCACDCCDDDCDC?A@A  @?B?DDDDDDCBCC@AAC@?CDDDDDDCDD@@@?4 *@>?@DEDDDDC@????B?>ADDDDDDCDAA?>@ ;?>@CDDDDDDCDC@?@CCCDDDDDDBAA@>A A>?@DDDDDDDDDD@BDDEDDDDDEBA@>B" .@>?ACDEDDDDDDCDEDEEDDDDBB@>A#  @@ADDDDDDEDDEEEDDDD?AA>A+  @>=@A@BDDEDDEEEEEEECBB@>A3  @>=>?ABCCCDEDCCDCCBA>>A/ ?@====?@@A@?@@??>=>?B+ /AA@>>==>=>>?>?@AB9    +5=BBBAA@><83)       "%%&&% *;BABBBB>'&8ABBBA@BAB9(!  %5>AB?@BBBBABBBC@4' 0 1?@>?ABBBBCTdCBBBBBA@@@5 BA?=;>???BGJ]odcGCCA@A=;<>@$  3@<;;=>??@^v\T\ac^ghFA?==<<=A$ .@=<=>=>A@QlNLMT]_S(QIA<>=<;=@  )@=>BA>=?AMx\S^]YZZY?H@@=>==A@>>AAA_J[^ZYTNZ\! AD>=>A?=@@' 2?=>><<>@@NI#OeOPP@N\@ N=<;>B@>A@===;;<=@A\?B\OHI:@Q\H<:;;>B??=3?=>>@B=>@=@)>=?ACCD@;ACnhiPDIDDECHBW5&PA<;ADC@>=>9 )?@BCCCCABLO_RCBBBBCBB\TUOA=@CCCCC?=@ @@ACDCCDPBAAGI\NDBBAABCDfONC?BDKCCCCA>@! ->@BCCCCJŽSBCDNYQCBBBBBCM_bJA>BWqDCCDC@?3==>BCCCCRQCDDDGMCBCBCCCNILTCBAZnDCCCCA??"?>@BBCCChvECDEDDBBBCCCCCADDGECAPjDCCCCA??% .>?ABBCCMl`DDDDD@BBBBBBCBBAEDCBBJtFDCCCA??: 6>@AABCBhbDDDDDAACBCBBABBBBBDDBBCvXDCCBA@?@;?AAAAAEsTCDDCC@BBBBBAACCBA@CDCA@_KA@AAA?? >AAAAAAF†JCCCB?@?CCCCBCDCB9?ADCA?GnmA@A@@@?$@AAAAAAAPA@A?=AABCDCCCCDDCBA?@BB?Atp>BAA@@@"ABAAA@A?ABAA@?BCCCDIWhaPECCC@>>?==AB@A@AA@? /ABBAA@@AAAHPC9@CIRXo{tteVTRHACBB=@AA@@@AAA7  +@ABAAA@ABABECCFTUTbrv|hnaYUUSEDaC@@@A@@ABB ?AABAAAAAACDDESQ]hVFpˆgFSjlXWEEFB@A@A@@BDC* <@>BAABABBCEFFP]lWHF]}TFIbnoNBIGC@@@AAACDC@ AFGFCBBBBACDECB?@CCADEECBABAB: ,BCCDCCBACC>?ADHGECB@ABEFGB@>@CCACDCCCCC/@= &ABCCCDCBCC?@BC@DFKJGHJFDA?@@ABCB@CCCCBC,,? A@CDDDCBCC@?BC@=@FILKIC@B@BBBCCA@CCCAAA4- ?@@DDCB>AAA@BCB><<>CB>=>AACBACCAABCC?@@0  -?@ADDC@BCA>BBB>=?BCBB@?AACB@BB@ACCA?@@" >?@CDDAADCA?BC@>BCCCCBB@BCBABA?CDB?A@7 !@?ADDCCDCCAACC@@BCDBAABCBBCDCADD@@A@& 0?@BBDDDDCCBACCA@AC@ACCBCCCDCDDB???? ??@>BDDDDDDB@@?==?>?BCCCCDDDDDA@>@- %@>>?CDDDDDDCB@==?AABDDDDDCCBA@>?8 7?=?@DDDDDDDDCB?@DDCDDDDDCA@@>?< ?==?BDDDDDDDCDBCDDDDDDDDDA@>?? $A==?@CDDDDDCDCDDDDDDDDCAA=>@! 2?=>?@CEDDCDDDDDDDDDDB?A>>B%  :?=>@@ACDDDEEEDCDDDCBA>>A'  ;?==??ABCCCCCBBCCBA?=>?  5@>=<<=>>>===>>===>@<  8@A@?>=>>>?@?@@A=+  (2;?@?><:73+        /?@=@7  (9A@AAAA9%   7?AAABBAAA6,) 2?A@AABA?ABAA?1  4??@@>BBBBBABBABB<$  3.?==?@ABACO`gNBBBB@@??;->A?<<>>@BO`bmkfiNJHA??=;<>=  *@=:<>@A@DqŽZWbh]Zt{F?>=<;;=? &?=@ABgz[[[`][XQYkEA=<<;:=> !?=?=;>7 ==<==?ABBC[ihU='%@Q/(8J>>=>A?<@C+><>??@BBCIaPcJ9$;R1>??=;=A?=>><>=:;>BBC]Œ]bE=/"9ND DA>=;;5 (>=><>><@CDn€]BA7+#*?EI*ebB@<<>;<=?CF~…wYBAA>A@?Bbw]^CA;@DB?<@BBBCCA?BAh…wT?@CCCB?BWiqZC@<=  ??BCCCCDSC?BDHMDA@B@BAACOKKCABEEBCCCA?? +>?BCCCCG…iBCDDCCBABBBABCEHDB@BoZCCCCB@>,;==BBCCCOw`CDDDJDBABBBBCIEDEDCD~XCCCCB@>= ?=@BCCCDmxLCCDCDBBBBCBCBBDCDDCBu_DCCCB@>?" *=?ABCCCSi]DCDDCABBBBBBBBB?CDDCBdrECCBB@?>8  4>@AABBBiWFECDCABCBBBBBBBC@ADDDCHzWBCBAA@>?:?AA@@ABvVEDCCB@AAB@BBBBBAA?CDDCA_wEBA@@@??>A@AAA@AƒLDCC@>AACCCBBCCCB?>@CCDAKo]A@@@@@@#@AAAA@A@GBAA>?@>@C>@@@@@@@9@BAA@@@AABFIC:ACGN[v}zxiXRPG@ACR?AA@??@@A@> 9?AAA@@@AAABDDFNSUQZjzzqn\SSUZSIRBA@@???@BB9 3?ABAA@@ABBCFPWSOV\mW}mXi][WORQOC@A@@?@ABA5->@AAA@BABBCRPMGVZ\]Koz^JW_]`;MRTEB@@??@ABA@ 0=>A@AAA@CCEMPVJaZ_VFGIGELa[hVVFCBCCF@@@ABB@ (78A@AC?@CBBCDJ[p\hGCCCCCDbooOECBBCDIE@@AAC@'/A?CCBCC@BBCCHbr_EBCCCBDNaRBCCBCCCCDC@@ABA  &@ACCCCB?BAACCWdZDBBCBADNPHCBABB@BBADA@A@A!  "AACCCCCBBA>BBG`fYJCBBFPUQA@@?CB>@CCDB@B4?9A@CCCCCBBA>@BBBW_^ba`^\U@=?A@BB@BCCCB@B$-7??BCCCCB??=>BBB@HWWXWZP>@A?@?BAACCCC@@A& :??CCCC?>@>>A@ABCCC?@A%  '?>ADDC?BCB>?ACB@=?BAA?@CCA=?A?@ACC??>?<>@DDDBACCC>@CCA>?AB?AACC@ACCA?CDB>??0 ?>ACCCBDCCB?ACCA>?A?BCC@ACCCBCDD@??@  />>@@CCDCCCC@@CB==>?CCBBCCCCCDDB>>>9 >>>>ADDDCCCCA?>==>>@BCCCCCDDCC@>=A$ $@==?CDDDDCCCCA?>@CCBCDCCCCA??><@/ 5>=>@DDDDDDCCCC?@CDCCDDCCDA?>=?6  >==>@CDDDDCCCDBDCDCDDDDDB@><>< A=<=?CDDDDDCDCDCDDDDDDB@?<>? )@=<>@BDDDCDDDDDCCDDCA@?=>A!  1@==???ACCDDDCBBCCBAA==>@  1@=<=?@BBBBBABAA@?>==?<  )@>=<<<==<<<<=<<==>A3  .=A@?>>>>???@AB?4  (2;==;750*       "8@<5?:"  &7@@@AAA@@0   5@AAAAAAAAAA<.#  2@AA>AAA@?ABAAA?0  %=??AAAA@EJHCBBAAA@3  +*?=?AABABUwtkHCBB???>/  4A?=>@8:>;>ABBBJ{˜fg`afpˆƒJ@@?=;<>=9><>BABCG‚‹w[LD?M]lyxFB@<=<;>8:><=>?ABC^…oa?1&&@e_w_BA?@A=;?- 6=<<>AACCD_„}H=82%#9Tms\EB@A@A><@A ><==?ACCCKeW]CAB>62;L[C@GCBA==><>97<=;:<@CCBc—mPCCCCA??IY2CQDCB?=>=<<;<<>CCCbŠRACCCCCCEZ]”gDC@=<<>=<9 4<>>@DB?BCMŠqPCBBCCCBBZu^CC>?B@=>>ABCCCABBIKBBBCCCBCSnx]CC?BCCB@=>( 0>@CCCCCCA@@V^RJBBCCCCBBR‡ˆuFCBCCBCB?=6 ==ACCCCDUN?ACCCBABCBBBAAFWpnBAFCCCCCA>? #?=BCCCCDz~ICCCA@@ABBAAAAACFG@EzJCCCCB?>% 5==BCCCCLypEDDBCA@@=8AABCBCDDBYˆMCCCBB@=9 ==>BBCCDjrRDDDBBCBA;5ABCBBCDDDOXCCCBB@>? ">?@BCBCRhUDCDCCCCBBBABBBBACDCDFurECCBBA@>6  .>@AABBBd\HDCDCBBCCBBBBBBCBADDDCHoSBBBBA@>> 7?AAA@A@vSFDDCBBBCBBBBBBBBB?CDDDCUqCBBA@@??=@@AA@@?{GDCC@@BBBCBBBABCBB>@CDDDSzLA@@A@@?%?AAA@A@?FCBBA>ACDN|D@A@A@@@& >AAA@@@@AABDCBCCCBBDKQKECBCCA@AB?AB?@@@@@@A" 0>BA@@@@AABCDB:ABENV\iu`YSPJC??CVAAA???@@AAA3  7>BAA@?@@ABCDDDCKY[X]wmpX]\YJDMTHAAA@???@BB@2  4! *5) @@CBCCCB@>BCCCQb]LDCCKdhUDDC@A@@BCCDB?A4<3 ??DCCCCC?=@BCCCKWZ\^`_ZNABBB??@BCCCDC@A %# :?BDCCCC?A>?BBCBCNQPQPE?@@@A>@?CCCCDA@A!  1??DDCCB>CB=A?BCB@CKJ?@BB@A>?A?BCCCC??A @>BDDC@ACC@@>ACCA>?@ABCC@>?BC@?CCC@?>= 7>@CDCC@CCC>=@CCB>>@@BCB@?CCC@ACDC???/?>@CCCBCCCC@>ACC@>?BCCA@CCCCACDDA?>@  *?=??CCCCCCCB?AA>==ABABCCCCCCDDA>=>4===>@DDDDCCCCA>>=>??ACCCCDDDBB?>=@  "@==?CDDDCCCCCB?=@CCCCDDDCDA?>==@* 4><=ADDDDDDDCBC?ACCCCDDCCDA@=>==ACDDDDDCCDCCCCCCDDDDB?><>; A=<>@CDDDDDDDDDCDDDDDDA@=<>@ $A=<>ABDDDDDDDDCCCDDB@@=<>A!  )A=<>???ADDDCCBBCBA@>==?>  (A=<<>>@BBAA@A@@>>=<=A6 >?=<<<<<<<=<<<<==@@)  ';A@??>>>@?@@AA;-   (07;;851+#   %   -=@:2==&  '=@@@@?@A@5 !'+;@AAA@?>@AAB@4+%.6>@AA?AA>($ 7@>?@AA85W^]I@@ACBA?- ,@>?A@A8Ct”„–ƒfHBBB@??'  /?@>AA@AAl’|_`|kBBA?=?>1)?<@CBA@G~h[IHdo’|NBAA?<=A8!?=;BCBAD††sKC<0@Jz‰ƒICA>?<=@* )?===@EEBYyxTCA@9:B_q†aCB@A@;<<>@AEHC`‡iFDCCBABKxZDCBA@><>@?=<==@ACEI`xYPGEDDDCCHVURDCCB@=<BEFJ˜Ù™RIFEDDDDFKOVJDDC@?>=<;==>-$>><>BB?CC_»£xIFCCCBBBBN’“wEBA>@>;>=; :=@ACCCBCBV³®•FDBCBCCCCIrzpEDABCC@??CCDDCDC>?szXDBBBBBBBCF… ¶^DCCBBCA>>* 9=ACCCCDWnJ?D@>BCCCCCCBBDˆ·±GBFCCCCC@=: >=BCCCCDrtaCC@>@CCCCCBBBCL]WA]{ECCCCA=? +>>CCCCDJwwGCCA?>@BA>BCBBA@DEEs}GCCCCB>=3  9=>BCCCDhdQCCCBAA??1&:@BBABEEDcwQCCCCB?>?>?ABBCCLmUECCBBABA?-%;ABCCCDDDJkkDCCCB@?>0 $?@AABCB_aEDCCCBBBBB??BBBCCCCDDDGhQCCCBA?>< 2@AAAAB@mKDCCCBBBBBBBBBABBBBCDDEE]lCBB@A@?? <@@@@@?>wGDCC?ABBBBBBB@@BBC@@CDEEY|CA@@A@@?%?AAAAA@>HCBBB>ABBCBBBBCCCCCB>?BDDQx@@@@A@@@( ?BAA@@@?AA@BBBBBCBBCCDCCCCCCBBCCAC@?@@@A@@A( 7BAA@??@ABBBA;ABEFIL^fOIFFEB@ADNBB????@@@AA=-BAA???@BCCCCABIXS]kf`neZS\OCCGCA@A@>?@@AA@>!AA@?A@ACCCDHCC]ZWgoe^kjaX^_EDGDAC@???@ABB?9.  0@>@CBACB?BCB@cVNGEEEFEHN[`EDDCCCC@@?@@AA?(  #??CC@>@>>BCCCIQIDBBBBBCGRHDCCCACC>A@A@AA?1  @@CC?>==>BCCCBCCBABBBABCGEDCCC@>?>?CA?A@>/ @@CBBCBB?ACCCBCCBABBBACGICDCCB?@BBCCA>A;;* ?@CBCCCB@>BCCBCDECBBBDKMECCCC?@CCCCCC?A)) BDCCCCABAACBCCCDEEDDBBBCBA@@ACCCCDB@A  +??CCCCC@BC?AABCCCA@AABBAA@>BBACCCCD@?@ @>BDCCA@BCA@A@CCCA?ACCCA?=ACC@@CCDA>?: 3>?CCCB@ACC?>?BCCB?BCCC?=?CCC>CCDC@>?,>>?@BCBACCCA>?CCA?BCCA?ACCCCBCDDB?>?  $?=>>CCCCCCCC@@???>AA?CCCCCCCDDB>=?/ :==>?CCCCCCCCB>>=?@ABCCDDDCCA@?==?  @==?CDDDCCCCCB?=?CCCCDDDDDA>===A% 4?<=@DDDDCDCCCC@BCCCDDDDDCB?==@0  =><=@CDDCDDCCDCCCCCDDDDDA?=<>@CDDDDDDDDDCDDDDDCA?=<>@ A=<>ABCDDDDDDDCCCDCB@?==?A  "A=<=>>?ADDDCCBBB@@?>=>A: A><<=>@BBAAA@@?>===?A*  ;@=<<<<<<===<<<=>A9  "8AA???>??@@AB@6#   (058862.'!  $4*#  1>?=:;>0  &;=??<9=AA:"  $3.4>?<>=89?A@BA0/53???@>=<<<3?>??BBDA;;%!@>>0c|…q’„Ž\ICCBAA.  2>B@B>@=C‹{tVGNe~‹|CFEA?@6/?@BBA@?@2 5@=CFEAD}MADEBEGv‘JGCA@:=> 7@>?CKKBYtaLEEFHFERtŠgEB@@>;?6:<<>AELULqnNILJGFFFFw|WIFD?>==@87 5=<=ABEGZ’clZQNLJHHIH>IGCCAA><=A1 @?>>CGLR]ÈýìbVROMKJHH>INBCCB@>=><3@@@BDIMMX±¸ÓsLDBBDFFJM\—ABDA>=>>A* ==><@??EM`hRIIB?=;:89?–ÑÄA==::98:;2 ,@ABEFGGLJV‰[AIJIIGFDEHÉžFD@?@?:;;9 =?CEFFGHU<CM>BAEECCCCBBq´NDCDEEC@<>  ,?ADDEEFX}X:CCCDDEEEiVb?A==>ABCDDCCBBENM^xnEDDDCA<= ?@CCDDDEbgB=@@>?@BCCDDCA@ADGXirDCCCCB>?-  .?>CDCCD]bD=>BBA@@A@?ABBCBBFFFkpLDCBBB>>>;?ACCCCFkH>>@BB>B@=%4?BCCBEEEJ`cDDCCB>=>( ?AABBCBS^?@?@BBABB?-+9 )@A@ABB?^E???@ABABCA@BACCCBCEEDDEfbCCBAA@?> 7AA@A@>=pBA@@?ABBBBA@B@BBBCCADEDERuBA@@B@A@# =AAAA@=;KA?@??AABBCBAACCCCCC?BDDDPt?AA@A@AA'  ;>@>?@@ABBBCCCCDDCCCCDCCDCDB=@@@AA@@  3BAA?===?A@?==@FOVZV]cRLNNICADCFCA????A@@A@8 &BA@>==>AAAAA?COX`_ZVV]_a`[QCBCABAA?>?@AAB@>BB?>=??BBBA@BEV^ic[YY\\bg\`EDCABCA?>?@@AB?> >@??@A@AA@@A@;YYgnaYZZjkbV]ADCCCCB@??@@AA>; ->=?AA>@??@@@@NTbNIJIMOgYQKCDDBBCC??=@ABA<8?>AB?;;;>?@@BCKLDCBBBBINHBDDDB?A@=BA@?@?82??BB>;::<>@ABCDEBBBBBACEDCDDCC>===>CA>@:0% >?BA?A@=>=ABBBCCBABBBACCCCDCCBA@?A@BB?A0=?CABBBAA?ABBBCBCCCBCCCCCCCCCBCCCCCCC@A, 9>CCBBBAAAABBCCBCDFDECCCCCCCC@CCDCCCC@A&2>ACCBBA@@AABCCBCCEDBCCCCCCCBACCDCCDB@A  '??CCBBB@?B@@BCBCCCCCCCCCCAAC@CCDDCC@?=?>ACBAB?ABA>?ABCCCBCCCBB?>BCA@BCDDB??6 0>>BBBA?>BB@>?BCCCBCCCB>>@BCA?CCDD@>@)<==>ABB@BCCBA>ACA@CCB?@CCCCBCDDDB?>= #?<<=BBBBCCCCA>=>????@CDDDCCCCCA>=@, :<;?=?AACDCDDDCC?>?===  ?;;>CCCCCCCCCB?>@CCDCDDDDCB>===A% 5>;<@CCCCCCCCCCACDDCDDDDDCB>=<@2  ==;=?CCCCCCCCDCDDDDDDDDDA?==?=@=<=@CCDDCCCDDDDDDDDDCA?==?@ @=<=@BCCDDDDDDCCDDCA@>=>@A  @=<===?BCCCDCCBA@@>==>B8 ?><<=>?@AA@@??>>===@?# 6@=<<<<<<<=====>?A1  5@A???>??@ABB=/  (/45630+% '44&  $3<<;3( +;@AA;<<@?;$!%!.AC?><:<>@>?>"+4 .>>?DDD>3YRI6:>9CDCA@9" )ACDFEFHžlVro™‰QCECA@4(.7?@EDHGR¦…ZIFGL]—‰CFD@@@$==@EFHGi¢dIHHGHJ‚ˆ_GF@C@@3%?;/ $@=::CFIl”XIHIJJM]“»–PE>:;<>! +?>>?@BCN¥™hIIGCBFKU ŠrOIA?=;=7,-!:99=AFB@X¦~_GCFNNJFICBD@A?<::=B2;=;:==>?5k²¦YJLKFFJKFF @I:@=><;;>2=<::<>=8ZÞâ{B<=?@FKNUZW—o68=>=====*676769?M£úÆU267999745=¨ë‹+25333458>>BEGHIR\9¹W>@CDEEECBKÇì¤GHFEDB=>>0 1?AEEGIL{h9_[HE@@@??><77\nGHCBDECA?<  @@DFFDFYwQ^_NFCCA??=;98=4A[ctQHECBA<>#  6?CDCDFFhUgNJCFBAA@?>=<=A8?djmaGFEDD@>5 >?BCDFEFeaDCGEFBA@AA@?>A<;?GgbmEEEDCA=?$  ">?BCDDE[gB?EGECCBA@AAAAB=6 3>?CDCDGqC?AEFDAA@A<;>@A?=AB@GGk]ECCCC>>? =@ABBCDP`?ABDEDCB@9! 3@B>?DC@DCNkFCCCB?>?4 !@AAABCA^K@ACDECCBD@:??BC??DCABDCiQDCCBA@@> 1AAAAA@@lDABCCDBCBCB?C@AA@@DAABECWdCBAAA@@@"  8AAAAA?=RA@BCCDBCCCCB@BB@@ADAAADDVm?BA@AAA@%  6AAAAA>=?@B@BCCCCCDDDCDCA@ADBBAABEC;@AAA@AA .BBB@??>?BBA=ADMSPKKT]MDDEFEABAAC@A=>@AAAA> $ABA>>=?ABBCCAL]YWWSRUUZTTTXFAA>CBA?>?@AAB:(BB@=>@?BCDCBCGXYUWWXWXXYWVTHCA@CDA?>?@AAB4,>ABA=>?CCDCCW_kVNLKOUm]]TDCBBBCA?@>@@BA$# ?@BB@;;?CCA@CK]iHCBBBC[eZHCAA@@?==BB@?@= ?@BB>;;>@@>ACDUaFBBBBAO_NDDBA>>=<>?BB?@5>?BA=>>>?@ABCCEYMBBBABVPCDDCA@?<=>?BB@A.  ACCDCCCBCCCCCCCDRRDCCCCCDCBABCCCCDB@?  #??CDDCCCBDCBCCCCCFLCBCCCDABBACBCCCD@?9?>ADDCCBABBBABBCCDGBBCCBB@BC?@BCCDB?@0/??BACCB?CDB@AABCBABBBA?ACBC?@CCCC@>A$==>>ADCACDCCB??A??AA??ADDCCACCCCA?=;#@=>?BDCCDDCCB>>?=<=>@CDDDCCCBB@>=@'<>=>BDCDDDCCCB>>==ABCCDDDCCC>=><>;  #@==@DDDDDCCCCB?=?BCCDDDDCBB?=<<=@DDDDCCCCCB@BCCCDDDDDBA>=<@1 @><>ADDDDCCCBCBCCCCDDDDDA><=?=  B>=>ACDCCCBBCCCCDDDDDC@><=>@BBDCCCCCCCDCCCB@><=@@  !A>====>ABBCCCCBA@?>==>B7 @?====>>??>>==>===>A># 5A><<;<<<<=<===?AA- 2@A@???@@ABBA8($+012/+% '% -7=?>95-" )8?AA<@=@?8 "4>C@?>:=?@?B9&!56;BDD>1]O@,2>AC6187&$4?ABDD@1j}m‚u9?CA<9>; +>@DEDFDgKFJLhTEB>>?4"'/>@CBCFKcFGEEELƒGC>>>= @=?DECCM~SFFHEDG[pYD>>@=< @=>BBDK•QFHHHFGuqlI@?A<=; :=;=CCDo¤ŠKDGHIJIT{™sA>;9;=. ;?<;@BAW°©DB@BEHIN{m]?>@>;:>%6=<>@FDBd®ª}A>BEEIKLJ;E3@CDFS{‹QACC@ACGLUIH->@;9768;  :=>>ABBA\¢³Y??@BAA@?BL‚fB5016567:. =@BCG† ®aCBBBCCC@?HÖîr'245689:2;=ABB@Rmx•KA??@??>:01Öú°6=?AC?==? >>@B@=>,;>ADCBBVlSuWDBAAA?=<97:8G[o‚ŠNFB@A>;9+?@BBBCCg^oM=AA@??>===>=?BOzZyZGECBA=?$ :>ABBCCEpYE@AAA@?????@@?>B@IlmjGFEDC?<8 =>@BCDCXiDBABA?AAA@@AB@A>D@BGasLEEDDB>=&  )>>ABBBDqJBAABA@@A@AABBA>>DB@FGnXGDDDB?>; :?@@AABOaDBBBBBA>==24;AA??DA@EESiGEDDA???* ??@@@AAaOCCBBBBAA@8670@B@@DA@CFEnJFECAA@@: '?@@@@@@kHBACABABBBA@A=AA@@C@@AEEfVFDB@AA@? .@@@@@??VDBBB@AABBBCB@@BAA@C@@@DE\gADCABAA@ .A@@@A?>ABCBAAACBCDCDGCBBAAB@A@@CHE=ABBBAAA (AAA@@??ACB?9ADHEDDET]MCBBBC@>?ADC@=?ABBAB? @AA???@BCBCBCYVNNU\VUYRFEFLIA@@DDA???BBBB: ?A@?ABABCDCCFJGRSW[XW\^XNFFRE@ACEC?=>@BBB-  7@?BBB>@ABBCCFK]^dYTVU\b[QISFBABDB?>?ABBC!  )??CBB<BA@@BB @ACBA;?ACC?<=BCC@@BKVcIBBBABYZUFA?>?A@>>@CCAA3=@CB@<=AABAAA@H`YBBBAEcZFBA@>?@===?CCAA*  :?CC@@BCCBBBABBNg[PMTh[FBBBBABA>>?>BCAA$ 4?CDACCCCBCCBCCCIXSRZSCBBBBBAAABCCACC@A  +?ACCDDCCBCCBCCCCFVTKCBBBBBBABBCCDCDB@> @?CDDCCCCCCCBCCCDPTEBCBCBABABBCCDDD@@6>?ADCDCCABBCBBCCCKUCACBBAABB?ACCDDC>A**@>@@CCC?BCBB@?ABBBBAA@>ABBB>ACCCC@>@ <>==ADCBBCCCB>?@>?@@?>ABCBBABCCCA?>6!@=>>BCCCCCCCC???><>?BBBCCBCCAA@>=A!:>==CDDCCCCCCB?<=><=A  7?<=?CDDDCCCCBB@BCCCCCCCCB@><=@1A><=ADCCDCCCBCBBCCCCCCCC@><  !B>=>ACCCCCCCCCCCCCCCCB@=<=>@ACCDCCCCBCCCBB@>=<=@@ "A?====>@ABBBBBA??>=<=>B6  @@=====>>==<<===<=>A=<<<<<<<==>@B;$ ):@AAAAABBB?8-  !$&'$ %-;>>?<4% (:AB@>A@AA4  4@BAA??@BABC<(-08@BBA>>?6=?BCB>1*$ #7>@BBBBJnzusndICBB>243&?ABCCCC–}MIHHNxXBBBA@6  8@BBBDLšŽQEEDDE]xNCBBA= B?@CDCDJœICDDCD^ŽaCBBA>4?=ACCDH’PCDDDCCM’“FABA<@CCEY‚‹JCCCCCCL¢žJAA?;<= '?<;?CC\ž”eCBBBBBCCUQCAA?;:=4 ==<>CCCl–—^BBBAAACCBDA@AB;;;>=89==>ACCFYxvFAAABBABADGB?AB=<::>/$>BVPA?@>>;;;=  7<=@BBDb†‹sFABBBBBA@>G¬¶a:???;:;=+ ><@BC@cy~ˆiCAA@BBB@?>D˜¡”PA>@@>=<7 8=ACCCHzQy~OC@@ABBB@??@s™‚b@BBB?<> 0>?BCCC]gblHBBAABBBBA@AAS‹xT€GCBBA=>* >?BCCCCldWD@CBBABAABBABBAQw]qRCCBB@<;  4>ABCCCJoKBABCCBAAAAABABBAAHadbDCCCB?>+ =?@BCCB^eCBACBBBBBABBBABBCADE[nFCCCBA>< ???BBBDsSCABCBABBBBBBBBAACBDDHkQDBCCA?=1 3?>?AABRlFCBCCBA?=A?@BBAABCCCDE\fDCBBA??>=@@@AABeSDBBCCCB@--9<59@AACCCDEIuECBB@@??2 ?AAAAAAhMC?BBBCBBBA>3*@BBBBBCCDFsNCB@@@@@<"@AAA@@>PECCBBBBBCBBA>=ABBBBBBCBD`]ABA?A@@? "AA@A@?>ADCCABACCCCCILFCCCBBAB@BCGC>@A@A@@? AAA@A>?BDC@??@A@A? @@@>?@@BCCDCJXJEEJcZV_TEDCDEBBCDDA??@AA@A9:@?ABB?@BDCCNRDEKXc^[c`LDBCIDBBCDB?>@AAAA/ /?>BBC>=?BBCDPCDJZ]\\`]OE>DHDCBBB@=?AAAAB% #?@CCC==ACCCCNbgPIXWXWPG^[RDCCCC@=>BBBAAB @BCCB<=CCCC@R\[^DCCCCCQ^a`FCDDDB?=BCCBA< >ACC?<@CCCBAEUW]GBBCBBYW[RCBBCDB?BCBB) 5?CC>=?BBBCCBB@UZWQPS[[F@ABCBCB><<=BCAB".?CD@ABACBCCBB@CVWQOS\GCCBBCCCB@BA>CC@@ $@ADCCCCCCCCCBABD[WYYHDDCBCCCCCCCCADB@< @?BCCCCCCCCCBACCHZ^ODDCCBCCCCCCDCCD@A2;?@BBDCCBBBCB>BCCQ[FCCCBBCBBBCCDDDC?A%&@>??CCC@ACCC??@BBBAA@>@CBCB@CCDDC@>? =>==ACCCACCCB@>=>?A?=?BCCCBBCDCC@>?1&@==?CDCCCCCCC@>@@??ACCCCCCCDB@@>=A=>=?DDDCCCCCCC?=>>CCCCCDCCCC??>=>7 %A==@CDCDDCDDCB?>@CCDDDDDDCC@>==B 9@<=@DDDDDDCCCBACCCCCDDDDCA>==@4A>==BDDCDDCCCCCCCCCDDDDCA>==@@  C>=>ACDDDDCDDDDDCCDCDB@>==?B "B?==@BCCDCDCDCCDCCB?>==>A@ A@==>>>@ABBCBBA@??==>@C5  ;B?===>?>>>=>>?>>>AC7  #=====>>@AB@0  *6=@BCCBA=6-    ,2./ .@A?@@?,  6BB@????B9  :BCA@@?A?AB; "9BCCA@JCG@@BB8! +;@ACCMr“Ÿ™š‚OCBB:%8AAABBIœ“rhbj~«gCCB=6! &@BBCCJq‹rGDDEWŽˆQCCBA3<>@CCBCOŽzGBCCCEp¢sDCCA?' ;>BCCCG{pMBCBBBBOxEBBB== >>BCCEU}|HCBBAAAG‰FBCB<>/ 9=>>CD]“}^BBCBBAACUH@AC@<<>  .><@CCFu„PBCCCBBBBC@@ABA=;=;,%">=>BCDVƒwGCBBCCBBABB@BAA<<<=A# 9==@ACMv\i`DBBBBBBBACJFABB>=<;>- #=;>BAFyeczGDCBBBBAAAD`gYDC@@=<<; 8<>ACAoekƒZDCBBBABAAADw„ƒrC>B@?<>#(>>BCCOvSsZCCABAAAB@@ADhŠ€tj@BBA=<3 ?>BCCCgcfOCCBAABBBBA@BDHvrK|GCBBA<> <>@BCCDn]GCCCBBABBBBBABCCFbelRCCBB?=2 +>?ACCBTiKBBCCBBAABBBBBCCCACJ_dDCCBA>> :>@ACBBjdDABCCCBAAABABBCCCA@CRnECCCB@=4 ??>ABBGrXDACBBABBBBCBBABBCCBCHoOCBCB@?>$ +?>>?ABVmHCACCBBBABBBCBBBBBCBCDdeCBBB@??< 8??@?ACeXD@ACCBB9#/;:8;?A@CCBCDRvCCBA@@@?)=@@@@@AgOBABBCCBBA4';BCCCBB@CHuJBB@A@@@5 >A@A?@>DCCCBBCBBBB@7/-ABBBCAABBDbV@BA@A@@;?AA@>>>ADDBAABBCCCCHIFBCCBBBA@CCD??@@@@@A=?A@B@??BCCBCCDCCCCNYYZIDDCCCA=CDC???@@A@A; ;@@@AA@ABCDBGICCDGQWVWMEDCCCBACDCA>??@@@A6  3?>BBB@>BDBCEFCBCRRQQQUODBCCBBABCB=?A@>@A. )??CBC?=?@ABCCA:BUYRUV\NB9ACCB@BB?>BBA@AB#@ACCC>>@CCCBDY^GKYSTXXHWYLCCCCCA>@BBCBAB @ACCB=BCCBA> =ACC?BCBCCC?<=BCBA+ 0?CD>=BCBCCDC?=KYYOKP\SA=?BCCCCB><@ACCCCCB=>RSRSRXC>@@CCCCC??==CC?@ @@DBBCBCCCCCA??DRS^^OCABACCCCCCCB@DA@;??BBCCCCCCCDA?@CFUaYECBACCCCCCCCCCD@@1 5??@BCCCCCBCB?@BCORJCC@?CCBBCDCDCDC?A$"A>??CCCA@CCC@>?@BBB@@=@CBCAACCDCC??? >===BDCCACCCC>>?@AA@>@CCCCBCCDBC?>@0 .?=>BDCCCCCCCC??@?>?BCCCCCCCCB>@==BA==ADDDCCDDDDC>=?>BCCDDDDCCCB?>=>: 0A==ADDDDDDDDCA>>?CDDDDDDDCCB>==B% ??==BDDDDDDCCCB@BCDCDDDDDDB>==@8B>=?CDDDDDDDDCCCDCCDDDDDB><=@A  #C?=?ACDDDDDDDCDDCCDCDCA?==?B %C?=>@ABBCDCCCCCDDCB@?>==@A# %B@=>?>>?AA@CBBAA@?>==?C:  =B?==>>>>?>>??>>>>@C<$ '=CA@?>>=>>>??ACA6"  *6=@BCCBA>90$    (+) 18::<7!  !:@???@?>(  '?BA@@@@@A@(  /ACB@@AA@ABBA( ,=ABCCLYio]XCBBA+ +8@@BCHvw|Š‚|‡€TBBA/ 5@BBCE\’†YNKQx˜bEBBA:-4?BBBCV’ˆ[CBCDVUCCCA;3?@CBCFsziDABCCFo€^CBCA>0  :=BCCE^\CBCBBC^|DBCB=> !>>?CD`ƒfwGBCCCBBMpY@BCB<=3 8=?>CJtqz\BBCCCCBDaWCBB@<<># /?<@@Ai‡puGBBCCCBBBUdKCB@=<=;7##><<@ATsMtWCBBBCCBBBPkhNC@==;==:<?=;>( &=:=?BCCnU\ECCBA@BAABAAACCRoU{HCCB?<8 2>?BCCKo[FCCBABABABBAAACCCJ^hTCCCB>># >?ABCBadSCCBCABAAAABBABBCBCE[hDCCB@=:4>?ABBDmbDBCCCCBAABBAABBCBB@AUsFCCCA?>%>???ABSjXDBBBBBCBBBBBAABBCBACJ~QCCCA@>=!??>?@B_jICBBCBABCBBBBBBBABC@CDrfBBBA??>5 -??@@ABnbCAACCB@5/6>=@BBBACCBBC^oCBB@@@@? 6@@@@A@SGBCBCCCB@> :ABBCBB@BLiLAA@@@@?+ :@@@@A>@BDCBBCBBBB6!-ABBBCBACCEaM@BA@@@@5  ;@@?>@>BCDC=AABCBBCDDCBBBBBA?@DCA>>@@@@@@7  9@@BAAABCAABCCCCCCFMNLECCCCCB@A??@@2  ->>BBCA?BDBCBCDDFX\USX]UJIFCCBA@AB>BB@??BCCCC:KXaZ\]^[E?BBB?@A @ACCC?=>ACCCDWVLbgeeej\S\RDDCCA@=@BCCB@A @ACCB=>CCCCCIjrVEJMNMGHsh^DDDCC@=>BCCB@=  =ACC?CCCCCCB>@KRCCCCFYF>?CCCCCCB==BCAA, /?CC=?CCCCCCC><>ILGEHPF@=@CCCCCB@<=CC?A @@D@@BCCCCCCB?ACDEIPFB@?BCCCCCBA>@DA?;??A@BCCCCCCCBBBCCHNUDCBBCCCCCCCCBCD@@. 4?>>BDCCCCCCB@ABCFHJBA>@CCCCCCCCCDB>A #@=>@CCCBABCC?ACCBABCCDCC??< @==?CDCCACCCB>?BCBB??ACCCCBCCDAA@>@/ 4?=ACDDCCCCCCC>>?@=>BCCCDCCCCC??==B B>>CDDCDCDDDDB>>>=@CCCCDDCDCCA>=>> 2A=>CDDDDDDDCCA??@BCCCDDDDDDC?<>A+ =?=@DDDDDDDDDCCACDCCDDDDDDC>==@< B>>@CDDDCDDDDCCDCCCDDDDDC?==?B )C?>@ACDDDDDDDDDCDCDDDCB?==?C#  2B>>?@@ACCCBCCCCDDDCBA?==@C$  5B>=>@?>>A@@BCCBA@@?>=>B?  0C@>=>???@?>?@??>==>AC3  ;CA?>>>>>>>>>>?@BB6  2=BCCCCCCCCB?8*  !$$$#"      *.1353# /=@@@@@@>1!=BBA@@?@ABA: -?BCBACDEBBBBB>  5?ACDIY_uxbdNEA@= 7AABCR……tpltŠSCAA> !9@BBCK|˜zHDDK•tGBBA=" &A?BBCEi|MCCCCZ„„PCBC@;)>?CBCb‰aqECCCBHqˆoDBCA>/ 4=@BB^qWxPCCCCABhlfEBCB<=>=@AKxcpZCBCCCBBJrkMCCB=>2 9==?>lc[kEBBCCCBBCkikFAA><=" 9><=?TmTzJCABCCCBBBTtje@??<=;9*=<=?KwTeQDBABCCBBACDx\sQ=?=<<=<<=@Ez[ZHDCCBBBBBBBCCSkOrF=?=;>' 5<>B@eceICCBBABA@BBBBCD\\VsAA@=<<,>=ABBvH]DCCBAABA@AABACCDZ\xHCBA<=,?=@BBOo_KCCBAAAAAABAAACCCDZ]WCCB@<>:>?ABAbgWDCCBABBAAABBAABCCCLYnDCCB>>- (?>@AABmeECCCCBBABBAAABBBCCBB^tKCCB@=> 9>@@@AOoRDCCBCBBBBBBAAABBCBBCOu[CBB@@>9?@>>?AUdFCCBBBABBCBBAABBBCCBBEmeCBA@?@>(  ?@@@@@NPDCABCC@06@>@BBBBBCCBBCadFA??@??;(?A@@@?@ABDCBCCB<09=@BCCCBBBPbLAA@@?@@-?@A@@>@CCDBCBBBBA09@BBCBCBDDCPB@A@@@@@& .????AABCCC8BABBBBBCBBBBBBBA>=DBB?>@@@@@@+  ->?ABBBBB?7?CCCCCCDHLIDCCCCCB;CBCA??A@@@@+  *?BCBBC@BDCCCDECCESUSURDDDDCCBDA@BABB>>@@% &?@CCCB>CDBCCEMHFQWWUVVLHIRECCB?>@ABCABACCDHS?IYZZYXV]GBXQFCC@>=ABCC@@< @ACCC?<>BCDCDhksn_][[aqmb[EDCC@=>ABCCB@8 ?BCCB>=BCCCCHednONNPOJQob]ECDCC@>?CCCB@2  BCCCCCDVVaJBCCCBUZUWECCCCC?=ACCBA)  7@CB=?CCCCCCCAKV]FCCCH]RICCCCCCCC>?BCAA! 1@CC=ACCCCCCC??CCCCCCC>ACCCCCCC@>BCHPUQEBB?ACCCCCCC=>CC@< @@C>@CCCCCCCBACCCCDDCCC@BCCCCCCA=@DB?1 @>@=@CCCCCCCCCCCCCCECCCBBCCCCCCC?BD@A#  9>>>ACCCCCCCB?ACCCDDCB?@CCCCCCDCBDB>A *?=>ACCCCBCCC@<@CCCCB=>ACCCBCCCCBC?>> B=?BCDCCACCCB>=BCCC@>ACCCCACCDA>?=?7 5@>CCCCCBBCCCB>=@@>>BCCCDCCCCCB@>=@* B>?CCDCCCCDCCA>>>>?CCCDDDCDCCB>==A .A=ADDDCCDDDCCBA@CCCDDDDDDCDC?==A+ @>>BDDDDDDDDDDCCDDCCDDDDDDC?==A9  -B>>@CDDDDDDDDCDDCCDDDDDDC?==A> =A>@BBDDDDDDDDDDDDDDDDCA?=>A@ @@>?@ABBCCBBCCCDDDDCB@?=>B?  @A>>?A>?>A@ABCCBAAA?==>B=  =C>>>>@@@@?@AB@??>=>@D4  /CB?>>>>>>?>?>>>?AD? /@CCBAAAAAABBCC9#  $,156431.)!    !+27;96( (:@AA@?@AA;! 4AABAA@@@ABA?+ :ABCACCIKCDBBA@- @BCBdrw\EDDFq}xFBAA?$;>BCA[lXvFCCCCSo]CAB?<>>CAVoZxNCCCCCDlnpE@C@>/3=?CHxTrNCBCCCBCIvi]@AA<<,><@@j\hYCACCCCBBCk^wJ>@<>+ +><)-<;9  5<=?Cw[YDCBBBBBABBABCFbSnJ<><;>+==??`b_PDCBBBBA?BBBBCCH^TuA>?<<6>=@?>o\gECCB@AA@?ABBBCCCUWqG@A@<>  9>?A?CjgJCCBA@AAAAAAAABCCGZ]YBCB?<8 ,?>@B?JbLDCCAAAAAAABAAABCCCYZpCBBA=?>=????ONBCCCBAAAAAAAABBBBCCDhuKBB@@=<1=??=?@MDCBBBBBBAABAAAAABCCCCQn^BA?@?>1;>?>>@@DBCBBBBBBBCBBABBBBCBCCEjeC@@??>?>???@?>BACBCBA>-:BABBBBBACCCBBW`B?=?>?>/?@@@@??@ADCBBBA1#)7A@?@CBCCCCEO?A@????; ">@@@A@?BBBBBBBBB?%4@>ABBBBBDDA>%>>@@CCBBBB8BABBBBCBABBBBBBB>7A@B???@@A@?'>@ACCCAA?.>CCCCCCDJOKDCCCCCC'?CCCCC?BCBBCDDCDDQWSUUDDDDCCCCB?@BBB>>?8%?ACCCC?CCBBDQPDDJZUST[HDDJGCCB@>?BBCB>@, !?ACCCB@BCCCHYiD@]^ZXZ_WCBRPGCCA>>BCCCA@& @ADCC@=@CCCCHlkfk`ZY[cgTRKCCCCB>>ACCCCA# @BDCC?=BCCCCThnmORPPPOJ_f_FCCCC@@ACCCBA >ADC?>BCCCCCHZX`IBBCBBOX^`ICDCCC@>ACCAA  :ACB=@CCCCCCBFSUWFCCCH[TSLCCCCCCC>=ACAA 5@CC=BCCCCCCC>>ES^SGP`NCA=CCCCCDC@-?CC>CCCCCCCC?ACCL_^]IDDB?CCCCCDD@=CC?6 $@@A=BCCCCCCCACCCCLSNDDCCACCCDCDC>?DB?0 A>>=ACCCCCCCCCCCCEFECCCCBCCCDCCB=BDA@, <>>>ACCCCCCCA>BCCCCCCCA@CCCCCCCC@CB?@( +@>?BCCCCBCCC>=BCCCCC@=ACCCCCDDC@B?=@A>BCCDCC@BCCB>?CCCCB>@CCCCBCCDB??=>?  2@?CCDCCCBCCC@>?AAA>ACCCDCCCDCDB>>A-  B>BDDDCCCCCCCB?=>?>BDDCDCDDCDC?>@>;??CDCDCCDDDCCCAACCCDDDCDDCDC?>@>  (B>@BDDCCDDDDDDCCCDCDDCDDDDC@=A; >@>?BDDDDDDDDCCDDDDDDDDDDC@=@>" !C?>ABCDDDDCCCCCDDDDDDDCA?=@A$  -C?>@ABCCCDCCDCCDDDDCB??=@B'   -C?>?@A=@>AABCCCCABA@>>AA&  $BA>=>?@???@AB@???>>?B@ 9C@>>>?>?????????AD9 :DCAA@@@@@@ABCD<" #.49=>=;850' !('  0?@@@@<2 3@A@@@@?@A>( $>AAAAA@AAAB@?.(@@BBAIV]YOFBBA@3 +@@ACNfwykp|o[DB@@2  <7?@BB]ojsOFH\{v`CB@@1  3?@CBOi_zKCCCDcmuNBB@?* :=ACPlekICCCCCDgqmDAB==#>>CFtWbFCBCCCBCFsf`@B>>)"><@Bb[jKBABCCCBBDfZxK@?=:>;=BTc[OCAABCCCB@BLrZp?@<=;6<<@OmZUDCBBBBBCB@BCT`mV>@<<=9,<=?@yYhGCBBBBBABBABCDYSmI>?<;><=>>D{kYCBBBBB@?BBABCCKbQsA=?==0 9=>=>FcWDCBBAAA@?AAABBCDcLvD>>?<>+=?@==GLDCBBA@AAAAA@@ABCCNeqQ>@@?=/>>?@=?CCCBBA@AAAAABA@ABCCD\wb?@B@>? 8=??@>@BBBBBAA@AAAAAAAAABCCC`jBAB?@>8  >=?<>@@BCCBBBBBAAAA@AA@BBBCCHgJ@@?@??$3=?=>?@?ACCBBBBBBBBAABBBBCBBCDWKA?A??>:  ;=???>@??BDCB@@<@BBBBBBB;BBCCCEC@;?>>>>>>@@@@>AA@CBBB< 0AB@>>?>(>??@BB@BBAA@BBBB;%?A@@ABBB@BA>>?A???@>.>@@BCCBAAB8AABCBCCBAABBBBAAA4@@?>@@?>@>-"?ABCCC@@?)@>$$@CCCCC@CCBCDCCCDDUXRT]EDDCCCCCB=@CBC@>?%?ACCCCACBBCDKECDK]\W\[PDDCDCCB?@@CBCC?A"@BCCCB@BCCCGLHA@CCCCA@@ADCC@=BCCCCERNGXngbdk[C@BCCCCC??ACCCCAABCCBACCAA>ACA<@CCCCCCBPZXXDBBCEZXYRCCDCCCC?BCCBCCDB 6?CA?CCCCCBCC@CCCFZUYGDDCACCCCDDDB=CD?> -?@>?CCCCCBCC@CCDCLWRDDCCACCCCDDD@>DC?? A>=@CCCCCCCCCCCCCMQOEDCCBCCCDDCC>AC@?> >>>>ACCCCCCCA?CCCEFFDCC@BCCCDCCB>BA>?75?ABACCCCBCCC=@CCCBCCB>@CCCCCCDC>?>=A% -@@CCCCCC@CBCA>BCCCCC?@BCCBBCDDBB?=A; #??BDCCCCCBCCB?>@BBC@ACCDDCCCDCCC>@= <@@DDCCCCCCCCCC@>>@?BCDDDDCDCDC@?@$  .A>ADDCDCCDDDCCCABCCCDDDCDDCDD@>B/ >@>ACDDDCDDDCCDCCCDDDDCDCCDDA>A; &C>>ACDDDCDDDCCCDDDDDDDCDDCA>@@)  1C>>ACDDDDCCCCCCDDDDDDDDA@>?B0  5C?>@BCCCDDCDDDCDDDDDC@?>@B2 1C@>?@@>>@ABBCCCCCCB@?>BB- &CA>>@@???@@AA??@?>>AD= :C@>>>?>>???????@CA) "@?<95-!-1* .@@@@@-;@?@A@@A>' 8A@@@AAB@AA@2=@@A@BINHC@A@@8>@@BEZhqqrkSCB@@:)-??BBRqctpbgzrmLBA?<)@?BCKmiuWGFFLnklECA?;,?@CNicTEBCCCCDan^DC@>/>>AElYIBBBCCCBCDgjZCB=<===C^VaC@ACCCBBBC_[vHC>?, 9=<@YbVXCAACCCCB@AHlbdB?<>5(=<@G{WkFCBABBBCB@ACV[jS@?<<:*""==@?T~wLCB@ABBABB?ABGfNtE@@=??>I[KCBCBBBA@BB@ABC]^g_?>?==&0>?>@>?BCCBBBAA@@AAABBCEpki@==?=; =?A?>@ABCCBA@AAAAAA?BBBCJnb?=@??>' 9=???ABBBBBAAAAAAAAA@@BBCCGPB>'>>@?ABABBBBB@@@A@AAAA@ABBCBDD=>@@?>/ ;>=>>>@ABBDCCBBAABAAAABBBCCCCBC@@>A@??'*=??>??>?>BCBAABBBABBAAA?BBDCBA@>=???>3 5=?>@A??A>BBBB73@BBBB?@BBAB@>ABA>??>6 ;=@ACCBAB@@?ABB?4%:?AABAABB?B?=@AA?>?>5>?@CCCC@AB8BABCCCCBAABBBCBAA2?@?@BA=??/ @ABCCCA?@%8CCCCCDELOLFCCCCBC<BCCCB?9#@BCCCC@BBBCCDCCDSWOPPN\EDEDCCB>ABCCCC?@ "ABCCCB>ABCCCDCA:^]PLNWdLBDCCCCA@ACCCCA@ ABCCC@?CCCCCDSNB^gXRSciJ>CCCCCC@>ABCCCAABCCA=ACCCCCIhjSN`YNQ^YPc]DCCCCCAACCCBAABCA<>CCCDCCKbdcFCCDCBDgkfICCCCCB@ACCAA@BCACCCBBCCC>BCEEDBDEECC@BCCBCCCC=BD@A =?B??CCCBCBCCACDCDEFEDDDCBCCCBCCDC>CD@A!  4??=@CCCCCBCC@CCCDDLGDDCCBCCCCDDDB?DC?A  )@>=BCCCCCCCCACCCCFJMDDCCCCCCDDDDABD@?@  (@?@?BCCCCCCCAACCDDGHDCC@BCCCDCDB=?@>@/ %@ACA@CCCCCCCB?BCCD@CCC??CCCCCCDA???A< @?BCBCCCCACCC@@CCCBCCA@BCCBBCDDBDB>B( =@@DDCCCCCCBBC@@BCCCA@CCCCCDDDDDD@@=  .B?BDCCDCCBCDCCC@??AACCDDDCCDCDDB?A9A@?BDDCDCCDDDDCCABCCCDDDDDDCDDC??@1 &C??CDDDDCDDDDDCCCCDDDDDDCCDDB@>@?  1C>@CDDDDDDDDCCCDDDDDDDDDDCB@>?B, 3C?>ACDDDDDDCBCDDDDDDDDDB@?>?B6  /D@>@BCDDDDCDEDCDDDDDDB@@>?C7 %AB>>@AA@ABBCCCCCCCB@@>?AC1 =C?>?@@??@AA@??@@?>@BC< 1CB?>>>>??>>???@BDB8#5CDBAAAAAACCD@4# )059:950( %471;@@??@, %?@?@A@@@:6A??@A@A@@@@"<@>A?ADGCA@A?@)<@@ABWflggbI@A>@-:?ABNtdeurrxu`DA?@/ )@?@CQrllgcf\_qoiCB?@,>?CLqbLCCDDCBD\f]DB??:??Dn[RACCCCCCCFboQC??+ 7@=A^\dQDCCCCCCCD`VqEA=?#'><>OuboEDCCCCCCCCTac^C=<>0 <<>@c€zHCCCCCBCCCCFmPtNA><=5 ;=?>:SZFCCBCCBBBCCBCRqfmBAA==;/ 5=??>;<@BBBBBBAABCBBBC^snA??@=?"!>??>>=ABBBBBBAA@ABBBBCCRZ>?>@?<4 :>A@@ABBBCBBAAAAAAAABBBBAA<=>A@??*>@>ABBBBCBA@ABAA@BBA@BBBBBA??A@@=6==@)==@AB@BBCDBB@@@@?@@@A@ABCCBBABB@@?>- 6<>??ABBAACCBBAAAABAABBBCCCBBBAA>@?>5 <=?=?@@@>@BBBABBAABBAAA@BBBAAAA><>?=8$>>>ABA?B@B@A@.#/@BA?>?=7 3=@BCCCBBB=@BB?87:AAAA=:?BA@BBAABA>?=6<>ACCCC@AA8BABCCBBAAABBBBBBB2@@?BCA@>=?@CCCCAAA"6BCCCCDCDFECCCBCBC67AACCCBA@#BCCCCCBCCBCCCCCCDIMQQJDCCCCCCCA?CCCCCA8#@BCCCC@ABBCCCDFGRaXUX\ZFEJDCCB>@CCCCC@@ &@BCCCB?ABCCCCCC=`c^Y[a\WMMDCCCB@@CCCCAA$@BCCC?ACCBCCCKMLkhhdcecY@MIFCCCB@BCCCBA ABCB@>CCCCCCD_gf\i`_acfkh^FCDCCCA@CCDBAABC@=@CCCCCCDabmNCDEDCEqe_JCCCCCC?@BCAA ABC@=BCCCCCCBK\ZbGCCCD^a]YDCCCCCCA<@DBA)B?B>?CCCBBCCC@BDIXKDFWREDBBCCCCDCC>BD@@*A>?=ACCCBCCCCBCDCDJMMGDDDCCCCBCDDC?CC?A#=>>ACCCCCCCCACCCCCCBCCCCCCCCDDDD@@B?A1 >@CB?CCCCCCCCBBCCCCCDCCC@BCCCDDDC?>?>@=?BC@ACCCCCCCB?CCCCBCDCB@CCCCCCD@AB@@< 6AADDBCCCBACCC@BCCCBCCCACCCBBCDDADDA@="D@CDCCCCCCCCCCABCCCCB@CCCCCCDDCDDC@A<  8B@CDDDDCCCCCCCCAAABBCCDDCCDDCDDDB>C, A@BDDDCCCCCDDDCCABCCCDDDDDDCDDDB?@B  'C@BDDDCCDDDDDDCCCDDDDDDDDCDDCB>?D) .C@ADDDDDDDDDDCCDDDDDDDDDDDCA??C6  -D@?BCDDDDDDDBBDDCDDDDDDD@@>>C=  'CA>@BDDDDDCDDDDDDDDDDCA@>?C= ;D??@BBABBCDCCDDDBB@@?>?D9 )AB?>?>???A@@?@@?????BD, 7CB?>>>??>>???@@BCD6 !8BDCCCCCDEECA=6( %)++($ $.-%'?@@?@@.  -@??@@??@97@?@@@?A@@??;?>A@AEFCAA@?@  8?@BBXotom`EA@>@! 0?@BMse[]]WfzYCA??#8??BNubmr‚ŒzilpcDA?=<>BJtZdMFEFFKYjoYD@@0/?$?<=SzsjEDDCCCDDWdVlD=>>;><@d†lEDCCCCCCDEuYrT?<=?% 5=>>>UVCCCDCCCCCCCJ€qtD@=<>#0=>>::=ABBCCCCCCCCCCMumF?@><=#$>>><;:>BBBBCCBBCCCCCACK@?==>@ABBBBBBAABBBCBBA<<<=>A?=2.>@ABBBBBCBBBBBBBBBBBBBBA@?>?A@=7 >?ABBBBBBBBAAABBBBBABBBBBBBAAB@></=?ABABBBCCAAAAAA@AAAAACCBBBBBBA?<,;@BABAAA@BAA@@@AABAAAA@AA@A@?>>=:>=?BCCABBBAA/!/>5?9*>B?AA?AB@>?=<(>@BCCCCBB:AB=699>BA@>('4ABABBBBCA???! 7=BCCCCBC?7BBBBCBBAAABBCCBBB2A@ACCBB>; >@CCCCBBB&4BCCCCCCBCBBCCCCBC04A@CCCCB@#BCCCCCBCCBCCCCCCCFQWWNDDDCCCCC@?CCCCCA6&ACCCCC@ABBCCCHNJJYYXX\SEEFDCCB?@BCCCC@> )@BCCCA@ABBCCCIMA[]ZZYY^OKZJCCCB@ACCCC@@ (@BCCB>ABBCCCEVdXma^[YYa[>\SLCCCBABCCCAA&@BCB?ACCCCCCD^pupa\\X[gxjcGDDDCCB?CCCB@ %@BC@?BCCCCCCC_`oSDCEDCEho`VDDDCCC@?ACA@*"@AB?>CCCCCCCBK^cfHCCCCYed_TDCCDDCBACCDCCCCCACESgQDF\_LJHCCCDCDDC?BC@@'#@>>>BCCCCCCCCCCDDI_]`UEDDCBCCCCDDD?CC?@ +?>>=CCCCCCCCCACCCDFOMDDDCBCCCCCDDC>C@A4  0@AA?CCCCCCCCCBCCCCCCCBCCCBCCCCDDD@=?>A0 +@ADAACDCCCCCCABCCCDCDDCCABCCCCDDD????@5B?CCACCCCCCCCBACCCCCDDDCACCCDCDDA@CC@A7;ACDC@CCCBACCCABCCCBCDCBCCCBCCDC@CDCAB/)C@CDCCCCCCCCCCBCCCCDCBCCCCBCDDBCDDC@C,% ">ACDDDCDCCCCDDCCBCCCCDCCDCCDDCCDDC@C<3$ #5A@CDDDCCCCCDDDCC@BDCDDDDDDDCCDDC@AC84 1=A@CDDDCCDDDDDCDBDDDDDDDDDDDDDC?@C<8/$ $8>@@BDDDDDDDDDDCBDDDDDDDCDDDCB@@C=86*& +9?@?@CDDDDDDDDBBDDCDDDDDDDCA?@D:56.')7>B??ACDDDDCDDDDDDDDDDDCB@?AD6.1,# /9AB??@AB@AACCCBCDCCBA@?>BC/#&$  &5BC@>>>?>@@@@@?@?@?>@D>"   -?DB??>?>>>?????ACC0  !4?DDEEEEEDDDD?-    ! $;@@@?;#*@??@@@?@4 5@>?@@AA??@< 7?>@@BHKDA@??>,??BGdxq{qcEA??=>>BPzd[ZmX`uWC@?7 9?@O|`s|Ž’€\Xr]C?@);@?EasrSKM[sq^zOB?=>=?^†kFDDDEGhvZxD>?6 8=;.><>>MIBCCCDDDDDFy€lD><=<%>==;=BBCCCCCDDCCBBkfF?><<9==><;?BBCCCCCCCCCCB@DA;=?<;5 9=><=@@?>@?BCCCCCCCCCCCBB@=<;<=@=@2=?BBBBBBBCCBCGLNIGCBCBAAA@@AA>>1>@BBBBBBCCBDEKNMMLECCCBBABBBB?<$<=ABABBBABBDEBBAABCFHCCBBBBBAB@<(  >>@BBBBA@A@B@@?@@@AADCBBABBBBB@>/  7=?>@AA@@@@C@?=5>?ABAAA@@CB@;70/>AA<>AEA@@@????=< ;=ABCCCBAAAB 4?<8$2>HAABA@@?>?>-?@CCCCCBA5BC3,;=8<=@=.-+BDAABBBCBA??,?CCCCBBB;2BBBBBB?AAABBBBCDB2ABBCCCB>=  :@CCCCCBB,2BCCBCCCBBBBCCCCBB,6BACCCCBA!BCCCCCBBCCCCDCCCCERXYREDDCCCCC@@BCCCCA0%BCCCCCAABABCDJGDDVURRWTDDDCCCB>?BCCCCA:*@BCCC@>?BBCCIYT?Pe^ZY]`HDHHDCBA@BCBCC@@  *@BCCA>ABCCCCJPZIdjb[[`fR8HJHCCCBABCCCAA (@CC@?ACCCBCCE_reY\\[[\`RIGDDCCCCC@ABCB@* )@BC>?CCCCCCCIamxMDDEDDDNb]VDCDDCCA=ACA@/ ,@@@>@CCCCCCCCXegYECCCCMamkfHCCCCCC>BCA@* 4?>>?BCCCCCCCCBFHS^HCCOfQRWJCCCDDDC?BC?@<>>>?CCCCCCCCCCCDCL^TU]GDDDBCCCCDCCABB@;??@??CCCCCCCCCBCDDDKYYHDDDCCCCCCDDC>@>@=) <@CB@CCCCCCCCCBCCCCFONDCCCBCCCCCCDC=>>@@21ABDABCCCCCCCCACCCCEEEDCCBBCCCCCDD@?BBAA6. ,BBDCACCCCCBCCBBCCCCCCDCCBCCCCCDDC?BCCAB<:   2AACDBACCCC@CCCBCCCCCCDDCCCCBCCCC@ACCCBB?;*  8?ACDDCBCCCCCCCCCCCCCDCBBCCBACCCAACDCBB@>;6$ 6?@BDDDCCCCCCCCCCCCCCCCDDCCCCCCCBCDCAA@??>;& ,@@?CDDDDCCCCCCDDDCBBDDDDDDCCCCCCDDB@A@?>>;% !9A??BDDDDDCCCCDDDDBCDDDDDDCCCDDCDB@A@??>>7#  -?@>>ACDDDDDDDDDCCACDDDDDCCDDDDDB@@@??>>>1 2A?>>@ACDDDDDDDDBBDCDDDDDDDDCBA?A@???>?8*  5A@?>?@ABCDDCBDEDDCDDDDDDCB@?@A@@???>:0  4@AA??>?@A@?A@CCBBABBCBB@>?BB@????>96,  *9@BBA??>>>>>??@@@@@@?>?BD?>???=81/% #1:?BCCA?>>>>?>>>>??BD;01231-&!(  '.4>>?@A@??@1 )?=>@CGICA?>@6 @/ 1>BU‚l[XgXd]B??"=>N€tuƒŠe[VB@8&<=>fƒnTKM^~{oI@?+;><>>HDBCCDDDDE\ujC<<>2 =<>=BCBBBCCCCCCBOZ@?><=/:>>><=) 1>>=;?BCCBCCCCCCBBBB?><>=<<%?>=;=@BCCCCCCBCCBBCCA<;<>><6 @BCCCCDEDCCCBCB@=;;=?=<*0>ABBBAAABBCIU^`[RDBBA?@@@AA?=< ;?ABBBBA?ADMRQHFJVRIB@@AABBBA9!!=>ABBBB?@CLMDB@@ADNRGA?ABBBBA=$ 6>?@BBBA@AGHA??@@@@@JKC@@ABBBB>2 .>???@@>=?CH?80(0:5:>=IE@=@@A@@>:>>@ACBA@?AF;?><36?@;28BD?@A>==>>>26>ACCCCCBBA< 6<751:@8?4.3ABA@A@@?>0>@CCCCCB@0BA+!+0';?<"*8A>BBCBCB??"%?CCCCCBB5.ABBBA@:=>@BBBLLD?U^YVUWVLDDDCCBA@BCBBC@A /?BCB@?@BCCCBFDG;U^YTSUZS6CCCCCCBABCCC@@# 3?BC>?BCCCCCCD\jZI\ZTTW_OCJEDCCCCC@?BBA?+9?@@=ACCCCCCCHbmvQEFEEFGF^_SECCCCCC=ACA?&>>=<>BCCCCCCCD]ji^DBBBBG`mf^HCCCCCC?BCA@!B>=>?CCCCCCCCBAHGMSEBBFVMLTLCCCCCCC@BC?@- B?>=@CCCCCCCCBBCDCGPHJOEDDDBCCCCCCCA@A>@?A4. (=BCBBCCCCCCCCCBCCCCJVTGDCCBCCCCCDCC?>@A@B@8! 5>ACCBCCCBCCCCCBCCCCIOOHCCBACCCCCCDC?ACCBBA<0& !@ACDCBACCCCACCCCCCDCACCDCCCCBCCCCB@BCCCB????3,' +<@ACDDCAACCCBCCCCCCCCCCCCBCCCBCCCA?BCDCBA??>?81,% *;@?BDDDCCCCCCCCCCCCCCCCCDDCCCCCCCACCDCBAA?>>@91,$ '9@??BCDDCCCCCCCCCCCCBCCDDDDDCCCBCCDDDCAA@?=>@83,"  5?@>>ACCDDDCCCCCDDDCACDDDDDCCCCCDDDDCB@@>==>@81' -=@>=>?ABDDDDCCCCCCBACDDDDDDCCDCDDDB@??>>=>?>7.!6?@>=>?@ACCDDDDCDDCBDCDDDDDDDDDCCA@?>===>>@;1'8@@>>>?@ABCCCCBBDEDDCCDDDDDCCBA????>===>@=1!  )9@@>=>>?@AAA??A@BBA@?ABBBB@??>>>===>>>AA8)  &3=BA@>=>>>?>>?=>?????@@?>>>??>==>>?@A=4- (1>>>>>>>>=>???ABAA@@@AABA?6*!  %2=BCCCBBAA@@@@@@BDB<:?BB@@>:55/%  !+279;=?ACCCC@7,(*/32.++&         )38992 -;>?@@??=24>?@ABA@???<(=?DVdijfXE?>74>D]qy{ƒvL?>) ,=?Oefbmsoy„oE?;0>:!+><>?CCCCCCCDLXQC<<> ;==>BCBCCCCCCCEF??<==-=<=ACBBCCCCCCCCB@=BBBBBCBBBCCCBB><><<89=>==ABBBBBBBBCCCBB?<=?;<- 5===;=ABBBA@@@ABBBBA>;=?<<@?????BDECA@@@?=:;>?;:(9??@@?@?==?GTSTUOB@=====@A=:2<@ABB@@=>DLJD@?AHJGA>??AAB?>;*>>ABB@>>CIGC@==>AEHDA>?ABBA?3-@>?@A@==ACC@==???=?CEB@>>@AA?6)>?@?@@><>AA><<>=@;==?>?- >>ABCBB???59?@;55<>==:*2?@==>@>>6 +?ACCCBBAAA' .- +=;?A@BBAA?>4 96437>ABAAAB/>BBBBBB@4 ;@CCCBBBB33BBCBCCCCCCCBCBDCB(2BABBBBB@AACCCBBCCBBBCCCCCELRSKEDCCCCBB@@BBBBCA( (BCCCCB@BAABBCCCCHSNMMMKFCCCCCB?>ABBBBA=  2BCCCB>=?@BBBDCCBWZTOMPYTFFECCCB@BBBBB@A 9?BCB@>@BCCCBCCD:_cYTTU^\>CCCCCCBABBBB??">>@A>@BCCCCCCCO`YSne]_be^DGFDCCCCCA?BC@@@>==ACA@$!A>=?A@CCCCBCCCBEIIP\FBCJj^UZMBBCCCCCA@B?>@32 (B@@?ACCCCCCCCBCDDDH[SQ[IDCDBCCCCCCCB=>==?>=+9ACCACCCCCCCCCCCCCCDDJJEDCCCBCCCCCCCC=<>@AA@81' /?ACCACCCCCCBCCBBCCBBDHFDCCCCCCCCCCCCB>?BCCB@=:50*" %9@ACCCBCCCCCCCCCBCCCCFJIGBCB@CCCCCCCCA>BCCCB@?>::6.#  1=?ACDCBCCCCCCCCCCCCCCDDDCDCCCCCCCCCCC@@CCCCA??>=;95,#7>?ACCCCABCCCCBCCCCCCCCACCCCBCCCCCCCC@@CCCCBB@@?>><92# )9??@CCCCC@ACCCBCCCCCCCCCCCCBCCCCCCCA?ABCCCCCBA?>>>=:5& +:?>>ACCCCCABCCCCCCCCCCCCCCCCCCCCCCB?CCCCDCCCA@>=>==94$ (8?>>>ACCCCCCCCCCCCCCCCCCCCCDCCCCCBACDDCCCCCB@>==>>=91 %5>>>>>@BCCCCCCCCCCCDCCACDDDCCCCCCCDDDDDCCBA??>==>=<6& /=>?@ABCCCCCCCCCCCA@BCDDDCCDDDCDDDDCBA??>>==>><8* &5>?=<>?>BBCCCCDCCCCCCBDCCCDDDDDDDCCCBA?>=>?===?=6)  *:??=<>=?@BCCCCCBBCDDDDCBCDDCDCCCCBAA?>==>>==?=7,,;@?>==>>?AAA@@@@A@BA@@?ABABBBAA@@@@??==<=>??:+-:@@?>====>?@?>>><=?????@?>??>?>>>>=?===>@@;1!  (6=?@@?>==>>=====>=>>>=>>>>>=<=====>>?@@=5(  -5;=?AA@>>>>>>=>>=>>>????>>>>>??@@@@>8-  "+.28@BBBAAAAAAABBBA?AAAAABBAA>:73+  (-05::;<;<<;:9;<==?<9854.("  '+$#(1.--*(#        #*/20)'6;=>>=;927?BCDEDB@>1.=BEGHJLKF@:$0>?BCBAADHIC>84==?BBA<>BCED>=>,  +=<>BBBA=?BCCB>>;>1 #$;<=ABBBA??BCBB@=>;>-"8==?BBBB@>?BBBBB>>=<<&+=<>@BBBA?>>@BBBA@>><=9:=>=>AAA@=<<=@@@@?=>><<, 6====@>>><;;<<==>==<=><8, +==>>>=;<<=?@B@@?>==<=>>7'6>=>>>=<>ABECBDCCB@=<<=?=/ 8??@>==?BCFC>>?ADFC@=<>@?:&+ :=?@?=AEEB@=>@@=:-*?=?@?===ABB?===>><=@CDA>>@@A@?>@A??>?AABA@==>?@?<<>?7$$3>=2!>=>?@A==9 @BBBBBBA=A# -+ =>"# @>==@CCCCCCBBMjfhaDCCCBEdncXDBCCCCCA?C@>?;<+2A>?@BCCCCCCBBEWc^]]DCCGbec^VCBCCCCCC?@=<=??;,$  +?BBA@CCCCCBBCCCDEEET`SScUFEHDBBCCCCCC?<<=?@@?=;,%" !BBBB@?><;96- %8@ACCCACCCCCCCCCBBCCBCCNKCCCCBCCCBCCCCCA?====7) 4>?ACCCBCCCCCCBCCCCCCBCCFEBACBACCCCCCCCC?>CCCBB@@@?>>=<2 +<>@ACCCCBCCCCCCCCCCCCCCDCDCCCCCCCCCCCCCB?BCCCBBBBA@?>>=:+4>>@ACCCCBACCCCCBCCCCCCCCACCCCBCCCCCCCCB@ACCCCCCCBAA?>==< &19>=?@CCCCCB@ACCCCCCCBCCCCACCCCCCCCCCCB?@CCCCCCCCCCA@?>==< (4<>=>>@CCCCCCABCBCCCCCCCCCCCCCCCDCCCCA>ACCCCCCCCCCBA@><==;%1;>==>?ABCCCCCCCCCCCCCCCCCCCCCCCCCCCBBCCCCCCCCCCBBA@?>===9*9>===>ABCBCCCCCCCCCCCCCBBBCDDCCCCCCCCCCCDCCCCCCBA@?>===;/ (4=>===?ABCCCCCCCCCCCCCC@@ACCCCCCDDCCCCDCCCCCCCBB@?>==><0,9?=<<=>@BCCCCCCCCCCCCCCCCCCCCDDDDDCCCCCCBBCCBA@?===><1#  .:?=<<<<>@BCCCCCCBBBCCDDCCCCDDDDCCCCCCCBBBBBA@>==>?=2$  "1====;>@ABBA???@@@A@@@?@ABCCCCCCBBBBAAA??==<>?<1!  #0<@?=====>>>????>>><?@?@?>?@AAAAAA@@@>====>@=4(  !.;@@>======>???>==>>>=>=>>??>??>?>>>>>====>?@9.$  )3>>==============>=>>==<==<=====>?@@=2%   )2:@AAAA@?>>=>>=======>=======>>>?@@A@=6*   (027<:8550.)!!  !$$&()%#    $29<=;5,  $8?@@@@@=11>>>?@>????9 3==>??<=@@?==>2 *<=>?@@;;?AA?=<=3 "9<=?@A?<;>ABA>=;=. 8=<>@A?;:;=?AA?>=<;& 7><=?@?<;:;<=>??>><;3 ?==>@??=;::;<<<==>>9/ /=<=?>>?<;<<=>=<<=>?8% %7=<>><<>@BABBBB?=<>?=.(7=>><<@BCHF@ADGCB>=?=;)  $8<>?=<@BCJF>=>?JNCB=>?>3 <>>?@>>?BCGC=<=<<=KMCA=??=3#1>??>>==EJB>=@==@,;>ABBBA?ABFB=>?>A@?><>DE@==>?=>6 0?ABBBBB@A;"1=0 6<,4A?AAAB?>6@BBBBBB@>@%, (%=@ABCBBA?' ;ABBBBBA??A7 , (=-=5=BBBBBA?$@BCBBBBA.@IFA<=@<5:@AAACFB,9BBBBBB@2;@CBBBBBB;5AECBBCBCCBCCBBFMB+-BBBBBBA@@BBBBBBBB@BBCCCCCDCEGCDCCCCCBB@AABBBB?.,@BBBBBBB?@ABCBGECJVYWYIDDDCCCB??>BBBB@9 :BBBB?A?@BBB@ADPRU`XSQR[KFJLCBBBA>@BBB@<  ?@??@>=@BBCBBDIM=baZXXXY^IQOCCCCCA?@CC@?# <><<;?CA>?>?7# $7?=<=BCCCCCBBB[gmsVCCCCCCQlfZFBBCCCCB>@><<==>:4%  7@A>=>CCCCCCBBBPipodMCCCCO`ke`GBCCCCCC@=<<<=?@@@:1/-)% !/?BCB?ACCCCCCBBCCHHEH`QEET^MLRIBBBCCCCCB=<=@BBA@?>>??=9!(5?@BCC@@CCCCCBCCCCCDDDF\Y\YEDDDCCCCCCCCCC><@BBBBA?>>??@?+/5>?ACCCAACCCCCCCCCBCCCCDG]\ECDCBCCCBCCCCCC?>BCCCBAAAA@@@@-58=>@BCCCCBCCCCCCBCCCBCCCCHVUCACBBCCCCCCCCCB>@CCBBCBBBBBA@@&19>>>@BCCCCBBCCCCCCCCCCCCCCHHKCCCCCCCCCCBCCCA?ACCCCCCBBBBA@? +6<>>>@BCCCCC@BCCBBCBCCCCCCCDADCCCCCCCCCCCCCAACCCCCCCCCCCBA@? .8==>>@BCCCCCCABBCCCCCCCCCCCB?CCCCCCCCCCCCB@ACCCCCCCCCCCBBA@> ,8>>=>@BCCCCCCBA?BBCCCCCCBCCCBCCCCCCCCCCB@BCCCCCCCCCCCCCCB@?<+7>=<>?ABCCCCCCCBBCCBCCCCCBCBCCCCCCCCCCCCCCCCCCCCCCCCCCCBA@=='5<>=<>@ACCCCCCCCCCCCCCCCCCBBBBCCCCCCCCCCCCCCCCCCCCCCCCBA@==> 08>=<<>@ACCCCCCCCCCCCCCCCC?A?CCCCCCCCCCCCCCCCCCCCCCCCBA?=<>= %4;><<<>?ABCCCCCCCCCCCDCCCCCCCCCCCDDDDCCCCCCCCCCCCCCBA><<>=6 )5<><<<=>@BBCCCCCCCBBBCCCCCCCCCCCDDDDCCCCCCCCCCCCBA?=<<>>6)+6=>=<==??@@BBCCCA@???>>@@?@@@BCCCCCCCCCCCCCCCBA@>=<=>>5',7=?=<<=>=<=>>?@@??>>>>>?>>>?>@@ABCCCCCCBBBBA@>====??9+ -8>?>=<<===>>>>==>=====>>>>=>??=?@@AAA@@@@?>==<=?@?5) )7=<===<<=====<========>>>>=====>>>>=<===?@?:1' #.8=?A@?>===<=<==<============<<<<<<<<===>?@@<3( !.49=ABAAAAA@@????>>>===========>>??@?AA@<6,  ")-04<=?=>@ABCCDDDCBBBCCCCCCCBBA@@><81'  $!$!'+++'2279::500224430.,-($   %2785+  $6<=====;0(9;;<==<<<<:) 7;;==<==<<<;:*2;<<>=;<>><<;;8& *:;<>=;::=?><;;:4(8<<=><;;;<>>=<;93 <8<<=??<;;;==>=<;:+  0=<=??>=<<=??>>><;33>=>>>?BBABBCBA>>=<'  6?>>=ABCDGCBKFCB???8 ':=>>?=ABCEF?>>>IICB?@>9! 8=?@BCFG?>??>?MHCA>A<>8") 8>?@@>>?BCFE>?@?=@>?FGB?=?==;&.%.>>?IIA=>??>?1 /@BBBBBB@ADB8>96< (KCABBBBA?1@BCBBBB@A?<' <:(;# 9B?ABBBBB@& BBBBBB?(?BBBBBB@1@MHA>ABA?ABAA@DSB"3BBBBBB@4 =ABBBBBBB<4@CBBBBBBCCCBBBDKB%+BBBBBBA@@ABBBABBB@ABCBCCCDCEFCCCCCCCBA@AABBBA@%+@ABBBBA@@@BBCCCCCIWXWXKDDDCCBA?@=BBBB@44ABBB?A?ABBBABFIGG]YTQRZFDDECBCBA>>BCBA? 3@@@@??BBCCCBBIK:Wa`[ZZ]UDFICBCCCB>?CCB@:15(  7?<<=?ACCCCBBCHFBYb_[Y\`_ACB?@?@=2(+:?=<=?CCCCCCBBD[^RGQUUUY[KDJGCBCCCCB?=@?<<<;3  -=>=<<=BCCCCCCCBK\gwXCCDCDDGb`VDBBCCCCB>=<;<;;6220/ #,:@BA=<@CCCCCCBBBJejfcFCCBBF_hd]FBBBCCCCB<;;<=@AA@?>>=== '07BCCCCCBBBCBKJDISHCCHOLJLHBBBBCCCCC?<=>BBBBA?>>>?? #39<=?ABCCB?BCCCCCCBCCBCDDDFRKKKDDDDBCCCCCCCCCB<?ABCCCB?BCCCCCBCCCBCCCDCESQDCDCBCCCBCCCCCCB=?BCBBBBBBBBBB#6;>>=@ABCCCCABCCCCCCBCCCCCCCBJXVCACBBCCCBCCCCCCA=ABCBBBBBCCBBB,9=>>?@BCCCCCBACCCCCCCCCCCCCCCTKXHCCCCCCCCCBCCCB??BCCCCCBCCBBBB/;=>?@ABCCCCCCBBCCCBCBCCCCCCCCKBPDCCCCCCCCCCCCB@ABCBCCCCCCCBBCB1<==?@BBCCCCCCCBABBBBCBCCCCCCCB@CCCCCCCCCCCCCBABCCCCCCCCCBCCCBB0;==>@ABCCCCCCCB??@BCCCCCCCCCCBACCCCCCCCCCC@ABCCCCCCCCCCCCCCCBA,9<==?ABCCCCCCCCCBBBCCCCCCCCCCBBCCCCCCCCCCBBBCCCCCCCCCCCCCCCBBA%7<=<=?ABCCCCCCCBBCCBBCCCCCCACBBACCCCCCCCCCCCCCCCCCCCCCCCCCCBA?3;=<<=?ABCCCCBBBBCCCCCCCCCBBAA@ABCCCCCCCCCCCCCCCCCCCCCCBCBB@>< *9<=<<>?ABCCCCCBBCCCCCCCCCBCCCCCCCCCCCCCCCCCCCCCCCCBCCCCBA?=<=2;<<<==?ABCCCCCCCCCCCCCCCCBBCCCCCCCCCCCCCCCCCCCCCCCCCCBA><<== %4:=<<<=?ABBBBBCCCCCC@@@>=>???@@AACCCCCCCCCCCCCCCCCCBA?><<==9 #3;==<==>@AAAAABBBB@>>?>>>?=>==>=>>BCCCCCCCCCCCCBBA@>=<<=>;- 1;==<<<=>??=????>=<=====>>>>==?@>=@ABBBBBBBBBA@?>==<=>>:.1;>>===<=><========<===========>=>>>??@?????>>=<<=>?>9+,8>?>>===<<<=<<<<<<<<==<<<====<=<<<==>>>=====<=>?>;1$  "09=@@?>>==<============<<<=<<<<<<<<<==>==<=>@?<3%  *17>?>>>???@?<6(  #*014<:;<<999887:<>?@@>?@AABBAA@@@?>=7/#   +01/& (3789873'%38;;;;;94( 18;;;;;;;82#,7;;;;:;;;:5( '5:<<<<;<<>=8) &/6;==<<=>>><8.5-6==>@@@@>5 6:??@@BBABCCCB@>6 #;A>>?BCCCDHIGCCB@>;):>>>??BCCCEC@@AFDCB@?>=+ (==?@=>?BCDHE@??@EMDBA>@==*%>ACHDB>?$ )@@BFDA>A@A?@/ 2@BBBBBB?AEL>;@:#@:7LCABBBBB@2#@BCBBBB@@>FO"?A5 =A%MC;ABBBBB@-=BCCBBBAAAAIM*8AA1:BA'%TC?@ABBBBB?*?BBBBBBA4@GGBAAAABBBABAGVB%5BBBBBB@23ABCBBBBBBBBBBBBE@*2BBBBBBA?@BBBBABBB@@BCCBCCCDFEDCCCCBBB@?@ABBBB?+ @ABB@@??@ABBCCCCDJWZZXKDDCCCC@?@>ABCB@> "@ABB@??BBBBABDCDHPSQQRSECCCBBBBB>>@CCB@677-  .A@A@?@BCCBBABCB?WSPNLMPSDCCBABBBB?=ABBA@???;2 .<>?<=>?BCCCCCBCC@>ZXPNMNS^>@BBBCCCC@>@BA===<>??;$  5>>=<<=?BCCCCCBBDVTKNYURRU]VBHICBCCCBA?<==;;;<<=??;1.-- !(0:?@?=<<>BCCCCCCCBDT_uODDEEFHIe]RBBBACCBC@<;;;;<=>@@====< '08<==?AB@;=ABBCCCBBBBLXYffECBBBHhl\TBBBBCCCBB=;::<@BBAA?>==='/8===>@ABBB>=BBCCBBBBBBESUOU`GBCKiYTOFBBBBCBBBBA=;=?BBBBBA@AAA+5<=>>?ABBBBB??BBCCCCCBBCBCCDEPaXY`MFDCABBBBCCCCCB=;>ABBBBBBBBBB4<>???ABBBBCC@?CBBCCCBBCCCCCCCCITQGDDCBBCCCCCCCCCC><@BBBBBBBBBBB9=>@AABBBCCBBA@CCCCCBBCCCCCCCBBBMHCBBCBCCCCCCCCCCB>>BCBBBBCCCBBB;=?ABBBBBCCCBBABCCCCBBBCCCCCCCCKHIFCCCCCCCCCCCCCCA=@BCCCCCBCCBBB;=?ABBBCCBBCCCBABCCCCCCCCCCCCCDFDIECCCCCCCCCBCCCBABBBCCCCCCBBCCB;?ABBCCCCCBCCBBABBBBCCCCCCCCCCBCDCCCCCCCCCBBBBCCCCCBBCCCCCCBBB;;=>@BBCCCCCCCCCBBA@ACBCCCCCCCCBACCCCCCCCCCA?@ABCCCCCBBBCBBCBBBC;;==>@BBCCCCCCCCCBBBAABCCCCCCBCBBBCCCCCCCCB@BBCCCCCCCCCCCBBBCBCB9<<=>?ABBCCCCCCCCCCBCCCCCCCCCABCA@BCCCCCBBBCCCCCCCCCCBCCCBCCCCBA1;=<<=@ABCCCCCCCCCCCCCCCCCCCBCCDCCBCCDCBBCCCCCCCCCCCCBCCCCCCBB@?'5<<<<>?ABCCCCCCCCCCCCCCCCCBBA@ABCCCCCCBCCCCCCCCCCCCCCCCCCCBA?>=,7=<<<=?@BBCCCCCCCCCCCCB@>>?>>>>>>@@ACCCCCCCCCCCCCCBCCCCCB@?==<#+8=<<<=>ABBCBCCCCCCCBB@==>>>?>?==<;=>ACCCCCCCCCCCCCCCCBA@>=;>>  )5<=<<=>@ABBBBBBBBA><<=>=>=><>>>>>>>=@BCCCCCCCCCCCBBA?>=<<=?9 "1=>=<<>>??@@?@@>>=<=<<<<==>=>===>><=>?@AABBBBBA@?>><<<=>?:* ,;?=<<<<=>><====<<<;<<<<<=<<<==<<<<==>??@?>?>===<<<=>?>4% '6>?>=<<<<<<=<<<<<<<<<<=<<<<<=<<<<<=====>====<=<=>??9-   +7=@@@?>=====<===>>???@???>>>==<<<=<=<==<<===>?@:/"  &.58=?AAAAAAAABBBBA@?@ABCCCBBA@@???>>>>>?@@?:1"    !%%#  "*--+'  ",2554/))046651,$$/69;;:4' + 1;>>=??@@@6 39@?AABBABBCCBA>.6@>>ABCCCBIQECCB@??2 +=???@BCCBCDBBDDCCB@?=?, !<@@A??ACCCFG@:0@FICCB>?>>9 4@BBBBB?BBCFEB@ >BEEBC?=@@?@D  8ACCCBBBAACEEAA: 8AAEECAABBBA@4 4ACCBCBB?ABGB8@A06@;2CFBABBBBBA9 %@BCCBBBAA@CN=(?B>1BA) 1IA<@BBBBB@0=ACCBBBAAABFRA6@AAABBB4 COA@AABBBBB?&@BCBBBBA7 BCDBBBAABBAABBIMA%7BBBBBB@58ABBBBBBB?4BCCCCBBBBBBBBBBC@5;BABBBBA@ >BBBA@BB@??BCCBBCCCCCCCCBBBBA@??@BCBB?8>@BB@@??@BBBCCCCDEGJKHEDDCCCB@@?>@BCCA@5981'  %@@BCB?@BBBBABCBCGQOMMOLEDDDBABBBA>?BCB@?>>?>8+.;?@=??@ACBBB@@ACEKSYTRQRXQHFCABABBC@>?BB@=<;=>??. %:?>=<<<=?BCCBBBDDC>FYXXWVUYXHABBBBCCCA?>??<;::;<=>>/'#"!##%,5>?><<;<=?ACCBBBBFPPK\ha\^[\dgNDKJDBBBBA><<;::::;:====)269;===>@@?>;;=ABBBBBBBBE\evUHFJKKR^l\PBBBBBBAB?<;;::;=?@?>==<;:==>@ABA>;>ABBBBBBBBBX`ktWBBBBBChxfUBABBBBBBB=;;:;=ABBBA@????@@??@AABBBB?<=BBBBBBBBBBOYcbbOCBBF]gh[QCBBBBBBBBA<;;<@BBBBBBBAB@@@@ABBBBBBB@=@BBBCCBBBBBCEGHPaYLNd`PNHBBBBBCCCCCB?;<>BBBBBBBBBB@@ABBBBBBBBBABCCBCBBBBCCCCCCCCFcWCDCBBCCCCCCCCCCC@<>ABBBBBBBBBB@ABBBBBBBBBBB@ACCCCCBBBCCCCCCCBAWLBCCCCCCCBBCCCCBB><@BCBBBBBBBBB?ABBBBBBBBBBBBABBBCBBBCCCCCCCCCDUKCCCCCCCCCCBCCCCB@ABBCCBBBBBBBB?ABCBCBBBBBBBB@@BBCBBCCCCCCCCCCINHDCCCCCCCCCACCCBA@BCBBBBBBBBBBB>@BBCCCCBBBBBBBAABBBBBBBBCCCCCCIIECCCCCCCCCBBCCBAABCCBBBBBBBBBBB>?ABBBCBCCBCCBBBBAA@ABBBCCCBCCCDDDCCCCCCCCCAAA@@BCCCCBBBBBBBBBBB=?@BBBBBCCCCCCCCBBB@@BBCCCCCCCCBCCCCDCCCCCB>>@BCBBCCCBBBBBBBBBBB=>?ABBBBCCCCCCCCBBBCBBBCCCCCCABDABBCCCCCC@>@BCCCBCCCCCBBBBCBBBBB==?@ABBBCCBCBCCCCCCCCCCCCCCCCCCCCCCCCDCCBBCCCCCCCCCCCCCBBBBBBCBC><=>@ABBBBCCCCCCCCCCCCCCCCCCB@?@@BCDDCCCCCCCCCCCCCCCCCCCBBBBBBBA=><<>@ABCCCCCCCCCCCCCCBBB@>=?==>===??ABCCCCCCCCCCCCCCBCBBCBCBBA?6>><<>?@BCCCCCCCCCCCCCBA><<=>>>>>==<<<>ACCCCCCCCCCCCCCCCCCCBA?><+7=><<=>@ABCCCCCCCCCCCA>======>=>==>=<<>ACCCCCCCCCCCCCCCCBA@>=<<'28==;<=?AABBCBBBBBB@=<<<<<<===<==<==><>@AABCCCCCCCCBBA@>=<<<>? (1:=<<<>?@AAAA@@?>=<<<<<<<<<=<<<>===<<>=>?@ABBAAA@?>=<<;<=>=5 *5>><<<===>><====<<<<<<<<=<<<;<<<<=<<=>>>>>====<<<<<<<>?==<<<==<<<<<;<<<==>=>>>=<<<<<==========<=<<<==>@>6(  (4:>@@@?>=====<<=>?@BBCCBCCBA@>==<<<<<<<<<<<<<>?@>7+   %,-)  &4<>>???@=-CA??@ABBBBCBA@@4 9??@BCCCBGPDCCA@??.*;?A@@BCCBBDGHFCCCB@?=<#+?ABBBABCCCDGC>4BFDBCA>???8 8ACCCCCABBCDGD@/$>BGCBB?@ABAA=7 9ACBCCCBBBCCGCAA ?BCGDB?BCCBB@;5ACCCCBBABACEBAA@?A@CFBB@BBBBCA<$?BCCBBA@BCAHK:@DC.-CC80DB@@@BBBBB@4 ACCBBDD>9SF>AAAABBBB@  @BCBCBBA: BCCCBBBBBBBBBCOF@"7BBBBBB@< 2ABBBBBBB@6BDCBCBBBBBBBBBCBA5ACCBA?6774+ >@BCCB??ABBBCCBCDDFLKFDDDCCCBA@@>=ACCBA?==?>;0+8<@>@BA@@BBBBBFJEDDOUSRVKEDDECCBBBB?>@BBA=<=<=??4  %9>?>=<<=@ACCBBAAAGOMQURRPQWJHPFABBBBCB?=?@?<;;===<;<<;<@BBBBBBDDE;O[VVVUSTYLCCAABBBBB?=<<;:::<;;=>=;;:9;;;;<==>?<<<;<<>ABBBBBAGNPIhr^VUTT^hWFLNFBBBBA><<<;::;::;=>>>==<>>====>@A@>?<<=ABBBBBBABITTk`QLQRP[qlSGBAABBB@A?;;;:;=;?A@?==<<@@@@@@AABBB?=<=ABBBBBAAAFZaldGBCCCBCXlgZEBBBABAAA=;;:<>>ABAAA@?@AAAABBBBBAB@;;=BBBBBBBBAEZelgWCAAAANisj`HAABBBBBBA<;:<<@BBBBBAABABBBBBBBBBBA=;ABBBBBBBBBADJQR_^HBBNeZ^VHABBBCCCCBB?:;;>ABBBBBBBABBBBBBBBBBBA=?ABBBBBBBABBBBBBBBBBBAABBBBBBBBABBBBBBBBBBBBA@BBBBCBBBCCCCCCCCCD]PACCCCCCBCBBCCCCC@<>@AAAABBBBBBBCBBCBBBBBBBBA?BCBCABCCCBCCCCCDK[RCCCCCCCCCCACCCCB@>@BABABBBBBBBBBBBBBBBBBBBBBAABCCABBBBBBCCCCCSVMCCCCCCCCCB@CCCBAABBBBBBBBBBBBBBBBBBBBBBCCCCBBBBBB@ABBBCCCBCCBNKFCCCCCCCCCAACBBBBBCCBBBBBBBBBBBBBBBBBBBBBBBCCBBBBA=?BBCCCCCCCBBBCCBCCCCCCC??BCCBCCCBBBBBBBBBBBBBBBCBBBBBBBBBCCBBBBAABBCCCCCBABEABCCCCCCCB@?BCCCCCBCCCBBBBBBBBBBABBBBBBBBBBBCCCCCBBBBCCCCCCCCCCCCCCCCCCCCAACCCCCCCCCCCCBBBCBBCCB?ABBCBBBBBBBBCCCCBBCCCCCCCCCB?>?>ACCCDCCCCCCCCCCCCCCCCCBBBBBBBBC=?@ABBCCCCCCCCCCCCCCCBBBBA?=><=><<>@BCCCBCCCCCCCCCCCCCCCBBBBBBBB==>?ABCCCCCCCCCCBCCCCCCA>=<>=>=<<=??A@BBCCCCCCCCCCCBBBBCCBBBA==<<>@BBCCCCCCCCCCCCCCCA=<=<==>>==<==;=?BCCCCCCCCBBCBCCBCCCBBA?=9==<<>>ABBCCCCCCCCCCCCBBA?><;<&5;<<<<=?ABBBBBCCCBBA?==<<<<<=<<<<====>==>?ABBBBCCCBBBBA?>=<<<<=,8:<<;<=>@@AAAAA@?=<<<<<<<<==<<<<<=======>>?@@A@@@?>>=;;<<<==;  -7<=<<<<<=>>>>====<<<<<<<====<<<<<==>==>=====<<<<<=<<<<<>>7&  .9>>==<<<<<=<=<<;<<<<=>?@@@@?==<<<<=<<====<=<==<<<<=>>:/  0;>>???>7% 1@9=>?AAABBA@?=(  1@@?ABCCBBDCCBA@?84?A@AABCCBBEINGBBCB@?>7$ 1@BCBCBBCCCCHH@???>.9ACCCCCCCABCKIB6,BHICBB@BBBBA?6 9ACCBBCBBBCCIICB,#ABHHC@ABBBBBA@!3ACCCBBBACBBFJDBBABDIEBB@BBBBBB>?BBBBBA@BCCCJHAEC,BCAHGB@A@BBBBB@9 9ACCCCABABCCFTICIE?@FHBMNCA@A@ABBBB?*@CCBBBBB> BCCGCBDFEEFDBIPCB$7BBBBBBA> (ABBBBBBBA9BDDCBBBBCCBBBCBAA2>>@BCCBA@>>>><0 /9???BCA?ABCBBCBACDDDGHDDDCBCBA@AA>=?BBBB>:;>65=>>><@AA>:;;<===1 +<==<<<;;=?ABBBBAABPPKQVQPPQVGELLAAABBBBA>>===::;;;==<:65<<<;;;<===;;;<;;>ABBBAAAABP:N^YXVVVX[MEJA@@AAABA><<;::;;::=>>=<=;<;<<<=?@=;<<<<<>ABBBBBABFJCJ^_XUW[c]JCMDAAABBB@=;<<;:;;;<>>>>=>@@@?@@@AAA>;<;==ABBBBBBBCJMEFJQUVXWXPFCBBABCCBB??<;;;;;;=AAA?===AAAAAAAABA@;<;;ABBBBBAAAIYbmSCBCDDDCG[bYGAAAAB@@A>;::;;:?AAAA@??BAAAAABBAAA<:;=BBBABBAAAEX_jlOAAAA@Lqrf^HAAAABBBBA<;:;:;@BBBAAAABBBBBBBBBBA=;;@BBBBBBBBBBEKNQ^IBAAEee^VJABBBBBBBBB?;:<;;?ABBBAAABBBBBBBBAA@=;=BBBBBBBBBBCCCDDFRMEIZPDDDCBCBCBCCCCCA;:?;;BBCBBBCBBBCCCCDDB@CNIACCDCCCCCCBCCCCCC>:;=>@ABBBBBBBBBBBBBBBBB@@BBBBBBBBBBBABBBABBBBBBABBCCCABBCCCCCCCCCEGICCCCCCCCCC@CCCCCCA@ABABABBBBBBBBBBBBBBBBBBBBBBBBB@BBBBCCCCCCBEDCCCCBCCCCCA@CCCCBBBABBABBBBBBBBCBBBBBBBBBBBCCCBBBA=ABBBBBBCCCBBBBCCCCCCCCC@@CCCCCCBBBBBCBBBBBBBCCBBBBBBBBBBBBBBBB@<@BBCCCCCBBAB@ACCCCCCCCB>?BCCCCBCBBCBBBBBBBBBCCBBCBBBBBCCCCBBBBAABCCCCCCCCABDBBCCCCCCCB@?@BBCBBCCCCCBCBBBBBBBBBBBBBBCCBBBCCBBBBBBBCCCCCCBCBABABCCCDDCCCBABCCCCCCCCBCCBBBBCCBCBBCCCBBBBCCCCCCCCBCBCBCCCCB@?=>>==?ACCCCCCBBBBCCCCCCBBCBCBBBBBBB@ABBCCCBBBCBBCCCCCCCCCCBA=<<=>>==<<@BBBCBBCCCCCCCCCCCCCCC@<<=>>>=>=<<<<>BCCCCCCCCCCCCBBBBBBBBBCBA<<==?ABCCCBBCCCCCCCCCCCA=<<======<<<=<>?@BCCCCCCBBBBBCCCCCBBBA?=>=<<<>@BBCCCCCCCCCCCCBA=<<<<<===<<<<<<<<=?@BCCCCCCCCCCCBBBA@=<<;/<><;;;=?ABBCCCCCCBB@?<=<<<<<<<<<<<<<==<<=>>@AABBBBBBBBA?=<;;;;<'6==<<;;=>?@AAAAA@?===<<<<<<<<<<<<<<<===<<>>>??@@@?>>=<<<<;;<=>,9=>=<;<<===>>=====<<<<<<<===<<<;<<=======>>=<<<<==<<<<<<=?;, %17997.?)4=@@@@@@@?9(*8@A@ABBBBABBBBA?=/  :AAAABACCBADFIFBBBA@??>2 4ABCCCCBCBBBHH5(EHBBB@>A@@?89ABCCCCCCBACKK@9IMC@BBBBBBAA,$ 8ACCBBBBBBBCJLC<4BLKBABBBBBBBA0/@BBCBBABCCBDLED6 /CGNDBAAABBBBA??BCBBB@@BDDBFJCF7 4ECMD@AB@ABBBB@<5ACCCBAAABCCBKKDHC;>DFCLHCCA@@ABBBB@3 ?BCCBBBBA"@DCIDBDEFFFDBMJCC'9BBBBBBB?4&*.* )@BCBBCBBA==9*/=@B@BBCCA@?ABDDCCCBB?BCCB@B@>>>>AAABBBBA<::==>4 (;@?>=>@A?@BCCBBAAACDDDFEDDDC@B@AABA@>=?@AA>::;>:;=/  8>>=>>>>>>>BBBBBBBDBCDMVYXTGCDBCABBBBBB@>>>><::;::9<<8329864227<=<:;;;:<=>ABBBAAABFGDLWTTSTXFCEEAAAABBBAA><<;:::999;<=>>;=;;<<<<=:::;:;@@<;;;;<BBAAAABBB@;;;;:;<;=?><;;=AA@@@@@AA@<::;<=@BBBBABCDEC@FRTUUTSVNA@ACBABBBB?><:::::::@A@?==CAAAAAAAAAA<:::;ABABBA@AFLQY[IDGHIJKIDITSLD@@AAA>?>::9:;9:?@@??>IAAAAAAAAAA<::;>ABBABAABBIPTclHABBBAFcj\QGAA@@BA?@@;::;<9:=@A@@@ABBABBAAAB@<::;@BBBBBAAAAAFOZ^bDBBBDch]SH?AAAABBBAB>:9==99@AAA@BBBBBBBBA?>;;@BBBBBBBBBBBCCCCFW^b]\GDDCCBBBBBCCCBBB<:;<::;=?@AAABBBBBBBBA?<:;BBBBBCBBBBBBCCCCBFWVVGCCCDCCCBBABCCCCC?::=;;<>?@AAAAAAAABBBBA?=?@AAAABBAAAAABBBA>?BBBBBC@BBBCCCCCCCBHTDACCCCCCCCBABCCCCCB;;>>>?@@@@A@BBBBBBBBBBBA@BBBBBB@ABBBBCCCCDDINCCCCCCCCCCB@CCCCCCB==>>>@AAAAAABBBBBBBBBBBBBBBBBBBABBBBCCCCCCCIJCDCCBCCCBBB@CCCCCCB@>?@@AAABAAABBBBBBBBBBBBBBBBBBB?BBBBBBBCCCCJJCCCCCCCCCCB@CCCCCCB@@AAABBBBBBBBBBBBBBBBBBBBBBBBB?;@BBBBBCCBBDIIBCBDCCCCCCA?BCCCCCBBBBBBBBBBBBBBBBBBBBBCBCCCCBBBA==BBCCBBBBC@ELF@BCCCCCCBA=<@BCCBCCCCBBBBBBBBBBBBBBBBBBBBCCCCCCBA?ACCBCCCCCCBDEDBCCCDDDCCB>=?ABCCCCCCBCCBBBBBBBBCCCCBBBBBBCCCCCCB@ABCCCCCBAB@@A@AB@CDCCCCC@?@BCCCCCBBCBBBBBBBBBCCCBBBBBBBBCCBCCCCBBCCCCCA?=<>>><<=?ABCCDCCBBBCCCCCCBABAABBBBBBBABBCBCCBBBBBBCCCCCCCCBBCA=<<<=>>=<<<<=@BCCCCCCCCCCCBBBCCCCCCBBBB<>@BBCCCBCBBCCCCCCCCCCCB?<<===>>==<<<=>>BCCCCCCCCCBBBBBBCBBBBBBA<;;=?ABCCBCCCCCCCCCCCCB?<<<<======<<<;;ABBBBCCCBCCCCCB@<<<<<=<===<<<<<<<>=<;;;7>><;;<=?ABBCCCCCBBBB?=<<<<<<<<<<<<<<<<<<=?@AAABBBBBBBA@>>?>=<;;,<@=<;;<=??@AAAAAA@?==<<<;<<;<<<<;<<<==<<=>??@@@AAA@@???>==<<=?mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/Tests/__init__.py0000644000175000017500000000000110223377127027116 0ustar debiandebian mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/Tests/colormap.map0000644000175000017500000000200010223377127027321 0ustar debiandebian    "%),036:=!A#D%H'K(N*R,U.Y/\1`3c5g6j8m:q<t>x?{AC‚E…F‰HŒJL“N—OšQS¡U¤V¨X«Z¯\²]µUºL1¿DFÄ;\É3qÎ*‡Ò"œ×²ÜÇá Ýæ òë óä ôÝ "ô× -õÐ 8õÊ Döà Oö½ [÷¶fø°qø©}ù£ˆùœ“ú–Ÿúªû‰¶ü‚Áü|ÌýuØýoãþhïÿbíÿaìÿ`êÿ`éÿ_çÿ_!æÿ^$åÿ]'ãÿ]*âÿ\.àÿ\1ßÿ[4Þÿ[7ÜÿZ:ÛÿY=ÙÿY@ØÿXD×ÿXGÕÿWJÔÿWMÒÿVPÑÿUQÐÿURÎÿTTÍÿTUËÿSVÊÿSWÉÿRXÇÿQYÆÿQ[ÄÿP\ÃÿP]ÂÿO^ÀÿN_¿ÿN`½ÿMb¼ÿMcºÿLd¹ÿLe¸ÿKf¶ÿJgµÿJi³ÿIj²ÿIk±ÿHl¯ÿHm®ÿGn¬ÿFp«ÿFqªÿEr¨ÿEs§ÿDt¥ÿDu¤ÿCw£ÿBx¡ÿBy ÿAzžÿA{ÿ@|œÿ?}šÿ?™ÿ>€—ÿ>–ÿ=‚•ÿ=ƒ“ÿ<„’ÿ;†ÿ;‡ÿ:ˆÿ:‰Œÿ9Š‹ÿ9‹‰ÿ8ˆÿ7ކÿ7…ÿ6„ÿ6‘‚ÿ5’ÿ5”ÿ4•~ÿ3–}ÿ3—{ÿ2˜zÿ2™xÿ1›wÿ1œvÿ0tÿ/žsÿ/Ÿqÿ. pÿ.¢oÿ-£mÿ,¤lÿ,¥jÿ+¦iÿ+§hÿ*¨fÿ*ªeÿ)«cÿ(¬bÿ(­aÿ'®_ÿ'¯^ÿ&±\ÿ&²[ÿ%³Yÿ$´Xÿ$µWÿ#¶Uÿ#¸Tÿ"¹Rÿ"ºQÿ!»Pÿ ¼Nÿ ½Mÿ¿KÿÀJÿÁIÿÂGÿÃFÿÄDÿÆCÿÇBÿÈ@ÿÉ?ÿÊ=ÿË<ÿÍ;ÿÎ9ÿÏ8ÿÐ6ÿÑ5ÿÒ4ÿÓ2ÿÕ1ÿÖ/ÿ×.ÿØ,ÿÙ+ÿÚ*ÿÜ(ÿÝ'ÿÞ%ÿß$ÿà#ÿá!ÿ ã ÿ äÿ åÿ æÿ çÿ èÿ êÿ ëÿ ìÿíÿîÿïÿñÿòÿó ÿô ÿõ ÿöÿøÿùÿúÿûÿüÿýÿÿmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/Tests/test.py0000644000175000017500000002322610653444130026350 0ustar debiandebian## Automatically adapted for numpy.oldnumeric Jul 30, 2007 by #!/usr/bin/env python try: import numpy.oldnumeric as Numeric from numpy.oldnumeric import * except: print "This test requires the Numeric extension" import sys sys.exit() #from RandomArray import * import string, sys try: from opengltk.OpenGL.GL import * from opengltk.OpenGL.GLUT import * from opengltk.OpenGL.GLU import * except: print "Error: Could not import opengltk " from struct import unpack #from Volume import VolumeLibrary from UTpackages.UTvolrend import UTVolumeLibrary from mglutil.regression import testplus import sys print "VOLLIB:", UTVolumeLibrary.__file__ class TestVolumeLibrary: def __init__(self): self.rotMatrix = [1.,0.,0.,0., 0.,1.,0.,0., 0.,0.,1.,0., 0.,0.,0.,1.] self.transMatrix = [1.,0.,0.,0., 0.,1.,0.,0., 0.,0.,1.,0., 0.,0.,0.,1.] self.W= 640 self.H= 480 self.halted = 0 self.whichbutton=0 self.mousex =0 self.mousey =0 self.cdx = 0 self.cdy = 0 self.state = 'ROTATE' #volume renderer self.vol = UTVolumeLibrary.VolumeRenderer() self.data =None self.byte_map=None self.indexCM =0 def Display(self,*args): glClearColor(0.0, 0.0, 0.0, 0.0) glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT) #Set up the modelview matrix glMatrixMode(GL_MODELVIEW) glLoadIdentity() glTranslated(0.0, 0.0, -4.0) glMultMatrixd(self.transMatrix) glMultMatrixd(self.rotMatrix) #the volume is rendered #volumeRenderer.renderVolume(); self.vol.renderVolume() glutSwapBuffers() def halt(self): pass def setup_viewport(self): glMatrixMode(GL_PROJECTION) glLoadIdentity() glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0) def reshape(self,w, h): glViewport(0, 0, w, h) self.setup_viewport() #Callback function for the mouse button */ def MouseButton(self,button, mstate, x, y): #sets the initial positions for mousex and mousey */ if (mstate == GLUT_DOWN): self.mousex = x self.mousey = y self.whichbutton = button self.cdx = 0 self.cdy = 0 #Callback function for the mouse motion */ def MouseMove(self,x, y): dx = x-self.mousex dy = y-self.mousey if self.state == 'ROTATE': self.Rotate(dx, dy) elif self.state == 'TRANSLATE': if (self.whichbutton == GLUT_LEFT_BUTTON): self.Translate(dx, -dy,0) else: self.Translate(0,0,-dy) else: pass self.mousex = x self.mousey = y glutPostRedisplay() def Keyboard(self,key, x, y): print '--> keyboard( %s <%c>, %i, %i)' % (key, chr( key), x, y) chkey = chr(key) if (chkey == 'R') or (chkey=='r'): self.state = 'ROTATE' elif (chkey == 't') or (chkey=='T'): self.state = 'TRANSLATE' elif (chkey == 'q') or (chkey == 'Q'): sys.exit() elif (chkey == 'z') or (chkey == 'Z'): #self.rotateCM = 1 self.StartRotateCM() elif (chkey == 'a') or (chkey == 'A'): #self.rotateCM = 0 self.StopRotateCM() else: pass def StopRotateCM(self): if hasattr(self, 'tmpCM'): self.byte_map[:] = self.tmpCM[:] del self.tmpCM self.indexCM =0 self.vol.uploadColorMap(self.byte_map) def StartRotateCM(self): if not hasattr(self, 'tmpCM'): self.tmpCM= Numeric.zeros((256,4),Numeric.UnsignedInt8) self.tmpCM[:] = self.byte_map[:] for i in range(10): if 10 <= self.indexCM < 255 : #print "self.indexCM",self.indexCM self.byte_map[self.indexCM] = (255,0,0,255) #print "self.indexCM -10",self.indexCM -10 self.byte_map[self.indexCM -10]=self.tmpCM[self.indexCM -10] self.indexCM =self.indexCM +1 elif self.indexCM <10 : self.byte_map[self.indexCM] = (255,0,0,255) self.indexCM =self.indexCM +1 else: print "End of color map" self.vol.uploadColorMap(self.byte_map) def Rotate(self,dx, dy): glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() glRotated((float(dy)), 1.0, 0.0, 0.0) glRotated((float(dx)), 0.0, 1.0, 0.0) glMultMatrixd(self.rotMatrix) self.rotMatrix=glGetDoublev(GL_MODELVIEW_MATRIX) #self.rotMatrix.shape = (16,) glPopMatrix() def Translate(self,dx,dy, dz): glMatrixMode(GL_MODELVIEW) glPushMatrix() glLoadIdentity() glTranslated((float(dx))/100.0, (float(dy))/100.0, (float(dz))/10.0) glMultMatrixd(self.transMatrix) self.transMatrix = glGetDoublev(GL_MODELVIEW_MATRIX) self.transMatrix.shape = (16,) glPopMatrix() def RegisterCallbacks(self): #glutSetDisplayFuncCallback(self.Display) #glutDisplayFunc() #glutSetIdleFuncCallback(self.Idle) #glutIdleFunc() glutDisplayFunc(self.Display) glutIdleFunc(self.Idle) #glutSetMouseFuncCallback(self.MouseButton) #glutMouseFunc() #glutSetMotionFuncCallback(self.MouseMove) #glutMotionFunc() #glutSetKeyboardFuncCallback(self.Keyboard) #glutKeyboardFunc() try: glutMouseFunc(self.MouseButton) except: print "Could not use glutMouseFunc" glutMotionFunc(self.MouseMove) glutKeyboardFunc(self.Keyboard) def InitProjection(self): glMatrixMode(GL_PROJECTION) glLoadIdentity() gluPerspective( 30.0, self.W / self.H, 0.01, 20.0 ) def InitModelMatrix(self): glMatrixMode(GL_MODELVIEW) glLoadIdentity() #initialize rotMatrix an d transMatrix to the identity */ self.rotMatrix=glGetDoublev(GL_MODELVIEW_MATRIX) #self.rotMatrix.shape = (16,) self.transMatrix=glGetDoublev(GL_MODELVIEW_MATRIX) #self.transMatrix.shape = (16,) def InitLighting(self): lightdir = [-1.0, 1.0, 1.0, 0.0] glEnable(GL_LIGHTING) glEnable(GL_LIGHT0) glLightfv(GL_LIGHT0, GL_POSITION, lightdir) glEnable(GL_NORMALIZE) def Idle(self): self.Rotate(self.cdx, self.cdy) glutPostRedisplay() def init(self): self.InitProjection() self.InitModelMatrix() self.InitLighting() self.InitState() self.InitVolumeRenderer() self.LoadData() self.InitData() def BeginGraphics(self): print "Init" glutInit('foo') print "InitWindowSize" glutInitWindowSize(640,480) print "InitWindowPosition" glutInitWindowPosition(100,100) print "InitDisplayMode" glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH) print "CreateWindow" win = glutCreateWindow('test') print "SetWindow" glutSetWindow(win) print "init" self.init() self.RegisterCallbacks() glutMainLoop() def InitVolumeRenderer(self): if not self.vol.initRenderer(): print "Warning, there was an error initializing the volume renderer\n" def LoadData(self): #load colormap from file import os myfile = open("ct_head.rawiv", "rb" ) print "myfile: ", myfile if not myfile: print "Error: could not open file: ct_head.rawiv" else: #the header header=myfile.read(68) # unpack header following rawiv format,big endian h = unpack('>6f5I6f',header) width=int(h[8]) height=int(h[9]) depth =int(h[10]) # load the data l = myfile.read(width*height*depth) self.data = Numeric.fromstring(l, Numeric.UnsignedInt8, (width*height*depth) ) self.size = (width, height, depth) print "size: ", self.size #self.data = Numeric.reshape(self.data,(width,height,depth)) myfile.close() myfile = open("colormap.map", "rb" ) if not myfile: print "Error: Could not open file: colormap.map" else: l = myfile.read(256*4) self.byte_map =Numeric.fromstring(l, Numeric.UnsignedInt8, (256*4)) self.byte_map = Numeric.reshape(self.byte_map,(256,4)) myfile.close() def InitState(self): glClearColor(0.2, 0.2, 0.2, 1.0) glColor4d(1.0, 1.0, 1.0, 1.0) glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ) glEnable(GL_DEPTH_TEST) glDisable(GL_CULL_FACE) def InitData(self): nx, ny, nz = self.size print "uploadColorMappedData.." status = self.vol.uploadColorMappedData(self.data, nx, ny, nz) print "status:", status print "done.." self.vol.uploadColorMap(self.byte_map) def test_Library(): v = TestVolumeLibrary() v.BeginGraphics() print "Use the mouse buttons to control." print " Hit 't' or 'T' to do translation." print " Hit 'r' or 'R' to do rotation." print "Hit q key to quit." ## harness = testplus.TestHarness( __name__, ## funs = testplus.testcollect( globals()), ## ) if __name__ == '__main__': harness = testplus.TestHarness( __name__, funs = testplus.testcollect( globals()), ) print harness sys.exit( len( harness)) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTvolrendDIST/UTvolrend/__init__.py0000644000175000017500000000000110223377127026014 0ustar debiandebian mgltools-utpackages-1.5.7~rc1~cvs.20130519/setup.py0000644000175000017500000001321310404134317021067 0ustar debiandebianfrom distutils.core import setup, Extension from distutils.cmd import Command from distutils.command.install import install from distutils.command.build import build from distutils.command.sdist import sdist from distutils import log from glob import glob from distutils.command.build_ext import build_ext import sys, os from os import path import string import traceback pack_name = "UTpackages" packages = ["UTpackages","UTpackages.Tests"] subpackages = ["UTblur", "UTisocontour", "UTvolrend", "UTmesh", "UTsdf", "UTmolderivatives"] ## if sys.platform == "linux2": ## subpackages.append("UTimposter") currdir = os.getcwd() status=[] #Overwrite run() method of Distutils build class to loop over # subpackages and execute their setup.py class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] def run(self): args = sys.argv if args[1] != "install": for pack in subpackages: os.chdir(pack+"DIST") log.info("Current directory : %s"%os.getcwd() ) cmd = "%s setup.py build"%sys.executable st = os.system(cmd) if st != 0: status.append([pack,cmd]) os.chdir(currdir) log.info("Current directory : %s"%os.getcwd()) #sys.argv = args build.run(self) class modified_sdist(sdist): def prune_file_list(self): """Overvrite the 'sdist' method to not remove automatically the RCS/CVS directories from the distribution. """ build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) def run(self): for pack in subpackages: os.chdir(pack+"DIST") log.info("Current directory : %s"%os.getcwd() ) cmd = "%s setup.py sdist --manifest-only"%sys.executable #print "running command: ", cmd st = os.system(cmd) if st != 0: status.append([pack, cmd]) os.chdir(currdir) log.info("Current directory : %s"%os.getcwd() ) sdist.run(self) def read_manifest (self, dirname =None): """Read the manifest file (named by 'self.manifest') and use it to fill in 'self.filelist', the list of files to include in the source distribution. """ log.info("reading manifest file '%s'", self.manifest) manifest = open(self.manifest) while 1: line = manifest.readline() if line == '': # end of file break if line[-1] == '\n': line = line[0:-1] if dirname: line = path.join(dirname, line) self.filelist.append(line) def write_manifest (self): currmanifest = self.manifest for pack in subpackages: self.manifest = path.join(pack+"DIST", "MANIFEST") self.read_manifest(dirname = pack+"DIST") self.manifest = currmanifest #print self.filelist.files sdist.write_manifest(self) #Overwrite run() method of Distutils install class to loop over # subpackages and execute their setup.py class modified_install(install): def run(self): self.install_lib = self.install_platlib install_platlib = path.abspath(self.install_platlib) install_purelib = install_platlib print "install_platlib=", install_platlib print "install_purelib=", install_purelib args = sys.argv bdist = 0 for i, arg in enumerate(args[1:]): if string.find(arg, "--install-platlib") != -1: platlib_fl = 1 args[i+1] = "--install-platlib="+install_platlib elif string.find(arg, "--install-purelib") != -1: purelib_fl = 1 args[i+1] = "--install-purelib="+install_purelib elif string.find(arg, "bdist") != -1: bdist = 1 args[i+1] = "install" args.append("--install-platlib="+install_platlib) cmd = "%s"%sys.executable for e in args: cmd = cmd + " " + e print "command: ", cmd for pack in subpackages: os.chdir(pack+"DIST") log.info("Current directory : %s"%os.getcwd() ) #sys.argv = args #print "args:" , sys.argv st = os.system(cmd) if st != 0: status.append([pack, cmd]) os.chdir(currdir) log.info("Current directory : %s"%os.getcwd() ) install.run(self) try: from version import VERSION except: VERSION = "1.0" dist = setup(name=pack_name, version=VERSION, description = "UT Austin software Python extensions", author = 'Molecular Graphics Laboratory', author_email = "mgltools@scripps.edu", download_url = "http://www.scripps.edu/~sanner/python/packager.html", url = 'http://www.scripps.edu/~sanner/software/index.html', packages = packages, cmdclass = {'build':modified_build, 'sdist':modified_sdist, 'install': modified_install}, ) if len(status): for i in status: print "Error in package %s , command: '%s' "%(i[0], i[1]) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTpackages_license.txt0000644000175000017500000001104310334433336023653 0ustar debiandebianTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 1. This software is the copyright of THE UNIVERSITY OF TEXAS AT AUSTIN, 2005. 2. The software is available under multiple licenses. 3. For non commercial educational and non commercial academic use, the software including source code, interface definitions and compile scripts are freely available. Any distribution of code, library or executables which contains any modules from this software should contain, conspicously and appropriately, on each copy, this copyright and license notice and should be freely distributed. 4. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation. 5. For any other purpose, including commercial purposes, please contact The University of Texas at Austin for a different license. 6. Credits: This software has been developed at the Computational and Visualization center under Dr Chandrajit Bajaj, Computational Applied Mathematics Chair in Visualization, Professor of Computer Sciences, Director of Center for Computational Visualization, Department of Computer Sciences & The Institute of Computational Engineering and Sciences , Center for Computational Visualization, 201 East 24th Street, ACES 2.324A, 1 University Station, C0200, Austin, TX 78712-0027. We request that you agree to acknowledge the use of the software that results in any published work, including scientific papers, films and videotapes by citing the references listed below For UTblur: C. Bajaj, V. Siddavanahalli Fast Feature Adaptive Surfaces and Derivatives Computation for Volumetric Particle Data ICES and CS technical reports, The University of Texas at Austin, 2005. For UTisocontour: C. Bajaj, V. Pascucci, D. Schikore Accelerated IsoContouring of Scalar Fields Data Visualization Techniques, edited by C. Bajaj, John Wiley and Sons (1998). C. Bajaj, V. Pascucci, D. Schikore Fast Isocontouring for Improved Interactivity Proceedings: ACM Siggraph/IEEE Symposium on Volume Visualization, ACM Press, (1996), San Francisco, CA. Pages: 39-46 99 For UTmesh: Y. Zhang, C. Bajaj Adaptive and Quality Quadrilateral/Hexahedral Meshing from Volumetric Data Computer Methods in Applied Mechanics and Engineering (CMAME), in press, 2005. Y. Zhang, C. Bajaj, B-S. Sohn 3D Finite Element Meshing from Imaging Data The special issue of Computer Methods in Applied Mechanics and Engineering (CMAME) on Unstructured Mesh Generation, 194(48-49):5083-5106, 2005. For UTsdf: C. Bajaj, V. Siddavanahalli An Adaptive Grid Based Method for Computing Molecular Surfaces and Properties ICES and CS Technical Reports, The University of Texas at Austin, 2005. For UTvolrend: C. Bajaj, Z. Yu, M. Auer Volumetric Feature Extraction and Visualization of Tomographic Molecular Imaging. Journal of Structural Biology, Volume 144, Issues 1-2, October 2003, Pages 132-143 For UTmolderivatives: C. Bajaj, V. Siddavanahalli Fast Feature Adaptive Surfaces and Derivatives Computation for Volumetric Particle Data ICES and CS Technical Reports, The University of Texas at Austin, 2005. 7. No warranty 7a. Because the library is licensed free of charge, there is no warranty for the library, to the extent permitted by applicable law. except when otherwise stated in writing the copyright holders and/or other parties provide the library "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. the entire risk as to the quality and performance of the library is with you. should the library prove defective, you assume the cost of all necessary servicing, repair or correction. 7b. In no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute the library as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use the library (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the library to operate with any other software), even if such holder or other party has been advised of the possibility of such damages. END OF TERMS AND CONDITIONS mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/0000755000175000017500000000000012146213527021264 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/setup.cfg0000644000175000017500000000014110216112742023072 0ustar debiandebian# Important : this instructs distutils to build SWIG wrappers for C++ [build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/setup.py0000644000175000017500000000663010675045452023010 0ustar debiandebianfrom distutils.core import setup, Extension from distutils.cmd import Command from distutils.command.install_data import install_data from distutils.command.build import build from distutils.command.sdist import sdist from glob import glob from distutils.command.build_ext import build_ext import sys from os import path ##################################################################### # This class overwrites the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. #################################################################### class modified_sdist(sdist): def prune_file_list(self): build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) ######################################################################## # Overwrite the sub_commands list of the build command so that # the build_py is called after build_clib and build_ext. This way # the python module generated by SWIG ('build_ext' command) will be # installed by 'build_py' command. ######################################################################## class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] ## Need to use C++ compiler: CC_exe = 'CC' cc_exe = 'cc' platform = sys.platform if platform == "linux2" or platform == "darwin": CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to', g[n] if platform in ('sunos5', 'linux2', 'irix6', 'darwin'): sysconfig._init_posix = my_init_posix comp_opts = [] link_opts = [] if platform == "irix6": comp_opts.append( "-LANG:std" ) link_opts.append("-LANG:std") elif platform == "win32": comp_opts.append("/MT") # UTblurring package should be installed in ***/UTPackages/ packFullName = "UTpackages.UTblur" packName = "UTblur" import numpy numpy_include = numpy.get_include() dist = setup(name=packFullName, version="1.0", description = "", author = "Molecular Graphics Laboratory", author_email = "mgltools@scripps.edu", download_url = "http://www.scripps.edu/~sanner/python/packager.html", url = '', packages = [packFullName], package_dir = {packFullName: packName}, cmdclass = {'build':modified_build, 'sdist':modified_sdist}, ext_package = packFullName, ext_modules = [Extension ("_blur", [path.join(packName, "blur.i")], extra_compile_args = comp_opts, extra_link_args = link_opts, include_dirs = [numpy_include,] ) ] ) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/0000755000175000017500000000000012146213527022501 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/blur.i.gridMove0000644000175000017500000003337611165234135025404 0ustar debiandebian%module blur %init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #include "numpy/arrayobject.h" static PyObject* l_output_helper2(PyObject* target, PyObject* o) { PyObject* o2; PyObject* o3; if (!target) { target = o; } else if (target == Py_None) { Py_DECREF(Py_None); target = o; } else { if (!PyList_Check(target)) { o2 = target; target = PyList_New(0); PyList_Append(target, o2); Py_XDECREF(o2); } PyList_Append(target,o); Py_XDECREF(o); } return target; } static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} %{ #include #include #include #include #include #define ELECTRON_DENSITY 0 float evalDensityInverse(float radius, float epsilon, int kernelType, double blobbyness) { if (kernelType == 0) return radius * (float)sqrt(1.0 + log(epsilon) / blobbyness); else if (kernelType == 1) return (float)sqrt(radius*radius+log(epsilon)/blobbyness); else // this should crash { assert(kernelType != kernelType); return 0.0; } } void getBoundingBox(float coords[][3], float radii[], int na, float min[3], float max[3], double blobbyness) { int i, j; float maxRad=0.0; // use a fixed epsilon to avoid the growing bounding box problem // (1/10,000 should be sufficient) float epsilon = 1.0e-4; if(na == 0) { // no atoms for(i = 0; i < 3; i++) { min[i] = max[i] = 0.0; } return; } for(i = 0; i < 3; i++) { min[i] = coords[0][i]; max[i] = coords[0][i]; } maxRad = evalDensityInverse(radii[0], epsilon, 1, blobbyness); //printf ("maxRad in getBoundingBox: %.2f\n", maxRad); for(j = 1; j < na; j++) { for(i = 0; i < 3; i++) { if(coords[j][i] < min[i]) min[i] = coords[j][i]; if(coords[j][i] > max[i]) max[i] = coords[j][i]; } float tempRad = evalDensityInverse(radii[j], epsilon, 1, blobbyness); //if (j<20) // printf("j = %d, tempRad = %.2f\n", j, tempRad); if (maxRad < tempRad) maxRad = tempRad; } // adjust the bounding box by 1 for(i = 0; i < 3; i++) { min[i] -= maxRad; max[i] += maxRad; } } float evalDensity(float position[3], float radius, float pnt[3], double maxRadius, int densityType, int hydrophobicity, double blobby) { // Gaussian approximation //return 1.0; //printf("[%.3f, %.3f, %.3f], r=%.2f, pnt:[%.3f, %.3f, %.3f], mr=%.2f, b=%.2f, dt=%d", position[0],position[1], position[2],radius, pnt[0], pnt[1],pnt[2], maxRadius, blobby, densityType); double r = (position[0]-pnt[0])*(position[0]-pnt[0]) + (position[1]-pnt[1])*(position[1]-pnt[1]) + (position[2]-pnt[2])*(position[2]-pnt[2]); double r0 = radius; r0 *= r0; //double expval = blobby*r/r0 - blobby; //double expval = blobby*r - blobby*r0; double expval = blobby*((r/r0) - 1); // truncated gaussian //if (sqrt(r) > maxRadius) // return 0.0; //printf ("r0=%.2f, ex=%.2f\n", r0, expval); float res; if( densityType == ELECTRON_DENSITY ) res = (float)(exp(expval)); //return (float)(exp(expval)); else // hydrophobicity res = (float)(hydrophobicity*exp(expval)); //return (float)(hydrophobicity*exp(expval)); //printf ("%.4f,", res); return res; } void generateBlurmap(float coords[][3], float radii[], int dlen, float *dens, int dim[3], double blobbyness, float orig[3], float span[3], float weights[]=NULL) { float min[3],max[3], epsilon; unsigned int gdim[3]; gdim[0] = dim[0]; gdim[1] = dim[1]; gdim[2] = dim[2]; //float *dens = new float[dimx*dimy*dimz]; epsilon = 1.0e-3; // compute the bounding box min[0] = min[1] = min[2] = 0.; max[0] = max[1] = max[2] = 0.; // getBoundingBox(coords, radii, dlen, min, max, epsilon, blobbyness); getBoundingBox(coords, radii, dlen, min, max, blobbyness); //printf("bounding box: (%f,%f,%f)->(%f,%f,%f)\n", min[0],min[1],min[2], // max[0],max[1],max[2]); // blur //float *maxDens=0; //float orig[3],span[3]; unsigned int zoff=0, i, c1; //printf("epsilon = %f\n", epsilon); orig[0] = min[0]; //vol->getMinX(); orig[1] = min[1]; //vol->getMinY(); orig[2] = min[2]; //vol->getMinZ(); if (weights) // ***** a trick to apply gridMove ***** { orig[0] += weights[0]; orig[1] += weights[1]; orig[2] += weights[2]; } // and span span[0] = (max[0] - min[0]) / (float)(dim[0]-1); //vol->getSpanX(); span[1] = (max[1] - min[1]) / (float)(dim[1]-1); //vol->getSpanY(); span[2] = (max[2] - min[2]) / (float)(dim[2]-1); //vol->getSpanZ(); //printf("origin: %.2f, %.2f, %.2f \n", orig[0], orig[1], orig[2]); //printf("span: %.2f, %.2f, %.2f \n", span[0], span[1], span[2]); // main blurring loop c1 = dim[0]*dim[1]; for (i=0; i < dlen; i++) { //PDBParser::Atom *at = atoms[i]; int hydrophobe=0; double c[3], maxRad, r0; unsigned int amax[3],amin[3], j,k,l, c2; //if (densityType != ELECTRON_DENSITY) //hydrophobe = lookUpHydrophobicity(*at); // calculate the maximum radius for this atom //maxRad = evalDensityInverse(at->getRadius(), epsilon, 1); maxRad = evalDensityInverse(radii[i], epsilon, 1, blobbyness); // compute the dataset coordinates of the atom's center for (j=0; j < 3; j++) { c[j] = (coords[i][j] - orig[j]) / span[j]; c[j] = ((c[j]-floor(c[j])) >= 0.5) ? ceil(c[j]) : floor(c[j]); } // then compute the bounding box of the atom (maxRad^3) for (j=0; j < 3; j++) { int tmp; tmp = (int)(c[j] - (maxRad / span[j]) - 1); tmp = (tmp < 0) ? 0 : tmp; amin[j] = (unsigned int)tmp; //amax[j] = (int)(c[j] + (maxRad / span[j]) + 1); //amax[j] = (amax[j] > gdim[j]) ? gdim[j] : amax[j]; tmp = (int)(c[j] + (maxRad / span[j]) + 1); tmp = (tmp > gdim[j]) ? gdim[j] : tmp; amax[j] = (unsigned int)tmp; } //if (i<40) // printf("bbox = (%d,%d,%d)\n", amax[0]-amin[0],amax[1]-amin[1],amax[2]-amin[2]); //printf("blur atom %d: (%u,%u,%u)->(%u,%u,%u)\n",i, // amin[0],amin[1],amin[2], // amax[0],amax[1],amax[2]); // begin blurring kernel for(l = amin[2]; l < amax[2]; l++) { for(k = amin[1]; k < amax[1]; k++) { c2 = k*dim[0]; for(j = amin[0]; j < amax[0]; j++) { int n = j + c2 + (l-zoff)*c1; //int n = j + k*dim[0] + (l-zoff)*dim[0]*dim[1]; float pnt[3], density; pnt[0] = orig[0] + j*span[0]; pnt[1] = orig[1] + k*span[1]; pnt[2] = orig[2] + l*span[2]; // calculate the electron density / hydrophobicity density = evalDensity( coords[i], radii[i], pnt, maxRad, ELECTRON_DENSITY, hydrophobe, blobbyness); // // scaling density by weights // if (weights) // density *= weights[i]; // sum up on a grid point dens[n] += density; } } } // end blurring kernel // status message /**** if (((i+1) % 20) == 0 || (i+1) == dlen) { printf("%2.2f%% done (%012d)\r", 100.0*(i+1)/(float)dlen, i+1); fflush(stdout); } ***/ } // end of status line //printf("\n"); fflush(stdout); //printf ("Done\n"); } %} // Typemaps for generateBlurmap() // typemap to input the list of dimensions and ignore float *dens argument %typemap(in) (float *dens, int dim[3]) %{ int i, datasize, temp[3]; PyObject *o; if (!PyList_Check($input)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } if (PySequence_Length($input) != 3) { PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected 3 elements"); return NULL; } for (i = 0; i < 3; i++) { o = PyList_GetItem($input,i); if (PyNumber_Check(o)) temp[i] = (int) PyInt_AsLong(o); else { PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); return NULL; } } datasize= temp[0]*temp[1]*temp[2]; //allocate memory for data array - 'float *dens' //$1 = (float *) malloc(datasize*sizeof(float *)); $1 = (float *) calloc( datasize, sizeof(float *)); $2 = temp; %} //typemap to output the data array - dens %typemap(argout ) float *dens %{ PyArrayObject * out; npy_intp dims[1]; dims[0] = datasize; out = (PyArrayObject *)PyArray_SimpleNewFromData(1, dims, PyArray_FLOAT, (char *)$1); //out = (PyArrayObject *)PyArray_FromDimsAndData(3, temp, PyArray_FLOAT, (char *)$1); if (!out) { PyErr_SetString(PyExc_RuntimeError, "Failed to allocate memory for normals"); return NULL; } out->flags |= NPY_OWNDATA; /* so we'll free this memory when this array will be garbage collected */ //$result = Py_BuildValue("O", (PyObject *)out) ; $result = l_output_helper2($result, (PyObject *)out); %} // typemap to input an array of weights %typemap(in) (float radii[1], int dlen) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (float radii[1], int dlen) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} // typemap to input an array of radii (it should have the same length as weights) %typemap(default) float weights[1] %{ PyArrayObject *weightsarr=NULL; // have to make weightsarr local variable and use it in "freearg" typemap - // SWIG does not apply $argnum correctly in this case. %} %typemap(in) float weights[1] (int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; weightsarr= contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! weightsarr) return NULL; $1 = (float *)weightsarr->data; } else { weightsarr = NULL; $1 = NULL; } %} %typemap(freearg) (float weights[1]) %{ if (weightsarr) Py_DECREF((PyObject *)weightsarr); %} //typemap to input an array of coords %typemap(in) float coords[1][3](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) float coords[1][3] %{ if (array$argnum ) Py_DECREF((PyObject *)array$argnum); %} // typemaps to ignore 'float orig[3]' and 'float span[3]' arguments %typemap(in, numinputs=0) float OUT[3] %{ $1 = (float *) malloc(sizeof(float)*3); %} // typemaps to output 'orig' and 'span' lists. %typemap(argout) float OUT[3](float element, int i, PyObject * res) %{ res = PyTuple_New(3); for (i=0; i<3; i++) { element = $1[i]; PyTuple_SetItem(res ,i, PyFloat_FromDouble((double)element)); } $result = l_output_helper2($result, res); %} %typemap(freearg) float OUT[3] %{ free($1); %} %apply float OUT[3] { float orig[3], float span[3], float min[3], float max[3]}; void generateBlurmap(float coords[1][3], float radii[1], int dlen, float *dens, int dim[3], double blobbyness, float orig[3], float span[3], float weights[1]=NULL); void getBoundingBox(float coords[1][3], float radii[1], int dlen, float min[3], float max[3], double blobbyness); /*** from Python interface the function is called as follows: import blurr #coords - array(n, 3) of xyz coodinates # radii - array(n) data, origin, span = blur.generateBlurmap(coords, radii, [dimx, dimy,dimz], blobbyness) ***/ %include elementInfo.i mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/test_blur.py0000644000175000017500000001777010653444130025067 0ustar debiandebian## Automatically adapted for numpy.oldnumeric Jul 30, 2007 by radii=[1.62,1.75,1.88,1.48,1.75,1.56,1.75,1.62,1.75,1.88,1.48,1.75,1.56,1.75,1.62,1.75,1.88,1.48,1.75,1.77,1.62,1.75,1.88,1.48,1.75,1.77,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.56,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.12,1.62,1.62,1.62,1.75,1.88,1.48,1.75,1.56,1.62,1.75,1.88,1.48,1.75,1.88,1.48,1.62,1.62,1.75,1.88,1.48,1.75,1.77,1.77,1.77,1.77,1.77,1.77,1.62,1.75,1.88,1.48,1.75,1.88,1.48,1.62,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.77,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.12,1.62,1.62,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.62,1.75,1.88,1.48,1.75,1.56,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.88,1.48,1.48,1.62,1.75,1.88,1.48,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.77,1.62,1.75,1.88,1.48,1.75,1.62,1.75,1.88,1.48,1.75,1.56,1.75,1.62,1.75,1.88,1.48,1.75,1.77,1.77,1.77,1.77,1.77,1.77,1.53,1.62,1.75,1.88,1.48,1.75,1.56,1.75,1.62,1.75,1.88,1.48,1.62,1.75,1.88,1.48,1.75,1.77,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.62,1.75,1.88,1.48,1.75,1.62,1.75,1.88,1.48,1.75,1.56,1.75,1.62,1.75,1.88,1.48,1.75,1.77,1.62,1.75,1.88,1.48,1.75,1.75,1.75,1.62,1.75,1.88,1.48,1.62,1.75,1.88,1.48,1.75,1.88,1.48,1.48,1.62,1.75,1.88,1.48,1.75,1.77,1.77,1.77,1.77,1.77,1.77,1.53,1.62,1.75,1.88,1.48,1.75,1.62,1.75,1.88,1.48,1.75,1.88,1.48,1.62,1.00] coords = [ [17.05,14.10,3.62],[16.97,12.78,4.34],[15.69,12.76,5.13],[15.27,13.82,5.59],[18.17,12.70,5.34],[19.33,12.83,4.46],[18.15,11.55,6.30],[15.11,11.56,5.26],[13.86,11.47,6.07],[14.16,10.78,7.38],[14.99,9.86,7.44],[12.73,10.71,5.26],[13.31,9.44,4.93],[12.48,11.44,3.89],[13.49,11.24,8.42],[13.66,10.71,9.79],[12.27,10.43,10.32],[11.39,11.31,10.19],[14.37,11.75,10.69],[15.89,12.43,10.02],[12.02,9.27,10.93],[10.65,8.99,11.41],[10.65,8.79,12.92],[11.66,8.30,13.49],[10.06,7.75,10.68],[9.84,8.02,8.90],[9.56,9.11,13.56],[9.45,9.03,15.01],[9.29,7.67,15.61],[9.49,7.52,16.82],[8.23,9.96,15.35],[7.34,9.79,14.11],[8.37,9.80,12.96],[8.88,6.69,14.80],[8.67,5.31,15.28],[8.75,4.38,14.08],[8.73,4.86,12.92],[7.34,5.12,16.00],[6.27,5.22,15.03],[8.88,3.08,14.36],[8.91,2.08,13.26],[7.58,2.09,12.51],[7.67,2.03,11.24],[9.21,0.68,13.92],[10.71,0.70,14.31],[8.81,-0.48,12.97],[11.19,-0.52,15.14],[6.46,2.16,13.16],[5.14,2.21,12.45],[5.11,3.38,11.46],[4.66,3.27,10.34],[3.99,2.35,13.48],[2.72,2.89,12.87],[3.76,1.03,14.21],[5.61,4.55,11.94],[5.60,5.77,11.08],[6.44,5.53,9.85],[6.05,5.93,8.74],[6.02,6.98,11.89],[7.65,4.91,10.01],[8.50,4.61,8.84],[7.80,3.61,7.88],[7.88,3.78,6.65],[9.85,4.02,9.31],[10.75,3.61,8.15],[11.23,4.70,7.24],[12.14,5.57,8.03],[12.76,6.61,7.44],[12.54,6.93,6.16],[13.60,7.32,8.20],[7.19,2.58,8.44],[6.50,1.58,7.57],[5.38,2.31,6.77],[5.21,2.02,5.56],[5.91,0.46,8.40],[6.99,-0.27,9.01],[4.65,3.18,7.45],[3.55,3.93,6.75],[4.11,4.85,5.69],[3.54,5.00,4.62],[2.66,4.68,7.75],[1.80,3.73,8.61],[1.57,2.61,8.16],[1.39,4.25,9.77],[5.26,5.50,6.01],[5.93,6.36,5.05],[6.30,5.58,3.80],[6.14,6.07,2.65],[7.18,6.99,5.75],[7.88,8.01,4.88],[8.91,7.59,4.03],[7.53,9.37,4.98],[9.56,8.54,3.19],[8.18,10.28,4.14],[9.14,9.85,3.29],[6.90,4.39,3.99],[7.33,3.61,2.79],[6.12,3.21,1.91],[6.24,3.14,0.68],[8.15,2.40,3.24],[9.56,2.86,3.73],[10.01,3.89,3.32],[10.12,1.96,4.54],[4.99,2.93,2.57],[3.78,2.60,1.74],[3.30,3.87,1.00],[2.95,3.82,-0.19],[2.70,1.95,2.61],[1.38,1.83,1.81],[3.17,0.53,3.01],[3.32,4.99,1.72],[2.89,6.28,1.13],[3.69,6.60,-0.11],[3.20,7.15,-1.10],[3.04,7.37,2.24],[2.56,9.01,1.65],[5.00,6.23,-0.10],[5.89,6.49,-1.21],[5.74,5.56,-2.41],[6.23,5.90,-3.51],[7.37,6.51,-0.73],[7.72,7.69,0.21],[7.95,8.95,-0.62],[9.21,8.86,-1.34],[9.54,9.53,-2.43],[8.66,10.35,-3.03],[10.79,9.49,-2.90],[5.05,4.41,-2.20],[4.93,3.43,-3.33],[4.40,4.01,-4.62],[4.99,3.76,-5.69],[4.20,2.18,-2.86],[4.96,1.18,-1.99],[3.91,0.10,-1.63],[6.13,0.61,-2.77],[3.33,4.80,-4.54],[2.79,5.38,-5.80],[3.57,6.54,-6.32],[3.26,7.05,-7.42],[1.36,5.77,-5.47],[1.22,5.69,-3.99],[2.42,4.94,-3.41],[4.57,7.05,-5.56],[5.37,8.19,-6.02],[5.01,9.48,-5.28],[5.53,10.51,-5.73],[4.18,9.44,-4.26],[3.77,10.61,-3.51],[5.02,11.40,-3.04],[5.95,10.76,-2.52],[2.99,10.19,-2.22],[2.05,9.14,-2.62],[2.26,11.35,-1.55],[4.97,12.70,-3.18],[6.14,13.51,-2.70],[6.40,13.23,-1.23],[5.49,13.06,-0.38],[5.70,14.97,-2.92],[4.68,14.89,-4.00],[3.96,13.57,-3.81],[7.73,13.30,-0.92],[8.11,13.10,0.50],[7.43,14.07,1.41],[7.04,13.68,2.54],[9.65,13.28,0.66],[10.44,12.09,0.06],[11.94,12.17,0.39],[12.42,13.23,0.68],[12.54,11.07,0.29],[7.21,15.33,0.97],[6.61,16.32,1.91],[5.21,15.94,2.35],[4.78,16.17,3.49],[6.61,17.69,1.25],[4.45,15.32,1.40],[3.07,14.89,1.76],[3.09,13.64,2.64],[2.32,13.52,3.58],[2.20,14.64,0.46],[1.82,16.05,-0.13],[0.90,13.86,0.81],[0.76,16.76,0.76],[4.03,12.76,2.31],[4.18,11.55,3.19],[4.63,11.94,4.60],[4.23,11.25,5.55],[5.04,10.52,2.54],[4.35,9.79,1.02],[5.41,13.01,4.69],[5.88,13.50,6.03],[4.70,13.91,6.88],[4.53,13.42,8.02],[6.88,14.61,5.83],[3.83,14.80,6.36],[2.69,15.22,7.19],[1.67,14.13,7.43],[0.95,14.11,8.47],[1.99,16.52,6.61],[1.66,16.22,5.23],[2.91,17.74,6.70],[1.62,13.19,6.51],[0.71,12.05,6.66],[1.12,11.12,7.82],[0.29,10.63,8.55],[0.75,11.23,5.32],[-0.20,10.04,5.35],[-1.55,10.34,5.64],[0.19,8.75,5.10],[-2.50,9.33,5.67],[-0.80,7.70,5.16],[-2.08,8.03,5.43],[-3.10,7.06,5.46],[2.47,10.98,7.99],[2.99,9.99,8.95],[3.61,10.51,10.23],[3.77,9.72,11.19],[4.08,9.10,8.23],[5.12,10.03,7.82],[3.49,8.32,7.03],[3.98,11.76,10.24],[4.77,12.34,11.36],[6.26,12.24,11.11],[7.04,12.75,11.95],[6.71,11.63,9.99],[8.14,11.69,9.64],[8.50,13.14,9.21],[7.58,13.95,8.94],[8.50,10.69,8.53],[8.05,8.99,8.88],[9.79,13.41,9.17],[10.28,14.76,8.82],[11.35,14.66,7.74],[11.97,13.58,7.55],[10.79,15.53,10.09],[12.06,14.80,10.67],[9.68,15.69,11.14],[12.73,15.68,11.78],[11.49,15.77,7.04],[12.55,15.88,6.04],[13.59,16.92,6.56],[13.17,18.01,6.95],[11.99,16.36,4.68],[10.91,15.34,4.16],[13.13,16.52,3.63],[10.15,16.02,2.94],[14.86,16.49,6.54],[15.93,17.45,6.94],[16.91,17.55,5.82],[17.10,16.66,4.97],[16.62,17.00,8.28],[17.36,15.65,8.07],[15.59,16.97,9.43],[18.30,15.21,9.22],[17.66,18.67,5.81],[18.64,18.86,4.74],[19.92,18.04,4.95],[20.59,17.74,3.94],[18.94,20.36,4.78],[18.24,20.94,5.91],[17.37,19.90,6.60],[20.17,17.73,6.22],[21.45,16.97,6.51],[21.14,15.48,6.43],[20.14,15.02,5.88],[22.06,14.70,7.03],[22.02,13.24,7.02],[21.94,12.63,8.40],[21.87,11.39,8.44],[23.25,12.70,6.28],[21.89,13.44,9.44],[21.94,12.91,10.81],[20.61,13.19,11.52],[20.36,14.32,11.95],[23.13,13.60,11.59],[24.28,13.40,10.71],[23.34,12.94,12.96],[19.83,12.11,11.64],[18.50,12.31,12.30],[18.68,12.45,13.78],[19.53,11.72,14.36],[17.58,11.12,12.00],[17.20,10.93,10.24],[17.88,13.27,14.43],[17.92,13.42,15.88],[17.39,12.21,16.59],[16.65,11.37,16.03],[17.08,14.66,16.15],[16.10,14.69,15.00],[16.86,14.15,13.78],[17.73,12.12,17.88],[17.33,10.96,18.69],[15.88,10.69,18.87],[15.43,9.55,19.17],[15.04,11.75,18.72],[13.56,11.57,18.84],[12.94,11.23,17.47],[11.72,11.04,17.43],[12.93,12.74,19.58],[13.14,14.09,18.96],[14.11,14.30,18.21],[12.27,14.96,19.26],[13.73,11.17,16.42],[13.26,10.74,15.08],[14.27,9.69,14.61],[14.93,9.86,13.57],[13.20,11.91,14.07],[12.00,12.82,14.40],[12.12,13.85,15.33],[10.77,12.62,13.76],[11.05,14.68,15.61],[9.68,13.43,14.05],[9.80,14.46,15.00],[8.74,15.27,15.27],[14.34,8.64,15.42],[15.44,7.67,15.25],[15.17,6.53,14.28],[16.09,5.70,14.04],[15.68,7.10,16.68],[13.97,6.50,13.74],[13.51,5.39,12.88],[13.31,5.85,11.45],[13.73,6.93,11.03],[12.27,4.77,13.50],[12.54,4.30,14.92],[11.98,4.85,15.89],[13.41,3.30,15.02],[12.70,4.97,10.75]] print len(radii), len(coords) import blur out= blur.getBoundingBox(coords, radii, -2.344) assert len(out) == 2 assert len(out[0]) == 3 assert len(out[1]) == 3 print out import numpy.oldnumeric as Numeric weights = Numeric.ones(len(radii), typecode = "f") data = blur.generateBlurmap(coords, radii, [16,16,16], -2.344, weights) #weights is an optional argument assert len(data) == 3 assert len(data[1]) == 3 assert len(data[2]) == 3 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/blur.i0000644000175000017500000003551311165234135023624 0ustar debiandebian%module blur %feature ("kwargs"); %init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #ifdef _MSC_VER #include #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif #include "numpy/arrayobject.h" static PyObject* l_output_helper2(PyObject* target, PyObject* o) { PyObject* o2; PyObject* o3; if (!target) { target = o; } else if (target == Py_None) { Py_DECREF(Py_None); target = o; } else { if (!PyList_Check(target)) { o2 = target; target = PyList_New(0); PyList_Append(target, o2); Py_XDECREF(o2); } PyList_Append(target,o); Py_XDECREF(o); } return target; } static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} %{ #include #include #include #include #include #define ELECTRON_DENSITY 0 float evalDensityInverse(float radius, float epsilon, int kernelType, double blobbyness) { if (kernelType == 0) return radius * (float)sqrt(1.0 + log(epsilon) / blobbyness); else if (kernelType == 1) return (float)sqrt(radius*radius+log(epsilon)/blobbyness); else // this should crash { assert(kernelType != kernelType); return 0.0; } } void getBoundingBox(float coords[][3], float radii[], int na, float min[3], float max[3], double blobbyness, float padding) { int i, j; float maxRad=0.0; // use a fixed epsilon to avoid the growing bounding box problem // (1/10,000 should be sufficient) float epsilon = 1.0e-4; if(na == 0) { // no atoms for(i = 0; i < 3; i++) { min[i] = max[i] = 0.0; } return; } for(i = 0; i < 3; i++) { min[i] = coords[0][i]; max[i] = coords[0][i]; } maxRad = evalDensityInverse(radii[0], epsilon, 1, blobbyness); //printf ("maxRad in getBoundingBox: %.2f\n", maxRad); for(j = 1; j < na; j++) { for(i = 0; i < 3; i++) { if(coords[j][i] < min[i]) min[i] = coords[j][i]; if(coords[j][i] > max[i]) max[i] = coords[j][i]; } float tempRad = evalDensityInverse(radii[j], epsilon, 1, blobbyness); //if (j<20) // printf("j = %d, tempRad = %.2f\n", j, tempRad); if (maxRad < tempRad) maxRad = tempRad; } // adjust the bounding box by 1 for(i = 0; i < 3; i++) { min[i] -= maxRad; max[i] += maxRad; if (padding > 0) { min[i] -= padding; max[i] += padding; } } } float evalDensity(float position[3], float radius, float pnt[3], double maxRadius, int densityType, int hydrophobicity, double blobby) { // Gaussian approximation //return 1.0; //printf("[%.3f, %.3f, %.3f], r=%.2f, pnt:[%.3f, %.3f, %.3f], mr=%.2f, b=%.2f, dt=%d", position[0],position[1], position[2],radius, pnt[0], pnt[1],pnt[2], maxRadius, blobby, densityType); double r = (position[0]-pnt[0])*(position[0]-pnt[0]) + (position[1]-pnt[1])*(position[1]-pnt[1]) + (position[2]-pnt[2])*(position[2]-pnt[2]); double r0 = radius; r0 *= r0; //double expval = blobby*r/r0 - blobby; //double expval = blobby*r - blobby*r0; double expval = blobby*((r/r0) - 1); // truncated gaussian //if (sqrt(r) > maxRadius) // return 0.0; //printf ("r0=%.2f, ex=%.2f\n", r0, expval); float res; if( densityType == ELECTRON_DENSITY ) res = (float)(exp(expval)); //return (float)(exp(expval)); else // hydrophobicity res = (float)(hydrophobicity*exp(expval)); //return (float)(hydrophobicity*exp(expval)); //printf ("%.4f,", res); return res; } void generateBlurmap(float coords[][3], float radii[], int dlen, float *dens, int dim[3], double blobbyness, float orig[3], float span[3], float weights[]=NULL, float gridMove[3]=NULL,float padding=0.0) { float min[3],max[3], epsilon; unsigned int gdim[3]; gdim[0] = dim[0]; gdim[1] = dim[1]; gdim[2] = dim[2]; //float *dens = new float[dimx*dimy*dimz]; epsilon = 1.0e-3; // compute the bounding box min[0] = min[1] = min[2] = 0.; max[0] = max[1] = max[2] = 0.; // getBoundingBox(coords, radii, dlen, min, max, epsilon, blobbyness); getBoundingBox(coords, radii, dlen, min, max, blobbyness, padding); //printf("bounding box: (%f,%f,%f)->(%f,%f,%f)\n", min[0],min[1],min[2], // max[0],max[1],max[2]); // blur //float *maxDens=0; //float orig[3],span[3]; unsigned int zoff=0, i, c1; //printf("epsilon = %f\n", epsilon); orig[0] = min[0]; //vol->getMinX(); orig[1] = min[1]; //vol->getMinY(); orig[2] = min[2]; //vol->getMinZ(); if (gridMove) // apply grid move { orig[0] += gridMove[0]; orig[1] += gridMove[1]; orig[2] += gridMove[2]; } // and span span[0] = (max[0] - min[0]) / (float)(dim[0]-1); //vol->getSpanX(); span[1] = (max[1] - min[1]) / (float)(dim[1]-1); //vol->getSpanY(); span[2] = (max[2] - min[2]) / (float)(dim[2]-1); //vol->getSpanZ(); //printf("origin: %.2f, %.2f, %.2f \n", orig[0], orig[1], orig[2]); //printf("span: %.2f, %.2f, %.2f \n", span[0], span[1], span[2]); // main blurring loop c1 = dim[0]*dim[1]; for (i=0; i < dlen; i++) { //PDBParser::Atom *at = atoms[i]; int hydrophobe=0; double c[3], maxRad, r0; unsigned int amax[3],amin[3], j,k,l, c2; //if (densityType != ELECTRON_DENSITY) //hydrophobe = lookUpHydrophobicity(*at); // calculate the maximum radius for this atom //maxRad = evalDensityInverse(at->getRadius(), epsilon, 1); maxRad = evalDensityInverse(radii[i], epsilon, 1, blobbyness); // compute the dataset coordinates of the atom's center for (j=0; j < 3; j++) { c[j] = (coords[i][j] - orig[j]) / span[j]; c[j] = ((c[j]-floor(c[j])) >= 0.5) ? ceil(c[j]) : floor(c[j]); } // then compute the bounding box of the atom (maxRad^3) for (j=0; j < 3; j++) { int tmp; tmp = (int)(c[j] - (maxRad / span[j]) - 1); tmp = (tmp < 0) ? 0 : tmp; amin[j] = (unsigned int)tmp; //amax[j] = (int)(c[j] + (maxRad / span[j]) + 1); //amax[j] = (amax[j] > gdim[j]) ? gdim[j] : amax[j]; tmp = (int)(c[j] + (maxRad / span[j]) + 1); tmp = (tmp > gdim[j]) ? gdim[j] : tmp; amax[j] = (unsigned int)tmp; } //if (i<40) // printf("bbox = (%d,%d,%d)\n", amax[0]-amin[0],amax[1]-amin[1],amax[2]-amin[2]); //printf("blur atom %d: (%u,%u,%u)->(%u,%u,%u)\n",i, // amin[0],amin[1],amin[2], // amax[0],amax[1],amax[2]); // begin blurring kernel for(l = amin[2]; l < amax[2]; l++) { for(k = amin[1]; k < amax[1]; k++) { c2 = k*dim[0]; for(j = amin[0]; j < amax[0]; j++) { int n = j + c2 + (l-zoff)*c1; //int n = j + k*dim[0] + (l-zoff)*dim[0]*dim[1]; float pnt[3], density; pnt[0] = orig[0] + j*span[0]; pnt[1] = orig[1] + k*span[1]; pnt[2] = orig[2] + l*span[2]; // calculate the electron density / hydrophobicity density = evalDensity( coords[i], radii[i], pnt, maxRad, ELECTRON_DENSITY, hydrophobe, blobbyness); // scaling density by weights if (weights){ density *= weights[i]; } // sum up on a grid point dens[n] += density; } } } // end blurring kernel // status message /**** if (((i+1) % 20) == 0 || (i+1) == dlen) { printf("%2.2f%% done (%012d)\r", 100.0*(i+1)/(float)dlen, i+1); fflush(stdout); } ***/ } // end of status line //printf("\n"); fflush(stdout); //printf ("Done\n"); } %} // Typemaps for generateBlurmap() // typemap to input the list of dimensions and ignore float *dens argument %typemap(in) (float *dens, int dim[3]) %{ int i, datasize, temp[3]; PyObject *o; if (!PyList_Check($input)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } if (PySequence_Length($input) != 3) { PyErr_SetString(PyExc_ValueError,"Size mismatch. Expected 3 elements"); return NULL; } for (i = 0; i < 3; i++) { o = PyList_GetItem($input,i); if (PyNumber_Check(o)) temp[i] = (int) PyInt_AsLong(o); else { PyErr_SetString(PyExc_ValueError,"Sequence elements must be numbers"); return NULL; } } datasize= temp[0]*temp[1]*temp[2]; //allocate memory for data array - 'float *dens' //$1 = (float *) malloc(datasize*sizeof(float *)); $1 = (float *) calloc( datasize, sizeof(float *)); $2 = temp; %} //typemap to output the data array - dens %typemap(argout ) float *dens %{ PyArrayObject * out; npy_intp dims[1]; dims[0] = datasize; out = (PyArrayObject *)PyArray_SimpleNewFromData(1, dims, PyArray_FLOAT, (char *)$1); //out = (PyArrayObject *)PyArray_FromDimsAndData(3, temp, PyArray_FLOAT, (char *)$1); if (!out) { PyErr_SetString(PyExc_RuntimeError, "Failed to allocate memory for normals"); return NULL; } #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: out->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected out->flags |= NPY_OWNDATA; #endif //$result = Py_BuildValue("O", (PyObject *)out) ; $result = l_output_helper2($result, (PyObject *)out); %} // typemap to input an array of radii %typemap(in) (float radii[1], int dlen) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (float radii[1], int dlen) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} // typemap to input an array of weights (it should have the same length as radii) %typemap(default) float weights[1] %{ PyArrayObject *weightsarr=NULL; // have to make weightsarr local variable and use it in "freearg" typemap - // SWIG does not apply $argnum correctly in this case. %} %typemap(in) float weights[1] (int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; weightsarr= contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! weightsarr) return NULL; $1 = (float *)weightsarr->data; } else { weightsarr = NULL; $1 = NULL; } %} %typemap(freearg) (float weights[1]) %{ if (weightsarr) Py_DECREF((PyObject *)weightsarr); %} //typemap to input an array of coords %typemap(in) float coords[1][3](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) float coords[1][3] %{ if (array$argnum ) Py_DECREF((PyObject *)array$argnum); %} // typemaps to ignore 'float orig[3]' and 'float span[3]' arguments %typemap(in, numinputs=0) float OUT[3] %{ $1 = (float *) malloc(sizeof(float)*3); %} // typemaps to output 'orig' and 'span' lists. %typemap(argout) float OUT[3](float element, int i, PyObject * res) %{ res = PyTuple_New(3); for (i=0; i<3; i++) { element = $1[i]; PyTuple_SetItem(res ,i, PyFloat_FromDouble((double)element)); } $result = l_output_helper2($result, res); %} %typemap(freearg) float OUT[3] %{ free($1); %} %typemap(default) float gridMove[3] %{ // have to make gridMoveVect a local variable and use it in "freearg" typemap - // SWIG does not apply $argnum correctly in this case. PyArrayObject *gridMoveVect=NULL; %} %typemap(in) float gridMove[3](int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0]=3; gridMoveVect = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (!gridMoveVect ) return NULL; $1 = (float *)gridMoveVect->data; } else { gridMoveVect = NULL; $1 = NULL; } %} %typemap(freearg) float gridMove[3] %{ if (gridMoveVect) Py_DECREF((PyObject *)gridMoveVect); %} %apply float OUT[3] { float orig[3], float span[3], float min[3], float max[3]}; void generateBlurmap(float coords[1][3], float radii[1], int dlen, float *dens, int dim[3], double blobbyness, float orig[3], float span[3], float weights[1]=NULL, float gridMove[3]=NULL, float padding=0.0); void getBoundingBox(float coords[1][3], float radii[1], int dlen, float min[3], float max[3], double blobbyness, float padding=0.0); /*** from Python interface the function is called as follows: import blurr #coords - array(n, 3) of xyz coodinates # radii - array(n) data, origin, span = blur.generateBlurmap(coords, radii, [dimx, dimy,dimz], blobbyness) ***/ %include elementInfo.i mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/Blur-license.txt0000644000175000017500000000615610334442651025575 0ustar debiandebianTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 1. This software is the copyright of THE UNIVERSITY OF TEXAS AT AUSTIN, 2005. 2. The software is available under multiple licenses. 3. For non commercial educational and non commercial academic use, the software including source code, interface definitions and compile scripts are freely available. Any distribution of code, library or executables which contains any modules from this software should contain, conspicously and appropriately, on each copy, this copyright and license notice and should be freely distributed. 4. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation. 5. For any other purpose, including commercial purposes, please contact The University of Texas at Austin for a different license. 6. Credits: This software has been developed at the Computational and Visualization center under Dr Chandrajit Bajaj, Computational Applied Mathematics Chair in Visualization, Professor of Computer Sciences, Director of Center for Computational Visualization, Department of Computer Sciences & The Institute of Computational Engineering and Sciences , Center for Computational Visualization, 201 East 24th Street, ACES 2.324A, 1 University Station, C0200, Austin, TX 78712-0027. We request that you agree to acknowledge the use of the software that results in any published work, including scientific papers, films and videotapes by citing the references listed below C. Bajaj, V. Siddavanahalli Fast Feature Adaptive Surfaces and Derivatives Computation for Volumetric Particle Data ICES and CS technical reports, The University of Texas at Austin, 2005. 7. No warranty 7a. Because the library is licensed free of charge, there is no warranty for the library, to the extent permitted by applicable law. except when otherwise stated in writing the copyright holders and/or other parties provide the library "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. the entire risk as to the quality and performance of the library is with you. should the library prove defective, you assume the cost of all necessary servicing, repair or correction. 7b. In no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute the library as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use the library (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the library to operate with any other software), even if such holder or other party has been advised of the possibility of such damages. END OF TERMS AND CONDITIONS mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/elementInfo.i0000644000175000017500000002037710216112742025122 0ustar debiandebian//insert Python code into blur.py %insert("shadow") %{ elementTable = { "N:GLY" : (1.625, 0.0, 0.0, 1.0, 1, 10 ), "CA:GLY" : (1.750, 0.3, 0.3, 0.3, -1, 10 ), "C:GLY" : (1.875, 0.3, 0.3, 0.3, 1, 10 ), "O:GLY" : (1.480, 1.0, 0.0, 0.0, 1, 10 ), "N:ALA" : (1.625, 0.0, 0.0, 1.0, 1, 1 ), "CA:ALA" : (1.750, 0.3, 0.3, 0.3, -1, 1 ), "C:ALA" : (1.875, 0.3, 0.3, 0.3, 1, 1 ), "O:ALA" : (1.480, 1.0, 0.0, 0.0, 1, 1 ), "CB:ALA" : (1.750, 0.3, 0.3, 0.3, -1, 1 ), "N:VAL" : (1.625, 0.0, 0.0, 1.0, 1, 23 ), "CA:VAL" : (1.750, 0.3, 0.3, 0.3, -1, 23 ), "C:VAL" : (1.875, 0.3, 0.3, 0.3, 1, 23 ), "O:VAL" : (1.480, 1.0, 0.0, 0.0, 1, 23 ), "CB:VAL" : (1.750, 0.3, 0.3, 0.3, -1, 23 ), "CG1:VAL": (1.750, 0.3, 0.3, 0.3, -1, 23 ), "CG2:VAL": (1.750, 0.3, 0.3, 0.3, -1, 23 ), "N:LEU" : (1.625, 0.0, 0.0, 1.0, 1, 13 ), "CA:LEU" : (1.750, 0.3, 0.3, 0.3, -1, 13 ), "C:LEU" : (1.875, 0.3, 0.3, 0.3, 1, 13 ), "O:LEU" : (1.480, 1.0, 0.0, 0.0, 1, 13 ), "CB:LEU" : (1.750, 0.3, 0.3, 0.3, -1, 13 ), "CG:LEU" : (1.750, 0.3, 0.3, 0.3, -1, 13 ), "CD1:LEU": (1.750, 0.3, 0.3, 0.3, -1, 13 ), "CD2:LEU": (1.750, 0.3, 0.3, 0.3, -1, 13 ), "N:ILE" : (1.625, 0.0, 0.0, 1.0, 1, 12 ), "CA:ILE" : (1.750, 0.3, 0.3, 0.3, -1, 12 ), "C:ILE" : (1.875, 0.3, 0.3, 0.3, 1, 12 ), "O:ILE" : (1.480, 1.0, 0.0, 0.0, 1, 12 ), "CB:ILE" : (1.750, 0.3, 0.3, 0.3, -1, 12 ), "CG1:ILE": (1.750, 0.3, 0.3, 0.3, -1, 12 ), "CG2:ILE": (1.750, 0.3, 0.3, 0.3, -1, 12 ), "CD1:ILE": (1.750, 0.3, 0.3, 0.3, -1, 12 ), "N:MET" : (1.625, 0.0, 0.0, 1.0, 1, 15 ), "CA:MET" : (1.750, 0.3, 0.3, 0.3, -1, 15 ), "C:MET" : (1.875, 0.3, 0.3, 0.3, 1, 15 ), "O:MET" : (1.480, 1.0, 0.0, 0.0, 1, 15 ), "CB:MET" : (1.750, 0.3, 0.3, 0.3, -1, 15 ), "CG:MET" : (1.750, 0.3, 0.3, 0.3, -1, 15 ), "SD:MET" : (1.775, 1.0, 1.0, 0.0, 1, 15 ), "CE:MET" : (1.750, 0.3, 0.3, 0.3, -1, 15 ), "N:PRO" : (1.625, 0.0, 0.0, 1.0, -1, 17 ), "CA:PRO" : (1.750, 0.3, 0.3, 0.3, -1, 17 ), "C:PRO" : (1.875, 0.3, 0.3, 0.3, 1, 17 ), "O:PRO" : (1.480, 1.0, 0.0, 0.0, 1, 17 ), "CB:PRO" : (1.750, 0.3, 0.3, 0.3, -1, 17 ), "CG:PRO" : (1.750, 0.3, 0.3, 0.3, -1, 17 ), "CD:PRO" : (1.750, 0.3, 0.3, 0.3, -1, 17 ), "N:PHE" : (1.625, 0.0, 0.0, 1.0, 1, 16 ), "CA:PHE" : (1.750, 0.3, 0.3, 0.3, -1, 16 ), "C:PHE" : (1.875, 0.3, 0.3, 0.3, 1, 16 ), "O:PHE" : (1.480, 1.0, 0.0, 0.0, 1, 16 ), "CB:PHE" : (1.750, 0.3, 0.3, 0.3, -1, 16 ), "CG:PHE" : (1.775, 0.3, 0.3, 0.3, -1, 16 ), "CD1:PHE": (1.775, 0.3, 0.3, 0.3, -1, 16 ), "CD2:PHE": (1.775, 0.3, 0.3, 0.3, -1, 16 ), "CE1:PHE": (1.775, 0.3, 0.3, 0.3, -1, 16 ), "CE2:PHE": (1.775, 0.3, 0.3, 0.3, -1, 16 ), "CZ:PHE" : (1.775, 0.3, 0.3, 0.3, -1, 16 ), "N:TRP" : (1.625, 0.0, 0.0, 1.0, 1, 20 ), "CA:TRP" : (1.750, 0.3, 0.3, 0.3, -1, 20 ), "C:TRP" : (1.875, 0.3, 0.3, 0.3, 1, 20 ), "O:TRP" : (1.480, 1.0, 0.0, 0.0, 1, 20 ), "CB:TRP" : (1.750, 0.3, 0.3, 0.3, -1, 20 ), "CG:TRP" : (1.775, 0.3, 0.3, 0.3, -1, 20 ), "CD1:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "CD2:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "NE1:TRP": (1.625, 0.2, 0.2, 1.0, 1, 20 ), "CE2:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "CE3:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "CZ2:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "CZ3:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "CH2:TRP": (1.775, 0.3, 0.3, 0.3, -1, 20 ), "N:SER" : (1.625, 0.0, 0.0, 1.0, 1, 18 ), "CA:SER" : (1.750, 0.3, 0.3, 0.3, -1, 18 ), "C:SER" : (1.875, 0.3, 0.3, 0.3, 1, 18 ), "O:SER" : (1.480, 1.0, 0.0, 0.0, 1, 18 ), "CB:SER" : (1.750, 0.3, 0.3, 0.3, -1, 18 ), "OG:SER" : (1.560, 1.0, 0.0, 0.0, 1, 18 ), "N:THR" : (1.625, 0.0, 0.0, 1.0, 1, 19 ), "CA:THR" : (1.750, 0.3, 0.3, 0.3, -1, 19 ), "C:THR" : (1.875, 0.3, 0.3, 0.3, 1, 19 ), "O:THR" : (1.480, 1.0, 0.0, 0.0, 1, 19 ), "CB:THR" : (1.750, 0.3, 0.3, 0.3, -1, 19 ), "OG1:THR": (1.560, 1.0, 0.0, 0.0, 1, 19 ), "CG2:THR": (1.750, 0.3, 0.3, 0.3, -1, 19 ), "N:ASN" : (1.625, 0.0, 0.0, 1.0, 1, 3 ), "CA:ASN" : (1.750, 0.3, 0.3, 0.3, -1, 3 ), "C:ASN" : (1.875, 0.3, 0.3, 0.3, 1, 3 ), "O:ASN" : (1.480, 1.0, 0.0, 0.0, 1, 3 ), "CB:ASN" : (1.750, 0.3, 0.3, 0.3, -1, 3 ), "CG:ASN" : (1.875, 0.3, 0.3, 0.3, 1, 3 ), "OD1:ASN": (1.480, 1.0, 0.0, 0.0, 1, 3 ), "ND2:ASN": (1.625, 0.2, 0.2, 1.0, 1, 3 ), "N:GLN" : (1.625, 0.0, 0.0, 1.0, 1, 7 ), "CA:GLN" : (1.750, 0.3, 0.3, 0.3, -1, 7 ), "C:GLN" : (1.875, 0.3, 0.3, 0.3, 1, 7 ), "O:GLN" : (1.480, 1.0, 0.0, 0.0, 1, 7 ), "CB:GLN" : (1.750, 0.3, 0.3, 0.3, -1, 7 ), "CG:GLN" : (1.750, 0.3, 0.3, 0.3, -1, 7 ), "CD:GLN" : (1.875, 0.3, 0.3, 0.3, 1, 7 ), "OE1:GLN": (1.480, 1.0, 0.0, 0.0, 1, 7 ), "NE2:GLN": (1.625, 0.2, 0.2, 1.0, 1, 7 ), "N:TYR" : (1.625, 0.0, 0.0, 1.0, 1, 21 ), "CA:TYR" : (1.750, 0.3, 0.3, 0.3, -1, 21 ), "C:TYR" : (1.875, 0.3, 0.3, 0.3, 1, 21 ), "O:TYR" : (1.480, 1.0, 0.0, 0.0, 1, 21 ), "CB:TYR" : (1.750, 0.3, 0.3, 0.3, -1, 21 ), "CG:TYR" : (1.775, 0.3, 0.3, 0.3, -1, 21 ), "CD1:TYR": (1.775, 0.3, 0.3, 0.3, -1, 21 ), "CD2:TYR": (1.775, 0.3, 0.3, 0.3, -1, 21 ), "CE1:TYR": (1.775, 0.3, 0.3, 0.3, -1, 21 ), "CE2:TYR": (1.775, 0.3, 0.3, 0.3, -1, 21 ), "CZ:TYR" : (1.775, 0.3, 0.3, 0.3, -1, 21 ), "OH:TYR" : (1.535, 1.0, 0.0, 0.0, 1, 21 ), "N:CYS" : (1.625, 0.0, 0.0, 1.0, 1, 6 ), "CA:CYS" : (1.750, 0.3, 0.3, 0.3, -1, 6 ), "C:CYS" : (1.875, 0.3, 0.3, 0.3, 1, 6 ), "O:CYS" : (1.480, 1.0, 0.0, 0.0, 1, 6 ), "CB:CYS" : (1.750, 0.3, 0.3, 0.3, -1, 6 ), "SG:CYS" : (1.775, 1.0, 1.0, 0.0, 1, 6 ), "N:LYS" : (1.625, 0.0, 0.0, 1.0, 1, 14 ), "CA:LYS" : (1.750, 0.3, 0.3, 0.3, -1, 14 ), "C:LYS" : (1.875, 0.3, 0.3, 0.3, 1, 14 ), "O:LYS" : (1.480, 1.0, 0.0, 0.0, 1, 14 ), "CB:LYS" : (1.750, 0.3, 0.3, 0.3, -1, 14 ), "CG:LYS" : (1.750, 0.3, 0.3, 0.3, -1, 14 ), "CD:LYS" : (1.750, 0.3, 0.3, 0.3, -1, 14 ), "CE:LYS" : (1.750, 0.3, 0.3, 0.3, -1, 14 ), "NZ:LYS" : (1.625, 0.2, 0.2, 1.0, 1, 14 ), "N:ARG" : (1.625, 0.0, 0.0, 1.0, 1, 2 ), "CA:ARG" : (1.750, 0.3, 0.3, 0.3, -1, 2 ), "C:ARG" : (1.875, 0.3, 0.3, 0.3, 1, 2 ), "O:ARG" : (1.480, 1.0, 0.0, 0.0, 1, 2 ), "CB:ARG" : (1.750, 0.3, 0.3, 0.3, -1, 2 ), "CG:ARG" : (1.750, 0.3, 0.3, 0.3, -1, 2 ), "CD:ARG" : (1.750, 0.3, 0.3, 0.3, -1, 2 ), "NE:ARG" : (1.625, 0.2, 0.2, 1.0, 1, 2 ), "CZ:ARG" : (1.125, 0.3, 0.3, 0.3, 1, 2 ), "NH1:ARG": (1.625, 0.2, 0.2, 1.0, 1, 2 ), "NH2:ARG": (1.625, 0.2, 0.2, 1.0, 1, 2 ), "N:HIS" : (1.625, 0.0, 0.0, 1.0, 1, 11 ), "CA:HIS" : (1.750, 0.3, 0.3, 0.3, -1, 11 ), "C:HIS" : (1.875, 0.3, 0.3, 0.3, 1, 11 ), "O:HIS" : (1.480, 1.0, 0.0, 0.0, 1, 11 ), "CB:HIS" : (1.750, 0.3, 0.3, 0.3, -1, 11 ), "CG:HIS" : (1.775, 0.3, 0.3, 0.3, -1, 11 ), "ND1:HIS": (1.625, 0.2, 0.2, 1.0, 1, 11 ), "CD2:HIS": (1.775, 0.3, 0.3, 0.3, -1, 11 ), "CE1:HIS": (1.775, 0.3, 0.3, 0.3, 1, 11 ), "NE2:HIS": (1.625, 0.2, 0.2, 1.0, 1, 11 ), "N:ASP" : (1.625, 0.0, 0.0, 1.0, 1, 4 ), "CA:ASP" : (1.750, 0.3, 0.3, 0.3, -1, 4 ), "C:ASP" : (1.875, 0.3, 0.3, 0.3, 1, 4 ), "O:ASP" : (1.480, 1.0, 0.0, 0.0, 1, 4 ), "CB:ASP" : (1.750, 0.3, 0.3, 0.3, -1, 4 ), "CG:ASP" : (1.875, 0.3, 0.3, 0.3, 1, 4 ), "OD1:ASP": (1.480, 1.0, 1.0, 1.0, 1, 4 ), "OD2:ASP": (1.480, 1.0, 0.0, 0.0, 1, 4 ), "N:GLU" : (1.625, 0.0, 0.0, 1.0, 1, 8 ), "CA:GLU" : (1.750, 0.3, 0.3, 0.3, -1, 8 ), "C:GLU" : (1.875, 0.3, 0.3, 0.3, 1, 8 ), "O:GLU" : (1.480, 1.0, 0.0, 0.0, 1, 8 ), "CB:GLU" : (1.750, 0.3, 0.3, 0.3, -1, 8 ), "CG:GLU" : (1.750, 0.3, 0.3, 0.3, -1, 8 ), "CD:GLU" : (1.875, 0.3, 0.3, 0.3, 1, 8 ), "OE1:GLU": (1.480, 1.0, 0.0, 0.0, 1, 8 ), "OE2:GLU": (1.480, 1.0, 0.0, 0.0, 1, 8 ) } def getRadii(names): radii = [] for n in names: if elementTable.has_key(n): radii.append(elementTable[n][0]) else: radii.append(1.0) return radii %}mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/UTblur/__init__.py0000644000175000017500000000000210216112742024573 0ustar debiandebian# mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/README0000644000175000017500000000223510334444171022144 0ustar debiandebianThis package builds a python extension of the blurring algorithm (PDB Blurring) developed in Chandrajit Bajaj's group at UT Austin (http://ccvweb.csres.utexas.edu/software). Plese see UTblur/Blur-license.txt for license info. Distutils are used to build and install the extension. SWIG (version swig1.3.20 or higher) is used for generating wrappers. (Currently there is no way to specify the version of swig to be used by Distutils - the default version has to be 1.3.20 or the one that automatically generates python shadow classes). To build the extensions and install the package: python2.4 setup.py install This will: - build _blur.so and blur.py(python shadow classes) in ./build/lib./UTpackages/UTblur; - install the UTblur package in sys.exec_prefix/lib/python2.4/site-packages/UTpackages. To specify an installation directory (INSTALL_DIR): python2.4 setup.py install --install-platlib=INSTALL_DIR To build the extension only: python2.4 setup.py build This will create ./build directory and build the extension there. To build source distribution: python2.4 setup.py sdist To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTblurDIST/MANIFEST.in0000644000175000017500000000020110334444171023011 0ustar debiandebianinclude MANIFEST.in include UTblur/*.i include UTblur/Blur-license.txt exclude UTblur/blur.py include CVS/* include UTblur/CVS/* mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/0000755000175000017500000000000012146213774021702 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/multisdf/0000755000175000017500000000000012146213774023531 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/multisdf/__init__.py0000644000175000017500000000000011344301500025610 0ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/multisdf/sdf.i0000644000175000017500000003422011344301500024440 0ustar debiandebian%module multisdf %feature ("kwargs"); %init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #include "numpy/arrayobject.h" static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } #include "mesh_io.h" #include "mds.h" #include "sdf.h" #include "kdtree.h" #include "matrix.h" #include "dt.h" double BB_SCALE = 0.2; void make_labeled_mesh(Mesh &mesh, int nv, float* verts, int nf, int* faces, int *label) { int i; //cout << "nverts: " << nv << endl; mesh.set_nv(nv); mesh.set_nf(nf); for(i = 0; i < nv; i ++) { float x,y,z; x = verts[3*i+0]; y = verts[3*i+1]; z = verts[3*i+2]; mesh.vert_list.push_back(MVertex(Point(x,y,z))); mesh.vert_list[mesh.vert_list.size() - 1].id = i; mesh.vert_list[mesh.vert_list.size() - 1].set_iso(true); } int ne = 0; //cout << "nfaces: " << nf << endl; for (i = 0; i v3 is the ith edge. for(int i = 0; i < nf; i ++) { for(int j = 0; j < 3; j ++) { int u = mesh.face_list[i].get_corner((j+1)%3); int w = mesh.face_list[i].get_corner((j+2)%3); // find the edge id connecting u and w. int eid = -1; #ifndef NDEBUG assert(mesh.vert_list[u].get_eid(w, eid)); #else mesh.vert_list[u].get_eid(w, eid); #endif assert(eid != -1); // this edge should be the jth edge of the face. mesh.face_list[i].set_edge(j, eid); } } } void construct_bbox(const Mesh& mesh, vector& bbox) { double x_min = HUGE, x_max = -HUGE, y_min = HUGE, y_max = -HUGE, z_min = HUGE, z_max = -HUGE; for(int i = 0; i < mesh.get_nv(); i ++) { if( mesh.vert_list[i].iso() ) continue; Point p = mesh.vert_list[i].point(); // check x-span if(CGAL::to_double(p.x()) < x_min) x_min = CGAL::to_double(p.x()); if(CGAL::to_double(p.x()) > x_max) x_max = CGAL::to_double(p.x()); // check y-span if(CGAL::to_double(p.y()) < y_min) y_min = CGAL::to_double(p.y()); if(CGAL::to_double(p.y()) > y_max) y_max = CGAL::to_double(p.y()); // check z-span if(CGAL::to_double(p.z()) < z_min) z_min = CGAL::to_double(p.z()); if(CGAL::to_double(p.z()) > z_max) z_max = CGAL::to_double(p.z()); } //cout << "scale: " << BB_SCALE << endl; bbox.push_back(x_min - BB_SCALE*(x_max-x_min)); bbox.push_back(y_min - BB_SCALE*(y_max-y_min)); bbox.push_back(z_min - BB_SCALE*(z_max-z_min)); bbox.push_back(x_max + BB_SCALE*(x_max-x_min)); bbox.push_back(y_max + BB_SCALE*(y_max-y_min)); bbox.push_back(z_max + BB_SCALE*(z_max-z_min)); } void assign_sdf_weight(Mesh& mesh, vector& weights) { // map the color of each facet to a weight (scalar). // for the time being the information is in file called "weights". ifstream fin; fin.open("weights"); istream_iterator input(fin); istream_iterator beyond; double tw = 0; while(input != beyond) { tw += *input; weights.push_back(*input); input++; } for(int i = 0; i < (int)weights.size(); i ++) weights[i] /= tw; } float* computeSDF(int nverts, float* verts, int nfaces, int* faces, int*labels, int dimx, int dimy, int dimz, double maxval=-10, double minval=10) { Mesh mesh; cerr << "Creating input mesh "; make_labeled_mesh(mesh, nverts,verts, nfaces, faces, labels); cerr << "done." << endl; // build a bounding box around the input and store the // origin, span etc. vector bbox; bbox.clear(); construct_bbox(mesh, bbox); // construct a kd-tree of all the non-isolated mesh_vertices. vector points; vector pts; //cout << "mesh nv: " << mesh.get_nv() << endl; for(int i = 0; i < mesh.get_nv(); i ++) { if( mesh.vert_list[i].iso() ) continue; Point p = mesh.vert_list[i].point(); pts.push_back(p); points.push_back(VECTOR3(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(p.z()))); } KdTree kd_tree(points, 20); kd_tree.setNOfNeighbours(1); //Now perform a reconstruction to build a tetrahedralized solid // with in-out marked. Triangulation triang; recon(pts, triang); // assign weight to each triangle. vector weights; weights.clear(); // assign_sdf_weight(mesh, weights); // comment out for uniform weight. cerr << "SDF "; double xmin, ymin, zmin, xmax, ymax, zmax, x, y, z; xmin = bbox[0]; ymin = bbox[1]; zmin = bbox[2]; xmax = bbox[3]; ymax = bbox[4]; zmax = bbox[5]; double XSpan = (dimx-1 == 0) ? 0.0 : (xmax-xmin)/(dimx-1); double YSpan = (dimy-1 == 0) ? 0.0 : (ymax-ymin)/(dimy-1); double ZSpan = (dimz-1 == 0) ? 0.0 : (zmax-zmin)/(dimz-1); int ind, jj, kk; float* sdfValues = (float*)(malloc(sizeof(float)*dimx*dimy*dimz)); for(unsigned int k=0; kdimensions[0]; $2 = (float *)array->data; } else { array = NULL; $1 = 0; $2 = NULL; } %} %typemap(freearg) (int nverts, float* verts) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %typemap(in) (int nfaces, int* faces) (PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = 0; expected_dims[1] = 3; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = ((PyArrayObject *)(array))->dimensions[0]; $2 = (int *)array->data; } else { array = NULL; $1 = 0; $2 = NULL; } %} %typemap(freearg) (int nfaces, int* faces) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %typemap(in) (int* labels) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = 0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) ( int* labels) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %native(createNumArr)PyObject *Py_createNumArr(PyObject *self, PyObject *args); %{ static PyObject *Py_createNumArr(PyObject *self, PyObject *args) { PyObject * swigPt = 0 ; int size; npy_intp dim[1]; float *data; PyArrayObject *out; if(!PyArg_ParseTuple(args, "Oi", &swigPt, &size)) return NULL; //cout << "size: " << size << endl; dim[0] = (npy_intp)size; if (swigPt) { swig_type_info *ty = SWIG_TypeQuery("float *"); if ((SWIG_ConvertPtr(swigPt, (void **)&data, ty,1)) == -1) { printf("utsdf,createNumArr: failed to convert a pointer\n"); return NULL; } } //cout << "dim[0]: " << dim[0] << endl; out = (PyArrayObject *)PyArray_SimpleNewFromData(1, dim, PyArray_FLOAT, (char *) data); //cout << "array dims: " << out->dimensions[0] << endl; if (!out) { PyErr_SetString(PyExc_RuntimeError, "Failed to allocate memory for normals"); return NULL; } #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: out->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected out->flags |= NPY_OWNDATA; #endif return Py_BuildValue("O", (PyObject *)out); } %} extern double BB_SCALE; float* computeSDF(int nverts, float* verts, int nfaces, int* faces, int*labels, int dimx, int dimy, int dimz, double maxval=10, double minval=-10); mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/multisdf/test.py0000644000175000017500000006111711344301500025050 0ustar debiandebian import numpy import multisdf display = True verts = numpy.array([[ -6.35169935e+00, 1.71848381e+00, -1.25078166e+00], [ -5.99447060e+00, 1.76962197e+00, -1.34229076e+00], [ -5.40389919e+00, 1.53262198e+00, -1.51157653e+00], [ -5.98930502e+00, 1.24300659e+00, -5.87009370e-01], [ -6.34768152e+00, 1.30889404e+00, -6.63340569e-01], [ -5.39873362e+00, 1.00600660e+00, -7.56295085e-01], [ -4.88011312e+00, 2.27892351e+00, 1.83224154e+00], [ -4.28954172e+00, 2.04192376e+00, 1.66295588e+00], [ -5.10275507e+00, 2.47127390e+00, 2.06052113e+00], [ -4.84323072e+00, 3.10903239e+00, 2.07303739e+00], [ -3.95586777e+00, 2.86189866e+00, 1.67904818e+00], [ -4.54643917e+00, 3.09889865e+00, 1.84833384e+00], [ -4.31470585e+00, 4.01959705e+00, 1.36778319e+00], [ -3.72413445e+00, 3.78259706e+00, 1.19849753e+00], [ -3.37632680e+00, 3.86124229e+00, 1.08872020e+00], [ -3.39838433e+00, 4.33719301e+00, 3.45438570e-01], [ -3.75249410e+00, 4.39453411e+00, 2.42849588e-01], [ -4.34306526e+00, 4.63153410e+00, 4.12135303e-01], [ -4.55016088e+00, 4.71038198e+00, -4.20726359e-01], [ -3.95958972e+00, 4.47338200e+00, -5.90012074e-01], [ -4.84668064e+00, 4.91685247e+00, -5.09009361e-01], [ -5.16063118e+00, 4.62609816e+00, -1.19720232e+00], [ -4.36323977e+00, 4.09955502e+00, -1.47483158e+00], [ -4.95381117e+00, 4.33655500e+00, -1.30554581e+00], [ -5.24543238e+00, 3.87960124e+00, -1.68316257e+00], [ -4.65486097e+00, 3.64260125e+00, -1.85244834e+00], [ -4.49689198e+00, 3.42957878e+00, -2.11312652e+00], [ -4.92730141e+00, 2.42781091e+00, -2.21218061e+00], [ -5.20824480e+00, 2.35461402e+00, -1.97980380e+00], [ -5.79881620e+00, 2.59161401e+00, -1.81051803e+00], [ -6.17186213e+00, 1.75140464e+00, -1.28765368e+00], [ -6.69312763e+00, 2.31586266e+00, -1.44922912e+00], [ -7.17195559e+00, 2.75110936e+00, -1.14247215e+00], [ -7.50769520e+00, 2.76926565e+00, -5.10202706e-01], [ -7.50367832e+00, 2.35969734e+00, 7.72093162e-02], [ -7.16225719e+00, 1.76231778e+00, 2.75669515e-01], [ -6.68342972e+00, 1.32706285e+00, -3.10751759e-02], [ -6.16730499e+00, 1.28683460e+00, -6.21358991e-01], [ -6.43344975e+00, 2.53768039e+00, -1.59743750e+00], [ -7.04908562e+00, 3.09728360e+00, -1.20303571e+00], [ -7.48075151e+00, 3.12062740e+00, -3.90117735e-01], [ -7.47558641e+00, 2.59403920e+00, 3.65126252e-01], [ -7.03661633e+00, 1.82598007e+00, 6.20289445e-01], [ -6.42098045e+00, 1.26636648e+00, 2.25903347e-01], [ -5.28495646e+00, 8.54451180e-01, -1.47193015e-01], [ -5.09398603e+00, 8.96619499e-01, 4.59990531e-01], [ -4.84623432e+00, 1.12800467e+00, 1.00036037e+00], [ -4.56818008e+00, 1.52387607e+00, 1.41616237e+00], [ -5.87552786e+00, 1.09145117e+00, 2.20926963e-02], [ -5.68455744e+00, 1.13361955e+00, 6.29276276e-01], [ -5.43680573e+00, 1.36500466e+00, 1.16964614e+00], [ -5.15875149e+00, 1.76087606e+00, 1.58544815e+00], [ -4.71540689e+00, 2.29100990e+00, 1.78518307e+00], [ -4.43630791e+00, 2.97687101e+00, 1.79864335e+00], [ -3.55148077e+00, 3.81475306e+00, 1.13451469e+00], [ -3.14082313e+00, 2.95325637e+00, 1.37895155e+00], [ -2.46105599e+00, 2.48594284e+00, 7.62382686e-01], [ -2.18193436e+00, 2.72239423e+00, -2.00323954e-01], [ -2.50757480e+00, 3.48969817e+00, -8.05158794e-01], [ -3.19984126e+00, 4.22673941e+00, -6.09818459e-01], [ -3.57649827e+00, 4.35457420e+00, 2.91488826e-01], [ -2.92264009e+00, 3.21619964e+00, 1.22907352e+00], [ -2.39393234e+00, 2.85273337e+00, 7.49520063e-01], [ -2.17683792e+00, 3.03663993e+00, 7.48149119e-04], [ -2.43011379e+00, 3.63343191e+00, -4.69678968e-01], [ -2.96854305e+00, 4.20668602e+00, -3.17747772e-01], [ -4.43917656e+00, 4.62001371e+00, -5.33037901e-01], [ -4.77711868e+00, 4.30704021e+00, -1.27382183e+00], [ -4.57243013e+00, 3.52865410e+00, -1.97462285e+00], [ -3.68609452e+00, 3.75512099e+00, -1.76594651e+00], [ -2.95125127e+00, 3.10836244e+00, -1.74696302e+00], [ -2.93768239e+00, 2.13125849e+00, -1.80808771e+00], [ -3.65438724e+00, 1.47182965e+00, -1.90878248e+00], [ -4.62604332e+00, 1.56741095e+00, -1.98226607e+00], [ -5.06062317e+00, 2.39239693e+00, -2.08697510e+00], [ -3.74340701e+00, 3.51709414e+00, -2.04584718e+00], [ -3.17186213e+00, 3.01405978e+00, -2.03108239e+00], [ -3.16130829e+00, 2.25409007e+00, -2.07862377e+00], [ -3.71874547e+00, 1.74120069e+00, -2.15694189e+00], [ -4.47447824e+00, 1.81554151e+00, -2.21409583e+00], [ -5.62676096e+00, 3.29255152e+00, -1.86806536e+00], [ -4.79348087e+00, 2.97298455e+00, -2.25693965e+00], [ -5.79935980e+00, 4.13695478e+00, -1.55056918e+00], [ -6.61272240e+00, 4.17190218e+00, -1.16063535e+00], [ -6.93550682e+00, 4.42170238e+00, -3.55502129e-01], [ -6.58579874e+00, 4.74557304e+00, 4.11075175e-01], [ -5.76068354e+00, 4.96098804e+00, 7.07070708e-01], [ -4.92518187e+00, 4.94654417e+00, 3.65667939e-01], [ -5.81828022e+00, 4.47085333e+00, -1.38777590e+00], [ -6.45089531e+00, 4.49803495e+00, -1.08449399e+00], [ -6.70194960e+00, 4.69232368e+00, -4.58279222e-01], [ -6.42995453e+00, 4.94422340e+00, 1.37947485e-01], [ -5.78819847e+00, 5.11176825e+00, 3.68166149e-01], [ -5.13836384e+00, 5.10053396e+00, 1.02630526e-01], [ -4.88935041e+00, 3.95628762e+00, 1.78065467e+00], [ -5.73640537e+00, 4.31230021e+00, 1.66647601e+00], [ -6.58596087e+00, 3.95609736e+00, 1.57341683e+00], [ -6.93489218e+00, 3.09863091e+00, 1.55658877e+00], [ -6.57655239e+00, 2.24771047e+00, 1.62595761e+00], [ -5.72316122e+00, 1.90726924e+00, 1.74044216e+00], [ -5.10993958e+00, 3.77589035e+00, 2.02039814e+00], [ -5.76876020e+00, 4.05278921e+00, 1.93159246e+00], [ -6.42952538e+00, 3.77574229e+00, 1.85921311e+00], [ -6.70091629e+00, 3.10882401e+00, 1.84612465e+00], [ -6.42220736e+00, 2.44699717e+00, 1.90007818e+00], [ -5.75845861e+00, 2.18220949e+00, 1.98912168e+00], [ -6.55912113e+00, 2.42897081e+00, -1.51273918e+00], [ -7.10222292e+00, 2.92264199e+00, -1.16480541e+00], [ -7.48303032e+00, 2.94323540e+00, -4.47665006e-01], [ -7.47847366e+00, 2.47868943e+00, 2.18596578e-01], [ -7.09122276e+00, 1.80112243e+00, 4.43696529e-01], [ -6.54812098e+00, 1.30744231e+00, 9.57767218e-02], [ -3.03691196e+00, 3.08314943e+00, 1.29370236e+00], [ -2.43725467e+00, 2.67090821e+00, 7.49795437e-01], [ -2.19102740e+00, 2.87949419e+00, -9.94573608e-02], [ -2.47829151e+00, 3.55637217e+00, -6.33012950e-01], [ -3.08897519e+00, 4.20655346e+00, -4.60693270e-01], [ -3.71778822e+00, 3.62791848e+00, -1.89831126e+00], [ -3.06951261e+00, 3.05735064e+00, -1.88156414e+00], [ -3.05754232e+00, 2.19535351e+00, -1.93548810e+00], [ -3.68981647e+00, 1.61360800e+00, -2.02432060e+00], [ -4.54700756e+00, 1.69792950e+00, -2.08914757e+00], [ -6.96899986e+00, 1.45586574e+00, -5.94785035e-01], [ -6.96899986e+00, 1.77244890e+00, -1.08739805e+00], [ -7.40823030e+00, 1.85299993e+00, -3.02000046e-01], [ -7.40823030e+00, 2.15300012e+00, -8.21615338e-01], [ -4.92896605e+00, 4.56303453e+00, 1.28530204e+00], [ -5.54699993e+00, 4.71447754e+00, 1.24364018e+00], [ -6.16503382e+00, 4.56303453e+00, 1.28530192e+00], [ -6.16503382e+00, 1.38914168e+00, 1.02230573e+00], [ -6.16503382e+00, 2.90492558e+00, -1.77861631e+00], [ -6.16503382e+00, 3.52894235e+00, -1.72690856e+00], [ -6.72257042e+00, 4.55686855e+00, 7.36194789e-01], [ -6.72257042e+00, 4.20612288e+00, 1.26112282e+00], [ -6.72257042e+00, 1.91787720e+00, 1.26112282e+00], [ -6.72257042e+00, 3.68119502e+00, -1.37786841e+00], [ -7.16503429e+00, 4.23757029e+00, 1.16999999e-01], [ -7.16503429e+00, 4.08007383e+00, 7.04785168e-01], [ -7.16503429e+00, 3.64978528e+00, 1.13507378e+00], [ -7.16503429e+00, 3.06200004e+00, 1.29257035e+00], [ -7.16503429e+00, 2.47421479e+00, 1.13507378e+00], [ -7.16503429e+00, 3.64978456e+00, -9.01074171e-01], [ -7.16503429e+00, 4.08007336e+00, -4.70785916e-01], [ -7.44911289e+00, 3.68003368e+00, 1.16999999e-01], [ -7.44911289e+00, 3.37101674e+00, 6.52232766e-01], [ -2.26688719e+00, 1.89096606e+00, -2.78000057e-01], [ -2.26688719e+00, 2.19998312e+00, -8.13233197e-01], [ -2.55096626e+00, 1.92121482e+00, 7.40073919e-01], [ -2.55096626e+00, 1.49092615e+00, 3.09785306e-01], [ -2.55096626e+00, 1.33342957e+00, -2.77999818e-01], [ -2.55096626e+00, 1.49092603e+00, -8.65785003e-01], [ -2.55096626e+00, 1.92121446e+00, -1.29607368e+00], [ -2.55096626e+00, 2.50899959e+00, -1.45357049e+00], [ -2.55096626e+00, 3.09678459e+00, -1.29607427e+00], [ -2.99342966e+00, 1.88980508e+00, 1.21686840e+00], [ -2.99342966e+00, 1.36487722e+00, 8.66122842e-01], [ -2.99342966e+00, 1.01413167e+00, 3.41194928e-01], [ -2.99342966e+00, 8.90966058e-01, -2.77999759e-01], [ -2.99342966e+00, 1.01413143e+00, -8.97194445e-01], [ -2.99342966e+00, 1.36487687e+00, -1.42212248e+00], [ -2.99342966e+00, 3.65312338e+00, -1.42212248e+00], [ -3.55096626e+00, 2.35192490e+00, 1.61761642e+00], [ -3.55096626e+00, 1.74493003e+00, 1.46390450e+00], [ -3.55096626e+00, 1.22073400e+00, 1.12143016e+00], [ -3.55096626e+00, 8.36141586e-01, 6.27305806e-01], [ -3.55096626e+00, 6.32829309e-01, 3.50775719e-02], [ -3.55096626e+00, 6.32829309e-01, -5.91077447e-01], [ -3.55096626e+00, 8.36141467e-01, -1.18330574e+00], [ -3.55096626e+00, 1.22073388e+00, -1.67743003e+00], [ -3.55096626e+00, 4.01003599e+00, -1.44630039e+00], [ -3.55096626e+00, 4.30805206e+00, -8.95612657e-01], [ -4.16900015e+00, 1.50899994e+00, 1.45405078e+00], [ -4.16900015e+00, 1.04289615e+00, 1.08234537e+00], [ -4.16900015e+00, 7.07062244e-01, 5.89767218e-01], [ -4.16900015e+00, 5.31338334e-01, 2.00841725e-02], [ -4.16900015e+00, 5.31338453e-01, -5.76084971e-01], [ -4.16900015e+00, 7.07062602e-01, -1.14576793e+00], [ -4.16900015e+00, 1.04289675e+00, -1.63834596e+00], [ -4.78703403e+00, 6.32829428e-01, 3.50775719e-02], [ -4.78703403e+00, 6.32829428e-01, -5.91077447e-01], [ -4.78703403e+00, 8.36141586e-01, -1.18330562e+00], [ -4.78703403e+00, 1.22073400e+00, -1.67742991e+00], [ -5.68100023e+00, 3.77667785e+00, 2.20158076e+00], [ -5.68100023e+00, 3.23964405e+00, 2.40525055e+00], [ -5.68100023e+00, 2.66947412e+00, 2.33601952e+00], [ -6.28100014e+00, 3.52671194e+00, 2.15931726e+00], [ -6.28100014e+00, 2.94710231e+00, 2.24265265e+00], [ -2.32576942e+00, 3.76000023e+00, 1.15000002e-01], [ -2.32576942e+00, 3.46000004e+00, 6.34615302e-01], [ -2.76500010e+00, 4.19923067e+00, 1.15000002e-01], [ -2.76500010e+00, 4.03425646e+00, 6.76850438e-01], [ -2.76500010e+00, 3.59171224e+00, 1.06031740e+00], [ -5.68200016e+00, 5.29300022e+00, -2.56999999e-01], [ -5.68200016e+00, 4.77467775e+00, -1.24458051e+00], [ -5.68200016e+00, 5.15554762e+00, -8.14667344e-01], [ -6.28200006e+00, 5.13223028e+00, -2.56999999e-01], [ -6.28200006e+00, 4.96725607e+00, -8.18850935e-01], [ -3.47900009e+00, 2.43110180e+00, -2.40565252e+00], [ -3.47900009e+00, 3.01071167e+00, -2.32231760e+00], [ -4.07900000e+00, 2.15347385e+00, -2.49901938e+00], [ -4.07900000e+00, 2.72364402e+00, -2.56825066e+00], [ -4.07900000e+00, 3.26067805e+00, -2.36458039e+00]], "f") faces = numpy.array([[ 2, 0, 30], [ 2, 30, 1], [ 5, 3, 37], [ 5, 37, 4], [ 0, 31, 30], [ 30, 31, 106], [ 30, 106, 1], [ 1, 106, 38], [ 31, 32, 106], [106, 32, 107], [106, 107, 38], [ 38, 107, 39], [ 32, 33, 107], [107, 33, 108], [107, 108, 39], [ 39, 108, 40], [ 33, 34, 108], [108, 34, 109], [108, 109, 40], [ 40, 109, 41], [ 34, 35, 109], [109, 35, 110], [109, 110, 41], [ 41, 110, 42], [ 35, 36, 110], [110, 36, 111], [110, 111, 42], [ 42, 111, 43], [ 36, 4, 111], [111, 4, 37], [111, 37, 43], [ 43, 37, 3], [ 4, 0, 5], [ 5, 0, 2], [ 8, 6, 52], [ 52, 6, 7], [ 5, 44, 3], [ 3, 44, 48], [ 44, 45, 48], [ 48, 45, 49], [ 45, 46, 49], [ 49, 46, 50], [ 46, 47, 50], [ 50, 47, 51], [ 47, 7, 51], [ 51, 7, 6], [ 11, 9, 53], [ 11, 53, 10], [ 7, 10, 52], [ 52, 10, 53], [ 52, 53, 8], [ 8, 53, 9], [ 14, 12, 54], [ 54, 12, 13], [ 10, 13, 11], [ 11, 13, 12], [ 17, 15, 60], [ 17, 60, 16], [ 13, 55, 54], [ 54, 55, 112], [ 54, 112, 14], [ 14, 112, 61], [ 55, 56, 112], [112, 56, 113], [112, 113, 61], [ 61, 113, 62], [ 56, 57, 113], [113, 57, 114], [113, 114, 62], [ 62, 114, 63], [ 57, 58, 114], [114, 58, 115], [114, 115, 63], [ 63, 115, 64], [ 58, 59, 115], [115, 59, 116], [115, 116, 64], [ 64, 116, 65], [ 59, 16, 116], [116, 16, 60], [116, 60, 65], [ 65, 60, 15], [ 20, 18, 66], [ 66, 18, 19], [ 16, 19, 17], [ 17, 19, 18], [ 23, 21, 67], [ 23, 67, 22], [ 19, 22, 66], [ 66, 22, 67], [ 66, 67, 20], [ 20, 67, 21], [ 26, 24, 68], [ 68, 24, 25], [ 22, 25, 23], [ 23, 25, 24], [ 29, 27, 74], [ 29, 74, 28], [ 25, 69, 68], [ 68, 69, 117], [ 68, 117, 26], [ 26, 117, 75], [ 69, 70, 117], [117, 70, 118], [117, 118, 75], [ 75, 118, 76], [ 70, 71, 118], [118, 71, 119], [118, 119, 76], [ 76, 119, 77], [ 71, 72, 119], [119, 72, 120], [119, 120, 77], [ 77, 120, 78], [ 72, 73, 120], [120, 73, 121], [120, 121, 78], [ 78, 121, 79], [ 73, 28, 121], [121, 28, 74], [121, 74, 79], [ 79, 74, 27], [ 28, 2, 29], [ 29, 2, 1], [ 29, 80, 27], [ 27, 80, 81], [ 80, 24, 81], [ 81, 24, 26], [ 23, 82, 21], [ 21, 82, 88], [ 82, 83, 88], [ 88, 83, 89], [ 83, 84, 89], [ 89, 84, 90], [ 84, 85, 90], [ 90, 85, 91], [ 85, 86, 91], [ 91, 86, 92], [ 86, 87, 92], [ 92, 87, 93], [ 87, 18, 93], [ 93, 18, 20], [ 17, 12, 15], [ 15, 12, 14], [ 11, 94, 9], [ 9, 94, 100], [ 94, 95, 100], [100, 95, 101], [ 95, 96, 101], [101, 96, 102], [ 96, 97, 102], [102, 97, 103], [ 97, 98, 103], [103, 98, 104], [ 98, 99, 104], [104, 99, 105], [ 99, 6, 105], [105, 6, 8], [122, 124, 125], [123, 122, 125], [123, 125, 31], [123, 31, 0], [123, 0, 4], [123, 4, 122], [122, 4, 36], [122, 36, 124], [124, 36, 35], [124, 35, 34], [124, 34, 125], [125, 34, 33], [125, 33, 32], [125, 32, 31], [128, 132, 133], [132, 136, 137], [133, 132, 137], [133, 137, 138], [137, 136, 143], [137, 143, 144], [138, 137, 144], [139, 138, 144], [136, 142, 143], [143, 142, 40], [143, 40, 144], [144, 40, 41], [144, 41, 140], [144, 140, 139], [139, 140, 97], [139, 97, 138], [138, 97, 96], [138, 96, 133], [133, 96, 128], [128, 96, 95], [128, 95, 127], [128, 127, 86], [128, 86, 85], [128, 85, 132], [132, 85, 136], [136, 85, 84], [136, 84, 142], [142, 84, 83], [142, 83, 141], [142, 141, 40], [ 40, 141, 39], [ 39, 141, 135], [ 39, 135, 130], [ 39, 130, 38], [ 38, 130, 29], [ 38, 29, 1], [ 29, 130, 80], [ 80, 130, 131], [ 80, 131, 82], [ 80, 82, 24], [ 24, 82, 23], [ 82, 131, 83], [ 83, 131, 135], [ 83, 135, 141], [135, 131, 130], [ 86, 127, 87], [ 87, 127, 126], [ 87, 126, 17], [ 87, 17, 18], [ 17, 126, 12], [ 12, 126, 94], [ 12, 94, 11], [ 94, 126, 95], [ 95, 126, 127], [ 97, 140, 98], [ 98, 140, 134], [ 98, 134, 99], [ 99, 134, 129], [ 99, 129, 50], [ 99, 50, 51], [ 99, 51, 6], [ 50, 129, 49], [ 49, 129, 43], [ 49, 43, 48], [ 48, 43, 3], [ 43, 129, 42], [ 42, 129, 134], [ 42, 134, 140], [ 42, 140, 41], [145, 148, 149], [145, 149, 150], [146, 145, 150], [146, 150, 151], [146, 151, 152], [147, 154, 155], [148, 147, 155], [148, 155, 156], [149, 148, 156], [149, 156, 157], [149, 157, 158], [150, 149, 158], [150, 158, 159], [151, 150, 159], [154, 161, 162], [154, 162, 163], [155, 154, 163], [155, 163, 164], [156, 155, 164], [156, 164, 165], [157, 156, 165], [157, 165, 166], [158, 157, 166], [158, 166, 167], [159, 158, 167], [159, 167, 168], [163, 162, 171], [163, 171, 172], [164, 163, 172], [164, 172, 173], [165, 164, 173], [165, 173, 174], [166, 165, 174], [166, 174, 175], [166, 175, 176], [167, 166, 176], [167, 176, 177], [168, 167, 177], [174, 173, 178], [174, 178, 179], [175, 174, 179], [176, 175, 179], [176, 179, 180], [177, 176, 180], [177, 180, 181], [177, 181, 73], [177, 73, 72], [177, 72, 168], [168, 72, 159], [159, 72, 71], [159, 71, 151], [151, 71, 152], [152, 71, 70], [152, 70, 153], [152, 153, 146], [146, 153, 57], [146, 57, 145], [145, 57, 56], [145, 56, 147], [145, 147, 148], [147, 56, 154], [154, 56, 55], [154, 55, 161], [161, 55, 10], [161, 10, 7], [161, 7, 162], [162, 7, 171], [171, 7, 47], [171, 47, 172], [172, 47, 46], [172, 46, 173], [173, 46, 45], [173, 45, 178], [178, 45, 44], [178, 44, 179], [179, 44, 5], [179, 5, 180], [180, 5, 2], [180, 2, 181], [181, 2, 73], [ 73, 2, 28], [ 10, 55, 13], [ 57, 153, 58], [ 58, 153, 160], [ 58, 160, 59], [ 59, 160, 170], [ 59, 170, 19], [ 59, 19, 16], [ 19, 170, 22], [ 22, 170, 169], [ 22, 169, 69], [ 22, 69, 25], [ 69, 169, 160], [ 69, 160, 70], [ 70, 160, 153], [160, 169, 170], [183, 182, 185], [183, 185, 186], [184, 183, 186], [184, 186, 104], [184, 104, 105], [184, 105, 8], [184, 8, 9], [184, 9, 183], [183, 9, 100], [183, 100, 182], [182, 100, 101], [182, 101, 185], [185, 101, 102], [185, 102, 103], [185, 103, 186], [186, 103, 104], [188, 187, 190], [188, 190, 191], [187, 189, 190], [190, 189, 15], [190, 15, 14], [190, 14, 191], [191, 14, 61], [191, 61, 62], [191, 62, 188], [188, 62, 63], [188, 63, 187], [187, 63, 64], [187, 64, 189], [189, 64, 65], [189, 65, 15], [194, 193, 196], [195, 194, 196], [192, 194, 195], [195, 196, 90], [195, 90, 91], [195, 91, 92], [195, 92, 192], [192, 92, 93], [192, 93, 20], [192, 20, 194], [194, 20, 21], [194, 21, 193], [193, 21, 88], [193, 88, 89], [193, 89, 196], [196, 89, 90], [197, 199, 200], [198, 197, 200], [198, 200, 201], [198, 201, 75], [198, 75, 76], [198, 76, 197], [197, 76, 77], [197, 77, 78], [197, 78, 199], [199, 78, 79], [199, 79, 27], [199, 27, 200], [200, 27, 81], [200, 81, 201], [201, 81, 26], [201, 26, 75]], 'i') labels = numpy.ones(len(faces), 'i') multisdf.BB_SCALE = BB_SCALE = 0.2 HUGE = 999999 def get_bbox(vert_list): bbox = [] x_min = HUGE; x_max = -HUGE y_min = HUGE; y_max = -HUGE z_min = HUGE; z_max = -HUGE for i in range(len(vert_list)): p = vert_list[i] #check x-span if p[0] < x_min: x_min = p[0] if p[0] > x_max: x_max = p[0] #check y-span if p[1] < y_min: y_min = p[1] if p[1] > y_max: y_max = p[1] #check z-span if p[2] < z_min: z_min = p[2] if p[2] > z_max: z_max = p[2] bbox.append(x_min - BB_SCALE*(x_max-x_min)) bbox.append(y_min - BB_SCALE*(y_max-y_min)) bbox.append(z_min - BB_SCALE*(z_max-z_min)) bbox.append(x_max + BB_SCALE*(x_max-x_min)) bbox.append(y_max + BB_SCALE*(y_max-y_min)) bbox.append(z_max + BB_SCALE*(z_max-z_min)) return bbox dimx = dimy = dimz = size = 32 datap = multisdf.computeSDF(verts, faces, labels, size, size, size) #datap = multisdf.computeSDF(verts, faces, labels, size, size, size) grid_size = size*size*size volarr = multisdf.createNumArr(datap, grid_size) print "data arr shape:", volarr.shape volarr.shape = (size, size, size) volarr = numpy.ascontiguousarray(numpy.transpose(volarr), 'f') bbox = get_bbox(verts) xmin = bbox[0]; ymin = bbox[1]; zmin = bbox[2] xmax = bbox[3]; ymax = bbox[4]; zmax = bbox[5] XSpan = (xmax-xmin)/(dimx-1) YSpan = (ymax-ymin)/(dimy-1) ZSpan = (zmax-zmin)/(dimz-1) inside = [] outside = [] for k in range(dimz): z = zmin + k*ZSpan for j in range(dimy): y = ymin + j*YSpan for i in range(dimx): val = volarr[i][j][k] x = xmin + i*XSpan #if val != 10: #vverts.append([x,y,z]) #labels.append("%.2f"%val) if val < 0: inside.append([x,y,z]) else: outside.append([x,y,z]) if display: from DejaVu.Viewer import Viewer vi = Viewer() from DejaVu.IndexedPolygons import IndexedPolygons obj = IndexedPolygons('obj', vertices=verts, faces=faces, inheritFrontPolyMode=False, frontPolyMode='line') vi.AddObject(obj) from DejaVu.Points import Points insideg = Points('inside', vertices=inside, materials=((0,1,0),), inheritMaterial=False, pointWidth=4) vi.AddObject(insideg) outsideg = Points('outside', vertices=outside, materials=((1,0,0),), inheritMaterial=False, pointWidth=4) vi.AddObject(outsideg) from DejaVu.Box import Box bb = Box("bb", cornerPoints = [[xmin, ymin, zmin],[xmax, ymax,zmax]]) vi.AddObject(bb) mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/setup.cfg0000644000175000017500000000003211344301500023476 0ustar debiandebian[build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/0000755000175000017500000000000012146213776022473 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/mds.h0000644000175000017500000001032711344301500023410 0ustar debiandebian#ifndef MDS_H #define MDS_H #include "datastruct.h" using namespace std; class MVertex { public: MVertex() { init(); } MVertex(const Point& p) : coord(p) { init(); } void set_point(const Point& p) { coord = p; } Point point() const { return coord; } void set_mesh_normal( const Vector& v) { mv_normal = v; } Vector mesh_normal() const { return mv_normal; } void set_iso(const bool& b) { mv_iso = b; } bool iso() const { return mv_iso; } void add_inc_vert(const int i) { inc_vert_list.push_back(i); num_inc_vert ++; } int inc_vert(int i) const { return inc_vert_list[i];} bool is_inc_vert(const int v) { for(int i = 0; i < num_inc_vert; i ++) if(inc_vert_list[i] == v) return true; return false; } void add_inc_edge(const int i) { inc_edge_list.push_back(i); num_inc_edge ++; } int inc_edge(int i) const { return inc_edge_list[i];} bool get_eid(const int v, int &eid) { eid = -1; assert(num_inc_vert == num_inc_edge); for(int i = 0; i < num_inc_vert; i ++) if(inc_vert_list[i] == v) { eid = inc_edge_list[i]; return true; } return false; } void add_inc_face(const int i) { inc_face_list.push_back(i); num_inc_face ++; } int inc_face(int i) const { return inc_face_list[i];} int id; bool visited; int num_inc_edge; int num_inc_vert; int num_inc_face; vector vert_color; inline void init() { id = -1; mv_normal = CGAL::NULL_VECTOR; mv_iso = true; num_inc_vert = 0; num_inc_edge = 0; num_inc_face = 0; inc_vert_list.clear(); inc_edge_list.clear(); inc_face_list.clear(); vert_color.resize(4,1); } private: Point coord; Vector mv_normal; bool mv_iso; vector inc_vert_list; vector inc_edge_list; vector inc_face_list; }; class MEdge { public: MEdge() { init(); } MEdge(const int v1, const int v2) { init(); endpoint[0] = v1; endpoint[1] = v2; } void set_endpoint(const int i, const int val) { endpoint[i] = val; } int get_endpoint(int i) const { return endpoint[i]; } void add_inc_face(const int fid) { inc_face[num_inc_face] = fid; num_inc_face ++; } void get_inc_face(int &f1, int& f2) { f1 = inc_face[0]; f2 = inc_face[1]; } int num_inc_face; inline void init() { endpoint[0] = endpoint[1] = -1; inc_face[0] = inc_face[1] = -1; num_inc_face = 0; } private: int endpoint[2]; int inc_face[2]; }; class MFace { public: MFace() { init(); } MFace(int v1, int v2, int v3) { init(); corner[0] = v1; corner[1] = v2; corner[2] = v3; } void set_corner(const int i, const int val) { corner[i] = val; } int get_corner(int i) const { return corner[i]; } void set_edge(const int i, const int val) { edge_array[i] = val; } int get_edge(int i) const { return edge_array[i]; } void set_color(const int i, const double c) { rgba[i] = c;} double get_color(int i) const { return rgba[i];} int id; int label; double w; inline void init() { corner[0] = corner[1] = corner[2] = -1; edge_array[0] = edge_array[1] = edge_array[2] = -1; rgba[0] = rgba[1] = rgba[2] = rgba[3] = 1; id = -1; label = -1; w = 1; } private: int corner[3]; int edge_array[3]; double rgba[4]; }; class Mesh { public: Mesh() { init(); } Mesh(int v, int f) { init(); nv = v; nf = f; } void set_nv(const int n) {nv = n;} int get_nv() const {return nv;} void set_nf(const int n) {nf = n;} int get_nf() const {return nf;} void set_ne(const int n) {ne = n;} int get_ne() const {return ne;} void add_vertex(MVertex v) {vert_list.push_back(v); } MVertex vertex(int i) const {return vert_list[i];} void add_face(const MFace f) {face_list.push_back(f); } MFace face(int i) const {return face_list[i];} vector vert_list; vector edge_list; vector face_list; inline void init() { nv = 0; nf = 0; ne = 0; vert_list.clear(); face_list.clear(); } private: int nv; int nf; int ne; }; #endif //MDS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/sdf.h0000644000175000017500000000044011344301500023374 0ustar debiandebian#ifndef SDF_H #define SDF_H #include "mds.h" #include "matrix.h" #include "kdtree.h" #include "util.h" float sdf( const Point& q, const Mesh &mesh, const vector& weights, KdTree& kd_tree, const Triangulation& triang, double maxval=10, double minval=-10); #endif // SDF_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/rcocone.C0000644000175000017500000002355211344301500024214 0ustar debiandebian #include "rcocone.h" // ------------------------- // initialize // ------------------------- // Initializes the attributes associated with the voronoi and // delaunay simplices // ------------------------- void compute_cell_radius(Triangulation &triang) { for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { double r = CGAL::to_double( (cit->voronoi() - cit->vertex(0)->point())* (cit->voronoi() - cit->vertex(0)->point()) ); if(isnan(r) || isinf(r)) { cerr << "cell radius nan or inf " << endl; cit->set_cell_radius(HUGE); } else if(r <= 0) cit->set_cell_radius(0); else cit->set_cell_radius(r); } } // ------------------------------ // mark_big_tetrahedral_balls // ------------------------------ // Mark the tetrahedra which have the circumspherical // balls quite big compared to the distance to the // nearest neighbor for every corner of the tetrahedron // ------------------------------ void mark_big_tetrahedral_balls(Triangulation &triang, const double &bb_ratio) { // find the nearest neighbor distance(nnd) for each vertex. // nnd(v) = average of distance to first three nearest neighbors. for(FEI eit = triang.finite_edges_begin(); eit != triang.finite_edges_end(); eit ++) { Cell_handle ch = (*eit).first; Vertex_handle u = ch->vertex((*eit).second); Vertex_handle v = ch->vertex((*eit).third); // find the length of the edge. double le = CGAL::to_double((u->point() - v->point())* (u->point() - v->point()) ); CGAL_assertion(le > 0); for(int i = 0; i < (int)u->nnd_vector.size(); i ++) { if(u->nnd_vector[i] < le) continue; // insert le into the ith position. double push_val = le; for(int j = i; j < (int)u->nnd_vector.size(); j ++) { double temp = u->nnd_vector[j]; u->nnd_vector[j] = push_val; push_val = temp; } break; } for(int i = 0; i < (int)v->nnd_vector.size(); i ++) { if(v->nnd_vector[i] < le) continue; // insert le into the ith position. double push_val = le; for(int j = i; j < (int)v->nnd_vector.size(); j ++) { double temp = v->nnd_vector[j]; v->nnd_vector[j] = push_val; push_val = temp; } break; } } // for each cell check if the circumradius is big compared to // the nnd of atleast one of its corners. for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { double r = cit->cell_radius(); for(int i = 0; i < 4; i ++) { double nnd = (1./3.)*(cit->vertex(i)->nnd_vector[0] + cit->vertex(i)->nnd_vector[1] + cit->vertex(i)->nnd_vector[2] ); // if the radius is sufficiently big i.e., // radius is bigger than a certain fraction of // the average nearest neighbor distance if(r > bb_ratio * nnd) cit->set_bb(true); } } } // ------------------------------- // identify_deep_intersection // ------------------------------- // Identify which two big balls really // intersect deeply. // ------------------------------- void identify_deep_intersection(Triangulation &triang, const double theta_ff, const double theta_if) { for(AFI fit = triang.all_facets_begin(); fit != triang.all_facets_end(); fit ++) { Cell_handle c[2]; int id[2]; c[0] = (*fit).first; id[0] = (*fit).second; c[1] = c[0]->neighbor(id[0]); id[1] = c[1]->index(c[0]); // there are three cases depending on whether the tetrahedra // are finite or infinite. // case 1 : both infinite .. not needed .. we assume they // all are outside, big and intersect deeply. if(triang.is_infinite(c[0]) && triang.is_infinite(c[1])) continue; // case 2 : one infinite and one finite. if(triang.is_infinite(c[0]) || triang.is_infinite(c[1])) { // assign c[0] the finite tetrahedron. if(triang.is_infinite(c[0])) { Cell_handle temp = c[0]; c[0] = c[1]; c[1] = temp; id[0] = c[0]->index(c[1]); id[1] = c[1]->index(c[0]); } CGAL_assertion(! triang.is_infinite(c[0]) && triang.is_infinite(c[1]) ); if(! c[0]->bb()) continue; Point p[4]; p[0] = c[0]->vertex(id[0])->point(); p[1] = c[0]->vertex((id[0]+1)%4)->point(); p[2] = c[0]->vertex((id[0]+2)%4)->point(); p[3] = c[0]->vertex((id[0]+3)%4)->point(); // if the cell is not flowing into the infinite cell // then the intersection is not deep. if(CGAL::orientation(p[1],p[2],p[3],p[0]) == CGAL::orientation(p[1],p[2],p[3],c[0]->voronoi())) continue; // check the deepness of the intersection. // let r_f = circumradius of the facet // r_t = circumradius of the tetrahedron // then sin(theta_current) = r_f/r_t. // so deep intersection <=> r_f/r_t < sin(theta). double r_f = sq_cr_tr_3(p[1],p[2],p[3]); double r_t = c[0]->cell_radius(); if(r_f/r_t < sin(theta_if)*sin(theta_if)) { c[0]->set_deep_int(id[0], true); c[1]->set_deep_int(id[1], true); } continue; } // case 3 : both finite. if(!c[0]->bb() || !c[1]->bb()) continue; // check if the circumscribing balls of the two cells // intersect deeply. // Let (p,r_p) and (q,r_q) be the two balls. // Check the expression : ||p-q||*||p-q|| - r_p*r_p - r_q*r_q. Point p = c[0]->voronoi(); Point q = c[1]->voronoi(); double r_p = c[0]->cell_radius(); double r_q = c[1]->cell_radius(); double d = CGAL::to_double((p-q)*(p-q)); // = ||p-q||*||p-q|| // we call an intersection deep when the angle made // is less than 60 degree. double r1 = (r_p > r_q) ? r_p : r_q; double r2 = r_p + r_q - r1; CGAL_assertion(r1 >= r2); // d <= r1 + r2 - 2*sqrt(r1*r2)*cos(theta). // when theta = 60 degree. // d <= r1 + r2 - sqrt(r1*r2). if(d <= r1 + r2 - 2*sqrt(r1*r2)*cos(theta_ff)) { c[0]->set_deep_int(id[0], true); c[1]->set_deep_int(id[1], true); } } } // ------------------------------- // walk // ------ // Walk among the cells to collect // the connected components. // ------------------------------- void walk(Triangulation &triang) { for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { cit->visited = false; if(triang.is_infinite(cit)) cit->outside = true; else cit->outside = false; } // start from a cell which has big circumscribing ball // and which is flowing into infinity. for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { if(cit->visited) continue; if(!cit->bb()) continue; bool start_flag = false; Cell_handle start_cell = cit; for(int i = 0; i < 4; i ++) { if(!triang.is_infinite(cit->neighbor(i))) continue; // so this cell has a face in the convex hull. // check if the circumscribing ball of the cell // intersects the infinite ball deeply. if(cit->deep_int(i)) start_flag = true; } if(! start_flag) continue; vector cell_stack; cell_stack.push_back(start_cell); start_cell->visited = true; while(!cell_stack.empty()) { Cell_handle c = cell_stack.back(); cell_stack.pop_back(); c->outside = true; // get the other neighboring cells into the stack. // restrictions : // 1. cell has to have big circumscribing balls. // 2. cell must not be visited already. // 3. deep_intersection flag has to be true. // 4. cell has to be finite. for(int i = 0; i < 4; i ++) { if(c->neighbor(i)->visited) continue; if(triang.is_infinite(c->neighbor(i))) continue; if(!c->neighbor(i)->bb()) continue; CGAL_assertion(c->deep_int(i) == c->neighbor(i)->deep_int(c->neighbor(i)->index(c))); if(!c->deep_int(i)) continue; cell_stack.push_back(c->neighbor(i)); c->neighbor(i)->visited = true; } } } for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { if(! cit->outside) { for(int i = 0; i < 4; i ++) { if(triang.is_infinite(cit->neighbor(i))) { cit->vertex((i+1)%4)->set_on_smooth_surface(true); cit->vertex((i+2)%4)->set_on_smooth_surface(true); cit->vertex((i+3)%4)->set_on_smooth_surface(true); } } continue; } for(int i = 0; i < 4; i ++) cit->vertex(i)->set_on_smooth_surface(true); } } // ------------------------------- // write_tcip // --------- // Write the points in the outside tetrahedron. // These will be input to tight cocone. // ------------------------------- void write_tcip(const Triangulation &triang, const char* file_prefix) { ofstream fout; char filename[100]; strcat(strcpy(filename, file_prefix), ".tcip"); fout.open(filename); if(!fout) { cerr << "can not open output file " << filename << endl; exit(1); } for(FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); vit ++) if(vit->on_smooth_surface()) fout << vit->point() << endl; } void robust_cocone(const double bb_ratio, const double theta_ff, const double theta_if, Triangulation &triang, const char *outfile_prefix) { // computation of cell radius. compute_cell_radius(triang); cerr << "."; // mark big balls. mark_big_tetrahedral_balls(triang, bb_ratio); cerr << "."; // identify deep intersection between the balls. identify_deep_intersection(triang, theta_ff, theta_if); cerr << "."; // walk among the cells to collect the components. walk(triang); cerr << "."; // write the points as input to the tight cocone. write_tcip(triang, outfile_prefix); cerr << "."; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/priorityqueue.h0000644000175000017500000001033111344301500025546 0ustar debiandebian#ifndef __PRIORITYQUEUE_H_ #define __PRIORITYQUEUE_H_ #include /** * Fix sized maximum priority queue */ template class MaxPriorityQueue { public: typedef struct el{ Index index; Weight weight; } Element; MaxPriorityQueue() { _queue = NULL; } ~MaxPriorityQueue() { if (_queue) { delete[] _queue; } } void setSize(int size) { if (_queue) { delete[] _queue; } _queue = new Element[size+1]; _nOfElements = size; init(); } inline void init() { _current = 0; } inline bool isEmpty() { return _current == 0; } inline bool isFull() { return _current==(_nOfElements); } inline int getNofElements() { return _current; } inline void insert(Index index, Weight weight) { if (isFull()) { // if full replace max _queue[1].index = index; _queue[1].weight = weight; restore(1, _nOfElements); } else { _current++; _queue[_current].index = index; _queue[_current].weight = weight; register int i=_current; while(i>1 && (_queue[i].weight > _queue[i>>1].weight)) { swap(&_queue[i], &_queue[i>>1]); i >>= 1; } } } inline Element getMax() { // ASSERT(!isEmpty()); return _queue[1]; } inline Index getMaxIndex() { // ASSERT(!isEmpty()); return _queue[1].index; } inline Weight getMaxWeight() { // ASSERT(!isEmpty()); return _queue[1].weight; } inline void removeMax() { // ASSERT(!isEmpty()); _queue[1] = _queue[_current]; restore(1, _current); _current--; } inline Element* getQueue() { return _queue+1; } protected: inline void restore(register int L, register int R) { register int i, j; i = L; while (i <= (R>>1)) { if( 2*i < R && _queue[2*i+1].weight > _queue[2*i].weight) { j = 2*i+1; } else { j = 2*i; } if (_queue[j].weight > _queue[i].weight) { swap(&_queue[j], &_queue[i]); swap(&i, &j); } else { i = R; } } } private: Element* _queue; int _nOfElements; int _current; inline void swap(Element* m1, Element* m2) { Element tmp; tmp = *m2; *m2 = *m1; *m1 = tmp; } inline void swap(int *i, int *j) { int tmp = *i; *i = *j; *j = tmp; } }; /** * Fix sized minimum priority queue */ template class MinPriorityQueue { public: typedef struct el{ Index index; Weight weight; } Element; MinPriorityQueue() { _queue = NULL; } ~MinPriorityQueue() { if (_queue) { delete[] _queue; } } void setSize(int size) { if (_queue) { delete[] _queue; } _queue = new Element[size+1]; _nOfElements = size; init(); } inline void init() { _current = 0; } inline bool isEmpty() { return _current == 0; } inline bool isFull() { return _current==(_nOfElements); } inline int getNofElements() { return _current; } inline void insert(Index index, Weight weight) { if (isFull()) { // if full replace max _queue[1].index = index; _queue[1].weight = weight; restore(1, _nOfElements); } else { _current++; _queue[_current].index = index; _queue[_current].weight = weight; register int i=_current; while(i>1 && (_queue[i].weight < _queue[i>>1].weight)) { swap(&_queue[i], &_queue[i>>1]); i >>= 1; } } } inline Element getMin() { ASSERT(!isEmpty()); return _queue[1]; } inline Index getMinIndex() { ASSERT(!isEmpty()); return _queue[1].index; } inline Weight getMinWeight() { ASSERT(!isEmpty()); return _queue[1].weight; } inline void removeMin() { ASSERT(!isEmpty()); _queue[1] = _queue[_current]; restore(1, _current); _current--; } inline Element* getQueue() { return _queue+1; } protected: inline void restore(register int L, register int R) { register int i, j; i = L; while (i <= (R>>1)) { if( 2*i < R && _queue[2*i+1].weight < _queue[2*i].weight) { j = 2*i+1; } else { j = 2*i; } if (_queue[j].weight < _queue[i].weight) { swap(&_queue[j], &_queue[i]); swap(&i, &j); } else { i = R; } } } private: Element* _queue; int _nOfElements; int _current; inline void swap(Element* m1, Element* m2) { Element tmp; tmp = *m2; *m2 = *m1; *m1 = tmp; } inline void swap(int *i, int *j) { int tmp = *i; *i = *j; *j = tmp; } }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/mesh_io.C0000644000175000017500000002317611344301500024211 0ustar debiandebian #include "mesh_io.h" // ------------------------ // read_mesh // ------------------------ void read_labeled_mesh(Mesh &mesh, const string& ip_filename, const FILE_TYPE& ftype, const bool& read_color_opacity, const bool& is_uniform) { FILE* fp = fopen(ip_filename.c_str(), "r"); char header[10]; switch(ftype) { case OFF: fscanf(fp, "%s", header); if( strcmp(header, "OFF") != 0 ) { cerr << "Error : Missing header OFF" << endl; exit(1); } break; case RAW: case RAWC: case RAWNC: break; default: break; }; int nv = -1, nf = -1; fscanf(fp, "%d %d", &nv, &nf); mesh.set_nv(nv); mesh.set_nf(nf); if( ftype == OFF ) { int skip_int = -1; fscanf(fp, "%d ", &skip_int); } for(int i = 0; i < nv; i ++) { float x,y,z; fscanf(fp, "%f %f %f", &x,&y,&z); float r=1,g=1,b=1; if(ftype == RAWC) fscanf(fp,"%f %f %f", &r,&g,&b); float nx,ny,nz; if(ftype == RAWNC) fscanf(fp,"%f %f %f %f %f %f", &nx,&ny,&nz,&r,&g,&b); mesh.vert_list.push_back(MVertex(Point(x,y,z))); mesh.vert_list[mesh.vert_list.size() - 1].id = i; mesh.vert_list[mesh.vert_list.size() - 1].set_iso(true); if( ftype == RAWC || ftype == RAWNC ) { mesh.vert_list[mesh.vert_list.size() - 1].vert_color[0] = r; mesh.vert_list[mesh.vert_list.size() - 1].vert_color[1] = g; mesh.vert_list[mesh.vert_list.size() - 1].vert_color[2] = b; } } int ne = 0; for(int i = 0; i < nf; i ++) { int np = -1, v1 = -1, v2 = -1, v3 = -1, label = -1; float r = 1, g = 1, b = 1, a = 1; if( ftype == OFF && read_color_opacity && ! is_uniform) fscanf(fp,"%d %d %d %d %f %f %f %f %d", &np, &v1, &v2, &v3, &r, &g, &b, &a, &label); else if( ftype == OFF && read_color_opacity ) fscanf(fp,"%d %d %d %d %f %f %f %f", &np, &v1, &v2, &v3, &r, &g, &b, &a); else if( ftype == OFF && ! is_uniform ) fscanf(fp,"%d %d %d %d %d", &np, &v1, &v2, &v3, &label); else if( ftype == OFF ) fscanf(fp,"%d %d %d %d", &np, &v1, &v2, &v3); else if( ! is_uniform ) fscanf(fp,"%d %d %d %d", &v1, &v2, &v3, &label); else fscanf(fp,"%d %d %d", &v1, &v2, &v3); if( ftype == OFF && np != 3 ) { cerr << endl << "Please check the file format. " << endl; cerr << "This program accepts OFF format with triangles plus weights." << endl; exit(1); } mesh.face_list.push_back(MFace(v1,v2,v3)); mesh.face_list[mesh.face_list.size() - 1].id = i; mesh.face_list[mesh.face_list.size() - 1].label = label; // mesh.face_list[mesh.face_list.size() - 1].label = a; // mesh.face_list[mesh.face_list.size() - 1].w = a; // mesh.face_list[mesh.face_list.size() - 1].w = 1; // add the incident faces in all three vertices. mesh.vert_list[v1].add_inc_face(i); mesh.vert_list[v1].set_iso(false); mesh.vert_list[v2].add_inc_face(i); mesh.vert_list[v2].set_iso(false); mesh.vert_list[v3].add_inc_face(i); mesh.vert_list[v3].set_iso(false); if( read_color_opacity ) { mesh.face_list[mesh.face_list.size() - 1].set_color(0, r); mesh.face_list[mesh.face_list.size() - 1].set_color(1, g); mesh.face_list[mesh.face_list.size() - 1].set_color(2, b); mesh.face_list[mesh.face_list.size() - 1].set_color(3, a); } // book keeping for incident vertices for a vertex. if(!mesh.vert_list[v1].is_inc_vert(v2)) { mesh.vert_list[v1].add_inc_vert(v2); assert(!mesh.vert_list[v2].is_inc_vert(v1)); mesh.vert_list[v2].add_inc_vert(v1); // here create an edge between v1 and v2. // add the face to the edge MEdge me = MEdge(v1,v2); me.add_inc_face(i); mesh.edge_list.push_back(me); ne ++; // insert the id of the incident edge in the vertices mesh.vert_list[v1].add_inc_edge(mesh.edge_list.size() - 1); mesh.vert_list[v2].add_inc_edge(mesh.edge_list.size() - 1); } else { // the edge is already there. // find the edge id using the vertex indices. MVertex mv = mesh.vert_list[v1]; int eid = -1; #ifndef NDEBUG assert(mv.get_eid(v2, eid)); #else mv.get_eid(v2, eid); #endif assert(eid != -1); // add the face to the edge. if(mesh.edge_list[eid].num_inc_face <= 1) { assert(mesh.edge_list[eid].num_inc_face == 1); mesh.edge_list[eid].add_inc_face(i); } else mesh.edge_list[eid].num_inc_face ++; // nonmanifold. } if(!mesh.vert_list[v2].is_inc_vert(v3)) { mesh.vert_list[v2].add_inc_vert(v3); assert(!mesh.vert_list[v3].is_inc_vert(v2)); mesh.vert_list[v3].add_inc_vert(v2); // here create an edge between v2 and v3. // add the face to the edge MEdge me = MEdge(v2,v3); me.add_inc_face(i); mesh.edge_list.push_back(me); ne ++; // insert the id of the incident edge in the vertices mesh.vert_list[v2].add_inc_edge(mesh.edge_list.size() - 1); mesh.vert_list[v3].add_inc_edge(mesh.edge_list.size() - 1); } else { // the edge is already there. // find the edge id using the vertex indices. MVertex mv = mesh.vert_list[v2]; int eid = -1; #ifndef NDEBUG assert(mv.get_eid(v3, eid)); #else mv.get_eid(v3, eid); #endif assert(eid != -1); // add the face to the edge. if(mesh.edge_list[eid].num_inc_face <= 1) { assert(mesh.edge_list[eid].num_inc_face == 1); mesh.edge_list[eid].add_inc_face(i); } else mesh.edge_list[eid].num_inc_face ++; // nonmanifold. } if(!mesh.vert_list[v3].is_inc_vert(v1)) { mesh.vert_list[v3].add_inc_vert(v1); assert(!mesh.vert_list[v1].is_inc_vert(v3)); mesh.vert_list[v1].add_inc_vert(v3); // here create an edge between v3 and v1. // add the face to the edge MEdge me = MEdge(v3,v1); me.add_inc_face(i); mesh.edge_list.push_back(me); ne ++; // insert the id of the incident edge in the vertices mesh.vert_list[v3].add_inc_edge(mesh.edge_list.size() - 1); mesh.vert_list[v1].add_inc_edge(mesh.edge_list.size() - 1); } else { // the edge is already there. // find the edge id using the vertex indices. MVertex mv = mesh.vert_list[v3]; int eid = -1; #ifndef NDEBUG assert(mv.get_eid(v1, eid)); #else mv.get_eid(v1, eid); #endif assert(eid != -1); // add the face to the edge. if(mesh.edge_list[eid].num_inc_face <= 1) { assert(mesh.edge_list[eid].num_inc_face == 1); mesh.edge_list[eid].add_inc_face(i); } else mesh.edge_list[eid].num_inc_face ++; // nonmanifold. } } fclose(fp); mesh.set_ne(ne); // add the edges in the face so that // if v1 is the ith corner of a face // then v2<->v3 is the ith edge. for(int i = 0; i < nf; i ++) { for(int j = 0; j < 3; j ++) { int u = mesh.face_list[i].get_corner((j+1)%3); int w = mesh.face_list[i].get_corner((j+2)%3); // find the edge id connecting u amd w. int eid = -1; #ifndef NDEBUG assert(mesh.vert_list[u].get_eid(w, eid)); #else mesh.vert_list[u].get_eid(w, eid); #endif assert(eid != -1); // this edge should be the jth edge of the face. mesh.face_list[i].set_edge(j, eid); } } } void write_mesh(const Mesh& mesh, const char* ofname, FILE_TYPE ftype, bool write_color_opacity, bool use_input_mesh_color, float r, float g, float b, float a) { ofstream fout; fout.open(ofname); if( ! fout ) { cerr << "Can not open " << ofname << " for writing." << endl; exit(0); } switch(ftype) { case OFF: fout << "OFF" << endl; fout << mesh.get_nv() << " " << mesh.get_nf() << " 0" << endl; break; case COFF: fout << "COFF" << endl; fout << mesh.get_nv() << " " << mesh.get_nf() << " 0" << endl; break; case RAW: case RAWN: case RAWC: case RAWNC: fout << mesh.get_nv() << " " << mesh.get_nf() << endl; break; case STL: break; default: break; }; for(int i = 0; i < mesh.get_nv(); i ++) { fout << mesh.vert_list[i].point() << " "; switch(ftype) { case OFF: fout << endl; break; case COFF: if( use_input_mesh_color ) fout << mesh.vert_list[i].vert_color[0] << " " << mesh.vert_list[i].vert_color[1] << " " << mesh.vert_list[i].vert_color[2] << " " << mesh.vert_list[i].vert_color[3] << endl; else fout << r << " " << g << " " << b << " " << a << endl; break; case RAW: fout << endl; break; case RAWN: fout << mesh.vert_list[i].mesh_normal() << endl; break; case RAWC: if( use_input_mesh_color ) fout << endl; else fout << r << " " << g << " " << b << endl; break; case RAWNC: fout << endl; break; default: break; }; } for(int i = 0; i < mesh.get_nf(); i ++) { if( ftype == OFF || ftype == COFF ) fout << "3\t"; fout << mesh.face_list[i].get_corner(0) << " " << mesh.face_list[i].get_corner(1) << " " << mesh.face_list[i].get_corner(2) << " "; if( ftype == OFF ) { if( write_color_opacity ) { if( use_input_mesh_color ) fout << mesh.face_list[i].get_color(0) << " " << mesh.face_list[i].get_color(1) << " " << mesh.face_list[i].get_color(2) << " " << mesh.face_list[i].get_color(3); else fout << r << " " << g << " " << b << " " << a; } } fout << endl; } fout.close(); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/op.h0000644000175000017500000000222111344301500023235 0ustar debiandebian#ifndef OP_H #define OP_H #include "datastruct.h" #include "util.h" void draw_ray(const Ray& ray, const double& r, const double& g, const double& b, const double& a, ofstream& fout); void draw_segment(const Segment& segment, const double& r, const double& g, const double& b, const double& a, ofstream& fout); void draw_poly(const vector& poly, const double& r, const double& g, const double& b, const double& a, ofstream& fout); void draw_VF(const Triangulation& triang, const Edge& dual_e, const double& r, const double& g, const double& b, const double& a, ofstream& fout); void draw_tetra(const Cell_handle& cell, const double& r, const double& g, const double& b, const double& a, ofstream& fout); void write_wt( const Triangulation &triang, const char* file_prefix); void write_iobdy( const Triangulation &triang, const char* file_prefix); #endif // OP_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/multi_sdf.pro0000644000175000017500000000150211344301500025157 0ustar debiandebianTEMPLATE = app LANGUAGE = C++ CONFIG += warn_off opengl link_prl console CONFIG -= qt LIBS += ../VolMagick/libVolMagick.a -lCGAL QMAKE_CXXFLAGS += $$(CPPFLAGS) QMAKE_LFLAGS += $$(LDFLAGS) # gmp #unix:LIBS += -lgmpxx linux-g++ { INCLUDEPATH += $(CGALINCLUDE) INCLUDEPATH += $(CGALCONFIG) } linux-g++-64 { INCLUDEPATH += $(CGALINCLUDE) INCLUDEPATH += $(CGALCONFIG) } INCLUDEPATH += /workspace/jgsun/usr/local/include \ /usr/include \ ../VolMagick HEADERS += SOURCES += main.C \ mesh_io.C \ sdf.C \ kdtree.C \ matrix.C \ dt.C \ init.C \ robust_cc.C \ rcocone.C \ tcocone.C \ op.C \ util.C \ TARGET += msdf contains( QMAKE_CXXFLAGS_RELEASE, -fno-exceptions ) { # have to enable exceptions QMAKE_CXXFLAGS_RELEASE += -fexceptions } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/init.h0000644000175000017500000000026711344301500023572 0ustar debiandebian#ifndef INIT_H #define INIT_H #include "datastruct.h" void initialize(Triangulation &triang); void compute_voronoi_vertex_and_cell_radius(Triangulation &triang); #endif // INIT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/Makefile0000644000175000017500000001067711344301500024124 0ustar debiandebian############################################################################# # Makefile for building: msdf # Generated by qmake (1.07a) (Qt 3.3.4) on: Fri Feb 12 13:42:59 2010 # Project: multi_sdf.pro # Template: app # Command: $(QMAKE) -o Makefile multi_sdf.pro ############################################################################# ####### Compiler, tools and options CC = gcc CXX = g++ LEX = flex YACC = yacc CFLAGS = -pipe -w -O2 #CXXFLAGS = -pipe -w -O2 CXXFLAGS = -pipe -w -O2 -fPIC LEXFLAGS = YACCFLAGS= -d CGAL_DIR = /mgl/devuser1/annao/CGAL/CGAL-3.1 #CGALPLATFORM=i686_Linux-2.4.21-27.0.2.EL_g++-3.2.3 CGALPLATFORM=x86-64_Linux-2.6.27.35-170.2.94.fc10.x86-64_g++-4.3.2 CGALINCLUDE= $(CGAL_DIR)/include CGALCONFIG = $(CGAL_DIR)/include/CGAL/config/$(CGALPLATFORM) CGAL_LIB = $(CGAL_DIR)/lib/$(CGALPLATFORM) INCPATH = -I/usr/local/mkspecs/default -I. -I$(CGALINCLUDE) -I$(CGALCONFIG) -I/usr/include -I../VolMagick -I/usr/X11R6/include -I/usr/X11R6/include LINK = g++ LFLAGS = LIBS = $(SUBLIBS) -L/usr/X11R6/lib -L/usr/X11R6/lib -L$(CGAL_LIB) ../VolMagick/libVolMagick.a -lCGAL -lGLU -lGL -lXmu -lXext -lX11 -lm AR = ar cqs RANLIB = MOC = $(QTDIR)/bin/moc UIC = $(QTDIR)/bin/uic QMAKE = qmake TAR = tar -cf GZIP = gzip -9f COPY = cp -f COPY_FILE= $(COPY) COPY_DIR = $(COPY) -r INSTALL_FILE= $(COPY_FILE) INSTALL_DIR = $(COPY_DIR) DEL_FILE = rm -f SYMLINK = ln -sf DEL_DIR = rmdir MOVE = mv -f CHK_DIR_EXISTS= test -d MKDIR = mkdir -p ####### Output directory OBJECTS_DIR = ./ ####### Files HEADERS = SOURCES = main.C \ mesh_io.C \ sdf.C \ kdtree.C \ matrix.C \ dt.C \ init.C \ robust_cc.C \ rcocone.C \ tcocone.C \ op.C \ util.C OBJECTS = main.o \ mesh_io.o \ sdf.o \ kdtree.o \ matrix.o \ dt.o \ init.o \ robust_cc.o \ rcocone.o \ tcocone.o \ op.o \ util.o FORMS = UICDECLS = UICIMPLS = SRCMOC = OBJMOC = DIST = multi_sdf.pro QMAKE_TARGET = msdf DESTDIR = TARGET = msdf first: all ####### Implicit rules .SUFFIXES: .c .o .cpp .cc .cxx .C .cpp.o: $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $< .cc.o: $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $< .cxx.o: $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $< .C.o: $(CXX) -c $(CXXFLAGS) $(INCPATH) -o $@ $< .c.o: $(CC) -c $(CFLAGS) $(INCPATH) -o $@ $< ####### Build rules staticlib: libSDF.a #all: Makefile $(TARGET) staticlib all: Makefile staticlib $(TARGET): $(UICDECLS) $(OBJECTS) $(OBJMOC) $(LINK) $(LFLAGS) -o $(TARGET) $(OBJECTS) $(OBJMOC) $(OBJCOMP) $(LIBS) libSDF.a : $(UICDECLS) $(OBJECTS) $(OBJMOC) $(OBJCOMP) $(AR) libSDF.a $(OBJECTS) $(OBJMOC) mocables: $(SRCMOC) uicables: $(UICDECLS) $(UICIMPLS) $(MOC): ( cd $(QTDIR)/src/moc && $(MAKE) ) #Makefile: multi_sdf.pro /usr/local/mkspecs/default/qmake.conf # $(QMAKE) -o Makefile multi_sdf.pro #qmake: # @$(QMAKE) -o Makefile multi_sdf.pro dist: @mkdir -p .tmp/msdf && $(COPY_FILE) --parents $(SOURCES) $(HEADERS) $(FORMS) $(DIST) .tmp/msdf/ && ( cd `dirname .tmp/msdf` && $(TAR) msdf.tar msdf && $(GZIP) msdf.tar ) && $(MOVE) `dirname .tmp/msdf`/msdf.tar.gz . && $(DEL_FILE) -r .tmp/msdf mocclean: uiclean: yaccclean: lexclean: clean: -$(DEL_FILE) $(OBJECTS) -$(DEL_FILE) *~ core *.core ####### Sub-libraries distclean: clean -$(DEL_FILE) $(TARGET) $(TARGET) FORCE: ####### Compile main.o: main.C mesh_io.h \ sdf.h \ kdtree.h \ matrix.h \ dt.h \ ../VolMagick/VolMagick.h \ ../VolMagick/VolumeCache.h \ ../VolMagick/endians.h \ mds.h \ datastruct.h \ util.h \ priorityqueue.h \ init.h \ rcocone.h \ tcocone.h \ robust_cc.h \ op.h \ ../VolMagick/Exceptions.h \ ../VolMagick/Dimension.h \ ../VolMagick/BoundingBox.h mesh_io.o: mesh_io.C mesh_io.h \ mds.h \ datastruct.h sdf.o: sdf.C sdf.h \ mds.h \ matrix.h \ kdtree.h \ util.h \ datastruct.h \ priorityqueue.h kdtree.o: kdtree.C kdtree.h \ priorityqueue.h \ matrix.h matrix.o: matrix.C matrix.h dt.o: dt.C dt.h \ datastruct.h \ init.h \ rcocone.h \ tcocone.h \ util.h \ robust_cc.h \ op.h \ mds.h init.o: init.C init.h \ robust_cc.h \ op.h \ datastruct.h \ util.h robust_cc.o: robust_cc.C robust_cc.h \ datastruct.h rcocone.o: rcocone.C rcocone.h \ datastruct.h \ util.h \ robust_cc.h tcocone.o: tcocone.C tcocone.h \ datastruct.h \ util.h \ robust_cc.h op.o: op.C op.h \ datastruct.h \ util.h util.o: util.C util.h \ datastruct.h ####### Install install: uninstall: mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/matrix.C0000644000175000017500000002733211344301500024070 0ustar debiandebian/////////////////////////////////////////////////////////////////// // Purpose: vector and matrix class and operations // Created by: Matt Camuto // // Modification: // Time Programmer // 07-09-99 R. Wenger // 07-15-00 J. Gao // 08-09-03 J. Sun /////////////////////////////////////////////////////////////////// #include "matrix.h" #include #include using namespace std; int Shift[32]; void init_shift() { Shift[0] = 1; for (int i=1; i<32; i++) { Shift[i] = 1<32)) return 0; if (value & Shift[pos-1]) { return 1; } return 0; } void set_bit(INT_32 &value, int pos){ if ((pos<1)||(pos>32)) return; value |= Shift[pos-1]; } //********************************************************* // // INT64 class definitions // //********************************************************* // Set the posth [1, 64] bit as 1 void INT_64::set_bit(int pos){ if ((pos<1)||(pos>64)) return; int flag = (pos>32)?1:0; int move = (pos-1)%32; //vec[flag] |= Shift[move]; if (move==0) vec[flag] |=1; else vec[flag] |= 1<64)) return 0; int flag = (pos>32)?1:0; int move = (pos-1)%32; int temp = 0; if (move==0) temp |=1; else temp |= 1< maxval) maxval = vec[1]; if (vec[2] > maxval) maxval = vec[2]; return maxval; } // make sure all dimension <=1.0 void VECTOR3::Clamp() { for (int i = 0; i < Dimension(); i++) if (vec[i]>1.0) vec[i] = 1.0; } //********************************************************* // // VECTOR4 class definitions // //********************************************************* // normalize vector // Assumes (pre-condition): vector != (0,0,0,0) void VECTOR4::Normalize() { double norm = sqrt(vec[0]*vec[0] + vec[1]*vec[1] + vec[2]*vec[2]); if(norm < 1e-10) return; for (int i = 0; i < Dimension(); i++) vec[i] = vec[i]/norm; } //********************************************************* // // MATRIX3 class definitions // //********************************************************* // set matrix to identity matrix void MATRIX3::Identity() { for (int i = 0; i < Dimension(); i++) { mat[i].Zero(); mat[i][i] = 1.0; }; } void MATRIX3::Zero() { for (int i = 0; i < Dimension(); i++) { mat[i].Zero(); }; } //********************************************************* // // MATRIX4 class definitions // //********************************************************* // set matrix to identity matrix void MATRIX4::Identity() { for (int i = 0; i < Dimension(); i++) { mat[i].Zero(); mat[i][i] = 1.0; }; } //************************ // MATRIX3 operations //************************ // return m0 + m1 MATRIX3 operator +(const MATRIX3 & m0, const MATRIX3 & m1) { MATRIX3 result; result[0] = m0(0) + m1(0); result[1] = m0(1) + m1(1); result[2] = m0(2) + m1(2); return(result); } // return m0 - m1 MATRIX3 operator -(const MATRIX3 & m0, const MATRIX3 & m1) { MATRIX3 result; result[0] = m0(0) - m1(0); result[1] = m0(1) - m1(1); result[2] = m0(2) - m1(2); return(result); } // return m0 * m1 MATRIX3 operator *(const MATRIX3 & m0, const MATRIX3 & m1) { MATRIX3 result; for (int i = 0; i < m0.Dimension(); i++) for (int j = 0; j < m0.Dimension(); j++) { result[i][j] = 0; for (int k = 0; k < m0.Dimension(); k++) result[i][j] += m0(i,k) * m1(k,j); }; return(result); } // return x0 * m0 MATRIX3 operator *(const double x0, const MATRIX3 & m0) { MATRIX3 result; result[0] = x0*m0(0); result[1] = x0*m0(1); result[2] = x0*m0(2); return(result); } // return m0 * x0 MATRIX3 operator *(const MATRIX3 & m0, const double x0) { return(x0*m0); }; // return m0 * v0 VECTOR3 operator *(const MATRIX3 & m0, const VECTOR3 & v0) { VECTOR3 result; result[0] = dot(m0(0),v0); result[1] = dot(m0(1),v0); result[2] = dot(m0(2),v0); return(result); } // return v0 * m0 VECTOR3 operator *(const VECTOR3 & v0, const MATRIX3 & m0) { VECTOR3 result; result[0] = v0(0)*m0(0,0) + v0(1)*m0(1,0) + v0(2)*m0(2,0); result[1] = v0(0)*m0(0,1) + v0(1)*m0(1,1) + v0(2)*m0(2,1); result[2] = v0(0)*m0(0,2) + v0(1)*m0(1,2) + v0(2)*m0(2,2); return(result); } //************************ // MATRIX4 operations //************************ // get the rotation matrix // type: 1:x, 2:y, 3:z MATRIX4 rotate_matrix(int type, double angle) { MATRIX4 rot_mat; switch(type) { case 1: // rotate by x { double anglex = (angle/180.0f)*3.14159f; double sinx = (double)sin((double)anglex); double cosx = (double)cos((double)anglex); rot_mat[1][1] = rot_mat[2][2] = cosx; rot_mat[1][2] = -sinx; rot_mat[2][1] = sinx; break; } case 2: // rotate by y { double angley = (angle/180.0f)*3.14159f; double siny = (double)sin((double)angley); double cosy = (double)cos((double)angley); rot_mat[0][0] = rot_mat[2][2] = cosy; rot_mat[0][2] = siny; rot_mat[2][0] = -siny; break; } case 3: // rotate by z { double anglez = (angle/180.0f)*3.14159f; double sinz = (double)sin((double)anglez); double cosz = (double)cos((double)anglez); rot_mat[0][0] = rot_mat[1][1] = cosz; rot_mat[0][1] = -sinz; rot_mat[1][0] = sinz; break; } } return rot_mat; } // get translation matrix MATRIX4 translate_matrix(double tx, double ty, double tz){ MATRIX4 translation_mat; translation_mat[0][3] = tx; translation_mat[1][3] = ty; translation_mat[2][3] = tz; return translation_mat; } // get scaling matrix MATRIX4 scale_matrix(double sx, double sy, double sz){ MATRIX4 scale_mat; scale_mat[0][0] = sx; scale_mat[1][1] = sy; scale_mat[2][2] = sz; return scale_mat; } // return m0 + m1 MATRIX4 operator +(const MATRIX4 & m0, const MATRIX4 & m1) { MATRIX4 result; result[0] = m0(0) + m1(0); result[1] = m0(1) + m1(1); result[2] = m0(2) + m1(2); result[3] = m0(3) + m1(3); return(result); } // return m0 - m1 MATRIX4 operator -(const MATRIX4 & m0, const MATRIX4 & m1) { MATRIX4 result; result[0] = m0(0) - m1(0); result[1] = m0(1) - m1(1); result[2] = m0(2) - m1(2); result[3] = m0(3) - m1(3); return(result); } // return m0 * m1 MATRIX4 operator *(const MATRIX4 & m0, const MATRIX4 & m1) { MATRIX4 result; for (int i = 0; i < m0.Dimension(); i++) for (int j = 0; j < m0.Dimension(); j++) { result[i][j] = 0; for (int k = 0; k < m0.Dimension(); k++) result[i][j] += m0(i,k) * m1(k,j); }; return(result); } // return x0 * m0 MATRIX4 operator *(const double x0, const MATRIX4 & m0) { MATRIX4 result; result[0] = x0*m0(0); result[1] = x0*m0(1); result[2] = x0*m0(2); result[3] = x0*m0(3); return(result); } // return m0 * x0 MATRIX4 operator *(const MATRIX4 & m0, const double x0) { return(x0*m0); }; // return m0 * v0 VECTOR4 operator *(const MATRIX4 & m0, const VECTOR4 & v0) { VECTOR4 result; result[0] = dot(m0(0),v0); result[1] = dot(m0(1),v0); result[2] = dot(m0(2),v0); result[3] = dot(m0(3),v0); return(result); } // return m0 * v0 VECTOR3 operator *(const MATRIX4 & m0, const VECTOR3 & v0) { VECTOR4 v(v0); VECTOR3 result; double temp = dot(m0(3),v); result[0] = dot(m0(0),v)/temp; result[1] = dot(m0(1),v)/temp; result[2] = dot(m0(2),v)/temp; return(result); } VECTOR4 operator *(const VECTOR4 & v0, const MATRIX4 & m0) // return v0 * m0 { VECTOR4 result; result[0] = v0(0)*m0(0,0) + v0(1)*m0(1,0) + v0(2)*m0(2,0) + v0(3)*m0(3,0); result[1] = v0(0)*m0(0,1) + v0(1)*m0(1,1) + v0(2)*m0(2,1) + v0(3)*m0(3,1); result[2] = v0(0)*m0(0,2) + v0(1)*m0(1,2) + v0(2)*m0(2,2) + v0(3)*m0(3,2); result[3] = v0(0)*m0(0,3) + v0(1)*m0(1,3) + v0(2)*m0(2,3) + v0(3)*m0(3,3); return(result); } VECTOR3 operator *(const VECTOR3 & v0, const MATRIX4 & m0) // return v0 * m0 { VECTOR3 result; double temp = v0(0)*m0(0,3) + v0(1)*m0(1,3) + v0(2)*m0(2,3) + m0(3,3); result[0] = (v0(0)*m0(0,0) + v0(1)*m0(1,0) + v0(2)*m0(2,0) + m0(3,0))/temp; result[1] = (v0(0)*m0(0,1) + v0(1)*m0(1,1) + v0(2)*m0(2,1) + m0(3,1))/temp; result[2] = (v0(0)*m0(0,2) + v0(1)*m0(1,2) + v0(2)*m0(2,2) + m0(3,2))/temp; return(result); } //Code was taken from the original 'edge' library written by dave ebert. MATRIX4 inverse(const MATRIX4 & m) { register int lp,i,j,k; static double wrk[4][8]; static double a, b; MATRIX4 result; for( i=0; i<4; i++ ) /* Set up matrices */ { for( j=0; j<4; j++ ) { wrk[i][j]=(double)m(i,j); wrk[i][j+4]=0.0; result[i][j] = 0.0; } wrk[i][i+4]=1.0; } for( lp=0; lp<4; lp++ ) /* Loop over all rows */ { a=0.0; j=(-1); for( i=lp; i<4; i++ ) /* Find largest non-zero element */ { b=wrk[i][lp]; if( b< 0.0 ) b=(-b); if( b>a ) { a=b; j=i; } } if( j!=lp ) /* If not on diagonal, put it there */ { if( j<0 ) /* Singular if none found */ return(result); else /* Exchange rows from lp to end */ for( k=lp; k<8; k++ ) { a=wrk[j][k]; wrk[j][k]=wrk[lp][k]; wrk[lp][k]=a; } } a=wrk[lp][lp]; /* Normalize working row */ for( i=lp; i<8; i++ ) wrk[lp][i]/=a; for( i=lp+1; i<8; i++ ) /* Adjust rest of work space */ { b=wrk[lp][i]; for( j=0; j<4; j++ ) /* One column at a time */ if( j!=lp ) wrk[j][i]-=wrk[j][lp]*b; } } for( i=0; i<4; i++ ) /* Return result matrix */ for( j=0; j<4; j++ ) result[i][j]=(double)wrk[i][j+4]; return(result); } //******************************* // output procedures/operators //******************************* // output vector ostream & operator<<(ostream & os, const VECTOR3 & v) { os << "( " << v(0) << " " << v(1) << " " << v(2) << " )"; return(os); } // output vector ostream & operator<<(ostream & os, const VECTOR4 & v) { os << "( " << v(0) << " " << v(1) << " " << v(2) << " " << v(3) << " )"; return(os); } // routine to print out matrix. Useful for debugging. // call at the beginning of a new line for proper formatting // mat = matrix // indent = # of indented spaces // cout_width = output field width // precision = output precision void print_matrix(const MATRIX3 & mat, const int indent, const int cout_width, const int precision) { cout.precision(precision); cout.flags(ios::fixed); for (int i = 0; i < mat.Dimension(); i++) { int j; for (j = 0; j < indent; j++) cout << " "; cout << "( "; for (j = 0; j < mat.Dimension(); j++) cout << setw(cout_width) << mat(i,j) << " "; cout << ")" << endl; }; } // routine to print out matrix. Useful for debugging. // call at the beginning of a new line for proper formatting // mat = matrix // indent = # of indented spaces // cout_width = output field width // precision = output precision void print_matrix(const MATRIX4 & mat, const int indent, const int cout_width, const int precision) { cout.precision(precision); cout.flags(ios::fixed); for (int i = 0; i < mat.Dimension(); i++) { int j; for (j = 0; j < indent; j++) cout << " "; cout << "( "; for (j = 0; j < mat.Dimension(); j++) cout << setw(cout_width) << mat(i,j) << " "; cout << ")" << endl; } } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/tcocone.C0000644000175000017500000016100111344301500024206 0ustar debiandebian #include "tcocone.h" // ------------------------------------ // Surface Reconstruction with boundary // ------------------------------------ // ----------------------------------------------------------------------- // compute_poles // ------------- // Computes and stores normals and poles in the triangulation. // ----------------------------------------------------------------------- void compute_poles( Triangulation &triang) { // Compute the center of mass of the sample points. Vector center_of_mass = CGAL::NULL_VECTOR; for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) center_of_mass = center_of_mass + (vit->point() - CGAL::ORIGIN); center_of_mass = (1./triang.number_of_vertices()) * center_of_mass; // Compute the normals. for ( FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); ++cit) { for ( int id = 0; id < 4; ++id) { // If the neighboring cell of *cit opposite to the vertex with // index id is infinite then all vertices of *cit different from // the vertex with index id are on the boundary of the convex hull. // For such vertices the normal is computed as the average of the // normals of the incident facets on the convex hull. if ( triang.is_infinite( cit->neighbor(id))) { Vector facet_normal = CGAL::cross_product( cit->vertex((id+2)%4)->point() - cit->vertex((id+1)%4)->point(), cit->vertex((id+3)%4)->point() - cit->vertex((id+1)%4)->point() ); // Normalize and choose a consistent orientation. This is // important for computing the average of facet normals of // facets incident to one vertex in a meaningful way. facet_normal = facet_normal / CGAL::sqrt( facet_normal.x() * facet_normal.x() + facet_normal.y() * facet_normal.y() + facet_normal.z() * facet_normal.z() ); if ( facet_normal * (cit->vertex((id+1)%4)->point() - (CGAL::ORIGIN + center_of_mass)) < 0) facet_normal = -facet_normal; // Add facet normal to all vertices of the facet opposite to // the vertex with index i. for ( int i = 1; i <= 3; ++i) { Vertex_handle vh = cit->vertex((id+i)%4); // Flatness marking shouldn't be done here!! if ( cosine( vh->normal(), facet_normal) < 0) { vh->set_flat( false); continue; } Vector new_normal = vh->normal() + facet_normal; new_normal = new_normal / CGAL::sqrt( new_normal.x() * new_normal.x() + new_normal.y() * new_normal.y() + new_normal.z() * new_normal.z() ); vh->set_normal( new_normal); } } // Update the normal at the vertex with index id if necessary. Vertex_handle vh = cit->vertex(id); if ( (! vh->on_convex_hull()) && (vh->normal() * vh->normal()) <= (cit->voronoi() - vh->point()) * (cit->voronoi() - vh->point())) vh->set_normal( cit->voronoi() - vh->point()); } } //BE // Added for CGAL2.3 in which the poles cannot be initialised properly for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit){ vit->set_pole(vit->point()); } //ED // Compute the poles. for ( FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); ++cit) { for ( int id = 0; id < 4; ++id) { Vertex_handle vh = cit->vertex(id); Vector old_pole = vh->pole() - vh->point(); Vector new_pole = vh->point() - cit->voronoi(); if ( (CGAL::to_double(old_pole*old_pole) < CGAL::to_double(new_pole*new_pole)) && ((cit->voronoi() - vh->point()) * vh->normal() < 0) ) vh->set_pole( cit->voronoi()); } } } // ----------------------------------------------------------------------- // mark_flat_vertices // ------------------ // Computes and marks flat vertices in the triangulation. // ----------------------------------------------------------------------- void mark_flat_vertices( Triangulation &triang, double ratio, double cocone_phi, double flat_phi) { double min_cos = cos( M_PI / 2.0 + cocone_phi); // Bounds for the co-cone. double max_cos = cos( M_PI / 2.0 - cocone_phi); CGAL_assertion( min_cos < max_cos); // Compute the center of mass of the sample points. Vector center_of_mass = CGAL::NULL_VECTOR; for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) center_of_mass = center_of_mass + (vit->point() - CGAL::ORIGIN); center_of_mass = (1./triang.number_of_vertices()) * center_of_mass ; // Compute the coccone width, i.e. the diameter of the copolygon // which is the largest distance of the sample point to a vertex // of the copolygon. To do so iterate over the Voronoi edges which // means iterating over their duals, i.e. the Delaunay facets. for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; // A finite facet must be incident to at least one finite cell. if ( triang.is_infinite( ch)) { Cell_handle c = ch; ch = ch->neighbor(id); id = ch->index( c); } CGAL_assertion( ! triang.is_infinite( ch)); // Compute the facet normal or the Voronoi edge respectively. Vector facet_normal; if ( triang.is_infinite( ch->neighbor(id))) { facet_normal = CGAL::cross_product( ch->vertex((id+1)%4)->point() - ch->vertex((id+2)%4)->point(), ch->vertex((id+1)%4)->point() - ch->vertex((id+3)%4)->point() ); // Ensure that the orientation is correct. if ( facet_normal * (ch->vertex((id+1)%4)->point() - (CGAL::ORIGIN + center_of_mass)) < 0) facet_normal = -facet_normal; } else // Facet normal connects to Voronoi vertices. facet_normal = ch->neighbor(id)->voronoi() - ch->voronoi(); // Update the width of co-cones of the vertices incident to the facet // if necessary, i.e. if there is a co-polygon neighbor with larger // distance to the vertex. for ( int i = 1; i < 4; ++i) { Vertex_handle vh = ch->vertex((id+i)%4); double cos1 = cosine( ch->voronoi() - vh->point(), vh->normal()); // If the facet is not on the convex hull, i.e. ch->neighbor(id) // is not infinite, then the second cosine is computed using the // normal vector at the vertex *vh and the the vector from the // point vh->point() to the Voronoi vertex of neighboring cell. double cos2 = ( triang.is_infinite( ch->neighbor(id))) ? 1.0 : cosine( (ch->voronoi() + facet_normal) - vh->point(), vh->normal()); if ( cos1 > cos2) swap( cos1, cos2); if ( (cos2 >= 0.0) && (cos1 <= 0.0)) { // Compute the intersection point of the Voronoi edge with // the co-polygon, i.e. co-cone with opening angle zero. Point p = ch->voronoi() + ((vh->point() - ch->voronoi()) * vh->normal()) / (facet_normal * vh->normal()) * facet_normal; double w = CGAL::to_double( (p - vh->point()) * (p - vh->point())); if ( vh->width() < w) vh->set_width( w); } } } // Now check the flatness property for every vertex. for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) { // If the vertex is already marked non flat then continue with // the next vertex. if ( ! vit->is_flat()) continue; double scaled_width = ratio * vit->width(); double second_height = CGAL::to_double( (vit->pole() - vit->point()) * (vit->pole() - vit->point())); if ( scaled_width > second_height) { vit->set_flat( false); continue; } // If the sample point lies on the boundary of the triangulation // it obviously passes the flatness test in the normal direction. // Otherwise we have to do the test in the normal direction. if ( ! vit->on_convex_hull()) { double first_height = CGAL::to_double( (vit->normal() * vit->normal())); if ( scaled_width > first_height) vit->set_flat( false); } } // Second stage of boundary detection. for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) vit->tag = vit->is_flat(); for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; // A finite facet must be incident to at least one finite cell. if ( triang.is_infinite( ch)) { Cell_handle c = ch; ch = ch->neighbor(id); id = ch->index( c); } CGAL_assertion( ! triang.is_infinite( ch)); for ( int i = 1; i < 4; ++i) { Vertex_handle v = ch->vertex( (id+i)%4); // Process only flat vertices. if ( ! v->is_flat()) continue; // Normal Check. for ( int j = 1; j < 4; ++j) { // Consider only vertices with index != i. if ( j == i) continue; // Check if *v is cocone neighbor of *w. Vertex_handle w = ch->vertex( (id+j)%4); double cos1 = cosine( ch->voronoi() - w->point(), w->normal()); double cos2 = ( triang.is_infinite( ch->neighbor(id))) ? 1.0 : cosine( ch->neighbor(id)->voronoi() - w->point(), w->normal()); if ( cos1 > cos2) swap( cos1, cos2); // Test for disjoint intervals [cos1, cos2] and [min_cos, max_cos]. if ( (cos2 < min_cos) || (cos1 > max_cos)) continue; // *v is not a cocone neighbor. double cos3 = cosine( v->normal(), w->normal()); if ( (cos3 < cos( flat_phi) && cos3 > cos( M_PI - flat_phi))) v->set_flat( false); } } } bool update = true; while ( update) { update = false; for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; // A finite facet must be incident to at least one finite cell. if ( triang.is_infinite( ch)) { Cell_handle c = ch; ch = ch->neighbor(id); id = ch->index( c); } CGAL_assertion( ! triang.is_infinite( ch)); for ( int i = 1; i < 4; ++i) { Vertex_handle v = ch->vertex( (id+i)%4); // Process only non flat vertices which fulfill the ratio condition. if ( v->is_flat() || ! v->tag ) continue; // Normal Check. for ( int j = 1; j < 4; ++j) { // Consider only vertices with index != i. if ( j == i) continue; // Check if *v is cocone neighbor of *w. Vertex_handle w = ch->vertex( (id+j)%4); double cos1 = cosine( ch->voronoi() - w->point(), w->normal()); double cos2 = ( triang.is_infinite( ch->neighbor(id))) ? 1.0 : cosine( ch->neighbor(id)->voronoi() - w->point(), w->normal()); if ( cos1 > cos2) swap( cos1, cos2); // Test for disjoint intervals [cos1, cos2] and [min_cos, max_cos]. if ( (cos2 < min_cos) || (cos1 > max_cos)) continue; // *v is not a cocone neighbor. double cos3 = cosine( v->normal(), w->normal()); if ( (cos3 > cos( flat_phi) || cos3 < cos( M_PI - flat_phi))) { v->set_flat( true); update = true; } } } } } } // ----------------------------------------------------------------------- // filter_candidates // ----------------- // First filter of candidate triangles. // ----------------------------------------------------------------------- void filter_candidates( Triangulation &triang, double phi) { double min_cos = cos(M_PI / 2.0 + phi); // Bounds for the co-cone. double max_cos = cos(M_PI / 2.0 - phi); CGAL_assertion( min_cos < max_cos); // Check for the co-cone condition for every finite facet. for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; // A finite facet must be incident to at least one finite cell. if ( triang.is_infinite( ch)) { Cell_handle c = ch; ch = ch->neighbor(id); id = ch->index( c); } CGAL_assertion( ! triang.is_infinite( ch)); // Iterate over the vertices incident to the facet. bool choose_facet = true; bool tested = false; for ( int i = 1; i < 4; ++i) { Vertex_handle vh = ch->vertex((id+i)%4); // Only flat vertices are allowed to choose a facet. if ( ! vh->is_flat()) continue; tested = true; double cos1 = cosine( ch->voronoi() - vh->point(), vh->normal()); double cos2 = ( triang.is_infinite( ch->neighbor(id))) ? 1.0 : cosine( ch->neighbor(id)->voronoi() - vh->point(), vh->normal()); if ( cos1 > cos2) swap( cos1, cos2); // Test for disjoint intervals [cos1, cos2] and [min_cos, max_cos]. if ( (cos2 < min_cos) || (cos1 > max_cos)) choose_facet = false; } // Set the cocone flag. ch->set_cocone_flag( id, choose_facet && tested); ch->neighbor(id)->set_cocone_flag( ch->neighbor(id)->index(ch), choose_facet && tested); } } // ----------------------------------------------------------------------- // safety_check // -------------- // Mark vertices in the triangulation as boundary vertices if they // do not have a non sharp umbrella in the complex. Mark candidate // facets non removable if they are incident to an edge that has only // two incident candidate triangles which which make a large dihedral // angle with each other. // ----------------------------------------------------------------------- void safety_check( Triangulation &triang, double sharp_phi) { typedef CGAL::Triple Anchored_facet; double sharp_cos = cos( sharp_phi); for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; // Consider only marked facets. if ( ! ch->cocone_flag( id)) continue; for ( int i = 1; i < 4; ++i) { Vertex_handle v = ch->vertex( (id+i)%4); v->set_isolated( false); // If a non sharp umbrella for v has already been found // then continue. if ( v->has_umbrella()) continue; vector< Anchored_facet> facet_stack; int iw = ( i == 3) ? (id+1)%4 : (id+i+1)%4; facet_stack.push_back( Anchored_facet( ch, id, iw)); // list< Vertex*> umbrella_vertices; -- this is what it was earlier. list< Vertex_handle > umbrella_vertices; bool found = true; while ( ! facet_stack.empty()) { Cell_handle cell = facet_stack.back().first; int fid = facet_stack.back().second; iw = facet_stack.back().third; facet_stack.pop_back(); Vertex_handle w = cell->vertex( iw); int iv = cell->index( v); int iu = edge_index(fid, iv, iw); Vertex_handle u = cell->vertex( iu); if ( ! found) { /* umbrella_vertices.erase( ++find( umbrella_vertices.begin(), umbrella_vertices.end(), &(*u)), umbrella_vertices.end()); */ umbrella_vertices.erase( ++find( umbrella_vertices.begin(), umbrella_vertices.end(), u), umbrella_vertices.end()); } Facet_circulator begin = triang.incident_facets( Edge( cell, iv, iw)); Facet_circulator fcirc = begin; found = false; do { cell = (*fcirc).first; fid = (*fcirc).second; // Consider only finite marked facets. if ( ! cell->cocone_flag( fid) || triang.is_infinite( *fcirc)) { ++fcirc; continue; } // Third vertex of *fcirc. int iz = find_third_vertex_index( *fcirc, v, w); Vertex_handle z = cell->vertex( iz); // Consider only facets different from the current facet. if ( z->point() == u->point()) { ++fcirc; continue; } // Cosine of the normals of facet and *fcirc. double current_cos = cosine( CGAL::cross_product( u->point() - v->point(), w->point() - v->point()), CGAL::cross_product( w->point() - v->point(), z->point() - v->point())); // If the cosine of the normals is larger than `sharp_cos' // then check if a non sharp umbrella was closed and other- // wise push a new oriented facet on the stack and w in the // list umbrella_vertices. if ( current_cos >= sharp_cos) { found = true; /* if ( find( umbrella_vertices.begin(), umbrella_vertices.end(), &(*(z))) != umbrella_vertices.end()) { */ if ( find( umbrella_vertices.begin(), umbrella_vertices.end(), z) != umbrella_vertices.end()) { v->set_umbrella( true); break; } else { umbrella_vertices.push_back( w); facet_stack.push_back( Anchored_facet( cell, fid, iz)); } } ++fcirc; } while ( fcirc != begin); } } } // Mark the facets which are not removable. for ( FEI eit = triang.finite_edges_begin(); eit != triang.finite_edges_end(); ++eit) { Cell_handle ch = (*eit).first; Vertex_handle v = ch->vertex((*eit).second); Vertex_handle w = ch->vertex((*eit).third); Facet_circulator begin = triang.incident_facets( *eit); Facet_circulator fcirc = begin; int cnt = 0; double max_cos = -2.0; do { Cell_handle cell = (*fcirc).first; int fid = (*fcirc).second; // Consider only finite marked facets. if ( ! cell->cocone_flag( fid) || triang.is_infinite( *fcirc)) { ++fcirc; continue; } // Increase the facet counter. ++cnt; // Third vertex of *fcirc. int iu = find_third_vertex_index( *fcirc, v, w); Vertex_handle u = cell->vertex( iu); Facet_circulator gcirc = fcirc; ++gcirc; for ( ; gcirc != begin; ++gcirc) { cell = (*gcirc).first; int gid = (*gcirc).second; // Consider only finite marked facets. if ( (! cell->cocone_flag( gid)) || triang.is_infinite( *gcirc)) continue; // Third vertex of *gcirc. int iz = find_third_vertex_index( *gcirc, v, w); Vertex_handle z = cell->vertex( iz); // Compute the cosine of the normals of *fcirc and *gcirc. double normals_cos = cosine( CGAL::cross_product( u->point() - v->point(), w->point() - v->point()), CGAL::cross_product( w->point() - v->point(), z->point() - v->point())); if ( normals_cos > max_cos) max_cos = normals_cos; } ++fcirc; } while ( fcirc != begin); if ( cnt == 2 && max_cos >= 0.7) { do { // Here fcirc == begin should hold. Cell_handle cell = (*fcirc).first; int fid = (*fcirc).second; // Consider only finite marked facets. if ( ! cell->cocone_flag( fid) || triang.is_infinite( *fcirc)) { ++fcirc; continue; } cell->set_removable( fid, false); cell->neighbor( fid)-> set_removable( cell->neighbor( fid)->index( cell), false); ++fcirc; } while ( fcirc != begin); } } } // ----------------------------------------------------------------------- // pruning // ------- // Deselects all triangles incident to sharp edges. // ----------------------------------------------------------------------- void pruning( Triangulation &triang, double sharp_phi) { double sharp_cos = cos(sharp_phi); vector< Edge> edge_stack; for ( FEI eit = triang.finite_edges_begin(); eit != triang.finite_edges_end(); ++eit) { Cell_handle ch = (*eit).first; Vertex_handle v = ch->vertex( (*eit).second); Vertex_handle w = ch->vertex( (*eit).third); // Process only edges for which both endpoints have an incident // umbrella. if ( ! (v->has_umbrella() && w->has_umbrella())) continue; // Process only edges for which ... . edge_stack.push_back( *eit); while ( ! edge_stack.empty()) { // The edge we cycle around. Edge edge = edge_stack.back(); edge_stack.pop_back(); // The two endpoints of the edge which we circle around. v = edge.first->vertex( edge.second); w = edge.first->vertex( edge.third); Facet_circulator begin = triang.incident_facets( edge); Facet_circulator fcirc = begin; double max_cos = -2.0; do { Cell_handle cell = (*fcirc).first; int fid = (*fcirc).second; // Consider only finite marked facets. if ( ! cell->cocone_flag( fid) || triang.is_infinite( *fcirc)) { ++fcirc; continue; } // Third vertex of *fcirc. int iu = find_third_vertex_index( *fcirc, v, w); Vertex_handle u = cell->vertex( iu); Facet_circulator gcirc = fcirc; ++gcirc; for ( ; gcirc != begin; ++gcirc) { cell = (*gcirc).first; int gid = (*gcirc).second; // Consider only finite marked facets. if ( (! cell->cocone_flag( gid)) || triang.is_infinite( *gcirc)) continue; // Third vertex of *gcirc. int iz = find_third_vertex_index( *gcirc, v, w); Vertex_handle z = cell->vertex( iz); // Compute the cosine of the normals of *fcirc and *gcirc. double normals_cos = cosine( CGAL::cross_product( u->point() - v->point(), w->point() - v->point()), CGAL::cross_product( w->point() - v->point(), z->point() - v->point())); if ( normals_cos > max_cos) max_cos = normals_cos; } ++fcirc; } while ( fcirc != begin); // If the edge is sharp reset its incident facets. if ( max_cos < sharp_cos) { fcirc = begin; do { Cell_handle ch = (*fcirc).first; int id = (*fcirc).second; // int iv = ch->index( &(*v)); // int iw = ch->index( &(*w)); int iv = -1; int iw = -1; #ifndef NDEBUG CGAL_assertion(ch->has_vertex(v, iv) && (iv != -1)); CGAL_assertion(ch->has_vertex(w, iw) && (iw != -1)); #else ch->has_vertex(v, iv); ch->has_vertex(w, iw); #endif //cout << "pruning: " << iv << " " << iw << endl; int iz = find_third_vertex_index( *fcirc, v, w); Vertex_handle z = ch->vertex( iz); // Consider only removable, marked finite facets which third // incident vertex also has an incident umbrella. if ( ! ch->cocone_flag( id) || triang.is_infinite( *fcirc) || ! ch->removable( id)) { ++fcirc; continue; } // Reset cocone flags on both side of facet. ch->set_cocone_flag( id, false); ch->neighbor( id)-> set_cocone_flag( ch->neighbor( id)->index( ch), false); // Push incident edges on stack for reconsideration. if ( v->has_umbrella() || z->has_umbrella()) edge_stack.push_back( Edge( ch, iv, iz)); if ( w->has_umbrella() || z->has_umbrella()) edge_stack.push_back( Edge( ch, iw, iz)); ++fcirc; } while ( fcirc != begin); } } } } // ----------------------------------------------------------------------- // walk // ---- // Extracts a surface. // ----------------------------------------------------------------------- void walk( const Triangulation &triang){ typedef CGAL::Triple Oriented_facet; // The tag is used to mark explored facets. for ( ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); ++cit) { cit->tag[0] = cit->tag[1] = cit->tag[2] = cit->tag[3] = false; } // The tag is used to mark explored vertices. for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) { vit->tag = false; } // Main loop of the walk covers different components of the surface. for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; // Consider only marked, untagged facets. if ( ! ch->cocone_flag( id) || ch->tag[id]) continue; // If one of the vertices incident to *fit are already tagged // then the *fit has to be unmarked, because otherwise it would // introduce a topological conflict. if ( ch->vertex( (id+1)%4)->tag || ch->vertex( (id+2)%4)->tag || ch->vertex( (id+3)%4)->tag) { ch->set_cocone_flag( id, false); ch->neighbor( id)-> set_cocone_flag( ch->neighbor( id)->index( ch), false); continue; } // Don't start from the inside of a completely marked tetrahedron // or from the boundary. if ( (ch->cocone_flag( 0) && ch->cocone_flag( 1) && ch->cocone_flag( 2) && ch->cocone_flag( 3)) || ! ch->vertex( (id+1)%4)->has_umbrella() || ! ch->vertex( (id+2)%4)->has_umbrella() || ! ch->vertex( (id+3)%4)->has_umbrella()) continue; // Prepare the initial three oriented facets from which the walk starts. vector< Oriented_facet> facet_stack; for ( int i = 1; i <= 3; ++i) { int j = (i == 3) ? (id+1)%4 : (id+i+1)%4; facet_stack.push_back( Oriented_facet( ch, id, edge_index( id, (id+i)%4, j))); } ch->tag[id] = true; ch->neighbor( id)->tag[ch->neighbor( id)->index( ch)] = true; ch->vertex( (id+1)%4)->tag = true; ch->vertex( (id+2)%4)->tag = true; ch->vertex( (id+3)%4)->tag = true; // Main loop of the walk on a single component. while ( ! facet_stack.empty()) { Cell_handle cell = facet_stack.back().first; int fid = facet_stack.back().second; int eid = facet_stack.back().third; facet_stack.pop_back(); int iv, iw; vertex_indices( fid, eid, iv, iw); Vertex_handle v = cell->vertex( iv); Vertex_handle w = cell->vertex( iw); Cell_handle old_cell = cell; Cell_handle new_cell = old_cell->neighbor( eid); bool found = false; do { fid = old_cell->index( new_cell); Facet facet = Facet( old_cell, fid); iv = old_cell->index( v); iw = old_cell->index( w); Vertex_handle z = old_cell->vertex( edge_index(fid, iv, iw)); if ( old_cell->cocone_flag( fid)) { if ( !(triang.is_infinite( facet) || found)) { found = true; if ( ! old_cell->tag[fid]) { z->tag = true; old_cell->tag[fid] = true; new_cell->tag[new_cell->index( old_cell)] = true; if ( w->has_umbrella() || z->has_umbrella()) facet_stack.push_back( Oriented_facet( old_cell, fid, iv)); if ( v->has_umbrella() || z->has_umbrella()) facet_stack.push_back( Oriented_facet( old_cell, fid, iw)); } } else { // Reset cocone flags of facet. old_cell->set_cocone_flag( fid, false); new_cell->set_cocone_flag( new_cell->index( old_cell), false); } } old_cell = new_cell; new_cell = new_cell->neighbor( new_cell->index( z)); } while ( new_cell != cell); } } } // ----------------------------------------------------------------------- // cocone // ------ // reconstructs the surface of an unorganized set of points. // ----------------------------------------------------------------------- // modified cocone void cocone( double cocone_angle, double sharp_angle, double flat_angle, double ratio, Triangulation &triang) { compute_poles( triang); cerr<<"."; mark_flat_vertices( triang, ratio, cocone_angle, flat_angle); cerr<<"."; filter_candidates( triang, cocone_angle); cerr<<"."; safety_check( triang, sharp_angle); cerr<<"."; pruning( triang, sharp_angle); cerr<<"."; walk( triang); cerr<<"."; } // ---------------------------------------------------------------------------- // Watertight Surface Reconstruction // ---------------------------------- // The names of the functions are the following // ---------------------------------------------------------------------------- // 1. mark_bad_points(triang) // calls : i> identify_vertices_with_dirty_umbrella(triang) // ii> check_sharp_facets(triang) // 2. mark_in_out(triang) // calls : propagate_in_out_marking(triang, stack) // 3. create_surface(tring, bool b1, bool b2) // calls : grow_boundary(triang, stack, bool b1) // depending on b2 calls : create_surface(triang, false, false) // 4. reset_cocone_flag(triang) // 5. mark_isolated_points_and_reset_bad_points(triang, bool b) // ----------------------------------------------------------------------------- // ----------------------------------------------------------------------- // identify_vertices_with_dirty_umbrella // ------------------------------------- // Marking the points with no clean umbrella as bad points. // Their neighbors on the surface are also marked as the bad points. // This function returns a boolean value // which is false when there is no bad point. // and true otherwise. // ----------------------------------------------------------------------- bool identify_vertices_with_dirty_umbrella( Triangulation &triang) { // Resets the flag needed for the subroutine. for(FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); vit ++) { vit->visited = false; vit->bad = false; vit->bad_neighbor = false; while(! vit->bad_v.empty() ) vit->bad_v.pop_back(); } // Iterate over the facets. // Take one facet on the surface. Insert the two edges in a stack. // Take one edge from the stack. // Take one of the endpoints. Call that endpoint v. // If v is already visited then v is bad. // If v is not visited then fixing v circulate. // If any edge is found with more than two cocone facets // mark both the endpoints of the edge as bad. // After coming back to the starting edge mark the vertex visited. // In the next iteration, take one bad vertex and all the neighbors // who are on the surface mark them bad_neighbor. bool is_there_any_bad_point = false; for(FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); fit ++) { Cell_handle ch = (*fit).first; int id = (*fit).second; if(triang.is_infinite(ch) ) { Cell_handle c = ch; ch = ch->neighbor(id); id = ch->index(c); } CGAL_assertion(! triang.is_infinite(ch) ); if( ! ch->cocone_flag(id) ) continue; // If I reach a vertex which is already marked as bad then I don't proceed // with the vertex. // Or if the vertex is visited and I have already wlaked over one of its umbrellas // then it should be marked as bad. // This loop checks if any of the vertex of the surface can be bad for(int k = 1; k < 4; k ++) { if(! ch->vertex((id+k)%4)->visited || ch->vertex((id+k)%4)->bad) continue; int v_id = ch->vertex((id+k)%4)->id; int v_index1 = -1, v_index2 = -1; for(int j = 1; j < 4; j ++) { if(ch->vertex((id + j)%4)->id == v_id) v_index1 = j; if(ch->neighbor(id)->vertex((ch->neighbor(id)->index(ch) + j)%4)->id == v_id) v_index2 = j; } CGAL_assertion(v_index1 != -1 && v_index1 == k); CGAL_assertion(v_index2 != -1); CGAL_assertion(ch->umbrella_member[id][v_index1] == ch->neighbor(id)->umbrella_member[ch->neighbor(id)->index(ch)][v_index2] ); if(ch->umbrella_member[id][v_index1] != v_id) { ch->vertex((id+k)%4)->bad = true; is_there_any_bad_point = true; } } // Now I will start searching for the umbrella of each vertex (if it's not bad) // taking the edge as the starting point. for(int i = 1; i < 4; i ++) { Vertex_handle v = ch->vertex((id+i)%4); if(v->visited || v->bad) continue; v->visited = true; // i1 is the pivot around which I am searching for umbrella int i1 = (id+i)%4; int i2 = (i==3) ? (id+1)%4 : (id+i+1)%4; int start_id = ch->vertex(i2)->id; Cell_handle c = ch; int fid = id; bool found = true; while(found) { Cell_handle next_c = c; int next_id = fid; found = false; Facet_circulator begin = triang.incident_facets( Edge( c, i1, i2)); Facet_circulator fcirc = begin; int k = 0; // k will count the number of facets on the surface around the edge do{ Cell_handle cc = (*fcirc).first; int cid = (*fcirc).second; if( triang.is_infinite(cc->vertex( (cid+1)%4)) || triang.is_infinite(cc->vertex( (cid+2)%4)) || triang.is_infinite(cc->vertex( (cid+3)%4)) ) { fcirc ++; continue; } if(cc->cocone_flag(cid) ) { if(triang.is_infinite(cc) ) { Cell_handle temp = cc; cc = cc->neighbor(cid); cid = cc->index(temp); } CGAL_assertion(! triang.is_infinite(cc) ); // put the vertex id in the umbrella_member array // of the cell cc and it's neighbor int v_index1 = -1, v_index2 = -1; for(int j = 1; j < 4; j ++) { if(cc->vertex((cid + j)%4)->id == v->id) v_index1 = j; if(cc->neighbor(cid)->vertex((cc->neighbor(cid)->index(cc) + j)%4)->id == v->id) v_index2 = j; } CGAL_assertion(v_index1 != -1); CGAL_assertion(v_index2 != -1); cc->umbrella_member[cid][v_index1] = v->id; cc->neighbor(cid)->umbrella_member[cc->neighbor(cid)->index(cc)][v_index2] = v->id; if((cc->id == c->id && cid == fid) || (cc->neighbor(cid)->id == c->id && cc->neighbor(cid)->index(cc) == fid) ) { if((cc->id != c->id || cid != fid) && (triang.is_infinite(cc->neighbor(cid))) ) ; else { fcirc ++; continue; } } next_c = cc; next_id = cid; k++; } fcirc ++; }while (fcirc != begin); if(k != 1) { c->vertex(i1)->bad = true; c->vertex(i2)->bad = true; is_there_any_bad_point = true; break; } // get the next edge .. that is find the next cell and i1 and i2 // the next cell is next_c and the facet is next_id int ni1 = -1, ni2 = -1; for(int j = 1; j < 4; j ++) { Vertex_handle nv = next_c->vertex((next_id+j)%4); if(nv->id == c->vertex(i2)->id ) continue; if( nv->id == v->id) ni1 = (next_id+j)%4; else ni2 = (next_id+j)%4; } c = next_c; fid = next_id; i1 = ni1; i2 = ni2; if(c->vertex(i2)->id == start_id ) found = false; else found = true; } } } return is_there_any_bad_point; } // ----------------------------------------------------------------------------- // check_sharp_facets // -------------------- // Cehcks if some good points have such edges which have sharp cocone facets // incident to it. // This places create ambiguity in in-out marking and mobius strip like behaviour // are dangerous because wrong in-out marking can destroy the whole surface. // ------------------------------------------------------------------------------ void check_sharp_facets( Triangulation &triang) { for(FEI eit = triang.finite_edges_begin(); eit != triang.finite_edges_end(); eit ++) { Cell_handle c = (*eit).first; int i1 = (*eit).second; int i2 = (*eit).third; Vertex_handle v = c->vertex(i1); Vertex_handle w = c->vertex(i2); if(v->bad && w->bad ) continue; // this edge has a good point Facet_circulator begin = triang.incident_facets( *eit); Facet_circulator fcirc = begin; int cnt = 0; double min_cos = 2.0; do { Cell_handle cell = (*fcirc).first; int fid = (*fcirc).second; // Consider only finite marked facets. if ( ! cell->cocone_flag( fid) || triang.is_infinite( *fcirc)) { ++fcirc; continue; } // Increase the facet counter. ++cnt; // Third vertex of *fcirc. int iu = find_third_vertex_index( *fcirc, v, w); Vertex_handle u = cell->vertex( iu); Facet_circulator gcirc = fcirc; ++gcirc; for ( ; gcirc != begin; ++gcirc) { cell = (*gcirc).first; int gid = (*gcirc).second; // Consider only finite marked facets. if ( (! cell->cocone_flag( gid)) || triang.is_infinite( *gcirc)) continue; // Third vertex of *gcirc. int iz = find_third_vertex_index( *gcirc, v, w); Vertex_handle z = cell->vertex( iz); // Compute the cosine of the normals of *fcirc and *gcirc. double normals_cos = cosine( CGAL::cross_product( u->point() - v->point(), w->point() - v->point()), CGAL::cross_product( w->point() - v->point(), z->point() - v->point())); if ( normals_cos < min_cos) min_cos = normals_cos; } ++fcirc; } while ( fcirc != begin); if(cnt == 2) { if(min_cos <= -0.9) { v->bad = true; w->bad = true; continue; } if(min_cos < 0) { if(! v->is_flat() ) v->bad = true; if(! w->is_flat() ) w->bad = true; } } } } // ------------------------------------------------------------------------- // mark_bad_points // --------------- // The bad points are classified in the following two ways. // 1. If a point doesn't have a clean umbrella, that is, if the umbrella is // not homeomorphic to a disk (either boundary, or pinching, or one edge // having more than two facets) // 2. If an edge has a sharp facet pair then the vertices incident // to it are also bad. // ------------------------------------------------------------------------- void mark_bad_points( Triangulation &triang) { // Identify the dirty umbrella vertices identify_vertices_with_dirty_umbrella(triang); // Identify vertices incident to edges with sharp facets check_sharp_facets(triang); } // ----------------------------------------------------------------------- // propagate_in_out_marking // ------------------------ // Given a set of vertices and an initial marking of one of the cells // the marking is propagated through whatever vertices can be reached // from these initial vertices on the surface. // ----------------------------------------------------------------------- void propagate_in_out_marking( Triangulation &triang, vector < CGAL::Triple >& v_stack) { typedef CGAL::Triple Pivot_vertex; if(v_stack.empty()) return; // process the vertices in the v_stack until it is empty while(! v_stack.empty() ) { Cell_handle cell = v_stack.back().first; int fid = v_stack.back().second; int vid = v_stack.back().third; v_stack.pop_back(); CGAL_assertion(cell->vertex(vid)->visited && ! cell->vertex(vid)->bad && ! cell->vertex(vid)->is_isolated() ); // Now move around the outside umbrella of vertex untill it hits // a cocone facet. vector< Pivot_vertex> f_stack; f_stack.push_back( Pivot_vertex(cell, fid, vid) ); vector< int> vis_id; vis_id.push_back(cell->id); while(! f_stack.empty() ) { Cell_handle old_cell = f_stack.back().first; int old_fid = f_stack.back().second; int old_vid = f_stack.back().third; Vertex_handle v = old_cell->vertex(old_vid); f_stack.pop_back(); CGAL_assertion(old_cell->outside ); Cell_handle new_cell = old_cell->neighbor(old_fid); int new_fid = new_cell->index(old_cell); int new_vid = -1; if(! triang.has_vertex(new_cell, new_fid, v, new_vid) ) CGAL_assertion(false); else CGAL_assertion(new_vid != -1); if(old_cell->cocone_flag(old_fid) ) { // don't insert any more facet in f_stack. // But try to get some new vertices that can be inserted in v_stack. // These vertices are the ones from the cocone facet for(int i = 1; i < 4; i ++) { int j = (i+old_fid)%4; // A cocone facet is a finite facet. So infinite vertex // can not be a member of this facet. CGAL_assertion(! triang.is_infinite(old_cell->vertex(j)) && ! old_cell->vertex(j)->is_isolated() ); // The new vertex is different from the current vertex // and it has to be good and // it is not visited yet. if(j == old_vid || old_cell->vertex(j)->bad || old_cell->vertex(j)->visited ) continue; int iv = -1, iw = -1; vertex_indices(old_fid, j, iv, iw); CGAL_assertion(iv != -1 && iw != -1); v_stack.push_back(Pivot_vertex(old_cell, iv, j) ); v_stack.push_back(Pivot_vertex(old_cell, iw, j) ); old_cell->vertex(j)->visited = true; } } else { // Insert the new facets. These facets have to be // different than the old one. And the new cell captured has to be // unvisited. int iv = -1, iw = -1; vertex_indices(new_fid,new_vid,iv,iw); CGAL_assertion(iv != -1 && iw != -1); bool f = false; for(unsigned int i = 0; i < vis_id.size(); i ++) { if(vis_id[i] == new_cell->id) f = true; } if(! f) { bool f1 = false, f2 = false; for(unsigned int i = 0; i < vis_id.size(); i ++) { if(vis_id[i] == new_cell->neighbor(iv)->id ) f1 = true; if(vis_id[i] == new_cell->neighbor(iw)->id ) f2 = true; } if(! f1) f_stack.push_back(Pivot_vertex(new_cell, iv, new_vid) ); if(! f2) f_stack.push_back(Pivot_vertex(new_cell, iw, new_vid) ); vis_id.push_back(new_cell->id); new_cell->outside = true; } } } } } // ------------------------------------------------------------------------- // mark_in_out // ----------- // The points having a clean (and preferably non-sharp) umbrella has // tetrahedra incident on it divided into two classes inside and outside. // These tetrahedra will be marked consistently in and out. // Infinite tetrahedra which are definitely outside are the starting points. // ------------------------------------------------------------------------- void mark_in_out( Triangulation &triang) { typedef CGAL::Triple Pivot_vertex; // Before starting I have to set the flags for all the // cells and vertices // At the same time the cells also need to be marked transparent // for future create_surface function. for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { // all the infinite cells are outside if(triang.is_infinite(cit) ) { cit->outside = true; continue; } // For finite cells // if all four points are bad or isolated // the cell is trasparent. // all the vertices are anyway marked unvisited. bool mark_transp_flag = true; for(int i = 0; i < 4; i ++) { cit->vertex(i)->visited = false; if(! cit->vertex(i)->bad && ! cit->vertex(i)->is_isolated() ) mark_transp_flag = false; } cit->transp = mark_transp_flag; // If a cell is marked trasparent the opaque also has to be determined // at the same time. Otherwise making something transparent has no meaning. if(! mark_transp_flag) continue; // calculate the facet with least circumradius and mark that facet only // as opaque facet. double min_r = HUGE; int min = -1; for(int i = 0; i < 4; i ++) { Point p = cit->vertex((i+1)%4)->point(); Point q = cit->vertex((i+2)%4)->point(); Point r = cit->vertex((i+3)%4)->point(); double radius = sq_cr_tr_3(p, q, r); if(radius < min_r) { min = i; min_r = radius; } } CGAL_assertion(min != -1); // make the min-th facet that is the one with minimum circumradius // as opaque cit->opaque[min] = true; cit->neighbor(min)->opaque[cit->neighbor(min)->index(cit)] = true; } // Start marking for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { bool start = false; Cell_handle start_cell; vector v_stack; if(!triang.is_infinite(cit) ) continue; start_cell = cit; for(int i = 0; i < 4; i ++) { // every marking has to start from an infinite cell if(! triang.is_infinite(start_cell->vertex(i)) ) continue; // push the good vertices (along with three facets incident) // in a stack and they will be processed duely for(int j = 1; j < 4; j ++) { int v_id = (i+j)%4; if( start_cell->vertex(v_id)->bad || start_cell->vertex(v_id)->is_isolated() || start_cell->vertex(v_id)->visited ) continue; v_stack.push_back( Pivot_vertex( start_cell, (v_id+1)%4, v_id) ); v_stack.push_back( Pivot_vertex( start_cell, (v_id+2)%4, v_id) ); v_stack.push_back( Pivot_vertex( start_cell, (v_id+3)%4, v_id) ); start_cell->vertex(v_id)->visited = true; start = true; } break; } if(! start) continue; // The cell is infinite and therefore has to be outside CGAL_assertion(start_cell->outside); // v_stack has been filled up with some vertices // now start marking their inside and outside propagate_in_out_marking(triang, v_stack); // at the end of propagation v_stack should be empty CGAL_assertion(v_stack.empty()); } } // ----------------------------------------------------------------------- // grow_boundary // ------------- // Given a starting boundary, it grows the boundary within the outside // tetrahedra. // ----------------------------------------------------------------------- void grow_boundary( Triangulation &triang, vector< Facet >& bdy_stack, bool postponne_walk_to_do_io_marking) { typedef CGAL::Triple Pivot_vertex; if(bdy_stack.empty()) return; while(!bdy_stack.empty() ) { Cell_handle c = bdy_stack.back().first; int id = bdy_stack.back().second; bdy_stack.pop_back(); if(! c->bdy[id]) continue; CGAL_assertion(c->outside); // If the neighboring cell is not outside then if the facet is not opaque // cross the facet otherwise don't cross. if(! c->neighbor(id)->outside ) { if(! c->neighbor(id)->transp ) continue; if(c->opaque[id] ) continue; } Cell_handle ch_n = c->neighbor(id); int id_n = ch_n->index(c); c->bdy[id] = false; ch_n->bdy[id_n] = false; for(int i = 1; i < 4; i ++) { int j = (i+id_n)%4; if(ch_n->bdy[j]) { ch_n->bdy[j] = false; ch_n->neighbor(j)->bdy[ch_n->neighbor(j)->index(ch_n)] = false; } else { ch_n->bdy[j] = true; ch_n->neighbor(j)->bdy[ch_n->neighbor(j)->index(ch_n)] = true; if(! ch_n->neighbor(j)->visited ) bdy_stack.push_back(Facet(ch_n, j) ); } } ch_n->visited = true; ch_n->outside = true; // this is needed for the transparent tetrahedra // they were not outside at the beginning. if(! postponne_walk_to_do_io_marking) continue; // here I have to postponne walk to see if any unvisited good (not isolated) point has // been reached so that I can mark the in-out for that point now bool postponne_walk = false; if(! ch_n->vertex(id_n)->is_isolated() && ! ch_n->vertex(id_n)->bad && ! ch_n->vertex(id_n)->visited ) postponne_walk = true; if(postponne_walk) { vector v_stack; v_stack.push_back(Pivot_vertex(ch_n, (id_n+1)%4, id_n) ); v_stack.push_back(Pivot_vertex(ch_n, (id_n+2)%4, id_n) ); v_stack.push_back(Pivot_vertex(ch_n, (id_n+3)%4, id_n) ); ch_n->vertex(id_n)->visited = true; // propagate the marking propagate_in_out_marking(triang, v_stack); // after the execution v_stack should be empty CGAL_assertion(v_stack.empty()); } } } // ----------------------------------------------------------------------- // create_surface // -------------- // Given a set of inside and outside tetrahedra // this procedure grows a boundary within the outside tetrahedra and // seperates the outside from inside. This boundary is the surface. // Note : This function is not responsible for transparent marking. // So set/reset-ing transparent marking is the responsibility // of the calling function. // ----------------------------------------------------------------------- void create_surface( Triangulation &triang, bool postponne_walk_to_do_io_marking, bool do_second_phase_of_walk) { // before starting the walk among the outside tetrahedra // set/reset the required flags. for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { // visited flag has to be reset here. cit->visited = false; // bdy flag is reset as there is no boundary in the beginning. for(int i = 0; i < 4; i ++) { cit->vertex(i)->tag = false; cit->bdy[i] = false; } // the infinite tetrahedra are always outside. if(triang.is_infinite(cit) && !cit->outside ) cit->outside = true; } // Start growing the boundary // The stack maintains the set of facets to be processed // to grow the boundary. vector bdy_stack; for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { bool start = false; // Walk has to start from an infinite cell which is // guaranteed to be outside and it has to be unvisited. if(! triang.is_infinite(cit) || cit->visited) continue; for(int i = 0; i < 4; i ++) { if(! triang.is_infinite(cit->vertex(i)) ) continue; for(int j = 1; j < 4; j ++) { // If any vertex is bad or isolated // take a new cell .. a little conservative. if(cit->vertex((i+j)%4)->bad || cit->vertex((i+j)%4)->is_isolated()) { start = false; break; } start = true; } break; } // The cell is not suitable to start. So continue to get // a new cell. if(! start) continue; // Got a fresh boundary to grow. // put the facets in the bdy_stack to get the // starting boundary. Cell_handle start_cell = cit; start_cell->visited = true; for(int i = 0; i < 4; i ++) { start_cell->bdy[i] = true; start_cell->neighbor(i)->bdy[start_cell->neighbor(i)->index(start_cell)] = true; bdy_stack.push_back(Facet(start_cell, i)); } // Call a function to grow the boundary given a starting boundary. // bdy_stack holds the initial facets of the boundary. grow_boundary(triang, bdy_stack, postponne_walk_to_do_io_marking); // after growing the boundary the bdy_stack should be empty CGAL_assertion(bdy_stack.empty()); } // end of first phase of walk. // check if second phase is needed. if(! do_second_phase_of_walk) return; // Some vertices (good, not isolated) are still unvisited. // For them some blobs show up outside the surface. // To get rid of them we need to make another walk with // the cells with one or more good, unvisited, non-isolated points // and rest bad/isolated points transparent. bool walk_flag = false; for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { // make all the facets non-opaque for(int i = 0; i < 4; i ++) { cit->opaque[i] = false; if(! cit->vertex(i)->bad && ! cit->vertex(i)->is_isolated() && ! cit->vertex(i)->visited ) { cit->vertex(i)->bad = true; walk_flag = true; } } } // if walk_flag is not set that means we don't need to walk again. if(! walk_flag) return; // phase two of walk starts. // any cell having all four bad/isolated are made transp. // and a facet is to be marked as opaque accordingly. for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { bool mark_transp_flag = true; for(int i = 0; i < 4; i ++) if(!cit->vertex(i)->bad && !cit->vertex(i)->is_isolated()) mark_transp_flag = false; cit->transp = mark_transp_flag; if(! mark_transp_flag) continue; // if the cell is marked transparent choose the opaque facet. // calculate the facet with least circumradius and mark that facet only // as opaque facet. double min_r = HUGE; int min = -1; for(int i = 0; i < 4; i ++) { Point p = cit->vertex((i+1)%4)->point(); Point q = cit->vertex((i+2)%4)->point(); Point r = cit->vertex((i+3)%4)->point(); double radius = sq_cr_tr_3(p, q, r); if(radius < min_r) { min = i; min_r = radius; } } CGAL_assertion(min != -1); // make the min-th facet that is the one with minimum circumradius // as opaque cit->opaque[min] = true; cit->neighbor(min)->opaque[cit->neighbor(min)->index(cit)] = true; } // call this function recursively ... with two restrictions. // postponne-walk-and-do-io-marking = false // second-phase-walk = false create_surface(triang, false, false); } // ------------------------------------------------------------------------ // reset_cocone_flag // ------------------ // Resets the cocone flag after doing the inside-outside marking // ------------------------------------------------------------------------ void reset_cocone_flag( Triangulation &triang) { // Reset the cocone flags. for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; ch->set_cocone_flag(id,false); ch->neighbor(id)->set_cocone_flag( ch->neighbor(id)->index(ch), false); } for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; CGAL_assertion(ch->bdy[id] == ch->neighbor(id)->bdy[ch->neighbor(id)->index(ch)] ); if(ch->bdy[id]) { ch->set_cocone_flag(id,true); ch->neighbor(id)->set_cocone_flag( ch->neighbor(id)->index(ch), true); } } } // ----------------------------------------------------------------------- // mark_isolated_points_and_reset_bad_points // ----------------------------------------- // Marking the isolated points. // Resets the bad-point flag if the boolean parameter is true. // ----------------------------------------------------------------------- void mark_isolated_points_and_reset_bad_points( Triangulation &triang, bool reset_bad_point_flag) { for(FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); vit ++) { vit->set_isolated(true); if(reset_bad_point_flag) vit->bad = false; } for(FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); fit ++) { Cell_handle ch = (*fit).first; int id = (*fit).second; if(! ch->cocone_flag(id) ) continue; for(int i = 1; i < 4; i ++) ch->vertex((id+i)%4)->set_isolated(false); } } // ----------------------------------------------------------------------- // walk_wt // -------- // Walking on watertight surface to get rid of the outside tetrahedron // inside the surface // This is more like a confirmatory walk that ensures the consistency // of the outside marking // ----------------------------------------------------------------------- void walk_wt( Triangulation &triang) { for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { cit->visited = false; cit->outside = false; if(triang.is_infinite(cit) ) cit->outside = true; } vector c_stack; for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { if(! triang.is_infinite(cit) || cit->visited) continue; cit->visited = true; for(int i = 0; i < 4; i ++) { if(cit->cocone_flag(i) || cit->neighbor(i)->visited ) continue; c_stack.push_back(cit->neighbor(i) ); cit->neighbor(i)->outside = true; cit->neighbor(i)->visited = true; } while( ! c_stack.empty() ) { Cell_handle ch = c_stack.back(); c_stack.pop_back(); CGAL_assertion(ch->outside && ch->visited ); for(int i = 0; i < 4; i ++) { Cell_handle c = ch->neighbor(i); if( ch->cocone_flag(i) || c->visited ) continue; c_stack.push_back(c); c->outside = true; c->visited = true; } } } } // ------------------------------------------------------------------ // tcocone // ------------ // This function takes a triangulation of a pointset sampled from a // surface and reconstructs a water-tight surface out of it. // As a first step it uses cocone to get a surface with its boundary // identified. Then it performs two operations called marking and // peeling void tcocone(const double DEFAULT_ANGLE, const double DEFAULT_SHARP, const double DEFAULT_FLAT, const double DEFAULT_RATIO, Triangulation &triang) { // -------------------------- // Cocone // -------------------------- // Initial surface reconstruction // with boundary detection. // -------------------------- // Initial mesh generation (with boundary) using cocone. cocone( DEFAULT_ANGLE, DEFAULT_SHARP, DEFAULT_FLAT, DEFAULT_RATIO, triang); cerr << "." << flush; // --------------------------------------------------- // After cocone there are some anomalies in the // surface along with the actual boundary. // We need to identify those points in those regions. // --------------------------------------------------- // marking isolated points in the initial mesh. mark_isolated_points_and_reset_bad_points(triang, true); cerr << "." << flush; // The points which don't have any proper umbrella or // are incident to edges with sharp facet pairs are marked bad. mark_bad_points(triang); cerr << "." << flush; // ------------------------------------------------------ // Marking (step 1 of Tight Cocone). // ------------------------------------------------------ // Inside - outside of all the good points are marked consistently. mark_in_out(triang); cerr << "." << flush; // ------------------------------------------------------- // Peeling (step 2 of Tight Cocone). // ------------------------------------------------------- // Determine the inside and outside of the surface. create_surface(triang, true, true); cerr << "." << flush; // ------------------------------------------------------- // Conforming the surface information with inside/outside // marking. // ------------------------------------------------------- // Updating the surface information and confirming // the inside-outside marking. reset_cocone_flag(triang); cerr << "." << flush; // marking isolated points. mark_isolated_points_and_reset_bad_points(triang, true); cerr << "." << flush; // walking on the so-far watertight surface to ensure the marking. walk_wt(triang); cerr << "." << flush; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/robust_cc.C0000644000175000017500000002230511344301500024542 0ustar debiandebian #include "robust_cc.h" // ----------------------------------------------------------------------- // Functions to handle the degeneracy and potential problem in voronoi // computation // ----------------------------------------------------------------------- /////////////////////////////////////////////////////////////// // these next functions are used to get the voronoi point if // points are coplanar. Coplanarity makes CGAL very sad. :-( //a flag that will be set if the call to circumsphere fails static bool cgal_failed; //the handler that will flag the operation as having failed //oh, what the heck, let's make it static while we're at it static void failure_func( const char *type, const char *exp, const char *file, int line, const char *expl) { //bad CGAL! cgal_failed = true; return; } // ------------------------------------------------------------- // nondg_voronoi_point // ------------------------------------------------------------- // This function will not assume any degeneracy and compute the // voronoi point. If the computation fails it will set a boolean // variable passed as a parameter by which the calling function // will know that the computation was not correct. // ------------------------------------------------------------- Point nondg_voronoi_point(const Point &a, const Point &b, const Point &c, const Point &d, bool &is_correct_computation) { //we tell CGAL to call our function if there is a problem //we also tell it not to die if things go haywire CGAL::Failure_function old_ff = CGAL::set_error_handler(failure_func); CGAL::Failure_behaviour old_fb = CGAL::set_error_behaviour(CGAL::CONTINUE); // be optimistic :-) //this is a global cgal_failed = false; Point cc = CGAL::circumcenter( a,b,c,d ); is_correct_computation = !cgal_failed; if(cgal_failed) { // set cc a junk value. It's not the duty of // this function to find out what the correct // circumcenter should be. cc = CGAL::ORIGIN; } //put everything back the way we found it, CGAL::set_error_handler(old_ff); CGAL::set_error_behaviour(old_fb); //see ya! I'm outta here! if(cc == CGAL::ORIGIN) cerr << "" << endl; return cc; } // ------------------------------------------------------------- // dg_voronoi_point // ------------------------------------------------------------- // This function computes a voronoi point when some degeneracies // have been discovered about the four points of a tetrahedron. // // In this function we assume that the degeneracies occured // because of the coplanarity. We approximate the circumcenter // of the tetrahedron by the circumcenter of one of the triangular // facets. // ------------------------------------------------------------- Point dg_voronoi_point(const Point &a, const Point &b, const Point &c, const Point &d, bool &is_correct_computation) { // First, we check if our assumption is correct. // This is more of a debugging purpose than of // actual computation. Tetrahedron t = Tetrahedron(a,b,c,d); if( ! t.is_degenerate() ) { // cerr << "error in the assumption of coplanarity." << endl; /* // debug cout << "{OFF " << endl; cout << "4 4 0" << endl; cout << a << "\n" << b << "\n" << c << "\n" << d << endl; cout << "3\t0 1 2" << endl; cout << "3\t0 2 3" << endl; cout << "3\t0 3 1" << endl; cout << "3\t1 2 3" << endl; cout << "}" << endl; // end debug */ } // Approximate the circumcenter of the tetrahedron with that of // one of its triangular facets. The facet should not be collinear. // The following boolean variable will keep track if we have found // a valid circumcenter (of a triangle) to replace that of a // tetrahedron. Point cc = CGAL::ORIGIN; is_correct_computation = false; Point p[4] = {a,b,c,d}; for(int i = 0; i < 4; i ++) { // first check if the facet is degenerate or not. Triangle_3 t = Triangle_3(p[(i+1)%4], p[(i+2)%4], p[(i+3)%4]); if( t.is_degenerate() ) continue; // since we found a non-degenerate triangle we can now compute // its circumcenter and we will be done. cc = nondg_cc_tr_3(p[(i+1)%4], p[(i+2)%4], p[(i+3)%4], is_correct_computation); if( is_correct_computation ) break; } if( is_correct_computation ) { if(cc == CGAL::ORIGIN) cerr << "" << endl; return cc; } cerr << "four points are colinear. " << endl; // for the time being, I just average the four points. What should be // the circumcenter of a tetrahedron whose four points are collinear ? cc = CGAL::ORIGIN + ( 0.25*Vector ( a[0]+b[0]+c[0]+d[0], a[1]+b[1]+c[1]+d[1], a[2]+b[2]+c[2]+d[2] ) ); if(cc == CGAL::ORIGIN) cerr << "" << endl; return cc; } // ------------------------------------------------------------- // nondg_cc_tr_3 // ------------------------------------------------------------- // This function computes the circumcenter of a triangle in 3D. // It doesn't assume any degeneracy but in case it happens it // will set a flag which has been passed as parameter. // ------------------------------------------------------------- Point nondg_cc_tr_3(const Point &a, const Point &b, const Point &c, bool &is_correct_computation) { //we tell CGAL to call our function if there is a problem //we also tell it not to die if things go haywire CGAL::Failure_function old_ff = CGAL::set_error_handler(failure_func); CGAL::Failure_behaviour old_fb = CGAL::set_error_behaviour(CGAL::CONTINUE); // be optimistic :-) //this is a global cgal_failed = false; Point cc = CGAL::circumcenter( a,b,c ); is_correct_computation = !cgal_failed; if(cgal_failed) { // set cc a junk value. It's not the duty of // this function to find out what the correct // circumcenter should be. cc = CGAL::ORIGIN; } //put everything back the way we found it, CGAL::set_error_handler(old_ff); CGAL::set_error_behaviour(old_fb); return cc; } // ------------------------------------------------------------- // cc_tr_3 // ------------------------------------------------------------- // This function computes the circumcenter of a triangle in 3D. // It doesn't assume any degeneracy and calls nondg function to // do the job. The nondg function checks if there is any deg and // sets a flag. Then this function will approximate the cc as the // average of the three points passed as the parameters. // ------------------------------------------------------------- Point cc_tr_3(const Point &a, const Point &b, const Point &c) { bool is_correct_computation = true; // call nondg function which will set is_correct_computation // depending on the degeneracy. Point cc = nondg_cc_tr_3(a,b,c,is_correct_computation); if( is_correct_computation ) return cc; cerr << "< Bad cc of triangle > "; // if the three points were degenerate (collinear) then // we approximate the circumcenter by the average of the // three points. cc = CGAL::ORIGIN + ( (1./3.)*Vector ( a[0]+b[0]+c[0], a[1]+b[1]+c[1], a[2]+b[2]+c[2] ) ); return cc; } // ------------------------------------------------------------- // sq_cr_tr_3 // ------------------------------------------------------------- // This function computes the squared circumradius of a triangle in 3D. // It calls cc_tr_3 to get the circumcenter and then computes the // radius. // ------------------------------------------------------------- double sq_cr_tr_3(const Point &a, const Point &b, const Point &c) { Point cc = cc_tr_3(a,b,c); double r = CGAL::to_double((cc - a)*(cc - a)); CGAL_assertion( (r > 0) && (! isnan(r)) && (! isinf(r)) ); return r; } Point circumcenter(const Facet& f) { Cell_handle c = f.first; int id = f.second; Point p[3]; for(int i = 0; i < 3; i ++) p[i] = c->vertex((id + (i+1))%4)->point(); return cc_tr_3(p[0], p[1], p[2]); } double circumradius(const Facet& f) { Point c = circumcenter(f); Point p = f.first->vertex((f.second+1)%4)->point(); return sqrt(CGAL::to_double((p-c)*(p-c))); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/init.C0000644000175000017500000001543311344301500023526 0ustar debiandebian #include "init.h" #include "robust_cc.h" #include "op.h" // --------------------------------------------------------- // initialize // ---------- // Initialize some of the attributes of the triangulation. // --------------------------------------------------------- void initialize(Triangulation &triang) { // set vertex id. int id = 0; for(FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); vit ++) { vit->id = id++; vit->visited = false; vit->bad = false; vit->bad_neighbor = false; } // set cell id. id = 0; for(ACI cit = triang.all_cells_begin(); cit != triang.all_cells_end(); cit ++) { cit->id = id++; cit->visited = false; cit->outside = false; cit->transp = false; for(int id = 0 ; id < 4; id++) { cit->set_cocone_flag(id,false); cit->neighbor(id)->set_cocone_flag(cit->neighbor(id)->index(cit),false); cit->bdy[id] = false; cit->opaque[id] = false; for(int k = 0; k < 4; k ++) cit->umbrella_member[id][k] = -1; } // set the convex hull points. if(! triang.is_infinite(cit)) continue; for(int i = 0; i < 4; i ++) { if(! triang.is_infinite(cit->vertex(i))) continue; cit->vertex((i+1)%4)->set_convex_hull(true); cit->vertex((i+2)%4)->set_convex_hull(true); cit->vertex((i+3)%4)->set_convex_hull(true); } } } // --------------------------------------------------------- // compute_voronoi_vertex_and_cell_radius // -------------------------------------- // Compute all the finite voronoi vertices and the circumradius // of all the finite cells. // --------------------------------------------------------- void compute_voronoi_vertex_and_cell_radius(Triangulation &triang) { bool is_there_any_problem_in_VV_computation = false; for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { // For each cell call the circumcenter computation. // The function will set a boolean variable passed // as a parameter showing if the computation is correct. bool is_correct_computation = true; cit->set_voronoi(nondg_voronoi_point( cit->vertex(0)->point(), cit->vertex(1)->point(), cit->vertex(2)->point(), cit->vertex(3)->point(), is_correct_computation ) ); is_there_any_problem_in_VV_computation |= !is_correct_computation; // The problem arises when the computation is not correct // that is, when is_correct_computation = false. // If is_correct_computation = true then we need to check // the radius. Sometimes, even if the circumcenter computation // is correct, radius of the cell is too big to fit in double // and that creates a problem. Sometimes, (possibly due to // overflow) it is <= 0. In the next loop we will check for // the validity of radius and if that also works well we will // return. Otherwise, we will go the next part where the // degeneracies are taken care of. if( is_correct_computation ) { bool is_correct_radius = true; // check if the radius fits good in double. double r = CGAL::to_double((cit->voronoi() - cit->vertex(0)->point()) * (cit->voronoi() - cit->vertex(0)->point()) ); if( isnan(r) || isinf(r) ) is_correct_radius = false; if( r <= 0 ) is_correct_radius = false; // if it does, go back and collect the next cell // and do the same computation. if( is_correct_radius ) continue; is_there_any_problem_in_VV_computation |= !is_correct_radius; } cerr << " < bad > "; cit->set_dirty(true); // The flow comes here means either the voronoi computation // is incorrect or the cell radius is junk. // Either case, we need to take measures. // Our assumption is // This happens when the four points of the cell are coplanar // atleast that is reflected by the choice of arithmatic. // Our approach is to approximate the circumcenter of the cell // by the circumcenter of one of the triangular facets. cit->set_voronoi(dg_voronoi_point( cit->vertex(0)->point(), cit->vertex(1)->point(), cit->vertex(2)->point(), cit->vertex(3)->point(), is_correct_computation ) ); // debug // Certain checks to make sure we are not setting anything bad // about the voronoi information in any cell. double cx = CGAL::to_double(cit->voronoi().x()); double cy = CGAL::to_double(cit->voronoi().y()); double cz = CGAL::to_double(cit->voronoi().z()); // check 1 : the coordinates of the voronoi point fits well in double. CGAL_assertion( ( ( ! isnan(cx)) && ( ! isinf(cx)) ) && ( ( ! isnan(cy)) && ( ! isinf(cy)) ) && ( ( ! isnan(cz)) && ( ! isinf(cz)) ) ); // check 2 : the radius of the cell fits well in double and is non-negative. double r = CGAL::to_double((cit->voronoi() - cit->vertex(0)->point()) * (cit->voronoi() - cit->vertex(0)->point()) ); CGAL_assertion( r > 0 && ! isnan(r) && ! isinf(r) ); // end debug } if(is_there_any_problem_in_VV_computation) { ofstream fout; fout.open("degen_tetra"); for(FCI cit = triang.finite_cells_begin(); cit != triang.finite_cells_end(); cit ++) { if(cit->dirty()) { draw_tetra(cit, 1, 1, 0, 1, fout); continue; } if(cit->voronoi() == CGAL::ORIGIN) { draw_tetra(cit, 0, 1, 0, 1, fout); continue; } } fout.close(); } return; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/kdtree.h0000644000175000017500000000712111344301500024101 0ustar debiandebian#ifndef __KDTREE_H_ #define __KDTREE_H_ #include "priorityqueue.h" #include "matrix.h" #include using namespace std; #define SQ(x) (x*x) #define MYNZERO 1e-20 typedef MaxPriorityQueue PQueue; typedef PQueue::Element Neighbour; typedef struct point { VECTOR3 pos; int index; } MyPoint; /** * abstract node class * base class for leaves and nodes */ class Node { public: virtual void queryNode(double rd, PQueue* queryPriorityQueue) = 0; virtual void print_node() = 0; }; class KdNode : public Node { public: KdNode(){ _lchild = NULL; _rchild = NULL; } virtual ~KdNode() { if(_lchild) delete _lchild; if(_rchild) delete _rchild; } Node* _lchild; Node* _rchild; double _cutVal; unsigned char _dim; void queryNode(double rd, PQueue* queryPriorityQueue); //debug void print_node(); }; class KdLeaf : public Node { public: MyPoint* _points; unsigned int _nOfElements; void queryNode(double rd, PQueue* queryPriorityQueue); //debug void print_node(); }; /** * An efficient k-d tree for 3 dimensions * It is very similar to the k-d tree * described by Arya and Mount in ``Algorithms * for fast vector quantization,'' Proc. of DCC '93: Data Compression * Conference, eds. J. A. Storer and M. Cohn, IEEE Press, 1993, 381-390 * and their ANN software library */ class KdTree { public: KdTree(const VECTOR3 *positions, const unsigned int nOfPositions, const unsigned int maxBucketSize); KdTree(const vector& positions, const unsigned int maxBucketSize); ~KdTree(); void queryPosition(const VECTOR3 &position); void queryRange(const VECTOR3 &position, const double maxSqrDistance); void setNOfNeighbours (const unsigned int newNOfNeighbours); inline unsigned int getNeighbourPositionIndex (const unsigned int i); inline VECTOR3 getNeighbourPosition(const unsigned int i); inline double getSquaredDistance (const unsigned int i); inline unsigned int getNOfFoundNeighbours(); protected: double computeBoxDistance(const VECTOR3 &q, const VECTOR3 &lo, const VECTOR3 &hi); void computeEnclosingBoundingBox(VECTOR3 &lowCorner, VECTOR3 &hiCorner); void createTree(KdNode &node, int start, int end, VECTOR3 maximum, VECTOR3 minimum); private: MyPoint* _points; const VECTOR3* _positions; Neighbour* _neighbours; int _bucketSize; KdNode* _root; unsigned int _nOfFoundNeighbours, _nOfNeighbours, _nOfPositions; PQueue* _queryPriorityQueue; VECTOR3 _boundingBoxLowCorner; VECTOR3 _boundingBoxHighCorner; void getMinMax(MyPoint *points, int nOfPoints, int dim, double &min, double &max); void splitAtMid(MyPoint *points, int nOfPoints, int dim, double cutVal, int &br1, int &br2); void getSpread(MyPoint* points, int nOfPoints, VECTOR3 &maximum, VECTOR3 &minimum); }; inline unsigned int KdTree::getNOfFoundNeighbours() { return _nOfFoundNeighbours; } inline unsigned int KdTree::getNeighbourPositionIndex(const unsigned int neighbourIndex) { return _neighbours[neighbourIndex].index; } //----------------------------------------------------- //this function is not efficient, try your best to avoid to use it. inline VECTOR3 KdTree::getNeighbourPosition(const unsigned int neighbourIndex) { for (unsigned int i = 0; i < _nOfPositions; i++) { if (_points[i].index == _neighbours[neighbourIndex].index) { return _points[i].pos; } } return VECTOR3(0, 0, 0); // VECTOR3 ret = _points[_neighbours[neighbourIndex].index].pos; // return ret; } inline double KdTree::getSquaredDistance (const unsigned int neighbourIndex) { return _neighbours[neighbourIndex].weight; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/dt.C0000644000175000017500000000265011344301500023167 0ustar debiandebian #include "dt.h" // ----------------------------------------------------------------------- // Constants // ----------------------------------------------------------------------- // -- flatness marking --- const double DEFAULT_ANGLE = M_PI / 8.0; // Half of the co-cone angle. const double DEFAULT_SHARP = 2 * M_PI / 3.0; // Angle of sharp edges. const double DEFAULT_RATIO = 1.2 * 1.2; // Squared thinness factor. const double DEFAULT_FLAT = M_PI / 3.0; // Angle for flatness Test // -- robust cocone --- const double DEFAULT_BIGBALL_RATIO = (1./4.)*(1./4.); // parameter to choose big balls. const double DEFAULT_THETA_IF_d = 5.0; // parameter for infinite-finite deep intersection. const double DEFAULT_THETA_FF_d = 10.0; // parameter for finite-finite deep intersection. void recon( const vector& pts, Triangulation& triang) { // for flatness marking (in cocone) double flatness_ratio = DEFAULT_RATIO; double cocone_phi = DEFAULT_ANGLE; double flat_phi = DEFAULT_FLAT; for(int i = 0; i < pts.size(); i ++) triang.insert(pts[i]); // --- Init ---- cerr << "Init "; initialize(triang); cerr << "."; // compute voronoi vertex compute_voronoi_vertex_and_cell_radius(triang); cerr << ". done." << endl; // ---- Reconstruction ----- cerr << "TC "; tcocone(cocone_phi, DEFAULT_SHARP, flat_phi, flatness_ratio, triang); cerr << " done." << endl; write_wt(triang, "test"); return; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/datastruct.h0000644000175000017500000002271711344301500025011 0ustar debiandebian#ifndef DATASTRUCT_H #define DATASTRUCT_H #include #include #include #include #include #include #include #include #include #include // for compiler discrepancies #include #include #include #include #include // implements Traits. #include #include #include #include using namespace std; // ----------------------------------------------------------------------- // Define a new Vertex_base with additional attributes. // ----------------------------------------------------------------------- template < class Gt, class Vb = CGAL::Triangulation_vertex_base_3 > class LRec_vertex : public Vb { typedef Vb Base; public: typedef typename Vb::Point Point; typedef typename Point::R Rep; typedef typename Vb::Vertex_handle Vertex_handle; typedef typename Vb::Cell_handle Cell_handle; typedef CGAL::Vector_3 Vector; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef LRec_vertex Other; }; LRec_vertex() { init(); } LRec_vertex( const Point& p) : Base(p) { init(); } LRec_vertex( const Point& p, void* cell) : Base(p, cell) { init(); } LRec_vertex( void* cell) : Base(cell) { init(); } // Member functions for TightCocone void set_normal( const Vector& v) { v_normal = v; } Vector normal() const { return v_normal; } void set_pole( const Point& p) { v_pole = p; } Point pole() const { return v_pole; } void set_width( const double& w) { v_width = w; } double width() const { return v_width; } void set_diameter( const double& d) { v_diameter = d; } double diameter() const { return v_diameter; } void set_flat( const bool b) { v_flat = b; } bool is_flat() const { return v_flat; } void set_convex_hull( const bool b) { v_chull = b; } bool on_convex_hull() const { return v_chull; } void set_isolated( const bool b) { v_isolated = b; } bool is_isolated() const { return v_isolated; } void set_umbrella( const bool b) { v_umbrella = b; } bool has_umbrella() const { return v_umbrella; } void set_on_smooth_surface( const bool b) { v_on_smooth_surface = b; } bool on_smooth_surface() const { return v_on_smooth_surface; } // Public member needed for robust cocone vector nnd_vector; // General purpose int id; bool tag; bool visited; int label; // For TightCocone bool bad; bool bad_neighbor; vector bad_v; // For Medial Axis vector normal_stack; // Used to store the normals of the // incident disk private: inline void init() { v_normal = CGAL::NULL_VECTOR; v_pole = this->point(); v_width = 0.0; v_diameter = 0.0; v_flat = true; v_chull = false; v_umbrella = false; v_isolated = true; v_on_smooth_surface = false; nnd_vector.clear(); nnd_vector.resize(3, HUGE); // init of general purpose fields. id = -1; tag = false; visited = false; label = -1; } Vector v_normal; // Estimated normal at the vertex. Point v_pole; // The negative pole. double v_width; // Radius of the cocone. double v_diameter; // Diamter of the the incident umbrella. bool v_flat; // Indicates whether the vertex is flat. bool v_chull; // Indicates wheter the vertex lies on the boundary // of the convex hull. bool v_umbrella; // Indicates if v has a (non sharp) umbrella. bool v_isolated; // Indicates whether the vertex is isolated. bool v_on_smooth_surface; // Indicates whether, after RobustCocone, // the vertex is selected. }; // ----------------------------------------------------------------------- // Define a new Cell_base storing associated Voronoi vertices // and cocone flags. // ----------------------------------------------------------------------- template < class Gt, class Cb = CGAL::Triangulation_cell_base_3 > class LRec_cell : public Cb { typedef Cb Base; public: typedef typename Cb::Point Point; typedef typename Cb::Vertex_handle Vertex_handle; typedef typename Cb::Cell_handle Cell_handle; LRec_cell() { init(); } LRec_cell( Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3 ) : Base(v0,v1,v2,v3) { init(); } LRec_cell( Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Cell_handle c0, Cell_handle c1, Cell_handle c2, Cell_handle c3 ) : Base(v0,v1,v2,v3,c0,c1,c2,c3) { init(); } template < typename TDS2 > struct Rebind_TDS { typedef typename Cb::template Rebind_TDS::Other Cb2; typedef LRec_cell Other; }; // Member functions for TightCocone void set_voronoi( const Point& p) { c_voronoi = p; } Point voronoi() const { return c_voronoi; } void set_cocone_flag( int i, bool new_value) { CGAL_precondition( 0 <= i && i < 4); c_cocone_flag[i] = new_value; } bool cocone_flag( int i) const { CGAL_precondition( 0 <= i && i < 4); return c_cocone_flag[i]; } void set_removable( int i, bool new_value) { CGAL_precondition( 0 <= i && i < 4); c_removable[i] = new_value; } bool removable( int i) const { CGAL_precondition( 0 <= i && i < 4); return c_removable[i]; } // End // Member functions for Robust Cocone void set_cell_radius( const double r) { c_cell_radius = r; } double cell_radius() const { return c_cell_radius; } void set_bb( const bool flag) { c_bb = flag; } bool bb() const { return c_bb; } void set_deep_int(const int i, const bool flag) { c_deep_int[i] = flag; } bool deep_int(int i) const { return c_deep_int[i]; } // End void set_dirty(const bool& b) { c_dirty = b; } bool dirty() const { return c_dirty; } // Members for TightCocone bool outside; bool bdy[4]; bool opaque[4]; bool transp; int umbrella_member[4][4]; // General purpose members. bool tag[4]; int id; bool flag; bool visited; bool f_visited[4]; bool e_visited[4][4]; bool e_tag[4][4]; inline void init() { id = -1; visited = false; c_dirty = false; outside = false; c_cell_radius = 0.0; c_bb = false; for ( int i = 0; i < 4; ++i) { f_visited[i] = false; c_cocone_flag[i] = false; c_removable[i] = true; c_deep_int[i] = false; for(int j = 0; j < 4; j ++) { e_visited[i][j] = false; e_tag[i][j] = false; } } } private: Point c_voronoi; bool c_cocone_flag[4]; bool c_removable[4]; bool c_VV_on_medax; bool c_VF_on_medax[4][4]; // dual VF of edge btn i<->j is in medial axis double c_cell_radius; bool c_deep_int[4]; bool c_bb; bool c_dirty; }; struct K : CGAL::Exact_predicates_inexact_constructions_kernel {}; typedef LRec_vertex< K > Vertex; typedef LRec_cell< K > Cell; typedef CGAL::Triangulation_data_structure_3 TDS; typedef CGAL::Delaunay_triangulation_3 Triangulation; typedef Triangulation::Point Point; typedef Point::R Rep; typedef CGAL::Vector_3 Vector; typedef CGAL::Ray_3 Ray; typedef CGAL::Segment_3 Segment; typedef CGAL::Triangle_3 Triangle_3; typedef CGAL::Plane_3 Plane_3; typedef CGAL::Tetrahedron_3 Tetrahedron; typedef Triangulation::Vertex_handle Vertex_handle; typedef Triangulation::Edge Edge; typedef Triangulation::Facet Facet; typedef Triangulation::Cell_handle Cell_handle; typedef Triangulation::Finite_vertices_iterator FVI; typedef Triangulation::Finite_edges_iterator FEI; typedef Triangulation::Finite_facets_iterator FFI; typedef Triangulation::Finite_cells_iterator FCI; typedef Triangulation::All_vertices_iterator AVI; typedef Triangulation::All_edges_iterator AEI; typedef Triangulation::All_facets_iterator AFI; typedef Triangulation::All_cells_iterator ACI; typedef Triangulation::Facet_circulator Facet_circulator; typedef Triangulation::Cell_circulator Cell_circulator; #endif //DATASTRUCT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/sdf.C0000644000175000017500000000606411344322224023345 0ustar debiandebian #include "sdf.h" float sdf( const Point& q, const Mesh &mesh, const vector& weights, KdTree& kd_tree, const Triangulation& triang, double maxval, double minval) { VECTOR3 query (CGAL::to_double(q.x()), CGAL::to_double(q.y()), CGAL::to_double(q.z())); kd_tree.queryPosition(query); // Initialize the search structure, and search all N points int n_vid = kd_tree.getNeighbourPositionIndex(0); CGAL_assertion( ! mesh.vert_list[n_vid].iso()); MVertex nv = mesh.vert_list[n_vid]; double min_sq_d = HUGE; int n_fid = -1; for(int i = 0; i < nv.num_inc_face; i ++) { MFace f = mesh.face_list[nv.inc_face(i)]; Point p[3] = {mesh.vert_list[f.get_corner(0)].point(), mesh.vert_list[f.get_corner(1)].point(), mesh.vert_list[f.get_corner(2)].point()}; Triangle_3 t (p[0], p[1], p[2]); Plane_3 H (p[0], p[1], p[2]); Point _q = H.projection(q); // check if _q is inside t. if( t.has_on(_q) ) { double sq_d = CGAL::to_double((q-_q)*(q-_q)); if( sq_d < min_sq_d ) { min_sq_d = sq_d; n_fid = nv.inc_face(i); } } else { for(int j = 0; j < 3; j ++) { double _d = CGAL::to_double(CGAL::squared_distance(_q,Segment(p[j], p[(j+1)%3]))); double sq_d = CGAL::to_double((q-_q)*(q-_q)) + _d; if( sq_d < min_sq_d ) { min_sq_d = sq_d; n_fid = nv.inc_face(i); } } } } // locate the query point in the triang which is already tagged // with in-out flag by the reconstruction. bool is_q_outside = false; Triangulation::Locate_type lt; int u = -1, v = -1; Cell_handle c = triang.locate(q, lt, u, v); if( lt == Triangulation::OUTSIDE_AFFINE_HULL ) { is_q_outside = true; cerr << "Point " << q << " is outside the affine hull." << endl; } else if( lt == Triangulation::OUTSIDE_CONVEX_HULL ) is_q_outside = true; else { if( lt == Triangulation::CELL ) { if( c->outside ) is_q_outside = true; else is_q_outside = false; } else if( lt == Triangulation::FACET ) { Cell_handle _c = c->neighbor(u); if( c->outside && _c->outside ) is_q_outside = true; else is_q_outside = false; } else if( lt == Triangulation::EDGE ) { if( is_outside_VF(triang, Edge(c, u, v)) ) is_q_outside = true; else is_q_outside = false; } else { CGAL_assertion( lt == Triangulation::VERTEX ); is_q_outside = false; } } double w; if(weights.size() && mesh.face_list[n_fid].label != -1) w = weights[mesh.face_list[n_fid].label]; else w = 1.0; // double w = mesh.face_list[n_fid].w; double gen_sdf = 0; if( is_q_outside ) gen_sdf = w*sqrt(min_sq_d); else gen_sdf = -w*min_sq_d; //double MAX = 10, MIN = -10; //if( gen_sdf > MAX ) gen_sdf = MAX; //if( gen_sdf < MIN ) gen_sdf = MIN; if( gen_sdf > maxval ) gen_sdf = maxval; if( gen_sdf < minval) gen_sdf = minval; return gen_sdf; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/util.C0000644000175000017500000002501411344301500023534 0ustar debiandebian #include "util.h" // --------------------------------------- // cosine // ------------- // Given two vectors v and w find the cosine // of the angle between v and w // --------------------------------------- double cosine( const Vector& v, const Vector& w) { return CGAL::to_double( v * w) / sqrt( CGAL::to_double( v * v) * CGAL::to_double( w * w)); } // ----------- // normalize // ----------- // Given a vector v, normalize it // ----------- void normalize(Vector& v) { v = (1./(sqrt(CGAL::to_double(v*v))))*v; return; } // check if the angle 90 degree bool is_obtuse(const Point& p0, const Point& p1, const Point& p2) { Vector v0 = p0 - p2; Vector v1 = p1 - p2; return (CGAL::to_double(v0 * v1) < 0); } double length_of_seg(const Segment& s) { return sqrt(CGAL::to_double((s.point(0) - s.point(1))*(s.point(0) - s.point(1)))); } // Find the index of the third vertex for a facet where this vertex // is neither *v nor *w. int find_third_vertex_index( const Facet& f, Vertex_handle v, Vertex_handle w) { int id = f.second; for ( int i =1; i <= 3; ++i) { if ( f.first->vertex((id+i)%4) != v && f.first->vertex((id+i)%4) != w) return (id+i)%4; } return -1; } // Compute the index of an edge. The index of an edge in a facet // is defined as the index of a facet in cell, i.e. it is the index // of the opposite vertex. The arguments are the facet index of the // facet witth respect to the cell and the indices of the vertices // incident to the edge also with respect to the cell. int edge_index( const int facet_index, const int first_vertex_index, const int second_vertex_index) { return 6 - facet_index - first_vertex_index - second_vertex_index; } // --------------------------------------- // vertex_indices // -------------- // Compute the indices of the vertices // incident to an edge. Given, facet_id // and edge_id. // --------------------------------------- void vertex_indices( const int facet_index, const int edge_index, int& first_vertex, int& second_vertex) { if ( (facet_index == 0 && edge_index == 1) || (facet_index == 1 && edge_index == 0)) { first_vertex = 2; second_vertex = 3; } else if ( (facet_index == 0 && edge_index == 2) || (facet_index == 2 && edge_index == 0)) { first_vertex = 1; second_vertex = 3; } else if ( (facet_index == 0 && edge_index == 3) || (facet_index == 3 && edge_index == 0)) { first_vertex = 1; second_vertex = 2; } else if ( (facet_index == 1 && edge_index == 2) || (facet_index == 2 && edge_index == 1)) { first_vertex = 0; second_vertex = 3; } else if ( (facet_index == 1 && edge_index == 3) || (facet_index == 3 && edge_index == 1)) { first_vertex = 0; second_vertex = 2; } else if ( (facet_index == 2 && edge_index == 3) || (facet_index == 3 && edge_index == 2)) { first_vertex = 0; second_vertex = 1; } } // ------------------------ // is_same_side_of_ray // ------------------------ // Given a ray and two points a and b find out if a and // b is in the same side of the ray. // // Assumption: The ray, a and b are in the same plane. // // [*] Instead of the Ray we will work on a pair of points // (p0, p1) where p1 is dummy and can be shifted. [*] // ------------------------- bool is_same_side_of_ray(const Point& p0, const Point& p1, const Point& a, const Point& b) { return (CGAL::to_double(CGAL::cross_product(p1 - p0, a - p1)* CGAL::cross_product(p1 - p0, b - p1)) >= 0); } // -------------------------- // is_contained_in_inf_tr // -------------------------- // Given two rays and a segment find out if the segment // is fully/partially contained in the infinite triangle. // // Parameters: ray 1 = (p0, p1), ray 2 = (p0, p2). // Both p1 and p2 are just two points on the rays. // segment = (a, b) // [*] Note: a or b can coincide with p1 or p2. // coincidence_vector records that information. // coincidence_vector[0] = {0,1,2} - matches with none, p1, p2. // coincidence_vector[1] = {0,1,2} - matches with none, p1, p2. // two booleans co0 and co1 indicate that. // Result will be stored in contained[]. // contained[0] says if a is within the fan. // contained[1] says if b is within the fan. // If both entries true the segment is fully contained. // If both entries false the segment is fully outside. // Otherwise it's partially contained. // --------------------------- void is_contained_in_inf_tr(const Point& p0, const Point& p1, const Point& p2, const Point& a, const Point& b, const vector& coincidence_vector, bool* contained) { if( coincidence_vector[0] == 0 && coincidence_vector[1] == 0) { // point a is within the opening (or visible by p0) if // it is in the same side of ray1 (p0, p1) as p2 is and // it is in the same side of ray2 (p0, p2) as p1 is. contained[0] = is_same_side_of_ray(p0, p1, p2, a) && is_same_side_of_ray(p0, p2, p1, a); // same for b. contained[1] = is_same_side_of_ray(p0, p1, p2, b) && is_same_side_of_ray(p0, p2, p1, b); return; } else { // point a = p1 and b doesn't match. if(coincidence_vector[0] == 1 && coincidence_vector[1] == 0) { if( ! is_same_side_of_ray(p0, p1, p2, b) ) contained[0] = contained[1] = false; else { contained[0] = true; if( is_same_side_of_ray(p0, p2, p1, b) ) contained[1] = true; else contained[1] = false; } return; } // point a = p2 and b doesn't match. if(coincidence_vector[0] == 2 && coincidence_vector[1] == 0) { if( ! is_same_side_of_ray(p0, p2, p1, b) ) contained[0] = contained[1] = false; else { contained[0] = true; if( is_same_side_of_ray(p0, p1, p2, b) ) contained[1] = true; else contained[1] = false; } return; } // point b = p1 and a doesn't match. if(coincidence_vector[0] == 0 && coincidence_vector[1] == 1) { if( ! is_same_side_of_ray(p0, p1, p2, a) ) contained[0] = contained[1] = false; else { contained[1] = true; if( is_same_side_of_ray(p0, p2, p1, a) ) contained[0] = true; else contained[0] = false; } return; } // point b = p2 and a doesn't match. if(coincidence_vector[0] == 0 && coincidence_vector[1] == 2) { if( ! is_same_side_of_ray(p0, p2, p1, a) ) contained[0] = contained[1] = false; else { contained[1] = true; if( is_same_side_of_ray(p0, p1, p2, a) ) contained[0] = true; else contained[0] = false; } return; } // otherwise the segment(a,b) coincides with the segment(p1,p2). // the segment must be contained in the inf_tr (p0, p1, p2). contained[0] = true; contained[1] = true; return; } return; } // ------------------------ // is_outside_bounding_box // ------------------------ // Given a bounding_box and a set of points // find if any point is outside the bounding_box // ------------------------ bool is_outside_bounding_box(const Point& p, const vector& bounding_box) { if(CGAL::to_double(p.x()) < bounding_box[0] || CGAL::to_double(p.x()) > bounding_box[1] || CGAL::to_double(p.y()) < bounding_box[2] || CGAL::to_double(p.y()) > bounding_box[3] || CGAL::to_double(p.z()) < bounding_box[4] || CGAL::to_double(p.z()) > bounding_box[5] ) return true; return false; } // ------------------------ // is_outside_bounding_box // ------------------------ // Given a bounding_box and a set of points // find if any point is outside the bounding_box // ------------------------ bool is_outside_bounding_box(const vector& points, const vector& bounding_box) { for(int i = 0; i < (int)points.size(); i ++) { Point p = points[i]; if( is_outside_bounding_box(p, bounding_box) ) return true; } return false; } // ------------------------ // is_VF_outside_bounding_box // ------------------------ // Given a bounding_box and a VF // find if any VV of VF is outside the bounding_box // ------------------------ bool is_VF_outside_bounding_box(const Triangulation& triang, const Edge& e, const vector& bounding_box) { Facet_circulator fcirc = triang.incident_facets(e); Facet_circulator begin = fcirc; do{ if(is_outside_bounding_box((*fcirc).first->voronoi(), bounding_box)) return true; fcirc ++; } while(fcirc != begin); return false; } bool is_outside_VF(const Triangulation& triang, const Edge& e) { Facet_circulator fcirc = triang.incident_facets(e); Facet_circulator begin = fcirc; do{ if( ! (*fcirc).first->outside) return false; fcirc ++; } while(fcirc != begin); return true; } bool is_inside_VF(const Triangulation& triang, const Edge& e) { Facet_circulator fcirc = triang.incident_facets(e); Facet_circulator begin = fcirc; do{ if((*fcirc).first->outside) return false; fcirc ++; } while(fcirc != begin); return true; } bool is_surf_VF(const Triangulation& triang, const Edge& e) { Facet_circulator fcirc = triang.incident_facets(Edge(e)); Facet_circulator begin = fcirc; bool in = false, out = false; do{ Cell_handle cur_c = (*fcirc).first; if( cur_c->outside ) out = true; else in = true; // int cur_fid = (*fcirc).second; // if(cur_c->cocone_flag(cur_fid) ) return true; fcirc ++; } while(fcirc != begin); return (in && out); } bool is_inf_VF(const Triangulation& triang, const Cell_handle& c, const int uid, const int vid) { Facet_circulator fcirc = triang.incident_facets(Edge(c,uid,vid)); Facet_circulator begin = fcirc; do{ Cell_handle cur_c = (*fcirc).first; if( triang.is_infinite( cur_c ) ) return true; fcirc ++; } while(fcirc != begin); return false; } bool is_there_any_common_element(const vector& vec1, const vector& vec2) { for(int i = 0; i < (int) vec1.size(); i ++) for(int j = 0; j < (int) vec2.size(); j ++) if( vec1[i] == vec2[j] ) return true; return false; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/op.C0000644000175000017500000001423611344301500023201 0ustar debiandebian #include "op.h" extern vector bounding_box; void draw_ray(const Ray& ray, const double& r, const double& g, const double& b, const double& a, ofstream& fout) { fout << "{OFF" << endl; fout << "2 1 0" << endl; fout << ray.source() << endl; fout << (ray.source() - CGAL::ORIGIN) + ray.to_vector() << endl; fout << "2\t0 1 " << r << " " << g << " " << b << " " << a << endl; fout << "}" << endl; } void draw_segment(const Segment& segment, const double& r, const double& g, const double& b, const double& a, ofstream& fout) { fout << "{OFF" << endl; fout << "2 1 0" << endl; fout << segment.point(0) << endl; fout << segment.point(1) << endl; fout << "2\t0 1 " << r << " " << g << " " << b << " " << a << endl; fout << "}" << endl; } void draw_poly(const vector& poly, const double& r, const double& g, const double& b, const double& a, ofstream& fout) { fout << "{OFF" << endl; fout << (int)poly.size() << " 1 0" << endl; for(int i = 0; i < (int)poly.size(); i ++) fout << poly[i] << endl; fout << (int)poly.size() << "\t"; for(int i = 0; i < (int)poly.size(); i ++) fout << i << " "; fout << r << " " << g << " " << b << " " << a << endl; fout << "}" << endl; } void draw_VF(const Triangulation& triang, const Edge& dual_e, const double& r, const double& g, const double& b, const double& a, ofstream& fout) { Facet_circulator fcirc = triang.incident_facets(dual_e); Facet_circulator begin = fcirc; vector vvset; do { Cell_handle cc = (*fcirc).first; vvset.push_back(cc->voronoi()); fcirc ++; } while(fcirc != begin); fout << "{OFF" << endl; fout << (int)vvset.size() << " 1 0" << endl; for(int i = 0; i < (int)vvset.size(); i ++) fout << vvset[i] << endl; fout << (int)vvset.size() << "\t"; for(int i = 0; i < (int)vvset.size(); i ++) fout << i << " "; fout << r << " " << g << " " << b << " " << a << endl; fout << "}" << endl; } void draw_tetra(const Cell_handle& cell, const double& r, const double& g, const double& b, const double& a, ofstream& fout) { fout << "{OFF" << endl; fout << "4 4 0" << endl; for(int i = 0; i < 4; i ++) fout << cell->vertex(i)->point() << endl; for(int i = 0; i < 4; i ++) fout << "3\t" << (i+1)%4 << " " << (i+2)%4 << " " << (i+3)%4 << " " << r << " " << g << " " << b << " " << a << endl; fout << "}" << endl; } void write_wt( const Triangulation &triang, const char* file_prefix) { char filename[100]; strcat(strcpy(filename, file_prefix), ".surf"); ofstream fout; fout.open(filename); if(! fout) { cerr << "Can not open " << filename << " for writing. " << endl; exit(1); } // Count number of facets on the surface. int num_facets = 0; for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) if((*fit).first->cocone_flag((*fit).second) ) num_facets ++; fout <<"OFF" << endl; fout << triang.number_of_vertices() << " " << num_facets << " 0" << endl; // Write the vertices. for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) fout << vit->point() << endl; // Write the facets. for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle c[2] = {(*fit).first, (*fit).first->neighbor((*fit).second)}; int id[2] = {c[0]->index(c[1]), c[1]->index(c[0])}; if(! c[0]->cocone_flag(id[0]) ) continue; CGAL_assertion( c[0]->bdy[id[0]] && c[1]->bdy[id[1]] ); CGAL_assertion( c[0]->outside != c[1]->outside ); Vertex_handle vh[3] = { c[0]->vertex((id[0]+1)%4), c[0]->vertex((id[0]+2)%4), c[0]->vertex((id[0]+3)%4) }; if( ! c[0]->outside ) if( CGAL::is_negative( Tetrahedron( vh[0]->point(), vh[1]->point(), vh[2]->point(), c[0]->vertex(id[0])->point() ).volume() ) ) fout << "3\t" << vh[0]->id << " " << vh[1]->id << " " << vh[2]->id << " "; else fout << "3\t" << vh[1]->id << " " << vh[0]->id << " " << vh[2]->id << " "; else if( CGAL::is_negative( Tetrahedron( vh[0]->point(), vh[1]->point(), vh[2]->point(), c[1]->vertex(id[1])->point() ).volume() ) ) fout << "3\t" << vh[0]->id << " " << vh[1]->id << " " << vh[2]->id << " "; else fout << "3\t" << vh[1]->id << " " << vh[0]->id << " " << vh[2]->id << " "; fout << endl; } fout.close(); return; } void write_iobdy( const Triangulation &triang, const char* file_prefix) { char filename[100]; strcat(strcpy(filename, file_prefix), ".io"); ofstream fout; fout.open(filename); if(! fout) { cerr << "Can not open " << filename << " for writing. " << endl; exit(1); } // Count int num_facets = 0; for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; if(ch->outside != ch->neighbor(id)->outside) num_facets ++; } // The header of the output file fout <<"OFF"; fout <<" " << triang.number_of_vertices(); //The number of points fout <<" " << num_facets; //The number of facets fout <<" 0" << endl; // Write the vertices. for ( FVI vit = triang.finite_vertices_begin(); vit != triang.finite_vertices_end(); ++vit) fout << vit->point() << endl; for ( FFI fit = triang.finite_facets_begin(); fit != triang.finite_facets_end(); ++fit) { Cell_handle ch = (*fit).first; int id = (*fit).second; if(ch->outside == ch->neighbor(id)->outside) continue; fout << " 3\t"; for (int i = 1; i <= 3; i++) fout << " " << ch->vertex((id+i)%4)->id; fout << "\t " << "1 1 1 1 \n"; ; } fout.close(); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/matrix.h0000644000175000017500000003547311344301500024142 0ustar debiandebian/////////////////////////////////////////////////////////////////// // Purpose: vector and matrix class and operations // Paper: Hierarchical Polygon Tiling with Coverage Masks // Created by: Matt Camuto // // Modification: // Time Programmer // 07-09-99 R. Wenger // 08-20-99 K. Boner // 07-15-00 J. Gao // 08-09-03 J. Sun /////////////////////////////////////////////////////////////////// #ifndef MATRIX_H #define MATRIX_H /////////////////////////////////////////////////////////////////// // 2d, 3d and 4d vector and matrix classes. // Supports vector and matrix addition and subtraction, // matrix multiplication, vector dot products, cross products, // normalization, etc. /////////////////////////////////////////////////////////////////// #include #include #include #include using namespace std; typedef unsigned int INT_32; extern void init_shift(); extern int is_bit_set(INT_32 value, int pos); extern void set_bit(INT_32 &value, int pos); // 16 bit structure used for bit mask class INT_64 { private : INT_32 vec[2]; public : INT_64() // constructor { Zero();}; INT_64(const INT_32 x0, const INT_32 x1) // constructor { vec[0] = x0; vec[1] = x1;}; ~INT_64() {}; int Dimension() const { return 2; }; INT_32 & operator [](const int i) // index i'th element { return(vec[i]); }; INT_32 operator ()(const int i) const // return i'th element { return(vec[i]); }; const INT_64 & operator =(const INT_64 & v0) // copy vector v0 { vec[0] = v0(0); vec[1] = v0(1); return(*this); }; void Zero() // make zero vector { vec[0] = vec[1] = 0; }; void Fullset() { vec[0] = ~0; vec[1] = ~0; }; void combine(INT_64 &v0) { vec[0] = vec[0] | v0[0]; vec[1] = vec[1] | v0[1]; } void combine2(INT_32 &v0, INT_32 &v1) { vec[0] = vec[0] | v0; vec[1] = vec[1] | v1; } void set_bit(int pos); int is_set(int pos); int is_zero() { if (vec[0] || vec[1]) return 0; return 1; }; int is_full() { INT_32 full = ~0; if ((vec[0]==full)&&(vec[1]==full)) return 1; return 0; }; void print(FILE *fp) const {fprintf(fp, "%d, %d", vec[0], vec[1]); }; }; // 2d vector used for Point class VECTOR2 { private : double vec[2]; public : VECTOR2() // constructor { Zero(); }; VECTOR2(const double x0, const double x1) // constructor { vec[0] = x0; vec[1] = x1;}; int Dimension() const { return 2; }; double & operator [](const int i) // index i'th element { return(vec[i]); }; double operator ()(const int i) const // return i'th element { return(vec[i]); }; const VECTOR2 & operator =(const VECTOR2 & v0) // copy vector v0 { vec[0] = v0(0); vec[1] = v0(1); return(*this); }; const VECTOR2 operator *(const double t) //number mulitple overload { return VECTOR2(vec[0] * t, vec[1] * t); } const double operator *(const VECTOR2 & v0) //dot product overload { return vec[0] * v0.vec[0] + vec[1] * v0.vec[1]; } const VECTOR2 operator +(const VECTOR2 & v0) //add overload { return VECTOR2(vec[0] + v0.vec[0], vec[1] + v0.vec[1]); } // { return VECTOR2(vec[0], vec[1]); } const VECTOR2 operator - (const VECTOR2 & v0) //sub overload { return VECTOR2(vec[0] - v0.vec[0], vec[1] - v0.vec[1]); } // { return VECTOR2(vec[0], vec[1]); } void Normalize(); void Zero() // make zero vector { vec[0] = vec[1] = 0.0; }; void Set(const double x0, const double x1) { vec[0] = x0; vec[1] = x1; }; }; // Line class typedef struct line_2d { VECTOR2 start; VECTOR2 end; }Line; // 3d vector class class VECTOR3 { private : public : double vec[3]; public : friend class VECTOR4; VECTOR3() // constructor { Zero(); }; VECTOR3(const double x0, const double x1, const double x2) // constructor { vec[0] = x0; vec[1] = x1; vec[2] = x2; }; void Set(const double x0, const double x1, const double x2) { vec[0] = x0; vec[1] = x1; vec[2] = x2; }; int Dimension() const { return 3; }; double & operator [](const int i) // index i'th element { return(vec[i]); }; double operator ()(const int i) const // return i'th element { return(vec[i]); }; const VECTOR3 & operator =(const VECTOR3 & v0) // copy vector v0 { vec[0] = v0(0); vec[1] = v0(1); vec[2] = v0(2); return(*this); }; void Zero() // make zero vector { vec[0] = vec[1] = vec[2] = 0.0; }; double GetMax(); void Clamp(); const double Magnitude(); void Normalize() { double norm = Magnitude(); if(norm > 1e-10){ norm = 1.0 / norm; vec[0] = vec[0] * norm; vec[1] = vec[1] * norm; vec[2] = vec[2] * norm; } } const VECTOR3 Hat() { double norm = Magnitude(); if(norm > 1e-10){ norm = 1.0 / norm; return VECTOR3(vec[0] * norm, vec[1] * norm, vec[2] * norm); } return VECTOR3(vec[0], vec[1], vec[2]); } const VECTOR3& operator +=(const VECTOR3 & v0) //+= overload { vec[0] += v0(0); vec[1] += v0(1); vec[2] += v0(2); return (*this); } const VECTOR3& operator -=(const VECTOR3 & v0) //+= overload { vec[0] -= v0(0); vec[1] -= v0(1); vec[2] -= v0(2); return (*this); } }; // 4d vector class class VECTOR4 { private : double vec[4]; public : VECTOR4() // constructor { Zero(); }; VECTOR4(VECTOR3 v) // constructor { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; vec[3] = 1.0; }; VECTOR4(VECTOR3 v, double x) { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; vec[3] = x; }; VECTOR4(const double x0, const double x1, const double x2, const double x3) // constructor { vec[0] = x0; vec[1] = x1; vec[2] = x2; vec[3] = x3; }; int Dimension() const { return 4; }; double & operator [](const int i) // index i'th element { return(vec[i]); }; double operator ()(const int i) const // return i'th element { return(vec[i]); }; const VECTOR4 & operator =(const VECTOR4 & v0) // copy vector v0 { vec[0] = v0(0); vec[1] = v0(1); vec[2] = v0(2); vec[3] = v0(3); return(*this); }; const VECTOR4 & operator =(const VECTOR3 & v0) // copy vector v0 { vec[0] = v0(0); vec[1] = v0(1); vec[2] = v0(2); vec[3] = 1.0; return(*this); }; VECTOR3 get_vector3() { VECTOR3 temp(vec[0]/vec[3], vec[1]/vec[3], vec[2]/vec[3]); return temp;}; void Zero() // make zero vector { vec[0] = vec[1] = vec[2] = vec[3] = 0.0; }; void Normalize(); // normalize vector }; // 3d matrix class MATRIX3 { private : VECTOR3 mat[3]; // a vector represents each matrix row public : MATRIX3() // constructor { Identity(); }; MATRIX3(const VECTOR3 & v0, const VECTOR3 & v1, const VECTOR3 & v2) { mat[0] = v0; mat[1] = v1; mat[2] = v2; }; // constructor int Dimension() const { return 3; }; VECTOR3 & operator [](const int i) // index row i { return(mat[i]); }; // Note: reference row i, column j of MATRIX3 m0 as m0[i][j] (not m0[i,j]) VECTOR3 operator()(const int i) const // return row i { return(mat[i]); }; double operator ()(const int i, const int j) const { return(mat[i](j)); }; // return element (i,j) MATRIX3 & operator =(const MATRIX3 & m0) // copy matrix m0 { mat[0] = m0(0); mat[1] = m0(1); mat[2] = m0(2); return(*this); }; void Identity(); // set to identity void Zero(); const void operator +=(const MATRIX3 & m0) //+= overload { mat[0] += m0(0); mat[1] += m0(1); mat[2] += m0(2);} const void operator -=(const MATRIX3 & m0) //-= overload { mat[0] -= m0(0); mat[1] -= m0(1); mat[2] -= m0(2);} }; // 4d matrix class MATRIX4 { private : VECTOR4 mat[4]; // a vector represents each matrix row public : MATRIX4() // constructor { Identity(); }; MATRIX4(const VECTOR4 & v0, const VECTOR4 & v1, const VECTOR4 & v2, const VECTOR4 & v3) // constructor { mat[0] = v0; mat[1] = v1; mat[2] = v2; mat[3] = v3; }; int Dimension() const { return 4; }; VECTOR4 & operator [](int i) // index row i { return(mat[i]); }; // Note: reference row i, column j of MATRIX4 m0 as m0[i][j] (not m0[i,j]) VECTOR4 operator()(const int i) const // return row i { return(mat[i]); }; double operator ()(const int i, const int j) const { return(mat[i](j)); }; // return element (i,j) MATRIX4 & operator =(const MATRIX4 & m0) // copy matrix m0 { mat[0] = m0(0); mat[1] = m0(1); mat[2] = m0(2); mat[3] = m0(3); return(*this); }; MATRIX4 & operator =(const MATRIX3 & m0) // copy matrix m0 { mat[0] = m0(0); mat[1] = m0(1); mat[2] = m0(2); VECTOR4 temp(0.0,0.0,0.0,1.0); mat[3] = temp; return(*this); }; void Identity(); // set to identity }; //************************ // INT_64 operations //************************ inline INT_64 operator &(const INT_64 & v0, const INT_64 & v1) // return v0 & v1 { return(INT_64(v0(0)&v1(0), v0(1)&v1(1))); }; inline INT_64 operator |(const INT_64 & v0, const INT_64 & v1) // return v0 | v1 { return(INT_64(v0(0)|v1(0), v0(1)|v1(1))); }; inline INT_64 operator ~(const INT_64 & v0) // return ~v0 { return(INT_64(~v0(0), ~v0(1))); }; //************************ // VECTOR2 operations //************************ inline double dot(const VECTOR2 & v0, const VECTOR2 & v1) // return dot product of v0 and v1 { return(v0(0)*v1(0) + v0(1)*v1(1)); }; inline VECTOR2 operator +(const VECTOR2 & v0, const VECTOR2 & v1) // return v0 + v1 { return(VECTOR2(v0(0) + v1(0), v0(1) + v1(1))); }; inline VECTOR2 operator -(const VECTOR2 & v0, const VECTOR2 & v1) // return v0 - v1 { return(VECTOR2(v0(0) - v1(0), v0(1) - v1(1))); }; inline VECTOR2 operator *(double x0, const VECTOR2 & v0) // return x0*v0 { return(VECTOR2(x0*v0(0), x0*v0(1))); }; inline VECTOR2 operator *(const VECTOR2 & v0, double x0) // return v0*x0 (= x0*v0) { return(x0*v0); }; inline double norm(const VECTOR2& v) { return sqrt(v(0)*v(0) + v(1)*v(1)); } inline double norm2(const VECTOR2& v) { return v(0)*v(0) + v(1)*v(1);} //************************ // VECTOR3 operations //************************ inline double dot(const VECTOR3 & v0, const VECTOR3 & v1) // return dot product of v0 and v1 { return(v0(0)*v1(0) + v0(1)*v1(1) + v0(2)*v1(2)); }; inline VECTOR3 cross(const VECTOR3 & v0, const VECTOR3 & v1) // return cross product of v0 and v1 { return(VECTOR3(v0(1)*v1(2) - v0(2)*v1(1), v0(2)*v1(0) - v0(0)*v1(2), v0(0)*v1(1) - v0(1)*v1(0))); }; inline VECTOR3 operator +(const VECTOR3 & v0, const VECTOR3 & v1) // return v0 + v1 { return(VECTOR3(v0(0) + v1(0), v0(1) + v1(1), v0(2) + v1(2))); }; inline VECTOR3 operator -(const VECTOR3 & v0, const VECTOR3 & v1) // return v0 - v1 { return(VECTOR3(v0(0) - v1(0), v0(1) - v1(1), v0(2) - v1(2))); }; inline VECTOR3 operator *(double x0, const VECTOR3 & v0) // return x0*v0 { return(VECTOR3(x0*v0(0), x0*v0(1), x0*v0(2))); }; inline VECTOR3 operator *(const VECTOR3 & v0, double x0) // return v0*x0 (= x0*v0) { return(x0*v0); }; inline double norm(const VECTOR3& v) { return sqrt(v(0)*v(0) + v(1)*v(1) + v(2)*v(2)); } inline double norm2(const VECTOR3& v) { return v(0)*v(0) + v(1)*v(1) + v(2)*v(2);} inline VECTOR4 get_vector4(VECTOR3 vec) { VECTOR4 temp(vec[0], vec[1], vec[2], 1.0); return temp;}; //************************ // VECTOR4 operations //************************ inline double dot(const VECTOR4 & v0, const VECTOR4 & v1) // return dot product of v0 and v1 { return(v0(0)*v1(0) + v0(1)*v1(1) + v0(2)*v1(2) + v0(3)*v1(3)); }; inline VECTOR4 operator +(const VECTOR4 & v0, const VECTOR4 & v1) // return v0 + v1 { return(VECTOR4(v0(0)+v1(0), v0(1)+v1(1), v0(2)+v1(2), v0(3)+v1(3))); }; inline VECTOR4 operator -(const VECTOR4 & v0, const VECTOR4 & v1) // return v0 - v1 { return(VECTOR4(v0(0)-v1(0), v0(1)-v1(1), v0(2)-v1(2), v0(3)-v1(3))); }; inline VECTOR4 operator *(double x0, const VECTOR4 & v0) // return x0*v0 { return(VECTOR4(x0*v0(0), x0*v0(1), x0*v0(2), x0*v0(3))); }; inline VECTOR4 operator *(const VECTOR4 & v0, double x0) // return v0*x0 (= x0*v0) { return(x0*v0); }; inline double norm(const VECTOR4& v) { return sqrt(v(0)*v(0) + v(1)*v(1) + v(2)*v(2) + v(3)*v(3)); } inline double norm2(const VECTOR4& v) { return v(0)*v(0) + v(1)*v(1) + v(2)*v(2) + v(3)*v(3);} //************************ // MATRIX3 operations //************************ MATRIX3 operator +(const MATRIX3 & m0, const MATRIX3 & m1); // return m0 + m1 MATRIX3 operator -(const MATRIX3 & m0, const MATRIX3 & m1); // return m0 - m1 MATRIX3 operator *(const MATRIX3 & m0, const MATRIX3 & m1); // return m0 * m1 MATRIX3 operator *(const double x0, const MATRIX3 & m0); // return x0 * m0 MATRIX3 operator *(const MATRIX3 & m0, const double x0); // return m0 * x0 VECTOR3 operator *(const MATRIX3 & m0, const VECTOR3 & v0); // return m0 * v0 VECTOR3 operator *(const VECTOR3 & v0, const MATRIX3 & m0); // return v0 * m0 //************************ // MATRIX4 operations //************************ MATRIX4 operator +(const MATRIX4 & m0, const MATRIX4 & m1); // return m0 + m1 MATRIX4 operator -(const MATRIX4 & m0, const MATRIX4 & m1); // return m0 - m1 MATRIX4 operator *(const MATRIX4 & m0, const MATRIX4 & m1); // return m0 * m1 MATRIX4 operator *(const double x0, const MATRIX4 & m0); // return x0 * m0 MATRIX4 operator *(const MATRIX4 & m0, const double x0); // return m0 * x0 VECTOR4 operator *(const MATRIX4 & m0, const VECTOR4 & v0); // return m0 * v0 VECTOR4 operator *(const VECTOR4 & v0, const MATRIX4 & m0); // return v0 * m0 VECTOR3 operator *(const MATRIX4 & m0, const VECTOR3 & v0); // return m0 * v0 VECTOR3 operator *(const VECTOR3 & v0, const MATRIX4 & m0); // return v0 * m0 MATRIX4 inverse(const MATRIX4 & m); // return inverse of m; return 0 matrix if // m is singular MATRIX4 rotate_matrix(int type, double angle); // type: 1:x, 2:y, 3:z MATRIX4 translate_matrix(double dx, double dy, double dz); MATRIX4 scale_matrix(double sx, double sy, double sz); //****************************** // output procedures, operators //****************************** ostream & operator<<(ostream & os, const VECTOR3 & v); // output vector ostream & operator<<(ostream & os, const VECTOR4 & v); // output vector void print_matrix(const MATRIX3 & mat, // print matrix const int indent = 0, const int cout_width = 6, const int precision = 1); void print_matrix(const MATRIX4 & mat, // print matrix const int indent = 0, const int cout_width = 6, const int precision = 1); #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/mesh_io.h0000644000175000017500000000103211344301500024241 0ustar debiandebian#ifndef MESH_IO_H #define MESH_IO_H #include "mds.h" enum FILE_TYPE { OFF, COFF, RAW, RAWN, RAWC, RAWNC, STL, SMF }; void read_labeled_mesh(Mesh &mesh, const string& ip_filename, const FILE_TYPE& ftype, const bool& read_color_opacity, const bool& is_uniform); void write_mesh(const Mesh& mesh, const char* ofname, FILE_TYPE ftype, bool write_color_opacity, bool use_input_mesh_color, float r, float g, float b, float a); #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/dt.h0000644000175000017500000000040011344301500023223 0ustar debiandebian #ifndef DT_H #define DT_H #include "datastruct.h" #include "init.h" #include "rcocone.h" #include "tcocone.h" #include "util.h" #include "robust_cc.h" #include "op.h" #include "mds.h" void recon(const vector& pts, Triangulation& triang); #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/priorityqueue.C0000644000175000017500000000003511344301500025501 0ustar debiandebian #include "priorityqueue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/robust_cc.h0000644000175000017500000000142211344301500024604 0ustar debiandebian#ifndef ROBUST_CC_H #define ROBUST_CC_H #include "datastruct.h" Point nondg_voronoi_point( const Point &a, const Point &b, const Point &c, const Point &d, bool &is_correct_computation); Point dg_voronoi_point( const Point &a, const Point &b, const Point &c, const Point &d, bool &is_correct_computation); Point nondg_cc_tr_3(const Point &a, const Point &b, const Point &c, bool &is_correct_computation); Point cc_tr_3(const Point &a, const Point &b, const Point &c); double sq_cr_tr_3(const Point &a, const Point &b, const Point &c); Point circumcenter(const Facet& f); double circumradius(const Facet& f); #endif // ROBUST_CC_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/util.h0000644000175000017500000000407411344301500023604 0ustar debiandebian#ifndef UTIL_H #define UTIL_H #include "datastruct.h" double cosine( const Vector& v, const Vector& w); void normalize(Vector& v); double length_of_seg(const Segment& s); bool is_obtuse(const Point& p0, const Point& p1, const Point& p2); int find_third_vertex_index( const Facet& f, Vertex_handle v, Vertex_handle w); int edge_index( const int facet_index, const int first_vertex_index, const int second_vertex_index); void vertex_indices( const int facet_index, const int edge_index, int& first_vertex, int& second_vertex); bool is_same_side_of_ray(const Point& p0, const Point& p1, const Point& a, const Point& b); void is_contained_in_inf_tr(const Point& p0, const Point& p1, const Point& p2, const Point& a, const Point& b, const vector& coincidence_vector, bool* contained); bool is_outside_bounding_box(const Point& p, const vector& bounding_box); bool is_outside_bounding_box(const vector& points, const vector& bounding_box); bool is_VF_outside_bounding_box(const Triangulation& triang, const Edge& e, const vector& bounding_box); bool is_outside_VF(const Triangulation& triang, const Edge& e); bool is_inside_VF(const Triangulation& triang, const Edge& e); bool is_surf_VF(const Triangulation& triang, const Edge& e); bool is_cospherical_pair(const Triangulation& triang, const Facet& f); bool identify_cospherical_neighbor(Triangulation &triang); // void // mark_VF_visited(Triangulation& triang, // Cell_handle& c, int uid, int vid); // void // mark_VF_medax_flag(Triangulation& triang, // Cell_handle& c, int uid, int vid, const bool& b); bool is_inf_VF(const Triangulation& triang, const Cell_handle& c, const int uid, const int vid); bool is_there_any_common_element(const vector& vec1, const vector& vec2); #endif // UTIL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/main.C0000644000175000017500000001411411344301500023502 0ustar debiandebian // Samrat // Started Dec 4th, 2007. #include "mesh_io.h" #include "sdf.h" #include "kdtree.h" #include "matrix.h" #include "dt.h" #include "../VolMagick/VolMagick.h" #include "../VolMagick/VolumeCache.h" #include "../VolMagick/endians.h" const int DIMX = 16; //100; const int DIMY = 16; //100; const int DIMZ = 16; //100; const double BB_SCALE = 0.2; using namespace std; void construct_bbox(const Mesh& mesh, vector& bbox) { double x_min = HUGE, x_max = -HUGE, y_min = HUGE, y_max = -HUGE, z_min = HUGE, z_max = -HUGE; for(int i = 0; i < mesh.get_nv(); i ++) { if( mesh.vert_list[i].iso() ) continue; Point p = mesh.vert_list[i].point(); // check x-span if(CGAL::to_double(p.x()) < x_min) x_min = CGAL::to_double(p.x()); if(CGAL::to_double(p.x()) > x_max) x_max = CGAL::to_double(p.x()); // check y-span if(CGAL::to_double(p.y()) < y_min) y_min = CGAL::to_double(p.y()); if(CGAL::to_double(p.y()) > y_max) y_max = CGAL::to_double(p.y()); // check z-span if(CGAL::to_double(p.z()) < z_min) z_min = CGAL::to_double(p.z()); if(CGAL::to_double(p.z()) > z_max) z_max = CGAL::to_double(p.z()); } bbox.push_back(x_min - BB_SCALE*(x_max-x_min)); bbox.push_back(y_min - BB_SCALE*(y_max-y_min)); bbox.push_back(z_min - BB_SCALE*(z_max-z_min)); bbox.push_back(x_max + BB_SCALE*(x_max-x_min)); bbox.push_back(y_max + BB_SCALE*(y_max-y_min)); bbox.push_back(z_max + BB_SCALE*(z_max-z_min)); } void assign_sdf_weight(Mesh& mesh, vector& weights) { // map the color of each facet to a weight (scalar). // for the time being the information is in file called "weights". ifstream fin; fin.open("weights"); istream_iterator input(fin); istream_iterator beyond; double tw = 0; while(input != beyond) { tw += *input; weights.push_back(*input); input++; } for(int i = 0; i < (int)weights.size(); i ++) weights[i] /= tw; } int main(int argc, char** argv) { std::string ifname; std::string ofname; FILE_TYPE in_ftype = OFF; bool read_color_opacity = false; bool is_uniform = false; int dimx = DIMX, dimy = DIMY, dimz = DIMZ; // Check commandline options. bool help = false; if(argc == 1) help = true; for (int i = 1; i < argc; i++) { if ( argc < 3 ) { help = true; break; } if ( (strcmp( "-h", argv[i]) == 0) || (strcmp( "-help", argv[i]) == 0)) { help = true; break; } else if(strcmp("-u", argv[i]) == 0 ) is_uniform = true; else if(strcmp("-ca", argv[i]) == 0 ) read_color_opacity = true; else if(strcmp("-off", argv[i]) == 0 || strcmp("-OFF", argv[i]) == 0) in_ftype = OFF; else if(strcmp("-raw", argv[i]) == 0 || strcmp("-RAW", argv[i]) == 0) in_ftype = RAW; else if(strcmp("-rawn", argv[i]) == 0 || strcmp("-RAWN", argv[i]) == 0) in_ftype = RAWN; else if(strcmp("-rawc", argv[i]) == 0 || strcmp("-RAWC", argv[i]) == 0) in_ftype = RAWC; else if(strcmp("-rawnc", argv[i]) == 0 || strcmp("-RAWNC", argv[i]) == 0) in_ftype = RAWNC; else if ( i+1 >= argc) help = true; else { ifname = argv[i]; ofname = argv[i+1]; i++; } } if ( help) { cerr << "Usage: " << argv[0] << " [FILE_TYPE ] " << " infile outfile " << endl; exit( 1); } // read the annotated input file and Mesh mesh; cerr << "Reading input mesh "; read_labeled_mesh(mesh, ifname, in_ftype, read_color_opacity, is_uniform); cerr << "done." << endl; // build a bounding box around the input and store the // origin, span etc. vector bbox; bbox.clear(); construct_bbox(mesh, bbox); // construct a kd-tree of all the non-isolated mesh_vertices. vector points; vector pts; for(int i = 0; i < mesh.get_nv(); i ++) { if( mesh.vert_list[i].iso() ) continue; Point p = mesh.vert_list[i].point(); pts.push_back(p); points.push_back(VECTOR3(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(p.z()))); } KdTree kd_tree(points, 20); kd_tree.setNOfNeighbours(1); int n_vid = kd_tree.getNeighbourPositionIndex(0); // Now perform a reconstruction to build a tetrahedralized solid // with in-out marked. Triangulation triang; recon(pts, triang); // assign weight to each triangle. vector weights; weights.clear(); // assign_sdf_weight(mesh, weights); // comment out for uniform weight. cerr << "SDF "; try { VolMagick::VolumeCache volcache; // VolMagickOpStatus status; // VolMagick::setDefaultMessenger(&status); VolMagick::Volume vol; vol.dimension(VolMagick::Dimension(dimx,dimy,dimz)); vol.voxelType(VolMagick::Float); vol.boundingBox(VolMagick::BoundingBox(bbox[0],bbox[1],bbox[2], // xmin,ymin,zmin, bbox[3],bbox[4],bbox[5])); // xmax,ymax,zmax for(unsigned int k=0; k(1, vol.voxelType())); VolMagick::writeVolumeFile(vol, ofname); } catch(VolMagick::Exception &e) { cerr << e.what() << endl; } catch(std::exception &e) { cerr << e.what() << endl; } cerr << "done." << endl; return 0; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/rcocone.h0000644000175000017500000000044511344301500024255 0ustar debiandebian#ifndef RCOCONE_H #define RCOCONE_H #include "datastruct.h" #include "util.h" #include "robust_cc.h" void robust_cocone(const double bb_ratio, const double theta_ff, const double theta_if, Triangulation &triang, const char *outfile_prefix); #endif // RCOCONE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/src/kdtree.C0000644000175000017500000002347111344301500024042 0ustar debiandebian#include "kdtree.h" #include #include #define SWAP_POINTS(a,b) \ MyPoint tmp = points[a];\ points[a] = points[b];\ points[b] = tmp; double __queryOffsets[3]; VECTOR3 __queryPosition; KdTree::KdTree(const VECTOR3 *positions, const unsigned int nOfPositions, const unsigned int maxBucketSize) { _bucketSize = maxBucketSize; // _positions = positions; _nOfPositions = nOfPositions; _points = new MyPoint[nOfPositions]; _neighbours = NULL; _nOfFoundNeighbours = 0; _nOfNeighbours = 0; _queryPriorityQueue = new PQueue(); for (unsigned int i=0; i& positions, const unsigned int maxBucketSize) { _bucketSize = maxBucketSize; // _positions = positions; // _nOfPositions = nOfPositions; _nOfPositions = positions.size(); _points = new MyPoint[_nOfPositions]; _neighbours = NULL; _nOfFoundNeighbours = 0; _nOfNeighbours = 0; _queryPriorityQueue = new PQueue(); for (unsigned int i=0; i<_nOfPositions; i++) { _points[i].pos = positions[i]; _points[i].index = i; } computeEnclosingBoundingBox(_boundingBoxLowCorner, _boundingBoxHighCorner); _root = new KdNode(); VECTOR3 maximum, minimum; getSpread(_points, _nOfPositions, maximum, minimum); createTree(*_root, 0, _nOfPositions, maximum, minimum); setNOfNeighbours(1); } KdTree::~KdTree() { delete _root; delete[] _points; if (_neighbours) { delete _neighbours; } delete _queryPriorityQueue; } void KdTree::computeEnclosingBoundingBox(VECTOR3 &lowCorner, VECTOR3 &hiCorner) { VECTOR3 tmp; hiCorner = lowCorner = _points[0].pos; for (unsigned int i=1; i<_nOfPositions; i++) { // tmp = _positions[i]; tmp = _points[i].pos; if (hiCorner[0] < tmp[0]) { hiCorner[0] = tmp[0]; } else if (lowCorner[0] > tmp[0]) { lowCorner[0] = tmp[0]; } if (hiCorner[1] < tmp[1]) { hiCorner[1] = tmp[1]; } else if (lowCorner[1] > tmp[1]) { lowCorner[1] = tmp[1]; } if (hiCorner[2] < tmp[2]) { hiCorner[2] = tmp[2]; } else if (lowCorner[2] > tmp[2]) { lowCorner[2] = tmp[2]; } } } double KdTree::computeBoxDistance(const VECTOR3 &q, const VECTOR3 &lo, const VECTOR3 &hi) { register double dist = 0.0; register double t; if (q(0) < lo(0)) { t = lo(0) - q(0); dist = t*t; } else if (q(0) > hi(0)) { t = q(0) - hi(0); dist = t*t; } if (q(1) < lo(1)) { t = lo(1) - q(1); dist += t*t; } else if (q(1) > hi(1)) { t = q(1) - hi(1); dist += t*t; } if (q(2) < lo(2)) { t = lo(2) - q(2); dist += t*t; } else if (q(2) > hi(2)) { t = q(2) - hi(2); dist += t*t; } return dist; } void KdTree::queryPosition(const VECTOR3 &position) { if (!_neighbours) { return; } __queryOffsets[0] = __queryOffsets[1] = __queryOffsets[2] = 0.0; _queryPriorityQueue->init(); _queryPriorityQueue->insert(-1, FLT_MAX); __queryPosition = position; double dist = computeBoxDistance(position, _boundingBoxLowCorner, _boundingBoxHighCorner); _root->queryNode(dist, _queryPriorityQueue); _nOfFoundNeighbours = 0; for(int i=_nOfNeighbours-1; i>=0; i--) { _neighbours[i] = _queryPriorityQueue->getMax(); if (_neighbours[i].index == -1) { break; } _nOfFoundNeighbours++; _queryPriorityQueue->removeMax(); } } void KdNode::queryNode(double rd, PQueue* queryPriorityQueue) { register double old_off = __queryOffsets[_dim]; register double new_off = __queryPosition[_dim] - _cutVal; if (new_off < 0) { _lchild->queryNode(rd, queryPriorityQueue); rd = rd - SQ(old_off) + SQ(new_off); if (rd <= queryPriorityQueue->getMaxWeight()) { __queryOffsets[_dim] = new_off; _rchild->queryNode(rd, queryPriorityQueue); __queryOffsets[_dim] = old_off; } } else { _rchild->queryNode(rd, queryPriorityQueue); rd = rd - SQ(old_off) + SQ(new_off); if (rd <= queryPriorityQueue->getMaxWeight()) { __queryOffsets[_dim] = new_off; _lchild->queryNode(rd, queryPriorityQueue); __queryOffsets[_dim] = old_off; } } } void KdLeaf::queryNode(double rd, PQueue* queryPriorityQueue) { double sqrDist; //use pointer arithmetic to speed up the linear traversing MyPoint* point = _points; for (register unsigned int i=0; i<_nOfElements; i++) { // sqrDist = (point->pos - __queryPosition).getSquaredLength(); sqrDist = dot(point->pos - __queryPosition, point->pos - __queryPosition); if (sqrDist < queryPriorityQueue->getMaxWeight()) { queryPriorityQueue->insert(point->index, sqrDist); } point++; } } void KdTree::queryRange(const VECTOR3 &position, const double maxSqrDistance) { if (!_neighbours) { return; } __queryOffsets[0] = __queryOffsets[1] = __queryOffsets[2] = 0.0; _queryPriorityQueue->init(); _queryPriorityQueue->insert(-1, maxSqrDistance); __queryPosition = position; double dist = computeBoxDistance(position, _boundingBoxLowCorner, _boundingBoxHighCorner); _root->queryNode(dist, _queryPriorityQueue); _nOfFoundNeighbours = 0; int cnt = _queryPriorityQueue->getNofElements() - 1; while(cnt >= 0) { _neighbours[cnt] = _queryPriorityQueue->getMax(); if (_neighbours[cnt].index != -1) { _nOfFoundNeighbours++; } _queryPriorityQueue->removeMax(); cnt--; } } void KdTree::setNOfNeighbours (const unsigned int newNOfNeighbours) { if (newNOfNeighbours != _nOfNeighbours) { _nOfNeighbours = newNOfNeighbours; if (_neighbours) { delete _neighbours; } _queryPriorityQueue->setSize(_nOfNeighbours); _nOfNeighbours = newNOfNeighbours; _neighbours = new Neighbour[_nOfNeighbours]; _nOfFoundNeighbours = 0; } } void KdTree::createTree(KdNode &node, int start, int end, VECTOR3 maximum, VECTOR3 minimum) { int mid; int n = end-start; VECTOR3 diff = maximum - minimum; short dim; // get longest axe if (diff[0] > diff[1]) { if (diff[0] > diff[2]) { dim = 0;} // x-axe is longest axe else { dim = 2; } // z-axe is longest axe } else { if (diff[1] > diff[2]) { dim = 1;} // y-axe is longest axe else { dim = 2; } // z-axe is longest axe } node._dim = dim; double bestCut = (maximum[dim]+minimum[dim])/2.0; double min, max; getMinMax(_points+start, n, dim, min, max); // find min/max coordinates if (bestCut < min) // slide to min or max as needed node._cutVal = min; else if (bestCut > max) node._cutVal = max; else node._cutVal = bestCut; int br1, br2; splitAtMid(_points+start, n, dim, node._cutVal, br1, br2); // permute points accordingly if (bestCut < min) mid = start+1; else if (bestCut > max) mid = end-1; else if (br1 > n/2.0) mid = start+br1; else if (br2 < n/2.0) mid = start+br2; else mid = start + (n>>1); if (mid-start <= _bucketSize || (maximum[dim] - minimum[dim]) < MYNZERO ) { // if (mid-start <= _bucketSize) { // new leaf KdLeaf* leaf = new KdLeaf(); node._lchild = leaf; leaf->_points = (_points+start); leaf->_nOfElements = mid-start; } else { // new node KdNode* childNode = new KdNode(); node._lchild = childNode; double oldMax = maximum[dim]; maximum[dim] = node._cutVal; createTree(*childNode, start, mid, maximum, minimum); maximum[dim] = oldMax; } if (end-mid <= _bucketSize || (maximum[dim] - minimum[dim]) < MYNZERO ) { // if (end-mid <= _bucketSize) { // new leaf KdLeaf* leaf = new KdLeaf(); node._rchild = leaf; leaf->_points = (_points+mid); leaf->_nOfElements = end-mid; } else { // new node minimum[dim] = node._cutVal; KdNode* childNode = new KdNode(); node._rchild = childNode; createTree(*childNode, mid, end, maximum, minimum); } } void KdTree::getSpread(MyPoint* points, int nOfPoints, VECTOR3 &maximum, VECTOR3 &minimum) { VECTOR3 pos = points->pos; maximum = VECTOR3(pos[0], pos[1], pos[2]); minimum = VECTOR3(pos[0], pos[1], pos[2]); points++; for (int i = 1; i < nOfPoints; i++) { pos = points->pos; if (pos[0] < minimum[0]) { minimum[0] = pos[0]; } if (pos[0] > maximum[0]) { maximum[0] = pos[0]; } if (pos[1] < minimum[1]) { minimum[1] = pos[1]; } if (pos[1] > maximum[1]) { maximum[1] = pos[1]; } if (pos[2] < minimum[2]) { minimum[2] = pos[2]; } if (pos[2] > maximum[2]) { maximum[2] = pos[2]; } points++; } } void KdTree::getMinMax(MyPoint *points, int nOfPoints, int dim, double &min, double &max) { min = points->pos[dim]; max = points->pos[dim]; points++; for (int i=1; ipos[dim] < min) { min = points->pos[dim]; } else if (points->pos[dim] > max) { max = points->pos[dim]; } points++; } } void KdTree::splitAtMid(MyPoint *points, int nOfPoints, int dim, double cutVal, int &br1, int &br2) { int l = 0; int r = nOfPoints-1; for(;;) { // partition points[0..n-1] about the cut value while (l < nOfPoints && points[l].pos[dim] < cutVal) { l++; } while (r >= 0 && points[r].pos[dim] >= cutVal) { r--; } if (l > r) break; SWAP_POINTS(l,r); l++; r--; } br1 = l; // now: points[0..br1-1] < cutVal <= points[br1..n-1] r = nOfPoints-1; for(;;) { // partition points[br1..n-1] about cutVal while (l < nOfPoints && points[l].pos[dim] <= cutVal) { l++; } while (r >= br1 && points[r].pos[dim] > cutVal) { r--; } if (l > r) break; SWAP_POINTS(l,r); l++; r--; } br2 = l; // now: points[br1..br2-1] == cutVal < points[br2..n-1] } void KdNode::print_node(){ cout<<"_dim: "<<(int)_dim<<" _cutVal: "<<_cutVal<print_node(); cout<<"rchild: "<print_node(); } void KdLeaf::print_node() { MyPoint* point = _points; for(register unsigned int i=0; i<_nOfElements; i++){ cout<index<<" "; point ++; } cout< # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/cregex.hpp0000644000175000017500000000143411344301501027431 0ustar debiandebian/* * * Copyright (c) 1998-2002 * Dr John Maddock * * Use, modification and distribution are subject to the * Boost Software License, Version 1.0. (See accompanying file * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) * */ /* * LOCATION: see http://www.boost.org/libs/regex for most recent version. * FILE cregex.cpp * VERSION see * DESCRIPTION: Declares POSIX API functions * + boost::RegEx high level wrapper. */ #ifndef BOOST_RE_CREGEX_HPP #define BOOST_RE_CREGEX_HPP #ifndef BOOST_REGEX_CONFIG_HPP #include #endif #ifdef BOOST_REGEX_V3 #include #else #include #endif #endif /* include guard */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits.hpp0000644000175000017500000000541111344301501030522 0ustar debiandebian// (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // See boost/type_traits/*.hpp for full copyright notices. #ifndef BOOST_TYPE_TRAITS_HPP #define BOOST_TYPE_TRAITS_HPP #include "boost/type_traits/add_const.hpp" #include "boost/type_traits/add_cv.hpp" #include "boost/type_traits/add_pointer.hpp" #include "boost/type_traits/add_reference.hpp" #include "boost/type_traits/add_volatile.hpp" #include "boost/type_traits/alignment_of.hpp" #include "boost/type_traits/has_nothrow_assign.hpp" #include "boost/type_traits/has_nothrow_constructor.hpp" #include "boost/type_traits/has_nothrow_copy.hpp" #include "boost/type_traits/has_nothrow_destructor.hpp" #include "boost/type_traits/has_trivial_assign.hpp" #include "boost/type_traits/has_trivial_constructor.hpp" #include "boost/type_traits/has_trivial_copy.hpp" #include "boost/type_traits/has_trivial_destructor.hpp" #include "boost/type_traits/is_abstract.hpp" #include "boost/type_traits/is_arithmetic.hpp" #include "boost/type_traits/is_array.hpp" #include "boost/type_traits/is_base_and_derived.hpp" #include "boost/type_traits/is_class.hpp" #include "boost/type_traits/is_compound.hpp" #include "boost/type_traits/is_const.hpp" #include "boost/type_traits/is_convertible.hpp" #include "boost/type_traits/is_empty.hpp" #include "boost/type_traits/is_enum.hpp" #include "boost/type_traits/is_float.hpp" #include "boost/type_traits/is_function.hpp" #include "boost/type_traits/is_fundamental.hpp" #include "boost/type_traits/is_integral.hpp" #include "boost/type_traits/is_member_function_pointer.hpp" #include "boost/type_traits/is_member_pointer.hpp" #include "boost/type_traits/is_object.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/is_polymorphic.hpp" #include "boost/type_traits/is_pointer.hpp" #include "boost/type_traits/is_reference.hpp" #include "boost/type_traits/is_same.hpp" #include "boost/type_traits/is_scalar.hpp" #include "boost/type_traits/is_stateless.hpp" #include "boost/type_traits/is_union.hpp" #include "boost/type_traits/is_void.hpp" #include "boost/type_traits/is_volatile.hpp" #include "boost/type_traits/remove_bounds.hpp" #include "boost/type_traits/remove_const.hpp" #include "boost/type_traits/remove_cv.hpp" #include "boost/type_traits/remove_pointer.hpp" #include "boost/type_traits/remove_reference.hpp" #include "boost/type_traits/remove_volatile.hpp" #include "boost/type_traits/type_with_alignment.hpp" #include "boost/type_traits/function_traits.hpp" #include "boost/type_traits/ice.hpp" #endif // BOOST_TYPE_TRAITS_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/regex_fwd.hpp0000644000175000017500000000140611344301501030125 0ustar debiandebian/* * * Copyright (c) 1998-2002 * Dr John Maddock * * Use, modification and distribution are subject to the * Boost Software License, Version 1.0. (See accompanying file * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) * */ /* * LOCATION: see http://www.boost.org/libs/regex for documentation. * FILE regex_fwd.cpp * VERSION see * DESCRIPTION: Forward declares boost::reg_expression<> and * associated typedefs. */ #ifndef BOOST_REGEX_FWD_HPP #define BOOST_REGEX_FWD_HPP #ifndef BOOST_REGEX_CONFIG_HPP #include #endif #ifdef BOOST_REGEX_V3 #include #else #include #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/pointee.hpp0000644000175000017500000000331211344301501027614 0ustar debiandebian// Copyright David Abrahams 2004. Use, modification and distribution is // subject to the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef POINTEE_DWA200415_HPP # define POINTEE_DWA200415_HPP // dereferenceable_traits provides access to the value_type and // reference of a Dereferenceable type. # include # include # include # include # include # include namespace boost { namespace detail { template struct smart_ptr_pointee { typedef typename P::element_type type; }; template struct iterator_pointee { typedef typename iterator_traits::value_type value_type; struct impl { template static char test(T const&); static char (& test(value_type&) )[2]; static Iterator& x; }; BOOST_STATIC_CONSTANT(bool, is_constant = sizeof(impl::test(*impl::x)) == 1); typedef typename mpl::if_c< # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) ::boost::detail::iterator_pointee::is_constant # else is_constant # endif , typename add_const::type , value_type >::type type; }; } template struct pointee : mpl::eval_if< detail::is_incrementable

, detail::iterator_pointee

, detail::smart_ptr_pointee

::type type; }; template< typename Pred > failed ************ (Pred::************ assert_arg( void (*)(Pred), typename assert_arg_pred::type ) ); template< typename Pred > failed ************ (boost::mpl::not_::************ assert_not_arg( void (*)(Pred), typename assert_arg_pred_not::type ) ); template< typename Pred > AUX778076_ASSERT_ARG(assert) assert_arg( void (*)(Pred), typename assert_arg_pred_not::type ); template< typename Pred > AUX778076_ASSERT_ARG(assert) assert_not_arg( void (*)(Pred), typename assert_arg_pred::type ); #else // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER template< bool c, typename Pred > struct assert_arg_type_impl { typedef failed ************ Pred::* mwcw83_wknd; typedef mwcw83_wknd ************* type; }; template< typename Pred > struct assert_arg_type_impl { typedef AUX778076_ASSERT_ARG(assert) type; }; template< typename Pred > struct assert_arg_type : assert_arg_type_impl< BOOST_MPL_AUX_VALUE_WKND(BOOST_MPL_AUX_NESTED_TYPE_WKND(Pred))::value, Pred > { }; template< typename Pred > typename assert_arg_type::type assert_arg(void (*)(Pred), int); template< typename Pred > typename assert_arg_type< boost::mpl::not_ >::type assert_not_arg(void (*)(Pred), int); # if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) template< long x, long y, bool (*r)(failed, failed) > typename assert_arg_type_impl< false,BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) >::type assert_rel_arg( BOOST_MPL_AUX_ASSERT_RELATION(x,y,r) ); # else template< assert_::relations r, long x, long y > typename assert_arg_type_impl< false,assert_relation >::type assert_rel_arg( assert_relation ); # endif #endif // BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER #undef AUX778076_ASSERT_ARG BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE // BOOST_MPL_ASSERT((pred)) #define BOOST_MPL_ASSERT(pred) \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed( \ boost::mpl::assert_arg( (void (*) pred)0, 1 ) \ ) \ ) \ }\ /**/ // BOOST_MPL_ASSERT_NOT((pred)) #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # define BOOST_MPL_ASSERT_NOT(pred) \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion::failed( \ boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \ ) \ ) \ }\ /**/ #else # define BOOST_MPL_ASSERT_NOT(pred) \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed( \ boost::mpl::assert_not_arg( (void (*) pred)0, 1 ) \ ) \ ) \ }\ /**/ #endif // BOOST_MPL_ASSERT_RELATION(x, ==|!=|<=|<|>=|>, y) #if defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) # if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) # define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed<(x rel y)>( \ (boost::mpl::failed ************ ( boost::mpl::assert_relation< \ boost::mpl::assert_::relations( sizeof( \ boost::mpl::assert_::arg rel boost::mpl::assert_::arg \ ) ) \ , x \ , y \ >::************)) 0 ) \ ) \ } \ /**/ # else # define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ enum { \ BOOST_PP_CAT(mpl_assert_rel,__LINE__) = sizeof(boost::mpl::assert_::arg rel boost::mpl::assert_::arg) \ , BOOST_PP_CAT(mpl_assert_rel_value,__LINE__) = (x rel y) \ , BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed( \ boost::mpl::assert_rel_arg( boost::mpl::assert_relation< \ boost::mpl::assert_::relations(BOOST_PP_CAT(mpl_assert_rel,__LINE__)) \ , x \ , y \ >() ) \ ) \ ) \ } \ /**/ # endif #else // !BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES # if defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) # define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed<(x rel y)>( boost::mpl::assert_rel_arg( \ boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))() \ ) ) \ ) \ }\ /**/ # else # define BOOST_MPL_ASSERT_RELATION(x, rel, y) \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed<(x rel y)>( (boost::mpl::failed ************ ( \ boost::mpl::BOOST_MPL_AUX_ASSERT_RELATION(x,y,(&boost::mpl::operator rel))::************))0 ) \ ) \ }\ /**/ # endif #endif // BOOST_MPL_ASSERT_MSG( (pred::value), USER_PROVIDED_MESSAGE, (types) ) #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) # define BOOST_MPL_ASSERT_MSG( c, msg, types_ ) \ struct msg; \ typedef struct BOOST_PP_CAT(msg,__LINE__) : boost::mpl::assert_ \ { \ using boost::mpl::assert_::types; \ static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \ { return 0; } \ } BOOST_PP_CAT(mpl_assert_arg,__LINE__); \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion<(c)>::failed( BOOST_PP_CAT(mpl_assert_arg,__LINE__)::assert_arg() ) \ ) \ }\ /**/ #else # define BOOST_MPL_ASSERT_MSG( c, msg, types_ ) \ struct msg; \ typedef struct BOOST_PP_CAT(msg,__LINE__) : boost::mpl::assert_ \ { \ static boost::mpl::failed ************ (msg::************ assert_arg()) types_ \ { return 0; } \ } BOOST_PP_CAT(mpl_assert_arg,__LINE__); \ enum { \ BOOST_PP_CAT(mpl_assertion_in_line_,__LINE__) = sizeof( \ boost::mpl::assertion_failed<(c)>( BOOST_PP_CAT(mpl_assert_arg,__LINE__)::assert_arg() ) \ ) \ }\ /**/ #endif #endif // BOOST_MPL_ASSERT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/inherit.hpp0000644000175000017500000001321311344301501030404 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_INHERIT_HPP_INCLUDED #define BOOST_MPL_INHERIT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/inherit.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER inherit.hpp # include #else # include # include # include # include # include # include # include # include # include namespace boost { namespace mpl { // 'inherit' metafunction; returns an unspecified class type // produced by public derivation from all metafunction's parameters // (T1,T2,..,Tn), except the parameters of 'empty_base' class type; // regardless the position and number of 'empty_base' parameters in the // metafunction's argument list, derivation from them is always a no-op; // for instance: // inherit::type == her // inherit::type == struct unspecified : her, my {}; // inherit::type == her // inherit::type == her // inherit::type == struct unspecified : her, my {}; // inherit::type == empty_base #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1,T2)) }; template< typename T1 > struct inherit2 { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1,empty_base)) }; template< typename T2 > struct inherit2 { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base,T2)) }; // needed to disambiguate the previous two in case when both // T1 and T2 == empty_base template<> struct inherit2 { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base,empty_base)) }; #else namespace aux { template< bool C1, bool C2 > struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ : T1, T2 { typedef Derived type_; }; }; template<> struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ : T1 { typedef T1 type_; }; }; template<> struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ : T2 { typedef T2 type_; }; }; template<> struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ { typedef T1 type_; }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : aux::inherit2_impl< is_empty_base::value , is_empty_base::value >::template result_< inherit2,T1,T2 > { typedef typename inherit2::type_ type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1,T2)) }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_MPL_AUX_NA_SPEC(2, inherit2) #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(3, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_INHERIT_HPP_INCLUDED ///// iteration #else #define n_ BOOST_PP_FRAME_ITERATION(1) template< BOOST_MPL_PP_DEFAULT_PARAMS(n_, typename T, na) > struct BOOST_PP_CAT(inherit,n_) : inherit2< typename BOOST_PP_CAT(inherit,BOOST_PP_DEC(n_))< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(n_), T) >::type , BOOST_PP_CAT(T,n_) > { BOOST_MPL_AUX_LAMBDA_SUPPORT( n_ , BOOST_PP_CAT(inherit,n_) , (BOOST_MPL_PP_PARAMS(n_, T)) ) }; BOOST_MPL_AUX_NA_SPEC(n_, BOOST_PP_CAT(inherit,n_)) #if n_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY /// primary template template< BOOST_MPL_PP_DEFAULT_PARAMS(n_, typename T, empty_base) > struct inherit : BOOST_PP_CAT(inherit,n_) { }; // 'na' specialization template<> struct inherit< BOOST_MPL_PP_ENUM(5, na) > { template< #if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) BOOST_MPL_PP_DEFAULT_PARAMS(n_, typename T, empty_base) #else BOOST_MPL_PP_PARAMS(n_, typename T) #endif > struct apply : inherit< BOOST_MPL_PP_PARAMS(n_, T) > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(n_, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(n_, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(n_, n_, inherit) #endif #undef n_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/push_front.hpp0000644000175000017500000000257511344301501031142 0ustar debiandebian #ifndef BOOST_MPL_PUSH_FRONT_HPP_INCLUDED #define BOOST_MPL_PUSH_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/push_front.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct push_front : push_front_impl< typename sequence_tag::type > ::template apply< Sequence,T > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,push_front,(Sequence,T)) }; template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct has_push_front : has_push_front_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,has_push_front,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(2, push_front) BOOST_MPL_AUX_NA_SPEC(1, has_push_front) }} #endif // BOOST_MPL_PUSH_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c_fwd.hp0000644000175000017500000000176111344301501031536 0ustar debiandebian #ifndef BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED #define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN #if BOOST_WORKAROUND(__HP_aCC, BOOST_TESTED_AT(53800)) // the type of non-type template arguments may not depend on template arguments template< typename T, long N > struct integral_c; #else template< typename T, T N > struct integral_c; #endif BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c) #endif // BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bitwise.hpp0000644000175000017500000000131211344301501030405 0ustar debiandebian #ifndef BOOST_MPL_BITWISE_HPP_INCLUDED #define BOOST_MPL_BITWISE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bitwise.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #endif // BOOST_MPL_BITWISE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/value_type.hpp0000644000175000017500000000216211344301501031120 0ustar debiandebian #ifndef BOOST_MPL_VALUE_TYPE_HPP_INCLUDED #define BOOST_MPL_VALUE_TYPE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/value_type.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct value_type : value_type_impl< typename sequence_tag::type > ::template apply { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,value_type,(AssociativeSequence,T)) }; BOOST_MPL_AUX_NA_SPEC(2, value_type) }} #endif // BOOST_MPL_VALUE_TYPE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bitand.hpp0000644000175000017500000000125711344301501030210 0ustar debiandebian #ifndef BOOST_MPL_BITAND_HPP_INCLUDED #define BOOST_MPL_BITAND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bitand.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME bitand_ #define AUX778076_OP_PREFIX bitand #define AUX778076_OP_TOKEN & #include #endif // BOOST_MPL_BITAND_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/sequence_tag_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/sequence_tag_fwd.0000644000175000017500000000127211344301501031537 0ustar debiandebian #ifndef BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED #define BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/sequence_tag_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { struct nested_begin_end_tag; struct non_sequence_tag; template< typename Sequence > struct sequence_tag; }} #endif // BOOST_MPL_SEQUENCE_TAG_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/and.hpp0000644000175000017500000000307111344301501027505 0ustar debiandebian #ifndef BOOST_MPL_AND_HPP_INCLUDED #define BOOST_MPL_AND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/and.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include // agurt, 19/may/04: workaround a conflict with header's // 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(and)' // has to be checked in a separate condition, otherwise GCC complains // about 'and' being an alternative token #if defined(_MSC_VER) #if defined(and) # pragma push_macro("and") # undef and # define and(x) #endif #endif # define BOOST_MPL_PREPROCESSED_HEADER and.hpp # include #if defined(_MSC_VER) #if defined(and) # pragma pop_macro("and") #endif #endif #else # define AUX778076_OP_NAME and_ # define AUX778076_OP_VALUE1 false # define AUX778076_OP_VALUE2 true # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AND_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bind.hpp0000644000175000017500000003503411344301501027663 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_BIND_HPP_INCLUDED #define BOOST_MPL_BIND_HPP_INCLUDED // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bind.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include # include # include # include # include # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include # endif #endif #include #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # if defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) # define BOOST_MPL_PREPROCESSED_HEADER basic_bind.hpp # else # define BOOST_MPL_PREPROCESSED_HEADER bind.hpp # endif # include #else # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include namespace boost { namespace mpl { // local macros, #undef-ined at the end of the header # define AUX778076_APPLY \ BOOST_PP_CAT(apply_wrap,BOOST_MPL_LIMIT_METAFUNCTION_ARITY) \ /**/ # if defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) # define AUX778076_DMC_PARAM() , int dummy_ # else # define AUX778076_DMC_PARAM() # endif # define AUX778076_BIND_PARAMS(param) \ BOOST_MPL_PP_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ ) \ /**/ # define AUX778076_BIND_DEFAULT_PARAMS(param, value) \ BOOST_MPL_PP_DEFAULT_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ , value \ ) \ /**/ # define AUX778076_BIND_N_PARAMS(n, param) \ BOOST_PP_COMMA_IF(n) BOOST_MPL_PP_PARAMS(n, param) \ /**/ # define AUX778076_BIND_N_SPEC_PARAMS(n, param, def) \ BOOST_PP_COMMA_IF(n) \ BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ /**/ #if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define AUX778076_BIND_NESTED_DEFAULT_PARAMS(param, value) \ AUX778076_BIND_DEFAULT_PARAMS(param, value) \ /**/ #else # define AUX778076_BIND_NESTED_DEFAULT_PARAMS(param, value) \ AUX778076_BIND_PARAMS(param) \ /**/ #endif namespace aux { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename T, AUX778076_BIND_PARAMS(typename U) > struct resolve_bind_arg { typedef T type; }; # if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg<-1>,Arg > { typedef typename Arg::next next; typedef Arg type; }; # endif // BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT template< BOOST_MPL_AUX_NTTP_DECL(int, N), AUX778076_BIND_PARAMS(typename U) > struct resolve_bind_arg< arg,AUX778076_BIND_PARAMS(U) > { typedef typename AUX778076_APPLY, AUX778076_BIND_PARAMS(U)>::type type; }; #if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) template< typename F, AUX778076_BIND_PARAMS(typename T), AUX778076_BIND_PARAMS(typename U) > struct resolve_bind_arg< bind,AUX778076_BIND_PARAMS(U) > { typedef bind f_; typedef typename AUX778076_APPLY::type type; }; #endif #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // agurt, 15/jan/02: it's not a intended to be used as a function class, and // MSVC6.5 has problems with 'apply' name here (the code compiles, but doesn't // work), so I went with the 'result_' here, and in all other similar cases template< bool > struct resolve_arg_impl { template< typename T, AUX778076_BIND_PARAMS(typename U) > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, AUX778076_BIND_PARAMS(typename U) > struct result_ { typedef typename AUX778076_APPLY< T , AUX778076_BIND_PARAMS(U) >::type type; }; }; // for 'resolve_bind_arg' template< typename T > struct is_bind_template; template< typename T, AUX778076_BIND_PARAMS(typename U) > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,AUX778076_BIND_PARAMS(U) > { }; # if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) template< typename T > struct replace_unnamed_arg_impl { template< typename Arg > struct result_ { typedef Arg next; typedef T type; }; }; template<> struct replace_unnamed_arg_impl< arg<-1> > { template< typename Arg > struct result_ { typedef typename next::type next; typedef Arg type; }; }; template< typename T, typename Arg > struct replace_unnamed_arg : replace_unnamed_arg_impl::template result_ { }; # endif // BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT // agurt, 10/mar/02: the forward declaration has to appear before any of // 'is_bind_helper' overloads, otherwise MSVC6.5 issues an ICE on it template< BOOST_MPL_AUX_NTTP_DECL(int, arity_) > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); // overload for "main" form // agurt, 15/mar/02: MSVC 6.5 fails to properly resolve the overload // in case if we use 'aux::type_wrapper< bind<...> >' here, and all // 'bind' instantiations form a complete type anyway #if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) template< typename F, AUX778076_BIND_PARAMS(typename T) > aux::yes_tag is_bind_helper(bind*); #endif template< BOOST_MPL_AUX_NTTP_DECL(int, N) > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace aux #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) /// if_/eval_if specializations # define AUX778076_SPEC_NAME if_ # define BOOST_PP_ITERATION_PARAMS_1 (3,(3, 3, )) # include BOOST_PP_ITERATE() #if !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) # define AUX778076_SPEC_NAME eval_if # define BOOST_PP_ITERATION_PARAMS_1 (3,(3, 3, )) # include BOOST_PP_ITERATE() #endif #endif // real C++ version is already taken care of #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) namespace aux { // apply_count_args #define AUX778076_COUNT_ARGS_PREFIX bind #define AUX778076_COUNT_ARGS_DEFAULT na #define AUX778076_COUNT_ARGS_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY #include } // bind template< typename F, AUX778076_BIND_PARAMS(typename T) AUX778076_DMC_PARAM() > struct bind : aux::bind_chooser< aux::bind_count_args::value >::template result_< F,AUX778076_BIND_PARAMS(T) >::type { }; BOOST_MPL_AUX_ARITY_SPEC( BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) , bind ) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC( BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) , bind ) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # undef AUX778076_BIND_NESTED_DEFAULT_PARAMS # undef AUX778076_BIND_N_SPEC_PARAMS # undef AUX778076_BIND_N_PARAMS # undef AUX778076_BIND_DEFAULT_PARAMS # undef AUX778076_BIND_PARAMS # undef AUX778076_DMC_PARAM # undef AUX778076_APPLY }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_BIND_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 # define i_ BOOST_PP_FRAME_ITERATION(1) #if defined(AUX778076_SPEC_NAME) // lazy metafunction specialization template< template< BOOST_MPL_PP_PARAMS(i_, typename T) > class F, typename Tag > struct BOOST_PP_CAT(quote,i_); template< BOOST_MPL_PP_PARAMS(i_, typename T) > struct AUX778076_SPEC_NAME; template< typename Tag AUX778076_BIND_N_PARAMS(i_, typename T) > struct BOOST_PP_CAT(bind,i_)< BOOST_PP_CAT(quote,i_) AUX778076_BIND_N_PARAMS(i_,T) > { template< AUX778076_BIND_NESTED_DEFAULT_PARAMS(typename U, na) > struct apply { private: typedef mpl::arg<1> n1; # define BOOST_PP_ITERATION_PARAMS_2 (3,(1, i_, )) # include BOOST_PP_ITERATE() typedef typename AUX778076_SPEC_NAME< typename t1::type , BOOST_MPL_PP_EXT_PARAMS(2, BOOST_PP_INC(i_), t) >::type f_; public: typedef typename f_::type type; }; }; #undef AUX778076_SPEC_NAME #else // AUX778076_SPEC_NAME template< typename F AUX778076_BIND_N_PARAMS(i_, typename T) AUX778076_DMC_PARAM() > struct BOOST_PP_CAT(bind,i_) { template< AUX778076_BIND_NESTED_DEFAULT_PARAMS(typename U, na) > struct apply { private: # if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) typedef aux::replace_unnamed_arg< F,mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg::type f_; /// # else typedef typename aux::resolve_bind_arg::type f_; # endif // BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT # if i_ > 0 # define BOOST_PP_ITERATION_PARAMS_2 (3,(1, i_, )) # include BOOST_PP_ITERATE() # endif public: # define AUX778076_ARG(unused, i_, t) \ BOOST_PP_COMMA_IF(i_) \ typename BOOST_PP_CAT(t,BOOST_PP_INC(i_))::type \ /**/ typedef typename BOOST_PP_CAT(apply_wrap,i_)< f_ BOOST_PP_COMMA_IF(i_) BOOST_MPL_PP_REPEAT(i_, AUX778076_ARG, t) >::type type; # undef AUX778076_ARG }; }; namespace aux { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename F AUX778076_BIND_N_PARAMS(i_, typename T), AUX778076_BIND_PARAMS(typename U) > struct resolve_bind_arg< BOOST_PP_CAT(bind,i_),AUX778076_BIND_PARAMS(U) > { typedef BOOST_PP_CAT(bind,i_) f_; typedef typename AUX778076_APPLY::type type; }; #else template< typename F AUX778076_BIND_N_PARAMS(i_, typename T) > aux::yes_tag is_bind_helper(BOOST_PP_CAT(bind,i_)*); #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(BOOST_PP_INC(i_), BOOST_PP_CAT(bind,i_)) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(BOOST_PP_INC(i_), BOOST_PP_CAT(bind,i_)) # if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) #if i_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY /// primary template (not a specialization!) template< typename F AUX778076_BIND_N_PARAMS(i_, typename T) AUX778076_DMC_PARAM() > struct bind : BOOST_PP_CAT(bind,i_) { }; #else template< typename F AUX778076_BIND_N_PARAMS(i_, typename T) AUX778076_DMC_PARAM() > struct bind< F AUX778076_BIND_N_SPEC_PARAMS(i_, T, na) > : BOOST_PP_CAT(bind,i_) { }; #endif # else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace aux { template<> struct bind_chooser { template< typename F, AUX778076_BIND_PARAMS(typename T) > struct result_ { typedef BOOST_PP_CAT(bind,i_)< F AUX778076_BIND_N_PARAMS(i_,T) > type; }; }; } // namespace aux # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # endif // BOOST_MPL_CFG_NO_BIND_TEMPLATE #endif // AUX778076_SPEC_NAME # undef i_ ///// iteration, depth == 2 #elif BOOST_PP_ITERATION_DEPTH() == 2 # define j_ BOOST_PP_FRAME_ITERATION(2) # if !defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) typedef aux::replace_unnamed_arg< BOOST_PP_CAT(T,j_),BOOST_PP_CAT(n,j_) > BOOST_PP_CAT(r,j_); typedef typename BOOST_PP_CAT(r,j_)::type BOOST_PP_CAT(a,j_); typedef typename BOOST_PP_CAT(r,j_)::next BOOST_PP_CAT(n,BOOST_PP_INC(j_)); typedef aux::resolve_bind_arg BOOST_PP_CAT(t,j_); /// # else typedef aux::resolve_bind_arg< BOOST_PP_CAT(T,j_),AUX778076_BIND_PARAMS(U)> BOOST_PP_CAT(t,j_); # endif # undef j_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/push_back.hpp0000644000175000017500000000256011344301501030704 0ustar debiandebian #ifndef BOOST_MPL_PUSH_BACK_HPP_INCLUDED #define BOOST_MPL_PUSH_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/push_back.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct push_back : push_back_impl< typename sequence_tag::type > ::template apply< Sequence,T > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,push_back,(Sequence,T)) }; template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct has_push_back : has_push_back_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,has_push_back,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(2, push_back) BOOST_MPL_AUX_NA_SPEC(1, has_push_back) }} #endif // BOOST_MPL_PUSH_BACK_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/prior.hpp0000644000175000017500000000103411344301501030073 0ustar debiandebian #ifndef BOOST_MPL_PRIOR_HPP_INCLUDED #define BOOST_MPL_PRIOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/prior.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_PRIOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/is_sequence.hpp0000644000175000017500000000527711344301501031260 0ustar debiandebian #ifndef BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED #define BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/is_sequence.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) # include #elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) # include #endif #include namespace boost { namespace mpl { #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) namespace aux { // agurt, 11/jun/03: // MSVC 6.5/7.0 fails if 'has_begin' is instantiated on a class type that has a // 'begin' member that doesn't name a type; e.g. 'has_begin< std::vector >' // would fail; requiring 'T' to have _both_ 'tag' and 'begin' members workarounds // the issue for most real-world cases template< typename T > struct is_sequence_impl : and_< identity< aux::has_tag > , identity< aux::has_begin > > { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct is_sequence : if_< #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) aux::msvc_is_class #else boost::is_class #endif , aux::is_sequence_impl , bool_ >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(1, is_sequence, (T)) }; #elif defined(BOOST_MPL_CFG_NO_HAS_XXX) template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct is_sequence : bool_ { }; #else template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct is_sequence : not_< is_same< typename begin::type, void_ > > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1, is_sequence, (T)) }; #endif // BOOST_MSVC #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) template<> struct is_sequence : bool_ { }; #endif BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, is_sequence) }} #endif // BOOST_MPL_IS_SEQUENCE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/sequence_tag.hpp0000644000175000017500000000602711344301501031412 0ustar debiandebian #ifndef BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED #define BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/sequence_tag.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // agurt, 27/nov/02: have to use a simplistic 'sequence_tag' implementation // on MSVC to avoid dreadful "internal structure overflow" error #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) \ || defined(BOOST_MPL_CFG_NO_HAS_XXX) template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct sequence_tag { typedef typename Sequence::tag type; }; #elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) // agurt, 07/feb/03: workaround for what seems to be MSVC 7.0-specific ETI issue namespace aux { template< bool > struct sequence_tag_impl { template< typename Sequence > struct result_ { typedef typename Sequence::tag type; }; }; template<> struct sequence_tag_impl { template< typename Sequence > struct result_ { typedef int type; }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct sequence_tag : aux::sequence_tag_impl< !aux::is_msvc_eti_arg::value > ::template result_ { }; #else namespace aux { template< bool has_tag_, bool has_begin_ > struct sequence_tag_impl { // agurt 24/nov/02: MSVC 6.5 gets confused in 'sequence_tag_impl' // specialization below, if we name it 'result_' here template< typename Sequence > struct result2_; }; # define AUX_CLASS_SEQUENCE_TAG_SPEC(has_tag, has_begin, result_type) \ template<> struct sequence_tag_impl \ { \ template< typename Sequence > struct result2_ \ { \ typedef result_type type; \ }; \ }; \ /**/ AUX_CLASS_SEQUENCE_TAG_SPEC(true, true, typename Sequence::tag) AUX_CLASS_SEQUENCE_TAG_SPEC(true, false, typename Sequence::tag) AUX_CLASS_SEQUENCE_TAG_SPEC(false, true, nested_begin_end_tag) AUX_CLASS_SEQUENCE_TAG_SPEC(false, false, non_sequence_tag) # undef AUX_CLASS_SEQUENCE_TAG_SPEC } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct sequence_tag : aux::sequence_tag_impl< ::boost::mpl::aux::has_tag::value , ::boost::mpl::aux::has_begin::value >::template result2_ { }; #endif // BOOST_MSVC BOOST_MPL_AUX_NA_SPEC(1, sequence_tag) }} #endif // BOOST_MPL_SEQUENCE_TAG_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/lambda.hpp0000644000175000017500000000156011344301501030164 0ustar debiandebian #ifndef BOOST_MPL_LAMBDA_HPP_INCLUDED #define BOOST_MPL_LAMBDA_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/lambda.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # include #else # include # include # define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS #endif #endif // BOOST_MPL_LAMBDA_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/inherit_linearly.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/inherit_linearly.0000644000175000017500000000206411344301501031575 0ustar debiandebian #ifndef BOOST_MPL_INHERIT_FRONT_TO_BACK_HPP_INCLUDED #define BOOST_MPL_INHERIT_FRONT_TO_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/inherit_linearly.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Types_) , typename BOOST_MPL_AUX_NA_PARAM(Node_) , typename Root_ = empty_base > struct inherit_linearly : fold { BOOST_MPL_AUX_LAMBDA_SUPPORT(3,inherit_linearly,(Types_,Node_,Root_)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit_linearly) }} #endif // BOOST_MPL_INHERIT_FRONT_TO_BACK_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/end.hpp0000644000175000017500000000102311344301501027504 0ustar debiandebian #ifndef BOOST_MPL_END_HPP_INCLUDED #define BOOST_MPL_END_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/end.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_END_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/placeholders.hpp0000644000175000017500000000477411344301501031423 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED #define BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/placeholders.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) # define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) \ using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; \ /**/ # else # define BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(type) /**/ # endif #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER placeholders.hpp # include #else # include # include # include # include // watch out for GNU gettext users, who #define _(x) #if !defined(_) || defined(BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<-1> _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} #endif /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY + 1, )) #include BOOST_PP_ITERATE() #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_PLACEHOLDERS_HPP_INCLUDED ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg BOOST_PP_CAT(_,i_); BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(BOOST_PP_CAT(_,i_)) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::BOOST_PP_CAT(_,i_); } }} #undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/begin_end_fwd.hpp0000644000175000017500000000136111344301501031515 0ustar debiandebian #ifndef BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED #define BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/begin_end_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct begin_impl; template< typename Tag > struct end_impl; template< typename Sequence > struct begin; template< typename Sequence > struct end; }} #endif // BOOST_MPL_BEGIN_END_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/erase_key_fwd.hpp0000644000175000017500000000126211344301501031552 0ustar debiandebian #ifndef BOOST_MPL_ERASE_KEY_FWD_HPP_INCLUDED #define BOOST_MPL_ERASE_KEY_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/erase_key_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct erase_key_impl; template< typename Sequence, typename Key > struct erase_key; }} #endif // BOOST_MPL_ERASE_KEY_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/times.hpp0000644000175000017500000000114611344301501030065 0ustar debiandebian #ifndef BOOST_MPL_TIMES_HPP_INCLUDED #define BOOST_MPL_TIMES_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/times.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME times #define AUX778076_OP_TOKEN * #include #endif // BOOST_MPL_TIMES_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/arithmetic.hpp0000644000175000017500000000140111344301501031067 0ustar debiandebian #ifndef BOOST_MPL_ARITHMETIC_HPP_INCLUDED #define BOOST_MPL_ARITHMETIC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/arithmetic.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include // deprecated #endif // BOOST_MPL_ARITHMETIC_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/not.hpp0000644000175000017500000000214611344301501027545 0ustar debiandebian #ifndef BOOST_MPL_NOT_HPP_INCLUDED #define BOOST_MPL_NOT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/not.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(long, C_) > // 'long' is intentional here struct not_impl : bool_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct not_ : aux::not_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T)::value > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,not_,(T)) }; BOOST_MPL_AUX_NA_SPEC(1,not_) }} #endif // BOOST_MPL_NOT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_tags.hpp0000644000175000017500000000154711344301501031620 0ustar debiandebian #ifndef BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED #define BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_tags.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; }; struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; }; struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; }; }} #endif // BOOST_MPL_ITERATOR_TAG_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/erase_fwd.hpp0000644000175000017500000000125311344301501030702 0ustar debiandebian #ifndef BOOST_MPL_ERASE_FWD_HPP_INCLUDED #define BOOST_MPL_ERASE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/erase_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct erase_impl; template< typename Sequence, typename First, typename Last > struct erase; }} #endif // BOOST_MPL_ERASE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/begin.hpp0000644000175000017500000000103311344301501030023 0ustar debiandebian #ifndef BOOST_MPL_BEGIN_HPP_INCLUDED #define BOOST_MPL_BEGIN_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/begin.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_BEGIN_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector_c.hpp0000644000175000017500000000364011344301501030551 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector_c.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_VECTOR_C_HEADER \ BOOST_PP_CAT(BOOST_PP_CAT(vector,BOOST_MPL_LIMIT_VECTOR_SIZE),_c).hpp \ /**/ #else # define AUX778076_VECTOR_C_HEADER \ BOOST_PP_CAT(BOOST_PP_CAT(vector,BOOST_MPL_LIMIT_VECTOR_SIZE),_c)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_C_HEADER) # undef AUX778076_VECTOR_C_HEADER # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector_c.hpp # include #else # include # define AUX778076_SEQUENCE_NAME vector_c # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE # define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(vector,n),_c) # define AUX778076_SEQUENCE_INTEGRAL_WRAPPER # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/for_each.hpp0000644000175000017500000000520211344301501030507 0ustar debiandebian #ifndef BOOST_MPL_FOR_EACH_HPP_INCLUDED #define BOOST_MPL_FOR_EACH_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/for_each.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< bool done = true > struct for_each_impl { template< typename Iterator , typename LastIterator , typename TransformFunc , typename F > static void execute( Iterator* , LastIterator* , TransformFunc* , F ) { } }; template<> struct for_each_impl { template< typename Iterator , typename LastIterator , typename TransformFunc , typename F > static void execute( Iterator* , LastIterator* , TransformFunc* , F f ) { typedef typename deref::type item; typedef typename apply1::type arg; // dwa 2002/9/10 -- make sure not to invoke undefined behavior // when we pass arg. value_initialized x; aux::unwrap(f, 0)(boost::get(x)); typedef typename mpl::next::type iter; for_each_impl::value> ::execute((iter*)0, (LastIterator*)0, (TransformFunc*)0, f); } }; } // namespace aux // agurt, 17/mar/02: pointer default parameters are necessary to workaround // MSVC 6.5 function template signature's mangling bug template< typename Sequence , typename TransformOp , typename F > inline void for_each(F f, Sequence* = 0, TransformOp* = 0) { typedef typename begin::type first; typedef typename end::type last; aux::for_each_impl< boost::is_same::value > ::execute((first*)0, (last*)0, (TransformOp*)0, f); } template< typename Sequence , typename F > inline void for_each(F f, Sequence* = 0) { for_each >(f); } }} #endif // BOOST_MPL_FOR_EACH_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/deque.hpp0000644000175000017500000000336511344301501030054 0ustar debiandebian #ifndef BOOST_MPL_DEQUE_HPP_INCLUDED #define BOOST_MPL_DEQUE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/deque.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_DEQUE_HEADER \ BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE).hpp \ /**/ #else # define AUX778076_DEQUE_HEADER \ BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_DEQUE_HEADER) # undef AUX778076_DEQUE_HEADER #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER deque.hpp # include #else # include # define AUX778076_SEQUENCE_NAME deque # define AUX778076_SEQUENCE_BASE_NAME vector # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_DEQUE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bitor.hpp0000644000175000017500000000125111344301501030060 0ustar debiandebian #ifndef BOOST_MPL_BITOR_HPP_INCLUDED #define BOOST_MPL_BITOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bitor.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME bitor_ #define AUX778076_OP_PREFIX bitor #define AUX778076_OP_TOKEN | #include #endif // BOOST_MPL_BITOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/apply.hpp0000644000175000017500000001357511344301501030102 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_APPLY_HPP_INCLUDED #define BOOST_MPL_APPLY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/apply.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER apply.hpp # include #else # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include namespace boost { namespace mpl { // local macros, #undef-ined at the end of the header # define AUX778076_APPLY_PARAMS(param) \ BOOST_MPL_PP_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ ) \ /**/ # define AUX778076_APPLY_DEF_PARAMS(param, value) \ BOOST_MPL_PP_DEFAULT_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ , value \ ) \ /**/ # define AUX778076_APPLY_N_PARAMS(n, param) \ BOOST_MPL_PP_PARAMS(n, param) \ /**/ # define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \ BOOST_PP_COMMA_IF(n) \ BOOST_MPL_PP_PARAMS(n, param) \ /**/ # define AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(n, param, def) \ BOOST_PP_COMMA_IF(n) \ BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ /**/ # define AUX778076_APPLY_N_SPEC_PARAMS(n, param) \ BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \ /**/ #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() # if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) // real C++ version is already taken care of # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace aux { // apply_count_args #define AUX778076_COUNT_ARGS_PREFIX apply #define AUX778076_COUNT_ARGS_DEFAULT na #define AUX778076_COUNT_ARGS_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY #include } template< typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na) > struct apply : aux::apply_chooser< aux::apply_count_args< AUX778076_APPLY_PARAMS(T) >::value >::template result_< F, AUX778076_APPLY_PARAMS(T) >::type { }; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE # undef AUX778076_APPLY_N_SPEC_PARAMS # undef AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS # undef AUX778076_APPLY_N_COMMA_PARAMS # undef AUX778076_APPLY_N_PARAMS # undef AUX778076_APPLY_DEF_PARAMS # undef AUX778076_APPLY_PARAMS }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_APPLY_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 # define i_ BOOST_PP_FRAME_ITERATION(1) template< typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) > struct BOOST_PP_CAT(apply,i_) #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) : BOOST_PP_CAT(apply_wrap,i_)< typename lambda::type AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > { #else { typedef typename BOOST_PP_CAT(apply_wrap,i_)< typename lambda::type AUX778076_APPLY_N_COMMA_PARAMS(i_, T) >::type type; #endif BOOST_MPL_AUX_LAMBDA_SUPPORT( BOOST_PP_INC(i_) , BOOST_PP_CAT(apply,i_) , (F AUX778076_APPLY_N_COMMA_PARAMS(i_,T)) ) }; #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) /// workaround for ETI bug template<> struct BOOST_PP_CAT(apply,i_) { typedef int type; }; #endif # if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) #if i_ == BOOST_MPL_LIMIT_METAFUNCTION_ARITY /// primary template (not a specialization!) template< typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) > struct apply : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > { }; #else template< typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) > struct apply< F AUX778076_APPLY_N_PARTIAL_SPEC_PARAMS(i_, T, na) > : BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > { }; #endif # else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) namespace aux { template<> struct apply_chooser { template< typename F, AUX778076_APPLY_PARAMS(typename T) > struct result_ { typedef BOOST_PP_CAT(apply,i_)< F AUX778076_APPLY_N_COMMA_PARAMS(i_, T) > type; }; }; } // namespace aux #endif # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE # undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/deref.hpp0000644000175000017500000000201611344301501030026 0ustar debiandebian #ifndef BOOST_MPL_DEREF_HPP_INCLUDED #define BOOST_MPL_DEREF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/deref.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Iterator) > struct deref { #if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) typedef typename Iterator::type type; #else typedef typename aux::msvc_type::type type; #endif BOOST_MPL_AUX_LAMBDA_SUPPORT(1,deref,(Iterator)) }; BOOST_MPL_AUX_NA_SPEC(1, deref) }} #endif // BOOST_MPL_DEREF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/push_back_fwd.hpp0000644000175000017500000000126011344301501031540 0ustar debiandebian #ifndef BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED #define BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/push_back_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct push_back_impl; template< typename Sequence, typename T > struct push_back; }} #endif // BOOST_MPL_PUSH_BACK_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse_fold.hpp0000644000175000017500000000255411344301501031427 0ustar debiandebian #ifndef BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED #define BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse_fold.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(State) , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp) , typename ForwardOp = arg<1> > struct reverse_fold { typedef typename aux::reverse_fold_impl< ::boost::mpl::O1_size::value , typename begin::type , typename end::type , State , BackwardOp , ForwardOp >::state type; BOOST_MPL_AUX_LAMBDA_SUPPORT(3,reverse_fold,(Sequence,State,BackwardOp)) }; BOOST_MPL_AUX_NA_SPEC(3, reverse_fold) }} #endif // BOOST_MPL_REVERSE_FOLD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/greater_equal.hpp0000644000175000017500000000121711344301501031563 0ustar debiandebian #ifndef BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED #define BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/greater_equal.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME greater_equal #define AUX778076_OP_TOKEN >= #include #endif // BOOST_MPL_GREATER_EQUAL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/is_placeholder.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/is_placeholder.hp0000644000175000017500000000306711344301501031545 0ustar debiandebian #ifndef BOOST_MPL_IS_PLACEHOLDER_HPP_INCLUDED #define BOOST_MPL_IS_PLACEHOLDER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/is_placeholder.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename T > struct is_placeholder : bool_ { }; template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct is_placeholder< arg > : bool_ { }; #else namespace aux { aux::no_tag is_placeholder_helper(...); template< BOOST_MPL_AUX_NTTP_DECL(int, N) > aux::yes_tag is_placeholder_helper(aux::type_wrapper< arg >*); } // namespace aux template< typename T > struct is_placeholder { static aux::type_wrapper* get(); BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_placeholder_helper(get())) == sizeof(aux::yes_tag) ); typedef bool_ type; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION }} #endif // BOOST_MPL_IS_PLACEHOLDER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_front_fwd.hpp0000644000175000017500000000124411344301501031611 0ustar debiandebian #ifndef BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED #define BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_front_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct pop_front_impl; template< typename Sequence > struct pop_front; }} #endif // BOOST_MPL_POP_FRONT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/comparison.hpp0000644000175000017500000000134311344301501031115 0ustar debiandebian #ifndef BOOST_MPL_COMPARISON_HPP_INCLUDED #define BOOST_MPL_COMPARISON_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/comparison.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #endif // BOOST_MPL_COMPARISON_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/switch.hpp0000644000175000017500000000240711344301501030246 0ustar debiandebian #ifndef BOOST_MPL_SWITCH_HPP_INCLUDED #define BOOST_MPL_SWITCH_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/switch.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Body) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct switch_ { typedef typename find_if< Body , apply1< lambda< first<_1> >, T > >::type iter_; typedef typename deref::type pair_; typedef typename lambda< typename second::type >::type f_; typedef typename apply1::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2,switch_,(Body,T)) }; BOOST_MPL_AUX_NA_SPEC(2, switch_) }} #endif // BOOST_MPL_SWITCH_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/alias.hpp0000644000175000017500000000104711344301501030035 0ustar debiandebian #ifndef BOOST_MPL_ALIAS_HPP_INCLUDED #define BOOST_MPL_ALIAS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/alias.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace { namespace mpl = boost::mpl; } #endif // BOOST_MPL_ALIAS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/filter_view.hpp0000644000175000017500000000234211344301501031262 0ustar debiandebian #ifndef BOOST_MPL_FILTER_VIEW_HPP_INCLUDED #define BOOST_MPL_FILTER_VIEW_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/filter_view.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Predicate) > struct filter_view { private: typedef typename lambda::type pred_; typedef typename begin::type first_; typedef typename end::type last_; public: struct tag; typedef filter_view type; typedef typename aux::next_filter_iter< first_,last_,pred_ >::type begin; typedef aux::filter_iter< last_,last_,pred_ > end; }; BOOST_MPL_AUX_NA_SPEC(2, filter_view) }} #endif // BOOST_MPL_FILTER_VIEW_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/identity.hpp0000644000175000017500000000203511344301501030573 0ustar debiandebian #ifndef BOOST_MPL_IDENTITY_HPP_INCLUDED #define BOOST_MPL_IDENTITY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/identity.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct identity { typedef T type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1, identity, (T)) }; template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct make_identity { typedef identity type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1, make_identity, (T)) }; BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, identity) BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, make_identity) }} #endif // BOOST_MPL_IDENTITY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/sizeof.hpp0000644000175000017500000000154211344301501030243 0ustar debiandebian #ifndef BOOST_MPL_SIZEOF_HPP_INCLUDED #define BOOST_MPL_SIZEOF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/sizeof.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct sizeof_ : mpl::size_t< sizeof(T) > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,sizeof_,(T)) }; BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, sizeof_) }} #endif // BOOST_MPL_SIZEOF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/empty.hpp0000644000175000017500000000176111344301501030105 0ustar debiandebian #ifndef BOOST_MPL_EMPTY_HPP_INCLUDED #define BOOST_MPL_EMPTY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/empty.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct empty : empty_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,empty,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, empty) }} #endif // BOOST_MPL_EMPTY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/O1_size_fwd.hpp0000644000175000017500000000123011344301501031107 0ustar debiandebian #ifndef BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED #define BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/O1_size_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct O1_size_impl; template< typename Sequence > struct O1_size; }} #endif // BOOST_MPL_O1_SIZE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/apply_wrap.hpp0000644000175000017500000001235111344301501031122 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_APPLY_WRAP_HPP_INCLUDED #define BOOST_MPL_APPLY_WRAP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/apply_wrap.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER apply_wrap.hpp # include #else # include # include # include # include # include # include # include # include # include # include # include # include # include namespace boost { namespace mpl { // local macros, #undef-ined at the end of the header # define AUX778076_APPLY_WRAP_PARAMS(n, param) \ BOOST_MPL_PP_PARAMS(n, param) \ /**/ # define AUX778076_APPLY_WRAP_SPEC_PARAMS(n, param) \ BOOST_MPL_PP_ENUM(BOOST_PP_INC(n), param) \ /**/ #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() # undef AUX778076_APPLY_WRAP_SPEC_PARAMS # undef AUX778076_APPLY_WRAP_PARAMS }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_APPLY_WRAP_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 # define i_ BOOST_PP_FRAME_ITERATION(1) # if BOOST_WORKAROUND(BOOST_MSVC, < 1300) // MSVC version #define AUX778076_MSVC_DTW_NAME BOOST_PP_CAT(msvc_apply,i_) #define AUX778076_MSVC_DTW_ORIGINAL_NAME apply #define AUX778076_MSVC_DTW_ARITY i_ #include template< typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) > struct BOOST_PP_CAT(apply_wrap,i_) { // Metafunction forwarding confuses vc6 typedef typename BOOST_PP_CAT(msvc_apply,i_)::template result_< AUX778076_APPLY_WRAP_PARAMS(i_, T) >::type type; }; # elif defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) // MWCW/Borland version template< int N, typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) > struct BOOST_PP_CAT(apply_wrap_impl,i_); #define BOOST_PP_ITERATION_PARAMS_2 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY - i_, )) #include BOOST_PP_ITERATE() template< typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) > struct BOOST_PP_CAT(apply_wrap,i_) : BOOST_PP_CAT(apply_wrap_impl,i_)< ::boost::mpl::aux::arity::value , F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) >::type { }; # else // ISO98 C++, with minor concession to vc7 template< typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) #if i_ == 0 , typename has_apply_ = typename aux::has_apply::type #endif > struct BOOST_PP_CAT(apply_wrap,i_) // metafunction forwarding confuses MSVC 7.0 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1300) : F::template apply< AUX778076_APPLY_WRAP_PARAMS(i_, T) > { #else { typedef typename F::template apply< AUX778076_APPLY_WRAP_PARAMS(i_, T) >::type type; #endif }; #if i_ == 0 && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename F > struct BOOST_PP_CAT(apply_wrap,i_) : F::apply { }; #endif # endif // workarounds #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) /// workaround for ETI bug template<> struct BOOST_PP_CAT(apply_wrap,i_) { typedef int type; }; #endif # undef i_ ///// iteration, depth == 2 #elif BOOST_PP_ITERATION_DEPTH() == 2 # define j_ BOOST_PP_FRAME_ITERATION(2) template< typename F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, typename T) > struct BOOST_PP_CAT(apply_wrap_impl,i_)< BOOST_MPL_PP_ADD(i_, j_) , F BOOST_PP_COMMA_IF(i_) AUX778076_APPLY_WRAP_PARAMS(i_, T) > { typedef typename F::template apply< AUX778076_APPLY_WRAP_PARAMS(i_, T) #if i_ == 0 && j_ == 0 /// since the defaults are "lost", we have to pass *something* even for nullary /// metafunction classes na #else BOOST_PP_COMMA_IF(BOOST_PP_AND(i_, j_)) BOOST_MPL_PP_ENUM(j_, na) #endif > type; }; # undef j_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/replace.hpp0000644000175000017500000000236611344301501030364 0ustar debiandebian #ifndef BOOST_MPL_REPLACE_HPP_INCLUDED #define BOOST_MPL_REPLACE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright John R. Bandela 2000-2002 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/replace.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Sequence , typename OldType , typename NewType , typename Inserter > struct replace_impl : replace_if_impl< Sequence, same_as, NewType, Inserter > { }; template< typename Sequence , typename OldType , typename NewType , typename Inserter > struct reverse_replace_impl : reverse_replace_if_impl< Sequence, same_as, NewType, Inserter > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, replace) }} #endif // BOOST_MPL_REPLACE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set_c.hpp0000644000175000017500000000354711344301501030050 0ustar debiandebian #ifndef BOOST_MPL_SET_C_HPP_INCLUDED #define BOOST_MPL_SET_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set_c.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_SET_C_HEADER \ BOOST_PP_CAT(BOOST_PP_CAT(set,BOOST_MPL_LIMIT_SET_SIZE),_c).hpp \ /**/ #else # define AUX778076_SET_C_HEADER \ BOOST_PP_CAT(BOOST_PP_CAT(set,BOOST_MPL_LIMIT_SET_SIZE),_c)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_C_HEADER) # undef AUX778076_SET_C_HEADER # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set_c.hpp # include #else # include # define AUX778076_SEQUENCE_NAME set_c # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_SET_SIZE # define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(set,n),_c) # define AUX778076_SEQUENCE_INTEGRAL_WRAPPER # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/or.hpp0000644000175000017500000000312611344301501027364 0ustar debiandebian #ifndef BOOST_MPL_OR_HPP_INCLUDED #define BOOST_MPL_OR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/or.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include // agurt, 19/may/04: workaround a conflict with header's // 'or' and 'and' macros, see http://tinyurl.com/3et69; 'defined(or)' // has to be checked in a separate condition, otherwise GCC complains // about 'or' being an alternative token #if defined(_MSC_VER) #if defined(or) # pragma push_macro("or") # undef or # define or(x) #endif #endif # define BOOST_MPL_PREPROCESSED_HEADER or.hpp # include #if defined(_MSC_VER) #if defined(or) # pragma pop_macro("or") #endif #endif #else # define AUX778076_OP_NAME or_ # define AUX778076_OP_VALUE1 true # define AUX778076_OP_VALUE2 false # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_OR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/size.hpp0000644000175000017500000000212211344301501027711 0ustar debiandebian #ifndef BOOST_MPL_SIZE_HPP_INCLUDED #define BOOST_MPL_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/size.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct size : aux::msvc_eti_base< typename size_impl< typename sequence_tag::type > ::template apply< Sequence >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(1, size, (Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, size) }} #endif // BOOST_MPL_SIZE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/lower_bound.hpp0000644000175000017500000000715511344301501031271 0ustar debiandebian #ifndef BOOST_MPL_LOWER_BOUND_HPP_INCLUDED #define BOOST_MPL_LOWER_BOUND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/lower_bound.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL #endif #if !defined(BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL) # include # include # include # include # include # include # include # include # include # include # include #else # include # include # include #endif #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL) // agurt 23/oct/02: has a wrong complexity etc., but at least it works // feel free to contribute a better implementation! template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) , typename Predicate = less<> , typename pred_ = typename lambda::type > struct lower_bound : find_if< Sequence, bind1< not_<>, bind2 > > { }; #else namespace aux { template< typename Distance , typename Predicate , typename T , typename DeferredIterator > struct lower_bound_step_impl; template< typename Distance , typename Predicate , typename T , typename DeferredIterator > struct lower_bound_step { typedef typename eval_if< Distance , lower_bound_step_impl , DeferredIterator >::type type; }; template< typename Distance , typename Predicate , typename T , typename DeferredIterator > struct lower_bound_step_impl { typedef typename divides< Distance, long_<2> >::type offset_; typedef typename DeferredIterator::type iter_; typedef typename advance< iter_,offset_ >::type middle_; typedef typename apply2< Predicate , typename deref::type , T >::type cond_; typedef typename prior< minus< Distance, offset_> >::type step_; typedef lower_bound_step< offset_,Predicate,T,DeferredIterator > step_forward_; typedef lower_bound_step< step_,Predicate,T,next > step_backward_; typedef typename eval_if< cond_ , step_backward_ , step_forward_ >::type type; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) , typename Predicate = less<> > struct lower_bound { private: typedef typename lambda::type pred_; typedef typename size::type size_; public: typedef typename aux::lower_bound_step< size_,pred_,T,begin >::type type; }; #endif // BOOST_MPL_CFG_STRIPPED_DOWN_LOWER_BOUND_IMPL BOOST_MPL_AUX_NA_SPEC(2, lower_bound) }} #endif // BOOST_MPL_LOWER_BOUND_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/pair.hpp0000644000175000017500000000307011344301501027675 0ustar debiandebian #ifndef BOOST_MPL_PAIR_HPP_INCLUDED #define BOOST_MPL_PAIR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/pair.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct pair { typedef pair type; typedef T1 first; typedef T2 second; BOOST_MPL_AUX_LAMBDA_SUPPORT(2,pair,(T1,T2)) }; template< typename BOOST_MPL_AUX_NA_PARAM(P) > struct first { #if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) typedef typename P::first type; #else typedef typename aux::msvc_eti_base

::first type; #endif BOOST_MPL_AUX_LAMBDA_SUPPORT(1,first,(P)) }; template< typename BOOST_MPL_AUX_NA_PARAM(P) > struct second { #if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) typedef typename P::second type; #else typedef typename aux::msvc_eti_base

::second type; #endif BOOST_MPL_AUX_LAMBDA_SUPPORT(1,second,(P)) }; BOOST_MPL_AUX_NA_SPEC(2, pair) BOOST_MPL_AUX_NA_SPEC(1, first) BOOST_MPL_AUX_NA_SPEC(1, second) }} #endif // BOOST_MPL_PAIR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/void_fwd.hpp0000644000175000017500000000127511344301501030550 0ustar debiandebian #ifndef BOOST_MPL_VOID_FWD_HPP_INCLUDED #define BOOST_MPL_VOID_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/void_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN struct void_; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(void_) #endif // BOOST_MPL_VOID_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/min.hpp0000644000175000017500000000102111344301501027517 0ustar debiandebian #ifndef BOOST_MPL_MIN_HPP_INCLUDED #define BOOST_MPL_MIN_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/min.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_MIN_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/contains.hpp0000644000175000017500000000212711344301501030562 0ustar debiandebian #ifndef BOOST_MPL_CONTAINS_HPP_INCLUDED #define BOOST_MPL_CONTAINS_HPP_INCLUDED // Copyright Eric Friedman 2002 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/contains.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct contains : contains_impl< typename sequence_tag::type > ::template apply< Sequence,T > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,contains,(Sequence,T)) }; BOOST_MPL_AUX_NA_SPEC(2, contains) }} #endif // BOOST_MPL_CONTAINS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/logical.hpp0000644000175000017500000000113311344301501030352 0ustar debiandebian #ifndef BOOST_MPL_LOGICAL_HPP_INCLUDED #define BOOST_MPL_LOGICAL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/logical.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #endif // BOOST_MPL_LOGICAL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/remove.hpp0000644000175000017500000000215511344301501030242 0ustar debiandebian #ifndef BOOST_MPL_REMOVE_HPP_INCLUDED #define BOOST_MPL_REMOVE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/remove.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Sequence , typename T , typename Inserter > struct remove_impl : remove_if_impl< Sequence, same_as, Inserter > { }; template< typename Sequence , typename T , typename Inserter > struct reverse_remove_impl : reverse_remove_if_impl< Sequence, same_as, Inserter > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, remove) }} #endif // BOOST_MPL_REMOVE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_fwd.hpp0000644000175000017500000000121411344301501030736 0ustar debiandebian #ifndef BOOST_MPL_EMPTY_FWD_HPP_INCLUDED #define BOOST_MPL_EMPTY_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct empty_impl; template< typename Sequence > struct empty; }} #endif // BOOST_MPL_EMPTY_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/sort.hpp0000644000175000017500000000131011344301501027724 0ustar debiandebian #ifndef BOOST_MPL_SORT_HPP_INCLUDED #define BOOST_MPL_SORT_HPP_INCLUDED // Copyright Eric Friedman 2002-2003 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/sort.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, sort) }} #endif // BOOST_MPL_SORT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/long.hpp0000644000175000017500000000115711344301501027705 0ustar debiandebian #ifndef BOOST_MPL_LONG_HPP_INCLUDED #define BOOST_MPL_LONG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/long.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #define AUX_WRAPPER_VALUE_TYPE long #include #endif // BOOST_MPL_LONG_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/back_fwd.hpp0000644000175000017500000000120611344301501030501 0ustar debiandebian #ifndef BOOST_MPL_BACK_FWD_HPP_INCLUDED #define BOOST_MPL_BACK_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/back_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct back_impl; template< typename Sequence > struct back; }} #endif // BOOST_MPL_BACK_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/joint_view.hpp0000644000175000017500000000334011344301501031117 0ustar debiandebian #ifndef BOOST_MPL_JOINT_VIEW_HPP_INCLUDED #define BOOST_MPL_JOINT_VIEW_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/joint_view.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { namespace aux { struct joint_view_tag; } template<> struct size_impl< aux::joint_view_tag > { template < typename JointView > struct apply : plus< size , size > {}; }; template< typename BOOST_MPL_AUX_NA_PARAM(Sequence1_) , typename BOOST_MPL_AUX_NA_PARAM(Sequence2_) > struct joint_view { typedef typename mpl::begin::type first1_; typedef typename mpl::end::type last1_; typedef typename mpl::begin::type first2_; typedef typename mpl::end::type last2_; // agurt, 25/may/03: for the 'size_traits' implementation above typedef Sequence1_ sequence1_; typedef Sequence2_ sequence2_; typedef joint_view type; typedef aux::joint_view_tag tag; typedef joint_iter begin; typedef joint_iter end; }; BOOST_MPL_AUX_NA_SPEC(2, joint_view) }} #endif // BOOST_MPL_JOINT_VIEW_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/transform.hpp0000644000175000017500000001031411344301501030754 0ustar debiandebian #ifndef BOOST_MPL_TRANSFORM_HPP_INCLUDED #define BOOST_MPL_TRANSFORM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/transform.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Seq , typename Op , typename In > struct transform1_impl : fold< Seq , typename In::state , bind2< typename lambda< typename In::operation >::type , _1 , bind1< typename lambda::type, _2> > > { }; template< typename Seq , typename Op , typename In > struct reverse_transform1_impl : reverse_fold< Seq , typename In::state , bind2< typename lambda< typename In::operation >::type , _1 , bind1< typename lambda::type, _2> > > { }; template< typename Seq1 , typename Seq2 , typename Op , typename In > struct transform2_impl : fold< pair_view , typename In::state , bind2< typename lambda< typename In::operation >::type , _1 , bind2< typename lambda::type , bind1,_2> , bind1,_2> > > > { }; template< typename Seq1 , typename Seq2 , typename Op , typename In > struct reverse_transform2_impl : reverse_fold< pair_view , typename In::state , bind2< typename lambda< typename In::operation >::type , _1 , bind2< typename lambda< Op >::type , bind1,_2> , bind1,_2> > > > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, transform1) BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, transform2) #define AUX778076_TRANSFORM_DEF(name) \ template< \ typename BOOST_MPL_AUX_NA_PARAM(Seq1) \ , typename BOOST_MPL_AUX_NA_PARAM(Seq2OrOperation) \ , typename BOOST_MPL_AUX_NA_PARAM(OperationOrInserter) \ , typename BOOST_MPL_AUX_NA_PARAM(Inserter) \ > \ struct name \ : if_< \ or_< \ is_na \ , is_lambda_expression< Seq2OrOperation > \ , not_< is_sequence > \ > \ , name##1 \ , name##2 \ >::type \ { \ }; \ BOOST_MPL_AUX_NA_SPEC(4, name) \ /**/ AUX778076_TRANSFORM_DEF(transform) AUX778076_TRANSFORM_DEF(reverse_transform) #undef AUX778076_TRANSFORM_DEF }} #endif // BOOST_MPL_TRANSFORM_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/fold.hpp0000644000175000017500000000237311344301501027673 0ustar debiandebian #ifndef BOOST_MPL_FOLD_HPP_INCLUDED #define BOOST_MPL_FOLD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/fold.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(State) , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) > struct fold { typedef typename aux::fold_impl< ::boost::mpl::O1_size::value , typename begin::type , typename end::type , State , ForwardOp >::state type; BOOST_MPL_AUX_LAMBDA_SUPPORT(3,fold,(Sequence,State,ForwardOp)) }; BOOST_MPL_AUX_NA_SPEC(3, fold) }} #endif // BOOST_MPL_FOLD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/protect.hpp0000644000175000017500000000247211344301501030427 0ustar debiandebian #ifndef BOOST_MPL_PROTECT_HPP_INCLUDED #define BOOST_MPL_PROTECT_HPP_INCLUDED // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/protect.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T) , int not_le_ = 0 > struct protect : T { #if BOOST_WORKAROUND(__EDG_VERSION__, == 238) typedef mpl::protect type; #else typedef protect type; #endif }; #if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(int, N), typename T > struct arity< protect, N > : arity { }; } // namespace aux #endif BOOST_MPL_AUX_NA_SPEC_MAIN(1, protect) #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(1, 1, protect) #endif }} #endif // BOOST_MPL_PROTECT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/back.hpp0000644000175000017500000000174711344301501027653 0ustar debiandebian #ifndef BOOST_MPL_BACK_HPP_INCLUDED #define BOOST_MPL_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/back.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct back : back_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,back,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, back) }} #endif // BOOST_MPL_BACK_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/find.hpp0000644000175000017500000000165311344301501027667 0ustar debiandebian #ifndef BOOST_MPL_FIND_HPP_INCLUDED #define BOOST_MPL_FIND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/find.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct find : find_if< Sequence,same_as > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,find,(Sequence,T)) }; BOOST_MPL_AUX_NA_SPEC(2, find) }} #endif // BOOST_MPL_FIND_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/arg.hpp0000644000175000017500000000636111344301501027521 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_ARG_HPP_INCLUDED #define BOOST_MPL_ARG_HPP_INCLUDED // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/arg.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include #endif #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER arg.hpp # include #else # include # include # include # include # include # include # include # include # include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN // local macro, #undef-ined at the end of the header #if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \ BOOST_MPL_PP_DEFAULT_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ , value \ ) \ /**/ #else # define AUX778076_ARG_N_DEFAULT_PARAMS(param,value) \ BOOST_MPL_PP_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ ) \ /**/ #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() # undef AUX778076_ARG_N_DEFAULT_PARAMS BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int,arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_ARG_HPP_INCLUDED ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) #if i_ > 0 template<> struct arg { BOOST_STATIC_CONSTANT(int, value = i_); typedef arg next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na) > struct apply { typedef BOOST_PP_CAT(U,i_) type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; #else template<> struct arg<-1> { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< AUX778076_ARG_N_DEFAULT_PARAMS(typename U, na) > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; #endif // i_ > 0 #undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bool.hpp0000644000175000017500000000202611344301501027675 0ustar debiandebian #ifndef BOOST_MPL_BOOL_HPP_INCLUDED #define BOOST_MPL_BOOL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bool.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< bool C_ > struct bool_ { BOOST_STATIC_CONSTANT(bool, value = C_); typedef integral_c_tag tag; typedef bool_ type; typedef bool value_type; operator bool() const { return this->value; } }; #if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) template< bool C_ > bool const bool_::value; #endif BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE #endif // BOOST_MPL_BOOL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/key_type.hpp0000644000175000017500000000214011344301501030570 0ustar debiandebian #ifndef BOOST_MPL_KEY_TYPE_HPP_INCLUDED #define BOOST_MPL_KEY_TYPE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/key_type.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct key_type : key_type_impl< typename sequence_tag::type > ::template apply { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,key_type,(AssociativeSequence,T)) }; BOOST_MPL_AUX_NA_SPEC(2, key_type) }} #endif // BOOST_MPL_KEY_TYPE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/divides.hpp0000644000175000017500000000116011344301501030367 0ustar debiandebian #ifndef BOOST_MPL_DIVIDES_HPP_INCLUDED #define BOOST_MPL_DIVIDES_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/divides.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME divides #define AUX778076_OP_TOKEN / #include #endif // BOOST_MPL_DIVIDES_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/front_fwd.hpp0000644000175000017500000000121411344301501030730 0ustar debiandebian #ifndef BOOST_MPL_FRONT_FWD_HPP_INCLUDED #define BOOST_MPL_FRONT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/front_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct front_impl; template< typename Sequence > struct front; }} #endif // BOOST_MPL_FRONT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/insert.hpp0000644000175000017500000000215211344301501030246 0ustar debiandebian #ifndef BOOST_MPL_INSERT_HPP_INCLUDED #define BOOST_MPL_INSERT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/insert.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Pos_or_T) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct insert : insert_impl< typename sequence_tag::type > ::template apply< Sequence,Pos_or_T,T > { BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert,(Sequence,Pos_or_T,T)) }; BOOST_MPL_AUX_NA_SPEC(3, insert) }} #endif // BOOST_MPL_INSERT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse_iter_fold.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse_iter_fold0000644000175000017500000000311011344301501031651 0ustar debiandebian #ifndef BOOST_MPL_ITER_FOLD_BACKWARD_HPP_INCLUDED #define BOOST_MPL_ITER_FOLD_BACKWARD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Dave Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse_iter_fold.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(State) , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp) , typename ForwardOp = arg<1> > struct reverse_iter_fold { typedef typename aux::reverse_iter_fold_impl< ::boost::mpl::O1_size::value , typename begin::type , typename end::type , State , typename lambda::type , typename lambda::type >::state type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , reverse_iter_fold , (Sequence,State,BackwardOp,ForwardOp) ) }; BOOST_MPL_AUX_NA_SPEC(3, reverse_iter_fold) }} #endif // BOOST_MPL_ITER_FOLD_BACKWARD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/tag.hpp0000644000175000017500000000214011344301501027512 0ustar debiandebian #ifndef BOOST_MPL_TAG_HPP_INCLUDED #define BOOST_MPL_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/tag.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename T > struct tag_impl { typedef typename T::tag type; }; } template< typename T, typename Default = void_ > struct tag #if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) : if_< aux::has_tag , aux::tag_impl , Default >::type { #else { typedef typename eval_if< aux::has_tag , aux::tag_impl , Default >::type type; #endif }; }} #endif // BOOST_MPL_TAG_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/eval_if.hpp0000644000175000017500000000350211344301501030347 0ustar debiandebian #ifndef BOOST_MPL_EVAL_IF_HPP_INCLUDED #define BOOST_MPL_EVAL_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/eval_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(C) , typename BOOST_MPL_AUX_NA_PARAM(F1) , typename BOOST_MPL_AUX_NA_PARAM(F2) > struct eval_if #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ || ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, >= 0x0300) \ && BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) \ ) { typedef typename if_::type f_; typedef typename f_::type type; #else : if_::type { #endif BOOST_MPL_AUX_LAMBDA_SUPPORT(3,eval_if,(C,F1,F2)) }; // (almost) copy & paste in order to save one more // recursively nested template instantiation to user template< bool C , typename F1 , typename F2 > struct eval_if_c #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ || ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, >= 0x0300) \ && BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) \ ) { typedef typename if_c::type f_; typedef typename f_::type type; #else : if_c::type { #endif }; BOOST_MPL_AUX_NA_SPEC(3, eval_if) }} #endif // BOOST_MPL_EVAL_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_range.hpp0000644000175000017500000000224311344301501031423 0ustar debiandebian #ifndef BOOST_MPL_INSERT_RANGE_HPP_INCLUDED #define BOOST_MPL_INSERT_RANGE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_range.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Pos) , typename BOOST_MPL_AUX_NA_PARAM(Range) > struct insert_range : insert_range_impl< typename sequence_tag::type > ::template apply< Sequence,Pos,Range > { BOOST_MPL_AUX_LAMBDA_SUPPORT(3,insert_range,(Sequence,Pos,Range)) }; BOOST_MPL_AUX_NA_SPEC(3, insert_range) }} #endif // BOOST_MPL_INSERT_RANGE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/unpack_args.hpp0000644000175000017500000000664711344301501031254 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_UNPACK_ARGS_HPP_INCLUDED #define BOOST_MPL_UNPACK_ARGS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/unpack_args.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER unpack_args.hpp # include #else # include # include # include # include # include # include namespace boost { namespace mpl { // local macros, #undef-ined at the end of the header # define AUX778076_UNPACK(unused, i, Args) \ , typename at_c::type \ /**/ # define AUX778076_UNPACKED_ARGS(n, Args) \ BOOST_MPL_PP_REPEAT(n, AUX778076_UNPACK, Args) \ /**/ namespace aux { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< int size, typename F, typename Args > struct unpack_args_impl; #else template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl { template< typename F, typename Args > struct apply; }; #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() } template< typename F > struct unpack_args { template< typename Args > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) : aux::unpack_args_impl< size::value,F,Args > # else : aux::unpack_args_impl< size::value > ::template apply< F,Args > # endif { #else // BOOST_MPL_CFG_NO_NESTED_FORWARDING { typedef typename aux::unpack_args_impl< size::value , F , Args >::type type; #endif }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) # undef AUX778076_UNPACK # undef AUX778076_UNPACKED_ARGS }} #endif // BOOST_MPL_CFG_USE_PREPROCESSED_HEADERS #endif // BOOST_MPL_UNPACK_ARGS_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 # define i_ BOOST_PP_FRAME_ITERATION(1) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename F, typename Args > struct unpack_args_impl : BOOST_PP_CAT(apply,i_)< F AUX778076_UNPACKED_ARGS(i_, Args) > { }; #else template<> struct unpack_args_impl { template< typename F, typename Args > struct apply : BOOST_PP_CAT(apply,i_)< F AUX778076_UNPACKED_ARGS(i_, Args) > { }; }; #endif # undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/min_max.hpp0000644000175000017500000000174511344301501030401 0ustar debiandebian #ifndef BOOST_MPL_MAX_HPP_INCLUDED #define BOOST_MPL_MAX_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/min_max.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct min : if_< less,N1,N2 > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct max : if_< less,N2,N1 > { }; BOOST_MPL_AUX_NA_SPEC(2, min) BOOST_MPL_AUX_NA_SPEC(2, max) }} #endif // BOOST_MPL_MAX_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/size_t_fwd.hpp0000644000175000017500000000147311344301501031104 0ustar debiandebian #ifndef BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED #define BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/size_t_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // make sure 'size_t' is placed into 'std' #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< std::size_t N > struct size_t; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(size_t) #endif // BOOST_MPL_SIZE_T_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/unique.hpp0000644000175000017500000000415111344301501030251 0ustar debiandebian #ifndef BOOST_MPL_UNIQUE_HPP_INCLUDED #define BOOST_MPL_UNIQUE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright John R. Bandela 2000-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/unique.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Predicate, typename Operation > struct unique_op { template< typename Pair, typename T > struct apply { typedef typename Pair::first seq_; typedef typename Pair::second prior_; typedef typename eval_if< and_< is_not_na, apply2 > , identity , apply2 >::type new_seq_; typedef pair type; }; }; template< typename Sequence , typename Predicate , typename Inserter > struct unique_impl : first< typename fold< Sequence , pair< typename Inserter::state,na > , protect< aux::unique_op > >::type > { }; template< typename Sequence , typename Predicate , typename Inserter > struct reverse_unique_impl : first< typename reverse_fold< Sequence , pair< typename Inserter::state,na > , protect< aux::unique_op > >::type > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, unique) }} #endif // BOOST_MPL_UNIQUE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/0000755000175000017500000000000012146213760027544 5ustar debiandebian././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/unrolling.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/unrolling.0000644000175000017500000000117711344301502031553 0ustar debiandebian #ifndef BOOST_MPL_LIMITS_UNROLLING_HPP_INCLUDED #define BOOST_MPL_LIMITS_UNROLLING_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/unrolling.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_LIMIT_UNROLLING) # define BOOST_MPL_LIMIT_UNROLLING 4 #endif #endif // BOOST_MPL_LIMITS_UNROLLING_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/arity.hpp0000644000175000017500000000120111344301502031366 0ustar debiandebian #ifndef BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED #define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/arity.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) # define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5 #endif #endif // BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/list.hpp0000644000175000017500000000115411344301502031220 0ustar debiandebian #ifndef BOOST_MPL_LIMITS_LIST_HPP_INCLUDED #define BOOST_MPL_LIMITS_LIST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/list.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_LIMIT_LIST_SIZE) # define BOOST_MPL_LIMIT_LIST_SIZE 20 #endif #endif // BOOST_MPL_LIMITS_LIST_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/map.hpp0000644000175000017500000000114611344301502031023 0ustar debiandebian #ifndef BOOST_MPL_LIMITS_MAP_HPP_INCLUDED #define BOOST_MPL_LIMITS_MAP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/map.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_LIMIT_MAP_SIZE) # define BOOST_MPL_LIMIT_MAP_SIZE 20 #endif #endif // BOOST_MPL_LIMITS_MAP_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/set.hpp0000644000175000017500000000114611344301502031041 0ustar debiandebian #ifndef BOOST_MPL_LIMITS_SET_HPP_INCLUDED #define BOOST_MPL_LIMITS_SET_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/set.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_LIMIT_SET_SIZE) # define BOOST_MPL_LIMIT_SET_SIZE 20 #endif #endif // BOOST_MPL_LIMITS_SET_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/vector.hpp0000644000175000017500000000117011344301502031545 0ustar debiandebian #ifndef BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED #define BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/limits/vector.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_LIMIT_VECTOR_SIZE) # define BOOST_MPL_LIMIT_VECTOR_SIZE 20 #endif #endif // BOOST_MPL_LIMITS_VECTOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/0000755000175000017500000000000012146213761027546 5ustar debiandebian././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector30_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector30_c0000644000175000017500000000252311344301502031430 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR30_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR30_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector30_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector30_c.hpp # include #else # include # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_USE_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR30_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/0000755000175000017500000000000012146213761030502 5ustar debiandebian././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/pop_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/pop_b0000644000175000017500000000200611344301502031510 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/pop_back.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # include # include namespace boost { namespace mpl { template<> struct pop_back_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef v_mask type; }; }; }} #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #endif // BOOST_MPL_VECTOR_AUX_POP_BACK_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/itera0000644000175000017500000000601511344301502031521 0ustar debiandebian #ifndef BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED #define BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/iterator.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Vector , BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_iter { typedef aux::v_iter_tag tag; typedef random_access_iterator_tag category; typedef typename v_at::type type; typedef Vector vector_; typedef mpl::long_ pos; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) enum { next_ = n_ + 1 , prior_ = n_ - 1 , pos_ = n_ }; typedef v_iter next; typedef v_iter prior; #endif }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Vector , BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct next< v_iter > { typedef v_iter type; }; template< typename Vector , BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct prior< v_iter > { typedef v_iter type; }; template< typename Vector , BOOST_MPL_AUX_NTTP_DECL(long, n_) , typename Distance > struct advance< v_iter,Distance> { typedef v_iter< Vector , (n_ + BOOST_MPL_AUX_NESTED_VALUE_WKND(long, Distance)) > type; }; template< typename Vector , BOOST_MPL_AUX_NTTP_DECL(long, n_) , BOOST_MPL_AUX_NTTP_DECL(long, m_) > struct distance< v_iter, v_iter > : mpl::long_<(m_ - n_)> { }; #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template<> struct advance_impl { template< typename Iterator, typename N > struct apply { enum { pos_ = Iterator::pos_, n_ = N::value }; typedef v_iter< typename Iterator::vector_ , (pos_ + n_) > type; }; }; template<> struct distance_impl { template< typename Iter1, typename Iter2 > struct apply { enum { pos1_ = Iter1::pos_, pos2_ = Iter2::pos_ }; typedef long_<( pos2_ - pos1_ )> type; BOOST_STATIC_CONSTANT(long, value = ( pos2_ - pos1_ )); }; }; #endif }} #endif // BOOST_MPL_AUX_VECTOR_ITERATOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/push_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/push_0000644000175000017500000000204011344301502031525 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/push_front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # include # include namespace boost { namespace mpl { template<> struct push_front_impl< aux::vector_tag > { template< typename Vector, typename T > struct apply { typedef v_item type; }; }; }} #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #endif // BOOST_MPL_VECTOR_AUX_PUSH_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/include_preprocessed.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/inclu0000644000175000017500000000271611344301502031533 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/include_preprocessed.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # define AUX778076_INCLUDE_DIR typeof_based #elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ || defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) # define AUX778076_INCLUDE_DIR no_ctps #else # define AUX778076_INCLUDE_DIR plain #endif #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_HEADER \ AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER \ /**/ #else # define AUX778076_HEADER \ BOOST_PP_CAT(AUX778076_INCLUDE_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/vector/aux_/preprocessed/AUX778076_HEADER) # undef AUX778076_HEADER # undef AUX778076_INCLUDE_DIR #undef BOOST_MPL_PREPROCESSED_HEADER ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/push_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/push_0000644000175000017500000000176311344301502031540 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/push_back.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # include # include namespace boost { namespace mpl { template<> struct push_back_impl< aux::vector_tag > { template< typename Vector, typename T > struct apply { typedef v_item type; }; }; }} #endif #endif // BOOST_MPL_VECTOR_AUX_PUSH_BACK_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/item.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/item.0000644000175000017500000000464711344301502031442 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/item.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template< typename T , typename Base , int at_front = 0 > struct v_item : Base { typedef typename Base::upper_bound_ index_; typedef typename next::type upper_bound_; typedef typename next::type size; typedef Base base; // agurt 10/sep/04: MWCW <= 9.3 workaround here and below; the compiler // breaks if using declaration comes _before_ the new overload static aux::type_wrapper item_(index_); using Base::item_; }; template< typename T , typename Base > struct v_item : Base { typedef typename prior::type index_; typedef index_ lower_bound_; typedef typename next::type size; typedef Base base; static aux::type_wrapper item_(index_); using Base::item_; }; // "erasure" item template< typename Base , int at_front > struct v_mask : Base { typedef typename prior::type index_; typedef index_ upper_bound_; typedef typename prior::type size; typedef Base base; static aux::type_wrapper item_(index_); using Base::item_; }; template< typename Base > struct v_mask : Base { typedef typename Base::lower_bound_ index_; typedef typename next::type lower_bound_; typedef typename prior::type size; typedef Base base; static aux::type_wrapper item_(index_); using Base::item_; }; #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_ITEM_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000755000175000017500000000000012146213762031554 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000755000175000017500000000000012146213762031554 5ustar debiandebian././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001155411344301502031551 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 > struct vector21_c : v_item< integral_c< T,C20 > , vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 > > { typedef vector21_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21 > struct vector22_c : v_item< integral_c< T,C21 > , vector21_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 > > { typedef vector22_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22 > struct vector23_c : v_item< integral_c< T,C22 > , vector22_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 > > { typedef vector23_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23 > struct vector24_c : v_item< integral_c< T,C23 > , vector23_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 > > { typedef vector24_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24 > struct vector25_c : v_item< integral_c< T,C24 > , vector24_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 > > { typedef vector25_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25 > struct vector26_c : v_item< integral_c< T,C25 > , vector25_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 > > { typedef vector26_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26 > struct vector27_c : v_item< integral_c< T,C26 > , vector26_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 > > { typedef vector27_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27 > struct vector28_c : v_item< integral_c< T,C27 > , vector27_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 > > { typedef vector28_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 > struct vector29_c : v_item< integral_c< T,C28 > , vector28_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 > > { typedef vector29_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 > struct vector30_c : v_item< integral_c< T,C29 > , vector29_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 > > { typedef vector30_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000000735611344301502031556 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 > struct vector11_c : v_item< integral_c< T,C10 > , vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > > { typedef vector11_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11 > struct vector12_c : v_item< integral_c< T,C11 > , vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > > { typedef vector12_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12 > struct vector13_c : v_item< integral_c< T,C12 > , vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > > { typedef vector13_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13 > struct vector14_c : v_item< integral_c< T,C13 > , vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > > { typedef vector14_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14 > struct vector15_c : v_item< integral_c< T,C14 > , vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 > > { typedef vector15_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15 > struct vector16_c : v_item< integral_c< T,C15 > , vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 > > { typedef vector16_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16 > struct vector17_c : v_item< integral_c< T,C16 > , vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 > > { typedef vector17_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17 > struct vector18_c : v_item< integral_c< T,C17 > , vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 > > { typedef vector18_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 > struct vector19_c : v_item< integral_c< T,C18 > , vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 > > { typedef vector19_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 > struct vector20_c : v_item< integral_c< T,C19 > , vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 > > { typedef vector20_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001033311344301502031543 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector11 : v_item< T10 , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > > { typedef vector11 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector12 : v_item< T11 , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > > { typedef vector12 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector13 : v_item< T12 , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > > { typedef vector13 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector14 : v_item< T13 , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > > { typedef vector14 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector15 : v_item< T14 , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > > { typedef vector15 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector16 : v_item< T15 , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 > > { typedef vector16 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector17 : v_item< T16 , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 > > { typedef vector17 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector18 : v_item< T17 , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 > > { typedef vector18 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector19 : v_item< T18 , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 > > { typedef vector19 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector20 : v_item< T19 , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 > > { typedef vector20 type; }; }} ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001410711344301502031546 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20 > struct vector21 : v_item< T20 , vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 > > { typedef vector21 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21 > struct vector22 : v_item< T21 , vector21< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 > > { typedef vector22 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22 > struct vector23 : v_item< T22 , vector22< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 > > { typedef vector23 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23 > struct vector24 : v_item< T23 , vector23< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 > > { typedef vector24 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 > struct vector25 : v_item< T24 , vector24< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 > > { typedef vector25 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25 > struct vector26 : v_item< T25 , vector25< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 > > { typedef vector26 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26 > struct vector27 : v_item< T26 , vector26< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 > > { typedef vector27 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27 > struct vector28 : v_item< T27 , vector27< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 > > { typedef vector28 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28 > struct vector29 : v_item< T28 , vector28< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 > > { typedef vector29 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 > struct vector30 : v_item< T29 , vector29< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 > > { typedef vector30 type; }; }} ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001375211344301502031553 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 > struct vector31_c : v_item< integral_c< T,C30 > , vector30_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29 > > { typedef vector31_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31 > struct vector32_c : v_item< integral_c< T,C31 > , vector31_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30 > > { typedef vector32_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32 > struct vector33_c : v_item< integral_c< T,C32 > , vector32_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31 > > { typedef vector33_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33 > struct vector34_c : v_item< integral_c< T,C33 > , vector33_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32 > > { typedef vector34_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34 > struct vector35_c : v_item< integral_c< T,C34 > , vector34_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33 > > { typedef vector35_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35 > struct vector36_c : v_item< integral_c< T,C35 > , vector35_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34 > > { typedef vector36_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36 > struct vector37_c : v_item< integral_c< T,C36 > , vector36_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35 > > { typedef vector37_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37 > struct vector38_c : v_item< integral_c< T,C37 > , vector37_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36 > > { typedef vector38_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 > struct vector39_c : v_item< integral_c< T,C38 > , vector38_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37 > > { typedef vector39_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 > struct vector40_c : v_item< integral_c< T,C39 > , vector39_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38 > > { typedef vector40_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000000465411344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 > struct vector1 : v_item< T0 , vector0< > > { typedef vector1 type; }; template< typename T0, typename T1 > struct vector2 : v_item< T1 , vector1 > { typedef vector2 type; }; template< typename T0, typename T1, typename T2 > struct vector3 : v_item< T2 , vector2< T0,T1 > > { typedef vector3 type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector4 : v_item< T3 , vector3< T0,T1,T2 > > { typedef vector4 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector5 : v_item< T4 , vector4< T0,T1,T2,T3 > > { typedef vector5 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector6 : v_item< T5 , vector5< T0,T1,T2,T3,T4 > > { typedef vector6 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector7 : v_item< T6 , vector6< T0,T1,T2,T3,T4,T5 > > { typedef vector7 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector8 : v_item< T7 , vector7< T0,T1,T2,T3,T4,T5,T6 > > { typedef vector8 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector9 : v_item< T8 , vector8< T0,T1,T2,T3,T4,T5,T6,T7 > > { typedef vector9 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector10 : v_item< T9 , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > > { typedef vector10 type; }; }} ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000002343711344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40 > struct vector41 : v_item< T40 , vector40< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39 > > { typedef vector41 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41 > struct vector42 : v_item< T41 , vector41< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40 > > { typedef vector42 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42 > struct vector43 : v_item< T42 , vector42< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41 > > { typedef vector43 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43 > struct vector44 : v_item< T43 , vector43< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42 > > { typedef vector44 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 > struct vector45 : v_item< T44 , vector44< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43 > > { typedef vector45 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45 > struct vector46 : v_item< T45 , vector45< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44 > > { typedef vector46 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46 > struct vector47 : v_item< T46 , vector46< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45 > > { typedef vector47 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47 > struct vector48 : v_item< T47 , vector47< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46 > > { typedef vector48 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48 > struct vector49 : v_item< T48 , vector48< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47 > > { typedef vector49 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48, typename T49 > struct vector50 : v_item< T49 , vector49< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48 > > { typedef vector50 type; }; }} ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001766311344301502031560 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30 > struct vector31 : v_item< T30 , vector30< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29 > > { typedef vector31 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31 > struct vector32 : v_item< T31 , vector31< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30 > > { typedef vector32 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32 > struct vector33 : v_item< T32 , vector32< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31 > > { typedef vector33 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33 > struct vector34 : v_item< T33 , vector33< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32 > > { typedef vector34 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 > struct vector35 : v_item< T34 , vector34< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33 > > { typedef vector35 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35 > struct vector36 : v_item< T35 , vector35< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34 > > { typedef vector36 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36 > struct vector37 : v_item< T36 , vector36< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35 > > { typedef vector37 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37 > struct vector38 : v_item< T37 , vector37< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36 > > { typedef vector38 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38 > struct vector39 : v_item< T38 , vector38< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37 > > { typedef vector39 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 > struct vector40 : v_item< T39 , vector39< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38 > > { typedef vector40 type; }; }} ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000000526111344301502031547 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0 > struct vector1_c : v_item< integral_c< T,C0 > , vector0_c > { typedef vector1_c type; typedef T value_type; }; template< typename T , T C0, T C1 > struct vector2_c : v_item< integral_c< T,C1 > , vector1_c< T,C0 > > { typedef vector2_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2 > struct vector3_c : v_item< integral_c< T,C2 > , vector2_c< T,C0,C1 > > { typedef vector3_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3 > struct vector4_c : v_item< integral_c< T,C3 > , vector3_c< T,C0,C1,C2 > > { typedef vector4_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4 > struct vector5_c : v_item< integral_c< T,C4 > , vector4_c< T,C0,C1,C2,C3 > > { typedef vector5_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5 > struct vector6_c : v_item< integral_c< T,C5 > , vector5_c< T,C0,C1,C2,C3,C4 > > { typedef vector6_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6 > struct vector7_c : v_item< integral_c< T,C6 > , vector6_c< T,C0,C1,C2,C3,C4,C5 > > { typedef vector7_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 > struct vector8_c : v_item< integral_c< T,C7 > , vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > > { typedef vector8_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 > struct vector9_c : v_item< integral_c< T,C8 > , vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > > { typedef vector9_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 > struct vector10_c : v_item< integral_c< T,C9 > , vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > > { typedef vector10_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001615011344301502031546 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 > struct vector41_c : v_item< integral_c< T,C40 > , vector40_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39 > > { typedef vector41_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41 > struct vector42_c : v_item< integral_c< T,C41 > , vector41_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40 > > { typedef vector42_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42 > struct vector43_c : v_item< integral_c< T,C42 > , vector42_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41 > > { typedef vector43_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43 > struct vector44_c : v_item< integral_c< T,C43 > , vector43_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42 > > { typedef vector44_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44 > struct vector45_c : v_item< integral_c< T,C44 > , vector44_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43 > > { typedef vector45_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45 > struct vector46_c : v_item< integral_c< T,C45 > , vector45_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44 > > { typedef vector46_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46 > struct vector47_c : v_item< integral_c< T,C46 > , vector46_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45 > > { typedef vector47_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47 > struct vector48_c : v_item< integral_c< T,C47 > , vector47_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46 > > { typedef vector48_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 > struct vector49_c : v_item< integral_c< T,C48 > , vector48_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47 > > { typedef vector49_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 > struct vector50_c : v_item< integral_c< T,C49 > , vector49_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48 > > { typedef vector50_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000755000175000017500000000000012146213761031553 5ustar debiandebian././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000002244511344301502031552 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 > struct vector21_c : vector21< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 > > { typedef vector21_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21 > struct vector22_c : vector22< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > > { typedef vector22_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22 > struct vector23_c : vector23< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >, integral_c > { typedef vector23_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23 > struct vector24_c : vector24< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 > > { typedef vector24_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24 > struct vector25_c : vector25< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > > { typedef vector25_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25 > struct vector26_c : vector26< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >, integral_c > { typedef vector26_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26 > struct vector27_c : vector27< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 > > { typedef vector27_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27 > struct vector28_c : vector28< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > > { typedef vector28_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 > struct vector29_c : vector29< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >, integral_c > { typedef vector29_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 > struct vector30_c : vector30< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 > > { typedef vector30_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001433111344301502031545 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 > struct vector11_c : vector11< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >, integral_c > { typedef vector11_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11 > struct vector12_c : vector12< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 > > { typedef vector12_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12 > struct vector13_c : vector13< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > > { typedef vector13_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13 > struct vector14_c : vector14< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >, integral_c > { typedef vector14_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14 > struct vector15_c : vector15< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 > > { typedef vector15_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15 > struct vector16_c : vector16< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > > { typedef vector16_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16 > struct vector17_c : vector17< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >, integral_c > { typedef vector17_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17 > struct vector18_c : vector18< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 > > { typedef vector18_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 > struct vector19_c : vector19< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > > { typedef vector19_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 > struct vector20_c : vector20< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >, integral_c > { typedef vector20_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000013224511344301502031552 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector11 { typedef aux::vector_tag<11> tag; typedef vector11 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef void_ item11; typedef T10 back; typedef v_iter< type,0 > begin; typedef v_iter< type,11 > end; }; template<> struct push_front_impl< aux::vector_tag<10> > { template< typename Vector, typename T > struct apply { typedef vector11< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef vector10< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 > type; }; }; template<> struct push_back_impl< aux::vector_tag<10> > { template< typename Vector, typename T > struct apply { typedef vector11< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef vector10< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 > type; }; }; namespace aux { template<> struct v_at_impl<11> { template< typename V_ > struct result_ { typedef typename V_::item11 type; }; }; } template<> struct at_impl< aux::vector_tag<11> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<11> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<11> > { template< typename Vector > struct apply : long_<11> { }; }; template<> struct O1_size_impl< aux::vector_tag<11> > : size_impl< aux::vector_tag<11> > { }; template<> struct clear_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector12 { typedef aux::vector_tag<12> tag; typedef vector12 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef void_ item12; typedef T11 back; typedef v_iter< type,0 > begin; typedef v_iter< type,12 > end; }; template<> struct push_front_impl< aux::vector_tag<11> > { template< typename Vector, typename T > struct apply { typedef vector12< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef vector11< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11 > type; }; }; template<> struct push_back_impl< aux::vector_tag<11> > { template< typename Vector, typename T > struct apply { typedef vector12< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef vector11< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10 > type; }; }; namespace aux { template<> struct v_at_impl<12> { template< typename V_ > struct result_ { typedef typename V_::item12 type; }; }; } template<> struct at_impl< aux::vector_tag<12> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<12> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<12> > { template< typename Vector > struct apply : long_<12> { }; }; template<> struct O1_size_impl< aux::vector_tag<12> > : size_impl< aux::vector_tag<12> > { }; template<> struct clear_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector13 { typedef aux::vector_tag<13> tag; typedef vector13 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef void_ item13; typedef T12 back; typedef v_iter< type,0 > begin; typedef v_iter< type,13 > end; }; template<> struct push_front_impl< aux::vector_tag<12> > { template< typename Vector, typename T > struct apply { typedef vector13< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef vector12< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 > type; }; }; template<> struct push_back_impl< aux::vector_tag<12> > { template< typename Vector, typename T > struct apply { typedef vector13< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef vector12< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 > type; }; }; namespace aux { template<> struct v_at_impl<13> { template< typename V_ > struct result_ { typedef typename V_::item13 type; }; }; } template<> struct at_impl< aux::vector_tag<13> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<13> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<13> > { template< typename Vector > struct apply : long_<13> { }; }; template<> struct O1_size_impl< aux::vector_tag<13> > : size_impl< aux::vector_tag<13> > { }; template<> struct clear_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector14 { typedef aux::vector_tag<14> tag; typedef vector14 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef void_ item14; typedef T13 back; typedef v_iter< type,0 > begin; typedef v_iter< type,14 > end; }; template<> struct push_front_impl< aux::vector_tag<13> > { template< typename Vector, typename T > struct apply { typedef vector14< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef vector13< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13 > type; }; }; template<> struct push_back_impl< aux::vector_tag<13> > { template< typename Vector, typename T > struct apply { typedef vector14< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef vector13< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12 > type; }; }; namespace aux { template<> struct v_at_impl<14> { template< typename V_ > struct result_ { typedef typename V_::item14 type; }; }; } template<> struct at_impl< aux::vector_tag<14> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<14> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<14> > { template< typename Vector > struct apply : long_<14> { }; }; template<> struct O1_size_impl< aux::vector_tag<14> > : size_impl< aux::vector_tag<14> > { }; template<> struct clear_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector15 { typedef aux::vector_tag<15> tag; typedef vector15 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef void_ item15; typedef T14 back; typedef v_iter< type,0 > begin; typedef v_iter< type,15 > end; }; template<> struct push_front_impl< aux::vector_tag<14> > { template< typename Vector, typename T > struct apply { typedef vector15< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef vector14< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 > type; }; }; template<> struct push_back_impl< aux::vector_tag<14> > { template< typename Vector, typename T > struct apply { typedef vector15< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef vector14< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 > type; }; }; namespace aux { template<> struct v_at_impl<15> { template< typename V_ > struct result_ { typedef typename V_::item15 type; }; }; } template<> struct at_impl< aux::vector_tag<15> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<15> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<15> > { template< typename Vector > struct apply : long_<15> { }; }; template<> struct O1_size_impl< aux::vector_tag<15> > : size_impl< aux::vector_tag<15> > { }; template<> struct clear_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector16 { typedef aux::vector_tag<16> tag; typedef vector16 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef void_ item16; typedef T15 back; typedef v_iter< type,0 > begin; typedef v_iter< type,16 > end; }; template<> struct push_front_impl< aux::vector_tag<15> > { template< typename Vector, typename T > struct apply { typedef vector16< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef vector15< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15 > type; }; }; template<> struct push_back_impl< aux::vector_tag<15> > { template< typename Vector, typename T > struct apply { typedef vector16< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef vector15< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14 > type; }; }; namespace aux { template<> struct v_at_impl<16> { template< typename V_ > struct result_ { typedef typename V_::item16 type; }; }; } template<> struct at_impl< aux::vector_tag<16> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<16> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<16> > { template< typename Vector > struct apply : long_<16> { }; }; template<> struct O1_size_impl< aux::vector_tag<16> > : size_impl< aux::vector_tag<16> > { }; template<> struct clear_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector17 { typedef aux::vector_tag<17> tag; typedef vector17 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef void_ item17; typedef T16 back; typedef v_iter< type,0 > begin; typedef v_iter< type,17 > end; }; template<> struct push_front_impl< aux::vector_tag<16> > { template< typename Vector, typename T > struct apply { typedef vector17< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef vector16< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 > type; }; }; template<> struct push_back_impl< aux::vector_tag<16> > { template< typename Vector, typename T > struct apply { typedef vector17< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef vector16< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 > type; }; }; namespace aux { template<> struct v_at_impl<17> { template< typename V_ > struct result_ { typedef typename V_::item17 type; }; }; } template<> struct at_impl< aux::vector_tag<17> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<17> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<17> > { template< typename Vector > struct apply : long_<17> { }; }; template<> struct O1_size_impl< aux::vector_tag<17> > : size_impl< aux::vector_tag<17> > { }; template<> struct clear_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector18 { typedef aux::vector_tag<18> tag; typedef vector18 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef void_ item18; typedef T17 back; typedef v_iter< type,0 > begin; typedef v_iter< type,18 > end; }; template<> struct push_front_impl< aux::vector_tag<17> > { template< typename Vector, typename T > struct apply { typedef vector18< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef vector17< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17 > type; }; }; template<> struct push_back_impl< aux::vector_tag<17> > { template< typename Vector, typename T > struct apply { typedef vector18< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef vector17< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16 > type; }; }; namespace aux { template<> struct v_at_impl<18> { template< typename V_ > struct result_ { typedef typename V_::item18 type; }; }; } template<> struct at_impl< aux::vector_tag<18> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<18> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<18> > { template< typename Vector > struct apply : long_<18> { }; }; template<> struct O1_size_impl< aux::vector_tag<18> > : size_impl< aux::vector_tag<18> > { }; template<> struct clear_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector19 { typedef aux::vector_tag<19> tag; typedef vector19 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef void_ item19; typedef T18 back; typedef v_iter< type,0 > begin; typedef v_iter< type,19 > end; }; template<> struct push_front_impl< aux::vector_tag<18> > { template< typename Vector, typename T > struct apply { typedef vector19< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef vector18< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 > type; }; }; template<> struct push_back_impl< aux::vector_tag<18> > { template< typename Vector, typename T > struct apply { typedef vector19< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef vector18< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 > type; }; }; namespace aux { template<> struct v_at_impl<19> { template< typename V_ > struct result_ { typedef typename V_::item19 type; }; }; } template<> struct at_impl< aux::vector_tag<19> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<19> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<19> > { template< typename Vector > struct apply : long_<19> { }; }; template<> struct O1_size_impl< aux::vector_tag<19> > : size_impl< aux::vector_tag<19> > { }; template<> struct clear_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector20 { typedef aux::vector_tag<20> tag; typedef vector20 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef void_ item20; typedef T19 back; typedef v_iter< type,0 > begin; typedef v_iter< type,20 > end; }; template<> struct push_front_impl< aux::vector_tag<19> > { template< typename Vector, typename T > struct apply { typedef vector20< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef vector19< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19 > type; }; }; template<> struct push_back_impl< aux::vector_tag<19> > { template< typename Vector, typename T > struct apply { typedef vector20< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef vector19< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18 > type; }; }; namespace aux { template<> struct v_at_impl<20> { template< typename V_ > struct result_ { typedef typename V_::item20 type; }; }; } template<> struct at_impl< aux::vector_tag<20> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<20> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<20> > { template< typename Vector > struct apply : long_<20> { }; }; template<> struct O1_size_impl< aux::vector_tag<20> > : size_impl< aux::vector_tag<20> > { }; template<> struct clear_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000017243111344301502031553 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20 > struct vector21 { typedef aux::vector_tag<21> tag; typedef vector21 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef void_ item21; typedef T20 back; typedef v_iter< type,0 > begin; typedef v_iter< type,21 > end; }; template<> struct push_front_impl< aux::vector_tag<20> > { template< typename Vector, typename T > struct apply { typedef vector21< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef vector20< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 > type; }; }; template<> struct push_back_impl< aux::vector_tag<20> > { template< typename Vector, typename T > struct apply { typedef vector21< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef vector20< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 > type; }; }; namespace aux { template<> struct v_at_impl<21> { template< typename V_ > struct result_ { typedef typename V_::item21 type; }; }; } template<> struct at_impl< aux::vector_tag<21> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<21> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<21> > { template< typename Vector > struct apply : long_<21> { }; }; template<> struct O1_size_impl< aux::vector_tag<21> > : size_impl< aux::vector_tag<21> > { }; template<> struct clear_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21 > struct vector22 { typedef aux::vector_tag<22> tag; typedef vector22 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef void_ item22; typedef T21 back; typedef v_iter< type,0 > begin; typedef v_iter< type,22 > end; }; template<> struct push_front_impl< aux::vector_tag<21> > { template< typename Vector, typename T > struct apply { typedef vector22< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef vector21< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21 > type; }; }; template<> struct push_back_impl< aux::vector_tag<21> > { template< typename Vector, typename T > struct apply { typedef vector22< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef vector21< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20 > type; }; }; namespace aux { template<> struct v_at_impl<22> { template< typename V_ > struct result_ { typedef typename V_::item22 type; }; }; } template<> struct at_impl< aux::vector_tag<22> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<22> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<22> > { template< typename Vector > struct apply : long_<22> { }; }; template<> struct O1_size_impl< aux::vector_tag<22> > : size_impl< aux::vector_tag<22> > { }; template<> struct clear_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22 > struct vector23 { typedef aux::vector_tag<23> tag; typedef vector23 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef void_ item23; typedef T22 back; typedef v_iter< type,0 > begin; typedef v_iter< type,23 > end; }; template<> struct push_front_impl< aux::vector_tag<22> > { template< typename Vector, typename T > struct apply { typedef vector23< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef vector22< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 > type; }; }; template<> struct push_back_impl< aux::vector_tag<22> > { template< typename Vector, typename T > struct apply { typedef vector23< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef vector22< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 > type; }; }; namespace aux { template<> struct v_at_impl<23> { template< typename V_ > struct result_ { typedef typename V_::item23 type; }; }; } template<> struct at_impl< aux::vector_tag<23> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<23> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<23> > { template< typename Vector > struct apply : long_<23> { }; }; template<> struct O1_size_impl< aux::vector_tag<23> > : size_impl< aux::vector_tag<23> > { }; template<> struct clear_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23 > struct vector24 { typedef aux::vector_tag<24> tag; typedef vector24 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef void_ item24; typedef T23 back; typedef v_iter< type,0 > begin; typedef v_iter< type,24 > end; }; template<> struct push_front_impl< aux::vector_tag<23> > { template< typename Vector, typename T > struct apply { typedef vector24< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef vector23< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23 > type; }; }; template<> struct push_back_impl< aux::vector_tag<23> > { template< typename Vector, typename T > struct apply { typedef vector24< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef vector23< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22 > type; }; }; namespace aux { template<> struct v_at_impl<24> { template< typename V_ > struct result_ { typedef typename V_::item24 type; }; }; } template<> struct at_impl< aux::vector_tag<24> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<24> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<24> > { template< typename Vector > struct apply : long_<24> { }; }; template<> struct O1_size_impl< aux::vector_tag<24> > : size_impl< aux::vector_tag<24> > { }; template<> struct clear_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 > struct vector25 { typedef aux::vector_tag<25> tag; typedef vector25 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef void_ item25; typedef T24 back; typedef v_iter< type,0 > begin; typedef v_iter< type,25 > end; }; template<> struct push_front_impl< aux::vector_tag<24> > { template< typename Vector, typename T > struct apply { typedef vector25< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef vector24< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 > type; }; }; template<> struct push_back_impl< aux::vector_tag<24> > { template< typename Vector, typename T > struct apply { typedef vector25< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef vector24< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 > type; }; }; namespace aux { template<> struct v_at_impl<25> { template< typename V_ > struct result_ { typedef typename V_::item25 type; }; }; } template<> struct at_impl< aux::vector_tag<25> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<25> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<25> > { template< typename Vector > struct apply : long_<25> { }; }; template<> struct O1_size_impl< aux::vector_tag<25> > : size_impl< aux::vector_tag<25> > { }; template<> struct clear_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25 > struct vector26 { typedef aux::vector_tag<26> tag; typedef vector26 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef void_ item26; typedef T25 back; typedef v_iter< type,0 > begin; typedef v_iter< type,26 > end; }; template<> struct push_front_impl< aux::vector_tag<25> > { template< typename Vector, typename T > struct apply { typedef vector26< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef vector25< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25 > type; }; }; template<> struct push_back_impl< aux::vector_tag<25> > { template< typename Vector, typename T > struct apply { typedef vector26< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef vector25< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24 > type; }; }; namespace aux { template<> struct v_at_impl<26> { template< typename V_ > struct result_ { typedef typename V_::item26 type; }; }; } template<> struct at_impl< aux::vector_tag<26> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<26> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<26> > { template< typename Vector > struct apply : long_<26> { }; }; template<> struct O1_size_impl< aux::vector_tag<26> > : size_impl< aux::vector_tag<26> > { }; template<> struct clear_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26 > struct vector27 { typedef aux::vector_tag<27> tag; typedef vector27 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef void_ item27; typedef T26 back; typedef v_iter< type,0 > begin; typedef v_iter< type,27 > end; }; template<> struct push_front_impl< aux::vector_tag<26> > { template< typename Vector, typename T > struct apply { typedef vector27< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef vector26< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 > type; }; }; template<> struct push_back_impl< aux::vector_tag<26> > { template< typename Vector, typename T > struct apply { typedef vector27< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef vector26< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 > type; }; }; namespace aux { template<> struct v_at_impl<27> { template< typename V_ > struct result_ { typedef typename V_::item27 type; }; }; } template<> struct at_impl< aux::vector_tag<27> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<27> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<27> > { template< typename Vector > struct apply : long_<27> { }; }; template<> struct O1_size_impl< aux::vector_tag<27> > : size_impl< aux::vector_tag<27> > { }; template<> struct clear_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27 > struct vector28 { typedef aux::vector_tag<28> tag; typedef vector28 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef void_ item28; typedef T27 back; typedef v_iter< type,0 > begin; typedef v_iter< type,28 > end; }; template<> struct push_front_impl< aux::vector_tag<27> > { template< typename Vector, typename T > struct apply { typedef vector28< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef vector27< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27 > type; }; }; template<> struct push_back_impl< aux::vector_tag<27> > { template< typename Vector, typename T > struct apply { typedef vector28< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef vector27< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26 > type; }; }; namespace aux { template<> struct v_at_impl<28> { template< typename V_ > struct result_ { typedef typename V_::item28 type; }; }; } template<> struct at_impl< aux::vector_tag<28> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<28> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<28> > { template< typename Vector > struct apply : long_<28> { }; }; template<> struct O1_size_impl< aux::vector_tag<28> > : size_impl< aux::vector_tag<28> > { }; template<> struct clear_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28 > struct vector29 { typedef aux::vector_tag<29> tag; typedef vector29 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef void_ item29; typedef T28 back; typedef v_iter< type,0 > begin; typedef v_iter< type,29 > end; }; template<> struct push_front_impl< aux::vector_tag<28> > { template< typename Vector, typename T > struct apply { typedef vector29< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef vector28< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 > type; }; }; template<> struct push_back_impl< aux::vector_tag<28> > { template< typename Vector, typename T > struct apply { typedef vector29< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef vector28< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 > type; }; }; namespace aux { template<> struct v_at_impl<29> { template< typename V_ > struct result_ { typedef typename V_::item29 type; }; }; } template<> struct at_impl< aux::vector_tag<29> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<29> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<29> > { template< typename Vector > struct apply : long_<29> { }; }; template<> struct O1_size_impl< aux::vector_tag<29> > : size_impl< aux::vector_tag<29> > { }; template<> struct clear_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 > struct vector30 { typedef aux::vector_tag<30> tag; typedef vector30 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef void_ item30; typedef T29 back; typedef v_iter< type,0 > begin; typedef v_iter< type,30 > end; }; template<> struct push_front_impl< aux::vector_tag<29> > { template< typename Vector, typename T > struct apply { typedef vector30< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef vector29< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29 > type; }; }; template<> struct push_back_impl< aux::vector_tag<29> > { template< typename Vector, typename T > struct apply { typedef vector30< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef vector29< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28 > type; }; }; namespace aux { template<> struct v_at_impl<30> { template< typename V_ > struct result_ { typedef typename V_::item30 type; }; }; } template<> struct at_impl< aux::vector_tag<30> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<30> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<30> > { template< typename Vector > struct apply : long_<30> { }; }; template<> struct O1_size_impl< aux::vector_tag<30> > : size_impl< aux::vector_tag<30> > { }; template<> struct clear_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; }} ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000003056011344301502031547 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 > struct vector31_c : vector31< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > > { typedef vector31_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31 > struct vector32_c : vector32< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >, integral_c > { typedef vector32_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32 > struct vector33_c : vector33< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 > > { typedef vector33_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33 > struct vector34_c : vector34< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > > { typedef vector34_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34 > struct vector35_c : vector35< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >, integral_c > { typedef vector35_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35 > struct vector36_c : vector36< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 > > { typedef vector36_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36 > struct vector37_c : vector37< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > > { typedef vector37_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37 > struct vector38_c : vector38< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >, integral_c > { typedef vector38_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 > struct vector39_c : vector39< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 > > { typedef vector39_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 > struct vector40_c : vector40< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > > { typedef vector40_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000007365511344301502031563 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template<> struct v_at_impl<0> { template< typename V_ > struct result_ { typedef typename V_::item0 type; }; }; } template<> struct at_impl< aux::vector_tag<0> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct size_impl< aux::vector_tag<0> > { template< typename Vector > struct apply : long_<0> { }; }; template<> struct O1_size_impl< aux::vector_tag<0> > : size_impl< aux::vector_tag<0> > { }; template<> struct clear_impl< aux::vector_tag<0> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0 > struct vector1 { typedef aux::vector_tag<1> tag; typedef vector1 type; typedef T0 item0; typedef void_ item1; typedef T0 back; typedef v_iter< type,0 > begin; typedef v_iter< type,1 > end; }; template<> struct push_front_impl< aux::vector_tag<0> > { template< typename Vector, typename T > struct apply { typedef vector1< T > type; }; }; template<> struct pop_front_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef vector0< > type; }; }; template<> struct push_back_impl< aux::vector_tag<0> > { template< typename Vector, typename T > struct apply { typedef vector1< T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef vector0< > type; }; }; namespace aux { template<> struct v_at_impl<1> { template< typename V_ > struct result_ { typedef typename V_::item1 type; }; }; } template<> struct at_impl< aux::vector_tag<1> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<1> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<1> > { template< typename Vector > struct apply : long_<1> { }; }; template<> struct O1_size_impl< aux::vector_tag<1> > : size_impl< aux::vector_tag<1> > { }; template<> struct clear_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1 > struct vector2 { typedef aux::vector_tag<2> tag; typedef vector2 type; typedef T0 item0; typedef T1 item1; typedef void_ item2; typedef T1 back; typedef v_iter< type,0 > begin; typedef v_iter< type,2 > end; }; template<> struct push_front_impl< aux::vector_tag<1> > { template< typename Vector, typename T > struct apply { typedef vector2< T , typename Vector::item0 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef vector1< typename Vector::item1 > type; }; }; template<> struct push_back_impl< aux::vector_tag<1> > { template< typename Vector, typename T > struct apply { typedef vector2< typename Vector::item0 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef vector1< typename Vector::item0 > type; }; }; namespace aux { template<> struct v_at_impl<2> { template< typename V_ > struct result_ { typedef typename V_::item2 type; }; }; } template<> struct at_impl< aux::vector_tag<2> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<2> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<2> > { template< typename Vector > struct apply : long_<2> { }; }; template<> struct O1_size_impl< aux::vector_tag<2> > : size_impl< aux::vector_tag<2> > { }; template<> struct clear_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2 > struct vector3 { typedef aux::vector_tag<3> tag; typedef vector3 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef void_ item3; typedef T2 back; typedef v_iter< type,0 > begin; typedef v_iter< type,3 > end; }; template<> struct push_front_impl< aux::vector_tag<2> > { template< typename Vector, typename T > struct apply { typedef vector3< T , typename Vector::item0, typename Vector::item1 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef vector2< typename Vector::item1, typename Vector::item2 > type; }; }; template<> struct push_back_impl< aux::vector_tag<2> > { template< typename Vector, typename T > struct apply { typedef vector3< typename Vector::item0, typename Vector::item1 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef vector2< typename Vector::item0, typename Vector::item1 > type; }; }; namespace aux { template<> struct v_at_impl<3> { template< typename V_ > struct result_ { typedef typename V_::item3 type; }; }; } template<> struct at_impl< aux::vector_tag<3> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<3> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<3> > { template< typename Vector > struct apply : long_<3> { }; }; template<> struct O1_size_impl< aux::vector_tag<3> > : size_impl< aux::vector_tag<3> > { }; template<> struct clear_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector4 { typedef aux::vector_tag<4> tag; typedef vector4 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef void_ item4; typedef T3 back; typedef v_iter< type,0 > begin; typedef v_iter< type,4 > end; }; template<> struct push_front_impl< aux::vector_tag<3> > { template< typename Vector, typename T > struct apply { typedef vector4< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef vector3< typename Vector::item1, typename Vector::item2 , typename Vector::item3 > type; }; }; template<> struct push_back_impl< aux::vector_tag<3> > { template< typename Vector, typename T > struct apply { typedef vector4< typename Vector::item0, typename Vector::item1 , typename Vector::item2 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef vector3< typename Vector::item0, typename Vector::item1 , typename Vector::item2 > type; }; }; namespace aux { template<> struct v_at_impl<4> { template< typename V_ > struct result_ { typedef typename V_::item4 type; }; }; } template<> struct at_impl< aux::vector_tag<4> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<4> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<4> > { template< typename Vector > struct apply : long_<4> { }; }; template<> struct O1_size_impl< aux::vector_tag<4> > : size_impl< aux::vector_tag<4> > { }; template<> struct clear_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector5 { typedef aux::vector_tag<5> tag; typedef vector5 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef void_ item5; typedef T4 back; typedef v_iter< type,0 > begin; typedef v_iter< type,5 > end; }; template<> struct push_front_impl< aux::vector_tag<4> > { template< typename Vector, typename T > struct apply { typedef vector5< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef vector4< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 > type; }; }; template<> struct push_back_impl< aux::vector_tag<4> > { template< typename Vector, typename T > struct apply { typedef vector5< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef vector4< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 > type; }; }; namespace aux { template<> struct v_at_impl<5> { template< typename V_ > struct result_ { typedef typename V_::item5 type; }; }; } template<> struct at_impl< aux::vector_tag<5> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<5> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<5> > { template< typename Vector > struct apply : long_<5> { }; }; template<> struct O1_size_impl< aux::vector_tag<5> > : size_impl< aux::vector_tag<5> > { }; template<> struct clear_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector6 { typedef aux::vector_tag<6> tag; typedef vector6 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef void_ item6; typedef T5 back; typedef v_iter< type,0 > begin; typedef v_iter< type,6 > end; }; template<> struct push_front_impl< aux::vector_tag<5> > { template< typename Vector, typename T > struct apply { typedef vector6< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef vector5< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5 > type; }; }; template<> struct push_back_impl< aux::vector_tag<5> > { template< typename Vector, typename T > struct apply { typedef vector6< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef vector5< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4 > type; }; }; namespace aux { template<> struct v_at_impl<6> { template< typename V_ > struct result_ { typedef typename V_::item6 type; }; }; } template<> struct at_impl< aux::vector_tag<6> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<6> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<6> > { template< typename Vector > struct apply : long_<6> { }; }; template<> struct O1_size_impl< aux::vector_tag<6> > : size_impl< aux::vector_tag<6> > { }; template<> struct clear_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector7 { typedef aux::vector_tag<7> tag; typedef vector7 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef void_ item7; typedef T6 back; typedef v_iter< type,0 > begin; typedef v_iter< type,7 > end; }; template<> struct push_front_impl< aux::vector_tag<6> > { template< typename Vector, typename T > struct apply { typedef vector7< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef vector6< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 > type; }; }; template<> struct push_back_impl< aux::vector_tag<6> > { template< typename Vector, typename T > struct apply { typedef vector7< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef vector6< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 > type; }; }; namespace aux { template<> struct v_at_impl<7> { template< typename V_ > struct result_ { typedef typename V_::item7 type; }; }; } template<> struct at_impl< aux::vector_tag<7> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<7> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<7> > { template< typename Vector > struct apply : long_<7> { }; }; template<> struct O1_size_impl< aux::vector_tag<7> > : size_impl< aux::vector_tag<7> > { }; template<> struct clear_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector8 { typedef aux::vector_tag<8> tag; typedef vector8 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef void_ item8; typedef T7 back; typedef v_iter< type,0 > begin; typedef v_iter< type,8 > end; }; template<> struct push_front_impl< aux::vector_tag<7> > { template< typename Vector, typename T > struct apply { typedef vector8< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef vector7< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7 > type; }; }; template<> struct push_back_impl< aux::vector_tag<7> > { template< typename Vector, typename T > struct apply { typedef vector8< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef vector7< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6 > type; }; }; namespace aux { template<> struct v_at_impl<8> { template< typename V_ > struct result_ { typedef typename V_::item8 type; }; }; } template<> struct at_impl< aux::vector_tag<8> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<8> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<8> > { template< typename Vector > struct apply : long_<8> { }; }; template<> struct O1_size_impl< aux::vector_tag<8> > : size_impl< aux::vector_tag<8> > { }; template<> struct clear_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector9 { typedef aux::vector_tag<9> tag; typedef vector9 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef void_ item9; typedef T8 back; typedef v_iter< type,0 > begin; typedef v_iter< type,9 > end; }; template<> struct push_front_impl< aux::vector_tag<8> > { template< typename Vector, typename T > struct apply { typedef vector9< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef vector8< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 > type; }; }; template<> struct push_back_impl< aux::vector_tag<8> > { template< typename Vector, typename T > struct apply { typedef vector9< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef vector8< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 > type; }; }; namespace aux { template<> struct v_at_impl<9> { template< typename V_ > struct result_ { typedef typename V_::item9 type; }; }; } template<> struct at_impl< aux::vector_tag<9> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<9> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<9> > { template< typename Vector > struct apply : long_<9> { }; }; template<> struct O1_size_impl< aux::vector_tag<9> > : size_impl< aux::vector_tag<9> > { }; template<> struct clear_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector10 { typedef aux::vector_tag<10> tag; typedef vector10 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef void_ item10; typedef T9 back; typedef v_iter< type,0 > begin; typedef v_iter< type,10 > end; }; template<> struct push_front_impl< aux::vector_tag<9> > { template< typename Vector, typename T > struct apply { typedef vector10< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef vector9< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9 > type; }; }; template<> struct push_back_impl< aux::vector_tag<9> > { template< typename Vector, typename T > struct apply { typedef vector10< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef vector9< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8 > type; }; }; namespace aux { template<> struct v_at_impl<10> { template< typename V_ > struct result_ { typedef typename V_::item10 type; }; }; } template<> struct at_impl< aux::vector_tag<10> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<10> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<10> > { template< typename Vector > struct apply : long_<10> { }; }; template<> struct O1_size_impl< aux::vector_tag<10> > : size_impl< aux::vector_tag<10> > { }; template<> struct clear_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000027300111344301502031546 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40 > struct vector41 { typedef aux::vector_tag<41> tag; typedef vector41 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef void_ item41; typedef T40 back; typedef v_iter< type,0 > begin; typedef v_iter< type,41 > end; }; template<> struct push_front_impl< aux::vector_tag<40> > { template< typename Vector, typename T > struct apply { typedef vector41< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef vector40< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 > type; }; }; template<> struct push_back_impl< aux::vector_tag<40> > { template< typename Vector, typename T > struct apply { typedef vector41< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef vector40< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 > type; }; }; namespace aux { template<> struct v_at_impl<41> { template< typename V_ > struct result_ { typedef typename V_::item41 type; }; }; } template<> struct at_impl< aux::vector_tag<41> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<41> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<41> > { template< typename Vector > struct apply : long_<41> { }; }; template<> struct O1_size_impl< aux::vector_tag<41> > : size_impl< aux::vector_tag<41> > { }; template<> struct clear_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41 > struct vector42 { typedef aux::vector_tag<42> tag; typedef vector42 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef void_ item42; typedef T41 back; typedef v_iter< type,0 > begin; typedef v_iter< type,42 > end; }; template<> struct push_front_impl< aux::vector_tag<41> > { template< typename Vector, typename T > struct apply { typedef vector42< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef vector41< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41 > type; }; }; template<> struct push_back_impl< aux::vector_tag<41> > { template< typename Vector, typename T > struct apply { typedef vector42< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef vector41< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40 > type; }; }; namespace aux { template<> struct v_at_impl<42> { template< typename V_ > struct result_ { typedef typename V_::item42 type; }; }; } template<> struct at_impl< aux::vector_tag<42> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<42> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<42> > { template< typename Vector > struct apply : long_<42> { }; }; template<> struct O1_size_impl< aux::vector_tag<42> > : size_impl< aux::vector_tag<42> > { }; template<> struct clear_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42 > struct vector43 { typedef aux::vector_tag<43> tag; typedef vector43 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef void_ item43; typedef T42 back; typedef v_iter< type,0 > begin; typedef v_iter< type,43 > end; }; template<> struct push_front_impl< aux::vector_tag<42> > { template< typename Vector, typename T > struct apply { typedef vector43< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef vector42< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 > type; }; }; template<> struct push_back_impl< aux::vector_tag<42> > { template< typename Vector, typename T > struct apply { typedef vector43< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef vector42< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 > type; }; }; namespace aux { template<> struct v_at_impl<43> { template< typename V_ > struct result_ { typedef typename V_::item43 type; }; }; } template<> struct at_impl< aux::vector_tag<43> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<43> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<43> > { template< typename Vector > struct apply : long_<43> { }; }; template<> struct O1_size_impl< aux::vector_tag<43> > : size_impl< aux::vector_tag<43> > { }; template<> struct clear_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43 > struct vector44 { typedef aux::vector_tag<44> tag; typedef vector44 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef void_ item44; typedef T43 back; typedef v_iter< type,0 > begin; typedef v_iter< type,44 > end; }; template<> struct push_front_impl< aux::vector_tag<43> > { template< typename Vector, typename T > struct apply { typedef vector44< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef vector43< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43 > type; }; }; template<> struct push_back_impl< aux::vector_tag<43> > { template< typename Vector, typename T > struct apply { typedef vector44< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef vector43< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42 > type; }; }; namespace aux { template<> struct v_at_impl<44> { template< typename V_ > struct result_ { typedef typename V_::item44 type; }; }; } template<> struct at_impl< aux::vector_tag<44> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<44> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<44> > { template< typename Vector > struct apply : long_<44> { }; }; template<> struct O1_size_impl< aux::vector_tag<44> > : size_impl< aux::vector_tag<44> > { }; template<> struct clear_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 > struct vector45 { typedef aux::vector_tag<45> tag; typedef vector45 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef void_ item45; typedef T44 back; typedef v_iter< type,0 > begin; typedef v_iter< type,45 > end; }; template<> struct push_front_impl< aux::vector_tag<44> > { template< typename Vector, typename T > struct apply { typedef vector45< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef vector44< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 > type; }; }; template<> struct push_back_impl< aux::vector_tag<44> > { template< typename Vector, typename T > struct apply { typedef vector45< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef vector44< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 > type; }; }; namespace aux { template<> struct v_at_impl<45> { template< typename V_ > struct result_ { typedef typename V_::item45 type; }; }; } template<> struct at_impl< aux::vector_tag<45> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<45> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<45> > { template< typename Vector > struct apply : long_<45> { }; }; template<> struct O1_size_impl< aux::vector_tag<45> > : size_impl< aux::vector_tag<45> > { }; template<> struct clear_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45 > struct vector46 { typedef aux::vector_tag<46> tag; typedef vector46 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef void_ item46; typedef T45 back; typedef v_iter< type,0 > begin; typedef v_iter< type,46 > end; }; template<> struct push_front_impl< aux::vector_tag<45> > { template< typename Vector, typename T > struct apply { typedef vector46< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef vector45< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45 > type; }; }; template<> struct push_back_impl< aux::vector_tag<45> > { template< typename Vector, typename T > struct apply { typedef vector46< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef vector45< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44 > type; }; }; namespace aux { template<> struct v_at_impl<46> { template< typename V_ > struct result_ { typedef typename V_::item46 type; }; }; } template<> struct at_impl< aux::vector_tag<46> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<46> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<46> > { template< typename Vector > struct apply : long_<46> { }; }; template<> struct O1_size_impl< aux::vector_tag<46> > : size_impl< aux::vector_tag<46> > { }; template<> struct clear_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46 > struct vector47 { typedef aux::vector_tag<47> tag; typedef vector47 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef void_ item47; typedef T46 back; typedef v_iter< type,0 > begin; typedef v_iter< type,47 > end; }; template<> struct push_front_impl< aux::vector_tag<46> > { template< typename Vector, typename T > struct apply { typedef vector47< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef vector46< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 > type; }; }; template<> struct push_back_impl< aux::vector_tag<46> > { template< typename Vector, typename T > struct apply { typedef vector47< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef vector46< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 > type; }; }; namespace aux { template<> struct v_at_impl<47> { template< typename V_ > struct result_ { typedef typename V_::item47 type; }; }; } template<> struct at_impl< aux::vector_tag<47> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<47> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<47> > { template< typename Vector > struct apply : long_<47> { }; }; template<> struct O1_size_impl< aux::vector_tag<47> > : size_impl< aux::vector_tag<47> > { }; template<> struct clear_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47 > struct vector48 { typedef aux::vector_tag<48> tag; typedef vector48 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef T47 item47; typedef void_ item48; typedef T47 back; typedef v_iter< type,0 > begin; typedef v_iter< type,48 > end; }; template<> struct push_front_impl< aux::vector_tag<47> > { template< typename Vector, typename T > struct apply { typedef vector48< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef vector47< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 , typename Vector::item47 > type; }; }; template<> struct push_back_impl< aux::vector_tag<47> > { template< typename Vector, typename T > struct apply { typedef vector48< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef vector47< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46 > type; }; }; namespace aux { template<> struct v_at_impl<48> { template< typename V_ > struct result_ { typedef typename V_::item48 type; }; }; } template<> struct at_impl< aux::vector_tag<48> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<48> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<48> > { template< typename Vector > struct apply : long_<48> { }; }; template<> struct O1_size_impl< aux::vector_tag<48> > : size_impl< aux::vector_tag<48> > { }; template<> struct clear_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48 > struct vector49 { typedef aux::vector_tag<49> tag; typedef vector49 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef T47 item47; typedef T48 item48; typedef void_ item49; typedef T48 back; typedef v_iter< type,0 > begin; typedef v_iter< type,49 > end; }; template<> struct push_front_impl< aux::vector_tag<48> > { template< typename Vector, typename T > struct apply { typedef vector49< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef vector48< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 , typename Vector::item47, typename Vector::item48 > type; }; }; template<> struct push_back_impl< aux::vector_tag<48> > { template< typename Vector, typename T > struct apply { typedef vector49< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef vector48< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 > type; }; }; namespace aux { template<> struct v_at_impl<49> { template< typename V_ > struct result_ { typedef typename V_::item49 type; }; }; } template<> struct at_impl< aux::vector_tag<49> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<49> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<49> > { template< typename Vector > struct apply : long_<49> { }; }; template<> struct O1_size_impl< aux::vector_tag<49> > : size_impl< aux::vector_tag<49> > { }; template<> struct clear_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48, typename T49 > struct vector50 { typedef aux::vector_tag<50> tag; typedef vector50 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef T47 item47; typedef T48 item48; typedef T49 item49; typedef void_ item50; typedef T49 back; typedef v_iter< type,0 > begin; typedef v_iter< type,50 > end; }; template<> struct push_front_impl< aux::vector_tag<49> > { template< typename Vector, typename T > struct apply { typedef vector50< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , typename Vector::item48 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef vector49< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 , typename Vector::item47, typename Vector::item48 , typename Vector::item49 > type; }; }; template<> struct push_back_impl< aux::vector_tag<49> > { template< typename Vector, typename T > struct apply { typedef vector50< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , typename Vector::item48 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef vector49< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , typename Vector::item48 > type; }; }; namespace aux { template<> struct v_at_impl<50> { template< typename V_ > struct result_ { typedef typename V_::item50 type; }; }; } template<> struct at_impl< aux::vector_tag<50> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<50> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<50> > { template< typename Vector > struct apply : long_<50> { }; }; template<> struct O1_size_impl< aux::vector_tag<50> > : size_impl< aux::vector_tag<50> > { }; template<> struct clear_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000023261511344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30 > struct vector31 { typedef aux::vector_tag<31> tag; typedef vector31 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef void_ item31; typedef T30 back; typedef v_iter< type,0 > begin; typedef v_iter< type,31 > end; }; template<> struct push_front_impl< aux::vector_tag<30> > { template< typename Vector, typename T > struct apply { typedef vector31< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef vector30< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 > type; }; }; template<> struct push_back_impl< aux::vector_tag<30> > { template< typename Vector, typename T > struct apply { typedef vector31< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef vector30< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 > type; }; }; namespace aux { template<> struct v_at_impl<31> { template< typename V_ > struct result_ { typedef typename V_::item31 type; }; }; } template<> struct at_impl< aux::vector_tag<31> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<31> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<31> > { template< typename Vector > struct apply : long_<31> { }; }; template<> struct O1_size_impl< aux::vector_tag<31> > : size_impl< aux::vector_tag<31> > { }; template<> struct clear_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31 > struct vector32 { typedef aux::vector_tag<32> tag; typedef vector32 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef void_ item32; typedef T31 back; typedef v_iter< type,0 > begin; typedef v_iter< type,32 > end; }; template<> struct push_front_impl< aux::vector_tag<31> > { template< typename Vector, typename T > struct apply { typedef vector32< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef vector31< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31 > type; }; }; template<> struct push_back_impl< aux::vector_tag<31> > { template< typename Vector, typename T > struct apply { typedef vector32< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef vector31< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30 > type; }; }; namespace aux { template<> struct v_at_impl<32> { template< typename V_ > struct result_ { typedef typename V_::item32 type; }; }; } template<> struct at_impl< aux::vector_tag<32> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<32> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<32> > { template< typename Vector > struct apply : long_<32> { }; }; template<> struct O1_size_impl< aux::vector_tag<32> > : size_impl< aux::vector_tag<32> > { }; template<> struct clear_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32 > struct vector33 { typedef aux::vector_tag<33> tag; typedef vector33 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef void_ item33; typedef T32 back; typedef v_iter< type,0 > begin; typedef v_iter< type,33 > end; }; template<> struct push_front_impl< aux::vector_tag<32> > { template< typename Vector, typename T > struct apply { typedef vector33< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef vector32< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 > type; }; }; template<> struct push_back_impl< aux::vector_tag<32> > { template< typename Vector, typename T > struct apply { typedef vector33< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef vector32< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 > type; }; }; namespace aux { template<> struct v_at_impl<33> { template< typename V_ > struct result_ { typedef typename V_::item33 type; }; }; } template<> struct at_impl< aux::vector_tag<33> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<33> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<33> > { template< typename Vector > struct apply : long_<33> { }; }; template<> struct O1_size_impl< aux::vector_tag<33> > : size_impl< aux::vector_tag<33> > { }; template<> struct clear_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33 > struct vector34 { typedef aux::vector_tag<34> tag; typedef vector34 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef void_ item34; typedef T33 back; typedef v_iter< type,0 > begin; typedef v_iter< type,34 > end; }; template<> struct push_front_impl< aux::vector_tag<33> > { template< typename Vector, typename T > struct apply { typedef vector34< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef vector33< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33 > type; }; }; template<> struct push_back_impl< aux::vector_tag<33> > { template< typename Vector, typename T > struct apply { typedef vector34< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef vector33< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32 > type; }; }; namespace aux { template<> struct v_at_impl<34> { template< typename V_ > struct result_ { typedef typename V_::item34 type; }; }; } template<> struct at_impl< aux::vector_tag<34> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<34> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<34> > { template< typename Vector > struct apply : long_<34> { }; }; template<> struct O1_size_impl< aux::vector_tag<34> > : size_impl< aux::vector_tag<34> > { }; template<> struct clear_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 > struct vector35 { typedef aux::vector_tag<35> tag; typedef vector35 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef void_ item35; typedef T34 back; typedef v_iter< type,0 > begin; typedef v_iter< type,35 > end; }; template<> struct push_front_impl< aux::vector_tag<34> > { template< typename Vector, typename T > struct apply { typedef vector35< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef vector34< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 > type; }; }; template<> struct push_back_impl< aux::vector_tag<34> > { template< typename Vector, typename T > struct apply { typedef vector35< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef vector34< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 > type; }; }; namespace aux { template<> struct v_at_impl<35> { template< typename V_ > struct result_ { typedef typename V_::item35 type; }; }; } template<> struct at_impl< aux::vector_tag<35> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<35> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<35> > { template< typename Vector > struct apply : long_<35> { }; }; template<> struct O1_size_impl< aux::vector_tag<35> > : size_impl< aux::vector_tag<35> > { }; template<> struct clear_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35 > struct vector36 { typedef aux::vector_tag<36> tag; typedef vector36 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef void_ item36; typedef T35 back; typedef v_iter< type,0 > begin; typedef v_iter< type,36 > end; }; template<> struct push_front_impl< aux::vector_tag<35> > { template< typename Vector, typename T > struct apply { typedef vector36< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef vector35< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35 > type; }; }; template<> struct push_back_impl< aux::vector_tag<35> > { template< typename Vector, typename T > struct apply { typedef vector36< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef vector35< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34 > type; }; }; namespace aux { template<> struct v_at_impl<36> { template< typename V_ > struct result_ { typedef typename V_::item36 type; }; }; } template<> struct at_impl< aux::vector_tag<36> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<36> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<36> > { template< typename Vector > struct apply : long_<36> { }; }; template<> struct O1_size_impl< aux::vector_tag<36> > : size_impl< aux::vector_tag<36> > { }; template<> struct clear_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36 > struct vector37 { typedef aux::vector_tag<37> tag; typedef vector37 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef void_ item37; typedef T36 back; typedef v_iter< type,0 > begin; typedef v_iter< type,37 > end; }; template<> struct push_front_impl< aux::vector_tag<36> > { template< typename Vector, typename T > struct apply { typedef vector37< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef vector36< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 > type; }; }; template<> struct push_back_impl< aux::vector_tag<36> > { template< typename Vector, typename T > struct apply { typedef vector37< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef vector36< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 > type; }; }; namespace aux { template<> struct v_at_impl<37> { template< typename V_ > struct result_ { typedef typename V_::item37 type; }; }; } template<> struct at_impl< aux::vector_tag<37> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<37> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<37> > { template< typename Vector > struct apply : long_<37> { }; }; template<> struct O1_size_impl< aux::vector_tag<37> > : size_impl< aux::vector_tag<37> > { }; template<> struct clear_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37 > struct vector38 { typedef aux::vector_tag<38> tag; typedef vector38 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef void_ item38; typedef T37 back; typedef v_iter< type,0 > begin; typedef v_iter< type,38 > end; }; template<> struct push_front_impl< aux::vector_tag<37> > { template< typename Vector, typename T > struct apply { typedef vector38< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef vector37< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37 > type; }; }; template<> struct push_back_impl< aux::vector_tag<37> > { template< typename Vector, typename T > struct apply { typedef vector38< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef vector37< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36 > type; }; }; namespace aux { template<> struct v_at_impl<38> { template< typename V_ > struct result_ { typedef typename V_::item38 type; }; }; } template<> struct at_impl< aux::vector_tag<38> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<38> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<38> > { template< typename Vector > struct apply : long_<38> { }; }; template<> struct O1_size_impl< aux::vector_tag<38> > : size_impl< aux::vector_tag<38> > { }; template<> struct clear_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38 > struct vector39 { typedef aux::vector_tag<39> tag; typedef vector39 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef void_ item39; typedef T38 back; typedef v_iter< type,0 > begin; typedef v_iter< type,39 > end; }; template<> struct push_front_impl< aux::vector_tag<38> > { template< typename Vector, typename T > struct apply { typedef vector39< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef vector38< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 > type; }; }; template<> struct push_back_impl< aux::vector_tag<38> > { template< typename Vector, typename T > struct apply { typedef vector39< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef vector38< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 > type; }; }; namespace aux { template<> struct v_at_impl<39> { template< typename V_ > struct result_ { typedef typename V_::item39 type; }; }; } template<> struct at_impl< aux::vector_tag<39> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<39> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<39> > { template< typename Vector > struct apply : long_<39> { }; }; template<> struct O1_size_impl< aux::vector_tag<39> > : size_impl< aux::vector_tag<39> > { }; template<> struct clear_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 > struct vector40 { typedef aux::vector_tag<40> tag; typedef vector40 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef void_ item40; typedef T39 back; typedef v_iter< type,0 > begin; typedef v_iter< type,40 > end; }; template<> struct push_front_impl< aux::vector_tag<39> > { template< typename Vector, typename T > struct apply { typedef vector40< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef vector39< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39 > type; }; }; template<> struct push_back_impl< aux::vector_tag<39> > { template< typename Vector, typename T > struct apply { typedef vector40< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef vector39< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38 > type; }; }; namespace aux { template<> struct v_at_impl<40> { template< typename V_ > struct result_ { typedef typename V_::item40 type; }; }; } template<> struct at_impl< aux::vector_tag<40> > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; template<> struct front_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag<40> > { template< typename Vector > struct apply : false_ { }; }; template<> struct size_impl< aux::vector_tag<40> > { template< typename Vector > struct apply : long_<40> { }; }; template<> struct O1_size_impl< aux::vector_tag<40> > : size_impl< aux::vector_tag<40> > { }; template<> struct clear_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef vector0<> type; }; }; }} ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000000630211344301502031544 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0 > struct vector1_c : vector1< integral_c< T,C0 > > { typedef vector1_c type; typedef T value_type; }; template< typename T , T C0, T C1 > struct vector2_c : vector2< integral_c< T,C0 >, integral_c< T,C1 > > { typedef vector2_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2 > struct vector3_c : vector3< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > > { typedef vector3_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3 > struct vector4_c : vector4< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >, integral_c > { typedef vector4_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4 > struct vector5_c : vector5< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 > > { typedef vector5_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5 > struct vector6_c : vector6< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 > > { typedef vector6_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6 > struct vector7_c : vector7< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c > { typedef vector7_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 > struct vector8_c : vector8< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 > > { typedef vector8_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 > struct vector9_c : vector9< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 > > { typedef vector9_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 > struct vector10_c : vector10< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > > { typedef vector10_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000003670311344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 > struct vector41_c : vector41< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >, integral_c > { typedef vector41_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41 > struct vector42_c : vector42< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 > > { typedef vector42_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42 > struct vector43_c : vector43< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > > { typedef vector43_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43 > struct vector44_c : vector44< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >, integral_c > { typedef vector44_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44 > struct vector45_c : vector45< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 > > { typedef vector45_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45 > struct vector46_c : vector46< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > > { typedef vector46_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46 > struct vector47_c : vector47< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >, integral_c > { typedef vector47_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47 > struct vector48_c : vector48< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > , integral_c< T,C46 >, integral_c< T,C47 > > { typedef vector48_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 > struct vector49_c : vector49< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 > > { typedef vector49_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 > struct vector50_c : vector50< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >, integral_c > { typedef vector50_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000755000175000017500000000000012146213762031554 5ustar debiandebian././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000002244511344301502031552 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector30_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 > struct vector21_c : vector21< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 > > { typedef vector21_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21 > struct vector22_c : vector22< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > > { typedef vector22_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22 > struct vector23_c : vector23< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 >, integral_c > { typedef vector23_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23 > struct vector24_c : vector24< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 > > { typedef vector24_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24 > struct vector25_c : vector25< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > > { typedef vector25_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25 > struct vector26_c : vector26< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 >, integral_c > { typedef vector26_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26 > struct vector27_c : vector27< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 > > { typedef vector27_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27 > struct vector28_c : vector28< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > > { typedef vector28_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 > struct vector29_c : vector29< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 >, integral_c > { typedef vector29_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 > struct vector30_c : vector30< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 > > { typedef vector30_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000001433111344301502031545 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector20_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 > struct vector11_c : vector11< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 >, integral_c > { typedef vector11_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11 > struct vector12_c : vector12< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 > > { typedef vector12_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12 > struct vector13_c : vector13< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > > { typedef vector13_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13 > struct vector14_c : vector14< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 >, integral_c > { typedef vector14_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14 > struct vector15_c : vector15< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 > > { typedef vector15_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15 > struct vector16_c : vector16< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > > { typedef vector16_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16 > struct vector17_c : vector17< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 >, integral_c > { typedef vector17_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17 > struct vector18_c : vector18< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 > > { typedef vector18_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 > struct vector19_c : vector19< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > > { typedef vector19_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 > struct vector20_c : vector20< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 >, integral_c > { typedef vector20_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000010371511344301502031552 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector11 { typedef aux::vector_tag<11> tag; typedef vector11 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef void_ item11; typedef T10 back; typedef v_iter< type,0 > begin; typedef v_iter< type,11 > end; }; template<> struct push_front_impl< aux::vector_tag<10> > { template< typename Vector, typename T > struct apply { typedef vector11< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef vector10< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 > type; }; }; template<> struct push_back_impl< aux::vector_tag<10> > { template< typename Vector, typename T > struct apply { typedef vector11< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<11> > { template< typename Vector > struct apply { typedef vector10< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 > type; }; }; template< typename V > struct v_at< V,11 > { typedef typename V::item11 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector12 { typedef aux::vector_tag<12> tag; typedef vector12 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef void_ item12; typedef T11 back; typedef v_iter< type,0 > begin; typedef v_iter< type,12 > end; }; template<> struct push_front_impl< aux::vector_tag<11> > { template< typename Vector, typename T > struct apply { typedef vector12< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef vector11< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11 > type; }; }; template<> struct push_back_impl< aux::vector_tag<11> > { template< typename Vector, typename T > struct apply { typedef vector12< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<12> > { template< typename Vector > struct apply { typedef vector11< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10 > type; }; }; template< typename V > struct v_at< V,12 > { typedef typename V::item12 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector13 { typedef aux::vector_tag<13> tag; typedef vector13 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef void_ item13; typedef T12 back; typedef v_iter< type,0 > begin; typedef v_iter< type,13 > end; }; template<> struct push_front_impl< aux::vector_tag<12> > { template< typename Vector, typename T > struct apply { typedef vector13< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef vector12< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 > type; }; }; template<> struct push_back_impl< aux::vector_tag<12> > { template< typename Vector, typename T > struct apply { typedef vector13< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<13> > { template< typename Vector > struct apply { typedef vector12< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 > type; }; }; template< typename V > struct v_at< V,13 > { typedef typename V::item13 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector14 { typedef aux::vector_tag<14> tag; typedef vector14 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef void_ item14; typedef T13 back; typedef v_iter< type,0 > begin; typedef v_iter< type,14 > end; }; template<> struct push_front_impl< aux::vector_tag<13> > { template< typename Vector, typename T > struct apply { typedef vector14< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef vector13< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13 > type; }; }; template<> struct push_back_impl< aux::vector_tag<13> > { template< typename Vector, typename T > struct apply { typedef vector14< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<14> > { template< typename Vector > struct apply { typedef vector13< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12 > type; }; }; template< typename V > struct v_at< V,14 > { typedef typename V::item14 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector15 { typedef aux::vector_tag<15> tag; typedef vector15 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef void_ item15; typedef T14 back; typedef v_iter< type,0 > begin; typedef v_iter< type,15 > end; }; template<> struct push_front_impl< aux::vector_tag<14> > { template< typename Vector, typename T > struct apply { typedef vector15< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef vector14< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 > type; }; }; template<> struct push_back_impl< aux::vector_tag<14> > { template< typename Vector, typename T > struct apply { typedef vector15< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<15> > { template< typename Vector > struct apply { typedef vector14< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 > type; }; }; template< typename V > struct v_at< V,15 > { typedef typename V::item15 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector16 { typedef aux::vector_tag<16> tag; typedef vector16 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef void_ item16; typedef T15 back; typedef v_iter< type,0 > begin; typedef v_iter< type,16 > end; }; template<> struct push_front_impl< aux::vector_tag<15> > { template< typename Vector, typename T > struct apply { typedef vector16< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef vector15< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15 > type; }; }; template<> struct push_back_impl< aux::vector_tag<15> > { template< typename Vector, typename T > struct apply { typedef vector16< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<16> > { template< typename Vector > struct apply { typedef vector15< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14 > type; }; }; template< typename V > struct v_at< V,16 > { typedef typename V::item16 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector17 { typedef aux::vector_tag<17> tag; typedef vector17 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef void_ item17; typedef T16 back; typedef v_iter< type,0 > begin; typedef v_iter< type,17 > end; }; template<> struct push_front_impl< aux::vector_tag<16> > { template< typename Vector, typename T > struct apply { typedef vector17< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef vector16< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 > type; }; }; template<> struct push_back_impl< aux::vector_tag<16> > { template< typename Vector, typename T > struct apply { typedef vector17< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<17> > { template< typename Vector > struct apply { typedef vector16< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 > type; }; }; template< typename V > struct v_at< V,17 > { typedef typename V::item17 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector18 { typedef aux::vector_tag<18> tag; typedef vector18 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef void_ item18; typedef T17 back; typedef v_iter< type,0 > begin; typedef v_iter< type,18 > end; }; template<> struct push_front_impl< aux::vector_tag<17> > { template< typename Vector, typename T > struct apply { typedef vector18< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef vector17< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17 > type; }; }; template<> struct push_back_impl< aux::vector_tag<17> > { template< typename Vector, typename T > struct apply { typedef vector18< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<18> > { template< typename Vector > struct apply { typedef vector17< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16 > type; }; }; template< typename V > struct v_at< V,18 > { typedef typename V::item18 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector19 { typedef aux::vector_tag<19> tag; typedef vector19 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef void_ item19; typedef T18 back; typedef v_iter< type,0 > begin; typedef v_iter< type,19 > end; }; template<> struct push_front_impl< aux::vector_tag<18> > { template< typename Vector, typename T > struct apply { typedef vector19< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef vector18< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 > type; }; }; template<> struct push_back_impl< aux::vector_tag<18> > { template< typename Vector, typename T > struct apply { typedef vector19< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<19> > { template< typename Vector > struct apply { typedef vector18< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 > type; }; }; template< typename V > struct v_at< V,19 > { typedef typename V::item19 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector20 { typedef aux::vector_tag<20> tag; typedef vector20 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef void_ item20; typedef T19 back; typedef v_iter< type,0 > begin; typedef v_iter< type,20 > end; }; template<> struct push_front_impl< aux::vector_tag<19> > { template< typename Vector, typename T > struct apply { typedef vector20< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef vector19< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19 > type; }; }; template<> struct push_back_impl< aux::vector_tag<19> > { template< typename Vector, typename T > struct apply { typedef vector20< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<20> > { template< typename Vector > struct apply { typedef vector19< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18 > type; }; }; template< typename V > struct v_at< V,20 > { typedef typename V::item20 type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000014410111344301502031544 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20 > struct vector21 { typedef aux::vector_tag<21> tag; typedef vector21 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef void_ item21; typedef T20 back; typedef v_iter< type,0 > begin; typedef v_iter< type,21 > end; }; template<> struct push_front_impl< aux::vector_tag<20> > { template< typename Vector, typename T > struct apply { typedef vector21< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef vector20< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 > type; }; }; template<> struct push_back_impl< aux::vector_tag<20> > { template< typename Vector, typename T > struct apply { typedef vector21< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<21> > { template< typename Vector > struct apply { typedef vector20< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 > type; }; }; template< typename V > struct v_at< V,21 > { typedef typename V::item21 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21 > struct vector22 { typedef aux::vector_tag<22> tag; typedef vector22 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef void_ item22; typedef T21 back; typedef v_iter< type,0 > begin; typedef v_iter< type,22 > end; }; template<> struct push_front_impl< aux::vector_tag<21> > { template< typename Vector, typename T > struct apply { typedef vector22< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef vector21< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21 > type; }; }; template<> struct push_back_impl< aux::vector_tag<21> > { template< typename Vector, typename T > struct apply { typedef vector22< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<22> > { template< typename Vector > struct apply { typedef vector21< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20 > type; }; }; template< typename V > struct v_at< V,22 > { typedef typename V::item22 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22 > struct vector23 { typedef aux::vector_tag<23> tag; typedef vector23 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef void_ item23; typedef T22 back; typedef v_iter< type,0 > begin; typedef v_iter< type,23 > end; }; template<> struct push_front_impl< aux::vector_tag<22> > { template< typename Vector, typename T > struct apply { typedef vector23< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef vector22< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 > type; }; }; template<> struct push_back_impl< aux::vector_tag<22> > { template< typename Vector, typename T > struct apply { typedef vector23< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<23> > { template< typename Vector > struct apply { typedef vector22< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 > type; }; }; template< typename V > struct v_at< V,23 > { typedef typename V::item23 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23 > struct vector24 { typedef aux::vector_tag<24> tag; typedef vector24 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef void_ item24; typedef T23 back; typedef v_iter< type,0 > begin; typedef v_iter< type,24 > end; }; template<> struct push_front_impl< aux::vector_tag<23> > { template< typename Vector, typename T > struct apply { typedef vector24< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef vector23< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23 > type; }; }; template<> struct push_back_impl< aux::vector_tag<23> > { template< typename Vector, typename T > struct apply { typedef vector24< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<24> > { template< typename Vector > struct apply { typedef vector23< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22 > type; }; }; template< typename V > struct v_at< V,24 > { typedef typename V::item24 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 > struct vector25 { typedef aux::vector_tag<25> tag; typedef vector25 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef void_ item25; typedef T24 back; typedef v_iter< type,0 > begin; typedef v_iter< type,25 > end; }; template<> struct push_front_impl< aux::vector_tag<24> > { template< typename Vector, typename T > struct apply { typedef vector25< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef vector24< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 > type; }; }; template<> struct push_back_impl< aux::vector_tag<24> > { template< typename Vector, typename T > struct apply { typedef vector25< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<25> > { template< typename Vector > struct apply { typedef vector24< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 > type; }; }; template< typename V > struct v_at< V,25 > { typedef typename V::item25 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25 > struct vector26 { typedef aux::vector_tag<26> tag; typedef vector26 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef void_ item26; typedef T25 back; typedef v_iter< type,0 > begin; typedef v_iter< type,26 > end; }; template<> struct push_front_impl< aux::vector_tag<25> > { template< typename Vector, typename T > struct apply { typedef vector26< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef vector25< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25 > type; }; }; template<> struct push_back_impl< aux::vector_tag<25> > { template< typename Vector, typename T > struct apply { typedef vector26< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<26> > { template< typename Vector > struct apply { typedef vector25< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24 > type; }; }; template< typename V > struct v_at< V,26 > { typedef typename V::item26 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26 > struct vector27 { typedef aux::vector_tag<27> tag; typedef vector27 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef void_ item27; typedef T26 back; typedef v_iter< type,0 > begin; typedef v_iter< type,27 > end; }; template<> struct push_front_impl< aux::vector_tag<26> > { template< typename Vector, typename T > struct apply { typedef vector27< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef vector26< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 > type; }; }; template<> struct push_back_impl< aux::vector_tag<26> > { template< typename Vector, typename T > struct apply { typedef vector27< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<27> > { template< typename Vector > struct apply { typedef vector26< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 > type; }; }; template< typename V > struct v_at< V,27 > { typedef typename V::item27 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27 > struct vector28 { typedef aux::vector_tag<28> tag; typedef vector28 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef void_ item28; typedef T27 back; typedef v_iter< type,0 > begin; typedef v_iter< type,28 > end; }; template<> struct push_front_impl< aux::vector_tag<27> > { template< typename Vector, typename T > struct apply { typedef vector28< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef vector27< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27 > type; }; }; template<> struct push_back_impl< aux::vector_tag<27> > { template< typename Vector, typename T > struct apply { typedef vector28< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<28> > { template< typename Vector > struct apply { typedef vector27< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26 > type; }; }; template< typename V > struct v_at< V,28 > { typedef typename V::item28 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28 > struct vector29 { typedef aux::vector_tag<29> tag; typedef vector29 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef void_ item29; typedef T28 back; typedef v_iter< type,0 > begin; typedef v_iter< type,29 > end; }; template<> struct push_front_impl< aux::vector_tag<28> > { template< typename Vector, typename T > struct apply { typedef vector29< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef vector28< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 > type; }; }; template<> struct push_back_impl< aux::vector_tag<28> > { template< typename Vector, typename T > struct apply { typedef vector29< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<29> > { template< typename Vector > struct apply { typedef vector28< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 > type; }; }; template< typename V > struct v_at< V,29 > { typedef typename V::item29 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 > struct vector30 { typedef aux::vector_tag<30> tag; typedef vector30 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef void_ item30; typedef T29 back; typedef v_iter< type,0 > begin; typedef v_iter< type,30 > end; }; template<> struct push_front_impl< aux::vector_tag<29> > { template< typename Vector, typename T > struct apply { typedef vector30< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef vector29< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29 > type; }; }; template<> struct push_back_impl< aux::vector_tag<29> > { template< typename Vector, typename T > struct apply { typedef vector30< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<30> > { template< typename Vector > struct apply { typedef vector29< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28 > type; }; }; template< typename V > struct v_at< V,30 > { typedef typename V::item30 type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000003056011344301502031547 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector40_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 > struct vector31_c : vector31< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > > { typedef vector31_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31 > struct vector32_c : vector32< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 >, integral_c > { typedef vector32_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32 > struct vector33_c : vector33< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 > > { typedef vector33_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33 > struct vector34_c : vector34< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > > { typedef vector34_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34 > struct vector35_c : vector35< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 >, integral_c > { typedef vector35_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35 > struct vector36_c : vector36< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 > > { typedef vector36_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36 > struct vector37_c : vector37< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > > { typedef vector37_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37 > struct vector38_c : vector38< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 >, integral_c > { typedef vector38_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 > struct vector39_c : vector39< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 > > { typedef vector39_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 > struct vector40_c : vector40< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > > { typedef vector40_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000004416511344301502031555 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename V > struct v_at< V,0 > { typedef typename V::item0 type; }; template< typename T0 > struct vector1 { typedef aux::vector_tag<1> tag; typedef vector1 type; typedef T0 item0; typedef void_ item1; typedef T0 back; typedef v_iter< type,0 > begin; typedef v_iter< type,1 > end; }; template<> struct push_front_impl< aux::vector_tag<0> > { template< typename Vector, typename T > struct apply { typedef vector1< T > type; }; }; template<> struct pop_front_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef vector0< > type; }; }; template<> struct push_back_impl< aux::vector_tag<0> > { template< typename Vector, typename T > struct apply { typedef vector1< T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<1> > { template< typename Vector > struct apply { typedef vector0< > type; }; }; template< typename V > struct v_at< V,1 > { typedef typename V::item1 type; }; template< typename T0, typename T1 > struct vector2 { typedef aux::vector_tag<2> tag; typedef vector2 type; typedef T0 item0; typedef T1 item1; typedef void_ item2; typedef T1 back; typedef v_iter< type,0 > begin; typedef v_iter< type,2 > end; }; template<> struct push_front_impl< aux::vector_tag<1> > { template< typename Vector, typename T > struct apply { typedef vector2< T , typename Vector::item0 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef vector1< typename Vector::item1 > type; }; }; template<> struct push_back_impl< aux::vector_tag<1> > { template< typename Vector, typename T > struct apply { typedef vector2< typename Vector::item0 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<2> > { template< typename Vector > struct apply { typedef vector1< typename Vector::item0 > type; }; }; template< typename V > struct v_at< V,2 > { typedef typename V::item2 type; }; template< typename T0, typename T1, typename T2 > struct vector3 { typedef aux::vector_tag<3> tag; typedef vector3 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef void_ item3; typedef T2 back; typedef v_iter< type,0 > begin; typedef v_iter< type,3 > end; }; template<> struct push_front_impl< aux::vector_tag<2> > { template< typename Vector, typename T > struct apply { typedef vector3< T , typename Vector::item0, typename Vector::item1 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef vector2< typename Vector::item1, typename Vector::item2 > type; }; }; template<> struct push_back_impl< aux::vector_tag<2> > { template< typename Vector, typename T > struct apply { typedef vector3< typename Vector::item0, typename Vector::item1 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<3> > { template< typename Vector > struct apply { typedef vector2< typename Vector::item0, typename Vector::item1 > type; }; }; template< typename V > struct v_at< V,3 > { typedef typename V::item3 type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector4 { typedef aux::vector_tag<4> tag; typedef vector4 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef void_ item4; typedef T3 back; typedef v_iter< type,0 > begin; typedef v_iter< type,4 > end; }; template<> struct push_front_impl< aux::vector_tag<3> > { template< typename Vector, typename T > struct apply { typedef vector4< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef vector3< typename Vector::item1, typename Vector::item2 , typename Vector::item3 > type; }; }; template<> struct push_back_impl< aux::vector_tag<3> > { template< typename Vector, typename T > struct apply { typedef vector4< typename Vector::item0, typename Vector::item1 , typename Vector::item2 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<4> > { template< typename Vector > struct apply { typedef vector3< typename Vector::item0, typename Vector::item1 , typename Vector::item2 > type; }; }; template< typename V > struct v_at< V,4 > { typedef typename V::item4 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector5 { typedef aux::vector_tag<5> tag; typedef vector5 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef void_ item5; typedef T4 back; typedef v_iter< type,0 > begin; typedef v_iter< type,5 > end; }; template<> struct push_front_impl< aux::vector_tag<4> > { template< typename Vector, typename T > struct apply { typedef vector5< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef vector4< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 > type; }; }; template<> struct push_back_impl< aux::vector_tag<4> > { template< typename Vector, typename T > struct apply { typedef vector5< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<5> > { template< typename Vector > struct apply { typedef vector4< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 > type; }; }; template< typename V > struct v_at< V,5 > { typedef typename V::item5 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector6 { typedef aux::vector_tag<6> tag; typedef vector6 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef void_ item6; typedef T5 back; typedef v_iter< type,0 > begin; typedef v_iter< type,6 > end; }; template<> struct push_front_impl< aux::vector_tag<5> > { template< typename Vector, typename T > struct apply { typedef vector6< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef vector5< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5 > type; }; }; template<> struct push_back_impl< aux::vector_tag<5> > { template< typename Vector, typename T > struct apply { typedef vector6< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<6> > { template< typename Vector > struct apply { typedef vector5< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4 > type; }; }; template< typename V > struct v_at< V,6 > { typedef typename V::item6 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector7 { typedef aux::vector_tag<7> tag; typedef vector7 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef void_ item7; typedef T6 back; typedef v_iter< type,0 > begin; typedef v_iter< type,7 > end; }; template<> struct push_front_impl< aux::vector_tag<6> > { template< typename Vector, typename T > struct apply { typedef vector7< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef vector6< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 > type; }; }; template<> struct push_back_impl< aux::vector_tag<6> > { template< typename Vector, typename T > struct apply { typedef vector7< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<7> > { template< typename Vector > struct apply { typedef vector6< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 > type; }; }; template< typename V > struct v_at< V,7 > { typedef typename V::item7 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector8 { typedef aux::vector_tag<8> tag; typedef vector8 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef void_ item8; typedef T7 back; typedef v_iter< type,0 > begin; typedef v_iter< type,8 > end; }; template<> struct push_front_impl< aux::vector_tag<7> > { template< typename Vector, typename T > struct apply { typedef vector8< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef vector7< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7 > type; }; }; template<> struct push_back_impl< aux::vector_tag<7> > { template< typename Vector, typename T > struct apply { typedef vector8< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<8> > { template< typename Vector > struct apply { typedef vector7< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6 > type; }; }; template< typename V > struct v_at< V,8 > { typedef typename V::item8 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector9 { typedef aux::vector_tag<9> tag; typedef vector9 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef void_ item9; typedef T8 back; typedef v_iter< type,0 > begin; typedef v_iter< type,9 > end; }; template<> struct push_front_impl< aux::vector_tag<8> > { template< typename Vector, typename T > struct apply { typedef vector9< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef vector8< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 > type; }; }; template<> struct push_back_impl< aux::vector_tag<8> > { template< typename Vector, typename T > struct apply { typedef vector9< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<9> > { template< typename Vector > struct apply { typedef vector8< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 > type; }; }; template< typename V > struct v_at< V,9 > { typedef typename V::item9 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector10 { typedef aux::vector_tag<10> tag; typedef vector10 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef void_ item10; typedef T9 back; typedef v_iter< type,0 > begin; typedef v_iter< type,10 > end; }; template<> struct push_front_impl< aux::vector_tag<9> > { template< typename Vector, typename T > struct apply { typedef vector10< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef vector9< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9 > type; }; }; template<> struct push_back_impl< aux::vector_tag<9> > { template< typename Vector, typename T > struct apply { typedef vector10< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<10> > { template< typename Vector > struct apply { typedef vector9< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8 > type; }; }; template< typename V > struct v_at< V,10 > { typedef typename V::item10 type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000024445111344301502031555 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40 > struct vector41 { typedef aux::vector_tag<41> tag; typedef vector41 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef void_ item41; typedef T40 back; typedef v_iter< type,0 > begin; typedef v_iter< type,41 > end; }; template<> struct push_front_impl< aux::vector_tag<40> > { template< typename Vector, typename T > struct apply { typedef vector41< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef vector40< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 > type; }; }; template<> struct push_back_impl< aux::vector_tag<40> > { template< typename Vector, typename T > struct apply { typedef vector41< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<41> > { template< typename Vector > struct apply { typedef vector40< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 > type; }; }; template< typename V > struct v_at< V,41 > { typedef typename V::item41 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41 > struct vector42 { typedef aux::vector_tag<42> tag; typedef vector42 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef void_ item42; typedef T41 back; typedef v_iter< type,0 > begin; typedef v_iter< type,42 > end; }; template<> struct push_front_impl< aux::vector_tag<41> > { template< typename Vector, typename T > struct apply { typedef vector42< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef vector41< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41 > type; }; }; template<> struct push_back_impl< aux::vector_tag<41> > { template< typename Vector, typename T > struct apply { typedef vector42< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<42> > { template< typename Vector > struct apply { typedef vector41< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40 > type; }; }; template< typename V > struct v_at< V,42 > { typedef typename V::item42 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42 > struct vector43 { typedef aux::vector_tag<43> tag; typedef vector43 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef void_ item43; typedef T42 back; typedef v_iter< type,0 > begin; typedef v_iter< type,43 > end; }; template<> struct push_front_impl< aux::vector_tag<42> > { template< typename Vector, typename T > struct apply { typedef vector43< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef vector42< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 > type; }; }; template<> struct push_back_impl< aux::vector_tag<42> > { template< typename Vector, typename T > struct apply { typedef vector43< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<43> > { template< typename Vector > struct apply { typedef vector42< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 > type; }; }; template< typename V > struct v_at< V,43 > { typedef typename V::item43 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43 > struct vector44 { typedef aux::vector_tag<44> tag; typedef vector44 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef void_ item44; typedef T43 back; typedef v_iter< type,0 > begin; typedef v_iter< type,44 > end; }; template<> struct push_front_impl< aux::vector_tag<43> > { template< typename Vector, typename T > struct apply { typedef vector44< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef vector43< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43 > type; }; }; template<> struct push_back_impl< aux::vector_tag<43> > { template< typename Vector, typename T > struct apply { typedef vector44< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<44> > { template< typename Vector > struct apply { typedef vector43< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42 > type; }; }; template< typename V > struct v_at< V,44 > { typedef typename V::item44 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 > struct vector45 { typedef aux::vector_tag<45> tag; typedef vector45 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef void_ item45; typedef T44 back; typedef v_iter< type,0 > begin; typedef v_iter< type,45 > end; }; template<> struct push_front_impl< aux::vector_tag<44> > { template< typename Vector, typename T > struct apply { typedef vector45< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef vector44< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 > type; }; }; template<> struct push_back_impl< aux::vector_tag<44> > { template< typename Vector, typename T > struct apply { typedef vector45< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<45> > { template< typename Vector > struct apply { typedef vector44< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 > type; }; }; template< typename V > struct v_at< V,45 > { typedef typename V::item45 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45 > struct vector46 { typedef aux::vector_tag<46> tag; typedef vector46 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef void_ item46; typedef T45 back; typedef v_iter< type,0 > begin; typedef v_iter< type,46 > end; }; template<> struct push_front_impl< aux::vector_tag<45> > { template< typename Vector, typename T > struct apply { typedef vector46< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef vector45< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45 > type; }; }; template<> struct push_back_impl< aux::vector_tag<45> > { template< typename Vector, typename T > struct apply { typedef vector46< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<46> > { template< typename Vector > struct apply { typedef vector45< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44 > type; }; }; template< typename V > struct v_at< V,46 > { typedef typename V::item46 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46 > struct vector47 { typedef aux::vector_tag<47> tag; typedef vector47 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef void_ item47; typedef T46 back; typedef v_iter< type,0 > begin; typedef v_iter< type,47 > end; }; template<> struct push_front_impl< aux::vector_tag<46> > { template< typename Vector, typename T > struct apply { typedef vector47< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef vector46< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 > type; }; }; template<> struct push_back_impl< aux::vector_tag<46> > { template< typename Vector, typename T > struct apply { typedef vector47< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<47> > { template< typename Vector > struct apply { typedef vector46< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 > type; }; }; template< typename V > struct v_at< V,47 > { typedef typename V::item47 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47 > struct vector48 { typedef aux::vector_tag<48> tag; typedef vector48 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef T47 item47; typedef void_ item48; typedef T47 back; typedef v_iter< type,0 > begin; typedef v_iter< type,48 > end; }; template<> struct push_front_impl< aux::vector_tag<47> > { template< typename Vector, typename T > struct apply { typedef vector48< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef vector47< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 , typename Vector::item47 > type; }; }; template<> struct push_back_impl< aux::vector_tag<47> > { template< typename Vector, typename T > struct apply { typedef vector48< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<48> > { template< typename Vector > struct apply { typedef vector47< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46 > type; }; }; template< typename V > struct v_at< V,48 > { typedef typename V::item48 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48 > struct vector49 { typedef aux::vector_tag<49> tag; typedef vector49 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef T47 item47; typedef T48 item48; typedef void_ item49; typedef T48 back; typedef v_iter< type,0 > begin; typedef v_iter< type,49 > end; }; template<> struct push_front_impl< aux::vector_tag<48> > { template< typename Vector, typename T > struct apply { typedef vector49< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef vector48< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 , typename Vector::item47, typename Vector::item48 > type; }; }; template<> struct push_back_impl< aux::vector_tag<48> > { template< typename Vector, typename T > struct apply { typedef vector49< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<49> > { template< typename Vector > struct apply { typedef vector48< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 > type; }; }; template< typename V > struct v_at< V,49 > { typedef typename V::item49 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48, typename T49 > struct vector50 { typedef aux::vector_tag<50> tag; typedef vector50 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef T40 item40; typedef T41 item41; typedef T42 item42; typedef T43 item43; typedef T44 item44; typedef T45 item45; typedef T46 item46; typedef T47 item47; typedef T48 item48; typedef T49 item49; typedef void_ item50; typedef T49 back; typedef v_iter< type,0 > begin; typedef v_iter< type,50 > end; }; template<> struct push_front_impl< aux::vector_tag<49> > { template< typename Vector, typename T > struct apply { typedef vector50< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , typename Vector::item48 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef vector49< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39, typename Vector::item40 , typename Vector::item41, typename Vector::item42 , typename Vector::item43, typename Vector::item44 , typename Vector::item45, typename Vector::item46 , typename Vector::item47, typename Vector::item48 , typename Vector::item49 > type; }; }; template<> struct push_back_impl< aux::vector_tag<49> > { template< typename Vector, typename T > struct apply { typedef vector50< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , typename Vector::item48 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<50> > { template< typename Vector > struct apply { typedef vector49< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38, typename Vector::item39 , typename Vector::item40, typename Vector::item41 , typename Vector::item42, typename Vector::item43 , typename Vector::item44, typename Vector::item45 , typename Vector::item46, typename Vector::item47 , typename Vector::item48 > type; }; }; template< typename V > struct v_at< V,50 > { typedef typename V::item50 type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000020426511344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30 > struct vector31 { typedef aux::vector_tag<31> tag; typedef vector31 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef void_ item31; typedef T30 back; typedef v_iter< type,0 > begin; typedef v_iter< type,31 > end; }; template<> struct push_front_impl< aux::vector_tag<30> > { template< typename Vector, typename T > struct apply { typedef vector31< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef vector30< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 > type; }; }; template<> struct push_back_impl< aux::vector_tag<30> > { template< typename Vector, typename T > struct apply { typedef vector31< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<31> > { template< typename Vector > struct apply { typedef vector30< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 > type; }; }; template< typename V > struct v_at< V,31 > { typedef typename V::item31 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31 > struct vector32 { typedef aux::vector_tag<32> tag; typedef vector32 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef void_ item32; typedef T31 back; typedef v_iter< type,0 > begin; typedef v_iter< type,32 > end; }; template<> struct push_front_impl< aux::vector_tag<31> > { template< typename Vector, typename T > struct apply { typedef vector32< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef vector31< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31 > type; }; }; template<> struct push_back_impl< aux::vector_tag<31> > { template< typename Vector, typename T > struct apply { typedef vector32< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<32> > { template< typename Vector > struct apply { typedef vector31< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30 > type; }; }; template< typename V > struct v_at< V,32 > { typedef typename V::item32 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32 > struct vector33 { typedef aux::vector_tag<33> tag; typedef vector33 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef void_ item33; typedef T32 back; typedef v_iter< type,0 > begin; typedef v_iter< type,33 > end; }; template<> struct push_front_impl< aux::vector_tag<32> > { template< typename Vector, typename T > struct apply { typedef vector33< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef vector32< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 > type; }; }; template<> struct push_back_impl< aux::vector_tag<32> > { template< typename Vector, typename T > struct apply { typedef vector33< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<33> > { template< typename Vector > struct apply { typedef vector32< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 > type; }; }; template< typename V > struct v_at< V,33 > { typedef typename V::item33 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33 > struct vector34 { typedef aux::vector_tag<34> tag; typedef vector34 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef void_ item34; typedef T33 back; typedef v_iter< type,0 > begin; typedef v_iter< type,34 > end; }; template<> struct push_front_impl< aux::vector_tag<33> > { template< typename Vector, typename T > struct apply { typedef vector34< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef vector33< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33 > type; }; }; template<> struct push_back_impl< aux::vector_tag<33> > { template< typename Vector, typename T > struct apply { typedef vector34< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<34> > { template< typename Vector > struct apply { typedef vector33< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32 > type; }; }; template< typename V > struct v_at< V,34 > { typedef typename V::item34 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 > struct vector35 { typedef aux::vector_tag<35> tag; typedef vector35 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef void_ item35; typedef T34 back; typedef v_iter< type,0 > begin; typedef v_iter< type,35 > end; }; template<> struct push_front_impl< aux::vector_tag<34> > { template< typename Vector, typename T > struct apply { typedef vector35< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef vector34< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 > type; }; }; template<> struct push_back_impl< aux::vector_tag<34> > { template< typename Vector, typename T > struct apply { typedef vector35< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<35> > { template< typename Vector > struct apply { typedef vector34< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 > type; }; }; template< typename V > struct v_at< V,35 > { typedef typename V::item35 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35 > struct vector36 { typedef aux::vector_tag<36> tag; typedef vector36 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef void_ item36; typedef T35 back; typedef v_iter< type,0 > begin; typedef v_iter< type,36 > end; }; template<> struct push_front_impl< aux::vector_tag<35> > { template< typename Vector, typename T > struct apply { typedef vector36< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef vector35< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35 > type; }; }; template<> struct push_back_impl< aux::vector_tag<35> > { template< typename Vector, typename T > struct apply { typedef vector36< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<36> > { template< typename Vector > struct apply { typedef vector35< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34 > type; }; }; template< typename V > struct v_at< V,36 > { typedef typename V::item36 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36 > struct vector37 { typedef aux::vector_tag<37> tag; typedef vector37 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef void_ item37; typedef T36 back; typedef v_iter< type,0 > begin; typedef v_iter< type,37 > end; }; template<> struct push_front_impl< aux::vector_tag<36> > { template< typename Vector, typename T > struct apply { typedef vector37< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef vector36< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 > type; }; }; template<> struct push_back_impl< aux::vector_tag<36> > { template< typename Vector, typename T > struct apply { typedef vector37< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<37> > { template< typename Vector > struct apply { typedef vector36< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 > type; }; }; template< typename V > struct v_at< V,37 > { typedef typename V::item37 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37 > struct vector38 { typedef aux::vector_tag<38> tag; typedef vector38 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef void_ item38; typedef T37 back; typedef v_iter< type,0 > begin; typedef v_iter< type,38 > end; }; template<> struct push_front_impl< aux::vector_tag<37> > { template< typename Vector, typename T > struct apply { typedef vector38< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef vector37< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37 > type; }; }; template<> struct push_back_impl< aux::vector_tag<37> > { template< typename Vector, typename T > struct apply { typedef vector38< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<38> > { template< typename Vector > struct apply { typedef vector37< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36 > type; }; }; template< typename V > struct v_at< V,38 > { typedef typename V::item38 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38 > struct vector39 { typedef aux::vector_tag<39> tag; typedef vector39 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef void_ item39; typedef T38 back; typedef v_iter< type,0 > begin; typedef v_iter< type,39 > end; }; template<> struct push_front_impl< aux::vector_tag<38> > { template< typename Vector, typename T > struct apply { typedef vector39< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef vector38< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 > type; }; }; template<> struct push_back_impl< aux::vector_tag<38> > { template< typename Vector, typename T > struct apply { typedef vector39< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<39> > { template< typename Vector > struct apply { typedef vector38< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 > type; }; }; template< typename V > struct v_at< V,39 > { typedef typename V::item39 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 > struct vector40 { typedef aux::vector_tag<40> tag; typedef vector40 type; typedef T0 item0; typedef T1 item1; typedef T2 item2; typedef T3 item3; typedef T4 item4; typedef T5 item5; typedef T6 item6; typedef T7 item7; typedef T8 item8; typedef T9 item9; typedef T10 item10; typedef T11 item11; typedef T12 item12; typedef T13 item13; typedef T14 item14; typedef T15 item15; typedef T16 item16; typedef T17 item17; typedef T18 item18; typedef T19 item19; typedef T20 item20; typedef T21 item21; typedef T22 item22; typedef T23 item23; typedef T24 item24; typedef T25 item25; typedef T26 item26; typedef T27 item27; typedef T28 item28; typedef T29 item29; typedef T30 item30; typedef T31 item31; typedef T32 item32; typedef T33 item33; typedef T34 item34; typedef T35 item35; typedef T36 item36; typedef T37 item37; typedef T38 item38; typedef T39 item39; typedef void_ item40; typedef T39 back; typedef v_iter< type,0 > begin; typedef v_iter< type,40 > end; }; template<> struct push_front_impl< aux::vector_tag<39> > { template< typename Vector, typename T > struct apply { typedef vector40< T , typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38 > type; }; }; template<> struct pop_front_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef vector39< typename Vector::item1, typename Vector::item2 , typename Vector::item3, typename Vector::item4 , typename Vector::item5, typename Vector::item6 , typename Vector::item7, typename Vector::item8 , typename Vector::item9, typename Vector::item10 , typename Vector::item11, typename Vector::item12 , typename Vector::item13, typename Vector::item14 , typename Vector::item15, typename Vector::item16 , typename Vector::item17, typename Vector::item18 , typename Vector::item19, typename Vector::item20 , typename Vector::item21, typename Vector::item22 , typename Vector::item23, typename Vector::item24 , typename Vector::item25, typename Vector::item26 , typename Vector::item27, typename Vector::item28 , typename Vector::item29, typename Vector::item30 , typename Vector::item31, typename Vector::item32 , typename Vector::item33, typename Vector::item34 , typename Vector::item35, typename Vector::item36 , typename Vector::item37, typename Vector::item38 , typename Vector::item39 > type; }; }; template<> struct push_back_impl< aux::vector_tag<39> > { template< typename Vector, typename T > struct apply { typedef vector40< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38 , T > type; }; }; template<> struct pop_back_impl< aux::vector_tag<40> > { template< typename Vector > struct apply { typedef vector39< typename Vector::item0, typename Vector::item1 , typename Vector::item2, typename Vector::item3 , typename Vector::item4, typename Vector::item5 , typename Vector::item6, typename Vector::item7 , typename Vector::item8, typename Vector::item9 , typename Vector::item10, typename Vector::item11 , typename Vector::item12, typename Vector::item13 , typename Vector::item14, typename Vector::item15 , typename Vector::item16, typename Vector::item17 , typename Vector::item18, typename Vector::item19 , typename Vector::item20, typename Vector::item21 , typename Vector::item22, typename Vector::item23 , typename Vector::item24, typename Vector::item25 , typename Vector::item26, typename Vector::item27 , typename Vector::item28, typename Vector::item29 , typename Vector::item30, typename Vector::item31 , typename Vector::item32, typename Vector::item33 , typename Vector::item34, typename Vector::item35 , typename Vector::item36, typename Vector::item37 , typename Vector::item38 > type; }; }; template< typename V > struct v_at< V,40 > { typedef typename V::item40 type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000000630211344301502031544 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector10_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0 > struct vector1_c : vector1< integral_c< T,C0 > > { typedef vector1_c type; typedef T value_type; }; template< typename T , T C0, T C1 > struct vector2_c : vector2< integral_c< T,C0 >, integral_c< T,C1 > > { typedef vector2_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2 > struct vector3_c : vector3< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > > { typedef vector3_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3 > struct vector4_c : vector4< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 >, integral_c > { typedef vector4_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4 > struct vector5_c : vector5< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 > > { typedef vector5_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5 > struct vector6_c : vector6< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 > > { typedef vector6_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6 > struct vector7_c : vector7< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c > { typedef vector7_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 > struct vector8_c : vector8< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 > > { typedef vector8_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 > struct vector9_c : vector9< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 > > { typedef vector9_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 > struct vector10_c : vector10< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > > { typedef vector10_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/prepr0000644000175000017500000003670311344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector/vector50_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 > struct vector41_c : vector41< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 >, integral_c > { typedef vector41_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41 > struct vector42_c : vector42< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 > > { typedef vector42_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42 > struct vector43_c : vector43< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > > { typedef vector43_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43 > struct vector44_c : vector44< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 >, integral_c > { typedef vector44_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44 > struct vector45_c : vector45< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 > > { typedef vector45_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45 > struct vector46_c : vector46< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > > { typedef vector46_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46 > struct vector47_c : vector47< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 >, integral_c > { typedef vector47_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47 > struct vector48_c : vector48< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > , integral_c< T,C46 >, integral_c< T,C47 > > { typedef vector48_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 > struct vector49_c : vector49< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 > > { typedef vector49_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 > struct vector50_c : vector50< integral_c< T,C0 >, integral_c< T,C1 >, integral_c< T,C2 > , integral_c< T,C3 >, integral_c< T,C4 >, integral_c< T,C5 >, integral_c< T,C6 > , integral_c< T,C7 >, integral_c< T,C8 >, integral_c< T,C9 > , integral_c< T,C10 >, integral_c< T,C11 >, integral_c< T,C12 > , integral_c< T,C13 >, integral_c< T,C14 >, integral_c< T,C15 > , integral_c< T,C16 >, integral_c< T,C17 >, integral_c< T,C18 > , integral_c< T,C19 >, integral_c< T,C20 >, integral_c< T,C21 > , integral_c< T,C22 >, integral_c< T,C23 >, integral_c< T,C24 > , integral_c< T,C25 >, integral_c< T,C26 >, integral_c< T,C27 > , integral_c< T,C28 >, integral_c< T,C29 >, integral_c< T,C30 > , integral_c< T,C31 >, integral_c< T,C32 >, integral_c< T,C33 > , integral_c< T,C34 >, integral_c< T,C35 >, integral_c< T,C36 > , integral_c< T,C37 >, integral_c< T,C38 >, integral_c< T,C39 > , integral_c< T,C40 >, integral_c< T,C41 >, integral_c< T,C42 > , integral_c< T,C43 >, integral_c< T,C44 >, integral_c< T,C45 > , integral_c< T,C46 >, integral_c< T,C47 >, integral_c< T,C48 >, integral_c > { typedef vector50_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/empty0000644000175000017500000000301011344301502031543 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/empty.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template<> struct empty_impl< aux::vector_tag > { template< typename Vector > struct apply : is_same< typename Vector::lower_bound_ , typename Vector::upper_bound_ > { }; }; #else template<> struct empty_impl< aux::vector_tag<0> > { template< typename Vector > struct apply : true_ { }; }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< long N > struct empty_impl< aux::vector_tag > { template< typename Vector > struct apply : false_ { }; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_EMPTY_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/size.0000644000175000017500000000226511344301502031450 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/size.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template<> struct size_impl< aux::vector_tag > : O1_size_impl< aux::vector_tag > { }; #else #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< long N > struct size_impl< aux::vector_tag > : O1_size_impl< aux::vector_tag > { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_SIZE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/back.0000644000175000017500000000262211344301502031373 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/back.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template<> struct back_impl< aux::vector_tag > { template< typename Vector > struct apply : v_at< Vector , prior::type::value > { }; }; #else #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< long n_ > struct back_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_BACK_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/tag.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/tag.h0000644000175000017500000000152511344301502031417 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/tag.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { struct v_iter_tag; #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) struct vector_tag; #else template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct vector_tag; #endif }}} #endif // BOOST_MPL_VECTOR_AUX_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/numbered.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/numbe0000644000175000017500000001144111344301502031522 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/numbered.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #define i_ BOOST_PP_FRAME_ITERATION(1) #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # define AUX778076_VECTOR_TAIL(vector, i_, T) \ BOOST_PP_CAT(vector,i_)< \ BOOST_PP_ENUM_PARAMS(i_, T) \ > \ /**/ #if i_ > 0 template< BOOST_PP_ENUM_PARAMS(i_, typename T) > struct BOOST_PP_CAT(vector,i_) : v_item< BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) , AUX778076_VECTOR_TAIL(vector,BOOST_PP_DEC(i_),T) > { typedef BOOST_PP_CAT(vector,i_) type; }; #endif # undef AUX778076_VECTOR_TAIL #else // "brute force" implementation # if i_ > 0 template< BOOST_PP_ENUM_PARAMS(i_, typename T) > struct BOOST_PP_CAT(vector,i_) { typedef aux::vector_tag tag; typedef BOOST_PP_CAT(vector,i_) type; # define AUX778076_VECTOR_ITEM(unused, i_, unused2) \ typedef BOOST_PP_CAT(T,i_) BOOST_PP_CAT(item,i_); \ /**/ BOOST_PP_REPEAT(i_, AUX778076_VECTOR_ITEM, unused) # undef AUX778076_VECTOR_ITEM typedef void_ BOOST_PP_CAT(item,i_); typedef BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) back; // Borland forces us to use 'type' here (instead of the class name) typedef v_iter begin; typedef v_iter end; }; template<> struct push_front_impl< aux::vector_tag > { template< typename Vector, typename T > struct apply { typedef BOOST_PP_CAT(vector,i_)< T BOOST_PP_COMMA_IF(BOOST_PP_DEC(i_)) BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item) > type; }; }; template<> struct pop_front_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef BOOST_PP_CAT(vector,BOOST_PP_DEC(i_))< BOOST_PP_ENUM_SHIFTED_PARAMS(i_, typename Vector::item) > type; }; }; template<> struct push_back_impl< aux::vector_tag > { template< typename Vector, typename T > struct apply { typedef BOOST_PP_CAT(vector,i_)< BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item) BOOST_PP_COMMA_IF(BOOST_PP_DEC(i_)) T > type; }; }; template<> struct pop_back_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef BOOST_PP_CAT(vector,BOOST_PP_DEC(i_))< BOOST_PP_ENUM_PARAMS(BOOST_PP_DEC(i_), typename Vector::item) > type; }; }; # endif // i_ > 0 # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) template< typename V > struct v_at { typedef typename V::BOOST_PP_CAT(item,i_) type; }; # else namespace aux { template<> struct v_at_impl { template< typename V_ > struct result_ { typedef typename V_::BOOST_PP_CAT(item,i_) type; }; }; } template<> struct at_impl< aux::vector_tag > { template< typename V_, typename N > struct apply { typedef typename aux::v_at_impl ::template result_::type type; }; }; #if i_ > 0 template<> struct front_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; template<> struct back_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef typename Vector::back type; }; }; template<> struct empty_impl< aux::vector_tag > { template< typename Vector > struct apply : false_ { }; }; #endif template<> struct size_impl< aux::vector_tag > { template< typename Vector > struct apply : long_ { }; }; template<> struct O1_size_impl< aux::vector_tag > : size_impl< aux::vector_tag > { }; template<> struct clear_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef vector0<> type; }; }; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/O1_size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/O1_si0000644000175000017500000000245611344301502031374 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/O1_size.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template<> struct O1_size_impl< aux::vector_tag > { template< typename Vector > struct apply : Vector::size { }; }; #else #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< long N > struct O1_size_impl< aux::vector_tag > { template< typename Vector > struct apply : mpl::long_ { }; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_O1_SIZE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/vector0.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/vecto0000644000175000017500000000261311344301502031535 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/vector0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Dummy = na > struct vector0; template<> struct vector0 { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) typedef aux::vector_tag tag; typedef vector0 type; typedef long_<32768> lower_bound_; typedef lower_bound_ upper_bound_; typedef long_<0> size; static aux::type_wrapper item_(...); #else typedef aux::vector_tag<0> tag; typedef vector0 type; typedef void_ item0; typedef v_iter,0> begin; typedef v_iter,0> end; #endif }; }} #endif // BOOST_MPL_VECTOR_AUX_VECTOR0_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/at.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/at.hp0000644000175000017500000000467311344301502031437 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/at.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template< typename Vector, long n_ > struct v_at_impl { typedef long_< (Vector::lower_bound_::value + n_) > index_; typedef __typeof__( Vector::item_(index_()) ) type; }; template< typename Vector, long n_ > struct v_at : aux::wrapped_type< typename v_at_impl::type > { }; template<> struct at_impl< aux::vector_tag > { template< typename Vector, typename N > struct apply : v_at< Vector , BOOST_MPL_AUX_VALUE_WKND(N)::value > { }; }; #else # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) template< typename Vector, BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at; template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct at_impl< aux::vector_tag > { template< typename Vector, typename N > struct apply #if !defined(__BORLANDC__) : v_at< Vector , BOOST_MPL_AUX_VALUE_WKND(N)::value > { #else { typedef typename v_at< Vector , BOOST_MPL_AUX_VALUE_WKND(N)::value >::type type; #endif }; }; # else namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at_impl { template< typename V > struct result_; }; } // namespace aux template< typename T, BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct v_at : aux::v_at_impl::template result_ { }; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_AT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/begin_end.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/begin0000644000175000017500000000226611344301502031505 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/begin_end.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # include # include # include namespace boost { namespace mpl { template<> struct begin_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef v_iter type; }; }; template<> struct end_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef v_iter type; }; }; }} #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #endif // BOOST_MPL_VECTOR_AUX_BEGIN_END_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/front0000644000175000017500000000254011344301502031544 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template<> struct front_impl< aux::vector_tag > { template< typename Vector > struct apply : v_at { }; }; #else #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< BOOST_MPL_AUX_NTTP_DECL(long, n_) > struct front_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef typename Vector::item0 type; }; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/numbered_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/numbe0000644000175000017500000000401111344301502031515 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/numbered_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #define i_ BOOST_PP_FRAME_ITERATION(1) #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # define AUX778076_VECTOR_TAIL(vector, i_, C) \ BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) \ /**/ #if i_ > 0 template< typename T , BOOST_PP_ENUM_PARAMS(i_, T C) > struct BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) : v_item< integral_c , AUX778076_VECTOR_TAIL(vector,BOOST_PP_DEC(i_),C) > { typedef BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) type; typedef T value_type; }; #endif # undef AUX778076_VECTOR_TAIL #else // "brute force" implementation # define AUX778076_VECTOR_C_PARAM_FUNC(unused, i_, param) \ BOOST_PP_COMMA_IF(i_) \ integral_c \ /**/ template< typename T , BOOST_PP_ENUM_PARAMS(i_, T C) > struct BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) : BOOST_PP_CAT(vector,i_)< BOOST_PP_REPEAT(i_,AUX778076_VECTOR_C_PARAM_FUNC,C) > { typedef BOOST_PP_CAT(BOOST_PP_CAT(vector,i_),_c) type; typedef T value_type; }; # undef AUX778076_VECTOR_C_PARAM_FUNC #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/clear.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/clear0000644000175000017500000000244111344301502031502 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/clear.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template<> struct clear_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef vector0<> type; }; }; #else #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< long N > struct clear_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef vector0<> type; }; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_VECTOR_AUX_CLEAR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/pop_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/pop_f0000644000175000017500000000201411344301502031513 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED #define BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/aux_/pop_front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # include # include namespace boost { namespace mpl { template<> struct pop_front_impl< aux::vector_tag > { template< typename Vector > struct apply { typedef v_mask type; }; }; }} #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #endif // BOOST_MPL_VECTOR_AUX_POP_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector20_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector20_c0000644000175000017500000000246611344301502031435 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector20_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector20_c.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR20_C_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector20.h0000644000175000017500000000237411344301502031357 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector20.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector20.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR20_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector30.h0000644000175000017500000000237411344301502031360 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR30_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR30_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector30.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector30.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR30_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector40_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector40_c0000644000175000017500000000246611344301502031437 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR40_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR40_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector40_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector40_c.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR40_C_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector10.h0000644000175000017500000000237211344301502031354 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector10.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector10.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR10_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector0_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector0_c.0000644000175000017500000000142011344301502031416 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR0_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR0_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector0_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename T > struct vector0_c : vector0<> { typedef vector0_c type; typedef T value_type; }; }} #endif // BOOST_MPL_VECTOR_VECTOR0_C_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector50.h0000644000175000017500000000237411344301502031362 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR50_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR50_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector50.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector50.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR50_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector40.h0000644000175000017500000000237411344301502031361 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR40_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR40_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector40.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector40.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR40_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector0.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector0.hp0000644000175000017500000000234411344301502031452 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // BOOST_MPL_VECTOR_VECTOR0_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector10_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector10_c0000644000175000017500000000246411344301502031432 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR10_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR10_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector10_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector10_c.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR10_C_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector50_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector50_c0000644000175000017500000000246311344301502031435 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_VECTOR50_C_HPP_INCLUDED #define BOOST_MPL_VECTOR_VECTOR50_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector/vector50_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector50_c.hpp # include #else # include # include # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_VECTOR50_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/always.hpp0000644000175000017500000000164711344301501030252 0ustar debiandebian #ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED #define BOOST_MPL_ALWAYS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/always.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template< typename Value > struct always { template< typename T BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(1, typename T, na) > struct apply { typedef Value type; }; }; BOOST_MPL_AUX_ARITY_SPEC(1, always) }} #endif // BOOST_MPL_ALWAYS_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/value_type_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/value_type_fwd.hp0000644000175000017500000000134711344301501031604 0ustar debiandebian #ifndef BOOST_MPL_VALUE_TYPE_FWD_HPP_INCLUDED #define BOOST_MPL_VALUE_TYPE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/value_type_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct value_type_impl; template< typename AssociativeSequence, typename T > struct value_type; }} #endif // BOOST_MPL_VALUE_TYPE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_back_fwd.hpp0000644000175000017500000000123611344301501031362 0ustar debiandebian #ifndef BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED #define BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_back_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct pop_back_impl; template< typename Sequence > struct pop_back; }} #endif // BOOST_MPL_POP_BACK_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/order_fwd.hpp0000644000175000017500000000131311344301501030713 0ustar debiandebian #ifndef BOOST_MPL_ORDER_FWD_HPP_INCLUDED #define BOOST_MPL_ORDER_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/order_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct order_impl; template< typename AssociativeSequence, typename Key > struct order; }} #endif // BOOST_MPL_ORDER_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bitxor.hpp0000644000175000017500000000125711344301501030256 0ustar debiandebian #ifndef BOOST_MPL_BITXOR_HPP_INCLUDED #define BOOST_MPL_BITXOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bitxor.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME bitxor_ #define AUX778076_OP_PREFIX bitxor #define AUX778076_OP_TOKEN ^ #include #endif // BOOST_MPL_BITXOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bind_fwd.hpp0000644000175000017500000000504311344301501030520 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_BIND_FWD_HPP_INCLUDED #define BOOST_MPL_BIND_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bind_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER bind_fwd.hpp # include #else # include # include # include # include # include # include # include namespace boost { namespace mpl { // local macros, #undef-ined at the end of the header # if defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) # define AUX778076_DMC_PARAM() , int dummy_ = 0 # else # define AUX778076_DMC_PARAM() # endif # define AUX778076_BIND_DEFAULT_PARAMS(param, value) \ BOOST_MPL_PP_DEFAULT_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ , value \ ) \ AUX778076_DMC_PARAM() \ /**/ # define AUX778076_BIND_N_PARAMS(n, param) \ BOOST_PP_COMMA_IF(n) BOOST_MPL_PP_PARAMS(n, param) \ AUX778076_DMC_PARAM() \ /**/ #if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) template< typename F, AUX778076_BIND_DEFAULT_PARAMS(typename T, na) > struct bind; #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() # undef AUX778076_BIND_N_PARAMS # undef AUX778076_BIND_DEFAULT_PARAMS # undef AUX778076_DMC_PARAM }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_BIND_FWD_HPP_INCLUDED ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) template< typename F AUX778076_BIND_N_PARAMS(i_, typename T) > struct BOOST_PP_CAT(bind,i_); #undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/greater.hpp0000644000175000017500000000116011344301501030371 0ustar debiandebian #ifndef BOOST_MPL_GREATER_HPP_INCLUDED #define BOOST_MPL_GREATER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/greater.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME greater #define AUX778076_OP_TOKEN > #include #endif // BOOST_MPL_GREATER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/base.hpp0000644000175000017500000000145611344301501027662 0ustar debiandebian #ifndef BOOST_MPL_BASE_HPP_INCLUDED #define BOOST_MPL_BASE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/base.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct base { typedef typename T::base type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,base,(T)) }; BOOST_MPL_AUX_NA_SPEC(1, base) }} #endif // BOOST_MPL_BASE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/order.hpp0000644000175000017500000000216411344301501030060 0ustar debiandebian #ifndef BOOST_MPL_ORDER_HPP_INCLUDED #define BOOST_MPL_ORDER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/order.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) , typename BOOST_MPL_AUX_NA_PARAM(Key) > struct order : order_impl< typename sequence_tag::type > ::template apply { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,order,(AssociativeSequence,Key)) }; BOOST_MPL_AUX_NA_SPEC(2, order) }} #endif // BOOST_MPL_ORDER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list.hpp0000644000175000017500000000325211344301501027717 0ustar debiandebian #ifndef BOOST_MPL_LIST_HPP_INCLUDED #define BOOST_MPL_LIST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_LIST_HEADER \ BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE).hpp \ /**/ #else # define AUX778076_LIST_HEADER \ BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_HEADER) # undef AUX778076_LIST_HEADER #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list.hpp # include #else # include # define AUX778076_SEQUENCE_NAME list # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_LIST_SIZE # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c_tag.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c_tag.hp0000644000175000017500000000150111344301501031521 0ustar debiandebian #ifndef BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED #define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c_tag.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN struct integral_c_tag { BOOST_STATIC_CONSTANT(int, value = 0); }; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c_tag) #endif // BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/equal.hpp0000644000175000017500000000531711344301501030057 0ustar debiandebian #ifndef BOOST_MPL_EQUAL_HPP_INCLUDED #define BOOST_MPL_EQUAL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/equal.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Predicate , typename LastIterator1 , typename LastIterator2 > struct equal_pred { template< typename Iterator2 , typename Iterator1 > struct apply { typedef typename and_< not_< is_same > , not_< is_same > , aux::iter_apply2 >::type type; }; }; template< typename Sequence1 , typename Sequence2 , typename Predicate > struct equal_impl { typedef typename begin::type first1_; typedef typename begin::type first2_; typedef typename end::type last1_; typedef typename end::type last2_; typedef aux::iter_fold_if_impl< first1_ , first2_ , next<> , protect< aux::equal_pred > , void_ , always > fold_; typedef typename fold_::iterator iter1_; typedef typename fold_::state iter2_; typedef and_< is_same , is_same > result_; typedef typename result_::type type; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence1) , typename BOOST_MPL_AUX_NA_PARAM(Sequence2) , typename Predicate = is_same<_,_> > struct equal : aux::msvc_eti_base< typename aux::equal_impl::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,equal,(Sequence1,Sequence2)) }; BOOST_MPL_AUX_NA_SPEC(2, equal) }} #endif // BOOST_MPL_EQUAL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/size_fwd.hpp0000644000175000017500000000120611344301501030553 0ustar debiandebian #ifndef BOOST_MPL_SIZE_FWD_HPP_INCLUDED #define BOOST_MPL_SIZE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/size_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct size_impl; template< typename Sequence > struct size; }} #endif // BOOST_MPL_SIZE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/has_xxx.hpp0000644000175000017500000001526511344301501030435 0ustar debiandebian #ifndef BOOST_MPL_HAS_XXX_HPP_INCLUDED #define BOOST_MPL_HAS_XXX_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // Copyright David Abrahams 2002-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/has_xxx.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #if !defined(BOOST_MPL_CFG_NO_HAS_XXX) # if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) // agurt, 11/sep/02: MSVC-specific version (< 7.1), based on a USENET // newsgroup's posting by John Madsen (comp.lang.c++.moderated, // 1999-11-12 19:17:06 GMT); the code is _not_ standard-conforming, but // it works way more reliably than the SFINAE-based implementation // Modified dwa 8/Oct/02 to handle reference types. # include # include namespace boost { namespace mpl { namespace aux { struct has_xxx_tag; #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) template< typename U > struct msvc_incomplete_array { typedef char (&type)[sizeof(U) + 1]; }; #endif template< typename T > struct msvc_is_incomplete { // MSVC is capable of some kinds of SFINAE. If U is an incomplete // type, it won't pick the second overload static char tester(...); #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) template< typename U > static typename msvc_incomplete_array::type tester(type_wrapper); #else template< typename U > static char (& tester(type_wrapper) )[sizeof(U)+1]; #endif BOOST_STATIC_CONSTANT(bool, value = sizeof(tester(type_wrapper())) == 1 ); }; template<> struct msvc_is_incomplete { BOOST_STATIC_CONSTANT(bool, value = false); }; }}} # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, default_) \ template< typename T, typename name = ::boost::mpl::aux::has_xxx_tag > \ struct BOOST_PP_CAT(trait,_impl) : T \ { \ static boost::mpl::aux::no_tag \ test(void(*)(::boost::mpl::aux::has_xxx_tag)); \ \ static boost::mpl::aux::yes_tag test(...); \ \ BOOST_STATIC_CONSTANT(bool, value = \ sizeof(test(static_cast(0))) \ != sizeof(boost::mpl::aux::no_tag) \ ); \ typedef boost::mpl::bool_ type; \ }; \ \ template< typename T, typename fallback_ = boost::mpl::bool_ > \ struct trait \ : boost::mpl::if_c< \ boost::mpl::aux::msvc_is_incomplete::value \ , boost::mpl::bool_ \ , BOOST_PP_CAT(trait,_impl) \ >::type \ { \ }; \ \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, void) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, bool) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, char) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed char) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned char) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed short) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned short) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed int) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned int) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, signed long) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, unsigned long) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, float) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, double) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, long double) \ /**/ # define BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, T) \ template<> struct trait \ { \ BOOST_STATIC_CONSTANT(bool, value = false); \ typedef boost::mpl::bool_ type; \ }; \ /**/ #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ BOOST_MPL_AUX_HAS_XXX_TRAIT_SPEC(trait, wchar_t) \ /**/ #else # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, unused) \ BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF_(trait, name, unused) \ /**/ #endif // SFINAE-based implementations below are derived from a USENET newsgroup's // posting by Rani Sharoni (comp.lang.c++.moderated, 2002-03-17 07:45:09 PST) # elif BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) // MSVC 7.1+ # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ template< typename T > struct BOOST_PP_CAT(trait,_wrapper_); \ template< typename T > \ boost::mpl::aux::yes_tag BOOST_PP_CAT(trait,_helper_)( \ BOOST_PP_CAT(trait,_wrapper_) const volatile* \ , BOOST_PP_CAT(trait,_wrapper_)* = 0 \ ); \ \ boost::mpl::aux::no_tag BOOST_PP_CAT(trait,_helper_)(...); \ \ template< typename T, typename fallback_ = boost::mpl::bool_ > \ struct trait \ { \ typedef BOOST_PP_CAT(trait,_wrapper_) t_; \ BOOST_STATIC_CONSTANT(bool, value = \ sizeof((BOOST_PP_CAT(trait,_helper_))(static_cast(0))) \ == sizeof(boost::mpl::aux::yes_tag) \ ); \ typedef boost::mpl::bool_ type; \ }; \ /**/ # else // other SFINAE-capable compilers # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ template< typename T, typename fallback_ = boost::mpl::bool_ > \ struct trait \ { \ struct gcc_3_2_wknd \ { \ template< typename U > \ static boost::mpl::aux::yes_tag test( \ boost::mpl::aux::type_wrapper const volatile* \ , boost::mpl::aux::type_wrapper* = 0 \ ); \ \ static boost::mpl::aux::no_tag test(...); \ }; \ \ typedef boost::mpl::aux::type_wrapper t_; \ BOOST_STATIC_CONSTANT(bool, value = \ sizeof(gcc_3_2_wknd::test(static_cast(0))) \ == sizeof(boost::mpl::aux::yes_tag) \ ); \ typedef boost::mpl::bool_ type; \ }; \ /**/ # endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) #else // BOOST_MPL_CFG_NO_HAS_XXX // placeholder implementation # define BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(trait, name, default_) \ template< typename T, typename fallback_ = boost::mpl::bool_ > \ struct trait \ { \ BOOST_STATIC_CONSTANT(bool, value = fallback_::value); \ typedef fallback_ type; \ }; \ /**/ #endif #define BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \ BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(BOOST_PP_CAT(has_,name), name, false) \ /**/ #endif // BOOST_MPL_HAS_XXX_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/stable_partition.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/stable_partition.0000644000175000017500000000343311344301501031600 0ustar debiandebian #ifndef BOOST_MPL_STABLE_PARTITION_HPP_INCLUDED #define BOOST_MPL_STABLE_PARTITION_HPP_INCLUDED // Copyright Eric Friedman 2002-2003 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/stable_partition.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template < typename Sequence , typename Pred , typename In , typename In2 , typename In1 = typename if_na::type > struct stable_partition_impl : fold< Sequence , pair< typename In1::state, typename In2::state > , protect< partition_op< Pred , typename In1::operation , typename In2::operation > > > { }; template < typename Sequence , typename Pred , typename In , typename In2 , typename In1 = typename if_na::type > struct reverse_stable_partition_impl : reverse_fold< Sequence , pair< typename In1::state, typename In2::state > , protect< partition_op< Pred , typename In1::operation , typename In2::operation > > > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, stable_partition) }} #endif // BOOST_MPL_STABLE_PARTITION_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/zip_view.hpp0000644000175000017500000000310211344301501030572 0ustar debiandebian #ifndef BOOST_MPL_ZIP_VIEW_HPP_INCLUDED #define BOOST_MPL_ZIP_VIEW_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2002 // Copyright David Abrahams 2000-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/zip_view.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename IteratorSeq > struct zip_iterator { typedef forward_iterator_tag category; typedef typename transform1< IteratorSeq , deref<_1> >::type type; typedef zip_iterator< typename transform1< IteratorSeq , next<_1> >::type > next; }; template< typename BOOST_MPL_AUX_NA_PARAM(Sequences) > struct zip_view { private: typedef typename transform1< Sequences, begin<_1> >::type first_ones_; typedef typename transform1< Sequences, end<_1> >::type last_ones_; public: typedef nested_begin_end_tag tag; typedef zip_iterator begin; typedef zip_iterator end; }; BOOST_MPL_AUX_NA_SPEC(1, zip_view) }} #endif // BOOST_MPL_ZIP_VIEW_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iter_fold_if.hpp0000644000175000017500000000615211344301501031373 0ustar debiandebian #ifndef BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED #define BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright Eric Friedman 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/iter_fold_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Predicate, typename LastIterator > struct iter_fold_if_pred { template< typename State, typename Iterator > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : and_< not_< is_same > , apply1 > { #else { typedef and_< not_< is_same > , apply1 > type; #endif }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(State) , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) , typename BOOST_MPL_AUX_NA_PARAM(ForwardPredicate) , typename BOOST_MPL_AUX_NA_PARAM(BackwardOp) , typename BOOST_MPL_AUX_NA_PARAM(BackwardPredicate) > struct iter_fold_if { typedef typename begin::type first_; typedef typename end::type last_; typedef typename eval_if< is_na , if_< is_na, always, always > , identity >::type backward_pred_; // cwpro8 doesn't like 'cut-off' type here (use typedef instead) #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) && !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) struct result_ : #else typedef #endif aux::iter_fold_if_impl< first_ , State , ForwardOp , protect< aux::iter_fold_if_pred< ForwardPredicate,last_ > > , BackwardOp , backward_pred_ > #if !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) && !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) { }; #else result_; #endif public: typedef pair< typename result_::state , typename result_::iterator > type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , iter_fold_if , (Sequence,State,ForwardOp,ForwardPredicate,BackwardOp,BackwardPredicate) ) }; BOOST_MPL_AUX_NA_SPEC(6, iter_fold_if) }} #endif // BOOST_MPL_ITER_FOLD_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/accumulate.hpp0000644000175000017500000000203211344301501031062 0ustar debiandebian #ifndef BOOST_MPL_ACCUMULATE_HPP_INCLUDED #define BOOST_MPL_ACCUMULATE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/accumulate.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(State) , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) > struct accumulate : fold { BOOST_MPL_AUX_LAMBDA_SUPPORT(3,accumulate,(Sequence,State,ForwardOp)) }; BOOST_MPL_AUX_NA_SPEC(3, accumulate) }} #endif // BOOST_MPL_ACCUMULATE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/count_if.hpp0000644000175000017500000000351411344301501030553 0ustar debiandebian #ifndef BOOST_MPL_COUNT_IF_HPP_INCLUDED #define BOOST_MPL_COUNT_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/count_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Predicate > struct next_if { template< typename N , typename T > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : eval_if< typename apply1::type , next , identity > { #else { typedef typename eval_if< typename apply1::type , next , identity >::type type; #endif }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Predicate) > struct count_if : aux::msvc_eti_base< typename fold< Sequence , integral_c , protect< aux::next_if > >::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,count_if,(Sequence,Predicate)) }; BOOST_MPL_AUX_NA_SPEC(2, count_if) }} #endif // BOOST_MPL_COUNT_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/minus.hpp0000644000175000017500000000114611344301501030077 0ustar debiandebian #ifndef BOOST_MPL_MINUS_HPP_INCLUDED #define BOOST_MPL_MINUS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/minus.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME minus #define AUX778076_OP_TOKEN - #include #endif // BOOST_MPL_MINUS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/O1_size.hpp0000644000175000017500000000212011344301501030246 0ustar debiandebian #ifndef BOOST_MPL_O1_SIZE_HPP_INCLUDED #define BOOST_MPL_O1_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/O1_size.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { // returns sequence size if it's an O(1) operation; otherwise returns -1 template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct O1_size : O1_size_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1, O1_size, (Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, O1_size) }} #endif // BOOST_MPL_O1_SIZE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/print.hpp0000644000175000017500000000305611344301501030102 0ustar debiandebian #ifndef BOOST_MPL_PRINT_HPP_INCLUDED #define BOOST_MPL_PRINT_HPP_INCLUDED // Copyright David Abrahams 2003 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/print.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { #if defined(BOOST_MSVC) # pragma warning(push, 3) // we only want one warning from MSVC, so turn off the other one # pragma warning(disable: 4307) #elif defined(__MWERKS__) # pragma warn_hidevirtual on struct print_base { virtual void f() {} }; #endif #if defined(__EDG_VERSION__) template struct dependent_unsigned { static const unsigned value = 1; }; #endif } // namespace aux template struct print : mpl::identity #if defined(__MWERKS__) , aux::print_base #endif { #if defined(BOOST_MSVC) enum { n = sizeof(T) + -1 }; #elif defined(__MWERKS__) void f(int); #else enum { n = # if defined(__EDG_VERSION__) aux::dependent_unsigned::value > -1 # else sizeof(T) > -1, # endif }; #endif }; #if defined(BOOST_MSVC) # pragma warning(pop) #elif defined(__MWERKS__) # pragma warn_hidevirtual reset #endif }} #endif // BOOST_MPL_PRINT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/at_fwd.hpp0000644000175000017500000000120611344301501030205 0ustar debiandebian #ifndef BOOST_MPL_AT_FWD_HPP_INCLUDED #define BOOST_MPL_AT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/at_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct at_impl; template< typename Sequence, typename N > struct at; }} #endif // BOOST_MPL_AT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiplies.hpp0000644000175000017500000000264511344301501031140 0ustar debiandebian #ifndef BOOST_MPL_MULTIPLIES_HPP_INCLUDED #define BOOST_MPL_MULTIPLIES_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiplies.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include // backward compatibility header, deprecated namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY #else # define AUX778076_OP_ARITY 2 #endif template< BOOST_MPL_PP_DEFAULT_PARAMS(AUX778076_OP_ARITY, typename N, na) > struct multiplies : times< BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) > { BOOST_MPL_AUX_LAMBDA_SUPPORT( AUX778076_OP_ARITY , multiplies , ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) ) ) }; BOOST_MPL_AUX_NA_SPEC(AUX778076_OP_ARITY, multiplies) #undef AUX778076_OP_ARITY }} #endif // BOOST_MPL_MULTIPLIES_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/has_key_fwd.hpp0000644000175000017500000000132711344301501031230 0ustar debiandebian #ifndef BOOST_MPL_HAS_KEY_FWD_HPP_INCLUDED #define BOOST_MPL_HAS_KEY_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/has_key_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct has_key_impl; template< typename AssociativeSequence, typename Key > struct has_key; }} #endif // BOOST_MPL_HAS_KEY_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/clear_fwd.hpp0000644000175000017500000000121411344301501030666 0ustar debiandebian #ifndef BOOST_MPL_CLEAR_FWD_HPP_INCLUDED #define BOOST_MPL_CLEAR_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/clear_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct clear_impl; template< typename Sequence > struct clear; }} #endif // BOOST_MPL_CLEAR_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/remove_if.hpp0000644000175000017500000000371311344301501030721 0ustar debiandebian #ifndef BOOST_MPL_REMOVE_IF_HPP_INCLUDED #define BOOST_MPL_REMOVE_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/remove_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Pred, typename InsertOp > struct remove_if_helper { template< typename Sequence, typename U > struct apply { typedef typename eval_if< typename apply1::type , identity , apply2 >::type type; }; }; template< typename Sequence , typename Predicate , typename Inserter > struct remove_if_impl : fold< Sequence , typename Inserter::state , protect< aux::remove_if_helper< typename lambda::type , typename Inserter::operation > > > { }; template< typename Sequence , typename Predicate , typename Inserter > struct reverse_remove_if_impl : reverse_fold< Sequence , typename Inserter::state , protect< aux::remove_if_helper< typename lambda::type , typename Inserter::operation > > > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, remove_if) }} #endif // BOOST_MPL_REMOVE_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/index_if.hpp0000644000175000017500000000311211344301501030524 0ustar debiandebian #ifndef BOOST_MPL_INDEX_IF_HPP_INCLUDED #define BOOST_MPL_INDEX_IF_HPP_INCLUDED // Copyright Eric Friedman 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/index_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Predicate) > struct index_if { typedef typename iter_fold_if< Sequence , int_<0> , next<> , aux::find_if_pred >::type result_; typedef typename end::type not_found_; typedef typename first::type result_index_; typedef typename second::type result_iterator_; typedef typename if_< is_same< result_iterator_,not_found_ > , void_ , result_index_ >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2,index_if,(Sequence,Predicate)) }; BOOST_MPL_AUX_NA_SPEC(2, index_if) }} #endif // BOOST_MPL_INDEX_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iter_fold.hpp0000644000175000017500000000253711344301501030720 0ustar debiandebian #ifndef BOOST_MPL_ITER_FOLD_HPP_INCLUDED #define BOOST_MPL_ITER_FOLD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/iter_fold.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(State) , typename BOOST_MPL_AUX_NA_PARAM(ForwardOp) > struct iter_fold { typedef typename aux::iter_fold_impl< ::boost::mpl::O1_size::value , typename begin::type , typename end::type , State , typename lambda::type >::state type; BOOST_MPL_AUX_LAMBDA_SUPPORT(3,iter_fold,(Sequence,State,ForwardOp)) }; BOOST_MPL_AUX_NA_SPEC(3, iter_fold) }} #endif // BOOST_MPL_ITER_FOLD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/modulus.hpp0000644000175000017500000000121511344301501030431 0ustar debiandebian #ifndef BOOST_MPL_MODULUS_HPP_INCLUDED #define BOOST_MPL_MODULUS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/modulus.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME modulus #define AUX778076_OP_TOKEN % #define AUX778076_OP_ARITY 2 #include #endif // BOOST_MPL_MODULUS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/as_sequence.hpp0000644000175000017500000000173011344301501031236 0ustar debiandebian #ifndef BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED #define BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/as_sequence.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct as_sequence : if_< is_sequence, T, single_view > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,as_sequence,(T)) }; BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, as_sequence) }} #endif // BOOST_MPL_AS_SEQUENCE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/single_view.hpp0000644000175000017500000000162611344301501031262 0ustar debiandebian #ifndef BOOST_MPL_SINGLE_VIEW_HPP_INCLUDED #define BOOST_MPL_SINGLE_VIEW_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/single_view.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct single_view : iterator_range< aux::sel_iter , aux::sel_iter > { }; BOOST_MPL_AUX_NA_SPEC_NO_ETI(1, single_view) }} #endif // BOOST_MPL_SINGLE_VIEW_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/at.hpp0000644000175000017500000000242111344301501027345 0ustar debiandebian #ifndef BOOST_MPL_AT_HPP_INCLUDED #define BOOST_MPL_AT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/at.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(N) > struct at : at_impl< typename sequence_tag::type > ::template apply< Sequence,N > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,at,(Sequence,N)) }; template< typename Sequence , BOOST_MPL_AUX_NTTP_DECL(long, N) > struct at_c : at_impl< typename sequence_tag::type > ::template apply< Sequence,mpl::long_ > { }; BOOST_MPL_AUX_NA_SPEC(2, at) }} #endif // BOOST_MPL_AT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/max_element.hpp0000644000175000017500000000322511344301501031242 0ustar debiandebian #ifndef BOOST_MPL_MAX_ELEMENT_HPP_INCLUDED #define BOOST_MPL_MAX_ELEMENT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/max_element.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { BOOST_MPL_AUX_COMMON_NAME_WKND(max_element) namespace aux { template< typename Predicate > struct select_max { template< typename OldIterator, typename Iterator > struct apply { typedef typename apply2< Predicate , typename deref::type , typename deref::type >::type condition_; typedef typename if_< condition_ , Iterator , OldIterator >::type type; }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename Predicate = less<_,_> > struct max_element : iter_fold< Sequence , typename begin::type , protect< aux::select_max > > { }; BOOST_MPL_AUX_NA_SPEC(1, max_element) }} #endif // BOOST_MPL_MAX_ELEMENT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map.hpp0000644000175000017500000000323211344301501027517 0ustar debiandebian #ifndef BOOST_MPL_MAP_HPP_INCLUDED #define BOOST_MPL_MAP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_MAP_HEADER \ BOOST_PP_CAT(map, BOOST_MPL_LIMIT_MAP_SIZE).hpp \ /**/ #else # define AUX778076_MAP_HEADER \ BOOST_PP_CAT(map, BOOST_MPL_LIMIT_MAP_SIZE)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/map/AUX778076_MAP_HEADER) # undef AUX778076_MAP_HEADER #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER map.hpp # include #else # include # define AUX778076_SEQUENCE_NAME map # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_MAP_SIZE # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_MAP_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/find_if.hpp0000644000175000017500000000241411344301501030341 0ustar debiandebian #ifndef BOOST_MPL_FIND_IF_HPP_INCLUDED #define BOOST_MPL_FIND_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/find_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { BOOST_MPL_AUX_COMMON_NAME_WKND(find_if) template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Predicate) > struct find_if { typedef typename iter_fold_if< Sequence , void , arg<1> // ignore , protect< aux::find_if_pred > >::type result_; typedef typename second::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2,find_if,(Sequence,Predicate)) }; BOOST_MPL_AUX_NA_SPEC(2,find_if) }} #endif // BOOST_MPL_FIND_IF_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_range_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_range_fwd.0000644000175000017500000000132411344301501031552 0ustar debiandebian #ifndef BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED #define BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_range_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct insert_range_impl; template< typename Sequence, typename Pos, typename Range > struct insert_range; }} #endif // BOOST_MPL_INSERT_RANGE_FWD_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/transform_view.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/transform_view.hp0000644000175000017500000000232011344301501031624 0ustar debiandebian #ifndef BOOST_MPL_TRANSFORM_VIEW_HPP_INCLUDED #define BOOST_MPL_TRANSFORM_VIEW_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/transform_view.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(F) > struct transform_view { private: typedef typename lambda::type f_; typedef typename begin::type first_; typedef typename end::type last_; public: struct tag; typedef transform_view type; typedef aux::transform_iter< first_,last_,f_ > begin; typedef aux::transform_iter< last_,last_,f_ > end; }; BOOST_MPL_AUX_NA_SPEC(2, transform_view) }} #endif // BOOST_MPL_TRANSFORM_VIEW_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/key_type_fwd.hpp0000644000175000017500000000133311344301501031433 0ustar debiandebian #ifndef BOOST_MPL_KEY_TYPE_FWD_HPP_INCLUDED #define BOOST_MPL_KEY_TYPE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/key_type_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct key_type_impl; template< typename AssociativeSequence, typename T > struct key_type; }} #endif // BOOST_MPL_KEY_TYPE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/if.hpp0000644000175000017500000000570011344301501027342 0ustar debiandebian #ifndef BOOST_MPL_IF_HPP_INCLUDED #define BOOST_MPL_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< bool C , typename T1 , typename T2 > struct if_c { typedef T1 type; }; template< typename T1 , typename T2 > struct if_c { typedef T2 type; }; // agurt, 05/sep/04: nondescriptive parameter names for the sake of DigitalMars // (and possibly MWCW < 8.0); see http://article.gmane.org/gmane.comp.lib.boost.devel/108959 template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename BOOST_MPL_AUX_NA_PARAM(T3) > struct if_ { private: // agurt, 02/jan/03: two-step 'type' definition for the sake of aCC typedef if_c< #if defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) BOOST_MPL_AUX_VALUE_WKND(T1)::value #else BOOST_MPL_AUX_STATIC_CAST(bool, BOOST_MPL_AUX_VALUE_WKND(T1)::value) #endif , T2 , T3 > almost_type_; public: typedef typename almost_type_::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(T1,T2,T3)) }; #else // no partial class template specialization namespace aux { template< bool C > struct if_impl { template< typename T1, typename T2 > struct result_ { typedef T1 type; }; }; template<> struct if_impl { template< typename T1, typename T2 > struct result_ { typedef T2 type; }; }; } // namespace aux template< bool C_ , typename T1 , typename T2 > struct if_c { typedef typename aux::if_impl< C_ > ::template result_::type type; }; // (almost) copy & paste in order to save one more // recursively nested template instantiation to user template< typename BOOST_MPL_AUX_NA_PARAM(C_) , typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct if_ { enum { msvc_wknd_ = BOOST_MPL_AUX_MSVC_VALUE_WKND(C_)::value }; typedef typename aux::if_impl< BOOST_MPL_AUX_STATIC_CAST(bool, msvc_wknd_) > ::template result_::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(3,if_,(C_,T1,T2)) }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_MPL_AUX_NA_SPEC(3, if_) }} #endif // BOOST_MPL_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/advance.hpp0000644000175000017500000000401011344301501030336 0ustar debiandebian #ifndef BOOST_MPL_ADVANCE_HPP_INCLUDED #define BOOST_MPL_ADVANCE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/advance.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation for forward/bidirectional iterators template< typename Tag > struct advance_impl { template< typename Iterator, typename N > struct apply { typedef typename less< N,long_<0> >::type backward_; typedef typename if_< backward_, negate, N >::type offset_; typedef typename if_< backward_ , aux::advance_backward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value > , aux::advance_forward< BOOST_MPL_AUX_VALUE_WKND(offset_)::value > >::type f_; typedef typename apply_wrap1::type type; }; }; template< typename BOOST_MPL_AUX_NA_PARAM(Iterator) , typename BOOST_MPL_AUX_NA_PARAM(N) > struct advance : advance_impl< typename tag::type > ::template apply { }; template< typename Iterator , BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_c : advance_impl< typename tag::type > ::template apply > { }; BOOST_MPL_AUX_NA_SPEC(2, advance) }} #endif // BOOST_MPL_ADVANCE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set.hpp0000644000175000017500000000323211344301501027535 0ustar debiandebian #ifndef BOOST_MPL_SET_HPP_INCLUDED #define BOOST_MPL_SET_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_SET_HEADER \ BOOST_PP_CAT(set, BOOST_MPL_LIMIT_SET_SIZE).hpp \ /**/ #else # define AUX778076_SET_HEADER \ BOOST_PP_CAT(set, BOOST_MPL_LIMIT_SET_SIZE)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/set/AUX778076_SET_HEADER) # undef AUX778076_SET_HEADER #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set.hpp # include #else # include # define AUX778076_SEQUENCE_NAME set # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_SET_SIZE # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/partition.hpp0000644000175000017500000000217511344301501030760 0ustar debiandebian #ifndef BOOST_MPL_PARTITION_HPP_INCLUDED #define BOOST_MPL_PARTITION_HPP_INCLUDED // Copyright Eric Friedman 2002-2003 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/partition.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { template < typename Sequence , typename Pred , typename In1 , typename In2 > struct partition_impl : stable_partition_impl { }; template < typename Sequence , typename Pred , typename In1 , typename In2 > struct reverse_partition_impl : reverse_stable_partition_impl { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, partition) }} #endif // BOOST_MPL_PARTITION_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/numeric_cast.hpp0000644000175000017500000000236611344301501031425 0ustar debiandebian #ifndef BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED #define BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/numeric_cast.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // agurt 21/sep/04: portability macro for the sake of MSVC 6.x-7.0; // resolves conflicts with 'boost::numeric_cast' function template. // use it in your own code _only_ if you care about compatibility with // these outdated compilers! #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # define BOOST_MPL_AUX_NUMERIC_CAST numeric_cast_ #else # define BOOST_MPL_AUX_NUMERIC_CAST numeric_cast #endif namespace boost { namespace mpl { // no default implementation; the definition is needed to make MSVC happy template< typename SourceTag, typename TargetTag > struct BOOST_MPL_AUX_NUMERIC_CAST { template< typename N > struct apply; }; }} #endif // BOOST_MPL_NUMERIC_CAST_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/erase_key.hpp0000644000175000017500000000217611344301501030717 0ustar debiandebian #ifndef BOOST_MPL_ERASE_KEY_HPP_INCLUDED #define BOOST_MPL_ERASE_KEY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/erase_key.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Key) > struct erase_key : erase_key_impl< typename sequence_tag::type > ::template apply< Sequence,Key > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,erase_key,(Sequence,Key)) }; BOOST_MPL_AUX_NA_SPEC(2,erase_key) }} #endif // BOOST_MPL_ERASE_KEY_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_range.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_range.hp0000644000175000017500000000203311344301501031565 0ustar debiandebian #ifndef BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED #define BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_range.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { struct iterator_range_tag; template< typename BOOST_MPL_AUX_NA_PARAM(First) , typename BOOST_MPL_AUX_NA_PARAM(Last) > struct iterator_range { typedef iterator_range_tag tag; typedef iterator_range type; typedef First begin; typedef Last end; BOOST_MPL_AUX_LAMBDA_SUPPORT(2,iterator_range,(First,Last)) }; BOOST_MPL_AUX_NA_SPEC(2, iterator_range) }} #endif // BOOST_MPL_ITERATOR_RANGE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/negate.hpp0000644000175000017500000000367311344301501030216 0ustar debiandebian #ifndef BOOST_MPL_NEGATE_HPP_INCLUDED #define BOOST_MPL_NEGATE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/negate.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Tag > struct negate_impl; template< typename T > struct negate_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N) > struct negate #if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) : negate_impl< typename negate_tag::type >::template apply::type #else : aux::msvc_eti_base< typename apply_wrap1< negate_impl< typename negate_tag::type > , N >::type >::type #endif { BOOST_MPL_AUX_LAMBDA_SUPPORT(1, negate, (N)) }; BOOST_MPL_AUX_NA_SPEC(1, negate) #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) namespace aux { template< typename T, T n > struct negate_wknd { BOOST_STATIC_CONSTANT(T, value = -n); typedef integral_c type; }; } #endif template<> struct negate_impl { #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) template< typename N > struct apply : aux::negate_wknd< typename N::value_type, N::value > #else template< typename N > struct apply : integral_c< typename N::value_type, (-N::value) > #endif { }; }; }} #endif // BOOST_MPL_NEGATE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/bool_fwd.hpp0000644000175000017500000000154411344301501030541 0ustar debiandebian #ifndef BOOST_MPL_BOOL_FWD_HPP_INCLUDED #define BOOST_MPL_BOOL_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/bool_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< bool C_ > struct bool_; // shorcuts typedef bool_ true_; typedef bool_ false_; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(bool_) BOOST_MPL_AUX_ADL_BARRIER_DECL(true_) BOOST_MPL_AUX_ADL_BARRIER_DECL(false_) #endif // BOOST_MPL_BOOL_FWD_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/front_inserter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/front_inserter.hp0000644000175000017500000000144011344301501031624 0ustar debiandebian #ifndef BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED #define BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/front_inserter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename Sequence > struct front_inserter : inserter< Sequence,push_front<> > { }; }} #endif // BOOST_MPL_FRONT_INSERTER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/vector.hpp0000644000175000017500000000332011344301501030242 0ustar debiandebian #ifndef BOOST_MPL_VECTOR_HPP_INCLUDED #define BOOST_MPL_VECTOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/vector.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_VECTOR_HEADER \ BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE).hpp \ /**/ #else # define AUX778076_VECTOR_HEADER \ BOOST_PP_CAT(vector, BOOST_MPL_LIMIT_VECTOR_SIZE)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/vector/AUX778076_VECTOR_HEADER) # undef AUX778076_VECTOR_HEADER #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER vector.hpp # include #else # include # define AUX778076_SEQUENCE_NAME vector # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_VECTOR_SIZE # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_VECTOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/arg_fwd.hpp0000644000175000017500000000145411344301501030357 0ustar debiandebian #ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED #define BOOST_MPL_ARG_FWD_HPP_INCLUDED // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/arg_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arg; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(arg) #endif // BOOST_MPL_ARG_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list_c.hpp0000644000175000017500000000357211344301501030226 0ustar debiandebian #ifndef BOOST_MPL_LIST_C_HPP_INCLUDED #define BOOST_MPL_LIST_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list_c.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_LIST_C_HEADER \ BOOST_PP_CAT(BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE),_c).hpp \ /**/ #else # define AUX778076_LIST_C_HEADER \ BOOST_PP_CAT(BOOST_PP_CAT(list,BOOST_MPL_LIMIT_LIST_SIZE),_c)##.hpp \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_LIST_C_HEADER) # undef AUX778076_LIST_C_HEADER # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list_c.hpp # include #else # include # define AUX778076_SEQUENCE_NAME list_c # define AUX778076_SEQUENCE_LIMIT BOOST_MPL_LIMIT_LIST_SIZE # define AUX778076_SEQUENCE_NAME_N(n) BOOST_PP_CAT(BOOST_PP_CAT(list,n),_c) # define AUX778076_SEQUENCE_INTEGRAL_WRAPPER # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/has_key.hpp0000644000175000017500000000221011344301501030360 0ustar debiandebian #ifndef BOOST_MPL_HAS_KEY_HPP_INCLUDED #define BOOST_MPL_HAS_KEY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/has_key.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(AssociativeSequence) , typename BOOST_MPL_AUX_NA_PARAM(Key) > struct has_key : has_key_impl< typename sequence_tag::type > ::template apply { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,has_key,(AssociativeSequence,Key)) }; BOOST_MPL_AUX_NA_SPEC(2, has_key) }} #endif // BOOST_MPL_HAS_KEY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/range_c.hpp0000644000175000017500000000231111344301501030335 0ustar debiandebian #ifndef BOOST_MPL_RANGE_C_HPP_INCLUDED #define BOOST_MPL_RANGE_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/range_c.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename T , T Start , T Finish > struct range_c { typedef aux::half_open_range_tag tag; typedef T value_type; typedef range_c type; typedef integral_c start; typedef integral_c finish; typedef r_iter begin; typedef r_iter end; }; }} #endif // BOOST_MPL_RANGE_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/int.hpp0000644000175000017500000000115111344301501027532 0ustar debiandebian #ifndef BOOST_MPL_INT_HPP_INCLUDED #define BOOST_MPL_INT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/int.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #define AUX_WRAPPER_VALUE_TYPE int #include #endif // BOOST_MPL_INT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c.hpp0000644000175000017500000000303411344301501031051 0ustar debiandebian #ifndef BOOST_MPL_INTEGRAL_C_HPP_INCLUDED #define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/integral_c.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if BOOST_WORKAROUND(__HP_aCC, BOOST_TESTED_AT(53800)) // the type of non-type template arguments may not depend on template arguments # define AUX_WRAPPER_PARAMS(N) typename T, long N #else # define AUX_WRAPPER_PARAMS(N) typename T, T N #endif #define AUX_WRAPPER_NAME integral_c #define AUX_WRAPPER_VALUE_TYPE T #define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value > #include #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !BOOST_WORKAROUND(__BORLANDC__, <= 0x551) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN // 'bool' constant doesn't have 'next'/'prior' members template< bool C > struct integral_c { BOOST_STATIC_CONSTANT(bool, value = C); typedef integral_c type; operator bool() const { return this->value; } }; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE #endif #endif // BOOST_MPL_INTEGRAL_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/begin_end.hpp0000644000175000017500000000301311344301501030651 0ustar debiandebian #ifndef BOOST_MPL_BEGIN_END_HPP_INCLUDED #define BOOST_MPL_BEGIN_END_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/begin_end.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { // agurt, 13/sep/02: switched from inheritance to typedef; MSVC is more // happy this way (less ETI-related errors), and it doesn't affect // anything else template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct begin { typedef typename sequence_tag::type tag_; typedef typename begin_impl< tag_ > ::template apply< Sequence >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,begin,(Sequence)) }; template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct end { typedef typename sequence_tag::type tag_; typedef typename end_impl< tag_ > ::template apply< Sequence >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,end,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, begin) BOOST_MPL_AUX_NA_SPEC(1, end) }} #endif // BOOST_MPL_BEGIN_END_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/0000755000175000017500000000000012146213760027036 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set0_c.hpp0000644000175000017500000000141711344301502030716 0ustar debiandebian #ifndef BOOST_MPL_SET_SET0_C_HPP_INCLUDED #define BOOST_MPL_SET_SET0_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set0_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename T > struct set0_c : set0<> { typedef set0_c type; typedef T value_type; }; }} #endif // BOOST_MPL_SET_SET0_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set40_c.hpp0000644000175000017500000000232311344301502030777 0ustar debiandebian #ifndef BOOST_MPL_SET_SET40_C_HPP_INCLUDED #define BOOST_MPL_SET_SET40_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set40_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set40_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET40_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set30.hpp0000644000175000017500000000223711344301502030500 0ustar debiandebian #ifndef BOOST_MPL_SET_SET30_HPP_INCLUDED #define BOOST_MPL_SET_SET30_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set30.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set30.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET30_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/0000755000175000017500000000000012146213761027773 5ustar debiandebian././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/iterator0000644000175000017500000000463011344301502031540 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED #define BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/iterator.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // used by 's_iter_impl' template< typename Set, typename Tail > struct s_iter; template< typename Set, typename Tail > struct s_iter_impl { typedef Tail tail_; typedef forward_iterator_tag category; typedef typename Tail::type type; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) typedef typename eval_if< has_key< Set,typename Tail::next_::type > , identity< s_iter > , next< s_iter > >::type next; #endif }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Set, typename Tail > struct next< s_iter > : eval_if< has_key< Set,typename Tail::next_::type > , identity< s_iter > , next< s_iter > > { }; template< typename Set > struct next< s_iter > > { typedef s_iter > type; }; template< typename Set, typename Tail > struct s_iter : s_iter_impl { }; template< typename Set > struct s_iter > { typedef forward_iterator_tag category; }; #else template< typename Set > struct s_end_iter { typedef forward_iterator_tag category; typedef s_iter > next; }; template< typename Set, typename Tail > struct s_iter : if_< is_same< Tail,set0<> > , s_end_iter , s_iter_impl >::type { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION }} #endif // BOOST_MPL_SET_AUX_ITERATOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/include_preprocessed.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/include_0000644000175000017500000000177411344301502031477 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/include_preprocessed.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_HEADER \ plain/BOOST_MPL_PREPROCESSED_HEADER \ /**/ #else # define AUX778076_HEADER \ BOOST_PP_CAT(plain,/)##BOOST_MPL_PREPROCESSED_HEADER \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/set/aux_/preprocessed/AUX778076_HEADER) # undef AUX778076_HEADER #undef BOOST_MPL_PREPROCESSED_HEADER ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/erase_key_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/erase_ke0000644000175000017500000000257011344301502031466 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/erase_key_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template<> struct erase_key_impl< aux::set_tag > { template< typename Set , typename T > struct apply : eval_if< has_key_impl::apply , eval_if< is_same< T,typename Set::item_type_ > , base , identity< s_mask > > , identity > { }; }; }} #endif // BOOST_MPL_SET_AUX_ERASE_KEY_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/item.hpp0000644000175000017500000000435611344301502031440 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED #define BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/item.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename T, typename Base > struct s_item : Base { typedef void_ last_masked_; typedef Base next_; typedef T item_type_; typedef item_type_ type; typedef Base base; typedef typename next< typename Base::size >::type size; typedef typename next< typename Base::order >::type order; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) typedef typename aux::weighted_tag::type order_tag_; #else typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value]; #endif BOOST_MPL_AUX_SET_OVERLOAD( order_tag_, ORDER_BY_KEY, s_item, aux::type_wrapper* ); BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_item, aux::type_wrapper* ); }; template< typename T, typename Base > struct s_mask : Base { typedef T last_masked_; typedef void_ item_type_; typedef Base base; typedef typename prior< typename Base::size >::type size; BOOST_MPL_AUX_SET_OVERLOAD( aux::yes_tag, IS_MASKED, s_mask, aux::type_wrapper* ); }; template< typename T, typename Base > struct s_unmask : Base { typedef void_ last_masked_; typedef T item_type_; typedef Base base; typedef typename next< typename Base::size >::type size; BOOST_MPL_AUX_SET_OVERLOAD( aux::no_tag, IS_MASKED, s_unmask, aux::type_wrapper* ); }; }} #endif // BOOST_MPL_SET_AUX_ITEM_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000755000175000017500000000000012146213761031533 5ustar debiandebian././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000755000175000017500000000000012146213761031533 5ustar debiandebian././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set40_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000001326211344301502031527 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/Attic/set40_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 > struct set31_c : s_item< integral_c< T,C30 > , set30_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29 > > { typedef set31_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31 > struct set32_c : s_item< integral_c< T,C31 > , set31_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30 > > { typedef set32_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32 > struct set33_c : s_item< integral_c< T,C32 > , set32_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31 > > { typedef set33_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33 > struct set34_c : s_item< integral_c< T,C33 > , set33_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32 > > { typedef set34_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34 > struct set35_c : s_item< integral_c< T,C34 > , set34_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33 > > { typedef set35_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35 > struct set36_c : s_item< integral_c< T,C35 > , set35_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34 > > { typedef set36_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36 > struct set37_c : s_item< integral_c< T,C36 > , set36_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35 > > { typedef set37_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37 > struct set38_c : s_item< integral_c< T,C37 > , set37_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36 > > { typedef set38_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 > struct set39_c : s_item< integral_c< T,C38 > , set38_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37 > > { typedef set39_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 > struct set40_c : s_item< integral_c< T,C39 > , set39_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38 > > { typedef set40_c type; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000001401511344301502031524 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/set30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20 > struct set21 : s_item< T20 , set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 > > { typedef set21 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21 > struct set22 : s_item< T21 , set21< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 > > { typedef set22 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22 > struct set23 : s_item< T22 , set22< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 > > { typedef set23 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23 > struct set24 : s_item< T23 , set23< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 > > { typedef set24 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 > struct set25 : s_item< T24 , set24< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 > > { typedef set25 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25 > struct set26 : s_item< T25 , set25< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 > > { typedef set26 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26 > struct set27 : s_item< T26 , set26< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 > > { typedef set27 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27 > struct set28 : s_item< T27 , set27< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 > > { typedef set28 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28 > struct set29 : s_item< T28 , set28< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 > > { typedef set29 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 > struct set30 : s_item< T29 , set29< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 > > { typedef set30 type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set30_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000001106411344301502031525 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/Attic/set30_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 > struct set21_c : s_item< integral_c< T,C20 > , set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 > > { typedef set21_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21 > struct set22_c : s_item< integral_c< T,C21 > , set21_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 > > { typedef set22_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22 > struct set23_c : s_item< integral_c< T,C22 > , set22_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 > > { typedef set23_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23 > struct set24_c : s_item< integral_c< T,C23 > , set23_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 > > { typedef set24_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24 > struct set25_c : s_item< integral_c< T,C24 > , set24_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 > > { typedef set25_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25 > struct set26_c : s_item< integral_c< T,C25 > , set25_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 > > { typedef set26_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26 > struct set27_c : s_item< integral_c< T,C26 > , set26_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 > > { typedef set27_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27 > struct set28_c : s_item< integral_c< T,C27 > , set27_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 > > { typedef set28_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 > struct set29_c : s_item< integral_c< T,C28 > , set28_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 > > { typedef set29_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 > struct set30_c : s_item< integral_c< T,C29 > , set29_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 > > { typedef set30_c type; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000002334511344301502031532 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/set50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40 > struct set41 : s_item< T40 , set40< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39 > > { typedef set41 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41 > struct set42 : s_item< T41 , set41< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40 > > { typedef set42 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42 > struct set43 : s_item< T42 , set42< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41 > > { typedef set43 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43 > struct set44 : s_item< T43 , set43< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42 > > { typedef set44 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 > struct set45 : s_item< T44 , set44< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43 > > { typedef set45 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45 > struct set46 : s_item< T45 , set45< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44 > > { typedef set46 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46 > struct set47 : s_item< T46 , set46< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45 > > { typedef set47 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47 > struct set48 : s_item< T47 , set47< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46 > > { typedef set48 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48 > struct set49 : s_item< T48 , set48< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47 > > { typedef set49 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48, typename T49 > struct set50 : s_item< T49 , set49< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48 > > { typedef set50 type; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000000456211344301502031532 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/set10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 > struct set1 : s_item< T0 , set0< > > { typedef set1 type; }; template< typename T0, typename T1 > struct set2 : s_item< T1 , set1 > { typedef set2 type; }; template< typename T0, typename T1, typename T2 > struct set3 : s_item< T2 , set2< T0,T1 > > { typedef set3 type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set4 : s_item< T3 , set3< T0,T1,T2 > > { typedef set4 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set5 : s_item< T4 , set4< T0,T1,T2,T3 > > { typedef set5 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set6 : s_item< T5 , set5< T0,T1,T2,T3,T4 > > { typedef set6 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set7 : s_item< T6 , set6< T0,T1,T2,T3,T4,T5 > > { typedef set7 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set8 : s_item< T7 , set7< T0,T1,T2,T3,T4,T5,T6 > > { typedef set8 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set9 : s_item< T8 , set8< T0,T1,T2,T3,T4,T5,T6,T7 > > { typedef set9 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set10 : s_item< T9 , set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > > { typedef set10 type; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000001757111344301502031536 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/set40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30 > struct set31 : s_item< T30 , set30< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29 > > { typedef set31 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31 > struct set32 : s_item< T31 , set31< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30 > > { typedef set32 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32 > struct set33 : s_item< T32 , set32< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31 > > { typedef set33 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33 > struct set34 : s_item< T33 , set33< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32 > > { typedef set34 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 > struct set35 : s_item< T34 , set34< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33 > > { typedef set35 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35 > struct set36 : s_item< T35 , set35< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34 > > { typedef set36 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36 > struct set37 : s_item< T36 , set36< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35 > > { typedef set37 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37 > struct set38 : s_item< T37 , set37< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36 > > { typedef set38 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38 > struct set39 : s_item< T38 , set38< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37 > > { typedef set39 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 > struct set40 : s_item< T39 , set39< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38 > > { typedef set40 type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set10_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000000457111344301502031532 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/Attic/set10_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0 > struct set1_c : s_item< integral_c< T,C0 > , set0_c > { typedef set1_c type; }; template< typename T , T C0, T C1 > struct set2_c : s_item< integral_c< T,C1 > , set1_c< T,C0 > > { typedef set2_c type; }; template< typename T , T C0, T C1, T C2 > struct set3_c : s_item< integral_c< T,C2 > , set2_c< T,C0,C1 > > { typedef set3_c type; }; template< typename T , T C0, T C1, T C2, T C3 > struct set4_c : s_item< integral_c< T,C3 > , set3_c< T,C0,C1,C2 > > { typedef set4_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4 > struct set5_c : s_item< integral_c< T,C4 > , set4_c< T,C0,C1,C2,C3 > > { typedef set5_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5 > struct set6_c : s_item< integral_c< T,C5 > , set5_c< T,C0,C1,C2,C3,C4 > > { typedef set6_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6 > struct set7_c : s_item< integral_c< T,C6 > , set6_c< T,C0,C1,C2,C3,C4,C5 > > { typedef set7_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 > struct set8_c : s_item< integral_c< T,C7 > , set7_c< T,C0,C1,C2,C3,C4,C5,C6 > > { typedef set8_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 > struct set9_c : s_item< integral_c< T,C8 > , set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > > { typedef set9_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 > struct set10_c : s_item< integral_c< T,C9 > , set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > > { typedef set10_c type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set50_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000001546011344301502031531 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/Attic/set50_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 > struct set41_c : s_item< integral_c< T,C40 > , set40_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39 > > { typedef set41_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41 > struct set42_c : s_item< integral_c< T,C41 > , set41_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40 > > { typedef set42_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42 > struct set43_c : s_item< integral_c< T,C42 > , set42_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41 > > { typedef set43_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43 > struct set44_c : s_item< integral_c< T,C43 > , set43_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42 > > { typedef set44_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44 > struct set45_c : s_item< integral_c< T,C44 > , set44_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43 > > { typedef set45_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45 > struct set46_c : s_item< integral_c< T,C45 > , set45_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44 > > { typedef set46_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46 > struct set47_c : s_item< integral_c< T,C46 > , set46_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45 > > { typedef set47_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47 > struct set48_c : s_item< integral_c< T,C47 > , set47_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46 > > { typedef set48_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 > struct set49_c : s_item< integral_c< T,C48 > , set48_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47 > > { typedef set49_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 > struct set50_c : s_item< integral_c< T,C49 > , set49_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48 > > { typedef set50_c type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set20_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000000666611344301502031541 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/Attic/set20_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 > struct set11_c : s_item< integral_c< T,C10 > , set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > > { typedef set11_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11 > struct set12_c : s_item< integral_c< T,C11 > , set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > > { typedef set12_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12 > struct set13_c : s_item< integral_c< T,C12 > , set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > > { typedef set13_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13 > struct set14_c : s_item< integral_c< T,C13 > , set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > > { typedef set14_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14 > struct set15_c : s_item< integral_c< T,C14 > , set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 > > { typedef set15_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15 > struct set16_c : s_item< integral_c< T,C15 > , set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 > > { typedef set16_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16 > struct set17_c : s_item< integral_c< T,C16 > , set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 > > { typedef set17_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17 > struct set18_c : s_item< integral_c< T,C17 > , set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 > > { typedef set18_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 > struct set19_c : s_item< integral_c< T,C18 > , set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 > > { typedef set19_c type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 > struct set20_c : s_item< integral_c< T,C19 > , set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 > > { typedef set20_c type; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preprocessed/plain/set20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/preproce0000644000175000017500000001024111344301502031521 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set/set20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set11 : s_item< T10 , set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > > { typedef set11 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set12 : s_item< T11 , set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > > { typedef set12 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set13 : s_item< T12 , set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > > { typedef set13 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set14 : s_item< T13 , set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > > { typedef set14 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set15 : s_item< T14 , set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > > { typedef set15 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set16 : s_item< T15 , set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 > > { typedef set16 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set17 : s_item< T16 , set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 > > { typedef set17 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set18 : s_item< T17 , set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 > > { typedef set18 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set19 : s_item< T18 , set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 > > { typedef set19 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set20 : s_item< T19 , set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 > > { typedef set20 type; }; }} ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/key_type_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/key_type0000644000175000017500000000155011344301502031536 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/key_type_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct key_type_impl< aux::set_tag > { template< typename Set, typename T > struct apply { typedef T type; }; }; }} #endif // BOOST_MPL_SET_AUX_KEY_TYPE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/empty_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/empty_im0000644000175000017500000000151611344301502031532 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/empty_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct empty_impl< aux::set_tag > { template< typename Set > struct apply : not_< typename Set::size > { }; }; }} #endif // BOOST_MPL_SET_AUX_EMPTY_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/tag.hpp0000644000175000017500000000120411344301502031242 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED #define BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/tag.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { namespace aux { struct set_tag; }}} #endif // BOOST_MPL_SET_AUX_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/numbered.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/numbered0000644000175000017500000000217711344301502031514 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/numbered.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #define i_ BOOST_PP_FRAME_ITERATION(1) # define AUX778076_SET_TAIL(set, i_, T) \ BOOST_PP_CAT(set,i_)< \ BOOST_PP_ENUM_PARAMS(i_, T) \ > \ /**/ #if i_ > 0 template< BOOST_PP_ENUM_PARAMS(i_, typename T) > struct BOOST_PP_CAT(set,i_) : s_item< BOOST_PP_CAT(T,BOOST_PP_DEC(i_)) , AUX778076_SET_TAIL(set,BOOST_PP_DEC(i_),T) > { typedef BOOST_PP_CAT(set,i_) type; }; #endif # undef AUX778076_SET_TAIL #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/value_type_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/value_ty0000644000175000017500000000156411344301502031542 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/value_type_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct value_type_impl< aux::set_tag > { template< typename Set, typename T > struct apply { typedef T type; }; }; }} #endif // BOOST_MPL_SET_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/has_key_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/has_key_0000644000175000017500000000343411344301502031472 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/has_key_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template<> struct has_key_impl< aux::set_tag > { template< typename Set, typename T > struct apply #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) { BOOST_STATIC_CONSTANT(bool, value = ( sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED( Set , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) ) ) == sizeof(aux::no_tag) ) ); typedef bool_ type; #else // ISO98 C++ : bool_< ( sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED( Set , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) ) ) == sizeof(aux::no_tag) ) > { #endif }; }; }} #endif // BOOST_MPL_SET_AUX_HAS_KEY_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/erase_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/erase_im0000644000175000017500000000200011344301502031460 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/erase_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct erase_impl< aux::set_tag > { template< typename Set , typename Pos , typename unused_ > struct apply : erase_key_impl ::apply { }; }; }} #endif // BOOST_MPL_SET_AUX_ERASE_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/set0.hpp0000644000175000017500000000364411344301502031354 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED #define BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/set0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) # define BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \ friend R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ /**/ # define BOOST_MPL_AUX_SET_OVERLOAD(R, f, X, T) \ BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \ /**/ #else # define BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T) \ static R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ /**/ # define BOOST_MPL_AUX_SET_OVERLOAD(R, f, X, T) \ BOOST_MPL_AUX_SET0_OVERLOAD(R, f, X, T); \ using Base::BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f) \ /**/ #endif template< typename Dummy = na > struct set0 { typedef aux::set_tag tag; typedef void_ last_masked_; typedef void_ item_type_; typedef item_type_ type; typedef long_<0> size; typedef long_<1> order; BOOST_MPL_AUX_SET0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, set0<>, void const volatile* ); BOOST_MPL_AUX_SET0_OVERLOAD( aux::yes_tag, IS_MASKED, set0<>, void const volatile* ); }; }} #endif // BOOST_MPL_SET_AUX_SET0_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/begin_end_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/begin_en0000644000175000017500000000200411344301502031446 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/begin_end_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct begin_impl< aux::set_tag > { template< typename Set > struct apply { typedef s_iter type; }; }; template<> struct end_impl< aux::set_tag > { template< typename Set > struct apply { typedef s_iter< Set,set0<> > type; }; }; }} #endif // BOOST_MPL_SET_AUX_BEGIN_END_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/clear_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/clear_im0000644000175000017500000000156611344301502031467 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/clear_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct clear_impl< aux::set_tag > { template< typename Set > struct apply { typedef set0<> type; }; }; }} #endif // BOOST_MPL_SET_AUX_CLEAR_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/at_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/at_impl.0000644000175000017500000000201711344301502031407 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/at_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template<> struct at_impl< aux::set_tag > { template< typename Set, typename T > struct apply { typedef typename if_< has_key_impl::apply , T , void_ >::type type; }; }; }} #endif // BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/numbered_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/numbered0000644000175000017500000000243711344301502031513 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/numbered_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #define i_ BOOST_PP_FRAME_ITERATION(1) # define AUX778076_SET_C_TAIL(set, i_, T, C) \ BOOST_PP_CAT(BOOST_PP_CAT(set,i_),_c)< \ T BOOST_PP_ENUM_TRAILING_PARAMS(i_, C) \ > \ /**/ template< typename T , BOOST_PP_ENUM_PARAMS(i_, T C) > struct BOOST_PP_CAT(BOOST_PP_CAT(set,i_),_c) : s_item< integral_c , AUX778076_SET_C_TAIL(set,BOOST_PP_DEC(i_), T, C) > { typedef BOOST_PP_CAT(BOOST_PP_CAT(set,i_),_c) type; }; # undef AUX778076_SET_C_TAIL #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/size_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/size_imp0000644000175000017500000000143211344301502031523 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/size_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct size_impl< aux::set_tag > { template< typename Set > struct apply : Set::size { }; }; }} #endif // BOOST_MPL_SET_AUX_SIZE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/insert_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/insert_i0000644000175000017500000000312111344301502031515 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/aux_/insert_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Set, typename T > struct set_insert_impl : eval_if< has_key_impl::apply , identity , eval_if< is_same< T,typename Set::last_masked_ > , base , identity< s_item > > > { }; } template<> struct insert_impl< aux::set_tag > { template< typename Set , typename PosOrKey , typename KeyOrNA > struct apply : aux::set_insert_impl< Set , typename if_na::type > { }; }; }} #endif // BOOST_MPL_SET_AUX_INSERT_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set30_c.hpp0000644000175000017500000000232311344301502030776 0ustar debiandebian #ifndef BOOST_MPL_SET_SET30_C_HPP_INCLUDED #define BOOST_MPL_SET_SET30_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set30_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set30_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET30_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set50.hpp0000644000175000017500000000223711344301502030502 0ustar debiandebian #ifndef BOOST_MPL_SET_SET50_HPP_INCLUDED #define BOOST_MPL_SET_SET50_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set50.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set50.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET50_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set10.hpp0000644000175000017500000000223511344301502030474 0ustar debiandebian #ifndef BOOST_MPL_SET_SET10_HPP_INCLUDED #define BOOST_MPL_SET_SET10_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set10.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set10.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET10_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set40.hpp0000644000175000017500000000223711344301502030501 0ustar debiandebian #ifndef BOOST_MPL_SET_SET40_HPP_INCLUDED #define BOOST_MPL_SET_SET40_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set40.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set40.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET40_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set10_c.hpp0000644000175000017500000000232111344301502030772 0ustar debiandebian #ifndef BOOST_MPL_SET_SET10_C_HPP_INCLUDED #define BOOST_MPL_SET_SET10_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set10_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set10_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET10_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set50_c.hpp0000644000175000017500000000232311344301502031000 0ustar debiandebian #ifndef BOOST_MPL_SET_SET50_C_HPP_INCLUDED #define BOOST_MPL_SET_SET50_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set50_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set50_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET50_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set0.hpp0000644000175000017500000000237011344301502030413 0ustar debiandebian #ifndef BOOST_MPL_SET_SET0_HPP_INCLUDED #define BOOST_MPL_SET_SET0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include //#include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // BOOST_MPL_SET_SET0_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set20_c.hpp0000644000175000017500000000232311344301502030775 0ustar debiandebian #ifndef BOOST_MPL_SET_SET20_C_HPP_INCLUDED #define BOOST_MPL_SET_SET20_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set20_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set20_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET20_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set20.hpp0000644000175000017500000000223711344301502030477 0ustar debiandebian #ifndef BOOST_MPL_SET_SET20_HPP_INCLUDED #define BOOST_MPL_SET_SET20_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/set/set20.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER set20.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_SET_SET20_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/copy.hpp0000644000175000017500000000226411344301501027720 0ustar debiandebian #ifndef BOOST_MPL_COPY_HPP_INCLUDED #define BOOST_MPL_COPY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/copy.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Sequence , typename Inserter > struct copy_impl : fold< Sequence , typename Inserter::state , typename Inserter::operation > { }; template< typename Sequence , typename Inserter > struct reverse_copy_impl : reverse_fold< Sequence , typename Inserter::state , typename Inserter::operation > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(2, copy) }} #endif // BOOST_MPL_COPY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/front.hpp0000644000175000017500000000176111344301501030077 0ustar debiandebian #ifndef BOOST_MPL_FRONT_HPP_INCLUDED #define BOOST_MPL_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/front.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct front : front_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,front,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, front) }} #endif // BOOST_MPL_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_sequence.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_sequence.hp0000644000175000017500000000174511344301501031617 0ustar debiandebian #ifndef BOOST_MPL_EMPTY_SEQUENCE_HPP_INCLUDED #define BOOST_MPL_EMPTY_SEQUENCE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // Copyright Alexander Nasonov 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_sequence.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { struct empty_sequence { struct tag; struct begin { typedef random_access_iterator_tag category; }; typedef begin end; }; template<> struct size_impl { template< typename Sequence > struct apply : int_<0> { }; }; }} #endif // #ifndef BOOST_MPL_EMPTY_SEQUENCE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/int_fwd.hpp0000644000175000017500000000141311344301501030373 0ustar debiandebian #ifndef BOOST_MPL_INT_FWD_HPP_INCLUDED #define BOOST_MPL_INT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/int_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct int_; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(int_) #endif // BOOST_MPL_INT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/index_of.hpp0000644000175000017500000000175111344301501030541 0ustar debiandebian #ifndef BOOST_MPL_INDEX_OF_HPP_INCLUDED #define BOOST_MPL_INDEX_OF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright Eric Friedman 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/index_of.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct index_of : index_if< Sequence,same_as > { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,index_of,(Sequence,T)) }; BOOST_MPL_AUX_NA_SPEC(2, index_of) }} #endif // BOOST_MPL_INDEX_OF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/0000755000175000017500000000000012146213760027216 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/0000755000175000017500000000000012146213760030152 5ustar debiandebian././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/iterato0000644000175000017500000000340411344301502031534 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/iterator.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Node > struct l_iter { typedef aux::l_iter_tag tag; typedef forward_iterator_tag category; }; template< typename Node > struct deref< l_iter > { typedef typename Node::item type; }; template< typename Node > struct next< l_iter > { typedef l_iter< typename Node::next > type; }; #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template< typename Node > struct l_iter { typedef aux::l_iter_tag tag; typedef forward_iterator_tag category; typedef typename Node::item type; typedef l_iter< typename mpl::next::type > next; }; #endif template<> struct l_iter { typedef aux::l_iter_tag tag; typedef forward_iterator_tag category; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) typedef na type; typedef l_iter next; #endif }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, l_iter) }} #endif // BOOST_MPL_LIST_AUX_ITERATOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/push_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/push_fr0000644000175000017500000000200411344301502031526 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/push_front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template<> struct push_front_impl< aux::list_tag > { template< typename List, typename T > struct apply { typedef l_item< typename next::type , T , typename List::type > type; }; }; }} #endif // BOOST_MPL_LIST_AUX_PUSH_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/include_preprocessed.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/include0000644000175000017500000000143611344301502031513 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/include_preprocessed.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! #include #include # define AUX778076_HEADER \ aux_/preprocessed/plain/BOOST_MPL_PREPROCESSED_HEADER \ /**/ # include BOOST_PP_STRINGIZE(boost/mpl/list/AUX778076_HEADER) # undef AUX778076_HEADER #undef BOOST_MPL_PREPROCESSED_HEADER ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/push_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/push_ba0000644000175000017500000000157611344301502031516 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/push_back.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template< typename Tag > struct has_push_back_impl; template<> struct has_push_back_impl< aux::list_tag > { template< typename Seq > struct apply : false_ { }; }; }} #endif // BOOST_MPL_LIST_AUX_PUSH_BACK_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/item.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/item.hp0000644000175000017500000000240011344301502031424 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/item.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename Size , typename T , typename Next > struct l_item { // agurt, 17/jul/03: to facilitate the deficient 'is_sequence' implementation #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) typedef int begin; #endif typedef aux::list_tag tag; typedef l_item type; typedef Size size; typedef T item; typedef Next next; }; struct l_end { #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) typedef int begin; #endif typedef aux::list_tag tag; typedef l_end type; typedef long_<0> size; }; }} #endif // BOOST_MPL_LIST_AUX_NODE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000755000175000017500000000000012146213760031545 5ustar debiandebian././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000755000175000017500000000000012146213760031545 5ustar debiandebian././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000002007311344301502031540 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30 > struct list31 : l_item< long_<31> , T0 , list30< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30 > > { typedef list31 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31 > struct list32 : l_item< long_<32> , T0 , list31< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31 > > { typedef list32 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32 > struct list33 : l_item< long_<33> , T0 , list32< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32 > > { typedef list33 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33 > struct list34 : l_item< long_<34> , T0 , list33< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33 > > { typedef list34 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 > struct list35 : l_item< long_<35> , T0 , list34< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34 > > { typedef list35 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35 > struct list36 : l_item< long_<36> , T0 , list35< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35 > > { typedef list36 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36 > struct list37 : l_item< long_<37> , T0 , list36< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36 > > { typedef list37 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37 > struct list38 : l_item< long_<38> , T0 , list37< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37 > > { typedef list38 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38 > struct list39 : l_item< long_<39> , T0 , list38< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38 > > { typedef list39 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 > struct list40 : l_item< long_<40> , T0 , list39< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39 > > { typedef list40 type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000001431711344301502031544 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20 > struct list21 : l_item< long_<21> , T0 , list20< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20 > > { typedef list21 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21 > struct list22 : l_item< long_<22> , T0 , list21< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21 > > { typedef list22 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22 > struct list23 : l_item< long_<23> , T0 , list22< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22 > > { typedef list23 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23 > struct list24 : l_item< long_<24> , T0 , list23< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23 > > { typedef list24 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 > struct list25 : l_item< long_<25> , T0 , list24< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24 > > { typedef list25 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25 > struct list26 : l_item< long_<26> , T0 , list25< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25 > > { typedef list26 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26 > struct list27 : l_item< long_<27> , T0 , list26< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26 > > { typedef list27 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27 > struct list28 : l_item< long_<28> , T0 , list27< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27 > > { typedef list28 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28 > struct list29 : l_item< long_<29> , T0 , list28< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28 > > { typedef list29 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 > struct list30 : l_item< long_<30> , T0 , list29< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29 > > { typedef list30 type; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list20_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000000756611344301502031554 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list20_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 > struct list11_c : l_item< long_<11> , integral_c< T,C0 > , list10_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > > { typedef list11_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11 > struct list12_c : l_item< long_<12> , integral_c< T,C0 > , list11_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > > { typedef list12_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12 > struct list13_c : l_item< long_<13> , integral_c< T,C0 > , list12_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > > { typedef list13_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13 > struct list14_c : l_item< long_<14> , integral_c< T,C0 > , list13_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 > > { typedef list14_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14 > struct list15_c : l_item< long_<15> , integral_c< T,C0 > , list14_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 > > { typedef list15_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15 > struct list16_c : l_item< long_<16> , integral_c< T,C0 > , list15_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 > > { typedef list16_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16 > struct list17_c : l_item< long_<17> , integral_c< T,C0 > , list16_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 > > { typedef list17_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17 > struct list18_c : l_item< long_<18> , integral_c< T,C0 > , list17_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 > > { typedef list18_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18 > struct list19_c : l_item< long_<19> , integral_c< T,C0 > , list18_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 > > { typedef list19_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19 > struct list20_c : l_item< long_<20> , integral_c< T,C0 > , list19_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 > > { typedef list20_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000001054311344301502031541 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list11 : l_item< long_<11> , T0 , list10< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > > { typedef list11 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list12 : l_item< long_<12> , T0 , list11< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > > { typedef list12 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list13 : l_item< long_<13> , T0 , list12< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > > { typedef list13 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list14 : l_item< long_<14> , T0 , list13< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > > { typedef list14 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list15 : l_item< long_<15> , T0 , list14< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 > > { typedef list15 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list16 : l_item< long_<16> , T0 , list15< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 > > { typedef list16 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list17 : l_item< long_<17> , T0 , list16< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 > > { typedef list17 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list18 : l_item< long_<18> , T0 , list17< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 > > { typedef list18 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list19 : l_item< long_<19> , T0 , list18< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 > > { typedef list19 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list20 : l_item< long_<20> , T0 , list19< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 > > { typedef list20 type; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list30_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000001176411344301502031547 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list30_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 > struct list21_c : l_item< long_<21> , integral_c< T,C0 > , list20_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20 > > { typedef list21_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21 > struct list22_c : l_item< long_<22> , integral_c< T,C0 > , list21_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21 > > { typedef list22_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22 > struct list23_c : l_item< long_<23> , integral_c< T,C0 > , list22_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22 > > { typedef list23_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23 > struct list24_c : l_item< long_<24> , integral_c< T,C0 > , list23_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23 > > { typedef list24_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24 > struct list25_c : l_item< long_<25> , integral_c< T,C0 > , list24_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24 > > { typedef list25_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25 > struct list26_c : l_item< long_<26> , integral_c< T,C0 > , list25_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25 > > { typedef list26_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26 > struct list27_c : l_item< long_<27> , integral_c< T,C0 > , list26_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26 > > { typedef list27_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27 > struct list28_c : l_item< long_<28> , integral_c< T,C0 > , list27_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27 > > { typedef list28_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28 > struct list29_c : l_item< long_<29> , integral_c< T,C0 > , list28_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28 > > { typedef list29_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29 > struct list30_c : l_item< long_<30> , integral_c< T,C0 > , list29_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29 > > { typedef list30_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list50_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000001636011344301502031544 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list50_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 > struct list41_c : l_item< long_<41> , integral_c< T,C0 > , list40_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40 > > { typedef list41_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41 > struct list42_c : l_item< long_<42> , integral_c< T,C0 > , list41_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41 > > { typedef list42_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42 > struct list43_c : l_item< long_<43> , integral_c< T,C0 > , list42_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42 > > { typedef list43_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43 > struct list44_c : l_item< long_<44> , integral_c< T,C0 > , list43_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43 > > { typedef list44_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44 > struct list45_c : l_item< long_<45> , integral_c< T,C0 > , list44_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44 > > { typedef list45_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45 > struct list46_c : l_item< long_<46> , integral_c< T,C0 > , list45_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45 > > { typedef list46_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46 > struct list47_c : l_item< long_<47> , integral_c< T,C0 > , list46_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46 > > { typedef list47_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47 > struct list48_c : l_item< long_<48> , integral_c< T,C0 > , list47_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47 > > { typedef list48_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48 > struct list49_c : l_item< long_<49> , integral_c< T,C0 > , list48_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48 > > { typedef list49_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39, T C40 , T C41, T C42, T C43, T C44, T C45, T C46, T C47, T C48, T C49 > struct list50_c : l_item< long_<50> , integral_c< T,C0 > , list49_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39,C40,C41,C42,C43,C44,C45,C46,C47,C48,C49 > > { typedef list50_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list40_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000001416211344301502031542 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list40_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 > struct list31_c : l_item< long_<31> , integral_c< T,C0 > , list30_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30 > > { typedef list31_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31 > struct list32_c : l_item< long_<32> , integral_c< T,C0 > , list31_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31 > > { typedef list32_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32 > struct list33_c : l_item< long_<33> , integral_c< T,C0 > , list32_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32 > > { typedef list33_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33 > struct list34_c : l_item< long_<34> , integral_c< T,C0 > , list33_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33 > > { typedef list34_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34 > struct list35_c : l_item< long_<35> , integral_c< T,C0 > , list34_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34 > > { typedef list35_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35 > struct list36_c : l_item< long_<36> , integral_c< T,C0 > , list35_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35 > > { typedef list36_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36 > struct list37_c : l_item< long_<37> , integral_c< T,C0 > , list36_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36 > > { typedef list37_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37 > struct list38_c : l_item< long_<38> , integral_c< T,C0 > , list37_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37 > > { typedef list38_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38 > struct list39_c : l_item< long_<39> , integral_c< T,C0 > , list38_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38 > > { typedef list39_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9, T C10 , T C11, T C12, T C13, T C14, T C15, T C16, T C17, T C18, T C19, T C20 , T C21, T C22, T C23, T C24, T C25, T C26, T C27, T C28, T C29, T C30 , T C31, T C32, T C33, T C34, T C35, T C36, T C37, T C38, T C39 > struct list40_c : l_item< long_<40> , integral_c< T,C0 > , list39_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19,C20,C21,C22,C23,C24,C25,C26,C27,C28,C29,C30,C31,C32,C33,C34,C35,C36,C37,C38,C39 > > { typedef list40_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000002364711344301502031552 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40 > struct list41 : l_item< long_<41> , T0 , list40< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40 > > { typedef list41 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41 > struct list42 : l_item< long_<42> , T0 , list41< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41 > > { typedef list42 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42 > struct list43 : l_item< long_<43> , T0 , list42< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42 > > { typedef list43 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43 > struct list44 : l_item< long_<44> , T0 , list43< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43 > > { typedef list44 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 > struct list45 : l_item< long_<45> , T0 , list44< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44 > > { typedef list45 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45 > struct list46 : l_item< long_<46> , T0 , list45< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45 > > { typedef list46 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46 > struct list47 : l_item< long_<47> , T0 , list46< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46 > > { typedef list47 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47 > struct list48 : l_item< long_<48> , T0 , list47< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47 > > { typedef list48 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48 > struct list49 : l_item< long_<49> , T0 , list48< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48 > > { typedef list49 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 , typename T20, typename T21, typename T22, typename T23, typename T24 , typename T25, typename T26, typename T27, typename T28, typename T29 , typename T30, typename T31, typename T32, typename T33, typename T34 , typename T35, typename T36, typename T37, typename T38, typename T39 , typename T40, typename T41, typename T42, typename T43, typename T44 , typename T45, typename T46, typename T47, typename T48, typename T49 > struct list50 : l_item< long_<50> , T0 , list49< T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,T31,T32,T33,T34,T35,T36,T37,T38,T39,T40,T41,T42,T43,T44,T45,T46,T47,T48,T49 > > { typedef list50 type; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000000504711344301502031544 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 > struct list1 : l_item< long_<1> , T0 , l_end > { typedef list1 type; }; template< typename T0, typename T1 > struct list2 : l_item< long_<2> , T0 , list1 > { typedef list2 type; }; template< typename T0, typename T1, typename T2 > struct list3 : l_item< long_<3> , T0 , list2< T1,T2 > > { typedef list3 type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list4 : l_item< long_<4> , T0 , list3< T1,T2,T3 > > { typedef list4 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list5 : l_item< long_<5> , T0 , list4< T1,T2,T3,T4 > > { typedef list5 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list6 : l_item< long_<6> , T0 , list5< T1,T2,T3,T4,T5 > > { typedef list6 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list7 : l_item< long_<7> , T0 , list6< T1,T2,T3,T4,T5,T6 > > { typedef list7 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list8 : l_item< long_<8> , T0 , list7< T1,T2,T3,T4,T5,T6,T7 > > { typedef list8 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list9 : l_item< long_<9> , T0 , list8< T1,T2,T3,T4,T5,T6,T7,T8 > > { typedef list9 type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list10 : l_item< long_<10> , T0 , list9< T1,T2,T3,T4,T5,T6,T7,T8,T9 > > { typedef list10 type; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preprocessed/plain/list10_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/preproc0000644000175000017500000000545311344301502031545 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list/list10_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T , T C0 > struct list1_c : l_item< long_<1> , integral_c< T,C0 > , l_end > { typedef list1_c type; typedef T value_type; }; template< typename T , T C0, T C1 > struct list2_c : l_item< long_<2> , integral_c< T,C0 > , list1_c< T,C1 > > { typedef list2_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2 > struct list3_c : l_item< long_<3> , integral_c< T,C0 > , list2_c< T,C1,C2 > > { typedef list3_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3 > struct list4_c : l_item< long_<4> , integral_c< T,C0 > , list3_c< T,C1,C2,C3 > > { typedef list4_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4 > struct list5_c : l_item< long_<5> , integral_c< T,C0 > , list4_c< T,C1,C2,C3,C4 > > { typedef list5_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5 > struct list6_c : l_item< long_<6> , integral_c< T,C0 > , list5_c< T,C1,C2,C3,C4,C5 > > { typedef list6_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6 > struct list7_c : l_item< long_<7> , integral_c< T,C0 > , list6_c< T,C1,C2,C3,C4,C5,C6 > > { typedef list7_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7 > struct list8_c : l_item< long_<8> , integral_c< T,C0 > , list7_c< T,C1,C2,C3,C4,C5,C6,C7 > > { typedef list8_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8 > struct list9_c : l_item< long_<9> , integral_c< T,C0 > , list8_c< T,C1,C2,C3,C4,C5,C6,C7,C8 > > { typedef list9_c type; typedef T value_type; }; template< typename T , T C0, T C1, T C2, T C3, T C4, T C5, T C6, T C7, T C8, T C9 > struct list10_c : l_item< long_<10> , integral_c< T,C0 > , list9_c< T,C1,C2,C3,C4,C5,C6,C7,C8,C9 > > { typedef list10_c type; typedef T value_type; }; }} ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/empty.h0000644000175000017500000000150011344301502031444 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/empty.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct empty_impl< aux::list_tag > { template< typename List > struct apply : not_ { }; }; }} #endif // BOOST_MPL_LIST_AUX_EMPTY_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/size.hp0000644000175000017500000000141611344301502031446 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/size.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct size_impl< aux::list_tag > { template< typename List > struct apply : List::size { }; }; }} #endif // BOOST_MPL_LIST_AUX_SIZE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/tag.hpp0000644000175000017500000000116611344301502031431 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/tag.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { namespace aux { struct list_tag; struct l_iter_tag; }}} #endif // BOOST_MPL_LIST_AUX_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/numbered.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/numbere0000644000175000017500000000261311344301502031523 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Peter Dimov 2000-2002 // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/numbered.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if defined(BOOST_PP_IS_ITERATING) #include #include #include #include #define i BOOST_PP_FRAME_ITERATION(1) #if i == 1 template< BOOST_PP_ENUM_PARAMS(i, typename T) > struct list1 : l_item< long_<1> , T0 , l_end > { typedef list1 type; }; #else # define MPL_AUX_LIST_TAIL(list, i, T) \ BOOST_PP_CAT(list,BOOST_PP_DEC(i))< \ BOOST_PP_ENUM_SHIFTED_PARAMS(i, T) \ > \ /**/ template< BOOST_PP_ENUM_PARAMS(i, typename T) > struct BOOST_PP_CAT(list,i) : l_item< long_ , T0 , MPL_AUX_LIST_TAIL(list,i,T) > { typedef BOOST_PP_CAT(list,i) type; }; # undef MPL_AUX_LIST_TAIL #endif // i == 1 #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/O1_size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/O1_size0000644000175000017500000000144011344301502031374 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/O1_size.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct O1_size_impl< aux::list_tag > { template< typename List > struct apply : List::size { }; }; }} #endif // BOOST_MPL_LIST_AUX_O1_SIZE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/begin_end.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/begin_e0000644000175000017500000000204211344301502031452 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/begin_end.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template<> struct begin_impl< aux::list_tag > { template< typename List > struct apply { typedef l_iter type; }; }; template<> struct end_impl< aux::list_tag > { template< typename > struct apply { typedef l_iter type; }; }; }} #endif // BOOST_MPL_LIST_AUX_BEGIN_END_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/front.h0000644000175000017500000000145111344301502031443 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct front_impl< aux::list_tag > { template< typename List > struct apply { typedef typename List::item type; }; }; }} #endif // BOOST_MPL_LIST_AUX_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/numbered_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/numbere0000644000175000017500000000301511344301502031520 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/numbered_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if defined(BOOST_PP_IS_ITERATING) #include #include #include #include #define i BOOST_PP_FRAME_ITERATION(1) #if i == 1 template< typename T , BOOST_PP_ENUM_PARAMS(i, T C) > struct list1_c : l_item< long_<1> , integral_c , l_end > { typedef list1_c type; typedef T value_type; }; #else # define MPL_AUX_LIST_C_TAIL(list, i, C) \ BOOST_PP_CAT(BOOST_PP_CAT(list,BOOST_PP_DEC(i)),_c) \ /**/ template< typename T , BOOST_PP_ENUM_PARAMS(i, T C) > struct BOOST_PP_CAT(BOOST_PP_CAT(list,i),_c) : l_item< long_ , integral_c , MPL_AUX_LIST_C_TAIL(list,i,C) > { typedef BOOST_PP_CAT(BOOST_PP_CAT(list,i),_c) type; typedef T value_type; }; # undef MPL_AUX_LIST_C_TAIL #endif // i == 1 #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/clear.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/clear.h0000644000175000017500000000150311344301502031377 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/clear.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct clear_impl< aux::list_tag > { template< typename List > struct apply { typedef l_end type; }; }; }} #endif // BOOST_MPL_LIST_AUX_CLEAR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/pop_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/pop_fro0000644000175000017500000000156011344301502031532 0ustar debiandebian #ifndef BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED #define BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/aux_/pop_front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct pop_front_impl< aux::list_tag > { template< typename List > struct apply { typedef typename mpl::next::type type; }; }; }} #endif // BOOST_MPL_LIST_AUX_POP_FRONT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list40.hpp0000644000175000017500000000220311344301502031032 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST40_HPP_INCLUDED #define BOOST_MPL_LIST_LIST40_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list40.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list40.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST40_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list30.hpp0000644000175000017500000000220311344301502031031 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST30_HPP_INCLUDED #define BOOST_MPL_LIST_LIST30_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list30.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list30.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST30_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list0.hpp0000644000175000017500000000222711344301502030754 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST0_HPP_INCLUDED #define BOOST_MPL_LIST_LIST0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Dummy = na > struct list0; template<> struct list0 : l_end { typedef l_end type; }; }} #endif // BOOST_MPL_LIST_LIST0_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list20_c.hpp0000644000175000017500000000222111344301502031332 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST20_C_HPP_INCLUDED #define BOOST_MPL_LIST_LIST20_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list20_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list20_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST20_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list20.hpp0000644000175000017500000000220311344301502031030 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST20_HPP_INCLUDED #define BOOST_MPL_LIST_LIST20_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list20.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list20.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST20_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list30_c.hpp0000644000175000017500000000222111344301502031333 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST30_C_HPP_INCLUDED #define BOOST_MPL_LIST_LIST30_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list30_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list30_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST30_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list0_c.hpp0000644000175000017500000000136211344301502031255 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST0_C_HPP_INCLUDED #define BOOST_MPL_LIST_LIST0_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list0_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename T > struct list0_c : l_end { typedef l_end type; typedef T value_type; }; }} #endif // BOOST_MPL_LIST_LIST0_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list50_c.hpp0000644000175000017500000000222111344301502031335 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST50_C_HPP_INCLUDED #define BOOST_MPL_LIST_LIST50_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list50_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list50_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST50_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list40_c.hpp0000644000175000017500000000222111344301502031334 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST40_C_HPP_INCLUDED #define BOOST_MPL_LIST_LIST40_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list40_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list40_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST40_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list50.hpp0000644000175000017500000000220311344301502031033 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST50_HPP_INCLUDED #define BOOST_MPL_LIST_LIST50_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list50.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list50.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST50_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list10.hpp0000644000175000017500000000220411344301502031030 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST10_HPP_INCLUDED #define BOOST_MPL_LIST_LIST10_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list10.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list10.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST10_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list10_c.hpp0000644000175000017500000000221711344301502031336 0ustar debiandebian #ifndef BOOST_MPL_LIST_LIST10_C_HPP_INCLUDED #define BOOST_MPL_LIST_LIST10_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/list/list10_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER list10_c.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_LIST_LIST10_C_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/push_front_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/push_front_fwd.hp0000644000175000017500000000126611344301501031616 0ustar debiandebian #ifndef BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED #define BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/push_front_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct push_front_impl; template< typename Sequence, typename T > struct push_front; }} #endif // BOOST_MPL_PUSH_FRONT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/0000755000175000017500000000000012146213760030111 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/0000755000175000017500000000000012146213760031045 5ustar debiandebian././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/item.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/ite0000644000175000017500000000712111344301502031541 0ustar debiandebian #ifndef BOOST_MPL_MULTISET_AUX_ITEM_HPP_INCLUDED #define BOOST_MPL_MULTISET_AUX_ITEM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/item.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # include # include # include #endif namespace boost { namespace mpl { #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) template< typename T, typename Base > struct ms_item { typedef aux::multiset_tag tag; template< typename U > struct prior_count { enum { msvc70_wknd_ = sizeof(Base::key_count(BOOST_MPL_AUX_STATIC_CAST(U*,0))) }; typedef int_< msvc70_wknd_ > count_; typedef typename eval_if< is_same, next, count_ >::type c_; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) typedef typename aux::weighted_tag::type type; #else typedef char (&type)[BOOST_MPL_AUX_MSVC_VALUE_WKND(c_)::value]; #endif }; template< typename U > struct prior_ref_count { typedef U (* u_)(); enum { msvc70_wknd_ = sizeof(Base::ref_key_count(BOOST_MPL_AUX_STATIC_CAST(u_,0))) }; typedef int_< msvc70_wknd_ > count_; typedef typename eval_if< is_same, next, count_ >::type c_; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) typedef typename aux::weighted_tag::type type; #else typedef char (&type)[BOOST_MPL_AUX_MSVC_VALUE_WKND(c_)::value]; #endif }; template< typename U > static typename prior_count::type key_count(U*); template< typename U > static typename prior_ref_count::type ref_key_count(U (*)()); }; #else // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) namespace aux { template< typename U, typename Base > struct prior_key_count { enum { msvc71_wknd_ = sizeof(Base::key_count(BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*,0))) }; typedef int_< msvc71_wknd_ > count_; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) typedef typename aux::weighted_tag< BOOST_MPL_AUX_VALUE_WKND(count_)::value >::type type; #else typedef char (&type)[count_::value]; #endif }; } template< typename T, typename Base > struct ms_item { typedef aux::multiset_tag tag; enum { msvc71_wknd_ = sizeof(Base::key_count(BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*,0))) + 1 }; typedef int_< msvc71_wknd_ > count_; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) static typename aux::weighted_tag< BOOST_MPL_AUX_VALUE_WKND(count_)::value >::type key_count(aux::type_wrapper*); #else static char (& key_count(aux::type_wrapper*) )[count_::value]; #endif template< typename U > static typename aux::prior_key_count::type key_count(aux::type_wrapper*); }; #endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) }} #endif // BOOST_MPL_MULTISET_AUX_ITEM_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/tag.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/tag0000644000175000017500000000116711344301502031537 0ustar debiandebian #ifndef BOOST_MPL_MULTISET_AUX_TAG_HPP_INCLUDED #define BOOST_MPL_MULTISET_AUX_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/tag.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { namespace aux { struct multiset_tag; }}} #endif // BOOST_MPL_MULTISET_AUX_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/multiset0.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/mul0000644000175000017500000000161711344301502031561 0ustar debiandebian #ifndef BOOST_MPL_MULTISET_AUX_MULTISET0_HPP_INCLUDED #define BOOST_MPL_MULTISET_AUX_MULTISET0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/multiset0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< int dummy_ = 0 > struct multiset0 { typedef aux::multiset_tag tag; typedef int_<1> count_; static char (& key_count(...) )[count_::value]; static char (& ref_key_count(...) )[count_::value]; }; }} #endif // BOOST_MPL_MULTISET_AUX_MULTISET0_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/count_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/cou0000644000175000017500000000427711344301502031557 0ustar debiandebian #ifndef BOOST_MPL_MULTISET_AUX_COUNT_IMPL_HPP_INCLUDED #define BOOST_MPL_MULTISET_AUX_COUNT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/count_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # include # include #endif namespace boost { namespace mpl { #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) namespace aux { template< typename S, typename U > struct multiset_count_impl : int_< sizeof(S::key_count(BOOST_MPL_AUX_STATIC_CAST(U*,0))) - 1 > { }; template< typename S, typename U > struct multiset_count_ref_impl { typedef U (* u_)(); typedef int_< sizeof(S::ref_key_count(BOOST_MPL_AUX_STATIC_CAST(u_,0))) - 1 > type_; BOOST_STATIC_CONSTANT(int, value = type_::value); typedef type_ type; }; } template<> struct count_impl< aux::multiset_tag > { template< typename Set, typename Key > struct apply : if_< is_reference , aux::multiset_count_ref_impl , aux::multiset_count_impl >::type { }; }; #else template<> struct count_impl< aux::multiset_tag > { template< typename Set, typename Key > struct apply { enum { msvc71_wknd_ = sizeof(Set::key_count(BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*,0))) - 1 }; typedef int_< msvc71_wknd_ > type; BOOST_STATIC_CONSTANT(int, value = msvc71_wknd_); }; }; #endif // BOOST_WORKAROUND(BOOST_MSVC, <= 1300) }} #endif // BOOST_MPL_MULTISET_AUX_COUNT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/insert_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/ins0000644000175000017500000000164311344301502031554 0ustar debiandebian #ifndef BOOST_MPL_MULTISET_AUX_INSERT_IMPL_HPP_INCLUDED #define BOOST_MPL_MULTISET_AUX_INSERT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/aux_/insert_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct insert_impl< aux::multiset_tag > { template< typename Set, typename Key, typename unused_ > struct apply { typedef ms_item type; }; }; }} #endif // BOOST_MPL_MULTISET_AUX_INSERT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/multiset0.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/multiset0000644000175000017500000000263211344301502031674 0ustar debiandebian #ifndef BOOST_MPL_MULTISET_MULTISET0_HPP_INCLUDED #define BOOST_MPL_MULTISET_MULTISET0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/multiset/multiset0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ //#include //#include //#include //#include //#include //#include //#include //#include //#include //#include #include #include //#include //#include //#include #include #include #include #endif // BOOST_MPL_MULTISET_MULTISET0_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/distance_fwd.hpp0000644000175000017500000000140411344301501031373 0ustar debiandebian #ifndef BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED #define BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/distance_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { BOOST_MPL_AUX_COMMON_NAME_WKND(distance) template< typename Tag > struct distance_impl; template< typename First, typename Last > struct distance; }} #endif // BOOST_MPL_DISTANCE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/less_equal.hpp0000644000175000017500000000120011344301501031070 0ustar debiandebian #ifndef BOOST_MPL_LESS_EQUAL_HPP_INCLUDED #define BOOST_MPL_LESS_EQUAL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/less_equal.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME less_equal #define AUX778076_OP_TOKEN <= #include #endif // BOOST_MPL_LESS_EQUAL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/plus.hpp0000644000175000017500000000114111344301501027722 0ustar debiandebian #ifndef BOOST_MPL_PLUS_HPP_INCLUDED #define BOOST_MPL_PLUS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/plus.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME plus #define AUX778076_OP_TOKEN + #include #endif // BOOST_MPL_PLUS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/equal_to.hpp0000644000175000017500000000116611344301501030557 0ustar debiandebian #ifndef BOOST_MPL_EQUAL_TO_HPP_INCLUDED #define BOOST_MPL_EQUAL_TO_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/equal_to.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME equal_to #define AUX778076_OP_TOKEN == #include #endif // BOOST_MPL_EQUAL_TO_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_category.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_category0000644000175000017500000000164311344301501031706 0ustar debiandebian #ifndef BOOST_MPL_ITERATOR_CATEGORY_HPP_INCLUDED #define BOOST_MPL_ITERATOR_CATEGORY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/iterator_category.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Iterator) > struct iterator_category { typedef typename Iterator::category type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,iterator_category,(Iterator)) }; BOOST_MPL_AUX_NA_SPEC(1, iterator_category) }} #endif // BOOST_MPL_ITERATOR_CATEGORY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/advance_fwd.hpp0000644000175000017500000000137511344301501031211 0ustar debiandebian #ifndef BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED #define BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/advance_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { BOOST_MPL_AUX_COMMON_NAME_WKND(advance) template< typename Tag > struct advance_impl; template< typename Iterator, typename N > struct advance; }} #endif // BOOST_MPL_ADVANCE_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/inserter.hpp0000644000175000017500000000135611344301501030602 0ustar debiandebian #ifndef BOOST_MPL_INSERTER_HPP_INCLUDED #define BOOST_MPL_INSERTER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/inserter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Sequence , typename Operation > struct inserter { typedef Sequence state; typedef Operation operation; }; }} #endif // BOOST_MPL_INSERTER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/clear.hpp0000644000175000017500000000176111344301501030035 0ustar debiandebian #ifndef BOOST_MPL_CLEAR_HPP_INCLUDED #define BOOST_MPL_CLEAR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/clear.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct clear : clear_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,clear,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, clear) }} #endif // BOOST_MPL_CLEAR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_front.hpp0000644000175000017500000000203111344301501030744 0ustar debiandebian #ifndef BOOST_MPL_POP_FRONT_HPP_INCLUDED #define BOOST_MPL_POP_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_front.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct pop_front : pop_front_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,pop_front,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, pop_front) }} #endif // BOOST_MPL_POP_FRONT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/same_as.hpp0000644000175000017500000000231111344301501030347 0ustar debiandebian #ifndef BOOST_MPL_SAME_AS_HPP_INCLUDED #define BOOST_MPL_SAME_AS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/same_as.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename T1 > struct same_as { template< typename T2 > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : is_same { #else { typedef typename is_same::type type; #endif }; }; template< typename T1 > struct not_same_as { template< typename T2 > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : not_< is_same > { #else { typedef typename not_< is_same >::type type; #endif }; }; }} #endif // BOOST_MPL_SAME_AS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/noncopyable.hpp0000644000175000017500000000176611344301501030475 0ustar debiandebian// Boost noncopyable.hpp header file --------------------------------------// // (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/utility for documentation. #ifndef BOOST_NONCOPYABLE_HPP_INCLUDED #define BOOST_NONCOPYABLE_HPP_INCLUDED namespace boost { // Private copy constructor and copy assignment ensure classes derived from // class noncopyable cannot be copied. // Contributed by Dave Abrahams namespace noncopyable_ // protection from unintended ADL { class noncopyable { protected: noncopyable() {} ~noncopyable() {} private: // emphasize the following members are private noncopyable( const noncopyable& ); const noncopyable& operator=( const noncopyable& ); }; } typedef noncopyable_::noncopyable noncopyable; } // namespace boost #endif // BOOST_NONCOPYABLE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/token_iterator.hpp0000644000175000017500000000721011344301501031203 0ustar debiandebian// Boost token_iterator.hpp -------------------------------------------------// // Copyright John R. Bandela 2001 // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/tokenizer for documentation. // Revision History: // 16 Jul 2003 John Bandela // Allowed conversions from convertible base iterators // 03 Jul 2003 John Bandela // Converted to new iterator adapter #ifndef BOOST_TOKENIZER_POLICY_JRB070303_HPP_ #define BOOST_TOKENIZER_POLICY_JRB070303_HPP_ #include #include #include #include #include namespace boost { template class token_iterator : public iterator_facade< token_iterator , Type , typename detail::minimum_category< forward_traversal_tag , typename iterator_traversal::type >::type , const Type& > { friend class iterator_core_access; TokenizerFunc f_; Iterator begin_; Iterator end_; bool valid_; Type tok_; void increment(){ assert(valid_); valid_ = f_(begin_,end_,tok_); } const Type& dereference() const { assert(valid_); return tok_; } template bool equal(const Other& a) const{ return (a.valid_ && valid_) ?( (a.begin_==begin_) && (a.end_ == end_) ) :(a.valid_==valid_); } void initialize(){ if(valid_) return; f_.reset(); valid_ = (begin_ != end_)? f_(begin_,end_,tok_):false; } public: token_iterator():begin_(),end_(),valid_(false),tok_() { } token_iterator(TokenizerFunc f, Iterator begin, Iterator e = Iterator()) : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); } token_iterator(Iterator begin, Iterator e = Iterator()) : f_(),begin_(begin),end_(e),valid_(false),tok_() {initialize();} template token_iterator( token_iterator const& t , typename enable_if_convertible::type* = 0) : f_(t.tokenizer_function()),begin_(t.base()) ,end_(t.end()),valid_(t.at_end()),tok_(t.current_token()) {} Iterator base()const{return begin_;} Iterator end()const{return end_;}; TokenizerFunc tokenizer_function()const{return f_;} Type current_token()const{return tok_;} bool at_end()const{return valid_;} }; template < class TokenizerFunc = char_delimiters_separator, class Iterator = std::string::const_iterator, class Type = std::string > class token_iterator_generator { private: public: typedef token_iterator type; }; // Type has to be first because it needs to be explicitly specified // because there is no way the function can deduce it. template typename token_iterator_generator::type make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){ typedef typename token_iterator_generator::type ret_type; return ret_type(fun,begin,end); } } // namespace boost #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/dynamic_bitset.hpp0000644000175000017500000000116311344301501031151 0ustar debiandebian// -------------------------------------------------- // // (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002. // (C) Copyright Gennaro Prota 2003 - 2004. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // ----------------------------------------------------------- // See http://www.boost.org/libs/dynamic_bitset for documentation. #ifndef BOOST_DYNAMIC_BITSET_HPP #define BOOST_DYNAMIC_BITSET_HPP #include "boost/dynamic_bitset/dynamic_bitset.hpp" #endif // include guard mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/io_fwd.hpp0000644000175000017500000000451511344301501027426 0ustar debiandebian// Boost io_fwd.hpp header file --------------------------------------------// // Copyright 2002 Daryle Walker. Use, modification, and distribution are subject // to the Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or a copy at .) // See for the library's home page. #ifndef BOOST_IO_FWD_HPP #define BOOST_IO_FWD_HPP #include // for std::char_traits (declaration) namespace boost { namespace io { // From -------------------------------------------// class ios_flags_saver; class ios_precision_saver; class ios_width_saver; class ios_base_all_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_iostate_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_exception_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_tie_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_rdbuf_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_fill_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_locale_saver; template < typename Ch, class Tr = ::std::char_traits > class basic_ios_all_saver; typedef basic_ios_iostate_saver ios_iostate_saver; typedef basic_ios_iostate_saver wios_iostate_saver; typedef basic_ios_exception_saver ios_exception_saver; typedef basic_ios_exception_saver wios_exception_saver; typedef basic_ios_tie_saver ios_tie_saver; typedef basic_ios_tie_saver wios_tie_saver; typedef basic_ios_rdbuf_saver ios_rdbuf_saver; typedef basic_ios_rdbuf_saver wios_rdbuf_saver; typedef basic_ios_fill_saver ios_fill_saver; typedef basic_ios_fill_saver wios_fill_saver; typedef basic_ios_locale_saver ios_locale_saver; typedef basic_ios_locale_saver wios_locale_saver; typedef basic_ios_all_saver ios_all_saver; typedef basic_ios_all_saver wios_all_saver; class ios_iword_saver; class ios_pword_saver; class ios_all_word_saver; } // namespace io } // namespace boost #endif // BOOST_IO_FWD_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/call_traits.hpp0000644000175000017500000000140511344301501030453 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/utility for most recent version including documentation. // See boost/detail/call_traits.hpp and boost/detail/ob_call_traits.hpp // for full copyright notices. #ifndef BOOST_CALL_TRAITS_HPP #define BOOST_CALL_TRAITS_HPP #ifndef BOOST_CONFIG_HPP #include #endif #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #include #else #include #endif #endif // BOOST_CALL_TRAITS_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/0000755000175000017500000000000012146213742026720 5ustar debiandebian././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/requires_threads.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/requires_threa0000644000175000017500000000666311344301501031666 0ustar debiandebian// (C) Copyright John Maddock 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_CONFIG_REQUIRES_THREADS_HPP #define BOOST_CONFIG_REQUIRES_THREADS_HPP #ifndef BOOST_CONFIG_HPP # include #endif #if defined(BOOST_DISABLE_THREADS) // // special case to handle versions of gcc which don't currently support threads: // #if defined(__GNUC__) && ((__GNUC__ < 3) || (__GNUC_MINOR__ <= 3) || !defined(BOOST_STRICT_CONFIG)) // // this is checked up to gcc 3.3: // #if defined(__sgi) || defined(__hpux) # error "Multi-threaded programs are not supported by gcc on HPUX or Irix (last checked with gcc 3.3)" #endif #endif # error "Threading support unavaliable: it has been explicitly disabled with BOOST_DISABLE_THREADS" #elif !defined(BOOST_HAS_THREADS) # if defined __COMO__ // Comeau C++ # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_MT (Windows) or -D_REENTRANT (Unix)" #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) // Intel #ifdef _WIN32 # error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd" #else # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -openmp" #endif # elif defined __GNUC__ // GNU C++: # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread (Linux), -pthreads (Solaris) or -mthreads (Mingw32)" #elif defined __sgi // SGI MIPSpro C++ # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -D_SGI_MP_SOURCE" #elif defined __DECCXX // Compaq Tru64 Unix cxx # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -pthread" #elif defined __BORLANDC__ // Borland # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -tWM" #elif defined __MWERKS__ // Metrowerks CodeWarrior # error "Compiler threading support is not turned on. Please set the correct command line options for threading: either -runtime sm, -runtime smd, -runtime dm, or -runtime dmd" #elif defined __SUNPRO_CC // Sun Workshop Compiler C++ # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt" #elif defined __HP_aCC // HP aCC # error "Compiler threading support is not turned on. Please set the correct command line options for threading: -mt" #elif defined(__IBMCPP__) // IBM Visual Age # error "Compiler threading support is not turned on. Please compile the code with the xlC_r compiler" #elif defined _MSC_VER // Microsoft Visual C++ // // Must remain the last #elif since some other vendors (Metrowerks, for // example) also #define _MSC_VER # error "Compiler threading support is not turned on. Please set the correct command line options for threading: either /MT /MTd /MD or /MDd" #else # error "Compiler threading support is not turned on. Please consult your compiler's documentation for the appropriate options to use" #endif // compilers #endif // BOOST_HAS_THREADS #endif // BOOST_CONFIG_REQUIRES_THREADS_HPP ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/select_stdlib_config.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/select_stdlib_0000644000175000017500000000452211344301501031613 0ustar debiandebian// Boost compiler configuration selection header file // (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2001 - 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // locate which std lib we are using and define BOOST_STDLIB_CONFIG as needed: // we need to include a std lib header here in order to detect which // library is in use, use as it's about the smallest // of the std lib headers - do not rely on this header being included - // users can short-circuit this header if they know whose std lib // they are using. #include #if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) // STLPort library; this _must_ come first, otherwise since // STLport typically sits on top of some other library, we // can end up detecting that first rather than STLport: # define BOOST_STDLIB_CONFIG "boost/config/stdlib/stlport.hpp" #elif defined(__LIBCOMO__) // Comeau STL: #define BOOST_STDLIB_CONFIG "boost/config/stdlib/libcomo.hpp" #elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER) // Rogue Wave library: # define BOOST_STDLIB_CONFIG "boost/config/stdlib/roguewave.hpp" #elif defined(__GLIBCPP__) || defined(__GLIBCXX__) // GNU libstdc++ 3 # define BOOST_STDLIB_CONFIG "boost/config/stdlib/libstdcpp3.hpp" #elif defined(__STL_CONFIG_H) // generic SGI STL # define BOOST_STDLIB_CONFIG "boost/config/stdlib/sgi.hpp" #elif defined(__MSL_CPP__) // MSL standard lib: # define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp" #elif defined(__IBMCPP__) // take the default VACPP std lib # define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp" #elif defined(MSIPL_COMPILE_H) // Modena C++ standard library # define BOOST_STDLIB_CONFIG "boost/config/stdlib/modena.hpp" #elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER) // Dinkumware Library (this has to appear after any possible replacement libraries): # define BOOST_STDLIB_CONFIG "boost/config/stdlib/dinkumware.hpp" #elif defined (BOOST_ASSERT_CONFIG) // this must come last - generate an error if we don't // recognise the library: # error "Unknown standard library - please configure and report the results to boost.org" #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/posix_features.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/posix_features0000644000175000017500000000667611344301501031710 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // All POSIX feature tests go in this file, // Note that we test _POSIX_C_SOURCE and _XOPEN_SOURCE as well // _POSIX_VERSION and _XOPEN_VERSION: on some systems POSIX API's // may be present but none-functional unless _POSIX_C_SOURCE and // _XOPEN_SOURCE have been defined to the right value (it's up // to the user to do this *before* including any header, although // in most cases the compiler will do this for you). # if defined(BOOST_HAS_UNISTD_H) # include // XOpen has , but is this the correct version check? # if defined(_XOPEN_VERSION) && (_XOPEN_VERSION >= 3) # define BOOST_HAS_NL_TYPES_H # endif // POSIX version 6 requires # if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 200100) # define BOOST_HAS_STDINT_H # endif // POSIX version 2 requires # if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199009L) # define BOOST_HAS_DIRENT_H # endif // POSIX version 3 requires to have sigaction: # if defined(_POSIX_VERSION) && (_POSIX_VERSION >= 199506L) # define BOOST_HAS_SIGACTION # endif // POSIX defines _POSIX_THREADS > 0 for pthread support, // however some platforms define _POSIX_THREADS without // a value, hence the (_POSIX_THREADS+0 >= 0) check. // Strictly speaking this may catch platforms with a // non-functioning stub , but such occurrences should // occur very rarely if at all. # if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_MPTASKS) # define BOOST_HAS_PTHREADS # endif // BOOST_HAS_NANOSLEEP: // This is predicated on _POSIX_TIMERS or _XOPEN_REALTIME: # if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) \ || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0)) # define BOOST_HAS_NANOSLEEP # endif // BOOST_HAS_CLOCK_GETTIME: // This is predicated on _POSIX_TIMERS (also on _XOPEN_REALTIME // but at least one platform - linux - defines that flag without // defining clock_gettime): # if (defined(_POSIX_TIMERS) && (_POSIX_TIMERS+0 >= 0)) # define BOOST_HAS_CLOCK_GETTIME # endif // BOOST_HAS_SCHED_YIELD: // This is predicated on _POSIX_PRIORITY_SCHEDULING or // on _POSIX_THREAD_PRIORITY_SCHEDULING or on _XOPEN_REALTIME. # if defined(_POSIX_PRIORITY_SCHEDULING) && (_POSIX_PRIORITY_SCHEDULING+0 > 0)\ || (defined(_POSIX_THREAD_PRIORITY_SCHEDULING) && (_POSIX_THREAD_PRIORITY_SCHEDULING+0 > 0))\ || (defined(_XOPEN_REALTIME) && (_XOPEN_REALTIME+0 >= 0)) # define BOOST_HAS_SCHED_YIELD # endif // BOOST_HAS_GETTIMEOFDAY: // BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE: // These are predicated on _XOPEN_VERSION, and appears to be first released // in issue 4, version 2 (_XOPEN_VERSION > 500). # if defined(_XOPEN_VERSION) && (_XOPEN_VERSION+0 >= 500) # define BOOST_HAS_GETTIMEOFDAY # if defined(_XOPEN_SOURCE) && (_XOPEN_SOURCE+0 >= 500) # define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE # endif # endif # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/0000755000175000017500000000000012146213743030202 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/sgi.hpp0000644000175000017500000000606611344301501031472 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Darin Adler 2001. // (C) Copyright Jens Maurer 2001 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // generic SGI STL: #if !defined(__STL_CONFIG_H) # include # if !defined(__STL_CONFIG_H) # error "This is not the SGI STL!" # endif #endif // // No std::iterator traits without partial specialisation: // #if !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) # define BOOST_NO_STD_ITERATOR_TRAITS #endif // // No std::stringstream with gcc < 3 // #if defined(__GNUC__) && (__GNUC__ < 3) && \ ((__GNUC_MINOR__ < 95) || (__GNUC_MINOR__ == 96)) && \ !defined(__STL_USE_NEW_IOSTREAMS) || \ defined(__APPLE_CC__) // Note that we only set this for GNU C++ prior to 2.95 since the // latest patches for that release do contain a minimal // If you are running a 2.95 release prior to 2.95.3 then this will need // setting, but there is no way to detect that automatically (other // than by running the configure script). // Also, the unofficial GNU C++ 2.96 included in RedHat 7.1 doesn't // have . # define BOOST_NO_STRINGSTREAM #endif // // Assume no std::locale without own iostreams (this may be an // incorrect assumption in some cases): // #if !defined(__SGI_STL_OWN_IOSTREAMS) && !defined(__STL_USE_NEW_IOSTREAMS) # define BOOST_NO_STD_LOCALE #endif // // Original native SGI streams have non-standard std::messages facet: // #if defined(__sgi) && (_COMPILER_VERSION <= 650) && !defined(__SGI_STL_OWN_IOSTREAMS) # define BOOST_NO_STD_LOCALE #endif // // SGI's new iostreams have missing "const" in messages<>::open // #if defined(__sgi) && (_COMPILER_VERSION <= 740) && defined(__STL_USE_NEW_IOSTREAMS) # define BOOST_NO_STD_MESSAGES #endif // // No template iterator constructors, or std::allocator // without member templates: // #if !defined(__STL_MEMBER_TEMPLATES) # define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS # define BOOST_NO_STD_ALLOCATOR #endif // // We always have SGI style hash_set, hash_map, and slist: // #define BOOST_HAS_HASH #define BOOST_HAS_SLIST // // If this is GNU libstdc++2, then no and no std::wstring: // #if (defined(__GNUC__) && (__GNUC__ < 3)) # include # if defined(__BASTRING__) # define BOOST_NO_LIMITS // Note: will provide compile-time constants # undef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS # define BOOST_NO_STD_WSTRING # endif #endif // // There is no standard iterator unless we have namespace support: // #if !defined(__STL_USE_NAMESPACES) # define BOOST_NO_STD_ITERATOR #endif // // Intrinsic type_traits support. // The SGI STL has it's own __type_traits class, which // has intrinsic compiler support with SGI's compilers. // Whatever map SGI style type traits to boost equivalents: // #define BOOST_HAS_SGI_TYPE_TRAITS #define BOOST_STDLIB "SGI standard library" ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/vacpp.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/vacpp.h0000644000175000017500000000074411344301501031456 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. #if __IBMCPP__ <= 501 # define BOOST_NO_STD_ALLOCATOR #endif #define BOOST_HAS_MACRO_USE_FACET #define BOOST_NO_STD_MESSAGES #define BOOST_STDLIB "Visual Age default standard library" mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/msl.hpp0000644000175000017500000000217711344301501031502 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright Darin Adler 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Metrowerks standard library: #ifndef __MSL_CPP__ # include # ifndef __MSL_CPP__ # error This is not the MSL standard library! # endif #endif #if __MSL_CPP__ >= 0x6000 // Pro 6 # define BOOST_HAS_HASH # define BOOST_STD_EXTENSION_NAMESPACE Metrowerks #endif #define BOOST_HAS_SLIST #if __MSL_CPP__ < 0x6209 # define BOOST_NO_STD_MESSAGES #endif // check C lib version for #include #if defined(__MSL__) && (__MSL__ >= 0x5000) # define BOOST_HAS_STDINT_H # if !defined(__PALMOS_TRAPS__) # define BOOST_HAS_UNISTD_H # endif // boilerplate code: # include #endif #if defined(_MWMT) || _MSL_THREADSAFE # define BOOST_HAS_THREADS #endif #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__) ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/libcomo.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/libcomo0000644000175000017500000000236111344301501031540 0ustar debiandebian// (C) Copyright John Maddock 2002 - 2003. // (C) Copyright Jens Maurer 2002 - 2003. // (C) Copyright Beman Dawes 2002 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Comeau STL: #if !defined(__LIBCOMO__) # include # if !defined(__LIBCOMO__) # error "This is not the Comeau STL!" # endif #endif // // std::streambuf is non-standard // NOTE: versions of libcomo prior to beta28 have octal version numbering, // e.g. version 25 is 21 (dec) #if __LIBCOMO_VERSION__ <= 22 # define BOOST_NO_STD_WSTREAMBUF #endif #if (__LIBCOMO_VERSION__ <= 31) && defined(_WIN32) #define BOOST_NO_SWPRINTF #endif #if __LIBCOMO_VERSION__ >= 31 # define BOOST_HAS_HASH # define BOOST_HAS_SLIST #endif // // Intrinsic type_traits support. // The SGI STL has it's own __type_traits class, which // has intrinsic compiler support with SGI's compilers. // Whatever map SGI style type traits to boost equivalents: // #define BOOST_HAS_SGI_TYPE_TRAITS #define BOOST_STDLIB "Comeau standard library " BOOST_STRINGIZE(__LIBCOMO_VERSION__) ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/roguewave.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/roguewa0000644000175000017500000000711411344301501031566 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2001. // (C) Copyright David Abrahams 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Rogue Wave std lib: #if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER) # include # if !defined(__STD_RWCOMPILER_H__) && !defined(_RWSTD_VER) # error This is not the Rogue Wave standard library # endif #endif // // figure out a consistent version number: // #ifndef _RWSTD_VER # define BOOST_RWSTD_VER 0x010000 #elif _RWSTD_VER < 0x010000 # define BOOST_RWSTD_VER (_RWSTD_VER << 8) #else # define BOOST_RWSTD_VER _RWSTD_VER #endif #ifndef _RWSTD_VER # define BOOST_STDLIB "Rogue Wave standard library version (Unknown version)" #else # define BOOST_STDLIB "Rogue Wave standard library version " BOOST_STRINGIZE(_RWSTD_VER) #endif // // Prior to version 2.2.0 the primary template for std::numeric_limits // does not have compile time constants, even though specializations of that // template do: // #if BOOST_RWSTD_VER < 0x020200 # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #endif // Sun CC 5.5 patch 113817-07 adds long long specialization, but does not change the // library version number (http://sunsolve6.sun.com/search/document.do?assetkey=1-21-113817): #if BOOST_RWSTD_VER <= 0x020101 && (!defined(__SUNPRO_CC) || (__SUNPRO_CC < 0x550)) # define BOOST_NO_LONG_LONG_NUMERIC_LIMITS # endif // // Borland version of numeric_limits lacks __int64 specialisation: // #ifdef __BORLANDC__ # define BOOST_NO_MS_INT64_NUMERIC_LIMITS #endif // // No std::iterator if it can't figure out default template args: // #if defined(_RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || defined(RWSTD_NO_SIMPLE_DEFAULT_TEMPLATES) || (BOOST_RWSTD_VER < 0x020000) # define BOOST_NO_STD_ITERATOR #endif // // No iterator traits without partial specialization: // #if defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) || defined(RWSTD_NO_CLASS_PARTIAL_SPEC) # define BOOST_NO_STD_ITERATOR_TRAITS #endif // // Prior to version 2.0, std::auto_ptr was buggy, and there were no // new-style iostreams, and no conformant std::allocator: // #if (BOOST_RWSTD_VER < 0x020000) # define BOOST_NO_AUTO_PTR # define BOOST_NO_STRINGSTREAM # define BOOST_NO_STD_ALLOCATOR # define BOOST_NO_STD_LOCALE #endif // // No template iterator constructors without member template support: // #if defined(RWSTD_NO_MEMBER_TEMPLATES) || defined(_RWSTD_NO_MEMBER_TEMPLATES) # define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS #endif // // RW defines _RWSTD_ALLOCATOR if the allocator is conformant and in use // (the or _HPACC_ part is a hack - the library seems to define _RWSTD_ALLOCATOR // on HP aCC systems even though the allocator is in fact broken): // #if !defined(_RWSTD_ALLOCATOR) || (defined(__HP_aCC) && __HP_aCC <= 33100) # define BOOST_NO_STD_ALLOCATOR #endif // // If we have a std::locale, we still may not have std::use_facet: // #if defined(_RWSTD_NO_TEMPLATE_ON_RETURN_TYPE) && !defined(BOOST_NO_STD_LOCALE) # define BOOST_NO_STD_USE_FACET # define BOOST_HAS_TWO_ARG_USE_FACET #endif // // There's no std::distance prior to version 2, or without // partial specialization support: // #if (BOOST_RWSTD_VER < 0x020000) || defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) #define BOOST_NO_STD_DISTANCE #endif // // Some versions of the rogue wave library don't have assignable // OutputIterators: // #if BOOST_RWSTD_VER < 0x020100 # define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/stlport.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/stlport0000644000175000017500000001440111344301501031621 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2002. // (C) Copyright Darin Adler 2001. // (C) Copyright Jens Maurer 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // STLPort standard library config: #if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) # include # if !defined(__SGI_STL_PORT) && !defined(_STLPORT_VERSION) # error "This is not STLPort!" # endif #endif // // __STL_STATIC_CONST_INIT_BUG implies BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS // for versions prior to 4.1(beta) // #if (defined(__STL_STATIC_CONST_INIT_BUG) || defined(_STLP_STATIC_CONST_INIT_BUG)) && (__SGI_STL_PORT <= 0x400) # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #endif // // If STLport thinks that there is no partial specialisation, then there is no // std::iterator traits: // #if !(defined(_STLP_CLASS_PARTIAL_SPECIALIZATION) || defined(__STL_CLASS_PARTIAL_SPECIALIZATION)) # define BOOST_NO_STD_ITERATOR_TRAITS #endif // // No new style iostreams on GCC without STLport's iostreams enabled: // #if (defined(__GNUC__) && (__GNUC__ < 3)) && !(defined(__SGI_STL_OWN_IOSTREAMS) || defined(_STLP_OWN_IOSTREAMS)) # define BOOST_NO_STRINGSTREAM #endif // // No new iostreams implies no std::locale, and no std::stringstream: // #if defined(__STL_NO_IOSTREAMS) || defined(__STL_NO_NEW_IOSTREAMS) || defined(_STLP_NO_IOSTREAMS) || defined(_STLP_NO_NEW_IOSTREAMS) # define BOOST_NO_STD_LOCALE # define BOOST_NO_STRINGSTREAM #endif // // If the streams are not native, and we have a "using ::x" compiler bug // then the io stream facets are not available in namespace std:: // #ifdef _STLPORT_VERSION # if !defined(_STLP_OWN_IOSTREAMS) && defined(_STLP_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__) # define BOOST_NO_STD_LOCALE # endif #else # if !defined(__SGI_STL_OWN_IOSTREAMS) && defined(__STL_USE_NAMESPACES) && defined(BOOST_NO_USING_TEMPLATE) && !defined(__BORLANDC__) # define BOOST_NO_STD_LOCALE # endif #endif // // Without member template support enabled, their are no template // iterate constructors, and no std::allocator: // #if !(defined(__STL_MEMBER_TEMPLATES) || defined(_STLP_MEMBER_TEMPLATES)) # define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS # define BOOST_NO_STD_ALLOCATOR #endif // // however we always have at least a partial allocator: // #define BOOST_HAS_PARTIAL_STD_ALLOCATOR #if !defined(_STLP_MEMBER_TEMPLATE_CLASSES) # define BOOST_NO_STD_ALLOCATOR #endif #if defined(_STLP_NO_MEMBER_TEMPLATE_KEYWORD) && defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) # define BOOST_NO_STD_ALLOCATOR #endif // // If STLport thinks there is no wchar_t at all, then we have to disable // the support for the relevant specilazations of std:: templates. // #if !defined(_STLP_HAS_WCHAR_T) && !defined(_STLP_WCHAR_T_IS_USHORT) # ifndef BOOST_NO_STD_WSTRING # define BOOST_NO_STD_WSTRING # endif # ifndef BOOST_NO_STD_WSTREAMBUF # define BOOST_NO_STD_WSTREAMBUF # endif #endif // // We always have SGI style hash_set, hash_map, and slist: // #define BOOST_HAS_HASH #define BOOST_HAS_SLIST // // STLport does a good job of importing names into namespace std::, // but doesn't always get them all, define BOOST_NO_STDC_NAMESPACE, since our // workaround does not conflict with STLports: // // // Harold Howe says: // Borland switched to STLport in BCB6. Defining BOOST_NO_STDC_NAMESPACE with // BCB6 does cause problems. If we detect C++ Builder, then don't define // BOOST_NO_STDC_NAMESPACE // #if !defined(__BORLANDC__) && !defined(__DMC__) // // If STLport is using it's own namespace, and the real names are in // the global namespace, then we duplicate STLport's using declarations // (by defining BOOST_NO_STDC_NAMESPACE), we do this because STLport doesn't // necessarily import all the names we need into namespace std:: // # if (defined(__STL_IMPORT_VENDOR_CSTD) \ || defined(__STL_USE_OWN_NAMESPACE) \ || defined(_STLP_IMPORT_VENDOR_CSTD) \ || defined(_STLP_USE_OWN_NAMESPACE)) \ && (defined(__STL_VENDOR_GLOBAL_CSTD) || defined (_STLP_VENDOR_GLOBAL_CSTD)) # define BOOST_NO_STDC_NAMESPACE # define BOOST_NO_EXCEPTION_STD_NAMESPACE # endif #elif defined(__BORLANDC__) && __BORLANDC__ < 0x560 // STLport doesn't import std::abs correctly: #include namespace std { using ::abs; } // and strcmp/strcpy don't get imported either ('cos they are macros) #include #ifdef strcpy # undef strcpy #endif #ifdef strcmp # undef strcmp #endif #ifdef _STLP_VENDOR_CSTD namespace std{ using _STLP_VENDOR_CSTD::strcmp; using _STLP_VENDOR_CSTD::strcpy; } #endif #endif // // std::use_facet may be non-standard, uses a class instead: // #if defined(__STL_NO_EXPLICIT_FUNCTION_TMPL_ARGS) || defined(_STLP_NO_EXPLICIT_FUNCTION_TMPL_ARGS) # define BOOST_NO_STD_USE_FACET # define BOOST_HAS_STLP_USE_FACET #endif // // If STLport thinks there are no wide functions, etc. is not working; but // only if BOOST_NO_STDC_NAMESPACE is not defined (if it is then we do the import // into std:: ourselves). // #if defined(_STLP_NO_NATIVE_WIDE_FUNCTIONS) && !defined(BOOST_NO_STDC_NAMESPACE) # define BOOST_NO_CWCHAR # define BOOST_NO_CWCTYPE #endif // // If STLport for some reason was configured so that it thinks that wchar_t // is not an intrinsic type, then we have to disable the support for it as // well (we would be missing required specializations otherwise). // #if !defined( _STLP_HAS_WCHAR_T) || defined(_STLP_WCHAR_T_IS_USHORT) # undef BOOST_NO_INTRINSIC_WCHAR_T # define BOOST_NO_INTRINSIC_WCHAR_T #endif // // Borland ships a version of STLport with C++ Builder 6 that lacks // hashtables and the like: // #if defined(__BORLANDC__) && (__BORLANDC__ == 0x560) # undef BOOST_HAS_HASH #endif // // gcc-2.95.3/STLPort does not like the using declarations we use to get ADL with std::min/max // #if defined(__GNUC__) && (__GNUC__ < 3) # include // for std::min and std::max # define BOOST_USING_STD_MIN() ((void)0) # define BOOST_USING_STD_MAX() ((void)0) namespace boost { using std::min; using std::max; } #endif #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT) ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/dinkumware.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/dinkumw0000644000175000017500000000700511344301501031572 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2001. // (C) Copyright Peter Dimov 2001. // (C) Copyright David Abrahams 2002. // (C) Copyright Guillaume Melquiond 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Dinkumware standard library config: #if !defined(_YVALS) && !defined(_CPPLIB_VER) #include #if !defined(_YVALS) && !defined(_CPPLIB_VER) #error This is not the Dinkumware lib! #endif #endif #if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 306) // full dinkumware 3.06 and above // fully conforming provided the compiler supports it: # if !(defined(_GLOBAL_USING) && (_GLOBAL_USING+0 > 0)) && !defined(__BORLANDC__) && !defined(_STD) && !(defined(__ICC) && (__ICC >= 700)) // can be defined in yvals.h # define BOOST_NO_STDC_NAMESPACE # endif # if !(defined(_HAS_MEMBER_TEMPLATES_REBIND) && (_HAS_MEMBER_TEMPLATES_REBIND+0 > 0)) && !(defined(_MSC_VER) && (_MSC_VER > 1300)) && defined(BOOST_MSVC) # define BOOST_NO_STD_ALLOCATOR # endif # define BOOST_HAS_PARTIAL_STD_ALLOCATOR # if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) // if this lib version is set up for vc6 then there is no std::use_facet: # define BOOST_NO_STD_USE_FACET # define BOOST_HAS_TWO_ARG_USE_FACET // C lib functions aren't in namespace std either: # define BOOST_NO_STDC_NAMESPACE // and nor is # define BOOST_NO_EXCEPTION_STD_NAMESPACE # endif // There's no numeric_limits support unless _LONGLONG is defined: # if !defined(_LONGLONG) && (_CPPLIB_VER <= 310) # define BOOST_NO_MS_INT64_NUMERIC_LIMITS # endif // 3.06 appears to have (non-sgi versions of) & , // and no at all #else # define BOOST_MSVC_STD_ITERATOR 1 # define BOOST_NO_STD_ITERATOR # define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS # define BOOST_NO_STD_ALLOCATOR # define BOOST_NO_STDC_NAMESPACE # define BOOST_NO_STD_USE_FACET # define BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN # define BOOST_HAS_MACRO_USE_FACET # ifndef _CPPLIB_VER // Updated Dinkum library defines this, and provides // its own min and max definitions. # define BOOST_NO_STD_MIN_MAX # define BOOST_NO_MS_INT64_NUMERIC_LIMITS # endif #endif // // std extension namespace is stdext for vc7.1 and later, // the same applies to other compilers that sit on top // of vc7.1 (Intel and Comeau): // #if defined(_MSC_VER) && (_MSC_VER >= 1310) && !defined(__BORLANDC__) # define BOOST_STD_EXTENSION_NAMESPACE stdext #endif #if (defined(_MSC_VER) && (_MSC_VER <= 1300) && !defined(__BORLANDC__)) || !defined(_CPPLIB_VER) || (_CPPLIB_VER < 306) // if we're using a dinkum lib that's // been configured for VC6/7 then there is // no iterator traits (true even for icl) # define BOOST_NO_STD_ITERATOR_TRAITS #endif #if defined(__ICL) && (__ICL < 800) && defined(_CPPLIB_VER) && (_CPPLIB_VER <= 310) // Intel C++ chokes over any non-trivial use of // this may be an overly restrictive define, but regex fails without it: # define BOOST_NO_STD_LOCALE #endif #ifdef _CPPLIB_VER # define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER #else # define BOOST_DINKUMWARE_STDLIB 1 #endif #ifdef _CPPLIB_VER # define BOOST_STDLIB "Dinkumware standard library version " BOOST_STRINGIZE(_CPPLIB_VER) #else # define BOOST_STDLIB "Dinkumware standard library version 1.x" #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/modena.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/modena.0000644000175000017500000000123411344301501031433 0ustar debiandebian// (C) Copyright Jens Maurer 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Modena C++ standard library (comes with KAI C++) #if !defined(MSIPL_COMPILE_H) # include # if !defined(__MSIPL_COMPILE_H) # error "This is not the Modena C++ library!" # endif #endif #ifndef MSIPL_NL_TYPES #define BOOST_NO_STD_MESSAGES #endif #ifndef MSIPL_WCHART #define BOOST_NO_STD_WSTRING #endif #define BOOST_STDLIB "Modena C++ standard library" ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/libstdcpp3.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/stdlib/libstdc0000644000175000017500000000317411344301501031543 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright Jens Maurer 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // config for libstdc++ v3 // not much to go in here: #ifdef __GLIBCXX__ #define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCXX__) #else #define BOOST_STDLIB "GNU libstdc++ version " BOOST_STRINGIZE(__GLIBCPP__) #endif #if !defined(_GLIBCPP_USE_WCHAR_T) && !defined(_GLIBCXX_USE_WCHAR_T) # define BOOST_NO_CWCHAR # define BOOST_NO_CWCTYPE # define BOOST_NO_STD_WSTRING # define BOOST_NO_STD_WSTREAMBUF #endif #if defined(__osf__) && !defined(_REENTRANT) && defined(_GLIBCXX_HAVE_GTHR_DEFAULT) // GCC 3.4 on Tru64 forces the definition of _REENTRANT when any std lib header // file is included, therefore for consistency we define it here as well. # define _REENTRANT #endif #ifdef __GLIBCXX__ // gcc 3.4 and greater: # ifdef _GLIBCXX_HAVE_GTHR_DEFAULT // // If the std lib has thread support turned on, then turn it on in Boost // as well. We do this because some gcc-3.4 std lib headers define _REENTANT // while others do not... // # define BOOST_HAS_THREADS # else # define BOOST_DISABLE_THREADS # endif #endif #if !defined(_GLIBCPP_USE_LONG_LONG) \ && !defined(_GLIBCXX_USE_LONG_LONG)\ && defined(BOOST_HAS_LONG_LONG) // May have been set by compiler/*.hpp, but "long long" without library // support is useless. # undef BOOST_HAS_LONG_LONG #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/suffix.hpp0000644000175000017500000004211511344301501030726 0ustar debiandebian// Boost config.hpp configuration header file ------------------------------// // (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Darin Adler 2001. // (C) Copyright Peter Dimov 2001. // (C) Copyright Bill Kempf 2002. // (C) Copyright Jens Maurer 2002. // (C) Copyright David Abrahams 2002 - 2003. // (C) Copyright Gennaro Prota 2003. // (C) Copyright Eric Friedman 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Boost config.hpp policy and rationale documentation has been moved to // http://www.boost.org/libs/config // // This file is intended to be stable, and relatively unchanging. // It should contain boilerplate code only - no compiler specific // code unless it is unavoidable - no changes unless unavoidable. #ifndef BOOST_CONFIG_SUFFIX_HPP #define BOOST_CONFIG_SUFFIX_HPP // // look for long long by looking for the appropriate macros in . // Note that we use limits.h rather than climits for maximal portability, // remember that since these just declare a bunch of macros, there should be // no namespace issues from this. // #include # if !defined(BOOST_HAS_LONG_LONG) \ && !(defined(BOOST_MSVC) && BOOST_MSVC <=1300) && !defined(__BORLANDC__) \ && (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) # define BOOST_HAS_LONG_LONG #endif #if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_INTEGRAL_INT64_T) # define BOOST_NO_INTEGRAL_INT64_T #endif // GCC 3.x will clean up all of those nasty macro definitions that // BOOST_NO_CTYPE_FUNCTIONS is intended to help work around, so undefine // it under GCC 3.x. #if defined(__GNUC__) && (__GNUC__ >= 3) && defined(BOOST_NO_CTYPE_FUNCTIONS) # undef BOOST_NO_CTYPE_FUNCTIONS #endif // // Assume any extensions are in namespace std:: unless stated otherwise: // # ifndef BOOST_STD_EXTENSION_NAMESPACE # define BOOST_STD_EXTENSION_NAMESPACE std # endif // // If cv-qualified specializations are not allowed, then neither are cv-void ones: // # if defined(BOOST_NO_CV_SPECIALIZATIONS) \ && !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) # define BOOST_NO_CV_VOID_SPECIALIZATIONS # endif // // If there is no numeric_limits template, then it can't have any compile time // constants either! // # if defined(BOOST_NO_LIMITS) \ && !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS # define BOOST_NO_MS_INT64_NUMERIC_LIMITS # define BOOST_NO_LONG_LONG_NUMERIC_LIMITS # endif // // if there is no long long then there is no specialisation // for numeric_limits either: // #if !defined(BOOST_HAS_LONG_LONG) && !defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS) # define BOOST_NO_LONG_LONG_NUMERIC_LIMITS #endif // // if there is no __int64 then there is no specialisation // for numeric_limits<__int64> either: // #if !defined(BOOST_HAS_MS_INT64) && !defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS) # define BOOST_NO_MS_INT64_NUMERIC_LIMITS #endif // // if member templates are supported then so is the // VC6 subset of member templates: // # if !defined(BOOST_NO_MEMBER_TEMPLATES) \ && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) # define BOOST_MSVC6_MEMBER_TEMPLATES # endif // // Without partial specialization, can't test for partial specialisation bugs: // # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG) # define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG # endif // // Without partial specialization, we can't have array-type partial specialisations: // # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) # define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS # endif // // Without partial specialization, std::iterator_traits can't work: // # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_NO_STD_ITERATOR_TRAITS) # define BOOST_NO_STD_ITERATOR_TRAITS # endif // // Without member template support, we can't have template constructors // in the standard library either: // # if defined(BOOST_NO_MEMBER_TEMPLATES) \ && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ && !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS) # define BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS # endif // // Without member template support, we can't have a conforming // std::allocator template either: // # if defined(BOOST_NO_MEMBER_TEMPLATES) \ && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) \ && !defined(BOOST_NO_STD_ALLOCATOR) # define BOOST_NO_STD_ALLOCATOR # endif // // without ADL support then using declarations will break ADL as well: // #if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) && !defined(BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL) # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL #endif // // If we have a standard allocator, then we have a partial one as well: // #if !defined(BOOST_NO_STD_ALLOCATOR) # define BOOST_HAS_PARTIAL_STD_ALLOCATOR #endif // // We can't have a working std::use_facet if there is no std::locale: // # if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_USE_FACET) # define BOOST_NO_STD_USE_FACET # endif // // We can't have a std::messages facet if there is no std::locale: // # if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_MESSAGES) # define BOOST_NO_STD_MESSAGES # endif // // We can't have a working std::wstreambuf if there is no std::locale: // # if defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF) # define BOOST_NO_STD_WSTREAMBUF # endif // // We can't have a if there is no : // # if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_CWCTYPE) # define BOOST_NO_CWCTYPE # endif // // We can't have a swprintf if there is no : // # if defined(BOOST_NO_CWCHAR) && !defined(BOOST_NO_SWPRINTF) # define BOOST_NO_SWPRINTF # endif // // If Win32 support is turned off, then we must turn off // threading support also, unless there is some other // thread API enabled: // #if defined(BOOST_DISABLE_WIN32) && defined(_WIN32) \ && !defined(BOOST_DISABLE_THREADS) && !defined(BOOST_HAS_PTHREADS) # define BOOST_DISABLE_THREADS #endif // // Turn on threading support if the compiler thinks that it's in // multithreaded mode. We put this here because there are only a // limited number of macros that identify this (if there's any missing // from here then add to the appropriate compiler section): // #if (defined(__MT__) || defined(_MT) || defined(_REENTRANT) \ || defined(_PTHREADS)) && !defined(BOOST_HAS_THREADS) # define BOOST_HAS_THREADS #endif // // Turn threading support off if BOOST_DISABLE_THREADS is defined: // #if defined(BOOST_DISABLE_THREADS) && defined(BOOST_HAS_THREADS) # undef BOOST_HAS_THREADS #endif // // Turn threading support off if we don't recognise the threading API: // #if defined(BOOST_HAS_THREADS) && !defined(BOOST_HAS_PTHREADS)\ && !defined(BOOST_HAS_WINTHREADS) && !defined(BOOST_HAS_BETHREADS)\ && !defined(BOOST_HAS_MPTASKS) # undef BOOST_HAS_THREADS #endif // // Turn threading detail macros off if we don't (want to) use threading // #ifndef BOOST_HAS_THREADS # undef BOOST_HAS_PTHREADS # undef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE # undef BOOST_HAS_WINTHREADS # undef BOOST_HAS_BETHREADS # undef BOOST_HAS_MPTASKS #endif // // If the compiler claims to be C99 conformant, then it had better // have a : // # if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) # define BOOST_HAS_STDINT_H # endif // // Define BOOST_NO_SLIST and BOOST_NO_HASH if required. // Note that this is for backwards compatibility only. // # ifndef BOOST_HAS_SLIST # define BOOST_NO_SLIST # endif # ifndef BOOST_HAS_HASH # define BOOST_NO_HASH # endif // BOOST_HAS_ABI_HEADERS // This macro gets set if we have headers that fix the ABI, // and prevent ODR violations when linking to external libraries: #if defined(BOOST_ABI_PREFIX) && defined(BOOST_ABI_SUFFIX) && !defined(BOOST_HAS_ABI_HEADERS) # define BOOST_HAS_ABI_HEADERS #endif #if defined(BOOST_HAS_ABI_HEADERS) && defined(BOOST_DISABLE_ABI_HEADERS) # undef BOOST_HAS_ABI_HEADERS #endif // BOOST_NO_STDC_NAMESPACE workaround --------------------------------------// // Because std::size_t usage is so common, even in boost headers which do not // otherwise use the C library, the workaround is included here so // that ugly workaround code need not appear in many other boost headers. // NOTE WELL: This is a workaround for non-conforming compilers; // must still be #included in the usual places so that inclusion // works as expected with standard conforming compilers. The resulting // double inclusion of is harmless. # ifdef BOOST_NO_STDC_NAMESPACE # include namespace std { using ::ptrdiff_t; using ::size_t; } # endif // Workaround for the unfortunate min/max macros defined by some platform headers #define BOOST_PREVENT_MACRO_SUBSTITUTION #ifndef BOOST_USING_STD_MIN # define BOOST_USING_STD_MIN() using std::min #endif #ifndef BOOST_USING_STD_MAX # define BOOST_USING_STD_MAX() using std::max #endif // BOOST_NO_STD_MIN_MAX workaround -----------------------------------------// # ifdef BOOST_NO_STD_MIN_MAX namespace std { template inline const _Tp& min BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { return __b < __a ? __b : __a; } template inline const _Tp& max BOOST_PREVENT_MACRO_SUBSTITUTION (const _Tp& __a, const _Tp& __b) { return __a < __b ? __b : __a; } } # endif // BOOST_STATIC_CONSTANT workaround --------------------------------------- // // On compilers which don't allow in-class initialization of static integral // constant members, we must use enums as a workaround if we want the constants // to be available at compile-time. This macro gives us a convenient way to // declare such constants. # ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION # define BOOST_STATIC_CONSTANT(type, assignment) enum { assignment } # else # define BOOST_STATIC_CONSTANT(type, assignment) static const type assignment # endif // BOOST_USE_FACET / HAS_FACET workaround ----------------------------------// // When the standard library does not have a conforming std::use_facet there // are various workarounds available, but they differ from library to library. // The same problem occurs with has_facet. // These macros provide a consistent way to access a locale's facets. // Usage: // replace // std::use_facet(loc); // with // BOOST_USE_FACET(Type, loc); // Note do not add a std:: prefix to the front of BOOST_USE_FACET! // Use for BOOST_HAS_FACET is analagous. #if defined(BOOST_NO_STD_USE_FACET) # ifdef BOOST_HAS_TWO_ARG_USE_FACET # define BOOST_USE_FACET(Type, loc) std::use_facet(loc, static_cast(0)) # define BOOST_HAS_FACET(Type, loc) std::has_facet(loc, static_cast(0)) # elif defined(BOOST_HAS_MACRO_USE_FACET) # define BOOST_USE_FACET(Type, loc) std::_USE(loc, Type) # define BOOST_HAS_FACET(Type, loc) std::_HAS(loc, Type) # elif defined(BOOST_HAS_STLP_USE_FACET) # define BOOST_USE_FACET(Type, loc) (*std::_Use_facet(loc)) # define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) # endif #else # define BOOST_USE_FACET(Type, loc) std::use_facet< Type >(loc) # define BOOST_HAS_FACET(Type, loc) std::has_facet< Type >(loc) #endif // BOOST_NESTED_TEMPLATE workaround ------------------------------------------// // Member templates are supported by some compilers even though they can't use // the A::template member syntax, as a workaround replace: // // typedef typename A::template rebind binder; // // with: // // typedef typename A::BOOST_NESTED_TEMPLATE rebind binder; #ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD # define BOOST_NESTED_TEMPLATE template #else # define BOOST_NESTED_TEMPLATE #endif // BOOST_UNREACHABLE_RETURN(x) workaround -------------------------------------// // Normally evaluates to nothing, unless BOOST_NO_UNREACHABLE_RETURN_DETECTION // is defined, in which case it evaluates to return x; Use when you have a return // statement that can never be reached. #ifdef BOOST_NO_UNREACHABLE_RETURN_DETECTION # define BOOST_UNREACHABLE_RETURN(x) return x; #else # define BOOST_UNREACHABLE_RETURN(x) #endif // BOOST_DEDUCED_TYPENAME workaround ------------------------------------------// // // Some compilers don't support the use of `typename' for dependent // types in deduced contexts, e.g. // // template void f(T, typename T::type); // ^^^^^^^^ // Replace these declarations with: // // template void f(T, BOOST_DEDUCED_TYPENAME T::type); #ifndef BOOST_NO_DEDUCED_TYPENAME # define BOOST_DEDUCED_TYPENAME typename #else # define BOOST_DEDUCED_TYPENAME #endif // long long workaround ------------------------------------------// // On gcc (and maybe other compilers?) long long is alway supported // but it's use may generate either warnings (with -ansi), or errors // (with -pedantic -ansi) unless it's use is prefixed by __extension__ // #if defined(BOOST_HAS_LONG_LONG) namespace boost{ # ifdef __GNUC__ __extension__ typedef long long long_long_type; __extension__ typedef unsigned long long ulong_long_type; # else typedef long long long_long_type; typedef unsigned long long ulong_long_type; # endif } #endif // BOOST_[APPEND_]EXPLICIT_TEMPLATE_[NON_]TYPE macros --------------------------// // // Some compilers have problems with function templates whose // template parameters don't appear in the function parameter // list (basically they just link one instantiation of the // template in the final executable). These macros provide a // uniform way to cope with the problem with no effects on the // calling syntax. // Example: // // #include // #include // #include // // template // void f() { std::cout << n << ' '; } // // template // void g() { std::cout << typeid(T).name() << ' '; } // // int main() { // f<1>(); // f<2>(); // // g(); // g(); // } // // With VC++ 6.0 the output is: // // 2 2 double double // // To fix it, write // // template // void f(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, n)) { ... } // // template // void g(BOOST_EXPLICIT_TEMPLATE_TYPE(T)) { ... } // #if defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS # include "boost/type.hpp" # include "boost/non_type.hpp" # define BOOST_EXPLICIT_TEMPLATE_TYPE(t) boost::type* = 0 # define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) boost::type* # define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) boost::non_type* = 0 # define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) boost::non_type* # define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) \ , BOOST_EXPLICIT_TEMPLATE_TYPE(t) # define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) \ , BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) # define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) \ , BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) # define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) \ , BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) #else // no workaround needed: expand to nothing # define BOOST_EXPLICIT_TEMPLATE_TYPE(t) # define BOOST_EXPLICIT_TEMPLATE_TYPE_SPEC(t) # define BOOST_EXPLICIT_TEMPLATE_NON_TYPE(t, v) # define BOOST_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) # define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t) # define BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE_SPEC(t) # define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(t, v) # define BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE_SPEC(t, v) #endif // defined BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS // ---------------------------------------------------------------------------// // // Helper macro BOOST_STRINGIZE: // Converts the parameter X to a string after macro replacement // on X has been performed. // #define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) #define BOOST_DO_STRINGIZE(X) #X // // Helper macro BOOST_JOIN: // The following piece of macro magic joins the two // arguments together, even when one of the arguments is // itself a macro (see 16.3.1 in C++ standard). The key // is that macro expansion of macro arguments does not // occur in BOOST_DO_JOIN2 but does in BOOST_DO_JOIN. // #define BOOST_JOIN( X, Y ) BOOST_DO_JOIN( X, Y ) #define BOOST_DO_JOIN( X, Y ) BOOST_DO_JOIN2(X,Y) #define BOOST_DO_JOIN2( X, Y ) X##Y // // Set some default values for compiler/library/platform names. // These are for debugging config setup only: // # ifndef BOOST_COMPILER # define BOOST_COMPILER "Unknown ISO C++ Compiler" # endif # ifndef BOOST_STDLIB # define BOOST_STDLIB "Unknown ISO standard library" # endif # ifndef BOOST_PLATFORM # if defined(unix) || defined(__unix) || defined(_XOPEN_SOURCE) \ || defined(_POSIX_SOURCE) # define BOOST_PLATFORM "Generic Unix" # else # define BOOST_PLATFORM "Unknown" # endif # endif #endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/select_compiler_config.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/select_compile0000644000175000017500000000525211344301501031624 0ustar debiandebian// Boost compiler configuration selection header file // (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Martin Wille 2003. // (C) Copyright Guillaume Melquiond 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // locate which compiler we are using and define // BOOST_COMPILER_CONFIG as needed: # if defined __COMO__ // Comeau C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/comeau.hpp" #elif defined __DMC__ // Digital Mars C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp" #elif defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC) // Intel # define BOOST_COMPILER_CONFIG "boost/config/compiler/intel.hpp" # elif defined __GNUC__ // GNU C++: # define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp" #elif defined __KCC // Kai C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/kai.hpp" #elif defined __sgi // SGI MIPSpro C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/sgi_mipspro.hpp" #elif defined __DECCXX // Compaq Tru64 Unix cxx # define BOOST_COMPILER_CONFIG "boost/config/compiler/compaq_cxx.hpp" #elif defined __ghs // Greenhills C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/greenhills.hpp" #elif defined __BORLANDC__ // Borland # define BOOST_COMPILER_CONFIG "boost/config/compiler/borland.hpp" #elif defined __MWERKS__ // Metrowerks CodeWarrior # define BOOST_COMPILER_CONFIG "boost/config/compiler/metrowerks.hpp" #elif defined __SUNPRO_CC // Sun Workshop Compiler C++ # define BOOST_COMPILER_CONFIG "boost/config/compiler/sunpro_cc.hpp" #elif defined __HP_aCC // HP aCC # define BOOST_COMPILER_CONFIG "boost/config/compiler/hp_acc.hpp" #elif defined(__MRC__) || defined(__SC__) // MPW MrCpp or SCpp # define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp" #elif defined(__IBMCPP__) // IBM Visual Age # define BOOST_COMPILER_CONFIG "boost/config/compiler/vacpp.hpp" #elif defined _MSC_VER // Microsoft Visual C++ // // Must remain the last #elif since some other vendors (Metrowerks, for // example) also #define _MSC_VER # define BOOST_COMPILER_CONFIG "boost/config/compiler/visualc.hpp" #elif defined (BOOST_ASSERT_CONFIG) // this must come last - generate an error if we don't // recognise the compiler: # error "Unknown compiler - please configure (http://www.boost.org/libs/config/config.htm#configuring) and report the results to the main boost mailing list (http://www.boost.org/more/mailing_lists.htm#main)" #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/0000755000175000017500000000000012146213742030532 5ustar debiandebian././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/gcc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/gcc.h0000644000175000017500000000545311344301501031434 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Darin Adler 2001 - 2002. // (C) Copyright Jens Maurer 2001 - 2002. // (C) Copyright Beman Dawes 2001 - 2003. // (C) Copyright Douglas Gregor 2002. // (C) Copyright David Abrahams 2002 - 2003. // (C) Copyright Synge Todo 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // GNU C++ compiler setup: # if __GNUC__ == 2 && __GNUC_MINOR__ == 91 // egcs 1.1 won't parse shared_ptr.hpp without this: # define BOOST_NO_AUTO_PTR # endif # if __GNUC__ == 2 && __GNUC_MINOR__ < 95 // // Prior to gcc 2.95 member templates only partly // work - define BOOST_MSVC6_MEMBER_TEMPLATES // instead since inline member templates mostly work. // # define BOOST_NO_MEMBER_TEMPLATES # if __GNUC_MINOR__ >= 9 # define BOOST_MSVC6_MEMBER_TEMPLATES # endif # endif # if __GNUC__ == 2 && __GNUC_MINOR__ < 96 # define BOOST_NO_SFINAE # endif # if __GNUC__ == 2 && __GNUC_MINOR__ <= 97 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS # define BOOST_NO_OPERATORS_IN_NAMESPACE # endif # if __GNUC__ < 3 # define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL # endif #ifndef __EXCEPTIONS # define BOOST_NO_EXCEPTIONS #endif // // Bug specific to gcc 3.1 and 3.2: // #if (__GNUC__ == 3) && ((__GNUC_MINOR__ == 1) || (__GNUC_MINOR__ == 2)) # define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS #endif // // Threading support: Turn this on unconditionally here (except for // those platforms where we can know for sure). It will get turned off again // later if no threading API is detected. // #if !defined(__MINGW32__) && !defined(linux) && !defined(__linux) && !defined(__linux__) # define BOOST_HAS_THREADS #endif // // gcc has "long long" // #define BOOST_HAS_LONG_LONG // // gcc implements the named return value optimization since version 3.1 // #if __GNUC__ > 3 || ( __GNUC__ == 3 && __GNUC_MINOR__ >= 1 ) #define BOOST_HAS_NRVO #endif #define BOOST_COMPILER "GNU C++ version " __VERSION__ // // versions check: // we don't know gcc prior to version 2.90: #if (__GNUC__ == 2) && (__GNUC_MINOR__ < 90) # error "Compiler not configured - please reconfigure" #endif // // last known and checked version is 3.4: #if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ > 4)) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # else # warning "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/compaq_cxx.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/compa0000644000175000017500000000106711344301501031546 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Dec Alpha True64 C++ compiler setup: #define BOOST_COMPILER "Dec Alpha True64 " BOOST_STRINGIZE(__DECCXX_VER) #include "boost/config/compiler/common_edg.hpp" // // versions check: // Nothing to do here? # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/common_edg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/commo0000644000175000017500000000263711344301501031565 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2002. // (C) Copyright Jens Maurer 2001. // (C) Copyright David Abrahams 2002. // (C) Copyright Aleksey Gurtovoy 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // // Options common to all edg based compilers. // // This is included from within the individual compiler mini-configs. #ifndef __EDG_VERSION__ # error This file requires that __EDG_VERSION__ be defined. #endif #if (__EDG_VERSION__ <= 238) # define BOOST_NO_INTEGRAL_INT64_T # define BOOST_NO_SFINAE #endif #if (__EDG_VERSION__ <= 240) # define BOOST_NO_VOID_RETURNS #endif #if (__EDG_VERSION__ <= 241) && !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) # define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP #endif #if (__EDG_VERSION__ <= 244) && !defined(BOOST_NO_TEMPLATE_TEMPLATES) # define BOOST_NO_TEMPLATE_TEMPLATES #endif // See also kai.hpp which checks a Kai-specific symbol for EH # if !defined(__KCC) && !defined(__EXCEPTIONS) # define BOOST_NO_EXCEPTIONS # endif # if !defined(__NO_LONG_LONG) # define BOOST_HAS_LONG_LONG # endif #ifdef c_plusplus // EDG has "long long" in non-strict mode // However, some libraries have insufficient "long long" support // #define BOOST_HAS_LONG_LONG #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/borland.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/borla0000644000175000017500000001176111344301501031550 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright David Abrahams 2002 - 2003. // (C) Copyright Aleksey Gurtovoy 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Borland C++ compiler setup: // Version 5.0 and below: # if __BORLANDC__ <= 0x0550 // Borland C++Builder 4 and 5: # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS # if __BORLANDC__ == 0x0550 // Borland C++Builder 5, command-line compiler 5.5: # define BOOST_NO_OPERATORS_IN_NAMESPACE # endif # endif // Version 5.51 and below: #if (__BORLANDC__ <= 0x551) # define BOOST_NO_CV_SPECIALIZATIONS # define BOOST_NO_CV_VOID_SPECIALIZATIONS # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS # define BOOST_NO_DEDUCED_TYPENAME // workaround for missing WCHAR_MAX/WCHAR_MIN: #include #include #ifndef WCHAR_MAX # define WCHAR_MAX 0xffff #endif #ifndef WCHAR_MIN # define WCHAR_MIN 0 #endif #endif #if (__BORLANDC__ <= 0x564) # define BOOST_NO_SFINAE #endif // Version 7.0 (Kylix) and below: #if (__BORLANDC__ <= 0x570) # define BOOST_NO_INTEGRAL_INT64_T # define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS # define BOOST_NO_PRIVATE_IN_AGGREGATE # define BOOST_NO_USING_TEMPLATE # define BOOST_BCB_PARTIAL_SPECIALIZATION_BUG # define BOOST_NO_TEMPLATE_TEMPLATES # define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS // we shouldn't really need this - but too many things choke // without it, this needs more investigation: # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL # ifdef NDEBUG // fix broken so that Boost.test works: # include # undef strcmp # endif // // new bug in 5.61: #if (__BORLANDC__ >= 0x561) && (__BORLANDC__ <= 0x570) // this seems to be needed by the command line compiler, but not the IDE: # define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS #endif # ifdef _WIN32 # define BOOST_NO_SWPRINTF # elif defined(linux) || defined(__linux__) || defined(__linux) // we should really be able to do without this // but the wcs* functions aren't imported into std:: # define BOOST_NO_STDC_NAMESPACE // _CPPUNWIND doesn't get automatically set for some reason: # pragma defineonoption BOOST_CPPUNWIND -x # endif #endif // // Post 0x561 we have long long and stdint.h: #if __BORLANDC__ >= 0x561 # ifndef __NO_LONG_LONG # define BOOST_HAS_LONG_LONG # endif // On non-Win32 platforms let the platform config figure this out: # ifdef _WIN32 # define BOOST_HAS_STDINT_H # endif #endif // Borland C++Builder 6 defaults to using STLPort. If _USE_OLD_RW_STL is // defined, then we have 0x560 or greater with the Rogue Wave implementation // which presumably has the std::DBL_MAX bug. #if ((__BORLANDC__ >= 0x550) && (__BORLANDC__ < 0x560)) || defined(_USE_OLD_RW_STL) // is partly broken, some macros define symbols that are really in // namespace std, so you end up having to use illegal constructs like // std::DBL_MAX, as a fix we'll just include float.h and have done with: #include #endif // // __int64: // #if (__BORLANDC__ >= 0x530) && !defined(__STRICT_ANSI__) # define BOOST_HAS_MS_INT64 #endif // // check for exception handling support: // #if !defined(_CPPUNWIND) && !defined(BOOST_CPPUNWIND) && !defined(__EXCEPTIONS) # define BOOST_NO_EXCEPTIONS #endif // // all versions have a : // #ifndef __STRICT_ANSI__ # define BOOST_HAS_DIRENT_H #endif // // all versions support __declspec: // #ifndef __STRICT_ANSI__ # define BOOST_HAS_DECLSPEC #endif // // ABI fixing headers: // #if __BORLANDC__ < 0x600 // not implemented for version 6 compiler yet #ifndef BOOST_ABI_PREFIX # define BOOST_ABI_PREFIX "boost/config/abi/borland_prefix.hpp" #endif #ifndef BOOST_ABI_SUFFIX # define BOOST_ABI_SUFFIX "boost/config/abi/borland_suffix.hpp" #endif #endif // // Disable Win32 support in ANSI mode: // #if __BORLANDC__ < 0x600 # pragma defineonoption BOOST_DISABLE_WIN32 -A #elif defined(__STRICT_ANSI__) # define BOOST_DISABLE_WIN32 #endif // // MSVC compatibility mode does some nasty things: // #if defined(_MSC_VER) && (_MSC_VER <= 1200) # define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP # define BOOST_NO_VOID_RETURNS #endif #define BOOST_COMPILER "Borland C++ version " BOOST_STRINGIZE(__BORLANDC__) // // versions check: // we don't support Borland prior to version 5.4: #if __BORLANDC__ < 0x540 # error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 1536 (Builder X preview): #if (__BORLANDC__ > 1536) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # else # pragma message( "Unknown compiler version - please run the configure tests and report the results") # endif #endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/sgi_mipspro.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/sgi_m0000644000175000017500000000124611344301501031544 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // SGI C++ compiler setup: #define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION) #include "boost/config/compiler/common_edg.hpp" // // Threading support: // Turn this on unconditionally here, it will get turned off again later // if no threading API is detected. // #define BOOST_HAS_THREADS // // version check: // probably nothing to do here? ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/intel.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/intel0000644000175000017500000001232711344301501031563 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright Peter Dimov 2001. // (C) Copyright Jens Maurer 2001. // (C) Copyright David Abrahams 2002 - 2003. // (C) Copyright Aleksey Gurtovoy 2002 - 2003. // (C) Copyright Guillaume Melquiond 2002 - 2003. // (C) Copyright Beman Dawes 2003. // (C) Copyright Martin Wille 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Intel compiler setup: #include "boost/config/compiler/common_edg.hpp" #if defined(__INTEL_COMPILER) # define BOOST_INTEL_CXX_VERSION __INTEL_COMPILER #elif defined(__ICL) # define BOOST_INTEL_CXX_VERSION __ICL #elif defined(__ICC) # define BOOST_INTEL_CXX_VERSION __ICC #elif defined(__ECC) # define BOOST_INTEL_CXX_VERSION __ECC #endif #define BOOST_COMPILER "Intel C++ version " BOOST_STRINGIZE(BOOST_INTEL_CXX_VERSION) #define BOOST_INTEL BOOST_INTEL_CXX_VERSION #if defined(_WIN32) || defined(_WIN64) # define BOOST_INTEL_WIN BOOST_INTEL #else # define BOOST_INTEL_LINUX BOOST_INTEL #endif #if (BOOST_INTEL_CXX_VERSION <= 500) && defined(_MSC_VER) # define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS # define BOOST_NO_TEMPLATE_TEMPLATES #endif #if (BOOST_INTEL_CXX_VERSION <= 600) # if defined(_MSC_VER) && (_MSC_VER <= 1300) // added check for <= VC 7 (Peter Dimov) // Boost libraries assume strong standard conformance unless otherwise // indicated by a config macro. As configured by Intel, the EDG front-end // requires certain compiler options be set to achieve that strong conformance. // Particularly /Qoption,c,--arg_dep_lookup (reported by Kirk Klobe & Thomas Witt) // and /Zc:wchar_t,forScope. See boost-root/tools/build/intel-win32-tools.jam for // details as they apply to particular versions of the compiler. When the // compiler does not predefine a macro indicating if an option has been set, // this config file simply assumes the option has been set. // Thus BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP will not be defined, even if // the compiler option is not enabled. # define BOOST_NO_SWPRINTF # endif // Void returns, 64 bit integrals don't work when emulating VC 6 (Peter Dimov) # if defined(_MSC_VER) && (_MSC_VER <= 1200) # define BOOST_NO_VOID_RETURNS # define BOOST_NO_INTEGRAL_INT64_T # endif #endif #if (BOOST_INTEL_CXX_VERSION <= 710) && defined(_WIN32) # define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS #endif // See http://aspn.activestate.com/ASPN/Mail/Message/boost/1614864 #if BOOST_INTEL_CXX_VERSION < 600 # define BOOST_NO_INTRINSIC_WCHAR_T #else // We should test the macro _WCHAR_T_DEFINED to check if the compiler // supports wchar_t natively. *BUT* there is a problem here: the standard // headers define this macro if they typedef wchar_t. Anyway, we're lucky // because they define it without a value, while Intel C++ defines it // to 1. So we can check its value to see if the macro was defined natively // or not. // Under UNIX, the situation is exactly the same, but the macro _WCHAR_T // is used instead. # if ((_WCHAR_T_DEFINED + 0) == 0) && ((_WCHAR_T + 0) == 0) # define BOOST_NO_INTRINSIC_WCHAR_T # endif #endif // // Verify that we have actually got BOOST_NO_INTRINSIC_WCHAR_T // set correctly, if we don't do this now, we will get errors later // in type_traits code among other things, getting this correct // for the Intel compiler is actually remarkably fragile and tricky: // #if defined(BOOST_NO_INTRINSIC_WCHAR_T) #include template< typename T > struct assert_no_intrinsic_wchar_t; template<> struct assert_no_intrinsic_wchar_t { typedef void type; }; // if you see an error here then you need to unset BOOST_NO_INTRINSIC_WCHAR_T // where it is defined above: typedef assert_no_intrinsic_wchar_t::type assert_no_intrinsic_wchar_t_; #else template< typename T > struct assert_intrinsic_wchar_t; template<> struct assert_intrinsic_wchar_t {}; // if you see an error here then define BOOST_NO_INTRINSIC_WCHAR_T on the command line: template<> struct assert_intrinsic_wchar_t {}; #endif #if (BOOST_INTEL_CXX_VERSION <= 800) || !defined(BOOST_STRICT_CONFIG) # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL #endif #if _MSC_VER+0 >= 1000 # if _MSC_VER >= 1200 # define BOOST_HAS_MS_INT64 # endif # define BOOST_NO_SWPRINTF #elif defined(_WIN32) # define BOOST_DISABLE_WIN32 #endif // I checked version 6.0 build 020312Z, it implements the NRVO. // Correct this as you find out which version of the compiler // implemented the NRVO first. (Daniel Frey) #if (BOOST_INTEL_CXX_VERSION >= 600) # define BOOST_HAS_NRVO #endif // // versions check: // we don't support Intel prior to version 5.0: #if BOOST_INTEL_CXX_VERSION < 500 # error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version: #if (BOOST_INTEL_CXX_VERSION > 810) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # elif defined(_MSC_VER) # pragma message("Unknown compiler version - please run the configure tests and report the results") # endif #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/vacpp.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/vacpp0000644000175000017500000000336111344301501031557 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Toon Knapen 2001 - 2003. // (C) Copyright Lie-Quan Lee 2001. // (C) Copyright Markus Schöpflin 2002 - 2003. // (C) Copyright Beman Dawes 2002 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Visual Age (IBM) C++ compiler setup: #if __IBMCPP__ <= 501 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS # define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS #endif #if (__IBMCPP__ <= 502) // Actually the compiler supports inclass member initialization but it // requires a definition for the class member and it doesn't recognize // it as an integral constant expression when used as a template argument. # define BOOST_NO_INCLASS_MEMBER_INITIALIZATION # define BOOST_NO_INTEGRAL_INT64_T # define BOOST_NO_MEMBER_TEMPLATE_KEYWORD #endif #if (__IBMCPP__ <= 600) || !defined(BOOST_STRICT_CONFIG) # define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS # define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES 1 #endif // // On AIX thread support seems to be indicated by _THREAD_SAFE: // #ifdef _THREAD_SAFE # define BOOST_HAS_THREADS #endif #define BOOST_COMPILER "IBM Visual Age version " BOOST_STRINGIZE(__IBMCPP__) // // versions check: // we don't support Visual age prior to version 5: #if __IBMCPP__ < 500 #error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 600: #if (__IBMCPP__ > 600) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/visualc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/visua0000644000175000017500000001031611344301501031573 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Darin Adler 2001 - 2002. // (C) Copyright Peter Dimov 2001. // (C) Copyright Aleksey Gurtovoy 2002. // (C) Copyright David Abrahams 2002 - 2003. // (C) Copyright Beman Dawes 2002 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Microsoft Visual C++ compiler setup: #define BOOST_MSVC _MSC_VER // turn off the warnings before we #include anything #pragma warning( disable : 4503 ) // warning: decorated name length exceeded #if _MSC_VER < 1300 // 1200 == VC++ 6.0, 1201 == EVC4.2 #pragma warning( disable : 4786 ) // ident trunc to '255' chars in debug info # define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS # define BOOST_NO_VOID_RETURNS # define BOOST_NO_EXCEPTION_STD_NAMESPACE // disable min/max macro defines on vc6: // #endif #if (_MSC_VER <= 1300) // 1300 == VC++ 7.0 #if !defined(_MSC_EXTENSIONS) && !defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) // VC7 bug with /Za # define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS #endif # define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS # define BOOST_NO_INCLASS_MEMBER_INITIALIZATION # define BOOST_NO_PRIVATE_IN_AGGREGATE # define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP # define BOOST_NO_INTEGRAL_INT64_T # define BOOST_NO_DEDUCED_TYPENAME # define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE // VC++ 6/7 has member templates but they have numerous problems including // cases of silent failure, so for safety we define: # define BOOST_NO_MEMBER_TEMPLATES // For VC++ experts wishing to attempt workarounds, we define: # define BOOST_MSVC6_MEMBER_TEMPLATES # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS # define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # define BOOST_NO_CV_VOID_SPECIALIZATIONS # define BOOST_NO_FUNCTION_TEMPLATE_ORDERING # define BOOST_NO_USING_TEMPLATE # define BOOST_NO_SWPRINTF # define BOOST_NO_TEMPLATE_TEMPLATES # define BOOST_NO_SFINAE # define BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS # if (_MSC_VER > 1200) # define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS # endif #endif #if _MSC_VER < 1310 // 1310 == VC++ 7.1 # define BOOST_NO_SWPRINTF #endif #if _MSC_VER <= 1400 // 1400 == VC++ 8.0 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS #endif #ifndef _NATIVE_WCHAR_T_DEFINED # define BOOST_NO_INTRINSIC_WCHAR_T #endif #ifdef _WIN32_WCE # define BOOST_NO_THREADEX # define BOOST_NO_GETSYSTEMTIMEASFILETIME #endif // // check for exception handling support: #ifndef _CPPUNWIND # define BOOST_NO_EXCEPTIONS #endif // // __int64 support: // #if (_MSC_VER >= 1200) # define BOOST_HAS_MS_INT64 #endif #if (_MSC_VER >= 1310) && defined(_MSC_EXTENSIONS) # define BOOST_HAS_LONG_LONG #endif // // disable Win32 API's if compiler extentions are // turned off: // #ifndef _MSC_EXTENSIONS # define BOOST_DISABLE_WIN32 #endif // // all versions support __declspec: // #define BOOST_HAS_DECLSPEC // // prefix and suffix headers: // #ifndef BOOST_ABI_PREFIX # define BOOST_ABI_PREFIX "boost/config/abi/msvc_prefix.hpp" #endif #ifndef BOOST_ABI_SUFFIX # define BOOST_ABI_SUFFIX "boost/config/abi/msvc_suffix.hpp" #endif # if _MSC_VER == 1200 # define BOOST_COMPILER_VERSION 6.0 # elif _MSC_VER == 1300 # define BOOST_COMPILER_VERSION 7.0 # elif _MSC_VER == 1310 # define BOOST_COMPILER_VERSION 7.1 # elif _MSC_VER == 1400 # define BOOST_COMPILER_VERSION 8.0 # else # define BOOST_COMPILER_VERSION _MSC_VER # endif #define BOOST_COMPILER "Microsoft Visual C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) // // versions check: // we don't support Visual C++ prior to version 6: #if _MSC_VER < 1200 #error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 1310: #if (_MSC_VER > 1400) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # else # pragma message("Unknown compiler version - please run the configure tests and report the results") # endif #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/metrowerks.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/metro0000644000175000017500000000523211344301501031573 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright Darin Adler 2001. // (C) Copyright Peter Dimov 2001. // (C) Copyright David Abrahams 2001 - 2002. // (C) Copyright Beman Dawes 2001 - 2003. // (C) Copyright Stefan Slapeta 2004. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Metrowerks C++ compiler setup: // locale support is disabled when linking with the dynamic runtime # ifdef _MSL_NO_LOCALE # define BOOST_NO_STD_LOCALE # endif # if __MWERKS__ <= 0x2301 // 5.3 # define BOOST_NO_FUNCTION_TEMPLATE_ORDERING # define BOOST_NO_POINTER_TO_MEMBER_CONST # define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS # define BOOST_NO_MEMBER_TEMPLATE_KEYWORD # endif # if __MWERKS__ <= 0x2401 // 6.2 //# define BOOST_NO_FUNCTION_TEMPLATE_ORDERING # endif # if(__MWERKS__ <= 0x2407) // 7.x # define BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS # define BOOST_NO_UNREACHABLE_RETURN_DETECTION # endif # if(__MWERKS__ <= 0x3003) // 8.x # define BOOST_NO_SFINAE # endif # if(__MWERKS__ <= 0x3204) // 9.3 # define BOOST_NO_MEMBER_TEMPLATE_FRIENDS # endif #if !__option(wchar_type) # define BOOST_NO_INTRINSIC_WCHAR_T #endif #if !__option(exceptions) # define BOOST_NO_EXCEPTIONS #endif #if (__INTEL__ && _WIN32) || (__POWERPC__ && macintosh) # if __MWERKS__ == 0x3000 # define BOOST_COMPILER_VERSION 8.0 # elif __MWERKS__ == 0x3001 # define BOOST_COMPILER_VERSION 8.1 # elif __MWERKS__ == 0x3002 # define BOOST_COMPILER_VERSION 8.2 # elif __MWERKS__ == 0x3003 # define BOOST_COMPILER_VERSION 8.3 # elif __MWERKS__ == 0x3200 # define BOOST_COMPILER_VERSION 9.0 # elif __MWERKS__ == 0x3201 # define BOOST_COMPILER_VERSION 9.1 # elif __MWERKS__ == 0x3202 # define BOOST_COMPILER_VERSION 9.2 # elif __MWERKS__ == 0x3204 # define BOOST_COMPILER_VERSION 9.3 # else # define BOOST_COMPILER_VERSION __MWERKS__ # endif #else # define BOOST_COMPILER_VERSION __MWERKS__ #endif #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) // // versions check: // we don't support Metrowerks prior to version 5.3: #if __MWERKS__ < 0x2301 # error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version: #if (__MWERKS__ > 0x3204) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/sunpro_cc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/sunpr0000644000175000017500000000605411344301501031617 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright Jens Maurer 2001 - 2003. // (C) Copyright Peter Dimov 2002. // (C) Copyright Aleksey Gurtovoy 2002 - 2003. // (C) Copyright David Abrahams 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Sun C++ compiler setup: # if __SUNPRO_CC <= 0x500 # define BOOST_NO_MEMBER_TEMPLATES # define BOOST_NO_FUNCTION_TEMPLATE_ORDERING # endif # if (__SUNPRO_CC <= 0x520) // // Sunpro 5.2 and earler: // // although sunpro 5.2 supports the syntax for // inline initialization it often gets the value // wrong, especially where the value is computed // from other constants (J Maddock 6th May 2001) # define BOOST_NO_INCLASS_MEMBER_INITIALIZATION // Although sunpro 5.2 supports the syntax for // partial specialization, it often seems to // bind to the wrong specialization. Better // to disable it until suppport becomes more stable // (J Maddock 6th May 2001). # define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # endif # if (__SUNPRO_CC <= 0x530) || !defined(BOOST_STRICT_CONFIG) // Requesting debug info (-g) with Boost.Python results // in an internal compiler error for "static const" // initialized in-class. // >> Assertion: (../links/dbg_cstabs.cc, line 611) // while processing ../test.cpp at line 0. // (Jens Maurer according to Gottfried Ganßauge 04 Mar 2002) # define BOOST_NO_INCLASS_MEMBER_INITIALIZATION // SunPro 5.3 has better support for partial specialization, // but breaks when compiling std::less > // (Jens Maurer 4 Nov 2001). // std::less specialization fixed as reported by George // Heintzelman; partial specialization re-enabled // (Peter Dimov 17 Jan 2002) //# define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // integral constant expressions with 64 bit numbers fail # define BOOST_NO_INTEGRAL_INT64_T # endif # if (__SUNPRO_CC <= 0x540) || !defined(BOOST_STRICT_CONFIG) # define BOOST_NO_TEMPLATE_TEMPLATES // see http://lists.boost.org/MailArchives/boost/msg47184.php // and http://lists.boost.org/MailArchives/boost/msg47220.php # define BOOST_NO_INCLASS_MEMBER_INITIALIZATION # define BOOST_NO_SFINAE # define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS # endif #define BOOST_COMPILER "Sun compiler version " BOOST_STRINGIZE(__SUNPRO_CC) // // versions check: // we don't support sunpro prior to version 4: #if __SUNPRO_CC < 0x400 #error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 0x530: #if (__SUNPRO_CC > 0x530) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/mpw.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/mpw.h0000644000175000017500000000311611344301501031475 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2002. // (C) Copyright Aleksey Gurtovoy 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // MPW C++ compilers setup: # if defined(__SC__) # define BOOST_COMPILER "MPW SCpp version " BOOST_STRINGIZE(__SC__) # elif defined(__MRC__) # define BOOST_COMPILER "MPW MrCpp version " BOOST_STRINGIZE(__MRC__) # else # error "Using MPW compiler configuration by mistake. Please update." # endif // // MPW 8.90: // #if (MPW_CPLUS <= 0x890) || !defined(BOOST_STRICT_CONFIG) # define BOOST_NO_CV_SPECIALIZATIONS # define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS # define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS # define BOOST_NO_INCLASS_MEMBER_INITIALIZATION # define BOOST_NO_INTRINSIC_WCHAR_T # define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # define BOOST_NO_USING_TEMPLATE # define BOOST_NO_CWCHAR # define BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS # define BOOST_NO_STD_ALLOCATOR /* actually a bug with const reference overloading */ #endif // // versions check: // we don't support MPW prior to version 8.9: #if MPW_CPLUS < 0x890 # error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 0x890: #if (MPW_CPLUS > 0x890) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/digitalmars.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/digit0000644000175000017500000000266011344301501031547 0ustar debiandebian// Copyright (C) Christof Meerwald 2003 // Copyright (C) Dan Watkins 2003 // // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // Digital Mars C++ compiler setup: #define BOOST_COMPILER __DMC_VERSION_STRING__ #define BOOST_HAS_LONG_LONG #define BOOST_HAS_PRAGMA_ONCE #if (__DMC__ <= 0x833) #define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL #define BOOST_NO_TEMPLATE_TEMPLATES #define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING #define BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS #define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS #endif #if (__DMC__ <= 0x840) || !defined(BOOST_STRICT_CONFIG) #define BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS #define BOOST_NO_MEMBER_TEMPLATE_FRIENDS #define BOOST_NO_OPERATORS_IN_NAMESPACE #define BOOST_NO_UNREACHABLE_RETURN_DETECTION #define BOOST_NO_SFINAE #define BOOST_NO_USING_TEMPLATE #define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL #endif // // has macros: #if (__DMC__ >= 0x840) #define BOOST_HAS_DIRENT_H #define BOOST_HAS_STDINT_H #define BOOST_HAS_WINTHREADS #endif // check for exception handling support: #ifndef _CPPUNWIND # define BOOST_NO_EXCEPTIONS #endif #if (__DMC__ < 0x840) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/hp_acc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/hp_ac0000644000175000017500000000404611344301501031521 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2001 - 2003. // (C) Copyright Aleksey Gurtovoy 2002. // (C) Copyright David Abrahams 2002 - 2003. // (C) Copyright Toon Knapen 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // HP aCC C++ compiler setup: #if (__HP_aCC <= 33100) # define BOOST_NO_INTEGRAL_INT64_T # define BOOST_NO_OPERATORS_IN_NAMESPACE # if !defined(_NAMESPACE_STD) # define BOOST_NO_STD_LOCALE # define BOOST_NO_STRINGSTREAM # endif #endif #if (__HP_aCC <= 33300) // member templates are sufficiently broken that we disable them for now # define BOOST_NO_MEMBER_TEMPLATES # define BOOST_NO_DEPENDENT_NESTED_DERIVATIONS # define BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE #endif #if (__HP_aCC <= 33900) || !defined(BOOST_STRICT_CONFIG) # define BOOST_NO_UNREACHABLE_RETURN_DETECTION # define BOOST_NO_TEMPLATE_TEMPLATES # define BOOST_NO_SWPRINTF # define BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS // std lib config should set this one already: //# define BOOST_NO_STD_ALLOCATOR #endif // optional features rather than defects: #if (__HP_aCC >= 33900) # define BOOST_HAS_LONG_LONG # define BOOST_HAS_PARTIAL_STD_ALLOCATOR #endif #if (__HP_aCC >= 50000 ) && (__HP_aCC <= 53800 ) || (__HP_aCC < 31300 ) # define BOOST_NO_MEMBER_TEMPLATE_KEYWORD #endif #define BOOST_NO_MEMBER_TEMPLATE_FRIENDS #define BOOST_COMPILER "HP aCC version " BOOST_STRINGIZE(__HP_aCC) // // versions check: // we don't support HP aCC prior to version 0: #if __HP_aCC < 33000 # error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 0: #if (__HP_aCC > 53800) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/greenhills.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/green0000644000175000017500000000145711344301501031552 0ustar debiandebian// (C) Copyright John Maddock 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Greenhills C++ compiler setup: #define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs) #include "boost/config/compiler/common_edg.hpp" // // versions check: // we don't support Greenhills prior to version 0: #if __ghs < 0 # error "Compiler not supported or configured - please reconfigure" #endif // // last known and checked version is 0: #if (__ghs > 0) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/kai.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/kai.h0000644000175000017500000000205011344301501031432 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright David Abrahams 2002. // (C) Copyright Aleksey Gurtovoy 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Kai C++ compiler setup: #include "boost/config/compiler/common_edg.hpp" # if (__KCC_VERSION <= 4001) || !defined(BOOST_STRICT_CONFIG) // at least on Sun, the contents of is not in namespace std # define BOOST_NO_STDC_NAMESPACE # endif // see also common_edg.hpp which needs a special check for __KCC # if !defined(_EXCEPTIONS) # define BOOST_NO_EXCEPTIONS # endif #define BOOST_COMPILER "Kai C++ version " BOOST_STRINGIZE(__KCC_VERSION) // // last known and checked version is 4001: #if (__KCC_VERSION > 4001) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/comeau.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/compiler/comea0000644000175000017500000000313711344301501031533 0ustar debiandebian// (C) Copyright John Maddock 2001. // (C) Copyright Douglas Gregor 2001. // (C) Copyright Peter Dimov 2001. // (C) Copyright Aleksey Gurtovoy 2003. // (C) Copyright Beman Dawes 2003. // (C) Copyright Jens Maurer 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Comeau C++ compiler setup: #include "boost/config/compiler/common_edg.hpp" #if (__COMO_VERSION__ <= 4245) # define BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL # if defined(_MSC_VER) && _MSC_VER <= 1300 # if _MSC_VER > 100 // only set this in non-strict mode: # define BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP # endif # endif // Void returns don't work when emulating VC 6 (Peter Dimov) # if defined(_MSC_VER) && (_MSC_VER == 1200) # define BOOST_NO_VOID_RETURNS # endif #endif // version 4245 // // enable __int64 support in VC emulation mode // # if defined(_MSC_VER) && (_MSC_VER >= 1200) # define BOOST_HAS_MS_INT64 # endif #define BOOST_COMPILER "Comeau compiler version " BOOST_STRINGIZE(__COMO_VERSION__) // // versions check: // we don't know Comeau prior to version 4245: #if __COMO_VERSION__ < 4245 # error "Compiler not configured - please reconfigure" #endif // // last known and checked version is 4245: #if (__COMO_VERSION__ > 4245) # if defined(BOOST_ASSERT_CONFIG) # error "Unknown compiler version - please run the configure tests and report the results" # endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/0000755000175000017500000000000012146213742027453 5ustar debiandebian././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/msvc_prefix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/msvc_prefi0000644000175000017500000000037711344301501031530 0ustar debiandebian// (C) Copyright John Maddock 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #pragma pack(push,8) ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/borland_prefix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/borland_pr0000644000175000017500000000174711344301501031517 0ustar debiandebian// (C) Copyright John Maddock 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // for C++ Builder the following options effect the ABI: // // -b (on or off - effect emum sizes) // -Vx (on or off - empty members) // -Ve (on or off - empty base classes) // -aX (alignment - 5 options). // -pX (Calling convention - 4 options) // -VmX (member pointer size and layout - 5 options) // -VC (on or off, changes name mangling) // -Vl (on or off, changes struct layout). // In addition the following warnings are sufficiently annoying (and // unfixable) to have them turned off by default: // // 8027 - functions containing [for|while] loops are not expanded inline // 8026 - functions taking class by value arguments are not expanded inline #pragma nopushoptwarn # pragma option push -Vx -Ve -a8 -b -pc -Vmv -VC- -Vl- -w-8027 -w-8026 ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/msvc_suffix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/msvc_suffi0000644000175000017500000000037411344301501031534 0ustar debiandebian// (C) Copyright John Maddock 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #pragma pack(pop) ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/borland_suffix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi/borland_su0000644000175000017500000000043011344301501031511 0ustar debiandebian// (C) Copyright John Maddock 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) # pragma option pop #pragma nopushoptwarn ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/select_platform_config.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/select_platfor0000644000175000017500000000467611344301501031654 0ustar debiandebian// Boost compiler configuration selection header file // (C) Copyright John Maddock 2001 - 2002. // (C) Copyright Jens Maurer 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // locate which platform we are on and define BOOST_PLATFORM_CONFIG as needed. // Note that we define the headers to include using "header_name" not // in order to prevent macro expansion within the header // name (for example "linux" is a macro on linux systems). #if defined(linux) || defined(__linux) || defined(__linux__) // linux: # define BOOST_PLATFORM_CONFIG "boost/config/platform/linux.hpp" #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) // BSD: # define BOOST_PLATFORM_CONFIG "boost/config/platform/bsd.hpp" #elif defined(sun) || defined(__sun) // solaris: # define BOOST_PLATFORM_CONFIG "boost/config/platform/solaris.hpp" #elif defined(__sgi) // SGI Irix: # define BOOST_PLATFORM_CONFIG "boost/config/platform/irix.hpp" #elif defined(__hpux) // hp unix: # define BOOST_PLATFORM_CONFIG "boost/config/platform/hpux.hpp" #elif defined(__CYGWIN__) // cygwin is not win32: # define BOOST_PLATFORM_CONFIG "boost/config/platform/cygwin.hpp" #elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) // win32: # define BOOST_PLATFORM_CONFIG "boost/config/platform/win32.hpp" #elif defined(__BEOS__) // BeOS # define BOOST_PLATFORM_CONFIG "boost/config/platform/beos.hpp" #elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) // MacOS # define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp" #elif defined(__IBMCPP__) // IBM # define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp" #elif defined(__amigaos__) // AmigaOS # define BOOST_PLATFORM_CONFIG "boost/config/platform/amigaos.hpp" #else # if defined(unix) \ || defined(__unix) \ || defined(_XOPEN_SOURCE) \ || defined(_POSIX_SOURCE) // generic unix platform: # ifndef BOOST_HAS_UNISTD_H # define BOOST_HAS_UNISTD_H # endif # include # endif # if defined (BOOST_ASSERT_CONFIG) // this must come last - generate an error if we don't // recognise the platform: # error "Unknown platform - please configure and report the results to boost.org" # endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi_suffix.hpp0000644000175000017500000000132111344301501031533 0ustar debiandebian// abi_sufffix header -------------------------------------------------------// // © Copyright John Maddock 2003 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // This header should be #included AFTER code that was preceded by a #include // . #ifndef BOOST_CONFIG_ABI_PREFIX_HPP # error Header boost/config/abi_prefix.hpp must only be used after boost/config/abi_prefix.hpp #else # undef BOOST_CONFIG_ABI_PREFIX_HPP #endif // the suffix header occurs after all of our code: #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/auto_link.hpp0000644000175000017500000002207111344301501031406 0ustar debiandebian// (C) Copyright John Maddock 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) /* * LOCATION: see http://www.boost.org for most recent version. * FILE auto_link.hpp * VERSION see * DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers. */ /************************************************************************* USAGE: ~~~~~~ Before including this header you must define one or more of define the following macros: BOOST_LIB_NAME: Required: A string containing the basename of the library, for example boost_regex. BOOST_DYN_LINK: Optional: when set link to dll rather than static library. BOOST_LIB_DIAGNOSTIC: Optional: when set the header will print out the name of the library selected (useful for debugging). These macros will be undef'ed at the end of the header, further this header has no include guards - so be sure to include it only once from your library! Algorithm: ~~~~~~~~~~ Libraries for Borland and Microsoft compilers are automatically selected here, the name of the lib is selected according to the following formula: BOOST_LIB_PREFIX + BOOST_LIB_NAME + "_" + BOOST_LIB_TOOLSET + BOOST_LIB_THREAD_OPT + BOOST_LIB_RT_OPT "-" + BOOST_LIB_VERSION These are defined as: BOOST_LIB_PREFIX: "lib" for static libraries otherwise "". BOOST_LIB_NAME: The base name of the lib ( for example boost_regex). BOOST_LIB_TOOLSET: The compiler toolset name (vc6, vc7, bcb5 etc). BOOST_LIB_THREAD_OPT: "-mt" for multithread builds, otherwise nothing. BOOST_LIB_RT_OPT: A suffix that indicates the runtime library used, contains one or more of the following letters after a hiphen: s static runtime (dynamic if not present). d debug build (release if not present). g debug/diagnostic runtime (release if not present). p STLPort Build. BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. ***************************************************************************/ #ifdef __cplusplus # ifndef BOOST_CONFIG_HPP # include # endif #elif defined(_MSC_VER) && !defined(__MWERKS__) && !defined(__EDG_VERSION__) // // C language compatability (no, honestly) // # define BOOST_MSVC _MSC_VER # define BOOST_STRINGIZE(X) BOOST_DO_STRINGIZE(X) # define BOOST_DO_STRINGIZE(X) #X #endif // // Only include what follows for known and supported compilers: // #if defined(BOOST_MSVC) \ || defined(__BORLANDC__) \ || (defined(__MWERKS__) && defined(_WIN32) && (__MWERKS__ >= 0x3000)) \ || (defined(__ICL) && defined(_MSC_EXTENSIONS) && (_MSC_VER >= 1200)) #ifndef BOOST_VERSION_HPP # include #endif #ifndef BOOST_LIB_NAME # error "Macro BOOST_LIB_NAME not set (internal error)" #endif // // error check: // #if defined(__MSVC_RUNTIME_CHECKS) && !defined(_DEBUG) # pragma message("Using the /RTC option without specifying a debug runtime will lead to linker errors") # pragma message("Hint: go to the code generation options and switch to one of the debugging runtimes") # error "Incompatible build options" #endif // // select toolset: // #if defined(BOOST_MSVC) && (BOOST_MSVC == 1200) // vc6: # define BOOST_LIB_TOOLSET "vc6" #elif defined(BOOST_MSVC) && (BOOST_MSVC == 1300) // vc7: # define BOOST_LIB_TOOLSET "vc7" #elif defined(BOOST_MSVC) && (BOOST_MSVC == 1310) // vc71: # define BOOST_LIB_TOOLSET "vc71" #elif defined(BOOST_MSVC) && (BOOST_MSVC >= 1400) // vc80: # define BOOST_LIB_TOOLSET "vc80" #elif defined(__BORLANDC__) // CBuilder 6: # define BOOST_LIB_TOOLSET "bcb" #elif defined(__ICL) // Intel C++, no version number: # define BOOST_LIB_TOOLSET "iw" #elif defined(__MWERKS__) && (__MWERKS__ <= 0x31FF ) // Metrowerks CodeWarrior 8.x # define BOOST_LIB_TOOLSET "cw8" #elif defined(__MWERKS__) && (__MWERKS__ <= 0x32FF ) // Metrowerks CodeWarrior 9.x # define BOOST_LIB_TOOLSET "cw9" #endif // // select thread opt: // #if defined(_MT) || defined(__MT__) # define BOOST_LIB_THREAD_OPT "-mt" #else # define BOOST_LIB_THREAD_OPT #endif #if defined(_MSC_VER) || defined(__MWERKS__) # ifdef _DLL # if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS)) # if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) # define BOOST_LIB_RT_OPT "-gdp" # elif defined(_DEBUG) # define BOOST_LIB_RT_OPT "-gdp" # pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") # error "Build options aren't compatible with pre-built libraries" # else # define BOOST_LIB_RT_OPT "-p" # endif # elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) # if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) # define BOOST_LIB_RT_OPT "-gdpn" # elif defined(_DEBUG) # define BOOST_LIB_RT_OPT "-gdpn" # pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") # error "Build options aren't compatible with pre-built libraries" # else # define BOOST_LIB_RT_OPT "-pn" # endif # else # if defined(_DEBUG) # define BOOST_LIB_RT_OPT "-gd" # else # define BOOST_LIB_RT_OPT # endif # endif # else # if (defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)) && (defined(_STLP_OWN_IOSTREAMS) || defined(__STL_OWN_IOSTREAMS)) # if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) # define BOOST_LIB_RT_OPT "-sgdp" # elif defined(_DEBUG) # define BOOST_LIB_RT_OPT "-sgdp" # pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") # error "Build options aren't compatible with pre-built libraries" # else # define BOOST_LIB_RT_OPT "-sp" # endif # elif defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION) # if defined(_DEBUG) && (defined(__STL_DEBUG) || defined(_STLP_DEBUG)) # define BOOST_LIB_RT_OPT "-sgdpn" # elif defined(_DEBUG) # define BOOST_LIB_RT_OPT "-sgdpn" # pragma message("warning: STLPort debug versions are built with /D_STLP_DEBUG=1") # error "Build options aren't compatible with pre-built libraries" # else # define BOOST_LIB_RT_OPT "-spn" # endif # else # if defined(_DEBUG) # define BOOST_LIB_RT_OPT "-sgd" # else # define BOOST_LIB_RT_OPT "-s" # endif # endif # endif #elif defined(__BORLANDC__) // // figure out whether we want the debug builds or not: // #pragma defineonoption BOOST_BORLAND_DEBUG -v // // sanity check: // #if defined(__STL_DEBUG) || defined(_STLP_DEBUG) #error "Pre-built versions of the Boost libraries are not provided in STLPort-debug form" #endif # ifdef _RTLDLL # ifdef BOOST_BORLAND_DEBUG # define BOOST_LIB_RT_OPT "-d" # else # define BOOST_LIB_RT_OPT # endif # else # ifdef BOOST_BORLAND_DEBUG # define BOOST_LIB_RT_OPT "-sd" # else # define BOOST_LIB_RT_OPT "-s" # endif # endif #endif // // select linkage opt: // #if (defined(_DLL) || defined(_RTLDLL)) && defined(BOOST_DYN_LINK) # define BOOST_LIB_PREFIX #elif defined(BOOST_DYN_LINK) # error "Mixing a dll boost library with a static runtime is a really bad idea..." #else # define BOOST_LIB_PREFIX "lib" #endif // // now include the lib: // #if defined(BOOST_LIB_NAME) \ && defined(BOOST_LIB_PREFIX) \ && defined(BOOST_LIB_TOOLSET) \ && defined(BOOST_LIB_THREAD_OPT) \ && defined(BOOST_LIB_RT_OPT) \ && defined(BOOST_LIB_VERSION) # pragma comment(lib, BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib") #ifdef BOOST_LIB_DIAGNOSTIC # pragma message ("Linking to lib file: " BOOST_LIB_PREFIX BOOST_STRINGIZE(BOOST_LIB_NAME) "-" BOOST_LIB_TOOLSET BOOST_LIB_THREAD_OPT BOOST_LIB_RT_OPT "-" BOOST_LIB_VERSION ".lib") #endif #else # error "some required macros where not defined (internal logic error)." #endif #endif // _MSC_VER || __BORLANDC__ // // finally undef any macros we may have set: // #ifdef BOOST_LIB_PREFIX # undef BOOST_LIB_PREFIX #endif #if defined(BOOST_LIB_NAME) # undef BOOST_LIB_NAME #endif #if defined(BOOST_LIB_TOOLSET) # undef BOOST_LIB_TOOLSET #endif #if defined(BOOST_LIB_THREAD_OPT) # undef BOOST_LIB_THREAD_OPT #endif #if defined(BOOST_LIB_RT_OPT) # undef BOOST_LIB_RT_OPT #endif #if defined(BOOST_LIB_LINK_OPT) # undef BOOST_LIB_LINK_OPT #endif #if defined(BOOST_LIB_DEBUG_OPT) # undef BOOST_LIB_DEBUG_OPT #endif #if defined(BOOST_DYN_LINK) # undef BOOST_DYN_LINK #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/user.hpp0000644000175000017500000001204511344301501030377 0ustar debiandebian// boost/config/user.hpp ---------------------------------------------------// // (C) Copyright John Maddock 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // Do not check in modified versions of this file, // This file may be customized by the end user, but not by boost. // // Use this file to define a site and compiler specific // configuration policy: // // define this to locate a compiler config file: // #define BOOST_COMPILER_CONFIG // define this to locate a stdlib config file: // #define BOOST_STDLIB_CONFIG // define this to locate a platform config file: // #define BOOST_PLATFORM_CONFIG // define this to disable compiler config, // use if your compiler config has nothing to set: // #define BOOST_NO_COMPILER_CONFIG // define this to disable stdlib config, // use if your stdlib config has nothing to set: // #define BOOST_NO_STDLIB_CONFIG // define this to disable platform config, // use if your platform config has nothing to set: // #define BOOST_NO_PLATFORM_CONFIG // define this to disable all config options, // excluding the user config. Use if your // setup is fully ISO compliant, and has no // useful extensions, or for autoconf generated // setups: // #define BOOST_NO_CONFIG // define this to make the config "optimistic" // about unknown compiler versions. Normally // unknown compiler versions are assumed to have // all the defects of the last known version, however // setting this flag, causes the config to assume // that unknown compiler versions are fully conformant // with the standard: // #define BOOST_STRICT_CONFIG // define this to cause the config to halt compilation // with an #error if it encounters anything unknown -- // either an unknown compiler version or an unknown // compiler/platform/library: // #define BOOST_ASSERT_CONFIG // define if you want to disable threading support, even // when available: // #define BOOST_DISABLE_THREADS // define when you want to disable Win32 specific features // even when available: // #define BOOST_DISABLE_WIN32 // BOOST_DISABLE_ABI_HEADERS: Stops boost headers from including any // prefix/suffix headers that normally control things like struct // packing and alignment. // #define BOOST_DISABLE_ABI_HEADERS // BOOST_ABI_PREFIX: A prefix header to include in place of whatever // boost.config would normally select, any replacement should set up // struct packing and alignment options as required. // #define BOOST_ABI_PREFIX my-header-name // BOOST_ABI_SUFFIX: A suffix header to include in place of whatever // boost.config would normally select, any replacement should undo // the effects of the prefix header. // #define BOOST_ABI_SUFFIX my-header-name // BOOST_ALL_DYN_LINK: Forces all libraries that have separate source, // to be linked as dll's rather than static libraries on Microsoft Windows // (this macro is used to turn on __declspec(dllimport) modifiers, so that // the compiler knows which symbols to look for in a dll rather than in a // static library). Note that there may be some libraries that can only // be statically linked (Boost.Test for example) and others which may only // be dynamically linked (Boost.Threads for example), in these cases this // macro has no effect. // #define BOOST_ALL_DYN_LINK // BOOST_WHATEVER_DYN_LINK: Forces library "whatever" to be linked as a dll // rather than a static library on Microsoft Windows: replace the WHATEVER // part of the macro name with the name of the library that you want to // dynamically link to, for example use BOOST_DATE_TIME_DYN_LINK or // BOOST_REGEX_DYN_LINK etc (this macro is used to turn on __declspec(dllimport) // modifiers, so that the compiler knows which symbols to look for in a dll // rather than in a static library). // Note that there may be some libraries that can only be statically linked // (Boost.Test for example) and others which may only be dynamically linked // (Boost.Threads for example), in these cases this macro is unsupported. // #define BOOST_WHATEVER_DYN_LINK // BOOST_ALL_NO_LIB: Tells the config system not to automatically select // which libraries to link against. // Normally if a compiler supports #pragma lib, then the correct library // build variant will be automatically selected and linked against, // simply by the act of including one of that library's headers. // This macro turns that feature off. // #define BOOST_ALL_NO_LIB // BOOST_WHATEVER_NO_LIB: Tells the config system not to automatically // select which library to link against for library "whatever", // replace WHATEVER in the macro name with the name of the library; // for example BOOST_DATE_TIME_NO_LIB or BOOST_REGEX_NO_LIB. // Normally if a compiler supports #pragma lib, then the correct library // build variant will be automatically selected and linked against, simply // by the act of including one of that library's headers. This macro turns // that feature off. // #define BOOST_WHATEVER_NO_LIB mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/abi_prefix.hpp0000644000175000017500000000117511344301501031533 0ustar debiandebian// abi_prefix header -------------------------------------------------------// // © Copyright John Maddock 2003 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). #ifndef BOOST_CONFIG_ABI_PREFIX_HPP # define BOOST_CONFIG_ABI_PREFIX_HPP #else # error double inclusion of header boost/config/abi_prefix.hpp is an error #endif #include // this must occur after all other includes and before any code appears: #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/0000755000175000017500000000000012146213742030544 5ustar debiandebian././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/win32.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/win320000644000175000017500000000255511344301501031426 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Bill Kempf 2001. // (C) Copyright Aleksey Gurtovoy 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Win32 specific config options: #define BOOST_PLATFORM "Win32" #if defined(__GNUC__) && !defined(BOOST_NO_SWPRINTF) # define BOOST_NO_SWPRINTF #endif #if !defined(__GNUC__) && !defined(BOOST_HAS_DECLSPEC) # define BOOST_HAS_DECLSPEC #endif #if defined(__MINGW32__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 2))) # define BOOST_HAS_STDINT_H # define __STDC_LIMIT_MACROS #endif // // Win32 will normally be using native Win32 threads, // but there is a pthread library avaliable as an option, // we used to disable this when BOOST_DISABLE_WIN32 was // defined but no longer - this should allow some // files to be compiled in strict mode - while maintaining // a consistent setting of BOOST_HAS_THREADS across // all translation units (needed for shared_ptr etc). // #ifdef _WIN32_WCE # define BOOST_NO_ANSI_APIS #endif #ifndef BOOST_HAS_PTHREADS # define BOOST_HAS_WINTHREADS #endif #ifndef BOOST_DISABLE_WIN32 // WEK: Added #define BOOST_HAS_FTIME #define BOOST_WINDOWS 1 #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/irix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/irix.0000644000175000017500000000142511344301501031510 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // SGI Irix specific config options: #define BOOST_PLATFORM "SGI Irix" #define BOOST_NO_SWPRINTF // // these are not auto detected by POSIX feature tests: // #define BOOST_HAS_GETTIMEOFDAY #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE #ifdef __GNUC__ // GNU C on IRIX does not support threads (checked up to gcc 3.3) # define BOOST_DISABLE_THREADS #endif // boilerplate code: #define BOOST_HAS_UNISTD_H #include ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/aix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/aix.h0000644000175000017500000000156111344301501031467 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // IBM/Aix specific config options: #define BOOST_PLATFORM "IBM Aix" #define BOOST_HAS_UNISTD_H #define BOOST_HAS_NL_TYPES_H #define BOOST_HAS_NANOSLEEP #define BOOST_HAS_CLOCK_GETTIME // This needs support in "boost/cstdint.hpp" exactly like FreeBSD. // This platform has header named which includes all // the things needed. #define BOOST_HAS_STDINT_H // Threading API's: #define BOOST_HAS_PTHREADS #define BOOST_HAS_PTHREAD_DELAY_NP #define BOOST_HAS_SCHED_YIELD //#define BOOST_HAS_PTHREAD_YIELD // boilerplate code: #include ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/macos.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/macos0000644000175000017500000000326211344301501031562 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Darin Adler 2001 - 2002. // (C) Copyright Bill Kempf 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // Mac OS specific config options: #define BOOST_PLATFORM "Mac OS" #if __MACH__ && !defined(_MSL_USING_MSL_C) // Using the Mac OS X system BSD-style C library. # ifndef BOOST_HAS_UNISTD_H # define BOOST_HAS_UNISTD_H # endif // boilerplate code: # ifndef TARGET_CARBON # include # endif # ifndef BOOST_HAS_STDINT_H # define BOOST_HAS_STDINT_H # endif // // BSD runtime has pthreads, sigaction, sched_yield and gettimeofday, // of these only pthreads are advertised in , so set the // other options explicitly: // # define BOOST_HAS_SCHED_YIELD # define BOOST_HAS_GETTIMEOFDAY # define BOOST_HAS_SIGACTION # if (__GNUC__ < 3) && !defined( __APPLE_CC__) // GCC strange "ignore std" mode works better if you pretend everything // is in the std namespace, for the most part. # define BOOST_NO_STDC_NAMESPACE # endif #else // Using the MSL C library. // We will eventually support threads in non-Carbon builds, but we do // not support this yet. # if TARGET_CARBON # define BOOST_HAS_MPTASKS // The MP task implementation of Boost Threads aims to replace MP-unsafe // parts of the MSL, so we turn on threads unconditionally. # define BOOST_HAS_THREADS // The remote call manager depends on this. # define BOOST_BIND_ENABLE_PASCAL # endif #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/bsd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/bsd.h0000644000175000017500000000324611344301501031460 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Darin Adler 2001. // (C) Copyright Douglas Gregor 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // generic BSD config options: #if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) #error "This platform is not BSD" #endif #ifdef __FreeBSD__ #define BOOST_PLATFORM "FreeBSD " BOOST_STRINGIZE(__FreeBSD__) #elif defined(__NetBSD__) #define BOOST_PLATFORM "NetBSD " BOOST_STRINGIZE(__NetBSD__) #elif defined(__OpenBSD__) #define BOOST_PLATFORM "OpenBSD " BOOST_STRINGIZE(__OpenBSD__) #endif // // is this the correct version check? // FreeBSD has but does not // advertise the fact in : // #if defined(__FreeBSD__) && (__FreeBSD__ >= 3) # define BOOST_HAS_NL_TYPES_H #endif // // FreeBSD 3.x has pthreads support, but defines _POSIX_THREADS in // and not in // #if defined(__FreeBSD__) && (__FreeBSD__ <= 3) # define BOOST_HAS_PTHREADS #endif // // No wide character support in the BSD header files: // #define BOOST_NO_CWCHAR // // The BSD has macros only, no functions: // #if !defined(__OpenBSD__) # define BOOST_NO_CTYPE_FUNCTIONS #endif // // thread API's not auto detected: // #define BOOST_HAS_SCHED_YIELD #define BOOST_HAS_NANOSLEEP #define BOOST_HAS_GETTIMEOFDAY #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE #define BOOST_HAS_SIGACTION // boilerplate code: #define BOOST_HAS_UNISTD_H #include ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/cygwin.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/cygwi0000644000175000017500000000232211344301501031576 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // cygwin specific config options: #define BOOST_PLATFORM "Cygwin" #define BOOST_NO_CWCTYPE #define BOOST_NO_CWCHAR #define BOOST_NO_SWPRINTF #define BOOST_HAS_DIRENT_H // // Threading API: // See if we have POSIX threads, if we do use them, otherwise // revert to native Win threads. #define BOOST_HAS_UNISTD_H #include #if defined(_POSIX_THREADS) && (_POSIX_THREADS+0 >= 0) && !defined(BOOST_HAS_WINTHREADS) # define BOOST_HAS_PTHREADS # define BOOST_HAS_SCHED_YIELD # define BOOST_HAS_GETTIMEOFDAY # define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE # define BOOST_HAS_SIGACTION #else # if !defined(BOOST_HAS_WINTHREADS) # define BOOST_HAS_WINTHREADS # endif # define BOOST_HAS_FTIME #endif // // find out if we have a stdint.h, there should be a better way to do this: // #include #ifdef _STDINT_H #define BOOST_HAS_STDINT_H #endif // boilerplate code: #include ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/beos.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/beos.0000644000175000017500000000112111344301501031456 0ustar debiandebian// (C) Copyright John Maddock 2001. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // BeOS specific config options: #define BOOST_PLATFORM "BeOS" #define BOOST_NO_CWCHAR #define BOOST_NO_CWCTYPE #define BOOST_HAS_UNISTD_H #define BOOST_HAS_BETHREADS #ifndef BOOST_DISABLE_THREADS # define BOOST_HAS_THREADS #endif // boilerplate code: #include ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/amigaos.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/amiga0000644000175000017500000000067211344301501031540 0ustar debiandebian// (C) Copyright John Maddock 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. #define BOOST_PLATFORM "AmigaOS" #define BOOST_DISABLE_THREADS #define BOOST_NO_CWCHAR #define BOOST_NO_STD_WSTRING #define BOOST_NO_INTRINSIC_WCHAR_T ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/solaris.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/solar0000644000175000017500000000102211344301501031570 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // sun specific config options: #define BOOST_PLATFORM "Sun Solaris" #define BOOST_HAS_GETTIMEOFDAY // boilerplate code: #define BOOST_HAS_UNISTD_H #include ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/hpux.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/hpux.0000644000175000017500000000326311344301501031523 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2001 - 2003. // (C) Copyright David Abrahams 2002. // (C) Copyright Toon Knapen 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // hpux specific config options: #define BOOST_PLATFORM "HP-UX" // In principle, HP-UX has a nice under the name // However, it has the following problem: // Use of UINT32_C(0) results in "0u l" for the preprocessed source // (verifyable with gcc 2.95.3, assumed for HP aCC) // #define BOOST_HAS_STDINT_H #define BOOST_NO_SWPRINTF #define BOOST_NO_CWCTYPE #ifdef __GNUC__ // GNU C on HP-UX does not support threads (checked up to gcc 3.3) # define BOOST_DISABLE_THREADS #endif // boilerplate code: #define BOOST_HAS_UNISTD_H #include // the following are always available: #ifndef BOOST_HAS_GETTIMEOFDAY # define BOOST_HAS_GETTIMEOFDAY #endif #ifndef BOOST_HAS_SCHED_YIELD # define BOOST_HAS_SCHED_YIELD #endif #ifndef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE # define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE #endif #ifndef BOOST_HAS_NL_TYPES_H # define BOOST_HAS_NL_TYPES_H #endif #ifndef BOOST_HAS_NANOSLEEP # define BOOST_HAS_NANOSLEEP #endif #ifndef BOOST_HAS_GETTIMEOFDAY # define BOOST_HAS_GETTIMEOFDAY #endif #ifndef BOOST_HAS_DIRENT_H # define BOOST_HAS_DIRENT_H #endif #ifndef BOOST_HAS_CLOCK_GETTIME # define BOOST_HAS_CLOCK_GETTIME #endif #ifndef BOOST_HAS_SIGACTION # define BOOST_HAS_SIGACTION #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/linux.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config/platform/linux0000644000175000017500000000465011344301501031621 0ustar debiandebian// (C) Copyright John Maddock 2001 - 2003. // (C) Copyright Jens Maurer 2001 - 2003. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for most recent version. // linux specific config options: #define BOOST_PLATFORM "linux" // make sure we have __GLIBC_PREREQ if available at all #include // // added to glibc 2.1.1 // We can only test for 2.1 though: // #if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1))) // defines int64_t unconditionally, but defines // int64_t only if __GNUC__. Thus, assume a fully usable // only when using GCC. # if defined __GNUC__ # define BOOST_HAS_STDINT_H # endif #endif #if defined(__LIBCOMO__) // // como on linux doesn't have std:: c functions: // NOTE: versions of libcomo prior to beta28 have octal version numbering, // e.g. version 25 is 21 (dec) // # if __LIBCOMO_VERSION__ <= 20 # define BOOST_NO_STDC_NAMESPACE # endif # if __LIBCOMO_VERSION__ <= 21 # define BOOST_NO_SWPRINTF # endif #endif // // If glibc is past version 2 then we definitely have // gettimeofday, earlier versions may or may not have it: // #if defined(__GLIBC__) && (__GLIBC__ >= 2) # define BOOST_HAS_GETTIMEOFDAY #endif #ifdef __USE_POSIX199309 # define BOOST_HAS_NANOSLEEP #endif #if defined(__GLIBC__) && defined(__GLIBC_PREREQ) // __GLIBC_PREREQ is available since 2.1.2 // swprintf is available since glibc 2.2.0 # if !__GLIBC_PREREQ(2,2) || (!defined(__USE_ISOC99) && !defined(__USE_UNIX98)) # define BOOST_NO_SWPRINTF # endif #else # define BOOST_NO_SWPRINTF #endif // boilerplate code: #define BOOST_HAS_UNISTD_H #include #ifndef __GNUC__ // // if the compiler is not gcc we still need to be able to parse // the GNU system headers, some of which (mainly ) // use GNU specific extensions: // # ifndef __extension__ # define __extension__ # endif # ifndef __const__ # define __const__ const # endif # ifndef __volatile__ # define __volatile__ volatile # endif # ifndef __signed__ # define __signed__ signed # endif # ifndef __typeof__ # define __typeof__ typeof # endif # ifndef __inline__ # define __inline__ inline # endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/none.hpp0000644000175000017500000000137711344301501027121 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_NONE_17SEP2003_HPP #define BOOST_NONE_17SEP2003_HPP #include "boost/detail/none_t.hpp" // NOTE: Borland users have to include this header outside any precompiled headers // (bcc<=5.64 cannot include instance data in a precompiled header) namespace boost { namespace { detail::none_t const none = ((detail::none_t)0) ; } } // namespace boost #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/enable_shared_from_this.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/enable_shared_from_th0000644000175000017500000000261611344301501031663 0ustar debiandebian#ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED #define BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED // // enable_shared_from_this.hpp // // Copyright (c) 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html // #include #include #include #include namespace boost { template class enable_shared_from_this { protected: enable_shared_from_this() { } enable_shared_from_this(enable_shared_from_this const &) { } enable_shared_from_this & operator=(enable_shared_from_this const &) { return *this; } ~enable_shared_from_this() { } public: shared_ptr shared_from_this() { shared_ptr p(_internal_weak_this); BOOST_ASSERT(p.get() == this); return p; } shared_ptr shared_from_this() const { shared_ptr p(_internal_weak_this); BOOST_ASSERT(p.get() == this); return p; } typedef T _internal_element_type; // for bcc 5.5.1 mutable weak_ptr<_internal_element_type> _internal_weak_this; }; } // namespace boost #endif // #ifndef BOOST_ENABLE_SHARED_FROM_THIS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/0000755000175000017500000000000012146213772026607 5ustar debiandebian././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/tuple_comparison.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/tuple_compariso0000644000175000017500000001272111344301501031725 0ustar debiandebian// tuple_comparison.hpp ----------------------------------------------------- // // Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // For more information, see http://www.boost.org // // (The idea and first impl. of comparison operators was from Doug Gregor) // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_COMPARISON_HPP #define BOOST_TUPLE_COMPARISON_HPP #include "boost/tuple/tuple.hpp" // ------------------------------------------------------------- // equality and comparison operators // // == and != compare tuples elementwise // <, >, <= and >= use lexicographical ordering // // Any operator between tuples of different length fails at compile time // No dependencies between operators are assumed // (i.e. !(a=b, a!=b does not imply a==b etc. // so any weirdnesses of elementary operators are respected). // // ------------------------------------------------------------- namespace boost { namespace tuples { inline bool operator==(const null_type&, const null_type&) { return true; } inline bool operator>=(const null_type&, const null_type&) { return true; } inline bool operator<=(const null_type&, const null_type&) { return true; } inline bool operator!=(const null_type&, const null_type&) { return false; } inline bool operator<(const null_type&, const null_type&) { return false; } inline bool operator>(const null_type&, const null_type&) { return false; } namespace detail { // comparison operators check statically the length of its operands and // delegate the comparing task to the following functions. Hence // the static check is only made once (should help the compiler). // These functions assume tuples to be of the same length. template inline bool eq(const T1& lhs, const T2& rhs) { return lhs.get_head() == rhs.get_head() && eq(lhs.get_tail(), rhs.get_tail()); } template<> inline bool eq(const null_type&, const null_type&) { return true; } template inline bool neq(const T1& lhs, const T2& rhs) { return lhs.get_head() != rhs.get_head() || neq(lhs.get_tail(), rhs.get_tail()); } template<> inline bool neq(const null_type&, const null_type&) { return false; } template inline bool lt(const T1& lhs, const T2& rhs) { return lhs.get_head() < rhs.get_head() || !(rhs.get_head() < lhs.get_head()) && lt(lhs.get_tail(), rhs.get_tail()); } template<> inline bool lt(const null_type&, const null_type&) { return false; } template inline bool gt(const T1& lhs, const T2& rhs) { return lhs.get_head() > rhs.get_head() || !(rhs.get_head() > lhs.get_head()) && gt(lhs.get_tail(), rhs.get_tail()); } template<> inline bool gt(const null_type&, const null_type&) { return false; } template inline bool lte(const T1& lhs, const T2& rhs) { return lhs.get_head() <= rhs.get_head() && ( !(rhs.get_head() <= lhs.get_head()) || lte(lhs.get_tail(), rhs.get_tail())); } template<> inline bool lte(const null_type&, const null_type&) { return true; } template inline bool gte(const T1& lhs, const T2& rhs) { return lhs.get_head() >= rhs.get_head() && ( !(rhs.get_head() >= lhs.get_head()) || gte(lhs.get_tail(), rhs.get_tail())); } template<> inline bool gte(const null_type&, const null_type&) { return true; } } // end of namespace detail // equal ---- template inline bool operator==(const cons& lhs, const cons& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length::value == length::value); return detail::eq(lhs, rhs); } // not equal ----- template inline bool operator!=(const cons& lhs, const cons& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length::value == length::value); return detail::neq(lhs, rhs); } // < template inline bool operator<(const cons& lhs, const cons& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length::value == length::value); return detail::lt(lhs, rhs); } // > template inline bool operator>(const cons& lhs, const cons& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length::value == length::value); return detail::gt(lhs, rhs); } // <= template inline bool operator<=(const cons& lhs, const cons& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length::value == length::value); return detail::lte(lhs, rhs); } // >= template inline bool operator>=(const cons& lhs, const cons& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length::value == length::value); return detail::gte(lhs, rhs); } } // end of namespace tuples } // end of namespace boost #endif // BOOST_TUPLE_COMPARISON_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/tuple.hpp0000644000175000017500000000545411344301501030444 0ustar debiandebian// tuple.hpp - Boost Tuple Library -------------------------------------- // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_HPP #define BOOST_TUPLE_HPP #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 // Work around a compiler bug. // boost::python::tuple has to be seen by the compiler before the // boost::tuple class template. namespace boost { namespace python { class tuple; }} #endif #include "boost/config.hpp" #include "boost/static_assert.hpp" #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) // The MSVC version #include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp" #else // other compilers #include "boost/ref.hpp" #include "boost/tuple/detail/tuple_basic.hpp" #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { using tuples::tuple; using tuples::make_tuple; using tuples::tie; #if !defined(BOOST_NO_USING_TEMPLATE) using tuples::get; #elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) // // The "using tuples::get" statement causes the // Borland compiler to ICE, use forwarding // functions instead: // template inline typename tuples::access_traits< typename tuples::element >::type >::non_const_type get(tuples::cons& c) { return tuples::get(c); } // get function for const cons-lists, returns a const reference to // the element. If the element is a reference, returns the reference // as such (that is, can return a non-const reference) template inline typename tuples::access_traits< typename tuples::element >::type >::const_type get(const tuples::cons& c) { return tuples::get(c); } #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // // MSVC, using declarations don't mix with templates well, // so use forwarding functions instead: // template typename tuples::detail::element_ref >::RET get(tuples::cons& t, tuples::detail::workaround_holder* = 0) { return tuples::detail::get_class::get(t); } template typename tuples::detail::element_const_ref >::RET get(const tuples::cons& t, tuples::detail::workaround_holder* = 0) { return tuples::detail::get_class::get(t); } #endif // BOOST_NO_USING_TEMPLATE } // end namespace boost #endif // BOOST_TUPLE_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/tuple_io.hpp0000644000175000017500000003311011344301501031121 0ustar debiandebian// tuple_io.hpp -------------------------------------------------------------- // Copyright (C) 2001 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) // 2001 Gary Powell (gary.powell@sierra.com) // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org // ---------------------------------------------------------------------------- #ifndef BOOST_TUPLE_IO_HPP #define BOOST_TUPLE_IO_HPP // add to boost/config.hpp // for now # if defined __GNUC__ # if (__GNUC__ == 2 && __GNUC_MINOR__ <= 97) #define BOOST_NO_TEMPLATED_STREAMS #endif #endif // __GNUC__ #if defined BOOST_NO_TEMPLATED_STREAMS #include #else #include #include #endif #include "boost/tuple/tuple.hpp" // This is ugly: one should be using twoargument isspace since whitspace can // be locale dependent, in theory at least. // not all libraries implement have the two-arg version, so we need to // use the one-arg one, which one should get with but there seem // to be exceptions to this. #if !defined (BOOST_NO_STD_LOCALE) #include // for two-arg isspace #else #include // for one-arg (old) isspace #include // Metrowerks does not find one-arg isspace from cctype #endif namespace boost { namespace tuples { namespace detail { class format_info { public: enum manipulator_type { open, close, delimiter }; BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1); private: static int get_stream_index (int m) { static const int stream_index[number_of_manipulators] = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() }; return stream_index[m]; } format_info(const format_info&); format_info(); public: #if defined (BOOST_NO_TEMPLATED_STREAMS) static char get_manipulator(std::ios& i, manipulator_type m) { char c = static_cast(i.iword(get_stream_index(m))); // parentheses and space are the default manipulators if (!c) { switch(m) { case detail::format_info::open : c = '('; break; case detail::format_info::close : c = ')'; break; case detail::format_info::delimiter : c = ' '; break; } } return c; } static void set_manipulator(std::ios& i, manipulator_type m, char c) { i.iword(get_stream_index(m)) = static_cast(c); } #else template static CharType get_manipulator(std::basic_ios& i, manipulator_type m) { // The manipulators are stored as long. // A valid instanitation of basic_stream allows CharType to be any POD, // hence, the static_cast may fail (it fails if long is not convertible // to CharType CharType c = static_cast(i.iword(get_stream_index(m)) ); // parentheses and space are the default manipulators if (!c) { switch(m) { case detail::format_info::open : c = i.widen('('); break; case detail::format_info::close : c = i.widen(')'); break; case detail::format_info::delimiter : c = i.widen(' '); break; } } return c; } template static void set_manipulator(std::basic_ios& i, manipulator_type m, CharType c) { // The manipulators are stored as long. // A valid instanitation of basic_stream allows CharType to be any POD, // hence, the static_cast may fail (it fails if CharType is not // convertible long. i.iword(get_stream_index(m)) = static_cast(c); } #endif // BOOST_NO_TEMPLATED_STREAMS }; } // end of namespace detail template class tuple_manipulator { const detail::format_info::manipulator_type mt; CharType f_c; public: explicit tuple_manipulator(detail::format_info::manipulator_type m, const char c = 0) : mt(m), f_c(c) {} #if defined (BOOST_NO_TEMPLATED_STREAMS) void set(std::ios &io) const { detail::format_info::set_manipulator(io, mt, f_c); } #else #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template void set(std::basic_ios &io) const { detail::format_info::set_manipulator(io, mt, f_c); } #else template void set(std::basic_ios &io) const { detail::format_info::set_manipulator(io, mt, f_c); } #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_NO_TEMPLATED_STREAMS }; #if defined (BOOST_NO_TEMPLATED_STREAMS) inline std::ostream& operator<<(std::ostream& o, const tuple_manipulator& m) { m.set(o); return o; } inline std::istream& operator>>(std::istream& i, const tuple_manipulator& m) { m.set(i); return i; } #else template inline std::basic_ostream& operator<<(std::basic_ostream& o, const tuple_manipulator& m) { m.set(o); return o; } template inline std::basic_istream& operator>>(std::basic_istream& i, const tuple_manipulator& m) { m.set(i); return i; } #endif // BOOST_NO_TEMPLATED_STREAMS template inline tuple_manipulator set_open(const CharType c) { return tuple_manipulator(detail::format_info::open, c); } template inline tuple_manipulator set_close(const CharType c) { return tuple_manipulator(detail::format_info::close, c); } template inline tuple_manipulator set_delimiter(const CharType c) { return tuple_manipulator(detail::format_info::delimiter, c); } // ------------------------------------------------------------- // printing tuples to ostream in format (a b c) // parentheses and space are defaults, but can be overriden with manipulators // set_open, set_close and set_delimiter namespace detail { // Note: The order of the print functions is critical // to let a conforming compiler find and select the correct one. #if defined (BOOST_NO_TEMPLATED_STREAMS) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template inline std::ostream& print(std::ostream& o, const cons& t) { return o << t.head; } #endif // BOOST_NO_TEMPLATED_STREAMS inline std::ostream& print(std::ostream& o, const null_type&) { return o; } template inline std::ostream& print(std::ostream& o, const cons& t) { const char d = format_info::get_manipulator(o, format_info::delimiter); o << t.head; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) if (tuples::length::value == 0) return o; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION o << d; return print(o, t.tail ); } #else #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template inline std::basic_ostream& print(std::basic_ostream& o, const cons& t) { return o << t.head; } #endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template inline std::basic_ostream& print(std::basic_ostream& o, const null_type&) { return o; } template inline std::basic_ostream& print(std::basic_ostream& o, const cons& t) { const CharType d = format_info::get_manipulator(o, format_info::delimiter); o << t.head; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) if (tuples::length::value == 0) return o; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION o << d; return print(o, t.tail); } #endif // BOOST_NO_TEMPLATED_STREAMS } // namespace detail #if defined (BOOST_NO_TEMPLATED_STREAMS) template inline std::ostream& operator<<(std::ostream& o, const cons& t) { if (!o.good() ) return o; const char l = detail::format_info::get_manipulator(o, detail::format_info::open); const char r = detail::format_info::get_manipulator(o, detail::format_info::close); o << l; detail::print(o, t); o << r; return o; } #else template inline std::basic_ostream& operator<<(std::basic_ostream& o, const cons& t) { if (!o.good() ) return o; const CharType l = detail::format_info::get_manipulator(o, detail::format_info::open); const CharType r = detail::format_info::get_manipulator(o, detail::format_info::close); o << l; detail::print(o, t); o << r; return o; } #endif // BOOST_NO_TEMPLATED_STREAMS // ------------------------------------------------------------- // input stream operators namespace detail { #if defined (BOOST_NO_TEMPLATED_STREAMS) inline std::istream& extract_and_check_delimiter( std::istream& is, format_info::manipulator_type del) { const char d = format_info::get_manipulator(is, del); #if defined (BOOST_NO_STD_LOCALE) const bool is_delimiter = !isspace(d); #else const bool is_delimiter = (!std::isspace(d, is.getloc()) ); #endif char c; if (is_delimiter) { is >> c; if (c!=d) { is.setstate(std::ios::failbit); } } return is; } // Note: The order of the read functions is critical to let a // (conforming?) compiler find and select the correct one. #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template inline std::istream & read (std::istream &is, cons& t1) { if (!is.good()) return is; return is >> t1.head ; } #else inline std::istream& read(std::istream& i, const null_type&) { return i; } #endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template inline std::istream& read(std::istream &is, cons& t1) { if (!is.good()) return is; is >> t1.head; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) if (tuples::length::value == 0) return is; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION extract_and_check_delimiter(is, format_info::delimiter); return read(is, t1.tail); } } // end namespace detail inline std::istream& operator>>(std::istream &is, null_type&) { if (!is.good() ) return is; detail::extract_and_check_delimiter(is, detail::format_info::open); detail::extract_and_check_delimiter(is, detail::format_info::close); return is; } template inline std::istream& operator>>(std::istream& is, cons& t1) { if (!is.good() ) return is; detail::extract_and_check_delimiter(is, detail::format_info::open); detail::read(is, t1); detail::extract_and_check_delimiter(is, detail::format_info::close); return is; } #else template inline std::basic_istream& extract_and_check_delimiter( std::basic_istream &is, format_info::manipulator_type del) { const CharType d = format_info::get_manipulator(is, del); #if defined (BOOST_NO_STD_LOCALE) const bool is_delimiter = !isspace(d); #elif defined ( __BORLANDC__ ) const bool is_delimiter = !std::use_facet< std::ctype< CharType > > (is.getloc() ).is( std::ctype_base::space, d); #else const bool is_delimiter = (!std::isspace(d, is.getloc()) ); #endif CharType c; if (is_delimiter) { is >> c; if (c!=d) { is.setstate(std::ios::failbit); } } return is; } #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template inline std::basic_istream & read (std::basic_istream &is, cons& t1) { if (!is.good()) return is; return is >> t1.head; } #else template inline std::basic_istream& read(std::basic_istream& i, const null_type&) { return i; } #endif // !BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template inline std::basic_istream& read(std::basic_istream &is, cons& t1) { if (!is.good()) return is; is >> t1.head; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) if (tuples::length::value == 0) return is; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION extract_and_check_delimiter(is, format_info::delimiter); return read(is, t1.tail); } } // end namespace detail template inline std::basic_istream& operator>>(std::basic_istream &is, null_type&) { if (!is.good() ) return is; detail::extract_and_check_delimiter(is, detail::format_info::open); detail::extract_and_check_delimiter(is, detail::format_info::close); return is; } template inline std::basic_istream& operator>>(std::basic_istream& is, cons& t1) { if (!is.good() ) return is; detail::extract_and_check_delimiter(is, detail::format_info::open); detail::read(is, t1); detail::extract_and_check_delimiter(is, detail::format_info::close); return is; } #endif // BOOST_NO_TEMPLATED_STREAMS } // end of namespace tuples } // end of namespace boost #endif // BOOST_TUPLE_IO_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/detail/0000755000175000017500000000000012146213772030051 5ustar debiandebian././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/detail/tuple_basic.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/detail/tuple_ba0000644000175000017500000007326011344301501031562 0ustar debiandebian// tuple_basic.hpp ----------------------------------------------------- // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org // Outside help: // This and that, Gary Powell. // Fixed return types for get_head/get_tail // ( and other bugs ) per suggestion of Jens Maurer // simplified element type accessors + bug fix (Jeremy Siek) // Several changes/additions according to suggestions by Douglas Gregor, // William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, // David Abrahams. // Revision history: // 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes // 2002 04 18 Jaakko: tuple element types can be void or plain function // types, as long as no object is created. // Tuple objects can no hold even noncopyable types // such as arrays. // 2001 10 22 John Maddock // Fixes for Borland C++ // 2001 08 30 David Abrahams // Added default constructor for cons<>. // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_BASIC_HPP #define BOOST_TUPLE_BASIC_HPP #include // needed for the assignment from pair to tuple #include "boost/type_traits/cv_traits.hpp" #include "boost/type_traits/function_traits.hpp" #include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND namespace boost { namespace tuples { // -- null_type -------------------------------------------------------- struct null_type {}; // a helper function to provide a const null_type type temporary namespace detail { inline const null_type cnull() { return null_type(); } // -- if construct ------------------------------------------------ // Proposed by Krzysztof Czarnecki and Ulrich Eisenecker template struct IF { typedef Then RET; }; template struct IF { typedef Else RET; }; } // end detail // - cons forward declaration ----------------------------------------------- template struct cons; // - tuple forward declaration ----------------------------------------------- template < class T0 = null_type, class T1 = null_type, class T2 = null_type, class T3 = null_type, class T4 = null_type, class T5 = null_type, class T6 = null_type, class T7 = null_type, class T8 = null_type, class T9 = null_type> class tuple; // tuple_length forward declaration template struct length; namespace detail { // -- generate error template, referencing to non-existing members of this // template is used to produce compilation errors intentionally template class generate_error; // - cons getters -------------------------------------------------------- // called: get_class::get(aTuple) template< int N > struct get_class { template inline static RET get(const cons& t) { #if BOOST_WORKAROUND(__IBMCPP__,==600) // vacpp 6.0 is not very consistent regarding the member template keyword // Here it generates an error when the template keyword is used. return get_class::get(t.tail); #else return get_class::BOOST_NESTED_TEMPLATE get(t.tail); #endif } template inline static RET get(cons& t) { #if BOOST_WORKAROUND(__IBMCPP__,==600) return get_class::get(t.tail); #else return get_class::BOOST_NESTED_TEMPLATE get(t.tail); #endif } }; template<> struct get_class<0> { template inline static RET get(const cons& t) { return t.head; } template inline static RET get(cons& t) { return t.head; } }; } // end of namespace detail // -cons type accessors ---------------------------------------- // typename tuples::element::type gets the type of the // Nth element ot T, first element is at index 0 // ------------------------------------------------------- #ifndef BOOST_NO_CV_SPECIALIZATIONS template struct element { private: typedef typename T::tail_type Next; public: typedef typename element::type type; }; template struct element<0,T> { typedef typename T::head_type type; }; template struct element { private: typedef typename T::tail_type Next; typedef typename element::type unqualified_type; public: #if BOOST_WORKAROUND(__BORLANDC__,<0x600) typedef const unqualified_type type; #else typedef typename boost::add_const::type type; #endif }; template struct element<0,const T> { #if BOOST_WORKAROUND(__BORLANDC__,<0x600) typedef const typename T::head_type type; #else typedef typename boost::add_const::type type; #endif }; #else // def BOOST_NO_CV_SPECIALIZATIONS namespace detail { template struct element_impl { private: typedef typename T::tail_type Next; public: typedef typename element_impl::type type; }; template struct element_impl { private: typedef typename T::tail_type Next; public: typedef const typename element_impl::type type; }; template struct element_impl<0, T, false /* IsConst */> { typedef typename T::head_type type; }; template struct element_impl<0, T, true /* IsConst */> { typedef const typename T::head_type type; }; } // end of namespace detail template struct element: public detail::element_impl::value> { }; #endif // -get function templates ----------------------------------------------- // Usage: get(aTuple) // -- some traits classes for get functions // access traits lifted from detail namespace to be part of the interface, // (Joel de Guzman's suggestion). Rationale: get functions are part of the // interface, so should the way to express their return types be. template struct access_traits { typedef const T& const_type; typedef T& non_const_type; typedef const typename boost::remove_cv::type& parameter_type; // used as the tuple constructors parameter types // Rationale: non-reference tuple element types can be cv-qualified. // It should be possible to initialize such types with temporaries, // and when binding temporaries to references, the reference must // be non-volatile and const. 8.5.3. (5) }; template struct access_traits { typedef T& const_type; typedef T& non_const_type; typedef T& parameter_type; }; // get function for non-const cons-lists, returns a reference to the element template inline typename access_traits< typename element >::type >::non_const_type get(cons& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { #if BOOST_WORKAROUND(__IBMCPP__,==600 ) return detail::get_class:: #else return detail::get_class::BOOST_NESTED_TEMPLATE #endif get< typename access_traits< typename element >::type >::non_const_type, HT,TT >(c); } // get function for const cons-lists, returns a const reference to // the element. If the element is a reference, returns the reference // as such (that is, can return a non-const reference) template inline typename access_traits< typename element >::type >::const_type get(const cons& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { #if BOOST_WORKAROUND(__IBMCPP__,==600) return detail::get_class:: #else return detail::get_class::BOOST_NESTED_TEMPLATE #endif get< typename access_traits< typename element >::type >::const_type, HT,TT >(c); } // -- the cons template -------------------------------------------------- namespace detail { // These helper templates wrap void types and plain function types. // The reationale is to allow one to write tuple types with those types // as elements, even though it is not possible to instantiate such object. // E.g: typedef tuple some_type; // ok // but: some_type x; // fails template class non_storeable_type { non_storeable_type(); }; template struct wrap_non_storeable_type { typedef typename IF< ::boost::is_function::value, non_storeable_type, T >::RET type; }; template <> struct wrap_non_storeable_type { typedef non_storeable_type type; }; } // detail template struct cons { typedef HT head_type; typedef TT tail_type; typedef typename detail::wrap_non_storeable_type::type stored_head_type; stored_head_type head; tail_type tail; typename access_traits::non_const_type get_head() { return head; } typename access_traits::non_const_type get_tail() { return tail; } typename access_traits::const_type get_head() const { return head; } typename access_traits::const_type get_tail() const { return tail; } cons() : head(), tail() {} // cons() : head(detail::default_arg::f()), tail() {} // the argument for head is not strictly needed, but it prevents // array type elements. This is good, since array type elements // cannot be supported properly in any case (no assignment, // copy works only if the tails are exactly the same type, ...) cons(typename access_traits::parameter_type h, const tail_type& t) : head (h), tail(t) {} template cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) : head (t1), tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull()) {} template cons( const null_type& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) : head (), tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull()) {} template cons( const cons& u ) : head(u.head), tail(u.tail) {} template cons& operator=( const cons& u ) { head=u.head; tail=u.tail; return *this; } // must define assignment operator explicitly, implicit version is // illformed if HT is a reference (12.8. (12)) cons& operator=(const cons& u) { head = u.head; tail = u.tail; return *this; } template cons& operator=( const std::pair& u ) { BOOST_STATIC_ASSERT(length::value == 2); // check length = 2 head = u.first; tail.head = u.second; return *this; } // get member functions (non-const and const) template typename access_traits< typename element >::type >::non_const_type get() { return boost::tuples::get(*this); // delegate to non-member get } template typename access_traits< typename element >::type >::const_type get() const { return boost::tuples::get(*this); // delegate to non-member get } }; template struct cons { typedef HT head_type; typedef null_type tail_type; typedef cons self_type; typedef typename detail::wrap_non_storeable_type::type stored_head_type; stored_head_type head; typename access_traits::non_const_type get_head() { return head; } null_type get_tail() { return null_type(); } typename access_traits::const_type get_head() const { return head; } const null_type get_tail() const { return null_type(); } // cons() : head(detail::default_arg::f()) {} cons() : head() {} cons(typename access_traits::parameter_type h, const null_type& = null_type()) : head (h) {} template cons(T1& t1, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&) : head (t1) {} cons(const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&) : head () {} template cons( const cons& u ) : head(u.head) {} template cons& operator=(const cons& u ) { head = u.head; return *this; } // must define assignment operator explicitely, implicit version // is illformed if HT is a reference cons& operator=(const cons& u) { head = u.head; return *this; } template typename access_traits< typename element::type >::non_const_type get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { return boost::tuples::get(*this); } template typename access_traits< typename element::type >::const_type get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const { return boost::tuples::get(*this); } }; // templates for finding out the length of the tuple ------------------- template struct length { BOOST_STATIC_CONSTANT(int, value = 1 + length::value); }; template<> struct length > { BOOST_STATIC_CONSTANT(int, value = 0); }; template<> struct length { BOOST_STATIC_CONSTANT(int, value = 0); }; namespace detail { // Tuple to cons mapper -------------------------------------------------- template struct map_tuple_to_cons { typedef cons::type > type; }; // The empty tuple is a null_type template <> struct map_tuple_to_cons { typedef null_type type; }; } // end detail // ------------------------------------------------------------------- // -- tuple ------------------------------------------------------ template class tuple : public detail::map_tuple_to_cons::type { public: typedef typename detail::map_tuple_to_cons::type inherited; typedef typename inherited::head_type head_type; typedef typename inherited::tail_type tail_type; // access_traits::parameter_type takes non-reference types as const T& tuple() {} tuple(typename access_traits::parameter_type t0) : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1) : inherited(t0, t1, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2) : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3) : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3, typename access_traits::parameter_type t4) : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3, typename access_traits::parameter_type t4, typename access_traits::parameter_type t5) : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3, typename access_traits::parameter_type t4, typename access_traits::parameter_type t5, typename access_traits::parameter_type t6) : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3, typename access_traits::parameter_type t4, typename access_traits::parameter_type t5, typename access_traits::parameter_type t6, typename access_traits::parameter_type t7) : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3, typename access_traits::parameter_type t4, typename access_traits::parameter_type t5, typename access_traits::parameter_type t6, typename access_traits::parameter_type t7, typename access_traits::parameter_type t8) : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {} tuple(typename access_traits::parameter_type t0, typename access_traits::parameter_type t1, typename access_traits::parameter_type t2, typename access_traits::parameter_type t3, typename access_traits::parameter_type t4, typename access_traits::parameter_type t5, typename access_traits::parameter_type t6, typename access_traits::parameter_type t7, typename access_traits::parameter_type t8, typename access_traits::parameter_type t9) : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {} template tuple(const cons& p) : inherited(p) {} template tuple& operator=(const cons& k) { inherited::operator=(k); return *this; } template tuple& operator=(const std::pair& k) { BOOST_STATIC_ASSERT(length::value == 2);// check_length = 2 this->head = k.first; this->tail.head = k.second; return *this; } }; // The empty tuple template <> class tuple : public null_type { public: typedef null_type inherited; }; // Swallows any assignment (by Doug Gregor) namespace detail { struct swallow_assign { template swallow_assign const& operator=(const T&) const { return *this; } }; } // namespace detail // "ignore" allows tuple positions to be ignored when using "tie". detail::swallow_assign const ignore = detail::swallow_assign(); // --------------------------------------------------------------------------- // The call_traits for make_tuple // Honours the reference_wrapper class. // Must be instantiated with plain or const plain types (not with references) // from template foo(const T& t) : make_tuple_traits::type // from template foo(T& t) : make_tuple_traits::type // Conversions: // T -> T, // references -> compile_time_error // reference_wrapper -> T& // const reference_wrapper -> T& // array -> const ref array template struct make_tuple_traits { typedef T type; // commented away, see below (JJ) // typedef typename IF< // boost::is_function::value, // T&, // T>::RET type; }; // The is_function test was there originally for plain function types, // which can't be stored as such (we must either store them as references or // pointers). Such a type could be formed if make_tuple was called with a // reference to a function. // But this would mean that a const qualified function type was formed in // the make_tuple function and hence make_tuple can't take a function // reference as a parameter, and thus T can't be a function type. // So is_function test was removed. // (14.8.3. says that type deduction fails if a cv-qualified function type // is created. (It only applies for the case of explicitly specifying template // args, though?)) (JJ) template struct make_tuple_traits { typedef typename detail::generate_error:: do_not_use_with_reference_type error; }; // Arrays can't be stored as plain types; convert them to references. // All arrays are converted to const. This is because make_tuple takes its // parameters as const T& and thus the knowledge of the potential // non-constness of actual argument is lost. template struct make_tuple_traits { typedef const T (&type)[n]; }; template struct make_tuple_traits { typedef const T (&type)[n]; }; template struct make_tuple_traits { typedef const volatile T (&type)[n]; }; template struct make_tuple_traits { typedef const volatile T (&type)[n]; }; template struct make_tuple_traits >{ typedef T& type; }; template struct make_tuple_traits >{ typedef T& type; }; namespace detail { // a helper traits to make the make_tuple functions shorter (Vesa Karvonen's // suggestion) template < class T0 = null_type, class T1 = null_type, class T2 = null_type, class T3 = null_type, class T4 = null_type, class T5 = null_type, class T6 = null_type, class T7 = null_type, class T8 = null_type, class T9 = null_type > struct make_tuple_mapper { typedef tuple::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type, typename make_tuple_traits::type> type; }; } // end detail // -make_tuple function templates ----------------------------------- inline tuple<> make_tuple() { return tuple<>(); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0) { typedef typename detail::make_tuple_mapper::type t; return t(t0); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1) { typedef typename detail::make_tuple_mapper::type t; return t(t0, t1); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1, const T2& t2) { typedef typename detail::make_tuple_mapper::type t; return t(t0, t1, t2); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) { typedef typename detail::make_tuple_mapper::type t; return t(t0, t1, t2, t3); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4) { typedef typename detail::make_tuple_mapper::type t; return t(t0, t1, t2, t3, t4); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { typedef typename detail::make_tuple_mapper::type t; return t(t0, t1, t2, t3, t4, t5); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { typedef typename detail::make_tuple_mapper ::type t; return t(t0, t1, t2, t3, t4, t5, t6); } template inline typename detail::make_tuple_mapper::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { typedef typename detail::make_tuple_mapper ::type t; return t(t0, t1, t2, t3, t4, t5, t6, t7); } template inline typename detail::make_tuple_mapper ::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) { typedef typename detail::make_tuple_mapper ::type t; return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); } template inline typename detail::make_tuple_mapper ::type make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) { typedef typename detail::make_tuple_mapper ::type t; return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); } // Tie function templates ------------------------------------------------- template inline tuple tie(T1& t1) { return tuple (t1); } template inline tuple tie(T1& t1, T2& t2) { return tuple (t1, t2); } template inline tuple tie(T1& t1, T2& t2, T3& t3) { return tuple (t1, t2, t3); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4) { return tuple (t1, t2, t3, t4); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) { return tuple (t1, t2, t3, t4, t5); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) { return tuple (t1, t2, t3, t4, t5, t6); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) { return tuple (t1, t2, t3, t4, t5, t6, t7); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) { return tuple (t1, t2, t3, t4, t5, t6, t7, t8); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) { return tuple (t1, t2, t3, t4, t5, t6, t7, t8, t9); } template inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9, T10& t10) { return tuple (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); } } // end of namespace tuples } // end of namespace boost #endif // BOOST_TUPLE_BASIC_HPP ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/detail/tuple_basic_no_partial_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tuple/detail/tuple_ba0000644000175000017500000006404111344301501031557 0ustar debiandebian// - tuple_basic_no_partial_spec.hpp ----------------------------------------- // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu) // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org or http://lambda.cs.utu.fi // Revision History // 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG) // 10 02 01 Fixed "null_type" constructors. // Implemented comparison operators globally. // Hide element_type_ref and element_type_const_ref. // (DG). // 09 02 01 Extended to tuples of length 10. Changed comparison for // operator<() // to the same used by std::pair<>, added cnull_type() (GP) // 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG) // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP #define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP #include "boost/type_traits.hpp" #include #if defined BOOST_MSVC #pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored #pragma warning(disable:4181) // qualifier applied to reference type ignored #pragma warning(disable:4227) // qualifier applied to reference type ignored #endif namespace boost { namespace tuples { // null_type denotes the end of a list built with "cons" struct null_type { null_type() {} null_type(const null_type&, const null_type&) {} }; // a helper function to provide a const null_type type temporary inline const null_type cnull_type() { return null_type(); } // forward declaration of tuple template< typename T1 = null_type, typename T2 = null_type, typename T3 = null_type, typename T4 = null_type, typename T5 = null_type, typename T6 = null_type, typename T7 = null_type, typename T8 = null_type, typename T9 = null_type, typename T10 = null_type > class tuple; // forward declaration of cons template struct cons; namespace detail { // Takes a pointer and routes all assignments to whatever it points to template struct assign_to_pointee { public: explicit assign_to_pointee(T* p) : ptr(p) {} template assign_to_pointee& operator=(const Other& other) { *ptr = other; return *this; } private: T* ptr; }; // Swallows any assignment struct swallow_assign { template swallow_assign const& operator=(const T&) const { return *this; } }; template struct add_const_reference : add_reference::type> {}; template struct init_tail { // Each of vc6 and vc7 seem to require a different formulation // of this return type template #if BOOST_WORKAROUND(BOOST_MSVC, == 1200) static typename add_reference::type>::type #else static typename add_const_reference::type #endif execute( cons const& u, long ) { return u.get_tail(); } }; template <> struct init_tail { template static null_type execute( cons const& u, long ) { return null_type(); } template static null_type execute(U const&, ...) { return null_type(); } private: template void execute( cons const&, int); }; template Other const& init_head( Other const& u, ... ) { return u; } template typename add_reference::type>::type init_head( cons const& u, int ) { return u.get_head(); } inline char**** init_head(null_type const&, int); } // end of namespace detail // cons builds a heterogenous list of types template struct cons { typedef cons self_type; typedef Head head_type; typedef Tail tail_type; private: typedef typename boost::add_reference::type head_ref; typedef typename boost::add_reference::type tail_ref; typedef typename detail::add_const_reference::type head_cref; typedef typename detail::add_const_reference::type tail_cref; public: head_type head; tail_type tail; head_ref get_head() { return head; } tail_ref get_tail() { return tail; } head_cref get_head() const { return head; } tail_cref get_tail() const { return tail; } cons() : head(), tail() {} #if defined BOOST_MSVC template cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf. const Tail& t) : head(h), tail(t.head, t.tail) { } cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf. const null_type& t) : head(h), tail(t) { } #else template explicit cons(head_cref h, const T& t) : head(h), tail(t.head, t.tail) { } explicit cons(head_cref h = head_type(), tail_cref t = tail_type()) : head(h), tail(t) { } #endif template cons( const U& u ) : head(detail::init_head(u, 0)) , tail(detail::init_tail::execute(u, 0L)) { } template cons& operator=(const Other& other) { head = other.head; tail = other.tail; return *this; } }; namespace detail { // Determines if the parameter is null_type template struct is_null_type { enum { RET = 0 }; }; template<> struct is_null_type { enum { RET = 1 }; }; /* Build a cons structure from the given Head and Tail. If both are null_type, return null_type. */ template struct build_cons { private: enum { tail_is_null_type = is_null_type::RET }; public: typedef cons RET; }; template<> struct build_cons { typedef null_type RET; }; // Map the N elements of a tuple into a cons list template< typename T1, typename T2 = null_type, typename T3 = null_type, typename T4 = null_type, typename T5 = null_type, typename T6 = null_type, typename T7 = null_type, typename T8 = null_type, typename T9 = null_type, typename T10 = null_type > struct map_tuple_to_cons { typedef typename detail::build_cons::RET cons10; typedef typename detail::build_cons::RET cons9; typedef typename detail::build_cons::RET cons8; typedef typename detail::build_cons::RET cons7; typedef typename detail::build_cons::RET cons6; typedef typename detail::build_cons::RET cons5; typedef typename detail::build_cons::RET cons4; typedef typename detail::build_cons::RET cons3; typedef typename detail::build_cons::RET cons2; typedef typename detail::build_cons::RET cons1; }; // Workaround the lack of partial specialization in some compilers template struct _element_type { template struct inner { private: typedef typename Tuple::tail_type tail_type; typedef _element_type next_elt_type; public: typedef typename _element_type::template inner::RET RET; }; }; template<> struct _element_type<0> { template struct inner { typedef typename Tuple::head_type RET; }; }; } // namespace detail // Return the Nth type of the given Tuple template struct element { private: typedef detail::_element_type nth_type; public: typedef typename nth_type::template inner::RET RET; typedef RET type; }; namespace detail { #if defined(BOOST_MSVC) && (BOOST_MSVC == 1300) // special workaround for vc7: template struct reference_adder { template struct rebind { typedef T& type; }; }; template <> struct reference_adder { template struct rebind { typedef T type; }; }; // Return a reference to the Nth type of the given Tuple template struct element_ref { private: typedef typename element::RET elt_type; enum { is_ref = is_reference::value }; public: typedef reference_adder::rebind::type RET; typedef RET type; }; // Return a const reference to the Nth type of the given Tuple template struct element_const_ref { private: typedef typename element::RET elt_type; enum { is_ref = is_reference::value }; public: typedef reference_adder::rebind::type RET; typedef RET type; }; #else // vc7 // Return a reference to the Nth type of the given Tuple template struct element_ref { private: typedef typename element::RET elt_type; public: typedef typename add_reference::type RET; typedef RET type; }; // Return a const reference to the Nth type of the given Tuple template struct element_const_ref { private: typedef typename element::RET elt_type; public: typedef typename add_reference::type RET; typedef RET type; }; #endif // vc7 } // namespace detail // Get length of this tuple template struct length { BOOST_STATIC_CONSTANT(int, value = 1 + length::value); }; template<> struct length > { BOOST_STATIC_CONSTANT(int, value = 0); }; template<> struct length { BOOST_STATIC_CONSTANT(int, value = 0); }; namespace detail { // Reference the Nth element in a tuple and retrieve it with "get" template struct get_class { template static inline typename detail::element_ref >::RET get(cons& t) { return get_class::get(t.tail); } template static inline typename detail::element_const_ref >::RET get(const cons& t) { return get_class::get(t.tail); } }; template<> struct get_class<0> { template static inline typename add_reference::type get(cons& t) { return t.head; } template static inline typename add_reference::type get(const cons& t) { return t.head; } }; } // namespace detail // tuple class template< typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10 > class tuple : public detail::map_tuple_to_cons::cons1 { private: typedef detail::map_tuple_to_cons mapped_tuple; typedef typename mapped_tuple::cons10 cons10; typedef typename mapped_tuple::cons9 cons9; typedef typename mapped_tuple::cons8 cons8; typedef typename mapped_tuple::cons7 cons7; typedef typename mapped_tuple::cons6 cons6; typedef typename mapped_tuple::cons5 cons5; typedef typename mapped_tuple::cons4 cons4; typedef typename mapped_tuple::cons3 cons3; typedef typename mapped_tuple::cons2 cons2; typedef typename mapped_tuple::cons1 cons1; typedef typename detail::add_const_reference::type t1_cref; typedef typename detail::add_const_reference::type t2_cref; typedef typename detail::add_const_reference::type t3_cref; typedef typename detail::add_const_reference::type t4_cref; typedef typename detail::add_const_reference::type t5_cref; typedef typename detail::add_const_reference::type t6_cref; typedef typename detail::add_const_reference::type t7_cref; typedef typename detail::add_const_reference::type t8_cref; typedef typename detail::add_const_reference::type t9_cref; typedef typename detail::add_const_reference::type t10_cref; public: typedef cons1 inherited; typedef tuple self_type; tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10())))))))))) {} tuple( t1_cref t1, t2_cref t2, t3_cref t3 = T3(), t4_cref t4 = T4(), t5_cref t5 = T5(), t6_cref t6 = T6(), t7_cref t7 = T7(), t8_cref t8 = T8(), t9_cref t9 = T9(), t10_cref t10 = T10() ) : cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10)))))))))) { } explicit tuple(t1_cref t1) : cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10())))))))))) {} template tuple(const cons& other) : cons1(other.head, other.tail) { } template self_type& operator=(const std::pair& other) { this->head = other.first; this->tail.head = other.second; return *this; } template self_type& operator=(const cons& other) { this->head = other.head; this->tail = other.tail; return *this; } }; namespace detail { template struct workaround_holder {}; } // namespace detail template typename detail::element_ref >::RET get(cons& t, detail::workaround_holder* = 0) { return detail::get_class::get(t); } template typename detail::element_const_ref >::RET get(const cons& t, detail::workaround_holder* = 0) { return detail::get_class::get(t); } // Make a tuple template inline tuple make_tuple(const T1& t1) { return tuple(t1); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2) { return tuple(t1, t2); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3) { return tuple(t1, t2, t3); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) { return tuple(t1, t2, t3, t4); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { return tuple(t1, t2, t3, t4, t5); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { return tuple(t1, t2, t3, t4, t5, t6); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { return tuple(t1, t2, t3, t4, t5, t6, t7); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) { return tuple(t1, t2, t3, t4, t5, t6, t7, t8); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) { return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9); } // Make a tuple template inline tuple make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) { return tuple(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); } // Tie variables into a tuple template inline tuple > tie(T1& t1) { return make_tuple(detail::assign_to_pointee(&t1)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee > tie(T1& t1, T2& t2) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4), detail::assign_to_pointee(&t5)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4), detail::assign_to_pointee(&t5), detail::assign_to_pointee(&t6)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4), detail::assign_to_pointee(&t5), detail::assign_to_pointee(&t6), detail::assign_to_pointee(&t7)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4), detail::assign_to_pointee(&t5), detail::assign_to_pointee(&t6), detail::assign_to_pointee(&t7), detail::assign_to_pointee(&t8)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4), detail::assign_to_pointee(&t5), detail::assign_to_pointee(&t6), detail::assign_to_pointee(&t7), detail::assign_to_pointee(&t8), detail::assign_to_pointee(&t9)); } // Tie variables into a tuple template inline tuple, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee, detail::assign_to_pointee > tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10) { return make_tuple(detail::assign_to_pointee(&t1), detail::assign_to_pointee(&t2), detail::assign_to_pointee(&t3), detail::assign_to_pointee(&t4), detail::assign_to_pointee(&t5), detail::assign_to_pointee(&t6), detail::assign_to_pointee(&t7), detail::assign_to_pointee(&t8), detail::assign_to_pointee(&t9), detail::assign_to_pointee(&t10)); } // "ignore" allows tuple positions to be ignored when using "tie". detail::swallow_assign const ignore = detail::swallow_assign(); } // namespace tuples } // namespace boost #endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/concept_archetype.hpp0000644000175000017500000005616711344301501031670 0ustar debiandebian// // (C) Copyright Jeremy Siek 2000. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Revision History: // // 17 July 2001: Added const to some member functions. (Jeremy Siek) // 05 May 2001: Removed static dummy_cons object. (Jeremy Siek) // See http://www.boost.org/libs/concept_check for documentation. #ifndef BOOST_CONCEPT_ARCHETYPES_HPP #define BOOST_CONCEPT_ARCHETYPES_HPP #include #include #include #include namespace boost { //=========================================================================== // Basic Archetype Classes namespace detail { class dummy_constructor { }; } // A type that models no concept. The template parameter // is only there so that null_archetype types can be created // that have different type. template class null_archetype { private: null_archetype() { } null_archetype(const null_archetype&) { } null_archetype& operator=(const null_archetype&) { return *this; } public: null_archetype(detail::dummy_constructor) { } #ifndef __MWERKS__ template friend void dummy_friend(); // just to avoid warnings #endif }; // This is a helper class that provides a way to get a reference to // an object. The get() function will never be called at run-time // (nothing in this file will) so this seemingly very bad function // is really quite innocent. The name of this class needs to be // changed. template class static_object { public: static T& get() { #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) return *reinterpret_cast(0); #else static char d[sizeof(T)]; return *reinterpret_cast(d); #endif } }; template > class default_constructible_archetype : public Base { public: default_constructible_archetype() : Base(static_object::get()) { } default_constructible_archetype(detail::dummy_constructor x) : Base(x) { } }; template > class assignable_archetype : public Base { assignable_archetype() { } assignable_archetype(const assignable_archetype&) { } public: assignable_archetype& operator=(const assignable_archetype&) { return *this; } assignable_archetype(detail::dummy_constructor x) : Base(x) { } }; template > class copy_constructible_archetype : public Base { public: copy_constructible_archetype() : Base(static_object::get()) { } copy_constructible_archetype(const copy_constructible_archetype&) : Base(static_object::get()) { } copy_constructible_archetype(detail::dummy_constructor x) : Base(x) { } }; template > class sgi_assignable_archetype : public Base { public: sgi_assignable_archetype(const sgi_assignable_archetype&) : Base(static_object::get()) { } sgi_assignable_archetype& operator=(const sgi_assignable_archetype&) { return *this; } sgi_assignable_archetype(const detail::dummy_constructor& x) : Base(x) { } }; struct default_archetype_base { default_archetype_base(detail::dummy_constructor) { } }; // Careful, don't use same type for T and Base. That results in the // conversion operator being invalid. Since T is often // null_archetype, can't use null_archetype for Base. template class convertible_to_archetype : public Base { private: convertible_to_archetype() { } convertible_to_archetype(const convertible_to_archetype& ) { } convertible_to_archetype& operator=(const convertible_to_archetype&) { return *this; } public: convertible_to_archetype(detail::dummy_constructor x) : Base(x) { } operator const T&() const { return static_object::get(); } }; template class convertible_from_archetype : public Base { private: convertible_from_archetype() { } convertible_from_archetype(const convertible_from_archetype& ) { } convertible_from_archetype& operator=(const convertible_from_archetype&) { return *this; } public: convertible_from_archetype(detail::dummy_constructor x) : Base(x) { } convertible_from_archetype(const T&) { } convertible_from_archetype& operator=(const T&) { return *this; } }; class boolean_archetype { public: boolean_archetype(const boolean_archetype&) { } operator bool() const { return true; } boolean_archetype(detail::dummy_constructor) { } private: boolean_archetype() { } boolean_archetype& operator=(const boolean_archetype&) { return *this; } }; template > class equality_comparable_archetype : public Base { public: equality_comparable_archetype(detail::dummy_constructor x) : Base(x) { } }; template boolean_archetype operator==(const equality_comparable_archetype&, const equality_comparable_archetype&) { return boolean_archetype(static_object::get()); } template boolean_archetype operator!=(const equality_comparable_archetype&, const equality_comparable_archetype&) { return boolean_archetype(static_object::get()); } template > class equality_comparable2_first_archetype : public Base { public: equality_comparable2_first_archetype(detail::dummy_constructor x) : Base(x) { } }; template > class equality_comparable2_second_archetype : public Base { public: equality_comparable2_second_archetype(detail::dummy_constructor x) : Base(x) { } }; template boolean_archetype operator==(const equality_comparable2_first_archetype&, const equality_comparable2_second_archetype&) { return boolean_archetype(static_object::get()); } template boolean_archetype operator!=(const equality_comparable2_first_archetype&, const equality_comparable2_second_archetype&) { return boolean_archetype(static_object::get()); } template > class less_than_comparable_archetype : public Base { public: less_than_comparable_archetype(detail::dummy_constructor x) : Base(x) { } }; template boolean_archetype operator<(const less_than_comparable_archetype&, const less_than_comparable_archetype&) { return boolean_archetype(static_object::get()); } template > class comparable_archetype : public Base { public: comparable_archetype(detail::dummy_constructor x) : Base(x) { } }; template boolean_archetype operator<(const comparable_archetype&, const comparable_archetype&) { return boolean_archetype(static_object::get()); } template boolean_archetype operator<=(const comparable_archetype&, const comparable_archetype&) { return boolean_archetype(static_object::get()); } template boolean_archetype operator>(const comparable_archetype&, const comparable_archetype&) { return boolean_archetype(static_object::get()); } template boolean_archetype operator>=(const comparable_archetype&, const comparable_archetype&) { return boolean_archetype(static_object::get()); } // The purpose of the optags is so that one can specify // exactly which types the operator< is defined between. // This is useful for allowing the operations: // // A a; B b; // a < b // b < a // // without also allowing the combinations: // // a < a // b < b // struct optag1 { }; struct optag2 { }; struct optag3 { }; #define BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(OP, NAME) \ template , class Tag = optag1 > \ class NAME##_first_archetype : public Base { \ public: \ NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \ }; \ \ template , class Tag = optag1 > \ class NAME##_second_archetype : public Base { \ public: \ NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \ }; \ \ template \ boolean_archetype \ operator OP (const NAME##_first_archetype&, \ const NAME##_second_archetype&) \ { \ return boolean_archetype(static_object::get()); \ } BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(==, equal_op) BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(!=, not_equal_op) BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<, less_than_op) BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<=, less_equal_op) BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>, greater_than_op) BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>=, greater_equal_op) #define BOOST_DEFINE_OPERATOR_ARCHETYPE(OP, NAME) \ template > \ class NAME##_archetype : public Base { \ public: \ NAME##_archetype(detail::dummy_constructor x) : Base(x) { } \ NAME##_archetype(const NAME##_archetype&) \ : Base(static_object::get()) { } \ NAME##_archetype& operator=(const NAME##_archetype&) { return *this; } \ }; \ template \ NAME##_archetype \ operator OP (const NAME##_archetype&,\ const NAME##_archetype&) \ { \ return \ NAME##_archetype(static_object::get()); \ } BOOST_DEFINE_OPERATOR_ARCHETYPE(+, addable) BOOST_DEFINE_OPERATOR_ARCHETYPE(-, subtractable) BOOST_DEFINE_OPERATOR_ARCHETYPE(*, multipliable) BOOST_DEFINE_OPERATOR_ARCHETYPE(/, dividable) BOOST_DEFINE_OPERATOR_ARCHETYPE(%, modable) // As is, these are useless because of the return type. // Need to invent a better way... #define BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(OP, NAME) \ template > \ class NAME##_first_archetype : public Base { \ public: \ NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \ }; \ \ template > \ class NAME##_second_archetype : public Base { \ public: \ NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \ }; \ \ template \ Return \ operator OP (const NAME##_first_archetype&, \ const NAME##_second_archetype&) \ { \ return Return(static_object::get()); \ } BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(+, plus_op) BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(*, time_op) BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(/, divide_op) BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(-, subtract_op) BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(%, mod_op) //=========================================================================== // Function Object Archetype Classes template class generator_archetype { public: const Return& operator()() { return static_object::get(); } }; class void_generator_archetype { public: void operator()() { } }; template class unary_function_archetype { private: unary_function_archetype() { } public: unary_function_archetype(detail::dummy_constructor) { } const Return& operator()(const Arg&) const { return static_object::get(); } }; template class binary_function_archetype { private: binary_function_archetype() { } public: binary_function_archetype(detail::dummy_constructor) { } const Return& operator()(const Arg1&, const Arg2&) const { return static_object::get(); } }; template class unary_predicate_archetype { typedef boolean_archetype Return; unary_predicate_archetype() { } public: unary_predicate_archetype(detail::dummy_constructor) { } const Return& operator()(const Arg&) const { return static_object::get(); } }; template > class binary_predicate_archetype { typedef boolean_archetype Return; binary_predicate_archetype() { } public: binary_predicate_archetype(detail::dummy_constructor) { } const Return& operator()(const Arg1&, const Arg2&) const { return static_object::get(); } }; //=========================================================================== // Iterator Archetype Classes template class input_iterator_archetype { private: typedef input_iterator_archetype self; public: typedef std::input_iterator_tag iterator_category; typedef T value_type; struct reference { operator const value_type&() const { return static_object::get(); } }; typedef const T* pointer; typedef std::ptrdiff_t difference_type; self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return reference(); } self& operator++() { return *this; } self operator++(int) { return *this; } }; template class input_iterator_archetype_no_proxy { private: typedef input_iterator_archetype_no_proxy self; public: typedef std::input_iterator_tag iterator_category; typedef T value_type; typedef const T& reference; typedef const T* pointer; typedef std::ptrdiff_t difference_type; self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } }; template struct output_proxy { output_proxy& operator=(const T&) { return *this; } }; template class output_iterator_archetype { public: typedef output_iterator_archetype self; public: typedef std::output_iterator_tag iterator_category; typedef output_proxy value_type; typedef output_proxy reference; typedef void pointer; typedef void difference_type; output_iterator_archetype(detail::dummy_constructor) { } output_iterator_archetype(const self&) { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return output_proxy(); } self& operator++() { return *this; } self operator++(int) { return *this; } private: output_iterator_archetype() { } }; template class input_output_iterator_archetype { private: typedef input_output_iterator_archetype self; struct in_out_tag : public std::input_iterator_tag, public std::output_iterator_tag { }; public: typedef in_out_tag iterator_category; typedef T value_type; struct reference { reference& operator=(const T&) { return *this; } operator value_type() { return static_object::get(); } }; typedef const T* pointer; typedef std::ptrdiff_t difference_type; input_output_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return reference(); } self& operator++() { return *this; } self operator++(int) { return *this; } }; template class forward_iterator_archetype { public: typedef forward_iterator_archetype self; public: typedef std::forward_iterator_tag iterator_category; typedef T value_type; typedef const T& reference; typedef T const* pointer; typedef std::ptrdiff_t difference_type; forward_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } }; template class mutable_forward_iterator_archetype { public: typedef mutable_forward_iterator_archetype self; public: typedef std::forward_iterator_tag iterator_category; typedef T value_type; typedef T& reference; typedef T* pointer; typedef std::ptrdiff_t difference_type; mutable_forward_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } }; template class bidirectional_iterator_archetype { public: typedef bidirectional_iterator_archetype self; public: typedef std::bidirectional_iterator_tag iterator_category; typedef T value_type; typedef const T& reference; typedef T* pointer; typedef std::ptrdiff_t difference_type; bidirectional_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } self& operator--() { return *this; } self operator--(int) { return *this; } }; template class mutable_bidirectional_iterator_archetype { public: typedef mutable_bidirectional_iterator_archetype self; public: typedef std::bidirectional_iterator_tag iterator_category; typedef T value_type; typedef T& reference; typedef T* pointer; typedef std::ptrdiff_t difference_type; mutable_bidirectional_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } self& operator--() { return *this; } self operator--(int) { return *this; } }; template class random_access_iterator_archetype { public: typedef random_access_iterator_archetype self; public: typedef std::random_access_iterator_tag iterator_category; typedef T value_type; typedef const T& reference; typedef T* pointer; typedef std::ptrdiff_t difference_type; random_access_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } self& operator--() { return *this; } self operator--(int) { return *this; } reference operator[](difference_type) const { return static_object::get(); } self& operator+=(difference_type) { return *this; } self& operator-=(difference_type) { return *this; } difference_type operator-(const self&) const { return difference_type(); } self operator+(difference_type) const { return *this; } self operator-(difference_type) const { return *this; } bool operator<(const self&) const { return true; } bool operator<=(const self&) const { return true; } bool operator>(const self&) const { return true; } bool operator>=(const self&) const { return true; } }; template random_access_iterator_archetype operator+(typename random_access_iterator_archetype::difference_type, const random_access_iterator_archetype& x) { return x; } template class mutable_random_access_iterator_archetype { public: typedef mutable_random_access_iterator_archetype self; public: typedef std::random_access_iterator_tag iterator_category; typedef T value_type; typedef T& reference; typedef T* pointer; typedef std::ptrdiff_t difference_type; mutable_random_access_iterator_archetype() { } self& operator=(const self&) { return *this; } bool operator==(const self&) const { return true; } bool operator!=(const self&) const { return true; } reference operator*() const { return static_object::get(); } self& operator++() { return *this; } self operator++(int) { return *this; } self& operator--() { return *this; } self operator--(int) { return *this; } reference operator[](difference_type) const { return static_object::get(); } self& operator+=(difference_type) { return *this; } self& operator-=(difference_type) { return *this; } difference_type operator-(const self&) const { return difference_type(); } self operator+(difference_type) const { return *this; } self operator-(difference_type) const { return *this; } bool operator<(const self&) const { return true; } bool operator<=(const self&) const { return true; } bool operator>(const self&) const { return true; } bool operator>=(const self&) const { return true; } }; template mutable_random_access_iterator_archetype operator+ (typename mutable_random_access_iterator_archetype::difference_type, const mutable_random_access_iterator_archetype& x) { return x; } } // namespace boost #endif // BOOST_CONCEPT_ARCHETYPES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/weak_ptr.hpp0000644000175000017500000001020311344301501027762 0ustar debiandebian#ifndef BOOST_WEAK_PTR_HPP_INCLUDED #define BOOST_WEAK_PTR_HPP_INCLUDED // // weak_ptr.hpp // // Copyright (c) 2001, 2002, 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation. // #include #ifdef BOOST_MSVC // moved here to work around VC++ compiler crash # pragma warning(push) # pragma warning(disable:4284) // odd return type for operator-> #endif namespace boost { template class weak_ptr { private: // Borland 5.5.1 specific workarounds typedef weak_ptr this_type; public: typedef T element_type; weak_ptr(): px(0), pn() // never throws in 1.30+ { } // generated copy constructor, assignment, destructor are fine // // The "obvious" converting constructor implementation: // // template // weak_ptr(weak_ptr const & r): px(r.px), pn(r.pn) // never throws // { // } // // has a serious problem. // // r.px may already have been invalidated. The px(r.px) // conversion may require access to *r.px (virtual inheritance). // // It is not possible to avoid spurious access violations since // in multithreaded programs r.px may be invalidated at any point. // template weak_ptr(weak_ptr const & r): pn(r.pn) // never throws { px = r.lock().get(); } template weak_ptr(shared_ptr const & r): px(r.px), pn(r.pn) // never throws { } #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200) template weak_ptr & operator=(weak_ptr const & r) // never throws { px = r.lock().get(); pn = r.pn; return *this; } template weak_ptr & operator=(shared_ptr const & r) // never throws { px = r.px; pn = r.pn; return *this; } #endif shared_ptr lock() const // never throws { #if defined(BOOST_HAS_THREADS) // optimization: avoid throw overhead if(expired()) { return shared_ptr(); } try { return shared_ptr(*this); } catch(bad_weak_ptr const &) { // Q: how can we get here? // A: another thread may have invalidated r after the use_count test above. return shared_ptr(); } #else // optimization: avoid try/catch overhead when single threaded return expired()? shared_ptr(): shared_ptr(*this); #endif } long use_count() const // never throws { return pn.use_count(); } bool expired() const // never throws { return pn.use_count() == 0; } void reset() // never throws in 1.30+ { this_type().swap(*this); } void swap(this_type & other) // never throws { std::swap(px, other.px); pn.swap(other.pn); } void _internal_assign(T * px2, detail::shared_count const & pn2) { px = px2; pn = pn2; } template bool _internal_less(weak_ptr const & rhs) const { return pn < rhs.pn; } // Tasteless as this may seem, making all members public allows member templates // to work in the absence of member template friends. (Matthew Langston) #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: template friend class weak_ptr; template friend class shared_ptr; #endif T * px; // contained pointer detail::weak_count pn; // reference counter }; // weak_ptr template inline bool operator<(weak_ptr const & a, weak_ptr const & b) { return a._internal_less(b); } template void swap(weak_ptr & a, weak_ptr & b) { a.swap(b); } // deprecated, provided for backward compatibility template shared_ptr make_shared(weak_ptr const & r) { return r.lock(); } } // namespace boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #endif // #ifndef BOOST_WEAK_PTR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/current_function.hpp0000644000175000017500000000255711344301501031552 0ustar debiandebian#ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED #define BOOST_CURRENT_FUNCTION_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/current_function.hpp - BOOST_CURRENT_FUNCTION // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // http://www.boost.org/libs/utility/current_function.html // namespace boost { namespace detail { inline void current_function_helper() { #if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__ #elif defined(__FUNCSIG__) # define BOOST_CURRENT_FUNCTION __FUNCSIG__ #elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || (defined(__IBMCPP__) && (__IBMCPP__ >= 500)) # define BOOST_CURRENT_FUNCTION __FUNCTION__ #elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550) # define BOOST_CURRENT_FUNCTION __FUNC__ #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901) # define BOOST_CURRENT_FUNCTION __func__ #else # define BOOST_CURRENT_FUNCTION "(unknown)" #endif } } // namespace detail } // namespace boost #endif // #ifndef BOOST_CURRENT_FUNCTION_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/vector_property_map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/vector_property_map.h0000644000175000017500000000603711344301501031723 0ustar debiandebian// Copyright (C) Vladimir Prus 2003. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/graph/vector_property_map.html for // documentation. // #ifndef VECTOR_PROPERTY_MAP_HPP_VP_2003_03_04 #define VECTOR_PROPERTY_MAP_HPP_VP_2003_03_04 #include #include #include namespace boost { template class vector_property_map : public boost::put_get_helper< typename std::iterator_traits< typename std::vector::iterator >::reference, vector_property_map > { public: typedef typename property_traits::key_type key_type; typedef T value_type; typedef typename std::iterator_traits< typename std::vector::iterator >::reference reference; typedef boost::lvalue_property_map_tag category; vector_property_map(const IndexMap& index = IndexMap()) : store(new std::vector()), index(index) {} vector_property_map(unsigned initial_size, const IndexMap& index = IndexMap()) : store(new std::vector(initial_size)), index(index) {} typename std::vector::iterator storage_begin() { return store->begin(); } typename std::vector::iterator storage_end() { return store->end(); } typename std::vector::const_iterator storage_begin() const { return store->begin(); } typename std::vector::const_iterator storage_end() const { return store->end(); } public: // Copy ctor absent, default semantics is OK. // Assignment operator absent, default semantics is OK. // CONSIDER: not sure that assignment to 'index' is correct. reference operator[](const key_type& v) const { typename property_traits::value_type i = get(index, v); if (i >= store->size()) { store->resize(i + 1); } return (*store)[i]; } private: // Conceptually, we have a vector of infinite size. For practical // purposes, we start with an empty vector and grow it as needed. // Note that we cannot store pointer to vector here -- we cannot // store pointer to data, because if copy of property map resizes // the vector, the pointer to data will be invalidated. // I wonder if class 'pmap_ref' is simply needed. shared_ptr< std::vector > store; IndexMap index; }; template vector_property_map make_vector_property_map(IndexMap index) { return vector_property_map(index); } } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/non_type.hpp0000644000175000017500000000115311344301501030005 0ustar debiandebian// ------------------------------------- // // (C) Copyright Gennaro Prota 2003. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // ------------------------------------------------------ #ifndef BOOST_NON_TYPE_HPP_GP_20030417 #define BOOST_NON_TYPE_HPP_GP_20030417 namespace boost { // Just a simple "envelope" for non-type template parameters. Useful // to work around some MSVC deficiencies. template struct non_type { }; } #endif // include guard mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/property_map.hpp0000644000175000017500000004475211344301501030707 0ustar debiandebian// (C) Copyright Jeremy Siek 1999-2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/property_map for documentation. #ifndef BOOST_PROPERTY_MAP_HPP #define BOOST_PROPERTY_MAP_HPP #include #include #include #include #include #include namespace boost { //========================================================================= // property_traits class template struct property_traits { typedef typename PA::key_type key_type; typedef typename PA::value_type value_type; typedef typename PA::reference reference; typedef typename PA::category category; }; //========================================================================= // property_traits category tags namespace detail { enum ePropertyMapID { READABLE_PA, WRITABLE_PA, READ_WRITE_PA, LVALUE_PA, OP_BRACKET_PA, RAND_ACCESS_ITER_PA, LAST_PA }; } struct readable_property_map_tag { enum { id = detail::READABLE_PA }; }; struct writable_property_map_tag { enum { id = detail::WRITABLE_PA }; }; struct read_write_property_map_tag : public readable_property_map_tag, public writable_property_map_tag { enum { id = detail::READ_WRITE_PA }; }; struct lvalue_property_map_tag : public read_write_property_map_tag { enum { id = detail::LVALUE_PA }; }; //========================================================================= // property_traits specialization for pointers #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // The user will just have to create their own specializations for // other pointers types if the compiler does not have partial // specializations. Sorry! #define BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(TYPE) \ template <> \ struct property_traits { \ typedef TYPE value_type; \ typedef value_type& reference; \ typedef std::ptrdiff_t key_type; \ typedef lvalue_property_map_tag category; \ }; \ template <> \ struct property_traits { \ typedef TYPE value_type; \ typedef const value_type& reference; \ typedef std::ptrdiff_t key_type; \ typedef lvalue_property_map_tag category; \ } BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(long); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned long); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(int); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned int); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(short); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned short); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(char); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(unsigned char); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(signed char); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(bool); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(float); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(double); BOOST_SPECIALIZE_PROPERTY_TRAITS_PTR(long double); // This may need to be turned off for some older compilers that don't have // wchar_t intrinsically. # ifndef BOOST_NO_INTRINSIC_WCHAR_T template <> struct property_traits { typedef wchar_t value_type; typedef value_type& reference; typedef std::ptrdiff_t key_type; typedef lvalue_property_map_tag category; }; template <> struct property_traits { typedef wchar_t value_type; typedef const value_type& reference; typedef std::ptrdiff_t key_type; typedef lvalue_property_map_tag category; }; # endif #else template struct property_traits { typedef T value_type; typedef value_type& reference; typedef std::ptrdiff_t key_type; typedef lvalue_property_map_tag category; }; template struct property_traits { typedef T value_type; typedef const value_type& reference; typedef std::ptrdiff_t key_type; typedef lvalue_property_map_tag category; }; #endif #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) // MSVC doesn't have Koenig lookup, so the user has to // do boost::get() anyways, and the using clause // doesn't really work for MSVC. } // namespace boost #endif // These need to go in global namespace because Koenig // lookup does not apply to T*. // V must be convertible to T template inline void put(T* pa, std::ptrdiff_t k, const V& val) { pa[k] = val; } template inline const T& get(const T* pa, std::ptrdiff_t k) { return pa[k]; } #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) namespace boost { using ::put; using ::get; #endif //========================================================================= // concept checks for property maps template struct ReadablePropertyMapConcept { typedef typename property_traits::key_type key_type; typedef typename property_traits::reference reference; typedef typename property_traits::category Category; typedef boost::readable_property_map_tag ReadableTag; void constraints() { function_requires< ConvertibleConcept >(); val = get(pmap, k); } PMap pmap; Key k; typename property_traits::value_type val; }; template struct readable_property_map_archetype { typedef KeyArchetype key_type; typedef ValueArchetype value_type; typedef convertible_to_archetype reference; typedef readable_property_map_tag category; }; template const typename readable_property_map_archetype::reference& get(const readable_property_map_archetype&, const typename readable_property_map_archetype::key_type&) { typedef typename readable_property_map_archetype::reference R; return static_object::get(); } template struct WritablePropertyMapConcept { typedef typename property_traits::key_type key_type; typedef typename property_traits::category Category; typedef boost::writable_property_map_tag WritableTag; void constraints() { function_requires< ConvertibleConcept >(); put(pmap, k, val); } PMap pmap; Key k; typename property_traits::value_type val; }; template struct writable_property_map_archetype { typedef KeyArchetype key_type; typedef ValueArchetype value_type; typedef void reference; typedef writable_property_map_tag category; }; template void put(const writable_property_map_archetype&, const typename writable_property_map_archetype::key_type&, const typename writable_property_map_archetype::value_type&) { } template struct ReadWritePropertyMapConcept { typedef typename property_traits::category Category; typedef boost::read_write_property_map_tag ReadWriteTag; void constraints() { function_requires< ReadablePropertyMapConcept >(); function_requires< WritablePropertyMapConcept >(); function_requires< ConvertibleConcept >(); } }; template struct read_write_property_map_archetype : public readable_property_map_archetype, public writable_property_map_archetype { typedef KeyArchetype key_type; typedef ValueArchetype value_type; typedef convertible_to_archetype reference; typedef read_write_property_map_tag category; }; template struct LvaluePropertyMapConcept { typedef typename property_traits::category Category; typedef boost::lvalue_property_map_tag LvalueTag; typedef typename property_traits::reference reference; void constraints() { function_requires< ReadablePropertyMapConcept >(); function_requires< ConvertibleConcept >(); typedef typename property_traits::value_type value_type; typedef typename require_same< const value_type&, reference>::type req; reference ref = pmap[k]; ignore_unused_variable_warning(ref); } PMap pmap; Key k; }; template struct lvalue_property_map_archetype : public readable_property_map_archetype { typedef KeyArchetype key_type; typedef ValueArchetype value_type; typedef const ValueArchetype& reference; typedef lvalue_property_map_tag category; const value_type& operator[](const key_type&) const { return static_object::get(); } }; template struct Mutable_LvaluePropertyMapConcept { typedef typename property_traits::category Category; typedef boost::lvalue_property_map_tag LvalueTag; typedef typename property_traits::reference reference; void constraints() { boost::function_requires< ReadWritePropertyMapConcept >(); boost::function_requires >(); typedef typename property_traits::value_type value_type; typedef typename require_same< value_type&, reference>::type req; reference ref = pmap[k]; ignore_unused_variable_warning(ref); } PMap pmap; Key k; }; template struct mutable_lvalue_property_map_archetype : public readable_property_map_archetype, public writable_property_map_archetype { typedef KeyArchetype key_type; typedef ValueArchetype value_type; typedef ValueArchetype& reference; typedef lvalue_property_map_tag category; value_type& operator[](const key_type&) const { return static_object::get(); } }; struct identity_property_map; // A helper class for constructing a property map // from a class that implements operator[] template struct put_get_helper { }; template inline Reference get(const put_get_helper& pa, const K& k) { Reference v = static_cast(pa)[k]; return v; } template inline void put(const put_get_helper& pa, K k, const V& v) { static_cast(pa)[k] = v; } //========================================================================= // Adapter to turn a RandomAccessIterator into a property map template ::value_type , class R = typename std::iterator_traits::reference #endif > class iterator_property_map : public boost::put_get_helper< R, iterator_property_map > { public: typedef typename property_traits::key_type key_type; typedef T value_type; typedef R reference; typedef boost::lvalue_property_map_tag category; inline iterator_property_map( RandomAccessIterator cc = RandomAccessIterator(), const IndexMap& _id = IndexMap() ) : iter(cc), index(_id) { } inline R operator[](key_type v) const { return *(iter + get(index, v)) ; } protected: RandomAccessIterator iter; IndexMap index; }; #if !defined BOOST_NO_STD_ITERATOR_TRAITS template inline iterator_property_map< RAIter, ID, typename std::iterator_traits::value_type, typename std::iterator_traits::reference> make_iterator_property_map(RAIter iter, ID id) { function_requires< RandomAccessIteratorConcept >(); typedef iterator_property_map< RAIter, ID, typename std::iterator_traits::value_type, typename std::iterator_traits::reference> PA; return PA(iter, id); } #endif template inline iterator_property_map make_iterator_property_map(RAIter iter, ID id, Value) { function_requires< RandomAccessIteratorConcept >(); typedef iterator_property_map PMap; return PMap(iter, id); } template ::value_type , class R = typename std::iterator_traits::reference #endif > class safe_iterator_property_map : public boost::put_get_helper< R, safe_iterator_property_map > { public: typedef typename property_traits::key_type key_type; typedef T value_type; typedef R reference; typedef boost::lvalue_property_map_tag category; inline safe_iterator_property_map( RandomAccessIterator first, std::size_t n = 0, const IndexMap& _id = IndexMap() ) : iter(first), n(n), index(_id) { } inline safe_iterator_property_map() { } inline R operator[](key_type v) const { assert(get(index, v) < n); return *(iter + get(index, v)) ; } typename property_traits::value_type size() const { return n; } protected: RandomAccessIterator iter; typename property_traits::value_type n; IndexMap index; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template inline safe_iterator_property_map< RAIter, ID, typename boost::detail::iterator_traits::value_type, typename boost::detail::iterator_traits::reference> make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id) { function_requires< RandomAccessIteratorConcept >(); typedef safe_iterator_property_map< RAIter, ID, typename boost::detail::iterator_traits::value_type, typename boost::detail::iterator_traits::reference> PA; return PA(iter, n, id); } #endif template inline safe_iterator_property_map make_safe_iterator_property_map(RAIter iter, std::size_t n, ID id, Value) { function_requires< RandomAccessIteratorConcept >(); typedef safe_iterator_property_map PMap; return PMap(iter, n, id); } //========================================================================= // An adaptor to turn a Unique Pair Associative Container like std::map or // std::hash_map into an Lvalue Property Map. template class associative_property_map : public boost::put_get_helper< typename UniquePairAssociativeContainer::value_type::second_type&, associative_property_map > { typedef UniquePairAssociativeContainer C; public: typedef typename C::key_type key_type; typedef typename C::value_type::second_type value_type; typedef value_type& reference; typedef lvalue_property_map_tag category; associative_property_map() : m_c(0) { } associative_property_map(C& c) : m_c(&c) { } reference operator[](const key_type& k) const { return (*m_c)[k]; } private: C* m_c; }; template associative_property_map make_assoc_property_map(UniquePairAssociativeContainer& c) { return associative_property_map(c); } template class const_associative_property_map : public boost::put_get_helper< const typename UniquePairAssociativeContainer::value_type::second_type&, const_associative_property_map > { typedef UniquePairAssociativeContainer C; public: typedef typename C::key_type key_type; typedef typename C::value_type::second_type value_type; typedef const value_type& reference; typedef lvalue_property_map_tag category; const_associative_property_map() : m_c(0) { } const_associative_property_map(const C& c) : m_c(&c) { } reference operator[](const key_type& k) const { return m_c->find(k)->second; } private: C const* m_c; }; template const_associative_property_map make_assoc_property_map(const UniquePairAssociativeContainer& c) { return const_associative_property_map(c); } //========================================================================= // A property map that applies the identity function to integers struct identity_property_map : public boost::put_get_helper { typedef std::size_t key_type; typedef std::size_t value_type; typedef std::size_t reference; typedef boost::readable_property_map_tag category; inline value_type operator[](const key_type& v) const { return v; } }; //========================================================================= // A property map that does not do anything, for // when you have to supply a property map, but don't need it. namespace detail { struct dummy_pmap_reference { template dummy_pmap_reference& operator=(const T&) { return *this; } operator int() { return 0; } }; } class dummy_property_map : public boost::put_get_helper { public: typedef void key_type; typedef int value_type; typedef detail::dummy_pmap_reference reference; typedef boost::read_write_property_map_tag category; inline dummy_property_map() : c(0) { } inline dummy_property_map(value_type cc) : c(cc) { } inline dummy_property_map(const dummy_property_map& x) : c(x.c) { } template inline reference operator[](Vertex) const { return reference(); } protected: value_type c; }; } // namespace boost #endif /* BOOST_PROPERTY_MAP_HPP */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/integer_fwd.hpp0000644000175000017500000000650611344301501030456 0ustar debiandebian// Boost integer_fwd.hpp header file ---------------------------------------// // (C) Copyright Dave Abrahams and Daryle Walker 2001. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/integer for documentation. #ifndef BOOST_INTEGER_FWD_HPP #define BOOST_INTEGER_FWD_HPP #include // for UCHAR_MAX, etc. #include // for std::size_t #include // for BOOST_NO_INTRINSIC_WCHAR_T #include // for std::numeric_limits namespace boost { // From ------------------------------------------------// // Only has typedefs or using statements, with #conditionals // From -----------------------------------------// template < class T > class integer_traits; template < > class integer_traits< bool >; template < > class integer_traits< char >; template < > class integer_traits< signed char >; template < > class integer_traits< unsigned char >; #ifndef BOOST_NO_INTRINSIC_WCHAR_T template < > class integer_traits< wchar_t >; #endif template < > class integer_traits< short >; template < > class integer_traits< unsigned short >; template < > class integer_traits< int >; template < > class integer_traits< unsigned int >; template < > class integer_traits< long >; template < > class integer_traits< unsigned long >; #ifdef ULLONG_MAX template < > class integer_traits< ::boost::long_long_type>; template < > class integer_traits< ::boost::ulong_long_type >; #endif // From ------------------------------------------------// template < typename LeastInt > struct int_fast_t; template< int Bits > struct int_t; template< int Bits > struct uint_t; template< long MaxValue > struct int_max_value_t; template< long MinValue > struct int_min_value_t; template< unsigned long Value > struct uint_value_t; // From -----------------------------------// template < std::size_t Bit > struct high_bit_mask_t; template < std::size_t Bits > struct low_bits_mask_t; template < > struct low_bits_mask_t< ::std::numeric_limits::digits >; #if USHRT_MAX > UCHAR_MAX template < > struct low_bits_mask_t< ::std::numeric_limits::digits >; #endif #if UINT_MAX > USHRT_MAX template < > struct low_bits_mask_t< ::std::numeric_limits::digits >; #endif #if ULONG_MAX > UINT_MAX template < > struct low_bits_mask_t< ::std::numeric_limits::digits >; #endif // From ------------------------------------// template < unsigned long Value > struct static_log2; template < > struct static_log2< 0ul >; // From ---------------------------------// template < long Value1, long Value2 > struct static_signed_min; template < long Value1, long Value2 > struct static_signed_max; template < unsigned long Value1, unsigned long Value2 > struct static_unsigned_min; template < unsigned long Value1, unsigned long Value2 > struct static_unsigned_max; } // namespace boost #endif // BOOST_INTEGER_FWD_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/shared_ptr.hpp0000644000175000017500000002630711344301501030315 0ustar debiandebian#ifndef BOOST_SHARED_PTR_HPP_INCLUDED #define BOOST_SHARED_PTR_HPP_INCLUDED // // shared_ptr.hpp // // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002, 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. // #include // for broken compiler workarounds #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) #include #else #include #include #include #include #include #include // for std::auto_ptr #include // for std::swap #include // for std::less #include // for std::bad_cast #include // for std::basic_ostream #ifdef BOOST_MSVC // moved here to work around VC++ compiler crash # pragma warning(push) # pragma warning(disable:4284) // odd return type for operator-> #endif namespace boost { template class weak_ptr; template class enable_shared_from_this; namespace detail { struct static_cast_tag {}; struct const_cast_tag {}; struct dynamic_cast_tag {}; struct polymorphic_cast_tag {}; template struct shared_ptr_traits { typedef T & reference; }; template<> struct shared_ptr_traits { typedef void reference; }; #if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS) template<> struct shared_ptr_traits { typedef void reference; }; template<> struct shared_ptr_traits { typedef void reference; }; template<> struct shared_ptr_traits { typedef void reference; }; #endif // enable_shared_from_this support template void sp_enable_shared_from_this( shared_count const & pn, boost::enable_shared_from_this const * pe, Y const * px ) { if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast(px), pn); } inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... ) { } } // namespace detail // // shared_ptr // // An enhanced relative of scoped_ptr with reference counted copy semantics. // The object pointed to is deleted when the last shared_ptr pointing to it // is destroyed or reset. // template class shared_ptr { private: // Borland 5.5.1 specific workaround typedef shared_ptr this_type; public: typedef T element_type; typedef T value_type; typedef T * pointer; typedef typename detail::shared_ptr_traits::reference reference; shared_ptr(): px(0), pn() // never throws in 1.30+ { } template explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter()) // Y must be complete { detail::sp_enable_shared_from_this( pn, p, p ); } // // Requirements: D's copy constructor must not throw // // shared_ptr will release p by calling d(p) // template shared_ptr(Y * p, D d): px(p), pn(p, d) { detail::sp_enable_shared_from_this( pn, p, p ); } // generated copy constructor, assignment, destructor are fine... // except that Borland C++ has a bug, and g++ with -Wsynth warns #if defined(__BORLANDC__) || defined(__GNUC__) shared_ptr & operator=(shared_ptr const & r) // never throws { px = r.px; pn = r.pn; // shared_count::op= doesn't throw return *this; } #endif template explicit shared_ptr(weak_ptr const & r): pn(r.pn) // may throw { // it is now safe to copy r.px, as pn(r.pn) did not throw px = r.px; } template shared_ptr(shared_ptr const & r): px(r.px), pn(r.pn) // never throws { } template shared_ptr(shared_ptr const & r, detail::static_cast_tag): px(static_cast(r.px)), pn(r.pn) { } template shared_ptr(shared_ptr const & r, detail::const_cast_tag): px(const_cast(r.px)), pn(r.pn) { } template shared_ptr(shared_ptr const & r, detail::dynamic_cast_tag): px(dynamic_cast(r.px)), pn(r.pn) { if(px == 0) // need to allocate new counter -- the cast failed { pn = detail::shared_count(); } } template shared_ptr(shared_ptr const & r, detail::polymorphic_cast_tag): px(dynamic_cast(r.px)), pn(r.pn) { if(px == 0) { boost::throw_exception(std::bad_cast()); } } #ifndef BOOST_NO_AUTO_PTR template explicit shared_ptr(std::auto_ptr & r): px(r.get()), pn() { Y * tmp = r.get(); pn = detail::shared_count(r); detail::sp_enable_shared_from_this( pn, tmp, tmp ); } #endif #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200) template shared_ptr & operator=(shared_ptr const & r) // never throws { px = r.px; pn = r.pn; // shared_count::op= doesn't throw return *this; } #endif #ifndef BOOST_NO_AUTO_PTR template shared_ptr & operator=(std::auto_ptr & r) { this_type(r).swap(*this); return *this; } #endif void reset() // never throws in 1.30+ { this_type().swap(*this); } template void reset(Y * p) // Y must be complete { BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors this_type(p).swap(*this); } template void reset(Y * p, D d) { this_type(p, d).swap(*this); } reference operator* () const // never throws { BOOST_ASSERT(px != 0); return *px; } T * operator-> () const // never throws { BOOST_ASSERT(px != 0); return px; } T * get() const // never throws { return px; } // implicit conversion to "bool" #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) operator bool () const { return px != 0; } #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) typedef T * (this_type::*unspecified_bool_type)() const; operator unspecified_bool_type() const // never throws { return px == 0? 0: &this_type::get; } #else typedef T * this_type::*unspecified_bool_type; operator unspecified_bool_type() const // never throws { return px == 0? 0: &this_type::px; } #endif // operator! is redundant, but some compilers need it bool operator! () const // never throws { return px == 0; } bool unique() const // never throws { return pn.unique(); } long use_count() const // never throws { return pn.use_count(); } void swap(shared_ptr & other) // never throws { std::swap(px, other.px); pn.swap(other.pn); } template bool _internal_less(shared_ptr const & rhs) const { return pn < rhs.pn; } void * _internal_get_deleter(std::type_info const & ti) const { return pn.get_deleter(ti); } // Tasteless as this may seem, making all members public allows member templates // to work in the absence of member template friends. (Matthew Langston) #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: template friend class shared_ptr; template friend class weak_ptr; #endif T * px; // contained pointer detail::shared_count pn; // reference counter }; // shared_ptr template inline bool operator==(shared_ptr const & a, shared_ptr const & b) { return a.get() == b.get(); } template inline bool operator!=(shared_ptr const & a, shared_ptr const & b) { return a.get() != b.get(); } #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 // Resolve the ambiguity between our op!= and the one in rel_ops template inline bool operator!=(shared_ptr const & a, shared_ptr const & b) { return a.get() != b.get(); } #endif template inline bool operator<(shared_ptr const & a, shared_ptr const & b) { return a._internal_less(b); } template inline void swap(shared_ptr & a, shared_ptr & b) { a.swap(b); } template shared_ptr static_pointer_cast(shared_ptr const & r) { return shared_ptr(r, detail::static_cast_tag()); } template shared_ptr const_pointer_cast(shared_ptr const & r) { return shared_ptr(r, detail::const_cast_tag()); } template shared_ptr dynamic_pointer_cast(shared_ptr const & r) { return shared_ptr(r, detail::dynamic_cast_tag()); } // shared_*_cast names are deprecated. Use *_pointer_cast instead. template shared_ptr shared_static_cast(shared_ptr const & r) { return shared_ptr(r, detail::static_cast_tag()); } template shared_ptr shared_dynamic_cast(shared_ptr const & r) { return shared_ptr(r, detail::dynamic_cast_tag()); } template shared_ptr shared_polymorphic_cast(shared_ptr const & r) { return shared_ptr(r, detail::polymorphic_cast_tag()); } template shared_ptr shared_polymorphic_downcast(shared_ptr const & r) { BOOST_ASSERT(dynamic_cast(r.get()) == r.get()); return shared_static_cast(r); } // get_pointer() enables boost::mem_fn to recognize shared_ptr template inline T * get_pointer(shared_ptr const & p) { return p.get(); } // operator<< #if defined(__GNUC__) && (__GNUC__ < 3) template std::ostream & operator<< (std::ostream & os, shared_ptr const & p) { os << p.get(); return os; } #else # if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT) // MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL using std::basic_ostream; template basic_ostream & operator<< (basic_ostream & os, shared_ptr const & p) # else template std::basic_ostream & operator<< (std::basic_ostream & os, shared_ptr const & p) # endif { os << p.get(); return os; } #endif // get_deleter (experimental) #if (defined(__GNUC__) && (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238)) // g++ 2.9x doesn't allow static_cast(void *) // apparently EDG 2.38 also doesn't accept it template D * get_deleter(shared_ptr const & p) { void const * q = p._internal_get_deleter(typeid(D)); return const_cast(static_cast(q)); } #else template D * get_deleter(shared_ptr const & p) { return static_cast(p._internal_get_deleter(typeid(D))); } #endif } // namespace boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/integer_traits.hpp0000644000175000017500000001662711344301501031211 0ustar debiandebian/* boost integer_traits.hpp header file * * Copyright Jens Maurer 2000 * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * $Id: integer_traits.hpp,v 1.1.1.1 2010/03/05 22:18:41 annao Exp $ * * Idea by Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers */ // See http://www.boost.org/libs/integer for documentation. #ifndef BOOST_INTEGER_TRAITS_HPP #define BOOST_INTEGER_TRAITS_HPP #include #include // These are an implementation detail and not part of the interface #include #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && !defined(BOOST_NO_CWCHAR) #include #endif namespace boost { template class integer_traits : public std::numeric_limits { public: BOOST_STATIC_CONSTANT(bool, is_integral = false); }; namespace detail { template class integer_traits_base { public: BOOST_STATIC_CONSTANT(bool, is_integral = true); BOOST_STATIC_CONSTANT(T, const_min = min_val); BOOST_STATIC_CONSTANT(T, const_max = max_val); }; #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION // A definition is required even for integral static constants template const bool integer_traits_base::is_integral; template const T integer_traits_base::const_min; template const T integer_traits_base::const_max; #endif } // namespace detail template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; #ifndef BOOST_NO_INTRINSIC_WCHAR_T template<> class integer_traits : public std::numeric_limits, #if defined(WCHAR_MIN) && defined(WCHAR_MAX) public detail::integer_traits_base #elif defined(__BORLANDC__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__BEOS__) && defined(__GNUC__)) // No WCHAR_MIN and WCHAR_MAX, whar_t is short and unsigned: public detail::integer_traits_base #elif (defined(__sgi) && (!defined(__SGI_STL_PORT) || __SGI_STL_PORT < 0x400))\ || (defined __APPLE__)\ || (defined(__OpenBSD__) && defined(__GNUC__))\ || (defined(__NetBSD__) && defined(__GNUC__))\ || (defined(__FreeBSD__) && defined(__GNUC__))\ || (defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 3) && !defined(__SGI_STL_PORT)) // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as int. // - SGI MIPSpro with native library // - gcc 3.x on HP-UX // - Mac OS X with native library // - gcc on FreeBSD, OpenBSD and NetBSD public detail::integer_traits_base #elif defined(__hpux) && defined(__GNUC__) && (__GNUC__ == 2) && !defined(__SGI_STL_PORT) // No WCHAR_MIN and WCHAR_MAX, wchar_t has the same range as unsigned int. // - gcc 2.95.x on HP-UX // (also, std::numeric_limits appears to return the wrong values). public detail::integer_traits_base #else #error No WCHAR_MIN and WCHAR_MAX present, please adjust integer_traits<> for your compiler. #endif { }; #endif // BOOST_NO_INTRINSIC_WCHAR_T template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; template<> class integer_traits : public std::numeric_limits, public detail::integer_traits_base { }; #if !defined(BOOST_NO_INTEGRAL_INT64_T) && !defined(BOOST_NO_INT64_T) #if defined(ULLONG_MAX) && defined(BOOST_HAS_LONG_LONG) template<> class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, LLONG_MIN, LLONG_MAX> { }; template<> class integer_traits< ::boost::ulong_long_type> : public std::numeric_limits< ::boost::ulong_long_type>, public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULLONG_MAX> { }; #elif defined(ULONG_LONG_MAX) && defined(BOOST_HAS_LONG_LONG) template<> class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, LONG_LONG_MIN, LONG_LONG_MAX>{ }; template<> class integer_traits< ::boost::ulong_long_type> : public std::numeric_limits< ::boost::ulong_long_type>, public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONG_LONG_MAX> { }; #elif defined(ULONGLONG_MAX) && defined(BOOST_HAS_LONG_LONG) template<> class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, LONGLONG_MIN, LONGLONG_MAX> { }; template<> class integer_traits< ::boost::ulong_long_type> : public std::numeric_limits< ::boost::ulong_long_type>, public detail::integer_traits_base< ::boost::ulong_long_type, 0, ULONGLONG_MAX> { }; #elif defined(_LLONG_MAX) && defined(_C2) && defined(BOOST_HAS_LONG_LONG) template<> class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, -_LLONG_MAX - _C2, _LLONG_MAX> { }; template<> class integer_traits< ::boost::ulong_long_type> : public std::numeric_limits< ::boost::ulong_long_type>, public detail::integer_traits_base< ::boost::ulong_long_type, 0, _ULLONG_MAX> { }; #elif defined(BOOST_HAS_LONG_LONG) // // we have long long but no constants, this happens for example with gcc in -ansi mode, // we'll just have to work out the values for ourselves (assumes 2's compliment representation): // template<> class integer_traits< ::boost::long_long_type> : public std::numeric_limits< ::boost::long_long_type>, public detail::integer_traits_base< ::boost::long_long_type, (1LL << (sizeof(::boost::long_long_type) - 1)), ~(1LL << (sizeof(::boost::long_long_type) - 1))> { }; template<> class integer_traits< ::boost::ulong_long_type> : public std::numeric_limits< ::boost::ulong_long_type>, public detail::integer_traits_base< ::boost::ulong_long_type, 0, ~0uLL> { }; #endif #endif } // namespace boost #endif /* BOOST_INTEGER_TRAITS_HPP */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/operators.hpp0000644000175000017500000011005711344301501030174 0ustar debiandebian// Boost operators.hpp header file ----------------------------------------// // (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/utility/operators.htm for documentation. // Revision History // 21 Oct 02 Modified implementation of operators to allow compilers with a // correct named return value optimization (NRVO) to produce optimal // code. (Daniel Frey) // 02 Dec 01 Bug fixed in random_access_iteratable. (Helmut Zeisel) // 28 Sep 01 Factored out iterator operator groups. (Daryle Walker) // 27 Aug 01 'left' form for non commutative operators added; // additional classes for groups of related operators added; // workaround for empty base class optimization // bug of GCC 3.0 (Helmut Zeisel) // 25 Jun 01 output_iterator_helper changes: removed default template // parameters, added support for self-proxying, additional // documentation and tests (Aleksey Gurtovoy) // 29 May 01 Added operator classes for << and >>. Added input and output // iterator helper classes. Added classes to connect equality and // relational operators. Added classes for groups of related // operators. Reimplemented example operator and iterator helper // classes in terms of the new groups. (Daryle Walker, with help // from Alexy Gurtovoy) // 11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly // supplied arguments from actually being used (Dave Abrahams) // 04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and // refactoring of compiler workarounds, additional documentation // (Alexy Gurtovoy and Mark Rodgers with some help and prompting from // Dave Abrahams) // 28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and // Jeremy Siek (Dave Abrahams) // 20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5 // (Mark Rodgers) // 20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy) // 10 Jun 00 Support for the base class chaining technique was added // (Aleksey Gurtovoy). See documentation and the comments below // for the details. // 12 Dec 99 Initial version with iterator operators (Jeremy Siek) // 18 Nov 99 Change name "divideable" to "dividable", remove unnecessary // specializations of dividable, subtractable, modable (Ed Brey) // 17 Nov 99 Add comments (Beman Dawes) // Remove unnecessary specialization of operators<> (Ed Brey) // 15 Nov 99 Fix less_than_comparable second operand type for first two // operators.(Beman Dawes) // 12 Nov 99 Add operators templates (Ed Brey) // 11 Nov 99 Add single template parameter version for compilers without // partial specialization (Beman Dawes) // 10 Nov 99 Initial version // 10 Jun 00: // An additional optional template parameter was added to most of // operator templates to support the base class chaining technique (see // documentation for the details). Unfortunately, a straightforward // implementation of this change would have broken compatibility with the // previous version of the library by making it impossible to use the same // template name (e.g. 'addable') for both the 1- and 2-argument versions of // an operator template. This implementation solves the backward-compatibility // issue at the cost of some simplicity. // // One of the complications is an existence of special auxiliary class template // 'is_chained_base<>' (see 'detail' namespace below), which is used // to determine whether its template parameter is a library's operator template // or not. You have to specialize 'is_chained_base<>' for each new // operator template you add to the library. // // However, most of the non-trivial implementation details are hidden behind // several local macros defined below, and as soon as you understand them, // you understand the whole library implementation. #ifndef BOOST_OPERATORS_HPP #define BOOST_OPERATORS_HPP #include #include #include #if defined(__sgi) && !defined(__GNUC__) # pragma set woff 1234 #endif #if defined(BOOST_MSVC) # pragma warning( disable : 4284 ) // complaint about return type of #endif // operator-> not begin a UDT namespace boost { namespace detail { // Helmut Zeisel, empty base class optimization bug with GCC 3.0.0 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0 class empty_base { bool dummy; }; #else class empty_base {}; #endif } // namespace detail } // namespace boost // In this section we supply the xxxx1 and xxxx2 forms of the operator // templates, which are explicitly targeted at the 1-type-argument and // 2-type-argument operator forms, respectively. Some compilers get confused // when inline friend functions are overloaded in namespaces other than the // global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of // these templates must go in the global namespace. #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE namespace boost { #endif // Basic operator classes (contributed by Dave Abrahams) ------------------// // Note that friend functions defined in a class are implicitly inline. // See the C++ std, 11.4 [class.friend] paragraph 5 template struct less_than_comparable2 : B { friend bool operator<=(const T& x, const U& y) { return !(x > y); } friend bool operator>=(const T& x, const U& y) { return !(x < y); } friend bool operator>(const U& x, const T& y) { return y < x; } friend bool operator<(const U& x, const T& y) { return y > x; } friend bool operator<=(const U& x, const T& y) { return !(y < x); } friend bool operator>=(const U& x, const T& y) { return !(y > x); } }; template struct less_than_comparable1 : B { friend bool operator>(const T& x, const T& y) { return y < x; } friend bool operator<=(const T& x, const T& y) { return !(y < x); } friend bool operator>=(const T& x, const T& y) { return !(x < y); } }; template struct equality_comparable2 : B { friend bool operator==(const U& y, const T& x) { return x == y; } friend bool operator!=(const U& y, const T& x) { return !(x == y); } friend bool operator!=(const T& y, const U& x) { return !(y == x); } }; template struct equality_comparable1 : B { friend bool operator!=(const T& x, const T& y) { return !(x == y); } }; // A macro which produces "name_2left" from "name". #define BOOST_OPERATOR2_LEFT(name) name##2##_##left // NRVO-friendly implementation (contributed by Daniel Frey) ---------------// #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) // This is the optimal implementation for ISO/ANSI C++, // but it requires the compiler to implement the NRVO. // If the compiler has no NRVO, this is the best symmetric // implementation available. #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \ template \ struct NAME##2 : B \ { \ friend T operator OP( const T& lhs, const U& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ friend T operator OP( const U& lhs, const T& rhs ) \ { T nrv( rhs ); nrv OP##= lhs; return nrv; } \ }; \ \ template \ struct NAME##1 : B \ { \ friend T operator OP( const T& lhs, const T& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ }; #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \ template \ struct NAME##2 : B \ { \ friend T operator OP( const T& lhs, const U& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ }; \ \ template \ struct BOOST_OPERATOR2_LEFT(NAME) : B \ { \ friend T operator OP( const U& lhs, const T& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ }; \ \ template \ struct NAME##1 : B \ { \ friend T operator OP( const T& lhs, const T& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ }; #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) // For compilers without NRVO the following code is optimal, but not // symmetric! Note that the implementation of // BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide // optimization opportunities to the compiler :) #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \ template \ struct NAME##2 : B \ { \ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \ friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \ }; \ \ template \ struct NAME##1 : B \ { \ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \ }; #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \ template \ struct NAME##2 : B \ { \ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \ }; \ \ template \ struct BOOST_OPERATOR2_LEFT(NAME) : B \ { \ friend T operator OP( const U& lhs, const T& rhs ) \ { return T( lhs ) OP##= rhs; } \ }; \ \ template \ struct NAME##1 : B \ { \ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \ }; #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * ) BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + ) BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - ) BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / ) BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % ) BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ ) BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & ) BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | ) #undef BOOST_BINARY_OPERATOR_COMMUTATIVE #undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE #undef BOOST_OPERATOR2_LEFT // incrementable and decrementable contributed by Jeremy Siek template struct incrementable : B { friend T operator++(T& x, int) { incrementable_type nrv(x); ++x; return nrv; } private: // The use of this typedef works around a Borland bug typedef T incrementable_type; }; template struct decrementable : B { friend T operator--(T& x, int) { decrementable_type nrv(x); --x; return nrv; } private: // The use of this typedef works around a Borland bug typedef T decrementable_type; }; // Iterator operator classes (contributed by Jeremy Siek) ------------------// template struct dereferenceable : B { P operator->() const { return &*static_cast(*this); } }; template struct indexable : B { R operator[](I n) const { return *(static_cast(*this) + n); } }; // More operator classes (contributed by Daryle Walker) --------------------// // (NRVO-friendly implementation contributed by Daniel Frey) ---------------// #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) #define BOOST_BINARY_OPERATOR( NAME, OP ) \ template \ struct NAME##2 : B \ { \ friend T operator OP( const T& lhs, const U& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ }; \ \ template \ struct NAME##1 : B \ { \ friend T operator OP( const T& lhs, const T& rhs ) \ { T nrv( lhs ); nrv OP##= rhs; return nrv; } \ }; #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) #define BOOST_BINARY_OPERATOR( NAME, OP ) \ template \ struct NAME##2 : B \ { \ friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \ }; \ \ template \ struct NAME##1 : B \ { \ friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \ }; #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS) BOOST_BINARY_OPERATOR( left_shiftable, << ) BOOST_BINARY_OPERATOR( right_shiftable, >> ) #undef BOOST_BINARY_OPERATOR template struct equivalent2 : B { friend bool operator==(const T& x, const U& y) { return !(x < y) && !(x > y); } }; template struct equivalent1 : B { friend bool operator==(const T&x, const T&y) { return !(x < y) && !(y < x); } }; template struct partially_ordered2 : B { friend bool operator<=(const T& x, const U& y) { return (x < y) || (x == y); } friend bool operator>=(const T& x, const U& y) { return (x > y) || (x == y); } friend bool operator>(const U& x, const T& y) { return y < x; } friend bool operator<(const U& x, const T& y) { return y > x; } friend bool operator<=(const U& x, const T& y) { return (y > x) || (y == x); } friend bool operator>=(const U& x, const T& y) { return (y < x) || (y == x); } }; template struct partially_ordered1 : B { friend bool operator>(const T& x, const T& y) { return y < x; } friend bool operator<=(const T& x, const T& y) { return (x < y) || (x == y); } friend bool operator>=(const T& x, const T& y) { return (y < x) || (x == y); } }; // Combined operator classes (contributed by Daryle Walker) ----------------// template struct totally_ordered2 : less_than_comparable2 > {}; template struct totally_ordered1 : less_than_comparable1 > {}; template struct additive2 : addable2 > {}; template struct additive1 : addable1 > {}; template struct multiplicative2 : multipliable2 > {}; template struct multiplicative1 : multipliable1 > {}; template struct integer_multiplicative2 : multiplicative2 > {}; template struct integer_multiplicative1 : multiplicative1 > {}; template struct arithmetic2 : additive2 > {}; template struct arithmetic1 : additive1 > {}; template struct integer_arithmetic2 : additive2 > {}; template struct integer_arithmetic1 : additive1 > {}; template struct bitwise2 : xorable2 > > {}; template struct bitwise1 : xorable1 > > {}; template struct unit_steppable : incrementable > {}; template struct shiftable2 : left_shiftable2 > {}; template struct shiftable1 : left_shiftable1 > {}; template struct ring_operators2 : additive2 > > {}; template struct ring_operators1 : additive1 > {}; template struct ordered_ring_operators2 : ring_operators2 > {}; template struct ordered_ring_operators1 : ring_operators1 > {}; template struct field_operators2 : ring_operators2 > > {}; template struct field_operators1 : ring_operators1 > {}; template struct ordered_field_operators2 : field_operators2 > {}; template struct ordered_field_operators1 : field_operators1 > {}; template struct euclidian_ring_operators2 : ring_operators2 > > > > {}; template struct euclidian_ring_operators1 : ring_operators1 > > {}; template struct ordered_euclidian_ring_operators2 : totally_ordered2 > {}; template struct ordered_euclidian_ring_operators1 : totally_ordered1 > {}; template struct input_iteratable : equality_comparable1 > > {}; template struct output_iteratable : incrementable {}; template struct forward_iteratable : input_iteratable {}; template struct bidirectional_iteratable : forward_iteratable > {}; // To avoid repeated derivation from equality_comparable, // which is an indirect base class of bidirectional_iterable, // random_access_iteratable must not be derived from totally_ordered1 // but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001) template struct random_access_iteratable : bidirectional_iteratable > > > {}; #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE } // namespace boost #endif // BOOST_NO_OPERATORS_IN_NAMESPACE // BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 - // // When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an // operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used // for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for // two-argument forms. Note that these macros expect to be invoked from within // boost. #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE // The template is already in boost so we have nothing to do. # define BOOST_IMPORT_TEMPLATE4(template_name) # define BOOST_IMPORT_TEMPLATE3(template_name) # define BOOST_IMPORT_TEMPLATE2(template_name) # define BOOST_IMPORT_TEMPLATE1(template_name) #else // BOOST_NO_OPERATORS_IN_NAMESPACE # ifndef BOOST_NO_USING_TEMPLATE // Bring the names in with a using-declaration // to avoid stressing the compiler. # define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name; # define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name; # define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name; # define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name; # else // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration // from working, we are forced to use inheritance for that compiler. # define BOOST_IMPORT_TEMPLATE4(template_name) \ template \ struct template_name : ::template_name {}; # define BOOST_IMPORT_TEMPLATE3(template_name) \ template \ struct template_name : ::template_name {}; # define BOOST_IMPORT_TEMPLATE2(template_name) \ template \ struct template_name : ::template_name {}; # define BOOST_IMPORT_TEMPLATE1(template_name) \ template \ struct template_name : ::template_name {}; # endif // BOOST_NO_USING_TEMPLATE #endif // BOOST_NO_OPERATORS_IN_NAMESPACE // // Here's where we put it all together, defining the xxxx forms of the templates // in namespace boost. We also define specializations of is_chained_base<> for // the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as // neccessary. // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // is_chained_base<> - a traits class used to distinguish whether an operator // template argument is being used for base class chaining, or is specifying a // 2nd argument type. namespace boost { // A type parameter is used instead of a plain bool because Borland's compiler // didn't cope well with the more obvious non-type template parameter. namespace detail { struct true_t {}; struct false_t {}; } // namespace detail // Unspecialized version assumes that most types are not being used for base // class chaining. We specialize for the operator templates defined in this // library. template struct is_chained_base { typedef ::boost::detail::false_t value; }; } // namespace boost // Import a 4-type-argument operator template into boost (if neccessary) and // provide a specialization of 'is_chained_base<>' for it. # define BOOST_OPERATOR_TEMPLATE4(template_name4) \ BOOST_IMPORT_TEMPLATE4(template_name4) \ template \ struct is_chained_base< ::boost::template_name4 > { \ typedef ::boost::detail::true_t value; \ }; // Import a 3-type-argument operator template into boost (if neccessary) and // provide a specialization of 'is_chained_base<>' for it. # define BOOST_OPERATOR_TEMPLATE3(template_name3) \ BOOST_IMPORT_TEMPLATE3(template_name3) \ template \ struct is_chained_base< ::boost::template_name3 > { \ typedef ::boost::detail::true_t value; \ }; // Import a 2-type-argument operator template into boost (if neccessary) and // provide a specialization of 'is_chained_base<>' for it. # define BOOST_OPERATOR_TEMPLATE2(template_name2) \ BOOST_IMPORT_TEMPLATE2(template_name2) \ template \ struct is_chained_base< ::boost::template_name2 > { \ typedef ::boost::detail::true_t value; \ }; // Import a 1-type-argument operator template into boost (if neccessary) and // provide a specialization of 'is_chained_base<>' for it. # define BOOST_OPERATOR_TEMPLATE1(template_name1) \ BOOST_IMPORT_TEMPLATE1(template_name1) \ template \ struct is_chained_base< ::boost::template_name1 > { \ typedef ::boost::detail::true_t value; \ }; // BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it // can be used for specifying both 1-argument and 2-argument forms. Requires the // existence of two previously defined class templates named '1' // and '2' which must implement the corresponding 1- and 2- // argument forms. // // The template type parameter O == is_chained_base::value is used to // distinguish whether the 2nd argument to is being used for // base class chaining from another boost operator template or is describing a // 2nd operand type. O == true_t only when U is actually an another operator // template from the library. Partial specialization is used to select an // implementation in terms of either '1' or '2'. // # define BOOST_OPERATOR_TEMPLATE(template_name) \ template ::value \ > \ struct template_name : template_name##2 {}; \ \ template \ struct template_name \ : template_name##1 {}; \ \ template \ struct template_name \ : template_name##1 {}; \ \ template \ struct is_chained_base< ::boost::template_name > { \ typedef ::boost::detail::true_t value; \ }; \ \ BOOST_OPERATOR_TEMPLATE2(template_name##2) \ BOOST_OPERATOR_TEMPLATE1(template_name##1) #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # define BOOST_OPERATOR_TEMPLATE4(template_name4) \ BOOST_IMPORT_TEMPLATE4(template_name4) # define BOOST_OPERATOR_TEMPLATE3(template_name3) \ BOOST_IMPORT_TEMPLATE3(template_name3) # define BOOST_OPERATOR_TEMPLATE2(template_name2) \ BOOST_IMPORT_TEMPLATE2(template_name2) # define BOOST_OPERATOR_TEMPLATE1(template_name1) \ BOOST_IMPORT_TEMPLATE1(template_name1) // In this case we can only assume that template_name<> is equivalent to the // more commonly needed template_name1<> form. # define BOOST_OPERATOR_TEMPLATE(template_name) \ template \ struct template_name : template_name##1 {}; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { BOOST_OPERATOR_TEMPLATE(less_than_comparable) BOOST_OPERATOR_TEMPLATE(equality_comparable) BOOST_OPERATOR_TEMPLATE(multipliable) BOOST_OPERATOR_TEMPLATE(addable) BOOST_OPERATOR_TEMPLATE(subtractable) BOOST_OPERATOR_TEMPLATE2(subtractable2_left) BOOST_OPERATOR_TEMPLATE(dividable) BOOST_OPERATOR_TEMPLATE2(dividable2_left) BOOST_OPERATOR_TEMPLATE(modable) BOOST_OPERATOR_TEMPLATE2(modable2_left) BOOST_OPERATOR_TEMPLATE(xorable) BOOST_OPERATOR_TEMPLATE(andable) BOOST_OPERATOR_TEMPLATE(orable) BOOST_OPERATOR_TEMPLATE1(incrementable) BOOST_OPERATOR_TEMPLATE1(decrementable) BOOST_OPERATOR_TEMPLATE2(dereferenceable) BOOST_OPERATOR_TEMPLATE3(indexable) BOOST_OPERATOR_TEMPLATE(left_shiftable) BOOST_OPERATOR_TEMPLATE(right_shiftable) BOOST_OPERATOR_TEMPLATE(equivalent) BOOST_OPERATOR_TEMPLATE(partially_ordered) BOOST_OPERATOR_TEMPLATE(totally_ordered) BOOST_OPERATOR_TEMPLATE(additive) BOOST_OPERATOR_TEMPLATE(multiplicative) BOOST_OPERATOR_TEMPLATE(integer_multiplicative) BOOST_OPERATOR_TEMPLATE(arithmetic) BOOST_OPERATOR_TEMPLATE(integer_arithmetic) BOOST_OPERATOR_TEMPLATE(bitwise) BOOST_OPERATOR_TEMPLATE1(unit_steppable) BOOST_OPERATOR_TEMPLATE(shiftable) BOOST_OPERATOR_TEMPLATE(ring_operators) BOOST_OPERATOR_TEMPLATE(ordered_ring_operators) BOOST_OPERATOR_TEMPLATE(field_operators) BOOST_OPERATOR_TEMPLATE(ordered_field_operators) BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators) BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators) BOOST_OPERATOR_TEMPLATE2(input_iteratable) BOOST_OPERATOR_TEMPLATE1(output_iteratable) BOOST_OPERATOR_TEMPLATE2(forward_iteratable) BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable) BOOST_OPERATOR_TEMPLATE4(random_access_iteratable) #undef BOOST_OPERATOR_TEMPLATE #undef BOOST_OPERATOR_TEMPLATE4 #undef BOOST_OPERATOR_TEMPLATE3 #undef BOOST_OPERATOR_TEMPLATE2 #undef BOOST_OPERATOR_TEMPLATE1 #undef BOOST_IMPORT_TEMPLATE1 #undef BOOST_IMPORT_TEMPLATE2 #undef BOOST_IMPORT_TEMPLATE3 #undef BOOST_IMPORT_TEMPLATE4 // The following 'operators' classes can only be used portably if the derived class // declares ALL of the required member operators. template struct operators2 : totally_ordered2 > > {}; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct operators : operators2 {}; template struct operators #else template struct operators #endif : totally_ordered > > > {}; // Iterator helper classes (contributed by Jeremy Siek) -------------------// // (Input and output iterator helpers contributed by Daryle Walker) -------// // (Changed to use combined operator classes by Daryle Walker) ------------// template struct input_iterator_helper : input_iteratable > {}; template struct output_iterator_helper : output_iteratable > { T& operator*() { return static_cast(*this); } T& operator++() { return static_cast(*this); } }; template struct forward_iterator_helper : forward_iteratable > {}; template struct bidirectional_iterator_helper : bidirectional_iteratable > {}; template struct random_access_iterator_helper : random_access_iteratable > { friend D requires_difference_operator(const T& x, const T& y) { return x - y; } }; // random_access_iterator_helper } // namespace boost #if defined(__sgi) && !defined(__GNUC__) #pragma reset woff 1234 #endif #endif // BOOST_OPERATORS_HPP ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/multi_index_container.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/multi_index_container0000644000175000017500000006503011344301501031753 0ustar debiandebian/* Multiply indexed container. * * Copyright 2003-2004 Joaquín M López Muñoz. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * See http://www.boost.org/libs/multi_index for library home page. */ #ifndef BOOST_MULTI_INDEX_HPP #define BOOST_MULTI_INDEX_HPP #include /* keep it first to prevent nasty warns in MSVC */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING) #include #define BOOST_MULTI_INDEX_CHECK_INVARIANT \ detail::scope_guard BOOST_JOIN(check_invariant_,__LINE__)= \ detail::make_obj_guard(*this,&multi_index_container::check_invariant_); \ BOOST_JOIN(check_invariant_,__LINE__).touch(); #else #define BOOST_MULTI_INDEX_CHECK_INVARIANT #endif namespace boost{ namespace multi_index{ template class multi_index_container: private ::boost::base_from_member< typename boost::detail::allocator::rebind_to< Allocator, typename detail::multi_index_node_type< Value,IndexSpecifierList,Allocator>::type >::type>, BOOST_MULTI_INDEX_PRIVATE_IF_MEMBER_TEMPLATE_FRIENDS detail::header_holder< typename detail::multi_index_node_type< Value,IndexSpecifierList,Allocator>::type, multi_index_container >, public detail::multi_index_base_type< Value,IndexSpecifierList,Allocator>::type { #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ BOOST_WORKAROUND(__MWERKS__,<=0x3003) /* The "ISO C++ Template Parser" option in CW8.3 has a problem with the * lifetime of const references bound to temporaries --precisely what * scopeguards are. */ #pragma parse_mfunc_templ off #endif private: #if !defined(BOOST_MULTI_INDEX_NO_MEMBER_TEMPLATE_FRIENDS) template friend class detail::index_base; template friend class detail::header_holder; template friend class detail::converter; #endif typedef typename detail::multi_index_base_type< Value,IndexSpecifierList,Allocator>::type super; typedef ::boost::base_from_member< typename boost::detail::allocator::rebind_to< Allocator, typename super::node_type >::type> bfm_allocator; typedef detail::header_holder< typename super::node_type, multi_index_container> bfm_header; public: /* All types are inherited from super, a few are explicitly * brought forward here to save us some typename's. */ #if defined(BOOST_MSVC) typedef detail::default_constructible_tuple_cons< typename super::ctor_args_list> ctor_args_list; #else typedef typename super::ctor_args_list ctor_args_list; #endif typedef IndexSpecifierList index_specifier_type_list; typedef typename super::index_type_list index_type_list; typedef typename super::iterator_type_list iterator_type_list; typedef typename super::const_iterator_type_list const_iterator_type_list; typedef typename super::value_type value_type; typedef typename super::final_allocator_type allocator_type; typedef typename super::iterator iterator; typedef typename super::const_iterator const_iterator; BOOST_STATIC_ASSERT( detail::no_duplicate_tags_in_index_list::value); /* global project() needs to see this publicly */ typedef typename super::node_type node_type; /* construct/copy/destroy */ explicit multi_index_container( #if BOOST_WORKAROUND(__IBMCPP__,<=600) /* VisualAge seems to have an ETI issue with the default values * for arguments args_list and al. */ const ctor_args_list& args_list= typename mpl::identity::type:: ctor_args_list(), const allocator_type& al= typename mpl::identity::type:: allocator_type()): #else const ctor_args_list& args_list=ctor_args_list(), const allocator_type& al=allocator_type()): #endif bfm_allocator(al), super(args_list,bfm_allocator::member), node_count(0) { BOOST_MULTI_INDEX_CHECK_INVARIANT; } template multi_index_container( InputIterator first,InputIterator last, #if BOOST_WORKAROUND(__IBMCPP__,<=600) /* VisualAge seems to have an ETI issue with the default values * for arguments args_list and al. */ const ctor_args_list& args_list= typename mpl::identity::type:: ctor_args_list(), const allocator_type& al= typename mpl::identity::type:: allocator_type()): #else const ctor_args_list& args_list=ctor_args_list(), const allocator_type& al=allocator_type()): #endif bfm_allocator(al), super(args_list,bfm_allocator::member), node_count(0) { BOOST_MULTI_INDEX_CHECK_INVARIANT; BOOST_TRY{ iterator hint=super::end(); for(;first!=last;++first){ hint=super::make_iterator(insert_(*first,hint.get_node()).first); } } BOOST_CATCH(...){ clean_up(); BOOST_RETHROW; } BOOST_CATCH_END } multi_index_container( const multi_index_container& x): bfm_allocator(x.bfm_allocator::member), super(x), node_count(0) { copy_map_type map(bfm_allocator::member,x.size(),x.header(),header()); for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){ map.clone(it.get_node()); } super::copy_(x,map); map.release(); node_count=x.size(); /* Not until this point are the indices required to be consistent, * hence the position of the invariant checker. */ BOOST_MULTI_INDEX_CHECK_INVARIANT; } ~multi_index_container() { BOOST_MULTI_INDEX_CHECK_INVARIANT; clean_up(); } multi_index_container& operator=( const multi_index_container& x) { BOOST_MULTI_INDEX_CHECK_INVARIANT; multi_index_container tmp(x); this->swap(tmp); return *this; } allocator_type get_allocator()const { return allocator_type(bfm_allocator::member); } /* retrieval of indices by number */ #if !defined(BOOST_NO_MEMBER_TEMPLATES) template struct nth_index { BOOST_STATIC_ASSERT(N>=0&&N::type::value); typedef typename mpl::at_c::type type; }; template typename nth_index::type& get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) { BOOST_STATIC_ASSERT(N>=0&&N::type::value); return *this; } template const typename nth_index::type& get( BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const { BOOST_STATIC_ASSERT(N>=0&&N::type::value); return *this; } #endif /* retrieval of indices by tag */ #if !defined(BOOST_NO_MEMBER_TEMPLATES) template struct index { typedef typename mpl::find_if< index_type_list, detail::has_tag >::type iter; BOOST_STATIC_CONSTANT( bool,index_found=!(is_same::type >::value)); BOOST_STATIC_ASSERT(index_found); typedef typename mpl::deref::type type; }; template typename index::type& get(BOOST_EXPLICIT_TEMPLATE_TYPE(Tag)) { return *this; } template const typename index::type& get( BOOST_EXPLICIT_TEMPLATE_TYPE(Tag))const { return *this; } #endif /* projection of iterators by number */ #if !defined(BOOST_NO_MEMBER_TEMPLATES) template struct nth_index_iterator { typedef typename nth_index::type::iterator type; }; template struct nth_index_const_iterator { typedef typename nth_index::type::const_iterator type; }; template typename nth_index_iterator::type project( IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) { typedef typename nth_index::type index; BOOST_STATIC_ASSERT( (mpl::contains::value)); BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); return index::make_iterator(static_cast(it.get_node())); } template typename nth_index_const_iterator::type project( IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N))const { typedef typename nth_index::type index; BOOST_STATIC_ASSERT(( mpl::contains::value|| mpl::contains::value)); BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); return index::make_iterator(static_cast(it.get_node())); } #endif /* projection of iterators by tag */ #if !defined(BOOST_NO_MEMBER_TEMPLATES) template struct index_iterator { typedef typename index::type::iterator type; }; template struct index_const_iterator { typedef typename index::type::const_iterator type; }; template typename index_iterator::type project( IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) { typedef typename index::type index; BOOST_STATIC_ASSERT( (mpl::contains::value)); BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); return index::make_iterator(static_cast(it.get_node())); } template typename index_const_iterator::type project( IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag))const { typedef typename index::type index; BOOST_STATIC_ASSERT(( mpl::contains::value|| mpl::contains::value)); BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); BOOST_MULTI_INDEX_CHECK_IS_OWNER( it,static_cast(*this)); return index::make_iterator(static_cast(it.get_node())); } #endif BOOST_MULTI_INDEX_PROTECTED_IF_MEMBER_TEMPLATE_FRIENDS: typedef typename super::copy_map_type copy_map_type; node_type* header()const { return bfm_header::member; } node_type* allocate_node() { return bfm_allocator::member.allocate(1); } void deallocate_node(node_type* x) { bfm_allocator::member.deallocate(x,1); } bool empty_()const { return node_count==0; } std::size_t size_()const { return node_count; } std::size_t max_size_()const { return static_cast(-1); } std::pair insert_(const Value& v) { node_type* x=allocate_node(); BOOST_TRY{ node_type* res=super::insert_(v,x); if(res==x){ ++node_count; return std::pair(res,true); } else{ deallocate_node(x); return std::pair(res,false); } } BOOST_CATCH(...){ deallocate_node(x); BOOST_RETHROW; } BOOST_CATCH_END } std::pair insert_(const Value& v,node_type* position) { node_type* x=allocate_node(); BOOST_TRY{ node_type* res=super::insert_(v,position,x); if(res==x){ ++node_count; return std::pair(res,true); } else{ deallocate_node(x); return std::pair(res,false); } } BOOST_CATCH(...){ deallocate_node(x); BOOST_RETHROW; } BOOST_CATCH_END } void erase_(node_type* x) { super::erase_(x); deallocate_node(x); --node_count; } void swap_(multi_index_container& x) { std::swap(bfm_header::member,x.bfm_header::member); super::swap_(x); std::swap(node_count,x.node_count); } bool replace_(const Value& k,node_type* x) { return super::replace_(k,x); } template bool modify_(Modifier mod,node_type* x) { mod(const_cast(x->value)); BOOST_TRY{ if(!super::modify_(x)){ deallocate_node(x); --node_count; return false; } else return true; } BOOST_CATCH(...){ deallocate_node(x); --node_count; BOOST_RETHROW; } BOOST_CATCH_END } #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING) /* invariant stuff */ bool invariant_()const { return super::invariant_(); } void check_invariant_()const { BOOST_MULTI_INDEX_INVARIANT_ASSERT(invariant_()); } #endif private: void clean_up() { for(iterator it=super::begin(),it_end=super::end();it!=it_end;){ erase_(it++.get_node()); } } std::size_t node_count; #if defined(BOOST_MULTI_INDEX_ENABLE_INVARIANT_CHECKING)&&\ BOOST_WORKAROUND(__MWERKS__,<=0x3003) #pragma parse_mfunc_templ reset #endif }; /* retrieval of indices by number */ template struct nth_index { BOOST_STATIC_CONSTANT( int, M=mpl::size::type::value); BOOST_STATIC_ASSERT(N>=0&&N::type type; }; template typename nth_index< multi_index_container,N>::type& get( multi_index_container& m BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename nth_index< multi_index_container< Value,IndexSpecifierList,Allocator>, N >::type index; BOOST_STATIC_ASSERT(N>=0&& N< mpl::size< BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list >::type::value); return detail::converter::index(m); } template const typename nth_index< multi_index_container,N>::type& get( const multi_index_container& m BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename nth_index< multi_index_container< Value,IndexSpecifierList,Allocator>, N >::type index; BOOST_STATIC_ASSERT(N>=0&& N< mpl::size< BOOST_DEDUCED_TYPENAME multi_index_type::index_type_list >::type::value); return detail::converter::index(m); } /* retrieval of indices by tag */ template struct index { typedef typename MultiIndexContainer::index_type_list index_type_list; typedef typename mpl::find_if< index_type_list, detail::has_tag >::type iter; BOOST_STATIC_CONSTANT( bool,index_found=!(is_same::type >::value)); BOOST_STATIC_ASSERT(index_found); typedef typename mpl::deref::type type; }; template< typename Tag,typename Value,typename IndexSpecifierList,typename Allocator > typename ::boost::multi_index::index< multi_index_container,Tag>::type& get( multi_index_container& m BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename ::boost::multi_index::index< multi_index_container< Value,IndexSpecifierList,Allocator>, Tag >::type index; return detail::converter::index(m); } template< typename Tag,typename Value,typename IndexSpecifierList,typename Allocator > const typename ::boost::multi_index::index< multi_index_container,Tag>::type& get( const multi_index_container& m BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename ::boost::multi_index::index< multi_index_container< Value,IndexSpecifierList,Allocator>, Tag >::type index; return detail::converter::index(m); } /* projection of iterators by number */ template struct nth_index_iterator { typedef typename detail::prevent_eti< nth_index, typename nth_index::type>::type::iterator type; }; template struct nth_index_const_iterator { typedef typename detail::prevent_eti< nth_index, typename nth_index::type >::type::const_iterator type; }; template< int N,typename IteratorType, typename Value,typename IndexSpecifierList,typename Allocator> typename nth_index_iterator< multi_index_container,N>::type project( multi_index_container& m, IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename nth_index::type index; #if !defined(BOOST_MSVC)||!(BOOST_MSVC<1300) /* this ain't work in MSVC++ 6.0 */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value)); #endif BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) typedef detail::converter< multi_index_type, BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif return detail::converter::iterator( m,static_cast(it.get_node())); } template< int N,typename IteratorType, typename Value,typename IndexSpecifierList,typename Allocator> typename nth_index_const_iterator< multi_index_container,N>::type project( const multi_index_container& m, IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int,N)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename nth_index::type index; #if !defined(BOOST_MSVC)||!(BOOST_MSVC<1300) /* this ain't work in MSVC++ 6.0 */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list, IteratorType>::value)); #endif BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) typedef detail::converter< multi_index_type, BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif return detail::converter::const_iterator( m,static_cast(it.get_node())); } /* projection of iterators by tag */ template struct index_iterator { typedef typename ::boost::multi_index::index< MultiIndexContainer,Tag>::type::iterator type; }; template struct index_const_iterator { typedef typename ::boost::multi_index::index< MultiIndexContainer,Tag>::type::const_iterator type; }; template< typename Tag,typename IteratorType, typename Value,typename IndexSpecifierList,typename Allocator> typename index_iterator< multi_index_container,Tag>::type project( multi_index_container& m, IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename ::boost::multi_index::index< multi_index_type,Tag>::type index; #if !defined(BOOST_MSVC)||!(BOOST_MSVC<1300) /* this ain't work in MSVC++ 6.0 */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value)); #endif BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) typedef detail::converter< multi_index_type, BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif return detail::converter::iterator( m,static_cast(it.get_node())); } template< typename Tag,typename IteratorType, typename Value,typename IndexSpecifierList,typename Allocator> typename index_const_iterator< multi_index_container,Tag>::type project( const multi_index_container& m, IteratorType it BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(Tag)) { typedef multi_index_container< Value,IndexSpecifierList,Allocator> multi_index_type; typedef typename ::boost::multi_index::index< multi_index_type,Tag>::type index; #if !defined(BOOST_MSVC)||!(BOOST_MSVC<1300) /* this ain't work in MSVC++ 6.0 */ BOOST_STATIC_ASSERT(( mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< BOOST_DEDUCED_TYPENAME multi_index_type::const_iterator_type_list, IteratorType>::value)); #endif BOOST_MULTI_INDEX_CHECK_VALID_ITERATOR(it); #if defined(BOOST_MULTI_INDEX_ENABLE_SAFE_MODE) typedef detail::converter< multi_index_type, BOOST_DEDUCED_TYPENAME IteratorType::container_type> converter; BOOST_MULTI_INDEX_CHECK_IS_OWNER(it,converter::index(m)); #endif return detail::converter::const_iterator( m,static_cast(it.get_node())); } /* Comparison. Simple forward to first index. */ template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator==( const multi_index_container& x, const multi_index_container& y) { return get<0>(x)==get<0>(y); } template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator<( const multi_index_container& x, const multi_index_container& y) { return get<0>(x)(y); } template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator!=( const multi_index_container& x, const multi_index_container& y) { return get<0>(x)!=get<0>(y); } template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator>( const multi_index_container& x, const multi_index_container& y) { return get<0>(x)>get<0>(y); } template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator>=( const multi_index_container& x, const multi_index_container& y) { return get<0>(x)>=get<0>(y); } template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator<=( const multi_index_container& x, const multi_index_container& y) { return get<0>(x)<=get<0>(y); } /* specialized algorithms */ template void swap( multi_index_container& x, multi_index_container& y) { x.swap(y); } } /* namespace multi_index */ /* Associated global functions are promoted to namespace boost, except * comparison operators and swap, which are meant to be Koenig looked-up. */ using multi_index::get; using multi_index::project; } /* namespace boost */ #undef BOOST_MULTI_INDEX_CHECK_INVARIANT #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/version.hpp0000644000175000017500000000210611344301501027636 0ustar debiandebian// Boost version.hpp configuration header file ------------------------------// // (C) Copyright John maddock 1999. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/config for documentation #ifndef BOOST_VERSION_HPP #define BOOST_VERSION_HPP // // Caution, this is the only boost header that is guarenteed // to change with every boost release, including this header // will cause a recompile every time a new boost version is // released. // // BOOST_VERSION % 100 is the sub-minor version // BOOST_VERSION / 100 % 1000 is the minor version // BOOST_VERSION / 100000 is the major version #define BOOST_VERSION 103200 // // BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION // but as a *string* in the form "x_y" where x is the major version // number and y is the minor version number. This is used by // to select which library version to link to. #define BOOST_LIB_VERSION "1_32" #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/shared_array.hpp0000644000175000017500000000764711344301501030634 0ustar debiandebian#ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED #define BOOST_SHARED_ARRAY_HPP_INCLUDED // // shared_array.hpp // // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation. // #include // for broken compiler workarounds #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) #include #else #include #include #include #include #include // for std::ptrdiff_t #include // for std::swap #include // for std::less namespace boost { // // shared_array // // shared_array extends shared_ptr to arrays. // The array pointed to is deleted when the last shared_array pointing to it // is destroyed or reset. // template class shared_array { private: // Borland 5.5.1 specific workarounds typedef checked_array_deleter deleter; typedef shared_array this_type; public: typedef T element_type; explicit shared_array(T * p = 0): px(p), pn(p, deleter()) { } // // Requirements: D's copy constructor must not throw // // shared_array will release p by calling d(p) // template shared_array(T * p, D d): px(p), pn(p, d) { } // generated copy constructor, assignment, destructor are fine void reset(T * p = 0) { BOOST_ASSERT(p == 0 || p != px); this_type(p).swap(*this); } template void reset(T * p, D d) { this_type(p, d).swap(*this); } T & operator[] (std::ptrdiff_t i) const // never throws { BOOST_ASSERT(px != 0); BOOST_ASSERT(i >= 0); return px[i]; } T * get() const // never throws { return px; } // implicit conversion to "bool" #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) operator bool () const { return px != 0; } #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) typedef T * (this_type::*unspecified_bool_type)() const; operator unspecified_bool_type() const // never throws { return px == 0? 0: &this_type::get; } #else typedef T * this_type::*unspecified_bool_type; operator unspecified_bool_type() const // never throws { return px == 0? 0: &this_type::px; } #endif bool operator! () const // never throws { return px == 0; } bool unique() const // never throws { return pn.unique(); } long use_count() const // never throws { return pn.use_count(); } void swap(shared_array & other) // never throws { std::swap(px, other.px); pn.swap(other.pn); } private: T * px; // contained pointer detail::shared_count pn; // reference counter }; // shared_array template inline bool operator==(shared_array const & a, shared_array const & b) // never throws { return a.get() == b.get(); } template inline bool operator!=(shared_array const & a, shared_array const & b) // never throws { return a.get() != b.get(); } template inline bool operator<(shared_array const & a, shared_array const & b) // never throws { return std::less()(a.get(), b.get()); } template void swap(shared_array & a, shared_array & b) // never throws { a.swap(b); } } // namespace boost #endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES) #endif // #ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/shared_container_iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/shared_container_iter0000644000175000017500000000372711344301501031730 0ustar debiandebian// (C) Copyright Ronald Garcia 2002. Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // See http://www.boost.org/libs/utility/shared_container_iterator.html for documentation. #ifndef SHARED_CONTAINER_ITERATOR_RG08102002_HPP #define SHARED_CONTAINER_ITERATOR_RG08102002_HPP #include "boost/iterator_adaptors.hpp" #include "boost/shared_ptr.hpp" #include namespace boost { template class shared_container_iterator : public iterator_adaptor< shared_container_iterator, typename Container::iterator> { typedef iterator_adaptor< shared_container_iterator, typename Container::iterator> super_t; typedef typename Container::iterator iterator_t; typedef boost::shared_ptr container_ref_t; container_ref_t container_ref; public: shared_container_iterator() { } shared_container_iterator(iterator_t const& x,container_ref_t const& c) : super_t(x), container_ref(c) { } }; template shared_container_iterator make_shared_container_iterator(typename Container::iterator iter, boost::shared_ptr const& container) { typedef shared_container_iterator iterator; return iterator(iter,container); } template std::pair< shared_container_iterator, shared_container_iterator > make_shared_container_range(boost::shared_ptr const& container) { return std::make_pair( make_shared_container_iterator(container->begin(),container), make_shared_container_iterator(container->end(),container)); } } // namespace boost #endif // SHARED_CONTAINER_ITERATOR_RG08102002_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/cstdint.hpp0000644000175000017500000003224511344301501027630 0ustar debiandebian// boost cstdint.hpp header file ------------------------------------------// // (C) Copyright Beman Dawes 1999. // (C) Copyright Jens Mauer 2001 // (C) Copyright John Maddock 2001 // Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/integer for documentation. // Revision History // 31 Oct 01 use BOOST_HAS_LONG_LONG to check for "long long" (Jens M.) // 16 Apr 01 check LONGLONG_MAX when looking for "long long" (Jens Maurer) // 23 Jan 01 prefer "long" over "int" for int32_t and intmax_t (Jens Maurer) // 12 Nov 00 Merged (Jens Maurer) // 23 Sep 00 Added INTXX_C macro support (John Maddock). // 22 Sep 00 Better 64-bit support (John Maddock) // 29 Jun 00 Reimplement to avoid including stdint.h within namespace boost // 8 Aug 99 Initial version (Beman Dawes) #ifndef BOOST_CSTDINT_HPP #define BOOST_CSTDINT_HPP #include #ifdef BOOST_HAS_STDINT_H // The following #include is an implementation artifact; not part of interface. # ifdef __hpux // HP-UX has a vaguely nice in a non-standard location # include # ifdef __STDC_32_MODE__ // this is triggered with GCC, because it defines __cplusplus < 199707L # define BOOST_NO_INT64_T # endif # elif defined(__FreeBSD__) || defined(__IBMCPP__) # include # else # include # endif namespace boost { using ::int8_t; using ::int_least8_t; using ::int_fast8_t; using ::uint8_t; using ::uint_least8_t; using ::uint_fast8_t; using ::int16_t; using ::int_least16_t; using ::int_fast16_t; using ::uint16_t; using ::uint_least16_t; using ::uint_fast16_t; using ::int32_t; using ::int_least32_t; using ::int_fast32_t; using ::uint32_t; using ::uint_least32_t; using ::uint_fast32_t; # ifndef BOOST_NO_INT64_T using ::int64_t; using ::int_least64_t; using ::int_fast64_t; using ::uint64_t; using ::uint_least64_t; using ::uint_fast64_t; # endif using ::intmax_t; using ::uintmax_t; } // namespace boost #elif defined(__FreeBSD__) && (__FreeBSD__ <= 4) || defined(__osf__) // FreeBSD and Tru64 have an that contains much of what we need. # include namespace boost { using ::int8_t; typedef int8_t int_least8_t; typedef int8_t int_fast8_t; using ::uint8_t; typedef uint8_t uint_least8_t; typedef uint8_t uint_fast8_t; using ::int16_t; typedef int16_t int_least16_t; typedef int16_t int_fast16_t; using ::uint16_t; typedef uint16_t uint_least16_t; typedef uint16_t uint_fast16_t; using ::int32_t; typedef int32_t int_least32_t; typedef int32_t int_fast32_t; using ::uint32_t; typedef uint32_t uint_least32_t; typedef uint32_t uint_fast32_t; # ifndef BOOST_NO_INT64_T using ::int64_t; typedef int64_t int_least64_t; typedef int64_t int_fast64_t; using ::uint64_t; typedef uint64_t uint_least64_t; typedef uint64_t uint_fast64_t; typedef int64_t intmax_t; typedef uint64_t uintmax_t; # else typedef int32_t intmax_t; typedef uint32_t uintmax_t; # endif } // namespace boost #else // BOOST_HAS_STDINT_H # include // implementation artifact; not part of interface namespace boost { // These are fairly safe guesses for some 16-bit, and most 32-bit and 64-bit // platforms. For other systems, they will have to be hand tailored. // // Because the fast types are assumed to be the same as the undecorated types, // it may be possible to hand tailor a more efficient implementation. Such // an optimization may be illusionary; on the Intel x86-family 386 on, for // example, byte arithmetic and load/stores are as fast as "int" sized ones. // 8-bit types ------------------------------------------------------------// # if UCHAR_MAX == 0xff typedef signed char int8_t; typedef signed char int_least8_t; typedef signed char int_fast8_t; typedef unsigned char uint8_t; typedef unsigned char uint_least8_t; typedef unsigned char uint_fast8_t; # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif // 16-bit types -----------------------------------------------------------// # if USHRT_MAX == 0xffff # if defined(__crayx1) // The Cray X1 has a 16-bit short, however it is not recommend // for use in performance critical code. typedef short int16_t; typedef short int_least16_t; typedef int int_fast16_t; typedef unsigned short uint16_t; typedef unsigned short uint_least16_t; typedef unsigned int uint_fast16_t; # else typedef short int16_t; typedef short int_least16_t; typedef short int_fast16_t; typedef unsigned short uint16_t; typedef unsigned short uint_least16_t; typedef unsigned short uint_fast16_t; # endif # elif (USHRT_MAX == 0xffffffff) && defined(CRAY) // no 16-bit types on Cray: typedef short int_least16_t; typedef short int_fast16_t; typedef unsigned short uint_least16_t; typedef unsigned short uint_fast16_t; # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif // 32-bit types -----------------------------------------------------------// # if ULONG_MAX == 0xffffffff typedef long int32_t; typedef long int_least32_t; typedef long int_fast32_t; typedef unsigned long uint32_t; typedef unsigned long uint_least32_t; typedef unsigned long uint_fast32_t; # elif UINT_MAX == 0xffffffff typedef int int32_t; typedef int int_least32_t; typedef int int_fast32_t; typedef unsigned int uint32_t; typedef unsigned int uint_least32_t; typedef unsigned int uint_fast32_t; # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif // 64-bit types + intmax_t and uintmax_t ----------------------------------// # if defined(BOOST_HAS_LONG_LONG) && \ !defined(BOOST_MSVC) && !defined(__BORLANDC__) && \ (!defined(__GLIBCPP__) || defined(_GLIBCPP_USE_LONG_LONG)) && \ (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) # if defined(__hpux) // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions # elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615ULL) || (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615ULL) || (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615ULL) // 2**64 - 1 # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif typedef ::boost::long_long_type intmax_t; typedef ::boost::ulong_long_type uintmax_t; typedef ::boost::long_long_type int64_t; typedef ::boost::long_long_type int_least64_t; typedef ::boost::long_long_type int_fast64_t; typedef ::boost::ulong_long_type uint64_t; typedef ::boost::ulong_long_type uint_least64_t; typedef ::boost::ulong_long_type uint_fast64_t; # elif ULONG_MAX != 0xffffffff # if ULONG_MAX == 18446744073709551615 // 2**64 - 1 typedef long intmax_t; typedef unsigned long uintmax_t; typedef long int64_t; typedef long int_least64_t; typedef long int_fast64_t; typedef unsigned long uint64_t; typedef unsigned long uint_least64_t; typedef unsigned long uint_fast64_t; # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif # elif defined(__GNUC__) && defined(BOOST_HAS_LONG_LONG) __extension__ typedef long long intmax_t; __extension__ typedef unsigned long long uintmax_t; __extension__ typedef long long int64_t; __extension__ typedef long long int_least64_t; __extension__ typedef long long int_fast64_t; __extension__ typedef unsigned long long uint64_t; __extension__ typedef unsigned long long uint_least64_t; __extension__ typedef unsigned long long uint_fast64_t; # elif defined(BOOST_HAS_MS_INT64) // // we have Borland/Intel/Microsoft __int64: // typedef __int64 intmax_t; typedef unsigned __int64 uintmax_t; typedef __int64 int64_t; typedef __int64 int_least64_t; typedef __int64 int_fast64_t; typedef unsigned __int64 uint64_t; typedef unsigned __int64 uint_least64_t; typedef unsigned __int64 uint_fast64_t; # else // assume no 64-bit integers # define BOOST_NO_INT64_T typedef int32_t intmax_t; typedef uint32_t uintmax_t; # endif } // namespace boost #endif // BOOST_HAS_STDINT_H #endif // BOOST_CSTDINT_HPP /**************************************************** Macro definition section: Define various INTXX_C macros only if __STDC_CONSTANT_MACROS is defined. Undefine the macros if __STDC_CONSTANT_MACROS is not defined and the macros are (cf ). Added 23rd September 2000 (John Maddock). Modified 11th September 2001 to be excluded when BOOST_HAS_STDINT_H is defined (John Maddock). ******************************************************/ #if defined(__STDC_CONSTANT_MACROS) && !defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(BOOST_HAS_STDINT_H) # define BOOST__STDC_CONSTANT_MACROS_DEFINED # if defined(BOOST_HAS_MS_INT64) // // Borland/Intel/Microsoft compilers have width specific suffixes: // # define INT8_C(value) value##i8 # define INT16_C(value) value##i16 # define INT32_C(value) value##i32 # define INT64_C(value) value##i64 # ifdef __BORLANDC__ // Borland bug: appending ui8 makes the type a signed char # define UINT8_C(value) static_cast(value##u) # else # define UINT8_C(value) value##ui8 # endif # define UINT16_C(value) value##ui16 # define UINT32_C(value) value##ui32 # define UINT64_C(value) value##ui64 # define INTMAX_C(value) value##i64 # define UINTMAX_C(value) value##ui64 # else // do it the old fashioned way: // 8-bit types ------------------------------------------------------------// # if UCHAR_MAX == 0xff # define INT8_C(value) static_cast(value) # define UINT8_C(value) static_cast(value##u) # endif // 16-bit types -----------------------------------------------------------// # if USHRT_MAX == 0xffff # define INT16_C(value) static_cast(value) # define UINT16_C(value) static_cast(value##u) # endif // 32-bit types -----------------------------------------------------------// # if UINT_MAX == 0xffffffff # define INT32_C(value) value # define UINT32_C(value) value##u # elif ULONG_MAX == 0xffffffff # define INT32_C(value) value##L # define UINT32_C(value) value##uL # endif // 64-bit types + intmax_t and uintmax_t ----------------------------------// # if defined(BOOST_HAS_LONG_LONG) && \ (defined(ULLONG_MAX) || defined(ULONG_LONG_MAX) || defined(ULONGLONG_MAX)) # if defined(__hpux) // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions # elif (defined(ULLONG_MAX) && ULLONG_MAX == 18446744073709551615U) || \ (defined(ULONG_LONG_MAX) && ULONG_LONG_MAX == 18446744073709551615U) || \ (defined(ULONGLONG_MAX) && ULONGLONG_MAX == 18446744073709551615U) # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif # define INT64_C(value) value##LL # define UINT64_C(value) value##uLL # elif ULONG_MAX != 0xffffffff # if ULONG_MAX == 18446744073709551615 // 2**64 - 1 # define INT64_C(value) value##L # define UINT64_C(value) value##uL # else # error defaults not correct; you must hand modify boost/cstdint.hpp # endif # endif # ifdef BOOST_NO_INT64_T # define INTMAX_C(value) INT32_C(value) # define UINTMAX_C(value) UINT32_C(value) # else # define INTMAX_C(value) INT64_C(value) # define UINTMAX_C(value) UINT64_C(value) # endif # endif // Borland/Microsoft specific width suffixes #elif defined(BOOST__STDC_CONSTANT_MACROS_DEFINED) && !defined(__STDC_CONSTANT_MACROS) && !defined(BOOST_HAS_STDINT_H) // // undef all the macros: // # undef INT8_C # undef INT16_C # undef INT32_C # undef INT64_C # undef UINT8_C # undef UINT16_C # undef UINT32_C # undef UINT64_C # undef INTMAX_C # undef UINTMAX_C #endif // __STDC_CONSTANT_MACROS_DEFINED etc. mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/variant.hpp0000644000175000017500000000160511344301501027620 0ustar debiandebian//----------------------------------------------------------------------------- // boost variant.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman, Itay Maman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_VARIANT_HPP #define BOOST_VARIANT_HPP // variant "main" #include "boost/variant/variant.hpp" #include "boost/variant/recursive_variant.hpp" #include "boost/variant/recursive_wrapper.hpp" // common applications #include "boost/variant/get.hpp" #include "boost/variant/apply_visitor.hpp" #include "boost/variant/static_visitor.hpp" #include "boost/variant/visitor_ptr.hpp" #endif // BOOST_VARIANT_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/scoped_ptr.hpp0000644000175000017500000000657711344301501030333 0ustar debiandebian#ifndef BOOST_SCOPED_PTR_HPP_INCLUDED #define BOOST_SCOPED_PTR_HPP_INCLUDED // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // http://www.boost.org/libs/smart_ptr/scoped_ptr.htm // #include #include #include #ifndef BOOST_NO_AUTO_PTR # include // for std::auto_ptr #endif namespace boost { // Debug hooks #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) void sp_scalar_constructor_hook(void * p); void sp_scalar_destructor_hook(void * p); #endif // scoped_ptr mimics a built-in pointer except that it guarantees deletion // of the object pointed to, either on destruction of the scoped_ptr or via // an explicit reset(). scoped_ptr is a simple solution for simple needs; // use shared_ptr or std::auto_ptr if your needs are more complex. template class scoped_ptr // noncopyable { private: T * ptr; scoped_ptr(scoped_ptr const &); scoped_ptr & operator=(scoped_ptr const &); typedef scoped_ptr this_type; public: typedef T element_type; explicit scoped_ptr(T * p = 0): ptr(p) // never throws { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) boost::sp_scalar_constructor_hook(ptr); #endif } #ifndef BOOST_NO_AUTO_PTR explicit scoped_ptr(std::auto_ptr p): ptr(p.release()) // never throws { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) boost::sp_scalar_constructor_hook(ptr); #endif } #endif ~scoped_ptr() // never throws { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) boost::sp_scalar_destructor_hook(ptr); #endif boost::checked_delete(ptr); } void reset(T * p = 0) // never throws { BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors this_type(p).swap(*this); } T & operator*() const // never throws { BOOST_ASSERT(ptr != 0); return *ptr; } T * operator->() const // never throws { BOOST_ASSERT(ptr != 0); return ptr; } T * get() const // never throws { return ptr; } // implicit conversion to "bool" #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) operator bool () const { return ptr != 0; } #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) typedef T * (this_type::*unspecified_bool_type)() const; operator unspecified_bool_type() const // never throws { return ptr == 0? 0: &this_type::get; } #else typedef T * this_type::*unspecified_bool_type; operator unspecified_bool_type() const // never throws { return ptr == 0? 0: &this_type::ptr; } #endif bool operator! () const // never throws { return ptr == 0; } void swap(scoped_ptr & b) // never throws { T * tmp = b.ptr; b.ptr = ptr; ptr = tmp; } }; template inline void swap(scoped_ptr & a, scoped_ptr & b) // never throws { a.swap(b); } // get_pointer(p) is a generic way to say p.get() template inline T * get_pointer(scoped_ptr const & p) { return p.get(); } } // namespace boost #endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/generator_iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/generator_iterator.hp0000644000175000017500000000350311344301501031672 0ustar debiandebian// (C) Copyright Jens Maurer 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Revision History: // 15 Nov 2001 Jens Maurer // created. // See http://www.boost.org/libs/utility/iterator_adaptors.htm for documentation. #ifndef BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP #define BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP #include #include namespace boost { template class generator_iterator : public iterator_facade< generator_iterator , typename Generator::result_type , single_pass_traversal_tag , typename Generator::result_type const& > { typedef iterator_facade< generator_iterator , typename Generator::result_type , single_pass_traversal_tag , typename Generator::result_type const& > super_t; public: generator_iterator() {} generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {} void increment() { m_value = (*m_g)(); } const typename Generator::result_type& dereference() const { return m_value; } bool equal(generator_iterator const& y) const { return this->m_g == y.m_g && this->m_value == y.m_value; } private: Generator* m_g; typename Generator::result_type m_value; }; template struct generator_iterator_generator { typedef generator_iterator type; }; template inline generator_iterator make_generator_iterator(Generator & gen) { typedef generator_iterator result_t; return result_t(&gen); } } // namespace boost #endif // BOOST_ITERATOR_ADAPTOR_GENERATOR_ITERATOR_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/get_pointer.hpp0000644000175000017500000000122211344301501030466 0ustar debiandebian// Copyright Peter Dimov and David Abrahams 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef GET_POINTER_DWA20021219_HPP # define GET_POINTER_DWA20021219_HPP # include namespace boost { // get_pointer(p) extracts a ->* capable pointer from p template T * get_pointer(T * p) { return p; } // get_pointer(shared_ptr const & p) has been moved to shared_ptr.hpp template T * get_pointer(std::auto_ptr const& p) { return p.get(); } } // namespace boost #endif // GET_POINTER_DWA20021219_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/program_options.hpp0000644000175000017500000000136411344301501031400 0ustar debiandebian// Copyright Vladimir Prus 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef PROGRAM_OPTIONS_VP_2003_05_19 #define PROGRAM_OPTIONS_VP_2003_05_19 #if _MSC_VER >= 1020 #pragma once #endif #include #include #include #include #include #include #include #include #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/0000755000175000017500000000000012146213744026717 5ustar debiandebian././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/templated_streams.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/templated_stre0000644000175000017500000000430211344301501031641 0ustar debiandebian//----------------------------------------------------------------------------- // boost detail/templated_streams.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_DETAIL_TEMPLATED_STREAMS_HPP #define BOOST_DETAIL_TEMPLATED_STREAMS_HPP #include "boost/config.hpp" /////////////////////////////////////////////////////////////////////////////// // (detail) BOOST_TEMPLATED_STREAM_* macros // // Provides workaround platforms without stream class templates. // #if !defined(BOOST_NO_STD_LOCALE) #define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) \ template < typename E , typename T > #define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) \ template < typename E , typename T , typename A > #define BOOST_TEMPLATED_STREAM_ARGS(E,T) \ typename E , typename T #define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) \ typename E , typename T , typename A #define BOOST_TEMPLATED_STREAM_COMMA , #define BOOST_TEMPLATED_STREAM_ELEM(E) E #define BOOST_TEMPLATED_STREAM_TRAITS(T) T #define BOOST_TEMPLATED_STREAM_ALLOC(A) A #define BOOST_TEMPLATED_STREAM(X,E,T) \ BOOST_JOIN(std::basic_,X)< E , T > #define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ BOOST_JOIN(std::basic_,X)< E , T , A > #else // defined(BOOST_NO_STD_LOCALE) #define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) /**/ #define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) /**/ #define BOOST_TEMPLATED_STREAM_ARGS(E,T) /**/ #define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) /**/ #define BOOST_TEMPLATED_STREAM_COMMA /**/ #define BOOST_TEMPLATED_STREAM_ELEM(E) char #define BOOST_TEMPLATED_STREAM_TRAITS(T) std::char_traits #define BOOST_TEMPLATED_STREAM_ALLOC(A) std::allocator #define BOOST_TEMPLATED_STREAM(X,E,T) \ std::X #define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ std::X #endif // BOOST_NO_STD_LOCALE #endif // BOOST_DETAIL_TEMPLATED_STREAMS_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_linux.hpp0000644000175000017500000000334211344301501031434 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED #define BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED // // boost/detail/lwm_linux.hpp // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // // This implementation uses . This is a kernel header; // using kernel headers in a user program may cause a number of problems, // and not all flavors of Linux provide the atomic instructions. // // This file is only provided because the performance of this implementation // is about 3.5 times higher than the pthreads version. Use at your own risk // (by defining BOOST_USE_ASM_ATOMIC_H.) // #include #include namespace boost { namespace detail { class lightweight_mutex { private: atomic_t a_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex() { atomic_t a = ATOMIC_INIT(1); a_ = a; } class scoped_lock; friend class scoped_lock; class scoped_lock { private: lightweight_mutex & m_; scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: explicit scoped_lock(lightweight_mutex & m): m_(m) { while( !atomic_dec_and_test(&m_.a_) ) { atomic_inc(&m_.a_); sched_yield(); } } ~scoped_lock() { atomic_inc(&m_.a_); } }; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_LINUX_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/algorithm.hpp0000644000175000017500000001640511344301501031410 0ustar debiandebian// (C) Copyright Jeremy Siek 2001. Permission to copy, use, modify, // sell and distribute this software is granted provided this // copyright notice appears in all copies. This software is provided // "as is" without express or implied warranty, and with no claim as // to its suitability for any purpose. /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1996 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ #ifndef BOOST_ALGORITHM_HPP # define BOOST_ALGORITHM_HPP # include // Algorithms on sequences // // The functions in this file have not yet gone through formal // review, and are subject to change. This is a work in progress. // They have been checked into the detail directory because // there are some graph algorithms that use these functions. #include #include namespace boost { template Iter1 begin(const std::pair& p) { return p.first; } template Iter2 end(const std::pair& p) { return p.second; } template typename boost::detail::iterator_traits::difference_type size(const std::pair& p) { return std::distance(p.first, p.second); } #if 0 // These seem to interfere with the std::pair overloads :( template typename Container::iterator begin(Container& c) { return c.begin(); } template typename Container::const_iterator begin(const Container& c) { return c.begin(); } template typename Container::iterator end(Container& c) { return c.end(); } template typename Container::const_iterator end(const Container& c) { return c.end(); } template typename Container::size_type size(const Container& c) { return c.size(); } #else template typename std::vector::iterator begin(std::vector& c) { return c.begin(); } template typename std::vector::const_iterator begin(const std::vector& c) { return c.begin(); } template typename std::vector::iterator end(std::vector& c) { return c.end(); } template typename std::vector::const_iterator end(const std::vector& c) { return c.end(); } template typename std::vector::size_type size(const std::vector& c) { return c.size(); } #endif template void iota(ForwardIterator first, ForwardIterator last, T value) { for (; first != last; ++first, ++value) *first = value; } template void iota(Container& c, const T& value) { iota(begin(c), end(c), value); } // Also do version with 2nd container? template OutIter copy(const Container& c, OutIter result) { return std::copy(begin(c), end(c), result); } template bool equal(const Container1& c1, const Container2& c2) { if (size(c1) != size(c2)) return false; return std::equal(begin(c1), end(c1), begin(c2)); } template void sort(Container& c) { std::sort(begin(c), end(c)); } template void sort(Container& c, const Predicate& p) { std::sort(begin(c), end(c), p); } template void stable_sort(Container& c) { std::stable_sort(begin(c), end(c)); } template void stable_sort(Container& c, const Predicate& p) { std::stable_sort(begin(c), end(c), p); } template bool any_if(InputIterator first, InputIterator last, Predicate p) { return std::find_if(first, last, p) != last; } template bool any_if(const Container& c, Predicate p) { return any_if(begin(c), end(c), p); } template bool contains(InputIterator first, InputIterator last, T value) { return std::find(first, last, value) != last; } template bool contains(const Container& c, const T& value) { return contains(begin(c), end(c), value); } template bool all(InputIterator first, InputIterator last, Predicate p) { for (; first != last; ++first) if (!p(*first)) return false; return true; } template bool all(const Container& c, Predicate p) { return all(begin(c), end(c), p); } template bool none(InputIterator first, InputIterator last, Predicate p) { return std::find_if(first, last, p) == last; } template bool none(const Container& c, Predicate p) { return none(begin(c), end(c), p); } template std::size_t count(const Container& c, const T& value) { return std::count(begin(c), end(c), value); } template std::size_t count_if(const Container& c, Predicate p) { return std::count_if(begin(c), end(c), p); } template bool is_sorted(ForwardIterator first, ForwardIterator last) { if (first == last) return true; ForwardIterator next = first; for (++next; next != last; first = next, ++next) { if (*next < *first) return false; } return true; } template bool is_sorted(ForwardIterator first, ForwardIterator last, StrictWeakOrdering comp) { if (first == last) return true; ForwardIterator next = first; for (++next; next != last; first = next, ++next) { if (comp(*next, *first)) return false; } return true; } template bool is_sorted(const Container& c) { return is_sorted(begin(c), end(c)); } template bool is_sorted(const Container& c, StrictWeakOrdering comp) { return is_sorted(begin(c), end(c), comp); } } // namespace boost #endif // BOOST_ALGORITHM_HPP ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/named_template_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/named_template0000644000175000017500000001371211344301501031611 0ustar debiandebian// (C) Copyright Jeremy Siek 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // Revision History: // 04 Oct 2001 David Abrahams // Changed name of "bind" to "select" to avoid problems with MSVC. #ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP #define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP #include #include // for is_reference #if defined(__BORLANDC__) #include #endif namespace boost { namespace detail { struct default_argument { }; struct dummy_default_gen { template struct select { typedef default_argument type; }; }; // This class template is a workaround for MSVC. template struct default_generator { typedef detail::dummy_default_gen type; }; template struct is_default { enum { value = false }; typedef type_traits::no_type type; }; template <> struct is_default { enum { value = true }; typedef type_traits::yes_type type; }; struct choose_default { template struct select { typedef typename default_generator::type Gen; typedef typename Gen::template select::type type; }; }; struct choose_arg { template struct select { typedef Arg type; }; }; #if defined(__BORLANDC__) template struct choose_arg_or_default { typedef choose_arg type; }; template <> struct choose_arg_or_default { typedef choose_default type; }; #else template struct choose_arg_or_default { typedef choose_arg type; }; template <> struct choose_arg_or_default { typedef choose_default type; }; #endif template class resolve_default { #if defined(__BORLANDC__) typedef typename choose_arg_or_default::type>::type Selector; #else // This usually works for Borland, but I'm seeing weird errors in // iterator_adaptor_test.cpp when using this method. enum { is_def = is_default::value }; typedef typename choose_arg_or_default::type Selector; #endif public: typedef typename Selector ::template select::type type; }; // To differentiate an unnamed parameter from a traits generator // we use is_convertible. struct named_template_param_base { }; template struct is_named_param_list { enum { value = is_convertible::value }; }; struct choose_named_params { template struct select { typedef Prev type; }; }; struct choose_default_arg { template struct select { typedef detail::default_argument type; }; }; template struct choose_default_dispatch_; template <> struct choose_default_dispatch_ { typedef choose_named_params type; }; template <> struct choose_default_dispatch_ { typedef choose_default_arg type; }; // The use of inheritance here is a Solaris Forte 6 workaround. template struct choose_default_dispatch : public choose_default_dispatch_ { }; template struct choose_default_argument { enum { is_named = is_named_param_list::value }; typedef typename choose_default_dispatch::type Selector; typedef typename Selector::template select::type type; }; // This macro assumes that there is a class named default_##TYPE // defined before the application of the macro. This class should // have a single member class template named "select" with two // template parameters: the type of the class being created (e.g., // the iterator_adaptor type when creating iterator adaptors) and // a traits class. The select class should have a single typedef // named "type" that produces the default for TYPE. See // boost/iterator_adaptors.hpp for an example usage. Also, // applications of this macro must be placed in namespace // boost::detail. #define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \ struct get_##TYPE##_from_named { \ template \ struct select { \ typedef typename NamedParams::traits NamedTraits; \ typedef typename NamedTraits::TYPE TYPE; \ typedef typename resolve_default::type type; \ }; \ }; \ struct pass_thru_##TYPE { \ template struct select { \ typedef typename resolve_default::type type; \ };\ }; \ template \ struct get_##TYPE##_dispatch { }; \ template <> struct get_##TYPE##_dispatch<1> { \ typedef get_##TYPE##_from_named type; \ }; \ template <> struct get_##TYPE##_dispatch<0> { \ typedef pass_thru_##TYPE type; \ }; \ template \ class get_##TYPE { \ enum { is_named = is_named_param_list::value }; \ typedef typename get_##TYPE##_dispatch::type Selector; \ public: \ typedef typename Selector::template select::type type; \ }; \ template <> struct default_generator { \ typedef default_##TYPE type; \ } } // namespace detail } // namespace boost #endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/iterator.hpp0000644000175000017500000003673011344301501031256 0ustar debiandebian// (C) Copyright David Abrahams 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // Boost versions of // // std::iterator_traits<>::iterator_category // std::iterator_traits<>::difference_type // std::distance() // // ...for all compilers and iterators // // Additionally, if X is a pointer // std::iterator_traits::pointer // Otherwise, if partial specialization is supported or X is not a pointer // std::iterator_traits::value_type // std::iterator_traits::pointer // std::iterator_traits::reference // // See http://www.boost.org for most recent version including documentation. // Revision History // 04 Mar 2001 - More attempted fixes for Intel C++ (David Abrahams) // 03 Mar 2001 - Put all implementation into namespace // boost::detail::iterator_traits_. Some progress made on fixes // for Intel compiler. (David Abrahams) // 02 Mar 2001 - Changed BOOST_MSVC to BOOST_MSVC_STD_ITERATOR in a few // places. (Jeremy Siek) // 19 Feb 2001 - Improved workarounds for stock MSVC6; use yes_type and // no_type from type_traits.hpp; stopped trying to remove_cv // before detecting is_pointer, in honor of the new type_traits // semantics. (David Abrahams) // 13 Feb 2001 - Make it work with nearly all standard-conforming iterators // under raw VC6. The one category remaining which will fail is // that of iterators derived from std::iterator but not // boost::iterator and which redefine difference_type. // 11 Feb 2001 - Clean away code which can never be used (David Abrahams) // 09 Feb 2001 - Always have a definition for each traits member, even if it // can't be properly deduced. These will be incomplete types in // some cases (undefined), but it helps suppress MSVC errors // elsewhere (David Abrahams) // 07 Feb 2001 - Support for more of the traits members where possible, making // this useful as a replacement for std::iterator_traits when // used as a default template parameter. // 06 Feb 2001 - Removed useless #includes of standard library headers // (David Abrahams) #ifndef ITERATOR_DWA122600_HPP_ # define ITERATOR_DWA122600_HPP_ # include # include // STLPort 4.0 and betas have a bug when debugging is enabled and there is no // partial specialization: instead of an iterator_category typedef, the standard // container iterators have _Iterator_category. // // Also, whether debugging is enabled or not, there is a broken specialization // of std::iterator which has no // typedefs but iterator_category. # if defined(__SGI_STL_PORT) # if (__SGI_STL_PORT <= 0x410) && !defined(__STL_CLASS_PARTIAL_SPECIALIZATION) && defined(__STL_DEBUG) # define BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF # endif # define BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION # endif // STLPort <= 4.1b4 && no partial specialization # if !defined(BOOST_NO_STD_ITERATOR_TRAITS) \ && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MSVC_STD_ITERATOR) namespace boost { namespace detail { // Define a new template so it can be specialized template struct iterator_traits : std::iterator_traits {}; using std::distance; }} // namespace boost::detail # else # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MSVC_STD_ITERATOR) // This is the case where everything conforms except BOOST_NO_STD_ITERATOR_TRAITS namespace boost { namespace detail { // Rogue Wave Standard Library fools itself into thinking partial // specialization is missing on some platforms (e.g. Sun), so fails to // supply iterator_traits! template struct iterator_traits { typedef typename Iterator::value_type value_type; typedef typename Iterator::reference reference; typedef typename Iterator::pointer pointer; typedef typename Iterator::difference_type difference_type; typedef typename Iterator::iterator_category iterator_category; }; template struct iterator_traits { typedef T value_type; typedef T& reference; typedef T* pointer; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; }; template struct iterator_traits { typedef T value_type; typedef T const& reference; typedef T const* pointer; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; }; }} // namespace boost::detail # else # include # include # include # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include # include # endif # ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION # include # endif # include # include # include // should be the last #include # include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type) BOOST_MPL_HAS_XXX_TRAIT_DEF(reference) BOOST_MPL_HAS_XXX_TRAIT_DEF(pointer) BOOST_MPL_HAS_XXX_TRAIT_DEF(difference_type) BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator_category) // is_mutable_iterator -- // // A metafunction returning true iff T is a mutable iterator type // with a nested value_type. Will only work portably with iterators // whose operator* returns a reference, but that seems to be OK for // the iterators supplied by Dinkumware. Some input iterators may // compile-time if they arrive here, and if the compiler is strict // about not taking the address of an rvalue. // This one detects ordinary mutable iterators - the result of // operator* is convertible to the value_type. template type_traits::yes_type is_mutable_iterator_helper(T const*, BOOST_DEDUCED_TYPENAME T::value_type*); // Since you can't take the address of an rvalue, the guts of // is_mutable_iterator_impl will fail if we use &*t directly. This // makes sure we can still work with non-lvalue iterators. template T* mutable_iterator_lvalue_helper(T& x); int mutable_iterator_lvalue_helper(...); // This one detects output iterators such as ostream_iterator which // return references to themselves. template type_traits::yes_type is_mutable_iterator_helper(T const*, T const*); type_traits::no_type is_mutable_iterator_helper(...); template struct is_mutable_iterator_impl { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof( detail::is_mutable_iterator_helper( (T*)0 , mutable_iterator_lvalue_helper(*t) // like &*t )) == sizeof(type_traits::yes_type) ); }; BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_mutable_iterator,T,::boost::detail::is_mutable_iterator_impl::value) // is_full_iterator_traits -- // // A metafunction returning true iff T has all the requisite nested // types to satisfy the requirements for a fully-conforming // iterator_traits implementation. template struct is_full_iterator_traits_impl { enum { value = has_value_type::value & has_reference::value & has_pointer::value & has_difference_type::value & has_iterator_category::value }; }; BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_full_iterator_traits,T,::boost::detail::is_full_iterator_traits_impl::value) # ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF BOOST_MPL_HAS_XXX_TRAIT_DEF(_Iterator_category) // is_stlport_40_debug_iterator -- // // A metafunction returning true iff T has all the requisite nested // types to satisfy the requirements of an STLPort 4.0 debug iterator // iterator_traits implementation. template struct is_stlport_40_debug_iterator_impl { enum { value = has_value_type::value & has_reference::value & has_pointer::value & has_difference_type::value & has__Iterator_category::value }; }; BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_stlport_40_debug_iterator,T,::boost::detail::is_stlport_40_debug_iterator_impl::value) template struct stlport_40_debug_iterator_traits { typedef typename T::value_type value_type; typedef typename T::reference reference; typedef typename T::pointer pointer; typedef typename T::difference_type difference_type; typedef typename T::_Iterator_category iterator_category; }; # endif // BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF template struct pointer_iterator_traits; # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct pointer_iterator_traits { typedef typename remove_const::type value_type; typedef T* pointer; typedef T& reference; typedef std::random_access_iterator_tag iterator_category; typedef std::ptrdiff_t difference_type; }; # else // In case of no template partial specialization, and if T is a // pointer, iterator_traits::value_type can still be computed. For // some basic types, remove_pointer is manually defined in // type_traits/broken_compiler_spec.hpp. For others, do it yourself. template class please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee; template struct pointer_value_type : mpl::if_< is_same::type> , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee

, typename remove_const< typename remove_pointer

::type >::type > { }; template struct pointer_reference : mpl::if_< is_same::type> , please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_on_cv_unqualified_pointee

, typename remove_pointer

::type& > { }; template struct pointer_iterator_traits { typedef T pointer; typedef std::random_access_iterator_tag iterator_category; typedef std::ptrdiff_t difference_type; typedef typename pointer_value_type::type value_type; typedef typename pointer_reference::type reference; }; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // We'll sort iterator types into one of these classifications, from which we // can determine the difference_type, pointer, reference, and value_type template struct standard_iterator_traits { typedef typename Iterator::difference_type difference_type; typedef typename Iterator::value_type value_type; typedef typename Iterator::pointer pointer; typedef typename Iterator::reference reference; typedef typename Iterator::iterator_category iterator_category; }; template struct msvc_stdlib_mutable_traits : std::iterator_traits { typedef typename std::iterator_traits::distance_type difference_type; typedef typename std::iterator_traits::value_type* pointer; typedef typename std::iterator_traits::value_type& reference; }; template struct msvc_stdlib_const_traits : std::iterator_traits { typedef typename std::iterator_traits::distance_type difference_type; typedef const typename std::iterator_traits::value_type* pointer; typedef const typename std::iterator_traits::value_type& reference; }; # ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION template struct is_bad_output_iterator : is_base_and_derived< std::iterator , Iterator> { }; struct bad_output_iterator_traits { typedef void value_type; typedef void difference_type; typedef std::output_iterator_tag iterator_category; typedef void pointer; typedef void reference; }; # endif // If we're looking at an MSVC6 (old Dinkumware) ``standard'' // iterator, this will generate an appropriate traits class. template struct msvc_stdlib_iterator_traits : mpl::if_< is_mutable_iterator , msvc_stdlib_mutable_traits , msvc_stdlib_const_traits >::type {}; template struct non_pointer_iterator_traits : mpl::if_< // if the iterator contains all the right nested types... is_full_iterator_traits // Use a standard iterator_traits implementation , standard_iterator_traits # ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF // Check for STLPort 4.0 broken _Iterator_category type , mpl::if_< is_stlport_40_debug_iterator , stlport_40_debug_iterator_traits # endif // Otherwise, assume it's a Dinkum iterator , msvc_stdlib_iterator_traits # ifdef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF >::type # endif >::type { }; template struct iterator_traits_aux : mpl::if_< is_pointer , pointer_iterator_traits , non_pointer_iterator_traits >::type { }; template struct iterator_traits { // Explicit forwarding from base class needed to keep MSVC6 happy // under some circumstances. private: # ifdef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION typedef typename mpl::if_< is_bad_output_iterator , bad_output_iterator_traits , iterator_traits_aux >::type base; # else typedef iterator_traits_aux base; # endif public: typedef typename base::value_type value_type; typedef typename base::pointer pointer; typedef typename base::reference reference; typedef typename base::difference_type difference_type; typedef typename base::iterator_category iterator_category; }; // This specialization cuts off ETI (Early Template Instantiation) for MSVC. template <> struct iterator_traits { typedef int value_type; typedef int pointer; typedef int reference; typedef int difference_type; typedef int iterator_category; }; }} // namespace boost::detail # endif // workarounds namespace boost { namespace detail { namespace iterator_traits_ { template struct distance_select { static Difference execute(Iterator i1, const Iterator i2, ...) { Difference result = 0; while (i1 != i2) { ++i1; ++result; } return result; } static Difference execute(Iterator i1, const Iterator i2, std::random_access_iterator_tag*) { return i2 - i1; } }; } // namespace boost::detail::iterator_traits_ template inline typename iterator_traits::difference_type distance(Iterator first, Iterator last) { typedef typename iterator_traits::difference_type diff_t; typedef typename ::boost::detail::iterator_traits::iterator_category iterator_category; return iterator_traits_::distance_select::execute( first, last, (iterator_category*)0); } }} # endif # undef BOOST_BAD_CONTAINER_ITERATOR_CATEGORY_TYPEDEF # undef BOOST_BAD_OUTPUT_ITERATOR_SPECIALIZATION #endif // ITERATOR_DWA122600_HPP_ ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/allocator_utilities.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/allocator_util0000644000175000017500000001032711344301501031646 0ustar debiandebian/* Copyright 2003-2004 Joaquín M López Muñoz. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * See Boost website at http://www.boost.org/ */ #ifndef BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP #define BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP #include /* keep it first to prevent nasty warns in MSVC */ #include #include #include #include #include #include #include namespace boost{ namespace detail{ /* Allocator adaption layer. Some stdlibs provide allocators without rebind * and template ctors. These facilities are simulated with the external * template class rebind_to and the aid of partial_std_allocator_wrapper. */ namespace allocator{ /* partial_std_allocator_wrapper inherits the functionality of a std * allocator while providing a templatized ctor. */ template class partial_std_allocator_wrapper:public std::allocator { public: partial_std_allocator_wrapper(){}; template partial_std_allocator_wrapper(const partial_std_allocator_wrapper&){} #if defined(BOOST_DINKUMWARE_STDLIB) /* Dinkumware guys didn't provide a means to call allocate() without * supplying a hint, in disagreement with the standard. */ Type* allocate(std::size_t n,const void* hint=0) { std::allocator& a=*this; return a.allocate(n,hint); } #endif }; /* Detects whether a given allocator belongs to a defective stdlib not * having the required member templates. * Note that it does not suffice to check the Boost.Config stdlib * macros, as the user might have passed a custom, compliant allocator. * The checks also considers partial_std_allocator_wrapper to be * a standard defective allocator. */ #if defined(BOOST_NO_STD_ALLOCATOR)&&\ (defined(BOOST_HAS_PARTIAL_STD_ALLOCATOR)||defined(BOOST_DINKUMWARE_STDLIB)) template struct is_partial_std_allocator { BOOST_STATIC_CONSTANT(bool, value= (is_same< std::allocator, Allocator >::value)|| (is_same< partial_std_allocator_wrapper< BOOST_DEDUCED_TYPENAME Allocator::value_type>, Allocator >::value)); }; #else template struct is_partial_std_allocator { BOOST_STATIC_CONSTANT(bool,value=false); }; #endif /* rebind operations for defective std allocators */ template struct partial_std_allocator_rebind_to { typedef partial_std_allocator_wrapper type; }; /* rebind operation in all other cases */ #if BOOST_WORKAROUND(BOOST_MSVC,<1300) /* Workaround for a problem in MSVC with dependent template typedefs * when doing rebinding of allocators. * Modeled after (thanks, Aleksey!) */ template struct rebinder { template struct fake_allocator:Allocator{}; template<> struct fake_allocator { template struct rebind{}; }; template struct result: fake_allocator::value>:: template rebind { }; }; #else template struct rebinder { template struct result:Allocator::BOOST_NESTED_TEMPLATE rebind { }; }; #endif template struct compliant_allocator_rebind_to { typedef typename rebinder:: BOOST_NESTED_TEMPLATE result::other type; }; /* rebind front-end */ template struct rebind_to: mpl::eval_if_c< is_partial_std_allocator::value, partial_std_allocator_rebind_to, compliant_allocator_rebind_to > { }; /* allocator-independent versions of construct and destroy */ template void construct(void* p,const Type& t) { new (p) Type(t); } template void destroy(const Type* p) { p->~Type(); } } /* namespace boost::detail::allocator */ } /* namespace boost::detail */ } /* namespace boost */ #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/shared_ptr_nmt.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/shared_ptr_nmt0000644000175000017500000000726011344301501031644 0ustar debiandebian#ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED #define BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED // // detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates // // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation. // #include #include #include #include #ifndef BOOST_NO_AUTO_PTR # include // for std::auto_ptr #endif #include // for std::swap #include // for std::less #include // for std::bad_alloc namespace boost { template class shared_ptr { private: typedef detail::atomic_count count_type; public: typedef T element_type; typedef T value_type; explicit shared_ptr(T * p = 0): px(p) { #ifndef BOOST_NO_EXCEPTIONS try // prevent leak if new throws { pn = new count_type(1); } catch(...) { boost::checked_delete(p); throw; } #else pn = new count_type(1); if(pn == 0) { boost::checked_delete(p); boost::throw_exception(std::bad_alloc()); } #endif } ~shared_ptr() { if(--*pn == 0) { boost::checked_delete(px); delete pn; } } shared_ptr(shared_ptr const & r): px(r.px) // never throws { pn = r.pn; ++*pn; } shared_ptr & operator=(shared_ptr const & r) { shared_ptr(r).swap(*this); return *this; } #ifndef BOOST_NO_AUTO_PTR explicit shared_ptr(std::auto_ptr & r) { pn = new count_type(1); // may throw px = r.release(); // fix: moved here to stop leak if new throws } shared_ptr & operator=(std::auto_ptr & r) { shared_ptr(r).swap(*this); return *this; } #endif void reset(T * p = 0) { BOOST_ASSERT(p == 0 || p != px); shared_ptr(p).swap(*this); } T & operator*() const // never throws { BOOST_ASSERT(px != 0); return *px; } T * operator->() const // never throws { BOOST_ASSERT(px != 0); return px; } T * get() const // never throws { return px; } long use_count() const // never throws { return *pn; } bool unique() const // never throws { return *pn == 1; } void swap(shared_ptr & other) // never throws { std::swap(px, other.px); std::swap(pn, other.pn); } private: T * px; // contained pointer count_type * pn; // ptr to reference counter }; template inline bool operator==(shared_ptr const & a, shared_ptr const & b) { return a.get() == b.get(); } template inline bool operator!=(shared_ptr const & a, shared_ptr const & b) { return a.get() != b.get(); } template inline bool operator<(shared_ptr const & a, shared_ptr const & b) { return std::less()(a.get(), b.get()); } template void swap(shared_ptr & a, shared_ptr & b) { a.swap(b); } // get_pointer() enables boost::mem_fn to recognize shared_ptr template inline T * get_pointer(shared_ptr const & p) { return p.get(); } } // namespace boost #endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/reference_content.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/reference_cont0000644000175000017500000000571611344301501031620 0ustar debiandebian//----------------------------------------------------------------------------- // boost detail/reference_content.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_DETAIL_REFERENCE_CONTENT_HPP #define BOOST_DETAIL_REFERENCE_CONTENT_HPP #include "boost/config.hpp" #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include "boost/mpl/bool.hpp" # include "boost/type_traits/has_nothrow_copy.hpp" #else # include "boost/mpl/if.hpp" # include "boost/type_traits/is_reference.hpp" #endif #include "boost/mpl/void.hpp" namespace boost { namespace detail { /////////////////////////////////////////////////////////////////////////////// // (detail) class template reference_content // // Non-Assignable wrapper for references. // template class reference_content { private: // representation RefT content_; public: // structors ~reference_content() { } reference_content(RefT r) : content_( r ) { } reference_content(const reference_content& operand) : content_( operand.content_ ) { } private: // non-Assignable reference_content& operator=(const reference_content&); public: // queries RefT get() const { return content_; } }; /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction make_reference_content // // Wraps with reference_content if specified type is reference. // template struct make_reference_content; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template struct make_reference_content { typedef T type; }; template struct make_reference_content< T& > { typedef reference_content type; }; #else // defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template struct make_reference_content : mpl::if_< is_reference , reference_content , T > { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION workaround template <> struct make_reference_content< mpl::void_ > { template struct apply : make_reference_content { }; typedef mpl::void_ type; }; } // namespace detail /////////////////////////////////////////////////////////////////////////////// // reference_content type traits specializations // #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template struct has_nothrow_copy< ::boost::detail::reference_content< T& > > : mpl::true_ { }; #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) } // namespace boost #endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/is_function_ref_tester.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/is_function_re0000644000175000017500000001744711344301501031651 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED #define BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/config.hpp" #if defined(BOOST_TT_PREPROCESSING_MODE) # include "boost/preprocessor/iterate.hpp" # include "boost/preprocessor/enum_params.hpp" # include "boost/preprocessor/comma_if.hpp" #endif namespace boost { namespace detail { namespace is_function_ref_tester_ { template boost::type_traits::no_type BOOST_TT_DECL is_function_ref_tester(T& ...); #if !defined(BOOST_TT_PREPROCESSING_MODE) // preprocessor-generated part, don't edit by hand! template boost::type_traits::yes_type is_function_ref_tester(R (&)(), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23), int); template boost::type_traits::yes_type is_function_ref_tester(R (&)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24), int); #else #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 25, "boost/type_traits/detail/is_function_ref_tester.hpp")) #include BOOST_PP_ITERATE() #endif // BOOST_TT_PREPROCESSING_MODE } // namespace detail } // namespace python } // namespace boost #endif // BOOST_DETAIL_IS_FUNCTION_REF_TESTER_HPP_INCLUDED ///// iteration #else #define i BOOST_PP_FRAME_ITERATION(1) template boost::type_traits::yes_type is_function_ref_tester(R (&)(BOOST_PP_ENUM_PARAMS(i,T)), int); #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_win32.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_w0000644000175000017500000000373411344301501031647 0ustar debiandebian#ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED #define BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/atomic_count_win32.hpp // // Copyright (c) 2001, 2002, 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifdef BOOST_USE_WINDOWS_H # include #endif namespace boost { namespace detail { #ifndef BOOST_USE_WINDOWS_H #ifdef _WIN64 // Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users] extern "C" long_type __cdecl _InterlockedIncrement(long volatile *); extern "C" long_type __cdecl _InterlockedDecrement(long volatile *); #pragma intrinsic(_InterlockedIncrement) #pragma intrinsic(_InterlockedDecrement) inline long InterlockedIncrement(long volatile * lp) { return _InterlockedIncrement(lp); } inline long InterlockedDecrement(long volatile* lp) { return _InterlockedDecrement(lp); } #else // _WIN64 extern "C" __declspec(dllimport) long __stdcall InterlockedIncrement(long volatile *); extern "C" __declspec(dllimport) long __stdcall InterlockedDecrement(long volatile *); #endif // _WIN64 #endif // #ifndef BOOST_USE_WINDOWS_H class atomic_count { public: explicit atomic_count(long v): value_(v) { } long operator++() { // Some older versions do not accept volatile return InterlockedIncrement(const_cast(&value_)); } long operator--() { return InterlockedDecrement(const_cast(&value_)); } operator long() const { return value_; } private: atomic_count(atomic_count const &); atomic_count & operator=(atomic_count const &); volatile long value_; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/compressed_pair.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/compressed_pai0000644000175000017500000003727111344301501031635 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/utility for most recent version including documentation. // compressed_pair: pair that "compresses" empty members // (see libs/utility/compressed_pair.htm) // // JM changes 25 Jan 2004: // For the case where T1 == T2 and both are empty, then first() and second() // should return different objects. // JM changes 25 Jan 2000: // Removed default arguments from compressed_pair_switch to get // C++ Builder 4 to accept them // rewriten swap to get gcc and C++ builder to compile. // added partial specialisations for case T1 == T2 to avoid duplicate constructor defs. #ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP #define BOOST_DETAIL_COMPRESSED_PAIR_HPP #include #include #include #include #include namespace boost { template class compressed_pair; // compressed_pair namespace details { // JM altered 26 Jan 2000: template struct compressed_pair_switch; template struct compressed_pair_switch {static const int value = 0;}; template struct compressed_pair_switch {static const int value = 3;}; template struct compressed_pair_switch {static const int value = 1;}; template struct compressed_pair_switch {static const int value = 2;}; template struct compressed_pair_switch {static const int value = 4;}; template struct compressed_pair_switch {static const int value = 5;}; template class compressed_pair_imp; #ifdef __GNUC__ // workaround for GCC (JM): using std::swap; #endif // // can't call unqualified swap from within classname::swap // as Koenig lookup rules will find only the classname::swap // member function not the global declaration, so use cp_swap // as a forwarding function (JM): template inline void cp_swap(T& t1, T& t2) { #ifndef __GNUC__ using std::swap; #endif swap(t1, t2); } // 0 derive from neither template class compressed_pair_imp { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_(x), second_(y) {} compressed_pair_imp(first_param_type x) : first_(x) {} compressed_pair_imp(second_param_type y) : second_(y) {} first_reference first() {return first_;} first_const_reference first() const {return first_;} second_reference second() {return second_;} second_const_reference second() const {return second_;} void swap(::boost::compressed_pair& y) { cp_swap(first_, y.first()); cp_swap(second_, y.second()); } private: first_type first_; second_type second_; }; // 1 derive from T1 template class compressed_pair_imp : private T1 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_type(x), second_(y) {} compressed_pair_imp(first_param_type x) : first_type(x) {} compressed_pair_imp(second_param_type y) : second_(y) {} first_reference first() {return *this;} first_const_reference first() const {return *this;} second_reference second() {return second_;} second_const_reference second() const {return second_;} void swap(::boost::compressed_pair& y) { // no need to swap empty base class: cp_swap(second_, y.second()); } private: second_type second_; }; // 2 derive from T2 template class compressed_pair_imp : private T2 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : second_type(y), first_(x) {} compressed_pair_imp(first_param_type x) : first_(x) {} compressed_pair_imp(second_param_type y) : second_type(y) {} first_reference first() {return first_;} first_const_reference first() const {return first_;} second_reference second() {return *this;} second_const_reference second() const {return *this;} void swap(::boost::compressed_pair& y) { // no need to swap empty base class: cp_swap(first_, y.first()); } private: first_type first_; }; // 3 derive from T1 and T2 template class compressed_pair_imp : private T1, private T2 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_type(x), second_type(y) {} compressed_pair_imp(first_param_type x) : first_type(x) {} compressed_pair_imp(second_param_type y) : second_type(y) {} first_reference first() {return *this;} first_const_reference first() const {return *this;} second_reference second() {return *this;} second_const_reference second() const {return *this;} // // no need to swap empty bases: void swap(::boost::compressed_pair&) {} }; // JM // 4 T1 == T2, T1 and T2 both empty // Note does not actually store an instance of T2 at all - // but reuses T1 base class for both first() and second(). template class compressed_pair_imp : private T1 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_type(x), m_second(y) {} compressed_pair_imp(first_param_type x) : first_type(x), m_second(x) {} first_reference first() {return *this;} first_const_reference first() const {return *this;} second_reference second() {return m_second;} second_const_reference second() const {return m_second;} void swap(::boost::compressed_pair&) {} private: T2 m_second; }; // 5 T1 == T2 and are not empty: //JM template class compressed_pair_imp { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_(x), second_(y) {} compressed_pair_imp(first_param_type x) : first_(x), second_(x) {} first_reference first() {return first_;} first_const_reference first() const {return first_;} second_reference second() {return second_;} second_const_reference second() const {return second_;} void swap(::boost::compressed_pair& y) { cp_swap(first_, y.first()); cp_swap(second_, y.second()); } private: first_type first_; second_type second_; }; } // details template class compressed_pair : private ::boost::details::compressed_pair_imp::type, typename remove_cv::type>::value, ::boost::is_empty::value, ::boost::is_empty::value>::value> { private: typedef details::compressed_pair_imp::type, typename remove_cv::type>::value, ::boost::is_empty::value, ::boost::is_empty::value>::value> base; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair() : base() {} compressed_pair(first_param_type x, second_param_type y) : base(x, y) {} explicit compressed_pair(first_param_type x) : base(x) {} explicit compressed_pair(second_param_type y) : base(y) {} first_reference first() {return base::first();} first_const_reference first() const {return base::first();} second_reference second() {return base::second();} second_const_reference second() const {return base::second();} void swap(compressed_pair& y) { base::swap(y); } }; // JM // Partial specialisation for case where T1 == T2: // template class compressed_pair : private details::compressed_pair_imp::type, typename remove_cv::type>::value, ::boost::is_empty::value, ::boost::is_empty::value>::value> { private: typedef details::compressed_pair_imp::type, typename remove_cv::type>::value, ::boost::is_empty::value, ::boost::is_empty::value>::value> base; public: typedef T first_type; typedef T second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair() : base() {} compressed_pair(first_param_type x, second_param_type y) : base(x, y) {} #if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) explicit #endif compressed_pair(first_param_type x) : base(x) {} first_reference first() {return base::first();} first_const_reference first() const {return base::first();} second_reference second() {return base::second();} second_const_reference second() const {return base::second();} void swap(::boost::compressed_pair& y) { base::swap(y); } }; template inline void swap(compressed_pair& x, compressed_pair& y) { x.swap(y); } } // boost #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count.h0000644000175000017500000000624511344301501031547 0ustar debiandebian#ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED #define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/atomic_count.hpp - thread/SMP safe reference counter // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // typedef boost::detail::atomic_count; // // atomic_count a(n); // // (n is convertible to long) // // Effects: Constructs an atomic_count with an initial value of n // // a; // // Returns: (long) the current value of a // // ++a; // // Effects: Atomically increments the value of a // Returns: nothing // // --a; // // Effects: Atomically decrements the value of a // Returns: (long) zero if the new value of a is zero, // unspecified non-zero value otherwise (usually the new value) // // Important note: when --a returns zero, it must act as a // read memory barrier (RMB); i.e. the calling thread must // have a synchronized view of the memory // // On Intel IA-32 (x86) memory is always synchronized, so this // is not a problem. // // On many architectures the atomic instructions already act as // a memory barrier. // // This property is necessary for proper reference counting, since // a thread can update the contents of a shared object, then // release its reference, and another thread may immediately // release the last reference causing object destruction. // // The destructor needs to have a synchronized view of the // object to perform proper cleanup. // // Original example by Alexander Terekhov: // // Given: // // - a mutable shared object OBJ; // - two threads THREAD1 and THREAD2 each holding // a private smart_ptr object pointing to that OBJ. // // t1: THREAD1 updates OBJ (thread-safe via some synchronization) // and a few cycles later (after "unlock") destroys smart_ptr; // // t2: THREAD2 destroys smart_ptr WITHOUT doing any synchronization // with respect to shared mutable object OBJ; OBJ destructors // are called driven by smart_ptr interface... // // Note: atomic_count_linux.hpp has been disabled by default; see the // comments inside for more info. #include #ifndef BOOST_HAS_THREADS namespace boost { namespace detail { typedef long atomic_count; } } #elif defined(BOOST_USE_ASM_ATOMIC_H) # include #elif defined(BOOST_AC_USE_PTHREADS) # include #elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) # include #elif defined(__GLIBCPP__) # include #elif defined(BOOST_HAS_PTHREADS) # define BOOST_AC_USE_PTHREADS # include #else // Use #define BOOST_DISABLE_THREADS to avoid the error #error Unrecognized threading platform #endif #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_irix.hpp0000644000175000017500000000242111344301501031245 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED #define BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED // // boost/detail/lwm_irix.hpp // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // Copyright (c) 2002 Dan Gohman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include #include #include namespace boost { namespace detail { class lightweight_mutex { private: __uint32_t l_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex(): l_(0) { } class scoped_lock; friend class scoped_lock; class scoped_lock { private: lightweight_mutex & m_; scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: explicit scoped_lock(lightweight_mutex & m): m_(m) { while( test_and_set32(&m_.l_, 1) ) { sched_yield(); } } ~scoped_lock() { m_.l_ = 0; } }; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_IRIX_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_win32_cs.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_win32_cs.h0000644000175000017500000000415011344301501031362 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED #define BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lwm_win32_cs.hpp // // Copyright (c) 2002, 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifdef BOOST_USE_WINDOWS_H # include #endif namespace boost { namespace detail { #ifndef BOOST_USE_WINDOWS_H struct CRITICAL_SECTION { struct critical_section_debug * DebugInfo; long LockCount; long RecursionCount; void * OwningThread; void * LockSemaphore; #if defined(_WIN64) unsigned __int64 SpinCount; #else unsigned long SpinCount; #endif }; extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(CRITICAL_SECTION *); extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(CRITICAL_SECTION *); extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(CRITICAL_SECTION *); extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(CRITICAL_SECTION *); #endif // #ifndef BOOST_USE_WINDOWS_H class lightweight_mutex { private: CRITICAL_SECTION cs_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex() { InitializeCriticalSection(&cs_); } ~lightweight_mutex() { DeleteCriticalSection(&cs_); } class scoped_lock; friend class scoped_lock; class scoped_lock { private: lightweight_mutex & m_; scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: explicit scoped_lock(lightweight_mutex & m): m_(m) { EnterCriticalSection(&m_.cs_); } ~scoped_lock() { LeaveCriticalSection(&m_.cs_); } }; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_WIN32_CS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_pthreads.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_p0000644000175000017500000000332511344301501031634 0ustar debiandebian#ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED #define BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED // // boost/detail/atomic_count_pthreads.hpp // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include // // The generic pthread_mutex-based implementation sometimes leads to // inefficiencies. Example: a class with two atomic_count members // can get away with a single mutex. // // Users can detect this situation by checking BOOST_AC_USE_PTHREADS. // namespace boost { namespace detail { class atomic_count { private: class scoped_lock { public: scoped_lock(pthread_mutex_t & m): m_(m) { pthread_mutex_lock(&m_); } ~scoped_lock() { pthread_mutex_unlock(&m_); } private: pthread_mutex_t & m_; }; public: explicit atomic_count(long v): value_(v) { pthread_mutex_init(&mutex_, 0); } ~atomic_count() { pthread_mutex_destroy(&mutex_); } void operator++() { scoped_lock lock(mutex_); ++value_; } long operator--() { scoped_lock lock(mutex_); return --value_; } operator long() const { scoped_lock lock(mutex_); return value_; } private: atomic_count(atomic_count const &); atomic_count & operator=(atomic_count const &); mutable pthread_mutex_t mutex_; long value_; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_gcc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_g0000644000175000017500000000223011344301501031615 0ustar debiandebian#ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED #define BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED // // boost/detail/atomic_count_gcc.hpp // // atomic_count for GNU libstdc++ v3 // // http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // Copyright (c) 2002 Lars Gullik Bjønnes // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include namespace boost { namespace detail { class atomic_count { public: explicit atomic_count(long v) : value_(v) {} void operator++() { __atomic_add(&value_, 1); } long operator--() { return __exchange_and_add(&value_, -1) - 1; } operator long() const { return __exchange_and_add(&value_, 0); } private: atomic_count(atomic_count const &); atomic_count & operator=(atomic_count const &); mutable _Atomic_word value_; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/none_t.hpp0000644000175000017500000000117011344301501030675 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_DETAIL_NONE_T_17SEP2003_HPP #define BOOST_DETAIL_NONE_T_17SEP2003_HPP namespace boost { namespace detail { struct none_helper{}; typedef int none_helper::*none_t ; } // namespace detail } // namespace boost #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_pthreads.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_pthreads.h0000644000175000017500000000305411344301501031547 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED #define BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lwm_pthreads.hpp // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include namespace boost { namespace detail { class lightweight_mutex { private: pthread_mutex_t m_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex() { // HPUX 10.20 / DCE has a nonstandard pthread_mutex_init #if defined(__hpux) && defined(_DECTHREADS_) pthread_mutex_init(&m_, pthread_mutexattr_default); #else pthread_mutex_init(&m_, 0); #endif } ~lightweight_mutex() { pthread_mutex_destroy(&m_); } class scoped_lock; friend class scoped_lock; class scoped_lock { private: pthread_mutex_t & m_; scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: scoped_lock(lightweight_mutex & m): m_(m.m_) { pthread_mutex_lock(&m_); } ~scoped_lock() { pthread_mutex_unlock(&m_); } }; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_PTHREADS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/limits.hpp0000644000175000017500000004075111344301501030724 0ustar debiandebian/* * Copyright (c) 1997 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ /* NOTE: This is not portable code. Parts of numeric_limits<> are * inherently machine-dependent, and this file is written for the MIPS * architecture and the SGI MIPSpro C++ compiler. Parts of it (in * particular, some of the characteristics of floating-point types) * are almost certainly incorrect for any other platform. */ /* The above comment is almost certainly out of date. This file works * on systems other than SGI MIPSpro C++ now. */ /* * Revision history: * 21 Sep 2001: * Only include if BOOST_NO_CWCHAR is defined. (Darin Adler) * 10 Aug 2001: * Added MIPS (big endian) to the big endian family. (Jens Maurer) * 13 Apr 2001: * Added powerpc to the big endian family. (Jeremy Siek) * 5 Apr 2001: * Added sparc (big endian) processor support (John Maddock). * Initial sub: * Modified by Jens Maurer for gcc 2.95 on x86. */ #ifndef BOOST_SGI_CPP_LIMITS #define BOOST_SGI_CPP_LIMITS #include #include #include #ifndef BOOST_NO_CWCHAR #include // for WCHAR_MIN and WCHAR_MAX #endif // The macros are not named appropriately. We don't care about integer // bit layout, but about floating-point NaN (etc.) bit patterns. #if defined(__sparc) || defined(__sparc__) || defined(__powerpc__) || defined(__ppc__) || defined(__hppa) || defined(_MIPSEB) || defined(_POWER) #define BOOST_BIG_ENDIAN #elif defined(__i386__) || defined(__alpha__) || defined(__ia64) || defined(__ia64__) #define BOOST_LITTLE_ENDIAN #else #error The file boost/detail/limits.hpp needs to be set up for your CPU type. #endif namespace std { enum float_round_style { round_indeterminate = -1, round_toward_zero = 0, round_to_nearest = 1, round_toward_infinity = 2, round_toward_neg_infinity = 3 }; enum float_denorm_style { denorm_indeterminate = -1, denorm_absent = 0, denorm_present = 1 }; // The C++ standard (section 18.2.1) requires that some of the members of // numeric_limits be static const data members that are given constant- // initializers within the class declaration. On compilers where the // BOOST_NO_INCLASS_MEMBER_INITIALIZATION macro is defined, it is impossible to write // a standard-conforming numeric_limits class. // // There are two possible workarounds: either initialize the data // members outside the class, or change them from data members to // enums. Neither workaround is satisfactory: the former makes it // impossible to use the data members in constant-expressions, and the // latter means they have the wrong type and that it is impossible to // take their addresses. We choose the former workaround. #ifdef BOOST_NO_INCLASS_MEMBER_INITIALIZATION # define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \ enum { __mem_name = __mem_value } #else /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */ # define BOOST_STL_DECLARE_LIMITS_MEMBER(__mem_type, __mem_name, __mem_value) \ static const __mem_type __mem_name = __mem_value #endif /* BOOST_NO_INCLASS_MEMBER_INITIALIZATION */ // Base class for all specializations of numeric_limits. template class _Numeric_limits_base { public: BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, false); static __number min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); } static __number max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __number(); } BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, 0); BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, 0); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, false); BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 0); static __number epsilon() throw() { return __number(); } static __number round_error() throw() { return __number(); } BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, 0); BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, 0); BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, 0); BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, 0); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, false); BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style, has_denorm, denorm_absent); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false); static __number infinity() throw() { return __number(); } static __number quiet_NaN() throw() { return __number(); } static __number signaling_NaN() throw() { return __number(); } static __number denorm_min() throw() { return __number(); } BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false); BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, round_toward_zero); }; // Base class for integers. template class _Integer_limits : public _Numeric_limits_base<_Int> { public: BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true); static _Int min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imin; } static _Int max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return __imax; } BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, (__idigits < 0) ? (int)(sizeof(_Int) * CHAR_BIT) - (__imin == 0 ? 0 : 1) : __idigits); BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, (digits * 301) / 1000); // log 2 = 0.301029995664... BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, __imin != 0); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_integer, true); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_exact, true); BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_modulo, true); }; #if defined(BOOST_BIG_ENDIAN) template struct float_helper{ static Number get_word() throw() { // sizeof(long double) == 16 const unsigned int _S_word[4] = { Word, 0, 0, 0 }; return *reinterpret_cast(&_S_word); } }; #else template struct float_helper{ static Number get_word() throw() { // sizeof(long double) == 12, but only 10 bytes significant const unsigned int _S_word[4] = { 0, 0, 0, Word }; return *reinterpret_cast( reinterpret_cast(&_S_word)+16- (sizeof(Number) == 12 ? 10 : sizeof(Number))); } }; #endif // Base class for floating-point numbers. template class _Floating_limits : public _Numeric_limits_base<__number> { public: BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_specialized, true); BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits, __Digits); BOOST_STL_DECLARE_LIMITS_MEMBER(int, digits10, __Digits10); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_signed, true); BOOST_STL_DECLARE_LIMITS_MEMBER(int, radix, 2); BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent, __MinExp); BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent, __MaxExp); BOOST_STL_DECLARE_LIMITS_MEMBER(int, min_exponent10, __MinExp10); BOOST_STL_DECLARE_LIMITS_MEMBER(int, max_exponent10, __MaxExp10); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_infinity, true); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_quiet_NaN, true); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_signaling_NaN, true); BOOST_STL_DECLARE_LIMITS_MEMBER(float_denorm_style, has_denorm, denorm_indeterminate); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, has_denorm_loss, false); static __number infinity() throw() { return float_helper<__number, __InfinityWord>::get_word(); } static __number quiet_NaN() throw() { return float_helper<__number,__QNaNWord>::get_word(); } static __number signaling_NaN() throw() { return float_helper<__number,__SNaNWord>::get_word(); } BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_iec559, __IsIEC559); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, is_bounded, true); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, traps, false /* was: true */ ); BOOST_STL_DECLARE_LIMITS_MEMBER(bool, tinyness_before, false); BOOST_STL_DECLARE_LIMITS_MEMBER(float_round_style, round_style, __RoundStyle); }; // Class numeric_limits // The unspecialized class. template class numeric_limits : public _Numeric_limits_base {}; // Specializations for all built-in integral types. template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; #ifndef BOOST_NO_INTRINSIC_WCHAR_T template<> class numeric_limits #if !defined(WCHAR_MAX) || !defined(WCHAR_MIN) #if defined(_WIN32) || defined(__CYGWIN__) : public _Integer_limits #elif defined(__hppa) // wchar_t has "unsigned int" as the underlying type : public _Integer_limits #else // assume that wchar_t has "int" as the underlying type : public _Integer_limits #endif #else // we have WCHAR_MIN and WCHAR_MAX defined, so use it : public _Integer_limits #endif {}; #endif template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; template<> class numeric_limits : public _Integer_limits {}; #ifdef __GNUC__ // Some compilers have long long, but don't define the // LONGLONG_MIN and LONGLONG_MAX macros in limits.h. This // assumes that long long is 64 bits. #if !defined(LONGLONG_MAX) && !defined(ULONGLONG_MAX) # define ULONGLONG_MAX 0xffffffffffffffffLLU # define LONGLONG_MAX 0x7fffffffffffffffLL #endif #if !defined(LONGLONG_MIN) # define LONGLONG_MIN (-LONGLONG_MAX - 1) #endif #if !defined(ULONGLONG_MIN) # define ULONGLONG_MIN 0 #endif #endif /* __GNUC__ */ // Specializations for all built-in floating-point type. template<> class numeric_limits : public _Floating_limits { public: static float min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MIN; } static float denorm_min() throw() { return FLT_MIN; } static float max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return FLT_MAX; } static float epsilon() throw() { return FLT_EPSILON; } static float round_error() throw() { return 0.5f; } // Units: ulps. }; template<> class numeric_limits : public _Floating_limits { public: static double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MIN; } static double denorm_min() throw() { return DBL_MIN; } static double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return DBL_MAX; } static double epsilon() throw() { return DBL_EPSILON; } static double round_error() throw() { return 0.5; } // Units: ulps. }; template<> class numeric_limits : public _Floating_limits { public: static long double min BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MIN; } static long double denorm_min() throw() { return LDBL_MIN; } static long double max BOOST_PREVENT_MACRO_SUBSTITUTION () throw() { return LDBL_MAX; } static long double epsilon() throw() { return LDBL_EPSILON; } static long double round_error() throw() { return 4; } // Units: ulps. }; } // namespace std #endif /* BOOST_SGI_CPP_LIMITS */ // Local Variables: // mode:C++ // End: ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/ob_compressed_pair.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/ob_compressed_0000644000175000017500000004056711344301501031625 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/utility for most recent version including documentation. // see libs/utility/compressed_pair.hpp // /* Release notes: 20 Jan 2001: Fixed obvious bugs (David Abrahams) 07 Oct 2000: Added better single argument constructor support. 03 Oct 2000: Added VC6 support (JM). 23rd July 2000: Additional comments added. (JM) Jan 2000: Original version: this version crippled for use with crippled compilers - John Maddock Jan 2000. */ #ifndef BOOST_OB_COMPRESSED_PAIR_HPP #define BOOST_OB_COMPRESSED_PAIR_HPP #include #ifndef BOOST_OBJECT_TYPE_TRAITS_HPP #include #endif #ifndef BOOST_SAME_TRAITS_HPP #include #endif #ifndef BOOST_CALL_TRAITS_HPP #include #endif namespace boost { #ifdef BOOST_MSVC6_MEMBER_TEMPLATES // // use member templates to emulate // partial specialisation. Note that due to // problems with overload resolution with VC6 // each of the compressed_pair versions that follow // have one template single-argument constructor // in place of two specific constructors: // template class compressed_pair; namespace detail{ template struct best_conversion_traits { typedef char one; typedef char (&two)[2]; static A a; static one test(T1); static two test(T2); enum { value = sizeof(test(a)) }; }; template struct init_one; template <> struct init_one<1> { template static void init(const A& a, T1* p1, T2*) { *p1 = a; } }; template <> struct init_one<2> { template static void init(const A& a, T1*, T2* p2) { *p2 = a; } }; // T1 != T2, both non-empty template class compressed_pair_0 { private: T1 _first; T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_0() : _first(), _second() {} compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {} template explicit compressed_pair_0(const A& val) { init_one::value>::init(val, &_first, &_second); } compressed_pair_0(const ::boost::compressed_pair& x) : _first(x.first()), _second(x.second()) {} #if 0 compressed_pair_0& operator=(const compressed_pair_0& x) { cout << "assigning compressed pair 0" << endl; _first = x._first; _second = x._second; cout << "finished assigning compressed pair 0" << endl; return *this; } #endif first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair_0& y) { using std::swap; swap(_first, y._first); swap(_second, y._second); } }; // T1 != T2, T2 empty template class compressed_pair_1 : T2 { private: T1 _first; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_1() : T2(), _first() {} compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {} template explicit compressed_pair_1(const A& val) { init_one::value>::init(val, &_first, static_cast(this)); } compressed_pair_1(const ::boost::compressed_pair& x) : T2(x.second()), _first(x.first()) {} #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 // Total weirdness. If the assignment to _first is moved after // the call to the inherited operator=, then this breaks graph/test/graph.cpp // by way of iterator_adaptor. compressed_pair_1& operator=(const compressed_pair_1& x) { _first = x._first; T2::operator=(x); return *this; } #endif first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return *this; } second_const_reference second() const { return *this; } void swap(compressed_pair_1& y) { // no need to swap empty base class: using std::swap; swap(_first, y._first); } }; // T1 != T2, T1 empty template class compressed_pair_2 : T1 { private: T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_2() : T1(), _second() {} compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {} template explicit compressed_pair_2(const A& val) { init_one::value>::init(val, static_cast(this), &_second); } compressed_pair_2(const ::boost::compressed_pair& x) : T1(x.first()), _second(x.second()) {} #if 0 compressed_pair_2& operator=(const compressed_pair_2& x) { cout << "assigning compressed pair 2" << endl; T1::operator=(x); _second = x._second; cout << "finished assigning compressed pair 2" << endl; return *this; } #endif first_reference first() { return *this; } first_const_reference first() const { return *this; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair_2& y) { // no need to swap empty base class: using std::swap; swap(_second, y._second); } }; // T1 != T2, both empty template class compressed_pair_3 : T1, T2 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_3() : T1(), T2() {} compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {} template explicit compressed_pair_3(const A& val) { init_one::value>::init(val, static_cast(this), static_cast(this)); } compressed_pair_3(const ::boost::compressed_pair& x) : T1(x.first()), T2(x.second()) {} first_reference first() { return *this; } first_const_reference first() const { return *this; } second_reference second() { return *this; } second_const_reference second() const { return *this; } void swap(compressed_pair_3& y) { // no need to swap empty base classes: } }; // T1 == T2, and empty template class compressed_pair_4 : T1 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_4() : T1() {} compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {} // only one single argument constructor since T1 == T2 explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {} compressed_pair_4(const ::boost::compressed_pair& x) : T1(x.first()), m_second(x.second()) {} first_reference first() { return *this; } first_const_reference first() const { return *this; } second_reference second() { return m_second; } second_const_reference second() const { return m_second; } void swap(compressed_pair_4& y) { // no need to swap empty base classes: } private: T2 m_second; }; // T1 == T2, not empty template class compressed_pair_5 { private: T1 _first; T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair_5() : _first(), _second() {} compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {} // only one single argument constructor since T1 == T2 explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {} compressed_pair_5(const ::boost::compressed_pair& c) : _first(c.first()), _second(c.second()) {} first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair_5& y) { using std::swap; swap(_first, y._first); swap(_second, y._second); } }; template struct compressed_pair_chooser { template struct rebind { typedef compressed_pair_0 type; }; }; template <> struct compressed_pair_chooser { template struct rebind { typedef compressed_pair_1 type; }; }; template <> struct compressed_pair_chooser { template struct rebind { typedef compressed_pair_2 type; }; }; template <> struct compressed_pair_chooser { template struct rebind { typedef compressed_pair_3 type; }; }; template <> struct compressed_pair_chooser { template struct rebind { typedef compressed_pair_4 type; }; }; template <> struct compressed_pair_chooser { template struct rebind { typedef compressed_pair_5 type; }; }; template struct compressed_pair_traits { private: typedef compressed_pair_chooser::value, is_empty::value, is_same::value> chooser; typedef typename chooser::template rebind bound_type; public: typedef typename bound_type::type type; }; } // namespace detail template class compressed_pair : public detail::compressed_pair_traits::type { private: typedef typename detail::compressed_pair_traits::type base_type; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair() : base_type() {} compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {} template explicit compressed_pair(const A& x) : base_type(x){} first_reference first() { return base_type::first(); } first_const_reference first() const { return base_type::first(); } second_reference second() { return base_type::second(); } second_const_reference second() const { return base_type::second(); } }; template inline void swap(compressed_pair& x, compressed_pair& y) { x.swap(y); } #else // no partial specialisation, no member templates: template class compressed_pair { private: T1 _first; T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits::param_type first_param_type; typedef typename call_traits::param_type second_param_type; typedef typename call_traits::reference first_reference; typedef typename call_traits::reference second_reference; typedef typename call_traits::const_reference first_const_reference; typedef typename call_traits::const_reference second_const_reference; compressed_pair() : _first(), _second() {} compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {} explicit compressed_pair(first_param_type x) : _first(x), _second() {} // can't define this in case T1 == T2: // explicit compressed_pair(second_param_type y) : _first(), _second(y) {} first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair& y) { using std::swap; swap(_first, y._first); swap(_second, y._second); } }; template inline void swap(compressed_pair& x, compressed_pair& y) { x.swap(y); } #endif } // boost #endif // BOOST_OB_COMPRESSED_PAIR_HPP ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_linux.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/atomic_count_l0000644000175000017500000000266011344301501031631 0ustar debiandebian#ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED #define BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED // // boost/detail/atomic_count_linux.hpp // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // // This implementation uses . This is a kernel header; // using kernel headers in a user program may cause a number of problems, // and not all flavors of Linux provide the atomic instructions. // // This file is only provided because the performance of this implementation // is significantly higher than the pthreads version. Use at your own risk // (by defining BOOST_USE_ASM_ATOMIC_H.) // #include namespace boost { namespace detail { class atomic_count { public: explicit atomic_count(long v) { atomic_t init = ATOMIC_INIT(v); value_ = init; } void operator++() { atomic_inc(&value_); } long operator--() { return !atomic_dec_and_test(&value_); } operator long() const { return atomic_read(&value_); } private: atomic_count(atomic_count const &); atomic_count & operator=(atomic_count const &); atomic_t value_; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_LINUX_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_win32.hpp0000644000175000017500000000525011344301501031237 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED #define BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lwm_win32.hpp // // Copyright (c) 2002, 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifdef BOOST_USE_WINDOWS_H # include #endif #ifdef __BORLANDC__ # pragma warn -8027 // Functions containing while are not expanded inline #endif namespace boost { namespace detail { #ifndef BOOST_USE_WINDOWS_H #ifdef _WIN64 // Intel 6.0 on Win64 version, posted by Tim Fenders to [boost-users] extern "C" long_type __cdecl _InterlockedExchange(long volatile *, long); #pragma intrinsic(_InterlockedExchange) inline long InterlockedExchange(long volatile* lp, long l) { return _InterlockedExchange(lp, l); } #else // _WIN64 extern "C" __declspec(dllimport) long __stdcall InterlockedExchange(long volatile *, long); #endif // _WIN64 extern "C" __declspec(dllimport) void __stdcall Sleep(unsigned long); #endif // #ifndef BOOST_USE_WINDOWS_H class lightweight_mutex { private: long l_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex(): l_(0) { } class scoped_lock; friend class scoped_lock; class scoped_lock { private: lightweight_mutex & m_; scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: explicit scoped_lock(lightweight_mutex & m): m_(m) { while( InterlockedExchange(&m_.l_, 1) ) { // Note: changed to Sleep(1) from Sleep(0). // According to MSDN, Sleep(0) will never yield // to a lower-priority thread, whereas Sleep(1) // will. Performance seems not to be affected. Sleep(1); } } ~scoped_lock() { InterlockedExchange(&m_.l_, 0); // Note: adding a yield here will make // the spinlock more fair and will increase the overall // performance of some applications substantially in // high contention situations, but will penalize the // low contention / single thread case up to 5x } }; }; } // namespace detail } // namespace boost #ifdef __BORLANDC__ # pragma warn .8027 // Functions containing while are not expanded inline #endif #endif // #ifndef BOOST_DETAIL_LWM_WIN32_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/workaround.hpp0000644000175000017500000000522211344301501031610 0ustar debiandebian// Copyright David Abrahams 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef WORKAROUND_DWA2002126_HPP # define WORKAROUND_DWA2002126_HPP // Compiler/library version workaround macro // // Usage: // // #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) // ... // workaround code here // #endif // // When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the // first argument must be undefined or expand to a numeric // value. The above expands to: // // (BOOST_MSVC) != 0 && (BOOST_MSVC) <= 1200 // // When used for workarounds that apply to the latest known version // and all earlier versions of a compiler, the following convention // should be observed: // // #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301)) // // The version number in this case corresponds to the last version in // which the workaround was known to have been required. When // BOOST_DETECT_OUTDATED_WORKAROUNDS is not the defined, the macro // BOOST_TESTED_AT(x) expands to "!= 0", which effectively activates // the workaround for any version of the compiler. When // BOOST_DETECT_OUTDATED_WORKAROUNDS is defined, a compiler warning or // error will be issued if the compiler version exceeds the argument // to BOOST_TESTED_AT(). This can be used to locate workarounds which // may be obsoleted by newer versions. # ifndef BOOST_STRICT_CONFIG # define BOOST_WORKAROUND(symbol, test) \ ((symbol != 0) && (1 % (( (symbol test) ) + 1))) // ^ ^ ^ ^ // The extra level of parenthesis nesting above, along with the // BOOST_OPEN_PAREN indirection below, is required to satisfy the // broken preprocessor in MWCW 8.3 and earlier. // // The basic mechanism works as follows: // (symbol test) + 1 => if (symbol test) then 2 else 1 // 1 % ((symbol test) + 1) => if (symbol test) then 1 else 0 // // The complication with % is for cooperation with BOOST_TESTED_AT(). // When "test" is BOOST_TESTED_AT(x) and // BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined, // // symbol test => if (symbol <= x) then 1 else -1 // (symbol test) + 1 => if (symbol <= x) then 2 else 0 // 1 % ((symbol test) + 1) => if (symbol <= x) then 1 else divide-by-zero // # ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS # define BOOST_OPEN_PAREN ( # define BOOST_TESTED_AT(value) > value) ?(-1): BOOST_OPEN_PAREN 1 # else # define BOOST_TESTED_AT(value) != ((value)-(value)) # endif # else # define BOOST_WORKAROUND(symbol, test) 0 # endif #endif // WORKAROUND_DWA2002126_HPP ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/is_incrementable.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/is_incrementab0000644000175000017500000000460411344301501031614 0ustar debiandebian// Copyright David Abrahams 2004. Use, modification and distribution is // subject to the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef IS_INCREMENTABLE_DWA200415_HPP # define IS_INCREMENTABLE_DWA200415_HPP # include # include # include namespace boost { namespace detail { // is_incrementable metafunction // // Requires: Given x of type T&, if the expression ++x is well-formed // it must have complete type; otherwise, it must neither be ambiguous // nor violate access. // This namespace ensures that ADL doesn't mess things up. namespace is_incrementable_ { // a type returned from operator++ when no increment is found in the // type's own namespace struct tag {}; // any soaks up implicit conversions and makes the following // operator++ less-preferred than any other such operator that // might be found via ADL. struct any { template any(T const&); }; // This is a last-resort operator++ for when none other is found tag operator++(any const&); tag operator++(any const&,int); # if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # define BOOST_comma(a,b) (a) # else // In case an operator++ is found that returns void, we'll use ++x,0 tag operator,(tag,int); # define BOOST_comma(a,b) (a,b) # endif // two check overloads help us identify which operator++ was picked char (& check(tag) )[2]; template char check(T const&); template struct impl { static typename remove_cv::type& x; BOOST_STATIC_CONSTANT( bool , value = sizeof(is_incrementable_::check(BOOST_comma(++x,0))) == 1 ); }; template struct postfix_impl { static typename remove_cv::type& x; BOOST_STATIC_CONSTANT( bool , value = sizeof(is_incrementable_::check(BOOST_comma(x++,0))) == 1 ); }; } # undef BOOST_comma template struct is_incrementable : mpl::bool_< ::boost::detail::is_incrementable_::impl::value> { }; template struct is_postfix_incrementable : mpl::bool_< ::boost::detail::is_incrementable_::postfix_impl::value> { }; }} // namespace boost::detail #endif // IS_INCREMENTABLE_DWA200415_HPP ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/shared_count.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/shared_count.h0000644000175000017500000002775711344301501031554 0ustar debiandebian#ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED #define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // detail/shared_count.hpp // // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include #if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR) # error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible. #endif #include #include #include #if defined(BOOST_SP_USE_QUICK_ALLOCATOR) #include #endif #include // std::auto_ptr, std::allocator #include // std::less #include // std::exception #include // std::bad_alloc #include // std::type_info in get_deleter #include // std::size_t #ifdef __BORLANDC__ # pragma warn -8026 // Functions with excep. spec. are not expanded inline # pragma warn -8027 // Functions containing try are not expanded inline #endif namespace boost { // Debug hooks #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn); void sp_array_constructor_hook(void * px); void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn); void sp_array_destructor_hook(void * px); #endif // The standard library that comes with Borland C++ 5.5.1 // defines std::exception and its members as having C calling // convention (-pc). When the definition of bad_weak_ptr // is compiled with -ps, the compiler issues an error. // Hence, the temporary #pragma option -pc below. The version // check is deliberately conservative. #if defined(__BORLANDC__) && __BORLANDC__ == 0x551 # pragma option push -pc #endif class bad_weak_ptr: public std::exception { public: virtual char const * what() const throw() { return "boost::bad_weak_ptr"; } }; #if defined(__BORLANDC__) && __BORLANDC__ == 0x551 # pragma option pop #endif namespace detail { class sp_counted_base { private: typedef detail::lightweight_mutex mutex_type; public: sp_counted_base(): use_count_(1), weak_count_(1) { } virtual ~sp_counted_base() // nothrow { } // dispose() is called when use_count_ drops to zero, to release // the resources managed by *this. virtual void dispose() = 0; // nothrow // destruct() is called when weak_count_ drops to zero. virtual void destruct() // nothrow { delete this; } virtual void * get_deleter(std::type_info const & ti) = 0; void add_ref_copy() { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif ++use_count_; } void add_ref_lock() { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif if(use_count_ == 0) boost::throw_exception(boost::bad_weak_ptr()); ++use_count_; } void release() // nothrow { { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif long new_use_count = --use_count_; if(new_use_count != 0) return; } dispose(); weak_release(); } void weak_add_ref() // nothrow { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif ++weak_count_; } void weak_release() // nothrow { long new_weak_count; { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif new_weak_count = --weak_count_; } if(new_weak_count == 0) { destruct(); } } long use_count() const // nothrow { #if defined(BOOST_HAS_THREADS) mutex_type::scoped_lock lock(mtx_); #endif return use_count_; } private: sp_counted_base(sp_counted_base const &); sp_counted_base & operator= (sp_counted_base const &); long use_count_; // #shared long weak_count_; // #weak + (#shared != 0) #if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32) mutable mutex_type mtx_; #endif }; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) template void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter const &, int) { boost::sp_scalar_constructor_hook(px, sizeof(T), pn); } template void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter const &, int) { boost::sp_array_constructor_hook(px); } template void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long) { } template void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter const &, int) { boost::sp_scalar_destructor_hook(px, sizeof(T), pn); } template void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter const &, int) { boost::sp_array_destructor_hook(px); } template void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long) { } #endif // // Borland's Codeguard trips up over the -Vx- option here: // #ifdef __CODEGUARD__ # pragma option push -Vx- #endif template class sp_counted_base_impl: public sp_counted_base { private: P ptr; // copy constructor must not throw D del; // copy constructor must not throw sp_counted_base_impl(sp_counted_base_impl const &); sp_counted_base_impl & operator= (sp_counted_base_impl const &); typedef sp_counted_base_impl this_type; public: // pre: initial_use_count <= initial_weak_count, d(p) must not throw sp_counted_base_impl(P p, D d): ptr(p), del(d) { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) detail::cbi_call_constructor_hook(this, p, d, 0); #endif } virtual void dispose() // nothrow { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) detail::cbi_call_destructor_hook(this, ptr, del, 0); #endif del(ptr); } virtual void * get_deleter(std::type_info const & ti) { return ti == typeid(D)? &del: 0; } #if defined(BOOST_SP_USE_STD_ALLOCATOR) void * operator new(std::size_t) { return std::allocator().allocate(1, static_cast(0)); } void operator delete(void * p) { std::allocator().deallocate(static_cast(p), 1); } #endif #if defined(BOOST_SP_USE_QUICK_ALLOCATOR) void * operator new(std::size_t) { return quick_allocator::alloc(); } void operator delete(void * p) { quick_allocator::dealloc(p); } #endif }; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) int const shared_count_id = 0x2C35F101; int const weak_count_id = 0x298C38A4; #endif class weak_count; class shared_count { private: sp_counted_base * pi_; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) int id_; #endif friend class weak_count; public: shared_count(): pi_(0) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { } template shared_count(P p, D d): pi_(0) #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { #ifndef BOOST_NO_EXCEPTIONS try { pi_ = new sp_counted_base_impl(p, d); } catch(...) { d(p); // delete p throw; } #else pi_ = new sp_counted_base_impl(p, d); if(pi_ == 0) { d(p); // delete p boost::throw_exception(std::bad_alloc()); } #endif } #ifndef BOOST_NO_AUTO_PTR // auto_ptr is special cased to provide the strong guarantee template explicit shared_count(std::auto_ptr & r): pi_(new sp_counted_base_impl< Y *, checked_deleter >(r.get(), checked_deleter())) #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { r.release(); } #endif ~shared_count() // nothrow { if(pi_ != 0) pi_->release(); #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) id_ = 0; #endif } shared_count(shared_count const & r): pi_(r.pi_) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) pi_->add_ref_copy(); } explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0 shared_count & operator= (shared_count const & r) // nothrow { sp_counted_base * tmp = r.pi_; if(tmp != pi_) { if(tmp != 0) tmp->add_ref_copy(); if(pi_ != 0) pi_->release(); pi_ = tmp; } return *this; } void swap(shared_count & r) // nothrow { sp_counted_base * tmp = r.pi_; r.pi_ = pi_; pi_ = tmp; } long use_count() const // nothrow { return pi_ != 0? pi_->use_count(): 0; } bool unique() const // nothrow { return use_count() == 1; } friend inline bool operator==(shared_count const & a, shared_count const & b) { return a.pi_ == b.pi_; } friend inline bool operator<(shared_count const & a, shared_count const & b) { return std::less()(a.pi_, b.pi_); } void * get_deleter(std::type_info const & ti) const { return pi_? pi_->get_deleter(ti): 0; } }; #ifdef __CODEGUARD__ # pragma option pop #endif class weak_count { private: sp_counted_base * pi_; #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) int id_; #endif friend class shared_count; public: weak_count(): pi_(0) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(weak_count_id) #endif { } weak_count(shared_count const & r): pi_(r.pi_) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) pi_->weak_add_ref(); } weak_count(weak_count const & r): pi_(r.pi_) // nothrow #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) pi_->weak_add_ref(); } ~weak_count() // nothrow { if(pi_ != 0) pi_->weak_release(); #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) id_ = 0; #endif } weak_count & operator= (shared_count const & r) // nothrow { sp_counted_base * tmp = r.pi_; if(tmp != 0) tmp->weak_add_ref(); if(pi_ != 0) pi_->weak_release(); pi_ = tmp; return *this; } weak_count & operator= (weak_count const & r) // nothrow { sp_counted_base * tmp = r.pi_; if(tmp != 0) tmp->weak_add_ref(); if(pi_ != 0) pi_->weak_release(); pi_ = tmp; return *this; } void swap(weak_count & r) // nothrow { sp_counted_base * tmp = r.pi_; r.pi_ = pi_; pi_ = tmp; } long use_count() const // nothrow { return pi_ != 0? pi_->use_count(): 0; } friend inline bool operator==(weak_count const & a, weak_count const & b) { return a.pi_ == b.pi_; } friend inline bool operator<(weak_count const & a, weak_count const & b) { return std::less()(a.pi_, b.pi_); } }; inline shared_count::shared_count(weak_count const & r): pi_(r.pi_) #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) , id_(shared_count_id) #endif { if(pi_ != 0) { pi_->add_ref_lock(); } else { boost::throw_exception(boost::bad_weak_ptr()); } } } // namespace detail } // namespace boost #ifdef __BORLANDC__ # pragma warn .8027 // Functions containing try are not expanded inline # pragma warn .8026 // Functions with excep. spec. are not expanded inline #endif #endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/dynamic_bitset.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/dynamic_bitset0000644000175000017500000001156311344301501031632 0ustar debiandebian// -------------------------------------------------- // // (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002. // (C) Copyright Gennaro Prota 2003 - 2004. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // ----------------------------------------------------------- // See http://www.boost.org/libs/dynamic_bitset for documentation. #ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP #define BOOST_DETAIL_DYNAMIC_BITSET_HPP #include // for std::size_t #include "boost/config.hpp" #include "boost/detail/workaround.hpp" //#include "boost/static_assert.hpp" // gps namespace boost { namespace detail { // Gives (read-)access to the object representation // of an object of type T (3.9p4). CANNOT be used // on a base sub-object // template inline const unsigned char * object_representation (T* p) { return static_cast(static_cast(p)); } // ------- count function implementation -------------- namespace dynamic_bitset_count_impl { typedef unsigned char byte_type; enum mode { access_by_bytes, access_by_blocks }; template struct mode_to_type {}; // the table: wrapped in a class template, so // that it is only instantiated if/when needed // template struct count_table { static const byte_type table[]; }; template <> struct count_table { /* no table */ }; const unsigned int table_width = 8; template const byte_type count_table::table[] = { // Automatically generated by GPTableGen.exe v.1.0 // 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8 }; // overload for access by bytes // template inline std::size_t do_count(Iterator first, std::size_t length, int /*dummy param*/, mode_to_type* ) { std::size_t num = 0; if (length) { const byte_type * p = object_representation(&*first); length *= sizeof(*first); do { num += count_table<>::table[*p]; ++p; --length; } while (length); } return num; } // overload for access by blocks // template inline std::size_t do_count(Iterator first, std::size_t length, ValueType, mode_to_type*) { std::size_t num = 0; while (length){ ValueType value = *first; while (value) { num += count_table<>::table[value & ((1u<>= table_width; } ++first; --length; } return num; } } // dynamic_bitset_count_impl // ------------------------------------------------------- // Some library implementations simply return a dummy // value such as // // size_type(-1) / sizeof(T) // // from vector<>::max_size. This tries to get out more // meaningful info. // template typename T::size_type vector_max_size_workaround(const T & v) { typedef typename T::allocator_type allocator_type; const typename allocator_type::size_type alloc_max = v.get_allocator().max_size(); const typename T::size_type container_max = v.max_size(); return alloc_max < container_max? alloc_max : container_max; } // for static_asserts template struct dynamic_bitset_allowed_block_type { enum { value = T(-1) > 0 }; // ensure T has no sign }; template <> struct dynamic_bitset_allowed_block_type { enum { value = false }; }; } // namespace detail } // namespace boost #endif // include guard ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/call_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/call_traits.hp0000644000175000017500000000733711344301501031547 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/utility for most recent version including documentation. // call_traits: defines typedefs for function usage // (see libs/utility/call_traits.htm) /* Release notes: 23rd July 2000: Fixed array specialization. (JM) Added Borland specific fixes for reference types (issue raised by Steve Cleary). */ #ifndef BOOST_DETAIL_CALL_TRAITS_HPP #define BOOST_DETAIL_CALL_TRAITS_HPP #ifndef BOOST_CONFIG_HPP #include #endif #include #include #include namespace boost{ namespace detail{ template struct ct_imp2 { typedef const T& param_type; }; template struct ct_imp2 { typedef const T param_type; }; template struct ct_imp { typedef const T& param_type; }; template struct ct_imp { typedef typename ct_imp2::param_type param_type; }; template struct ct_imp { typedef T const param_type; }; } template struct call_traits { public: typedef T value_type; typedef T& reference; typedef const T& const_reference; // // C++ Builder workaround: we should be able to define a compile time // constant and pass that as a single template parameter to ct_imp, // however compiler bugs prevent this - instead pass three bool's to // ct_imp and add an extra partial specialisation // of ct_imp to handle the logic. (JM) typedef typename detail::ct_imp< T, ::boost::is_pointer::value, ::boost::is_arithmetic::value >::param_type param_type; }; template struct call_traits { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x560) // these are illegal specialisations; cv-qualifies applied to // references have no effect according to [8.3.2p1], // C++ Builder requires them though as it treats cv-qualified // references as distinct types... template struct call_traits { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; template struct call_traits { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; template struct call_traits { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; #endif #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template struct call_traits { private: typedef T array_type[N]; public: // degrades array to pointer: typedef const T* value_type; typedef array_type& reference; typedef const array_type& const_reference; typedef const T* const param_type; }; template struct call_traits { private: typedef const T array_type[N]; public: // degrades array to pointer: typedef const T* value_type; typedef array_type& reference; typedef const array_type& const_reference; typedef const T* const param_type; }; #endif } #endif // BOOST_DETAIL_CALL_TRAITS_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_nop.hpp0000644000175000017500000000124011344301501031064 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED #define BOOST_DETAIL_LWM_NOP_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lwm_nop.hpp // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // namespace boost { namespace detail { class lightweight_mutex { public: typedef lightweight_mutex scoped_lock; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_NOP_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_gcc.hpp0000644000175000017500000000271311344301501031032 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED #define BOOST_DETAIL_LWM_GCC_HPP_INCLUDED // // boost/detail/lwm_gcc.hpp // // lightweight_mutex for GNU libstdc++ v3 // // http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // Copyright (c) 2002 Lars Gullik Bjønnes // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include #include namespace boost { namespace detail { class lightweight_mutex { private: _Atomic_word a_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex(): a_(0) { } class scoped_lock; friend class scoped_lock; class scoped_lock { private: lightweight_mutex & m_; scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: explicit scoped_lock(lightweight_mutex & m): m_(m) { while( __exchange_and_add(&m_.a_, 1) ) { __atomic_add(&m_.a_, -1); sched_yield(); } } ~scoped_lock() { __atomic_add(&m_.a_, -1); } }; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_GCC_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/binary_search.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/binary_search.0000644000175000017500000001432611344301501031523 0ustar debiandebian// Copyright (c) 2000 David Abrahams. // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Copyright (c) 1994 // Hewlett-Packard Company // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Hewlett-Packard Company makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // // Copyright (c) 1996 // Silicon Graphics Computer Systems, Inc. // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Silicon Graphics makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // #ifndef BINARY_SEARCH_DWA_122600_H_ # define BINARY_SEARCH_DWA_122600_H_ # include # include namespace boost { namespace detail { template ForwardIter lower_bound(ForwardIter first, ForwardIter last, const Tp& val) { typedef detail::iterator_traits traits; typename traits::difference_type len = boost::detail::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (*middle < val) { first = middle; ++first; len = len - half - 1; } else len = half; } return first; } template ForwardIter lower_bound(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef detail::iterator_traits traits; typename traits::difference_type len = boost::detail::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(*middle, val)) { first = middle; ++first; len = len - half - 1; } else len = half; } return first; } template ForwardIter upper_bound(ForwardIter first, ForwardIter last, const Tp& val) { typedef detail::iterator_traits traits; typename traits::difference_type len = boost::detail::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (val < *middle) len = half; else { first = middle; ++first; len = len - half - 1; } } return first; } template ForwardIter upper_bound(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef detail::iterator_traits traits; typename traits::difference_type len = boost::detail::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(val, *middle)) len = half; else { first = middle; ++first; len = len - half - 1; } } return first; } template std::pair equal_range(ForwardIter first, ForwardIter last, const Tp& val) { typedef detail::iterator_traits traits; typename traits::difference_type len = boost::detail::distance(first, last); typename traits::difference_type half; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (*middle < val) { first = middle; ++first; len = len - half - 1; } else if (val < *middle) len = half; else { left = boost::detail::lower_bound(first, middle, val); std::advance(first, len); right = boost::detail::upper_bound(++middle, first, val); return std::pair(left, right); } } return std::pair(first, first); } template std::pair equal_range(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef detail::iterator_traits traits; typename traits::difference_type len = boost::detail::distance(first, last); typename traits::difference_type half; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(*middle, val)) { first = middle; ++first; len = len - half - 1; } else if (comp(val, *middle)) len = half; else { left = boost::detail::lower_bound(first, middle, val, comp); std::advance(first, len); right = boost::detail::upper_bound(++middle, first, val, comp); return std::pair(left, right); } } return std::pair(first, first); } template bool binary_search(ForwardIter first, ForwardIter last, const Tp& val) { ForwardIter i = boost::detail::lower_bound(first, last, val); return i != last && !(val < *i); } template bool binary_search(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { ForwardIter i = boost::detail::lower_bound(first, last, val, comp); return i != last && !comp(val, *i); } }} // namespace boost::detail #endif // BINARY_SEARCH_DWA_122600_H_ ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/quick_allocator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/quick_allocato0000644000175000017500000001124111344301501031617 0ustar debiandebian#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED #define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // detail/quick_allocator.hpp // // Copyright (c) 2003 David Abrahams // Copyright (c) 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #include #include #include #include #include // ::operator new, ::operator delete #include // std::size_t namespace boost { namespace detail { template union freeblock { typedef typename boost::type_with_alignment::type aligner_type; aligner_type aligner; char bytes[size]; freeblock * next; }; template struct allocator_impl { typedef freeblock block; // It may seem odd to use such small pages. // // However, on a typical Windows implementation that uses // the OS allocator, "normal size" pages interact with the // "ordinary" operator new, slowing it down dramatically. // // 512 byte pages are handled by the small object allocator, // and don't interfere with ::new. // // The other alternative is to use much bigger pages (1M.) // // It is surprisingly easy to hit pathological behavior by // varying the page size. g++ 2.96 on Red Hat Linux 7.2, // for example, passionately dislikes 496. 512 seems OK. #if defined(BOOST_QA_PAGE_SIZE) enum { items_per_page = BOOST_QA_PAGE_SIZE / size }; #else enum { items_per_page = 512 / size }; // 1048560 / size #endif #ifdef BOOST_HAS_THREADS static lightweight_mutex mutex; #endif static block * free; static block * page; static unsigned last; static inline void * alloc() { #ifdef BOOST_HAS_THREADS lightweight_mutex::scoped_lock lock(mutex); #endif if(block * x = free) { free = x->next; return x; } else { if(last == items_per_page) { // "Listen to me carefully: there is no memory leak" // -- Scott Meyers, Eff C++ 2nd Ed Item 10 page = ::new block[items_per_page]; last = 0; } return &page[last++]; } } static inline void * alloc(std::size_t n) { if(n != size) // class-specific new called for a derived object { return ::operator new(n); } else { #ifdef BOOST_HAS_THREADS lightweight_mutex::scoped_lock lock(mutex); #endif if(block * x = free) { free = x->next; return x; } else { if(last == items_per_page) { page = ::new block[items_per_page]; last = 0; } return &page[last++]; } } } static inline void dealloc(void * pv) { if(pv != 0) // 18.4.1.1/13 { #ifdef BOOST_HAS_THREADS lightweight_mutex::scoped_lock lock(mutex); #endif block * pb = static_cast(pv); pb->next = free; free = pb; } } static inline void dealloc(void * pv, std::size_t n) { if(n != size) // class-specific delete called for a derived object { ::operator delete(pv); } else if(pv != 0) // 18.4.1.1/13 { #ifdef BOOST_HAS_THREADS lightweight_mutex::scoped_lock lock(mutex); #endif block * pb = static_cast(pv); pb->next = free; free = pb; } } }; #ifdef BOOST_HAS_THREADS template lightweight_mutex allocator_impl::mutex; #endif template freeblock * allocator_impl::free = 0; template freeblock * allocator_impl::page = 0; template unsigned allocator_impl::last = allocator_impl::items_per_page; template struct quick_allocator: public allocator_impl< sizeof(T), boost::alignment_of::value > { }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/ob_call_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/ob_call_traits0000644000175000017500000000740611344301501031616 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/utility for most recent version including documentation. // // Crippled version for crippled compilers: // see libs/utility/call_traits.htm // /* Release notes: 01st October 2000: Fixed call_traits on VC6, using "poor man's partial specialisation", using ideas taken from "Generative programming" by Krzysztof Czarnecki & Ulrich Eisenecker. */ #ifndef BOOST_OB_CALL_TRAITS_HPP #define BOOST_OB_CALL_TRAITS_HPP #ifndef BOOST_CONFIG_HPP #include #endif #ifndef BOOST_ARITHMETIC_TYPE_TRAITS_HPP #include #endif #ifndef BOOST_COMPOSITE_TYPE_TRAITS_HPP #include #endif namespace boost{ #ifdef BOOST_MSVC6_MEMBER_TEMPLATES // // use member templates to emulate // partial specialisation: // namespace detail{ template struct standard_call_traits { typedef T value_type; typedef T& reference; typedef const T& const_reference; typedef const T& param_type; }; template struct simple_call_traits { typedef T value_type; typedef T& reference; typedef const T& const_reference; typedef const T param_type; }; template struct reference_call_traits { typedef T value_type; typedef T reference; typedef T const_reference; typedef T param_type; }; template struct call_traits_chooser { template struct rebind { typedef standard_call_traits type; }; }; template <> struct call_traits_chooser { template struct rebind { typedef simple_call_traits type; }; }; template <> struct call_traits_chooser { template struct rebind { typedef reference_call_traits type; }; }; template struct call_traits_sizeof_chooser2 { template struct small_rebind { typedef simple_call_traits small_type; }; }; template<> struct call_traits_sizeof_chooser2 { template struct small_rebind { typedef standard_call_traits small_type; }; }; template <> struct call_traits_chooser { template struct rebind { enum { sizeof_choice = (sizeof(T) <= sizeof(void*)) }; typedef call_traits_sizeof_chooser2<(sizeof(T) <= sizeof(void*))> chooser; typedef typename chooser::template small_rebind bound_type; typedef typename bound_type::small_type type; }; }; } // namespace detail template struct call_traits { private: typedef detail::call_traits_chooser< ::boost::is_pointer::value, ::boost::is_arithmetic::value, ::boost::is_reference::value > chooser; typedef typename chooser::template rebind bound_type; typedef typename bound_type::type call_traits_type; public: typedef typename call_traits_type::value_type value_type; typedef typename call_traits_type::reference reference; typedef typename call_traits_type::const_reference const_reference; typedef typename call_traits_type::param_type param_type; }; #else // // sorry call_traits is completely non-functional // blame your broken compiler: // template struct call_traits { typedef T value_type; typedef T& reference; typedef const T& const_reference; typedef const T& param_type; }; #endif // member templates } #endif // BOOST_OB_CALL_TRAITS_HPP ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lightweight_test.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lightweight_te0000644000175000017500000000354011344301501031637 0ustar debiandebian#ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED #define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lightweight_test.hpp - lightweight test library // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // BOOST_TEST(expression) // BOOST_ERROR(message) // // int boost::report_errors() // #include #include namespace boost { namespace detail { inline int & test_errors() { static int x = 0; return x; } inline void test_failed_impl(char const * expr, char const * file, int line, char const * function) { std::cerr << file << "(" << line << "): test '" << expr << "' failed in function '" << function << "'" << std::endl; ++test_errors(); } inline void error_impl(char const * msg, char const * file, int line, char const * function) { std::cerr << file << "(" << line << "): " << msg << " in function '" << function << "'" << std::endl; ++test_errors(); } } // namespace detail inline int report_errors() { int errors = detail::test_errors(); if(errors == 0) { std::cerr << "No errors detected." << std::endl; return 0; } else { std::cerr << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl; return 1; } } } // namespace boost #define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)) #define BOOST_ERROR(msg) ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/select_type.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/select_type.hp0000644000175000017500000000215211344301501031554 0ustar debiandebian// (C) Copyright David Abrahams 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org for most recent version including documentation. // Revision History // 09 Feb 01 Applied John Maddock's Borland patch Moving // specialization to unspecialized template (David Abrahams) // 06 Feb 01 Created (David Abrahams) #ifndef SELECT_TYPE_DWA20010206_HPP # define SELECT_TYPE_DWA20010206_HPP namespace boost { namespace detail { // Template class if_true -- select among 2 types based on a bool constant expression // Usage: // typename if_true<(bool_const_expression)>::template then::type // HP aCC cannot deal with missing names for template value parameters template struct if_true { template struct then { typedef T type; }; }; template <> struct if_true { template struct then { typedef F type; }; }; }} #endif // SELECT_TYPE_DWA20010206_HPP ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_win32_nt.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lwm_win32_nt.h0000644000175000017500000000214411344301501031377 0ustar debiandebian#ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED #define BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lwm_win32_nt.hpp // // Copyright (c) 2002, 2003 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // "No threads" version of lwm_win32.hpp; binary compatible but no-op. // namespace boost { namespace detail { class lightweight_mutex { private: long l_; lightweight_mutex(lightweight_mutex const &); lightweight_mutex & operator=(lightweight_mutex const &); public: lightweight_mutex(): l_(0) { } class scoped_lock; friend class scoped_lock; class scoped_lock { private: scoped_lock(scoped_lock const &); scoped_lock & operator=(scoped_lock const &); public: explicit scoped_lock(lightweight_mutex &) { } }; }; } // namespace detail } // namespace boost #endif // #ifndef BOOST_DETAIL_LWM_WIN32_NT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/catch_exceptions.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/catch_exceptio0000644000175000017500000001321011344301501031605 0ustar debiandebian// boost/catch_exceptions.hpp -----------------------------------------------// // Copyright Beman Dawes 1995-2001. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/test for documentation. // Revision History // 13 Jun 01 report_exception() made inline. (John Maddock, Jesse Jones) // 26 Feb 01 Numerous changes suggested during formal review. (Beman) // 25 Jan 01 catch_exceptions.hpp code factored out of cpp_main.cpp. // 22 Jan 01 Remove test_tools dependencies to reduce coupling. // 5 Nov 00 Initial boost version (Beman Dawes) #ifndef BOOST_CATCH_EXCEPTIONS_HPP #define BOOST_CATCH_EXCEPTIONS_HPP // header dependencies are deliberately restricted to the standard library // to reduce coupling to other boost libraries. #include // for string #include // for bad_alloc #include // for bad_cast, bad_typeid #include // for exception, bad_exception #include // for std exception hierarchy #include // for exit codes # if __GNUC__ != 2 || __GNUC_MINOR__ > 96 # include // for ostream # else # include // workaround GNU missing ostream header # endif # if defined(__BORLANDC__) && (__BORLANDC__ <= 0x0551) # define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT # endif #if defined(MPW_CPLUS) && (MPW_CPLUS <= 0x890) # define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT namespace std { class bad_typeid { }; } # endif namespace boost { namespace detail { // A separate reporting function was requested during formal review. inline void report_exception( std::ostream & os, const char * name, const char * info ) { os << "\n** uncaught exception: " << name << " " << info << std::endl; } } // catch_exceptions ------------------------------------------------------// template< class Generator > // Generator is function object returning int int catch_exceptions( Generator function_object, std::ostream & out, std::ostream & err ) { int result = 0; // quiet compiler warnings bool exception_thrown = true; // avoid setting result for each excptn type #ifndef BOOST_NO_EXCEPTIONS try { #endif result = function_object(); exception_thrown = false; #ifndef BOOST_NO_EXCEPTIONS } // As a result of hard experience with strangely interleaved output // under some compilers, there is a lot of use of endl in the code below // where a simple '\n' might appear to do. // The rules for catch & arguments are a bit different from function // arguments (ISO 15.3 paragraphs 18 & 19). Apparently const isn't // required, but it doesn't hurt and some programmers ask for it. catch ( const char * ex ) { detail::report_exception( out, "", ex ); } catch ( const std::string & ex ) { detail::report_exception( out, "", ex.c_str() ); } // std:: exceptions catch ( const std::bad_alloc & ex ) { detail::report_exception( out, "std::bad_alloc:", ex.what() ); } # ifndef BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT catch ( const std::bad_cast & ex ) { detail::report_exception( out, "std::bad_cast:", ex.what() ); } catch ( const std::bad_typeid & ex ) { detail::report_exception( out, "std::bad_typeid:", ex.what() ); } # else catch ( const std::bad_cast & ) { detail::report_exception( out, "std::bad_cast", "" ); } catch ( const std::bad_typeid & ) { detail::report_exception( out, "std::bad_typeid", "" ); } # endif catch ( const std::bad_exception & ex ) { detail::report_exception( out, "std::bad_exception:", ex.what() ); } catch ( const std::domain_error & ex ) { detail::report_exception( out, "std::domain_error:", ex.what() ); } catch ( const std::invalid_argument & ex ) { detail::report_exception( out, "std::invalid_argument:", ex.what() ); } catch ( const std::length_error & ex ) { detail::report_exception( out, "std::length_error:", ex.what() ); } catch ( const std::out_of_range & ex ) { detail::report_exception( out, "std::out_of_range:", ex.what() ); } catch ( const std::range_error & ex ) { detail::report_exception( out, "std::range_error:", ex.what() ); } catch ( const std::overflow_error & ex ) { detail::report_exception( out, "std::overflow_error:", ex.what() ); } catch ( const std::underflow_error & ex ) { detail::report_exception( out, "std::underflow_error:", ex.what() ); } catch ( const std::logic_error & ex ) { detail::report_exception( out, "std::logic_error:", ex.what() ); } catch ( const std::runtime_error & ex ) { detail::report_exception( out, "std::runtime_error:", ex.what() ); } catch ( const std::exception & ex ) { detail::report_exception( out, "std::exception:", ex.what() ); } catch ( ... ) { detail::report_exception( out, "unknown exception", "" ); } #endif // BOOST_NO_EXCEPTIONS if ( exception_thrown ) result = boost::exit_exception_failure; if ( result != 0 && result != exit_success ) { out << std::endl << "**** returning with error code " << result << std::endl; err << "********** errors detected; see stdout for details ***********" << std::endl; } #if !defined(BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE) else { out << std::flush << "no errors detected" << std::endl; } #endif return result; } // catch_exceptions } // boost #endif // BOOST_CATCH_EXCEPTIONS_HPP ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/indirect_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/indirect_trait0000644000175000017500000002465011344301501031641 0ustar debiandebian// Copyright David Abrahams 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef INDIRECT_TRAITS_DWA2002131_HPP # define INDIRECT_TRAITS_DWA2002131_HPP # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include # endif namespace boost { namespace detail { namespace indirect_traits { # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_reference_to_const : mpl::false_ { }; template struct is_reference_to_const : mpl::true_ { }; # if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround template struct is_reference_to_const : mpl::true_ { }; # endif template struct is_reference_to_function : mpl::false_ { }; template struct is_reference_to_function : is_function { }; template struct is_pointer_to_function : mpl::false_ { }; // There's no such thing as a pointer-to-cv-function, so we don't need // specializations for those template struct is_pointer_to_function : is_function { }; template struct is_reference_to_member_function_pointer_impl : mpl::false_ { }; template struct is_reference_to_member_function_pointer_impl : is_member_function_pointer::type> { }; template struct is_reference_to_member_function_pointer : is_reference_to_member_function_pointer_impl { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T)) }; template struct is_reference_to_function_pointer_aux : mpl::and_< is_reference , is_pointer_to_function< typename remove_cv< typename remove_reference::type >::type > > { // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those }; template struct is_reference_to_function_pointer : mpl::if_< is_reference_to_function , mpl::false_ , is_reference_to_function_pointer_aux >::type { }; template struct is_reference_to_non_const : mpl::and_< is_reference , mpl::not_< is_reference_to_const > > { }; template struct is_reference_to_volatile : mpl::false_ { }; template struct is_reference_to_volatile : mpl::true_ { }; # if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround template struct is_reference_to_volatile : mpl::true_ { }; # endif template struct is_reference_to_pointer : mpl::false_ { }; template struct is_reference_to_pointer : mpl::true_ { }; template struct is_reference_to_pointer : mpl::true_ { }; template struct is_reference_to_pointer : mpl::true_ { }; template struct is_reference_to_pointer : mpl::true_ { }; template struct is_reference_to_class : mpl::and_< is_reference , is_class< typename remove_cv< typename remove_reference::type >::type > > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T)) }; template struct is_pointer_to_class : mpl::and_< is_pointer , is_class< typename remove_cv< typename remove_pointer::type >::type > > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_class,(T)) }; # else using namespace boost::detail::is_function_ref_tester_; typedef char (&inner_yes_type)[3]; typedef char (&inner_no_type)[2]; typedef char (&outer_no_type)[1]; template struct is_const_help { typedef typename mpl::if_< is_const , inner_yes_type , inner_no_type >::type type; }; template struct is_volatile_help { typedef typename mpl::if_< is_volatile , inner_yes_type , inner_no_type >::type type; }; template struct is_pointer_help { typedef typename mpl::if_< is_pointer , inner_yes_type , inner_no_type >::type type; }; template struct is_class_help { typedef typename mpl::if_< is_class , inner_yes_type , inner_no_type >::type type; }; template struct is_reference_to_function_aux { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof(detail::is_function_ref_tester(t,0)) == sizeof(::boost::type_traits::yes_type)); }; template struct is_reference_to_function : mpl::if_, is_reference_to_function_aux, mpl::bool_ >::type { }; template struct is_pointer_to_function_aux { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type)); typedef mpl::bool_ type; }; template struct is_pointer_to_function : mpl::if_, is_pointer_to_function_aux, mpl::bool_ >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_pointer_to_function,(T)) }; struct false_helper1 { template struct apply : mpl::false_ { }; }; template typename is_const_help::type reference_to_const_helper(V&); outer_no_type reference_to_const_helper(...); struct true_helper1 { template struct apply { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof(reference_to_const_helper(t)) == sizeof(inner_yes_type)); typedef mpl::bool_ type; }; }; template struct is_reference_to_const_helper1 : true_helper1 { }; template <> struct is_reference_to_const_helper1 : false_helper1 { }; template struct is_reference_to_const : is_reference_to_const_helper1::value>::template apply { }; template struct is_reference_to_non_const_helper1 { template struct apply { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof(reference_to_const_helper(t)) == sizeof(inner_no_type)); }; }; template <> struct is_reference_to_non_const_helper1 : false_helper1 { }; template struct is_reference_to_non_const : is_reference_to_non_const_helper1::value>::template apply { }; template typename is_volatile_help::type reference_to_volatile_helper(V&); outer_no_type reference_to_volatile_helper(...); template struct is_reference_to_volatile_helper1 { template struct apply { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof(reference_to_volatile_helper(t)) == sizeof(inner_yes_type)); }; }; template <> struct is_reference_to_volatile_helper1 : false_helper1 { }; template struct is_reference_to_volatile : is_reference_to_volatile_helper1::value>::template apply { }; template typename is_pointer_help::type reference_to_pointer_helper(V&); outer_no_type reference_to_pointer_helper(...); template struct is_reference_to_pointer { static T t; BOOST_STATIC_CONSTANT( bool, value = (is_reference::value && sizeof((reference_to_pointer_helper)(t)) == sizeof(inner_yes_type)) ); }; template struct is_reference_to_function_pointer : mpl::if_< is_reference , is_pointer_to_function_aux , mpl::bool_ >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_function_pointer,(T)) }; template struct is_member_function_pointer_help : mpl::if_, inner_yes_type, inner_no_type> {}; template typename is_member_function_pointer_help::type member_function_pointer_helper(V&); outer_no_type member_function_pointer_helper(...); template struct is_pointer_to_member_function_aux { static T t; BOOST_STATIC_CONSTANT( bool, value = sizeof((member_function_pointer_helper)(t)) == sizeof(inner_yes_type)); typedef mpl::bool_ type; }; template struct is_reference_to_member_function_pointer : mpl::if_< is_reference , is_pointer_to_member_function_aux , mpl::bool_ >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_member_function_pointer,(T)) }; template typename is_class_help::type reference_to_class_helper(V const volatile&); outer_no_type reference_to_class_helper(...); template struct is_reference_to_class { static T t; BOOST_STATIC_CONSTANT( bool, value = (is_reference::value & (sizeof(reference_to_class_helper(t)) == sizeof(inner_yes_type))) ); typedef mpl::bool_ type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_reference_to_class,(T)) }; template typename is_class_help::type pointer_to_class_helper(V const volatile*); outer_no_type pointer_to_class_helper(...); template struct is_pointer_to_class { static T t; BOOST_STATIC_CONSTANT( bool, value = (is_pointer::value && sizeof(pointer_to_class_helper(t)) == sizeof(inner_yes_type)) ); }; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } using namespace indirect_traits; }} // namespace boost::python::detail #endif // INDIRECT_TRAITS_DWA2002131_HPP ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/no_exceptions_support.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/no_exceptions_0000644000175000017500000000371511344301501031650 0ustar debiandebian#ifndef BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ #define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP_ #if (defined _MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif //---------------------------------------------------------------------- // (C) Copyright 2004 Pavel Vozenilek. // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt // or copy at http://www.boost.org/LICENSE_1_0.txt) // // // This file contains helper macros used when exception support may be // disabled (as indicated by macro BOOST_NO_EXCEPTIONS). // // Before picking up these macros you may consider using RAII techniques // to deal with exceptions - their syntax can be always the same with // or without exception support enabled. // /* Example of use: void foo() { BOOST_TRY { ... } BOOST_CATCH(const std::bad_alloc&) { ... BOOST_RETHROW } BOOST_CATCH(const std::exception& e) { ... } BOOST_CATCH_END } With exception support enabled it will expand into: void foo() { { try { ... } catch (const std::bad_alloc&) { ... throw; } catch (const std::exception& e) { ... } } } With exception support disabled it will expand into: void foo() { { if(true) { ... } else if (false) { ... } else if (false) { ... } } } */ //---------------------------------------------------------------------- #include #include #if !(defined BOOST_NO_EXCEPTIONS) # define BOOST_TRY { try # define BOOST_CATCH(x) catch(x) # define BOOST_RETHROW throw; # define BOOST_CATCH_END } #else # if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) # define BOOST_TRY { if ("") # define BOOST_CATCH(x) else if (!"") # else # define BOOST_TRY { if (true) # define BOOST_CATCH(x) else if (false) # endif # define BOOST_RETHROW # define BOOST_CATCH_END } #endif #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/numeric_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/numeric_traits0000644000175000017500000001515411344301501031664 0ustar debiandebian// (C) Copyright David Abrahams 2001, Howard Hinnant 2001. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Template class numeric_traits -- // // Supplies: // // typedef difference_type -- a type used to represent the difference // between any two values of Number. // // Support: // 1. Not all specializations are supplied // // 2. Use of specializations that are not supplied will cause a // compile-time error // // 3. Users are free to specialize numeric_traits for any type. // // 4. Right now, specializations are only supplied for integer types. // // 5. On implementations which do not supply compile-time constants in // std::numeric_limits<>, only specializations for built-in integer types // are supplied. // // 6. Handling of numbers whose range of representation is at least as // great as boost::intmax_t can cause some differences to be // unrepresentable in difference_type: // // Number difference_type // ------ --------------- // signed Number // unsigned intmax_t // // template typename numeric_traits::difference_type // numeric_distance(Number x, Number y) // computes (y - x), attempting to avoid overflows. // // See http://www.boost.org for most recent version including documentation. // Revision History // 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams) // 11 Feb 2001 - Rolled back ineffective Borland-specific code // (David Abrahams) // 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but // not seeing any improvement yet (David Abrahams) // 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp // (David Abrahams) // 23 Jan 2001 - Fixed logic of difference_type selection, which was // completely wack. In the process, added digit_traits<> // to compute the number of digits in intmax_t even when // not supplied by numeric_limits<>. (David Abrahams) // 21 Jan 2001 - Created (David Abrahams) #ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901 # define BOOST_NUMERIC_TRAITS_HPP_DWA20001901 # include # include # include # include # include # include namespace boost { namespace detail { // Template class is_signed -- determine whether a numeric type is signed // Requires that T is constructable from the literals -1 and 0. Compile-time // error results if that requirement is not met (and thus signedness is not // likely to have meaning for that type). template struct is_signed { #if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_MSVC) && BOOST_MSVC <= 1300 BOOST_STATIC_CONSTANT(bool, value = (Number(-1) < Number(0))); #else BOOST_STATIC_CONSTANT(bool, value = std::numeric_limits::is_signed); #endif }; # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS // digit_traits - compute the number of digits in a built-in integer // type. Needed for implementations on which numeric_limits is not specialized // for intmax_t (e.g. VC6). template struct digit_traits_select; // numeric_limits is specialized; just select that version of digits template <> struct digit_traits_select { template struct traits { BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits::digits); }; }; // numeric_limits is not specialized; compute digits from sizeof(T) template <> struct digit_traits_select { template struct traits { BOOST_STATIC_CONSTANT(int, digits = ( sizeof(T) * std::numeric_limits::digits - (is_signed::value ? 1 : 0)) ); }; }; // here's the "usable" template template struct digit_traits { typedef digit_traits_select< ::std::numeric_limits::is_specialized> selector; typedef typename selector::template traits traits; BOOST_STATIC_CONSTANT(int, digits = traits::digits); }; #endif // Template class integer_traits -- traits of various integer types // This should probably be rolled into boost::integer_traits one day, but I // need it to work without template struct integer_traits { # ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS private: typedef Integer integer_type; typedef std::numeric_limits x; # if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 // for some reason, MSVC asserts when it shouldn't unless we make these // local definitions BOOST_STATIC_CONSTANT(bool, is_integer = x::is_integer); BOOST_STATIC_CONSTANT(bool, is_specialized = x::is_specialized); BOOST_STATIC_ASSERT(is_integer); BOOST_STATIC_ASSERT(is_specialized); # endif public: typedef typename if_true<(int(x::is_signed) && (!int(x::is_bounded) // digits is the number of no-sign bits || (int(x::digits) + 1 >= digit_traits::digits)))>::template then< Integer, typename if_true<(int(x::digits) + 1 < digit_traits::digits)>::template then< signed int, typename if_true<(int(x::digits) + 1 < digit_traits::digits)>::template then< signed long, // else intmax_t >::type>::type>::type difference_type; #else BOOST_STATIC_ASSERT(boost::is_integral::value); typedef typename if_true<(sizeof(Integer) >= sizeof(intmax_t))>::template then< typename if_true<(is_signed::value)>::template then< Integer, intmax_t >::type, typename if_true<(sizeof(Integer) < sizeof(std::ptrdiff_t))>::template then< std::ptrdiff_t, intmax_t >::type >::type difference_type; # endif }; // Right now, only supports integers, but should be expanded. template struct numeric_traits { typedef typename integer_traits::difference_type difference_type; }; template typename numeric_traits::difference_type numeric_distance(Number x, Number y) { typedef typename numeric_traits::difference_type difference_type; return difference_type(y) - difference_type(x); } }} #endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901 ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/shared_array_nmt.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/shared_array_n0000644000175000017500000000626111344301501031614 0ustar debiandebian#ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED #define BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED // // detail/shared_array_nmt.hpp - shared_array.hpp without member templates // // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation. // #include #include #include #include #include // for std::ptrdiff_t #include // for std::swap #include // for std::less #include // for std::bad_alloc namespace boost { template class shared_array { private: typedef detail::atomic_count count_type; public: typedef T element_type; explicit shared_array(T * p = 0): px(p) { #ifndef BOOST_NO_EXCEPTIONS try // prevent leak if new throws { pn = new count_type(1); } catch(...) { boost::checked_array_delete(p); throw; } #else pn = new count_type(1); if(pn == 0) { boost::checked_array_delete(p); boost::throw_exception(std::bad_alloc()); } #endif } ~shared_array() { if(--*pn == 0) { boost::checked_array_delete(px); delete pn; } } shared_array(shared_array const & r) : px(r.px) // never throws { pn = r.pn; ++*pn; } shared_array & operator=(shared_array const & r) { shared_array(r).swap(*this); return *this; } void reset(T * p = 0) { BOOST_ASSERT(p == 0 || p != px); shared_array(p).swap(*this); } T * get() const // never throws { return px; } T & operator[](std::ptrdiff_t i) const // never throws { BOOST_ASSERT(px != 0); BOOST_ASSERT(i >= 0); return px[i]; } long use_count() const // never throws { return *pn; } bool unique() const // never throws { return *pn == 1; } void swap(shared_array & other) // never throws { std::swap(px, other.px); std::swap(pn, other.pn); } private: T * px; // contained pointer count_type * pn; // ptr to reference counter }; // shared_array template inline bool operator==(shared_array const & a, shared_array const & b) { return a.get() == b.get(); } template inline bool operator!=(shared_array const & a, shared_array const & b) { return a.get() != b.get(); } template inline bool operator<(shared_array const & a, shared_array const & b) { return std::less()(a.get(), b.get()); } template void swap(shared_array & a, shared_array & b) { a.swap(b); } } // namespace boost #endif // #ifndef BOOST_DETAIL_SHARED_ARRAY_NMT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lightweight_mutex.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/detail/lightweight_mu0000644000175000017500000000742111344301501031652 0ustar debiandebian#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED #define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lightweight_mutex.hpp - lightweight mutex // // Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // typedef boost::detail::lightweight_mutex; // // boost::detail::lightweight_mutex meets a subset of the Mutex concept // requirements: http://www.boost.org/libs/thread/doc/mutex_concept.html#Mutex // // * Used by the smart pointer library // * Performance oriented // * Header-only implementation // * Small memory footprint // * Not a general purpose mutex, use boost::mutex, CRITICAL_SECTION or // pthread_mutex instead. // * Never spin in a tight lock/do-something/unlock loop, since // lightweight_mutex does not guarantee fairness. // * Never keep a lightweight_mutex locked for long periods. // // The current implementation can use a pthread_mutex, a CRITICAL_SECTION, // or a platform-specific spinlock. // // You can force a particular implementation by defining BOOST_LWM_USE_PTHREADS, // BOOST_LWM_USE_CRITICAL_SECTION, or BOOST_LWM_USE_SPINLOCK. // // If neither macro has been defined, the default is to use a spinlock on Win32, // and a pthread_mutex otherwise. // // Note that a spinlock is not a general synchronization primitive. In particular, // it is not guaranteed to be a memory barrier, and it is possible to "livelock" // if a lower-priority thread has acquired the spinlock but a higher-priority // thread is spinning trying to acquire the same lock. // // For these reasons, spinlocks have been disabled by default except on Windows, // where a spinlock can be several orders of magnitude faster than a CRITICAL_SECTION. // Note: lwm_linux.hpp has been disabled by default; see the comments // inside for more info. #include // Note to implementors: if you write a platform-specific spinlock // for a platform that supports pthreads, be sure to test its performance // against the pthreads-based version using shared_ptr_timing_test.cpp and // shared_ptr_mt_test.cpp. Custom versions are usually not worth the trouble // _unless_ the performance gains are substantial. // // Be sure to compare against a "real" pthreads library; // shared_ptr_timing_test.cpp will compile succesfully with a stub do-nothing // pthreads library, since it doesn't create any threads. #if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) && !defined(BOOST_LWM_USE_CRITICAL_SECTION) && !defined(BOOST_LWM_USE_PTHREADS) # define BOOST_LWM_WIN32 #endif #if !defined(BOOST_HAS_THREADS) # if defined(BOOST_LWM_WIN32) # include # else # include # endif #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(BOOST_USE_ASM_ATOMIC_H) # include #elif defined(BOOST_LWM_USE_CRITICAL_SECTION) # include #elif defined(BOOST_LWM_USE_PTHREADS) # include #elif defined(BOOST_LWM_WIN32) # include #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__sgi) # include #elif defined(BOOST_LWM_USE_SPINLOCK) && defined(__GLIBCPP__) # include #elif defined(BOOST_HAS_PTHREADS) # define BOOST_LWM_USE_PTHREADS # include #else // Use #define BOOST_DISABLE_THREADS to avoid the error # error Unrecognized threading platform #endif #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/optional.hpp0000644000175000017500000000101711344301501027776 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_OPTIONAL_FLC_19NOV2002_HPP #define BOOST_OPTIONAL_FLC_19NOV2002_HPP #include "boost/optional/optional.hpp" #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/smart_cast.hpp0000644000175000017500000002411511344301501030315 0ustar debiandebian#ifndef BOOST_SMART_CAST_HPP #define BOOST_SMART_CAST_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // smart_cast.hpp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. // casting of pointers and references. // In casting between different C++ classes, there are a number of // rules that have to be kept in mind in deciding whether to use // static_cast or dynamic_cast. // a) dynamic casting can only be applied when one of the types is polymorphic // Otherwise static_cast must be used. // b) only dynamic casting can do runtime error checking // use of static_cast is generally un checked even when compiled for debug // c) static_cast would be considered faster than dynamic_cast. // If casting is applied to a template parameter, there is no apriori way // to know which of the two casting methods will be permitted or convenient. // smart_cast uses C++ type_traits, and program debug mode to select the // most convenient cast to use. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace smart_cast_impl { template struct reference { struct polymorphic { struct linear { template static T cast(U & u){ return static_cast(u); } }; struct cross { template static T cast(U & u){ return dynamic_cast(u); } }; template static T cast(U & u){ // if we're in debug mode #if ! defined(NDEBUG) \ || defined(__BORLANDC__) && (__BORLANDC__ <= 0x564) \ || defined(__MWERKS__) // do a checked dynamic cast return cross::cast(u); #else // borland 5.51 chokes here so we can't use it // note: if remove_reference isn't function for these types // cross casting will be selected this will work but will // not be the most efficient method. This will conflict with // the original smart_cast motivation. typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< BOOST_DEDUCED_TYPENAME mpl::and_< mpl::not_::type, U > >, mpl::not_::type > > >, // borland chokes w/o full qualification here mpl::identity, mpl::identity >::type typex; // typex works around gcc 2.95 issue return typex::cast(u); #endif } }; struct non_polymorphic { template static T cast(U & u){ return static_cast(u); } }; template static T cast(U & u){ #if defined(__BORLANDC__) return mpl::eval_if< boost::is_polymorphic, mpl::identity, mpl::identity >::type::cast(u); #else typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< boost::is_polymorphic, mpl::identity, mpl::identity >::type typex; return typex::cast(u); #endif } }; template struct pointer { struct polymorphic { // unfortunately, this below fails to work for virtual base // classes. Subject for further study #if 0 struct linear { template static T cast(U * u){ return static_cast(u); } }; struct cross { template static T cast(U * u){ T tmp = dynamic_cast(u); #ifndef NDEBUG if ( tmp == 0 ) throw std::bad_cast(); #endif return tmp; } }; template static T cast(U * u){ // if we're in debug mode #if ! defined(NDEBUG) || defined(__BORLANDC__) && (__BORLANDC__ <= 0x564) // do a checked dynamic cast return cross::cast(u); #else // borland 5.51 chokes here so we can't use it // note: if remove_pointer isn't function for these types // cross casting will be selected this will work but will // not be the most efficient method. This will conflict with // the original smart_cast motivation. typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< BOOST_DEDUCED_TYPENAME mpl::and_< mpl::not_::type, U > >, mpl::not_::type > > >, // borland chokes w/o full qualification here mpl::identity, mpl::identity >::type typex; return typex::cast(u); #endif } #endif template static T cast(U * u){ T tmp = dynamic_cast(u); #ifndef NDEBUG if ( tmp == 0 ) throw std::bad_cast(); #endif return tmp; } }; struct non_polymorphic { template static T cast(U * u){ return static_cast(u); } }; template static T cast(U * u){ #if defined(__BORLANDC__) return mpl::eval_if< boost::is_polymorphic, mpl::identity, mpl::identity >::type::cast(u); #else typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< boost::is_polymorphic, mpl::identity, mpl::identity >::type typex; return typex::cast(u); #endif } }; template struct void_pointer { template static TPtr cast(UPtr uptr){ return static_cast(uptr); } }; template struct error { // if we get here, its because we are using one argument in the // cast on a system which doesn't support partial template // specialization template static T cast(U u){ BOOST_STATIC_ASSERT(sizeof(T)==0); return * static_cast(NULL); } }; } // smart_cast_impl // this implements: // smart_cast(Source * s) // smart_cast(s) // note that it will fail with // smart_cast(s) template static T smart_cast(U u) { typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< BOOST_DEDUCED_TYPENAME mpl::or_< boost::is_same, boost::is_same, boost::is_same, boost::is_same >, mpl::identity >, // else BOOST_DEDUCED_TYPENAME mpl::eval_if, mpl::identity >, // else BOOST_DEDUCED_TYPENAME mpl::eval_if, mpl::identity >, // else mpl::identity > > > >::type typex; return typex::cast(u); } // this implements: // smart_cast_reference(Source & s) template static T smart_cast_reference(U & u) { return smart_cast_impl::reference::cast(u); } } // namespace boost #endif // BOOST_SMART_CAST_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/assign.hpp0000644000175000017500000000114611344301501027440 0ustar debiandebian// Boost.Assign library // // Copyright Thorsten Ottosen 2003-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // For more information, see http://www.boost.org/libs/assign/ // #ifndef BOOST_ASSIGN_HPP #define BOOST_ASSIGN_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif #include #include #include #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/cast.hpp0000644000175000017500000003314711344301501027114 0ustar debiandebian// boost cast.hpp header file ----------------------------------------------// // (C) Copyright Kevlin Henney and Dave Abrahams 1999. // Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/conversion for Documentation. // Revision History // 02 Apr 01 Removed BOOST_NO_LIMITS workarounds and included // instead (the workaround did not // actually compile when BOOST_NO_LIMITS was defined in // any case, so we loose nothing). (John Maddock) // 21 Jan 01 Undid a bug I introduced yesterday. numeric_cast<> never // worked with stock GCC; trying to get it to do that broke // vc-stlport. // 20 Jan 01 Moved BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS to config.hpp. // Removed unused BOOST_EXPLICIT_TARGET macro. Moved // boost::detail::type to boost/type.hpp. Made it compile with // stock gcc again (Dave Abrahams) // 29 Nov 00 Remove nested namespace cast, cleanup spacing before Formal // Review (Beman Dawes) // 19 Oct 00 Fix numeric_cast for floating-point types (Dave Abrahams) // 15 Jul 00 Suppress numeric_cast warnings for GCC, Borland and MSVC // (Dave Abrahams) // 30 Jun 00 More MSVC6 wordarounds. See comments below. (Dave Abrahams) // 28 Jun 00 Removed implicit_cast<>. See comment below. (Beman Dawes) // 27 Jun 00 More MSVC6 workarounds // 15 Jun 00 Add workarounds for MSVC6 // 2 Feb 00 Remove bad_numeric_cast ";" syntax error (Doncho Angelov) // 26 Jan 00 Add missing throw() to bad_numeric_cast::what(0 (Adam Levar) // 29 Dec 99 Change using declarations so usages in other namespaces work // correctly (Dave Abrahams) // 23 Sep 99 Change polymorphic_downcast assert to also detect M.I. errors // as suggested Darin Adler and improved by Valentin Bonnard. // 2 Sep 99 Remove controversial asserts, simplify, rename. // 30 Aug 99 Move to cast.hpp, replace value_cast with numeric_cast, // place in nested namespace. // 3 Aug 99 Initial version #ifndef BOOST_CAST_HPP #define BOOST_CAST_HPP # include # include # include # include # include # include // It has been demonstrated numerous times that MSVC 6.0 fails silently at link // time if you use a template function which has template parameters that don't // appear in the function's argument list. // // TODO: Add this to config.hpp? # if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // 1200 = VC6 # define BOOST_EXPLICIT_DEFAULT_TARGET , ::boost::type* = 0 # else # define BOOST_EXPLICIT_DEFAULT_TARGET # endif namespace boost { // See the documentation for descriptions of how to choose between // static_cast<>, dynamic_cast<>, polymorphic_cast<> and polymorphic_downcast<> // polymorphic_cast --------------------------------------------------------// // Runtime checked polymorphic downcasts and crosscasts. // Suggested in The C++ Programming Language, 3rd Ed, Bjarne Stroustrup, // section 15.8 exercise 1, page 425. template inline Target polymorphic_cast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET) { Target tmp = dynamic_cast(x); if ( tmp == 0 ) throw std::bad_cast(); return tmp; } // polymorphic_downcast ----------------------------------------------------// // assert() checked polymorphic downcast. Crosscasts prohibited. // WARNING: Because this cast uses assert(), it violates the One Definition // Rule if NDEBUG is inconsistently defined across translation units. // Contributed by Dave Abrahams template inline Target polymorphic_downcast(Source* x BOOST_EXPLICIT_DEFAULT_TARGET) { assert( dynamic_cast(x) == x ); // detect logic error return static_cast(x); } // implicit_cast -----------------------------------------------------------// // // Removed due to uncertain purpose. Use either numeric_cast (see below) // or static_cast according to the need. // numeric_cast and related exception --------------------------------------// // Contributed by Kevlin Henney // bad_numeric_cast --------------------------------------------------------// // exception used to indicate runtime numeric_cast failure class bad_numeric_cast : public std::bad_cast { public: // constructors, destructors and assignment operator defaulted // function inlined for brevity and consistency with rest of library virtual const char *what() const throw() { return "bad numeric cast: loss of range in numeric_cast"; } }; // numeric_cast ------------------------------------------------------------// #if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) || defined(BOOST_SGI_CPP_LIMITS) namespace detail { template struct signed_numeric_limits : std::numeric_limits { static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION () { return (std::numeric_limits::min)() >= 0 // unary minus causes integral promotion, thus the static_cast<> ? static_cast(-(std::numeric_limits::max)()) : (std::numeric_limits::min)(); }; }; // Move to namespace boost in utility.hpp? template struct fixed_numeric_limits_base : public if_true< std::numeric_limits::is_signed > ::BOOST_NESTED_TEMPLATE then< signed_numeric_limits, std::numeric_limits >::type {}; template struct fixed_numeric_limits : fixed_numeric_limits_base::is_specialized)> {}; # ifdef BOOST_HAS_LONG_LONG // cover implementations which supply no specialization for long // long / unsigned long long. Not intended to be full // numeric_limits replacements, but good enough for numeric_cast<> template <> struct fixed_numeric_limits_base< ::boost::long_long_type, false> { BOOST_STATIC_CONSTANT(bool, is_specialized = true); BOOST_STATIC_CONSTANT(bool, is_signed = true); static ::boost::long_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { # ifdef LONGLONG_MAX return LONGLONG_MAX; # else return 9223372036854775807LL; // hope this is portable # endif } static ::boost::long_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { # ifdef LONGLONG_MIN return LONGLONG_MIN; # else return -( 9223372036854775807LL )-1; // hope this is portable # endif } }; template <> struct fixed_numeric_limits_base< ::boost::ulong_long_type, false> { BOOST_STATIC_CONSTANT(bool, is_specialized = true); BOOST_STATIC_CONSTANT(bool, is_signed = false); static ::boost::ulong_long_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { # ifdef ULONGLONG_MAX return ULONGLONG_MAX; # else return 0xffffffffffffffffULL; // hope this is portable # endif } static ::boost::ulong_long_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; } }; # endif } // namespace detail // less_than_type_min - // x_is_signed should be numeric_limits::is_signed // y_is_signed should be numeric_limits::is_signed // y_min should be numeric_limits::min() // // check(x, y_min) returns true iff x < y_min without invoking comparisons // between signed and unsigned values. // // "poor man's partial specialization" is in use here. template struct less_than_type_min { template static bool check(X x, Y y_min) { return x < y_min; } }; template <> struct less_than_type_min { template static bool check(X, Y) { return false; } }; template <> struct less_than_type_min { template static bool check(X x, Y) { return x < 0; } }; // greater_than_type_max - // same_sign should be: // numeric_limits::is_signed == numeric_limits::is_signed // y_max should be numeric_limits::max() // // check(x, y_max) returns true iff x > y_max without invoking comparisons // between signed and unsigned values. // // "poor man's partial specialization" is in use here. template struct greater_than_type_max; template<> struct greater_than_type_max { template static inline bool check(X x, Y y_max) { return x > y_max; } }; template <> struct greater_than_type_max { // What does the standard say about this? I think it's right, and it // will work with every compiler I know of. template static inline bool check(X x, Y) { return x >= 0 && static_cast(static_cast(x)) != x; } # if defined(BOOST_MSVC) && BOOST_MSVC <= 1200 // MSVC6 can't static_cast unsigned __int64 -> floating types # define BOOST_UINT64_CAST(src_type) \ static inline bool check(src_type x, unsigned __int64) \ { \ if (x < 0) return false; \ unsigned __int64 y = static_cast(x); \ bool odd = y & 0x1; \ __int64 div2 = static_cast<__int64>(y >> 1); \ return ((static_cast(div2) * 2.0) + odd) != x; \ } BOOST_UINT64_CAST(long double); BOOST_UINT64_CAST(double); BOOST_UINT64_CAST(float); # undef BOOST_UINT64_CAST # endif }; template<> struct greater_than_type_max { template static inline bool check(X x, Y y_max) { return x > y_max; } }; template <> struct greater_than_type_max { // What does the standard say about this? I think it's right, and it // will work with every compiler I know of. template static inline bool check(X x, Y) { return static_cast(static_cast(x)) != x; } }; #else // use #pragma hacks if available namespace detail { # if BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4018) # pragma warning(disable : 4146) #elif defined(__BORLANDC__) # pragma option push -w-8041 # endif // Move to namespace boost in utility.hpp? template struct fixed_numeric_limits : public std::numeric_limits { static inline T min BOOST_PREVENT_MACRO_SUBSTITUTION () { return std::numeric_limits::is_signed && (std::numeric_limits::min)() >= 0 ? T(-(std::numeric_limits::max)()) : (std::numeric_limits::min)(); } }; # if BOOST_MSVC # pragma warning(pop) #elif defined(__BORLANDC__) # pragma option pop # endif } // namespace detail #endif template inline Target numeric_cast(Source arg BOOST_EXPLICIT_DEFAULT_TARGET) { // typedefs abbreviating respective trait classes typedef detail::fixed_numeric_limits arg_traits; typedef detail::fixed_numeric_limits result_traits; #if defined(BOOST_STRICT_CONFIG) \ || (!defined(__HP_aCC) || __HP_aCC > 33900) \ && (!defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) \ || defined(BOOST_SGI_CPP_LIMITS)) // typedefs that act as compile time assertions // (to be replaced by boost compile time assertions // as and when they become available and are stable) typedef bool argument_must_be_numeric[arg_traits::is_specialized]; typedef bool result_must_be_numeric[result_traits::is_specialized]; const bool arg_is_signed = arg_traits::is_signed; const bool result_is_signed = result_traits::is_signed; const bool same_sign = arg_is_signed == result_is_signed; if (less_than_type_min::check(arg, (result_traits::min)()) || greater_than_type_max::check(arg, (result_traits::max)()) ) #else // We need to use #pragma hacks if available # if BOOST_MSVC # pragma warning(push) # pragma warning(disable : 4018) #elif defined(__BORLANDC__) #pragma option push -w-8012 # endif if ((arg < 0 && !result_traits::is_signed) // loss of negative range || (arg_traits::is_signed && arg < (result_traits::min)()) // underflow || arg > (result_traits::max)()) // overflow # if BOOST_MSVC # pragma warning(pop) #elif defined(__BORLANDC__) #pragma option pop # endif #endif { throw bad_numeric_cast(); } return static_cast(arg); } // numeric_cast # undef BOOST_EXPLICIT_DEFAULT_TARGET } // namespace boost #endif // BOOST_CAST_HPP ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/indirect_reference.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/indirect_reference.hp0000644000175000017500000000176311344301501031620 0ustar debiandebian// Copyright David Abrahams 2004. Use, modification and distribution is // subject to the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef INDIRECT_REFERENCE_DWA200415_HPP # define INDIRECT_REFERENCE_DWA200415_HPP // dereferenceable_traits provides access to the value_type and // reference of a Dereferenceable type. # include # include # include # include # include namespace boost { namespace detail { template struct smart_ptr_reference { typedef typename boost::pointee

::type& type; }; } template struct indirect_reference : mpl::eval_if< detail::is_incrementable

, iterator_reference

, detail::smart_ptr_reference

> { }; } // namespace boost #endif // INDIRECT_REFERENCE_DWA200415_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/0000755000175000017500000000000012146213733025033 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_2_bases.h0000644000175000017500000001405011344301500027313 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_2_bases.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel #ifndef CGAL_ARR_2_BASES_H #define CGAL_ARR_2_BASES_H #include CGAL_BEGIN_NAMESPACE template class Arr_2_vertex_base { protected: void* hdg; Pt pt; public: typedef Pt Point; Arr_2_vertex_base() {} virtual ~Arr_2_vertex_base() {} void* halfedge() { return hdg; } const void* halfedge() const { return hdg; } void set_halfedge(void* h) { hdg = h; } // an incident halfedge pointing at `v'. // Point& point() { return pt;} const Point& point() const { return pt;} void set_point(const Point& p) { pt = p; } // assign function for non-connectivity data virtual void assign(const Arr_2_vertex_base & v) { pt = v.pt; } }; template class Arr_2_halfedge_base { public: typedef typename Base_node::X_monotone_curve_2 X_monotone_curve_2; Arr_2_halfedge_base() : bn(0) {} virtual ~Arr_2_halfedge_base() {} void* opposite() { return opp; } const void* opposite() const { return opp; } void* next() { return nxt; } const void* next() const { return nxt; } // the next halfedge along the face. void set_opposite(void* h) { opp = h; } void set_next(void* h) { nxt = h; } // void* prev() { return prv;} // const void* prev() const { return prv;} void* vertex() { return v; } const void* vertex() const { return v; } void* face() { return f; } const void* face() const { return f; } // the face to the left. void set_vertex( void* _v) { v = _v; } void set_face( void* _f) { f = _f; } //for debug only !! //const Curve& curve() const { return cv;} //void set_curve(const Curve& c) {cv=c;} //WATCH OUT: //we make the curve and set_curve empty so the pm can find them but not //use them , the curves are set in the halfedge via the edge_node!! const X_monotone_curve_2 & curve() const { return bn->x_curve(); } // void set_curve(const Curve& cv) {bn->set_curve(cv);} //the setting of the curve is done only in the arrangement level void set_curve(const X_monotone_curve_2 &) {} Base_node* edge_node() {return bn;} //will become private in the arrangement const Base_node* edge_node() const {return bn;} void set_edge_node(Base_node* b) {bn=b;} // assign function for non-connectivity data virtual void assign(const Arr_2_halfedge_base &) { //bn = new Base_node(*e.bn); } protected: void* opp; void* nxt; void* v; void* f; //face Base_node* bn; //debug //Curve cv; }; class Arr_2_face_base { public: typedef std::list Holes_container; typedef Holes_container::iterator Holes_iterator; typedef Holes_container::const_iterator Holes_const_iterator; Arr_2_face_base() : holes() {}; virtual ~Arr_2_face_base() {} void* halfedge() { return hdg;} const void* halfedge() const { return hdg;} void set_halfedge(void* h) {hdg=h;} //mine Holes_iterator holes_begin() {return holes.begin();} Holes_iterator holes_end() {return holes.end();} Holes_const_iterator holes_begin() const {return holes.begin();} Holes_const_iterator holes_end() const {return holes.end();} void add_hole(void* halfedge_ptr) { holes.push_back(halfedge_ptr); } void erase_hole(Holes_iterator hit) { holes.erase(hit); } void erase_holes(Holes_iterator first, Holes_iterator last) { holes.erase(first,last); } //this is not documented but needed for a private project Holes_container::size_type number_of_holes() const { return holes.size(); } // assign function for non-connectivity data virtual void assign(const Arr_2_face_base &) { } protected: void* hdg; Holes_container holes; }; template class Arr_base_node { public: typedef _Curve_2 Curve_2; typedef _X_monotone_curve_2 X_monotone_curve_2; class Curve_wrap{ public: Curve_2* cv; X_monotone_curve_2* x_cv; Curve_wrap ():cv(NULL), x_cv(NULL) {} ~Curve_wrap() { if(cv) delete cv; if(x_cv) delete x_cv; } Curve_wrap(const Curve_wrap& cv_wrap) { if(cv_wrap.cv!=NULL) { cv = new Curve_2; *cv = *(cv_wrap.cv); } else cv=NULL; if(cv_wrap.x_cv!=NULL) { x_cv = new X_monotone_curve_2; *x_cv = *(cv_wrap.x_cv); } else x_cv=NULL; } Curve_wrap& operator= (const Curve_wrap& cv_wrap) { if (this == &cv_wrap) return (*this); if(cv_wrap.cv!=NULL) { cv = new Curve_2; *cv = *(cv_wrap.cv); } else cv=NULL; if(cv_wrap.x_cv!=NULL) { x_cv = new X_monotone_curve_2; *x_cv = *(cv_wrap.x_cv); } else x_cv=NULL; return *this; } }; Arr_base_node() {} virtual ~Arr_base_node() {} const Curve_2& curve() const {return *(cv_wrap.cv);} void set_curve(const Curve_2& c) { *cv_wrap.cv = c; } const X_monotone_curve_2& x_curve() const { return *(cv_wrap.x_cv); } void set_x_monotone_curve(const X_monotone_curve_2& c) {*cv_wrap.x_cv = c;} // assign function for non-connectivity data virtual void assign(const Arr_base_node<_Curve_2, _X_monotone_curve_2> &bn) { cv_wrap = bn.cv_wrap; } protected: // Curve cv; Curve_wrap cv_wrap; }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Compact_container.h0000644000175000017500000006360511344301500030633 0ustar debiandebian// Copyright (c) 2003-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Compact_container.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_COMPACT_CONTAINER_H #define CGAL_COMPACT_CONTAINER_H #include #include #include #include #include // An STL like container with the following properties : // - to achieve compactness, it requires access to a pointer stored in T, // specified by a traits. This pointer is supposed to be 4 bytes aligned // when the object is alive, otherwise, the container uses the 2 least // significant bits to store information in the pointer. // - Ts are allocated in arrays of increasing size, which are linked together // by their first and last element. // - the iterator looks at the famous 2 bits to know if it has to deal with // a free/used/boundary element. // TODO : // - Add .reserve() and .resize() (and proper copy of capacity_). // - Add preconditions in input that real pointers need to have clean bits. // Also for the allocated memory alignment, and sizeof(). // - Do a benchmark before/after. // - Check the end result with Valgrind. // - The bit squatting mecanism will be reused for the conflict flag, maybe // it could be put out of the class. // TODO low priority : // - rebind<> the allocator // - Exception safety guarantees // - Thread safety guarantees // - std requirements on iterators says all defined operations are constant // time amortized (it's not true here, maybe it could be with some work...) // - all this is expected especially when there are not so many free objects // compared to the allocated elements. // - Should block_size be selectable/hintable by .reserve() ? // - would be nice to have a temporary_free_list (still active elements, but // which are going to be freed soon). Probably it prevents compactness. // - eventually something to copy this data structure, providing a way to // update the pointers (give access to a hash_map, at least a function that // converts an old pointer to the new one ?). Actually it doesn't have to // be stuck to a particular DS, because for a list it's useful too... // - Currently, end() can be invalidated on insert() if a new block is added. // It would be nice to fix this. We could insert the new block at the // beginning instead ? That would drop the property that iterator order // is preserved. Maybe it's not a problem if end() is not preserved, after // all nothing is going to dereference it, it's just for comparing with // end() that it can be a problem. // Another way would be to have end() point to the end of an always // empty block (containing no usable element), and insert new blocks just // before this one. // Instead of having the blocks linked between them, the start/end pointers // could point back to the container, so that we can do more interesting // things (e.g. freeing empty blocks automatically) ? // - Submission to Boost. CGAL_BEGIN_NAMESPACE // The following base class can be used to easily add a squattable pointer // to a class (maybe you loose a bit of compactness though). // TODO : Shouldn't adding these bits be done automatically and transparently, // based on the traits class info ? class Compact_container_base { void * p; public: Compact_container_base() : p(NULL) {} void * for_compact_container() const { return p; } void * & for_compact_container() { return p; } }; // The traits class describes the way to access the pointer. // It can be specialized. template < class T > struct Compact_container_traits { static void * pointer(const T &t) { return t.for_compact_container(); } static void * & pointer(T &t) { return t.for_compact_container(); } }; namespace CGALi { template < class DSC, bool Const > class CC_iterator; } template < class T, class Allocator = CGAL_ALLOCATOR(T) > class Compact_container { typedef Compact_container Self; typedef Compact_container_traits Traits; public: typedef T value_type; typedef Allocator allocator_type; typedef typename Allocator::reference reference; typedef typename Allocator::const_reference const_reference; typedef typename Allocator::pointer pointer; typedef typename Allocator::const_pointer const_pointer; typedef typename Allocator::size_type size_type; typedef typename Allocator::difference_type difference_type; typedef CGALi::CC_iterator iterator; typedef CGALi::CC_iterator const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; friend class CGALi::CC_iterator; friend class CGALi::CC_iterator; explicit Compact_container(const Allocator &a = Allocator()) : alloc(a) { init(); } template < class InputIterator > Compact_container(InputIterator first, InputIterator last, const Allocator & a = Allocator()) : alloc(a) { init(); std::copy(first, last, CGAL::inserter(*this)); } // The copy constructor and assignment operator preserve the iterator order Compact_container(const Compact_container &c) : alloc(c.get_allocator()) { init(); block_size = c.block_size; std::copy(c.begin(), c.end(), CGAL::inserter(*this)); } Compact_container & operator=(const Compact_container &c) { if (&c != this) { Self tmp(c); swap(tmp); } return *this; } ~Compact_container() { clear(); } void swap(Self &c) { std::swap(alloc, c.alloc); std::swap(capacity_, c.capacity_); std::swap(size_, c.size_); std::swap(block_size, c.block_size); std::swap(first_item, c.first_item); std::swap(last_item, c.last_item); std::swap(free_list, c.free_list); } iterator begin() { return iterator(first_item, 0, 0); } iterator end() { return iterator(last_item, 0); } const_iterator begin() const { return const_iterator(first_item, 0, 0); } const_iterator end() const { return const_iterator(last_item, 0); } reverse_iterator rbegin() { return reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } // inserts a default constructed item. iterator construct_insert() { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } // Special insert methods that construct the objects in place // (just forward the arguments to the constructor, to optimize a copy). template < typename T1 > iterator construct_insert(const T1 &t1) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2 > iterator construct_insert(const T1 &t1, const T2 &t2) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2, typename T3 > iterator construct_insert(const T1 &t1, const T2 &t2, const T3 &t3) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2, t3); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2, typename T3, typename T4 > iterator construct_insert(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2, t3, t4); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2, typename T3, typename T4, typename T5 > iterator construct_insert(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2, t3, t4, t5); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2, typename T3, typename T4, typename T5, typename T6 > iterator construct_insert(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2, t3, t4, t5, t6); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7 > iterator construct_insert(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2, t3, t4, t5, t6, t7); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8 > iterator construct_insert(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7, const T8 &t8) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); new (ret) value_type(t1, t2, t3, t4, t5, t6, t7, t8); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } iterator insert(const T &t) { if (free_list == NULL) allocate_new_block(); pointer ret = free_list; free_list = clean_pointee(ret); alloc.construct(ret, t); CGAL_assertion(type(ret) == USED); ++size_; return iterator(ret, 0); } template < class InputIterator > void insert(InputIterator first, InputIterator last) { for (; first != last; ++first) insert(*first); } template < class InputIterator > void assign(InputIterator first, InputIterator last) { clear(); // erase(begin(), end()); // ? insert(first, last); } void erase(iterator x) { CGAL_precondition(type(&*x) == USED); alloc.destroy(&*x); put_on_free_list(&*x); --size_; } void erase(iterator first, iterator last) { for (; first != last; ++first) erase(first); } void clear(); // Merge the content of d into *this. d gets cleared. // The complexity is O(size(free list = capacity-size)). void merge(Self &d); size_type size() const { CGAL_expensive_assertion(size_ == (size_type) std::distance(begin(), end())); return size_; } size_type max_size() const { return alloc.max_size(); } size_type capacity() const { return capacity_; } void reserve(size_type n); // TODO // void resize(size_type sz, T c = T()); // TODO makes sense ??? bool empty() const { return size_ == 0; } allocator_type get_allocator() const { return alloc; } private: void allocate_new_block(); void put_on_free_list(pointer x) { set_type(x, free_list, FREE); free_list = x; } // Definition of the bit squatting : // ================================= // ptr is composed of a pointer part and the last 2 bits. // Here is the meaning of each of the 8 cases. // // value of the last 2 bits // pointer part 0 1 2 3 // NULL user elt unused free_list end start/end // != NULL user elt block boundary free elt unused // // meaning of ptr : user stuff next/prev block free_list unused enum Type { USED = 0, BLOCK_BOUNDARY = 1, FREE = 2, START_END = 3 }; // Using a union is clean and should avoid aliasing problems. union menion { void * p; unsigned int t:2; menion(void * ptr) : p(ptr) {} menion(void * ptr, Type type) : p(ptr) { CGAL_precondition(0 <= type && type < 4); t = type; } }; // Returns the pointee, cleaned from the squatted bits (the last 2 bits). static pointer clean_pointee(const_pointer ptr) { return (pointer) menion(Traits::pointer(*ptr), USED).p; } // Get the type of the pointee. static Type type(const_pointer ptr) { menion me(Traits::pointer(*ptr)); return (Type) me.t; } // Sets the pointer part and the type of the pointee. static void set_type(pointer ptr, void * p, Type t) { Traits::pointer(*ptr) = menion(p, t).p; } void init() { block_size = 14; capacity_ = 0; size_ = 0; free_list = NULL; first_item = NULL; last_item = NULL; } allocator_type alloc; size_type capacity_; size_type size_; size_type block_size; pointer free_list; pointer first_item; pointer last_item; }; template < class T, class Allocator > void Compact_container::merge(Self &d) { CGAL_precondition(&d != this); // Allocators must be "compatible" : CGAL_precondition(get_allocator() == d.get_allocator()); // Concatenate the free_lists. if (free_list == NULL) { free_list = d.free_list; } else if (d.free_list != NULL) { pointer p = free_list; while (clean_pointee(p) != NULL) p = clean_pointee(p); set_type(p, d.free_list, FREE); } // Concatenate the blocks. if (last_item == NULL) { // empty... first_item = d.first_item; last_item = d.last_item; } else if (d.last_item != NULL) { set_type(last_item, d.first_item, BLOCK_BOUNDARY); set_type(d.first_item, last_item, BLOCK_BOUNDARY); last_item = d.last_item; } // Add the sizes. size_ += d.size_; // Add the capacities. capacity_ += d.capacity_; // It seems reasonnable to take the max of the block sizes. block_size = std::max(block_size, d.block_size); // Clear d. d.init(); } template < class T, class Allocator > void Compact_container::clear() { // erase(begin(), end()); // nicer, but doesn't free memory. pointer p = first_item; while (p != NULL) { // catches the empty container case. ++p; if (type(p) == USED) alloc.destroy(p); // destroy used elements else if (type(p) == BLOCK_BOUNDARY || type(p) == START_END) { const_pointer end = p; p = clean_pointee(p); // p becomes NULL if end of block alloc.deallocate(first_item, end - first_item + 1); capacity_ -= end - first_item -1; first_item = p; // keep pointer to begining of current block. } }; CGAL_assertion(capacity_==0); init(); } template < class T, class Allocator > void Compact_container::allocate_new_block() { pointer new_block = alloc.allocate(block_size + 2); capacity_ += block_size; // We don't touch the first and the last one. // We mark them free in reverse order, so that the insertion order // will correspond to the iterator order... for (size_type i = block_size; i >= 1; --i) put_on_free_list(new_block + i); // We insert this new block at the end. if (last_item == NULL) // First time { first_item = new_block; last_item = new_block + block_size + 1; set_type(first_item, NULL, START_END); set_type(last_item, NULL, START_END); } else { set_type(last_item, new_block, BLOCK_BOUNDARY); set_type(new_block, last_item, BLOCK_BOUNDARY); last_item = new_block + block_size + 1; set_type(last_item, NULL, START_END); } // Increase the block_size for the next time. block_size += 16; } template < class T, class Allocator > inline bool operator==(const Compact_container &lhs, const Compact_container &rhs) { return lhs.size() == rhs.size() && std::equal(lhs.begin(), lhs.end(), rhs.begin()); } template < class T, class Allocator > inline bool operator!=(const Compact_container &lhs, const Compact_container &rhs) { return ! (lhs == rhs); } template < class T, class Allocator > inline bool operator< (const Compact_container &lhs, const Compact_container &rhs) { return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end()); } template < class T, class Allocator > inline bool operator> (const Compact_container &lhs, const Compact_container &rhs) { return rhs < lhs; } template < class T, class Allocator > inline bool operator<=(const Compact_container &lhs, const Compact_container &rhs) { return ! (lhs > rhs); } template < class T, class Allocator > inline bool operator>=(const Compact_container &lhs, const Compact_container &rhs) { return ! (lhs < rhs); } namespace CGALi { // This template metaprogramming bit should move from here. // Select::Type is (b?T1:T2). template < bool, typename, typename > struct Select; template < typename T1, typename T2 > struct Select { typedef T1 Type; }; template < typename T1, typename T2 > struct Select { typedef T2 Type; }; template < class DSC, bool Const > class CC_iterator { typedef typename DSC::iterator iterator; typedef CC_iterator Self; public: typedef typename DSC::value_type value_type; typedef typename DSC::size_type size_type; typedef typename DSC::difference_type difference_type; typedef typename Select::Type pointer; typedef typename Select::Type reference; typedef std::bidirectional_iterator_tag iterator_category; // the initialization with NULL is required by our Handle concept. CC_iterator() : p(NULL) {} // Either a harmless copy-ctor, // or a conversion from iterator to const_iterator. CC_iterator(const iterator &it) : p(&*it) {} // Same for assignment operator (otherwise MipsPro warns) CC_iterator & operator=(const iterator &it) { p = it.p; return *this; } // Construction from NULL CC_iterator(CGAL_NULL_TYPE CGAL_assertion_code(n)) : p(NULL) { CGAL_assertion( n == NULL); } private: pointer p; // Only Compact_container should access these constructors. friend class Compact_container; // For begin() CC_iterator(pointer ptr, int, int) : p(ptr) { if (p == NULL) // empty container. return; ++p; // if not empty, p = start if (DSC::type(p) == DSC::FREE) increment(); } // Construction from raw pointer and for end(). CC_iterator(pointer ptr, int) : p(ptr) {} // NB : in case empty container, begin == end == NULL. void increment() { // It's either pointing to end(), or valid. CGAL_assertion_msg(p != NULL, "Doing ++ on empty container iterator ?"); CGAL_assertion_msg(DSC::type(p) != DSC::START_END, "Doing ++ on end() ?"); // If it's not end(), then it's valid, we can do ++. do { ++p; if (DSC::type(p) == DSC::USED || DSC::type(p) == DSC::START_END) return; if (DSC::type(p) == DSC::BLOCK_BOUNDARY) p = DSC::clean_pointee(p); } while (true); } void decrement() { // It's either pointing to end(), or valid. CGAL_assertion_msg(p != NULL, "Doing -- on empty container iterator ?"); CGAL_assertion_msg(DSC::type(p-1) != DSC::START_END, "Doing -- on begin() ?"); // If it's not begin(), then it's valid, we can do --. do { --p; if (DSC::type(p) == DSC::USED || DSC::type(p) == DSC::START_END) return; if (DSC::type(p) == DSC::BLOCK_BOUNDARY) p = DSC::clean_pointee(p); } while (true); } public: Self & operator++() { increment(); return *this; } Self & operator--() { decrement(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } reference operator*() const { return *p; } pointer operator->() const { return p; } // For std::less... bool operator<(const CC_iterator& other) const { return p < other.p; } // Can itself be used for bit-squatting. void * for_compact_container() const { return (void *) p; } void * & for_compact_container() { return (void * &) p; } }; #if defined(__GNUG__) && __GNUG__==2 && __GNUC_MINOR__==95 // G++ 2.95 has loosy namespace support, // and this produces conflicts with std::rel_ops... template < class DSC, bool Const > inline bool operator==(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs == &*lhs; } template < class DSC > inline bool operator==(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs == &*lhs; } template < class DSC > inline bool operator==(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs == &*lhs; } template < class DSC, bool Const > inline bool operator!=(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs != &*lhs; } template < class DSC > inline bool operator!=(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs != &*lhs; } template < class DSC > inline bool operator!=(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs != &*lhs; } template < class DSC, bool Const > inline bool operator==(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs == NULL; } template < class DSC > inline bool operator==(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs == NULL; } template < class DSC > inline bool operator==(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs == NULL; } template < class DSC, bool Const > inline bool operator!=(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs != NULL; } template < class DSC > inline bool operator!=(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs != NULL; } template < class DSC > inline bool operator!=(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs != NULL; } #else template < class DSC, bool Const1, bool Const2 > inline bool operator==(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs == &*lhs; } template < class DSC, bool Const1, bool Const2 > inline bool operator!=(const CC_iterator &rhs, const CC_iterator &lhs) { return &*rhs != &*lhs; } template < class DSC, bool Const > inline bool operator==(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs == NULL; } template < class DSC, bool Const > inline bool operator!=(const CC_iterator &rhs, CGAL_NULL_TYPE CGAL_assertion_code(n)) { CGAL_assertion( n == NULL); return &*rhs != NULL; } #endif } // namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_COMPACT_CONTAINER_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Ray_2_inters0000644000175000017500000000223311344301500031206 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/0000755000175000017500000000000012146213727026112 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_items.h0000644000175000017500000002317511344301501027776 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_items.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner // Peter Hachenberger #ifndef CGAL_SM_ITEMS_H #define CGAL_SM_ITEMS_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE //template class Sphere_map; template class SM_const_decorator; template class SM_decorator; struct SM_items { public: template class SVertex { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Sphere_point Sphere_point; typedef typename Refs::SVertex_handle SVertex_handle; typedef typename Refs::SHalfedge_handle SHalfedge_handle; typedef typename Refs::SFace_handle SFace_handle; Sphere_point point_; Mark mark_; SHalfedge_handle out_sedge_; SFace_handle incident_sface_; GenPtr info_; // temporary information: public: SVertex() : point_(), mark_(), out_sedge_(), incident_sface_(), info_() {} SVertex(const Mark& m) : point_(), mark_(m), out_sedge_(), incident_sface_(), info_() {} SVertex(const Sphere_point& p) : point_(p), mark_(), out_sedge_(), incident_sface_(), info_() {} ~SVertex() {} SVertex(const SVertex& v) { point_ = v.point_; mark_ = v.mark_; out_sedge_ = v.out_sedge_; incident_sface_ = v.incident_sface_; info_ = 0; } SVertex& operator=(const SVertex& v) { point_ = v.point_; mark_ = v.mark_; out_sedge_ = v.out_sedge_; incident_sface_ = v.incident_sface_; info_ = 0; return *this; } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } Sphere_point& point(){ return point_; } const Sphere_point& point() const { return point_; } SHalfedge_handle& out_sedge() { return out_sedge_; } SHalfedge_handle out_sedge() const { return out_sedge_; } SFace_handle& incident_sface() { return incident_sface_; } SFace_handle incident_sface() const { return incident_sface_; } bool is_isolated() const { return (out_sedge() == SHalfedge_handle()); } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } public: std::string debug() const { std::ostringstream os; set_pretty_mode(os); os<<"V"< class SHalfedge { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Sphere_circle Sphere_circle; typedef typename Refs::SVertex_handle SVertex_handle; typedef typename Refs::SHalfedge_handle SHalfedge_handle; typedef typename Refs::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Refs::SFace_handle SFace_handle; // Role within local graph: Sphere_circle circle_; Mark mark_; SHalfedge_handle twin_, sprev_, snext_; SVertex_handle source_; SFace_handle incident_sface_; GenPtr info_; public: SHalfedge() : circle_(), mark_(), twin_(), sprev_(), snext_(), source_(), incident_sface_(), info_() {} ~SHalfedge() {} SHalfedge(const SHalfedge& e) { circle_ = e.circle_; mark_ = e.mark_; twin_ = e.twin_; sprev_ = e.sprev_; snext_ = e.snext_; source_ = e.source_; incident_sface_ = e.incident_sface_; info_ = 0; } SHalfedge& operator=(const SHalfedge& e) { circle_ = e.circle_; mark_ = e.mark_; twin_ = e.twin_; sprev_ = e.sprev_; snext_ = e.snext_; source_ = e.source_; incident_sface_ = e.incident_sface_; info_ = 0; return *this; } bool is_twin() const { return (&*twin_ < this); } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } SHalfedge_handle& twin() { return twin_; } SHalfedge_handle twin() const { return twin_; } SVertex_handle& source() { return source_; } SVertex_handle source() const { return source_; } SVertex_handle& target() { return twin()->source(); } SVertex_handle target() const { return twin()->source(); } SHalfedge_handle& sprev() { return sprev_; } SHalfedge_handle sprev() const { return sprev_; } SHalfedge_handle& snext() { return snext_; } SHalfedge_handle snext() const { return snext_; } Sphere_circle& circle() { return circle_; } const Sphere_circle& circle() const { return circle_; } SFace_handle& incident_sface() { return incident_sface_; } SFace_handle incident_sface() const { return incident_sface_; } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } std::string debug() const { std::ostringstream os; set_pretty_mode(os); os <<"e["<debug()<<", " <source_->debug()<<" "< class SHalfloop { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Sphere_circle Sphere_circle; typedef typename Refs::SHalfloop_handle SHalfloop_handle; typedef typename Refs::SFace_handle SFace_handle; Sphere_circle circle_; Mark mark_; SHalfloop_handle twin_; SFace_handle incident_sface_; GenPtr info_; // temporary needed: public: SHalfloop() : circle_(), mark_(), twin_(), incident_sface_(), info_() {} ~SHalfloop() {} SHalfloop(const SHalfloop& l) { circle_ = l.circle_; mark_ = l.mark_; twin_ = l.twin_; incident_sface_ = l.incident_sface_; info_ = 0; } SHalfloop& operator=(const SHalfloop& l) { circle_ = l.circle_; mark_ = l.mark_; twin_ = l.twin_; incident_sface_ = l.incident_sface_; info_ = 0; return *this; } bool is_twin() const { return (&*twin_ < this); } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } SHalfloop_handle& twin() { return twin_; } SHalfloop_handle twin() const { return twin_; } Sphere_circle& circle() { return circle_; } const Sphere_circle& circle() const { return circle_; } SFace_handle& incident_sface() { return incident_sface_; } SFace_handle incident_sface() const { return incident_sface_; } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } std::string debug() const { std::ostringstream os; set_pretty_mode(os); os<<"l"< class SFace { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Object_handle Object_handle; typedef typename Refs::Object_list Object_list; typedef typename Refs::SFace_cycle_iterator SFace_cycle_iterator; typedef typename Refs::SFace_cycle_const_iterator SFace_cycle_const_iterator; Mark mark_; Object_list boundary_entry_objects_; // SHalfedges, SHalfloops, Vertices GenPtr info_; // temporary needed: public: SFace() : mark_(), info_() {} ~SFace() {} SFace(const SFace& f) { mark_ = f.mark_; boundary_entry_objects_ = f.boundary_entry_objects_; info_ = 0; } SFace& operator=(const SFace& f) { if (this == &f) return *this; mark_ = f.mark_; boundary_entry_objects_ = f.boundary_entry_objects_; info_ = 0; return *this; } SFace_cycle_iterator sface_cycles_begin() { return boundary_entry_objects_.begin(); } SFace_cycle_iterator sface_cycles_end() { return boundary_entry_objects_.end(); } SFace_cycle_const_iterator sface_cycles_begin() const { return boundary_entry_objects_.begin(); } SFace_cycle_const_iterator sface_cycles_end() const { return boundary_entry_objects_.end(); } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } Object_list& boundary_entry_objects() { return boundary_entry_objects_; } const Object_list& boundary_entry_objects() const { return boundary_entry_objects_; } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } }; // SFace }; // SM_items CGAL_END_NAMESPACE #endif // CGAL_SM_ITEMS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_circle.h0000644000175000017500000001345511344301501031025 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_circle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_CIRCLE_H #define CGAL_SPHERE_CIRCLE_H #include CGAL_BEGIN_NAMESPACE template class Sphere_segment; /*{\Manpage{Sphere_circle}{R}{Great circles on the unit sphere}{c}}*/ template class Sphere_circle : public R_::Plane_3 { /*{\Mdefinition An object |\Mvar| of type |\Mname| is an oriented great circle on the surface of a unit sphere. Such circles correspond to the intersection of an oriented plane (that contains the origin) and the surface of $S_2$. The orientation of the great circle is that of a counterclockwise walk along the circle as seen from the positive halfspace of the oriented plane.}*/ public: /*{\Mtypes 5}*/ typedef R_ R; /*{\Mtypemember representation class.}*/ typedef typename R::RT RT; /*{\Mtypemember ring type.}*/ typedef std::pair< Sphere_segment,Sphere_segment > Sphere_segment_pair; /*{\Mtypemember sphere segment pair.}*/ typedef typename R_::Plane_3 Plane_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Point_3 Point_3; typedef Sphere_circle Self; typedef typename R_::Plane_3 Base; /*{\Mcreation 5}*/ Sphere_circle() : Base() {} /*{\Mcreate creates some great circle.}*/ Sphere_circle(const Sphere_point& p, const Sphere_point&q) : Base(Point_3(0,0,0),p,q) /*{\Mcreate creates a great circle through $p$ and $q$. If $p$ and $q$ are not antipodal on $S_2$, then this circle is unique and oriented such that a walk along |\Mvar| meets $p$ just before the shorter segment between $p$ and $q$. If $p$ and $q$ are antipodal of each other then we create any great circle that contains $p$ and $q$.}*/ { Point_3 p1(0,0,0), p4 = CGAL::ORIGIN + ((Base*) this)->orthogonal_vector(); if ( p != q.antipode() ) { if ( CGAL::orientation(p1,p,q,p4) != CGAL::POSITIVE ) *this = Self(opposite()); } else { /* previous method was: *this = Self(Plane_3(p1,q-p)); but p, q don't belong to he plane ((0,0,0), q-p) */ if(!Line_3(p,q).has_on(Point_3(1,0,0))) *this = Self(Plane_3(p,q,Point_3(1,0,0))); else *this = Self(Plane_3(p,q,Point_3(0,1,0))); /* take one point that doesn't belong to the line (p, q-p) */ } } Sphere_circle(const Plane_3& h) : Base(h) /*{\Mcreate creates the circle of $S_2$ corresponding to the plane |h|. If |h| does not contain the origin, then |\Mvar| becomes the circle parallel to |h| containing the origin.}*/ { if(h.d() != 0) *this = Plane_3(h.a(),h.b(),h.c(),RT(0)); } Sphere_circle(const RT& x, const RT& y, const RT& z): Base(x,y,z,0) {} /*{\Mcreate creates the circle orthogonal to the vector $(x,y,z)$.}*/ Sphere_circle(Sphere_circle c, const Sphere_point& p) /*{\Mcreate creates a great circle orthogonal to $c$ that contains $p$. \precond $p$ is not part of $c$.}*/ { CGAL_assertion(!c.has_on(p)); if ( c.has_on_negative_side(p) ) c=c.opposite(); if ( p == c.orthogonal_pole() ) *this = Sphere_circle(Base(Point_3(0,0,0),p,CGAL::ORIGIN+c.base1())); else *this = Sphere_circle(Base(Point_3(0,0,0),p,c.orthogonal_pole())); } /*{\Moperations 4 2}*/ Sphere_circle opposite() const /*{\Mop returns the opposite of |\Mvar|.}*/ { return Base::opposite(); } bool has_on(const Sphere_point& p) const /*{\Mop returns true iff |\Mvar| contains |p|.}*/ { return Base::has_on(p); } Plane_3 plane() const { return Base(*this); } /*{\Mop returns the plane supporting |\Mvar|.}*/ Plane_3 plane_through(const Point_3& p) const /*{\Mop returns the plane parallel to |\Mvar| that contains point |p|.}*/ { return Plane_3(p,((Base*) this)->orthogonal_direction()); } Sphere_point orthogonal_pole() const /*{\Mop returns the point that is the pole of the hemisphere left of |\Mvar|.}*/ { return CGAL::ORIGIN+((Base*) this)->orthogonal_vector(); } Sphere_segment_pair split_at(const Sphere_point& p) const; /*{\Mop returns the pair of circle segments that is the result of splitting |\Mvar| at |p| and |p.antipode()|.}*/ Sphere_segment_pair split_at_xy_plane() const; /*{\Mop returns the pair of circle segments that is the result of splitting |\Mvar| at the $x$-$y$-coordinate plane if |\Mvar| is not part of it. Otherwise |\Mvar| is split at the $x$-$z$-coordinate plane.}*/ }; // Sphere_circle /*{\Mtext\headerline{Global functions}}*/ template bool equal_as_sets(const CGAL::Sphere_circle& c1, const CGAL::Sphere_circle& c2) /*{\Mfunc returns true iff |c1| and |c2| are equal as unoriented circles.}*/ { return c1==c2 || c1==c2.opposite(); } template Sphere_point intersection(const Sphere_circle& c1, const Sphere_circle& c2) /*{\Mfunc returns one of the two intersection points of |c1| and |c2|. \precond |c1 != c2| as sets.}*/ { CGAL_assertion(!equal_as_sets(c1,c2)); typename R::Line_3 lres; CGAL_NEF_TRACEN("circle_intersection "< // Miguel Granados // Susan Hert // Lutz Kettner // Peter Hachenberger #ifndef CGAL_SM_DECORATOR_H #define CGAL_SM_DECORATOR_H #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 23 #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*{\Moptions print_title=yes }*/ /*{\Moptions outfile=SM_decorator.man }*/ /*{\Manpage {SM_decorator}{Sphere_map} {Topological sphere map decorator}{D}}*/ template class SM_decorator { public: typedef Map_ Map; typedef Map_ Sphere_map; typedef SM_decorator Self; typedef SM_decorator_traits Decorator_traits; /*{\Mdefinition ...}*/ /*{\Mtypes 5}*/ typedef SM_const_decorator SM_const_decorator; typedef typename Map::Sphere_kernel Sphere_kernel; /*{\Mtypemember spherical geometry.}*/ typedef typename Map::Sphere_point Sphere_point; /*{\Mtypemember embedding vertices.}*/ typedef typename Map::Sphere_segment Sphere_segment; /*{\Mtypemember embedding edges.}*/ typedef typename Map::Sphere_circle Sphere_circle; /*{\Mtypemember embedding loops.}*/ typedef typename Map::Sphere_direction Sphere_direction; /*{\Mtypemember embedding directions.}*/ typedef typename Map::Mark Mark; /*{\Mtypemember attributes of objects (vertices, edges, faces).}*/ typedef size_t Size_type; /*{\Mtypemember size type.}*/ enum { BEFORE = -1, AFTER = 1 }; /*{\Menum insertion order labels.}*/ typedef typename Sphere_kernel::Aff_transformation_3 Aff_transformation_3; typedef void* GenPtr; typedef typename Map::SVertex SVertex; typedef typename Map::SVertex_handle SVertex_handle; typedef typename Map::SVertex_iterator SVertex_iterator; typedef typename Map::SVertex_const_handle SVertex_const_handle; typedef typename Map::SVertex_const_iterator SVertex_const_iterator; typedef typename Map::SHalfedge SHalfedge; typedef typename Map::SHalfedge_handle SHalfedge_handle; typedef typename Map::SHalfedge_iterator SHalfedge_iterator; typedef typename Map::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Map::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Map::SFace SFace; typedef typename Map::SFace_handle SFace_handle; typedef typename Map::SFace_iterator SFace_iterator; typedef typename Map::SFace_const_handle SFace_const_handle; typedef typename Map::SFace_const_iterator SFace_const_iterator; typedef typename Map::SHalfloop SHalfloop; typedef typename Map::SHalfloop_handle SHalfloop_handle; typedef typename Map::SHalfloop_iterator SHalfloop_iterator; typedef typename Map::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Map::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename Map::Object_handle Object_handle; typedef typename Map::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Map::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Map::SFace_cycle_iterator SFace_cycle_iterator; /*{\Mtypemember iterating all face cycles of an face |f|. The iterator has method |bool is_svertex()|, |bool is_shalfedge()|, |bool is_shalfloop()|, and can be converted to the corresponding handles |SVertex_handle|, |SHalfedge_handle|, or |SHalfloop_handle|.}*/ protected: Map* psm_; public: /*{\Mcreation 3}*/ SM_decorator() : psm_(0) {} SM_decorator(const Self& D) : psm_(D.psm_) {} Self& operator=(const Self& D) { psm_=D.psm_; return *this; } SM_decorator(Map* M) : psm_(M) {} /*{\Moperations 4 4}*/ Map* sphere_map() const { return psm_; } Map* map() { return psm_; } const Map* map() const { return psm_; } SVertex_const_handle source(SHalfedge_const_handle e) const { return e->source(); } SVertex_const_handle target(SHalfedge_const_handle e) const { return e->twin()->source(); } SHalfedge_const_handle twin(SHalfedge_const_handle e) const { return e->twin(); } SHalfloop_const_handle twin(SHalfloop_const_handle l) const { return l->twin(); } SVertex_handle source(SHalfedge_handle e) const /*{\Mop returns the source of |e|.}*/ { return e->source(); } SVertex_handle target(SHalfedge_handle e) const /*{\Mop returns the target of |e|.}*/ { return e->twin()->source(); } SHalfedge_handle twin(SHalfedge_handle e) const /*{\Mop returns the twin of |e|.}*/ { return e->twin(); } SHalfloop_handle twin(SHalfloop_handle l) const /*{\Mop returns the twin of |l|.}*/ { return l->twin(); } bool is_isolated(SVertex_const_handle v) const { return (v->out_sedge() == SHalfedge_handle()); } bool is_isolated(SVertex_handle v) const /*{\Mop returns |true| when |v| is linked to the interior of a face.}*/ { return (v->out_sedge() == SHalfedge_handle()); } SHalfedge_const_handle first_out_edge(SVertex_const_handle v) const { return v->out_sedge(); } SHalfedge_const_handle last_out_edge(SVertex_const_handle v) const { return cap(v->out_sedge()); } SHalfedge_handle first_out_edge(SVertex_handle v) const /*{\Mop returns one edge with source |v|. It's the starting point for the circular iteration over the edges with source |v|. \precond |!is_isolated(v)|.}*/ { return v->out_sedge(); } SHalfedge_handle last_out_edge(SVertex_handle v) const /*{\Mop returns one edge with source |v|. \precond |!is_isolated(v)|.}*/ { return cap(v->out_sedge()); } SHalfedge_const_handle cyclic_adj_succ(SHalfedge_const_handle e) const { return e->sprev()->twin(); } SHalfedge_const_handle cyclic_adj_pred(SHalfedge_const_handle e) const { return e->twin()->snext(); } SHalfedge_handle cyclic_adj_succ(SHalfedge_handle e) const /*{\Mop returns the edge after |e| in the cyclic ordered adjacency list of |source(e)|.}*/ { return e->sprev()->twin(); } SHalfedge_handle cyclic_adj_pred(SHalfedge_handle e) const /*{\Mop returns the edge before |e| in the cyclic ordered adjacency list of |source(e)|.}*/ { return e->twin()->snext(); } SHalfedge_const_handle next(SHalfedge_const_handle e) const { return e->snext(); } SHalfedge_const_handle previous(SHalfedge_const_handle e) const { return e->sprev(); } SHalfedge_handle next(SHalfedge_handle e) const /*{\Mop returns the next edge in the face cycle containing |e|.}*/ { return e->snext(); } SHalfedge_handle previous(SHalfedge_handle e) const /*{\Mop returns the previous edge in the face cycle containing |e|.}*/ { return e->sprev(); } SFace_const_handle face(SHalfedge_const_handle e) const { return e->incident_sface(); } SFace_const_handle face(SHalfloop_const_handle l) const { return l->incident_sface(); } SFace_const_handle face(SVertex_const_handle v) const { return v->incident_sface(); } SFace_handle face(SHalfedge_handle e) const /*{\Mop returns the face incident to |e|.}*/ { return e->incident_sface(); } SFace_handle face(SHalfloop_handle l) const /*{\Mop returns the face incident to |l|.}*/ { return l->incident_sface(); } SFace_handle face(SVertex_handle v) const /*{\Mop returns the face incident to |v|. \precond |is_isolated(v)|.}*/ { return v->incident_sface(); } bool has_shalfloop() const /*{\Mop returns true iff there is a loop.}*/ { return psm_->has_shalfloop(); } /*{\Mtext \headerline{Iteration} \setopdims{3.3cm}{0cm}}*/ SVertex_iterator svertices_begin() const { return psm_->svertices_begin(); } SVertex_iterator svertices_end() const { return psm_->svertices_end(); } SHalfedge_iterator shalfedges_begin() const { return psm_->shalfedges_begin(); } SHalfedge_iterator shalfedges_end() const { return psm_->shalfedges_end(); } SFace_iterator sfaces_begin() const { return psm_->sfaces_begin(); } SFace_iterator sfaces_end() const { return psm_->sfaces_end(); } SHalfloop_iterator shalfloops_begin() const { return psm_->shalfloops_begin(); } SHalfloop_iterator shalfloops_end() const { return psm_->shalfloops_end(); } SHalfloop_handle shalfloop() const { return psm_->shalfloop(); } Size_type number_of_svertices() const /*{\Mop returns the number of vertices.}*/ { return psm_->number_of_svertices(); } Size_type number_of_shalfedges() const /*{\Mop returns the number of halfedges.}*/ { return psm_->number_of_shalfedges(); } Size_type number_of_sedges() const /*{\Mop returns the number of edges.}*/ { return number_of_shalfedges()/2; } Size_type number_of_shalfloops() const /*{\Mop returns the number of halfloops.}*/ { return psm_->number_of_shalfloops(); } Size_type number_of_sloops() const /*{\Mop returns the number of loops.}*/ { return psm_->number_of_shalfloops()/2; } Size_type number_of_sfaces() const /*{\Mop returns the number of faces.}*/ { return psm_->number_of_sfaces(); } SFace_cycle_iterator sface_cycles_begin(SFace_handle f) const /*{\Mop returns an iterator for all bounding face cycles of |f|. The iterator is is convertable to |SVertex_handle|, |SHalfloop_handle|, or |SHalfedge_handle|.}*/ { return f->boundary_entry_objects().begin(); } SFace_cycle_iterator sface_cycles_end(SFace_handle f) const /*{\Mop returns the past the end iterator of |f|.}*/ { return f->boundary_entry_objects_.end(); } SHalfedge_around_svertex_circulator out_edges(SVertex_handle v) const /*{\Mop returns a circulator for the cyclic adjacency list of |v|. \precond the adjacency list is not empty.}*/ { return SHalfedge_around_svertex_circulator(first_out_edge(v)); } /*{\Mtext \headerline{Update Operations}}*/ void clear() const /*{\Mop reintializes |P| to the empty map.}*/ { psm_->clear(); } bool is_closed_at_source(SHalfedge_handle e) const /*{\Mop returns |true| when |prev(e) == twin(e)|.}*/ { return previous(e) == twin(e); } bool is_closed_at_target(SHalfedge_handle e) const /*{\Mop returns |true| when |next(e) == twin(e)|.}*/ { return next(e) == twin(e); } SHalfedge_handle cas(SHalfedge_handle e) const { return cyclic_adj_succ(e); } SHalfedge_handle cap(SHalfedge_handle e) const { return cyclic_adj_pred(e); } template void make_twins(H h1, H h2) const { h1->twin() = h2; h2->twin() = h1; } SVertex_handle new_svertex(const Sphere_point& p = Sphere_point()) /*{\Mop creates a new vertex.}*/ { return map()->new_svertex(p); } SHalfedge_handle new_shalfedge_pair() { /*{\Xop creates a new edge pair. No connectivity is provided.}*/ return map()->new_shalfedge_pair(); } SHalfloop_handle new_shalfloop_pair() /*{\Mop creates a new loop pair. \precond No sloop pair exists in the local graph.}*/ { CGAL_assertion(!has_shalfloop()); return map()->new_shalfloop_pair(); } SFace_handle new_sface() /*{\Mop creates a new face.}*/ { return map()->new_sface(); } void delete_vertex_only(SVertex_handle v) /*{\Mop deletes |v| without any connectivity update.}*/ { map()->delete_svertex(v); } void delete_edge_pair_only(SHalfedge_handle e) /*{\Mop deletes |e| and its twin without any connectivity update.}*/ { map()->delete_shalfedge_pair(e); } void delete_halfedge_only(SHalfedge_handle e) /*{\Mop deletes |e| without its twin and without any connectivity update.}*/ { map()->delete_shalfedge(e); } void delete_face_only(SFace_handle f) /*{\Mop deletes |f| without any connectivity update.}*/ { map()->delete_sface(f); } void delete_loop_only() /*{\Mop deletes the loop and its twin without any connectivity update.}*/ { map()->delete_shalfloop_pair(); } template bool is_sm_boundary_object(H h) const { return map()->is_sm_boundary_object(h); } template void store_sm_boundary_object(H h, SFace_handle f) { CGAL_assertion(!map()->is_sm_boundary_object(h)); f->boundary_entry_objects().push_back(Object_handle(h)); map()->store_sm_boundary_item(h, --(f->sface_cycles_end())); } template void undo_sm_boundary_object(H h, SFace_handle f) { CGAL_assertion(map()->is_sm_boundary_object(h)); SFace_cycle_iterator it = map()->sm_boundary_item(h); map()->undef_sm_boundary_item(h); f->boundary_entry_objects().erase(it); } void link_as_face_cycle(SHalfedge_handle e, SFace_handle f) /*{\Mop creates a new face cycle of |f| and makes |e| the entry point of it.}*/ { SHalfedge_around_sface_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) hfc->incident_sface() = f; store_sm_boundary_object(e,f); } void link_as_loop(SHalfloop_handle l, SFace_handle f) /*{\Mop creates a new trivial face cycle of |f| and makes |l| the singular object of it.}*/ { store_sm_boundary_object(l,f); l->incident_sface() = f; } void link_as_isolated_vertex(SVertex_handle v, SFace_handle f) /*{\Mop creates a new trivial face cycle of |f|. (makes |v| an isolated vertex within |f|).}*/ { store_sm_boundary_object(v,f); v->incident_sface() = f; } void unlink_as_face_cycle(SHalfedge_handle e) /*{\Mop removes the face cycle defined by |e| from |face(e)|. Does not update the face links of the corresponding face cycle edges. \precond |e| is the entry object of the face cycle.}*/ { undo_sm_boundary_object(e,face(e)); } void unlink_as_loop(SHalfloop_handle l) /*{\Mop removes the trivial face cycle defined by |l| from |face(l)|. Does not update |l|'s face link.}*/ { undo_sm_boundary_object(l,face(l)); } void unlink_as_isolated_vertex(SVertex_handle v) /*{\Mop removes the trivial face cycle defined by |v| from |face(v)|. Does not update |v|'s face link. \precond |v| is a trivial face cycle of |face(v)|.}*/ { undo_sm_boundary_object(v,face(v)); } void clear_face_cycle_entries(SFace_handle f) { map()->reset_sm_object_list(f->boundary_entry_objects()); // removes entries of list and the hashed membership } SHalfedge_handle new_shalfedge_pair(SVertex_handle v1, SVertex_handle v2) /*{\Mop creates a new pair of edges |(e1,e2)| representing |(v1,v2)| by appending the |ei| to |A(vi)| $(i=1,2)$.}*/ { SHalfedge_handle e1 = new_shalfedge_pair(); SHalfedge_handle e2 = twin(e1); if (!is_isolated(v1)) set_adjacency_at_source_between(cap(first_out_edge(v1)),e1, first_out_edge(v1)); else close_tip_at_source(e1,v1); if (!is_isolated(v2)) set_adjacency_at_source_between(cap(first_out_edge(v2)),e2, first_out_edge(v2)); else close_tip_at_source(e2,v2); return e1; } SHalfedge_handle new_shalfedge_pair(SHalfedge_handle e1, SHalfedge_handle e2, int pos1 = AFTER, int pos2 = AFTER) /*{\Mop creates a new pair of edges |(es1,es2)| representing the uedge |\{source(e1),source(e2)\}| by inserting the |esi| before or after |ei| into the cyclic adjacency list of |source(ei)| depending on |posi| $(i=1,2)$ from |\Mname::BEFORE|, |\Mname::AFTER|.}*/ { SHalfedge_handle er = new_shalfedge_pair(); SHalfedge_handle ero = twin(er); if (pos1 < 0) { // before e1 set_adjacency_at_source_between(cap(e1),er,e1); if ( e1 == first_out_edge(source(e1)) ) set_first_out_edge(source(e1),er); } else { // after e1 set_adjacency_at_source_between(e1,er,cas(e1)); } if (pos2 < 0) { // before e2 set_adjacency_at_source_between(cap(e2),ero,e2); if ( e2 == first_out_edge(source(e2)) ) set_first_out_edge(source(e2),ero); } else { // after e2 set_adjacency_at_source_between(e2,ero,cas(e2)); } return er; } SHalfedge_handle new_shalfedge_pair(SHalfedge_handle e, SVertex_handle v, int pos = AFTER) /*{\Mop creates a new pair of edges |(e1,e2)| representing the uedge |\{source(e),v\}| by inserting |e1| before or after |e| into cyclic adjacency list of |source(e)| depending on |pos| from |\Mname::BEFORE|, |\Mname::AFTER| and appending |e2| at |A(v)|.}*/ { SHalfedge_handle e_new = new_shalfedge_pair(); SHalfedge_handle e_opp = twin(e_new); if (pos < 0) { // before e set_adjacency_at_source_between(cap(e),e_new,e); if ( e == first_out_edge(source(e)) ) set_first_out_edge(source(e),e_new); } else // after e set_adjacency_at_source_between(e,e_new,cas(e)); if (!is_isolated(v)) { SHalfedge_handle e_first = first_out_edge(v); set_adjacency_at_source_between(cap(e_first),e_opp,e_first); } else close_tip_at_source(e_opp,v); return e_new; } SHalfedge_handle new_shalfedge_pair(SVertex_handle v, SHalfedge_handle e, int pos = AFTER) /*{\Mop symmetric to the previous one.}*/ { return twin(new_shalfedge_pair(e,v,pos)); } void delete_edge_pair(SHalfedge_handle e) /*{\Mop deletes |e| and its twin and maintains the adjacency at its source and its target.}*/ { remove_from_adj_list_at_source(e); remove_from_adj_list_at_source(twin(e)); delete_edge_pair_only(e); } void delete_vertex(SVertex_handle v) /*{\Mop deletes |v| and all outgoing edges |A(v)| as well as their twins. Updates the adjacency at the targets of the edges in |A(v)|.}*/ { if (!is_isolated(v)) { SHalfedge_handle e = first_out_edge(v); while ( e != cap(e) ) delete_edge_pair(cap(e)); delete_edge_pair(e); } delete_vertex_only(v); } void delete_face(SFace_handle f) /*{\Mop deletes the face |f| without consideration of topological linkage.}*/ { clear_face_cycle_entries(f); delete_face_only(f); } bool has_outdeg_two(SVertex_handle v) const /*{\Mop return true when |v| has outdegree two.}*/ // does this work for looping edges? { if (is_isolated(v)) return false; SHalfedge_handle e1 = first_out_edge(v); SHalfedge_handle e2 = last_out_edge(v); return (e1!=e2 && e2==cas(e1)); } void link_as_prev_next_pair(SHalfedge_handle e1, SHalfedge_handle e2) /*{\Xop makes |e1| and |e2| adjacent in the face cycle $\ldots-|e1-e2|-\ldots$. Afterwards |e1 = previous(e2)| and |e2 = next(e1)|.}*/ { e1->snext() = e2; e2->sprev() = e1; } void merge_edge_pairs_at_target(SHalfedge_handle e) /*{\Mop merges the edge pairs at |v = target(e)|. |e| and |twin(e)| are preserved, |next(e)|, |twin(next(e))| and |v| are deleted in the merger. \precond |v| has outdegree two. The adjacency at |source(e)| and |target(next(e))| is kept consistent. If |next(e)| was entry point of |face(e)| then |e| takes this role. The same holds for |twin(next(e))| and |face(twin(e))|.}*/ { CGAL_NEF_TRACEN("merge_edge_pairs_at_target "<source() = vn; if ( first_out_edge(vn) == eno ) set_first_out_edge(vn,eo); if ( is_sm_boundary_object(en) ) { undo_sm_boundary_object(en,f1); store_sm_boundary_object(e,f1); } if ( is_sm_boundary_object(eno) ) { undo_sm_boundary_object(eno,f2); store_sm_boundary_object(eo,f2); } delete_vertex_only(v); delete_edge_pair_only(en); CGAL_NEF_TRACEN("END "<source() = v; if (v->out_sedge() == SHalfedge_handle()) v->out_sedge() = e; } void link_as_target_of(SHalfedge_handle e, SVertex_handle v) const /*{\Mop makes |target(e) = v| and sets |e| as the first in edge if |v| was isolated before.}*/ { link_as_source_of(twin(e),v); } void set_adjacency_at_source_between(SHalfedge_handle e, SHalfedge_handle en) /*{\Mop makes |e| and |en| neigbors in the cyclic ordered adjacency list around |v=source(e)|. \precond |source(e)==source(en)|.}*/ { CGAL_assertion(source(e)==source(en)); link_as_prev_next_pair(twin(en),e); } void set_adjacency_at_source_between(SHalfedge_handle e1, SHalfedge_handle e_between, SHalfedge_handle e2) /*{\Mop inserts |e_between| into the adjacency list around |source(e1)| between |e1| and |e2| and makes |source(e1)| the source of |e_between|. \precond |source(e1)==source(e2)|.}*/ { e_between->source() = source(e1); set_adjacency_at_source_between(e1,e_between); set_adjacency_at_source_between(e_between,e2); } void close_tip_at_source(SHalfedge_handle e, SVertex_handle v) /*{\Mop sets |v| as source of |e| and closes the tip by setting the corresponding pointers such that |prev(e) == twin(e)| and |next(twin(e)) == e|.}*/ { link_as_source_of(e,v); link_as_prev_next_pair(twin(e),e); } void close_tip_at_target(SHalfedge_handle e, SVertex_handle v) /*{\Mop sets |v| as target of |e| and closes the tip by setting the corresponding pointers such that |prev(twin(e)) == e| and |next(e) == twin(e)|.}*/ { link_as_target_of(e,v); link_as_prev_next_pair(e,twin(e)); } void remove_from_adj_list_at_source(SHalfedge_handle e) /*{\Mop removes a halfedge pair |(e,twin(e)| from the adjacency list of |source(e)|. Afterwards |next(prev(e))==next(twin(e))| and |first_out_edge(source(e))| is valid if |degree(source(v))>1| before the operation.}*/ { SVertex_handle v = source(e); if ( is_closed_at_source(e) ) { // last outgoing v->out_sedge() = SHalfedge_handle(); } else { if (e == first_out_edge(v)) v->out_sedge() = cap(e); set_adjacency_at_source_between(cap(e),cas(e)); } } void set_face(SHalfedge_handle e, SFace_handle f) const { e->incident_sface() = f; } void set_face(SHalfloop_handle l, SFace_handle f) const { l->incident_sface() = f; } void set_face(SVertex_handle v, SFace_handle f) const { v->incident_sface() = f; } void set_first_out_edge(SVertex_handle v, SHalfedge_handle e) const { v->out_sedge() = e; } void set_prev(SHalfedge_handle e, SHalfedge_handle ep) const { e->sprev() = ep; } void set_next(SHalfedge_handle e, SHalfedge_handle en) const { e->snext() = en; } void set_source(SHalfedge_handle e, SVertex_handle v) const { e->source() = v; } /*{\Mtext \headerline{Associated Information}\restoreopdims}*/ Sphere_point& point(SVertex_handle v) const /*{\Mop returns the embedding of |v|.}*/ { return v->point(); } Sphere_circle& circle(SHalfedge_handle e) const /*{\Mop returns the plane supporting |e|.}*/ { return e->circle(); } Sphere_circle& circle(SHalfloop_handle l) const /*{\Mop returns the plane supporting |e|.}*/ { return l->circle(); } Mark& mark(SVertex_handle v) const /*{\Mop returns the mark of |v|.}*/ { return v->mark(); } Mark& mark(SHalfedge_handle e) const /*{\Mop returns the mark of |e|.}*/ { return e->mark(); } Mark& mark(SHalfloop_handle l) const /*{\Mop returns the mark of |l|.}*/ { return l->mark(); } Mark& mark(SFace_handle f) const /*{\Mop returns the mark of |f|.}*/ { return f->mark(); } const Sphere_point& point(SVertex_const_handle v) const { return v->point(); } const Sphere_circle& circle(SHalfedge_const_handle e) const { return e->circle(); } const Sphere_circle& circle(SHalfloop_const_handle l) const { return l->circle(); } const Mark& mark(SVertex_const_handle v) const { return v->mark(); } const Mark& mark(SHalfedge_const_handle e) const { return e->mark(); } const Mark& mark(SHalfloop_const_handle l) const { return l->mark(); } const Mark& mark(SFace_const_handle f) const { return f->mark(); } void set_marks_in_face_cycle(SHalfedge_handle e, Mark m) const { SHalfedge_around_sface_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) mark(hfc) = mark(target(hfc)) = m; } GenPtr& info(SVertex_handle v) const { return v->info(); } GenPtr& info(SHalfedge_handle e) const { return e->info(); } GenPtr& info(SHalfloop_handle l) const { return l->info(); } GenPtr& info(SFace_handle f) const { return f->info(); } const GenPtr& info(SVertex_const_handle v) const { return v->info(); } const GenPtr& info(SHalfedge_const_handle e) const { return e->info(); } const GenPtr& info(SHalfloop_const_handle l) const { return l->info(); } const GenPtr& info(SFace_const_handle f) const { return f->info(); } /*{\Mtext \headerline{Iteration}}*/ /*{\Mtext The list of all objects can be accessed via iterator ranges. For comfortable iteration we also provide iterations macros. The iterator range access operations are of the following kind:\\ |SVertex_iterator svertices_begin()/svertices_end()|\\ |SHalfedge_iterator shalfedges_begin()/shalfedges_end()|\\ |SHalfedge_iterator sedges_begin()/sedges_end()|\\ |SFace_iterator sfaces_begin()/sfaces_end()| The macros are then |CGAL_forall_svertices_of(v,V)|, |CGAL_forall_shalfedges_of(e,V)|, |CGAL_forall_sedges_of(e,V)|, |CGAL_forall_sfaces_of(f,V)|, |CGAL_forall_sface_cycles_of(fc,F)|.}*/ void transform( const Aff_transformation_3& linear) { // CGAL_NEF_TRACEN("transform sphere map of vertex" << center_vertex()->point()); // The affine transformation is linear, i.e., no translation part. CGAL_precondition( linear.hm(0,3) == 0 && linear.hm(1,3) == 0 && linear.hm(2,3) == 0); // CGAL_NEF_TRACEN(linear); for (SVertex_iterator i = svertices_begin(); i != svertices_end(); ++i) point(i) = normalized(Sphere_point( point(i).transform( linear))); for (SHalfedge_iterator i = shalfedges_begin(); i !=shalfedges_end(); ++i) circle(i) = Sphere_circle( circle(i).transform( linear)); if ( has_shalfloop()) { circle(shalfloop()) = Sphere_circle(circle(shalfloop()) .transform( linear)); circle(twin(shalfloop())) = Sphere_circle(circle(twin(shalfloop())).transform( linear)); } } void extract_complement() { SVertex_handle sv; CGAL_forall_svertices(sv,*this) mark(sv) = !mark(sv); SHalfedge_handle she; CGAL_forall_shalfedges(she,*this) mark(she) = !mark(she); SHalfloop_handle shl; if(has_shalfloop()) { shl = shalfloop(); mark(shl) = mark(twin(shl)) = !mark(shl); } SFace_handle sf; CGAL_forall_sfaces(sf,*this) mark(sf) = !mark(sf); } void extract_interior() { SVertex_handle sv; CGAL_forall_svertices(sv,*this) mark(sv) = false; SHalfedge_handle she; CGAL_forall_shalfedges(she,*this) mark(she) = false; SHalfloop_handle shl; if(has_shalfloop()) { shl = shalfloop(); mark(shl) = mark(twin(shl)) = false; } } void extract_boundary() { SVertex_handle sv; CGAL_forall_svertices(sv,*this) mark(sv) = true; SHalfedge_handle she; CGAL_forall_shalfedges(she,*this) mark(she) = true; SHalfloop_handle shl; if(has_shalfloop()) { shl = shalfloop(); mark(shl) = mark(twin(shl)) = true; } SFace_handle sf; CGAL_forall_sfaces(sf,*this) mark(sf) = false; } bool is_valid( Unique_hash_map& sv_hash, Unique_hash_map& se_hash, Unique_hash_map& sf_hash, bool verb = false, int level = 0) { Verbose_ostream verr(verb); verr << "begin CGAL::SNC_SM_decorator<...>::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = true; int count = 0; int max = 2 * number_of_svertices() + 2 * number_of_shalfedges() + number_of_sfaces() + 2; SVertex_handle sv; int isolated_vertices_found = 0; CGAL_forall_svertices(sv,*this) { valid = valid && (!sv_hash[sv]); sv_hash[sv] = true; if(is_isolated(sv)) isolated_vertices_found++; valid = valid && (++count <= max); } SHalfedge_iterator she; CGAL_forall_shalfedges(she,*this) { valid = valid && she->is_valid(verb, level); valid = valid && (twin(she) != she); valid = valid && (twin(twin(she)) == she); valid = valid && (previous(next(she)) == she); valid = valid && ((previous(she) != she && next(she) != she) || (previous(she) == she && next(she) == she)); valid = valid && (face(she) == face(next(she))); valid = valid && (face(she) == face(previous(she))); valid = valid && (!se_hash[she]); // Plane_3 pl(point(source(she)),point(target(she)),Point_3(0,0,0)); // Sphere_point vct(pl.orthogonal_vector()); // valid = valid && (normalized(Sphere_point(circle(she).orthogonal_vector())) == normalized(vct) || // normalized(Sphere_point(circle(she).opposite().orthogonal_vector())) == normalized(vct)); se_hash[she] = true; valid = valid && (++count <= max); } if(has_shalfloop()) { SHalfloop_handle shl = shalfloop(); valid = valid && shl->is_valid(); valid = valid && twin(shl)->is_valid(); valid = valid && (twin(shl) != shl); valid = valid && (twin(twin(shl)) == shl); } SFace_iterator sf; SFace_cycle_iterator sfc; int loop_entries_found = 0; int edge_entries_found = 0; int vertex_entries_found = 0; CGAL_forall_sfaces(sf,*this) { valid = valid && sf->is_valid(verb, level); valid = valid && (!sf_hash[sf]); sf_hash[sf] = true; CGAL_forall_sface_cycles_of(sfc,sf) { if (sfc.is_shalfloop()) loop_entries_found++; else if(sfc.is_shalfedge()) edge_entries_found++; else if(sfc.is_svertex()) vertex_entries_found++; valid = valid && (++count <= max); } valid = valid && (++count <= max); } if(has_shalfloop()) valid = valid && (loop_entries_found == 2); else valid = valid && (loop_entries_found == 0); if(number_of_shalfedges() > 0) valid = valid && (edge_entries_found > 0); else valid = valid && (edge_entries_found == 0); valid = valid && (vertex_entries_found == isolated_vertices_found); verr << "end of CGAL::SNC_SM_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } template void change_marks(const Mark& m, const Selection& SP) { psm_->mark() = SP(m, psm_->mark()); SVertex_iterator v; CGAL_forall_svertices(v,*this) mark(v) = SP(m, mark(v)); SHalfedge_iterator e; CGAL_forall_shalfedges(e,*this) mark(e) = SP(m, mark(e)); SFace_iterator f; CGAL_forall_sfaces(f,*this) mark(f) = SP(m, mark(f)); } template void change_marks(const Selection& SP, const Mark& m) { psm_->mark() = SP(psm_->mark(), m); SVertex_iterator v; CGAL_forall_svertices(v,*this) mark(v) = SP(mark(v),m); SHalfedge_iterator e; CGAL_forall_shalfedges(e,*this) mark(e) = SP(mark(e),m); SFace_iterator f; CGAL_forall_sfaces(f,*this) mark(f) = SP(mark(f),m); } void check_integrity_and_topological_planarity(bool faces=true) const { SM_const_decorator C(psm_); C.check_integrity_and_topological_planarity(faces); } }; // SM_decorator CGAL_END_NAMESPACE #endif // CGAL_SM_DECORATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_io_parser.h0000644000175000017500000003670611344301501030644 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_io_parser.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SM_IO_PARSER_H #define CGAL_SM_IO_PARSER_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=SM_io_parser.man }*/ /*{\Manpage {SM_io_parser}{Decorator_}{IO of embedded maps}{IO}}*/ /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to provide input and output of a embedded map. |\Mtype| is generic with respect to the |Decorator_| parameter. |Decorator_| has to be a decorator model of our |SM_decorator| concept.}*/ /*{\Mgeneralization SM_decorator}*/ template class SM_io_parser : public Decorator_ { typedef Decorator_ Base; typedef typename Decorator_::Sphere_point Sphere_point; typedef typename Decorator_::Sphere_circle Sphere_circle; typedef typename Decorator_::Mark Mark; typedef typename Decorator_::Decorator_traits Decorator_traits; typedef typename Decorator_traits::SVertex_iterator SVertex_iterator; typedef typename Decorator_traits::SHalfedge_iterator SHalfedge_iterator; typedef typename Decorator_traits::SFace_iterator SFace_iterator; typedef typename Decorator_traits::SVertex_handle SVertex_handle; typedef typename Decorator_traits::SHalfedge_handle SHalfedge_handle; typedef typename Decorator_traits::SFace_handle SFace_handle; typedef typename Decorator_traits::SHalfloop_handle SHalfloop_handle; typedef typename Decorator_traits::SFace_cycle_iterator SFace_cycle_iterator; typedef typename Decorator_traits::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; std::istream& in; std::ostream& out; bool verbose; // a reference to the IO object CGAL::Object_index VI; CGAL::Object_index EI; CGAL::Object_index FI; std::vector SVertex_of; std::vector Edge_of; std::vector SFace_of; SHalfloop_handle Loop_of[2]; // object mapping for input int vn,en,ln,fn,i; // the number of objects bool check_sep(char* sep); void print_vertex(SVertex_handle) const; void print_edge(SHalfedge_handle) const; void print_loop(SHalfloop_handle) const; void print_face(SFace_handle) const; bool read_vertex(SVertex_handle); bool read_edge(SHalfedge_handle); bool read_loop(SHalfloop_handle); bool read_face(SFace_handle); void debug_vertex(SVertex_handle) const; void debug_edge(SHalfedge_handle) const; void debug_loop(SHalfloop_handle) const; public: /*{\Mcreation 3}*/ SM_io_parser(std::istream& is, const Base& D); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to input |H| from |is|.}*/ SM_io_parser(std::ostream& os, const Base& D); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to output |H| to |os|.}*/ /*{\Moperations 2 3}*/ void print() const; /*{\Mop prints |H| to |os|.}*/ void read(); /*{\Mop reads |H| from |is|.}*/ void debug() const; void print_faces() const; std::string index(SVertex_handle v) const { return VI(v,verbose); } std::string index(SHalfedge_handle e) const { return EI(e,verbose); } std::string index(SHalfloop_handle l) const { if (verbose) return (l==this->shalfloop()? "l0" : "l1"); else return (l==this->shalfloop()? "0" : "1"); } std::string index(SFace_handle f) const { return FI(f,verbose); } static void dump(const Decorator_& D, std::ostream& os = std::cerr); /*{\Mstatic prints the plane map decorated by |D| to |os|.}*/ }; // SM_io_parser template SM_io_parser:: SM_io_parser(std::istream& iin, const Base& H) : Base(H), in(iin), out(std::cout), verbose(0), vn(0), en(0), fn(0), ln(0) { this->clear(); } template SM_io_parser:: SM_io_parser(std::ostream& iout, const Base& D) : Base(D), in(std::cin), out(iout), VI(this->svertices_begin(),this->svertices_end(),'v'), EI(this->shalfedges_begin(),this->shalfedges_end(),'e'), FI(this->sfaces_begin(),this->sfaces_end(),'f'), vn(this->number_of_svertices()), en(this->number_of_shalfedges()), ln(this->number_of_shalfloops()), fn(this->number_of_sfaces()) { verbose = (out.iword(CGAL::IO::mode) != CGAL::IO::ASCII && out.iword(CGAL::IO::mode) != CGAL::IO::BINARY); } //----------------------------------------------------------------------------- // OUTPUT AND INPUT: //----------------------------------------------------------------------------- template bool SM_io_parser::check_sep(char* sep) { char c; do in.get(c); while (isspace(c)); while (*sep != '\0') { if (*sep != c) { in.putback(c); return false; } ++sep; in.get(c); } in.putback(c); return true; } template void SM_io_parser::print_vertex(SVertex_handle v) const { // syntax: index { isolated incident_object, mark, point } out << index(v) << " { "; if ( is_isolated(v) ) out << "1 " << index(face(v)); else out << "0 " << index(first_out_edge(v)); out << ", " << mark(v) << ", " << point(v) << "}\n"; } template bool SM_io_parser::read_vertex(SVertex_handle v) { // precondition: nodes exist // syntax: index { isolated incident_object, mark, point} int n; bool iso; int f; Mark m; Sphere_point p; if ( !(in >> n) || !check_sep("{") || !(in >> iso) || !(in >> f) || !check_sep(",") || !(in >> m) || !check_sep(",") || !(in >> p) || !check_sep("}") ) return false; if (iso) set_face(v,SFace_of[f]); else set_first_out_edge(v,Edge_of[f]); mark(v) = m; point(v) = p; return true; } template void SM_io_parser::print_edge(SHalfedge_handle e) const { // syntax: index { twin, prev, next, source, face, mark, circle } out << index(e) << " { " << index(twin(e)) << ", " << index(previous(e)) << ", " << index(next(e)) << ", " << index(source(e)) << ", " << index(face(e)) << ", " << mark(e) << ", " << circle(e) << " }\n"; } template bool SM_io_parser::read_edge(SHalfedge_handle e) { // syntax: index { twin, prev, next, source, face, mark, circle } int n, eo, epr, ene, v, f; bool m; Sphere_circle k; if ( !(in >> n) || !check_sep("{") || !(in >> eo) || !check_sep(",") || !(in >> epr) || !check_sep(",") || !(in >> ene) || !check_sep(",") || !(in >> v) || !check_sep(",") || !(in >> f) || !check_sep(",") || !(in >> m) || !check_sep(",") || !(in >> k) || !check_sep("}") ) return false; CGAL_assertion_msg (eo >= 0 && eo < en && epr >= 0 && epr < en && ene >= 0 && ene < en && v >= 0 && v < vn && f >= 0 && f < fn , "wrong index in read_edge"); // precond: features exist! CGAL_assertion(EI[twin(e)]); set_prev(e,Edge_of[epr]); set_next(e,Edge_of[ene]); set_source(e,SVertex_of[v]); set_face(e,SFace_of[f]); mark(e) = m; circle(e) = k; return true; } template void SM_io_parser::print_loop(SHalfloop_handle l) const { // syntax: index { twin, face, mark, circle } out << index(l) << " { " << index(twin(l)) << ", " << index(face(l)) << ", " << mark(l) << ", " << circle(l) << " }\n"; } template bool SM_io_parser::read_loop(SHalfloop_handle l) { // syntax: index { twin, face, mark, circle } int n, lo, f; bool m; Sphere_circle k; if ( !(in >> n) || !check_sep("{") || !(in >> lo) || !check_sep(",") || !(in >> f) || !check_sep(",") || !(in >> m) || !check_sep(",") || !(in >> k) || !check_sep("}") ) return false; CGAL_assertion_msg( (lo >= 0 && lo < 2 && f >= 0 && f < fn),"wrong index in read_edge"); set_face(l,SFace_of[f]); mark(l) = m; circle(l) = k; return true; } template void SM_io_parser::print_face(SFace_handle f) const { // syntax: index { fclist, ivlist, loop, mark } out << index(f) << " { "; SFace_cycle_iterator it; CGAL_forall_sface_cycles_of(it,f) if ( it.is_shalfedge() ) out << index(SHalfedge_handle(it)) << ' '; out << ", "; CGAL_forall_sface_cycles_of(it,f) if ( it.is_svertex() ) out << index(SVertex_handle(it)) << ' '; out << ", "; CGAL_forall_sface_cycles_of(it,f) if ( it.is_shalfloop() ) out << index(SHalfloop_handle(it)); out << ", " << mark(f) << " }\n"; } template bool SM_io_parser::read_face(SFace_handle f) { // syntax: index { fclist, ivlist, loop, mark } int n, ei, vi, li; Mark m; if ( !(in >> n) || !check_sep("{") ) return false; while (in >> ei) { CGAL_assertion_msg(ei >= 0 && ei < en, "wrong index in face cycle list."); store_boundary_object(Edge_of[ei],f); } in.clear(); if (!check_sep(",")) { return false; } while (in >> vi) { CGAL_assertion_msg(vi >= 0 && vi < vn, "wrong index in iso vertex list."); store_boundary_object(SVertex_of[vi],f); } in.clear(); if (!check_sep(",")) { return false; } while (in >> li) { CGAL_assertion_msg(li >= 0 && li < 2, "wrong index in iso vertex list."); store_boundary_object(Loop_of[li],f); } in.clear(); if (!check_sep(",") || !(in >> m) || !check_sep("}") ) return false; mark(f) = m; return true; } template void SM_io_parser::print() const { out << "Sphere_map_2" << std::endl; out << "vertices " << vn << std::endl; out << "edges " << en << std::endl; out << "loops " << ln << std::endl; out << "faces " << fn << std::endl; if (verbose) out << "/* index { isolated ? face : edge, mark, point } */" << std::endl; SVertex_iterator vit; CGAL_forall_svertices(vit,*this) print_vertex(vit); if (verbose) out << "/* index { twin, prev, next, source, face, mark, circle } */" << std::endl; SHalfedge_iterator eit; CGAL_forall_shalfedges(eit,*this) print_edge(eit); if (verbose) out << "/* index { twin, face, mark, circle } */" << std::endl; if ( this->has_shalfloop() ) { print_loop(this->shalfloop()); print_loop(twin(this->shalfloop())); } if (verbose) out << "/* index { fclist, ivlist, loop, mark } */" << std::endl; SFace_iterator fit; CGAL_forall_sfaces(fit,*this) print_face(fit); out.flush(); if (verbose) debug(); } template void SM_io_parser::read() { if ( !check_sep("Plane_map_2") ) CGAL_assertion_msg(0,"SM_io_parser::read: no embedded_PM header."); if ( !(check_sep("vertices") && (in >> vn)) ) CGAL_assertion_msg(0,"SM_io_parser::read: wrong vertex line."); if ( !(check_sep("edges") && (in >> en) && (en%2==0)) ) CGAL_assertion_msg(0,"SM_io_parser::read: wrong edge line."); if ( !(check_sep("loops") && (in >> ln)) ) CGAL_assertion_msg(0,"SM_io_parser::read: wrong loop line."); if ( !(check_sep("faces") && (in >> fn)) ) CGAL_assertion_msg(0,"SM_io_parser::read: wrong face line."); SVertex_of.reserve(vn); Edge_of.reserve(en); SFace_of.reserve(fn); for(i=0; inew_vertex(); for(i=0; inew_edge_pair_without_vertices(); else Edge_of[i] = twin(Edge_of[i-1]); for(i=0; inew_face(); if ( ln == 2 ) { Loop_of[0] = this->new_loop(); Loop_of[1] = twin(this->loop()); } for(i=0; i void SM_io_parser::debug_vertex(SVertex_handle v) const { out << index(v) << "[" << mark(v) << "," << point(v) << "]" << std::endl; } template void SM_io_parser::debug_edge(SHalfedge_handle e) const { out << index(e) << "(" << index(source(e)) << "," << index(target(e)) << ") " << index(twin(e)) << " " << index(face(e)) << " ["<< mark(e) << "," << circle(e) << "] " << std::endl; } template void SM_io_parser::debug_loop(SHalfloop_handle l) const { out << index(l) << " " << index(twin(l)) << " " << index(face(l)) << " ["<< mark(l) << "] " << circle(l) << std::endl; } template void SM_io_parser::debug() const { out << "\nDEBUG Plane_map\n"; out << "Vertices: " << this->number_of_svertices() << "\n"; out << "SHalfedges: " << this->number_of_shalfedges() << "\n"; out << "Loop: " << this->number_of_shalfloops() << "\n"; SVertex_iterator vit; CGAL_forall_svertices(vit,*this) { if ( is_isolated(vit) ) continue; SHalfedge_around_svertex_circulator hcirc(out_edges(vit)), hend(hcirc); debug_vertex(vit); CGAL_For_all(hcirc,hend) { out << " "; debug_edge(hcirc); } } if ( this->has_shalfloop() ) { debug_loop(this->shalfloop()); debug_loop(twin(this->shalfloop())); } out << std::endl; } template void SM_io_parser::print_faces() const { out << "\nFACES\n"; out << "Vertices: " << this->number_of_svertices() << "\n"; out << "SHalfedges: " << this->number_of_shalfedges() << "\n"; out << "Loop: " << this->number_of_shalfloops() << "\n"; SHalfedge_iterator e; Unique_hash_map Done(false); CGAL_forall_shalfedges(e,*this) { if ( Done[e] ) continue; typename Base::SHalfedge_around_sface_circulator c(e), ce = c; out << "face cycle\n"; CGAL_For_all(c,ce) { Done[c]=true; out << " "; debug_vertex(source(c)); } } if ( this->has_shalfloop() ) { debug_loop(this->shalfloop()); debug_loop(twin(this->shalfloop())); } out << std::endl; } template void SM_io_parser::dump(const Decorator_& D, std::ostream& os) { SM_io_parser Out(os,D); Out.print(); Out.print_faces(); } CGAL_END_NAMESPACE #endif //CGAL_SM_IO_PARSER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_visualizor.h0000644000175000017500000001606111344301501031060 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_visualizor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef SM_VISUALIZOR_H #define SM_VISUALIZOR_H #include #include #include #include #define LGREY CGAL::Color(170,170,200) #define DGREY CGAL::Color(30,30,50) CGAL_BEGIN_NAMESPACE template class SM_BooleColor { typedef typename Map_::SVertex_const_handle SVertex_const_handle; typedef typename Map_::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Map_::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Map_::SFace_const_handle SFace_const_handle; typedef typename Map_::Mark Mark; public: Color color(SVertex_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfedge_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfloop_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SFace_const_handle, Mark m) const { return ( m ? DGREY : LGREY ); } }; /*{\Moptions outfile=SM_visualizor.man }*/ /*{\Manpage {SM_visualizor}{Map_,Sphere_kernel_} {Drawing plane maps}{V}}*/ template class SM_visualizor : public SM_triangulator< SM_decorator > { /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to draw the structure of a sphere map into the surface of a OpenGL sphere. It is generic with respect to the template concept.}*/ /*{\Mgeneralization SM_decorator}*/ /*{\Mtypes 3}*/ public: typedef typename SM_explorer::Sphere_map Sphere_map; typedef CGAL::SM_BooleColor Color_; typedef typename Sphere_map::Sphere_kernel Sphere_kernel; typedef SM_visualizor Self; typedef SM_decorator Decorator; typedef SM_triangulator Base; typedef typename Sphere_map::SVertex_const_handle SVertex_const_handle; typedef typename Sphere_map::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Sphere_map::SFace_const_handle SFace_const_handle; typedef typename Sphere_map::SVertex_const_iterator SVertex_const_iterator; typedef typename Sphere_map::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Sphere_map::SFace_const_iterator SFace_const_iterator; typedef typename Sphere_map::Mark Mark; typedef typename Sphere_kernel::Sphere_point Sphere_point; typedef typename Sphere_kernel::Sphere_segment Sphere_segment; typedef typename Sphere_kernel::Sphere_circle Sphere_circle; typedef typename Sphere_kernel::Sphere_triangle Sphere_triangle; typedef Color_ Color_objects; protected: const SM_explorer* E_; const Color_objects& CO_; Sphere_map MT_; CGAL::OGL::Unit_sphere& S_; public: /*{\Mcreation 4}*/ SM_visualizor(const SM_explorer* M, CGAL::OGL::Unit_sphere& S, const Color_objects& C = Color_objects()) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to visualize the vertices, edges, and faces of |D| in an open GL window.}*/ : Base(&MT_,M), E_(M), CO_(C), MT_(true), S_(S) { triangulate(); } /*{\Moperations 2 1}*/ /* |draw_map| draws all object of the referenced sphere map: 1) edges, loops, and vertices are taken from E_ 2) faces are drawn via the calculated triangulation in MT_ */ void draw_map() const /*{\Mop draw the whole plane map.}*/ { // draw sphere segments underlying edges of E_: SHalfedge_const_iterator e; CGAL_forall_sedges(e,*E_) { if ( source(e) == target(e) ) { S_.push_back(E_->circle(e), CO_.color(e,E_->mark(e))); } else { S_.push_back(Sphere_segment(E_->point(E_->source(e)), E_->point(E_->target(e)), E_->circle(e)),CO_.color(e,E_->mark(e))); } } // draw sphere circles underlying loops of E_: if ( E_->has_shalfloop() ) S_.push_back( Sphere_circle(E_->circle(E_->shalfloop())), CO_.color(E_->shalfloop(),E_->mark(E_->shalfloop()))); // draw points underlying vertices of E_: SVertex_const_iterator v; CGAL_forall_svertices(v,*E_) S_.push_back(E_->point(v),CO_.color(v,E_->mark(v))); Unique_hash_map Done(false); CGAL_forall_shalfedges(e,*this) { if ( Done[e] ) continue; SHalfedge_const_handle en(next(e)),enn(next(en)); CGAL_NEF_TRACEV(Base::incident_triangle(e)); CGAL_NEF_TRACEN(incident_mark(e)<point(E_->source(e)), E_->point(E_->target(e)), E_->circle(e))); Done[e]=Done[twin(e)]=true; } } /* |draw_triangulation| draws all object of the underlying triangulation: 1) edges, loops, and vertices are taken from E_ 2) faces are drawn via the calculated triangulation in MT_ */ void draw_triangulation() const { // draw sphere segments underlying edges of triangulation: SHalfedge_const_iterator e; CGAL_forall_sedges(e,*this) { S_.push_back(Sphere_segment(point(source(e)),point(target(e)), circle(e)),CO_.color(e,mark(e))); } // draw points underlying vertices of triangulation: SVertex_const_iterator v; CGAL_forall_svertices(v,*this) S_.push_back(point(v),CO_.color(v,mark(v))); Unique_hash_map Done(false); CGAL_forall_shalfedges(e,*this) { if ( Done[e] ) continue; SHalfedge_const_handle en(next(e)),enn(next(en)); CGAL_assertion(incident_mark(e)==incident_mark(en)&& incident_mark(en)==incident_mark(enn)); Mark m = incident_mark(e); Sphere_triangle t = incident_triangle(e); S_.push_back(t, (m ? DGREY : LGREY) ); Done[e]=Done[en]=Done[enn]=true; } } }; // end of SM_visualizor CGAL_END_NAMESPACE #undef CGAL_USING //#undef LGREY //#undef DGREY #endif // SM_VISUALIZOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Normalizing.h0000644000175000017500000001631511344301501030545 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Normalizing.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_NORMALIZING_H #define CGAL_NORMALIZING_H #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 307 #include CGAL_BEGIN_NAMESPACE class Homogeneous_tag; class Cartesian_tag; template class Normalizing; template<> class Normalizing { public: template static CGAL::Point_3 normalized(const CGAL::Point_3& p) { typedef typename R::RT RT; RT g = p.hw(); g = (p.hx() == 0 ? g : CGAL_NTS gcd(g,p.hx())); g = (p.hy() == 0 ? g : CGAL_NTS gcd(g,p.hy())); g = (p.hz() == 0 ? g : CGAL_NTS gcd(g,p.hz())); RT x = p.hx()/g; RT y = p.hy()/g; RT z = p.hz()/g; RT w = p.hw()/g; return CGAL::Point_3(x,y,z,w); } template static CGAL::Sphere_point normalized(CGAL::Sphere_point& p) { typedef typename R::RT RT; RT g = (p.x()==0) ? ((p.y()==0) ? ((p.z()==0) ? 1: p.z()): p.y()): p.x(); if(p.y() != 0) g = CGAL_NTS gcd(g,p.y()); if(p.z() != 0) g = CGAL_NTS gcd(g,p.z()); if(g<0) g = -g; RT x = p.x()/g; RT y = p.y()/g; RT z = p.z()/g; return CGAL::Sphere_point(x,y,z); } template static CGAL::Vector_3 normalized(const CGAL::Vector_3& p) { typedef typename R::RT RT; RT g = (p.hx()==0) ? ((p.hy()==0) ? ((p.hz()==0) ? 1: p.hz()): p.hy()): p.hx(); if(p.hy() != 0) g = CGAL_NTS gcd(g,p.hy()); if(p.hz() != 0) g = CGAL_NTS gcd(g,p.hz()); if(g<0) g = -g; RT x = p.hx()/g; RT y = p.hy()/g; RT z = p.hz()/g; return CGAL::Vector_3(x,y,z); } template static CGAL::Sphere_direction normalized(CGAL::Sphere_direction& c) { CGAL::Plane_3 h = c.plane(); CGAL_assertion(!(h.a()==0 && h.b()==0 && h.c()==0 && h.d()==0)); typedef typename R::RT RT; RT x = (h.a()==0) ? ((h.b()==0) ? ((h.c()==0) ? ((h.d()==0) ? 1 : h.d()) : h.c()) : h.b()) : h.a(); if(h.b() != 0) x = gcd(x,h.b()); if(h.c() != 0) x = gcd(x,h.c()); if(h.d() !=0) x = gcd(x,h.d()); x = CGAL_NTS abs(x); RT pa = h.a()/x; RT pb = h.b()/x; RT pc = h.c()/x; RT pd = h.d()/x; return CGAL::Sphere_direction(CGAL::Plane_3(pa,pb,pc,pd)); } template static CGAL::Plane_3 normalized(CGAL::Plane_3& h) { CGAL_assertion(!(h.a()==0 && h.b()==0 && h.c()==0 && h.d()==0)); typedef typename R::RT RT; RT x = (h.a()==0) ? ((h.b()==0) ? ((h.c()==0) ? ((h.d()==0) ? 1 : h.d()) : h.c()) : h.b()) : h.a(); CGAL_NEF_TRACE("gcd... i"<<' '); if(h.b() != 0) x = CGAL_NTS gcd(x,h.b()); CGAL_NEF_TRACE(x<<' '); if(h.c() != 0) x = CGAL_NTS gcd(x,h.c()); CGAL_NEF_TRACE(x<<' '); if(h.d() !=0) x = CGAL_NTS gcd(x,h.d()); CGAL_NEF_TRACEN(x); x = CGAL_NTS abs(x); RT pa = h.a()/x; RT pb = h.b()/x; RT pc = h.c()/x; RT pd = h.d()/x; CGAL_NEF_TRACEN(" after normalizing " << CGAL::Plane_3(pa,pb,pc,pd)); return CGAL::Plane_3(pa,pb,pc,pd); } template static CGAL::Sphere_circle normalized(CGAL::Sphere_circle& c) { CGAL::Plane_3 h = c.plane(); CGAL_assertion(!(h.a()==0 && h.b()==0 && h.c()==0 && h.d()==0)); typedef typename R::RT RT; RT x = (h.a()==0) ? ((h.b()==0) ? ((h.c()==0) ? ((h.d()==0) ? 1 : h.d()) : h.c()) : h.b()) : h.a(); if(h.b() != 0) x = CGAL_NTS gcd(x,h.b()); if(h.c() != 0) x = CGAL_NTS gcd(x,h.c()); if(h.d() !=0) x = CGAL_NTS gcd(x,h.d()); x = CGAL_NTS abs(x); RT pa = h.a()/x; RT pb = h.b()/x; RT pc = h.c()/x; RT pd = h.d()/x; return CGAL::Sphere_circle(CGAL::Plane_3(pa,pb,pc,pd)); } }; template<> class Normalizing { public: template static CGAL::Point_3 normalized(const CGAL::Point_3& p) { return p; /* typedef typename R::FT FT; FT g = (p.x() != 0 ? p.x() : (p.y() != 0 ? p.y() : (p.z() != 0 ? p.z() : 1))); g = CGAL_NTS abs(g); FT x = p.x()/g; FT y = p.y()/g; FT z = p.z()/g; return CGAL::Point_3(x,y,z); */ } template static CGAL::Vector_3 normalized(const CGAL::Vector_3& p) { return p; } template static CGAL::Sphere_point normalized(const CGAL::Sphere_point& p) { return p; } template static CGAL::Sphere_direction normalized(CGAL::Sphere_direction& c) { return c; } template static CGAL::Plane_3 normalized(CGAL::Plane_3& h) { CGAL_assertion(!(h.a()==0 && h.b()==0 && h.c()==0 && h.d()==0)); typedef typename R::FT FT; FT x = (h.a()==0) ? ((h.b()==0) ? ((h.c()==0) ? ((h.d()==0) ? 1 : h.d()) : h.c()) : h.b()) : h.a(); x = CGAL_NTS abs(x); FT pa = h.a()/x; FT pb = h.b()/x; FT pc = h.c()/x; FT pd = h.d()/x; CGAL_NEF_TRACEN(" after normalizing " << CGAL::Plane_3(pa,pb,pc,pd)); return CGAL::Plane_3(pa,pb,pc,pd); } template static CGAL::Sphere_circle normalized(CGAL::Sphere_circle& c) { return c; } }; template CGAL::Point_3 normalized(const CGAL::Point_3& p) { return Normalizing::normalized(p); } template CGAL::Sphere_point normalized(CGAL::Sphere_point& p) { return Normalizing::normalized(p); } template CGAL::Vector_3 normalized(const CGAL::Vector_3& p) { return Normalizing::normalized(p); } template CGAL::Sphere_direction normalized(CGAL::Sphere_direction& c) { return Normalizing::normalized(c); } template CGAL::Plane_3 normalized(CGAL::Plane_3& h) { return Normalizing::normalized(h); } template CGAL::Sphere_circle normalized(CGAL::Sphere_circle& c) { return Normalizing::normalized(c); } CGAL_END_NAMESPACE #endif // CGAL_NORMALIZING_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/OGL_base_object.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/OGL_base_object0000644000175000017500000000301711344301501030762 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/OGL_base_object.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_OGL_BASE_OBJECT_H #define CGAL_OGL_BASE_OBJECT_H #include CGAL_BEGIN_NAMESPACE namespace OGL { class OGL_base_object { public: typedef CGAL::Simple_cartesian Double_kernel; typedef Double_kernel::Point_3 Double_point; typedef Double_kernel::Vector_3 Double_vector; typedef Double_kernel::Segment_3 Double_segment; typedef Double_kernel::Aff_transformation_3 Affine_3; virtual void draw(double z_vec[3]) const = 0; virtual void init() = 0; virtual void toggle(int) = 0; virtual void set_style(int) = 0; virtual ~OGL_base_object() {} }; } CGAL_END_NAMESPACE #endif // CGAL_OGL_BASE_OBJECT_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/sphere_predicates.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/sphere_predicat0000644000175000017500000003460711344301501031173 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/sphere_predicates.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_SPHERE_PREDICATES_H #define CGAL_SPHERE_PREDICATES_H #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 23 #include #include #undef CGAL_forall_iterators #define CGAL_forall_iterators(x,L)\ for(x = (L).begin(); x != (L).end(); ++x) CGAL_BEGIN_NAMESPACE /* |spherical_orientation| takes three points of one hemisphere and returns the orientation of $p_3$ with respect to the halfcircle through $p_1$ and $p_2$. We map this to the 3d orientation predicate of the origin, $p_1$, $p_2$, and $p_3$ */ template int spherical_orientation(const Sphere_point& p1, const Sphere_point& p2, const Sphere_point& p3) { return CGAL::orientation(CGAL::Point_3(0,0,0),(CGAL::Point_3)p1, (CGAL::Point_3)p2,(CGAL::Point_3)p3); } /* |spherical_compare| codes our order of points during the sweep. The south pole is the first point, the north pole is the last point, then we order lexicographically. We cover the special case where both points are part of the equator first. Otherwise we sort according to the angle of the halfcircle through $S$, $N$, and the points with respect to the xy-plane. If both lie on the same halfcircle then the angle with respect to $OS$ decides. The parameter $pos=1$ does everthing in the positive halfsphere. If $pos=-1$ then we rotate the whole scenery around the y-axis by $\pi$. Then the x-axis points left and the z-axis into the equatorial plane. */ template int spherical_compare(const Sphere_point& p1, const Sphere_point& p2, int axis, int pos) { Sphere_point pS, pN; CGAL_assertion(axis>=0 && axis<=2); switch(axis) { case 0: pS=Sphere_point(0,-1,0); pN=Sphere_point(0,1,0); break; case 1: pS=Sphere_point(0,0,1); pN=Sphere_point(0,0,-1); break; case 2: pS=Sphere_point(0,-1,0); pN=Sphere_point(0,1,0); break; } CGAL::Direction_3 d1(p1-CGAL::ORIGIN), d2(p2-CGAL::ORIGIN), dS(pS-CGAL::ORIGIN), dN(pN-CGAL::ORIGIN); if (d1 == d2) return 0; if (d1 == dS || d2 == dN) return -1; if (d1 == dN || d2 == dS) return 1; // now no more special cases if (axis==0 && (p1.hx()==static_cast(0) && p2.hx()==static_cast(0))) { int s1 = CGAL_NTS sign(p1.hz()); int s2 = CGAL_NTS sign(p2.hz()); if ( s1 != s2 ) return pos * -s1; // now s1 == s2 return -s1 * CGAL::spherical_orientation(p1,Sphere_point(1,0,0),p2); } else if (axis==1 && (p1.hy()==static_cast(0) && p2.hy()==static_cast(0))) { int s1 = CGAL_NTS sign(p1.hx()); int s2 = CGAL_NTS sign(p2.hx()); if ( s1 != s2 ) return pos * s1; // now s1 == s2 return s1 * CGAL::spherical_orientation(p1,Sphere_point(0,1,0),p2); } else if (axis==2 && (p1.hz()==static_cast(0) && p2.hz()==static_cast(0))) { int s1 = CGAL_NTS sign(p1.hx()); int s2 = CGAL_NTS sign(p2.hx()); if ( s1 != s2 ) return pos * s1; // now s1 == s2 return s1 * CGAL::spherical_orientation(p1,Sphere_point(0,0,1),p2); } int sor = CGAL::spherical_orientation(pS,p1,p2); if ( sor ) return sor; if(axis==0) return CGAL::spherical_orientation(Sphere_point(0,0,pos),p2,p1); return CGAL::spherical_orientation(Sphere_point(-pos,0,0),p2,p1); } /* the next two functions partition the segments in a list into a list that carries the segment parts that are only part of a halfspace. Halfcircles are again divided into two equally sized pieces. */ template void partition(const Sphere_circle& c, I start, I beyond, std::list< Sphere_segment >& Lpos) { CGAL_NEF_TRACEN("partition "); Sphere_segment s1,s2,s3; while ( start != beyond ) { CGAL_NEF_TRACEN(" "<<*start); int i = start->intersection(c,s1,s2); if (i>1) Lpos.push_back(s2); if (i>0) Lpos.push_back(s1); ++start; } } template void partition_xy(I start, I beyond, std::list< Sphere_segment >& L, int pos) { Sphere_circle xy_circle(0,0,1), yz_circle(1,0,0); Sphere_point S(0,-1,0),N(0,1,0); Sphere_segment s1,s2; if (pos > 0) partition(xy_circle,start,beyond,L); else partition(xy_circle.opposite(),start,beyond,L); typename std::list< Sphere_segment >::iterator it,itl; CGAL_NEF_TRACEN("partition_xy "); CGAL_forall_iterators(it,L) { CGAL_NEF_TRACEN(" "<<*it); if ( equal_as_sets(it->sphere_circle(),xy_circle) ) { CGAL_NEF_TRACEN(" splitting xy seg "<<*it); int n1 = it->intersection(yz_circle,s1,s2); if (n1 > 1 && !s2.is_degenerate()) L.insert(it,s2); if (n1 > 0 && !s1.is_degenerate()) L.insert(it,s1); int n2 = it->intersection(yz_circle.opposite(),s1,s2); if (n2 > 1 && !s2.is_degenerate()) L.insert(it,s2); if (n2 > 0 && !s1.is_degenerate()) L.insert(it,s1); itl = it; --it; L.erase(itl); // at least one item was appended } } CGAL_forall_iterators(it,L) { if ( it->is_halfcircle() ) { CGAL_NEF_TRACEN(" splitting halfcircle "<<*it); Sphere_segment s1,s2; it->split_halfcircle(s1,s2); *it = s2; L.insert(it,s1); } } // append 4 xy-equator segments: Sphere_segment sp(S,N,xy_circle); Sphere_segment sm(S,N,xy_circle.opposite()); Sphere_segment s[4]; sp.split_halfcircle(s[0],s[1]); sm.split_halfcircle(s[2],s[3]); L.insert(L.end(),s,s+4); } /* |intersection| calculates the intersection of a halfspace $h$ (defined via a great circle $c$) with a sphere segment $s$. Interesting are the boundary cases. If an endpoint is part of $h^0$, but the part of $s$ incident to the endpoint is not part of $h^{0+}$ then we return a trivial segment. */ /* template int Sphere_segment:: intersection(const CGAL::Sphere_circle& c, std::vector >& s) const { CGAL_NEF_TRACEN(" intersection "<<*this<<" "< i1 = CGAL::intersection(ptr()->c_,c); if ( !has_on(i1) ) i1 = i1.antipode(); s.push_back(Sphere_segment(source(),i1,sphere_circle())); s.push_back(Sphere_segment(i1,target(),sphere_circle())); return 2; } else if ( or1 == CGAL::ON_ORIENTED_BOUNDARY && or2 == CGAL::ON_ORIENTED_BOUNDARY ) { // if both ends of $s$ are part of $h$ then $s$ is a halfcircle or // $s$ is fully part of $h$. In this case we have to check if the // halfcircle is not part of $h^-$. This can be formulated by an // orientation test of the point $p$ at the tip of the normal of // |s.sphere_circle()| with respect to the plane through the // endpoints of $s$ and the tip of the normal of $h$. CGAL_NEF_TRACEN(" both in plane"); s.push_back(*this); return 1; } else if ( or1 != CGAL::ON_NEGATIVE_SIDE && or2 != CGAL::ON_NEGATIVE_SIDE ) { // this case covers the endpoints of $s$ as part of the closed // oriented halfspace $h^{0+}$. At least one is part of // $h^{+}$. If $s$ is not long then the segment must be fully part // of $h^{0+}$. Otherwise if $s$ is long, then we at both ends // there are subsegments as part of $h^{0+}$ (one might be // degenerate). if ( is_long() ) { Sphere_point i1 = CGAL::intersection(ptr()->c_,c); Sphere_point i2 = i1.antipode(); Sphere_segment so(i1,i2,sphere_circle()); if ( so.has_on(source()) && so.has_on(target()) ) std::swap(i1,i2); // now source(),i1,i2,target() are circularly ordered s.push_back(Sphere_segment(source(),i1,sphere_circle())); s.push_back(Sphere_segment(i1,i2,sphere_circle())); s.push_back(Sphere_segment(i2,target(),sphere_circle())); // CGAL_NEF_TRACEN(" both >= plane, long "<= plane, short "); s.push_back(*this); return 1; } else if ( or1 != CGAL::ON_POSITIVE_SIDE && or2 != CGAL::ON_POSITIVE_SIDE ) { // either both endpoints of $s$ are in $h^-$ or one is in $h^-$ // and one on $h^0$. if ( is_long() ) { Sphere_point i1 = CGAL::intersection(ptr()->c_,c); Sphere_point i2 = i1.antipode(); Sphere_segment so(i1,i2,sphere_circle()); // CGAL_NEF_TRACEN(" both <= plane, long"< int Sphere_segment:: intersection(const CGAL::Sphere_circle& c, Sphere_segment& s1, Sphere_segment& s2) const { CGAL_NEF_TRACEN(" intersection "<<*this<<" "< i1 = CGAL::intersection(this->ptr()->c_,c); if ( !has_on(i1) ) i1 = i1.antipode(); if ( or1 == CGAL::ON_POSITIVE_SIDE ) s1 = Sphere_segment(source(),i1,sphere_circle()); else if ( or2 == CGAL::ON_POSITIVE_SIDE ) s1 = Sphere_segment(i1,target(),sphere_circle()); else CGAL_assertion_msg(0,"no intersection."); return 1; } else if ( or1 == CGAL::ON_ORIENTED_BOUNDARY && or2 == CGAL::ON_ORIENTED_BOUNDARY ) { // if both ends of $s$ are part of $h$ then $s$ is a halfcircle or // $s$ is fully part of $h$. In this case we have to check if the // halfcircle is not part of $h^-$. This can be formulated by an // orientation test of the point $p$ at the tip of the normal of // |s.sphere_circle()| with respect to the plane through the // endpoints of $s$ and the tip of the normal of $h$. CGAL_NEF_TRACEN(" both in plane"); if ( source() != target().antipode() ) { s1 = *this; return 1; } // now this is a halfcircle register bool halfcircle_notin_hminus = (CGAL::orientation(source(),target(), CGAL::ORIGIN + c.orthogonal_vector(), CGAL::ORIGIN + sphere_circle().orthogonal_vector()) != CGAL::POSITIVE); CGAL_NEF_TRACE(" ");CGAL_NEF_TRACEV(halfcircle_notin_hminus); if ( halfcircle_notin_hminus ) { s1 = *this; return 1; } else { s1 = Sphere_segment(source(),source(),sphere_circle()); s2 = Sphere_segment(target(),target(),sphere_circle()); return 2; } } else if ( or1 != CGAL::ON_NEGATIVE_SIDE && or2 != CGAL::ON_NEGATIVE_SIDE ) { // this case covers the endpoints of $s$ as part of the closed // oriented halfspace $h^{0+}$. At least one is part of // $h^{+}$. If $s$ is not long then the segment must be fully part // of $h^{0+}$. Otherwise if $s$ is long, then we at both ends // there are subsegments as part of $h^{0+}$ (one might be // degenerate). if ( is_long() ) { Sphere_point i1 = CGAL::intersection(this->ptr()->c_,c); Sphere_point i2 = i1.antipode(); Sphere_segment so(i1,i2,sphere_circle()); if ( so.has_on(source()) && so.has_on(target()) ) std::swap(i1,i2); // now source(),i1,i2,target() are circularly ordered s1 = Sphere_segment(source(),i1,sphere_circle()); s2 = Sphere_segment(i2,target(),sphere_circle()); CGAL_NEF_TRACEN(" both >= plane, long "<= plane, short "); s1=*this; return 1; } else if ( or1 != CGAL::ON_POSITIVE_SIDE && or2 != CGAL::ON_POSITIVE_SIDE ) { // either both endpoints of $s$ are in $h^-$ or one is in $h^-$ // and one on $h^0$. if ( is_long() ) { Sphere_point i1 = CGAL::intersection(this->ptr()->c_,c); Sphere_point i2 = i1.antipode(); Sphere_segment so(i1,i2,sphere_circle()); CGAL_NEF_TRACEN(" both <= plane, long"<(source(),source(),sphere_circle()); return 1; } if ( or2 == CGAL::ON_ORIENTED_BOUNDARY ) { s1 = Sphere_segment(target(),target(),sphere_circle()); return 1; } return 0; } CGAL_assertion_msg(0,"Oops, forgot some case."); return -1; } CGAL_END_NAMESPACE #endif //CGAL_SPHERE_PREDICATES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_checker.h0000644000175000017500000002153411344301501030256 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_checker.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SM_CHECKER_H #define CGAL_SM_CHECKER_H #include #include #define CGAL_USING(t) typedef typename Base::t t CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=SM_checker.man }*/ /*{\Manpage {SM_checker}{PMCDEC,GEOM}{Plane map checking}{}}*/ /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to check the structure of a plane map. It is generic with respect to two template concepts. |PMCDEC| has to be a decorator model of our |SM_const_decorator| concept. |GEOM| has to be a model of our geometry kernel concept.}*/ /*{\Mgeneralization SM_const_decorator}*/ template class SM_checker : public PMCDEC { typedef PMCDEC Base; const GEOM& K; public: /*{\Mtypes 3}*/ typedef PMCDEC SM_const_decorator; /*{\Mtypemember equals |PMCDEC|. Add link to PMCDEC concept.}*/ typedef typename PMCDEC::Plane_map Plane_map; /*{\Mtypemember equals |PMCDEC::Plane_map|, the underlying plane map type.}*/ typedef GEOM Geometry; /*{\Mtypemember equals |GEOM|. Add link to GEOM concept.\\ \precond |Geometry::Point_2| equals |Plane_map::Point|. }*/ typedef typename GEOM::Point_2 Point; typedef typename GEOM::Direction_2 Direction; CGAL_USING(Vertex_const_handle); CGAL_USING(SEdge_handle); CGAL_USING(Vertex_const_iterator); CGAL_USING(Halfedge_const_iterator); CGAL_USING(Halfedge_around_vertex_const_circulator); CGAL_USING(Halfedge_around_face_const_circulator); /*{\Mtext Iterators, handles, and circulators are inherited from |SM_const_decorator|.}*/ /*{\Mcreation 3}*/ SM_checker(Plane_map& P, const Geometry& k = Geometry()) : Base(P), K(k) {} /*{\Mcreate constructs a plane map checker working on |P| with geometric predicates used from |k|.}*/ SM_checker(const Base& D, const Geometry& k = Geometry()) : Base(D), K(k) {} /*{\Moperations 2 }*/ Direction direction(Halfedge_const_handle e) const { return K.construct_direction( point(source(e)),point(target(e))); } bool is_forward(Halfedge_const_handle e) const { return K.compare_xy(point(source(e)),point(target(e)))<0; } void check_order_preserving_embedding(Vertex_const_handle v) const; /*{\Mop checks if the embedding of the targets of the edges in the adjacency list |A(v)| is counter-clockwise order-preserving with respect to the order of the edges in |A(v)|.}*/ void check_order_preserving_embedding() const; /*{\Mop checks if the embedding of all vertices of |P| is counter-clockwise order-preserving with respect to the adjacency list ordering of all vertices.}*/ void check_forward_prefix_condition(Vertex_const_handle v) const; /*{\Mop checks the forward prefix property of the adjacency list of |v|.}*/ Halfedge_const_iterator check_boundary_is_clockwise_weakly_polygon() const; /*{\Mop checks if the outer face cycle of |P| is a clockwise weakly polygon and returns a halfedge on the boundary. \precond |P| is a connected graph. }*/ void check_is_triangulation() const; /*{\Mop checks if |P| is a triangulation.}*/ }; // SM_checker template void SM_checker:: check_order_preserving_embedding(Vertex_const_handle v) const { std::ostrstream error_status; CGAL::set_pretty_mode ( error_status ); Halfedge_const_handle ef = first_out_edge(v) ,e=ef,en,enn; error_status << "check_order_preserving_embedding\n"; error_status << "vertex " << PV(v) << endl; if ( e != Halfedge_const_handle() ) { while ( true ) { en = cyclic_adj_succ(e); enn = cyclic_adj_succ(en); if (en == ef) break; error_status << " -> " << point(target(e)); error_status << " " << point(target(en)) << " "; error_status << " " << point(target(enn)) << endl; if ( !K.strictly_ordered_ccw(direction(e),direction(en), direction(enn)) || !K.strictly_ordered_ccw(direction(e),direction(en), direction(ef)) ) { error_status << "ccw order violate!" << endl << '\0'; CGAL_assertion_msg(0,error_status.str()); } e = en; } } error_status.freeze(0); } template void SM_checker:: check_forward_prefix_condition(Vertex_const_handle v) const { Halfedge_const_handle ef = first_out_edge(v); if ( ef == Halfedge_const_handle() ) return; Halfedge_const_handle el = cyclic_adj_pred(ef); bool is_left_turn = K.left_turn(point(v), point(target(ef)), point(target(el))); bool el_forward = is_forward(el); bool ef_forward = is_forward(ef); CGAL_assertion_msg( (ef == el || ef_forward && !el_forward || ef_forward && el_forward && is_left_turn || !ef_forward && !el_forward && is_left_turn) , "check_forward_prefix_condition: first backward, last forward\n"); } template void SM_checker:: check_order_preserving_embedding() const { Vertex_const_iterator vit; for (vit = vertices_begin(); vit != vertices_end(); ++vit) { check_order_preserving_embedding(vit); check_forward_prefix_condition(vit); } } template typename SM_checker::Halfedge_const_iterator SM_checker:: check_boundary_is_clockwise_weakly_polygon() const { Vertex_const_iterator vit, v_min; for (vit = v_min = vertices_begin() ; vit != vertices_end(); ++vit) if ( K.compare_xy(point(vit), point(v_min))<0 ) v_min = vit; CGAL_assertion_msg(!is_isolated(v_min),"Minimal vertex not connected."); Sphere_point p_min = point(v_min); // determine boundary edge incident to v_min: Halfedge_const_handle e_boundary_at_v_min = first_out_edge(v_min); // all out edges are forward oriented due to minimality Halfedge_around_vertex_const_circulator hvit(e_boundary_at_v_min), hend(hvit); do { --hvit; Sphere_point p1 = point(target(e_boundary_at_v_min)); Sphere_point p2 = point(target(hvit)); if ( K.orientation(p_min,p1,p2) > 0 ) { // left_turn e_boundary_at_v_min = hvit; break; } } while (hvit != hend); // now e_boundary_at_v_min is highest starting edge in bundle!! int winding_around_globally=0; Halfedge_around_face_const_circulator hfit(e_boundary_at_v_min),hstart(hfit); Halfedge_const_handle e_prev = next(e_boundary_at_v_min); /* we run counterclockwise around the outer face cycle and allow only position where the direction vector of an edge gets smaller again */ Direction d_prev = direction(e_prev); CGAL_For_all_backwards(hstart,hfit) { Direction d_curr = direction(hfit); if ( d_curr < d_prev ) ++winding_around_globally; d_prev = d_curr; } CGAL_assertion(winding_around_globally == 1); return e_boundary_at_v_min; } template void SM_checker:: check_is_triangulation() const { Halfedge_const_iterator eb; check_integrity_and_topological_planarity(false); CGAL_assertion(number_of_connected_components() == 1); check_order_preserving_embedding(); eb = check_boundary_is_clockwise_weakly_polygon(); CGAL::Hash_map< Halfedge_const_iterator, bool> on_boundary(false); Halfedge_around_face_const_circulator hit(eb), hend(hit); std::ostrstream error_status; CGAL::set_pretty_mode ( error_status ); error_status << "check_is_triangulation\n"; error_status << "on boundary:\n"; CGAL_For_all(hit,hend) { error_status << " " << PE(hit) << endl; on_boundary[hit]=true; } Halfedge_const_iterator eit; for( eit = halfedges_begin(); eit != halfedges_end(); ++eit) { if (on_boundary[eit]) continue; hit = hend = eit; int edges_in_face_cycle=0; CGAL_For_all(hit,hend) { error_status << PE(hit); ++edges_in_face_cycle; } CGAL_assertion_msg(edges_in_face_cycle==3,error_status.str()); } error_status.freeze(0); } \subsection{Plane map input and output} The input and output is mainly triggered by an IO Decorator which has the control over the IO format and does some basic parsing when reading input. CGAL_END_NAMESPACE #undef CGAL_USING #endif // CGAL_SM_CHECKER_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_point_locator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_point_locato0000644000175000017500000004514611344301501031123 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_point_locator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SM_POINT_LOCATOR_H #define CGAL_SM_POINT_LOCATOR_H #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 47 #include CGAL_BEGIN_NAMESPACE /*{\Moptions print_title=yes }*/ /*{\Manpage {SM_point_locator}{Decorator} {Naive point location in plane maps}{PL}}*/ /*{\Mdefinition An instance |\Mvar| of data type |\Mname| encapsulates naive point location queries within a sphere map |M|. The two template parameters are specified via concepts. |SM_decorator_| must be a model of the concept |SMDecorator| as described in the appendix. |Geometry_| must be a model of the concept |AffineGeometryTraits_2| as described in the appendix. For a specification of plane maps see also the concept of |SMConstDecorator|.}*/ /*{\Mgeneralization Decorator}*/ template class SM_point_locator : public SM_decorator { protected: typedef SM_decorator Base; typedef SM_point_locator Self; typedef typename SM_decorator::Sphere_map Sphere_map; public: /*{\Mtypes 5}*/ typedef typename SM_decorator::Decorator_traits Decorator_traits; typedef typename Base::Mark Mark; /*{\Mtypemember the attribute of all objects (vertices, edges, loops, faces).}*/ typedef typename SM_decorator::Sphere_kernel Sphere_kernel; /*{\Mtypemember the sphere kernel.}*/ typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember points.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember segments.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember circles.}*/ typedef typename Sphere_kernel::Sphere_direction Sphere_direction; /*{\Mtypemember directions.}*/ /*{\Mtext Local types are handles, iterators and circulators of the following kind: |SVertex_const_handle|, |SVertex_const_iterator|, |SHalfedge_const_handle|, |SHalfedge_const_iterator|, |SHalfloop_const_handle|, |SHalfloop_const_iterator|, |SFace_const_handle|, |SFace_const_iterator|.}*/ typedef CGAL::Object_handle Object_handle; /*{\Mtypemember a generic handle to an object of the underlying plane map. The kind of the object |(vertex, halfedge,face)| can be determined and the object assigned by the three functions:\\ |bool assign(SVertex_const_handle& h, Object_handle o)|\\ |bool assign(SHalfedge_const_handle& h, Object_handle o)|\\ |bool assign(SFace_const_handle& h, Object_handle o)|\\ where each function returns |true| iff the assignment of |o| to |h| was valid.}*/ typedef typename Decorator_traits::SVertex_handle SVertex_handle; typedef typename Decorator_traits::SHalfedge_handle SHalfedge_handle; typedef typename Decorator_traits::SHalfloop_handle SHalfloop_handle; typedef typename Decorator_traits::SFace_handle SFace_handle; typedef typename Decorator_traits::SVertex_iterator SVertex_iterator; typedef typename Decorator_traits::SHalfedge_iterator SHalfedge_iterator; typedef typename Decorator_traits::SHalfloop_iterator SHalfloop_iterator; typedef typename Decorator_traits::SFace_iterator SFace_iterator; typedef typename Decorator_traits::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Decorator_traits::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; Sphere_segment segment(SHalfedge_handle e) const { return Sphere_segment(point(source(e)), point(target(e)), circle(e)); } Sphere_direction direction(SHalfedge_handle e) const { return Sphere_direction(circle(e)); } SHalfedge_handle out_wedge(SVertex_handle v, const Sphere_direction& d, bool& collinear) const /*{\Xop returns a halfedge |e| bounding a wedge in between two neighbored edges in the adjacency list of |v| which contains |d|. If |d| extends along a edge then |e| is this edge. If |d| extends into the interior of such a wedge then |e| is the first edge hit when |d| is rotated clockwise. \precond |v| is not isolated.}*/ { CGAL_NEF_TRACEN("out_wedge "<has_shalfloop() && circle(this->shalfloop()).has_on(p) ) { CGAL_NEF_TRACEN( " on loop"); return Object_handle(SHalfloop_handle(this->shalfloop())); } // now in face: if(this->number_of_sfaces() == 1) { CGAL_NEF_TRACEN(" on unique face"); SFace_handle f = this->sfaces_begin(); return Object_handle(f); } SVertex_handle v_res; SHalfedge_handle e_res; SHalfloop_handle l_res(this->shalfloop()); SOLUTION solution; CGAL_NEF_TRACEN(" on face..."); Sphere_segment s; // we shorten the segment iteratively if ( this->has_shalfloop() ) { Sphere_circle c(circle(this->shalfloop()),p); // orthogonal through p s = Sphere_segment(p,intersection(c,circle(this->shalfloop()))); l_res = circle(this->shalfloop()).has_on_positive_side(p) ? this->shalfloop() : twin(this->shalfloop()); solution = is_loop_; CGAL_NEF_TRACEN("has loop, initial ray "<number_of_svertices()!=0 ); SVertex_iterator vi = this->svertices_begin(); if( p == point(vi).antipode()) { ++vi; CGAL_assertion( vi != this->svertices_end()); } CGAL_NEF_TRACEN("initial segment: "< visited(false); CGAL_forall_svertices(v,*this) { Sphere_point vp = point(v); if ( s.has_on(vp) ) { CGAL_NEF_TRACEN(" location via vertex at "< Object_handle ray_shoot(const Sphere_point& p, const Sphere_direction& d, const Object_predicate& M) const /*{\Mop returns an |Object_handle o| which can be converted to a |SVertex_handle|, |SHalfedge_handle|, |SFace_handle| |h| as described above. The object predicate |M| has to have function operators \\ |bool operator() (const SVertex_/SHalfedge_/SHalfloop_/SFace_handle&)|.\\ The object returned is intersected by |d.circle()|, has minimal distance to |p|, and |M(h)| holds on the converted object. The operation returns the null handle |NULL| if the ray shoot along |s| does not hit any object |h| of |M| with |M(h)|.}*/ { Sphere_circle c(d.circle()); Sphere_segment s; bool s_init(false); Object_handle h = locate(p); SVertex_handle v; SHalfedge_handle e; SHalfloop_handle l; SFace_handle f; if ( CGAL::assign(v,h) && M(v) || CGAL::assign(e,h) && M(e) || CGAL::assign(l,h) && M(l) || CGAL::assign(f,h) && M(f) ) return h; h = Object_handle(); CGAL_NEF_TRACEN("not contained"); #if 0 HASEN: s am anfang circle, ab wann segment ? wo loop ? CGAL_forall_svertices (v,*this) { Point pv = point(v); if ( !(s_init && s.has_on(pv) || !s_init && c.has_on(pv)) ) continue; CGAL_NEF_TRACEN("candidate "< visited(false); SHalfedge_iterator e_res; CGAL_forall_sedges(e,*this) { Sphere_segment se = segment(e); Sphere_point p_res; if ( do_intersect_internally(se,s,p_res) ) { // internal intersection CGAL_NEF_TRACEN("candidate "<has_shalfloop()) { Sphere_circle cl(this->shalfloop()->circle()); if(!s_init) s = Sphere_segment(p,p.antipode(),c); Sphere_point p_res; if(!do_intersect_internally(cl,s,p_res)) return h; if(p_res == p.antipode()) p_res = p; if (start_inclusive || p != p_res) { ip = p_res; return Object_handle(this->shalfloop()); } } return h; } void marks_of_halfspheres(std::vector& mohs, int offset, int axis=2); void marks_of_halfspheres(Mark& unten, Mark& oben, int axis=2); /*{\Mimplementation Naive query operations are realized by checking the intersection points of the $1$-skeleton of the plane map |P| with the query segments $s$. This method takes time linear in the size $n$ of the underlying plane map without any preprocessing.}*/ }; // SM_point_locator template void SM_point_locator:: marks_of_halfspheres(std::vector& mohs, int offset, int axis) { Mark lower, upper; marks_of_halfspheres(lower, upper, axis); mohs[offset] = lower; mohs[offset+1] = upper; } template void SM_point_locator:: marks_of_halfspheres(Mark& lower, Mark& upper, int axis) { CGAL_NEF_TRACEN("marks_of_halfspheres "); Sphere_point y_minus; if(axis!=1) y_minus = Sphere_point(0,-1,0); else y_minus = Sphere_point(0,0,1); Object_handle h = locate(y_minus); SFace_handle f; if ( CGAL::assign(f,h) ) { CGAL_NEF_TRACEN("on face " << mark(f)); lower = upper = mark(f); return; } SHalfedge_handle e; if ( CGAL::assign(e,h) ) { CGAL_assertion(circle(e).has_on(y_minus)); Sphere_point op(CGAL::ORIGIN+circle(e).orthogonal_vector()); CGAL_NEF_TRACEN("on edge "< 0) || (op.x() == 0) && (op.y() < 0))) e = twin(e); if (axis==2 && ((op.x() > 0) || (op.x() == 0) && (op.z() < 0))) e = twin(e); upper = mark(face(e)); lower = mark(face(twin(e))); return; } SHalfloop_handle l; if ( CGAL::assign(l,h) ) { CGAL_assertion(circle(l).has_on(y_minus)); Sphere_point op(CGAL::ORIGIN+circle(l).orthogonal_vector()); CGAL_NEF_TRACEN("on loop "< 0) || (op.x() == 0) && (op.y() < 0))) l = twin(l); if (axis==2 && ((op.x() > 0) || (op.x() == 0) && (op.z() < 0))) l = twin(l); upper = mark(face(l)); lower = mark(face(twin(l))); return; } Sphere_circle c; switch(axis) { case 0: c = Sphere_circle(1,0,0); break; case 1: c = Sphere_circle(0,1,0); break; case 2: c = Sphere_circle(0,0,1); break; } Sphere_direction right(c),left(c.opposite()); bool collinear(false); SVertex_handle v; if ( CGAL::assign(v,h) ) { CGAL_assertion(point(v)==y_minus); if(is_isolated(v)) upper = lower = mark(face(v)); else { e = out_wedge(v,left,collinear); if ( collinear ) upper = mark(face(twin(e))); else upper = mark(face(e)); e = out_wedge(v,right,collinear); if ( collinear ) lower = mark(face(twin(e))); else lower = mark(face(e)); } } } CGAL_END_NAMESPACE #endif // CGAL_SM_POINT_LOCATOR_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_decorator_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_decorator_tr0000644000175000017500000000512511344301501031111 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_decorator_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef SM_DECORATOR_TRAITS_H #define SM_DECORATOR_TRAITS_H template class SM_decorator_traits { typedef Refs_ Refs; public: typedef typename Refs::SVertex_handle SVertex_handle; typedef typename Refs::SHalfedge_handle SHalfedge_handle; typedef typename Refs::SHalfloop_handle SHalfloop_handle; typedef typename Refs::SFace_handle SFace_handle; typedef typename Refs::SVertex_iterator SVertex_iterator; typedef typename Refs::SHalfedge_iterator SHalfedge_iterator; typedef typename Refs::SHalfloop_iterator SHalfloop_iterator; typedef typename Refs::SFace_iterator SFace_iterator; typedef typename Refs::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Refs::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Refs::SFace_cycle_iterator SFace_cycle_iterator; }; template class SM_decorator_const_traits { typedef Refs_ Refs; public: typedef typename Refs::SVertex_const_handle SVertex_handle; typedef typename Refs::SHalfedge_const_handle SHalfedge_handle; typedef typename Refs::SHalfloop_const_handle SHalfloop_handle; typedef typename Refs::SFace_const_handle SFace_handle; typedef typename Refs::SVertex_const_iterator SVertex_iterator; typedef typename Refs::SHalfedge_const_iterator SHalfedge_iterator; typedef typename Refs::SHalfloop_const_iterator SHalfloop_iterator; typedef typename Refs::SFace_const_iterator SFace_iterator; typedef typename Refs::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_circulator; typedef typename Refs::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_circulator; typedef typename Refs::SFace_cycle_const_iterator SFace_cycle_iterator; }; #endif // SM_DECORATOR_TRAITS_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_const_decorator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_const_decora0000644000175000017500000004105711344301501031071 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_const_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner // Peter Hachenberger #ifndef CGAL_SM_CONST_DECORATOR_H #define CGAL_SM_CONST_DECORATOR_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 67 #include CGAL_BEGIN_NAMESPACE template class SM_const_decorator { typedef SM_const_decorator Self; public: typedef Map_ Map; typedef const Map_ Sphere_map; typedef SM_decorator_const_traits Decorator_traits; /*{\Mdefinition ...}*/ /*{\Mtypes 5}*/ typedef typename Map::Sphere_kernel Sphere_kernel; /*{\Mtypemember spherical geometry.}*/ typedef typename Map::Sphere_point Sphere_point; /*{\Mtypemember embedding vertices.}*/ typedef typename Map::Sphere_segment Sphere_segment; /*{\Mtypemember embedding edges.}*/ typedef typename Map::Sphere_circle Sphere_circle; /*{\Mtypemember embedding loops.}*/ typedef typename Map::Sphere_direction Sphere_direction; /*{\Mtypemember embedding directions.}*/ typedef typename Map::Mark Mark; /*{\Mtypemember attributes of objects (vertices, edges, faces).}*/ typedef size_t Size_type; /*{\Mtypemember size type.}*/ typedef void* GenPtr; // typedef typename Map::Constructor_const_parameter Constructor_parameter; typedef typename Map::SVertex_const_handle SVertex_const_handle; typedef typename Map::SVertex_const_iterator SVertex_const_iterator; typedef typename Map::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Map::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Map::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Map::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename Map::SFace_const_handle SFace_const_handle; typedef typename Map::SFace_const_iterator SFace_const_iterator; /*{\Mtext Local types are handles, iterators and circulators of the following kind: |SVertex_handle|, |SVertex_iterator|, |SHalfedge_handle|, |SHalfedge_iterator|, |SHalfloop_handle|, |SHalfloop_iterator|, |SFace_handle|, |SFace_iterator|. Additionally the following circulators are defined.}*/ typedef typename Map::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; /*{\Mtypemember circulating the adjacency list of an vertex |v|.}*/ typedef typename Map::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_const_circulator; /*{\Mtypemember circulating the face cycle of an face |f|.}*/ typedef typename Map::SFace_cycle_const_iterator SFace_cycle_const_iterator; /*{\Mtypemember iterating all sface cycles of an sface |f|. The iterator has method |bool is_svertex()|, |bool is_shalfedge()|, |bool is_shalfloop()|, and can be converted to the corresponding handles |SVertex_const_handle|, |SHalfedge_const_handle|, or |SHalfloop_const_handle|.}*/ protected: const Map* psm_; void set_sm(const Map* W) { psm_ = W; } public: /*{\Mcreation 3}*/ SM_const_decorator() : psm_(0) {} SM_const_decorator(const Self& D) : psm_(D.psm_) {} Self& operator=(const Self& D) { psm_=D.psm_; return *this; } SM_const_decorator(const Map* M) : psm_(M) {} /*{\Mcreate constructs a plane map decorator exploring |M|.}*/ /*{\Moperations 4 4}*/ const Map* sphere_map() const { return psm_; } SVertex_const_handle source(SHalfedge_const_handle e) const /*{\Mop returns the source of |e|.}*/ { return e->source(); } SVertex_const_handle target(SHalfedge_const_handle e) const /*{\Mop returns the target of |e|.}*/ { return e->twin()->source(); } SHalfedge_const_handle twin(SHalfedge_const_handle e) const /*{\Mop returns the twin of |e|.}*/ { return e->twin(); } SHalfloop_const_handle twin(SHalfloop_const_handle l) const /*{\Mop returns the twin of |l|.}*/ { return l->twin(); } bool is_isolated(SVertex_const_handle v) const /*{\Mop returns |true| when |v| is linked to the interior of a face.}*/ { return (SHalfedge_const_handle(v->out_sedge()) == SHalfedge_const_handle()); } SHalfedge_const_handle first_out_edge(SVertex_const_handle v) const /*{\Mop returns one edge with source |v|. It's the starting point for the circular iteration over the edges with source |v|. \precond |!is_isolated(v)|.}*/ { return v->out_sedge(); } SHalfedge_const_handle last_out_edge(SVertex_const_handle v) const /*{\Mop returns one edge with source |v|. \precond |!is_isolated(v)|.}*/ { return cap(v->out_sedge()); } SHalfedge_const_handle cyclic_adj_succ(SHalfedge_const_handle e) const /*{\Mop returns the edge after |e| in the cyclic ordered adjacency list of |source(e)|.}*/ { return e->sprev()->twin(); } SHalfedge_const_handle cyclic_adj_pred(SHalfedge_const_handle e) const /*{\Mop returns the edge before |e| in the cyclic ordered adjacency list of |source(e)|.}*/ { return e->twin()->snext(); } SHalfedge_const_handle next(SHalfedge_const_handle e) const /*{\Mop returns the next edge in the face cycle containing |e|.}*/ { return e->snext(); } SHalfedge_const_handle previous(SHalfedge_const_handle e) const /*{\Mop returns the previous edge in the face cycle containing |e|.}*/ { return e->sprev(); } SFace_const_handle face(SHalfedge_const_handle e) const /*{\Mop returns the face incident to |e|.}*/ { return e->incident_sface(); } SFace_const_handle face(SHalfloop_const_handle l) const /*{\Mop returns the face incident to |l|.}*/ { return l->incident_sface(); } SFace_const_handle face(SVertex_const_handle v) const /*{\Mop returns the face incident to |v|. \precond |is_isolated(v)|.}*/ { return v->incident_sface(); } /*{\Mtext \headerline{Iteration} \setopdims{3.3cm}{0cm}}*/ SVertex_const_iterator svertices_begin() const { return psm_->svertices_begin(); } SVertex_const_iterator svertices_end() const { return psm_->svertices_end(); } SHalfedge_const_iterator shalfedges_begin() const { return psm_->shalfedges_begin(); } SHalfedge_const_iterator shalfedges_end() const { return psm_->shalfedges_end(); } SFace_const_iterator sfaces_begin() const { return psm_->sfaces_begin(); } SFace_const_iterator sfaces_end() const { return psm_->sfaces_end(); } SHalfloop_const_iterator shalfloops_begin() const { return psm_->shalfloops_begin(); } SHalfloop_const_iterator shalfloops_end() const { return psm_->shalfloops_end(); } SHalfloop_const_handle shalfloop() const /*{\Mop returns access to the loop.}*/ { return psm_->shalfloop(); } bool has_shalfloop() const /*{\Mop returns true iff there is a loop.}*/ { return psm_->has_shalfloop(); } SHalfedge_around_svertex_const_circulator out_edges(SVertex_const_handle v) const /*{\Mop returns a circulator for the cyclic adjacency list of |v|. \precond the adjacency list is not empty.}*/ { return SHalfedge_around_svertex_const_circulator(first_out_edge(v)); } SFace_cycle_const_iterator sface_cycles_begin(SFace_const_handle f) const /*{\Mop returns an iterator for all bounding face cycles of |f|. The iterator is is convertable to |SVertex_const_handle|, |SHalfloop_const_handle|, or |SHalfedge_const_handle|.}*/ { return f->boundary_entry_objects_.begin(); } SFace_cycle_const_iterator sface_cycles_end(SFace_const_handle f) const /*{\Mop returns the past the end iterator of |f|.}*/ { return f->boundary_entry_objects_.end(); } /*{\Mtext \headerline{Statistics and Integrity}}*/ Size_type number_of_svertices() const /*{\Mop returns the number of vertices.}*/ { return psm_->number_of_svertices(); } Size_type number_of_shalfedges() const /*{\Mop returns the number of halfedges.}*/ { return psm_->number_of_shalfedges(); } Size_type number_of_sedges() const /*{\Mop returns the number of edges.}*/ { return number_of_shalfedges()/2; } Size_type number_of_shalfloops() const /*{\Mop returns the number of halfloops.}*/ { return psm_->number_of_shalfloops(); } Size_type number_of_sloops() const /*{\Mop returns the number of loops.}*/ { return psm_->number_of_shalfloops()/2; } Size_type number_of_sfaces() const /*{\Mop returns the number of faces.}*/ { return psm_->number_of_sfaces(); } Size_type number_of_sface_cycles() const; /*{\Mop returns the number of face cycles.}*/ Size_type number_of_connected_components() const; /*{\Mop calculates the number of connected components of |P|.}*/ void print_statistics(std::ostream& os = std::cout) const /*{\Mop print the statistics of |P|: the number of vertices, edges, and faces.}*/ { os << "Sphere Map - Statistics\n"; os << "|V| = " << number_of_svertices() << std::endl; os << "|E| = " << number_of_shalfedges() << std::endl; os << "|L| = " << number_of_shalfloops() << std::endl; os << "|F| = " << number_of_sfaces() << std::endl; os << "|Fcs| = " << number_of_sface_cycles() << std::endl << std::endl; } void check_integrity_and_topological_planarity(bool faces=true) const; /*{\Mop checks the link structure and the genus of |P|.}*/ SHalfedge_const_handle cas(SHalfedge_const_handle e) const { return cyclic_adj_succ(e); } SHalfedge_const_handle cap(SHalfedge_const_handle e) const { return cyclic_adj_pred(e); } template bool is_sm_boundary_object(H h) const { return psm_->is_sm_boundary_object(h); } /*{\Mtext \headerline{Associated Information}\restoreopdims}*/ const Sphere_point& point(SVertex_const_handle v) const /*{\Mop returns the embedding of |v|.}*/ { return v->point(); } const Sphere_circle& circle(SHalfedge_const_handle e) const /*{\Mop returns the circle supporting |e|.}*/ { return e->circle(); } const Sphere_circle& circle(SHalfloop_const_handle l) const /*{\Mop returns the circle supporting |l|.}*/ { return l->circle(); } const Mark& mark(SVertex_const_handle v) const /*{\Mop returns the mark of |v|.}*/ { return v->mark(); } const Mark& mark(SHalfedge_const_handle e) const /*{\Mop returns the mark of |e|.}*/ { return e->mark(); } const Mark& mark(SHalfloop_const_handle l) const /*{\Mop returns the mark of |l|.}*/ { return ( &*l < &*twin(l) ) ? l->mark() : twin(l)->mark(); } const Mark& mark(SFace_const_handle f) const /*{\Mop returns the mark of |f|.}*/ { return f->mark(); } /*{\Mtext \headerline{Iteration}}*/ /*{\Mtext The list of all objects can be accessed via iterator ranges. For comfortable iteration we also provide iterations macros. The iterator range access operations are of the following kind:\\ |SVertex_iterator svertices_begin()/svertices_end()|\\ |SHalfedge_iterator shalfedges_begin()/shalfedges_end()|\\ |SHalfloop_iterator shalfloops_begin()/shalfloops_end()|\\ |SFace_iterator sfaces_begin()/sfaces_end()| The macros are then |CGAL_forall_svertices(v,M)|, |CGAL_forall_shalfedges(e,M)|, |CGAL_forall_sedges(e,M)|, |CGAL_forall_sfaces(f,M)|, |CGAL_forall_sface_cycles_of(fc,F)| where |M| is a sphere map and |F| is a sface.}*/ }; // SM_const_decorator template void SM_const_decorator:: check_integrity_and_topological_planarity(bool faces) const { CGAL_NEF_TRACEN("check_integrity_and_topological_planarity:"); using CGAL::Object_index; Object_index VI(svertices_begin(),svertices_end(),'v'); Object_index EI(shalfedges_begin(),shalfedges_end(),'e'); Object_index FI(sfaces_begin(),sfaces_end(),'f'); typedef SHalfedge_around_svertex_const_circulator hvc_circulator; typedef SHalfedge_around_sface_const_circulator hfc_circulator; SVertex_const_handle v; int iso_vert_num=0; /* check the source links of out edges and count isolated vertices */ CGAL_forall_svertices(v,*this) { if ( is_isolated(v) ) { if ( faces ) CGAL_assertion_msg(face(v) != SFace_const_handle(), VI(v).c_str()); ++iso_vert_num; } else { CGAL_assertion_msg(first_out_edge(v) != SHalfedge_const_handle(), VI(v).c_str()); CGAL_NEF_TRACEN(point(v)<<" "< typename SM_const_decorator::Size_type SM_const_decorator:: number_of_sface_cycles() const { unsigned int fc_num=0; CGAL::Unique_hash_map visited; SHalfedge_const_iterator e; CGAL_forall_shalfedges(e,*this) { if (visited[e]) continue; SHalfedge_around_sface_const_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) visited[hfc]=true; ++fc_num; } if ( has_shalfloop() ) fc_num += 2; return fc_num; } template typename SM_const_decorator::Size_type SM_const_decorator:: number_of_connected_components() const { int comp_num=0; CGAL::Unique_hash_map visited(false); SVertex_const_iterator v; CGAL_forall_svertices(v,*this) { if (visited[v]) continue; std::list L; L.push_back(v); visited[v]=true; /* we keep the invariant that all nodes which have been stacked are marked visited */ while (!L.empty()) { SVertex_const_iterator vc = L.front(); L.pop_front(); if ( is_isolated(vc) ) continue; SHalfedge_around_svertex_const_circulator havc(first_out_edge(vc)), hend(havc); CGAL_For_all(havc,hend) { if (!visited[target(havc)]) { L.push_back(target(havc)); visited[target(havc)]=true; } } } ++comp_num; } return comp_num; } CGAL_END_NAMESPACE #endif // CGAL_SM_CONST_DECORATOR_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_constrained_triang_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_constrained_0000644000175000017500000003315411344301501031075 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_constrained_triang_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SM_CONSTRAINED_TRIANG_TRAITS_H #define CGAL_SM_CONSTRAINED_TRIANG_TRAITS_H #include #include #include //#include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 139 #include CGAL_BEGIN_NAMESPACE /* For a detailed documentation see the MPI research report 2001-1-003 which documents the planar flavor of this baby; only minor deviations are included in this code */ template class SM_constrained_triang_traits : public Decorator_ { public: typedef SM_constrained_triang_traits Self; typedef Decorator_ Base; typedef typename Kernel_::Point_2 Point; typedef typename Kernel_::Segment_2 Segment; typedef typename Base::SHalfedge_handle SHalfedge_handle; typedef typename Base::SVertex_handle SVertex_handle; typedef typename Base::SFace_handle SFace_handle; typedef typename Base::SHalfedge_iterator SHalfedge_iterator; typedef typename Base::SVertex_iterator SVertex_iterator; typedef typename Base::SFace_iterator SFace_iterator; typedef typename Base::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; // the types interfacing the sweep: typedef std::pair INPUT; typedef Decorator_ OUTPUT; typedef Kernel_ GEOMETRY; class lt_edges_in_sweepline : public Decorator_ { const Point& p; const SHalfedge_handle& e_bottom; const SHalfedge_handle& e_top; const Kernel_& K; public: lt_edges_in_sweepline(const Point& pi, const SHalfedge_handle& e1, const SHalfedge_handle& e2, const Decorator_& D, const Kernel_& k) : Decorator_(D), p(pi), e_bottom(e1), e_top(e2), K(k) {} lt_edges_in_sweepline(const lt_edges_in_sweepline& lt) : Decorator_(lt), p(lt.p), e_bottom(lt.e_bottom), e_top(lt.e_top), K(lt.K) {} Segment seg(const SHalfedge_handle& e) const { return K.construct_segment(point(source(e)),point(target(e))); } int orientation(SHalfedge_handle e, const Point& p) const { return K.orientation(point(source(e)),point(target(e)),p); } bool operator()(const SHalfedge_handle& e1, const SHalfedge_handle& e2) const { // Precondition: // [[p]] is identical to the source of either [[e1]] or [[e2]]. if (e1 == e_bottom || e2 == e_top) return true; if (e2 == e_bottom || e1 == e_top) return false; if ( e1 == e2 ) return 0; int s = 0; if ( p == point(source(e1)) ) s = orientation(e2,p); else if ( p == point(source(e2)) ) s = - orientation(e1,p); else CGAL_assertion_msg(0,"compare error in sweep."); if ( s || source(e1) == target(e1) || source(e2) == target(e2) ) return ( s < 0 ); s = orientation(e2,point(target(e1))); if (s==0) CGAL_assertion_msg(0,"parallel edges not allowed."); return ( s < 0 ); } }; // lt_edges_in_sweepline class lt_pnts_xy : public Decorator_ { const Kernel_& K; public: lt_pnts_xy(const Decorator_& D, const Kernel_& k) : Decorator_(D), K(k) {} lt_pnts_xy(const lt_pnts_xy& lt) : Decorator_(lt), K(lt.K) {} int operator()(const SVertex_handle& v1, const SVertex_handle& v2) const { return K.compare_xy(point(v1),point(v2)) < 0; } }; // lt_pnts_xy typedef std::map Sweep_status_structure; typedef typename Sweep_status_structure::iterator ss_iterator; typedef typename Sweep_status_structure::value_type ss_pair; typedef std::set Event_Q; typedef typename Event_Q::const_iterator event_iterator; const GEOMETRY& K; Event_Q event_Q; event_iterator event_it; SVertex_handle event; Point p_sweep; Sweep_status_structure SL; CGAL::Unique_hash_map SLItem; SHalfedge_handle e_low,e_high; // framing edges ! SHalfedge_handle e_search; SVertex_iterator v_first, v_beyond; SM_constrained_triang_traits(const INPUT& in, OUTPUT& out, const GEOMETRY& k) : Base(out), K(k), event_Q(lt_pnts_xy(*this,K)), SL(lt_edges_in_sweepline(p_sweep,e_low,e_high,*this,K)), SLItem(SL.end()), v_first(in.first), v_beyond(in.second) { CGAL_NEF_TRACEN("Constrained Triangulation Sweep"); } /* |treat_new_sedge| is used to forward information that exists at input edges of the triangulation as such it spreads input information to the newly created edges of the triangulation; the used operation incident_mark refers to the base class of |*this| */ void treat_new_edge(SHalfedge_handle e) { assoc_info(e); mark(e) = incident_mark(e) = incident_mark(twin(e)) = incident_mark(next(e)); CGAL_NEF_TRACEN(" treat_new_edge "< 0 ); // left_turn } void triangulate_up(SHalfedge_handle& e_apex) { CGAL_NEF_TRACEN("triangulate_up "< e is lowest in ingoing bundle only outgoing => e is highest in outgoing bundle ingoing and outgoing => e is lowest in ingoing bundle */ eb_high = e_end = ep; eb_low = e; CGAL_NEF_TRACEN("determining handle in SL"); if ( e != SHalfedge_handle() ) { point(target(e_search)) = p_sweep; // degenerate loop edge sit_pred = SLItem[e]; if ( sit_pred != SL.end()) sit = --sit_pred; else sit = sit_pred = --SL.upper_bound(e_search); } else { // event is isolated vertex point(target(e_search)) = p_sweep; // degenerate loop edge sit_pred = --SL.upper_bound(e_search); } bool ending_edges(0), starting_edges(0); while ( e != SHalfedge_handle() ) { // walk adjacency list clockwise if ( SLItem[e] != SL.end() ) { CGAL_NEF_TRACEN("ending " << segment(e)); if (ending_edges) triangulate_between(e,cyclic_adj_succ(e)); ending_edges = true; SL.erase(SLItem[e]); link_bi_edge_to(e,SL.end()); // not in SL anymore } else { CGAL_NEF_TRACEN("starting "<second; SHalfedge_handle e_vis_n = cyclic_adj_succ(e_vis); eb_low = eb_high = new_bi_edge(event,e_vis_n); CGAL_NEF_TRACEN(" producing link "<second = eb_low; } bool event_exists() { if ( event_it != event_Q.end() ) { // event is set at end of loop and in init event = *event_it; p_sweep = point(event); return true; } return false; } void procede_to_next_event() { ++event_it; } void link_bi_edge_to(SHalfedge_handle e, ss_iterator sit) { SLItem[e] = SLItem[twin(e)] = sit; } void initialize_structures() { CGAL_NEF_TRACEN("initialize_structures "); for ( event = v_first; event != v_beyond; ++event ) event_Q.insert(event); // sorted order of vertices event_it = event_Q.begin(); if ( event_Q.empty() ) return; event = *event_it; p_sweep = point(event); if ( !is_isolated(event) ) { SHalfedge_around_svertex_circulator e(first_out_edge(event)), eend(e); CGAL_For_all(e,eend) { CGAL_NEF_TRACEN("init with "< C(*this,K); C.check_order_preserving_embedding(event); #endif } void check_invariants() { #ifdef CGAL_CHECK_EXPENSIVEXXX if ( event_it == event_Q.end() ) return; check_ccw_local_embedding(); #endif } void check_final() { #ifdef CGAL_CHECK_EXPENSIVEXXX PM_checker C(*this,K); C.check_is_triangulation(); #endif } }; // SM_constrained_triang_traits CGAL_END_NAMESPACE #endif // CGAL_SM_CONSTRAINED_TRIANG_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Tuple.h0000644000175000017500000000317211344301501027342 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Tuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_TUPLE_H #define CGAL_TUPLE_H #include CGAL_BEGIN_NAMESPACE template class Tuple { typedef Tuple Self; T object_[n]; public: Tuple() { for (unsigned i=0; i1); object_[0]=t1; object_[1]=t2; } Tuple(const T& t1, const T& t2, const T& t3) { CGAL_assertion(n>2); object_[0]=t1; object_[1]=t2; object_[2]=t3; } Tuple(const Self& t) { for (unsigned i=0; i #ifndef CGAL_SM_LIST_H #define CGAL_SM_LIST_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE /* template class move_edge_around_svertex { public: void forward(HE& e) const { e = (e->sprev()->twin()); } void backward(HE& e) const { e = (e->twin()->snext()); } }; template struct move_edge_around_sface { void forward(HE& e) const { e = (e->snext()); } void backward(HE& e) const { e = (e->sprev()); } }; */ template < class SVertex> class SNC_in_place_list_svertex : public SVertex, public In_place_list_base > { public: typedef SNC_in_place_list_svertex Self; // typedef typename SVertex::SVertex_handle SVertex_handle; // typedef typename SVertex::SVertex_const_handle SVertex_const_handle; SNC_in_place_list_svertex() {} SNC_in_place_list_svertex(const SVertex& v) // down cast : SVertex(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((SVertex*)this) = ((const SVertex&)v); return *this; } }; template < class SHalfedge> class SNC_in_place_list_shalfedge : public SHalfedge, public In_place_list_base > { public: typedef SNC_in_place_list_shalfedge Self; // typedef typename SHalfedge::SHalfedge_handle SHalfedge_handle; // typedef typename SHalfedge::SHalfedge_const_handle SHalfedge_const_handle; SNC_in_place_list_shalfedge() {} SNC_in_place_list_shalfedge(const SHalfedge& v) // down cast : SHalfedge(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((SHalfedge*)this) = ((const SHalfedge&)v); return *this; } }; template < class SFace> class SNC_in_place_list_sface : public SFace, public In_place_list_base > { public: typedef SNC_in_place_list_sface Self; // typedef typename SFace::SFace_handle SFace_handle; // typedef typename SFace::SFace_const_handle SFace_const_handle; SNC_in_place_list_sface() {} SNC_in_place_list_sface(const SFace& v) // down cast : SFace(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((SFace*)this) = ((const SFace&)v); return *this; } }; CGAL_END_NAMESPACE #endif // CGAL_SM_LIST_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_point.h0000644000175000017500000001135111344301501030706 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_point.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_POINT_H #define CGAL_SPHERE_POINT_H #include CGAL_BEGIN_NAMESPACE /*{\Mtext \headerline{Restricted Spherical Geometry} We introduce geometric objects that are part of the spherical surface $S_2$ and operations on them. We define types |Sphere_point|, |Sphere_circle|, |Sphere_segment|, and |Sphere_direction|. |Sphere_point|s are points on $S_2$, |Sphere_circle|s are oriented great circles of $S_2$, |Sphere_segment|s are oriented parts of |Sphere_circles| bounded by a pair of |Sphere_point|s, and |Sphere_direction|s are directions that are part of great circles (a direction is usually defined to be a vector without length, that floats around in its underlying space and can be used to specify a movement at any point of the underlying space; in our case we use directions only at points that are part of the great circle that underlies also the direction.) Note that we have to consider special geometric properties of the objects. For example two points that are part of a great circle define two |Sphere_segment|s, and two arbitrary |Sphere_segment|s can intersect in two points. If we restrict our geometric objects to a so-called perfect hemisphere of $S_2$\footnote{A perfect hemisphere of $S_2$ is an open half-sphere plus an open half-circle in the boundary of the open half-sphere plus one endpoint of the half-circle.} then the restricted objects behave like in classical geometry, e.g., two points define exactly one segment, two segments intersect in at most one interior point (non-degenerately), or three non-cocircular sphere points can be qualified as being positively or negatively oriented.}*/ /*{\Moptions print_title=yes }*/ /*{\Manpage{Sphere_point}{R}{Points on the unit sphere}{p}}*/ template class Sphere_point : public R_::Point_3 { /*{\Mdefinition An object |\Mvar| of type |\Mname| is a point on the surface of a unit sphere. Such points correspond to the nontrivial directions in space and similarly to the equivalence classes of all nontrivial vectors under normalization.}*/ public: /*{\Mtypes 5}*/ typedef R_ R; /*{\Mtypemember representation class.}*/ typedef typename R_::FT FT; /*{\Xtypemember ring number type.}*/ typedef typename R_::RT RT; /*{\Mtypemember field number type.}*/ typedef Sphere_point Self; typedef typename R::Point_3 Base; typedef typename R::Vector_3 Vector_3; typedef typename R::Direction_3 Direction_3; /*{\Mcreation 5}*/ Sphere_point() : Base() {} /*{\Mcreate creates some sphere point.}*/ Sphere_point(int x, int y, int z) : Base(x,y,z,1) { CGAL_assertion(x!=0 || y!=0 || z!=0); } Sphere_point(const RT& x, const RT& y, const RT& z) : /*{\Mcreate creates a sphere point corresponding to the point of intersection of the ray starting at the origin in direction $(x,y,z)$ and the surface of $S_2$.}*/ Base(x,y,z,1) { CGAL_assertion(x!=0 || y!=0 || z!=0); } Sphere_point(const Base& p) : Base(p) {} Sphere_point(const Vector_3& v) : Base(CGAL::ORIGIN+v) {} Sphere_point(const Direction_3& d) : Base(CGAL::ORIGIN+d.vector()) {} /*{\Moperations 4 2}*/ /*{\Mtext Access to the coordinates is provided by the following operations. Note that the vector $(x,y,z)$ is not normalized.}*/ RT x() const { return ((Base*) this)->hx(); } /*{\Mop the $x$-coordinate.}*/ RT y() const { return ((Base*) this)->hy(); } /*{\Mop the $y$-coordinate.}*/ RT z() const { return ((Base*) this)->hz(); } /*{\Mop the $z$-coordinate.}*/ bool operator==(const Sphere_point& q) const /*{\Mbinop Equality.}*/ { return Direction_3(Base(*this)-ORIGIN)== Direction_3(q-ORIGIN); } bool operator!=(const Sphere_point& q) const /*{\Mbinop Inequality.}*/ { return !operator==(q); } Sphere_point antipode() const /*{\Mop returns the antipode of |\Mvar|.}*/ { return ORIGIN + -(Base(*this)-ORIGIN); } }; // Sphere_point template CGAL::Point_3 operator+( const CGAL::Point_3& p, const Sphere_point& q) { return p + (q-CGAL::ORIGIN); } CGAL_END_NAMESPACE #endif //CGAL_SPHERE_POINT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_iteration.h0000644000175000017500000000350211344301501030643 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_iteration.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_SM_ITERATION_H #define CGAL_SM_ITERATION_H #undef CGAL_forall_iterators #define CGAL_forall_iterators(x,S)\ for(x = (S).begin(); x != (S).end(); ++x) #undef CGAL_forall_svertices #define CGAL_forall_svertices(x,SM)\ for(x = (SM).svertices_begin(); x != (SM).svertices_end(); ++x) #undef CGAL_forall_shalfedges #define CGAL_forall_shalfedges(x,SM)\ for(x = (SM).shalfedges_begin(); x != (SM).shalfedges_end(); ++x) #undef CGAL_forall_sedges #define CGAL_forall_sedges(x,SM)\ for(x = (SM).shalfedges_begin(); x != (SM).shalfedges_end(); ++(++x)) #undef CGAL_forall_shalfloops #define CGAL_forall_shalfloops(x,SM)\ for(x = (SM).shalfloops_begin(); x != (SM).shalfloops_end(); ++x) #undef CGAL_forall_sfaces #define CGAL_forall_sfaces(x,SM)\ for(x = (SM).sfaces_begin(); x != (SM).sfaces_end(); ++x) #undef CGAL_forall_sface_cycles_of #define CGAL_forall_sface_cycles_of(x,F)\ for(x = (F)->sface_cycles_begin(); x != (F)->sface_cycles_end(); ++x) #endif //CGAL_SM_ITERATION_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_triangle.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_triangle0000644000175000017500000000746311344301501031145 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_triangle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_TRIANGLE_H #define CGAL_SPHERE_TRIANGLE_H #include #include #include CGAL_BEGIN_NAMESPACE template class Sphere_triangle_rep { typedef Sphere_point Point; typedef Sphere_circle Circle; typedef Sphere_triangle_rep Rep; Tuple points_; Tuple circles_; friend class Sphere_triangle; Sphere_triangle_rep(const Point& p1, const Point& p2, const Point& p3, const Circle& c1, const Circle& c2, const Circle& c3) : points_(p1,p2,p3), circles_(c1,c2,c3) {} public: Sphere_triangle_rep() : points_(), circles_() {} Sphere_triangle_rep(const Rep& r) : points_(r.points_), circles_(r.circles_) {} }; /*{\Manpage{Sphere_triangle}{R}{Triangles on the unit sphere}{t}}*/ template class Sphere_triangle : public Handle_for< Sphere_triangle_rep > { /*{\Mdefinition An object |\Mvar| of type |\Mname| is a triangle on the surface of the unit sphere.}*/ public: /*{\Mtypes 5}*/ typedef R_ R; /*{\Mtypemember representation class.}*/ typedef typename R::RT RT; /*{\Mtypemember ring type.}*/ typedef Sphere_triangle_rep Rep; typedef Handle_for Base; /*{\Mcreation 5}*/ Sphere_triangle() : Base() {} /*{\Mcreate creates some triangle.}*/ Sphere_triangle( const Sphere_point& p0, const Sphere_point& p1, const Sphere_point& p2, const Sphere_circle& c0, const Sphere_circle& c1, const Sphere_circle& c2) : Base(Rep(p0,p1,p2,c0,c1,c2)) /*{\Mcreate creates a triangle spanned by the three points |p0|, |p1|, |p2|, where the triangle is left of the three circles |c0|, |c1|, |c2|. \precond $c_i$ contains $p_i$ and $p_{i+1}$ mod 3.}*/ { CGAL_assertion( c0.has_on(p0) && c0.has_on(p1) ); CGAL_assertion( c1.has_on(p1) && c1.has_on(p2) ); CGAL_assertion( c2.has_on(p2) && c0.has_on(p0) ); } Sphere_triangle(const Sphere_triangle& t) : Base(t) {} /*{\Moperations 4 2}*/ const Sphere_point& point(unsigned i) const /*{\Mop returns the ith point of |\Mvar|.}*/ { return this->ptr()->points_[i%3]; } const Sphere_circle& circle(unsigned i) const /*{\Mop returns the ith circle of |\Mvar|.}*/ { return this->ptr()->circles_[i%3]; } Sphere_triangle opposite() const /*{\Mop returns the opposite of |\Mvar|.}*/ { return Sphere_triangle(point(0), point(1), point(2), circle(0).opposite(), circle(1).opposite(), circle(2).opposite()); } }; // Sphere_triangle template std::ostream& operator<<(std::ostream& os, const CGAL::Sphere_triangle& t) { for (int i=0; i<3; ++i) os << t.point(i); for (int i=0; i<3; ++i) os << t.circle(i); return os; } template std::istream& operator>>(std::istream& is, CGAL::Sphere_triangle& t) { CGAL::Sphere_point p1,p2,p3; CGAL::Sphere_circle c1,c2,c3; if ( !(is >> p1 >> p2 >> p3 >> c1 >> c2 >> c3) ) return is; t = CGAL::Sphere_triangle(p1,p2,p3,c1,c2,c3); return is; } CGAL_END_NAMESPACE #endif //CGAL_SPHERE_TRIANGLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_overlayer.h0000644000175000017500000016002411344301501030660 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_overlayer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SM_OVERLAYER_H #define CGAL_SM_OVERLAYER_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 131 #include #ifndef CGAL_USE_LEDA #define LEDA_MEMORY(t) #endif CGAL_BEGIN_NAMESPACE template struct SMO_from_segs { typedef Decorator_ SM_decorator; typedef typename SM_decorator::SVertex_handle Vertex_handle; typedef typename SM_decorator::SHalfedge_handle Halfedge_handle; typedef typename SM_decorator::Sphere_point Point; typedef typename SM_decorator::Sphere_segment Segment; typedef CGAL::Unique_hash_map Iterator_map; SM_decorator G; const Iterator_map& M; SMO_from_segs(SM_decorator Gi, const Iterator_map& Mi) : G(Gi),M(Mi) {} Vertex_handle new_vertex(const Point& p) { Vertex_handle v = G.new_svertex(p); geninfo::create(G.info(v)); return v; } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) { G.link_as_target_and_append(v,e); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) { Halfedge_handle e = G.new_shalfedge_pair_at_source(v,SM_decorator::BEFORE); return e; } void supporting_segment(Halfedge_handle e, I it) const { if ( M[it] ) G.mark(e) = true; } void trivial_segment(Vertex_handle v, I it) const { if ( M[it] ) G.mark(v) = true; } void starting_segment(Vertex_handle v, I it) const { if ( M[it] ) G.mark(v) = true; } void passing_segment(Vertex_handle v, I it) const { if ( M[it] ) G.mark(v) = true; } void ending_segment(Vertex_handle v, I it) const { if ( M[it] ) G.mark(v) = true; } void halfedge_below(Vertex_handle v, Halfedge_handle e) const { geninfo::access(G.info(v)) = e; } Halfedge_handle halfedge_below(Vertex_handle v) const { return geninfo::access(G.info(v)); } void assert_equal_marks(Vertex_handle v1, Vertex_handle v2) const { CGAL_assertion(G.mark(v1)==G.mark(v2)); } void discard_info(Vertex_handle v) const { geninfo::clear(G.info(v)); } void assert_equal_marks(Halfedge_handle e1, Halfedge_handle e2) const { CGAL_assertion(G.mark(e1)==G.mark(e2)); } void discard_info(Halfedge_handle e) const {} void clear_temporary_vertex_info() const { Vertex_handle v; CGAL_forall_svertices(v,G) geninfo::clear(G.info(v)); } }; // SMO_from_segs template struct SMO_from_sm { typedef typename SM_overlayer::SM_const_decorator SM_const_decorator; typedef typename SM_overlayer::SVertex_handle Vertex_handle; typedef typename SM_overlayer::SHalfedge_handle Halfedge_handle; typedef typename SM_overlayer::Sphere_point Point; typedef typename SM_overlayer::Sphere_segment Segment; SM_overlayer G; SM_const_decorator* pGI; CGAL::Unique_hash_map& M; SMO_from_sm(SM_overlayer Gi, SM_const_decorator* pGIi, CGAL::Unique_hash_map& Mi) : G(Gi), pGI(pGIi), M(Mi) {} Vertex_handle new_vertex(const Point& p) { Vertex_handle v = G.new_svertex(p); G.assoc_info(v); return v; } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) { G.link_as_target_and_append(v,e); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) { Halfedge_handle e = G.new_shalfedge_pair_at_source(v,SM_overlayer::BEFORE); G.assoc_info(e); return e; } void halfedge_below(Vertex_handle v, Halfedge_handle e) const { G.halfedge_below(v) = e; } void supporting_segment(Halfedge_handle e, IT it) const { INFO& si = M[it]; G.is_forward(e) = true; if ( si._from == -1 ) return; // equatorial segment G.supp_object(e,si._from) = si._o; CGAL_NEF_TRACEN(" supporting segment "<point()); } void starting_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; if ( si._from == -1 ) return; G.supp_object(v,si._from) = si._o; CGAL_NEF_TRACEN("starting_segment " << si._from << " "<< v->point()); } void ending_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; if ( si._from == -1 ) return; G.supp_object(v,si._from) = si._o; CGAL_NEF_TRACEN("ending_segment " << si._from << " "<< v->point()); } void passing_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; if ( si._from == -1 ) return; G.supp_object(v,si._from) = si._o; CGAL_NEF_TRACEN("passing_segment " << si._from << " "<< v->point()); } Halfedge_handle halfedge_below(Vertex_handle v) const { return G.halfedge_below(v); } void assert_equal_marks(Vertex_handle v1, Vertex_handle v2) const { CGAL_NEF_TRACEV(G.mark(v1,0));CGAL_NEF_TRACEV(G.mark(v1,1)); CGAL_NEF_TRACEV(G.mark(v2,0));CGAL_NEF_TRACEV(G.mark(v2,1)); CGAL_assertion(G.mark(v1,0)==G.mark(v2,0)&& G.mark(v1,1)==G.mark(v2,1)); } void discard_info(Vertex_handle v) const { G.discard_info(v); } void assert_equal_marks(Halfedge_handle e1, Halfedge_handle e2) const { CGAL_assertion(G.mark(e1,0)==G.mark(e2,0) && G.mark(e1,1)==G.mark(e2,1)); } void discard_info(Halfedge_handle e) const { G.discard_info(e); } }; // SMO_from_sm template class SMO_decorator { public: typedef SM_decorator Graph; typedef typename SM_decorator::SVertex_handle SVertex_handle; typedef typename SM_decorator::SHalfedge_handle SHalfedge_handle; typedef typename SM_decorator::Sphere_point Point_2; typedef typename SM_decorator::Sphere_segment Segment_2; SM_decorator G; SMO_decorator(Graph Gi) : G(Gi) {} SVertex_handle new_vertex(const Point_2& p) { return G.snew_vertex(p); } void link_as_target_and_append(SVertex_handle v, SHalfedge_handle e) { G.link_as_target_and_append(v,e); } SHalfedge_handle new_halfedge_pair_at_source(SVertex_handle v) { return G.new_shalfedge_pair_at_source(v,Graph::BEFORE); } void supporting_segment(SHalfedge_handle e, ITERATOR it) {} void halfedge_below(SVertex_handle v, SHalfedge_handle e) {} void trivial_segment(SVertex_handle v, ITERATOR it) {} void starting_segment(SVertex_handle v, ITERATOR it) {} void passing_segment(SVertex_handle v, ITERATOR it) {} void ending_segment(SVertex_handle v, ITERATOR it) {} }; // SMO_decorator // ============================================================================ // ============================================================================ /*{\Manpage {SM_overlayer}{SM_decorator}{Overlay in the sphere}{O}}*/ template class SM_overlayer : public SM_decorator_ { public: /*{\Mdefinition An instance |\Mvar| of data type |\Mname| is a decorator object offering sphere map overlay calculation. Overlay is either calculated from two sphere maps or from a set of halfspaces. The result is stored in a sphere map |M| that carries the geometry and the topology of the overlay. The template parameter provides the underlying topological interface to sphere maps. The template parameter |SM_decorator| has to be a model conforming to our map decorator concept |SM_decorator|. The concept also describes the interface how the topological information stored in |M| can be extracted or extended. The overlay of a set of sphere segments $S$ is stored in a sphere map $M = (V,E,L,F)$. Vertices are either the endpoints of segments (trivial segments are allowed) or the result of the internal intersection of two segments. Between two vertices there's an edge if there's a segment that supports the spherical embedding of $e$ and if there's no vertex in the relative interior of the embedding of $e$. The faces refer to the maximal connected open point sets of the spherical subdivision implied by the embedding of the vertices and edges. SFaces are bounded by possibly several face cycles\footnote{For the definition of sphere maps and their concepts see the manual page of |SM_decorator|.} including isolated vertices. The overlay process in the method |create_from_segments| creates the objects and the topology of the result. The method starts from zero- and one-dimensional geometric objects in $S$ and produces a spherical structure where each point of the sphere can be assigned to an object (vertex, edge, loop, or face) of |M|. The overlay of two sphere maps $M_i = (V_i, E_i, L_i, F_i)$ has the additional aspect that we already start from two spherical subdivisions. We use the index $i=0,1$ defining the reference to $M_i$, unindexed variables refer to the resulting sphere map $M$. The $1$-skeleta of the two maps subdivide the edges, loops, and faces of the complementary structure into smaller units. This means vertices, edges, and loops of $M_i$ can split edges and loops of $M_{1-i}$ and face cycles of $M_i$ subdivide faces of $M_{1-i}$. The 1-skeleton $G$ of $M$ is defined by the overlay of the embedding of the 1-skeleta of $M_0$ and $M_1$ (Take a trivial segment for each vertex and a segment for each edge, and a circle for a loop, and use the overlay definition of a set of segments and loops above). The faces of $M$ refer to the maximal connected open point sets of the spherical subdivision implied by the embedding of $G$. Each object from the output tuple $(V,E,F)$ has a \emph{supporting} object $u_i$ in each of the two input structures. Imagine the two maps to be transparent balls, where one contains the other. Then each point of the sphere is covered by an object from each of the input structures. This support relationship from the input structures to the output structure defines an information flow. Each supporting object $u_i$ of $u$ $(i=0,1)$ carries an associated information $|mark|(u_i)$. After the subdivision operation this information is attributed to the output object $u$ by $|mark|(u,i)$.}*/ typedef SM_decorator_ SM_decorator; typedef typename SM_decorator::Map Map; typedef SM_decorator Base; typedef SM_overlayer Self; typedef CGAL::SM_const_decorator SM_const_decorator; typedef SM_point_locator SM_point_locator; // typedef typename SM_const_decorator::Constructor_parameter // Constructor_const_parameter; typedef typename SM_const_decorator::SVertex_const_handle SVertex_const_handle; typedef typename SM_const_decorator::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SM_const_decorator::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SM_const_decorator::SFace_const_handle SFace_const_handle; typedef typename SM_const_decorator::SVertex_const_iterator SVertex_const_iterator; typedef typename SM_const_decorator::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename SM_const_decorator::SFace_const_iterator SFace_const_iterator; // typedef typename Base::Constructor_parameter Constructor_parameter; typedef typename Base::SVertex_handle SVertex_handle; typedef typename Base::SHalfedge_handle SHalfedge_handle; typedef typename Base::SHalfloop_handle SHalfloop_handle; typedef typename Base::SFace_handle SFace_handle; typedef typename Base::SVertex_iterator SVertex_iterator; typedef typename Base::SHalfedge_iterator SHalfedge_iterator; typedef typename Base::SFace_iterator SFace_iterator; typedef typename Base::Object_handle Object_handle; typedef typename Base::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Base::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Base::SFace_cycle_iterator SFace_cycle_iterator; typedef std::pair SHalfedge_pair; /*{\Mtypes 3}*/ typedef typename Base::Sphere_kernel Sphere_kernel; /*{\Mtypemember the geometry kernel.}*/ typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember the point type of the sphere geometry.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember the segment type of the sphere geometry.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember the circle type of the sphere geometry.}*/ typedef typename Base::Mark Mark; /*{\Mtypemember the mark of sphere map objects.}*/ typedef typename Base::GenPtr GenPtr; /*{\Mgeneralization SM_decorator}*/ protected: SM_const_decorator PI[2]; const Sphere_kernel& K; public: // --------------------------------------------------------------- struct Seg_info { // to transport information from input to output Object_handle _o; int _from; Seg_info() : _o(), _from(-1) {} Seg_info(SVertex_const_handle v, int i) { _o=Object_handle(v); _from=i; } Seg_info(SHalfedge_const_handle e, int i) { _o=Object_handle(e); _from=i; } Seg_info(SHalfloop_const_handle l, int i) { _o=Object_handle(l); _from=i; } Seg_info(const Seg_info& si) { _o=si._o; _from=si._from; } Seg_info& operator=(const Seg_info& si) { _o=si._o; _from=si._from; return *this; } LEDA_MEMORY(Seg_info) }; // Seg_info typedef std::list Seg_list; typedef typename Seg_list::iterator Seg_iterator; typedef std::pair Seg_it_pair; typedef std::pair Seg_pair; typedef CGAL::Unique_hash_map Seg_map; // --------------------------------------------------------------- struct vertex_info { Mark m[2]; Object_handle o_supp[2]; SHalfedge_handle e_below; vertex_info() { o_supp[0]=o_supp[1]=Object_handle(); } LEDA_MEMORY(vertex_info) }; // vertex_info void assoc_info(SVertex_handle v) const { geninfo::create(info(v)); } void discard_info(SVertex_handle v) const { geninfo::clear(info(v)); } vertex_info& ginfo(SVertex_handle v) const { return geninfo::access(info(v)); } Mark& mark(SVertex_handle v, int i) const { return ginfo(v).m[i]; } Object_handle& supp_object(SVertex_handle v, int i) const { return ginfo(v).o_supp[i]; } SHalfedge_handle& halfedge_below(SVertex_handle v) const { return ginfo(v).e_below; } // --------------------------------------------------------------- struct edge_info { Mark m[2]; Mark mf[2]; Object_handle o_supp[2]; bool forw; edge_info() { m[0]=m[1]=mf[0]=mf[1]=Mark(); o_supp[0]=o_supp[1]=Object_handle(); forw=false; } LEDA_MEMORY(edge_info) }; void assoc_info(SHalfedge_handle e) const { geninfo::create(info(e)); geninfo::create(info(twin(e))); } void discard_info(SHalfedge_handle e) const { geninfo::clear(info(e)); geninfo::clear(info(twin(e))); } edge_info& ginfo(SHalfedge_handle e) const { return geninfo::access(info(e)); } Mark& mark(SHalfedge_handle e, int i) const { return ginfo(e).m[i]; } Object_handle& supp_object(SHalfedge_handle e, int i) const // uedge information we store in the smaller one { if (&*e < &*(twin(e))) return ginfo(e).o_supp[i]; else return ginfo(twin(e)).o_supp[i]; } Mark& incident_mark(SHalfedge_handle e, int i) const // biedge information we store in the edge { return ginfo(e).mf[i]; } bool& is_forward(SHalfedge_handle e) const // biedge information we store in the edge { return ginfo(e).forw; } // --------------------------------------------------------------- struct face_info { Mark m[2]; face_info() { m[0]=m[1]=Mark(); } LEDA_MEMORY(face_info) }; void assoc_info(SFace_handle f) const { geninfo::create(info(f)); } void discard_info(SFace_handle f) const { geninfo::clear(info(f)); } face_info& ginfo(SFace_handle f) const { return geninfo::access(info(f)); } Mark& mark(SFace_handle f, int i) const { return ginfo(f).m[i]; } // --------------------------------------------------------------- template SFace_handle determine_face(SHalfedge_handle e, const std::vector& MinimalSHalfedge, const CGAL::Unique_hash_map& SFaceCycle, const Below_accessor& D) { CGAL_NEF_TRACEN("determine_face "< void create_from_segments( Forward_iterator start, Forward_iterator end); /*{\Mop produces the sphere map which is the overlay of the segments from the iterator range |[start,end)|. \precond |Forward_iterator| has value type |Sphere_segment|.}*/ template void create_from_circles(Forward_iterator start, Forward_iterator end); /*{\Mop produces the sphere map which is the overlay of the circles from the iterator range |[start,end)|. \precond |Forward_iterator| has value type |Sphere_circle|.}*/ void create(const Sphere_circle& c); /*{\Mop produces the sphere map which consists of one loop and the two halfspheres incident to it.}*/ void subdivide(const Map* M0, const Map* M1); /*{\Mop constructs the overlay of the sphere maps |M0| and |M1| in |M|, where all objects (vertices, halfedges, faces) of |M| are \emph{enriched} by the marks of the supporting objects of the two input structures: e.g. let |v| be a vertex supported by a node |v0| in |M0| and by a face |f1| in |M1| and |D0|, |D1| be decorators of type |SM_decorator| on |M0|,|M1|. Then |\Mvar.mark(v,0) = D0.mark(v0)| and |\Mvar.mark(v,1) = D1.mark(f1)|.}*/ template void select(const Selection& SP) const; /*{\Mop sets the marks of all objects according to the selection predicate |SP|. |Selection| has to be a function object type with a function operator\\ [[Mark operator()(Mark m0, Mark m1) const]]\\ For each object |u| of |M| enriched by the marks of the supporting objects according to the previous procedure |subdivide|, after this operation |\Mvar.mark(u) = SP ( \Mvar.mark(u,0),\Mvar.mark(u,1) )|. The additional marks are invalidated afterwards. \precond subdivide() was called before.}*/ void simplify(); /*{\Mop simplifies the structure of |M| according to the marks of its objects. An edge |e| separating two faces |f1| and |f2| and equal marks |mark(e) == mark(f1) == mark(f2)| is removed and the faces are unified. An isolated vertex |v| in a face |f| with |mark(v)==mark(f)| is removed. A vertex |v| with outdegree two, two collinear out-edges |e1|,|e2| and equal marks |mark(v) == mark(e1) == mark(e2)| is removed and the edges are unified.}*/ int check_sphere(const Seg_list& L, bool compute_halfsphere[3][2]) const; template void subdivide_segments(Iterator start, Iterator end) const; template void partition_to_halfsphere(Iterator start, Iterator end, Seg_list& L, CGAL::Unique_hash_map& M, Sphere_circle xycircle, Sphere_circle yzcircle, bool include_equator) const; template void merge_halfsphere_maps(SVertex_handle v1, SVertex_handle v2, const Mark_accessor& D); template void merge_nodes(SHalfedge_handle e1, SHalfedge_handle e2, const Mark_accessor& D); template void create_face_objects(SHalfedge_iterator e_start, SHalfedge_iterator e_end, SVertex_iterator v_start, SVertex_iterator v_end, const Below_accessor& D, const Halfsphere_geometry& SG); template void complete_face_support(SVertex_iterator v_start, SVertex_iterator v_end, const Below_accessor& D, std::vector& mohs, int offset, bool both=true) const; void set_outer_face_mark(int offset, const std::vector& mohs); void dump(std::ostream& os = std::cerr) const { SM_io_parser::dump(*this,os); } }; // SM_overlayer template template void SM_overlayer:: create_from_segments(Forward_iterator start, Forward_iterator end) { CGAL_NEF_TRACEN("creating from segment iterator range"); Seg_list L(start,end); Unique_hash_map From_input(false); Seg_iterator it; CGAL_forall_iterators(it,L) From_input[it]=true; Seg_list L_pos,L_neg; partition_to_halfsphere(L.begin(), L.end(), L_pos, From_input, Sphere_circle(0,0,1), Sphere_circle(1,0,0), true); partition_to_halfsphere(L.begin(), L.end(), L_neg, From_input, Sphere_circle(0,0,-1), Sphere_circle(1,0,0), true); //CGAL_NEF_TRACEN("L_pos="<<(MSDEBUG::print_elements(L_pos),"")); //CGAL_NEF_TRACEN("L_neg="<<(MSDEBUG::print_elements(L_neg),"")); typedef SMO_from_segs SM_output; typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, PH_geometry> PHS_traits; typedef CGAL::generic_sweep Positive_halfsphere_sweep; typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, NH_geometry> NHS_traits; typedef CGAL::generic_sweep Negative_halfsphere_sweep; SVertex_iterator v; SHalfedge_iterator e; SM_output O(*this,From_input); typedef typename PHS_traits::INPUT Input_range; Positive_halfsphere_sweep SP( Input_range(L_pos.begin(),L_pos.end()),O, PH_geometry()); SP.sweep(); //CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),"")); v=--this->svertices_end(); e=--this->shalfedges_end(); Negative_halfsphere_sweep SM( Input_range(L_neg.begin(),L_neg.end()),O, NH_geometry()); SM.sweep(); //CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),"")); ++v; ++e; // now two CCs of sphere graph are calculated // v = first vertex of CC in negative x-sphere // e = first edge of CC in negative x-sphere create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O, PH_geometry()); create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O, NH_geometry()); SHalfedge_iterator u; CGAL_forall_sedges(u,*this) { Sphere_segment s(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); } merge_halfsphere_maps(this->svertices_begin(),v,O); this->check_integrity_and_topological_planarity(); O.clear_temporary_vertex_info(); } template template void SM_overlayer:: create_from_circles(Forward_iterator start, Forward_iterator end) { CGAL_NEF_TRACEN("creating from circle iterator range"); Seg_list L; Unique_hash_map From_input(false); for ( ; start != end; ++start ) { std::pair spair = start->split_at_xy_plane(); L.push_back(spair.first); L.push_back(spair.second); } Seg_iterator it; CGAL_forall_iterators(it,L) From_input[it]=true; Seg_list L_pos,L_neg; partition_to_halfsphere(L.begin(), L.end(), L_pos, From_input, Sphere_circle(0,0,1), Sphere_circle(1,0,0), true); partition_to_halfsphere(L.begin(), L.end(), L_neg, From_input, Sphere_circle(0,0,-1), Sphere_circle(1,0,0), true); typedef SMO_from_segs SM_output; typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, PH_geometry> PHS_traits; typedef CGAL::generic_sweep Positive_halfsphere_sweep; typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, NH_geometry> NHS_traits; typedef CGAL::generic_sweep Negative_halfsphere_sweep; SVertex_iterator v; SHalfedge_iterator e; SM_output O(*this,From_input); typedef typename PHS_traits::INPUT Input_range; Positive_halfsphere_sweep SP( Input_range(L_pos.begin(),L_pos.end()),O, PH_geometry()); SP.sweep(); //CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),"")); v=--this->svertices_end(); e=--this->shalfedges_end(); Negative_halfsphere_sweep SM( Input_range(L_neg.begin(),L_neg.end()), O, NH_geometry()); SM.sweep(); //CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),"")); ++v; ++e; // now two CCs of sphere graph are calculated // v = first vertex of CC in negative x-sphere // e = first edge of CC in negative x-sphere create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O, PH_geometry()); create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O, NH_geometry()); SHalfedge_iterator u; CGAL_forall_sedges(u,*this) { Sphere_segment s(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); } merge_halfsphere_maps(this->svertices_begin(),v,O); this->check_integrity_and_topological_planarity(); O.clear_temporary_vertex_info(); } template int SM_overlayer:: check_sphere(const Seg_list& L, bool compute_halfsphere[3][2]) const { for(int i=0; i<6; i++) compute_halfsphere[i/2][i%2] = false; CGAL_NEF_TRACEN("compute_halfsphere (at begin)"); for(int i=0; i<6; ++i) CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]); typename Seg_list::const_iterator it; CGAL_forall_iterators(it,L) { if(!compute_halfsphere[0][0]) if(it->source().hx()>0 || it->target().hx()>0) compute_halfsphere[0][0] = true; if(!compute_halfsphere[0][1]) if(it->source().hx()<0 || it->target().hx()<0) compute_halfsphere[0][1] = true; if(!compute_halfsphere[1][0]) if(it->source().hy()>0 || it->target().hy()>0) compute_halfsphere[1][0] = true; if(!compute_halfsphere[1][1]) if(it->source().hy()<0 || it->target().hy()<0) compute_halfsphere[1][1] = true; if(!compute_halfsphere[2][0]) if(it->source().hz()>0 || it->target().hz()>0) compute_halfsphere[2][0] = true; if(!compute_halfsphere[2][1]) if(it->source().hz()<0 || it->target().hz()<0) compute_halfsphere[2][1] = true; } CGAL_NEF_TRACEN("compute_halfsphere (after vertices)"); for(int i=0; i<6; ++i) CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]); if(!compute_halfsphere[2][0]) { CGAL_forall_iterators(it,L) { if(CGAL::orientation(it->source(),it->target(), Sphere_point(0,0,1), CGAL::ORIGIN+it->sphere_circle().orthogonal_vector()) == CGAL::NEGATIVE) if((it->source().hz()==0 && it->target().hz()==0) || it->is_long()) { compute_halfsphere[2][0] = true; break; } } } if(!compute_halfsphere[2][0]) { compute_halfsphere[2][1] = true; return 4; } if(!compute_halfsphere[2][1]) { CGAL_forall_iterators(it,L) { if(CGAL::orientation(it->source(),it->target(), Sphere_point(0,0,-1), CGAL::ORIGIN+it->sphere_circle().orthogonal_vector()) == CGAL::NEGATIVE) if((it->source().hz()==0 && it->target().hz()==0) || it->is_long()) { compute_halfsphere[2][1] = true; break; } } } if(!compute_halfsphere[2][1]) return 5; if(!compute_halfsphere[0][0]) { CGAL_forall_iterators(it,L) { if(CGAL::orientation(it->source(),it->target(), Sphere_point(1,0,0), CGAL::ORIGIN+it->sphere_circle().orthogonal_vector()) == CGAL::NEGATIVE) if((it->source().hx()==0 && it->target().hx()==0) || it->is_long()) { compute_halfsphere[0][0] = true; break; } } } if(!compute_halfsphere[0][0]) { compute_halfsphere[0][1] = true; return 0; } if(!compute_halfsphere[0][1]) { CGAL_forall_iterators(it,L) { if(CGAL::orientation(it->source(),it->target(), Sphere_point(-1,0,0), CGAL::ORIGIN+it->sphere_circle().orthogonal_vector()) == CGAL::NEGATIVE) if((it->source().hx()==0 && it->target().hx()==0) || it->is_long()) { compute_halfsphere[0][1] = true; break; } } } if(!compute_halfsphere[0][1]) return 1; if(!compute_halfsphere[1][0]) { CGAL_forall_iterators(it,L) { if(CGAL::orientation(it->source(),it->target(), Sphere_point(0,1,0), CGAL::ORIGIN+it->sphere_circle().orthogonal_vector()) == CGAL::NEGATIVE) if((it->source().hy()==0 && it->target().hy()==0) || it->is_long()) { compute_halfsphere[1][0] = true; break; } } } if(!compute_halfsphere[1][0]) { compute_halfsphere[1][1] = true; return 2; } if(!compute_halfsphere[1][1]) { CGAL_forall_iterators(it,L) { if(CGAL::orientation(it->source(),it->target(), Sphere_point(0,-1,0), CGAL::ORIGIN+it->sphere_circle().orthogonal_vector()) == CGAL::NEGATIVE) if((it->source().hy()==0 && it->target().hy()==0) || it->is_long()) { compute_halfsphere[1][1] = true; break; } } } if(!compute_halfsphere[1][1]) return 3; return -1; } template void SM_overlayer:: create(const Sphere_circle& c) { SHalfloop_handle l1 = this->new_shalfloop_pair(); SHalfloop_handle l2 = this->twin(l1); circle(l1) = c; circle(l2) = c.opposite(); SFace_handle f1 = this->new_sface(); SFace_handle f2 = this->new_sface(); link_as_loop(l1,f1); link_as_loop(l2,f2); } template void SM_overlayer:: subdivide(const Map* M0, const Map* M1) { PI[0] = SM_const_decorator(M0); PI[1] = SM_const_decorator(M1); Seg_list L; Seg_map From; for (int i=0; i<2; ++i) { SVertex_const_iterator v; CGAL_forall_svertices(v,PI[i]) { CGAL_NEF_TRACEN(v->point() << " from " << i << " mark " << v->mark()); if ( !PI[i].is_isolated(v) ) continue; L.push_back(trivial_segment(PI[i],v)); From[--L.end()] = Seg_info(v,i); } SHalfedge_const_iterator e; CGAL_forall_sedges(e,PI[i]) { if ( source(e) == target(e) ) { Seg_pair p = two_segments(PI[i],e); L.push_back(p.first); L.push_back(p.second); From[--L.end()] = From[--(--L.end())] = Seg_info(e,i); } else { L.push_back(segment(PI[i],e)); From[--L.end()] = Seg_info(e,i); } } if ( PI[i].has_shalfloop() ) { SHalfloop_const_handle shl = PI[i].shalfloop(); Seg_pair p = two_segments(PI[i],shl); L.push_back(p.first); L.push_back(p.second); From[--L.end()] = From[--(--L.end())] = Seg_info(shl,i); } } CGAL_assertion_code(typename Seg_list::iterator it); CGAL_assertion_code(CGAL_forall_iterators(it,L) CGAL_NEF_TRACEN(" "<<*it)); bool compute_halfsphere[3][2]; #ifdef CGAL_NEF3_SPHERE_SWEEP_OPTIMIZATION_OFF int cs = -1; compute_halfsphere[2][0]=true; compute_halfsphere[2][1]=true; #else int cs = check_sphere(L, compute_halfsphere); #endif CGAL_NEF_TRACEN("compute_halfsphere\n cs = " << cs); for(int i=0; i<6; ++i) CGAL_NEF_TRACEN(" " << i << " : " << compute_halfsphere[i/2][i%2]); Seg_list L_pos,L_neg; switch(cs) { case 1: partition_to_halfsphere(L.begin(), L.end(), L_pos, From, Sphere_circle(1,0,0), Sphere_circle(0,0,-1), compute_halfsphere[0][1]); break; case 0: partition_to_halfsphere(L.begin(), L.end(), L_neg, From, Sphere_circle(-1,0,0), Sphere_circle(0,0,-1), compute_halfsphere[0][0]); break; case 3: partition_to_halfsphere(L.begin(), L.end(), L_pos, From, Sphere_circle(0,1,0), Sphere_circle(1,0,0), compute_halfsphere[1][1]); break; case 2: partition_to_halfsphere(L.begin(), L.end(), L_neg, From, Sphere_circle(0,-1,0), Sphere_circle(1,0,0), compute_halfsphere[1][0]); break; case 5: partition_to_halfsphere(L.begin(), L.end(), L_pos, From, Sphere_circle(0,0,1), Sphere_circle(1,0,0), compute_halfsphere[2][1]); break; case 4: partition_to_halfsphere(L.begin(), L.end(), L_neg, From, Sphere_circle(0,0,-1), Sphere_circle(1,0,0), compute_halfsphere[2][0]); break; case -1: partition_to_halfsphere(L.begin(), L.end(), L_pos, From, Sphere_circle(0,0,1), Sphere_circle(1,0,0), true); partition_to_halfsphere(L.begin(), L.end(), L_neg, From, Sphere_circle(0,0,-1), Sphere_circle(1,0,0), true); break; default: CGAL_assertion_msg(0, "wrong value"); } cs = cs==-1 ? 2 : cs/2; #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS timer_sphere_sweeps.start(); #endif typedef SMO_from_sm SM_output; typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry; typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, PH_geometry> PHS_traits; typedef CGAL::generic_sweep Positive_halfsphere_sweep; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, NH_geometry> NHS_traits; typedef CGAL::generic_sweep Negative_halfsphere_sweep; typedef typename PHS_traits::INPUT Input_range; SVertex_handle v; SHalfedge_handle e; SM_output O(*this,PI,From); if(compute_halfsphere[cs][0]) { Positive_halfsphere_sweep SP( Input_range(L_pos.begin(),L_pos.end()),O, PH_geometry(cs)); SP.sweep(); v=--this->svertices_end(); e=--this->shalfedges_end(); #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS number_of_sphere_sweeps++; #endif } if(compute_halfsphere[cs][1]) { Negative_halfsphere_sweep SM( Input_range(L_neg.begin(),L_neg.end()),O, NH_geometry(cs)); SM.sweep(); #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS number_of_sphere_sweeps++; #endif } #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS timer_sphere_sweeps.stop(); #endif if(compute_halfsphere[cs][0]) { ++v; ++e; } else { v = this->svertices_begin(); e = this->shalfedges_begin(); } if(compute_halfsphere[cs][0]) create_face_objects(this->shalfedges_begin(), e, this->svertices_begin(), v, O, PH_geometry(cs)); if(compute_halfsphere[cs][1]) create_face_objects(e, this->shalfedges_end(), v, this->svertices_end(), O, NH_geometry(cs)); SHalfedge_iterator u; CGAL_forall_shalfedges(u,*this) { Sphere_segment s(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); CGAL_NEF_TRACEN(PH(u) << " with circle " << circle(u)); } std::vector mohs(4); SM_point_locator L0(M0); SM_point_locator L1(M1); L0.marks_of_halfspheres(mohs, 0, cs); L1.marks_of_halfspheres(mohs, 2, cs); CGAL_NEF_TRACEN("compute_halfsphrere\n cs = " << cs << "\n [cs][0] = " << compute_halfsphere[cs][0] << "\n [cs][1] = " << compute_halfsphere[cs][1]); if(compute_halfsphere[cs][0]) complete_face_support(this->svertices_begin(), v, O, mohs, 0, compute_halfsphere[cs][1]); if(compute_halfsphere[cs][1]) complete_face_support(v, this->svertices_end(), O, mohs, 1, compute_halfsphere[cs][0]); // DEBUG CODE: to do: have all svertices a halfedge below associated? CGAL_NEF_TRACEN("Vertex info after swep"); CGAL_assertion_code(SVertex_iterator svi); CGAL_assertion_code( for(svi=this->svertices_begin(); svi!=this->svertices_end(); svi++) { CGAL_NEF_TRACEN("vertex "<svertices_begin(),v,O); else set_outer_face_mark(compute_halfsphere[cs][1], mohs); this->check_integrity_and_topological_planarity(); CGAL_NEF_TRACEN("subdivided"); CGAL_assertion_code(CGAL_forall_svertices(v,*this) CGAL_NEF_TRACEN(PH(v))); } template void SM_overlayer:: set_outer_face_mark(int offset, const std::vector& mohs) { SFace_handle sf = this->new_sface(); mark(sf, 0) = mohs[offset]; mark(sf, 1) = mohs[offset+2]; SHalfedge_iterator e; CGAL_forall_shalfedges(e, *this) { if ( face(e) != SFace_handle() ) continue; link_as_face_cycle(e,sf); } SVertex_handle v; CGAL_forall_svertices(v, *this) { if(!is_isolated(v) || face(v) != SFace_handle()) continue; link_as_isolated_vertex(v,sf); } } template template void SM_overlayer:: partition_to_halfsphere(Iterator start, Iterator beyond, Seg_list& L, CGAL::Unique_hash_map& M, Sphere_circle xycircle, Sphere_circle yzcircle, bool include_equator) const { CGAL_NEF_TRACEN("partition_to_halfsphere "); // CGAL_assertion(pos!=0); Sphere_segment s1,s2; // Sphere_circle xycircle(0,0,pos); if(include_equator) { while ( start != beyond) { int i = start->intersection(xycircle,s1,s2); CGAL_NEF_TRACEN("segment " << start->source() << " " << start->target()); if (i>1) { L.push_back(s2); M[--L.end()] = M[start]; CGAL_NEF_TRACEN(">1 " << s2.source() << " " << s2.target()); } if (i>0) { L.push_back(s1); M[--L.end()] = M[start]; CGAL_NEF_TRACEN(">0 " << s1.source() << " " << s1.target()); } ++start; } } else { while(start != beyond) { L.push_back(*start); M[--L.end()] = M[start]; ++start; } } // now all segments are split into hemispheres // we still have to: // - split segments containing our special poles y^-, y^+ // - split halfcircles // - add four equator segments // Sphere_circle yzcircle(1,0,0); typename Seg_list::iterator it, itl; CGAL_forall_iterators(it,L) { CGAL_NEF_TRACEN(" "<<*it); if ( equal_as_sets(it->sphere_circle(),xycircle) ) { CGAL_NEF_TRACEN(" splitting xy seg "<<*it); bool added=false; int n1 = it->intersection(yzcircle,s1,s2); if (n1 > 1 && !s2.is_degenerate()) { M[ L.insert(it,s2) ] = M[it]; added=true; CGAL_NEF_TRACEN(">1 " << s2.source() << " " << s2.target()); } if (n1 > 0 && !s1.is_degenerate()) { M[ L.insert(it,s1) ] = M[it]; added = true; CGAL_NEF_TRACEN(">1 " << s1.source() << " " << s1.target()); } int n2 = it->intersection(yzcircle.opposite(),s1,s2); if (n2 > 1 && !s2.is_degenerate()) { M[ L.insert(it,s2) ] = M[it]; added=true; CGAL_NEF_TRACEN(">1 " << s2.source() << " " << s2.target()); } if (n2 > 0 && !s1.is_degenerate()) { M[ L.insert(it,s1) ] = M[it]; added=true; CGAL_NEF_TRACEN(">1 " << s1.source() << " " << s1.target()); } if(added) { itl = it; --it; L.erase(itl); M[itl] = T(); } // at least one item was appended } } CGAL_forall_iterators(it,L) { if ( it->is_halfcircle() ) { CGAL_NEF_TRACEN(" splitting halfcircle "<<*it); Sphere_segment s1,s2; it->split_halfcircle(s1,s2); *it = s2; M[ L.insert(it,s1) ] = M[it]; } } if(include_equator) { // append 4 xy-equator segments: Sphere_point S(0,-1,0),N(0,1,0); Sphere_segment sp(S,N,xycircle); Sphere_segment sm(S,N,xycircle.opposite()); Sphere_segment s[4]; sp.split_halfcircle(s[0],s[1]); sm.split_halfcircle(s[2],s[3]); L.insert(L.end(),s,s+4); } } template template void SM_overlayer:: create_face_objects(SHalfedge_iterator e_start, SHalfedge_iterator e_end, SVertex_iterator v_start, SVertex_iterator v_end, const Below_accessor& D, const Halfsphere_geometry& SG) { CGAL_NEF_TRACEN("create_face_objects()"); if(e_start != e_end) { CGAL::Unique_hash_map SFaceCycle(-1); std::vector MinimalSHalfedge; SHalfedge_around_sface_circulator hfc(last_out_edge(v_start)),hend(hfc); CGAL_NEF_TRACEN("equator cycle "<= 0 ) continue; // already assigned SHalfedge_around_sface_circulator hfc(e),hend(hfc); SHalfedge_handle e_min = e; CGAL_NEF_TRACEN(""); CGAL_NEF_TRACEN(" face cycle numbering "< 0 ) { // left_turn => outer face cycle SFace_handle f = this->new_sface(); link_as_face_cycle(e,f); CGAL_NEF_TRACEN(" creating new face object "<<&*f<<" bd "<<&*e); } } for (SHalfedge_iterator e = e_start; e != e_end; ++e) { if ( face(e) != SFace_handle() ) continue; if ( SFaceCycle[e] == 0 ) continue; CGAL_NEF_TRACEN("linking hole "< template void SM_overlayer:: complete_face_support(SVertex_iterator v_start, SVertex_iterator v_end, const Below_accessor& D, std::vector& mohs, int offset, bool both) const { CGAL_NEF_TRACEN("complete_face_support"); for (SVertex_iterator v = v_start; v != v_end; ++v) { CGAL_NEF_TRACEN("VERTEX = "<= 0) : (point(v).hx()<=0)) ); if(!is_isolated(v)) { if(!both) { for (int i=0; i<2; ++i) m_buffer[i] = mohs[offset+2*i]; CGAL_NEF_TRACEN("no edge below "); } else { for (int i=0; i<2; ++i) m_buffer[i] = incident_mark(previous(first_out_edge(v)),i); } } } CGAL_NEF_TRACEN(" faces right-below "<sfaces_begin(); f != this->sfaces_end(); ++f) { assoc_info(f); SFace_cycle_iterator boundary_object(f->sface_cycles_begin()); if (!boundary_object.is_shalfedge() ) CGAL_assertion_msg(0,"Outer face cycle should be first."); SHalfedge_handle e(boundary_object); for (int i=0; i<2; ++i) mark(f,i) = incident_mark(e,i); } } template template void SM_overlayer:: merge_nodes(SHalfedge_handle e1, SHalfedge_handle e2, const Mark_accessor& D) { SVertex_handle v1 = source(e1), v2 = target(e2); CGAL_NEF_TRACEN("merge_nodes "< template void SM_overlayer:: merge_halfsphere_maps(SVertex_handle v1, SVertex_handle v2, const Mark_accessor& D) { CGAL_NEF_TRACEN("merging halfspheres "< L_equator; SHalfedge_around_sface_circulator ep(last_out_edge(v1)), en(twin(first_out_edge(v2))); do { L_equator.push_back(SHalfedge_pair(ep,en)); merge_nodes(ep,en,D); ++ep; --en; } while ( source(ep) != v1 ); typename std::list::iterator it; CGAL_forall_iterators(it,L_equator) { SHalfedge_handle e1 = it->first, e2 = it->second; SHalfedge_handle e1t = twin(e1), e2t = twin(e2); CGAL_NEF_TRACEV(PH(e1));CGAL_NEF_TRACEV(PH(e2)); SHalfedge_handle e2tp = previous(e2t); SHalfedge_handle e2tn = next(e2t); link_as_prev_next_pair(e2tp,e1); link_as_prev_next_pair(e1,e2tn); SFace_handle f = face(e2t); if ( is_sm_boundary_object(e2t) ) { undo_sm_boundary_object(e2t,f); store_sm_boundary_object(e1,f); } set_face(e1,f); if ( e2 == first_out_edge(source(e2)) ) set_first_out_edge(source(e2),e1t); D.discard_info(e2); delete_edge_pair_only(e2); } } template template void SM_overlayer:: select(const Selection& SP) const { SVertex_iterator v; CGAL_forall_svertices(v,*this) { mark(v) = SP(mark(v,0),mark(v,1)); discard_info(v); } SHalfedge_iterator e; CGAL_forall_sedges(e,*this) { mark(e) = SP(mark(e,0),mark(e,1)); mark(twin(e)) = SP(mark(twin(e),0),mark(twin(e),1)); CGAL_assertion(mark(e) == mark(twin(e))); discard_info(e); } SFace_iterator f; CGAL_forall_sfaces(f,*this) { mark(f) = SP(mark(f,0),mark(f,1)); discard_info(f); } } template void SM_overlayer::simplify() { CGAL_NEF_TRACEN("simplifying"); typedef typename CGAL::Union_find::handle Union_find_handle; CGAL::Unique_hash_map< SFace_handle, Union_find_handle> Pitem(NULL); CGAL::Unique_hash_map< SVertex_handle, Union_find_handle> Vitem(NULL); CGAL::Union_find< SFace_handle> UF; SFace_iterator f; CGAL_forall_sfaces(f,*this) { Pitem[f] = UF.make_set(f); clear_face_cycle_entries(f); } if ( this->has_shalfloop() ) { SHalfloop_handle l = this->shalfloop(); SFace_handle f = *(UF.find(Pitem[face(l)])); link_as_loop(l,f); f = *(UF.find(Pitem[face(twin(l))])); link_as_loop(twin(l),f); } SHalfedge_iterator e, en; for(e = this->shalfedges_begin(); e != this->shalfedges_end(); e = en) { en = e; ++en; if ( en==twin(e) ) ++en; CGAL_NEF_TRACEN("can simplify ? " << PH(e)); CGAL_NEF_TRACEN(mark(e) << " " << mark(face(e)) << " " << mark(face(twin(e)))); if (( mark(e) == mark(face(e)) && mark(e) == mark(face(twin(e))))){ CGAL_NEF_TRACEN("deleting "< linked(false); for (e = this->shalfedges_begin(); e != this->shalfedges_end(); ++e) { if ( linked[e] ) continue; SHalfedge_around_sface_circulator hfc(e),hend(hfc); SFace_handle f = *(UF.find( Pitem[face(e)])); CGAL_For_all(hfc,hend) { set_face(hfc,f); linked[hfc]=true; } store_sm_boundary_object(e,f); } SVertex_iterator v,vn; for(v = this->svertices_begin(); v != this->svertices_end(); v=vn) { vn=v; ++vn; if ( is_isolated(v) ) { if(Vitem[v] != NULL) { set_face(v,*(UF.find(Vitem[v]))); CGAL_NEF_TRACEN("incident face of " << PH(v) << " set to " << &*(face(v))); } else { set_face(v, *(UF.find(Pitem[face(v)]))); CGAL_NEF_TRACEN("isolated svertex " << PH(v) << " already has incident face " << &*(face(v))); } if ( mark(v) == mark(face(v)) ) { CGAL_NEF_TRACEN("removing isolated vertex"<sfaces_begin(); f != this->sfaces_end(); f=fn) { ++fn; Union_find_handle pit = Pitem[f]; if ( UF.find(pit) != pit ) { CGAL_NEF_TRACEN("delete face " << &*f); delete_face_only(f); } } } template template void SM_overlayer:: subdivide_segments(Iterator start, Iterator end) const { typedef SMO_decorator SM_output; typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry; typedef CGAL::Segment_overlay_traits< Iterator, SM_output, PH_geometry> PHS_traits; typedef CGAL::generic_sweep Positive_halfsphere_sweep; typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry; typedef CGAL::Segment_overlay_traits< Iterator, SM_output, NH_geometry> NHS_traits; typedef CGAL::generic_sweep Negative_halfsphere_sweep; std::list Lp,Lm; partition_xy( start, end, Lp , +1); partition_xy( start, end, Lm , -1); // both lists initialized with four quarter segments // supporting the xy-equator thereby separating the // two halfspheres // all other segments in the range are split into their // connected components with respect to the xy-plane. //CGAL_NEF_TRACEN("Lp="<<(MSDEBUG::print_elements(Lp),"")); //CGAL_NEF_TRACEN("Lm="<<(MSDEBUG::print_elements(Lm),"")); SVertex_handle v1,v2; SM_output O(*this); typedef typename PHS_traits::INPUT Input_range; Positive_halfsphere_sweep SP(Input_range(Lp.begin(),Lp.end()),O); SP.sweep(); //CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),"")); v1= this->vertices_begin(); v2=--this->vertices_end(); Negative_halfsphere_sweep SM(Input_range(Lm.begin(),Lm.end()),O); SM.sweep(); //CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),"")); ++v2; // now two CCs of sphere graph calculated // v1 = first node of CC in positive xy-sphere // v2 = first node of CC in negative xy-sphere merge_halfsphere_maps(v1,v2,O); this->check_integrity_and_topological_planarity(false); } CGAL_END_NAMESPACE #endif //CGAL_SM_OVERLAYER_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_triangulator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_triangulator0000644000175000017500000006124511344301501031142 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/SM_triangulator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SM_TRIANGULATOR_H #define CGAL_SM_TRIANGULATOR_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 137 #include #define CGAL_USING(t) typedef typename Base::t t #ifndef CGAL_USE_LEDA #define LEDA_MEMORY(t) #endif CGAL_BEGIN_NAMESPACE template struct SM_subdivision { typedef Decorator_ Triangulator; typedef typename Decorator_::SVertex_handle Vertex_handle; typedef typename Decorator_::SHalfedge_handle Halfedge_handle; typedef typename Decorator_::Sphere_point Point; typedef typename Decorator_::Sphere_segment Segment; Triangulator T; CGAL::Unique_hash_map& M; /* M stores the object that supports the segment that is input object of the sweep */ SM_subdivision(Triangulator Ti, CGAL::Unique_hash_map& Mi) : T(Ti), M(Mi) {} Vertex_handle new_vertex(const Point& p) { Vertex_handle v = T.new_svertex(p); T.assoc_info(v); return v; } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) { T.link_as_target_and_append(v,e); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) { Halfedge_handle e = T.new_shalfedge_pair_at_source(v,Decorator_::BEFORE); T.assoc_info(e); return e; } void halfedge_below(Vertex_handle v, Halfedge_handle e) const { T.halfedge_below(v) = e; } /* the following operation associates segment support with halfedges, we only update if non-NULL; this prevents artificial sphere subdivision segments that have NULL support to overwrite non-NULL support */ void supporting_segment(Halfedge_handle e, IT it) const { T.is_forward(e) = true; if ( M[it] != NULL ) T.support(e) = M[it]; } /* the following operation associate segment support with vertices, we only update if non-NULL; this prevents artificial segments that have NULL support to overwrite non-NULL support */ void trivial_segment(Vertex_handle v, IT it) const { if ( M[it] != NULL ) T.support(v) = M[it]; } void starting_segment(Vertex_handle v, IT it) const { if ( M[it] != NULL ) T.support(v) = M[it]; } void ending_segment(Vertex_handle v, IT it) const { if ( M[it] != NULL ) T.support(v) = M[it]; } void passing_segment(Vertex_handle v, IT it) const { if ( M[it] != NULL ) T.support(v) = M[it]; } }; // SM_subdivision /*{\Manpage {SM_triangulator}{Decorator_}{Overlay in the sphere}{O}}*/ template class SM_triangulator : public Decorator_ { public: /*{\Mdefinition An instance |\Mvar| of data type |\Mname| is a decorator object offering sphere map triangulation calculation.}*/ typedef Decorator_ Base; typedef typename Decorator_::Sphere_map Sphere_map; typedef CGAL::SM_const_decorator SM_const_decorator; typedef SM_const_decorator Explorer; typedef Decorator_ Decorator; typedef SM_triangulator Self; typedef SM_point_locator SM_point_locator; typedef typename SM_const_decorator::SVertex_const_handle SVertex_const_handle; typedef typename SM_const_decorator::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SM_const_decorator::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SM_const_decorator::SFace_const_handle SFace_const_handle; typedef typename SM_const_decorator::SVertex_const_iterator SVertex_const_iterator; typedef typename SM_const_decorator::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename SM_const_decorator::SFace_const_iterator SFace_const_iterator; typedef typename Base::SVertex_handle SVertex_handle; typedef typename Base::SHalfedge_handle SHalfedge_handle; typedef typename Base::SHalfloop_handle SHalfloop_handle; typedef typename Base::SFace_handle SFace_handle; typedef typename Base::SVertex_iterator SVertex_iterator; typedef typename Base::SHalfedge_iterator SHalfedge_iterator; typedef typename Base::SFace_iterator SFace_iterator; typedef typename Base::Object_handle Object_handle; typedef typename Base::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Base::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef std::pair SHalfedge_pair; /*{\Mtypes 3}*/ typedef typename Base::Sphere_kernel Sphere_kernel; typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember the point type of the sphere geometry.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember the segment type of the sphere geometry.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember the circle type of the sphere geometry.}*/ typedef typename Sphere_kernel::Sphere_triangle Sphere_triangle; /*{\Mtypemember the triangle type of the sphere geometry.}*/ typedef typename Decorator::Mark Mark; /*{\Mtypemember the mark of sphere map objects.}*/ /*{\Mgeneralization Decorator_}*/ protected: const Explorer* E_; const Sphere_kernel& K; public: typedef std::list Seg_list; typedef typename Seg_list::iterator Seg_iterator; typedef std::pair Seg_it_pair; typedef std::pair Seg_pair; typedef CGAL::Unique_hash_map Seg_map; // vertex_info stores the origin of vertices struct vertex_info { Object_handle o_; SHalfedge_handle e_; vertex_info() : o_(),e_() {} LEDA_MEMORY(vertex_info) }; void assoc_info(SVertex_handle v) const { geninfo::create(info(v)); } void discard_info(SVertex_handle v) const { geninfo::clear(info(v)); } vertex_info& ginfo(SVertex_handle v) const { return geninfo::access(info(v)); } Object_handle& support(SVertex_handle v) const { return ginfo(v).o_; } SHalfedge_handle& halfedge_below(SVertex_handle v) const { return ginfo(v).e_; } // edge_info stores the origin of edges struct edge_info { Mark m_left_; Object_handle o_; bool forw_; edge_info() { m_left_=Mark(); o_=Object_handle(); forw_=false; } LEDA_MEMORY(edge_info) }; void assoc_info(SHalfedge_handle e) const { geninfo::create(info(e)); geninfo::create(info(twin(e))); } void discard_info(SHalfedge_handle e) const { geninfo::clear(info(e)); geninfo::clear(info(twin(e))); } edge_info& ginfo(SHalfedge_handle e) const { return geninfo::access(info(e)); } Object_handle& support(SHalfedge_handle e) const // uedge information we store in the smaller one { if (&*e < &*(twin(e))) return ginfo(e).o_; else return ginfo(twin(e)).o_; } Mark& incident_mark(SHalfedge_handle e) const // biedge information we store in the edge { return ginfo(e).m_left_; } const edge_info& ginfo(SHalfedge_const_handle e) const { return geninfo::const_access(info(e)); } const Mark& incident_mark(SHalfedge_const_handle e) const { return ginfo(e).m_left_; } bool& is_forward(SHalfedge_handle e) const // biedge information we store in the edge { return ginfo(e).forw_; } void assert_equal_marks(SVertex_handle v1, SVertex_handle v2) const { CGAL_assertion(mark(v1)==mark(v2)); } void assert_equal_marks(SHalfedge_handle e1, SHalfedge_handle e2) const { CGAL_assertion(mark(e1)==mark(e2)); } Sphere_segment segment(const Explorer* N, SHalfedge_const_handle e) const { return Sphere_segment( N->point(N->source(e)),N->point(N->target(e)),N->circle(e)); } Sphere_segment trivial_segment(const Explorer* N, SVertex_const_handle v) const { Sphere_point p = N->point(v); return Sphere_segment(p,p); } Seg_pair two_segments(const Explorer* N, SHalfedge_const_handle e) const // we know that source(e)==target(e) { return N->circle(e).split_at(N->point(N->source(e))); } Seg_pair two_segments(const Explorer* N, SHalfloop_const_handle l) const { return N->circle(l).split_at_xy_plane(); } Mark& mark(SVertex_handle h) const { return Base::mark(h); } Mark& mark(SHalfedge_handle h) const { return Base::mark(h); } Mark& mark(SHalfloop_handle h) const { return Base::mark(h); } Mark& mark(SFace_handle h) const { return Base::mark(h); } const Mark& mark(SVertex_const_handle h) const { return Base::mark(h); } const Mark& mark(SHalfedge_const_handle h) const { return Base::mark(h); } const Mark& mark(SHalfloop_const_handle h) const { return Base::mark(h); } const Mark& mark(SFace_const_handle h) const { return Base::mark(h); } /*{\Mcreation 6}*/ SM_triangulator(Sphere_map* M, const Explorer* E, const Sphere_kernel& G = Sphere_kernel()) : Base(M), E_(E), K(G) {} /*{\Mcreate |\Mvar| is a triangulator object for the map |M|, stores the triangulation in |MT|.}*/ /*{\Moperations 1.1 1}*/ void triangulate(); /*{\Mop produces a triangulated sphere map.}*/ void triangulate_per_hemisphere(SVertex_iterator start, SVertex_iterator end); template void partition_to_halfsphere(Iterator start, Iterator end, Seg_list& L, CGAL::Unique_hash_map& M, int pos) const; void merge_halfsphere_maps(SVertex_handle v1, SVertex_handle v2); void merge_nodes(SHalfedge_handle e1, SHalfedge_handle e2); void complete_support(SVertex_iterator v_start, SVertex_iterator v_end, Mark mohs) const; void correct_triangle_at(SVertex_handle v) { CGAL_NEF_TRACEN("correct_triangle_at "<::dump(E_,os); SM_io_parser::dump(*this,os); } Sphere_triangle incident_triangle(SHalfedge_handle e) const { SHalfedge_handle en(next(e)), enn(next(en)); CGAL_assertion(next(enn)==e); return Sphere_triangle( point(source(e)),point(source(en)),point(source(enn)), circle(e),circle(en),circle(enn)); } Sphere_triangle incident_triangle(SHalfedge_const_handle e) const { SHalfedge_const_handle en(next(e)), enn(next(en)); CGAL_assertion(next(enn)==e); return Sphere_triangle( point(source(e)),point(source(en)),point(source(enn)), circle(e),circle(en),circle(enn)); } void discard_info() { SVertex_iterator v; SHalfedge_iterator e; CGAL_forall_svertices(v,*this) discard_info(v); CGAL_forall_shalfedges(e,*this) discard_info(e); } }; // SM_triangulator template void SM_triangulator::triangulate() { CGAL_NEF_TRACEN("triangulate"); // first create sphere segments from isoverts, edges, loops Seg_list L; Seg_map From; SVertex_const_iterator v; CGAL_forall_svertices(v,*E_) { if ( !E_->is_isolated(v) ) continue; L.push_back(trivial_segment(E_,v)); From[--L.end()] = Object_handle(v); } SHalfedge_const_iterator e; CGAL_forall_sedges(e,*E_) { if ( E_->source(e) == E_->target(e) ) { Seg_pair p = two_segments(E_,e); L.push_back(p.first); L.push_back(p.second); From[--L.end()] = From[--(--L.end())] = Object_handle(e); } else { L.push_back(segment(E_,e)); From[--L.end()] = Object_handle(e); } } if ( E_->has_shalfloop() ) { Seg_pair p = two_segments(E_,E_->shalfloop()); L.push_back(p.first); L.push_back(p.second); From[--L.end()] = From[--(--L.end())] = Object_handle(E_->shalfloop()); } // partition segments from L to positive and negative hemisphere Seg_list L_pos,L_neg; partition_to_halfsphere(L.begin(), L.end(), L_pos, From, +1); partition_to_halfsphere(L.begin(), L.end(), L_neg, From, -1); // typename Seg_list::iterator it; // std::cerr << "L_pos" << std::endl; // CGAL_forall_iterators(it,L_pos) std::cerr << *it << std::endl; // std::cerr << "L_neg" << std::endl; // CGAL_forall_iterators(it,L_neg) std::cerr << *it << std::endl; // sweep the hemispheres to create two half sphere maps typedef SM_subdivision SM_output; typedef typename Sphere_kernel::Positive_halfsphere_geometry PH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, PH_geometry> PHS_traits; typedef CGAL::generic_sweep Positive_halfsphere_sweep; typedef typename Sphere_kernel::Negative_halfsphere_geometry NH_geometry; typedef CGAL::Segment_overlay_traits< Seg_iterator, SM_output, NH_geometry> NHS_traits; typedef CGAL::generic_sweep Negative_halfsphere_sweep; SVertex_handle v_sep; SHalfedge_handle e_sep; SM_output O(*this,From); typedef typename PHS_traits::INPUT Input_range; Positive_halfsphere_sweep SP( Input_range(L_pos.begin(),L_pos.end()),O, PH_geometry()); SP.sweep(); v_sep=--this->svertices_end(); e_sep=--this->shalfedges_end(); Negative_halfsphere_sweep SM( Input_range(L_neg.begin(),L_neg.end()),O, NH_geometry()); SM.sweep(); ++v_sep; ++e_sep; // now two CCs of sphere graph are calculated // v_sep = first vertex of CC in negative x-sphere // e_sep = first edge of CC in negative x-sphere SHalfedge_iterator u; CGAL_forall_sedges(u,*this) { Sphere_segment s(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); } Mark lower, upper; SM_point_locator PL(E_->sphere_map()); PL.marks_of_halfspheres(lower,upper); complete_support(this->svertices_begin(), v_sep, lower); complete_support(v_sep, this->svertices_end(), upper); /* CGAL_forall_sedges(u,*this) { std::cerr << point(source(u)) << "->" << point(target(u)) << std::endl; } */ // triangulate per hemisphere typedef SM_constrained_triang_traits PCT_traits; typedef CGAL::generic_sweep Positive_halfsphere_ct_sweep; typedef SM_constrained_triang_traits NCT_traits; typedef CGAL::generic_sweep Negative_halfsphere_ct_sweep; typedef std::pair SVertex_pair; SVertex_pair vpp(this->svertices_begin(),v_sep); Positive_halfsphere_ct_sweep PCTS(vpp, *this, PH_geometry()); PCTS.sweep(); SVertex_pair vpn(v_sep,this->svertices_end()); Negative_halfsphere_ct_sweep NCTS(vpn, *this, NH_geometry()); NCTS.sweep(); /* std::cerr << std::endl; CGAL_forall_sedges(u,*this) { std::cerr << point(source(u)) << "->" << point(target(u)) << std::endl; } */ /* Note the we divide the world along the xy equator and split the equator at y- and y+. We treat the halfcircle at x+ as if perturbed slightly up. This makes triangles that have y- or y+ as a vertex degenerate. if such triangles appear we repair it by flipping the edge opposite to the vertex y-(y+). */ correct_triangle_at(this->svertices_begin()); correct_triangle_at(--SVertex_iterator(v_sep)); correct_triangle_at(v_sep); correct_triangle_at(--this->svertices_end()); // enrigh triangulation edges by circle information /* std::cerr << std::endl; CGAL_forall_sedges(u,*this) { std::cerr << point(source(u)) << "->" << point(target(u)) << std::endl; } */ /* Sphere_segment s; for(u=shalfedges_begin(); u!=e_sep; ++u) { if(point(source(u)) == point(target(u)).antipode()) s = Sphere_segment(point(source(u)), Sphere_point(0,0,1)); else s=Sphere_segment(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); } for(u=e_sep; u!=shalfedges_end(); ++u) { if(point(source(u)) == point(target(u)).antipode()) s = Sphere_segment(point(source(u)), Sphere_point(0,0,-1)); else s=Sphere_segment(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); } */ CGAL_forall_sedges(u,*this) { Sphere_segment s(point(source(u)),point(target(u))); circle(u) = s.sphere_circle(); circle(twin(u)) = s.sphere_circle().opposite(); } // merge the hemisphere maps into one sphere map merge_halfsphere_maps(this->svertices_begin(),v_sep); this->check_integrity_and_topological_planarity(false); } template template void SM_triangulator:: partition_to_halfsphere(Iterator start, Iterator beyond, Seg_list& L, CGAL::Unique_hash_map& M, int pos) const { CGAL_NEF_TRACEN("partition_to_halfsphere "); CGAL_assertion(pos!=0); bool add_cross = true; Sphere_segment s1,s2; Sphere_circle xycircle(0,0,pos); while ( start != beyond ) { if(start->source().hz() * pos > 0 || start->target().hz() * pos > 0) add_cross = false; int i = start->intersection(xycircle,s1,s2); if (i>1) { L.push_back(s2); M[--L.end()] = M[start]; } if (i>0) { L.push_back(s1); M[--L.end()] = M[start]; } ++start; } // now all segments are split into halfspheres // we still have to: // - split segments containing our special poles y^-, y^+ // - split halfcircles // - add four equator segments Sphere_point S(0,-1,0),N(0,1,0); Sphere_circle yzcircle(1,0,0); typename Seg_list::iterator it, itl; bool part_in_hemisphere(false); CGAL_forall_iterators(it,L) { CGAL_NEF_TRACEN(" "<<*it); if ( equal_as_sets(it->sphere_circle(),xycircle) ) { CGAL_NEF_TRACEN(" splitting xy seg "<<*it); int n1 = it->intersection(yzcircle,s1,s2); if (n1 > 1 && !s2.is_degenerate()) { M[ L.insert(it,s2) ] = M[it]; } if (n1 > 0 && !s1.is_degenerate()) { M[ L.insert(it,s1) ] = M[it]; } int n2 = it->intersection(yzcircle.opposite(),s1,s2); if (n2 > 1 && !s2.is_degenerate()) { M[ L.insert(it,s2) ] = M[it]; } if (n2 > 0 && !s1.is_degenerate()) { M[ L.insert(it,s1) ] = M[it]; } itl = it; --it; L.erase(itl); M[itl] = T(); // at least one item was appended } else { part_in_hemisphere = true; } } CGAL_forall_iterators(it,L) { if ( it->is_halfcircle() ) { CGAL_NEF_TRACEN(" splitting halfcircle "<<*it); Sphere_segment s1,s2; it->split_halfcircle(s1,s2); *it = s2; M[ L.insert(it,s1) ] = M[it]; } } // append 4 xy-equator segments: Sphere_segment sp(S,N,xycircle); Sphere_segment sm(S,N,xycircle.opposite()); Sphere_segment s[4]; sp.split_halfcircle(s[0],s[1]); sm.split_halfcircle(s[2],s[3]); L.insert(L.end(),s,s+4); /* if no segment is covering the interior of the hemisphere we have to add a trivial segment to allow for a correct triangulation */ if ( !part_in_hemisphere || add_cross) { Sphere_point p(0,0,pos); Sphere_circle c(1,0,0); L.push_back(Sphere_segment(p,p,c)); } } template void SM_triangulator:: merge_nodes(SHalfedge_handle e1, SHalfedge_handle e2) { SVertex_handle v1 = source(e1), v2 = target(e2); CGAL_NEF_TRACEN("merge_nodes "< void SM_triangulator:: merge_halfsphere_maps(SVertex_handle v1, SVertex_handle v2) { CGAL_NEF_TRACEN("merging halfspheres "< L_equator; SHalfedge_around_sface_circulator ep(last_out_edge(v1)), en(twin(first_out_edge(v2))); do { L_equator.push_back(SHalfedge_pair(ep,en)); merge_nodes(ep,en); ++ep; --en; } while ( source(ep) != v1 ); typename std::list::iterator it; CGAL_forall_iterators(it,L_equator) { SHalfedge_handle e1 = it->first, e2 = it->second; SHalfedge_handle e1t = twin(e1), e2t = twin(e2); CGAL_NEF_TRACEV(PH(e1));CGAL_NEF_TRACEV(PH(e2)); SHalfedge_handle e2tp = previous(e2t); SHalfedge_handle e2tn = next(e2t); link_as_prev_next_pair(e2tp,e1); link_as_prev_next_pair(e1,e2tn); SFace_handle f = face(e2t); if ( is_sm_boundary_object(e2t) ) { undo_sm_boundary_object(e2t,f); store_sm_boundary_object(e1,f); } set_face(e1,f); if ( e2 == first_out_edge(source(e2)) ) set_first_out_edge(source(e2),e1t); discard_info(e2); delete_edge_pair_only(e2); } } template void SM_triangulator:: complete_support(SVertex_iterator v_start, SVertex_iterator v_end, Mark mohs) const { CGAL_NEF_TRACEN("complete_support"); Mark m_buffer(mohs); for (SVertex_iterator v = v_start; v != v_end; ++v) { CGAL_NEF_TRACEN(" vertex = "< 0 ? (point(v).x() >= 0) : (point(v).x()<=0)) ); m_buffer = incident_mark(previous(first_out_edge(v))); } CGAL_NEF_TRACEN(" face mark below "<mark(vs); } else if ( CGAL::assign(es,o) ) { if ( E_->point(E_->source(es)) == point(v) ) { mark(v) = E_->mark(E_->source(es)); } else if ( E_->point(E_->target(es)) == point(v) ) { mark(v) = E_->mark(E_->target(es)); } else { mark(v) = E_->mark(es); } } else if ( CGAL::assign(ls,o) ) { mark(v) = E_->mark(ls); } else CGAL_assertion_msg(0,"damn wrong support."); CGAL_NEF_TRACEN(" face mark at "<circle(ei) != circle(e) ) { ei = E_->twin(ei); } CGAL_assertion( E_->circle(ei) == circle(e) ); CGAL_NEF_TRACEN(" supporting edge "<mark(E_->face(E_->twin(ei))); mark(e) = E_->mark(ei); incident_mark(e) = m_buffer = E_->mark(E_->face(ei)); } SHalfloop_const_handle li; if ( CGAL::assign(li,support(e)) ) { if ( E_->circle(li) != circle(e) ) { li = E_->twin(li); } CGAL_assertion( E_->circle(li) == circle(e) ); CGAL_NEF_TRACEN(" supporting loop "<mark(E_->face(E_->twin(li))); mark(e) = E_->mark(li); incident_mark(e) = m_buffer = E_->mark(E_->face(li)); } } else { CGAL_NEF_TRACEN(" support from face below "); incident_mark(twin(e)) = mark(e) = incident_mark(e) = m_buffer; } CGAL_NEF_TRACEN(" new face mark "< #ifndef CGAL_SPHERE_DIRECTION_H #define CGAL_SPHERE_DIRECTION_H #include CGAL_BEGIN_NAMESPACE /*{\Manpage{Sphere_direction}{R}{Directions on the unit sphere}{c}}*/ template class Sphere_direction : public R_::Plane_3 { /*{\Mdefinition An object |\Mvar| of type |\Mname| is a direction on the surface of the unit sphere. Such directions can be used to describe walks that are part of great circles.}*/ public: /*{\Mtypes 5}*/ typedef R_ R; /*{\Mtypemember representation class.}*/ typedef typename R::RT RT; /*{\Mtypemember ring type.}*/ typedef typename R_::Point_3 Point_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Plane_3 Base; typedef Sphere_direction Self; /*{\Mcreation 5}*/ Sphere_direction() : Base() {} /*{\Mcreate creates some direction.}*/ Sphere_direction(const Sphere_circle& c) /*{\Mcreate creates the direction corresponding to the circle |c|.}*/ : Base(c) {} Sphere_direction(const Sphere_point& p, const Sphere_point&q) : Base(Point_3(0,0,0),p,q) /*{\Mcreate creates a direction that describes the orientation of the great circle through $p$ and $q$ (oriented such that the segment $pq$ is the shorter one of the two possible ones. \precond $p$ and $q$ are not opposite on $S_2$.}*/ { CGAL_assertion(p!=q.opposite()); Point_3 p1(0,0,0), p4 = CGAL::ORIGIN + ((Base*) this)->orthogonal_vector(); if ( CGAL::orientation(p1,p,q,p4) != CGAL::POSITIVE ) *this = Sphere_direction(opposite()); } Sphere_direction(const CGAL::Plane_3& h) /*{\Xcreate creates the direction corresponding to the plane |h|. \precond |h| contains the origin.}*/ : Base(h) { CGAL_assertion(h.d() == 0); } /*{\Moperations 4 2}*/ Sphere_direction opposite() const /*{\Mop returns the opposite of |\Mvar|.}*/ { return Base::opposite(); } Plane_3 plane() const { return Base(*this); } /*{\Xop returns the plane supporting |\Mvar|.}*/ }; // Sphere_direction /* We have: 1) all directions fixed at p 2) d1==d3 possible return true iff d1,d2,d3 are stricly ccw ordered around p Note: Sphere_directions are Plane_3 we therefore compare the normal vectors of the planes that underly the directions d1,d2,d3 in the plane through 0 and orthogonal to the vector p-0 */ template bool strictly_ordered_ccw_at(const Sphere_point& p, const Sphere_direction& d1, const Sphere_direction& d2, const Sphere_direction& d3) { CGAL_assertion(d1.has_on(p) && d2.has_on(p) && d3.has_on(p)); typename R::Point_3 p0(0,0,0); typename R::Point_3 p1(CGAL::ORIGIN + d1.orthogonal_vector()); typename R::Point_3 p2(CGAL::ORIGIN + d2.orthogonal_vector()); typename R::Point_3 p3(CGAL::ORIGIN + d3.orthogonal_vector()); if ( d1 == d3 ) return false; if ( CGAL::orientation(p0,p,p1,p3) == CGAL::POSITIVE ) { return CGAL::orientation(p0,p,p1,p2) == CGAL::POSITIVE && CGAL::orientation(p0,p,p3,p2) == CGAL::NEGATIVE; } else { return CGAL::orientation(p0,p,p1,p2) == CGAL::POSITIVE || CGAL::orientation(p0,p,p3,p2) == CGAL::NEGATIVE; } } CGAL_END_NAMESPACE #endif //CGAL_SPHERE_DIRECTION_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_segment.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_segment.0000644000175000017500000003120411344301501031046 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_segment.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_SEGMENT_H #define CGAL_SPHERE_SEGMENT_H #include #include #include CGAL_BEGIN_NAMESPACE template class Sphere_segment_rep { typedef typename R_::Point_3 Point_3; typedef typename R_::Plane_3 Plane_3; typedef Sphere_point Point; typedef Sphere_circle Circle; typedef Sphere_segment_rep Rep; friend class Sphere_segment; public: Sphere_segment_rep() { ps_ = pt_ = Point(); c_ = Circle(); } Sphere_segment_rep(const Point& p1, const Point& p2, bool shorter_arc=true) : ps_(p1), pt_(p2), c_(Plane_3(p1,p2,Point_3(0,0,0))) { // warning stays as reminder that one gets an arbitrary plane equation // in this degenerate case CGAL_warning(p1 != p2.antipode()); CGAL_assertion(p1 != p2.antipode()); if ( p1 == p2 ) { Plane_3 h(Point_3(0,0,0),(p1-CGAL::ORIGIN)); c_ = Sphere_circle(Plane_3(Point_3(0,0,0),h.base1())); } if (!shorter_arc) c_ = c_.opposite(); CGAL_exactness_assertion(c_.has_on(p1) && c_.has_on(p2)); } Sphere_segment_rep(const Point& p1, const Point& p2, const Circle& c) : ps_(p1), pt_(p2), c_(c) { CGAL_assertion(c.has_on(p1)&&c.has_on(p2)); } Sphere_segment_rep(const Circle& c1, const Circle& c2) : c_(c1) { CGAL_assertion(!equal_as_sets(c1,c2)); ps_ = intersection(c1,c2); pt_ = ps_.antipode(); if ( orientation(Point_3(0,0,0),ps_,pt_, CGAL::ORIGIN + c_.orthogonal_vector()) != CGAL::POSITIVE ) std::swap(ps_,pt_); } Sphere_segment_rep(const Rep& r) : ps_(r.ps_), pt_(r.pt_), c_(r.c_) {} Rep& operator=(const Rep& r) { ps_=r.ps_; pt_=r.pt_; c_=r.c_; return *this; } protected: Sphere_point ps_,pt_; Sphere_circle c_; }; /*{\Moptions print_title=yes }*/ /*{\Manpage{Sphere_segment}{R}{Segments on the unit sphere}{s}}*/ template class Sphere_segment : public Handle_for< Sphere_segment_rep > { /*{\Mdefinition An object |\Mvar| of type |\Mname| is a segment in the surface of a unit sphere that is part of a great circle trough the origin. Sphere segments are represented by two sphere points $p$ and $q$ plus an oriented plane $h$ that contains $p$ and $q$. The plane determines the sphere segment. Let $c$ be the circle in the intersection of $h$ and $S_2$. Then $s$ is that part of $c$ that is swept, when we rotate $p$ into $q$ in counterclockwise rotation around the normal vector of $h$ as seen from the positive halfspace.}*/ public: /*{\Mtypes 6}*/ typedef R_ R; /*{\Mtypemember representation class.}*/ typedef typename R_::RT RT; /*{\Mtypemember ring number type.}*/ typedef Sphere_segment_rep Rep; typedef Handle_for Base; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Line_3 Line_3; typedef Sphere_segment Self; /*{\Mcreation 4}*/ Sphere_segment() : Base() {} Sphere_segment(const Sphere_point& p1, const Sphere_point& p2, bool shorter_arc=true) : Base(Rep(p1,p2,shorter_arc)) {} /*{\Mcreate creates a spherical segment spanning the shorter arc from |p1| to |p2| if |shorter_arc == true|. Otherwise the longer arc is created. \precond |p1 != p2| and |p1 != p2.antipode()|.}*/ Sphere_segment(const Sphere_point& p1, const Sphere_point& p2, const Sphere_circle& c) : Base(Rep(p1,p2,c)) {} /*{\Mcreate creates a spherical segment spanning the arc from |p1| to |p2| as part of the oriented circle |c| (|p1 == p2| or |p1 == p2.antipode()| are possible.) \precond |p1| and |p2| are contained in |c|.}*/ Sphere_segment(const Sphere_circle& c1, const Sphere_circle& c2) : Base(Rep(c1,c2)) {} /*{\Mcreate creates the spherical segment as part of |c1| that is part of the halfsphere left of the oriented circle |c2|. \precond |c1 != c2| as unoriented circles.}*/ Sphere_segment(const Self& s) : Base(s) {} /*{\Moperations 4 2}*/ const Sphere_point& source() const { return this->ptr()->ps_; } /*{\Mop the source point of |\Mvar|.}*/ const Sphere_point& target() const { return this->ptr()->pt_; } /*{\Mop the target point of |\Mvar|.}*/ const Sphere_circle& sphere_circle() const { return this->ptr()->c_; } /*{\Mop the great circle supporting |\Mvar|.}*/ Sphere_segment opposite() const /*{\Mop returns the sperical segment oriented from |target()| to |source()| with the same point set as |\Mvar|. }*/ { return Sphere_segment( target(),source(),sphere_circle().opposite()); } Sphere_segment complement() const /*{\Mop returns the sperical segment oriented from |target()| to |source()| with the point set completing |\Mvar| to a full circle. }*/ { return Sphere_segment(target(),source(),sphere_circle()); } int intersection(const Sphere_circle& c, std::vector >& s) const; int intersection(const Sphere_circle& c, Sphere_segment& s1, Sphere_segment& s2) const; /*{\Mop returns the number of non-trivial connected components of the intersection of |\Mvar| and the closed halfsphere left of |c|.}*/ Sphere_point intersection(const Sphere_segment& so) const; /*{\Mop returns the point of intersection of |\Mvar| and |so|. \precond |\Mvar| and |so| do intersect.}*/ void split_halfcircle(Sphere_segment& s1, Sphere_segment& s2) const /*{\Mop splits a halfcircle into two equally sized segments. \precond |\Mvar| is a halfcircle.}*/ { CGAL_assertion( is_halfcircle() ); Plane_3 h(Point_3(0,0,0),(target()-CGAL::ORIGIN)); Sphere_point p = CGAL::intersection(sphere_circle(),Sphere_circle(h)); if ( !has_on(p) ) p = p.antipode(); s1 = Sphere_segment(this->ptr()->ps_,p,this->ptr()->c_); s2 = Sphere_segment(p,this->ptr()->pt_,this->ptr()->c_); } bool is_short() const /*{\Mop a segment is short iff it is shorter than a halfcircle.}*/ { return CGAL::orientation(Point_3(0,0,0), source(), target(), CGAL::ORIGIN + this->ptr()->c_.orthogonal_vector()) == CGAL::POSITIVE; } bool is_long() const /*{\Mop a segment is long iff it is longer than a halfcircle.}*/ { return CGAL::orientation(Point_3(0,0,0), source(), target(), CGAL::ORIGIN + this->ptr()->c_.orthogonal_vector()) == CGAL::NEGATIVE; } bool is_degenerate() const { return source() == target(); } /*{\Mop return true iff |\Mvar| is degenerate.}*/ bool is_halfcircle() const { return source().antipode() == target(); } /*{\Mop return true iff |\Mvar| is a halfcircle.}*/ bool has_on(const Sphere_point& p) const; /*{\Mop return true iff |\Mvar| contains |p|.}*/ bool has_in_relative_interior(const Sphere_point& p) const; /*{\Mop return true iff |\Mvar| contains |p| in its relative interior.}*/ bool operator==(const Sphere_segment& so) const { return source() == so.source() && target() == so.target() && (source() == target() || sphere_circle() == so.sphere_circle()); } bool operator!=(const Sphere_segment& so) const { return !operator==(so); } }; template bool do_intersect_internally(const Sphere_segment& s1, const Sphere_segment& s2, Sphere_point& p); /*{\Mfunc return true iff |s1| and |s2| intersect internally (non-degenerately). If |true| the parameter |p| returns the point of intersection.}*/ template std::ostream& operator<<(std::ostream& os, const CGAL::Sphere_segment& s) { os << s.source()<<" "< std::istream& operator>>(std::istream& is, CGAL::Sphere_segment& s) { CGAL::Sphere_point p1,p2; CGAL::Sphere_circle c; if ( !(is >> p1 >> p2 >> c) ) return is; s = CGAL::Sphere_segment(p1,p2,c); return is; } template std::pair< Sphere_segment,Sphere_segment > Sphere_circle::split_at(const Sphere_point& p) const { CGAL_assertion(has_on(p)); Sphere_point q(p.antipode()); return Sphere_segment_pair( Sphere_segment(p,q,*this), Sphere_segment(p,q,this->opposite())); } template std::pair< Sphere_segment,Sphere_segment > Sphere_circle::split_at_xy_plane() const { Self xycircle(0,0,1), yzcircle(1,0,0); if ( !equal_as_sets(xycircle,*this) ) return split_at(intersection(*this,xycircle)); else return split_at(intersection(*this,yzcircle)); } /* Contains maps to two orientation checks with the wedge spanned by the source and the target with planes orthogonal to the supporting plane of $p$ and $q$. The logic depends on the segments length: long or short. */ template bool Sphere_segment:: has_on(const CGAL::Sphere_point& p) const { if ( !sphere_circle().has_on(p) ) return false; if ( !is_long() ) { return orientation(Point_3(0,0,0), CGAL::ORIGIN + sphere_circle().orthogonal_vector(), source(),p) != CGAL::NEGATIVE && orientation(Point_3(0,0,0),target(), CGAL::ORIGIN + sphere_circle().orthogonal_vector(),p) != CGAL::NEGATIVE; } else { return orientation(Point_3(0,0,0), CGAL::ORIGIN + sphere_circle().orthogonal_vector(), source(),p) != CGAL::NEGATIVE || orientation(Point_3(0,0,0),target(), CGAL::ORIGIN + sphere_circle().orthogonal_vector(),p) != CGAL::NEGATIVE; } } template bool Sphere_segment:: has_in_relative_interior(const CGAL::Sphere_point& p) const { if ( !sphere_circle().has_on(p) ) return false; if ( !is_long() ) { return orientation(Point_3(0,0,0), CGAL::ORIGIN + sphere_circle().orthogonal_vector(), source(),p) == CGAL::POSITIVE && orientation(Point_3(0,0,0),target(), CGAL::ORIGIN + sphere_circle().orthogonal_vector(),p) == CGAL::POSITIVE; } else { return orientation(Point_3(0,0,0), CGAL::ORIGIN + sphere_circle().orthogonal_vector(), source(),p) == CGAL::POSITIVE || orientation(Point_3(0,0,0),target(), CGAL::ORIGIN + sphere_circle().orthogonal_vector(),p) == CGAL::POSITIVE; } } /* Intersection of two sphere segments. It does not work if the two involved planes are equal as sets. */ template Sphere_point Sphere_segment:: intersection(const Sphere_segment& s) const { CGAL_assertion(!equal_as_sets(sphere_circle(),s.sphere_circle())); Sphere_point res = CGAL::intersection(sphere_circle(),s.sphere_circle()); if ( has_on(res) && s.has_on(res) ) return res; return res.antipode(); } template bool do_intersect_internally(const Sphere_segment& s1, const Sphere_segment& s2, Sphere_point& p) { if ( equal_as_sets(s1.sphere_circle(),s2.sphere_circle()) ) return false; p = CGAL::intersection(s1.sphere_circle(),s2.sphere_circle()); if ( s1.has_in_relative_interior(p) && s2.has_in_relative_interior(p) ) return true; p = p.antipode(); if ( s1.has_in_relative_interior(p) && s2.has_in_relative_interior(p) ) return true; return false; } template bool do_intersect_internally(const Sphere_circle& c1, const Sphere_segment& s2, Sphere_point& p) { if ( equal_as_sets(c1,s2.sphere_circle()) ) return false; p = CGAL::intersection(c1,s2.sphere_circle()); if ( s2.has_in_relative_interior(p) ) return true; p = p.antipode(); if ( s2.has_in_relative_interior(p) ) return true; return false; } CGAL_END_NAMESPACE #endif //CGAL_SPHERE_SEGMENT_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_geometry.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_geometry0000644000175000017500000002002511344301501031160 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_geometry.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_GEOMETRY_H #define CGAL_SPHERE_GEOMETRY_H #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 113 #include CGAL_BEGIN_NAMESPACE template class Sphere_point; template class Sphere_segment; template class Sphere_triangle; template class Sphere_circle; template class Sphere_direction; CGAL_END_NAMESPACE #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template struct Positive_halfsphere_geometry { typedef R_ R; typedef CGAL::Sphere_point Point_2; typedef CGAL::Sphere_segment Segment_2; int axis; Positive_halfsphere_geometry() : axis(2) {} Positive_halfsphere_geometry(int check_sphere) : axis(check_sphere) {} Point_2 source(const Segment_2& s) const { return s.source(); } Point_2 target(const Segment_2& s) const { return s.target(); } Segment_2 construct_segment(const Point_2& p, const Point_2& q) const { return Segment_2(p,q); } void xz_pi_half_rotate(Point_2& p) const { p = Point_2(-p.hz(),p.hy(),p.hx()); } void zx_pi_half_rotate(Point_2& p) const { p = Point_2(-p.hz(),p.hy(),p.hx()); } void xy_pi_half_rotate(Point_2& p) const { p = Point_2(-p.hy(),p.hx(),p.hz()); } int orientation(const Point_2& p1, const Point_2& p2, const Point_2& p3) const { int sor = CGAL::spherical_orientation(p1,p2,p3); if (sor) return sor; Point_2 pp1(p1), pp2(p2), pp3(p3); switch(axis) { case 0: if ( !( p1.hx() == 0 && p2.hx() == 0 && p3.hx() == 0) ) return sor; if ( p1.hz()<0 ) zx_pi_half_rotate(pp1); if ( p2.hz()<0 ) zx_pi_half_rotate(pp2); if ( p3.hz()<0 ) zx_pi_half_rotate(pp3); return CGAL::spherical_orientation(pp1,pp2,pp3); break; case 1: if ( !( p1.hy() == 0 && p2.hy() == 0 && p3.hy() == 0) ) return sor; if ( p1.hx()>0 ) xy_pi_half_rotate(pp1); if ( p2.hx()>0 ) xy_pi_half_rotate(pp2); if ( p3.hx()>0 ) xy_pi_half_rotate(pp3); return CGAL::spherical_orientation(pp1,pp2,pp3); break; case 2: if ( !( p1.hz() == 0 && p2.hz() == 0 && p3.hz() == 0) ) return sor; // sor==0 we perturb any point in the xy-plane with x>0 // by a negative rotation around the y-axis // our perturbation is big :-) we take PI/2 : if ( p1.hx()>0 ) xz_pi_half_rotate(pp1); if ( p2.hx()>0 ) xz_pi_half_rotate(pp2); if ( p3.hx()>0 ) xz_pi_half_rotate(pp3); return CGAL::spherical_orientation(pp1,pp2,pp3); break; } return 0; } int orientation(const Segment_2& s, const Point_2& p) const { return orientation(s.source(),s.target(),p); } bool is_degenerate(const Segment_2& s) const { return s.is_degenerate(); } int compare_xy(const Point_2& p1, const Point_2& p2) const { CGAL_NEF_TRACEN("compare_xy " << axis << ":" << p1 << " / " << p2); return CGAL::spherical_compare(p1,p2,axis,+1); } Point_2 intersection(const Segment_2& s1, const Segment_2& s2) const { if (s1.sphere_circle() != s2.sphere_circle().opposite()) return s1.intersection(s2); CGAL_assertion(s1.target()==s2.target()); return s1.target(); } }; // Positive_halfsphere_geometry template struct Negative_halfsphere_geometry : public Positive_halfsphere_geometry { typedef Positive_halfsphere_geometry Base; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; Negative_halfsphere_geometry() : Base() {} Negative_halfsphere_geometry(int check_sphere) : Base(check_sphere) {} int orientation(const Point_2& p1, const Point_2& p2, const Point_2& p3) const { int sor = CGAL::spherical_orientation(p1,p2,p3); if (sor) return sor; Point_2 pp1(p1), pp2(p2), pp3(p3); switch(((Base*) this)->axis) { case 0: if ( !( p1.hx() == 0 && p2.hx() == 0 && p3.hx() == 0) ) return sor; if ( p1.hz()>0 ) zx_pi_half_rotate(pp1); if ( p2.hz()>0 ) zx_pi_half_rotate(pp2); if ( p3.hz()>0 ) zx_pi_half_rotate(pp3); return CGAL::spherical_orientation(pp1,pp2,pp3); break; case 1: if ( !( p1.hy() == 0 && p2.hy() == 0 && p3.hy() == 0) ) return sor; if ( p1.hx()<0 ) xy_pi_half_rotate(pp1); if ( p2.hx()<0 ) xy_pi_half_rotate(pp2); if ( p3.hx()<0 ) xy_pi_half_rotate(pp3); return CGAL::spherical_orientation(pp1,pp2,pp3); break; case 2: if ( !( p1.hz() == 0 && p2.hz() == 0 && p3.hz() == 0) ) return sor; // sor==0 we perturb any point in the xy-plane with x>0 // by a negative rotation around the y-axis // our perturbation is big :-) we take PI/2 : if ( p1.hx()<0 ) xz_pi_half_rotate(pp1); if ( p2.hx()<0 ) xz_pi_half_rotate(pp2); if ( p3.hx()<0 ) xz_pi_half_rotate(pp3); return CGAL::spherical_orientation(pp1,pp2,pp3); break; } return 0; } int orientation(const Segment_2& s, const Point_2& p) const { return orientation(s.source(),s.target(),p); } int compare_xy(const Point_2& p1, const Point_2& p2) const { return CGAL::spherical_compare(p1,p2,this->axis,-1); } }; // Negative_halfsphere_geometry template struct Sphere_geometry { typedef R_ R; typedef typename R_::RT RT; typedef typename R_::FT FT; typedef CGAL::Sphere_point Sphere_point; typedef CGAL::Sphere_segment Sphere_segment; typedef CGAL::Sphere_circle Sphere_circle; typedef CGAL::Sphere_direction Sphere_direction; typedef CGAL::Sphere_triangle Sphere_triangle; typedef CGAL::Point_3 Point_3; typedef CGAL::Plane_3 Plane_3; typedef CGAL::Aff_transformation_3 Aff_transformation_3; typedef Positive_halfsphere_geometry Positive_halfsphere_geometry; typedef Negative_halfsphere_geometry Negative_halfsphere_geometry; Sphere_point source(const Sphere_segment& s) const { return s.source(); } Sphere_point target(const Sphere_segment& s) const { return s.target(); } Sphere_segment construct_segment(const Sphere_point& p, const Sphere_point& q) const { return Sphere_segment(p,q); } Sphere_segment construct_segment(const Sphere_point& p, const Sphere_point& q, const Plane_3& h) const { return Sphere_segment(p,q,Sphere_circle(h)); } Plane_3 affine_representation(const Plane_3& h, const Point_3& p) const { RT wp = p.hw(); return Plane_3(wp*h.a(),wp*h.b(),wp*h.c(), -(p.hx()*h.a() + p.hy()*h.b() + p.hz()*h.c())); } Plane_3 linear_representation(const Plane_3& h) const { return Plane_3(h.a(),h.b(),h.c(),0); } /* Positive_halfsphere_geometry PHG; const Positive_halfsphere_geometry& get_positive_halfsphere_geometry() const { return PHG; } Negative_halfsphere_geometry NHG; const Negative_halfsphere_geometry& get_negative_halfsphere_geometry() const { return NHG; } */ const Positive_halfsphere_geometry& get_positive_halfsphere_geometry(int a) const { return Positive_halfsphere_geometry(a); } const Negative_halfsphere_geometry& get_negative_halfsphere_geometry(int a) const { return Negative_halfsphere_geometry(a); } }; CGAL_END_NAMESPACE #endif //CGAL_SPHERE_GEOMETRY_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Generic_handle_map.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Generic_handle_0000644000175000017500000000277611344301501031062 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Generic_handle_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_GENERIC_HANDLE_MAP_H #define CGAL_GENERIC_HANDLE_MAP_H #include CGAL_BEGIN_NAMESPACE struct Void_handle_hash_function { std::size_t operator() (void* h) const { return std::size_t(h); } }; template class Generic_handle_map : public Unique_hash_map { typedef Unique_hash_map Base; public: Generic_handle_map() : Base() {} Generic_handle_map(I i) : Base(i) {} template const I& operator[](H h) const { return Base::operator[](&*h); } template I& operator[](H h) { return Base::operator[](&*h); } }; CGAL_END_NAMESPACE #endif //CGAL_GENERIC_HANDLE_MAP_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_geometry_OGL.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_geometry0000644000175000017500000006032111344301501031163 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_geometry_OGL.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_GEOMETRY_OGL_H #define CGAL_SPHERE_GEOMETRY_OGL_H #include #include #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 151 #include #define LGREY CGAL::Color(170,170,200) #define DGREY CGAL::Color(30,30,50) CGAL_BEGIN_NAMESPACE namespace OGL { struct Gen_object { Gen_object() {} virtual ~Gen_object() {} virtual void draw() const {} virtual Gen_object* clone() const { return 0; } virtual void print() const {} }; typedef CGAL::Simple_cartesian VKernel; typedef VKernel::Vector_3 VVector; typedef VKernel::Point_3 VPoint; typedef VKernel::Aff_transformation_3 VTrafo; typedef VKernel::Aff_transformation_3 Affine_3; typedef std::vector VSegment; typedef VKernel::Triangle_3 DTriangle; typedef std::vector VTriangle; const double refinement_angle = 0.1; const double shrink_fac = 0.995; template class Approximator { public: static VPoint approximate(const CGAL::Sphere_point& p) { VVector v = convert(p-CGAL::ORIGIN); v = v / CGAL_NTS sqrt(v*v) ; // normalize return CGAL::ORIGIN+v; } static VSegment approximate(const CGAL::Sphere_segment& s) { /* we construct the rotation matrix that transfers the x-axis into |ps_|, the z-axis into h_.orthogonal_vector() and the y-axix into the corresponding crossproduct of the two.*/ if ( s.is_degenerate() ) { VSegment S(1); S[0] = approximate(s.source()); return S; } VVector v0 = convert(s.source()-CGAL::ORIGIN); VVector v2 = convert(s.sphere_circle().orthogonal_vector()); VVector v1(-cross_product(v0,v2)); VVector v3 = convert(s.target()-CGAL::ORIGIN); double v0l = CGAL_NTS sqrt(v0*v0); double v1l = CGAL_NTS sqrt(v1*v1); double v2l = CGAL_NTS sqrt(v2*v2); double v3l = CGAL_NTS sqrt(v3*v3); double cosalpha = v0*v3 / v0l / v3l; double alpha = acos(cosalpha); const int units_per_halfcircle = 50; int units = int(units_per_halfcircle/CGAL_PI * alpha); if (units == 0) ++units; bool seg_is_short = s.is_short(); bool seg_is_halfcircle = s.is_halfcircle(); if ( seg_is_halfcircle ) units = units_per_halfcircle; else if ( !seg_is_short ) { units = 2*units_per_halfcircle - (units+1); } CGAL_NEF_TRACEV(units); CGAL_NEF_TRACEV(cosalpha); CGAL_NEF_TRACEV(alpha); v0 = v0 / v0l; v1 = v1 / v1l; v2 = v2 / v2l; v3 = v3 / v3l; VTrafo T(v0.x(),v1.x(),v2.x(), v0.y(),v1.y(),v2.y(), v0.z(),v1.z(),v2.z()); VSegment S(units+1); for (int i=0; i& s) { /* we construct the rotation matrix that transfers the x-axis into |ps_|, the z-axis into h_.orthogonal_vector() and the y-axix into the corresponding crossproduct of the two.*/ VVector v0 = convert(s.base1()); VVector v1 = convert(s.base2()); VVector v2 = convert(s.orthogonal_vector()); double v0l = CGAL_NTS sqrt(v0*v0); double v1l = CGAL_NTS sqrt(v1*v1); double v2l = CGAL_NTS sqrt(v2*v2); const int units = 100; v0 = v0 / v0l; v1 = v1 / v1l; v2 = v2 / v2l; VTrafo T(v0.x(),v1.x(),v2.x(), v0.y(),v1.y(),v2.y(), v0.z(),v1.z(),v2.z()); VSegment S(units); for (int i=0; i angle[0] ) { if ( angle[2] > angle[1] ) i=2; else i=1; } else { // angle[0] >= angle[1] if ( angle[2] > angle[0] ) i=2; else i=0; } // now i references the side of maximal angle if ( angle[i] < refinement_angle ) // refinement threshhold { T.push_back(t); return; } VVector v; switch (i) { case 0: v = (t[0]-CGAL::ORIGIN)+(t[1]-CGAL::ORIGIN); break; case 1: v = (t[1]-CGAL::ORIGIN)+(t[2]-CGAL::ORIGIN); break; case 2: v = (t[2]-CGAL::ORIGIN)+(t[0]-CGAL::ORIGIN); break; } v = v / CGAL_NTS sqrt(v*v) ; // normalize VPoint p = CGAL::ORIGIN+v; DTriangle t1,t2; switch (i) { case 0: t1=DTriangle(t[0],p,t[2]); t2=DTriangle(p,t[1],t[2]); break; case 1: t1=DTriangle(t[1],p,t[0]); t2=DTriangle(p,t[2],t[0]); break; case 2: t1=DTriangle(t[2],p,t[1]); t2=DTriangle(p,t[0],t[1]); break; } refine(t1,T); refine(t2,T); } static VTriangle approximate(const CGAL::Sphere_triangle& t) { // we subdivide the triangle into a list of triangles until // we reach a fine resolution on the surface. VTriangle T; DTriangle td(approximate(t.point(0)), approximate(t.point(1)), approximate(t.point(2))); CGAL_NEF_TRACEN("approximate " << td); refine(td,T); return T; } }; template VVector convert(const CGAL::Vector_3& v) { return VVector(CGAL::to_double(v.x()), CGAL::to_double(v.y()), CGAL::to_double(v.z())); } template class Sphere_point : public VPoint, public Gen_object { typedef R_ R; CGAL::Sphere_point p_; CGAL::Color c_; unsigned w_; public: Sphere_point() {} Sphere_point(const CGAL::Sphere_point& p, CGAL::Color c = CGAL::BLACK, unsigned w = 10) : VPoint(Approximator::approximate(p)), p_(p), c_(c), w_(w) {} Sphere_point(const Sphere_point& p) : VPoint(p) { p_ = p.p_; c_ = p.c_; w_ = p.w_; } Sphere_point& operator=(const Sphere_point& p) { VPoint::operator=(p); p_ = p.p_; c_ = p.c_; w_ = p.w_; return *this; } virtual ~Sphere_point() {} const CGAL::Sphere_point& original() const { return p_; } virtual Gen_object* clone() const { return new Sphere_point(*this); } virtual void draw() const { glPointSize(w_); glColor3ub(c_.red(),c_.green(),c_.blue()); glBegin(GL_POINTS); glNormal3d(x(),y(),z()); glVertex3d(x(),y(),z()); glEnd(); } virtual void print() const { std::cerr << "point " << p_; } }; template class Sphere_segment : public VSegment, public Gen_object { typedef R_ R; CGAL::Sphere_segment s_; CGAL::Color c_; unsigned w_; public: Sphere_segment() {} Sphere_segment(const CGAL::Sphere_segment& s, CGAL::Color c = CGAL::BLACK, unsigned w = 2) : VSegment(Approximator::approximate(s)), s_(s), c_(c), w_(w) {} Sphere_segment(const Sphere_segment& s) : VSegment(s) { s_ = s.s_; c_ = s.c_; w_ = s.w_; } Sphere_segment& operator=(const Sphere_segment& s) { VSegment::operator=(s); s_ = s.s_; c_ = s.c_; w_ = s.w_; return *this; } virtual ~Sphere_segment() {} const CGAL::Sphere_segment& original() const { return s_; } virtual Gen_object* clone() const { return new Sphere_segment(*this); } virtual void draw() const { CGAL_NEF_TRACEN("draw "<x(),begin()->y(),begin()->z()); glVertex3d(begin()->x(),begin()->y(),begin()->z()); glEnd(); } else { glLineWidth(w_); glColor3ub(c_.red(),c_.green(),c_.blue()); glBegin(GL_LINE_STRIP); VSegment::const_iterator it; for(it = begin(); it != end(); ++it) { glNormal3d(it->x(),it->y(),it->z()); glVertex3d(it->x(),it->y(),it->z()); } glEnd(); } } virtual void print() const { std::cerr << "segment " << s_; } }; template class Sphere_circle : public VSegment, public Gen_object { typedef R_ R; CGAL::Sphere_circle s_; CGAL::Color c_; unsigned w_; public: Sphere_circle() {} Sphere_circle(const CGAL::Sphere_circle& s, CGAL::Color c = CGAL::BLACK, unsigned w = 2) : VSegment(Approximator::approximate(s)), s_(s), c_(c), w_(w) {} Sphere_circle(const Sphere_circle& s) : VSegment(s) { s_ = s.s_; c_ = s.c_; w_ = s.w_; } Sphere_circle& operator=(const Sphere_circle& s) { VSegment::operator=(s); s_ = s.s_; c_ = s.c_; w_ = s.w_; return *this; } virtual ~Sphere_circle() {} const CGAL::Sphere_circle& original() const { return s_; } virtual Gen_object* clone() const { return new Sphere_circle(*this); } virtual void draw() const { CGAL_NEF_TRACEN("draw "<x(),it->y(),it->z()); glVertex3d(it->x(),it->y(),it->z()); } glEnd(); } virtual void print() const { std::cerr << "circle " << s_; } }; /* The following class approximates a spherical triangle by a list of flat triangles */ template class Sphere_triangle : public VTriangle, public Gen_object { typedef R_ R; CGAL::Sphere_triangle t_; CGAL::Color c_; public: Sphere_triangle() {} Sphere_triangle(const CGAL::Sphere_triangle& t, CGAL::Color c = CGAL::Color(100,100,120)) : VTriangle(Approximator::approximate(t)), t_(t), c_(c) {} Sphere_triangle(const Sphere_triangle& t) : VTriangle(t) { t_ = t.t_; c_ = t.c_; } Sphere_triangle& operator=(const Sphere_triangle& t) { VTriangle::operator=(t); t_ = t.t_; c_ = t.c_; return *this; } virtual ~Sphere_triangle() {} const CGAL::Sphere_triangle& original() const { return t_; } virtual Gen_object* clone() const { return new Sphere_triangle(*this); } virtual void draw() const { CGAL_NEF_TRACEN("draw "<vertex(0); glNormal3d(p.x(),p.y(),p.z()); //glVertex3d(p.x(),p.y(),p.z()); glVertex3d(shrink_fac*p.x(),shrink_fac*p.y(),shrink_fac*p.z()); p = it->vertex(1); glNormal3d(p.x(),p.y(),p.z()); glVertex3d(shrink_fac*p.x(),shrink_fac*p.y(),shrink_fac*p.z()); p = it->vertex(2); glNormal3d(p.x(),p.y(),p.z()); glVertex3d(shrink_fac*p.x(),shrink_fac*p.y(),shrink_fac*p.z()); } glEnd(); glDisable(GL_COLOR_MATERIAL); } virtual void print() const { std::cerr << "triangle " << t_; } }; //---------------------------------------------------------------------------- // the sphere: //---------------------------------------------------------------------------- enum { SM_FACES, SM_SKELETON, SM_TRIANGULATION }; enum { SM_AXES, SM_CUBE }; class Unit_sphere : public OGL_base_object { typedef std::list Object_list; typedef Object_list::const_iterator Object_const_iterator; typedef Object_list::iterator Object_iterator; GLUquadricObj* sphere_; int style_; bool initialized_; Object_list objects_,triangles_,triangle_edges_; GLuint sphere_list_; std::vector switches; public: void init() { style_ = SM_FACES; switches[0] = true; switches[1] = false; gluQuadricNormals(sphere_,GLenum(GLU_SMOOTH)); } Unit_sphere() : switches(2) { sphere_ = gluNewQuadric(); initialized_ = false; init(); } void clear_list() { while ( objects_.begin() != objects_.end() ) { delete (*objects_.begin()); objects_.pop_front(); } while ( triangles_.begin() != triangles_.end() ) { delete (*triangles_.begin()); triangles_.pop_front(); } while ( triangle_edges_.begin() != triangle_edges_.end() ) { delete (*triangle_edges_.begin()); triangle_edges_.pop_front(); } } void copy_list(const Unit_sphere& S) { Object_const_iterator it; CGAL_forall_iterators (it,S.objects_) objects_.push_back( (*it)->clone() ); CGAL_forall_iterators (it,S.triangles_) triangles_.push_back( (*it)->clone() ); CGAL_forall_iterators (it,S.triangle_edges_) triangle_edges_.push_back( (*it)->clone() ); } void print() const { std::cerr << "Dumping Unit_sphere:\n"; for (Object_const_iterator it = objects_.begin(); it != objects_.end(); ++it) (*it)->print(); std::cerr << std::endl; for (Object_const_iterator it = triangles_.begin(); it != triangles_.end(); ++it) (*it)->print(); std::cerr << std::endl; } Unit_sphere(const Unit_sphere& S) : switches(2) { CGAL_NEF_TRACEN("copyconstruction"); sphere_ = gluNewQuadric(); initialized_ = S.initialized_; style_ = S.style_; switches[0] = S.switches[0]; switches[1] = S.switches[1]; copy_list(S); } Unit_sphere& operator=(const Unit_sphere& S) { CGAL_NEF_TRACEN("assignment"); initialized_ = S.initialized_; style_ = S.style_; switches[0] = S.switches[0]; switches[1] = S.switches[1]; clear_list(); copy_list(S); return *this; } ~Unit_sphere() { clear_list(); gluDeleteQuadric(sphere_); } template void push_back(const CGAL::Sphere_point& p, CGAL::Color c = CGAL::YELLOW, unsigned w = 5) { objects_.push_back(new Sphere_point(p,c,w)); } template void push_back(const CGAL::Sphere_segment& s, CGAL::Color c = CGAL::BLACK, unsigned w = 1) { objects_.push_back(new Sphere_segment(s,c,w)); } template void push_back(const CGAL::Sphere_circle& s, CGAL::Color c = CGAL::BLACK, unsigned w = 1) { objects_.push_back(new Sphere_circle(s,c,w)); } template void push_back(const CGAL::Sphere_triangle& t, CGAL::Color c = CGAL::WHITE) { triangles_.push_back(new Sphere_triangle(t,c)); } template void push_back_triangle_edge(const CGAL::Sphere_segment& s, CGAL::Color c = CGAL::BLUE, unsigned w = 1) { triangle_edges_.push_back(new Sphere_segment(s,c,w)); } void set_style(int style) { style_ = style; } void toggle(int index) { switches[index] = !switches[index]; } private: void construct_axes() const { int i; register double f(1.02); glNewList(sphere_list_+3, GL_COMPILE); glLineWidth(2.0); // red x-axis and equator glColor3f(1.0,0.0,0.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(1.2,0.0,0.0); glEnd(); glBegin(GL_LINE_LOOP); for(i=0;i<100;i++) glVertex3d(f*cos(2.0*CGAL_PI*i/100.0),f*sin(2.0*CGAL_PI*i/100.0),0.0); glEnd(); // green y-axis and equator glColor3f(0.0,1.0,0.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(0.0,1.2,0.0); glEnd(); glBegin(GL_LINE_LOOP); for(i=0;i<100;i++) glVertex3d(0.0,f*cos(2.0*CGAL_PI*i/100.0),f*sin(2.0*CGAL_PI*i/100.0)); glEnd(); // blue z-axis and equator glColor3f(0.0,0.0,1.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(0.0,0.0,1.2); glEnd(); glBegin(GL_LINE_LOOP); for(i=0;i<100;i++) glVertex3d(f*cos(2.0*CGAL_PI*i/100.0),0.0,f*sin(2.0*CGAL_PI*i/100.0)); glEnd(); // six coordinate points in pink: glPointSize(10); glColor3f(1,0,1); glBegin(GL_POINTS); glVertex3d(1,0,0); glVertex3d(0,1,0); glVertex3d(0,0,1); glVertex3d(-1,0,0); glVertex3d(0,-1,0); glVertex3d(0,0,-1); glEnd(); glEndList(); } void construct_cube() const { glNewList(sphere_list_+4, GL_COMPILE); glColor3f(1,1,0); // yellow glLineWidth(2.0); glBegin(GL_LINE_LOOP); glVertex3f(-1.0,-1.0,-1.0); glVertex3f( 1.0,-1.0,-1.0); glVertex3f( 1.0, 1.0,-1.0); glVertex3f(-1.0, 1.0,-1.0); glEnd(); glBegin(GL_LINE_LOOP); glVertex3f(-1.0,-1.0, 1.0); glVertex3f( 1.0,-1.0, 1.0); glVertex3f( 1.0, 1.0, 1.0); glVertex3f(-1.0, 1.0, 1.0); glEnd(); glBegin(GL_LINES); glVertex3f(-1.0,-1.0,-1.0); glVertex3f(-1.0,-1.0, 1.0); glVertex3f( 1.0,-1.0,-1.0); glVertex3f( 1.0,-1.0, 1.0); glVertex3f( 1.0, 1.0,-1.0); glVertex3f( 1.0, 1.0, 1.0); glVertex3f(-1.0, 1.0,-1.0); glVertex3f(-1.0, 1.0, 1.0); glEnd(); glEndList(); } void construct() { initialized_=true; sphere_list_ = glGenLists(5); CGAL_assertion_msg(sphere_list_!=0,"no display list."); // skeleton: glNewList(sphere_list_, GL_COMPILE); for (Object_const_iterator it = objects_.begin(); it != objects_.end(); ++it) (*it)->draw(); glEndList(); // triangles: glNewList(sphere_list_+1, GL_COMPILE); for (Object_const_iterator it = triangles_.begin(); it != triangles_.end(); ++it) (*it)->draw(); glEndList(); glNewList(sphere_list_+2, GL_COMPILE); for (Object_const_iterator it = triangle_edges_.begin(); it != triangle_edges_.end(); ++it) (*it)->draw(); glEndList(); // orientation features: construct_axes(); construct_cube(); } public: void draw(GLdouble z_vec[3]) const // void draw() const { gluQuadricDrawStyle(sphere_,GLenum(GLU_FILL)); glEnable(GL_LIGHTING); if ( style_ == SM_SKELETON ) { glEnable(GL_COLOR_MATERIAL); glColor3f(0.7,0.7,0.7); gluSphere(sphere_,shrink_fac,50,50); glDisable(GL_COLOR_MATERIAL); } glDisable(GL_LIGHTING); if ( !initialized_ ) const_cast(this)->construct(); if ( style_ == SM_FACES || style_ == SM_TRIANGULATION ) { glEnable(GL_LIGHTING); glCallList(sphere_list_+1); // triangle list glDisable(GL_LIGHTING); } if ( style_ == SM_TRIANGULATION ) { glCallList(sphere_list_+2); // triangle edge list } if ( style_ != SM_TRIANGULATION ) { glCallList(sphere_list_); } if ( switches[0] ) glCallList(sphere_list_+3); if ( switches[1] ) glCallList(sphere_list_+4); } }; template class SM_BooleColor { typedef typename Map_::SVertex_const_handle SVertex_const_handle; typedef typename Map_::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Map_::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Map_::SFace_const_handle SFace_const_handle; typedef typename Map_::Mark Mark; public: Color color(SVertex_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfedge_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfloop_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SFace_const_handle, Mark m) const { return ( m ? DGREY : LGREY ); } }; template class NefS2_to_UnitSphere { typedef typename Nef_polyhedron::Sphere_map Sphere_map; typedef CGAL::OGL::SM_BooleColor Color_; typedef typename Sphere_map::Sphere_kernel Sphere_kernel; typedef SM_decorator Decorator; typedef CGAL::SM_triangulator Base; typedef typename Sphere_map::SVertex_const_handle SVertex_const_handle; typedef typename Sphere_map::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Sphere_map::SFace_const_handle SFace_const_handle; typedef typename Sphere_map::SVertex_const_iterator SVertex_const_iterator; typedef typename Sphere_map::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Sphere_map::SFace_const_iterator SFace_const_iterator; typedef typename Sphere_map::Mark Mark; typedef typename Sphere_kernel::Sphere_point Sphere_point; typedef typename Sphere_kernel::Sphere_segment Sphere_segment; typedef typename Sphere_kernel::Sphere_circle Sphere_circle; typedef typename Sphere_kernel::Sphere_triangle Sphere_triangle; typedef Color_ Color_objects; public: static CGAL::OGL::Unit_sphere convert(const Nef_polyhedron& E_, const Color_objects& CO_ = Color_objects()) { Sphere_map MT_(true); Base T_(&MT_, &E_); CGAL::OGL::Unit_sphere S_; T_.triangulate(); SHalfedge_const_iterator e; CGAL_forall_sedges(e,E_) { if ( e->source() == e->twin()->source() ) { S_.push_back(E_.circle(e), CO_.color(e,E_.mark(e)));} else { S_.push_back(Sphere_segment(E_.point(E_.source(e)), E_.point(E_.target(e)), E_.circle(e)),CO_.color(e,E_.mark(e))); } } // draw sphere circles underlying loops of E_: if ( E_.has_shalfloop() ) S_.push_back( Sphere_circle(E_.circle(E_.shalfloop())), CO_.color(E_.shalfloop(),E_.mark(E_.shalfloop()))); // draw points underlying vertices of E_: SVertex_const_iterator v; CGAL_forall_svertices(v,E_) S_.push_back(E_.point(v),CO_.color(v,E_.mark(v))); Unique_hash_map Done(false); CGAL_forall_shalfedges(e,T_) { if ( Done[e] ) continue; SHalfedge_const_handle en(e->snext()),enn(en->snext()); CGAL_NEF_TRACEV(T_.incident_triangle(e)); CGAL_NEF_TRACEN(T_.incident_mark(e)<twin()]=true; } return S_; } }; } // OGL CGAL_END_NAMESPACE template std::ostream& operator<<(std::ostream& os, const CGAL::OGL::Sphere_segment& s) { CGAL::OGL::VSegment::const_iterator it; os << s.original() << " "; for (it = s.begin(); it != s.end(); ++it) os << *it; return os; } template std::ostream& operator<<(std::ostream& os, const CGAL::OGL::Sphere_circle& s) { CGAL::OGL::VSegment::const_iterator it; os << s.original() << " "; for (it = s.begin(); it != s.end(); ++it) os << *it; return os; } template std::ostream& operator<<(std::ostream& os, const CGAL::OGL::Sphere_point& p) { os << p.original() << CGAL::OGL::VPoint(p); return os; } #endif //CGAL_SPHERE_GEOMETRY_OGL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_map.h0000644000175000017500000005204511344301501030337 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/Sphere_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_SPHERE_MAP_H #define CGAL_SPHERE_MAP_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 109 #include CGAL_BEGIN_NAMESPACE template class move_edge_around_svertex { public: void forward(HE& e) const { e = (e->sprev()->twin()); } void backward(HE& e) const { e = (e->twin()->snext()); } }; template struct move_edge_around_sface { void forward(HE& e) const { e = (e->snext()); } void backward(HE& e) const { e = (e->sprev()); } }; /*{\Manpage {Sphere_map}{Kernel}{Sphere Maps}{M}}*/ template class Sphere_map { /*{\Mdefinition selective sphere map container based on the HDS design of Kettner.}*/ public: /*{\Mtypes 7}*/ typedef Sphere_map Self; typedef Kernel_ Sphere_kernel; typedef Items_ Items; typedef Mark_ Mark; friend class SM_const_decorator; friend class SM_decorator; typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember points on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember segments on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember segments on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_direction Sphere_direction; /*{\Mtypemember directions on the unit sphere.}*/ // typedef bool Mark; /*{\Mtypemember selective attributes of all objects.}*/ typedef size_t Size_type; /*{\Mtypemember size type.}*/ /*{\Mtext For all objects |Vertex|, |Halfedge|, |Halfloop|, |Face| there are handle and iterator types |xxx_handle|, |xxx_iterator|. There's no type |SLoop_iterator|, as there is at most one |SLoop| pair per sphere map.}*/ typedef typename Items::template SVertex SVertex_base; typedef SNC_in_place_list_svertex SVertex; typedef CGAL::In_place_list SVertex_list; typedef CGAL_ALLOCATOR(SVertex) SVertex_alloc; typedef typename SVertex_list::iterator SVertex_handle; typedef typename SVertex_list::const_iterator SVertex_const_handle; typedef typename SVertex_list::iterator SVertex_iterator; typedef typename SVertex_list::const_iterator SVertex_const_iterator; typedef typename Items::template SHalfedge SHalfedge_base; typedef SNC_in_place_list_shalfedge SHalfedge; typedef CGAL::In_place_list SHalfedge_list; typedef CGAL_ALLOCATOR(SHalfedge) SHalfedge_alloc; typedef typename SHalfedge_list::iterator SHalfedge_handle; typedef typename SHalfedge_list::const_iterator SHalfedge_const_handle; typedef typename SHalfedge_list::iterator SHalfedge_iterator; typedef typename SHalfedge_list::const_iterator SHalfedge_const_iterator; typedef typename Items::template SFace SFace_base; typedef SNC_in_place_list_sface SFace; typedef CGAL::In_place_list SFace_list; typedef CGAL_ALLOCATOR(SFace) SFace_alloc; typedef typename SFace_list::iterator SFace_handle; typedef typename SFace_list::const_iterator SFace_const_handle; typedef typename SFace_list::iterator SFace_iterator; typedef typename SFace_list::const_iterator SFace_const_iterator; typedef typename Items::template SHalfloop SHalfloop; typedef SHalfloop* SHalfloop_handle; typedef const SHalfloop* SHalfloop_const_handle; typedef SHalfloop* SHalfloop_iterator; typedef const SHalfloop* SHalfloop_const_iterator; typedef CGAL::Object_handle Object_handle; /*{\Mtypemember a generic handle to an object of |\Mvar|. The kind of the object can be determined and the object assigned by the function:\\ |bool assign(xxx_handle& h, Object_handle o)|\\ where the function returns |true| iff the assignment of |o| to |h| was valid.}*/ typedef std::list Object_list; typedef typename Object_list::iterator Object_iterator; typedef typename Object_list::const_iterator Object_const_iterator; typedef Generic_handle_map Handle_to_iterator_map; typedef Sphere_map* Constructor_parameter; typedef const Sphere_map* Constructor_const_parameter; class SFace_cycle_iterator : public Object_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a facet. Convertible to |Object_handle|.}*/ { typedef Object_iterator Ibase; public: SFace_cycle_iterator() : Ibase() {} SFace_cycle_iterator(const Ibase& b) : Ibase(b) {} SFace_cycle_iterator(const SFace_cycle_iterator& i) : Ibase(i) {} bool is_svertex() const { SVertex_handle v; return CGAL::assign(v,Ibase::operator*()); } bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SVertex_handle() const { SVertex_handle v; CGAL::assign(v,Ibase::operator*()); return v; } operator SHalfedge_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return e; } operator SHalfloop_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return l; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_assertion_msg(0,"not impl."); return Object_handle(); } }; class SFace_cycle_const_iterator : public Object_const_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a facet. Convertible to |Object_handle|.}*/ { typedef Object_const_iterator Ibase; public: SFace_cycle_const_iterator() : Ibase() {} SFace_cycle_const_iterator(const Ibase& b) : Ibase(b) {} SFace_cycle_const_iterator(const SFace_cycle_const_iterator& i) : Ibase(i) {} bool is_svertex() const { SVertex_handle v; return CGAL::assign(v,Ibase::operator*()); } bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SVertex_const_handle() const { SVertex_handle v; CGAL::assign(v,Ibase::operator*()); return SVertex_const_handle(v); } operator SHalfedge_const_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return SHalfedge_const_handle(e); } operator SHalfloop_const_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return SHalfloop_const_handle(l); } operator Object_handle() const { return Ibase::operator*(); } const Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_assertion_msg(0,"not impl."); return Object_handle(); } }; /*{\Mtext Local types are handles, iterators and circulators of the following kind: |SVertex_handle|, |SVertex_iterator|, |SHalfedge_handle|, |SHalfedge_iterator|, |SHalfloop_handle|, |SHalfloop_iterator|, |SFace_handle|, |SFace_iterator|. Additionally the following circulators are defined.}*/ typedef CircFromIt< SHalfedge_const_iterator, move_edge_around_svertex > SHalfedge_around_svertex_const_circulator; /*{\Mtypemember circulating the adjacency list of an vertex |v|.}*/ typedef CircFromIt< SHalfedge_const_iterator, move_edge_around_sface > SHalfedge_around_sface_const_circulator; /*{\Mtypemember circulating the face cycle of an face |f|.}*/ typedef CircFromIt< SHalfedge_iterator, move_edge_around_svertex > SHalfedge_around_svertex_circulator; /*{\Mtypemember circulating the adjacency list of an vertex |v|.}*/ typedef CircFromIt< SHalfedge_iterator, move_edge_around_sface > SHalfedge_around_sface_circulator; /*{\Mtypemember circulating the face cycle of an face |f|.}*/ /*{\Mcreation 3}*/ /*{\Mtext |\Mname| is default and copy constructible. Note that copy construction means cloning an isomorphic structure and is thus an expensive operation.}*/ Sphere_map(bool b=false) : boundary_item_(undef_), svertices_(), sedges_(), sfaces_(), shalfloop_() {} ~Sphere_map() { clear(); } Sphere_map(const Self& D) : boundary_item_(undef_), svertices_(D.svertices_), sedges_(D.sedges_), sfaces_(D.sfaces_), shalfloop_(0) { if ( D.shalfloop_ != 0 ) new_shalfloop_pair(*(D.shalfloop_)); pointer_update(D); } Self& operator=(const Self& D) { if ( this == &D ) return *this; clear(); svertices_ = D.svertices_; sfaces_ = D.sfaces_; sedges_ = D.sedges_; if ( D.shalfloop_ != 0 ) new_shalfloop_pair(*D.shalfloop_); pointer_update(D); return *this; } void clear() { boundary_item_.clear(undef_); svertices_.destroy(); sfaces_.destroy(); while ( shalfedges_begin() != shalfedges_end() ) delete_shalfedge_pair( shalfedges_begin() ); if ( shalfloop_ != 0 ) { delete_shalfloop_pair(); shalfloop_=0; } } template bool is_sm_boundary_object(H h) const { return boundary_item_[h]!=undef_; } template Object_iterator& sm_boundary_item(H h) { return boundary_item_[h]; } template void store_sm_boundary_item(H h, Object_iterator o) { boundary_item_[h] = o; } template void undef_sm_boundary_item(H h) { CGAL_assertion(boundary_item_[h]!=undef_); boundary_item_[h] = undef_; } void reset_sm_iterator_hash(Object_iterator it) { SVertex_handle sv; SHalfedge_handle se; SHalfloop_handle sl; if ( CGAL::assign(se,*it) ) { undef_sm_boundary_item(se); return; } if ( CGAL::assign(sl,*it) ) { undef_sm_boundary_item(sl); return; } if ( CGAL::assign(sv,*it) ) { undef_sm_boundary_item(sv); return; } } void reset_sm_object_list(Object_list& L) { Object_iterator oit; CGAL_forall_iterators(oit,L) reset_sm_iterator_hash(oit); L.clear(); } /*{\Moperations 2.5 3}*/ // The constant iterators and circulators. SVertex_const_iterator svertices_begin() const { return svertices_.begin();} SVertex_const_iterator svertices_end() const { return svertices_.end();} SHalfedge_const_iterator shalfedges_begin() const { return sedges_.begin();} SHalfedge_const_iterator shalfedges_end() const { return sedges_.end();} SHalfloop_const_iterator shalfloops_begin() const { return shalfloop_; } SHalfloop_const_iterator shalfloops_end() const { return shalfloop_ != 0 ? shalfloop_+2 : shalfloop_; } SFace_const_iterator sfaces_begin() const { return sfaces_.begin();} SFace_const_iterator sfaces_end() const { return sfaces_.end();} SVertex_iterator svertices_begin() { return svertices_.begin();} SVertex_iterator svertices_end() { return svertices_.end();} SHalfedge_iterator shalfedges_begin() { return sedges_.begin();} SHalfedge_iterator shalfedges_end() { return sedges_.end();} SHalfloop_iterator shalfloops_begin() { return shalfloop_; } SHalfloop_iterator shalfloops_end() { return shalfloop_ != 0 ? shalfloop_+2 : shalfloop_; } SFace_iterator sfaces_begin() { return sfaces_.begin();} SFace_iterator sfaces_end() { return sfaces_.end();} SFace_cycle_const_iterator sface_cycles_begin(SFace_const_handle f) const { return f->sface_cycles_begin(); } SFace_cycle_const_iterator sface_cycles_end(SFace_const_handle f) const { return f->sface_cycles_end(); } SFace_cycle_iterator sface_cycles_begin(SFace_handle f) const { return f->sface_cycles_begin(); } SFace_cycle_iterator sface_cycles_end(SFace_handle f) const { return f->sface_cycles_end(); } /*{\Mtext The list of all objects can be accessed via iterator ranges. For comfortable iteration we also provide iterations macros. The iterator range access operations are of the following kind:\\ |SVertex_iterator vertices_begin()/vertices_end()|\\ |SHalfedge_iterator halfedges_begin()/halfedges_end()|\\ |SHalfloop_iterator halfloops_begin()/halfloops_end()|\\ |SFace_iterator faces_begin()/faces_end()| */ Size_type number_of_svertices() const { return svertices_.size();} /*{\Mop returns the number of vertices.}*/ Size_type number_of_shalfedges() const { return sedges_.size();} /*{\Mop returns the number of (directed edges).}*/ Size_type number_of_sfaces() const { return sfaces_.size();} /*{\Mop returns the number of facets.}*/ Size_type number_of_shalfloops() const { return shalfloop_!=SHalfloop_handle() ? 2 : 0; } /*{\Mop returns the number of shalfloop.}*/ bool empty() const { return number_of_svertices() == 0 && number_of_shalfedges() == 0 && number_of_shalfloops() == 0 && number_of_sfaces() == 0; } bool has_shalfloop() const { return shalfloop_ != 0; } SHalfloop_handle& shalfloop() { return shalfloop_; } SHalfloop_const_handle shalfloop() const { return shalfloop_; } SVertex_alloc vertex_allocator; SVertex* get_vertex_node( const SVertex& t) { SVertex* p = vertex_allocator.allocate(1); vertex_allocator.construct( p, SVertex()); return p; } void put_vertex_node( SVertex* p) { vertex_allocator.destroy(p); vertex_allocator.deallocate( p, 1); } SHalfedge_alloc halfedge_allocator; SHalfedge* get_halfedge_node( const SHalfedge& t) { SHalfedge* p = halfedge_allocator.allocate(1); halfedge_allocator.construct( p, SHalfedge()); return p; } void put_halfedge_node( SHalfedge* p) { halfedge_allocator.destroy(p); halfedge_allocator.deallocate( p, 1); } SFace_alloc face_allocator; SFace* get_face_node( const SFace& t) { SFace* p = face_allocator.allocate(1); face_allocator.construct( p, SFace()); return p; } void put_face_node( SFace* p) { face_allocator.destroy(p); face_allocator.deallocate( p, 1); } SVertex_handle new_svertex(const Sphere_point& p, Mark m = Mark()) /*{\Mop returns a new vertex at point |p| marked by |m|.}*/ { SVertex_handle vh = new_svertex(); vh->point() = p; vh->mark() = m; CGAL_NEF_TRACEN("new_svertex "<<&*vh); return vh; } template void make_twins(H h1, H h2) { h1->twin() = h2; h2->twin() = h1; } SVertex_handle new_svertex() { svertices_.push_back( * get_vertex_node(SVertex())); return --svertices_end(); } SFace_handle new_sface() { sfaces_.push_back( * get_face_node(SFace())); return --sfaces_end(); } SHalfedge_handle new_shalfedge_pair() { SHalfedge* ep2 = get_halfedge_node(SHalfedge()); SHalfedge* ep1 = get_halfedge_node(SHalfedge()); sedges_.push_back( *ep1 ); SHalfedge_handle e1 = --shalfedges_end(); sedges_.push_back( *ep2 ); SHalfedge_handle e2 = --shalfedges_end(); make_twins(e1,e2); return e1; } SHalfloop_handle new_shalfloop_pair() { SHalfloop_handle ph = new SHalfloop[2]; SHalfloop* pt(ph); ++pt; make_twins(ph,pt); shalfloop_=ph; return ph; } SHalfedge_handle new_shalfedge_pair(const SHalfedge& e1) { const SHalfedge& e2 = *(e1.twin()); SHalfedge* ep2 = new SHalfedge[2]; SHalfedge* ep1 = ep2++; *ep1=e1; *ep2=e2; sedges_.push_back( *ep1 ); SHalfedge_handle eh1 = --shalfedges_end(); sedges_.push_back( *ep2 ); SHalfedge_handle eh2 = --shalfedges_end(); make_twins(eh1,eh2); return eh1; } SHalfloop_handle new_shalfloop_pair(const SHalfloop& l1) { const SHalfloop& l2 = *(l1.twin()); SHalfloop* ph = new SHalfloop[2]; SHalfloop* pt(ph); ++pt; *ph=l1; *pt=l2; make_twins(ph,pt); shalfloop_=ph; return ph; } void delete_svertex(SVertex_handle h) { svertices_.erase(h); put_vertex_node(&*h); } void delete_sface(SFace_handle h) { sfaces_.erase(h); put_face_node(&*h); } void delete_shalfedge_pair(SHalfedge_handle h) { SHalfedge_handle t = h->twin(); sedges_.erase(h); sedges_.erase(t); put_halfedge_node(&*h); put_halfedge_node(&*t); } void delete_shalfloop_pair() { CGAL_assertion(has_shalfloop()); SHalfloop* ph = &*shalfloop_; SHalfloop* pt = &*shalfloop_->twin(); if ( ph > pt ) std::swap(ph,pt); shalfloop_ = SHalfloop_handle(); delete [] ph; } protected: void pointer_update(const Self& D); Handle_to_iterator_map boundary_item_; static Object_iterator undef_; SVertex_list svertices_; SHalfedge_list sedges_; SFace_list sfaces_; SHalfloop_iterator shalfloop_; }; // Sphere_map template void Sphere_map:: pointer_update(const Sphere_map& D) { CGAL::Unique_hash_map VM; CGAL::Unique_hash_map EM; CGAL::Unique_hash_map LM; CGAL::Unique_hash_map FM; SVertex_const_iterator vc = D.svertices_begin(); SVertex_iterator v = svertices_begin(); for ( ; vc != D.svertices_end(); ++vc,++v) VM[vc] = v; VM[D.svertices_end()] = svertices_end(); SHalfedge_const_iterator ec = D.shalfedges_begin(); SHalfedge_iterator e = shalfedges_begin(); for ( ; ec != D.shalfedges_end(); ++ec,++e) { EM[ec] = e; e->mark() = ec->mark(); } EM[D.shalfedges_end()] = shalfedges_end(); SFace_const_iterator fc = D.sfaces_begin(); SFace_iterator f = sfaces_begin(); for ( ; fc != D.sfaces_end(); ++fc,++f) FM[fc] = f; FM[D.sfaces_end()] = sfaces_end(); SHalfloop_iterator l; if ( D.shalfloop_ != 0 ) { LM[D.shalfloop_] = shalfloop_; LM[D.shalfloop_->twin()] = shalfloop_->twin(); l = shalfloop(); shalfloop_->mark() = D.shalfloop()->mark(); shalfloop_->twin()->mark() = D.shalfloop()->twin()->mark(); if( !l->is_twin() && D.shalfloop()->is_twin()) l->mark() = l->twin()->mark(); } for (v = svertices_begin(); v != svertices_end(); ++v) { // Local Graph update: (SVertices are postponed/updated as Edges) v->out_sedge() = EM[v->out_sedge()]; v->incident_sface() = FM[v->incident_sface()]; } // Edge update: for (e = shalfedges_begin(); e != shalfedges_end(); ++e) { e->twin() = EM[e->twin()]; e->sprev() = EM[e->sprev()]; e->snext() = EM[e->snext()]; e->source() = VM[e->source()]; e->incident_sface() = FM[e->incident_sface()]; } for ( ec = D.shalfedges_begin(), e = shalfedges_begin(); ec != D.shalfedges_end(); ++ec, ++e) { if( !e->is_twin() && ec->is_twin()) e->mark() = e->twin()->mark(); } for (l = shalfloops_begin(); l != shalfloops_end(); ++l) { // l->twin() = LM[l->twin()]; l->incident_sface() = FM[l->incident_sface()]; } for (f = sfaces_begin(); f != sfaces_end(); ++f) { SFace_cycle_iterator fci; for(fci = f->boundary_entry_objects().begin(); fci != f->boundary_entry_objects().end(); ++fci) { if ( fci.is_svertex() ) { v = SVertex_handle(fci); *fci = Object_handle(VM[v]); store_sm_boundary_item(v,fci); } else if ( fci.is_shalfedge() ) { e = SHalfedge_handle(fci); *fci = Object_handle(EM[e]); store_sm_boundary_item(e,fci); } else if ( fci.is_shalfloop() ) { l = SHalfloop_handle(fci); *fci = Object_handle(LM[l]); store_sm_boundary_item(l,fci); } else CGAL_assertion_msg(0,"damn wrong boundary item in face."); } } } template typename Sphere_map::Object_iterator Sphere_map::undef_; CGAL_END_NAMESPACE #endif // CGAL_SPHERE_MAP_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/leda_sphere_map.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/leda_sphere_map0000644000175000017500000001774511344301501031146 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_S2/leda_sphere_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef LEDA_SPHERE_MAP_H #define LEDA_SPHERE_MAP_H #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 211 #include template class leda_graph_decorator { public: typedef leda_node Vertex_handle; typedef leda_edge Halfedge_handle; typedef CGAL::Sphere_point Point_2; typedef CGAL::Sphere_segment Segment_2; typedef GRAPH< Point_2, Segment_2 > Graph; typedef leda_node_map Below_map; Graph& G; Below_map& M; leda_graph_decorator(Graph& Gi, Below_map& Mi) : G(Gi), M(Mi) {} Vertex_handle new_vertex(const Point_2& p) { return G.new_node(p); } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) { Halfedge_handle erev = G.reversal(e); G.move_edge(e,G.cyclic_adj_pred(e,G.source(e)),v); G.move_edge(erev,v,G.target(erev)); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) { Halfedge_handle e_res,e_rev, e_first = G.first_adj_edge(v); if ( e_first == nil ) { e_res = G.new_edge(v,v); e_rev = G.new_edge(v,v); } else { e_res = G.new_edge(e_first,v,LEDA::before); e_rev = G.new_edge(e_first,v,LEDA::before); } G.set_reversal(e_res,e_rev); return e_res; } void supporting_segment(Halfedge_handle e, ITERATOR it) { G[e] = *it; } void halfedge_below(Vertex_handle v, Halfedge_handle e) { M[v] = e; } void trivial_segment(Vertex_handle v, ITERATOR it) {} void starting_segment(Vertex_handle v, ITERATOR it) {} void passing_segment(Vertex_handle v, ITERATOR it) {} void ending_segment(Vertex_handle v, ITERATOR it) {} }; // leda_graph_decorator template class leda_sphere_map_overlayer { typedef std::pair edge_pair; typedef CGAL::Sphere_point SPoint_2; typedef CGAL::Sphere_segment SSegment_2; typedef CGAL::Plane_3 Plane_3; typedef GRAPH Sphere_map; Sphere_map G; leda_node_map E; public: leda_sphere_map_overlayer() : G(),E(G) {} const Sphere_map& sphere_map() const { return G; } template void subdivide(Iterator start, Iterator end) /* subdivision is done in phases - first we partition all segments into the pieces in the closed postive xy-halfspace and into the pieces in the negative xy-halfspace - we sweep both halfspheres separate. Note that the boundary carries the same topology - we unify the graphs embedded into both halfspheres at the boundary. */ { typedef leda_graph_decorator leda_graph_output; typedef CGAL::Positive_halfsphere_geometry PH_geometry; typedef CGAL::Segment_overlay_traits< Iterator, leda_graph_output, PH_geometry> PHS_traits; typedef CGAL::generic_sweep Positive_halfsphere_sweep; typedef CGAL::Negative_halfsphere_geometry NH_geometry; typedef CGAL::Segment_overlay_traits< Iterator, leda_graph_output, NH_geometry> NHS_traits; typedef CGAL::generic_sweep Negative_halfsphere_sweep; std::list Lp,Lm; partition_xy( start, end, Lp , +1); partition_xy( start, end, Lm , -1); // both lists initialized with four quarter segments // supporting the xy-equator thereby separating the // two halfspheres // all other segments in the range are split into their // connected components with respect to the xy-plane. leda_node v1,v2; leda_graph_output O(G,E); typedef typename PHS_traits::INPUT Input_range; Positive_halfsphere_sweep SP(Input_range(Lp.begin(),Lp.end()),O); SP.sweep(); CGAL_NEF_TRACEN("POS SWEEP\n"<<(dump(std::cerr),"")); v1=G.first_node(); v2=G.last_node(); Negative_halfsphere_sweep SM(Input_range(Lm.begin(),Lm.end()),O); SM.sweep(); CGAL_NEF_TRACEN("NEG SWEEP\n"<<(dump(std::cerr),"")); v2 = G.succ_node(v2); // now two CCs of sphere graph calculated // v1 = first node of CC in positive xy-sphere // v2 = first node of CC in negative xy-sphere merging_halfspheres(v1,v2); clean_trivial_sface_cycles(); if (!Is_Plane_Map(G)) error_handler(1,"Sphere map: embedding wrong."); compute_faces(); } void merge_nodes(leda_edge e1, leda_edge e2) // e1 and e2 are two edges of the xy equator such that // e1 is part of the positive xy-sphere bounding outer face // e2 is part of the negative xy-sphere bounding outer face // e1 and e2 are oppositely oriented // the outer faces are left of the edges // the edges are embedded orderpreserving ccw // then the following code merges the edges of A(target(e2)) // to A(source(e1)) preserving the embedding // afterwards source(e1) carries all edges, target(e2) is isolated { leda_node v = source(e1); leda_edge e_pos = e1; leda_edge e = G.reversal(e2), er = e2; leda_edge e_end = e; do { leda_edge e_next = G.cyclic_adj_succ(e); G.move_edge(e,e_pos,target(e)); G.move_edge(er,er,v); e_pos = e; e = e_next; er = G.reversal(e); } while ( e != e_end ); } void merging_halfspheres(leda_node v1, leda_node v2) // v1 and v2 are the definite nodes of both CCs // where the negative y-axis pierces the sphere. // the faces are left of edges // edges are embedded orderpreserving ccw { CGAL_NEF_TRACEN("Merging Halfspheres"); leda_edge e1,e2,e3,e4,e1n,e2n; forall_sadj_edges(e1,v1) if ( G[target(e1)].hz()==0 && G[target(e1)].hx()<0 ) break; forall_sadj_edges(e2,v2) if ( G[target(e2)].hz()==0 && G[target(e2)].hx()>0 ) break; e3 = G.face_cycle_pred(e1); e4 = e2; e2 = G.face_cycle_pred(e2); while ( e1 != e3 || e2 != e4 ) { CGAL_NEF_TRACEN(G[source(e1)]<<" "<< G[target(e2)]); e1n = G.face_cycle_succ(e1); e2n = G.face_cycle_pred(e2); merge_nodes(e1,e2); e1 = e1n; e2 = e2n; } } void clean_trivial_sface_cycles() // removes trivial face cycles at equator // removes isolated vertices stemming from // equator unification { leda_edge_map known(G,false); leda_list L; leda_list Lr; leda_edge e; forall_sedges(e,G) { if (known[e]) continue; leda_edge en = G.face_cycle_succ(e); if ( G.face_cycle_succ(en) != e ) continue; // e in trivial face cycle L.append(e); L.append(en); CGAL_NEF_TRACEN("tivial cycle "<"; dump(os,target(e),false); os <<" ["< #endif //LEDA_SPHERE_MAP_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_2_mine.h0000644000175000017500000000000011344301501031217 0ustar debiandebian././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarch0000644000175000017500000000451511344301501031436 0ustar debiandebian// Copyright (c) 1998 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Olivier Devillers // Mariette Yvinec #ifndef CGAL_TRIANGULATION_HIERARCHY_VERTEX_BASE_2_H #define CGAL_TRIANGULATION_HIERARCHY_VERTEX_BASE_2_H #include #include CGAL_BEGIN_NAMESPACE template < class Vbb> class Triangulation_hierarchy_vertex_base_2 : public Vbb { typedef Vbb Base; typedef typename Base::Triangulation_data_structure Tds; public: typedef typename Base::Point Point; typedef Tds Triangulation_data_structure; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Face_handle Face_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Vbb::template Rebind_TDS::Other Vb2; typedef Triangulation_hierarchy_vertex_base_2 Other; }; Triangulation_hierarchy_vertex_base_2() : Base(), _up(0), _down(0) {} Triangulation_hierarchy_vertex_base_2(const Point & p, Face_handle f) : Base(p,f), _up(0), _down(0) {} Triangulation_hierarchy_vertex_base_2(const Point & p) : Base(p), _up(0), _down(0) {} Vertex_handle up() {return _up;} Vertex_handle down() {return _down;} void set_up(Vertex_handle u) {_up=u;} void set_down(Vertex_handle d) { _down=d;} private: Vertex_handle _up; // same vertex one level above Vertex_handle _down; // same vertex one level below }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_HIERARCHY_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pierce_rectangles_2_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pierce_rectangles_2_tr0000644000175000017500000000307011344301500031307 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pierce_rectangles_2_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_PIERCE_RECTANGLES_2_TRAITS_H) #define CGAL_PIERCE_RECTANGLES_2_TRAITS_H 1 #include CGAL_BEGIN_NAMESPACE template < class R_ > struct Piercing_traits_cartesian { // types typedef R_ R; typedef typename R::FT FT; typedef Point_2< R > Point_2; // constructions typedef Infinity_distance_2< R > Infinity_distance_2; // get object methods: Infinity_distance_2 get_infinity_distance_2() const { return Infinity_distance_2(); } }; // Piercing_traits_cartesian CGAL_END_NAMESPACE #endif // ! (CGAL_PIERCE_RECTANGLES_2_TRAITS_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Tetrahedron_3.h0000644000175000017500000000452711344301501027703 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Tetrahedron_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_TETRAHEDRON_3_H #define CGAL_TETRAHEDRON_3_H CGAL_BEGIN_NAMESPACE template class Tetrahedron_3 : public R_::Kernel_base::Tetrahedron_3 { typedef typename R_::Point_3 Point_3; typedef typename R_::Kernel_base::Tetrahedron_3 RTetrahedron_3; public: typedef R_ R; Tetrahedron_3() {} Tetrahedron_3(const RTetrahedron_3& t) : RTetrahedron_3(t) {} Tetrahedron_3(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) : RTetrahedron_3(p,q,r,s) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_TETRAHEDRON_3 template < class R > std::ostream& operator<<(std::ostream& os, const Tetrahedron_3& t) { typedef typename R::Kernel_base::Tetrahedron_3 RTetrahedron_3; return os << static_cast(t); } #endif // CGAL_NO_OSTREAM_INSERT_TETRAHEDRON_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_TETRAHEDRON_3 template < class R > std::istream& operator>>(std::istream& is, Tetrahedron_3& t) { typedef typename R::Kernel_base::Tetrahedron_3 RTetrahedron_3; return is >> static_cast(t); } #endif // CGAL_NO_ISTREAM_EXTRACT_TETRAHEDRON_3 CGAL_END_NAMESPACE #endif // CGAL_TETRAHEDRON_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Direction_3.h0000644000175000017500000000522111344301500027333 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Direction_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_DIRECTION_3_H #define CGAL_DIRECTION_3_H CGAL_BEGIN_NAMESPACE template class Direction_3 : public R_::Kernel_base::Direction_3 { typedef typename R_::RT RT; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Kernel_base::Direction_3 RDirection_3; public: typedef R_ R; Direction_3() {} Direction_3(const RDirection_3& d) : RDirection_3(d) {} Direction_3(const Vector_3& v) : RDirection_3(v) {} Direction_3(const Line_3& l) : RDirection_3(l) {} Direction_3(const Ray_3& r) : RDirection_3(r) {} Direction_3(const Segment_3& s) : RDirection_3(s) {} Direction_3(const RT& hx, const RT& hy, const RT& hz) : RDirection_3(hx, hy, hz) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_DIRECTION_3 template < class R > std::ostream& operator<<(std::ostream& os, const Direction_3& d) { typedef typename R::Kernel_base::Direction_3 RDirection_3; return os << static_cast(d); } #endif // CGAL_NO_OSTREAM_INSERT_DIRECTION_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_DIRECTION_3 template < class R > std::istream& operator>>(std::istream& is, Direction_3& p) { typedef typename R::Kernel_base::Direction_3 RDirection_3; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_DIRECTION_3 CGAL_END_NAMESPACE #endif // CGAL_DIRECTION_3_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interpolation_gradient_fitting_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interpolation_gradient0000644000175000017500000001112511344301500031447 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Interpolation_gradient_fitting_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_INTERPOLATION_GRADIENT_FITTING_TRAITS_2_H #define CGAL_INTERPOLATION_GRADIENT_FITTING_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Interpolation_gradient_fitting_traits_2 //-----------------------------------------------------------------------// // The class meets the requirement of the concept InterpolationTraits2 // and GradientFittingTraits2: it defines the geometric // operations used by the interpolation methods and the gradient // fitting function. template class Construct_sum_matrix_2 { public: typedef Aff_2 Aff_transformation_2; Aff_transformation_2 operator()(const Aff_transformation_2& tr1, const Aff_transformation_2& tr2) const { return Aff_transformation_2(tr1.m(0,0) + tr2.m(0,0), tr1.m(0,1) + tr2.m(0,1), tr1.m(0,2) + tr2.m(0,2), tr1.m(1,0) + tr2.m(1,0), tr1.m(1,1) + tr2.m(1,1), tr1.m(1,2) + tr2.m(1,2)); } }; template class Construct_null_matrix_2 { public: typedef Aff_2 Aff_transformation_2; Aff_transformation_2 operator()() const { return Aff_transformation_2(0,0,0,0,0,0); } }; template class Construct_scaling_matrix_2 { public: typedef Aff_2 Aff_transformation_2; Aff_transformation_2 operator()(const typename Aff_transformation_2::R::FT & scale) const { return Aff_transformation_2(SCALING, scale); } }; template < class R > class Construct_outer_product_2 { public: typedef typename R::Aff_transformation_2 Aff_transformation_2; typedef typename R::Vector_2 Vector_2; Aff_transformation_2 operator()(const Vector_2& v) const { return Aff_transformation_2(v.x()*v.x(),v.x()*v.y(),v.x()*v.y(), v.y()*v.y()); } }; template class Interpolation_gradient_fitting_traits_2 { public: typedef R Rep; typedef typename Rep::FT FT; typedef typename Rep::Point_2 Point_d; typedef typename Rep::Vector_2 Vector_d; typedef typename Rep::Construct_vector_2 Construct_vector_d; typedef typename Rep::Construct_scaled_vector_2 Construct_scaled_vector_d; //only one not needed by gradient fitting: typedef typename Rep::Compute_squared_distance_2 Compute_squared_distance_d; //additional types for gradient computation: typedef typename Rep::Aff_transformation_2 Aff_transformation_d; typedef Construct_null_matrix_2 Construct_null_matrix_d; typedef Construct_scaling_matrix_2 Construct_scaling_matrix_d; typedef Construct_sum_matrix_2 Construct_sum_matrix_d; typedef Construct_outer_product_2 Construct_outer_product_d; Construct_outer_product_d construct_outer_product_d_object() const {return Construct_outer_product_d();} Construct_sum_matrix_d construct_sum_matrix_d_object() const {return Construct_sum_matrix_d();} Construct_scaling_matrix_d construct_scaling_matrix_d_object() const {return Construct_scaling_matrix_d();} Construct_null_matrix_d construct_null_matrix_d_object() const {return Construct_null_matrix_d();} //also in the traits without gradient computation: Construct_scaled_vector_d construct_scaled_vector_d_object()const {return Construct_scaled_vector_d();} Construct_vector_d construct_vector_d_object()const {return Construct_vector_d();} Compute_squared_distance_d compute_squared_distance_d_object()const {return Compute_squared_distance_d();} }; CGAL_END_NAMESPACE #endif // CGAL_INTERPOLATION_GRADIENT_FITTING_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Rotation_tree_2.C0000644000175000017500000000744711344301500030177 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Rotation_tree_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #include namespace CGAL { // makes *p the rightmost child of *q template void Rotation_tree_2::set_rightmost_child(Self_iterator p, Self_iterator q) { CGAL_assertion(q != this->end()); if (p != this->end()) { (*p).clear_right_sibling(); if (rightmost_child(q) != this->end()) { (*p).set_left_sibling(rightmost_child(q)); (*rightmost_child(q)).set_right_sibling(p); } else (*p).clear_left_sibling(); (*p).set_parent(q); (*q).set_rightmost_child(p); } else { (*q).clear_rightmost_child(); } } // makes *p the left sibling of *q template void Rotation_tree_2::set_left_sibling(Self_iterator p, Self_iterator q) { if (q == this->end()) return; if (p != this->end()) { if (left_sibling(q) != this->end()) { (*left_sibling(q)).set_right_sibling(p); (*p).set_left_sibling(left_sibling(q)); } else (*p).clear_left_sibling(); (*q).set_left_sibling(p); (*p).set_right_sibling(q); set_parent(parent(q),p); } else { if (left_sibling(q) != this->end()) (*(*q).left_sibling()).clear_right_sibling(); (*q).clear_left_sibling(); } } // makes p the right sibling of q template void Rotation_tree_2::set_right_sibling(Self_iterator p, Self_iterator q) { if (q == this->end()) return; if (p != this->end()) { if (right_sibling(q) != this->end()) { (*right_sibling(q)).set_left_sibling(p); (*p).set_right_sibling(right_sibling(q)); } else (*p).clear_right_sibling(); (*q).set_right_sibling(p); (*p).set_left_sibling(q); set_parent(parent(q),p); } else { if (right_sibling(q) != this->end()) (*right_sibling(q)).clear_left_sibling(); (*q).clear_right_sibling(); } } // NOTE: this function does not actually remove the node p from the // list; it only reorganizes the pointers so this node is not // in the tree structure anymore template void Rotation_tree_2::erase(Self_iterator p) { CGAL_assertion((*p).is_a_leaf()); Self_iterator s; s = right_sibling(p); if (s != this->end()) set_left_sibling(left_sibling(p),s); s = left_sibling(p); if (s != this->end()) set_right_sibling(right_sibling(p),s); s = parent(p); // if p was the rightmost child of its parent, then set its left // sibling as the new rightmost child if (rightmost_child(s) == p) set_rightmost_child(left_sibling(p),s); } template std::ostream& operator<<(std::ostream& os, const Rotation_tree_2& tree) { typename Rotation_tree_2::const_iterator it; for (it = tree.begin(); it != tree.end(); it++) os << *it << " " << std::endl; return os; } } ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_adapterH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_adapterH20000644000175000017500000002402511344301500031125 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_adapterH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_CIRCLE_2_ADAPTERH2_H #define CGAL_MIN_CIRCLE_2_ADAPTERH2_H // includes #ifndef CGAL_OPTIMISATION_BASIC_H # include #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_circle_2; template < class PT_, class DA_ > class Min_circle_2_adapterH2; template < class PT_, class DA_ > class _Min_circle_2_adapterH2__Circle; // Class interface and implementation // ================================== template < class PT_, class DA_ > class Min_circle_2_adapterH2 { public: // types typedef PT_ PT; typedef DA_ DA; // nested types typedef PT Point; typedef CGAL::_Min_circle_2_adapterH2__Circle Circle; private: DA dao; // data accessor object Circle circle; // current circle friend class CGAL::Min_circle_2< CGAL::Min_circle_2_adapterH2 >; public: // creation Min_circle_2_adapterH2( const DA& da = DA()) : dao( da), circle( da) { } // operations CGAL::Orientation orientation( const Point& p, const Point& q, const Point& r) const { typedef typename DA_::RT RT; RT phx; RT phy; RT phw; RT qhx; RT qhy; RT qhw; RT rhx; RT rhy; RT rhw; dao.get( p, phx, phy, phw); dao.get( q, qhx, qhy, qhw); dao.get( r, rhx, rhy, rhw); return( static_cast< CGAL::Orientation>( CGAL_NTS sign( ( phx*rhw - rhx*phw) * ( qhy*rhw - rhy*qhw) - ( phy*rhw - rhy*phw) * ( qhx*rhw - rhx*qhw)))); } }; // Nested type `Circle' template < class PT_, class DA_ > std::ostream& operator << ( std::ostream&, const CGAL::_Min_circle_2_adapterH2__Circle&); template < class PT_, class DA_ > std::istream& operator >> ( std::istream&, CGAL::_Min_circle_2_adapterH2__Circle&); template < class PT_, class DA_ > class _Min_circle_2_adapterH2__Circle { public: // typedefs typedef PT_ PT; typedef DA_ DA; typedef typename DA_::RT RT; typedef CGAL::Quotient FT; private: // data members DA dao; // data accessor object RT center_hx; // center's hx-coordinate RT center_hy; // center's hy-coordinate RT center_hw; // center's hw-coordinate FT sqr_rad; // squared radius // private member functions FT sqr_dist( const RT& phx, const RT& phy, const RT& phw, const RT& qhx, const RT& qhy, const RT& qhw) const { RT dhx( phx*qhw - qhx*phw); RT dhy( phy*qhw - qhy*phw); RT dhw( phw*qhw); return( FT( dhx*dhx + dhy*dhy, dhw*dhw)); } friend std::ostream& operator << <> ( std::ostream&, const CGAL::_Min_circle_2_adapterH2__Circle&); friend std::istream& operator >> <> ( std::istream&, CGAL::_Min_circle_2_adapterH2__Circle&); public: // types typedef PT Point; typedef FT Distance; // creation _Min_circle_2_adapterH2__Circle( const DA& da) : dao( da) { } void set( ) { center_hx = RT( 0); center_hy = RT( 0); center_hw = RT( 1); sqr_rad = -FT( 1); } void set( const Point& p) { dao.get( p, center_hx, center_hy, center_hw); sqr_rad = FT( 0); } void set( const Point& p, const Point& q) { RT phx; RT phy; RT phw; RT qhx; RT qhy; RT qhw; dao.get( p, phx, phy, phw); dao.get( q, qhx, qhy, qhw); center_hx = ( phx*qhw + qhx*phw); center_hy = ( phy*qhw + qhy*phw); center_hw = ( phw*qhw * RT( 2)); sqr_rad = sqr_dist( phx, phy, phw, center_hx, center_hy, center_hw); } void set( const Point& p, const Point& q, const Point& r) { RT phx; RT phy; RT phw; RT qhx; RT qhy; RT qhw; RT rhx; RT rhy; RT rhw; dao.get( p, phx, phy, phw); dao.get( q, qhx, qhy, qhw); dao.get( r, rhx, rhy, rhw); RT qhx_phx( qhx*phw - phx*qhw); RT qhy_phy( qhy*phw - phy*qhw); // denominator: qhw*phw RT rhx_phx( rhx*phw - phx*rhw); RT rhy_phy( rhy*phw - phy*rhw); // denominator: rhw*phw RT phw2( phw*phw); RT qhw2( qhw*qhw); RT rhw2( rhw*rhw); RT p2( phx*phx + phy*phy); // denominator: phw2 RT q2_p2( ( qhx*qhx + qhy*qhy) * phw2 - p2 * qhw2); // denominator: qhw2*phw2 RT r2_p2( ( rhx*rhx + rhy*rhy) * phw2 - p2 * rhw2); // denominator: rhw2*phw2 center_hx = q2_p2*rhy_phy * rhw - r2_p2*qhy_phy * qhw; center_hy = r2_p2*qhx_phx * qhw - q2_p2*rhx_phx * rhw; center_hw = ( qhx_phx*rhy_phy - rhx_phx*qhy_phy) * phw*qhw*rhw * RT( 2); sqr_rad = sqr_dist( phx, phy, phw, center_hx, center_hy, center_hw); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const { RT phx; RT phy; RT phw; dao.get( p, phx, phy, phw); return( CGAL::Bounded_side( CGAL_NTS sign( sqr_rad - sqr_dist( phx, phy, phw, center_hx, center_hy, center_hw)))); } bool has_on_bounded_side( const Point& p) const { RT phx; RT phy; RT phw; dao.get( p, phx, phy, phw); return( sqr_dist( phx, phy, phw, center_hx, center_hy, center_hw) < sqr_rad); } bool has_on_boundary( const Point& p) const { RT phx; RT phy; RT phw; dao.get( p, phx, phy, phw); return( sqr_dist( phx, phy, phw, center_hx, center_hy, center_hw) == sqr_rad); } bool has_on_unbounded_side( const Point& p) const { RT phx; RT phy; RT phw; dao.get( p, phx, phy, phw); return( sqr_rad < sqr_dist( phx, phy, phw, center_hx, center_hy, center_hw)); } bool is_empty( ) const { return( CGAL::is_negative( sqr_rad)); } bool is_degenerate( ) const { return( ! CGAL::is_positive( sqr_rad)); } // additional operations for checking bool operator == ( const CGAL::_Min_circle_2_adapterH2__Circle& c) const { return( ( center_hx*c.center_hw == c.center_hx*center_hw) && ( center_hy*c.center_hw == c.center_hy*center_hw) && ( sqr_rad == c.sqr_rad ) ); } bool operator != ( const CGAL::_Min_circle_2_adapterH2__Circle& c) const { return( ! ( *this == c)); } Point center( ) const { Point p; dao.set( p, center_hx, center_hy, center_hw); return( p); } const Distance& squared_radius( ) const { return( sqr_rad); } }; // I/O template < class PT_, class DA_ > std::ostream& operator << ( std::ostream& os, const CGAL::_Min_circle_2_adapterH2__Circle& c) { switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << "CGAL::Min_circle_2_adapterH2::Circle( " << c.center_hx << ", " << c.center_hy << ", " << c.center_hw << ", " << c.sqr_rad << ')'; break; case CGAL::IO::ASCII: os << c.center_hx << ' ' << c.center_hy << ' ' << c.center_hw << ' ' << c.sqr_rad; break; case CGAL::IO::BINARY: CGAL::write( os, c.center_hx); CGAL::write( os, c.center_hy); CGAL::write( os, c.center_hw); CGAL::write( os, c.sqr_rad); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } template < class PT_, class DA_ > std::istream& operator >> ( std::istream& is, CGAL::_Min_circle_2_adapterH2__Circle& c) { switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case CGAL::IO::ASCII: is >> c.center_hx >> c.center_hy >> c.center_hw >> c.sqr_rad; break; case CGAL::IO::BINARY: CGAL::read( is, c.center_hx); CGAL::read( is, c.center_hy); CGAL::read( is, c.center_hw); CGAL::read( is, c.sqr_rad); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE #endif // CGAL_MIN_CIRCLE_2_ADAPTERH2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_0000644000175000017500000000620411344301500031454 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_D_TRAITS_D_H #define CGAL_OPTIMISATION_D_TRAITS_D_H // includes #ifndef CGAL_OPTIMISATION_ACCESS_DIMENSION_D_H # include #endif #ifndef CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_D_H # include #endif #ifndef CGAL_OPTIMISATION_CONSTRUCT_POINT_D_H # include #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K_, class ET_ = typename K_::RT, class NT_ = typename K_::RT > class Optimisation_d_traits_d; // Class interface // =============== template < class K_, class ET_, class NT_> class Optimisation_d_traits_d { public: // self typedef K_ K; typedef ET_ ET; typedef NT_ NT; typedef Optimisation_d_traits_d Self; // types typedef typename K::Point_d Point_d; typedef typename K::Rep_tag Rep_tag; typedef typename K::RT RT; typedef typename K::FT FT; typedef CGAL::Access_dimension_d Access_dimension_d; typedef CGAL::Access_coordinates_begin_d Access_coordinates_begin_d; typedef CGAL::_Construct_point_d Construct_point_d; // creation Optimisation_d_traits_d( ) { } Optimisation_d_traits_d( const Optimisation_d_traits_d&) {} // operations Access_dimension_d access_dimension_d_object( ) const { return Access_dimension_d(); } Access_coordinates_begin_d access_coordinates_begin_d_object( ) const { return Access_coordinates_begin_d(); } Construct_point_d construct_point_d_object( ) const { return Construct_point_d(); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_D_TRAITS_D_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/polygon_function_objects.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/polygon_function_objec0000644000175000017500000000334611344301500031507 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/polygon_function_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef POLYGON_FUNCTION_OBJECTS_H #define POLYGON_FUNCTION_OBJECTS_H #include namespace CGAL { template class Is_vacuously_valid { public: Is_vacuously_valid(Traits ) {} template bool operator()(ForwardIterator, ForwardIterator) { return true; } }; template class Is_convex_2 { public: Is_convex_2(Traits t): traits(t) {} template bool operator()(ForwardIterator first, ForwardIterator last) { return is_convex_2(first, last, traits); } private: Traits traits; }; template class Is_y_monotone_2 { public: Is_y_monotone_2(Traits t): traits(t) {} template bool operator()(ForwardIterator first, ForwardIterator last) { return is_y_monotone_2(first, last, traits); } private: Traits traits; }; } #endif // POLYGON_FUNCTION_OBJECTS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/solve.h0000644000175000017500000000444711344301501026333 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/solve.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_SOLVE_H #define CGAL_SOLVE_H CGAL_BEGIN_NAMESPACE template void solve (const FT &a1, const FT &a2, const FT &a3, const FT &b1, const FT &b2, const FT &b3, const FT &c1, const FT &c2, const FT &c3, const FT &d1, const FT &d2, const FT &d3, FT &x, FT &y, FT &z) { FT denom = b2*c1*a3-b1*c2*a3+c3*b1*a2+b3*c2*a1-c1*b3*a2-b2*c3*a1; x = - (b2*c3*d1-b2*c1*d3+c1*b3*d2+b1*c2*d3-c3*b1*d2-b3*c2*d1)/denom; z = (b2*d1*a3-b2*a1*d3+b1*a2*d3-b1*d2*a3-d1*b3*a2+a1*b3*d2)/denom; y = (a2*c3*d1-a2*c1*d3-c2*d1*a3+c2*a1*d3+d2*c1*a3-d2*c3*a1)/denom; } // this is for a parabola c1, c2, c3 are equal to 1 template void solve_quadratic (const FT &a1, const FT &a2, const FT &a3, const FT &b1, const FT &b2, const FT &b3, const FT &d1, const FT &d2, const FT &d3, FT &x, FT &y, FT &z) { FT denom = b2*a3-b1*a3+b1*a2+b3*a1-b3*a2-b2*a1; x = - (b2*d1-b2*d3+b3*d2+b1*d3-b1*d2-b3*d1)/denom; z = (b2*d1*a3-b2*a1*d3+b1*a2*d3-b1*d2*a3-d1*b3*a2+a1*b3*d2)/denom; y = (a2*d1-a2*d3-d1*a3+a1*d3+d2*a3-d2*a1)/denom; } CGAL_END_NAMESPACE #endif // CGAL_SOLVE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Union_find.h0000644000175000017500000002106511344301501027266 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Union_find.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel , // Lutz Kettner #ifndef CGAL_UNION_FIND_H #define CGAL_UNION_FIND_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class UF_forward_iterator { PTR_ m_p; public: // should be private and Union_find<...> a friend. PTR_ ptr() const { return m_p; } typedef UF_forward_iterator Self; typedef V_ value_type; typedef R_ reference; typedef P_ pointer; typedef std::forward_iterator_tag iterator_category; UF_forward_iterator() : m_p(0) {} UF_forward_iterator(PTR_ p) : m_p(p) {} // Allows construction of const_iterator from iterator template UF_forward_iterator(const UF_forward_iterator& i) : m_p(i.ptr()) {} bool operator==( const Self& x) const { return m_p == x.m_p; } bool operator!=( const Self& x) const { return !(*this == x); } reference operator*() const { return m_p->value; } pointer operator->() const { return &(m_p->value); } Self& operator++() { CGAL_assertion(m_p); m_p = m_p->next; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; } // CGALi // Union-Find with path compression. // -------------------------------------------------------------------- // An instance of the data type Union_find is a partition of values of // type |T| into disjoint sets. The type |A| has to be a model of the // allocator concept as defined in the C++ standard. // Union_find is implemented with union by rank and path compression. // The running time for $m$ set operations on $n$ elements is // $O(n \alpha(m,n))$ where $\alpha(m,n)$ is the extremely slow // growing inverse of Ackermann's function. template class Union_find { struct Union_find_struct { typedef Union_find_struct* pointer; // friend class Union_find; mutable pointer up; pointer next; std::size_t size; T value; Union_find_struct( pointer n, const T& x) : up(0), next(n), size(1), value(x) {} }; public: typedef Union_find Self; typedef Union_find_struct* pointer; typedef const Union_find_struct* const_pointer; typedef T value_type; typedef CGALi::UF_forward_iterator< pointer, T, T&, T*> iterator; typedef iterator handle; typedef CGALi::UF_forward_iterator< const_pointer, T, const T&, const T*> const_iterator; typedef const_iterator const_handle; #ifdef _MSC_VER typedef CGAL_ALLOCATOR(Union_find_struct) allocator; #else typedef typename A::template rebind Rebind; typedef typename Rebind::other allocator; #endif private: pointer m_first; std::size_t sets; std::size_t values; allocator alloc; // Private decl. and no definition, thus no copy constructor // and no assignment for this class. Union_find(const Self&); Self& operator=(const Self&); pointer find( pointer p) const { CGAL_assertion(p); pointer r = p; while (r->up) r = r->up; // now r is the root; while (p->up) { pointer u = p->up; p->up = r; // path compression: assign root r as new parent p = u; // this would need the 'mutable' for the up field } // if we would have a const_pointer, see the cast return r; // in the fct. below. We keep the mutable as reminder. } const_pointer find( const_pointer p ) const { return find( const_cast(p)); } bool is_valid(const_handle v) const { return v != const_handle(0); } public: Union_find() : m_first(0), sets(0), values(0) {} ~Union_find() { clear(); } allocator get_allocator() const { return alloc; } std::size_t number_of_sets() const { return sets; } // returns the number of disjoint sets std::size_t size() const { return values; } // returns the number of values std::size_t bytes() const { // returns the memory consumed return values * sizeof(Union_find_struct) + sizeof( Self); } std::size_t size( const_handle p) const { return find(p).ptr()->size; } // returns the size of the set containing $p$ void clear(); // reinitializes to an empty partition handle make_set(const T& x); // creates a new singleton set containing |x| and returns a handle to it handle push_back(const T& x) { return make_set(x); } // same as |make_set(x)| template void insert( Forward_iterator first, Forward_iterator beyond) { // insert the range of values referenced by |[first,beyond)|. // Precond: value type of |Forward_iterator| is |T|. while (first != beyond) push_back(*first++); } handle find( handle p) const { return find(p.ptr()); } const_handle find( const_handle p ) const { // returns a canonical handle of the set that contains |p|, // i.e., |P.same_set(p,q)| iff |P.find(p)| and |P.find(q)| return // the same handle. Precond: |p| is a handle in the union find structure. return find(p.ptr()); } void unify_sets(handle p, handle q); // unites the sets of partition containing $p$ and $q$. // Precond: $p$ and $q$ are in the partition. bool same_set( const_handle p, const_handle q) const { // returns true iff $p$ and $q$ belong to the same set. // Precond: $p$ and $q$ are in the partition. return find(p) == find(q); } iterator begin() { return iterator(m_first); } iterator end() { return iterator(0); } const_iterator begin() const { return const_iterator(m_first); } const_iterator end() const { return const_iterator(0); } }; template typename Union_find::handle Union_find::make_set(const T& x) { pointer tmp = m_first; m_first = alloc.allocate(1); alloc.construct( m_first, Union_find_struct(tmp,x)); ++sets; ++values; return handle( m_first); } template void Union_find::clear() { while (m_first) { pointer tmp = m_first->next; alloc.destroy(m_first); alloc.deallocate(m_first,1); m_first = tmp; } sets = 0; values = 0; } template void Union_find::unify_sets( handle p, handle q) { CGAL_assertion( is_valid(p) && is_valid(q)); pointer pit = find( p.ptr()); pointer qit = find( q.ptr()); if (pit == qit) return; std::size_t sp = pit->size; std::size_t sq = qit->size; if (sp > sq) std::swap(pit,qit); // now sp <= sq pit->up = qit; // linking roots qit->size += pit->size; // updating size --sets; } CGAL_END_NAMESPACE #endif // CGAL_UNION_FIND_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/pierce_rectangles_2.h0000644000175000017500000010357711344301500031105 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/pierce_rectangles_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_PIERCE_RECTANGLES_2_H) #define CGAL_PIERCE_RECTANGLES_2_H 1 #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE //!!! STL-extensions template < class T > struct Wastebasket { typedef std::output_iterator_tag iterator_category; typedef Wastebasket< T > iterator; iterator operator=( const T&) { return *this; } iterator operator*() { return *this; } iterator operator++() { return *this; } iterator operator++( int) { return *this; } }; template < class Traits_ > struct Loc_domain { // --------------------------------------------- // types: typedef Traits_ Traits; typedef typename Traits::FT FT; typedef typename Traits::Point_2 Point_2; typedef std::vector< Point_2 > Container; typedef typename Container::iterator Iterator; typedef typename Container::const_iterator Citerator; typedef typename Container::reverse_iterator Riterator; typedef typename Container::const_reference Creference; typedef typename Container::size_type size_type; // --------------------------------------------- // creation: void update(int j, Citerator i) { CGAL_optimisation_precondition(j >= 0 && j < 4); if (j < 2) if (j == 0) { if (traits.less_x_2_object()(*i, minx)) minx = *i; if (traits.less_y_2_object()(*i, miny)) miny = *i; } else { if (traits.less_y_2_object()(*i, miny)) miny = *i; if (traits.less_x_2_object()(maxx, *i)) maxx = *i; } else if (j == 2) { if (traits.less_x_2_object()(maxx, *i)) maxx = *i; if (traits.less_y_2_object()(maxy, *i)) maxy = *i; } else { if (traits.less_y_2_object()(maxy, *i)) maxy = *i; if (traits.less_x_2_object()(*i, minx)) minx = *i; } } template < class InputIC > Loc_domain(InputIC b, InputIC e, Traits t) : pts(b, e), end_(pts.end()), minx(pts.front()), miny(pts.front()), maxx(pts.front()), maxy(pts.front()), traits(t) { CGAL_optimisation_precondition(b != e); Iterator i = pts.begin(); CGAL_optimisation_assertion(i != pts.end()); while (++i != pts.end()) { if (traits.less_x_2_object()(*i, minx)) minx = *i; if (traits.less_x_2_object()(maxx, *i)) maxx = *i; if (traits.less_y_2_object()(*i, miny)) miny = *i; if (traits.less_y_2_object()(maxy, *i)) maxy = *i; } } // --------------------------------------------- // access operations: Point_2 operator[](int i) const // return corner points (0 <-> bottom-left, 1 <-> bottom-right) { CGAL_optimisation_precondition(i >= 0 && i < 4); if (i == 0) return traits.construct_point_2_above_right_implicit_point_2_object()( minx, miny, r); else if (i == 1) return traits.construct_point_2_above_left_implicit_point_2_object()( maxx, miny, r); else if (i == 2) return traits.construct_point_2_below_left_implicit_point_2_object()( maxx, maxy, r); return traits.construct_point_2_below_right_implicit_point_2_object()( minx, maxy, r); } Point_2 extreme(int i) const // return extreme points (0 <-> left, 1 <-> bottom) { CGAL_optimisation_precondition(i >= 0 && i < 4); if (i > 1) return i == 2 ? maxx : maxy; return i == 0 ? minx : miny; } Point_2& extreme(int i) // return extreme points (0 <-> left, 1 <-> bottom) { CGAL_optimisation_precondition(i >= 0 && i < 4); if (i > 1) return i == 2 ? maxx : maxy; return i == 0 ? minx : miny; } Citerator begin() const { return pts.begin(); } Iterator begin() { return pts.begin(); } #ifndef _MSC_VER Citerator end() const { return end_; } #else // Yet another really great MSVC feature ... // without that static_cast to itself it does not compile :-) Citerator end() const { return static_cast(end_); } #endif Iterator& end() { return end_; } Iterator real_end() { return pts.end(); } bool empty() const { return begin() == end(); } size_type size() const { return end() - begin(); } Creference front() const { return pts.front(); } // --------------------------------------------- // check operation: void check() const { CGAL_optimisation_expensive_assertion_code( Iterator i = pts.begin(); do { CGAL_optimisation_assertion(!traits.less_x_2_object()(*i, minx)); CGAL_optimisation_assertion(!traits.less_x_2_object()(maxx, *i)); CGAL_optimisation_assertion(!traits.less_y_2_object()(*i, miny)); CGAL_optimisation_assertion(!traits.less_y_2_object()(maxy, *i)); } while (++i != end); ) } protected: // points container Container pts; // const iterator to past-the-end Iterator end_; public: // actual center radius FT r; // (copies of) elements with minimal/maximal x/y coordinate Point_2 minx, miny, maxx, maxy; // Traits class Traits traits; }; // class Loc_domain template < class Traits_ > struct Staircases : public Loc_domain< Traits_ > { typedef Traits_ Traits; typedef Loc_domain< Traits > Base; typedef typename Base::Container Container; typedef typename Base::Iterator Iterator; typedef typename Base::Citerator Citerator; typedef typename Base::Riterator Riterator; typedef typename Traits::Point_2 Point_2; typedef typename Traits::FT FT; typedef std::pair< Point_2, Point_2 > Intervall; template < class InputIC > Staircases(InputIC b, InputIC e, Traits t) : Base(b, e, t), sorted(this->pts), xgy(t.signed_x_distance_2_object()(this->maxx, this->minx) > t.signed_y_distance_2_object()(this->maxy, this->miny)) { #if defined(__sun) && defined(__SUNPRO_CC) // I get linker errors otherweise, the call from above // does not seem to suffice :-( { Base bb(b, e, t); } #endif // defined(__sun) && defined(__SUNPRO_CC) using std::sort; using std::find_if; Container& xsort = xgy ? sorted : this->pts; Container& ysort = xgy ? this->pts : sorted; // build top-left and bottom-right staircases sort(ysort.begin(), ysort.end(), this->traits.less_y_2_object()); // bottom-right Iterator i = ysort.begin(); do { brstc.push_back(*i++); i = find_if(i, ysort.end(), bind_1(this->traits.less_x_2_object(), brstc.back())); } while (i != ysort.end()); // top-left Riterator j = ysort.rbegin(); do { tlstc.push_back(*j++); j = find_if(j, ysort.rend(), bind_2(this->traits.less_x_2_object(), tlstc.back())); } while (j != ysort.rend()); // build left-bottom and right-top staircases sort(xsort.begin(), xsort.end(), this->traits.less_x_2_object()); // left-bottom i = xsort.begin(); do { lbstc.push_back(*i++); i = find_if(i, xsort.end(), bind_2(this->traits.less_y_2_object(), lbstc.back())); } while (i != xsort.end()); // right-top j = xsort.rbegin(); do { rtstc.push_back(*j++); j = find_if(j, xsort.rend(), bind_1(this->traits.less_y_2_object(), rtstc.back())); } while (j != xsort.rend()); } // Staircases(b, e, t) bool is_middle_empty() const { //!!! the "middle" point could be precomputed in advance Citerator i = this->pts.begin(); FT rr = FT(2) * this->r; do if (this->traits.signed_x_distance_2_object()(this->maxx, *i) > rr && this->traits.signed_x_distance_2_object()(*i, this->minx) > rr && this->traits.signed_y_distance_2_object()(*i, this->miny) > rr && this->traits.signed_y_distance_2_object()(this->maxy, *i) > rr) return false; while (++i != this->pts.end()); return true; } // is_middle() bool is_x_greater_y() const { return xgy; } Citerator tlstc_begin() const { return tlstc.begin(); } Citerator tlstc_end() const { return tlstc.end(); } Citerator lbstc_begin() const { return lbstc.begin(); } Citerator lbstc_end() const { return lbstc.end(); } Citerator brstc_begin() const { return brstc.begin(); } Citerator brstc_end() const { return brstc.end(); } Citerator rtstc_begin() const { return rtstc.begin(); } Citerator rtstc_end() const { return rtstc.end(); } Intervall top_intervall() const { Point_2 p = this->traits.construct_point_2_above_right_implicit_point_2_object()( this->minx, this->miny, FT(2) * this->r); Point_2 q = this->traits.construct_point_2_above_left_implicit_point_2_object()( this->maxx, this->miny, FT(2) * this->r); Citerator i = min_element_if( this->pts.begin(), this->pts.end(), this->traits.less_x_2_object(), compose_shared(std::logical_and< bool >(), bind_1(this->traits.less_x_2_object(), p), bind_1(this->traits.less_y_2_object(), p))); Citerator j = max_element_if( this->pts.begin(), this->pts.end(), this->traits.less_x_2_object(), compose_shared(std::logical_and< bool >(), bind_2(this->traits.less_x_2_object(), q), bind_1(this->traits.less_y_2_object(), q))); return Intervall(i == this->pts.end() ? this->maxx : *i, j == this->pts.end() ? this->minx : *j); } // top_intervall() Intervall bottom_intervall() const { Point_2 p = this->traits.construct_point_2_below_right_implicit_point_2_object()( this->minx, this->maxy, FT(2) * this->r); Point_2 q = this->traits.construct_point_2_below_left_implicit_point_2_object()( this->maxx, this->maxy, FT(2) * this->r); Citerator i = min_element_if( this->pts.begin(), this->pts.end(), this->traits.less_x_2_object(), compose_shared(std::logical_and< bool >(), bind_1(this->traits.less_x_2_object(), p), bind_2(this->traits.less_y_2_object(), p))); Citerator j = max_element_if( this->pts.begin(), this->pts.end(), this->traits.less_x_2_object(), compose_shared(std::logical_and< bool >(), bind_2(this->traits.less_x_2_object(), q), bind_2(this->traits.less_y_2_object(), q))); return Intervall(i == this->pts.end() ? this->maxx : *i, j == this->pts.end() ? this->minx : *j); } // bottom_intervall() Intervall left_intervall() const { Point_2 p = this->traits.construct_point_2_above_left_implicit_point_2_object()( this->maxx, this->miny, FT(2) * this->r); Point_2 q = this->traits.construct_point_2_below_left_implicit_point_2_object()( this->maxx, this->maxy, FT(2) * this->r); Citerator i = min_element_if( this->pts.begin(), this->pts.end(), this->traits.less_y_2_object(), compose_shared(std::logical_and< bool >(), bind_2(this->traits.less_x_2_object(), p), bind_1(this->traits.less_y_2_object(), p))); Citerator j = max_element_if( this->pts.begin(), this->pts.end(), this->traits.less_y_2_object(), compose_shared(std::logical_and< bool >(), bind_2(this->traits.less_x_2_object(), q), bind_2(this->traits.less_y_2_object(), q))); return Intervall(i == this->pts.end() ? this->maxy : *i, j == this->pts.end() ? this->miny : *j); } // left_intervall() Intervall right_intervall() const { Point_2 p = this->traits.construct_point_2_above_right_implicit_point_2_object()( this->minx, this->miny, FT(2) * this->r); Point_2 q = this->traits.construct_point_2_below_right_implicit_point_2_object()( this->minx, this->maxy, FT(2) * this->r); Citerator i = min_element_if( this->pts.begin(), this->pts.end(), this->traits.less_y_2_object(), compose_shared(std::logical_and< bool >(), bind_1(this->traits.less_x_2_object(), p), bind_1(this->traits.less_y_2_object(), p))); Citerator j = max_element_if( this->pts.begin(), this->pts.end(), this->traits.less_y_2_object(), compose_shared(std::logical_and< bool >(), bind_1(this->traits.less_x_2_object(), q), bind_2(this->traits.less_y_2_object(), q))); return Intervall(i == this->pts.end() ? this->maxy : *i, j == this->pts.end() ? this->miny : *j); } // right_intervall() template < class OutputIterator > OutputIterator shared_intervall(OutputIterator o) const { if (xgy) { if (this->traits.signed_y_distance_2_object()( this->maxy, this->miny) > FT(4) * this->r) return o; Point_2 p = this->traits.construct_point_2_below_right_implicit_point_2_object()( this->minx, this->maxy, FT(2) * this->r); Point_2 q = this->traits.construct_point_2_above_left_implicit_point_2_object()( this->maxx, this->miny, FT(2) * this->r); //!!! start with binary search for (Citerator i = sorted.begin(); i != sorted.end(); ++i) if (this->traits.less_x_2_object()(p, *i) && this->traits.less_x_2_object()(*i, q) && !this->traits.less_y_2_object()(*i, p) && !this->traits.less_y_2_object()(q, *i)) *o++ = *i; } else { if (this->traits.signed_x_distance_2_object()( this->maxx, this->minx) > FT(4) * this->r) return o; Point_2 p = this->traits.construct_point_2_above_left_implicit_point_2_object()( this->maxx, this->miny, FT(2) * this->r); Point_2 q = this->traits.construct_point_2_below_right_implicit_point_2_object()( this->minx, this->maxy, FT(2) * this->r); //!!! start with binary search for (Citerator i = sorted.begin(); i != sorted.end(); ++i) if (!this->traits.less_x_2_object()(*i, p) && !this->traits.less_x_2_object()(q, *i) && this->traits.less_y_2_object()(p, *i) && this->traits.less_y_2_object()(*i, q)) *o++ = *i; } return o; } // shared_intervall(o) private: Container tlstc, lbstc, brstc, rtstc, sorted; // exceeds the x-dimension of the location domain its y-dimension? bool xgy; }; CGAL_END_NAMESPACE //#ifdef CGAL_REP_CLASS_DEFINED //#include //#endif // CGAL_REP_CLASS_DEFINED CGAL_BEGIN_NAMESPACE template < class InputIC, class OutputIterator, class Traits > inline OutputIterator two_cover_points( InputIC f, InputIC l, OutputIterator o, bool& ok, const Traits& t) { CGAL_optimisation_precondition(f != l); // compute location domain: Loc_domain< Traits > d(f, l, t); return two_cover_points(d, o, ok, t); } // two_cover_points(f, l, o, ok, t) template < class InputIC, class OutputIterator, class Traits > inline OutputIterator three_cover_points( InputIC f, InputIC l, OutputIterator o, bool& ok, const Traits& t) { CGAL_optimisation_precondition(f != l); // compute location domain: Loc_domain< Traits > d(f, l, t); return three_cover_points(d, o, ok, t); } // three_cover_points(f, l, o, ok, t) template < class InputIC, class OutputIterator, class Traits > inline OutputIterator four_cover_points( InputIC f, InputIC l, OutputIterator o, bool& ok, const Traits& t) { CGAL_optimisation_precondition(f != l); // compute location domain: Loc_domain< Traits > d(f, l, t); return four_cover_points(d, o, ok, t); } // four_cover_points(f, l, o, ok, t) template < class OutputIterator, class Traits > OutputIterator two_cover_points( const Loc_domain< Traits >& d, OutputIterator o, bool& ok) { using std::find_if; using std::less; typedef typename Traits::FT FT; typedef typename Traits::Point_2 Point_2; typename Traits::Infinity_distance_2 dist = d.traits.infinity_distance_2_object(); typename Traits::Signed_infinity_distance_2 sdist = d.traits.signed_infinity_distance_2_object(); Min< FT > minft; less< FT > lessft; if (sdist(d[2], d[0]) <= FT(0)) { // the location domain is degenerate and [f,l) is one-pierceable *o++ = d[0]; ok = true; return o; } // check whether {d[0], d[2]} forms a piercing set if (d.end() == find_if(d.begin(), d.end(), compose( bind_1(lessft, d.r), compose_shared( minft, bind_1(dist, d[0]), bind_1(dist, d[2]))))) { *o++ = d[0]; *o++ = d[2]; ok = true; return o; } // check whether {d[1], d[3]} forms a piercing set if (d.end() == find_if(d.begin(), d.end(), compose( bind_1(lessft, d.r), compose_shared( minft, bind_1(dist, d[1]), bind_1(dist, d[3]))))) { *o++ = d[1]; *o++ = d[3]; ok = true; return o; } // no piercing set exists: ok = false; return o; } // two_cover_points(d, o, ok, t) template < class OutputIterator, class Traits > OutputIterator three_cover_points( Loc_domain< Traits >& d, OutputIterator o, bool& ok) { using std::find_if; using std::less; using std::iter_swap; CGAL_optimisation_precondition(!d.empty()); // typedefs: typedef typename Traits::FT FT; typedef typename Traits::Point_2 Point_2; typedef typename Loc_domain< Traits >::Iterator Iterator; typename Traits::Infinity_distance_2 dist = d.traits.infinity_distance_2_object(); less< FT > lessft; // test the four corners: for (int k = 0; k < 4; ++k) { // extract all points which are close enough to d[k] Point_2 corner = d[k]; // find first point not covered by the rectangle at d[k] Iterator i = find_if(d.begin(), d.end(), compose(bind_1(lessft, d.r), bind_1(dist, corner))); // are all points already covered? if (i == d.end()) { CGAL_optimisation_assertion(k == 0); *o++ = d[0]; ok = true; return o; } // if (i == d.end()) // save changing sides of d: Point_2 save_side1 = d.extreme(k); Point_2 save_side2 = d.extreme((k+1) % 4); Iterator save_end = d.end(); // now run through it: // initialize the two (possibly) changing sides of d d.extreme(k) = d.extreme((k+1) % 4) = *i; // is there any point covered? if (i == d.begin()) { while (++i != d.end() && dist(corner, *i) > d.r) d.update(k, i); d.end() = i; } else { // move *i to the begin of pts iter_swap(i, d.begin()); d.end() = d.begin() + 1; } // [d.begin(), d.end()) shall be the range of uncovered points if (i != save_end) while (++i != save_end) if (dist(corner, *i) > d.r) { d.update(k, i); iter_swap(i, d.end()); ++d.end(); } // if (dist(corner, *i) > d.r) // check disjoint for two-pierceability: CGAL_optimisation_expensive_assertion( save_end == find_if(d.end(), save_end, compose(bind_1(lessft, d.r), bind_1(dist, corner)))); CGAL_optimisation_expensive_assertion( d.end() == find_if(d.begin(), d.end(), compose(bind_1(std::greater_equal(), d.r), bind_1(dist, corner)))); two_cover_points(d, o, ok); // restore saved sides of d: d.extreme(k) = save_side1; d.extreme((k+1) % 4) = save_side2; if (ok) { // does any rectangle contain the corner? if (d.end() != save_end) { *o++ = corner; d.end() = save_end; } return o; } // if (ok) d.end() = save_end; } // for (int k = 0; k < 4; ++k) // no piercing set exists: ok = false; return o; } // three_cover_points(d, o, ok) CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class OutputIterator, class Traits > OutputIterator four_cover_points(Staircases< Traits >& d, OutputIterator o, bool& ok) { using std::less; using std::iter_swap; using std::find_if; using std::back_inserter; typedef typename Traits::Point_2 Point_2; typedef typename Traits::FT FT; typedef typename Traits::Less_x_2 Less_x_2; typedef typename Traits::Less_y_2 Less_y_2; typedef typename Traits::Signed_x_distance_2 Signed_x_distance_2; typedef typename Traits::Signed_y_distance_2 Signed_y_distance_2; typedef typename Traits::Infinity_distance_2 Infinity_distance_2; typedef typename Staircases< Traits >::Container Container; typedef typename Staircases< Traits >::Iterator Iterator; typedef typename Staircases< Traits >::Citerator Citerator; typedef typename Staircases< Traits >::Intervall Intervall; less< FT > lessft; Infinity_distance_2 dist = d.traits.infinity_distance_2_object(); Less_x_2 lessx = d.traits.less_x_2_object(); Less_y_2 lessy = d.traits.less_y_2_object(); Signed_x_distance_2 sdistx = d.traits.signed_x_distance_2_object(); Signed_y_distance_2 sdisty = d.traits.signed_y_distance_2_object(); typename Traits::Construct_point_2_above_right_implicit_point_2 cparip = d.traits.construct_point_2_above_right_implicit_point_2_object(); typename Traits::Construct_point_2_above_left_implicit_point_2 cpalip = d.traits.construct_point_2_above_left_implicit_point_2_object(); typename Traits::Construct_point_2_below_right_implicit_point_2 cpbrip = d.traits.construct_point_2_below_right_implicit_point_2_object(); // test the four corners: for (int j = 0; j < 5; ++j) { const int k = j < 4 ? j : 3; // extract all points which are close enough to this point Point_2 corner = d[k]; if (j >= 3) if (j == 3) { Citerator i = d.tlstc_begin(); while (sdistx(*i, d.minx) > FT(2) * d.r) ++i; corner = cpbrip(d.minx, *i, d.r); } else { Citerator i = d.tlstc_end(); while (sdisty(d.maxy, *--i) > FT(2) * d.r) {} corner = cpbrip(*i, d.maxy, d.r); } // find first point not covered by the rectangle at d[k] Iterator i = find_if(d.begin(), d.end(), compose(bind_1(lessft, d.r), bind_1(dist, corner))); // are all points already covered? if (i == d.end()) { CGAL_optimisation_assertion(k == 0); *o++ = d[0]; ok = true; return o; } // if (i == d.end()) // save changing sides of d: Point_2 save_side1 = d.extreme(k); Point_2 save_side2 = d.extreme((k+1) % 4); Iterator save_end = d.end(); // now run through it: // initialize the two (possibly) changing sides of d d.extreme(k) = d.extreme((k+1) % 4) = *i; // is there any point covered? if (i == d.begin()) { while (++i != d.end() && dist(corner, *i) > d.r) d.update(k, i); d.end() = i; } else { // move *i to the begin of pts iter_swap(i, d.begin()); d.end() = d.begin() + 1; } // [d.begin(), d.end()) shall be the range of uncovered points if (i != save_end) while (++i != save_end) if (dist(corner, *i) > d.r) { d.update(k, i); iter_swap(i, d.end()); ++d.end(); } // if (dist(corner, *i) > d.r) // check disjoint for two-pierceability: CGAL_optimisation_expensive_assertion( save_end == find_if(d.end(), save_end, compose(bind_1(lessft, d.r), bind_1(dist, corner)))); CGAL_optimisation_expensive_assertion( d.end() == find_if(d.begin(), d.end(), compose(bind_1(std::greater_equal(), d.r), bind_1(dist, corner)))); three_cover_points(d, o, ok); // restore saved sides of d: d.extreme(k) = save_side1; d.extreme((k+1) % 4) = save_side2; if (ok) { // does any rectangle contain the corner? if (d.end() != save_end) { *o++ = corner; d.end() = save_end; } return o; } // if (ok) d.end() = save_end; } // for (int k = 0; k < 4; ++k) // test if four covering rectangles can be placed // on the boundary of d, one on each side // if there is any point that cannot be covered in this way, stop here if (d.is_middle_empty()) { // now try to position the bottom piercing point in each // of the intervalls formed by S_bt and S_br // (no need to consider S_bl, since we move from left // to right and leaving a rectangle won't make piercing easier) Intervall top_i = d.top_intervall(); Intervall left_i = d.left_intervall(); Intervall bottom_i = d.bottom_intervall(); Intervall right_i = d.right_intervall(); Container share; d.shared_intervall(back_inserter(share)); Citerator shf = share.end(); Citerator shl = share.end(); Citerator tl = d.tlstc_begin(); Citerator lb = d.lbstc_begin(); Citerator br = d.brstc_begin(); Citerator rt = d.rtstc_begin(); // make sure the top intervall is covered (left endpoint) // (it might be that top_i.first determines the placement of // the top square) Point_2 top = top_i.first; if (lessx(top, *tl)) while (++tl != d.tlstc_end() && !lessx(*tl, top)) {} else top = *tl++; if (tl != d.tlstc_end()) { for (;;) { // make sure the top intervall is covered (right endpoint) if (sdistx(top_i.second, top) > FT(2) * d.r) break; // compute position of left square Point_2 left = lessy(left_i.second, *tl) ? *tl : left_i.second; // make sure the left intervall is covered if (sdisty(left, left_i.first) <= FT(2) * d.r) { // compute position of bottom square while (lb != d.lbstc_end() && sdisty(left, *lb) <= FT(2) * d.r) ++lb; // has the left square reached the bottom-left corner? if (lb == d.lbstc_end()) break; Point_2 bottom = lessx(bottom_i.first, *lb) ? bottom_i.first : *lb; // check the shared x-intervall if (!share.empty() && d.is_x_greater_y()) { // compute position of top in share #ifndef _MSC_VER while (shf != share.begin() && !lessx(*(shf - 1), top)) #else while (shf != Citerator(share.begin()) && !lessx(*(shf - 1), top)) #endif --shf; #ifndef _MSC_VER while (shl != share.begin() && #else while (shl != Citerator(share.begin()) && #endif sdistx(*(shl - 1), top) > FT(2) * d.r) --shl; // make sure shared intervall is covered (left endpoint) #ifndef _MSC_VER if ((shf != share.begin() || shl == share.end()) && lessx(share.front(), bottom)) bottom = share.front(); else if (shl != share.end() && lessx(*shl, bottom)) bottom = *shl; #else if ((shf != Citerator(share.begin()) || shl == Citerator(share.end())) && lessx(share.front(), bottom)) bottom = share.front(); else if (shl != Citerator(share.end()) && lessx(*shl, bottom)) bottom = *shl; #endif } // make sure the bottom and the shared intervall (right endpoint) // are covered #ifndef _MSC_VER if (sdistx(bottom_i.second, bottom) <= FT(2) * d.r && (!d.is_x_greater_y() || (shl == share.end() || sdistx(share.back(), bottom) <= FT(2) * d.r) && (shf == share.begin() || sdistx(*(shf - 1), bottom) <= FT(2) * d.r))) #else if (sdistx(bottom_i.second, bottom) <= FT(2) * d.r && (!d.is_x_greater_y() || (shl == Citerator(share.end()) || sdistx(share.back(), bottom) <= FT(2) * d.r) && (shf == Citerator(share.begin()) || sdistx(*(shf - 1), bottom) <= FT(2) * d.r))) #endif { // compute position of right square while (br != d.brstc_end() && sdistx(*br, bottom) <= FT(2) * d.r) ++br; // has the bottom square reached the bottom-right corner? if (br == d.brstc_end()) break; Point_2 right = lessy(right_i.first, *br) ? right_i.first : *br; // check the shared y-intervall if (!share.empty() && !d.is_x_greater_y()) { // compute position of left in share #ifndef _MSC_VER while (shf != share.begin() && sdisty(left, *(shf - 1)) <= FT(2) * d.r) #else while (shf != Citerator(share.begin()) && sdisty(left, *(shf - 1)) <= FT(2) * d.r) #endif --shf; #ifndef _MSC_VER while (shl != share.begin() && #else while (shl != Citerator(share.begin()) && #endif lessy(left, *(shl - 1))) --shl; // make sure shared intervall is covered (bottom endpoint) #ifndef _MSC_VER if ((shf != share.begin() || shl == share.end()) && lessy(share.front(), right)) right = share.front(); else if (shl != share.end() && lessy(*shl, right)) right = *shl; #else if ((shf != Citerator(share.begin()) || shl == Citerator(share.end())) && lessy(share.front(), right)) right = share.front(); else if (shl != Citerator(share.end()) && lessy(*shl, right)) right = *shl; #endif } // make sure the right intervall and the shared intervall // (top endpoint) are covered #ifndef _MSC_VER if (sdisty(right_i.second, right) <= FT(2) * d.r && (d.is_x_greater_y() || (shl == share.end() || sdisty(share.back(), right) <= FT(2) * d.r) && (shf == share.begin() || sdisty(*(shf - 1), right) <= FT(2) * d.r))) #else if (sdisty(right_i.second, right) <= FT(2) * d.r && (d.is_x_greater_y() || (shl == Citerator(share.end()) || sdisty(share.back(), right) <= FT(2) * d.r) && (shf == Citerator(share.begin()) || sdisty(*(shf - 1), right) <= FT(2) * d.r))) #endif { // compute right bound for top square while (rt != d.rtstc_end() && sdisty(*rt, right) <= FT(2) * d.r) ++rt; // has the right square reached the top-right corner? if (rt == d.rtstc_end()) break; // Finally: Do we have a covering? if (sdistx(*rt, top) <= FT(2) * d.r) { *o++ = cpbrip(d.minx, left, d.r); *o++ = cparip(bottom, d.miny, d.r); *o++ = cpalip(d.maxx, right, d.r); *o++ = cpbrip(top, d.maxy, d.r); ok = true; return o; } // if (covering) } // if (sdisty(right_i.second, right) <= FT(2) * d.r) } // if (bottom and shared intervall are covered) } // if (sdisty(left, left_i.first) <= FT(2) * d.r) top = *tl; if (!lessy(left_i.second, *tl) || ++tl == d.tlstc_end() || lessx(bottom_i.first, *lb) || lessy(right_i.first, *br)) break; } // for (;;) } // if (tl != d.tlstc_end()) } // if (!d.is_middle_empty()) ok = false; return o; } // four_cover_points(d, o, ok) struct Two_covering_algorithm { template < class Traits, class OutputIterator > OutputIterator operator()(Staircases< Traits >& d, OutputIterator o, bool& ok) const { return two_cover_points(d, o, ok); } }; // class Two_covering_algorithm struct Three_covering_algorithm { template < class Traits, class OutputIterator > OutputIterator operator()(Staircases< Traits >& d, OutputIterator o, bool& ok) const { return three_cover_points(d, o, ok); } }; // class Three_covering_algorithm struct Four_covering_algorithm { template < class Traits, class OutputIterator > OutputIterator operator()(Staircases< Traits >& d, OutputIterator o, bool& ok) const { return four_cover_points(d, o, ok); } }; // class Four_covering_algorithm CGAL_END_NAMESPACE #endif // ! (CGAL_PIERCE_RECTANGLES_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Triangle_3_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Triangle_3_0000644000175000017500000003221311344301501031142 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Triangle_3_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_3_TRIANGLE_3_DO_INTERSECT_H #define CGAL_TRIANGLE_3_TRIANGLE_3_DO_INTERSECT_H CGAL_BEGIN_NAMESPACE namespace CGALi { template bool _intersection_test_vertex(const typename K::Point_3 * p, const typename K::Point_3 * q, const typename K::Point_3 * r, const typename K::Point_3 * a, const typename K::Point_3 * b, const typename K::Point_3 * c, const K & k){ CGAL_kernel_precondition( k.coplanar_orientation_3_object() (*p,*q,*r) == POSITIVE); CGAL_kernel_precondition( k.coplanar_orientation_3_object() (*a,*b,*c) == POSITIVE); // Vertex p sees vertex c typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); if (coplanar_orientation(*c,*a,*q) != NEGATIVE) { if (coplanar_orientation(*c,*b,*q) != POSITIVE) { if (coplanar_orientation(*p,*a,*q) == POSITIVE) return coplanar_orientation(*p,*b,*q) != POSITIVE; return coplanar_orientation(*p,*a,*r) != NEGATIVE && coplanar_orientation(*q,*r,*a) != NEGATIVE; } if (coplanar_orientation(*p,*b,*q) != POSITIVE) return coplanar_orientation(*c,*b,*r) != POSITIVE && coplanar_orientation(*q,*r,*b) != NEGATIVE; return false; } if (coplanar_orientation(*c,*a,*r) != NEGATIVE) { //qr straddles (ac) if (coplanar_orientation(*q,*r,*c) != NEGATIVE) return (coplanar_orientation(*p,*a,*r) != NEGATIVE); return coplanar_orientation(*q,*r,*b) != NEGATIVE && coplanar_orientation(*c,*r,*b) != NEGATIVE; } return false; // ca separes } template bool _intersection_test_edge(const typename K::Point_3 * p, const typename K::Point_3 * q, const typename K::Point_3 * r, const typename K::Point_3 * a, const typename K::Point_3 * b, const typename K::Point_3 * c, const K & k){ CGAL_kernel_precondition( k.coplanar_orientation_3_object() (*p,*q,*r) == POSITIVE); CGAL_kernel_precondition( k.coplanar_orientation_3_object() (*a,*b,*c) == POSITIVE); // Vertex p sees edge ca typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); if (coplanar_orientation(*c,*a,*q) != NEGATIVE) { //pq straddles (ac) if (coplanar_orientation(*p,*a,*q) != NEGATIVE) return coplanar_orientation(*p,*q,*c) != NEGATIVE ; return coplanar_orientation(*q,*r,*a) != NEGATIVE && coplanar_orientation(*r,*p,*a) != NEGATIVE; } if (coplanar_orientation(*c,*a,*r) != NEGATIVE) { // pr and qr straddle line (pr) return coplanar_orientation(*p,*a,*r) != NEGATIVE && ( coplanar_orientation(*p,*r,*c) != NEGATIVE || coplanar_orientation(*q,*r,*c) != NEGATIVE ); } return false; //ac separes } template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t1, const typename CGAL_WRAP(K)::Triangle_3 &t2, const K & k) { CGAL_kernel_precondition( ! k.is_degenerate_3_object() (t1) ); CGAL_kernel_precondition( ! k.is_degenerate_3_object() (t2) ); typedef typename K::Point_3 Point_3; typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Orientation_3 orientation = k.orientation_3_object(); const Point_3 & p = vertex_on(t1,0); const Point_3 & q = vertex_on(t1,1); const Point_3 & r = vertex_on(t1,2); const Point_3 & a = vertex_on(t2,0); const Point_3 & b = vertex_on(t2,1); const Point_3 & c = vertex_on(t2,2); const Point_3 * s_min1; const Point_3 * t_min1; const Point_3 * s_max1; const Point_3 * t_max1; // Compute distance signs of p, q and r to the plane of triangle(a,b,c) const Orientation dp = orientation(a,b,c,p); const Orientation dq = orientation(a,b,c,q); const Orientation dr = orientation(a,b,c,r); switch ( dp ) { case POSITIVE: if ( dq == POSITIVE ) { if ( dr == POSITIVE) // pqr lies in the open positive halfspace induced by // the plane of triangle(a,b,c) return false; // r is isolated on the negative side of the plane s_min1 = &q ; t_min1 = &r ; s_max1 = &r ; t_max1 = &p; } else { if ( dr == POSITIVE) { // q is isolated on the negative side of the plane s_min1 = &p; t_min1 = &q; s_max1 = &q; t_max1 = &r; } else { // p is isolated on the positive side of the plane s_min1 = &p; t_min1 = &q; s_max1 = &r; t_max1 = &p; } } break; case NEGATIVE: if ( dq == NEGATIVE ) { if ( dr == NEGATIVE ) // pqr lies in the open negative halfspace induced by // the plane of triangle(a,b,c) return false; // r is isolated on the positive side of the plane s_min1 = &r; t_min1 = &p; s_max1 = &q; t_max1 = &r; } else { if ( dr == NEGATIVE ) { // q is isolated on the positive side of the plane s_min1 = &q; t_min1 = &r; s_max1 = &p; t_max1 = &q; } else { // p is isolated on the negative side of the plane s_min1 = &r; t_min1 = &p; s_max1 = &p; t_max1 = &q; } } break; case COPLANAR: switch ( dq ) { case POSITIVE: if ( dr == POSITIVE ) { // p is isolated on the negative side of the plane s_min1 = &r; t_min1 = &p; s_max1 = &p; t_max1 = &q; } else { // q is isolated on the positive side of the plane s_min1 = &q; t_min1 = &r; s_max1 = &p; t_max1 = &q; } break; case NEGATIVE: if ( dr == NEGATIVE ) { // p is isolated on the positive side of the plane s_min1 = &p; t_min1 = &q; s_max1 = &r; t_max1 = &p; } else { // q is isolated on the negative side of the plane s_min1 = &p; t_min1 = &q; s_max1 = &q; t_max1 = &r; } break; case COPLANAR: switch ( dr ) { case POSITIVE: // r is isolated on the positive side of the plane s_min1 = &r; t_min1 = &p; s_max1 = &q; t_max1 = &r; break; case NEGATIVE: // r is isolated on the negative side of the plane s_min1 = &q ; t_min1 = &r ; s_max1 = &r ; t_max1 = &p; break; case COPLANAR: return do_intersect_coplanar(t1,t2,k); default: // should not happen. CGAL_kernel_assertion(false); return false; } break; default: // should not happen. CGAL_kernel_assertion(false); return false; } break; default: // should not happen. CGAL_kernel_assertion(false); return false; } const Point_3 * s_min2; const Point_3 * t_min2; const Point_3 * s_max2; const Point_3 * t_max2; // Compute distance signs of a, b and c to the plane of triangle(p,q,r) const Orientation da = orientation(p,q,r,a); const Orientation db = orientation(p,q,r,b); const Orientation dc = orientation(p,q,r,c); switch ( da ) { case POSITIVE: if ( db == POSITIVE ) { if ( dc == POSITIVE) // abc lies in the open positive halfspace induced by // the plane of triangle(p,q,r) return false; // c is isolated on the negative side of the plane s_min2 = &b ; t_min2 = &c ; s_max2 = &c ; t_max2 = &a; } else { if ( dc == POSITIVE) { // b is isolated on the negative side of the plane s_min2 = &a; t_min2 = &b; s_max2 = &b; t_max2 = &c; } else { // a is isolated on the positive side of the plane s_min2 = &a; t_min2 = &b; s_max2 = &c; t_max2 = &a; } } break; case NEGATIVE: if ( db == NEGATIVE ) { if ( dc == NEGATIVE ) // abc lies in the open negative halfspace induced by // the plane of triangle(p,q,r) return false; // c is isolated on the positive side of the plane s_min2 = &c ; t_min2 = &a ; s_max2 = &b ; t_max2 = &c; } else { if ( dc == NEGATIVE ) { // b is isolated on the positive side of the plane s_min2 = &b ; t_min2 = &c ; s_max2 = &a ; t_max2 = &b; } else { // a is isolated on the negative side of the plane s_min2 = &c ; t_min2 = &a ; s_max2 = &a ; t_max2 = &b; } } break; case COPLANAR: switch ( db ) { case POSITIVE: if ( dc == POSITIVE ) { // a is isolated on the negative side of the plane s_min2 = &c ; t_min2 = &a ; s_max2 = &a ; t_max2 = &b; } else { // b is isolated on the positive side of the plane s_min2 = &b ; t_min2 = &c ; s_max2 = &a ; t_max2 = &b; } break; case NEGATIVE: if ( dc == NEGATIVE ) { // a is isolated on the positive side of the plane s_min2 = &a ; t_min2 = &b ; s_max2 = &c ; t_max2 = &a; } else { // b is isolated on the negative side of the plane s_min2 = &a ; t_min2 = &b ; s_max2 = &b ; t_max2 = &c; } break; case COPLANAR: switch ( dc ) { case POSITIVE: // c is isolated on the positive side of the plane s_min2 = &c ; t_min2 = &a ; s_max2 = &b ; t_max2 = &c; break; case NEGATIVE: // c is isolated on the negative side of the plane s_min2 = &b ; t_min2 = &c ; s_max2 = &c ; t_max2 = &a; break; case COPLANAR: // Supposed unreachable code // since the triangles are assumed to be non-flat return do_intersect_coplanar(t1,t2,k); default: // should not happen. CGAL_kernel_assertion(false); return false; } break; default: // should not happen. CGAL_kernel_assertion(false); return false; } break; default: // should not happen. CGAL_kernel_assertion(false); return false; } return orientation(*s_min1,*t_min1,*s_min2,*t_min2) != POSITIVE && orientation(*s_max1,*t_max1,*t_max2,*s_max2) != POSITIVE ; } template bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t1, const typename CGAL_WRAP(K)::Triangle_3 &t2, const K & k) { CGAL_kernel_precondition( ! k.is_degenerate_3_object() (t1) ); CGAL_kernel_precondition( ! k.is_degenerate_3_object() (t2) ); typedef typename K::Point_3 Point_3; typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); const Point_3 & P = vertex_on(t1,0); const Point_3 & Q = vertex_on(t1,1); const Point_3 & R = vertex_on(t1,2); const Point_3 & A = vertex_on(t2,0); const Point_3 & B = vertex_on(t2,1); const Point_3 & C = vertex_on(t2,2); const Point_3 * p = &P; const Point_3 * q = &Q; const Point_3 * r = &R; const Point_3 * a = &A; const Point_3 * b = &B; const Point_3 * c = &C; // First we ensure that both triangles are counterclockwise // oriented, t1 and t2 are supposed to be non flat. if ( coplanar_orientation(P,Q,R) == NEGATIVE ) { q = &R; r = &Q; } if ( coplanar_orientation(A,B,C) == NEGATIVE ) { b = &C; c = &B; } // Localization of p in the arrangement of the // lines supporting abc's edges if ( coplanar_orientation(*a,*b,*p) != NEGATIVE ) { if ( coplanar_orientation(*b,*c,*p) != NEGATIVE ) { if ( coplanar_orientation(*c,*a,*p) != NEGATIVE ) // p is inside triangle abc return true; // p sees ac return CGALi::_intersection_test_edge(p,q,r,a,b,c,k); } if ( coplanar_orientation(*c,*a,*p) != NEGATIVE )//p sees bc return CGALi::_intersection_test_edge(p,q,r,c,a,b,k); // p sees c return CGALi::_intersection_test_vertex(p,q,r,a,b,c,k); } if ( coplanar_orientation(*b,*c,*p) != NEGATIVE ) { if ( coplanar_orientation(*c,*a,*p) != NEGATIVE ) //p sees ab return CGALi::_intersection_test_edge(p,q,r,b,c,a,k); // p sees a return CGALi::_intersection_test_vertex(p,q,r,b,c,a,k); } // p sees b return CGALi::_intersection_test_vertex(p,q,r,c,a,b,k); } } // namespace CGALi template inline bool do_intersect(const Triangle_3 &t1, const Triangle_3 &t2) { return typename K::Do_intersect_3()(t1,t2); } template inline bool do_intersect_coplanar(const typename K::Triangle_3 &t1, const typename K::Triangle_3 &t2) { return CGALi::do_intersect_coplanar(t1,t2,K()); } CGAL_END_NAMESPACE #endif //CGAL_TRIANGLE_3_TRIANGLE_3_DO_INTERSECT_H ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_exact_constructions_kernel_with_sqrt.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_exact0000644000175000017500000000353511344301500031404 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_exact_constructions_kernel_with_sqrt.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas, Sylvain Pion #ifndef CGAL_EXACT_PREDICATES_EXACT_CONSTRUCTIONS_KERNEL_WITH_SQRT_H #define CGAL_EXACT_PREDICATES_EXACT_CONSTRUCTIONS_KERNEL_WITH_SQRT_H #include #ifdef CGAL_USE_LEDA # include #elif defined CGAL_USE_CORE # include #else # error "You need LEDA or CORE installed." #endif CGAL_BEGIN_NAMESPACE #ifdef CGAL_USE_LEDA typedef Simple_cartesian< leda_real > Exact_predicates_exact_constructions_kernel_with_sqrt; #elif defined CGAL_USE_CORE typedef Simple_cartesian< CORE::Expr > Exact_predicates_exact_constructions_kernel_with_sqrt; #endif CGAL_END_NAMESPACE #endif // CGAL_EXACT_PREDICATES_EXACT_CONSTRUCTIONS_KERNEL_WITH_SQRT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/LEDA_basic.h0000644000175000017500000000261611344301500027044 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/LEDA_basic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_LEDA_BASIC_H #define CGAL_LEDA_BASIC_H #ifdef CGAL_USE_LEDA // The following is needed for LEDA 4.4 due to min/max problems... # define LEDA_NO_MIN_MAX_TEMPL #include #ifdef LEDA_NAMESPACE # define CGAL_LEDA_SCOPE leda #else # define CGAL_LEDA_SCOPE #endif #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ConicCPA2.h0000644000175000017500000005136411344301500026643 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ConicCPA2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Bernd Gaertner, Sven Schoenherr #ifndef CGAL_CONICCPA2_H #define CGAL_CONICCPA2_H // includes #include #include CGAL_BEGIN_NAMESPACE template < class PT, class DA> class ConicCPA2; template < class PT, class DA> class _Min_ellipse_2_adapterC2__Ellipse; template < class _PT, class _DA> class ConicCPA2 { public: // types typedef _PT PT; typedef _DA DA; typedef typename _DA::FT FT; //private: //friend class Conic_2< CGAL::Cartesian >; friend class _Min_ellipse_2_adapterC2__Ellipse; DA dao; FT _r, _s, _t, _u, _v, _w; Conic_type type; CGAL::Orientation o; bool empty, trivial, degenerate; void set_linear_combination (const FT& a1, const ConicCPA2& c1, const FT& a2, const ConicCPA2& c2) { _r = a1 * c1.r() + a2 * c2.r(); _s = a1 * c1.s() + a2 * c2.s(); _t = a1 * c1.t() + a2 * c2.t(); _u = a1 * c1.u() + a2 * c2.u(); _v = a1 * c1.v() + a2 * c2.v(); _w = a1 * c1.w() + a2 * c2.w(); } static void set_two_linepairs (const PT& p1, const PT& p2, const PT& p3, const PT& p4, ConicCPA2& pair1, ConicCPA2& pair2) { FT x1, y1, x2, y2, x3, y3, x4, y4; const DA& da = pair1.da(); da.get (p1, x1, y1); da.get (p2, x2, y2); da.get (p3, x3, y3); da.get (p4, x4, y4); CGAL::Orientation side1_24 = (CGAL::Orientation)(CGAL_NTS sign (-x1*y4+x2*y4 +x4*y1-x2*y1 +x1*y2-x4*y2)), side3_24 = (CGAL::Orientation)(CGAL_NTS sign (-x3*y4+x2*y4 +x4*y3-x2*y3 +x3*y2-x4*y2)); if (side1_24 != side3_24) { // (counter)clockwise order pair1.set_linepair (p1, p2, p3, p4); pair2.set_linepair (p2, p3, p4, p1); } else { CGAL::Orientation side1_32 = (CGAL::Orientation)(CGAL_NTS sign (-x1*y2+x3*y2 +x2*y1-x3*y1 +x1*y3-x2*y3)); if (side1_32 != side3_24) { // p1, p2 need to be swapped pair1.set_linepair (p2, p1, p3, p4); pair2.set_linepair (p1, p3, p4, p2); } else { // p2, p3 need to be swapped pair1.set_linepair (p1, p3, p2, p4); pair2.set_linepair (p3, p2, p4, p1); } } } void set_ellipse (const ConicCPA2& pair1, const ConicCPA2& pair2) { FT b = FT(2) * (pair1.r() * pair2.s() + pair1.s() * pair2.r()) - pair1.t() * pair2.t(); set_linear_combination (pair2.det()-b, pair1, pair1.det()-b, pair2); } void set (const ConicCPA2& c1, const ConicCPA2& c2, const PT& p) { set_linear_combination (c2.evaluate(p), c1, -c1.evaluate(p), c2); } CGAL::Sign vol_derivative (FT dr, FT ds, FT dt, FT du, FT dv, FT dw) const { FT a1 = FT(4)*r()*ds+FT(4)*dr*s()-FT(2)*t()*dt, a0 = FT(4)*r()*s()-t()*t(), b1 = (FT(4)*r()*s()-t()*t())*dw+(FT(4)*r()*ds+FT(4)*dr*s()- FT(2)*t()*dt)*w()-u()*u()*ds - FT(2)*u()*du*s()-v()*v()*dr-FT(2)*v()*dv*r()+u()*v()*dt+ (u()*dv+du*v())*t(), b0 = (FT(4)*r()*s()-t()*t())*w() -u()*u()*s()-v()*v()*r()+u()*v()*t(), c0 = -FT(2)*a0*b1 + FT(3)*a1*b0; return CGAL_NTS sign (-CGAL_NTS sign (c0)*o); } double vol_minimum (FT dr, FT ds, FT dt, FT du, FT dv, FT dw) const { FT a2 = FT(4)*dr*ds-dt*dt, a1 = FT(4)*r()*ds+FT(4)*dr*s()-FT(2)*t()*dt, a0 = FT(4)*r()*s()-t()*t(), b3 = (FT(4)*dr*ds-dt*dt)*dw-du*du*ds-dv*dv*dr+du*dv*dt, b2 = (FT(4)*r()*ds+FT(4)*dr*s()-FT(2)*t()*dt)*dw+ (FT(4)*dr*ds-dt*dt)*w()-FT(2)*u()*du*ds-du*du*s()- FT(2)*v()*dv*dr-dv*dv*r()+(u()*dv+du*v())*dt+du*dv*t(), b1 = (FT(4)*r()*s()-t()*t())*dw+(FT(4)*r()*ds+FT(4)*dr*s()- FT(2)*t()*dt)*w()-u()*u()*ds - FT(2)*u()*du*s()-v()*v()*dr-FT(2)*v()*dv*r()+u()*v()*dt+ (u()*dv+du*v())*t(), b0 = (FT(4)*r()*s()-t()*t())*w() -u()*u()*s()-v()*v()*r()+u()*v()*t(), c3 = -FT(3)*a1*b3 + FT(2)*a2*b2, c2 = -FT(6)*a0*b3 - a1*b2 + FT(4)*a2*b1, c1 = -FT(4)*a0*b2 + a1*b1 + FT(6)*a2*b0, c0 = -FT(2)*a0*b1 + FT(3)*a1*b0; double roots[3]; int nr_roots = solve_cubic (CGAL::to_double(c3), CGAL::to_double(c2), CGAL::to_double(c1), CGAL::to_double(c0), roots[0], roots[1], roots[2]); CGAL_kernel_precondition (nr_roots > 0); // minimum exists return best_value (roots, nr_roots, CGAL::to_double(a2), CGAL::to_double(a1), CGAL::to_double(a0), CGAL::to_double(b3), CGAL::to_double(b2), CGAL::to_double(b1), CGAL::to_double(b0)); } protected: FT det () const { return FT(4)*s()*r() - t()*t(); } void analyse( ) { FT d = det(); type = (Conic_type)(CGAL_NTS sign(d)); switch (type) { case HYPERBOLA: { trivial = empty = false; FT z_prime = d*w() - u()*u()*s() - v()*v()*r() + u()*v()*t(); o = (CGAL::Orientation)(CGAL_NTS sign (z_prime)); degenerate = (o == CGAL::ZERO); } break; case PARABOLA: { if (!CGAL_NTS is_zero (r())) { trivial = false; degenerate = (t()*u() == FT(2)*r()*v()); if (degenerate) { CGAL::Sign discr = (CGAL::Sign) CGAL_NTS sign(u()*u()-FT(4)*r()*w()); switch (discr) { case CGAL::NEGATIVE: empty = true; o = (CGAL::Orientation)(CGAL_NTS sign (w())); break; case CGAL::ZERO: empty = false; o = (CGAL::Orientation)(CGAL_NTS sign (r())); break; case CGAL::POSITIVE: empty = false; o = CGAL::ZERO; break; } } else { empty = false; o = (CGAL::Orientation)(-CGAL_NTS sign (r())); } } else if (!CGAL_NTS is_zero (s())) { trivial = false; degenerate = (t()*v() == FT(2)*s()*u()); if (degenerate) { CGAL::Sign discr = (CGAL::Sign) CGAL_NTS sign(v()*v()-FT(4)*s()*w()); switch (discr) { case CGAL::NEGATIVE: empty = true; o = (CGAL::Orientation)(CGAL_NTS sign (w())); break; case CGAL::ZERO: empty = false; o = (CGAL::Orientation)(CGAL_NTS sign (s())); break; case CGAL::POSITIVE: empty = false; o = CGAL::ZERO; break; } } else { empty = false; o = (CGAL::Orientation)(-CGAL_NTS sign (s())); } } else { // r=0, s=0 degenerate = true; bool uv_zero = CGAL_NTS is_zero (u()) && CGAL_NTS is_zero (v()); trivial = uv_zero && CGAL_NTS is_zero (w()); empty = uv_zero && !trivial; if (empty) o = (CGAL::Orientation)(CGAL_NTS sign (w())); else if (trivial) o = CGAL::POSITIVE; else o = CGAL::ZERO; } } break; case ELLIPSE: { trivial = false; FT z_prime = d*w() - u()*u()*s() - v()*v()*r() + u()*v()*t(); if (CGAL_NTS is_positive (r())) { empty = CGAL_NTS is_positive(CGAL_NTS sign (z_prime)); empty ? o = CGAL::POSITIVE : o = CGAL::NEGATIVE; } else { empty = CGAL_NTS is_negative(CGAL_NTS sign (z_prime)); empty ? o = CGAL::NEGATIVE : o = CGAL::POSITIVE; } degenerate = empty || CGAL_NTS is_zero (z_prime); } break; } } FT evaluate (const PT& p) const { FT x, y; dao.get (p, x, y); return r()*x*x + s()*y*y + t()*x*y + u()*x + v()*y + w(); } public: ConicCPA2 ( const DA& da = DA()) : dao( da) { } ConicCPA2 (FT r, FT s, FT t, FT u, FT v, FT w, const DA& da = DA()) : dao( da), _r(r), _s(s), _t(t), _u(u), _v(v), _w(w) { analyse(); } const DA& da() const { return dao; } FT r() const { return _r;} FT s() const { return _s;} FT t() const { return _t;} FT u() const { return _u;} FT v() const { return _v;} FT w() const { return _w;} PT center () const { CGAL_kernel_precondition (type != PARABOLA); // PT p; // replaced previous line by following hack (no idea // why original version doesn't work) typename DA::Point p; FT two = FT(2); FT div = -det(); dao.set( p, (two*s()*u() - t()*v()) / div, (two*r()*v() - t()*u()) / div); return p; } Conic_type conic_type () const { return type; } bool is_hyperbola () const { return (type == HYPERBOLA); } bool is_parabola () const { return (type == PARABOLA); } bool is_ellipse () const { return (type == ELLIPSE); } bool is_circle () const { return (type == ELLIPSE && (r()==s()) && CGAL_NTS is_zero (t())); } bool is_empty () const { return empty; } bool is_trivial () const { return trivial; } bool is_degenerate () const { return degenerate; } CGAL::Orientation orientation () const { return o; } CGAL::Oriented_side oriented_side (const PT& p) const { return (CGAL::Oriented_side)(CGAL_NTS sign (evaluate (p))); } bool has_on_positive_side (const PT& p) const { return (CGAL_NTS is_positive (evaluate(p))); } bool has_on_negative_side (const PT& p) const { return (CGAL_NTS is_negative (evaluate(p))); } bool has_on_boundary (const PT& p) const { return (CGAL_NTS is_zero (evaluate(p))); } bool has_on (const PT& p) const { return (CGAL_NTS is_zero (evaluate(p))); } Convex_side convex_side (const PT& p) const { switch (o) { case CGAL::POSITIVE: return (Convex_side)( CGAL_NTS sign (evaluate (p))); case CGAL::NEGATIVE: return (Convex_side)(-CGAL_NTS sign (evaluate (p))); case CGAL::ZERO: return (Convex_side)( CGAL_NTS sign (CGAL_NTS abs (evaluate(p)))); } // keeps g++ happy return( Convex_side( 0)); } bool has_on_convex_side (const PT& p) const { return (convex_side (p) == ON_CONVEX_SIDE); } bool has_on_nonconvex_side (const PT& p) const { return (convex_side (p) == ON_NONCONVEX_SIDE); } bool operator == ( const ConicCPA2<_PT,_DA>& c) const { // find coefficient != 0 FT factor1(0); if ( ! CGAL_NTS is_zero( r())) factor1 = r(); else if ( ! CGAL_NTS is_zero( s())) factor1 = s(); else if ( ! CGAL_NTS is_zero( t())) factor1 = t(); else if ( ! CGAL_NTS is_zero( u())) factor1 = u(); else if ( ! CGAL_NTS is_zero( v())) factor1 = v(); else if ( ! CGAL_NTS is_zero( w())) factor1 = w(); else CGAL_kernel_assertion_msg( false, "all coefficients zero"); // find coefficient != 0 FT factor2(0); if ( ! CGAL_NTS is_zero( c.r())) factor2 = c.r(); else if ( ! CGAL_NTS is_zero( c.s())) factor2 = c.s(); else if ( ! CGAL_NTS is_zero( c.t())) factor2 = c.t(); else if ( ! CGAL_NTS is_zero( c.u())) factor2 = c.u(); else if ( ! CGAL_NTS is_zero( c.v())) factor2 = c.v(); else if ( ! CGAL_NTS is_zero( c.w())) factor2 = c.w(); else CGAL_kernel_assertion_msg( false, "all coefficients zero"); return( ( r()*factor2 == c.r()*factor1) && ( s()*factor2 == c.s()*factor1) && ( t()*factor2 == c.t()*factor1) && ( u()*factor2 == c.u()*factor1) && ( v()*factor2 == c.v()*factor1) && ( w()*factor2 == c.w()*factor1)); } void set (FT r_, FT s_, FT t_, FT u_, FT v_, FT w_) { _r = r_; _s = s_; _t = t_; _u = u_; _v = v_; _w = w_; analyse(); } void set_opposite () { _r = -r(); _s = -s(); _t = -t(); _u = -u(); _v = -v(); _w = -w(); o = CGAL::opposite(orientation()); } void set_circle (const PT& p1, const PT& p2, const PT& p3) { // the circle will have r = s = det, t=0 FT x1, y1, x2, y2, x3, y3; dao.get (p1, x1, y1); dao.get (p2, x2, y2); dao.get (p3, x3, y3); // precondition: p1, p2, p3 not collinear FT det = -x3*y2+x1*y2+x2*y3-x1*y3+x3*y1-x2*y1; CGAL_kernel_precondition (!CGAL_NTS is_zero (det)); // Cramer's rule FT sqr1 = -x1*x1 - y1*y1; FT sqr2 = -x2*x2 - y2*y2; FT sqr3 = -x3*x3 - y3*y3; _u = -sqr3*y2+sqr1*y2+sqr2*y3-sqr1*y3+sqr3*y1-sqr2*y1; _v = -x3*sqr2+x1*sqr2+x2*sqr3-x1*sqr3+x3*sqr1-x2*sqr1; _w = -x3*y2*sqr1+x1*y2*sqr3+x2*y3*sqr1-x1*y3*sqr2+x3*y1*sqr2-x2*y1*sqr3; _r = det; _s = det; _t = FT(0); analyse(); CGAL_kernel_postcondition(is_circle()); CGAL_kernel_postcondition(has_on_boundary(p1)); CGAL_kernel_postcondition(has_on_boundary(p2)); CGAL_kernel_postcondition(has_on_boundary(p3)); } void set_linepair (const PT& p1, const PT& p2, const PT& p3, const PT& p4) { FT x1, y1, x2, y2, x3, y3, x4, y4; dao.get (p1, x1, y1); dao.get (p2, x2, y2); dao.get (p3, x3, y3); dao.get (p4, x4, y4); // precondition: p1 != p2, p3 != p4 CGAL_kernel_precondition ( ((x1 != x2) || (y1 != y2)) && ((x3 != x4) || (y3 != y4)) ); FT x2_x1 = x2-x1; FT x4_x3 = x4-x3; FT y1_y2 = y1-y2; FT y3_y4 = y3-y4; FT x1y2_y1x2 = x1*y2-y1*x2; FT x3y4_y3x4 = x3*y4-y3*x4; _r = y1_y2 * y3_y4; _s = x2_x1 * x4_x3; _t = x2_x1 * y3_y4 + y1_y2 * x4_x3; _u = x1y2_y1x2 * y3_y4 + y1_y2 * x3y4_y3x4; _v = x1y2_y1x2 * x4_x3 + x2_x1 * x3y4_y3x4; _w = x1y2_y1x2 * x3y4_y3x4; analyse(); } void set_ellipse (const PT& p1, const PT& p2, const PT& p3) { FT x1, y1, x2, y2, x3, y3; dao.get (p1, x1, y1); dao.get (p2, x2, y2); dao.get (p3, x3, y3); // precondition: p1, p2, p3 not collinear FT det = -x3*y2+x1*y2+x2*y3-x1*y3+x3*y1-x2*y1; CGAL_kernel_precondition (!CGAL_NTS is_zero (det)); FT x1x1 = x1*x1, y1y1 = y1*y1, x2x2 = x2*x2, y2y2 = y2*y2, x3x3 = x3*x3, y3y3 = y3*y3, // x_i^2, y_i^2 two = FT(2); _r = y1y1 - y1*y2 - y1*y3 + y2y2 - y2*y3 + y3y3; _s = x1x1 - x1*x2 - x1*x3 + x2x2 - x2*x3 + x3x3; _t = -two*x1*y1 + x1*y2 + x1*y3 + y1*x2 -two*x2*y2 + x2*y3 + y1*x3 + y2*x3 -two*x3*y3; _u = -(y2y2*x3 - x2*y2*y3 - y2*x3*y3 + x1*y3y3 + x2*y3y3 + y1y1*x2 + y1y1*x3 - x1*y1*y2 - y1*x2*y2 - x1*y1*y3 - y1*x3*y3 + x1*y2y2); _v = -(x2x2*y3 - x2*y2*x3 - x2*x3*y3 + y1*x3x3 + y2*x3x3 + x1x1*y2 + x1x1*y3 - x1*y1*x2 - x1*x2*y2 - x1*y1*x3 - x1*x3*y3 + y1*x2x2); _w = y1y1*x2*x3 - x1*y1*y2*x3 - y1*x2*y2*x3 + y1*y2*x3x3 - x1*y1*x2*y3 + y1*x2x2*y3 - y1*x2*x3*y3 + x1*y2y2*x3 + x1x1*y2*y3 - x1*x2*y2*y3 - x1*y2*x3*y3 + x1*x2*y3y3; type = ELLIPSE; degenerate = trivial = empty = false; o = CGAL::NEGATIVE; if (CGAL_NTS is_positive (det)) set_opposite(); } void set_ellipse (const PT& p1, const PT& p2, const PT& p3, const PT& p4, CGAL::Orientation _o = POSITIVE) { ConicCPA2 pair1, pair2; set_two_linepairs (p1, p2, p3, p4, pair1, pair2); set_ellipse (pair1, pair2); analyse(); if (o != _o) set_opposite(); } void set (const PT& p1, const PT& p2, const PT& p3, const PT& p4, const PT& p5, CGAL::Orientation _o = POSITIVE) { ConicCPA2 c1; c1.set_linepair (p1, p2, p3, p4); ConicCPA2 c2; c2.set_linepair (p1, p4, p2, p3); set_linear_combination (c2.evaluate (p5), c1, -c1.evaluate (p5), c2); analyse(); // precondition: all points distinct <=> conic nontrivial CGAL_kernel_precondition (!is_trivial()); if (o != _o) set_opposite(); } }; #ifndef CGAL_NO_OSTREAM_INSERT_CONICCPA2 template< class _PT, class _DA> std::ostream& operator << ( std::ostream& os, const ConicCPA2<_PT,_DA>& c) { return( os << c.r() << ' ' << c.s() << ' ' << c.t() << ' ' << c.u() << ' ' << c.v() << ' ' << c.w()); } template< class _PT, class _DA> std::istream& operator >> ( std::istream& is, ConicCPA2<_PT,_DA>& c) { typedef ConicCPA2<_PT,_DA> Conic; typedef typename _DA::FT FT; FT r, s, t, u, v, w; is >> r >> s >> t >> u >> v >> w; c.set( r, s, t, u, v, w); return( is); } #endif // CGAL_NO_OSTREAM_INSERT_CONICCPA2 CGAL_END_NAMESPACE #endif // CGAL_CONICCPA2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circle_2.h0000644000175000017500000000560311344301500026617 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Sven Schoenherr #ifndef CGAL_CIRCLE_2_H #define CGAL_CIRCLE_2_H CGAL_BEGIN_NAMESPACE template class Circle_2 : public R_::Kernel_base::Circle_2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Kernel_base::Circle_2 RCircle_2; public: typedef R_ R; Circle_2() {} Circle_2(const RCircle_2& t) : RCircle_2(t) {} Circle_2(const Point_2 ¢er, const FT &squared_radius, const Orientation &orientation) : RCircle_2(center, squared_radius, orientation) {} Circle_2(const Point_2 ¢er, const FT &squared_radius) : RCircle_2(center, squared_radius, COUNTERCLOCKWISE) {} Circle_2(const Point_2 &p, const Point_2 &q, const Point_2 &r) : RCircle_2(p,q,r) {} Circle_2(const Point_2 & p, const Point_2 & q, const Orientation &orientation) : RCircle_2(p,q,orientation) {} Circle_2(const Point_2 & p, const Point_2 & q) : RCircle_2(p,q,COUNTERCLOCKWISE) {} Circle_2(const Point_2 & center, const Orientation& orientation) : RCircle_2(center,FT(0),orientation) {} Circle_2(const Point_2 & center) : RCircle_2(center,FT(0),COUNTERCLOCKWISE) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_CIRCLE_2 template < class R > std::ostream & operator<<(std::ostream &os, const Circle_2 &c) { typedef typename R::Kernel_base::Circle_2 RCircle_2; return os << (const RCircle_2&)c; } #endif // CGAL_NO_OSTREAM_INSERT_CIRCLE_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_CIRCLE_2 template < class R > std::istream & operator>>(std::istream &is, Circle_2 &c) { typedef typename R::Kernel_base::Circle_2 RCircle_2; return is >> (RCircle_2&)c; } #endif // CGAL_NO_ISTREAM_EXTRACT_CIRCLE_2 CGAL_END_NAMESPACE #endif // CGAL_CIRCLE_2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Indirect_not_less_yx_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Indirect_not_less_yx_20000644000175000017500000000246611344301500031363 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Indirect_not_less_yx_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_INDIRECT_NOT_LESS_YX_2_H #define CGAL_INDIRECT_NOT_LESS_YX_2_H namespace CGAL { template class Indirect_not_less_yx_2 { public: typedef typename Traits::Less_yx_2 Less_yx_2; Indirect_not_less_yx_2(const Traits& traits) : less_yx_2(traits.less_yx_2_object()) {} template bool operator()( const Iterator& p, const Iterator& q) const { return less_yx_2( *q, *p); } private: Less_yx_2 less_yx_2; }; } #endif // CGAL_INDIRECT_NOT_LESS_YX_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nested_iterator.h0000644000175000017500000001345111344301500030330 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nested_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_NESTED_ITERATOR_H #define CGAL_NESTED_ITERATOR_H #include #include CGAL_BEGIN_NAMESPACE template struct Nested_iterator_traits { typedef It Base_iterator; typedef typename std::iterator_traits::value_type::iterator Iterator; Iterator begin(It it) const { return it->begin(); } Iterator end(It it) const { return it->end(); } }; namespace CGALi { template struct Emptyness_predicate : public Tr { typedef Tr Traits; bool operator()(typename Traits::Base_iterator base_it) const { return this->begin(base_it) == this->end(base_it); } }; template class FI_w_begin_end : public F_iterator { private: typedef typename F_iterator::Predicate Predicate; typedef typename Predicate::Traits::Iterator Iterator; typedef typename Predicate::Traits::Base_iterator Base_iterator; public: FI_w_begin_end() : F_iterator() {} FI_w_begin_end(Base_iterator it2, Base_iterator it3) : F_iterator(it2, Predicate(), it3) {} Iterator begin(Base_iterator it) { return this->predicate().begin(it); } Iterator end(Base_iterator it) { return this->predicate().end(it); } }; } template class Nested_iterator; template bool operator==(const Nested_iterator&, const Nested_iterator&); template > class Nested_iterator : private CGALi::FI_w_begin_end< Filter_iterator > > { typedef Nested_iterator Self; public: typedef Base_it Base_iterator; typedef Tr Traits; typedef typename Tr::Iterator Iterator; protected: typedef CGALi:: FI_w_begin_end< Filter_iterator > > Filter_base_iterator; private: typedef std::iterator_traits ItTraits; public: typedef typename ItTraits::reference reference; typedef typename ItTraits::pointer pointer; typedef typename ItTraits::value_type value_type; typedef typename ItTraits::difference_type difference_type; typedef typename ItTraits::iterator_category iterator_category; public: Nested_iterator() : Filter_base_iterator(), nested_it_() {} Nested_iterator(Base_iterator base_it_end, Base_iterator base_it_cur) : Filter_base_iterator(base_it_end, base_it_cur), nested_it_() { if ( !this->is_end() ) { nested_it_ = this->begin( this->base() ); } } Nested_iterator(const Self& other) { copy_from(other); } Self& operator=(const Self& other) { copy_from(other); return *this; } Self& operator++() { if ( nested_it_ != end( this->base() ) ) { ++nested_it_; if ( nested_it_ == end( this->base() ) ) { Filter_base_iterator::operator++(); if ( !this->is_end() ) { nested_it_ = begin( this->base() ); } } } return *this; } Self operator++(int) { Self tmp = *this; ++(*this); return tmp; } Self& operator--() { if ( this->is_end() ) { Filter_base_iterator::operator--(); nested_it_ = this->end(this->base()); --nested_it_; } else { if ( nested_it_ != begin( this->base() ) ) { --nested_it_; } else { Filter_base_iterator::operator--(); nested_it_ = this->end( this->base() ); --nested_it_; } } return *this; } Self operator--(int) { Self tmp = *this; --(*this); return tmp; } reference operator*() const { return *nested_it_; } pointer operator->() const { return nested_it_.operator->(); } friend bool operator==<>(const Self&, const Self&); protected: void copy_from(const Self& other) { Filter_base_iterator::operator=(other); if ( !other.is_end() ) { nested_it_ = other.nested_it_; } } protected: Iterator nested_it_; }; template inline bool operator==(const Nested_iterator& it1, const Nested_iterator& it2) { // CGAL_precondition( it1.b_ == it2.b_ && it1.e_ == it2.e_ ); if ( it1.base() != it2.base() ) { return false; } return it1.is_end() || ( it1.nested_it_ == it2.nested_it_ ); } template inline bool operator!=(const Nested_iterator& it1, const Nested_iterator& it2) { return !(it1 == it2); } CGAL_END_NAMESPACE #endif // CGAL_NESTED_ITERATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2.C0000644000175000017500000000621511344301500027415 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #include CGAL_BEGIN_NAMESPACE // Class implementation (continued) // ================================ // I/O // --- template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_circle_2& min_circle) { CGAL_USING_NAMESPACE_STD typedef typename Min_circle_2::Point Point; typedef ostream_iterator Os_it; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << endl; os << "CGAL::Min_circle_2( |P| = " << min_circle.number_of_points() << ", |S| = " << min_circle.number_of_support_points() << endl; os << " P = {" << endl; os << " "; copy( min_circle.points_begin(), min_circle.points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " S = {" << endl; os << " "; copy( min_circle.support_points_begin(), min_circle.support_points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " circle = " << min_circle.circle() << endl; os << ")" << endl; break; case CGAL::IO::ASCII: copy( min_circle.points_begin(), min_circle.points_end(), Os_it( os, "\n")); break; case CGAL::IO::BINARY: copy( min_circle.points_begin(), min_circle.points_end(), Os_it( os)); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } template < class Traits_ > std::istream& operator >> ( std::istream& is, CGAL::Min_circle_2& min_circle) { CGAL_USING_NAMESPACE_STD switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: cerr << endl; cerr << "Stream must be in ascii or binary mode" << endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: typedef typename CGAL::Min_circle_2::Point Point; typedef istream_iterator Is_it; min_circle.clear(); min_circle.insert( Is_it( is), Is_it()); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Linear_algebraCd.h0000644000175000017500000000743611344301500030341 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Linear_algebraCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Herve.Bronnimann@sophia.inria.fr #ifndef CGAL_LINEAR_ALGEBRACD_H #define CGAL_LINEAR_ALGEBRACD_H #include #include #include #include #undef _DEBUG #define _DEBUG 13 #include //#define CGAL_LA_SELFTEST CGAL_BEGIN_NAMESPACE template < class _FT, class _AL = CGAL_ALLOCATOR(_FT) > class Linear_algebraCd { public: typedef _FT FT; typedef _FT RT; typedef _AL AL; typedef Linear_algebraCd Self; typedef CGALLA::Vector_ Vector; typedef CGALLA::Matrix_ Matrix; typedef const FT* const_iterator; typedef FT* iterator; Linear_algebraCd() {} protected: // Major routines for Linear_algebra_d static void Gaussian_elimination(const Matrix &M, Matrix &L, Matrix &U, std::vector &row_permutation, std::vector &column_permutation, FT &det, int &rank, Vector &c); static bool Triangular_system_solver(const Matrix &U, const Matrix &L, const Vector &b, int rank, Vector &x, FT &det); static void Triangular_left_inverse(const Matrix &U, Matrix &Uinv); public: static std::pair transpose(std::pair dim) { std::swap(dim.first,dim.second); return dim; } static Matrix transpose(const Matrix &M); static bool inverse(const Matrix &M, Matrix &I, FT &D, Vector &c); static Matrix inverse(const Matrix &M, RT &D); static FT determinant(const Matrix &M, Matrix &L, Matrix &U, std::vector &q, Vector &c); static FT determinant(const Matrix &M); static Sign sign_of_determinant(const Matrix &M); static bool verify_determinant(const Matrix &M, const RT &D, const Matrix &L, const Matrix &U, const std::vector &q, const Vector &c); static bool linear_solver(const Matrix &M, const Vector &b, Vector &x, RT &D, Matrix &spanning_vectors, Vector &c); static bool linear_solver(const Matrix &M, const Vector &b, Vector &x, RT &D, Vector &c); static bool linear_solver(const Matrix &M, const Vector &b, Vector &x, RT &D); static bool is_solvable(const Matrix &M, const Vector &b); static bool homogeneous_linear_solver(const Matrix &M, Vector &x); static int homogeneous_linear_solver(const Matrix &M, Matrix &spanning_vectors); static int rank(const Matrix &M); static int independent_columns(const Matrix& M, std::vector& columns); }; CGAL_END_NAMESPACE #include #endif // CGAL_LINEAR_ALGEBRACD_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/leda_integer.h0000644000175000017500000000570211344301500027617 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/leda_integer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_LEDA_INTEGER_H #define CGAL_LEDA_INTEGER_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_true Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; #ifndef CGAL_CFG_NO_NAMESPACE inline double to_double(const leda_integer & i) { return i.to_double(); } #endif inline leda_integer sqrt(const leda_integer & i) { return CGAL_LEDA_SCOPE::sqrt(i); } inline bool is_finite(const leda_integer &) { return true; } inline bool is_valid(const leda_integer &) { return true; } inline io_Operator io_tag(const leda_integer &) { return io_Operator(); } #ifndef CGAL_CFG_NO_NAMESPACE inline Sign sign(const leda_integer& n) { return (Sign) CGAL_LEDA_SCOPE::sign(n); } #endif inline leda_integer div( const leda_integer& n1, const leda_integer& n2) { return n1 / n2; } // missing mixed operators inline bool operator==(int a, const leda_integer& b) { return b == a; } inline bool operator!=(int a, const leda_integer& b) { return b != a; } inline std::pair to_interval (const leda_integer & n) { Protect_FPU_rounding P (CGAL_FE_TONEAREST); double cn = CGAL::to_double(n); leda_integer pn = ( n>0 ? n : -n); if ( pn.iszero() || log(pn) < 53 ) return to_interval(cn); else { FPU_set_cw(CGAL_FE_UPWARD); Interval_nt_advanced ina(cn); ina += Interval_nt_advanced::smallest(); return ina.pair(); } } inline leda_integer gcd( const leda_integer& n1, const leda_integer& n2) { return CGAL_LEDA_SCOPE::gcd(n1, n2); } CGAL_END_NAMESPACE #endif // CGAL_LEDA_INTEGER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_set_2.h0000644000175000017500000003022011344301500027353 0ustar debiandebian// Copyright (c) 1999 Martin-Luther-University Halle-Wittenberg (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_set_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_POINT_SET_2_H #define CGAL_POINT_SET_2_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // compare function objects for the priority queues // used in nearest neighbor search template class compare_vertices { public: MAP_TYPE* pmap; compare_vertices(MAP_TYPE *p){ pmap=p; } bool operator()(VP e1, VP e2) // get the priorities from the map and return result of comparison ... { NT& v1 = (*pmap)[e1]; NT& v2 = (*pmap)[e2]; return (v1 > v2); } }; template > > class Point_set_2 : public Delaunay_triangulation_2 { public: typedef Gt Geom_traits; typedef typename Geom_traits::Point_2 Point; typedef typename Geom_traits::Segment_2 Segment; typedef typename Geom_traits::Circle_2 Circle; typedef typename Geom_traits::Orientation_2 Orientation_2; typedef typename Geom_traits::Side_of_oriented_circle_2 Side_of_oriented_circle_2; typedef typename Geom_traits::Construct_circle_2 Construct_circle_2; typedef typename Geom_traits::Compute_squared_distance_2 Compute_squared_distance_2; typedef typename Geom_traits::FT Numb_type; // field number type ... typedef Triangulation_2 Triangulation; typedef typename Triangulation::Locate_type Locate_type; typedef typename Triangulation::Face_handle Face_handle; typedef typename Triangulation::Vertex_handle Vertex_handle; typedef typename Triangulation::Edge Edge; typedef typename Triangulation::Vertex Vertex; typedef typename Triangulation::Face Face; typedef typename Triangulation::Edge_circulator Edge_circulator; typedef typename Triangulation::Finite_edges_iterator Finite_edges_iterator; typedef typename Triangulation::Vertex_iterator Vertex_iterator; typedef typename Triangulation::Vertex_circulator Vertex_circulator; typedef typename Triangulation::Edge_iterator Edge_iterator; typedef typename Geom_traits::Bounded_side_2 Circleptori; typedef typename Geom_traits::Compare_distance_2 Comparedist; typedef typename Geom_traits::Construct_center_2 Circlecenter; typedef Unique_hash_map MAP_TYPE; typedef Delaunay_triangulation_2 Base; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::finite_vertices_begin; using Base::finite_vertices_end; using Base::number_of_vertices; using Base::VERTEX; #endif Comparedist tr_comparedist; Orientation_2 tr_orientation; Side_of_oriented_circle_2 tr_so_circle; Compute_squared_distance_2 tr_sqrdist; Circleptori tr_circleptori; Circlecenter tr_circlecenter; //constructions... Construct_circle_2 tr_createcircle_3p; Point_set_2() { init_vertex_marks(); } template Point_set_2(InputIterator first, InputIterator last) { init_vertex_marks(); insert(first,last); } ~Point_set_2() {} template OutputIterator vertices(OutputIterator res) // return vertex handles ... { Vertex_iterator vit = finite_vertices_begin(); for (; vit != finite_vertices_end(); vit++) { *res= vit; res++; } return res; } Vertex_handle lookup(Point p) const { if (number_of_vertices() == 0) return NULL; // locate ... Locate_type lt; int li; Face_handle fh = locate(p,lt,li); if (lt == VERTEX){ Face f = *fh; return f.vertex(li); } else return NULL; } Vertex_handle nearest_neighbor(Point p) { if (number_of_vertices() == 0) return NULL; return nearest_vertex(p); } Vertex_handle nearest_neighbor(Vertex_handle v) const { if (number_of_vertices() <= 1) return NULL; Point p = v->point(); Vertex_circulator vc = incident_vertices(v); Vertex_circulator start =vc; Vertex_handle min_v = vc; if (is_infinite(min_v)){ vc++; min_v = vc; } Vertex_handle act; // go through the vertices ... do { act = vc; if (! is_infinite(act)) { if ( tr_comparedist(p,act->point(), min_v->point()) == SMALLER ) { min_v = act; } } vc++; } while (vc != start); return min_v; } template OutputIterator nearest_neighbors(Point p, int k, OutputIterator res) { int n = number_of_vertices(); if ( k <= 0 ) return res; if ( n <= k ) { // return all finite vertices ... return vertices(res); } // insert p, if nesessary Vertex_handle vh = lookup(p); bool old_node = true; // we have to add a new vertex ... if (vh == NULL){ vh = insert(p); old_node = false; k++; } std::list res_list; nearest_neighbors_list(vh, k, res_list); if ( !old_node ) { res_list.pop_front(); remove(vh); } typename std::list::iterator it = res_list.begin(); for (; it != res_list.end(); it++) { *res= *it; res++; } return res; } template OutputIterator nearest_neighbors(Vertex_handle v, int k,OutputIterator res) { int n = number_of_vertices(); if ( k <= 0 ) return res; if ( n <= k ) { // return all (finite) vertices ... return vertices(res); } std::list res_list; nearest_neighbors_list(v, k, res_list); typename std::list::iterator it = res_list.begin(); for (; it != res_list.end(); it++) { *res= *it; res++; } return res; } void nearest_neighbors_list(Vertex_handle v, int k, std::list& res) { int n = number_of_vertices(); if ( k <= 0 ) return; if ( n <= k ) { vertices(std::back_inserter(res)); return; } Point p = v->point(); // "unmark" the vertices ... init_dfs(); MAP_TYPE priority_number; // here we save the priorities ... compare_vertices comp(& priority_number); // comparison object ... std::priority_queue, CGAL::compare_vertices > PQ(comp); priority_number[v] = 0; PQ.push(v); mark_vertex(v); while ( k > 0 ) { // find minimum from PQ ... Vertex_handle w = PQ.top(); PQ.pop(); res.push_back(w); k--; // get the incident vertices of w ... Vertex_circulator vc = incident_vertices(w); Vertex_circulator start =vc; Vertex_handle act; do { act = vc; if ( (!is_marked(act)) && (! is_infinite(act)) ) { priority_number[act] = tr_sqrdist(p,act->point()); PQ.push(act); mark_vertex(act); } vc++; } while (vc != start); } } // dfs // for marking nodes in search procedures int cur_mark; Unique_hash_map mark; void init_vertex_marks() { cur_mark = 0; mark.clear(); } void init_dfs() { cur_mark++; if (cur_mark == INT_MAX) init_vertex_marks(); } void mark_vertex(Vertex_handle vh) // mark vh as visited ... { mark[vh] = cur_mark; } bool is_marked(Vertex_handle vh) { if (! mark.is_defined(vh)) return false; return (mark[vh] == cur_mark); } void dfs(Vertex_handle v,const Circle& C, std::list& L) { L.push_back(v); mark_vertex(v); // get incident vertices of v ... Vertex_circulator vc = incident_vertices(v); Vertex_circulator start =vc; Vertex_handle act; // go through the vertices ... do { act = vc; if (! is_infinite(act)) { if (!is_marked(act) && ! (tr_circleptori(C,act->point())==ON_UNBOUNDED_SIDE) ) dfs(act,C,L); } vc++; } while (vc != start); } template OutputIterator range_search(const Circle& C, OutputIterator res) { if (number_of_vertices() == 0) return res; if (number_of_vertices() == 1) { // get the one vertex ... Vertex_iterator vit = finite_vertices_begin(); Point p = vit->point(); if (! (tr_circleptori(C, p) == ON_UNBOUNDED_SIDE)){ *res= vit; res++; } return res; } // normal case ... Point p = tr_circlecenter(C); Vertex_handle v = lookup(p); bool new_v = false; if ( v == NULL ) { new_v = true; v = insert(p); } init_dfs(); std::list L; dfs(v,C,L); if (new_v) { L.pop_front(); //first one was inserted in range_search ... remove(v); } typename std::list::const_iterator iter = L.begin(); for(;iter != L.end() ;iter++){ *res= *iter; res++; } return res; } template OutputIterator range_search(const Point& a, const Point& b, const Point& c,OutputIterator res) { int orient = (int)(tr_orientation(a,b,c)); Circle C = tr_createcircle_3p(a,b,c); std::list L; range_search(C,std::back_inserter(L)); typename std::list::const_iterator it = L.begin(); for(;it != L.end();it++) { Point p = (*it)->point(); if ( ((int)(tr_orientation(a,b,p))) == - orient || ((int)(tr_orientation(b,c,p))) == - orient || ((int)(tr_orientation(c,a,p))) == - orient ) { } else { *res = *it; res++; } } return res; } template OutputIterator range_search(const Point& a1, const Point& b1, const Point& c1,const Point& d1,OutputIterator res) // a1 upper left, b1 lower left , c1 lower right { //Point b(c.xcoord(),a.ycoord()); //Point d(a.xcoord(),c.ycoord()); Point a=a1,b=b1,c=c1,d=d1; if (tr_orientation(a,b,c) == RIGHT_TURN) { Point tmp = b; b = d; d = tmp; } Circle C = tr_createcircle_3p(a,b,c); std::list L; range_search(C,std::back_inserter(L)); typename std::list::const_iterator it = L.begin(); for(;it != L.end();it++) { Point p = (*it)->point(); if ( tr_orientation(a,b,p) == RIGHT_TURN || tr_orientation(b,c,p) == RIGHT_TURN || tr_orientation(c,d,p) == RIGHT_TURN || tr_orientation(d,a,p) == RIGHT_TURN ) { } else { *res = *it; res++; } } return res; } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Object.h0000644000175000017500000000520511344301500026401 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Object.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra // Andreas Fabri // Geert-Jan Giezeman // Michael Seel // Sylvain Pion #ifndef CGAL_OBJECT_H #define CGAL_OBJECT_H #include #include CGAL_BEGIN_NAMESPACE template class Wrapper : public Ref_counted_virtual { public: Wrapper(const T& object) : _object(object) {} Wrapper() {} operator T() const { return _object; } ~Wrapper() {} private: T _object; }; class Object : public Handle_for_virtual { struct empty{}; typedef Handle_for_virtual base; public: struct private_tag{}; Object() { initialize_with(Wrapper()); } template Object(const T&t, private_tag) { initialize_with(Wrapper(t)); } template bool assign(T &t) const { #ifdef _MSC_VER try { #endif const Wrapper *wp = dynamic_cast *>(Ptr()); if (wp == NULL) return false; t = *wp; #ifdef _MSC_VER } catch (...) { std::cerr << "ERROR : YOUR COMPILER MUST SUPPORT RTTI" << std::endl; abort(); } #endif return true; } bool is_empty() const { empty E; return assign(E); } }; template inline Object make_object(const T& t) { return Object(t, Object::private_tag()); } template inline bool assign(T& t, const Object& o) { return o.assign(t); } CGAL_END_NAMESPACE #endif // CGAL_OBJECT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Threetuple.h0000644000175000017500000000262011344301501027313 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Threetuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL__THREETUPLE_H #define CGAL__THREETUPLE_H CGAL_BEGIN_NAMESPACE template < class T > struct Threetuple { T e0; T e1; T e2; Threetuple() {} Threetuple(const T & a0, const T & a1, const T & a2) : e0(a0), e1(a1), e2(a2) {} }; CGAL_END_NAMESPACE #endif // CGAL__THREETUPLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_2_2.h0000644000175000017500000003600711344301501031160 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_2_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SQUARED_DISTANCE_2_2_H #define CGAL_SQUARED_DISTANCE_2_2_H #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template void distance_index(int &ind1, int &ind2, const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Triangle_2 &triangle, const K& k ) { typename K::Left_turn_2 leftturn = k.left_turn_2_object(); typedef typename K::Point_2 Point_2; const Point_2 &vt0 = triangle.vertex(0); const Point_2 &vt1 = triangle.vertex(1); const Point_2 &vt2 = triangle.vertex(2); if (leftturn(vt0, vt1, vt2)) { if (leftturn(pt, vt1, vt0)) { if (!is_acute_angle(vt0, vt1, pt, k)) { if (leftturn(pt, vt2, vt1)) { if (!is_acute_angle(vt1, vt2, pt, k)) { ind1 = 2; ind2 = -1; return; } if (!is_acute_angle(vt2, vt1, pt, k)) { ind1 = 1; ind2 = -1; return; } ind1 = 1; ind2 = 2; return; } ind1 = 1; ind2 = -1; return; } if (!is_acute_angle(vt1, vt0, pt, k)) { if (leftturn(pt, vt0, vt2)) { if (!is_acute_angle(vt0, vt2, pt, k)) { ind1 = 2; ind2 = -1; return; } if (!is_acute_angle(vt2, vt0, pt, k)) { ind1 = 0; ind2 = -1; return; } ind1 = 2; ind2 = 0; return; } ind1 = 0; ind2 = -1; return; } ind1 = 0; ind2 = 1; return; } else { if (leftturn(pt, vt2, vt1)) { if (!is_acute_angle(vt1, vt2, pt, k)) { if (leftturn(pt, vt0, vt2)) { if (!is_acute_angle(vt0, vt2, pt, k)) { ind1 = 2; ind2 = -1; return; } if (!is_acute_angle(vt2, vt0, pt, k)) { ind1 = 0; ind2 = -1; return; } ind1 = 2; ind2 = 0; return; } ind1 = 0; ind2 = -1; return; } if (!is_acute_angle(vt2, vt1, pt, k)) { ind1 = 1; ind2 = -1; return; } ind1 = 1; ind2 = 2; return; } else { if (leftturn(pt, vt0, vt2)) { if (!is_acute_angle(vt2, vt0, pt, k)) { ind1 = 0; ind2 = -1; return; } if (!is_acute_angle(vt0, vt2, pt, k)) { ind1 = 2; ind2 = -1; return; } ind1 = 2; ind2 = 0; return; } else { ind1 = -1; ind2 = -1; // point inside or on boundary. return; } } } } else { if (leftturn(pt, vt2, vt0)) { if (!is_acute_angle(vt0, vt2, pt, k)) { if (leftturn(pt, vt1, vt2)) { if (!is_acute_angle(vt2, vt1, pt, k)) { ind1 = 1; ind2 = -1; return; } if (!is_acute_angle(vt1, vt2, pt, k)) { ind1 = 2; ind2 = -1; return; } ind1 = 2; ind2 = 1; return; } ind1 = 2; ind2 = -1; return; } if (!is_acute_angle(vt2, vt0, pt, k)) { if (leftturn(pt, vt0, vt1)) { if (!is_acute_angle(vt0, vt1, pt, k)) { ind1 = 1; ind2 = -1; return; } if (!is_acute_angle(vt1, vt0, pt, k)) { ind1 = 0; ind2 = -1; return; } ind1 = 1; ind2 = 0; return; } ind1 = 0; ind2 = -1; return; } ind1 = 0; ind2 = 2; return; } else { if (leftturn(pt, vt1, vt2)) { if (!is_acute_angle(vt2, vt1, pt, k)) { if (leftturn(pt, vt0, vt1)) { if (!is_acute_angle(vt0, vt1, pt, k)) { ind1 = 1; ind2 = -1; return; } if (!is_acute_angle(vt1, vt0, pt, k)) { ind1 = 0; ind2 = -1; return; } ind1 = 1; ind2 = 0; return; } ind1 = 0; ind2 = -1; return; } if (!is_acute_angle(vt1, vt2, pt, k)) { ind1 = 2; ind2 = -1; return; } ind1 = 2; ind2 = 1; return; } else { if (leftturn(pt, vt0, vt1)) { if (!is_acute_angle(vt1, vt0, pt, k)) { ind1 = 0; ind2 = -1; return; } if (!is_acute_angle(vt0, vt1, pt, k)) { ind1 = 1; ind2 = -1; return; } ind1 = 1; ind2 = 0; return; } else { ind1 = -1; ind2 = -1; // point inside or on boundary. return; } } } } } template typename K::FT squared_distance_indexed(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Triangle_2 &triangle, int ind1, int ind2, const K& k) { typedef typename K::FT FT; typedef typename K::Line_2 Line_2; if (ind1 == -1) return FT(0); if (ind2 == -1) return CGALi::squared_distance(pt, triangle.vertex(ind1), k); return CGALi::squared_distance(pt, Line_2(triangle.vertex(ind1), triangle.vertex(ind2)), k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Triangle_2 &triangle, const K& k) { int ind1,ind2; distance_index(ind1, ind2, pt, triangle, k); return squared_distance_indexed(pt, triangle, ind1, ind2, k); } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle, const typename CGAL_WRAP(K)::Point_2 & pt, const K& k) { return CGALi::squared_distance(pt, triangle, k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Triangle_2 &triangle, const K& k) { typedef typename K::FT FT; Oriented_side side0; side0 = line.oriented_side(triangle.vertex(0)); if (line.oriented_side(triangle.vertex(1)) != side0) return FT(0); if (line.oriented_side(triangle.vertex(2)) != side0) return FT(0); FT mindist, dist; int i; mindist = CGALi::squared_distance(triangle.vertex(0),line,k); for (i=1; i<3; i++) { dist = CGALi::squared_distance(triangle.vertex(i),line,k); if (dist < mindist) mindist = dist; } return mindist; } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle, const typename CGAL_WRAP(K)::Line_2 & line, const K& k) { return CGALi::squared_distance(line, triangle, k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Triangle_2 &triangle, const K& k) { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; int i, ind_tr1, ind_tr2, ind_ray = 0, ind1; FT mindist, dist; distance_index(ind_tr1, ind_tr2, ray.source(), triangle, k); mindist = squared_distance_indexed(ray.source(), triangle, ind_tr1, ind_tr2, k); for (i=0; i<3; i++) { const Point_2& pt = triangle.vertex(i); distance_index(ind1, pt, ray, k); dist = squared_distance_indexed(pt, ray, ind1, k); if (dist < mindist) { ind_ray = ind1; ind_tr1 = i; ind_tr2 = -1; mindist = dist; } } // now check if all vertices are on the right side of the separating line. // In case of vertex-vertex smallest distance this is the case. if (ind_tr2 == -1 && ind_ray != -1) return mindist; if (ind_tr2 != -1) { // Check if all the segment vertices lie at the same side of // the triangle segment. const Point_2 &vt1 = triangle.vertex(ind_tr1); const Point_2 &vt2 = triangle.vertex(ind_tr2); if (clockwise(ray.direction().vector(), vt2-vt1, k)) { mindist = FT(0); } } else { // Check if all the triangle vertices lie // at the same side of the segment. const Line_2 &sl = ray.supporting_line(); Oriented_side or_s = sl.oriented_side(triangle.vertex(0)); for (i=1; i<3; i++) { if (sl.oriented_side(triangle.vertex(i)) != or_s) { mindist = FT(0); break; } } } return mindist; } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle, const typename CGAL_WRAP(K)::Ray_2 & ray, const K& k) { return CGALi::squared_distance(ray, triangle, k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Triangle_2 &triangle, const K& k) { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typename K::Orientation_2 orientation; int i, ind_tr1 = 0, ind_tr2 = -1, ind_seg = 0, ind1, ind2; FT mindist, dist; mindist = CGALi::squared_distance(seg.source(), triangle.vertex(0), k); for (i=0; i<2; i++) { const Point_2 &pt = seg.vertex(i); distance_index(ind1, ind2, pt, triangle, k); dist = CGALi::squared_distance_indexed(pt, triangle, ind1, ind2, k); if (dist < mindist) { ind_seg = i; ind_tr1 = ind1; ind_tr2 = ind2; mindist = dist; } } for (i=0; i<3; i++) { const Point_2& pt = triangle.vertex(i); distance_index(ind1, pt, seg, k); dist = CGALi::squared_distance_indexed(pt, seg, ind1, k); if (dist < mindist) { ind_seg = ind1; ind_tr1 = i; ind_tr2 = -1; mindist = dist; } } // now check if all vertices are on the right side of the separating line. // In case of vertex-vertex smallest distance this is the case. if (ind_tr2 == -1 && ind_seg != -1) return mindist; if (ind_tr2 != -1) { // Check if all the segment vertices lie at the same side of // the triangle segment. const Point_2 &vt1 = triangle.vertex(ind_tr1); const Point_2 &vt2 = triangle.vertex(ind_tr2); Orientation or_s = orientation(vt1, vt2, seg.source()); if (orientation(vt1, vt2, seg.target()) != or_s) { mindist = FT(0); } } else { // Check if all the triangle vertices lie // at the same side of the segment. const Point_2 &vt1 = seg.source(); const Point_2 &vt2 = seg.target(); Orientation or_s = orientation(vt1, vt2, triangle.vertex(0)); for (i=1; i<3; i++) { if (orientation(vt1, vt2, triangle.vertex(i)) != or_s) { mindist = FT(0); break; } } } return mindist; } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Triangle_2 & triangle, const typename CGAL_WRAP(K)::Segment_2 & seg, const K& k) { return CGALi::squared_distance(seg, triangle, k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Triangle_2 &triangle1, const typename CGAL_WRAP(K)::Triangle_2 &triangle2, const K& k) { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typename K::Orientation_2 orientation; int i, ind1_1 = 0,ind1_2 = -1, ind2_1 = 0, ind2_2 = -1, ind1, ind2; FT mindist, dist; mindist = CGALi::squared_distance(triangle1.vertex(0), triangle2.vertex(0), k); for (i=0; i<3; i++) { const Point_2& pt = triangle1.vertex(i); distance_index(ind1, ind2, pt, triangle2, k); dist = squared_distance_indexed(pt, triangle2, ind1, ind2, k); if (dist < mindist) { ind1_1 = i; ind1_2 = -1; ind2_1 = ind1; ind2_2 = ind2; mindist = dist; } } for (i=0; i<3; i++) { const Point_2& pt = triangle2.vertex(i); distance_index(ind1, ind2, pt, triangle1, k); dist = squared_distance_indexed(pt, triangle1, ind1, ind2, k); if (dist < mindist) { ind1_1 = ind1; ind1_2 = ind2; ind2_1 = i; ind2_2 = -1; mindist = dist; } } // now check if all vertices are on the right side of the // separating line. if (ind1_2 == -1 && ind2_2 == -1) return mindist; // In case of point-segment closest distance, there is still the // possibility of overlapping triangles. Check if all the // vertices lie at the same side of the segment. if (ind1_2 != -1) { const Point_2 &vt1 = triangle1.vertex(ind1_1); const Point_2 &vt2 = triangle1.vertex(ind1_2); Orientation or_s = orientation(vt1, vt2, triangle2.vertex(0)); for (i=1; i<3; i++) { if (orientation(vt1, vt2, triangle2.vertex(i)) != or_s) { mindist = FT(0); break; } } } else { const Point_2 &vt1 = triangle2.vertex(ind2_1); const Point_2 &vt2 = triangle2.vertex(ind2_2); Orientation or_s = orientation(vt1, vt2, triangle1.vertex(0)); for (i=1; i<3; i++) { if (orientation(vt1, vt2, triangle1.vertex(i)) != or_s) { mindist = FT(0); break; } } } return mindist; } } // namespace CGALi template inline typename K::FT squared_distance(const Point_2 &pt, const Triangle_2 &triangle) { return CGALi::squared_distance(pt, triangle, K()); } template inline typename K::FT squared_distance(const Triangle_2 &triangle, const Point_2 &pt) { return CGALi::squared_distance(pt, triangle, K()); } template inline typename K::FT squared_distance(const Line_2 &line, const Triangle_2 &triangle) { return CGALi::squared_distance(line, triangle, K()); } template inline typename K::FT squared_distance(const Triangle_2 &triangle, const Line_2 &line) { return CGALi::squared_distance(line, triangle, K()); } template inline typename K::FT squared_distance(const Ray_2 &ray, const Triangle_2 &triangle) { return CGALi::squared_distance(ray, triangle, K()); } template inline typename K::FT squared_distance(const Triangle_2 &triangle, const Ray_2 &ray) { return CGALi::squared_distance(ray, triangle, K()); } template inline typename K::FT squared_distance(const Segment_2 &seg, const Triangle_2 &triangle) { return CGALi::squared_distance(seg, triangle, K()); } template inline typename K::FT squared_distance(const Triangle_2 &triangle, const Segment_2 &seg) { return CGALi::squared_distance(seg, triangle, K()); } template inline typename K::FT squared_distance(const Triangle_2 &triangle1, const Triangle_2 &triangle2) { return CGALi::squared_distance(triangle1, triangle2, K()); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/0000755000175000017500000000000012146213735027160 5ustar debiandebian././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_basic_predicates_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_basic_p0000644000175000017500000002212311344301501031303 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_basic_predicates_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_BASIC_PREDICATES_C2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_BASIC_PREDICATES_C2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template struct Svd_basic_predicates_C2 { public: //------------------------------------------------------------------- // TYPES //------------------------------------------------------------------- typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; typedef CGAL::Square_root_1 Sqrt_1; typedef CGAL::Square_root_2 Sqrt_2; typedef CGAL::Square_root_2 Sqrt_3; typedef typename Number_type_traits::Has_sqrt RT_Has_sqrt; typedef typename Number_type_traits::Has_sqrt FT_Has_sqrt; static const RT_Has_sqrt& rt_has_sqrt() { static RT_Has_sqrt has_sqrt; return has_sqrt; } static FT_Has_sqrt ft_has_sqrt() { static FT_Has_sqrt has_sqrt; return has_sqrt; } class Line_2 { private: RT a_, b_, c_; public: Line_2() : a_(1), b_(0), c_(0) {} Line_2(const RT& a, const RT& b, const RT& c) : a_(a), b_(b), c_(c) {} RT a() const { return a_; } RT b() const { return b_; } RT c() const { return c_; } Oriented_side oriented_side(const Point_2& p) const { Sign s = CGAL::sign(a_ * p.x() + b_ * p.y() + c_); if ( s == ZERO ) { return ON_ORIENTED_BOUNDARY; } return (s == POSITIVE) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } }; class Homogeneous_point_2 { private: RT hx_, hy_, hw_; public: Homogeneous_point_2() : hx_(0), hy_(0), hw_(1) {} Homogeneous_point_2(const RT& hx, const RT& hy, const RT& hw) : hx_(hx), hy_(hy), hw_(hw) { CGAL_precondition( !(CGAL::is_zero(hw_)) ); } Homogeneous_point_2(const Point_2& p) : hx_(p.x()), hy_(p.y()), hw_(1) {} Homogeneous_point_2(const Homogeneous_point_2& other) : hx_(other.hx_), hy_(other.hy_), hw_(other.hw_) {} RT hx() const { return hx_; } RT hy() const { return hy_; } RT hw() const { return hw_; } FT x() const { return hx_ / hw_; } FT y() const { return hy_ / hw_; } }; public: //------------------------------------------------------------------- // CONVERSIONS //------------------------------------------------------------------- static FT compute_sqrt(const FT& x, const Tag_true&) { return CGAL::sqrt( x ); } static FT compute_sqrt(const FT& x, const Tag_false&) { return FT( CGAL::sqrt( CGAL::to_double(x) ) ); } static FT to_ft(const Sqrt_1& x) { FT sqrt_c = compute_sqrt( x.c(), ft_has_sqrt() ); return x.a() + x.b() * sqrt_c; } static FT to_ft(const Sqrt_3& x) { FT sqrt_e = compute_sqrt( to_ft(x.e()), ft_has_sqrt() ); FT sqrt_f = compute_sqrt( to_ft(x.f()), ft_has_sqrt() ); FT sqrt_ef = sqrt_e * sqrt_f; return to_ft(x.a()) + to_ft(x.b()) * sqrt_e + to_ft(x.c()) * sqrt_f + to_ft(x.d()) * sqrt_ef; } public: // compute_supporting_line(q.supporting_segment(), a1, b1, c1); // compute_supporting_line(r.supporting_segment(), a2, b2, c2); //------------------------------------------------------------------- // BASIC CONSTRUCTIONS //------------------------------------------------------------------- #if 1 static Line_2 compute_supporting_line(const Site_2& s) { RT a, b, c; compute_supporting_line(s, a, b, c); return Line_2(a, b, c); } static void compute_supporting_line(const Site_2& s, RT& a, RT& b, RT& c) { a = s.source().y() - s.target().y(); b = s.target().x() - s.source().x(); c = s.source().x() * s.target().y() - s.target().x() * s.source().y(); } #else static Line_2 compute_supporting_line(const Segment_2& s) { RT a, b, c; compute_supporting_line(s, a, b, c); return Line_2(a, b, c); } static void compute_supporting_line(const Segment_2& s, RT& a, RT& b, RT& c) { a = s.source().y() - s.target().y(); b = s.target().x() - s.source().x(); c = s.source().x() * s.target().y() - s.target().x() * s.source().y(); } #endif static Homogeneous_point_2 compute_projection(const Line_2& l, const Point_2& p) { RT ab = l.a() * l.b(); RT hx = CGAL::square(l.b()) * p.x() - ab * p.y() - l.a() * l.c(); RT hy = CGAL::square(l.a()) * p.y() - ab * p.x() - l.b() * l.c(); RT hw = CGAL::square(l.a()) + CGAL::square(l.b()); return Homogeneous_point_2(hx, hy, hw); } static Homogeneous_point_2 projection_on_line(const Line_2& l, const Point_2& p) { RT ab = l.a() * l.b(); RT hx = CGAL::square(l.b()) * p.x() - ab * p.y() - l.a() * l.c(); RT hy = CGAL::square(l.a()) * p.y() - ab * p.x() - l.b() * l.c(); RT hw = CGAL::square(l.a()) + CGAL::square(l.b()); return Homogeneous_point_2(hx, hy, hw); } static Homogeneous_point_2 midpoint(const Point_2& p1, const Point_2& p2) { RT hx = p1.x() + p2.x(); RT hy = p1.y() + p2.y(); RT hw = RT(2); return Homogeneous_point_2(hx, hy, hw); } static Homogeneous_point_2 midpoint(const Homogeneous_point_2& p1, const Homogeneous_point_2& p2) { RT hx = p1.hx() * p2.hw() + p2.hx() * p1.hw(); RT hy = p1.hy() * p2.hw() + p2.hy() * p1.hw(); RT hw = RT(2) * p1.hw() * p2.hw(); return Homogeneous_point_2(hx, hy, hw); } static Line_2 compute_perpendicular(const Line_2& l, const Point_2& p) { RT a, b, c; a = -l.b(); b = l.a(); c = l.b() * p.x() - l.a() * p.y(); return Line_2(a, b, c); } static Line_2 opposite_line(const Line_2& l) { return Line_2(-l.a(), -l.b(), -l.c()); } static RT compute_squared_distance(const Point_2& p, const Point_2& q) { return CGAL::square(p.x() - q.x()) + CGAL::square(p.y() - q.y()); } static std::pair compute_squared_distance(const Point_2& p, const Line_2& l) { RT d2 = CGAL::square(l.a() * p.x() + l.b() * p.y() + l.c()); RT n2 = CGAL::square(l.a()) + CGAL::square(l.b()); return std::pair(d2, n2); } public: //------------------------------------------------------------------- // BASIC PREDICATES //------------------------------------------------------------------- static Comparison_result compare_squared_distances_to_line(const Line_2& l, const Point_2& p, const Point_2& q) { RT d2_lp = CGAL::square(l.a() * p.x() + l.b() * p.y() + l.c()); RT d2_lq = CGAL::square(l.a() * q.x() + l.b() * q.y() + l.c()); return CGAL::compare(d2_lp, d2_lq); } static Comparison_result compare_squared_distances_to_lines(const Point_2& p, const Line_2& l1, const Line_2& l2) { RT d2_l1 = CGAL::square(l1.a() * p.x() + l1.b() * p.y() + l1.c()); RT d2_l2 = CGAL::square(l2.a() * p.x() + l2.b() * p.y() + l2.c()); RT n1 = CGAL::square(l1.a()) + CGAL::square(l1.b()); RT n2 = CGAL::square(l2.a()) + CGAL::square(l2.b()); return CGAL::compare(d2_l1 * n2, d2_l2 * n1); } static Oriented_side oriented_side_of_line(const Line_2& l, const Point_2& p) { Sign s = CGAL::sign(l.a() * p.x() + l.b() * p.y() + l.c()); if ( s == ZERO ) { return ON_ORIENTED_BOUNDARY; } return ( s == POSITIVE ) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } static Oriented_side oriented_side_of_line(const Line_2& l, const Homogeneous_point_2& p) { Sign s1 = CGAL::sign(l.a() * p.hx() + l.b() * p.hy() + l.c() * p.hw()); Sign s_hw = CGAL::sign(p.hw()); Sign s = Sign(s1 * s_hw); if ( s == ZERO ) { return ON_ORIENTED_BOUNDARY; } return ( s == POSITIVE ) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } static bool is_on_positive_halfspace(const Line_2& l, const Segment_2& s) { Oriented_side os1, os2; os1 = oriented_side_of_line(l, s.source()); os2 = oriented_side_of_line(l, s.target()); return ( (os1 == ON_POSITIVE_SIDE && os2 != ON_NEGATIVE_SIDE) || (os1 != ON_NEGATIVE_SIDE && os2 == ON_POSITIVE_SIDE) ); } }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_BASIC_PREDICATES_C2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_compare_y_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_compare0000644000175000017500000000315711344301501031337 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_compare_y_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_COMPARE_Y_2_H #define CGAL_SVD_COMPARE_Y_2_H CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------- // compare y //----------------------------------------------------------------------- template< class K > class Svd_compare_y_2 { public: typedef typename K::Site_2 Site_2; typedef typename K::Point_2 Point_2; typedef Comparison_result result_type; typedef Arity_tag<2> Arity; private: typedef typename K::Compare_y_2 compare_y_2; public: result_type operator()(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_point() && q.is_point() ); return compare_y_2()( p.point(), q.point() ); } }; CGAL_END_NAMESPACE #endif // CGAL_SVD_COMPARE_Y_2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_finite_edge_test_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_finite_0000644000175000017500000004275411344301501031211 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_finite_edge_test_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_FINITE_EDGE_TEST_C2_H #define CGAL_AG2_FINITE_EDGE_TEST_C2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template< class K > class Orientation_wrt_symmetry_axis { public: typedef typename K::Point_2 Point_2; typedef CGAL::Voronoi_circle Voronoi_circle; typedef typename K::FT FT; public: Orientation operator()(const Voronoi_circle& vc, const Point_2& p1, const Point_2& p2, const Sqrt_field_tag&) const { FT a = vc.a1() + vc.a2() * CGAL::sqrt(vc.delta()); FT b = vc.b1() + vc.b2() * CGAL::sqrt(vc.delta()); FT det = a * (p2.y() - p1.y()) - b * (p2.x() - p1.x()); return CGAL::sign(det); } Orientation operator()(const Voronoi_circle& vc, const Point_2& p1, const Point_2& p2, const Ring_tag&) const { FT dx = p2.x() - p1.x(); FT dy = p2.y() - p1.y(); FT A = vc.a1() * dy - vc.b1() * dx; FT B = vc.a2() * dy - vc.b2() * dx; return sign_a_plus_b_x_sqrt_c(A, B, vc.delta()); } }; //-------------------------------------------------------------------- template< class K > class Compare_Voronoi_radii { public: typedef CGAL::Voronoi_circle Voronoi_circle; typedef typename K::FT FT; private: Sign sign_of_P4(const FT& u, const FT& v, const FT& du, const FT& dv, const FT& dr, const FT& Du, const FT& Dv, const FT& Dr) const { std::pair factors = factors_of_P4(u, v, du, dv, dr, Du, Dv, Dr); Sign s1 = CGAL::sign(factors.first); Sign s2 = CGAL::sign(factors.second); return (s1 * s2); } std::pair factors_of_P4(const FT& u, const FT& v, const FT& du, const FT& dv, const FT& dr, const FT& Du, const FT& Dv, const FT& Dr) const { FT u2 = CGAL::square(u); FT v2 = CGAL::square(v); FT du2 = CGAL::square(du); FT Du2 = CGAL::square(Du); FT dv2 = CGAL::square(dv); FT Dv2 = CGAL::square(Dv); FT dr2 = CGAL::square(dr); FT Dr2 = CGAL::square(Dr); FT u2_P_v2 = u2 + v2; FT u2_M_v2 = u2 - v2; FT uv = FT(2) * u * v; FT drDr = FT(2) * dr * Dr; FT du2_P_dv2 = du2 + dv2; FT Du2_P_Dv2 = Du2 + Dv2; FT uU_P_vV = du * Du + dv * Dv; FT uU_M_vV = du * Du - dv * Dv; FT uV_P_Uv = du * Dv + Du * dv; FT uV_M_Uv = du * Dv - Du * dv; FT F1 = du2_P_dv2 * Dr2 + Du2_P_Dv2 * dr2 - uU_P_vV * drDr - CGAL::square(uV_M_Uv); FT F2 = CGAL::square(u2_P_v2) * (du2_P_dv2 * Dr2 + Du2_P_Dv2 * dr2); F2 -= u2_P_v2 * (u2_M_v2 * uU_M_vV + uv * uV_P_Uv) * drDr; F2 -= CGAL::square(u2_M_v2 * uV_P_Uv - uv * uU_M_vV); std::pair factors(F1,F2); return factors; } public: Comparison_result operator()(const Voronoi_circle& vc1, const Voronoi_circle& vc2, const Sqrt_field_tag&) const { FT c1 = (vc1.c1() + vc1.c2() * CGAL::sqrt(vc1.delta())) / vc1.d(); FT c2 = (vc2.c1() + vc2.c2() * CGAL::sqrt(vc2.delta())) / vc2.d(); Comparison_result r = CGAL::compare(c2, c1); return r; } // this is the naive way but without divisions and square roots; the // degree becomes 36 in this case. /* Comparison_result operator()(const Voronoi_circle& vc1, const Voronoi_circle& vc2, Ring_tag) { FT A = vc1.c1() * vc2.d() - vc2.c1() * vc1.d(); FT B = vc1.c2() * vc2.d(); FT C = -vc2.c2() * vc1.d(); FT E = vc1.delta(); FT F = vc2.delta(); Sign s = sign_a_plus_b_x_sqrt_e_plus_c_x_sqrt_f(A,B,C,E,F); if ( s == ZERO ) { return EQUAL; } return ( s == POSITIVE ) ? SMALLER : LARGER; } */ Comparison_result operator()(const Voronoi_circle& vc1, const Voronoi_circle& vc2, const Ring_tag&) const { bool is_first_root1 = vc1.is_first_root(); bool is_first_root2 = vc2.is_first_root(); CGAL_precondition( CGAL::is_positive(vc1.alpha()) ); CGAL_precondition( CGAL::is_positive(vc2.alpha()) ); Comparison_result r; if ( is_first_root1 && is_first_root2 ) { r = ke_compare_l1_l2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } else if ( is_first_root1 && !is_first_root2 ) { r = ke_compare_l1_r2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } else if ( !is_first_root1 && is_first_root2 ) { r = ke_compare_r1_l2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } else { r = ke_compare_r1_r2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } #ifdef COMPARATOR_PROFILER if ( comparator_profiler::count_cases ) { // count cases only for the tree r1-r2 if ( !is_first_root1 && !is_first_root2 ) { comparator_profiler::count_case(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } } #endif if ( r == EQUAL ) { return EQUAL; } return ( r == LARGER ) ? SMALLER : LARGER; } // this uses the DFMT trees; slightly slower but same degree (20). /* Comparison_result operator()(const Voronoi_circle& vc1, const Voronoi_circle& vc2, Ring_tag) { bool is_first_root1 = vc1.is_first_root(); bool is_first_root2 = vc2.is_first_root(); CGAL_precondition( CGAL::is_positive(vc1.alpha()) ); CGAL_precondition( CGAL::is_positive(vc2.alpha()) ); Comparison_result r; if ( is_first_root1 && is_first_root2 ) { r = dfmt_compare_l1_l2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } else if ( is_first_root1 && !is_first_root2 ) { r = dfmt_compare_l1_r2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } else if ( !is_first_root1 && is_first_root2 ) { r = dfmt_compare_r1_l2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } else { r = dfmt_compare_r1_r2(vc1.alpha(), vc1.beta(), vc1.gamma(), vc2.alpha(), vc2.beta(), vc2.gamma()); } if ( r == EQUAL ) { return EQUAL; } return ( r == LARGER ) ? SMALLER : LARGER; } */ }; //-------------------------------------------------------------------- template< class K > class Order_on_finite_bisector { public: typedef CGAL::Voronoi_circle Voronoi_circle; typedef typename K::Site_2 Site_2; typedef typename K::FT FT; typedef CGAL::Orientation_wrt_symmetry_axis Orientation_wrt_symmetry_axis; typedef CGAL::Compare_Voronoi_radii Compare_Voronoi_radii; public: template Comparison_result operator()(const Voronoi_circle& vc1, const Voronoi_circle& vc2, const Site_2& p1, const Site_2& p2, const Method_tag& tag) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::order_on_bisector_counter++; #endif Orientation o1 = Orientation_wrt_symmetry_axis()(vc1, p1.point(), p2.point(), tag); Orientation o2 = Orientation_wrt_symmetry_axis()(vc2, p1.point(), p2.point(), tag); Comparison_result cr; if ( o1 == LEFT_TURN ) { if ( o2 != LEFT_TURN ) { return SMALLER; } Comparison_result r = Compare_Voronoi_radii()(vc1, vc2, tag); if ( r == EQUAL ) { cr = EQUAL; } else { cr = (r == LARGER ) ? SMALLER : LARGER; } } else if ( o1 == COLLINEAR ) { if ( o2 == COLLINEAR ) { cr = EQUAL; } else { cr = (o2 == LEFT_TURN) ? LARGER : SMALLER; } } else { if ( o2 != RIGHT_TURN ) { cr = LARGER; } else { Comparison_result r = Compare_Voronoi_radii()(vc1, vc2, tag); cr = r; } } return cr; } }; //-------------------------------------------------------------------- template < class K > class Finite_edge_test { public: typedef typename K::Site_2 Site_2; typedef CGAL::Weighted_point_inverter Weighted_point_inverter; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Voronoi_radius Voronoi_radius; typedef CGAL::Voronoi_circle Voronoi_circle; typedef CGAL::Bitangent_line Bitangent_line; typedef typename K::FT FT; typedef CGAL::Bounded_side_of_CCW_circle Bounded_side_of_CCW_circle; typedef CGAL::Sign_of_distance_from_bitangent_line Sign_of_distance_from_bitangent_line; typedef CGAL::Sign_of_distance_from_CCW_circle Sign_of_distance_from_CCW_circle; typedef CGAL::Order_on_finite_bisector Order_on_finite_bisector; public: template bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b, const Method_tag& tag) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::shadow_region_type_counter++; #endif // Weighted_point_inverter inverter(p1); Inverted_weighted_point u2 = inverter(p2); Inverted_weighted_point v = inverter(q); // Voronoi_radius vr_12q(u2, v); Voronoi_radius vr_1q2 = vr_12q.get_symmetric(); Bounded_side bs1 = Bounded_side_of_CCW_circle()(vr_12q, tag ); Bounded_side bs2 = Bounded_side_of_CCW_circle()(vr_1q2, tag ); bool is_bs1 = (bs1 == ON_UNBOUNDED_SIDE); bool is_bs2 = (bs2 == ON_UNBOUNDED_SIDE); // both the ccw and cw circles do not exist if ( !is_bs1 && !is_bs2 ) { return b; } // the ccw circle exists but not the cw if ( is_bs1 && !is_bs2 ) { return b; } // the cw circle exists but not the ccw if ( !is_bs1 && is_bs2 ) { return b; } // both circles exist // check whether the shadow region is connected, i.e., wether it is // of the form (a, b) or (-oo, a) U (b, +oo) Bitangent_line bl_12(p1, p2); Sign stc = Sign_of_distance_from_bitangent_line()(bl_12, q, tag); CGAL_assertion( stc != ZERO ); bool is_shadow_region_connected = (stc == POSITIVE); if ( is_shadow_region_connected ) { if ( b ) { return true; } Inverted_weighted_point u3 = inverter(p3); Bitangent_line blinv_23(u2, u3); Voronoi_circle vc_123(blinv_23); Voronoi_circle vc_12q(vr_12q); Comparison_result r = Order_on_finite_bisector()(vc_123, vc_12q, p1, p2, tag); if ( r != SMALLER ) { return false; } Inverted_weighted_point u4 = inverter(p4); Bitangent_line blinv_42(u4, u2); Voronoi_circle vc_142(blinv_42); Voronoi_circle vc_1q2(vr_1q2); r = Order_on_finite_bisector()(vc_142, vc_1q2, p1, p2, tag); return ( r == LARGER ); } // the shadow region is of the form (-oo, a) U (b, +oo) if ( !b ) { return false; } Inverted_weighted_point u3 = inverter(p3); Bitangent_line blinv_23(u2, u3); Voronoi_circle vc_123(blinv_23); Voronoi_circle vc_1q2(vr_1q2); Comparison_result r = Order_on_finite_bisector()(vc_123, vc_1q2, p1, p2, tag); if ( r != SMALLER ) { return true; } Inverted_weighted_point u4 = inverter(p4); Bitangent_line blinv_42(u4, u2); Voronoi_circle vc_142(blinv_42); Voronoi_circle vc_12q(vr_12q); r = Order_on_finite_bisector()(vc_142, vc_12q, p1, p2, tag); return ( r != LARGER ); } }; //-------------------------------------------------------------------- template < class K > class Finite_edge_test_degenerated { public: typedef typename K::Site_2 Site_2; typedef CGAL::Weighted_point_inverter Weighted_point_inverter; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Voronoi_radius Voronoi_radius; typedef CGAL::Voronoi_circle Voronoi_circle; typedef CGAL::Bitangent_line Bitangent_line; typedef typename K::FT FT; typedef CGAL::Bounded_side_of_CCW_circle Bounded_side_of_CCW_circle; typedef CGAL::Sign_of_distance_from_bitangent_line Sign_of_distance_from_bitangent_line; typedef CGAL::Sign_of_distance_from_CCW_circle Sign_of_distance_from_CCW_circle; typedef CGAL::Order_on_finite_bisector Order_on_finite_bisector; public: template bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q, bool b, const Method_tag& tag) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::shadow_region_type_counter++; #endif // Weighted_point_inverter inverter(p1); Inverted_weighted_point u2 = inverter(p2); Inverted_weighted_point v = inverter(q); Voronoi_radius vr_12q(u2, v); Voronoi_radius vr_1q2 = vr_12q.get_symmetric(); Bounded_side bs1 = Bounded_side_of_CCW_circle()(vr_12q, tag ); Bounded_side bs2 = Bounded_side_of_CCW_circle()(vr_1q2, tag ); bool is_bs1 = (bs1 == ON_UNBOUNDED_SIDE); bool is_bs2 = (bs2 == ON_UNBOUNDED_SIDE); // both the ccw and cw circles do not exist if ( !is_bs1 && !is_bs2 ) { return b; } // the ccw circle exists but not the cw if ( is_bs1 && !is_bs2 ) { return b; } // the cw circle exists but not the ccw if ( !is_bs1 && is_bs2 ) { return b; } // both circles exist // check whether the shadow region is connected, i.e., wether it is // of the form (a, b) or (-oo, a) U (b, +oo) Bitangent_line bl_12(p1, p2); Sign stc = Sign_of_distance_from_bitangent_line()(bl_12, q, tag); Inverted_weighted_point u3 = inverter(p3); Bitangent_line blinv_23(u2, u3); CGAL_assertion( stc != ZERO ); bool is_shadow_region_connected = (stc == POSITIVE); if ( is_shadow_region_connected ) { // the shadow region is of the form (a, b) if ( b ) { return false; } Voronoi_circle vc_123(blinv_23); Voronoi_circle vc_12q(vr_12q); Comparison_result r = Order_on_finite_bisector()(vc_123, vc_12q, p1, p2, tag); return ( r == SMALLER ); } // the shadow region is of the form (-oo, a) U (b, +oo) if ( !b ) { return false; } Voronoi_circle vc_123(blinv_23); Voronoi_circle vc_1q2(vr_1q2); Comparison_result r = Order_on_finite_bisector()(vc_123, vc_1q2, p1, p2, tag); return ( r != SMALLER ); } template bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& q, bool b, const Method_tag& tag) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::shadow_region_type_counter++; #endif // Weighted_point_inverter inverter(p1); Inverted_weighted_point u2 = inverter(p2); Inverted_weighted_point v = inverter(q); Voronoi_radius vr_12q(u2, v); Voronoi_radius vr_1q2 = vr_12q.get_symmetric(); Bounded_side bs1 = Bounded_side_of_CCW_circle()(vr_12q, tag ); Bounded_side bs2 = Bounded_side_of_CCW_circle()(vr_1q2, tag ); bool is_bs1 = (bs1 == ON_UNBOUNDED_SIDE); bool is_bs2 = (bs2 == ON_UNBOUNDED_SIDE); // both the ccw and cw circles do not exist if ( !is_bs1 && !is_bs2 ) { return b; } // only the ccw circle exists if ( is_bs1 && !is_bs2 ) { return false; } // only the cw circle exists if ( !is_bs1 && is_bs2 ) { return false; } // both circles exist // check whether the shadow region is connected, i.e., wether it is // of the form (a, b) or (-oo, a) U (b, +oo) return !b; } }; //-------------------------------------------------------------------- template class Ag2_finite_edge_test_C2 { public: typedef K Kernel; typedef MTag Method_tag; typedef typename K::Site_2 Site_2; private: typedef CGAL::Finite_edge_test_degenerated Test_degenerated; typedef CGAL::Finite_edge_test Test; public: typedef bool result_type; struct argument_type {}; struct Arity {}; inline bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& q, bool b) const { return Test_degenerated()(p1, p2, q, b, Method_tag()); } inline bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q, bool b) const { return Test_degenerated()(p1, p2, p3, q, b, Method_tag()); } inline bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b) const { return Test()(p1, p2, p3, p4, q, b, Method_tag()); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_FINITE_EDGE_TEST_C2_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_infinite_edge_interior_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_infinit0000644000175000017500000000703311344301501031346 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_infinite_edge_interior_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_INFINITE_EDGE_INTERIOR_2_H #define CGAL_SVD_INFINITE_EDGE_INTERIOR_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------------- template class Svd_infinite_edge_interior_2 { public: typedef typename K::Site_2 Site_2; typedef typename K::RT RT; typedef Svd_are_same_points_C2 Are_same_points_2; typedef Svd_are_same_segments_C2 Are_same_segments_2; typedef bool result_type; struct argument_type {}; typedef Arity_tag<5> Arity; private: Are_same_points_2 same_points; Are_same_segments_2 same_segments; public: bool operator()(const Site_2& q, const Site_2& s, const Site_2& r, const Site_2& t, Sign sgn) const { if ( t.is_segment() ) { return false; } if ( q.is_segment() ) { // in this case r and s must be endpoints of q return ( sgn == NEGATIVE ); } if ( s.is_point() && r.is_point() && same_points(s, r) ) { // MK::ERROR: write this code using the compare_x_2 and // compare_y_2 predicates instead of computing the inner // product... RT dtsx = s.point().x() - t.point().x(); RT dtsy = s.point().y() - t.point().y(); RT dtqx = q.point().x() - t.point().x(); RT minus_dtqy = -q.point().y() + t.point().y(); Sign sgn1 = sign_of_determinant2x2(dtsx, dtsy, minus_dtqy, dtqx); CGAL_assertion( sgn1 != ZERO ); return (sgn1 == POSITIVE); } if ( s.is_segment() && r.is_segment() && same_segments(s, r) ) { CGAL_assertion( same_points(q, s.source_site()) || same_points(q, s.target_site()) ); Site_2 ss; if ( same_points(q, s.source_site()) ) { ss = s.target_site(); } else { ss = s.source_site(); } // MK::ERROR: write this code using the compare_x_2 and // compare_y_2 predicates instead of computing the inner // product... RT dtssx = ss.point().x() - t.point().x(); RT dtssy = ss.point().y() - t.point().y(); RT dtqx = q.point().x() - t.point().x(); RT minus_dtqy = -q.point().y() + t.point().y(); Sign sgn1 = sign_of_determinant2x2(dtssx, dtssy, minus_dtqy, dtqx); CGAL_assertion( sgn1 != ZERO ); return (sgn1 == POSITIVE); } return ( sgn == NEGATIVE ); } }; //----------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_INFINITE_EDGE_INTERIOR_2_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_finite_edge_interior_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_finite_0000644000175000017500000005106611344301501031330 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_finite_edge_interior_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_FINITE_EDGE_INTERIOR_2_H #define CGAL_SVD_FINITE_EDGE_INTERIOR_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------------- template class Svd_finite_edge_interior_2 : public Svd_basic_predicates_C2 { public: typedef Svd_basic_predicates_C2 Base; typedef Svd_voronoi_vertex_2 Voronoi_vertex_2; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Line_2 Line_2; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename Base::Homogeneous_point_2 Homogeneous_point_2; private: typedef Svd_are_same_points_C2 Are_same_points_2; typedef Svd_are_same_segments_C2 Are_same_segments_2; typedef typename K::Intersections_tag ITag; private: Are_same_points_2 same_points; Are_same_segments_2 same_segments; private: //-------------------------------------------------------------------- //-------------------------------------------------------------------- //-------------------------------------------------------------------- bool is_interior_in_conflict_both(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { bool in_conflict(false); if ( p.is_point() && q.is_point() ) { in_conflict = is_interior_in_conflict_both_pp(p, q, r, s, t, tag); } else if ( p.is_segment() && q.is_segment() ) { in_conflict = is_interior_in_conflict_both_ss(p, q, r, s, t, tag); } else if ( p.is_point() && q.is_segment() ) { in_conflict = is_interior_in_conflict_both_ps(p, q, r, s, t, tag); } else { // p is a segment and q is a point in_conflict = is_interior_in_conflict_both_sp(p, q, r, s, t, tag); } return in_conflict; } //-------------------------------------------------------------------- bool is_interior_in_conflict_both_pp(const Site_2& sp, const Site_2& sq, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { CGAL_precondition( sp.is_point() && sq.is_point() ); Point_2 p = sp.point(), q = sq.point(); if ( t.is_point() ) { return true; } Line_2 lt = compute_supporting_line(t.supporting_site()); Oriented_side op, oq; if ( same_points(sp, t.source_site()) || same_points(sp, t.target_site()) ) { op = ON_ORIENTED_BOUNDARY; } else { op = oriented_side_of_line(lt, p); } if ( same_points(sq, t.source_site()) || same_points(sq, t.target_site()) ) { oq = ON_ORIENTED_BOUNDARY; } else { oq = oriented_side_of_line(lt, q); } if ((op == ON_POSITIVE_SIDE && oq == ON_NEGATIVE_SIDE) || (op == ON_NEGATIVE_SIDE && oq == ON_POSITIVE_SIDE) || (op == ON_ORIENTED_BOUNDARY || oq == ON_ORIENTED_BOUNDARY)) { return true; } Comparison_result res = compare_squared_distances_to_line(lt, p, q); if ( res == EQUAL ) { return true; } Voronoi_vertex_2 vpqr(sp, sq, r); Voronoi_vertex_2 vqps(sq, sp, s); Line_2 lperp; if ( res == SMALLER ) { // p is closer to lt than q lperp = compute_perpendicular(lt, p); } else { // q is closer to lt than p lperp = compute_perpendicular(lt, q); } Oriented_side opqr = vpqr.oriented_side(lperp); Oriented_side oqps = vqps.oriented_side(lperp); return ( opqr == oqps ); } //-------------------------------------------------------------------- bool is_interior_in_conflict_both_ss(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag) const { CGAL_precondition( p.is_segment() && q.is_segment() ); return true; } //-------------------------------------------------------------------- bool is_interior_in_conflict_both_ps(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { CGAL_precondition( p.is_point() && q.is_segment() ); if ( same_points(p, q.source_site()) || same_points(p, q.target_site()) ) { return false; } if ( t.is_point() ) { return is_interior_in_conflict_both_ps_p(p, q, r, s, t, tag); } return is_interior_in_conflict_both_ps_s(p, q, r, s, t, tag); } //-------------------------------------------------------------------- bool is_interior_in_conflict_both_ps_p(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { CGAL_precondition( t.is_point() ); // Line_2 lq = compute_supporting_line(q); Line_2 lq = compute_supporting_line(q.supporting_site()); Comparison_result res = compare_squared_distances_to_line(lq, p.point(), t.point()); if ( res != SMALLER ) { return true; } Voronoi_vertex_2 vpqr(p, q, r); Voronoi_vertex_2 vqps(q, p, s); Line_2 lperp = compute_perpendicular(lq, p.point()); Oriented_side opqr = vpqr.oriented_side(lperp); Oriented_side oqps = vqps.oriented_side(lperp); return (opqr == oqps); } //-------------------------------------------------------------------- bool check_if_exact(const Site_2& t1, const Tag_false&) const { return true; } bool check_if_exact(const Site_2& t1, const Tag_true&) const { return t1.is_input(); } bool is_interior_in_conflict_both_ps_s(const Site_2& sp, const Site_2& sq, const Site_2& r, const Site_2& s, const Site_2& st, Method_tag tag) const { CGAL_precondition( st.is_segment() ); Point_2 p = sp.point(); // Segment_2 q = sq.segment(), t = st.segment(); Line_2 lq = compute_supporting_line(sq.supporting_site()); if ( oriented_side_of_line(lq, p) == ON_NEGATIVE_SIDE ) { lq = opposite_line(lq); } if ( same_points(sp, st.source_site()) || same_points(sp, st.target_site()) ) { Line_2 lqperp = compute_perpendicular(lq, p); Voronoi_vertex_2 vpqr(sp, sq, r); Voronoi_vertex_2 vqps(sq, sp, s); Oriented_side opqr = vpqr.oriented_side(lqperp); Oriented_side oqps = vqps.oriented_side(lqperp); bool on_different_parabola_arcs = ((opqr == ON_NEGATIVE_SIDE && oqps == ON_POSITIVE_SIDE) || (opqr == ON_POSITIVE_SIDE && oqps == ON_NEGATIVE_SIDE)); if ( !on_different_parabola_arcs ) { return true; } Site_2 t1; if ( same_points(sp, st.source_site()) ) { t1 = st.target_site(); } else { t1 = st.source_site(); } Oriented_side o_t1; if ( same_points(t1, sq.source_site()) || same_points(t1, sq.target_site()) ) { o_t1 = ON_ORIENTED_BOUNDARY; } else if ( !check_if_exact(t1, ITag()) && ( same_segments(t1.supporting_site(0), sq.supporting_site()) || same_segments(t1.supporting_site(1), sq.supporting_site()) ) ) { o_t1 = ON_ORIENTED_BOUNDARY; } else { o_t1 = oriented_side_of_line(lq, t1.point()); } if ( o_t1 == ON_NEGATIVE_SIDE ) { return true; } Comparison_result res = compare_squared_distances_to_line(lq, p, t1.point()); return ( res == LARGER ); } Line_2 lt = compute_supporting_line(st.supporting_site()); if ( oriented_side_of_line(lt, p) == ON_NEGATIVE_SIDE ) { lt = opposite_line(lt); } Comparison_result res = CGAL::compare(lt.a() * lq.b(), lt.b() * lq.a()); bool are_parallel = (res == EQUAL); if ( are_parallel ) { Sign sgn = CGAL::sign(lt.a() * lq.a() + lt.b() * lq.b()); bool have_opposite_directions = (sgn == NEGATIVE); if ( have_opposite_directions ) { lq = opposite_line(lq); } if ( oriented_side_of_line(lq, p) == oriented_side_of_line(lt, p) ) { return true; } if ( have_opposite_directions ) { lq = opposite_line(lq); } } Line_2 l = compute_perpendicular(lt, p); Voronoi_vertex_2 vpqr(sp, sq, r); Voronoi_vertex_2 vqps(sq, sp, s); Oriented_side o_l_pqr = vpqr.oriented_side(l); Oriented_side o_l_qps = vqps.oriented_side(l); if ( o_l_pqr == ON_POSITIVE_SIDE && o_l_qps == ON_NEGATIVE_SIDE ) { return false; } if ( o_l_pqr == ON_NEGATIVE_SIDE && o_l_qps == ON_POSITIVE_SIDE ) { return true; } //>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> //>>>>>>>>>> HERE I NEED TO CHECK THE BOUNDARY CASES <<<<<< //<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Line_2 lqperp = compute_perpendicular(lq, p); Oriented_side opqr = vpqr.oriented_side(lqperp); Oriented_side oqps = vqps.oriented_side(lqperp); bool on_different_parabola_arcs = ((opqr == ON_NEGATIVE_SIDE && oqps == ON_POSITIVE_SIDE) || (opqr == ON_POSITIVE_SIDE && oqps == ON_NEGATIVE_SIDE)); if ( !on_different_parabola_arcs ) { return true; } Homogeneous_point_2 pv = projection_on_line(lq, p); Homogeneous_point_2 hp(p); pv = Base::midpoint(pv, hp); Oriented_side o_l_pv = oriented_side_of_line(l, pv); CGAL_assertion( o_l_pv != ON_ORIENTED_BOUNDARY ); CGAL_assertion( o_l_pqr != ON_ORIENTED_BOUNDARY || o_l_qps != ON_ORIENTED_BOUNDARY ); if ( o_l_pqr == ON_ORIENTED_BOUNDARY ) { return ( o_l_qps == o_l_pv ); } else { return ( o_l_pqr == o_l_pv ); } } //-------------------------------------------------------------------- bool is_interior_in_conflict_both_sp(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { return is_interior_in_conflict_both_ps(q, p, s, r, t, tag); } //------------------------------------------------------------------------ //------------------------------------------------------------------------ //------------------------------------------------------------------------ bool is_interior_in_conflict_touch(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { // checks if interior of voronoi edge is in conflict if both extrema // of the voronoi edge touch the corresponding circles. // return true if interior is in conflict; false otherwise if ( t.is_segment() ) { return false; } #if 1 CGAL_assertion( p.is_segment() || q.is_segment() ); Voronoi_vertex_2 vpqr(p, q, r); Voronoi_vertex_2 vqps(q, p, s); if ( vpqr.incircle_no_easy(s) == ZERO && vqps.incircle_no_easy(r) == ZERO ) { return false; } if ( p.is_segment() && q.is_segment() ) { return true; } #else // OLD CODE: buggy if the edge is degenerate if ( (p.is_point() && q.is_point()) || (p.is_segment() && q.is_segment()) ) { return true; } #endif if ( p.is_point() && q.is_segment() ) { Line_2 lq = compute_supporting_line(q.supporting_site()); Comparison_result res = compare_squared_distances_to_line(lq, p.point(), t.point()); return (res != SMALLER); } return is_interior_in_conflict_touch(q, p, s, r, t, tag); } //------------------------------------------------------------------------ //------------------------------------------------------------------------ //------------------------------------------------------------------------ bool is_interior_in_conflict_none(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { if ( t.is_segment() ) { return false; } bool in_conflict(false); if ( p.is_point() && q.is_point() ) { in_conflict = is_interior_in_conflict_none_pp(p, q, r, s, t, tag); } else if ( p.is_point() && q.is_segment() ) { in_conflict = is_interior_in_conflict_none_ps(p, q, r, s, t, tag); } else if ( p.is_segment() && q.is_point() ) { in_conflict = is_interior_in_conflict_none_sp(p, q, r, s, t, tag); } else { // both p and q are segments in_conflict = is_interior_in_conflict_none_ss(p, q, r, s, t, tag); } return in_conflict; } //------------------------------------------------------------------------ bool is_interior_in_conflict_none_pp(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { CGAL_precondition( p.is_point() && q.is_point() && t.is_point() ); return false; } //------------------------------------------------------------------------ bool is_interior_in_conflict_none_ps(const Site_2& sp, const Site_2& sq, const Site_2& r, const Site_2& s, const Site_2& st, Method_tag tag) const { CGAL_precondition( sp.is_point() && sq.is_segment() && st.is_point() ); if ( same_points(sp, sq.source_site()) || same_points(sp, sq.target_site()) ) { return false; } Line_2 lq = compute_supporting_line(sq.supporting_site()); Voronoi_vertex_2 vpqr(sp, sq, r); Voronoi_vertex_2 vqps(sq, sp, s); Point_2 p = sp.point(), t = st.point(); Line_2 lperp = compute_perpendicular(lq, t); Oriented_side op = oriented_side_of_line(lq, p); Oriented_side ot = oriented_side_of_line(lq, t); bool on_same_side = ((op == ON_POSITIVE_SIDE && ot == ON_POSITIVE_SIDE) || (op == ON_NEGATIVE_SIDE && ot == ON_NEGATIVE_SIDE)); Comparison_result res = compare_squared_distances_to_line(lq, t, p); Oriented_side opqr = vpqr.oriented_side(lperp); Oriented_side oqps = vqps.oriented_side(lperp); bool on_different_side = ((opqr == ON_POSITIVE_SIDE && oqps == ON_NEGATIVE_SIDE) || (opqr == ON_NEGATIVE_SIDE && oqps == ON_POSITIVE_SIDE)); return ( on_same_side && (res == SMALLER) && on_different_side ); } //------------------------------------------------------------------------ bool is_interior_in_conflict_none_sp(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { return is_interior_in_conflict_none_ps(q, p, s, r, t, tag); } //------------------------------------------------------------------------ bool is_interior_in_conflict_none_ss(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Method_tag tag) const { CGAL_precondition( p.is_segment() && q.is_segment() && t.is_point() ); Voronoi_vertex_2 vpqr(p, q, r); Voronoi_vertex_2 vqps(q, p, s); Line_2 lp = compute_supporting_line(p.supporting_site()); Line_2 lq = compute_supporting_line(q.supporting_site()); // first orient lp according to its Voronoi vertices if ( vpqr.is_degenerate_Voronoi_circle() ) { Site_2 tpqr = Site_2::construct_site_2(vpqr.degenerate_point()); if ( same_points(tpqr, p.source_site()) || same_points(tpqr, p.target_site()) ) { if ( vqps.oriented_side(lp) != ON_POSITIVE_SIDE ) { lp = opposite_line(lp); } } } else { if ( vpqr.oriented_side(lp) != ON_POSITIVE_SIDE ) { lp = opposite_line(lp); } } #if 0 // OLD CODE if ( ( vpqr.is_degenerate_Voronoi_circle() && same_points(vpqr.degenerate_point(), p.source_site()) ) || ( vpqr.is_degenerate_Voronoi_circle() && same_points(vpqr.degenerate_point(), p.target_site()) ) ) { if ( vqps.oriented_side(lp) != ON_POSITIVE_SIDE ) { lp = opposite_line(lp); } } else { if ( vpqr.oriented_side(lp) != ON_POSITIVE_SIDE ) { lp = opposite_line(lp); } } #endif // then orient lq according to its Voronoi vertices if ( vpqr.is_degenerate_Voronoi_circle() ) { Site_2 tpqr = Site_2::construct_site_2(vpqr.degenerate_point()); if ( same_points(tpqr, q.source_site()) || same_points(tpqr, q.target_site()) ) { if ( vqps.oriented_side(lq) != ON_POSITIVE_SIDE ) { lq = opposite_line(lq); } } } else { if ( vpqr.oriented_side(lq) != ON_POSITIVE_SIDE ) { lq = opposite_line(lq); } } #if 0 // OLD CODE if ( ( vpqr.is_degenerate_Voronoi_circle() && same_points(vpqr.degenerate_point(), q.source_site()) ) || ( vpqr.is_degenerate_Voronoi_circle() && same_points(vpqr.degenerate_point(), q.target_site()) ) ) { if ( vqps.oriented_side(lq) != ON_POSITIVE_SIDE ) { lq = opposite_line(lq); } } else { if ( vpqr.oriented_side(lq) != ON_POSITIVE_SIDE ) { lq = opposite_line(lq); } } #endif Point_2 tp = t.point(); // check if t is on the same side as the Voronoi vertices Oriented_side ot_lp = oriented_side_of_line(lp, tp); Oriented_side ot_lq = oriented_side_of_line(lq, tp); if ( ot_lp != ON_POSITIVE_SIDE || ot_lq != ON_POSITIVE_SIDE ) { return false; } Line_2 lperp; Comparison_result res = compare_squared_distances_to_lines(tp, lp, lq); if ( res == SMALLER ) { lperp = compute_perpendicular(lp, tp); } else { lperp = compute_perpendicular(lq, tp); } CGAL_precondition( ot_lp != ON_ORIENTED_BOUNDARY && ot_lq != ON_ORIENTED_BOUNDARY ); // check of lperp separates the two Voronoi vertices Oriented_side opqr_perp = vpqr.oriented_side(lperp); Oriented_side oqps_perp = vqps.oriented_side(lperp); bool on_different_side = (opqr_perp == ON_POSITIVE_SIDE && oqps_perp == ON_NEGATIVE_SIDE) || (opqr_perp == ON_NEGATIVE_SIDE && oqps_perp == ON_POSITIVE_SIDE); return ( on_different_side ); } //------------------------------------------------------------------------ //------------------------------------------------------------------------ //------------------------------------------------------------------------ public: typedef bool result_type; typedef Site_2 argument_type; struct Arity {}; bool operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Sign sgn) const { if ( sgn == POSITIVE ) { return is_interior_in_conflict_none(p, q, r, s, t, Method_tag()); } else if ( sgn == NEGATIVE ) { return is_interior_in_conflict_both(p, q, r, s, t, Method_tag()); } else { return is_interior_in_conflict_touch(p, q, r, s, t, Method_tag()); } } bool operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& t, Sign sgn) const { if ( t.is_point() ) { return ( sgn == NEGATIVE ); } if ( sgn != NEGATIVE ) { return false; } if ( p.is_segment() || q.is_segment() ) { return false; } bool p_is_endpoint = same_points(p, t.source_site()) || same_points(p, t.target_site()); bool q_is_endpoint = same_points(q, t.source_site()) || same_points(q, t.target_site()); return ( p_is_endpoint && q_is_endpoint ); } bool operator()(const Site_2& p, const Site_2& q, const Site_2& t, Sign sgn) const { if ( p.is_segment() || q.is_segment()) { return false; } // both p and q are points if ( t.is_point() ) { RT dtpx = p.point().x() - t.point().x(); RT minus_dtpy = -p.point().y() + t.point().y(); RT dtqx = q.point().x() - t.point().x(); RT dtqy = q.point().y() - t.point().y(); Sign s1 = sign_of_determinant2x2(dtpx, minus_dtpy, dtqy, dtqx); CGAL_assertion( s1 != ZERO ); return ( s1 == NEGATIVE ); } bool bp = same_points(p, t.source_site()) || same_points(p, t.target_site()); bool bq = same_points(q, t.source_site()) || same_points(q, t.target_site()); return ( bp && bq ); } }; //----------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_FINITE_EDGE_INTERIOR_2_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare_weight_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare0000644000175000017500000000277211344301501031216 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare_weight_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_COMPARE_WEIGHT_2_H #define CGAL_AG2_COMPARE_WEIGHT_2_H #include //-------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE template class Ag2_compare_weight_2 { public: typedef K Kernel; typedef typename K::Site_2 Site_2; typedef Comparison_result result_type; typedef Arity_tag<2> Arity; typedef Site_2 argument_type; inline Comparison_result operator()(const Site_2& s1, const Site_2& s2) const { return CGAL::compare(s1.weight(), s2.weight()); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_COMPARE_WEIGHT_2_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi_vertex_ring_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi0000644000175000017500000011446511344301501031351 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi_vertex_ring_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VERTEX_RING_C2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VERTEX_RING_C2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Svd_voronoi_vertex_ring_C2 : public Svd_basic_predicates_C2 { public: typedef Svd_basic_predicates_C2 Base; typedef enum {PPP = 0, PPS, PSS, SSS} vertex_t; struct PPP_Type {}; struct PPS_Type {}; struct PSS_Type {}; struct SSS_Type {}; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Line_2 Line_2; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename Base::Sqrt_1 Sqrt_1; typedef typename Base::Sqrt_2 Sqrt_2; typedef typename Base::Sqrt_3 Sqrt_3; typedef typename Base::Homogeneous_point_2 Homogeneous_point_2; private: typedef Svd_are_same_points_C2 Are_same_points_C2; typedef Svd_are_same_segments_C2 Are_same_segments_C2; typedef typename K::Intersections_tag ITag; Are_same_points_C2 same_points; Are_same_segments_C2 same_segments; private: //-------------------------------------------------------------------------- void compute_ppp(const Site_2& sp, const Site_2& sq, const Site_2& sr) { CGAL_precondition( sp.is_point() && sq.is_point() && sr.is_point() ); Point_2 p = sp.point(), q = sq.point(), r = sr.point(); v_type = PPP; RT np = CGAL::square(p.x()) + CGAL::square(p.y()); RT nq = CGAL::square(q.x()) + CGAL::square(q.y()); RT nr = CGAL::square(r.x()) + CGAL::square(r.y()); ux_ppp = np * (q.y() - r.y()) + nq * (r.y() - p.y()) + nr * (p.y() - q.y()); uy_ppp = -(np * (q.x() - r.x()) + nq * (r.x() - p.x()) + nr * (p.x() - q.x())); uz_ppp = RT(2) * ( (q.x() * r.y() - r.x() * q.y()) + (r.x() * p.y() - p.x() * r.y()) + (p.x() * q.y() - q.x() * p.y()) ); } //-------------------------------------------------------------------------- void compute_pss(const Site_2& p, const Site_2& q, const Site_2& r) { CGAL_precondition( p.is_point() && q.is_segment() && r.is_segment() ); v_type = PSS; bool pq = same_points(p, q.source_site()) || same_points(p, q.target_site()); bool pr = same_points(p, r.source_site()) || same_points(p, r.target_site()); Point_2 pp = p.point(); if ( pq && pr ) { Sqrt_1 One(RT(1), RT(0), RT(0)); ux = Sqrt_3(pp.x() * One); uy = Sqrt_3(pp.y() * One); uz = Sqrt_3(One); return; } RT a1, b1, c1, a2, b2, c2; compute_supporting_line(q.supporting_site(), a1, b1, c1); compute_supporting_line(r.supporting_site(), a2, b2, c2); RT c1_ = a1 * pp.x() + b1 * pp.y() + c1; RT c2_ = a2 * pp.x() + b2 * pp.y() + c2; if ( pq ) { c1_ = RT(0); } if ( pr ) { c2_ = RT(0); } Sign sgn_c1_ = CGAL::sign(c1_); Sign sgn_c2_ = CGAL::sign(c2_); if ( sgn_c1_ == NEGATIVE ) { a1 = -a1; b1 = -b1; c1_ = -c1_; } else if ( sgn_c1_ == ZERO ) { CGAL_assertion( pq ); if ( same_points(p, q.target_site()) ) { a1 = -a1; b1 = -b1; c1_ = -c1_; } } if ( sgn_c2_ == NEGATIVE ) { a2 = -a2; b2 = -b2; c2_ = -c2_; } else if ( sgn_c2_ == ZERO ) { CGAL_assertion( pr ); if ( same_points(p, r.source_site()) ) { a2 = -a2; b2 = -b2; c2_ = -c2_; } } if ( pq ) { RT J = a1 * c2_; RT I = b1 * c2_; RT n1 = CGAL::square(a1) + CGAL::square(b1); RT n2 = CGAL::square(a2) + CGAL::square(b2); RT D1D2 = n1 * n2; Sqrt_1 Zero(RT(0), RT(0), D1D2); Sqrt_1 vz(-a1 * a2 - b1 * b2, RT(1), D1D2); ux = Sqrt_3(J + pp.x() * vz, Zero, Zero, Zero, Zero, Zero); uy = Sqrt_3(I + pp.y() * vz, Zero, Zero, Zero, Zero, Zero); uz = Sqrt_3(vz, Zero, Zero, Zero, Zero, Zero); } else if ( pr ) { RT J = a2 * c1_; RT I = b2 * c1_; RT n1 = CGAL::square(a1) + CGAL::square(b1); RT n2 = CGAL::square(a2) + CGAL::square(b2); RT D1D2 = n1 * n2; Sqrt_1 Zero(RT(0), RT(0), D1D2); Sqrt_1 vz(-a1 * a2 - b1 * b2, RT(1), D1D2); ux = Sqrt_3(J + pp.x() * vz, Zero, Zero, Zero, Zero, Zero); uy = Sqrt_3(I + pp.y() * vz, Zero, Zero, Zero, Zero, Zero); uz = Sqrt_3(vz, Zero, Zero, Zero, Zero, Zero); } else { Line_2 lq(a1, b1, c1_); Line_2 lr(a2, b2, c2_); compute_pll(pp, lq, lr); } } void compute_pll(const Point_2& p, const Line_2& lq, const Line_2& lr) { RT a1 = lq.a(), b1 = lq.b(), c1_ = lq.c(); RT a2 = lr.a(), b2 = lr.b(), c2_ = lr.c(); CGAL_precondition( c1_ >= RT(0) ); CGAL_precondition( c2_ >= RT(0) ); RT n1 = CGAL::square(a1) + CGAL::square(b1); RT n2 = CGAL::square(a2) + CGAL::square(b2); RT I = b1 * c2_ + b2 * c1_; RT J = a1 * c2_ + a2 * c1_; RT c1c2 = RT(2) * c1_ * c2_; RT a1a2 = a1 * a2; RT b1b2 = b1 * b2; RT D1D2 = n1 * n2; Sqrt_1 Zero(RT(0), RT(0), D1D2); Sqrt_1 One(RT(1), RT(0), D1D2); Sign s1, s2; // compute sigma Sign s_sigma(ZERO); s1 = CGAL::sign(b1); s2 = CGAL::sign(-b2); if ( s1 == ZERO ) { s_sigma = s2; } else if ( s2 == ZERO ) { s_sigma = s1; } else if ( s1 == s2 ) { s_sigma = s1; } else { RT e = CGAL::square(b1) * n2 - CGAL::square(b2) * n1; s_sigma = Sign(s1 * CGAL::sign(e)); } Sqrt_1 sigma = Zero; if ( s_sigma == POSITIVE ) { sigma = One; } else if ( s_sigma == NEGATIVE ) { sigma = -One; } // compute rho Sign s_rho(ZERO); s1 = CGAL::sign(a1); s2 = CGAL::sign(-a2); if ( s1 == ZERO ) { s_rho = s2; } else if ( s2 == ZERO ) { s_rho = s1; } else if ( s1 == s2 ) { s_rho = s1; } else { RT e = CGAL::square(a1) * n2 - CGAL::square(a2) * n1; s_rho = Sign(s1 * CGAL::sign(e)); } Sqrt_1 rho = Zero; if ( s_rho == POSITIVE ) { rho = One; } else if ( s_rho == NEGATIVE ) { rho = -One; } Sqrt_1 vz(-a1a2 - b1b2, RT(1), D1D2); RT A = a1a2 - b1b2; Sqrt_1 u1( c1c2 * A, c1c2, D1D2); Sqrt_1 u2(-c1c2 * A, c1c2, D1D2); ux = Sqrt_3(J + p.x() * vz, sigma, Zero, Zero, u1, u2); uy = Sqrt_3(I + p.y() * vz, Zero, -rho, Zero, u1, u2); uz = Sqrt_3(vz, Zero, Zero, Zero, u1, u2); } //-------------------------------------------------------------------------- void compute_pps(const Site_2& p, const Site_2& q, const Site_2& r) { CGAL_precondition( p.is_point() && q.is_point() && r.is_segment() ); v_type = PPS; RT a, b, c; compute_supporting_line(r.supporting_site(), a, b, c); Point_2 pp = p.point(), qq = q.point(); RT c_ = a * pp.x() + b * pp.y() + c; RT cq_ = a * qq.x() + b * qq.y() + c; if ( same_points(p, r.source_site()) || same_points(p, r.target_site()) ) { c_ = RT(0); } if ( same_points(q, r.source_site()) || same_points(q, r.target_site()) ) { cq_ = RT(0); } Sign s = CGAL::sign(c_); if ( s == NEGATIVE ) { a = -a; b = -b; c = -c; c_ = -c_; cq_ = -cq_; } else if ( s == ZERO ) { Sign s1 = CGAL::sign(cq_); CGAL_assertion( s1 != ZERO ); if ( s1 == NEGATIVE ) { a = -a; b = -b; c = -c; c_ = -c_; cq_ = -cq_; } } RT nl = CGAL::square(a) + CGAL::square(b); RT x_ = qq.x() - pp.x(); RT y_ = qq.y() - pp.y(); RT n_ = CGAL::square(x_) + CGAL::square(y_); Comparison_result res = CGAL::compare( c_, cq_ ); if ( res == EQUAL ) { RT e1 = CGAL::square(c_); RT J = nl * (a * n_ + RT(4) * c_ * x_) - RT(4) * a * e1; RT I = nl * (b * n_ + RT(4) * c_ * y_) - RT(4) * b * e1; RT X = RT(8) * nl * c_; ux_pps = Sqrt_1(J + pp.x() * X); uy_pps = Sqrt_1(I + pp.y() * X); uz_pps = Sqrt_1(X); return; } RT e1 = a * x_ + b * y_; RT e2 = b * x_ - a * y_; RT e3 = n_ * e1; RT e4 = RT(2) * c_ * e2; RT X = RT(2) * CGAL::square(e1); RT I = b * e3 + x_ * e4; RT J = a * e3 - y_ * e4; RT S = n_ * nl * c_ * cq_; ux_pps = Sqrt_1(J + pp.x() * X, RT(-2) * y_, S); uy_pps = Sqrt_1(I + pp.y() * X, RT( 2) * x_, S); uz_pps = Sqrt_1(X, RT(0), S); } //-------------------------------------------------------------------------- bool check_if_exact(const Site_2& s, unsigned int i, const Tag_false&) const { return true; } bool check_if_exact(const Site_2& s, unsigned int i, const Tag_true&) const { return s.is_input(i); } // determines of the segment s is on the positive halfspace as // defined by the supporting line of the segment supp; the line l // is supposed to be the supporting line of the segment supp and we // pass it so that we do not have to recompute it bool is_on_positive_halfspace(const Site_2& supp, const Site_2& s, const Line_2& l) const { CGAL_precondition( supp.is_segment() && s.is_segment() ); if ( same_segments(supp.supporting_site(), s.supporting_site()) ) { return false; } if ( same_points(supp.source_site(), s.source_site()) || same_points(supp.target_site(), s.source_site()) ) { return oriented_side_of_line(l, s.target()) == ON_POSITIVE_SIDE; } if ( same_points(supp.source_site(), s.target_site()) || same_points(supp.target_site(), s.target_site()) ) { return oriented_side_of_line(l, s.source()) == ON_POSITIVE_SIDE; } ITag itag; if ( !check_if_exact(s, 0, itag) && same_segments(supp.supporting_site(), s.crossing_site(0)) ) { return oriented_side_of_line(l, s.target()) == ON_POSITIVE_SIDE; } if ( !check_if_exact(s, 1, itag) && same_segments(supp.supporting_site(), s.crossing_site(1)) ) { return oriented_side_of_line(l, s.source()) == ON_POSITIVE_SIDE; } return Base::is_on_positive_halfspace(l, s.segment()); } //-------------------------------------------------------------------------- void orient_lines(const Site_2& p, const Site_2& q, const Site_2& r, RT a[], RT b[], RT c[]) const { CGAL_precondition( p.is_segment() && q.is_segment() && r.is_segment() ); Line_2 l[3]; l[0] = compute_supporting_line(p.supporting_site()); l[1] = compute_supporting_line(q.supporting_site()); l[2] = compute_supporting_line(r.supporting_site()); bool is_oriented[3] = {false, false, false}; if ( is_on_positive_halfspace(p, q, l[0]) || is_on_positive_halfspace(p, r, l[0]) ) { is_oriented[0] = true; } else { l[0] = opposite_line(l[0]); if ( is_on_positive_halfspace(p, q, l[0]) || is_on_positive_halfspace(p, r, l[0]) ) { is_oriented[0] = true; } else { l[0] = opposite_line(l[0]); } } if ( is_on_positive_halfspace(q, p, l[1]) || is_on_positive_halfspace(q, r, l[1]) ) { is_oriented[1] = true; } else { l[1] = opposite_line(l[1]); if ( is_on_positive_halfspace(q, p, l[1]) || is_on_positive_halfspace(q, r, l[1]) ) { is_oriented[1] = true; } else { l[1] = opposite_line(l[1]); } } if ( is_on_positive_halfspace(r, p, l[2]) || is_on_positive_halfspace(r, q, l[2]) ) { is_oriented[2] = true; } else { l[2] = opposite_line(l[2]); if ( is_on_positive_halfspace(r, p, l[2]) || is_on_positive_halfspace(r, q, l[2]) ) { is_oriented[2] = true; } else { l[2] = opposite_line(l[2]); } } if ( is_oriented[0] && is_oriented[1] && is_oriented[2] ) { for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } int i_no(-1); for (int i = 0; i < 3; i++) { if ( !is_oriented[i] ) { i_no = i; CGAL_assertion( is_oriented[(i+1)%3] && is_oriented[(i+2)%3] ); break; } } CGAL_assertion( i_no != -1 ); RT d[3]; for (int i = 0; i < 3; i++) { d[i] = CGAL::square(l[i].a()) + CGAL::square(l[i].b()); } RT z[3]; for (int i = 0; i < 3; i++) { z[i] = l[(i+1)%3].a() * l[(i+2)%3].b() - l[(i+2)%3].a() * l[(i+1)%3].b(); } Sqrt_1 Zero(RT(0), RT(0), d[0]); Sqrt_1 sqrt_D0(RT(0), RT(1), d[0]); Sqrt_1 D1 = d[1] + Zero; Sqrt_1 D2 = d[2] + Zero; Sqrt_3 vz(z[0] * sqrt_D0, z[1] + Zero, z[2] + Zero, Zero, D1, D2); Sign s_minus_vz = CGAL::sign(vz); CGAL_assertion( s_minus_vz != ZERO ); if ( s_minus_vz == NEGATIVE ) { l[i_no] = opposite_line(l[i_no]); for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } // now we have to check if the other orientation of l[i_no] // corresponds to a CCW triangle as well. z[(i_no+1)%3] = -z[(i_no+1)%3]; z[(i_no+2)%3] = -z[(i_no+2)%3]; vz = Sqrt_3(z[0] * sqrt_D0, z[1] + Zero, z[2] + Zero, Zero, D1, D2); Sign s_minus_vz_2 = CGAL::sign(vz); CGAL_assertion( s_minus_vz_2 != ZERO ); if ( s_minus_vz_2 == NEGATIVE ) { // the other orientation does not correspond to a CCW triangle. for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } // now compute the Voronoi vertex; for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } RT x[3], y[3], w[3]; for (int i = 0; i < 3; i++) { x[i] = c[(i+1)%3] * b[(i+2)%3] - c[(i+2)%3] * b[(i+1)%3]; y[i] = -(c[(i+1)%3] * a[(i+2)%3] - c[(i+2)%3] * a[(i+1)%3]); w[i] = -(a[(i+1)%3] * b[(i+2)%3] - a[(i+2)%3] * b[(i+1)%3]); } Sqrt_3 vx, vy, vw; vx = Sqrt_3(x[0] * sqrt_D0, x[1] + Zero, x[2] + Zero, Zero, D1, D2); vy = Sqrt_3(y[0] * sqrt_D0, y[1] + Zero, y[2] + Zero, Zero, D1, D2); vw = Sqrt_3(w[0] * sqrt_D0, w[1] + Zero, w[2] + Zero, Zero, D1, D2); Sqrt_1 a1(a[(i_no+1)%3], RT(0), d[0]); Sqrt_1 b1(b[(i_no+1)%3], RT(0), d[0]); Sqrt_1 c1(c[(i_no+1)%3], RT(0), d[0]); Sqrt_3 dist = a1 * vx + b1 * vy + c1 * vw; Sign s_vw = CGAL::sign(vw); Sign sgn_dist = Sign(s_vw * CGAL::sign(dist)); CGAL_assertion( sgn_dist != ZERO ); if ( sgn_dist == NEGATIVE ) { a[i_no] = -a[i_no]; b[i_no] = -b[i_no]; c[i_no] = -c[i_no]; } } void compute_sss(const Site_2& p, const Site_2& q, const Site_2& r) { CGAL_precondition( p.is_segment() && q.is_segment() && r.is_segment() ); v_type = SSS; RT a[3], b[3], c[3]; RT cx[3], cy[3], cz[3], D[3]; orient_lines(p, q, r, a, b, c); for (int i = 0; i < 3; i++) { cx[i] = c[(i+1)%3] * b[(i+2)%3] - c[(i+2)%3] * b[(i+1)%3]; cy[i] = -(c[(i+1)%3] * a[(i+2)%3] - c[(i+2)%3] * a[(i+1)%3]); cz[i] = -(a[(i+1)%3] * b[(i+2)%3] - a[(i+2)%3] * b[(i+1)%3]); D[i] = CGAL::square(a[i]) + CGAL::square(b[i]); Sqrt_1 Zero(RT(0), RT(0), D[0]); Sqrt_1 sqrt_D0(RT(0), RT(1), D[0]); Sqrt_1 D1 = Zero + D[1]; Sqrt_1 D2 = Zero + D[2]; ux = Sqrt_3(cx[0] * sqrt_D0, cx[1] + Zero, cx[2] + Zero, Zero, D1, D2); uy = Sqrt_3(cy[0] * sqrt_D0, cy[1] + Zero, cy[2] + Zero, Zero, D1, D2); uz = Sqrt_3(cz[0] * sqrt_D0, cz[1] + Zero, cz[2] + Zero, Zero, D1, D2); } } //-------------------------------------------------------------------------- void compute_vertex(const Site_2& s1, const Site_2& s2, const Site_2& s3) { if ( s1.is_point() && s2.is_point() && s3.is_point() ) { compute_ppp(s1, s2, s3); } else if ( s1.is_segment() && s2.is_point() && s3.is_point() ) { compute_vertex(s2, s3, s1); pps_idx = 1; } else if ( s1.is_point() && s2.is_segment() && s3.is_point() ) { compute_vertex(s3, s1, s2); pps_idx = 2; } else if ( s1.is_point() && s2.is_point() && s3.is_segment() ) { compute_pps(s1, s2, s3); pps_idx = 0; } else if ( s1.is_point() && s2.is_segment() && s3.is_segment() ) { compute_pss(s1, s2, s3); } else if ( s1.is_segment() && s2.is_point() && s3.is_segment() ) { compute_vertex(s2, s3, s1); } else if ( s1.is_segment() && s2.is_segment() && s3.is_point() ) { compute_vertex(s3, s1, s2); } else { compute_sss(s1, s2, s3); } } //-------------------------------------------------------------------------- bool is_endpoint_of(const Site_2& p, const Site_2& s) const { CGAL_precondition( p.is_point() && s.is_segment() ); return ( same_points(p, s.source_site()) || same_points(p, s.target_site()) ); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the orientation test //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Orientation orientation(const Line_2& l, PPP_Type) const { Sign s_uz = CGAL::sign(uz_ppp); Sign s_l = CGAL::sign(l.a() * ux_ppp + l.b() * uy_ppp + l.c() * uz_ppp); Sign s = Sign(s_uz * s_l); if ( s == ZERO ) { return COLLINEAR; } return ( s == POSITIVE ) ? LEFT_TURN : RIGHT_TURN; } //-------------------------------------------------------------------------- Orientation orientation(const Line_2& l, PPS_Type) const { Sign s_uz = CGAL::sign(uz_pps); Sign s_l = CGAL::sign(l.a() * ux_pps + l.b() * uy_pps + l.c() * uz_pps); Sign s = Sign(s_uz * s_l); if ( s == ZERO ) { return COLLINEAR; } return ( s == POSITIVE ) ? LEFT_TURN : RIGHT_TURN; } //-------------------------------------------------------------------------- // the cases PSS and SSS are identical template Orientation orientation(const Line_2& l, Type) const { Sqrt_1 Zero(RT(0), RT(0), ux.a().c()); Sqrt_1 a = l.a() + Zero; Sqrt_1 b = l.b() + Zero; Sqrt_1 c = l.c() + Zero; Sign s_uz = CGAL::sign(uz); Sign s_l = CGAL::sign(a * ux + b * uy + c * uz); Sign s = Sign(s_uz * s_l); if ( s == ZERO ) { return COLLINEAR; } return ( s == POSITIVE ) ? LEFT_TURN : RIGHT_TURN; } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test when the fourth site is a point //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign check_easy_degeneracies(const Site_2& t, PPS_Type, bool& use_result) const { CGAL_precondition( t.is_point() ); use_result = false; if ( ( p_.is_point() && same_points(p_, t) ) || ( q_.is_point() && same_points(q_, t) ) || ( r_.is_point() && same_points(r_, t) ) ) { use_result = true; return ZERO; } if ( ( p_.is_segment() && is_endpoint_of(t, p_) ) || ( q_.is_segment() && is_endpoint_of(t, q_) ) || ( r_.is_segment() && is_endpoint_of(t, r_) ) ) { use_result = true; return POSITIVE; } return ZERO; } inline Sign check_easy_degeneracies(const Site_2& t, PSS_Type, bool& use_result) const { CGAL_precondition( t.is_point() ); return check_easy_degeneracies(t, PPS_Type(), use_result); } inline Sign check_easy_degeneracies(const Site_2& t, SSS_Type, bool& use_result) const { CGAL_precondition( t.is_point() ); use_result = false; // ADD THE CASES WHERE t IS AN ENDPOINT OF ONE OF THE SEGMENTS return ZERO; } //-------------------------------------------------------------------------- template inline Sign incircle_p(const Site_2& st, Type type) const { CGAL_precondition( st.is_point() ); bool use_result(false); Sign s = check_easy_degeneracies(st, type, use_result); if ( use_result ) { return s; } return incircle_p_no_easy(st, type); } //-------------------------------------------------------------------------- Sign incircle_p(const Site_2& st, PPP_Type) const { CGAL_precondition( st.is_point() ); Point_2 t = st.point(); Oriented_side os = side_of_oriented_circle(p_.point(), q_.point(), r_.point(), t); if ( os == ON_POSITIVE_SIDE ) { return NEGATIVE; } if ( os == ON_NEGATIVE_SIDE ) { return POSITIVE; } return ZERO; } //-------------------------------------------------------------------------- Sign incircle_p_no_easy(const Site_2& st, PPS_Type type) const { CGAL_precondition( st.is_point() ); Point_2 t = st.point(); Point_2 pref = p_ref().point(); Sqrt_1 vx = ux_pps - pref.x() * uz_pps; Sqrt_1 vy = uy_pps - pref.y() * uz_pps; Sqrt_1 Rs = CGAL::square(vx) + CGAL::square(vy); Sqrt_1 Rs1 = CGAL::square(ux_pps - t.x() * uz_pps) + CGAL::square(uy_pps - t.y() * uz_pps); return CGAL::sign(Rs1 - Rs); } //-------------------------------------------------------------------------- Sign incircle_p_no_easy(const Site_2& st, PSS_Type type) const { CGAL_precondition( st.is_point() ); Point_2 t = st.point(); Sqrt_1 Zero(RT(0), RT(0), ux.a().c()); Point_2 pref = p_ref().point(); Sqrt_1 xref = pref.x() + Zero; Sqrt_1 yref = pref.y() + Zero; Sqrt_3 vx = ux - xref * uz; Sqrt_3 vy = uy - yref * uz; Sqrt_3 Rs = CGAL::square(vx) + CGAL::square(vy); Sqrt_1 tx = t.x() + Zero; Sqrt_1 ty = t.y() + Zero; Sqrt_3 Rs1 = CGAL::square(ux - tx * uz) + CGAL::square(uy - ty * uz); Sign s_Q = CGAL::sign(Rs1 - Rs); return s_Q; } //-------------------------------------------------------------------------- Sign incircle_p_no_easy(const Site_2& st, SSS_Type type) const { CGAL_precondition( st.is_point() ); Point_2 t = st.point(); Sqrt_1 Zero(RT(0), RT(0), ux.a().c()); RT a1, b1, c1; compute_supporting_line(p_.supporting_site(), a1, b1, c1); RT ns = CGAL::square(a1) + CGAL::square(b1); Sqrt_1 a = a1 + Zero; Sqrt_1 b = b1 + Zero; Sqrt_1 c = c1 + Zero; Sqrt_1 Ns = ns + Zero; Sqrt_3 Ls = CGAL::square(a * ux + b * uy + c * uz); Sqrt_1 tx = t.x() + Zero; Sqrt_1 ty = t.y() + Zero; Sqrt_3 R1s = CGAL::square(ux - tx * uz) + CGAL::square(uy - ty * uz); return CGAL::sign(R1s * Ns - Ls); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign incircle_p(const Site_2& t) const { if ( is_degenerate_Voronoi_circle() ) { return POSITIVE; } Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle_p(t, PPP_Type()); break; case PPS: s = incircle_p(t, PPS_Type()); break; case PSS: s = incircle_p(t, PSS_Type()); break; case SSS: s = incircle_p(t, SSS_Type()); break; } return s; } Sign incircle_p_no_easy(const Site_2& t) const { Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle_p(t, PPP_Type()); break; case PPS: s = incircle_p_no_easy(t, PPS_Type()); break; case PSS: s = incircle_p_no_easy(t, PSS_Type()); break; case SSS: s = incircle_p_no_easy(t, SSS_Type()); break; } return s; } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test when the fourth site is a segment //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Oriented_side oriented_side(const Line_2& l, const Point_2& p, PPP_Type) const { Sign s_uz = CGAL::sign(uz_ppp); RT px = uz_ppp * p.x() - ux_ppp; RT py = uz_ppp * p.y() - uy_ppp; Sign s1 = CGAL::sign(l.b() * px - l.a() * py); Sign s = Sign(s_uz * s1); if ( s == POSITIVE ) { return ON_POSITIVE_SIDE; } if ( s == NEGATIVE ) { return ON_NEGATIVE_SIDE; } return ON_ORIENTED_BOUNDARY; } Oriented_side oriented_side(const Line_2& l, const Point_2& p, PPS_Type) const { Sqrt_1 dx = ux_pps - uz_pps * p.x(); Sqrt_1 dy = uy_pps - uz_pps * p.y(); Sign s = Sign(CGAL::sign(uz_pps) * CGAL::sign(dy * l.a() - dx * l.b()) ); if ( s == POSITIVE ) { return ON_POSITIVE_SIDE; } if ( s == NEGATIVE ) { return ON_NEGATIVE_SIDE; } return ON_ORIENTED_BOUNDARY; } // the cases PSS and SSS are identical template Oriented_side oriented_side(const Line_2& l, const Point_2& p, Type) const { Sqrt_1 Zero(RT(0), RT(0), ux.a().c()); Sqrt_1 px = p.x() + Zero; Sqrt_1 py = p.y() + Zero; Sqrt_3 dx = ux - px * uz; Sqrt_3 dy = uy - py * uz; Sqrt_1 a = l.a() + Zero; Sqrt_1 b = l.b() + Zero; Sign s = Sign(CGAL::sign(uz) * CGAL::sign(a * dy - b * dx) ); if ( s == POSITIVE ) { return ON_POSITIVE_SIDE; } if ( s == NEGATIVE ) { return ON_NEGATIVE_SIDE; } return ON_ORIENTED_BOUNDARY; } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign incircle(const Line_2& l, PPP_Type) const { Point_2 pref = p_ref().point(); RT a1 = CGAL::square(l.a()) + CGAL::square(l.b()); RT a2 = CGAL::square(ux_ppp - pref.x() * uz_ppp) + CGAL::square(uy_ppp - pref.y() * uz_ppp); RT a3 = CGAL::square(l.a() * ux_ppp + l.b() * uy_ppp + l.c() * uz_ppp); Comparison_result cr = CGAL::compare(a3, a1 * a2); if ( cr == LARGER ) { return POSITIVE; } if ( cr == SMALLER ) { return NEGATIVE; } return ZERO; } //-------------------------------------------------------------------------- Sign incircle(const Line_2& l, PPS_Type) const { Point_2 pref = p_ref().point(); Sqrt_1 vx = ux_pps - pref.x() * uz_pps; Sqrt_1 vy = uy_pps - pref.y() * uz_pps; Sqrt_1 Rs = CGAL::square(vx) + CGAL::square(vy); RT Ns = CGAL::square(l.a()) + CGAL::square(l.b()); Sqrt_1 Ls = CGAL::square(l.a() * ux_pps + l.b() * uy_pps + l.c() * uz_pps); return CGAL::sign(Ls - Rs * Ns); } //-------------------------------------------------------------------------- Sign incircle(const Line_2& l, PSS_Type) const { Sqrt_1 Zero(RT(0), RT(0), ux.a().c()); Point_2 pref = p_ref().point(); Sqrt_3 vx = ux - (pref.x() + Zero) * uz; Sqrt_3 vy = uy - (pref.y() + Zero) * uz; Sqrt_3 Rs = CGAL::square(vx) + CGAL::square(vy); Sqrt_1 a = l.a() + Zero; Sqrt_1 b = l.b() + Zero; Sqrt_1 c = l.c() + Zero; Sqrt_1 Ns = CGAL::square(a) + CGAL::square(b); Sqrt_3 Ls = CGAL::square(a * ux + b * uy + c * uz); return CGAL::sign(Ls - Rs * Ns); } //-------------------------------------------------------------------------- Sign incircle(const Line_2& l, SSS_Type) const { Sqrt_1 Zero(RT(0), RT(0), ux.a().c()); RT a1, b1, c1; compute_supporting_line(p_.supporting_site(), a1, b1, c1); Sqrt_1 a = a1 + Zero; Sqrt_1 b = b1 + Zero; Sqrt_1 c = c1 + Zero; Sqrt_1 Ns = CGAL::square(a) + CGAL::square(b); Sqrt_1 la = l.a() + Zero; Sqrt_1 lb = l.b() + Zero; Sqrt_1 lc = l.c() + Zero; Sqrt_1 Ns1 = CGAL::square(la) + CGAL::square(lb); Sqrt_3 Ls = CGAL::square(a * ux + b * uy + c * uz); Sqrt_3 Ls1 = CGAL::square(la * ux + lb * uy + lc * uz); return CGAL::sign(Ls1 * Ns - Ls * Ns1); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template Sign incircle_s(const Site_2& t, Type type) const { CGAL_precondition( t.is_segment() ); if ( v_type == PPP || v_type == PPS ) { if ( p_.is_point() && q_.is_point() && is_endpoint_of(p_, t) && is_endpoint_of(q_, t) ) { return NEGATIVE; } if ( p_.is_point() && r_.is_point() && is_endpoint_of(p_, t) && is_endpoint_of(r_, t) ){ return NEGATIVE; } if ( q_.is_point() && r_.is_point() && is_endpoint_of(q_, t) && is_endpoint_of(r_, t) ){ return NEGATIVE; } } if ( v_type == PSS ) { if ( p_.is_segment() && same_segments(p_.supporting_site(), t.supporting_site()) ) { return POSITIVE; } if ( q_.is_segment() && same_segments(q_.supporting_site(), t.supporting_site()) ) { return POSITIVE; } if ( r_.is_segment() && same_segments(r_.supporting_site(), t.supporting_site()) ) { return POSITIVE; } } return incircle_s_no_easy(t, type); } template Sign incircle_s_no_easy(const Site_2& t, Type type) const { Sign d1, d2; if ( ( p_.is_point() && same_points(p_, t.source_site()) ) || ( q_.is_point() && same_points(q_, t.source_site()) ) || ( r_.is_point() && same_points(r_, t.source_site()) ) ) { d1 = ZERO; } else { d1 = incircle_p(t.source_site()); } if ( d1 == NEGATIVE ) { return NEGATIVE; } if ( ( p_.is_point() && same_points(p_, t.target_site()) ) || ( q_.is_point() && same_points(q_, t.target_site()) ) || ( r_.is_point() && same_points(r_, t.target_site()) ) ) { d2 = ZERO; } else { d2 = incircle_p(t.target_site()); } if ( d2 == NEGATIVE ) { return NEGATIVE; } Line_2 l = compute_supporting_line(t.supporting_site()); Sign sl = incircle(l, type); if ( sl == POSITIVE ) { return sl; } if ( sl == ZERO && (d1 == ZERO || d2 == ZERO) ) { return ZERO; } Oriented_side os1 = oriented_side(l, t.source(), type); Oriented_side os2 = oriented_side(l, t.target(), type); if ( sl == ZERO ) { if (os1 == ON_ORIENTED_BOUNDARY || os2 == ON_ORIENTED_BOUNDARY) { return ZERO; } return ( os1 == os2 ) ? POSITIVE : ZERO; } return (os1 == os2) ? POSITIVE : NEGATIVE; } //-------------------------------------------------------------------------- Sign incircle_s(const Site_2& t) const { CGAL_precondition( t.is_segment() ); if ( is_degenerate_Voronoi_circle() ) { // case 1: the new segment is not adjacent to the center of the // degenerate Voronoi circle if ( !same_points( p_ref(), t.source_site() ) && !same_points( p_ref(), t.target_site() ) ) { return POSITIVE; } CGAL_assertion( v_type == PSS ); if ( p_.is_segment() && same_segments(p_.supporting_site(), t.supporting_site()) ) { return ZERO; } if ( q_.is_segment() && same_segments(q_.supporting_site(), t.supporting_site()) ) { return ZERO; } if ( r_.is_segment() && same_segments(r_.supporting_site(), t.supporting_site()) ) { return ZERO; } Site_2 pr; Site_2 sp, sq; if ( p_.is_point() ) { CGAL_assertion( q_.is_segment() && r_.is_segment() ); pr = p_; sp = q_; sq = r_; } else if ( q_.is_point() ) { CGAL_assertion( r_.is_segment() && p_.is_segment() ); pr = q_; sp = r_; sq = p_; } else { CGAL_assertion( p_.is_segment() && q_.is_segment() ); pr = r_; sp = p_; sq = q_; } Point_2 pq = sq.source(), pp = sp.source(), pt = t.source(); if ( same_points(sp.source_site(), pr) ) { pp = sp.target(); } if ( same_points(sq.source_site(), pr) ) { pq = sq.target(); } if ( same_points( t.source_site(), pr) ) { pt = t.target(); } Point_2 pr_ = pr.point(); if ( CGAL::orientation(pr_, pp, pt) == LEFT_TURN && CGAL::orientation(pr_, pq, pt) == RIGHT_TURN ) { return NEGATIVE; } return ZERO; } // if ( is_degenerate_Voronoi_circle() ) Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle_s(t, PPP_Type()); break; case PPS: s = incircle_s(t, PPS_Type()); break; case PSS: s = incircle_s(t, PSS_Type()); break; case SSS: s = incircle_s(t, SSS_Type()); break; } return s; } Sign incircle_s_no_easy(const Site_2& t) const { Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle_s_no_easy(t, PPP_Type()); break; case PPS: s = incircle_s_no_easy(t, PPS_Type()); break; case PSS: s = incircle_s_no_easy(t, PSS_Type()); break; case SSS: s = incircle_s_no_easy(t, SSS_Type()); break; } return s; } //-------------------------------------------------------------------------- // subpredicates for the incircle test //-------------------------------------------------------------------------- public: bool is_degenerate_Voronoi_circle() const { if ( v_type != PSS ) { return false; } if ( p_.is_point() ) { return ( is_endpoint_of(p_, q_) && is_endpoint_of(p_, r_) ); } else if ( q_.is_point() ) { return ( is_endpoint_of(q_, p_) && is_endpoint_of(q_, r_) ); } else { CGAL_assertion( r_.is_point() ); return ( is_endpoint_of(r_, p_) && is_endpoint_of(r_, q_) ); } } //-------------------------------------------------------------------------- private: //-------------------------------------------------------------------------- // the reference point (valid if v_type != SSS) //-------------------------------------------------------------------------- Site_2 p_ref() const { CGAL_precondition ( v_type != SSS ); if ( v_type == PPS ) { if ( pps_idx == 0 ) { return p_; } if ( pps_idx == 1 ) { return q_; } return r_; } if ( p_.is_point() ) { return p_; } else if ( q_.is_point() ) { return q_; } else { CGAL_assertion( r_.is_point() ); return r_; } } public: //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // access methods //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- FT x() const { return hx() / hw(); } FT y() const { return hy() / hw(); } FT hx() const { if ( v_type == PPP ) { return ux_ppp; } if ( v_type == PPS ) { return to_ft(ux_pps); } return to_ft(ux); } FT hy() const { if ( v_type == PPP ) { return uy_ppp; } if ( v_type == PPS ) { return to_ft(uy_pps); } return to_ft(uy); } FT hw() const { if ( v_type == PPP ) { return uz_ppp; } if ( v_type == PPS ) { return to_ft(uz_pps); } return to_ft(uz); } FT squared_radius() const { switch (v_type) { case PPP: case PPS: case PSS: { Point_2 pref = p_ref().point(); FT dx2 = CGAL::square(x() - pref.x()); FT dy2 = CGAL::square(y() - pref.y()); return dx2 + dy2; } break; case SSS: { Line_2 l = compute_supporting_line(p_.supporting_site()); Homogeneous_point_2 q = compute_projection(l, point()); FT dx2 = CGAL::square(x() - q.x()); FT dy2 = CGAL::square(y() - q.y()); return dx2 + dy2; } break; default: return FT(0); } } Point_2 point() const { if ( is_degenerate_Voronoi_circle() ) { return degenerate_point(); } return Point_2(x(), y()); } Point_2 degenerate_point() const { CGAL_precondition( is_degenerate_Voronoi_circle() ); return p_ref().point(); } typename K::Circle_2 circle() const { typedef typename K::Circle_2 K_Circle_2; return K_Circle_2(point(), squared_radius()); } vertex_t type() const { return v_type; } public: Svd_voronoi_vertex_ring_C2(const Site_2& p, const Site_2& q, const Site_2& r) : p_(p), q_(q), r_(r) { compute_vertex(p, q, r); } //-------------------------------------------------------------------------- Sign incircle(const Site_2& t) const { Sign s; if ( t.is_point() ) { s = incircle_p(t); } else { s = incircle_s(t); } return s; } Sign incircle_no_easy(const Site_2& t) const { Sign s; if ( t.is_point() ) { s = incircle_p_no_easy(t); } else { s = incircle_s_no_easy(t); } return s; } //-------------------------------------------------------------------------- Orientation orientation(const Line_2& l) const { Orientation o(COLLINEAR); switch ( v_type ) { case PPP: o = orientation(l, PPP_Type()); break; case PPS: o = orientation(l, PPS_Type()); break; case PSS: o = orientation(l, PSS_Type()); break; case SSS: o = orientation(l, SSS_Type()); break; } return o; } Oriented_side oriented_side(const Line_2& l) const { Orientation o = orientation(l); if ( o == COLLINEAR ) { return ON_ORIENTED_BOUNDARY; } return ( o == LEFT_TURN ) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } //-------------------------------------------------------------------------- private: const Site_2& p_, q_, r_; vertex_t v_type; // index that indicates the refence point for the case PPS short pps_idx; // the case ppp RT ux_ppp, uy_ppp, uz_ppp; // the case pps Sqrt_1 ux_pps, uy_pps, uz_pps; // the case pss and sss Sqrt_3 ux, uy, uz; }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VERTEX_RING_C2_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_orientation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_orienta0000644000175000017500000000303711344301501031224 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_orientation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_ORIENTATION_2_H #define CGAL_AG2_ORIENTATION_2_H #include //-------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE template class Ag2_orientation_2 { public: typedef K Kernel; typedef typename K::Site_2 Site_2; typedef Orientation result_type; typedef Arity_tag<3> Arity; typedef Site_2 argument_type; inline Orientation operator()(const Site_2& s1, const Site_2& s2, const Site_2& s3) const { return Kernel().orientation_2_object()(s1.point(), s2.point(), s3.point()); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_ORIENTATION_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/sign_of_determinant.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/sign_of_det0000644000175000017500000001076511344301501031360 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/sign_of_determinant.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // Stefan Schirra #ifndef CGAL_PREDICATES_SIGN_OF_DETERMINANT_H #define CGAL_PREDICATES_SIGN_OF_DETERMINANT_H #include CGAL_BEGIN_NAMESPACE template inline Sign sign_of_determinant2x2( const FT& a00, const FT& a01, const FT& a10, const FT& a11) { return static_cast(static_cast(CGAL_NTS compare( a00*a11, a10*a01))); } template inline Sign sign_of_determinant3x3( const FT& a00, const FT& a01, const FT& a02, const FT& a10, const FT& a11, const FT& a12, const FT& a20, const FT& a21, const FT& a22) { return CGAL_NTS sign(det3x3_by_formula(a00, a01, a02, a10, a11, a12, a20, a21, a22)); } template inline Sign sign_of_determinant4x4( const FT& a00, const FT& a01, const FT& a02, const FT& a03, const FT& a10, const FT& a11, const FT& a12, const FT& a13, const FT& a20, const FT& a21, const FT& a22, const FT& a23, const FT& a30, const FT& a31, const FT& a32, const FT& a33) { return CGAL_NTS sign(det4x4_by_formula(a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23, a30, a31, a32, a33)); } template CGAL_KERNEL_LARGE_INLINE Sign sign_of_determinant5x5( const FT& a00, const FT& a01, const FT& a02, const FT& a03, const FT& a04, const FT& a10, const FT& a11, const FT& a12, const FT& a13, const FT& a14, const FT& a20, const FT& a21, const FT& a22, const FT& a23, const FT& a24, const FT& a30, const FT& a31, const FT& a32, const FT& a33, const FT& a34, const FT& a40, const FT& a41, const FT& a42, const FT& a43, const FT& a44) { return CGAL_NTS sign(det5x5_by_formula(a00, a01, a02, a03, a04, a10, a11, a12, a13, a14, a20, a21, a22, a23, a24, a30, a31, a32, a33, a34, a40, a41, a42, a43, a44)); } template CGAL_KERNEL_LARGE_INLINE Sign sign_of_determinant6x6( const FT& a00, const FT& a01, const FT& a02, const FT& a03, const FT& a04, const FT& a05, const FT& a10, const FT& a11, const FT& a12, const FT& a13, const FT& a14, const FT& a15, const FT& a20, const FT& a21, const FT& a22, const FT& a23, const FT& a24, const FT& a25, const FT& a30, const FT& a31, const FT& a32, const FT& a33, const FT& a34, const FT& a35, const FT& a40, const FT& a41, const FT& a42, const FT& a43, const FT& a44, const FT& a45, const FT& a50, const FT& a51, const FT& a52, const FT& a53, const FT& a54, const FT& a55) { return CGAL_NTS sign(det6x6_by_formula(a00, a01, a02, a03, a04, a05, a10, a11, a12, a13, a14, a15, a20, a21, a22, a23, a24, a25, a30, a31, a32, a33, a34, a35, a40, a41, a42, a43, a44, a45, a50, a51, a52, a53, a54, a55)); } CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #include #endif // CGAL_ARITHMETIC_FILTER_H #endif // CGAL_PREDICATES_SIGN_OF_DETERMINANT_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_basic_predicates_H2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_basic_p0000644000175000017500000001630111344301501031304 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_basic_predicates_H2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_BASIC_PREDICATES_H2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_BASIC_PREDICATES_H2_H #include #include #include CGAL_BEGIN_NAMESPACE template struct Svd_basic_predicates_H2 { public: //------------------------------------------------------------------- // TYPES //------------------------------------------------------------------- typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; typedef CGAL::Square_root_1 Sqrt_1; typedef CGAL::Square_root_2 Sqrt_2; typedef CGAL::Square_root_2 Sqrt_3; typedef Point_2 Homogeneous_point_2; class Line_2 { private: RT a_, b_, c_; public: Line_2() : a_(1), b_(0), c_(0) {} Line_2(const RT& a, const RT& b, const RT& c) : a_(a), b_(b), c_(c) {} RT a() const { return a_; } RT b() const { return b_; } RT c() const { return c_; } }; #if 0 class Homogeneous_point_2 { private: RT hx_, hy_, hw_; public: Homogeneous_point_2() : hx_(0), hy_(0), hw_(1) {} Homogeneous_point_2(const RT& hx, const RT& hy, const RT& hw) : hx_(hx), hy_(hy), hw_(hw) { CGAL_precondition( !(CGAL::is_zero(hw_)) ); } Homogeneous_point_2(const Point_2& p) : hx_(p.x()), hy_(p.y()), hw_(1) {} Homogeneous_point_2(const Homogeneous_point_2& other) : hx_(other.hx_), hy_(other.hy_), hw_(other.hw_) {} RT hx() const { return hx_; } RT hy() const { return hy_; } RT hw() const { return hw_; } FT x() const { return hx_ / hw_; } FT y() const { return hy_ / hw_; } }; #endif public: //------------------------------------------------------------------- // CONVERSIONS //------------------------------------------------------------------- static FT to_ft(const Sqrt_1& x) { FT sqrt_c = CGAL::sqrt(x.c()); return x.a() + x.b() * sqrt_c; } static FT to_ft(const Sqrt_3& x) { FT sqrt_e = CGAL::sqrt(x.e()); FT sqrt_f = CGAL::sqrt(x.f()); FT sqrt_ef = sqrt_e * sqrt_f; return x.a() + x.b() * sqrt_e + x.c() * sqrt_f + x.d() * sqrt_ef; } public: //------------------------------------------------------------------- // BASIC CONSTRUCTIONS //------------------------------------------------------------------- static Line_2 compute_supporting_line(const Segment_2& s) { RT a, b, c; compute_supporting_line(s, a, b, c); return Line_2(a, b, c); } static void compute_supporting_line(const Segment_2& s, RT& a, RT& b, RT& c) { RT x1 = s.source().hx(); RT y1 = s.source().hy(); RT w1 = s.source().hw(); if ( w1 < 0 ) { x1 = -x1; y1 = -y1; w1 = -w1; } RT x2 = s.target().hx(); RT y2 = s.target().hy(); RT w2 = s.target().hw(); if ( w2 < 0 ) { x2 = -x2; y2 = -y2; w2 = -w2; } a = y1 * w2 - y2 * w1; b = x2 * w1 - x1 * w2; c = x1 * y2 - x2 * y1; } static Homogeneous_point_2 compute_projection(const Line_2& l, const Point_2& p) { Homogeneous_point_2 hp; RT ab = l.a() * l.b(); RT hx = CGAL::square(l.b()) * p.hx() - ab * p.hy() - l.a() * l.c() * p.hw(); RT hy = CGAL::square(l.a()) * p.hy() - ab * p.hx() - l.b() * l.c() * p.hw(); RT hw = CGAL::square(l.a()) + CGAL::square(l.b()); return Homogeneous_point_2(hx, hy, hw * p.hw()); } static Homogeneous_point_2 projection_on_line(const Line_2& l, const Point_2& p) { return compute_projection(l, p); } static Homogeneous_point_2 midpoint(const Homogeneous_point_2& p1, const Homogeneous_point_2& p2) { RT hx = p1.hx() * p2.hw() + p2.hx() * p1.hw(); RT hy = p1.hy() * p2.hw() + p2.hy() * p1.hw(); RT hw = RT(2) * p1.hw() * p2.hw(); return Homogeneous_point_2(hx, hy, hw); } static Line_2 compute_perpendicular(const Line_2& l, const Point_2& p) { RT hx = p.hx(); RT hy = p.hy(); RT hw = p.hw(); if ( hw < 0 ) { hx = -hx; hy = -hy; hw = -hw; } RT a, b, c; a = -l.b() * hw; b = l.a() * hw; c = l.b() * hx - l.a() * hy; return Line_2(a, b, c); } static Line_2 opposite_line(const Line_2& l) { return Line_2(-l.a(), -l.b(), -l.c()); } public: //------------------------------------------------------------------- // BASIC PREDICATES //------------------------------------------------------------------- static Comparison_result compare_squared_distances_to_line(const Line_2& l, const Point_2& p, const Point_2& q) { RT d2_lp = CGAL::square(l.a() * p.hx() + l.b() * p.hy() + l.c() * p.hw()); RT d2_lq = CGAL::square(l.a() * q.hx() + l.b() * q.hy() + l.c() * p.hw()); RT p_hw_sq = CGAL::square( p.hw() ); RT q_hw_sq = CGAL::square( q.hw() ); return CGAL::compare(d2_lp * q_hw_sq, d2_lq * p_hw_sq); } static Comparison_result compare_squared_distances_to_lines(const Point_2& p, const Line_2& l1, const Line_2& l2) { RT hx = p.hx(); RT hy = p.hy(); RT hw = p.hw(); RT d2_l1 = CGAL::square(l1.a() * hx + l1.b() * hy + l1.c() * hw); RT d2_l2 = CGAL::square(l2.a() * hx + l2.b() * hy + l2.c() * hw); RT n1 = CGAL::square(l1.a()) + CGAL::square(l1.b()); RT n2 = CGAL::square(l2.a()) + CGAL::square(l2.b()); return CGAL::compare(d2_l1 * n2, d2_l2 * n1); } static Oriented_side oriented_side_of_line(const Line_2& l, const Homogeneous_point_2& p) { Sign s1 = CGAL::sign(l.a() * p.hx() + l.b() * p.hy() + l.c() * p.hw()); Sign s_hw = CGAL::sign(p.hw()); Sign s = Sign(s1 * s_hw); if ( s == ZERO ) { return ON_ORIENTED_BOUNDARY; } return ( s == POSITIVE ) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } static bool is_on_positive_halfspace(const Line_2& l, const Segment_2& s) { Oriented_side os1, os2; os1 = oriented_side_of_line(l, s.source()); os2 = oriented_side_of_line(l, s.target()); return ( (os1 == ON_POSITIVE_SIDE && os2 != ON_NEGATIVE_SIDE) || (os1 != ON_NEGATIVE_SIDE && os2 == ON_POSITIVE_SIDE) ); } }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_BASIC_PREDICATES_C2_H ././@LongLink0000000000000000000000000000020500000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicates_on_weighted_points_cartesian_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicates_0000644000175000017500000002174111344301501031356 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicates_on_weighted_points_cartesian_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_PREDICATES_ON_WEIGHTED_POINTS_CARTESIAN_3 #define CGAL_PREDICATES_ON_WEIGHTED_POINTS_CARTESIAN_3 #include #include //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- template < class FT > Comparison_result compare_power_distanceC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw) { FT dqx = qx - px; FT dqy = qy - py; FT dqz = qz - pz; FT drx = rx - px; FT dry = ry - py; FT drz = rz - pz; return Comparison_result(CGAL_NTS sign ( (dqx*dqx + dqy*dqy + dqz*dqz - qw ) - (drx*drx + dry*dry + drz*drz - rw ) )); } //return the sign of the power test of weighted point (sx,sy,sz,sw) //with respect to the smallest sphere orthogonal to //p,q,r template< class FT > CGAL_MEDIUM_INLINE Sign in_smallest_orthogonal_sphereC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &sx, const FT &sy, const FT &sz, const FT &sw) { // Translate p to origin and compute determinants FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT rr = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz); FT qr = qpx*rpx + qpy*rpy + qpz*rpz; FT qpw = qq - qw + pw ; FT rpw = rr - rw + pw ; FT den = det2x2_by_formula(qq,qr, qr,rr); FT detq = det2x2_by_formula(qpw,qr, rpw,rr); FT detr = det2x2_by_formula(qq,qpw, qr,rpw); // Smallest smallest orthogonal sphere center // c = detq/2*den q + detr/2*den r (origin at p) // square radius c^2 - pw FT spx = sx-px; FT spy = sy-py; FT spz = sz-pz; FT ss = CGAL_NTS square(spx) + CGAL_NTS square(spy) + CGAL_NTS square(spz); FT sq = spx*qpx + spy*qpy + spz*qpz; FT sr = spx*rpx + spy*rpy + spz*rpz; CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); // return sign of (c- s)^2 - (c^2 - pw) - sw note that den >= 0 - return CGAL_NTS sign( den*(ss - sw + pw)- detq*sq - detr*sr); } // return the sign of the power test of weighted point (rx,ry,rz,rw) // with respect to the smallest sphere orthogoanal to // p,q template< class FT > Sign in_smallest_orthogonal_sphereC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw) { FT FT2(2); FT FT4(4); FT dpx = px - qx; FT dpy = py - qy; FT dpz = pz - qz; FT dpw = pw - qw; FT dp2 = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) + CGAL_NTS square(dpz); FT drx = rx - (px + qx)/FT2; FT dry = ry - (py + qy)/FT2; FT drz = rz - (pz + qz)/FT2; FT drw = rw - (pw + qw)/FT2; FT dr2 = CGAL_NTS square(drx) + CGAL_NTS square(dry) + CGAL_NTS square(drz); FT dpr = dpx*drx + dpy*dry +dpz*drz; return CGAL_NTS sign (dr2 - dp2/FT4 + dpr*dpw/dp2 - drw ); } // return ON_UNBOUNDED_SIDE, ON_BOUNDARY or ON_BOUNDED_SIDE according // to the position of the weighted circumcenter of pqrs // with respect with the tertraedron formed by bare points in p, q,r,s template Bounded_side does_simplex_intersect_dual_supportC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &sx, const FT &sy, const FT &sz, const FT &sw) { FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT spx = sx-px; FT spy = sy-py; FT spz = sz-pz; FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT rr = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz); FT ss = CGAL_NTS square(spx) + CGAL_NTS square(spy) + CGAL_NTS square(spz); FT qr = qpx*rpx + qpy*rpy + qpz*rpz; FT rs = rpx*spx + rpy*spy + rpz*spz; FT qs = spx*qpx + spy*qpy + spz*qpz; FT qpw = qq - qw + pw ; FT rpw = rr - rw + pw ; FT spw = ss - sw + pw ; FT den = det3x3_by_formula(qq,qr,qs, qr,rr,rs, qs,rs,ss); FT detq = det3x3_by_formula(qpw,qr,qs, rpw,rr,rs, spw,rs,ss); FT detr = det3x3_by_formula(qq,qpw,qs, qr,rpw,rs, qs,spw,ss); FT dets = det3x3_by_formula(qq,qr,qpw, qr,rr,rpw, qs,rs,spw); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); // The barycentrique coordinate of the smallest orthogonal sphere center // are detq/2*den detr/2*den dets/2*den // and 1-(detq+ detr+dets)/2*den CGAL::Sign sign1 = CGAL_NTS sign(FT(2)*den - detq -detr -dets); if ( (CGAL_NTS sign(detq) == CGAL_NTS sign(den) || CGAL_NTS sign(detq)== ZERO) && (CGAL_NTS sign(detr) == CGAL_NTS sign(den) || CGAL_NTS sign(detr)== ZERO) && (CGAL_NTS sign(dets) == CGAL_NTS sign(den) || CGAL_NTS sign(dets)== ZERO) && ( sign1 == POSITIVE || sign1 == ZERO )) { // inside or on boundary if (CGAL_NTS sign(detq) != ZERO && CGAL_NTS sign(detr) != ZERO && CGAL_NTS sign(dets) != ZERO && sign1 != ZERO) return ON_BOUNDED_SIDE; else return ON_BOUNDARY ; } return ON_UNBOUNDED_SIDE; } // return ON_UNBOUNDED_SIDE, ON_BOUNDARY or ON_BOUNDED_SIDE according // to the position of the intersection if the radialaxis // of weighted circumcenter of pqr with affine hull of bare p,q,r // with respect with the triangle formed by bare points in p, q,r. template Bounded_side does_simplex_intersect_dual_supportC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw) { // returns true if weighted circumcenter of pqr is in // triangle pqr or on boundary FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT rr = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz); FT qr = qpx*rpx + qpy*rpy + qpz*rpz; FT qpw = qq - qw + pw ; FT rpw = rr - rw + pw ; FT den = det2x2_by_formula(qq,qr, qr,rr); FT detq = det2x2_by_formula(qpw,qr, rpw,rr); FT detr = det2x2_by_formula(qq,qpw, qr,rpw); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); // The barycentrique coordinate of the smallest orthogonal sphere center // are detq/2*den detr/2*den // and 1-(detq+ detr)/2*den CGAL::Sign sign1 = CGAL_NTS sign(FT(2)*den - detq - detr); if ( (CGAL_NTS sign(detq) == CGAL_NTS sign(den) || CGAL_NTS sign(detq)== ZERO) && (CGAL_NTS sign(detr) == CGAL_NTS sign(den) || CGAL_NTS sign(detr)== ZERO) && ( sign1 == POSITIVE || sign1 == ZERO )) { // inside or on boundary if ( CGAL_NTS sign(detq) != ZERO && CGAL_NTS sign(detr) != ZERO && sign1 != ZERO) return ON_BOUNDED_SIDE; else return ON_BOUNDARY; } return ON_UNBOUNDED_SIDE; } template Bounded_side does_simplex_intersect_dual_supportC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw) { // returns true if weighted circumcenter of pq is in // segment pq or on boundary FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qq = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT dw = pw - qw; CGAL::Sign sign1 = CGAL_NTS sign( qq + dw); CGAL::Sign sign2 = CGAL_NTS sign( qq - dw); if( ( sign1 == POSITIVE || sign1 == ZERO ) && ( sign2 == POSITIVE || sign2 == ZERO )) { // inside or on boundary if (sign1 != ZERO && sign2 != ZERO) return ON_BOUNDED_SIDE; else return ON_BOUNDARY; } return ON_UNBOUNDED_SIDE; } //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif //CGAL_PREDICATES_ON_WEIGHTED_POINTS_CARTESIAN_3 ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_is_degenerate_edge_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_is_dege0000644000175000017500000000421211344301501031301 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_is_degenerate_edge_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_IS_DEGENERATE_EDGE_2_H #define CGAL_SVD_IS_DEGENERATE_EDGE_2_H //#include //#include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------------- template class Svd_is_degenerate_edge_C2 { public: typedef typename K::Site_2 Site_2; private: typedef CGAL::Svd_voronoi_vertex_2 Voronoi_vertex_2; typedef Svd_are_same_points_C2 Are_same_points_C2; bool is_endpoint(const Site_2& p, const Site_2& s) const { CGAL_precondition( p.is_point() && s.is_segment() ); Are_same_points_C2 same_points; return same_points(p, s.source_site()) || same_points(p, s.target_site()); } public: bool operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s) { Voronoi_vertex_2 vpqr(p, q, r); if ( vpqr.incircle_no_easy(s) == POSITIVE ) { return false; } Voronoi_vertex_2 vqps(q, p, s); if ( vqps.incircle_no_easy(r) == POSITIVE ) { return false; } return true; } }; //----------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_IS_DEGENERATE_EDGE_2_H ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_is_degenerate_edge_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_is_dege0000644000175000017500000000563111344301501031164 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_is_degenerate_edge_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_IS_DEGENERATE_EDGE_C2_H #define CGAL_AG2_IS_DEGENERATE_EDGE_C2_H #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template < class K, class MTag > class Is_degenerate_edge_test { public: typedef K Kernel; typedef MTag Method_tag; typedef typename K::Site_2 Site_2; typedef CGAL::Weighted_point_inverter Weighted_point_inverter; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Bitangent_line Bitangent_line; typedef CGAL::Voronoi_circle Voronoi_circle; typedef typename K::FT FT; typedef CGAL::Sign_of_distance_from_CCW_circle Sign_of_distance_from_CCW_circle; typedef CGAL::Order_on_finite_bisector Order_on_finite_bisector; public: typedef Site_2 argument_type; typedef bool result_type; typedef Arity_tag<4> Arity; bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4) const { Method_tag tag; Weighted_point_inverter inverter(p1); Inverted_weighted_point u2 = inverter(p2); Inverted_weighted_point u3 = inverter(p3); Inverted_weighted_point u4 = inverter(p4); Sign s; Bitangent_line blinv_23(u2, u3); s = Sign_of_distance_from_CCW_circle()(blinv_23, u4, tag); if ( s != ZERO ) { return false; } Bitangent_line blinv_42(u4, u2); s = Sign_of_distance_from_CCW_circle()(blinv_42, u3, tag); if ( s != ZERO ) { return false; } Voronoi_circle vc_123(blinv_23); Voronoi_circle vc_142(blinv_42); Comparison_result r = Order_on_finite_bisector()(vc_123, vc_142, p1, p2, tag); return ( r == EQUAL ); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_IS_DEGENERATE_EDGE_C2_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/compare_quadratic.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/compare_qua0000644000175000017500000005705011344301501031372 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/compare_quadratic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_COMPARE_QUADRATIC_H #define CGAL_COMPARE_QUADRATIC_H #include CGAL_BEGIN_NAMESPACE #ifdef COMPARATOR_PROFILER #include #endif //-------------------------------------------------------------------- // help functions for the compulation of various quantites template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_D(const FT& a, const FT& b, const FT& c) { return CGAL::square(b) - a * c; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_J(const FT& a1, const FT& b1, const FT& a2, const FT& b2) { return (a1 * b2 - a2 * b1); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_Jp(const FT& b1, const FT& c1, const FT& b2, const FT& c2) { return (b1 * c2 - b2 * c1); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_G(const FT& a1, const FT& c1, const FT& a2, const FT& c2) { return (a1 * c2 - a2 * c1); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_K(const FT& a1c2, const FT& a2c1, const FT& b1b2) { return a1c2 + a2c1 - FT(2) * b1b2; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_K(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { return c1 * a2 + a1 * c2 - FT(2) * b1 * b2; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_R0(const FT& J, const FT& Jp, const FT& a1, const FT& c1, const FT& a2, const FT& c2) { return CGAL::square(a1 * c2 - c1 * a2) - FT(4) * J * Jp; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_R0(const FT& D1, const FT& D2, const FT& K) { return CGAL::square(K) - FT(4) * D1 * D2; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_P4(const FT& D1, const FT& D2, const FT& K) { return FT(4) * D1 * D2 - CGAL::square(K); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_D(const FT& a1, const FT& D1, const FT& a2, const FT& D2) { return D1 * CGAL::square(a2) - D2 * CGAL::square(a1); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_P3inf(const FT& a1, const FT& b1, const FT& J, const FT& G) { return FT(2) * b1 * J - a1 * G; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_P3inf_bis(const FT& a1, const FT& K, const FT& a2, const FT& D1) { return -(a1 * K + FT(2) * a2 * D1); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_P3pinf(const FT& c1, const FT& J, const FT& a1, const FT& Jp) { return c1 * J - a1 * Jp; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_L(const FT& a1, const FT& c2, const FT& b1, const FT& b2) { return (a1 * c2 - b1 * b2); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_Lp(const FT& a2, const FT& c1, const FT& b1, const FT& b2) { return (a2 * c1 - b1 * b2); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_A(const FT& b1, const FT& J, const FT& a1, const FT& L) { return b1 * J + a1 * L; } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_Q3(const FT& b2, const FT& a2, const FT& J, const FT& L) { return (b2 * J + a2 * L); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_Q3(const FT& a2, const FT& b2, const FT& J, const FT& G, const FT& K) { return FT(2) * b2 * J - a2 * (G - K); } template < class FT > /*CGAL_NO_FILTER*/ inline FT value_of_Q3p(const FT& a1, const FT& b1, const FT& J, const FT& G, const FT& K) { return a1 * (G + K) - FT(2) * b1 * J; } //-------------------------------------------------------------------- // the trivial method that uses square roots template < class FT > inline Comparison_result sqrt_compare_l1_l2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT l1 = ( b1 - CGAL::sqrt(D1) ) / a1; FT l2 = ( b2 - CGAL::sqrt(D2) ) / a2; return CGAL::compare(l1, l2); } template < class FT > inline Comparison_result sqrt_compare_l1_r2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT l1 = ( b1 - CGAL::sqrt(D1) ) / a1; FT r2 = ( b2 + CGAL::sqrt(D2) ) / a2; return CGAL::compare(l1, r2); } template < class FT > inline Comparison_result sqrt_compare_r1_l2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT r1 = ( b1 + CGAL::sqrt(D1) ) / a1; FT l2 = ( b2 - CGAL::sqrt(D2) ) / a2; return CGAL::compare(r1, l2); } template < class FT > inline Comparison_result sqrt_compare_r1_r2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT r1 = ( b1 + CGAL::sqrt(D1) ) / a1; FT r2 = ( b2 + CGAL::sqrt(D2) ) / a2; return CGAL::compare(r1, r2); } //-------------------------------------------------------------------- // the DFMT evaluation trees template < class FT > inline Comparison_result dfmt_compare_l1_l2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT J = value_of_J(a1, b1, a2, b2); FT K = value_of_K(a1, b1, c1, a2, b2, c2); if ( CGAL::is_positive(J) ) { if ( CGAL::is_positive(K) ) return SMALLER; // l1 < l2 FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT D = value_of_D(a1, D1, a2, D2); if ( CGAL::is_positive(D) ) return SMALLER; // l1 < l2 FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_negative(Jp) ) return LARGER; // l1 > l2 FT R0 = value_of_R0(D1, D2, K); Sign s_R0 = CGAL::sign(R0); if ( s_R0 == NEGATIVE ) return SMALLER; // l1 < l2 if ( s_R0 == POSITIVE ) return LARGER; // l1 > l2 return EQUAL; } else { // J<0 if ( CGAL::is_positive(K) ) return LARGER; // l1 > l2 FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT D = value_of_D(a1, D1, a2, D2); if ( CGAL::is_negative(D) ) return LARGER; // l1 > l2 FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_positive(Jp) ) return SMALLER; // l1 < l2 FT R0 = value_of_R0(D1, D2, K); Sign s_R0 = CGAL::sign(R0); if ( s_R0 == NEGATIVE ) return LARGER; // l1 > l2 if ( s_R0 == POSITIVE ) return SMALLER; // l1 < l2 return EQUAL; } } template < class FT > inline Comparison_result dfmt_compare_l1_r2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT J = value_of_J(a1, b1, a2, b2); if ( CGAL::is_positive(J) ) return SMALLER; // l1 < r2 FT K = value_of_K(a1, b1, c1, a2, b2, c2); if ( CGAL::is_negative(K) ) return SMALLER; // l1 < r2 FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_positive(Jp) ) return LARGER; // l1 > r2 FT R0 = value_of_R0(J, Jp, a1, c1, a2, c2); Sign s_R0 = CGAL::sign(R0); if ( s_R0 == NEGATIVE ) return SMALLER; // l1 < r2 if ( s_R0 == POSITIVE ) return LARGER; // l1 > r2 return EQUAL; } template < class FT > inline Comparison_result dfmt_compare_r1_l2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT J = value_of_J(a1, b1, a2, b2); if ( CGAL::is_negative(J) ) return LARGER; // r1 > l2 FT K = value_of_K(a1, b1, c1, a2, b2, c2); if ( CGAL::is_negative(K) ) return LARGER; // r1 > l2 FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_negative(Jp) ) return SMALLER; // r1 < l2 FT R0 = value_of_R0(J, Jp, a1, c1, a2, c2); Sign s_R0 = CGAL::sign(R0); if ( s_R0 == NEGATIVE ) return LARGER; // r1 > l2 if ( s_R0 == POSITIVE ) return SMALLER; // r1 < l2 return EQUAL; } template < class FT > inline Comparison_result dfmt_compare_r1_r2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr++; #endif FT J = value_of_J(a1, b1, a2, b2); FT K = value_of_K(a1, b1, c1, a2, b2, c2); if ( CGAL::is_positive(J) ){ if ( CGAL::is_positive(K) ) return SMALLER; // r1 < r2 1,2 #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_e++; #endif FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT D = value_of_D(a1, D1, a2, D2); if ( CGAL::is_negative(D) ) return SMALLER; // r1 < r2 2,3b #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_r0++; #endif FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_negative(Jp) ) return LARGER; // r1 > r2 3a FT R0 = value_of_R0(D1, D2, K); Sign s_R0 = CGAL::sign(R0); if ( s_R0 == NEGATIVE ) return SMALLER; // r1 < r2 2 if ( s_R0 == POSITIVE ) return LARGER; // r1 > r2 3a return EQUAL; } else { // J<0 if ( CGAL::is_positive(K) ) return LARGER; // r1 > r2 4,5 #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_e++; #endif FT D1 = value_of_D(a1, b1, c1); FT D2 = value_of_D(a2, b2, c2); FT D = value_of_D(a1, D1, a2, D2); if ( CGAL::is_positive(D) ) return LARGER; // r1 > r2 3a,4 #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_r0++; #endif FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_positive(Jp) ) return SMALLER; // r1 < r2 3b FT R0 = value_of_P4(D1, D2, K); Sign s_R0 = CGAL::sign(R0); if ( s_R0 == NEGATIVE ) return LARGER; // r1 > r2 4 if ( s_R0 == POSITIVE ) return SMALLER; // r1 < r2 3b return EQUAL; } } //-------------------------------------------------------------------- // the KE evaluation trees template < class FT > inline Comparison_result ke_compare_l1_l2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT J = value_of_J(a1, b1, a2, b2); Sign s_J = CGAL::sign(J); if ( s_J == ZERO ) { Sign s_G = CGAL::sign( value_of_G(a1, c1, a2, c2) ); if ( s_G == POSITIVE ) { return SMALLER; } if ( s_G == NEGATIVE ) { return LARGER; } return EQUAL; } FT a1c2 = a1 * c2; FT a2c1 = a2 * c1; FT K = value_of_K(a1c2, a2c1, b1 * b2); Sign s_K = CGAL::sign(K); if ( s_J == POSITIVE ) { if ( s_K == POSITIVE ) { return SMALLER; } if ( s_K == ZERO ) { FT D1 = value_of_D(a1, b1, c1); if ( CGAL::is_zero(D1) ) { return EQUAL; } return SMALLER; } FT G = a1c2 - a2c1; FT P3inf = value_of_P3inf(a1, b1, J, G); if ( !(CGAL::is_positive(P3inf)) ) { return SMALLER; } FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_negative(Jp) ) { return LARGER; } FT P4 = value_of_P4(J, Jp, G); Sign s_P4 = CGAL::sign(P4); if ( s_P4 == POSITIVE ) { return SMALLER; } if ( s_P4 == NEGATIVE ) { return LARGER; } return EQUAL; } else { // J < 0 if ( s_K == POSITIVE ) { return LARGER; } if ( s_K == ZERO ) { FT D2 = value_of_D(a2, b2, c2); if ( CGAL::is_zero(D2) ) { return EQUAL; } return LARGER; } FT G = a1c2 - a2c1; FT P3inf = value_of_P3inf(a1, b1, J, G); if ( !(CGAL::is_negative(P3inf)) ) { return LARGER; } FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_positive(Jp) ) { return SMALLER; } FT P4 = value_of_P4(J, Jp, G); Sign s_P4 = CGAL::sign(P4); if ( s_P4 == POSITIVE ) { return LARGER; } if ( s_P4 == NEGATIVE ) { return SMALLER; } return EQUAL; } } template < class FT > inline Comparison_result ke_compare_l1_r2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT J = value_of_J(a1, b1, a2, b2); FT s_J = CGAL::sign(J); #if 0 if ( s_J == ZERO ) { FT D1 = value_of_D(a1, b1, c1); if ( CGAL::is_positive(D1) ) { return SMALLER; } FT D2 = value_of_D(a2, b2, c2); if ( CGAL::is_positive(D2) ) { return SMALLER; } return EQUAL; } #endif if ( s_J == POSITIVE ) { return SMALLER; } FT a1c2 = a1 * c2; FT a2c1 = a2 * c1; FT K = value_of_K(a1c2, a2c1, b1 * b2); Sign s_K = CGAL::sign(K); if ( s_K == NEGATIVE ) { return SMALLER; } #if 0 if ( s_K == ZERO ) { FT D1 = value_of_D(a1, b1, c1); if ( CGAL::is_zero(D1) ) { return EQUAL; } FT D2 = value_of_D(a2, b2, c2); if ( CGAL::is_zero(D2) ) { return EQUAL; } return SMALLER; } #endif FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_positive(Jp) ) { return LARGER; } FT P4 = value_of_P4(J, Jp, a1c2 - a2c1); Sign s_P4 = CGAL::sign(P4); if ( s_P4 == POSITIVE ) { return SMALLER; } if ( s_P4 == NEGATIVE ) { return LARGER; } return EQUAL; } template < class FT > inline Comparison_result ke_compare_r1_l2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { FT J = value_of_J(a1, b1, a2, b2); FT s_J = CGAL::sign(J); #if 0 if ( s_J == ZERO ) { FT D1 = value_of_D(a1, b1, c1); if ( CGAL::is_positive(D1) ) { return LARGER; } FT D2 = value_of_D(a2, b2, c2); if ( CGAL::is_positive(D2) ) { return LARGER; } return EQUAL; } #endif if ( s_J == NEGATIVE ) { return LARGER; } FT a1c2 = a1 * c2; FT a2c1 = a2 * c1; FT K = value_of_K(a1c2, a2c1, b1 * b2); Sign s_K = CGAL::sign(K); if ( s_K == NEGATIVE ) { return LARGER; } #if 0 if ( s_K == ZERO ) { FT D1 = value_of_D(a1, b1, c1); if ( CGAL::is_zero(D1) ) { return EQUAL; } FT D2 = value_of_D(a2, b2, c2); if ( CGAL::is_zero(D2) ) { return EQUAL; } return LARGER; } #endif FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_negative(Jp) ) { return SMALLER; } FT P4 = value_of_P4(J, Jp, a1c2 - a2c1); Sign s_P4 = CGAL::sign(P4); if ( s_P4 == POSITIVE ) { return LARGER; } if ( s_P4 == NEGATIVE ) { return SMALLER; } return EQUAL; } template < class FT > inline Comparison_result ke_compare_r1_r2(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr++; #endif FT J = value_of_J(a1, b1, a2, b2); Sign s_J = CGAL::sign(J); FT a1c2 = a1 * c2; FT a2c1 = a2 * c1; FT K = value_of_K(a1c2, a2c1, b1 * b2); Sign s_K = CGAL::sign(K); if ( s_J == POSITIVE ) { if ( s_K == POSITIVE ) { return SMALLER; } else if ( s_K == NEGATIVE ) { #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_p3inf++; #endif FT G = a1c2 - a2c1; FT P3inf = value_of_P3inf(a1, b1, J, G); if ( !(CGAL::is_negative(P3inf)) ) { return SMALLER; } #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_p4++; #endif FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_negative(Jp) ) { return LARGER; } FT P4 = value_of_P4(J, Jp, G); Sign s_P4 = CGAL::sign(P4); if ( s_P4 == POSITIVE ) { return SMALLER; } if ( s_P4 == NEGATIVE ) { return LARGER; } return EQUAL; } else { // K = 0 FT D2 = value_of_D(a2, b2, c2); if ( CGAL::is_zero(D2) ) { return EQUAL; } return SMALLER; } } else if ( s_J == NEGATIVE ) { // J < 0 if ( s_K == POSITIVE ) { return LARGER; } else if ( s_K == NEGATIVE ) { #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_p3inf++; #endif FT G = a1c2 - a2c1; FT P3inf = value_of_P3inf(a1, b1, J, G); if ( !(CGAL::is_positive(P3inf)) ) { return LARGER; } #ifdef COMPARATOR_PROFILER comparator_profiler::counter_rr_p4++; #endif FT Jp = value_of_Jp(b1, c1, b2, c2); if ( CGAL::is_positive(Jp) ) { return SMALLER; } FT P4 = value_of_P4(J, Jp, G); Sign s_P4 = CGAL::sign(P4); if ( s_P4 == POSITIVE ) { return LARGER; } if ( s_P4 == NEGATIVE ) { return SMALLER; } return EQUAL; } else { // K = 0 FT D1 = value_of_D(a1, b1, c1); if ( CGAL::is_zero(D1) ) { return EQUAL; } return LARGER; } } else { // J = 0 Sign s_G = CGAL::sign( value_of_G(a1, c1, a2, c2) ); if ( s_G == NEGATIVE ) { return SMALLER; } if ( s_G == POSITIVE ) { return LARGER; } return EQUAL; } } //-------------------------------------------------------------------- //-------------------------------------------------------------------- //-------------------------------------------------------------------- // the following functions do the filtering for the r1-r2 tree without // using C++ exceptions template < class CT, class ET > /*CGAL_NO_FILTER*/ inline Comparison_result sqrt_compare_r1_r2_filtered(const CT& a1, const CT& b1, const CT& c1, const CT& a2, const CT& b2, const CT& c2) { typedef Interval_nt IT; FPU_CW_t backup = FPU_get_cw(); FPU_set_cw(CGAL_FE_UPWARD); IT a1i(a1), b1i(b1), c1i(c1); IT a2i(a2), b2i(b2), c2i(c2); IT D1 = value_of_D(a1i, b1i, c1i); IT D2 = value_of_D(a2i, b2i, c2i); IT r1 = ( b1i + CGAL::sqrt(D1) ) / a1i; IT r2 = ( b2i + CGAL::sqrt(D2) ) / a2i; FPU_set_cw(backup); if ( r1.sup() < r2.inf() ) { return SMALLER; } if ( r1.inf() > r2.sup() ) { return LARGER; } return sqrt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } //-------------------------------------------------------------------- template < class CT, class ET > /*CGAL_NO_FILTER*/ inline Comparison_result dfmt_compare_r1_r2_filtered(const CT& a1, const CT& b1, const CT& c1, const CT& a2, const CT& b2, const CT& c2) { typedef Interval_nt IT; FPU_CW_t backup = FPU_get_cw(); FPU_set_cw(CGAL_FE_UPWARD); IT a1i(a1), b1i(b1), c1i(c1); IT a2i(a2), b2i(b2), c2i(c2); IT J = value_of_J(a1i, b1i, a2i, b2i); IT K = value_of_K(a1i, b1i, c1i, a2i, b2i, c2i); if ( J.inf() > 0 ){ if ( K.inf() > 0 ) { FPU_set_cw(backup); return SMALLER; } if ( K.sup() > 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT D1 = value_of_D(a1i, b1i, c1i); IT D2 = value_of_D(a2i, b2i, c2i); IT D = value_of_D(a1i, D1, a2i, D2); if ( D.sup() < 0 ) { FPU_set_cw(backup); return SMALLER; } if ( D.inf() < 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT Jp = value_of_Jp(b1i, c1i, b2i, c2i); if ( Jp.sup() < 0 ) { FPU_set_cw(backup); return LARGER; } if ( Jp.inf() < 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT R0 = value_of_R0(D1, D2, K); FPU_set_cw(backup); if ( R0.sup() < 0 ) { return SMALLER; } if ( R0.inf() > 0 ) { return LARGER; } return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } else if ( J.sup() > 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } else { // J < 0 if ( K.inf() > 0 ) { FPU_set_cw(backup); return LARGER; } if ( K.sup() > 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT D1 = value_of_D(a1i, b1i, c1i); IT D2 = value_of_D(a2i, b2i, c2i); IT D = value_of_D(a1i, D1, a2i, D2); if ( D.inf() > 0 ) { FPU_set_cw(backup); return LARGER; } if ( D.sup() > 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT Jp = value_of_Jp(b1i, c1i, b2i, c2i); if ( Jp.inf() > 0 ) { FPU_set_cw(backup); return SMALLER; } if ( Jp.sup() > 0 ) { FPU_set_cw(backup); return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT R0 = value_of_P4(D1, D2, K); FPU_set_cw(backup); if ( R0.sup() < 0 ) { return LARGER; } if ( R0.inf() > 0 ) { return SMALLER; } return dfmt_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } } //-------------------------------------------------------------------- template < class CT, class ET > /*CGAL_NO_FILTER*/ inline Comparison_result ke_compare_r1_r2_filtered(const CT& a1, const CT& b1, const CT& c1, const CT& a2, const CT& b2, const CT& c2) { typedef Interval_nt IT; FPU_CW_t backup = FPU_get_cw(); FPU_set_cw(CGAL_FE_UPWARD); IT a1i(a1), b1i(b1), c1i(c1); IT a2i(a2), b2i(b2), c2i(c2); IT J = value_of_J(a1i, b1i, a2i, b2i); IT a1c2 = a1i * c2i; IT a2c1 = a2i * c1i; IT K = value_of_K(a1c2, a2c1, b1i * b2i); if ( J.inf() > 0 ) { if ( K.inf() > 0 ) { FPU_set_cw(backup); return SMALLER; } else if ( K.sup() < 0 ) { IT G = a1c2 - a2c1; IT P3inf = value_of_P3inf(a1i, b1i, J, G); if ( P3inf.inf() >= 0 ) { FPU_set_cw(backup); return SMALLER; } if ( P3inf.sup() > 0 ) { FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT Jp = value_of_Jp(b1i, c1i, b2i, c2i); if ( Jp.sup() < 0 ) { FPU_set_cw(backup); return LARGER; } if ( Jp.inf() < 0 ) { FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT P4 = value_of_P4(J, Jp, G); FPU_set_cw(backup); if ( P4.inf() > 0 ) { return SMALLER; } if ( P4.sup() < 0 ) { return LARGER; } return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } else { FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } } else if ( J.sup() < 0 ) { // J < 0 if ( K.inf() > 0 ) { FPU_set_cw(backup); return LARGER; } else if ( K.sup() < 0 ) { IT G = a1c2 - a2c1; IT P3inf = value_of_P3inf(a1i, b1i, J, G); if ( P3inf.sup() <= 0 ) { FPU_set_cw(backup); return LARGER; } if ( P3inf.inf() < 0 ) { FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT Jp = value_of_Jp(b1i, c1i, b2i, c2i); if ( Jp.inf() > 0 ) { FPU_set_cw(backup); return SMALLER; } if ( Jp.sup() > 0 ) { FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } IT P4 = value_of_P4(J, Jp, G); FPU_set_cw(backup); if ( P4.inf() > 0 ) { return LARGER; } if ( P4.sup() < 0 ) { return SMALLER; } return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } else { FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } } else { // J = ? FPU_set_cw(backup); return ke_compare_r1_r2(ET(a1), ET(b1), ET(c1), ET(a2), ET(b2), ET(c2)); } } //-------------------------------------------------------------------- //-------------------------------------------------------------------- CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #ifndef CGAL_ARITHMETIC_FILTER_COMPARE_QUADRATIC_H #include #endif // CGAL_ARITHMETIC_FILTER_COMPARE_QUADRATIC_H #endif // CGAL_ARITHMETIC_FILTER_H #endif // CGAL_COMPARE_QUADRATIC ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicate_profiler.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicate_p0000644000175000017500000000472411344301501031355 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicate_profiler.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_PREDICATE_PROFILER #define CGAL_AG2_PREDICATE_PROFILER #define AG2_PROFILE_PREDICATES CGAL_BEGIN_NAMESPACE class ag2_predicate_profiler { public: // high level predicates static unsigned long side_of_bisector_counter; static unsigned long is_trivial_counter; static unsigned long infinite_edge_conflict_type_counter; static unsigned long finite_edge_conflict_type_counter; // subpredicates static unsigned long inside_circular_arc_counter; static unsigned long distance_from_bitangent_counter; static unsigned long shadow_region_type_counter; static unsigned long incircle_counter; static unsigned long order_on_bisector_counter; static void reset() { side_of_bisector_counter = 0; is_trivial_counter = 0; infinite_edge_conflict_type_counter = 0; finite_edge_conflict_type_counter = 0; inside_circular_arc_counter = 0; distance_from_bitangent_counter = 0; shadow_region_type_counter = 0; incircle_counter = 0; order_on_bisector_counter = 0; } }; unsigned long ag2_predicate_profiler::side_of_bisector_counter = 0; unsigned long ag2_predicate_profiler::is_trivial_counter = 0; unsigned long ag2_predicate_profiler::infinite_edge_conflict_type_counter = 0; unsigned long ag2_predicate_profiler::finite_edge_conflict_type_counter = 0; unsigned long ag2_predicate_profiler::inside_circular_arc_counter = 0; unsigned long ag2_predicate_profiler::distance_from_bitangent_counter = 0; unsigned long ag2_predicate_profiler::shadow_region_type_counter = 0; unsigned long ag2_predicate_profiler::incircle_counter = 0; unsigned long ag2_predicate_profiler::order_on_bisector_counter = 0; CGAL_END_NAMESPACE #endif // CGAL_AG2_PREDICATE_PROFILER ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Square_root_1.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Square_root0000644000175000017500000001641211344301501031376 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Square_root_1.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SQUARE_ROOT_1_H #define CGAL_SQUARE_ROOT_1_H #include #include #include #define CHECK_CGAL_PRECONDITIONS 0 CGAL_BEGIN_NAMESPACE template class Square_root_1; template Sign sign(const Square_root_1&); template Comparison_result compare(const Square_root_1&, const Square_root_1&); template class Square_root_1 { private: NT x, y, r; private: typedef Square_root_1 Self; public: typedef NT FT; typedef NT RT; Square_root_1() : x(0), y(0), r(0) {} Square_root_1(int i) : x(i), y(0), r(0) {} Square_root_1(const NT& a) : x(a), y(0), r(0) {} Square_root_1(const NT& a, const NT& b, const NT& c) : x(a), y(b), r(c) { #if CHECK_CGAL_PRECONDITIONS CGAL_assertion( !(CGAL::is_negative(r)) ); #endif } Square_root_1(const Square_root_1& other) : x(other.x), y(other.y), r(other.r) {} NT a() const { return x; } NT b() const { return y; } NT c() const { return r; } Self square() const { NT xy = x * y; return Self(CGAL::square(x) + CGAL::square(y) * r, xy + xy, r); } Sign sign() const { Sign sx = CGAL::sign(x); if ( CGAL::sign(r) == ZERO ) { return sx; } Sign sy = CGAL::sign(y); if ( sx == sy ) { return sx; } if ( sx == ZERO ) { return sy; } return Sign( sx * CGAL::compare( CGAL::square(x), r * CGAL::square(y) ) ); } Self operator+() const { return (*this); } Self operator-() const { return Self(-x, -y, r); } double to_double() const { // THIS MUST BE CHECK WITH SYLVAIN FOR CORRECTNESS double xd = CGAL::to_double(x); double yd = CGAL::to_double(y); double rd = CGAL::to_double(r); return (xd + yd * CGAL::sqrt(rd)); } std::pair to_interval() const { // THIS MUST BE CHECK WITH SYLVAIN FOR CORRECTNESS std::pair x_ivl = CGAL::to_interval(x); std::pair y_ivl = CGAL::to_interval(y); std::pair r_ivl = CGAL::to_interval(r); std::pair sqrt_r_ivl(CGAL::sqrt(r_ivl.first), CGAL::sqrt(r_ivl.second)); std::pair ivl(x_ivl.first + y_ivl.first * sqrt_r_ivl.first, x_ivl.second + y_ivl.second * sqrt_r_ivl.second); return ivl; } }; // operator * template inline Square_root_1 operator*(const Square_root_1& x, const NT& n) { return Square_root_1(x.a() * n, x.b() * n, x.c()); } template inline Square_root_1 operator*(const NT& n, const Square_root_1& x) { return (x * n); } template inline Square_root_1 operator*(const Square_root_1& x, const Square_root_1& y) { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( CGAL::compare(x.c(), y.c()) == EQUAL ); #endif NT a = x.a() * y.a() + x.b() * y.b() * x.c(); NT b = x.a() * y.b() + x.b() * y.a(); return Square_root_1(a, b, x.c()); } // operator + template inline Square_root_1 operator+(const Square_root_1& x, const NT& n) { return Square_root_1(x.a() + n, x.b(), x.c()); } template inline Square_root_1 operator+(const NT& n, const Square_root_1& x) { return (x + n); } template inline Square_root_1 operator+(const Square_root_1& x, const Square_root_1& y) { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( CGAL::compare(x.c(), y.c()) == EQUAL ); #endif return Square_root_1(x.a() + y.a(), x.b() + y.b(), x.c()); } // operator - template inline Square_root_1 operator-(const Square_root_1& x, const NT& n) { return x + (-n); } template inline Square_root_1 operator-(const NT& n, const Square_root_1& x) { return -(x - n); } template inline Square_root_1 operator-(const Square_root_1& x, const Square_root_1& y) { return (x + (-y)); } //============================================================= template struct Number_type_traits< Square_root_1 > { static inline std::pair to_interval(const Square_root_1& x) { return x.to_interval(); } static inline bool is_positive(const Square_root_1& x) { return x.sign() == POSITIVE; } static inline bool is_negative(const Square_root_1& x) { return x.sign() == NEGATIVE; } static inline bool is_zero(const Square_root_1& x) { return x.sign() == ZERO; } static inline Sign sign(const Square_root_1& x) { return x.sign(); } static inline Square_root_1 square(const Square_root_1& x) { return x.square(); } static inline Comparison_result compare(const Square_root_1& x, const Square_root_1& y) { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( CGAL::compare(x.c(), y.c()) == EQUAL ); #endif // Sign s = CGAL::sign(x - y); Sign s = (x - y).sign(); if ( s == ZERO ) { return EQUAL; } return (s == POSITIVE) ? LARGER : SMALLER; } static inline double to_double(const Square_root_1& x) { return x.to_double(); } }; template inline std::pair to_interval(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::to_interval(x); } template inline bool is_positive(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::is_positive(x); } template inline bool is_negative(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::is_negative(x); } template inline bool is_zero(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::is_zero(x); } template inline Sign sign(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::sign(x); } template inline Square_root_1 square(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::square(x); } template inline Comparison_result compare(const Square_root_1& x, const Square_root_1& y) { return Number_type_traits< Square_root_1 >::compare(x, y); } template inline double to_double(const Square_root_1& x) { return Number_type_traits< Square_root_1 >::to_double(x); } // operator << template inline Stream& operator<<(Stream& os, const Square_root_1& x) { os << "(" << x.a() << ")+(" << x.b() << ") sqrt{" << x.c() << "}"; return os; } CGAL_END_NAMESPACE #endif // CGAL_SQUARE_ROOT_1_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_graph_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_0000644000175000017500000004230711344301501031361 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_graph_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_FTC2_H #define CGAL_APOLLONIUS_GRAPH_FTC2_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template< class RT > inline Orientation ag2_orientation_test_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Ag2_orientation_2 f; return f(p1, p2, p3); } //-------------------------------------------------------------------- template< class RT > inline bool ad_is_hidden_test_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2) { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::is_trivial_counter++; #endif must_be_filtered(x1); Sign s = CGAL::sign( CGAL::square(x1 - x2) + CGAL::square(y1 - y2) - CGAL::square(w1 - w2) ); if ( s == POSITIVE ) { return false; } return (CGAL::compare(w1, w2) != SMALLER); } template< class RT > inline bool ad_is_hidden_test_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2) { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::is_trivial_counter++; #endif RT d = CGAL::sqrt(CGAL::square(x1 - x2) + CGAL::square(y1 - y2)); Sign s = CGAL::sign(d - w1 + w2); return ( s != POSITIVE ); } //-------------------------------------------------------------------- template< class RT > CGAL_MEDIUM_INLINE Comparison_result compare_ad_distances_test_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT & x, const RT & y) { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::side_of_bisector_counter++; #endif must_be_filtered(x1); // this function compares the distances of the point(x, y) from the // disks {(x1, y1), w1} and {(x2, y2), w2} RT D1 = CGAL::square(x1 - x) + CGAL::square(y1 - y); RT D2 = CGAL::square(x2 - x) + CGAL::square(y2 - y); RT Dw = w2 - w1; Sign sign_of_Dw = CGAL::sign(Dw); Comparison_result R = CGAL::compare(D1, D2); if ( sign_of_Dw == ZERO ) { return R; } if ( sign_of_Dw == POSITIVE ) { if ( R != SMALLER ) return LARGER; Sign s = sign_a_plus_b_x_sqrt_c(D1 - D2 + CGAL::square(Dw), RT(2) * Dw, D1); return ((s == POSITIVE) ? LARGER : ((s == ZERO) ? EQUAL : SMALLER)); } if ( R != LARGER ) return SMALLER; Sign s = sign_a_plus_b_x_sqrt_c(D1 - D2 - CGAL::square(Dw), RT(2) * Dw, D2); return ((s == POSITIVE) ? LARGER : ((s == ZERO) ? EQUAL : SMALLER)); } //-------------------------------------------------------------------- template< class RT > CGAL_MEDIUM_INLINE Comparison_result compare_ad_distances_test_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT & x, const RT & y) { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::side_of_bisector_counter++; #endif // this function compares the distances of the point(x, y) from the // disks {(x1, y1), w1} and {(x2, y2), w2} RT D1 = CGAL::square(x1 - x) + CGAL::square(y1 - y); RT D2 = CGAL::square(x2 - x) + CGAL::square(y2 - y); RT d1 = CGAL::sqrt(D1) - w1; RT d2 = CGAL::sqrt(D2) - w2; return CGAL::compare(d1, d2); } //-------------------------------------------------------------------- template< class RT > /*CGAL_NO_FILTER*/ Bounded_side bounded_side_of_segment(const RT& x1, const RT& y1, const RT& x2, const RT& y2, const RT& x, const RT& y) { // this function tests whether the point (x, y) is in the interior // of the segment defined by (x1, y1) and (x2, y2). // It is assumed that the three points are collinear. // The result is ON_BOUNDED_SIDE if the point (x,y) is in the // interior of the segment, ON_BOUNDARY if (x,y) coincides with // either (x1, y1) or (x1, y1) and ON_UNBOUNDED_SIDE otherwise. CGAL_precondition( sign_of_determinant2x2(x1-x,y1-y,x2-x,y2-y) == ZERO ); Comparison_result rx1 = CGAL::compare(x, x1); Comparison_result ry1 = CGAL::compare(y, y1); if ( rx1 == EQUAL && ry1 == EQUAL ) { return ON_BOUNDARY; } Comparison_result rx2 = CGAL::compare(x, x2); Comparison_result ry2 = CGAL::compare(y, y2); if ( rx2 == EQUAL && ry2 == EQUAL ) { return ON_BOUNDARY; } Comparison_result rx12 = CGAL::compare(x1, x2); if ( rx12 == SMALLER ) { CGAL_assertion( rx1 != EQUAL && rx2 != EQUAL ); return ( rx1 == LARGER && rx2 == SMALLER ) ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } else if ( rx12 == LARGER ) { CGAL_assertion( rx1 != EQUAL && rx2 != EQUAL ); return ( rx1 == SMALLER && rx2 == LARGER ) ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } Comparison_result ry12 = CGAL::compare(y1, y2); CGAL_assertion( ry12 != EQUAL ); CGAL_assertion( ry1 != EQUAL && ry2 != EQUAL ); if ( ry12 == SMALLER ) { return ( ry1 == LARGER && ry2 == SMALLER ) ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } CGAL_assertion( ry12 == LARGER ); return ( ry1 == SMALLER && ry2 == LARGER ) ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } //-------------------------------------------------------------------- template < class RT > Sign ad_incircle_test_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &qx, const RT &qy, const RT &qw) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 q(Point_2(qx, qy), qw); Incircle_test f; return f(p1, p2, q); } template < class RT > Sign ad_incircle_test_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &qx, const RT &qy, const RT &qw) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 q(Point_2(qx, qy), qw); Incircle_test f; return f(p1, p2, q); } //-------------------------------------------------------------------- template < class RT > Sign ad_incircle_test_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &qx, const RT &qy, const RT &qw) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 q(Point_2(qx, qy), qw); Incircle_test f; return f(p1, p2, p3, q); } template < class RT > Sign ad_incircle_test_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &qx, const RT &qy, const RT &qw) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 q(Point_2(qx, qy), qw); Incircle_test f; return f(p1, p2, p3, q); } //-------------------------------------------------------------------- template < class RT > bool ad_finite_edge_test_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &x4, const RT &y4, const RT &w4, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 p4(Point_2(x4, y4), w4); Site_2 q(Point_2(qx, qy), qw); Ag2_finite_edge_test_C2 f; return f(p1, p2, p3, p4, q, b); } template < class RT > bool ad_finite_edge_test_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &x4, const RT &y4, const RT &w4, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 p4(Point_2(x4, y4), w4); Site_2 q(Point_2(qx, qy), qw); Ag2_finite_edge_test_C2 f; return f(p1, p2, p3, p4, q, b); } //-------------------------------------------------------------------- template < class RT > bool ad_finite_edge_test_degenerated_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 q(Point_2(qx, qy), qw); Ag2_finite_edge_test_C2 f; return f(p1, p2, q, b); } template < class RT > bool ad_finite_edge_test_degenerated_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 q(Point_2(qx, qy), qw); Ag2_finite_edge_test_C2 f; return f(p1, p2, q, b); } template < class RT > bool ad_finite_edge_test_degenerated_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 q(Point_2(qx, qy), qw); Ag2_finite_edge_test_C2 f; return f(p1, p2, p3, q, b); } template < class RT > bool ad_finite_edge_test_degenerated_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 q(Point_2(qx, qy), qw); Ag2_finite_edge_test_C2 f; return f(p1, p2, p3, q, b); } //-------------------------------------------------------------------- template < class RT > bool ad_infinite_edge_test_sqrtf_C2(const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &x4, const RT &y4, const RT &w4, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x2); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 p4(Point_2(x4, y4), w4); Site_2 q(Point_2(qx, qy), qw); Infinite_edge_test f; return f(p2, p3, p4, q, b); } template < class RT > bool ad_infinite_edge_test_ring_C2(const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &x4, const RT &y4, const RT &w4, const RT &qx, const RT &qy, const RT &qw, bool b) { must_be_filtered(x2); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 p4(Point_2(x4, y4), w4); Site_2 q(Point_2(qx, qy), qw); Infinite_edge_test f; return f(p2, p3, p4, q, b); } //-------------------------------------------------------------------- template < class RT > bool ad_is_degenerate_edge_test_sqrtf_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &x4, const RT &y4, const RT &w4) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 p4(Point_2(x4, y4), w4); Is_degenerate_edge_test f; return f(p1, p2, p3, p4); } template < class RT > bool ad_is_degenerate_edge_test_ring_C2(const RT &x1, const RT &y1, const RT &w1, const RT &x2, const RT &y2, const RT &w2, const RT &x3, const RT &y3, const RT &w3, const RT &x4, const RT &y4, const RT &w4) { must_be_filtered(x1); typedef Simple_cartesian Rep; typedef Apollonius_graph_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; Site_2 p1(Point_2(x1, y1), w1); Site_2 p2(Point_2(x2, y2), w2); Site_2 p3(Point_2(x3, y3), w3); Site_2 p4(Point_2(x4, y4), w4); Is_degenerate_edge_test f; return f(p1, p2, p3, p4); } //-------------------------------------------------------------------- CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #ifndef CGAL_ARITHMETIC_FILTER_APOLLONIUS_GRAPH_FTC2_H #include #endif // CGAL_ARITHMETIC_FILTER_APOLLONIUS_GRAPH_FTC2_H #endif #endif // CGAL_APOLLONIUS_GRAPH_FTC2_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_same_points_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_sam0000644000175000017500000000511311344301501031312 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_same_points_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_ARE_SAME_POINTS_C2_H #define CGAL_SVD_ARE_SAME_POINTS_C2_H CGAL_BEGIN_NAMESPACE template class Svd_are_same_points_C2 { private: typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; typedef typename K::Compare_x_2 Compare_x_2; typedef typename K::Compare_y_2 Compare_y_2; typedef typename K::Intersections_tag ITag; Compare_x_2 compare_x_2; Compare_y_2 compare_y_2; bool are_same(const Point_2& p, const Point_2& q) const { return compare_x_2(p, q) == EQUAL && compare_y_2(p, q) == EQUAL; } bool are_same(const Site_2& s, const Site_2& t) const { return ( are_same(s.source(), t.source()) && are_same(s.target(), t.target()) ) || ( are_same(s.source(), t.target()) && are_same(s.target(), t.source()) ); } bool predicate(const Site_2& p, const Site_2& q, const Tag_false&) const { return are_same(p.point(), q.point()); } bool predicate(const Site_2& p, const Site_2& q, const Tag_true&) const { if ( !p.is_input() && !q.is_input() ) { Site_2 s[2] = { p.supporting_site(0), p.supporting_site(1) }; Site_2 t[2] = { q.supporting_site(0), q.supporting_site(1) }; if ( ( are_same(s[0], t[0]) && are_same(s[1], t[1]) ) || ( are_same(s[0], t[1]) && are_same(s[1], t[0]) ) ) { return true; } } return predicate(p, q, Tag_false()); } public: typedef bool result_type; typedef Site_2 argument_type; typedef Arity_tag<2> Arity; bool operator()(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_point() && q.is_point() ); return predicate(p, q, ITag()); } }; CGAL_END_NAMESPACE #endif // CGAL_SVD_ARE_SAME_POINTS_C2_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/check_filter.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/check_filte0000644000175000017500000000225411344301501031332 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/check_filter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_CHECK_FILTER_H #define CGAL_CHECK_FILTER_H #undef CGAL_IA_NEW_FILTERS namespace CGAL { template < class T> void must_be_filtered(const T&) {} #if defined CGAL_ARITHMETIC_FILTER_H template < class CT, class ET, class Type, bool Protection, class Cache> void must_be_filtered(const Filtered_exact &) { dont_compile(CT(), ET()); } #endif } #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare_y_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare0000644000175000017500000000272711344301501031216 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare_y_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_COMPARE_Y_2_H #define CGAL_AG2_COMPARE_Y_2_H #include //-------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE template class Ag2_compare_y_2 { public: typedef K Kernel; typedef typename K::Site_2 Site_2; typedef Comparison_result result_type; typedef Arity_tag<2> Arity; typedef Site_2 argument_type; inline Comparison_result operator()(const Site_2& s1, const Site_2& s2) const { return CGAL::compare(s1.y(), s2.y()); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_COMPARE_Y_2_H ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_vertex_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Vor0000644000175000017500000000401011344301501031312 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_vertex_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_2_H #include #include CGAL_BEGIN_NAMESPACE template struct Svd_which_rep_2; template<> struct Svd_which_rep_2 { template struct Which_rep { typedef Svd_voronoi_vertex_C2 Rep; }; }; template<> struct Svd_which_rep_2 { template struct Which_base { typedef Svd_voronoi_vertex_H2 Rep; }; }; //---------------------------------------------------------------------- template class Svd_voronoi_vertex_2 : public Svd_which_rep_2::template Which_rep::Rep { private: typedef typename K::Rep_tag Rep_tag; typedef typename Svd_which_rep_2::template Which_rep::Rep Base; typedef typename Base::Site_2 Site_2; public: Svd_voronoi_vertex_2(const Site_2& p, const Site_2& q, const Site_2& r) : Base(p, q, r) {} }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_2_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_tri0000644000175000017500000001305211344301501031347 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_REGULAR_TRIANGULATION_FTC3_H #define CGAL_REGULAR_TRIANGULATION_FTC3_H // This file contains the low level cartesian predicates // used by the 3D regular triangulation. CGAL_BEGIN_NAMESPACE // return the sign of the 5x5 determinant [P,Q,R,S,T] // where column [P] = transpose[px,py,pz,p^2 -wp,1] template Oriented_side power_testC3( const FT &px, const FT &py, const FT &pz, const FT &pwt, const FT &qx, const FT &qy, const FT &qz, const FT &qwt, const FT &rx, const FT &ry, const FT &rz, const FT &rwt, const FT &sx, const FT &sy, const FT &sz, const FT &swt, const FT &tx, const FT &ty, const FT &tz, const FT &twt) { // We translate the points so that T becomes the origin. FT dpx = px - tx; FT dpy = py - ty; FT dpz = pz - tz; FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) + CGAL_NTS square(dpz) - pwt + twt; FT dqx = qx - tx; FT dqy = qy - ty; FT dqz = qz - tz; FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) + CGAL_NTS square(dqz) - qwt + twt; FT drx = rx - tx; FT dry = ry - ty; FT drz = rz - tz; FT drt = CGAL_NTS square(drx) + CGAL_NTS square(dry) + CGAL_NTS square(drz) - rwt + twt; FT dsx = sx - tx; FT dsy = sy - ty; FT dsz = sz - tz; FT dst = CGAL_NTS square(dsx) + CGAL_NTS square(dsy) + CGAL_NTS square(dsz) - swt + twt; return Oriented_side( - sign_of_determinant4x4(dpx, dpy, dpz, dpt, dqx, dqy, dqz, dqt, drx, dry, drz, drt, dsx, dsy, dsz, dst)); } template Oriented_side power_testC3( const FT &px, const FT &py, const FT &pz, const FT &pwt, const FT &qx, const FT &qy, const FT &qz, const FT &qwt, const FT &rx, const FT &ry, const FT &rz, const FT &rwt, const FT &tx, const FT &ty, const FT &tz, const FT &twt) { // Same translation as above. FT dpx = px - tx; FT dpy = py - ty; FT dpz = pz - tz; FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) + CGAL_NTS square(dpz) - pwt + twt; FT dqx = qx - tx; FT dqy = qy - ty; FT dqz = qz - tz; FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) + CGAL_NTS square(dqz) - qwt + twt; FT drx = rx - tx; FT dry = ry - ty; FT drz = rz - tz; FT drt = CGAL_NTS square(drx) + CGAL_NTS square(dry) + CGAL_NTS square(drz) - rwt + twt; Sign cmp; // Projection on the (xy) plane. cmp = sign_of_determinant3x3(dpx, dpy, dpt, dqx, dqy, dqt, drx, dry, drt); if (cmp != ZERO) return Oriented_side(cmp * sign_of_determinant2x2(px-rx, py-ry, qx-rx, qy-ry)); // Projection on the (xz) plane. cmp = sign_of_determinant3x3(dpx, dpz, dpt, dqx, dqz, dqt, drx, drz, drt); if (cmp != ZERO) return Oriented_side(cmp * sign_of_determinant2x2(px-rx, pz-rz, qx-rx, qz-rz)); // Projection on the (yz) plane. cmp = sign_of_determinant3x3(dpy, dpz, dpt, dqy, dqz, dqt, dry, drz, drt); return Oriented_side(cmp * sign_of_determinant2x2(py-ry, pz-rz, qy-ry, qz-rz)); } template Oriented_side power_testC3( const FT &px, const FT &py, const FT &pz, const FT &pwt, const FT &qx, const FT &qy, const FT &qz, const FT &qwt, const FT &tx, const FT &ty, const FT &tz, const FT &twt) { // Same translation as above. FT dpx = px - tx; FT dpy = py - ty; FT dpz = pz - tz; FT dpt = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) + CGAL_NTS square(dpz) - pwt + twt; FT dqx = qx - tx; FT dqy = qy - ty; FT dqz = qz - tz; FT dqt = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) + CGAL_NTS square (dqz) - qwt + twt; Comparison_result cmp; // We do an orthogonal projection on the (x) axis, if possible. cmp = CGAL_NTS compare(px, qx); if (cmp != EQUAL) return Oriented_side(cmp * sign_of_determinant2x2(dpx, dpt, dqx, dqt)); // We do an orthogonal projection on the (y) axis, if possible. cmp = CGAL_NTS compare(py, qy); if (cmp != EQUAL) return Oriented_side(cmp * sign_of_determinant2x2(dpy, dpt, dqy, dqt)); // We do an orthogonal projection on the (z) axis. cmp = CGAL_NTS compare(pz, qz); return Oriented_side(cmp * sign_of_determinant2x2(dpz, dpt, dqz, dqt)); } template Oriented_side power_testC3(const FT &pwt, const FT &qwt) { return Oriented_side(CGAL_NTS compare(qwt, pwt)); } CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #include #endif #endif // CGAL_REGULAR_TRIANGULATION_FTC3_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_tri0000644000175000017500000000615311344301501031353 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // Mariette Yvinec #ifndef CGAL_REGULAR_TRIANGULATION_FTC2_H #define CGAL_REGULAR_TRIANGULATION_FTC2_H // This file contains the low level cartesian predicates // used by the 2D regular triangulation. CGAL_BEGIN_NAMESPACE template Oriented_side power_testC2( const FT &px, const FT &py, const FT &pwt, const FT &qx, const FT &qy, const FT &qwt, const FT &rx, const FT &ry, const FT &rwt, const FT &tx, const FT &ty, const FT &twt) { // Note: maybe this can be further optimized like the usual in_circle() ? // We translate the 4 points so that T becomes the origin. FT dpx = px - tx; FT dpy = py - ty; FT dpz = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) - pwt + twt; FT dqx = qx - tx; FT dqy = qy - ty; FT dqz = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) - qwt + twt; FT drx = rx - tx; FT dry = ry - ty; FT drz = CGAL_NTS square(drx) + CGAL_NTS square(dry) - rwt + twt; return Oriented_side(sign_of_determinant3x3(dpx, dpy, dpz, dqx, dqy, dqz, drx, dry, drz)); } template Oriented_side power_testC2( const FT &px, const FT &py, const FT &pwt, const FT &qx, const FT &qy, const FT &qwt, const FT &tx, const FT &ty, const FT &twt) { // Same translation as above. FT dpx = px - tx; FT dpy = py - ty; FT dpz = CGAL_NTS square(dpx) + CGAL_NTS square(dpy) - pwt + twt; FT dqx = qx - tx; FT dqy = qy - ty; FT dqz = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) - qwt + twt; // We do an orthogonal projection on the (x) axis, if possible. Comparison_result cmpx = CGAL_NTS compare(px, qx); if (cmpx != EQUAL) return Oriented_side(cmpx * sign_of_determinant2x2(dpx, dpz, dqx, dqz)); // If not possible, then on the (y) axis. Comparison_result cmpy = CGAL_NTS compare(py, qy); return Oriented_side(cmpy * sign_of_determinant2x2(dpy, dpz, dqy, dqz)); } CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H #include #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H #endif #endif // CGAL_REGULAR_TRIANGULATION_FTC2_H ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_oriented_side_of_bisector_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_oriente0000644000175000017500000000725211344301501031233 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_oriented_side_of_bisector_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_ORIENTED_SIDE_OF_BISECTOR_C2_H #define CGAL_AG2_ORIENTED_SIDE_OF_BISECTOR_C2_H #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template class Ag2_oriented_side_of_bisector_C2 { public: typedef K Kernel; typedef MTag Method_tag; typedef typename K::Point_2 Point_2; typedef typename K::Site_2 Site_2; private: typedef typename Kernel::RT RT; private: Comparison_result compare_distances(const Site_2& p1, const Site_2& p2, const Point_2& p, const Ring_tag&) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::side_of_bisector_counter++; #endif // this function compares the distances of the point(x, y) from the // disks {(x1, y1), w1} and {(x2, y2), w2} RT D1 = CGAL::square(p1.x() - p.x()) + CGAL::square(p1.y() - p.y()); RT D2 = CGAL::square(p2.x() - p.x()) + CGAL::square(p2.y() - p.y()); RT Dw = p2.weight() - p1.weight(); Sign sign_of_Dw = CGAL::sign(Dw); Comparison_result R = CGAL::compare(D1, D2); if ( sign_of_Dw == ZERO ) { return R; } if ( sign_of_Dw == POSITIVE ) { if ( R != SMALLER ) return LARGER; Sign s = sign_a_plus_b_x_sqrt_c(D1 - D2 + CGAL::square(Dw), RT(2) * Dw, D1); return ((s == POSITIVE) ? LARGER : ((s == ZERO) ? EQUAL : SMALLER)); } if ( R != LARGER ) return SMALLER; Sign s = sign_a_plus_b_x_sqrt_c(D1 - D2 - CGAL::square(Dw), RT(2) * Dw, D2); return ((s == POSITIVE) ? LARGER : ((s == ZERO) ? EQUAL : SMALLER)); } Comparison_result compare_distances(const Site_2& p1, const Site_2& p2, const Point_2 &p, const Sqrt_field_tag&) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::side_of_bisector_counter++; #endif // this function compares the distances of the point(x, y) from the // disks {(x1, y1), w1} and {(x2, y2), w2} RT D1 = CGAL::square(p1.x() - p.x()) + CGAL::square(p1.y() - p.y()); RT D2 = CGAL::square(p2.x() - p.x()) + CGAL::square(p2.y() - p.y()); RT d1 = CGAL::sqrt(D1) - p1.weight(); RT d2 = CGAL::sqrt(D2) - p2.weight(); return CGAL::compare(d1, d2); } public: typedef Oriented_side result_type; typedef Arity_tag<3> Arity; struct argument_type {}; inline Oriented_side operator()(const Site_2& p1, const Site_2& p2, const Point_2 &p) const { Comparison_result r = compare_distances(p1, p2, p, Method_tag()); if ( r == EQUAL ) { return ON_ORIENTED_BOUNDARY; } return ( r == LARGER ) ? ON_NEGATIVE_SIDE : ON_POSITIVE_SIDE; } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_ORIENTED_SIDE_OF_BISECTOR_C2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_incircle_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_incircl0000644000175000017500000003455211344301501031337 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_incircle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_INCIRCLE_2_H #define CGAL_SVD_INCIRCLE_2_H #include #include #include CGAL_BEGIN_NAMESPACE //--------------------------------------------------------------------- template class Svd_incircle_2 { private: typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; typedef CGAL::Svd_voronoi_vertex_2 Voronoi_vertex_2; typedef typename K::FT FT; typedef typename K::RT RT; typedef Svd_are_same_points_C2 Are_same_points_C2; typedef Svd_are_same_segments_C2 Are_same_segments_C2; typedef typename K::Intersections_tag ITag; private: Are_same_points_C2 same_points; Are_same_segments_C2 same_segments; bool is_on_common_support(const Site_2& s1, const Site_2& s2, const Point_2& p) const { CGAL_precondition( !s1.is_input() && !s2.is_input() ); if ( same_segments(s1.supporting_site(0), s2.supporting_site(0)) || same_segments(s1.supporting_site(0), s2.supporting_site(1)) ) { Site_2 support = s1.supporting_site(0); Site_2 tp = Site_2::construct_site_2(p); return ( same_points(support.source_site(), tp) || same_points(support.target_site(), tp) ); } else if ( same_segments(s1.supporting_site(1), s2.supporting_site(1)) || same_segments(s1.supporting_site(1), s2.supporting_site(0)) ) { Site_2 support = s1.supporting_site(1); Site_2 tp = Site_2::construct_site_2(p); return ( same_points(support.source_site(), tp) || same_points(support.target_site(), tp) ); } return false; } bool have_common_support(const Site_2& p, const Site_2& q) const { CGAL_precondition( !p.is_input() && !q.is_input() ); return same_segments(p.supporting_site(0), q.supporting_site(0)) || same_segments(p.supporting_site(0), q.supporting_site(1)) || same_segments(p.supporting_site(1), q.supporting_site(1)) || same_segments(p.supporting_site(1), q.supporting_site(0)); } bool have_common_support(const Site_2& s, const Point_2& p1, const Point_2& p2) const { CGAL_precondition( !s.is_input() ); Site_2 t = Site_2::construct_site_2(p1, p2); return ( same_segments(s.supporting_site(0), t) || same_segments(s.supporting_site(1), t) ); } private: Sign incircle_ppp(const Site_2& p, const Site_2& q, const Site_2& t, const Tag_false&) const { Point_2 pp = p.point(), qp = q.point(), tp = t.point(); // MK::ERROR: here I should call a kernel object, not a // function...; actually here (and everywhere in this class) // use the orientation predicate for sites; it does some // geometric filtering... Orientation o = orientation(pp, qp, tp); if ( o != COLLINEAR ) { return (o == LEFT_TURN) ? POSITIVE : NEGATIVE; } // MK::ERROR: change the following code to use the compare_x_2 // and compare_y_2 stuff... RT dtpx = pp.x() - tp.x(); RT dtpy = pp.y() - tp.y(); RT dtqx = qp.x() - tp.x(); RT minus_dtqy = -qp.y() + tp.y(); Sign s = sign_of_determinant2x2(dtpx, dtpy, minus_dtqy, dtqx); CGAL_assertion( s != ZERO ); return s; } Sign incircle_ppp(const Site_2& p, const Site_2& q, const Site_2& t, const Tag_true&) const { Orientation o = COLLINEAR; // the initialization was done in // order a compiler warning // do some geometric filtering... bool p_exact = p.is_input(); bool q_exact = q.is_input(); bool t_exact = t.is_input(); bool filtered = false; // the following if-statement does the gometric filtering... // maybe it is not so important since this will only be // activated if a lot of intersection points appear on the // convex hull if ( !p_exact || !q_exact || !t_exact ) { if ( !p_exact && !q_exact && !t_exact ) { if ( have_common_support(p, q) && have_common_support(q, t) ) { o = COLLINEAR; filtered = true; } } else if ( !p_exact && !q_exact && t_exact ) { if ( is_on_common_support(p, q, t.point()) ) { o = COLLINEAR; filtered = true; } } else if ( !p_exact && q_exact && !t_exact ) { if ( is_on_common_support(p, t, q.point()) ) { o = COLLINEAR; filtered = true; } } else if ( p_exact && !q_exact && !t_exact ) { if ( is_on_common_support(t, q, p.point()) ) { o = COLLINEAR; filtered = true; } } else if ( !p_exact && q_exact && t_exact ) { if ( have_common_support(p, q.point(), t.point()) ) { o = COLLINEAR; filtered = true; } } else if ( p_exact && !q_exact && t_exact ) { if ( have_common_support(q, p.point(), t.point()) ) { o = COLLINEAR; filtered = true; } } else if ( p_exact && q_exact && !t_exact ) { if ( have_common_support(t, p.point(), q.point()) ) { o = COLLINEAR; filtered = true; } } } Point_2 pp = p.point(), qp = q.point(), tp = t.point(); if ( !filtered ) { // MK::ERROR: here I should call a kernel object, not a // function...; actually here (and everywhere in this class) // use the orientation predicate for sites; it does some // geometric filtering... o = orientation(pp, qp, tp); } if ( o != COLLINEAR ) { return (o == LEFT_TURN) ? POSITIVE : NEGATIVE; } // MK::ERROR: change the following code to use the compare_x_2 // and compare_y_2 stuff... RT dtpx = pp.x() - tp.x(); RT dtpy = pp.y() - tp.y(); RT dtqx = qp.x() - tp.x(); RT minus_dtqy = -qp.y() + tp.y(); Sign s = sign_of_determinant2x2(dtpx, dtpy, minus_dtqy, dtqx); CGAL_assertion( s != ZERO ); return s; } Sign incircle_p(const Site_2& p, const Site_2& q, const Site_2& t) const { CGAL_precondition( t.is_point() ); if ( p.is_point() && q.is_point() ) { #if 1 return incircle_ppp(p, q, t, ITag()); #else Orientation o = COLLINEAR; // the initialization was done in // order a compiler warning // do some geometric filtering... bool p_exact = p.is_input(); bool q_exact = q.is_input(); bool t_exact = t.is_input(); bool filtered = false; // the following if-statement does the gometric filtering... // maybe it is not so important since this will only be // activated if a lot of intersection points appear on the // convex hull if ( !p_exact || !q_exact || !t_exact ) { if ( !p_exact && !q_exact && !t_exact ) { if ( have_common_support(p, q) && have_common_support(q, t) ) { o = COLLINEAR; filtered = true; } } else if ( !p_exact && !q_exact && t_exact ) { if ( is_on_common_support(p, q, t.point()) ) { o = COLLINEAR; filtered = true; } } else if ( !p_exact && q_exact && !t_exact ) { if ( is_on_common_support(p, t, q.point()) ) { o = COLLINEAR; filtered = true; } } else if ( p_exact && !q_exact && !t_exact ) { if ( is_on_common_support(t, q, p.point()) ) { o = COLLINEAR; filtered = true; } } else if ( !p_exact && q_exact && t_exact ) { if ( have_common_support(p, q.point(), t.point()) ) { o = COLLINEAR; filtered = true; } } else if ( p_exact && !q_exact && t_exact ) { if ( have_common_support(q, p.point(), t.point()) ) { o = COLLINEAR; filtered = true; } } else if ( p_exact && q_exact && !t_exact ) { if ( have_common_support(t, p.point(), q.point()) ) { o = COLLINEAR; filtered = true; } } } Point_2 pp = p.point(), qp = q.point(), tp = t.point(); if ( !filtered ) { // MK::ERROR: here I should call a kernel object, not a // function...; actually here (and everywhere in this class) // use the orientation predicate for sites; it does some // geometric filtering... o = orientation(pp, qp, tp); } if ( o != COLLINEAR ) { return (o == LEFT_TURN) ? POSITIVE : NEGATIVE; } // MK::ERROR: change the following code to use the compare_x_2 // and compare_y_2 stuff... RT dtpx = pp.x() - tp.x(); RT dtpy = pp.y() - tp.y(); RT dtqx = qp.x() - tp.x(); RT minus_dtqy = -qp.y() + tp.y(); Sign s = sign_of_determinant2x2(dtpx, dtpy, minus_dtqy, dtqx); CGAL_assertion( s != ZERO ); return s; #endif } CGAL_assertion( p.is_point() || q.is_point() ); Orientation o; if ( p.is_point() && q.is_segment() ) { Point_2 pq = same_points(p, q.source_site()) ? q.target() : q.source(); o = orientation(p.point(), pq, t.point()); } else { // p is a segment and q is a point Point_2 pp = same_points(q, p.source_site()) ? p.target() : p.source(); o = orientation(pp, q.point(), t.point()); } return ( o == RIGHT_TURN ) ? NEGATIVE : POSITIVE; } //----------------------------------------------------------------------- Sign incircle_pps(const Site_2& p, const Site_2& q, const Site_2& t) const { CGAL_precondition( p.is_point() && q.is_point() ); bool is_p_tsrc = same_points(p, t.source_site()); bool is_p_ttrg = same_points(p, t.target_site()); bool is_q_tsrc = same_points(q, t.source_site()); bool is_q_ttrg = same_points(q, t.target_site()); bool is_p_on_t = is_p_tsrc || is_p_ttrg; bool is_q_on_t = is_q_tsrc || is_q_ttrg; if ( is_p_on_t && is_q_on_t ) { // if t is the segment joining p and q then t must be a vertex // on the convex hull return NEGATIVE; } else if ( is_p_on_t ) { // p is an endpoint of t // in this case the p,q,oo vertex is destroyed only if the // other endpoint of t is beyond Point_2 pt = is_p_tsrc ? t.target() : t.source(); Orientation o = orientation(p.point(), q.point(), pt); return (o == RIGHT_TURN) ? NEGATIVE : POSITIVE; } else if ( is_q_on_t ) { Point_2 pt = is_q_tsrc ? t.target() : t.source(); Orientation o = orientation(p.point(), q.point(), pt); return (o == RIGHT_TURN) ? NEGATIVE : POSITIVE; } else { // maybe here I should immediately return POSITIVE; // since we insert endpoints of segments first, p and q cannot // be consecutive points on the convex hull if one of the // endpoints of t is to the right of the line pq. Point_2 pp = p.point(), qq = q.point(); Orientation o1 = orientation(pp, qq, t.source()); Orientation o2 = orientation(pp, qq, t.target()); if ( o1 == RIGHT_TURN || o2 == RIGHT_TURN ) { return NEGATIVE; } return POSITIVE; } } Sign incircle_sps(const Site_2& p, const Site_2& q, const Site_2& t) const { CGAL_precondition( p.is_segment() && q.is_point() ); bool is_q_tsrc = same_points(q, t.source_site()); bool is_q_ttrg = same_points(q, t.target_site()); bool is_q_on_t = is_q_tsrc || is_q_ttrg; if ( is_q_on_t ) { Point_2 pp = same_points(q, p.source_site()) ? p.target() : p.source(); Point_2 pt = is_q_tsrc ? t.target() : t.source(); Orientation o = orientation(pp, q.point(), pt); return (o == RIGHT_TURN) ? NEGATIVE : POSITIVE; } else { return POSITIVE; } } Sign incircle_pss(const Site_2& p, const Site_2& q, const Site_2& t) const { CGAL_precondition( p.is_point() && q.is_segment() ); bool is_p_tsrc = same_points(p, t.source_site()); bool is_p_ttrg = same_points(p, t.target_site()); bool is_p_on_t = is_p_tsrc || is_p_ttrg; if ( is_p_on_t ) { Point_2 pq = same_points(p, q.source_site()) ? q.target() : q.source(); Point_2 pt = is_p_tsrc ? t.target() : t.source(); Orientation o = orientation(p.point(), pq, pt); return (o == RIGHT_TURN) ? NEGATIVE : POSITIVE; } else { // if p is not an endpoint of t, then either p and q should // not be on the convex hull or t does not affect the vertex // of p and q. return POSITIVE; } } Sign incircle_s(const Site_2& p, const Site_2& q, const Site_2& t) const { CGAL_precondition( t.is_segment() ); if ( p.is_point() && q.is_point() ) { return incircle_pps(p, q, t); } else if ( p.is_point() && q.is_segment() ) { return incircle_pss(p, q, t); } else { // p is a segment and q is a point return incircle_sps(p, q, t); } } public: typedef Site_2 argument_type; typedef Sign result_type; struct Arity {}; Sign operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& t) const { Voronoi_vertex_2 v(p, q, r); return v.incircle(t); } Sign operator()(const Site_2& p, const Site_2& q, const Site_2& t) const { CGAL_assertion( !(p.is_segment() && q.is_segment()) ); if ( p.is_point() && q.is_segment() ) { // p must be an endpoint of q CGAL_assertion( same_points(p, q.source_site()) || same_points(p, q.target_site()) ); } else if ( p.is_segment() && q.is_point() ) { // q must be an endpoint of p CGAL_assertion( same_points(p.source_site(), q) || same_points(p.target_site(), q) ); } if ( t.is_point() ) { // return incircle_p(p, q, t); return incircle_p(q, p, t); } // MK::ERROR: do geometric filtering when orientation is called. // return incircle_s(p, q, t); return incircle_s(q, p, t); } }; //--------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_INCIRCLE_2_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_rtH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_tri0000644000175000017500000000627111344301501031354 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_rtH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_REGULAR_TRIANGULATION_RTH3_H #define CGAL_REGULAR_TRIANGULATION_RTH3_H // This file contains the low level homogeneous predicates // used by the 3D regular triangulation. #include CGAL_BEGIN_NAMESPACE template Oriented_side power_testH3( const RT &phx, const RT &phy, const RT &phz, const RT &phw, const RT &pwt, const RT &qhx, const RT &qhy, const RT &qhz, const RT &qhw, const RT &qwt, const RT &rhx, const RT &rhy, const RT &rhz, const RT &rhw, const RT &rwt, const RT &shx, const RT ­, const RT &shz, const RT &shw, const RT &swt, const RT &thx, const RT &thy, const RT &thz, const RT &thw, const RT &twt) { RT dphx = phx*phw; RT dphy = phy*phw; RT dphz = phz*phw; RT dphw = CGAL_NTS square(phw); RT dpz = CGAL_NTS square(phx) + CGAL_NTS square(phy) + CGAL_NTS square(phz) - pwt*dphw; RT dqhx = qhx*qhw; RT dqhy = qhy*qhw; RT dqhz = qhz*qhw; RT dqhw = CGAL_NTS square(qhw); RT dqz = CGAL_NTS square(qhx) + CGAL_NTS square(qhy) + CGAL_NTS square(qhz) - qwt*dqhw; RT drhx = rhx*rhw; RT drhy = rhy*rhw; RT drhz = rhz*rhw; RT drhw = CGAL_NTS square(rhw); RT drz = CGAL_NTS square(rhx) + CGAL_NTS square(rhy) + CGAL_NTS square(rhz) - rwt*drhw; RT dshx = shx*shw; RT dshy = shy*shw; RT dshz = shz*shw; RT dshw = CGAL_NTS square(shw); RT dsz = CGAL_NTS square(shx) + CGAL_NTS square(shy) + CGAL_NTS square(shz) - swt*dshw; RT dthx = thx*thw; RT dthy = thy*thw; RT dthz = thz*thw; RT dthw = CGAL_NTS square(thw); RT dtz = CGAL_NTS square(thx) + CGAL_NTS square(thy) + CGAL_NTS square(thz) - twt*dthw; return Oriented_side(- sign_of_determinant5x5(dphx, dphy, dphz, dpz, dphw, dqhx, dqhy, dqhz, dqz, dqhw, drhx, drhy, drhz, drz, drhw, dshx, dshy, dshz, dsz, dshw, dthx, dthy, dthz, dtz, dthw)); } // The 2 degenerate are not speed critical, and they are quite boring and error // prone to write, so we use the Cartesian version, using FT. CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #include #endif #endif // CGAL_REGULAR_TRIANGULATION_RTH3_H ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_vertex_H2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Vor0000644000175000017500000000416311344301501031323 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_vertex_H2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_H2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_H2_H #include //#include #include CGAL_BEGIN_NAMESPACE template struct Svd_which_base_H2 { template struct Which_base { // this should change once I have written the code for the ring // operations for a homogeneous kernel // typedef Svd_voronoi_vertex_ring_H2 Base; typedef Svd_voronoi_vertex_sqrt_field_H2 Base; }; }; template <> struct Svd_which_base_H2 { template struct Which_base { typedef Svd_voronoi_vertex_sqrt_field_H2 Base; }; }; //---------------------------------------------------------------------- template class Svd_voronoi_vertex_H2 : public Svd_which_base_H2::template Which_base::Base { private: typedef typename Svd_which_base_H2::template Which_base::Base Base; protected: typedef typename Base::Site_2 Site_2; public: Svd_voronoi_vertex_H2(const Site_2& p, const Site_2& q, const Site_2& r) : Base(p, q, r) {} }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_H2_H ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_infinite_edge_test_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_infinit0000644000175000017500000002321211344301501031220 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_infinite_edge_test_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_INFINITE_EDGE_TEST_C2_H #define CGAL_AG2_INFINITE_EDGE_TEST_C2_H #include #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template< class K > class Bounded_side_of_CCW_circular_arc { public: typedef CGAL::Weighted_point_inverter Weighted_point_inverter; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Voronoi_radius Voronoi_radius; typedef CGAL::Voronoi_circle Voronoi_circle; typedef CGAL::Bitangent_line Bitangent_line; typedef typename K::FT FT; public: template< class Method_tag > Bounded_side operator()(const Bitangent_line& l1, const Bitangent_line& l2, const Bitangent_line& l3, Method_tag tag) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::inside_circular_arc_counter++; #endif // This function checks whether the direction (a3, b3) (defined in // the unit circle) is inside the CCW circular arc defined on the // unit circle by the directions (a1, b1) and (a2, b2). By CCW arc // we mean that we walk on the unit circle in the CCW order from // (a1,b1) to (a2, b2) to define the arc. Orientation o = chi2(l1, l2, tag); //sign_of_determinant2x2(a1, b1, a2, b2); if ( o == COLLINEAR ) { Bitangent_line l2_rot = l2.get_rot90(); Sign dot = chi2(l1, l2_rot, tag); //sign_of_determinant2x2(a1, b1, -b2, a2); CGAL_assertion( dot != ZERO ); Orientation o1 = chi2(l1, l3, tag); //sign_of_determinant2x2(a1, b1, a3, b3); if ( dot == POSITIVE ) { if ( o1 != COLLINEAR ) { return ON_UNBOUNDED_SIDE; } Bitangent_line l3_rot = l3.get_rot90(); Sign dot1 = chi2(l1, l3_rot, tag); //sign_of_determinant2x2(a1, b1, -b3, a3); CGAL_assertion( dot1 != ZERO ); return ( dot1 == POSITIVE ) ? ON_BOUNDARY : ON_UNBOUNDED_SIDE; } if ( o1 == LEFT_TURN ) { return ON_BOUNDED_SIDE; } return ( o1 == COLLINEAR ) ? ON_BOUNDARY : ON_UNBOUNDED_SIDE; } else if ( o == LEFT_TURN ) { Orientation o1 = chi2(l1, l3, tag); //sign_of_determinant2x2(a1, b1, a3, b3); Orientation o2 = chi2(l2, l3, tag); //sign_of_determinant2x2(a2, b2, a3, b3); // std::cout << "orientation(l1, l3): " << int(o1) << std::endl; // std::cout << "orientation(l2, l3): " << int(o2) << std::endl; if ( o1 == LEFT_TURN ) { if ( o2 == COLLINEAR ) { return ON_BOUNDARY; } return ( o2 == RIGHT_TURN ) ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } else if ( o1 == COLLINEAR ) { CGAL_assertion( o2 != COLLINEAR ); return ( o2 == RIGHT_TURN ) ? ON_BOUNDARY : ON_UNBOUNDED_SIDE; } return ON_UNBOUNDED_SIDE; } Orientation o1 = chi2(l1, l3, tag); //sign_of_determinant2x2(a1, b1, a3, b3); Orientation o2 = chi2(l2, l3, tag); //sign_of_determinant2x2(a2, b2, a3, b3); // std::cout << "orientation(l1, l3): " << int(o1) << std::endl; // std::cout << "orientation(l2, l3): " << int(o2) << std::endl; if ( o1 == LEFT_TURN || o2 == RIGHT_TURN ) { return ON_BOUNDED_SIDE; } if ( o1 == COLLINEAR || o2 == COLLINEAR ) { return ON_BOUNDARY; } return ON_UNBOUNDED_SIDE; } Sign chi2(const Bitangent_line& bl1, const Bitangent_line& bl2, Sqrt_field_tag) const { FT sigma = bl1.dx() * bl2.dx() + bl1.dy() * bl2.dy(); FT delta = bl1.dx() * bl2.dy() - bl1.dy() * bl2.dx(); // FT E1 = -bl2.dw() * sigma; // FT E2 = bl1.dw() * sigma; FT E1 = bl2.dw() * sigma; FT E2 = -bl1.dw() * sigma; FT E3 = delta; FT E4 = bl1.dw() * bl2.dw() * delta; FT p = bl1.delta(); FT P = bl2.delta(); FT E = E1 * CGAL::sqrt(p) + E2 * CGAL::sqrt(P) + E3 * CGAL::sqrt(p * P) + E4; return CGAL::sign(E); } inline Sign chi2(const Bitangent_line& bl1, const Bitangent_line& bl2, Ring_tag) const { return chi2(bl1.dx(), bl1.dy(), -bl1.dw(), bl1.d(), bl1.delta(), bl2.dx(), bl2.dy(), -bl2.dw(), bl2.d(), bl2.delta()); } Sign chi2(const FT& a, const FT& b, const FT& r, const FT& d, const FT& p, const FT& A, const FT& B, const FT& R, const FT& D, const FT& P) const { FT sigma = a * A + b * B; FT delta = det2x2_by_formula(a, b, A, B); Sign sign_sigma = CGAL::sign(sigma); Sign sign_delta = CGAL::sign(delta); Sign sign_r = CGAL::sign(r); Sign sign_R = CGAL::sign(R); Sign sign_E1 = opposite(Sign(sign_R * sign_sigma)); Sign sign_E2 = Sign(sign_r * sign_sigma); Sign sign_E3 = sign_delta; Sign sign_E4 = Sign(sign_r * sign_R * sign_delta); Sign sign_E1_plus_E3_P, sign_E4_plus_E2_P; // FT d = CGAL::square(a) + CGAL::square(b); FT G = CGAL::square(R) * d; FT delta2 = CGAL::square(delta); if ( sign_E3 == ZERO ) { sign_E1_plus_E3_P = sign_E1; } else { if ( sign_E3 == sign_E1 ) { sign_E1_plus_E3_P = sign_E3; } else { FT F1 = delta2 - G; sign_E1_plus_E3_P = Sign(sign_E3 * CGAL::sign(F1)); } } if ( sign_E2 == ZERO ) { sign_E4_plus_E2_P = sign_E4; } else { if ( sign_E2 == sign_E4 ) { sign_E4_plus_E2_P = sign_E2; } else { FT F2 = CGAL::square(sigma) - G; if ( sign_r == ZERO ) { sign_E4_plus_E2_P = ZERO; } else { sign_E4_plus_E2_P = Sign(sign_E2 * CGAL::sign(F2)); } } } if ( sign_E1_plus_E3_P == ZERO ) { return sign_E4_plus_E2_P; } if ( sign_E1_plus_E3_P == sign_E4_plus_E2_P ) { return sign_E1_plus_E3_P; } Sign sign_E5 = opposite(Sign(sign_R * sign_sigma * sign_delta)); // FT D = CGAL::square(A) + CGAL::square(B); // FT P = D - CGAL::square(R); FT F3 = P * delta2 + CGAL::square(R * sigma) - CGAL::square(r * D); Sign sign_E6 = CGAL::sign(F3); if ( sign_E5 == ZERO ) { return Sign(sign_E1_plus_E3_P * sign_E6); } if ( sign_E5 == sign_E6 ) { return Sign(sign_E1_plus_E3_P * sign_E5); } // FT p = d - CGAL::square(r); FT rR = r * R; FT pP = p * P; //error(); FT F4 = CGAL::square(sigma - rR) - pP; FT F5 = CGAL::square(sigma + rR) - pP; Sign sign_E7 = opposite(Sign(CGAL::sign(F4) * CGAL::sign(F5))); return Sign(sign_E1_plus_E3_P * sign_E5 * sign_E7); } }; //-------------------------------------------------------------------- template < class K, class MTag > class Infinite_edge_test { public: typedef K Kernel; typedef MTag Method_tag; typedef typename K::Site_2 Site_2; typedef CGAL::Weighted_point_inverter Weighted_point_inverter; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Voronoi_radius Voronoi_radius; typedef CGAL::Voronoi_circle Voronoi_circle; typedef CGAL::Bitangent_line Bitangent_line; typedef typename K::FT FT; typedef CGAL::Bounded_side_of_CCW_circle Bounded_side_of_CCW_circle; typedef CGAL::Sign_of_distance_from_bitangent_line Sign_of_distance_from_bitangent_line; typedef CGAL::Sign_of_distance_from_CCW_circle Sign_of_distance_from_CCW_circle; typedef CGAL::Order_on_finite_bisector Order_on_finite_bisector; typedef CGAL::Bounded_side_of_CCW_circular_arc Bounded_side_of_CCW_circular_arc; public: typedef bool result_type; typedef Arity_tag<5> Arity; struct argument_type {}; bool operator()(const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b) const { Method_tag tag = Method_tag(); Bitangent_line bl_32(p3, p2); Bitangent_line bl_24(p2, p4); Bitangent_line bl_2q(p2, q); Bounded_side bs1 = Bounded_side_of_CCW_circular_arc()(bl_32, bl_24, bl_2q, tag); if ( b ) { if ( bs1 == ON_BOUNDARY ) { Bitangent_line bl_q2(q, p2); Bounded_side bs2 = Bounded_side_of_CCW_circular_arc()(bl_32, bl_24, bl_q2, tag); if ( bs2 != ON_BOUNDARY ) { return ( bs2 != ON_BOUNDED_SIDE ); } return !b; } return ( bs1 != ON_BOUNDED_SIDE ); } if ( bs1 == ON_BOUNDARY ) { Bitangent_line bl_q2(q, p2); Bounded_side bs2 = Bounded_side_of_CCW_circular_arc()(bl_32, bl_24, bl_q2, tag); if ( bs2 != ON_BOUNDARY ) { return ( bs2 == ON_BOUNDED_SIDE ); } return !b; } return ( bs1 == ON_BOUNDED_SIDE ); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_INFINITE_EDGE_TEST_C2_H ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_predicates_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Vor0000644000175000017500000010127111344301501031321 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_predicates_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_FTC2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_FTC2_H #include #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template void svd_predicate_push_back_C2(const typename K::Site_2& t, typename K::FT v[], unsigned int& k, char site_types[], unsigned int& j, const Tag_true&) { unsigned int step(0); if ( t.is_point() ) { site_types[j] = 'p'; if ( t.is_input() ) { site_types[j+1] = 'e'; v[k] = t.point().x(); v[k+1] = t.point().y(); step = 2; } else { site_types[j+1] = 'i'; v[k] = t.source_of_supporting_site(0).x(); v[k+1] = t.source_of_supporting_site(0).y(); v[k+2] = t.target_of_supporting_site(0).x(); v[k+3] = t.target_of_supporting_site(0).y(); v[k+4] = t.source_of_supporting_site(1).x(); v[k+5] = t.source_of_supporting_site(1).y(); v[k+6] = t.target_of_supporting_site(1).x(); v[k+7] = t.target_of_supporting_site(1).y(); step = 8; } } else { site_types[j] = 's'; if ( t.is_input() ) { site_types[j+1] = 'e'; v[k] = t.source_of_supporting_site().x(); v[k+1] = t.source_of_supporting_site().y(); v[k+2] = t.target_of_supporting_site().x(); v[k+3] = t.target_of_supporting_site().y(); step = 4; } else { v[k] = t.source_of_supporting_site().x(); v[k+1] = t.source_of_supporting_site().y(); v[k+2] = t.target_of_supporting_site().x(); v[k+3] = t.target_of_supporting_site().y(); typedef typename K::Point_2 Point_2; if ( t.is_input(0) ) { const Point_2& cs_p1 = t.source_of_crossing_site(1); const Point_2& cs_p2 = t.target_of_crossing_site(1); site_types[j+1] = '0'; v[k+4] = cs_p1.x(); v[k+5] = cs_p1.y(); v[k+6] = cs_p2.x(); v[k+7] = cs_p2.y(); step = 8; } else if ( t.is_input(1) ) { const Point_2& cs_p1 = t.source_of_crossing_site(0); const Point_2& cs_p2 = t.target_of_crossing_site(0); site_types[j+1] = '1'; v[k+4] = cs_p1.x(); v[k+5] = cs_p1.y(); v[k+6] = cs_p2.x(); v[k+7] = cs_p2.y(); step = 8; } else { const Point_2& cs_p1 = t.source_of_crossing_site(0); const Point_2& cs_p2 = t.target_of_crossing_site(0); const Point_2& cs2_p1 = t.source_of_crossing_site(1); const Point_2& cs2_p2 = t.target_of_crossing_site(1); site_types[j+1] = 'i'; v[k+4] = cs_p1.x(); v[k+5] = cs_p1.y(); v[k+6] = cs_p2.x(); v[k+7] = cs_p2.y(); v[k+8] = cs2_p1.x(); v[k+9] = cs2_p1.y(); v[k+10] = cs2_p2.x(); v[k+11] = cs2_p2.y(); step = 12; } } } j += 2; k += step; } template void svd_predicate_push_back_C2(const typename K::Site_2& t, typename K::FT v[], unsigned int& k, char site_types[], unsigned int& j, const Tag_false&) { unsigned int step(0); if ( t.is_point() ) { site_types[j] = 'p'; site_types[j+1] = 'e'; v[k] = t.point().x(); v[k+1] = t.point().y(); step = 2; } else { site_types[j] = 's'; site_types[j+1] = 'e'; v[k] = t.source().x(); v[k+1] = t.source().y(); v[k+2] = t.target().x(); v[k+3] = t.target().y(); step = 4; } j += 2; k += step; } //-------------------------------------------------------------------------- template class Svd_get_site_C2; template class Svd_get_site_C2 { private: typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; typedef typename K::FT FT; public: Site_2 operator()(const FT v[], unsigned int& k, const char site_types[], unsigned int& j) { Site_2 t; unsigned int step(0); if ( site_types[j] == 'p' ) { if ( site_types[j+1] == 'e' ) { Point_2 p(v[k], v[k+1]); t = Site_2::construct_site_2(p); step = 2; } else { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Point_2 p3(v[k+4], v[k+5]), p4(v[k+6], v[k+7]); t = Site_2::construct_site_2(p1, p2, p3, p4); step = 8; } } else { if ( site_types[j+1] == 'e' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); t = Site_2::construct_site_2(p1, p2); step = 4; } else { if ( site_types[j+1] != 'i' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Point_2 p3(v[k+4], v[k+5]), p4(v[k+6], v[k+7]); t = Site_2::construct_site_2(p1, p2, p3, p4, (site_types[j+1] == '0')); step = 8; } else { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Point_2 p3(v[k+4], v[k+5]), p4(v[k+6], v[k+7]); Point_2 p5(v[k+8], v[k+9]), p6(v[k+10], v[k+11]); t = Site_2::construct_site_2(p1, p2, p3, p4, p5, p6); step = 12; } } } j += 2; k += step; return t; } }; template class Svd_get_site_C2 { private: typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; typedef typename K::FT FT; public: Site_2 operator()(const FT v[], unsigned int& k, const char site_types[], unsigned int& j) { Site_2 t; unsigned int step(0); if ( site_types[j] == 'p' ) { Point_2 p(v[k], v[k+1]); t = Site_2::construct_site_2(p); step = 2; } else { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); t = Site_2::construct_site_2(p1, p2); step = 4; } j += 2; k += step; return t; } }; template typename K::Site_2 svd_get_site_C2(const typename K::FT v[], unsigned int& k, const char site_types[], unsigned int& j, const Tag_true&) { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; Site_2 t; unsigned int step(0); if ( site_types[j] == 'p' ) { if ( site_types[j+1] == 'e' ) { Point_2 p(v[k], v[k+1]); t = Site_2::construct_site_2(p); step = 2; } else { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Point_2 p3(v[k+4], v[k+5]), p4(v[k+6], v[k+7]); t = Site_2::construct_site_2(p1, p2, p3, p4); step = 8; } } else { if ( site_types[j+1] == 'e' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); t = Site_2::construct_site_2(p1, p2); step = 4; } else { if ( site_types[j+1] != 'i' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Point_2 p3(v[k+4], v[k+5]), p4(v[k+6], v[k+7]); t = Site_2::construct_site_2(p1, p2, p3, p4, (site_types[j+1] == '0')); step = 8; } else { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Point_2 p3(v[k+4], v[k+5]), p4(v[k+6], v[k+7]); Point_2 p5(v[k+8], v[k+9]), p6(v[k+10], v[k+11]); t = Site_2::construct_site_2(p1, p2, p3, p4, p5, p6); step = 12; } } } j += 2; k += step; return t; } template typename K::Site_2 svd_get_site_C2(const typename K::FT v[], unsigned int& k, const char site_types[], unsigned int& j, const Tag_false&) { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Site_2 Site_2; Site_2 t; unsigned int step(0); if ( site_types[j] == 'p' ) { Point_2 p(v[k], v[k+1]); t = Site_2::construct_site_2(p); step = 2; } else { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); t = Site_2::construct_site_2(p1, p2); step = 4; } j += 2; k += step; return t; } //-------------------------------------------------------------------------- template struct Svd_predicate_caller; template struct Svd_predicate_caller { template Result_t operator()(const S t[]) const { return Predicate()(t[0], t[1]); } }; template struct Svd_predicate_caller { template Result_t operator()(const S t[]) const { return Predicate()(t[0], t[1], t[2]); } template Result_t operator()(const S t[], Data data) const { return Predicate()(t[0], t[1], t[2], data); } }; template struct Svd_predicate_caller { template Result_t operator()(const S t[]) const { return Predicate()(t[0], t[1], t[2], t[3]); } template Result_t operator()(const S t[], Data data) const { return Predicate()(t[0], t[1], t[2], t[3], data); } }; template struct Svd_predicate_caller { template Result_t operator()(const S t[]) const { return Predicate()(t[0], t[1], t[2], t[3], t[4]); } template Result_t operator()(const S t[], Data data) const { return Predicate()(t[0], t[1], t[2], t[3], t[4], data); } }; //-------------------------------------------------------------------------- #if 0 template class Predicate_t, typename Return_t, class FT, class ITag, unsigned int Num_sites> Return_t svd_predicate_ftC2(const FT v[], const char site_types[]) { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Predicate_t Predicate; typedef Svd_predicate_caller Caller; must_be_filtered(FT()); Site_2 t[Num_sites]; for (unsigned int i = 0, k = 0, j = 0; i < Num_sites; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } Return_t result = Caller()(t); return result; } template class Predicate_t, typename Return_t, class FT, class Method_tag, class ITag, unsigned int Num_sites> Return_t svd_predicate_ftC2(const FT v[], const char site_types[]) { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Predicate_t Predicate; typedef Svd_predicate_caller Caller; must_be_filtered(FT()); Site_2 t[Num_sites]; for (unsigned int i = 0, k = 0, j = 0; i < Num_sites; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } Return_t result = Caller()(t); return result; } template class Predicate_t, typename Return_t, class FT, class Method_tag, class ITag, typename Data, unsigned int Num_sites> Return_t svd_predicate_ftC2(const FT v[], const char site_types[], Data data) { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Predicate_t Predicate; typedef Svd_predicate_caller Caller; must_be_filtered(FT()); Site_2 t[Num_sites]; for (unsigned int i = 0, k = 0, j = 0; i < Num_sites; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } Return_t result = Caller()(t, data); return result; } #endif //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_are_same_points_ftC2 { public: inline bool operator()(const FT v[], const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_are_same_points_C2 Predicate; must_be_filtered(FT()); Site_2 t[2]; for (unsigned int i = 0, k = 0, j = 0; i < 2; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1]); } }; template inline bool svd_are_same_points_C2(const typename K::Site_2& p, const typename K::Site_2& q) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Svd_are_same_points_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q}; ITag itag; FT v[24]; char site_types[4]; for (unsigned int i = 0, k = 0, j = 0; i < 2; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_orientation_ftC2 { public: inline Orientation operator()(const FT v[], const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_orientation_C2 Predicate; must_be_filtered(FT()); Site_2 t[3]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1], t[2]); } }; template inline Orientation svd_orientation_C2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Svd_orientation_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, r}; ITag itag; FT v[36]; char site_types[6]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_oriented_side_of_bisector_ftC2 { public: inline Oriented_side operator()(const FT v[], const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_oriented_side_of_bisector_C2 Predicate; must_be_filtered(FT()); Site_2 t[3]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1], t[2]); } }; template inline Oriented_side svd_oriented_side_of_bisector_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& t, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_oriented_side_of_bisector_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, t}; ITag itag; FT v[36]; char site_types[6]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_vertex_conflict_ftC2 { public: inline Sign operator()(const FT v[], const char site_types[]) const // const MTag& mtag, const ITag& itag) { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_incircle_2 Predicate; typedef Svd_predicate_caller Caller; must_be_filtered(FT()); Site_2 t[Num_sites]; for (unsigned int i = 0, k = 0, j = 0; i < Num_sites; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Caller()(t); } }; //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template inline Sign svd_vertex_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& t, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_vertex_conflict_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, t}; ITag itag; FT v[36]; char site_types[6]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- template inline Sign svd_vertex_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& t, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typename K::Site_2 tt[] = {p, q, r, t}; ITag itag; FT v[48]; char site_types[8]; for (unsigned int i = 0, k = 0, j = 0; i < 4; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } typedef Svd_vertex_conflict_ftC2 VC; return VC()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_finite_edge_conflict_ftC2 { public: inline bool operator()(const FT v[], Sign sgn, const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_finite_edge_interior_2 Predicate; typedef Svd_predicate_caller Caller; must_be_filtered(FT()); Site_2 t[Num_sites]; for (unsigned int i = 0, k = 0, j = 0; i < Num_sites; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Caller()(t, sgn); } }; //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_finite_edge_conflict_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, t}; ITag itag; FT v[36]; char site_types[6]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, sgn, site_types); } //-------------------------------------------------------------------------- template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_finite_edge_conflict_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, r, t}; ITag itag; FT v[48]; char site_types[8]; for (unsigned int i = 0, k = 0, j = 0; i < 4; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, sgn, site_types); } //-------------------------------------------------------------------------- template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& s, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_finite_edge_conflict_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, r, s, t}; ITag itag; FT v[60]; char site_types[10]; for (unsigned int i = 0, k = 0, j = 0; i < 5; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, sgn, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_infinite_edge_conflict_ftC2 { public: inline bool operator()(const FT v[], Sign sgn, const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_infinite_edge_interior_2 Predicate; must_be_filtered(FT()); Site_2 t[4]; for (unsigned int i = 0, k = 0, j = 0; i < 4; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1], t[2], t[3], sgn); } }; template inline bool svd_infinite_edge_conflict_ftC2(const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& s, const typename K::Site_2& t, Sign sgn, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_infinite_edge_conflict_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {q, r, s, t}; ITag itag; FT v[48]; char site_types[8]; for (unsigned int i = 0, k = 0, j = 0; i < 4; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, sgn, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_is_degenerate_edge_ftC2 { public: inline bool operator()(const FT v[], const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_is_degenerate_edge_C2 Predicate; must_be_filtered(FT()); Site_2 t[4]; for (unsigned int i = 0, k = 0, j = 0; i < 4; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1], t[2], t[3]); } }; template inline bool svd_is_degenerate_edge_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& t, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_is_degenerate_edge_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q, r, t}; ITag itag; FT v[48]; char site_types[8]; for (unsigned int i = 0, k = 0, j = 0; i < 4; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_arrangement_type_ftC2 { public: typedef Simple_cartesian Rep; typedef Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef Svd_arrangement_type_C2 Predicate; typedef typename Predicate::result_type result_type; typedef typename Kernel::Site_2 Site_2; inline result_type operator()(const FT v[], const char site_types[]) const { must_be_filtered(FT()); Site_2 t[2]; for (unsigned int i = 0, k = 0, j = 0; i < 2; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1]); } }; template inline typename Svd_arrangement_type_ftC2::result_type svd_arrangement_type_C2(const typename K::Site_2& p, const typename K::Site_2& q, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_arrangement_type_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q}; ITag itag; FT v[24]; char site_types[4]; for (unsigned int i = 0, k = 0, j = 0; i < 2; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_are_parallel_ftC2 { public: inline bool operator()(const FT v[], const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_are_parallel_C2 Predicate; must_be_filtered(FT()); Site_2 t[2]; for (unsigned int i = 0, k = 0, j = 0; i < 2; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Predicate()(t[0], t[1]); } }; template inline bool svd_are_parallel_C2(const typename K::Site_2& p, const typename K::Site_2& q) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Svd_are_parallel_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {p, q}; ITag itag; FT v[24]; char site_types[4]; for (unsigned int i = 0, k = 0, j = 0; i < 2; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template class Svd_oriented_side_ftC2 { public: inline Oriented_side operator()(const FT v[], const char site_types[]) const { typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Site_2 Site_2; typedef Svd_oriented_side_C2 Predicate; typedef Svd_predicate_caller Caller; must_be_filtered(FT()); Site_2 t[Num_sites]; for (unsigned int i = 0, k = 0, j = 0; i < Num_sites; i++) { t[i] = svd_get_site_C2(v, k, site_types, j, ITag()); } return Caller()(t); } }; //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- template inline Oriented_side svd_oriented_side_ftC2(const typename K::Site_2& q, const typename K::Site_2& s, const typename K::Site_2& p, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_oriented_side_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {q, s, p}; ITag itag; FT v[36]; char site_types[6]; for (unsigned int i = 0, k = 0, j = 0; i < 3; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- template inline Oriented_side svd_oriented_side_ftC2(const typename K::Site_2& s1, const typename K::Site_2& s2, const typename K::Site_2& s3, const typename K::Site_2& s, const typename K::Site_2& p, const Method_tag& mtag) { typedef typename K::FT FT; typedef typename K::Intersections_tag ITag; typedef Method_tag MTag; typedef Svd_oriented_side_ftC2 Predicate_ftC2; typename K::Site_2 tt[] = {s1, s2, s3, s, p}; ITag itag; FT v[60]; char site_types[10]; for (unsigned int i = 0, k = 0, j = 0; i < 5; i++) { svd_predicate_push_back_C2(tt[i], v, k, site_types, j, itag); } return Predicate_ftC2()(v, site_types); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #ifndef CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_FTC2_H #include #endif // CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_FTC2_H #endif #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_FTC2_H ././@LongLink0000000000000000000000000000020700000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_graph_predicate_constructions_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_0000644000175000017500000002470311344301501031361 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_graph_predicate_constructions_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_PREDICATE_CONSTRUCTIONS_C2_H #define CGAL_APOLLONIUS_GRAPH_PREDICATE_CONSTRUCTIONS_C2_H CGAL_BEGIN_NAMESPACE template< class K > class Inverted_weighted_point : public K::Site_2 { public: typedef typename K::Site_2 K_Site_2; typedef typename K::FT FT; private: FT _p; public: Inverted_weighted_point(const K_Site_2& wp, const FT& p) : K_Site_2(wp), _p(p) {} inline FT p() const { return _p; } }; template< class K > class Weighted_point_inverter { public: typedef typename K::Point_2 Point_2; typedef typename K::Site_2 Site_2; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef typename K::FT FT; private: Site_2 _pole; public: Weighted_point_inverter(const Site_2& pole) : _pole(pole) {} Inverted_weighted_point operator()(const Site_2& wp) { FT xs = wp.x() - _pole.x(); FT ys = wp.y() - _pole.y(); FT ws = wp.weight() - _pole.weight(); FT ps = CGAL::square(xs) + CGAL::square(ys) - CGAL::square(ws); return Inverted_weighted_point(Site_2(Point_2(xs, ys), ws), ps); } Site_2 pole() const { return _pole; } }; template< class K > class Voronoi_radius { // this class stores the coefficients for the tritangent circle // radius equation. In particular we have: // a x^2 - 2 b x + c = 0; // x here represents the inverse of the radius public: typedef typename K::FT FT; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; private: FT _a, _b, _c; FT _c2, _delta; FT _dxp, _dyp, _dwp; Voronoi_radius(FT a, FT b, FT c, FT c2, FT delta, FT dxp, FT dyp, FT dwp) : _a(a), _b(b), _c(c), _c2(c2), _delta(delta), _dxp(dxp), _dyp(dyp), _dwp(dwp) {} public: Voronoi_radius(const Inverted_weighted_point& u1, const Inverted_weighted_point& u2) { FT dxp = det2x2_by_formula(u1.x(), u1.p(), u2.x(), u2.p()); FT dyp = det2x2_by_formula(u1.y(), u1.p(), u2.y(), u2.p()); FT dwp = det2x2_by_formula(u1.weight(), u1.p(), u2.weight(), u2.p()); FT dxy = det2x2_by_formula(u1.x(), u1.y(), u2.x(), u2.y()); FT dxw = det2x2_by_formula(u1.x(), u1.weight(), u2.x(), u2.weight()); FT dyw = det2x2_by_formula(u1.y(), u1.weight(), u2.y(), u2.weight()); _a = CGAL::square(dxp) + CGAL::square(dyp); _b = dxp * dxw + dyp * dyw; _c = CGAL::square(dxw) + CGAL::square(dyw) - CGAL::square(dxy); _c2 = dxy; _delta = _a - CGAL::square(dwp); _dxp = dxp; _dyp = dyp; _dwp = dwp; } inline FT a() const { return _a; } inline FT b() const { return _b; } inline FT c() const { return _c; } inline FT c1() const { return _b; } inline FT c2() const { return _c2; } inline FT delta() const { return _delta; } inline FT d() const { return _a; } inline FT dxp() const { return _dxp; } inline FT dyp() const { return _dyp; } inline FT dwp() const { return _dwp; } inline bool is_first_root() const { return CGAL::is_negative(_c2); } Voronoi_radius get_symmetric() { return Voronoi_radius(_a, _b, _c, -_c2, _delta, -_dxp, -_dyp, -_dwp); } }; template< class K > class Bitangent_line { // this class computes and stores the data for the left bitangent // line of the weighted points p1, p2 oriented from p1 to p2 // or the left bitangent line of the inverted weighted point u1 and // u2, oriented from u1 to u2 public: typedef typename K::Point_2 Point_2; typedef typename K::Site_2 Site_2; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef typename K::FT FT; protected: FT _a1, _a2; FT _b1, _b2; FT _c1, _c2; FT _delta; FT _d; FT _dw; FT _dxw, _dyw; Bitangent_line(FT a1, FT a2, FT b1, FT b2, FT c1, FT c2, FT delta, FT d, FT dw, FT dxw, FT dyw) : _a1(a1), _a2(a2), _b1(b1), _b2(b2), _c1(c1), _c2(c2), _delta(delta), _d(d), _dw(dw),_dxw(dxw), _dyw(dyw) {} inline void store(FT dx, FT dy, FT dw) { _dw = dw; _a1 = dx * dw; _a2 = dy; _b1 = dy * dw; _b2 = -dx; } inline void store(FT dx, FT dy, FT dw, FT dxy, FT dxw, FT dyw) { store(dx, dy, dw); _c1 = dx * dxw + dy * dyw; _c2 = dxy; _d = CGAL::square(dx) + CGAL::square(dy); _delta = _d - CGAL::square(dw); _dxw = dxw; _dyw = dyw; } public: Bitangent_line(const Site_2& p1, const Site_2& p2) { FT dx = p1.x() - p2.x(); FT dy = p1.y() - p2.y(); FT dw = p1.weight() - p2.weight(); FT dxy = det2x2_by_formula(p1.x(), p1.y(), p2.x(), p2.y()); FT dxw = det2x2_by_formula(p1.x(), p1.weight(), p2.x(), p2.weight()); FT dyw = det2x2_by_formula(p1.y(), p1.weight(), p2.y(), p2.weight()); store(dx, dy, dw, dxy, dxw, dyw); } Bitangent_line(const Inverted_weighted_point& u1, const Inverted_weighted_point& u2) { FT dxp = det2x2_by_formula(u1.x(), u1.p(), u2.x(), u2.p()); FT dyp = det2x2_by_formula(u1.y(), u1.p(), u2.y(), u2.p()); FT dwp = det2x2_by_formula(u1.weight(), u1.p(), u2.weight(), u2.p()); FT dxy = det2x2_by_formula(u1.x(), u1.y(), u2.x(), u2.y()); FT dxw = det2x2_by_formula(u1.x(), u1.weight(), u2.x(), u2.weight()); FT dyw = det2x2_by_formula(u1.y(), u1.weight(), u2.y(), u2.weight()); store(dxp, dyp, dwp, dxy, dxw, dyw); } Bitangent_line get_symmetric() const { return Bitangent_line(_a1, -_a2, _b1, -_b2, _c1, -_c2, _delta, _d, -_dw, -_dxw, -_dyw); } Bitangent_line get_rot90() const { return Bitangent_line(-_b1, -_b2, _a1, _a2, _c1, _c2, _delta, _d, _dw, -_dyw, _dxw); } Bitangent_line perpendicular(const Point_2& p) const { // THIS DOES NOT KEEP TRACK OF THE ADDITIONALLY STORED // QUANTITIES; THIS IS INEVITABLE IN ANY CASE SINCE GIVEN p WE // CANNOT ANY LONGER HOPE TO KEEP TRACK OF THOSE Bitangent_line rotated = get_rot90(); rotated._c1 = _b1 * p.x() - _a1 * p.y(); rotated._c2 = _b2 * p.x() - _a2 * p.y(); return rotated; } Bitangent_line perpendicular(const Inverted_weighted_point& u) const { // THIS DOES NOT KEEP TRACK OF THE ADDITIONALLY STORED // QUANTITIES; THIS IS INEVITABLE IN ANY CASE SINCE GIVEN p WE // CANNOT ANY LONGER HOPE TO KEEP TRACK OF THOSE Bitangent_line rotated = get_rot90(); rotated._c1 = (_b1 * u.x() - _a1 * u.y()) * u.p(); rotated._c2 = (_b2 * u.x() - _a2 * u.y()) * u.p(); return rotated; } inline FT a1() const { return _a1; } inline FT a2() const { return _a2; } inline FT b1() const { return _b1; } inline FT b2() const { return _b2; } inline FT c1() const { return _c1; } inline FT c2() const { return _c2; } inline FT delta() const { return _delta; } inline FT d() const { return _d; } inline FT dx() const { return -_b2; } inline FT dy() const { return _a2; } inline FT dw() const { return _dw; } inline FT dxw() const { return _dxw; } inline FT dyw() const { return _dyw; } }; template< class K > class Voronoi_circle : public Bitangent_line { public: typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Bitangent_line Bitangent_line; typedef CGAL::Voronoi_radius Voronoi_radius; typedef typename Bitangent_line::FT FT; protected: FT _gamma; inline void compute_gamma() { _gamma = CGAL::square(this->_dxw) + CGAL::square(this->_dyw) - CGAL::square(this->_c2); } public: Voronoi_circle(const Voronoi_radius& vr) : Bitangent_line(FT(0), FT(0), FT(0), FT(0), vr.b(), vr.c2(), vr.delta(), vr.d(), FT(0), FT(0), FT(0)), _gamma(vr.c()) { store(vr.dxp(), vr.dyp(), vr.dwp()); } Voronoi_circle(const Bitangent_line& bl) : Bitangent_line(bl.a1(), bl.a2(), bl.b1(), bl.b2(), bl.c1(), bl.c2(), bl.delta(), bl.d(), bl.dw(), bl.dxw(), bl.dyw()) { compute_gamma(); } inline FT alpha() const { return this->_d; } inline FT beta() const { return this->_c1; } inline FT gamma() const { return _gamma; } inline bool is_first_root() const { return CGAL::is_negative(this->_c2); } FT compute_P4(const Inverted_weighted_point& u1, const Inverted_weighted_point& u2, const Inverted_weighted_point& u3) const { FT dx1 = det2x2_by_formula(u2.x(), u2.p(), u1.x(), u1.p()); FT dy1 = det2x2_by_formula(u2.y(), u2.p(), u1.y(), u1.p()); FT dw1 = det2x2_by_formula(u2.weight(), u2.p(), u1.weight(), u1.p()); FT dx3 = det2x2_by_formula(u3.x(), u3.p(), u2.x(), u2.p()); FT dy3 = det2x2_by_formula(u3.y(), u3.p(), u2.y(), u2.p()); FT dw3 = det2x2_by_formula(u3.weight(), u3.p(), u2.weight(), u2.p()); FT u2Pv2 = CGAL::square(u2.x()) + CGAL::square(u2.y()); FT u2Mv2 = CGAL::square(u2.x()) - CGAL::square(u2.y()); FT u2v2 = FT(2) * u2.x() * u2.y(); FT vvMuu = dy1 * dy3 - dx1 * dx3; FT vuPuv = dy1 * dx3 + dx1 * dy3; FT dx2Pdy2_1 = CGAL::square(dx1) + CGAL::square(dy1); FT dx2Pdy2_3 = CGAL::square(dx3) + CGAL::square(dy3); FT fr1_sq = CGAL::square(dw1) * dx2Pdy2_3; FT fr3_sq = CGAL::square(dw3) * dx2Pdy2_1; FT f1 = (fr1_sq + fr3_sq) * CGAL::square(u2Pv2); FT f2 = FT(2) * dw1 * dw3 * u2Pv2 * (u2Mv2 * vvMuu - u2v2 * vuPuv ); FT f3 = CGAL::square(u2Mv2 * vuPuv + u2v2 * vvMuu); FT F = f1 + f2 - f3; FT uuPvv = dy1 * dy3 + dx1 * dx3; FT vuMuv = dy1 * dx3 - dx1 * dy3; FT G = fr1_sq + fr3_sq - FT(2) * dw1 * dw3 * uuPvv - CGAL::square(vuMuv); return (F * G); } }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_PREDICATE_CONSTRUCTIONS_C2_H ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_graph_predicates_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_0000644000175000017500000000266011344301501031357 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Apollonius_graph_predicates_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_PREDICATES_C2_H #define CGAL_APOLLONIUS_GRAPH_PREDICATES_C2_H #include #include #include #include #include #include #include #include #include #include #endif // CGAL_APOLLONIUS_GRAPH_PREDICATES_C2_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_oriented_side_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_oriente0000644000175000017500000000607611344301501031361 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_oriented_side_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_ORIENTED_SIDE_C2_H #define CGAL_SVD_ORIENTED_SIDE_C2_H #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------------- template class Svd_oriented_side_C2 : public Svd_basic_predicates_C2 { private: typedef Svd_basic_predicates_C2 Base; typedef Svd_voronoi_vertex_2 Voronoi_vertex_2; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Line_2 Line_2; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::RT RT; public: typedef Oriented_side result_type; typedef Site_2 argument_type; typedef Arity_tag<5> Arity; // computes the oriented side of the point q // wrt the line that is passes through the point p and its direction // is the direction of the supporting line of s, rotated by 90 // degrees counterclockwise. Oriented_side operator()(const Site_2& q, const Site_2& s, const Site_2& p) const { CGAL_precondition( q.is_point() ); CGAL_precondition( s.is_segment() && p.is_point() ); Line_2 l = compute_supporting_line( s ); Line_2 lp = compute_perpendicular(l, p.point()); return lp.oriented_side(q.point()); } // computes the oriented side of the Voronoi vertex of s1, s2, s3 // wrt the line that is passes through the point p and its direction // is the direction of the supporting line of s, rotated by 90 // degrees counterclockwise. Oriented_side operator()(const Site_2& s1, const Site_2& s2, const Site_2& s3, const Site_2& s, const Site_2& p) const { CGAL_precondition( s.is_segment() && p.is_point() ); Voronoi_vertex_2 v(s1, s2, s3); Line_2 l = compute_supporting_line( s ); Line_2 lp = compute_perpendicular(l, p.point()); return v.oriented_side(lp); } }; //----------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_ORIENTED_SIDE_C2_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_same_segments_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_sam0000644000175000017500000000315711344301501031320 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_same_segments_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #include #ifndef CGAL_SVD_ARE_SAME_SEGMENTS_C2_H #define CGAL_SVD_ARE_SAME_SEGMENTS_C2_H CGAL_BEGIN_NAMESPACE template class Svd_are_same_segments_C2 { private: typedef typename K::Site_2 Site_2; typedef Svd_are_same_points_C2 Are_same_points_2; private: Are_same_points_2 same_points; public: bool operator()(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_segment() && q.is_segment() ); return ( same_points(p.source_site(), q.source_site()) && same_points(p.target_site(), q.target_site()) ) || ( same_points(p.source_site(), q.target_site()) && same_points(p.target_site(), q.source_site()) ); } }; CGAL_END_NAMESPACE #endif // CGAL_SVD_ARE_SAME_SEGMENTS_C2_H ././@LongLink0000000000000000000000000000021500000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicates_for_voronoi_intersection_cartesian_2_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicates_0000644000175000017500000001217111344301501031353 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/predicates_for_voronoi_intersection_cartesian_2_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_PREDICATES_FOR_VORONOI_INTERSECTION_CARTESIAN_2_3_H #define CGAL_PREDICATES_FOR_VORONOI_INTERSECTION_CARTESIAN_2_3_H CGAL_BEGIN_NAMESPACE template < class RT> Oriented_side side_of_plane_centered_sphere_translateC3( const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &qx, const RT &qy, const RT &qz, const RT &rx, const RT &ry, const RT &rz, const RT &tx, const RT &ty, const RT &tz) { RT q2 = CGAL_NTS square(qx) + CGAL_NTS square(qy) + CGAL_NTS square(qz); RT r2 = CGAL_NTS square(rx) + CGAL_NTS square(ry) + CGAL_NTS square(rz); RT t2 = CGAL_NTS square(tx) + CGAL_NTS square(ty) + CGAL_NTS square(tz); RT na =nx*ax + ny*ay + nz*az; na *= RT(2.0); Sign num = sign_of_determinant4x4(rx, ry, rz, r2, qx, qy, qz, q2, nx, ny, nz, na, tx, ty, tz, t2); //denumerator: Sign den = sign_of_determinant3x3(nx,ny,nz, qx,qy,qz, rx,ry,rz); CGAL_assertion(den != ZERO); return Oriented_side(den * num); } template < class RT> Oriented_side side_of_plane_centered_sphereC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &px, const RT &py, const RT &pz, const RT &qx, const RT &qy, const RT &qz, const RT &rx, const RT &ry, const RT &rz, const RT &tx, const RT &ty, const RT &tz) { // resolution of the system (where c denotes the sphere's center) // // ((a-c)*n)= 0 //the center lies in the plane (a, n) // (c-p)(c-p)=(c-q)(c-q)=(c-r)(c-r) // p,q,r on a sphere(center c) // // return: sign( (c-p)(c-p) - (c-t)(c-t)) // //method: // - tranlation of p to the origin. // - seperate computation of det and norm of the expression return side_of_plane_centered_sphere_translateC3(ax-px, ay-py, az-pz, nx, ny, nz, qx-px, qy-py,qz-pz, rx-px, ry-py,rz-pz, tx-px, ty-py,tz-pz); } template < class RT> Oriented_side side_of_plane_centered_sphere_translateC3( const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &qx, const RT &qy, const RT &qz, const RT &rx, const RT &ry, const RT &rz) { //first choice of n_ortho: (ny+nz, -nx, -nx) // if it is RT q2 = CGAL_NTS square(qx) + CGAL_NTS square(qy) + CGAL_NTS square(qz); RT r2 = CGAL_NTS square(rx) + CGAL_NTS square(ry) + CGAL_NTS square(rz); RT na =nx*ax + ny*ay + nz*az; na *= RT(2.0); Sign num = sign_of_determinant4x4(qx, qy, qz, q2, ny, -nx, RT(0), RT(0), nx, ny, nz, na, rx, ry, rz, r2); //denumerator: Sign den = sign_of_determinant3x3(nx,ny,nz, ny,-nx, RT(0), qx,qy,qz); if (den==ZERO) { // bad choice: (ny,-nx,0) is coplanar with n,q. // by precondition: q and n may not be collinear // => the cross product q*n is orthogonal to q, n and not coplanar num = sign_of_determinant4x4(qx, qy, qz, q2, ny*qz-nz*qy, nz*qx-nx*qz,nx*qy-ny*qx, RT(0), nx, ny, nz, na, rx, ry, rz, r2); den = sign_of_determinant3x3(nx,ny,nz, ny*qz-nz*qy, nz*qx - nx*qz,nx*qy-ny*qx, qx,qy,qz); } CGAL_assertion(den != ZERO); return Oriented_side(den * num); } template < class RT> Oriented_side side_of_plane_centered_sphereC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &px, const RT &py, const RT &pz, const RT &qx, const RT &qy, const RT &qz, const RT &rx, const RT &ry, const RT &rz) { // precondition: no two points p,q,r have the same projection // <=> (p-q),(p-r), (q-r) may not be collinear to n // // resolution of the system (where we note c the center) // // ((a-c)*n)= 0 //the center lies in the plane (a, n) // ((c-p)* n_orthogonal)=0 // c lies in the plane containing p and n // (c-p)(c-p)=(c-q)(c-q) // p,q lie on a sphere(center c) // // return: sign( (c-p)(c-p) - (c-r)(c-r)) // //method: // - tranlation of p to the origin. // - seperate computation of det and nom of the expression return side_of_plane_centered_sphere_translateC3(ax-px, ay-py, az-pz, nx, ny, nz, qx-px, qy-py,qz-pz, rx-px, ry-py,rz-pz); } CGAL_END_NAMESPACE #endif // CGAL_PREDICATES_FOR_VORONOI_INTERSECTION_CARTESIAN_2_3_H ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi_vertex_sqrt_field_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi0000644000175000017500000007103111344301501031340 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi_vertex_sqrt_field_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_SQRT_FIELD_C2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_SQRT_FIELD_C2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Svd_voronoi_vertex_sqrt_field_C2 : public Svd_basic_predicates_C2 { public: typedef Svd_basic_predicates_C2 Base; typedef enum {PPP = 0, PPS, PSS, SSS} vertex_t; struct PPP_Type {}; struct PPS_Type {}; struct PSS_Type {}; struct SSS_Type {}; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Line_2 Line_2; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename Base::Homogeneous_point_2 Homogeneous_point_2; private: typedef Svd_are_same_points_C2 Are_same_points_C2; typedef Svd_are_same_segments_C2 Are_same_segments_C2; typedef typename K::Intersections_tag ITag; Are_same_points_C2 same_points; Are_same_segments_C2 same_segments; private: //-------------------------------------------------------------------------- void compute_ppp(const Site_2& sp, const Site_2& sq, const Site_2& sr) { CGAL_precondition( sp.is_point() && sq.is_point() && sr.is_point() ); Point_2 p = sp.point(), q = sq.point(), r = sr.point(); v_type = PPP; FT np = CGAL::square(p.x()) + CGAL::square(p.y()); FT nq = CGAL::square(q.x()) + CGAL::square(q.y()); FT nr = CGAL::square(r.x()) + CGAL::square(r.y()); ux = np * (q.y() - r.y()) + nq * (r.y() - p.y()) + nr * (p.y() - q.y()); uy = -(np * (q.x() - r.x()) + nq * (r.x() - p.x()) + nr * (p.x() - q.x())); uz = FT(2) * ( (q.x() * r.y() - r.x() * q.y()) + (r.x() * p.y() - p.x() * r.y()) + (p.x() * q.y() - q.x() * p.y()) ); } //-------------------------------------------------------------------------- void compute_pss(const Site_2& p, const Site_2& q, const Site_2& r) { CGAL_precondition( p.is_point() && q.is_segment() && r.is_segment() ); v_type = PSS; bool pq = same_points(p, q.source_site()) || same_points(p, q.target_site()); bool pr = same_points(p, r.source_site()) || same_points(p, r.target_site()); Point_2 pp = p.point(); if ( pq && pr ) { ux = pp.x(); uy = pp.y(); uz = FT(1); return; } FT a1, b1, c1, a2, b2, c2; compute_supporting_line(q.supporting_site(), a1, b1, c1); compute_supporting_line(r.supporting_site(), a2, b2, c2); FT c1_ = a1 * pp.x() + b1 * pp.y() + c1; FT c2_ = a2 * pp.x() + b2 * pp.y() + c2; if ( pq ) { c1_ = FT(0); } if ( pr ) { c2_ = FT(0); } Sign sgn_c1_ = CGAL::sign(c1_); Sign sgn_c2_ = CGAL::sign(c2_); if ( sgn_c1_ == NEGATIVE ) { a1 = -a1; b1 = -b1; c1_ = -c1_; } else if ( sgn_c1_ == ZERO ) { CGAL_assertion( pq ); if ( same_points(p, q.target_site()) ) { a1 = -a1; b1 = -b1; c1_ = -c1_; } } if ( sgn_c2_ == NEGATIVE ) { a2 = -a2; b2 = -b2; c2_ = -c2_; } else if ( sgn_c2_ == ZERO ) { CGAL_assertion( pr ); if ( same_points(p, r.source_site()) ) { a2 = -a2; b2 = -b2; c2_ = -c2_; } } if ( pq ) { FT J = a1 * c2_; FT I = b1 * c2_; FT n1 = CGAL::square(a1) + CGAL::square(b1); FT n2 = CGAL::square(a2) + CGAL::square(b2); FT D1D2 = n1 * n2; uz = -a1 * a2 - b1 * b2 + CGAL::sqrt(D1D2); ux = J + pp.x() * uz; uy = I + pp.y() * uz; } else if ( pr ) { FT J = a2 * c1_; FT I = b2 * c1_; FT n1 = CGAL::square(a1) + CGAL::square(b1); FT n2 = CGAL::square(a2) + CGAL::square(b2); FT D1D2 = n1 * n2; uz = -a1 * a2 - b1 * b2 + CGAL::sqrt(D1D2); ux = J + pp.x() * uz; uy = I + pp.y() * uz; } else { Line_2 lq(a1, b1, c1_); Line_2 lr(a2, b2, c2_); compute_pll(pp, lq, lr); } } void compute_pll(const Point_2& p, const Line_2& lq, const Line_2& lr) { FT a1 = lq.a(), b1 = lq.b(), c1_ = lq.c(); FT a2 = lr.a(), b2 = lr.b(), c2_ = lr.c(); CGAL_precondition( c1_ >= FT(0) ); CGAL_precondition( c2_ >= FT(0) ); FT n1 = CGAL::square(a1) + CGAL::square(b1); FT n2 = CGAL::square(a2) + CGAL::square(b2); FT I = b1 * c2_ + b2 * c1_; FT J = a1 * c2_ + a2 * c1_; FT c1c2 = FT(2) * c1_ * c2_; FT a1a2 = a1 * a2; FT b1b2 = b1 * b2; FT D1D2 = n1 * n2; // compute sigma FT sigma_expr = b1 * CGAL::sqrt(n2) - b2 * CGAL::sqrt(n1); Sign s_sigma = CGAL::sign(sigma_expr); int i_sigma(s_sigma); FT sigma(i_sigma); // compute rho FT rho_expr = a1 * CGAL::sqrt(n2) - a2 * CGAL::sqrt(n1); Sign s_rho = CGAL::sign(rho_expr); int i_rho(s_rho); FT rho(i_rho); FT sqrt_D1D2 = CGAL::sqrt(D1D2); FT A = a1a2 - b1b2; FT u1 = c1c2 * (sqrt_D1D2 + A); FT u2 = c1c2 * (sqrt_D1D2 - A); uz = -a1a2 - b1b2 + CGAL::sqrt(D1D2); ux = J + p.x() * uz + sigma * CGAL::sqrt(u1); uy = I + p.y() * uz - rho * CGAL::sqrt(u2); } //-------------------------------------------------------------------------- void compute_pps(const Site_2& p, const Site_2& q, const Site_2& r) { CGAL_precondition( p.is_point() && q.is_point() && r.is_segment() ); v_type = PPS; FT a, b, c; compute_supporting_line(r.supporting_site(), a, b, c); Point_2 pp = p.point(), qq = q.point(); FT c_ = a * pp.x() + b * pp.y() + c; FT cq_ = a * qq.x() + b * qq.y() + c; if ( same_points(p, r.source_site()) || same_points(p, r.target_site()) ) { c_ = FT(0); } if ( same_points(q, r.source_site()) || same_points(q, r.target_site()) ) { cq_ = FT(0); } Sign s = CGAL::sign(c_); if ( s == NEGATIVE ) { a = -a; b = -b; c = -c; c_ = -c_; cq_ = -cq_; } else if ( s == ZERO ) { Sign s1 = CGAL::sign(cq_); CGAL_assertion( s1 != ZERO ); if ( s1 == NEGATIVE ) { a = -a; b = -b; c = -c; c_ = -c_; cq_ = -cq_; } } FT nl = CGAL::square(a) + CGAL::square(b); FT x_ = qq.x() - pp.x(); FT y_ = qq.y() - pp.y(); FT n_ = CGAL::square(x_) + CGAL::square(y_); Comparison_result res = CGAL::compare( c_, cq_ ); if ( res == EQUAL ) { FT e1 = CGAL::square(c_); FT J = nl * (a * n_ + FT(4) * c_ * x_) - FT(4) * a * e1; FT I = nl * (b * n_ + FT(4) * c_ * y_) - FT(4) * b * e1; FT X = FT(8) * nl * c_; ux = J + pp.x() * X; uy = I + pp.y() * X; uz = X; return; } FT e1 = a * x_ + b * y_; FT e2 = b * x_ - a * y_; FT e3 = n_ * e1; FT e4 = FT(2) * c_ * e2; FT X = FT(2) * CGAL::square(e1); FT I = b * e3 + x_ * e4; FT J = a * e3 - y_ * e4; FT sqrt_S = CGAL::sqrt(n_ * nl * c_ * cq_); ux = J + pp.x() * X - FT(2) * y_ * sqrt_S; uy = I + pp.y() * X + FT(2) * x_ * sqrt_S; uz = X; } //-------------------------------------------------------------------------- bool check_if_exact(const Site_2& s, unsigned int i, const Tag_false&) const { return true; } bool check_if_exact(const Site_2& s, unsigned int i, const Tag_true&) const { return s.is_input(i); } // determines of the segment s is on the positive halfspace as // defined by the supporting line of the segment supp; the line l // is supposed to be the supporting line of the segment supp and we // pass it so that we do not have to recompute it bool is_on_positive_halfspace(const Site_2& supp, const Site_2& s, const Line_2& l) const { CGAL_precondition( supp.is_segment() && s.is_segment() ); if ( same_segments(supp.supporting_site(), s.supporting_site()) ) { return false; } if ( same_points(supp.source_site(), s.source_site()) || same_points(supp.target_site(), s.source_site()) ) { return oriented_side_of_line(l, s.target()) == ON_POSITIVE_SIDE; } if ( same_points(supp.source_site(), s.target_site()) || same_points(supp.target_site(), s.target_site()) ) { return oriented_side_of_line(l, s.source()) == ON_POSITIVE_SIDE; } ITag itag; if ( !check_if_exact(s, 0, itag) && same_segments(supp.supporting_site(), s.crossing_site(0)) ) { return oriented_side_of_line(l, s.target()) == ON_POSITIVE_SIDE; } if ( !check_if_exact(s, 1, itag) && same_segments(supp.supporting_site(), s.crossing_site(1)) ) { return oriented_side_of_line(l, s.source()) == ON_POSITIVE_SIDE; } return Base::is_on_positive_halfspace(l, s.segment()); } //-------------------------------------------------------------------------- void orient_lines(const Site_2& sp, const Site_2& sq, const Site_2& sr, FT a[], FT b[], FT c[]) const { CGAL_precondition( sp.is_segment() && sq.is_segment() && sr.is_segment() ); Line_2 l[3]; l[0] = compute_supporting_line(sp.supporting_site()); l[1] = compute_supporting_line(sq.supporting_site()); l[2] = compute_supporting_line(sr.supporting_site()); bool is_oriented[3] = {false, false, false}; if ( is_on_positive_halfspace(sp, sq, l[0]) || is_on_positive_halfspace(sp, sr, l[0]) ) { is_oriented[0] = true; } else { l[0] = opposite_line(l[0]); if ( is_on_positive_halfspace(sp, sq, l[0]) || is_on_positive_halfspace(sp, sr, l[0]) ) { is_oriented[0] = true; } else { l[0] = opposite_line(l[0]); } } if ( is_on_positive_halfspace(sq, sp, l[1]) || is_on_positive_halfspace(sq, sr, l[1]) ) { is_oriented[1] = true; } else { l[1] = opposite_line(l[1]); if ( is_on_positive_halfspace(sq, sp, l[1]) || is_on_positive_halfspace(sq, sr, l[1]) ) { is_oriented[1] = true; } else { l[1] = opposite_line(l[1]); } } if ( is_on_positive_halfspace(sr, sp, l[2]) || is_on_positive_halfspace(sr, sq, l[2]) ) { is_oriented[2] = true; } else { l[2] = opposite_line(l[2]); if ( is_on_positive_halfspace(sr, sp, l[2]) || is_on_positive_halfspace(sr, sq, l[2]) ) { is_oriented[2] = true; } else { l[2] = opposite_line(l[2]); } } if ( is_oriented[0] && is_oriented[1] && is_oriented[2] ) { for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } int i_no(-1); for (int i = 0; i < 3; i++) { if ( !is_oriented[i] ) { i_no = i; CGAL_assertion( is_oriented[(i+1)%3] && is_oriented[(i+2)%3] ); break; } } CGAL_assertion( i_no != -1 ); FT sqrt_d[3]; for (int i = 0; i < 3; i++) { FT d1 = CGAL::square(l[i].a()) + CGAL::square(l[i].b()); sqrt_d[i] = CGAL::sqrt(d1); } FT z[3]; for (int i = 0; i < 3; i++) { z[i] = l[(i+1)%3].a() * l[(i+2)%3].b() - l[(i+2)%3].a() * l[(i+1)%3].b(); } FT vz = z[0] * sqrt_d[0] + z[1] * sqrt_d[1] + z[2] * sqrt_d[2]; Sign s_minus_vz = CGAL::sign(vz); CGAL_assertion( s_minus_vz != ZERO ); if ( s_minus_vz == NEGATIVE ) { l[i_no] = opposite_line(l[i_no]); for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } // now we have to check if the other orientation of l[i_no] // corresponds to a CCW triangle as well. z[(i_no+1)%3] = -z[(i_no+1)%3]; z[(i_no+2)%3] = -z[(i_no+2)%3]; vz = z[0] * sqrt_d[0] + z[1] * sqrt_d[1] + z[2] * sqrt_d[2]; Sign s_minus_vz_2 = CGAL::sign(vz); CGAL_assertion( s_minus_vz_2 != ZERO ); if ( s_minus_vz_2 == NEGATIVE ) { // the other orientation does not correspond to a CCW triangle. for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } // now compute the Voronoi vertex; for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } FT x[3], y[3], w[3]; for (int i = 0; i < 3; i++) { x[i] = c[(i+1)%3] * b[(i+2)%3] - c[(i+2)%3] * b[(i+1)%3]; y[i] = -(c[(i+1)%3] * a[(i+2)%3] - c[(i+2)%3] * a[(i+1)%3]); w[i] = -(a[(i+1)%3] * b[(i+2)%3] - a[(i+2)%3] * b[(i+1)%3]); } FT vx = FT(0), vy = FT(0), vw = FT(0); for (int i = 0; i < 3; i++) { vx += x[i] * sqrt_d[i]; vy += y[i] * sqrt_d[i]; vw += w[i] * sqrt_d[i]; } Sign s_vw = CGAL::sign(vw); FT dist = a[(i_no+1)%3] * vx + b[(i_no+1)%3] * vy + c[(i_no+1)%3] * vw; Sign sgn_dist = Sign(s_vw * CGAL::sign(dist)); CGAL_assertion( sgn_dist != ZERO ); if ( sgn_dist == NEGATIVE ) { a[i_no] = -a[i_no]; b[i_no] = -b[i_no]; c[i_no] = -c[i_no]; } } void compute_sss(const Site_2& p, const Site_2& q, const Site_2& r) { CGAL_precondition( p.is_segment() && q.is_segment() && r.is_segment() ); v_type = SSS; FT a[3], b[3], c[3]; FT cx[3], cy[3], cz[3], sqrt_D[3]; orient_lines(p, q, r, a, b, c); for (int i = 0; i < 3; i++) { cx[i] = c[(i+1)%3] * b[(i+2)%3] - c[(i+2)%3] * b[(i+1)%3]; cy[i] = -(c[(i+1)%3] * a[(i+2)%3] - c[(i+2)%3] * a[(i+1)%3]); cz[i] = -(a[(i+1)%3] * b[(i+2)%3] - a[(i+2)%3] * b[(i+1)%3]); FT d = CGAL::square(a[i]) + CGAL::square(b[i]); sqrt_D[i] = CGAL::sqrt(d); } ux = cx[0] * sqrt_D[0] + cx[1] * sqrt_D[1] + cx[2] * sqrt_D[2]; uy = cy[0] * sqrt_D[0] + cy[1] * sqrt_D[1] + cy[2] * sqrt_D[2]; uz = cz[0] * sqrt_D[0] + cz[1] * sqrt_D[1] + cz[2] * sqrt_D[2]; } //-------------------------------------------------------------------------- void compute_vertex(const Site_2& s1, const Site_2& s2, const Site_2& s3) { if ( s1.is_point() && s2.is_point() && s3.is_point() ) { compute_ppp(s1, s2, s3); } else if ( s1.is_segment() && s2.is_point() && s3.is_point() ) { compute_vertex(s2, s3, s1); pps_idx = 1; } else if ( s1.is_point() && s2.is_segment() && s3.is_point() ) { compute_vertex(s3, s1, s2); pps_idx = 2; } else if ( s1.is_point() && s2.is_point() && s3.is_segment() ) { compute_pps(s1, s2, s3); pps_idx = 0; } else if ( s1.is_point() && s2.is_segment() && s3.is_segment() ) { compute_pss(s1, s2, s3); } else if ( s1.is_segment() && s2.is_point() && s3.is_segment() ) { compute_vertex(s2, s3, s1); } else if ( s1.is_segment() && s2.is_segment() && s3.is_point() ) { compute_vertex(s3, s1, s2); } else { compute_sss(s1, s2, s3); } } //-------------------------------------------------------------------------- bool is_endpoint_of(const Site_2& p, const Site_2& s) const { CGAL_precondition( p.is_point() && s.is_segment() ); return ( same_points(p, s.source_site()) || same_points(p, s.target_site()) ); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test when the fourth site is a point //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign check_easy_degeneracies(const Site_2& t, PPS_Type, bool& use_result) const { CGAL_precondition( t.is_point() ); use_result = false; if ( ( p_.is_point() && same_points(p_, t) ) || ( q_.is_point() && same_points(q_, t) ) || ( r_.is_point() && same_points(r_, t) ) ) { use_result = true; return ZERO; } if ( ( p_.is_segment() && is_endpoint_of(t, p_) ) || ( q_.is_segment() && is_endpoint_of(t, q_) ) || ( r_.is_segment() && is_endpoint_of(t, r_) ) ) { use_result = true; return POSITIVE; } return ZERO; } Sign check_easy_degeneracies(const Site_2& t, PSS_Type, bool& use_result) const { CGAL_precondition( t.is_point() ); return check_easy_degeneracies(t, PPS_Type(), use_result); } Sign check_easy_degeneracies(const Site_2& t, SSS_Type, bool& use_result) const { CGAL_precondition( t.is_point() ); use_result = false; // ADD THE CASES WHERE t IS AN ENDPOINT OF ONE OF THE SEGMENTS return ZERO; } //-------------------------------------------------------------------------- Sign incircle_p(const Site_2& st, PPP_Type) const { CGAL_precondition( st.is_point() ); Point_2 t = st.point(); Oriented_side os = side_of_oriented_circle(p_.point(), q_.point(), r_.point(), t); if ( os == ON_POSITIVE_SIDE ) { return NEGATIVE; } if ( os == ON_NEGATIVE_SIDE ) { return POSITIVE; } return ZERO; } //-------------------------------------------------------------------------- template inline Sign incircle_p(const Site_2& st, Type type) const { CGAL_precondition( st.is_point() ); bool use_result(false); Sign s = check_easy_degeneracies(st, type, use_result); if ( use_result ) { return s; } return incircle_p_no_easy(st, type); } template Sign incircle_p_no_easy(const Site_2& st, Type type) const { CGAL_precondition( st.is_point() ); FT r2 = squared_radius(); Point_2 t = st.point(); FT d2 = CGAL::square(x() - t.x()) + CGAL::square(y() - t.y()); return Sign( CGAL::compare(d2, r2) ); } //-------------------------------------------------------------------------- Sign incircle_p(const Site_2& t) const { if ( is_degenerate_Voronoi_circle() ) { return POSITIVE; } Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle_p(t, PPP_Type()); break; case PPS: s = incircle_p(t, PPS_Type()); break; case PSS: s = incircle_p(t, PSS_Type()); break; case SSS: s = incircle_p(t, SSS_Type()); break; } return s; } Sign incircle_p_no_easy(const Site_2& t) const { Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle_p(t, PPP_Type()); break; case PPS: s = incircle_p_no_easy(t, PPS_Type()); break; case PSS: s = incircle_p_no_easy(t, PSS_Type()); break; case SSS: s = incircle_p_no_easy(t, SSS_Type()); break; } return s; } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test when the fourth site is a segment //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Oriented_side oriented_side(const Line_2& l, const Point_2& p) const { Line_2 l1(l.b(), -l.a(), l.a() * y() - l.b() * x()); return oriented_side_of_line(l1, p); } Sign incircle(const Line_2& l) const { FT r2 = squared_radius(); FT n2 = CGAL::square(l.a()) + CGAL::square(l.b()); FT d2 = CGAL::square(l.a() * x() + l.b() * y() + l.c()); return Sign( CGAL::compare(d2, r2 * n2) ); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign incircle_s(const Site_2& t, int i) const { CGAL_precondition( t.is_segment() ); if ( v_type == PPP || v_type == PPS ) { if ( p_.is_point() && q_.is_point() && is_endpoint_of(p_, t) && is_endpoint_of(q_, t) ) { return NEGATIVE; } if ( p_.is_point() && r_.is_point() && is_endpoint_of(p_, t) && is_endpoint_of(r_, t) ){ return NEGATIVE; } if ( q_.is_point() && r_.is_point() && is_endpoint_of(q_, t) && is_endpoint_of(r_, t) ){ return NEGATIVE; } } if ( v_type == PSS ) { if ( p_.is_segment() && same_segments(p_.supporting_site(), t.supporting_site()) ) { return POSITIVE; } if ( q_.is_segment() && same_segments(q_.supporting_site(), t.supporting_site()) ) { return POSITIVE; } if ( r_.is_segment() && same_segments(r_.supporting_site(), t.supporting_site()) ) { return POSITIVE; } } return incircle_s_no_easy(t, i); } Sign incircle_s_no_easy(const Site_2& t, int) const { Sign d1, d2; if ( ( p_.is_point() && same_points(p_, t.source_site()) ) || ( q_.is_point() && same_points(q_, t.source_site()) ) || ( r_.is_point() && same_points(r_, t.source_site()) ) ) { d1 = ZERO; } else { d1 = incircle_p(t.source_site()); } if ( d1 == NEGATIVE ) { return NEGATIVE; } if ( ( p_.is_point() && same_points(p_, t.target_site()) ) || ( q_.is_point() && same_points(q_, t.target_site()) ) || ( r_.is_point() && same_points(r_, t.target_site()) ) ) { d2 = ZERO; } else { d2 = incircle_p(t.target_site()); } if ( d2 == NEGATIVE ) { return NEGATIVE; } Line_2 l = compute_supporting_line(t.supporting_site()); Sign sl = incircle(l); if ( sl == POSITIVE ) { return sl; } if ( sl == ZERO && (d1 == ZERO || d2 == ZERO) ) { return ZERO; } Oriented_side os1 = oriented_side(l, t.source()); Oriented_side os2 = oriented_side(l, t.target()); if ( sl == ZERO ) { if (os1 == ON_ORIENTED_BOUNDARY || os2 == ON_ORIENTED_BOUNDARY) { return ZERO; } return ( os1 == os2 ) ? POSITIVE : ZERO; } return (os1 == os2) ? POSITIVE : NEGATIVE; } //-------------------------------------------------------------------------- Sign incircle_s(const Site_2& t) const { CGAL_precondition( t.is_segment() ); if ( is_degenerate_Voronoi_circle() ) { // case 1: the new segment is not adjacent to the center of the // degenerate Voronoi circle if ( !same_points( p_ref(), t.source_site() ) && !same_points( p_ref(), t.target_site() ) ) { return POSITIVE; } CGAL_assertion( v_type == PSS ); if ( p_.is_segment() && same_segments(p_.supporting_site(), t.supporting_site()) ) { return ZERO; } if ( q_.is_segment() && same_segments(q_.supporting_site(), t.supporting_site()) ) { return ZERO; } if ( r_.is_segment() && same_segments(r_.supporting_site(), t.supporting_site()) ) { return ZERO; } Site_2 pr; Site_2 sp, sq; if ( p_.is_point() ) { CGAL_assertion( q_.is_segment() && r_.is_segment() ); pr = p_; sp = q_; sq = r_; } else if ( q_.is_point() ) { CGAL_assertion( r_.is_segment() && p_.is_segment() ); pr = q_; sp = r_; sq = p_; } else { CGAL_assertion( p_.is_segment() && q_.is_segment() ); pr = r_; sp = p_; sq = q_; } Point_2 pq = sq.source(), pp = sp.source(), pt = t.source(); if ( same_points(sp.source_site(), pr) ) { pp = sp.target(); } if ( same_points(sq.source_site(), pr) ) { pq = sq.target(); } if ( same_points( t.source_site(), pr) ) { pt = t.target(); } Point_2 pr_ = pr.point(); if ( CGAL::orientation(pr_, pp, pt) == LEFT_TURN && CGAL::orientation(pr_, pq, pt) == RIGHT_TURN ) { return NEGATIVE; } return ZERO; } // if ( is_degenerate_Voronoi_circle() ) Sign s = incircle_s(t, 0); return s; } inline Sign incircle_s_no_easy(const Site_2& t) const { return incircle_s_no_easy(t, 0); } //-------------------------------------------------------------------------- // subpredicates for the incircle test //-------------------------------------------------------------------------- public: bool is_degenerate_Voronoi_circle() const { if ( v_type != PSS ) { return false; } if ( p_.is_point() ) { return ( is_endpoint_of(p_, q_) && is_endpoint_of(p_, r_) ); } else if ( q_.is_point() ) { return ( is_endpoint_of(q_, p_) && is_endpoint_of(q_, r_) ); } else { CGAL_assertion( r_.is_point() ); return ( is_endpoint_of(r_, p_) && is_endpoint_of(r_, q_) ); } } //-------------------------------------------------------------------------- private: //-------------------------------------------------------------------------- // the reference point (valid if v_type != SSS) //-------------------------------------------------------------------------- Site_2 p_ref() const { CGAL_precondition ( v_type != SSS ); if ( v_type == PPS ) { if ( pps_idx == 0 ) { return p_; } if ( pps_idx == 1 ) { return q_; } return r_; } if ( p_.is_point() ) { return p_; } else if ( q_.is_point() ) { return q_; } else { CGAL_assertion( r_.is_point() ); return r_; } } public: //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // access methods //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- FT x() const { return hx() / hw(); } FT y() const { return hy() / hw(); } FT hx() const { return ux; } FT hy() const { return uy; } FT hw() const { return uz; } FT squared_radius() const { switch (v_type) { case PPP: case PPS: case PSS: { Point_2 pref = p_ref().point(); FT dx2 = CGAL::square(x() - pref.x()); FT dy2 = CGAL::square(y() - pref.y()); return dx2 + dy2; } case SSS: { Line_2 l = compute_supporting_line(p_.supporting_site()); Homogeneous_point_2 q = compute_projection(l, point()); FT dx2 = CGAL::square(x() - q.x()); FT dy2 = CGAL::square(y() - q.y()); return dx2 + dy2; } default: return FT(0); } } Point_2 point() const { if ( is_degenerate_Voronoi_circle() ) { return degenerate_point(); } return Point_2(x(), y()); } Point_2 degenerate_point() const { CGAL_precondition( is_degenerate_Voronoi_circle() ); return p_ref().point(); } typename K::Circle_2 circle() const { typedef typename K::Circle_2 K_Circle_2; return K_Circle_2(point(), squared_radius()); } vertex_t type() const { return v_type; } public: Svd_voronoi_vertex_sqrt_field_C2(const Site_2& p, const Site_2& q, const Site_2& r) : p_(p), q_(q), r_(r) { compute_vertex(p, q, r); } //-------------------------------------------------------------------------- Sign incircle(const Site_2& t) const { if ( t.is_point() ) { return incircle_p(t); } return incircle_s(t); } Sign incircle_no_easy(const Site_2& t) const { Sign s; if ( t.is_point() ) { s = incircle_p_no_easy(t); } else { s = incircle_s_no_easy(t); } return s; } //-------------------------------------------------------------------------- Orientation orientation(const Line_2& l) const { Sign s = CGAL::sign(l.a() * x() + l.b() * y() + l.c()); if ( s == ZERO ) { return COLLINEAR; } return ( s == POSITIVE ) ? LEFT_TURN : RIGHT_TURN; } Oriented_side oriented_side(const Line_2& l) const { Orientation o = orientation(l); if ( o == COLLINEAR ) { return ON_ORIENTED_BOUNDARY; } return ( o == LEFT_TURN ) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } //-------------------------------------------------------------------------- private: const Site_2& p_, q_, r_; vertex_t v_type; // index that indicates the refence point for the case PPS short pps_idx; FT ux, uy, uz; }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VEFTEX_SQRT_FIELD_C2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare_x_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare0000644000175000017500000000272711344301501031216 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_compare_x_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_COMPARE_X_2_H #define CGAL_AG2_COMPARE_X_2_H #include //-------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE template class Ag2_compare_x_2 { public: typedef K Kernel; typedef typename K::Site_2 Site_2; typedef Comparison_result result_type; typedef Arity_tag<2> Arity; typedef Site_2 argument_type; inline Comparison_result operator()(const Site_2& s1, const Site_2& s2) const { return CGAL::compare(s1.x(), s2.x()); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_COMPARE_X_2_H ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_vertex_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Vor0000644000175000017500000000502411344301501031320 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_vertex_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_C2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_C2_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { #if 0 template struct Svd_which_base_C2 { template struct Which_base { typedef Svd_voronoi_vertex_ring_C2 Base; }; }; template <> struct Svd_which_base_C2 { template struct Which_base { typedef Svd_voronoi_vertex_sqrt_field_C2 Base; }; }; #else // with partial specialization: template struct Svd_which_base_C2; template struct Svd_which_base_C2 { typedef Svd_voronoi_vertex_ring_C2 Base; }; template struct Svd_which_base_C2 { typedef Svd_voronoi_vertex_sqrt_field_C2 Base; }; #endif } // namespace CGALi //---------------------------------------------------------------------- template class Svd_voronoi_vertex_C2 // : public CGALi::Svd_which_base_C2::template Which_base::Base // using partial specialization: : public CGALi::Svd_which_base_C2::Base { private: // typedef typename // CGALi::Svd_which_base_C2::template Which_base::Base Base; typedef typename CGALi::Svd_which_base_C2::Base Base; protected: typedef typename Base::Site_2 Site_2; public: Svd_voronoi_vertex_C2(const Site_2& p, const Site_2& q, const Site_2& r) : Base(p, q, r) {} }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_C2_H ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_predicates_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Vor0000644000175000017500000000332611344301501031323 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_predicates_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_C2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_C2_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_C2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/comparator_profiler.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/comparator_0000644000175000017500000001061211344301501031375 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/comparator_profiler.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_COMPARATOR_PROFILER_H #define CGAL_COMPARATOR_PROFILER_H CGAL_BEGIN_NAMESPACE class comparator_profiler { public: static bool count_cases; static unsigned long case_1_counter; static unsigned long case_2_counter; static unsigned long case_3a_Jpos_counter; static unsigned long case_3a_Jneg_counter; static unsigned long case_3b_Jpos_counter; static unsigned long case_3b_Jneg_counter; static unsigned long case_4_counter; static unsigned long case_5_counter; static unsigned long case_degenerate_counter; public: static unsigned long counter_rr; static unsigned long counter_rr_p3inf; static unsigned long counter_rr_p4; static unsigned long counter_rr_e; static unsigned long counter_rr_r0; // static unsigned long counter_rr_jneg; static void reset() { count_cases = false; case_1_counter = 0; case_2_counter = 0; case_3a_Jpos_counter = 0; case_3a_Jneg_counter = 0; case_3b_Jpos_counter = 0; case_3b_Jneg_counter = 0; case_4_counter = 0; case_5_counter = 0; case_degenerate_counter = 0; counter_rr = 0; counter_rr_p3inf = 0; counter_rr_p4 = 0; counter_rr_e = 0; counter_rr_r0 = 0; // counter_rr_jneg = 0; } template< class FT > static void count_case(const FT& a1, const FT& b1, const FT& c1, const FT& a2, const FT& b2, const FT& c2) { // works correctly only with leda_real FT D1 = CGAL::square(b1) - a1 * c1; FT l1 = (b1 - CGAL::sqrt(D1)) / a1; FT r1 = (b1 + CGAL::sqrt(D1)) / a1; if ( a1 < 0 ) { std::swap(r1, l1); } FT D2 = CGAL::square(b2) - a2 * c2; if ( D1 == 0 || D2 == 0 ) { case_degenerate_counter++; return; } FT l2 = (b2 - CGAL::sqrt(D2)) / a2; FT r2 = (b2 + CGAL::sqrt(D2)) / a2; if ( a2 < 0 ) { std::swap(r2, l2); } if ( l1 < l2 ) { if ( r1 > r2 ) { FT J = a1 * b2 - a2 * b1; if ( J > 0 ) { case_3b_Jpos_counter++; } else if ( J < 0 ) { case_3b_Jneg_counter++; } else { case_degenerate_counter++; } } else if ( r1 < r2 ) { if ( r1 < l2 ) { case_5_counter++; } else if ( r1 > l2 ) { case_4_counter++; } else { case_degenerate_counter++; } } else { case_degenerate_counter++; } } else if ( l1 > l2 ) { if ( r1 < r2 ) { FT J = a1 * b2 - a2 * b1; if ( J > 0 ) { case_3a_Jpos_counter++; } else if ( J < 0 ) { case_3a_Jneg_counter++; } else { case_degenerate_counter++; } } else if ( r1 > r2 ) { if ( l1 < r2 ) { case_2_counter++; } else if ( l1 > r2 ) { case_1_counter++; } else { case_degenerate_counter++; } } else { case_degenerate_counter++; } } else { case_degenerate_counter++; } } }; bool comparator_profiler::count_cases = false; unsigned long comparator_profiler::case_1_counter = 0; unsigned long comparator_profiler::case_2_counter = 0; unsigned long comparator_profiler::case_3a_Jpos_counter = 0; unsigned long comparator_profiler::case_3a_Jneg_counter = 0; unsigned long comparator_profiler::case_3b_Jpos_counter = 0; unsigned long comparator_profiler::case_3b_Jneg_counter = 0; unsigned long comparator_profiler::case_4_counter = 0; unsigned long comparator_profiler::case_5_counter = 0; unsigned long comparator_profiler::case_degenerate_counter = 0; unsigned long comparator_profiler::counter_rr = 0; unsigned long comparator_profiler::counter_rr_p3inf = 0; unsigned long comparator_profiler::counter_rr_p4 = 0; unsigned long comparator_profiler::counter_rr_e = 0; unsigned long comparator_profiler::counter_rr_r0 = 0; //unsigned long comparator_profiler::counter_rr_jneg = 0; CGAL_END_NAMESPACE #endif // CGAL_COMPARATOR_PROFILER_H ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/in_smallest_orthogonalcircle_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/in_smallest0000644000175000017500000000345511344301501031410 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/in_smallest_orthogonalcircle_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H #define CGAL_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H #include #include //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- template< class FT > CGAL_MEDIUM_INLINE Bounded_side in_smallest_orthogonalcircleC2(const FT &px, const FT &py, const FT &pw, const FT &qx, const FT &qy, const FT &qw, const FT &tx, const FT &ty, const FT &tw) { FT dpx = px-qx; FT dpy = py-qy; FT dtx = tx-qx; FT dty = ty-qy; FT dpz = CGAL_NTS square(dpx)+CGAL_NTS square(dpy); return Bounded_side (CGAL_NTS sign(-(CGAL_NTS square(dtx)+CGAL_NTS square(dty)-tw+qw)*dpz +(dpz-pw+qw)*(dpx*dtx+dpy*dty))); } //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif //CGAL_IN_SMALLEST_ORTHOGONALCIRCLEC2_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_is_hidden_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_is_hidd0000644000175000017500000000443111344301501031165 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_is_hidden_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_IS_HIDDEN_C2_H #define CGAL_AG2_IS_HIDDEN_C2_H #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template class Ag2_is_hidden_C2 { public: typedef K Kernel; typedef MTag Method_tag; typedef typename K::Site_2 Site_2; typedef typename K::RT RT; private: bool is_hidden(const Site_2& p, const Site_2& q, const Ring_tag&) const { RT w1 = p.weight(); RT w2 = q.weight(); Sign s = CGAL::sign( CGAL::square(p.x() - q.x()) + CGAL::square(p.y() - q.y()) - CGAL::square(w1 - w2) ); if ( s == POSITIVE ) { return false; } return (CGAL::compare(w1, w2) != SMALLER); } bool is_hidden(const Site_2& p, const Site_2& q, const Sqrt_field_tag&) const { RT d = CGAL::sqrt(CGAL::square(p.x() - q.x()) + CGAL::square(p.y() - q.y())); Sign s = CGAL::sign(d - p.weight() + q.weight()); return ( s != POSITIVE ); } public: typedef bool result_type; typedef Site_2 argument_type; typedef Arity_tag<2> Arity; inline bool operator()(const Site_2 &p, const Site_2 &q) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::is_trivial_counter++; #endif return is_hidden(p, q, Method_tag()); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_IS_HIDDEN_C2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Square_root_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Square_root0000644000175000017500000001735511344301501031405 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Square_root_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SQUARE_ROOT_2_H #define CGAL_SQUARE_ROOT_2_H #include CGAL_BEGIN_NAMESPACE template class Square_root_2 { private: typedef Square_root_2 Self; typedef Square_root_1 Sqrt_1; NT a0_, a1_, a2_, a3_; NT A_, B_; public: typedef NT FT; typedef NT RT; public: Square_root_2() : a0_(0), a1_(0), a2_(0), a3_(0), A_(0), B_(0) {} Square_root_2(int i) : a0_(i), a1_(0), a2_(0), a3_(0), A_(0), B_(0) {} Square_root_2(const NT& a) : a0_(a), a1_(0), a2_(0), a3_(0), A_(0), B_(0) {} Square_root_2(const NT& a0, const NT& a1, const NT& a2, const NT& a3, const NT& A, const NT& B) : a0_(a0), a1_(a1), a2_(a2), a3_(a3), A_(A), B_(B) { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( !(CGAL::is_negative(A_)) ); CGAL_precondition( !(CGAL::is_negative(B_)) ); #endif } Square_root_2(const Square_root_2& other) : a0_(other.a0_), a1_(other.a1_), a2_(other.a2_), a3_(other.a3_), A_(other.A_), B_(other.B_) {} NT a() const { return a0_; } NT b() const { return a1_; } NT c() const { return a2_; } NT d() const { return a3_; } NT e() const { return A_; } NT f() const { return B_; } Self operator*(const Self& b) const { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( CGAL::compare(A_, b.A_) == EQUAL ); CGAL_precondition( CGAL::compare(B_, b.B_) == EQUAL ); #endif NT a0 = a0_ * b.a0_ + a1_ * b.a1_ * A_ + a2_ * b.a2_ * B_ + a3_ * b.a3_ * A_ * B_; NT a1 = a0_ * b.a1_ + a1_ * b.a0_ + (a2_ * b.a3_ + a3_ * b.a2_) * B_; NT a2 = a0_ * b.a2_ + a2_ * b.a0_ + (a1_ * b.a3_ + a3_ * b.a1_) * A_; NT a3 = a0_ * b.a3_ + a3_ * b.a0_ + a1_ * b.a2_ + a2_ * b.a1_; return Self(a0, a1, a2, a3, A_, B_); } Self operator-() const { return Self(-a0_, -a1_, -a2_, -a3_, A_, B_); } Self operator+() const { return (*this); } Self square() const { NT a0 = CGAL::square(a0_) + CGAL::square(a1_) * A_ + CGAL::square(a2_) * B_ + CGAL::square(a3_) * A_ * B_; NT a1_half = a0_ * a1_ + a2_ * a3_ * B_; NT a2_half = a0_ * a2_ + a1_ * a3_ * A_; NT a3_half = a0_ * a3_ + a1_ * a2_; NT a1 = a1_half + a1_half; NT a2 = a2_half + a2_half; NT a3 = a3_half + a3_half; return Self(a0, a1, a2, a3, A_, B_); } Sign sign() const { Sqrt_1 x(a0_, a1_, A_); Sqrt_1 y(a2_, a3_, A_); Sign s_x = Number_type_traits::sign(x); Sign s_y = Number_type_traits::sign(y); Sign s_B = Number_type_traits::sign(B_); if ( s_B == ZERO ) { return s_x; } else if ( s_x == s_y ) { return s_x; } else if ( s_x == ZERO ) { return s_y; } else if ( s_y == ZERO ) { return s_x; } else { Sqrt_1 Q = CGAL::square(x) - CGAL::square(y) * B_; return Sign(s_x * Number_type_traits::sign(Q)); } } double to_double() const { // THIS MUST BE CHECK WITH SYLVAIN FOR CORRECTNESS double a0d = CGAL::to_double(a0_); double a1d = CGAL::to_double(a1_); double a2d = CGAL::to_double(a2_); double a3d = CGAL::to_double(a3_); double Ad = CGAL::to_double(A_); double Bd = CGAL::to_double(B_); return (a0d + a1d * CGAL::sqrt(Ad) + a2d * CGAL::sqrt(Bd) + a3d * CGAL::sqrt(Ad * Bd)); } }; // operator * template inline Square_root_2 operator*(const Square_root_2& x, const NT& n) { return Square_root_2(x.a() * n, x.b() * n, x.c() * n, x.d() * n, x.e(), x.f()); } template inline Square_root_2 operator*(const NT& n, const Square_root_2& x) { return (x * n); } // operator + template inline Square_root_2 operator+(const Square_root_2& x, const NT& n) { return Square_root_2(x.a() + n, x.b(), x.c(), x.d(), x.e(), x.f()); } template inline Square_root_2 operator+(const NT& n, const Square_root_2& x) { return (x + n); } template inline Square_root_2 operator+(const Square_root_2& x, const Square_root_2& y) { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( CGAL::compare(x.e(), y.e()) == EQUAL ); CGAL_precondition( CGAL::compare(x.f(), y.f()) == EQUAL ); #endif return Square_root_2(x.a() + y.a(), x.b() + y.b(), x.c() + y.c(), x.d() + y.d(), x.e(), x.f()); } // operator - template inline Square_root_2 operator-(const Square_root_2& x, const NT& n) { return x + (-n); } template inline Square_root_2 operator-(const NT& n, const Square_root_2& x) { return -(x - n); } template inline Square_root_2 operator-(const Square_root_2& x, const Square_root_2& y) { return (x + (-y)); } //=================================================================== template struct Number_type_traits< Square_root_2 > { static inline bool is_positive(const Square_root_2& x) { return x.sign() == POSITIVE; } static inline bool is_negative(const Square_root_2& x) { return x.sign() == NEGATIVE; } static inline bool is_zero(const Square_root_2& x) { return x.sign() == ZERO; } static inline Sign sign(const Square_root_2& x) { return x.sign(); } static inline Square_root_2 square(const Square_root_2& x) { return x.square(); } static inline Comparison_result compare(const Square_root_2& x, const Square_root_2& y) { #if CHECK_CGAL_PRECONDITIONS CGAL_precondition( CGAL::compare(x.e(), y.e()) == EQUAL ); CGAL_precondition( CGAL::compare(x.f(), y.f()) == EQUAL ); #endif // Sign s = CGAL::sign(x - y); Sign s = (x - y).sign(); if ( s == ZERO ) { return EQUAL; } return (s == POSITIVE) ? LARGER : SMALLER; } }; template inline bool is_positive(const Square_root_2& x) { return Number_type_traits< Square_root_2 >::is_positive(x); } template inline bool is_negative(const Square_root_2& x) { return Number_type_traits< Square_root_2 >::is_negative(x); } template inline bool is_zero(const Square_root_2& x) { return Number_type_traits< Square_root_2 >::is_zero(x); } template inline Sign sign(const Square_root_2& x) { return Number_type_traits< Square_root_2 >::sign(x); } template inline Square_root_2 square(const Square_root_2& x) { return Number_type_traits< Square_root_2 >::square(x); } template inline Comparison_result compare(const Square_root_2& x, const Square_root_2& y) { return Number_type_traits< Square_root_2 >::compare(x, y); } // operator << template inline Stream& operator<<(Stream& os, const Square_root_2& x) { os << "(" << x.a() << ")+(" << x.b() << ") sqrt{" << x.e() << "}"; os << "+(" << x.c() << ") sqrt{" << x.f() << "}"; os << "+(" << x.d() << ") sqrt{(" << x.e() << ") (" << x.f() << ")}"; return os; } CGAL_END_NAMESPACE #endif // CGAL_SQUARE_ROOT_2_H ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi_vertex_sqrt_field_H2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi0000644000175000017500000006372111344301501031347 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_Voronoi_vertex_sqrt_field_H2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_SQRT_FIELD_H2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VERTEX_SQRT_FIELD_H2_H #include #include #include CGAL_BEGIN_NAMESPACE template class Svd_voronoi_vertex_sqrt_field_H2 : public Svd_basic_predicates_H2 { public: typedef Svd_basic_predicates_H2 Base; typedef enum {PPP = 0, PPS, PSS, SSS} vertex_t; struct PPP_Type {}; struct PPS_Type {}; struct PSS_Type {}; struct SSS_Type {}; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Line_2 Line_2; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename Base::Homogeneous_point_2 Homogeneous_point_2; private: //-------------------------------------------------------------------------- void compute_ppp(const Point_2& p, const Point_2& q, const Point_2& r) { v_type = PPP; RT np = CGAL::square(p.hx()) + CGAL::square(p.hy()); RT nq = CGAL::square(q.hx()) + CGAL::square(q.hy()); RT nr = CGAL::square(r.hx()) + CGAL::square(r.hy()); RT p_xw = p.hx() * p.hw(); RT q_xw = q.hx() * q.hw(); RT r_xw = r.hx() * r.hw(); RT p_yw = p.hy() * p.hw(); RT q_yw = q.hy() * q.hw(); RT r_yw = r.hy() * r.hw(); RT p_hw_sq = CGAL::square( p.hw() ); RT q_hw_sq = CGAL::square( q.hw() ); RT r_hw_sq = CGAL::square( r.hw() ); ux = -det3x3_by_formula(p_yw, np, p_hw_sq, q_yw, nq, q_hw_sq, r_yw, nr, r_hw_sq); uy = det3x3_by_formula(p_xw, np, p_hw_sq, q_xw, nq, q_hw_sq, r_xw, nr, r_hw_sq); uz = RT(2) * det3x3_by_formula(p_xw, p_yw, p_hw_sq, q_xw, q_yw, q_hw_sq, r_xw, r_yw, r_hw_sq); } //-------------------------------------------------------------------------- void compute_pss(const Point_2& p, const Segment_2& q, const Segment_2& r) { v_type = PSS; bool pq = (p == q.source() || p == q.target()); bool pr = (p == r.source() || p == r.target()); if ( pq && pr ) { ux = p.hx(); uy = p.hy(); uz = p.hw(); return; } RT a1, b1, c1, a2, b2, c2; compute_supporting_line(q, a1, b1, c1); compute_supporting_line(r, a2, b2, c2); RT c1_ = a1 * p.hx() + b1 * p.hy() + c1 * p.hw(); RT c2_ = a2 * p.hx() + b2 * p.hy() + c2 * p.hw(); if ( pq ) { c1_ = RT(0); } if ( pr ) { c2_ = RT(0); } Sign sgn_c1_ = CGAL::sign(c1_); Sign sgn_c2_ = CGAL::sign(c2_); if ( sgn_c1_ == NEGATIVE ) { a1 = -a1; b1 = -b1; c1_ = -c1_; } else if ( sgn_c1_ == ZERO ) { CGAL_assertion( pq ); if ( p == q.target() ) { a1 = -a1; b1 = -b1; c1_ = -c1_; } } if ( sgn_c2_ == NEGATIVE ) { a2 = -a2; b2 = -b2; c2_ = -c2_; } else if ( sgn_c2_ == ZERO ) { CGAL_assertion( pr ); if ( p == r.source() ) { a2 = -a2; b2 = -b2; c2_ = -c2_; } } if ( pq ) { RT J = a1 * c2_; RT I = b1 * c2_; RT n1 = CGAL::square(a1) + CGAL::square(b1); RT n2 = CGAL::square(a2) + CGAL::square(b2); RT D1D2 = n1 * n2; uz = p.hw() * (-a1 * a2 - b1 * b2 + CGAL::sqrt(D1D2)); ux = J + p.hx() * uz; uy = I + p.hy() * uz; } else if ( pr ) { RT J = a2 * c1_; RT I = b2 * c1_; RT n1 = CGAL::square(a1) + CGAL::square(b1); RT n2 = CGAL::square(a2) + CGAL::square(b2); RT D1D2 = n1 * n2; uz = p.hw() * (-a1 * a2 - b1 * b2 + CGAL::sqrt(D1D2)); ux = J + p.hx() * uz; uy = I + p.hy() * uz; } else { Line_2 lq(a1, b1, c1_); Line_2 lr(a2, b2, c2_); compute_pll(p, lq, lr); } } void compute_pll(const Point_2& p, const Line_2& lq, const Line_2& lr) { RT a1 = lq.a(), b1 = lq.b(), c1_ = lq.c(); RT a2 = lr.a(), b2 = lr.b(), c2_ = lr.c(); CGAL_precondition( c1_ >= FT(0) ); CGAL_precondition( c2_ >= FT(0) ); RT n1 = CGAL::square(a1) + CGAL::square(b1); RT n2 = CGAL::square(a2) + CGAL::square(b2); RT I = b1 * c2_ + b2 * c1_; RT J = a1 * c2_ + a2 * c1_; RT c1c2 = RT(2) * c1_ * c2_; RT a1a2 = a1 * a2; RT b1b2 = b1 * b2; RT D1D2 = n1 * n2; Sign s_pw = CGAL::sign( p.hw() ); // compute sigma RT sigma_expr = b1 * CGAL::sqrt(n2) - b2 * CGAL::sqrt(n1); Sign s_sigma = s_pw * CGAL::sign(sigma_expr); int i_sigma(s_sigma); RT sigma(i_sigma); // compute rho RT rho_expr = a1 * CGAL::sqrt(n2) - a2 * CGAL::sqrt(n1); Sign s_rho = s_pw * CGAL::sign(rho_expr); int i_rho(s_rho); RT rho(i_rho); RT sqrt_D1D2 = CGAL::sqrt(D1D2); RT A = a1a2 - b1b2; RT u1 = c1c2 * (sqrt_D1D2 + A); RT u2 = c1c2 * (sqrt_D1D2 - A); uz = p.hw() * (-a1a2 - b1b2 + CGAL::sqrt(D1D2)); ux = J + p.hx() * uz + sigma * CGAL::sqrt(u1); uy = I + p.hy() * uz - rho * CGAL::sqrt(u2); } //-------------------------------------------------------------------------- void compute_pps(const Point_2& p, const Point_2& q, const Segment_2& r) { v_type = PPS; RT a, b, c; compute_supporting_line(r, a, b, c); RT c_ = a * p.hx() + b * p.hy() + c * p.hw(); RT cq_ = a * q.hx() + b * q.hy() + c * q.hw(); if ( p == r.source() || p == r.target() ) { c_ = RT(0); } if ( q == r.source() || q == r.target() ) { cq_ = RT(0); } Sign s_pw = CGAL::sign( p.hw() ); Sign s_qw = CGAL::sign( q.hw() ); Sign s = s_pw * CGAL::sign(c_); if ( s == NEGATIVE ) { a = -a; b = -b; c = -c; c_ = -c_; cq_ = -cq_; } else if ( s == ZERO ) { Sign s1 = s_qw * CGAL::sign(cq_); CGAL_assertion( s1 != ZERO ); if ( s1 == NEGATIVE ) { a = -a; b = -b; c = -c; c_ = -c_; cq_ = -cq_; } } RT nl = CGAL::square(a) + CGAL::square(b); RT x_ = q.hx() * p.hw() - p.hx() * q.hw(); RT y_ = q.hy() * p.hw() - p.hy() * q.hw(); RT n_ = CGAL::square(x_) + CGAL::square(y_); // old equality of distcne check // ------------------------------ // Comparison_result res = CGAL::compare( c_, cq_); // checking equality of distance through the quantity X: Comparison_result res = CGAL::compare(a * x_, -b * y_); if ( res == EQUAL ) { RT qw_sq = CGAL::square( q.hw() ); RT e1 = CGAL::square(c_); RT J = nl * (a * n_ + RT(4) * c_ * x_ * q.hw()) - RT(4) * a * e1 * qw_sq; RT I = nl * (b * n_ + RT(4) * c_ * y_ * q.hw()) - RT(4) * b * e1 * qw_sq; RT X = RT(8) * nl * c_ * qw_sq * p.hw(); ux = J + p.hx() * X; uy = I + p.hy() * X; uz = p.hw() * X; return; } FT e1 = a * x_ + b * y_; FT e2 = b * x_ - a * y_; FT e3 = n_ * e1; FT e4 = FT(2) * c_ * e2 * q.hw(); FT X = FT(2) * CGAL::square(e1); FT I = b * e3 + x_ * e4; FT J = a * e3 - y_ * e4; FT sqrt_S = CGAL::sqrt(p.hw() * q.hw() * n_ * nl * c_ * cq_); ux = J + p.hx() * X - FT(2) * y_ * sqrt_S; uy = I + p.hy() * X + FT(2) * x_ * sqrt_S; uz = p.hw() * X; } //-------------------------------------------------------------------------- bool is_consistent(const Segment_2& p, const Segment_2& q, const Segment_2& r, RT a[], RT b[], RT c[]) const { Line_2 l[3] = {Line_2(a[0], b[0], c[0]), Line_2(a[1], b[1], c[1]), Line_2(a[2], b[2], c[2])}; int num_oriented(0); if ( is_on_positive_halfspace(l[0], q) || is_on_positive_halfspace(l[0], r) ) { num_oriented++; } if ( is_on_positive_halfspace(l[1], p) || is_on_positive_halfspace(l[1], r) ) { num_oriented++; } if ( is_on_positive_halfspace(l[2], p) || is_on_positive_halfspace(l[2], q) ) { num_oriented++; } return ( num_oriented >= 2 ); } void orient_lines(const Segment_2& p, const Segment_2& q, const Segment_2& r, RT a[], RT b[], RT c[]) const { Line_2 l[3]; l[0] = compute_supporting_line(p); l[1] = compute_supporting_line(q); l[2] = compute_supporting_line(r); bool is_oriented[3] = {false, false, false}; if ( is_on_positive_halfspace(l[0], q) || is_on_positive_halfspace(l[0], r) ) { is_oriented[0] = true; } else { l[0] = opposite_line(l[0]); if ( is_on_positive_halfspace(l[0], q) || is_on_positive_halfspace(l[0], r) ) { is_oriented[0] = true; } else { l[0] = opposite_line(l[0]); } } if ( is_on_positive_halfspace(l[1], p) || is_on_positive_halfspace(l[1], r) ) { is_oriented[1] = true; } else { l[1] = opposite_line(l[1]); if ( is_on_positive_halfspace(l[1], p) || is_on_positive_halfspace(l[1], r) ) { is_oriented[1] = true; } else { l[1] = opposite_line(l[1]); } } if ( is_on_positive_halfspace(l[2], p) || is_on_positive_halfspace(l[2], q) ) { is_oriented[2] = true; } else { l[2] = opposite_line(l[2]); if ( is_on_positive_halfspace(l[2], p) || is_on_positive_halfspace(l[2], q) ) { is_oriented[2] = true; } else { l[2] = opposite_line(l[2]); } } if ( is_oriented[0] && is_oriented[1] && is_oriented[2] ) { for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } int i_no(-1); for (int i = 0; i < 3; i++) { if ( !is_oriented[i] ) { i_no = i; CGAL_assertion( is_oriented[(i+1)%3] && is_oriented[(i+2)%3] ); break; } } CGAL_assertion( i_no != -1 ); RT sqrt_d[3]; for (int i = 0; i < 3; i++) { RT d1 = CGAL::square(l[i].a()) + CGAL::square(l[i].b()); sqrt_d[i] = CGAL::sqrt(d1); } RT z[3]; for (int i = 0; i < 3; i++) { z[i] = l[(i+1)%3].a() * l[(i+2)%3].b() - l[(i+2)%3].a() * l[(i+1)%3].b(); } RT vz = z[0] * sqrt_d[0] + z[1] * sqrt_d[1] + z[2] * sqrt_d[2]; Sign s_minus_vz = CGAL::sign(vz); CGAL_assertion( s_minus_vz != ZERO ); if ( s_minus_vz == NEGATIVE ) { l[i_no] = opposite_line(l[i_no]); for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } // now we have to check if the other orientation of l[i_no] // corresponds to a CCW triangle as well. z[(i_no+1)%3] = -z[(i_no+1)%3]; z[(i_no+2)%3] = -z[(i_no+2)%3]; vz = z[0] * sqrt_d[0] + z[1] * sqrt_d[1] + z[2] * sqrt_d[2]; Sign s_minus_vz_2 = CGAL::sign(vz); CGAL_assertion( s_minus_vz_2 != ZERO ); if ( s_minus_vz_2 == NEGATIVE ) { // the other orientation does not correspond to a CCW triangle. for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } return; } // now compute the Voronoi vertex; for (int i = 0; i < 3; i++) { a[i] = l[i].a(); b[i] = l[i].b(); c[i] = l[i].c(); } RT x[3], y[3], w[3]; for (int i = 0; i < 3; i++) { x[i] = c[(i+1)%3] * b[(i+2)%3] - c[(i+2)%3] * b[(i+1)%3]; y[i] = -(c[(i+1)%3] * a[(i+2)%3] - c[(i+2)%3] * a[(i+1)%3]); w[i] = -(a[(i+1)%3] * b[(i+2)%3] - a[(i+2)%3] * b[(i+1)%3]); } RT vx = RT(0), vy = RT(0), vw = RT(0); for (int i = 0; i < 3; i++) { vx += x[i] * sqrt_d[i]; vy += y[i] * sqrt_d[i]; vw += w[i] * sqrt_d[i]; } Sign s_vw = CGAL::sign(vw); RT dist = a[(i_no+1)%3] * vx + b[(i_no+1)%3] * vy + c[(i_no+1)%3] * vw; Sign sgn_dist = Sign(s_vw * CGAL::sign(dist)); CGAL_assertion( sgn_dist != ZERO ); if ( sgn_dist == NEGATIVE ) { a[i_no] = -a[i_no]; b[i_no] = -b[i_no]; c[i_no] = -c[i_no]; } } void compute_sss(const Segment_2& p, const Segment_2& q, const Segment_2& r) { v_type = SSS; RT a[3], b[3], c[3]; RT cx[3], cy[3], cz[3], sqrt_D[3]; orient_lines(p, q, r, a, b, c); for (int i = 0; i < 3; i++) { cx[i] = c[(i+1)%3] * b[(i+2)%3] - c[(i+2)%3] * b[(i+1)%3]; cy[i] = -(c[(i+1)%3] * a[(i+2)%3] - c[(i+2)%3] * a[(i+1)%3]); cz[i] = -(a[(i+1)%3] * b[(i+2)%3] - a[(i+2)%3] * b[(i+1)%3]); RT d = CGAL::square(a[i]) + CGAL::square(b[i]); sqrt_D[i] = CGAL::sqrt(d); } ux = cx[0] * sqrt_D[0] + cx[1] * sqrt_D[1] + cx[2] * sqrt_D[2]; uy = cy[0] * sqrt_D[0] + cy[1] * sqrt_D[1] + cy[2] * sqrt_D[2]; uz = cz[0] * sqrt_D[0] + cz[1] * sqrt_D[1] + cz[2] * sqrt_D[2]; } //-------------------------------------------------------------------------- void compute_vertex(const Site_2& s1, const Site_2& s2, const Site_2& s3) { if ( s1.is_point() && s2.is_point() && s3.is_point() ) { compute_ppp(s1.point(), s2.point(), s3.point()); } else if ( s1.is_segment() && s2.is_point() && s3.is_point() ) { compute_vertex(s2, s3, s1); pps_idx = 1; } else if ( s1.is_point() && s2.is_segment() && s3.is_point() ) { compute_vertex(s3, s1, s2); pps_idx = 2; } else if ( s1.is_point() && s2.is_point() && s3.is_segment() ) { compute_pps(s1.point(), s2.point(), s3.segment()); pps_idx = 0; } else if ( s1.is_point() && s2.is_segment() && s3.is_segment() ) { compute_pss(s1.point(), s2.segment(), s3.segment()); } else if ( s1.is_segment() && s2.is_point() && s3.is_segment() ) { compute_vertex(s2, s3, s1); } else if ( s1.is_segment() && s2.is_segment() && s3.is_point() ) { compute_vertex(s3, s1, s2); } else { compute_sss(s1.segment(), s2.segment(), s3.segment()); } } //-------------------------------------------------------------------------- bool are_identical(const Point_2& p, const Point_2& q) const { return (p == q); } //-------------------------------------------------------------------------- bool is_endpoint_of(const Point_2& p, const Segment_2& s) const { return ( are_identical(p, s.source()) || are_identical(p, s.target()) ); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test when the fourth site is a point //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign check_easy_degeneracies(const Point_2& t, PPS_Type, bool& use_result) const { use_result = false; if ( ( p_.is_point() && are_identical(p_.point(),t) ) || ( q_.is_point() && are_identical(q_.point(),t) ) || ( r_.is_point() && are_identical(r_.point(),t) ) ) { use_result = true; return ZERO; } if ( ( p_.is_segment() && is_endpoint_of(t, p_.segment()) ) || ( q_.is_segment() && is_endpoint_of(t, q_.segment()) ) || ( r_.is_segment() && is_endpoint_of(t, r_.segment()) ) ) { use_result = true; return POSITIVE; } return ZERO; } Sign check_easy_degeneracies(const Point_2& t, PSS_Type, bool& use_result) const { return check_easy_degeneracies(t, PPS_Type(), use_result); } Sign check_easy_degeneracies(const Point_2& t, SSS_Type, bool& use_result) const { use_result = false; // ADD THE CASES WHERE t IS AN ENDPOINT OF ONE OF THE SEGMENTS return ZERO; } //-------------------------------------------------------------------------- Sign incircle(const Point_2& t, PPP_Type) const { Oriented_side os = side_of_oriented_circle(p_.point(), q_.point(), r_.point(), t); if ( os == ON_POSITIVE_SIDE ) { return NEGATIVE; } if ( os == ON_NEGATIVE_SIDE ) { return POSITIVE; } return ZERO; } //-------------------------------------------------------------------------- template Sign incircle(const Point_2& t, Type type) const { bool use_result(false); Sign s = check_easy_degeneracies(t, type, use_result); if ( use_result ) { return s; } FT r2 = squared_radius(); FT d2 = CGAL::square(x() - t.x()) + CGAL::square(y() - t.y()); return Sign( CGAL::compare(d2, r2) ); } //-------------------------------------------------------------------------- Sign incircle(const Point_2& t) const { if ( is_degenerate_Voronoi_circle() ) { return POSITIVE; } Sign s(ZERO); switch ( v_type ) { case PPP: s = incircle(t, PPP_Type()); break; case PPS: s = incircle(t, PPS_Type()); break; case PSS: s = incircle(t, PSS_Type()); break; case SSS: s = incircle(t, SSS_Type()); break; } return s; } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // the incircle test when the fourth site is a segment //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Oriented_side oriented_side(const Line_2& l, const Point_2& p) const { Line_2 l1(l.b() * hw(), -l.a() * hw(), l.a() * hy() - l.b() * hx()); if ( hw() < 0 ) { l1 = Line_2(-l1.a(), -l1.b(), -l1.c()); } return oriented_side_of_line(l1, p); } Sign incircle(const Line_2& l) const { FT r2 = squared_radius(); FT n2 = CGAL::square(l.a()) + CGAL::square(l.b()); FT d2 = CGAL::square(l.a() * x() + l.b() * y() + l.c()); return Sign( CGAL::compare(d2, r2 * n2) ); } //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- Sign incircle1(const Segment_2& t) const { if ( v_type == PPP || v_type == PPS ) { if ( p_.is_point() && q_.is_point() && is_endpoint_of(p_.point(), t) && is_endpoint_of(q_.point(), t) ) { return NEGATIVE; } if ( p_.is_point() && r_.is_point() && is_endpoint_of(p_.point(), t) && is_endpoint_of(r_.point(), t) ){ return NEGATIVE; } if ( q_.is_point() && r_.is_point() && is_endpoint_of(q_.point(), t) && is_endpoint_of(r_.point(), t) ){ return NEGATIVE; } } Sign d1, d2; if ( ( p_.is_point() && are_identical(p_.point(), t.source()) ) || ( q_.is_point() && are_identical(q_.point(), t.source()) ) || ( r_.is_point() && are_identical(r_.point(), t.source()) ) ) { d1 = ZERO; } else { d1 = incircle(t.source()); } if ( d1 == NEGATIVE ) { return NEGATIVE; } if ( ( p_.is_point() && are_identical(p_.point(), t.target()) ) || ( q_.is_point() && are_identical(q_.point(), t.target()) ) || ( r_.is_point() && are_identical(r_.point(), t.target()) ) ) { d2 = ZERO; } else { d2 = incircle(t.target()); } if ( d2 == NEGATIVE ) { return NEGATIVE; } Line_2 l = compute_supporting_line(t); Sign sl = incircle(l); // this is the old code if ( sl == POSITIVE ) { return sl; } Oriented_side os1 = oriented_side(l, t.source()); Oriented_side os2 = oriented_side(l, t.target()); if ( sl == ZERO ) { if ( (os1 == ON_POSITIVE_SIDE && os2 == ON_NEGATIVE_SIDE) || (os1 == ON_NEGATIVE_SIDE && os2 == ON_POSITIVE_SIDE) ) { return ZERO; } return POSITIVE; } return (os1 == os2) ? POSITIVE : NEGATIVE; } //-------------------------------------------------------------------------- Sign incircle(const Segment_2& t) const { if ( is_degenerate_Voronoi_circle() ) { // case 1: the new segment is not adjacent to the center of the // degenerate Voronoi circle if ( !are_identical( p_ref(), t.source() ) && !are_identical( p_ref(), t.target() ) ) { return POSITIVE; } if ( ( r_.is_point() && are_identical(p_ref(),r_.point()) ) || ( q_.is_point() && are_identical(p_ref(),q_.point()) ) || ( p_.is_point() && are_identical(p_ref(),p_.point()) ) ) { Point_2 pr; Segment_2 sp, sq; if ( p_.is_point() ) { CGAL_assertion( q_.is_segment() && r_.is_segment() ); pr = p_.point(); sp = q_.segment(); sq = r_.segment(); } else if ( q_.is_point() ) { CGAL_assertion( r_.is_segment() && p_.is_segment() ); pr = q_.point(); sp = r_.segment(); sq = p_.segment(); } else { CGAL_assertion( p_.is_segment() && q_.is_segment() ); pr = r_.point(); sp = p_.segment(); sq = q_.segment(); } Point_2 pq = sq.source(), pp = sp.source(), pt = t.source(); if ( are_identical(sp.source(),pr) ) { pp = sp.target(); } if ( are_identical(sq.source(),pr) ) { pq = sq.target(); } if ( are_identical( t.source(),pr) ) { pt = t.target(); } if ( CGAL::orientation(pr, pp, pt) == LEFT_TURN && CGAL::orientation(pr, pq, pt) == RIGHT_TURN ) { return NEGATIVE; } return ZERO; } } // if ( is_degenerate_Voronoi_circle() ) Sign s = incircle1(t); return s; } //-------------------------------------------------------------------------- // subpredicates for the incircle test //-------------------------------------------------------------------------- public: bool is_degenerate_Voronoi_circle() const { if ( v_type != PSS ) { return false; } if ( p_.is_point() ) { return ( is_endpoint_of(p_.point(), q_.segment()) && is_endpoint_of(p_.point(), r_.segment()) ); } else if ( q_.is_point() ) { return ( is_endpoint_of(q_.point(), p_.segment()) && is_endpoint_of(q_.point(), r_.segment()) ); } else { CGAL_assertion( r_.is_point() ); return ( is_endpoint_of(r_.point(), p_.segment()) && is_endpoint_of(r_.point(), q_.segment()) ); } } //-------------------------------------------------------------------------- private: //-------------------------------------------------------------------------- // the reference point (valid if v_type != SSS) //-------------------------------------------------------------------------- const Point_2& p_ref() const { CGAL_precondition ( v_type != SSS ); if ( v_type == PPS ) { if ( pps_idx == 0 ) { return p_.point(); } if ( pps_idx == 1 ) { return q_.point(); } return r_.point(); } if ( p_.is_point() ) { return p_.point(); } else if ( q_.is_point() ) { return q_.point(); } else { CGAL_assertion( r_.is_point() ); return r_.point(); } } public: //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- // access methods //-------------------------------------------------------------------------- //-------------------------------------------------------------------------- FT x() const { return FT(hx()) / FT(hw()); } FT y() const { return FT(hy()) / FT(hw()); } RT hx() const { return ux; } RT hy() const { return uy; } RT hw() const { return uz; } FT squared_radius() const { switch (v_type) { case PPP: case PPS: case PSS: { FT dx2 = CGAL::square(x() - p_ref().x()); FT dy2 = CGAL::square(y() - p_ref().y()); return dx2 + dy2; } break; case SSS: { Line_2 l = compute_supporting_line(p_.segment()); Homogeneous_point_2 q = compute_projection(l, point()); FT dx2 = CGAL::square(x() - q.x()); FT dy2 = CGAL::square(y() - q.y()); return dx2 + dy2; } break; default: return FT(0); } } Point_2 point() const { if ( is_degenerate_Voronoi_circle() ) { return p_ref(); } return Point_2(hx(), hy(), hw()); } Point_2 degenerate_point() const { CGAL_precondition( is_degenerate_Voronoi_circle() ); return p_ref(); } typename K::Circle_2 circle() const { typedef typename K::Circle_2 K_Circle_2; return K_Circle_2(point(), squared_radius()); } vertex_t type() const { return v_type; } public: Svd_voronoi_vertex_sqrt_field_H2(const Site_2& p, const Site_2& q, const Site_2& r) : p_(p), q_(q), r_(r) { compute_vertex(p, q, r); } //-------------------------------------------------------------------------- Sign incircle(const Site_2& t) const { if ( t.is_point() ) { return incircle(t.point()); } return incircle(t.segment()); } //-------------------------------------------------------------------------- Orientation orientation(const Line_2& l) const { Sign s_w = CGAL::sign( hw() ); Sign s1 = CGAL::sign(l.a() * hx() + l.b() * hy() + l.c() * hw()); Sign s = Sign(s1 * s_w); if ( s == ZERO ) { return COLLINEAR; } return ( s == POSITIVE ) ? LEFT_TURN : RIGHT_TURN; } Oriented_side oriented_side(const Line_2& l) const { Orientation o = orientation(l); if ( o == COLLINEAR ) { return ON_ORIENTED_BOUNDARY; } return ( o == LEFT_TURN ) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } //-------------------------------------------------------------------------- private: const Site_2& p_, q_, r_; vertex_t v_type; // index that indicates the refence point for the case PPS short pps_idx; RT ux, uy, uz; }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VORONOI_VEFTEX_SQRT_FIELD_H2_H ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_bounded_side_of_ccw_circle_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_bounded0000644000175000017500000000514711344301501031207 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_bounded_side_of_ccw_circle_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_BOUNDED_SIDE_OF_CCW_CIRCLE_C2_H #define CGAL_AG2_BOUNDED_SIDE_OF_CCW_CIRCLE_C2_H #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template< class K > class Sign_of_Voronoi_radius { public: typedef CGAL::Voronoi_radius Voronoi_radius; typedef typename K::FT FT; public: inline Sign operator()(const Voronoi_radius& vr, const Sqrt_field_tag&) const { FT r = vr.c1() + vr.c2() * CGAL::sqrt(vr.delta()); return CGAL::sign(r); } inline Sign operator()(const Voronoi_radius& vr, const Ring_tag&) const { // this is another way of doing this; the degree becomes 10 // instead of 5 in this case. // return sign_a_plus_b_x_sqrt_c(vr.c1(), vr.c2(), vr.delta()); bool is_first_root = CGAL::is_negative(vr.c2()); Sign s_beta = CGAL::sign(vr.b()); Sign s_gamma = CGAL::sign(vr.c()); // the existence test Sign sign_of_root; if ( is_first_root ) { sign_of_root = sign_of_first_root(s_beta, s_gamma); } else { sign_of_root = sign_of_second_root(s_beta, s_gamma); } return sign_of_root; } }; template< class K > class Bounded_side_of_CCW_circle { private: CGAL::Sign_of_Voronoi_radius test; public: typedef CGAL::Voronoi_radius Voronoi_radius; typedef typename K::FT FT; public: template inline Bounded_side operator()(const Voronoi_radius& vr, const Tag& tag) { return Bounded_side( opposite( test(vr, tag ) ) ); } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_BOUNDED_SIDE_OF_CCW_CIRCLE_C2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/kernel_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/kernel_ftC20000644000175000017500000005022711344301501031233 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/kernel_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann (Herve.Bronnimann@sophia.inria.fr) #ifndef CGAL_PREDICATES_KERNEL_FTC2_H #define CGAL_PREDICATES_KERNEL_FTC2_H #include #include #include CGAL_BEGIN_NAMESPACE template < class FT > inline bool parallelC2(const FT &l1a, const FT &l1b, const FT &l2a, const FT &l2b) { return sign_of_determinant2x2(l1a, l1b, l2a, l2b) == ZERO; } template < class FT > bool parallelC2(const FT &s1sx, const FT &s1sy, const FT &s1tx, const FT &s1ty, const FT &s2sx, const FT &s2sy, const FT &s2tx, const FT &s2ty) { return sign_of_determinant2x2(s1tx - s1sx, s1ty - s1sy, s2tx - s2sx, s2ty - s2sy) == ZERO; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool equal_lineC2(const FT &l1a, const FT &l1b, const FT &l1c, const FT &l2a, const FT &l2b, const FT &l2c) { if (sign_of_determinant2x2(l1a, l1b, l2a, l2b) != ZERO) return false; // Not parallel. CGAL::Sign s1a = CGAL_NTS sign(l1a); if (s1a != ZERO) return s1a == CGAL_NTS sign(l2a) && sign_of_determinant2x2(l1a, l1c, l2a, l2c) == ZERO; return CGAL_NTS sign(l1b) == CGAL_NTS sign(l2b) && sign_of_determinant2x2(l1b, l1c, l2b, l2c) == ZERO; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_xC2(const FT &px, const FT &la, const FT &lb, const FT &lc, const FT &ha, const FT &hb, const FT &hc) { // The abscissa of the intersection point is num/den. FT num = det2x2_by_formula( lb, lc, hb, hc); FT den = det2x2_by_formula( la, lb, ha, hb); Sign s = CGAL_NTS sign(den); CGAL_kernel_assertion( s != ZERO ); return Comparison_result( s * CGAL_NTS compare( px * den, num) ); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_xC2(const FT &la, const FT &lb, const FT &lc, const FT &h1a, const FT &h1b, const FT &h1c, const FT &h2a, const FT &h2b, const FT &h2c) { /* FT num1 = det2x2_by_formula( lb, lc, h1b, h1c); FT den1 = det2x2_by_formula( la, lb, h1a, h1b); FT num2 = det2x2_by_formula( lb, lc, h2b, h2c); FT den2 = det2x2_by_formula( la, lb, h2a, h2b); Sign s = Sign (CGAL_NTS sign(den1) * CGAL_NTS sign(den2)); CGAL_kernel_assertion( s != ZERO ); return Comparison_result( s * sign_of_determinant2x2(num1, num2, den1, den2)); */ FT num1 = det2x2_by_formula( la, lc, h1a, h1c); FT num2 = det2x2_by_formula( la, lc, h2a, h2c); FT num = det2x2_by_formula(h1a,h1c,h2a,h2c)*lb + det2x2_by_formula(num1,num2,h1b,h2b); FT den1 = det2x2_by_formula( la, lb, h1a, h1b); FT den2 = det2x2_by_formula( la, lb, h2a, h2b); return Comparison_result( CGAL_NTS sign(lb) * CGAL_NTS sign(num) * CGAL_NTS sign(den1) * CGAL_NTS sign(den2)); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_xC2(const FT &l1a, const FT &l1b, const FT &l1c, const FT &h1a, const FT &h1b, const FT &h1c, const FT &l2a, const FT &l2b, const FT &l2c, const FT &h2a, const FT &h2b, const FT &h2c) { FT num1 = det2x2_by_formula( l1b, l1c, h1b, h1c); FT den1 = det2x2_by_formula( l1a, l1b, h1a, h1b); FT num2 = det2x2_by_formula( l2b, l2c, h2b, h2c); FT den2 = det2x2_by_formula( l2a, l2b, h2a, h2b); Sign s = Sign (CGAL_NTS sign(den1) * CGAL_NTS sign(den2)); CGAL_kernel_assertion( s != ZERO ); return Comparison_result( s * sign_of_determinant2x2(num1, num2, den1, den2)); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_y_at_xC2(const FT &px, const FT &py, const FT &la, const FT &lb, const FT &lc) { Sign s = CGAL_NTS sign(lb); CGAL_kernel_assertion( s != ZERO ); return Comparison_result (s * CGAL_NTS sign(la*px + lb*py + lc)); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_y_at_xC2(const FT &px, const FT &l1a, const FT &l1b, const FT &l1c, const FT &l2a, const FT &l2b, const FT &l2c) { Sign s = Sign (CGAL_NTS sign(l1b) * CGAL_NTS sign(l2b)); CGAL_kernel_assertion( s != ZERO ); return Comparison_result ( s * sign_of_determinant2x2(l2a*px+l2c, l2b, l1a*px+l1c, l1b)); } template < class FT > CGAL_KERNEL_LARGE_INLINE Comparison_result compare_y_at_xC2(const FT &l1a, const FT &l1b, const FT &l1c, const FT &l2a, const FT &l2b, const FT &l2c, const FT &ha, const FT &hb, const FT &hc) { Sign s = Sign (sign_of_determinant2x2(l1a, l1b, l2a, l2b) * CGAL_NTS sign(hb)); CGAL_kernel_assertion( s != ZERO ); return Comparison_result( s * sign_of_determinant3x3(l1a, l1b, l1c, l2a, l2b, l2c, ha, hb, hc)); } template < class FT > CGAL_KERNEL_LARGE_INLINE Comparison_result compare_y_at_xC2(const FT &l1a, const FT &l1b, const FT &l1c, const FT &l2a, const FT &l2b, const FT &l2c, const FT &h1a, const FT &h1b, const FT &h1c, const FT &h2a, const FT &h2b, const FT &h2c) { // The abscissa of the intersection point is num/den. FT num = det2x2_by_formula( l1b, l1c, l2b, l2c); FT den = det2x2_by_formula( l1a, l1b, l2a, l2b); Sign s = Sign (CGAL_NTS sign(h1b) * CGAL_NTS sign(h2b) * CGAL_NTS sign(den)); CGAL_kernel_assertion( s != ZERO ); return Comparison_result ( s * sign_of_determinant2x2(h2a*num+h2c*den, h2b, h1a*num+h1c*den, h1b)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_LARGE_INLINE Comparison_result compare_y_at_xC2(const FT &px, const FT &py, const FT &ssx, const FT &ssy, const FT &stx, const FT &sty) { // compares the y-coordinates of p and the vertical projection of p on s. // Precondition : p is in the x-range of s. CGAL_kernel_precondition(px >= min(ssx, stx) && px <= max(ssx, stx)); if (ssx < stx) return (Comparison_result) orientationC2(px, py, ssx, ssy, stx, sty); else if (ssx > stx) return (Comparison_result) orientationC2(px, py, stx, sty, ssx, ssy); else { if (py < min(sty, ssy)) return SMALLER; if (py > max(sty, ssy)) return LARGER; return EQUAL; } } template < class FT > CGAL_KERNEL_LARGE_INLINE Comparison_result compare_y_at_x_segment_C2(const FT &px, const FT &s1sx, const FT &s1sy, const FT &s1tx, const FT &s1ty, const FT &s2sx, const FT &s2sy, const FT &s2tx, const FT &s2ty) { // compares the y-coordinates of the vertical projections of p on s1 and s2 // Precondition : p is in the x-range of s1 and s2. // - if one or two segments are vertical : // - if the segments intersect, return EQUAL // - if not, return the obvious SMALLER/LARGER. CGAL_kernel_precondition(px >= min(s1sx, s1tx) && px <= max(s1sx, s1tx)); CGAL_kernel_precondition(px >= min(s2sx, s2tx) && px <= max(s2sx, s2tx)); if (s1sx != s1tx && s2sx != s2tx) { FT s1stx = s1sx-s1tx; FT s2stx = s2sx-s2tx; return Comparison_result( CGAL_NTS compare(s1sx, s1tx) * CGAL_NTS compare(s2sx, s2tx) * CGAL_NTS compare(-(s1sx-px)*(s1sy-s1ty)*s2stx, (s2sy-s1sy)*s2stx*s1stx -(s2sx-px)*(s2sy-s2ty)*s1stx )); } else { if (s1sx == s1tx) { // s1 is vertical Comparison_result c1, c2; c1 = compare_y_at_xC2(px, s1sy, s2sx, s2sy, s2tx, s2ty); c2 = compare_y_at_xC2(px, s1ty, s2sx, s2sy, s2tx, s2ty); if (c1 == c2) return c1; return EQUAL; } // s2 is vertical Comparison_result c3, c4; c3 = compare_y_at_xC2(px, s2sy, s1sx, s1sy, s1tx, s1ty); c4 = compare_y_at_xC2(px, s2ty, s1sx, s1sy, s1tx, s1ty); if (c3 == c4) return opposite(c3); return EQUAL; } } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool equal_directionC2(const FT &dx1, const FT &dy1, const FT &dx2, const FT &dy2) { return CGAL_NTS sign(dx1) == CGAL_NTS sign(dx2) && CGAL_NTS sign(dy1) == CGAL_NTS sign(dy2) && sign_of_determinant2x2(dx1, dy1, dx2, dy2) == ZERO; } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_angle_with_x_axisC2(const FT &dx1, const FT &dy1, const FT &dx2, const FT &dy2) { // angles are in [-pi,pi], and the angle between Ox and d1 is compared // with the angle between Ox and d2 int quadrant_1 = (dx1 >= FT(0)) ? ((dy1 >= FT(0))?1:4) : ((dy1 >= FT(0))?2:3); int quadrant_2 = (dx2 >= FT(0)) ? ((dy2 >= FT(0))?1:4) : ((dy2 >= FT(0))?2:3); // We can't use CGAL_NTS compare(quadrant_1,quadrant_2) because in case // of tie, we need additional computation if (quadrant_1 > quadrant_2) return LARGER; else if (quadrant_1 < quadrant_2) return SMALLER; return Comparison_result(-sign_of_determinant2x2(dx1,dy1,dx2,dy2)); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_slopesC2(const FT &l1a, const FT &l1b, const FT &l2a, const FT &l2b) { if (l1a == FT(0)) // l1 is horizontal return l2b == FT(0) ? SMALLER : Comparison_result(CGAL_NTS sign(l2a*l2b)); if (l2a == FT(0)) // l2 is horizontal return l1b == FT(0) ? LARGER : Comparison_result(-CGAL_NTS sign(l1a*l1b)); if (l1b == FT(0)) return l2b == FT(0) ? EQUAL : LARGER; if (l2b == FT(0)) return SMALLER; int l1_sign = CGAL_NTS sign(-l1a * l1b); int l2_sign = CGAL_NTS sign(-l2a * l2b); if (l1_sign < l2_sign) return SMALLER; if (l1_sign > l2_sign) return LARGER; if (l1_sign > 0) return CGAL_NTS compare ( CGAL_NTS abs(l1a * l2b), CGAL_NTS abs(l2a * l1b) ); return CGAL_NTS compare ( CGAL_NTS abs(l2a * l1b), CGAL_NTS abs(l1a * l2b) ); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_slopesC2(const FT &s1_src_x, const FT &s1_src_y, const FT &s1_tgt_x, const FT &s1_tgt_y, const FT &s2_src_x, const FT &s2_src_y, const FT &s2_tgt_x, const FT &s2_tgt_y) { Comparison_result cmp_y1 = CGAL_NTS compare(s1_src_y, s1_tgt_y); if (cmp_y1 == EQUAL) // horizontal { Comparison_result cmp_x2 = CGAL_NTS compare(s2_src_x, s2_tgt_x); if (cmp_x2 == EQUAL) return SMALLER; return Comparison_result (- CGAL_NTS sign((s2_src_y - s2_tgt_y) * (s2_src_x - s2_tgt_x)) ); } Comparison_result cmp_y2 = CGAL_NTS compare(s2_src_y, s2_tgt_y); if (cmp_y2 == EQUAL) { Comparison_result cmp_x1 = CGAL_NTS compare(s1_src_x, s1_tgt_x); if (cmp_x1 == EQUAL) return LARGER; return Comparison_result ( CGAL_NTS sign((s1_src_y - s1_tgt_y) * (s1_src_x - s1_tgt_x)) ); } Comparison_result cmp_x1 = CGAL_NTS compare(s1_src_x, s1_tgt_x); Comparison_result cmp_x2 = CGAL_NTS compare(s2_src_x, s2_tgt_x); if (cmp_x1 == EQUAL) return cmp_x2 == EQUAL ? EQUAL : LARGER; if (cmp_x2 == EQUAL) return SMALLER; FT s1_xdiff = s1_src_x - s1_tgt_x; FT s1_ydiff = s1_src_y - s1_tgt_y; FT s2_xdiff = s2_src_x - s2_tgt_x; FT s2_ydiff = s2_src_y - s2_tgt_y; Sign s1_sign = CGAL_NTS sign(s1_ydiff * s1_xdiff); Sign s2_sign = CGAL_NTS sign(s2_ydiff * s2_xdiff); if (s1_sign < s2_sign) return SMALLER; if (s1_sign > s2_sign) return LARGER; if (s1_sign > 0) return CGAL_NTS compare( CGAL_NTS abs(s1_ydiff * s2_xdiff), CGAL_NTS abs(s2_ydiff * s1_xdiff)); return CGAL_NTS compare( CGAL_NTS abs(s2_ydiff * s1_xdiff), CGAL_NTS abs(s1_ydiff * s2_xdiff)); } template < class FT > inline Comparison_result compare_deltax_deltayC2(const FT &px, const FT &qx, const FT &ry, const FT &sy) { return CGAL_NTS compare(CGAL_NTS abs(px-qx), CGAL_NTS abs(ry-sy)); } template < class FT > /*CGAL_NO_FILTER*/ inline Comparison_result compare_lexicographically_xyC2(const FT &px, const FT &py, const FT &qx, const FT &qy) { Comparison_result c = CGAL_NTS compare(px,qx); return (c != EQUAL) ? c : CGAL_NTS compare(py,qy); } template < class FT > inline Orientation orientationC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { return Orientation (sign_of_determinant2x2(qx-px, qy-py, rx-px, ry-py)); } template < class FT > inline Angle angleC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { return (Angle) CGAL_NTS sign ((px-qx)*(rx-qx)+(py-qy)*(ry-qy)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool collinear_are_ordered_along_lineC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { if (px < qx) return !(rx < qx); if (qx < px) return !(qx < rx); if (py < qy) return !(ry < qy); if (qy < py) return !(qy < ry); return true; // p==q } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool collinear_are_strictly_ordered_along_lineC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { if (px < qx) return (qx < rx); if (qx < px) return (rx < qx); if (py < qy) return (qy < ry); if (qy < py) return (ry < qy); return false; } template < class FT > CGAL_KERNEL_LARGE_INLINE Oriented_side side_of_oriented_circleC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, const FT &tx, const FT &ty) { // Oriented_side( // sign_of_determinant4x4(px, py, px*px + py*py, 1, // qx, qy, qx*qx + qy*qy, 1, // rx, ry, rx*rx + ry*ry, 1, // tx, ty, tx*tx + ty*ty, 1)); // We first translate so that p is the new origin. FT qpx = qx-px; FT qpy = qy-py; FT rpx = rx-px; FT rpy = ry-py; FT tpx = tx-px; FT tpy = ty-py; // The usual 3x3 formula can be simplified a little bit to a 2x2. // - sign_of_determinant3x3(qpx, qpy, square(qpx) + square(qpy), // rpx, rpy, square(rpx) + square(rpy), // tpx, tpy, square(tpx) + square(tpy))); return Oriented_side(sign_of_determinant2x2( qpx*tpy - qpy*tpx, tpx*(tx-qx) + tpy*(ty-qy), qpx*rpy - qpy*rpx, rpx*(rx-qx) + rpy*(ry-qy))); } template < class FT > CGAL_KERNEL_LARGE_INLINE Bounded_side side_of_bounded_circleC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, const FT &tx, const FT &ty) { return Bounded_side( side_of_oriented_circleC2(px,py,qx,qy,rx,ry,tx,ty) * orientationC2(px,py,qx,qy,rx,ry) ); } template < class FT > CGAL_KERNEL_LARGE_INLINE Bounded_side side_of_bounded_circleC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &tx, const FT &ty) { // Returns whether T lies inside or outside the circle which diameter is PQ. return Bounded_side( CGAL_NTS compare((tx-px)*(qx-tx), (ty-py)*(ty-qy)) ); } template < class FT > inline Comparison_result cmp_dist_to_pointC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { return CGAL_NTS compare(squared_distanceC2(px,py,qx,qy), squared_distanceC2(px,py,rx,ry)); } template < class FT > /*CGAL_NO_FILTER*/ inline bool has_larger_dist_to_pointC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { return cmp_dist_to_pointC2(px,py,qx,qy,rx,ry) == LARGER; } template < class FT > /*CGAL_NO_FILTER*/ inline bool has_smaller_dist_to_pointC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { return cmp_dist_to_pointC2(px,py,qx,qy,rx,ry) == SMALLER; } template < class FT > inline Comparison_result cmp_signed_dist_to_directionC2(const FT &la, const FT &lb, const FT &px, const FT &py, const FT &qx, const FT &qy) { return CGAL_NTS compare(scaled_distance_to_directionC2(la,lb,px,py), scaled_distance_to_directionC2(la,lb,qx,qy)); } template < class FT > /*CGAL_NO_FILTER*/ inline bool has_larger_signed_dist_to_directionC2(const FT &la, const FT &lb, const FT &px, const FT &py, const FT &qx, const FT &qy) { return cmp_signed_dist_to_directionC2(la,lb,px,py,qx,qy) == LARGER; } template < class FT > /*CGAL_NO_FILTER*/ inline bool has_smaller_signed_dist_to_directionC2(const FT &la, const FT &lb, const FT &px, const FT &py, const FT &qx, const FT &qy) { return cmp_signed_dist_to_directionC2(la,lb,px,py,qx,qy) == SMALLER; } template inline Comparison_result cmp_signed_dist_to_lineC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, const FT &sx, const FT &sy) { return CGAL_NTS compare(scaled_distance_to_lineC2(px,py,qx,qy,rx,ry), scaled_distance_to_lineC2(px,py,qx,qy,sx,sy)); } template /*CGAL_NO_FILTER*/ inline bool has_larger_signed_dist_to_lineC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, const FT &sx, const FT &sy) { return cmp_signed_dist_to_lineC2(px,py,qx,qy,rx,ry,sx,sy) == LARGER; } template /*CGAL_NO_FILTER*/ inline bool has_smaller_signed_dist_to_lineC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, const FT &sx, const FT &sy) { return cmp_signed_dist_to_lineC2(px,py,qx,qy,rx,ry,sx,sy) == SMALLER; } template inline Oriented_side side_of_oriented_lineC2(const FT &a, const FT &b, const FT &c, const FT &x, const FT &y) { return Oriented_side(CGAL_NTS sign(a*x+b*y+c)); } CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #include #endif #endif // CGAL_PREDICATES_KERNEL_FTC2_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_rtH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_tri0000644000175000017500000000703311344301501031351 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Regular_triangulation_rtH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // Mariette Yvinec #ifndef CGAL_REGULAR_TRIANGULATION_RTH2_H #define CGAL_REGULAR_TRIANGULATION_RTH2_H // This file contains the low level homogeneous predicates // used by the 2D regular triangulation. CGAL_BEGIN_NAMESPACE template Oriented_side power_testH2( const RT &phx, const RT &phy, const RT &phw, const RT &pwt, const RT &qhx, const RT &qhy, const RT &qhw, const RT &qwt, const RT &rhx, const RT &rhy, const RT &rhw, const RT &rwt, const RT &thx, const RT &thy, const RT &thw, const RT &twt) { RT dphx = phx*phw; RT dphy = phy*phw; RT dphw = CGAL_NTS square(phw); RT dpz = CGAL_NTS square(phx) + CGAL_NTS square(phy) - pwt*dphw; RT dqhx = qhx*qhw; RT dqhy = qhy*qhw; RT dqhw = CGAL_NTS square(qhw); RT dqz = CGAL_NTS square(qhx) + CGAL_NTS square(qhy) - qwt*dqhw; RT drhx = rhx*rhw; RT drhy = rhy*rhw; RT drhw = CGAL_NTS square(rhw); RT drz = CGAL_NTS square(rhx) + CGAL_NTS square(rhy) - rwt*drhw; RT dthx = thx*thw; RT dthy = thy*thw; RT dthw = CGAL_NTS square(thw); RT dtz = CGAL_NTS square(thx) + CGAL_NTS square(thy) - twt*dthw; return Oriented_side(sign_of_determinant4x4(dphx, dphy, dpz, dphw, dqhx, dqhy, dqz, dqhw, drhx, drhy, drz, drhw, dthx, dthy, dtz, dthw)); } template Oriented_side power_testH2( const RT &phx, const RT &phy, const RT &phw, const RT &pwt, const RT &qhx, const RT &qhy, const RT &qhw, const RT &qwt, const RT &thx, const RT &thy, const RT &thw, const RT &twt) { // Test if we can project on the (x) axis. If not, then on the // (y) axis RT pa, qa, ta; if (phx * qhw != qhx * phw ) { pa = phx*phw; qa = qhx*qhw; ta = thx*thw; } else { pa = phy*phw; qa = qhy*qhw; ta = thy*thw; } RT dphw = CGAL_NTS square(phw); RT dpz = CGAL_NTS square(phx) + CGAL_NTS square(phy) - pwt*dphw; RT dqhw = CGAL_NTS square(qhw); RT dqz = CGAL_NTS square(qhx) + CGAL_NTS square(qhy) - qwt*dqhw; RT dthw = CGAL_NTS square(thw); RT dtz = CGAL_NTS square(thx) + CGAL_NTS square(thy) - twt*dthw; return Oriented_side(CGAL_NTS compare(pa, qa) * sign_of_determinant3x3(pa, dpz, dphw, qa, dqz, dqhw, ta, dtz, dthw)); } CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H #include #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H #endif #endif // CGAL_REGULAR_TRIANGULATION_RTH2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_arrangement_type_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_arrange0000644000175000017500000004622711344301501031335 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_arrangement_type_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_ARRANGEMENT_TYPE_C2_H #define CGAL_SVD_ARRANGEMENT_TYPE_C2_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { struct Svd_arrangement_enum { enum Arrangement_type { DISJOINT = 0, // obvious TOUCH_1, // (p1,p2) and q, and p1 and q are identical TOUCH_2, // (p1,p2) and q, and p2 and q are identical TOUCH_11, // (p1,p2), (q1,q2), and p1, q1 are identical TOUCH_12, // (p1,p2), (q1,q2), and p1, q2 are identical TOUCH_21, // (p1,p2), (q1,q2), and p2, q1 are identical TOUCH_22, // (p1,p2), (q1,q2), and p2, q2 are identical CROSSING, // two segments intersecting at interior points IDENTICAL, // either two segments or two points that are identical INTERIOR_1, // (p1,p2) and (q1,q2), and q1, q2 are interior // points of (p1,p2) INTERIOR_2, // (p1,p2) and (q1,q2), and p1, p2 are interior // points of (q1,q2) INTERIOR, // (p1,p2) and q, and q is an interior point of (p1,p2) TOUCH_11_INTERIOR_1, // (p1,p2) and (q1,q2), and p1, q1 are // identical and q2 is an interior point of (p1,p2) TOUCH_11_INTERIOR_2, // (p1,p2) and (q1,q2), and p1, q1 are // identical and p2 is an interior point of // (q1,q2) TOUCH_12_INTERIOR_1, // (p1,p2) and (q1,q2), and p1, q2 are // identical and q1 is an interior point of (p1,p2) TOUCH_12_INTERIOR_2, // (p1,p2) and (q1,q2), and p1, q2 are // identical and p2 is an interior point of (q1,q2) TOUCH_21_INTERIOR_1, // (p1,p2) and (q1,q2), and p2, q1 are // identical and q2 is an interior point of (p1,p2) TOUCH_21_INTERIOR_2, // (p1,p2) and (q1,q2), and p2, q1 are // identical and p1 is an interior point of (q1,q2) TOUCH_22_INTERIOR_1, // (p1,p2) and (q1,q2), and p2, q2 are // identical and q1 is an interior point of (p1,p2) TOUCH_22_INTERIOR_2, // (p1,p2) and (q1,q2), and p2, q2 are // identical and p1 is an interior point of (q1,q2) OVERLAPPING_11, // (p1,p2) and (q1,q2), and (p1,q1) is the overlap OVERLAPPING_12, // (p1,p2) and (q1,q2), and (p1,q1) is the overlap OVERLAPPING_21, // (p1,p2) and (q1,q2), and (p2,q1) is the overlap OVERLAPPING_22, // (p1,p2) and (q1,q2), and (p2,q2) is the overlap TOUCH_INTERIOR_12, // (p1,p2) and (q1,q2) and p1 is an interior // point of (q1,q2) TOUCH_INTERIOR_22, // (p1,p2) and (q1,q2) and p2 is an interior // point of (q1,q2) TOUCH_INTERIOR_11, // (p1,p2) and (q1,q2) and q1 is an interior // point of (p1,p2) TOUCH_INTERIOR_21 // (p1,p2) and (q1,q2) and q2 is an interior // point of (p1,p2) }; static Arrangement_type opposite(const Arrangement_type& at) { // this returns the result if we swap the order of the arguments... if ( at == TOUCH_12 ) { return TOUCH_21; } else if ( at == TOUCH_21 ) { return TOUCH_12; } else if ( at == INTERIOR_1 ) { return INTERIOR_2; } else if ( at == INTERIOR_2 ) { return INTERIOR_1; } else if ( at == TOUCH_11_INTERIOR_1 ) { return TOUCH_11_INTERIOR_2; } else if ( at == TOUCH_11_INTERIOR_2 ) { return TOUCH_11_INTERIOR_1; } else if ( at == TOUCH_12_INTERIOR_1 ) { return TOUCH_21_INTERIOR_2; } else if ( at == TOUCH_12_INTERIOR_2 ) { return TOUCH_21_INTERIOR_1; } else if ( at == TOUCH_21_INTERIOR_1 ) { return TOUCH_12_INTERIOR_2; } else if ( at == TOUCH_21_INTERIOR_2 ) { return TOUCH_12_INTERIOR_1; } else if ( at == TOUCH_22_INTERIOR_1 ) { return TOUCH_22_INTERIOR_2; } else if ( at == TOUCH_22_INTERIOR_2 ) { return TOUCH_22_INTERIOR_1; } else if ( at == OVERLAPPING_12 ) { return OVERLAPPING_21; } else if ( at == OVERLAPPING_21 ) { return OVERLAPPING_12; } else if ( at == TOUCH_INTERIOR_12 ) { return TOUCH_INTERIOR_11; } else if ( at == TOUCH_INTERIOR_22 ) { return TOUCH_INTERIOR_21; } else if ( at == TOUCH_INTERIOR_11 ) { return TOUCH_INTERIOR_12; } else if ( at == TOUCH_INTERIOR_21 ) { return TOUCH_INTERIOR_22; } return at; } }; std::ostream& operator<<(std::ostream& os, const Svd_arrangement_enum::Arrangement_type& at) { typedef Svd_arrangement_enum AT; if ( at == AT::DISJOINT ) { os << "DISJOINT"; } else if ( at == AT::TOUCH_1 ) { os << "TOUCH_1"; } else if ( at == AT::TOUCH_2 ) { os << "TOUCH_2"; } else if ( at == AT::TOUCH_11 ) { os << "TOUCH_11"; } else if ( at == AT::TOUCH_12 ) { os << "TOUCH_12"; } else if ( at == AT::TOUCH_21 ) { os << "TOUCH_21"; } else if ( at == AT::TOUCH_22 ) { os << "TOUCH_22"; } else if ( at == AT::CROSSING ) { os << "CROSSING"; } else if ( at == AT::IDENTICAL) { os << "IDENTICAL"; } else if ( at == AT::INTERIOR_1 ) { os << "INTERIOR_1"; } else if ( at == AT::INTERIOR_2 ) { os << "INTERIOR_2"; } else if ( at == AT::INTERIOR ) { os << "INTERIOR"; } else if ( at == AT::TOUCH_11_INTERIOR_1 ) { os << "TOUCH_11_INTERIOR_1"; } else if ( at == AT::TOUCH_11_INTERIOR_2 ) { os << "TOUCH_11_INTERIOR_2"; } else if ( at == AT::TOUCH_12_INTERIOR_1 ) { os << "TOUCH_12_INTERIOR_1"; } else if ( at == AT::TOUCH_12_INTERIOR_2 ) { os << "TOUCH_12_INTERIOR_2"; } else if ( at == AT::TOUCH_21_INTERIOR_1 ) { os << "TOUCH_21_INTERIOR_1"; } else if ( at == AT::TOUCH_21_INTERIOR_2 ) { os << "TOUCH_21_INTERIOR_2"; } else if ( at == AT::TOUCH_22_INTERIOR_1 ) { os << "TOUCH_22_INTERIOR_1"; } else if ( at == AT::TOUCH_22_INTERIOR_2 ) { os << "TOUCH_22_INTERIOR_2"; } else if ( at == AT::OVERLAPPING_11 ) { os << "OVERLAPPING_11"; } else if ( at == AT::OVERLAPPING_12 ) { os << "OVERLAPPING_12"; } else if ( at == AT::OVERLAPPING_21 ) { os << "OVERLAPPING_21"; } else if ( at == AT::OVERLAPPING_22 ) { os << "OVERLAPPING_22"; } else if ( at == AT::TOUCH_INTERIOR_11 ) { os << "TOUCH_INTERIOR_11"; } else if ( at == AT::TOUCH_INTERIOR_12 ) { os << "TOUCH_INTERIOR_12"; } else if ( at == AT::TOUCH_INTERIOR_21 ) { os << "TOUCH_INTERIOR_21"; } else if ( at == AT::TOUCH_INTERIOR_22 ) { os << "TOUCH_INTERIOR_22"; } else { CGAL_assertion( false ); } return os; } } // namespace CGALi //--------------------------------------------------------------------- template typename CGALi::Svd_arrangement_enum::Arrangement_type svd_arrangement_type_ftC2(const RT& x1, const RT& y1, const RT& x2, const RT& y2, const RT& x3, const RT& y3, const RT& x4, const RT& y4) { typedef CGALi::Svd_arrangement_enum Enum; RT delta = -det2x2_by_formula(x2 - x1, x4 - x3, y2 - y1, y4 - y3); Sign s = CGAL::sign( delta ); if ( s != CGAL::ZERO ) { return svd_arrangement_type_non_parallel_C2(x1, y1, x2, y2, x3, y3, x4, y4, delta); } else { return svd_arrangement_type_parallel_C2(x1, y1, x2, y2, x3, y3, x4, y4); } } //--------------------------------------------------------------------- template typename CGALi::Svd_arrangement_enum::Arrangement_type svd_arrangement_type_non_parallel_C2(const RT& x1, const RT& y1, const RT& x2, const RT& y2, const RT& x3, const RT& y3, const RT& x4, const RT& y4, const RT& D) { typedef CGALi::Svd_arrangement_enum Enum; RT Dt = -det2x2_by_formula(x3 - x1, x4 - x3, y3 - y1, y4 - y3); RT Ds = det2x2_by_formula(x2 - x1, x3 - x1, y2 - y1, y3 - y1); Sign s_D = CGAL::sign( D ); Sign s_Dt = CGAL::sign( Dt ); Sign s_Ds = CGAL::sign( Ds ); Sign s_tdiff = CGAL::sign(Dt - D); Sign s_sdiff = CGAL::sign(Ds - D); Sign s_t = Sign(s_Dt * s_D); Sign s_s = Sign(s_Ds * s_D); Sign s_t_minus_1 = Sign(s_tdiff * s_D); Sign s_s_minus_1 = Sign(s_sdiff * s_D); if ( s_t == CGAL::NEGATIVE || s_t_minus_1 == CGAL::POSITIVE || s_s == CGAL::NEGATIVE || s_s_minus_1 == CGAL::POSITIVE ) { // t < 0 or t > 1 or s < 0 or s > 1 return Enum::DISJOINT; } int it(0), is(0); if ( s_t == CGAL::ZERO ) { it = 0; } else if ( s_t_minus_1 == CGAL::ZERO ) { it = 1; } else { it = 2; } if ( s_s == CGAL::ZERO ) { is = 0; } else if ( s_s_minus_1 == CGAL::ZERO ) { is = 1; } else { is = 2; } if ( it == 0 ) { if ( is == 0 ) { return Enum::TOUCH_11; } else if ( is == 1 ) { return Enum::TOUCH_12; } else { return Enum::TOUCH_INTERIOR_12; } } else if ( it == 1 ) { if ( is == 0 ) { return Enum::TOUCH_21; } else if ( is == 1 ) { return Enum::TOUCH_22; } else { return Enum::TOUCH_INTERIOR_22; } } else { if ( is == 0 ) { return Enum::TOUCH_INTERIOR_11; } else if ( is == 1 ) { return Enum::TOUCH_INTERIOR_21; } else { return Enum::CROSSING; } } } //--------------------------------------------------------------------- template typename CGALi::Svd_arrangement_enum::Arrangement_type svd_arrangement_type_parallel_C2(const RT& x1, const RT& y1, const RT& x2, const RT& y2, const RT& x3, const RT& y3, const RT& x4, const RT& y4) { typedef CGALi::Svd_arrangement_enum Enum; RT D1 = det2x2_by_formula(x2 - x1, x3 - x1, y2 - y1, y3 - y1); if ( CGAL::sign( D1 ) != CGAL::ZERO ) { return Enum::DISJOINT; } RT Dt3, Dt4, Dt; if ( CGAL::compare(x2, x1) != CGAL::EQUAL ) { Dt = x2 - x1; Dt3 = x3 - x1; Dt4 = x4 - x1; } else { Dt = y2 - y1; Dt3 = y3 - y1; Dt4 = y4 - y1; } Sign s_Dt = CGAL::sign( Dt ); Sign s_Dt3 = CGAL::sign( Dt3 ); Sign s_Dt4 = CGAL::sign( Dt4 ); Sign s_t3 = Sign(s_Dt3 * s_Dt); Sign s_t4 = Sign(s_Dt4 * s_Dt); Sign s_t3diff = CGAL::sign( Dt3 - Dt ); Sign s_t4diff = CGAL::sign( Dt4 - Dt ); Sign s_t3_minus_1 = Sign(s_t3diff * s_Dt); Sign s_t4_minus_1 = Sign(s_t4diff * s_Dt); int it3(0), it4(0); if ( s_t3 == CGAL::ZERO ) { // t3 == 0 it3 = 0; } else if ( s_t3_minus_1 == CGAL::ZERO ) { // t3 == 1 it3 = 1; } else if ( s_t3 == CGAL::POSITIVE && s_t3_minus_1 == CGAL::NEGATIVE ) { // 0 < t3 < 1 it3 = 2; } else if ( s_t3 == CGAL::NEGATIVE ) { // t3 < 0 it3 = -1; } else { // t3 > 1 it3 = 3; } if ( s_t4 == CGAL::ZERO ) { // t4 == 0 it4 = 0; } else if ( s_t4_minus_1 == CGAL::ZERO ) { // t4 == 1 it4 = 1; } else if ( s_t4 == CGAL::POSITIVE && s_t4_minus_1 == CGAL::NEGATIVE ) { // 0 < t4 < 1 it4 = 2; } else if ( s_t4 == CGAL::NEGATIVE ) { // t4 < 0 it4 = -1; } else { // t4 > 1 it4 = 3; } // decode now if ( it3 == -1 ) { if ( it4 == -1 ) { return Enum::DISJOINT; } else if ( it4 == 0 ) { return Enum::TOUCH_12; } else if ( it4 == 1 ) { return Enum::TOUCH_22_INTERIOR_2; } else if ( it4 == 2 ) { return Enum::OVERLAPPING_12; } else { // it4 == 3 return Enum::INTERIOR_2; } } else if ( it3 == 0 ) { CGAL_assertion( it4 != 0 ); if ( it4 == -1 ) { return Enum::TOUCH_11; } else if ( it4 == 1 ) { return Enum::IDENTICAL; } else if ( it4 == 2 ) { return Enum::TOUCH_11_INTERIOR_1; } else { // it4 == 3 return Enum::TOUCH_11_INTERIOR_2; } } else if ( it3 == 1 ) { CGAL_assertion( it4 != 1 ); if ( it4 == -1 ) { return Enum::TOUCH_21_INTERIOR_2; } else if ( it4 == 0 ) { return Enum::IDENTICAL; } else if ( it4 == 2 ) { return Enum::TOUCH_21_INTERIOR_1; } else { // it4 == 3 return Enum::TOUCH_21; } } else if ( it3 == 2 ) { if ( it4 == -1 ) { return Enum::OVERLAPPING_11; } else if ( it4 == 0 ) { return Enum::TOUCH_12_INTERIOR_1; } else if ( it4 == 1 ) { return Enum::TOUCH_22_INTERIOR_1; } else if ( it4 == 2 ) { return Enum::INTERIOR_1; } else { // it4 == 3 return Enum::OVERLAPPING_21; } } else { // it3 == 3 ( t3 > 1 ) if ( it4 == -1 ) { return Enum::INTERIOR_2; } else if ( it4 == 0 ) { return Enum::TOUCH_12_INTERIOR_2; } else if ( it4 == 1 ) { return Enum::TOUCH_22; } else if ( it4 == 2 ) { return Enum::OVERLAPPING_22; } else { // it4 == 3 return Enum::DISJOINT; } } } //--------------------------------------------------------------------- //--------------------------------------------------------------------- template class Svd_arrangement_type_C2 : public Svd_basic_predicates_C2, public CGALi::Svd_arrangement_enum { public: typedef Arrangement_type result_type; private: typedef Svd_basic_predicates_C2 Base; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Site_2 Site_2; typedef typename Base::Line_2 Line_2; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename K::Orientation_2 Orientation_2; typedef Svd_are_same_points_C2 Are_same_points_C2; typedef Svd_are_same_segments_C2 Are_same_segments_C2; private: Are_same_points_C2 same_points; Are_same_segments_C2 same_segments; private: bool inside_segment(const Site_2& s, const Site_2& p) const { CGAL_precondition( s.is_segment() && p.is_point() ); Line_2 l = compute_supporting_line( s.supporting_site() ); // do geometric filtering here... Point_2 pp = p.point(); Oriented_side os = oriented_side_of_line(l, pp ); if ( os != ON_ORIENTED_BOUNDARY ) { // the point does not belong to the same line as the segment return false; } Line_2 lp1 = compute_perpendicular(l, s.segment().source()); Oriented_side os1 = oriented_side_of_line(lp1, pp); CGAL_assertion( os1 != ON_ORIENTED_BOUNDARY ); if ( os1 == ON_POSITIVE_SIDE ) { return false; } Line_2 lp2 = compute_perpendicular(l, s.segment().target()); lp2 = opposite_line(lp2); Oriented_side os2 = oriented_side_of_line(lp2, pp); CGAL_assertion( os2 != ON_ORIENTED_BOUNDARY ); if ( os2 == ON_POSITIVE_SIDE ) { return false; } return true; } //------------------------------------------------------------------------ result_type arrangement_type_same_point(const Site_2& p, const Site_2& q, unsigned int ip, unsigned int iq) const { CGAL_precondition( ip < 2 && iq < 2 ); #if 0 if ( same_segments(p.supporting_site(), q.supporting_site()) ) { Line_2 l = compute_supporting_line(p.supporting_site()); Line_2 lp; if ( ip == 0 ) { lp = compute_perpendicular(l, p.segment().source()); } else { lp = compute_perpendicular(l, p.segment().target()); lp = opposite_line(lp); } Oriented_side os; if ( iq == 0 ) { os = oriented_side_of_line(lp, q.segment().target()); } else { os = oriented_side_of_line(lp, q.segment().source()); } CGAL_assertion( os != ON_ORIENTED_BOUNDARY ); if ( os == ON_POSITIVE_SIDE ) { return std::pair(ip,iq); } else { return std::pair(5,5); } } #endif Point_2 p1 = p.supporting_site().source(); Point_2 p2 = p.supporting_site().target(); Point_2 p3; if ( iq == 0 ) { p3 = q.supporting_site().target(); } else { p3 = q.supporting_site().source(); } if ( Orientation_2()(p1, p2, p3) != COLLINEAR ) { if ( ip == 0 ) { if ( iq == 0 ) { return TOUCH_11; } else { return TOUCH_12; } } else { if ( iq == 0 ) { return TOUCH_21; } else { return TOUCH_22; } } } else { Segment_2 s1 = p.segment(); Segment_2 s2 = q.segment(); return svd_arrangement_type_parallel_C2( s1.source().x(), s1.source().y(), s1.target().x(), s1.target().y(), s2.source().x(), s2.source().y(), s2.target().x(), s2.target().y() ); } } result_type arrangement_type_ss(const Site_2& p, const Site_2& q) const { if ( same_segments(p, q) ) { return IDENTICAL; } if ( same_points(p.source_site(), q.source_site()) ) { return arrangement_type_same_point(p, q, 0, 0); } if ( same_points(p.source_site(), q.target_site()) ) { return arrangement_type_same_point(p, q, 0, 1); } else if ( same_points(p.target_site(), q.source_site()) ) { return arrangement_type_same_point(p, q, 1, 0); } else if ( same_points(p.target_site(), q.target_site()) ) { return arrangement_type_same_point(p, q, 1, 1); } Segment_2 s1 = p.segment(); Segment_2 s2 = q.segment(); result_type res = svd_arrangement_type_ftC2( s1.source().x(), s1.source().y(), s1.target().x(), s1.target().y(), s2.source().x(), s2.source().y(), s2.target().x(), s2.target().y() ); return res; } //-------------------------------------------------------------------- result_type arrangement_type_ps(const Site_2& p, const Site_2& q) const { if ( same_points(p, q.source_site()) ) { return TOUCH_1; } else if ( same_points(p, q.target_site()) ) { return TOUCH_2; } else if ( inside_segment(q, p) ) { return INTERIOR; } else { return DISJOINT; } } //-------------------------------------------------------------------- result_type arrangement_type_pp(const Site_2& p, const Site_2& q) const { if ( same_points(p, q) ) { return IDENTICAL; } else { return DISJOINT; } } //-------------------------------------------------------------------- public: typedef Site_2 argument_type; typedef Arity_tag<2> Arity; result_type operator()(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_defined() && q.is_defined() ); if ( p.is_point() && q.is_point() ) { return arrangement_type_pp(p, q); } else if ( p.is_point() && q.is_segment() ) { return arrangement_type_ps(p, q); } else if ( p.is_segment() && q.is_point() ) { return opposite( arrangement_type_ps(q, p) ); } else { return arrangement_type_ss(p, q); } } }; //--------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_ARRANGEMENT_TYPE_C2_H ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_predicates_rtH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Vor0000644000175000017500000004443211344301501031326 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Segment_Voronoi_diagram_predicates_rtH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_RTH2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_RTH2_H #include #include #include CGAL_BEGIN_NAMESPACE template Comparison_result svd_compare_distanceH2(const RT& qhx, const RT& qhy, const RT& qhw, const RT& shx, const RT& shy, const RT& shw, const RT& thx, const RT& thy, const RT& thw, const RT& phx, const RT& phy, const RT& phw, Method_tag) { // first check if (qx,qy) is inside, the boundary or at the exterior // of the band of the segment s //******************************************************************** //******************************************************************** must_be_filtered(qhx); FT dx = sx - tx; FT dy = sy - ty; FT d1x = qx - sx; FT d1y = qy - sy; FT d2x = qx - tx; FT d2y = qy - ty; if ( px == sx && py == sy ) { FT o = dx * d1x + dy * d1y; if ( o >= FT(0) ) { return LARGER; } } if ( px == tx && py == ty ) { FT o = dx * d2x + dy * d2y; if ( o <= FT(0) ) { return LARGER; } } FT d2_from_p = CGAL::square (qx-px) + CGAL::square(qy-py); FT dot1 = dx * d1x + dy * d1y; if ( dot1 >= FT(0) ) { // q is outside (or the boundary of) the band on the side of s. FT d2_from_s = CGAL::square(d1x) + CGAL::square(d1y); return CGAL::compare(d2_from_s, d2_from_p); } FT dot2 = dx * d2x + dy * d2y; if ( dot2 <= FT(0) ) { // q is outside (or the boundary of) the band on the side of t. FT d2_from_t = CGAL::square(d2x) + CGAL::square(d2y); return CGAL::compare(d2_from_t, d2_from_p); } // q is strictly in the interior of the band, so I have to compare // its distance from the supporting line. FT c = sx * ty - sy * tx; FT n = CGAL::square(dx) + CGAL::square(dy); FT d2_from_l = CGAL::square(qx * dy - qy * dx + c); return CGAL::compare(d2_from_l, d2_from_p * n); } template Comparison_result svd_compare_distanceC2(const FT& qx, const FT& qy, const FT& s1x, const FT& s1y, const FT& t1x, const FT& t1y, const FT& s2x, const FT& s2y, const FT& t2x, const FT& t2y, Method_tag) { // first check if (qx,qy) is inside, the boundary or at the exterior // of the band of the segments s1, s2 must_be_filtered(qx); FT d1x = s1x - t1x; FT d1y = s1y - t1y; FT d2x = s2x - t2x; FT d2y = s2y - t2y; FT dqs1x = qx - s1x; FT dqs1y = qy - s1y; FT dqt1x = qx - t1x; FT dqt1y = qy - t1y; FT dqs2x = qx - s2x; FT dqs2y = qy - s2y; FT dqt2x = qx - t2x; FT dqt2y = qy - t2y; FT dot_s1 = d1x * dqs1x + d1y * dqs1y; int idx1; // 0 for s1, 1 for interior of 1, 2 for t1; if ( qx == s1x && qy == s1y ) { idx1 = 0; } else if ( qx == t1x && qy == t1y ) { idx1 = 2; } else if ( dot_s1 >= FT(0) ) { // q is outside (or the boundary of) the band of 1 on the side of s1. idx1 = 0; } else { FT dot_t1 = d1x * dqt1x + d1y * dqt1y; if ( dot_t1 <= FT(0) ) { // q is outside (or the boundary of) the band of 1 on the side of t1. idx1 = 2; } else { idx1 = 1; } } FT dot_s2 = d2x * dqs2x + d2y * dqs2y; int idx2; // 0 for s2, 1 for interior of 2, 2 for t2; if ( qx == s2x && qy == s2y ) { idx2 = 0; } else if ( qx == t2x && qy == t2y ) { idx2 = 2; } else if ( dot_s2 >= FT(0) ) { // q is outside (or the boundary of) the band of 2 on the side of s2. idx2 = 0; } else { FT dot_t2 = d2x * dqt2x + d2y * dqt2y; if ( dot_t2 <= FT(0) ) { // q is outside (or the boundary of) the band of 2 on the side of t2. idx2 = 2; } else { idx2 = 1; } } if ( idx1 == 0 ) { FT d2_from_s1 = CGAL::square(dqs1x) + CGAL::square(dqs1y); // if ( qx == s1x && qy == s1y ) { d2_from_s1 = FT(0); } if ( idx2 == 0 ) { FT d2_from_s2 = CGAL::square(dqs2x) + CGAL::square(dqs2y); // if ( qx == s2x && qy == s2y ) { d2_from_s2 = FT(0); } if ( s1x == s2x && s1y == s2y ) { return EQUAL; } return CGAL::compare(d2_from_s1, d2_from_s2); } else if ( idx2 == 2 ) { FT d2_from_t2 = CGAL::square(dqt2x) + CGAL::square(dqt2y); // if ( qx == t2x && qy == t2y ) { d2_from_t2 = FT(0); } if ( s1x == t2x && s1y == t2y ) { return EQUAL; } return CGAL::compare(d2_from_s1, d2_from_t2); } else { // idx2 == 1 FT c2 = s2x * t2y - s2y * t2x; FT n2 = CGAL::square(d2x) + CGAL::square(d2y); FT d2_from_l2 = CGAL::square(qx * d2y - qy * d2x + c2); return CGAL::compare(d2_from_s1 * n2, d2_from_l2); } } else if ( idx1 == 2 ) { FT d2_from_t1 = CGAL::square(dqt1x) + CGAL::square(dqt1y); // if ( qx == t1x && qy == t1y ) { d2_from_t1 = FT(0); } if ( idx2 == 0 ) { FT d2_from_s2 = CGAL::square(dqs2x) + CGAL::square(dqs2y); // if ( qx == s2x && qy == s2y ) { d2_from_s2 = FT(0); } if ( t1x == s2x && t1y == s2y ) { return EQUAL; } return CGAL::compare(d2_from_t1, d2_from_s2); } else if ( idx2 == 2 ) { FT d2_from_t2 = CGAL::square(dqt2x) + CGAL::square(dqt2y); // if ( qx == t2x && qy == t2y ) { d2_from_t2 = FT(0); } if ( t1x == t2x && t1y == t2y ) { return EQUAL; } return CGAL::compare(d2_from_t1, d2_from_t2); } else { // idx2 == 1 FT c2 = s2x * t2y - s2y * t2x; FT n2 = CGAL::square(d2x) + CGAL::square(d2y); FT d2_from_l2 = CGAL::square(qx * d2y - qy * d2x + c2); return CGAL::compare(d2_from_t1 * n2, d2_from_l2); } } else { // idx1 == 1 FT c1 = s1x * t1y - s1y * t1x; FT n1 = CGAL::square(d1x) + CGAL::square(d1y); FT d2_from_l1 = CGAL::square(qx * d1y - qy * d1x + c1); if ( idx2 == 0 ) { FT d2_from_s2 = CGAL::square(dqs2x) + CGAL::square(dqs2y); // if ( qx == s2x && qy == s2y ) { d2_from_s2 = FT(0); } return CGAL::compare(d2_from_l1, d2_from_s2 * n1); } else if ( idx2 == 2 ) { FT d2_from_t2 = CGAL::square(dqt2x) + CGAL::square(dqt2y); // if ( qx == t2x && qy == t2y ) { d2_from_t2 = FT(0); } return CGAL::compare(d2_from_l1, d2_from_t2 * n1); } else { // idx2 == 1 FT c2 = s2x * t2y - s2y * t2x; FT n2 = CGAL::square(d2x) + CGAL::square(d2y); FT d2_from_l2 = CGAL::square(qx * d2y - qy * d2x + c2); return CGAL::compare(d2_from_l1 * n2, d2_from_l2 * n1); } } } //-------------------------------------------------------------------------- template inline Sign svd_vertex_conflict_ftC2(const typename K::Site_2 t[], unsigned int num_sites, Method_tag mtag) { typedef typename K::FT FT; char site_types[4]; std::vector v; for (unsigned int i = 0; i < num_sites; i++) { if ( t[i].is_point() ) { v.push_back( t[i].point().x() ); v.push_back( t[i].point().y() ); site_types[i] = 'p'; } else { v.push_back( t[i].source().x() ); v.push_back( t[i].source().y() ); v.push_back( t[i].target().x() ); v.push_back( t[i].target().y() ); site_types[i] = 's'; } } return svd_vertex_conflict_ftC2(v, site_types, num_sites, mtag); } template inline Sign svd_vertex_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& t, Method_tag mtag) { typename K::Site_2 site_vec[] = {p, q, t}; return svd_vertex_conflict_ftC2(site_vec, 3, mtag); } template inline Sign svd_vertex_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& t, Method_tag mtag) { typename K::Site_2 site_vec[] = {p, q, r, t}; return svd_vertex_conflict_ftC2(site_vec, 4, mtag); } template inline Sign svd_vertex_conflict_ftC2(const std::vector& v, char site_types[], unsigned int num_sites, Method_tag) { CGAL_precondition( num_sites == 3 || num_sites == 4 ); must_be_filtered(FT()); typedef Simple_cartesian Rep; typedef CGAL::Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment_2; typedef typename Kernel::Site_2 Site_2; typedef Svd_incircle_2 Incircle; Site_2* t = new Site_2[4]; for (unsigned int i = 0, k = 0; i < num_sites; i++) { if ( site_types[i] == 'p' ) { Point_2 p(v[k], v[k+1]); t[i].set_point( p ); } else if ( site_types[i] == 's' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Segment_2 s(p1, p2); t[i].set_segment( s ); } else { CGAL_assertion( site_types[i] == 'p' || site_types[i] == 's' ); } k += ( (site_types[i] == 'p') ? 2 : 4 ); } Sign res(ZERO); if ( num_sites == 3 ) { res = Incircle()(t[0], t[1], t[2]); } else { res = Incircle()(t[0], t[1], t[2], t[3]); } delete[] t; return res; } //-------------------------------------------------------------------------- template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2 t[], Sign sgn, unsigned int num_sites, Method_tag mtag) { typedef typename K::FT FT; char site_types[5]; std::vector v; for (unsigned int i = 0; i < num_sites; i++) { if ( t[i].is_point() ) { v.push_back( t[i].point().x() ); v.push_back( t[i].point().y() ); site_types[i] = 'p'; } else { v.push_back( t[i].source().x() ); v.push_back( t[i].source().y() ); v.push_back( t[i].target().x() ); v.push_back( t[i].target().y() ); site_types[i] = 's'; } } return svd_finite_edge_conflict_ftC2(v, sgn, site_types, num_sites, mtag); } template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typename K::Site_2 site_vec[] = {p, q, t}; return svd_finite_edge_conflict_ftC2(site_vec, sgn, 3, mtag); } template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typename K::Site_2 site_vec[] = {p, q, r, t}; return svd_finite_edge_conflict_ftC2(site_vec, sgn, 4, mtag); } template inline bool svd_finite_edge_conflict_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& s, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typename K::Site_2 site_vec[] = {p, q, r, s, t}; return svd_finite_edge_conflict_ftC2(site_vec, sgn, 5, mtag); } template inline bool svd_finite_edge_conflict_ftC2(const std::vector& v, Sign sgn, char site_types[], unsigned int num_sites, Method_tag) { CGAL_precondition( num_sites >= 3 || num_sites <= 5 ); must_be_filtered(FT()); typedef Simple_cartesian Rep; typedef Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment_2; typedef typename Kernel::Site_2 Site_2; typedef Svd_finite_edge_interior_2 Edge_interior_test; Site_2* t = new Site_2[5]; for (unsigned int i = 0, k = 0; i < num_sites; i++) { if ( site_types[i] == 'p' ) { Point_2 p(v[k], v[k+1]); t[i].set_point( p ); } else if ( site_types[i] == 's' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Segment_2 s(p1, p2); t[i].set_segment( s ); } else { CGAL_assertion( site_types[i] == 'p' || site_types[i] == 's' ); } k += ( (site_types[i] == 'p') ? 2 : 4 ); } bool res(false); if ( num_sites == 3 ) { res = Edge_interior_test()(t[0], t[1], t[2], sgn); } else if ( num_sites == 4 ) { res = Edge_interior_test()(t[0], t[1], t[2], t[3], sgn); } else { res = Edge_interior_test()(t[0], t[1], t[2], t[3], t[4], sgn); } delete[] t; return res; } //-------------------------------------------------------------------------- template inline bool svd_infinite_edge_conflict_ftC2(const typename K::Site_2 t[], Sign sgn, unsigned int num_sites, Method_tag mtag) { typedef typename K::FT FT; char site_types[4]; std::vector v; for (unsigned int i = 0; i < num_sites; i++) { if ( t[i].is_point() ) { v.push_back( t[i].point().x() ); v.push_back( t[i].point().y() ); site_types[i] = 'p'; } else { v.push_back( t[i].source().x() ); v.push_back( t[i].source().y() ); v.push_back( t[i].target().x() ); v.push_back( t[i].target().y() ); site_types[i] = 's'; } } return svd_infinite_edge_conflict_ftC2(v, sgn, site_types, num_sites, mtag); } template inline bool svd_infinite_edge_conflict_ftC2(const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& s, const typename K::Site_2& t, Sign sgn, Method_tag mtag) { typename K::Site_2 site_vec[] = {q, r, s, t}; return svd_infinite_edge_conflict_ftC2(site_vec, sgn, 4, mtag); } template inline bool svd_infinite_edge_conflict_ftC2(const std::vector& v, Sign sgn, char site_types[], unsigned int num_sites, Method_tag) { CGAL_precondition( num_sites == 4 ); must_be_filtered(FT()); typedef Simple_cartesian Rep; typedef Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment_2; typedef typename Kernel::Site_2 Site_2; typedef Svd_infinite_edge_interior_2 Edge_interior_test; Site_2* t = new Site_2[num_sites]; for (unsigned int i = 0, k = 0; i < num_sites; i++) { if ( site_types[i] == 'p' ) { Point_2 p(v[k], v[k+1]); t[i].set_point( p ); } else if ( site_types[i] == 's' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Segment_2 s(p1, p2); t[i].set_segment( s ); } else { CGAL_assertion( site_types[i] == 'p' || site_types[i] == 's' ); } k += ( (site_types[i] == 'p') ? 2 : 4 ); } bool res = Edge_interior_test()(t[0], t[1], t[2], t[3], sgn); delete[] t; return res; } //-------------------------------------------------------------------------- template inline bool svd_is_degenerate_edge_ftC2(const typename K::Site_2 t[], unsigned int num_sites, Method_tag mtag) { typedef typename K::FT FT; char site_types[4]; std::vector v; for (unsigned int i = 0; i < num_sites; i++) { if ( t[i].is_point() ) { v.push_back( t[i].point().x() ); v.push_back( t[i].point().y() ); site_types[i] = 'p'; } else { v.push_back( t[i].source().x() ); v.push_back( t[i].source().y() ); v.push_back( t[i].target().x() ); v.push_back( t[i].target().y() ); site_types[i] = 's'; } } return svd_is_degenerate_edge_ftC2(v, site_types, num_sites, mtag); } template inline bool svd_is_degenerate_edge_ftC2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, const typename K::Site_2& t, Method_tag mtag) { typename K::Site_2 site_vec[] = {p, q, r, t}; return svd_is_degenerate_edge_ftC2(site_vec, 4, mtag); } template inline bool svd_is_degenerate_edge_ftC2(const std::vector& v, char site_types[], unsigned int num_sites, Method_tag) { CGAL_precondition( num_sites == 4 ); must_be_filtered(FT()); typedef Simple_cartesian Rep; typedef Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment_2; typedef typename Kernel::Site_2 Site_2; typedef Svd_is_degenerate_edge_test_2 Is_degenerate_edge; Site_2* t = new Site_2[4]; for (unsigned int i = 0, k = 0; i < num_sites; i++) { if ( site_types[i] == 'p' ) { Point_2 p(v[k], v[k+1]); t[i].set_point( p ); } else if ( site_types[i] == 's' ) { Point_2 p1(v[k], v[k+1]), p2(v[k+2], v[k+3]); Segment_2 s(p1, p2); t[i].set_segment( s ); } else { CGAL_assertion( site_types[i] == 'p' || site_types[i] == 's' ); } k += ( (site_types[i] == 'p') ? 2 : 4 ); } bool res = Is_degenerate_edge()(t[0], t[1], t[2], t[3]); delete[] t; return res; } //-------------------------------------------------------------------------- CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #ifndef CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_RTH2_H //#include #endif // CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_RTH2_H #endif #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_PREDICATES_RTH2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_parallel_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_par0000644000175000017500000000414111344301501031314 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_are_parallel_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef SVD_ARE_PARALLEL_C2_H #define SVD_ARE_PARALLEL_C2_H #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------- // are parallel //----------------------------------------------------------------------- template< class K > class Svd_are_parallel_C2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<2> Arity; private: typedef typename K::Segment_2 Segment_2; typedef typename K::FT FT; private: bool predicate(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_segment() && q.is_segment() ); Segment_2 s1 = p.segment(); Segment_2 s2 = q.segment(); FT x1 = s1.source().x(), y1 = s1.source().y(), x2 = s1.target().x(), y2 = s1.target().y(), x3 = s2.source().x(), y3 = s2.source().y(), x4 = s2.target().x(), y4 = s2.target().y(); FT det = det2x2_by_formula(x2 - x1, x4 - x3, y2 - y1, y4 - y3); return ( CGAL::sign(det) == CGAL::ZERO ); } public: result_type operator()(const Site_2& p, const Site_2& q) const { return predicate(p, q); } }; CGAL_END_NAMESPACE #endif // SVD_ARE_PARALLEL_C2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_compare_x_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_compare0000644000175000017500000000316311344301501031334 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_compare_x_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_COMPARE_X_2_H #define CGAL_SVD_COMPARE_X_2_H CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------- // compare x //----------------------------------------------------------------------- template< class K > class Svd_compare_x_2 { public: typedef typename K::Site_2 Site_2; typedef typename K::Point_2 Point_2; typedef Comparison_result result_type; typedef Arity_tag<2> Arity; private: typedef typename K::Compare_x_2 compare_x_2; public: result_type operator()(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_point() && q.is_point() ); return compare_x_2()( p.point(), q.point() ); } }; CGAL_END_NAMESPACE #endif // CGAL_SVD_COMPARE_X_2_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_orientation_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_orienta0000644000175000017500000001242611344301501031351 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_orientation_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_ORIENTATION_C2_H #define CGAL_SVD_ORIENTATION_C2_H #include #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------------- template class Svd_orientation_C2 : public Svd_basic_predicates_C2 { private: typedef Svd_basic_predicates_C2 Base; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename K::Kernel::Orientation_2 Orientation_2; typedef CGAL::Svd_are_same_points_C2 Are_same_points_2; typedef CGAL::Svd_are_same_segments_C2 Are_same_segments_2; typedef typename K::Intersections_tag ITag; Are_same_points_2 same_points; Are_same_segments_2 same_segments; bool have_common_support(const Site_2& p, const Site_2& q) const { CGAL_precondition( !p.is_input() && !q.is_input() ); return same_segments(p.supporting_site(0), q.supporting_site(0)) || same_segments(p.supporting_site(0), q.supporting_site(1)) || same_segments(p.supporting_site(1), q.supporting_site(0)) || same_segments(p.supporting_site(1), q.supporting_site(1)); } bool have_common_support(const Site_2& p, const Site_2& q, Site_2& support) const { CGAL_precondition( !p.is_input() && !q.is_input() ); if ( same_segments(p.supporting_site(0), q.supporting_site(0)) || same_segments(p.supporting_site(0), q.supporting_site(1)) ) { support = p.supporting_site(0); return true; } else if ( same_segments(p.supporting_site(1), q.supporting_site(0)) || same_segments(p.supporting_site(1), q.supporting_site(1)) ) { support = p.supporting_site(1); return true; } return false; } bool is_endpoint(const Site_2& p, const Site_2& s) const { return same_points(s.source_site(), p) || same_points(s.target_site(), p); } //------------------------------------------------------------- Orientation predicate(const Site_2& p, const Site_2& q, const Site_2& r, const Tag_false&) const { return Orientation_2()(p.point(), q.point(), r.point()); } Orientation predicate(const Site_2& p, const Site_2& q, const Site_2& r, const Tag_true&) const { #if 1 // do geometric filtering bool pe = p.is_input(); bool qe = q.is_input(); bool re = r.is_input(); Site_2 support; if ( !pe && !qe && !re ) { if ( have_common_support(p, q, support) && have_common_support(support, r) ) { return COLLINEAR; } } else if ( !pe && !qe ) { if ( have_common_support(p, q, support) && is_endpoint(r, support) ) { return COLLINEAR; } } else if ( !pe && !re ) { if ( have_common_support(p, r, support) && is_endpoint(q, support) ) { return COLLINEAR; } } else if ( !qe && !re ) { if ( have_common_support(q, r, support) && is_endpoint(p, support) ) { return COLLINEAR; } } else if ( !pe ) { Site_2 s0 = p.supporting_site(0); Site_2 s1 = p.supporting_site(1); if ( (is_endpoint(q, s0) && is_endpoint(r, s0)) || (is_endpoint(q, s1) && is_endpoint(r, s1)) ) { return COLLINEAR; } } else if ( !qe ) { Site_2 s0 = q.supporting_site(0); Site_2 s1 = q.supporting_site(1); if ( (is_endpoint(p, s0) && is_endpoint(r, s0)) || (is_endpoint(p, s1) && is_endpoint(r, s1)) ) { return COLLINEAR; } } else if ( !re ) { Site_2 s0 = r.supporting_site(0); Site_2 s1 = r.supporting_site(1); if ( (is_endpoint(q, s0) && is_endpoint(p, s0)) || (is_endpoint(q, s1) && is_endpoint(p, s1)) ) { return COLLINEAR; } } #endif return predicate(p, q, r, Tag_false()); } public: typedef Orientation result_type; typedef Site_2 argument_type; typedef Arity_tag<3> Arity; Orientation operator()(const Site_2& p, const Site_2& q, const Site_2& r) const { CGAL_precondition( p.is_point() && q.is_point() && r.is_point() ); return predicate(p, q, r, ITag()); } }; //----------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SVD_ORIENTATION_C2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/kernel_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/kernel_ftC30000644000175000017500000004331411344301501031233 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/kernel_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann, Sylvain Pion #ifndef CGAL_PREDICATES_KERNEL_FTC3_H #define CGAL_PREDICATES_KERNEL_FTC3_H #include #include #include CGAL_BEGIN_NAMESPACE template < class FT > inline bool parallelC3(const FT &v1x, const FT &v1y, const FT &v1z, const FT &v2x, const FT &v2y, const FT &v2z) { return sign_of_determinant2x2(v1x, v2x, v1y, v2y) == ZERO && sign_of_determinant2x2(v1x, v2x, v1z, v2z) == ZERO && sign_of_determinant2x2(v1y, v2y, v1z, v2z) == ZERO; } template < class FT > bool parallelC3(const FT &s1sx, const FT &s1sy, const FT &s1sz, const FT &s1tx, const FT &s1ty, const FT &s1tz, const FT &s2sx, const FT &s2sy, const FT &s2sz, const FT &s2tx, const FT &s2ty, const FT &s2tz) { // NB : Could be made slightly more efficient by computing the z differences // only when they are needed. FT v1x = s1tx - s1sx; FT v1y = s1ty - s1sy; FT v1z = s1tz - s1sz; FT v2x = s2tx - s2sx; FT v2y = s2ty - s2sy; FT v2z = s2tz - s2sz; return parallelC3(v1x, v1y, v1z, v2x, v2y, v2z); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_lexicographically_xyzC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { Comparison_result c = CGAL_NTS compare(px, qx); if (c != EQUAL) return c; c = CGAL_NTS compare(py, qy); if (c != EQUAL) return c; return CGAL_NTS compare(pz, qz); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool strict_dominanceC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return CGAL_NTS compare(px, qx) == LARGER && CGAL_NTS compare(py, qy) == LARGER && CGAL_NTS compare(pz, qz) == LARGER; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool dominanceC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return CGAL_NTS compare(px, qx) != SMALLER && CGAL_NTS compare(py, qy) != SMALLER && CGAL_NTS compare(pz, qz) != SMALLER; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool collinearC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { FT dpx = px-rx; FT dqx = qx-rx; FT dpy = py-ry; FT dqy = qy-ry; if (sign_of_determinant2x2(dpx, dqx, dpy, dqy) != ZERO) return false; FT dpz = pz-rz; FT dqz = qz-rz; return sign_of_determinant2x2(dpx, dqx, dpz, dqz) == ZERO && sign_of_determinant2x2(dpy, dqy, dpz, dqz) == ZERO; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Orientation orientationC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz) { return Orientation(sign_of_determinant3x3(qx-px,rx-px,sx-px, qy-py,ry-py,sy-py, qz-pz,rz-pz,sz-pz)); } template < class FT > inline Angle angleC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { return (Angle) CGAL_NTS sign((px-qx)*(rx-qx)+ (py-qy)*(ry-qy)+ (pz-qz)*(rz-qz)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE Orientation coplanar_orientationC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz) { Orientation oxy_pqr = orientationC2(px,py,qx,qy,rx,ry); if (oxy_pqr != COLLINEAR) return Orientation( oxy_pqr * orientationC2(px,py,qx,qy,sx,sy)); Orientation oyz_pqr = orientationC2(py,pz,qy,qz,ry,rz); if (oyz_pqr != COLLINEAR) return Orientation( oyz_pqr * orientationC2(py,pz,qy,qz,sy,sz)); Orientation oxz_pqr = orientationC2(px,pz,qx,qz,rx,rz); CGAL_kernel_assertion(oxz_pqr != COLLINEAR); return Orientation( oxz_pqr * orientationC2(px,pz,qx,qz,sx,sz)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE Orientation coplanar_orientationC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { Orientation oxy_pqr = orientationC2(px,py,qx,qy,rx,ry); if (oxy_pqr != COLLINEAR) return oxy_pqr; Orientation oyz_pqr = orientationC2(py,pz,qy,qz,ry,rz); if (oyz_pqr != COLLINEAR) return oyz_pqr; return orientationC2(px,pz,qx,qz,rx,rz); } template < class FT > CGAL_KERNEL_LARGE_INLINE Bounded_side coplanar_side_of_bounded_circleC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &tx, const FT &ty, const FT &tz) { // The approach is to compute side_of_bounded_sphere(p,q,r,t+v,t), // with v = pq ^ pr. // Note : since the circle defines the orientation of the plane, it can not // be considered oriented. FT ptx = px - tx; FT pty = py - ty; FT ptz = pz - tz; FT pt2 = CGAL_NTS square(ptx) + CGAL_NTS square(pty) + CGAL_NTS square(ptz); FT qtx = qx - tx; FT qty = qy - ty; FT qtz = qz - tz; FT qt2 = CGAL_NTS square(qtx) + CGAL_NTS square(qty) + CGAL_NTS square(qtz); FT rtx = rx - tx; FT rty = ry - ty; FT rtz = rz - tz; FT rt2 = CGAL_NTS square(rtx) + CGAL_NTS square(rty) + CGAL_NTS square(rtz); FT pqx = qx - px; FT pqy = qy - py; FT pqz = qz - pz; FT prx = rx - px; FT pry = ry - py; FT prz = rz - pz; FT vx = pqy*prz - pqz*pry; FT vy = pqz*prx - pqx*prz; FT vz = pqx*pry - pqy*prx; FT v2 = CGAL_NTS square(vx) + CGAL_NTS square(vy) + CGAL_NTS square(vz); return Bounded_side(sign_of_determinant4x4(ptx,pty,ptz,pt2, rtx,rty,rtz,rt2, qtx,qty,qtz,qt2, vx,vy,vz,v2)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool collinear_are_ordered_along_lineC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { if (px < qx) return !(rx < qx); if (qx < px) return !(qx < rx); if (py < qy) return !(ry < qy); if (qy < py) return !(qy < ry); if (pz < qz) return !(rz < qz); if (qz < pz) return !(qz < rz); return true; // p==q } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool collinear_are_strictly_ordered_along_lineC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { if (px < qx) return (qx < rx); if (qx < px) return (rx < qx); if (py < qy) return (qy < ry); if (qy < py) return (ry < qy); if (pz < qz) return (qz < rz); if (qz < pz) return (rz < qz); return false; // p==q } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool equal_directionC3(const FT &dx1, const FT &dy1, const FT &dz1, const FT &dx2, const FT &dy2, const FT &dz2) { return sign_of_determinant2x2(dx1, dy1, dx2, dy2) == ZERO && sign_of_determinant2x2(dx1, dz1, dx2, dz2) == ZERO && sign_of_determinant2x2(dy1, dz1, dy2, dz2) == ZERO && CGAL_NTS sign(dx1) == CGAL_NTS sign(dx2) && CGAL_NTS sign(dy1) == CGAL_NTS sign(dy2) && CGAL_NTS sign(dz1) == CGAL_NTS sign(dz2); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE bool equal_planeC3(const FT &ha, const FT &hb, const FT &hc, const FT &hd, const FT &pa, const FT &pb, const FT &pc, const FT &pd) { if (!equal_directionC3(ha, hb, hc, pa, pb, pc)) return false; // Not parallel. CGAL::Sign s1a = CGAL_NTS sign(ha); if (s1a != ZERO) return s1a == CGAL_NTS sign(pa) && sign_of_determinant2x2(pa, pd, ha, hd) == ZERO; CGAL::Sign s1b = CGAL_NTS sign(hb); if (s1b != ZERO) return s1b == CGAL_NTS sign(pb) && sign_of_determinant2x2(pb, pd, hb, hd) == ZERO; return CGAL_NTS sign(pc) == CGAL_NTS sign(hc) && sign_of_determinant2x2(pc, pd, hc, hd) == ZERO; } template CGAL_KERNEL_LARGE_INLINE Oriented_side side_of_oriented_planeC3(const FT &a, const FT &b, const FT &c, const FT &d, const FT &px, const FT &py, const FT &pz) { return Oriented_side(CGAL_NTS sign(a*px + b*py + c*pz +d)); } template CGAL_KERNEL_LARGE_INLINE Oriented_side side_of_oriented_sphereC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz, const FT &tx, const FT &ty, const FT &tz) { FT ptx = px - tx; FT pty = py - ty; FT ptz = pz - tz; FT pt2 = CGAL_NTS square(ptx) + CGAL_NTS square(pty) + CGAL_NTS square(ptz); FT qtx = qx - tx; FT qty = qy - ty; FT qtz = qz - tz; FT qt2 = CGAL_NTS square(qtx) + CGAL_NTS square(qty) + CGAL_NTS square(qtz); FT rtx = rx - tx; FT rty = ry - ty; FT rtz = rz - tz; FT rt2 = CGAL_NTS square(rtx) + CGAL_NTS square(rty) + CGAL_NTS square(rtz); FT stx = sx - tx; FT sty = sy - ty; FT stz = sz - tz; FT st2 = CGAL_NTS square(stx) + CGAL_NTS square(sty) + CGAL_NTS square(stz); return Oriented_side(sign_of_determinant4x4(ptx,pty,ptz,pt2, rtx,rty,rtz,rt2, qtx,qty,qtz,qt2, stx,sty,stz,st2)); } template CGAL_KERNEL_MEDIUM_INLINE Bounded_side side_of_bounded_sphereC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz, const FT &tx, const FT &ty, const FT &tz) { Oriented_side s = side_of_oriented_sphereC3(px, py, pz, qx, qy, qz, rx, ry, rz, sx, sy, sz, tx, ty, tz); Orientation o = orientationC3(px, py, pz, qx, qy, qz, rx, ry, rz, sx, sy, sz); return Bounded_side(s * o); } template CGAL_KERNEL_MEDIUM_INLINE Bounded_side side_of_bounded_sphereC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &tx, const FT &ty, const FT &tz) { // Returns whether T lies inside or outside the sphere which diameter is PQ. return Bounded_side( CGAL_NTS sign((tx-px)*(qx-tx) + (ty-py)*(qy-ty) + (tz-pz)*(qz-tz)) ); } template < class FT > CGAL_KERNEL_INLINE Comparison_result cmp_dist_to_pointC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { return CGAL_NTS compare(squared_distanceC3(px,py,pz,qx,qy,qz), squared_distanceC3(px,py,pz,rx,ry,rz)); } // Because of the way the filtered predicates generator script works, // cmp_dist_to_pointC3() must be defined _before_ ths following one. template CGAL_KERNEL_MEDIUM_INLINE Bounded_side side_of_bounded_sphereC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &sx, const FT &sy, const FT &sz, const FT &tx, const FT &ty, const FT &tz) { // Returns whether T lies inside or outside the sphere which equatorial // circle is PQR. // This code is inspired by the one of circumcenterC3(3 points). FT psx = px-sx; FT psy = py-sy; FT psz = pz-sz; FT ps2 = CGAL_NTS square(psx) + CGAL_NTS square(psy) + CGAL_NTS square(psz); FT qsx = qx-sx; FT qsy = qy-sy; FT qsz = qz-sz; FT qs2 = CGAL_NTS square(qsx) + CGAL_NTS square(qsy) + CGAL_NTS square(qsz); FT rsx = psy*qsz-psz*qsy; FT rsy = psz*qsx-psx*qsz; FT rsz = psx*qsy-psy*qsx; FT tsx = tx-sx; FT tsy = ty-sy; FT tsz = tz-sz; FT num_x = ps2 * det2x2_by_formula(qsy,qsz,rsy,rsz) - qs2 * det2x2_by_formula(psy,psz,rsy,rsz); FT num_y = ps2 * det2x2_by_formula(qsx,qsz,rsx,rsz) - qs2 * det2x2_by_formula(psx,psz,rsx,rsz); FT num_z = ps2 * det2x2_by_formula(qsx,qsy,rsx,rsy) - qs2 * det2x2_by_formula(psx,psy,rsx,rsy); FT den = det3x3_by_formula(psx,psy,psz, qsx,qsy,qsz, rsx,rsy,rsz); FT den2 = FT(2) * den; // The following could be simplified a bit. return Bounded_side(cmp_dist_to_pointC3(num_x, - num_y, num_z, psx*den2, psy*den2, psz*den2, tsx*den2, tsy*den2, tsz*den2) ); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool has_larger_dist_to_pointC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { return cmp_dist_to_pointC3(px,py,pz,qx,qy,qz,rx,ry,rz) == LARGER; } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool has_smaller_dist_to_pointC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { return cmp_dist_to_pointC3(px,py,pz,qx,qy,qz,rx,ry,rz) == SMALLER; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result cmp_signed_dist_to_directionC3( const FT &pa, const FT &pb, const FT &pc, const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return CGAL_NTS compare(scaled_distance_to_directionC3(pa,pb,pc,px,py,pz), scaled_distance_to_directionC3(pa,pb,pc,qx,qy,qz)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool has_larger_signed_dist_to_directionC3( const FT &pa, const FT &pb, const FT &pc, const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return cmp_signed_dist_to_directionC3(pa,pb,pc,px,py,pz,qx,qy,qz) == LARGER; } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool has_smaller_signed_dist_to_directionC3( const FT &pa, const FT &pb, const FT &pc, const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return cmp_signed_dist_to_directionC3(pa,pb,pc,px,py,pz,qx,qy,qz) == SMALLER; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE Comparison_result cmp_signed_dist_to_planeC3( const FT &ppx, const FT &ppy, const FT &ppz, const FT &pqx, const FT &pqy, const FT &pqz, const FT &prx, const FT &pry, const FT &prz, const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return Comparison_result(sign_of_determinant3x3( pqx-ppx, pqy-ppy, pqz-ppz, prx-ppx, pry-ppy, prz-ppz, px-qx, py-qy, pz-qz)); } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool has_larger_signed_dist_to_planeC3( const FT &ppx, const FT &ppy, const FT &ppz, const FT &pqx, const FT &pqy, const FT &pqz, const FT &prx, const FT &pry, const FT &prz, const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return cmp_signed_dist_to_planeC3(ppx, ppy, ppz, pqx, pqy, pqz, prx, pry, prz, px, py, pz, qx, qy, qz) == LARGER; } template < class FT > /*CGAL_NO_FILTER*/ CGAL_KERNEL_MEDIUM_INLINE bool has_smaller_signed_dist_to_planeC3( const FT &ppx, const FT &ppy, const FT &ppz, const FT &pqx, const FT &pqy, const FT &pqz, const FT &prx, const FT &pry, const FT &prz, const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return cmp_signed_dist_to_planeC3(ppx, ppy, ppz, pqx, pqy, pqz, prx, pry, prz, px, py, pz, qx, qy, qz) == SMALLER; } CGAL_END_NAMESPACE #ifdef CGAL_ARITHMETIC_FILTER_H #include #endif #endif // CGAL_PREDICATES_KERNEL_FTC3_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_incircle_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_incircl0000644000175000017500000001602111344301501031203 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Ag2_incircle_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_AG2_INCIRCLE_C2_H #define CGAL_AG2_INCIRCLE_C2_H #include #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- template< class K > class Sign_of_distance_from_bitangent_line { public: typedef CGAL::Bitangent_line Bitangent_line; typedef typename K::Site_2 Site_2; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef typename K::FT FT; public: inline Sign operator()(const Bitangent_line& bl, const Site_2& q, const Sqrt_field_tag&) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::distance_from_bitangent_counter++; #endif FT a = bl.a1() + bl.a2() * CGAL::sqrt(bl.delta()); FT b = bl.b1() + bl.b2() * CGAL::sqrt(bl.delta()); FT c = bl.c1() + bl.c2() * CGAL::sqrt(bl.delta()); FT r = a * q.x() + b * q.y() + c - q.weight() * bl.d(); return CGAL::sign(r); } inline Sign operator()(const Bitangent_line& bl, const Site_2& q, const Ring_tag&) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::distance_from_bitangent_counter++; #endif FT A = bl.a1() * q.x() + bl.b1() * q.y() + bl.c1() - q.weight() * bl.d(); FT B = bl.a2() * q.x() + bl.b2() * q.y() + bl.c2(); return sign_a_plus_b_x_sqrt_c(A, B, bl.delta()); } }; //-------------------------------------------------------------------- template< class K > class Sign_of_distance_from_CCW_circle { public: typedef CGAL::Bitangent_line Bitangent_line; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef typename K::FT FT; public: inline Sign operator()(const Bitangent_line& bl, const Inverted_weighted_point& v, const Sqrt_field_tag&) const { FT a = bl.a1() + bl.a2() * CGAL::sqrt(bl.delta()); FT b = bl.b1() + bl.b2() * CGAL::sqrt(bl.delta()); FT c = bl.c1() + bl.c2() * CGAL::sqrt(bl.delta()); FT r = a * v.x() + b * v.y() + c * v.p() - v.weight() * bl.d(); return CGAL::sign(r); } inline Sign operator()(const Bitangent_line& bl, const Inverted_weighted_point& v, const Ring_tag&) const { FT A = bl.a1() * v.x() + bl.b1() * v.y() + bl.c1() * v.p() - v.weight() * bl.d(); FT B = bl.a2() * v.x() + bl.b2() * v.y() + bl.c2() * v.p(); return sign_a_plus_b_x_sqrt_c(A, B, bl.delta()); } }; template < class Weighted_point > class Weighted_point_less_than { public: inline bool operator()(const Weighted_point& p1, const Weighted_point& p2) const { if ( p1.x() == p2.x() ) { return p1.y() < p2.y(); } return p1.x() < p2.x(); } }; template < class K, class MTag > class Incircle_test { public: typedef K Kernel; typedef MTag Method_tag; typedef typename K::Point_2 Point_2; typedef typename K::Site_2 Site_2; typedef CGAL::Weighted_point_inverter Weighted_point_inverter; typedef CGAL::Inverted_weighted_point Inverted_weighted_point; typedef CGAL::Bitangent_line Bitangent_line; typedef CGAL::Voronoi_radius Voronoi_radius; typedef typename K::FT FT; typedef CGAL::Bounded_side_of_CCW_circle Bounded_side_of_CCW_circle; typedef CGAL::Sign_of_distance_from_bitangent_line Sign_of_distance_from_bitangent_line; typedef CGAL::Sign_of_distance_from_CCW_circle Sign_of_distance_from_CCW_circle; private: inline Orientation orientation(const Bitangent_line& l, const Point_2& p, const Sqrt_field_tag&) const { FT A = l.a1() * p.x() + l.b1() * p.y() + l.c1(); FT B = l.a2() * p.x() + l.b2() * p.y() + l.c2(); FT P = A + B * CGAL::sqrt(l.delta()); return CGAL::sign(P); } inline Orientation orientation(const Bitangent_line& l, const Point_2& p, const Ring_tag&) const { FT A = l.a1() * p.x() + l.b1() * p.y() + l.c1(); FT B = l.a2() * p.x() + l.b2() * p.y() + l.c2(); return sign_a_plus_b_x_sqrt_c(A, B, l.delta()); } inline Orientation orientation(const Bitangent_line& l, const Inverted_weighted_point& u) const { FT A = l.a1() * u.x() / u.p() + l.b1() * u.y() / u.p() + l.c1(); FT B = l.a2() * u.x() / u.p() + l.b2() * u.y() / u.p() + l.c2(); FT P = A + B * CGAL::sqrt(l.delta()); return CGAL::sign(P); } public: typedef Sign result_type; typedef Site_2 argument_type; struct Arity {}; inline Sign operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q) const { #ifdef AG2_PROFILE_PREDICATES ag2_predicate_profiler::incircle_counter++; #endif // Method_tag tag; Weighted_point_inverter inverter(p1); Inverted_weighted_point u2 = inverter(p2); Inverted_weighted_point u3 = inverter(p3); Voronoi_radius vr_123(u2, u3); Bounded_side bs = Bounded_side_of_CCW_circle()(vr_123, tag ); if ( bs != ON_UNBOUNDED_SIDE ) { return NEGATIVE; } Inverted_weighted_point v = inverter(q); Bitangent_line blinv_23(u2, u3); Sign s = Sign_of_distance_from_CCW_circle()(blinv_23, v, tag); return s; } inline Sign operator()(const Site_2& p1, const Site_2& p2, const Site_2& q) const { Method_tag tag; // Bitangent_line bl_21(p2, p1); Sign s = Sign_of_distance_from_bitangent_line()(bl_21, q, tag); if ( s != ZERO ) { return s; } Bitangent_line bl1_perp = bl_21.perpendicular(p1.point()); Bitangent_line bl2_perp = bl_21.perpendicular(p2.point()); Orientation o1 = orientation(bl1_perp, q.point(), tag); Orientation o2 = orientation(bl2_perp, q.point(), tag); CGAL_assertion( o1 != COLLINEAR && o2 != COLLINEAR ); if ( o1 == o2 ) { return POSITIVE; } return NEGATIVE; } }; //-------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_AG2_INCIRCLE_C2_H ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_oriented_side_of_bisector_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_oriente0000644000175000017500000002300711344301501031352 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates/Svd_oriented_side_of_bisector_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SVD_ORIENTED_SIDE_OF_BISECTOR_C2_H #define CGAL_SVD_ORIENTED_SIDE_OF_BISECTOR_C2_H #include #include #include CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------------ //------------------------------------------------------------------------ template class Svd_oriented_side_of_bisector_C2 : public Svd_basic_predicates_C2 { private: typedef Svd_basic_predicates_C2 Base; typedef typename Base::Line_2 Line_2; typedef typename Base::RT RT; typedef typename Base::FT FT; typedef Svd_are_same_points_C2 Are_same_points_C2; typedef Svd_are_same_segments_C2 Are_same_segments_C2; private: Are_same_points_C2 same_points; Are_same_segments_C2 same_segments; public: typedef typename Base::Site_2 Site_2; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; private: bool is_endpoint(const Site_2& p, const Site_2& s) const { CGAL_precondition( p.is_point() && s.is_segment() ); return same_points(p, s.source_site()) || same_points(p, s.target_site()); } bool is_degenerate(const Site_2& s) const { CGAL_precondition( s.is_segment() ); return same_points( s.source_site(), s.target_site() ); } //----------------------------------------------------------------- Comparison_result compare_distances_pp(const Site_2& p1, const Site_2& p2, const Site_2& q) const { CGAL_precondition( p1.is_point() && p2.is_point() ); CGAL_precondition( !same_points(p1,p2) ); if ( same_points(q, p1) ) { return SMALLER; } if ( same_points(q, p2) ) { return LARGER; } return compare_distance_to_point(q.point(), p1.point(), p2.point()); } //----------------------------------------------------------------- Comparison_result compare_distances_sp(const Site_2& s, const Site_2& p, const Site_2& q) const { CGAL_precondition( s.is_segment() && p.is_point() ); CGAL_precondition( !is_degenerate(s) ); if ( same_points(q, p) ) { return LARGER; } if ( same_points(q, s.source_site()) ) { return SMALLER; } if ( same_points(q, s.target_site()) ) { return SMALLER; } bool is_src = same_points(p, s.source_site()); bool is_trg = same_points(p, s.target_site()); if ( is_src || is_trg ) { Line_2 ls = compute_supporting_line(s.supporting_site()); Line_2 lp = compute_perpendicular(ls, p.point()); if ( is_trg ) { lp = opposite_line(lp); } Oriented_side os = oriented_side_of_line(lp, q.point()); if ( os == ON_POSITIVE_SIDE ) { return LARGER; } else if ( os == ON_NEGATIVE_SIDE) { return SMALLER; } else { return EQUAL; } } Point_2 pp = p.point(), qq = q.point(); RT d2_p = compute_squared_distance(pp, qq); Point_2 ssrc = s.source(), strg = s.target(); Line_2 ls = compute_supporting_line(s.supporting_site()); Line_2 lsrc = compute_perpendicular(ls, ssrc); Line_2 ltrg = compute_perpendicular(ls, strg); Oriented_side os_src = oriented_side_of_line(lsrc, qq); if ( os_src != ON_NEGATIVE_SIDE ) { RT d2_s = compute_squared_distance(qq, ssrc); return CGAL::compare(d2_s, d2_p); } else { Oriented_side os_trg = oriented_side_of_line(ltrg, qq); if ( os_trg != ON_POSITIVE_SIDE ) { RT d2_s = compute_squared_distance(qq, strg); return CGAL::compare(d2_s, d2_p); } else { std::pair d2_s = compute_squared_distance(qq, ls); return CGAL::compare(d2_s.first, d2_p * d2_s.second); } } } //----------------------------------------------------------------- Comparison_result compare_distances_ss(const Site_2& s1, const Site_2& s2, const Site_2& q) const { CGAL_precondition( s1.is_segment() && s2.is_segment() ); CGAL_precondition( !is_degenerate(s1) ); CGAL_precondition( !is_degenerate(s2) ); bool is_on_s1 = is_endpoint(q, s1); bool is_on_s2 = is_endpoint(q, s2); if ( is_on_s1 && is_on_s2 ) { return EQUAL; } else if ( is_on_s1 && !is_on_s2 ) { return SMALLER; } else if ( !is_on_s1 && is_on_s2 ) { return LARGER; } if ( same_segments(s1, s2) ) { return EQUAL; } Point_2 qq = q.point(); Point_2 ssrc1 = s1.source(), strg1 = s1.target(); Line_2 ls1 = compute_supporting_line(s1.supporting_site()); Line_2 lsrc1 = compute_perpendicular(ls1, ssrc1); Line_2 ltrg1 = compute_perpendicular(ls1, strg1); Point_2 ssrc2 = s2.source(), strg2 = s2.target(); Line_2 ls2 = compute_supporting_line(s2.supporting_site()); Line_2 lsrc2 = compute_perpendicular(ls2, ssrc2); Line_2 ltrg2 = compute_perpendicular(ls2, strg2); // idx1 and idx2 indicate if q is to the left (source endpoint // side), the right side (target endpoint side) or inside // the band of s1 and s2 respectively; if q is on the boundary of // the band we assign it to the adjacent halfplane; for left // halfplane the value is -1; for the band the value is 0; for the // right halfplane the value is 1. int idx1(0), idx2(0); Oriented_side os_src1 = oriented_side_of_line(lsrc1, qq); if ( os_src1 != ON_NEGATIVE_SIDE ) { idx1 = -1; } else { Oriented_side os_trg1 = oriented_side_of_line(ltrg1, qq); if ( os_trg1 != ON_POSITIVE_SIDE ) { idx1 = 1; } } Oriented_side os_src2 = oriented_side_of_line(lsrc2, qq); if ( os_src2 != ON_NEGATIVE_SIDE ) { idx2 = -1; } else { Oriented_side os_trg2 = oriented_side_of_line(ltrg2, qq); if ( os_trg2 != ON_POSITIVE_SIDE ) { idx2 = 1; } } CGAL_assertion( idx1 >= -1 && idx1 <= 1 ); CGAL_assertion( idx2 >= -1 && idx2 <= 1 ); if ( idx1 == -1 ) { RT d2_s1 = compute_squared_distance(qq, ssrc1); if ( idx2 == -1 ) { if ( same_points(s1.source_site(), s2.source_site()) ) { return EQUAL; } RT d2_s2 = compute_squared_distance(qq, ssrc2); return CGAL::compare(d2_s1, d2_s2); } else if ( idx2 == 1 ) { if ( same_points(s1.source_site(), s2.target_site()) ) { return EQUAL; } RT d2_s2 = compute_squared_distance(qq, strg2); return CGAL::compare(d2_s1, d2_s2); } else { std::pair d2_s2 = compute_squared_distance(qq, ls2); return CGAL::compare(d2_s1 * d2_s2.second, d2_s2.first); } } else if ( idx1 == 1 ) { RT d2_s1 = compute_squared_distance(qq, strg1); if ( idx2 == -1 ) { if ( same_points(s1.target_site(), s2.source_site()) ) { return EQUAL; } RT d2_s2 = compute_squared_distance(qq, ssrc2); return CGAL::compare(d2_s1, d2_s2); } else if ( idx2 == 1 ) { if ( same_points(s1.target_site(), s2.target_site()) ) { return EQUAL; } RT d2_s2 = compute_squared_distance(qq, strg2); return CGAL::compare(d2_s1, d2_s2); } else { std::pair d2_s2 = compute_squared_distance(qq, ls2); return CGAL::compare(d2_s1 * d2_s2.second, d2_s2.first); } } else { std::pair d2_s1 = compute_squared_distance(qq, ls1); if ( idx2 == -1 ) { RT d2_s2 = compute_squared_distance(qq, ssrc2); return CGAL::compare(d2_s1.first, d2_s2 * d2_s1.second); } else if ( idx2 == 1 ) { RT d2_s2 = compute_squared_distance(qq, strg2); return CGAL::compare(d2_s1.first, d2_s2 * d2_s1.second); } else { std::pair d2_s2 = compute_squared_distance(qq, ls2); return CGAL::compare(d2_s1.first * d2_s2.second, d2_s2.first * d2_s1.second); } } } //----------------------------------------------------------------- //----------------------------------------------------------------- Oriented_side compare_distances(const Site_2& t1, const Site_2& t2, const Site_2& q) const { Comparison_result r; if ( t1.is_point() && t2.is_point() ) { r = compare_distances_pp(t1, t2, q); } else if ( t1.is_segment() && t2.is_point() ) { r = compare_distances_sp(t1, t2, q); } else if ( t1.is_point() && t2.is_segment() ) { r = opposite( compare_distances_sp(t2, t1, q) ); } else { r = compare_distances_ss(t1, t2, q); } if ( r == LARGER ) { return ON_NEGATIVE_SIDE; } if ( r == SMALLER ) { return ON_POSITIVE_SIDE; } return ON_ORIENTED_BOUNDARY; } public: typedef Oriented_side result_type; typedef Site_2 argument_type; typedef Arity_tag<3> Arity; Oriented_side operator()(const Site_2& t1, const Site_2& t2, const Site_2& q) const { CGAL_precondition( q.is_point() ); return compare_distances(t1, t2, q); } }; CGAL_END_NAMESPACE #endif // CGAL_SVD_ORIENTED_SIDE_OF_BISECTOR_C2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/0000755000175000017500000000000012146213717025766 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Constrained_triang_anim.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Constrained_tria0000644000175000017500000000366711344301501031201 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Constrained_triang_anim.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_CONSTR_TRIANG_ANIM_H #define CGAL_PM_CONSTR_TRIANG_ANIM_H #include CGAL_BEGIN_NAMESPACE template class Constrained_triang_anim { CGAL::Window_stream _W; public: typedef CGAL::Window_stream VDEVICE; typedef typename GT::GEOMETRY GEOM; typedef typename GT::Base PMDEC; typedef typename PMDEC::Point Point; Constrained_triang_anim() : _W(400,400) { _W.set_show_coordinates(true); _W.init(-120,120,-120,5); _W.display(); } VDEVICE& device() { return _W; } void post_init_animation(GT& gpst) { PM_visualizor V(_W,gpst); V.point(V.target(gpst.e_search)) = Point(-120,0); // to draw we have to embed the virtual search vertex V.draw_skeleton(CGAL::BLUE); _W.read_mouse(); } void pre_event_animation(GT& gpst) { } void post_event_animation(GT& gpst) { PM_visualizor V(_W,gpst); V.draw_ending_bundle(gpst.event,CGAL::GREEN); _W.read_mouse(); } void post_completion_animation(GT& gpst) { _W.clear(); PM_visualizor V(_W,gpst); V.draw_skeleton(CGAL::BLACK); _W.read_mouse(); } }; CGAL_END_NAMESPACE #endif // CGAL_PM_CONSTR_TRIANG_ANIM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Object_index.h0000644000175000017500000000342411344301501030523 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Object_index.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef OBJECT_INDEX_H #define OBJECT_INDEX_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Object_index { char _prefix; CGAL::Unique_hash_map _index; public: Object_index() : _prefix('\0'), _index(-1) {} Object_index(I first, I beyond, char c=' ') : _prefix(c), _index(-1) { for(int i=0 ; first!=beyond; ++i,++first) _index[first]=i; } int operator[](const I& it) const { return _index[it]; } int& operator[](const I& it) { return _index[it]; } void index(I first, I beyond, char c=' ') { _prefix=c; for(int i=0 ; first!=beyond; ++i,++first) _index[first]=i; } std::string operator()(const I& it, bool verbose=true) const { if (verbose && _index[it]==-1) return "nil"; if (verbose && _index[it]==-2) return "end"; std::ostringstream os; if (verbose) os << _prefix; os << _index[it]; return os.str(); } }; CGAL_END_NAMESPACE #endif //OBJECT_INDEX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Polynomial.h0000644000175000017500000021373411344301501030260 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Polynomial.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Andreas Fabri #ifndef CGAL_POLYNOMIAL_H #define CGAL_POLYNOMIAL_H #include #include #include #include #include #include #include #include #undef _DEBUG #define _DEBUG 3 #include #include CGAL_BEGIN_NAMESPACE template class Polynomial_rep; // SPECIALIZE_CLASS(NT,int double) START // CLASS TEMPLATE NT: template class Polynomial; // CLASS TEMPLATE int: template <> class Polynomial ; // CLASS TEMPLATE double: template <> class Polynomial ; // SPECIALIZE_CLASS(NT,int double) END /*{\Mtext \headerline{Range template}}*/ template typename std::iterator_traits::value_type gcd_of_range(Forward_iterator its, Forward_iterator ite) { typedef typename std::iterator_traits::value_type NT; typedef typename Number_type_traits::Has_gcd Has_gcd; return gcd_of_range(its,ite,Has_gcd()); } template typename std::iterator_traits::value_type gcd_of_range(Forward_iterator its, Forward_iterator ite, Tag_true) /*{\Mfunc calculates the greates common divisor of the set of numbers $\{ |*its|, |*++its|, \ldots, |*it| \}$ of type |NT|, where |++it == ite| and |NT| is the value type of |Forward_iterator|. \precond there exists a pairwise gcd operation |NT gcd(NT,NT)| and |its!=ite|.}*/ { CGAL_assertion(its!=ite); typedef typename std::iterator_traits::value_type NT; NT res = *its++; for(; its!=ite; ++its) res = (*its==0 ? res : CGAL_NTS gcd(res, *its)); if (res==0) res = 1; return res; } template typename std::iterator_traits::value_type gcd_of_range(Forward_iterator its, Forward_iterator ite, Tag_false) /*{\Mfunc calculates the greates common divisor of the set of numbers $\{ |*its|, |*++its|, \ldots, |*it| \}$ of type |NT|, where |++it == ite| and |NT| is the value type of |Forward_iterator|. \precond |its!=ite|.}*/ { CGAL_assertion(its!=ite); typedef typename std::iterator_traits::value_type NT; NT res = *its++; for(; its!=ite; ++its) res = (*its==0 ? res : 1); if (res==0) res = 1; return res; } template inline Polynomial operator - (const Polynomial&); template Polynomial operator + (const Polynomial&, const Polynomial&); template Polynomial operator - (const Polynomial&, const Polynomial&); template Polynomial operator * (const Polynomial&, const Polynomial&); template inline Polynomial operator / (const Polynomial&, const Polynomial&); template inline Polynomial operator % (const Polynomial&, const Polynomial&); template CGAL::Sign sign(const Polynomial& p); template double to_double(const Polynomial& p) ; template bool is_valid(const Polynomial& p) ; template bool is_finite(const Polynomial& p) ; template std::ostream& operator << (std::ostream& os, const Polynomial& p); template std::istream& operator >> (std::istream& is, Polynomial& p); // lefthand side template inline Polynomial operator + (const NT& num, const Polynomial& p2); template inline Polynomial operator - (const NT& num, const Polynomial& p2); template inline Polynomial operator * (const NT& num, const Polynomial& p2); template inline Polynomial operator / (const NT& num, const Polynomial& p2); template inline Polynomial operator % (const NT& num, const Polynomial& p2); // righthand side template inline Polynomial operator + (const Polynomial& p1, const NT& num); template inline Polynomial operator - (const Polynomial& p1, const NT& num); template inline Polynomial operator * (const Polynomial& p1, const NT& num); template inline Polynomial operator / (const Polynomial& p1, const NT& num); template inline Polynomial operator % (const Polynomial& p1, const NT& num); // lefthand side template inline bool operator == (const NT& num, const Polynomial& p); template inline bool operator != (const NT& num, const Polynomial& p); template inline bool operator < (const NT& num, const Polynomial& p); template inline bool operator <= (const NT& num, const Polynomial& p); template inline bool operator > (const NT& num, const Polynomial& p); template inline bool operator >= (const NT& num, const Polynomial& p); // righthand side template inline bool operator == (const Polynomial& p, const NT& num); template inline bool operator != (const Polynomial& p, const NT& num); template inline bool operator < (const Polynomial& p, const NT& num); template inline bool operator <= (const Polynomial& p, const NT& num); template inline bool operator > (const Polynomial& p, const NT& num); template inline bool operator >= (const Polynomial& p, const NT& num); template class Polynomial_rep { typedef pNT NT; typedef std::vector Vector; typedef typename Vector::size_type size_type; typedef typename Vector::iterator iterator; typedef typename Vector::const_iterator const_iterator; Vector coeff; Polynomial_rep() : coeff(0) {} Polynomial_rep(const NT& n) : coeff(1) { coeff[0]=n; } Polynomial_rep(const NT& n, const NT& m) : coeff(2) { coeff[0]=n; coeff[1]=m; } Polynomial_rep(const NT& a, const NT& b, const NT& c) : coeff(3) { coeff[0]=a; coeff[1]=b; coeff[2]=c; } Polynomial_rep(size_type s) : coeff(s,NT(0)) {} template Polynomial_rep(std::pair poly) : coeff(poly.first,poly.second) {} void reduce() { while ( coeff.size()>1 && coeff.back()==NT(0) ) coeff.pop_back(); } friend class Polynomial; friend class Polynomial; friend class Polynomial; friend std::istream& operator >> <> (std::istream&, Polynomial&); }; // SPECIALIZE_CLASS(NT,int double) START // CLASS TEMPLATE NT: /*{\Msubst typename iterator_traits::value_type#NT <># }*/ /*{\Manpage{Polynomial}{NT}{Polynomials in one variable}{p}}*/ template class Polynomial : public Handle_for< Polynomial_rep > { /* {\Mdefinition An instance |\Mvar| of the data type |\Mname| represents a polynomial $p = a_0 + a_1 x + \ldots a_d x^d $ from the ring |NT[x]|. The data type offers standard ring operations and a sign operation which determines the sign for the limit process $x \rightarrow \infty$. |NT[x]| becomes a unique factorization domain, if the number type |NT| is either a field type (1) or a unique factorization domain (2). In both cases there's a polynomial division operation defined.} */ /*{\Mtypes 5}*/ public: typedef pNT NT; typedef typename Number_type_traits::Has_gcd Has_gcd; typedef CGAL::Tag_false Has_sqrt; typedef CGAL::Tag_true Has_division; typedef CGAL::Tag_false Has_exact_division; typedef CGAL::Tag_false Has_exact_sqrt; typedef typename Number_type_traits::Has_exact_ring_operations Has_exact_ring_operations; typedef Handle_for< Polynomial_rep > Base; typedef Polynomial_rep Rep; typedef typename Rep::Vector Vector; typedef typename Rep::size_type size_type; typedef typename Rep::iterator iterator; typedef typename Rep::const_iterator const_iterator; /*{\Mtypemember a random access iterator for read-only access to the coefficient vector.}*/ //protected: void reduce() { this->ptr()->reduce(); } Vector& coeffs() { return this->ptr()->coeff; } const Vector& coeffs() const { return this->ptr()->coeff; } Polynomial(size_type s) : Base( Polynomial_rep(s) ) {} // creates a polynomial of degree s-1 /*{\Mcreation 3}*/ public: Polynomial() /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| of undefined value. }*/ : Base( Polynomial_rep() ) {} Polynomial(const NT& a0) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| representing the constant polynomial $a_0$.}*/ : Base(Polynomial_rep(a0)) { reduce(); } Polynomial(NT a0, NT a1) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial $a_0 + a_1 x$. }*/ : Base(Polynomial_rep(a0,a1)) { reduce(); } Polynomial(const NT& a0, const NT& a1,const NT& a2) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial $a_0 + a_1 x + a_2 x^2$. }*/ : Base(Polynomial_rep(a0,a1,a2)) { reduce(); } template Polynomial(std::pair poly) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial whose coefficients are determined by the iterator range, i.e. let $(a_0 = |*first|, a_1 = |*++first|, \ldots a_d = |*it|)$, where |++it == last| then |\Mvar| stores the polynomial $a_1 + a_2 x + \ldots a_d x^d$.}*/ : Base(Polynomial_rep(poly)) { reduce(); } // KILL double START Polynomial(double n) : Base(Polynomial_rep(NT(n))) { reduce(); } Polynomial(double n1, double n2) : Base(Polynomial_rep(NT(n1),NT(n2))) { reduce(); } // KILL double END // KILL int START Polynomial(int n) : Base(Polynomial_rep(NT(n))) { reduce(); } Polynomial(int n1, int n2) : Base(Polynomial_rep(NT(n1),NT(n2))) { reduce(); } // KILL int END Polynomial(const Polynomial& p) : Base(p) {} //protected: // accessing coefficients internally: NT& coeff(unsigned int i) { CGAL_assertion(!this->is_shared() && i<(this->ptr()->coeff.size())); return this->ptr()->coeff[i]; } public: /*{\Moperations 3 3 }*/ const_iterator begin() const { return this->ptr()->coeff.begin(); } /*{\Mop a random access iterator pointing to $a_0$.}*/ const_iterator end() const { return this->ptr()->coeff.end(); } /*{\Mop a random access iterator pointing beyond $a_d$.}*/ int degree() const { return this->ptr()->coeff.size()-1; } /*{\Mop the degree of the polynomial.}*/ const NT& operator[](unsigned int i) const { CGAL_assertion( i<(this->ptr()->coeff.size()) ); return this->ptr()->coeff[i]; } //{\Marrop the coefficient $a_i$ of the polynomial.} NT operator()(unsigned int i) const { if(i<(this->ptr()->coeff.size())) return this->ptr()->coeff[i]; return 0; } NT eval_at(const NT& r) const /*{\Mop evaluates the polynomial at |r|.}*/ { CGAL_assertion( degree()>=0 ); NT res = this->ptr()->coeff[0], x = r; for(int i=1; i<=degree(); ++i) { res += this->ptr()->coeff[i]*x; x*=r; } return res; } CGAL::Sign sign() const /*{\Mop returns the sign of the limit process for $x \rightarrow \infty$ (the sign of the leading coefficient).}*/ { const NT& leading_coeff = this->ptr()->coeff.back(); if (leading_coeff < NT(0)) return (CGAL::NEGATIVE); if (leading_coeff > NT(0)) return (CGAL::POSITIVE); return CGAL::ZERO; } bool is_zero() const /*{\Mop returns true iff |\Mvar| is the zero polynomial.}*/ { return degree()==0 && this->ptr()->coeff[0]==NT(0); } Polynomial abs() const /*{\Mop returns |-\Mvar| if |\Mvar.sign()==NEGATIVE| and |\Mvar| otherwise.}*/ { if ( sign()==CGAL::NEGATIVE ) return -*this; return *this; } NT content() const /*{\Mop returns the content of |\Mvar| (the gcd of its coefficients).}*/ { CGAL_assertion( degree()>=0 ); return gcd_of_range(this->ptr()->coeff.begin(),this->ptr()->coeff.end()); } /*{\Mtext Additionally |\Mname| offers standard arithmetic ring opertions like |+,-,*,+=,-=,*=|. By means of the sign operation we can also offer comparison predicates as $<,>,\leq,\geq$. Where $p_1 < p_2$ holds iff $|sign|(p_1 - p_2) < 0$. This data type is fully compliant to the requirements of CGAL number types. \setopdims{3cm}{2cm}}*/ friend Polynomial operator - <> (const Polynomial&); friend Polynomial operator + <> (const Polynomial&, const Polynomial&); friend Polynomial operator - <> (const Polynomial&, const Polynomial&); friend Polynomial operator * <> (const Polynomial&, const Polynomial&); friend Polynomial operator / <> (const Polynomial& p1, const Polynomial& p2); /*{\Mbinopfunc implements polynomial division of |p1| and |p2|. if |p1 = p2 * p3| then |p2| is returned. The result is undefined if |p3| does not exist in |NT[x]|. The correct division algorithm is chosen according to a number type traits class. If |Number_type_traits::Has_gcd == Tag_true| then the division is done by \emph{pseudo division} based on a |gcd| operation of |NT|. If |Number_type_traits::Has_gcd == Tag_false| then the division is done by \emph{euclidean division} based on the division operation of the field |NT|. \textbf{Note} that |NT=int| quickly leads to overflow errors when using this operation.}*/ /*{\Mtext \headerline{Static member functions}}*/ static Polynomial gcd (const Polynomial& p1, const Polynomial& p2); /*{\Mstatic returns the greatest common divisor of |p1| and |p2|. \textbf{Note} that |NT=int| quickly leads to overflow errors when using this operation. \precond Requires |NT| to be a unique factorization domain, i.e. to provide a |gcd| operation.}*/ static void pseudo_div (const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r, NT& D); /*{\Mstatic implements division with remainder on polynomials of the ring |NT[x]|: $D*f = g*q + r$. \precond |NT| is a unique factorization domain, i.e., there exists a |gcd| operation and an integral division operation on |NT|.}*/ static void euclidean_div (const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r); /*{\Mstatic implements division with remainder on polynomials of the ring |NT[x]|: $f = g*q + r$. \precond |NT| is a field, i.e., there exists a division operation on |NT|. }*/ friend double to_double <> (const Polynomial& p); Polynomial& operator += (const Polynomial& p1) { this->copy_on_write(); int d = std::min(degree(),p1.degree()), i; for(i=0; i<=d; ++i) coeff(i) += p1[i]; while (i<=p1.degree()) this->ptr()->coeff.push_back(p1[i++]); reduce(); return (*this); } Polynomial& operator -= (const Polynomial& p1) { this->copy_on_write(); int d = std::min(degree(),p1.degree()), i; for(i=0; i<=d; ++i) coeff(i) -= p1[i]; while (i<=p1.degree()) this->ptr()->coeff.push_back(-p1[i++]); reduce(); return (*this); } Polynomial& operator *= (const Polynomial& p1) { (*this)=(*this)*p1; return (*this); } Polynomial& operator /= (const Polynomial& p1) { (*this)=(*this)/p1; return (*this); } Polynomial& operator %= (const Polynomial& p1) { (*this)=(*this)%p1; return (*this); } //------------------------------------------------------------------ // SPECIALIZE_MEMBERS(int double) START Polynomial& operator += (const NT& num) { this->copy_on_write(); coeff(0) += (NT)num; return *this; } Polynomial& operator -= (const NT& num) { this->copy_on_write(); coeff(0) -= (NT)num; return *this; } Polynomial& operator *= (const NT& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (NT)num; reduce(); return *this; } Polynomial& operator /= (const NT& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (NT)num; reduce(); return *this; } Polynomial& operator %= (const NT& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (NT)num; reduce(); return *this; } // SPECIALIZING_MEMBERS FOR const int& Polynomial& operator += (const int& num) { this->copy_on_write(); coeff(0) += (NT)num; return *this; } Polynomial& operator -= (const int& num) { this->copy_on_write(); coeff(0) -= (NT)num; return *this; } Polynomial& operator *= (const int& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (NT)num; reduce(); return *this; } Polynomial& operator /= (const int& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (NT)num; reduce(); return *this; } Polynomial& operator %= (const int& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (NT)num; reduce(); return *this; } // SPECIALIZING_MEMBERS FOR const double& Polynomial& operator += (const double& num) { this->copy_on_write(); coeff(0) += (NT)num; return *this; } Polynomial& operator -= (const double& num) { this->copy_on_write(); coeff(0) -= (NT)num; return *this; } Polynomial& operator *= (const double& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (NT)num; reduce(); return *this; } Polynomial& operator /= (const double& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (NT)num; reduce(); return *this; } Polynomial& operator %= (const double& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (NT)num; reduce(); return *this; } // SPECIALIZE_MEMBERS(int double) END //------------------------------------------------------------------ void minus_offsetmult(const Polynomial& p, const NT& b, int k) { CGAL_assertion(!this->is_shared()); Polynomial s(size_type(p.degree()+k+1)); // zero entries for (int i=k; i <= s.degree(); ++i) s.coeff(i) = b*p[i-k]; operator-=(s); } }; /*{\Mimplementation This data type is implemented as an item type via a smart pointer scheme. The coefficients are stored in a vector of |NT| entries. The simple arithmetic operations $+,-$ take time $O(d*T(NT))$, multiplication is quadratic in the maximal degree of the arguments times $T(NT)$, where $T(NT)$ is the time for a corresponding operation on two instances of the ring type.}*/ //############ POLYNOMIAL< INT > ################################### // CLASS TEMPLATE int: /*{\Xsubst iterator_traits::value_type#int <># }*/ /*{\Xanpage{Polynomial}{int}{Polynomials in one variable}{p}}*/ template <> class Polynomial : public Handle_for< Polynomial_rep > { /*{\Xdefinition An instance |\Mvar| of the data type |\Mname| represents a polynomial $p = a_0 + a_1 x + \ldots a_d x^d $ from the ring |int[x]|. The data type offers standard ring operations and a sign operation which determines the sign for the limit process $x \rightarrow \infty$. |int[x]| becomes a unique factorization domain, if the number type |int| is either a field type (1) or a unique factorization domain (2). In both cases there's a polynomial division operation defined.}*/ /*{\Xtypes 5}*/ public: typedef int NT; /*{\Xtypemember the component type representing the coefficients.}*/ typedef Number_type_traits::Has_gcd Has_gcd; typedef CGAL::Tag_false Has_sqrt; typedef CGAL::Tag_true Has_division; typedef CGAL::Tag_false Has_exact_ring_operations; typedef CGAL::Tag_false Has_exact_division; typedef CGAL::Tag_false Has_exact_sqrt; typedef Handle_for< Polynomial_rep > Base; typedef Polynomial_rep Rep; typedef Rep::Vector Vector; typedef Rep::size_type size_type; typedef Rep::iterator iterator; typedef Rep::const_iterator const_iterator; /*{\Xtypemember a random access iterator for read-only access to the coefficient vector.}*/ //protected: void reduce() { this->ptr()->reduce(); } Vector& coeffs() { return this->ptr()->coeff; } const Vector& coeffs() const { return this->ptr()->coeff; } Polynomial(size_type s) : Base( Polynomial_rep(s) ) {} // creates a polynomial of degree s-1 /*{\Xcreation 3}*/ public: Polynomial() /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| of undefined value. }*/ : Base( Polynomial_rep() ) {} Polynomial(const int& a0) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the constant polynomial $a_0$.}*/ : Base(Polynomial_rep(a0)) { reduce(); } Polynomial(int a0, int a1) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial $a_0 + a_1 x$. }*/ : Base(Polynomial_rep(a0,a1)) { reduce(); } Polynomial(const int& a0, const int& a1,const int& a2) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial $a_0 + a_1 x + a_2 x^2$. }*/ : Base(Polynomial_rep(a0,a1,a2)) { reduce(); } template Polynomial(std::pair poly) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial whose coefficients are determined by the iterator range, i.e. let $(a_0 = |*first|, a_1 = |*++first|, \ldots a_d = |*it|)$, where |++it == last| then |\Mvar| stores the polynomial $a_1 + a_2 x + \ldots a_d x^d$.}*/ : Base(Polynomial_rep(poly)) { reduce(); } // KILL double START Polynomial(double n) : Base(Polynomial_rep(int(n))) { reduce(); } Polynomial(double n1, double n2) : Base(Polynomial_rep(int(n1),int(n2))) { reduce(); } // KILL double END Polynomial(const Polynomial& p) : Base(p) {} //protected: // accessing coefficients internally: int& coeff(unsigned int i) { CGAL_assertion(!this->is_shared() && i<(this->ptr()->coeff.size())); return this->ptr()->coeff[i]; } public: /*{\Xoperations 3 3 }*/ const_iterator begin() const { return this->ptr()->coeff.begin(); } /*{\Xop a random access iterator pointing to $a_0$.}*/ const_iterator end() const { return this->ptr()->coeff.end(); } /*{\Xop a random access iterator pointing beyond $a_d$.}*/ int degree() const { return this->ptr()->coeff.size()-1; } /*{\Xop the degree of the polynomial.}*/ const int& operator[](unsigned int i) const { CGAL_assertion( i<(this->ptr()->coeff.size()) ); return this->ptr()->coeff[i]; } /*{\Xarrop the coefficient $a_i$ of the polynomial.}*/ int eval_at(const int& r) const /*{\Xop evaluates the polynomial at |r|.}*/ { CGAL_assertion( degree()>=0 ); int res = this->ptr()->coeff[0], x = r; for(int i=1; i<=degree(); ++i) { res += this->ptr()->coeff[i]*x; x*=r; } return res; } CGAL::Sign sign() const /*{\Xop returns the sign of the limit process for $x \rightarrow \infty$ (the sign of the leading coefficient).}*/ { const int& leading_coeff = this->ptr()->coeff.back(); if (leading_coeff < int(0)) return (CGAL::NEGATIVE); if (leading_coeff > int(0)) return (CGAL::POSITIVE); return CGAL::ZERO; } bool is_zero() const /*{\Xop returns true iff |\Mvar| is the zero polynomial.}*/ { return degree()==0 && this->ptr()->coeff[0]==int(0); } Polynomial abs() const /*{\Xop returns |-\Mvar| if |\Mvar.sign()==NEGATIVE| and |\Mvar| otherwise.}*/ { if ( sign()==CGAL::NEGATIVE ) return -*this; return *this; } int content() const /*{\Xop returns the content of |\Mvar| (the gcd of its coefficients). \precond Requires |int| to provide a |gcd| operation.}*/ { CGAL_assertion( degree()>=0 ); return gcd_of_range(this->ptr()->coeff.begin(),this->ptr()->coeff.end()); } /*{\Xtext Additionally |\Mname| offers standard arithmetic ring opertions like |+,-,*,+=,-=,*=|. By means of the sign operation we can also offer comparison predicates as $<,>,\leq,\geq$. Where $p_1 < p_2$ holds iff $|sign|(p_1 - p_2) < 0$. This data type is fully compliant to the requirements of CGAL number types. \setopdims{3cm}{2cm}}*/ friend Polynomial operator + <> (const Polynomial&, const Polynomial&); friend Polynomial operator - <> (const Polynomial&, const Polynomial&); friend Polynomial operator * <> (const Polynomial&, const Polynomial&); friend Polynomial operator / <> (const Polynomial& p1, const Polynomial& p2); /*{\Xbinopfunc implements polynomial division of |p1| and |p2|. if |p1 = p2 * p3| then |p2| is returned. The result is undefined if |p3| does not exist in |int[x]|. The correct division algorithm is chosen according to a number type traits class. If |Number_type_traits::Has_gcd == Tag_true| then the division is done by \emph{pseudo division} based on a |gcd| operation of |int|. If |Number_type_traits::Has_gcd == Tag_false| then the division is done by \emph{euclidean division} based on the division operation of the field |int|. \textbf{Note} that |int=int| quickly leads to overflow errors when using this operation.}*/ /*{\Xtext \headerline{Static member functions}}*/ static Polynomial gcd (const Polynomial& p1, const Polynomial& p2); /*{\Xstatic returns the greatest common divisor of |p1| and |p2|. \textbf{Note} that |int=int| quickly leads to overflow errors when using this operation. \precond Requires |int| to be a unique factorization domain, i.e. to provide a |gcd| operation.}*/ static void pseudo_div (const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r, int& D); /*{\Xstatic implements division with remainder on polynomials of the ring |int[x]|: $D*f = g*q + r$. \precond |int| is a unique factorization domain, i.e., there exists a |gcd| operation and an integral division operation on |int|.}*/ static void euclidean_div (const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r); /*{\Xstatic implements division with remainder on polynomials of the ring |int[x]|: $f = g*q + r$. \precond |int| is a field, i.e., there exists a division operation on |int|. }*/ friend double to_double <> (const Polynomial& p); Polynomial& operator += (const Polynomial& p1) { this->copy_on_write(); int d = std::min(degree(),p1.degree()), i; for(i=0; i<=d; ++i) coeff(i) += p1[i]; while (i<=p1.degree()) this->ptr()->coeff.push_back(p1[i++]); reduce(); return (*this); } Polynomial& operator -= (const Polynomial& p1) { this->copy_on_write(); int d = std::min(degree(),p1.degree()), i; for(i=0; i<=d; ++i) coeff(i) -= p1[i]; while (i<=p1.degree()) this->ptr()->coeff.push_back(-p1[i++]); reduce(); return (*this); } Polynomial& operator *= (const Polynomial& p1) { (*this)=(*this)*p1; return (*this); } Polynomial& operator /= (const Polynomial& p1) { (*this)=(*this)/p1; return (*this); } Polynomial& operator %= (const Polynomial& p1) { (*this)=(*this)%p1; return (*this); } //------------------------------------------------------------------ // SPECIALIZE_MEMBERS(int double) START Polynomial& operator += (const int& num) { this->copy_on_write(); coeff(0) += (int)num; return *this; } Polynomial& operator -= (const int& num) { this->copy_on_write(); coeff(0) -= (int)num; return *this; } Polynomial& operator *= (const int& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (int)num; reduce(); return *this; } Polynomial& operator /= (const int& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (int)num; reduce(); return *this; } Polynomial& operator %= (const int& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (int)num; reduce(); return *this; } // SPECIALIZING_MEMBERS FOR const double& Polynomial& operator += (const double& num) { this->copy_on_write(); coeff(0) += (int)num; return *this; } Polynomial& operator -= (const double& num) { this->copy_on_write(); coeff(0) -= (int)num; return *this; } Polynomial& operator *= (const double& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (int)num; reduce(); return *this; } Polynomial& operator /= (const double& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (int)num; reduce(); return *this; } Polynomial& operator %= (const double& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (int)num; reduce(); return *this; } // SPECIALIZE_MEMBERS(int double) END //------------------------------------------------------------------ void minus_offsetmult(const Polynomial& p, const int& b, int k) { CGAL_assertion(!is_shared()); Polynomial s(size_type(p.degree()+k+1)); // zero entries for (int i=k; i <= s.degree(); ++i) s.coeff(i) = b*p[i-k]; operator-=(s); } }; /*{\Ximplementation This data type is implemented as an item type via a smart pointer scheme. The coefficients are stored in a vector of |int| entries. The simple arithmetic operations $+,-$ take time $O(d*T(int))$, multiplication is quadratic in the maximal degree of the arguments times $T(int)$, where $T(int)$ is the time for a corresponding operation on two instances of the ring type.}*/ //############ POLYNOMIAL< INT > ################################### //############ POLYNOMIAL< DOUBLE > ################################ // CLASS TEMPLATE double: /*{\Xsubst iterator_traits::value_type#double <># }*/ /*{\Xanpage{Polynomial}{double}{Polynomials in one variable}{p}}*/ template <> class Polynomial : public Handle_for< Polynomial_rep > { /*{\Xdefinition An instance |\Mvar| of the data type |\Mname| represents a polynomial $p = a_0 + a_1 x + \ldots a_d x^d $ from the ring |double[x]|. The data type offers standard ring operations and a sign operation which determines the sign for the limit process $x \rightarrow \infty$. |double[x]| becomes a unique factorization domain, if the number type |double| is either a field type (1) or a unique factorization domain (2). In both cases there's a polynomial division operation defined.}*/ /*{\Xtypes 5}*/ public: typedef double NT; /*{\Xtypemember the component type representing the coefficients.}*/ typedef Number_type_traits::Has_gcd Has_gcd; typedef CGAL::Tag_false Has_sqrt; typedef CGAL::Tag_true Has_division; typedef CGAL::Tag_false Has_exact_ring_operations; typedef CGAL::Tag_false Has_exact_division; typedef CGAL::Tag_false Has_exact_sqrt; typedef Handle_for< Polynomial_rep > Base; typedef Polynomial_rep Rep; typedef Rep::Vector Vector; typedef Rep::size_type size_type; typedef Rep::iterator iterator; typedef Rep::const_iterator const_iterator; /*{\Xtypemember a random access iterator for read-only access to the coefficient vector.}*/ //protected: void reduce() { this->ptr()->reduce(); } Vector& coeffs() { return this->ptr()->coeff; } const Vector& coeffs() const { return this->ptr()->coeff; } Polynomial(size_type s) : Base( Polynomial_rep(s) ) {} // creates a polynomial of degree s-1 /*{\Xcreation 3}*/ public: Polynomial() /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| of undefined value. }*/ : Base( Polynomial_rep() ) {} Polynomial(const double& a0) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the constant polynomial $a_0$.}*/ : Base(Polynomial_rep(a0)) { reduce(); } Polynomial(const double a0, const double a1) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial $a_0 + a_1 x$. }*/ : Base(Polynomial_rep(a0,a1)) { reduce(); } Polynomial(const double& a0, const double& a1,const double& a2) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial $a_0 + a_1 x + a_2 x^2$. }*/ : Base(Polynomial_rep(a0,a1,a2)) { reduce(); } template Polynomial(std::pair poly) /*{\Xcreate introduces a variable |\Mvar| of type |\Mname| representing the polynomial whose coefficients are determined by the iterator range, i.e. let $(a_0 = |*first|, a_1 = |*++first|, \ldots a_d = |*it|)$, where |++it == last| then |\Mvar| stores the polynomial $a_1 + a_2 x + \ldots a_d x^d$.}*/ : Base(Polynomial_rep(poly)) { reduce(); } // KILL int START Polynomial(int n) : Base(Polynomial_rep(double(n))) { reduce(); } Polynomial(int n1, int n2) : Base(Polynomial_rep(double(n1),double(n2))) { reduce(); } // KILL int END Polynomial(const Polynomial& p) : Base(p) {} //protected: // accessing coefficients internally: double& coeff(unsigned int i) { CGAL_assertion(!this->is_shared() && i<(this->ptr()->coeff.size())); return this->ptr()->coeff[i]; } public: /*{\Xoperations 3 3 }*/ const_iterator begin() const { return this->ptr()->coeff.begin(); } /*{\Xop a random access iterator pointing to $a_0$.}*/ const_iterator end() const { return this->ptr()->coeff.end(); } /*{\Xop a random access iterator pointing beyond $a_d$.}*/ int degree() const { return this->ptr()->coeff.size()-1; } /*{\Xop the degree of the polynomial.}*/ const double& operator[](unsigned int i) const { CGAL_assertion( i<(this->ptr()->coeff.size()) ); return this->ptr()->coeff[i]; } /*{\Xarrop the coefficient $a_i$ of the polynomial.}*/ double eval_at(const double& r) const /*{\Xop evaluates the polynomial at |r|.}*/ { CGAL_assertion( degree()>=0 ); double res = this->ptr()->coeff[0], x = r; for(int i=1; i<=degree(); ++i) { res += this->ptr()->coeff[i]*x; x*=r; } return res; } CGAL::Sign sign() const /*{\Xop returns the sign of the limit process for $x \rightarrow \infty$ (the sign of the leading coefficient).}*/ { const double& leading_coeff = this->ptr()->coeff.back(); if (leading_coeff < double(0)) return (CGAL::NEGATIVE); if (leading_coeff > double(0)) return (CGAL::POSITIVE); return CGAL::ZERO; } bool is_zero() const /*{\Xop returns true iff |\Mvar| is the zero polynomial.}*/ { return degree()==0 && this->ptr()->coeff[0]==double(0); } Polynomial abs() const /*{\Xop returns |-\Mvar| if |\Mvar.sign()==NEGATIVE| and |\Mvar| otherwise.}*/ { if ( sign()==CGAL::NEGATIVE ) return -*this; return *this; } double content() const /*{\Xop returns the content of |\Mvar| (the gcd of its coefficients). \precond Requires |double| to provide a |gdc| operation.}*/ { CGAL_assertion( degree()>=0 ); return gcd_of_range(this->ptr()->coeff.begin(),this->ptr()->coeff.end()); } /*{\Xtext Additionally |\Mname| offers standard arithmetic ring opertions like |+,-,*,+=,-=,*=|. By means of the sign operation we can also offer comparison predicates as $<,>,\leq,\geq$. Where $p_1 < p_2$ holds iff $|sign|(p_1 - p_2) < 0$. This data type is fully compliant to the requirements of CGAL number types. \setopdims{3cm}{2cm}}*/ friend Polynomial operator + <> (const Polynomial&, const Polynomial&); friend Polynomial operator - <> (const Polynomial&, const Polynomial&); friend Polynomial operator * <> (const Polynomial&, const Polynomial&); friend Polynomial operator / <> (const Polynomial& p1, const Polynomial& p2); /*{\Xbinopfunc implements polynomial division of |p1| and |p2|. if |p1 = p2 * p3| then |p2| is returned. The result is undefined if |p3| does not exist in |double[x]|. The correct division algorithm is chosen according to the number type traits class. If |Number_type_traits::Has_gcd == Tag_true| then the division is done by \emph{pseudo division} based on a |gcd| operation of |double|. If |Number_type_traits::Has_gcd == Tag_false| then the division is done by \emph{euclidean division} based on the division operation of the field |double|. \textbf{Note} that |double=int| quickly leads to overflow errors when using this operation.}*/ /*{\Xtext \headerline{Static member functions}}*/ static Polynomial gcd (const Polynomial& p1, const Polynomial& p2); /*{\Xstatic returns the greatest common divisor of |p1| and |p2|. \textbf{Note} that |double=int| quickly leads to overflow errors when using this operation. \precond Requires |double| to be a unique factorization domain, i.e. to provide a |gdc| operation.}*/ static void pseudo_div (const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r, double& D); /*{\Xstatic implements division with remainder on polynomials of the ring |double[x]|: $D*f = g*q + r$. \precond |double| is a unique factorization domain, i.e., there exists a |gcd| operation and an integral division operation on |double|.}*/ static void euclidean_div (const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r); /*{\Xstatic implements division with remainder on polynomials of the ring |double[x]|: $f = g*q + r$. \precond |double| is a field, i.e., there exists a division operation on |double|. }*/ friend double to_double <> (const Polynomial& p); Polynomial& operator += (const Polynomial& p1) { this->copy_on_write(); int d = std::min(degree(),p1.degree()), i; for(i=0; i<=d; ++i) coeff(i) += p1[i]; while (i<=p1.degree()) this->ptr()->coeff.push_back(p1[i++]); reduce(); return (*this); } Polynomial& operator -= (const Polynomial& p1) { this->copy_on_write(); int d = std::min(degree(),p1.degree()), i; for(i=0; i<=d; ++i) coeff(i) -= p1[i]; while (i<=p1.degree()) this->ptr()->coeff.push_back(-p1[i++]); reduce(); return (*this); } Polynomial& operator *= (const Polynomial& p1) { (*this)=(*this)*p1; return (*this); } Polynomial& operator /= (const Polynomial& p1) { (*this)=(*this)/p1; return (*this); } Polynomial& operator %= (const Polynomial& p1) { (*this)=(*this)%p1; return (*this); } //------------------------------------------------------------------ // SPECIALIZE_MEMBERS(int double) START Polynomial& operator += (const double& num) { this->copy_on_write(); coeff(0) += (double)num; return *this; } Polynomial& operator -= (const double& num) { this->copy_on_write(); coeff(0) -= (double)num; return *this; } Polynomial& operator *= (const double& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (double)num; reduce(); return *this; } Polynomial& operator /= (const double& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (double)num; reduce(); return *this; } /* Polynomial& operator %= (const double& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (double)num; reduce(); return *this; } */ // SPECIALIZING_MEMBERS FOR const int& Polynomial& operator += (const int& num) { this->copy_on_write(); coeff(0) += (double)num; return *this; } Polynomial& operator -= (const int& num) { this->copy_on_write(); coeff(0) -= (double)num; return *this; } Polynomial& operator *= (const int& num) { this->copy_on_write(); for(int i=0; i<=degree(); ++i) coeff(i) *= (double)num; reduce(); return *this; } Polynomial& operator /= (const int& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) /= (double)num; reduce(); return *this; } /* Polynomial& operator %= (const int& num) { this->copy_on_write(); CGAL_assertion(num!=0); for(int i=0; i<=degree(); ++i) coeff(i) %= (double)num; reduce(); return *this; } */ // SPECIALIZE_MEMBERS(int double) END //------------------------------------------------------------------ void minus_offsetmult(const Polynomial& p, const double& b, int k) { CGAL_assertion(!this->is_shared()); Polynomial s(size_type(p.degree()+k+1)); // zero entries for (int i=k; i <= s.degree(); ++i) s.coeff(i) = b*p[i-k]; operator-=(s); } }; /*{\Ximplementation This data type is implemented as an item type via a smart pointer scheme. The coefficients are stored in a vector of |double| entries. The simple arithmetic operations $+,-$ take time $O(d*T(double))$, multiplication is quadratic in the maximal degree of the arguments times $T(double)$, where $T(double)$ is the time for a corresponding operation on two instances of the ring type.}*/ //############ POLYNOMIAL< DOUBLE > ################################ // SPECIALIZE_CLASS(NT,int double) END template double to_double (const Polynomial&) { return 0; } template bool is_valid (const Polynomial& p) { return (CGAL::is_valid(p[0])); } template bool is_finite (const Polynomial& p) { return CGAL::is_finite(p[0]); } template CGAL::io_Operator io_tag(const Polynomial&) { return CGAL::io_Operator(); } template inline Polynomial operator - (const Polynomial& p) { CGAL_assertion(p.degree()>=0); Polynomial res(std::make_pair(p.coeffs().begin(),p.coeffs().end())); typename Polynomial::iterator it, ite=res.coeffs().end(); for(it=res.coeffs().begin(); it!=ite; ++it) *it = -*it; return res; } template Polynomial operator + (const Polynomial& p1, const Polynomial& p2) { typedef typename Polynomial::size_type size_type; CGAL_assertion(p1.degree()>=0 && p2.degree()>=0); bool p1d_smaller_p2d = p1.degree() < p2.degree(); int min,max,i; if (p1d_smaller_p2d) { min = p1.degree(); max = p2.degree(); } else { max = p1.degree(); min = p2.degree(); } Polynomial p( size_type(max + 1)); for (i = 0; i <= min; ++i ) p.coeff(i) = p1[i]+p2[i]; if (p1d_smaller_p2d) for (; i <= max; ++i ) p.coeff(i)=p2[i]; else /* p1d >= p2d */ for (; i <= max; ++i ) p.coeff(i)=p1[i]; p.reduce(); return p; } template Polynomial operator - (const Polynomial& p1, const Polynomial& p2) { typedef typename Polynomial::size_type size_type; CGAL_assertion(p1.degree()>=0 && p2.degree()>=0); bool p1d_smaller_p2d = p1.degree() < p2.degree(); int min,max,i; if (p1d_smaller_p2d) { min = p1.degree(); max = p2.degree(); } else { max = p1.degree(); min = p2.degree(); } Polynomial p( size_type(max+1) ); for (i = 0; i <= min; ++i ) p.coeff(i)=p1[i]-p2[i]; if (p1d_smaller_p2d) for (; i <= max; ++i ) p.coeff(i)= -p2[i]; else /* p1d >= p2d */ for (; i <= max; ++i ) p.coeff(i)= p1[i]; p.reduce(); return p; } template Polynomial operator * (const Polynomial& p1, const Polynomial& p2) { typedef typename Polynomial::size_type size_type; CGAL_assertion(p1.degree()>=0 && p2.degree()>=0); Polynomial p( size_type(p1.degree()+p2.degree()+1) ); // initialized with zeros for (int i=0; i <= p1.degree(); ++i) for (int j=0; j <= p2.degree(); ++j) p.coeff(i+j) += (p1[i]*p2[j]); p.reduce(); return p; } template inline Polynomial operator / (const Polynomial& p1, const Polynomial& p2) { typedef Number_type_traits Traits; typename Traits::Has_gcd has_gcd; return divop(p1,p2, has_gcd); } template inline Polynomial operator % (const Polynomial& p1, const Polynomial& p2) { typedef Number_type_traits Traits; typename Traits::Has_gcd has_gcd; return modop(p1,p2, has_gcd); } template Polynomial divop (const Polynomial& p1, const Polynomial& p2, Tag_false) { CGAL_assertion(!p2.is_zero()); if (p1.is_zero()) { return 0; } Polynomial q; Polynomial r; Polynomial::euclidean_div(p1,p2,q,r); CGAL_postcondition( (p2*q+r==p1) ); return q; } template Polynomial divop (const Polynomial& p1, const Polynomial& p2, Tag_true) { CGAL_assertion(!p2.is_zero()); if (p1.is_zero()) return 0; Polynomial q,r; NT D; Polynomial::pseudo_div(p1,p2,q,r,D); CGAL_postcondition( (p2*q+r==p1*Polynomial(D)) ); return q/=D; } template Polynomial modop (const Polynomial& p1, const Polynomial& p2, Tag_false) { CGAL_assertion(!p2.is_zero()); if (p1.is_zero()) return 0; Polynomial q,r; Polynomial::euclidean_div(p1,p2,q,r); CGAL_postcondition( (p2*q+r==p1) ); return r; } template Polynomial modop (const Polynomial& p1, const Polynomial& p2, Tag_true) { CGAL_assertion(!p2.is_zero()); if (p1.is_zero()) return 0; Polynomial q,r; NT D; Polynomial::pseudo_div(p1,p2,q,r,D); CGAL_postcondition( (p2*q+r==p1*Polynomial(D)) ); return q/=D; } template inline Polynomial gcd(const Polynomial& p1, const Polynomial& p2) { return Polynomial::gcd(p1,p2); } template bool operator == (const Polynomial& p1, const Polynomial& p2) { return ( (p1-p2).sign() == CGAL::ZERO ); } template bool operator != (const Polynomial& p1, const Polynomial& p2) { return ( (p1-p2).sign() != CGAL::ZERO ); } template bool operator < (const Polynomial& p1, const Polynomial& p2) { return ( (p1-p2).sign() == CGAL::NEGATIVE ); } template bool operator <= (const Polynomial& p1, const Polynomial& p2) { return ( (p1-p2).sign() != CGAL::POSITIVE ); } template bool operator > (const Polynomial& p1, const Polynomial& p2) { return ( (p1-p2).sign() == CGAL::POSITIVE ); } template bool operator >= (const Polynomial& p1, const Polynomial& p2) { return ( (p1-p2).sign() != CGAL::NEGATIVE ); } template CGAL::Sign sign(const Polynomial& p) { return p.sign(); } //------------------------------------------------------------------ // SPECIALIZE_FUNCTION(NT,int double) START // SPECIALIZING inline to : // lefthand side inline Polynomial operator + (const int& num, const Polynomial& p2) { return (Polynomial(num) + p2); } inline Polynomial operator - (const int& num, const Polynomial& p2) { return (Polynomial(num) - p2); } inline Polynomial operator * (const int& num, const Polynomial& p2) { return (Polynomial(num) * p2); } inline Polynomial operator / (const int& num, const Polynomial& p2) { return (Polynomial(num)/p2); } inline Polynomial operator % (const int& num, const Polynomial& p2) { return (Polynomial(num)%p2); } // righthand side inline Polynomial operator + (const Polynomial& p1, const int& num) { return (p1 + Polynomial(num)); } inline Polynomial operator - (const Polynomial& p1, const int& num) { return (p1 - Polynomial(num)); } inline Polynomial operator * (const Polynomial& p1, const int& num) { return (p1 * Polynomial(num)); } inline Polynomial operator / (const Polynomial& p1, const int& num) { return (p1 / Polynomial(num)); } inline Polynomial operator % (const Polynomial& p1, const int& num) { return (p1 % Polynomial(num)); } // lefthand side inline bool operator == (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::ZERO );} inline bool operator != (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::ZERO );} inline bool operator < (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::NEGATIVE );} inline bool operator <= (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::POSITIVE );} inline bool operator > (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::POSITIVE );} inline bool operator >= (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::NEGATIVE );} // righthand side inline bool operator == (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() == CGAL::ZERO );} inline bool operator != (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() != CGAL::ZERO );} inline bool operator < (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() == CGAL::NEGATIVE );} inline bool operator <= (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() != CGAL::POSITIVE );} inline bool operator > (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() == CGAL::POSITIVE );} inline bool operator >= (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() != CGAL::NEGATIVE );} // SPECIALIZING pure int params: // lefthand side template Polynomial operator + (const int& num, const Polynomial& p2) { return (Polynomial(num) + p2); } template Polynomial operator - (const int& num, const Polynomial& p2) { return (Polynomial(num) - p2); } template Polynomial operator * (const int& num, const Polynomial& p2) { return (Polynomial(num) * p2); } template Polynomial operator / (const int& num, const Polynomial& p2) { return (Polynomial(num)/p2); } template Polynomial operator % (const int& num, const Polynomial& p2) { return (Polynomial(num)%p2); } // righthand side template Polynomial operator + (const Polynomial& p1, const int& num) { return (p1 + Polynomial(num)); } template Polynomial operator - (const Polynomial& p1, const int& num) { return (p1 - Polynomial(num)); } template Polynomial operator * (const Polynomial& p1, const int& num) { return (p1 * Polynomial(num)); } template Polynomial operator / (const Polynomial& p1, const int& num) { return (p1 / Polynomial(num)); } template Polynomial operator % (const Polynomial& p1, const int& num) { return (p1 % Polynomial(num)); } // lefthand side template bool operator == (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::ZERO );} template bool operator != (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::ZERO );} template bool operator < (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::NEGATIVE );} template bool operator <= (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::POSITIVE );} template bool operator > (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::POSITIVE );} template bool operator >= (const int& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::NEGATIVE );} // righthand side template bool operator == (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() == CGAL::ZERO );} template bool operator != (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() != CGAL::ZERO );} template bool operator < (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() == CGAL::NEGATIVE );} template bool operator <= (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() != CGAL::POSITIVE );} template bool operator > (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() == CGAL::POSITIVE );} template bool operator >= (const Polynomial& p, const int& num) { return ( (p-Polynomial(num)).sign() != CGAL::NEGATIVE );} // SPECIALIZING inline to : // lefthand side inline Polynomial operator + (const double& num, const Polynomial& p2) { return (Polynomial(num) + p2); } inline Polynomial operator - (const double& num, const Polynomial& p2) { return (Polynomial(num) - p2); } inline Polynomial operator * (const double& num, const Polynomial& p2) { return (Polynomial(num) * p2); } inline Polynomial operator / (const double& num, const Polynomial& p2) { return (Polynomial(num)/p2); } inline Polynomial operator % (const double& num, const Polynomial& p2) { return (Polynomial(num)%p2); } // righthand side inline Polynomial operator + (const Polynomial& p1, const double& num) { return (p1 + Polynomial(num)); } inline Polynomial operator - (const Polynomial& p1, const double& num) { return (p1 - Polynomial(num)); } inline Polynomial operator * (const Polynomial& p1, const double& num) { return (p1 * Polynomial(num)); } inline Polynomial operator / (const Polynomial& p1, const double& num) { return (p1 / Polynomial(num)); } inline Polynomial operator % (const Polynomial& p1, const double& num) { return (p1 % Polynomial(num)); } // lefthand side inline bool operator == (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::ZERO );} inline bool operator != (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::ZERO );} inline bool operator < (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::NEGATIVE );} inline bool operator <= (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::POSITIVE );} inline bool operator > (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::POSITIVE );} inline bool operator >= (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::NEGATIVE );} // righthand side inline bool operator == (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() == CGAL::ZERO );} inline bool operator != (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() != CGAL::ZERO );} inline bool operator < (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() == CGAL::NEGATIVE );} inline bool operator <= (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() != CGAL::POSITIVE );} inline bool operator > (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() == CGAL::POSITIVE );} inline bool operator >= (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() != CGAL::NEGATIVE );} // SPECIALIZING pure double params: // lefthand side template Polynomial operator + (const double& num, const Polynomial& p2) { return (Polynomial(num) + p2); } template Polynomial operator - (const double& num, const Polynomial& p2) { return (Polynomial(num) - p2); } template Polynomial operator * (const double& num, const Polynomial& p2) { return (Polynomial(num) * p2); } template Polynomial operator / (const double& num, const Polynomial& p2) { return (Polynomial(num)/p2); } template Polynomial operator % (const double& num, const Polynomial& p2) { return (Polynomial(num)%p2); } // righthand side template Polynomial operator + (const Polynomial& p1, const double& num) { return (p1 + Polynomial(num)); } template Polynomial operator - (const Polynomial& p1, const double& num) { return (p1 - Polynomial(num)); } template Polynomial operator * (const Polynomial& p1, const double& num) { return (p1 * Polynomial(num)); } template Polynomial operator / (const Polynomial& p1, const double& num) { return (p1 / Polynomial(num)); } template Polynomial operator % (const Polynomial& p1, const double& num) { return (p1 % Polynomial(num)); } // lefthand side template bool operator == (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::ZERO );} template bool operator != (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::ZERO );} template bool operator < (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::NEGATIVE );} template bool operator <= (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::POSITIVE );} template bool operator > (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::POSITIVE );} template bool operator >= (const double& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::NEGATIVE );} // righthand side template bool operator == (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() == CGAL::ZERO );} template bool operator != (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() != CGAL::ZERO );} template bool operator < (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() == CGAL::NEGATIVE );} template bool operator <= (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() != CGAL::POSITIVE );} template bool operator > (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() == CGAL::POSITIVE );} template bool operator >= (const Polynomial& p, const double& num) { return ( (p-Polynomial(num)).sign() != CGAL::NEGATIVE );} // SPECIALIZE_FUNCTION ORIGINAL // lefthand side template Polynomial operator + (const NT& num, const Polynomial& p2) { return (Polynomial(num) + p2); } template Polynomial operator - (const NT& num, const Polynomial& p2) { return (Polynomial(num) - p2); } template Polynomial operator * (const NT& num, const Polynomial& p2) { return (Polynomial(num) * p2); } template Polynomial operator / (const NT& num, const Polynomial& p2) { return (Polynomial(num)/p2); } template Polynomial operator % (const NT& num, const Polynomial& p2) { return (Polynomial(num)%p2); } // righthand side template Polynomial operator + (const Polynomial& p1, const NT& num) { return (p1 + Polynomial(num)); } template Polynomial operator - (const Polynomial& p1, const NT& num) { return (p1 - Polynomial(num)); } template Polynomial operator * (const Polynomial& p1, const NT& num) { return (p1 * Polynomial(num)); } template Polynomial operator / (const Polynomial& p1, const NT& num) { return (p1 / Polynomial(num)); } template Polynomial operator % (const Polynomial& p1, const NT& num) { return (p1 % Polynomial(num)); } // lefthand side template bool operator == (const NT& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::ZERO );} template bool operator != (const NT& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::ZERO );} template bool operator < (const NT& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::NEGATIVE );} template bool operator <= (const NT& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::POSITIVE );} template bool operator > (const NT& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() == CGAL::POSITIVE );} template bool operator >= (const NT& num, const Polynomial& p) { return ( (Polynomial(num)-p).sign() != CGAL::NEGATIVE );} // righthand side template bool operator == (const Polynomial& p, const NT& num) { return ( (p-Polynomial(num)).sign() == CGAL::ZERO );} template bool operator != (const Polynomial& p, const NT& num) { return ( (p-Polynomial(num)).sign() != CGAL::ZERO );} template bool operator < (const Polynomial& p, const NT& num) { return ( (p-Polynomial(num)).sign() == CGAL::NEGATIVE );} template bool operator <= (const Polynomial& p, const NT& num) { return ( (p-Polynomial(num)).sign() != CGAL::POSITIVE );} template bool operator > (const Polynomial& p, const NT& num) { return ( (p-Polynomial(num)).sign() == CGAL::POSITIVE );} template bool operator >= (const Polynomial& p, const NT& num) { return ( (p-Polynomial(num)).sign() != CGAL::NEGATIVE );} // SPECIALIZE_FUNCTION(NT,int double) END //------------------------------------------------------------------ template void print_monomial(std::ostream& os, const NT& n, int i) { if (i==0) os << n; if (i==1) os << n << "R"; if (i>1) os << n << "R^" << i; } // I/O template std::ostream& operator << (std::ostream& os, const Polynomial& p) { int i; switch( os.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : os << p.degree() << ' '; for(i=0; i<=p.degree(); ++i) os << p[i] << ' '; break; case CGAL::IO::BINARY : CGAL::write(os, p.degree()); for( i=0; i <= p.degree(); ++i) CGAL::write(os, p[i]); break; default: // i.e. PRETTY os << "Polynomial(" << p.degree() << ", "; for( i=0; i <= p.degree(); ++i) { os << p[i]; if (i < p.degree()) os << ", "; } os << ")"; // Alternative pretty format //print_monomial(os,p[p.degree()],p.degree()); //for(i=p.degree()-1; i>=0; --i) { // if (p[i]!=NT(0)) { os << " + "; print_monomial(os,p[i],i); } //} break; } return os; } template std::istream& operator >> (std::istream& is, Polynomial& p) { int i,d; char ch; NT c; bool pretty = false; switch( is.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : case CGAL::IO::PRETTY : is >> ch; if ( ch == 'P') { pretty = true; // Parse rest of "olynomial(" const char buffer[11] = "olynomial("; const char* p = buffer; is >> ch; while ( is && *p != '\0' && *p == ch) { is >> ch; ++p; } if ( *p != '\0') is.clear( std::ios::badbit); if ( ! is) return is; is.putback(ch); } else { is.putback(ch); } is >> d; if ( pretty) { is >> ch; if ( ch != ',') { is.clear( std::ios::badbit); return is; } } if (d < 0) { if ( pretty) { is >> ch; if ( ch != ')') { is.clear( std::ios::badbit); return is; } } if ( is) p = Polynomial(); } else { typename Polynomial::Vector coeffs(d+1); for( i = 0; i <= d; ++i) { is >> coeffs[i]; if ( pretty && i < d) { is >> ch; if ( ch != ',') { is.clear( std::ios::badbit); return is; } } } if ( pretty) { is >> ch; if ( ch != ')') { is.clear( std::ios::badbit); return is; } } if ( is) p = Polynomial(std::make_pair( coeffs.begin(), coeffs.end())); } break; case CGAL::IO::BINARY : CGAL::read(is, d); if (d < 0) p = Polynomial(); else { typename Polynomial::Vector coeffs(d+1); for(i=0; i<=d; ++i) { CGAL::read(is,c); coeffs[i]=c; } p = Polynomial(std::make_pair( coeffs.begin(), coeffs.end())); } break; } return is; } // SPECIALIZE_FUNCTION ORIGINAL template void Polynomial::euclidean_div( const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r) { r = f; r.copy_on_write(); int rd = r.degree(); int gd = g.degree(), qd; if ( rd < gd ) { q = Polynomial(NT(0)); } else { qd = rd - gd + 1; q = Polynomial(std::size_t(qd)); } while ( rd >= gd && !(r.is_zero())) { NT S = r[rd] / g[gd]; qd = rd-gd; q.coeff(qd) += S; r.minus_offsetmult(g,S,qd); rd = r.degree(); } CGAL_postcondition( f==q*g+r ); } template void Polynomial::pseudo_div( const Polynomial& f, const Polynomial& g, Polynomial& q, Polynomial& r, NT& D) { CGAL_NEF_TRACEN("pseudo_div "<(0); r = f; D = 1; CGAL_postcondition(Polynomial(D)*f==q*g+r); return; } // now we know fd >= gd and f>=g int qd=fd-gd, delta=qd+1, rd=fd; { q = Polynomial( std::size_t(delta) ); }; // workaround for SunPRO NT G = g[gd]; // highest order coeff of g D = G; while (--delta) D*=G; // D = G^delta Polynomial res = Polynomial(D)*f; CGAL_NEF_TRACEN(" pseudo_div start "<= 0) { NT F = res[rd]; // highest order coeff of res NT t = F/G; // ensured to be integer by multiplication of D q.coeff(qd) = t; // store q coeff res.minus_offsetmult(g,t,qd); if (res.is_zero()) break; rd = res.degree(); qd = rd - gd; } r = res; CGAL_postcondition(Polynomial(D)*f==q*g+r); CGAL_NEF_TRACEN(" returning "< Polynomial Polynomial::gcd( const Polynomial& p1, const Polynomial& p2) { CGAL_NEF_TRACEN("gcd("<(NT(1)); else return p2.abs(); if ( p2.is_zero() ) return p1.abs(); Polynomial f1 = p1.abs(); Polynomial f2 = p2.abs(); NT f1c = f1.content(), f2c = f2.content(); f1 /= f1c; f2 /= f2c; NT F = CGAL_NTS gcd(f1c,f2c); Polynomial q,r; NT M=1,D; bool first = true; while ( ! f2.is_zero() ) { Polynomial::pseudo_div(f1,f2,q,r,D); if (!first) M*=D; CGAL_NEF_TRACEV(f1);CGAL_NEF_TRACEV(f2);CGAL_NEF_TRACEV(q);CGAL_NEF_TRACEV(r);CGAL_NEF_TRACEV(M); r /= r.content(); f1=f2; f2=r; first=false; } CGAL_NEF_TRACEV(f1.content()); return Polynomial(F)*f1.abs(); } // SPECIALIZE_IMPLEMENTATION(NT,int double) END CGAL_END_NAMESPACE #endif // CGAL_POLYNOMIAL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_decorator.h0000644000175000017500000010377511344301501030516 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_DECORATOR_H #define CGAL_PM_DECORATOR_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=PMDecorator.man }*/ /*{\Msubst PM_decorator#PMDecorator PM_const_decorator#PMConstDecorator }*/ /*{\Manpage {PMDecorator}{}{Plane map manipulation}{D}}*/ template class PM_decorator : public PM_const_decorator { /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to examine and modify a plane map. |\Mvar| inherits from |PM_const_decorator| but provides additional manipulation operations.}*/ /*{\Mgeneralization PM_const_decorator}*/ public: /*{\Mtypes 3}*/ typedef PM_decorator Self; typedef PM_const_decorator Base; typedef HDS Plane_map; typedef typename HDS::Vertex_base Vertex_base; typedef typename HDS::Halfedge_base Halfedge_base; typedef typename HDS::Face_base Face_base; typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_iterator Face_iterator; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face_const_iterator Face_const_iterator; typedef typename Base::Hole_const_iterator Hole_const_iterator ; typedef typename Base::Isolated_vertex_const_iterator Isolated_vertex_const_iterator; typedef typename Base::Point_const_iterator Point_const_iterator; typedef typename Base::Mark Mark; typedef typename Base::Point Point; typedef typename Base::GenPtr GenPtr; /*{\Mtext Local types are handles, iterators and circulators of the following kind: |Vertex_handle|, |Vertex_iterator|, |Halfedge_handle|, |Halfedge_iterator|, |Face_handle|, |Face_iterator|. Additionally the following circulators are defined. The |circulators| can be constructed from the corresponding halfedge handles or iterators.}*/ typedef CircFromIt< Halfedge_iterator, move_halfedge_around_vertex > Halfedge_around_vertex_circulator; /*{\Mtypemember circulating the outgoing halfedges in $A(v)$.}*/ typedef CircFromIt< Halfedge_iterator, move_halfedge_around_face > Halfedge_around_face_circulator; /*{\Mtypemember circulating the halfedges in the face cycle of a face |f|.}*/ typedef typename Face::Hole_iterator Hole_iterator; /*{\Mtypemember iterating all holes of a face |f|. The type is convertible to |Halfedge_handle|.}*/ typedef typename Face::Isolated_vertex_iterator Isolated_vertex_iterator; /*{\Mtypemember iterating all isolated vertices of a face |f|. The type generalizes |Vertex_handle|.}*/ /* note: originally I had the mhavs, mhafs hardwired to Halfedge in this class scope. egcs 290.60 reacted with an internal compiler error; this recursive instatiation scheme works however! what a shitty world */ enum { BEFORE = -1, AFTER = 1 }; /*{\Menum insertion order labels.}*/ #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::phds; #endif /*{\Mcreation 3}*/ PM_decorator() : Base() {} PM_decorator(const PM_decorator& D) : Base((PM_const_decorator)D) {} PM_decorator& operator=(const PM_decorator& D) { Base::phds = ((PM_const_decorator)D).phds; return *this; } PM_decorator(Plane_map& p) : Base(p) {} /*{\Mcreate constructs a decorator working on |P|.}*/ #define BASE(t) { return Base::t; } Hole_const_iterator holes_begin(Face_const_handle f) const BASE(holes_begin(f)) Hole_const_iterator holes_end(Face_const_handle f) const BASE(holes_end(f)) Isolated_vertex_const_iterator isolated_vertices_begin(Face_const_handle f) const BASE(isolated_vertices_begin(f)) Isolated_vertex_const_iterator isolated_vertices_end(Face_const_handle f) const BASE(isolated_vertices_end(f)) Vertex_const_handle source(Halfedge_const_handle e) const BASE(source(e)) Vertex_const_handle target(Halfedge_const_handle e) const BASE(target(e)) Halfedge_const_handle twin(Halfedge_const_handle e) const BASE(twin(e)) bool is_isolated(Vertex_const_handle v) const BASE(is_isolated(v)) Halfedge_const_handle first_out_edge(Vertex_const_handle v) const BASE(first_out_edge(v)) Halfedge_const_handle last_out_edge(Vertex_const_handle v) const BASE(last_out_edge(v)) Halfedge_const_handle cyclic_adj_succ( Halfedge_const_handle e) const BASE(cyclic_adj_succ(e)) Halfedge_const_handle cyclic_adj_pred( Halfedge_const_handle e) const BASE(cyclic_adj_pred(e)) Halfedge_const_handle next(Halfedge_const_handle e) const BASE(next(e)) Halfedge_const_handle previous(Halfedge_const_handle e) const BASE(previous(e)) Face_const_handle face(Halfedge_const_handle e) const BASE(face(e)) Face_const_handle face(Vertex_const_handle v) const BASE(face(v)) const Mark& mark(Vertex_const_handle v) const BASE(mark(v)) const Mark& mark(Halfedge_const_handle e) const BASE(mark(e)) const Mark& mark(Face_const_handle f) const BASE(mark(f)) const Point& point(Vertex_const_handle v) const BASE(point(v)) const GenPtr& info(Vertex_const_handle v) const BASE(info(v)) const GenPtr& info(Halfedge_const_handle e) const BASE(info(e)) const GenPtr& info(Face_const_handle f) const BASE(info(f)) #undef BASE /*{\Moperations 3 3}*/ Plane_map& plane_map() const /*{\Mop returns the plane map decorated.}*/ { return *Base::phds; } void clear() const /*{\Mop reinitializes |P| to the empty map.}*/ { this->phds->clear(); } Vertex_handle source(Halfedge_handle e) const /*{\Mop returns the source of |e|.}*/ { return e->opposite()->vertex(); } Vertex_handle target(Halfedge_handle e) const /*{\Mop returns the target of |e|.}*/ { return e->vertex(); } Halfedge_handle twin(Halfedge_handle e) const /*{\Mop returns the twin of |e|.}*/ { return e->opposite(); } bool is_isolated(Vertex_handle v) const /*{\Mop returns |true| iff |v| is linked to the interior of a face. This is equivalent to the condition that $A(v) = \emptyset$.}*/ { return v->is_isolated(); } bool is_closed_at_source(Halfedge_handle e) const /*{\Mop returns |true| when |prev(e) == twin(e)|.}*/ { return e->prev() == e->opposite(); } Halfedge_handle first_out_edge(Vertex_handle v) const /*{\Mop returns a halfedge with source |v|. It's the starting point for the circular iteration over the halfedges with source |v|. \precond |!is_isolated(v)|.}*/ { return v->halfedge()->opposite(); } Halfedge_handle last_out_edge(Vertex_handle v) const /*{\Mop returns a the halfedge with source |v| that is the last in the circular iteration before encountering |first_out_edge(v)| again. \precond |!is_isolated(v)|.}*/ { return v->halfedge()->next(); } Halfedge_handle cas(Halfedge_handle e) const { return e->prev()->opposite(); } Halfedge_handle cap(Halfedge_handle e) const { return e->opposite()->next(); } Halfedge_handle cyclic_adj_succ(Halfedge_handle e) const { return cas(e); } /*{\Mop returns the edge after |e| in the cyclic ordered adjacency list of |source(e)|.}*/ Halfedge_handle cyclic_adj_pred(Halfedge_handle e) const { return cap(e); } /*{\Mop returns the edge before |e| in the cyclic ordered adjacency list of |source(e)|.}*/ Halfedge_handle adj_succ_at_source(Halfedge_handle e) const { if (e==last_out_edge(source(e))) return Halfedge_handle(); return cas(e); } // the edge of source(e) is the first in the adj list Halfedge_handle adj_pred_at_source(Halfedge_handle e) const { if (e==first_out_edge(source(e))) return Halfedge_handle(); return cap(e); } // the edge of source(e) is the first in the adj list Halfedge_handle next(Halfedge_handle e) const /*{\Mop returns the next edge in the face cycle containing |e|.}*/ { return e->next(); } Halfedge_handle previous(Halfedge_handle e) const /*{\Mop returns the previous edge in the face cycle containing |e|.}*/ { return e->prev(); } Face_handle face(Halfedge_handle e) const /*{\Mop returns the face incident to |e|.}*/ { return e->face(); } Face_handle face(Vertex_handle v) const /*{\Mop returns the face incident to |v|. \precond |is_isolated(v)|.}*/ { return v->face(); } Halfedge_handle halfedge(Face_handle f) const /*{\Mop returns a halfedge in the bounding face cycle of |f| (|Halfedge_handle()| if there is no bounding face cycle).}*/ { return f->halfedge(); } Vertex_iterator vertices_begin() const { return this->phds->vertices_begin(); } Halfedge_iterator halfedges_begin() const { return this->phds->halfedges_begin(); } Face_iterator faces_begin() const { return this->phds->faces_begin(); } Vertex_iterator vertices_end() const { return this->phds->vertices_end(); } Halfedge_iterator halfedges_end() const { return this->phds->halfedges_end(); } Face_iterator faces_end() const { return this->phds->faces_end(); } /*{\Mtext \headerline{Iteration} \setopdims{6.5cm}{0cm}}*/ Halfedge_around_vertex_circulator out_edges(Vertex_handle v) const /*{\Mop returns a circulator for the cyclic adjacency list of |v|.}*/ { return Halfedge_around_vertex_circulator(first_out_edge(v)); } Halfedge_around_face_circulator face_cycle(Face_handle f) const /*{\Mop returns a circulator for the outer face cycle of |f|.}*/ { return Halfedge_around_face_circulator(f->halfedge()); } Hole_iterator holes_begin(Face_handle f) const /*{\Mop returns an iterator for all holes in the interior of |f|. A |Hole_iterator| can be assigned to a |Halfedge_around_face_circulator|.}*/ { return f->fc_begin(); } Hole_iterator holes_end(Face_handle f) const /*{\Mop returns the past-the-end iterator of |f|.}*/ { return f->fc_end(); } Isolated_vertex_iterator isolated_vertices_begin(Face_handle f) const /*{\Mop returns an iterator for all isolated vertices in the interior of |f|.}*/ { return f->iv_begin(); } Isolated_vertex_iterator isolated_vertices_end(Face_handle f) const /*{\Mop returns the past the end iterator of |f|.}*/ { return f->iv_end(); } /*{\Mtext \headerline{Update Operations} \restoreopdims}*/ Vertex_handle new_vertex(const Vertex_base& vb = Vertex_base()) const /*{\Mop creates a new vertex.}*/ { Vertex_handle v = this->phds->vertices_push_back(vb); v->set_halfedge(Halfedge_handle()); return v; } Face_handle new_face(const Face_base& fb = Face_base()) const /*{\Mop creates a new face.}*/ { Face_handle f = this->phds->faces_push_back(fb); return f; } void link_as_outer_face_cycle(Face_handle f, Halfedge_handle e) const /*{\Mop makes |e| the entry point of the outer face cycle of |f| and makes |f| the face of all halfedges in the face cycle of |e|.}*/ { Halfedge_around_face_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) hfc->set_face(f); f->set_halfedge(e); } void link_as_hole(Face_handle f, Halfedge_handle e) const /*{\Mop makes |e| the entry point of a hole face cycle of |f| and makes |f| the face of all halfedges in the face cycle of |e|.}*/ { Halfedge_around_face_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) hfc->set_face(f); f->store_fc(e); } void link_as_isolated_vertex(Face_handle f, Vertex_handle v) const /*{\Mop makes |v| an isolated vertex within |f|.}*/ { f->store_iv(v); v->set_face(f); } void clear_face_cycle_entries(Face_handle f) const /*{\Mop removes all isolated vertices and halfedges that are entrie points into face cycles from the lists of |f|.}*/ { f->clear_all_entries(); } Halfedge_handle new_halfedge_pair(Vertex_handle v1, Vertex_handle v2, Halfedge_base hb = Halfedge_base()) const /*{\Mop creates a new pair of edges |(e1,e2)| representing |(v1,v2)| by appending the |ei| to |A(vi)| $(i=1,2)$.}*/ { Halfedge_handle e1 = this->phds->edges_push_back(hb,hb); Halfedge_handle e2 = e1->opposite(); e1->set_face(Face_handle()); e2->set_face(Face_handle()); if ( ! is_isolated(v1) ) set_adjacency_at_source_between(cap(first_out_edge(v1)),e1, first_out_edge(v1)); else close_tip_at_source(e1,v1); if ( ! is_isolated(v2) ) set_adjacency_at_source_between(cap(first_out_edge(v2)),e2, first_out_edge(v2)); else close_tip_at_source(e2,v2); return e1; } Halfedge_handle new_halfedge_pair(Halfedge_handle e1, Halfedge_handle e2, Halfedge_base hb = Halfedge_base(), int pos1 = AFTER, int pos2 = AFTER) const /*{\Mop creates a new pair of edges |(h1,h2)| representing |(source(e1),source(e2))| by inserting the |hi| before or after |ei| into the cyclic adjacency list of |source(ei)| depending on |posi| $(i=1,2)$ from |\Mname::BEFORE, \Mname::AFTER|.}*/ { Halfedge_handle er = this->phds->edges_push_back(hb,hb); Halfedge_handle ero = er->opposite(); er->set_face(Face_handle()); ero->set_face(Face_handle()); if (pos1 < 0) { // before e1 set_adjacency_at_source_between(cap(e1),er,e1); if ( e1 == first_out_edge(source(e1)) ) make_first_out_edge(er); // added 22/8/00 } else { // after e1 set_adjacency_at_source_between(e1,er,cas(e1)); } if (pos2 < 0) { // before e2 set_adjacency_at_source_between(cap(e2),ero,e2); if ( e2 == first_out_edge(source(e2)) ) make_first_out_edge(ero); } else { // after e2 set_adjacency_at_source_between(e2,ero,cas(e2)); } return er; } Halfedge_handle new_halfedge_pair(Halfedge_handle e, Vertex_handle v, Halfedge_base hb = Halfedge_base(), int pos = AFTER) const /*{\Mop creates a new pair of edges |(e1,e2)| representing |(source(e),v)| by inserting |e1| before or after |e| into the cyclic adjacency list of |source(e)| depending on |pos| from |\Mname::BEFORE, \Mname::AFTER| and appending |e2| to |A(v)|.}*/ { Halfedge_handle e_new = this->phds->edges_push_back(hb,hb); Halfedge_handle e_opp = e_new->opposite(); e_new->set_face(Face_handle()); e_opp->set_face(Face_handle()); if (pos < 0) { // before e set_adjacency_at_source_between(cap(e),e_new,e); if ( e == first_out_edge(source(e)) ) make_first_out_edge(e_new); } else // after e set_adjacency_at_source_between(e,e_new,cas(e)); if ( ! is_isolated(v) ) { Halfedge_handle e_first = first_out_edge(v); set_adjacency_at_source_between(cap(e_first),e_opp,e_first); } else close_tip_at_source(e_opp,v); return e_new; } Halfedge_handle new_halfedge_pair(Vertex_handle v, Halfedge_handle e, Halfedge_base hb = Halfedge_base(), int pos = AFTER) const /*{\Mop symmetric to the previous one.}*/ { return new_halfedge_pair(e,v,hb,pos)->opposite(); } void delete_halfedge_pair(Halfedge_handle e) const /*{\Mop deletes |e| and its twin and updates the adjacency at its source and its target.}*/ { remove_from_adj_list_at_source(e); remove_from_adj_list_at_source(e->opposite()); this->phds->edges_erase(e); } void delete_vertex(Vertex_handle v) const /*{\Mop deletes |v| and all outgoing edges |A(v)| as well as their twins. Updates the adjacency at the targets of the edges in |A(v)|.}*/ { if ( ! is_isolated(v) ) { Halfedge_handle e = first_out_edge(v); while ( e != cap(e) ) delete_halfedge_pair(cap(e)); delete_halfedge_pair(e); } this->phds->vertices_erase(v); } void delete_face(Face_handle f) const /*{\Mop deletes the face |f| without consideration of topological linkage.}*/ { this->phds->faces_erase(f); } bool has_outdeg_two(Vertex_handle v) const /*{\Mop return true when |v| has outdegree two.}*/ { if (v->is_isolated()) return false; Halfedge_handle e1 = v->halfedge(); Halfedge_handle e2 = e1->next()->opposite(); return (e1!=e2 && e2->next()->opposite()==e1); } void merge_halfedge_pairs_at_target(Halfedge_handle e) const /*{\Mop merges the halfedge pairs at |v = target(e)|. |e| and |twin(e)| are preserved, |next(e)|, |twin(next(e))| and |v| are deleted in the merger. \precond |v| has outdegree two. The adjacency at |source(e)| and |target(next(e))| is kept consistent.}*/ { CGAL_NEF_TRACEN("merge_halfedge_pairs_at_target "<opposite(), en = e->next(), eno = en->opposite(), enn = en->next(), enno = eno->prev(); Vertex_handle v = e->vertex(), vn = en->vertex(); CGAL_assertion(has_outdeg_two(v)); Face_handle f1 = en->face(), f2 = eno->face(); // transfer the opposite face cycles e-en-enn to e-enn if ( enn != eno ) { e->set_next(enn); enn->set_prev(e); eo->set_prev(enno); enno->set_next(eo); } else { e->set_next(eo); eo->set_prev(e); } // set vertex of e and deal with vertex-halfedge incidence e->set_vertex(vn); if (vn->halfedge()==en) vn->set_halfedge(e); if (en->is_hole_entry()) { f1->remove_fc(en); f1->store_fc(e); } if (eno->is_hole_entry()) { f2->remove_fc(eno); f2->store_fc(eo); } if (f1->halfedge() == en) f1->set_halfedge(e); if (f2->halfedge() == eno) f2->set_halfedge(eo); this->phds->vertices_erase(v); this->phds->edges_erase(en); } void flip_diagonal(Halfedge_handle e) const { Halfedge_handle r = twin(e); Halfedge_handle en = e->next(), enn= en->next(); Halfedge_handle rn = r->next(), rnn= rn->next(); CGAL_assertion( enn->next()==e && rnn->next()==r ); remove_from_adj_list_at_source(e); remove_from_adj_list_at_source(r); set_adjacency_at_source_between(enn,e,twin(en)); set_adjacency_at_source_between(rnn,r,twin(rn)); } /*{\Mtext \headerline{Incomplete topological update primitives}}*/ Halfedge_handle new_halfedge_pair_at_source (Halfedge_handle e, int pos = AFTER, Halfedge_base hb = Halfedge_base()) const /*{\Xop creates a new pair of edges |(e1,e2)| representing |(source(e),())| by inserting |e1| before or after |e| into cyclic adjacency list of |source(e)| depending on |pos| from |\Mname::BEFORE, \Mname::AFTER|.}*/ { Halfedge_handle e_new = this->phds->edges_push_back(hb,hb); if (pos < 0) // before e set_adjacency_at_source_between(cap(e),e_new,e); else // after e set_adjacency_at_source_between(e,e_new,cas(e)); return e_new; } Halfedge_handle new_halfedge_pair_at_source (Vertex_handle v, int pos = AFTER, Halfedge_base hb = Halfedge_base()) const /*{\Mop creates a new pair of edges |(e1,e2)| representing |(v,())| by inserting |e1| at the beginning (BEFORE) or end (AFTER) of adjacency list of |v|.}*/ { Halfedge_handle e1 = this->phds->edges_push_back(hb,hb); Halfedge_handle e2 = e1->opposite(); e1->set_face(Face_handle()); e2->set_face(Face_handle()); if ( ! is_isolated(v) ) { Halfedge_handle ef = first_out_edge(v); set_adjacency_at_source_between(cap(ef),e1,ef); if ( pos == BEFORE ) v->set_halfedge(e2); } else close_tip_at_source(e1,v); return e1; } void delete_halfedge_pair_at_source(Halfedge_handle e) const /*{\Mop deletes |e| and its twin and updates the adjacency at its source.}*/ { remove_from_adj_list_at_source(e); this->phds->edges_erase(e); } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) const /*{\Mop makes |v| the target of |e| and appends |twin(e)| to $A(v)$.}*/ { if ( ! is_isolated(v) ) set_adjacency_at_source_between(cap(first_out_edge(v)),twin(e), first_out_edge(v)); else close_tip_at_target(e,v); } Halfedge_handle new_halfedge_pair_without_vertices() const /*{\Mop inserts an open edge pair, and inits all link slots to their default handles.}*/ { Halfedge_handle e_new = this->phds->edges_push_back(Halfedge(),Halfedge()); return e_new; } void delete_vertex_only(Vertex_handle v) const /*{\Mop deletes |v| without consideration of adjacency.}*/ { this->phds->vertices_erase(v); } void delete_halfedge_pair_only(Halfedge_handle e) const /*{\Mop deletes |e| and its twin without consideration of adjacency.}*/ { this->phds->edges_erase(e); } void link_as_target_of(Halfedge_handle e, Vertex_handle v) const /*{\Mop makes |target(e) = v| and sets |e| as the first in-edge if |v| was isolated before.}*/ { e->set_vertex(v); if (v->halfedge() == Halfedge_handle()) v->set_halfedge(e); } void link_as_source_of(Halfedge_handle e, Vertex_handle v) const /*{\Mop makes |source(e) = v| and sets |e| as the first out-edge if |v| was isolated before.}*/ { link_as_target_of(e->opposite(),v); } void make_first_out_edge(Halfedge_handle e) const /*{\Mop makes |e| the first outgoing halfedge in the cyclic adjacency list of |source(e)|.}*/ { source(e)->set_halfedge(e->opposite()); } void set_adjacency_at_source_between(Halfedge_handle e, Halfedge_handle en) const /*{\Mop makes |e| and |en| neigbors in the cyclic ordered adjacency list around |v=source(e)|. \precond |source(e)==source(en)|.}*/ { CGAL_assertion(source(e)==source(en)); link_as_prev_next_pair(en->opposite(),e); } void set_adjacency_at_source_between(Halfedge_handle e1, Halfedge_handle e_between, Halfedge_handle e2) const /*{\Mop inserts |e_between| into the adjacency list around |source(e1)| between |e1| and |e2| and makes |source(e1)| the source of |e_between|. \precond |source(e1)==source(e2)|.}*/ { e_between->opposite()->set_vertex(source(e1)); set_adjacency_at_source_between(e1,e_between); set_adjacency_at_source_between(e_between,e2); } void close_tip_at_target(Halfedge_handle e, Vertex_handle v) const /*{\Mop sets |v| as target of |e| and closes the tip by setting the corresponding pointers such that |prev(twin(e)) == e| and |next(e) == twin(e)|.}*/ { link_as_target_of(e,v); link_as_prev_next_pair(e,e->opposite()); } void close_tip_at_source(Halfedge_handle e, Vertex_handle v) const /*{\Mop sets |v| as source of |e| and closes the tip by setting the corresponding pointers such that |prev(e) == twin(e)| and |next(twin(e)) == e|.}*/ { close_tip_at_target(e->opposite(),v); } void remove_from_adj_list_at_source(Halfedge_handle e) const /*{\Mop removes a halfedge pair |(e,twin(e)| from the adjacency list of |source(e)|. Afterwards |next(prev(e))==next(twin(e))| and |first_out_edge(source(e))| is valid if |degree(source(v))>1| before the operation.}*/ { Vertex_handle vs = source(e); if ( is_closed_at_source(e) ) { // last outgoing vs->set_halfedge(Halfedge_handle()); } else { if (e == first_out_edge(vs)) vs->set_halfedge(e->prev()); set_adjacency_at_source_between(cap(e),cas(e)); } } void unlink_as_hole(Halfedge_handle e) const /*{\Mop removes |e|'s existence as an face cycle entry point of |face(e)|. Does not update the face links of the corresponding face cycle halfedges.}*/ { e->face()->remove_fc(e); } void unlink_as_isolated_vertex(Vertex_handle v) const /*{\Mop removes |v|'s existence as an isolated vertex in |face(v)|. Does not update |v|'s face link.}*/ { v->face()->remove_iv(v); } void link_as_prev_next_pair(Halfedge_handle e1, Halfedge_handle e2) const /*{\Mop makes |e1| and |e2| adjacent in the face cycle $\ldots-|e1-e2|-\ldots$. Afterwards |e1 = previous(e2)| and |e2 = next(e1)|.}*/ { e1->set_next(e2); e2->set_prev(e1); } void set_face(Halfedge_handle e, Face_handle f) const /*{\Mop makes |f| the face of |e|.}*/ { e->set_face(f); } void set_face(Vertex_handle v, Face_handle f) const /*{\Mop makes |f| the face of |v|.}*/ { v->set_face(f); } void set_halfedge(Face_handle f, Halfedge_handle e) const /*{\Mop makes |e| entry edge in the outer face cycle of |f|.}*/ { f->set_halfedge(e); } void set_hole(Face_handle f, Halfedge_handle e) const /*{\Mop makes |e| entry edge in a hole face cycle of |f|.}*/ { f->store_fc(e); } void set_isolated_vertex(Face_handle f, Vertex_handle v) const /*{\Mop makes |v| an isolated vertex of |f|.}*/ { f->store_iv(v); } /*{\Mtext \headerline{Cloning}\setopdims{2cm}{1cm}}*/ void clone(const Plane_map& H) const; /*{\Mop clones |H| into |P|. Afterwards |P| is a copy of |H|.\\ \precond |H.check_integrity_and_topological_planarity()| and |P| is empty.}*/ #if ! defined(CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG) template void clone_skeleton(const Plane_map& H, const LINKDA& L) const; /*{\Mop clones the skeleton of |H| into |P|. Afterwards |P| is a copy of |H|. The link data accessor allows to transfer information from the old to the new objects. It needs the function call operators:\\ |void operator()(Vertex_handle vn, Ver\-tex_\-const_\-handle vo) const|\\ |void operator()(Halfedge_handle hn, Half\-edge_\-const_\-handle ho) const|\\ where |vn,hn| are the cloned objects and |vo,ho| are the original objects.\\ \precond |H.check_integrity_and_topological_planarity()| and |P| is empty.}*/ #else template void clone_skeleton(const HDS& H, const LINKDA& L) const { CGAL_assertion(number_of_vertices()==0&& number_of_halfedges()==0&& number_of_faces()==0); PM_const_decorator DC(H); CGAL_assertion((DC.check_integrity_and_topological_planarity(),1)); CGAL::Unique_hash_map Vnew; CGAL::Unique_hash_map Hnew; /* First clone all objects and store correspondance in the two maps.*/ Vertex_const_iterator vit, vend = H.vertices_end(); for (vit = H.vertices_begin(); vit!=vend; ++vit) { Vertex_handle v = this->phds->vertices_push_back(Vertex_base()); Vnew[vit] = v; } Halfedge_const_iterator eit, eend = H.halfedges_end(); for (eit = H.halfedges_begin(); eit!=eend; ++(++eit)) { Halfedge_handle e = this->phds->edges_push_back(Halfedge_base(),Halfedge_base()); Hnew[eit] = e; Hnew[eit->opposite()] = e->opposite(); } /* Now copy topology.*/ Vertex_iterator vit2, vend2 = vertices_end(); for (vit = H.vertices_begin(), vit2 = vertices_begin(); vit2!=vend2; ++vit, ++vit2) { mark(vit2) = DC.mark(vit); point(vit2) = DC.point(vit); if ( !DC.is_isolated(vit) ) vit2->set_halfedge(Hnew[vit->halfedge()]); L(vit2,vit); } Halfedge_iterator eit2, eend2 = this->phds->halfedges_end(); for (eit = H.halfedges_begin(), eit2 = halfedges_begin(); eit2!=eend2; ++eit, ++eit2) { eit2->set_prev(Hnew[eit->prev()]); eit2->set_next(Hnew[eit->next()]); eit2->set_vertex(Vnew[eit->vertex()]); mark(eit2) = DC.mark(eit); // eit2->set_face(Face_handle((Face*)&*(eit->face()))); L(eit2,eit); // link to face of original } } #endif void reflecting_inversion() /*{\Xop inverts the topological links corresponding to a reflecting inversion. Assume that the plane map is embedded into the x-y plane and one looks at it from the tip of the positive z-axis in space. Now change your view point to a point on the negative z-axis. As a consequence faces are right of edges and adjacency list are clockwise order-preserving. This operation recreates our embedding invariant (faces are left of edges and adjacency lists are counterclockwise order-preserving).}*/ { // swap faces: Halfedge_iterator e; for (e = halfedges_begin(); e != halfedges_end(); ++(++e)) { Face_handle f1 = face(e), f2 = face(twin(e)); e->set_face(f2); twin(e)->set_face(f1); } // reverse adjacency lists: std::vector A; Vertex_iterator v; for (v = vertices_begin(); v != vertices_end(); ++v) { if ( is_isolted(v) ) continue; Halfedge_around_vertex_circulator h = out_edges(v), hend(h); CGAL_For_all(h,hend) A.push_back(h); int n = A.size(); for (int i=0; ipoint(); } Mark& mark(Vertex_handle v) const /*{\Mop returns the mark of |v|.}*/ { return v->mark(); } Mark& mark(Halfedge_handle e) const /*{\Mop returns the mark of |e|.}*/ { if (&*e < &*(e->opposite())) return e->mark(); else return e->opposite()->mark(); } // we store the mark in the container with smaller memory address ! Mark& mark(Face_handle f) const /*{\Mop returns the mark of |f|.}*/ { return f->mark(); } void set_marks_in_face_cycle(Halfedge_handle e, Mark m) const { Halfedge_around_face_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) { mark(hfc) = mark(target(hfc)) = m; } } GenPtr& info(Vertex_handle v) const /*{\Mop returns a generic information slot.}*/ { return v->info(); } GenPtr& info(Halfedge_handle e) const /*{\Mop returns a generic information slot.}*/ { return e->info(); } GenPtr& info(Face_handle f) const /*{\Mop returns a generic information slot.}*/ { return f->info(); } }; // PM_decorator template void PM_decorator::clone(const HDS& H) const { CGAL_assertion(this->number_of_vertices()==0&& this->number_of_halfedges()==0&& this->number_of_faces()==0); PM_const_decorator DC(H); CGAL_assertion((DC.check_integrity_and_topological_planarity(),1)); CGAL::Unique_hash_map Vnew; CGAL::Unique_hash_map Hnew; CGAL::Unique_hash_map Fnew; /* First clone all objects and store correspondance in three maps.*/ Vertex_const_iterator vit, vend = H.vertices_end(); for (vit = H.vertices_begin(); vit!=vend; ++vit) Vnew[vit] = this->phds->vertices_push_back(Vertex_base()); Halfedge_const_iterator eit, eend = H.halfedges_end(); for (eit = H.halfedges_begin(); eit!=eend; ++(++eit)) { Hnew[eit] = this->phds->edges_push_back(Halfedge_base(),Halfedge_base()); Hnew[eit->opposite()] = Hnew[eit]->opposite(); } Face_const_iterator fit, fend = H.faces_end(); for (fit = H.faces_begin(); fit!=fend; ++fit) { Fnew[fit] = this->phds->faces_push_back(Face_base()); } /* Now copy topology.*/ Vertex_iterator vit2, vend2 = this->phds->vertices_end(); for (vit = H.vertices_begin(), vit2 = vertices_begin(); vit2!=vend2; ++vit, ++vit2) { mark(vit2) = DC.mark(vit); point(vit2) = DC.point(vit); if ( DC.is_isolated(vit) ) vit2->set_face(Fnew[vit->face()]); else vit2->set_halfedge(Hnew[vit->halfedge()]); } Halfedge_iterator eit2, eend2 = this->phds->halfedges_end(); for (eit = H.halfedges_begin(), eit2 = halfedges_begin(); eit2!=eend2; ++eit, ++eit2) { eit2->set_prev(Hnew[eit->prev()]); eit2->set_next(Hnew[eit->next()]); eit2->set_vertex(Vnew[eit->vertex()]); eit2->set_face(Fnew[eit->face()]); mark(eit2) = DC.mark(eit); } Face_iterator fit2, fend2 = faces_end(); for (fit = H.faces_begin(), fit2 = faces_begin(); fit2!=fend2; ++fit, ++fit2) { fit2->set_halfedge(Hnew[fit->halfedge()]); // outer face cycle Hole_const_iterator fcit, fcend = holes_end(fit); for (fcit = holes_begin(fit); fcit!=fcend; ++fcit) { fit2->store_fc(Hnew[fcit]); } // hole face cycles Isolated_vertex_const_iterator ivit; for (ivit = isolated_vertices_begin(fit); ivit != isolated_vertices_end(fit); ++ivit) fit2->store_iv(Vnew[ivit]); // isolated vertices in the interior mark(fit2) = DC.mark(fit); } CGAL_assertion((this->check_integrity_and_topological_planarity(),1)); } #if ! defined(CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG) template template void PM_decorator:: clone_skeleton(const HDS& H, const LINKDA& L) const { CGAL_assertion(this->number_of_vertices()==0&& this->number_of_halfedges()==0&& this->number_of_faces()==0); PM_const_decorator DC(H); CGAL_assertion((DC.check_integrity_and_topological_planarity(),1)); CGAL::Unique_hash_map Vnew; CGAL::Unique_hash_map Hnew; /* First clone all objects and store correspondance in the two maps.*/ Vertex_const_iterator vit, vend = H.vertices_end(); for (vit = H.vertices_begin(); vit!=vend; ++vit) { Vertex_handle v = this->phds->vertices_push_back(Vertex_base()); Vnew[vit] = v; } Halfedge_const_iterator eit, eend = H.halfedges_end(); for (eit = H.halfedges_begin(); eit!=eend; ++(++eit)) { Halfedge_handle e = this->phds->edges_push_back(Halfedge_base(),Halfedge_base()); Hnew[eit] = e; Hnew[eit->opposite()] = e->opposite(); } /* Now copy topology.*/ Vertex_iterator vit2, vend2 = vertices_end(); for (vit = H.vertices_begin(), vit2 = vertices_begin(); vit2!=vend2; ++vit, ++vit2) { mark(vit2) = DC.mark(vit); point(vit2) = DC.point(vit); if ( !DC.is_isolated(vit) ) vit2->set_halfedge(Hnew[vit->halfedge()]); L(vit2,vit); } Halfedge_iterator eit2, eend2 = this->phds->halfedges_end(); for (eit = H.halfedges_begin(), eit2 = halfedges_begin(); eit2!=eend2; ++eit, ++eit2) { eit2->set_prev(Hnew[eit->prev()]); eit2->set_next(Hnew[eit->next()]); eit2->set_vertex(Vnew[eit->vertex()]); mark(eit2) = DC.mark(eit); // eit2->set_face(Face_handle((Face*)&*(eit->face()))); L(eit2,eit); // link to face of original } } #endif CGAL_END_NAMESPACE #endif //CGAL_PM_DECORATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_explorer.h0000644000175000017500000001262611344301501030366 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_explorer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_EXPLORER_H #define CGAL_PM_EXPLORER_H #include #include CGAL_BEGIN_NAMESPACE /*{\Moptions print_title=yes }*/ /*{\Moptions outfile=Explorer.man }*/ /*{\Msubst PM_explorer#Explorer }*/ /*{\Manpage {PM_explorer}{}{Plane map exploration}{E}}*/ /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to explore the structure of the plane map underlying the Nef polyhedron. It inherits all topological adjacency exploration operations from |PMConstDecorator|. |\Mname| additionally allows one to explore the geometric embedding. The position of each vertex is given by a so-called extended point, which is either a standard affine point or the tip of a ray touching an infinimaximal square frame centered at the origin. A vertex |v| is called a \emph{standard} vertex if its embedding is a \emph{standard} point and \emph{non-standard} if its embedding is a \emph{non-standard} point. By the straightline embedding of their source and target vertices, edges correspond to either affine segments, rays or lines or are part of the bounding frame. \displayeps{extsegs}{Extended geometry: standard vertices are marked by S, non-standard vertices are marked by N. \textbf{A}: The possible embeddings of edges: an affine segment s1, an affine ray s2, an affine line s3. \textbf{B}: A plane map embedded by extended geometry: note that the frame is arbitrarily large, the 6 vertices on the frame are at infinity, the two faces represent a geometrically unbounded area, however they are topologically closed by the frame edges. No standard point can be placed outside the frame.}{10cm} }*/ /*{\Mgeneralization Topological_explorer}*/ template class PM_explorer : public PMCDEC { typedef PMCDEC Base; typedef PM_explorer Self; const GEOM* pK; public: /*{\Mtypes 4}*/ typedef PMCDEC Topological_explorer; /*{\Mtypemember The base class.}*/ typedef typename PMCDEC::Plane_map Plane_map; /*{\Xtypemember equals |PMCDEC::Plane_map|, the underlying plane map type.}*/ typedef GEOM Geometry; /*{\Xtypemember equals |GEOM|. Add link to GEOM model.\\ \precond |Geometry::Point_2| equals |Plane_map::Point|. }*/ typedef typename GEOM::Standard_point_2 Point; /*{\Mtypemember the point type of finite vertices.}*/ typedef typename GEOM::Standard_ray_2 Ray; /*{\Mtypemember the ray type of vertices on the frame.}*/ typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Vertex_const_iterator Vertex_const_iterator; typedef typename Base::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Base::Face_const_iterator Face_const_iterator; typedef typename Base::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; typedef typename Base::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename Base::Isolated_vertex_const_iterator Isolated_vertex_const_iterator; typedef typename Base::Hole_const_iterator Hole_const_iterator; /*{\Mtext Iterators, handles, and circulators are inherited from |Topological_explorer|.}*/ /*{\Mcreation 3}*/ /*{\Mtext |\Mname| is copy constructable and assignable. An object can be obtained via the |Nef_polyhedron_2::explorer()| method of |Nef_polyhedron_2|.}*/ PM_explorer(const Self& E) : Base(E), pK(E.pK) {} Self& operator=(const Self& E) { Base::operator=(E); pK=E.pK; return *this; } PM_explorer(const Plane_map& P, const Geometry& k = Geometry()) : Base(P), pK(&k) {} /*{\Xcreate constructs a plane map explorer working on |P| with geometric predicates used from |k|.}*/ /*{\Moperations 2 }*/ bool is_standard(Vertex_const_handle v) const /*{\Mop returns true iff |v|'s position is a standard point.}*/ { return pK->is_standard(Base::point(v)); } Point point(Vertex_const_handle v) const /*{\Mop returns the standard point that is the embedding of |v|. \precond |\Mvar.is_standard(v)|.}*/ { return pK->standard_point(Base::point(v)); } Ray ray(Vertex_const_handle v) const /*{\Mop returns the ray defining the non-standard point on the frame. \precond |!\Mvar.is_standard(v)|.}*/ { return pK->standard_ray(Base::point(v)); } bool is_frame_edge(Halfedge_const_handle e) const /*{\Mop returns true iff |e| is part of the infinimaximal frame.}*/ { return ( face(e) == this->faces_begin() || face(twin(e)) == this->faces_begin() ); } }; // PM_explorer CGAL_END_NAMESPACE #endif // CGAL_PM_EXPLORER_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/HalfedgeDS_items_decorator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/HalfedgeDS_items0000644000175000017500000004563611344301501031042 0ustar debiandebian// Copyright (c) 1997 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/HalfedgeDS_items_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_ITEMS_DECORATOR_H #define CGAL_HALFEDGEDS_ITEMS_DECORATOR_H 1 #include CGAL_BEGIN_NAMESPACE template < class p_HDS > class HalfedgeDS_items_decorator { public: // TYPES // ---------------------------------- typedef p_HDS HDS; typedef p_HDS HalfedgeDS; typedef typename HDS::Traits Traits; typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Face_iterator Face_iterator; typedef typename HDS::Face_const_iterator Face_const_iterator; typedef typename HDS::size_type size_type; typedef typename HDS::difference_type difference_type; typedef typename HDS::iterator_category iterator_category; // The following types are equal to either `Tag_true' or `Tag_false', // dependent whether the named feature is supported or not. typedef typename HDS::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename HDS::Supports_halfedge_prev Supports_halfedge_prev; typedef typename HDS::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename HDS::Supports_halfedge_face Supports_halfedge_face; typedef typename HDS::Supports_face_halfedge Supports_face_halfedge; typedef typename HDS::Supports_removal Supports_removal; protected: typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Halfedge::Base_base HBase_base; typedef typename Face::Base FBase; public: // CREATION // ---------------------------------- HalfedgeDS_items_decorator() {} // Access Functions // ---------------------------------- Halfedge_handle get_vertex_halfedge( Vertex_handle v) const { // returns the incident halfedge of v if supported, // `Halfedge_handle()' otherwise. return get_vertex_halfedge( v, Supports_vertex_halfedge()); } Vertex_handle get_vertex( Halfedge_handle h) const { // returns the incident vertex of h if supported, // `Vertex_handle()' otherwise. return get_vertex( h, Supports_halfedge_vertex()); } Halfedge_handle get_prev( Halfedge_handle h) const { // returns the previous halfedge of h if supported, // `Halfedge_handle()' otherwise. return get_prev( h, Supports_halfedge_prev()); } Halfedge_handle find_prev( Halfedge_handle h) const { // returns the previous halfedge of h. Uses the `prev()' method if // supported or performs a search around the face using `next()'. return find_prev( h, Supports_halfedge_prev()); } Halfedge_handle find_prev_around_vertex( Halfedge_handle h) const { // returns the previous halfedge of h. Uses the `prev()' method if // supported or performs a search around the vertex using `next()'. return find_prev_around_vertex( h, Supports_halfedge_prev()); } Face_handle get_face( Halfedge_handle h) const { // returns the incident face of h if supported, // `Face_handle()' otherwise. return get_face( h, Supports_halfedge_face()); } Halfedge_handle get_face_halfedge( Face_handle f) const { // returns the incident halfedge of f if supported, // `Halfedge_handle()' otherwise. return get_face_halfedge( f, Supports_face_halfedge()); } // Const Access Functions // ---------------------------------- Halfedge_const_handle get_vertex_halfedge( Vertex_const_handle v) const { return get_vertex_halfedge( v, Supports_vertex_halfedge()); } Vertex_const_handle get_vertex( Halfedge_const_handle h) const { return get_vertex( h, Supports_halfedge_vertex()); } Halfedge_const_handle get_prev( Halfedge_const_handle h) const { return get_prev( h, Supports_halfedge_prev()); } Halfedge_const_handle find_prev( Halfedge_const_handle h) const { return find_prev( h, Supports_halfedge_prev()); } Halfedge_const_handle find_prev_around_vertex( Halfedge_const_handle h) const { return find_prev_around_vertex( h, Supports_halfedge_prev()); } Face_const_handle get_face( Halfedge_const_handle h) const { return get_face( h, Supports_halfedge_face()); } Halfedge_const_handle get_face_halfedge( Face_const_handle f) const { return get_face_halfedge( f, Supports_face_halfedge()); } // Modifying Functions (Primitives) // ---------------------------------- void set_vertex_halfedge( Vertex_handle v, Halfedge_handle g) const { // sets the incident halfedge of v to g. set_vertex_halfedge( v, g, Supports_vertex_halfedge()); } void set_vertex_halfedge( Halfedge_handle h) const { // sets the incident halfedge of the vertex incident to h to h. set_vertex_halfedge( h, h, Supports_halfedge_vertex()); } void set_vertex( Halfedge_handle h, Vertex_handle v) const { // sets the incident vertex of h to v. set_vertex(h, v, Supports_halfedge_vertex()); } void set_prev( Halfedge_handle h, Halfedge_handle g) const { // sets the previous link of h to g. set_prev( h, g, Supports_halfedge_prev()); } void set_face( Halfedge_handle h, Face_handle f) const { // sets the incident face of h to f. set_face(h, f, Supports_halfedge_face()); } void set_face_halfedge( Face_handle f, Halfedge_handle g) const { // sets the incident halfedge of f to g. set_face_halfedge( f, g, Supports_face_halfedge()); } void set_face_halfedge( Halfedge_handle h) const { // sets the incident halfedge of the face incident to h to h. set_face_halfedge( h, h, Supports_halfedge_face()); } // Modifying Functions (Composed) // ---------------------------------- void close_tip( Halfedge_handle h) const { // makes `h->opposite()' the successor of h. h->HBase::set_next( h->opposite()); set_prev( h->opposite(), h); } void close_tip( Halfedge_handle h, Vertex_handle v) const { // makes `h->opposite()' the successor of h and sets the incident // vertex of h to v. h->HBase::set_next( h->opposite()); set_prev( h->opposite(), h); set_vertex( h, v); } void insert_tip( Halfedge_handle h, Halfedge_handle v) const { // inserts the tip of the edge h into the halfedges around the // vertex pointed to by v. Halfedge `h->opposite()' is the new // successor of v and `h->next()' will be set to `v->next()'. The // vertex of h will be set to the vertex v refers to if vertices // are supported. h->HBase::set_next( v->next()); v->HBase::set_next( h->opposite()); set_prev( h->next(), h); set_prev( h->opposite(), v); set_vertex( h, get_vertex( v)); } void remove_tip( Halfedge_handle h) const { // removes the edge `h->next()->opposite()' from the halfedge // circle around the vertex referred to by h. The new successor // halfedge of h will be `h->next()->opposite()->next()'. h->HBase::set_next( h->next()->opposite()->next()); set_prev( h->next(), h); } void insert_halfedge( Halfedge_handle h, Halfedge_handle f) const { // inserts the halfedge h between f and `f->next()'. The face of h // will be the one f refers to if faces are supported. h->HBase::set_next( f->next()); f->HBase::set_next( h); set_prev( h->next(), h); set_prev( h, f); set_face( h, get_face( f)); } void remove_halfedge( Halfedge_handle h) const { // removes edge `h->next()' from the halfedge circle around the // face referred to by h. The new successor of h will be // `h->next()->next()'. h->HBase::set_next( h->next()->next()); set_prev( h->next(), h); } void set_vertex_in_vertex_loop( Halfedge_handle h, Vertex_handle v, CGAL::Tag_false) const {} void set_vertex_in_vertex_loop( Halfedge_handle h, Vertex_handle v, CGAL::Tag_true) const { CGAL_assertion_code( size_t termination_count = 0;) Halfedge_handle end = h; do { CGAL_assertion( ++termination_count != 0); h->HBase::set_vertex( v); h = h->next()->opposite(); } while ( h != end); } void set_vertex_in_vertex_loop( Halfedge_handle h, Vertex_handle v) const { // loops around the vertex incident to h and sets all vertex // pointers to v. Precondition: `h != Halfedge_handle()'. CGAL_precondition( h != Halfedge_handle()); set_vertex_in_vertex_loop( h, v, Supports_halfedge_vertex()); } void set_face_in_face_loop( Halfedge_handle h, Face_handle f, CGAL::Tag_false) const {} void set_face_in_face_loop( Halfedge_handle h, Face_handle f, CGAL::Tag_true) const { CGAL_assertion_code( size_t termination_count = 0;) Halfedge_handle end = h; do { CGAL_assertion( ++termination_count != 0); h->HBase::set_face( f); h = h->next(); } while ( h != end); } void set_face_in_face_loop( Halfedge_handle h, Face_handle f) const { // loops around the face incident to h and sets all face pointers // to f. Precondition: `h != Halfedge_handle()'. CGAL_precondition( h != Halfedge_handle()); set_face_in_face_loop( h, f, Supports_halfedge_face()); } Halfedge_handle flip_edge( Halfedge_handle h) const { // performs an edge flip, i.e. a Delaunay flip. It returns h after // rotating the edge h one vertex in the direction of the face // orientation. Precondition: `h != Halfedge_handle()' and both // incident faces of h are triangles. CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( h == h->next()->next()->next()); CGAL_precondition( h->opposite() == h->opposite()->next()->next()->next()); Halfedge_handle hprev = h->next()->next(); Halfedge_handle gprev = h->opposite()->next()->next(); remove_tip( hprev); remove_tip( gprev); set_face_halfedge( hprev); set_face_halfedge( gprev); set_vertex_halfedge( hprev); set_vertex_halfedge( gprev); set_face( hprev->next(), hprev->face()); set_face( gprev->next(), gprev->face()); hprev = hprev->next(); gprev = gprev->next(); insert_tip( h, gprev); insert_tip( h->opposite(), hprev); CGAL_postcondition( h == h->next()->next()->next()); CGAL_postcondition( h->opposite() == h->opposite()->next()->next()->next()); return h; } // Implementing These Functions. // ==================================================== // Access Functions // ---------------------------------- Halfedge_handle get_vertex_halfedge( Vertex_handle ,CGAL::Tag_false) const { return Halfedge_handle(); } Halfedge_handle get_vertex_halfedge( Vertex_handle v,CGAL::Tag_true) const { return v->halfedge(); } Vertex_handle get_vertex( Halfedge_handle , CGAL::Tag_false) const { return Vertex_handle(); } Vertex_handle get_vertex( Halfedge_handle h, CGAL::Tag_true) const { return h->vertex(); } Halfedge_handle get_prev( Halfedge_handle , CGAL::Tag_false) const { return Halfedge_handle(); } Halfedge_handle get_prev( Halfedge_handle h, CGAL::Tag_true) const { return h->HBase::prev(); } Halfedge_handle find_prev( Halfedge_handle h, CGAL::Tag_true) const { return h->HBase::prev(); } Halfedge_handle find_prev( Halfedge_handle h, CGAL::Tag_false) const { Halfedge_handle g = h; while ( g->next() != h) g = g->next(); return g; } Halfedge_handle find_prev_around_vertex( Halfedge_handle h, CGAL::Tag_true) const { return h->HBase::prev(); } Halfedge_handle find_prev_around_vertex( Halfedge_handle h, CGAL::Tag_false) const { Halfedge_handle g = h->opposite(); while ( g->next() != h) g = g->next()->opposite(); return g; } Face_handle get_face( Halfedge_handle , CGAL::Tag_false) const { return Face_handle(); } Face_handle get_face( Halfedge_handle h, CGAL::Tag_true) const { return h->face(); } Halfedge_handle get_face_halfedge( Face_handle , CGAL::Tag_false) const { return Halfedge_handle(); } Halfedge_handle get_face_halfedge( Face_handle f, CGAL::Tag_true) const { return f->halfedge(); } // Const Access Functions // ---------------------------------- Halfedge_const_handle get_vertex_halfedge( Vertex_const_handle ,CGAL::Tag_false) const { return Halfedge_const_handle(); } Halfedge_const_handle get_vertex_halfedge( Vertex_const_handle v,CGAL::Tag_true) const { return v->halfedge(); } Vertex_const_handle get_vertex( Halfedge_const_handle , CGAL::Tag_false) const { return Vertex_const_handle(); } Vertex_const_handle get_vertex( Halfedge_const_handle h, CGAL::Tag_true) const { return h->vertex(); } Halfedge_const_handle get_prev( Halfedge_const_handle , CGAL::Tag_false) const { return Halfedge_const_handle(); } Halfedge_const_handle get_prev( Halfedge_const_handle h, CGAL::Tag_true) const { return h->HBase::prev(); } Halfedge_const_handle find_prev( Halfedge_const_handle h, CGAL::Tag_true) const { return h->HBase::prev(); } Halfedge_const_handle find_prev( Halfedge_const_handle h, CGAL::Tag_false) const { Halfedge_const_handle g = h; while ( g->next() != h) g = g->next(); return g; } Halfedge_const_handle find_prev_around_vertex( Halfedge_const_handle h, CGAL::Tag_true) const { return h->HBase::prev(); } Halfedge_const_handle find_prev_around_vertex( Halfedge_const_handle h, CGAL::Tag_false) const { Halfedge_const_handle g = h->opposite(); while ( g->next() != h) g = g->next()->opposite(); return g; } Face_const_handle get_face( Halfedge_const_handle , CGAL::Tag_false) const { return Face_const_handle(); } Face_const_handle get_face( Halfedge_const_handle h, CGAL::Tag_true) const { return h->face(); } Halfedge_const_handle get_face_halfedge( Face_const_handle , CGAL::Tag_false) const { return Halfedge_const_handle(); } Halfedge_const_handle get_face_halfedge( Face_const_handle f, CGAL::Tag_true) const { return f->halfedge(); } // Modifying Function Primitives // ---------------------------------- void set_vertex_halfedge( Vertex_handle, Halfedge_handle, CGAL::Tag_false) const {} void set_vertex_halfedge( Vertex_handle v, Halfedge_handle g, CGAL::Tag_true) const { v->VBase::set_halfedge(g); } void set_vertex_halfedge( Halfedge_handle, Halfedge_handle, CGAL::Tag_false) const {} void set_vertex_halfedge( Halfedge_handle h, Halfedge_handle g, CGAL::Tag_true) const { set_vertex_halfedge( h->vertex(), g); } void set_vertex( Halfedge_handle, Vertex_handle, CGAL::Tag_false) const {} void set_vertex( Halfedge_handle h, Vertex_handle v, CGAL::Tag_true) const { h->HBase::set_vertex(v); } void set_prev( Halfedge_handle, Halfedge_handle, CGAL::Tag_false) const {} void set_prev( Halfedge_handle h, Halfedge_handle g, CGAL::Tag_true) const { h->HBase::set_prev( g); } void set_face( Halfedge_handle, Face_handle, CGAL::Tag_false) const {} void set_face( Halfedge_handle h, Face_handle f, CGAL::Tag_true) const { h->HBase::set_face(f); } void set_face_halfedge( Face_handle, Halfedge_handle, CGAL::Tag_false) const {} void set_face_halfedge( Face_handle f, Halfedge_handle g, CGAL::Tag_true) const { f->FBase::set_halfedge(g); } void set_face_halfedge( Halfedge_handle, Halfedge_handle, CGAL::Tag_false) const {} void set_face_halfedge( Halfedge_handle h, Halfedge_handle g, CGAL::Tag_true) const { set_face_halfedge( h->face(), g); } }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_ITEMS_DECORATOR_H // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_io_parser.h0000644000175000017500000003113611344301501030506 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_io_parser.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_IO_PARSER_H #define CGAL_PM_IO_PARSER_H #include #include #include CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=PM_io_parser.man }*/ /*{\Manpage {PM_io_parser}{PMDEC}{IO of plane maps}{IO}}*/ /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to provide input and output of a plane map. |\Mtype| is generic with respect to the |PMDEC| parameter. |PMDEC| has to be a decorator model of our |PM_decorator| concept.}*/ /*{\Mgeneralization PM_decorator}*/ template class PM_io_parser : public PMDEC { typedef PMDEC Base; typedef typename PMDEC::Plane_map Plane_map; typedef typename PMDEC::Point Point; typedef typename PMDEC::Mark Mark; typedef typename PMDEC::Vertex_iterator Vertex_iterator; typedef typename PMDEC::Halfedge_iterator Halfedge_iterator; typedef typename PMDEC::Face_iterator Face_iterator; typedef typename PMDEC::Vertex_handle Vertex_handle; typedef typename PMDEC::Halfedge_handle Halfedge_handle; typedef typename PMDEC::Face_handle Face_handle; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::clear; using Base::vertices_begin; using Base::vertices_end; using Base::halfedges_begin; using Base::halfedges_end; using Base::faces_begin; using Base::faces_end; using Base::number_of_vertices; using Base::number_of_halfedges; using Base::number_of_faces; using Base::new_vertex; using Base::new_face; using Base::new_halfedge_pair_without_vertices; #endif std::istream& in; std::ostream& out; bool verbose; // a reference to the IO object CGAL::Object_index VI; CGAL::Object_index EI; CGAL::Object_index FI; std::vector Vertex_of; std::vector Halfedge_of; std::vector Face_of; // object mapping for input int vn,en,fn,i; // the number of objects void print_vertex(Vertex_handle) const; void print_hedge(Halfedge_handle) const; void print_face(Face_handle) const; bool read_vertex(Vertex_handle); bool read_hedge(Halfedge_handle); bool read_face(Face_handle); void debug_vertex(Vertex_handle) const; void debug_hedge(Halfedge_handle) const; public: /*{\Mcreation 3}*/ PM_io_parser(std::istream& is, Plane_map& H) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to input |H| from |is|.}*/ : Base(H), in(is), out(std::cout), verbose(0), vn(0), en(0), fn(0) { this->clear(); } PM_io_parser(std::ostream& os, const Plane_map& H) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to output |H| to |os|.}*/ : Base(const_cast(H)), in(std::cin), out(os), VI(this->vertices_begin(),this->vertices_end(),'v'), EI(this->halfedges_begin(),this->halfedges_end(),'e'), FI(this->faces_begin(),this->faces_end(),'f'), vn(this->number_of_vertices()), en(this->number_of_halfedges()), fn(this->number_of_faces()) { verbose = (out.iword(CGAL::IO::mode) != CGAL::IO::ASCII && out.iword(CGAL::IO::mode) != CGAL::IO::BINARY); } PM_io_parser(std::ostream& os, const PMDEC& D) : Base(D), in(std::cin), out(os), VI(this->vertices_begin(),this->vertices_end(),'v'), EI(this->halfedges_begin(),this->halfedges_end(),'e'), FI(this->faces_begin(),this->faces_end(),'f'), vn(this->number_of_vertices()), en(this->number_of_halfedges()), fn(this->number_of_faces()) { verbose = (out.iword(CGAL::IO::mode) != CGAL::IO::ASCII && out.iword(CGAL::IO::mode) != CGAL::IO::BINARY); } /*{\Moperations 2 3}*/ bool check_sep(const char* sep); void print() const; /*{\Mop prints |H| to |os|.}*/ void read(); /*{\Mop reads |H| from |is|.}*/ void debug() const; std::string index(Vertex_handle v) const { return VI(v,verbose); } std::string index(Halfedge_handle e) const { return EI(e,verbose); } std::string index(Face_handle f) const { return FI(f,verbose); } static void dump(const PMDEC& D, std::ostream& os = std::cerr); /*{\Mstatic prints the plane map decorated by |D| to |os|.}*/ }; // PM_io_parser //----------------------------------------------------------------------------- // OUTPUT AND INPUT: //----------------------------------------------------------------------------- #ifdef __BORLANDC__ #define ISSPACENS std:: #else #define ISSPACENS #endif template bool PM_io_parser::check_sep(const char* sep) { char c; do in.get(c); while (ISSPACENS isspace(c)); while (*sep != '\0') { if (*sep != c) { in.putback(c); return false; } ++sep; in.get(c); } in.putback(c); return true; } template void PM_io_parser::print_vertex(Vertex_handle v) const { // syntax: index { isolated incident_object, mark, point } out << index(v) << " { "; if ( is_isolated(v) ) out << "1 " << index(face(v)); else out << "0 " << index(v->halfedge()); out << ", " << mark(v) << ", " << point(v) << "}\n"; } template bool PM_io_parser::read_vertex(Vertex_handle v) { // precondition: nodes exist // syntax: index { mark, point, isolated object } int n; bool iso; int f; Mark m; Point p; if ( !(in >> n) || !check_sep("{") || !(in >> iso) || !(in >> f) || !check_sep(",") || !(in >> m) || !check_sep(",") || !(in >> p) || !check_sep("}") ) return false; if (iso) v->set_face(Face_of[f]); else v->set_halfedge(Halfedge_of[f]); mark(v) = m; point(v) = p; return true; } template void PM_io_parser::print_hedge(Halfedge_handle e) const { // syntax: index { opposite, prev, next, vertex, face, mark } out << index(e) << " { " << index(twin(e)) << ", " << index(previous(e)) << ", " << index(next(e)) << ", " << index(target(e)) << ", " << index(face(e)) << ", " << mark(e) << " }\n"; } template bool PM_io_parser::read_hedge(Halfedge_handle e) { // syntax: index { opposite, prev, next, vertex, face, mark } int n, eo, epr, ene, v, f; bool m; if ( !(in >> n) || !check_sep("{") || !(in >> eo) || !check_sep(",") || !(in >> epr) || !check_sep(",") || !(in >> ene) || !check_sep(",") || !(in >> v) || !check_sep(",") || !(in >> f) || !check_sep(",") || !(in >> m) || !check_sep("}") ) return false; CGAL_assertion_msg (eo >= 0 || eo < en || epr >= 0 || epr < en || ene >= 0 || ene < en || v >= 0 || v < vn || f >= 0 || f < fn , "wrong index in read_hedge"); // precond: objects exist! CGAL_assertion(EI[e->opposite()]); e->set_prev(Halfedge_of[epr]); e->set_next(Halfedge_of[ene]); e->set_vertex(Vertex_of[v]); e->set_face(Face_of[f]); mark(e) = m; return true; } template void PM_io_parser::print_face(Face_handle f) const { // syntax: index { halfedge, fclist, ivlist, mark } out << index(f) << " { " << index(halfedge(f)) << ", "; typedef typename std::list::iterator lhiterator; lhiterator hit, hend = f->fc_end(); for(hit = f->fc_begin(); hit!=hend; ++hit) out << index(*hit) << ' '; out << ", "; typedef typename std::list::iterator lviterator; lviterator vit, vend = f->iv_end(); for(vit = f->iv_begin(); vit!=vend; ++vit) out << index(*vit) << ' '; out << ", " << mark(f) << " }\n"; } template bool PM_io_parser::read_face(Face_handle f) { // syntax: index { halfedge, fclist, ivlist, mark } int n, ei, vi; Mark m; if ( !(in >> n) || !check_sep("{") ) return false; if ( !(in >> ei) || !check_sep(",") ) return false; if (ei >= 0) f->set_halfedge(Halfedge_of[ei]); while (in >> ei) { CGAL_assertion_msg(ei >= 0 && ei < en, "wrong index in face cycle list."); f->store_fc(Halfedge_of[ei]); } in.clear(); if (!check_sep(",")) { return false; } while (in >> vi) { CGAL_assertion_msg(vi >= 0 && vi < vn, "wrong index in iso vertex list."); f->store_iv(Vertex_of[vi]); } in.clear(); if (!check_sep(",") || !(in >> m) || !check_sep("}") ) return false; mark(f) = m; return true; } template void PM_io_parser::print() const { out << "Plane_map_2" << std::endl; out << "vertices " << vn << std::endl; out << "halfedges " << en << std::endl; out << "faces " << fn << std::endl; if (verbose) out << "/* index { isolated ? face : halfedge, mark, point } */" << std::endl; Vertex_iterator vit, vend = this->vertices_end(); for(vit = this->vertices_begin(); vit!=vend; ++vit) print_vertex(vit); if (verbose) out << "/* index { opposite, prev, next, vertex, face, mark } */" << std::endl; Halfedge_iterator eit, eend = this->halfedges_end(); for(eit = this->halfedges_begin(); eit!=eend; ++eit) print_hedge(eit); if (verbose) out << "/* index { halfedge, fclist, ivlist, mark } */" << std::endl; Face_iterator fit, fend = this->faces_end(); for(fit = this->faces_begin(); fit!=fend; ++fit) print_face(fit); out.flush(); if (verbose) debug(); } template void PM_io_parser::read() { if ( !check_sep("Plane_map_2") ) CGAL_assertion_msg(0,"PM_io_parser::read: no embedded_PM header."); if ( !(check_sep("vertices") && (in >> vn)) ) CGAL_assertion_msg(0,"PM_io_parser::read: wrong node line."); if ( !(check_sep("halfedges") && (in >> en) && (en%2==0)) ) CGAL_assertion_msg(0,"PM_io_parser::read: wrong edge line."); if ( !(check_sep("faces") && (in >> fn)) ) CGAL_assertion_msg(0,"PM_io_parser::read: wrong face line."); Vertex_of.reserve(vn); Halfedge_of.reserve(en); Face_of.reserve(fn); for(i=0; inew_vertex(); for(i=0; inew_halfedge_pair_without_vertices(); else Halfedge_of[i] = twin(Halfedge_of[i-1]); for(i=0; inew_face(); for(i=0; i void PM_io_parser::debug_vertex(Vertex_handle v) const { out << index(v) << "[" << mark(v) << "," << point(v) << "]" << std::endl; } template void PM_io_parser::debug_hedge(Halfedge_handle e) const { out << index(e) << "(" << index(source(e)) << "," << index(target(e)) << ") " << index(face(e)) << " " << index(twin(e)) << " ["<< mark(e) << "]" <<" "<<&*(face(e)) << std::endl; } template void PM_io_parser::debug() const { out << "\nDEBUG Plane_map\n" << "Vertices: " << this->number_of_vertices() << "\n" << "Halfedges: " << this->number_of_halfedges() << "\n"; Vertex_iterator vit,vend = this->vertices_end(); for( vit = this->vertices_begin(); vit != vend; ++vit ) { if ( is_isolated(vit) ) continue; typename Base::Halfedge_around_vertex_circulator hcirc = out_edges(vit), hend = hcirc; debug_vertex(vit); CGAL_For_all(hcirc,hend) { out << " "; debug_hedge(hcirc); } } out << std::endl; } template void PM_io_parser::dump(const PMDEC& D, std::ostream& os) { PM_io_parser Out(os,D); Out.print(); } CGAL_END_NAMESPACE #endif //CGAL_PM_IO_PARSER_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_persistent_PL.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_persistent_PL0000644000175000017500000001517511344301501031075 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_persistent_PL.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_PERSISTENT_PL_H #define CGAL_PM_PM_PERSISTENT_PL_H #include template struct PM_persistent_PL_traits { typedef PMPL Graph; typedef typename PMPL::Vertex_const_handle Node; typedef typename PMPL::Halfedge_const_handle Edge; typedef typename PMPL::Face_const_handle Face; typedef typename PMPL::Object_handle Object_handle; typedef typename PMPL::Geometry Geometry; typedef typename PMPL::Point Point; typedef typename PMPL::Segment Segment; const Geometry* pK; typedef typename PMPL::Vertex_const_iterator NodeIterator; NodeIterator Nodes_begin(const Graph& G) const { return G.vertices_begin(); } NodeIterator Nodes_end(const Graph& G) const { return G.vertices_end(); } Node toNode(const NodeIterator& nit) const { return nit; } typedef typename PMPL::Halfedge_around_vertex_const_circulator HAVC; struct IncEdgeIterator { HAVC _start, _curr; bool met; IncEdgeIterator() {} IncEdgeIterator(HAVC c) : _start(c), _curr(c), met(false) {} IncEdgeIterator& operator++() { if (_curr==_start) if (!met) { met=true; ++_curr; } else { _curr=HAVC(); } else ++_curr; return *this; } bool operator==(const IncEdgeIterator& it2) const { return _curr==it2._curr; } bool operator!=(const IncEdgeIterator& it2) const { return !(*this==it2); } }; Edge toEdge(const IncEdgeIterator& eit) const { return eit._curr; } IncEdgeIterator IncEdges_begin(const Graph& G, const Node& n) { return IncEdgeIterator(HAVC(G.first_out_edge(n))); } IncEdgeIterator IncEdges_end(const Graph& G, const Node& n) { return IncEdgeIterator(); } enum EdgeCategory { StartingNonVertical, StartingVertical, EndingNonVertical, EndingVertical }; Node opposite(const Graph& G, const Edge& e, const Node& u) { if ( G.source(e) == u ) return G.target(e); else return G.source(e); } EdgeCategory ClassifyEdge(const Graph& G, const Edge& e, const Node& u) { Point p_u = G.point(u); Point p_v = G.point(opposite(G,e,u)); int cmpX = pK->compare_x(p_u, p_v); if ( cmpX < 0 ) return StartingNonVertical; if ( cmpX > 0 ) return EndingNonVertical; int cmpY = pK->compare_y(p_u, p_v); assert(cmpY != 0); if ( cmpY < 0 ) return StartingVertical; return EndingVertical; } typedef Point XCoord; const XCoord getXCoord(const Point& p) const { return p; } const XCoord getXCoord(const Graph& G, const Node& n) const { return G.point(n); } class PredLessThanX { const Geometry* pK; public: PredLessThanX() : pK(0) {} PredLessThanX(const Geometry* pKi) : pK(pKi) {} PredLessThanX(const PredLessThanX& P) : pK(P.pK) { CGAL_NEF_TRACEN("copy PredLessThanX"); } int operator() (const XCoord& x1, const XCoord& x2) const { return pK->compare_x(x1,x2) < 0; } }; PredLessThanX getLessThanX() const { return PredLessThanX(pK); } // Curve connected functionality: typedef Segment Curve; Curve makeCurve(const Point& p) const { return pK->construct_segment(p,p); } Curve makeCurve(const Graph& G, const Node& n) const { return makeCurve(G.point(n)); } Curve makeCurve(const Graph& G, const Edge& e) const { Point ps = G.point(G.source(e)), pt = G.point(G.target(e)); Curve res(G.point(G.source(e)),G.point(G.target(e))); if ( pK->compare_xy(ps,pt) < 0 ) res = pK->construct_segment(ps,pt); else res = pK->construct_segment(pt,ps); return res; } struct PredCompareCurves { const Geometry* pK; PredCompareCurves() : pK(0) {} PredCompareCurves(const Geometry* pKi) : pK(pKi) {} PredCompareCurves(const PredCompareCurves& P) : pK(P.pK) {} int cmppntseg(const Point& p, const Curve& s) const { if ( pK->compare_x(pK->source(s),pK->target(s)) != 0 ) // !vertical return pK->orientation(pK->source(s),pK->target(s), p); if ( pK->compare_y(p,pK->source(s)) <= 0 ) return -1; if ( pK->compare_y(p,pK->target(s)) >= 0 ) return +1; return 0; } int operator()(const Curve& s1, const Curve& s2) const { Point a = pK->source(s1); Point b = pK->target(s1); Point c = pK->source(s2); Point d = pK->target(s2); if ( a==b ) if ( c==d ) return pK->compare_y(a,c); else return cmppntseg(a, s2); if ( c==d ) return -cmppntseg(c, s1); // now both are non-trivial: int cmpX = pK->compare_x(a, c); if ( cmpX < 0 ) return - pK->orientation(a,b,c); if ( cmpX > 0 ) return pK->orientation(c,d,a); int cmpY = pK->compare_y(a, c); if ( cmpY < 0 ) return -1; if ( cmpY > 0 ) return +1; // cmpX == cmpY == 0 => a == c return pK->orientation(c,d,b); } }; PredCompareCurves getCompareCurves() const { return PredCompareCurves(pK); } typedef GenericLocation Location; typedef Object_handle QueryResult; virtual Object_handle PostProcess(const Location& L, const Location& L_plus, const Point& p) const { /* we only get an L_plus (non-nil) if L is ABOVE a vertex in which case we want to extract the face from the edge below (p+epsilon) available via L_plus. */ if (!L_plus.is_nil()) { assert(L_plus.is_edge()); return Object_handle(Edge(L_plus)); } else { if ( L.is_edge() ) { return Object_handle(Edge(L)); } if ( L.is_node() ) { Node v(L); assert( v != Node() ); return Object_handle(v); } return Object_handle(); } } PM_persistent_PL_traits() : pK(0) {} PM_persistent_PL_traits(const Geometry& k) : pK(&k) {} virtual ~PM_persistent_PL_traits() {} virtual void sweep_begin(const Graph&) {} virtual void sweep_moveto(const XCoord&) {} virtual void sweep_end() {} virtual void clear() {} }; #endif // CGAL_PM_PM_PERSISTENT_PL_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Constrained_triang_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Constrained_tria0000644000175000017500000003232111344301501031166 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Constrained_triang_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_CONSTR_TRIANG_TRAITS_H #define CGAL_PM_CONSTR_TRIANG_TRAITS_H #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 19 #include CGAL_BEGIN_NAMESPACE inline void CGAL_error_handler(int n, const char* s) { std::cerr << s << std::endl; exit(n); } struct Do_nothing { Do_nothing() {} template void operator()(ARG&) const {} }; template class Constrained_triang_traits : public PMDEC { public: typedef Constrained_triang_traits Self; typedef PMDEC Base; // the types interfacing the sweep: typedef NEWEDGE INPUT; typedef typename PMDEC::Plane_map OUTPUT; typedef GEOM GEOMETRY; typedef typename GEOM::Point_2 Point; typedef typename GEOM::Segment_2 Segment; typedef typename GEOM::Direction_2 Direction; typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Halfedge_iterator Halfedge_iterator; typedef typename Base::Vertex_iterator Vertex_iterator; typedef typename Base::Face_iterator Face_iterator; typedef typename Base::Halfedge_base Halfedge_base; typedef typename Base::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; class lt_edges_in_sweepline : public PMDEC { const Point& p; const Halfedge_handle& e_bottom; const Halfedge_handle& e_top; const GEOMETRY& K; public: lt_edges_in_sweepline(const Point& pi, const Halfedge_handle& e1, const Halfedge_handle& e2, const PMDEC& D, const GEOMETRY& k) : PMDEC(D), p(pi), e_bottom(e1), e_top(e2), K(k) {} lt_edges_in_sweepline(const lt_edges_in_sweepline& lt) : PMDEC(lt), p(lt.p), e_bottom(lt.e_bottom), e_top(lt.e_top), K(lt.K) {} Segment seg(const Halfedge_handle& e) const { return K.construct_segment(point(source(e)),point(target(e))); } int orientation(Halfedge_handle e, const Point& p) const { return K.orientation(point(source(e)),point(target(e)),p); } bool operator()(const Halfedge_handle& e1, const Halfedge_handle& e2) const { // Precondition: // [[p]] is identical to the source of either [[e1]] or [[e2]]. if (e1 == e_bottom || e2 == e_top) return true; if (e2 == e_bottom || e1 == e_top) return false; if ( e1 == e2 ) return 0; int s = 0; if ( p == point(source(e1)) ) s = orientation(e2,p); else if ( p == point(source(e2)) ) s = - orientation(e1,p); else CGAL_error_handler(1,"compare error in sweep."); if ( s || source(e1) == target(e1) || source(e2) == target(e2) ) return ( s < 0 ); s = orientation(e2,point(target(e1))); if (s==0) CGAL_error_handler(1,"parallel edges not allowed."); return ( s < 0 ); } }; // lt_edges_in_sweepline class lt_pnts_xy : public PMDEC { const GEOMETRY& K; public: lt_pnts_xy(const PMDEC& D, const GEOMETRY& k) : PMDEC(D), K(k) {} lt_pnts_xy(const lt_pnts_xy& lt) : PMDEC(lt), K(lt.K) {} int operator()(const Vertex_handle& v1, const Vertex_handle& v2) const { return K.compare_xy(point(v1),point(v2)) < 0; } }; // lt_pnts_xy typedef std::map Sweep_status_structure; typedef typename Sweep_status_structure::iterator ss_iterator; typedef typename Sweep_status_structure::value_type ss_pair; typedef std::set Event_Q; typedef typename Event_Q::const_iterator event_iterator; const GEOMETRY& K; Event_Q event_Q; event_iterator event_it; Vertex_handle event; Point p_sweep; Sweep_status_structure SL; CGAL::Unique_hash_map SLItem; const NEWEDGE& Treat_new_edge; Halfedge_handle e_low,e_high; // framing edges ! Halfedge_handle e_search; Constrained_triang_traits(const INPUT& in, OUTPUT& out, const GEOMETRY& k) : Base(out), K(k), event_Q(lt_pnts_xy(*this,K)), SL(lt_edges_in_sweepline(p_sweep,e_low,e_high,*this,K)), SLItem(SL.end()), Treat_new_edge(in) { CGAL_NEF_TRACEN("Constrained Triangulation Sweep"); } Halfedge_handle new_bi_edge(Vertex_handle v1, Vertex_handle v2) { // appended at v1 and v2 adj list Halfedge_handle e = Base::new_halfedge_pair(v1,v2); Treat_new_edge(e); return e; } Halfedge_handle new_bi_edge(Halfedge_handle e_bf, Halfedge_handle e_af) { // ccw before e_bf and after e_af Halfedge_handle e = Base::new_halfedge_pair(e_bf,e_af,Halfedge_base(), Base::BEFORE, Base::AFTER); Treat_new_edge(e); return e; } Halfedge_handle new_bi_edge(Vertex_handle v, Halfedge_handle e_bf) { // appended at v's adj list and before e_bf Halfedge_handle e = Base::new_halfedge_pair(v,e_bf,Halfedge_base(), Base::BEFORE); Treat_new_edge(e); return e; } Segment seg(Halfedge_handle e) const { return K.construct_segment(point(source(e)),point(target(e))); } Direction dir(Halfedge_handle e) const { return K.construct_direction(point(source(e)),point(target(e))); } bool is_forward(Halfedge_handle e) const { return K.compare_xy(point(source(e)),point(target(e))) < 0; } bool edge_is_visible_from(Vertex_handle v, Halfedge_handle e) { Point p = point(v); Point p1 = point(source(e)); Point p2 = point(target(e)); return ( K.orientation(p1,p2,p)>0 ); // left_turn } void triangulate_up(Halfedge_handle& e_apex) { CGAL_NEF_TRACEN("triangulate_up "< e is lowest in ingoing bundle only outgoing => e is highest in outgoing bundle ingoing and outgoing => e is lowest in ingoing bundle */ eb_high = e_end = ep; eb_low = e; CGAL_NEF_TRACEN("determining handle in SL"); if ( e != Halfedge_handle() ) { point(target(e_search)) = p_sweep; // degenerate loop edge sit_pred = SLItem[e]; if ( sit_pred != SL.end()) sit = --sit_pred; else sit = sit_pred = --SL.upper_bound(e_search); } else { // event is isolated vertex point(target(e_search)) = p_sweep; // degenerate loop edge sit_pred = --SL.upper_bound(e_search); } bool ending_edges(0), starting_edges(0); while ( e != Halfedge_handle() ) { // walk adjacency list clockwise if ( SLItem[e] != SL.end() ) { CGAL_NEF_TRACEN("ending " << seg(e)); if (ending_edges) triangulate_between(e,cyclic_adj_succ(e)); ending_edges = true; SL.erase(SLItem[e]); link_bi_edge_to(e,SL.end()); // not in SL anymore } else { CGAL_NEF_TRACEN("starting "<second; Halfedge_handle e_vis_n = cyclic_adj_succ(e_vis); eb_low = eb_high = new_bi_edge(event,e_vis_n); CGAL_NEF_TRACEN(" producing link "<second = eb_low; } bool event_exists() { if ( event_it != event_Q.end() ) { // event is set at end of loop and in init event = *event_it; p_sweep = point(event); return true; } return false; } void procede_to_next_event() { ++event_it; } void link_bi_edge_to(Halfedge_handle e, ss_iterator sit) { SLItem[e] = SLItem[twin(e)] = sit; } void initialize_structures() { CGAL_NEF_TRACEN("initialize_structures "); for ( event=this->vertices_begin(); event != this->vertices_end(); ++event ) event_Q.insert(event); // sorted order of vertices event_it = event_Q.begin(); if ( event_Q.empty() ) return; event = *event_it; p_sweep = point(event); if ( !is_isolated(event) ) { Halfedge_around_vertex_circulator e(first_out_edge(event)), eend(e); CGAL_For_all(e,eend) { CGAL_NEF_TRACEN("init with "<new_vertex(); point(v_tmp) = Point(); e_high = Base::new_halfedge_pair(event,v_tmp); e_low = Base::new_halfedge_pair(event,v_tmp); // this are two symbolic edges just accessed as sentinels // they carry no geometric information e_search = Base::new_halfedge_pair(v_tmp,v_tmp); // this is just a loop used for searches in SL ss_iterator sit_high = SL.insert(ss_pair(e_high,e_high)).first; ss_iterator sit_low = SL.insert(ss_pair(e_low,e_low)).first; // inserting sentinels into SL link_bi_edge_to(e_high, sit_high); link_bi_edge_to(e_low , sit_low); // we mark them being in the sweepline, which they will never leave // we move to the second vertex: procede_to_next_event(); event_exists(); // sets p_sweep for check invariants CGAL_NEF_TRACEN("EOF initialization"); } void complete_structures() { if (e_low != Halfedge_handle()) { delete_vertex(target(e_search)); } // removing sentinels and e_search } void check_ccw_local_embedding() const { PM_checker C(*this,K); C.check_order_preserving_embedding(event); } void check_invariants() { #ifdef CGAL_CHECK_EXPENSIVE if ( event_it == event_Q.end() ) return; check_ccw_local_embedding(); #endif } void check_final() { #ifdef CGAL_CHECK_EXPENSIVE PM_checker C(*this,K); C.check_is_triangulation(); #endif } }; // Constrained_triang_traits CGAL_END_NAMESPACE #endif // CGAL_PM_CONSTR_TRIANG_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/HDS_items.h0000644000175000017500000003715611344301501027756 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/HDS_items.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_HDS_ITEMS_H #define CGAL_HDS_ITEMS_H #include #include #include template struct Halfedge__base { typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; protected: Halfedge_handle opp; public: Halfedge_handle opposite() { return opp; } Halfedge_const_handle opposite() const { return opp; } void set_opposite(Halfedge_handle h) { opp = h; } }; //#ifndef CGAL_USE_LEDA //#define LEDA_MEMORY(t) //#endif template class Nef_vertex_2 { public: typedef Refs HalfedgeDS; typedef Nef_vertex_2 Base; typedef CGAL::Tag_true Supports_vertex_halfedge; typedef CGAL::Tag_true Supports_vertex_point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Halfedge Halfedge; typedef typename Refs::Face Face; typedef void* GenPtr; typedef typename Traits::Point Point; // geometric embedding typedef typename Traits::Mark Mark; // information typedef typename std::list::iterator iv_iterator; private: Halfedge_handle _h; Face_handle _f; Point _p; iv_iterator _ivit; Mark _m; GenPtr _i; public: Nef_vertex_2() : _h(),_f(),_ivit(nil_),_m(0),_i((GenPtr)0xABCD) {} // constructs an uninitialized vertex concerning embedding // and mark. All links are initialized by their default value. Nef_vertex_2( const Point& p) : _h(),_f(),_p(p),_ivit(nil_),_m(0),_i((GenPtr)0xABCD) {} // constructs a vertex with embedding |p| and mark |m|. // All links are initialized by their default value. bool is_isolated() const { return _h == Halfedge_handle(); } // returns true iff |\Mvar| is isolated, else false. Halfedge_handle halfedge() { return _h; } /*{\Mop returns an incident halfedge. \precond |!is_isolated()|.}*/ Halfedge_const_handle halfedge() const { return _h; } void set_halfedge(Halfedge_handle h) { _h=h; } /*{\Mop makes |h| the entry point into the adjacency cycle of |\Mvar|.}*/ Face_handle face() { return _f; } /*{\Mop returns the incident face if |is_isolated()|.}*/ Face_const_handle face() const { return _f; } void set_face(Face_handle f) { _f=f; } /*{\Mop makes |f| the incident face of |\Mvar|.}*/ Point& point() { return _p; } /*{\Mop returns the embedding point of |\Mvar|.}*/ const Point& point() const { return _p; } Mark& mark() { return _m; } /*{\Mop returns the mark of |\Mvar|.}*/ const Mark& mark() const { return _m; } GenPtr& info() { return _i; } /*{\Mop returns a generic information slot of |\Mvar|.}*/ const GenPtr& info() const { return _i; } iv_iterator ivit() const { return _ivit; } void set_ivit(iv_iterator it) { _ivit = it; } static iv_iterator nil_; /* stl iterators have default construction but are only equal comparable when copy constructed, what a mess in the specification */ }; template class Nef_halfedge_2 { public: typedef Refs HalfedgeDS; typedef Nef_halfedge_2 Base; typedef Nef_halfedge_2 Base_base; typedef CGAL::Tag_true Supports_halfedge_prev; typedef CGAL::Tag_true Supports_halfedge_vertex; typedef CGAL::Tag_true Supports_halfedge_face; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Face Face; typedef void* GenPtr; typedef typename std::list::iterator fc_iterator; typedef typename Traits::Mark Mark; // information protected: Halfedge_handle opp, prv, nxt; Vertex_handle _v; Face_handle _f; fc_iterator _fcit; Mark _m; GenPtr _i; public: Nef_halfedge_2() : opp(),prv(),nxt(),_v(),_f(),_fcit(nil_),_m(0),_i((GenPtr)0xABCD) {} /*{\Mcreate constructs an uninitialized halfedge concerning embedding and mark. All links are initialized by their default value.}*/ Halfedge_handle opposite() { return opp; } /*{\Mop returns the twin of |\Mvar|.}*/ Halfedge_const_handle opposite() const { return opp; } void set_opposite(Halfedge_handle h) { opp = h; } /*{\Mop makes |h| the twin of |\Mvar|.}*/ Halfedge_handle prev() { return prv; } /*{\Mop returns the previous edge of the face cycle of |\Mvar|.}*/ Halfedge_const_handle prev() const { return prv; } void set_prev(Halfedge_handle h) { prv = h; } /*{\Mop makes |h| the previous edge in the face cycle of |\Mvar|.}*/ Halfedge_handle next() { return nxt; } /*{\Mop returns the next edge of the face cycle of |\Mvar|.}*/ Halfedge_const_handle next() const { return nxt; } void set_next(Halfedge_handle h) { nxt = h; } /*{\Mop makes |h| the next edge in the face cycle of |\Mvar|.}*/ Vertex_handle vertex() { return _v; } /*{\Mop returns the vertex incident to the halfedge |\Mvar|.}*/ Vertex_const_handle vertex() const { return _v; } void set_vertex(Vertex_handle v) { _v = v; } /*{\Mop makes |v| the vertex incident to |\Mvar|.}*/ Face_handle face() { return _f; } /*{\Mop returns the face incident to the halfedge |\Mvar|.}*/ Face_const_handle face() const { return _f; } void set_face(Face_handle f) { _f = f; } /*{\Mop makes |f| the face incident to |\Mvar|.}*/ bool is_border() const { return _f == Face_handle(); } Mark& mark() { return _m; } /*{\Mop returns the mark of |\Mvar|.}*/ const Mark& mark() const { return _m; } GenPtr& info() { return _i; } /*{\Mop returns a generic information slot of |\Mvar|.}*/ const GenPtr& info() const { return _i; } fc_iterator fcit() const { return _fcit; } void set_fcit(fc_iterator it) { _fcit=it; } bool is_hole_entry() const /*{\Mop returns true iff |\Mvar| is entry point into a hole face cycle of |\Mvar.face()|.}*/ { return _fcit != nil_; } static fc_iterator nil_; /* stl iterators have default construction but are only equal comparable when copy constructed, what a mess in the specification */ }; template class Nef_face_2 { public: typedef Refs HalfedgeDS; typedef Nef_face_2 Base; typedef CGAL::Tag_true Supports_face_halfedge; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Halfedge Halfedge; typedef void* GenPtr; typedef typename Traits::Mark Mark; // mark information class Hole_iterator /*{\Mtypemember iterator for face cycles. Fits the concept |Halfedge_handle|.}*/ : public std::list::iterator { typedef typename std::list::iterator Ibase; public: Hole_iterator() : Ibase() {} Hole_iterator(const Ibase& b) : Ibase(b) {} Hole_iterator(const Hole_iterator& i) : Ibase(i) {} operator Halfedge_handle() const { return Ibase::operator*(); } Halfedge& operator*() { return *(Ibase::operator*()); } Halfedge_handle operator->() { return Ibase::operator*(); } }; class Hole_const_iterator : public std::list::const_iterator { typedef typename std::list::const_iterator Ibase; public: Hole_const_iterator() : Ibase() {} Hole_const_iterator(const Ibase& b) : Ibase(b) {} Hole_const_iterator(const Hole_const_iterator& i) : Ibase(i) {} operator Halfedge_const_handle() const { return Ibase::operator*(); } const Halfedge& operator*() { return *(Ibase::operator*()); } Halfedge_const_handle operator->() { return Ibase::operator*(); } }; class Isolated_vertex_iterator /*{\Mtypemember iterator for isolated vertices. Fits the concept |Vertex_handle|.}*/ : public std::list::iterator { typedef typename std::list::iterator Ibase; public: Isolated_vertex_iterator() : Ibase() {} Isolated_vertex_iterator(const Ibase& b) : Ibase(b) {} Isolated_vertex_iterator(const Isolated_vertex_iterator& i) : Ibase(i) {} operator Vertex_handle() const { return Ibase::operator*(); } Vertex& operator*() { return *(Ibase::operator*()); } Vertex_handle operator->() { return Ibase::operator*(); } }; class Isolated_vertex_const_iterator : public std::list::const_iterator { typedef typename std::list::const_iterator Ibase; public: Isolated_vertex_const_iterator() : Ibase() {} Isolated_vertex_const_iterator(const Ibase& b) : Ibase(b) {} Isolated_vertex_const_iterator( const Isolated_vertex_const_iterator& i) : Ibase(i) {} operator Vertex_const_handle() const { return Ibase::operator*(); } const Vertex& operator*() { return *(Ibase::operator*()); } Vertex_const_handle operator->() { return Ibase::operator*(); } }; /*{\Mtext |Hole_const_iterator| and |Isolated_vertex_const_iterator| are the non mutable versions.}*/ private: Halfedge_handle _e; std::list FC; std::list IV; Mark _m; GenPtr _i; public: Nef_face_2() : _e(),_m(0),_i((GenPtr)0xABCD) {} /*{\Mcreate constructs an uninitialized face with undefined mark, empty face cycle list, and empty isolated vertices list.}*/ ~Nef_face_2() { FC.clear(); IV.clear(); } void store_fc(Halfedge_handle h) /*{\Mop stores halfedge |h| as an entry into a face cycle of |\Mvar|. Postcondition: |h->is_hole_entry()|.}*/ { FC.push_back(h); h->set_fcit(--FC.end()); CGAL_assertion(h->is_hole_entry()); } void remove_fc(Halfedge_handle h) /*{\Mop removes halfedge |h| as an entry into a face cycle of |\Mvar|. \precond |h->is_hole_entry()| and |h| is stored in the face cycle list of |\Mvar|. Postcondition: |!h->is_hole_entry()|.}*/ { CGAL_assertion(h->is_hole_entry()); FC.erase(h->fcit()); h->set_fcit(Halfedge::nil_); } void store_iv(Vertex_handle v) /*{\Mop stores vertex |v| as an isolated vertex of |\Mvar|.}*/ { IV.push_back(v); v->set_ivit(--IV.end()); } void remove_iv(Vertex_handle v) /*{\Mop removes vertex |v| as an isolated vertex of |\Mvar|. \precond |v->is_isolated()| and |v| is stored in the isolated vertices list of |\Mvar|. Postcondition: |!v->is_isolated()|.}*/ { CGAL_assertion(v->is_isolated()); IV.erase(v->ivit()); v->set_ivit(Vertex::nil_); } /*{\Mtext\setopdims{4cm}{0cm}}*/ Hole_iterator fc_begin() { return FC.begin(); } /*{\Mop}*/ Hole_iterator fc_end() { return FC.end(); } /*{\Mop the iterator range |[fc_begin(),fc_end())| spans the set of interior face cycles.}*/ Isolated_vertex_iterator iv_begin() { return IV.begin(); } /*{\Mop}*/ Isolated_vertex_iterator iv_end() { return IV.end(); } /*{\Mop the iterator range |[iv_begin(),iv_end())| spans the set of isolated vertices.}*/ void clear_all_entries() { for (Hole_iterator hit = fc_begin(); hit!=fc_end(); ++hit) hit->set_fcit(Halfedge::nil_); for (Isolated_vertex_iterator vit = iv_begin(); vit!=iv_end(); ++vit) vit->set_ivit(Vertex::nil_); FC.clear(); IV.clear(); } /*{\Mtext There are the same iterator ranges defined for the const iterators |Hole_const_iterator|, |Isolated_vertex_const_iterator|. \restoreopdims}*/ Hole_const_iterator fc_begin() const { return FC.begin(); } Hole_const_iterator fc_end() const { return FC.end(); } Isolated_vertex_const_iterator iv_begin() const { return IV.begin(); } Isolated_vertex_const_iterator iv_end() const { return IV.end(); } void set_halfedge(Halfedge_handle h) { _e = h; } /*{\Mop makes |h| the entry edge into the outer face cycle.}*/ Halfedge_handle halfedge() { return _e; } /*{\Mop returns a halfedge in the outer face cycle.}*/ Halfedge_const_handle halfedge() const { return _e; } Mark& mark() { return _m; } /*{\Mop returns the mark of |\Mvar|.}*/ const Mark& mark() const { return _m; } GenPtr& info() { return _i; } /*{\Mop returns a generic information slot of |\Mvar|.}*/ const GenPtr& info() const { return _i; } }; template typename Nef_vertex_2::iv_iterator Nef_vertex_2::nil_; template typename Nef_halfedge_2::fc_iterator Nef_halfedge_2::nil_; class HDS_items { public: template < class Refs, class Traits> struct Vertex_wrapper { typedef Nef_vertex_2< Refs, Traits> Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef Nef_halfedge_2< Refs, Traits> Halfedge; }; template < class Refs, class Traits> struct Face_wrapper { typedef Nef_face_2< Refs, Traits> Face; }; }; #endif // CGAL_HDS_ITEMS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_overlayer.h0000644000175000017500000006764711344301501030553 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_overlayer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_OVERLAYER_H #define CGAL_PM_OVERLAYER_H #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 13 #include #ifndef CGAL_USE_LEDA #define LEDA_MEMORY(t) #endif CGAL_BEGIN_NAMESPACE template struct PMO_from_segs { typedef PMD Decorator; typedef typename Decorator::Vertex_handle Vertex_handle; typedef typename Decorator::Halfedge_handle Halfedge_handle; typedef typename Decorator::Point Point; const Decorator& G; DA& D; PMO_from_segs(const Decorator& Gi, DA& Di) : G(Gi),D(Di) {} Vertex_handle new_vertex(const Point& p) { Vertex_handle v = G.new_vertex(p); geninfo::create(G.info(v)); return v; } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) { G.link_as_target_and_append(v,e); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) { Halfedge_handle e = G.new_halfedge_pair_at_source(v,Decorator::BEFORE); return e; } void supporting_segment(Halfedge_handle e, I it) const { D.supporting_segment(e,it); } void trivial_segment(Vertex_handle v, I it) const { D.trivial_segment(v,it); } void starting_segment(Vertex_handle v, I it) const { D.starting_segment(v,it); } void passing_segment(Vertex_handle v, I it) const { D.passing_segment(v,it); } void ending_segment(Vertex_handle v, I it) const { D.ending_segment(v,it); } void halfedge_below(Vertex_handle v, Halfedge_handle e) const { geninfo::access(G.info(v)) = e; } Halfedge_handle halfedge_below(Vertex_handle v) const { return geninfo::access(G.info(v)); } void clear_temporary_vertex_info() const { Vertex_handle v; for(v = G.vertices_begin(); v!= G.vertices_end(); ++v) geninfo::clear(G.info(v)); } }; // PMO_from_segs template struct PMO_from_pm { typedef PMD Decorator; typedef typename PMD::Const_decorator Const_decorator; typedef typename Decorator::Vertex_handle Vertex_handle; typedef typename Decorator::Halfedge_handle Halfedge_handle; typedef typename Decorator::Vertex_const_handle Vertex_const_handle; typedef typename Decorator::Halfedge_const_handle Halfedge_const_handle; typedef typename Decorator::Point Point; const Decorator& G; const Const_decorator* pGI[2]; CGAL::Unique_hash_map& M; PMO_from_pm(const Decorator& Gi, const Const_decorator* pG0, const Const_decorator* pG1, CGAL::Unique_hash_map& Mi) : G(Gi),M(Mi) { pGI[0]=pG0; pGI[1]=pG1; } Vertex_handle new_vertex(const Point& p) const { Vertex_handle v = G.new_vertex(p); G.assoc_info(v); return v; } void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) const { G.link_as_target_and_append(v,e); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) const { Halfedge_handle e = G.new_halfedge_pair_at_source(v,Decorator::BEFORE); G.assoc_info(e); return e; } void halfedge_below(Vertex_handle v, Halfedge_handle e) const { G.halfedge_below(v) = e; } void supporting_segment(Halfedge_handle e, IT it) const { INFO& si = M[it]; CGAL_assertion( si.e != Halfedge_const_handle() ); G.supp_halfedge(e,si.i) = si.e; G.is_forward(e) = true; } void trivial_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; CGAL_assertion( si.v != Vertex_const_handle() ); G.supp_vertex(v,si.i) = si.v; } void starting_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; G.supp_vertex(v,si.i) = pGI[si.i]->source(si.e); } void ending_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; G.supp_vertex(v,si.i) = pGI[si.i]->target(si.e); } void passing_segment(Vertex_handle v, IT it) const { INFO& si = M[it]; G.supp_halfedge(v,si.i) = si.e; } Halfedge_handle halfedge_below(Vertex_handle v) const { return G.halfedge_below(v); } }; // PMO_from_pm /*{\Moptions print_title=yes }*/ /*{\Msubst PM_decorator_#PMD Geometry_#GEO }*/ /*{\Manpage {PM_overlayer}{PMD,GEO}{Plane Map Overlay}{O}}*/ template class PM_overlayer : public PM_decorator_ { typedef PM_decorator_ Base; typedef PM_overlayer Self; const Geometry_& K; // geometry reference /*{\Mdefinition An instance |\Mvar| of data type |\Mname| is a decorator object offering plane map overlay calculation. Overlay is either calculated from two plane maps or from a set of segments. The result is stored in a plane map |P| that carries the geometry and the topology of the overlay. The two template parameters allow to adapt the overlay calculation to different scenarios. The template parameter |PM_decorator_| has to be a model conforming to our plane map decorator concept |PMDecorator|. The concept describes the interface how the topological information stored in |P| can be extracted. The geometry |Geometry_| has to be a model conforming to the concept |OverlayerGeometry_2|. The overlay of a set of segments $S$ is stored in a plane map $P = (V,E,F)$. Vertices are either the endpoints of segments (trivial segments are allowed) or the result of a non-degenerate internal intersection of two segments. Between two vertices there is an edge if there is a segment that supports the straight line embedding of $e$ and if there is no vertex in the relative interior of the embedding of $e$. The faces refer to the maximal connected open point sets of the planar subdivision implied by the embedding of the vertices and edges. Faces are bounded by possibly several face cycles\footnote{For the definition of plane maps and their concepts see the manual page of |PMConstDecorator|.} including isolated vertices. The overlay process in the method |create| creates the objects, the topology of the result and allows to link the plane map objects to input segments by means of a data accessor. The method starts from zero- and one-dimensional geometric objects in $S$ and produces a plane map |P| where each point of the plane can be assigned to an object (vertex, edge, or face) of |P|. The overlay of two plane maps $P_i = (V_i, E_i, F_i)$ has the additional aspect that we already start from two planar subdivisions. We use the index $i=0,1$ defining the reference to $P_i$, unindexed variables refer to the resulting plane map $P$. The $1$-skeleta of the two maps subdivide the edges and faces of the complementary structure into smaller units. This means vertices and edges of $P_i$ can split edges of $P_{1-i}$ and face cycles of $P_i$ subdivide faces of $P_{1-i}$. The 1-skeleton $P'$ of $P$ is defined by the overlay of the embedding of the 1-skeleta of $P_0$ and $P_1$ (Take a trivial segment for each vertex and a segment for each edge and use the overlay definition of a set of segments above). The faces of $P$ refer to the maximal connected open point sets of the planar subdivision implied by the embedding of $P'$. Each object from the output tuple $(V,E,F)$ has a \emph{supporting} object $u_i$ in each of the two input structures. Imagine the two maps to be transparencies, which we stack. Then each point of the plane is covered by an object from each of the input structures. This support relation from the input structures to the output structure defines an information flow. Each supporting object $u_i$ of $u$ $(i=0,1)$ carries an attribute $|mark|(u_i)$. After the subdivision operation this attribute is associated to the output object $u$ by $|mark|(u,i)$.}*/ /*{\Mgeneralization PM_decorator_}*/ public: /*{\Mtypes 8}*/ typedef PM_decorator_ Decorator; /*{\Mtypemember the plane map decorator |PM_decorator_|.}*/ typedef typename Decorator::Plane_map Plane_map; /*{\Mtypemember the plane map type decorated by |PM_decorator_|.}*/ typedef Geometry_ Geometry; /*{\Mtypemember the geometry kernel |Geometry_|.}*/ typedef typename Geometry::Point_2 Point; /*{\Mtypemember the point type of the geometric kernel, \precond |Point| equals |Plane_map::Point|.}*/ typedef typename Geometry::Segment_2 Segment; /*{\Mtypemember the segment type of the geometric kernel.}*/ typedef typename Decorator::Mark Mark; /*{\Mtypemember the attribute type of plane map objects.}*/ typedef typename Decorator::Base Const_decorator; typedef typename Decorator::Halfedge_handle Halfedge_handle; typedef typename Decorator::Vertex_handle Vertex_handle; typedef typename Decorator::Face_handle Face_handle; typedef typename Decorator::Vertex_iterator Vertex_iterator; typedef typename Decorator::Halfedge_iterator Halfedge_iterator; typedef typename Decorator::Face_iterator Face_iterator; typedef typename Decorator::Halfedge_const_handle Halfedge_const_handle; typedef typename Decorator::Vertex_const_handle Vertex_const_handle; typedef typename Decorator::Face_const_handle Face_const_handle; typedef typename Decorator::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Decorator::Vertex_const_iterator Vertex_const_iterator; typedef typename Decorator::Face_const_iterator Face_const_iterator; typedef typename Decorator::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Decorator::Halfedge_around_face_circulator Halfedge_around_face_circulator; typedef typename Decorator::Hole_iterator Hole_iterator; typedef typename Decorator::Isolated_vertex_iterator Isolated_vertex_iterator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::clear; using Base::vertices_begin; using Base::vertices_end; using Base::halfedges_begin; using Base::halfedges_end; using Base::faces_begin; using Base::faces_end; using Base::number_of_vertices; using Base::number_of_halfedges; using Base::number_of_faces; using Base::new_vertex; using Base::new_face; #endif // C++ is really friendly: #define USECMARK(t) const Mark& mark(t h) const { return Base::mark(h); } #define USEMARK(t) Mark& mark(t h) const { return Base::mark(h); } USEMARK(Vertex_handle) USEMARK(Halfedge_handle) USEMARK(Face_handle) USECMARK(Vertex_const_handle) USECMARK(Halfedge_const_handle) USECMARK(Face_const_handle) #undef USEMARK #undef USECMARK /*{\Moperations 1.1 1}*/ struct Seg_info { // to transport information from input to output Halfedge_const_handle e; Vertex_const_handle v; int i; Seg_info() : i(-1) {} Seg_info(Halfedge_const_handle e_, int i_) { e=e_; i=i_; } Seg_info(Vertex_const_handle v_, int i_) { v=v_; i=i_; } Seg_info(const Seg_info& si) { e=si.e; v=si.v; i=si.i; } Seg_info& operator=(const Seg_info& si) { e=si.e; v=si.v; i=si.i; return *this; } LEDA_MEMORY(Seg_info) }; typedef std::list Seg_list; typedef typename Seg_list::const_iterator Seg_iterator; typedef std::pair Seg_it_pair; /*{\Mcreation 6}*/ PM_overlayer(Plane_map& P, const Geometry& g = Geometry()) : /*{\Mcreate |\Mvar| is a decorator object manipulating |P|.}*/ Base(P), K(g) {} template void create(Forward_iterator start, Forward_iterator end, Object_data_accessor& A) const /*{\Mop produces in |P| the plane map consistent with the overlay of the segments from the iterator range |[start,end)|. The data accessor |A| allows to initialize created vertices and edges with respect to the segments in the iterator range. |A| requires the following methods:\\ [[void supporting_segment(Halfedge_handle e, Forward_iterator it)]]\\ [[void trivial_segment(Vertex_handle v, Forward_iterator it)]]\\ [[void starting_segment(Vertex_handle v, Forward_iterator it)]]\\ [[void passing_segment(Vertex_handle v, Forward_iterator it)]]\\ [[void ending_segment(Vertex_handle v, Forward_iterator it)]]\\ where |supporting_segment| is called for each non-trivial segment |*it| supporting a newly created edge |e|, |trivial_segment| is called for each trivial segment |*it| supporting a newly created vertex |v|, and the three last operations are called for each non-trivial segment |*it| starting at/passing through/ending at the embedding of a newly created vertex |v|. \precond |Forward_iterator| has value type |Segment|.}*/ { CGAL_NEF_TRACEN("creating from iterator range"); typedef PMO_from_segs Output_from_segments; typedef Segment_overlay_traits< Forward_iterator, Output_from_segments, Geometry> seg_overlay; typedef generic_sweep< seg_overlay > seg_overlay_sweep; typedef typename seg_overlay::INPUT input_range; Output_from_segments Out(*this, A); seg_overlay_sweep SOS( input_range(start, end), Out, K); SOS.sweep(); create_face_objects(Out); Out.clear_temporary_vertex_info(); } void subdivide(const Plane_map& P0, const Plane_map& P1) const /*{\Mop constructs the overlay of the plane maps |P0| and |P1| in |P|, where all objects (vertices, halfedges, faces) of |P| are \emph{enriched} by the marks of the supporting objects of the two input structures: e.g. let |v| be a vertex supported by a node |v0| in |P0| and by a face |f1| in |P1| and |D0|, |D1| be decorators of type |PM_decorator| on |P0|,|P1|. Then |\Mvar.mark(v,0) = D0.mark(v0)| and |\Mvar.mark(v,1) = D1.mark(f1)|.}*/ { Const_decorator PI[2]; PI[0] = Const_decorator(P0); PI[1] = Const_decorator(P1); Seg_list Segments; int i; CGAL::Unique_hash_map From; for (i=0; i<2; ++i) { Vertex_const_iterator v; for(v = PI[i].vertices_begin(); v != PI[i].vertices_end(); ++v) if ( PI[i].is_isolated(v) ) { Segments.push_back(segment(PI[i],v)); From[--Segments.end()] = Seg_info(v,i); } Halfedge_const_iterator e; for(e = PI[i].halfedges_begin(); e != PI[i].halfedges_end(); ++e) if ( is_forward_edge(PI[i],e) ) { Segments.push_back(segment(PI[i],e)); From[--Segments.end()] = Seg_info(e,i); } } typedef PMO_from_pm Output_from_plane_maps; typedef Segment_overlay_traits< Seg_iterator, Output_from_plane_maps, Geometry> pm_overlay; typedef generic_sweep< pm_overlay > pm_overlay_sweep; Output_from_plane_maps Out(*this,&PI[0],&PI[1],From); pm_overlay_sweep SOS(Seg_it_pair(Segments.begin(),Segments.end()),Out,K); SOS.sweep(); create_face_objects(Out); CGAL_NEF_TRACEN("transfering marks"); Face_iterator f = this->faces_begin(); assoc_info(f); for (i=0; i<2; ++i) mark(f,i) = PI[i].mark(PI[i].faces_begin()); Vertex_iterator v, vend = this->vertices_end(); for (v = this->vertices_begin(); v != vend; ++v) { CGAL_NEF_TRACEN("mark at "<faces_begin(); f != this->faces_end(); ++f) { // skip first face assoc_info(f); for (i=0; i<2; ++i) mark(f,i) = incident_mark(halfedge(f),i); } } template void select(Selection& predicate) const /*{\Mop sets the marks of all objects according to the selection predicate |predicate|. |Selection| has to be a function object type with a function operator\\ [[Mark operator()(Mark m0, Mark m1)]]\\ For each object |u| of |P| enriched by the marks of the supporting objects according to the previous procedure |subdivide|, after this operation |\Mvar.mark(u) = predicate ( \Mvar.mark(u,0),\Mvar.mark(u,1) )|. The additional marks are invalidated afterwards. }*/ { Vertex_iterator vit = this->vertices_begin(), vend = this->vertices_end(); for( ; vit != vend; ++vit) { mark(vit) = predicate(mark(vit,0),mark(vit,1)); discard_info(vit); } Halfedge_iterator hit = this->halfedges_begin(), hend = this->halfedges_end(); for(; hit != hend; ++(++hit)) { mark(hit) = predicate(mark(hit,0),mark(hit,1)); discard_info(hit); } Face_iterator fit = this->faces_begin(), fend = this->faces_end(); for(; fit != fend; ++fit) { mark(fit) = predicate(mark(fit,0),mark(fit,1)); discard_info(fit); } } template void simplify(const Keep_edge& keep) const /*{\Mop simplifies the structure of |P| according to the marks of its objects. An edge |e| separating two faces |f1| and |f2| and equal marks |mark(e) == mark(f1) == mark(f2)| is removed and the faces are unified. An isolated vertex |v| in a face |f| with |mark(v)==mark(f)| is removed. A vertex |v| with outdegree two, two collinear out-edges |e1|,|e2| and equal marks |mark(v) == mark(e1) == mark(e2)| is removed and the edges are unified. The data accessor |keep| requires the function call operator\\[[bool operator()(Halfedge_handle e)]]\\that allows to avoid the simplification for edge pairs referenced by |e|.}*/ { CGAL_NEF_TRACEN("simplifying"); typedef typename CGAL::Union_find::handle Union_find_handle; CGAL::Unique_hash_map< Face_iterator, Union_find_handle> Pitem; CGAL::Union_find unify_faces; Face_iterator f, fend = this->faces_end(); for (f = this->faces_begin(); f!= fend; ++f) { Pitem[f] = unify_faces.make_set(f); clear_face_cycle_entries(f); } Halfedge_iterator e = this->halfedges_begin(), en, eend = this->halfedges_end(); for(; en=e, ++(++en), e != eend; e=en) { if ( keep(e) ) continue; if ( mark(e) == mark(face(e)) && mark(e) == mark(face(twin(e))) ) { CGAL_NEF_TRACEN("deleting "< linked(false); for (e = this->halfedges_begin(); e != eend; ++e) { if ( linked[e] ) continue; Halfedge_around_face_circulator hfc(e),hend(hfc); Halfedge_handle e_min = e; Face_handle f = *(unify_faces.find(Pitem[face(e)])); CGAL_For_all(hfc,hend) { set_face(hfc,f); if ( K.compare_xy(point(target(hfc)), point(target(e_min))) < 0 ) e_min = hfc; linked[hfc]=true; } Point p1 = point(source(e_min)), p2 = point(target(e_min)), p3 = point(target(next(e_min))); if ( K.orientation(p1,p2,p3) > 0 ) set_halfedge(f,e_min); // outer else set_hole(f,e_min); // store as inner } Vertex_iterator v, vn, vend = this->vertices_end(); for(v = this->vertices_begin(); v != vend; v=vn) { CGAL_NEF_TRACEN("at vertex "<faces_begin(); f != fend; f=fn) { fn=f; ++fn; Union_find_handle pit = Pitem[f]; if ( unify_faces.find(pit) != pit ) delete_face(f); } } struct vertex_info { Mark m[2]; Vertex_const_handle v_supp[2]; Halfedge_const_handle e_supp[2]; Halfedge_handle e_below; vertex_info() { v_supp[0]=v_supp[1]=Vertex_const_handle(); e_supp[0]=e_supp[1]=Halfedge_const_handle(); } LEDA_MEMORY(vertex_info) }; void assoc_info(Vertex_handle v) const { geninfo::create(info(v)); } void discard_info(Vertex_handle v) const { geninfo::clear(info(v)); } vertex_info& ginfo(Vertex_handle v) const { return geninfo::access(info(v)); } Mark& mark(Vertex_handle v, int i) const { return ginfo(v).m[i]; } Vertex_const_handle& supp_vertex(Vertex_handle v, int i) const { return ginfo(v).v_supp[i]; } Halfedge_const_handle& supp_halfedge(Vertex_handle v, int i) const { return ginfo(v).e_supp[i]; } Halfedge_handle& halfedge_below(Vertex_handle v) const { return ginfo(v).e_below; } struct halfedge_info { Mark m[2]; Mark mf[2]; Halfedge_const_handle e_supp[2]; bool forw; halfedge_info() { m[0]=m[1]=mf[0]=mf[1]=Mark(); e_supp[0]=e_supp[1]=Halfedge_const_handle(); forw=false; } LEDA_MEMORY(halfedge_info) }; void assoc_info(Halfedge_handle e) const { geninfo::create(info(e)); geninfo::create(info(twin(e))); } void discard_info(Halfedge_handle e) const { geninfo::clear(info(e)); geninfo::clear(info(twin(e))); } halfedge_info& ginfo(Halfedge_handle e) const { return geninfo::access(info(e)); } Mark& mark(Halfedge_handle e, int i) const // uedge information we store in the smaller one { if (&*e < &*(twin(e))) return ginfo(e).m[i]; else return ginfo(twin(e)).m[i]; } Halfedge_const_handle& supp_halfedge(Halfedge_handle e, int i) const // uedge information we store in the smaller one { if (&*e < &*(twin(e))) return ginfo(e).e_supp[i]; else return ginfo(twin(e)).e_supp[i]; } Mark& incident_mark(Halfedge_handle e, int i) const // biedge information we store in the halfedge { return ginfo(e).mf[i]; } bool& is_forward(Halfedge_handle e) const // biedge information we store in the halfedge { return ginfo(e).forw; } struct face_info { Mark m[2]; face_info() { m[0]=m[1]=Mark(); } LEDA_MEMORY(face_info) }; void assoc_info(Face_handle f) const { geninfo::create(info(f)); } void discard_info(Face_handle f) const { geninfo::clear(info(f)); } face_info& ginfo(Face_handle f) const { return geninfo::access(info(f)); } Mark& mark(Face_handle f, int i) const { return ginfo(f).m[i]; } void clear_associated_info_of_all_objects() const { Vertex_iterator vit; for (vit = this->vertices_begin(); vit != this->vertices_end(); ++vit) discard_info(vit); Halfedge_iterator hit; for (hit = this->halfedges_begin(); hit != this->halfedges_end(); ++hit) discard_info(hit); Face_iterator fit; for (fit = this->faces_begin(); fit != this->faces_end(); ++fit) discard_info(fit); } template void create_face_objects(const Below_info& D) const { CGAL_NEF_TRACEN("create_face_objects()"); CGAL::Unique_hash_map FaceCycle(-1); std::vector MinimalHalfedge; int i=0; Halfedge_iterator e, eend = this->halfedges_end(); for (e=this->halfedges_begin(); e != eend; ++e) { if ( FaceCycle[e] >= 0 ) continue; // already assigned Halfedge_around_face_circulator hfc(e),hend(hfc); Halfedge_handle e_min = e; CGAL_NEF_TRACE("face cycle "<new_face(); for (int j=0; j outer face cycle CGAL_NEF_TRACEN(" creating new face object"); Face_handle f = this->new_face(); link_as_outer_face_cycle(f,e); } } for (e = this->halfedges_begin(); e != eend; ++e) { if ( face(e) != Face_handle() ) continue; CGAL_NEF_TRACEN("linking hole "<vertices_end(); for (v = this->vertices_begin(); v != v_end; ++v) { if ( !is_isolated(v) ) continue; Halfedge_handle e_below = D.halfedge_below(v); if ( e_below == Halfedge_handle() ) link_as_isolated_vertex(f_outer,v); else link_as_isolated_vertex(face(e_below),v); } } template Face_handle determine_face(Halfedge_handle e, const std::vector& MinimalHalfedge, const CGAL::Unique_hash_map& FaceCycle, const Below_info& D) const { CGAL_NEF_TRACEN("determine_face "<faces_begin(); Face_handle f = face(e_below); if (f != Face_handle()) return f; // has face already f = determine_face(e_below, MinimalHalfedge, FaceCycle,D); link_as_hole(f,e_below); return f; } Segment segment(const Const_decorator& N, Halfedge_const_handle e) const { return K.construct_segment( N.point(N.source(e)),N.point(N.target(e))); } Segment segment(const Const_decorator& N, Vertex_const_handle v) const { Point p = N.point(v); return K.construct_segment(p,p); } bool is_forward_edge(const Const_decorator& N, Halfedge_const_iterator hit) const { Point p1 = N.point(N.source(hit)); Point p2 = N.point(N.target(hit)); return (K.compare_xy(p1,p2) < 0); } void assert_type_precondition() const { typename PM_decorator_::Point p1; Point p2; assert_equal_types(p1,p2); } }; // PM_overlayer CGAL_END_NAMESPACE #endif // CGAL_PM_OVERLAYER_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/gen_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/gen_point_locati0000644000175000017500000004705211344301501031222 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/gen_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef GEN_POINT_LOCATION_H #define GEN_POINT_LOCATION_H #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 17 #include // #define CHECKING_OFF // for dictionary template inline std::ostream& operator<<(std::ostream& o, const std::list& n) { return o; } /*{\Manpage {GenericLocation}{Node, Edge} {Return Type for Planar Point Location}{L}}*/ template class GenericLocation { /*{\Mdefinition An instance of the data type |\Mtype| is used as return value for planar point location. It can store a node or an edge of a graph or the special value |nil| which is used to signal that no node or edge could be found. }*/ typedef void* GenPtr; public: /*{\Mtypes}*/ enum Type { NIL, NODE, EDGE }; /*{\Menum This enumeration allows to specify the 3 basic types of the values that a |\Mtype| can represent.}*/ /*{\Mcreation}*/ GenericLocation() { init(); } /*{\Mcreate creates a |\Mtype| and initializes with the value |nil|.}*/ GenericLocation(Node n) { init(n); } /*{\Mcreate creates a |\Mtype| and initializes with the node |n|.}*/ GenericLocation(Edge e) { init(e); } /*{\Mcreate creates a |\Mtype| and initializes with the edge |e|.}*/ ~GenericLocation() { clear(); } GenericLocation(const GenericLocation& L) { assign(L); } GenericLocation& operator=( const GenericLocation& L) { clear(); assign(L); return *this; } /*{\Moperations}*/ operator const Node&() const { #if !defined(CHECKING_OFF) if (type != NODE) CGAL_LEDA_SCOPE::error_handler(1, "Location: not convertible to node"); #endif return geninfo::const_access(value); } /*{\Mconversion converts |\Mvar| into a node.\\ \precond |\Mvar| represents a node.}*/ operator const Edge&() const { #if !defined(CHECKING_OFF) if (type != EDGE) CGAL_LEDA_SCOPE::error_handler(1, "Location: not convertible to edge"); #endif return geninfo::const_access(value); } /*{\Mconversion converts |\Mvar| into an edge.\\ \precond |\Mvar| represents an edge.}*/ GenericLocation& operator=(Node n) { clear(); init(n); return *this; } /*{\Mbinop makes |\Mvar| represent the node |n|.}*/ GenericLocation& operator=(Edge e) { clear(); init(e); return *this; } /*{\Mbinop makes |\Mvar| represent the edge |e|.}*/ Type get_type() const { return type; } /*{\Mop returns the type of the value contained in |\Mvar|.}*/ bool is_nil() const { return type == NIL; } /*{\Mop returns |true| iff |\Mvar| represents the value |nil|.}*/ bool is_node() const { return type == NODE; } /*{\Mop returns |true| iff |\Mvar| represents a node.}*/ bool is_edge() const { return type == EDGE; } /*{\Mop returns |true| iff |\Mvar| represents an edge.}*/ private: void init() { type = NIL; } void init(Node n) { type = NODE; geninfo::create(value); geninfo::access(value) = n; } void init(Edge e) { type = EDGE; geninfo::create(value); geninfo::access(value) = e; } void clear() { switch(type) { case NODE: geninfo::clear(value); break; case EDGE: geninfo::clear(value); break; case NIL: break; } } void assign(const GenericLocation& L) { type = L.type; switch(type) { case NODE: geninfo::access(value) = geninfo::const_access(L.value); break; case EDGE: geninfo::access(value) = geninfo::const_access(L.value); break; case NIL: break; } } public: typedef GenericLocation self; private: Type type; GenPtr value; }; /*{\Mimplementation The data type |\Mtype| is implemented as a union of the types |Node| and |Edge|. There is only constant time and space overhead. }*/ template inline bool operator==(const GenericLocation& L1, const GenericLocation& L2) { if (L1.get_type() != L2.get_type()) return false; switch (L1.get_type()) { case GenericLocation::NIL: return true; case GenericLocation::NODE: return Node(L1) == Node(L2); case GenericLocation::EDGE: return Edge(L1) == Edge(L2); } } template inline bool operator!=(const GenericLocation& L1, const GenericLocation& L2) { return ! (L1==L2); } template std::ostream& operator<<(std::ostream& o, const GenericLocation& L) { switch (L.get_type()) { case GenericLocation::NIL: return o<<"nil"; case GenericLocation::NODE: return o<<"node("<<&*Node(L)<<')'; case GenericLocation::EDGE: return o<<"edge("<<&*Edge(L)<<')'; } return o; } template std::istream& operator>>(std::istream& i, GenericLocation&) { return i; } template class GenericXStructure { public: typedef std::vector Array_Coordinates; typedef std::vector Array_Sweeplines; typedef typename Array_Coordinates::const_iterator Coord_iterator; typedef typename Array_Sweeplines::const_iterator Sweepline_iterator; private: int stops; PredLessThanX LtX; Array_Coordinates Coordinates; Array_Sweeplines SweepLines; // SweepLines[0] is EmptyLine; public: GenericXStructure() { clear(); } GenericXStructure(int n, const PredLessThanX& cmp) { init(n, cmp); } ~GenericXStructure() { clear(); } void init(int n, const PredLessThanX& cmp) { CGAL_NEF_TRACEN("XSinit "<= X */ bool found_exact = false; if ( LtX(X,*stopit) ) --stopit; // X < *stopit else found_exact = true; // X >= *stopit CGAL_NEF_TRACEN("stopit "<<*stopit); int offset = stopit-Coordinates.begin(); return found_exact ? SweepLines.begin() + (2*offset+1) : SweepLines.begin() + (2*offset+2); } Sweepline_iterator begin() const { return SweepLines.begin(); } Sweepline_iterator end() const { return SweepLines.end();} }; /*{\Manpage {PointLocator} {PLocTraits} {Planar Point Location} {PL}}*/ template class PointLocator { /*{\Mdefinition An instance |\Mvar| of the parameterized data type |\Mtype| can be used to perform point location queries in the two-dimensional plane. Every non-empty instance |\Mvar| is associated with an embedded planar graph |G|, which has to remain unchanged while it is referenced by |PL|.\\ A location query for a point |p| returns the first object (node or edge) of |G| which is intersected by the straight ray starting in |p| and going vertically downwards/upwards. If the ray does not intersect any node or edge of |G|, then |nil| is returned.\\ The class |\Mtype| is generic, it is parameterized with a traits class |PLocTraits| which widely controls its behaviour. The traits may even change the return type of a query and its semantics. There are predined traits classes for the LEDA graph types, which are described below in a seperate section. }*/ public: // copied types from PLocTraits typedef typename PLocTraits::Point Point; typedef typename PLocTraits::XCoord XCoord; typedef typename PLocTraits::PredLessThanX PredLessThanX; typedef typename PLocTraits::Graph Graph; typedef typename PLocTraits::Node Node; typedef typename PLocTraits::Edge Edge; typedef typename PLocTraits::NodeIterator NodeIterator; typedef typename PLocTraits::IncEdgeIterator IncEdgeIterator; typedef typename PLocTraits::Curve Curve; typedef typename PLocTraits::PredCompareCurves PredCompareCurves; typedef typename PLocTraits::QueryResult QueryResult; /*{\Mtypes}*/ // define additional types typedef GenericLocation Location; /*{\Mtypedef usual return value for the point loaction.}*/ enum Direction { downwards, upwards}; /*{\Menum used to specify the direction for the point location.}*/ typedef CGAL_LEDA_SCOPE::pp_dictionary Sweepline; typedef GenericXStructure XStructure; typedef typename Sweepline::item SL_item; typedef typename XStructure::Sweepline_iterator Sweepline_iterator; /*{\Mcreation}*/ PointLocator() { clear(); } /*{\Mcreate creates an empty |\Mtype|.}*/ PointLocator(const Graph& G, const PLocTraits& PLT = PLocTraits()) : traits(PLT) { init(G); } /*{\Mcreate creates a |\Mtype| for the graph |G| and the traits |PLT|.}*/ /*{\Moperations}*/ void clear() { X_Structure.clear(); traits.clear(); } /*{\Mop makes |\Mvar| empty.}*/ void init(const Graph& G, const PLocTraits& PLT) { traits = PLT; init(G); } /*{\Mop makes |\Mvar| a |\Mtype| for the graph |G| and the traits |PLT|.}*/ void init(const Graph& G); /*{\Mop makes |\Mvar| a |\Mtype| for the graph |G|.}*/ QueryResult locate(const Point& p, const Direction dir) const { return dir == downwards ? locate_down(p) : locate_up(p); } /*{\Mop locates the point |p| in the direction |dir|.}*/ QueryResult locate_down(const Point& p) const; /*{\Mop locates the point |p| vertically downwards.}*/ QueryResult locate_up(const Point& p) const; /*{\Mop locates the point |p| vertically upwards.}*/ Location location(Sweepline_iterator S, SL_item it) const { return (it == nil ? Location() : S->inf(it)); } std::string str(const Sweepline& S) const { std::ostringstream os; os << "Sweepline:\n"; SL_item it; forall_items(it,S) { os << " " << S.key(it) << std::endl; } return os.str(); } private: PLocTraits traits; XStructure X_Structure; }; template void PointLocator::init(const Graph& G) { traits.sweep_begin(G); PredLessThanX LtX = traits.getLessThanX(); typedef std::map, PredLessThanX> dictionary; typedef typename dictionary::iterator dic_iterator; dictionary stops(LtX); // Note: X_Structure, Sweepline, and stops copy compare object NodeIterator ni = traits.Nodes_begin(G), beyond = traits.Nodes_end(G); for(; ni != beyond; ++ni) { XCoord currentX = traits.getXCoord(G, ni); stops[currentX].push_front(traits.toNode(ni)); } Sweepline SL(traits.getCompareCurves()); X_Structure.init(stops.size(), LtX); dic_iterator stop; for(stop = stops.begin(); stop != stops.end(); ++stop) { std::list& NodesOnSL = stop->second; traits.sweep_moveto(traits.getXCoord(G, *NodesOnSL.begin())); std::list EmergingEdges, VerticalEdges; // explore the nodes on SL typename std::list::iterator cur_node; for(cur_node = NodesOnSL.begin(); cur_node != NodesOnSL.end(); ++cur_node) { IncEdgeIterator ei = traits.IncEdges_begin(G, *cur_node); IncEdgeIterator beyond = traits.IncEdges_end(G, *cur_node); CGAL_NEF_TRACEN("NODE: "<<(*cur_node)->point()); for(; ei != beyond; ++ei) { switch (traits.ClassifyEdge(G, traits.toEdge(ei), *cur_node)) { case PLocTraits::StartingNonVertical: EmergingEdges.push_front(traits.toEdge(ei)); break; case PLocTraits::StartingVertical: VerticalEdges.push_front(traits.toEdge(ei)); break; case PLocTraits::EndingNonVertical: SL.del(traits.makeCurve(G, traits.toEdge(ei))); break; case PLocTraits::EndingVertical: break; } } } // compute SL_at_X typename std::list::iterator cur_edge; for(cur_edge=VerticalEdges.begin(); cur_edge!=VerticalEdges.end(); ++cur_edge) SL.insert(traits.makeCurve(G, *cur_edge), Location(*cur_edge)); for(cur_node=NodesOnSL.begin(); cur_node!=NodesOnSL.end(); ++cur_node) SL.insert(traits.makeCurve(G, *cur_node), Location(*cur_node)); Sweepline SL_at_X = SL; // compute SL_in_X_plus for(cur_edge=VerticalEdges.begin(); cur_edge!=VerticalEdges.end(); ++cur_edge) SL.del(traits.makeCurve(G, *cur_edge)); for(cur_node=NodesOnSL.begin(); cur_node!=NodesOnSL.end(); ++cur_node) SL.del(traits.makeCurve(G, *cur_node)); for(cur_edge=EmergingEdges.begin(); cur_edge!=EmergingEdges.end(); ++cur_edge) SL.insert(traits.makeCurve(G, *cur_edge), Location(*cur_edge)); X_Structure.insertLines(traits.getXCoord(G, *NodesOnSL.begin()), SL_at_X, SL); } traits.sweep_end(); } template typename PointLocator::QueryResult PointLocator:: locate_down(const typename PLocTraits::Point& p) const { Sweepline_iterator line_at_x = X_Structure.getLineAt(traits.getXCoord(p)), line_plus = line_at_x; CGAL_NEF_TRACEN("locate_down "<locate_pred(p_curve), it_plus(0); if ( it && line_at_x->inf(it).is_node() && cmp(p_curve, line_at_x->key(it))!=0 ) { // p hit a feature exactly line_plus = line_at_x+1; if ( line_plus != X_Structure.end() ) it_plus = line_plus->locate_pred(p_curve); } return traits.PostProcess(location(line_at_x,it), location(line_plus,it_plus),p); } template typename PointLocator::QueryResult PointLocator::locate_up(const typename PLocTraits::Point& p) const { Sweepline_iterator line_at_x = X_Structure.getLineAt(traits.getXCoord(p)), line_plus; Curve p_curve = traits.makeCurve(p); PredCompareCurves cmp = traits.getCompareCurves(); SL_item it = line_at_x->locate_succ(p_curve), it_plus(0); if ( it && line_at_x->inf(it).is_node() && cmp(p_curve, line_at_x->key(it))!=0 ) { // p hit a feature exactly line_plus = line_at_x+1; if ( line_plus != X_Structure.end() ) it_plus = line_plus->locate_succ(p_curve); } return traits.PostProcess(location(line_at_x,it), location(line_plus,it_plus), p); } /*{\Mimplementation The implementation of the data type |\Mtype| is based on partially persistent binary search trees. The expected space requirement is $O(k)$ where $k$ is the sum of the number of nodes and the number of edges in the graph $G$. The expected time needed for construction and the operation |init| is $O(k \cdot \log k)$, for the |locate|-operations it is $O(\log k)$. The operation |clear| runs in $O(k)$. }*/ /*{\Mtext \headerline{\arabic{manctr}. Predefined traits classes} \stepcounter{manctr} All predefined traits classes have in common that the return type of a query is the type |Location|. The embedding of the given graph |G| is a straight-line embedding, so that it is totally determined by the position of the nodes of |G|. Such a position is specified by a |Point| which can be one of the LEDA point types |point| or |rat_point|. The positions can be specified implicitly by the node attribute of a parameterized graph (e.g. |GRAPH|) or explicitly by a |node_array|. In case of explicit specification a |node_array| with the positions of the nodes can be passed to the constructor of the traits class. Further, the point location processes for maps and for standard graphs differ slightly. As a map is a bidirected graph where each edge knows its reversal, the traits classes for maps can ensure the following property: If the result of a query for point |p| is an edge |e| (not containing |p|), then |e| bounds the face of |G| which contains |p|, i.e. |p| lies to the left of |e|.\\ Here comes a list of the predefined traits classes:\\[-5.5ex] \begin{itemize} \item |PLocTraits|: standard traits for implicitly specified node positions\\ |Graph| can be |GRAPH| (standard graph) or |PLANAR_MAP| (map). \item |PLocTraits_NodeArray|: std. traits for explicitly specified node positions\\ |Graph| can be |graph| (standard graph) or |planar_map| (map). \item |PLocTraits_Map| and |PLocTraits_Map_NodeArray|:\\ The parameter |Graph| can be |GRAPH| and |graph| respectively. These traits classes assume that the given graphs are maps. \item |PLocTraits< GRAPH >|: traits class for closest-site voronoi diagrams \end{itemize} Note that a traits class instantiated with |Graph| can also handle graph types which are derived from |Graph|. Thus |PLocTraits< graph >| can be used for graphs of type |ugraph| for example. }*/ /*{\Mexample First we show an example where the node positions are given implicitly as node attributes: \begin{verbatim} typedef PointLocator< PLocTraits< GRAPH > > PLocator1; typedef PLocator1::Location Location; UGRAPH G; ... // construct G PLocator1 PL1(G); Point p = ...; // compute p Location L1 = PL1.locate_down(p); \end{verbatim} The second example shows how a |node_array| can be used to determine the node positions: \begin{verbatim} typedef PLocTraits_NodeArray PLocTraits2; typedef PointLocator PLocator2; planar_map pm; node_array na; ... // construct pm and na PLocator2 PL2(pm, PLocTraits2(na)); Point q = ...; // compute q Location L2 = PL2.locate_up(q); \end{verbatim} }*/ #endif // GEN_POINT_LOCATION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Line_to_epoint.h0000644000175000017500000000476411344301501031105 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Line_to_epoint.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_LINE_TO_EPOINT_H #define CGAL_LINE_TO_EPOINT_H CGAL_BEGIN_NAMESPACE template struct Line_to_epoint { typedef Kernel_ Kernel; typedef typename Kernel::RT RT; typedef typename Kernel::FT FT; typedef typename Kernel::Line_2 Line_2; enum Point_type { SWCORNER=1, LEFTFRAME, NWCORNER, BOTTOMFRAME, STANDARD, TOPFRAME, SECORNER, RIGHTFRAME, NECORNER }; static RT dx(const Line_2& l) { return l.b(); } static RT dy(const Line_2& l) { return -l.a(); } static FT ordinate_distance(const Line_2& l) { return Kernel::make_FT(-l.c(),l.b()); } static Point_type determine_type(const Line_2& l) { RT adx = CGAL_NTS abs(dx(l)), ady = CGAL_NTS abs(dy(l)); int sdx = CGAL_NTS sign(dx(l)), sdy = CGAL_NTS sign(dy(l)); int cmp_dx_dy = CGAL_NTS compare(adx,ady), s(1); if (sdx < 0 && ( cmp_dx_dy > 0 || cmp_dx_dy == 0 && sdy != (s = CGAL_NTS sign(ordinate_distance(l))))) { if (0 == s) return ( sdy < 0 ? SWCORNER : NWCORNER ); else return LEFTFRAME; } else if (sdx > 0 && ( cmp_dx_dy > 0 || cmp_dx_dy == 0 && sdy != (s = CGAL_NTS sign(ordinate_distance(l))))) { if (0 == s) return ( sdy < 0 ? SECORNER : NECORNER ); else return RIGHTFRAME; } else if (sdy < 0 && ( cmp_dx_dy < 0 || cmp_dx_dy == 0 && ordinate_distance(l) < FT(0))) { return BOTTOMFRAME; } else if (sdy > 0 && ( cmp_dx_dy < 0 || cmp_dx_dy == 0 && ordinate_distance(l) > FT(0))) { return TOPFRAME; } CGAL_assertion_msg(false," determine_type: degenerate line."); return (Point_type)-1; // never come here } }; CGAL_END_NAMESPACE #endif //CGAL_LINE_TO_EPOINT_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_const_decorator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_const_decorat0000644000175000017500000005067011344301501031130 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_const_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_CONST_DECORATOR_H #define CGAL_PM_CONST_DECORATOR_H #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 7 #include CGAL_BEGIN_NAMESPACE template inline CGAL::Circulator_tag query_circulator_or_iterator(const CircFromIt& ) { return CGAL::Circulator_tag(); } template class move_halfedge_around_vertex { public: void forward(HE& e) const { e = (e->prev()->opposite()); } void backward(HE& e) const { e = (e->opposite()->next()); } }; template struct move_halfedge_around_face { void forward(HE& e) const { e = (e->next()); } void backward(HE& e) const { e = (e->prev()); } }; /*{\Moptions print_title=yes}*/ /*{\Moptions constref=yes}*/ /*{\Msubst PM_const_decorator#PMConstDecorator PM_decorator#PMDecorator }*/ /*{\Moptions outfile=PMConstDecorator.man }*/ /*{\Manpage {PMConstDecorator}{}{Topological plane map exploration}{D}}*/ template class PM_decorator; template class PM_const_decorator { typedef PM_const_decorator Self; /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator for interfacing the topological structure of a plane map |P| (read-only). A plane map |P| consists of a triple $(V, E, F)$ of vertices, edges, and faces. We collectively call them objects. An edge |e| is a pair of vertices |(v,w)| with incidence operations |v = source(e)|, |w = target(e)|. The list of all edges with source |v| is called the adjacency list |A(v)|. Edges are paired into twins. For each edge |e = (v,w)| there's an edge |twin(e) = (w,v)| and |twin(twin(e)) == e|\footnote{The existence of the edge pairs makes |P| a bidirected graph, the |twin| links make |P| a map.}. An edge |e = (v,w)| knows two adjacent edges |en = next(e)| and |ep = previous(e)| where |source(en) = w|, |previous(en) = e| and |target(ep) = v| and |next(ep) = e|. By this symmetric |previous-next| relationship all edges are partitioned into face cycles. Two edges $e$ and $e'$ are in the same face cycle if $e = |next|^*(e')$. All edges |e| in the same face cycle have the same incident face $f = |face|(e)$. The cyclic order on the adjacency list of a vertex |v = source(e)| is given by |cyclic_adj_succ(e) = twin(previous(e))| and |cyclic_adj_pred(e) = next(twin(e))|. A vertex |v| is embedded via coordinates |point(v)|. By the embedding of its source and target an edge corresponds to a segment. |P| has the property that the embedding is always \emph{order-preserving}. This means a ray fixed in |point(v)| of a vertex |v| and swept around counterclockwise meets the embeddings of |target(e)| ($e \in A(v)$) in the cyclic order defined by the list order of |A|. The embedded face cycles partition the plane into maximal connected subsets of points. Each such set corresponds to a face. A face is bounded by its incident face cycles. For all the edges in the non-trivial face cycles it holds that the face is left of the edges. There can also be trivial face cycles in form of isolated vertices in the interior of a face. Each such vertex |v| knows its surrounding face |f = face(v)|. We call the embedded map |(V,E)| also the $1$-skeleton of |P|. Plane maps are attributed. To each object $u \in V \cup E \cup F$ we attribute a value |mark(u)| of type |Mark|. |Mark| fits the concepts assignable, default-constructible, and equal-comparable.}*/ protected: HDS* phds; friend class PM_decorator; public: /*{\Mtypes 6}*/ typedef HDS Plane_map; /*{\Mtypemember The underlying plane map type}*/ typedef typename HDS::Traits Traits; typedef typename Traits::Point Point; /*{\Mtypemember The point type of vertices.}*/ typedef typename Traits::Mark Mark; /*{\Mtypemember All objects (vertices, edges, faces) are attributed by a |Mark| object.}*/ typedef size_t Size_type; /*{\Mtypemember The size type.}*/ typedef void* GenPtr; typedef typename HDS::Vertex Vertex; typedef typename HDS::Vertex_base Vertex_base; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge Halfedge ; typedef typename HDS::Halfedge_base Halfedge_base ; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face Face; typedef typename HDS::Face_base Face_base; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Face_const_iterator Face_const_iterator; /*{\Mtext Local types are handles, iterators and circulators of the following kind: |Vertex_const_handle|, |Vertex_const_iterator|, |Halfedge_const_handle|, |Halfedge_const_iterator|, |Face_const_handle|, |Face_\-const_\-ite\-rator|. Additionally the following circulators are defined.}*/ typedef CircFromIt< Halfedge_const_iterator, move_halfedge_around_vertex > Halfedge_around_vertex_const_circulator; /*{\Mtypemember circulating the outgoing halfedges in $A(v)$.}*/ typedef CircFromIt< Halfedge_const_iterator, move_halfedge_around_face > Halfedge_around_face_const_circulator; /*{\Mtypemember circulating the halfedges in the face cycle of a face |f|.}*/ typedef typename Face::Hole_const_iterator Hole_const_iterator; /*{\Mtypemember iterating all holes of a face |f|. The type is convertible to |Halfedge_const_handle|.}*/ typedef typename Face::Isolated_vertex_const_iterator Isolated_vertex_const_iterator; /*{\Mtypemember iterating all isolated vertices of a face |f|. The type generalizes |Vertex_const_handle|.}*/ typedef PntItFromVertIt Point_const_iterator; /*{\Mcreation 3}*/ PM_const_decorator() : phds(0) {} PM_const_decorator(const PM_const_decorator& D) : phds(D.phds) {} PM_const_decorator& operator=( const PM_const_decorator& D) { phds=D.phds; return *this; } PM_const_decorator(const Plane_map& P) /*{\Mcreate constructs a plane map decorator exploring |P|.}*/ : phds(const_cast(&P)) {} /*{\Moperations 4 4}*/ Vertex_const_handle source(Halfedge_const_handle e) const /*{\Mop returns the source of |e|.}*/ { return e->opposite()->vertex(); } Vertex_const_handle target(Halfedge_const_handle e) const /*{\Mop returns the target of |e|.}*/ { return e->vertex(); } Halfedge_const_handle twin(Halfedge_const_handle e) const /*{\Mop returns the twin of |e|.}*/ { return e->opposite(); } bool is_isolated(Vertex_const_handle v) const /*{\Mop returns |true| iff $A(v) = \emptyset$.}*/ { return v->is_isolated(); } Halfedge_const_handle first_out_edge(Vertex_const_handle v) const /*{\Mop returns one halfedge with source |v|. It's the starting point for the circular iteration over the halfedges with source |v|. \precond |!is_isolated(v)|.}*/ { return v->halfedge()->opposite(); } Halfedge_const_handle last_out_edge(Vertex_const_handle v) const /*{\Mop returns the halfedge with source |v| that is the last in the circular iteration before encountering |first_out_edge(v)| again. \precond |!is_isolated(v)|.}*/ { return v->halfedge()->next(); } Halfedge_const_handle cyclic_adj_succ( Halfedge_const_handle e) const /*{\Mop returns the edge after |e| in the cyclic ordered adjacency list of |source(e)|.}*/ { return e->prev()->opposite(); } Halfedge_const_handle cyclic_adj_pred( Halfedge_const_handle e) const /*{\Mop returns the edge before |e| in the cyclic ordered adjacency list of |source(e)|.}*/ { return e->opposite()->next(); } Halfedge_const_handle next(Halfedge_const_handle e) const /*{\Mop returns the next edge in the face cycle containing |e|.}*/ { return e->next(); } Halfedge_const_handle previous(Halfedge_const_handle e) const /*{\Mop returns the previous edge in the face cycle containing |e|.}*/ { return e->prev(); } Face_const_handle face(Halfedge_const_handle e) const /*{\Mop returns the face incident to |e|.}*/ { return e->face(); } Face_const_handle face(Vertex_const_handle v) const /*{\Mop returns the face incident to |v|. \precond |is_isolated(v)|.}*/ { return v->face(); } Halfedge_const_handle halfedge(Face_const_handle f) const /*{\Mop returns a halfedge in the bounding face cycle of |f| (|Halfedge_const_handle()| if there is no bounding face cycle).}*/ { return f->halfedge(); } /*{\Mtext \headerline{Iteration} \setopdims{7.5cm}{0cm}}*/ Vertex_const_iterator vertices_begin() const { return phds->vertices_begin(); } Halfedge_const_iterator halfedges_begin() const { return phds->halfedges_begin(); } Face_const_iterator faces_begin() const { return phds->faces_begin(); } Vertex_const_iterator vertices_end() const { return phds->vertices_end(); } Halfedge_const_iterator halfedges_end() const { return phds->halfedges_end(); } Face_const_iterator faces_end() const { return phds->faces_end(); } Point_const_iterator points_begin() const { return Point_const_iterator(vertices_begin()); } Point_const_iterator points_end() const { return Point_const_iterator(vertices_end()); } Halfedge_around_vertex_const_circulator out_edges(Vertex_const_handle v) const /*{\Mop returns a circulator for the cyclic adjacency list of |v|.}*/ { return Halfedge_around_vertex_const_circulator(first_out_edge(v)); } Halfedge_around_face_const_circulator face_cycle(Face_const_handle f) const /*{\Mop returns a circulator for the outer face cycle of |f|.}*/ { return Halfedge_around_face_const_circulator(f->halfedge()); } Hole_const_iterator holes_begin(Face_const_handle f) const /*{\Mop returns an iterator for all holes in the interior of |f|. A |Hole_iterator| can be assigned to a |Halfedge_around_face_const_circulator|.}*/ { return f->fc_begin(); } Hole_const_iterator holes_end(Face_const_handle f) const /*{\Mop returns the past-the-end iterator of |f|.}*/ { return f->fc_end(); } Isolated_vertex_const_iterator isolated_vertices_begin(Face_const_handle f) const /*{\Mop returns an iterator for all isolated vertices in the interior of |f|.}*/ { return f->iv_begin(); } Isolated_vertex_const_iterator isolated_vertices_end(Face_const_handle f) const /*{\Mop returns the past the end iterator of |f|.}*/ { return f->iv_end(); } /*{\Mtext \headerline{Associated Information}\setopdims{2.5cm}{4cm} The type |Mark| is the general attribute of an object. The type |GenPtr| is equal to type |void*|.}*/ const Point& point(Vertex_const_handle v) const /*{\Mop returns the embedding of |v|.}*/ { return v->point(); } const Mark& mark(Vertex_const_handle v) const /*{\Mop returns the mark of |v|.}*/ { return v->mark(); } const Mark& mark(Halfedge_const_handle e) const /*{\Mop returns the mark of |e|.}*/ { if (&*e < &*(e->opposite())) return e->mark(); else return e->opposite()->mark(); } // we store the mark in the container with smaller memory address ! const Mark& mark(Face_const_handle f) const /*{\Mop returns the mark of |f|.}*/ { return f->mark(); } const GenPtr& info(Vertex_const_handle v) const /*{\Mop returns a generic information slot.}*/ { return v->info(); } const GenPtr& info(Halfedge_const_handle e) const /*{\Mop returns a generic information slot.}*/ { return e->info(); } const GenPtr& info(Face_const_handle f) const /*{\Mop returns a generic information slot.}*/ { return f->info(); } /*{\Mtext \headerline{Statistics and Integrity}}*/ Size_type number_of_vertices() const /*{\Mop returns the number of vertices.}*/ { return phds->size_of_vertices(); } Size_type number_of_halfedges() const /*{\Mop returns the number of halfedges.}*/ { return phds->size_of_halfedges(); } Size_type number_of_edges() const /*{\Mop returns the number of halfedge pairs.}*/ { return phds->size_of_halfedges()/2; } Size_type number_of_faces() const /*{\Mop returns the number of faces.}*/ { return phds->size_of_faces(); } Size_type number_of_face_cycles() const; /*{\Mop returns the number of face cycles.}*/ Size_type number_of_connected_components() const; /*{\Mop calculates the number of connected components of |P|.}*/ void print_statistics(std::ostream& os = std::cout) const /*{\Mop print the statistics of |P|: the number of vertices, edges, and faces.}*/ { os << "Plane Map - Statistics\n"; os << "|V| = " << number_of_vertices() << std::endl; os << "|E| = " << number_of_edges() << " (" << 2*number_of_edges() << ")" << std::endl; os << "|F| = " << number_of_faces() << std::endl; os << "|Fcs| = " << number_of_face_cycles() << std::endl << std::endl; } void check_integrity_and_topological_planarity(bool faces=true) const; /*{\Mop checks the link structure and the genus of |P|.}*/ }; // PM_const_decorator template std::string PV(VH v) { std::ostringstream os; CGAL::set_pretty_mode(os); if (v != VH()) os << v->point(); else os << "nil"; return os.str(); } template std::string PE(HH e) { std::ostringstream os; if (e==HH()) return "nil"; os << "[" << PV(e->opposite()->vertex()) << "," << PV(e->vertex()) << " " << e->info() << "]"; return os.str(); } template void PM_const_decorator:: check_integrity_and_topological_planarity(bool faces) const { CGAL_NEF_TRACEN("check_integrity_and_topological_planarity:"); using CGAL::Object_index; Object_index VI(vertices_begin(),vertices_end(),'v'); Object_index EI(halfedges_begin(),halfedges_end(),'e'); Object_index FI(faces_begin(),faces_end(),'f'); typedef Halfedge_around_vertex_const_circulator hvc_circulator; typedef Halfedge_around_face_const_circulator hfc_circulator; Vertex_const_handle vit, vend = phds->vertices_end(); int iso_vert_num=0; /* check the source links of out edges and count isolated vertices */ for (vit = vertices_begin() ; vit != vend; ++vit) { if ( is_isolated(vit) ) { if ( faces ) CGAL_assertion_msg( vit->face() != Face_const_handle(), VI(vit).c_str()); ++iso_vert_num; } else { CGAL_assertion_msg( vit->halfedge() != Halfedge_const_handle(), VI(vit).c_str()); CGAL_assertion_msg( vit->halfedge()->vertex() == vit ,VI(vit).c_str()); } } /* check the bidirected links and the face pointer init */ Halfedge_const_iterator eit, eend = phds->halfedges_end(); for (eit = phds->halfedges_begin() ; eit != eend; ++eit) { CGAL_assertion( twin(twin(eit)) == eit ); CGAL_assertion( eit->vertex() != Vertex_const_handle() ); CGAL_assertion( next(eit) != Halfedge_const_handle() ); CGAL_assertion( previous(next(eit)) == eit ); CGAL_assertion( target(eit) == source(next(eit)) ); CGAL_assertion( previous(eit) != Halfedge_const_handle() ); CGAL_assertion( next(previous(eit)) == eit ); CGAL_assertion( target(previous(eit)) == source(eit) ); if ( !faces ) continue; CGAL_assertion( face(eit) != Face_const_handle() ); CGAL_assertion( face(next(eit)) == face(eit) ); CGAL_assertion( face(previous(eit)) == face(eit) ); } bool first=true; int fc_num(0),iv_num(0); Face_const_iterator fit; for (fit = faces_begin(); fit != faces_end(); ++fit) { if (!first) { CGAL_assertion( face(halfedge(fit))==fit ); ++fc_num; } Hole_const_iterator fcit; for( fcit = holes_begin(fit); fcit != holes_end(fit); ++fcit) { CGAL_assertion( face(fcit)==fit ); ++fc_num; } Isolated_vertex_const_iterator ivit; for(ivit = isolated_vertices_begin(fit); ivit != isolated_vertices_end(fit); ++ivit) { CGAL_assertion( face(ivit)==fit ); ++iv_num; } first=false; } int v_num = number_of_vertices() - iso_vert_num; int e_num = number_of_edges(); int c_num = number_of_connected_components() - iso_vert_num; int f_num = number_of_face_cycles() - c_num + 1; CGAL_NEF_TRACEV(fc_num);CGAL_NEF_TRACEV(iv_num);CGAL_NEF_TRACEV(iso_vert_num); CGAL_NEF_TRACEV(v_num);CGAL_NEF_TRACEV(e_num);CGAL_NEF_TRACEV(c_num);CGAL_NEF_TRACEV(f_num); // CGAL_assertion(fc_num == f_num && iv_num == iso_vert_num); /* this means all face cycles and all isolated vertices are indeed referenced from a face */ /* every isolated vertex increases the component count one face cycle per component is redundent except one finally check the Euler formula: */ CGAL_assertion( v_num - e_num + f_num == 1 + c_num ); } template typename PM_const_decorator::Size_type PM_const_decorator:: number_of_face_cycles() const { unsigned int fc_num=0; CGAL::Unique_hash_map visited; // init with bool() == false Halfedge_const_iterator eit = phds->halfedges_begin(); Halfedge_const_iterator eend = phds->halfedges_end(); for ( ; eit != eend; ++eit) { if (visited[eit]) continue; Halfedge_around_face_const_circulator hfc(eit), hend(hfc); CGAL_For_all(hfc,hend) visited[hfc]=true; ++fc_num; } return fc_num; } template size_t PM_const_decorator:: number_of_connected_components() const { typedef Vertex_const_iterator vc_handle; typedef Halfedge_around_vertex_const_circulator hvc_circulator; int comp_num=0; CGAL::Unique_hash_map< vc_handle, bool> handled(false); vc_handle vit = vertices_begin(), vend = vertices_end(); for ( ; vit != vend; ++vit) { if (handled[vit]) continue; std::list L; L.push_back(vit); handled[vit]=true; /* we keep the invariant that all nodes which have been stacked are marked handled */ while (!L.empty()) { vc_handle v=L.front(); L.pop_front(); if ( is_isolated(v) ) continue; hvc_circulator havc(first_out_edge(v)), hend(havc); CGAL_For_all(havc,hend) { if (!handled[target(havc)]) { L.push_back(target(havc)); handled[target(havc)]=true; } } } ++comp_num; } return comp_num; } struct KERNELPNT { template std::string operator() (const PNT& p) const { std::ostringstream os; os << "(" << CGAL::to_double(p.x()) << "," << CGAL::to_double(p.y()) << ")"; return os.str(); } }; template void print_as_leda_graph(std::ostream& os, const PMCDEC& D, const POINTDA& P) { typedef typename PMCDEC::Vertex_const_iterator Vertex_const_iterator; typedef typename PMCDEC::Halfedge_const_iterator Halfedge_const_iterator; int vn(1), en(1); CGAL::Unique_hash_map v_num; CGAL::Unique_hash_map e_num; os << "LEDA.GRAPH\n" << "point\n" << "int\n"; os << D.number_of_vertices() << std::endl; Vertex_const_iterator vit; for (vit = D.vertices_begin(); vit != D.vertices_end(); ++vit) { v_num[vit] = vn++; os << "|{(" << P(D.point(vit)) << ")}|\n"; typename PMCDEC::Halfedge_around_vertex_const_circulator ecirc(D.first_out_edge(vit)),ecend(ecirc); int l=0; CGAL_For_all(ecirc,ecend) e_num[ecirc]=l++; } os << 2* D.number_of_edges() << std::endl; Halfedge_const_iterator eit; for (eit = D.halfedges_begin(); eit != D.halfedges_end(); ++eit) { e_num[eit] = en++; } for (eit = D.halfedges_begin(); eit != D.halfedges_end(); ++eit) { os << v_num[D.source(eit)] << " " << v_num[D.target(eit)] << " " << e_num[D.twin(eit)] << " "; os << "|{" << e_num[eit] << "}|\n"; } os << std::flush; } CGAL_END_NAMESPACE #endif // CGAL_PM_CONST_DECORATOR_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Segment_overlay_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Segment_overlay_0000644000175000017500000006606711344301501031216 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Segment_overlay_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SEGMENT_OVERLAY_TRAITS_H #define CGAL_SEGMENT_OVERLAY_TRAITS_H #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 23 #include #if defined(CGAL_USE_LEDA) #include #include #include #include #include #include #include #include #include #include namespace CGAL { #ifdef CGAL_NEF_DEBUG #define PIS(s) (s->first()) #endif template class leda_seg_overlay_traits { public: typedef IT ITERATOR; typedef std::pair INPUT; typedef PMDEC OUTPUT; typedef typename PMDEC::Vertex_handle Vertex_handle; typedef typename PMDEC::Halfedge_handle Halfedge_handle; typedef GEOM GEOMETRY; typedef typename GEOMETRY::Point_2 Point_2; typedef typename GEOMETRY::Segment_2 Segment_2; typedef leda_two_tuple seg_pair; typedef seg_pair* ISegment; typedef leda_list IList; typedef typename IList::iterator ilist_iterator; // types interfacing the generic sweep frame: ITERATOR its, ite; OUTPUT& GO; const GEOMETRY& K; class cmp_segs_at_sweepline : public CGAL_LEDA_SCOPE::leda_cmp_base { const Point_2& p; ISegment s_bottom, s_top; // sentinel segments const GEOMETRY& K; public: cmp_segs_at_sweepline(const Point_2& pi, ISegment s1, ISegment s2, const GEOMETRY& k) : p(pi), s_bottom(s1), s_top(s2), K(k) {} int operator()(const ISegment& is1, const ISegment& is2) const { // Precondition: p is identical to the left endpoint of s1 or s2. if ( is2 == s_top || is1 == s_bottom ) return -1; if ( is1 == s_top || is2 == s_bottom ) return 1; if ( is1 == is2 ) return 0; const Segment_2& s1 = is1->first(); const Segment_2& s2 = is2->first(); int s = 0; if ( p == K.source(s1) ) s = K.orientation(s2,p); else if ( p == K.source(s2) ) s = - K.orientation(s1,p); else CGAL_assertion_msg(0,"compare error in sweep."); if ( s || K.is_degenerate(s1) || K.is_degenerate(s2) ) return s; s = K.orientation(s2,K.target(s1)); if (s==0) return ( is1 - is2 ); // overlapping segments are not equal return s; } }; struct cmp_pnts_xy : public CGAL_LEDA_SCOPE::leda_cmp_base { const GEOMETRY& K; public: cmp_pnts_xy(const GEOMETRY& k) : K(k) {} int operator()(const Point_2& p1, const Point_2& p2) const { return K.compare_xy(p1,p2); } }; typedef leda_sortseq EventQueue; typedef leda_sortseq SweepStatus; typedef leda_p_queue SegQueue; typedef leda_map AssocEdgeMap; typedef leda_slist IsoList; typedef leda_map AssocIsoMap; typedef leda_map2 EventHash; CGAL_LEDA_SCOPE::seq_item event; Point_2 p_sweep; cmp_pnts_xy cmp; EventQueue XS; seg_pair sl,sh; cmp_segs_at_sweepline SLcmp; SweepStatus YS; SegQueue SQ; EventHash IEvent; IList Internal; AssocEdgeMap Edge_of; AssocIsoMap Isos_of; leda_seg_overlay_traits(const INPUT& in, OUTPUT& G, const GEOMETRY& k) : its(in.first), ite(in.second), GO(G), K(k), cmp(K), XS(cmp), SLcmp(p_sweep,&sl,&sh,K), YS(SLcmp), SQ(cmp), IEvent(0), Edge_of(0), Isos_of(0) {} leda_string dump_structures() const { std::ostringstream out; out << "SQ= "; CGAL_LEDA_SCOPE::pq_item pqit; forall_items(pqit,SQ) { if (SQ.prio(pqit)==XS.key(XS.succ(XS.min_item()))) { out << SQ.inf(pqit)->first(); } pqit = SQ.next_item(pqit); } CGAL_LEDA_SCOPE::seq_item sit; out << "\nXS=\n"; forall_items(sit,XS) out << " " << XS.key(sit) << " " << XS.inf(sit) <first()<<" "<first()); } Point_2 target(ISegment is) const { return K.target(is->first()); } ITERATOR original(ISegment s) const { return s->second(); } int orientation(CGAL_LEDA_SCOPE::seq_item sit, const Point_2& p) const { return K.orientation(YS.key(sit)->first(),p); } bool collinear(CGAL_LEDA_SCOPE::seq_item sit1, CGAL_LEDA_SCOPE::seq_item sit2) const { Point_2 ps = source(YS.key(sit2)), pt = target(YS.key(sit2)); return ( orientation(sit1,ps)==0 && orientation(sit1,pt)==0 ); } void compute_intersection(CGAL_LEDA_SCOPE::seq_item sit0) { CGAL_LEDA_SCOPE::seq_item sit1 = YS.succ(sit0); if ( sit0 == YS.min_item() || sit1 == YS.max_item() ) return; ISegment s0 = YS.key(sit0); ISegment s1 = YS.key(sit1); int or0 = K.orientation(s0->first(),target(s1)); int or1 = K.orientation(s1->first(),target(s0)); if ( or0 <= 0 && or1 >= 0 ) { CGAL_LEDA_SCOPE::seq_item it = IEvent(YS.key(sit0),YS.key(sit1)); if ( it==0 ) { Point_2 q = K.intersection(s0->first(),s1->first()); it = XS.insert(q,sit0); } YS.change_inf(sit0, it); } } void initialize_structures() { CGAL_NEF_TRACEN("initialize_structures"); ITERATOR it_s; for ( it_s=its; it_s != ite; ++it_s ) { Segment_2 s = *it_s; CGAL_LEDA_SCOPE::seq_item it1 = XS.insert( K.source(s), CGAL_LEDA_SCOPE::seq_item(nil)); CGAL_LEDA_SCOPE::seq_item it2 = XS.insert( K.target(s), CGAL_LEDA_SCOPE::seq_item(nil)); if (it1 == it2) { if ( Isos_of[it1] == 0 ) Isos_of[it1] = new IsoList; Isos_of[it1]->push(it_s); continue; // ignore zero-length segments in SQ/YS } Point_2 p = XS.key(it1); Point_2 q = XS.key(it2); Segment_2 s1; if ( K.compare_xy(p,q) < 0 ) s1 = K.construct_segment(p,q); else s1 = K.construct_segment(q,p); Internal.append(seg_pair(s1,it_s)); SQ.insert(K.source(s1),&Internal[Internal.last()]); } // insert a lower and an upper sentinel segment YS.insert(&sl,CGAL_LEDA_SCOPE::seq_item(nil)); YS.insert(&sh,CGAL_LEDA_SCOPE::seq_item(nil)); CGAL_NEF_TRACEN("end of initialization\n"<>> process_event: "< #include #include #include namespace CGAL { template class stl_seg_overlay_traits { public: typedef IT ITERATOR; typedef std::pair INPUT; typedef PMDEC OUTPUT; typedef typename PMDEC::Vertex_handle Vertex_handle; typedef typename PMDEC::Halfedge_handle Halfedge_handle; typedef GEOM GEOMETRY; typedef typename GEOMETRY::Point_2 Point_2; typedef typename GEOMETRY::Segment_2 Segment_2; typedef std::pair seg_pair; typedef seg_pair* ISegment; typedef std::list IList; typedef typename IList::const_iterator ilist_iterator; // types interfacing the generic sweep frame ITERATOR its, ite; OUTPUT& GO; const GEOMETRY& K; class lt_segs_at_sweepline { const Point_2& p; ISegment s_bottom, s_top; // sentinel segments const GEOMETRY& K; public: lt_segs_at_sweepline(const Point_2& pi, ISegment s1, ISegment s2, const GEOMETRY& k) : p(pi), s_bottom(s1), s_top(s2), K(k) {} lt_segs_at_sweepline(const lt_segs_at_sweepline& lt) : p(lt.p), s_bottom(lt.s_bottom), s_top(lt.s_top), K(lt.K) {} bool operator()(const ISegment& is1, const ISegment& is2) const { if ( is2 == s_top || is1 == s_bottom ) return true; if ( is1 == s_top || is2 == s_bottom ) return false; if ( is1 == is2 ) return false; // Precondition: p is contained in s1 or s2. const Segment_2& s1 = is1->first; const Segment_2& s2 = is2->first; int s = 0; if ( K.orientation(s1,p) == 0 ) s = K.orientation(s2,p); else if ( K.orientation(s2,p) == 0 ) s = - K.orientation(s1,p); else CGAL_assertion_msg(0,"compare error in sweep."); if ( s || K.is_degenerate(s1) || K.is_degenerate(s2) ) return ( s < 0 ); s = K.orientation(s2,K.target(s1)); if (s==0) return ( is1 - is2 ) < 0; // overlapping segments are not equal return ( s < 0 ); } }; struct lt_pnts_xy { const GEOMETRY& K; public: lt_pnts_xy(const GEOMETRY& k) : K(k) {} lt_pnts_xy(const lt_pnts_xy& lt) : K(lt.K) {} int operator()(const Point_2& p1, const Point_2& p2) const { return K.compare_xy(p1,p2) < 0; } }; typedef std::map SweepStatus; typedef typename SweepStatus::iterator ss_iterator; typedef typename SweepStatus::value_type ss_pair; typedef std::list IsoList; typedef std::map EventQueue; typedef typename EventQueue::iterator event_iterator; typedef typename EventQueue::value_type event_pair; typedef std::multimap SegQueue; typedef typename SegQueue::iterator seg_iterator; typedef typename SegQueue::value_type ps_pair; event_iterator event; Point_2 p_sweep; EventQueue XS; seg_pair sl,sh; SweepStatus YS; SegQueue SQ; IList Internal; stl_seg_overlay_traits(const INPUT& in, OUTPUT& G, const GEOMETRY& k) : its(in.first), ite(in.second), GO(G), K(k), XS(lt_pnts_xy(K)), YS(lt_segs_at_sweepline(p_sweep,&sl,&sh,K)), SQ(lt_pnts_xy(K)) {} std::string dump_structures() const { std::ostringstream out; out << "EventQueue:\n"; typename EventQueue::const_iterator sit1; for(sit1 = XS.begin(); sit1 != XS.end(); ++sit1) out << " " << sit1->first << std::endl; out << "SegQueue:\n"; typename SegQueue::const_iterator sit2; for(sit2 = SQ.begin(); sit2 != SQ.end(); ++sit2) out << " " << sit2->first << " " << sit2->second << " " << sit2->first << std::endl; out << "SweepStatus:\n"; typename SweepStatus::const_iterator sit3; for( sit3 = YS.begin(); sit3 != YS.end(); ++sit3 ) out << sit3->first << std::endl; return out.str(); } Point_2 source(ISegment is) const { return K.source(is->first); } Point_2 target(ISegment is) const { return K.target(is->first); } ITERATOR original(ISegment s) const { return s->second; } int orientation(ss_iterator sit, const Point_2& p) const { return K.orientation(sit->first->first,p); } bool collinear(ss_iterator sit1, ss_iterator sit2) const { Point_2 ps = source(sit2->first), pt = target(sit2->first); return ( orientation(sit1,ps)==0 && orientation(sit1,pt)==0 ); } void compute_intersection(ss_iterator sit0) { // Given an item |sit0| in the Y-structure compute the point of // intersection with its successor and (if existing) insert it into // the event queue and do all necessary updates. ss_iterator sit1 = sit0; ++sit1; CGAL_NEF_TRACEN("compute_intersection "<first<<" "<first); if ( sit0 == YS.begin() || sit1 == --YS.end() ) return; const Segment_2& s0 = sit0->first->first; const Segment_2& s1 = sit1->first->first; int or0 = K.orientation(s0,K.target(s1)); int or1 = K.orientation(s1,K.target(s0)); if ( or0 <= 0 && or1 >= 0 ) { Point_2 q = K.intersection(s0,s1); XS.insert(event_pair(q,0)); // only done if none existed!!! } } void initialize_structures() { /* INITIALIZATION - insert all vertices into the x-structure - insert sentinels into y-structure - exploit the fact that insert operations into the x-structure leave previously inserted points unchanged to achieve that any pair of endpoints $p$ and $q$ with |p == q| are identical */ CGAL_NEF_TRACEN("initialize_structures"); ITERATOR it_s; for ( it_s=its; it_s != ite; ++it_s ) { const Segment_2& s = *it_s; event_iterator it1 = (XS.insert(event_pair(K.source(s),0))).first; event_iterator it2 = (XS.insert(event_pair(K.target(s),0))).first; // note that the STL only inserts if key is not yet in XS if (it1 == it2) { if ( it1->second == 0 ) it1->second = new IsoList; it1->second->push_front(it_s); continue; // ignore zero-length segments regarding YS } Point_2 p = it1->first; Point_2 q = it2->first; Segment_2 s1; if ( K.compare_xy(p,q) < 0 ) s1 = K.construct_segment(p,q); else s1 = K.construct_segment(q,p); Internal.push_back(seg_pair(s1,it_s)); SQ.insert(ps_pair(K.source(s1),&Internal.back())); } // insert a lower and an upper sentinel segment to avoid special // cases when traversing the Y-structure YS.insert(ss_pair(&sl,Halfedge_handle())); YS.insert(ss_pair(&sh,Halfedge_handle())); CGAL_NEF_TRACEN("end of initialization\n"); } bool event_exists() { if (!XS.empty()) { // event is set at end of loop and in init event = XS.begin(); p_sweep = event->first; return true; } return false; } void procede_to_next_event() { XS.erase(event); } void process_event() { CGAL_NEF_TRACEN("\n\n >>> process_event: "<first is ending or passing segment // Determine upper bundle item: CGAL_NEF_TRACEN("ending/passing segs"); /* Walk down until |sit_pred|, close edges for all segments in the bundle, delete all segments in the bundle, but reinsert the continuing ones */ std::list L_tmp; bool overlapping; do { ISegment s = sit->first; ss_iterator sit_next(sit); --sit_next; overlapping = (sit_next != YS.begin()) && collinear(sit,sit_next); Halfedge_handle e = sit->second; if ( overlapping ) { CGAL_NEF_TRACEN("overlapping segment "<first); CGAL_NEF_TRACEN("\n "<first); /* Interfaceproposition for next chunk: - succ(sit_pred) == sit_first == sit_succ - bundle not empty: sit_first != sit_succ */ // delete and reinsert the continuing bundle YS.erase(sit_first,sit_succ); typename std::list::const_iterator lit; for ( lit = L_tmp.begin(); lit != L_tmp.end(); ++lit ) { YS.insert(sit_pred,ss_pair(*lit,Halfedge_handle())); } } // if (sit != ss_iterator() ) assert( sit_pred != YS.end() ); GO.halfedge_below(v,sit_pred->second); if ( event->second != 0 ) { const IsoList& IL = *(event->second); typename IsoList::const_iterator iso_it; for (iso_it = IL.begin(); iso_it != IL.end(); ++iso_it) GO.trivial_segment(v,*iso_it); delete (event->second); } ISegment next_seg; seg_iterator next_it = SQ.begin(); while ( next_it != SQ.end() && ( next_seg = next_it->second, p_sweep == source(next_seg)) ) { CGAL_NEF_TRACEN("inserting "<first<<"\n "<first); if ( sit_curr != YS.begin() && sit_prev != --YS.end() && collinear(sit_curr,sit_prev) ) // overlapping sit_curr->second = sit_prev->second; else { CGAL_NEF_TRACEN("creating new edge"); sit_curr->second = GO.new_halfedge_pair_at_source(v); } } sit_first = sit_prev; // compute possible intersections between |sit_pred| and its // successor and |sit_succ| and its predecessor CGAL_NEF_TRACEN("pred,succ = "<first<<" "<first); compute_intersection(sit_pred); sit = sit_succ; --sit; if (sit != sit_pred) compute_intersection(sit); } void complete_structures() {} void check_invariants() {CGAL_NEF_TRACEN("check_invariants\n"< #endif // CGAL_SEGMENT_OVERLAY_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Object_handle.h0000644000175000017500000000445411344301501030653 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Object_handle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra // Andreas Fabri // Geert-Jan Giezeman // Michael Seel // Sylvain Pion // ====================================================================== #ifndef CGAL_OBJECT_HANDLE_H #define CGAL_OBJECT_HANDLE_H #include #include CGAL_BEGIN_NAMESPACE template class Handle_wrapper : public Ref_counted_virtual { public: Handle_wrapper(const T& object) : _object(object) {} Handle_wrapper() {} operator T() const { return _object; } ~Handle_wrapper() {} private: T _object; }; class Object_handle : public Handle_for_virtual { struct empty{}; typedef Handle_for_virtual base; public: Object_handle() { initialize_with(Handle_wrapper()); } template Object_handle(const T&t) { initialize_with(Handle_wrapper(t)); } template bool assign(T &t) const { const Handle_wrapper *wp = dynamic_cast *>(Ptr()); if ( wp == static_cast *>(0) ) return false; t = *(wp); return true; } bool is_empty() const { empty E; return assign(E); } bool operator==(CGAL_NULL_TYPE n) const { CGAL_assertion(n == 0); return is_empty(); } bool operator!=(CGAL_NULL_TYPE n) const { CGAL_assertion(n == 0); return !is_empty(); } }; template inline bool assign(T& t, const Object_handle& o) { return o.assign(t); } CGAL_END_NAMESPACE #endif // CGAL_OBJECT_HANDLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/debug.h0000644000175000017500000000405611344301501027216 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/debug.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DEBUG_H #define CGAL_DEBUG_H #include #ifdef NDEBUG #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 0 #endif #if CGAL_NEF_DEBUG>0 static int debugthread=1; #endif #undef CGAL_NEF_TRACE #undef CGAL_NEF_TRACEN #undef CGAL_NEF_TRACEV #undef CGAL_NEF_CTRACE #undef CGAL_NEF_CTRACEN #undef ASSERT #undef CGAL_NEF_SETDTHREAD #if CGAL_NEF_DEBUG>0 #define CGAL_NEF_SETDTHREAD(l) debugthread=l #else #define CGAL_NEF_SETDTHREAD(l) #endif #if CGAL_NEF_DEBUG>0 #define CGAL_NEF_TRACE(t) if((debugthread%CGAL_NEF_DEBUG)==0) \ std::cerr<<" "<0 #define CGAL_NEF_TRACEV(t) if((debugthread%CGAL_NEF_DEBUG)==0) \ std::cerr<<" "<<#t<<" = "<<(t)<0 #define CGAL_NEF_TRACEN(t) if((debugthread%CGAL_NEF_DEBUG)==0) \ std::cerr<<" "<0 #define CGAL_NEF_CTRACE(b,t) if(b) std::cerr<<" "<0 #define CGAL_NEF_CTRACEN(b,t) if(b) std::cerr<<" "< #ifndef GENINFO_H #define GENINFO_H #include /*{\Moptions outfile=geninfo.man}*/ /*{\Moptions constref=yes}*/ /*{\Manpage {geninfo} {T} {Information association via GenPtr} {}}*/ template struct geninfo { typedef void* GenPtr; /*{\Mdefinition |\Mname| encapsulates information association via generic pointers of type |GenPtr (=void*)|. An object |t| of type |T| is stored directly in a variable |p| of type |GenPtr| if |sizeof(T)| is not larger than |sizeof(GenPtr)| (also called word size). Otherwise |t| is allocated on the heap and referenced via |p|. This class encapsulates the technicalities, however the user always has to obey the order of its usage: |create|-|access/const_access|-|clear|. On misuse memory problems occur.}*/ /*{\Moperations 2 1}*/ #ifdef __BORLANDC__ #pragma option -w-rch -w-eff -w-ccc #endif static void create(GenPtr& p) /*{\Mstatic create a slot for an object of type |T| referenced via |p|.}*/ { if (sizeof(T) <= sizeof(GenPtr)) new((void*)(&p)) T; if (sizeof(T) > sizeof(GenPtr)) p = (GenPtr) new T; } static T& access(GenPtr& p) /*{\Mstatic access an object of type |T| via |p|. \precond |p| was initialized via |create| and was not cleared via |clear|.}*/ { if (sizeof(T) <= sizeof(GenPtr)) return *(T*)(&p); else return *(T*)p; } static const T& const_access(const GenPtr& p) /*{\Mstatic read-only access of an object of type |T| via |p|. \precond |p| was initialized via |create| and was not cleared via |clear|.}*/ { if (sizeof(T) <= sizeof(GenPtr)) return *(const T*)(&p); else return *(const T*)p; } static void clear(GenPtr& p) /*{\Mstatic clear the memory used for the object of type |T| via |p|. \precond |p| was initialized via |create|.}*/ { if (sizeof(T) <= sizeof(GenPtr)) ((T*)(&p))->~T(); if (sizeof(T) > sizeof(GenPtr)) delete (T*) p; p=0; } }; /*{\Mexample In the first example we store a pair of boolean values which normally fit into one word. Thus there will no heap allocation take place. \begin{Mverb} struct A { bool a,b }; GenPtr a; geninfo::create(a); A& a_access = geninfo::access(a); geninfo::clear(a); \end{Mverb} The second example uses the heap scheme as two longs do not fit into one word. \begin{Mverb} struct B { long a,b }; GenPtr b; geninfo::create(b); B& b_access = geninfo::access(b); geninfo::clear(b); \end{Mverb} Note that usage of the scheme takes away with the actual check for the type size. Even more important this size might depend on the platform which is used to compile the code and thus the scheme enables platform independent programming.}*/ #endif //GENINFO_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_visualizor.h0000644000175000017500000002314511344301501030733 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_visualizor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef PM_VISUALIZOR_H #define PM_VISUALIZOR_H #include #include #include #if defined(CGAL_USE_CGAL_WINDOW) #define leda_color CGAL::color #endif #define LGREY CGAL::Color(190,190,190) #define DGREY CGAL::Color(130,130,130) CGAL_BEGIN_NAMESPACE template class PM_BooleColor { typedef typename PMCDEC::Vertex_const_handle Vertex_const_handle; typedef typename PMCDEC::Halfedge_const_handle Halfedge_const_handle; typedef typename PMCDEC::Face_const_handle Face_const_handle; typedef typename PMCDEC::Mark Mark; public: Color color(Vertex_const_handle, const Mark& m) const { return ( m ? CGAL::BLACK : LGREY ); } int width(Vertex_const_handle, const Mark& m) const { return 3; } Color color(Halfedge_const_handle, const Mark& m) const { return ( m ? CGAL::BLACK : LGREY ); } int width(Halfedge_const_handle, const Mark& m) const { return 2; } Color color(Face_const_handle, const Mark& m) const { return ( m ? DGREY : CGAL::WHITE ); } }; template class PM_DefColor { CGAL::Color _cs, _cf; int _wv, _we; public: PM_DefColor() : _cs(CGAL::BLACK), _cf(CGAL::WHITE), _wv(3), _we(2) {} PM_DefColor(CGAL::Color cs, CGAL::Color cf, int wv, int we) : _cs(cs), _cf(cf), _wv(wv), _we(we) {} typedef typename PMCDEC::Vertex_const_handle Vertex_const_handle; typedef typename PMCDEC::Halfedge_const_handle Halfedge_const_handle; typedef typename PMCDEC::Face_const_handle Face_const_handle; typedef typename PMCDEC::Mark Mark; Color color(Vertex_const_handle, const Mark&) const { return _cs; } int width(Vertex_const_handle, const Mark&) const { return _wv; } Color color(Halfedge_const_handle, const Mark&) const { return _cs; } int width(Halfedge_const_handle, const Mark&) const { return _we; } Color color(Face_const_handle, const Mark&) const { return _cf; } }; /*{\Moptions outfile=PM_visualizor.man }*/ /*{\Manpage {PM_visualizor}{PMCDEC,GEOM,COLORDA}{Drawing plane maps}{V}}*/ template > class PM_visualizor : public PMCDEC { /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to draw the structure of a plane map into a CGAL window stream. It is generic with respect to two template concepts. |PMCDEC| has to be a decorator model of our |PM_const_decorator| concept. |GEOM| has to be a model of our geometry kernel concept. The data accessor |COLORDA| has to have two members determining the visualization parameters of the objects of |P|:\\ |CGAL::Color color(Vertex/Halfedge/Face_const_handle h) const|\\ |int width(Vertex/Halfedge_const_handle h) const|. }*/ /*{\Mgeneralization PMCDEC}*/ /*{\Mtypes 3}*/ public: typedef PM_visualizor Self; typedef PMCDEC Base; typedef typename PMCDEC::Plane_map Plane_map; typedef typename PMCDEC::Vertex_const_handle Vertex_const_handle; typedef typename PMCDEC::Halfedge_const_handle Halfedge_const_handle; typedef typename PMCDEC::Face_const_handle Face_const_handle; typedef typename PMCDEC::Vertex_const_iterator Vertex_const_iterator; typedef typename PMCDEC::Halfedge_const_iterator Halfedge_const_iterator; typedef typename PMCDEC::Face_const_iterator Face_const_iterator; typedef typename PMCDEC::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; typedef typename PMCDEC::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename PMCDEC::Hole_const_iterator Hole_const_iterator; typedef typename PMCDEC::Isolated_vertex_const_iterator Isolated_vertex_const_iterator; typedef typename PMCDEC::Point Point; typedef typename PMCDEC::Mark Mark; typedef typename GEOM::Segment_2 Segment; typedef CGAL::Cartesian::Point_2 Draw_point; typedef PMCDEC PM_const_decorator; /*{\Mtypemember The plane map decorator.}*/ typedef GEOM Geometry; /*{\Mtypemember The used geometry.}*/ typedef COLORDA Color_objects; /*{\Mtypemember The color data accessor.}*/ CGAL::Window_stream& _W; const Geometry& _K; const Color_objects& _CO; /*{\Mcreation 4}*/ PM_visualizor(CGAL::Window_stream& W, const PM_const_decorator& D, const Geometry& K = Geometry(), const Color_objects& C = Color_objects() ) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to visualize the vertices, edges, and faces of |D| in window |W|. The coloring of the objects is determined by data accessor |C|.}*/ : Base(D), _W(W), _K(K), _CO(C) { _W.set_node_width(3); _W.set_line_width(2); } /*{\Moperations 2 1}*/ void draw(Vertex_const_handle v) const /*{\Mop draws |v| according to the color and width specified by |C.color(v)| and |C.width(v)|.}*/ { int ow = _W.set_node_width(_CO.width(v,mark(v))); _W << _CO.color(v,mark(v)) << point(v); _W.set_node_width(ow); } void draw(Halfedge_const_handle e) const /*{\Mop draws |e| according to the color and width specified by |C.color(e)| and |C.width(e)|.}*/ { int ow = _W.set_line_width(_CO.width(e,mark(e))); Segment s = _K.construct_segment(point(source(e)),point(target(e))); _W << _CO.color(e,mark(e)) << s; _W.set_line_width(ow); } void draw_face_cycle(const std::list& fc, int c) const { int n = fc.size(); double* xc = new double[n]; double* yc = new double[n]; int i = 0; std::list::const_iterator it; for (it = fc.begin(); it != fc.end(); ++i,++it) { xc[i] = (*it).x(); yc[i] = (*it).y(); } _W.clip_mask_polygon(n,xc,yc,c); delete[] xc; delete[] yc; } void get_point_list(std::list& L, Halfedge_const_iterator e) const { Halfedge_around_face_const_circulator fcirc(e), fend(fcirc); CGAL_For_all(fcirc,fend) { Point p = point(target(fcirc)); L.push_back(Draw_point(CGAL::to_double(p.x()), CGAL::to_double(p.y()))); } } void draw(Face_const_handle f) const /*{\Mop draws |f| with color |C.color(f)|.}*/ { CGAL::Color cc = _CO.color(f,mark(f)); leda_color c (cc.r(),cc.g(),cc.b()); std::list outer_cycle; // First the outer face cycle: get_point_list(outer_cycle,halfedge(f)); double x0 = _W.xmin(); double y0 = _W.ymin(); double x1 = _W.xmax(); double y1 = _W.ymax(); if ( _W.is_buffering() ) { x0 = _W.xreal(0); y0 = _W.yreal(_W.height()); x1 = _W.xreal(_W.width()); y1 = _W.yreal(0); } _W.reset_clip_mask(); std::list frame; frame.push_back(Draw_point(x0,y0)); frame.push_back(Draw_point(x1,y0)); frame.push_back(Draw_point(x1,y1)); frame.push_back(Draw_point(x0,y1)); frame.reverse(); draw_face_cycle(frame,0); // enforcing transparent mode outside f and inside frame draw_face_cycle(outer_cycle,1); // drawing non-transparent outer face cycle Hole_const_iterator hole_it; for (hole_it = holes_begin(f); hole_it != holes_end(f); ++hole_it) { std::list hole; get_point_list(hole,hole_it); draw_face_cycle(hole,0); // enforcing transparent mode for holes } Isolated_vertex_const_iterator iv_it; for (iv_it = isolated_vertices_begin(f); iv_it != isolated_vertices_end(f); ++iv_it) { draw(iv_it); } _W.draw_box(x0,y0,x1,y1,c); _W.reset_clip_mask(); } void draw_map() const /*{\Mop draw the whole plane map.}*/ { Face_const_iterator fit = faces_begin(), fend = faces_end(); // we don't draw the first face outside the box: for ( ++fit; fit != fend; ++fit) draw(fit); // draw segments underlying halfedges: Halfedge_const_iterator hit, hend = halfedges_end(); for (hit = halfedges_begin(); hit != hend; ++(++hit)) draw(hit); // draw points underlying vertices: Vertex_const_iterator vit, vend = vertices_end(); for (vit = vertices_begin(); vit != vend; ++vit) draw(vit); } void init_window() const { _W.set_show_coordinates(true); _W.init(-110,110,-110); _W.display(); _W.set_node_width(3); } void draw_skeleton(const CGAL::Color& c=CGAL::BLACK) const { int old = _W.set_line_width(1); _W << c; Halfedge_const_iterator hit, hend = halfedges_end(); for (hit = halfedges_begin(); hit != hend; ++(++hit)) _W << _K.construct_segment(point(source(hit)),point(target(hit))); // draw points underlying vertices: Vertex_const_iterator vit, vend = vertices_end(); for (vit = vertices_begin(); vit != vend; ++vit) _W << point(vit); _W.set_line_width(old); } void draw_ending_bundle(Vertex_const_handle v, const CGAL::Color& c=CGAL::BLACK) { if (is_isolated(v)) return; _W << c; Halfedge_around_vertex_const_circulator hc(first_out_edge(v)), hend(hc); CGAL_For_all(hc,hend) { Point p1=point(source(hc)), p2=point(target(hc)); if ( _K.compare_xy(p1,p2)>0 ) _W << _K.construct_segment(p1,p2); } } }; // end of PM_visualizor CGAL_END_NAMESPACE #undef CGAL_USING #undef LGREY #undef DGREY #endif // PM_VISUALIZOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_checker.h0000644000175000017500000002437011344301501030131 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_checker.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_CHECKER_H #define CGAL_PM_CHECKER_H #include #include #include CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=PM_checker.man }*/ /*{\Manpage {PM_checker}{PMCDEC,GEOM}{Plane map checking}{}}*/ /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to check the structure of a plane map. It is generic with respect to two template concepts. |PMCDEC| has to be a decorator model of our |PM_const_decorator| concept. |GEOM| has to be a model of our geometry kernel concept.}*/ /*{\Mgeneralization PM_const_decorator}*/ template class PM_checker : public PMCDEC { typedef PMCDEC Base; const GEOM& K; public: /*{\Mtypes 3}*/ typedef PMCDEC PM_const_decorator; /*{\Mtypemember equals |PMCDEC|.}*/ typedef typename PMCDEC::Plane_map Plane_map; /*{\Mtypemember equals |PMCDEC::Plane_map|, the underlying plane map type.}*/ typedef GEOM Geometry; /*{\Mtypemember equals |GEOM|. Add link to GEOM concept.\\ \precond |Geometry::Point_2| equals |Plane_map::Point|. }*/ typedef typename GEOM::Point_2 Point; typedef typename GEOM::Direction_2 Direction; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Vertex_const_iterator Vertex_const_iterator; typedef typename Base::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Base::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename Base::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::clear; using Base::vertices_begin; using Base::vertices_end; using Base::halfedges_begin; using Base::halfedges_end; using Base::faces_begin; using Base::faces_end; using Base::number_of_vertices; using Base::number_of_halfedges; using Base::number_of_edges; using Base::number_of_faces; using Base::number_of_connected_components; using Base::check_integrity_and_topological_planarity; #endif /*{\Mtext Iterators, handles, and circulators are inherited from |PM_const_decorator|.}*/ /*{\Mcreation 3}*/ PM_checker(Plane_map& P, const Geometry& k = Geometry()) : Base(P), K(k) {} /*{\Mcreate constructs a plane map checker working on |P| with geometric predicates used from |k|.}*/ PM_checker(const Base& D, const Geometry& k = Geometry()) : Base(D), K(k) {} /*{\Moperations 2 }*/ Direction direction(Halfedge_const_handle e) const { return K.construct_direction( point(source(e)),point(target(e))); } bool is_forward(Halfedge_const_handle e) const { return K.compare_xy(point(source(e)),point(target(e)))<0; } void check_order_preserving_embedding(Vertex_const_handle v) const; /*{\Mop checks if the embedding of the targets of the edges in the adjacency list |A(v)| is counter-clockwise order-preserving with respect to the order of the edges in |A(v)|.}*/ void check_order_preserving_embedding() const; /*{\Mop checks if the embedding of all vertices of |P| is counter-clockwise order-preserving with respect to the adjacency list ordering of all vertices.}*/ void check_forward_prefix_condition(Vertex_const_handle v) const; /*{\Mop checks the forward-prefix property of the adjacency list of |v|.}*/ Halfedge_const_iterator check_boundary_is_clockwise_weakly_polygon() const; /*{\Mop checks if the outer face cycle of |P| is a clockwise weakly polygon and returns a halfedge on the boundary. \precond |P| is a connected graph. }*/ void check_is_triangulation() const; /*{\Mop checks if |P| is a triangulation.}*/ }; // PM_checker template void PM_checker:: check_order_preserving_embedding(Vertex_const_handle v) const { if ( is_isolated(v) ) return; std::ostringstream error_status; CGAL::set_pretty_mode ( error_status ); Halfedge_const_handle ef = first_out_edge(v) ,e=ef,en,enn; error_status << "check_order_preserving_embedding\n"; error_status << "vertex " << PV(v) << std::endl; error_status << "ef " << PE(ef) << std::endl; while ( true ) { en = cyclic_adj_succ(e); enn = cyclic_adj_succ(en); if (en == ef) break; error_status << " -> " << point(target(e)) << " " << point(target(en)) << " " << point(target(enn)) << std::endl; bool ccw1 = K.strictly_ordered_ccw(direction(e),direction(en), direction(enn)); bool ccw2 = K.strictly_ordered_ccw(direction(e),direction(en), direction(ef)); if ( !(ccw1 && ccw2) ) { error_status << "ccw order violate!" << std::endl << '\0'; CGAL_assertion_msg(0,error_status.str().c_str()); } e = en; } } template void PM_checker:: check_forward_prefix_condition(Vertex_const_handle v) const { Halfedge_const_handle ef = first_out_edge(v); if ( ef == Halfedge_const_handle() ) return; Halfedge_const_handle el = cyclic_adj_pred(ef); bool is_left_turn = K.left_turn(point(v), point(target(ef)), point(target(el))); bool el_forward = is_forward(el); bool ef_forward = is_forward(ef); bool ef_el_eq = (ef==el); std::ostringstream error_status; error_status << "check_forward_prefix_condition: "; error_status << PV(v) << "\n"; error_status << PE(ef) << "\n" << PE(el) << "\n"; error_status << " ef == el = " << ef_el_eq; error_status << " ef_forward = " << ef_forward; error_status << " el_forward = " << el_forward; error_status << " is_left_turn = " << is_left_turn; CGAL_assertion_msg( (ef == el || ef_forward && !el_forward || ef_forward && el_forward && is_left_turn || !ef_forward && !el_forward && is_left_turn) , error_status.str().c_str()); } /* We check the geometric integrity of the structure. We check + that all adjacent nodes are differently embedded + that all node lists are correctly embedded counterclockwise with winding number one. + that the convex hull of the structure has winding number one. */ template void PM_checker:: check_order_preserving_embedding() const { Vertex_const_iterator vit; for (vit = this->vertices_begin(); vit != this->vertices_end(); ++vit) { check_order_preserving_embedding(vit); check_forward_prefix_condition(vit); } } template typename PM_checker::Halfedge_const_iterator PM_checker:: check_boundary_is_clockwise_weakly_polygon() const { Vertex_const_iterator vit, v_min; for (vit = v_min = this->vertices_begin() ; vit != this->vertices_end(); ++vit) if ( K.compare_xy(point(vit), point(v_min))<0 ) v_min = vit; CGAL_assertion_msg(!is_isolated(v_min),"Minimal vertex not connected."); Point p_min = point(v_min); // determine boundary edge incident to v_min: Halfedge_const_handle e_boundary_at_v_min = first_out_edge(v_min); // all out edges are forward oriented due to minimality Halfedge_around_vertex_const_circulator hvit(e_boundary_at_v_min), hend(hvit); do { --hvit; Point p1 = point(target(e_boundary_at_v_min)); Point p2 = point(target(hvit)); if ( K.orientation(p_min,p1,p2) > 0 ) { // left_turn e_boundary_at_v_min = hvit; break; } } while (hvit != hend); // now e_boundary_at_v_min is highest starting edge in bundle!! int winding_around_globally=0; Halfedge_around_face_const_circulator hfit(e_boundary_at_v_min),hstart(hfit); Halfedge_const_handle e_prev = next(e_boundary_at_v_min); /* we run counterclockwise around the outer face cycle and allow only position where the direction vector of an edge gets smaller again */ Direction d_prev = direction(e_prev); CGAL_For_all_backwards(hstart,hfit) { Direction d_curr = direction(hfit); if ( d_curr < d_prev ) ++winding_around_globally; d_prev = d_curr; } CGAL_assertion(winding_around_globally == 1); return e_boundary_at_v_min; } template void PM_checker:: check_is_triangulation() const { Halfedge_const_iterator eb; CGAL_assertion(this->number_of_connected_components() == 1); CGAL_assertion_msg(this->number_of_edges()!=this->number_of_vertices()-1, " checker checks only full dimensional complexes."); this->check_integrity_and_topological_planarity(false); check_order_preserving_embedding(); eb = check_boundary_is_clockwise_weakly_polygon(); CGAL::Unique_hash_map< Halfedge_const_iterator, bool> on_boundary(false); Halfedge_around_face_const_circulator hit(eb), hend(hit); std::ostringstream error_status; CGAL::set_pretty_mode ( error_status ); error_status << "check_is_triangulation\n"; error_status << "on boundary:\n"; CGAL_For_all(hit,hend) { error_status << " " << PE(hit) << std::endl; on_boundary[hit]=true; } Halfedge_const_iterator eit; for( eit = this->halfedges_begin(); eit != this->halfedges_end(); ++eit) { if (on_boundary[eit]) continue; hit = hend = eit; int edges_in_face_cycle=0; CGAL_For_all(hit,hend) { error_status << PE(hit); ++edges_in_face_cycle; } CGAL_assertion_msg(edges_in_face_cycle==3,error_status.str().c_str()); CGAL_assertion_msg( K.left_turn(point(source(hit)),point(target(hit)), point(target(next(hit)))), error_status.str().c_str()); } } CGAL_END_NAMESPACE #endif // CGAL_PM_CHECKER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/iterator_tools.h0000644000175000017500000000574111344301501031203 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/iterator_tools.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_ITERATORTOOLS_H #define CGAL_ITERATORTOOLS_H #include #include CGAL_BEGIN_NAMESPACE template class CircFromIt : public Iter { // Ptr node; // The internal node ptr inherited from It. typedef CircFromIt Self; public: typedef typename Iter::iterator_category Icategory; typedef I_Circulator_from_iterator_traits CTraits; typedef typename CTraits::iterator_category iterator_category; CircFromIt() : Iter(0) {} CircFromIt(Iter i) : Iter(i) {} // OPERATIONS Forward Category // --------------------------- bool operator==( CGAL_NULL_TYPE p ) const { CGAL_assertion( p == NULL ); return Iter::operator==( Iter(NULL) ); } bool operator!=( CGAL_NULL_TYPE p ) const { return !(*this == p); } bool operator==( const Self& i ) const { return Iter::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { Move move; move.forward(*this); return *this; } Self operator++(int) { CircFromIt tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { Move move; move.backward(*this); return *this; } Self operator--(int) { CircFromIt tmp = *this; --*this; return tmp; } }; template class PntItFromVertIt : public Iter { public: typedef PntItFromVertIt Self; typedef Iter Base; typedef Pnt value_type; typedef const Pnt* pointer; typedef const Pnt& reference; PntItFromVertIt() : Base() {} PntItFromVertIt(Iter it) : Base(it) {} PntItFromVertIt(const Self& it) : Base(it) {} reference operator*() const { return Base::operator*().point(); } pointer operator->() const { return &(operator*()); } Self& operator++() { return (Self&)Base::operator++(); } Self operator++(int) { Self tmp=*this; ++*this; return tmp; } }; template std::string PH(H h) { if (h == H()) return "nil"; return h->debug(); } CGAL_END_NAMESPACE #endif // CGAL_ITERATORTOOLS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Nef_polynomial.h0000644000175000017500000001174411344301501031105 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/Nef_polynomial.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_NEF_POLYNOMIAL_H #define CGAL_NEF_POLYNOMIAL_H #include //#include //#include //#include //#include //#include //#include //#include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 3 #include #include CGAL_BEGIN_NAMESPACE template class Nef_polynomial : public Polynomial { typedef typename CGAL::Polynomial Base; typedef typename Base::size_type size_type; protected: Nef_polynomial(size_type s) : Base(s) {} public: Nef_polynomial() : Base() {} Nef_polynomial(const NT& a0) : Base(a0) {} Nef_polynomial(NT a0, NT a1) : Base(a0,a1) {} Nef_polynomial(const NT& a0, const NT& a1,const NT& a2) : Base(a0,a1,a2) {} template Nef_polynomial(std::pair poly) : Base(poly) {} Nef_polynomial(double n) : Base(n) {} Nef_polynomial(double n1, double n2) : Base(n1, n2) {} Nef_polynomial(int n) : Base(NT(n)) {} Nef_polynomial(int n1, int n2) : Base(n1,n2) {} Nef_polynomial(const Base& p) : Base(p) {} Nef_polynomial(const Nef_polynomial& p) : Base(p) {} // static NT R_; // for visualization only // static void set_R(const NT& R) { R_ = R; } static NT& infi_maximal_value() { static NT R_ = 1; return R_; } }; template <> class Nef_polynomial : public Polynomial { typedef CGAL::Polynomial Base; typedef Base::size_type size_type; protected: Nef_polynomial(size_type s) : Base(s) {} public: Nef_polynomial() : Base() {} Nef_polynomial(const int& a0) : Base(a0) {} Nef_polynomial(int a0, int a1) : Base(a0,a1) {} Nef_polynomial(const int& a0, const int& a1,const int& a2) : Base(a0,a1,a2) {} template Nef_polynomial(std::pair poly) : Base(poly) {} Nef_polynomial(double n) : Base(n) {} Nef_polynomial(double n1, double n2) : Base(n1, n2) {} Nef_polynomial(const Base& p) : Base(p) {} Nef_polynomial(const Nef_polynomial& p) : Base(p) {} // static int R_; // for visualization only // static void set_R(const int& R) { R_ = R; } static int& infi_maximal_value() { static int R_ = 1; return R_; } }; template <> class Nef_polynomial : public Polynomial { typedef CGAL::Polynomial Base; typedef Base::size_type size_type; protected: Nef_polynomial(size_type s) : Base(s) {} public: Nef_polynomial() : Base() {} Nef_polynomial(const double& a0) : Base(a0) {} Nef_polynomial(double a0, double a1) : Base(a0,a1) {} Nef_polynomial(const double& a0, const double& a1,const double& a2) : Base(a0,a1,a2) {} template Nef_polynomial(std::pair poly) : Base(poly) {} Nef_polynomial(int n) : Base(NT(n)) {} Nef_polynomial(int n1, int n2) : Base(n1,n2) {} Nef_polynomial(const Base& p) : Base(p) {} Nef_polynomial(const Nef_polynomial& p) : Base(p) {} // static double R_; // for visualization only // static void set_R(const double& R) { R_ = R; } static double& infi_maximal_value() { static double R_ = 1.0; return R_; } }; // template NT Nef_polynomial::R_ = 1; // int Nef_polynomial::R_ = 1; // double Nef_polynomial::R_ = 1.0; template double to_double(const ::CGAL::Nef_polynomial& p) { return CGAL::to_double(p.eval_at(CGAL::Nef_polynomial ::infi_maximal_value())); } inline double to_double(const Nef_polynomial& p) { return CGAL::to_double(p.eval_at(CGAL::Nef_polynomial ::infi_maximal_value())); } inline double to_double(const Nef_polynomial& p) { return CGAL::to_double(p.eval_at(CGAL::Nef_polynomial ::infi_maximal_value())); } template Nef_polynomial gcd(const Nef_polynomial& p1, const Nef_polynomial& p2) { return gcd(Polynomial(p1), Polynomial(p2)); } CGAL_END_NAMESPACE #endif // CGAL_NEF_POLYNOMIAL_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_point_locator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_point_locator0000644000175000017500000010230411344301501031145 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_2/PM_point_locator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PM_POINT_LOCATOR_H #define CGAL_PM_POINT_LOCATOR_H #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 17 #include #include #ifdef CGAL_USE_LEDA #include #if __LEDA__ > 410 && __LEDA__ < 441 #define CGAL_USING_PPL #include #endif #endif CGAL_BEGIN_NAMESPACE /*{\Moptions print_title=yes }*/ /*{\Msubst PM_decorator_#PMD Geometry_#GEO }*/ /*{\Manpage {PM_naive_point_locator}{PMD,GEO} {Naive point location in plane maps}{PL}}*/ /*{\Mdefinition An instance |\Mvar| of data type |\Mname| encapsulates naive point location queries within a plane map |P|. The two template parameters are specified via concepts. |PM_decorator_| must be a model of the concept |PMDecorator| as described in the appendix. |Geometry_| must be a model of the concept |AffineGeometryTraits_2| as described in the appendix. For a specification of plane maps see also the concept of |PMConstDecorator|.}*/ /*{\Mgeneralization PMD}*/ template class PM_naive_point_locator : public PM_decorator_ { protected: typedef PM_decorator_ Base; typedef PM_naive_point_locator Self; const Geometry_& K; public: /*{\Mtypes 5}*/ typedef PM_decorator_ Decorator; /*{\Mtypemember equals |PM_decorator_|.}*/ typedef typename Decorator::Plane_map Plane_map; /*{\Mtypemember the plane map type decorated by |Decorator|.}*/ typedef typename Decorator::Mark Mark; /*{\Mtypemember the attribute of all objects (vertices, edges, faces).}*/ typedef Geometry_ Geometry; /*{\Mtypemember equals |Geometry_|.}*/ typedef typename Geometry_::Point_2 Point; /*{\Mtypemember the point type of the geometry kernel.\\ \require |Geometry::Point_2| equals |Plane_map::Point|.}*/ typedef typename Geometry_::Segment_2 Segment; /*{\Mtypemember the segment type of the geometry kernel.}*/ typedef typename Geometry_::Direction_2 Direction; /*{\Mtext Local types are handles, iterators and circulators of the following kind: |Vertex_const_handle|, |Vertex_const_iterator|, |Halfedge_const_handle|, |Halfedge_const_iterator|, |Face_const_handle|, |Face_const_iterator|.}*/ typedef CGAL::Object_handle Object_handle; /*{\Mtypemember a generic handle to an object of the underlying plane map. The kind of the object |(vertex, halfedge,face)| can be determined and the object assigned by the three functions:\\ |bool assign(Vertex_const_handle& h, Object_handle o)|\\ |bool assign(Halfedge_const_handle& h, Object_handle o)|\\ |bool assign(Face_const_handle& h, Object_handle o)|\\ where each function returns |true| iff the assignment of |o| to |h| was valid.}*/ typedef typename PM_decorator_::Vertex_handle Vertex_handle; typedef typename PM_decorator_::Halfedge_handle Halfedge_handle; typedef typename PM_decorator_::Face_handle Face_handle; typedef typename PM_decorator_::Vertex_const_handle Vertex_const_handle; typedef typename PM_decorator_::Halfedge_const_handle Halfedge_const_handle; typedef typename PM_decorator_::Face_const_handle Face_const_handle; typedef typename PM_decorator_::Vertex_iterator Vertex_iterator; typedef typename PM_decorator_::Halfedge_iterator Halfedge_iterator; typedef typename PM_decorator_::Face_iterator Face_iterator; typedef typename PM_decorator_::Vertex_const_iterator Vertex_const_iterator; typedef typename PM_decorator_::Halfedge_const_iterator Halfedge_const_iterator; typedef typename PM_decorator_::Face_const_iterator Face_const_iterator; typedef typename PM_decorator_::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename PM_decorator_::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename PM_decorator_::Halfedge_around_face_circulator Halfedge_around_face_circulator; typedef typename PM_decorator_::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::clear; using Base::vertices_begin; using Base::vertices_end; using Base::halfedges_begin; using Base::halfedges_end; using Base::faces_begin; using Base::faces_end; using Base::number_of_vertices; using Base::number_of_halfedges; using Base::number_of_faces; #endif Halfedge_const_handle out_wedge(Vertex_const_handle v, const Direction& d, bool& collinear) const /*{\Xop returns a halfedge |e| bounding a wedge in between two neighbored edges in the adjacency list of |v| which contains |d|. If |d| extends along a edge then |e| is this edge. If |d| extends into the interior of such a wedge then |e| is the first edge hit when |d| is rotated clockwise. \precond |v| is not isolated.}*/ { CGAL_NEF_TRACEN("out_wedge "<(P)), K(k) {} /*{\Mcreate constructs a point locator working on |P|.}*/ /*{\Moptions constref=no}*/ /*{\Moperations 2.5 0.5}*/ const Mark& mark(Object_handle h) const /*{\Mop returns the mark associated to the object |h|.}*/ { Vertex_const_handle v; Halfedge_const_handle e; Face_const_handle f; if ( assign(v,h) ) return mark(v); if ( assign(e,h) ) return mark(e); if ( assign(f,h) ) return mark(f); CGAL_assertion_msg(0, "PM_point_locator::mark: Object_handle holds no object."); #if !defined(__BORLANDC__) return mark(v); // never reached #endif } Object_handle locate(const Segment& s) const /*{\Mop returns a generic handle |h| to an object (vertex, halfedge, face) of the underlying plane map |P| which contains the point |p = s.source()| in its relative interior. |s.target()| must be a point such that |s| intersects the $1$-skeleton of |P|.}*/ { CGAL_NEF_TRACEN("locate naivly "<number_of_vertices() == 0) CGAL_assertion_msg(0,"PM_naive_point_locator: plane map is empty."); Point p = K.source(s); Vertex_const_iterator vit; for(vit = this->vertices_begin(); vit != this->vertices_end(); ++vit) { if ( p == point(vit) ) return Object_handle(vit); } Halfedge_const_iterator eit; for(eit = this->halfedges_begin(); eit != this->halfedges_end(); ++(++eit)) { // we only have to check each second halfedge if ( K.contains(segment(eit),p) ) return Object_handle(eit); } Vertex_const_handle v_res; Halfedge_const_handle e_res; Segment ss = s; // we shorten the segment iteratively Direction dso = K.construct_direction(K.target(s),p), d_res; CGAL::Unique_hash_map visited(false); for(vit = this->vertices_begin(); vit != this->vertices_end(); ++vit) { Point p_res, vp = point(vit); if ( K.contains(ss,vp) ) { CGAL_NEF_TRACEN(" location via vertex at "<halfedges_begin(); eit != this->halfedges_end(); ++eit) { if ( visited[eit] ) continue; Point se = point(source(eit)), te = point(target(eit)); int o1 = K.orientation(ss,se); int o2 = K.orientation(ss,te); if ( o1 == -o2 && // internal intersection K.orientation(se,te,K.source(ss)) != K.orientation(se,te,K.target(ss)) ) { CGAL_NEF_TRACEN(" location via halfedge "< 0 ? eit : twin(eit)); // o2>0 => te left of s and se right of s => p left of e visited[eit] = visited[twin(eit)] = true; CGAL_NEF_TRACEN(" determined "< Object_handle ray_shoot(const Segment& s, const Object_predicate& M) const /*{\Mop returns an |Object_handle o| which can be converted to a |Vertex_const_handle|, |Halfedge_const_handle|, |Face_const_handle| |h| as described above. The object predicate |M| has to have function operators \\ |bool operator() (const Vertex_/Halfedge_/Face_const_handle&)|.\\ The object returned is intersected by the segment |s| and has minimal distance to |s.source()| and |M(h)| holds on the converted object. The operation returns the null handle |NULL| if the ray shoot along |s| does not hit any object |h| of |P| with |M(h)|.}*/ { CGAL_NEF_TRACEN("naive ray_shoot "<vertices_begin(); v != this->vertices_end(); ++v) { Point pv = point(v); if ( !K.contains(ss,pv) ) continue; CGAL_NEF_TRACEN("candidate "<halfedges_begin(); e != this->halfedges_end(); ++(++e)) { Segment es = segment(e); int o1 = K.orientation(ss,K.source(es)); int o2 = K.orientation(ss,K.target(es)); if ( o1 == -o2 && o1 != 0 && K.orientation(es, K.source(ss)) == - K.orientation(es, K.target(ss)) ) { // internal intersection CGAL_NEF_TRACEN("candidate "< 0 ? e : twin(e)); // o2 > 0 => te left of s and se right of s => p left of e if ( M(e_res) ) { h = Object_handle(e_res); ss = K.construct_segment(p,p_res); } else if ( M(face(twin(e_res))) ) { h = Object_handle(face(twin(e_res))); ss = K.construct_segment(p,p_res); } } } return h; } // C++ is really friendly: #define USECMARK(t) const Mark& mark(t h) const { return Base::mark(h); } #define USEMARK(t) Mark& mark(t h) const { return Base::mark(h); } USEMARK(Vertex_handle) USEMARK(Halfedge_handle) USEMARK(Face_handle) USECMARK(Vertex_const_handle) USECMARK(Halfedge_const_handle) USECMARK(Face_const_handle) #undef USEMARK #undef USECMARK /*{\Mimplementation Naive query operations are realized by checking the intersection points of the $1$-skeleton of the plane map |P| with the query segments $s$. This method takes time linear in the size $n$ of the underlying plane map without any preprocessing.}*/ }; // PM_naive_point_locator /*{\Moptions print_title=yes }*/ /*{\Msubst PM_decorator_#PMD Geometry_#GEO }*/ /*{\Manpage {PM_point_locator}{PMD,GEO} {Point location in plane maps via LMWT}{PL}}*/ /*{\Mdefinition An instance |\Mvar| of data type |\Mname| encapsulates point location queries within a plane map |P|. The two template parameters are specified via concepts. |PMD| must be a model of the concept |PMDecorator| as described in the appendix. |GEO| must be a model of the concept |AffineGeometryTraits_2| as described in the appendix. For a specification of plane maps see also the concept of |PMConstDecorator|.}*/ /*{\Mgeneralization PMD^#PM_naive_point_locator}*/ template class PM_point_locator : public PM_naive_point_locator { protected: typedef PM_naive_point_locator Base; typedef PM_point_locator Self; Base CT; #ifdef CGAL_USING_PPL typedef PM_persistent_PL_traits PMPPLT; typedef PointLocator PMPP_locator; PMPP_locator* pPPL; #define LOCATE_IN_TRIANGULATION pPPL->locate_down #else #define LOCATE_IN_TRIANGULATION walk_in_triangulation #endif public: typedef typename Base::Decorator Decorator; typedef typename Base::Plane_map Plane_map; typedef typename Base::Mark Mark; typedef typename Base::Geometry Geometry; typedef typename Base::Point Point; typedef typename Base::Segment Segment; typedef typename Base::Direction Direction; typedef typename Base::Object_handle Object_handle; typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Vertex_iterator Vertex_iterator; typedef typename Base::Halfedge_iterator Halfedge_iterator; typedef typename Base::Face_iterator Face_iterator; typedef typename Base::Vertex_const_iterator Vertex_const_iterator; typedef typename Base::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Base::Face_const_iterator Face_const_iterator; typedef typename Base::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Base::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename Base::Halfedge_around_face_circulator Halfedge_around_face_circulator; typedef typename Base::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::K; using Base::number_of_vertices; #endif /*{\Mtypes 2}*/ /*{\Mtext All local types of |PM_naive_point_locator| are inherited.}*/ typedef std::pair VF_pair; typedef std::pair EF_pair; struct CT_link_to_original : Decorator { // CT decorator const Decorator& Po; CT_link_to_original(const Decorator& P, const Decorator& Poi) : Decorator(P), Po(Poi) {} void operator()(Vertex_handle vn, Vertex_const_handle vo) const { Face_const_handle f; if ( Po.is_isolated(vo) ) f = Po.face(vo); geninfo::create(info(vn)); geninfo::access(info(vn)) = VF_pair(vo,f); CGAL_NEF_TRACEN("linking to org "<::create(info(hn)); geninfo::access(info(hn)) = EF_pair(ho,Po.face(ho)); CGAL_NEF_TRACEN("linking to org "<::const_access(CT.info(v)).first; } Halfedge_const_handle input_halfedge(Halfedge_const_handle e) const { return geninfo::const_access(CT.info(e)).first; } Face_const_handle input_face(Halfedge_const_handle e) const { return geninfo::const_access(CT.info(e)).second; } Object_handle input_object(Vertex_const_handle v) const { return Object_handle(input_vertex(v)); } Object_handle input_object(Halfedge_const_handle e) const { Halfedge_const_handle e_org = input_halfedge(e); if ( e_org != Halfedge_const_handle() ) return Object_handle( e_org ); // now e_org is not existing return Object_handle( input_face(e) ); } /*{\Mimplementation The efficiency of this point location module is mostly based on heuristics. Therefore worst case bounds are not very expressive. The query operations take up to linear time for subsequent query operations though they are better in practise. They trigger a one-time initialization which needs worst case $O(n^2)$ time though runtime tests often show subquadratic results. The necessary space for the query structure is subsumed in the storage space $O(n)$ of the input plane map. The query times are configuration dependent. If LEDA is present then point location is done via the slap method based on persistent dictionaries. Then $T_{pl}(n) = O( \log(n) )$. If CGAL is not configured to use LEDA then point location is done via a segment walk in the underlying convex subdivision of $P$. In this case $T_{pl}(n)$ is the number of triangles crossed by a walk from the boundary of the structure to the query point. The time for the ray shooting operation $T_{rs}(n)$ is the time for the point location $T_{pl}(n)$ plus the time for the walk in the triangulation that is superimposed to the plane map. Let's consider the plane map edges as obstacles and the additional triangulation edges as non-obstacle edges. Let's call the sum of the lengths of all edges of the triangulation its weight. If the calculated triangulation approximates\footnote{The calculation of general minimum-weight-triangulations is conjectured to be NP-complete and locally-minimum-weight-triangulations that we use are considered good approximations.} the minimum weight triangulation of the obstacle set then the stepping quotient\footnote {The number of non-obstacle edges crossed until an obstacle edge is hit.} for a random direction of the ray shot is expected to be $O( \sqrt{n} )$.}*/ struct CT_new_edge : Decorator { const Decorator& _DP; CT_new_edge(const Decorator& CT, const Decorator& DP) : Decorator(CT), _DP(DP) {} void operator()(Halfedge_handle& e) const { Halfedge_handle e_from = previous(e); Face_const_handle f; if ( is_closed_at_source(e) ) // source(e) was isolated before f = geninfo::access(info(source(e))).second; else f = geninfo::access(info(e_from)).second; mark(e) = _DP.mark(f); geninfo::create(info(e)); geninfo::create(info(twin(e))); geninfo::access(info(e)).first = geninfo::access(info(twin(e))).first = Halfedge_const_handle(); geninfo::access(info(e)).second = geninfo::access(info(twin(e))).second = f; CGAL_NEF_TRACEN("CT_new_edge "< NCTT; typedef CGAL::generic_sweep Constrained_triang_sweep; CT_new_edge NE(CT,*this); Constrained_triang_sweep T(NE,CT.plane_map(),this->K); T.sweep(); } void minimize_weight_CT() const { CGAL_NEF_TRACEN("minimize_weight_CT"); if ( this->number_of_vertices() < 2 ) return; std::list S; /* We maintain a stack |S| of edges containing diagonals which might have to be flipped. */ int flip_count = 0; Halfedge_iterator e; for (e = CT.halfedges_begin(); e != CT.halfedges_end(); ++(++e)) { Halfedge_const_handle e_org = input_halfedge(e); if ( e_org != Halfedge_const_handle() ) continue; S.push_back(e); } while ( !S.empty() ) { Halfedge_handle e = S.front(); S.pop_front(); Halfedge_handle r = twin(e); Halfedge_const_handle e_org = input_halfedge(e); if ( e_org != Halfedge_const_handle() ) continue; Halfedge_handle e1 = next(r); Halfedge_handle e3 = next(e); // e1,e3: edges of quadrilateral with diagonal e Point a = point(source(e1)); Point b = point(target(e1)); Point c = point(source(e3)); Point d = point(target(e3)); if (! (this->K.orientation(b,d,a) > 0 && // left_turn this->K.orientation(b,d,c) < 0) ) // right_turn continue; if ( this->K.first_pair_closer_than_second(b,d,a,c) ) { // flip CGAL_NEF_TRACEN("flipping diagonal of quadilateral"<K.orientation(segment(e),p); if ( orientation_ == 0 ) return Object_handle(e); if ( orientation_ < 0 ) return Object_handle(face(twin(e))); if ( orientation_ > 0 ) return Object_handle(face(e)); } assert(0); return h; // compiler warning } template Object_handle ray_shoot(const Segment& s, const Object_predicate& M) const /*{\Mop returns an |Object_handle o| which can be converted to a |Vertex_const_handle|, |Halfedge_const_handle|, |Face_const_handle| |h| as described above. The object predicate |M| has to have function operators\\ |bool operator() (const Vertex_/ Halfedge_/Face_const_handle&) const|.\\ The object returned is intersected by the segment |s| and has minimal distance to |s.source()| and |M(h)| holds on the converted object. The operation returns the null handle |NULL| if the ray shoot along |s| does not hit any object |h| of |P| with |M(h)|.}*/ { CGAL_NEF_TRACEN("ray_shoot "<K.is_degenerate(s) ); Point p = this->K.source(s), q = this->K.target(s); Direction d = this->K.construct_direction(p,q); Vertex_const_handle v; Halfedge_const_handle e; object_kind current; Object_handle h = LOCATE_IN_TRIANGULATION(p); if ( assign(v,h) ) { CGAL_NEF_TRACEN("located vertex "<K.orientation( segment(e), p); if ( orientation_ == 0 ) { // p on segment CGAL_NEF_TRACEN("on edge "<K.orientation(CT.segment(e),q)>0) ) // not left_turn e = CT.twin(e); } } else { // p not on segment, thus in triangle if ( orientation_ < 0 ) e = CT.twin(e); // now p left of e CGAL_NEF_TRACEN("in face at "<K.orientation(p,q,p1); int or2 = this->K.orientation(p,q,p2); int or3 = this->K.orientation(p,q,p3); if ( or1 == 0 && !this->K.left_turn(p1,p2,q) ) { v = CT.source(e); current = VERTEX; } else if ( or2 == 0 && !this->K.left_turn(p2,p3,q) ) { v = CT.target(e); current = VERTEX; } else if ( or3 == 0 && !this->K.left_turn(p3,p1,q) ) { v = CT.target(CT.next(e)); current = VERTEX; } else if ( or2 > 0 && or1 < 0 && !this->K.left_turn(p1,p2,q) ) { e = CT.twin(e); current = EDGE_CROSSING; } else if ( or3 > 0 && or2 < 0 && !this->K.left_turn(p2,p3,q) ) { e = CT.twin(CT.next(e)); current = EDGE_CROSSING; } else if ( or1 > 0 && or3 < 0 && !this->K.left_turn(p3,p1,q) ) { e = CT.twin(CT.previous(e)); current = EDGE_CROSSING; } else return Object_handle(); } } while (true) switch ( current ) { case VERTEX: { CGAL_NEF_TRACEN("vertex "<K.orientation(CT.segment(e),q) == 0 ) return Object_handle(); Halfedge_const_handle e_org = input_halfedge(e); if ( e_org != Halfedge_const_handle() ) { // not a CT edge if ( M(e_org) ) return Object_handle(e_org); if ( M(face(e_org)) ) return Object_handle(face(e_org)); } Vertex_const_handle v_cand = CT.target(CT.next(e)); CGAL_NEF_TRACEN("v_cand "<K.orientation(p,q,CT.point(v_cand)); switch( orientation_ ) { case 0: v = v_cand; current = VERTEX; break; case +1: e = CT.twin(CT.next(e)); current = EDGE_CROSSING; break; case -1: e = CT.twin(CT.previous(e)); current = EDGE_CROSSING; break; } } break; case EDGE_COLLINEAR: { CGAL_NEF_TRACEN("collinear edge "<K.strictly_ordered_along_line( CT.point(CT.source(e)),q,CT.point(CT.target(e))) ) return Object_handle(); v = CT.target(e); current = VERTEX; } break; } // assert(0); return h; // compiler warning } Object_handle walk_in_triangulation(const Point& p) const; enum object_kind { VERTEX, EDGE_CROSSING, EDGE_COLLINEAR }; }; // PM_point_locator #ifdef CGAL_USING_PPL static const char* const pointlocationversion ="point location via pers dicts"; #else static const char* const pointlocationversion ="point location via seg walks"; #endif template PM_point_locator:: PM_point_locator(const Plane_map& P, const Geometry& k) : Base(P,k), CT(*(new Plane_map),k) { CGAL_NEF_TRACEN("PM_point_locator construction"); CT.clone_skeleton(P,CT_link_to_original(CT,*this)); triangulate_CT(); minimize_weight_CT(); #ifdef CGAL_USING_PPL pPPL = new PMPP_locator(CT,PMPPLT(K)); #endif } template PM_point_locator:: ~PM_point_locator() { CGAL_NEF_TRACEN("clear_static_point_locator"); Vertex_iterator vit, vend = CT.vertices_end(); for (vit = CT.vertices_begin(); vit != vend; ++vit) { geninfo::clear(CT.info(vit)); } Halfedge_iterator eit, eend = CT.halfedges_end(); for (eit = CT.halfedges_begin(); eit != eend; ++eit) { geninfo::clear(CT.info(eit)); } CT.clear(); delete &(CT.plane_map()); #ifdef CGAL_USING_PPL delete pPPL; pPPL=0; #endif } template typename PM_point_locator::Object_handle PM_point_locator::walk_in_triangulation(const Point& q) const { CGAL_NEF_TRACEN("walk in triangulation "<K.construct_segment(p,q); Direction dir = this->K.construct_direction(p,q); object_kind current = VERTEX; while (true) switch ( current ) { case VERTEX: { CGAL_NEF_TRACEN("vertex "<K.orientation(CT.segment(e),q) > 0) ) // q not left of e return Object_handle(e); Vertex_const_handle v_cand = CT.target(CT.next(e)); int orientation_ = this->K.orientation(p,q,CT.point(v_cand)); switch( orientation_ ) { case 0: // collinear if ( this->K.strictly_ordered_along_line(p,q,CT.point(v_cand)) ) return Object_handle(e); v = v_cand; current = VERTEX; break; case +1: // left_turn e = twin(next(e)); current = EDGE_CROSSING; break; case -1: e = twin(previous(e)); current = EDGE_CROSSING; break; } } break; case EDGE_COLLINEAR: { CGAL_NEF_TRACEN("collinear edge "<K.strictly_ordered_along_line( CT.point(CT.source(e)),q,CT.point(CT.target(e))) ) return Object_handle(e); v = CT.target(e); current = VERTEX; } break; } #if !defined(__BORLANDC__) return Object_handle(); // never reached warning acceptable #endif } CGAL_END_NAMESPACE #endif // CGAL_PM_POINT_LOCATOR_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_ellipse_2.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_ellipse_20000644000175000017500000000651311344301500031365 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_ellipse_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner CGAL_BEGIN_NAMESPACE // Class implementation (continued) // ================================ // I/O // --- template < class K_ > std::ostream& operator << ( std::ostream& os, const CGAL::Optimisation_ellipse_2& e) { const char* const empty = ""; const char* const pretty_head = "CGAL::Optimisation_ellipse_2( "; const char* const pretty_sep = ", "; const char* const pretty_tail = ")"; const char* const ascii_sep = " "; const char* head = empty; const char* sep = empty; const char* tail = empty; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: head = pretty_head; sep = pretty_sep; tail = pretty_tail; break; case CGAL::IO::ASCII: sep = ascii_sep; break; case CGAL::IO::BINARY: break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } os << head << e.n_boundary_points; switch ( e.n_boundary_points) { case 0: break; case 1: os << sep << e.boundary_point1; break; case 2: os << sep << e.boundary_point1 << sep << e.boundary_point2; break; case 3: case 5: os << sep << e.conic1; break; case 4: os << sep << e.conic1 << sep << e.conic2; break; } os << tail; return( os); } template < class K_ > std::istream& operator >> ( std::istream& is, CGAL::Optimisation_ellipse_2& e) { switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: CGAL::read( is, e.n_boundary_points); switch ( e.n_boundary_points) { case 0: break; case 1: is >> e.boundary_point1; break; case 2: is >> e.boundary_point1 >> e.boundary_point2; break; case 3: case 5: is >> e.conic1; break; case 4: is >> e.conic1 >> e.conic2; break; } break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( is) invalid!"); break; } return( is); } CGAL_END_NAMESPACE // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_demo_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulat0000644000175000017500000000363311344301500031453 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_demo_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_CONSTRAINED_TRIANGULATION_DEMO_2_H #define CGAL_CONSTRAINED_TRIANGULATION_DEMO_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < class Gt,class Tds> class Constrained_triangulation_demo_2 : public Constrained_triangulation_2 { public: typedef Constrained_triangulation_2 Constrained_triangulation; typedef Constrained_triangulation_sweep_demo_2 Sweep_demo; typedef typename Gt::Segment Segment; typedef Window_stream Window_stream; Constrained_triangulation_demo_2() : Constrained_triangulation_2() {} Constrained_triangulation_demo_2(const Gt& gt=Gt()) : Constrained_triangulation_2(gt) {} Constrained_triangulation_demo_2(Window_stream& W, list& lc, const Gt& gt=Gt()) : Constrained_triangulation_2(gt) { Sweep_demo sweep(W,lc, gt); Constrained_triangulation_2 Tr( sweep.vertex(), gt); swap(Tr); CGAL_triangulation_postcondition( is_valid() ); } }; CGAL_END_NAMESPACE #endif //CGAL_CONSTRAINED_TRIANGULATION_DEMO_2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/simple_transformations_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/simple_transformations0000644000175000017500000000731711344301501031556 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/simple_transformations_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SIMPLE_TRANSFORMATIONS_D_H #define CGAL_SIMPLE_TRANSFORMATIONS_D_H #include CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=Simple_transformations.man}*/ /*{\Manpage{}{}{Simple Affine Transformations}{}}*/ template Point_d reflect(const Point_d& p, const Point_d& q) /*{\Mfunc returns |p| reflected at point |q|. }*/ { return Point_d(p + 2*(q-p)); } template Point_d reflect(const Point_d& p, const Line_d& l) /*{\Mfunc returns |p| reflected across line |l|.}*/ { // reflect point across line through r and s Point_d c = l.projection(p); return Point_d(p + 2*(c-p)); } template Sphere_d reflect(const Sphere_d& s, const Point_d& p) /*{\Mfunc returns |s| reflected across point |p|.}*/ { std::vector< Point_d > B(s.points_begin(),s.points_end()); typename std::vector< Point_d >::iterator it; for (it = B.begin(); it != B.end(); ++it) *it = reflect(*it,p); return Sphere_d(p.dimension(),B.begin(),B.end()); } template Sphere_d reflect(const Sphere_d& s, const Line_d& l) /*{\Mfunc returns |s| reflected across line |l|.}*/ { std::vector< Point_d > B(s.points_begin(),s.points_end()); typename std::vector< Point_d >::iterator it; for (it = B.begin(); it != B.end(); ++it) *it = reflect(*it,l); return Sphere_d(l.dimension(),B.begin(),B.end()); } template Segment_d reflect(const Segment_d& s, const Point_d& p) /*{\Mfunc returns |s| reflected across point |p|.}*/ { return Segment_d(reflect(s.point(0),p),reflect(s.point(1),p)); } template Segment_d reflect(const Segment_d& s, const Line_d& l) /*{\Mfunc returns |s| reflected across line |l|.}*/ { return Segment_d(reflect(s.point(0),l),reflect(s.point(1),l)); } template Ray_d reflect(const Ray_d& r, const Point_d& p) /*{\Mfunc returns |s| reflected across point |p|.}*/ { return Ray_d(reflect(r.point(0),p),reflect(r.point(1),p)); } template Ray_d reflect(const Ray_d& r, const Line_d& l) /*{\Mfunc returns |s| reflected across line |l|.}*/ { return Ray_d(reflect(r.point(0),l),reflect(r.point(1),l)); } template Line_d reflect(const Line_d& l, const Point_d& p) /*{\Mfunc returns |s| reflected across point |p|.}*/ { return Line_d(reflect(l.point(0),p),reflect(l.point(1),p)); } template Line_d reflect(const Line_d& s, const Line_d& l) /*{\Mfunc returns |s| reflected across line |l|.}*/ { return Line_d(reflect(s.point(0),l),reflect(s.point(1),l)); } CGAL_END_NAMESPACE #endif // CGAL_SIMPLE_TRANSFORMATIONS_D_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Range_segment_tree_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Range_segment_tree_tra0000644000175000017500000002122211344301500031405 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Range_segment_tree_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef CGAL_RANGE_SEGMENT_TREE_TRAITS_H #define CGAL_RANGE_SEGMENT_TREE_TRAITS_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class C_Compare_1{ public: bool operator()(const Key_1& k1, const Key_1& k2) { return SMALLER == compare_x(k1,k2); } }; template class C_Compare_2{ public: bool operator()(const Key_2& k1, const Key_2& k2) { return SMALLER == compare_y(k1,k2); } }; template class C_Compare_3{ public: bool operator()(const Key_3& k1, const Key_3& k2) { return SMALLER == compare_z(k1,k2); } }; template class C_Low_1{ public: Key_1 operator()(const Interval& i) { return i.first;} }; template class C_High_1{ public: Key_1 operator()(const Interval& i) { return i.second;} }; template class C_Low_2{ public: Key_2 operator()(const Interval& i) { return i.first;} }; template class C_High_2{ public: Key_2 operator()(const Interval& i) { return i.second;} }; template class C_Low_3{ public: Key_3 operator()(const Interval& i) { return i.first;} }; template class C_High_3{ public: Key_3 operator()(const Interval& i) { return i.second;} }; template class C_Key_1{ public: Key_1 operator()(const Key_1& k) { return k;} }; template class C_Key_2{ public: Key_2 operator()(const Key_2& k) { return k;} }; template class C_Key_3{ public: Key_3 operator()(const Key_3& k) { return k;} }; template class T_Key_1{ public: Key_1 operator()(const Key& k) { return k.first;} }; template class T_Key_2{ public: Key_2 operator()(const Key& k) { return k.first;} }; template class T_Key_3{ public: Key_3 operator()(const Key& k) { return k.first;} }; template class Range_tree_map_traits_2{ public: typedef T Value; typedef typename Rep::Point_2 Point_2; typedef Point_2 Pure_key; typedef std::pair Key; typedef Point_2 Key_1; typedef Point_2 Key_2; typedef std::pair Interval; typedef C_Compare_1 compare_1; typedef C_Compare_2 compare_2; typedef C_Low_1 low_1; typedef C_High_1 high_1; typedef T_Key_1 key_1; typedef C_Low_2 low_2; typedef C_High_2 high_2; typedef T_Key_2 key_2; }; template class T_Low_1{ public: Key_1 operator()(const Interval& i) { return i.first.first;} }; template class T_High_1{ public: Key_1 operator()(const Interval& i) { return i.second.first;} }; template class T_Low_2{ public: Key_2 operator()(const Interval& i) { return i.first.first;} }; template class T_High_2{ public: Key_2 operator()(const Interval& i) { return i.second.first;} }; template class T_Low_3{ public: Key_3 operator()(const Interval& i) { return i.first.first;} }; template class T_High_3{ public: Key_3 operator()(const Interval& i) { return i.second.first;} }; template class Range_tree_map_traits_3{ public: typedef typename Rep::Point_3 Point_3; typedef std::pair Key; typedef Point_3 Pure_key; typedef Point_3 Key_1; typedef Point_3 Key_2; typedef Point_3 Key_3; typedef std::pair Interval; typedef C_Compare_1 compare_1; typedef C_Compare_2 compare_2; typedef C_Compare_3 compare_3; typedef T_Low_1 low_1; typedef T_High_1 high_1; typedef T_Key_1 key_1; typedef T_Low_2 low_2; typedef T_High_2 high_2; typedef T_Key_2 key_2; typedef T_Low_3 low_3; typedef T_High_3 high_3; typedef T_Key_3 key_3; }; template class S_Low_1{ public: Key_1 operator()(const Interval& i) { return i.first.first;} }; template class S_High_1{ public: Key_1 operator()(const Interval& i) { return i.first.second;} }; template class S_Low_2{ public: Key_2 operator()(const Interval& i) { return i.first.first;} }; template class S_High_2{ public: Key_2 operator()(const Interval& i) { return i.first.second;} }; template class S_Low_3{ public: Key_3 operator()(const Interval& i) { return i.first.first;} }; template class S_High_3{ public: Key_3 operator()(const Interval& i) { return i.first.second;} }; template class Segment_tree_map_traits_2{ public: typedef T Value; typedef typename Rep::Point_2 Point_2; typedef Point_2 Key; typedef Point_2 Key_1; typedef Point_2 Key_2; typedef std::pair Pure_interval; typedef std::pair Interval; typedef C_Compare_1 compare_1; typedef C_Compare_2 compare_2; typedef S_Low_1 low_1; typedef S_High_1 high_1; typedef C_Key_1 key_1; typedef S_Low_2 low_2; typedef S_High_2 high_2; typedef C_Key_2 key_2; }; template class Segment_tree_map_traits_3{ public: typedef typename Rep::Point_3 Point_3; typedef Point_3 Key; typedef Point_3 Key_1; typedef Point_3 Key_2; typedef Point_3 Key_3; typedef std::pair Pure_interval; typedef std::pair Interval; typedef C_Compare_1 compare_1; typedef C_Compare_2 compare_2; typedef C_Compare_3 compare_3; typedef S_Low_1 low_1; typedef S_High_1 high_1; typedef C_Key_1 key_1; typedef S_Low_2 low_2; typedef S_High_2 high_2; typedef C_Key_2 key_2; typedef S_Low_3 low_3; typedef S_High_3 high_3; typedef C_Key_3 key_3; }; template class Range_segment_tree_set_traits_3{ public: typedef typename Rep::Point_3 Point_3; typedef Point_3 Key; typedef Point_3 Key_1; typedef Point_3 Key_2; typedef Point_3 Key_3; typedef std::pair Interval; typedef C_Compare_1 compare_1; typedef C_Compare_2 compare_2; typedef C_Compare_3 compare_3; typedef C_Low_1 low_1; typedef C_High_1 high_1; typedef C_Key_1 key_1; typedef C_Low_2 low_2; typedef C_High_2 high_2; typedef C_Key_2 key_2; typedef C_Low_3 low_3; typedef C_High_3 high_3; typedef C_Key_3 key_3; }; template class Range_segment_tree_set_traits_2{ public: typedef typename Rep::Point_2 Point_2; typedef Point_2 Key; typedef Point_2 Key_1; typedef Point_2 Key_2; typedef std::pair Interval; typedef C_Compare_1 compare_1; typedef C_Compare_2 compare_2; typedef C_Low_1 low_1; typedef C_High_1 high_1; typedef C_Key_1 key_1; typedef C_Low_2 low_2; typedef C_High_2 high_2; typedef C_Key_2 key_2; }; CGAL_END_NAMESPACE #endif // CGAL_RANGE_SEGMENT_TREE_TRAITS_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_adapterC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_adapterC0000644000175000017500000002670211344301500031236 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_adapterC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_ELLIPSE_2_ADAPTERC2_H #define CGAL_MIN_ELLIPSE_2_ADAPTERC2_H // includes #ifndef CGAL_CONICCPA2_H # include #endif #ifndef CGAL_OPTIMISATION_ASSERTIONS_H # include #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_ellipse_2; template < class PT_, class DA_ > class Min_ellipse_2_adapterC2; template < class PT_, class DA_ > class _Min_ellipse_2_adapterC2__Ellipse; // Class interface and implementation // ================================== template < class PT, class DA > bool are_ordered_along_lineC2( const PT& p, const PT& q, const PT& r, const DA& da) { typedef typename DA::FT FT; FT px; FT py; FT qx; FT qy; FT rx; FT ry; da.get( p, px, py); da.get( q, qx, qy); da.get( r, rx, ry); // p,q,r collinear? if ( ! CGAL_NTS is_zero( ( px-rx) * ( qy-ry) - ( py-ry) * ( qx-rx))) return( false); // p,q,r vertical? if ( px != rx) return( ( ( px < qx) && ( qx < rx)) || ( ( rx < qx) && ( qx < px))); else return( ( ( py < qy) && ( qy < ry)) || ( ( ry < qy) && ( qy < py))); // keeps g++ happy return false; } template < class PT_, class DA_ > class Min_ellipse_2_adapterC2 { public: // types typedef PT_ PT; typedef DA_ DA; // nested types typedef PT Point; typedef _Min_ellipse_2_adapterC2__Ellipse Ellipse; private: DA dao; // data accessor object Ellipse ellipse; // current ellipse friend class Min_ellipse_2< Min_ellipse_2_adapterC2 >; public: // creation Min_ellipse_2_adapterC2( const DA& da = DA()) : dao( da), ellipse( da) { } // operations CGAL::Orientation orientation( const Point& p, const Point& q, const Point& r) const { typedef typename DA_::FT FT; FT px; FT py; FT qx; FT qy; FT rx; FT ry; dao.get( p, px, py); dao.get( q, qx, qy); dao.get( r, rx, ry); return( static_cast< CGAL::Orientation>( CGAL_NTS sign( ( px-rx) * ( qy-ry) - ( py-ry) * ( qx-rx)))); } }; // Nested type `Ellipse' template < class PT_, class DA_ > std::ostream& operator << ( std::ostream& os, const _Min_ellipse_2_adapterC2__Ellipse& c); template < class PT_, class DA_ > std::istream& operator >> ( std::istream& is, _Min_ellipse_2_adapterC2__Ellipse& c); template < class PT_, class DA_ > class _Min_ellipse_2_adapterC2__Ellipse { public: // typedefs typedef PT_ PT; typedef DA_ DA; typedef ConicCPA2< PT, DA> CT; typedef typename DA_::FT FT; private: // data members int n_boundary_points; // number of boundary points PT boundary_point1, boundary_point2; // two boundary points CT conic1, conic2; // two conics FT dr, ds, dt, du, dv, dw; // the gradient vector friend std::ostream& operator << <> ( std::ostream& os, const _Min_ellipse_2_adapterC2__Ellipse& c); friend std::istream& operator >> <> ( std::istream& is, _Min_ellipse_2_adapterC2__Ellipse& c); public: // types typedef PT Point; // creation _Min_ellipse_2_adapterC2__Ellipse( const DA& da) : conic1( da), conic2( da) { } void set( ) { n_boundary_points = 0; } void set( const Point& p) { n_boundary_points = 1; boundary_point1 = p; } void set( const Point& p, const Point& q) { n_boundary_points = 2; boundary_point1 = p; boundary_point2 = q; } void set( const Point& p1, const Point& p2, const Point& p3) { n_boundary_points = 3; conic1.set_ellipse( p1, p2, p3); } void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4) { n_boundary_points = 4; CT::set_two_linepairs( p1, p2, p3, p4, conic1, conic2); dr = FT( 0); ds = conic1.r() * conic2.s() - conic2.r() * conic1.s(), dt = conic1.r() * conic2.t() - conic2.r() * conic1.t(), du = conic1.r() * conic2.u() - conic2.r() * conic1.u(), dv = conic1.r() * conic2.v() - conic2.r() * conic1.v(), dw = conic1.r() * conic2.w() - conic2.r() * conic1.w(); } void set( const Point&, const Point&, const Point&, const Point&, const Point& p5) { n_boundary_points = 5; conic1.set( conic1, conic2, p5); conic1.analyse(); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const { switch ( n_boundary_points) { case 0: return( CGAL::ON_UNBOUNDED_SIDE); case 1: return( ( p == boundary_point1) ? CGAL::ON_BOUNDARY : CGAL::ON_UNBOUNDED_SIDE); case 2: return( ( p == boundary_point1) || ( p == boundary_point2) || ( CGAL::are_ordered_along_lineC2( boundary_point1, p, boundary_point2, conic1.da())) ? CGAL::ON_BOUNDARY : CGAL::ON_UNBOUNDED_SIDE); case 3: case 5: return( conic1.convex_side( p)); case 4: { CT c( conic1.da()); c.set( conic1, conic2, p); c.analyse(); if ( ! c.is_ellipse()) { c.set_ellipse( conic1, conic2); c.analyse(); return( c.convex_side( p)); } else { int tau_star = c.vol_derivative( dr, ds, dt, du, dv, dw); return( CGAL::Bounded_side( CGAL_NTS sign( tau_star))); } } default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); } // keeps g++ happy return( CGAL::Bounded_side( 0)); } bool has_on_bounded_side( const Point& p) const { return( bounded_side( p) == CGAL::ON_BOUNDED_SIDE); } bool has_on_boundary( const Point& p) const { return( bounded_side( p) == CGAL::ON_BOUNDARY); } bool has_on_unbounded_side( const Point& p) const { return( bounded_side( p) == CGAL::ON_UNBOUNDED_SIDE); } bool is_empty( ) const { return( n_boundary_points == 0); } bool is_degenerate( ) const { return( n_boundary_points < 3); } // additional operations for checking bool operator == ( const CGAL::_Min_ellipse_2_adapterC2__Ellipse& e) const { if ( n_boundary_points != e.n_boundary_points) return( false); switch ( n_boundary_points) { case 0: return( true); case 1: return( boundary_point1 == e.boundary_point1); case 2: return( ( ( boundary_point1 == e.boundary_point1) && ( boundary_point2 == e.boundary_point2)) || ( ( boundary_point1 == e.boundary_point2) && ( boundary_point2 == e.boundary_point1))); case 3: case 5: return( conic1 == e.conic1); case 4: return( ( ( conic1 == e.conic1) && ( conic2 == e.conic2)) || ( ( conic1 == e.conic2) && ( conic2 == e.conic1))); default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5)); } // keeps g++ happy return( false); } bool operator != ( const CGAL::_Min_ellipse_2_adapterC2__Ellipse& e) const { return( ! ( *this == e)); } }; // I/O template < class PT_, class DA_ > std::ostream& operator << ( std::ostream& os, const CGAL::_Min_ellipse_2_adapterC2__Ellipse& e) { const char* const empty = ""; const char* const pretty_head = "CGAL::Min_ellipse_2_adapterC2::Ellipse( "; const char* const pretty_sep = ", "; const char* const pretty_tail = ")"; const char* const ascii_sep = " "; const char* head = empty; const char* sep = empty; const char* tail = empty; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: head = pretty_head; sep = pretty_sep; tail = pretty_tail; break; case CGAL::IO::ASCII: sep = ascii_sep; break; case CGAL::IO::BINARY: break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } os << head << e.n_boundary_points; switch ( e.n_boundary_points) { case 0: break; case 1: os << sep << e.boundary_point1; break; case 2: os << sep << e.boundary_point1 << sep << e.boundary_point2; break; case 3: case 5: os << sep << e.conic1; break; case 4: os << sep << e.conic1 << sep << e.conic2; break; } os << tail; return( os); } template < class PT_, class DA_ > std::istream& operator >> ( std::istream& is, CGAL::_Min_ellipse_2_adapterC2__Ellipse& e) { switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: CGAL::read( is, e.n_boundary_points); switch ( e.n_boundary_points) { case 0: break; case 1: is >> e.boundary_point1; break; case 2: is >> e.boundary_point1 >> e.boundary_point2; break; case 3: case 5: is >> e.conic1; break; case 4: is >> e.conic1 >> e.conic2; break; } break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE #endif // CGAL_MIN_ELLIPSE_2_ADAPTERC2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_vertex_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarch0000644000175000017500000000446611344301501031443 0ustar debiandebian// Copyright (c) 1998, 2001, 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_vertex_base_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Olivier Devillers // Sylvain Pion #ifndef CGAL_TRIANGULATION_HIERARCHY_VERTEX_BASE_3_H #define CGAL_TRIANGULATION_HIERARCHY_VERTEX_BASE_3_H #include #include CGAL_BEGIN_NAMESPACE template < class Vbb > class Triangulation_hierarchy_vertex_base_3 : public Vbb { typedef Vbb Base; typedef typename Base::Triangulation_data_structure Tds; public: typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Cell_handle Cell_handle; typedef typename Base::Point Point; template < typename TDS2 > struct Rebind_TDS { typedef typename Vbb::template Rebind_TDS::Other Vb2; typedef Triangulation_hierarchy_vertex_base_3 Other; }; Triangulation_hierarchy_vertex_base_3() : Base(), _up(), _down() {} Triangulation_hierarchy_vertex_base_3(const Point & p, Cell_handle f) : Base(p,f), _up(), _down() {} Triangulation_hierarchy_vertex_base_3(const Point & p) : Base(p), _up(), _down() {} Vertex_handle up() const { return _up; } Vertex_handle down() const { return _down; } void set_up(Vertex_handle u) { _up=u; } void set_down(Vertex_handle d) { _down=d; } private: Vertex_handle _up; // same vertex one level above Vertex_handle _down; // same vertex one level below }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_HIERARCHY_VERTEX_BASE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2.h0000644000175000017500000000546511344301500030202 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_ISO_RECTANGLE_2_H #define CGAL_ISO_RECTANGLE_2_H CGAL_BEGIN_NAMESPACE template class Iso_rectangle_2 : public R_::Kernel_base::Iso_rectangle_2 { typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Kernel_base::Iso_rectangle_2 RIso_rectangle_2; public: typedef R_ R; Iso_rectangle_2() {} Iso_rectangle_2(const RIso_rectangle_2& r) : RIso_rectangle_2(r) {} Iso_rectangle_2(const Point_2 &p, const Point_2 &q) : RIso_rectangle_2(p,q) {} Iso_rectangle_2(const Point_2 &left, const Point_2 &right, const Point_2 &bottom, const Point_2 &top) : RIso_rectangle_2(left, right, bottom, top) {} Iso_rectangle_2(const RT& min_hx, const RT& min_hy, const RT& max_hx, const RT& max_hy) : RIso_rectangle_2(min_hx, min_hy, max_hx, max_hy) {} Iso_rectangle_2(const RT& min_hx, const RT& min_hy, const RT& max_hx, const RT& max_hy, const RT& hw) : RIso_rectangle_2(min_hx, min_hy, max_hx, max_hy, hw) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_ISO_RECTANGLE_2 template < class R > std::ostream & operator<<(std::ostream &os, const Iso_rectangle_2 &r) { typedef typename R::Kernel_base::Iso_rectangle_2 RIso_rectangle_2; return os << (const RIso_rectangle_2&)r; } #endif // CGAL_NO_OSTREAM_INSERT_ISO_RECTANGLE_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_ISO_RECTANGLE_2 template < class R > std::istream & operator>>(std::istream &is, Iso_rectangle_2 &r) { typedef typename R::Kernel_base::Iso_rectangle_2 RIso_rectangle_2; is >> (RIso_rectangle_2&)r; return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_ISO_RECTANGLE_2 CGAL_END_NAMESPACE #endif // CGAL_ISO_RECTANGLE_2_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dynamic_open_bounding_box.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dynamic_open_boundi0000644000175000017500000004052111344301500031406 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dynamic_open_bounding_box.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PM_DYNAMIC_OPEN_BOUNDING_BOX_H #define CGAL_PM_DYNAMIC_OPEN_BOUNDING_BOX_H #ifndef CGAL_PLANAR_MAP_2_H #include #endif #ifndef CGAL_PM_BOUNDING_BOX_BASE_H #include #endif CGAL_BEGIN_NAMESPACE template class Pm_dynamic_open_bounding_box : public Pm_bounding_box_base { public: typedef Planar_map_ Planar_map; typedef Pm_bounding_box_base Base; typedef Pm_dynamic_open_bounding_box Self; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Face_const_handle Face_const_handle; typedef typename Planar_map::Vertex_iterator Vertex_iterator; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Face_iterator Face_iterator; typedef typename Planar_map::Vertex_const_iterator Vertex_const_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Face_const_iterator Face_const_iterator; typedef typename Planar_map::Locate_type Locate_type; typedef std::vector Halfedge_container; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; typedef typename Traits::Ray Ray; typedef typename Traits::Direction Direction; typedef typename Traits::Bounding_box Bounding_box; // typedef typename Traits::Boundary_type Boundary_type; typedef typename Traits::Point_container Point_container; typedef typename Point_container::iterator Point_iterator; typedef typename Traits::X_curve_container X_curve_container; typedef typename X_curve_container::iterator X_curve_iterator; typedef typename Planar_map::Point_location_base Point_location_base; /* typedef std::list X_curve_container; typedef Topological_map<_Dcel> TPM; */ typedef typename Planar_map::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Planar_map::Holes_iterator Holes_iterator; typedef typename Planar_map::Holes_const_iterator Holes_const_iterator; typedef typename Planar_map::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; struct Token : public Base::Token { // The following class is used to synchronize between two instances of // Bounding_box and Point_location strategies, during // rebuild of the bounding box in the first and an update call in the second. typedef typename Traits::Bounding_box Bounding_box; Token(const Bounding_box& t) : b(t) {}; virtual void rebuild_bounding_box(const Point_location_base* p) const {((Traits*)p->get_traits())->set_bounding_box(b);} private: const Bounding_box& b; }; Pm_dynamic_open_bounding_box(){} ~Pm_dynamic_open_bounding_box(){} void init(Planar_map& pmp, Traits& tr) { pm = &pmp; traits = (Traits_wrap*)(&tr); } bool insert(const Point& p) { #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif // Returns true if bounding box remained unchanged. Bounding_box bold = traits->get_bounding_box(), b = is_empty(bold) ? traits->get_bounding_box(p) : traits->get_bounding_box(p,bold); if (!traits->bounding_box_is_same(b)) { rebuild_bounding_box(b); return false; } return true; } bool insert(const Point_iterator& begin,const Point_iterator& end #ifdef _MSC_VER ,Point* dummy=0 #endif ) { // workaround for MSVC6.0 // Returns true if bounding box remained unchanged. #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif Point_iterator it=begin; Bounding_box bold = traits->get_bounding_box(),b=bold; if (it!=end) { b = is_empty(b) ? traits->get_bounding_box(*it) : traits->get_bounding_box(*it,b); ++it; } while(it!=end) { #ifdef CGAL_PMBB_DEBUG std::cout << "\nPm_dynamic_open_bounding_box::insert(" << "begin,end)" << std::endl; #endif #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif b=traits->get_bounding_box(*it,b); ++it; } if (!traits->bounding_box_is_same(b)) { #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif rebuild_bounding_box(b); return false; } return true; } bool insert(const X_curve& cv) { // we check that the finite endpoints of the curve is in the BBox // and if not enlarge the BBox to contain them. // if the curve is infinite (in both sides) we have to check that // it passes through the BBox. // Last, we change the "infinite" endpoints to lie on the BBox. Point p1, p2; X_curve c; #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif Bounding_box bold = traits->get_bounding_box(), b = is_empty(bold) ? traits->get_bounding_box(cv) : traits->get_bounding_box(cv,bold); if (!traits->bounding_box_is_same(b)) { rebuild_bounding_box(b); return false; } return true; } bool insert(const X_curve_iterator& begin,const X_curve_iterator& end #ifdef _MSC_VER ,X_curve* dummy=0 #endif ) { // workaround for MSVC6.0 #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif // Boundary_type bt; // Point p1, p2; // X_curve c; X_curve_iterator it=begin; Bounding_box bold = traits->get_bounding_box(),b=bold; if (it!=end) { b = is_empty(b) ? traits->get_bounding_box(*it) : traits->get_bounding_box(*it,b); ++it; } while(it!=end) { b = traits->get_bounding_box(*it,b); ++it; } if (!traits->bounding_box_is_same(b)) { rebuild_bounding_box(b); return false; } return true; } bool insert(const X_curve& cv,const Ray& r) { /* returns true if the bounding box remains unchanged, false otherwise. */ #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif const Bounding_box& bold = traits->get_bounding_box(), b = is_empty(bold) ? traits->get_bounding_box(cv,r) : traits->get_bounding_box(cv,r,bold); #ifdef CGAL_PMBB_DEBUG CGAL_postcondition(b==traits->get_bounding_box(cv,r,b)); #endif // makes sure that the intersection of the ray and the curve // (if such intersection exists) is inside the bounding box. if (!traits->bounding_box_is_same(b)) { rebuild_bounding_box(b); return false; } return true; } /* The point location query function may updates the resulting halfedge handle and locate type as expected from the bounding box */ /* Returns true if bounding box remained unchanged */ bool locate(const Point& p, Locate_type& lt,Halfedge_handle& h){ // apply_bounding_box(pm->unbounded_face(),h,lt); return true; }; /* Returns true if bounding box remained unchanged */ bool vertical_ray_shoot(const Point& p, Locate_type& lt, bool up, Halfedge_handle& h){ CGAL_precondition(lt==Planar_map::VERTEX||lt==Planar_map::EDGE|| lt==Planar_map::UNBOUNDED_FACE); if (lt==Planar_map::UNBOUNDED_FACE) { Halfedge_iterator it=pm->halfedges_begin(); Ray r(p,Direction(0,up ? 1 : -1)); while(it!=pm->halfedges_end()) { const X_curve& cv=it->curve(); if (!traits->point_in_x_range(cv,p) && !insert(cv,r)) return false; else {++it;++it;} } // make sure that the intersection of the curve with the vertical ray // is inside the bounding box // (if such intersection exists). } else if (lt==Planar_map::VERTEX) { if (!insert(h->target()->point())) return false; } return true; // apply_bounding_box(pm->unbounded_face(),h,lt); }; void split_edge(const X_curve &cv, Halfedge_handle e1, Halfedge_handle e2 //additions by iddo for arrangement ,const X_curve& cv1, const X_curve& cv2 //end additions ) {} virtual void split_boundary_edge(const Halfedge_handle &h, Halfedge_handle h1, Halfedge_handle h2, const Point& p) {} void merge_edge(const X_curve &cv1, const X_curve &cv2, Halfedge_handle e //additions by iddo for arrangement ,const X_curve& cv //end additions ) {} void remove_edge(Halfedge_handle e) {} void clear() { traits->set_bounding_box(); } inline bool is_empty() const { return is_empty(traits->get_bounding_box()); } protected: inline bool is_empty(const Bounding_box& b) const { return b.identical(Traits::unbounded_box()); } public: #ifdef CGAL_PM_DEBUG void debug() const {} bool debug_invariant() const{ CGAL_assertion(traits); CGAL_assertion(&traits->get_bounding_box()); return true; } #endif protected: void apply_bounding_box(const Face_handle& unbounded, const Halfedge_handle& he,Locate_type& lt) const { switch(lt) { case Planar_map::UNBOUNDED_FACE: break; case Planar_map::FACE: { Ccb_halfedge_const_circulator begin(he->twin()); Ccb_halfedge_const_circulator circ=begin; while (++circ!=begin) { if (circ->face()==unbounded) lt=Planar_map::UNBOUNDED_FACE; break; } } break; case Planar_map::EDGE: if (he->face()==unbounded || he->twin()->face()==unbounded) lt=Planar_map::UNBOUNDED_EDGE; break; case Planar_map::VERTEX: { Halfedge_around_vertex_circulator begin=he->target()->incident_halfedges(), circ=begin; while (++circ!=begin) { if (circ->face()==unbounded) lt=Planar_map::UNBOUNDED_VERTEX; break;} } break; } } bool cooriented(const Ccb_halfedge_circulator& h,const X_curve& cv) const { #ifdef CGAL_PMBB_DEBUG if (!traits->curve_equal(h->curve(),cv)) std::cerr << "\nbool cooriented(h," << cv << "); h->curve()=" << h->curve() << std::endl; #endif CGAL_precondition(traits->curve_equal(h->curve(),cv)); const Point& s=h->source()->point(),&t=h->target()->point(); if (traits->point_equal_x(s,t)) { CGAL_precondition( traits->curve_get_status(cv)==Traits::CURVE_VERTICAL_UP || traits->curve_get_status(cv)==Traits::CURVE_VERTICAL_DOWN); return (traits->point_is_right_top(t,s) == (traits->curve_get_status(cv)==Traits::CURVE_VERTICAL_UP)); } else { #ifdef CGAL_PMBB_DEBUG if ( traits->curve_get_status(cv)!=Traits::CURVE_RIGHT && traits->curve_get_status(cv)!=Traits::CURVE_LEFT) { std::cout << "\nCGAL_precondition(cv status is RIGHT||LEFT)" << "cv=" << cv << ",traits->curve_get_status(cv)=" << traits->curve_get_status(cv); } #endif CGAL_precondition( traits->curve_get_status(cv)==Traits::CURVE_RIGHT || traits->curve_get_status(cv)==Traits::CURVE_LEFT); return (traits->point_is_right(t,s)== (traits->curve_get_status(cv)==Traits::CURVE_RIGHT)); } } // discards the const Point_location_base* get_point_location() { return (Point_location_base*)pm->get_point_location(); } void rebuild_bounding_box(const Bounding_box& b){ /* The main function in the bounding box. When called, the planar map representation is rebuild. Precondition: The bounding box contains in its interior all the interesting points. */ #ifdef CGAL_PMBB_DEBUG std::cout << "\nPm_dynamic_open_bounding_box::rebuild_bounding_box()"; #endif Halfedge_container c; Holes_iterator hit=pm->unbounded_face()->holes_begin(), hoe=pm->unbounded_face()->holes_end(); while (hit!=hoe) { Ccb_halfedge_circulator begin = *hit, circ=begin; do { if (traits->curve_is_unbounded(circ->curve())) { // Each halfedge contributes an unbounded curve, due to the // dynamic nature of the bounding box and the invariant that // the curves are all bounded inside. // We optimize here taking only one representative for each edge. Halfedge_handle second=circ; ++second; if (second==circ->twin()) c.push_back(circ); } ++circ; } while(circ!=begin); ++hit; } typename Halfedge_container::iterator it=c.begin(),cend=c.end(); get_point_location()->update(it,cend,Token(b)); #ifdef CGAL_PMBB_DEBUG CGAL_assertion(traits->get_bounding_box().identical(b)); #endif while (it!=cend) { Halfedge_handle h=*it; const X_curve& cv=h->curve(); Vertex_handle s=h->source(),t=h->target(); if (cooriented(h,cv)) { t->set_point(traits->curve_target(cv)); s->set_point(traits->curve_source(cv)); } else { t->set_point(traits->curve_source(cv)); s->set_point(traits->curve_target(cv)); } CGAL_postcondition(!traits->point_equal( h->source()->point(),h->target()->point())); #ifdef CGAL_PM_DEBUG if (!(traits->point_equal( traits->curve_source(h->curve()), h->source()->point()) && traits->point_equal( traits->curve_target(h->curve()), h->target()->point()) || traits->point_equal( traits->curve_source(h->curve()), h->target()->point()) && traits->point_equal( traits->curve_target(h->curve()), h->source()->point()))) { std::cout << "\ncurve_source(h->curve())=" << traits->curve_source(h->curve()); std::cout << " curve_target(h->curve())=" << traits->curve_target(h->curve()); std::cout << " h->source()->point()=" << h->source()->point(); std::cout << " h->target()->point()=" << h->target()->point(); } CGAL_postcondition( traits->point_equal( traits->curve_source(h->curve()), h->source()->point()) && traits->point_equal( traits->curve_target(h->curve()), h->target()->point()) || traits->point_equal( traits->curve_source(h->curve()), h->target()->point()) && traits->point_equal( traits->curve_target(h->curve()),h->source()->point()) ); #endif ++it; } c.clear(); } protected: Planar_map* pm; Traits_wrap* traits; }; CGAL_END_NAMESPACE #endif //CGAL_PM_DYNAMIC_OPEN_BOUNDING_BOX_H /* Special situations: |-------- | x | | | | | | | |-\ /---| vrs */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/apply_to_range.h0000644000175000017500000001446411344301500030205 0ustar debiandebian// Copyright (c) 1997-2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/apply_to_range.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_apply_to_range_h #define CGAL_apply_to_range_h #include #include #include namespace CGAL{ template void apply_to_range(const Tr &t, const Point_2 &p1, const Point_2 &p2, Fct& fct) { if (t.dimension()<2) return; typedef typename Tr::Point POINT; typedef typename Tr::Segment SEGMENT; typedef typename Tr::Triangle TRIANGLE; typedef typename Tr::Face_handle hFACE; typedef typename Tr::Vertex_handle hVERTEX; typedef typename Tr::Line_face_circulator LFC; typedef typename Tr::Finite_vertices_iterator FVI; typedef typename Tr::Finite_faces_iterator FFI; typedef typename Kernel_traits::Kernel K; typedef typename K::FT FT; LFC l1, l2, l3, l4; //the faces that intersect the pixmap RECTANGLE hFACE hface1, hface2, hface3, hface4; //the faces where we start to search FT xr_left, yr_top, xr_right, yr_bottom;//the coordinates of the screen boundaries CGAL::Unique_hash_map visited(false);//used for DFS std::stack face_stack; //used for DFS xr_left = p1.x(); xr_right = p2.x(); yr_top = p1.y(); yr_bottom = p2.y(); hface1 = t.locate(POINT(xr_left, yr_top)); hface2 = t.locate(POINT(xr_right, yr_top)); hface3 = t.locate(POINT(xr_right, yr_bottom)); hface4 = t.locate(POINT(xr_left, yr_bottom)); l1 = t.line_walk(POINT(xr_left, yr_top), POINT(xr_right, yr_top), hface1); l2 = t.line_walk(POINT(xr_right, yr_top), POINT(xr_right, yr_bottom), hface2); l3 = t.line_walk(POINT(xr_right, yr_bottom), POINT(xr_left, yr_bottom), hface3); l4 = t.line_walk(POINT(xr_left, yr_bottom), POINT(xr_left, yr_top), hface4); //test if everything is inside or outside if( (l1 == (CGAL_NULL_TYPE) NULL) && (l2 == (CGAL_NULL_TYPE) NULL) && (l3 == (CGAL_NULL_TYPE) NULL) && (l4 == (CGAL_NULL_TYPE) NULL)) { FVI v = t.finite_vertices_begin(); if((*v).point().x() < xr_left || (*v).point().x() > xr_right || (*v).point().y() < yr_bottom || (*v).point().y() > yr_top) //true if everything is outside return; else{ //everything is inside FFI it = t.finite_faces_begin(); while(it != t.finite_faces_end()) { fct(it); it++; } } return; } //if we are here, then a part of the triangulation is inside, the other is outside //put all the faces on the boundaries in the stack and the map if(l1 != (CGAL_NULL_TYPE) NULL) //found at least one face that intersect the TOP segment { while (t.is_infinite(l1)) l1++; //we should start with a finite face do{ //put all of them in the stack; face_stack.push(l1); visited[l1] = true; l1++; }while(!t.is_infinite(l1) && t.triangle(l1).has_on_unbounded_side(POINT(xr_right, yr_top))); } if(l2 != (CGAL_NULL_TYPE) NULL) //found at least one face that intersect the RIGHT segment { while (t.is_infinite(l2)) l2++; //we should start with a finite face do{ //put all of them in the stack; if(!visited[l2]){ face_stack.push(l2); visited[l2] = true; } l2++; }while(!t.is_infinite(l2) && t.triangle(l2).has_on_unbounded_side(POINT(xr_right, yr_top))); } if(l3 != (CGAL_NULL_TYPE) NULL) //found at least one face that intersect the BOTTOM segment { while (t.is_infinite(l3)) l3++; //we should start with a finite face do{ //put all of them in the stack; if(!visited[l3]){ face_stack.push(l3); visited[l3] = true; } l3++; }while(!t.is_infinite(l3) && t.triangle(l3).has_on_unbounded_side(POINT(xr_right, yr_top))); } if(l4 != (CGAL_NULL_TYPE) NULL) //found at least one face that intersect the LEFT segment { while (t.is_infinite(l4)) l4++; //we should start with a finite face do{ //put all of them in the stack; if(!visited[l4]){ face_stack.push(l4); visited[l4] = true; } l4++; }while(!t.is_infinite(l4) && t.triangle(l4).has_on_unbounded_side(POINT(xr_right, yr_top))); } //HERE we begin to walk through the faces DFS hFACE hf; typename CGAL::Unique_hash_map::Data& data_ref_start(visited[hf]); data_ref_start = true; while(!face_stack.empty()){ hf = face_stack.top(); face_stack.pop(); //done with this face for (int i=0; i<3; i++){ //visit all the neighbors if(!visited[(*hf).neighbor(i)] ) if(!t.is_infinite((*hf).neighbor(i))){ //true if it is not an infinite face hVERTEX hv = (*(*hf).neighbor(i)).vertex((*(*hf).neighbor(i)).index(hf)); if(!((*hv).point().x() < xr_left || (*hv).point().x() > xr_right || (*hv).point().y() < yr_bottom || (*hv).point().y() > yr_top)) //true if the vertex is outside face_stack.push((*hf).neighbor(i)); typename CGAL::Unique_hash_map::Data& data_ref(visited[(*hf).neighbor(i)]); data_ref = true; } } fct(hf); } } }//end namespace #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_default.h0000644000175000017500000000544211344301500030630 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_default.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_DEFAULT_H #define CGAL_HALFEDGEDS_DEFAULT_H 1 #include #include #include CGAL_BEGIN_NAMESPACE #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template class HalfedgeDS_default : public HalfedgeDS_list< Traits_, HalfedgeDSItems, Alloc> { public: typedef Traits_ Traits; typedef HalfedgeDS_list DS; typedef typename DS::size_type size_type; HalfedgeDS_default() {} HalfedgeDS_default( size_type v, size_type h, size_type f) : HalfedgeDS_list< Traits_, HalfedgeDSItems, Alloc>(v,h,f) {} }; #define CGAL_HALFEDGEDS_DEFAULT ::CGAL::HalfedgeDS_default #else // CGAL_CFG_NO_TMPL_IN_TMPL_PARAM // struct HalfedgeDS_default { template class HDS : public HalfedgeDS_list::HDS { public: typedef Traits_ Traits; typedef HalfedgeDS_list::HDS DS; typedef typename DS::size_type size_type; HDS() {} HDS( size_type v, size_type h, size_type f) : HalfedgeDS_list::HDS(v,h,f) {} }; }; #define CGAL_HALFEDGEDS_DEFAULT ::CGAL::HalfedgeDS_default::HDS #endif // CGAL_CFG_NO_TMPL_IN_TMPL_PARAM // CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_DEFAULT_H // // EOF // ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_face_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_face_b0000644000175000017500000001133011344301501031332 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_face_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : ? #ifndef CGAL_TOPOLOGICAL_MAP_FACE_BASE_H #define CGAL_TOPOLOGICAL_MAP_FACE_BASE_H #ifndef CGAL_HALFEDGEDS_FACE_BASE_H #include #endif #include CGAL_BEGIN_NAMESPACE template < class Refs > class Topological_map_face_list_base : public HalfedgeDS_face_base { public: typedef HalfedgeDS_face_base Base; // Handles have to explicitly repeated, although they are derived typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Vertex Vertex; typedef typename Base::Halfedge Halfedge; // Supported options by HDS. typedef typename Base::Supports_face_halfedge Supports_face_halfedge; // Circulator category. typedef typename Halfedge::Supports_halfedge_prev Supports_prev; public: // Circulator category. // SHAI: //typedef Polyhedron_circulator_traits Ctr; //typedef typename Ctr::iterator_category circulator_category; // SHAI: figure out wether you realy want these here // and if so, replace names. // Circulators around a vertex and around a facet. //typedef I_HalfedgeDS_facet_circ< Halfedge_handle, circulator_category> //Halfedge_around_facet_circulator; //typedef I_HalfedgeDS_vertex_circ< Halfedge_handle, circulator_category> //Halfedge_around_vertex_circulator; //typedef I_HalfedgeDS_facet_circ< //Halfedge_const_handle, // circulator_category> Halfedge_around_facet_const_circulator; //typedef I_HalfedgeDS_vertex_circ< //Halfedge_const_handle, // circulator_category> Halfedge_around_vertex_const_circulator; //typedef typename Halfedge_around_vertex_circulator::size_type //size_type; //typedef typename Halfedge_around_vertex_circulator::difference_type //difference_type; public: // Hole types typedef std::list Holes_container; typedef Holes_container::iterator Holes_iterator; typedef Holes_container::const_iterator Holes_const_iterator; public: // We need to repeat the constructors here. Topological_map_face_list_base() : holes() {} // SHAI: Rewrite copy ctor to copy holes //Topological_map_face_list_base( const Base& b) : Base(b) : {} // New Access Functions (not provided in FacetBase). /* Halfedge_around_facet_circulator facet_begin() { // a circulator of halfedges around the facet (counterclockwise). return Halfedge_around_facet_circulator( halfedge()); } Halfedge_around_facet_const_circulator facet_begin() const { // a circulator of halfedges around the facet (counterclockwise). return Halfedge_around_facet_const_circulator( halfedge()); } size_type size() const { return circulator_size( facet_begin()); } */ // No longer hidden. Now the restricted version with precondition. // sets incident halfedge to h. Precondition: h is incident, i.e., // h->face() == v. void set_halfedge( Halfedge_handle hh) { CGAL_assertion( &*(hh->facet()) == this); Base::set_halfedge(hh); } private: Holes_container holes; public: Holes_iterator holes_begin() { return holes.begin(); } Holes_iterator holes_end() { return holes.end(); } Holes_const_iterator holes_begin() const { return holes.begin(); } Holes_const_iterator holes_end() const { return holes.end(); } void add_hole (Halfedge_handle hh) { holes.push_back(hh); } void erase_hole(Holes_iterator hit) { holes.erase(hit); } void erase_holes(Holes_iterator h_begin, Holes_iterator h_end) { holes.erase(h_begin, h_end); } }; CGAL_END_NAMESPACE #endif // CGAL_I_TOPOLOGICAL_MAP_FACE_BASE_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_bas0000644000175000017500000000371411344301501031374 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_FACE_BASE_2_H #define CGAL_TRIANGULATION_FACE_BASE_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename Gt, typename Fb = Triangulation_ds_face_base_2<> > class Triangulation_face_base_2 : public Fb { public: typedef Gt Geom_traits; typedef typename Fb::Vertex_handle Vertex_handle; typedef typename Fb::Face_handle Face_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Fb2; typedef Triangulation_face_base_2 Other; }; public: Triangulation_face_base_2() : Fb() {} Triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Fb(v0,v1,v2) {} Triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Fb(v0,v1,v2,n0,n1,n2) {} }; CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_FACE_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Modifier_base.h0000644000175000017500000000311411344301500027720 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Modifier_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_MODIFIER_BASE_H #define CGAL_MODIFIER_BASE_H 1 CGAL_BEGIN_NAMESPACE template class Modifier_base { // Abstract Base Class for protected internal access. // It defines the common interface for all modifiers. public: typedef R Representation; virtual void operator()( R& rep) = 0; // Postcondition: `rep' is a valid representation. virtual ~Modifier_base() {} }; CGAL_END_NAMESPACE #endif // CGAL_MODIFIER_BASE_H // // EOF // ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_Minkowski_distance.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_Minkowski_dis0000644000175000017500000001410311344301501031375 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_Minkowski_distance.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Hans Tangelder () // Note: Use p=0 to denote the weighted Linf-distance // For 0 #include namespace CGAL { template class Weighted_Minkowski_distance { public: typedef typename SearchTraits::Point_d Point_d; typedef Point_d Query_item; typedef typename SearchTraits::FT FT; typedef std::vector Weight_vector; private: typedef typename SearchTraits::Cartesian_const_iterator_d Coord_iterator; FT power; Weight_vector the_weights; public: // default constructor Weighted_Minkowski_distance() : power(2) {} Weighted_Minkowski_distance(const int d) : power(2), the_weights(d) { for (unsigned int i = 0; i < d; ++i) the_weights[i]=FT(1); } //default copy constructor and destructor Weighted_Minkowski_distance (FT pow, int dim, const Weight_vector& weights) : power(pow) { CGAL_assertion(power >= FT(0)); CGAL_assertion(dim==weights.size()); for (unsigned int i = 0; i < weights.size(); ++i) CGAL_assertion(weights[i]>=FT(0)); the_weights.resize(weights.size()); the_weights = weights; } template Weighted_Minkowski_distance (FT pow, int dim, InputIterator begin, InputIterator end) : power(pow) { CGAL_assertion(power >= FT(0)); the_weights.resize(dim); std::copy(begin, end, the_weights.begin()); for (int i = 0; i < dim; ++i){ the_weights[i] = *begin; ++begin; CGAL_assertion(the_weights[i]>=FT(0)); } CGAL_assertion(begin == end); } inline FT transformed_distance(const Query_item& q, const Point_d& p) { FT distance = FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; Coord_iterator qit = construct_it(q), qe = construct_it(q,1), pit = construct_it(p); if (power == FT(0)) { for (unsigned int i = 0; qit != qe; ++qit, ++i) if (the_weights[i] * fabs((*qit) - (*pit)) > distance) distance = the_weights[i] * fabs((*qit)-(*pit)); } else for (unsigned int i = 0; qit != qe; ++qit, ++i) distance += the_weights[i] * pow(fabs((*qit)-(*pit)),power); return distance; } inline FT min_distance_to_rectangle(const Query_item& q, const Kd_tree_rectangle& r) const { FT distance = FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; Coord_iterator qit = construct_it(q), qe = construct_it(q,1); if (power == FT(0)) { for (unsigned int i = 0; qit != qe; ++qit, ++i) { if (the_weights[i]*(r.min_coord(i) - (*qit)) > distance) distance = the_weights[i] * (r.min_coord(i)- (*qit)); if (the_weights[i] * ((*qit) - r.max_coord(i)) > distance) distance = the_weights[i] * ((*qit)-r.max_coord(i)); } } else { for (unsigned int i = 0; qit != qe; ++qit, ++i) { if ((*qit) < r.min_coord(i)) distance += the_weights[i] * pow(r.min_coord(i)-(*qit),power); if ((*qit) > r.max_coord(i)) distance += the_weights[i] * pow((*qit)-r.max_coord(i),power); } }; return distance; } inline FT max_distance_to_rectangle(const Query_item& q, const Kd_tree_rectangle& r) const { FT distance=FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; Coord_iterator qit = construct_it(q), qe = construct_it(q,1); if (power == FT(0)) { for (unsigned int i = 0; qit != qe; ++qit, ++i) { if ((*qit) >= (r.min_coord(i) + r.max_coord(i))/FT(2.0)) if (the_weights[i] * ((*qit) - r.min_coord(i)) > distance) distance = the_weights[i] * ((*qit)-r.min_coord(i)); else if (the_weights[i] * (r.max_coord(i) - (*qit)) > distance) distance = the_weights[i] * ( r.max_coord(i)-(*qit)); } } else { for (unsigned int i = 0; qit != qe; ++qit, ++i) { if ((*qit) <= (r.min_coord(i)+r.max_coord(i))/FT(2.0)) distance += the_weights[i] * pow(r.max_coord(i)-(*qit),power); else distance += the_weights[i] * pow((*qit)-r.min_coord(i),power); } }; return distance; } inline FT new_distance(FT dist, FT old_off, FT new_off, int cutting_dimension) const { FT new_dist; if (power == FT(0)) { if (the_weights[cutting_dimension]*fabs(new_off) > dist) new_dist= the_weights[cutting_dimension]*fabs(new_off); else new_dist=dist; } else { new_dist = dist + the_weights[cutting_dimension] * (pow(fabs(new_off),power)-pow(fabs(old_off),power)); } return new_dist; } inline FT transformed_distance(FT d) const { if (power <= FT(0)) return d; else return pow(d,power); } inline FT inverse_of_transformed_distance(FT d) const { if (power <= FT(0)) return d; else return pow(d,1/power); } }; // class Weighted_Minkowski_distance } // namespace CGAL #endif // CGAL_WEIGHTED_MINKOWSKI_DISTANCE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/wmult.h0000644000175000017500000000227011344301501026343 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/wmult.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_WMULT_H #define CGAL_WMULT_H #include #endif // CGAL_WMULT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/0000755000175000017500000000000012146213714026555 5ustar debiandebian././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/simple_objects.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/simple_object0000644000175000017500000000355511344301501031316 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/simple_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef SIMPLE_OBJECTS_H #define SIMPLE_OBJECTS_H CGAL_BEGIN_NAMESPACE template struct Lt_from_compare { typedef typename R::Point_d Point_d; bool operator()(const Point_d& p1, const Point_d& p2) const { typename R::Compare_lexicographically_d cmp; return cmp(p1,p2) == SMALLER; } }; template struct Le_from_compare { typedef typename R::Point_d Point_d; bool operator()(const Point_d& p1, const Point_d& p2) const { typename R::Compare_lexicographically_d cmp; return cmp(p1,p2) != LARGER; } }; template struct Eq_from_method { typedef typename R::Point_d Point_d; bool operator()(const Point_d& p1, const Point_d& p2) const { return p1 == p2; } }; CGAL_END_NAMESPACE #endif //SIMPLE_OBJECTS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PVDHACd.C0000644000175000017500000000306411344301501027764 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PVDHACd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #if defined(CGAL_POINTCD_H) && defined(CGAL_VECTORCD_H) && \ defined(CGAL_DIRECTIONCD_H) && defined(CGAL_HYPERPLANECD_H) && \ defined(CGAL_AFF_TRANSFORMATIONCD_H) && !defined(CGAL_PVDHACD_C) #define CGAL_PVDHACD_C #include #include #include #include #include #endif //CGAL_PVDHACD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Ray_d.h0000644000175000017500000001524311344301501027760 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Ray_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_RAY_D_H #define CGAL_RAY_D_H #include #include #include CGAL_BEGIN_NAMESPACE template std::istream& operator>>(std::istream&, Ray_d&); template std::ostream& operator<<(std::ostream&, const Ray_d&); /*{\Manpage {Ray_d}{R}{Rays in d-space}{r}}*/ template class Ray_d : public Handle_for< Pair_d > { typedef Pair_d Pair; typedef Handle_for Base; typedef Ray_d Self; using Base::ptr; /*{\Mdefinition An instance of data type |Ray_d| is a ray in $d$-dimensional Euclidian space. It starts in a point called the source of |\Mvar| and it goes to infinity.}*/ public: /*{\Mtypes 4}*/ typedef p_R R; /*{\Mtypemember the representation type.}*/ typedef typename p_R::RT RT; /*{\Mtypemember the ring type.}*/ typedef typename p_R::FT FT; /*{\Mtypemember the field type.}*/ typedef typename p_R::LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename Vector_d::Base_vector Base_vector; friend class Line_d; friend class Segment_d; private: Ray_d(const Base& b) : Base(b) {} public: /*{\Mcreation 3}*/ Ray_d() : Base( Pair() ) {} /*{\Mcreate introduces some ray in $d$-dimensional space }*/ Ray_d(const Point_d& p, const Point_d& q) /*{\Mcreate introduces a ray through |p| and |q| and starting at |p|. \precond $p$ and $q$ are distinct and have the same dimension. }*/ : Base( Pair(p,q) ) { CGAL_assertion_msg(!ptr()->is_degenerate(), "Ray_d::constructor: the two points must be different." ); CGAL_assertion_msg((p.dimension()==q.dimension()), "Ray_d::constructor: the two points must have the same dimension." ); } Ray_d(const Point_d& p, const Direction_d& dir) /*{\Mcreate introduces a ray starting in |p| with direction |dir|. \precond |p| and |dir| have the same dimension and |dir| is not trivial.}*/ : Base( Pair(p,p+dir.vector()) ) { CGAL_assertion_msg((p.dimension()==dir.dimension()), "Ray_d::constructor: the p and dir must have the same dimension." ); CGAL_assertion_msg(!dir.is_degenerate(), "Ray_d::constructor: dir must be non-degenerate." ); } Ray_d(const Segment_d& s) /*{\Mcreate introduces a ray through |s.source()| and |s.target()| and starting at |s.source()|. \precond $s$ is not trivial. }*/ : Base( s ) { CGAL_assertion_msg(!s.is_degenerate(), "Ray_d::constructor: segment is trivial."); } Ray_d(const Ray_d& r) : Base(r) {} /*{\Moperations 3 3}*/ int dimension() const { return (ptr()->_p[0].dimension()); } /*{\Mop returns the dimension of the underlying space.}*/ Point_d source() const { return (ptr()->_p[0]); } /*{\Mop returns the source point of |\Mvar|. }*/ Point_d point(int i) const /*{\Mop returns a point on |\Mvar|. |point(0)| is the source. |point(i)|, with $i>0$, is different from the source. \precond $i \geq 0$.}*/ { return (ptr()->_p[i%2]); } Direction_d direction() const /*{\Mop returns the direction of |\Mvar|. }*/ { return ptr()->direction(); } inline Line_d supporting_line() const; /*{\Mop returns the supporting line of |\Mvar|.}*/ Ray_d opposite() const /*{\Mop returns the ray with direction opposite to |\Mvar| and starting in |source|.}*/ { return Ray_d(source(),-direction()); } Ray_d transform(const Aff_transformation_d& t) const /*{\Mop returns $t(l)$. }*/ { return Ray_d(point(0).transform(t),point(1).transform(t)); } Ray_d operator+(const Vector_d& v) const /*{\Mbinop returns |\Mvar+v|, i.e., |\Mvar| translated by vector $v$.}*/ { return Ray_d(point(0)+v, point(1)+v); } bool has_on(const Point_d& p) const /*{\Mop A point is on |r|, iff it is equal to the source of |r|, or if it is in the interior of |r|.}*/ { typename R::Position_on_line_d pos; FT l; if (pos(p,point(0),point(1),l)) return (FT(0)<=l); return false; } /*{\Mtext \headerline{Non-Member Functions}}*/ bool operator==(const Ray_d& r1) const { if ( identical(r1) ) return true; if ( dimension() != r1.dimension() ) return false; return source() == r1.source() && direction() == r1.direction(); } bool operator!=(const Ray_d& r1) { return !operator==(r1); } friend std::istream& operator>> <> (std::istream&, Ray_d&); friend std::ostream& operator<< <> (std::ostream&, const Ray_d&); }; // end of class template bool parallel(const Ray_d& r1, const Ray_d& r2) /*{\Mfunc returns true if the unoriented supporting lines of |r1| and |r2| are parallel and false otherwise. }*/ { return (r1.direction() == r2.direction()) || (r1.direction() == -(r2.direction())); } template std::istream& operator>>(std::istream& I, Ray_d& r) { r.copy_on_write(); r.ptr()->read(I); CGAL_assertion_msg(r.point(0)!=r.point(1), "Line_d::operator>>: trivial ray."); CGAL_assertion_msg(r.point(0).dimension()==r.point(1).dimension(), "Ray_d::operator>>: dimensions disagree."); return I; } template std::ostream& operator<<(std::ostream& O, const Ray_d& r) { r.ptr()->print(O,"Ray_d"); return O; } template inline CGAL::io_Operator io_tag(const Ray_d&) { return CGAL::io_Operator(); } /*{\Mimplementation Rays are implemented by a pair of points as an item type. All operations like creation, initialization, tests, direction calculation, input and output on a ray $r$ take time $O(|r.dimension()|)$. |dimension()|, coordinate and point access, and identity test take constant time. The space requirement is $O(|r.dimension()|)$.}*/ CGAL_END_NAMESPACE #endif // CGAL_RAYHD_H //----------------------- end of file ---------------------------------- ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneCd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneCd.0000644000175000017500000001745311344301501031135 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_HYPERPLANECD_H #define CGAL_HYPERPLANECD_H #ifndef NOCGALINCL #include #endif CGAL_BEGIN_NAMESPACE #define PointCd PointCd2 template std::istream& operator>>(std::istream&, HyperplaneCd&); template std::ostream& operator<<(std::ostream&, const HyperplaneCd&); template class HyperplaneCd : public Handle_for< Tuple_d<_FT,_LA> > { typedef Tuple_d<_FT,_LA> Tuple; typedef Handle_for Base; typedef HyperplaneCd<_FT,_LA> Self; using Base::ptr; const typename _LA::Vector& vector_rep() const { return ptr()->v; } _FT& entry(int i) { return ptr()->v[i]; } const _FT& entry(int i) const { return ptr()->v[i]; } void invert_rep() { ptr()->invert(); } public: typedef _FT RT; typedef _FT FT; typedef _LA LA; typedef typename Tuple::const_iterator Coefficient_const_iterator; HyperplaneCd(int d = 0) : Base( Tuple(d+1) ) {} template HyperplaneCd(int d, InputIterator first, InputIterator last, const FT& D) : Base( Tuple(d+1,first,last,D) ) {} template HyperplaneCd(int d, InputIterator first, InputIterator last) : Base( Tuple(d+1,first,last) ) {} template void construct_from_points(ForwardIterator first, ForwardIterator last, const PointCd& o, Oriented_side side) { // inline due to template parameter TUPLE_DIM_CHECK(first,last,hyperplane::construction); CGAL_assertion_msg((first->dimension()==o.dimension()), "hyperplane::construction: dimensions disagree."); int d = first->dimension(); // we are in $d$ - dimensional space int m = std::distance(first,last); // |P| has $m$ points typename LA::Matrix A(m,d + 1); for (int i = 0; i < m; i++) { /* define $i$-th equation */ for (int j = 0; j < d; j++) A(i,j) = first->cartesian(j); // $j$ - th coord of $i$-th point A(i,d) = 1; ++first; } typename LA::Matrix spanning_vecs; // columns span solution int dim = LA::homogeneous_linear_solver(A,spanning_vecs); CGAL_assertion_msg(dim != 0, "HyperplaneCd::constructor: set P is full dimensional."); if (side == ON_ORIENTED_BOUNDARY) { ptr()->v = spanning_vecs.column(0); return; } FT sum = 0; int j; for (j = 0; j < dim; j++) { for (int i = 0; i < d; i++) sum += spanning_vecs(i,j)*o.cartesian(i); sum += spanning_vecs(d,j); if (sum != FT(0)) break; } CGAL_assertion_msg(j != dim, "HyperplaneCd::constructor: cannot use o to determine side."); ptr()->v = spanning_vecs.column(j); if ( CGAL_NTS sign(sum) > 0 && side == ON_NEGATIVE_SIDE || CGAL_NTS sign(sum) < 0 && side == ON_POSITIVE_SIDE) invert_rep(); } template HyperplaneCd(ForwardIterator first, ForwardIterator last, const PointCd& o, Oriented_side side = Oriented_side(0)) : Base( Tuple(o.dimension()+1) ) { construct_from_points(first,last,o,side); } HyperplaneCd(const PointCd& p, const DirectionCd& dir) : Base( Tuple(p.dimension()+1) ) { int d = p.dimension(); CGAL_assertion_msg((dir.dimension() == d), "HyperplaneCd::constructor: parameter dimensions disagree."); FT sum = 0; for (int i = 0; i < d; i++) { sum += dir.delta(i)*p.cartesian(i); entry(i) = dir.delta(i); } entry(d) = -sum; } HyperplaneCd(const FT& a, const FT& b, const FT& c) : Base( Tuple(a,b,c,MatchHelper()) ) {} HyperplaneCd(int a, int b, int c) : Base( Tuple(FT(a),FT(b),FT(c),MatchHelper()) ) {} HyperplaneCd(const FT& a, const FT& b, const FT& c, const FT& d) : Base( Tuple(a,b,c,d) ) {} HyperplaneCd(int a, int b, int c, int d) : Base( Tuple(FT(a),FT(b),FT(c),FT(d)) ) {} HyperplaneCd(const HyperplaneCd& h) : Base(h) {} ~HyperplaneCd() {} int dimension() const { return ptr()->size()-1; } FT operator[](int i) const { CGAL_assertion_msg((0<=i && i<=(dimension())), "HyperplaneCd::op[]: index out of range."); return entry(i); } FT coefficient(int i) const { return entry(i); } const typename LA::Vector& coefficient_vector() const { return vector_rep(); } Coefficient_const_iterator coefficients_begin() const { return ptr()->begin(); } Coefficient_const_iterator coefficients_end() const { return ptr()->end(); } inline VectorCd orthogonal_vector() const; DirectionCd orthogonal_direction() const { return orthogonal_vector().direction(); } FT value_at(const PointCd& p) const { CGAL_assertion_msg((dimension()==p.dimension()), "HyperplaneCd::value_at: dimensions disagree."); FT res(0); for (register int i=0; i& p) const { CGAL_assertion_msg(dimension()==p.dimension(), "HyperplaneCd::oriented_side: dimensions do not agree."); return Oriented_side(CGAL_NTS sign(value_at(p))); } bool has_on(const PointCd& p) const { return (oriented_side(p) == ON_ORIENTED_BOUNDARY); } bool has_on_boundary(const PointCd& p) const { return (oriented_side(p) == ON_ORIENTED_BOUNDARY); } bool has_on_positive_side(const PointCd& p) const { return (oriented_side(p) == ON_POSITIVE_SIDE); } bool has_on_negative_side(const PointCd& p) const { return (oriented_side(p) == ON_NEGATIVE_SIDE); } HyperplaneCd transform(const Aff_transformationCd& t) const { Aff_transformationCd t_inv = t.inverse(); typename LA::Vector res = LA::transpose(t_inv.matrix())*vector_rep(); if ( t_inv.is_odd() ) res = -res; return HyperplaneCd(dimension(),res.begin(),res.end()); } static Comparison_result weak_cmp( const HyperplaneCd&, const HyperplaneCd&); static Comparison_result strong_cmp( const HyperplaneCd&, const HyperplaneCd&); bool operator==(const HyperplaneCd& h2) const { if (identical(h2)) return true; if (dimension()!=h2.dimension()) return false; return HyperplaneCd::strong_cmp(*this,h2) == EQUAL; } bool operator!=(const HyperplaneCd& h2) const { return !operator==(h2); } friend std::istream& operator>> <> (std::istream&, HyperplaneCd&); friend std::ostream& operator<< <> (std::ostream&, const HyperplaneCd&); }; // end of class HyperplaneCd template bool weak_equality(const HyperplaneCd& h1, const HyperplaneCd& h2) /*{\Mfunc test for weak equality. }*/ { if (h1.identical(h2)) return true; if (h1.dimension()!=h2.dimension()) return false; return HyperplaneCd::weak_cmp(h1,h2) == EQUAL; } #undef PointCd CGAL_END_NAMESPACE #endif // CGAL_HYPERPLANECD_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointHd.h0000644000175000017500000002430211344301501030263 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_POINTHDXXX_H #define CGAL_POINTHDXXX_H #ifndef NOCGALINCL #include #include #include #endif #include #include #include CGAL_BEGIN_NAMESPACE #define PointHd PointHd2 template class PointHd; template std::istream& operator>>(std::istream&, PointHd&); template std::ostream& operator<<(std::ostream&, const PointHd&); /*{\Moptions outfile=Point_d.man}*/ /*{\Manpage {Point_d} {R} {Points in d-space} {p}}*/ /*{\Msubst Hd#_d PointHd#Point_d Quotient#FT }*/ template class PointHd : public Handle_for< Tuple_d<_RT,_LA> > { typedef Tuple_d<_RT,_LA> Tuple; typedef Handle_for Base; typedef PointHd<_RT,_LA> Self; using Base::ptr; /*{\Mdefinition An instance of data type |\Mname| is a point of Euclidean space in dimension $d$. A point $p = (p_0,\ldots,p_{ d - 1 })$ in $d$-dimensional space can be represented by homogeneous coordinates $(h_0,h_1,\ldots,h_d)$ of number type |RT| such that $p_i = h_i/h_d$, which is of type |FT|. The homogenizing coordinate $h_d$ is positive. We call $p_i$, $0 \leq i < d$ the $i$-th Cartesian coordinate and $h_i$, $0 \le i \le d$, the $i$-th homogeneous coordinate. We call $d$ the dimension of the point.}*/ const typename _LA::Vector& vector_rep() const { return ptr()->v; } _RT& entry(int i) { return ptr()->v[i]; } const _RT& entry(int i) const { return ptr()->v[i]; } void invert_rep() { ptr()->invert(); } PointHd(const Base& b) : Base(b) {} public: /*{\Mtypes 4}*/ typedef _RT RT; /*{\Mtypemember the ring type.}*/ typedef Quotient<_RT> FT; /*{\Mtypemember the field type.}*/ typedef _LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename Tuple::Cartesian_const_iterator Cartesian_const_iterator; /*{\Mtypemember a read-only iterator for the cartesian coordinates.}*/ typedef typename Tuple::const_iterator Homogeneous_const_iterator; /*{\Mtypemember a read-only iterator for the homogeneous coordinates.}*/ friend class VectorHd; friend class HyperplaneHd; /*{\Mcreation 4}*/ PointHd(int d = 0) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $d$-dimensional space.}*/ : Base( Tuple(d+1) ) { if ( d > 0 ) entry(d) = 1; } PointHd(int d, const Origin&) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $d$-dimensional space, initialized to the origin.}*/ : Base( Tuple(d+1) ) { entry(d) = 1; } template PointHd(int d, InputIterator first, InputIterator last) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in dimension |d|. If |size [first,last) == d| this creates a point with Cartesian coordinates |set [first,last)|. If |size [first,last) == p+1| the range specifies the homogeneous coordinates $|H = set [first,last)| = (\pm h_0, \pm h_1, \ldots, \pm h_d)$ where the sign chosen is the sign of $h_d$. \precond |d| is nonnegative, |[first,last)| has |d| or |d+1| elements where the last has to be non-zero, and the value type of |InputIterator| is |RT|.}*/ : Base( Tuple(d+1,first,last) ) { RT D = entry(d); if ( D == RT(0) ) entry(d) = 1; if ( D < RT(0) ) invert_rep(); } template PointHd (int d, InputIterator first, InputIterator last, const RT& D) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in dimension |d| initialized to the point with homogeneous coordinates as defined by |H = set [first,last)| and |D|: $(\pm |H[0]|, \pm|H[1]|, \ldots, \pm|H[d-1]|, \pm|D|)$. The sign chosen is the sign of $D$. \precond |D| is non-zero, the iterator range defines a $d$-tuple of |RT|, and the value type of |InputIterator| is |RT|. }*/ : Base( Tuple(d+1,first,last,D) ) { CGAL_assertion_msg(D!=RT(0),"PointHd::constructor: D must be nonzero."); if (D < RT(0)) invert_rep(); } PointHd(int x, int y, int w = 1) : Base( Tuple((RT)x,(RT)y,(RT)w) ) { CGAL_assertion_msg((w != 0),"PointHd::construction: w == 0."); if (w < 0) invert_rep(); } PointHd(const RT& x, const RT& y, const RT& w = 1) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $2$-dimensional space.}*/ : Base( Tuple(x,y,w,MatchHelper()) ) { CGAL_assertion_msg((w!=0),"PointHd::construction: w == 0."); if (w < 0) invert_rep(); } PointHd(int x, int y, int z, int w) : Base( Tuple((RT)x,(RT)y,(RT)z,(RT)w) ) { CGAL_assertion_msg((w!=0),"PointHd::construction: w == 0."); if (w < 0) invert_rep(); } PointHd(const RT& x, const RT& y, const RT& z, const RT& w) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $3$-dimensional space.}*/ : Base( Tuple(x,y,z,w) ) { CGAL_assertion_msg((w!=0),"PointHd::construction: w == 0."); if (w < 0) invert_rep(); } PointHd(const PointHd& p) : Base(p) {} ~PointHd() {} /*{\Moperations 4 3}*/ int dimension() const { return ptr()->size()-1; } /*{\Mop returns the dimension of |\Mvar|. }*/ Quotient cartesian(int i) const /*{\Mop returns the $i$-th Cartesian coordinate of |\Mvar|. \precond $0 \leq i < d$.}*/ { CGAL_assertion_msg((0<=i && i(entry(i), entry(dimension())); } Quotient operator[](int i) const { return cartesian(i); } /*{\Marrop returns the $i$-th Cartesian coordinate of |\Mvar|. \precond $0 \leq i < d$.}*/ RT homogeneous(int i) const /*{\Mop returns the $i$-th homogeneous coordinate of |\Mvar|. \precond $0 \leq i \leq d$.}*/ { CGAL_assertion_msg((0<=i && i<=(dimension())), "PointHd::homogeneous():index out of range."); return entry(i); } Cartesian_const_iterator cartesian_begin() const /*{\Mop returns an iterator pointing to the zeroth Cartesian coordinate $p_0$ of |\Mvar|. }*/ { return Cartesian_const_iterator(ptr()->begin(),ptr()->last()); } Cartesian_const_iterator cartesian_end() const /*{\Mop returns an iterator pointing beyond the last Cartesian coordinate of |\Mvar|. }*/ { return Cartesian_const_iterator(ptr()->last(),ptr()->last()); } Homogeneous_const_iterator homogeneous_begin() const /*{\Mop returns an iterator pointing to the zeroth homogeneous coordinate $h_0$ of |\Mvar|. }*/ { return ptr()->begin(); } Homogeneous_const_iterator homogeneous_end() const /*{\Mop returns an iterator pointing beyond the last homogeneous coordinate of |\Mvar|. }*/ { return ptr()->end(); } PointHd transform(const Aff_transformationHd& t) const; /*{\Mop returns $t(p)$. }*/ /*{\Mtext \headerline{Arithmetic Operators, Tests and IO}}*/ inline VectorHd operator-(const Origin& o) const; /*{\Mbinop returns the vector $\vec{0p}$.}*/ VectorHd operator-(const PointHd& q) const /*{\Mbinop returns $p - q$. \precond |p.dimension() == q.dimension()|.}*/ { VectorHd res(dimension()); res.ptr()->homogeneous_sub(ptr(),q.ptr()); return res; } PointHd operator+(const VectorHd& v) const; /*{\Mbinop returns $p + v$. \precond |p.dimension() == v.dimension()|.}*/ PointHd operator-(const VectorHd& v) const; /*{\Mbinop returns $p - v$. \precond |p.dimension() == v.dimension()|.}*/ PointHd& operator+=(const VectorHd& v); /*{\Mbinop adds |v| to |p|.\\ \precond |p.dimension() == v.dimension()|. }*/ PointHd& operator-=(const VectorHd& v); /*{\Mbinop subtracts |v| from |p|.\\ \precond |p.dimension() == v.dimension()|. }*/ static Comparison_result cmp( const PointHd& p1, const PointHd& p2) { Compare_homogeneously cmpobj; return cmpobj(p1.vector_rep(),p2.vector_rep()); } bool operator==(const PointHd& q) const { if (identical(q)) return true; if (dimension()!=q.dimension()) return false; return cmp(*this,q) == EQUAL; } bool operator!=(const PointHd& q) const { return !(*this==q); } bool operator==(const Origin&) const /*{\Mbinop returns true if |\Mvar| is the origin. }*/ { for (int i = 0; i < dimension(); i++) if (homogeneous(i) != RT(0)) return false; return true; } friend std::istream& operator>> <> (std::istream&, PointHd&); friend std::ostream& operator<< <> (std::ostream&, const PointHd&); /*{\Mtext \headerline{Downward compatibility} We provide operations of the lower dimensional interface |x()|, |y()|, |z()|, |hx()|, |hy()|, |hz()|, |hw()|.}*/ RT hx() const { return homogeneous(0); } RT hy() const { return homogeneous(1); } RT hz() const { return homogeneous(2); } RT hw() const { return homogeneous(dimension()); } Quotient x() const { return Quotient(hx(),hw()); } Quotient y() const { return Quotient(hy(),hw()); } Quotient z() const { return Quotient(hz(),hw()); } }; // PointHd /*{\Mimplementation Points are implemented by arrays of |RT| items. All operations like creation, initialization, tests, point - vector arithmetic, input and output on a point $p$ take time $O(|p.dimension()|)$. |dimension()|, coordinate access and conversions take constant time. The space requirement for points is $O(|p.dimension()|)$.}*/ #undef PointHd CGAL_END_NAMESPACE #endif // CGAL_POINTHD_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorCd.h0000644000175000017500000001704411344301501030434 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_VECTORCD_H #define CGAL_VECTORCD_H #ifndef NOCGALINCL #include #endif #include CGAL_BEGIN_NAMESPACE #define PointCd PointCd2 template class VectorCd; template std::istream& operator>>(std::istream&, VectorCd&); template std::ostream& operator<<(std::ostream&, const VectorCd&); template class VectorCd : public Handle_for< Tuple_d<_FT,_LA> > { typedef Tuple_d<_FT,_LA> Tuple; typedef Handle_for Base; typedef VectorCd<_FT,_LA> Self; using Base::ptr; using Base::copy_on_write; typename _LA::Vector& vector_rep() { return ptr()->v; } const typename _LA::Vector& vector_rep() const { return ptr()->v; } _FT& entry(int i) { return ptr()->v[i]; } const _FT& entry(int i) const { return ptr()->v[i]; } void invert_rep() { ptr()->invert(); } VectorCd(const Base& b) : Base(b) {} public: typedef _FT RT; typedef _FT FT; typedef _LA LA; typedef typename Tuple::const_iterator Cartesian_const_iterator; typedef typename Tuple::Homogeneous_const_iterator Homogeneous_const_iterator; class Base_vector {}; friend class PointCd; friend class DirectionCd; friend class HyperplaneCd; VectorCd(int d = 0) : Base( Tuple(d) ) {} VectorCd(int d, Null_vector) : Base( Tuple(d) ) {} template VectorCd(int d, InputIterator first, InputIterator last) : Base( Tuple(d,first,last) ) { if ( first == last ) return; // else first specifies common denominator: CGAL_assertion_msg(*first!=FT(0), "VectorCd::constructor: denominator must be nonzero."); for (register int i=0; i VectorCd(int d, InputIterator first, InputIterator last, const FT& D) : Base( Tuple(d,first,last) ) { CGAL_assertion_msg(D!=FT(0), "VectorCd::constructor: D must be nonzero."); for (register int i=0; i& p) : Base(p) {} ~VectorCd() {} int dimension() const { return ptr()->size(); } FT cartesian(int i) const { CGAL_assertion_msg((0<=i && i<(dimension())), "VectorCd::cartesian(): index out of range."); return entry(i); } FT operator[](int i) const { return cartesian(i); } FT homogeneous(int i) const { CGAL_assertion_msg((0<=i && i<=(dimension())), "VectorCd::homogeneous(): index out of range."); if (i!=dimension()) return entry(i); else return FT(1); } FT squared_length() const { return vector_rep()*vector_rep(); } Cartesian_const_iterator cartesian_begin() const { return ptr()->begin(); } Cartesian_const_iterator cartesian_end() const { return ptr()->end(); } Homogeneous_const_iterator homogeneous_begin() const { return Homogeneous_const_iterator(ptr()->begin(),ptr()->end()); } Homogeneous_const_iterator homogeneous_end() const { return Homogeneous_const_iterator(ptr()->beyondend()); } inline PointCd to_point() const; inline DirectionCd direction() const; /*{\Mop returns the direction of |\Mvar|. }*/ VectorCd transform(const Aff_transformationCd& t) const; VectorCd scale(const FT& m) const { VectorCd result(*this); result.copy_on_write(); result.vector_rep() *= m; return result; } void self_scale(const FT& m) { copy_on_write(); vector_rep() *= m; } VectorCd& operator*=(const FT& n) { self_scale(n); return *this; } VectorCd& operator*=(int n) { self_scale(n); return *this; } VectorCd operator/(int n) const { return scale(FT(1)/FT(n)); } VectorCd operator/(const FT& n) const { return scale(FT(1)/n); } VectorCd& operator/=(const FT& n) { self_scale(FT(1)/n); return *this; } VectorCd& operator/=(int n) { self_scale(FT(1)/FT(n)); return *this; } FT operator* (const VectorCd& w) const { return vector_rep()*w.vector_rep(); } VectorCd operator+(const VectorCd& w) const { VectorCd result(w.dimension()); result.ptr()->cartesian_add(ptr(),w.ptr()); return result; } VectorCd operator-(const VectorCd& w) const { VectorCd result(w.dimension()); result.ptr()->cartesian_sub(ptr(),w.ptr()); return result; } VectorCd operator-() const { VectorCd result(*this); result.copy_on_write(); // creates a copied object! result.ptr()->invert(); return result; } VectorCd& operator+=(const VectorCd& w) { copy_on_write(); vector_rep() += w.vector_rep(); return *this; } VectorCd& operator-=(const VectorCd& w) { copy_on_write(); vector_rep() -= w.vector_rep(); return *this; } static Comparison_result cmp( const VectorCd& x, const VectorCd& y) { Compare_componentwise cmpobj; return cmpobj(x.vector_rep(),y.vector_rep()); } bool operator==(const VectorCd& w) const { if ( identical(w) ) return true; if ( dimension() != w.dimension() ) return false; return vector_rep()==w.vector_rep(); } bool operator!=(const VectorCd& w) const { return !operator==(w); } bool is_zero() const { return vector_rep().is_zero(); } FT hx() const { return cartesian(0); } FT hy() const { return cartesian(1); } FT hz() const { return cartesian(2); } FT hw() const { return FT(1); } FT x() const { return cartesian(0); } FT y() const { return cartesian(1); } FT z() const { return cartesian(2); } friend std::istream& operator>> <> (std::istream& I, VectorCd& v); friend std::ostream& operator<< <> (std::ostream& O, const VectorCd& v); }; // end of class VectorCd #undef PointCd CGAL_END_NAMESPACE #endif // CGAL_VECTORCD_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionCd.h0000644000175000017500000001062111344301501031104 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DIRECTIONCD_H #define CGAL_DIRECTIONCD_H #ifndef NOCGALINCL #include #endif #include CGAL_BEGIN_NAMESPACE template class DirectionCd; template std::istream& operator>>(std::istream&, DirectionCd&); template std::ostream& operator<<(std::ostream&, const DirectionCd&); template class DirectionCd : public Handle_for< Tuple_d<_FT,_LA> > { typedef Tuple_d<_FT,_LA> Tuple; typedef Handle_for Base; typedef DirectionCd<_FT,_LA> Self; using Base::ptr; const typename _LA::Vector& vector_rep() const { return ptr()->v; } _FT& entry(int i) { return ptr()->v[i]; } const _FT& entry(int i) const { return ptr()->v[i]; } public: /*{\Mtypes 4}*/ typedef _FT RT; typedef _FT FT; typedef _LA LA; typedef typename Tuple::const_iterator Delta_const_iterator; class Base_direction {}; friend class VectorCd; DirectionCd(int d = 0) : Base( Tuple(d) ) {} DirectionCd(const VectorCd& v); template DirectionCd(int d, InputIterator first, InputIterator last) : Base( Tuple(d,first,last) ) {} DirectionCd(int d, Base_direction, int i) : Base( Tuple(d) ) { if ( d==0 ) return; CGAL_assertion_msg((0<=i&&i& p) : Base(p) {} ~DirectionCd() {} int dimension() const { return ptr()->size(); } FT delta(int i) const { CGAL_assertion_msg((0<=i && i<(dimension())), "DirectionCd::delta(): index out of range."); return entry(i); } FT D() { return FT(1); } FT operator[](int i) const { return delta(i); } Delta_const_iterator deltas_begin() const { return ptr()->begin(); } Delta_const_iterator deltas_end() const { return ptr()->end(); } VectorCd vector() const; bool is_degenerate() const { return vector_rep().is_zero(); } DirectionCd transform(const Aff_transformationCd& t) const; DirectionCd opposite() const { DirectionCd result(*this); // creates a copied object! result.copy_on_write(); // creates a copied object! result.ptr()->invert(); return result; } DirectionCd operator- () const { return opposite(); } static Comparison_result cmp( const DirectionCd& h1, const DirectionCd& h2); bool operator==(const DirectionCd& w) const { if ( identical(w) ) return true; if ( dimension()!=w.dimension() ) return false; return (DirectionCd::cmp(*this,w) == EQUAL); } bool operator!=(const DirectionCd& w) const { return !operator==(w); } FT dx() const { return delta(0); } FT dy() const { return delta(1); } FT dz() const { return delta(2); } friend std::istream& operator>> <> (std::istream& I, DirectionCd& d); friend std::ostream& operator<< <> (std::ostream& O, const DirectionCd& d); }; // end of class DirectionCd CGAL_END_NAMESPACE #endif // CGAL_DIRECTIONCD_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PVDHAHd.C0000644000175000017500000000306411344301501027771 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PVDHAHd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #if defined(CGAL_POINTHD_H) && defined(CGAL_VECTORHD_H) && \ defined(CGAL_DIRECTIONHD_H) && defined(CGAL_HYPERPLANEHD_H) && \ defined(CGAL_AFF_TRANSFORMATIONHD_H) && !defined(CGAL_PVDHAHD_C) #define CGAL_PVDHAHD_C #include #include #include #include #include #endif //CGAL_PVDHAHD_C ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_objectsHd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_0000644000175000017500000001140311344301501031333 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_objectsHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : ? #ifndef CGAL_INTERSECTION_OBJECTSHD_H #define CGAL_INTERSECTION_OBJECTSHD_H #include CGAL_BEGIN_NAMESPACE /*{\Manpage{Line_line_intersectionHd}{R}{intersecting two lines}}*/ template class Line_line_intersectionHd { typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; typedef typename R::Point_d Point_d; public: enum Intersection_result { NO, POINT, LINE }; Intersection_result operator()( const Point_d& s1, const Point_d& t1, const Point_d& s2, const Point_d& t2, Point_d& p, FT& l1, FT& l2) /*{\Mfunop returns |NO| if the lines which are represented by |s1t1| and |s2t2| don't intersect, returns |POINT| if they intersect in a unique point, and returns LINE if they are identical. In the |POINT| case the point of intersection is assigned to |p|. Then |p = s1 + l1 * t1-s1| and |p = s2 + l2 * t2-s2|. \precond none of the point pairs is degenerate.}*/ { int d = s1.dimension(),i; CGAL_assertion_msg(d==s2.dimension(), "intersection: dimensions disagree!"); typename LA::Matrix M(d,2),S; typename LA::Vector b(d), lambda(2), c; RT D; RT s1w = s1.homogeneous(d); RT t1w = t1.homogeneous(d); RT s2w = s2.homogeneous(d); RT t2w = t2.homogeneous(d); RT g1w = s1w*t1w; RT g2w = s2w*t2w; RT t12w = t1w*t2w; /* init $d \times 2$ - matrix |M| and $d$ - vector |b| */ for (i = 0; i < d; i++) { M(i,0) = g2w * (t1.homogeneous(i) * s1w - s1.homogeneous(i) * t1w); M(i,1) = g1w * (s2.homogeneous(i) * t2w - t2.homogeneous(i) * s2w); b[i] = t12w * (s2.homogeneous(i) * s1w - s1.homogeneous(i) * s2w); } if (LA::linear_solver(M,b,lambda,D,S,c)) { if (S.column_dimension()>0) return LINE; l1 = R::make_FT(lambda[0],D); l2 = R::make_FT(lambda[1],D); p = s1 + l1 * (t1 - s1); return POINT; } return NO; } }; /*{\Manpage {Line_hyperplane_intersectionHd}{R} {intersecting a line and a hyperplane}}*/ template class Line_hyperplane_intersectionHd { typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; typedef typename R::Point_d Point_d; typedef typename R::Hyperplane_d Hyperplane_d; public: enum Intersection_result { NO, POINT, LINE }; Intersection_result operator()(const Point_d& s, const Point_d& t, const Hyperplane_d& h, Point_d& p, FT& lambda) /*{\Mfunop returns |NO| if the line represented by |s1t1| and the hyperplane |h| don't intersect, returns |POINT| if they intersect in a unique point, and returns LINE if the line is part of the hyperplane. In the |POINT| case the point of intersection is assigned to |p|. Then |p = s1 + lambda * t1-s1|. \precond the point pair is not degenerate.}*/ { CGAL_assertion_msg((h.dimension()==s.dimension() && h.dimension()==t.dimension()), "Line_hyperplane_intersection_d: dimensions do not agree."); int d = h.dimension(),i; RT S(0),T(0); for (i=0; i<=d; ++i) { S += h[i]*s.homogeneous(i); T += h[i]*t.homogeneous(i); } bool s_contained = CGAL_NTS is_zero(S), t_contained = CGAL_NTS is_zero(T); if (s_contained && t_contained) { p = s; return LINE; } if (s_contained) { p = s; return POINT; } if (t_contained) { p = t; return POINT; } // now the simple cases are done RT D = S * t.homogeneous(d) - T * s.homogeneous(d); if (CGAL_NTS is_zero(D)) return NO; typename LA::Vector homog(d + 1); for (i = 0; i < d; ++i) homog[i] = S * t.homogeneous(i) - T * s.homogeneous(i); homog[d] = D; p = Point_d(d,homog.begin(),homog.end()); lambda = R::make_FT(S * t.homogeneous(d), D); return POINT; } }; CGAL_END_NAMESPACE #include #endif //CGAL_INTERSECTION_OBJECTSHD_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointHd.C0000644000175000017500000000602211344301501030215 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointHd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_POINTHD_C #define CGAL_POINTHD_C CGAL_BEGIN_NAMESPACE #define PointHd PointHd2 template PointHd PointHd:: transform(const Aff_transformationHd& t) const { typename LA::Vector res = t(vector_rep()); return PointHd(dimension(),res.begin(),res.end()); } template VectorHd PointHd::operator-(const Origin&) const { return VectorHd(Base(*this)); } template PointHd PointHd::operator+(const VectorHd &v) const { PointHd res(dimension()); res.ptr()->homogeneous_add(ptr(), v.ptr()); return res; } template PointHd PointHd::operator-(const VectorHd &v) const { PointHd res(dimension()); res.ptr()->homogeneous_sub(ptr(), v.ptr()); return res; } template PointHd& PointHd::operator+= (const VectorHd& v) { int d = dimension(); PointHd old(*this); *this = PointHd(d); ptr()->homogeneous_add(old.ptr(), v.ptr()); return *this; } template PointHd& PointHd::operator-= (const VectorHd& v) { int d = dimension(); PointHd old(*this); *this = PointHd(d); ptr()->homogeneous_sub(old.ptr(), v.ptr()); return *this; } template std::istream& operator>>(std::istream& I, PointHd& p) { p.copy_on_write(); p.ptr()->read(I); CGAL_assertion_msg((p.homogeneous(p.dimension()) > 0), "operator>>: denominator of point must be larger than zero."); return I; } template std::ostream& operator<<(std::ostream& O, const PointHd& p) { p.ptr()->print(O,"PointHd"); return O; } template inline CGAL::io_Operator io_tag(const PointHd&) { return CGAL::io_Operator(); } #undef PointHd CGAL_END_NAMESPACE #endif // CGAL_POINTHD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointCd.C0000644000175000017500000000562411344301501030217 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointCd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_POINTCDXXX_C #define CGAL_POINTCDXXX_C CGAL_BEGIN_NAMESPACE #define PointCd PointCd2 template PointCd PointCd:: transform(const Aff_transformationCd& t) const { typename LA::Vector res = t(vector_rep()); return PointCd(dimension(),res.begin(),res.end()); } template VectorCd PointCd::operator-(const Origin&) const { return VectorCd(Base(*this)); } template PointCd PointCd::operator+(const VectorCd &v) const { PointCd res(dimension()); res.ptr()->cartesian_add(ptr(), v.ptr()); return res; } template PointCd PointCd::operator-(const VectorCd &v) const { PointCd res(dimension()); res.ptr()->cartesian_sub(ptr(), v.ptr()); return res; } template PointCd& PointCd::operator+= (const VectorCd& v) { int d = dimension(); PointCd old(*this); *this = PointCd(d); ptr()->cartesian_add(old.ptr(), v.ptr()); return *this; } template PointCd& PointCd::operator-= (const VectorCd& v) { int d = dimension(); PointCd old(*this); *this = PointCd(d); ptr()->cartesian_sub(old.ptr(), v.ptr()); return *this; } template std::istream& operator>>(std::istream& I, PointCd& p) { p.copy_on_write(); p.ptr()->read(I); return I; } template std::ostream& operator<<(std::ostream& O, const PointCd& p) { p.ptr()->print(O,"PointCd"); return O; } template inline CGAL::io_Operator io_tag(const PointCd&) { return CGAL::io_Operator(); } #undef PointCd CGAL_END_NAMESPACE #endif // CGAL_POINTCDXXX_C ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Kernel_classesCd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Kernel_classe0000644000175000017500000000304011344301501031236 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Kernel_classesCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_KERNEL_CLASSESCD_H #define CGAL_KERNEL_CLASSESCD_H CGAL_BEGIN_NAMESPACE template class PointCd2; template class VectorCd; template class DirectionCd; template class HyperplaneCd; template class Aff_transformationCd; CGAL_END_NAMESPACE #endif //CGAL_KERNEL_CLASSESCD_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Vector_d.h0000644000175000017500000000703411344301501030466 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Vector_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_VECTOR_D_H #define CGAL_VECTOR_D_H CGAL_BEGIN_NAMESPACE template class Vector_d : public pR::Vector_d_base { public: typedef typename pR::Vector_d_base Base; typedef Vector_d Self; typedef pR R; typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; typedef typename Base::Base_vector Base_vector; Vector_d(int d=0) : Base(d) {} Vector_d(int d, Null_vector v) : Base(d,v) {} Vector_d(int a, int b, int c = 1) : Base(a,b,c) {} Vector_d(const RT& a, const RT& b, const RT& c = 1) : Base(a,b,c) {} Vector_d(int a, int b, int c, int d) : Base(a,b,c,d) {} Vector_d(const RT& a, const RT& b, const RT& c, const RT& d) : Base(a,b,c,d) {} Vector_d(int d, Base_vector, int i) : Base(d,Base_vector(),i) {} template Vector_d (int d, InputIterator first, InputIterator last) : Base (d, first, last) {} template Vector_d (int d, InputIterator first, InputIterator last, const RT& D) : Base (d, first, last, D) {} Vector_d(const Self& v) : Base(v) {} Vector_d(const Base& v) : Base(v) {} Direction_d direction() const { return Base::direction(); } FT operator* (const Self& w) const { return Base::operator*(w); } Self operator+(const Self& w) const { return Base::operator+(w); } Self operator-(const Self& w) const { return Base::operator-(w); } Self operator-() const { return Base::operator-(); } template Self operator/(const NT& n) const { return Base::operator/(n); } Self& operator+=(const Self& w) { return static_cast(Base::operator+=(w)); } Self& operator-=(const Self& w) { return static_cast(Base::operator-=(w)); } template Self& operator*=(const NT& n) { return static_cast(Base::operator*=(n)); } template Self& operator/=(const NT& n) { return static_cast(Base::operator/=(n)); } bool operator==(const Self& w) const { return Base::operator==(w); } bool operator!=(const Self& w) const { return Base::operator!=(w); } }; template Point_d operator+ (const Origin& o, const Vector_d& v) { return Point_d( o + static_cast::Base>(v) ); } template Vector_d operator*(const NT& n, const Vector_d& v) { return Vector_d( n * static_cast::Base>(v) ); } CGAL_END_NAMESPACE #endif //CGAL_VECTOR_D_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_objectsCd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_0000644000175000017500000001106411344301501031336 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_objectsCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : ? #ifndef CGAL_INTERSECTION_OBJECTSCD_H #define CGAL_INTERSECTION_OBJECTSCD_H #include #undef _DEBUG #define _DEBUG 11 #include CGAL_BEGIN_NAMESPACE /*{\Manpage{Line_line_intersectionCd}{R}{intersecting two lines}}*/ template class Line_line_intersectionCd { typedef typename R::FT FT; typedef typename R::LA LA; typedef typename R::Point_d Point_d; typedef typename R::Line_d Line_d; public: enum Intersection_result { NO, POINT, LINE }; Intersection_result operator()( const Point_d& s1, const Point_d& t1, const Point_d& s2, const Point_d& t2, Point_d& p, FT& l1, FT& l2) /*{\Mfunop returns |NO| if the lines which are represented by |s1t1| and |s2t2| don't intersect, returns |POINT| if they intersect in a unique point, and returns LINE if they are identical. In the |POINT| case the point of intersection is assigned to |p|. Then |p = s1 + l1 * t1-s1| and |p = s2 + l2 * t2-s2|. \precond none of the point pairs is degenerate.}*/ { int d = s1.dimension(),i; CGAL_assertion_msg(d==s2.dimension(), "intersection: dimensions disagree!"); typename LA::Matrix M(d,2),S; typename LA::Vector b(d), lambda(2), c; FT D; /* init $d \times 2$ - matrix |M| and $d$ - vector |b| */ for (i = 0; i < d; i++) { M(i,0) = t1.cartesian(i) - s1.cartesian(i); M(i,1) = s2.cartesian(i) - t2.cartesian(i); b[i] = s2.cartesian(i) - s1.cartesian(i); } if (LA::linear_solver(M,b,lambda,D,S,c)) { if ( S.column_dimension()>0 ) return LINE; l1 = lambda[0]; l2 = lambda[1]; p = s1 + l1 * (t1 - s1); #ifdef CGAL_CHECK_EXACTNESS Line_d L1(s1,t1), L2(s2,t2); CGAL_assertion(L1.has_on(p)&&L2.has_on(p)); #endif return POINT; } return NO; } }; /*{\Manpage {Line_hyperplane_intersectionCd}{R} {intersecting a line and a hyperplane}}*/ template class Line_hyperplane_intersectionCd { typedef typename R::FT FT; typedef typename R::LA LA; typedef typename R::Point_d Point_d; typedef typename R::Hyperplane_d Hyperplane_d; public: enum Intersection_result { NO, POINT, LINE }; Intersection_result operator()(const Point_d& s, const Point_d& t, const Hyperplane_d& h, Point_d& p, FT& lambda) /*{\Mfunop returns |NO| if the line represented by |s1t1| and the hyperplane |h| don't intersect, returns |POINT| if they intersect in a unique point, and returns LINE if the line is part of the hyperplane. In the |POINT| case the point of intersection is assigned to |p|. Then |p = s1 + lambda * t1-s1|. \precond the point pair is not degenerate.}*/ { CGAL_assertion_msg((h.dimension()==s.dimension() && h.dimension()==t.dimension()), "Line_hyperplane_intersection_d: dimensions do not agree."); int d = h.dimension(),i; FT S = h.value_at(s), T = h.value_at(t); bool s_contained = CGAL_NTS is_zero(S), t_contained = CGAL_NTS is_zero(T); if (s_contained && t_contained) { p = s; return LINE; } if (s_contained) { p = s; return POINT; } if (t_contained) { p = t; return POINT; } // now the simple cases are done FT D = S - T; if ( CGAL_NTS is_zero(D) ) return NO; typename LA::Vector v(d); for (i = 0; i < d; ++i) v[i] = (S * t.cartesian(i) - T * s.cartesian(i))/D; p = Point_d(d,v.begin(),v.end()); lambda = S/D; #ifdef CGAL_CHECK_EXACTNESS Line_d l(s,t); CGAL_assertion(h.has_on(p)&&l.has_on(p)); #endif return POINT; } }; CGAL_END_NAMESPACE #include #endif //CGAL_INTERSECTION_OBJECTSCD_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transformationCd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transform0000644000175000017500000001530711344301501031264 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transformationCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_AFF_TRANSFORMATIONCD_H #define CGAL_AFF_TRANSFORMATIONCD_H #ifndef NOCGALINCL #include #include #include #include #endif CGAL_BEGIN_NAMESPACE template class Aff_transformationCd; template class Aff_transformationCd_rep; template class Aff_transformationCd_rep { friend class Aff_transformationCd; typedef typename LA::Matrix Matrix; Matrix M_; public: Aff_transformationCd_rep(int d) : M_(d+1) {} Aff_transformationCd_rep(const Matrix& M_init) : M_(M_init) {} ~Aff_transformationCd_rep() {} }; template class Aff_transformationCd : public Handle_for< Aff_transformationCd_rep<_FT,_LA> > { typedef Aff_transformationCd_rep<_FT,_LA> Rep; typedef Handle_for Base; typedef Aff_transformationCd<_FT,_LA> Self; using Base::ptr; public: typedef _FT RT; typedef _FT FT; typedef _LA LA; typedef typename _LA::Matrix Matrix; typedef typename _LA::Vector Vector; Aff_transformationCd(int d = 0) : Base( Rep(d) ) {} Aff_transformationCd(int d, Identity_transformation) : Base( Rep(d) ) { for (int i = 0; i <= d; ++i) ptr()->M_(i,i) = FT(1); } Aff_transformationCd(const Matrix& M) : Base( Rep(M) ) { CGAL_assertion_msg((M.row_dimension()==M.column_dimension()), "Aff_transformationCd:: initialization matrix not quadratic."); int d = M.row_dimension(),i; for (i=0; i Aff_transformationCd(Scaling, Forward_iterator start, Forward_iterator end) : Base( Rep(std::distance(start,end)-1) ) /*{\Mcreate introduces the transformation of $d$-space specified by a diagonal matrix with entries |set [start,end)| on the diagonal (a scaling of the space). \precond |set [start,end)| is a vector of dimension $d+1$.}*/ { int i=0; while (start != end) { ptr()->M_(i,i) = *start++;++i; } } Aff_transformationCd(Translation, const VectorCd& v) : Base( Rep(v.dimension()) ) { register int d = v.dimension(); for (int i = 0; i < d; ++i) { ptr()->M_(i,i) = FT(1); ptr()->M_(i,d) = v.cartesian(i); } ptr()->M_(d,d) = FT(1); } Aff_transformationCd(int d, Scaling, const RT& num, const RT& den) : Base( Rep(d) ) { Matrix& M = ptr()->M_; for (int i = 0; i < d; ++i) M(i,i) = num/den; M(d,d) = FT(1); } Aff_transformationCd(int d, Rotation, const RT& sin_num, const RT& cos_num, const RT& den, int e1 = 0, int e2 = 1) : Base( Rep(d) ) { CGAL_assertion_msg((sin_num*sin_num + cos_num*cos_num == den*den), "planar_rotation: rotation parameters disobey precondition."); CGAL_assertion_msg((0<=e1 && e1<=e2 && e2M_; for (int i=0; i& dir, const RT& eps_num, const RT& eps_den, int e1 = 0, int e2 = 1) : Base( Rep(d) ) { CGAL_assertion(dir.dimension()==2); Matrix& M = ptr()->M_; for (int i=0; iM_.row_dimension()-1; } const Matrix& matrix() const { return ptr()->M_; } bool is_odd() const { return LA::sign_of_determinant(matrix())<0; } Vector operator()(const Vector& v) const { CGAL_assertion(matrix().row_dimension()-1==v.dimension()); const Matrix& M = ptr()->M_; int i,j,d(v.dimension()); Vector res(d); for (i=0; iM_; int i,j,d(v.dimension()); Vector res(d); for (i=0; i inverse() const { Aff_transformationCd Inv; RT D; Vector dummy; if ( !LA::inverse(matrix(),Inv.ptr()->M_,D,dummy) ) CGAL_assertion_msg(0,"Aff_transformationCd::inverse: not invertible."); if ( D < FT(0) ) Inv.ptr()->M_ = -Inv.ptr()->M_; return Inv; } Aff_transformationCd operator*(const Aff_transformationCd& s) const { CGAL_assertion_msg((dimension()==s.dimension()), "Aff_transformationCd::operator*: dimensions disagree."); return Aff_transformationCd(matrix()*s.matrix()); } bool operator==(const Aff_transformationCd& a1) const { if ( identical(a1) ) return true; return ( matrix() == a1.matrix() ); } bool operator!=(const Aff_transformationCd& a1) const { return !operator==(a1); } }; // Aff_transformationCd template std::ostream& operator<<( std::ostream& os, const Aff_transformationCd& t) { os << t.matrix(); return os; } template std::istream& operator>>( std::istream& is, Aff_transformationCd& t) { typename LA::Matrix M(t.dimension()); is >> M; t = Aff_transformationCd(M); return is; } CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATIONCD_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_objectsHd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_obje0000644000175000017500000003366211344301501031325 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_objectsHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel //--------------------------------------------------------------------- // file generated by notangle from noweb/function_objectsHd.lw // please debug or modify noweb file // coding: K. Mehlhorn, M. Seel //--------------------------------------------------------------------- #ifndef CGAL_FUNCTION_OBJECTSHD_H #define CGAL_FUNCTION_OBJECTSHD_H #ifndef NOCGALINCL #include #include #endif CGAL_BEGIN_NAMESPACE template struct Lift_to_paraboloidHd { typedef typename R::Point_d Point_d; typedef typename R::RT RT; typedef typename R::LA LA; Point_d operator()(const Point_d& p) const { int d = p.dimension(); typename LA::Vector h(d+2); RT D = p.homogeneous(d); RT sum = 0; for (int i = 0; i struct Project_along_d_axisHd { typedef typename R::Point_d Point_d; typedef typename R::RT RT; typedef typename R::LA LA; Point_d operator()(const Point_d& p) const { int d = p.dimension(); return Point_d(d-1, p.homogeneous_begin(),p.homogeneous_end()-2, p.homogeneous(d)); } }; template struct MidpointHd { typedef typename R::Point_d Point_d; Point_d operator()(const Point_d& p, const Point_d& q) const { return Point_d(p + (q-p)/2); } }; template struct Center_of_sphereHd { typedef typename R::Point_d Point_d; typedef typename R::RT RT; typedef typename R::LA LA; template Point_d operator()(Forward_iterator start, Forward_iterator end) const { CGAL_assertion(start!=end); int d = start->dimension(); typename LA::Matrix M(d); typename LA::Vector b(d); Point_d pd = *start++; RT pdd = pd.homogeneous(d); for (int i = 0; i < d; i++) { // we set up the equation for p_i Point_d pi = *start++; RT pid = pi.homogeneous(d); b[i] = 0; for (int j = 0; j < d; j++) { M(i,j) = RT(2) * pdd * pid * (pi.homogeneous(j)*pdd - pd.homogeneous(j)*pid); b[i] += (pi.homogeneous(j)*pdd - pd.homogeneous(j)*pid) * (pi.homogeneous(j)*pdd + pd.homogeneous(j)*pid); } } RT D; typename LA::Vector x; LA::linear_solver(M,b,x,D); return Point_d(d,x.begin(),x.end(),D); } }; // Center_of_sphereHd template struct Squared_distanceHd { typedef typename R::Point_d Point_d; typedef typename R::Vector_d Vector_d; typedef typename R::FT FT; FT operator()(const Point_d& p, const Point_d& q) const { Vector_d v = p-q; return v.squared_length(); } }; template struct Position_on_lineHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::FT FT; typedef typename R::RT RT; bool operator()(const Point_d& p, const Point_d& s, const Point_d& t, FT& l) const { int d = p.dimension(); CGAL_assertion_msg((d==s.dimension())&&(d==t.dimension()&& d>0), "position_along_line: argument dimensions disagree."); CGAL_assertion_msg((s!=t), "Position_on_line_d: line defining points are equal."); RT lnum = (p.homogeneous(0)*s.homogeneous(d) - s.homogeneous(0)*p.homogeneous(d)) * t.homogeneous(d); RT lden = (t.homogeneous(0)*s.homogeneous(d) - s.homogeneous(0)*t.homogeneous(d)) * p.homogeneous(d); RT num(lnum), den(lden), lnum_i, lden_i; for (int i = 1; i < d; i++) { lnum_i = (p.homogeneous(i)*s.homogeneous(d) - s.homogeneous(i)*p.homogeneous(d)) * t.homogeneous(d); lden_i = (t.homogeneous(i)*s.homogeneous(d) - s.homogeneous(i)*t.homogeneous(d)) * p.homogeneous(d); if (lnum*lden_i != lnum_i*lden) return false; if (lden_i != 0) { den = lden_i; num = lnum_i; } } l = R::make_FT(num,den); return true; } }; template struct Barycentric_coordinatesHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::RT RT; template OutputIterator operator()(ForwardIterator first, ForwardIterator last, const Point_d& p, OutputIterator result) { TUPLE_DIM_CHECK(first,last,Barycentric_coordinates_d); int n = std::distance(first,last); int d = p.dimension(); typename R::Affine_rank_d affine_rank; CGAL_assertion(affine_rank(first,last)==d); typename LA::Matrix M(first,last); typename LA::Vector b(p.homogeneous_begin(),p.homogeneous_end()), x; RT D; LA::linear_solver(M,b,x,D); for (int i=0; i< x.dimension(); ++result, ++i) { *result= R::make_FT(x[i],D); } return result; } }; template struct OrientationHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; template Orientation operator()(ForwardIterator first, ForwardIterator last) { TUPLE_DIM_CHECK(first,last,Orientation_d); int d = std::distance(first,last); // range contains d points of dimension d-1 CGAL_assertion_msg(first->dimension() == d-1, "Orientation_d: needs first->dimension() + 1 many points."); typename LA::Matrix M(d); // quadratic for (int i = 0; i < d; ++first,++i) { for (int j = 0; j < d; ++j) M(i,j) = first->homogeneous(j); } int row_correction = ( (d % 2 == 0) ? -1 : +1 ); // we invert the sign if the row number is even i.e. d is odd return Orientation(row_correction * LA::sign_of_determinant(M)); } }; template struct Side_of_oriented_sphereHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::RT RT; template Oriented_side operator()(ForwardIterator first, ForwardIterator last, const Point_d& x) { TUPLE_DIM_CHECK(first,last,Side_of_oriented_sphere_d); int d = std::distance(first,last); // |A| contains |d| points CGAL_assertion_msg((d-1 == first->dimension()), "Side_of_oriented_sphere_d: needs first->dimension()+1 many input points."); typename LA::Matrix M(d + 1); for (int i = 0; i < d; ++first, ++i) { RT Sum = 0; RT hd = first->homogeneous(d-1); M(i,0) = hd*hd; for (int j = 0; j < d; j++) { RT hj = first->homogeneous(j); M(i,j + 1) = hj * hd; Sum += hj*hj; } M(i,d) = Sum; } RT Sum = 0; RT hd = x.homogeneous(d-1); M(d,0) = hd*hd; for (int j = 0; j < d; j++) { RT hj = x.homogeneous(j); M(d,j + 1) = hj * hd; Sum += hj*hj; } M(d,d) = Sum; return Oriented_side( - LA::sign_of_determinant(M) ); } }; template struct Side_of_bounded_sphereHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::RT RT; template Bounded_side operator()(ForwardIterator first, ForwardIterator last, const Point_d& p) { TUPLE_DIM_CHECK(first,last,region_of_sphere); typename R::Orientation_d _orientation; Orientation o = _orientation(first,last); CGAL_assertion_msg((o != 0), "Side_of_bounded_sphere_d: \ A must be full dimensional."); typename R::Side_of_oriented_sphere_d _side_of_oriented_sphere; Oriented_side oside = _side_of_oriented_sphere(first,last,p); if (o == POSITIVE) { switch (oside) { case ON_POSITIVE_SIDE : return ON_BOUNDED_SIDE; case ON_ORIENTED_BOUNDARY: return ON_BOUNDARY; case ON_NEGATIVE_SIDE : return ON_UNBOUNDED_SIDE; } } else { switch (oside) { case ON_POSITIVE_SIDE : return ON_UNBOUNDED_SIDE; case ON_ORIENTED_BOUNDARY: return ON_BOUNDARY; case ON_NEGATIVE_SIDE : return ON_BOUNDED_SIDE; } } return ON_BOUNDARY; // never reached } }; template struct Contained_in_simplexHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::RT RT; template bool operator()(ForwardIterator first, ForwardIterator last, const Point_d& p) { TUPLE_DIM_CHECK(first,last,Contained_in_simplex_d); int k = std::distance(first,last); // |A| contains |k| points int d = first->dimension(); CGAL_assertion_code( typename R::Affinely_independent_d check_independence; ) CGAL_assertion_msg(check_independence(first,last), "Contained_in_simplex_d: A not affinely independent."); CGAL_assertion(d==p.dimension()); typename LA::Matrix M(d + 1,k); typename LA::Vector b(p.homogeneous_begin(),p.homogeneous_end()); for (int j = 0; j < k; ++first, ++j) { for (int i = 0; i <= d; ++i) M(i,j) = first->homogeneous(i); } RT D; typename LA::Vector lambda; if ( LA::linear_solver(M,b,lambda,D) ) { int s = CGAL_NTS sign(D); for (int j = 0; j < k; j++) { int t = CGAL_NTS sign(lambda[j]); if (s * t < 0) return false; } return true; } return false; } }; template struct Contained_in_affine_hullHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::RT RT; template bool operator()(ForwardIterator first, ForwardIterator last, const Point_d& p) { TUPLE_DIM_CHECK(first,last,Contained_in_affine_hull_d); int k = std::distance(first,last); // |A| contains |k| points int d = first->dimension(); typename LA::Matrix M(d + 1,k); typename LA::Vector b(p.homogeneous_begin(),p.homogeneous_end()); for (int j = 0; j < k; ++first, ++j) for (int i = 0; i <= d; ++i) M(i,j) = first->homogeneous(i); return LA::is_solvable(M,b); } }; template struct Affine_rankHd { typedef typename R::Point_d Point_d; typedef typename R::Vector_d Vector_d; typedef typename R::LA LA; typedef typename R::RT RT; template int operator()(ForwardIterator first, ForwardIterator last) { TUPLE_DIM_CHECK(first,last,Affine_rank_d); int k = std::distance(first,last); // |A| contains |k| points if (k == 0) return -1; if (k == 1) return 0; int d = first->dimension(); typename LA::Matrix M(d,--k); Point_d p0 = *first; ++first; // first points to second for (int j = 0; j < k; ++first, ++j) { Vector_d v = *first - p0; for (int i = 0; i < d; i++) M(i,j) = v.homogeneous(i); } return LA::rank(M); } }; template struct Affinely_independentHd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::RT RT; template bool operator()(ForwardIterator first, ForwardIterator last) { typename R::Affine_rank_d rank; int n = std::distance(first,last); return rank(first,last) == n-1; } }; template struct Compare_lexicographicallyHd { typedef typename R::Point_d Point_d; typedef typename R::Point_d PointD; //MSVC hack Comparison_result operator()(const Point_d& p1, const Point_d& p2) { return PointD::cmp(p1,p2); } }; template struct Contained_in_linear_hullHd { typedef typename R::LA LA; typedef typename R::RT RT; typedef typename R::Vector_d Vector_d; template bool operator()( ForwardIterator first, ForwardIterator last, const Vector_d& x) { TUPLE_DIM_CHECK(first,last,Contained_in_linear_hull_d); int k = std::distance(first,last); // |A| contains |k| vectors int d = first->dimension(); typename LA::Matrix M(d,k); typename LA::Vector b(d); for (int i = 0; i < d; i++) { b[i] = x.homogeneous(i); for (int j = 0; j < k; j++) M(i,j) = (first+j)->homogeneous(i); } return LA::is_solvable(M,b); } }; template struct Linear_rankHd { typedef typename R::LA LA; typedef typename R::RT RT; template int operator()(ForwardIterator first, ForwardIterator last) { TUPLE_DIM_CHECK(first,last,linear_rank); int k = std::distance(first,last); // k vectors int d = first->dimension(); typename LA::Matrix M(d,k); for (int i = 0; i < d ; i++) for (int j = 0; j < k; j++) M(i,j) = (first + j)->homogeneous(i); return LA::rank(M); } }; template struct Linearly_independentHd { typedef typename R::LA LA; typedef typename R::RT RT; template bool operator()(ForwardIterator first, ForwardIterator last) { typename R::Linear_rank_d rank; return rank(first,last) == std::distance(first,last); } }; template struct Linear_baseHd { typedef typename R::LA LA; typedef typename R::RT RT; typedef typename R::Vector_d Vector_d; template OutputIterator operator()(ForwardIterator first, ForwardIterator last, OutputIterator result) { TUPLE_DIM_CHECK(first,last,linear_base); int k = std::distance(first,last); // k vectors int d = first->dimension(); typename LA::Matrix M(d,k); for (int j = 0; j < k; j++) for (int i = 0; i < d; i++) M(i,j) = (first+j)->homogeneous(i); std::vector indcols; int r = LA::independent_columns(M,indcols); for (int l=0; l < r; l++) { typename LA::Vector v = M.column(indcols[l]); *result++ = Vector_d(d,v.begin(),v.end(),1); } return result; } }; CGAL_END_NAMESPACE #endif // CGAL_FUNCTION_OBJECTSHD_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Tuple_d.h0000644000175000017500000002473411344301501030323 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Tuple_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_TUPLE_D_H #define CGAL_TUPLE_D_H #ifndef NOCGALINCL #include #include #include #include #endif CGAL_BEGIN_NAMESPACE #define PointCd PointCd2 #define PointHd PointHd2 template class PointHd; template class VectorHd; template class DirectionHd; template class HyperplaneHd; template class Aff_transformationHd; template class PointCd; template class VectorCd; template class DirectionCd; template class HyperplaneCd; template class Aff_transformationCd; class MatchHelper {}; template class Tuple_d { typedef Tuple_d Self; typedef typename LA::Vector Vector; Vector v; public: typedef typename Vector::const_iterator const_iterator; struct Cartesian_const_iterator { typedef Cartesian_const_iterator self; typedef std::random_access_iterator_tag iterator_category; typedef CGAL::Quotient value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; Cartesian_const_iterator() : _it(0), _w(0) {} Cartesian_const_iterator(const_iterator it, const_iterator w = 0) : _it(it), _w(w) {} value_type operator*() const { return value_type(*_it,*_w); } self& operator++() { ++_it; return *this; } self operator++(int) { self tmp = *this; ++_it; return tmp; } self& operator--() { --_it; return *this; } self operator--(int) { self tmp = *this; --_it; return tmp; } self& operator+=(difference_type i) { _it+=i; return *this; } self& operator-=(difference_type i) { _it-=i; return *this; } self operator+(difference_type i) const { self tmp=*this; return tmp += i; } self operator-(difference_type i) const { self tmp=*this; return tmp -= i; } difference_type operator-(self x) const { return _it-x._it; } reference operator[](difference_type i) { return *(*this + i); } bool operator==(const self& x) const { return _it==x._it; } bool operator!=(const self& x) const { return ! (*this==x); } bool operator<(const self& x) const { return (x - *this) > 0; } private: const_iterator _it, _w; }; // Cartesian_const_iterator struct Homogeneous_const_iterator { typedef Homogeneous_const_iterator self; typedef std::random_access_iterator_tag iterator_category; typedef NT value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; Homogeneous_const_iterator() : _it(0), _w(0) {} Homogeneous_const_iterator(const_iterator it, const_iterator w = 0) : _it(it), _w(w) {} value_type operator*() const { if (_it == _w) return value_type(1); else return *_it; } self& operator++() { ++_it; return *this; } self operator++(int) { self tmp = *this; ++_it; return tmp; } self& operator--() { --_it; return *this; } self operator--(int) { self tmp = *this; --_it; return tmp; } self& operator+=(difference_type i) { _it+=i; return *this; } self& operator-=(difference_type i) { _it-=i; return *this; } self operator+(difference_type i) const { self tmp=*this; return tmp += i; } self operator-(difference_type i) const { self tmp=*this; return tmp -= i; } difference_type operator-(self x) const { return _it-x._it; } reference operator[](difference_type i) { return *(*this + i); } bool operator==(const self& x) const { return _it==x._it; } bool operator!=(const self& x) const { return ! (*this==x); } bool operator<(self x) const { return (x - *this) > 0; } private: const_iterator _it, _w; }; // Homogeneous_const_iterator Tuple_d(int d) : v(d) {} Tuple_d(const NT& a, const NT& b) : v(2) { v[0]=a; v[1]=b; } Tuple_d(const NT& a, const NT& b, const NT& c, const MatchHelper&) : v(3) { v[0]=a; v[1]=b; v[2]=c; } Tuple_d(const NT& a, const NT& b, const NT& c, const NT& d) : v(4) { v[0]=a; v[1]=b; v[2]=c; v[3]=d; } template Tuple_d(int d, I& start, I end) : v(d) { int i(0); while ( i < d && start != end ) v[i++] = *start++; } /* this constructor returns the final position of start to offer access to a possible common denominator as part of the tuple range */ template Tuple_d(int d, I start, I end, NT D) : v(d) { int i(0); while ( i < d && start != end ) v[i++] = *start++; v[d-1] = D; } int size() const { return v.dimension(); } const_iterator begin() const { return v.begin(); } const_iterator last() const { return v.end()-1; } const_iterator end() const { return v.end(); } const_iterator beyondend() const { return v.end()+1; } void invert() { for (int i=0; isize()-1; if ( d < 0 ) return; CGAL_assertion_msg((d == b->size()-1),"dimensions disagree."); CGAL_assertion_msg((d == size()-1),"dimensions disagree."); NT aw = a->v[d], bw = b->v[d]; for (int i = 0; i < d; ++i) { v[i] = a->v[i]*bw + b->v[i]*aw; } v[d] = aw*bw; } void homogeneous_sub(const Self* a, const Self* b) { register int d = a->size()-1; if ( d < 0 ) return; CGAL_assertion_msg((d == b->size()-1),"dimensions disagree."); CGAL_assertion_msg((d == size()-1),"dimensions disagree."); NT aw = a->v[d], bw = b->v[d]; for (int i = 0; i < d; ++i) { v[i] = a->v[i]*bw - b->v[i]*aw; } v[d] = aw*bw; } void cartesian_add(const Self* a, const Self* b) { v = a->v + b->v; } void cartesian_sub(const Self* a, const Self* b) { v = a->v - b->v; } friend class PointHd; friend class VectorHd; friend class DirectionHd; friend class HyperplaneHd; friend class PointCd; friend class VectorCd; friend class DirectionCd; friend class HyperplaneCd; }; // Tuple_d template class Compare_homogeneously { public: Comparison_result operator()( const typename LA::Vector& v1, const typename LA::Vector& v2) { CGAL_assertion_msg((v1.dimension() == v2.dimension()), "Compare_homogeneously: dimensions disagree."); NT aw = v1[v1.dimension()-1]; NT bw = v2[v2.dimension()-1]; CGAL_assertion(aw>0 && bw>0); for (int i = 0; i < v1.dimension()-1; i++ ) { NT aibw = v1[i]*bw; NT biaw = v2[i]*aw; Comparison_result S = (aibw class Compare_componentwise { public: Comparison_result operator()( const typename LA::Vector& v1, const typename LA::Vector& v2) { CGAL_assertion_msg((v1.dimension() == v2.dimension()), "Compare_coefficientwise: dimensions disagree."); for (int i = 0; i < v1.dimension(); i++ ) { Comparison_result S = (v1[i] void Tuple_d::print(std::ostream& os, const char* l) const { int i; switch( os.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : os << size() << " "; for (i = 0; i < size(); ++i) os << v[i] << " "; break; case CGAL::IO::BINARY : CGAL::write(os, size()); for (i = 0; i < size(); ++i) CGAL::write(os, v[i]); break; default : os << l << "(" << size() << ", "; for (i = 0; i < size(); ++i) { os << v[i]; if (i!=size()-1) os<<", "; else os<<")"; } } } template void Tuple_d::read(std::istream& is) { int i = 0, d; switch( is.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : is >> d; v = Vector(d); while (i < d && is >> v[i] ) ++i; break; case CGAL::IO::BINARY : CGAL::read(is, d); v = Vector(d); while (i < d) { CGAL::read(is, v[i]); ++i; } break; default: CGAL_assertion_msg(0,"\nStream must be in ascii or binary mode\n"); } } template void tuple_dim_check(ForwardIterator first, ForwardIterator last, const char* file, int line, const char* op) { if (first==last) return; int d = first->dimension(); ++first; for (; first!=last; ++first) if (first->dimension() != d) { std::ostringstream os; os << "Tuple Dimension Error " << "File " << file << "Line " << line << "Operation " << op << '\0'; CGAL_assertion_msg(0,os.str().c_str()); } } #define TUPLE_DIM_CHECK(i1,i2,op) tuple_dim_check(i1,i2,__FILE__,__LINE__,#op) template int copy_and_count(InputIterator first, InputIterator last, OutputIterator result) { int n=0; while (first != last) { ++n; *result++ = *first++; } return n; } #undef PointCd #undef PointHd CGAL_END_NAMESPACE #endif //CGAL_TUPLE_D_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Kernel_classesHd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Kernel_classe0000644000175000017500000000304011344301501031236 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Kernel_classesHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_KERNEL_CLASSESHD_H #define CGAL_KERNEL_CLASSESHD_H CGAL_BEGIN_NAMESPACE template class PointHd2; template class VectorHd; template class DirectionHd; template class HyperplaneHd; template class Aff_transformationHd; CGAL_END_NAMESPACE #endif //CGAL_KERNEL_CLASSESHD_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Linear_algebraHd.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Linear_algebr0000644000175000017500000007326111344301501031226 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Linear_algebraHd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel //--------------------------------------------------------------------- // file generated by notangle from Linear_algebra.lw // please debug or modify noweb file // based on LEDA architecture by S. Naeher, C. Uhrig // coding: K. Mehlhorn, M. Seel // debugging and templatization: M. Seel //--------------------------------------------------------------------- #ifndef CGAL_LINEAR_ALGEBRAHD_C #define CGAL_LINEAR_ALGEBRAHD_C CGAL_BEGIN_NAMESPACE template bool Linear_algebraHd:: linear_solver(const Matrix& A, const Vector& b, Vector& x, RT& D, Matrix& spanning_vectors, Vector& c) { bool solvable = true; int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j= 0; i--) { RT_ h = C(i,cols) * D; for (j = i + 1; j < rank; j++) { h -= C(i,j)*x[var[j]]; } x[var[i]]= h / C(i,i); } #ifdef CGAL_LA_SELFTEST CGAL_assertion( (M*x).is_zero() ); #endif int defect = cols - rank; // dimension of kernel spanning_vectors = Matrix(cols,defect); if (defect > 0) { for(int l=0; l < defect; l++) { spanning_vectors(var[rank + l],l)=D; for(i = rank - 1; i >= 0 ; i--) { RT_ h = - C(i,rank + l)*D; for ( j= i + 1; j RT_ Linear_algebraHd:: determinant(const Matrix& A) { if (A.row_dimension() != A.column_dimension()) CGAL_assertion_msg(0, "determinant(): only square matrices are legal inputs."); Vector b(A.row_dimension()); // zero - vector int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j RT_ Linear_algebraHd:: determinant(const Matrix& A, Matrix& Ld, Matrix& Ud, std::vector& q, Vector& c) { if (A.row_dimension() != A.column_dimension()) CGAL_assertion_msg(0, "determinant(): only square matrices are legal inputs."); Vector b(A.row_dimension()); // zero - vector int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j int Linear_algebraHd:: sign_of_determinant(const Matrix& M) { return CGAL_NTS sign(determinant(M)); } template bool Linear_algebraHd:: verify_determinant(const Matrix& A, RT_ D, Matrix& L, Matrix& U, const std::vector& q, Vector& c) { if ((int)q.size() != A.column_dimension()) CGAL_assertion_msg(0, "verify_determinant: q should be a permutation array \ with index range [0,A.column_dimension() - 1]."); int n = A.row_dimension(); int i,j; if (D == 0) { /* we have $c^T \cdot A = 0$ */ Vector zero(n); return (transpose(A) * c == zero); } else { /* we check the conditions on |L| and |U| */ if (L(0,0) != 1) return false; for (i = 0; i 0 && L(i,i) != U(i - 1,i - 1)) return false; for (j = i + 1; j < n; j++) if (L(i,j) != 0) return false; } /* check whether $L \cdot A \cdot Q = U$ */ Matrix LA = L * A; for (j = 0; j < n; j++) if (LA.column(q[j]) != U.column(j)) return false; /* compute sign |s| of |Q| */ int sign = 1; /* we chase the cycles of |q|. An even length cycle contributes - 1 and vice versa */ std::vector already_considered(n); for (i = 0; i < n; i++) already_considered[i] = false; for (i = 0; i < n; i++) already_considered[q[i]] = true; for (i = 0; i < n; i++) if (! already_considered[i]) CGAL_assertion_msg(0,"verify_determinant:q is not a permutation."); else already_considered[i] = false; for (i = 0; i < n; i++) { if (already_considered[i]) continue; /* we have found a new cycle with minimal element $i$. */ int k = q[i]; already_considered[i] =true; while (k != i) { sign = - sign; already_considered[k]= true; k = q[k]; } } return (D == RT(sign) * U(n - 1,n - 1)); } } template int Linear_algebraHd:: independent_columns(const Matrix& A, std::vector& columns) { Vector b(A.row_dimension()); // zero - vector int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j(rank); for(i = 0; i < rank; i++) columns[i] = var[i]; return rank; } template int Linear_algebraHd:: rank(const Matrix& A) { Vector b(A.row_dimension()); // zero - vector int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j bool Linear_algebraHd:: inverse(const Matrix& A, Matrix& inverse, RT_& D, Vector& c) { if (A.row_dimension() != A.column_dimension()) CGAL_assertion_msg(0,"inverse: only square matrices are legal inputs."); Vector b(A.row_dimension()); // zero - vector int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j= 0; j--) { h = L (j,i) * D; for (int l = j + 1; l int Linear_algebraHd:: homogeneous_linear_solver(const Matrix &A, Matrix& spanning_vectors) /* returns the dimension of the solution space of the homogeneous system $Ax = 0$. The columns of spanning\_vectors span the solution space. */ { Vector b(A.row_dimension()); // zero - vector RT_ D; int i,j,k; // indices to step through the matrix int rows = A.row_dimension(); int cols = A.column_dimension(); /* at this point one might want to check whether the computation can be carried out with doubles, see section \ref{ optimization }. */ CGAL_assertion_msg(b.dimension() == rows, "linear_solver: b has wrong dimension"); Matrix C(rows,cols + 1); // the matrix in which we will calculate ($C = (A \vert b)$) /* copy |A| and |b| into |C| and L becomes the identity matrix */ Matrix L(rows); // zero initialized for(i=0; i var(cols); // column $j$ of |C| represents the |var[j]| - th variable // the array is indexed between |0| and |cols - 1| for(j=0; j= 0; i--) { RT_ h = C(i,cols) * D; for (j = i + 1; j < rank; j++) { h -= C(i,j)*x[var[j]]; } x[var[i]]= h / C(i,i); } #ifdef CGAL_LA_SELFTEST CGAL_assertion( (M*x).is_zero() ); #endif int defect = cols - rank; // dimension of kernel spanning_vectors = Matrix(cols,defect); if (defect > 0) { for(int l=0; l < defect; l++) { spanning_vectors(var[rank + l],l)=D; for(i = rank - 1; i >= 0 ; i--) { RT_ h = - C(i,rank + l)*D; for ( j= i + 1; j bool Linear_algebraHd:: homogeneous_linear_solver(const Matrix& A, Vector& x) /* returns true if the homogeneous system $Ax = 0$ has a non - trivial solution and false otherwise. */ { x = Vector(A.row_dimension()); Matrix spanning_vectors; int dimension = homogeneous_linear_solver(A,spanning_vectors); if (dimension == 0) return false; /* return first column of |spanning_vectors| */ for (int i = 0; i < spanning_vectors.row_dimension(); i++) x[i] = spanning_vectors(i,0); return true; } template typename Linear_algebraHd::Matrix Linear_algebraHd::transpose(const Matrix& M) { int d1 = M.row_dimension(); int d2 = M.column_dimension(); Matrix result(d2,d1); for(int i = 0; i < d2; i++) for(int j = 0; j < d1; j++) result(i,j) = M(j,i); return result; } CGAL_END_NAMESPACE #endif //CGAL_LINEAR_ALGEBRAHD_C ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Linear_algebraCd.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Linear_algebr0000644000175000017500000003203411344301501031217 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Linear_algebraCd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve.Bronnimann@sophia.inria.fr // Michael.Seel@mpi-sb.mpg.de #ifndef CGAL_LINEAR_ALGEBRACD_C #define CGAL_LINEAR_ALGEBRACD_C #include #include CGAL_BEGIN_NAMESPACE template < class FT, class AL > typename Linear_algebraCd::Matrix Linear_algebraCd:: transpose(const Matrix &M) { Matrix P(transpose(M.dimension())); int i, j; for (i=0; i inline // in order to facilitate the optimization with unused variables void Linear_algebraCd:: Gaussian_elimination(const Matrix &M, // return parameters Matrix &L, Matrix &U, std::vector &row_permutation, std::vector &column_permutation, FT &det, int &rank, Vector &c) { // Method: we use Gaussian elimination with division at each step // We do not use the variant by Bareiss (because we are on a field) // We obtain L, U, q, such that LM' = U, and U is upper diagonal, // where M' is M whose rows and columns are permuted // Picked up on the way: // det, rank, non-trivial solution c if system is degenerate (c^t M = 0) int i, j, k; int dim = M.row_dimension(), cdim = M.column_dimension(); // All the parameters are already initialized (as in C++) int sign = 1; // First create a copy of M into U, and set L and permutations to identity U = M; typename Matrix::Identity IDENTITY; L = Matrix(dim,IDENTITY); for (i=0; i bool Linear_algebraCd:: Triangular_system_solver(const Matrix &U, const Matrix& L, const Vector &b, int rank, Vector &x, FT &D) { // METHOD: solve system Ux=b, returning solution (x/D) // back substitution of x[rdim], x[rdim-1], etc. // depends on "free" variables x[rdim+1], etc. x[cdim] CGAL_kernel_assertion( U.row_dimension() == b.dimension()); TRACEN("Triangular_system_solver");TRACEV(U);TRACEV(b); D = FT(1); int i; for (i = rank; i < U.row_dimension(); ++i) if ( b[i] != FT(0) ) { x = L.row(i); return false; } x = Vector(U.column_dimension()); for (i = rank-1; i>=0; --i) { x[i] = b[i]; for (int j = i+1; j inline // in order to facilitate the optimization with unused variables void Linear_algebraCd:: Triangular_left_inverse(const Matrix &U, Matrix &Uinv) { int i, j, k; CGAL_kernel_precondition(U.dimension() == transpose(Uinv.dimension())); TRACEN("system : " << U); for (i=U.row_dimension()-1; i>=0; --i) { Uinv[i][i] = FT(1)/U[i][i]; for (j=i+1; j bool Linear_algebraCd:: inverse(const Matrix &M, Matrix &I, FT &D, Vector &c) { CGAL_kernel_precondition(M.row_dimension()==M.column_dimension()); int rank; Matrix L,U; std::vector rq, cq; Gaussian_elimination(M, L, U, rq, cq, D, rank, c); if (D == FT(0)) return false; // c holds the witness // Otherwise, compute the inverse of U Matrix Uinv(M.column_dimension(),M.row_dimension()); Triangular_left_inverse(U,Uinv); Uinv = Uinv * L; // Don't forget to permute the rows of M back TRACEN("inverse before permutation : "< inline typename Linear_algebraCd::Matrix Linear_algebraCd:: inverse(const Matrix &M, FT &D) { CGAL_kernel_precondition(M.row_dimension()==M.column_dimension()); Matrix I; Vector c; CGAL_kernel_assertion_code( bool result = ) inverse(M,I,D,c); CGAL_kernel_assertion( result ); return I; } template < class FT, class AL > typename Linear_algebraCd::FT Linear_algebraCd:: determinant(const Matrix &M, Matrix &L, Matrix &U, std::vector &q, Vector &c) { FT det; int rank; std::vector cq; Gaussian_elimination(M, L, U, q, cq, det, rank, c); return det; } template < class FT, class AL > inline typename Linear_algebraCd::FT Linear_algebraCd:: determinant(const Matrix &M) { Matrix L,U; Vector c; std::vector q; return determinant(M,L,U,q,c); } template < class FT, class AL > inline Sign Linear_algebraCd:: sign_of_determinant(const Matrix &M) { return CGAL_NTS sign(determinant(M)); } template < class FT, class AL > bool Linear_algebraCd:: verify_determinant(const Matrix & /*M*/, const FT & /*D*/, const Matrix & /*L*/, const Matrix & /*U*/, const std::vector & /*q*/, const Vector & /*c*/) { // TODO: verify_determinant return true; } template < class FT, class AL > bool Linear_algebraCd:: linear_solver(const Matrix &M, const Vector &b, Vector &x, FT &D, Vector &c) { CGAL_kernel_precondition( b.dimension() == M.row_dimension() ); Matrix L,U; int rank; std::vector dummy, var; TRACEN("linear_solver");TRACEV(M); TRACEV(b); Gaussian_elimination(M, L, U, dummy, var, D, rank, c); // Compute a solution by solving triangular system // Since LM=U, and x is a solution of Mx=b, then Ux=Lb // Temporary store the solution in c if ( !Triangular_system_solver(U, L, L*b, rank, c, D) ) return false; // Don't forget to permute the rows of M back x = Vector(M.column_dimension()); for (int i=0; i bool Linear_algebraCd:: linear_solver(const Matrix &M, const Vector &b, Vector &x, FT &D, Matrix &spanning_vectors, Vector &c) { CGAL_kernel_precondition( b.dimension() == M.row_dimension() ); Matrix L,U; int rank; std::vector dummy, var; TRACEN("linear_solver");TRACEV(M); TRACEV(b); Gaussian_elimination(M, L, U, dummy, var, D, rank, c); // Compute a solution by solving triangular system // Since LM=U, and x is a solution of Mx=b, then Ux=Lb // Temporary store the solution in c if ( !Triangular_system_solver(U, L, L*b, rank, c, D) ) return false; // Don't forget to permute the rows of M back: x = Vector(M.column_dimension()); for (int i=0; i 0) { for(int l=0; l < defect; ++l) { spanning_vectors(var[rank + l],l)=FT(1); for(int i = rank - 1; i >= 0 ; i--) { FT h = - U(i,rank+l); for (int j= i + 1; j bool Linear_algebraCd:: linear_solver(const Matrix &M, const Vector &b, Vector &x, FT &D) { Vector c; return linear_solver(M, b, x, D, c); } template < class FT, class AL > bool Linear_algebraCd:: is_solvable(const Matrix &M, const Vector &b) { Vector x; FT D; return linear_solver(M, b, x, D); } template < class FT, class AL > int Linear_algebraCd:: homogeneous_linear_solver(const Matrix &M, Matrix &spanning_vectors) { Matrix L,U; Vector c, b(M.row_dimension()); std::vector dummy,var; FT D; int rank,i; Gaussian_elimination(M, L, U, dummy, var, D, rank, c); #ifdef CGAL_LA_SELFTEST Vector x; Triangular_system_solver(U, L, b, rank, c, D); TRACEV(M);TRACEV(U);TRACEV(b);TRACEV(rank);TRACEV(c);TRACEV(D); x = Vector(M.column_dimension()); for (i=0; i 0) { /* In the $l$-th spanning vector, $0 \le l < |defect|$ we set variable |var[rank + l]| to $1 = |denom|/|denom|$ and then the dependent variables as dictated by the $|rank| + l$ - th column of |C|.*/ for(int l=0; l < defect; ++l) { spanning_vectors(var[rank + l],l)=FT(1); for(i = rank - 1; i >= 0 ; i--) { FT h = - U(i,rank+l); for (int j= i + 1; j bool Linear_algebraCd:: homogeneous_linear_solver(const Matrix &M, Vector &x) { x = Vector(M.row_dimension()); Matrix spanning_vectors; int defect = homogeneous_linear_solver(M,spanning_vectors); if (defect == 0) return false; /* return first column of |spanning_vectors| */ for (int i = 0; i < spanning_vectors.row_dimension(); i++) x[i] = spanning_vectors(i,0); return true; } template < class FT, class AL > int Linear_algebraCd:: independent_columns(const Matrix &M, std::vector &q) { int rank; std::vector dummy; Matrix Dummy1,Dummy2; Vector Dummy3; FT null(0); Gaussian_elimination(M, Dummy1, Dummy2, dummy, q, null, rank, Dummy3); return rank; } template < class FT, class AL > int Linear_algebraCd:: rank(const Matrix &M) { std::vector q; return independent_columns(M,q); } CGAL_END_NAMESPACE #endif // CGAL_LINEAR_ALGEBRACD_C ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transformation_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transform0000644000175000017500000000555111344301501031264 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transformation_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_AFF_TRANSFORMATION_D_H #define CGAL_AFF_TRANSFORMATION_D_H CGAL_BEGIN_NAMESPACE template class Aff_transformation_d : public pR::Aff_transformation_d_base { public: typedef typename pR::Aff_transformation_d_base Base; typedef Aff_transformation_d Self; typedef pR R; typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; Aff_transformation_d(int d = 0) : Base(d) {} Aff_transformation_d(int d, Identity_transformation tag) : Base(d,tag) {} Aff_transformation_d(const typename LA::Matrix& M) : Base(M) {} Aff_transformation_d(Translation tag, const Vector_d& v) : Base(tag,v) {} Aff_transformation_d(int d, Scaling tag, const RT& num, const RT& den) : Base(d,tag,num,den) {} Aff_transformation_d(int d, Rotation tag, const RT& sin_num, const RT& cos_num, const RT& den, int e1 = 0, int e2 = 1) : Base(d,tag,sin_num,cos_num,den,e1,e2) {} Aff_transformation_d(int d, Rotation tag, const Direction_d& dir, const RT& num, const RT& den, int e1 = 0, int e2 = 1) : Base(d,tag,dir,num,den,e1,e2) {} Aff_transformation_d(const Base& a) : Base(a) {} Aff_transformation_d(const Self& a) : Base(a) {} template Aff_transformation_d(Scaling tag, Forward_iterator start, Forward_iterator end) : Base(tag,start,end) {} Self operator*(const Self& a) { return Base::operator*(a); } Self inverse() const { return Base::inverse(); } bool operator==(const Self& a) const { return Base::operator==(a); } bool operator!=(const Self& a) const { return Base::operator!=(a); } }; CGAL_END_NAMESPACE #endif //CGAL_AFF_TRANSFORMATION_D_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Interface_classes.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Interface_cla0000644000175000017500000000317211344301501031211 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Interface_classes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_INTERFACE_CLASSES_H #define CGAL_INTERFACE_CLASSES_H CGAL_BEGIN_NAMESPACE template class Point_d; template class Vector_d; template class Direction_d; template class Hyperplane_d; template class Sphere_d; template class Iso_box_d; template class Segment_d; template class Ray_d; template class Line_d; template class Aff_transformation_d; CGAL_END_NAMESPACE #endif //CGAL_INTERFACE_CLASSES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Line_d.C0000644000175000017500000000301611344301501030042 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Line_d.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_LINE_D_C #define CGAL_LINE_D_C CGAL_BEGIN_NAMESPACE template Line_d Segment_d::supporting_line() const { CGAL_assertion_msg((!is_degenerate()), "Segment_d::supporting_line(): degenerate segment cannot be converted."); return Line_d(Base(*this)); } template Line_d Ray_d::supporting_line() const { return Line_d(Base(*this)); } CGAL_END_NAMESPACE #endif //CGAL_LINE_D_C ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Hyperplane_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Hyperplane_d.0000644000175000017500000000543411344301501031165 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Hyperplane_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_HYPERPLANE_D_H #define CGAL_HYPERPLANE_D_H CGAL_BEGIN_NAMESPACE template class Hyperplane_d : public pR::Hyperplane_d_base { public: typedef typename pR::Hyperplane_d_base Base; typedef Hyperplane_d Self; typedef pR R; typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; Hyperplane_d(int d=0) : Base(d) {} Hyperplane_d(int a, int b, int c) : Base(a,b,c) {} Hyperplane_d(const RT& a, const RT& b, const RT& c) : Base(a,b,c) {} Hyperplane_d(int a, int b, int c, int d) : Base(a,b,c,d) {} Hyperplane_d(const RT& a, const RT& b, const RT& c, const RT& d) : Base(a,b,c,d) {} Hyperplane_d(const Point_d& p, const Direction_d& dir) : Base(p,dir) {} Hyperplane_d(const Hyperplane_d &h) : Base(h) {} Hyperplane_d(const Base& p) : Base(p) {} template Hyperplane_d(int d, InputIterator first, InputIterator last) : Base (d, first, last) {} template Hyperplane_d(int d, InputIterator first, InputIterator last, const RT& D) : Base (d, first, last, D) {} template Hyperplane_d(ForwardIterator first, ForwardIterator last, const Point_d& o, Oriented_side side = Oriented_side(0)) : Base(first,last,o,side) {} Vector_d orthogonal_vector() const { return Base::orthogonal_vector(); } Direction_d orthogonal_direction() const { return Base::orthogonal_direction(); } bool operator==(const Self& w) const { return Base::operator==(w); } bool operator!=(const Self& w) const { return Base::operator!=(w); } }; CGAL_END_NAMESPACE #endif //CGAL_HYPERPLANE_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/debug.h0000644000175000017500000000611311344301501030004 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/debug.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DEBUG_H #define CGAL_DEBUG_H #include #include #include #undef TRACE #undef TRACEN #undef TRACEV #undef CTRACE #undef CTRACEN #undef ASSERT static int debugthread=3141592; namespace { struct Avoid_warning_for_unused_debugthread { static int x; }; int Avoid_warning_for_unused_debugthread::x = debugthread; } #if _DEBUG>0 #define SETDTHREAD(l) debugthread=l #else #define SETDTHREAD(l) #endif #if _DEBUG>0 #define TRACE(t) if((debugthread%_DEBUG)==0)\ std::cerr<<" "<0 #define TRACEV(t) if((debugthread%_DEBUG)==0)\ std::cerr<<" "<<#t<<" = "<<(t)<0 #define TRACEN(t) if((debugthread%_DEBUG)==0)\ std::cerr<<" "<0 #define CTRACE(b,t) if(b) std::cerr << " " << t; else std::cerr << " 0" #else #define CTRACE(b,t) #endif #if _DEBUG>0 #define CTRACEN(b,t) if(b) std::cerr<< " " < void print_elements(const C& container) { typename C::const_iterator it; forall_iterators(it,container) std::cerr << *it << " "; } template void print(I s, I e, std::ostream& os = std::cerr) { while(s!=e) os<<*s++<<" "; } template std::string make_std_string(const T& t) { std::ostringstream os; os << t; std::string res(os.str()); return res; } } // MSDEBUG #endif //CGAL_DEBUG_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Point_d.h0000644000175000017500000000527511344301501030322 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Point_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_POINT_D_H #define CGAL_POINT_D_H CGAL_BEGIN_NAMESPACE template class Point_d : public pR::Point_d_base { public: typedef typename pR::Point_d_base Base; typedef Point_d Self; typedef pR R; private: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; public: Point_d(int d=0) : Base(d) {} Point_d(int d, const Origin &o) : Base(d,o) {} Point_d(int a, int b, int c = 1) : Base(RT(a),RT(b),RT(c)) {} Point_d(const RT& a, const RT& b, const RT& c = 1) : Base(a,b,c) {} Point_d(int a, int b, int c, int d) : Base(RT(a),RT(b),RT(c),RT(d)) {} Point_d(const RT& a, const RT& b, const RT& c, const RT& d) : Base(a,b,c,d) {} template Point_d (int d, InputIterator first, InputIterator last) : Base (d, first, last) {} template Point_d(int d, InputIterator first, InputIterator last, const RT& D) : Base (d, first, last, D) {} Point_d(const Self &p) : Base(p) {} Point_d(const Base& p) : Base(p) {} Vector_d operator-(const Origin& o) const { return Base::operator-(o); } Vector_d operator-(const Self& q) const { return Base::operator-(q); } Self operator+(const Vector_d& v) const { return Base::operator+(v); } Self operator-(const Vector_d& v) const { return Base::operator-(v); } Self& operator+=(const Vector_d& v) { return static_cast(Base::operator+=(v)); } Self& operator-=(const Vector_d& v) { return static_cast(Base::operator-=(v)); } }; CGAL_END_NAMESPACE #endif //CGAL_POINT_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Segment_d.h0000644000175000017500000002052711344301501030630 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Segment_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SEGMENT_D_H #define CGAL_SEGMENT_D_H #include #include #include CGAL_BEGIN_NAMESPACE template std::istream& operator>> (std::istream&, Segment_d&); template std::ostream& operator<< (std::ostream&, const Segment_d&); /*{\Manpage {Segment_d}{R}{Segments in d-space}{s}}*/ template class Segment_d : public Handle_for< Pair_d > { typedef Pair_d Pair; typedef Handle_for Base; typedef Segment_d Self; using Base::ptr; /*{\Mdefinition An instance $s$ of the data type |Segment_d| is a directed straight line segment in $d$-dimensional Euclidian space connecting two points $p$ and $q$. $p$ is called the source point and $q$ is called the target point of $s$, both points are called endpoints of $s$. A segment whose endpoints are equal is called \emph{degenerate}.}*/ public: /*{\Mtypes 5}*/ typedef p_R R; /*{\Mtypemember the representation type.}*/ typedef typename p_R::RT RT; /*{\Mtypemember the ring type.}*/ typedef typename p_R::FT FT; /*{\Mtypemember the field type.}*/ typedef typename p_R::LA LA; /*{\Mtypemember the linear algebra layer.}*/ friend class Line_d; friend class Ray_d; private: Segment_d(const Base& b) : Base(b) {} public: /*{\Mcreation 3}*/ Segment_d() : Base( Pair() ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname|.}*/ Segment_d(const Point_d& p, const Point_d& q) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| which is initialized to the segment $(p,q)$. }*/ : Base( Pair(p,q) ) {} Segment_d(const Point_d& p, const Vector_d& v) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| which is initialized to the segment |(p,p+v)|. }*/ : Base( Pair(p,p+v) ) {} Segment_d(const Segment_d& s) : Base(s) {} /*{\Moperations 3 3}*/ int dimension() const { return (ptr()->_p[0].dimension()); } /*{\Mop returns the dimension of the underlying space. }*/ Point_d source() const { return ptr()->_p[0]; } /*{\Mop returns the source point of segment |\Mvar|. }*/ Point_d target() const { return ptr()->_p[1]; } /*{\Mop returns the target point of segment |\Mvar|. }*/ // defined for historical reasons Point_d vertex(int i) const /*{\Mop returns source or target of |\Mvar|: |vertex(0)| returns the source, |vertex(1)| returns the target. The parameter $i$ is taken modulo $2$, which gives easy access to the other vertex. \precond $i \geq 0$.}*/ { CGAL_assertion(i>=0); return ptr()->_p[i%2]; } Point_d point(int i) const { return vertex(i); } /*{\Mop returns |vertex(i)|.}*/ Point_d operator[](int i) const { return vertex(i); } /*{\Marrop returns |vertex(i)|.}*/ Point_d min() const /*{\Mop returns the lexicographically smaller vertex.}*/ { typename R::Compare_lexicographically_d cmp; if (cmp(source(),target()) == CGAL::SMALLER) return source(); else return target(); } Point_d max() const /*{\Mop returns the lexicographically larger vertex.}*/ { typename R::Compare_lexicographically_d cmp; if (cmp(source(),target()) == SMALLER) return target(); else return source(); } Segment_d opposite() const /*{\Mop returns the segment |(target(),source())|.}*/ { return Segment_d(target(),source()); } Direction_d direction() const /*{\Mop returns the direction from source to target.\\ \precond |\Mvar| is non-degenerate. }*/ { CGAL_assertion_msg((!is_degenerate()), "Segment_d::direction(): degenerate segment cannot be converted."); return ptr()->direction(); } Vector_d vector() const /*{\Mop returns the vector from source to target.}*/ { return ptr()->vector(); } FT squared_length() const /*{\Mop returns the square of the length of |\Mvar|.}*/ { return (target()-source()).squared_length(); } bool has_on(const Point_d& p) const /*{\Mop returns true if $p$ lies on |\Mvar| and false otherwise. }*/ { if (is_degenerate()) return (source() == p); typename R::Position_on_line_d pos; FT l; if ( pos(p,source(),target(),l) ) return (FT(0)<=l && l<=FT(1)); return false; } inline Line_d supporting_line() const; /*{\Mop returns the supporting line of |\Mvar|. \precond |\Mvar| is non-degenerate. }*/ Segment_d transform(const Aff_transformation_d& t) const /*{\Mop returns $t(s)$.}*/ { return Segment_d(source().transform(t), target().transform(t)); } Segment_d operator+(const Vector_d& v) const /*{\Mbinop returns $s+v$, i.e., |\Mvar| translated by vector $v$.}*/ { return Segment_d(source()+v,target()+v); } bool is_degenerate() const /*{\Mop returns true if |\Mvar| is degenerate i.e. |\Mvar.source()=\Mvar.target()|. }*/ { return ptr()->is_degenerate(); } bool operator==(const Segment_d& t) const { if (identical(t)) return true; return ((source() == t.source() && target() == t.target())); } bool operator!=(const Segment_d& t) const { return !operator==(t); } friend std::istream& operator>> <> (std::istream&, Segment_d&); friend std::ostream& operator<< <> (std::ostream&, const Segment_d&); }; // end of class /*{\Mtext \headerline{Non-Member Functions} }*/ template bool weak_equality(const Segment_d& s, const Segment_d& t) /*{\Mfunc Test for equality as unoriented segments.}*/ { return (s==t || s==t.opposite()); } template bool parallel(const Segment_d& s1, const Segment_d& s2) /*{\Mfunc return true if one of the segments is trivial or if the unoriented supporting lines are parallel. }*/ { return s1.is_degenerate() || s2.is_degenerate() || s1.direction() == s2.direction() || s1.direction() == -s2.direction(); } template bool common_endpoint(const Segment_d& s1, const Segment_d& s2, Point_d& common) /*{\Mfunc if |s1| and |s2| touch in a common end point, this point is assigned to |common| and the result is |true|, otherwise the result is |false|. }*/ { if (s1.source() == s2.source()) { common = s1.source(); return true; } if (s1.source() == s2.target()) { common = s1.source(); return true; } if (s1.target() == s2.source()) { common = s1.target(); return true; } if (s1.target() == s2.target()) { common = s1.target(); return true; } return false; } template std::istream& operator>>(std::istream& I, Segment_d& s) { s.copy_on_write(); s.ptr()->read(I); CGAL_assertion_msg(s.source().dimension()==s.target().dimension(), "Segment_d::operator>>: dimensions disagree."); return I; } template std::ostream& operator<<(std::ostream& O, const Segment_d& s) { s.ptr()->print(O,"Segment_d"); return O; } template inline CGAL::io_Operator io_tag(const Segment_d&) { return CGAL::io_Operator(); } /*{\Mimplementation Segments are implemented by a pair of points as an item type. All operations like creation, initialization, tests, the calculation of the direction and source - target vector, input and output on a segment $s$ take time $O(|s.dimension()|)$. |dimension()|, coordinate and end point access, and identity test take constant time. The operations for intersection calculation also take time $O(|s.dimension()|)$. The space requirement is $O(|s.dimension()|)$. }*/ CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_D_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Pair_d.h0000644000175000017500000000556711344301501030130 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Pair_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PAIR_D_H #define CGAL_PAIR_D_H #include #include CGAL_BEGIN_NAMESPACE template class Segment_d; template class Ray_d; template class Line_d; template class Pair_d { typedef Pair_d Self; typedef typename R::Point_d Point_d; typedef typename R::Vector_d Vector_d; typedef typename R::Direction_d Direction_d; Point_d _p[2]; friend class Line_d; friend class Ray_d; friend class Segment_d; /* Any line object in $d$ - space is defined by two points |_p1| and |_p2| respectively. There exists an orientation from _p1 to _p2. */ public: Pair_d(int d = 0) { _p[0]=_p[1]=Point_d(d); } Pair_d(const Point_d& p, const Point_d& q) { CGAL_assertion_msg((p.dimension() == q.dimension()), "Pair_d::constructor: source and target must have the same dimension."); _p[0]=p; _p[1]=q; } bool is_degenerate() const { return (_p[0] == _p[1]); } Vector_d vector() const { return (_p[1] - _p[0]); } Direction_d direction() const { return vector().direction(); } void read(std::istream& is) { switch( is.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : is >> _p[0] >> _p[1]; break; case CGAL::IO::BINARY : CGAL::read(is, _p[0]); CGAL::read(is, _p[1]); break; default: CGAL_assertion_msg(0,"\nStream must be in ascii or binary mode\n"); } } void print(std::ostream& os, const char* _name) const { switch( os.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : os << _p[0] << " " << _p[1]; break; case CGAL::IO::BINARY : CGAL::write(os, _p[0]); CGAL::write(os, _p[1]); break; default : os << _name << "(" << _p[0] << ", " << _p[1] << ")"; break; } } }; // Pair_d CGAL_END_NAMESPACE #endif //CGAL_PAIR_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Sphere_d.h0000644000175000017500000002665711344301501030466 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Sphere_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SPHERE_D_H #define CGAL_SPHERE_D_H #include #include CGAL_BEGIN_NAMESPACE template class Sphere_d; template bool equal_as_sets(const Sphere_d&, const Sphere_d&); template class Sphere_d_rep { typedef typename R::Point_d Point_d; friend class Sphere_d; friend bool equal_as_sets <> (const Sphere_d&, const Sphere_d&); std::vector< Point_d > P; // d+1 defining points, index range 0-d Orientation orient; // orientation(P) Point_d* cp; // pointer to center (lazy calculated) public: Sphere_d_rep() : cp(0) {} Sphere_d_rep(int d) : P(d), cp(0) {} template Sphere_d_rep(int d, ForwardIterator first, ForwardIterator last) : P(first,last), cp(0) { TUPLE_DIM_CHECK(P.begin(),P.end(),Sphere_d); CGAL_assertion(d+1==int(P.size())); typename R::Orientation_d orientation_; orient = orientation_(P.begin(),P.end()); } ~Sphere_d_rep() { if (cp) delete cp; } }; // Sphere_d_rep /*{\Manpage {Sphere_d}{R}{Simple Spheres}{S}}*/ template class Sphere_d : public Handle_for< Sphere_d_rep > { /*{\Mdefinition An instance $S$ of the data type |Sphere_d| is an oriented sphere in some $d$-dimensional space. A sphere is defined by $d+1$ points with rational coordinates (class |Point_d|). We use $A$ to denote the array of the defining points. A set $A$ of defining points is \emph{legal} if either the points are affinely independent or if the points are all equal. Only a legal set of points defines a sphere in the geometric sense and hence many operations on spheres require the set of defining points to be legal. The orientation of $S$ is equal to the orientation of the defining points, i.e., |orientation(A)|. }*/ public: /*{\Mtypes 4}*/ typedef Sphere_d_rep Rep; typedef Handle_for Base; typedef Sphere_d Self; typedef typename R_::Point_d Point_d; using Base::ptr; Sphere_d(const Base& b) : Base(b) {} typedef R_ R; /*{\Mtypemember the representation type.}*/ typedef typename R::RT RT; /*{\Mtypemember the ring type.}*/ typedef typename R::FT FT; /*{\Mtypemember the field type.}*/ typedef typename R::LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename std::vector< Point_d >::const_iterator point_iterator; /*{\Mtypemember a read-only iterator for points defining the sphere.}*/ /*{\Mcreation 4}*/ Sphere_d(int d = 0) : Base( Rep(d+1) ) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname|. |\Mvar| is initialized to the empty sphere centered at the origin of $d$-dimensional space. }*/ { Point_d p(d); for (int i = 0; i <= d; i++) ptr()->P[i] = p; ptr()->orient = ZERO; ptr()->cp = new Point_d(p); } template Sphere_d(int d, ForwardIterator first, ForwardIterator last) : /*{\Mcreate introduces a variable |\Mvar| of type |\Mname|. |\Mvar| is initialized to the sphere through the points in |A = set [first,last)|. \precond $A$ consists of $d+1$ $d$-dimensional points.}*/ Base( Rep(d,first,last) ) {} Sphere_d(const Self& c) : Base(c) {} ~Sphere_d() {} /*{\Moperations 4 3}*/ int dimension() const /*{\Mop returns the dimension of |\Mvar|.}*/ { return ptr()->P.size() - 1; } Point_d point(int i) const /*{\Mop returns the $i$-th defining point. \precond $0 \le i \le |dim|$.}*/ { CGAL_assertion_msg((0<=i && i<=dimension()), "Sphere_d::point(): index out of range."); return ptr()->P[i]; } point_iterator points_begin() const { return ptr()->P.begin(); } /*{\Mop returns an iterator pointing to the first defining point.}*/ point_iterator points_end() const { return ptr()->P.end(); } /*{\Mop returns an iterator pointing beyond the last defining point.}*/ bool is_degenerate() const { return (ptr()->orient == CGAL::ZERO); } /*{\Mop returns true iff the defining points are not full dimenional.}*/ bool is_legal() const /*{\Mop returns true iff the set of defining points is legal. A set of defining points is legal iff their orientation is non-zero or if they are all equal.}*/ { if (ptr()->orient != ZERO ) return true; const std::vector< Point_d >& A = ptr()->P; Point_d po = A[0]; for (int i = 1; i < int(A.size()); ++i) if (A[i] != po) return false; return true; } Point_d center() const /*{\Mop returns the center of |\Mvar|. \precond The orientation of |\Mvar| is non-zero. }*/ { if (ptr()->cp == 0) { if (ptr()->orient == 0) { const std::vector< Point_d >& A = ptr()->P; Point_d po = A[0]; for (int i = 1; i < int(A.size()); ++i) if (A[i] != po) CGAL_assertion_msg(0,"Sphere_d::center(): points are illegal."); const_cast(*this).ptr()->cp = new Point_d(A[0]); return *(ptr()->cp); } typename R::Center_of_sphere_d center_of_sphere_; const_cast(*this).ptr()->cp = new Point_d(center_of_sphere_(points_begin(),points_end())); } return *(ptr()->cp); } FT squared_radius() const /*{\Mop returns the squared radius of the sphere.}*/ { if (is_degenerate()) return 0; return (point(0)-center()).squared_length(); } Orientation orientation() const { return ptr()->orient; } /*{\Mop returns the orientation of |\Mvar|.}*/ Oriented_side oriented_side(const Point_d& p) const /*{\Mop returns either the constant |ON_ORIENTED_BOUNDARY|, |ON_POSITIVE_SIDE|, or |ON_NEGATIVE_SIDE|, iff p lies on the boundary, properly on the positive side, or properly on the negative side of circle, resp.}*/ { typename R::Side_of_oriented_sphere_d side; return side(points_begin(),points_end(),p); } Bounded_side bounded_side(const Point_d& p) const /*{\Mop returns |ON_BOUNDED_SIDE|, |ON_BOUNDARY|, or |ON_UNBOUNDED_SIDE| iff p lies properly inside, on the boundary, or properly outside of circle, resp.}*/ { typename R::Side_of_bounded_sphere_d side; return side(points_begin(),points_end(),p); } bool has_on_positive_side (const Point_d& p) const /*{\Mop returns |\Mvar.oriented_side(p)==ON_POSITIVE_SIDE|.}*/ { return oriented_side(p) == ON_POSITIVE_SIDE; } bool has_on_negative_side (const Point_d& p) const /*{\Mop returns |\Mvar.oriented_side(p)==ON_NEGATIVE_SIDE|.}*/ { return oriented_side(p) == ON_NEGATIVE_SIDE; } bool has_on_boundary (const Point_d& p) const /*{\Mop returns |\Mvar.oriented_side(p)==ON_ORIENTED_BOUNDARY|, which is the same as |\Mvar.bounded_side(p)==ON_BOUNDARY|.}*/ { return oriented_side(p) == ON_ORIENTED_BOUNDARY; } bool has_on_bounded_side (const Point_d& p) const /*{\Mop returns |\Mvar.bounded_side(p)==ON_BOUNDED_SIDE|.}*/ { return (int(ptr()->orient) * int(oriented_side(p))) > 0 ; } bool has_on_unbounded_side (const Point_d& p) const /*{\Mop returns |\Mvar.bounded_side(p)==ON_UNBOUNDED_SIDE|.}*/ { return (int(ptr()->orient) * int(oriented_side(p))) < 0; } Sphere_d opposite() const /*{\Mop returns the sphere with the same center and squared radius as |\Mvar| but with opposite orientation.}*/ { CGAL_assertion(dimension()>1); if (is_degenerate()) return *this; std::vector< Point_d > V(points_begin(),points_end()); std::swap(V[0],V[1]); return Sphere_d(dimension(),V.begin(),V.end()); } Sphere_d transform(const Aff_transformation_d& t) const /*{\Mopl returns $t(s)$. }*/ { std::vector< Point_d > B(points_begin(),points_end()); typename std::vector< Point_d >::iterator it; for (it = B.begin(); it != B.end(); ++it) *it = it->transform(t); return Sphere_d(dimension(),B.begin(),B.end()); } Sphere_d operator+(const Vector_d& v) const /*{\Mbinop returns the sphere translated by |v|. }*/ { std::vector< Point_d > B(points_begin(),points_end()); typename std::vector< Point_d >::iterator it; for (it = B.begin(); it != B.end(); ++it) it->operator+=(v); return Sphere_d(dimension(),B.begin(),B.end()); } bool operator==(const Sphere_d& D) const { if (identical(D)) return true; if (dimension() != D.dimension()) return false; return (center()==D.center() && squared_radius() == D.squared_radius() && orientation() == D.orientation()); } bool operator!=(const Sphere_d& D) const { return !operator==(D); } }; // end of class Sphere_d /*{\Mtext \headerline{Non-Member Functions} }*/ template bool weak_equality(const Sphere_d& s1, const Sphere_d& s2) /*{\Mfunc Test for equality as unoriented spheres.}*/ { if (s1.identical(s2)) return true; if (s1.dimension() != s2.dimension()) return false; return (s1.center()==s2.center() && s1.squared_radius() == s2.squared_radius()); } /*{\Mimplementation Spheres are implemented by a vector of points as an item type. All operations like creation, initialization, tests, input and output of a sphere $s$ take time $O(|s.dimension()|)$. |dimension()|, point access take constant time. The space requirement for spheres is $O(|s.dimension()|)$ neglecting the storage room of the points.}*/ template std::ostream& operator<<(std::ostream& os, const CGAL::Sphere_d& s) { typedef typename Sphere_d::point_iterator iterator; os << s.dimension()+1 << " "; for (iterator it=s.points_begin(); it!=s.points_end(); ++it) os << *it << " "; return os; } template std::istream& operator>>(std::istream& is, CGAL::Sphere_d& s) { int d; is >> d; std::vector< Point_d > V(d); Point_d p; while ( d-- ) { if (!(is >> p)) return is; V[d] = p; } s = Sphere_d(V.size()-1, V.begin(), V.end() ); return is; } /* The center is only defined if the set of defining points are legal. If the defining points are all equal the sphere is trivial. So assume otherwise. Then the center $c$ is the unique point with equal distance to all the defining points. A point $c$ has equal distance to point $p_0$ and $p_i$ if it lies on the perpendicual bisector of $p_d$ and $p_i$, i.e., if it satiesfies the plane equation $(p_i - p_d)^T c = (p_i - p_d) (p_i + p_d)/2$. Note that $p_i - p_d$ is the normal vector of the bisector hyperplane and $(p_i + p_d)/2$ is the midpoint of $p_d$ and $p_i$. The equation above translates into the equation \[ \sum_{0 \le j < d} 2*p_{dd}p_{id}(p_{ij}p_{dd} - p_{dj}p_{id})c_j/c_d = \sum_{0 \le j < d} (p_{ij}p_{dd} - p_{dj}p_{id})(p_{ij}p_{dd} + p_{dj}p_{id}) \] for the homogeneous coordinates of the points and the center. We may tentatively assume that $c_d = 1$, solve the corresponding linear system, and then define the center. */ CGAL_END_NAMESPACE #endif // CGAL_SPHERE_D_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointCd.h0000644000175000017500000001414011344301501030255 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/PointCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_POINTCDXXX_H #define CGAL_POINTCDXXX_H #ifndef NOCGALINCL #include #include #endif #include CGAL_BEGIN_NAMESPACE #define PointCd PointCd2 template class PointCd; template std::istream& operator>>(std::istream&, PointCd&); template std::ostream& operator<<(std::ostream&, const PointCd&); template class PointCd : public Handle_for< Tuple_d<_FT,_LA> > { typedef Tuple_d<_FT,_LA> Tuple; typedef Handle_for Base; typedef PointCd<_FT,_LA> Self; using Base::ptr; typename _LA::Vector& vector_rep() { return ptr()->v; } const typename _LA::Vector& vector_rep() const { return ptr()->v; } _FT& entry(int i) { return ptr()->v[i]; } const _FT& entry(int i) const { return ptr()->v[i]; } PointCd(const Base& b) : Base(b) {} public: /*{\Mtypes 4}*/ typedef _FT RT; typedef _FT FT; typedef _LA LA; typedef typename Tuple::const_iterator Cartesian_const_iterator; typedef typename Tuple::Homogeneous_const_iterator Homogeneous_const_iterator; friend class VectorCd; friend class HyperplaneCd; /*{\Mcreation 4}*/ PointCd(int d = 0) : Base( Tuple(d) ) {} PointCd(int d, const Origin&) : Base( Tuple(d) ) {} template PointCd(int d, InputIterator first, InputIterator last) : Base( Tuple(d,first,last) ) { if ( first == last ) return; // else first specifies common denominator: CGAL_assertion_msg(FT(*first)!=FT(0), "PointCd::constructor: denominator must be nonzero."); for (register int i=0; i PointCd (int d, InputIterator first, InputIterator last, const FT& D) : Base( Tuple(d,first,last) ) { CGAL_assertion_msg(D!=FT(0),"PointCd::constructor: D must be nonzero."); for (register int i=0; i& p) : Base(p) {} ~PointCd() {} int dimension() const { return ptr()->size(); } FT cartesian(int i) const { CGAL_assertion_msg((0<=i && ibegin(); } Cartesian_const_iterator cartesian_end() const { return ptr()->end(); } Homogeneous_const_iterator homogeneous_begin() const { return Homogeneous_const_iterator(ptr()->begin(),ptr()->end()); } Homogeneous_const_iterator homogeneous_end() const { return Homogeneous_const_iterator(ptr()->beyondend()); } PointCd transform(const Aff_transformationCd& t) const; inline VectorCd operator-(const Origin& o) const; VectorCd operator-(const PointCd& q) const { VectorCd res(dimension()); res.ptr()->cartesian_sub(ptr(),q.ptr()); return res; } PointCd operator+(const VectorCd& v) const; PointCd operator-(const VectorCd& v) const; PointCd& operator+=(const VectorCd& v); PointCd& operator-=(const VectorCd& v); static Comparison_result cmp( const PointCd& p1, const PointCd& p2) { Compare_componentwise cmpobj; return cmpobj(p1.vector_rep(),p2.vector_rep()); } bool operator==(const PointCd& q) const { if (identical(q)) return true; if (dimension()!=q.dimension()) return false; return vector_rep()==q.vector_rep(); } bool operator!=(const PointCd& q) const { return !(*this==q); } bool operator==(const Origin&) const { for (int i = 0; i < dimension(); i++) if (cartesian(i) != FT(0)) return false; return true; } friend std::istream& operator>> <> (std::istream&, PointCd&); friend std::ostream& operator<< <> (std::ostream&, const PointCd&); FT hx() const { return cartesian(0); } FT hy() const { return cartesian(1); } FT hz() const { return cartesian(2); } FT hw() const { return FT(1); } FT x() const { return cartesian(0); } FT y() const { return cartesian(1); } FT z() const { return cartesian(2); } }; // PointCd #undef PointCd CGAL_END_NAMESPACE #endif // CGAL_POINTCDXXX_H //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Iso_box_d.h0000644000175000017500000003032211344301501030622 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Iso_box_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Authors : Hans Tangelder , Michael Hoffmann #ifndef CGAL_ISO_BOX_D_H #define CGAL_ISO_BOX_D_H #include #include #include #include #include #include #include namespace CGAL { namespace Kernel_d { struct Begin {}; struct End {}; struct Cartesian_end {}; } // namespace Kernel_d template < typename Point_, typename Functor_ > struct Cartesian_iterator { typedef Point_ Point; typedef Functor_ Functor; typedef typename Point::Cartesian_const_iterator Iterator; typedef Cartesian_iterator Self; typedef typename Functor::result_type value_type; typedef value_type& reference; typedef value_type* pointer; typedef std::ptrdiff_t difference_type; typedef std::input_iterator_tag iterator_category; protected: Iterator pb, qb; Functor f; public: Cartesian_iterator(const Point& p, const Point& q, Kernel_d::Begin) : pb(p.cartesian_begin()), qb(q.cartesian_begin()) {} Cartesian_iterator(const Point& p, const Point& q, Kernel_d::End) : pb(p.cartesian_end()), qb(q.cartesian_end()) {} Cartesian_iterator(const Point& p, const Point& q, Kernel_d::Cartesian_end) : pb(p.cartesian_end()), qb(q.cartesian_end()) {} Cartesian_iterator(const Point& p, const Point& q, const Functor& f_, Kernel_d::Begin) : pb(p.cartesian_begin()), qb(q.cartesian_begin()), f(f_) {} Cartesian_iterator(const Point& p, const Point& q, const Functor& f_, Kernel_d::End) : pb(p.cartesian_end()), qb(q.cartesian_end()), f(f_) {} Cartesian_iterator(const Point& p, const Point& q, const Functor& f_, Kernel_d::Cartesian_end) : pb(p.cartesian_end()), qb(q.cartesian_end()), f(f_) {} Self& operator++() { ++pb; ++qb; return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } value_type operator*() const { return f(*pb, *qb); } pointer operator->() const { return &(**this); } const Functor& functor() const { return f; } Iterator base_p() const { return pb; } Iterator base_q() const { return qb; } }; template < typename Iterator, typename Functor > inline bool operator==(const Cartesian_iterator& x, const Cartesian_iterator& y) { return x.base_p() == y.base_p() && x.base_q() == y.base_q(); } template < typename Iterator, typename Functor > inline bool operator!=(const Cartesian_iterator& x, const Cartesian_iterator& y) { return ! (x == y); } template < typename Point_, typename Functor_ > struct Homogeneous_iterator { typedef Point_ Point; typedef Functor_ Functor; typedef typename Point::Homogeneous_const_iterator Iterator; typedef Homogeneous_iterator Self; typedef typename Functor::result_type value_type; typedef value_type& reference; typedef value_type* pointer; typedef std::ptrdiff_t difference_type; typedef std::input_iterator_tag iterator_category; protected: Iterator pb, qb; Functor f; typedef typename Kernel_traits::Kernel::RT RT; RT hp, hq; // homogenizing coordinates public: Homogeneous_iterator(const Point& p, const Point& q, Kernel_d::Begin) : pb(p.homogeneous_begin()), qb(q.homogeneous_begin()), hp(p.homogeneous(p.dimension())), hq(q.homogeneous(q.dimension())) {} Homogeneous_iterator(const Point& p, const Point& q, Kernel_d::End) : pb(p.homogeneous_end()), qb(q.homogeneous_end()), hp(p.homogeneous(p.dimension())), hq(q.homogeneous(q.dimension())) {} Homogeneous_iterator(const Point& p, const Point& q, Kernel_d::Cartesian_end) : pb(p.homogeneous_end()), qb(q.homogeneous_end()), hp(p.homogeneous(p.dimension())), hq(q.homogeneous(q.dimension())) { --pb; --qb; } Homogeneous_iterator(const Point& p, const Point& q, const Functor& f_, Kernel_d::Begin) : pb(p.homogeneous_begin()), qb(q.homogeneous_begin()), f(f_), hp(p.homogeneous(p.dimension())), hq(q.homogeneous(q.dimension())) {} Homogeneous_iterator(const Point& p, const Point& q, const Functor& f_, Kernel_d::End) : pb(p.homogeneous_end()), qb(q.homogeneous_end()), f(f_), hp(p.homogeneous(p.dimension())), hq(q.homogeneous(q.dimension())) {} Homogeneous_iterator(const Point& p, const Point& q, const Functor& f_, Kernel_d::Cartesian_end) : pb(p.homogeneous_end()), qb(q.homogeneous_end()), f(f_), hp(p.homogeneous(p.dimension())), hq(q.homogeneous(q.dimension())) { --pb; --qb; } Self& operator++() { ++pb; ++qb; return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } value_type operator*() const { return f(*pb * hq, *qb * hp); } pointer operator->() const { return &(**this); } const Functor& functor() const { return f; } Iterator base_p() const { return pb; } Iterator base_q() const { return qb; } }; template < typename Iterator, typename Functor > inline bool operator==(const Homogeneous_iterator& x, const Homogeneous_iterator& y) { return x.base_p() == y.base_p() && x.base_q() == y.base_q(); } template < typename Iterator, typename Functor > inline bool operator!=(const Homogeneous_iterator& x, const Homogeneous_iterator& y) { return ! (x == y); } template < typename Kernel_ > struct Iso_box_d; namespace Kernel_d { template < typename RepTag > struct Coordinate_iterator; template <> struct Coordinate_iterator { template < typename Point, typename Functor > struct Iterator { typedef Cartesian_iterator type; }; }; template <> struct Coordinate_iterator { template < typename Point, typename Functor > struct Iterator { typedef Homogeneous_iterator type; }; }; template < typename Kernel_ > struct Iso_box_d_rep { typedef Kernel_ Kernel; friend class Iso_box_d; protected: typedef typename Kernel::Point_d Point_d; Point_d lower, upper; public: Iso_box_d_rep() {} template < typename InputIteratorI, typename InputIteratorII > Iso_box_d_rep(int dim, InputIteratorI b1, InputIteratorI e1, InputIteratorII b2, InputIteratorII e2) : lower(dim, b1, e1), upper(dim, b2, e2) {} }; } // namespace Kernel_d template < typename Kernel_ > struct Iso_box_d : public Handle_for< Kernel_d::Iso_box_d_rep > { typedef Kernel_ Kernel; protected: typedef Kernel_d::Iso_box_d_rep Rep; typedef Handle_for Base; typedef Iso_box_d Self; using Base::ptr; typedef typename Kernel::RT RT; typedef typename Kernel::FT FT; typedef typename Kernel::Point_d Point_d; typedef typename Kernel::Rep_tag Rep_tag; typedef CGAL::Kernel_d::Coordinate_iterator CIRT; typedef typename CIRT::template Iterator >::type MinIter; typedef typename CIRT::template Iterator >::type MaxIter; typedef Kernel_d::Begin Begin; typedef Kernel_d::End End; typedef Kernel_d::Cartesian_end Cartesian_end; RT volume_nominator() const { typedef typename CIRT::template Iterator >::type Iter; Iter b(ptr()->upper, ptr()->lower, Begin()); Iter e(ptr()->upper, ptr()->lower, Cartesian_end()); return std::accumulate(b, e, RT(1), std::multiplies()); } RT volume_denominator() const { RT den = ptr()->lower.homogeneous(dimension()) * ptr()->upper.homogeneous(dimension()); RT prod = den; for (int i = 1; i < dimension(); ++i) prod *= den; return prod; } FT volume(Homogeneous_tag) const { return FT(volume_nominator(), volume_denominator()); } FT volume(Cartesian_tag) const { return volume_nominator(); } public: Iso_box_d() {} Iso_box_d(const Point_d& p, const Point_d& q) : Base(Rep(p.dimension(), MinIter(p, q, Begin()), MinIter(p, q, End()), MaxIter(p, q, Begin()), MaxIter(p, q, End()))) { CGAL_precondition(p.dimension() == q.dimension()); } Bounded_side bounded_side(const Point_d& p) const { CGAL_precondition(p.dimension() == dimension()); typedef typename CIRT::template Iterator >::type Iter; Iter il(p, ptr()->lower, Begin()); Iter ilend(p, ptr()->lower, Cartesian_end()); Iter iu(p, ptr()->upper, Begin()); CGAL_assertion_code(Iter iuend(p, ptr()->upper, Cartesian_end())); for (; il != ilend; ++il, ++iu) { CGAL_assertion(iu != iuend); Comparison_result low = *il; Comparison_result upp = *iu; if (low == LARGER && upp == SMALLER) continue; if (low == SMALLER || upp == LARGER) return ON_UNBOUNDED_SIDE; return ON_BOUNDARY; } return ON_BOUNDED_SIDE; } bool has_on_bounded_side(const Point_d& p) const { return (bounded_side(p)==ON_BOUNDED_SIDE); } bool has_on_unbounded_side(const Point_d& p) const { return (bounded_side(p)==ON_UNBOUNDED_SIDE); } bool has_on_boundary(const Point_d& p) const { return (bounded_side(p)==ON_BOUNDARY); } int dimension() const { return ptr()->lower.dimension();} // FIXME! FT min_coord(int i) const { return ptr()->lower[i]; } FT max_coord(int i) const { return ptr()->upper[i]; } const Point_d& min() const { return ptr()->lower; } const Point_d& max() const { return ptr()->upper; } FT volume() const { return volume(Rep_tag()); } bool is_degenerate() const { typedef typename CIRT:: template Iterator >::type Iter; // omit homogenizing coordinates Iter e(ptr()->lower, ptr()->upper, Cartesian_end()); return e != std::find(Iter(ptr()->lower, ptr()->upper, Begin()), e, true); } }; // end of class template < typename Kernel > inline bool operator==(const Iso_box_d& b1, Iso_box_d& b2) { CGAL_precondition(b1.dimension() == b2.dimension()); return b1.min() == b2.min() && b1.max() == b2.max(); } template < typename Kernel > inline bool operator!=(const Iso_box_d& b1, Iso_box_d& b2) { return ! (b1 == b2); } } // namespace CGAL #endif // CGAL_ISO_BOX_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorCd.C0000644000175000017500000000513611344301501030366 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorCd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_VECTORCD_C #define CGAL_VECTORCD_C CGAL_BEGIN_NAMESPACE #define PointCd PointCd2 template PointCd VectorCd::to_point() const { return PointCd(Base(*this)); } template PointCd operator+ (const Origin&, const VectorCd& v) { return v.to_point(); } template DirectionCd VectorCd:: direction() const { CGAL_assertion_msg(!is_zero(), "VectorCd::direction: \ zero vector cannot be a direction."); return DirectionCd(*this); } template VectorCd VectorCd:: transform(const Aff_transformationCd& t) const { typename LA::Vector res = t.transform_linearly(vector_rep()); return VectorCd(dimension(),res.begin(),res.end()); } template VectorCd operator*(const int& n, const VectorCd& v) { return v.scale(n); } template VectorCd operator*(const FT& n, const VectorCd& v) { return v.scale(n); } template std::istream& operator>>(std::istream& I, VectorCd& v) { v.copy_on_write(); v.ptr()->read(I); return I; } template std::ostream& operator<<(std::ostream& O, const VectorCd& v) { v.ptr()->print(O,"VectorCd"); return O; } template inline CGAL::io_Operator io_tag(const VectorCd&) { return CGAL::io_Operator(); } #undef PointCd CGAL_END_NAMESPACE #endif // CGAL_VECTORCD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Vector__.h0000644000175000017500000003104111344301501030454 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Vector__.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_VECTOR___H #define CGAL_VECTOR___H #include #include #undef _DEBUG #define _DEBUG 51 #include #include #include #include #include #include #include namespace CGALLA { template class Vector_; template class Matrix_; /*{\Msubst # # Vector_#Vector Matrix_#Matrix }*/ /*{\Moptions print_title=yes}*/ /*{\Moptions outfile=Vector.man}*/ /*{\Xtext \headerline{Common Notation} The following data types use the concept of iterator ranges as an abstraction of tuples and sets. For an iterator range |[first,last)| we define |S = set [first,last)| as the ordered tuple $(|S[0]|,|S[1]|, \ldots |S[d-1]|)$ where $|S[i]| = |*| |++|^{(i)}|first|$ (the element obtained by forwarding the iterator by operator |++| $i$ times and then dereferencing it to get the value to which it points). We write |d = size [first,last)|. This extends the syntax of random access iterators to input iterators. If we index the tuple as above then we require that $|++|^{(d)}|first == last|$ (note that |last| points beyond the last element to be accepted).}*/ /*{\Manpage {Vector}{}{Vectors with NT Entries}{v}}*/ template class Vector_ { /*{\Mdefinition An instance of data type |Vector_| is a vector of variables of number type |NT|. Together with the type |Matrix_| it realizes the basic operations of linear algebra.}*/ public: /*{\Mtypes 5.5}*/ typedef NT_* pointer; typedef const NT_* const_pointer; typedef NT_ NT; /*{\Mtypemember the ring type of the components.}*/ typedef pointer iterator; /*{\Mtypemember the iterator type for accessing components.}*/ typedef const_pointer const_iterator; /*{\Mtypemember the const iterator type for accessing components.}*/ typedef AL_ allocator_type; /*{\Xtypemember the allocator type.}*/ protected: friend class Matrix_; NT* v_; int d_; static allocator_type MM; inline void allocate_vec_space(NT*& vi, int di) { /* We use this procedure to allocate memory. We first get an appropriate piece of memory from the allocator and then initialize each cell by an inplace new. */ vi = MM.allocate(di); NT* p = vi + di - 1; while (p >= vi) { new (p) NT(0); p--; } } inline void deallocate_vec_space(NT*& vi, int di) { /* We use this procedure to deallocate memory. We have to free it by the allocator scheme. We first call the destructor for type NT for each cell of the array and then return the piece of memory to the memory manager. */ NT* p = vi + di - 1; while (p >= vi) { MM.destroy(p); p--; } //af: as proposed by sylvain MM.deallocate(vi, di); vi = (NT*)0; } inline void check_dimensions(const Vector_& vec) const { CGAL_assertion_msg((d_ == vec.d_), "Vector_::check_dimensions: object dimensions disagree."); } public: /*{\Mcreation v 3}*/ Vector_() : v_(0),d_(0) {} /*{\Mcreate creates an instance |\Mvar| of type |\Mname|.}*/ Vector_(int d) /*{\Mcreate creates an instance |\Mvar| of type |\Mname|. |\Mvar| is initialized to a vector of dimension $d$.}*/ { CGAL_assertion_msg( d >= 0 , "Vector_::constructor: negative dimension."); d_ = d; v_ = (NT*)0; if (d_ > 0){ allocate_vec_space(v_,d_); while (d--) v_[d] = NT(0); } } Vector_(int d, const NT& x) /*{\Mcreate creates an instance |\Mvar| of type |\Mname|. |\Mvar| is initialized to a vector of dimension $d$ with entries |x|.}*/ { CGAL_assertion_msg( d >= 0 , "Vector_::constructor: negative dimension."); d_ = d; v_ = (NT*)0; if (d_ > 0){ allocate_vec_space(v_,d_); while (d--) v_[d] = x; } } template Vector_(Forward_iterator first, Forward_iterator last) /*{\Mcreate creates an instance |\Mvar| of type |\Mname|; |\Mvar| is initialized to the vector with entries |set [first,last)|. \require |Forward_iterator| has value type |NT|.}*/ { #if defined _MSC_VER && _MSC_VER == 1300 d_ = 0; Forward_iterator fit = first; while(fit++!=last) d_++; #else d_ = std::distance(first, last); #endif allocate_vec_space(v_,d_); iterator it = begin(); while (first != last) { *it = *first; ++it; ++first; } } Vector_(const Vector_& p) { d_ = p.d_; if (d_ > 0) allocate_vec_space(v_,d_); else v_ = (NT*)0; for(int i=0; i& operator=(const Vector_& vec) { if (&vec == this) return *this; register int n = vec.d_; if (n != d_) { if (d_ > 0) deallocate_vec_space(v_,d_); d_=n; if (n > 0) allocate_vec_space(v_,n); else v_ = (NT*)0; } while (n--) v_[n] = vec.v_[n]; return *this; } ~Vector_() { if (d_ > 0) deallocate_vec_space(v_,d_); } /*{\Moperations 3 4}*/ int dimension() const { return d_; } /*{\Mop returns the dimension of |\Mvar|.}*/ bool is_zero() const /*{\Mop returns true iff |\Mvar| is the zero vector.}*/ { for(int i=0; i operator+(const Vector_& v1) const; /*{\Mbinop Addition. \precond\\ |v.dimension() == v1.dimension()|.}*/ Vector_ operator-(const Vector_& v1) const; /*{\Mbinop Subtraction. \precond\\ |v.dimension() = v1.dimension()|.}*/ NT operator*(const Vector_& v1) const; /*{\Mbinop Inner Product. \precond\\ |v.dimension() = v1.dimension()|.}*/ Vector_ compmul(const NT& r) const; Vector_ operator-() const; /*{\Munop Negation.}*/ Vector_& operator+=(const Vector_& v1); /*{\Mbinop Addition plus assignment. \precond\\ |v.dimension() == v1.dimension()|.}*/ Vector_& operator-=(const Vector_& v1); /*{\Mbinop Subtraction plus assignment. \precond\\ |v.dimension() == v1.dimension()|.}*/ Vector_& operator*=(const NT& s); /*{\Mbinop Scalar multiplication plus assignment.}*/ Vector_& operator/=(const NT& s); /*{\Mbinop Scalar division plus assignment.}*/ bool operator==(const Vector_& w) const; bool operator!=(const Vector_& w) const { return !(*this == w); } static int compare(const Vector_&, const Vector_&); }; template inline Vector_ operator*(const NT& r, const Vector_& v) /*{\Mbinopfunc Componentwise multiplication with number $r$.}*/ { return v.compmul(r); } template inline Vector_ operator*(const Vector_& v, const NT& r) /*{\Mbinopfunc Componentwise multiplication with number $r$.}*/ { return v.compmul(r); } template inline Vector_& Vector_:: operator+=(const Vector_& vec) { check_dimensions(vec); register int n = d_; while (n--) v_[n] += vec.v_[n]; return *this; } template inline Vector_& Vector_:: operator-=(const Vector_& vec) { check_dimensions(vec); register int n = d_; while (n--) v_[n] -= vec.v_[n]; return *this; } template inline Vector_& Vector_:: operator*=(const NT& s) { register int n = d_; while (n--) v_[n] *= s; return *this; } template inline Vector_& Vector_:: operator/=(const NT& s) { register int n = d_; while (n--) v_[n] /= s; return *this; } template inline Vector_ Vector_:: operator+(const Vector_& vec) const { check_dimensions(vec); register int n = d_; Vector_ result(n); while (n--) result.v_[n] = v_[n]+vec.v_[n]; return result; } template inline Vector_ Vector_:: operator-(const Vector_& vec) const { check_dimensions(vec); register int n = d_; Vector_ result(n); while (n--) result.v_[n] = v_[n]-vec.v_[n]; return result; } template inline Vector_ Vector_:: operator-() const // unary minus { register int n = d_; Vector_ result(n); while (n--) result.v_[n] = -v_[n]; return result; } template inline Vector_ Vector_:: compmul(const NT& x) const { int n = d_; Vector_ result(n); while (n--) result.v_[n] = v_[n] * x; return result; } template inline NT_ Vector_:: operator*(const Vector_& vec) const { check_dimensions(vec); NT_ result=0; register int n = d_; while (n--) result = result+v_[n]*vec.v_[n]; return result; } template inline bool Vector_:: operator==(const Vector_& vec) const { if (vec.d_ != d_) return false; int i = 0; while ((i int Vector_:: compare(const Vector_& v1, const Vector_& v2) { register int i; v1.check_dimensions(v2); for(i=0; i < v1.dimension() && v1[i]==v2[i]; i++); if (i == v1.dimension()) return 0; return (v1[i] < v2[i]) ? -1 : 1; } template std::ostream& operator<<(std::ostream& os, const Vector_& v) /*{\Xbinopfunc writes |\Mvar| componentwise to the output stream $O$.}*/ { /* syntax: d x_0 x_1 ... x_d-1 */ int d = v.dimension(); switch (os.iword(CGAL::IO::mode)) { case CGAL::IO::BINARY: CGAL::write( os, d); for ( int i = 0; i < d; ++i) CGAL::write( os, v[i]); break; case CGAL::IO::ASCII: os << d; for ( int i = 0; i < d; ++i) os << ' ' << v[i]; break; case CGAL::IO::PRETTY: os << "LA::Vector(" << d << " ["; for ( int i = 0; i < d; ++i) { if ( i > 0) os << ',' << ' '; os << v[i]; } os << "])"; break; } return os; } template std::istream& operator>>(std::istream& is, Vector_& v) /*{\Xbinopfunc reads |\Mvar| componentwise from the input stream $I$.}*/ { /* syntax: d x_0 x_1 ... x_d-1 */ int d; switch (is.iword(CGAL::IO::mode)) { case CGAL::IO::ASCII : case CGAL::IO::BINARY : is >> d; v = Vector_(d); for ( int i = 0; i < d; ++i) { is >> v[i]; } break; default: std::cerr<<"\nStream must be in ascii or binary mode"< typename Vector_::allocator_type Vector_::MM; /*{\Ximplementation Vectors are implemented by arrays of type |NT|. All operations on a vector |v| take time $O(|v.dimension()|)$, except for |dimension()| and $[\ ]$ which take constant time. The space requirement is $O(|v.dimension()|)$. }*/ } // CGALLA #endif // CGAL__VECTOR___H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transformationHd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transform0000644000175000017500000002171711344301501031266 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Aff_transformationHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_AFF_TRANSFORMATIONHD_H #define CGAL_AFF_TRANSFORMATIONHD_H #ifndef NOCGALINCL #include #include #include #include #endif CGAL_BEGIN_NAMESPACE template class Aff_transformationHd; template class Aff_transformationHd_rep; template class Aff_transformationHd_rep { friend class Aff_transformationHd; typedef typename LA::Matrix Matrix; Matrix M_; public: Aff_transformationHd_rep(int d) : M_(d+1) {} Aff_transformationHd_rep(const Matrix& M_init) : M_(M_init) {} ~Aff_transformationHd_rep() {} }; /*{\Moptions outfile=Aff_transformation_d.man}*/ /*{\Manpage{Aff_transformation_d}{R}{Affine Transformations}{t}}*/ /*{\Msubst Hd#_d Aff_transformationHd#Aff_transformation_d Quotient#FT }*/ template class Aff_transformationHd : public Handle_for< Aff_transformationHd_rep<_RT,_LA> > { typedef Aff_transformationHd_rep<_RT,_LA> Rep; typedef Handle_for Base; typedef Aff_transformationHd<_RT,_LA> Self; using Base::ptr; /*{\Mdefinition An instance of the data type |\Mname| is an affine transformation of $d$-dimensional space. It is specified by a square matrix $M$ of dimension $d + 1$. All entries in the last row of |M| except the diagonal entry must be zero; the diagonal entry must be non-zero. A point $p$ with homogeneous coordinates $(p[0], \ldots, p[d])$ can be transformed into the point |p.transform(A)|, where |A| is an affine transformation created from |M| by the constructors below. }*/ public: /*{\Mtypes 4}*/ typedef _RT RT; /*{\Mtypemember the ring type.}*/ typedef Quotient<_RT> FT; /*{\Mtypemember the field type.}*/ typedef _LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename _LA::Matrix Matrix; /*{\Mtypemember the matrix type.}*/ typedef typename _LA::Vector Vector; /*{\Mcreation 3}*/ Aff_transformationHd(int d = 0) : Base( Rep(d) ) {} /*{\Mcreate introduces a transformation in $d$-dimensional space.}*/ Aff_transformationHd(int d, Identity_transformation) : Base( Rep(d) ) /*{\Mcreate introduces the identity transformation in $d$-dimensional space.}*/ { for (int i = 0; i <= d; ++i) ptr()->M_(i,i) = RT(1); } Aff_transformationHd(const Matrix& M) : Base( Rep(M) ) /*{\Mcreate introduces the transformation of $d$ - space specified by matrix $M$. \precond |M| is a square matrix of dimension $d + 1$. }*/ { CGAL_assertion_msg((M.row_dimension()==M.column_dimension()), "Aff_transformationHd::\ construction: initialization matrix is not quadratic."); } template Aff_transformationHd(Scaling, Forward_iterator start, Forward_iterator end) : Base( Rep(std::distance(start,end)-1) ) /*{\Mcreate introduces the transformation of $d$-space specified by a diagonal matrix with entries |set [start,end)| on the diagonal (a scaling of the space). \precond |set [start,end)| is a vector of dimension $d+1$.}*/ { int i=0; while (start != end) { ptr()->M_(i,i) = *start++;++i; } } Aff_transformationHd(Translation, const VectorHd& v) : Base( Rep(v.dimension()) ) /*{\Mcreate introduces the translation by vector $v$.}*/ { register int d = v.dimension(); for (int i = 0; i < d; ++i) { ptr()->M_(i,i) = v.homogeneous(d); ptr()->M_(i,d) = v.homogeneous(i); } ptr()->M_(d,d) = v.homogeneous(d); } Aff_transformationHd(int d, Scaling, const RT& num, const RT& den) : Base( Rep(d) ) /*{\Mcreate returns a scaling by a scale factor |num/den|.}*/ { Matrix& M = ptr()->M_; for (int i = 0; i < d; ++i) M(i,i) = num; M(d,d) = den; } Aff_transformationHd(int d, Rotation, const RT& sin_num, const RT& cos_num, const RT& den, int e1 = 0, int e2 = 1) : Base( Rep(d) ) /*{\Mcreate returns a planar rotation with sine and cosine values |sin_num/den| and |cos_num/den| in the plane spanned by the base vectors $b_{e1}$ and $b_{e2}$ in $d$-space. Thus the default use delivers a planar rotation in the $x$-$y$ plane. \precond $|sin_num|^2 + |cos_num|^2 = |den|^2$ and $0 \leq e_1 < e_2 < d$}*/ { CGAL_assertion_msg((sin_num*sin_num + cos_num*cos_num == den*den), "planar_rotation: rotation parameters disobey precondition."); CGAL_assertion_msg((0<=e1 && e1<=e2 && e2M_; for (int i=0; i& dir, const RT& eps_num, const RT& eps_den, int e1 = 0, int e2 = 1) /*{\Mcreate returns a planar rotation within the plane spanned by the base vectors $b_{e1}$ and $b_{e2}$ in $d$-space. The rotation parameters are given by the $2$-dimensional direction |dir|, such that the difference between the sines and cosines of the rotation given by |dir| and the approximated rotation are at most |num/den| each.\\ \precond |dir.dimension()==2|, |!dir.is_degenerate()| and |num < den| is positive and $0 \leq e_1 < e_2 < d$ }*/ : Base( Rep(d) ) { CGAL_assertion(dir.dimension()==2); Matrix& M = ptr()->M_; for (int i=0; iM_.row_dimension()-1; } /*{\Mop the dimension of the underlying space }*/ const Matrix& matrix() const { return ptr()->M_; } /*{\Mop returns the transformation matrix }*/ Vector operator()(const Vector& iv) const // transforms the ivector by a matrix multiplication { return matrix()*iv; } bool is_odd() const /*{\Mop returns true iff |\Mvar| is odd.}*/ { return LA::sign_of_determinant(matrix())<0; } Aff_transformationHd inverse() const /*{\Mop returns the inverse transformation. \precond |\Mvar.matrix()| is invertible.}*/ { Aff_transformationHd Inv; RT D; Vector dummy; if ( !LA::inverse(matrix(),Inv.ptr()->M_,D,dummy) ) CGAL_assertion_msg(0,"Aff_transformationHd::inverse: not invertible."); if ( D < 0 ) Inv.ptr()->M_ = -Inv.ptr()->M_; return Inv; } Aff_transformationHd operator*(const Aff_transformationHd& s) const /*{\Mbinop composition of transformations. Note that transformations are not necessarily commutative. |t*s| is the transformation which transforms first by |t| and then by |s|.}*/ { CGAL_assertion_msg((dimension()==s.dimension()), "Aff_transformationHd::operator*: dimensions disagree."); return Aff_transformationHd(matrix()*s.matrix()); } bool operator==(const Aff_transformationHd& a1) const { if ( identical(a1) ) return true; return ( matrix() == a1.matrix() ); } bool operator!=(const Aff_transformationHd& a1) const { return !operator==(a1); } }; // Aff_transformationHd template std::ostream& operator<<( std::ostream& os, const Aff_transformationHd& t) { os << t.matrix(); return os; } template std::istream& operator>>( std::istream& is, Aff_transformationHd& t) { typename LA::Matrix M(t.dimension()); is >> M; t = Aff_transformationHd(M); return is; } /*{\Mimplementation Affine Transformations are implemented by matrices of integers as an item type. All operations like creation, initialization, input and output on a transformation $t$ take time $O(|t.dimension()|^2)$. |dimension()| takes constant time. The operations for inversion and composition have the cubic costs of the used matrix operations. The space requirement is $O(|t.dimension()|^2)$. }*/ // ----------------------------- end of file ---------------------------- CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATIONHD_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorHd.C0000644000175000017500000000511211344301501030365 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorHd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_VECTORHD_C #define CGAL_VECTORHD_C CGAL_BEGIN_NAMESPACE #define PointHd PointHd2 template PointHd VectorHd::to_point() const { return PointHd(Base(*this)); } template PointHd operator+ (const Origin&, const VectorHd& v) { return v.to_point(); } template DirectionHd VectorHd:: direction() const { CGAL_assertion_msg(!is_zero(), "VectorHd::direction: \ zero vector cannot be a direction."); return DirectionHd(*this); } template VectorHd VectorHd:: transform(const Aff_transformationHd& t) const { typename LA::Matrix m_at = t.matrix(); int d = t.dimension(); for (int i = 0; i < d; i++) m_at(i,d) = 0; typename LA::Vector res(m_at*vector_rep()); return VectorHd(dimension(),res.begin(),res.end()); } template std::istream& operator>>(std::istream& I, VectorHd& v) { v.copy_on_write(); v.ptr()->read(I); CGAL_assertion_msg((v.homogeneous(v.dimension()) > 0), "operator>>: denominator of vector must be larger than zero."); return I; } template std::ostream& operator<<(std::ostream& O, const VectorHd& v) { v.ptr()->print(O,"VectorHd"); return O; } template inline CGAL::io_Operator io_tag(const VectorHd&) { return CGAL::io_Operator(); } #undef PointHd CGAL_END_NAMESPACE #endif // CGAL_VECTORHD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Direction_d.h0000644000175000017500000000461611344301501031147 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Direction_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DIRECTION_D_H #define CGAL_DIRECTION_D_H CGAL_BEGIN_NAMESPACE template class Direction_d : public pR::Direction_d_base { public: typedef typename pR::Direction_d_base Base; typedef Direction_d Self; typedef pR R; typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::LA LA; typedef typename Base::Base_direction Base_direction; Direction_d(int d=0) : Base(d) {} Direction_d(int a, int b) : Base(a,b) {} Direction_d(const RT& a, const RT& b) : Base(a,b) {} Direction_d(int a, int b, int c) : Base(a,b,c) {} Direction_d(const RT& a, const RT& b, const RT& c) : Base(a,b,c) {} template Direction_d (int d, InputIterator first, InputIterator last) : Base(d, first, last) {} Direction_d(const Direction_d &d) : Base(d) {} Direction_d(const Vector_d &v) : Base(v) {} Direction_d(int d, Base_direction, int i) : Base(d,Base_direction(),i) {} Direction_d(const Base& p) : Base(p) {} Self operator-() const { return Base::operator-(); } Vector_d vector() const { return Base::vector(); } bool operator==(const Self& w) const { return Base::operator==(w); } bool operator!=(const Self& w) const { return Base::operator!=(w); } }; CGAL_END_NAMESPACE #endif //CGAL_DIRECTION_D_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_objects_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_0000644000175000017500000004466211344301501031350 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/intersection_objects_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : ? #ifndef CGAL_INTERSECTION_OBJECTS_D_H #define CGAL_INTERSECTION_OBJECTS_D_H CGAL_BEGIN_NAMESPACE template class Line_d_Line_d_pair { public: enum Intersection_result {NO, POINT, LINE}; typedef typename R::Point_d Point_d; typedef typename R::Line_d Line_d; typedef typename R::FT FT; protected: Line_d _l1, _l2; bool _known; Intersection_result _result; Point_d _ip; public: Line_d_Line_d_pair() : _known(false) {} Line_d_Line_d_pair(const Line_d& l1, const Line_d& l2) : _l1(l1), _l2(l2), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Line_d& result); }; template typename Line_d_Line_d_pair::Intersection_result Line_d_Line_d_pair::intersection_type() { if (_known) return _result; _known = true; //CGAL_assertion(!_l1.is_degenerate()&&!_l2.is_degenerate()); typedef typename R::Line_line_intersection_d Int_obj_type; Int_obj_type Intersect; FT l1,l2; typename Int_obj_type::Intersection_result res = Intersect(_l1.point(0),_l1.point(1), _l2.point(0),_l2.point(1), _ip,l1,l2); if (res == Int_obj_type::LINE) { return _result = LINE; } if (res == Int_obj_type::POINT) { return _result = POINT; } return _result = NO; } template bool Line_d_Line_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Line_d_Line_d_pair::intersection(Line_d& l) { if (!_known) intersection_type(); if (_result != LINE) return false; l = _l1; return true; } template class Line_d_Ray_d_pair { public: enum Intersection_result {NO, POINT, RAY}; typedef typename R::Point_d Point_d; typedef typename R::Ray_d Ray_d; typedef typename R::Line_d Line_d; typedef typename R::FT FT; protected: Line_d _l; Ray_d _r; bool _known; Intersection_result _result; Point_d _ip; public: Line_d_Ray_d_pair() : _known(false) {} Line_d_Ray_d_pair(const Line_d& l, const Ray_d& r) : _l(l), _r(r), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Ray_d& result); }; template typename Line_d_Ray_d_pair::Intersection_result Line_d_Ray_d_pair::intersection_type() { if (_known) return _result; _known = true; //CGAL_assertion(!_l.is_degenerate()&&!_r.is_degenerate()); typedef typename R::Line_line_intersection_d Int_obj_type; Int_obj_type Intersect; FT l1,l2; typename Int_obj_type::Intersection_result res = Intersect(_l.point(0),_l.point(1), _r.point(0),_r.point(1), _ip,l1,l2); if ( res == Int_obj_type::LINE ) { return _result = RAY; } if ( res == Int_obj_type::POINT && l2 >= FT(0) ) { return _result = POINT; } return _result = NO; } template bool Line_d_Ray_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Line_d_Ray_d_pair::intersection(Ray_d& r) { if (!_known) intersection_type(); if (_result != RAY) return false; r = _r; return true; } template class Line_d_Segment_d_pair { public: enum Intersection_result {NO, POINT, SEGMENT}; typedef typename R::Point_d Point_d; typedef typename R::Segment_d Segment_d; typedef typename R::Line_d Line_d; typedef typename R::FT FT; protected: Line_d _l; Segment_d _s; bool _known; Intersection_result _result; Point_d _ip; public: Line_d_Segment_d_pair() : _known(false) {} Line_d_Segment_d_pair(const Line_d& l, const Segment_d& s) : _l(l), _s(s), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Segment_d& result); }; template typename Line_d_Segment_d_pair::Intersection_result Line_d_Segment_d_pair::intersection_type() { if (_known) return _result; _known = true; //CGAL_assertion(!_l.is_degenerate()); if ( _s.is_degenerate() ) { if ( _l.has_on(_s.point(0)) ) { _ip = _s.point(0); return _result = POINT; } return _result = NO; } // _s not degenerate typedef typename R::Line_line_intersection_d Int_obj_type; Int_obj_type Intersect; FT l1,l2; typename Int_obj_type::Intersection_result res = Intersect(_l.point(0),_l.point(1), _s.point(0),_s.point(1), _ip,l1,l2); if ( res == Int_obj_type::LINE ) { return _result = SEGMENT; } if ( res == Int_obj_type::POINT && FT(0) <= l2 && l2 <= FT(1) ) { return _result = POINT; } return _result = NO; } template bool Line_d_Segment_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Line_d_Segment_d_pair::intersection(Segment_d& s) { if (!_known) intersection_type(); if (_result != SEGMENT) return false; s = _s; return true; } template class Ray_d_Ray_d_pair { public: enum Intersection_result { NO, POINT, SEGMENT, RAY }; typedef typename R::FT FT; typedef typename R::Point_d Point_d; typedef typename R::Segment_d Segment_d; typedef typename R::Ray_d Ray_d; protected: Ray_d _r1, _r2; bool _known; Intersection_result _result; Point_d _ip; Segment_d _is; Ray_d _ir; public: Ray_d_Ray_d_pair() : _known(false) {} Ray_d_Ray_d_pair(const Ray_d& r1, const Ray_d& r2) : _r1(r1), _r2(r2), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Segment_d& result); bool intersection(Ray_d& result); }; template typename Ray_d_Ray_d_pair::Intersection_result Ray_d_Ray_d_pair::intersection_type() { if (_known) return _result; _known = true; //CGAL_assertion((!_r1.is_degenerate()&&!_r2.is_degenerate()); // none of the lines should be trivial typedef typename R::Line_line_intersection_d Int_obj_type; Int_obj_type Intersect; FT l1,l2; typename Int_obj_type::Intersection_result res = Intersect(_r1.point(0),_r1.point(1), _r2.point(0),_r2.point(1),_ip,l1,l2); if (res == Int_obj_type::LINE) { if ( _r1.direction() == _r2.direction() ) { if ( _r1.has_on(_r2.source()) ) _ir = _r2; else _ir = _r1; return _result = RAY; } // now oppositely directed: if ( _r1.has_on(_r2.source()) ) { if ( _r1.source() != _r2.source() ) { _is = Segment_d(_r1.source(),_r2.source()); return _result = SEGMENT; } else { _ip = _r1.source(); return _result = POINT; } } return _result = NO; } if (res == Int_obj_type::POINT && FT(0) <= l1 && FT(0) <= l2) { return _result = POINT; } return _result = NO; // now not parallel } template bool Ray_d_Ray_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Ray_d_Ray_d_pair::intersection(Segment_d& s) { if (!_known) intersection_type(); if (_result != SEGMENT) return false; s = _is; return true; } template bool Ray_d_Ray_d_pair::intersection(Ray_d& r) { if (!_known) intersection_type(); if (_result != RAY) return false; r = _ir; return true; } template class Ray_d_Segment_d_pair { public: enum Intersection_result { NO, POINT, SEGMENT }; typedef typename R::FT FT; typedef typename R::Point_d Point_d; typedef typename R::Segment_d Segment_d; typedef typename R::Ray_d Ray_d; protected: Ray_d _r; Segment_d _s; bool _known; Intersection_result _result; Point_d _ip; Segment_d _is; public: Ray_d_Segment_d_pair() : _known(false) {} Ray_d_Segment_d_pair(const Ray_d& r, const Segment_d& s) : _r(r), _s(s), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Segment_d& result); }; template typename Ray_d_Segment_d_pair::Intersection_result Ray_d_Segment_d_pair::intersection_type() { if (_known) return _result; _known = true; //CGAL_assertion(!_r.is_degenerate()); if ( _s.is_degenerate() ) { if ( _r.has_on(_s.point(0)) ) { _ip = _s.point(0); return _result = POINT; } return _result = NO; } // now s is not degenerate typedef typename R::Line_line_intersection_d Int_obj_type; Int_obj_type Intersect; FT l1,l2; typename Int_obj_type::Intersection_result res = Intersect(_r.point(0),_r.point(1), _s.point(0),_s.point(1),_ip,l1,l2); if (res == Int_obj_type::LINE) { Point_d p1 = _s.point(0), p2 = _s.point(1); if ( _s.direction() != _r.direction() ) std::swap(p1,p2); // now order p2 after p1 on r underlying line typename R::Position_on_line_d pos; pos(p1, _r.point(0),_r.point(1), l1); pos(p2, _r.point(0),_r.point(1), l2); if ( l1 < FT(0) ) p1 = _r.point(0); if ( l2 < FT(0) ) { return _result = NO; } if ( p1 == p2 ) { _ip = p1; return _result = NO; } _is = Segment_d(p1,p2); return _result = SEGMENT; } if (res == Int_obj_type::POINT && FT(0) <= l1 && FT(0) <= l2 && l2 <= FT(1)) { return _result = POINT; } return _result = NO; // now not parallel } template bool Ray_d_Segment_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Ray_d_Segment_d_pair::intersection(Segment_d& s) { if (!_known) intersection_type(); if (_result != SEGMENT) return false; s = _is; return true; } template class Segment_d_Segment_d_pair { public: enum Intersection_result { NO, POINT, SEGMENT }; typedef typename R::FT FT; typedef typename R::Point_d Point_d; typedef typename R::Segment_d Segment_d; protected: Segment_d _s1,_s2; bool _known; Intersection_result _result; Point_d _ip; Segment_d _is; public: Segment_d_Segment_d_pair() : _known(false) {} Segment_d_Segment_d_pair(const Segment_d& s1, const Segment_d& s2) : _s1(s1), _s2(s2), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Segment_d& result); }; template typename Segment_d_Segment_d_pair::Intersection_result Segment_d_Segment_d_pair::intersection_type() { if (_known) return _result; _known = true; if ( _s1.is_degenerate() ) { if ( _s2.is_degenerate() ) { if ( _s1.point(0) == _s2.point(0) ) { _ip = _s1.point(0); return _result = POINT; } else { return _result = NO; } } else { if ( _s2.has_on(_s1.point(0)) ) { _ip = _s1.point(0); return _result = POINT; } else { return _result = NO; } } } if ( _s2.is_degenerate() ) { CGAL_assertion( !_s1.is_degenerate() ); if ( _s1.has_on(_s2.point(0)) ) { _ip = _s2.point(0); return _result = POINT; } else { return _result = NO; } } // now s1,s2 not degenerate typedef typename R::Line_line_intersection_d Int_obj_type; Int_obj_type Intersect; FT l1,l2; typename Int_obj_type::Intersection_result res = Intersect(_s1.point(0),_s1.point(1), _s2.point(0),_s2.point(1),_ip,l1,l2); if (res == Int_obj_type::LINE) { Point_d p1 = _s1.min(), p2 = _s1.max(); Point_d q1 = _s2.min(), q2 = _s2.max(); Point_d s,t; // now order the for points along the line typename R::Position_on_line_d pos; pos(p1, q1, q2, l1); pos(p2, q1, q2, l2); if ( l1 < FT(0) ) { if ( l2 < FT(0) ) { return _result = NO; } else { s = q1; } } else { s = p1; } // l1 >= 0 if ( l2 > FT(1) ) { if ( l1 > FT(1) ) { return _result = NO; } else { t = q2; } } else { t = p2; } // l2 <= 1 if ( s == t ) { _ip = s; return _result = POINT; } _is = Segment_d(s,t); return _result = SEGMENT; } if ( res == Int_obj_type::POINT && FT(0) <= l1 && l1 <= FT(1) && FT(0) <= l2 && l2 <= FT(1) ) { return _result = POINT; } return _result = NO; } template bool Segment_d_Segment_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Segment_d_Segment_d_pair::intersection(Segment_d& s) { if (!_known) intersection_type(); if (_result != SEGMENT) return false; s = _is; return true; } template class Line_d_Hyperplane_d_pair { public: enum Intersection_result {NO, POINT, LINE}; typedef typename R::Point_d Point_d; typedef typename R::Line_d Line_d; typedef typename R::Hyperplane_d Hyperplane_d; typedef typename R::FT FT; protected: Line_d _l; Hyperplane_d _h; bool _known; Intersection_result _result; Point_d _ip; public: Line_d_Hyperplane_d_pair() : _known(false) {} Line_d_Hyperplane_d_pair(const Line_d& l, const Hyperplane_d& h) : _l(l), _h(h), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Line_d& result); }; template typename Line_d_Hyperplane_d_pair::Intersection_result Line_d_Hyperplane_d_pair::intersection_type() { if (_known) return _result; _known = true; // CGAL_assertion_msg((!_l.is_degenerate())); typedef typename R::Line_hyperplane_intersection_d Int_obj_type; Int_obj_type Intersect; FT lambda; typename Int_obj_type::Intersection_result res = Intersect(_l.point(0),_l.point(1),_h,_ip,lambda); if (res == Int_obj_type::LINE) { return _result = LINE; } if (res == Int_obj_type::POINT) { return _result = POINT; } return _result = NO; } template bool Line_d_Hyperplane_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Line_d_Hyperplane_d_pair::intersection(Line_d& l) { if (!_known) intersection_type(); if (_result != LINE) return false; l = _l; return true; } template class Ray_d_Hyperplane_d_pair { public: enum Intersection_result {NO, POINT, RAY}; typedef typename R::FT FT; typedef typename R::Point_d Point_d; typedef typename R::Ray_d Ray_d; typedef typename R::Hyperplane_d Hyperplane_d; protected: Ray_d _r; Hyperplane_d _h; bool _known; Intersection_result _result; Point_d _ip; public: Ray_d_Hyperplane_d_pair() : _known(false) {} Ray_d_Hyperplane_d_pair(const Ray_d& r, const Hyperplane_d& h) : _r(r), _h(h), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Ray_d& result); }; template typename Ray_d_Hyperplane_d_pair::Intersection_result Ray_d_Hyperplane_d_pair::intersection_type() { if (_known) return _result; _known = true; // CGAL_assertion( !_r.is_degenerate() ); typedef typename R::Line_hyperplane_intersection_d Int_obj_type; Int_obj_type Intersect; FT lambda; typename Int_obj_type::Intersection_result res = Intersect(_r.point(0),_r.point(1),_h,_ip,lambda); if ( res == Int_obj_type::POINT && FT(0) <= lambda ) { return _result = POINT; } if ( res == Int_obj_type::LINE ) { return _result = RAY; } return _result = NO; } template bool Ray_d_Hyperplane_d_pair::intersection(Point_d& p) { if (!_known) intersection_type(); if (_result != POINT) return false; p = _ip; return true; } template bool Ray_d_Hyperplane_d_pair::intersection(Ray_d& r) { if (!_known) intersection_type(); if (_result != RAY) return false; r = _r; return true; } template class Segment_d_Hyperplane_d_pair { public: enum Intersection_result {NO, POINT, SEGMENT}; typedef typename R::FT FT; typedef typename R::Point_d Point_d; typedef typename R::Segment_d Segment_d; typedef typename R::Hyperplane_d Hyperplane_d; protected: Segment_d _s; Hyperplane_d _h; bool _known; Intersection_result _result; Point_d _ip; public: /*{\Mcreation 4}*/ Segment_d_Hyperplane_d_pair() : _known(false) {} Segment_d_Hyperplane_d_pair( const Segment_d& s, const Hyperplane_d& h) : _s(s), _h(h), _known(false) {} Intersection_result intersection_type(); bool intersection(Point_d& result); bool intersection(Segment_d& result); }; template typename Segment_d_Hyperplane_d_pair::Intersection_result Segment_d_Hyperplane_d_pair::intersection_type() { if (_known) return _result; _known = true; if ( _s.is_degenerate() ) if ( _h.has_on(_s.point(0)) ) { _ip = _s.point(0); return _result = POINT; } else { return _result = NO; } typedef typename R::Line_hyperplane_intersection_d Int_obj_type; Int_obj_type Intersect; FT lambda; typename Int_obj_type::Intersection_result res = Intersect(_s.point(0),_s.point(1),_h,_ip,lambda); if ( res == Int_obj_type::LINE ) { return _result = SEGMENT; } if ( res == Int_obj_type::POINT && FT(0) <= lambda && lambda <= FT(1) ) { return _result = POINT; } return _result = NO; } template bool Segment_d_Hyperplane_d_pair::intersection(Point_d& pt) { if (!_known) intersection_type(); if (_result != POINT) return false; pt = _ip; return true; } template bool Segment_d_Hyperplane_d_pair::intersection(Segment_d& s) { if (!_known) intersection_type(); if (_result != SEGMENT) return false; s = _s; return true; } CGAL_END_NAMESPACE #endif //CGAL_INTERSECTION_OBJECTS_D_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_objects.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_obje0000644000175000017500000001171611344301501031321 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_KERNEL_D_FUNCTION_OBJECTS_H #define CGAL_KERNEL_D_FUNCTION_OBJECTS_H // These functors come from the 2D-3D kernels. // Since they have changed there, they now need to be copied here. #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Construct { public: typedef ToBeConstructed result_type; ToBeConstructed operator()() const { return ToBeConstructed(); } template ToBeConstructed operator()( const A1& a1) const { return ToBeConstructed(a1); } template ToBeConstructed operator()( const A1& a1, const A2& a2) const { return ToBeConstructed(a1,a2); } template ToBeConstructed operator()( const A1& a1, const A2& a2, const A3& a3) const { return ToBeConstructed(a1,a2,a3); } template ToBeConstructed operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return ToBeConstructed(a1,a2,a3,a4); } template ToBeConstructed operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return ToBeConstructed(a1,a2,a3,a4,a5); } template ToBeConstructed operator()( const A& a1, const A& a2, const A& a3, const A& a4, const A& a5, const A& a6 ) const { return ToBeConstructed(a1,a2,a3,a4,a5,a6); } template ToBeConstructed operator()( const A& a1, const A& a2, const A& a3, const A& a4, const A& a5, const A& a6, const A& a7 ) const { return ToBeConstructed(a1,a2,a3,a4,a5,a6,a7); } template ToBeConstructed operator()( const A& a1, const A& a2, const A& a3, const A& a4, const A& a5, const A& a6, const A& a7, const A& a8, const A& a9) const { return ToBeConstructed(a1,a2,a3,a4,a5,a6,a7,a8,a9); } template ToBeConstructed operator()( const A& a1, const A& a2, const A& a3, const A& a4, const A& a5, const A& a6, const A& a7, const A& a8, const A& a9, const A& a10) const { return ToBeConstructed(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10); } template ToBeConstructed operator()( const A& a1, const A& a2, const A& a3, const A& a4, const A& a5, const A& a6, const A& a7, const A& a8, const A& a9, const A& a10,const A& a11,const A& a12) const { return ToBeConstructed(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12); } template ToBeConstructed operator()( const A& a1, const A& a2, const A& a3, const A& a4, const A& a5, const A& a6, const A& a7, const A& a8, const A& a9, const A& a10,const A& a11,const A& a12, const A& a13) const { return ToBeConstructed(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12,a13); } }; class Call_has_on_positive_side { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; template bool operator()( const Cls& c, const Arg& a) const { return c.has_on_positive_side(a); } }; class Call_oriented_side { public: typedef Oriented_side result_type; typedef Arity_tag< 2 > Arity; template Oriented_side operator()( const Cls& c, const Arg& a) const { return c.oriented_side(a); } }; class Intersect { public: typedef CGAL::Object result_type; typedef Arity_tag< 2 > Arity; template CGAL::Object operator()(const T1& t1, const T2& t2) const { return intersection( t1, t2); } }; } // end namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_KERNEL_D_FUNCTION_OBJECTS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Matrix__.h0000644000175000017500000005717711344301501030500 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Matrix__.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_MATRIX___H #define CGAL_MATRIX___H #include #include #include // for std::size_t, std::ptrdiff_t namespace CGALLA { template class column_iterator_ { ROW_ row_; unsigned i_; public: typedef column_iterator_ Self; typedef V_ value_type; typedef R_ reference; typedef P_ pointer; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; column_iterator_() : row_(),i_() {} column_iterator_(ROW_ row, unsigned i) : row_(row),i_(i) {} bool operator==( const Self& x) const { return row_ == x.row_ && i_ == x.i_; } bool operator!=( const Self& x) const { return !(*this == x); } R_ operator*() const { return (**row_)[i_]; } P_ operator->() const { return (**row_)+i_; } Self& operator++() { ++row_; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { --row_; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self operator+(difference_type i) const { return Self(row_+i,i_); } Self operator-(difference_type i) const { return Self(row_-i,i_); } difference_type operator-(const Self& x) const { return (row_ - x.row_); } }; template class component_iterator_ { ROW_ row_; // pointer to row int i_, n_; // offset and limit public: typedef component_iterator_ Self; typedef V_ value_type; typedef R_ reference; typedef P_ pointer; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; component_iterator_() : row_(),i_(),n_() {} component_iterator_(ROW_ row, int i, int n) : row_(row),i_(i),n_(n) {} bool operator==( const Self& x) const { return row_==x.row_ && i_==x.i_; } bool operator!=( const Self& x) const { return !(*this == x); } R_ operator*() const { return (**row_)[i_]; } P_ operator->() const { return (**row_)+i_; } Self& operator++() { ++i_; if (i_==n_) { ++row_; i_=0; } return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { --i_; if (i_<0) { --row_; i_=n_-1; } return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; /*{\Msubst # # Vector_#Vector Matrix_#Matrix }*/ /*{\Moptions print_title=yes}*/ /*{\Moptions outfile=Matrix.man}*/ /*{\Manpage {Matrix}{}{Matrices with NT Entries}{M}}*/ template class Matrix_ { /*{\Mdefinition An instance of data type |\Mname| is a matrix of variables of number type |NT|. The types |\Mname| and |Vector_| together realize many functions of basic linear algebra.}*/ public: /*{\Mtypes 6}*/ typedef Vector_* vector_pointer; typedef const Vector_* const_vector_pointer; typedef NT_ NT; /*{\Mtypemember the ring type of the components.}*/ typedef component_iterator_ iterator; /*{\Mtypemember bidirectional iterator for accessing all components row-wise.}*/ typedef component_iterator_ const_iterator; typedef NT* row_iterator; /*{\Mtypemember random access iterator for accessing row entries.}*/ typedef const NT* row_const_iterator; typedef column_iterator_ column_iterator; /*{\Mtypemember random access iterator for accessing column entries.}*/ typedef column_iterator_ column_const_iterator; /*{\Mtext There also constant versions of the above iterators: |const_iterator|, |row_const_iterator|, and |column_const_iterator|.}*/ class Identity {}; /*{\Mtypemember a tag class for identity initialization}*/ typedef Vector_ Vector; /*{\Mtypemember the vector type used.}*/ protected: vector_pointer* v_; int dm_,dn_; NT& elem(int i, int j) const { return v_[i]->v_[j]; } typedef typename AL_::template rebind::other allocator_type; static allocator_type MM; inline void allocate_mat_space(vector_pointer*& vi, int d) { /* We use this procedure to allocate memory. We use our allocator memory allocation scheme. There we first get an appropriate piece of memory and then initialize each cell by an inplace new. */ vi = MM.allocate(d); vector_pointer* p = vi + d - 1; while (p >= vi) { new (p) vector_pointer*(0); p--; } } inline void deallocate_mat_space(vector_pointer*& vi, int d) { /* deallocate memory via our AL_ object. */ MM.deallocate(vi,d); vi = (vector_pointer*)0; } inline void check_dimensions(const Matrix_& mat) const { CGAL_assertion_msg((dm_ == mat.dm_ && dn_ == mat.dn_), "Matrix::check_dimensions: incompatible matrix dimensions.") ; } public: /*{\Mcreation 5}*/ Matrix_() : dm_(0),dn_(0) { v_ = (Vector**)0; } /*{\Mcreate creates an instance |\Mvar| of type |\Mname|.}*/ Matrix_(int n); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| of dimension $n \times n$ initialized to the zero matrix.}*/ Matrix_(int m, int n); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| of dimension $m \times n$ initialized to the zero matrix.}*/ Matrix_(std::pair p); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| of dimension |p.first|$\times$|p.second| initialized to the zero matrix.}*/ Matrix_(int n , const Identity&, const NT& x = NT(1) ); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| of dimension $n \times n$ initialized to the identity matrix (times |x|).}*/ Matrix_(int m, int n, const NT& x); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| of dimension $m \times n$ initialized to the matrix with |x| entries.}*/ template void range_initialize(RAIterator first, RAIterator last, std::random_access_iterator_tag) { typedef typename std::iterator_traits::value_type value_type; typedef typename value_type::const_iterator const_iterator; dn_ = last-first; if (dn_ == 0) { dm_=0; v_=0; return; } dm_ = first->dimension(); if (dm_ > 0) { int i,j; allocate_mat_space(v_,dm_); for (i=0; ibegin(); it != first->end(); ++i, ++it) // row wise elem(i,j) = *it; } else v_ = (Vector**)0; } template void range_initialize(InputIterator first, InputIterator last, std::forward_iterator_tag) { typedef typename std::iterator_traits::value_type value_type; std::vector V(first,last); range_initialize(V.begin(),V.end(),std::random_access_iterator_tag()); } template Matrix_(Forward_iterator first, Forward_iterator last) /*{\Mcreate creates an instance |\Mvar| of type |\Mname|. Let $S$ be the ordered set of $n$ column-vectors of common dimension $m$ as given by the iterator range |[first,last)|. |\Mvar| is initialized to an $m \times n$ matrix with the columns as specified by $S$. \precond |Forward_iterator| has a value type |V| from which we require to provide a iterator type |V::const_iterator|, to have |V::value_type == NT|.\\ Note that |Vector_| or |std::vector| fulfill these requirements.}*/ { typedef typename std::iterator_traits::iterator_category iterator_category; range_initialize(first,last,iterator_category()); } Matrix_(const std::vector< Vector >& A) /*{\Mcreate creates an instance |\Mvar| of type |\Mname|. Let $A$ be an array of $n$ column-vectors of common dimension $m$. |\Mvar| is initialized to an $m \times n$ matrix with the columns as specified by $A$. }*/ { range_initialize(A.begin(),A.end(), std::random_access_iterator_tag()); } Matrix_(const Matrix_&); Matrix_(const Vector&); /* creates a $d \times 1$ matrix */ Matrix_(int, int, NT**); Matrix_& operator=(const Matrix_&); ~Matrix_(); /*{\Moperations 3 4}*/ int row_dimension() const { return dm_; } /*{\Mop returns $n$, the number of rows of |\Mvar|.}*/ int column_dimension() const { return dn_; } /*{\Mop returns $m$, the number of columns of |\Mvar|.}*/ std::pair dimension() const /*{\Mop returns $(m,n)$, the dimension pair of |\Mvar|.}*/ { return std::pair(dm_,dn_); } Vector& row(int i) const /*{\Mop returns the $i$-th row of |\Mvar| (an $m$ - vector).\\ \precond $0 \le i \le m - 1$. }*/ { CGAL_assertion_msg((0<=i && i& operator[](int i) const { CGAL_assertion_msg((0<=i && ibegin(); } row_iterator row_end(int i) /*{\Mop an iterator pointing beyond the last entry of the $i$th row. \precond $0\le i\le m-1$.}*/ { CGAL_assertion_msg((0<=i&&iend(); } row_const_iterator row_begin(int i) const { CGAL_assertion_msg(0<=i&&ibegin(); } row_const_iterator row_end(int i) const { CGAL_assertion_msg(0<=i&&iend(); } column_iterator column_begin(int i) /*{\Mop an iterator pointing to the first entry of the $i$th column. \precond $0\le i\le n-1$.}*/ { CGAL_assertion_msg(0<=i&&i& M1) const; /*{\Mbinop Test for equality. }*/ bool operator!=(const Matrix_& M1) const /*{\Mbinop Test for inequality. }*/ { return !(*this == M1); } /*{\Mtext \headerline{Arithmetic Operators}}*/ /*{\Mtext \settowidth{\typewidth}{|Matrix_m|} \addtolength{\typewidth}{\colsep} \callwidth2cm \computewidths \newcommand{\dimeq}[2]{ \\|M.row_dimension() == M1.row_dimension()| and \\|M.column_dimension() == M1.column_dimension()| } }*/ Matrix_ operator+ (const Matrix_& M1); /*{\Mbinop Addition. \precond \dimeq.}*/ Matrix_ operator- (const Matrix_& M1); /*{\Mbinop Subtraction. \precond \dimeq.}*/ Matrix_ operator-(); // unary /*{\Munop Negation.}*/ Matrix_& operator-=(const Matrix_&); Matrix_& operator+=(const Matrix_&); Matrix_ operator*(const Matrix_& M1) const; /*{\Mbinop Multiplication. \precond \\ |\Mvar.column_dimension() = M1.row_dimension()|. }*/ Vector_ operator*(const Vector_& vec) const { return ((*this) * Matrix_(vec)).to_vector(); } /*{\Mbinop Multiplication with vector. \precond \\ |\Mvar.column_dimension() = vec.dimension()|.}*/ Matrix_ compmul(const NT& x) const; static int compare(const Matrix_& M1, const Matrix_& M2); }; // end of class /*{\Xtext \headerline{Input and Output}}*/ template std::ostream& operator<<(std::ostream& os, const Matrix_& M); /*{\Xbinopfunc writes matrix |\Mvar| row by row to the output stream |os|.}*/ template std::istream& operator>>(std::istream& is, Matrix_& M); /*{\Xbinopfunc reads matrix |\Mvar| row by row from the input stream |is|.}*/ template Matrix_:: Matrix_(int dim) : dm_(dim),dn_(dim) { CGAL_assertion_msg((dim >= 0), "Matrix_::constructor: negative dimension."); if (dm_ > 0) { allocate_mat_space(v_,dm_); for (int i=0; i Matrix_:: Matrix_(int dim1, int dim2) : dm_(dim1),dn_(dim2) { CGAL_assertion_msg((dim1>=0 && dim2>=0), "Matrix_::constructor: negative dimension."); if (dm_ > 0) { allocate_mat_space(v_,dm_); for (int i=0; i Matrix_:: Matrix_(std::pair p) : dm_(p.first),dn_(p.second) { CGAL_assertion_msg((dm_>=0 && dn_>=0), "Matrix_::constructor: negative dimension."); if (dm_ > 0) { allocate_mat_space(v_,dm_); for (int i=0; i Matrix_:: Matrix_(int dim, const Identity&, const NT& x) : dm_(dim),dn_(dim) { CGAL_assertion_msg((dim >= 0), "matrix::constructor: negative dimension."); if (dm_ > 0) { allocate_mat_space(v_,dm_); for (int i=0; i Matrix_:: Matrix_(int dim1, int dim2, const NT& x) : dm_(dim1),dn_(dim2) { CGAL_assertion_msg((dim1>=0 && dim2>=0), "Matrix_::constructor: negative dimension."); if (dm_ > 0) { allocate_mat_space(v_,dm_); for (int i=0; i Matrix_:: Matrix_(const Matrix_& p) : dm_(p.dm_),dn_(p.dn_) { if (dm_ > 0) { allocate_mat_space(v_,dm_); for (int i=0; i**)0; } template Matrix_:: Matrix_(const Vector& v) : dm_(v.d_),dn_(1) { if (dm_>0) allocate_mat_space(v_,dm_); else v_ = (Vector_**)0; for(int i = 0; i < dm_; i++) { v_[i] = new Vector(1); elem(i,0) = v[i]; } } template Matrix_:: Matrix_(int dim1, int dim2, NT** p) : dm_(dim1),dn_(dim2) { CGAL_assertion_msg((dim1 >= 0 && dim2 >= 0), "Matrix_::constructor: negative dimension."); if (dm_ > 0) { allocate_mat_space(v_,dm_); for(int i=0; i(dn_); for(int j=0; j**)0; } template Matrix_& Matrix_:: operator=(const Matrix_& mat) { if (&mat == this) return *this; register int i,j; if (dm_ != mat.dm_ || dn_ != mat.dn_) { for(i=0; i0) allocate_mat_space(v_,dm_); for(i = 0; i < dm_; i++) v_[i] = new Vector(dn_); } for(i = 0; i < dm_; i++) for(j = 0; j < dn_; j++) elem(i,j) = mat.elem(i,j); return *this; } template Matrix_:: ~Matrix_() { if (v_) { for (int i=0; i inline bool Matrix_:: operator==(const Matrix_& x) const { register int i,j; if (dm_ != x.dm_ || dn_ != x.dn_) return false; for(i = 0; i < dm_; i++) for(j = 0; j < dn_; j++) if (elem(i,j) != x.elem(i,j)) return false; return true; } template Matrix_ Matrix_:: operator+ (const Matrix_& mat) { register int i,j; check_dimensions(mat); Matrix_ result(dm_,dn_); for(i=0; i Matrix_ Matrix_:: operator- (const Matrix_& mat) { register int i,j; check_dimensions(mat); Matrix_ result(dm_,dn_); for(i=0; i Matrix_ Matrix_:: operator- () // unary { register int i,j; Matrix_ result(dm_,dn_); for(i=0; i Matrix_& Matrix_:: operator-= (const Matrix_& mat) { register int i,j; check_dimensions(mat); for(i=0; i Matrix_& Matrix_:: operator+= (const Matrix_& mat) { register int i,j; check_dimensions(mat); for(i=0; i inline Matrix_ Matrix_:: operator*(const Matrix_& M1) const { CGAL_assertion_msg((dn_==M1.dm_), "Matrix_::operator*: incompatible matrix types."); Matrix_ result(dm_,M1.dn_); register int i,j,l; for (i=0; i inline Matrix_ Matrix_:: compmul(const NT& f) const { register int i,j; Matrix_ result(dm_,dn_); for(i=0; i Matrix_ operator*(const NT& x, const Matrix_& M) /*{\Mbinopfunc Multiplication of every entry with |x|. }*/ { return M.compmul(x); } template Matrix_ operator*(const Matrix_& M, const NT& x) /*{\Mbinopfunc Multiplication of every entry with |x|. }*/ { return M.compmul(x); } template int Matrix_:: compare(const Matrix_& M1, const Matrix_& M2) { register int i; int res; M1.check_dimensions(M2); for(i=0; i < M1.row_dimension() && (res = compare(M1.row(i),M2.row(i))) != 0; i++); return res; } template std::ostream& operator<<(std::ostream& os, const Matrix_& M) { /* syntax: d1 d2 x_0,0 ... x_0,d1-1 d2-times x_d2-1,0 ... x_d2-1,d1-1 */ int d = M.row_dimension(); int k = M.column_dimension(); switch (os.iword(CGAL::IO::mode)) { case CGAL::IO::BINARY: CGAL::write( os, d); CGAL::write( os, k); for ( int i = 0; i < d; ++i) { for ( register int j = 0; j < k; ++j) { CGAL::write( os, M[i][j]); } } break; case CGAL::IO::ASCII: os << d << ' ' << k; for ( int i = 0; i < d; ++i) { for ( register int j = 0; j < k; ++j) { os << ' ' << M[i][j]; } } break; case CGAL::IO::PRETTY: os << "LA::Matrix((" << d << ", " << k << " ["; for ( int i = 0; i < d; ++i) { for ( register int j = 0; j < k; ++j) { if ( j != 0) os << ',' << ' '; os << M[i][j]; } if ( i != d) os << ",\n"; } os << "])"; break; } return os; } template std::istream& operator>>(std::istream& is, Matrix_& M) { /* syntax: d1 d2 x_0,0 ... x_0,d1-1 d2-times x_d2,0 ... x_d2,d1-1 */ int cdim, rdim, i; switch(is.iword(CGAL::IO::mode)) { case CGAL::IO::BINARY : CGAL::read(is,rdim); CGAL::read(is,cdim); for (i=0; i> rdim >> cdim; M = Matrix_(rdim,cdim); for (i=0; i> M(i/rdim,i%cdim); break; default: std::cerr<<"\nStream must be in ascii or binary mode"< typename Matrix_::allocator_type Matrix_::MM; /*{\Ximplementation The data type |\Mname| is implemented by two-dimensional arrays of variables of type |NT|. The memory layout is row oriented. Operation |column| takes time $O(n)$, |row|, |dim1|, |dim2| take constant time, and all other operations take time $O(nm)$. The space requirement is $O(nm)$.}*/ } // CGALLA #endif // CGAL_MATRIX___H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionHd.C0000644000175000017500000000566411344301501031057 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionHd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DIRECTIONHD_C #define CGAL_DIRECTIONHD_C CGAL_BEGIN_NAMESPACE template DirectionHd::DirectionHd(const VectorHd& v) : Base(v) {} template VectorHd DirectionHd::vector() const { return VectorHd(*this); } template DirectionHd DirectionHd:: transform(const Aff_transformationHd& t) const { return vector().transform(t).direction(); } template Comparison_result DirectionHd:: cmp(const DirectionHd& h1, const DirectionHd& h2) { if (h1.identical(h2)) return EQUAL; int i, d = h1.dimension(); for (i = 0; i < d && h1.delta(i)==0 && h2.delta(i)==0; i++) ; // no body int c1 = CGAL_NTS sign(h1.delta(i)); int c2 = CGAL_NTS sign(h2.delta(i)); if (c1 != c2) return CGAL_NTS compare(c1,c2); RT s1 = (RT) CGAL_NTS sign(h2.delta(i)) * h2.delta(i); RT s2 = (RT) CGAL_NTS sign(h1.delta(i)) * h1.delta(i); i++; Comparison_result c; while (i < d) { c = CGAL_NTS compare(s1 * h1.delta(i), s2 * h2.delta(i)); if (c != EQUAL) return c; i++; } return EQUAL; } template std::istream& operator>>(std::istream& I, DirectionHd& dir) { dir.copy_on_write(); dir.ptr()->read(I); CGAL_assertion_msg((dir.D()>=0), "operator>>: denominator of direction must be nonnegative."); return I; } template std::ostream& operator<<(std::ostream& O, const DirectionHd& dir) { dir.ptr()->print(O,"DirectionHd"); return O; } template inline CGAL::io_Operator io_tag(const DirectionHd&) { return CGAL::io_Operator(); } //----------------------- end of file ---------------------------------- CGAL_END_NAMESPACE #endif // CGAL_DIRECTIONHD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Line_d.h0000644000175000017500000001657011344301501030120 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/Line_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_LINE_D_H #define CGAL_LINE_D_H #include #include #include CGAL_BEGIN_NAMESPACE template std::istream& operator>>(std::istream&, Line_d&); template std::ostream& operator<<(std::ostream&, const Line_d&); /*{\Manpage {Line_d}{R}{Lines in d-space}{l}}*/ template class Line_d : public Handle_for< Pair_d > { typedef Pair_d Pair; typedef Handle_for Base; typedef Line_d Self; using Base::ptr; /*{\Mdefinition An instance of data type |Line_d| is an oriented line in $d$-dimensional Euclidian space.}*/ public: /*{\Mtypes 5}*/ typedef p_R R; /*{\Mtypemember the representation type.}*/ typedef typename p_R::RT RT; /*{\Mtypemember the ring type.}*/ typedef typename p_R::FT FT; /*{\Mtypemember the field type.}*/ typedef typename p_R::LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename Vector_d::Base_vector Base_vector; friend class Ray_d; friend class Segment_d; private: Line_d(const Base& b) : Base(b) {} public: /*{\Mcreation 3}*/ Line_d() : Base( Pair() ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| and initializes it to some line in $d$ - dimensional space }*/ Line_d(const Point_d& p, const Point_d& q) /*{\Mcreate introduces a line through |p| and |q| and oriented from |p| to |q|. \precond $p$ and $q$ are distinct and have the same dimension.}*/ : Base( Pair(p,q) ) { CGAL_assertion_msg(!ptr()->is_degenerate(), "Line_d::constructor: the two points must be different." ); CGAL_assertion_msg((p.dimension()==q.dimension()), "Line_d::constructor: the two points must have the same dimension." ); } Line_d(const Point_d& p, const Direction_d& dir) /*{\Mcreate introduces a line through |p| with direction |dir|. \precond |p| and |dir| have the same dimension, |dir| is not trivial. }*/ : Base( Pair(p,p+dir.vector()) ) { CGAL_assertion_msg((p.dimension()==dir.dimension()), "Line_d::constructor: the p and dir must have the same dimension." ); CGAL_assertion_msg(!dir.is_degenerate(), "Line_d::constructor: dir must be non-degenerate." ); } Line_d(const Segment_d& s) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| and initializes it to the line through |s.source()| and |s.target()| with direction from |s.source()| to |s.target()|. \precond $s$ is not degenerate. }*/ : Base( s ) { CGAL_assertion_msg((!s.is_degenerate()), "Line_d::constructor: segment is trivial."); } Line_d(const Ray_d& r) : Base(r) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| and initializes it to the line through |r.point(1)| and |r.point(2)|. }*/ Line_d(const Line_d& l) : Base(l) {} /*{\Moperations 3 3}*/ int dimension() const { return (ptr()->_p[0].dimension()); } /*{\Mop returns the dimension of the underlying space.}*/ Point_d point(int i) const /*{\Mop returns an arbitrary point on |l|. It holds that |point(i) == point(j)|, iff |i==j|. Furthermore, |l| is directed from |point(i)| to |point(j)|, for all |i < j|.}*/ { return (ptr()->_p[i%2]); } Line_d opposite() const /*{\Mop returns the line |(point(2),point(1))|. }*/ { return Line_d(point(1),point(0)); } Direction_d direction() const /*{\Mop returns the direction of |\Mvar|. }*/ { return ptr()->direction(); } Line_d transform(const Aff_transformation_d & t) const /*{\Mop returns $t(l)$. }*/ { return Line_d(point(0).transform(t),point(1).transform(t)); } Line_d operator+(const Vector_d& v) const /*{\Mbinop returns |\Mvar+v|, i.e., |\Mvar| translated by vector $v$.}*/ { return Line_d(point(0)+v,point(1)+v); } Point_d projection(const Point_d& p) const /*{\Mop returns the point of intersection of |\Mvar| with the hyperplane that is orthogonal to |\Mvar| through |p|. }*/ { Vector_d v = direction().vector(); Point_d q = point(0); FT lambda = ((p-q) * v) / (v*v); Point_d res = q + lambda * v; return res; } bool has_on(const Point_d& p) const /*{\Mopl returns true if $p$ lies on |\Mvar| and false otherwise. }*/ { typename R::Position_on_line_d pos; FT dummy; return pos(p,point(0),point(1),dummy); } bool operator==(const Line_d& l1) const { if ( identical(l1) ) return true; if ( dimension() != l1.dimension() ) return false; return has_on(l1.point(0)) && direction() == l1.direction(); } bool operator!=(const Line_d& l1) const { return !operator==(l1); } friend std::istream& operator>> <> (std::istream&, Line_d&); friend std::ostream& operator<< <> (std::ostream&, const Line_d&); }; // end of class /*{\Mtext \headerline{Non-Member Functions} }*/ template bool weak_equality(const Line_d& l1, const Line_d& l2) /*{\Mfunc Test for equality as unoriented lines.}*/ { if (l1.identical(l2)) return true; if (l1.dimension()!=l2.dimension()) return false; return (l1.has_on(l2.point(0)) && l1.has_on(l2.point(1))); } template bool parallel(const Line_d& l1, const Line_d& l2) /*{\Mfunc returns true if |l1| and |l2| are parallel as unoriented lines and false otherwise. }*/ { return (l1.direction() == l2.direction() || l1.direction() == -l2.direction()); } template std::istream& operator>>(std::istream& I, Line_d& l) { l.copy_on_write(); l.ptr()->read(I); CGAL_assertion_msg(l.point(0)!=l.point(1), "Line_d::operator>>: trivial line."); CGAL_assertion_msg(l.point(0).dimension()==l.point(1).dimension(), "Line_d::operator>>: dimensions disagree."); return I; } template std::ostream& operator<<(std::ostream& O, const Line_d& l) { l.ptr()->print(O,"Line_d"); return O; } template inline CGAL::io_Operator io_tag(const Line_d&) { return CGAL::io_Operator(); } /*{\Mimplementation Lines are implemented by a pair of points as an item type. All operations like creation, initialization, tests, direction calculation, input and output on a line $l$ take time $O(|l.dimension()|)$. |dimension()|, coordinate and point access, and identity test take constant time. The operations for intersection calculation also take time $O(|l.dimension()|)$. The space requirement is $O(|l.dimension()|)$.}*/ CGAL_END_NAMESPACE #endif // CGAL_LINE_D_H //----------------------- end of file ---------------------------------- ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneHd.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneHd.0000644000175000017500000000735511344301501031142 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneHd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_HYPERPLANEHD_C #define CGAL_HYPERPLANEHD_C CGAL_BEGIN_NAMESPACE template VectorHd HyperplaneHd:: orthogonal_vector() const { VectorHd res(*this); res.copy_on_write(); res.entry(dimension()) = 1; return res; } template Comparison_result HyperplaneHd:: weak_cmp(const HyperplaneHd& h1, const HyperplaneHd& h2) { CGAL_assertion_msg((h1.dimension()==h2.dimension()), "HyperplaneHd::weak_cmp: dimensions disagree."); if(h1.identical(h2)) return EQUAL; int i, d = h1.dimension(); for (i = 0; i <= d && h1.coefficient(i) == 0 && h2.coefficient(i) == 0; i++); // no body if (h1.coefficient(i) == 0) return SMALLER; if (h2.coefficient(i) == 0) return LARGER; int s = CGAL_NTS sign(h1.coefficient(i)) * CGAL_NTS sign(h2.coefficient(i)); RT s1 = (RT)s * h2.coefficient(i); RT s2 = (RT)s * h1.coefficient(i); // |s1 * h1.coefficient(i)| is // $\Labs{ |h1.coefficient(i)*h2.coefficient(i)| }$ Comparison_result c; while (++i <= d) { c = CGAL_NTS compare(s1 * h1.coefficient(i), s2 * h2.coefficient(i)); if (c != EQUAL) return c; } return EQUAL; } template Comparison_result HyperplaneHd:: strong_cmp(const HyperplaneHd& h1, const HyperplaneHd& h2) { CGAL_assertion_msg((h1.dimension()==h2.dimension()), "HyperplaneHd::strong_cmp: dimensions disagree."); if (h1.identical(h2)) return EQUAL; int i; int d = h1.dimension(); for (i = 0; i <=d && h1.coefficient(i)==0 && h2.coefficient(i)==0; i++) ; // no body int c1 = CGAL_NTS sign(h1.coefficient(i)); int c2 = CGAL_NTS sign(h2.coefficient(i)); if (c1 != c2) return CGAL_NTS compare(c1,c2); RT s1 = (RT)CGAL_NTS sign(h2.coefficient(i)) * h2.coefficient(i); RT s2 = (RT)CGAL_NTS sign(h1.coefficient(i)) * h1.coefficient(i); Comparison_result c; while (++i <= d) { c = CGAL_NTS compare(s1 * h1.coefficient(i), s2 * h2.coefficient(i)); if (c != EQUAL) return c; } return EQUAL; } template std::istream& operator>>(std::istream& I, HyperplaneHd& h) { h.copy_on_write(); h.ptr()->read(I); return I; } template std::ostream& operator<<(std::ostream& O, const HyperplaneHd& h) { h.ptr()->print(O,"HyperplaneHd"); return O; } template inline CGAL::io_Operator io_tag(const HyperplaneHd&) { return CGAL::io_Operator(); } CGAL_END_NAMESPACE #endif // CGAL_HYPERPLANEHD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionHd.h0000644000175000017500000001715511344301501031122 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DIRECTIONHD_H #define CGAL_DIRECTIONHD_H #ifndef NOCGALINCL #include #include #endif #include #include #include #include CGAL_BEGIN_NAMESPACE template class DirectionHd; template std::istream& operator>>(std::istream&, DirectionHd&); template std::ostream& operator<<(std::ostream&, const DirectionHd&); /*{\Manpage{Direction_d}{R}{Directions in d-space}{dir}}*/ /*{\Msubst Hd#_d VectorHd#Vector_d DirectionHd#Direction_d Quotient#FT }*/ template class DirectionHd : public Handle_for< Tuple_d<_RT,_LA> > { typedef Tuple_d<_RT,_LA> Tuple; typedef Handle_for Base; typedef DirectionHd<_RT,_LA> Self; using Base::ptr; /*{\Mdefinition A |DirectionHd| is a vector in the $d$-dimensional vector space where we forget about its length. We represent directions in $d$-dimensional space as a tuple $(h_0,\ldots,h_d)$ of variables of type |RT| which we call the homogeneous coordinates of the direction. The coordinate $h_d$ must be positive. The Cartesian coordinates of a direction are $c_i = h_i/h_d$ for $0 \le i < d$, which are of type |Quotient|. Two directions are equal if their Cartesian coordinates are positive multiples of each other. Directions are in one-to-one correspondence to points on the unit sphere.}*/ const typename _LA::Vector& vector_rep() const { return ptr()->v; } _RT& entry(int i) { return ptr()->v[i]; } const _RT& entry(int i) const { return ptr()->v[i]; } void invert_rep() { ptr()->invert(); } public: /*{\Mtypes 4}*/ typedef _RT RT; /*{\Mtypemember the ring type.}*/ typedef Quotient<_RT> FT; /*{\Mtypemember the field type.}*/ typedef _LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename Tuple::const_iterator Delta_const_iterator; /*{\Mtypemember a read-only iterator for the deltas of |\Mvar|.}*/ class Base_direction {}; /*{\Mtypemember construction tag.}*/ friend class VectorHd; /*{\Mcreation 4}*/ DirectionHd(int d = 0) : Base( Tuple(d+1) ) /*{\Mcreate introduces a variable |\Mvar| of type |DirectionHd| initialized to some direction in $d$-dimensional space.}*/ { if (d>0) entry(d) = 1; } DirectionHd(const VectorHd& v); /*{\Mcreate introduces a variable |\Mvar| of type |DirectionHd| initialized to the direction of |v|.}*/ template DirectionHd(int d, InputIterator first, InputIterator last) : Base( Tuple(d+1,first,last,1) ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in dimension |d| with representation tuple |set [first,last)|. \precond |d| is nonnegative, |[first,last)| has |d| elements and the value type of |InputIterator| is |RT|.}*/ DirectionHd(int d, Base_direction, int i) : Base( Tuple(d+1) ) /*{\Mcreate returns a variable |\Mvar| of type |\Mname| initialized to the direction of the $i$-th base vector of dimension $d$. \precond $0 \leq i < d$.}*/ { entry(d) = 1; if ( d==0 ) return; CGAL_assertion_msg((0<=i&&i& p) : Base(p) {} ~DirectionHd() {} /*{\Moperations 5 3}*/ int dimension() const { return ptr()->size()-1; } /*{\Mop returns the dimension of |\Mvar|. }*/ RT delta(int i) const /*{\Mop returns the $i$-th component of |\Mvar|. \precond $0 \leq i < d$.}*/ { CGAL_assertion_msg((0<=i && i<(dimension())), "DirectionHd::delta():\ index out of range."); return entry(i); } RT D() { return entry(dimension()); } RT operator[](int i) const /*{\Marrop returns the $i$-th delta of |\Mvar|. \precond $0 \leq i < d$.}*/ { return delta(i); } Delta_const_iterator deltas_begin() const { return ptr()->begin(); } /*{\Mop returns an iterator pointing to the first delta of |\Mvar|. }*/ Delta_const_iterator deltas_end() const { return ptr()->last(); } /*{\Mop returns an iterator pointing beyond the last delta of |\Mvar|. }*/ VectorHd vector() const; /*{\Mop returns a vector pointing in direction |\Mvar|. }*/ bool is_degenerate() const /*{\Mop returns true iff |\Mvar.vector()| is the zero vector.}*/ { for (int i=0; i transform(const Aff_transformationHd& t) const; /*{\Mop returns $t(p)$. }*/ DirectionHd opposite() const /*{\Mop returns the direction opposite to |\Mvar|. }*/ { DirectionHd result(*this); // creates a copied object! result.copy_on_write(); // creates a copied object! result.ptr()->invert(dimension()); return result; } DirectionHd operator- () const /*{\Munop returns the direction opposite to |\Mvar|.}*/ { return opposite(); } static Comparison_result cmp( const DirectionHd& h1, const DirectionHd& h2); bool operator==(const DirectionHd& w) const { if ( identical(w) ) return true; if ( dimension()!=w.dimension() ) return false; return (DirectionHd::cmp(*this,w) == EQUAL); } bool operator!=(const DirectionHd& w) const { return !operator==(w); } /*{\Mtext \headerline{Downward compatibility} We provide all operations of the lower dimensional interface |dx()|, |dy()|, |dz()|.}*/ RT dx() const { return delta(0); } RT dy() const { return delta(1); } RT dz() const { return delta(2); } friend std::istream& operator>> <> (std::istream& I, DirectionHd& d); friend std::ostream& operator<< <> (std::ostream& O, const DirectionHd& d); }; // end of class DirectionHd /*{\Mimplementation Directions are implemented by arrays of integers as an item type. All operations like creation, initialization, tests, inversion, input and output on a direction $d$ take time $O(|d.dimension()|)$. |dimension()|, coordinate access and conversion take constant time. The space requirement is $O(|d.dimension()|)$. }*/ CGAL_END_NAMESPACE #endif // CGAL_DIRECTIONHD_H //----------------------- end of file ---------------------------------- ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneCd.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneCd.0000644000175000017500000000740111344301501031125 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneCd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_HYPERPLANECD_C #define CGAL_HYPERPLANECD_C CGAL_BEGIN_NAMESPACE template VectorCd HyperplaneCd:: orthogonal_vector() const { return VectorCd(dimension(),coefficients_begin(), coefficients_end()-1); } template Comparison_result HyperplaneCd:: weak_cmp(const HyperplaneCd& h1, const HyperplaneCd& h2) { CGAL_assertion_msg((h1.dimension()==h2.dimension()), "HyperplaneCd::weak_cmp: dimensions disagree."); if(h1.identical(h2)) return EQUAL; int i, d = h1.dimension(); for (i = 0; i <= d && h1.coefficient(i) == FT(0) && h2.coefficient(i) == FT(0); i++); // no body if (h1.coefficient(i) == FT(0)) return SMALLER; if (h2.coefficient(i) == FT(0)) return LARGER; int s = CGAL_NTS sign(h1.coefficient(i)) * CGAL_NTS sign(h2.coefficient(i)); FT s1 = (FT)s * h2.coefficient(i); FT s2 = (FT)s * h1.coefficient(i); // |s1 * h1.coefficient(i)| is // $\Labs{ |h1.coefficient(i)*h2.coefficient(i)| }$ Comparison_result c; while (++i <= d) { c = CGAL_NTS compare(s1 * h1.coefficient(i), s2 * h2.coefficient(i)); if (c != EQUAL) return c; } return EQUAL; } template Comparison_result HyperplaneCd:: strong_cmp(const HyperplaneCd& h1, const HyperplaneCd& h2) { CGAL_assertion_msg((h1.dimension()==h2.dimension()), "HyperplaneCd::strong_cmp: dimensions disagree."); if (h1.identical(h2)) return EQUAL; int i; int d = h1.dimension(); for (i = 0; i <=d && h1.coefficient(i)==FT(0) && h2.coefficient(i)==FT(0); i++) ; // no body int c1 = CGAL_NTS sign(h1.coefficient(i)); int c2 = CGAL_NTS sign(h2.coefficient(i)); if (c1 != c2) return CGAL_NTS compare(c1,c2); FT s1 = (FT)CGAL_NTS sign(h2.coefficient(i)) * h2.coefficient(i); FT s2 = (FT)CGAL_NTS sign(h1.coefficient(i)) * h1.coefficient(i); Comparison_result c; while (++i <= d) { c = CGAL_NTS compare(s1 * h1.coefficient(i), s2 * h2.coefficient(i)); if (c != EQUAL) return c; } return EQUAL; } template std::istream& operator>>(std::istream& I, HyperplaneCd& h) { h.copy_on_write(); h.ptr()->read(I); return I; } template std::ostream& operator<<(std::ostream& O, const HyperplaneCd& h) { h.ptr()->print(O,"HyperplaneCd"); return O; } template inline CGAL::io_Operator io_tag(const HyperplaneCd&) { return CGAL::io_Operator(); } CGAL_END_NAMESPACE #endif // CGAL_HYPERPLANECD_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorHd.h0000644000175000017500000003425111344301501030440 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/VectorHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_VECTORHD_H #define CGAL_VECTORHD_H #ifndef NOCGALINCL #include #include #endif #include #include #include CGAL_BEGIN_NAMESPACE #define PointHd PointHd2 template class VectorHd; template std::istream& operator>>(std::istream&, VectorHd&); template std::ostream& operator<<(std::ostream&, const VectorHd&); /*{\Manpage {Vector_d}{R}{Vectors in d-space}{v}}*/ /*{\Msubst Hd#_d VectorHd#Vector_d PointHd#Point_d Quotient#FT }*/ template class VectorHd : public Handle_for< Tuple_d<_RT,_LA> > { typedef Tuple_d<_RT,_LA> Tuple; typedef Handle_for Base; typedef VectorHd<_RT,_LA> Self; using Base::ptr; using Base::copy_on_write; /*{\Mdefinition An instance of data type |\Mname| is a vector of Euclidean space in dimension $d$. A vector $r = (r_0,\ldots,r_{ d - 1})$ can be represented in homogeneous coordinates $(h_0,\ldots,h_d)$ of number type |RT|, such that $r_i = h_i/h_d$ which is of type |FT|. We call the $r_i$'s the Cartesian coordinates of the vector. The homogenizing coordinate $h_d$ is positive. This data type is meant for use in computational geometry. It realizes free vectors as opposed to position vectors (type |PointHd|). The main difference between position vectors and free vectors is their behavior under affine transformations, e.g., free vectors are invariant under translations.}*/ const typename _LA::Vector& vector_rep() const { return ptr()->v; } _RT& entry(int i) { return ptr()->v[i]; } const _RT& entry(int i) const { return ptr()->v[i]; } void invert_rep() { ptr()->invert(); } VectorHd(const Base& b) : Base(b) {} public: /*{\Mtypes 4}*/ typedef _RT RT; /*{\Mtypemember the ring type.}*/ typedef Quotient<_RT> FT; /*{\Mtypemember the field type.}*/ typedef _LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename Tuple::Cartesian_const_iterator Cartesian_const_iterator; /*{\Mtypemember a read-only iterator for the Cartesian coordinates.}*/ typedef typename Tuple::const_iterator Homogeneous_const_iterator; /*{\Mtypemember a read-only iterator for the homogeneous coordinates.}*/ class Base_vector {}; /*{\Mtypemember construction tag.}*/ friend class PointHd; friend class DirectionHd; friend class HyperplaneHd; /*{\Mcreation 4}*/ VectorHd(int d = 0) : Base( Tuple(d+1) ) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $d$-dimensional space.}*/ { if ( d > 0 ) entry(d) = 1; } VectorHd(int d, Null_vector) : Base( Tuple(d+1) ) /*{\Mcreate introduces the zero vector |\Mvar| of type |\Mname| in $d$-dimensional space. There is a constant |CGAL::NULL_VECTOR| that can be used for the second argument.}*/ { if ( d > 0 ) entry(d) = 1; } template VectorHd(int d, InputIterator first, InputIterator last) : Base( Tuple(d+1,first,last) ) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in dimension |d|. If |size [first,last) == d| this creates a vector with Cartesian coordinates |set [first,last)|. If |size [first,last) == p+1| the range specifies the homogeneous coordinates $|H = set [first,last)| = (\pm h_0, \pm h_1, \ldots, \pm h_d)$ where the sign chosen is the sign of $h_d$. \precond |d| is nonnegative, |[first,last)| has |d| or |d+1| elements where the last has to be non-zero, and the value type of |InputIterator| is |RT|.}*/ { RT D = entry(d); if ( D == RT(0) ) entry(d) = 1; if ( D < RT(0) ) invert_rep(); } template VectorHd(int d, InputIterator first, InputIterator last, const RT& D) : Base( Tuple(d+1,first,last,D) ) /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in dimension |d| initialized to the vector with homogeneous coordinates as defined by |H = set [first,last)| and |D|: $(\pm |H[0]|, \pm|H[1]|, \ldots, \pm|H[d-1]|, \pm|D|)$. The sign chosen is the sign of $D$. \precond |D| is non-zero, the iterator range defines a $d$-tuple of |RT|, and the value type of |InputIterator| is |RT|. }*/ { CGAL_assertion_msg(D!=RT(0), "VectorHd::constructor: D must be nonzero."); if (D < RT(0)) invert_rep(); } VectorHd(int d, Base_vector, int i) : Base( Tuple(d+1) ) /*{\Mcreate returns a variable |\Mvar| of type |\Mname| initialized to the $i$-th base vector of dimension $d$. }*/ { entry(d) = 1; if ( d == 0 ) return; CGAL_assertion_msg((0<=i&&i& p) : Base(p) {} ~VectorHd() {} /*{\Moperations 5 3 }*/ int dimension() const { return ptr()->size()-1; } /*{\Mop returns the dimension of |\Mvar|. }*/ Quotient cartesian(int i) const /*{\Mop returns the $i$-th Cartesian coordinate of |\Mvar|. \precond $0 \leq i < d$.}*/ { CGAL_assertion_msg((0<=i && i<(dimension())), "VectorHd::cartesian():\ index out of range."); return Quotient(entry(i), entry(dimension())); } Quotient operator[](int i) const { return cartesian(i); } /*{\Marrop returns the $i$-th Cartesian coordinate of |\Mvar|. \precond $0 \leq i < d$.}*/ RT homogeneous(int i) const /*{\Mop returns the $i$-th homogeneous coordinate of |\Mvar|. \precond $0 \leq i \leq d$.}*/ { CGAL_assertion_msg((0<=i && i<=(dimension())), "VectorHd::homogeneous():\ index out of range."); return entry(i); } Quotient squared_length() const /*{\Mop returns the square of the length of |\Mvar|. }*/ { RT nom = 0; for (int i = 0; i < dimension(); i++) nom += CGAL_NTS square(homogeneous(i)); RT denom = CGAL_NTS square(homogeneous(dimension())); return Quotient(nom,denom); } Cartesian_const_iterator cartesian_begin() const /*{\Mop returns an iterator pointing to the zeroth Cartesian coordinate of |\Mvar|. }*/ { return Cartesian_const_iterator(ptr()->begin(),ptr()->last()); } Cartesian_const_iterator cartesian_end() const /*{\Mop returns an iterator pointing beyond the last Cartesian coordinate of |\Mvar|. }*/ { return Cartesian_const_iterator(ptr()->last(),ptr()->last()); } Homogeneous_const_iterator homogeneous_begin() const /*{\Mop returns an iterator pointing to the zeroth homogeneous coordinate of |\Mvar|. }*/ { return ptr()->begin(); } Homogeneous_const_iterator homogeneous_end() const /*{\Mop returns an iterator pointing beyond the last homogeneous coordinate of |\Mvar|. }*/ { return ptr()->end(); } inline PointHd to_point() const; inline DirectionHd direction() const; /*{\Mop returns the direction of |\Mvar|. }*/ VectorHd transform(const Aff_transformationHd& t) const; /*{\Mop returns $t(v)$. }*/ /*{\Mtext \headerline{Arithmetic Operators, Tests and IO}}*/ VectorHd scale(const RT& m, const RT& n) const { int d = dimension(); VectorHd result(d); result.entry(d) = entry(d) * n; for (int i = 0; i < d; i++) result.entry(i) = entry(i) * m; return result; } void self_scale(const RT& m, const RT& n) { int d = dimension(); copy_on_write(); entry(d) *= n; for (int i = 0; i < d; i++) entry(i) *= m; } VectorHd& operator*=(const RT& n) /*{\Mbinop multiplies all Cartesian coordinates by |n|.}*/ { self_scale(n,1); return *this; } VectorHd& operator*=(int n) { self_scale(n,1); return *this; } VectorHd& operator*=(const Quotient& r) /*{\Mbinop multiplies all Cartesian coordinates by |r|.}*/ { self_scale(r.numerator(),r.denominator()); return *this; } VectorHd operator/(int n) const { return scale(1,n); } VectorHd operator/(const RT& n) const /*{\Mbinop returns the vector with Cartesian coordinates $v_i/n, 0 \leq i < d$.}*/ { return scale(1,n); } VectorHd operator/(const Quotient& r) const /*{\Mbinop returns the vector with Cartesian coordinates $v_i/r, 0 \leq i < d$.}*/ { return scale(r.denominator(),r.numerator()); } VectorHd& operator/=(const RT& n) { self_scale(1,n); return *this; } /*{\Mbinop divides all Cartesian coordinates by |n|.}*/ VectorHd& operator/=(int n) { self_scale(1,n); return *this; } VectorHd& operator/=(const Quotient& r) { self_scale(r.denominator(),r.numerator()); return *this; } /*{\Mbinop divides all Cartesian coordinates by |r|.}*/ Quotient operator* (const VectorHd& w) const /*{\Mbinop inner product, i.e., $\sum_{ 0 \le i < d } v_i w_i$, where $v_i$ and $w_i$ are the Cartesian coordinates of $v$ and $w$ respectively. }*/ { int d = dimension(); CGAL_assertion_msg((d==w.dimension()), "inner product: dimensions disagree."); RT nom = 0; for (int i = 0; i < d; i++) nom += homogeneous(i) * w.homogeneous(i); RT denom = homogeneous(d) * w.homogeneous(d); return Quotient(nom,denom); } VectorHd operator+(const VectorHd& w) const /*{\Mbinop returns the vector with Cartesian coordinates $v_i+w_i, 0 \leq i < d$.}*/ { VectorHd res(dimension()); res.ptr()->homogeneous_add(ptr(), w.ptr()); return res; } VectorHd& operator+=(const VectorHd& w) /*{\Mbinop addition plus assignment.}*/ { int d = dimension(); VectorHd old(*this); *this = VectorHd(d); ptr()->homogeneous_add(old.ptr(), w.ptr()); return *this; } VectorHd operator-(const VectorHd& w) const /*{\Mbinop returns the vector with Cartesian coordinates $v_i-w_i, 0 \leq i < d$.}*/ { VectorHd res(dimension()); res.ptr()->homogeneous_sub(ptr(), w.ptr()); return res; } VectorHd& operator-=(const VectorHd& w) /*{\Mbinop subtraction plus assignment.}*/ { int d = dimension(); VectorHd old(*this); *this = VectorHd(d); ptr()->homogeneous_sub(old.ptr(), w.ptr()); return *this; } VectorHd operator-() const /*{\Munop returns the vector in opposite direction.}*/ { VectorHd result(*this); result.copy_on_write(); // creates a copied object! result.ptr()->invert(dimension()); return result; } static Comparison_result cmp( const VectorHd& x, const VectorHd& y) { Compare_homogeneously cmpobj; return cmpobj(x.vector_rep(),y.vector_rep()); } bool operator==(const VectorHd& w) const { if ( identical(w) ) return true; if ( dimension() != w.dimension() ) return false; return cmp(*this,w) == EQUAL; } bool operator!=(const VectorHd& w) const { return !operator==(w); } bool is_zero() const /*{\Mop returns true if |\Mvar| is the zero vector. }*/ { for (int i = 0; i < dimension(); i++) if ( homogeneous(i) != RT(0) ) return false; return true; } /*{\Mtext \headerline{Downward compatibility} We provide all operations of the lower dimensional interface |x()|, |y()|, |z()|, |hx()|, |hy()|, |hz()|, |hw()|.}*/ RT hx() const { return homogeneous(0); } RT hy() const { return homogeneous(1); } RT hz() const { return homogeneous(2); } RT hw() const { return homogeneous(dimension()); } Quotient x() const { return Quotient(hx(),hw());} Quotient y() const { return Quotient(hy(),hw());} Quotient z() const { return Quotient(hz(),hw());} friend std::istream& operator>> <> (std::istream& I, VectorHd& v); friend std::ostream& operator<< <> (std::ostream& O, const VectorHd& v); }; // end of class VectorHd template VectorHd operator*(const int& n, const VectorHd& v) { return v.scale(n,1); } template VectorHd operator*(const RT& n, const VectorHd& v) /*{\Mbinopfunc returns the vector with Cartesian coordinates $n v_i$.}*/ { return v.scale(n,1); } template VectorHd operator*(const Quotient& r, const VectorHd& v) /*{\Mbinopfunc returns the vector with Cartesian coordinates $r v_i, 0 \leq i < d$.}*/ { return v.scale(r.numerator(),r.denominator()); } /*{\Mimplementation Vectors are implemented by arrays of variables of type |RT|. All operations like creation, initialization, tests, vector arithmetic, input and output on a vector $v$ take time $O(|v.dimension()|)$. coordinate access, |dimension()| and conversions take constant time. The space requirement of a vector is $O(|v.dimension()|)$.}*/ #undef PointHd CGAL_END_NAMESPACE #endif // CGAL_VECTORHD_H //----------------------- end of file ---------------------------------- ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneHd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneHd.0000644000175000017500000003232511344301501031135 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/HyperplaneHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_HYPERPLANEHD_H #define CGAL_HYPERPLANEHD_H #ifndef NOCGALINCL #include #include #endif #include #include #include CGAL_BEGIN_NAMESPACE #define PointHd PointHd2 template std::istream& operator>>(std::istream&, HyperplaneHd&); template std::ostream& operator<<(std::ostream&, const HyperplaneHd&); /*{\Manpage{Hyperplane_d}{R}{Hyperplanes in d-space}{h}}*/ /*{\Msubst Hd#_d HyperplaneHd#Hyperplane_d Quotient#FT }*/ template class HyperplaneHd : public Handle_for< Tuple_d<_RT,_LA> > { typedef Tuple_d<_RT,_LA> Tuple; typedef Handle_for Base; typedef HyperplaneHd<_RT,_LA> Self; using Base::ptr; /*{\Mdefinition An instance of data type |HyperplaneHd| is an oriented hyperplane in $d$ - dimensional space. A hyperplane $h$ is represented by coefficients $(c_0,c_1,\ldots,c_d)$ of type |RT|. At least one of $c_0$ to $c_{ d - 1 }$ must be non-zero. The plane equation is $\sum_{ 0 \le i < d } c_i x_i + c_d = 0$, where $x_0$ to $x_{d-1}$ are Cartesian point coordinates. For a particular $x$ the sign of $\sum_{ 0 \le i < d } c_i x_i + c_d$ determines the position of a point $x$ with respect to the hyperplane (on the hyperplane, on the negative side, or on the positive side). There are two equality predicates for hyperplanes. The (weak) equality predicate (|weak_equality|) declares two hyperplanes equal if they consist of the same set of points, the strong equality predicate (|operator==|) requires in addition that the negative halfspaces agree. In other words, two hyperplanes are strongly equal if their coefficient vectors are positive multiples of each other and they are (weakly) equal if their coefficient vectors are multiples of each other.}*/ const typename _LA::Vector& vector_rep() const { return ptr()->v; } _RT& entry(int i) { return ptr()->v[i]; } const _RT& entry(int i) const { return ptr()->v[i]; } void invert_rep() { ptr()->invert(); } public: /*{\Mtypes 4}*/ typedef _RT RT; /*{\Mtypemember the ring type.}*/ typedef Quotient<_RT> FT; /*{\Mtypemember the field type.}*/ typedef _LA LA; /*{\Mtypemember the linear algebra layer.}*/ typedef typename Tuple::const_iterator Coefficient_const_iterator; /*{\Mtypemember a read-only iterator for the coefficients.}*/ /*{\Mcreation h 4}*/ /*{\Moptions nextwarning=no}*/ HyperplaneHd(int d = 0) : Base( Tuple(d+1) ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| initialized to some hyperplane in $d$ - dimensional space. }*/ template HyperplaneHd(int d, InputIterator first, InputIterator last) : Base( Tuple(d+1,first,last) ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| initialized to the hyperplane with coefficients |set [first,last)|. \precond |size [first,last) == d+1| and the value type of InputIterator is |RT|.}*/ template HyperplaneHd(int d, InputIterator first, InputIterator last, const RT& D) : Base( Tuple(d+1,first,last,D) ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| initialized to the hyperplane with coefficients |set [first,last)| and |D|. \precond |size [first,last) == d| and the value type of InputIterator is |RT|.}*/ /* We want to construct a hyperplane that passes through a set |P = set [first,last)| of points in $d$-dimensional space and has a specified point $o$ on a specified side. We simply have to find a vector $x$ such that $P^T \cdot x = 0$ for every point in $P$. This amounts to solving a homogeneous linear system. If the system has only a trivial solution the task at hand is unsolvable and we report an error. So assume that the system has a non-trivial solution. Let vectors $s_1, \ldots, s_k$ span the solution space. if |side == ZERO| we may take any $s_j$ as the normal vector of our hyperplane. if $|side| \neq 0$ and the task at hand is solvable there must be a $j$ such that $o^T \cdot s_j \neq 0$. We take $s_j$ as the normal vector of our hyperplane and use |o| to normalize the hyperplane equation. */ template void construct_from_points(ForwardIterator first, ForwardIterator last, const PointHd& o, Oriented_side side) { TUPLE_DIM_CHECK(first,last,hyperplane::construction); CGAL_assertion_msg((first->dimension()==o.dimension()), "hyperplane::construction: dimensions disagree."); int d = first->dimension(); // we are in $d$ - dimensional space int m = std::distance(first,last); // |P| has $m$ points typename LA::Matrix A(m,d + 1); for (int i = 0; i < m; i++) { /* define $i$-th equation */ for (int j = 0; j <= d; j++) A(i,j) = first->homogeneous(j); // $j$ - th coord of $i$-th point ++first; } typename LA::Matrix spanning_vecs; // columns span solution int dim = LA::homogeneous_linear_solver(A,spanning_vecs); if (dim == 0) CGAL_assertion_msg(0,"HyperplaneHd::constructor: \ set P is full dimensional."); if (side == ON_ORIENTED_BOUNDARY) { ptr()->v = spanning_vecs.column(0); return; } RT sum = 0; int j; for (j = 0; j < dim; j++) { for (int i = 0; i <= d; i++) sum += spanning_vecs(i,j)*o.homogeneous(i); if (sum != 0) break; } if (j == dim) CGAL_assertion_msg(0,"HyperplaneHd::constructor: \ cannot use o to determine side."); ptr()->v = spanning_vecs.column(j); if ( CGAL_NTS sign(sum) > 0 && side == ON_NEGATIVE_SIDE || CGAL_NTS sign(sum) < 0 && side == ON_POSITIVE_SIDE) invert_rep(); } template HyperplaneHd(ForwardIterator first, ForwardIterator last, const PointHd& o, Oriented_side side = Oriented_side(0)) /*{\Mcreate constructs some hyperplane that passes through the points in |set [first,last)|. If |side| is |ON_POSITIVE_SIDE| or |ON_NEGATIVE_SIDE| then |o| is on that side of the constructed hyperplane. \precond A hyperplane with the stated properties must exist. The value type of |ForwardIterator| is |PointHd|. }*/ : Base( Tuple(o.dimension()+1) ) { construct_from_points(first,last,o,side); } HyperplaneHd(const PointHd& p, const DirectionHd& dir) /*{\Mcreate constructs the hyperplane with normal direction |dir| that passes through $p$. The direction |dir| points into the positive side. \precond |dir| is not the trivial direction.}*/ : Base( Tuple(p.dimension()+1) ) { int d = p.dimension(); CGAL_assertion_msg((dir.dimension() == d), "HyperplaneHd::constructor: \ parameter dimensions disagree."); CGAL_assertion_msg((dir.dimension() == d), "HyperplaneHd::constructor: \ parameter dimensions disagree."); RT sum = 0; for (int i = 0; i < d; i++) { sum += dir.delta(i)*p.homogeneous(i); entry(i) = dir.delta(i)*p.homogeneous(d); } entry(d) = -sum; } HyperplaneHd(const RT& a, const RT& b, const RT& c) : Base( Tuple(a,b,c,MatchHelper()) ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $2$-dimensional space with equation $ax+by+c=0$. }*/ HyperplaneHd(int a, int b, int c) : Base( Tuple(RT(a),RT(b),RT(c),MatchHelper()) ) {} HyperplaneHd(const RT& a, const RT& b, const RT& c, const RT& d) : Base( Tuple(a,b,c,d) ) {} /*{\Mcreate introduces a variable |\Mvar| of type |\Mname| in $3$-dimensional space with equation $ax+by+cz+d=0$. }*/ HyperplaneHd(int a, int b, int c, int d) : Base( Tuple(RT(a),RT(b),RT(c),RT(d)) ) {} HyperplaneHd(const HyperplaneHd& h) : Base(h) {} ~HyperplaneHd() {} /*{\Moperations 4 2}*/ int dimension() const { return ptr()->size()-1; } /*{\Mop returns the dimension of |\Mvar|. }*/ RT operator[](int i) const /*{\Marrop returns the $i$-th coefficient of |\Mvar|. \precond $0 \leq i \leq d$.}*/ { CGAL_assertion_msg((0<=i && i<=(dimension())), "HyperplaneHd::op[]:\ index out of range."); return entry(i); } RT coefficient(int i) const { return entry(i); } /*{\Mop returns the $i$-th coefficient of |\Mvar|. \precond $0 \leq i \leq d$.}*/ const typename LA::Vector& coefficient_vector() const /*{\Xop returns the coefficient vector $(c_0,\ldots,c_d)$ of |\Mvar|. }*/ { return vector_rep(); } Coefficient_const_iterator coefficients_begin() const /*{\Mop returns an iterator pointing to the first coefficient.}*/ { return ptr()->begin(); } Coefficient_const_iterator coefficients_end() const /*{\Mop returns an iterator pointing beyond the last coefficient.}*/ { return ptr()->end(); } VectorHd orthogonal_vector() const; /*{\Mop returns the orthogonal vector of |\Mvar|. It points from the negative halfspace into the positive halfspace and its homogeneous coordinates are $(c_0, \ldots, c_{d - 1},1)$. }*/ DirectionHd orthogonal_direction() const /*{\Mop returns the orthogonal direction of |\Mvar|. It points from the negative halfspace into the positive halfspace. }*/ { return orthogonal_vector().direction(); } RT value_at(const PointHd& p) const /*{\Xop returns the value of |\Mvar| at the point |p|, i.e., $\sum_{ 0 \le i \le d } h_i p_i$.\\ Warning: this value depends on the particular representation of |\Mvar| and |p|. }*/ { CGAL_assertion_msg((dimension()==p.dimension()),"HyperplaneHd::value_at:\ dimensions disagree."); return vector_rep()*p.vector_rep(); } Oriented_side oriented_side(const PointHd& p) const /*{\Mop returns the side of the hyperplane |\Mvar| containing $p$. }*/ /*{\Mtext \setopdims{2cm}{2cm}}*/ { CGAL_assertion_msg((dimension()==p.dimension()), "HyperplaneHd::oriented_side: dimensions do not agree."); return Oriented_side(CGAL_NTS sign(value_at(p))); } bool has_on(const PointHd& p) const /*{\Mop returns true iff point |p| lies on the hyperplane |\Mvar|. }*/ { return (oriented_side(p) == ON_ORIENTED_BOUNDARY); } bool has_on_boundary(const PointHd& p) const /*{\Mop returns true iff point |p| lies on the boundary of hyperplane |\Mvar|. }*/ { return (oriented_side(p) == ON_ORIENTED_BOUNDARY); } bool has_on_positive_side(const PointHd& p) const /*{\Mop returns true iff point |p| lies on the positive side of hyperplane |\Mvar|. }*/ { return (oriented_side(p) == ON_POSITIVE_SIDE); } bool has_on_negative_side(const PointHd& p) const /*{\Mop returns true iff point |p| lies on the negative side of hyperplane |\Mvar|. }*/ { return (oriented_side(p) == ON_NEGATIVE_SIDE); } /*{\Mtext \restoreopdims }*/ HyperplaneHd transform(const Aff_transformationHd& t) const /*{\Mop returns $t(h)$.}*/ { Aff_transformationHd t_inv = t.inverse(); typename LA::Vector res = LA::transpose(t_inv.matrix())*vector_rep(); if ( t_inv.is_odd() ) res = -res; return HyperplaneHd(dimension(),res.begin(),res.end()); } /*{\Mtext \headerline{Non-Member Functions}}*/ static Comparison_result weak_cmp( const HyperplaneHd&, const HyperplaneHd&); static Comparison_result strong_cmp( const HyperplaneHd&, const HyperplaneHd&); bool operator==(const HyperplaneHd& h2) const { if (identical(h2)) return true; if (dimension()!=h2.dimension()) return false; return HyperplaneHd::strong_cmp(*this,h2) == EQUAL; } bool operator!=(const HyperplaneHd& h2) const { return !operator==(h2); } friend std::istream& operator>> <> (std::istream&, HyperplaneHd&); friend std::ostream& operator<< <> (std::ostream&, const HyperplaneHd&); }; // end of class HyperplaneHd template bool weak_equality(const HyperplaneHd& h1, const HyperplaneHd& h2) /*{\Mfunc test for weak equality. }*/ { if (h1.identical(h2)) return true; if (h1.dimension()!=h2.dimension()) return false; return HyperplaneHd::weak_cmp(h1,h2) == EQUAL; } /*{\Mimplementation Hyperplanes are implemented by arrays of integers as an item type. All operations like creation, initialization, tests, vector arithmetic, input and output on a hyperplane $h$ take time $O(|h.dimension()|)$. coordinate access and |dimension()| take constant time. The space requirement is $O(|h.dimension()|)$. }*/ #undef PointHd CGAL_END_NAMESPACE #endif // CGAL_HYPERPLANEHD_H //----------------------- end of file ---------------------------------- ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_objectsCd.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_obje0000644000175000017500000003246211344301501031322 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/function_objectsCd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel, Kurt Mehlhorn #ifndef CGAL_FUNCTION_OBJECTSCD_H #define CGAL_FUNCTION_OBJECTSCD_H #ifndef NOCGALINCL #include #include #endif #undef TRACE #undef TRACEN #undef TRACEV #define TRACE(t) std::cerr << t #define TRACEN(t) std::cerr << t << std::endl #define TRACEV(t) std::cerr << #t << " = " << (t) << std::endl CGAL_BEGIN_NAMESPACE template struct Lift_to_paraboloidCd { typedef typename R::Point_d Point_d; typedef typename R::FT FT; typedef typename R::LA LA; Point_d operator()(const Point_d& p) const { int d = p.dimension(); typename LA::Vector h(d+1); FT sum = 0; for (int i = 0; i struct Project_along_d_axisCd { typedef typename R::Point_d Point_d; typedef typename R::FT FT; Point_d operator()(const Point_d& p) const { return Point_d(p.dimension()-1, p.cartesian_begin(),p.cartesian_end()-1); } }; template struct MidpointCd { typedef typename R::Point_d Point_d; Point_d operator()(const Point_d& p, const Point_d& q) const { return Point_d(p + (q-p)/2); } }; template struct Center_of_sphereCd { typedef typename R::Point_d Point_d; typedef typename R::FT FT; typedef typename R::LA LA; template Point_d operator()(Forward_iterator start, Forward_iterator end) const { CGAL_assertion(start!=end); int d = start->dimension(); typename LA::Matrix M(d); typename LA::Vector b(d); Point_d pd = *start++; for (int i = 0; i < d; i++) { // we set up the equation for p_i Point_d pi = *start++; b[i] = 0; for (int j = 0; j < d; j++) { M(i,j) = FT(2)*(pi.cartesian(j) - pd.cartesian(j)); b[i] += (pi.cartesian(j) - pd.cartesian(j)) * (pi.cartesian(j) + pd.cartesian(j)); } } FT D; typename LA::Vector x; LA::linear_solver(M,b,x,D); return Point_d(d,x.begin(),x.end()); } }; // Center_of_sphereCd template struct Squared_distanceCd { typedef typename R::Point_d Point_d; typedef typename R::Vector_d Vector_d; typedef typename R::FT FT; FT operator()(const Point_d& p, const Point_d& q) const { Vector_d v = p-q; return v.squared_length(); } }; template struct Position_on_lineCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::FT FT; bool operator()(const Point_d& p, const Point_d& s, const Point_d& t, FT& l) const { int d = p.dimension(); CGAL_assertion_msg((d==s.dimension())&&(d==t.dimension()&& d>0), "position_along_line: argument dimensions disagree."); CGAL_assertion_msg((s!=t), "Position_on_line_d: line defining points are equal."); FT lnum = (p.cartesian(0) - s.cartesian(0)); FT lden = (t.cartesian(0) - s.cartesian(0)); FT num(lnum), den(lden), lnum_i, lden_i; for (int i = 1; i < d; i++) { lnum_i = (p.cartesian(i) - s.cartesian(i)); lden_i = (t.cartesian(i) - s.cartesian(i)); if (lnum*lden_i != lnum_i*lden) return false; if (lden_i != FT(0)) { den = lden_i; num = lnum_i; } } l = num/den; return true; } }; template struct Barycentric_coordinatesCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::FT FT; template OutputIterator operator()(ForwardIterator first, ForwardIterator last, const Point_d& p, OutputIterator result) { TUPLE_DIM_CHECK(first,last,Barycentric_coordinates_d); int n = std::distance(first,last); int d = p.dimension(); typename R::Affine_rank_d affine_rank; CGAL_assertion(affine_rank(first,last)==d); std::vector< Point_d > V(first,last); typename LA::Matrix M(d+1,V.size()); typename LA::Vector b(d+1), x; register int i; for (i=0; i struct OrientationCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; template Orientation operator()(ForwardIterator first, ForwardIterator last) { TUPLE_DIM_CHECK(first,last,Orientation_d); int d = std::distance(first,last); // range contains d points of dimension d-1 CGAL_assertion_msg(first->dimension() == d-1, "Orientation_d: needs first->dimension() + 1 many points."); typename LA::Matrix M(d); // quadratic for (int i = 0; i < d; ++first,++i) { for (int j = 0; j < d-1; ++j) M(i,j) = first->cartesian(j); M(i,d-1) = 1; } int row_correction = ( (d % 2 == 0) ? -1 : +1 ); // we invert the sign if the row number is even i.e. d is odd return Orientation(row_correction * LA::sign_of_determinant(M)); } }; template struct Side_of_oriented_sphereCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::FT FT; template Oriented_side operator()(ForwardIterator first, ForwardIterator last, const Point_d& x) { TUPLE_DIM_CHECK(first,last,Side_of_oriented_sphere_d); int d = std::distance(first,last); // |A| contains |d| points CGAL_assertion_msg((d-1 == first->dimension()), "Side_of_oriented_sphere_d: needs first->dimension()+1 many input points."); typename LA::Matrix M(d + 1); for (register int i = 0; i < d; ++first, ++i) { FT Sum = 0; M(i,0) = 1; for (register int j = 0; j < d-1; j++) { FT cj = first->cartesian(j); M(i,j + 1) = cj; Sum += cj*cj; } M(i,d) = Sum; } FT Sum = 0; M(d,0) = 1; for (register int j = 0; j < d-1; j++) { FT hj = x.cartesian(j); M(d,j + 1) = hj; Sum += hj*hj; } M(d,d) = Sum; return Oriented_side( - LA::sign_of_determinant(M) ); } }; template struct Side_of_bounded_sphereCd { typedef typename R::Point_d Point_d; template Bounded_side operator()(ForwardIterator first, ForwardIterator last, const Point_d& p) { TUPLE_DIM_CHECK(first,last,region_of_sphere); typename R::Orientation_d _orientation; Orientation o = _orientation(first,last); CGAL_assertion_msg((o != 0), "Side_of_bounded_sphere_d: \ A must be full dimensional."); typename R::Side_of_oriented_sphere_d _side_of_oriented_sphere; Oriented_side oside = _side_of_oriented_sphere(first,last,p); if (o == POSITIVE) { switch (oside) { case ON_POSITIVE_SIDE : return ON_BOUNDED_SIDE; case ON_ORIENTED_BOUNDARY: return ON_BOUNDARY; case ON_NEGATIVE_SIDE : return ON_UNBOUNDED_SIDE; } } else { switch (oside) { case ON_POSITIVE_SIDE : return ON_UNBOUNDED_SIDE; case ON_ORIENTED_BOUNDARY: return ON_BOUNDARY; case ON_NEGATIVE_SIDE : return ON_BOUNDED_SIDE; } } return ON_BOUNDARY; // never reached } }; template struct Contained_in_simplexCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; typedef typename R::FT FT; template bool operator()(ForwardIterator first, ForwardIterator last, const Point_d& p) { TUPLE_DIM_CHECK(first,last,Contained_in_simplex_d); int k = std::distance(first,last); // |A| contains |k| points int d = first->dimension(); CGAL_assertion_code( typename R::Affinely_independent_d check_independence; ) CGAL_assertion_msg(check_independence(first,last), "Contained_in_simplex_d: A not affinely independent."); CGAL_assertion(d==p.dimension()); typename LA::Matrix M(d + 1,k); typename LA::Vector b(d +1); for (register int j = 0; j < k; ++first, ++j) { for (register int i = 0; i < d; ++i) M(i,j) = first->cartesian(i); M(d,j) = 1; } for (register int i = 0; i < d; ++i) b[i] = p.cartesian(i); b[d] = 1; FT D; typename LA::Vector lambda; if ( LA::linear_solver(M,b,lambda,D) ) { for (int j = 0; j < k; j++) { if (lambda[j] < FT(0)) return false; } return true; } return false; } }; template struct Contained_in_affine_hullCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; template bool operator()(ForwardIterator first, ForwardIterator last, const Point_d& p) { TUPLE_DIM_CHECK(first,last,Contained_in_affine_hull_d); int k = std::distance(first,last); // |A| contains |k| points int d = first->dimension(); typename LA::Matrix M(d + 1,k); typename LA::Vector b(d + 1); for (register int j = 0; j < k; ++first, ++j) { for (register int i = 0; i < d; ++i) M(i,j) = first->cartesian(i); M(d,j) = 1; } for (register int i = 0; i < d; ++i) b[i] = p.cartesian(i); b[d] = 1; return LA::is_solvable(M,b); } }; template struct Affine_rankCd { typedef typename R::Point_d Point_d; typedef typename R::Vector_d Vector_d; typedef typename R::LA LA; template int operator()(ForwardIterator first, ForwardIterator last) { TUPLE_DIM_CHECK(first,last,Affine_rank_d); int k = std::distance(first,last); // |A| contains |k| points if (k == 0) return -1; if (k == 1) return 0; int d = first->dimension(); typename LA::Matrix M(d,--k); Point_d p0 = *first; ++first; // first points to second for (int j = 0; j < k; ++first, ++j) { Vector_d v = *first - p0; for (int i = 0; i < d; i++) M(i,j) = v.cartesian(i); } return LA::rank(M); } }; template struct Affinely_independentCd { typedef typename R::Point_d Point_d; typedef typename R::LA LA; template bool operator()(ForwardIterator first, ForwardIterator last) { typename R::Affine_rank_d rank; int n = std::distance(first,last); return rank(first,last) == n-1; } }; template struct Compare_lexicographicallyCd { typedef typename R::Point_d Point_d; typedef typename R::Point_d PointD; //MSVC hack Comparison_result operator()(const Point_d& p1, const Point_d& p2) { return PointD::cmp(p1,p2); } }; template struct Contained_in_linear_hullCd { typedef typename R::LA LA; typedef typename R::FT FT; typedef typename R::Vector_d Vector_d; template bool operator()( ForwardIterator first, ForwardIterator last, const Vector_d& x) { TUPLE_DIM_CHECK(first,last,Contained_in_linear_hull_d); int k = std::distance(first,last); // |A| contains |k| vectors int d = first->dimension(); typename LA::Matrix M(d,k); typename LA::Vector b(d); for (int i = 0; i < d; i++) { b[i] = x.cartesian(i); for (int j = 0; j < k; j++) M(i,j) = (first+j)->cartesian(i); } return LA::is_solvable(M,b); } }; template struct Linear_rankCd { typedef typename R::LA LA; template int operator()(ForwardIterator first, ForwardIterator last) { TUPLE_DIM_CHECK(first,last,linear_rank); int k = std::distance(first,last); // k vectors int d = first->dimension(); typename LA::Matrix M(d,k); for (int i = 0; i < d ; i++) for (int j = 0; j < k; j++) M(i,j) = (first + j)->cartesian(i); return LA::rank(M); } }; template struct Linearly_independentCd { typedef typename R::LA LA; template bool operator()(ForwardIterator first, ForwardIterator last) { typename R::Linear_rank_d rank; return rank(first,last) == std::distance(first,last); } }; template struct Linear_baseCd { typedef typename R::LA LA; typedef typename R::FT FT; typedef typename R::Vector_d Vector_d; template OutputIterator operator()(ForwardIterator first, ForwardIterator last, OutputIterator result) { TUPLE_DIM_CHECK(first,last,linear_base); int k = std::distance(first,last); // k vectors int d = first->dimension(); typename LA::Matrix M(d,k); for (int j = 0; j < k; ++first, ++j) for (int i = 0; i < d; i++) M(i,j) = first->cartesian(i); std::vector indcols; int r = LA::independent_columns(M,indcols); for (int l=0; l < r; l++) { typename LA::Vector v = M.column(indcols[l]); *result++ = Vector_d(d,v.begin(),v.end()); } return result; } }; CGAL_END_NAMESPACE #endif //CGAL_FUNCTION_OBJECTSCD_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionCd.C0000644000175000017500000000552411344301501031045 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_d/DirectionCd.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DIRECTIONCD_C #define CGAL_DIRECTIONCD_C CGAL_BEGIN_NAMESPACE template DirectionCd::DirectionCd(const VectorCd& v) : Base(v) {} template VectorCd DirectionCd::vector() const { return VectorCd(*this); } template DirectionCd DirectionCd:: transform(const Aff_transformationCd& t) const { return vector().transform(t).direction(); } template Comparison_result DirectionCd:: cmp(const DirectionCd& h1, const DirectionCd& h2) { if (h1.identical(h2)) return EQUAL; int i, d = h1.dimension(); for (i = 0; i < d && h1.delta(i)==FT(0) && h2.delta(i)==FT(0); ++i) ; // no body int c1 = CGAL_NTS sign(h1.delta(i)); int c2 = CGAL_NTS sign(h2.delta(i)); if (c1 != c2) return CGAL_NTS compare(c1,c2); FT s1 = (FT) CGAL_NTS sign(h2.delta(i)) * h2.delta(i); FT s2 = (FT) CGAL_NTS sign(h1.delta(i)) * h1.delta(i); i++; Comparison_result c; while (i < d) { c = CGAL_NTS compare(s1 * h1.delta(i), s2 * h2.delta(i)); if (c != EQUAL) return c; i++; } return EQUAL; } template std::istream& operator>>(std::istream& I, DirectionCd& dir) { dir.copy_on_write(); dir.ptr()->read(I); return I; } template std::ostream& operator<<(std::ostream& O, const DirectionCd& dir) { dir.ptr()->print(O,"DirectionCd"); return O; } template inline CGAL::io_Operator io_tag(const DirectionCd&) { return CGAL::io_Operator(); } CGAL_END_NAMESPACE #endif // CGAL_DIRECTIONCD_C //----------------------- end of file ---------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Number_type_traits.h0000644000175000017500000000406011344301500031050 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Number_type_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert, Michael Hoffmann #ifndef CGAL_NUMBER_TYPE_TRAITS_H #define CGAL_NUMBER_TYPE_TRAITS_H CGAL_BEGIN_NAMESPACE template < class NT > struct Number_type_traits { typedef typename NT::Has_exact_ring_operations Has_exact_ring_operations; typedef typename NT::Has_exact_division Has_exact_division; typedef typename NT::Has_exact_sqrt Has_exact_sqrt; typedef typename NT::Has_gcd Has_gcd; typedef typename NT::Has_division Has_division; typedef typename NT::Has_sqrt Has_sqrt; }; template < class Rational > struct Rational_traits { typedef Rational RT; const RT& numerator (const Rational& r) const { return r; } RT denominator (const Rational&) const { return RT(1); } Rational make_rational(const RT & n, const RT & d) const { return n / d; } }; // number type tags struct Ring_tag {}; struct Euclidean_ring_tag {}; struct Field_tag {}; struct Sqrt_field_tag {}; CGAL_END_NAMESPACE #endif // CGAL_NUMBER_TYPE_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/leda_rational.h0000644000175000017500000000560311344301500027773 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/leda_rational.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_LEDA_RATIONAL_H #define CGAL_LEDA_RATIONAL_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_false Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_true Has_exact_division; typedef Tag_false Has_exact_sqrt; }; template <> struct Rational_traits { typedef leda_integer RT; RT numerator (const leda_rational & r) const { return r.numerator(); } RT denominator (const leda_rational & r) const { return r.denominator(); } leda_rational make_rational(const RT & n, const RT & d) const { return leda_rational(n, d); } }; #ifndef CGAL_NO_NAMESPACE inline double to_double(const leda_rational &r) { return r.to_double(); } #endif // CGAL_NO_NAMESPACE inline bool is_finite(const leda_rational &) { return true; } inline bool is_valid(const leda_rational &) { return true; } inline io_Operator io_tag(const leda_rational &) { return io_Operator(); } #ifndef CGAL_CFG_NO_NAMESPACE inline Sign sign(const leda_rational& r) { return (Sign) CGAL_LEDA_SCOPE::sign(r); } #endif // CGAL_CFG_NO_NAMESPACE inline std::pair to_interval (const leda_rational & z) { // There's no guarantee about the error of to_double(), so I add 3 ulps... Protect_FPU_rounding P (CGAL_FE_TONEAREST); Interval_nt_advanced approx (z.to_double()); FPU_set_cw(CGAL_FE_UPWARD); approx += Interval_nt::smallest(); approx += Interval_nt::smallest(); approx += Interval_nt::smallest(); return approx.pair(); } CGAL_END_NAMESPACE #endif // CGAL_LEDA_RATIONAL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Extended_cartesian.h0000644000175000017500000003512611344301500030771 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Extended_cartesian.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_EXTENDED_CARTESIAN_H #define CGAL_EXTENDED_CARTESIAN_H #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 51 #include #include CGAL_BEGIN_NAMESPACE template class Extended_cartesian; /*{\Xanpage {Extended_cartesian}{}{An extended geometric kernel model}{K}}*/ template class Extended_cartesian : public CGAL::Simple_cartesian< CGAL::Nef_polynomial > { public: typedef CGAL::Simple_cartesian< CGAL::Nef_polynomial > Base; typedef Extended_cartesian Self; /*{\Xdefinition |\Mname| is a kernel model realizing the concept extended geometry. }*/ /*{\Xtypes 6.5}*/ /*{\Xtext \headerline{Affine kernel and types}}*/ typedef CGAL::Simple_cartesian Standard_kernel; /*{\Xtypemember the standard affine kernel.}*/ typedef typename Standard_kernel::RT Standard_RT; /*{\Xtypemember the standard ring type.}*/ typedef typename Standard_kernel::FT Standard_FT; /*{\Xtypemember the field type.}*/ typedef typename Standard_kernel::Point_2 Standard_point_2; /*{\Xtypemember standard points.}*/ typedef typename Standard_kernel::Segment_2 Standard_segment_2; /*{\Xtypemember standard segments.}*/ typedef typename Standard_kernel::Line_2 Standard_line_2; /*{\Xtypemember standard oriented lines.}*/ typedef typename Standard_kernel::Direction_2 Standard_direction_2; /*{\Xtypemember standard directions.}*/ typedef typename Standard_kernel::Ray_2 Standard_ray_2; /*{\Xtypemember standard rays.}*/ typedef typename Standard_kernel::Aff_transformation_2 Standard_aff_transformation_2; /*{\Xtypemember standard affine transformations.}*/ /*{\Xtext \headerline{Extended kernel types}}*/ typedef typename Base::RT RT; /*{\Xtypemember the ring type of our extended kernel.}*/ typedef typename Base::FT FT; /*{\Xtypemember the ring type of our extended kernel.}*/ typedef typename Base::Point_2 Point_2; /*{\Xtypemember extended points.}*/ typedef typename Base::Segment_2 Segment_2; /*{\Xtypemember extended segments.}*/ typedef typename Base::Line_2 Line_2; /*{\Xtypemember extended lines.}*/ typedef typename Base::Direction_2 Direction_2; /*{\Xtypemember extended directions.}*/ enum Point_type { SWCORNER=1, LEFTFRAME, NWCORNER, BOTTOMFRAME, STANDARD, TOPFRAME, SECORNER, RIGHTFRAME, NECORNER }; /*{\Xenum a type descriptor for extended points.}*/ Point_2 epoint(const Standard_FT& m1, const Standard_FT& n1, const Standard_FT& m2, const Standard_FT& n2) const { return Point_2(FT(n1,m1),FT(n2,m2)); } public: /*{\Xoperations 2}*/ /*{\Xtext \headerline{Interfacing the affine kernel types}}*/ Point_2 construct_point(const Standard_point_2& p) const /*{\Xop creates an extended point |Point_2| and initializes it to the standard point |p|.}*/ { return Point_2(p.x(), p.y()); } Point_2 construct_point(const Standard_line_2& l, Point_type& t) const /*{\Xop creates an extended point initialized to the equivalence class of all the rays underlying the oriented line |l|. |t| returns the type of the new extended point.}*/ { t = (Point_type)Line_to_epoint::determine_type(l); Point_2 res; switch (t) { case SWCORNER: res = epoint(-1, 0, -1, 0); break; case NWCORNER: res = epoint(-1, 0, 1, 0); break; case SECORNER: res = epoint( 1, 0, -1, 0); break; case NECORNER: res = epoint( 1, 0, 1, 0); break; case LEFTFRAME: res = epoint(-1, 0, l.a()/l.b(), -l.c()/l.b()); break; case RIGHTFRAME: res = epoint( 1, 0, -l.a()/l.b(), -l.c()/l.b()); break; case BOTTOMFRAME: res = epoint( l.b()/l.a(), -l.c()/l.a(), -1, 0); break; case TOPFRAME: res = epoint(-l.b()/l.a(), -l.c()/l.a(), 1, 0); break; default: CGAL_assertion_msg(0,"EPoint type not correct!"); } return res; } Point_2 construct_point(const Standard_point_2& p1, const Standard_point_2& p2, Point_type& t) const /*{\Xop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line |l(p1,p2)|. |t| returns the type of the new extended point.}*/ { return construct_point(Standard_line_2(p1,p2),t); } Point_2 construct_point(const Standard_line_2& l) const /*{\Xop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line |l|. }*/ { Point_type dummy; return construct_point(l,dummy); } Point_2 construct_point(const Standard_point_2& p1, const Standard_point_2& p2) const /*{\Xop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line |l(p1,p2)|.}*/ { return construct_point(Standard_line_2(p1,p2)); } Point_2 construct_point(const Standard_point_2& p, const Standard_direction_2& d) const /*{\Xop creates an extended point and initializes it to the equivalence class of all the rays underlying the ray starting in |p| in direction |d|.}*/ { return construct_point(Standard_line_2(p,d)); } Point_2 construct_opposite_point(const Standard_line_2& l) const /*{\Xop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line opposite to |l|. }*/ { Point_type dummy; return construct_point(l.opposite(),dummy); } Point_type type(const Point_2& p) const /*{\Xop determines the type of |p| and returns it.}*/ { CGAL_assertion(p.x().degree()>=0 && p.y().degree()>=0 ); if ( p.x().degree() == 0 && p.y().degree() == 0) return STANDARD; // now we are on the square frame FT rx = p.x(); FT ry = p.y(); int sx = CGAL_NTS sign(rx); int sy = CGAL_NTS sign(ry); if (sx < 0) rx = -rx; if (sy < 0) ry = -ry; if (rx>ry) { if (sx > 0) return RIGHTFRAME; else return LEFTFRAME; } if (rx 0) return TOPFRAME; else return BOTTOMFRAME; } // now (rx == ry) if (sx==sy) { if (sx < 0) return SWCORNER; else return NECORNER; } else { CGAL_assertion(sx==-sy); if (sx < 0) return NWCORNER; else return SECORNER; } } bool is_standard(const Point_2& p) const /*{\Xop returns |true| iff |p| is a standard point.}*/ { return (type(p)==STANDARD); } Standard_point_2 standard_point(const Point_2& p) const /*{\Xop returns the standard point represented by |p|. \precond |\Mvar.is_standard(p)|.}*/ { CGAL_assertion( type(p)==STANDARD ); return Standard_point_2(p.x()[0],p.y()[0]); } Standard_line_2 standard_line(const Point_2& p) const /*{\Xop returns the oriented line representing the bundle of rays defining |p|. \precond |!\Mvar.is_standard(p)|.}*/ { CGAL_assertion( type(p)!=STANDARD ); FT x = p.x(), y = p.y(); Standard_FT dx = x.degree()>0 ? x[1] : Standard_FT(0); Standard_FT dy = y.degree()>0 ? y[1] : Standard_FT(0); Standard_point_2 p0(x[0],y[0]); Standard_point_2 p1(x[0]+dx,y[0]+dy); return Standard_line_2(p0,p1); } Standard_ray_2 standard_ray(const Point_2& p) const /*{\Xop a ray defining |p|. \precond |!\Mvar.is_standard(p)|.}*/ { CGAL_assertion( type(p)!=STANDARD ); FT x = p.x(), y = p.y(); Standard_FT dx = x.degree()>0 ? x[1] : Standard_FT(0); Standard_FT dy = y.degree()>0 ? y[1] : Standard_FT(0); Standard_point_2 p0(x[0],y[0]); Standard_point_2 p1(x[0]+dx,y[0]+dy); return Standard_ray_2(p0,p1); } Point_2 NE() const { return construct_point(Standard_line_2(-1, 1,0)); } /*{\Xop returns the point on the north east frame corner.}*/ Point_2 SE() const { return construct_point(Standard_line_2( 1, 1,0)); } /*{\Xop returns the point on the south east frame corner.}*/ Point_2 NW() const { return construct_point(Standard_line_2(-1,-1,0)); } /*{\Xop returns the point on the north west frame corner.}*/ Point_2 SW() const { return construct_point(Standard_line_2( 1,-1,0)); } /*{\Xop returns the point on the south west frame corner.}*/ Line_2 upper() const { return construct_line(NW(),NE()); } /*{\Xop returns the line underlying the upper frame segment.}*/ Line_2 lower() const { return construct_line(SW(),SE()); } /*{\Xop returns the line underlying the lower frame segment.}*/ Line_2 left() const { return construct_line(SW(),NW()); } /*{\Xop returns the line underlying the left frame segment.}*/ Line_2 right() const { return construct_line(SE(),NE()); } /*{\Xop returns the line underlying the right frame segment.}*/ /*{\Xtext \headerline{Geometric kernel calls}}*/ Point_2 source(const Segment_2& s) const /*{\Xop returns the source point of |s|.}*/ { typename Base::Construct_vertex_2 _source = this->construct_vertex_2_object(); return _source(s,0); } Point_2 target(const Segment_2& s) const /*{\Xop returns the target point of |s|.}*/ { typename Base::Construct_vertex_2 _target = this->construct_vertex_2_object(); return _target(s,1); } Segment_2 construct_segment(const Point_2& p, const Point_2& q) const /*{\Xop constructs a segment |pq|.}*/ { typename Base::Construct_segment_2 _segment = this->construct_segment_2_object(); return _segment(p,q); } Line_2 construct_line(const Standard_line_2& l) const /*{\Xop returns an extended line.}*/ { return Line_2(l.a(),l.b(),l.c()); } Line_2 construct_line(const Point_2& p1, const Point_2& p2) const /*{\Xop returns a line through the two extended points |p1| and |p2|.}*/ { Line_2 l(p1,p2); CGAL_NEF_TRACEN("eline("<orientation_2_object(); return static_cast ( _orientation(source(s),target(s),p) ); } int orientation(const Point_2& p1, const Point_2& p2, const Point_2& p3) const /*{\Xop returns the orientation of |p2| with respect to the line through |p1p2|.}*/ { typename Base::Orientation_2 _orientation = this->orientation_2_object(); return static_cast ( _orientation(p1,p2,p3) ); } bool left_turn(const Point_2& p1, const Point_2& p2, const Point_2& p3) const /*{\Xop return true iff the |p3| is left of the line through |p1p2|.}*/ { return orientation(p1,p2,p3) > 0; } bool is_degenerate(const Segment_2& s) const /*{\Xop return true iff |s| is degenerate.}*/ { typename Base::Is_degenerate_2 _is_degenerate = this->is_degenerate_2_object(); return _is_degenerate(s); } int compare_xy(const Point_2& p1, const Point_2& p2) const /*{\Xop returns the lexicographic order of |p1| and |p2|.}*/ { typename Base::Compare_xy_2 _compare_xy = this->compare_xy_2_object(); return static_cast( _compare_xy(p1,p2) ); } int compare_x(const Point_2& p1, const Point_2& p2) const /*{\Xop returns the order on the $x$-coordinates of |p1| and |p2|.}*/ { typename Base::Compare_x_2 _compare_x = this->compare_x_2_object(); return static_cast( _compare_x(p1,p2) ); } int compare_y(const Point_2& p1, const Point_2& p2) const /*{\Xop returns the order on the $y$-coordinates of |p1| and |p2|.}*/ { typename Base::Compare_y_2 _compare_y = this->compare_y_2_object(); return static_cast( _compare_y(p1,p2) ); } Point_2 intersection( const Segment_2& s1, const Segment_2& s2) const /*{\Xop returns the point of intersection of the lines supported by |s1| and |s2|.}*/ { typename Base::Intersect_2 _intersect = this->intersect_2_object(); typename Base::Construct_line_2 _line = this->construct_line_2_object(); Point_2 p; Line_2 l1 = _line(s1); Line_2 l2 = _line(s2); CGAL::Object result = _intersect(l1, l2); if ( !CGAL::assign(p, result) ) CGAL_assertion_msg(false,"intersection: no intersection."); return p; } Direction_2 construct_direction( const Point_2& p1, const Point_2& p2) const /*{\Xop returns the direction of the vector |p2| - |p1|.}*/ { typename Base::Construct_direction_2 _direction = this->construct_direction_2_object(); return _direction(construct_line(p1,p2)); } bool strictly_ordered_ccw(const Direction_2& d1, const Direction_2& d2, const Direction_2& d3) const /*{\Xop returns |true| iff |d2| is in the interior of the counterclockwise angular sector between |d1| and |d3|.}*/ { if ( d1 < d2 ) return ( d2 < d3 )||( d3 <= d1 ); if ( d1 > d2 ) return ( d2 < d3 )&&( d3 <= d1 ); return false; } bool contains(const Segment_2& s, const Point_2& p) const /*{\Xop returns true iff |s| contains |p|.}*/ { typename Base::Has_on_2 _contains = this->has_on_2_object(); return _contains(s,p); } bool strictly_ordered_along_line( const Point_2& p1, const Point_2& p2, const Point_2& p3) const /*{\Xop returns |true| iff |p2| is in the relative interior of the segment |p1p3|.}*/ { typename Base::Are_strictly_ordered_along_line_2 _ordered = this->are_strictly_ordered_along_line_2_object(); return _ordered(p1,p2,p3); } bool first_pair_closer_than_second( const Point_2& p1, const Point_2& p2, const Point_2& p3, const Point_2& p4) const { return ( squared_distance(p1,p2) < squared_distance(p3,p4) ); } template void determine_frame_radius(Forward_iterator start, Forward_iterator end, Standard_RT& R0) const { Standard_RT R; while ( start != end ) { Point_2 p = *start++; if ( is_standard(p) ) { R = CGAL_NTS max(CGAL_NTS abs(p.x()[0]), CGAL_NTS abs(p.y()[0])); } else { RT rx = CGAL_NTS abs(p.x()), ry = CGAL_NTS abs(p.y()); if ( rx[1] > ry[1] ) R = CGAL_NTS abs(ry[0]-rx[0])/(rx[1]-ry[1]); else if ( rx[1] < ry[1] ) R = CGAL_NTS abs(rx[0]-ry[0])/(ry[1]-rx[1]); else /* rx[1] == ry[1] */ R = CGAL_NTS abs(rx[0]-ry[0])/2; } R0 = CGAL_NTS max(R+1,R0); } } const char* output_identifier() const { return "Extended_cartesian"; } }; #undef Polynomial CGAL_END_NAMESPACE #endif // CGAL_EXTENDED_CARTESIAN_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree.h0000644000175000017500000001703711344301500026556 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_KD_TREE_H #define CGAL_KD_TREE_H #include #include #include #include #include #include #include namespace CGAL { //template , class UseExtendedNode = Tag_true > template , class UseExtendedNode = Tag_true > class Kd_tree { public: typedef Splitter_ Splitter; typedef typename SearchTraits::Point_d Point_d; typedef typename Splitter::Container Point_container; typedef typename SearchTraits::FT FT; typedef Kd_tree_node Node; typedef Kd_tree Tree; typedef typename Compact_container::iterator Node_handle; typedef typename std::vector::iterator Point_d_iterator; typedef typename Splitter::Separator Separator; typedef typename std::vector::const_iterator iterator; private: mutable Splitter split; mutable Compact_container nodes; mutable Node_handle tree_root; mutable Kd_tree_rectangle* bbox; mutable std::vector pts; // Instead of storing the points in arrays in the Kd_tree_node // we put all the data in a vector in the Kd_tree. // and we only store an iterator range in the Kd_tree_node. // mutable std::vector data; SearchTraits tr; mutable bool built_; // protected copy constructor Kd_tree(const Tree& tree) : built_(tree.built_) {}; // Instead of the recursive construction of the tree in the class Kd_tree_node // we do this in the tree class. The advantage is that we then can optimize // the allocation of the nodes. // The leaf node Node_handle create_leaf_node(Point_container& c) const { Node_handle nh = nodes.construct_insert(c.size(), Node::LEAF); nh->data = c.begin(); return nh; } // The internal node Node_handle create_internal_node(Point_container& c, const Tag_true&) const { return create_internal_node_use_extension(c); } Node_handle create_internal_node(Point_container& c, const Tag_false&) const { return create_internal_node(c); } // TODO: Similiar to the leaf_init function above, a part of the code should be // moved to a the class Kd_tree_node. // It is not proper yet, but the goal was to see if there is // a potential performance gain through the Compact_container Node_handle create_internal_node_use_extension(Point_container& c) const { Node_handle nh = nodes.construct_insert(Node::EXTENDED_INTERNAL); Point_container c_low(c.dimension()); split(nh->separator(), c, c_low); int cd = nh->separator().cutting_dimension(); nh->low_val = c_low.bounding_box().min_coord(cd); nh->high_val = c.bounding_box().max_coord(cd); CGAL_assertion(nh->separator().cutting_value() >= nh->low_val); CGAL_assertion(nh->separator().cutting_value() <= nh->high_val); if (c_low.size() > split.bucket_size()){ nh->lower_ch = create_internal_node_use_extension(c_low); }else{ nh->lower_ch = create_leaf_node(c_low); } if (c.size() > split.bucket_size()){ nh->upper_ch = create_internal_node_use_extension(c); }else{ nh->upper_ch = create_leaf_node(c); } return nh; } // Note also that I duplicated the code to get rid if the if's for // the boolean use_extension which was constant over the construction Node_handle create_internal_node(Point_container& c) const { Node_handle nh = nodes.construct_insert(Node::INTERNAL); Point_container c_low(c.dimension()); split(nh->separator(), c, c_low); if (c_low.size() > split.bucket_size()){ nh->lower_ch = create_internal_node(c_low); }else{ nh->lower_ch = create_leaf_node(c_low); } if (c.size() > split.bucket_size()){ nh->upper_ch = create_internal_node(c); }else{ nh->upper_ch = create_leaf_node(c); } return nh; } public: Kd_tree(Splitter s = Splitter()) : split(s), built_(false) {} template Kd_tree(InputIterator first, InputIterator beyond, Splitter s = Splitter()) : split(s), built_(false) { CGAL_assertion(first != beyond); std::copy(first, beyond, std::back_inserter(pts)); } void build() const { const Point_d& p = *pts.begin(); typename SearchTraits::Construct_cartesian_const_iterator_d ccci; int dim = std::distance(ccci(p), ccci(p,0)); data.reserve(pts.size()); for(unsigned int i = 0; i < pts.size(); i++){ data.push_back(&pts[i]); } Point_container c(dim, data.begin(), data.end()); bbox = new Kd_tree_rectangle(c.bounding_box()); if (c.size() <= split.bucket_size()){ tree_root = create_leaf_node(c); }else { tree_root = create_internal_node(c, UseExtendedNode()); } built_ = true; } bool is_built() const { return built_; } void invalidate_built() { if(is_built()){ nodes.clear(); delete bbox; built_ = false; } } void insert(const Point_d& p) { invalidate_built(); pts.push_back(p); } template void insert(InputIterator first, InputIterator beyond) { invalidate_built(); std::copy(first, beyond, std::back_inserter(pts)); } template OutputIterator search(OutputIterator it, const FuzzyQueryItem& q) { if(! is_built()){ build(); } Kd_tree_rectangle b(*bbox); tree_root->search(it,q,b); return it; } ~Kd_tree() { if(is_built()){ delete bbox; } } SearchTraits traits() const { return tr; } Node_handle root() const { if(! is_built()){ build(); } return tree_root; } void print() const { if(! is_built()){ build(); } root()->print(); } const Kd_tree_rectangle& bounding_box() const { if(! is_built()){ build(); } return *bbox; } iterator begin() const { return pts.begin(); } iterator end() const { return pts.end(); } int size() const { return pts.size(); } // Print statistics of the tree. std::ostream& statistics(std::ostream& s) { if(! is_built()){ build(); } s << "Tree statistics:" << std::endl; s << "Number of items stored: " << tree_root->num_items() << std::endl; s << "Number of nodes: " << tree_root->num_nodes() << std::endl; s << " Tree depth: " << tree_root->depth() << std::endl; return s; } }; } // namespace CGAL #endif // CGAL_KD_TREE_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_landmarks_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_landmarks_point_loc0000644000175000017500000002300611344301500031422 0ustar debiandebian// Copyright (c) 2004 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_landmarks_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Idit Haran #ifndef CGAL_PM_LANDMARKS_POINT_LOCATION_H #define CGAL_PM_LANDMARKS_POINT_LOCATION_H //#define CGAL_LM_DEBUG #define LM_CLOCK_DEBUG //---------------------------------------------------------- //Pm includes //---------------------------------------------------------- #include #include #include #include #include #include #include #include #include //////////////////////////////////////////////////////// // LANDMARKS STRATEGY //////////////////////////////////////////////////////// CGAL_BEGIN_NAMESPACE template class Pm_landmarks_point_location : public Pm_point_location_base { public: //---------------------------------------------------------- // Pm Types //---------------------------------------------------------- typedef typename Planar_map::Traits Traits; typedef typename Traits::Kernel Kernel; typedef typename Kernel::Segment_2 Segment; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef Pm_point_location_base Base; typedef Pm_landmarks_point_location Self; typedef typename Planar_map::Face_iterator Face_iterator; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Vertex_iterator Vertex_iterator; typedef typename Planar_map::Edge_iterator Edge_iterator; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Planar_map::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Planar_map::Holes_iterator Holes_iterator; typedef typename Planar_map::Holes_const_iterator Holes_const_iterator; typedef typename Base::Token Token; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Nearest_neighbor::NN_Point_2 NN_Point_2; typedef std::list NN_Point_list; //---------------------------------------------------------- protected: // typedef const Self* cPLp; typedef const Self* const_Self_ptr; public: // Constructor Pm_landmarks_point_location() : Pm_point_location_base(), pm(0), traits(0), updated_nn(false), verbose(false) { #ifdef LM_CLOCK_DEBUG clock_ff = 0.0; clock_fi= 0.0; clock_ni= 0.0; clock_for_nn_search = 0.0; clock_for_walk = 0.0; clock_fciif = 0.0; clock_new_alg = 0.0; entries_to_fi = 0; #endif } //Destructor ~Pm_landmarks_point_location() { #ifdef LM_CLOCK_DEBUG std::cout << "total time to walk is " << clock_for_walk <<" clocks" << std::endl; std::cout << "total time to nn search is " << clock_for_nn_search <<" clocks" << std::endl; std::cout << "total time to ff (find face) is " << clock_ff <<" clocks" << std::endl; std::cout << "total time to fi (find intersection) is " << clock_fi <<" clocks" << std::endl; std::cout << "total time to ni (nearest intersection) is " << clock_ni <<" clocks" << std::endl; std::cout << "total time to fciif(find closest intersection in face) is " << clock_fciif <<" clocks" << std::endl; std::cout << "total time to new algorithm is " << clock_new_alg <<" clocks" << std::endl; std::cout << "total entries to fi(find intersection) is " << entries_to_fi <<" times" << std::endl; getchar(); #endif } void init(Planar_map & pmp, const Traits & tr) { CGAL_precondition_msg(pm == NULL, "Point location instance should be uninitialized " "(Do not use the same instance for more than one map)."); pm = &pmp; traits = (Traits_wrap*)(&tr); } // void init(Planar_map & pmp, Traits & tr) // { // #ifdef CGAL_LM_DEBUG // std::cout << "init PL" << std::endl; // #endif // CGAL_precondition_msg(pm == NULL, // "Point location instance should be uninitialized " // "(Do not use the same instance for more than one map)."); // pm = &pmp; // traits = (Traits_wrap*)(&tr); // create_landmarks_tree(); // } inline void insert(Halfedge_handle hh, const X_monotone_curve_2 & cv) {insert_halfedge_to_ln_tree(hh, cv); } Halfedge_const_handle locate(const Point_2 & p, Locate_type & lt) const; Halfedge_handle locate(const Point_2 & p, Locate_type & lt); Halfedge_const_handle vertical_ray_shoot(const Point_2& p, Locate_type& lt, bool up) const; Halfedge_handle vertical_ray_shoot(const Point_2& p, Locate_type& lt, bool up); inline void split_edge(const X_monotone_curve_2 &, Halfedge_handle, Halfedge_handle, //additions by iddo for arrangement const X_monotone_curve_2 &, const X_monotone_curve_2 &) {updated_nn = false; create_landmarks_tree(); } inline void merge_edge(const X_monotone_curve_2 &, const X_monotone_curve_2 &, Halfedge_handle, //additions by iddo for arrangement const X_monotone_curve_2 &) {updated_nn = false; create_landmarks_tree();} inline void remove_edge(Halfedge_handle) {updated_nn = false; create_landmarks_tree();} inline void remove_edge(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &) {updated_nn = false; create_landmarks_tree(); }; inline void clear() {updated_nn = false; create_landmarks_tree();} inline void update(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &, const Token& token) {updated_nn = false; create_landmarks_tree(); } private: //function that updates the kd-tree for the nearest neightbor void create_landmarks_tree() ; void insert_halfedge_to_ln_tree(Halfedge_handle hh, const X_monotone_curve_2 &cv) ; //function that walks from the vertex to the point //Halfedge_const_handle void walk(Vertex_handle vh, const Point_2 & p, Halfedge_const_handle& e, Locate_type& lt) const; void find_face (const Point_2 & p, Vertex_handle vh, bool & found_vertex_or_edge, bool & new_vertex, bool & found_face, Vertex_handle & out_vertex, Halfedge_handle & out_edge, Locate_type& lt ) const; void find_intersection (const Point_2 & p, //Vertex_handle vh, Curve_2 &seg, Halfedge_handle e, int & num_of_intersections, bool & change_side, bool & found_edge, Point_2 & closest_interect_point, bool & new_vertex, Vertex_handle & out_vertex ) const; bool is_point_in_face (const Point_2 & p, const Ccb_halfedge_circulator & face, bool & found_edge, bool & found_vertex, Halfedge_handle & out_edge) const; bool find_closest_intersection_in_face (const Point_2 & p, Vertex_handle v, const Ccb_halfedge_circulator & face, Halfedge_handle & out_edge) const ; bool find_real_intersection (const Point_2 & p, Vertex_handle v, Halfedge_handle e, Point_2 & out_point) const ; #ifdef CGAL_LM_DEBUG void debug() {} void debug(const Halfedge_handle& e) const { { if (e!=pm->halfedges_end()) std::cerr << "(" << e->source()->point() << "," << e->target()->point() << ")" << std::flush; else std::cerr << "(oo)"; } } #endif public: inline const Traits * get_traits() const {return traits;} protected: Planar_map * pm; Traits_wrap * traits; Nearest_neighbor nn; bool updated_nn; #ifdef LM_CLOCK_DEBUG mutable double clock_ff; //find face mutable double clock_fi; //find intersection mutable double clock_ni; //nearest intersection (to left/to right) mutable double clock_for_nn_search ; mutable double clock_for_walk ; mutable double clock_fciif; mutable double clock_new_alg; mutable int entries_to_fi; #endif const bool verbose; }; CGAL_END_NAMESPACE #include #endif //PM_LANDMARKS_POINT_LOCATION_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Extremal_polygon_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Extremal_polygon_trait0000644000175000017500000002623211344301500031503 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Extremal_polygon_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_EXTREMAL_POLYGON_TRAITS_2_H) #define CGAL_EXTREMAL_POLYGON_TRAITS_2_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template < class K_ > struct Extremal_polygon_area_traits_2 { typedef K_ K; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; #ifdef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG typedef typename K::Less_xy_2 Less_xy_2; typedef typename K::Orientation_2 Orientation_2; #endif // CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG struct Kgon_triangle_area { typedef Arity_tag< 3 > Arity; typedef FT result_type; Kgon_triangle_area(const K& k_) : k(k_) {} result_type operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return CGAL_NTS abs(k.compute_area_2_object()( k.construct_triangle_2_object()(p, q, r))); } protected: K k; }; typedef Kgon_triangle_area Baseop; typedef typename Bind< Baseop, Point_2, 3 >::Type Operation; Extremal_polygon_area_traits_2() {} Extremal_polygon_area_traits_2(const K& k_) : k(k_) {} int min_k() const { return 3; } FT init( const Point_2&, const Point_2&) const { return FT( 0); } Operation operation( const Point_2& p) const { return bind_3(Baseop(k), p); } template < class RandomAccessIC, class OutputIterator > OutputIterator compute_min_k_gon( RandomAccessIC points_begin, RandomAccessIC points_end, FT& max_area, OutputIterator o) const // RandomAccessIC is a random access iterator or // circulator with value_type Point_2. // OutputIterator accepts int as value_type. // // PRE: n := | [points_begin, points_end) | >= min_k() and // the points described by the range [points_begin, points_end) // form the boundary of a convex polygon oriented counterclockwise. // // POST: write indices of the points from [points_begin, points_end) // forming a min_k()-gon rooted at points_begin[0] // of maximum area to o in counterclockwise order and return // the past-the-end iterator for that range (== o + min_k()). { int number_of_points( iterator_distance( points_begin, points_end)); CGAL_optimisation_precondition( number_of_points > min_k()); // this gives the area of the triangle of two points with // the root: Operation op( operation( points_begin[0])); int p1( 1); int p2( 2); // maximal triangle so far (and the corresponding points): max_area = op( points_begin[p1], points_begin[p2]); int opt_p1( p1); int opt_p2( p2); // maximal triangle containing p1 so far: FT tmp_area( max_area); for (;;) { while ( p2 + 1 < number_of_points && tmp_area < op( points_begin[p1], points_begin[p2+1])) { tmp_area = op( points_begin[p1], points_begin[++p2]); } if ( tmp_area > max_area) { max_area = tmp_area; opt_p1 = p1; opt_p2 = p2; } if ( ++p1 == number_of_points - 1) break; if ( p2 == p1) ++p2; tmp_area = op( points_begin[p1], points_begin[p2]); } // for (;;) // give result: *o++ = opt_p2; *o++ = opt_p1; *o++ = 0; return o; } // compute_min_k_gon( ... ) #ifdef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG Less_xy_2 less_xy_2_object() const { return k.less_xy_2_object(); } Orientation_2 orientation_2_object() const { return k.orientation_2_object(); } #endif // CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG protected: K k; }; CGAL_END_NAMESPACE #include #include #ifdef CGAL_USE_LEDA #include #endif // CGAL_USE_LEDA CGAL_BEGIN_NAMESPACE template < class K_ > struct Extremal_polygon_perimeter_traits_2 { typedef K_ K; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; #ifdef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG typedef typename K::Less_xy_2 Less_xy_2; typedef typename K::Orientation_2 Orientation_2; #endif // CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG struct Kgon_triangle_perimeter { typedef Arity_tag< 3 > Arity; typedef FT result_type; Kgon_triangle_perimeter(const K& k_): k(k_) {} result_type operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return dist(p, r) + dist(p, q) - dist(q, r); } private: result_type dist(const Point_2& p, const Point_2& q) const { return CGAL_NTS sqrt(k.compute_squared_distance_2_object()(p, q)); } protected: K k; }; typedef Kgon_triangle_perimeter Baseop; typedef typename Bind< Baseop, Point_2, 3 >::Type Operation; Extremal_polygon_perimeter_traits_2() {} Extremal_polygon_perimeter_traits_2(const K& k_) : k(k_) {} int min_k() const { return 2; } FT init( const Point_2& p, const Point_2& r) const { return operation( r)( p, r); } Operation operation( const Point_2& p) const { return bind_3( Baseop(k), p); } template < class RandomAccessIC, class OutputIterator > OutputIterator compute_min_k_gon( RandomAccessIC points_begin, RandomAccessIC points_end, FT& max_perimeter, OutputIterator o) const // RandomAccessIC is a random access iterator or // circulator with value_type Point_2. // OutputIterator accepts int as value_type. // // PRE: n := | [points_begin, points_end) | >= min_k() and // the points described by the range [points_begin, points_end) // form the boundary of a convex polygon oriented counterclockwise. // // POST: write indices of the points from [points_begin, points_end) // forming a min_k()-gon rooted at points_begin[0] of maximum // perimeter to o in counterclockwise order, set max_perimeter // to twice this perimeter and return the past-the-end iterator // for the range (== o + min_k()). { using std::less; using std::max_element; CGAL_optimisation_precondition_code( int number_of_points( iterator_distance( points_begin, points_end));) CGAL_optimisation_precondition( number_of_points > min_k()); // kind of messy, but first we have to have something // like Distance (function object) ... RandomAccessIC maxi( max_element( points_begin + 1, points_end, compose( less< FT >(), bind_2(operation(points_begin[0]), points_begin[0]), bind_2(operation(points_begin[0]), points_begin[0])))); // give result: max_perimeter = operation(*points_begin)(*maxi, *points_begin); *o++ = iterator_distance(points_begin, maxi); *o++ = 0; return o; } // compute_min_k_gon( ... ) #ifdef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG Less_xy_2 less_xy_2_object() const { return k.less_xy_2_object(); } Orientation_2 orientation_2_object() const { return k.orientation_2_object(); } #endif // CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG protected: K k; }; template < class RandomAccessIC, class OutputIterator > inline OutputIterator maximum_area_inscribed_k_gon_2( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // * R is a CGAL representation class // * value_type of RandomAccessIC is Point_2 // * OutputIterator accepts Point_2 as value_type // * k >= 3 // // functionality: // -------------- // computes maximum area inscribed k-gon $P_k$ // of the polygon $P$, // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { typedef typename std::iterator_traits< RandomAccessIC >::value_type::R R; return extremal_polygon_2( points_begin, points_end, k, o, Extremal_polygon_area_traits_2< R >()); } // maximum_area_inscribed_k_gon_2( ... ) // backwards compatibility template < class RandomAccessIC, class OutputIterator > inline OutputIterator maximum_area_inscribed_k_gon( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o) { return maximum_area_inscribed_k_gon_2( points_begin, points_end, k, o); } // maximum_area_inscribed_k_gon( ... ) template < class RandomAccessIC, class OutputIterator > inline OutputIterator maximum_perimeter_inscribed_k_gon_2( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // * R is a CGAL representation class // * value_type of RandomAccessIC is Point_2 // * OutputIterator accepts Point_2 as value_type // * k >= 2 // // functionality: // -------------- // computes maximum perimeter inscribed k-gon $P_k$ // of the polygon $P$, // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { typedef typename std::iterator_traits< RandomAccessIC >::value_type::R R; return extremal_polygon_2( points_begin, points_end, k, o, Extremal_polygon_perimeter_traits_2< R >()); } // maximum_perimeter_inscribed_k_gon_2( ... ) // backwards compatibility template < class RandomAccessIC, class OutputIterator > inline OutputIterator maximum_perimeter_inscribed_k_gon( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o) { return maximum_perimeter_inscribed_k_gon_2( points_begin, points_end, k, o); } // maximum_perimeter_inscribed_k_gon( ... ) CGAL_END_NAMESPACE #endif // ! (CGAL_EXTREMAL_POLYGON_TRAITS_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_circle_2.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_circle_2.0000644000175000017500000000542611344301500031251 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_circle_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner // includes #ifndef CGAL_OPTIMISATION_ASSERTIONS_H # include #endif CGAL_BEGIN_NAMESPACE // Class implementation (continued) // ================================ // I/O // --- template < class K_ > std::ostream& operator << ( std::ostream& os, const CGAL::Optimisation_circle_2& c) { switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << "CGAL::Optimisation_circle_2( " << c.center() << ", " << c.squared_radius() << ')'; break; case CGAL::IO::ASCII: os << c.center() << ' ' << c.squared_radius(); break; case CGAL::IO::BINARY: os << c.center(); CGAL::write( os, c.squared_radius()); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } template < class K_ > std::istream& operator >> ( std::istream& is, CGAL::Optimisation_circle_2& c) { typedef typename CGAL::Optimisation_circle_2::Point Point; typedef typename CGAL::Optimisation_circle_2::Distance Distance; switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case CGAL::IO::ASCII: { Point center; Distance squared_radius; is >> center >> squared_radius; c.set( center, squared_radius); } break; case CGAL::IO::BINARY: { Point center; Distance squared_radius; is >> center; CGAL::read( is, squared_radius); c.set( center, squared_radius); } break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( is) invalid!"); break; } return( is); } CGAL_END_NAMESPACE // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Iso_rectangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Iso_rectang0000644000175000017500000002470211344301501031254 0ustar debiandebian// Copyright (c) 1997-2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Iso_rectangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_TRIANGLE_2_ISO_RECTANGLE_2_INTERSECTION_H #define CGAL_TRIANGLE_2_ISO_RECTANGLE_2_INTERSECTION_H #include "CGAL/Point_2.h" #include "CGAL/Segment_2.h" #include "CGAL/Triangle_2.h" #include "CGAL/Iso_rectangle_2.h" #include "CGAL/Segment_2_Segment_2_intersection.h" #include #include namespace CGAL{ template Object intersection(const Triangle_2 &t, const Iso_rectangle_2 &r) { typedef typename R::FT FT; typedef Segment_2 Segment; typedef Point_2 Point; FT xr1, yr1, xr2, yr2; bool position[3][4] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}}; bool is_inside[3] = {false, false, false}; //true when a vertex is inside rectangle xr1 = r.xmin(); xr2 = r.xmax(); yr1 = r.ymax(); yr2 = r.ymin(); Point upper_left, lower_right; Point p[3]; //the vertices of triangle upper_left = Point(xr1, yr1); //upper left lower_right = Point(xr2, yr2); //lower right p[0] = t.vertex(0); p[1] = t.vertex(1); p[2] = t.vertex(2); //check the points of the triangle for(int i=0; i<3; i++){ if(!(compare_x(p[i], upper_left) == SMALLER)) if(!(compare_x(p[i], lower_right) == LARGER)) if(!(compare_y(p[i], upper_left) == LARGER)) if(!(compare_y(p[i], lower_right) == SMALLER)) is_inside[i] = true; //the point is inside else position[i][2] = true; //South else position[i][0] = true; //North else { position[i][3] = true; //East if(compare_y(p[i], upper_left) == LARGER) position[i][0] = true; //North else if(compare_y(p[i], lower_right) == SMALLER) position[i][2] = true; //South } else { position[i][1] = true; //West if(compare_y(p[i], upper_left) == LARGER) position[i][0] = true; //North else if(compare_y(p[i], lower_right) == SMALLER) position[i][2] = true; //South } } //test if the triangle is completely to the left, right, below or above the rectangle bool intersection = true; //true if it could be a intersection with the rectangle for(int j=0; j<4; j++) if(position[0][j] && position[1][j] && position[2][j] ){ intersection = false; break; } if(intersection){ Segment s[4]; //the segments that identify the N, W, S, E bool outside = false; bool status_in_list[3] = {false, false, false}; //true if the triangle's points are in the result vector std::list last_intersected; int last_intersected_segment = 5; //could be 0=N, 1=W, 2=S, 3=E last_intersected.push_back(5); int status_intersected[4] = {0, 0, 0, 0}; //the number of intersections for each segment CGAL::Object obj; Point p_obj; std::vector result; //the vector containing the result vertices int next; //the index of the next vertex s[0] = Segment(Point(xr2, yr1), Point(xr1, yr1)); //N s[1] = Segment(Point(xr1, yr1), Point(xr1, yr2)); //W s[2] = Segment(Point(xr1, yr2), Point(xr2, yr2)); //S s[3] = Segment(Point(xr2, yr2), Point(xr2, yr1)); //E //assign to p[i] the vertices of the triangle in ccw order if(t.orientation() == CGAL::CLOCKWISE) { p[0] = t.vertex(2); p[2] = t.vertex(0); is_inside[0] = is_inside[2] ^ is_inside[0]; is_inside[2] = is_inside[2] ^ is_inside[0]; is_inside[0] = is_inside[0] ^ is_inside[2]; for(int i=0; i<4; i++){ position[0][i] = position[2][i] ^ position[0][i]; position[2][i] = position[2][i] ^ position[0][i]; position[0][i] = position[0][i] ^ position[2][i]; } } for(int index=0; index<3; index++) //for each vertex { next=(index+1)%3; if(is_inside[index]){ // true if first is inside if(!status_in_list[index]){ //if is not yet in the list result.push_back(p[index]); status_in_list[index] = true; } if(is_inside[next]){ //true if second is inside //add the points in the vector if(!status_in_list[next]){ // if is not yet in the list result.push_back(p[next]); status_in_list[next] = true; } } else { //I'm going out, the second is outside for(int j=0; j<4; j++) // for all directions if(position[next][j]) // if it's a second point direction { //test for intersection obj = CGAL::intersection(Segment(p[index], p[next]), s[j]); if(CGAL::assign(p_obj, obj)) { //intersection found outside = true; result.push_back(p_obj); //add the intersection point if(last_intersected.back()!=j) last_intersected.push_back(j); status_intersected[j]++; } } } } else { //the first point is outside for(int j=0; j<4; j++) // for all directions if(position[index][j]) //watch only the first point directions { //test for intersection obj = CGAL::intersection(Segment(p[index], p[next]), s[j]); if(CGAL::assign(p_obj, obj)) { //intersection found outside = false; last_intersected_segment = last_intersected.back(); if(last_intersected_segment != 5 && last_intersected_segment != j && status_intersected[j] == 0){ //add the target of each rectangle segment in the list if(last_intersected_segment < j) while(last_intersected_segment < j){ result.push_back(s[last_intersected_segment].target()); last_intersected_segment++; } else{ while(last_intersected_segment < 4){ result.push_back(s[last_intersected_segment].target()); last_intersected_segment++; } last_intersected_segment = 0; while(last_intersected_segment < j){ result.push_back(s[last_intersected_segment].target()); last_intersected_segment++; } } } result.push_back(p_obj); //add the intersection point in the list if(last_intersected.back()!=j) last_intersected.push_back(j); status_intersected[j]++; if(!is_inside[next]){ //if the second point is not inside search a second intersection point for(j=0; j<4; j++) // for all directions if(position[next][j]) { //test for intersection obj = CGAL::intersection(Segment(p[index], p[next]), s[j]); if(CGAL::assign(p_obj, obj)) //found the second intersection { outside = true; result.push_back(p_obj); if(last_intersected.back()!=j) last_intersected.push_back(j); status_intersected[j]++; } } }//end if the second point is not inside } } }//end else (the first point is outside) }//endfor if(outside){ std::list::const_iterator it = last_intersected.begin(); while(*it == 5) it++; last_intersected_segment = *it; int j = last_intersected.back(); if(last_intersected_segment != 5 && last_intersected_segment != j){ //add the target of each rectangle segment in the list if(last_intersected_segment > j) while(last_intersected_segment > j){ result.push_back(s[j].target()); j++; } else{ while(j<4){ result.push_back(s[j].target()); j++; } j = 0; while(j(result[0], result[1], result[2])); default: return make_object(result); } }//end if(intersection) return Object(); }//end intersection }//end namespace #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_2.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000015427011344301500031400 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas // class implementation continued //================================= CGAL_BEGIN_NAMESPACE //==================================================================== //==================================================================== // CONSTRUCTORS //==================================================================== //==================================================================== // copy constructor template Segment_Voronoi_diagram_2:: Segment_Voronoi_diagram_2(const Segment_Voronoi_diagram_2& other) : DG(other.geom_traits()) { Segment_Voronoi_diagram_2& non_const_other = const_cast(other); copy(non_const_other); CGAL_postcondition( is_valid() ); } // assignment operator template typename Segment_Voronoi_diagram_2::Self& Segment_Voronoi_diagram_2:: operator=(const Self& other) { if ( this != &other ) { Segment_Voronoi_diagram_2& non_const_other = const_cast(other); copy(non_const_other); } return (*this); } //==================================================================== //==================================================================== // METHODS FOR INSERTION //==================================================================== //==================================================================== //-------------------------------------------------------------------- // insertion of first three sites //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_first(const Storage_site_2& ss, const Point_2& p) { CGAL_precondition( number_of_vertices() == 0 ); Vertex_handle v = this->_tds.insert_second(); v->set_site(ss); return v; } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_second(const Storage_site_2& ss, const Point_2& p) { CGAL_precondition( number_of_vertices() == 1 ); // p0 is actually a point Site_2 p0 = finite_vertices_begin()->site(); // MK: change the equality test between points by the functor in // geometric traits Site_2 tp = Site_2::construct_site_2(p); if ( same_points(tp,p0) ) { return Vertex_handle(finite_vertices_begin()); } return create_vertex_dim_up(ss); } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_third(const Storage_site_2& ss, const Point_2& p) { Site_2 t = Site_2::construct_site_2(p); return insert_third(t, ss); } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_third(const Site_2& t, const Storage_site_2& ss) { CGAL_precondition( number_of_vertices() == 2 ); // p0 and p1 are actually points Vertex_handle v0 = finite_vertices_begin(); Vertex_handle v1 = ++finite_vertices_begin(); Site_2 t0 = v0->site(); Site_2 t1 = v1->site(); if ( same_points(t, t0) ) { return v0; } if ( same_points(t, t1) ) { return v1; } Vertex_handle v = create_vertex_dim_up(ss); Face_handle f(finite_faces_begin()); Site_2 s1 = f->vertex(0)->site(); Site_2 s2 = f->vertex(1)->site(); Site_2 s3 = f->vertex(2)->site(); Orientation o = geom_traits().orientation_2_object()(s1, s2, s3); if ( o != COLLINEAR ) { if ( o == RIGHT_TURN ) { f->reorient(); for (int i = 0; i < 3; i++) { f->neighbor(i)->reorient(); } } } else { typename Geom_traits::Compare_x_2 compare_x = geom_traits().compare_x_2_object(); Comparison_result xcmp12 = compare_x(s1, s2); if ( xcmp12 == SMALLER ) { // x1 < x2 Comparison_result xcmp23 = compare_x(s2, s3); if ( xcmp23 == SMALLER ) { // x2 < x3 flip(f, f->index(v1)); } else { Comparison_result xcmp31 = compare_x(s3, s1); if ( xcmp31 == SMALLER ) { // x3 < x1 flip(f, f->index(v0)); } else { // x1 < x3 < x2 flip(f, f->index(v)); } } } else if ( xcmp12 == LARGER ) { // x1 > x2 Comparison_result xcmp32 = compare_x(s3, s2); if ( xcmp32 == SMALLER ) { // x3 < x2 flip(f, f->index(v1)); } else { Comparison_result xcmp13 = compare_x(s1, s3); if ( xcmp13 == SMALLER ) { // x1 < x3 flip(f, f->index(v0)); } else { // x2 < x3 < x1 flip(f, f->index(v)); } } } else { // x1 == x2 typename Geom_traits::Compare_y_2 compare_y = geom_traits().compare_y_2_object(); Comparison_result ycmp12 = compare_y(s1, s2); if ( ycmp12 == SMALLER ) { // y1 < y2 Comparison_result ycmp23 = compare_y(s2, s3); if ( ycmp23 == SMALLER ) { // y2 < y3 flip(f, f->index(v1)); } else { Comparison_result ycmp31 = compare_y(s3, s1); if ( ycmp31 == SMALLER ) { // y3 < y1 flip(f, f->index(v0)); } else { // y1 < y3 < y2 flip(f, f->index(v)); } } } else if ( ycmp12 == LARGER ) { // y1 > y2 Comparison_result ycmp32 = compare_y(s3, s2); if ( ycmp32 == SMALLER ) { // y3 < y2 flip(f, f->index(v1)); } else { Comparison_result ycmp13 = compare_y(s1, s3); if ( ycmp13 == SMALLER ) { // y1 < y3 flip(f, f->index(v0)); } else { // y2 < y3 < y1 flip(f, f->index(v)); } } } else { // this line should never have been reached CGAL_assertion( false ); } } } return v; } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_third(const Storage_site_2& ss, Vertex_handle v0, Vertex_handle v1) { CGAL_precondition( number_of_vertices() == 2 ); // this can only be the case if the first site is a segment CGAL_precondition( dimension() == 1 ); Vertex_handle v = create_vertex_dim_up(ss); Face_circulator fc = incident_faces(v); while ( true ) { Face_handle f(fc); if ( !is_infinite(f) ) { flip(f, f->index(v)); break; } ++fc; } return v; } //-------------------------------------------------------------------- // insertion of a point //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_point(const Storage_site_2& ss, const Point_2& p, Vertex_handle vnear) { int n = number_of_vertices(); if ( n == 0 ) { return insert_first(ss, p); } else if ( n == 1 ) { return insert_second(ss, p); } else if ( n == 2 ) { return insert_third(ss, p); } Site_2 t = Site_2::construct_site_2(p); return insert_point(ss, t, vnear); } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_point(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnear) { CGAL_precondition( t.is_point() ); CGAL_assertion( number_of_vertices() > 2 ); //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* // MK::ERROR: I need to write a insert_point_no_search method that // does not search for the nearest neighbor; this should be used by // insert_point. Below the first version of the code is correct. The // second is what the insert_point method should do before calling // insert_point_no_search. // first find the nearest neighbor #if 1 Vertex_handle vnearest = nearest_neighbor( t, vnear ); #else Vertex_handle vnearest; if ( vnear == Vertex_handle() ) { vnearest = nearest_neighbor( t, vnear ); } else { vnearest = vnear; } #endif //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* //********************************************************************* // check is the point has already been inserted or lies on // a segment already inserted Arrangement_type at_res = arrangement_type(t, vnearest); if ( vnearest->is_point() ) { if ( at_res == AT2::IDENTICAL ) { return vnearest; } } else { CGAL_assertion( vnearest->is_segment() ); CGAL_assertion( at_res != AT2::TOUCH_1 ); CGAL_assertion( at_res != AT2::TOUCH_2 ); CGAL_assertion( at_res == AT2::DISJOINT || at_res == AT2::INTERIOR ); if ( at_res == AT2::INTERIOR ) { CGAL_assertion( t.is_input() ); Vertex_triple vt = insert_exact_point_on_segment(ss, t, vnearest); return vt.first; } else { // the point to be inserted does not belong to the interior of a // segment CGAL_assertion( at_res == AT2::DISJOINT ); } } return insert_point2(ss, t, vnearest); } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_point2(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnearest) { CGAL_precondition( t.is_point() ); CGAL_assertion( number_of_vertices() > 2 ); CGAL_expensive_precondition ( nearest_neighbor(t, vnearest) == vnearest ); // find the first conflict #ifndef CGAL_NO_ASSERTIONS // verify that there are no intersections... Vertex_circulator vc = vnearest->incident_vertices(); Vertex_circulator vc_start = vc; do { Vertex_handle vv(vc); Arrangement_type at_res = arrangement_type(t, vv); CGAL_assertion( at_res == AT2::DISJOINT ); ++vc; } while ( vc != vc_start ); #endif // first look for conflict with vertex Face_circulator fc_start = vnearest->incident_faces(); Face_circulator fc = fc_start; Face_handle start_f; Sign s; std::map sign_map; do { Face_handle f(fc); s = incircle(f, t); sign_map[f] = s; if ( s == NEGATIVE ) { start_f = f; break; } ++fc; } while ( fc != fc_start ); // we are not in conflict with a Voronoi vertex, so we have to // be in conflict with the interior of a Voronoi edge if ( s != NEGATIVE ) { Edge_circulator ec_start = vnearest->incident_edges(); Edge_circulator ec = ec_start; bool interior_in_conflict(false); Edge e; do { e = *ec; Sign s1 = sign_map[e.first]; Sign s2 = sign_map[e.first->neighbor(e.second)]; if ( s1 == s2 ) { interior_in_conflict = edge_interior(e, t, s1); } else { // It seems that there was a problem here when one of the // signs was positive and the other zero. In this case we // still check pretending that both signs where positive interior_in_conflict = edge_interior(e, t, POSITIVE); } if ( interior_in_conflict ) { break; } ++ec; } while ( ec != ec_start ); sign_map.clear(); CGAL_assertion( interior_in_conflict ); return insert_degree_2(e, ss); } // we are in conflict with a Voronoi vertex; start from that and // find the entire conflict region and then repair the diagram List l; Face_map fm; Triple vcross(false, Vertex_handle(), AT2::DISJOINT); // MK:: NEED TO WRITE A FUNCTION CALLED find_conflict_region WHICH // IS GIVEN A STARTING FACE, A LIST, A FACE MAP, A VERTEX MAP AND A // LIST OF FLIPPED EDGES AND WHAT IS DOES IS INITIALIZE THE CONFLICT // REGION AND EXPANDS THE CONFLICT REGION. initialize_conflict_region(start_f, l); expand_conflict_region(start_f, t, ss, l, fm, sign_map, vcross); CGAL_assertion( !vcross.first ); Vertex_handle v = create_vertex(ss); retriangulate_conflict_region(v, l, fm); return v; } //-------------------------------------------------------------------- // insertion of a point that lies on a segment //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Face_pair Segment_Voronoi_diagram_2:: find_faces_to_split(const Vertex_handle& v, const Site_2& t) const { CGAL_precondition( v->is_segment() ); #ifndef CGAL_NO_ASSERTIONS { // count number of adjacent infinite faces Face_circulator fc = incident_faces(v); Face_circulator fc_start = fc; int n_inf = 0; do { if ( is_infinite(fc) ) { n_inf++; } fc++; } while ( fc != fc_start ); CGAL_assertion( n_inf == 0 || n_inf == 2 || n_inf == 4 ); } #endif Face_circulator fc1 = incident_faces(v); Face_circulator fc2 = fc1; ++fc2; Face_circulator fc_start = fc1; Face_handle f1, f2; bool found_f1 = false, found_f2 = false; Site_2 sitev_supp = v->site().supporting_site(); do { Face_handle ff1(fc1), ff2(fc2); Oriented_side os1, os2; if ( is_infinite(ff1) ) { int id_v = ff1->index(v); int cw_v = this->cw( id_v ); int ccw_v = this->ccw( id_v ); Site_2 sv_ep; if ( is_infinite( ff1->vertex(cw_v) ) ) { CGAL_assertion( !is_infinite( ff1->vertex(ccw_v) ) ); CGAL_assertion( ff1->vertex(ccw_v)->site().is_point() ); sv_ep = ff1->vertex(ccw_v)->site(); } else { CGAL_assertion( !is_infinite( ff1->vertex( cw_v) ) ); CGAL_assertion( ff1->vertex( cw_v)->site().is_point() ); sv_ep = ff1->vertex( cw_v)->site(); } os1 = oriented_side(sv_ep, sitev_supp, t); } else { os1 = oriented_side(fc1->vertex(0)->site(), fc1->vertex(1)->site(), fc1->vertex(2)->site(), sitev_supp, t); } if ( is_infinite(ff2) ) { int id_v = ff2->index(v); int cw_v = this->cw( id_v ); int ccw_v = this->ccw( id_v ); Site_2 sv_ep; if ( is_infinite( ff2->vertex(cw_v) ) ) { CGAL_assertion( !is_infinite( ff2->vertex(ccw_v) ) ); CGAL_assertion( ff2->vertex(ccw_v)->site().is_point() ); sv_ep = ff2->vertex(ccw_v)->site(); } else { CGAL_assertion( !is_infinite( ff2->vertex( cw_v) ) ); CGAL_assertion( ff2->vertex( cw_v)->site().is_point() ); sv_ep = ff2->vertex( cw_v)->site(); } os2 = oriented_side(sv_ep, sitev_supp, t); } else { os2 = oriented_side(fc2->vertex(0)->site(), fc2->vertex(1)->site(), fc2->vertex(2)->site(), sitev_supp, t); } if ( !found_f1 && os1 != ON_POSITIVE_SIDE && os2 == ON_POSITIVE_SIDE ) { f1 = ff2; found_f1 = true; } if ( !found_f2 && os1 == ON_POSITIVE_SIDE && os2 != ON_POSITIVE_SIDE ) { f2 = ff2; found_f2 = true; } if ( found_f1 && found_f2 ) { break; } ++fc1, ++fc2; } while ( fc_start != fc1 ); CGAL_assertion( found_f1 && found_f2 ); CGAL_assertion( f1 != f2 ); return Face_pair(f1, f2); } template typename Segment_Voronoi_diagram_2::Vertex_triple Segment_Voronoi_diagram_2:: insert_exact_point_on_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle v) { // splits the segment site v->site() in two and inserts represented by t // on return the three vertices are, respectively, the vertex // corresponding to t and the two subsegments of v->site() CGAL_assertion( t.is_point() ); CGAL_assertion( t.is_input() ); Storage_site_2 ssitev = v->storage_site(); CGAL_assertion( ssitev.is_segment() ); Face_pair fpair = find_faces_to_split(v, t); boost::tuples::tuple qq = this->_tds.split_vertex(v, fpair.first, fpair.second); Intersections_tag itag; // now I need to update the sites for vertices v1 and v2 Vertex_handle v1 = boost::tuples::get<0>(qq); //qq.first; Storage_site_2 ssv1 = split_storage_site(ssitev, ss, 0, itag); v1->set_site( ssv1 ); Vertex_handle v2 = boost::tuples::get<1>(qq); //qq.second; Storage_site_2 ssv2 = split_storage_site(ssitev, ss, 1, itag); v2->set_site( ssv2 ); Face_handle qqf = boost::tuples::get<2>(qq); //qq.third; Vertex_handle vsx = this->_tds.insert_in_edge(qqf, cw(qqf->index(v1))); vsx->set_site(ss); return Vertex_triple(vsx, v1, v2); } template typename Segment_Voronoi_diagram_2::Vertex_triple Segment_Voronoi_diagram_2:: insert_point_on_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, const Tag_true&) { // splits the segment site v->site() in two and inserts the point of // intersection of t and v->site() // on return the three vertices are, respectively, the point of // intersection and the two subsegments of v->site() Storage_site_2 ssitev = v->storage_site(); Storage_site_2 ssx = create_storage_site(ss, ssitev); Site_2 sitev = ssitev.site(); Face_pair fpair = find_faces_to_split(v, ssx.site()); boost::tuples::tuple qq = this->_tds.split_vertex(v, fpair.first, fpair.second); // now I need to update the sites for vertices v1 and v2 Vertex_handle v1 = boost::tuples::get<0>(qq); //qq.first; Storage_site_2 ssv1; Site_2 sv1; if ( sitev.is_input(0) ) { ssv1 = create_storage_site(ssitev, ss, true); } else { ssv1 = create_storage_site_type1(ssitev, ssitev, ss); } sv1 = ssv1.site(); v1->set_site( ssv1 ); Vertex_handle v2 = boost::tuples::get<1>(qq); //qq.second; Storage_site_2 ssv2; Site_2 sv2; if ( sitev.is_input(1) ) { ssv2 = create_storage_site(ssitev, ss, false); } else { ssv2 = create_storage_site_type2(ssitev, ss, ssitev); } sv2 = ssv2.site(); v2->set_site( ssv2 ); Face_handle qqf = boost::tuples::get<2>(qq); //qq.third; Vertex_handle vsx = this->_tds.insert_in_edge(qqf, cw(qqf->index(v1))); vsx->set_site(ssx); return Vertex_triple(vsx, v1, v2); } //-------------------------------------------------------------------- // insertion of a segment //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnear) { CGAL_precondition( t.is_segment() ); CGAL_precondition( t.is_input() ); if ( is_degenerate_segment(t) ) { return insert_point(ss.source_site(), t.source(), vnear); } Vertex_handle v0 = insert_point( ss.source_site(), t.source(), vnear ); Vertex_handle v1 = insert_point( ss.target_site(), t.target(), v0 ); if ( number_of_vertices() == 2 ) { return insert_third(ss, v0, v1); } return insert_segment_interior(t, ss, v0); } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_segment_interior(const Site_2& t, const Storage_site_2& ss, Vertex_handle vnearest) { CGAL_precondition( t.is_segment() ); CGAL_precondition( number_of_vertices() > 2 ); CGAL_assertion( vnearest != Vertex_handle() ); // find the first conflict // first look if there are intersections... Vertex_circulator vc = vnearest->incident_vertices(); Vertex_circulator vc_start = vc; do { Vertex_handle vv(vc); if ( is_infinite(vv) ) { vc++; continue; } Arrangement_type at_res = arrangement_type(t, vv); if ( vv->is_segment() ) { if ( at_res == AT2::DISJOINT || at_res == AT2::TOUCH_1 || at_res == AT2::TOUCH_2 || at_res == AT2::TOUCH_11 || at_res == AT2::TOUCH_12 || at_res == AT2::TOUCH_21 || at_res == AT2::TOUCH_22 ) { // do nothing } else if ( at_res == AT2::IDENTICAL ) { return vv; } else if ( at_res == AT2::CROSSING ) { Intersections_tag itag; return insert_intersecting_segment(ss, t, vv, itag); } else if ( at_res == AT2::TOUCH_11_INTERIOR_1 ) { Intersections_tag itag; Vertex_handle vp = second_endpoint_of_segment(vv); Storage_site_2 ssvp = vp->storage_site(); Storage_site_2 sss = split_storage_site(ss, ssvp, 1, itag); return insert_segment_interior(sss.site(), sss, vp); } else if ( at_res == AT2::TOUCH_12_INTERIOR_1 ) { Intersections_tag itag; Vertex_handle vp = first_endpoint_of_segment(vv); Storage_site_2 ssvp = vp->storage_site(); Storage_site_2 sss = split_storage_site(ss, ssvp, 0, itag); return insert_segment_interior(sss.site(), sss, vp); } else { // this should never be reached; the only possible values for // at_res are DISJOINT, CROSSING, TOUCH_11_INTERIOR_1 // and TOUCH_12_INTERIOR_1 CGAL_assertion( false ); } } else { CGAL_assertion( vv->is_point() ); if ( at_res == AT2::INTERIOR ) { Storage_site_2 ssvv = vv->storage_site(); if ( ssvv.is_input() ) { Intersections_tag itag; Storage_site_2 ss1 = split_storage_site(ss, ssvv, 0, itag); Storage_site_2 ss2 = split_storage_site(ss, ssvv, 1, itag); insert_segment_interior(ss1.site(), ss1, vv); return insert_segment_interior(ss2.site(), ss2, vv); } else { // this should never be reached; the only possible values for // at_res are DISJOINT and INTERIOR CGAL_assertion( false ); } } } ++vc; } while ( vc != vc_start ); // first look for conflict with vertex Face_circulator fc_start = vnearest->incident_faces(); Face_circulator fc = fc_start; Face_handle start_f; Sign s; std::map sign_map; do { Face_handle f(fc); s = incircle(f, t); sign_map[f] = s; if ( s == NEGATIVE ) { start_f = f; break; } ++fc; } while ( fc != fc_start ); // segments must have a conflict with at least one vertex CGAL_assertion( s == NEGATIVE ); // we are in conflict with a Voronoi vertex; start from that and // find the entire conflict region and then repair the diagram List l; Face_map fm; Triple vcross(false, Vertex_handle(), AT2::DISJOINT); // MK:: NEED TO WRITE A FUNCTION CALLED find_conflict_region WHICH // IS GIVEN A STARTING FACE, A LIST, A FACE MAP, A VERTEX MAP AND A // LIST OF FLIPPED EDGES AND WHAT IS DOES IS INITIALIZE THE CONFLICT // REGION AND EXPANDS THE CONFLICT REGION. initialize_conflict_region(start_f, l); expand_conflict_region(start_f, t, ss, l, fm, sign_map, vcross); CGAL_assertion( vcross.third == AT2::DISJOINT || vcross.third == AT2::CROSSING || vcross.third == AT2::INTERIOR ); // the following condition becomes true only if intersecting // segments are found if ( vcross.first ) { if ( t.is_segment() ) { if ( vcross.third == AT2::CROSSING ) { Intersections_tag itag; return insert_intersecting_segment(ss, t, vcross.second, itag); } else if ( vcross.third == AT2::INTERIOR ) { Storage_site_2 ssvv = vcross.second->storage_site(); Intersections_tag itag; Storage_site_2 ss1 = split_storage_site(ss, ssvv, 0, itag); Storage_site_2 ss2 = split_storage_site(ss, ssvv, 1, itag); insert_segment_interior(ss1.site(), ss1, vcross.second); return insert_segment_interior(ss2.site(), ss2, vcross.second); } else { // this should never be reached; the only possible values for // vcross.third are CROSSING, INTERIOR and DISJOINT CGAL_assertion( false ); } } } // no intersecting segment has been found; we insert the segment as // usual... Vertex_handle v = create_vertex(ss); retriangulate_conflict_region(v, l, fm); return v; } //-------------------------------------------------------------------- // insertion of an intersecting segment //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, Tag_false) { #if defined(__POWERPC__) && \ defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ == 4) // hack to avoid nasty warning for G++ 3.4 on Darwin static int i; #else static int i = 0; #endif if ( i == 0 ) { i = 1; print_error_message(); } return Vertex_handle(); } template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, Tag_true tag) { CGAL_precondition( t.is_segment() && v->is_segment() ); const Storage_site_2& ssitev = v->storage_site(); Site_2 sitev = ssitev.site(); if ( same_segments(t, sitev) ) { return v; } Vertex_triple vt = insert_point_on_segment(ss, t, v, tag); Vertex_handle vsx = vt.first; Storage_site_2 ss3, ss4; Site_2 s3, s4; if ( t.is_input(0) ) { ss3 = create_storage_site(ss, ssitev, true); } else { ss3 = create_storage_site_type1(ss, ss, ssitev); } s3 = ss3.site(); if ( t.is_input(1) ) { ss4 = create_storage_site(ss, ssitev, false); } else { ss4 = create_storage_site_type2(ss, ssitev, ss); } s4 = ss4.site(); insert_segment_interior(s3, ss3, vsx); insert_segment_interior(s4, ss4, vsx); return vsx; } //-------------------------------------------------------------------- //-------------------------------------------------------------------- // helper methods for insertion (find conflict region) //-------------------------------------------------------------------- //-------------------------------------------------------------------- template void Segment_Voronoi_diagram_2:: initialize_conflict_region(const Face_handle& f, List& l) { l.clear(); for (int i = 0; i < 3; i++) { l.push_back(sym_edge(f, i)); } } template void Segment_Voronoi_diagram_2:: expand_conflict_region(const Face_handle& f, const Site_2& t, const Storage_site_2& ss, List& l, Face_map& fm, std::map& sign_map, Triple& vcross) { if ( fm.find(f) != fm.end() ) { return; } // this is done to stop the recursion when intersecting segments // are found if ( vcross.first ) { return; } // setting fm[f] to true means that the face has been reached and // that the face is available for recycling. If we do not want the // face to be available for recycling we must set this flag to // false. fm[f] = true; // CGAL_assertion( fm.find(f) != fm.end() ); for (int i = 0; i < 3; i++) { Face_handle n = f->neighbor(i); bool face_registered = (fm.find(n) != fm.end()); if ( !face_registered ) { for (int j = 0; j < 3; j++) { Vertex_handle vf = n->vertex(j); if ( is_infinite(vf) ) { continue; } Arrangement_type at_res = arrangement_type(t, vf); CGAL_assertion( vcross.third == AT2::DISJOINT || vcross.third == AT2::CROSSING || vcross.third == AT2::INTERIOR ); if ( vf->is_segment() ) { CGAL_assertion( at_res != AT2::IDENTICAL ); CGAL_assertion( at_res != AT2::TOUCH_11_INTERIOR_1 ); CGAL_assertion( at_res != AT2::TOUCH_12_INTERIOR_1 ); if ( at_res == AT2::CROSSING ) { vcross.first = true; vcross.second = vf; vcross.third = AT2::CROSSING; l.clear(); fm.clear(); return; } else { CGAL_assertion ( at_res == AT2::DISJOINT || at_res == AT2::TOUCH_1 || at_res == AT2::TOUCH_2 || at_res == AT2::TOUCH_11 || at_res == AT2::TOUCH_12 || at_res == AT2::TOUCH_21 || at_res == AT2::TOUCH_22 ); // we do nothing in these cases } } else { CGAL_assertion( vf->is_point() ); if ( at_res == AT2::INTERIOR ) { vcross.first = true; vcross.second = vf; vcross.third = AT2::INTERIOR; l.clear(); fm.clear(); return; } } } } Sign s = incircle(n, t); sign_map[n] = s; Sign s_f = sign_map[f]; if ( s == POSITIVE ) { continue; } if ( s != s_f ) { continue; } bool interior_in_conflict = edge_interior(f, i, t, s); if ( !interior_in_conflict ) { continue; } if ( face_registered ) { continue; } Edge e = sym_edge(f, i); CGAL_assertion( l.is_in_list(e) ); int j = f->mirror_index(i); Edge e_before = sym_edge(n, ccw(j)); Edge e_after = sym_edge(n, cw(j)); if ( !l.is_in_list(e_before) ) { l.insert_before(e, e_before); } if ( !l.is_in_list(e_after) ) { l.insert_after(e, e_after); } l.remove(e); expand_conflict_region(n, t, ss, l, fm, sign_map, vcross); // this is done to stop the recursion when intersecting segments // are found // if ( fm.size() == 0 && l.size() == 0 ) { return; } if ( vcross.first ) { return; } } // for-loop } //-------------------------------------------------------------------- // retriangulate conflict region //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: add_bogus_vertex(Edge e, List& l) { Edge esym = sym_edge(e); Face_handle g1 = e.first; Face_handle g2 = esym.first; Vertex_handle v = insert_degree_2(e); Face_circulator fc(v); Face_handle f1(fc); Face_handle f2(++fc); int i1 = f1->index(v); int i2 = f2->index(v); CGAL_assertion( ((f1->neighbor(i1) == g1) && (f2->neighbor(i2) == g2)) || ((f1->neighbor(i1) == g2) && (f2->neighbor(i2) == g1)) ); Edge ee, eesym; if ( f1->neighbor(i1) == g1 ) { ee = Edge(f2, i2); eesym = Edge(f1, i1); } else { ee = Edge(f1, i1); eesym = Edge(f2, i2); } l.replace(e, ee); l.replace(esym, eesym); return v; } template typename Segment_Voronoi_diagram_2::Vertex_list Segment_Voronoi_diagram_2:: add_bogus_vertices(List& l) { Vertex_list vertex_list; std::set edge_list; edge_list.clear(); Edge e_start = l.front(); Edge e = e_start; do { Edge esym = sym_edge(e); if ( l.is_in_list(esym) && edge_list.find(esym) == edge_list.end() ) { edge_list.insert(e); } e = l.next(e); } while ( e != e_start ); typename std::set::iterator it; for (it = edge_list.begin(); it != edge_list.end(); ++it) { Vertex_handle v = add_bogus_vertex(*it, l); vertex_list.push_back(v); } return vertex_list; } template void Segment_Voronoi_diagram_2:: remove_bogus_vertices(Vertex_list& vl) { while ( vl.size() > 0 ) { Vertex_handle v = vl.front(); vl.pop_front(); remove_degree_2(v); } } template void Segment_Voronoi_diagram_2:: retriangulate_conflict_region(Vertex_handle v, List& l, Face_map& fm) { // 1. add the bogus vetrices Vertex_list dummy_vertices = add_bogus_vertices(l); // 2. repair the face pointers... Edge e_start = l.front(); Edge eit = e_start; do { Edge esym = sym_edge(eit); Face_handle f = eit.first; int k = eit.second; CGAL_assertion( !l.is_in_list(esym) ); CGAL_assertion( fm.find(f) == fm.end() ); f->vertex(ccw(k))->set_face(f); f->vertex( cw(k))->set_face(f); eit = l.next(eit); } while ( eit != e_start ); // 3. copy the edge list to a vector of edges and clear the edge list std::vector ve; Edge efront = l.front(); Edge e = efront; do { ve.push_back(e); e = l.next(e); } while ( e != efront ); l.clear(); // 4. retriangulate the hole this->_tds.star_hole(v, ve.begin(), ve.end()); // 5. remove the bogus vertices remove_bogus_vertices(dummy_vertices); // 6. remove the unused faces typename Face_map::iterator it; for (it = fm.begin(); it != fm.end(); ++it) { Face_handle fh = (*it).first; this->_tds.delete_face(fh); } fm.clear(); // 7. DONE!!!! } //-------------------------------------------------------------------- //-------------------------------------------------------------------- // combinatorial operations //-------------------------------------------------------------------- //-------------------------------------------------------------------- //-------------------------------------------------------------------- //-------------------------------------------------------------------- // point location //-------------------------------------------------------------------- //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Vertex_handle Segment_Voronoi_diagram_2:: nearest_neighbor(const Site_2& p, Vertex_handle start_vertex) const { CGAL_precondition( p.is_point() ); if ( number_of_vertices() == 0 ) { return Vertex_handle(); } if ( start_vertex == Vertex_handle() ) { start_vertex = finite_vertex(); } // if ( start_vertex == NULL ) { return start_vertex; } Vertex_handle vclosest; Vertex_handle v = start_vertex; if ( number_of_vertices() < 3 ) { vclosest = v; Finite_vertices_iterator vit = finite_vertices_begin(); for (; vit != finite_vertices_end(); ++vit) { Vertex_handle v1(vit); if ( v1 != vclosest /*&& !is_infinite(v1)*/ ) { Site_2 t0 = vclosest->site(); Site_2 t1 = v1->site(); if ( side_of_bisector(t0, t1, p) == ON_NEGATIVE_SIDE ) { vclosest = v1; } } } return vclosest; } do { vclosest = v; Site_2 t0 = v->site(); Vertex_circulator vc_start = incident_vertices(v); Vertex_circulator vc = vc_start; do { if ( !is_infinite(vc) ) { Vertex_handle v1(vc); Site_2 t1 = v1->site(); Oriented_side os = side_of_bisector(t0, t1, p); if ( os == ON_NEGATIVE_SIDE ) { v = v1; break; } } ++vc; } while ( vc != vc_start ); } while ( vclosest != v ); return vclosest; } //---------------------------------------------------------------------- //---------------------------------------------------------------------- // methods for the predicates //---------------------------------------------------------------------- //---------------------------------------------------------------------- template Sign Segment_Voronoi_diagram_2:: incircle(const Face_handle& f, const Site_2& q) const { if ( !is_infinite(f) ) { return incircle(f->vertex(0)->site(), f->vertex(1)->site(), f->vertex(2)->site(), q); } int inf_i(-1); // to avoid compiler warning for (int i = 0; i < 3; i++) { if ( is_infinite(f->vertex(i)) ) { inf_i = i; break; } } return incircle( f->vertex( ccw(inf_i) )->site(), f->vertex( cw(inf_i) )->site(), q ); } template Sign Segment_Voronoi_diagram_2:: incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v) const { CGAL_precondition( !is_infinite(v) ); if ( !is_infinite(v0) && !is_infinite(v1) && !is_infinite(v2) ) { return incircle(v0->site(), v1->site(), v2->site(), v->site()); } if ( is_infinite(v0) ) { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) ); return incircle( v1->site(), v2->site(), v->site()); } if ( is_infinite(v1) ) { CGAL_precondition( !is_infinite(v0) && !is_infinite(v2) ); return incircle( v2->site(), v0->site(), v->site()); } CGAL_assertion( is_infinite(v2) ); CGAL_precondition( !is_infinite(v0) && !is_infinite(v1) ); return incircle( v0->site(), v1->site(), v->site()); } // this the finite edge interior predicate for a degenerate edge template bool Segment_Voronoi_diagram_2:: finite_edge_interior(const Face_handle& f, int i, const Site_2& q, Sign sgn, int) const { if ( !is_infinite( f->mirror_vertex(i) ) ) { CGAL_precondition( is_infinite(f->vertex(i)) ); Face_handle g = f->neighbor(i); int j = f->mirror_index(i); return finite_edge_interior(g, j, q, sgn, 0 /* degenerate */); } CGAL_precondition( is_infinite( f->mirror_vertex(i) ) ); Site_2 t1 = f->vertex( ccw(i) )->site(); Site_2 t2 = f->vertex( cw(i) )->site(); if ( is_infinite(f->vertex(i)) ) { return finite_edge_interior(t1, t2, q, sgn); } Site_2 t3 = f->vertex(i)->site(); return finite_edge_interior(t1, t2, t3, q, sgn); } template bool Segment_Voronoi_diagram_2:: finite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign sgn, int) const { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) && !is_infinite(v) ); if ( !is_infinite( v4 ) ) { CGAL_precondition( is_infinite(v3) ); return finite_edge_interior(v2, v1, v4, v3, v, sgn, 0 /* degenerate */); } CGAL_precondition( is_infinite( v4 ) ); Site_2 t1 = v1->site(); Site_2 t2 = v2->site(); Site_2 q = v->site(); if ( is_infinite(v3) ) { return finite_edge_interior(t1, t2, q, sgn); } Site_2 t3 = v3->site(); return finite_edge_interior(t1, t2, t3, q, sgn); } template bool Segment_Voronoi_diagram_2:: infinite_edge_interior(const Face_handle& f, int i, const Site_2& q, Sign sgn) const { if ( !is_infinite( f->vertex(ccw(i)) ) ) { CGAL_precondition( is_infinite( f->vertex(cw(i)) ) ); Face_handle g = f->neighbor(i); int j = f->mirror_index(i); return infinite_edge_interior(g, j, q, sgn); } CGAL_precondition( is_infinite( f->vertex(ccw(i)) ) ); Site_2 t2 = f->vertex( cw(i) )->site(); Site_2 t3 = f->vertex( i )->site(); Site_2 t4 = f->mirror_vertex(i)->site(); return infinite_edge_interior(t2, t3, t4, q, sgn); } template bool Segment_Voronoi_diagram_2:: infinite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign sgn) const { CGAL_precondition( !is_infinite(v3) && !is_infinite(v4) && !is_infinite(v) ); if ( !is_infinite( v1 ) ) { CGAL_precondition( is_infinite( v2 ) ); return infinite_edge_interior(v2, v1, v4, v3, v, sgn); } CGAL_precondition( is_infinite( v1 ) ); Site_2 t2 = v2->site(); Site_2 t3 = v3->site(); Site_2 t4 = v4->site(); Site_2 q = v->site(); return infinite_edge_interior(t2, t3, t4, q, sgn); } template bool Segment_Voronoi_diagram_2:: edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign sgn) const { CGAL_precondition( !is_infinite(v) ); bool is_inf_v1 = is_infinite(v1); bool is_inf_v2 = is_infinite(v2); bool is_inf_v3 = is_infinite(v3); bool is_inf_v4 = is_infinite(v4); bool result; if ( !is_inf_v1 && !is_inf_v2 && !is_inf_v3 && !is_inf_v4 ) { result = finite_edge_interior(v1, v2, v3, v4, v, sgn); } else if ( is_inf_v3 || is_inf_v4 ) { result = finite_edge_interior(v1, v2, v3, v4, v, sgn, 0/* degenerate */); } else { result = infinite_edge_interior(v1, v2, v3, v4, v, sgn); } return result; } template bool Segment_Voronoi_diagram_2:: edge_interior(const Face_handle& f, int i, const Site_2& q, Sign sgn) const { Face_handle g = f->neighbor(i); bool is_inf_f = is_infinite(f); bool is_inf_g = is_infinite(g); bool result; if ( !is_inf_f && !is_inf_g ) { result = finite_edge_interior(f, i, q, sgn); } else if ( !is_inf_f || !is_inf_g ) { result = finite_edge_interior(f, i, q, sgn, 0 /* denegerate */); } else { if ( !is_infinite(f, i) ) { result = finite_edge_interior(f, i, q, sgn, 0 /* degenerate */); } else { result = infinite_edge_interior(f, i, q, sgn); } } return result; } template typename Segment_Voronoi_diagram_2::Arrangement_type Segment_Voronoi_diagram_2:: arrangement_type(const Site_2& p, const Site_2& q) const { typedef typename Geom_traits::Arrangement_type_2 AT2; typedef typename AT2::result_type Arrangement_type; Arrangement_type res = geom_traits().arrangement_type_2_object()(p, q); // The valeus that have to be treated are the following: // DISJOINT, TOUCH_1, TOUCH_2, CROSSING, IDENTICAL, INTERIOR, // TOUCH_11_INTERIOR_1, TOUCH_12_INTERIOR_1, TOUCH_21_INTERIOR_1 and // TOUCH_22_INTERIOR_1. // // The remaining values will either never appear because of one of // the following reasons: // 1. we insert the endpoints of the segments first and then the // interior (OVERLAPPING_*, INTERIOR_*, TOUCH_*_INTERIOR_2). // 2. the values have no meaning since we consider the segments to // be open (TOUCH_INTERIOR_*). In this case, the conflict will // appear when we test with the endpoint. // 3. a conflict will first happen with an endpoint before testing // for the segment (TOUCH_2*_INTERIOR_1). In this case the // segment to be inserted will first find an endpoint in its // interior before actually finding that there is another segment // it overlaps with. CGAL_assertion( res != AT2::INTERIOR_1 ); CGAL_assertion( res != AT2::INTERIOR_2 ); CGAL_assertion( res != AT2::OVERLAPPING_11 ); CGAL_assertion( res != AT2::OVERLAPPING_12 ); CGAL_assertion( res != AT2::OVERLAPPING_21 ); CGAL_assertion( res != AT2::OVERLAPPING_22 ); CGAL_assertion( res != AT2::TOUCH_11_INTERIOR_2 ); CGAL_assertion( res != AT2::TOUCH_21_INTERIOR_2 ); CGAL_assertion( res != AT2::TOUCH_12_INTERIOR_2 ); CGAL_assertion( res != AT2::TOUCH_22_INTERIOR_2 ); CGAL_assertion( res != AT2::TOUCH_21_INTERIOR_1 ); CGAL_assertion( res != AT2::TOUCH_22_INTERIOR_1 ); if ( res == AT2::TOUCH_INTERIOR_12 || res == AT2::TOUCH_INTERIOR_21 || res == AT2::TOUCH_INTERIOR_11 || res == AT2::TOUCH_INTERIOR_22 ) { return AT2::DISJOINT; } if ( res == AT2::TOUCH_11 || res == AT2::TOUCH_12 || res == AT2::TOUCH_21 || res == AT2::TOUCH_22 ) { return AT2::DISJOINT; } return res; } //-------------------------------------------------------------------- //-------------------------------------------------------------------- // embedding and visualization methods and constructions for primal // and dual //-------------------------------------------------------------------- //-------------------------------------------------------------------- // primal template Object Segment_Voronoi_diagram_2:: primal(const Edge e) const { typedef typename Gt::Line_2 Line_2; typedef typename Gt::Ray_2 Ray_2; CGAL_precondition( !is_infinite(e) ); if ( this->dimension() == 1 ) { Site_2 p = (e.first)->vertex(cw(e.second))->site(); Site_2 q = (e.first)->vertex(ccw(e.second))->site(); Line_2 l = construct_svd_bisector_2_object()(p,q); return make_object(l); } // dimension == 2 // none of the two adjacent faces is infinite if( (!is_infinite(e.first)) && (!is_infinite(e.first->neighbor(e.second))) ) { Site_2 p = (e.first)->vertex( ccw(e.second) )->site(); Site_2 q = (e.first)->vertex( cw(e.second) )->site(); Site_2 r = (e.first)->vertex( e.second )->site(); Site_2 s = (e.first)->mirror_vertex(e.second)->site(); return construct_svd_bisector_segment_2_object()(p,q,r,s); } // both of the adjacent faces are infinite if ( is_infinite(e.first) && is_infinite(e.first->neighbor(e.second)) ) { Site_2 p = (e.first)->vertex(cw(e.second))->site(); Site_2 q = (e.first)->vertex(ccw(e.second))->site(); Line_2 l = construct_svd_bisector_2_object()(p,q); return make_object(l); } // only one of the adjacent faces is infinite CGAL_assertion( is_infinite( e.first ) || is_infinite( e.first->neighbor(e.second) ) ); CGAL_assertion( !(is_infinite( e.first ) && is_infinite( e.first->neighbor(e.second) ) ) ); CGAL_assertion( is_infinite( e.first->vertex(e.second) ) || is_infinite( e.first->mirror_vertex(e.second) ) ); Edge ee = e; if ( is_infinite( e.first->vertex(e.second) ) ) { ee = sym_edge(e); } Site_2 p = ee.first->vertex( ccw(ee.second) )->site(); Site_2 q = ee.first->vertex( cw(ee.second) )->site(); Site_2 r = ee.first->vertex( ee.second )->site(); Ray_2 ray = construct_svd_bisector_ray_2_object()(p,q,r); return make_object(ray); } //-------------------------------------------------------------------- //-------------------------------------------------------------------- // validity test method //-------------------------------------------------------------------- //-------------------------------------------------------------------- template bool Segment_Voronoi_diagram_2:: is_valid(bool verbose, int level) const { if (level < 0) { return true; } if (number_of_vertices() <= 1) { return true; } // level 0 test: check the TDS bool result = data_structure().is_valid(verbose, level); if ( result && verbose ) { std::cerr << "SVDDS is ok... " << std::flush; } if (level == 0) { return result; } // level 1 test: do the incircle tests if (number_of_vertices() < 3) { return true; } for (All_edges_iterator eit = all_edges_begin(); eit != all_edges_end(); ++eit) { Edge e = *eit; Face_handle f = e.first; Vertex_handle v = f->mirror_vertex(e.second); if ( f->vertex(e.second) == v ) { continue; } if ( !is_infinite(v) ) { result = result && ( incircle(f, v->site()) != NEGATIVE ); } Edge sym_e = sym_edge(e); f = sym_e.first; v = f->mirror_vertex(sym_e.second); if ( !is_infinite(v) ) { result = result && ( incircle(f, v->site()) != NEGATIVE ); } } if ( result && verbose ) { std::cerr << "Segment Voronoi diagram is ok..." << std::flush; } if ( !result && verbose ) { std::cerr << "Segment Voronoi diagram is NOT valid..." << std::flush; } return result; } //-------------------------------------------------------------------- //-------------------------------------------------------------------- // misc //-------------------------------------------------------------------- //-------------------------------------------------------------------- template void Segment_Voronoi_diagram_2:: print_error_message() const { std::cerr << std::endl; std::cerr << "WARNING:" << std::endl; std::cerr << "A segment-segment intersection was found." << std::endl; std::cerr << "The segment Voronoi diagram class is not configured" << " to handle this situation." << std::endl; std::cerr << "Please look at the documentation on how to handle" << " this behavior." << std::endl; std::cerr << std::endl; } //-------------------------------------------------------------------- //-------------------------------------------------------------------- // the copy method //-------------------------------------------------------------------- //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_2::Storage_site_2 Segment_Voronoi_diagram_2:: copy_storage_site(const Storage_site_2& ss_other, Handle_map& hm, const Tag_false&) { if ( ss_other.is_segment() ) { Point_handle p0 = hm[ ss_other.source_of_supporting_site() ]; Point_handle p1 = hm[ ss_other.target_of_supporting_site() ]; return Storage_site_2::construct_storage_site_2(p0, p1); } else { Point_handle p0 = hm[ ss_other.point() ]; return Storage_site_2::construct_storage_site_2(p0); } } template typename Segment_Voronoi_diagram_2::Storage_site_2 Segment_Voronoi_diagram_2:: copy_storage_site(const Storage_site_2& ss_other, Handle_map& hm, const Tag_true&) { if ( ss_other.is_segment() ) { if ( ss_other.is_input() ) { Point_handle p0 = hm[ ss_other.source_of_supporting_site() ]; Point_handle p1 = hm[ ss_other.target_of_supporting_site() ]; return Storage_site_2::construct_storage_site_2(p0, p1); } else if ( ss_other.is_input(0) ) { Point_handle p0 = hm[ ss_other.source_of_supporting_site() ]; Point_handle p1 = hm[ ss_other.target_of_supporting_site() ]; Point_handle p4 = hm[ ss_other.source_of_crossing_site(1) ]; Point_handle p5 = hm[ ss_other.target_of_crossing_site(1) ]; return Storage_site_2::construct_storage_site_2(p0, p1, p4, p5, true); } else if ( ss_other.is_input(1) ) { Point_handle p0 = hm[ ss_other.source_of_supporting_site() ]; Point_handle p1 = hm[ ss_other.target_of_supporting_site() ]; Point_handle p2 = hm[ ss_other.source_of_crossing_site(0) ]; Point_handle p3 = hm[ ss_other.target_of_crossing_site(0) ]; return Storage_site_2::construct_storage_site_2(p0, p1, p2, p3, false); } else { Point_handle p0 = hm[ ss_other.source_of_supporting_site() ]; Point_handle p1 = hm[ ss_other.target_of_supporting_site() ]; Point_handle p2 = hm[ ss_other.source_of_crossing_site(0) ]; Point_handle p3 = hm[ ss_other.target_of_crossing_site(0) ]; Point_handle p4 = hm[ ss_other.source_of_crossing_site(1) ]; Point_handle p5 = hm[ ss_other.target_of_crossing_site(1) ]; return Storage_site_2::construct_storage_site_2(p0, p1, p2, p3, p4, p5); } } else { if ( ss_other.is_input() ) { Point_handle p0 = hm[ ss_other.point() ]; return Storage_site_2::construct_storage_site_2(p0); } else { Point_handle p2 = hm[ ss_other.source_of_supporting_site(0) ]; Point_handle p3 = hm[ ss_other.target_of_supporting_site(0) ]; Point_handle p4 = hm[ ss_other.source_of_supporting_site(1) ]; Point_handle p5 = hm[ ss_other.target_of_supporting_site(1) ]; return Storage_site_2::construct_storage_site_2(p2, p3, p4, p5); } } } template void Segment_Voronoi_diagram_2:: copy(Segment_Voronoi_diagram_2& other) { // first copy the point container and input point container pc_ = other.pc_; // first create a map between the old point handles and the new ones Handle_map hm; Point_handle it_other = other.pc_.begin(); Point_handle it_this = pc_.begin(); for (; it_other != other.pc_.end(); ++it_other, ++it_this) { hm.insert( Point_handle_pair(it_other, it_this) ); } copy(other, hm); } template void Segment_Voronoi_diagram_2:: copy(Segment_Voronoi_diagram_2& other, Handle_map& hm) { // second, copy the site representation info for the input sites // using the correct handles (i.e., the handles from the new point // container isc_.clear(); typename Input_sites_container::iterator iit_other = other.isc_.begin(); for (; iit_other != other.isc_.end(); ++iit_other) { Site_rep_2 old_srep = *iit_other; Site_rep_2 new_srep( hm[boost::tuples::get<0>(old_srep)], hm[boost::tuples::get<1>(old_srep)], boost::tuples::get<2>(old_srep) ); isc_.push_back( new_srep ); } CGAL_assertion( pc_.size() == other.pc_.size() ); CGAL_assertion( isc_.size() == other.isc_.size() ); #ifndef CGAL_NO_ASSERTIONS { Point_handle it_other = other.pc_.begin(); Point_handle it_this = pc_.begin(); for (; it_other != other.pc_.end(); ++it_other, ++it_this) { CGAL_assertion( *it_other == *it_this ); } } #endif // then copy the diagram DG::operator=(other); // now we have to update the sotrage sites in each vertex of the // diagram and also update the // then update the storage sites for each vertex Intersections_tag itag; Finite_vertices_iterator vit_other = other.finite_vertices_begin(); Finite_vertices_iterator vit_this = finite_vertices_begin(); for (; vit_other != other.finite_vertices_end(); vit_other++, vit_this++) { Storage_site_2 ss_other = vit_other->storage_site(); #ifndef CGAL_NO_ASSERTIONS Storage_site_2 ss_this = vit_this->storage_site(); if ( ss_other.is_segment() ) { CGAL_assertion( ss_this.is_segment() ); CGAL_assertion( same_segments(ss_this.site(), ss_other.site()) ); } else { CGAL_assertion( ss_this.is_point() ); CGAL_assertion( same_points(ss_this.site(), ss_other.site()) ); } #endif Storage_site_2 new_ss_this = copy_storage_site(ss_other, hm, itag); vit_this->set_site( new_ss_this ); } } CGAL_END_NAMESPACE // EOF mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/user_classes.h0000644000175000017500000000354511344301501027674 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/user_classes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_USER_CLASSES_H #define CGAL_USER_CLASSES_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // CGAL_USER_CLASSES_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_pair.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000001204111344301500031406 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_pair.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_PAIR #define CGAL_MINIBALL_PAIR namespace CGAL_MINIBALL_NAMESPACE { namespace Min_sphere_of_spheres_d_impl { const double Min_float = 1.0e-120; const double Eps = 1.0e-16; const double SqrOfEps = 1.0e-32; const double Tol = 1.0+Eps; } template inline FT sqr(const FT& x) { return x*x; } // We do not use std::inner_product() because in our case the number n // of operands is known. An optimizing compiler like GCC thus unrolls // the following loop. The same holds for copy_n(). template inline T inner_product_n(InputIterator1 first1,InputIterator2 first2,T init, BinaryOperation1 op1,BinaryOperation2 op2) { for (int i=0; i inline void copy_n(InputIterator first,OutputIterator result) { for (int i=0; i class Pair : public std::pair { private: typedef std::pair Base; public: // construction: Pair() : Base() {} Pair(const FT& a,const FT& b) : Base(a,b) {} Pair(int i) : Base(i,0) {} Pair& operator=(const FT& x) { this->first = x; this->second = 0; return *this; } public: // arithmetic and comparision: inline Pair operator+(const Pair& a) const { return Pair(this->first+a.first,this->second+a.second); } inline Pair operator-(const Pair& a) const { return Pair(this->first-a.first,this->second-a.second); } inline Pair operator-(const FT& a) const { return Pair(this->first-a,this->second); } inline Pair operator*(const FT& a) const { return Pair(this->first*a,this->second*a); } inline Pair operator/(const FT& a) const { CGAL_MINIBALL_ASSERT(a != FT(0)); return Pair(this->first/a,this->second/a); } inline Pair& operator+=(const Pair& p) { this->first += p.first; this->second += p.second; return *this; } inline Pair& operator-=(const Pair& p) { this->first -= p.first; this->second -= p.second; return *this; } inline bool operator!=(const Pair& p) const { return this->first!=p.first || this->second!=p.second; } }; template inline Pair operator+(const FT& a,const Pair& p) { return Pair(a+p.first,p.second); } template inline Pair operator-(const FT& a,const Pair& p) { return Pair(a-p.first,-p.second); } template inline bool is_neg(const FT& p,const FT&) { return p < 0; } template inline bool is_neg(const Pair p,const FT& d) { const bool aneg = p.first=0 and (ii) a>=0,b<0: // (i) We need to test b*sqrt(d)<-a with b,-a>=0. // (ii) We need to test a<(-b)*sqrt(d) with a,-b>=0. // Hence: const FT x = sqr(p.second)*d, y = sqr(p.first); return aneg? x inline bool is_zero(const Pair p,const FT& d) { if (d != FT(0)) // check whether the sides of a=-b*sqrt(d) (*) // have different signs: if ((p.first>FT(0)) ^ (p.second0,b<0,d!=0, or // (iii) a<=0,b>=0,d!=0 // Hence both sides of (*) are either positive or negative. return sqr(p.first) == sqr(p.second)*d; } template inline bool is_neg_or_zero(const FT& p,const FT& d) { return p <= 0; } template inline bool is_neg_or_zero(const Pair p,const FT& d) { return is_neg(p,d) || is_zero(p,d); } } // namespace CGAL_MINIBALL_NAMESPACE #endif // CGAL_MINIBALL_PAIR ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_0000644000175000017500000000634311344301500031460 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_D_TRAITS_3_H #define CGAL_OPTIMISATION_D_TRAITS_3_H // includes #ifndef CGAL_OPTIMISATION_ACCESS_DIMENSION_3_H # include #endif #ifndef CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_3_H # include #endif #ifndef CGAL_OPTIMISATION_CONSTRUCT_POINT_3_H # include #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K_, class ET_ = typename K_::RT, class NT_ = typename K_::RT > class Optimisation_d_traits_3; // Class interface // =============== template < class K_, class ET_, class NT_> class Optimisation_d_traits_3 { public: // self typedef K_ K; typedef ET_ ET; typedef NT_ NT; typedef Optimisation_d_traits_3 Self; // types typedef typename K::Point_3 Point_d; typedef typename K::Rep_tag Rep_tag; typedef typename K::RT RT; typedef typename K::FT FT; typedef CGAL::Access_dimension_3 Access_dimension_d; typedef CGAL::Access_coordinates_begin_3 Access_coordinates_begin_d; typedef _Construct_point_3 Construct_point_d; // this does not (yet) work: // typedef typename K::Construct_point_3 Construct_point_d; // creation Optimisation_d_traits_3( ) { } Optimisation_d_traits_3( const Optimisation_d_traits_3&) {} // operations Access_dimension_d access_dimension_d_object( ) const { return Access_dimension_d(); } Access_coordinates_begin_d access_coordinates_begin_d_object( ) const { return Access_coordinates_begin_d(); } Construct_point_d construct_point_d_object( ) const { return Construct_point_d(); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_D_TRAITS_3_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/simplest_rational_in_interval.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/simplest_rational_in_i0000644000175000017500000000670211344301501031500 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/simplest_rational_in_interval.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Susan Hert, Sylvain Pion #ifndef CGAL_SIMPLEST_RATIONAL_IN_INTERVAL_H #define CGAL_SIMPLEST_RATIONAL_IN_INTERVAL_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE /* simplest_rational_in_interval(x,y) returns the rational number with the smallest denominator in the interval [x,y]. See Knuth, "Seminumerical algorithms", page 654, answer to exercise 4.53-39. */ template Rational simplest_rational_in_interval(double x, double y) { if(x == y){ return to_rational(x); } if(x > y){ std::swap(x,y); } Rational r; // Return value. typename Rational_traits::RT r_numerator, r_denominator; Rational_traits t; // Deal with negative arguments. We only have to deal with the case // where both x and y are negative -- when exactly one is negative // the best rational in the interval [x,y] is 0. if (x < 0 && y < 0) { // Both arguments are negative: solve positive case and negate return - simplest_rational_in_interval(fabs(x),fabs(y)); } else if (x <= 0 || y <= 0) { // One argument is 0, or arguments are on opposite sides of 0: // simplest rational in interval is 0 exactly. r_numerator = 0; r_denominator = 1; } else { // x > 0 && y > 0 double xc = CGAL_CLIB_STD::floor(1/x); // First coefficient of cf for x. double xr = CGAL_CLIB_STD::fmod(1/x,1); // Remaining fractional part of x. double yc = CGAL_CLIB_STD::floor(1/y); // First coefficient of cf for y. double yr = CGAL_CLIB_STD::fmod(1/y,1); // Remaining fractional part of y. if (xc < yc) { // Return 1/(xc+1). r_numerator = 1; r_denominator = xc + 1; } else if (yc < xc) { // Return 1/(yc+1). r_numerator = 1; r_denominator = yc + 1; } else { // xc == yc // Recurse to find s, the rational with the lowest denominator // between xr and yr. Rational s(simplest_rational_in_interval(xr,yr)); // Return 1/(xc + s). r_numerator = t.denominator(s); typename Rational_traits::RT xc_rt(xc); r_denominator = t.numerator(s) + xc_rt * t.denominator(s); } } return t.make_rational(r_numerator, r_denominator); } CGAL_END_NAMESPACE #endif //CGAL_SIMPLEST_RATIONAL_IN_INTERVAL_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_advanced_point_location_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_advanced_point_loca0000644000175000017500000000423211344301500031354 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_advanced_point_location_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_PM_ADVANCED_POINT_LOCATION_BASE_H #define CGAL_PM_ADVANCED_POINT_LOCATION_BASE_H #ifndef CGAL_PM_BOUNDING_BOX_BASE_H #include #endif CGAL_BEGIN_NAMESPACE //////////////////////////////////////////////////////////////////// // ABSTRACT BASE CLASS OF STRATEGY ////////////////////////////////////////////////////////////////// template class Pm_advanced_point_location_base : public Pm_advanced_point_location_base<_Planar_map>{ public: typedef _Planar_map Planar_map; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge Halfedge; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; typedef Pm_bounding_box_base Bounding_box; Pm_advanced_point_location_base():Pm_point_location_base {} virtual Halfedge_handle ray_shoot(const Point& p, Locate_type& lt, const X_curve&) = 0; virtual Halfedge_handle x_curve_shoot(const Point& p, Locate_type& lt, const Ray&) = 0; }; CGAL_END_NAMESPACE #endif //CGAL_PM_ADVANCED_POINT_LOCATION_BASE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_graham_andrew.h0000644000175000017500000001020511344301500030440 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_graham_andrew.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_GRAHAM_ANDREW_H #define CGAL_CH_GRAHAM_ANDREW_H #include #include CGAL_BEGIN_NAMESPACE // computes the sorted sequence of extreme points which are not left // of $pq$ and reports this sequence in a range starting at |result|, // where $p$ is the value of |first| and $q$ is the value of |last| $-1$. // The sequence reported starts with $p$, point $q$ is omitted. // {\it Precondition:} The points in [|first|,|last|) are sorted with respect // to $pq$ and the range [|first|,|last|) contains at least two different // points. // {\sc traits}: uses |Traits::Left_turn_2| and |Traits::Equal_2| operating on the // point type |Traits::Point_2|. template OutputIterator ch_graham_andrew_scan( BidirectionalIterator first, BidirectionalIterator last, OutputIterator result, const Traits& ch_traits ); template inline OutputIterator ch_graham_andrew_scan( BidirectionalIterator first, BidirectionalIterator last, OutputIterator result ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_graham_andrew_scan( first, last, result, Kernel()); } template OutputIterator ch__ref_graham_andrew_scan( BidirectionalIterator first, BidirectionalIterator last, OutputIterator& result, const Traits& ch_traits); // same as |convex_hull_2(first,last,result)|. // {\sc traits}: uses |Traits::Point_2|, |Traits::Left_turn_2| // and |Traits::Less_xy_2|. template OutputIterator ch_graham_andrew( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits ); template inline OutputIterator ch_graham_andrew( InputIterator first, InputIterator last, OutputIterator result ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_graham_andrew( first, last, result, Kernel()); } template OutputIterator ch_lower_hull_scan( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits); template OutputIterator ch_upper_hull_scan( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits); CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_GRAHAM_ANDREW_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000001030211344301501031364 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_VERTEX_BASE_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_VERTEX_BASE_2_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template struct SVDVB2_Which_storage_site; // use the simple storage site template struct SVDVB2_Which_storage_site { typedef Gt Geom_traits; typedef Tag_false Storage_site_tag; typedef Segment_Voronoi_diagram_simple_storage_site_2 Storage_site_2; }; // use the full storage site template struct SVDVB2_Which_storage_site { typedef Gt Geom_traits; typedef Tag_true Storage_site_tag; typedef Segment_Voronoi_diagram_storage_site_2 Storage_site_2; }; } // namespace CGALi template < class Gt, class USE_FULL_STORAGE_SITE_Tag = Tag_true, class Vb = Triangulation_ds_vertex_base_2<> > class Segment_Voronoi_diagram_vertex_base_2 : public Vb { private: typedef typename Vb::Triangulation_data_structure DS; typedef std::list PC; typedef Simple_container_wrapper Point_container; typedef Vb Base; public: // TYPES //------ typedef Gt Geom_traits; typedef typename Point_container::iterator Point_handle; typedef typename Gt::Site_2 Site_2; typedef USE_FULL_STORAGE_SITE_Tag Storage_site_tag; private: typedef CGALi::SVDVB2_Which_storage_site Which_storage_site; public: typedef typename Which_storage_site::Storage_site_2 Storage_site_2; typedef DS Data_structure; typedef typename DS::Face_handle Face_handle; typedef typename DS::Vertex_handle Vertex_handle; template < typename DS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Storage_site_tag STag; typedef Segment_Voronoi_diagram_vertex_base_2 Other; }; Segment_Voronoi_diagram_vertex_base_2 () : Vb(), ss_() {} Segment_Voronoi_diagram_vertex_base_2(const Storage_site_2& ss, Face_handle f) : Vb(f), ss_(ss) {} void set_site(const Storage_site_2& ss) { ss_ = ss; } const Storage_site_2& storage_site() const { return ss_; } Site_2 site() const { return ss_.site(); } #if 1 // MK::ERROR: these must be removed; one may use the storage site to // get access to this info... bool is_segment() const { return ss_.is_segment(); } bool is_point() const { return ss_.is_point(); } #endif //the following trivial is_valid to allow // the user of derived face base classes // to add their own purpose checking bool is_valid(bool /* verbose */ = false, int /* level */ = 0) const { return true; } private: Storage_site_2 ss_; // std::list adjseg_list; // list of adjacent segments; this is // important when I want to do deletions }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Triangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Triangle_2_int0000644000175000017500000001342611344301500031203 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Triangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POINT_2_TRIANGLE_2_INTERSECTION_H #define CGAL_POINT_2_TRIANGLE_2_INTERSECTION_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Point_2_Triangle_2_pair { public: enum Intersection_results {NO, POINT}; Point_2_Triangle_2_pair() ; Point_2_Triangle_2_pair(typename K::Point_2 const *pt, typename K::Triangle_2 const *trian); ~Point_2_Triangle_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; protected: typename K::Point_2 const * _pt; typename K::Triangle_2 const * _trian; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; mutable typename K::Point_2 _other_point; }; template inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &p1, const typename CGAL_WRAP(K)::Triangle_2 &p2, const K&) { typedef Point_2_Triangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Triangle_2 &p2, const typename CGAL_WRAP(K)::Point_2 &p1, const K& k) { return CGALi::do_intersect(p1, p2, k); } template Point_2_Triangle_2_pair:: Point_2_Triangle_2_pair() { _known = false; _pt = 0; _trian = 0; } template Point_2_Triangle_2_pair:: Point_2_Triangle_2_pair(typename K::Point_2 const *pt, typename K::Triangle_2 const *trian) { _known = false; _pt = pt; _trian = trian; } template typename Point_2_Triangle_2_pair::Intersection_results Point_2_Triangle_2_pair::intersection_type() const { typedef typename K::Line_2 line_t; if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; if (_trian->has_on_unbounded_side(*_pt)) { _result = NO; } else { _result = POINT; } return _result; /* line_t l(_trian->vertex(0), _trian->vertex(1)); if (l.has_on_positive_side(_trian->vertex(2))) { for (int i=0; i<3; i++) { if (line_t(_trian->vertex(i), _trian->vertex(i+1)). has_on_negative_side(*_pt)) { _result = NO; return _result; } } } else { for (int i=0; i<3; i++) if(line_t(_trian->vertex(i), _trian->vertex(i-1)). has_on_negative_side(*_pt)){ _result = NO; return _result; } } */ } template bool Point_2_Triangle_2_pair:: intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = *_pt; return true; } template Object intersection(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Triangle_2 &tr, const K&) { typedef Point_2_Triangle_2_pair is_t; is_t ispair(&pt, &tr); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { return make_object(pt); } } } template inline Object intersection(const typename CGAL_WRAP(K)::Triangle_2 &tr, const typename CGAL_WRAP(K)::Point_2 &pt, const K&k) { return CGALi::intersection(pt, tr, k); } template class Triangle_2_Point_2_pair : public Point_2_Triangle_2_pair { public: Triangle_2_Point_2_pair( typename K::Triangle_2 const *trian, typename K::Point_2 const *pt) : Point_2_Triangle_2_pair(pt, trian) {} }; } // namespace CGALi template inline bool do_intersect(const Triangle_2 &tr, const Point_2 &pt) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, tr); } template inline bool do_intersect(const Point_2 &pt, const Triangle_2 &tr) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, tr); } template inline Object intersection(const Triangle_2 &tr, const Point_2 &pt) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, tr); } template inline Object intersection(const Point_2 &pt, const Triangle_2 &tr) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, tr); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/0000755000175000017500000000000012146213727027331 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_traits_wrap_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_traits0000644000175000017500000005142211344301501031205 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_traits_wrap_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel // Eyal Flato // Oren Nechushtan // Efi Fogel // Ron Wein #ifndef CGAL_PM_TRAITS_WRAP_H #define CGAL_PM_TRAITS_WRAP_H #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------------- // Pm_traits_wrap_2 - // Geometric Look Up Table. This class extends the user supplied // interface to include various less "shallow" operations that are // impelemented through the interface. //-------------------------------------------------------------------------- template class Pm_traits_wrap_2 : public PlanarMapTraits_2 { public: // typedef typename I::Info_vertex Info_vertex; // typedef typename I::Info_edge Info_edge; // typedef typename I::Info_face Info_face; typedef PlanarMapTraits_2 Base; typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; typedef typename Base::Point_2 Point_2; typedef typename Base::Has_left_category Has_left_category; typedef typename Base::Has_reflect_category Has_reflect_category; // Creators: // --------- Pm_traits_wrap_2() : Base() {} Pm_traits_wrap_2(const Base & i) : Base(i) {} // Predicates: // ----------- bool point_is_left(const Point_2 & p1, const Point_2 & p2) const { return (compare_x(p1, p2) == SMALLER); } bool point_is_right(const Point_2 & p1, const Point_2 & p2) const { return (compare_x(p1, p2) == LARGER); } bool point_equal_x(const Point_2 & p1, const Point_2 & p2) const { return (compare_x(p1, p2) == EQUAL); } bool point_is_left_low(const Point_2 & p1, const Point_2 & p2) const { return (compare_xy(p1, p2) == SMALLER); } bool point_is_right_top(const Point_2 & p1, const Point_2 & p2) const { return point_is_left_low(p2,p1); } const Point_2 & point_leftmost(const Point_2 & p1, const Point_2 & p2) const { return (point_is_left(p1, p2) ? p1 : p2); } const Point_2 & point_rightmost(const Point_2 & p1, const Point_2 & p2) const { return (point_is_right(p1, p2) ? p1 : p2); } const Point_2 & point_leftlow_most (const Point_2 & p1, const Point_2 & p2) const { return (point_is_left_low(p1, p2) ? p1 : p2); } const Point_2 & point_righttop_most (const Point_2 & p1, const Point_2 & p2) const { return (point_is_right_top(p1, p2) ? p1 : p2); } Point_2 curve_leftmost(const X_monotone_curve_2 & cv) const { return point_leftmost(curve_source(cv), curve_target(cv)); } Point_2 curve_rightmost(const X_monotone_curve_2 & cv) const { return point_rightmost(curve_source(cv), curve_target(cv)); } Point_2 curve_leftlow_most(const X_monotone_curve_2 & cv) const { if (!curve_is_vertical(cv)) return curve_leftmost(cv); else return point_leftlow_most(curve_source(cv), curve_target(cv)); } Point_2 curve_righttop_most(const X_monotone_curve_2 & cv) const { if (!curve_is_vertical(cv)) return curve_rightmost(cv); else return point_righttop_most(curve_source(cv), curve_target(cv)); } /*! * The function restuns whether two sub-curves can be merged to create * the input curve. * \param whole The input curve (the merge result). * \param part1 The first sub-curve. * \param part2 The second sub-curve. * \return (true) if whole == part1 + part2. */ bool curve_merge_condition(const X_monotone_curve_2 & whole, const X_monotone_curve_2 & part1, const X_monotone_curve_2 & part2) const { // The function simply checks whether it is possible to merge // the curves part1 and part2 such that whole is the result. if (point_equal(curve_source(whole), curve_source(part1))) if (point_equal(curve_target(part1), curve_source(part2))) if (point_equal(curve_target(part2), curve_target(whole))) return (true); else return (false); else if (point_equal(curve_target(part1), curve_target(part2))) if (point_equal(curve_source(part2), curve_target(whole))) return(true); else return (false); else return (false); else if (point_equal(curve_source(whole), curve_target(part1))) if (point_equal(curve_source(part1), curve_source(part2))) if (point_equal(curve_target(part2), curve_target(whole))) return (true); else return (false); else if (point_equal(curve_source(part1), curve_target(part2))) if (point_equal(curve_source(part2), curve_target(whole))) return (true); else return (false); else return (false); else if (point_equal(curve_source(whole), curve_source(part2)) || point_equal(curve_source(whole), curve_target(part2))) return (curve_merge_condition (whole, part2, part1)); else return (false); } /*! * Check whether the curve is degenerate. * \param cv The input curve. * \return (true) iff the curve source and target are the same. */ inline bool curve_is_degenerate(const X_monotone_curve_2 & cv) const { return point_equal(curve_source(cv),curve_target(cv)); } /*! * Check if the given query curve is encountered when rotating the first * curve in a clockwise direction around a given point until reaching the * second curve. * \param cv The query curve. * \param cv1 The first curve. * \param cv2 The second curve. * \param p The point around which we rotate cv1. * \pre p is an end-point of all three curves. * \return (true) if cv is between cv1 and cv2. If cv overlaps cv1 or cv2 * the result is always (false). If cv1 and cv2 overlap, the result is * (true), unless cv1 also overlaps them. */ bool curve_is_between_cw(const X_monotone_curve_2& cv, const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& p) const { // Find the direction of each segment. Curve_dir_at_point dir = _curve_direction_at_point (cv, p); Curve_dir_at_point dir1 = _curve_direction_at_point (cv1, p); Curve_dir_at_point dir2 = _curve_direction_at_point (cv2, p); // Special treatment for the cases where cv1 or cv2 are vertical segments: if (dir1 == DIR_UP || dir1 == DIR_DOWN) { if (dir2 == DIR_UP || dir2 == DIR_DOWN) { // Both cv1 and cv2 are vertical: if (dir1 == DIR_UP && dir2 == DIR_DOWN) return (dir == DIR_RIGHT); else if (dir1 == DIR_DOWN && dir2 == DIR_UP) return (dir == DIR_LEFT); else return (dir != dir1); } // Only cv1 is vertical: if (dir1 == DIR_UP) { if (dir2 == DIR_LEFT) return (dir == DIR_RIGHT || dir == DIR_DOWN || (dir == DIR_LEFT && curves_compare_y_at_x_left (cv2, cv, p) == LARGER)); else return (dir == DIR_RIGHT && curves_compare_y_at_x_right (cv2, cv, p) == SMALLER); } else { if (dir2 == DIR_LEFT) return (dir == DIR_LEFT && curves_compare_y_at_x_left (cv2, cv, p) == LARGER); else return (dir == DIR_LEFT || dir == DIR_UP || (dir == DIR_RIGHT && curves_compare_y_at_x_right (cv2, cv, p) == SMALLER)); } } if (dir2 == DIR_UP || dir2 == DIR_DOWN) { // Only cv2 is vertical: if (dir2 == DIR_UP) { if (dir1 == DIR_LEFT) return (dir == DIR_LEFT && curves_compare_y_at_x_left (cv1, cv, p) == SMALLER); else return (dir == DIR_LEFT || dir == DIR_DOWN || (dir == DIR_RIGHT && curves_compare_y_at_x_right (cv1, cv, p) == LARGER)); } else { if (dir1 == DIR_LEFT) return (dir == DIR_RIGHT || dir == DIR_UP || (dir == DIR_LEFT && curves_compare_y_at_x_left (cv1, cv, p) == SMALLER)); else return (dir == DIR_RIGHT && curves_compare_y_at_x_right (cv1, cv, p) == LARGER); } } // Take care of the general 4 cases: if (dir1 == DIR_LEFT && dir2 == DIR_LEFT) { // Case 1: Both cv1 and cv2 are defined to the left of p. Comparison_result l_res = curves_compare_y_at_x_left (cv1, cv2, p); if (l_res == LARGER) { // Case 1(a) : cv1 is above cv2. return (dir != DIR_LEFT || curves_compare_y_at_x_left (cv1, cv, p) == SMALLER || curves_compare_y_at_x_left (cv2, cv, p) == LARGER); } else if (l_res == SMALLER) { // Case 1(b): cv1 is below cv2. return (dir == DIR_LEFT && curves_compare_y_at_x_left (cv1, cv, p) == SMALLER && curves_compare_y_at_x_left (cv2, cv, p) == LARGER); } else { // Overlapping segments. return (dir != DIR_LEFT || curves_compare_y_at_x_left (cv1, cv, p) != EQUAL); } } else if (dir1 == DIR_RIGHT && dir2 == DIR_RIGHT) { // Case 2: Both cv1 and cv2 are defined to the right of p. Comparison_result r_res = curves_compare_y_at_x_right (cv1, cv2, p); if (r_res == LARGER) { // Case 2(a) : cv1 is above cv2. return (dir == DIR_RIGHT && curves_compare_y_at_x_right (cv1, cv, p) == LARGER && curves_compare_y_at_x_right (cv2, cv, p) == SMALLER); } else if (r_res == SMALLER) { // Case 2(b): cv1 is below cv2. return (dir != DIR_RIGHT || curves_compare_y_at_x_right (cv1, cv, p) == LARGER || curves_compare_y_at_x_right (cv2, cv, p) == SMALLER); } else { // Overlapping segments. return (dir != DIR_RIGHT || curves_compare_y_at_x_right (cv1, cv, p) != EQUAL); } } else if (dir1 == DIR_LEFT && dir2 == DIR_RIGHT) { // Case 3: cv1 is defined to the left of p, and cv2 to its right. return ((dir == DIR_LEFT && curves_compare_y_at_x_left (cv1, cv, p) == SMALLER) || (dir == DIR_RIGHT && curves_compare_y_at_x_right (cv2, cv, p) == SMALLER) || dir == DIR_UP); } else { // Case 4: cv1 is defined to the right of p, and cv2 to its left. return ((dir == DIR_RIGHT && curves_compare_y_at_x_right (cv1, cv, p) == LARGER) || (dir == DIR_LEFT && curves_compare_y_at_x_left (cv2, cv, p) == LARGER) || dir == DIR_DOWN); } } /*! curves_compare_y_at_x_from_bottom() * * \precondition cv1,cv2 are adjacent to q * \postcondition returns which of cv1,cv2 is first in clockwise sweep * around q starting from bottom direction. */ Comparison_result curves_compare_y_at_x_from_bottom(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { if (!curve_is_vertical(cv1)) { if (!curve_is_vertical(cv2)) { if (point_equal(curve_rightmost(cv1),q)) { // cv1 extends leftwards from q if (point_equal(curve_rightmost(cv2),q)) { // cv2 extends leftwards from q return curves_compare_y_at_x_left(cv1,cv2,q); } else // cv2 extends rightwards from q { return SMALLER; } } else // cv1 extends rightwards from q { if (point_equal(curve_leftmost(cv2),q)) { // cv2 extends rightwards from q return curves_compare_y_at_x_right(cv2,cv1,q); } else // cv2 extends leftwards from q { return LARGER; } } } else { // cv2 is vertical, cv1 is not vertical if (point_equal(curve_rightmost(cv1),q) && point_equal(curve_leftlow_most(cv2), q)) return SMALLER; else return LARGER; } } else { // cv1 is vertical if (point_equal(curve_righttop_most(cv1),q)) if (!curve_is_vertical(cv2) || point_equal(curve_leftlow_most(cv2),q)) return SMALLER; else return EQUAL; // both curves extend downwards else // cv1 extends from q upwards if (point_equal(curve_righttop_most(cv2),q)) return LARGER; else if (!curve_is_vertical(cv2)) // extends rightwards return SMALLER; else // cv2 extends upwards return EQUAL; } } /*! curves_compare_y_at_x_from_top() */ Comparison_result curves_compare_y_at_x_from_top(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { if (!curve_is_vertical(cv1)) if (!curve_is_vertical(cv2)) if (point_equal(curve_rightmost(cv1),q)) { // cv1 extends leftwards from q if (point_equal(curve_rightmost(cv2),q)) { // cv2 extends leftwards from q return curves_compare_y_at_x_left(cv1,cv2,q); } else // cv2 extends rightwards from q { return LARGER; } } else // cv1 extends rightwards from q { if (point_equal(curve_leftmost(cv2),q)) { // cv2 extends rightwards from q return curves_compare_y_at_x_right(cv2,cv1,q); } else // cv2 extends leftwards from q { return SMALLER; } } else // cv2 is vertical, cv1 is not vertical { if (point_equal(curve_leftmost(cv1),q) && point_equal(curve_righttop_most(cv2), q)) return SMALLER; else return LARGER; } else // cv1 is vertical { if (point_equal(curve_leftlow_most(cv1),q)) if (!curve_is_vertical(cv2) || point_equal(curve_righttop_most(cv2),q)) return SMALLER; else return EQUAL; // both curves extend upwards else // cv1 extends from q downwards if (point_equal(curve_leftlow_most(cv2),q)) return LARGER; else if (!curve_is_vertical(cv2)) // extends leftwards return SMALLER; else // cv2 extends downwards return EQUAL; } } /*! curve_is_unbounded() */ bool curve_is_unbounded(const X_monotone_curve_2 & cv) const { return (curve_is_source_unbounded(cv)|| curve_is_target_unbounded(cv)); } /*! curves_compare_y_at_x_left() is implemented based on the Has_left * category. If the category indicates that the "left" version is available, * it calls the function with same name defined in the base class. Otherwise, * it reflects the given point and curves about the origin, and calls the * "right" version. * * curves_compare_y_at_x_left() compares the y value of two curves in an * epsilon environment to the left of the x value of the input point * * \pre The point q is in the x range of the two curves, and both * of them must be also be defined to its left. The two curves must also * intersect at x(q). */ Comparison_result curves_compare_y_at_x_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { return curves_compare_y_at_x_left_imp(cv1, cv2, q, Has_left_category()); } Comparison_result curves_compare_y_at_x_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q, Tag_true) const { //std::cout << "base left implementation " << std::endl; return Base::curves_compare_y_at_x_left(cv1, cv2, q); } // if the function is not implemented in the traits, // call an inside implementation - if the reflect function is // implemented - use it, otherwise, use other implementation Comparison_result curves_compare_y_at_x_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q, Tag_false) const { return curves_compare_y_at_x_left_imp(cv1, cv2, q, Tag_false(), Has_reflect_category()); } //implement the function using reflect Comparison_result curves_compare_y_at_x_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q, Tag_false, Tag_true) const { //std::cout << "reflect left implementation " << std::endl; Point_2 rq = point_reflect_in_x_and_y(q); X_monotone_curve_2 rcv1 = curve_reflect_in_x_and_y(cv1); X_monotone_curve_2 rcv2 = curve_reflect_in_x_and_y(cv2); Comparison_result cr = curves_compare_y_at_x_right(rcv1, rcv2, rq); if (cr == SMALLER) return LARGER; if (cr == LARGER) return SMALLER; return EQUAL; } //implement the function without reflect Comparison_result curves_compare_y_at_x_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q, Tag_false, Tag_false) const { //std::cout << "Idit left implementation " << std::endl; // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1)); CGAL_precondition(! curve_is_vertical(cv2)); // The two curve must be defined at q and also to its left. // Since the curves are continuous, if they are not equal at q, the same // result also applies to q's left. CGAL_precondition (point_equal(curve_rightmost(cv1), curve_rightmost(cv2))); // and meet at a point with the same x-coordinate as q CGAL_precondition (point_equal_x(curve_rightmost(cv1),q)); // get the right-most endpoint between the left endpoints of cv1 and cv2 Point_2 left1 = curve_leftmost(cv1); Point_2 left2 = curve_leftmost(cv2); const Point_2& pnt = point_rightmost(left1, left2); //if the two left endpoints are equal, we need to compare to the right if (point_equal(left1,left2)) { return curves_compare_y_at_x_right(cv1,cv2,pnt); } //compare the y value of the left endpoint of the curves in the rightmost return curves_compare_y_at_x(cv1,cv2,pnt); } protected: /*! * Enum used only be the curve_is_between_cw() function. */ enum Curve_dir_at_point { DIR_UP, // Vertical segment, point at 12 o'clock. DIR_RIGHT, // Non-vertical segment going towards the right. DIR_DOWN, // Vertical segment, point at 6 o'clock. DIR_LEFT // Non-vertical segment going towards the left. }; /*! * Return the curve direction, with respect to a given refernece point. * \param cv The curve. * \param p The reference point. * \pre p must be an end-point of the segment. * \return DIR_UP if cv is a vertical segment pointing at 12 o'clock; * DIR_RIGHT if cv is a non-vertical curve going to the right of p; * DIR_DOWN if cv is a vertical segment pointing at 6 o'clock; * DIR_LEFT if cv is a non-vertical curve going to the left of p; */ Curve_dir_at_point _curve_direction_at_point (const X_monotone_curve_2& cv, const Point_2& p) const { // p is one of the end-point. Compare it with the other end-point. Comparison_result res; if (curve_is_vertical(cv)) { // Special treatment for vertical segments: res = compare_xy(p, curve_source(cv)); if (res == EQUAL) { res = compare_xy(p, curve_target(cv)); } else { // Make sure that p is indeed an end-point. CGAL_precondition(compare_xy(p, curve_target(cv)) == EQUAL); } return ((res == SMALLER) ? DIR_UP : DIR_DOWN); } // In case cv is not vertical: res = compare_x(p, curve_source(cv)); if (res == EQUAL) { res = compare_x(p, curve_target(cv)); } else { // Make sure that p is indeed an end-point. CGAL_precondition(compare_xy(p, curve_target(cv)) == EQUAL); } return ((res == SMALLER) ? DIR_RIGHT : DIR_LEFT); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Onetuple.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Onetuple.0000644000175000017500000000222511344301501031111 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Onetuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PLANAR_MAP_2_ONETUPLE_H #define CGAL_PLANAR_MAP_2_ONETUPLE_H CGAL_BEGIN_NAMESPACE template < class T > class _Onetuple : public Rep { public: T e0; _Onetuple() {} _Onetuple(const T & a0) : e0(a0) {} ~_Onetuple() {} }; template < class T > class Onetuple { public: T e0; Onetuple() {} Onetuple(const T & a0) : e0(a0) {} }; CGAL_END_NAMESPACE #endif // CGAL_PLANAR_MAP_2_ONETUPLE_H ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Bounding_box_special_initializer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Bounding_0000644000175000017500000001104211344301501031141 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Bounding_box_special_initializer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PM_ADVANCED_BOUNDING_BOX template Bounding_box_base* init_default_bounding_box(T_*) const { return new Pm_unbounding_box; } #ifdef CGAL_PM_STRAIGHT_EXACT_TRAITS_H template Bounding_box_base* init_default_bounding_box(Pm_straight_traits_2*) const { return new Pm_dynamic_open_bounding_box; } template Bounding_box_base* init_default_bounding_box(const Pm_straight_traits_2*) const { return new Pm_dynamic_open_bounding_box; } template Bounding_box_base* init_default_bounding_box(Pm_straight_traits_2*) { return new Pm_dynamic_open_bounding_box; } template Bounding_box_base* init_default_bounding_box(const Pm_straight_traits_2*) { return new Pm_dynamic_open_bounding_box; } #endif //CGAL_PM_STRAIGHT_EXACT_TRAITS_H #else // CGAL_PM_ADVANCED_BOUNDING_BOX template Bounding_box_base* init_default_bounding_box(T_*) const { return new Pm_dynamic_open_bounding_box; } // special initializers for backward compatability. #ifdef CGAL_PM_SEGMENT_EXACT_TRAITS_H template Bounding_box_base* init_default_bounding_box( Pm_segment_traits_2* t_) const { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( const Pm_segment_traits_2* t_) const { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( Pm_segment_traits_2* t_) { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( const Pm_segment_traits_2* t_) { return new Pm_unbounding_box; } #endif #ifdef CGAL_PM_SEGMENT_EPSILON_TRAITS_H template Bounding_box_base* init_default_bounding_box( const Pm_segment_epsilon_traits* t_) const { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( Pm_segment_epsilon_traits* t_) const { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( const Pm_segment_epsilon_traits* t_) { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( Pm_segment_epsilon_traits* t_) { return new Pm_unbounding_box; } #endif #ifdef CGAL_PM_LEDA_SEGMENT_EXACT_TRAITS_H template Bounding_box_base* init_default_bounding_box( const Pm_leda_segment_traits_2* t_) const { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( Pm_leda_segment_traits_2* t_) const { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( const Pm_leda_segment_traits_2* t_) { return new Pm_unbounding_box; } template Bounding_box_base* init_default_bounding_box( Pm_leda_segment_traits_2* t_) { return new Pm_unbounding_box; } #endif #ifdef CGAL_PM_TRAITS_CHECKER_H template Bounding_box_base* init_default_bounding_box( const Pm_traits_checker* t_) const { return init_default_bounding_box((const T1_* ) t_); } template Bounding_box_base* init_default_bounding_box( Pm_traits_checker* t_) const { return init_default_bounding_box((T1_* ) t_); } template Bounding_box_base* init_default_bounding_box( const Pm_traits_checker* t_) { return init_default_bounding_box((const T1_* ) t_); } template Bounding_box_base* init_default_bounding_box( Pm_traits_checker* t_) { return init_default_bounding_box((T1_* ) t_); } #endif #endif // CGAL_PM_ADVANCED_BOUNDING_BOX ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Handle_for_with_access.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Handle_fo0000644000175000017500000000273611344301501031126 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Handle_for_with_access.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PLANAR_MAP_2_HANDLE_FOR_WITH_ACCESS_H #define CGAL_PLANAR_MAP_2_HANDLE_FOR_WITH_ACCESS_H #ifndef CGAL_HANDLE_FOR_H #include #endif namespace CGAL { template class Handle_for_with_access : public Handle_for { public: Handle_for_with_access(const T& rc) : Handle_for(rc){} Handle_for_with_access() : Handle_for(){} Handle_for_with_access( const Handle_for_with_access& h) : Handle_for(h){} const T* pointer() const {return Ptr();} T* pointer() {return ptr();} }; } // namespace CGAL #endif // CGAL_PLANAR_MAP_2_HANDLE_FOR_WITH_ACCESS_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_point_utilities_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_point_0000644000175000017500000000551411344301501031170 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_point_utilities_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Shai Hirsch // Efi Fogel #ifndef CGAL_PM_POINT_UTILITIES_2_H #define CGAL_PM_POINT_UTILITIES_2_H CGAL_BEGIN_NAMESPACE template bool is_left(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return Kernel().less_x_2_object()(p1, p2); } template bool is_right(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return Kernel().less_x_2_object()(p2, p1); } template bool is_same_x(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return Kernel().equal_x_object()(p1, p2); } template bool is_lower(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return Kernel().less_y_2_object()(p1, p2); } template bool is_higher(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return Kernel().less_y_2_object()(p2, p1); } template bool is_same_y(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return Kernel().equal_y_object()(p1, p2); } template bool is_same(const Point_2 & p1, const Point_2 &p2) { typedef typename Point_2::R Kernel; return (compare_x(p1, p2) == EQUAL) && (compare_y(p1, p2) == EQUAL); } template const Point_2 & leftmost(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return (is_left(p1, p2) ? p1 : p2); } template const Point_2 & rightmost(const Point_2 & p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return (is_right(p1, p2) ? p1 : p2); } template const Point_2 & lowest(const Point_2 &p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return (is_lower(p1, p2) ? p1 : p2); } template const Point_2 & highest(const Point_2 &p1, const Point_2 & p2) { typedef typename Point_2::R Kernel; return (is_higher(p1, p2) ? p1 : p2); } CGAL_END_NAMESPACE #endif // CGAL_PM_POINT_UTILITIES_2_H // EOF ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_segment_utilities_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_segmen0000644000175000017500000001273411344301501031160 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_segment_utilities_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Shai Hirsch // Efi Fogel #ifndef CGAL_PM_SEGMENT_UTILITIES_2_H #define CGAL_PM_SEGMENT_UTILITIES_2_H CGAL_BEGIN_NAMESPACE /*! Construct a direction in the same direction as a given segment which source * is the given point * \pre the given point must be one of the segment end-points */ template struct Construct_direction_at_endpoint_2 : public Kernel_::Construct_direction_2 { typedef Kernel_ Kernel; typedef Segment_2_ Segment_2; typedef typename Kernel::Construct_direction_2 Base; typedef typename Kernel::Direction_2 Direction_2; typedef typename Kernel::Point_2 Point_2; Construct_direction_at_endpoint_2() { Kernel kernel; is_equal = kernel.equal_2_object(); construct_vertex = kernel.construct_vertex_2_object(); construct_opposite_direction = kernel.construct_opposite_direction_2_object(); } Construct_direction_at_endpoint_2(const Kernel & in_kernel) { is_equal = in_kernel.equal_2_object(); construct_vertex = in_kernel.construct_vertex_2_object(); construct_opposite_direction = in_kernel.construct_opposite_direction_2_object(); construct_direction = in_kernel.construct_direction_2_object(); } Direction_2 operator()(const Segment_2 & cv, const Point_2 & point) const { if (is_equal(construct_vertex(cv, 0), point)) return Base::operator()(cv); return construct_opposite_direction(construct_direction(cv)); } private: typename Kernel::Equal_2 is_equal; typename Kernel::Construct_vertex_2 construct_vertex; typename Kernel::Construct_direction_2 construct_direction; typename Kernel::Construct_opposite_direction_2 construct_opposite_direction; }; /*! */ template class Is_vertex_for_segments_2 { public: typedef Kernel_ Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment_2; Is_vertex_for_segments_2() { Kernel kernel; is_equal = kernel.equal_2_object(); construct_vertex = kernel.construct_vertex_2_object(); } Is_vertex_for_segments_2(const Kernel & in_kernel) { is_equal = in_kernel.equal_2_object(); construct_vertex = in_kernel.construct_vertex_2_object(); } bool operator()(const Point_2 & point, Segment_2 cv) { if (is_equal(construct_vertex(cv, 0), point) || is_equal(construct_vertex(cv, 1), point)) return true; return false; } private: typename Kernel::Equal_2 is_equal; typename Kernel::Construct_vertex_2 construct_vertex; }; /*! */ template struct Counterclockwise_in_between_for_segments_2 : public Kernel_::Counterclockwise_in_between_2 { typedef Kernel_ Kernel; typedef Segment_2_ Segment_2; typedef typename Kernel::Counterclockwise_in_between_2 Base; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Direction_2 Direction_2; typedef Is_vertex_for_segments_2 Is_vertex_2; typedef CGAL::Construct_direction_at_endpoint_2 Construct_direction_2; Counterclockwise_in_between_for_segments_2() { Kernel kernel; construct_direction = Construct_direction_2(kernel); counterclockwise_in_between = kernel.counterclockwise_in_between_2_object(); } Counterclockwise_in_between_for_segments_2(const Kernel & in_kernel) : construct_direction(in_kernel) { counterclockwise_in_between = in_kernel.counterclockwise_in_between_2_object(); } bool operator()(const Point_2 & point, const Segment_2 & cv, const Segment_2 & first, const Segment_2 & second) const { // Preconditions: CGAL_precondition_code(Is_vertex_2 is_vertex;); CGAL_precondition_msg(is_vertex(point, cv), "point should be an endpoint of cv."); CGAL_precondition_msg(is_vertex(point, first), "point should be an endpoint of first."); CGAL_precondition_msg(is_vertex(point, second), "point should be an endpoint of second."); const Direction_2 & d = construct_direction(cv, point); const Direction_2 & d1 = construct_direction(first, point); const Direction_2 & d2 = construct_direction(second, point); return counterclockwise_in_between(d, d1, d2); } private: Construct_direction_2 construct_direction; typename Kernel::Counterclockwise_in_between_2 counterclockwise_in_between; }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_change_notification.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_change0000644000175000017500000000463211344301501031125 0ustar debiandebian// Copyright (c) 2000 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Pm_change_notification.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eyal flato #ifndef CGAL_PM_CHANGE_NOTIFICATION_H #define CGAL_PM_CHANGE_NOTIFICATION_H CGAL_BEGIN_NAMESPACE template class Pm_change_notification { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; virtual void add_edge(const typename Traits::X_curve &, typename Planar_map::Halfedge_handle, bool /* original_direction */, bool overlap = false) { (void) overlap; } virtual void split_edge(typename Planar_map::Halfedge_handle /* org */, typename Planar_map::Halfedge_handle /* new */, const typename Traits::X_curve &, const typename Traits::X_curve &) { } // virtual void merge_edge(typename Planar_map::Halfedge_handle orig_edge, // typename Planar_map::Halfedge_handle new_edge, // const typename Traits::X_curve & c) // { // } // virtual void remove_edge(typename Planar_map::Halfedge_handle orig_edge) // { // } virtual void split_face(typename Planar_map::Face_handle /* org */, typename Planar_map::Face_handle /* new */) { } virtual void add_hole(typename Planar_map::Face_handle /* in_face */, typename Planar_map::Halfedge_handle /* new_hole */) { } virtual const typename Traits::X_curve & edge_support_curve(typename Planar_map::Halfedge_handle edge) { return edge->curve(); } virtual bool have_support_curve() { return false; } }; CGAL_END_NAMESPACE #endif // PM_CHANGE_NOTIFICATION ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Normalize.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Normalize0000644000175000017500000001057211344301501031204 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Normalize.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PLANAR_MAP_2_NORMALIZE_H #define CGAL_PLANAR_MAP_2_NORMALIZE_H #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE #ifdef CGAL_POINT_2_H template // default does nothing. inline bool normalize_coordinates(Point_2& pt){ return false; } #ifdef CGAL_CARTESIAN_H #ifdef CGAL_LEDA_RATIONAL_H // remove inline in future use inline bool normalize_coordinates(Point_2 >& pt) { typedef Cartesian K; typedef CGAL::Point_2 Point; typedef K::RT RT; RT x, y; x = pt.x(); y = pt.y(); if (CGAL_NTS is_zero(x) && CGAL_NTS is_zero(y)) return false; x.normalize(); y.normalize(); pt=Point(x,y); return true; } #endif #ifdef CGAL_LEDA_INTEGER_H // remove inline in future use inline bool normalize_coordinates(Point_2 >& pt) { typedef typename CGAL::Point_2 >::RT RT; RT g, x, y; x = pt.x(); y = pt.y(); if (CGAL_NTS is_zero(x) && CGAL_NTS is_zero(y)) return false; else { g = gcd(x,y); if (g != RT(1)) { pt=Point(x/g,y/g); return true; } else return false; } } #endif #endif // CGAL_CARTESIAN_H #ifdef CGAL_HOMOGENEOUS_H #ifdef CGAL_LEDA_RATIONAL_H /* #ifdef CGAL_LEDA_RATIONAL_H bool normalize_coordinates(PointH2 >& pt) { RT g, x, y, w; x = pt.hx(); y = pt.hy(); w = pt.hw(); if (CGAL_NTS is_zero(x) && CGAL_NTS is_zero(y)) { //g = w; pt=Point(x,y,1); return true; } else { g = CGAL_NTS gcd(x, y); g = CGAL_NTS gcd(g, w); pt=Point(x/g,y/g,w/g); return true; } } #endif */ #endif #ifdef CGAL_LEDA_INTEGER_H #endif #endif // CGAL_HOMOGENEOUS_H #endif // CGAL_POINT_2_H #ifdef CGAL_ISO_RECTANGLE_2_H template // default does nothing. inline bool normalize_coordinates(Iso_rectangle_2& bb) { return false; } #ifdef CGAL_CARTESIAN_H #ifdef CGAL_LEDA_RATIONAL_H inline bool normalize_coordinates( Iso_rectangle_2 >& bb) { // return normalize(bb[0])&&normalize(bb[2]); // Should be implemented internally in Iso_rectangle, in the near future. CGAL::Point_2 > min=bb[0]; CGAL::Point_2 > max=bb[2]; if (normalize_coordinates(min)||normalize_coordinates(max)) { bb=CGAL::Iso_rectangle_2 >(min,max); return true; } return false; } #endif #ifdef CGAL_LEDA_INTEGER_H inline bool normalize_coordinates( Iso_rectangle_2 >& bb) { // return normalize_coordinates(bb[0])&&normalize_coordinates(bb[2]); // Should be implemented internally in Iso_rectangle, in the near future. CGAL::Point_2 > min=bb[0]; CGAL::Point_2 > max=bb[2]; if (normalize_coordinates(min)||normalize_coordinates(max)) bb=CGAL::Iso_rectangle_2 >(min,max); return bb; } #endif #endif // CGAL_CARTESIAN_H #ifdef CGAL_HOMOGENEOUS_H #ifdef CGAL_LEDA_RATIONAL_H /* inline bool normalize_coordinates( Iso_rectangleH2 >& bb) { return normalize_coordinates((PointH2 >&) bb[0]) && normalize_coordinates((PointH2 >&) bb[2]); } */ #endif #ifdef CGAL_LEDA_INTEGER_H #endif #endif // CGAL_HOMOGENEOUS_H #endif // CGAL_ISO_RECTANGLE_2_H CGAL_END_NAMESPACE #endif // CGAL_PLANAR_MAP_2_NORMALIZE_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Point_plus_handle.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Point_plu0000644000175000017500000000700011344301501031205 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2/Point_plus_handle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_POINT_PLUS_HANDLE_H #define CGAL_POINT_PLUS_HANDLE_H #include #include CGAL_BEGIN_NAMESPACE template class Point_plus_handle; // Point_plus_rep: // Point_plus_rep holds a Point plus a vertex handle of the vertex in the // subdivision that will hold that point. // The reason we need the vertex handle information is to update the // subdivision by the time the sweep line progresses without makeing any // point location query. This class holds the representation, and the next // will hold the Handle to Point_plus. template class Point_plus_rep { public: typedef traits Traits; typedef typename Traits::Point Point; typedef vertexHandle Vertex_handle; Point_plus_rep() {} Point_plus_rep(const Point & p) : p_(p), v_(Vertex_handle(NULL)) {} Point_plus_rep(const Point & p, Vertex_handle v) : p_(p), v_(v) {} ~Point_plus_rep() {} protected: friend class Point_plus_handle; Point p_; Vertex_handle v_; }; // Point_plus: // The handle to Point_plus. template class Point_plus_handle : public Handle_for > { typedef Handle_for > Handle_for_Point_plus_rep; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Handle_for_Point_plus_rep::ptr; #endif public: typedef traits Traits; typedef typename Traits::Point Point; typedef vertexHandle Vertex_handle; typedef Point_plus_rep Point_plus_rep_pm; Point_plus_handle() : Handle_for_Point_plus_rep() {} Point_plus_handle(const Point & p) : Handle_for_Point_plus_rep(Point_plus_rep_pm(p)) { } Point_plus_handle(const Point & p, Vertex_handle v) : Handle_for_Point_plus_rep(Point_plus_rep_pm(p, v)) { } Point_plus_handle(const Point_plus_handle & p_plus) : Handle_for_Point_plus_rep(p_plus) {} ~Point_plus_handle() {} Point_plus_handle & operator=(const Point_plus_handle & p_plus) { Handle_for_Point_plus_rep::operator=(p_plus); return *this; } bool operator==(const Point_plus_handle & p_plus) const { return ptr()->p_ == p_plus.point(); } bool operator!=(const Point_plus_handle & p_plus) const { return !(operator==(p_plus)); } void set_point(const Point & p) { ptr()->p_ = p; } void set_vertex (Vertex_handle v) { ptr()->v_ = v; } const Point & point() const { return ptr()->p_; } Vertex_handle vertex() const { return ptr()->v_; } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Real_timer.h0000644000175000017500000000701511344301500027257 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Real_timer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner // Matthias Baesken #ifndef CGAL_REAL_TIMER_H #define CGAL_REAL_TIMER_H 1 #include // For the numerical limits #include CGAL_BEGIN_NAMESPACE // SECTION: A Timer Measuring Real-Time // ======================================================================== // // DEFINITION // // A timer `t' of type Real_timer is an object with a state. It is either // running or it is stopped. The state is controlled with `t.start()' // and `t.stop()'. The timer counts the time elapsed since its creation // or last reset. It counts only the time where it is in the running // state. The time information is given in seconds. class Real_timer { private: double elapsed; double started; int interv; bool running; static bool m_failed; double get_real_time() const; // in seconds double compute_precision() const; // in seconds public: Real_timer() : elapsed(0.0), started(0.0), interv(0), running(false) {} void start(); void stop (); void reset(); bool is_running() const { return running; } double time() const; int intervals() const { return interv; } double precision() const; // Returns timer precison. Computes it dynamically at first call. // Returns -1.0 if timer system call fails, which, for a proper coded // test towards precision leads to an immediate stop of an otherwise // infinite loop (fixed tolerance * total time >= precision). double max() const { return DBL_MAX; } }; // ----------------------------------------------------------------------- // Member functions for Real_timer // =========================== inline void Real_timer::start() { CGAL_precondition( ! running); started = get_real_time(); running = true; ++ interv; } inline void Real_timer::stop() { CGAL_precondition( running); double t = get_real_time(); elapsed += (t - started); started = 0.0; running = false; } inline void Real_timer::reset() { interv = 0; elapsed = 0.0; if (running) { started = get_real_time(); ++ interv; } else { started = 0.0; } } inline double Real_timer::time() const { if (running) { double t = get_real_time(); return elapsed + (t - started); } return elapsed; } CGAL_END_NAMESPACE #endif // CGAL_REAL_TIMER_H // // EOF // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_verte0000644000175000017500000000545511344301501031470 0ustar debiandebian// Copyright (c) 1999,2000,2001,2002,2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DS_VERTEX_BASE_2_H #define CGAL_TRIANGULATION_DS_VERTEX_BASE_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < class TDS = void > class Triangulation_ds_vertex_base_2 { public: typedef TDS Triangulation_data_structure; typedef typename TDS::Face_handle Face_handle; typedef typename TDS::Vertex_handle Vertex_handle; // Borland seems to require it. template struct Rebind_TDS { typedef Triangulation_ds_vertex_base_2 Other; }; Triangulation_ds_vertex_base_2 () : _f() {} Triangulation_ds_vertex_base_2(Face_handle f) : _f(f) {} Face_handle face() const { return _f;} void set_face(Face_handle f) { _f = f ;} //the following trivial is_valid to allow // the user of derived face base classes // to add their own purpose checking bool is_valid(bool /*verbose*/=false, int /*level*/= 0) const {return face() != Face_handle();} // For use by the Compact_container. void * for_compact_container() const { return _f.for_compact_container(); } void * & for_compact_container() { return _f.for_compact_container(); } private: Face_handle _f; }; // Specialization for void. template <> class Triangulation_ds_vertex_base_2 { public: typedef Dummy_tds_2 Triangulation_data_structure; typedef Triangulation_data_structure::Vertex_handle Vertex_handle; typedef Triangulation_data_structure::Face_handle Face_handle; template struct Rebind_TDS { typedef Triangulation_ds_vertex_base_2 Other; }; }; template < class TDS > inline std::istream& operator>>(std::istream &is, Triangulation_ds_vertex_base_2 &) // no combinatorial information. { return is; } template < class TDS > inline std::ostream& operator<<(std::ostream &os, const Triangulation_ds_vertex_base_2 &) // no combinatorial information. { return os; } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_DS_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dynamic_closed_bounding_box.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dynamic_closed_boun0000644000175000017500000006072111344301500031405 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dynamic_closed_bounding_box.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PM_DYNAMIC_CLOSED_BOUNDING_BOX_H #define CGAL_PM_DYNAMIC_CLOSED_BOUNDING_BOX_H #ifndef CGAL_PM_BOUNDING_BOX_BASE_H #include #endif #ifndef CGAL_CIRCULATOR_H #include #endif CGAL_BEGIN_NAMESPACE template class Pm_dynamic_closed_bounding_box : public Pm_bounding_box_base { public: typedef Planar_map_ Planar_map; typedef Pm_dynamic_closed_bounding_box Self; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Face_const_handle Face_const_handle; typedef typename Planar_map::Vertex_iterator Vertex_iterator; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Face_iterator Face_iterator; typedef typename Planar_map::Vertex_const_iterator Vertex_const_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Face_const_iterator Face_const_iterator; typedef std::vector Halfedge_container; typedef typename Planar_map::Locate_type Locate_type; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; typedef typename Traits::Ray Ray; typedef typename Traits::Direction Direction; typedef typename Traits::Bounding_box Bounding_box; typedef typename Traits::Boundary_type Boundary_type; typedef typename Traits::Point_container Point_container; typedef typename Traits::X_curve_container X_curve_container; typedef typename Point_container::iterator Point_iterator; typedef typename X_curve_container::iterator X_curve_iterator; typedef typename Planar_map::Point_location_base Point_location_base; /* // typedef std::list X_curve_container; // typedef Topological_map<_Dcel> TPM; */ typedef typename Planar_map::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Planar_map::Holes_iterator Holes_iterator; typedef typename Planar_map::Holes_const_iterator Holes_const_iterator; typedef typename Planar_map::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; /* typedef typename Base::Size Size; */ Pm_dynamic_closed_bounding_box() : intersection_on_boundary(false){} ~Pm_dynamic_closed_bounding_box(){} void init(Planar_map& pmp, Traits& tr) { pm = &pmp; traits = (Traits_wrap*)(&tr); } bool insert(const Point& p) { // Returns true if bounding box remained unchanged. Bounding_box bold = traits->get_bounding_box(), b = traits->increase_bounding_box(p); if (b!=bold) { Traits* PL_traits=(Traits*)get_point_location()->get_traits(); if (traits!=PL_traits) PL_traits->set_bounding_box(b); rebuild_bounding_box(); return false; } return true; } bool insert(const Point_iterator& begin,const Point_iterator& end #ifdef _MSC_VER ,Point* dummy=0 #endif ) { // workaround for MSVC6.0 // Returns true if bounding box remained unchanged. Point_iterator it=begin; Bounding_box bold = traits->get_bounding_box(); while(it!=end) { #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif traits->increase_bounding_box(*it); ++it; } Bounding_box b=traits->get_bounding_box(); if (b!=bold) { Traits* PL_traits=(Traits*)get_point_location()->get_traits(); if (traits!=PL_traits) PL_traits->set_bounding_box(b); #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif rebuild_bounding_box(); return false; } return true; } bool insert(const X_curve& cv) { // we check that the finite endpoints of the curve is in the BBox // and if not enlarge the BBox to contain them. // if the curve is infinite (in both sides) we have to check that // it passes through the BBox. // Last, we change the "infinite" endpoints to lie on the BBox. Point p1, p2; X_curve c; #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif Bounding_box bold = traits->get_bounding_box(), b = traits->increase_bounding_box(cv); if (b!=bold) { Traits* PL_traits=(Traits*)get_point_location()->get_traits(); if (traits!=PL_traits) PL_traits->set_bounding_box(b); //optimize here .... rebuild_bounding_box(); return false; } return true; /* while (!traits.is_curve_inside_bounding_box(cv,bt)) { switch (bt) { case Traits::TOP: find_adjacent_points(top_left, p1, p2); c = traits.create_segment(p1,p2); delete_vertex(top_left, c); break; case Traits::RIGHT: find_adjacent_points(top_right, p1, p2); c = traits.create_segment(p1,p2); // debug ppp = top_right->point(); //end debug delete_vertex(top_right, c); break; case Traits::BOTTOM: find_adjacent_points(bottom_right, p1, p2); c = traits.create_segment(p1,p2); delete_vertex(bottom_right, c); break; case Traits::LEFT: find_adjacent_points(bottom_left, p1, p2); c = traits.create_segment(p1,p2); delete_vertex(bottom_left, c); break; } reinsert_vertex_of_BBox(bt); switch (bt) { case Traits::TOP: find_adjacent_points(top_right, p1, p2); c = traits.create_segment(p1,p2); // debug ppp = top_right->point(); //end debug delete_vertex(top_right, c); reinsert_vertex_of_BBox(Traits::RIGHT); break; case Traits::RIGHT: find_adjacent_points(bottom_right, p1, p2); c = traits.create_segment(p1,p2); // debug ppp = bottom_right->point(); //end debug delete_vertex(bottom_right, c); reinsert_vertex_of_BBox(Traits::BOTTOM); break; case Traits::BOTTOM: find_adjacent_points(bottom_left, p1, p2); c = traits.create_segment(p1,p2); // debug ppp = bottom_left->point(); //end debug delete_vertex(bottom_left, c); reinsert_vertex_of_BBox(Traits::LEFT); break; case Traits::LEFT: find_adjacent_points(top_left, p1, p2); c = traits.create_segment(p1,p2); // debug ppp = top_left->point(); //end debug delete_vertex(top_left, c); reinsert_vertex_of_BBox(Traits::TOP); break; } } */ } bool insert(const X_curve_iterator& begin,const X_curve_iterator& end #ifdef _MSC_VER ,X_curve* dummy=0 #endif ) { // workaround for MSVC6.0 #ifdef CGAL_PM_DEBUG CGAL_assertion(debug_invariant()); #endif X_curve_iterator it=begin; Bounding_box bold = traits->get_bounding_box(); while(it!=end) { traits->increase_bounding_box(*it); ++it; } Bounding_box b = traits->get_bounding_box(); if (b!=bold) { Traits* PL_traits=(Traits*)get_point_location()->get_traits(); if (traits!=PL_traits) PL_traits->set_bounding_box(b); rebuild_bounding_box(); return false; } return true; } bool insert(const X_curve& cv,const Ray& r) { /* returns true if the bounding box remains unchanged, false otherwise. */ const Bounding_box before = traits->get_bounding_box(); const Bounding_box& after=traits->increase_bounding_box(cv,r,before); CGAL_postcondition(after==traits->increase_bounding_box(cv,r,after)); // makes sure that the intersection of the ray and the curve // (if such intersection exists) is inside the bounding box. return before==after; } /* The point location query function may updates the resulting halfedge handle and locate type as expected from the bounding box */ /* Returns true if bounding box remained unchanged */ bool locate(const Point& p, Locate_type& lt,Halfedge_handle& h){ // apply_bounding_box(pm->unbounded_face(),h,lt); return true; }; /* Returns true if bounding box remained unchanged */ bool vertical_ray_shoot(const Point& p, Locate_type& lt, bool up, Halfedge_handle& h){ CGAL_precondition(lt==Planar_map::VERTEX||lt==Planar_map::EDGE|| lt==Planar_map::UNBOUNDED_FACE); if (lt==Planar_map::UNBOUNDED_FACE) { Halfedge_iterator it=pm->halfedges_begin(); Ray r(p,Direction(0,up ? 1 : -1)); while(it!=pm->halfedges_end()) { const X_curve& cv=it->curve(); if (!traits->point_in_x_range(cv,p) && !insert(cv,r)) { rebuild_bounding_box(); return false; } else {++it;++it;} } // make sure that the intersection of the curve with the vertical ray // is inside the bounding box // (if such intersection exists). } else if (lt==Planar_map::VERTEX) { if (!insert(h->target()->point())) { rebuild_bounding_box(); return false; } } return true; // apply_bounding_box(pm->unbounded_face(),h,lt); }; void split_edge(const X_curve &cv, Halfedge_handle e1, Halfedge_handle e2 //additions by iddo for arrangement ,const X_curve& cv1, const X_curve& cv2 //end additions ) {} void split_boundary_edge(const Halfedge_handle &h, Halfedge_handle h1, Halfedge_handle h2, const Point& p) { X_curve cv1,cv2; traits->split_curve(h->curve(),cv1,cv2,p); h1 = pm->split_edge(h,cv1,cv2); h2 = h1->next_halfedge(); #ifdef CGAL_PM_DEBUG CGAL_postcondition(h1->target()==h2->source()); CGAL_postcondition(h1->source()==h->source()); CGAL_postcondition(h2->target()==h->target()); #endif } void merge_edge(const X_curve &cv1, const X_curve &cv2, Halfedge_handle e //additions by iddo for arrangement ,const X_curve& cv //end additions ) {} void remove_edge(Halfedge_handle e) {} void clear(){traits->set_bounding_box();} inline bool is_empty() const { return is_empty(traits->get_bounding_box()); } protected: inline bool is_empty(const Bounding_box& b) const { return b.identical(Traits::unbounded_box()); } protected: void apply_bounding_box( const Face_handle& unbounded, const Halfedge_handle& he,Locate_type& lt) const // Reevaluates the locate type according to the bounding box. { switch(lt) { case Planar_map::UNBOUNDED_FACE: break; case Planar_map::FACE: { Ccb_halfedge_const_circulator begin(he->twin()); Ccb_halfedge_const_circulator circ=begin; while (++circ!=begin) { if (circ->face()==unbounded) lt=Planar_map::UNBOUNDED_FACE; break; } } break; case Planar_map::EDGE: if (he->twin()->face()==unbounded || he->twin()->face()==unbounded) lt=Planar_map::UNBOUNDED_EDGE; break; case Planar_map::VERTEX: { Halfedge_around_vertex_circulator begin=he->target()->incident_halfedges(), circ=begin; while (++circ!=begin) { if (circ->face()==unbounded) lt=Planar_map::UNBOUNDED_VERTEX; break; } } break; } } //bool cooriented(const Ccb_halfedge_circulator& h,const X_curve& cv) const bool cooriented(const Halfedge_const_handle& h,const X_curve& cv) const // Returns weather the halfedge and the curve are cooriented or not. { CGAL_precondition(traits->curve_equal(h->curve(),cv)); const Point& s=h->source()->point(),&t=h->target()->point(); if (traits->point_equal_x(s,t)) { CGAL_precondition( traits->curve_get_status(cv)==Traits::CURVE_VERTICAL_UP || traits->curve_get_status(cv)==Traits::CURVE_VERTICAL_DOWN); return (traits->point_is_right_top(t,s) == (traits->curve_get_status(cv)==Traits::CURVE_VERTICAL_UP)); } else { CGAL_precondition( traits->curve_get_status(cv)==Traits::CURVE_RIGHT || traits->curve_get_status(cv)==Traits::CURVE_LEFT); return (traits->point_is_right(t,s) == (traits->curve_get_status(cv)==Traits::CURVE_RIGHT)); } } Point_location_base* get_point_location() const { // Returns the point location while discarding the const. return (Point_location_base*)pm->get_point_location(); } bool target_is_intersection_point(const Halfedge_handle& h,Point& p) const // Returns weather the halfedge's target is a real intersection point // on the boundary. // In that case, p is set to that point. { Halfedge_around_vertex_circulator avc_b=h; Halfedge_around_vertex_circulator avc_ntnt=avc_b; ++avc_ntnt; p = traits->curve_target(avc_ntnt->curve()); #ifdef CGAL_PM_DEBUG Halfedge_around_vertex_circulator avc_nt=avc_ntnt; CGAL_assertion(avc_nt!=avc_b); // Isolated corners are not allowed. #endif ++avc_ntnt; return avc_ntnt!=avc_b; // Found an intersection point on the boundary, i.e. a point } void find_reference_point() /* Finds an intersection point of the boundary with the Planar map curves, if such exists. */ { CGAL_precondition( pm->unbounded_face()->holes_begin()!= pm->unbounded_face()->holes_end()); #ifdef CGAL_PM_DEBUG Holes_iterator ho_nit=++pm->unbounded_face()->holes_begin(), ho_e=pm->unbounded_face()->holes_end(); CGAL_precondition(ho_nit==ho_e); // The unbounded face of the Planar map should have at most one hole. #endif Halfedge_container c; Holes_iterator it=pm->unbounded_face()->holes_begin(); Ccb_halfedge_circulator ccb_b = *ccb_hi; halfedge_on_boundary=ccb_b; Point p; do { if (target_is_intersection_point(halfedge_on_boundary,p)) { intersection_on_boundary=true; return; } // Found an intersection point on the boundary, i.e. a point // that belongs to one of the infinite curves in the planar map. } while(halfedge_on_boundary++!=ccb_b); intersection_on_boundary=false; } void rebuild_bounding_box(){ if (initialized) // bounding box is already initialized. { // Reevaluates the planar map, by recalculating the bounding box. find_reference_point(); // move this to modifying functions. #ifdef CGAL_PM_DEBUG if (intersection_on_boundary) { Halfedge_around_vertex_circulator avc_b=halfedge_on_boundary; Halfedge_around_vertex_circulator avc_ntnt=avc_b; ++avc_ntnt; ++avc_ntnt; CGAL_assertion(avc_ntnt!=avc_b); // Invariant: intersection_on_boundary -> // halfedge_on_boundary->target() is one. } #endif X_curve_container new_boundary; traits->get_x_curve_boundary(new_boundary); // Get new boundary from traits. typedef typename X_curve_container::reverse_iterator reverse_iterator; // The original orientation of the boundary is ccw, while we expect cw. reverse_iterator new_boundary_rbegin=new_boundary.rbegin(); /* reverse_iterator new_boundary_real_rend=--(new_boundary.rend()); */ CGAL_postcondition(new_boundary.rbegin()!=new_boundary.rend()); typedef Forward_circulator_from_iterator reverse_circulator; // Making a circulator from the container. (simpler to work with). /* reverse_circulator boundary_circulator(new_boundary_rbegin,new_boundary_real_rend); */ // note that the second iterator is not new_boundary.rend(); reverse_circulator::iterator boundary_begin=new_boundary_rbegin, boundary_circ=boundary_begin; // X_curve curr_cv; // Point curr_endp; // Notify the point location about the scheduled update. Ccb_halfedge_circulator begin=halfedge_on_boundary,circ=begin; Point last_end,curr_endp; // last and current points along new boundary. get_point_location()->update(halfedge_on_boundary); if (intersection_on_boundary) // Synchronize between the new boundary and the old boundary. { while ( !traits->is_point_on_curve( *boundary_circ, halfedge_on_boundary->target()->point()) ) boundary_circ++; // new_boundary_it contains an intersection point. while( target_is_intersection_point(circ,curr_endp) && traits->is_point_on_curve(*boundary_circ,curr_endp) ) { halfedge_on_boundary=circ; ++circ; } // Synchronize boundary curve iterator and halfedge circulator. // Curve turns counter clockwise, while halfedge turns clockwise. X_curve curr_cv=*boundary_circ; // last curves along old and new boundaries. bool last_was_intersecting=false; // last edge's target had an intersection point. Halfedge_around_vertex_circulator inter_edge=circ; // auxiliary halfedge for the intersection point calculation. ++inter_edge; curr_endp=traits->curve_target(inter_edge->curve()); ++circ; // circ is oriented clockwise. do{ if (target_is_intersection_point(circ,curr_endp)) { inter_edge=circ; ++inter_edge; curr_endp=traits->curve_target(inter_edge->curve()); while (!traits->is_point_on_curve(*boundary_circ,curr_endp)) { circ->set_curve(curr_cv); circ->twin()->set_curve(curr_cv); last_was_intersecting=false; ++boundary_circ; } // update the curve according to the newly split curve. { X_curve slower,faster; traits->split_curve(curr_cv,slower,faster,curr_endp); circ->set_curve(slower); circ->twin()->set_curve(slower); curr_cv=faster; last_was_intersecting=true; } } ++circ; // circ is oriented clockwise. // don't forget to remove the old halfedges!!! // optimization: need not remove all corver halfedges, // only in case of a lack, or an over use. } while (circ!=begin); /* const X_curve& cv=vnext->curve(); Halfedge_handle h=vnext; Vertex_handle s=h->source(), t=h->target(); // optimization: never handle both h and h->twin(). if (h->face()==h->twin()->face() && traits->point_is_left_low(s->point(),t->point())) { #ifdef CGAL_PM_DEBUG CGAL_precondition( traits->point_equal( traits->curve_source(h->curve()),h->source()->point()) && traits->point_equal( traits->curve_target(h->curve()),h->target()->point()) || traits->point_equal( traits->curve_source(h->curve()),h->target()->point()) && traits->point_equal( traits->curve_target(h->curve()),h->source()->point()) ); #endif --circ; // turn counter clockwise around face. continue; } if (cooriented(h,cv)) { t->set_point(traits->curve_target(cv)); s->set_point(traits->curve_source(cv)); } else { t->set_point(traits->curve_source(cv)); s->set_point(traits->curve_target(cv)); } CGAL_postcondition(!traits->point_equal( h->source()->point(),h->target()->point())); #ifdef CGAL_PM_DEBUG CGAL_precondition( traits->point_equal( traits->curve_source(h->curve()),h->source()->point()) && traits->point_equal( traits->curve_target(h->curve()),h->target()->point()) || traits->point_equal( traits->curve_source(h->curve()),h->target()->point()) && traits->point_equal( traits->curve_target(h->curve()),h->source()->point()) ); #endif } else { } ++circ; } while (circ!=begin); // ++it; */ } else // Recreate the whole boundary. { do { halfedge_on_boundary->set_curve(*boundary_circ); halfedge_on_boundary->twin()->set_curve(*boundary_circ); ++boundary_circ; ++halfedge_on_boundary; // optimization. In general the number of curves in the // boundary should not be a constant. } while(boundary_circ!=boundary_begin); } } else // bounding box is empty. { X_curve_container cv_aux; traits->get_x_curve_boundary(cv_aux); // returns the curve boundary of the bounding box. // e.g. the 4 (infinite) segments of the bounding box // in this order: bottom, right, top, left. const typename X_curve_container::iterator &bcv = cv_aux.begin(), &ecv = cv_aux.end(); typename X_curve_container::iterator currcv=bcv, nextcv=bcv; ++nextcv; const Halfedge_handle& first = pm->insert_in_face_interior(*bcv, pm->unbounded_face()); #ifdef CGAL_PM_DEBUG CGAL_postcondition(cooriented(first,*bcv)); #endif Halfedge_handle curre=first; currcv=nextcv; ++nextcv; while(nextcv!=ecv) { curre = pm->insert_from_vertex(*currcv, curre->target(), true); currcv=nextcv; ++nextcv; } curre = pm->insert_at_vertices(*currcv, curre->target(), first->source()); CGAL_assertion(curre->next_halfedge()==first); } } #ifdef CGAL_PM_DEBUG void debug() const {} bool debug_invariant() const{ CGAL_assertion(traits); CGAL_assertion(&traits->get_bounding_box()); return true; } #endif protected: Planar_map* pm; Traits_wrap* traits; bool initialized; Ccb_halfedge_circulator halfedge_on_boundary; // Halfedge on the outer boundary that points at an // intersection point on the boundary, if such exists. bool intersection_on_boundary; }; CGAL_END_NAMESPACE #endif //CGAL_PM_DYNAMIC_CLOSED_BOUNDING_BOX_H /* Special situations: |-------- | x | | | | | | | |-\ /---| vrs */ /* Souldn't Planar_map::Halfedge_handle insert_from_vertex(const X_curve& cv, Vertex_handle v1, bool source) be Planar_map::Halfedge_handle insert_from_vertex(const X_curve& cv, Vertex_const_handle v1, bool source) same for ... Halfedge_handle insert_at_vertices(const X_curve& cv, Vertex_handle v1, Vertex_handle v2) */ /* optimization: It is possible to keep a pointer to a bounding box, instead of a virtual base class. */ ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_adapterC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_adapterC20000644000175000017500000002051011344301500031113 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_adapterC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_CIRCLE_2_ADAPTERC2_H #define CGAL_MIN_CIRCLE_2_ADAPTERC2_H // includes #ifndef CGAL_OPTIMISATION_BASIC_H # include #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_circle_2; template < class PT_, class DA_ > class Min_circle_2_adapterC2; template < class PT_, class DA_ > class _Min_circle_2_adapterC2__Circle; // Class interface and implementation // ================================== template < class PT_, class DA_ > class Min_circle_2_adapterC2 { public: // types typedef PT_ PT; typedef DA_ DA; // nested types typedef PT Point; typedef CGAL::_Min_circle_2_adapterC2__Circle Circle; private: DA dao; // data accessor object Circle circle; // current circle friend class CGAL::Min_circle_2< CGAL::Min_circle_2_adapterC2 >; public: // creation Min_circle_2_adapterC2( const DA& da = DA()) : dao( da), circle( da) { } // operations CGAL::Orientation orientation( const Point& p, const Point& q, const Point& r) const { typedef typename DA_::FT FT; FT px; FT py; FT qx; FT qy; FT rx; FT ry; dao.get( p, px, py); dao.get( q, qx, qy); dao.get( r, rx, ry); return( static_cast< CGAL::Orientation>( CGAL_NTS sign( ( px-rx) * ( qy-ry) - ( py-ry) * ( qx-rx)))); } }; // Nested type `Circle' template < class PT_, class DA_ > std::ostream& operator << ( std::ostream&, const CGAL::_Min_circle_2_adapterC2__Circle&); template < class PT_, class DA_ > std::istream& operator >> ( std::istream&, CGAL::_Min_circle_2_adapterC2__Circle&); template < class PT_, class DA_ > class _Min_circle_2_adapterC2__Circle { public: // typedefs typedef PT_ PT; typedef DA_ DA; typedef typename DA_::FT FT; private: // data members DA dao; // data accessor object FT center_x; // center's x-coordinate FT center_y; // center's y-coordinate FT sqr_rad; // squared radius // private member functions FT sqr_dist( const FT& px, const FT& py, const FT& qx, const FT& qy) const { FT dx( px - qx); FT dy( py - qy); return( dx*dx + dy*dy); } friend std::ostream& operator << <> ( std::ostream&, const CGAL::_Min_circle_2_adapterC2__Circle&); friend std::istream& operator >> <> ( std::istream&, CGAL::_Min_circle_2_adapterC2__Circle&); public: // types typedef PT Point; typedef FT Distance; // creation _Min_circle_2_adapterC2__Circle( const DA& da) : dao( da) { } void set( ) { center_x = FT( 0); center_y = FT( 0); sqr_rad = -FT( 1); } void set( const Point& p) { dao.get( p, center_x, center_y); sqr_rad = FT( 0); } void set( const Point& p, const Point& q) { FT px; FT py; FT qx; FT qy; dao.get( p, px, py); dao.get( q, qx, qy); center_x = ( px+qx) / FT( 2); center_y = ( py+qy) / FT( 2); sqr_rad = sqr_dist( px, py, center_x, center_y); } void set( const Point& p, const Point& q, const Point& r) { FT px; FT py; FT qx; FT qy; FT rx; FT ry; dao.get( p, px, py); dao.get( q, qx, qy); dao.get( r, rx, ry); FT qx_px( qx - px); FT qy_py( qy - py); FT rx_px( rx - px); FT ry_py( ry - py); FT p2 ( px*px + py*py); FT q2_p2( qx*qx + qy*qy - p2); FT r2_p2( rx*rx + ry*ry - p2); FT denom( ( qx_px*ry_py - rx_px*qy_py) * FT( 2)); center_x = ( q2_p2*ry_py - r2_p2*qy_py) / denom; center_y = ( r2_p2*qx_px - q2_p2*rx_px) / denom; sqr_rad = sqr_dist( px, py, center_x, center_y); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const { FT px; FT py; dao.get( p, px, py); return( CGAL::Bounded_side( CGAL_NTS sign( sqr_rad - sqr_dist( px, py, center_x, center_y)))); } bool has_on_bounded_side( const Point& p) const { FT px; FT py; dao.get( p, px, py); return( sqr_dist( px, py, center_x, center_y) < sqr_rad); } bool has_on_boundary( const Point& p) const { FT px; FT py; dao.get( p, px, py); return( sqr_dist( px, py, center_x, center_y) == sqr_rad); } bool has_on_unbounded_side( const Point& p) const { FT px; FT py; dao.get( p, px, py); return( sqr_rad < sqr_dist( px, py, center_x, center_y)); } bool is_empty( ) const { return( CGAL::is_negative( sqr_rad)); } bool is_degenerate( ) const { return( ! CGAL::is_positive( sqr_rad)); } // additional operations for checking bool operator == ( const CGAL::_Min_circle_2_adapterC2__Circle& c) const { return( ( center_x == c.center_x) && ( center_y == c.center_y) && ( sqr_rad == c.sqr_rad ) ); } bool operator != ( const CGAL::_Min_circle_2_adapterC2__Circle& c) const { return( ! ( *this == c)); } Point center( ) const { Point p; dao.set( p, center_x, center_y); return( p); } const Distance& squared_radius( ) const { return( sqr_rad); } }; // I/O template < class PT_, class DA_ > std::ostream& operator << ( std::ostream& os, const CGAL::_Min_circle_2_adapterC2__Circle& c) { switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << "CGAL::Min_circle_2_adapterC2::Circle( " << c.center_x << ", " << c.center_y << ", " << c.sqr_rad << ')'; break; case CGAL::IO::ASCII: os << c.center_x << ' ' << c.center_y << ' ' << c.sqr_rad; break; case CGAL::IO::BINARY: CGAL::write( os, c.center_x); CGAL::write( os, c.center_y); CGAL::write( os, c.sqr_rad); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } template < class PT_, class DA_ > std::istream& operator >> ( std::istream& is, CGAL::_Min_circle_2_adapterC2__Circle& c) { switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case CGAL::IO::ASCII: is >> c.center_x >> c.center_y >> c.sqr_rad; break; case CGAL::IO::BINARY: CGAL::read( is, c.center_x); CGAL::read( is, c.center_y); CGAL::read( is, c.sqr_rad); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE #endif // CGAL_MIN_CIRCLE_2_ADAPTERC2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/functional.h0000644000175000017500000025603611344301500027347 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/functional.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_FUNCTIONAL_H #define CGAL_FUNCTIONAL_H 1 #include CGAL_BEGIN_NAMESPACE // +----------------------------------------------------------------------+ // | A functor adaptor to define an arity explicitly // +----------------------------------------------------------------------+ namespace CGALi { template < class F, int a > struct Set_arity_helper; template < class F > struct Set_arity_helper< F, 0 > { typedef Arity_tag< 0 > Arity; typedef typename F::result_type result_type; Set_arity_helper(const F& f) : f_(f) {} result_type operator() () const { return f_(); } protected: F f_; }; template < class F > struct Set_arity_helper< F, 1 > { typedef Arity_tag< 1 > Arity; typedef typename F::result_type result_type; Set_arity_helper(const F& f) : f_(f) {} template < class A1 > result_type operator() (const A1& a1) const { return f_(a1); } protected: F f_; }; template < class F > struct Set_arity_helper< F, 2 > { typedef Arity_tag< 2 > Arity; typedef typename F::result_type result_type; Set_arity_helper(const F& f) : f_(f) {} template < class A1, class A2 > result_type operator() (const A1& a1, const A2& a2) const { return f_(a1, a2); } protected: F f_; }; template < class F > struct Set_arity_helper< F, 3 > { typedef Arity_tag< 3 > Arity; typedef typename F::result_type result_type; Set_arity_helper(const F& f) : f_(f) {} template < class A1, class A2, class A3 > result_type operator() (const A1& a1, const A2& a2, const A3& a3) const { return f_(a1, a2, a3); } protected: F f_; }; template < class F > struct Set_arity_helper< F, 4 > { typedef Arity_tag< 4 > Arity; typedef typename F::result_type result_type; Set_arity_helper(const F& f) : f_(f) {} template < class A1, class A2, class A3, class A4 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f_(a1, a2, a3, a4); } protected: F f_; }; template < class F > struct Set_arity_helper< F, 5 > { typedef Arity_tag< 5 > Arity; typedef typename F::result_type result_type; Set_arity_helper(const F& f) : f_(f) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f_(a1, a2, a3, a4, a5); } protected: F f_; }; } // namespace CGALi template < class F, int a > struct Set_arity { typedef CGALi::Set_arity_helper< F, a > Type; }; template < class F > inline typename Set_arity< F, 0 >::Type set_arity_0(const F& f) { typedef typename Set_arity< F, 0 >::Type Type; return Type(f); } template < class F > inline typename Set_arity< F, 1 >::Type set_arity_1(const F& f) { typedef typename Set_arity< F, 1 >::Type Type; return Type(f); } template < class F > inline typename Set_arity< F, 2 >::Type set_arity_2(const F& f) { typedef typename Set_arity< F, 2 >::Type Type; return Type(f); } template < class F > inline typename Set_arity< F, 3 >::Type set_arity_3(const F& f) { typedef typename Set_arity< F, 3 >::Type Type; return Type(f); } template < class F > inline typename Set_arity< F, 4 >::Type set_arity_4(const F& f) { typedef typename Set_arity< F, 4 >::Type Type; return Type(f); } template < class F > inline typename Set_arity< F, 5 >::Type set_arity_5(const F& f) { typedef typename Set_arity< F, 5 >::Type Type; return Type(f); } // +----------------------------------------------------------------------+ // | Functor Adaptors for Swapping Arguments // +----------------------------------------------------------------------+ namespace CGALi { template < class F, int i, class A > struct Swapper; template < class F > struct Swapper< F, 1, Arity_tag< 2 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2 > result_type operator() (const A1& a1, const A2& a2) const { return f(a2, a1); } protected: F f; }; template < class F > struct Swapper< F, 1, Arity_tag< 3 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3 > result_type operator() (const A1& a1, const A2& a2, const A3& a3) const { return f(a2, a1, a3); } protected: F f; }; template < class F > struct Swapper< F, 2, Arity_tag< 3 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3 > result_type operator() (const A1& a1, const A2& a2, const A3& a3) const { return f(a1, a3, a2); } protected: F f; }; template < class F > struct Swapper< F, 1, Arity_tag< 4 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a2, a1, a3, a4); } protected: F f; }; template < class F > struct Swapper< F, 2, Arity_tag< 4 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a1, a3, a2, a4); } protected: F f; }; template < class F > struct Swapper< F, 3, Arity_tag< 4 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a1, a2, a4, a3); } protected: F f; }; template < class F > struct Swapper< F, 1, Arity_tag< 5 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f(a2, a1, a3, a4, a5); } protected: F f; }; template < class F > struct Swapper< F, 2, Arity_tag< 5 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f(a1, a3, a2, a4, a5); } protected: F f; }; template < class F > struct Swapper< F, 3, Arity_tag< 5 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f(a1, a2, a4, a3, a5); } protected: F f; }; template < class F > struct Swapper< F, 4, Arity_tag< 5 > > { typedef typename F::result_type result_type; typedef typename F::Arity Arity; Swapper(const F& f_) : f(f_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator() (const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f(a1, a2, a3, a5, a4); } protected: F f; }; } // namespace CGALi template < class F, int i = 1 > struct Swap { typedef CGALi::Swapper< F, i, typename Arity_traits< F >::Arity > Type; }; template < class F > inline typename Swap< F, 1 >::Type swap_1(const F& f) { typedef typename Swap< F, 1 >::Type S; return S(f); } template < class F > inline typename Swap< F, 2 >::Type swap_2(const F& f) { typedef typename Swap< F, 2 >::Type S; return S(f); } template < class F > inline typename Swap< F, 3 >::Type swap_3(const F& f) { typedef typename Swap< F, 3 >::Type S; return S(f); } template < class F > inline typename Swap< F, 4 >::Type swap_4(const F& f) { typedef typename Swap< F, 4 >::Type S; return S(f); } // +----------------------------------------------------------------------+ // | Binding Arguments of a Functor // +----------------------------------------------------------------------+ namespace CGALi { // Using (F::arity - 1) here gives an ICE on gcc 2.95 template < class F, class R, class A, int i > struct Binder; template < class F, class A > struct Binder< F, Arity_tag< 1 >, A, 1 > { typedef typename F::result_type result_type; typedef Arity_tag< 1 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} result_type operator()( ) const { return f(a); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 2 >, A, 1 > { typedef typename F::result_type result_type; typedef Arity_tag< 2 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1 > result_type operator()(const A1& a1) const { return f(a, a1); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 2 >, A, 2 > { typedef typename F::result_type result_type; typedef Arity_tag< 2 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1 > result_type operator()(const A1& a1) const { return f(a1, a); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 3 >, A, 1 > { typedef typename F::result_type result_type; typedef Arity_tag< 3 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2 > result_type operator()( const A1& a1, const A2& a2) const { return f(a, a1, a2); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 3 >, A, 2 > { typedef typename F::result_type result_type; typedef Arity_tag< 3 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2 > result_type operator()( const A1& a1, const A2& a2) const { return f(a1, a, a2); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 3 >, A, 3 > { typedef typename F::result_type result_type; typedef Arity_tag< 3 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2 > result_type operator()( const A1& a1, const A2& a2) const { return f(a1, a2, a); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 4 >, A, 1 > { typedef typename F::result_type result_type; typedef Arity_tag< 4 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f(a, a1, a2, a3); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 4 >, A, 2 > { typedef typename F::result_type result_type; typedef Arity_tag< 4 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f(a1, a, a2, a3); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 4 >, A, 3 > { typedef typename F::result_type result_type; typedef Arity_tag< 4 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f(a1, a2, a, a3); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 4 >, A, 4 > { typedef typename F::result_type result_type; typedef Arity_tag< 4 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f(a1, a2, a3, a); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 5 >, A, 1 > { typedef typename F::result_type result_type; typedef Arity_tag< 5 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a, a1, a2, a3, a4); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 5 >, A, 2 > { typedef typename F::result_type result_type; typedef Arity_tag< 5 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a1, a, a2, a3, a4); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 5 >, A, 3 > { typedef typename F::result_type result_type; typedef Arity_tag< 5 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a1, a2, a, a3, a4); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 5 >, A, 4 > { typedef typename F::result_type result_type; typedef Arity_tag< 5 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a1, a2, a3, a, a4); } protected: F f; A a; }; template < class F, class A > struct Binder< F, Arity_tag< 5 >, A, 5 > { typedef typename F::result_type result_type; typedef Arity_tag< 5 - 1 > Arity; Binder(const F& f_, const A& a_) : f(f_), a(a_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f(a1, a2, a3, a4, a); } protected: F f; A a; }; } // namespace CGALi template < class T, class A, int i > struct Bind { typedef CGALi::Binder< T, typename Arity_traits< T >::Arity, A, i > Type; }; template < class F, class A > inline typename Bind< F, A, 1 >::Type bind_1(const F& f, const A& a) { typedef typename Bind< F, A, 1 >::Type B; return B(f, a); } template < class F, class A > inline typename Bind< F, A, 2 >::Type bind_2(const F& f, const A& a) { typedef typename Bind< F, A, 2 >::Type B; return B(f, a); } template < class F, class A > inline typename Bind< F, A, 3 >::Type bind_3(const F& f, const A& a) { typedef typename Bind< F, A, 3 >::Type B; return B(f, a); } template < class F, class A > inline typename Bind< F, A, 4 >::Type bind_4(const F& f, const A& a) { typedef typename Bind< F, A, 4 >::Type B; return B(f, a); } template < class F, class A > inline typename Bind< F, A, 5 >::Type bind_5(const F& f, const A& a) { typedef typename Bind< F, A, 5 >::Type B; return B(f, a); } // +----------------------------------------------------------------------+ // | Composing Functors // +----------------------------------------------------------------------+ namespace CGALi { struct Not_used { typedef Arity_tag< -1 > Arity; }; template < class F0, class A0, class F1, class A1, class F2 = CGALi::Not_used, class A2 = Arity_tag< -1 >, class F3 = CGALi::Not_used, class A3 = Arity_tag< -1 > > struct Composer; template < class F0, class A0, class F1, class A1, class F2, class A2, class F3 = CGALi::Not_used, class A3 = Arity_tag< -1 > > struct Composer_shared; // ------------------------------------------------------------------------ // one function to compose // ------------------------------------------------------------------------ template < class F0, class F1 > struct Composer< F0, Arity_tag< 1 >, F1, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 > Arity; Composer(const F0& f0_, const F1& f1_) : f0(f0_), f1(f1_) {} result_type operator()( ) const { return f0(f1( )); } protected: F0 f0; F1 f1; }; template < class F0, class F1 > struct Composer< F0, Arity_tag< 1 >, F1, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 > Arity; Composer(const F0& f0_, const F1& f1_) : f0(f0_), f1(f1_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1(a1)); } protected: F0 f0; F1 f1; }; template < class F0, class F1 > struct Composer< F0, Arity_tag< 1 >, F1, Arity_tag< 2 >, CGALi::Not_used, Arity_tag< -1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 > Arity; Composer(const F0& f0_, const F1& f1_) : f0(f0_), f1(f1_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1, a2)); } protected: F0 f0; F1 f1; }; template < class F0, class F1 > struct Composer< F0, Arity_tag< 1 >, F1, Arity_tag< 3 >, CGALi::Not_used, Arity_tag< -1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 > Arity; Composer(const F0& f0_, const F1& f1_) : f0(f0_), f1(f1_) {} template < class A1, class A2, class A3 > result_type operator()(const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1, a2, a3)); } protected: F0 f0; F1 f1; }; template < class F0, class F1 > struct Composer< F0, Arity_tag< 1 >, F1, Arity_tag< 4 >, CGALi::Not_used, Arity_tag< -1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 > Arity; Composer(const F0& f0_, const F1& f1_) : f0(f0_), f1(f1_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2, a3, a4)); } protected: F0 f0; F1 f1; }; template < class F0, class F1 > struct Composer< F0, Arity_tag< 1 >, F1, Arity_tag< 5 >, CGALi::Not_used, Arity_tag< -1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 5 > Arity; Composer(const F0& f0_, const F1& f1_) : f0(f0_), f1(f1_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3, a4, a5)); } protected: F0 f0; F1 f1; }; // ------------------------------------------------------------------------ // two functions to compose // ------------------------------------------------------------------------ template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} result_type operator()( ) const { return f0(f1( ), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; // unary functions template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 1 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1(a1), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1( ), f2(a1)); } protected: F0 f0; F1 f1; F2 f2; }; // binary functions template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 2 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1, a2), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1), f2(a2)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 2 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(), f2(a1, a2)); } protected: F0 f0; F1 f1; F2 f2; }; // 3-arg functions template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 3 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3 > result_type operator()(const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1, a2, a3), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 2 >, F2, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3 > result_type operator()(const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1, a2), f2(a3)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 1 >, F2, Arity_tag< 2 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3 > result_type operator()(const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1), f2(a2, a3)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 3 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3 > result_type operator()(const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( ), f2(a1, a2, a3)); } protected: F0 f0; F1 f1; F2 f2; }; // 4-arg functions template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 4 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2, a3, a4), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 3 >, F2, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2, a3), f2(a4)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 2 >, F2, Arity_tag< 2 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2), f2(a3, a4)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 1 >, F2, Arity_tag< 3 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1), f2(a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 4 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 4 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( ), f2(a1, a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; }; // 5-arg functions template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 5 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 5 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3, a4, a5), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 4 >, F2, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3, a4), f2(a5)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 3 >, F2, Arity_tag< 2 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3), f2(a4, a5)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 2 >, F2, Arity_tag< 3 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2), f2(a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 1 >, F2, Arity_tag< 4 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 4 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1), f2(a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 5 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 5 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2(a1, a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer_shared< F0, Arity_tag< 2 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} result_type operator()( ) const { return f0(f1( ), f2( )); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer_shared< F0, Arity_tag< 2 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1(a1), f2(a1)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer_shared< F0, Arity_tag< 2 >, F1, Arity_tag< 2 >, F2, Arity_tag< 2 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1, a2), f2(a1, a2)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer_shared< F0, Arity_tag< 2 >, F1, Arity_tag< 3 >, F2, Arity_tag< 3 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( a1, a2, a3), f2( a1, a2, a3)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer_shared< F0, Arity_tag< 2 >, F1, Arity_tag< 4 >, F2, Arity_tag< 4 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( a1, a2, a3, a4), f2( a1, a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; }; template < class F0, class F1, class F2 > struct Composer_shared< F0, Arity_tag< 2 >, F1, Arity_tag< 5 >, F2, Arity_tag< 5 >, CGALi::Not_used, Arity_tag< -1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 5 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_) : f0(f0_), f1(f1_), f2(f2_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( a1, a2, a3, a4, a5), f2( a1, a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; }; // ------------------------------------------------------------------------ // three functions to compose // ------------------------------------------------------------------------ template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} result_type operator()( ) const { return f0(f1( ), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; // unary functions template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1(a1), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 1 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 1 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1( ), f2(a1), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1( ), f2( ), f3(a1)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; // binary functions template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1, a2), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 2 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 2 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1( ), f2(a1, a2), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1( ), f2( ), f3(a1, a2)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 1 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1), f2(a2), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 0 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 0 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1), f2( ), f3(a2 )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 1 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 1 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1( ), f2(a1), f3(a2 )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; // 3-arg functions template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1, a2, a3), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 3 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 3 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( ), f2(a1, a2, a3), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( ), f2( ), f3(a1, a2, a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 1 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 1 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1, a2), f2(a3), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 0 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 0 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1, a2), f2( ), f3(a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 2 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 2 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1), f2(a2, a3), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 2 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 2 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( ), f2(a1, a2), f3(a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 0 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 0 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1), f2( ), f3(a2, a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 1 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 1 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( ), f2(a1), f3(a2, a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 1 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1(a1), f2(a2), f3(a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; // 4-arg functions template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 4 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 + 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2, a3, a4), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 4 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 4 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( ), f2(a1, a2, a3, a4), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 4 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 + 4 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( ), f2( ), f3(a1, a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 1 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 1 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2, a3), f2(a4), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 0 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 0 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2, a3), f2( ), f3(a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 3 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 3 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1), f2(a2, a3, a4), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 3 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 3 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( ), f2(a1, a2, a3), f3(a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 0 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 0 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1), f2( ), f3(a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 1 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 1 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( ), f2(a1), f3(a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 2 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 2 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2), f2(a3, a4), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 0 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 0 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2), f2( ), f3(a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 2 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 2 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( ), f2(a1, a2), f3(a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 1 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 1 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1, a2), f2(a3), f3(a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 2 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 2 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1), f2(a2, a3), f3(a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 1 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()(const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1(a1), f2(a2), f3(a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; // 5-arg functions template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 5 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 5 + 0 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3, a4, a5), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 5 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 5 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2(a1, a2, a3, a4, a5), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 5 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 0 + 5 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2( ), f3(a1, a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 4 >, F2, Arity_tag< 1 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 + 1 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3, a4), f2(a5), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 4 >, F2, Arity_tag< 0 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 + 0 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3, a4), f2( ), f3(a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 4 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 4 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1), f2(a2, a3, a4, a5), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 4 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 4 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2(a1, a2, a3, a4), f3(a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 0 >, F3, Arity_tag< 4 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 0 + 4 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1), f2( ), f3(a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 1 >, F3, Arity_tag< 4 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 1 + 4 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2(a1), f3(a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 2 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 2 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3), f2(a4, a5), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 0 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 0 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3), f2( ), f3(a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 3 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 3 + 0 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2), f2(a3, a4, a5), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 3 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 3 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2(a1, a2, a3), f3(a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 0 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 0 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2), f2( ), f3(a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 2 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 + 2 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( ), f2(a1, a2), f3(a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 1 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 + 1 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2, a3), f2(a4), f3(a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 3 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 3 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1), f2(a2, a3, a4), f3(a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 1 + 3 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1), f2(a2), f3(a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 2 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 2 + 1 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2), f2(a3, a4), f3(a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 1 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 + 1 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1, a2), f2(a3), f3(a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 2 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 + 2 + 2 > Arity; Composer(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()(const A1& a1, const A2& a2,const A3& a3, const A4& a4, const A5& a5) const { return f0(f1(a1), f2(a2, a3), f3(a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer_shared< F0, Arity_tag< 3 >, F1, Arity_tag< 0 >, F2, Arity_tag< 0 >, F3, Arity_tag< 0 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 0 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} result_type operator()( ) const { return f0(f1( ), f2( ), f3( )); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer_shared< F0, Arity_tag< 3 >, F1, Arity_tag< 1 >, F2, Arity_tag< 1 >, F3, Arity_tag< 1 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 1 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1 > result_type operator()(const A1& a1) const { return f0(f1(a1), f2(a1), f3(a1)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer_shared< F0, Arity_tag< 3 >, F1, Arity_tag< 2 >, F2, Arity_tag< 2 >, F3, Arity_tag< 2 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 2 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2 > result_type operator()(const A1& a1, const A2& a2) const { return f0(f1(a1, a2), f2(a1, a2), f3(a1, a2)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer_shared< F0, Arity_tag< 3 >, F1, Arity_tag< 3 >, F2, Arity_tag< 3 >, F3, Arity_tag< 3 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 3 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3 > result_type operator()( const A1& a1, const A2& a2, const A3& a3) const { return f0(f1( a1, a2, a3), f2( a1, a2, a3), f3( a1, a2, a3)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer_shared< F0, Arity_tag< 3 >, F1, Arity_tag< 4 >, F2, Arity_tag< 4 >, F3, Arity_tag< 4 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 4 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4) const { return f0(f1( a1, a2, a3, a4), f2( a1, a2, a3, a4), f3( a1, a2, a3, a4)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; template < class F0, class F1, class F2, class F3 > struct Composer_shared< F0, Arity_tag< 3 >, F1, Arity_tag< 5 >, F2, Arity_tag< 5 >, F3, Arity_tag< 5 > > { typedef typename F0::result_type result_type; typedef Arity_tag< 5 > Arity; Composer_shared(const F0& f0_, const F1& f1_, const F2& f2_, const F3& f3_) : f0(f0_), f1(f1_), f2(f2_), f3(f3_) {} template < class A1, class A2, class A3, class A4, class A5 > result_type operator()( const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) const { return f0(f1( a1, a2, a3, a4, a5), f2( a1, a2, a3, a4, a5), f3( a1, a2, a3, a4, a5)); } protected: F0 f0; F1 f1; F2 f2; F3 f3; }; } // namespace CGALi // ------------------------------------------------------------------------ // Encapsulate the composition type ==> can be adapted // ------------------------------------------------------------------------ template < class F0, class F1, class F2 = CGALi::Not_used, class F3 = CGALi::Not_used > struct Compose { typedef CGALi::Composer< F0, typename Arity_traits< F0 >::Arity, F1, typename Arity_traits< F1 >::Arity, F2, typename Arity_traits< F2 >::Arity, F3, typename Arity_traits< F3 >::Arity > Type; }; template < class F0, class F1, class F2, class F3 = CGALi::Not_used > struct Compose_shared { typedef CGALi::Composer_shared< F0, typename Arity_traits< F0 >::Arity, F1, typename Arity_traits< F1 >::Arity, F2, typename Arity_traits< F2 >::Arity, F3, typename Arity_traits< F3 >::Arity > Type; }; // ------------------------------------------------------------------------ // compose helper functions // ------------------------------------------------------------------------ template < class F0, class F1 > inline typename Compose< F0, F1 >::Type compose(const F0& f0, const F1& f1) { typedef typename Compose< F0, F1 >::Type C; return C(f0, f1); } template < class F0, class F1, class F2 > inline typename Compose< F0, F1, F2 >::Type compose(const F0& f0, const F1& f1, const F2& f2) { typedef typename Compose< F0, F1, F2 >::Type C; return C(f0, f1, f2); } template < class F0, class F1, class F2 > inline typename Compose_shared< F0, F1, F2 >::Type compose_shared(const F0& f0, const F1& f1, const F2& f2) { typedef typename Compose_shared< F0, F1, F2 >::Type C; return C(f0, f1, f2); } template < class F0, class F1, class F2, class F3 > inline typename Compose< F0, F1, F2, F3 >::Type compose(const F0& f0, const F1& f1, const F2& f2, const F3& f3) { typedef typename Compose< F0, F1, F2, F3 >::Type C; return C(f0, f1, f2, f3); } template < class F0, class F1, class F2, class F3 > inline typename Compose_shared< F0, F1, F2, F3 >::Type compose_shared(const F0& f0, const F1& f1, const F2& f2, const F3& f3) { typedef typename Compose_shared< F0, F1, F2, F3 >::Type C; return C(f0, f1, f2, f3); } // adaptor for not/negation template < typename F > inline typename Compose< std::logical_not, F >::Type negate(const F& f) { return compose(std::logical_not(), f); } CGAL_END_NAMESPACE #endif // CGAL_FUNCTIONAL_H // // EOF // ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/basic_constructions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/basic_constructions_2.0000644000175000017500000000237511344301500031327 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/basic_constructions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_BASIC_CONSTRUCTIONS_2_H #define CGAL_BASIC_CONSTRUCTIONS_2_H // Only kept for backward compatibility. #endif // CGAL_BASIC_CONSTRUCTIONS_2_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Triangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Triangle_2_i0000644000175000017500000001634411344301500031154 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Triangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SEGMENT_2_TRIANGLE_2_INTERSECTION_H #define CGAL_SEGMENT_2_TRIANGLE_2_INTERSECTION_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Segment_2_Triangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Segment_2_Triangle_2_pair() ; Segment_2_Triangle_2_pair(typename K::Segment_2 const *seg, typename K::Triangle_2 const *trian); ~Segment_2_Triangle_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: typename K::Segment_2 const * _seg; typename K::Triangle_2 const * _trian; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; mutable typename K::Point_2 _other_point; }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Segment_2 &p1, const typename CGAL_WRAP(K)::Triangle_2 &p2, const K&) { typedef Segment_2_Triangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Segment_2_Triangle_2_pair:: Segment_2_Triangle_2_pair() { _known = false; _seg = 0; _trian = 0; } template Segment_2_Triangle_2_pair:: Segment_2_Triangle_2_pair(typename K::Segment_2 const *seg, typename K::Triangle_2 const *trian) { _known = false; _seg = seg; _trian = trian; } template typename Segment_2_Triangle_2_pair::Intersection_results Segment_2_Triangle_2_pair::intersection_type() const { if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; Straight_2_ straight(*_seg); typedef typename K::Line_2 Line_2; Line_2 l(_trian->vertex(0), _trian->vertex(1)); if (l.oriented_side(_trian->vertex(2)) == ON_POSITIVE_SIDE) { straight.cut_right_off( Line_2(_trian->vertex(0), _trian->vertex(1))); straight.cut_right_off( Line_2(_trian->vertex(1), _trian->vertex(2))); straight.cut_right_off( Line_2(_trian->vertex(2), _trian->vertex(0))); } else { straight.cut_right_off( Line_2(_trian->vertex(2), _trian->vertex(1))); straight.cut_right_off( Line_2(_trian->vertex(1), _trian->vertex(0))); straight.cut_right_off( Line_2(_trian->vertex(0), _trian->vertex(2))); } switch (straight.current_state()) { case Straight_2_::EMPTY: _result = NO; return _result; case Straight_2_::POINT: { straight.current(_intersection_point); _result = POINT; return _result; } case Straight_2_::SEGMENT: { typename K::Segment_2 seg; straight.current(seg); _intersection_point = seg.source(); _other_point = seg.target(); _result = SEGMENT; return _result; } default: // should not happen. CGAL_kernel_assertion_msg(false, "Internal CGAL error."); _result = NO; return _result; } } template bool Segment_2_Triangle_2_pair:: intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Segment_2_Triangle_2_pair:: intersection(typename K::Segment_2 &result) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = Segment_2(_intersection_point, _other_point); return true; } template Object intersection(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Triangle_2&tr, const K&) { typedef Segment_2_Triangle_2_pair is_t; is_t ispair(&seg, &tr); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } template Object intersection(const typename CGAL_WRAP(K)::Triangle_2&tr, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { return CGALi::intersection(seg, tr, k); } template class Triangle_2_Segment_2_pair : public Segment_2_Triangle_2_pair { public: Triangle_2_Segment_2_pair( typename K::Triangle_2 const *trian, typename K::Segment_2 const *seg) : Segment_2_Triangle_2_pair(seg, trian) {} }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Triangle_2 &p1, const typename CGAL_WRAP(K)::Segment_2 &p2, const K&) { typedef Triangle_2_Segment_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } } // namespace CGALi template inline Object intersection(const Segment_2 &seg, const Triangle_2 &tr) { typedef typename K::Intersect_2 Intersect; return Intersect()(seg, tr); } template inline Object intersection(const Triangle_2 &tr, const Segment_2 &seg) { typedef typename K::Intersect_2 Intersect; return Intersect()(seg, tr); } template inline bool do_intersect(const Segment_2 &seg, const Triangle_2 &tr) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(seg, tr); } template inline bool do_intersect(const Triangle_2 &tr, const Segment_2 &seg) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(seg, tr); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/functional_base.h0000644000175000017500000001200611344301500030324 0ustar debiandebian// Copyright (c) 1997-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/functional_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Basics for CGAL Functors. #ifndef CGAL_FUNCTIONAL_BASE_H #define CGAL_FUNCTIONAL_BASE_H #include CGAL_BEGIN_NAMESPACE // +----------------------------------------------------------------------+ // | Defining a Functors Arity (== #arguments) // +----------------------------------------------------------------------+ template < int i > struct Arity_tag { enum { arity = i }; }; // use to deduce arity of functors --> allows binding std functors template < class T > struct Arity_traits { typedef typename T::Arity Arity; }; // -------------------------------------------------------------------- // specializations for std functors: // template < class T > struct Arity_traits< std::plus< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::minus< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::multiplies< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::divides< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::modulus< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::negate< T > > { typedef Arity_tag< 1 > Arity; }; template < class T > struct Arity_traits< std::equal_to< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::not_equal_to< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::greater< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::less< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::greater_equal< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::less_equal< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::logical_and< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::logical_or< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::logical_not< T > > { typedef Arity_tag< 1 > Arity; }; template < class T > struct Arity_traits< std::unary_negate< T > > { typedef Arity_tag< 1 > Arity; }; template < class T > struct Arity_traits< std::binary_negate< T > > { typedef Arity_tag< 2 > Arity; }; template < class T > struct Arity_traits< std::binder1st< T > > { typedef Arity_tag< 1 > Arity; }; template < class T > struct Arity_traits< std::binder2nd< T > > { typedef Arity_tag< 1 > Arity; }; template < class T1, class T2 > struct Arity_traits< std::pointer_to_unary_function< T1, T2 > > { typedef Arity_tag< 1 > Arity; }; template < class T1, class T2, class T3 > struct Arity_traits< std::pointer_to_binary_function< T1, T2, T3 > > { typedef Arity_tag< 2 > Arity; }; template < class T1, class T2 > struct Arity_traits< std::mem_fun_t< T1, T2 > > { typedef Arity_tag< 1 > Arity; }; template < class T1, class T2, class T3 > struct Arity_traits< std::mem_fun1_t< T1, T2, T3 > > { typedef Arity_tag< 2 > Arity; }; template < class T1, class T2 > struct Arity_traits< std::mem_fun_ref_t< T1, T2 > > { typedef Arity_tag< 1 > Arity; }; template < class T1, class T2, class T3 > struct Arity_traits< std::mem_fun1_ref_t< T1, T2, T3 > > { typedef Arity_tag< 2 > Arity; }; template < class T1, class T2 > struct Arity_traits< std::const_mem_fun_t< T1, T2 > > { typedef Arity_tag< 1 > Arity; }; template < class T1, class T2, class T3 > struct Arity_traits< std::const_mem_fun1_t< T1, T2, T3 > > { typedef Arity_tag< 2 > Arity; }; template < class T1, class T2 > struct Arity_traits< std::const_mem_fun_ref_t< T1, T2 > > { typedef Arity_tag< 1 > Arity; }; template < class T1, class T2, class T3 > struct Arity_traits< std::const_mem_fun1_ref_t< T1, T2, T3 > > { typedef Arity_tag< 2 > Arity; }; CGAL_END_NAMESPACE #endif // CGAL_FUNCTIONAL_BASE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_2.h0000644000175000017500000021155211344301501030241 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Olivier Devillers, Mariette Yvinec #ifndef CGAL_TRIANGULATION_2_H #define CGAL_TRIANGULATION_2_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Gt, class Tds > class Triangulation_2; template < class Gt, class Tds > std::istream& operator>> (std::istream& is, Triangulation_2 &tr); template < class Gt, class Tds > std::ostream& operator<< (std::ostream& os, const Triangulation_2 &tr); template < class Gt, class Tds = Triangulation_data_structure_2 < Triangulation_vertex_base_2, Triangulation_face_base_2 > > class Triangulation_2 : public Triangulation_cw_ccw_2 { friend std::istream& operator>> <> (std::istream& is, Triangulation_2 &tr); typedef Triangulation_2 Self; public: typedef Tds Triangulation_data_structure; typedef Gt Geom_traits; typedef typename Geom_traits::Point_2 Point; typedef typename Geom_traits::Segment_2 Segment; typedef typename Geom_traits::Triangle_2 Triangle; typedef typename Geom_traits::Orientation_2 Orientation_2; typedef typename Geom_traits::Compare_x_2 Compare_x; typedef typename Geom_traits::Compare_y_2 Compare_y; typedef typename Tds::size_type size_type; typedef typename Tds::difference_type difference_type; typedef typename Tds::Vertex Vertex; typedef typename Tds::Face Face; typedef typename Tds::Edge Edge; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Face_circulator Face_circulator; typedef typename Tds::Vertex_circulator Vertex_circulator; typedef typename Tds::Edge_circulator Edge_circulator; typedef typename Tds::Face_iterator All_faces_iterator; typedef typename Tds::Edge_iterator All_edges_iterator; typedef typename Tds::Vertex_iterator All_vertices_iterator; // This class is used to generate the Finite_*_iterators. class Infinite_tester { const Triangulation_2 *t; public: Infinite_tester() {} Infinite_tester(const Triangulation_2 *tr) : t(tr) {} bool operator()(const All_vertices_iterator & vit) const { return t->is_infinite(vit); } bool operator()(const All_faces_iterator & fit ) const { return t->is_infinite(fit); } bool operator()(const All_edges_iterator & eit) const { return t->is_infinite(eit); } }; //We derive in order to add a conversion to handle. class Finite_vertices_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef Finite_vertices_iterator Self; public: Finite_vertices_iterator() : Base() {} Finite_vertices_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator const Vertex_handle() const { return Base::base(); } }; class Finite_faces_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef Finite_faces_iterator Self; public: Finite_faces_iterator() : Base() {} Finite_faces_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator const Face_handle() const { return Base::base(); } }; typedef Filter_iterator Finite_edges_iterator; //for backward compatibility typedef Finite_faces_iterator Face_iterator; typedef Finite_edges_iterator Edge_iterator; typedef Finite_vertices_iterator Vertex_iterator; typedef Triangulation_line_face_circulator_2 Line_face_circulator; // Auxiliary iterators for convenience // do not use default template argument to please VC++ typedef Project_point Proj_point; typedef Iterator_project Point_iterator; typedef Point value_type; // to have a back_inserter typedef const value_type& const_reference; typedef value_type& reference; enum Locate_type {VERTEX=0, EDGE, //1 FACE, //2 OUTSIDE_CONVEX_HULL, //3 OUTSIDE_AFFINE_HULL}; //4 //Tag to distinguish Regular triangulations from others; typedef Tag_false Weighted_tag; protected: Gt _gt; Tds _tds; Vertex_handle _infinite_vertex; mutable Random rng; public: // CONSTRUCTORS Triangulation_2(const Geom_traits& geom_traits=Geom_traits()); Triangulation_2(const Triangulation_2 &tr); //Assignement Triangulation_2 &operator=(const Triangulation_2 &tr); //Helping void copy_triangulation(const Triangulation_2 &tr); void swap(Triangulation_2 &tr); void clear(); //ACCESS FUNCTION const Geom_traits& geom_traits() const { return _gt;} const Tds & tds() const { return _tds;} Tds & tds() { return _tds;} int dimension() const { return _tds.dimension();} size_type number_of_vertices() const {return _tds.number_of_vertices() - 1;} size_type number_of_faces() const; Vertex_handle infinite_vertex() const; Vertex_handle finite_vertex() const; Face_handle infinite_face() const; Infinite_tester infinite_tester() const; //SETTING void set_infinite_vertex(const Vertex_handle& v) {_infinite_vertex=v;} // CHECKING bool is_valid(bool verbose = false, int level = 0) const; // TEST INFINITE FEATURES AND OTHER FEATURES bool is_infinite(Face_handle f) const; bool is_infinite(Vertex_handle v) const; bool is_infinite(Face_handle f, int i) const; bool is_infinite(const Edge& e) const; bool is_infinite(const Edge_circulator& ec) const; bool is_infinite(const All_edges_iterator& ei) const; bool is_edge(Vertex_handle va, Vertex_handle vb) const; bool is_edge(Vertex_handle va, Vertex_handle vb, Face_handle& fr, int & i) const; bool includes_edge(Vertex_handle va, Vertex_handle vb, Vertex_handle& vbb, Face_handle& fr, int & i) const; bool is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) const; bool is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle &fr) const; // GEOMETRIC FEATURES AND CONSTRUCTION Triangle triangle(Face_handle f) const; Segment segment(Face_handle f, int i) const; Segment segment(const Edge& e) const; Segment segment(const Edge_circulator& ec) const; Segment segment(const All_edges_iterator& ei) const; Segment segment(const Finite_edges_iterator& ei) const; Point circumcenter(Face_handle f) const; Point circumcenter(const Point& p0, const Point& p1, const Point& p2) const; //INSERTION - DELETION - Flip public: void flip(Face_handle f, int i); Vertex_handle insert_first(const Point& p); Vertex_handle insert_second(const Point& p); Vertex_handle insert_in_edge(const Point& p, Face_handle f,int i); Vertex_handle insert_in_face(const Point& p, Face_handle f); Vertex_handle insert_outside_convex_hull(const Point& p, Face_handle f); Vertex_handle insert_outside_affine_hull(const Point& p); Vertex_handle insert(const Point &p, Face_handle start = Face_handle() ); Vertex_handle insert(const Point& p, Locate_type lt, Face_handle loc, int li ); // template < class InputIterator > // int insert(InputIterator first, InputIterator last); Vertex_handle push_back(const Point& a); void remove_degree_3(Vertex_handle v, Face_handle f = Face_handle()); void remove_first(Vertex_handle v); void remove_second(Vertex_handle v); void remove(Vertex_handle v); // POINT LOCATION Face_handle march_locate_1D(const Point& t, Locate_type& lt, int& li) const ; Face_handle march_locate_2D(Face_handle start, const Point& t, Locate_type& lt, int& li) const; Face_handle march_locate_2D_LFC(Face_handle start, const Point& t, Locate_type& lt, int& li) const; void compare_walks(const Point& p, Face_handle c1, Face_handle c2, Locate_type& lt1, Locate_type& lt2, int li1, int li2) const; Face_handle locate(const Point& p, Locate_type& lt, int& li, Face_handle start = Face_handle()) const; Face_handle locate(const Point &p, Face_handle start = Face_handle()) const; //TRAVERSING : ITERATORS AND CIRCULATORS Finite_faces_iterator finite_faces_begin() const; Finite_faces_iterator finite_faces_end() const; Finite_vertices_iterator finite_vertices_begin() const; Finite_vertices_iterator finite_vertices_end() const; Finite_edges_iterator finite_edges_begin() const; Finite_edges_iterator finite_edges_end() const; Point_iterator points_begin() const; Point_iterator points_end() const; All_faces_iterator all_faces_begin() const; All_faces_iterator all_faces_end() const; All_vertices_iterator all_vertices_begin() const; All_vertices_iterator all_vertices_end() const; All_edges_iterator all_edges_begin() const; All_edges_iterator all_edges_end() const; //for compatibility with previous versions Face_iterator faces_begin() const {return finite_faces_begin();} Face_iterator faces_end() const {return finite_faces_end();} Edge_iterator edges_begin() const {return finite_edges_begin();} Edge_iterator edges_end() const {return finite_edges_end();} Vertex_iterator vertices_begin() const {return finite_vertices_begin();} Vertex_iterator vertices_end() const {return finite_vertices_end();} Face_circulator incident_faces( Vertex_handle v, Face_handle f = Face_handle()) const; Vertex_circulator incident_vertices(Vertex_handle v, Face_handle f = Face_handle()) const; Edge_circulator incident_edges(Vertex_handle v, Face_handle f = Face_handle()) const; Line_face_circulator line_walk(const Point& p, const Point& q, Face_handle f = Face_handle()) const; // TO DEBUG void show_all() const; void show_vertex(Vertex_handle vh) const; void show_face( Face_handle fh) const; // IO // template < class Stream > // Stream& draw_triangulation(Stream& os) const; //PREDICATES Oriented_side oriented_side(const Point &p0, const Point &p1, const Point &p2, const Point &p) const; Bounded_side bounded_side(const Point &p0, const Point &p1, const Point &p2, const Point &p) const; Oriented_side oriented_side(Face_handle f, const Point &p) const; Oriented_side side_of_oriented_circle(Face_handle f, const Point & p) const; bool collinear_between(const Point& p, const Point& q, const Point& r) const; Comparison_result compare_x(const Point& p, const Point& q) const; Comparison_result compare_y(const Point& p, const Point& q) const; bool xy_equal(const Point& p, const Point& q) const; Orientation orientation(const Point& p, const Point& q, const Point& r) const; protected: void remove_1D(Vertex_handle v); void remove_2D(Vertex_handle v); bool test_dim_down(Vertex_handle v); void fill_hole(Vertex_handle v, std::list & hole); void fill_hole_delaunay(std::list & hole); public: void make_hole(Vertex_handle v, std::list & hole); // template // Vertex_handle star_hole( Point p, // EdgeIt edge_begin, // EdgeIt edge_end); // template // Vertex_handle star_hole( Point p, // EdgeIt edge_begin, // EdgeIt edge_end, // FaceIt face_begin, // FaceIt face_end); Face_handle create_face(Face_handle f1, int i1, Face_handle f2, int i2, Face_handle f3, int i3); Face_handle create_face(Face_handle f1, int i1, Face_handle f2, int i2); Face_handle create_face(Face_handle f, int i, Vertex_handle v); Face_handle create_face(Vertex_handle v1, Vertex_handle v2,Vertex_handle v3); Face_handle create_face(Vertex_handle v1, Vertex_handle v2,Vertex_handle v3, Face_handle f1, Face_handle f2, Face_handle f3); Face_handle create_face(); Face_handle create_face(Face_handle); //calls copy constructor of Face void delete_face(Face_handle f); void delete_vertex(Vertex_handle v); Vertex_handle file_input(std::istream& is); void file_output(std::ostream& os) const; private: Vertex_handle insert_outside_convex_hull_1(const Point& p, Face_handle f); Vertex_handle insert_outside_convex_hull_2(const Point& p, Face_handle f); // template members public: template < class Stream > Stream& draw_triangulation(Stream& os) const { Finite_edges_iterator it = finite_edges_begin(); for( ;it != finite_edges_end() ; ++it) { os << segment(it); } return os; } template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } public: template Vertex_handle star_hole( const Point& p, EdgeIt edge_begin, EdgeIt edge_end) { std::list empty_list; return star_hole(p, edge_begin, edge_end, empty_list.begin(), empty_list.end()); } template Vertex_handle star_hole( const Point& p, EdgeIt edge_begin, EdgeIt edge_end, FaceIt face_begin, FaceIt face_end) { typedef typename Triangulation_data_structure::Edge Tds_Edge; typedef typename Triangulation_data_structure::Face Tds_Face; Vertex_handle v = _tds.star_hole( edge_begin, edge_end, face_begin, face_end); v->set_point(p); return v; } }; // CONSTRUCTORS template Triangulation_2:: Triangulation_2(const Geom_traits& geom_traits) : _gt(geom_traits), _tds() { _infinite_vertex = _tds.insert_first(); } // copy constructor duplicates vertices and faces template Triangulation_2:: Triangulation_2(const Triangulation_2 &tr) : _gt(tr._gt) { _infinite_vertex = _tds.copy_tds(tr._tds, tr.infinite_vertex()); } //Assignement template Triangulation_2 & Triangulation_2:: operator=(const Triangulation_2 &tr) { copy_triangulation(tr); return *this; } // Helping functions template void Triangulation_2:: copy_triangulation(const Triangulation_2 &tr) { _tds.clear(); _gt = tr._gt; _infinite_vertex = _tds.copy_tds(tr._tds, tr._infinite_vertex); } template void Triangulation_2:: swap(Triangulation_2 &tr) { Vertex_handle v= _infinite_vertex; _infinite_vertex = tr._infinite_vertex; tr._infinite_vertex = v; _tds.swap(tr._tds); Geom_traits t = geom_traits(); _gt = tr.geom_traits(); tr._gt = t; } template void Triangulation_2:: clear() { _tds.clear(); //detruit tous les sommets et toutes les faces _infinite_vertex = _tds.insert_first(); } template typename Triangulation_2::size_type Triangulation_2:: number_of_faces() const { size_type count = _tds.number_of_faces(); Face_circulator fc = incident_faces(infinite_vertex()), done(fc); if ( ! fc.is_empty() ) { do { --count; ++fc; } while (fc != done); } return count; } template inline typename Triangulation_2::Vertex_handle Triangulation_2:: infinite_vertex() const { return _infinite_vertex; } template inline typename Triangulation_2::Vertex_handle Triangulation_2:: finite_vertex() const { CGAL_triangulation_precondition (number_of_vertices() >= 1); return (finite_vertices_begin()); } template inline typename Triangulation_2::Face_handle Triangulation_2:: infinite_face() const { return infinite_vertex()->face(); } template inline typename Triangulation_2::Infinite_tester Triangulation_2:: infinite_tester() const { return Infinite_tester(this); } template bool Triangulation_2:: is_valid(bool verbose, int level) const { bool result = _tds.is_valid(verbose, level); if (dimension() <= 0 || (dimension()==1 && number_of_vertices() == 2 ) ) return result; if (dimension() == 1) { Finite_vertices_iterator it1 = finite_vertices_begin(), it2(it1), it3(it1); ++it2; ++it3; ++it3; while( it3 != finite_vertices_end()) { Orientation s = orientation(it1->point(), it2->point(), it3->point()); result = result && s == COLLINEAR ; CGAL_triangulation_assertion(result); ++it1 ; ++it2; ++it3; } } else { //dimension() == 2 for(Finite_faces_iterator it=finite_faces_begin(); it!=finite_faces_end(); it++) { CGAL_triangulation_assertion( ! is_infinite(it)); Orientation s = orientation(it->vertex(0)->point(), it->vertex(1)->point(), it->vertex(2)->point()); CGAL_triangulation_assertion( s == LEFT_TURN ); result = result && ( s == LEFT_TURN ); } Vertex_circulator start = incident_vertices(infinite_vertex()); Vertex_circulator pc(start); Vertex_circulator qc(start); ++qc; Vertex_circulator rc(start); ++rc; ++rc; do{ Orientation s = orientation(pc->point(), qc->point(), rc->point()); CGAL_triangulation_assertion( s != LEFT_TURN ); result = result && ( s != LEFT_TURN ); ++pc ; ++qc ; ++rc; }while(pc != start); // check number of faces. This cannot be done by the Tds // which does not know the number of components nor the genus result = result && (number_of_faces() == 2*(number_of_vertices()+1) - 4 - infinite_vertex()->degree()); CGAL_triangulation_assertion( result); } return result; } template inline bool Triangulation_2:: is_infinite(Face_handle f) const { return f->has_vertex(infinite_vertex()); } template inline bool Triangulation_2:: is_infinite(Vertex_handle v) const { return v == infinite_vertex(); } template inline bool Triangulation_2:: is_infinite(Face_handle f, int i) const { return is_infinite(f->vertex(ccw(i))) || is_infinite(f->vertex(cw(i))); } template inline bool Triangulation_2:: is_infinite(const Edge& e) const { return is_infinite(e.first,e.second); } template inline bool Triangulation_2:: is_infinite(const Edge_circulator& ec) const { return is_infinite(*ec); } template inline bool Triangulation_2:: is_infinite(const All_edges_iterator& ei) const { return is_infinite(*ei); } template inline bool Triangulation_2:: is_edge(Vertex_handle va, Vertex_handle vb) const { return _tds.is_edge( va, vb); } template inline bool Triangulation_2:: is_edge(Vertex_handle va, Vertex_handle vb, Face_handle& fr, int & i) const { return _tds.is_edge(va, vb, fr, i); } template bool Triangulation_2:: includes_edge(Vertex_handle va, Vertex_handle vb, Vertex_handle & vbb, Face_handle& fr, int & i) const // returns true if the line segment ab contains an edge e of t // incident to a, false otherwise // if true, vbb becomes the vertex of e distinct from a // fr is the face incident to e and e=(fr,i) // fr is on the right side of a->b { Vertex_handle v; Orientation orient; int indv; Edge_circulator ec = incident_edges(va), done(ec); if (ec != 0) { do { //find the index of the other vertex of *ec indv = 3 - ((*ec).first)->index(va) - (*ec).second ; v = ((*ec).first)->vertex(indv); if (!is_infinite(v)) { if (v==vb) { vbb = vb; fr=(*ec).first; i= (*ec).second; return true; } else { orient = orientation(va->point(), vb->point(), v->point()); if((orient==COLLINEAR) && (collinear_between (va->point(), v->point(), vb->point()))) { vbb = v; fr=(*ec).first; i= (*ec).second; return true; } } } } while (++ec != done); } return false; } template inline bool Triangulation_2:: is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) const { return _tds.is_face(v1, v2, v3); } template inline bool Triangulation_2:: is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle &fr) const { return _tds.is_face(v1, v2, v3, fr); } template typename Triangulation_2::Triangle Triangulation_2:: triangle(Face_handle f) const { CGAL_triangulation_precondition( ! is_infinite(f) ); typename Gt::Construct_triangle_2 construct_triangle = geom_traits().construct_triangle_2_object(); return construct_triangle(f->vertex(0)->point(), f->vertex(1)->point(), f->vertex(2)->point()); } template typename Triangulation_2::Segment Triangulation_2:: segment(Face_handle f, int i) const { CGAL_triangulation_precondition( ! is_infinite(f,i)); typename Gt::Construct_segment_2 construct_segment = geom_traits().construct_segment_2_object(); return construct_segment(f->vertex(ccw(i))->point(), f->vertex(cw(i))->point()); } template typename Triangulation_2::Segment Triangulation_2:: segment(const Edge& e) const { CGAL_triangulation_precondition(! is_infinite(e)); typename Gt::Construct_segment_2 construct_segment = geom_traits().construct_segment_2_object(); return construct_segment(e.first->vertex(ccw(e.second))->point(), e.first->vertex( cw(e.second))->point()); } template typename Triangulation_2::Segment Triangulation_2:: segment(const Edge_circulator& ec) const { return segment(*ec); } template typename Triangulation_2::Segment Triangulation_2:: segment(const Finite_edges_iterator& ei) const { return segment(*ei); } template typename Triangulation_2::Segment Triangulation_2:: segment(const All_edges_iterator& ei) const { return segment(*ei); } template void Triangulation_2:: flip(Face_handle f, int i) { CGAL_triangulation_precondition ( f != Face_handle() ); CGAL_triangulation_precondition (i == 0 || i == 1 || i == 2); CGAL_triangulation_precondition( dimension()==2); CGAL_triangulation_precondition( !is_infinite(f) && !is_infinite(f->neighbor(i)) ); CGAL_triangulation_precondition( orientation(f->vertex(i)->point(), f->vertex(cw(i))->point(), f->mirror_vertex(i)->point()) == RIGHT_TURN && orientation(f->vertex(i)->point(), f->vertex(ccw(i))->point(), f->mirror_vertex(i)->point()) == LEFT_TURN); _tds.flip(f, i); return; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_first(const Point& p) { CGAL_triangulation_precondition(number_of_vertices() == 0); Vertex_handle v = _tds.insert_second(); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_second(const Point& p) { CGAL_triangulation_precondition(number_of_vertices() == 1); Vertex_handle v = _tds.insert_dim_up(infinite_vertex(), true); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_in_edge(const Point& p, Face_handle f,int i) { CGAL_triangulation_exactness_precondition( orientation(f->vertex(cw(i))->point(), p, f->vertex(ccw(i))->point()) == COLLINEAR && collinear_between(f->vertex(cw(i))->point(), p, f->vertex(ccw(i))->point() ) ); Vertex_handle v = _tds.insert_in_edge(f,i); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_in_face(const Point& p, Face_handle f) { CGAL_triangulation_precondition(oriented_side(f,p) == ON_POSITIVE_SIDE); Vertex_handle v= _tds.insert_in_face(f); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_outside_convex_hull(const Point& p, Face_handle f) { CGAL_triangulation_precondition(is_infinite(f) && dimension() >= 1); Vertex_handle v; if (dimension() == 1) v=insert_outside_convex_hull_1(p, f); else v=insert_outside_convex_hull_2(p, f); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_outside_convex_hull_1(const Point& p, Face_handle f) { CGAL_triangulation_precondition( is_infinite(f) && dimension()==1); CGAL_triangulation_precondition( orientation( f->mirror_vertex(f->index(infinite_vertex()))->point(), f->vertex(1- f->index(infinite_vertex()))->point(), p) == COLLINEAR && collinear_between( f->mirror_vertex(f->index(infinite_vertex()))->point(), f->vertex(1- f->index(infinite_vertex()))->point(), p) ); Vertex_handle v=_tds.insert_in_edge(f, 2); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_outside_convex_hull_2(const Point& p, Face_handle f) { CGAL_triangulation_precondition(is_infinite(f)); int li = f->index(infinite_vertex()); CGAL_triangulation_precondition( orientation(p, f->vertex(ccw(li))->point(), f->vertex(cw(li))->point()) == LEFT_TURN); std::list ccwlist; std::list cwlist; Face_circulator fc = incident_faces(infinite_vertex(), f); bool done = false; while(! done) { fc--; li = fc->index(infinite_vertex()); const Point& q = fc->vertex(ccw(li))->point(); const Point& r = fc->vertex(cw(li))->point(); if(orientation(p,q,r) == LEFT_TURN ) { ccwlist.push_back(fc); } else {done=true;} } fc = incident_faces(infinite_vertex(), f); done = false; while(! done){ fc++; li = fc->index(infinite_vertex()); const Point& q = fc->vertex(ccw(li))->point(); const Point& r = fc->vertex(cw(li))->point(); if(orientation(p,q,r) == LEFT_TURN ) { cwlist.push_back(fc);} else {done=true;} } Vertex_handle v = _tds.insert_in_face(f); v->set_point(p); Face_handle fh; while ( ! ccwlist.empty()) { fh = ccwlist.front(); li = ccw(fh->index(infinite_vertex())); _tds.flip( fh, li); ccwlist.pop_front(); } while ( ! cwlist.empty()) { fh = cwlist.front(); li = cw(fh->index(infinite_vertex())); _tds.flip( fh, li); cwlist.pop_front(); } //reset infinite_vertex()->face(); fc = incident_faces(v); while( ! is_infinite(fc)) { fc++;} infinite_vertex()->set_face(fc); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert_outside_affine_hull(const Point& p) { CGAL_triangulation_precondition(dimension() == 1); Face_handle f = (*finite_edges_begin()).first; Orientation orient = orientation( f->vertex(0)->point(), f->vertex(1)->point(), p); CGAL_triangulation_precondition(orient != COLLINEAR); bool conform = ( orient == COUNTERCLOCKWISE); Vertex_handle v = _tds.insert_dim_up( infinite_vertex(), conform); v->set_point(p); return v; } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert(const Point &p, Face_handle start) { Locate_type lt; int li; Face_handle loc = locate (p, lt, li, start); return insert(p, lt, loc, li); } template typename Triangulation_2::Vertex_handle Triangulation_2:: insert(const Point& p, Locate_type lt, Face_handle loc, int li) // insert a point p, whose localisation is known (lt, f, i) { if(number_of_vertices() == 0) { return(insert_first(p)); } if(number_of_vertices() == 1) { if (lt == VERTEX) return finite_vertex(); else return(insert_second(p)); } switch(lt) { case FACE: return insert_in_face(p,loc); case EDGE: return insert_in_edge(p,loc,li); case OUTSIDE_CONVEX_HULL: return insert_outside_convex_hull(p,loc); case OUTSIDE_AFFINE_HULL: return insert_outside_affine_hull(p); case VERTEX: return loc->vertex(li); } CGAL_triangulation_assertion(false); // locate step failed return Vertex_handle(); } template inline typename Triangulation_2::Vertex_handle Triangulation_2:: push_back(const Point &p) { return insert(p); } template inline void Triangulation_2:: remove_degree_3(Vertex_handle v, Face_handle f) { if (f == Face_handle()) f=v->face(); _tds.remove_degree_3(v, f); return; } template inline void Triangulation_2:: remove_first(Vertex_handle v) { _tds.remove_second(v); return; } template inline void Triangulation_2:: remove_second(Vertex_handle v) { _tds.remove_dim_down(v); return; } template void Triangulation_2:: remove(Vertex_handle v) { CGAL_triangulation_precondition( v != Vertex_handle()); CGAL_triangulation_precondition( !is_infinite(v)); if (number_of_vertices() == 1) remove_first(v); else if (number_of_vertices() == 2) remove_second(v); else if ( dimension() == 1) remove_1D(v); else remove_2D(v); return; } template inline void Triangulation_2:: remove_1D(Vertex_handle v) { _tds.remove_1D(v); } template bool Triangulation_2:: test_dim_down(Vertex_handle v) { //test the dimensionality of the resulting triangulation //upon removing of vertex v //it goes down to 1 iff // 1) any finite face is incident to v // 2) all vertices are colinear CGAL_triangulation_precondition(dimension() == 2); bool dim1 = true; Finite_faces_iterator fit = finite_faces_begin(); while (dim1==true && fit != finite_faces_end()) { dim1 = dim1 && fit->has_vertex(v); fit++; } Face_circulator fic = incident_faces(v); while (is_infinite(fic)) {++fic;} Face_circulator done(fic); Face_handle start(fic); int iv = start->index(v); const Point& p = start->vertex(cw(iv))->point(); const Point& q = start->vertex(ccw(iv))->point(); while ( dim1 && ++fic != done) { iv = fic->index(v); if (fic->vertex(ccw(iv)) != infinite_vertex()) { dim1 = dim1 && orientation(p, q, fic->vertex(ccw(iv))->point()) == COLLINEAR; } } return dim1; } template void Triangulation_2:: remove_2D(Vertex_handle v) { if (test_dim_down(v)) { _tds.remove_dim_down(v); } else { std::list hole; make_hole(v, hole); fill_hole(v, hole); delete_vertex(v); } return; } template void Triangulation_2:: make_hole ( Vertex_handle v, std::list & hole) { std::list to_delete; Face_handle f, fn; int i, in ; Vertex_handle vv; Face_circulator fc = incident_faces(v); Face_circulator done(fc); do { f = fc; fc++; i = f->index(v); fn = f->neighbor(i); in = fn->index(f); vv = f->vertex(cw(i)); if( vv->face()== f) vv->set_face(fn); vv = f->vertex(ccw(i)); if( vv->face()== f) vv->set_face(fn); fn->set_neighbor(in, Face_handle()); hole.push_back(Edge(fn,in)); to_delete.push_back(f); } while(fc != done); while (! to_delete.empty()){ delete_face(to_delete.front()); to_delete.pop_front(); } return; } template void Triangulation_2:: fill_hole ( Vertex_handle v, std::list< Edge > & hole ) { // uses the fact that the hole is starshaped // with repect to v->point() typedef std::list Hole; Face_handle ff, fn; int ii , in; Vertex_handle v0, v1, v2; Bounded_side side; //stack algorithm to create faces // create face v0,v1,v2 //if v0,v1,v2 are finite vertices // and form a left_turn // and triangle v0v1v2 does not contain v->point() if( hole.size() != 3) { typename Hole::iterator hit = hole.begin(); typename Hole::iterator next= hit; while( hit != hole.end() && hole.size() != 3) { ff = (*hit).first; ii = (*hit).second; v0 = ff->vertex(cw(ii)); v1 = ff->vertex(ccw(ii)); if( !is_infinite(v0) && !is_infinite(v1)) { next=hit; next++; if(next == hole.end()) next=hole.begin(); fn = (*next).first; in = (*next).second; v2 = fn->vertex(ccw(in)); if ( !is_infinite(v2) && orientation(v0->point(), v1->point(), v2->point()) == LEFT_TURN ) { side = bounded_side(v0->point(), v1->point(), v2->point(), v->point()); if( side == ON_UNBOUNDED_SIDE || (side == ON_BOUNDARY && orientation(v0->point(), v->point(), v2->point()) == COLLINEAR && collinear_between(v0->point(),v->point(),v2->point()) )) { //create face Face_handle newf = create_face(ff,ii,fn,in); typename Hole::iterator tempo=hit; hit = hole.insert(hit,Edge(newf,1)); //push newf hole.erase(tempo); //erase ff hole.erase(next); //erase fn if (hit != hole.begin() ) --hit; continue; } } } ++hit; } } // either the hole has only three edges // or all its finite vertices are reflex or flat // except may be one vertex whose corresponding ear // includes the vertex being removed // deal with the last left_turn if any if(hole.size() != 3) { typename Hole::iterator hit=hole.begin(); while(hit != hole.end()) { ff = (*hit).first; ii = (*hit).second; hit++; if(hit != hole.end()) { fn = (*hit).first; in = (*hit).second;} else { fn = ((hole.front()).first); in = (hole.front()).second;} if ( !is_infinite(ff->vertex(cw(ii))) && !is_infinite(fn->vertex(cw(in))) && !is_infinite(fn->vertex(ccw(in))) && orientation(ff->vertex(cw(ii))->point(), fn->vertex(cw(in))->point(), fn->vertex(ccw(in))->point()) == LEFT_TURN) { create_face(ff,ii,fn,in); break; } } } // deal with a reflex chain of convex hull edges if(hole.size() != 3) { // look for infinite vertex ff = (hole.front()).first; ii = (hole.front()).second; while ( ! is_infinite(ff->vertex(cw(ii)))){ hole.push_back(hole.front()); hole.pop_front(); ff = (hole.front()).first; ii = (hole.front()).second; } //create faces while(hole.size() != 3){ ff = (hole.front()).first; ii = (hole.front()).second; hole.pop_front(); fn = (hole.front()).first; in = (hole.front()).second; hole.pop_front(); Face_handle newf = create_face(ff,ii,fn,in); hole.push_front(Edge(newf,1)); } } // now hole has three edges typename Hole::iterator hit; hit = hole.begin(); // I don't know why the following yelds a segmentation fault // create_face( (*hit).first, (*hit).second, // (* ++hit).first, (*hit).second, // (* ++hit).first, (*hit).second); ff = (*hit).first; ii = (*hit).second; fn = (* ++hit).first; in = (*hit).second; Face_handle f3 = (* ++hit).first; int i3 = (*hit).second; create_face(ff,ii,fn,in,f3,i3); } template void Triangulation_2:: fill_hole_delaunay(std::list & first_hole) { typename Gt::Side_of_oriented_circle_2 in_circle = geom_traits().side_of_oriented_circle_2_object(); typedef std::list Hole; typedef std::list Hole_list; Face_handle f, ff, fn; int i, ii, in; Hole_list hole_list; Hole hole; hole_list.push_front(first_hole); while( ! hole_list.empty()) { hole = hole_list.front(); hole_list.pop_front(); typename Hole::iterator hit = hole.begin(); // if the hole has only three edges, create the triangle if (hole.size() == 3) { hit = hole.begin(); f = (*hit).first; i = (*hit).second; ff = (* ++hit).first; ii = (*hit).second; fn = (* ++hit).first; in = (*hit).second; create_face(f,i,ff,ii,fn,in); continue; } // else find an edge with two finite vertices // on the hole boundary // and the new triangle adjacent to that edge // cut the hole and push it back // first, ensure that a neighboring face // whose vertices on the hole boundary are finite // is the first of the hole bool finite= false; while (!finite){ ff = (hole.front()).first; ii = (hole.front()).second; if ( is_infinite(ff->vertex(cw(ii))) || is_infinite(ff->vertex(ccw(ii)))) { hole.push_back(hole.front()); hole.pop_front(); } else finite=true; } // take the first neighboring face and pop it; ff = (hole.front()).first; ii =(hole.front()).second; hole.pop_front(); Vertex_handle v0 = ff->vertex(ff->cw(ii)); Vertex_handle v1 = ff->vertex(ff->ccw(ii)); Vertex_handle v2 = infinite_vertex(); const Point& p0 = v0->point(); const Point& p1 = v1->point(); Point p2; Point p; Vertex_handle vv; typename Hole::iterator hdone = hole.end(); hit = hole.begin(); typename Hole::iterator cut_after(hit); // if tested vertex is c with respect to the vertex opposite // to NULL neighbor, // stop at the before last face; hdone--; while( hit != hdone) { fn = (*hit).first; in = (*hit).second; vv = fn->vertex(ccw(in)); if (is_infinite(vv)) { if(is_infinite(v2)) cut_after = hit; } else { // vv is a finite vertex p = vv->point(); if (orientation(p0,p1,p) == COUNTERCLOCKWISE) { if(is_infinite(v2)) { v2=vv; p2=p; cut_after=hit;} else{ if( in_circle(p0,p1,p2,p) == ON_POSITIVE_SIDE){ v2=vv; p2=p; cut_after=hit;} } } } ++hit; } // create new triangle and update adjacency relations Face_handle newf; //update the hole and push back in the Hole_List stack // if v2 belongs to the neighbor following or preceding *f // the hole remain a single hole // otherwise it is split in two holes fn = (hole.front()).first; in = (hole.front()).second; if (fn->has_vertex(v2, i) && i == fn->ccw(in)) { newf = create_face(ff,ii,fn,in); hole.pop_front(); hole.push_front(Edge( newf,1)); hole_list.push_front(hole); } else{ fn = (hole.back()).first; in = (hole.back()).second; if (fn->has_vertex(v2, i) && i== fn->cw(in)) { newf = create_face(fn,in,ff,ii); hole.pop_back(); hole.push_back(Edge(newf,1)); hole_list.push_front(hole); } else{ // split the hole in two holes newf = create_face(ff,ii,v2); Hole new_hole; ++cut_after; while( hole.begin() != cut_after ) { new_hole.push_back(hole.front()); hole.pop_front(); } hole.push_front(Edge( newf,1)); new_hole.push_front(Edge( newf,0)); hole_list.push_front(hole); hole_list.push_front(new_hole); } } } } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face(Face_handle f1, int i1, Face_handle f2, int i2, Face_handle f3, int i3) { return _tds.create_face(f1, i1, f2, i2, f3, i3); } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face(Face_handle f1, int i1, Face_handle f2, int i2) { return _tds.create_face(f1, i1, f2, i2); } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face(Face_handle f, int i, Vertex_handle v) { return _tds.create_face(f, i, v); } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) { return _tds.create_face(v1, v2, v3); } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle f1, Face_handle f2, Face_handle f3) { return _tds.create_face(v1, v2, v3, f1, f2, f3); } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face(Face_handle fh) { return _tds.create_face(fh); } template inline typename Triangulation_2::Face_handle Triangulation_2:: create_face() { return _tds.create_face(); } template inline void Triangulation_2:: delete_face(Face_handle f) { _tds.delete_face(f); } template inline void Triangulation_2:: delete_vertex(Vertex_handle v) { _tds.delete_vertex(v); } // POINT LOCATION template typename Triangulation_2::Face_handle Triangulation_2:: march_locate_1D(const Point& t, Locate_type& lt, int& li) const { Face_handle ff = infinite_face(); int iv = ff->index(infinite_vertex()); Face_handle f = ff->neighbor(iv); Orientation pqt = orientation(f->vertex(0)->point(), f->vertex(1)->point(), t); if(pqt == RIGHT_TURN || pqt == LEFT_TURN) { lt = OUTSIDE_AFFINE_HULL; li = 4 ;// should not be used return Face_handle(); } int i= f->index(ff); if (collinear_between(t,f->vertex(1-i)->point(),f->vertex(i)->point())) { lt = OUTSIDE_CONVEX_HULL; li = iv; return ff; } if( xy_equal(t,f->vertex(1-i)->point()) ){ lt = VERTEX; li=1-i; return f; } ff = ff->neighbor(1-iv); //the other infinite face iv = ff->index(infinite_vertex()); f = ff->neighbor(iv); i = f->index(ff); if (collinear_between(t,f->vertex(1-i)->point(),f->vertex(i)->point())) { lt = OUTSIDE_CONVEX_HULL; li = iv; return ff; } if( xy_equal(t,f->vertex(1-i)->point()) ){ lt = VERTEX; li=1-i; return f; } Finite_edges_iterator eit= finite_edges_begin(); Vertex_handle u,v; for( ; eit != finite_edges_end() ; eit++) { u = (*eit).first->vertex(0); v = (*eit).first->vertex(1); if(xy_equal(t,v->point())){ lt = VERTEX; li = 1; return (*eit).first; } if(collinear_between(u->point(), t, v->point())){ lt = EDGE; li = 2; return (*eit).first; } } CGAL_triangulation_assertion(false); return Face_handle(); } template typename Triangulation_2::Face_handle Triangulation_2:: march_locate_2D_LFC(Face_handle start, const Point& t, Locate_type& lt, int& li) const { // CGAL_triangulation_precondition( ! is_infinite(start) ); const Point& p = start->vertex(0)->point(); const Point& q = start->vertex(1)->point(); const Point& r = start->vertex(2)->point(); if(xy_equal(t,p)) { lt = VERTEX; li = 0; return start; } Line_face_circulator lfc; Orientation o2 = orientation(p, q, t); Orientation o0 = orientation(q, r, t); Orientation o1 = orientation(r, p, t); if( (o2 == LEFT_TURN)&& (o1 == LEFT_TURN)) { lfc = Line_face_circulator(start, 0, Line_face_circulator::vertex_edge, this, p, t); } else if ( (o0 == LEFT_TURN)&& (o2 == LEFT_TURN)) { lfc = Line_face_circulator(start, 1, Line_face_circulator::vertex_edge, this, q, t); } else if ( (o1 == LEFT_TURN)&& (o0 == LEFT_TURN)) { lfc = Line_face_circulator(start, 2, Line_face_circulator::vertex_edge, this, r, t); } if( (o2 == RIGHT_TURN)&& (o1 == RIGHT_TURN)) { lfc = Line_face_circulator(start, 0, Line_face_circulator::edge_vertex, this, p, t); } else if ( (o0 == RIGHT_TURN)&& (o2 == RIGHT_TURN)) { lfc = Line_face_circulator(start, 1, Line_face_circulator::edge_vertex, this, q, t); } else if ( (o1 == RIGHT_TURN)&& (o0 == RIGHT_TURN)) { lfc = Line_face_circulator(start, 2, Line_face_circulator::edge_vertex, this, r, t); }else { lfc = Line_face_circulator(start->vertex(0), this, t); } if(lfc==0 || lfc.collinear_outside()){ // point t lies outside or on the convex hull // we walk on the convex hull to find it out Face_circulator fc = infinite_vertex()->incident_faces(); Face_circulator done(fc); int ic = fc->index(infinite_vertex()); if (xy_equal(t,fc->vertex(cw(ic))->point())){ lt = VERTEX; li = cw(ic); return fc; } Orientation ori; do{ // walking ccw around convex hull ic = fc->index(infinite_vertex()); if (xy_equal(t,fc->vertex(ccw(ic))->point())){ lt = VERTEX; li = ccw(ic); return fc; } ori = orientation( fc->vertex(cw(ic))->point(), fc->vertex(ccw(ic))->point(), t); if (ori == RIGHT_TURN) { lt = OUTSIDE_CONVEX_HULL; li = ic; return fc; } if (ori == COLLINEAR && collinear_between(fc->vertex(cw(ic))->point(), t, fc->vertex(ccw(ic))->point()) ) { lt = EDGE; li = ic; return fc; } } while (--fc != done); //should not arrive there; CGAL_triangulation_assertion(fc != done); } while(! lfc.locate(t, lt, li) ){ ++lfc; } return lfc; } template void Triangulation_2:: compare_walks(const Point& p, Face_handle c1, Face_handle c2, Locate_type& lt1, Locate_type& lt2, int li1, int li2) const { bool b = true; b = b && (lt1 == lt2); if((lt1 == lt2) && (lt1 == VERTEX)) { b = b && ( c1->vertex(li1) == c2->vertex(li2) ); } else if((lt1 == lt2) && (lt1 == EDGE)) { b = b && ((c1 == c2) || ( (c1->neighbor(li1) == c2) && (c2->neighbor(li2) == c1))); }else if((lt1 == lt2) && (lt1 == OUTSIDE_CONVEX_HULL)) { b = b && (is_infinite(c1) && is_infinite(c2)); } else { b = b && (lt1 == lt2); b = b && (lt1 == FACE); b = b && (c1 == c2); } if ( c1 != c2) { std::cerr << "from compare_walks " << std::endl; std::cerr << "point " << p << std::endl; std::cerr << "locate 1 " << &*c1 << "\t" << lt1 << "\t" << li1 << std::endl; std::cerr << "locate 2 " << &*c2 << "\t" << lt2 << "\t" << li2 << std::endl; std::cerr << std::endl; show_face(c1); std::cerr << std::endl; show_face(c2); std::cerr << std::endl; } CGAL_triangulation_assertion(b); } #if 1 template typename Triangulation_2::Face_handle Triangulation_2:: march_locate_2D(Face_handle c, const Point& t, Locate_type& lt, int& li) const { CGAL_triangulation_assertion(! is_infinite(c)); Face_handle prev = Face_handle(); bool first = true; while (1) { if ( is_infinite(c) ) { // c must contain t in its interior lt = OUTSIDE_CONVEX_HULL; li = c->index(infinite_vertex()); return c; } // else c is finite // Instead of testing its edges in a random order we do the following // until we find a neighbor to go further: // As we come from prev we do not have to check the edge leading to prev // Now we flip a coin in order to decide if we start checking the // edge before or the edge after the edge leading to prev // We do loop unrolling in order to find out if this is faster. // In the very beginning we do not have a prev, but for the first step // we do not need randomness int left_first = rng.template get_bits<1>(); const Point & p0 = c->vertex( 0 )->point(); const Point & p1 = c->vertex( 1 )->point(); const Point & p2 = c->vertex( 2 )->point(); Orientation o0, o1, o2; if(first){ prev = c; first = false; o0 = orientation(p0,p1,t); if ( o0 == NEGATIVE ) { c = c->neighbor( 2 ); continue; } o1 = orientation(p1,p2,t); if ( o1 == NEGATIVE ) { c = c->neighbor( 0 ); continue; } o2 = orientation(p2,p0,t); if ( o2 == NEGATIVE ) { c = c->neighbor( 1 ); continue; } } else if(left_first){ if(c->neighbor(0) == prev){ prev = c; o0 = orientation(p0,p1,t); if ( o0 == NEGATIVE ) { c = c->neighbor( 2 ); continue; } o2 = orientation(p2,p0,t); if ( o2 == NEGATIVE ) { c = c->neighbor( 1 ); continue; } o1 = POSITIVE; } else if(c->neighbor(1) == prev){ prev = c; o1 = orientation(p1,p2,t); if ( o1 == NEGATIVE ) { c = c->neighbor( 0 ); continue; } o0 = orientation(p0,p1,t); if ( o0 == NEGATIVE ) { c = c->neighbor( 2 ); continue; } o2 = POSITIVE; } else { prev = c; o2 = orientation(p2,p0,t); if ( o2 == NEGATIVE ) { c = c->neighbor( 1 ); continue; } o1 = orientation(p1,p2,t); if ( o1 == NEGATIVE ) { c = c->neighbor( 0 ); continue; } o0 = POSITIVE; } } else { // right_first if(c->neighbor(0) == prev){ prev = c; o2 = orientation(p2,p0,t); if ( o2 == NEGATIVE ) { c = c->neighbor( 1 ); continue; } o0 = orientation(p0,p1,t); if ( o0 == NEGATIVE ) { c = c->neighbor( 2 ); continue; } o1 = POSITIVE; } else if(c->neighbor(1) == prev){ prev = c; o0 = orientation(p0,p1,t); if ( o0 == NEGATIVE ) { c = c->neighbor( 2 ); continue; } o1 = orientation(p1,p2,t); if ( o1 == NEGATIVE ) { c = c->neighbor( 0 ); continue; } o2 = POSITIVE; } else { prev = c; o1 = orientation(p1,p2,t); if ( o1 == NEGATIVE ) { c = c->neighbor( 0 ); continue; } o2 = orientation(p2,p0,t); if ( o2 == NEGATIVE ) { c = c->neighbor( 1 ); continue; } o0 = POSITIVE; } } // now p is in c or on its boundary int sum = ( o0 == COLLINEAR ) + ( o1 == COLLINEAR ) + ( o2 == COLLINEAR ); switch (sum) { case 0: { lt = FACE; li = 4; break; } case 1: { lt = EDGE; li = ( o0 == COLLINEAR ) ? 2 : ( o1 == COLLINEAR ) ? 0 : 1; break; } case 2: { lt = VERTEX; li = ( o0 != COLLINEAR ) ? 2 : ( o1 != COLLINEAR ) ? 0 : 1; break; } } return c; } } #else template typename Triangulation_2::Face_handle Triangulation_2:: march_locate_2D(Face_handle c, const Point& t, Locate_type& lt, int& li) const { CGAL_triangulation_assertion(! is_infinite(c)); Face_handle prev = Face_handle(); while (1) { if ( is_infinite(c) ) { // c must contain t in its interior lt = OUTSIDE_CONVEX_HULL; li = c->index(infinite_vertex()); return c; } // else c is finite // we test its edges in a random order until we find a // neighbor to go further int i = rng.template get_bits<2>(); int ccwi = ccw(i); int cwi = cw(i); const Point & p0 = c->vertex( i )->point(); const Point & p1 = c->vertex( ccwi )->point(); Orientation o0, o1, o2; CGAL_triangulation_assertion(orientation(p0,p1,c->vertex( cwi )->point())==POSITIVE); if(c->neighbor(cwi) == prev){ o0 = POSITIVE; } else { o0 = orientation(p0,p1,t); if ( o0 == NEGATIVE ) { prev = c; c = c->neighbor( cwi ); continue; } } const Point & p2 = c->vertex( cwi )->point(); if(c->neighbor(i) == prev){ o1 = POSITIVE; } else { o1 = orientation(p1,p2,t); if ( o1 == NEGATIVE ) { prev = c; c = c->neighbor( i ); continue; } } if(c->neighbor(ccwi) == prev){ o2 = POSITIVE; } else { o2 = orientation(p2,p0,t); if ( o2 == NEGATIVE ) { prev = c; c = c->neighbor( ccwi ); continue; } } // now p is in c or on its boundary int sum = ( o0 == COLLINEAR ) + ( o1 == COLLINEAR ) + ( o2 == COLLINEAR ); switch (sum) { case 0: { lt = FACE; li = 4; break; } case 1: { lt = EDGE; li = ( o0 == COLLINEAR ) ? cwi : ( o1 == COLLINEAR ) ? i : ccwi; break; } case 2: { lt = VERTEX; li = ( o0 != COLLINEAR ) ? cwi : ( o1 != COLLINEAR ) ? i : ccwi; break; } } return c; } } #endif template typename Triangulation_2::Face_handle Triangulation_2:: locate(const Point& p, Locate_type& lt, int& li, Face_handle start) const { if( dimension() <= 0) { if(number_of_vertices() == 0) { lt = OUTSIDE_AFFINE_HULL; li = 4; // li should not be used in this case } else { // number_of_vertices() == 1 if (xy_equal(p,finite_vertex()->point())){ lt = VERTEX ; } else{ lt = OUTSIDE_AFFINE_HULL; } li = 4; // li should not be used in this case } return Face_handle(); } if(dimension() == 1){ return march_locate_1D(p, lt, li); } if(start == Face_handle()){ start = infinite_face()-> neighbor(infinite_face()->index(infinite_vertex())); }else if(is_infinite(start)){ start = start->neighbor(start->index(infinite_vertex())); } #if ( ! defined(CGAL_ZIG_ZAG_WALK)) && ( ! defined(CGAL_LFC_WALK)) #define CGAL_ZIG_ZAG_WALK #endif #ifdef CGAL_ZIG_ZAG_WALK Face_handle res1 = march_locate_2D(start, p, lt, li); #endif #ifdef CGAL_LFC_WALK Locate_type lt2; int li2; Face_handle res2 = march_locate_2D_LFC(start, p, lt2, li2); #endif #if defined(CGAL_ZIG_ZAG_WALK) && defined(CGAL_LFC_WALK) compare_walks(p, res1, res2, lt, lt2, li, li2); #endif #ifdef CGAL_ZIG_ZAG_WALK return res1; #endif #ifdef CGAL_LFC_WALK lt = lt2; li = li2; return res2; #endif } template typename Triangulation_2:: Face_handle Triangulation_2:: locate(const Point &p, Face_handle start) const { Locate_type lt; int li; return locate(p, lt, li, start); } template typename Triangulation_2::Finite_faces_iterator Triangulation_2:: finite_faces_begin() const { if ( dimension() < 2 ) return finite_faces_end(); return filter_iterator( all_faces_end(), Infinite_tester(this), all_faces_begin() ); } template typename Triangulation_2::Finite_faces_iterator Triangulation_2:: finite_faces_end() const { return filter_iterator( all_faces_end(), Infinite_tester(this) ); } template typename Triangulation_2::Finite_vertices_iterator Triangulation_2:: finite_vertices_begin() const { if ( number_of_vertices() <= 0 ) return finite_vertices_end(); return filter_iterator( all_vertices_end(), Infinite_tester(this), all_vertices_begin() ); } template typename Triangulation_2::Finite_vertices_iterator Triangulation_2:: finite_vertices_end() const { return filter_iterator(all_vertices_end(), Infinite_tester(this)); } template typename Triangulation_2::Finite_edges_iterator Triangulation_2:: finite_edges_begin() const { if ( dimension() < 1 ) return finite_edges_end(); return filter_iterator( all_edges_end(), infinite_tester(), all_edges_begin()); } template typename Triangulation_2::Finite_edges_iterator Triangulation_2:: finite_edges_end() const { return filter_iterator(all_edges_end(), infinite_tester() ); } template typename Triangulation_2::Point_iterator Triangulation_2:: points_begin() const { return Point_iterator(finite_vertices_begin()); } template typename Triangulation_2::Point_iterator Triangulation_2:: points_end() const { return Point_iterator(finite_vertices_end()); } template typename Triangulation_2::All_faces_iterator Triangulation_2:: all_faces_begin() const { return _tds.faces_begin(); } template typename Triangulation_2::All_faces_iterator Triangulation_2:: all_faces_end() const { return _tds.faces_end();; } template typename Triangulation_2::All_vertices_iterator Triangulation_2:: all_vertices_begin() const { return _tds.vertices_begin(); } template typename Triangulation_2::All_vertices_iterator Triangulation_2:: all_vertices_end() const { return _tds.vertices_end(); } template typename Triangulation_2::All_edges_iterator Triangulation_2:: all_edges_begin() const { return _tds.edges_begin(); } template typename Triangulation_2::All_edges_iterator Triangulation_2:: all_edges_end() const { return _tds.edges_end(); } template inline typename Triangulation_2::Face_circulator Triangulation_2:: incident_faces(Vertex_handle v, Face_handle f) const { return _tds.incident_faces(v,f); } template inline typename Triangulation_2::Vertex_circulator Triangulation_2:: incident_vertices(Vertex_handle v, Face_handle f) const { return _tds.incident_vertices(v,f); } template inline typename Triangulation_2::Edge_circulator Triangulation_2:: incident_edges(Vertex_handle v, Face_handle f) const { return _tds.incident_edges(v,f); } template typename Triangulation_2::Line_face_circulator Triangulation_2:: line_walk(const Point& p, const Point& q, Face_handle f) const { CGAL_triangulation_precondition( (dimension() == 2) && ! xy_equal(p,q)); Line_face_circulator lfc = (f == Face_handle()) ? Line_face_circulator(p, q, this) : Line_face_circulator(p, q, f, this); // the following lines may be useless : // Line_face_circulator(p,q...) returns either a null circulator // or a pointer to a finite face (to be checked) if( (!lfc.is_empty()) && is_infinite( lfc )){ do { ++lfc ;} while (is_infinite(lfc)); } return lfc; } template Oriented_side Triangulation_2:: oriented_side(const Point &p0, const Point &p1, const Point &p2, const Point &p) const { // return position of point p with respect to the oriented triangle p0p1p2 // depends on the orientation of the vertices Bounded_side bs=bounded_side(p0,p1,p2,p); if (bs == ON_BOUNDARY) return ON_ORIENTED_BOUNDARY; Orientation ot = orientation(p0, p1, p2); if (bs == ON_BOUNDED_SIDE) return (ot == LEFT_TURN) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; // bs == ON_UNBOUNDED_SIDE return (ot == LEFT_TURN) ? ON_NEGATIVE_SIDE : ON_POSITIVE_SIDE; } template Bounded_side Triangulation_2:: bounded_side(const Point &p0, const Point &p1, const Point &p2, const Point &p) const { // return position of point p with respect to triangle p0p1p2 CGAL_triangulation_precondition( orientation(p0, p1, p2) != COLLINEAR); Orientation o1 = orientation(p0, p1, p), o2 = orientation(p1, p2, p), o3 = orientation(p2, p0, p); if (o1 == COLLINEAR){ if (o2 == COLLINEAR || o3 == COLLINEAR) return ON_BOUNDARY; if (collinear_between(p0, p, p1)) return ON_BOUNDARY; return ON_UNBOUNDED_SIDE; } if (o2 == COLLINEAR){ if (o3 == COLLINEAR) return ON_BOUNDARY; if (collinear_between(p1, p, p2)) return ON_BOUNDARY; return ON_UNBOUNDED_SIDE; } if (o3 == COLLINEAR){ if (collinear_between(p2, p, p0)) return ON_BOUNDARY; return ON_UNBOUNDED_SIDE; } // from here none ot, o1, o2 and o3 are known to be non null if (o1 == o2 && o2 == o3) return ON_BOUNDED_SIDE; return ON_UNBOUNDED_SIDE; } template Oriented_side Triangulation_2:: oriented_side(Face_handle f, const Point &p) const { CGAL_triangulation_precondition ( dimension()==2); return oriented_side(f->vertex(0)->point(), f->vertex(1)->point(), f->vertex(2)->point(), p); } template < class Gt, class Tds > Oriented_side Triangulation_2:: side_of_oriented_circle(Face_handle f, const Point & p) const { if ( ! is_infinite(f) ) { typename Gt::Side_of_oriented_circle_2 in_circle = geom_traits().side_of_oriented_circle_2_object(); return in_circle(f->vertex(0)->point(), f->vertex(1)->point(), f->vertex(2)->point(),p); } int i = f->index(infinite_vertex()); Orientation o = orientation(f->vertex(ccw(i))->point(), f->vertex(cw(i))->point(), p); return (o == NEGATIVE) ? ON_NEGATIVE_SIDE : (o == POSITIVE) ? ON_POSITIVE_SIDE : ON_ORIENTED_BOUNDARY; } template bool Triangulation_2:: collinear_between(const Point& p, const Point& q, const Point& r) const { // return true if point q is strictly between p and r // p,q and r are supposed to be collinear points Comparison_result c_pr = compare_x(p, r); Comparison_result c_pq; Comparison_result c_qr; if(c_pr == EQUAL) { //c_pr = compare_y(p, r); c_pq = compare_y(p, q); c_qr = compare_y(q, r); } else { c_pq = compare_x(p, q); c_qr = compare_x(q, r); } return ( (c_pq == SMALLER) && (c_qr == SMALLER) ) || ( (c_pq == LARGER) && (c_qr == LARGER) ); } template inline Comparison_result Triangulation_2:: compare_x(const Point& p, const Point& q) const { return geom_traits().compare_x_2_object()(p,q); } template inline Comparison_result Triangulation_2:: compare_y(const Point& p, const Point& q) const { return geom_traits().compare_y_2_object()(p,q); } template inline bool Triangulation_2:: xy_equal(const Point& p, const Point& q) const { return compare_x(p,q)== EQUAL && compare_y(p,q)== EQUAL ; } template inline Orientation Triangulation_2:: orientation(const Point& p, const Point& q,const Point& r ) const { return geom_traits().orientation_2_object()(p,q,r); } template inline typename Triangulation_2::Point Triangulation_2:: circumcenter (const Point& p0, const Point& p1, const Point& p2) const { return geom_traits().construct_circumcenter_2_object()(p0,p1,p2); } template typename Triangulation_2::Point Triangulation_2:: circumcenter(Face_handle f) const { CGAL_triangulation_precondition (dimension()==2); // typename Gt::Construct_circumcenter_2 // circumcenter = geom_traits().construct_circumcenter_2_object(); return circumcenter((f->vertex(0))->point(), (f->vertex(1))->point(), (f->vertex(2))->point()); } template void Triangulation_2:: show_all() const { std::cerr<< "AFFICHE TOUTE LA TRIANGULATION :"< "<< this; std::cerr << " dimension " << dimension() << std::endl; std::cerr << "nb of vertices " << number_of_vertices() << std::endl; if (dimension() < 1) return; if(dimension() == 1) { std::cerr<<" all edges "<first); } return; } std::cerr<<" faces finies "<1) { std::cerr << "affichage des sommets de la triangulation reguliere" <face())))<< std::endl;; } std::cerr< void Triangulation_2:: show_vertex(Vertex_handle vh) const { if(is_infinite(vh)) std::cerr << "inf \t"; else std::cerr << vh->point() << "\t"; return; } template void Triangulation_2:: show_face(Face_handle fh) const { std::cerr << "face : "<<(void*)&(*fh)<<" => "<dimension(); switch(i){ case 0: std::cerr <<"point :" ; show_vertex(fh->vertex(0)); std::cerr <<" / voisin " << &(*(fh->neighbor(0))); std::cerr <<"[" ; show_vertex(fh->neighbor(0)->vertex(0)); std::cerr <<"]" << std::endl; break; case 1: std::cerr <<"point :" ; show_vertex(fh->vertex(0)); std::cerr <<" / voisin " << &(*(fh->neighbor(0))); std::cerr <<"[" ; show_vertex(fh->neighbor(0)->vertex(0)); std::cerr <<"/" ; show_vertex(fh->neighbor(0)->vertex(1)); std::cerr <<"]" <vertex(1)); std::cerr <<" / voisin " << &(*(fh->neighbor(1))); std::cerr <<"[" ; show_vertex(fh->neighbor(1)->vertex(0)); std::cerr <<"/" ; show_vertex(fh->neighbor(1)->vertex(1)); std::cerr <<"]" <vertex(0)); std::cerr <<" / voisin " << &(*(fh->neighbor(0))); std::cerr <<"[" ; show_vertex(fh->neighbor(0)->vertex(0)); std::cerr <<"/" ; show_vertex(fh->neighbor(0)->vertex(1)); std::cerr <<"/" ; show_vertex(fh->neighbor(0)->vertex(2)); std::cerr <<"]" <vertex(1)); std::cerr <<" / voisin " << &(*(fh->neighbor(1))); std::cerr <<"[" ; show_vertex(fh->neighbor(1)->vertex(0)); std::cerr <<"/" ; show_vertex(fh->neighbor(1)->vertex(1)); std::cerr <<"/" ; show_vertex(fh->neighbor(1)->vertex(2)); std::cerr <<"]" <vertex(2)); std::cerr <<" / voisin " << &(*(fh->neighbor(2))); std::cerr <<"[" ; show_vertex(fh->neighbor(2)->vertex(0)); std::cerr <<"/" ; show_vertex(fh->neighbor(2)->vertex(1)); std::cerr <<"/" ; show_vertex(fh->neighbor(2)->vertex(2)); std::cerr <<"]" < void Triangulation_2:: file_output(std::ostream& os) const { _tds.file_output(os, infinite_vertex(), true); } template typename Triangulation_2::Vertex_handle Triangulation_2:: file_input(std::istream& is) { clear(); Vertex_handle v= _tds.file_input(is, true); set_infinite_vertex(v); return v; } template std::ostream& operator<<(std::ostream& os, const Triangulation_2 &tr) { tr.file_output(os); return os ; } template < class Gt, class Tds > std::istream& operator>>(std::istream& is, Triangulation_2 &tr) { tr.file_input(is); CGAL_triangulation_assertion(tr.is_valid()); return is; } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/assertions.h0000644000175000017500000003351511344301500027372 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman and Sven Schoenherr #ifndef CGAL_CONFIG_H #include #endif // CGAL_CONFIG_H #ifndef CGAL_ASSERTIONS_H #define CGAL_ASSERTIONS_H CGAL_BEGIN_NAMESPACE // types // ===== enum Failure_behaviour { ABORT, EXIT, EXIT_WITH_SUCCESS, CONTINUE }; // function declarations // ===================== // failure functions // ----------------- void assertion_fail ( const char*, const char*, int, const char*); void precondition_fail ( const char*, const char*, int, const char*); void postcondition_fail ( const char*, const char*, int, const char*); // warning function // ---------------- void warning_fail( const char*, const char*, int, const char*); // macro definitions // ================= // assertions // ---------- #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_assertion(EX) (static_cast(0)) # define CGAL_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_assertion_code(CODE) #else # define CGAL_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_assertion_code(CODE) CODE #endif // CGAL_KERNEL_NO_ASSERTIONS #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_exactness_assertion(EX) (static_cast(0)) # define CGAL_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_exactness_assertion_code(CODE) #else # define CGAL_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_exactness_assertion_code(CODE) CODE #endif // CGAL_KERNEL_NO_ASSERTIONS #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_assertion(EX) (static_cast(0)) # define CGAL_expensive_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_assertion_code(CODE) #else # define CGAL_expensive_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_assertion_code(CODE) CODE #endif // CGAL_KERNEL_NO_ASSERTIONS #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_exactness_assertion(EX) (static_cast(0)) # define CGAL_expensive_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_exactness_assertion_code(CODE) #else # define CGAL_expensive_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_exactness_assertion_code(CODE) CODE #endif // CGAL_KERNEL_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_precondition(EX) (static_cast(0)) # define CGAL_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_precondition_code(CODE) #else # define CGAL_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_precondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_PRECONDITIONS #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_exactness_precondition(EX) (static_cast(0)) # define CGAL_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_exactness_precondition_code(CODE) #else # define CGAL_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_exactness_precondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_PRECONDITIONS #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_precondition(EX) (static_cast(0)) # define CGAL_expensive_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_precondition_code(CODE) #else # define CGAL_expensive_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_precondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_PRECONDITIONS #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_exactness_precondition(EX) (static_cast(0)) # define CGAL_expensive_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_exactness_precondition_code(CODE) #else # define CGAL_expensive_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_exactness_precondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_postcondition(EX) (static_cast(0)) # define CGAL_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_postcondition_code(CODE) #else # define CGAL_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_postcondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_POSTCONDITIONS #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_exactness_postcondition(EX) (static_cast(0)) # define CGAL_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_exactness_postcondition_code(CODE) #else # define CGAL_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_exactness_postcondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_POSTCONDITIONS #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_postcondition(EX) (static_cast(0)) # define CGAL_expensive_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_postcondition_code(CODE) #else # define CGAL_expensive_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_postcondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_POSTCONDITIONS #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_exactness_postcondition(EX) (static_cast(0)) # define CGAL_expensive_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_exactness_postcondition_code(CODE) #else # define CGAL_expensive_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_exactness_postcondition_code(CODE) CODE #endif // CGAL_KERNEL_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_warning(EX) (static_cast(0)) # define CGAL_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_warning_code(CODE) #else # define CGAL_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_warning_code(CODE) CODE #endif // CGAL_KERNEL_NO_WARNINGS #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_exactness_warning(EX) (static_cast(0)) # define CGAL_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_exactness_warning_code(CODE) #else # define CGAL_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_exactness_warning_code(CODE) CODE #endif // CGAL_KERNEL_NO_WARNINGS #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_warning(EX) (static_cast(0)) # define CGAL_expensive_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_warning_code(CODE) #else # define CGAL_expensive_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_warning_code(CODE) CODE #endif // CGAL_KERNEL_NO_WARNINGS #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG) # define CGAL_expensive_exactness_warning(EX) (static_cast(0)) # define CGAL_expensive_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_expensive_exactness_warning_code(CODE) #else # define CGAL_expensive_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_expensive_exactness_warning_code(CODE) CODE #endif // CGAL_KERNEL_NO_WARNINGS // failure handler declarations // ========================== // failure handler // --------------- typedef void (*Failure_function)( const char*, const char*, const char*, int, const char*); Failure_function set_error_handler( Failure_function handler); Failure_function set_warning_handler( Failure_function handler); // failure behaviour handler // ------------------------- Failure_behaviour set_error_behaviour(Failure_behaviour eb); Failure_behaviour set_warning_behaviour(Failure_behaviour eb); CGAL_END_NAMESPACE #endif // CGAL_ASSERTIONS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3_1.h0000644000175000017500000005724311344301501031165 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3_1.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman, Andreas Fabri #ifndef CGAL_DISTANCE_3_1_H #define CGAL_DISTANCE_3_1_H #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Point_3 &pt, const typename CGAL_WRAP(K)::Line_3 &line, const K& k) { typedef typename K::Vector_3 Vector_3; typename K::Construct_vector_3 construct_vector; Vector_3 dir(line.direction().vector()); Vector_3 diff = construct_vector(line.point(), pt); return CGALi::squared_distance_to_line(dir, diff, k); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Line_3 & line, const typename CGAL_WRAP(K)::Point_3 & pt, const K& k) { return squared_distance(pt, line, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Point_3 &pt, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; Vector_3 diff = construct_vector(ray.source(), pt); const Vector_3 &dir = ray.direction().vector(); if (!is_acute_angle(dir,diff, k) ) return (typename K::FT)(diff*diff); return squared_distance_to_line(dir, diff, k); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Ray_3 & ray, const typename CGAL_WRAP(K)::Point_3 & pt, const K& k) { return squared_distance(pt, ray, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Point_3 &pt, const typename CGAL_WRAP(K)::Segment_3 &seg, const K& k, const Homogeneous_tag) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; typedef typename K::RT RT; typedef typename K::FT FT; // assert that the segment is valid (non zero length). Vector_3 diff = construct_vector(seg.source(), pt); Vector_3 segvec = construct_vector(seg.source(), seg.target()); RT d = wdot(diff,segvec, k); if (d <= (RT)0) return (FT(diff*diff)); RT e = wdot(segvec,segvec, k); if ( (d * segvec.hw()) > (e * diff.hw())) return squared_distance(pt, seg.target(), k); Vector_3 wcr = wcross(segvec, diff, k); return FT(wcr*wcr)/FT(e * diff.hw() * diff.hw()); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Point_3 &pt, const typename CGAL_WRAP(K)::Segment_3 &seg, const K& k, const Cartesian_tag&) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; typedef typename K::RT RT; typedef typename K::FT FT; // assert that the segment is valid (non zero length). Vector_3 diff = construct_vector(seg.source(), pt); Vector_3 segvec = construct_vector(seg.source(), seg.target()); RT d = wdot(diff,segvec, k); if (d <= (RT)0) return (FT(diff*diff)); RT e = wdot(segvec,segvec, k); if (d > e) return squared_distance(pt, seg.target(), k); Vector_3 wcr = wcross(segvec, diff, k); return FT(wcr*wcr)/e; } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Point_3 &pt, const typename CGAL_WRAP(K)::Segment_3 &seg, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return squared_distance(pt, seg, k, tag); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Segment_3 & seg, const typename CGAL_WRAP(K)::Point_3 & pt, const K& k) { return squared_distance(pt, seg, k); } template typename K::FT squared_distance_parallel( const typename CGAL_WRAP(K)::Segment_3 &seg1, const typename CGAL_WRAP(K)::Segment_3 &seg2, const K& k) { typedef typename K::Vector_3 Vector_3; const Vector_3 &dir1 = seg1.direction().vector(); const Vector_3 &dir2 = seg2.direction().vector(); if (same_direction(dir1, dir2, k)) { if (!is_acute_angle(seg1.source(), seg1.target(), seg2.source(), k)) return squared_distance(seg1.target(), seg2.source(), k); if (!is_acute_angle(seg1.target(), seg1.source(), seg2.target(), k)) return squared_distance(seg1.source(), seg2.target(), k); } else { if (!is_acute_angle(seg1.source(), seg1.target(), seg2.target(), k)) return squared_distance(seg1.target(), seg2.target(), k); if (!is_acute_angle(seg1.target(), seg1.source(), seg2.source(), k)) return squared_distance(seg1.source(), seg2.source(), k); } return squared_distance(seg2.source(), seg1.supporting_line(), k); } template inline typename K::RT _distance_measure_sub(typename K::RT startwdist, typename K::RT endwdist, const typename CGAL_WRAP(K)::Vector_3 &start, const typename CGAL_WRAP(K)::Vector_3 &end, const K&) { return CGAL_NTS abs(wmult((K*)0, startwdist, end.hw())) - CGAL_NTS abs(wmult((K*)0, endwdist, start.hw())); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Segment_3 &seg1, const typename CGAL_WRAP(K)::Segment_3 &seg2, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; typedef typename K::RT RT; typedef typename K::FT FT; const Point_3 &start1 = seg1.source(); const Point_3 &start2 = seg2.source(); const Point_3 &end1 = seg1.target(); const Point_3 &end2 = seg2.target(); if (start1 == end1) return squared_distance(start1, seg2, k); if (start2 == end2) return squared_distance(start2, seg1, k); Vector_3 dir1, dir2, normal; dir1 = seg1.direction().vector(); dir2 = seg2.direction().vector(); normal = wcross(dir1, dir2, k); if (is_null(normal, k)) return squared_distance_parallel(seg1, seg2, k); bool crossing1, crossing2; RT sdm_s1to2, sdm_e1to2, sdm_s2to1, sdm_e2to1; Vector_3 perpend1, perpend2, s2mins1, e2mins1, e1mins2; perpend1 = wcross(dir1, normal, k); perpend2 = wcross(dir2, normal, k); s2mins1 = construct_vector(start1, start2); e2mins1 = construct_vector(start1, end2); e1mins2 = construct_vector(start2, end1); sdm_s1to2 = -RT(wdot(perpend2, s2mins1, k)); sdm_e1to2 = wdot(perpend2, e1mins2, k); sdm_s2to1 = wdot(perpend1, s2mins1, k); sdm_e2to1 = wdot(perpend1, e2mins1, k); if (sdm_s1to2 < RT(0)) { crossing1 = (sdm_e1to2 >= RT(0)); } else { if (sdm_e1to2 <= RT(0)) { crossing1 = true; } else { crossing1 = (sdm_s1to2 == RT(0)); } } if (sdm_s2to1 < RT(0)) { crossing2 = (sdm_e2to1 >= RT(0)); } else { if (sdm_e2to1 <= RT(0)) { crossing2 = true; } else { crossing2 = (sdm_s2to1 == RT(0)); } } if (crossing1) { if (crossing2) { return squared_distance_to_plane(normal, s2mins1, k); } RT dm; dm = _distance_measure_sub( sdm_s2to1, sdm_e2to1, s2mins1, e2mins1, k); if (dm < RT(0)) { return squared_distance(start2, seg1, k); } else { if (dm > RT(0)) { return squared_distance(end2, seg1, k); } else { // should not happen with exact arithmetic. return squared_distance_parallel(seg1, seg2, k); } } } else { if (crossing2) { RT dm; dm =_distance_measure_sub( sdm_s1to2, sdm_e1to2, s2mins1, e1mins2, k); if (dm < RT(0)) { return squared_distance(start1, seg2, k); } else { if (dm > RT(0)) { return squared_distance(end1, seg2, k); } else { // should not happen with exact arithmetic. return squared_distance_parallel(seg1, seg2, k); } } } else { FT min1, min2; RT dm; dm = _distance_measure_sub( sdm_s1to2, sdm_e1to2, s2mins1, e1mins2, k); if (dm == RT(0)) // should not happen with exact arithmetic. return squared_distance_parallel(seg1, seg2, k); min1 = (dm < RT(0)) ? squared_distance(seg1.source(), seg2, k): squared_distance(end1, seg2, k); dm = _distance_measure_sub( sdm_s2to1, sdm_e2to1, s2mins1, e2mins1, k); if (dm == RT(0)) // should not happen with exact arithmetic. return squared_distance_parallel(seg1, seg2, k); min2 = (dm < RT(0)) ? squared_distance(start2, seg1, k): squared_distance(end2, seg1, k); return (min1 < min2) ? min1 : min2; } } } template typename K::FT squared_distance_parallel( const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { typedef typename K::Vector_3 Vector_3; bool same_direction; const Vector_3 &dir1 = seg.direction().vector(); const Vector_3 &dir2 = ray.direction().vector(); if (CGAL_NTS abs(dir1.hx()) > CGAL_NTS abs(dir1.hy())) { same_direction = (CGAL_NTS sign(dir1.hx()) == CGAL_NTS sign(dir2.hx())); } else { same_direction = (CGAL_NTS sign(dir1.hy()) == CGAL_NTS sign(dir2.hy())); } if (same_direction) { if (!is_acute_angle(seg.source(), seg.target(), ray.source(), k)) return squared_distance(seg.target(), ray.source(), k); } else { if (!is_acute_angle(seg.target(), seg.source(), ray.source(), k)) return squared_distance(seg.source(), ray.source(), k); } return squared_distance(ray.source(), seg.supporting_line(), k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::RT RT; typedef typename K::FT FT; const Point_3 & ss = seg.source(); const Point_3 & se = seg.target(); if (ss == se) return squared_distance(ss, ray, k); Vector_3 raydir, segdir, normal; raydir = ray.direction().vector(); segdir = seg.direction().vector(); normal = wcross(segdir, raydir, k); if (is_null(normal, k)) return squared_distance_parallel(seg, ray, k); bool crossing1, crossing2; RT sdm_ss2r, sdm_se2r, sdm_rs2s, sdm_re2s; Vector_3 perpend2seg, perpend2ray, ss_min_rs, se_min_rs; perpend2seg = wcross(segdir, normal, k); perpend2ray = wcross(raydir, normal, k); ss_min_rs = construct_vector(ray.source(), ss); se_min_rs = construct_vector(ray.source(), se); sdm_ss2r = wdot(perpend2ray, ss_min_rs, k); sdm_se2r = wdot(perpend2ray, se_min_rs, k); if (sdm_ss2r < RT(0)) { crossing1 = (sdm_se2r >= RT(0)); } else { if (sdm_se2r <= RT(0)) { crossing1 = true; } else { crossing1 = (sdm_ss2r == RT(0)); } } sdm_rs2s = -RT(wdot(perpend2seg, ss_min_rs, k)); sdm_re2s = wdot(perpend2seg, raydir, k); if (sdm_rs2s < RT(0)) { crossing2 = (sdm_re2s >= RT(0)); } else { if (sdm_re2s <= RT(0)) { crossing2 = true; } else { crossing2 = (sdm_rs2s == RT(0)); } } if (crossing1) { if (crossing2) { return squared_distance_to_plane(normal, ss_min_rs, k); } return squared_distance(ray.source(), seg, k); } else { if (crossing2) { RT dm; dm = _distance_measure_sub( sdm_ss2r, sdm_se2r, ss_min_rs, se_min_rs, k); if (dm < RT(0)) { return squared_distance(ss, ray, k); } else { if (dm > RT(0)) { return squared_distance(se, ray, k); } else { // parallel, should not happen (no crossing) return squared_distance_parallel(seg, ray, k); } } } else { FT min1, min2; RT dm; dm = _distance_measure_sub( sdm_ss2r, sdm_se2r, ss_min_rs, se_min_rs, k); if (dm == RT(0)) return squared_distance_parallel(seg, ray, k); min1 = (dm < RT(0)) ? squared_distance(ss, ray, k) : squared_distance(se, ray, k); min2 = squared_distance(ray.source(), seg, k); return (min1 < min2) ? min1 : min2; } } } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Ray_3 & ray, const typename CGAL_WRAP(K)::Segment_3 & seg, const K& k) { return squared_distance(seg, ray, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Line_3 &line, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; typedef typename K::RT RT; const Point_3 &linepoint = line.point(); const Point_3 &start = seg.source(); const Point_3 &end = seg.target(); if (start == end) return squared_distance(start, line, k); Vector_3 linedir = line.direction().vector(); Vector_3 segdir = seg.direction().vector(); Vector_3 normal = wcross(segdir, linedir, k); if (is_null(normal, k)) return squared_distance_to_line(linedir, construct_vector(linepoint,start), k); bool crossing; RT sdm_ss2l, sdm_se2l; Vector_3 perpend2line, start_min_lp, end_min_lp; perpend2line = wcross(linedir, normal, k); start_min_lp = construct_vector(linepoint, start); end_min_lp = construct_vector(linepoint, end); sdm_ss2l = wdot(perpend2line, start_min_lp, k); sdm_se2l = wdot(perpend2line, end_min_lp, k); if (sdm_ss2l < RT(0)) { crossing = (sdm_se2l >= RT(0)); } else { if (sdm_se2l <= RT(0)) { crossing = true; } else { crossing = (sdm_ss2l == RT(0)); } } if (crossing) { return squared_distance_to_plane(normal, start_min_lp, k); } else { RT dm; dm = _distance_measure_sub( sdm_ss2l, sdm_se2l, start_min_lp, end_min_lp, k); if (dm <= RT(0)) { return squared_distance_to_line(linedir, start_min_lp, k); } else { return squared_distance_to_line(linedir, end_min_lp, k); } } } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Line_3 & line, const typename CGAL_WRAP(K)::Segment_3 & seg, const K& k) { return squared_distance(seg, line, k); } template typename K::FT ray_ray_squared_distance_parallel( const typename CGAL_WRAP(K)::Vector_3 &ray1dir, const typename CGAL_WRAP(K)::Vector_3 &ray2dir, const typename CGAL_WRAP(K)::Vector_3 &s1_min_s2, const K& k) { if (!is_acute_angle(ray2dir, s1_min_s2, k)) { if (!same_direction(ray1dir, ray2dir, k)) return (typename K::FT)(s1_min_s2*s1_min_s2); } return squared_distance_to_line(ray1dir, s1_min_s2, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Ray_3 &ray1, const typename CGAL_WRAP(K)::Ray_3 &ray2, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; typedef typename K::RT RT; typedef typename K::FT FT; const Point_3 & s1 = ray1.source(); const Point_3 & s2 = ray2.source(); Vector_3 dir1, dir2, normal; dir1 = ray1.direction().vector(); dir2 = ray2.direction().vector(); normal = wcross(dir1, dir2, k); Vector_3 s1_min_s2 = construct_vector(s2, s1); if (is_null(normal, k)) return ray_ray_squared_distance_parallel(dir1, dir2, s1_min_s2, k); bool crossing1, crossing2; RT sdm_s1_2, sdm_s2_1; Vector_3 perpend1, perpend2; perpend1 = wcross(dir1, normal, k); perpend2 = wcross(dir2, normal, k); sdm_s1_2 = wdot(perpend2, s1_min_s2, k); if (sdm_s1_2 < RT(0)) { crossing1 = (RT(wdot(perpend2, dir1, k)) >= RT(0)); } else { if (RT(wdot(perpend2, dir1, k)) <= RT(0)) { crossing1 = true; } else { crossing1 = (sdm_s1_2 == RT(0)); } } sdm_s2_1 = -RT(wdot(perpend1, s1_min_s2, k)); if (sdm_s2_1 < RT(0)) { crossing2 = (RT(wdot(perpend1, dir2, k)) >= RT(0)); } else { if (RT(wdot(perpend1, dir2, k)) <= RT(0)) { crossing2 = true; } else { crossing2 = (sdm_s2_1 == RT(0)); } } if (crossing1) { if (crossing2) return squared_distance_to_plane(normal, s1_min_s2, k); return squared_distance(ray2.source(), ray1, k); } else { if (crossing2) { return squared_distance(ray1.source(), ray2, k); } else { FT min1, min2; min1 = squared_distance(ray1.source(), ray2, k); min2 = squared_distance(ray2.source(), ray1, k); return (min1 < min2) ? min1 : min2; } } } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Line_3 &line, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; typedef typename K::RT RT; const Point_3 & rs =ray.source(); Vector_3 raydir, linedir, normal; linedir = line.direction().vector(); raydir = ray.direction().vector(); normal = wcross(raydir, linedir, k); Vector_3 rs_min_lp = construct_vector(line.point(), rs); if (is_null(normal, k)) return squared_distance_to_line(linedir, rs_min_lp, k); bool crossing; RT sdm_sr_l; Vector_3 perpend2l; perpend2l = wcross(linedir, normal, k); sdm_sr_l = wdot(perpend2l, rs_min_lp, k); if (sdm_sr_l < RT(0)) { crossing = (RT(wdot(perpend2l, raydir, k)) >= RT(0)); } else { if (RT(wdot(perpend2l, raydir, k)) <= RT(0)) { crossing = true; } else { crossing = (sdm_sr_l == RT(0)); } } if (crossing) return squared_distance_to_plane(normal, rs_min_lp, k); else return squared_distance_to_line(linedir, rs_min_lp, k); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Ray_3 & ray, const typename CGAL_WRAP(K)::Line_3 & line, const K& k) { return squared_distance(line, ray, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Line_3 &line1, const typename CGAL_WRAP(K)::Line_3 &line2, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; Vector_3 dir1, dir2, normal, diff; dir1 = line1.direction().vector(); dir2 = line2.direction().vector(); normal = wcross(dir1, dir2, k); diff = construct_vector(line1.point(), line2.point()); if (is_null(normal, k)) return squared_distance_to_line(dir2, diff, k); return squared_distance_to_plane(normal, diff, k); } } // namespace CGALi template inline typename K::FT squared_distance(const Point_3 &pt, const Line_3 &line) { return CGALi::squared_distance(pt, line, K()); } template inline typename K::FT squared_distance( const Line_3 & line, const Point_3 & pt) { return CGALi::squared_distance(pt, line, K()); } template inline typename K::FT squared_distance( const Point_3 &pt, const Ray_3 &ray) { return CGALi::squared_distance(pt, ray, K()); } template inline typename K::FT squared_distance( const Ray_3 & ray, const Point_3 & pt) { return CGALi::squared_distance(pt, ray, K()); } template inline typename K::FT squared_distance( const Point_3 &pt, const Segment_3 &seg) { return CGALi::squared_distance(pt, seg, K()); } template inline typename K::FT squared_distance( const Segment_3 & seg, const Point_3 & pt) { return CGALi::squared_distance(pt, seg, K()); } template inline typename K::FT squared_distance_parallel( const Segment_3 &seg1, const Segment_3 &seg2) { return CGALi::squared_distance_parallel(seg1, seg2, K()); } template inline typename K::FT squared_distance(const Segment_3 &seg1, const Segment_3 &seg2) { return CGALi::squared_distance(seg1, seg2, K()); } template inline typename K::FT squared_distance_parallel( const Segment_3 &seg, const Ray_3 &ray) { return CGALi::squared_distance_parallel(ray,seg, K()); } template inline typename K::FT squared_distance( const Segment_3 &seg, const Ray_3 &ray) { return CGALi::squared_distance(ray, seg, K()); } template inline typename K::FT squared_distance( const Ray_3 & ray, const Segment_3 & seg) { return squared_distance(seg, ray, K()); } template inline typename K::FT squared_distance( const Segment_3 &seg, const Line_3 &line) { return CGALi::squared_distance(seg, line, K()); } template inline typename K::FT squared_distance( const Line_3 & line, const Segment_3 & seg) { return CGALi::squared_distance(seg, line, K()); } template inline typename K::FT ray_ray_squared_distance_parallel( const Vector_3 &ray1dir, const Vector_3 &ray2dir, const Vector_3 &s1_min_s2) { return CGALi::ray_ray_squared_distance_parallel(ray1dir, ray2dir, s1_min_s2, K()); } template inline typename K::FT squared_distance( const Ray_3 &ray1, const Ray_3 &ray2) { return CGALi::squared_distance(ray1, ray2, K()); } template inline typename K::FT squared_distance( const Line_3 &line, const Ray_3 &ray) { return CGALi::squared_distance(line, ray, K()); } template inline typename K::FT squared_distance( const Ray_3 & ray, const Line_3 & line) { return CGALi::squared_distance(line, ray, K()); } template inline typename K::FT squared_distance( const Line_3 &line1, const Line_3 &line2) { return CGALi::squared_distance(line1, line2, K()); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_hierarchy_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000000461511344301501031376 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_hierarchy_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_HIERARCHY_VERTEX_BASE_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_HIERARCHY_VERTEX_BASE_2_H #include CGAL_BEGIN_NAMESPACE template class Segment_Voronoi_diagram_hierarchy_vertex_base_2 : public Vbb { public: typedef Vbb V_Base; typedef typename V_Base::Data_structure DS; typedef typename V_Base::Site_2 Site_2; typedef typename V_Base::Storage_site_2 Storage_site_2; typedef DS Data_structure; typedef typename DS::Vertex_handle Vertex_handle; typedef typename DS::Face_handle Face_handle; template < typename DS2 > struct Rebind_TDS { typedef typename Vbb::template Rebind_TDS::Other Vb2; typedef Segment_Voronoi_diagram_hierarchy_vertex_base_2 Other; }; Segment_Voronoi_diagram_hierarchy_vertex_base_2() : V_Base(), up_( Vertex_handle() ), down_( Vertex_handle() ) {} Segment_Voronoi_diagram_hierarchy_vertex_base_2(const Storage_site_2& ss, Face_handle f) : V_Base(ss,f), up_( Vertex_handle() ), down_( Vertex_handle() ) {} public: // for use in hierarchy only Vertex_handle up() { return up_; } Vertex_handle down() { return down_; } void set_up(Vertex_handle u) { up_ = u; } void set_down(Vertex_handle d) { down_ = d; } private: Vertex_handle up_; // same vertex one level above Vertex_handle down_; // same vertex one level below }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_HIERARCHY_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/more_functions_on_signs.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/more_functions_on_sign0000644000175000017500000000325711344301500031520 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/more_functions_on_signs.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_MORE_FUNCTIONS_ON_SIGNS_H #define CGAL_MORE_FUNCTIONS_ON_SIGNS_H #include CGAL_BEGIN_NAMESPACE inline Sign sign_of_first_root(const Sign &sb, const Sign &sc) { // this method computes the sign of the second root of the quadratic // equation: a x^2 - b x + c == 0. It is assumed that the sign of a // is +1. if ( sc == NEGATIVE ) return NEGATIVE; if ( sb == POSITIVE ) return sc; if ( sb == NEGATIVE ) return NEGATIVE; return opposite(sc); } inline Sign sign_of_second_root(const Sign &sb, const Sign &sc) { // this method computes the sign of the first root of the quadratic // equation: a x^2 - b x + c == 0. It is assumed that the sign of a // is +1. if ( sc == NEGATIVE ) return POSITIVE; if ( sb == POSITIVE ) return POSITIVE; if ( sb == NEGATIVE ) return opposite(sc); return sc; } CGAL_END_NAMESPACE #endif // CGAL_MORE_FUNCTIONS_ON_SIGNS_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_local_size_criteria_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_local_si0000644000175000017500000000675411344301500031402 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_local_size_criteria_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DELAUNAY_MESH_LOCAL_SIZE_CRITERIA_2_H #define CGAL_DELAUNAY_MESH_LOCAL_SIZE_CRITERIA_2_H #include namespace CGAL { template class Delaunay_mesh_local_size_criteria_2 : public Delaunay_mesh_size_criteria_2 { public: typedef Delaunay_mesh_size_criteria_2 Base; typedef typename Base::Base PreviousBase; typedef typename CDT::Geom_traits Geom_traits; typedef typename Geom_traits::FT FT; typedef typename Geom_traits::Point_2 Point; typedef typename CDT::Face_handle Face_handle; private: bool local; Point _p; public: Delaunay_mesh_local_size_criteria_2(const double aspect_bound = 0.125, const double size_bound = 0, const bool is_local_size = false, const Point p = Point()) : Base(aspect_bound, size_bound), local(is_local_size), _p(p) {}; inline Point point() const { return _p; }; inline void set_point(const Point p) { _p = p; }; inline bool is_local_size() const { return local; }; inline void set_local_size(bool local_size) { local = local_size; }; class Is_bad: public Base::Is_bad { public: typedef typename Base::Is_bad Baseclass; typedef typename Baseclass::Point_2 Point_2; typedef typename Base::Base PreviousBase; typedef typename PreviousBase::Is_bad PreviousBaseclass; typedef Geom_traits Traits; typedef typename Base::Quality Quality; private: const bool local; const Point_2 p; public: Is_bad(const double aspect_bound, const double size_bound, const bool l, const Point_2 _p) : Base::Is_bad(aspect_bound, size_bound), local(l), p(_p) {}; Mesh_2::Face_badness operator()(Quality q) const { return Base::Is_bad::operator()(q); } Mesh_2::Face_badness operator()(const Face_handle& fh, Quality& q) const { if(!local) return Baseclass::operator()(fh,q); else { typename Geom_traits::Orientation_2 orient = Geom_traits().orientation_2_object(); Mesh_2::Face_badness is_non_locally_bad = Baseclass::operator()(fh,q); const Point_2& a = fh->vertex(0)->point(); const Point_2& b = fh->vertex(1)->point(); const Point_2& c = fh->vertex(2)->point(); Orientation o1 = orient(a,b,p), o2 = orient(b,c,p), o3 = orient(c,a,p); if((o1==o2) && (o2==o3)) return is_non_locally_bad; else if( q.sine() < this->B ) return Mesh_2::BAD; else return Mesh_2::NOT_BAD; }; } }; Is_bad is_bad_object() const { return Is_bad(this->bound(), this->size_bound(), local, point()); }; }; }; //end namespace #endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_short_names_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_short_na0000644000175000017500000000470511344301501031467 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_short_names_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_SHORT_NAMES_2_H #define CGAL_TRIANGULATION_SHORT_NAMES_2_H //Define shorter names to please linker (g++/egcs) #define Triangulation_data_structure_2 Tds2 #define Triangulation_vertex_base_2 Tvb #define Triangulation_face_base_2 Tfb #define Triangulation_euclidean_traits_2 Et2 #define Triangulation_euclidean_traits_xy_3 Etxy3 #define Triangulation_euclidean_traits_xz_3 Etxz3 #define Triangulation_euclidean_traits_yz_3 Etyz3 #define Triangulation_ds_vertex_2 Tdsv #define Triangulation_ds_face_2 Tdsf #define Triangulation_ds_face_base_2 Tdsfb #define Triangulation_ds_vertex_base_2 Tdsvb #define Triangulation_vertex_2 Tv #define Triangulation_face_2 Tf #define Triangulation_vertex_handle_2 Tvh #define Triangulation_face_handle_2 Tfh #define Triangulation_vertex_iterator_2 Tvi #define Triangulation_face_iterator_2 Tfi #define Triangulation_edge_iterator_2 Tei #define Triangulation_all_faces_iterator_2 Tafi #define Triangulation_all_edges_iterator_2 Taei #define Triangulation_all_vertices_iterator_2 Tavi #define Triangulation_finite_faces_iterator_2 Tffi #define Triangulation_finite_edges_iterator_2 Tfei #define Triangulation_finite_vertices_iterator_2 Tfvi #define Triangulation_vertex_circulator_2 Tvc #define Triangulation_face_circulator_2 Tfc #define Triangulation_edge_circulator_2 Tec #define Constrained_triangulation_face_base_2 Ctfb #define Regular_triangulation_euclidean_traits_2 Rtet2 #define Regular_triangulation_face_base_2 Rtfb #define Regular_triangulation_vertex_base_2 Rtvb #endif //CGAL_TRIANGULATION_SHORT_NAMES_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_site_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000002234511344301501031376 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_site_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef SEGMENT_VORONOI_DIAGRAM_SITE_H #define SEGMENT_VORONOI_DIAGRAM_SITE_H #include #include #include #include CGAL_BEGIN_NAMESPACE /** A Site is either a point or a segment or a point defined as the intersection of two non-parallel segments (if defined) */ template class Segment_Voronoi_diagram_site_2 { public: typedef Gt Geom_traits; typedef typename Geom_traits::Point_2 Point_2; typedef typename Geom_traits::Segment_2 Segment_2; protected: typedef typename Geom_traits::FT FT; typedef typename Geom_traits::RT RT; typedef Segment_Voronoi_diagram_site_2 Self; public: Segment_Voronoi_diagram_site_2() : type_(0) {} static Self construct_site_2(const Point_2& p) { Self t; t.initialize_site(p); return t; } // constructs segment site using the segment (p1,p2) static Self construct_site_2(const Point_2& p1, const Point_2& p2) { Self t; t.initialize_site(p1, p2); return t; } // constructs point site using the point of intersection of the // segments (p1,p2) and (q1,q2) static Self construct_site_2(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2) { Self t; t.initialize_site(p1, p2, q1, q2); return t; } // constructs segment site using the points of intersection of the // segment-pairs (p1,p2)-(q1,q2) and (p1,p2)-(q3,q4) as endpoints; // the segment (p1,p2) is a segment that supports the actual segment static Self construct_site_2(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2, const Point_2& r1, const Point_2& r2) { Self t; t.initialize_site(p1, p2, q1, q2, r1, r2); return t; } // constructs segment site using either the source or the target of // (p1,p2) (that depends on the boolean is_first_exact) and the // intersection of (p1,p2) with (q1,q2) as the other endpoint static Self construct_site_2(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2, bool is_first_exact) { Self t; t.initialize_site(p1, p2, q1, q2, is_first_exact); return t; } public: bool is_defined() const { return type_; } bool is_point() const { return (type_ & 3) == 1; } bool is_segment() const { return (type_ & 3) == 2; } bool is_input() const { return !(type_ & 12); } bool is_input(unsigned int i) const { CGAL_precondition( is_segment() && i < 2 ); if ( i == 0 ) { return !(type_ & 4); } return !(type_ & 8); } const Point_2& source_of_supporting_site() const { CGAL_precondition( is_segment() ); return p_[0]; } const Point_2& target_of_supporting_site() const { CGAL_precondition( is_segment() ); return p_[1]; } const Point_2& source_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return (i == 0) ? p_[2] : p_[4]; } const Point_2& target_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return (i == 0) ? p_[3] : p_[5]; } const Point_2& source_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return (i == 0) ? p_[2] : p_[4]; } const Point_2& target_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return (i == 0) ? p_[3] : p_[5]; } Point_2 point() const { CGAL_precondition ( is_point() ); if ( !is_input() ) { return compute_intersection_point(p_[2], p_[3], p_[4], p_[5]); } else { return p_[0]; } } Segment_2 segment() const { CGAL_precondition ( is_segment() ); return Segment_2( source(), target() ); } Point_2 source() const { CGAL_precondition ( is_segment() ); return compute_source(); } Point_2 target() const { CGAL_precondition ( is_segment() ); return compute_target(); } Self supporting_site() const { CGAL_precondition( is_segment() ); return construct_site_2(p_[0], p_[1]); } Self supporting_site(unsigned int i) const { CGAL_precondition( is_point() && i < 2); CGAL_precondition( !is_input() ); if ( i == 0 ) { return construct_site_2(p_[2], p_[3]); } return construct_site_2(p_[4], p_[5]); } Self crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input() ); CGAL_precondition( i < 2 && !is_input(i) ); if ( i == 0 ) { return construct_site_2(p_[2], p_[3]); } else { return construct_site_2(p_[4], p_[5]); } } Self source_site() const { CGAL_precondition( is_segment() ); if ( is_input() || is_input(0) ) { return construct_site_2(p_[0]); } else { return construct_site_2(p_[0], p_[1], p_[2], p_[3]); } } Self target_site() const { CGAL_precondition( is_segment() ); if ( is_input() || is_input(1) ) { return construct_site_2(p_[1]); } else { return construct_site_2(p_[0], p_[1], p_[4], p_[5]); } } protected: void initialize_site(const Point_2& p) { type_ = 1; p_[0] = p; } void initialize_site(const Point_2& p1, const Point_2& p2) { type_ = 2; p_[0] = p1; p_[1] = p2; } void initialize_site(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2) { // MK: Sort the segments s1 and s2 in lexicographical order so // that the computation of the intersection point is always // done in the same manner (?) type_ = 5; p_[2] = p1; p_[3] = p2; p_[4] = q1; p_[5] = q2; } void initialize_site(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2, const Point_2& r1, const Point_2& r2) { type_ = 14; p_[0] = p1; p_[1] = p2; p_[2] = q1; p_[3] = q2; p_[4] = r1; p_[5] = r2; } void initialize_site(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2, bool is_first_exact) { type_ = (is_first_exact ? 10 : 6); p_[0] = p1; p_[1] = p2; if ( is_first_exact ) { p_[4] = q1; p_[5] = q2; } else { p_[2] = q1; p_[3] = q2; } } Point_2 compute_source() const { CGAL_precondition( is_segment() ); if ( is_input() || is_input(0) ) { return p_[0]; } else { return compute_intersection_point(p_[0], p_[1], p_[2], p_[3]); } } Point_2 compute_target() const { CGAL_precondition( is_segment() ); if ( is_input() || is_input(1) ) { return p_[1]; } else { return compute_intersection_point(p_[0], p_[1], p_[4], p_[5]); } } // computes the point of intersection of the segments p1p2 and p3p4 static Point_2 compute_intersection_point(const Point_2& p1, const Point_2& p2, const Point_2& p3, const Point_2& p4) { RT x1 = p1.x(), y1 = p1.y(); RT x2 = p2.x(), y2 = p2.y(); RT x3 = p3.x(), y3 = p3.y(); RT x4 = p4.x(), y4 = p4.y(); RT D = det2x2_by_formula(x2 - x1, x4 - x3, y2 - y1, y4 - y3); RT Dt = det2x2_by_formula(x3 - x1, x4 - x3, y3 - y1, y4 - y3); RT t = Dt / D; return Point_2(x1 + (x2 - x1) * t, y1 + (y2 - y1) * t); } protected: Point_2 p_[6]; char type_; }; //------------------------------------------------------------------------- template std::ostream& operator<<(std::ostream& os, const Segment_Voronoi_diagram_site_2& s) { if (!s.is_defined()) return os << "u"; if (s.is_point()) return os << "p " << s.point (); return os << "s " << s.segment (); } template std::istream & operator>>(std::istream &is, Segment_Voronoi_diagram_site_2& t) { typedef Segment_Voronoi_diagram_site_2 Site_2; typedef typename Site_2::Point_2 Point_2; char type; if (is >> type) { if (type == 'p') { Point_2 p; is >> p; t = Site_2::construct_site_2(p); } else if (type == 's') { Point_2 p1, p2; is >> p1 >> p2; t = Site_2::construct_site_2(p1, p2); } } return is; } template < class R, class Stream > Stream& operator<<(Stream& str, Segment_Voronoi_diagram_site_2& t) { if ( t.is_defined() ) { if ( t.is_point() ) { str << "p " << t.point(); } else { str << "s " << t.segment().source() << " " << t.segment().target(); } } return str; } CGAL_END_NAMESPACE #endif // SEGMENT_VORONOI_DIAGRAM_SITE_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/aff_transformation_tags.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/aff_transformation_tag0000644000175000017500000000315611344301500031465 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/aff_transformation_tags.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_AFF_TRANSFORMATION_TAGS_H #define CGAL_AFF_TRANSFORMATION_TAGS_H #include CGAL_BEGIN_NAMESPACE class Translation {}; class Rotation {}; class Scaling {}; class Reflection {}; class Identity_transformation {}; extern Translation TRANSLATION; extern Rotation ROTATION; extern Scaling SCALING; extern Reflection REFLECTION; extern Identity_transformation IDENTITY; CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATION_TAGS_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_area_criteria_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_area_cri0000644000175000017500000000762711344301500031362 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_area_criteria_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DELAUNAY_MESH_AREA_CRITERIA_2_H #define CGAL_DELAUNAY_MESH_AREA_CRITERIA_2_H #include namespace CGAL { template class Delaunay_mesh_area_criteria_2 : public virtual Delaunay_mesh_criteria_2, private Delaunay_mesh_size_criteria_2 /* This class "is a" Delaunay_mesh_criteria_2 and is implemented by Delaunay_mesh_size_criteria_2. Delaunay_mesh_criteria_2 is a virtual base class of Delaunay_mesh_size_criteria_2. */ { public: typedef Delaunay_mesh_criteria_2 Base; typedef Delaunay_mesh_size_criteria_2 Private_base; typedef typename Delaunay_mesh_size_criteria_2::Quality Quality; Delaunay_mesh_area_criteria_2(const double aspect_bound = 0.125, const double area_bound = 0) : Private_base(aspect_bound, area_bound) {}; inline double area_bound() const { return this->sizebound; }; inline void set_area_bound(const double ab) { this->sizebound = ab; }; class Is_bad: public Private_base::Is_bad { public: typedef typename Private_base::Is_bad Is_bad_base; typedef typename Tr::Point Point_2; typedef typename Tr::Triangle Triangle_2; typedef typename Tr::Face_handle Face_handle; Is_bad(const double aspect_bound, const double area_bound) : Is_bad_base(aspect_bound, area_bound) {}; Mesh_2::Face_badness operator()(Quality q) { return Is_bad_base::operator()(q); } Mesh_2::Face_badness operator()(const Face_handle& fh, Quality& q) const { typedef typename Tr::Geom_traits Geom_traits; typedef typename Geom_traits::Point_2 Point_2; typedef typename Geom_traits::Triangle_2 Triangle_2; typedef typename Geom_traits::Compute_area_2 Compute_area_2; typedef typename Geom_traits::Compute_squared_distance_2 Compute_squared_distance_2; typedef typename Geom_traits::FT FT; Geom_traits geom_traits; Compute_area_2 area_2 = geom_traits.compute_area_2_object(); Compute_squared_distance_2 squared_distance = geom_traits.compute_squared_distance_2_object(); const Point_2& pa = fh->vertex(0)->point(); const Point_2& pb = fh->vertex(1)->point(); const Point_2& pc = fh->vertex(2)->point(); Triangle_2 t = geom_traits.construct_triangle_2_object()(pa,pb,pc); double area = CGAL::to_double(area_2(t)); area=area*area; // squared area double a = CGAL::to_double(squared_distance(pb, pc)), b = CGAL::to_double(squared_distance(pc, pa)), c = CGAL::to_double(squared_distance(pa, pb)); double min_sine; // squared minimum sine if(asquared_size_bound != 0 && area > this->squared_size_bound ) return Mesh_2::IMPERATIVELY_BAD; else if( min_sine < this->B ) return Mesh_2::BAD; else return Mesh_2::NOT_BAD; }; }; // end class Is_bad Is_bad is_bad_object() const { return Is_bad(this->bound(), area_bound()); } }; } //end namespace #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interval_skip_list.h0000644000175000017500000011301211344301500031034 0ustar debiandebian// Copyright (c) 2003 GeometryFactory // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Interval_skip_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_INTERVAL_SKIP_LIST_H #define CGAL_INTERVAL_SKIP_LIST_H #include #include #include #include #include //#define CGAL_ISL_USE_CCC #define CGAL_ISL_USE_LIST #if defined(CGAL_ISL_USE_CCC) || ! defined(CGAL_ISL_USE_LIST) #include #endif namespace CGAL { class Interval; template class IntervalList; template class Interval_skip_list; template class IntervalListElt; template class IntervalSLnode; const int MAX_FORWARD = 48; // Maximum number of forward pointers template class IntervalSLnode // interval skip list node { typedef Interval_ Interval; typedef typename Interval::Value Value; bool is_header; typedef Interval* Interval_handle; Value key; IntervalSLnode** forward; // array of forward pointers IntervalList** markers; // array of interval markers, // one for each pointer IntervalList* eqMarkers; // markers for node itself int ownerCount; // number of interval end points with value equal to key int topLevel; // index of top level of forward pointers in this node. // Levels are numbered 0..topLevel. public: friend class Interval_skip_list; IntervalSLnode(const Value& searchKey, int levels); // constructor IntervalSLnode(int levels); // constructor for the header IntervalSLnode* get_next(); void print(std::ostream& os) const; const Value& getValue() { return key; } // number of levels of this node int level() const { return(topLevel+1); } bool isHeader() const { return is_header; } void deleteMarks(IntervalList* l); ~IntervalSLnode(); // destructor }; template class Interval_for_container : public Interval_ { private: void * p; public: Interval_for_container(const Interval_& i) : Interval_(i), p(NULL) {} void * for_compact_container() const { return p; } void * & for_compact_container() { return p; } }; template class Interval_skip_list { private: typedef Interval_ Interval; typedef typename Interval::Value Value; Random rand; #ifdef CGAL_ISL_USE_LIST std::list container; typedef typename std::list::iterator Interval_handle; #else Compact_container > container; typedef typename Compact_container >::iterator Interval_handle; #endif #ifdef CGAL_ISL_USE_CCC typedef typename Compact_container >::iterator ILE_handle; #else typedef IntervalListElt* ILE_handle; #endif int maxLevel; IntervalSLnode* header; int randomLevel(); // choose a new node level at random // place markers for Interval I. I must have been inserted in the list. // left is the left endpoint of I and right is the right endpoint if I. // *** needs to be fixed: void placeMarkers(IntervalSLnode* left, IntervalSLnode* right, const Interval_handle& I); // remove markers for Interval I void removeMarkers(const Interval_handle& I); // adjust markers after insertion of x with update vector "update" void adjustMarkersOnInsert(IntervalSLnode* x, IntervalSLnode** update); // adjust markers to prepare for deletion of x, which has update vector // "update" void adjustMarkersOnDelete(IntervalSLnode* x, IntervalSLnode** update); // remove node x, which has updated vector update. void remove(IntervalSLnode* x, IntervalSLnode** update); // remove markers for Interval I starting at left, the left endpoint // of I, and and stopping at the right endpoint of I. Interval_handle removeMarkers(IntervalSLnode* left, const Interval& I); // Remove markers for interval m from the edges and nodes on the // level i path from l to r. void removeMarkFromLevel(const Interval& m, int i, IntervalSLnode *l, IntervalSLnode* r); // Search for search key, and return a pointer to the // intervalSLnode x found, as well as setting the update vector // showing pointers into x. IntervalSLnode* search(const Value& searchKey, IntervalSLnode** update); // insert a new single value // into list, returning a pointer to its location. IntervalSLnode* insert(const Value& searchKey); // insert an interval into list void insert(const Interval_handle& I); public: friend class IntervalSLnode; Interval_skip_list(); template Interval_skip_list(InputIterator b, InputIterator e) { for(; b!= e; ++b){ insert(*b); } } ~Interval_skip_list(); void clear(); int size() const { return container.size(); } // return node containing // Value if found, otherwise null IntervalSLnode* search(const Value& searchKey); template OutputIterator find_intervals(const Value& searchKey, OutputIterator out ) { IntervalSLnode* x = header; for(int i=maxLevel; i >= 0 && (x->isHeader() || (x->key != searchKey)); i--) { while (x->forward[i] != 0 && (searchKey >= x->forward[i]->key)) { x = x->forward[i]; } // Pick up markers on edge as you drop down a level, unless you are at // the searchKey node already, in which case you pick up the // eqMarkers just prior to exiting loop. if(!x->isHeader() && (x->key != searchKey)) { out = x->markers[i]->copy(out); } else if (!x->isHeader()) { // we're at searchKey out = x->eqMarkers->copy(out); } } return out; } bool is_contained(const Value& searchKey) const { IntervalSLnode* x = header; for(int i=maxLevel; i >= 0 && (x->isHeader() || (x->key != searchKey)); i--) { while (x->forward[i] != 0 && (searchKey >= x->forward[i]->key)) { x = x->forward[i]; } // Pick up markers on edge as you drop down a level, unless you are at // the searchKey node already, in which case you pick up the // eqMarkers just prior to exiting loop. if(!x->isHeader() && (x->key != searchKey)) { return true; } else if (!x->isHeader()) { // we're at searchKey return true; } } return false; } void insert(const Interval& I); template int insert(InputIterator b, InputIterator e) { int i = 0; for(; b!= e; ++b){ insert(*b); ++i; } return i; } bool remove(const Interval& I); // delete an interval from list void print(std::ostream& os) const; void printOrdered(std::ostream& os) const; #ifdef CGAL_ISL_USE_LIST typedef typename std::list::const_iterator const_iterator; #else typedef typename Compact_container >::const_iterator const_iterator; #endif const_iterator begin() const { return container.begin(); } const_iterator end() const { return container.end(); } }; template class IntervalList { typedef Interval_ Interval; typedef typename Interval::Value Value; //typedef Interval* Interval_handle; #ifdef CGAL_ISL_USE_LIST typedef typename std::list::iterator Interval_handle; #else typedef typename Compact_container >::iterator Interval_handle; #endif #ifdef CGAL_ISL_USE_CCC typedef typename Compact_container >::iterator ILE_handle; #else typedef IntervalListElt* ILE_handle; #endif ILE_handle header; #ifdef CGAL_ISL_USE_CCC static Compact_container > compact_container; #endif std::allocator > alloc; public: friend class IntervalListElt; IntervalList(); void insert(const Interval_handle& I); bool remove(const Interval& I, Interval_handle& res); void remove(const Interval& I); void removeAll(IntervalList* l); ILE_handle create_list_element(const Interval_handle& I) { #ifdef CGAL_ISL_USE_CCC IntervalListElt e(I); ILE_handle it = compact_container.insert(e); return it; #else IntervalListElt *elt_ptr = alloc.allocate(1); alloc.construct(elt_ptr, I); return elt_ptr; //return new IntervalListElt(I); #endif } void erase_list_element(ILE_handle I) { #ifdef CGAL_ISL_USE_CCC compact_container.erase(I); #else alloc.destroy(I); alloc.deallocate(I,1); //delete I; #endif } ILE_handle get_first(); ILE_handle get_next(ILE_handle element); void copy(IntervalList* from); // add contents of "from" to self template OutputIterator copy(OutputIterator out) const { ILE_handle e = header; while(e!= NULL) { out = *(e->I); ++out; e = e->next; } return out; } bool contains(const Interval_handle& I) const; void clear(); // delete elements of self to make self an empty list. void print(std::ostream& os) const; ~IntervalList(); }; #ifdef CGAL_ISL_USE_CCC template Compact_container > IntervalList::compact_container; #endif template class IntervalListElt { typedef Interval_ Interval; #ifdef CGAL_ISL_USE_LIST typedef typename std::list::iterator Interval_handle; #else typedef typename Compact_container >::iterator Interval_handle; #endif #ifdef CGAL_ISL_USE_CCC typedef typename Compact_container >::iterator ILE_handle; #else typedef IntervalListElt* ILE_handle; #endif Interval_handle I; ILE_handle next; #ifdef CGAL_ISL_USE_CCC void* p; #endif public: #ifdef CGAL_ISL_USE_CCC void * for_compact_container() const { return p; } void * & for_compact_container() { return p; } #endif bool operator==(const IntervalListElt& e) { return ( ((*I) == (*(e.I))) && (next == e.next)); } friend class IntervalList; IntervalListElt(); IntervalListElt(const Interval_handle& anInterval); ~IntervalListElt(); void set_next(ILE_handle nextElt) { next = nextElt; } ILE_handle get_next() { return next; } Interval_handle getInterval() { return I; } void print(std::ostream& os) const; }; template IntervalSLnode::IntervalSLnode(const Value& searchKey, int levels) : is_header(false) { // levels is actually one less than the real number of levels key = searchKey; topLevel = levels; forward = new IntervalSLnode*[levels+1]; markers = new IntervalList*[levels+1]; eqMarkers = new IntervalList(); ownerCount = 0; for(int i=0; i<=levels; i++) { forward[i] = 0; // initialize an empty interval list markers[i] = new IntervalList(); } } template IntervalSLnode::IntervalSLnode(int levels) : is_header(true) { // levels is actually one less than the real number of levels topLevel = levels; forward = new IntervalSLnode*[levels+1]; markers = new IntervalList*[levels+1]; eqMarkers = new IntervalList(); ownerCount = 0; for(int i=0; i<=levels; i++) { forward[i] = 0; // initialize an empty interval list markers[i] = new IntervalList(); } } template Interval_skip_list::Interval_skip_list() { maxLevel = 0; header = new IntervalSLnode(MAX_FORWARD); for (int i = 0; i< MAX_FORWARD; i++) { header->forward[i] = 0; } } template Interval_skip_list::~Interval_skip_list() { while(header != 0){ IntervalSLnode* next = header->get_next(); delete header; header = next; } } template void Interval_skip_list::clear() { while(header != 0){ IntervalSLnode* next = header->get_next(); delete header; header = next; } header = new IntervalSLnode(MAX_FORWARD); maxLevel = 0; } template IntervalSLnode* IntervalSLnode::get_next() { return(forward[0]); } template void Interval_skip_list::print(std::ostream& os) const { os << "\nAn Interval_skip_list: \n"; os << "|container| == " << container.size() << std::endl; IntervalSLnode* n = header->get_next(); while( n != 0 ) { n->print(os); n = n->get_next(); } } template std::ostream& operator<<(std::ostream& os, const Interval_skip_list& isl) { isl.print(os); return os; } template void Interval_skip_list::printOrdered(std::ostream& os) const { IntervalSLnode* n = header->get_next(); os << "values in list: "; while( n != 0 ) { os << n->key << " "; n = n->get_next(); } os << std::endl; } template void IntervalList::copy(IntervalList* from) { ILE_handle e = from->header; while(e!=NULL) { insert(e->I); e = e->next; } } template void IntervalList::clear() { ILE_handle x = header; ILE_handle y; while(x!= NULL) { // was 0 y = x; x = x->next; erase_list_element(y); } header=0; } template IntervalSLnode* Interval_skip_list::insert(const Value& searchKey) { // array for maintaining update pointers IntervalSLnode* update[MAX_FORWARD]; IntervalSLnode* x; int i; // Find location of searchKey, building update vector indicating // pointers to change on insertion. x = search(searchKey,update); if(x==0 || (x->key != searchKey)) { // put a new node in the list for this searchKey int newLevel = randomLevel(); if (newLevel > maxLevel){ for(i=maxLevel+1; i<=newLevel; i++){ update[i] = header; header->markers[i]->clear(); } maxLevel = newLevel; } x = new IntervalSLnode(searchKey, newLevel); // add x to the list for(i=0; i<=newLevel; i++) { x->forward[i] = update[i]->forward[i]; update[i]->forward[i] = x; } // adjust markers to maintain marker invariant this->adjustMarkersOnInsert(x,update); } // else, the searchKey is in the list already, and x points to it. return(x); } // Adjust markers on this IS-list to maintain marker invariant now that // node x has just been inserted, with update vector `update.' template void Interval_skip_list::adjustMarkersOnInsert (IntervalSLnode* x, IntervalSLnode** update) { // Phase 1: place markers on edges leading out of x as needed. // Starting at bottom level, place markers on outgoing level i edge of x. // If a marker has to be promoted from level i to i+1 of higher, place it // in the promoted set at each step. IntervalList promoted; // list of intervals that identify markers being // promoted, initially empty. IntervalList newPromoted; // temporary set to hold newly promoted markers. IntervalList removePromoted; // holding place for elements to be removed from promoted list. IntervalList tempMarkList; // temporary mark list ILE_handle m; int i; for(i=0; (i<= x->level() - 2) && x->forward[i+1]!=0; i++) { IntervalList* markList = update[i]->markers[i]; for(m = markList->get_first(); m != NULL ; m = markList->get_next(m)) { if(m->getInterval()->contains_interval(x->key,x->forward[i+1]->key)) { // promote m // remove m from level i path from x->forward[i] to x->forward[i+1] removeMarkFromLevel(*m->getInterval(), i, x->forward[i], x->forward[i+1]); // add m to newPromoted newPromoted.insert(m->getInterval()); } else { // place m on the level i edge out of x x->markers[i]->insert(m->getInterval()); // do *not* place m on x->forward[i]; it must already be there. } } for(m = promoted.get_first(); m != NULL; m = promoted.get_next(m)) { if(!m->getInterval()->contains_interval(x->key, x->forward[i+1]->key)){ // Then m does not need to be promoted higher. // Place m on the level i edge out of x and remove m from promoted. x->markers[i]->insert(m->getInterval()); // mark x->forward[i] if needed if(m->getInterval()->contains(x->forward[i]->key)) x->forward[i]->eqMarkers->insert(m->getInterval()); removePromoted.insert(m->getInterval()); } else { // continue to promote m // Remove m from the level i path from x->forward[i] // to x->forward[i+1]. removeMarkFromLevel(*(m->getInterval()), i, x->forward[i], x->forward[i+1]); } } promoted.removeAll(&removePromoted); removePromoted.clear(); promoted.copy(&newPromoted); newPromoted.clear(); } // Combine the promoted set and updated[i]->markers[i] // and install them as the set of markers on the top edge out of x // that is non-null. x->markers[i]->copy(&promoted); x->markers[i]->copy(update[i]->markers[i]); for(m=promoted.get_first(); m!=NULL; m=promoted.get_next(m)) if(m->getInterval()->contains(x->forward[i]->key)) x->forward[i]->eqMarkers->insert(m->getInterval()); // Phase 2: place markers on edges leading into x as needed. // Markers on edges leading into x may need to be promoted as high as // the top edge coming into x, but never higher. promoted.clear(); for (i=0; (i <= x->level() - 2) && !update[i+1]->isHeader(); i++) { tempMarkList.copy(update[i]->markers[i]); for(m = tempMarkList.get_first(); m != NULL; m = tempMarkList.get_next(m)){ if(m->getInterval()->contains_interval(update[i+1]->key,x->key)) { // m needs to be promoted // add m to newPromoted newPromoted.insert(m->getInterval()); // Remove m from the path of level i edges between updated[i+1] // and x (it will be on all those edges or else the invariant // would have previously been violated. removeMarkFromLevel(*(m->getInterval()),i,update[i+1],x); } } tempMarkList.clear(); // reclaim storage for(m = promoted.get_first(); m != NULL; m = promoted.get_next(m)) { if (!update[i]->isHeader() && m->getInterval()->contains_interval(update[i]->key,x->key) && !update[i+1]->isHeader() && ! m->getInterval()->contains_interval(update[i+1]->key,x->key) ) { // Place m on the level i edge between update[i] and x, and // remove m from promoted. update[i]->markers[i]->insert(m->getInterval()); // mark update[i] if needed if(m->getInterval()->contains(update[i]->key)) update[i]->eqMarkers->insert(m->getInterval()); removePromoted.insert(m->getInterval()); } else { // Strip m from the level i path from update[i+1] to x. removeMarkFromLevel(*(m->getInterval()),i,update[i+1],x); } } // remove non-promoted marks from promoted promoted.removeAll(&removePromoted); removePromoted.clear(); // reclaim storage // add newPromoted to promoted and make newPromoted empty promoted.copy(&newPromoted); newPromoted.clear(); } /* Assertion: i=x->level()-1 OR update[i+1] is the header. If i=x->level()-1 then either x has only one level, or the top-level pointer into x must not be from the header, since otherwise we would have stopped on the previous iteration. If x has 1 level, then promoted is empty. If x has 2 or more levels, and i!=x->level()-1, then the edge on the next level up (level i+1) is from the header. In any of these cases, all markers in the promoted set should be deposited on the current level i edge into x. An edge out of the header should never be marked. Note that in the case where x has only 1 level, we try to copy the contents of the promoted set onto the marker set of the edge out of the header into x at level i=0, but of course, the promoted set will be empty in this case, so no markers will be placed on the edge. */ update[i]->markers[i]->copy(&promoted); for(m=promoted.get_first(); m!=NULL; m=promoted.get_next(m)) if(m->getInterval()->contains(update[i]->key)) update[i]->eqMarkers->insert(m->getInterval()); // Place markers on x for all intervals the cross x. // (Since x is a new node, every marker comming into x must also leave x). for(i=0; ilevel(); i++) x->eqMarkers->copy(x->markers[i]); promoted.clear(); // reclaim storage } // end adjustMarkersOnInsert template void Interval_skip_list::adjustMarkersOnDelete (IntervalSLnode* x, IntervalSLnode** update) { // x is node being deleted. It is still in the list. // update is the update vector for x. IntervalList demoted; IntervalList newDemoted; IntervalList tempRemoved; ILE_handle m; int i; IntervalSLnode *y; // Phase 1: lower markers on edges to the left of x as needed. for(i=x->level()-1; i>=0; i--){ // find marks on edge into x at level i to be demoted for(m=update[i]->markers[i]->get_first(); m!=NULL; m=update[i]->markers[i]->get_next(m)){ if(x->forward[i]==0 || ! m->getInterval()->contains_interval(update[i]->key, x->forward[i]->key)){ newDemoted.insert(m->getInterval()); } } // Remove newly demoted marks from edge. update[i]->markers[i]->removeAll(&newDemoted); // NOTE: update[i]->eqMarkers is left unchanged because any markers // there before demotion must be there afterwards. // Place previously demoted marks on this level as needed. for(m=demoted.get_first(); m!=NULL; m=demoted.get_next(m)){ // Place mark on level i from update[i+1] to update[i], not including // update[i+1] itself, since it already has a mark if it needs one. for(y=update[i+1]; y!=0 && y!=update[i]; y=y->forward[i]) { if (y!=update[i+1] && m->getInterval()->contains(y->key)) y->eqMarkers->insert(m->getInterval()); y->markers[i]->insert(m->getInterval()); } if(y!=0 && y!=update[i+1] && m->getInterval()->contains(y->key)) y->eqMarkers->insert(m->getInterval()); // if this is the lowest level m needs to be placed on, // then place m on the level i edge out of update[i] // and remove m from the demoted set. if(x->forward[i]!=0 && m->getInterval()->contains_interval(update[i]->key, x->forward[i]->key)) { update[i]->markers[i]->insert(m->getInterval()); tempRemoved.insert(m->getInterval()); } } demoted.removeAll(&tempRemoved); tempRemoved.clear(); demoted.copy(&newDemoted); newDemoted.clear(); } // Phase 2: lower markers on edges to the right of D as needed demoted.clear(); // newDemoted is already empty for(i=x->level()-1; i>=0; i--){ for(m=x->markers[i]->get_first(); m!=NULL ; m=x->markers[i]->get_next(m)){ if(x->forward[i]!=0 && (update[i]->isHeader() || !m->getInterval()->contains_interval(update[i]->key, x->forward[i]->key))) { newDemoted.insert(m->getInterval()); } } for(m=demoted.get_first(); m!= NULL; m=demoted.get_next(m)){ // Place mark on level i from x->forward[i] to x->forward[i+1]. // Don't place a mark directly on x->forward[i+1] since it is already // marked. for(y=x->forward[i];y!=x->forward[i+1];y=y->forward[i]){ y->eqMarkers->insert(m->getInterval()); y->markers[i]->insert(m->getInterval()); } if(x->forward[i]!=0 && !update[i]->isHeader() && m->getInterval()->contains_interval(update[i]->key, x->forward[i]->key)) { tempRemoved.insert(m->getInterval()); } } demoted.removeAll(&tempRemoved); demoted.copy(&newDemoted); newDemoted.clear(); } } // end adjustMarkersOnDelete template IntervalSLnode::~IntervalSLnode() { for(int i = 0; i<=topLevel; i++) delete markers[i]; delete forward; delete markers; delete eqMarkers; } template bool Interval_skip_list::remove(const Interval& I) { // arrays for maintaining update pointers IntervalSLnode* update[MAX_FORWARD]; IntervalSLnode* left = search(I.inf(),update); if(left==0 || left->ownerCount <= 0) { return false; } Interval_handle ih = removeMarkers(left,I); container.erase(ih); left->ownerCount--; if(left->ownerCount == 0) remove(left,update); // Note: we search for right after removing left since some // of left's forward pointers may point to right. We don't // want any pointers of update vector pointing to a node that is gone. IntervalSLnode* right = search(I.sup(),update); if(right==0 || right->ownerCount <= 0) { return false; } right->ownerCount--; if(right->ownerCount == 0) remove(right,update); return true; } template void Interval_skip_list::remove(IntervalSLnode* x, IntervalSLnode** update) { // Remove interval skip list node x. The markers that the interval // x belongs to have already been removed. adjustMarkersOnDelete(x,update); // now splice out x. for(int i=0; i<=x->level()-1; i++) update[i]->forward[i] = x->forward[i]; // and finally deallocate it delete x; } template IntervalSLnode* Interval_skip_list::search(const Value& searchKey) { IntervalSLnode* x = header; for(int i=maxLevel; i >= 0; i--) { while (x->forward[i] != 0 && (x->forward[i]->key < searchKey)) { x = x->forward[i]; } } x = x->forward[0]; if(x != NULL && (x->key == searchKey)) return(x); else return(NULL); } template IntervalSLnode* Interval_skip_list::search(const Value& searchKey, IntervalSLnode** update) { IntervalSLnode* x = header; // Find location of searchKey, building update vector indicating // pointers to change on insertion. for(int i=maxLevel; i >= 0; i--) { while (x->forward[i] != 0 && (x->forward[i]->key < searchKey)) { x = x->forward[i]; } update[i] = x; } x = x->forward[0]; return(x); } template void Interval_skip_list::insert(const Interval_handle& I) // insert an interval into list { // insert end points of interval IntervalSLnode* left = this->insert(I->inf()); IntervalSLnode* right = this->insert(I->sup()); left->ownerCount++; right->ownerCount++; // place markers on interval this->placeMarkers(left,right,I); } template void Interval_skip_list::insert(const Interval& I) { #ifdef CGAL_ISL_USE_LIST container.push_front(I); Interval_handle ih = container.begin(); #else Interval_for_container ifc(I); Interval_handle ih = container.insert(ifc); #endif insert(ih); } template void Interval_skip_list::placeMarkers(IntervalSLnode* left, IntervalSLnode* right, const Interval_handle& I) { // Place markers for the interval I. left is the left endpoint // of I and right is the right endpoint of I, so it isn't necessary // to search to find the endpoints. IntervalSLnode* x = left; if (I->contains(x->key)) x->eqMarkers->insert(I); int i = 0; // start at level 0 and go up while(x->forward[i]!=0 && I->contains_interval(x->key,x->forward[i]->key)){ // find level to put mark on while(i!=x->level()-1 && x->forward[i+1] != 0 && I->contains_interval(x->key,x->forward[i+1]->key)) i++; // Mark current level i edge since it is the highest edge out of // x that contains I, except in the case where current level i edge // is null, in which case it should never be marked. if (x->forward[i] != 0) { x->markers[i]->insert(I); x = x->forward[i]; // Add I to eqMarkers set on node unless currently at right endpoint // of I and I doesn't contain right endpoint. if (I->contains(x->key)) x->eqMarkers->insert(I); } } // mark non-ascending path while(x->key != right->key) { // find level to put mark on while(i!=0 && (x->forward[i] == 0 || !I->contains_interval(x->key,x->forward[i]->key))) i--; // At this point, we can assert that i=0 or x->forward[i]!=0 and // I contains // (x->key,x->forward[i]->key). In addition, x is between left and // right so i=0 implies I contains (x->key,x->forward[i]->key). // Hence, the interval must be marked. Note that it is impossible // for us to be at the end of the list because x->key is not equal // to right->key. x->markers[i]->insert(I); x = x->forward[i]; if (I->contains(x->key)) x->eqMarkers->insert(I); } } // end placeMarkers template typename Interval_skip_list::Interval_handle Interval_skip_list::removeMarkers(IntervalSLnode* left, const Interval& I) { // Remove markers for interval I, which has left as it's left // endpoint, following a staircase pattern. // Interval_handle res=0, tmp=0; // af: assignment not possible with std::list Interval_handle res, tmp; // remove marks from ascending path IntervalSLnode* x = left; if (I.contains(x->key)) { if(x->eqMarkers->remove(I, tmp)){ res = tmp; } } int i = 0; // start at level 0 and go up while(x->forward[i]!=0 && I.contains_interval(x->key,x->forward[i]->key)) { // find level to take mark from while(i!=x->level()-1 && x->forward[i+1] != 0 && I.contains_interval(x->key,x->forward[i+1]->key)) i++; // Remove mark from current level i edge since it is the highest edge out // of x that contains I, except in the case where current level i edge // is null, in which case there are no markers on it. if (x->forward[i] != 0) { if(x->markers[i]->remove(I, tmp)){ res = tmp; } x = x->forward[i]; // remove I from eqMarkers set on node unless currently at right // endpoint of I and I doesn't contain right endpoint. if (I.contains(x->key)){ if(x->eqMarkers->remove(I, tmp)){ res = tmp; } } } } // remove marks from non-ascending path while(x->key != I.sup()) { // find level to remove mark from while(i!=0 && (x->forward[i] == 0 || ! I.contains_interval(x->key,x->forward[i]->key))) i--; // At this point, we can assert that i=0 or x->forward[i]!=0 and // I contains // (x->key,x->forward[i]->key). In addition, x is between left and // right so i=0 implies I contains (x->key,x->forward[i]->key). // Hence, the interval is marked and the mark must be removed. // Note that it is impossible for us to be at the end of the list // because x->key is not equal to right->key. if(x->markers[i]->remove(I, tmp)){ res = tmp; } x = x->forward[i]; if (I.contains(x->key)){ if(x->eqMarkers->remove(I, tmp)){ res = tmp; } } } assert(*res == I); return res; } template void Interval_skip_list::removeMarkFromLevel(const Interval& m, int i, IntervalSLnode *l, IntervalSLnode* r) { IntervalSLnode *x; for(x=l; x!=0 && x!=r; x=x->forward[i]) { x->markers[i]->remove(m); x->eqMarkers->remove(m); } if(x!=0) x->eqMarkers->remove(m); } template int Interval_skip_list::randomLevel() { const float P = 0.5; int levels = 0; while( P < rand.get_double(0,1)) levels++; if ( levels <= maxLevel) return(levels); else return(maxLevel+1); } template void IntervalSLnode::print(std::ostream& os) const { int i; os << "IntervalSLnode key: "; if (! is_header) { os << key; }else { os << "HEADER"; } os << "\n"; os << "number of levels: " << level() << std::endl; os << "owning intervals: "; os << "ownerCount = " << ownerCount << std::endl; os << std::endl; os << "forward pointers:\n"; for(i=0; i<=topLevel; i++) { os << "forward[" << i << "] = "; if(forward[i] != NULL) { os << forward[i]->getValue(); } else { os << "NULL"; } os << std::endl; } os << "markers:\n"; for(i=0; i<=topLevel; i++) { os << "markers[" << i << "] = "; if(markers[i] != NULL) { markers[i]->print(os); } else { os << "NULL"; } os << "\n"; } os << "EQ markers: "; eqMarkers->print(os); os << std::endl << std::endl; } template void IntervalList::insert(const Interval_handle& I) { ILE_handle temp = create_list_element(I); temp->next = header; header = temp; } template inline bool IntervalList::remove(const Interval& I, Interval_handle& res) { ILE_handle x, last; x = header; last = NULL; while(x != NULL && *(x->getInterval()) != I) { last = x; x = x->next; } if(x==NULL) { return false; } else if (last==NULL) { header = x->next; res = x->getInterval(); erase_list_element(x); } else { last->next = x->next; res = x->getInterval(); erase_list_element(x); } return true; } template void IntervalList::remove(const Interval& I) { ILE_handle x, last; x = header; last = NULL; while(x != NULL && *(x->getInterval()) != I) { last = x; x = x->next; } if(x==NULL) { return ; } else if (last==NULL) { header = x->next; erase_list_element(x); } else { last->next = x->next; erase_list_element(x); } } template void IntervalList::removeAll(IntervalList *l) { ILE_handle x; for(x=l->get_first(); x!=NULL; x=l->get_next(x)) this->remove(*(x->getInterval())); } // We need the default constructor for the compact_container template inline IntervalListElt::IntervalListElt() : next(NULL) {} template inline IntervalListElt::IntervalListElt(const Interval_handle& anInterval) : I(anInterval), next(NULL) {} template inline IntervalListElt::~IntervalListElt() {} template inline typename IntervalList::ILE_handle IntervalList::get_first() { return header; } template inline typename IntervalList::ILE_handle IntervalList::get_next(ILE_handle element) { return element->next; } template void IntervalList::print(std::ostream& os) const { ILE_handle e = header; while(e != NULL) { e->print(os); e = e->get_next(); } } template void IntervalListElt::print(std::ostream& os) const { /* if(I == 0) { os << "NULL"; } else { os << *I; } */ } template inline bool IntervalList::contains(const Interval_handle& I) const { ILE_handle x = header; while(x!=0 && I != x->I) x = x->next; if (x==NULL) return false; else return true; } template inline IntervalList::IntervalList() : header(NULL) {} template inline IntervalList::~IntervalList() { this->clear(); } } // namespace CGAL #endif // CGAL_INTERVAL_SKIP_LIST_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_intersection.h0000644000175000017500000000245411344301500031077 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_BBOX_2_INTERSECTIONS_H #define CGAL_BBOX_2_INTERSECTIONS_H #include #include #endif // CGAL_BBOX_2_INTERSECTIONS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Dummy_tds_2.h0000644000175000017500000000253711344301500027366 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Dummy_tds_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DUMMY_TDS_2_H #define CGAL_TRIANGULATION_DUMMY_TDS_2_H #include #include CGAL_BEGIN_NAMESPACE // Dummy TDS which provides all types that a vertex_base or cell_base can use. struct Dummy_tds_2 { struct Vertex {}; struct Face {}; struct Edge {}; struct Vertex_handle {}; struct Face_handle {}; struct Vertex_iterator {}; struct Face_iterator {}; struct Edge_iterator {}; struct Edge_circulator {}; struct Facet_circulator {}; struct Vertex_circulator {}; }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DUMMY_TDS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/FPU.h0000644000175000017500000003252611344301500025633 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/FPU.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_FPU_H #define CGAL_FPU_H // This file specifies some platform dependant functions, regarding the FPU // directed rounding modes. There is only support for double precision. // // It also contains the definition of the Protect_FPU_rounding<> class, // which helps to protect blocks of code needing a particular rounding mode. #if defined __alpha__ && defined __linux__ extern "C" { # include } #elif defined __linux__ && !defined __PGI && !defined __ia64__ \ && !defined __x86_64__ # include #elif defined __SUNPRO_CC || (defined __KCC && defined __sun) # include #elif defined __osf || defined __osf__ # ifdef __GNUG__ // GCC seems to remove (fixincludes) read_rnd/write_rnd... # include "/usr/include/float.h" # else # include # endif #elif defined __BORLANDC__ # include #elif defined __sgi # include #elif defined _MSC_VER || defined __sparc__ || \ (defined __i386__ && !defined __PGI) // Nothing to include. #else // By default we use the ISO C99 version. # include #endif // GCC 3.0.0 has some bugs, which can be worked around, but it's // not worth maintaining them anymore. #if defined __GNUG__ && !defined __INTEL_COMPILER && \ (__GNUG__ == 3 && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 0) # error GCC 3.0.0 is buggy, use at your own risk. #endif // Some useful constants #if defined CGAL_CFG_NO_LIMITS # if defined CGAL_CFG_DENORMALS_COMPILE_BUG // For compilers crashing when dealing with denormalized values. // So we have to generate it at run time instead. # define CGAL_IA_MIN_DOUBLE (CGAL::CGALi::minimin) # else # define CGAL_IA_MIN_DOUBLE (5e-324) # endif # define CGAL_IA_MAX_DOUBLE (1.7976931348623157081e+308) #else # include # define CGAL_IA_MIN_DOUBLE std::numeric_limits::denorm_min() # define CGAL_IA_MAX_DOUBLE std::numeric_limits::max() #endif // Pure and safe SSE2 mode (g++ -mfpmath=sse && (-msse2 || -march=pentium4)) // can be detected by : // TODO : see what Intel and VC++ have to say about this. #if defined __FLT_EVAL_METHOD__ && defined __SSE2_MATH__ && \ (__FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1) # define CGAL_SAFE_SSE2 # include #endif // We do not handle -mfpmath=387,sse yet. #if defined __SSE2_MATH__ && \ ! (__FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1) # warning Unsafe SSE2 mode : not supported yet. #endif CGAL_BEGIN_NAMESPACE namespace CGALi { #ifdef CGAL_CFG_DENORMALS_COMPILE_BUG extern double minimin; #endif #ifdef __INTEL_COMPILER const double infinity = std::numeric_limits::infinity(); #else const double infinity = HUGE_VAL; #endif } // namespace CGALi // Inline function to stop compiler optimization. inline double IA_force_to_double(double x) { #if defined __GNUG__ && !defined __INTEL_COMPILER // Intel does not emulate GCC perfectly... asm("" : "=m"(x) : "m"(x)); // asm("" : "+m"(x) ); return x; #else volatile double e = x; return e; #endif } // The x86 processor keeps too wide exponents (15bits) in registers, even in // double precision mode ! It's a problem when the intervals overflow or // underflow. To work around that, we store the variable to memory when // needed, using the macro below. // Another possible workaround would be to use intervals of "long doubles" // directly, but I think it would be much slower. #if !defined (CGAL_IA_NO_X86_OVER_UNDER_FLOW_PROTECT) && \ ((defined __i386__ && !defined CGAL_SAFE_SSE2) \ || defined _MSC_VER || defined __BORLANDC__) # define CGAL_IA_FORCE_TO_DOUBLE(x) CGAL::IA_force_to_double(x) #else # define CGAL_IA_FORCE_TO_DOUBLE(x) (x) #endif // We sometimes need to stop constant propagation, // because operations are done with a wrong rounding mode at compile time. // G++ also uses __builtin_constant_p(). #ifndef CGAL_IA_DONT_STOP_CONSTANT_PROPAGATION # if defined __GNUG__ && __GNUG__ < 3 // Note : GCC 3 doesn't guarantee __builtin_constant_p to return false // when he will not do cprop :(. # define CGAL_IA_STOP_CPROP(x) \ (__builtin_constant_p (x) ? CGAL::IA_force_to_double(x) : (x) ) # define CGAL_IA_STOP_CPROP2(x,y) \ (__builtin_constant_p (y) ? CGAL_IA_STOP_CPROP(x) : (x) ) # else # define CGAL_IA_STOP_CPROP(x) CGAL::IA_force_to_double(x) # define CGAL_IA_STOP_CPROP2(x,y) CGAL::IA_force_to_double(x) # endif #else # define CGAL_IA_STOP_CPROP(x) (x) # define CGAL_IA_STOP_CPROP2(x,y) (x) #endif // std::sqrt(double) on VC++ and CygWin is buggy when not optimizing. #ifdef _MSC_VER inline double IA_bug_sqrt(double d) { _asm { fld d fsqrt fstp d } return d; } # define CGAL_BUG_SQRT(d) CGAL::IA_bug_sqrt(d) #elif defined __SSE2_MATH__ // For SSE2, we need to call __builtin_sqrt() instead of libc's sqrt(). # define CGAL_BUG_SQRT(d) __builtin_sqrt(d) #elif defined __CYGWIN__ inline double IA_bug_sqrt(double d) { double r; asm volatile ("fsqrt" : "=t"(r) : "0"(d)); return r; } # define CGAL_BUG_SQRT(d) CGAL::IA_bug_sqrt(d) #else # define CGAL_BUG_SQRT(d) CGAL_CLIB_STD::sqrt(d) #endif // Here are the operator macros that make use of the above. // With GCC, we can do slightly better : test with __builtin_constant_p() // that both arguments are constant before stopping one of them. // Use inline functions instead ? #define CGAL_IA_ADD(a,b) CGAL_IA_FORCE_TO_DOUBLE((a)+CGAL_IA_STOP_CPROP2(b,a)) #define CGAL_IA_SUB(a,b) CGAL_IA_FORCE_TO_DOUBLE((a)-CGAL_IA_STOP_CPROP2(b,a)) #define CGAL_IA_MUL(a,b) CGAL_IA_FORCE_TO_DOUBLE((a)*CGAL_IA_STOP_CPROP2(b,a)) #define CGAL_IA_DIV(a,b) CGAL_IA_FORCE_TO_DOUBLE((a)/CGAL_IA_STOP_CPROP2(b,a)) #define CGAL_IA_SQUARE(a) CGAL_IA_MUL(a,a) #define CGAL_IA_SQRT(a) \ CGAL_IA_FORCE_TO_DOUBLE(CGAL_BUG_SQRT(CGAL_IA_STOP_CPROP(a))) #if defined __i386__ && !defined __PGI # if defined CGAL_SAFE_SSE2 #define CGAL_IA_SETFPCW(CW) _MM_SET_ROUNDING_MODE(CW) #define CGAL_IA_GETFPCW(CW) CW = _MM_GET_ROUNDING_MODE() typedef unsigned int FPU_CW_t; #define CGAL_FE_TONEAREST _MM_ROUND_NEAREST #define CGAL_FE_TOWARDZERO _MM_ROUND_TOWARD_ZERO #define CGAL_FE_UPWARD _MM_ROUND_UP #define CGAL_FE_DOWNWARD _MM_ROUND_DOWN # else // The GNU libc version (cf powerpc) is nicer, but doesn't work on libc 5 :( // This one also works with CygWin. // Note that the ISO C99 version is not enough because of the extended // mantissa issue on x86 (required by Fixed_precision_nt, modular computations // in the future, but not IA right now). #define CGAL_IA_SETFPCW(CW) asm volatile ("fldcw %0" : :"m" (CW)) #define CGAL_IA_GETFPCW(CW) asm volatile ("fnstcw %0" : "=m" (CW)) typedef unsigned short FPU_CW_t; #define CGAL_FE_TONEAREST (0x000 | 0x127f) #define CGAL_FE_TOWARDZERO (0xc00 | 0x127f) #define CGAL_FE_UPWARD (0x800 | 0x127f) #define CGAL_FE_DOWNWARD (0x400 | 0x127f) # endif #elif defined __powerpc__ #define CGAL_IA_SETFPCW(CW) _FPU_SETCW(CW) #define CGAL_IA_GETFPCW(CW) _FPU_GETCW(CW) typedef fpu_control_t FPU_CW_t; #define CGAL_FE_TONEAREST (_FPU_RC_NEAREST | _FPU_DEFAULT) #define CGAL_FE_TOWARDZERO (_FPU_RC_ZERO | _FPU_DEFAULT) #define CGAL_FE_UPWARD (_FPU_RC_UP | _FPU_DEFAULT) #define CGAL_FE_DOWNWARD (_FPU_RC_DOWN | _FPU_DEFAULT) #elif defined __SUNPRO_CC || (defined __KCC && defined __sun) #define CGAL_IA_SETFPCW(CW) fpsetround(fp_rnd(CW)) #define CGAL_IA_GETFPCW(CW) CW = fpgetround() typedef unsigned int FPU_CW_t; #define CGAL_FE_TONEAREST FP_RN #define CGAL_FE_TOWARDZERO FP_RZ #define CGAL_FE_UPWARD FP_RP #define CGAL_FE_DOWNWARD FP_RM #elif defined __sparc__ #define CGAL_IA_SETFPCW(CW) asm volatile ("ld %0,%%fsr" : :"m" (CW)) #define CGAL_IA_GETFPCW(CW) asm volatile ("st %%fsr,%0" : "=m" (CW)) typedef unsigned int FPU_CW_t; #define CGAL_FE_TONEAREST (0x0 | 0x20000000 | 0x1f) #define CGAL_FE_TOWARDZERO (0x40000000 | 0x20000000 | 0x1f) #define CGAL_FE_UPWARD (0x80000000 | 0x20000000 | 0x1f) #define CGAL_FE_DOWNWARD (0xc0000000 | 0x20000000 | 0x1f) #elif defined __sgi typedef unsigned int FPU_CW_t; inline FPU_CW_t sgi_get_fpu_cw() { fpc_csr csr; csr.fc_word = get_fpc_csr(); return csr.fc_struct.rounding_mode; } inline void sgi_set_fpu_cw(FPU_CW_t cw) { fpc_csr csr; csr.fc_word = get_fpc_csr(); csr.fc_struct.rounding_mode = cw; csr.fc_struct.flush = 0; // By default, denormals are flushed to zero ! set_fpc_csr(csr.fc_word); } #define CGAL_IA_SETFPCW(CW) sgi_set_fpu_cw(CW) #define CGAL_IA_GETFPCW(CW) CW = sgi_get_fpu_cw() #define CGAL_FE_TONEAREST ROUND_TO_NEAREST #define CGAL_FE_TOWARDZERO ROUND_TO_ZERO #define CGAL_FE_UPWARD ROUND_TO_PLUS_INFINITY #define CGAL_FE_DOWNWARD ROUND_TO_MINUS_INFINITY #elif defined __mips__ // && !defined __sgi #define CGAL_IA_SETFPCW(CW) asm volatile ("ctc1 %0,$31" : :"r" (CW)) #define CGAL_IA_GETFPCW(CW) asm volatile ("cfc1 %0,$31" : "=r" (CW)) typedef unsigned int FPU_CW_t; #define CGAL_FE_TONEAREST (0x0) #define CGAL_FE_TOWARDZERO (0x1) #define CGAL_FE_UPWARD (0x2) #define CGAL_FE_DOWNWARD (0x3) #elif defined __osf || defined __osf__ // Not yet supported. #define CGAL_IA_SETFPCW(CW) write_rnd(CW) #define CGAL_IA_GETFPCW(CW) CW = read_rnd() typedef unsigned int FPU_CW_t; #define CGAL_FE_TONEAREST FP_RND_RN #define CGAL_FE_TOWARDZERO FP_RND_RZ #define CGAL_FE_UPWARD FP_RND_RP #define CGAL_FE_DOWNWARD FP_RND_RM #elif defined __alpha__ // preliminary support. #define CGAL_IA_SETFPCW(CW) (__ieee_set_fp_control(CW)) #define CGAL_IA_GETFPCW(CW) (CW = __ieee_get_fp_control()) typedef unsigned long FPU_CW_t; #define CGAL_FE_TONEAREST FE_TONEAREST #define CGAL_FE_TOWARDZERO FE_TOWARDZERO #define CGAL_FE_UPWARD FE_UPWARD #define CGAL_FE_DOWNWARD FE_DOWNWARD #elif defined _MSC_VER // Found in http://msdn.microsoft.com/library/sdkdoc/directx/imover_7410.htm : #define CGAL_IA_SETFPCW(CW) __asm fldcw (CW) #define CGAL_IA_GETFPCW(CW) __asm fstcw (CW) typedef unsigned short FPU_CW_t; #define CGAL_FE_TONEAREST (0x0 | 0x127f) #define CGAL_FE_TOWARDZERO (0xC00 | 0x127f) #define CGAL_FE_UPWARD (0x800 | 0x127f) #define CGAL_FE_DOWNWARD (0x400 | 0x127f) #elif defined __BORLANDC__ #define CGAL_IA_SETFPCW(CW) _control87(CW,~0) #define CGAL_IA_GETFPCW(CW) CW = _control87(0,0) typedef unsigned short FPU_CW_t; #define CGAL_FE_TONEAREST (0x0 | 0x127f) #define CGAL_FE_TOWARDZERO (0xC00 | 0x127f) #define CGAL_FE_UPWARD (0x800 | 0x127f) #define CGAL_FE_DOWNWARD (0x400 | 0x127f) #else // This is a version following the ISO C99 standard, which aims at portability. // The drawbacks are speed on one hand, and also, on x86, it doesn't fix the // extended mantissa issue (this is not a problem for IA, but it is one for // Fixed_precision_nt, and some future modular computations as well). #define CGAL_IA_SETFPCW(CW) fesetround(CW) #define CGAL_IA_GETFPCW(CW) CW = fegetround() typedef int FPU_CW_t; #define CGAL_FE_TONEAREST FE_TONEAREST #define CGAL_FE_TOWARDZERO FE_TOWARDZERO #define CGAL_FE_UPWARD FE_UPWARD #define CGAL_FE_DOWNWARD FE_DOWNWARD #endif // User interface: inline FPU_CW_t FPU_get_cw (void) { FPU_CW_t cw; CGAL_IA_GETFPCW(cw); return cw; } inline void FPU_set_cw (FPU_CW_t cw) { CGAL_IA_SETFPCW(cw); } inline FPU_CW_t FPU_get_and_set_cw (FPU_CW_t cw) { FPU_CW_t old = FPU_get_cw(); FPU_set_cw(cw); return old; } // The following is meant to truncate the mantissa of x86 FPUs to 53 bits. // It is used by the Fixed_precision_nt. inline void force_ieee_double_precision() { #if defined __i386__ || defined _MSC_VER || defined __BORLANDC__ FPU_set_cw(CGAL_FE_TONEAREST); #endif } // A class whose constructor sets the FPU mode to +inf, saves a backup of it, // and whose destructor resets it back to the saved state. template struct Protect_FPU_rounding; template <> struct Protect_FPU_rounding { Protect_FPU_rounding(FPU_CW_t r = CGAL_FE_UPWARD) : backup( FPU_get_and_set_cw(r) ) {} ~Protect_FPU_rounding() { FPU_set_cw(backup); } private: FPU_CW_t backup; }; template <> struct Protect_FPU_rounding { Protect_FPU_rounding(FPU_CW_t = CGAL_FE_UPWARD) {} ~Protect_FPU_rounding() {} // just to shut up a warning, but it has a performance issue with GCC 2.95, // so I should disable it for the moment. Use __attribute__((unused)) ? }; CGAL_END_NAMESPACE #endif // CGAL_FPU_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/0000755000175000017500000000000012146213727027515 5ustar debiandebian././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct_point_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct0000644000175000017500000000521011344301501031405 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct_point_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_CONSTRUCT_POINT_3_H #define CGAL_OPTIMISATION_CONSTRUCT_POINT_3_H // includes #ifndef CGAL_POINT_3_H # include #endif #ifndef CGAL_PROTECT_VECTOR # include # define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_PROTECT_FUNCTIONAL # include # define CGAL_PROTECT_FUNCTIONAL #endif #ifndef CGAL_PROTECT_ITERATOR # include # define CGAL_PROTECT_ITERATOR #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K > class _Construct_point_3; // Class interface // =============== template < class K_ > class _Construct_point_3 { public: // self typedef K_ K; typedef _Construct_point_3 Self; // types typedef typename K::Point_3 Point; // creation _Construct_point_3( ) { } // operations template < class InputIterator > Point operator() ( int, InputIterator first, InputIterator last) const { InputIterator i(first); typename K::RT x = *(i++); typename K::RT y = *(i++); typename K::RT z = *(i++); typedef typename K::Construct_point_3 Construct_point_3; Construct_point_3 construct_point_3 = K().construct_point_3_object(); if (i==last) { return construct_point_3(x,y,z); } else { typename K::RT h = *(i++); return construct_point_3(x,y,z,h); } } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_CONSTRUCT_POINT_3_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct_point_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct0000644000175000017500000000514611344301501031415 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct_point_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_CONSTRUCT_POINT_2_H #define CGAL_OPTIMISATION_CONSTRUCT_POINT_2_H // includes #ifndef CGAL_POINT_2_H # include #endif #ifndef CGAL_PROTECT_VECTOR # include # define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_PROTECT_FUNCTIONAL # include # define CGAL_PROTECT_FUNCTIONAL #endif #ifndef CGAL_PROTECT_ITERATOR # include # define CGAL_PROTECT_ITERATOR #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K > class _Construct_point_2; // Class interface // =============== template < class K_ > class _Construct_point_2 { public: // self typedef K_ K; typedef _Construct_point_2 Self; // types typedef typename K::Point_2 Point; // creation _Construct_point_2( ) { } // operations template < class InputIterator > Point operator() ( int, InputIterator first, InputIterator last) const { InputIterator i(first); typename K::RT x = *(i++); typename K::RT y = *(i++); typedef typename K::Construct_point_2 Construct_point_2; Construct_point_2 construct_point_2 = K().construct_point_2_object(); if (i==last) { return construct_point_2(x,y); } else { typename K::RT h = *(i++); return construct_point_2(x,y,h); } } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_CONSTRUCT_POINT_2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_dimension_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_di0000644000175000017500000000400711344301501031301 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_dimension_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_ACCESS_DIMENSION_D_H #define CGAL_OPTIMISATION_ACCESS_DIMENSION_D_H CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class R_ > class Access_dimension_d; // Class interface // =============== template < class R_ > class Access_dimension_d { public: // self typedef R_ R; typedef Access_dimension_d Self; // types typedef typename R::Point_d Point; // unary function class types typedef int result_type; typedef Point argument_type; // creation Access_dimension_d( ) { } // operations int operator() ( const Point& p) const { return p.dimension(); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_ACCESS_DIMENSION_D_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/assertions.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/assertion0000644000175000017500000004150111344301501031433 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman, Sven Schoenherr #ifndef CGAL_OPTIMISATION_ASSERTIONS_H #define CGAL_OPTIMISATION_ASSERTIONS_H // macro definitions // ================= // assertions // ---------- #if ( defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) # define CGAL_optimisation_assertion(EX) ((void)0) # define CGAL_optimisation_assertion_msg(EX,MSG) ((void)0) # define CGAL_optimisation_assertion_code(CODE) # undef CGAL_OPTIMISATION_ASSERTION_TAG #else # define CGAL_optimisation_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_assertion_code(CODE) CODE # define CGAL_OPTIMISATION_ASSERTION_TAG 1 #endif // optimisation assertions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXACTNESS) ) \ || defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) # define CGAL_optimisation_exactness_assertion(EX) ((void)0) # define CGAL_optimisation_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_optimisation_exactness_assertion_code(CODE) # undef CGAL_OPTIMISATION_EXACTNESS_ASSERTION_TAG #else # define CGAL_optimisation_exactness_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_exactness_assertion_code(CODE) CODE # define CGAL_OPTIMISATION_EXACTNESS_ASSERTION_TAG 1 #endif // optimisation exactness assertions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_assertion(EX) ((void)0) # define CGAL_optimisation_expensive_assertion_msg(EX,MSG) ((void)0) # define CGAL_optimisation_expensive_assertion_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_ASSERTION_TAG #else # define CGAL_optimisation_expensive_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_assertion_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_ASSERTION_TAG 1 #endif // optimisation expensive assertions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_ASSERTIONS) \ || defined( CGAL_NO_ASSERTIONS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_exactness_assertion(EX) \ ((void)0) # define CGAL_optimisation_expensive_exactness_assertion_msg(EX,MSG) \ ((void)0) # define CGAL_optimisation_expensive_exactness_assertion_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_ASSERTION_TAG #else # define CGAL_optimisation_expensive_exactness_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_exactness_assertion_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_ASSERTION_TAG 1 #endif // optimisation expensive exactness assertions // preconditions // ------------- #if ( defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_precondition(EX) ((void)0) # define CGAL_optimisation_precondition_msg(EX,MSG) ((void)0) # define CGAL_optimisation_precondition_code(CODE) # undef CGAL_OPTIMISATION_PRECONDITION_TAG #else # define CGAL_optimisation_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_precondition_code(CODE) CODE # define CGAL_OPTIMISATION_PRECONDITION_TAG 1 #endif // optimisation preconditions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXACTNESS) ) \ || defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_exactness_precondition(EX) ((void)0) # define CGAL_optimisation_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_optimisation_exactness_precondition_code(CODE) # undef CGAL_OPTIMISATION_EXACTNESS_PRECONDITION_TAG #else # define CGAL_optimisation_exactness_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_exactness_precondition_code(CODE) CODE # define CGAL_OPTIMISATION_EXACTNESS_PRECONDITION_TAG 1 #endif // optimisation exactness preconditions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_precondition(EX) ((void)0) # define CGAL_optimisation_expensive_precondition_msg(EX,MSG) ((void)0) # define CGAL_optimisation_expensive_precondition_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG #else # define CGAL_optimisation_expensive_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_precondition_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG 1 #endif // optimisation expensive preconditions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_PRECONDITIONS) \ || defined( CGAL_NO_PRECONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_exactness_precondition(EX) \ ((void)0) # define CGAL_optimisation_expensive_exactness_precondition_msg(EX,MSG) \ ((void)0) # define CGAL_optimisation_expensive_exactness_precondition_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_PRECONDITION_TAG #else # define CGAL_optimisation_expensive_exactness_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_exactness_precondition_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_PRECONDITION_TAG 1 #endif // optimisation expensive exactness preconditions // postconditions // -------------- #if ( defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_postcondition(EX) ((void)0) # define CGAL_optimisation_postcondition_msg(EX,MSG) ((void)0) # define CGAL_optimisation_postcondition_code(CODE) # undef CGAL_OPTIMISATION_POSTCONDITION_TAG #else # define CGAL_optimisation_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_postcondition_code(CODE) CODE # define CGAL_OPTIMISATION_POSTCONDITION_TAG 1 #endif // optimisation postconditions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXACTNESS) ) \ || defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_exactness_postcondition(EX) ((void)0) # define CGAL_optimisation_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_optimisation_exactness_postcondition_code(CODE) # undef CGAL_OPTIMISATION_EXACTNESS_POSTCONDITION_TAG #else # define CGAL_optimisation_exactness_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_exactness_postcondition_code(CODE) CODE # define CGAL_OPTIMISATION_EXACTNESS_POSTCONDITION_TAG 1 #endif // optimisation exactness postconditions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_postcondition(EX) ((void)0) # define CGAL_optimisation_expensive_postcondition_msg(EX,MSG) ((void)0) # define CGAL_optimisation_expensive_postcondition_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_POSTCONDITION_TAG #else # define CGAL_optimisation_expensive_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_postcondition_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_POSTCONDITION_TAG 1 #endif // optimisation expensive postconditions #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_POSTCONDITIONS) \ || defined( CGAL_NO_POSTCONDITIONS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_exactness_postcondition(EX) \ ((void)0) # define CGAL_optimisation_expensive_exactness_postcondition_msg(EX,MSG) \ ((void)0) # define CGAL_optimisation_expensive_exactness_postcondition_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_POSTCONDITION_TAG #else # define CGAL_optimisation_expensive_exactness_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_exactness_postcondition_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_POSTCONDITION_TAG 1 #endif // optimisation expensive exactness postconditions // warnings // -------- #if ( defined( CGAL_OPTIMISATION_NO_WARNINGS) \ || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) # define CGAL_optimisation_warning(EX) ((void)0) # define CGAL_optimisation_warning_msg(EX,MSG) ((void)0) # define CGAL_optimisation_warning_code(CODE) # undef CGAL_OPTIMISATION_WARNING_TAG #else # define CGAL_optimisation_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_warning_code(CODE) CODE # define CGAL_OPTIMISATION_WARNING_TAG 1 #endif // optimisation warnings #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXACTNESS) ) \ || defined( CGAL_OPTIMISATION_NO_WARNINGS) \ || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) # define CGAL_optimisation_exactness_warning(EX) ((void)0) # define CGAL_optimisation_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_optimisation_exactness_warning_code(CODE) # undef CGAL_OPTIMISATION_EXACTNESS_WARNING_TAG #else # define CGAL_optimisation_exactness_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_exactness_warning_code(CODE) CODE # define CGAL_OPTIMISATION_EXACTNESS_WARNING_TAG 1 #endif // optimisation exactness warnings #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_WARNINGS) \ || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_warning(EX) ((void)0) # define CGAL_optimisation_expensive_warning_msg(EX,MSG) ((void)0) # define CGAL_optimisation_expensive_warning_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_WARNING_TAG #else # define CGAL_optimisation_expensive_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_warning_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_WARNING_TAG 1 #endif // optimisation expensive warnings #if ( ! ( defined( CGAL_OPTIMISATION_CHECK_EXACTNESS) \ || defined( CGAL_OPTIMISATION_CHECK_EXPENSIVE) \ || defined( CGAL_CHECK_EXACTNESS) \ || defined( CGAL_CHECK_EXPENSIVE) ) \ || defined( CGAL_OPTIMISATION_NO_WARNINGS) \ || defined( CGAL_NO_WARNINGS) || defined( NDEBUG)) # define CGAL_optimisation_expensive_exactness_warning(EX) \ ((void)0) # define CGAL_optimisation_expensive_exactness_warning_msg(EX,MSG) \ ((void)0) # define CGAL_optimisation_expensive_exactness_warning_code(CODE) # undef CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_WARNING_TAG #else # define CGAL_optimisation_expensive_exactness_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,0)) # define CGAL_optimisation_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX ,__FILE__,__LINE__,MSG)) # define CGAL_optimisation_expensive_exactness_warning_code(CODE) CODE # define CGAL_OPTIMISATION_EXPENSIVE_EXACTNESS_WARNING_TAG 1 #endif // optimisation expensive exactness warnings #endif // CGAL_OPTIMISATION_ASSERTIONS_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/basic.h0000644000175000017500000000345711344301501030743 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/basic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_BASIC_H #define CGAL_OPTIMISATION_BASIC_H // includes #include #include #include #include CGAL_BEGIN_NAMESPACE // Function declarations // ===================== // is_valid failure function // ------------------------- inline bool _optimisation_is_valid_fail( CGAL::Verbose_ostream& verr, const char* message) { verr << "FAILED." << std::endl; verr << " --> " << message << std::endl; verr << " object is NOT valid!" << std::endl; return false; } CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_BASIC_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_coordinates_begin_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_co0000644000175000017500000001101311344301501031301 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_coordinates_begin_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_2_H #define CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_2_H CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class R_ > class Access_coordinates_begin_2; template < class R_ > class Point_2_coordinate_iterator; // Class interfaces // ================ template < class R_ > class Point_2_coordinate_iterator { public: // self typedef R_ R; typedef Point_2_coordinate_iterator Self; // types typedef typename R::Point_2 Point; // iterator types typedef typename R::RT value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; // forward operations Point_2_coordinate_iterator( const Point& point = Point(), int index = 0) : p( point), i( index) { } bool operator == ( const Self& it) const { return ( i == it.i);} bool operator != ( const Self& it) const { return ( i != it.i);} value_type operator * ( ) const { return p.homogeneous( i); } Self& operator ++ ( ) { ++i; return *this; } Self operator ++ ( int) { Self tmp = *this; ++i; return tmp; } // bidirectional operations Self& operator -- ( ) { --i; return *this; } Self operator -- ( int) { Self tmp = *this; --i; return tmp; } // random access operations Self& operator += ( int n) { i += n; return *this; } Self& operator -= ( int n) { i -= n; return *this; } Self operator + ( int n) const { Self tmp = *this; return tmp += n; } Self operator - ( int n) const { Self tmp = *this; return tmp -= n; } difference_type operator - ( const Self& it) const { return i - it.i; } value_type operator [] ( int n) const { return p.homogeneous( i+n); } bool operator < ( const Self& it) const { return ( i < it.i); } bool operator > ( const Self& it) const { return ( i > it.i); } bool operator <= ( const Self& it) const { return ( i <= it.i); } bool operator >= ( const Self& it) const { return ( i >= it.i); } private: const Point& p; int i; }; template < class R_ > class Access_coordinates_begin_2 { public: // self typedef R_ R; typedef Access_coordinates_begin_2 Self; // types typedef typename R::Point_2 Point; typedef Point_2_coordinate_iterator Coordinate_iterator; // unary function class types typedef Coordinate_iterator result_type; typedef Point argument_type; // creation Access_coordinates_begin_2( ) { } // operations Coordinate_iterator operator() ( const Point& p) const { return Coordinate_iterator( p); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_dimension_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_di0000644000175000017500000000401111344301501031274 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_dimension_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_ACCESS_DIMENSION_2_H #define CGAL_OPTIMISATION_ACCESS_DIMENSION_2_H CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class R_ > class Access_dimension_2; // Class interface // =============== template < class R_ > class Access_dimension_2 { public: // self typedef R_ R; typedef Access_dimension_2 Self; // types typedef typename R::Point_2 Point; // unary function class types typedef int result_type; typedef Point argument_type; // creation Access_dimension_2( ) { } // operations int operator() ( const Point& p) const { return p.dimension(); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_ACCESS_DIMENSION_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/debug.h0000644000175000017500000000311711344301501030741 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/debug.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_DEBUG_H #define CGAL_OPTIMISATION_DEBUG_H // macro definitions // ================= // debug // ----- #if ( defined( CGAL_OPTIMISATION_NO_DEBUG) \ || defined( CGAL_NO_DEGUG) || defined( NDEBUG)) # define CGAL_optimisation_debug if ( 0) #else # define CGAL_optimisation_debug if ( 1) #endif // optimisation debug #endif // CGAL_OPTIMISATION_DEBUG_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_coordinates_begin_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_co0000644000175000017500000000533111344301501031307 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_coordinates_begin_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_D_H #define CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_D_H CGAL_BEGIN_NAMESPACE struct Cartesian_tag; struct Homogeneous_tag; // Class declaration // ================= template < class R_ > class Access_coordinates_begin_d; // Class interface // =============== template < class R_ > class Access_coordinates_begin_d { public: // self typedef R_ R; typedef Access_coordinates_begin_d Self; // types typedef typename R::Point_d Point; typedef const typename R::RT * Coordinate_iterator; // unary function class types typedef Coordinate_iterator result_type; typedef Point argument_type; // creation Access_coordinates_begin_d( ) { } // operations private: Coordinate_iterator access( const Point& p, const Cartesian_tag&) const { return p.cartesian_begin(); } Coordinate_iterator access( const Point& p, const Homogeneous_tag&) const { return p.homogeneous_begin(); } public: Coordinate_iterator operator() ( const Point& p) const { typename R::Rep_tag tag; #if defined(__sun) && defined(__SUNPRO_CC) // to avoid a warning "tag has not yet been assigned a value" typedef typename R::Rep_tag Rep_tag; tag = Rep_tag(); #endif // SUNPRO return access(p, tag); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_D_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_dimension_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_di0000644000175000017500000000400711344301501031301 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_dimension_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_ACCESS_DIMENSION_3_H #define CGAL_OPTIMISATION_ACCESS_DIMENSION_3_H CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class R_ > class Access_dimension_3; // Class interface // =============== template < class R_ > class Access_dimension_3 { public: // self typedef R_ R; typedef Access_dimension_3 Self; // types typedef typename R::Point_3 Point; // unary function class types typedef int result_type; typedef Point argument_type; // creation Access_dimension_3( ) { } // operations int operator() ( const Point& p) const { return p.dimension(); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_ACCESS_DIMENSION_3_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_coordinates_begin_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_co0000644000175000017500000001101311344301501031301 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Access_coordinates_begin_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_3_H #define CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_3_H CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class R_ > class Access_coordinates_begin_3; template < class R_ > class Point_3_coordinate_iterator; // Class interfaces // ================ template < class R_ > class Point_3_coordinate_iterator { public: // self typedef R_ R; typedef Point_3_coordinate_iterator Self; // types typedef typename R::Point_3 Point; // iterator types typedef typename R::RT value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; // forward operations Point_3_coordinate_iterator( const Point& point = Point(), int index = 0) : p( point), i( index) { } bool operator == ( const Self& it) const { return ( i == it.i);} bool operator != ( const Self& it) const { return ( i != it.i);} value_type operator * ( ) const { return p.homogeneous( i); } Self& operator ++ ( ) { ++i; return *this; } Self operator ++ ( int) { Self tmp = *this; ++i; return tmp; } // bidirectional operations Self& operator -- ( ) { --i; return *this; } Self operator -- ( int) { Self tmp = *this; --i; return tmp; } // random access operations Self& operator += ( int n) { i += n; return *this; } Self& operator -= ( int n) { i -= n; return *this; } Self operator + ( int n) const { Self tmp = *this; return tmp += n; } Self operator - ( int n) const { Self tmp = *this; return tmp -= n; } difference_type operator - ( const Self& it) const { return i - it.i; } value_type operator [] ( int n) const { return p.homogeneous( i+n); } bool operator < ( const Self& it) const { return ( i < it.i); } bool operator > ( const Self& it) const { return ( i > it.i); } bool operator <= ( const Self& it) const { return ( i <= it.i); } bool operator >= ( const Self& it) const { return ( i >= it.i); } private: const Point& p; int i; }; template < class R_ > class Access_coordinates_begin_3 { public: // self typedef R_ R; typedef Access_coordinates_begin_3 Self; // types typedef typename R::Point_3 Point; typedef Point_3_coordinate_iterator Coordinate_iterator; // unary function class types typedef Coordinate_iterator result_type; typedef Point argument_type; // creation Access_coordinates_begin_3( ) { } // operations Coordinate_iterator operator() ( const Point& p) const { return Coordinate_iterator( p); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_3_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct_point_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct0000644000175000017500000000422011344301501031405 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation/Construct_point_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_CONSTRUCT_POINT_D_H #define CGAL_OPTIMISATION_CONSTRUCT_POINT_D_H // includes # include # include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K > class _Construct_point_d; // Class interface // =============== template < class K_ > class _Construct_point_d { public: // self typedef K_ K; typedef _Construct_point_d Self; // types typedef typename K::Point_d Point; // creation _Construct_point_d( ) { } // operations template < class InputIterator > Point operator() ( int d, InputIterator first, InputIterator last) const { // d-dim kernel has no functor to construct a point, use point's // constructor return Point( d, first, last); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_CONSTRUCT_POINT_D_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Lazy_exact_nt.h0000644000175000017500000004455611344301500030013 0ustar debiandebian// Copyright (c) 1999-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Lazy_exact_nt.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_LAZY_EXACT_NT_H #define CGAL_LAZY_EXACT_NT_H #include #include #include #include #include #include #include #include #include // to get the overloaded predicates. /* * This file contains the definition of the number type Lazy_exact_nt, * where ET is an exact number type (must provide the exact operations needed). * * Lazy_exact_nt provides a DAG-based lazy evaluation, like LEDA's real, * Core's Expr, LEA's lazy rationals... * * The values are first approximated using Interval_base. * The exactness is provided when needed by ET. * * Lazy_exact_nt is just a handle to the abstract base class * Lazy_exact_rep which has pure virtual methods .approx() and .exact(). * From this class derives one class per operation, with one constructor. * * The DAG is managed by : * - Handle and Rep. * - virtual functions to denote the various operators (instead of an enum). * * Other packages with vaguely similar design : APU, MetaCGAL, LOOK. */ /* * TODO : * - Generalize it for constructions at the kernel level. * - Interval rafinement functionnality ? * - Separate the handle and the representation(s) in 2 files (?) * maybe not a good idea, better if everything related to one operation is * close together. * - Add a CT template parameter like Filtered_exact_nt<> ? * - Add a string constant to provide an expression string (a la MetaCGAL) ? * // virtual ostream operator<<() const = 0; // or string, like Core ? * - Have a template-expression (?) thing that evaluates a temporary element, * and allocates stuff in memory only when really needs to convert to the * NT. (cf gmp++, and maybe other things, Blitz++, Synaps...) */ /* * Interface of the rep classes: * - .approx() returns Interval_nt<> (assumes rounding=nearest). * [ only called from the handle, and declared in the base ] * - .exact() returns ET, if not already done, computes recursively * * - .rafine_approx() ?? */ CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; // Abstract base representation class template struct Lazy_exact_rep : public Rep { Interval_nt in; // could be const, except for rafinement ? or mutable ? ET *et; // mutable as well ? Lazy_exact_rep (const Interval_nt & i) : in(i), et(NULL) {} private: Lazy_exact_rep (const Lazy_exact_rep&) { abort(); } // cannot be copied. public: const Interval_nt& approx() const { return in; } const ET & exact() { if (et==NULL) { update_exact(); in = CGAL_NTS to_interval(*et); } return *et; } virtual void update_exact() = 0; virtual ~Lazy_exact_rep () { delete et; }; }; // int constant template struct Lazy_exact_Int_Cst : public Lazy_exact_rep { Lazy_exact_Int_Cst (int i) : Lazy_exact_rep(double(i)) {} void update_exact() { this->et = new ET((int)this->in.inf()); } }; // double constant template struct Lazy_exact_Cst : public Lazy_exact_rep { Lazy_exact_Cst (double d) : Lazy_exact_rep(d) {} void update_exact() { this->et = new ET(this->in.inf()); } }; // Exact constant template struct Lazy_exact_Ex_Cst : public Lazy_exact_rep { Lazy_exact_Ex_Cst (const ET & e) : Lazy_exact_rep(to_interval(e)) { this->et = new ET(e); } void update_exact() { CGAL_assertion(false); } }; // Construction from a Lazy_exact_nt (which keeps the lazyness). template struct Lazy_lazy_exact_Cst : public Lazy_exact_rep { Lazy_lazy_exact_Cst (const Lazy_exact_nt &x) : Lazy_exact_rep(x.approx()), l(x) {} void update_exact() { this->et = new ET(l.exact()); } Lazy_exact_nt l; }; // Unary operations: abs, sqrt, square. // Binary operations: +, -, *, /, min, max. // Base unary operation template struct Lazy_exact_unary : public Lazy_exact_rep { const Lazy_exact_nt op1; Lazy_exact_unary (const Interval_nt &i, const Lazy_exact_nt &a) : Lazy_exact_rep(i), op1(a) {} }; // Base binary operation template struct Lazy_exact_binary : public Lazy_exact_unary { const Lazy_exact_nt op2; Lazy_exact_binary (const Interval_nt &i, const Lazy_exact_nt &a, const Lazy_exact_nt &b) : Lazy_exact_unary(i, a), op2(b) {} }; // Here we could use a template class for all operations (STL provides // function objects plus, minus, multiplies, divides...). But it would require // a template template parameter, and GCC 2.95 seems to crash easily with them. // Macro for unary operations #define CGAL_LAZY_UNARY_OP(OP, NAME) \ template \ struct NAME : public Lazy_exact_unary \ { \ NAME (const Lazy_exact_nt &a) \ : Lazy_exact_unary(OP(a.approx()), a) {} \ \ void update_exact() { this->et = new ET(OP(this->op1.exact())); } \ }; CGAL_LAZY_UNARY_OP(CGAL::opposite, Lazy_exact_Opp) CGAL_LAZY_UNARY_OP(CGAL_NTS abs, Lazy_exact_Abs) CGAL_LAZY_UNARY_OP(CGAL_NTS square, Lazy_exact_Square) CGAL_LAZY_UNARY_OP(CGAL::sqrt, Lazy_exact_Sqrt) // A macro for +, -, * and / #define CGAL_LAZY_BINARY_OP(OP, NAME) \ template \ struct NAME : public Lazy_exact_binary \ { \ NAME (const Lazy_exact_nt &a, const Lazy_exact_nt &b) \ : Lazy_exact_binary(a.approx() OP b.approx(), a, b) {} \ \ void update_exact() \ { \ this->et = new ET(this->op1.exact() OP this->op2.exact()); \ } \ }; CGAL_LAZY_BINARY_OP(+, Lazy_exact_Add) CGAL_LAZY_BINARY_OP(-, Lazy_exact_Sub) CGAL_LAZY_BINARY_OP(*, Lazy_exact_Mul) CGAL_LAZY_BINARY_OP(/, Lazy_exact_Div) // Minimum template struct Lazy_exact_Min : public Lazy_exact_binary { Lazy_exact_Min (const Lazy_exact_nt &a, const Lazy_exact_nt &b) : Lazy_exact_binary(min(a.approx(), b.approx()), a, b) {} void update_exact() { this->et = new ET(min(this->op1.exact(), this->op2.exact())); } }; // Maximum template struct Lazy_exact_Max : public Lazy_exact_binary { Lazy_exact_Max (const Lazy_exact_nt &a, const Lazy_exact_nt &b) : Lazy_exact_binary(max(a.approx(), b.approx()), a, b) {} void update_exact() { this->et = new ET(max(this->op1.exact(), this->op2.exact())); } }; // The real number type, handle class template class Lazy_exact_nt : public Handle { public : typedef typename Number_type_traits::Has_gcd Has_gcd; typedef typename Number_type_traits::Has_division Has_division; typedef typename Number_type_traits::Has_sqrt Has_sqrt; typedef typename Number_type_traits::Has_exact_sqrt Has_exact_sqrt; typedef typename Number_type_traits::Has_exact_division Has_exact_division; typedef typename Number_type_traits::Has_exact_ring_operations Has_exact_ring_operations; typedef Lazy_exact_nt Self; typedef Lazy_exact_rep Self_rep; // Lazy_exact_nt () {} // Handle is not such a nice stuff... at the moment. Lazy_exact_nt (Self_rep *r) { PTR = r; } // Operations Lazy_exact_nt (double d) { PTR = new Lazy_exact_Cst(d); } Lazy_exact_nt (int i = 0) { PTR = new Lazy_exact_Int_Cst(i); } Lazy_exact_nt (const ET & e) { PTR = new Lazy_exact_Ex_Cst(e); } template Lazy_exact_nt (const Lazy_exact_nt &x) { PTR = new Lazy_lazy_exact_Cst(x); } Self operator- () const { return new Lazy_exact_Opp(*this); } const Interval_nt& approx() const { return ptr()->approx(); } Interval_nt interval() const { const Interval_nt& i = ptr()->approx(); return Interval_nt(i.inf(), i.sup()); } Interval_nt_advanced approx_adv() const { return ptr()->approx(); } const ET & exact() const { return ptr()->exact(); } static const double & get_relative_precision_of_to_double() { return relative_precision_of_to_double; } static void set_relative_precision_of_to_double(const double & d) { CGAL_assertion(d > 0 && d < 1); relative_precision_of_to_double = d; } bool fit_in_double(double &r) const { // Returns true if the value is representable by a double and to_double() // would return it. False means "don't know". r = approx().inf(); return approx().is_point(); } private: Self_rep * ptr() const { return (Self_rep*) PTR; } static double relative_precision_of_to_double; }; template double Lazy_exact_nt::relative_precision_of_to_double = 0.00001; template bool operator<(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { std::pair res = Certified::operator<(a.approx(), b.approx()); if (res.second) return res.first; return a.exact() < b.exact(); } template bool operator==(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { std::pair res = Certified::operator==(a.approx(), b.approx()); if (res.second) return res.first; return a.exact() == b.exact(); } template inline bool operator>(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return b < a; } template inline bool operator<=(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return ! (b < a); } template inline bool operator>=(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return ! (a < b); } template inline bool operator!=(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return ! (a == b); } // Mixed operators with int. template bool operator<(int a, const Lazy_exact_nt& b) { std::pair res = Certified::operator<(a, b.approx()); if (res.second) return res.first; return a < b.exact(); } template bool operator<(const Lazy_exact_nt& a, int b) { std::pair res = Certified::operator<(a.approx(), b); if (res.second) return res.first; return a.exact() < b; } template bool operator==(int a, const Lazy_exact_nt& b) { std::pair res = Certified::operator==(a, b.approx()); if (res.second) return res.first; return a == b.exact(); } template inline bool operator==(const Lazy_exact_nt& a, int b) { return b == a; } template inline bool operator>(int a, const Lazy_exact_nt& b) { return b < a; } template inline bool operator>(const Lazy_exact_nt& a, int b) { return b < a; } template inline bool operator<=(int a, const Lazy_exact_nt& b) { return ! (b < a); } template inline bool operator<=(const Lazy_exact_nt& a, int b) { return ! (b < a); } template inline bool operator>=(int a, const Lazy_exact_nt& b) { return ! (a < b); } template inline bool operator>=(const Lazy_exact_nt& a, int b) { return ! (a < b); } template inline bool operator!=(int a, const Lazy_exact_nt& b) { return ! (a == b); } template inline bool operator!=(const Lazy_exact_nt& a, int b) { return ! (b == a); } template Lazy_exact_nt operator+(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return new Lazy_exact_Add(a, b); } template Lazy_exact_nt operator-(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return new Lazy_exact_Sub(a, b); } template Lazy_exact_nt operator*(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return new Lazy_exact_Mul(a, b); } template Lazy_exact_nt operator/(const Lazy_exact_nt& a, const Lazy_exact_nt& b) { return new Lazy_exact_Div(a, b); } // mixed operators template Lazy_exact_nt operator+(const Lazy_exact_nt& a, int b) { return new Lazy_exact_Add(a, b); } template Lazy_exact_nt operator-(const Lazy_exact_nt& a, int b) { return new Lazy_exact_Sub(a, b); } template Lazy_exact_nt operator*(const Lazy_exact_nt& a, int b) { return new Lazy_exact_Mul(a, b); } template Lazy_exact_nt operator/(const Lazy_exact_nt& a, int b) { return new Lazy_exact_Div(a, b); } template Lazy_exact_nt operator+(int a, const Lazy_exact_nt& b) { return new Lazy_exact_Add(a, b); } template Lazy_exact_nt operator-(int a, const Lazy_exact_nt& b) { return new Lazy_exact_Sub(a, b); } template Lazy_exact_nt operator*(int a, const Lazy_exact_nt& b) { return new Lazy_exact_Mul(a, b); } template Lazy_exact_nt operator/(int a, const Lazy_exact_nt& b) { return new Lazy_exact_Div(a, b); } template double to_double(const Lazy_exact_nt & a) { const Interval_nt& app = a.approx(); if (app.sup() == app.inf()) return app.sup(); // If it's precise enough, then OK. if ((app.sup() - app.inf()) < Lazy_exact_nt::get_relative_precision_of_to_double() * std::max(std::fabs(app.inf()), std::fabs(app.sup())) ) return CGAL::to_double(app); // Otherwise we trigger exact computation first, // which will refine the approximation. a.exact(); return CGAL::to_double(a.approx()); } template inline std::pair to_interval(const Lazy_exact_nt & a) { return a.approx().pair(); } template inline Sign sign(const Lazy_exact_nt & a) { std::pair res = Certified::sign(a.approx()); if (res.second) return res.first; return CGAL_NTS sign(a.exact()); } template inline Comparison_result compare(const Lazy_exact_nt & a, const Lazy_exact_nt & b) { std::pair res = Certified::compare(a.approx(), b.approx()); if (res.second) return res.first; return CGAL_NTS compare(a.exact(), b.exact()); } template inline Lazy_exact_nt abs(const Lazy_exact_nt & a) { return new Lazy_exact_Abs(a); } template inline Lazy_exact_nt square(const Lazy_exact_nt & a) { return new Lazy_exact_Square(a); } template inline Lazy_exact_nt sqrt(const Lazy_exact_nt & a) { return new Lazy_exact_Sqrt(a); } template inline Lazy_exact_nt min(const Lazy_exact_nt & a, const Lazy_exact_nt & b) { return new Lazy_exact_Min(a, b); } template inline Lazy_exact_nt max(const Lazy_exact_nt & a, const Lazy_exact_nt & b) { return new Lazy_exact_Max(a, b); } template std::ostream & operator<< (std::ostream & os, const Lazy_exact_nt & a) { return os << CGAL::to_double(a); } template std::istream & operator>> (std::istream & is, Lazy_exact_nt & a) { ET e; is >> e; a = e; return is; } template inline Lazy_exact_nt & operator+=(Lazy_exact_nt & a, const Lazy_exact_nt & b) { return a = a + b; } template inline Lazy_exact_nt & operator-=(Lazy_exact_nt & a, const Lazy_exact_nt & b) { return a = a - b; } template inline Lazy_exact_nt & operator*=(Lazy_exact_nt & a, const Lazy_exact_nt & b) { return a = a * b; } template inline Lazy_exact_nt & operator/=(Lazy_exact_nt & a, const Lazy_exact_nt & b) { return a = a / b; } template inline Lazy_exact_nt & operator+=(Lazy_exact_nt & a, int b) { return a = a + b; } template inline Lazy_exact_nt & operator-=(Lazy_exact_nt & a, int b) { return a = a - b; } template inline Lazy_exact_nt & operator*=(Lazy_exact_nt & a, int b) { return a = a * b; } template inline Lazy_exact_nt & operator/=(Lazy_exact_nt & a, int b) { return a = a / b; } template inline bool is_finite(const Lazy_exact_nt & a) { return is_finite(a.approx()) || is_finite(a.exact()); } template inline bool is_valid(const Lazy_exact_nt & a) { return is_valid(a.approx()) || is_valid(a.exact()); } template inline io_Operator io_tag (const Lazy_exact_nt&) { return io_Operator(); } template struct converter > { static inline ET do_it (const Lazy_exact_nt & z) { return z.exact(); } }; template < typename ET > inline bool fit_in_double(const Lazy_exact_nt& l, double& r) { return l.fit_in_double(r); } CGAL_END_NAMESPACE #endif // CGAL_LAZY_EXACT_NT_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_cell_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000000610311344301500031443 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // Author(s) : Christophe Delage // cell of a triangulation of any dimension <=3 // with hidden points (for the regular triangulation) #ifndef CGAL_REGULAR_TRIANGULATION_CELL_BASE_3_H #define CGAL_REGULAR_TRIANGULATION_CELL_BASE_3_H #include #include CGAL_BEGIN_NAMESPACE template < typename GT, typename Cb = Triangulation_cell_base_3, typename C = std::list > class Regular_triangulation_cell_base_3 : public Cb { public: static const bool DO_HIDE_POINT = true; typedef typename Cb::Vertex_handle Vertex_handle; typedef typename Cb::Cell_handle Cell_handle; typedef GT Geom_traits; typedef typename Geom_traits::Weighted_point_3 Point; typedef C Point_container; typedef typename Point_container::iterator Point_iterator; typedef typename Point_container::const_iterator Point_const_iterator; template < typename TDS2 > struct Rebind_TDS { typedef typename Cb::template Rebind_TDS::Other Cb2; typedef Regular_triangulation_cell_base_3 Other; }; Regular_triangulation_cell_base_3() : Cb() {} Regular_triangulation_cell_base_3(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3) : Cb(v0, v1, v2, v3) {} Regular_triangulation_cell_base_3(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Cell_handle& n0, const Cell_handle& n1, const Cell_handle& n2, const Cell_handle& n3) : Cb(v0, v1, v2, v3, n0, n1, n2, n3) {} Point_iterator hidden_points_begin() { return _hidden.begin(); } Point_iterator hidden_points_end() { return _hidden.end(); } Point_const_iterator hidden_points_begin() const { return _hidden.begin(); } Point_const_iterator hidden_points_end() const { return _hidden.end(); } void hide_point (const Point &p) { _hidden.push_back(p); } // void unhide_point (Point_iterator i) { _hidden.delete(i); } private: Point_container _hidden; }; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_CELL_BASE_3_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_triangle_point_location.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_triangle_point_loca0000644000175000017500000003571611344301500031427 0ustar debiandebian// Copyright (c) 2004 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_triangle_point_location.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Idit Haran #ifndef CGAL_PM_TRIANGLE_POINT_LOCATION_C #define CGAL_PM_TRIANGLE_POINT_LOCATION_C #include //#define CGAL_PM_DEBUG CGAL_BEGIN_NAMESPACE //debug #ifdef CGAL_PM_DEBUG int point_number = 0; int constr_number = 0; #endif //---------------------------------------------------- /*! */ //if unbounded face - returns NULL or some edge on unbounded face //if its a vertex returns a halfedge pointing _at_ it template typename Pm_triangle_point_location::Halfedge_const_handle Pm_triangle_point_location:: locate(const typename Planar_map::Traits::Point_2 & p, Locate_type & lt) const { #ifdef CGAL_PM_DEBUG point_number++; std::cout << std::endl << "LOCATE NUMBER "<< point_number << std::endl; std::cout << "------ locate point "<< p << std::endl; #endif //init output Face_handle f = pm->unbounded_face(), last = pm->faces_end(); // invariant: p always lies in f's interior or holes Halfedge_handle e = pm->halfedges_end(); // closest halfedge so far lt = Planar_map::UNBOUNDED_FACE; //init CDT if (! updated_cdt) { std::cout << "ERROR: CDT is not updated !" << std::endl; return e; } //assert(cdt.is_valid()); //locate in the CDT CDT_Point p1 = static_cast (p); //CDT_Face_handle fh1 = cdt.locate(p1); //locate point //fh1->info() = CGAL::YELLOW; //update the face's color //locate point int li; CDT_Locate_type cdt_lt; CDT_Face_handle fh = cdt.locate(p1,cdt_lt,li); switch(cdt_lt) { case CDT::OUTSIDE_AFFINE_HULL: case CDT::OUTSIDE_CONVEX_HULL: lt = Planar_map::UNBOUNDED_FACE; #ifdef CGAL_PM_DEBUG std::cout << "unbounded face" << std::endl; #endif return e; case CDT::VERTEX: { #ifdef CGAL_PM_DEBUG std::cout << "locate type = vertex"<

  • vertex(li)->info(); e = vertex_found->incident_halfedges(); lt = Planar_map::VERTEX; #ifdef CGAL_PM_DEBUG std::cout << "vertex is "<< vertex_found->point() << std::endl; std::cout << "e = "<< e->source()->point() <<" towards "<< e->target()->point() << std::endl; #endif return e; } case CDT::EDGE: { #ifdef CGAL_PM_DEBUG std::cout << "locate type = edge"<
  • point() << std::endl; do { //std::cout << "edge = "<< (*circ1).curve() << std::endl; //std::cout << "source = "<source()->point() << std::endl; //std::cout << "target = "<target()->point() << std::endl; if (v2_of_edge == circ1->source()) { e = circ1; #ifdef CGAL_PM_DEBUG std::cout << "e = "<< e->source()->point() <<" towards "<< e->target()->point() << std::endl; #endif } } while (++circ1 != circ1_done); //check if e is valid #ifdef CGAL_PM_DEBUG if (pm->halfedges_end() == e) std::cout << "ERROR: e is invalid " << std::endl; #endif return e; // ???? } //if the edge is not a constrained - its not an edge of the //plannar map, which means we're inside of a pm face - //lets look at the face as if it was a face case. // no break - continue to the face caes } case CDT::FACE: lt = Planar_map::FACE; break; } //we're in case CDT::FACE #ifdef CGAL_PM_DEBUG std::cout << "FACE " << std::endl; #endif //get 3 pm vertices of face Vertex_handle v0 = fh->vertex(0)->info(); Vertex_handle v1 = fh->vertex(1)->info(); Vertex_handle v2 = fh->vertex(2)->info(); //find the face in the pm correspond to the 3 vertices Halfedge_around_vertex_circulator havc0 = v0->incident_halfedges(); Halfedge_around_vertex_circulator havc0_done (havc0); Halfedge_around_vertex_circulator havc1 = v1->incident_halfedges(); Halfedge_around_vertex_circulator havc1_done (havc1); Halfedge_around_vertex_circulator havc2 = v2->incident_halfedges(); Halfedge_around_vertex_circulator havc2_done (havc2); #ifdef CGAL_PM_DEBUG //printings, debugging std::cout << "Halfedges incident to " << v0->point() << std::endl; do { std::cout << (*havc0).curve() << std::endl; } while (++havc0 != havc0_done); std::cout << "Halfedges incident to " << v1->point() << std::endl; do { std::cout << (*havc1).curve() << std::endl; } while (++havc1 != havc1_done); std::cout << "Halfedges incident to " << v2->point() << std::endl; do { std::cout << (*havc2).curve() << std::endl; } while (++havc2 != havc2_done); #endif //CGAL_PM_DEBUG //loop to find face Face_iterator found_face = pm->unbounded_face(); bool found = false; bool found_unbounded = false; do { //get face from halfedge Face_iterator f0 = (*havc0).face(); //printf ("f0 = %e \n", f0); //Pm_Face_iterator f0_2 = (*havc0).twin().face(); do { Face_iterator f1 = (*havc1).face(); //printf ("f1 = %e \n", f0); if ( f0 == f1 ) { #ifdef CGAL_PM_DEBUG std::cout <<"f0 == f1"<< std::endl; #endif do { Face_iterator f2 = (*havc2).face(); if ( f1 == f2 ) { #ifdef CGAL_PM_DEBUG std::cout << "f1 == f2"<< std::endl; #endif if (found_face != f0) { found_face = f0; e = havc0; //!!! this is the relevant update for the PL !!! found = true; } else found_unbounded = true; } //printf ("f2 = %e \n", f0); } while ((++havc2 != havc2_done) && !found ); } } while ((++havc1 != havc1_done)&& !found ); } while ((++havc0 != havc0_done)&& !found ); if (found_face == pm->unbounded_face()) { if (! found_unbounded) { std::cerr<< "NOT GOOD - face not found" << std::endl; //debug - print some more info std::cout << "p = "<< p <outer_ccb(); Ccb_halfedge_circulator ccb_end = ccb; do { std::cout << ccb->source()->point()<<" towards " << ccb->target()->point()<target()->point() << std::endl; #endif //CGAL_PM_DEBUG return e; } //---------------------------------------------------- /*! */ template typename Pm_triangle_point_location::Halfedge_handle Pm_triangle_point_location:: locate(const typename Planar_map::Traits::Point_2 & p, Locate_type & lt) { // if (! updated_cdt) // triangulate_pm(); // assert(cdt.is_valid()); Halfedge_handle h = Halfedge_handle_unconst(((cPLp)this)->locate(p,lt)); return h; } //---------------------------------------------------- /*! */ template typename Pm_triangle_point_location::Halfedge_const_handle Pm_triangle_point_location:: vertical_ray_shoot(const typename Planar_map::Traits::Point_2 & p, Locate_type & lt, bool up) const { std::cout << "ERROR: Vertical ray shoot NOT suppored in CDT point location" << std::endl; CGAL_precondition_msg(false, "Vertical ray shoot NOT suppored in CDT point location"); assert(false); Halfedge_handle e = pm->halfedges_end(); // closest halfedge so far lt = Planar_map::UNBOUNDED_FACE; return e; } //---------------------------------------------------- /*! */ template typename Pm_triangle_point_location::Halfedge_handle Pm_triangle_point_location:: vertical_ray_shoot(const typename Planar_map::Traits::Point_2 & p, Locate_type & lt, bool up) { Halfedge_handle h = Halfedge_handle_unconst(((cPLp)this)->vertical_ray_shoot(p,lt,up)); return h; } //---------------------------------------------------- /*! insert an halfedge to the plannar map - insert it as a constraint to the CDT */ template void Pm_triangle_point_location::insert_to_cdt (Halfedge_handle hh, const typename Planar_map::Traits::X_monotone_curve_2 &cv) { #ifdef CGAL_PM_DEBUG constr_number++; std::cout << "in insert_to_cdt, num = "<< constr_number << std::endl ; //std::cout << *pm << std::endl; std::cout << "cv = "<< cv << std::endl; std::cout << hh->source()->point()<<" towards " << hh->target()->point()<< std::endl; #endif //CGAL_PM_DEBUG Vertex_handle pm_vh1 = hh->source(); Vertex_handle pm_vh2 = hh->target(); //get points from vertices typename Planar_map::Traits::Point_2 pm_p1 = (*pm_vh1).point() ; typename Planar_map::Traits::Point_2 pm_p2 = (*pm_vh2).point() ; //cast the points to be CDT points CDT_Point cdt_p1 = static_cast (pm_p1); CDT_Point cdt_p2 = static_cast (pm_p2); //check if source point is equal to destination point if (traits->point_equal(pm_p1, pm_p2)) { std::cerr << "WARNING: source point is equal to destination point!!! " << std::endl ; CDT_Vertex_handle cdt_vh1 = cdt.insert(cdt_p1); cdt_vh1->info() = pm_vh1; return; } //insert vertices to the CDT CDT_Vertex_handle cdt_vh1 = cdt.insert(cdt_p1); CDT_Vertex_handle cdt_vh2 = cdt.insert(cdt_p2); //connect new CDT vertex with Pm vertex cdt_vh1->info() = pm_vh1; cdt_vh2->info() = pm_vh2; #ifdef CGAL_PM_DEBUG std::cout << "call to insert_constraint with " << cdt_vh1->point() << cdt_vh2->point() << std::endl ; #endif //CGAL_PM_DEBUG //add constraint from the two points cdt.insert_constraint(cdt_vh1, cdt_vh2); #ifdef CGAL_PM_DEBUG std::cout << "finished insert_to_cdt" << std::endl ; #endif //CGAL_PM_DEBUG } //---------------------------------------------------- /*! triangulate the plannar map into a cdt (Constaint Delauney Triangulation) : go over all halfedges, and insert each halfedge as a constraint to the cdt. */ template void Pm_triangle_point_location::triangulate_pm() { #ifdef CGAL_PM_DEBUG std::cout << "in triangulate_pm" << std::endl ; //std::cout << *pm << std::endl; #endif cdt.clear(); //Go over plannar map, and create a triangulation of it Edge_iterator eit; #ifdef CGAL_PM_DEBUG std::cout << "All edges" << std::endl; #endif eit=pm->edges_begin(); // std::cout << "0" << std::endl; for (eit=pm->edges_begin(); eit != pm->edges_end(); eit++) { //std::cout << "1" << std::endl; //get vertices from edge Vertex_handle pm_vh1 = (*eit).source(); Vertex_handle pm_vh2 = (*eit).target(); // std::cout << "2" << std::endl; //get curve X_monotone_curve_2 cv = (*eit).curve(); // std::cout << "cv = "<< cv << std::endl; //get points from vertices typename Planar_map::Traits::Point_2 pm_p1 = (*pm_vh1).point() ; typename Planar_map::Traits::Point_2 pm_p2 = (*pm_vh2).point() ; // std::cout << "3" << std::endl; //cast the points to be CDT points CDT_Point cdt_p1 = static_cast (pm_p1); CDT_Point cdt_p2 = static_cast (pm_p2); //check if source point is equal to destination point if (traits->point_equal(pm_p1, pm_p2)) { std::cerr << "WARNING: source point is equal to destination point!!! " << pm_p1 << std::endl ; CDT_Vertex_handle cdt_vh1 = cdt.insert(cdt_p1); cdt_vh1->info() = pm_vh1; continue; } // std::cout << "4" << std::endl; //insert vertices to the CDT CDT_Vertex_handle cdt_vh1 = cdt.insert(cdt_p1); CDT_Vertex_handle cdt_vh2 = cdt.insert(cdt_p2); // std::cout << "5" << std::endl; //connect new CDT vertex with Pm vertex cdt_vh1->info() = pm_vh1; cdt_vh2->info() = pm_vh2; // std::cout << "6" << std::endl; // std::cout << "pm_p1 = "<< pm_p1 <<" , cdt_p1 = "<< cdt_p1 << std::endl; // std::cout << "pm_p2 = "<< pm_p2 <<" , cdt_p2 = "<< cdt_p2 << std::endl; //std::cout << "pm_vh1 = "<< pm_vh1 <<" , cdt_vh1 = "<< cdt_vh1 << std::endl; //std::cout << "pm_vh2 = "<< pm_vh2 <<" , cdt_vh2 = "<< cdt_vh2 << std::endl; //add constraint from the two points cdt.insert_constraint(cdt_vh1, cdt_vh2); //print // std::cout << "7" << std::endl; #ifdef CGAL_PM_DEBUG std::cout << "curve = " << cv ; std::cout << " , source = " << pm_p1 ; std::cout << " , target = " << pm_p2 << std::endl; #endif } //the triangulation is now updated updated_cdt = true; // --- printing and debugging of CDT // std::cout << "cdt is now updated" << std::endl; assert(cdt.is_valid()); #ifdef CGAL_PM_DEBUG int count = 0; for (CDT_Finite_edges_iterator eit = cdt.finite_edges_begin(); eit != cdt.finite_edges_end(); ++eit) if (cdt.is_constrained(*eit)) ++count; std::cout << "The number of resulting constrained edges is "; std::cout << count << std::endl; CDT_Finite_faces_iterator fc = cdt.finite_faces_begin(); for( ; fc != cdt.finite_faces_end(); ++fc) { fc->info() = CGAL::BLUE; } count=0; fc = cdt.finite_faces_begin(); for( ; fc != cdt.finite_faces_end(); ++fc) { count++; std::cout << "fc number "< #ifndef CGAL_APOLLONIUS_GRAPH_HIERARCHY_2_C #define CGAL_APOLLONIUS_GRAPH_HIERARCHY_2_C // class implementation //--------------------- CGAL_BEGIN_NAMESPACE template void Apollonius_graph_hierarchy_2:: init_hierarchy(const Geom_traits& gt) { hierarchy[0] = this; for(unsigned int i = 1; i < ag_hierarchy_2__maxlevel; ++i) { hierarchy[i] = new Apollonius_graph_base(gt); } } template Apollonius_graph_hierarchy_2:: Apollonius_graph_hierarchy_2(const Geom_traits& gt) : Apollonius_graph_base(gt), random((long)0) { init_hierarchy(gt); } // copy constructor duplicates vertices and faces template Apollonius_graph_hierarchy_2:: Apollonius_graph_hierarchy_2 (const Apollonius_graph_hierarchy_2& agh) : Apollonius_graph_base(agh.geom_traits()), random((long)0) { init_hierarchy(agh.geom_traits()); copy(agh); } //Assignement template Apollonius_graph_hierarchy_2 & Apollonius_graph_hierarchy_2:: operator=(const Apollonius_graph_hierarchy_2 &agh) { copy(agh); return *this; } template void Apollonius_graph_hierarchy_2:: copy (const Apollonius_graph_hierarchy_2 &agh) { std::map< Vertex_handle, Vertex_handle > V; for(unsigned int i = 0; i < ag_hierarchy_2__maxlevel; ++i) { // hierarchy[i]->copy_triangulation(*awvd.hierarchy[i]); *(hierarchy[i]) = *agh.hierarchy[i]; } //up and down have been copied in straightforward way // compute a map at lower level for( Finite_vertices_iterator it = hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) { if ( it->up() != Vertex_handle() ) V[ it->up()->down() ] = it; } for(unsigned int i = 1; i < ag_hierarchy_2__maxlevel; ++i) { for( Finite_vertices_iterator it = hierarchy[i]->finite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) { // down pointer goes in original instead in copied triangulation it->set_down(V[it->down()]); // make reverse link it->down()->set_up( it ); // make map for next level if ( it->up() != Vertex_handle() ) V[ it->up()->down() ] = it; } } } template Apollonius_graph_hierarchy_2:: ~Apollonius_graph_hierarchy_2() { clear(); for(unsigned int i = 1; i < ag_hierarchy_2__maxlevel; ++i) { delete hierarchy[i]; } } template void Apollonius_graph_hierarchy_2:: clear() { for(unsigned int i = 0; i < ag_hierarchy_2__maxlevel; ++i) { hierarchy[i]->clear(); } } template bool Apollonius_graph_hierarchy_2:: is_valid(bool verbose, int level) const { bool result(true); //verify correctness of triangulation at all levels for(unsigned int i = 0; i < ag_hierarchy_2__maxlevel; ++i) { if ( verbose ) { std::cerr << "Level " << i << ": " << std::flush; } result = result && hierarchy[i]->is_valid(verbose, level); if ( verbose ) { std::cerr << std::endl; } } //verify that lower level has no down pointers for( Finite_vertices_iterator it = hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) { result = result && ( it->down() == 0 ); } //verify that other levels has down pointer and reciprocal link is fine for(unsigned int i = 1; i < ag_hierarchy_2__maxlevel; ++i) { for( Finite_vertices_iterator it = hierarchy[i]->finite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) { #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE result = result && ( &*it == &*(it->down()->up()) ); #else result = result && ( it->down()->up() == it ); #endif } } return result; } template typename Apollonius_graph_hierarchy_2::Vertex_handle Apollonius_graph_hierarchy_2:: insert(const Site_2 &p) { int vertex_level = random_level(); size_type n = this->number_of_vertices(); Vertex_handle vertex; Vertex_handle vnear[ag_hierarchy_2__maxlevel]; typename Apollonius_graph_base::List l; typename Apollonius_graph_base::Face_map fm; typename Apollonius_graph_base::Vertex_map v_hidden; if ( n <= 2 ) { if ( n == 0 ) { vertex = insert_first(p); } else if ( n == 1 ) { vertex = insert_second(p); } else if ( n == 2 ) { vertex = insert_third(p); } // if it hidden just return it right away if ( vertex == Vertex_handle() ) { return vertex; } Vertex_handle previous = vertex; Vertex_handle first = vertex; int level = 1; while (level <= vertex_level ){ vertex = hierarchy[level]->insert(p, vnear[level]); vertex->set_down(previous); // link with level above previous->set_up(vertex); previous = vertex; level++; } return first; } int n_hidden = 0; // locate the nearest neighbor using hierarchy nearest_neighbor(p.point(), vnear); CGAL_assertion( vnear[0] != Vertex_handle() ); // check if it is hidden Site_2 wp_nearest = vnear[0]->site(); if ( is_hidden(wp_nearest, p) ) { vnear[0]->add_hidden_site(p); return Vertex_handle(); } // find the first conflict typename Apollonius_graph_base::Face_circulator fc_start = vnear[0]->incident_faces(); typename Apollonius_graph_base::Face_circulator fc = fc_start; Face_handle start_f; Sign s; do { Face_handle f(fc); s = incircle(f, p); if ( s == NEGATIVE ) { start_f = f; break; } ++fc; } while ( fc != fc_start ); if ( s != NEGATIVE ) { typename Apollonius_graph_base::Edge_circulator ec_start = vnear[0]->incident_edges(); typename Apollonius_graph_base::Edge_circulator ec = ec_start; bool interior_in_conflict(false); typename Apollonius_graph_base::Edge e; do { e = *ec; interior_in_conflict = edge_interior(e, p, false); if ( interior_in_conflict ) { break; } ++ec; } while ( ec != ec_start ); CGAL_assertion( interior_in_conflict ); vertex = insert_degree_2(e, p); // insert at other levels Vertex_handle previous = vertex; Vertex_handle first = vertex; int level = 1; while (level <= vertex_level ){ vertex = hierarchy[level]->insert(p, vnear[level]); vertex->set_down(previous); // link with level above previous->set_up(vertex); previous = vertex; level++; } return first; } initialize_conflict_region(start_f, l); expand_conflict_region(start_f, p, l, fm, v_hidden, NULL); n_hidden = v_hidden.size(); if ( n_hidden != 0 ) { int n_non_hidden = this->number_of_vertices() - n_hidden; if ( n_non_hidden < 2 ) { for(unsigned int i = 1; i < ag_hierarchy_2__maxlevel; ++i) { hierarchy[i]->clear(); } if ( n_non_hidden == 1 ) { Vertex_handle non_hidden; Finite_vertices_iterator vit = this->finite_vertices_begin(); do { non_hidden = Vertex_handle(vit); ++vit; } while ( v_hidden.find(non_hidden) != v_hidden.end() ); non_hidden->set_up( Vertex_handle() ); } } else { typename Apollonius_graph_base::Vertex_map::iterator it; for (it = v_hidden.begin(); it != v_hidden.end(); it++) { Vertex_handle v = (*it).first; Vertex_handle u = v->up(); if ( u != Vertex_handle() ) { v = u; u = v->up(); unsigned int l = 1; while ( true ) { hierarchy[l++]->remove(v); if ( u == Vertex_handle() ) break; if(l >= ag_hierarchy_2__maxlevel) { break; } v = u; u = v->up(); } } } } } // now really insert at level 0 vertex = retriangulate_conflict_region(p, l, fm, v_hidden); fm.clear(); v_hidden.clear(); // end of insertion at level 0 // insert at other levels Vertex_handle previous = vertex; Vertex_handle first = vertex; if ( n_hidden != 0 ) { nearest_neighbor(p.point(), vnear); } int level = 1; while (level <= vertex_level ){ vertex = hierarchy[level]->insert(p, vnear[level]); vertex->set_down(previous); // link with level above previous->set_up(vertex); previous = vertex; level++; } return first; } template void Apollonius_graph_hierarchy_2:: remove(Vertex_handle v) { CGAL_triangulation_precondition( v != Vertex_handle()); CGAL_triangulation_precondition( !is_infinite(v)); // get the hidden circles typename Apollonius_graph_base::Site_list wp_list; typename Vertex::Hidden_sites_iterator wpit; for (wpit = v->hidden_sites_begin(); wpit != v->hidden_sites_end(); ++wpit) { wp_list.push_back(*wpit); } v->clear_hidden_sites_container(); // do the actual removal Vertex_handle u = v->up(); unsigned int l = 0; while ( true ) { hierarchy[l++]->remove(v); if ( u == Vertex_handle() ) break; if(l >= ag_hierarchy_2__maxlevel) break; v = u; u = v->up(); } insert(wp_list.begin(), wp_list.end()); } template typename Apollonius_graph_hierarchy_2::Vertex_handle Apollonius_graph_hierarchy_2:: nearest_neighbor(const Point_2& p) const { Vertex_handle vnear[ag_hierarchy_2__maxlevel]; nearest_neighbor(p, vnear); return vnear[0]; } template void Apollonius_graph_hierarchy_2:: swap(Apollonius_graph_hierarchy_2& agh) { Ag_base* temp; Ag_base::swap(agh); for(unsigned int i = 1; i < ag_hierarchy_2__maxlevel; ++i){ temp = hierarchy[i]; hierarchy[i] = agh.hierarchy[i]; agh.hierarchy[i]= temp; } } template void Apollonius_graph_hierarchy_2:: nearest_neighbor(const Point_2& p, Vertex_handle vnear[ag_hierarchy_2__maxlevel]) const { Vertex_handle nearest = 0; unsigned int level = ag_hierarchy_2__maxlevel; // find the highest level with enough vertices while ( hierarchy[--level]->number_of_vertices() < ag_hierarchy_2__minsize ) { if ( !level ) break; // do not go below 0 } for (unsigned int i = level+1; i < ag_hierarchy_2__maxlevel; ++i) { vnear[i] = 0; } while ( level > 0 ) { vnear[level] = nearest = hierarchy[level]->nearest_neighbor(p, nearest); CGAL_assertion( !hierarchy[level]->is_infinite(vnear[level]) ); // go at the same vertex on level below nearest = nearest->down(); --level; } vnear[0] = hierarchy[level]->nearest_neighbor(p, nearest); // at level 0 } template int Apollonius_graph_hierarchy_2:: random_level() { unsigned int l = 0; while (1) { if ( random(ag_hierarchy_2__ratio) ) break; ++l; } if (l >= ag_hierarchy_2__maxlevel) l = ag_hierarchy_2__maxlevel -1; return l; } CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_HIERARCHY_2_C ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_vertex_bas0000644000175000017500000000453611344301500031402 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_ALPHA_SHAPE_VERTEX_BASE_2_H #define CGAL_ALPHA_SHAPE_VERTEX_BASE_2_H #include #include //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- template > class Alpha_shape_vertex_base_2 : public Vb { typedef typename Vb::Triangulation_data_structure TDS; public: typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Face_handle Face_handle; typedef typename Gt::FT Coord_type; typedef std::pair< Coord_type, Coord_type > Interval2; typedef typename Vb::Point Point; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Alpha_shape_vertex_base_2 Other; }; private: Interval2 I; public: Alpha_shape_vertex_base_2() : Vb() {} Alpha_shape_vertex_base_2(const Point & p) : Vb(p) {} Alpha_shape_vertex_base_2(const Point & p, Face_handle f) : Vb(p, f) {} public: inline Interval2 get_range() { return I; } inline void set_range(Interval2 Inter) { I = Inter; } }; //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif //ALPHA_SHAPE_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective_xy_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective0000644000175000017500000001143011344301500031462 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective_xy_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_CONVEX_HULL_PROJECTIVE_XY_TRAITS_2_H #define CGAL_CONVEX_HULL_PROJECTIVE_XY_TRAITS_2_H #include #include namespace CGAL { template class Less_xy_plane_xy_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.x(), p.y(), q.x(), q.y()) == SMALLER; } }; template class Equal_xy_plane_xy_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.x(), p.y(), q.x(), q.y()) == EQUAL; } }; template class Less_yx_plane_xy_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.y(), p.x(), q.y(), q.x()) == SMALLER; } }; template class Left_turn_plane_xy_2 { public: typedef bool result_type; typedef Arity_tag<3> Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return orientationC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()) == LEFT_TURN; } }; template class Less_dist_to_line_plane_xy_2 { public: typedef bool result_type; typedef Arity_tag<4> Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { Comparison_result res = cmp_signed_dist_to_lineC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y(), s.x(), s.y()); if ( res == LARGER ) return false; else if ( res == SMALLER ) return true; else return compare_lexicographically_xyC2(r.x(), r.y(), s.x(), s.y()) == SMALLER; } }; template class Less_rotate_ccw_plane_xy_2 { public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3& r, const Point_3& p, const Point_3& q) const { Orientation orient = orientationC2(r.x(), r.y(), p.x(), p.y(), q.x(), q.y()); if ( orient == LEFT_TURN ) return true; else if ( orient == RIGHT_TURN ) return false; else { if (p.x() == r.x() && p.y() == r.y()) return false; if (q.x() == r.x() && q.y() == r.y()) return true; if (p.x() == q.x() && p.y() == q.y()) return false; return collinear_are_ordered_along_lineC2(r.x(), r.y(), q.x(), q.y(), p.x(), p.y()); } } }; template class Convex_hull_projective_xy_traits_2 { public: typedef Point_3 Point_2; typedef Less_xy_plane_xy_2 Less_xy_2; typedef Equal_xy_plane_xy_2 Equal_2; typedef Less_yx_plane_xy_2 Less_yx_2; typedef Left_turn_plane_xy_2 Left_turn_2; typedef Less_rotate_ccw_plane_xy_2 Less_rotate_ccw_2; typedef Less_dist_to_line_plane_xy_2 Less_signed_distance_to_line_2; Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Equal_2 equal_2_object() const { return Equal_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Less_rotate_ccw_2 less_rotate_ccw_2_object() const { return Less_rotate_ccw_2(); } Less_signed_distance_to_line_2 less_signed_distance_to_line_2_object() const { return Less_signed_distance_to_line_2(); } }; } #endif // CGAL_CONVEX_HULL_PROJECTIVE_XY_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/N_step_adaptor.h0000644000175000017500000000247511344301500030143 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/N_step_adaptor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete; use instead. #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sphere_3.h0000644000175000017500000000435011344301501026644 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sphere_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_SPHERE_3_H #define CGAL_SPHERE_3_H CGAL_BEGIN_NAMESPACE template class Sphere_3 : public R_::Kernel_base::Sphere_3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Kernel_base::Sphere_3 RSphere_3; public: typedef R_ R; Sphere_3() {} Sphere_3(const RSphere_3& s) : RSphere_3(s) {} Sphere_3(const Point_3& p, const FT& sq_rad, const Orientation& o = COUNTERCLOCKWISE) : RSphere_3(p, sq_rad, o) {} Sphere_3(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& u) : RSphere_3(p, q, r, u) {} Sphere_3(const Point_3& p, const Point_3& q, const Point_3& r, const Orientation& o = COUNTERCLOCKWISE) : RSphere_3(p, q, r, o) {} Sphere_3(const Point_3& p, const Point_3& q, const Orientation& o = COUNTERCLOCKWISE) : RSphere_3(p, q, o) {} Sphere_3(const Point_3& p, const Orientation& o = COUNTERCLOCKWISE) : RSphere_3(p, o) {} }; CGAL_END_NAMESPACE #endif // CGAL_SPHERE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_traits_2.h0000644000175000017500000003733711344301500031263 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Efi Fogel // Ron Wein #ifndef CGAL_ARR_SEGMENT_EXACT_TRAITS_H #define CGAL_ARR_SEGMENT_EXACT_TRAITS_H #include #include #include CGAL_BEGIN_NAMESPACE template class Arr_segment_traits_2 : public Pm_segment_traits_2 { public: typedef Kernel_ Kernel; typedef int Info_face; typedef int Info_edge; typedef int Info_vertex; typedef Pm_segment_traits_2 Base; typedef typename Base::Has_left_category Has_left_category; typedef typename Base::Has_reflect_category Has_reflect_category; typedef typename Base::Point_2 Point_2; typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; typedef X_monotone_curve_2 Curve_2; typedef typename Kernel::Assign_2 Assign_2; // Obsolete, for backward compatibility typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; protected: typedef typename Kernel::Construct_vertex_2 Construct_vertex_2; typedef typename Kernel::Construct_segment_2 Construct_segment_2; typedef typename Kernel::Compare_x_2 Compare_x_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Compare_xy_2 Compare_xy_2; typedef typename Kernel::Compare_y_at_x_2 Compare_y_at_x_2; typedef typename Kernel::Is_vertical_2 Is_vertical_2; typedef typename Kernel::Equal_2 Equal_2; typedef typename Kernel::Orientation_2 Orientation_2; typedef typename Kernel::Construct_object_2 Construct_object_2; public: #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Kernel::construct_opposite_segment_2_object; using Kernel::equal_2_object; using Kernel::construct_vertex_2_object; using Kernel::intersect_2_object; using Kernel::assign_2_object; using Kernel::compare_xy_2_object; using Kernel::compare_x_2_object; using Kernel::compare_y_2_object; using Kernel::construct_object_2_object; using Kernel::orientation_2_object; using Kernel::is_vertical_2_object; using Kernel::has_on_2_object; using Kernel::construct_line_2_object; using Kernel::construct_segment_2_object; #endif /*! * Default constructor. */ Arr_segment_traits_2() : Base() {} /*! * Check whether the curve is x-monotone. * \return (true) if the given curve is an x-monotone curve; * (false) otherwise. * For segments, this is always true */ bool is_x_monotone(const Curve_2 &) const { return (true); } /*! * Split the given curve into x-monotone subcurves and insert them to * the given output iterator. Since segments are x-monotone, the output * iterator will eventually contain a single curve. * \param cv the input curve * \param o the output iterator * \return the past-the-end iterator */ template OutputIterator curve_make_x_monotone(const Curve_2 & cv, OutputIterator o) const { *o++ = cv; return o; } /*! * Flip a given curve. * \param cv The curve * \return A segment with source and target point interchanged. */ X_monotone_curve_2 curve_opposite(const X_monotone_curve_2 & cv) const { return construct_opposite_segment_2_object()(cv); } /*! * Split a given curve at a given split point into two sub-curves. * \param cv The curve to split * \param c1 The output first part of the split curve. * Its source is the source of the original curve. * \param c2 The output second part of the split curve. * Its target is the target of the original curve. * \param split_pt A point on cv. * \pre split_pt is on cv but is not an endpoint. */ void curve_split (const X_monotone_curve_2 & cv, X_monotone_curve_2 & c1, X_monotone_curve_2 & c2, const Point_2 & split_pt) const { //split curve at split point (x coordinate) into c1 and c2 CGAL_precondition(curve_compare_y_at_x(split_pt, cv) == EQUAL); CGAL_precondition_code(Equal_2 is_equal = equal_2_object()); CGAL_precondition(!is_equal(curve_source(cv), split_pt)); CGAL_precondition(!is_equal(curve_target(cv), split_pt)); Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & source = construct_vertex(cv, 0); const Point_2 & target = construct_vertex(cv, 1); Construct_segment_2 construct_segment = construct_segment_2_object(); c1 = construct_segment(source, split_pt); c2 = construct_segment(split_pt, target); } /*! * Find the nearest intersection of the two given curves to the right of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the right of the reference point (that is, whose * left endpoint is the projection of the reference point onto the * overlapping subcurve). * \param c1 The first curve. * \param c2 The second curve. * \param pt The refernece point. * \return An empty object if there is no intersection to the right of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_right(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt) const { Object res = intersect_2_object()(c1, c2); // There is no intersection: if (res.is_empty()) return (res); // Chack if the intersection is a point: Assign_2 assign_f = assign_2_object(); Point_2 p; if (assign_f(p, res)) { // If the intersection is a point, return it if its to the right. if (compare_xy_2_object()(p, pt) == LARGER) return (res); // Otherwise, return the empty object return Object(); } // The intersection is a segment: X_monotone_curve_2 seg; if (assign_f(seg, res)) { Construct_vertex_2 construct_vertex_f = construct_vertex_2_object(); const Point_2 & src = construct_vertex_f (seg, 0); const Point_2 & trg = construct_vertex_f (seg, 1); Compare_xy_2 compare_xy_f = compare_xy_2_object(); Comparison_result src_pt = compare_xy_f(src, pt); Comparison_result trg_pt = compare_xy_f(trg, pt); /* If the subcurve is completely to the right, return it. Notice that * the case src_pt == EQUAL && trg_pt == EQUAL is impossible, cause * src and trg must be different! */ if (src_pt != SMALLER && trg_pt != SMALLER) return (res); // The target is to the left and the source is to the right. // Trim the trg: if (trg_pt == SMALLER && src_pt == LARGER) { Point_2 p1 = _vertical_ray_shoot (pt, c1); Construct_object_2 construct_object_f = construct_object_2_object(); if (equal_2_object() (p1, src)) return (construct_object_f(src)); else return (construct_object_f(X_monotone_curve_2(p1, src))); } // The source is to the left and the target is to the right. // Trim the src: if (src_pt == SMALLER && trg_pt == LARGER) { Point_2 p1 = _vertical_ray_shoot (pt, c1); Construct_object_2 construct_object_f = construct_object_2_object(); if (equal_2_object() (p1, trg)) return (construct_object_f(trg)); else return (construct_object_f(X_monotone_curve_2(p1, trg))); } // The subcurve is completely to the left: return Object(); } // The curves do not intersect: return Object(); } /*! * Find the nearest intersection of the two given curves to the left of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the left of the reference point (that is, whose * right endpoint is the projection of the reference point onto the * overlapping subcurve). * \param c1 The first curve. * \param c2 The second curve. * \param pt The refernece point. * \return An empty object if there is no intersection to the left of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_left(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt) const { Object res = intersect_2_object()(c1, c2); // There is no intersection: if (res.is_empty()) return (res); // Intersection is a point: Assign_2 assign_f = assign_2_object(); Point_2 p; if (assign_f(p, res)) { // If the intersection is a point, return it if its to the right. if (compare_xy_2_object()(p, pt) == SMALLER) return (res); // Otherwise, return the empty object return Object(); } // Check if the intersection is a segment: X_monotone_curve_2 seg; if (assign_f(seg, res)) { // the intersection is a segment: Construct_vertex_2 construct_vertex_f = construct_vertex_2_object(); const Point_2 & src = construct_vertex_f (seg, 0); const Point_2 & trg = construct_vertex_f (seg, 1); Compare_xy_2 compare_xy_f = compare_xy_2_object(); Comparison_result src_pt = compare_xy_f (src, pt); Comparison_result trg_pt = compare_xy_f (trg, pt); /* If the subcurve is completely to the right, return it. Notice that * the case src_pt == EQUAL && trg_pt == EQUAL is impossible, cause * src and trg must be different! */ if (src_pt != LARGER && trg_pt != LARGER) return (res); // The target is to the right and the source is to the left. // Trim the trg: if (trg_pt == LARGER && src_pt == SMALLER) { Point_2 p1 = _vertical_ray_shoot (pt, c1); Construct_object_2 construct_object_f = construct_object_2_object(); if (equal_2_object() (p1, src)) return (construct_object_f(src)); else return (construct_object_f(X_monotone_curve_2(src, p1))); } // The source is to the right and the target is to the left. // Trim the src: if (src_pt == LARGER && trg_pt == SMALLER) { Point_2 p1 = _vertical_ray_shoot (pt, c1); Construct_object_2 construct_object_f = construct_object_2_object(); if (equal_2_object() (p1, trg)) return (construct_object_f(trg)); else return (construct_object_f(X_monotone_curve_2(trg, p1))); } // The subcurve is completely to the right: return Object(); } // The curves do not intersect: return Object(); } /*! curves_overlap() test overlapping between two given curves * \patam c1 the first curve * \patam c2 the second curve * \return true if c1 and c2 overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, false. */ bool curves_overlap(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & src2 = construct_vertex(cv2, 0); const Point_2 & trg2 = construct_vertex(cv2, 1); const Point_2 & src1 = construct_vertex(cv1, 0); const Point_2 & trg1 = construct_vertex(cv1, 1); Orientation_2 orient = orientation_2_object(); if ((!orient(src1, trg1, src2) == COLLINEAR) || (!orient(src1, trg1, trg2) == COLLINEAR)) return false; Is_vertical_2 is_vertical = is_vertical_2_object(); if (is_vertical(cv1)) { if (is_vertical(cv2)) { Compare_y_2 compare_y = compare_y_2_object(); Comparison_result res_ss = compare_y (src1, src2); Comparison_result res_st = compare_y (src1, trg2); if (res_ss == SMALLER) { if (res_st == LARGER) return true; if (compare_y (trg1, src2) == LARGER) return true; return (compare_y (trg1, trg2) == LARGER); } if (res_ss == LARGER) { if (res_st == SMALLER) return true; if (compare_y (trg1, src2) == SMALLER) return true; return (compare_y (trg1, trg2) == SMALLER); } // res_ss == EQUAL if (res_st == SMALLER) return (compare_y (trg1, src2) == LARGER); return (compare_y (trg1, src2) == SMALLER); } return false; } if (is_vertical(cv2)) return false; Compare_x_2 compare_x = compare_x_2_object(); Comparison_result res_ss = compare_x (src1, src2); Comparison_result res_st = compare_x (src1, trg2); if (res_ss == SMALLER) { if (res_st == LARGER) return true; if (compare_x (trg1, src2) == LARGER) return true; return (compare_x (trg1, trg2) == LARGER); } if (res_ss == LARGER) { if (res_st == SMALLER) return true; if (compare_x (trg1, src2) == SMALLER) return true; return (compare_x (trg1, trg2) == SMALLER); } // res_ss == EQUAL if (res_st == SMALLER) return (compare_x (trg1, src2) == LARGER); return (compare_x (trg1, src2) == SMALLER); } private: /*! * Perform vertical ray-shooting from a given point towards a given curve. * \param pt The source point of the ray. * \param cv The target curve. * \return The resulting point. */ Point_2 _vertical_ray_shoot (const Point_2& pt, const X_monotone_curve_2& cv) const { // If the curve contains pt, return it. if (has_on_2_object() (cv, pt)) return (pt); // Construct a vertical line passing through pt. typename Kernel::Direction_2 dir (0, 1); typename Kernel::Line_2 vl = construct_line_2_object() (pt, dir); // Compute the intersetion between the vertical line and the given curve. Object res = intersect_2_object()(cv, vl); Point_2 ip; bool ray_shoot_successful = assign(ip, res); if (! ray_shoot_successful) CGAL_assertion (ray_shoot_successful); return (ip); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_verte0000644000175000017500000000355511344301501031467 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud // vertex of a combinatorial triangulation of any dimension <=3 #ifndef CGAL_TRIANGULATION_DS_VERTEX_3_H #define CGAL_TRIANGULATION_DS_VERTEX_3_H #include #include CGAL_BEGIN_NAMESPACE template < class Vb > struct Triangulation_ds_vertex_3 : public Vb { using Vb::cell; bool is_valid(bool verbose = false, int level = 0) const; }; // Should this be moved to TDS::is_valid(Vertex_handle, verbose, level) ? template < class Vb > bool Triangulation_ds_vertex_3::is_valid(bool verbose, int level) const { bool result = Vb::is_valid(verbose,level); // result = result && cell()->has_vertex(handle()); result = result && ( &*cell()->vertex(0) == this || &*cell()->vertex(1) == this || &*cell()->vertex(2) == this || &*cell()->vertex(3) == this ); if ( ! result ) { if ( verbose ) std::cerr << "invalid vertex" << std::endl; CGAL_triangulation_assertion(false); } return result; } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DS_VERTEX_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/kernel_basic.h0000644000175000017500000000300311344301500027606 0ustar debiandebian// Copyright (c) 1999,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/kernel_basic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_KERNEL_BASIC_H #define CGAL_KERNEL_BASIC_H #ifndef CGAL_KERNEL_INLINE # define CGAL_KERNEL_INLINE inline #endif #ifndef CGAL_KERNEL_MEDIUM_INLINE # define CGAL_KERNEL_MEDIUM_INLINE #endif #ifndef CGAL_KERNEL_LARGE_INLINE # define CGAL_KERNEL_LARGE_INLINE #endif #include #include #include #endif // CGAL_KERNEL_BASIC_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/In_place_list.h0000644000175000017500000005661711344301500027755 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/In_place_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_IN_PLACE_LIST_H #define CGAL_IN_PLACE_LIST_H 1 #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Define shorter names to please linker (g++/egcs) //#define In_place_list_iterator Ipli //#define In_place_list_const_iterator Iplci // Forward declarations namespace CGALi { template class In_place_list_iterator; template class In_place_list_const_iterator; } template class In_place_list; template < class T > class In_place_sl_list_base { public: T* next_link; // forward pointer }; template < class T > class In_place_list_base { public: T* next_link; // forward pointer T* prev_link; // backwards pointer friend class CGALi::In_place_list_iterator; friend class CGALi::In_place_list_const_iterator; friend class In_place_list; friend class In_place_list; }; namespace CGALi { template class In_place_list_iterator { // protected: // Made public for g++ 2.8 and egcs 2.90. They don't // accept the friend declarations below. public: T* node; public: // friend class In_place_list; // friend class In_place_list; typedef In_place_list_iterator Self; typedef In_place_list_base Base; typedef T value_type; typedef T* pointer; typedef T& reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; In_place_list_iterator() : node(0) {} In_place_list_iterator(T* x) : node(x) {} #if defined(__GNUC__) && (__GNUC__ < 3) // added by request of Michael Seel: In_place_list_iterator(const Self& i) { node=i.node; } Self& operator=(const Self& i) { node = i.node; return *this; } #endif bool operator==( const Self& x) const { return node == x.node; } bool operator!=( const Self& x) const { return node != x.node; } T& operator*() const { return *node; } T* operator->() const { return node; } Self& operator++() { node = ((Base*)(node))->next_link; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { node = ((Base*)(node))->prev_link; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; } namespace CGALi { template class In_place_list_const_iterator { // protected: // Made public for g++ 2.8 and egcs 2.90. They don't // accept the friend declarations below. public: const T* node; // It's not Ptr. Otherwise traversal won't work. public: // friend class In_place_list; // friend class In_place_list; typedef In_place_list_const_iterator Self; typedef In_place_list_iterator Iterator; typedef In_place_list_base Base; typedef T value_type; typedef const T* pointer; typedef const T& reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; In_place_list_const_iterator() : node(0) {} In_place_list_const_iterator( Iterator i) : node(&*i) {} In_place_list_const_iterator(const T* x) : node(x) {} #if defined(__GNUC__) && (__GNUC__ < 3) // added by request of Michael Seel: In_place_list_const_iterator(const Self& i) { node=i.node; } Self& operator=(const Self& i) { node = i.node; return *this; } #endif bool operator==( const Self& x) const { return node == x.node; } bool operator!=( const Self& x) const { return node != x.node; } const T& operator*() const { return *node; } const T* operator->() const { return node; } Self& operator++() { node = ((const Base*)(node))->next_link; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { node = ((const Base*)(node))->prev_link; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; } template class In_place_list { // Bidirectional List Managing Objects in Place // -------------------------------------------- // // DEFINITION An object of the class In_place_list is a // sequence that supports bidirectional iterators and allows constant time // insert and erase operations anywhere within the sequence. The // functionality is similar to the `list' in the STL. // // The In_place_list manages element items in place. Two // pointers `T*' are expected in the class. For example the base class // `In_place_list_base' can be used. // // The In_place_list does not copy element items during // insertion (unless otherwise stated for a function). On removal or // destruction of the list the element items are not deleted by default. // The second template parameter `bool' has to be set to `false' in this // case. If the In_place_list should take the responsibility // for the stored objects the `bool' parameter could be set to `true', in // which case the list will delete removed items and will delete all // remaining items on destruction. In any case, the `destroy()' member // function deletes all elements. // // On purpose, these two possible versions of In_place_list // are not assignment compatible to avoid confusions between the different // storage responsibilities. // // PARAMETERS // // The full classname is `In_place_list'. // // TYPES public: typedef Alloc Allocator; typedef Alloc allocator_type; // STL compliant // Note: the standard requires the following types to be equivalent // to T, T*, const T*, T&, const T&, size_t, and ptrdiff_t, respectively. // So we don't pass these types to the iterators explicitly. typedef typename Allocator::value_type value_type; typedef typename Allocator::pointer pointer; typedef typename Allocator::const_pointer const_pointer; typedef typename Allocator::reference reference; typedef typename Allocator::const_reference const_reference; typedef typename Allocator::size_type size_type; typedef typename Allocator::difference_type difference_type; typedef CGALi::In_place_list_iterator iterator; typedef CGALi::In_place_list_const_iterator const_iterator; typedef std::reverse_iterator< iterator > reverse_iterator; typedef std::reverse_iterator< const_iterator > const_reverse_iterator; typedef In_place_list Self; protected: Allocator allocator; pointer node; size_type length; // These are the only places where the allocator gets called. pointer get_node() { // was: return new T; pointer p = allocator.allocate(1); allocator.construct(p, value_type()); return p; } pointer get_node( const T& t) { // was: return new T(t); pointer p = allocator.allocate(1); allocator.construct(p, t); return p; } void put_node( pointer p) { // was: delete p; allocator.destroy( p); allocator.deallocate( p, 1); } public: // CREATION // // New creation variable is: `l' explicit In_place_list() : length(0) { // introduces an empty list. node = get_node(); (*node).next_link = node; (*node).prev_link = node; } void swap(Self& x) { std::swap(node, x.node); std::swap(length, x.length); } // ACCESS MEMBER FUNCTIONS allocator_type get_allocator() const { return allocator; } iterator begin() { return (*node).next_link; } const_iterator begin() const { return (*node).next_link; } iterator end() { return node; } const_iterator end() const { return node; } reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } bool empty() const { return length == 0; } size_type size() const { return length; } size_type max_size() const { return size_type(-1); } reference front() { return *begin(); } const_reference front() const { return *begin(); } reference back() { return *(--end()); } const_reference back() const { return *(--end()); } // INSERTION iterator insert(iterator position, T& x) { // inserts `t' in front of iterator `pos'. The return value points // to the inserted item. x.next_link = position.node; x.prev_link = (*position.node).prev_link; (*((*position.node).prev_link)).next_link = &x; (*position.node).prev_link = &x; ++length; return &x; } iterator insert(T* pos, T& x) { return insert( iterator(pos), x); } void push_front(T& x) { insert(begin(), x); } // inserts an item in front of list `l'. void push_back(T& x) { insert(end(), x); } // inserts an item at the back of list `l'. void insert(iterator position, size_type n); // inserts n copies of `T()' in front of iterator `pos'. void insert(iterator position, size_type n, const T& x); // inserts n copies of `t' in front of iterator `pos'. void insert( T* pos, size_type n) { insert( iterator(pos), n); } void insert( T* pos, size_type n, const T& x) { insert( iterator(pos), n, x); } template void insert(iterator pos, InputIterator first, InputIterator last) { // inserts the range [`first, last') in front of iterator `pos'. while (first != last) insert(pos, *get_node(*first++)); } template void insert(T* pos, InputIterator first, InputIterator last) { // inserts the range [`first, last') in front of iterator `pos'. while (first != last) insert(pos, *get_node(*first++)); } void insert(T* pos, const T* first, const T* last) { insert( iterator(pos), const_iterator(first), const_iterator(last)); } // REMOVAL void erase(iterator i) { // removes the item from list `l', where `pos' refers to. CGAL_assertion( length > 0); (*((*i.node).prev_link)).next_link = (*i.node).next_link; (*((*i.node).next_link)).prev_link = (*i.node).prev_link; #ifdef __BORLANDC__ #pragma warn -8008 #pragma warn -8066 #endif if (managed) put_node(i.node); #ifdef __BORLANDC__ #pragma warn .8008 #pragma warn .8066 #endif --length; } void erase(T* pos) { erase( iterator( pos)); } void pop_front() { erase(begin()); } // removes the first item from list `l'. void pop_back() { // removes the last item from list `l'. iterator tmp = end(); erase(--tmp); } void erase(iterator first, iterator last); // removes the items in the range [`first, last') from list `l'. void erase(T* first, T* last) { erase( iterator(first), iterator(last)); } void clear() { erase( begin(), end()); } // CREATION (Continued) explicit In_place_list(size_type n, const T& value) : length(0) { // introduces a list with n items, all initialized with copies of // value. node = get_node(); (*node).next_link = node; (*node).prev_link = node; insert(begin(), n, value); } // Sylvain reported a problem with the default argument // on sunpro; hence, I took it out. explicit In_place_list(size_type n) : length(0) { // introduces a list with n items, all initialized with copies of // value. node = get_node(); (*node).next_link = node; (*node).prev_link = node; T t; insert(begin(), n, t); } template In_place_list( InputIterator first, InputIterator last) : length(0) { // a list with copies from the range [`first,last'). node = get_node(); (*node).next_link = node; (*node).prev_link = node; insert( begin(), first, last); } In_place_list(const T* first, const T* last) : length(0) { // a list with copies from the range [`first,last'). node = get_node(); (*node).next_link = node; (*node).prev_link = node; insert(begin(), first, last); } In_place_list(const Self& x) : length(0) { // copy constructor. Each item in `l1' is copied. node = get_node(); (*node).next_link = node; (*node).prev_link = node; insert(begin(), x.begin(), x.end()); } ~In_place_list() { erase(begin(), end()); put_node(node); } Self& operator=(const Self& x); void destroy(); template void assign( InputIterator first, InputIterator last) { erase( begin(), end()); insert( begin(), first, last); } void assign( size_type n, const T& t) { erase( begin(), end()); insert( begin(), n, t); } void resize( size_type sz, const T& c) { if ( sz > size()) insert( end(), sz - size(), c); else if ( sz < size()) { iterator i = begin(); while ( sz-- > 0) ++i; erase( i, end()); } // else do nothing } // Sylvain reported a problem with the default argument // on sunpro; hence, I took it out. void resize( size_type sz) { T t; resize( sz, t); } // COMPARISON OPERATIONS bool operator==( const Self& y) const { return size() == y.size() && std::equal(begin(), end(), y.begin()); } bool operator!=( const Self& y) const { return size() != y.size() || ! std::equal(begin(),end(),y.begin()); } bool operator<(const Self& y) const { return std::lexicographical_compare( begin(),end(), y.begin(),y.end()); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } // SPECIAL LIST OPERATIONS protected: void transfer(iterator position, iterator first, iterator last) { // move the range [`first, last') before the position. (*((*last.node).prev_link)).next_link = position.node; (*((*first.node).prev_link)).next_link = last.node; (*((*position.node).prev_link)).next_link = first.node; T* tmp = (*position.node).prev_link; (*position.node).prev_link = (*last.node).prev_link; (*last.node).prev_link = (*first.node).prev_link; (*first.node).prev_link = tmp; } public: void splice(iterator position, Self& x) { // inserts the list x before position `pos' and x becomes empty. // It takes constant time. Precondition: `&l != &x'. if (!x.empty()) { transfer(position, x.begin(), x.end()); length += x.length; x.length = 0; } } void splice(T* position, Self& x) { splice( iterator(position), x); } void splice( iterator position, Self& x, iterator i) { // inserts an element pointed to by i from list x before position // `pos' and removes the element from x. It takes constant time. i // is a valid dereferenceable iterator of x. The result is // unchanged if `pos == i' or `pos == ++i'. iterator j = i; if (position == i || position == ++j) return; transfer(position, i, j); ++length; --x.length; } void splice(T* position, Self& x, T* i) { splice( iterator(position), x, iterator(i)); } void splice(iterator pos, Self& x, iterator first, iterator last) { // inserts elements in the range [`first, last') before position // `pos' and removes the elements from x. It takes constant time // if `&x == $l'; otherwise, it takes linear time. [`first, // last') is a valid range in x. Precondition: `pos' is not in the // range [`first, last'). if (first != last) { if (&x != this) { difference_type n = std::distance(first, last); x.length -= n; length += n; } transfer(pos, first, last); } } void splice(T* p, Self& x, T* first, T* last) { splice( iterator(p), x, iterator(first), iterator(last)); } void remove(const T& value); // erases all elements e in the list l for which `e == value'. // It is stable. Precondition: a suitable `operator==' for the // type T. void reverse(); // reverses the order of the elements in `l' in linear time. void unique(); // erases all but the first element from every consecutive group // of equal elements in the list `l'. Precondition: a suitable // `operator==' for the type T. void merge(Self& x); // merges the list x into the list `l' and x becomes empty. It is // stable. Precondition: Both lists are increasingly sorted. A // suitable `operator<' for the type T. template < class StrictWeakOrdering > void merge(Self& x, StrictWeakOrdering ord) // merges the list x into the list `l' and x becomes empty. // It is stable. // Precondition: Both lists are increasingly sorted wrt. ord. { iterator first1 = begin(); iterator last1 = end(); iterator first2 = x.begin(); iterator last2 = x.end(); while (first1 != last1 && first2 != last2) if (ord(*first2, *first1)) { iterator next = first2; transfer(first1, first2, ++next); first2 = next; } else ++first1; if (first2 != last2) transfer(last1, first2, last2); length += x.length; x.length= 0; } void sort(); // sorts the list `l' according to the `operator<' in time O(n // log n) where `n = size()'. It is stable. Precondition: a // suitable `operator<' for the type T. template < class StrictWeakOrdering > void sort(StrictWeakOrdering ord) // sorts the list `l' according to ord in time O(n log n) // where `n = size()'. It is stable. { if (size() < 2) return; In_place_list carry; In_place_list counter[64]; int fill = 0; while (!empty()) { carry.splice(carry.begin(), *this, begin()); int i = 0; while(i < fill && !counter[i].empty()) { counter[i].merge(carry, ord); carry.swap(counter[i++]); } carry.swap(counter[i]); if (i == fill) ++fill; } for (int i = 1; i < fill; ++i) counter[i].merge(counter[i-1], ord); swap(counter[fill-1]); } }; template void In_place_list:: insert(CGALi::In_place_list_iterator position, size_type n) { while (n--) insert(position, *get_node()); } template void In_place_list:: insert(CGALi::In_place_list_iterator position, size_type n, const T& x) { while (n--) insert(position, *get_node(x)); } template void In_place_list:: erase(CGALi::In_place_list_iterator first, CGALi::In_place_list_iterator last) { while (first != last) erase(first++); } template In_place_list& In_place_list:: operator=(const In_place_list& x) { if (this != &x) { iterator first1 = begin(); iterator last1 = end(); const_iterator first2 = x.begin(); const_iterator last2 = x.end(); while (first1 != last1 && first2 != last2) { // Save the pointer values before assignment. // Assignment avoids unneccassary delete's and new's. T* tmp1 = (*first1).next_link; T* tmp2 = (*first1).prev_link; *first1 = *first2++; (*first1).next_link = tmp1; (*first1).prev_link = tmp2; ++first1; } if (first2 == last2) erase(first1, last1); else insert(last1, first2, last2); } return *this; } template void In_place_list:: destroy() { iterator first = begin(); iterator last = end(); while( first != last) { iterator i = first++; put_node(i.node); } length = 0; (*node).next_link = node; (*node).prev_link = node; } template void In_place_list::remove(const T& value) { iterator first = begin(); iterator last = end(); while (first != last) { iterator next = first; ++next; if (*first == value) erase(first); first = next; } } template void In_place_list::reverse() { if (size() < 2) return; for (iterator first = ++begin(); first != end();) { iterator old = first++; transfer(begin(), old, first); } } template void In_place_list::unique() { iterator first = begin(); iterator last = end(); if (first == last) return; iterator next = first; while (++next != last) { if (*first == *next) erase(next); else first = next; next = first; } } template void In_place_list::merge(In_place_list& x) { iterator first1 = begin(); iterator last1 = end(); iterator first2 = x.begin(); iterator last2 = x.end(); while (first1 != last1 && first2 != last2) if (*first2 < *first1) { iterator next = first2; transfer(first1, first2, ++next); first2 = next; } else ++first1; if (first2 != last2) transfer(last1, first2, last2); length += x.length; x.length= 0; } template void In_place_list::sort() { if (size() < 2) return; In_place_list carry; In_place_list counter[64]; int fill = 0; while (!empty()) { carry.splice(carry.begin(), *this, begin()); int i = 0; while(i < fill && !counter[i].empty()) { counter[i].merge(carry); carry.swap(counter[i++]); } carry.swap(counter[i]); if (i == fill) ++fill; } for (int i = 1; i < fill; ++i) counter[i].merge(counter[i-1]); swap(counter[fill-1]); } // Undef shorter names (g++/egcs) //#undef In_place_list_iterator //#undef In_place_list_const_iterator CGAL_END_NAMESPACE #endif // CGAL_IN_PLACE_LIST_H // // EOF // ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/interpolation_functions.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/interpolation_function0000644000175000017500000002532211344301500031543 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: // /CVSROOT/CGAL/Packages/Interpolation/include/CGAL/interpolation_functions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_INTERPOLATION_FUNCTIONS_H #define CGAL_INTERPOLATION_FUNCTIONS_H #include #include CGAL_BEGIN_NAMESPACE //Functor class for accessing the function values/gradients template< class Map > struct Data_access : public std::unary_function< typename Map::key_type, std::pair< typename Map::mapped_type, bool> > { typedef typename Map::mapped_type Data_type; typedef typename Map::key_type Key_type; Data_access< Map >(const Map& m): map(m){}; std::pair< Data_type, bool> operator()(const Key_type& p) const { typename Map::const_iterator mit = map.find(p); if(mit!= map.end()) return std::make_pair(mit->second, true); return std::make_pair(Data_type(), false); }; const Map& map; }; //the interpolation functions: template < class ForwardIterator, class Functor> typename Functor::result_type::first_type linear_interpolation(ForwardIterator first, ForwardIterator beyond, const typename std::iterator_traits::value_type:: second_type& norm, Functor function_value) { CGAL_precondition(norm>0); typedef typename Functor::result_type::first_type Value_type; Value_type result(0); typename Functor::result_type val; for(; first !=beyond; ++first){ val = function_value(first->first); CGAL_assertion(val.second); result += (first->second/norm) * val.first; } return result; } template < class ForwardIterator, class Functor, class GradFunctor, class Traits> std::pair< typename Functor::result_type::first_type, bool> quadratic_interpolation(ForwardIterator first, ForwardIterator beyond, const typename std::iterator_traits:: value_type::second_type& norm, const typename std::iterator_traits::value_type:: first_type& p, Functor function_value, GradFunctor function_gradient, const Traits& traits) { CGAL_precondition(norm >0); typedef typename Functor::result_type::first_type Value_type; Value_type result(0); typename Functor::result_type f; typename GradFunctor::result_type grad; for(; first !=beyond; ++first){ f = function_value(first->first); grad = function_gradient(first->first); //test if value and gradient are correctly retrieved: CGAL_assertion(f.second); if(!grad.second) return std::make_pair(Value_type(0), false); result += (first->second/norm) *( f.first + grad.first* traits.construct_scaled_vector_d_object() (traits.construct_vector_d_object()(first->first, p),0.5)); } return std::make_pair(result, true); } template < class ForwardIterator, class Functor, class GradFunctor, class Traits> std::pair< typename Functor::result_type::first_type, bool> sibson_c1_interpolation(ForwardIterator first, ForwardIterator beyond, const typename std::iterator_traits:: value_type::second_type& norm, const typename std::iterator_traits::value_type:: first_type& p, Functor function_value, GradFunctor function_gradient, const Traits& traits) { CGAL_precondition(norm >0); typedef typename Functor::result_type::first_type Value_type; typedef typename Traits::FT Coord_type; Coord_type term1(0), term2(term1), term3(term1), term4(term1); Value_type linear_int(0),gradient_int(0); typename Functor::result_type f; typename GradFunctor::result_type grad; for(; first !=beyond; ++first){ f = function_value(first->first); grad = function_gradient(first->first); CGAL_assertion(f.second); if(!grad.second) //the values are not correct: return std::make_pair(Value_type(0), false); Coord_type coeff = first->second/norm; Coord_type squared_dist = traits. compute_squared_distance_d_object()(first->first, p); Coord_type dist = CGAL_NTS sqrt(squared_dist); if(squared_dist ==0){ ForwardIterator it = first; CGAL_assertion(++it==beyond); return std::make_pair(f.first, true); } //three different terms to mix linear and gradient //interpolation term1 += coeff/dist; term2 += coeff * squared_dist; term3 += coeff * dist; linear_int += coeff * f.first; gradient_int += (coeff/dist) * (f.first + grad.first * traits.construct_vector_d_object()(first->first, p)); } term4 = term3/ term1; gradient_int = gradient_int / term1; return std::make_pair((term4* linear_int + term2 * gradient_int)/ (term4 + term2), true); } //this method works with rational number types: //modification of Sibson's interpolant without sqrt //following a proposition by Gunther Rote: // // the general scheme: // Coord_type inv_weight = f(dist); //i.e. dist^2 // term1 += coeff/inv_weight; // term2 += coeff * squared_dist; // term3 += coeff*(squared_dist/inv_weight); // gradient_int += (coeff/inv_weight)* // (vh->get_value()+ vh->get_gradient() // *(p - vh->point())); template < class ForwardIterator, class Functor, class GradFunctor, class Traits> std::pair< typename Functor::result_type::first_type, bool> sibson_c1_interpolation_square(ForwardIterator first, ForwardIterator beyond, const typename std::iterator_traits:: value_type::second_type& norm, const typename std::iterator_traits:: value_type::first_type& p, Functor function_value, GradFunctor function_gradient, const Traits& traits) { CGAL_precondition(norm >0); typedef typename Functor::result_type::first_type Value_type; typedef typename Traits::FT Coord_type; Coord_type term1(0), term2(term1), term3(term1), term4(term1); Value_type linear_int(0),gradient_int(0); typename Functor::result_type f; typename GradFunctor::result_type grad; for(; first !=beyond; ++first){ f = function_value(first->first); grad = function_gradient(first->first); CGAL_assertion(f.second); if(!grad.second) //the gradient is not known return std::make_pair(Value_type(0), false); Coord_type coeff = first->second/norm; Coord_type squared_dist = traits. compute_squared_distance_d_object()(first->first, p); if(squared_dist ==0){ ForwardIterator it = first; CGAL_assertion(++it==beyond); return std::make_pair(f.first,true); } //three different terms to mix linear and gradient //interpolation term1 += coeff/squared_dist; term2 += coeff * squared_dist; term3 += coeff; linear_int += coeff * f.first; gradient_int += (coeff/squared_dist) *(f.first + grad.first* traits.construct_vector_d_object()(first->first, p)); } term4 = term3/ term1; gradient_int = gradient_int / term1; return std::make_pair((term4* linear_int + term2 * gradient_int)/ (term4 + term2), true); } template < class RandomAccessIterator, class Functor, class GradFunctor, class Traits> std::pair< typename Functor::result_type::first_type, bool> farin_c1_interpolation(RandomAccessIterator first, RandomAccessIterator beyond, const typename std::iterator_traits:: value_type::second_type& norm, const typename std::iterator_traits:: value_type::first_type& p, Functor function_value, GradFunctor function_gradient, const Traits& traits) { CGAL_precondition(norm >0); //the function value is available for all points //if a gradient value is not availble: function returns false typedef typename Functor::result_type::first_type Value_type; typedef typename Traits::FT Coord_type; typename Functor::result_type f; typename GradFunctor::result_type grad; int n= beyond - first; if( n==1){ f= function_value(first->first); CGAL_assertion(f.second); return std::make_pair(f.first, true); } //there must be one or at least three NN-neighbors: CGAL_assertion(n > 2); RandomAccessIterator it2, it; Value_type result(0); const Coord_type fac3(3); std::vector< std::vector > ordinates(n,std::vector(n, Value_type(0))); for(int i =0; isecond); //for later: the function value of it->first: f = function_value(it->first); CGAL_assertion(f.second); ordinates[i][i] = f.first; //control point = data point result += coord_i_square * it->second* ordinates[i][i]; //compute tangent plane control point (one 2, one 1 entry) Value_type res_i(0); for(int j =0; jfirst); if(!grad.second) //the gradient is not known return std::make_pair(Value_type(0), false); //ordinates[i][j] = (p_j - p_i) * g_i ordinates[i][j] = grad.first * traits.construct_vector_d_object()(it->first,it2->first); // a point in the tangent plane: // 3( f(p_i) + (1/3)(p_j - p_i) * g_i) // => 3*f(p_i) + (p_j - p_i) * g_i res_i += (fac3 * ordinates[i][i] + ordinates[i][j])* it2->second; } } //res_i already multiplied by three result += coord_i_square *res_i; } //the third type of control points: three 1 entries i,j,k for(int i=0; i< n; ++i) for(int j=i+1; j< n; ++j) for(int k=j+1; k 6 * b_ijk = 3*(f_i + f_j + f_k) + 0.5*a result += (Coord_type(2.0)*( ordinates[i][i]+ ordinates[j][j]+ ordinates[k][k]) + Coord_type(0.5)*(ordinates[i][j] + ordinates[i][k] + ordinates[j][i] + ordinates[j][k] + ordinates[k][i]+ ordinates[k][j])) *(first+i)->second *(first+j)->second *(first+k)->second ; } return std::make_pair(result/(CGAL_NTS square(norm)*norm), true); } CGAL_END_NAMESPACE #endif // CGAL_INTERPOLATION_FUNCTIONS_H ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Point_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Point_0000644000175000017500000000225311344301500031254 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Point_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Gmpz.h0000644000175000017500000002574611344301500026124 0ustar debiandebian// Copyright (c) 1999,2003,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Gmpz.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra, Sylvain Pion #ifndef CGAL_GMPZ_H #define CGAL_GMPZ_H #include #include #include #include #include #ifndef CGAL_CFG_NO_LOCALE # include #else # include #endif #include #include CGAL_BEGIN_NAMESPACE class Gmpz_rep { public: mpz_t mpZ; Gmpz_rep() { mpz_init(mpZ); } Gmpz_rep(const mpz_t z) { mpz_init_set(mpZ, z); } Gmpz_rep(const Gmpz_rep & g) { mpz_init_set(mpZ, g.mpZ); } Gmpz_rep & operator= (const Gmpz_rep & g) { if (&g != this) { mpz_clear(mpZ); mpz_init_set(mpZ, g.mpZ); } return *this; } Gmpz_rep(int si) { mpz_init_set_si(mpZ, si); } Gmpz_rep(long li) { mpz_init_set_si(mpZ, li); } Gmpz_rep(unsigned long li) { mpz_init_set_ui(mpZ, li); } Gmpz_rep(double d) { mpz_init_set_d(mpZ, d); } Gmpz_rep(const char * const str) { mpz_init_set_str(mpZ, str, 10); } Gmpz_rep(const char * const str, int base) { mpz_init_set_str(mpZ, str, base); } ~Gmpz_rep() { mpz_clear(mpZ); } }; class Gmpz : public Handle_for { typedef Handle_for Base; public: typedef Tag_true Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; Gmpz() // {} we can't do that since the non-const mpz() is called. : Base(Gmpz_rep()) {} Gmpz(const mpz_t z) : Base(Gmpz_rep(z)) {} Gmpz(int i) : Base(Gmpz_rep(i)) {} Gmpz(long l) : Base(Gmpz_rep(l)) {} Gmpz(unsigned long l) : Base(Gmpz_rep(l)) {} Gmpz(double d) : Base(Gmpz_rep(d)) {} Gmpz(const std::string& str) : Base(Gmpz_rep(str.c_str())) {} Gmpz(const std::string& str, int base) : Base(Gmpz_rep(str.c_str(), base)) {} Gmpz operator-() const; Gmpz operator%(const Gmpz &z) const; Gmpz& operator+=(const Gmpz &z); Gmpz operator+=(int i); Gmpz& operator-=(const Gmpz &z); Gmpz operator-=(int i); Gmpz& operator*=(const Gmpz &z); Gmpz operator*=(int i); Gmpz& operator%=(const Gmpz &z); Gmpz& operator/=(const Gmpz &z); Gmpz operator/=(int i); size_t approximate_decimal_length() const; double to_double() const; Sign sign() const; const mpz_t & mpz() const { return Ptr()->mpZ; } mpz_t & mpz() { return ptr()->mpZ; } }; inline bool operator==(const Gmpz &a, const Gmpz &b) { return mpz_cmp(a.mpz(), b.mpz()) == 0; } inline bool operator<(const Gmpz &a, const Gmpz &b) { return mpz_cmp(a.mpz(), b.mpz()) < 0; } inline bool operator<=(const Gmpz &a, const Gmpz &b) { return ! (b < a); } inline bool operator>(const Gmpz &a, const Gmpz &b) { return b < a; } inline bool operator>=(const Gmpz &a, const Gmpz &b) { return ! (a < b); } inline bool operator!=(const Gmpz &a, const Gmpz &b) { return ! (a == b); } // mixed operators. inline bool operator<(const Gmpz &a, int b) { return mpz_cmp_si(a.mpz(), b) < 0; } inline bool operator<(int a, const Gmpz &b) { return mpz_cmp_si(b.mpz(), a) > 0; } inline bool operator==(const Gmpz &a, int b) { return mpz_cmp_si(a.mpz(), b) == 0; } inline bool operator==(int a, const Gmpz &b) { return b == a; } inline bool operator<=(const Gmpz &a, int b) { return ! (b < a); } inline bool operator<=(int a, const Gmpz &b) { return ! (b < a); } inline bool operator>(const Gmpz &a, int b) { return b < a; } inline bool operator>(int a, const Gmpz &b) { return b < a; } inline bool operator>=(const Gmpz &a, int b) { return ! (a < b); } inline bool operator>=(int a, const Gmpz &b) { return ! (a < b); } inline bool operator!=(const Gmpz &a, int b) { return ! (a == b); } inline bool operator!=(int a, const Gmpz &b) { return ! (a == b); } inline Gmpz Gmpz::operator-() const { Gmpz Res; mpz_neg(Res.mpz(), mpz()); return Res; } inline Gmpz operator+(const Gmpz &a, const Gmpz &b) { Gmpz Res; mpz_add(Res.mpz(), a.mpz(), b.mpz()); return Res; } inline Gmpz operator+(const Gmpz &a, int b) { if (b>0) { Gmpz Res; mpz_add_ui(Res.mpz(), a.mpz(), b); return Res; } return a + Gmpz(b); } inline Gmpz& Gmpz::operator+=(const Gmpz &z) { *this = *this + z; return *this; } inline Gmpz Gmpz::operator+=(int i) { *this = *this + Gmpz(i); return *this; } inline Gmpz operator-(const Gmpz &a, const Gmpz &b) { Gmpz Res; mpz_sub(Res.mpz(), a.mpz(), b.mpz()); return Res; } inline Gmpz operator-(const Gmpz &a, int b) { if (b>0) { Gmpz Res; mpz_sub_ui(Res.mpz(), a.mpz(), b); return Res; } return a - Gmpz(b); } inline Gmpz& Gmpz::operator-=(const Gmpz &z) { *this = *this - z; return *this; } inline Gmpz Gmpz::operator-=(int i) { *this = *this - Gmpz(i); return *this; } inline Gmpz operator*(const Gmpz &a, const Gmpz &b) { Gmpz Res; mpz_mul(Res.mpz(), a.mpz(), b.mpz()); return Res; } inline Gmpz operator*(const Gmpz &a, int b) { if (b>0) { Gmpz Res; mpz_mul_ui(Res.mpz(), a.mpz(), b); return Res; } return a * Gmpz(b); } inline Gmpz& Gmpz::operator*=(const Gmpz &z) { *this = *this * z; return *this; } inline Gmpz Gmpz::operator*=(int i) { *this = *this * Gmpz(i); return *this; } inline Gmpz operator/(const Gmpz &a, const Gmpz &b) { CGAL_precondition(b != 0); Gmpz Res; mpz_tdiv_q(Res.mpz(), a.mpz(), b.mpz()); return Res; } inline Gmpz operator/(const Gmpz &a, int b) { if (b>0) { Gmpz Res; mpz_tdiv_q_ui(Res.mpz(), a.mpz(), b); return Res; } return a / Gmpz(b); } inline Gmpz& Gmpz::operator/=(const Gmpz &z) { *this = *this / z; return *this; } inline Gmpz Gmpz::operator/=(int i) { *this = *this / Gmpz(i); return *this; } inline Gmpz operator+(int i, const Gmpz &z) { return z + i; } inline Gmpz operator-(int i, const Gmpz &z) { return Gmpz(i) - z; } inline Gmpz operator*(int i, const Gmpz &z) { return z * i; } inline Gmpz operator/(int i, const Gmpz &z) { return Gmpz(i) / z; } inline Gmpz Gmpz::operator%(const Gmpz &z) const { Gmpz Res; mpz_tdiv_r(Res.mpz(), mpz(), z.mpz()); return Res; } inline Gmpz& Gmpz::operator%=(const Gmpz &z) { *this = *this % z; return *this; } inline double Gmpz::to_double() const { return mpz_get_d(mpz()); } inline io_Operator io_tag(const Gmpz&) { return io_Operator(); } inline Sign Gmpz::sign() const { return static_cast(mpz_sgn(mpz())); } inline double to_double(const Gmpz &z) { return z.to_double(); } inline Sign sign(const Gmpz &z) { return z.sign(); } inline bool is_valid(const Gmpz &) { return true; } inline bool is_finite(const Gmpz &) { return true; } inline Gmpz sqrt(const Gmpz &z) { Gmpz Res; mpz_sqrt(Res.mpz(), z.mpz()); return Res; } inline Gmpz div(const Gmpz &z1, const Gmpz &z2) { return z1 / z2; } inline Gmpz gcd(const Gmpz &z1, const Gmpz &z2) { Gmpz Res; mpz_gcd(Res.mpz(), z1.mpz(), z2.mpz()); return Res; } inline Gmpz gcd(const Gmpz &z, int i) { if (i > 0) { Gmpz Res; mpz_gcd_ui(Res.mpz(), z.mpz(), i); return Res; } return gcd(z, Gmpz(i)); } inline Gmpz exact_division(const Gmpz &z1, const Gmpz &z2) { Gmpz Res; mpz_divexact(Res.mpz(), z1.mpz(), z2.mpz()); #ifdef CGAL_CHECK_POSTCONDITIONS mpz_t prod; mpz_init(prod); mpz_mul(prod, Res.mpz(), z2.mpz()); CGAL_postcondition_msg(mpz_cmp(prod, z1.mpz()) == 0, "exact_division failed\n"); mpz_clear( prod); #endif // CGAL_CHECK_POSTCONDITIONS return Res; } inline size_t Gmpz::approximate_decimal_length() const { return mpz_sizeinbase(mpz(),10); } inline std::ostream& operator<<(std::ostream& os, const Gmpz &z) { char *str = new char [mpz_sizeinbase(z.mpz(),10) + 2]; str = mpz_get_str(str, 10, z.mpz()); os << str ; delete[] str; return os; } inline std::istream& operator>>(std::istream& is, Gmpz &z) { bool negative = false; bool good = false; const int null = '0'; char c; Gmpz tmp; std::ios::fmtflags old_flags = is.flags(); is.unsetf(std::ios::skipws); #ifndef CGAL_CFG_NO_LOCALE while (is.get(c) && std::isspace(c, std::locale::classic() )) #else while (is.get(c) && CGAL_CLIB_STD::isspace(c)) #endif // CGAL_CFG_NO_LOCALE {} if (c == '-') { negative = true; #ifndef CGAL_CFG_NO_LOCALE while (is.get(c) && std::isspace(c, std::locale::classic() )) #else while (is.get(c) && CGAL_CLIB_STD::isspace(c)) #endif // CGAL_CFG_NO_LOCALE {} } #ifndef CGAL_CFG_NO_LOCALE if (std::isdigit(c, std::locale::classic() )) #else if (std::isdigit(c)) #endif // CGAL_CFG_NO_LOCALE { good = true; tmp = c - null; #ifndef CGAL_CFG_NO_LOCALE while (is.get(c) && std::isdigit(c, std::locale::classic() )) #else while (is.get(c) && std::isdigit(c)) #endif // CGAL_CFG_NO_LOCALE { tmp = 10*tmp + (c-null); } } if (is) is.putback(c); if (sign(tmp) != ZERO && negative) tmp = -tmp; if (good){ z = tmp; } else is.clear(is.rdstate() | std::ios::failbit); is.flags(old_flags); return is; } inline std::pair to_interval (const Gmpz & z) { mpfr_t x; mpfr_init2 (x, 53); /* Assume IEEE-754 */ mpfr_set_z (x, z.mpz(), GMP_RNDD); double i = mpfr_get_d (x, GMP_RNDD); /* EXACT but can overflow */ mpfr_set_z (x, z.mpz(), GMP_RNDU); double s = mpfr_get_d (x, GMP_RNDU); /* EXACT but can overflow */ mpfr_clear (x); return std::pair(i, s); } CGAL_END_NAMESPACE #include CGAL_BEGIN_NAMESPACE inline double to_double(const Quotient& quot) { mpq_t mpQ; mpq_init(mpQ); const Gmpz& n = quot.numerator(); const Gmpz& d = quot.denominator(); mpz_set(mpq_numref(mpQ), n.mpz()); mpz_set(mpq_denref(mpQ), d.mpz()); mpq_canonicalize(mpQ); double ret = mpq_get_d(mpQ); mpq_clear(mpQ); return ret; } CGAL_END_NAMESPACE #endif // CGAL_GMPZ_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree_d_new.h0000644000175000017500000001277011344301500027731 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree_d_new.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Authors : Hans Tangelder () #ifndef CGAL_KD_TREE_D_NEW_H #define CGAL_KD_TREE_D_NEW_H #include #include #include #include #include #include namespace CGAL { // implementing backward compability to old kdtree template class Kdtree_d { public: typedef typename TreeTraits::Iso_box_d Box; private: typedef typename TreeTraits::Point Point; typedef std::list Point_list; Kd_tree* t; public: // constructor Kdtree_d(int k = 2) {} void build(Point_list &l) { t = new Kd_tree(l.begin(), l.end());} void delete_all() {delete t;} // not implemented for Kd_tree bool is_valid() {return true;} // not implemented for Kd_tree void dump() {} template OutputIterator search(OutputIterator it, const FuzzyQueryItem& q) { it = t->search(it,q); return it; } template OutputIterator report_all_points(OutputIterator it) {it=t->report_all_points(it); return it;} ~Kdtree_d() {} }; template > class Kdtree_interface_2d : public Search_traits { public: typedef typename Kernel_traits::Kernel K; typedef typename K::FT NT; typedef Fuzzy_iso_box_d > Iso_box_2; // work around, because old kd-tree constructor requires unneeded specification of dim class Iso_box_d { private: Iso_box_2 *b; public: //constuctor Iso_box_d(const Point& p, const Point&q, int dim) { b=new Iso_box_2(p,q); } bool contains(const Point& p) const { return b->contains(p); } bool inner_range_intersects(const Kd_tree_rectangle* rectangle) const { return b->inner_range_intersects(rectangle); } bool outer_range_is_contained_by(const Kd_tree_rectangle* rectangle) const { return b->outer_range_is_contained_by(rectangle); } //destructor ~Iso_box_d() { delete b;} }; //constructor Kdtree_interface_2d(unsigned int bucket_size=100, NT aspect_ratio=NT(3), bool use_extended_nodes=true) { Search_traits(bucket_size,aspect_ratio,use_extended_nodes); } // destructor ~Kdtree_interface_2d() {} }; template > class Kdtree_interface_3d : public Search_traits { public: typedef typename Kernel_traits::Kernel K; typedef typename K::FT NT; typedef Fuzzy_iso_box_d > Iso_box_3; // work around, because old kd-tree constructor requires unneeded specification of dim class Iso_box_d { private: Iso_box_3 *b; public: //constuctor Iso_box_d(const Point& p, const Point&q, int dim) { b=new Iso_box_3(p,q); } bool contains(const Point& p) const { return b->contains(p); } bool inner_range_intersects(const Kd_tree_rectangle* rectangle) const { return b->inner_range_intersects(rectangle); } bool outer_range_is_contained_by(const Kd_tree_rectangle* rectangle) const { return b->outer_range_is_contained_by(rectangle); } //destructor ~Iso_box_d() { delete b;} }; //constructor Kdtree_interface_3d(unsigned int bucket_size=100, NT aspect_ratio=NT(3), bool use_extended_nodes=true) { Search_traits(bucket_size,aspect_ratio,use_extended_nodes); } // destructor ~Kdtree_interface_3d() {} }; template > class Kdtree_interface : public Search_traits { public: typedef typename Kernel_traits::Kernel K; typedef typename K::FT NT; typedef Fuzzy_iso_rectangle_d > Iso_box; // work around, because old kd-tree constructor requires unneeded specification of dim class Iso_box_d { private: Iso_box *b; public: //constuctor Iso_box_d(const Point& p, const Point&q, int dim) { b=new Iso_box(p,q); } bool contains(const Point& p) const { return b->contains(p); } bool inner_range_intersects(const Kd_tree_rectangle* rectangle) const { return b->inner_range_intersects(rectangle); } bool outer_range_is_contained_by(const Kd_tree_rectangle* rectangle) const { return b->outer_range_is_contained_by(rectangle); } //destructor ~Iso_box_d() { delete b;} }; //constructor Kdtree_interface(unsigned int bucket_size=100, NT aspect_ratio=NT(3), bool use_extended_nodes=true) { Search_traits(bucket_size,aspect_ratio,use_extended_nodes); } // destructor ~Kdtree_interface() {} }; } // namespace CGAL #endif // CGAL_KD_TREE_D_NEW_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2.h0000644000175000017500000004323611344301500027466 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_CIRCLE_2_H #define CGAL_MIN_CIRCLE_2_H // includes # include # include # include # include # include # include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class Traits_ > class Min_circle_2; // Class interface // =============== template < class Traits_ > class Min_circle_2 { public: // types typedef Traits_ Traits; typedef typename Traits_::Point Point; typedef typename Traits_::Circle Circle; typedef typename std::list::const_iterator Point_iterator; typedef const Point * Support_point_iterator; /************************************************************************** WORKAROUND: Some compilers are unable to match member functions defined outside the class template. Therefore, all member functions are implemented in the class interface. // creation template < class InputIterator > Min_circle_2( InputIterator first, InputIterator last, bool randomize = false, Random& random = default_random, const Traits& traits = Traits()); Min_circle_2( const Traits& traits = Traits()); Min_circle_2( const Point& p, const Traits& traits = Traits()); Min_circle_2( Point p, Point q, const Traits& traits = Traits()); Min_circle_2( const Point& p1, const Point& p2, const Point& p3, const Traits& traits = Traits()); ~Min_circle_2( ); // access functions int number_of_points ( ) const; int number_of_support_points( ) const; Point_iterator points_begin( ) const; Point_iterator points_end ( ) const; Support_point_iterator support_points_begin( ) const; Support_point_iterator support_points_end ( ) const; const Point& support_point( int i) const; const Circle& circle( ) const; // predicates Bounded_side bounded_side( const Point& p) const; bool has_on_bounded_side ( const Point& p) const; bool has_on_boundary ( const Point& p) const; bool has_on_unbounded_side ( const Point& p) const; bool is_empty ( ) const; bool is_degenerate( ) const; // modifiers void insert( const Point& p); void insert( const Point* first, const Point* last ); void insert( std::list::const_iterator first, std::list::const_iterator last ); void insert( std::istream_iterator first, std::istream_iterator last ); void clear( ); // validity check bool is_valid( bool verbose = false, int level = 0) const; // miscellaneous const Traits& traits( ) const; **************************************************************************/ private: // private data members Traits tco; // traits class object std::list points; // doubly linked list of points int n_support_points; // number of support points Point* support_points; // array of support points // copying and assignment not allowed! Min_circle_2( const Min_circle_2&); Min_circle_2& operator = ( const Min_circle_2&); // ============================================================================ // Class implementation // ==================== public: // Access functions and predicates // ------------------------------- // #points and #support points inline int number_of_points( ) const { return( points.size()); } inline int number_of_support_points( ) const { return( n_support_points); } // is_... predicates inline bool is_empty( ) const { return( number_of_support_points() == 0); } inline bool is_degenerate( ) const { return( number_of_support_points() < 2); } // access to points and support points inline Point_iterator points_begin( ) const { return( points.begin()); } inline Point_iterator points_end( ) const { return( points.end()); } inline Support_point_iterator support_points_begin( ) const { return( support_points); } inline Support_point_iterator support_points_end( ) const { return( support_points+n_support_points); } // random access for support points inline const Point& support_point( int i) const { CGAL_optimisation_precondition( (i >= 0) && (i < number_of_support_points())); return( support_points[ i]); } // circle inline const Circle& circle( ) const { return( tco.circle); } // in-circle test predicates inline CGAL::Bounded_side bounded_side( const Point& p) const { return( tco.circle.bounded_side( p)); } inline bool has_on_bounded_side( const Point& p) const { return( tco.circle.has_on_bounded_side( p)); } inline bool has_on_boundary( const Point& p) const { return( tco.circle.has_on_boundary( p)); } inline bool has_on_unbounded_side( const Point& p) const { return( tco.circle.has_on_unbounded_side( p)); } private: // Private member functions // ------------------------ // compute_circle inline void compute_circle( ) { switch ( n_support_points) { case 3: tco.circle.set( support_points[ 0], support_points[ 1], support_points[ 2]); break; case 2: tco.circle.set( support_points[ 0], support_points[ 1]); break; case 1: tco.circle.set( support_points[ 0]); break; case 0: tco.circle.set( ); break; default: CGAL_optimisation_assertion( ( n_support_points >= 0) && ( n_support_points <= 3) ); } } void mc( const Point_iterator& last, int n_sp) { // compute circle through support points n_support_points = n_sp; compute_circle(); if ( n_sp == 3) return; // test first n points typename std::list::iterator point_iter = points.begin(); for ( ; last != point_iter; ) { const Point& p = *point_iter; // p not in current circle? if ( has_on_unbounded_side( p)) { // recursive call with p as additional support point support_points[ n_sp] = p; mc( point_iter, n_sp+1); // move current point to front points.splice( points.begin(), points, point_iter++); } else ++point_iter; } } public: // Constructors // ------------ // STL-like constructor (member template) template < class InputIterator > Min_circle_2( InputIterator first, InputIterator last, bool randomize #if !defined(__BORLANDC__) && (!defined(_MSC_VER) || _MSC_VER > 1300) = false #endif , Random& random = default_random, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 3]; // range of points not empty? if ( first != last) { // store points if ( randomize) { // shuffle points at random #ifndef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES std::vector v( first, last); #else std::vector v; std::copy( first, last, std::back_inserter( v)); #endif std::random_shuffle( v.begin(), v.end(), random); std::copy( v.begin(), v.end(), std::back_inserter( points)); } else std::copy( first, last, std::back_inserter( points)); } // compute mc mc( points.end(), 0); } // default constructor inline Min_circle_2( const Traits& traits = Traits()) : tco( traits), n_support_points( 0) { // allocate support points' array support_points = new Point[ 3]; // initialize circle tco.circle.set(); CGAL_optimisation_postcondition( is_empty()); } // constructor for one point inline Min_circle_2( const Point& p, const Traits& traits = Traits()) : tco( traits), points( 1, p), n_support_points( 1) { // allocate support points' array support_points = new Point[ 3]; // initialize circle support_points[ 0] = p; tco.circle.set( p); CGAL_optimisation_postcondition( is_degenerate()); } // constructor for two points // This was const Point& but then Intel 7.0/.net2003 messes it up // with the constructor taking an iterator range inline Min_circle_2( Point p1, Point p2, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 3]; // store points points.push_back( p1); points.push_back( p2); // compute mc mc( points.end(), 0); } // constructor for three points inline Min_circle_2( const Point& p1, const Point& p2, const Point& p3, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 3]; // store points points.push_back( p1); points.push_back( p2); points.push_back( p3); // compute mc mc( points.end(), 0); } // Destructor // ---------- inline ~Min_circle_2( ) { // free support points' array delete[] support_points; } // Modifiers // --------- void insert( const Point& p) { // p not in current circle? if ( has_on_unbounded_side( p)) { // p new support point support_points[ 0] = p; // recompute mc mc( points.end(), 1); // store p as the first point in list points.push_front( p); } else // append p to the end of the list points.push_back( p); } template < class InputIterator > void insert( InputIterator first, InputIterator last) { for ( ; first != last; ++first) insert( *first); } void clear( ) { points.erase( points.begin(), points.end()); n_support_points = 0; tco.circle.set(); } // Validity check // -------------- bool is_valid( bool verbose = false, int level = 0) const { CGAL_USING_NAMESPACE_STD CGAL::Verbose_ostream verr( verbose); verr << endl; verr << "CGAL::Min_circle_2::" << endl; verr << "is_valid( true, " << level << "):" << endl; verr << " |P| = " << number_of_points() << ", |S| = " << number_of_support_points() << endl; // containment check (a) verr << " a) containment check..." << flush; Point_iterator point_iter; for ( point_iter = points_begin(); point_iter != points_end(); ++point_iter) if ( has_on_unbounded_side( *point_iter)) return( CGAL::_optimisation_is_valid_fail( verr, "circle does not contain all points")); verr << "passed." << endl; // support set checks (b)+(c) verr << " b)+c) support set checks..." << flush; switch( number_of_support_points()) { case 0: if ( ! is_empty()) return( CGAL::_optimisation_is_valid_fail( verr, "P is nonempty, \ but there are no support points.")); break; case 1: if ( ( circle().center() != support_point( 0) ) || ( ! CGAL_NTS is_zero( circle().squared_radius())) ) return( CGAL::_optimisation_is_valid_fail( verr, "circle differs from the circle \ spanned by its single support point.")); break; case 2: { const Point& p = support_point( 0), q = support_point( 1); // p equals q? if ( p == q) return( CGAL::_optimisation_is_valid_fail( verr, "the two support points are equal.")); // segment(p,q) is not diameter? if ( ( ! has_on_boundary( p) ) || ( ! has_on_boundary( q) ) || ( tco.orientation( p, q, circle().center()) != CGAL::COLLINEAR) ) return( CGAL::_optimisation_is_valid_fail( verr, "circle does not have its \ two support points as diameter.")); } break; case 3: { const Point& p = support_point( 0), q = support_point( 1), r = support_point( 2); // p, q, r not pairwise distinct? if ( ( p == q) || ( q == r) || ( r == p)) return( CGAL::_optimisation_is_valid_fail( verr, "at least two of the three \ support points are equal.")); // p, q, r collinear? if ( tco.orientation( p, q, r) == CGAL::COLLINEAR) return( CGAL::_optimisation_is_valid_fail( verr, "the three support points are collinear.")); // current circle not equal the unique circle through p,q,r ? Circle c = circle(); c.set( p, q, r); if ( circle() != c) return( CGAL::_optimisation_is_valid_fail( verr, "circle is not the unique circle \ through its three support points.")); // circle's center on boundary of triangle(p,q,r)? const Point& center = circle().center(); CGAL::Orientation o_pqz = tco.orientation( p, q, center); CGAL::Orientation o_qrz = tco.orientation( q, r, center); CGAL::Orientation o_rpz = tco.orientation( r, p, center); if ( ( o_pqz == CGAL::COLLINEAR) || ( o_qrz == CGAL::COLLINEAR) || ( o_rpz == CGAL::COLLINEAR) ) return( CGAL::_optimisation_is_valid_fail( verr, "one of the three support points is redundant.")); // circle's center not inside triangle(p,q,r)? if ( ( o_pqz != o_qrz) || ( o_qrz != o_rpz) || ( o_rpz != o_pqz)) return( CGAL::_optimisation_is_valid_fail( verr, "circle's center is not in the \ convex hull of its three support points.")); } break; default: return( CGAL::_optimisation_is_valid_fail( verr, "illegal number of support points, \ not between 0 and 3.")); }; verr << "passed." << endl; verr << " object is valid!" << endl; return( true); } // Miscellaneous // ------------- inline const Traits& traits( ) const { return( tco); } }; // Function declarations // ===================== // I/O // --- template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_circle_2& mc); template < class Traits_ > std::istream& operator >> ( std::istream& is, Min_circle_2& mc); CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_MIN_CIRCLE_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3_2.h0000644000175000017500000001632411344301501031161 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman, Andreas Fabri #ifndef CGAL_DISTANCE_3_2_H #define CGAL_DISTANCE_3_2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template bool contains_vector(const typename CGAL_WRAP(K)::Plane_3 &pl, const typename CGAL_WRAP(K)::Vector_3 &vec, const K&) { typedef typename K::RT RT; return pl.a()*vec.hx() + pl.b()*vec.hy() + pl.c() * vec.hz() == RT(0); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Point_3 & pt, const typename CGAL_WRAP(K)::Plane_3 & plane, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; Vector_3 diff = construct_vector(plane.point(), pt); return squared_distance_to_plane(plane.orthogonal_vector(), diff, k); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Plane_3 & plane, const typename CGAL_WRAP(K)::Point_3 & pt, const K& k) { return squared_distance(pt, plane, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Line_3 &line, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { typedef typename K::FT FT; if (contains_vector(plane, line.direction().vector(), k)) return squared_distance(plane, line.point(), k); return FT(0); } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Plane_3 & p, const typename CGAL_WRAP(K)::Line_3 & line, const K& k) { return squared_distance(line, p, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Ray_3 &ray, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::RT RT; typedef typename K::FT FT; const Point_3 &start = ray.start(); const Point_3 &planepoint = plane.point(); Vector_3 start_min_pp = construct_vector(planepoint, start); Vector_3 end_min_pp = ray.direction().vector(); const Vector_3 &normal = plane.orthogonal_vector(); RT sdm_rs2pp = wdot(normal, start_min_pp, k); RT sdm_re2pp = wdot(normal, end_min_pp, k); switch (CGAL_NTS sign(sdm_rs2pp)) { case -1: if (sdm_re2pp > RT(0)) return FT(0); return squared_distance_to_plane(normal, start_min_pp, k); case 0: default: return FT(0); case 1: if (sdm_re2pp < RT(0)) return FT(0); return squared_distance_to_plane(normal, start_min_pp, k); } } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Plane_3 & plane, const typename CGAL_WRAP(K)::Ray_3 & ray, const K& k) { return squared_distance(ray, plane, k); } template typename K::FT squared_distance( const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { typename K::Construct_vector_3 construct_vector; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::RT RT; typedef typename K::FT FT; const Point_3 &start = seg.start(); const Point_3 &end = seg.end(); if (start == end) return squared_distance(start, plane, k); const Point_3 &planepoint = plane.point(); Vector_3 start_min_pp = construct_vector(planepoint, start); Vector_3 end_min_pp = construct_vector(planepoint, end); const Vector_3 &normal = plane.orthogonal_vector(); RT sdm_ss2pp = wdot(normal, start_min_pp, k); RT sdm_se2pp = wdot(normal, end_min_pp, k); switch (CGAL_NTS sign(sdm_ss2pp)) { case -1: if (sdm_se2pp >= RT(0)) return FT(0); if (sdm_ss2pp >= sdm_se2pp) return squared_distance_to_plane(normal, start_min_pp, k); else return squared_distance_to_plane(normal, end_min_pp, k); case 0: default: return FT(0); case 1: if (sdm_se2pp <= RT(0)) return FT(0); if (sdm_ss2pp <= sdm_se2pp) return squared_distance_to_plane(normal, start_min_pp, k); else return squared_distance_to_plane(normal, end_min_pp, k); } } template inline typename K::FT squared_distance( const typename CGAL_WRAP(K)::Plane_3 & plane, const typename CGAL_WRAP(K)::Segment_3 & seg, const K& k) { return squared_distance(seg, plane, k); } } // namespace CGALi template bool contains_vector(const Plane_3 &pl, const Vector_3 &vec) { return CGALi::contains_vector(pl,vec, K()); } template inline typename K::FT squared_distance( const Point_3 & pt, const Plane_3 & plane) { return CGALi::squared_distance(pt, plane, K()); } template inline typename K::FT squared_distance( const Plane_3 & plane, const Point_3 & pt) { return CGALi::squared_distance(pt, plane, K()); } template inline typename K::FT squared_distance( const Line_3 &line, const Plane_3 &plane) { return CGALi::squared_distance(line, plane, K()); } template inline typename K::FT squared_distance( const Plane_3 & p, const Line_3 & line) { return CGALi::squared_distance(line, p, K()); } template inline typename K::FT squared_distance( const Ray_3 &ray, const Plane_3 &plane) { return CGALi::squared_distance(ray, plane, K()); } template inline typename K::FT squared_distance( const Plane_3 & plane, const Ray_3 & ray) { return CGALi::squared_distance(ray, plane, K()); } template inline typename K::FT squared_distance( const Segment_3 &seg, const Plane_3 &plane) { return CGALi::squared_distance(seg, plane, K()); } template inline typename K::FT squared_distance( const Plane_3 & plane, const Segment_3 & seg) { return CGALi::squared_distance(seg, plane, K()); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective_yz_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective0000644000175000017500000001217411344301500031470 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective_yz_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CONVEX_HULL_PROJECTIVE_YZ_TRAITS_2_H #define CONVEX_HULL_PROJECTIVE_YZ_TRAITS_2_H #include #include namespace CGAL { template class Less_xy_plane_yz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.y(), p.z(), q.y(), q.z()) == SMALLER; } }; template class Equal_xy_plane_yz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.y(), p.z(), q.y(), q.z()) == EQUAL; } }; template class Less_yx_plane_yz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.z(), p.y(), q.z(), q.y()) == SMALLER; } }; template class Left_turn_plane_yz_2 { public: typedef bool result_type; typedef Arity_tag<3> Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return orientationC2(p.y(), p.z(), q.y(), q.z(), r.y(), r.z()) == LEFT_TURN; } }; template class Left_of_line_plane_yz_2 { public: Left_of_line_plane_yz_2(const Point_3& a, const Point_3& b): p_a(a), p_b(b) { } bool operator()(const Point_3& c) const { return orientationC2(p_a.y(), p_a.z(), p_b.y(), p_b.z(), c.y(), c.z()) == LEFT_TURN; } private: Point_3 p_a; Point_3 p_b; }; template class Less_dist_to_line_plane_yz_2 { public: typedef bool result_type; typedef Arity_tag<4> Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { Comparison_result res = cmp_signed_dist_to_lineC2(p.y(), p.z(), q.y(), q.z(), r.y(), r.z(), s.y(), s.z()); if ( res == LARGER ) return false; else if ( res == SMALLER ) return true; else return compare_lexicographically_xyC2(r.y(), r.z(), s.y(), s.z()) == SMALLER; } }; template class Less_rotate_ccw_plane_yz_2 { public: typedef bool result_type; typedef Arity_tag<3> Arity; bool operator()(const Point_3& r, const Point_3& p, const Point_3& q) const { Orientation orient = orientationC2(r.y(), r.z(), p.y(), p.z(), q.y(), q.z()); if ( orient == LEFT_TURN ) return true; else if ( orient == RIGHT_TURN ) return false; else { if (p.y() == r.y() && p.z() == r.z()) return false; if (q.y() == r.y() && q.z() == r.z()) return true; if (p.y() == q.y() && p.z() == q.z()) return false; return collinear_are_ordered_along_lineC2(r.y(), r.z(), q.y(), q.z(), p.y(), p.z()); } } }; template class Convex_hull_projective_yz_traits_2 { public: typedef Point_3 Point_2; typedef Less_xy_plane_yz_2 Less_xy_2; typedef Equal_xy_plane_yz_2 Equal_2; typedef Less_yx_plane_yz_2 Less_yx_2; typedef Left_turn_plane_yz_2 Left_turn_2; typedef Less_dist_to_line_plane_yz_2 Less_signed_distance_to_line_2; typedef Less_rotate_ccw_plane_yz_2 Less_rotate_ccw_plane_2; Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Equal_2 equal_2_object() const { return Equal_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Less_signed_distance_to_line_2 less_signed_distance_to_line_2_object() const { return Less_signed_distance_to_line_2(); } Less_rotate_ccw_plane_2 less_rotate_ccw_plane_2_object() const { return Less_rotate_ccw_plane_2(); } }; } #endif // CONVEX_HULL_PROJECTIVE_YZ_TRAITS_2_H ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_base_with_edges_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_bas0000644000175000017500000000736311344301501031400 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_base_with_edges_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_TRIANGULATION_FACE_BASE_WITH_EDGES_2_H #define CGAL_TRIANGULATION_FACE_BASE_WITH_EDGES_2_H #include #include CGAL_BEGIN_NAMESPACE template < class Gt, class Fb = Triangulation_ds_face_base_2<> > class Triangulation_face_base_with_edges_2 : public Fb { protected: // local types typedef typename Fb::Triangulation_data_structure TDS; public: // TYPES //------ typedef Gt Geom_traits; typedef Fb Base; typedef TDS Triangulation_data_structure_2; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Face_handle Face_handle; typedef typename TDS::Edge Edge; template struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Vb2; typedef Triangulation_face_base_with_edges_2 Other; }; public: // CREATION //--------- Triangulation_face_base_with_edges_2() : Base() { init(); } Triangulation_face_base_with_edges_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Base(v0,v1,v2) { init(); } Triangulation_face_base_with_edges_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Base(v0,v1,v2,n0,n1,n2) { init(); } public: // OPERATIONS //----------- bool is_in_list(int i) const { CGAL_precondition( i >= 0 && i <= 2 ); return ( next_edge_in_list[i].first != Face_handle() || prev_edge_in_list[i].first != Face_handle() ); } void set_next(int i, const Edge& next) { CGAL_precondition( i >= 0 && i <= 2 ); CGAL_precondition( next.first == Face_handle() || (next.second >= 0 && next.second <= 2) ); next_edge_in_list[i] = next; } void set_previous(int i, const Edge& prev) { CGAL_precondition( i >= 0 && i <= 2 ); CGAL_precondition( prev.first == Face_handle() || (prev.second >= 0 && prev.second <= 2) ); prev_edge_in_list[i] = prev; } Edge next(int i) const { CGAL_precondition( i >= 0 && i <= 2 ); return next_edge_in_list[i]; } Edge previous(int i) const { CGAL_precondition( i >= 0 && i <= 2 ); return prev_edge_in_list[i]; } protected: // class variables Edge next_edge_in_list[3]; Edge prev_edge_in_list[3]; protected: static int sentinel_index() { return -1; } static const Edge& sentinel_edge() { static Edge SENTINEL_EDGE = Edge(Face_handle(), sentinel_index()); return SENTINEL_EDGE; } // initialization of in-place list pointers void init() { for (int i = 0; i < 3; i++) { next_edge_in_list[i] = sentinel_edge(); prev_edge_in_list[i] = sentinel_edge(); } } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_FACE_BASE_WITH_EDGES_2_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_cell_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_cell_0000644000175000017500000002636711344301501031426 0ustar debiandebian// Copyright (c) 1999-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_cell_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud // cell of a combinatorial triangulation of any dimension <=3 // use to store vertices if dimension <=0, edges if dimension 1, // faces if dimension 2, plain cells if dimension 3 #ifndef CGAL_TRIANGULATION_DS_CELL_3_H #define CGAL_TRIANGULATION_DS_CELL_3_H #include #include #include CGAL_BEGIN_NAMESPACE template < class Cb > class Triangulation_ds_cell_3 : public Cb { static int ccw(int i) { return Triangulation_utils_3::ccw(i); } static int cw(int i) { return Triangulation_utils_3::cw(i); } typedef typename Cb::Triangulation_data_structure Tds; public: typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Cell_handle Cell_handle; typedef typename Tds::Vertex Vertex; typedef typename Tds::Cell Cell; using Cb::neighbor; using Cb::vertex; Triangulation_ds_cell_3() : Cb() { set_in_conflict_flag(0); } Triangulation_ds_cell_3(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) : Cb(v0, v1, v2, v3) { set_in_conflict_flag(0); } Triangulation_ds_cell_3(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Cell_handle n0, Cell_handle n1, Cell_handle n2, Cell_handle n3) : Cb(v0, v1, v2, v3, n0, n1, n2, n3) { set_in_conflict_flag(0); } int mirror_index(int i) const { CGAL_triangulation_precondition ( i>=0 && i<4 ); Cell_handle ni = neighbor(i); if (&*ni->neighbor(0) == this) return 0; if (&*ni->neighbor(1) == this) return 1; if (&*ni->neighbor(2) == this) return 2; CGAL_triangulation_assertion(&*ni->neighbor(3) == this); return 3; } Vertex_handle mirror_vertex(int i) const { return neighbor(i)->vertex(mirror_index(i)); } void set_in_conflict_flag(unsigned char f) { _in_conflict_flag = f; } unsigned char get_in_conflict_flag() const { return _in_conflict_flag; } bool is_valid(int dim = 3, bool verbose = false, int level = 0) const; private: unsigned char _in_conflict_flag; void error_orient(Cell_handle, int i) const { std::cerr << " pb orientation with neighbor " << i << std::endl; } }; template < class Cb > bool Triangulation_ds_cell_3::is_valid(int dim, bool verbose, int level) const { if ( ! Cb::is_valid(verbose,level) ) return false; switch (dim) { case -2: case -1: { if ( vertex(0) == Vertex_handle() ) { if (verbose) std::cerr << "vertex 0 NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } vertex(0)->is_valid(verbose,level); if ( vertex(1) != Vertex_handle() || vertex(2) != Vertex_handle()) { if (verbose) std::cerr << "vertex 1 or 2 != NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( neighbor(0) != Cell_handle() || neighbor(1) != Cell_handle() || neighbor(2) != Cell_handle()) { if (verbose) std::cerr << "one neighbor != NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 0: { if ( vertex(0) == Vertex_handle() ) { if (verbose) std::cerr << "vertex 0 NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } vertex(0)->is_valid(verbose,level); if ( neighbor (0) == Cell_handle() ) { if (verbose) std::cerr << "neighbor 0 NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( vertex(1) != Vertex_handle() || vertex(2) != Vertex_handle() ) { if (verbose) std::cerr << "vertex 1 or 2 != NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( neighbor(1) != Cell_handle() || neighbor(2) != Cell_handle() ) { if (verbose) std::cerr << "neighbor 1 or 2 != NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( ! neighbor(0)->has_vertex(vertex(0)) ) { if (verbose) std::cerr << "neighbor 0 does not have vertex 0" << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 1: { Vertex_handle v0 = vertex(0); Vertex_handle v1 = vertex(1); Cell_handle n0 = neighbor(0); Cell_handle n1 = neighbor(1); if ( v0 == Vertex_handle() || v1 == Vertex_handle() ) { if (verbose) std::cerr << "vertex 0 or 1 NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } vertex(0)->is_valid(verbose,level); vertex(1)->is_valid(verbose,level); if ( n0 == Cell_handle() || n1 == Cell_handle() ) { if (verbose) std::cerr << "neighbor 0 or 1 NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( v0 != n1->vertex(1) ) { if (verbose) std::cerr << "neighbor 1 does not have vertex 0 as vertex 1" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( v1 != n0->vertex(0) ) { if (verbose) std::cerr << "neighbor 0 does not have vertex 1 as vertex 0" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( &*n0->neighbor(1) != this ) { if (verbose) std::cerr << "neighbor 0 does not have this as neighbor 1" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( &*n1->neighbor(0) != this ) { if (verbose) std::cerr << "neighbor 1 does not have this as neighbor 0" << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 2: { if ( vertex(0) == Vertex_handle() || vertex(1) == Vertex_handle() || vertex(2) == Vertex_handle() ) { if (verbose) std::cerr << "vertex 0, 1, or 2 NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } vertex(0)->is_valid(verbose,level); vertex(1)->is_valid(verbose,level); vertex(2)->is_valid(verbose,level); int in; Cell_handle n; for(int i = 0; i < 3; i++) { n = neighbor(i); if ( n == Cell_handle() ) { if (verbose) std::cerr << "neighbor " << i << " NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( ! n->has_vertex(vertex(cw(i)),in ) ) { if (verbose) std::cerr << "vertex " << cw(i) << " not vertex of neighbor " << i << std::endl; CGAL_triangulation_assertion(false); return false; } in = cw(in); if ( &*n->neighbor(in) != this ) { if (verbose) std::cerr << "neighbor " << i << " does not have this as neighbor " << in << std::endl; CGAL_triangulation_assertion(false); return false; } if ( vertex(ccw(i)) != n->vertex(cw(in)) ) { if (verbose) std::cerr << "vertex " << ccw(i) << " is not vertex " << cw(in) << " of neighbor " << i << std::endl; CGAL_triangulation_assertion(false); return false; } } break; } case 3: { int i; for(i = 0; i < 4; i++) { if ( vertex(i) == Vertex_handle() ) { if (verbose) std::cerr << "vertex " << i << " NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } vertex(i)->is_valid(verbose,level); } for(i = 0; i < 4; i++) { Cell_handle n = neighbor(i); if ( n == Cell_handle() ) { if (verbose) std::cerr << "neighbor " << i << " NULL" << std::endl; CGAL_triangulation_assertion(false); return false; } int in = 5; // if ( ! n->has_neighbor(handle(), in) ) { if ( &*n->neighbor(0) == this) in = 0; if ( &*n->neighbor(1) == this) in = 1; if ( &*n->neighbor(2) == this) in = 2; if ( &*n->neighbor(3) == this) in = 3; if (in == 5) { if (verbose) std::cerr << "neighbor of c has not c as neighbor" << std::endl; CGAL_triangulation_assertion(false); return false; } int j1n,j2n,j3n; if ( ! n->has_vertex(vertex((i+1)&3),j1n) ) { if (verbose) { std::cerr << "vertex " << ((i+1)&3) << " not vertex of neighbor " << i << std::endl; } CGAL_triangulation_assertion(false); return false; } if ( ! n->has_vertex(vertex((i+2)&3),j2n) ) { if (verbose) { std::cerr << "vertex " << ((i+2)&3) << " not vertex of neighbor " << i << std::endl; } CGAL_triangulation_assertion(false); return false; } if ( ! n->has_vertex(vertex((i+3)&3),j3n) ) { if (verbose) { std::cerr << "vertex " << ((i+3)&3) << " not vertex of neighbor " << i << std::endl; } CGAL_triangulation_assertion(false); return false; } if ( in+j1n+j2n+j3n != 6) { if (verbose) { std::cerr << "sum of the indices != 6 " << std::endl; } CGAL_triangulation_assertion(false); return false; } // tests whether the orientations of this and n are consistent if ( ((i+in)&1) == 0 ) { // i and in have the same parity if ( j1n == ((in+1)&3) ) { if ( ( j2n != ((in+3)&3) ) || ( j3n != ((in+2)&3) ) ) { if (verbose) { error_orient(n,i); } CGAL_triangulation_assertion(false); return false; } } if ( j1n == ((in+2)&3) ) { if ( ( j2n != ((in+1)&3) ) || ( j3n != ((in+3)&3) ) ) { if (verbose) { error_orient(n,i); } CGAL_triangulation_assertion(false); return false; } } if ( j1n == ((in+3)&3) ) { if ( ( j2n != ((in+2)&3) ) || ( j3n != ((in+1)&3) ) ) { if (verbose) { error_orient(n,i); } CGAL_triangulation_assertion(false); return false; } } } else { // i and in do not have the same parity if ( j1n == ((in+1)&3) ) { if ( ( j2n != ((in+2)&3) ) || ( j3n != ((in+3)&3) ) ) { if (verbose) { error_orient(n,i); } CGAL_triangulation_assertion(false); return false; } } if ( j1n == ((in+2)&3) ) { if ( ( j2n != ((in+3)&3) ) || ( j3n != ((in+1)&3) ) ) { if (verbose) { error_orient(n,i); } CGAL_triangulation_assertion(false); return false; } } if ( j1n == ((in+3)&3) ) { if ( ( j2n != ((in+1)&3) ) || ( j3n != ((in+2)&3) ) ) { if (verbose) { error_orient(n,i); } CGAL_triangulation_assertion(false); return false; } } } } // end looking at neighbors }// end case dim 3 } // end switch return true; } // end is_valid CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DS_CELL_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Concatenate_iterator.h0000644000175000017500000000673611344301500031342 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Concatenate_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_CONCATENATE_ITERATOR_H #define CGAL_CONCATENATE_ITERATOR_H #include #include CGAL_BEGIN_NAMESPACE template class Concatenate_iterator; template bool operator==(const Concatenate_iterator&, const Concatenate_iterator&); template class Concatenate_iterator { private: typedef Concatenate_iterator Self; typedef std::iterator_traits Traits1; public: typedef It1 Iterator1; typedef It2 Iterator2; typedef typename Traits1::reference reference; typedef typename Traits1::pointer pointer; typedef typename Traits1::value_type value_type; typedef typename Traits1::difference_type difference_type; typedef typename Traits1::iterator_category iterator_category; public: Concatenate_iterator() : e1_(), i1_(), b2_(), i2_() {} Concatenate_iterator(It1 e1, It2 b2, It1 i1) : e1_(e1), i1_(i1), b2_(b2), i2_(b2) {} Concatenate_iterator(It1 e1, It2 b2, It2 i2, int) : e1_(e1), i1_(e1), b2_(b2), i2_(i2) {} Self& operator++() { if ( i1_ == e1_ ) { ++i2_; } else { ++i1_; } return *this; } Self operator++(int) { Self tmp = *this; ++(*this); return tmp; } Self& operator--() { if ( i2_ == b2_ ) { --i1_; } else { --i2_; } return *this; } Self operator--(int) { Self tmp = *this; --(*this); return tmp; } reference operator*() const { if ( i1_ == e1_ ) { return *i2_; } else { return *i1_; } } pointer operator->() const { if ( i1_ == e1_ ) { return i2_.operator->(); } else { return i1_.operator->(); } } friend bool operator==<>(const Self&, const Self&); protected: It1 e1_, i1_; It2 b2_, i2_; }; template inline bool operator==(const Concatenate_iterator& it1, const Concatenate_iterator& it2) { return (it1.i1_ == it2.i1_ && it1.i2_ == it2.i2_); } template inline bool operator!=(const Concatenate_iterator& it1, const Concatenate_iterator& it2) { return !(it1 == it2); } CGAL_END_NAMESPACE #endif // CGAL_CONCATENATE_ITERATOR mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_3.h0000644000175000017500000005725011344301500027752 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert // : Amol Prakash #ifndef CGAL_CONVEX_HULL_3_H #define CGAL_CONVEX_HULL_3_H #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS namespace CGAL { template class Build_coplanar_poly : public Modifier_base { public: Build_coplanar_poly(ForwardIterator i, ForwardIterator j) { start = i; end = j; } void operator()( HDS& hds) { Polyhedron_incremental_builder_3 B(hds,true); ForwardIterator iter = start; int count = 0; while (iter != end) { count++; iter++; } B.begin_surface(count, 1, 2*count); iter = start; while (iter != end) { B.add_vertex(*iter); iter++; } iter = start; B.begin_facet(); int p = 0; while (p < count) { B.add_vertex_to_facet(p); p++; } B.end_facet(); B.end_surface(); } private: ForwardIterator start; ForwardIterator end; }; template void coplanar_3_hull(InputIterator first, InputIterator beyond, Plane_3 plane, Polyhedron_3& P, const Traits& traits) { typedef typename Traits::R R; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Vector_3 Vector_3; typedef typename Traits::Max_coordinate_3 Max_coordinate_3; typedef Polyhedron_3 Polyhedron; std::list CH_2; typedef typename std::list::iterator CH_2_iterator; typedef typename Traits::Construct_orthogonal_vector_3 Construct_normal_vec; Max_coordinate_3 max_coordinate = traits.max_coordinate_3_object(); Construct_normal_vec c_normal = traits.construct_orthogonal_vector_3_object(); Vector_3 normal = c_normal(plane); int max_coord = max_coordinate(normal); switch (max_coord) { case 0: { convex_hull_points_2(first, beyond, std::back_inserter(CH_2), Convex_hull_projective_yz_traits_2()); break; } case 1: { convex_hull_points_2(first, beyond, std::back_inserter(CH_2), Convex_hull_projective_xz_traits_2()); break; } case 2: { convex_hull_points_2(first, beyond, std::back_inserter(CH_2), Convex_hull_projective_xy_traits_2()); break; } default: break; } typedef typename Polyhedron::Halfedge_data_structure HDS; Build_coplanar_poly poly(CH_2.begin(),CH_2.end()); P.delegate(poly); } // // visible is the set of facets visible from point and reachable from // start_facet. // template void find_visible_set(const typename Traits::Point_3& point, Facet_handle start_facet, std::list& visible, const Traits& traits) { typedef typename Facet_handle::value_type Facet; typedef typename Facet::Halfedge_around_facet_circulator Halfedge_circ; typedef typename Facet::Halfedge_handle Halfedge_handle; typedef typename Traits::Plane_3 Plane_3; typename Traits::Has_on_positive_side_3 has_on_positive_side = traits.has_on_positive_side_3_object(); visible.clear(); typename std::list::iterator vis_it; CGAL::Unique_hash_map visited(false); visible.push_back(start_facet); visited[start_facet] = true; Facet_handle current; for (vis_it = visible.begin(); vis_it != visible.end(); vis_it++) { // check all the neighbors of the current facet to see if they have // already been visited or not and if not whether they are visible // or not. current = *vis_it; Halfedge_circ hdl_init = (*current).facet_begin(); Halfedge_circ hdl_curr = hdl_init; do { // the facet on the other side of the current halfedge Facet_handle f = (*(*hdl_curr).opposite()).facet(); // if haven't already seen this facet if ( !visited[f] ) { visited[f] = true; Plane_3 plane; get_plane(plane,f); if ( has_on_positive_side(plane, point) ) // is visible { visible.push_back(f); } } hdl_curr++; } while (hdl_curr != hdl_init); } } // using a third template parameter for the point instead of getting it from // the traits class as it should be is required by M$VC6 template Point farthest_outside_point(Facet_handle f_handle, std::list& outside_set, const Traits& traits) { typedef typename std::list::iterator Outside_set_iterator; typename Traits::Plane_3 plane; get_plane(plane, f_handle); CGAL_assertion(!outside_set.empty()); typename Traits::Less_signed_distance_to_plane_3 less_dist_to_plane = traits.less_signed_distance_to_plane_3_object(); Outside_set_iterator farthest_it = std::max_element(outside_set.begin(), outside_set.end(), bind_1(less_dist_to_plane, plane)); return *farthest_it; } template void compute_plane_equation(Facet_handle f) { typedef typename Facet_handle::value_type Facet; typedef typename Facet::Halfedge_handle Halfedge_handle; typedef typename Facet::Plane_3 Plane_3; Halfedge_handle h = (*f).halfedge(); (*f).plane() = Plane_3(h->opposite()->vertex()->point(), h->vertex()->point(), h->next()->vertex()->point()); } template void get_plane(Plane& plane, Facet_handle f) { typedef typename Facet_handle::value_type Facet; typedef typename Facet::Halfedge_handle Halfedge_handle; Halfedge_handle h = (*f).halfedge(); plane = Plane(h->opposite()->vertex()->point(), h->vertex()->point(), h->next()->vertex()->point()); } // using a template for the Unique_hash_map is required by M$VC7 // using a template for the Point type instead of getting it from // the traits class as it should be is required by M$VC6 template void partition_outside_sets(const std::list& new_facets, std::list& vis_outside_set, UHM& outside_sets, std::list& pending_facets, const Traits& traits) { typedef typename Traits::Plane_3 Plane_3; typename std::list::const_iterator f_list_it; typename std::list::iterator point_it; typename Traits::Has_on_positive_side_3 has_on_positive_side = traits.has_on_positive_side_3_object(); // walk through all the new facets and check each unassigned outside point // to see if it belongs to the outside set of this new facet. for (f_list_it = new_facets.begin(); f_list_it != new_facets.end(); f_list_it++) { Plane_3 plane; get_plane(plane, *f_list_it); for (point_it = vis_outside_set.begin(); point_it != vis_outside_set.end();) { if ( has_on_positive_side(plane, *point_it) ) { outside_sets[(*f_list_it)].push_back(*point_it); point_it = vis_outside_set.erase(point_it); } else point_it++; } } // put all the new facets with non-empty outside sets in the pending facets // list. for (f_list_it = new_facets.begin(); f_list_it != new_facets.end(); f_list_it++) { if (!outside_sets[*f_list_it].empty()) pending_facets.push_back(*f_list_it); } } template void ch_quickhull_3_scan( Polyhedron_3& P, std::list& pending_facets, CGAL::Unique_hash_map >& outside_sets, const Traits& traits) { typedef Polyhedron_3 Polyhedron; typedef typename Polyhedron::Halfedge_handle Halfedge_handle; typedef typename Polyhedron::Halfedge_iterator Halfedge_iterator; typedef typename Polyhedron::Facet_handle Facet_handle; typedef typename Traits::Point_3 Point_3; typedef std::list Outside_set; typedef typename std::list::iterator Outside_set_iterator; std::list visible_set; typename std::list::iterator vis_set_it; Outside_set vis_outside_set; Halfedge_iterator hole_halfedge; Halfedge_handle new_pt_halfedge; while (!pending_facets.empty()) { vis_outside_set.clear(); Facet_handle f_handle = pending_facets.back(); pending_facets.pop_back(); Point_3 farthest_pt = farthest_outside_point(f_handle, outside_sets[f_handle], traits); #ifdef CGAL_CH_3_WINDOW_DEBUG window << CGAL::RED; window << farthest_pt; cout << "farthest point is in red" << endl; char ch; cin >> ch; assert (P.is_valid(true)); window.clear(); #endif find_visible_set(farthest_pt, f_handle, visible_set, traits); // for each visible facet for (vis_set_it = visible_set.begin(); vis_set_it != visible_set.end(); vis_set_it++) { // add its outside set to the global outside set list std::copy(outside_sets[*vis_set_it].begin(), outside_sets[*vis_set_it].end(), std::back_inserter(vis_outside_set)); // delete this visible facet P.erase_facet((*(*vis_set_it)).halfedge()); outside_sets[*vis_set_it].clear(); } #ifdef CGAL_CH_3_WINDOW_DEBUG window << CGAL::RED; window << farthest_pt; window << CGAL::BLUE; window << P; cout << "farthest point is in red" << endl; cout << "after erasing visibile facets"; cin >> ch; #endif for (hole_halfedge = P.halfedges_begin(); hole_halfedge != P.halfedges_end() && !(*hole_halfedge).is_border(); hole_halfedge++) {} CGAL_assertion(hole_halfedge->is_border()); CGAL_assertion(hole_halfedge->next()->is_border()); // add a new facet and vertex to the surface. This is the first // new facet to be added. new_pt_halfedge = P.add_vertex_and_facet_to_border(hole_halfedge, (*hole_halfedge).next()); // associate the farthest point with the new vertex. (*(*new_pt_halfedge).vertex()).point() = farthest_pt; CGAL_assertion( !new_pt_halfedge->is_border() ); CGAL_assertion( new_pt_halfedge->opposite()->is_border() ); std::list new_facets; new_facets.push_back(new_pt_halfedge->facet()); Halfedge_handle start_hole_halfedge = new_pt_halfedge->opposite()->prev(); CGAL_assertion( start_hole_halfedge->is_border() ); CGAL_assertion( start_hole_halfedge->vertex()->point() == farthest_pt ); // need to move to second next halfedge to get to a point where a // triangular facet can be created Halfedge_handle curr_halfedge = start_hole_halfedge->next()->next(); CGAL_assertion( curr_halfedge->is_border() ); Halfedge_handle new_halfedge; // now walk around all the border halfedges and add a facet incident to // each one to connect it to the farthest point while (curr_halfedge->next() != start_hole_halfedge) { new_halfedge = P.add_facet_to_border(start_hole_halfedge, curr_halfedge); CGAL_assertion( !new_halfedge->is_border() ); CGAL_assertion( new_halfedge->opposite()->is_border() ); new_facets.push_back(new_halfedge->facet()); // once the new facet is added curr->next() will be the next halfedge // on this facet (i.e., not a border halfedge), so the next border // halfedge will be the one after the opposite of the new halfedge curr_halfedge = new_halfedge->opposite()->next(); CGAL_assertion( curr_halfedge->is_border() ); } // fill in the last triangular hole with a facet new_halfedge = P.fill_hole(curr_halfedge); new_facets.push_back(new_halfedge->facet()); #ifdef CGAL_CH_3_WINDOW_DEBUG window << CGAL::BLUE; window << P; cout << "after filling hole" << endl; char c; cin >> c; assert (P.is_valid(true)); #endif // now partition the set of outside set points among the new facets. partition_outside_sets(new_facets, vis_outside_set, outside_sets, pending_facets, traits); } } template void non_coplanar_quickhull_3(std::list& points, Polyhedron_3& P, const Traits& traits) { typedef Polyhedron_3 Polyhedron; typedef typename Polyhedron::Facet_handle Facet_handle; typedef typename Polyhedron::Facet_iterator Facet_iterator; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Plane_3 Plane_3; typedef CGAL::Unique_hash_map > Outside_set_map; typedef typename std::list::iterator P3_iterator; std::list pending_facets; Facet_iterator f_it; typename Traits::Has_on_positive_side_3 has_on_positive_side = traits.has_on_positive_side_3_object(); Outside_set_map outside_sets; // for each facet, look at each unassigned point and decide if it belongs // to the outside set of this facet. for (f_it = P.facets_begin(); f_it != P.facets_end(); f_it++) { Plane_3 plane; get_plane(plane, f_it); for (P3_iterator point_it = points.begin() ; point_it != points.end(); ) { if ( has_on_positive_side(plane, *point_it) ){ outside_sets[f_it].push_back(*point_it); point_it = points.erase(point_it); } else { ++point_it; } } } // add all the facets with non-empty outside sets to the set of facets for // further consideration for (f_it = P.facets_begin(); f_it != P.facets_end(); f_it++) if (!outside_sets[f_it].empty()) pending_facets.push_back(f_it); ch_quickhull_3_scan(P, pending_facets, outside_sets, traits); CGAL_ch_expensive_postcondition(all_points_inside(points.begin(), points.end(),P,traits)); CGAL_ch_postcondition(is_strongly_convex_3(P, traits)); } template void ch_quickhull_polyhedron_3(std::list& points, InputIterator point1_it, InputIterator point2_it, InputIterator point3_it, Polyhedron_3& P, const Traits& traits) { typedef typename Traits::Point_3 Point_3; typedef typename Traits::Plane_3 Plane_3; typedef typename std::list::iterator P3_iterator; // found three points that are not collinear, so construct the plane defined // by these points and then find a point that has maximum distance from this // plane. typename Traits::Construct_plane_3 construct_plane = traits.construct_plane_3_object(); Plane_3 plane = construct_plane(*point3_it, *point2_it, *point1_it); typedef typename Traits::Less_signed_distance_to_plane_3 Dist_compare; Dist_compare compare_dist = traits.less_signed_distance_to_plane_3_object(); typename Traits::Coplanar_3 coplanar = traits.coplanar_3_object(); // find both min and max here since using signed distance. If all points // are on the negative side of ths plane, the max element will be on the // plane. std::pair min_max; min_max = CGAL::min_max_element(points.begin(), points.end(), bind_1(compare_dist, plane), bind_1(compare_dist, plane)); P3_iterator max_it; if (coplanar(*point1_it, *point2_it, *point3_it, *min_max.second)) { max_it = min_max.first; // want the orientation of the points defining the plane to be positive // so have to reorder these points if all points were on negative side // of plane std::swap(*point1_it, *point3_it); } else max_it = min_max.second; #ifdef CGAL_CH_3_WINDOW_DEBUG window << CGAL::GREEN; window << *point1_it; window << *point2_it; window << *point3_it; window << CGAL::RED; window << *max_it; char ch; cin >> ch; #endif // if the maximum distance point is on the plane then all are coplanar if (coplanar(*point1_it, *point2_it, *point3_it, *max_it)) { coplanar_3_hull(points.begin(), points.end(), plane, P, traits); } else { P.make_tetrahedron(*point1_it, *point2_it, *point3_it, *max_it); points.erase(point1_it); points.erase(point2_it); points.erase(point3_it); points.erase(max_it); if (!points.empty()) non_coplanar_quickhull_3(points, P, traits); } } template void convex_hull_3(InputIterator first, InputIterator beyond, Object& ch_object, const Traits& traits) { typedef typename Traits::Point_3 Point_3; typedef typename Traits::Plane_3 Plane_3; typedef std::list Point_3_list; typedef typename Point_3_list::iterator P3_iterator; typedef std::pair P3_iterator_pair; if (first == beyond) // No point return; Point_3_list points(first, beyond); unsigned int size = points.size(); if ( size == 1 ) // 1 point { ch_object = make_object(*points.begin()); return; } else if ( size == 2 ) // 2 points { typedef typename Traits::Segment_3 Segment_3; typename Traits::Construct_segment_3 construct_segment = traits.construct_segment_3_object(); Segment_3 seg = construct_segment(*points.begin(), *(++points.begin())); ch_object = make_object(seg); return; } else if ( size == 3 ) // 3 points { typedef typename Traits::Triangle_3 Triangle_3; typename Traits::Construct_triangle_3 construct_triangle = traits.construct_triangle_3_object(); Triangle_3 tri = construct_triangle(*(points.begin()), *(++points.begin()), *(--points.end())); ch_object = make_object(tri); return; } // at least 4 points typename Traits::Collinear_3 collinear = traits.collinear_3_object(); P3_iterator point1_it = points.begin(); P3_iterator point2_it = points.begin(); point2_it++; P3_iterator point3_it = points.end(); point3_it--; // find three that are not collinear while (point2_it != points.end() && collinear(*point1_it,*point2_it,*point3_it)) point2_it++; // all are collinear, so the answer is a segment if (point2_it == points.end()) { typedef typename Traits::Less_distance_to_point_3 Less_dist; Less_dist less_dist = traits.less_distance_to_point_3_object(); P3_iterator_pair endpoints = min_max_element(points.begin(), points.end(), bind_1(less_dist, *points.begin()), bind_1(less_dist, *points.begin())); typename Traits::Construct_segment_3 construct_segment = traits.construct_segment_3_object(); typedef typename Traits::Segment_3 Segment_3; Segment_3 seg = construct_segment(*endpoints.first, *endpoints.second); ch_object = make_object(seg); return; } typename Traits::Polyhedron_3 P; // result will be a polyhedron ch_quickhull_polyhedron_3(points, point1_it, point2_it, point3_it, P, traits); ch_object = make_object(P); } template void convex_hull_3(InputIterator first, InputIterator beyond, Object& ch_object) { typedef typename std::iterator_traits::value_type Point_3; typedef typename Kernel_traits::Kernel K; convex_hull_3(first, beyond, ch_object, Convex_hull_traits_3()); } template void convex_hull_3(InputIterator first, InputIterator beyond, Polyhedron_3& polyhedron, const Traits& traits) { typedef typename Traits::Point_3 Point_3; typedef typename Traits::Plane_3 Plane_3; typedef std::list Point_3_list; typedef typename Point_3_list::iterator P3_iterator; Point_3_list points(first, beyond); CGAL_ch_precondition(points.size() > 3); // at least 4 points typename Traits::Collinear_3 collinear = traits.collinear_3_object(); typename Traits::Equal_3 equal = traits.equal_3_object(); P3_iterator point1_it = points.begin(); P3_iterator point2_it = points.begin(); point2_it++; // find three that are not collinear while (point2_it != points.end() && equal(*point1_it,*point2_it)) ++point2_it; CGAL_ch_precondition_msg(point2_it != points.end(), "All points are equal; cannot construct polyhedron."); P3_iterator point3_it = point2_it; ++point3_it; CGAL_ch_precondition_msg(point3_it != points.end(), "Only two points with different coordinates; cannot construct polyhedron."); while (point3_it != points.end() && collinear(*point1_it,*point2_it,*point3_it)) ++point3_it; CGAL_ch_precondition_msg(point3_it != points.end(), "All points are collinear; cannot construct polyhedron."); polyhedron.clear(); // result will be a polyhedron ch_quickhull_polyhedron_3(points, point1_it, point2_it, point3_it, polyhedron, traits); } template void convex_hull_3(InputIterator first, InputIterator beyond, Polyhedron_3& polyhedron) { typedef typename std::iterator_traits::value_type Point_3; typedef typename Kernel_traits::Kernel K; convex_hull_3(first, beyond, polyhedron, Convex_hull_traits_3()); } } // namespace CGAL #endif // CGAL_CONVEX_HULL_3_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Line_2_interse0000644000175000017500000000566111344301500031206 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POINT_2_LINE_2_INTERSECTION_H #define CGAL_POINT_2_LINE_2_INTERSECTION_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Line_2 &line, const K&) { return line.has_on(pt); } template inline bool do_intersect(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Point_2 &pt, const K&) { return line.has_on(pt); } template Object intersection(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { if (do_intersect(pt,line, k)) { return make_object(pt); } return Object(); } template Object intersection(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Point_2 &pt, const K& k) { if (do_intersect(pt,line, k)) { return make_object(pt); } return Object(); } } // namespace CGALi template inline bool do_intersect(const Line_2 &line, const Point_2 &pt) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, line); } template inline bool do_intersect(const Point_2 &pt, const Line_2 &line) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, line); } template inline Object intersection(const Line_2 &line, const Point_2 &pt) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, line); } template inline Object intersection(const Point_2 &pt, const Line_2 &line) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, line); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/utils.h0000644000175000017500000000250411344301501026333 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/utils.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_UTILS_H #define CGAL_UTILS_H #ifndef CGAL_ASSERTIONS_H #include #endif // CGAL_ASSERTIONS_H #ifndef CGAL_KERNEL_ASSERTIONS_H #include #endif // CGAL_KERNEL_ASSERTIONS_H #endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_constructions_rtH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_const0000644000175000017500000000446411344301500031467 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_constructions_rtH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_RTH2_H #define CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_RTH2_H #include #include CGAL_BEGIN_NAMESPACE template < class RT, class We > inline void ad_circumcenterH2(const RT &hx1, const RT &hy1, const RT &hw1, const We &w1, const RT &hx2, const RT &hy2, const RT &hw2, const We &w2, const RT &hx3, const RT &hy3, const RT &hw3, const We &w3, RT & cx, RT & cy, RT & cw) { We cwt; ad_circumcircleH2(hx1, hy1, hw1, w1, hx2, hy2, hw2, w2, hx3, hy3, hw3, w3, cx, cy, cw, cwt); } template < class RT, class We > inline void ad_circumcircleH2(const RT &hx1, const RT &hy1, const RT &hw1, const We &w1, const RT &hx2, const RT &hy2, const RT &hw2, const We &w2, const RT &hx3, const RT &hy3, const RT &hw3, const We &w3, RT & cx, RT & cy, RT & cw, We &cwt) { ad_circumcircleC2(RT(hx1/hw1), RT(hy1/hw1), w1, RT(hx2/hw2), RT(hy2/hw2), w2, RT(hx3/hw3), RT(hy3/hw3), w3, cx, cy, cwt); cw = RT(1); } template < class RT, class We > void ad_left_bitangent_lineH2(const FT &hx1, const FT &hy1, const We &w1, const FT &hx2, const FT &hy2, const We &w2, RT & a, RT & b, RT & c) { ad_left_bitangent_lineC2(RT(hx1/hw1), RT(hy1/hw1), w1, RT(hx2/hw2), RT(hy2/hw2), w2, a, b, c); } CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_RTH2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_3.h0000644000175000017500000014514711344301500027634 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the so // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA // Andreas Fabri // Mariette Yvinec #ifndef CGAL_ALPHA_SHAPE_3_H #define CGAL_ALPHA_SHAPE_3_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CGAL_USE_GEOMVIEW #include // TBC #endif //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- template < class Dt > class Alpha_shape_3 : public Dt { // DEFINITION The class Alpha_shape_3
    represents the family // of alpha-shapes for a set of points (or a set of weighted points) // for all possible values of alpha. The alphashape is defined through // the Delaunay tetrahedralization of the points // (or the Regular tetrahedralization in case of weighted points) // and depends on the value of a parameter called alpha. // The alpha_shape is the domain of a subcomplex of this triangulation // called the Alpha_complex. The alpha_complex includes any simplex // having a circumscribing sphere (an orthogonal sphere // in case of weighted points) empty of other points // (or suborthogonal to other sites in case of weighted points) // with squared radius equal or less than alpha // The alpha_shapes comes in two versions : GENERAL or REGULARIZED // where the REGULARIZED version is onbtaining by restricting the // alpha complex ti is pure 3D component. // The cells of the triangulation are classified as INTERIOR // or EXTERIOR according to the value alpha_cell of their circumsphere // squared radius compared to alpha. // In GENERAL mode each k-dimensional simplex of the triangulation // for (k=0,1,2) // can be classified as EXTERIOR, SINGULAR, REGULAR // or INTERIOR with respect to the alpha shape. // In GENERAL mode a $k$ simplex is REGULAR if it is on the boundary // of the alpha_complex and belongs to a $k+1$ simplex in the complex // and it is SINGULAR simplex if it is a boundary simplex tht is not // included in a $k+1$ simplex of the complex. // In REGULARIZED mode each k-dimensional simplex of the triangulation // for (k=0,1,2) // can be classified as EXTERIOR, REGULAR // or INTERIOR with respect to the alpha shape. // A $k$ simplex is REGULAR if it is on the boundary of alpha complex // and belong to a tetrahedral cell of the complex. // Roughly, the Alpha_shapes data structure computes and stores, // for each simplex // the at most three critical value (alpha_min, alpha_mid and alpha_max) // which compared to the actual alpha value // determine the classification of the simplex. //------------------------- TYPES ------------------------------------ public: typedef Dt Triangulation; typedef typename Dt::Geom_traits Gt; typedef typename Dt::Triangulation_data_structure Tds; typedef typename Gt::FT Coord_type; typedef Coord_type NT; typedef typename Gt::Point_3 Point; typedef typename Dt::Cell_handle Cell_handle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Facet Facet; typedef typename Dt::Edge Edge; typedef typename Dt::Cell_circulator Cell_circulator; typedef typename Dt::Facet_circulator Facet_circulator; typedef typename Dt::Cell_iterator Cell_iterator; typedef typename Dt::Facet_iterator Facet_iterator; typedef typename Dt::Edge_iterator Edge_iterator; typedef typename Dt::Vertex_iterator Vertex_iterator; typedef typename Dt::Finite_cells_iterator Finite_cells_iterator; typedef typename Dt::Finite_facets_iterator Finite_facets_iterator; typedef typename Dt::Finite_edges_iterator Finite_edges_iterator; typedef typename Dt::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Dt::Locate_type Locate_type; typedef typename Dt::Weighted_tag Weighted_tag; using Dt::dimension; using Dt::finite_facets_begin; using Dt::finite_facets_end; using Dt::finite_edges_begin; using Dt::finite_edges_end; using Dt::finite_vertices_begin; using Dt::finite_vertices_end; using Dt::finite_cells_begin; using Dt::finite_cells_end; using Dt::VERTEX; using Dt::EDGE; using Dt::FACET; using Dt::CELL; using Dt::OUTSIDE_CONVEX_HULL; using Dt::OUTSIDE_AFFINE_HULL; using Dt::vertex_triple_index; enum Classification_type {EXTERIOR, SINGULAR, REGULAR, INTERIOR}; enum Mode {GENERAL, REGULARIZED}; typedef Alpha_status< NT > Alpha_status; typedef Compact_container Alpha_status_container; typedef typename Alpha_status_container::const_iterator Alpha_status_const_iterator; typedef typename Alpha_status_container::iterator Alpha_status_iterator; typedef std::vector< NT > Alpha_spectrum; typedef std::multimap< NT, Cell_handle > Alpha_cell_map; typedef std::multimap< NT, Facet> Alpha_facet_map; typedef std::multimap< NT, Edge > Alpha_edge_map; typedef std::multimap< NT, Vertex_handle> Alpha_vertex_map; typedef std::pair Vertex_handle_pair; typedef std::map Edge_alpha_map; typedef typename std::list< Vertex_handle >::iterator Alpha_shape_vertices_iterator; typedef typename std::list< Facet >::iterator Alpha_shape_facets_iterator; //test if a cell is exterior to the alphashape class Exterior_cell_test{ const Alpha_shape_3 * _as; public: Exterior_cell_test() {} Exterior_cell_test(const Alpha_shape_3 * as) {_as = as;} bool operator() ( const Finite_cells_iterator& fci) const { return _as->classify(fci) == EXTERIOR ; } }; typedef Filter_iterator< Finite_cells_iterator, Exterior_cell_test> Alpha_shape_cells_iterator; typedef typename Alpha_spectrum::const_iterator Alpha_iterator; // An iterator that allow to traverse the sorted sequence of // different alpha-values. The iterator is bidirectional and // non-mutable. Its value-type is NT private: typedef Unique_hash_map Marked_cell_set; private: NT _alpha; NT _alpha_solid; Mode _mode; mutable bool use_vertex_cache; mutable bool use_facet_cache; // only finite facets and simplices are inserted into the maps Alpha_cell_map alpha_cell_map; Alpha_facet_map alpha_min_facet_map; Alpha_edge_map alpha_min_edge_map; Alpha_vertex_map alpha_min_vertex_map; Alpha_spectrum alpha_spectrum; Alpha_status_container alpha_status_container; Edge_alpha_map edge_alpha_map; //deprecated - for backward compatibility mutable std::list< Vertex_handle > alpha_shape_vertices_list; mutable std::list< Facet > alpha_shape_facets_list; //------------------------- CONSTRUCTORS ------------------------------ public: // Introduces an empty alpha-shape `A' for a // alpha-value `alpha'. Alpha_shape_3(NT alpha = 0, Mode m = REGULARIZED) : _alpha(alpha), _mode(m), use_vertex_cache(false), use_facet_cache(false) {} Alpha_shape_3(Dt& dt, NT alpha = 0, Mode m = REGULARIZED) :_alpha(alpha), _mode(m), use_vertex_cache(false), use_facet_cache(false) { Dt::swap(dt); if (dimension() == 3) initialize_alpha(); } // Introduces an alpha-shape `A' for the alpha-value // `alpha' that is initialized with the points in the range // from first to last template < class InputIterator > Alpha_shape_3(const InputIterator& first, const InputIterator& last, const NT& alpha = 0, Mode m = REGULARIZED) : _alpha(alpha), _mode(m), use_vertex_cache(false), use_facet_cache(false) { Dt::insert(first, last); if (dimension() == 3) initialize_alpha(); } public: //----------------------- OPERATIONS --------------------------------- template < class InputIterator > int make_alpha_shape(const InputIterator& first, const InputIterator& last) { clear(); int n = Dt::insert(first, last); if (dimension() == 3) initialize_alpha(); return n; } // Introduces an alpha-shape `A' // that is initialized with the points in the range // from first to last private : //--------------------- INITIALIZATION OF PRIVATE MEMBERS ----------- // called with reinitialize=false on first initialization // reinitialize=true when switching the mode. void initialize_alpha_cell_map(); void initialize_alpha_facet_maps(bool reinitialize = false); void initialize_alpha_edge_maps(bool reinitialize = false); void initialize_alpha_vertex_maps(bool reinitialize = false); void initialize_alpha_spectrum(); void initialize_alpha(bool reinitialize = false) { if (reinitialize == false) initialize_alpha_cell_map(); initialize_alpha_facet_maps(reinitialize); initialize_alpha_edge_maps(reinitialize); initialize_alpha_vertex_maps(reinitialize); initialize_alpha_spectrum(); } private : Vertex_handle_pair make_vertex_handle_pair( Vertex_handle v1, Vertex_handle v2) const { return v1 < v2 ? std::make_pair(v1,v2) : std::make_pair(v2,v1); } // the version to be used with Tag_true is templated to avoid // instanciation through explicit instantiation of the whole class void set_alpha_min_of_vertices(Tag_false) { for( Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit){ Alpha_status* as = vit->get_alpha_status(); as->set_is_Gabriel(true); as->set_alpha_min(NT(0)); } // insert a single vertex into the map because they all have the // same alpha_min value alpha_min_vertex_map.insert(typename Alpha_vertex_map::value_type ( NT(0), finite_vertices_begin())); } template void set_alpha_min_of_vertices(Tag) { for( Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit) { if (is_Gabriel(vit)) { Alpha_status* as = vit->get_alpha_status(); as->set_is_Gabriel(true); as->set_alpha_min(squared_radius(vit)); alpha_min_vertex_map.insert(typename Alpha_vertex_map::value_type (as->alpha_min(),vit)); } } return; } //--------------------------------------------------------------------- public: void clear() { // clears the structure alpha_status_container.clear(); Dt::clear(); alpha_cell_map.clear(); alpha_min_facet_map.clear(); alpha_min_edge_map.clear(); alpha_min_vertex_map.clear(); alpha_spectrum.clear(); alpha_shape_vertices_list.clear(); alpha_shape_facets_list.clear(); use_vertex_cache = false; use_facet_cache = false; } //--------------------------------------------------------------------- public: NT set_alpha(const NT& alpha) // Sets the alpha-value to `alpha'. Precondition: `alpha' >= 0. // Returns the previous alpha { NT previous_alpha = _alpha; _alpha = alpha; use_vertex_cache = false; use_facet_cache = false; return previous_alpha; } const NT& get_alpha() const // Returns the current alpha-value. { return _alpha; } const NT& get_nth_alpha(int n) const // Returns the n-th alpha-value. // n < size() { assert( n > 0 && n <= static_cast(alpha_spectrum.size()) ); return alpha_spectrum[n-1]; } int number_of_alphas() const // Returns the number of different alpha-values { return alpha_spectrum.size(); } //--------------------------------------------------------------------- private: // the dynamic version is not yet implemented // desactivate the tetrahedralization member functions void insert(const Point& p) {} // Inserts point `p' in the alpha shape and returns the // corresponding vertex of the underlying Delaunay tetrahedralization. // If point `p' coincides with an already existing vertex, this // vertex is returned and the alpha shape remains unchanged. // Otherwise, the vertex is inserted in the underlying Delaunay // tetrahedralization and the associated intervals are updated. void remove(Vertex_handle v) {} // Removes the vertex from the underlying Delaunay tetrahedralization. // The created hole is retriangulated and the associated intervals // are updated. //--------------------------------------------------------------------- public: Mode set_mode(Mode mode = REGULARIZED ) // Sets `A' to its general or regularized version. Returns the // previous mode. { Mode previous_mode = _mode; _mode = mode; if (previous_mode != _mode) { initialize_alpha(true); use_vertex_cache = false; use_facet_cache = false; } return previous_mode; } Mode get_mode() const // Returns whether `A' is general or regularized. { return _mode; } //--------------------------------------------------------------------- private: void update_alpha_shape_vertex_list() const; void update_alpha_shape_facet_list() const; //--------------------------------------------------------------------- public: Alpha_shape_vertices_iterator alpha_shape_vertices_begin() const { if(!use_vertex_cache) update_alpha_shape_vertex_list(); return alpha_shape_vertices_list.begin(); } Alpha_shape_vertices_iterator Alpha_shape_vertices_begin() const { return alpha_shape_vertices_begin(); } //--------------------------------------------------------------------- Alpha_shape_vertices_iterator alpha_shape_vertices_end() const { return alpha_shape_vertices_list.end(); } Alpha_shape_vertices_iterator Alpha_shape_vertices_end() const { return alpha_shape_vertices_end(); } //--------------------------------------------------------------------- Alpha_shape_facets_iterator alpha_shape_facets_begin() const { if(! use_facet_cache) update_alpha_shape_facet_list(); return alpha_shape_facets_list.begin(); } Alpha_shape_facets_iterator Alpha_shape_facets_begin() const { return alpha_shape_facets_begin(); } //--------------------------------------------------------------------- Alpha_shape_facets_iterator alpha_shape_facets_end() const { return alpha_shape_facets_list.end(); } Alpha_shape_facets_iterator Alpha_shape_facets_end() const { return alpha_shape_facets_end(); } Alpha_shape_cells_iterator alpha_shape_cells_begin() const { return filter_iterator(finite_cells_end(), Exterior_cell_test(this), finite_cells_begin()); } Alpha_shape_cells_iterator alpha_shape_cells_end() const { return filter_iterator(finite_cells_end(), Exterior_cell_test(this)); } public: // Traversal of the alpha-Values // // The alpha shape class defines an iterator that allows to // visit the sorted sequence of alpha-values. This iterator is // non-mutable and bidirectional. Its value type is NT. Alpha_iterator alpha_begin() const { return alpha_spectrum.begin(); } Alpha_iterator alpha_end() const {return alpha_spectrum.end();} Alpha_iterator alpha_find(const NT& alpha) const // Returns an iterator pointing to an element with alpha-value // `alpha', or the corresponding past-the-end iterator if such an // element is not found. { return std::find(alpha_spectrum.begin(), alpha_spectrum.end(), alpha); } Alpha_iterator alpha_lower_bound(const NT& alpha) const // Returns an iterator pointing to the first element with // alpha-value not less than `alpha'. { return std::lower_bound(alpha_spectrum.begin(), alpha_spectrum.end(), alpha); } Alpha_iterator alpha_upper_bound(const NT& alpha) const // Returns an iterator pointing to the first element with // alpha-value greater than `alpha'. { return std::upper_bound(alpha_spectrum.begin(), alpha_spectrum.end(), alpha); } //--------------------- PREDICATES ----------------------------------- private: void compute_edge_status( const Cell_handle& c, int i, int j, Alpha_status& as) const; Classification_type classify(const Alpha_status& as, const NT& alpha) const; public: Classification_type classify(const Point& p) const { return classify(p, get_alpha()); } Classification_type classify(const Point& p, const NT& alpha) const // Classifies a point `p' with respect to `A'. { Locate_type type; int i, j; Cell_handle pCell = locate(p, type, i, j); switch (type) { case VERTEX : return classify(pCell->vertex(i), alpha); case EDGE : return classify(pCell, i, j, alpha); case FACET : return classify(pCell, i, alpha); case CELL : return classify(pCell, alpha); case OUTSIDE_CONVEX_HULL : return EXTERIOR; case OUTSIDE_AFFINE_HULL : return EXTERIOR; default : return EXTERIOR; }; } //--------------------------------------------------------------------- Classification_type classify(const Cell_handle& s) const // Classifies the cell `f' of the underlying Delaunay // tetrahedralization with respect to `A'. { return classify(s, get_alpha()); } Classification_type classify(const Cell_handle& s, const NT& alpha) const // Classifies the cell `f' of the underlying Delaunay // tetrahedralization with respect to `A'. // s->radius == alpha => f interior { if (is_infinite(s)) return EXTERIOR; return (s->get_alpha() <= alpha) ? INTERIOR : EXTERIOR; } //--------------------------------------------------------------------- Classification_type classify(const Facet& f) const { return classify(f.first, f.second, get_alpha()); } Classification_type classify(const Cell_handle& s, int i) const { return classify(s, i, get_alpha()); } Classification_type classify(const Facet& f, const NT& alpha) const { return classify(f.first, f.second, alpha); } Classification_type classify(const Cell_handle& s, int i, const NT& alpha) const; // Classifies the face `f' of the underlying Delaunay // tetrahedralization with respect to `A'. //--------------------------------------------------------------------- Classification_type classify(const Edge& e) const { return classify(e.first, e.second, e.third, get_alpha()); } Classification_type classify(const Cell_handle& s, int i, int j) const { return classify(s, i, j, get_alpha()); } Classification_type classify(const Edge& e, const NT& alpha ) const { return classify(e.first, e.second, e.third, alpha); } Classification_type classify(const Cell_handle& s, int i, int j, const NT& alpha) const; // Classifies the edge `e' of the underlying Delaunay // tetrahedralization with respect to `A'. //--------------------------------------------------------------------- Classification_type classify(const Vertex_handle& v) const { return classify(v, get_alpha()); } Classification_type classify(const Vertex_handle& v, const NT& alpha) const; // Classifies the vertex `v' of the underlying Delaunay // tetrahedralization with respect to `A'. //--------------------- NB COMPONENTS --------------------------------- int number_solid_components() const { return number_of_solid_components(get_alpha()); } int number_of_solid_components() const { return number_of_solid_components(get_alpha()); } int number_solid_components(const NT& alpha) const { return number_of_solid_components(alpha); } int number_of_solid_components(const NT& alpha) const; // Determine the number of connected solid components // takes time O(#alpha_shape) amortized if STL_HASH_TABLES // O(#alpha_shape log n) otherwise private: void traverse(Cell_handle pCell, Marked_cell_set& marked_cell_set, const NT alpha) const; //---------------------------------------------------------------------- public: Alpha_iterator find_optimal_alpha(int nb_components); // find the minimum alpha that satisfies the properties // (1) all data points are on the boundary of some 3d component // or in its interior // (2) the nb of solid components is equal or less than nb_component NT find_alpha_solid() const; // compute the minumum alpha such that all data points // are either on the boundary or in the interior // not necessarily connected // starting point for searching // takes O(#alpha_shape) time //------------------- GEOMETRIC PRIMITIVES ---------------------------- private: NT squared_radius(const Cell_handle& s) const { return Gt().compute_squared_radius_3_object()(s->vertex(0)->point(), s->vertex(1)->point(), s->vertex(2)->point(), s->vertex(3)->point()); } NT squared_radius(const Cell_handle& s, const int& i) const { return Gt().compute_squared_radius_3_object() ( s->vertex(vertex_triple_index(i,0))->point(), s->vertex(vertex_triple_index(i,1))->point(), s->vertex(vertex_triple_index(i,2))->point()); } NT squared_radius(const Facet& f) const { return squared_radius(f.first, f.second); } NT squared_radius(const Cell_handle& s, const int& i, const int& j) const { return Gt().compute_squared_radius_3_object()(s->vertex(i)->point(), s->vertex(j)->point()); } NT squared_radius(const Edge& e) const { return squared_radius(e.first,e.second,e.third); } NT squared_radius(const Vertex_handle& v) const { return Gt().compute_squared_radius_3_object()(v->point()); } //--------------------------------------------------------------------- private: // prevent default copy constructor and default assigment Alpha_shape_3(const Alpha_shape_3& A) {} void operator=(const Alpha_shape_3& A) {} //--------------------------------------------------------------------- public: #ifdef CGAL_USE_GEOMVIEW void show_alpha_shape_faces(Geomview_stream &gv) const; #endif // to Debug void print_maps(); //should be const void print_alphas() const; void print_alpha_status( const Alpha_status& as) const; // To extract the alpha_shape faces for a given alpha value template OutputIterator get_alpha_shape_cells(OutputIterator it, Classification_type type, const NT& alpha) const { Finite_cells_iterator cit = finite_cells_begin(); for( ; cit != finite_cells_end() ; ++cit){ if (classify(cit) == type) *it++ = Cell_handle(cit); } return it; } template OutputIterator get_alpha_shape_facets(OutputIterator it, Classification_type type, const NT& alpha) const { Finite_facets_iterator fit = finite_facets_begin(); for( ; fit != finite_facets_end() ; ++fit){ if (classify(*fit) == type) *it++ = *fit; } return it; } template OutputIterator get_alpha_shape_edges(OutputIterator it, Classification_type type, const NT& alpha) const { Finite_edges_iterator eit = finite_edges_begin(); for( ; eit != finite_edges_end() ; ++eit){ if (classify(*eit) == type) *it++ = *eit; } return it; } template OutputIterator get_alpha_shape_vertices(OutputIterator it, Classification_type type, const NT& alpha) const { Finite_vertices_iterator vit = finite_vertices_begin(); for( ; vit != finite_vertices_end() ; ++vit){ if (classify(vit) == type) *it++ = Vertex_handle(vit); } return it; } template OutputIterator get_alpha_shape_cells(OutputIterator it, Classification_type type) const { return get_alpha_shape_cells(it, type, get_alpha());} template OutputIterator get_alpha_shape_facets(OutputIterator it, Classification_type type) const { return get_alpha_shape_facets(it, type, get_alpha());} template OutputIterator get_alpha_shape_edges(OutputIterator it, Classification_type type) const { return get_alpha_shape_edges(it, type, get_alpha());} template OutputIterator get_alpha_shape_vertices(OutputIterator it, Classification_type type) const { return get_alpha_shape_vertices(it, type, get_alpha());} }; //--------------------------------------------------------------------- //--------------------- MEMBER FUNCTIONS------------------------------- //--------------------------------------------------------------------- //--------------------- INITIALIZATION OF PRIVATE MEMBERS ------------- template void Alpha_shape_3
    ::initialize_alpha_cell_map() { Finite_cells_iterator cell_it, done = finite_cells_end(); NT alpha ; for( cell_it = finite_cells_begin(); cell_it != done; ++cell_it) { alpha = squared_radius(cell_it); alpha_cell_map.insert(typename Alpha_cell_map::value_type(alpha, cell_it)); // cross references cell_it->set_alpha(alpha); } return; } //--------------------------------------------------------------------- template void Alpha_shape_3
    ::initialize_alpha_facet_maps(bool reinitialize) { Finite_facets_iterator fit; Cell_handle pCell, pNeighbor ; int i, iNeigh; Alpha_status_iterator as; if (!reinitialize) { NT alpha_max, alpha_mid; for( fit = finite_facets_begin(); fit != finite_facets_end(); ++fit) { as = alpha_status_container.insert(Alpha_status()); pCell = fit->first; i = fit->second; pNeighbor = pCell->neighbor(i); iNeigh = pNeighbor->index(pCell); // not on the convex hull if(!is_infinite(pCell) && !is_infinite(pNeighbor)) { NT alpha_Cell = pCell->get_alpha(); NT alpha_Neighbor = pNeighbor->get_alpha(); if ( alpha_Cell < alpha_Neighbor) { alpha_mid = alpha_Cell; alpha_max = alpha_Neighbor; } else { alpha_mid = alpha_Neighbor; alpha_max = alpha_Cell; } as->set_is_on_chull(false); as->set_alpha_mid(alpha_mid); as->set_alpha_max(alpha_max); // alpha_mid_facet_map.insert(typename // Alpha_facet_map::value_type(alpha_mid, *fit)); } else { // on the convex hull alpha_mid = !is_infinite(pCell) ? pCell->get_alpha() : pNeighbor->get_alpha(); as->set_alpha_mid(alpha_mid); as->set_is_on_chull(true); } //cross links pCell->set_facet_status(i, as); pNeighbor->set_facet_status(iNeigh,as); } } // initialize alpha_min if mode GENERAL if(get_mode() == GENERAL && alpha_min_facet_map.empty()) { //already done if !alpha_min_facet_map.empty() NT alpha_min; for( fit = finite_facets_begin(); fit != finite_facets_end(); ++fit) { as = fit->first->get_facet_status(fit->second); if (is_Gabriel(*fit)) { as->set_is_Gabriel(true); alpha_min = squared_radius(*fit); as->set_alpha_min(alpha_min); alpha_min_facet_map.insert(typename Alpha_facet_map::value_type(alpha_min, *fit)); } else as->set_is_Gabriel(false); } } return; } template void Alpha_shape_3
    ::initialize_alpha_edge_maps(bool ) { // alpha_status for edges, edge_alpha_map // and alpha_mid_edge and alpha_min_edge // are initialized only in GENERAL mode if(get_mode() == REGULARIZED) {return;} //no_edge_map in REGULARIZED mode if ( !edge_alpha_map.empty()) return; // already done Finite_edges_iterator eit; Alpha_status_iterator as; for (eit = finite_edges_begin(); eit != finite_edges_end(); ++eit) { as = alpha_status_container.insert(Alpha_status()); compute_edge_status(eit->first, eit->second, eit->third, *as); if ( as->is_Gabriel()) { alpha_min_edge_map.insert(typename Alpha_edge_map::value_type(as->alpha_min(), *eit)); } //cross links Vertex_handle_pair vhp = make_vertex_handle_pair( eit->first->vertex(eit->second), eit->first->vertex(eit->third)); edge_alpha_map.insert(std::make_pair(vhp, as)); } return; } template void Alpha_shape_3
    ::initialize_alpha_vertex_maps(bool reinitialize) { //for a vertex // alpha_max = max of alpha values of incident cells // alpha_mid = min of alpha values of incident cells in GENERAL mode // = min of alpha values of incidents faces in REGULAR mode // alpha_min = -squared_radius of weighted point, // if the vertex is Gabriel set only in GENERAL mode NT alpha, alpha_mid; Finite_vertices_iterator vit; if (reinitialize == false) _alpha_solid = alpha_cell_map.begin()->first; for( vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit) { Alpha_status* as = vit->get_alpha_status(); if (reinitialize == false) { // set is_on_chull, compute alpha_max // and alpha_mid (version REGULAR) // compute _alpha_solid (max of alpha_mid of vertices in REGULAR mode) as->set_is_on_chull(false); std::list incidents; incident_cells(static_cast(vit), back_inserter(incidents)); typename std::list::iterator chit=incidents.begin(); if (is_infinite(*chit)) as->set_is_on_chull(true); while (is_infinite(*chit)) ++chit; //skip infinte cells alpha = (*chit)->get_alpha(); as->set_alpha_mid(alpha); as->set_alpha_max(alpha); for( ; chit != incidents.end(); ++chit) { if (is_infinite(*chit)) as->set_is_on_chull(true); else { alpha = (*chit)->get_alpha(); if (alpha < as->alpha_mid()) as->set_alpha_mid(alpha); if (alpha > as->alpha_max()) as->set_alpha_max(alpha); } } if (as->alpha_mid() > _alpha_solid) _alpha_solid = as->alpha_mid(); } if (get_mode() == GENERAL) { //reset alpha_mid, set alph_min std::list incidentv; incident_vertices(static_cast(vit), back_inserter(incidentv)); typename std::list::iterator vvit=incidentv.begin(); for( ; vvit != incidentv.end(); ++vvit) { if (!is_infinite(*vvit)) { Vertex_handle_pair vhp = make_vertex_handle_pair( *vvit, vit); Alpha_status_iterator asedge = edge_alpha_map[vhp]; alpha_mid = asedge->is_Gabriel() ? asedge->alpha_min() : asedge->alpha_mid(); if ( alpha_mid < as->alpha_mid()) as->set_alpha_mid(alpha_mid); } } } if (get_mode()== REGULARIZED && reinitialize == true) { // reset alpha_mid std::list incidents; incident_cells(static_cast(vit), back_inserter(incidents)); typename std::list::iterator chit=incidents.begin(); while (is_infinite(*chit)) ++chit; //skip infinte cells alpha = (*chit)->get_alpha(); as->set_alpha_mid(alpha); for( ; chit != incidents.end(); ++chit) { if (is_infinite(*chit)) as->set_is_on_chull(true); else { alpha = (*chit)->get_alpha(); if (alpha < as->alpha_mid()) as->set_alpha_mid(alpha); } } } } // set alpha_min in case GENERAL if (get_mode() == GENERAL && alpha_min_vertex_map.empty()) { set_alpha_min_of_vertices(Weighted_tag()); } return; } /* template */ /* void */ /* Alpha_shape_3
    ::set_alpha_min_of_vertices(Tag_true) */ /* { */ /* for( Finite_vertices_iterator vit = finite_vertices_begin(); */ /* vit != finite_vertices_end(); ++vit) { */ /* if (is_Gabriel(vit)) { */ /* Alpha_status* as = vit->get_alpha_status(); */ /* as->set_is_Gabriel(true); */ /* as->set_alpha_min(squared_radius(vit)); */ /* alpha_min_vertex_map.insert(typename Alpha_vertex_map::value_type */ /* (as->alpha_min(),vit)); */ /* } */ /* } */ /* return; */ /* } */ /* template */ /* void */ /* Alpha_shape_3
    ::set_alpha_min_of_vertices(Tag_false) */ /* { */ /* for( Finite_vertices_iterator vit = finite_vertices_begin(); */ /* vit != finite_vertices_end(); ++vit){ */ /* Alpha_status* as = vit->get_alpha_status(); */ /* as->set_is_Gabriel(true); */ /* as->set_alpha_min(NT(0)); */ /* } */ /* // insert a single vertex into the map because they all have the */ /* // same alpha_min value */ /* alpha_min_vertex_map.insert(typename Alpha_vertex_map::value_type */ /* ( NT(0), finite_vertices_begin())); */ /* } */ //--------------------------------------------------------------------- template void Alpha_shape_3
    ::initialize_alpha_spectrum() // merges the alpha values of alpha_cell_map // and alpha_min_facet_map alpha_min_edge_map alpha_min_vertex in GENERAL mode // only alpha_cell_map in REGULARIZED mode { typename Alpha_cell_map::iterator cit ; typename Alpha_facet_map::iterator fit ; typename Alpha_edge_map::iterator eit ; typename Alpha_vertex_map::iterator vit; alpha_spectrum.clear(); if (get_mode() == GENERAL) { cit = alpha_cell_map.begin(); fit = alpha_min_facet_map.begin(); eit = alpha_min_edge_map.begin(); vit = alpha_min_vertex_map.begin(); alpha_spectrum.reserve(alpha_cell_map.size() + alpha_min_facet_map.size() + alpha_min_edge_map.size() + alpha_min_vertex_map.size()); } else { alpha_spectrum.reserve(alpha_cell_map.size()); cit = alpha_cell_map.begin(); fit = alpha_min_facet_map.end(); eit = alpha_min_edge_map.end(); vit = alpha_min_vertex_map.end(); } while (cit != alpha_cell_map.end() || fit != alpha_min_facet_map.end() || eit != alpha_min_edge_map.end() ) { if ( cit != alpha_cell_map.end() && ( fit == alpha_min_facet_map.end() || !(fit->first < cit->first) ) && ( eit == alpha_min_edge_map.end() || !(eit->first < cit->first) ) && ( vit == alpha_min_vertex_map.end() || !(vit->first < cit->first) ) ) { //advance on cit if (alpha_spectrum.empty() || alpha_spectrum.back() < cit->first){ alpha_spectrum.push_back(cit->first); } cit++; } if ( fit != alpha_min_facet_map.end() && ( cit == alpha_cell_map.end() || !(cit->first < fit->first) ) && ( eit == alpha_min_edge_map.end() || !(eit->first < fit->first) ) && ( vit == alpha_min_vertex_map.end() || !(vit->first < fit->first) ) ) { //advance on fit if (alpha_spectrum.empty() || alpha_spectrum.back() < fit->first){ alpha_spectrum.push_back(fit->first); } fit++; } if ( eit != alpha_min_edge_map.end() && ( fit == alpha_min_facet_map.end() || !(fit->first < eit->first) ) && ( cit == alpha_cell_map.end() || !(cit->first < eit->first) ) && ( vit == alpha_min_vertex_map.end() || !(vit->first < eit->first) ) ) { //advance on eit if (alpha_spectrum.empty() || alpha_spectrum.back() < eit->first) { alpha_spectrum.push_back(eit->first); } eit++; } if ( vit != alpha_min_vertex_map.end() && ( fit == alpha_min_facet_map.end() || !(fit->first < vit->first) ) && ( cit == alpha_cell_map.end() || !(cit->first < vit->first) ) && ( eit == alpha_min_edge_map.end() || !(eit->first < vit->first) ) ) { //advance on eit if (alpha_spectrum.empty() || alpha_spectrum.back() < vit->first) { alpha_spectrum.push_back(vit->first); } vit++; } } } //--------------------------------------------------------------------- #if 0 // Obviously not ready yet template std::istream& operator>>(std::istream& is, const Alpha_shape_3
    & A) // Reads a alpha shape from stream `is' and assigns it to // Unknown creationvariable. Precondition: The extract operator must // be defined for `Point'. {} #endif //--------------------------------------------------------------------- template std::ostream& operator<<(std::ostream& os, const Alpha_shape_3
    & A) // Inserts the alpha shape into the stream `os' as an indexed face set. // Precondition: The insert operator must be defined for `Point' { typedef Alpha_shape_3
    AS; typedef typename AS::Vertex_handle Vertex_handle; typedef typename AS::Cell_handle Cell_handle; typedef typename AS::Alpha_shape_vertices_iterator Alpha_shape_vertices_iterator; typedef typename AS::Alpha_shape_facets_iterator Alpha_shape_facets_iterator; Unique_hash_map< Vertex_handle, int > V; int number_of_vertices = 0; Alpha_shape_vertices_iterator vit; for( vit = A.alpha_shape_vertices_begin(); vit != A.alpha_shape_vertices_end(); ++vit) { V[*vit] = number_of_vertices++; os << (*vit)->point() << std::endl; } Cell_handle c; int i; Alpha_shape_facets_iterator fit; for( fit = A.alpha_shape_facets_begin(); fit != A.alpha_shape_facets_end(); ++fit) { c = fit->first; i = fit->second; // the following ensures that regulat facets are output // in ccw order if (A.classify(*fit) == AS::REGULAR && A.classify(c) == AS::EXTERIOR){ c = c->neighbor(i); i = c->index(fit->first); } int i0=(i+1)&3, i1=(i+2)&3, i2=(i+3)&3; os << V[c->vertex(i0)] << ' ' << V[c->vertex(i1)] << ' ' << V[c->vertex(i2)] << std::endl; } return os; } //--------------------------------------------------------------------- template void Alpha_shape_3
    ::update_alpha_shape_vertex_list() const { alpha_shape_vertices_list.clear(); use_vertex_cache = true; std::back_insert_iterator > it = back_inserter(alpha_shape_vertices_list); get_alpha_shape_vertices(it, REGULAR); if (get_mode()==GENERAL) get_alpha_shape_vertices(it, SINGULAR); /* // get REGULAR vertices */ /* // alpha_mid <= alpha < alpha_max */ /* typename Alpha_vertex_map::const_iterator vit; */ /* for(vit = alpha_mid_vertex_map.begin(); */ /* vit != alpha_mid_vertex_map.upper_bound(get_alpha()); */ /* ++vit) { */ /* if (classify(vit->second) == REGULAR) */ /* alpha_shape_vertices_list.push_back(vit->second); */ /* } */ /* if (get_mode() == GENERAL){ */ /* // get SINGULAR vertices */ /* for(vit = alpha_min_vertex_map.begin(); */ /* vit != alpha_min_vertex_map.upper_bound(get_alpha()); */ /* ++vit) { */ /* if (classify(vit->second) == SINGULAR) */ /* alpha_shape_vertices_list.push_back(vit->second); */ /* } */ /* } */ return; } //--------------------------------------------------------------------- template void Alpha_shape_3
    ::update_alpha_shape_facet_list() const { alpha_shape_facets_list.clear(); use_facet_cache = true; // Writes the faces of the alpha shape `A' for the current 'alpha'-value // to the container where 'out' refers to. std::back_insert_iterator > it = back_inserter(alpha_shape_facets_list); get_alpha_shape_facets(it, REGULAR); if (get_mode()==GENERAL) get_alpha_shape_facets(it, SINGULAR); /* // Get regular facets */ /* // alpha_mid <= alpha < alpha_max */ /* typename Alpha_facet_map::const_iterator fit; */ /* for( fit = alpha_mid_facet_map.begin(); */ /* fit != alpha_mid_facet_map.upper_bound(get_alpha()); */ /* ++fit) { */ /* if (classify(fit->second) == REGULAR) */ /* alpha_shape_facets_list.push_back(fit->second); */ /* } */ /* if (get_mode() == REGULARIZED) return; */ /* // Get singular facets */ /* // alpha_min <= alpha < alpha_mid */ /* typename Alpha_facet_map::const_iterator fit2; */ /* for( fit2 = alpha_min_facet_map.begin(); */ /* fit2 != alpha_min_facet_map.upper_bound(get_alpha()); */ /* ++fit2) { */ /* if (classify(fit2->second) == SINGULAR) */ /* alpha_shape_facets_list.push_back(fit2->second); */ /* } */ return; } //--------------------------------------------------------------------- template < class Dt > typename Alpha_shape_3
    ::Classification_type Alpha_shape_3
    ::classify(const Alpha_status& as, const NT& alpha) const { //tetrahedra with circumragius=alpha are considered inside if ( !as.is_on_chull() && alpha >= as.alpha_max()) return INTERIOR; else if ( alpha >= as.alpha_mid()) return REGULAR; else if ( get_mode() == GENERAL && as.is_Gabriel() && alpha >= as.alpha_min()) return SINGULAR; else return EXTERIOR; } template < class Dt > typename Alpha_shape_3
    ::Classification_type Alpha_shape_3
    ::classify(const Cell_handle& s, int i, const NT& alpha) const // Classifies the face `f' of the underlying Delaunay // tetrahedralization with respect to `A'. { if (is_infinite(s,i)) return EXTERIOR; Alpha_status_iterator as = s->get_facet_status(i); return classify(*as, alpha); } template < class Dt > typename Alpha_shape_3
    ::Classification_type Alpha_shape_3
    ::classify(const Cell_handle& c, int i, int j, const NT& alpha) const // Classifies the edge `e' of the underlying Delaunay // tetrahedralization with respect to `A'. { if (is_infinite(c, i, j)) return EXTERIOR; Alpha_status as; if (get_mode() == GENERAL) { Vertex_handle_pair vhp=make_vertex_handle_pair(c->vertex(i),c->vertex(j)); as = *(edge_alpha_map.find(vhp)->second); } else{ //no edge map in REGULARIZED mode - classify on the fly compute_edge_status( c, i, j, as); } return classify(as, alpha); } template < class Dt > void Alpha_shape_3
    :: compute_edge_status( const Cell_handle& c, int i, int j, Alpha_status& as) const { Facet_circulator fcirc, done; Alpha_status_iterator asf; NT alpha; fcirc = incident_facets(c,i,j); while (is_infinite(*fcirc) ) ++fcirc; //skip infinite incident faces done = fcirc; as.set_is_on_chull(false); asf = (*fcirc).first->get_facet_status((*fcirc).second); as.set_alpha_mid(asf->alpha_mid()); // initialise as.alpha_mid as.set_alpha_max(asf->alpha_mid()); // and as.alpha->max to the same do { if (!is_infinite(*fcirc)) { asf = (*fcirc).first->get_facet_status((*fcirc).second); if (get_mode() == GENERAL && asf->is_Gabriel()) alpha = asf->alpha_min(); else alpha = asf->alpha_mid(); if (alpha < as.alpha_mid()) as.set_alpha_mid(alpha) ; if ( ! asf->is_on_chull()) { if( as.alpha_max() < asf->alpha_max()) as.set_alpha_max( asf->alpha_max()); } else{ as.set_is_on_chull(true); } } } while (++fcirc != done); // initialize alphamin if ( get_mode() == GENERAL){ if (is_Gabriel(c,i,j)) { alpha = squared_radius(c,i,j); as.set_is_Gabriel(true); as.set_alpha_min(alpha); } else as.set_is_Gabriel(false); } } //--------------------------------------------------------------------- template < class Dt > typename Alpha_shape_3
    ::Classification_type Alpha_shape_3
    ::classify(const Vertex_handle& v, const NT& alpha) const // Classifies the vertex `v' of the underlying Delaunay // tetrahedralization with respect to `A'. { if (is_infinite(v)) return EXTERIOR; Alpha_status* as = v->get_alpha_status(); return classify(*as, alpha); } //--------------------- NB COMPONENTS --------------------------------- template < class Dt > int Alpha_shape_3
    ::number_of_solid_components(const NT& alpha) const // Determine the number of connected solid components // takes time O(#alpha_shape) amortized if STL_HASH_TABLES // O(#alpha_shape log n) otherwise { typedef typename Marked_cell_set::Data Data; Marked_cell_set marked_cell_set(false); Finite_cells_iterator cell_it, done = finite_cells_end(); int nb_solid_components = 0; // only finite simplices for( cell_it = finite_cells_begin(); cell_it != done; ++cell_it) { Cell_handle pCell = cell_it; assert(pCell != NULL); if (classify(pCell, alpha) == INTERIOR){ Data& data = marked_cell_set[pCell]; if(data == false) { // we traverse only interior simplices data = true; traverse(pCell, marked_cell_set, alpha); nb_solid_components++; } } } return nb_solid_components; } template < class Dt > void Alpha_shape_3
    ::traverse(Cell_handle pCell, Marked_cell_set& marked_cell_set, const NT alpha) const { typedef typename Marked_cell_set::Data Data; std::list cells; cells.push_back(pCell); Cell_handle pNeighbor; while(! cells.empty()){ pCell = cells.back(); cells.pop_back(); for (int i=0; i<=3; i++) { pNeighbor = pCell->neighbor(i); assert(pNeighbor != NULL); if (classify(pNeighbor, alpha) == INTERIOR){ Data& data = marked_cell_set[pNeighbor]; if(data == false){ data = true; cells.push_back(pNeighbor); } } } } } //---------------------------------------------------------------------- template typename Alpha_shape_3
    ::Alpha_iterator Alpha_shape_3
    ::find_optimal_alpha(int nb_components) // find the minimum alpha that satisfies the properties // (1) nb_components solid components <= nb_components // (2) all data points on the boundary or in its interior { NT alpha = find_alpha_solid(); // from this alpha on the alpha_solid satisfies property (2) Alpha_iterator first = alpha_lower_bound(alpha); if (number_of_solid_components(alpha) == nb_components) { // if ((first+1) < alpha_end()) // return (first+1); // else return first; } // do binary search on the alpha values // number_of_solid_components() is a monotone function // if we start with find_alpha_solid Alpha_iterator last = alpha_end(); Alpha_iterator middle; std::ptrdiff_t len = last - first - 1; std::ptrdiff_t half; while (len > 0) { half = len / 2; middle = first + half; /* //#ifdef DEBUG */ /* std::cerr << "first : " << *first */ /* << " last : " */ /* << ((first+len != last) ? *(first+len) : *(last-1)) */ /* << " mid : " << *middle */ /* << " nb comps : " << number_of_solid_components(*middle) */ /* << std::endl; */ /* //#endif // DEBUG */ if (number_of_solid_components(*middle) > nb_components) { first = middle + 1; len = len - half -1; } else // number_of_solid_components(*middle) <= nb_components { len = half; } } /* std::cerr << "a la fin " << std::endl */ /* << "first : " << *first */ /* << " nb comps : " << number_of_solid_components(*first) */ /* << std::endl; */ /* if ((first+1) < alpha_end()) */ /* std::cerr << "first+1 " << *(first+1) */ /* << " nb comps : " << number_of_solid_components(*(first+1)) */ /* << std::endl; */ /* std::cerr << std::endl; */ if (number_of_solid_components(*first) <= nb_components ) return first; else return first+1; } //---------------------------------------------------------------------- template typename Alpha_shape_3
    ::NT Alpha_shape_3
    ::find_alpha_solid() const // compute the minumum alpha such that all data points // are either on the boundary or in the interior // not necessarily connected { return _alpha_solid; } // TO DEBUG template void Alpha_shape_3
    ::print_maps() { typename Alpha_cell_map::iterator cit ; typename Alpha_facet_map::iterator fit ; typename Alpha_edge_map::iterator eit ; std::cerr << "size of cell_map " << alpha_cell_map.size() << std::endl; std::cerr << "size of facet_map " << alpha_min_facet_map.size() << std::endl; std::cerr << "size of edge_map " << alpha_min_edge_map.size() << std::endl; std::cerr << std::endl; std::cerr << "alpha_cell_map " << std::endl; for(cit = alpha_cell_map.begin(); cit != alpha_cell_map.end(); ++cit) { std::cerr << cit->first << std::endl; } std::cerr << std::endl; std::cerr << "alpha_min_facet_map " << std::endl; for(fit = alpha_min_facet_map.begin(); fit != alpha_min_facet_map.end(); ++fit) { std::cerr << fit->first << std::endl; } std::cerr << std::endl; std::cerr << "alpha_min_edge_map " << std::endl; for(eit = alpha_min_edge_map.begin(); eit != alpha_min_edge_map.end(); ++eit) { std::cerr << eit->first << std::endl; } std::cerr << std::endl; } template void Alpha_shape_3
    ::print_alphas() const { std::cerr << std::endl; std::cerr << " alpha values of facets" << std::endl; for(Finite_facets_iterator fit = finite_facets_begin(); fit != finite_facets_end(); ++fit) { Alpha_status_iterator as = fit->first->get_facet_status(fit->second); print_alpha_status(*as); } std::cerr << std::endl; std::cerr << " alpha values of edges " << std::endl; if (get_mode() == GENERAL) { for(Finite_edges_iterator eit = finite_edges_begin(); eit != finite_edges_end(); ++eit) { Vertex_handle_pair vhp = make_vertex_handle_pair(eit->first->vertex(eit->second), eit->first->vertex(eit->third)); Alpha_status_iterator as = edge_alpha_map.find(vhp)->second; print_alpha_status(*as); } } std::cerr << std::endl; std::cerr << " alpha values of vertices " << std::endl; for(Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit) { Alpha_status* as = vit->get_alpha_status(); print_alpha_status(*as); } } template void Alpha_shape_3
    ::print_alpha_status(const Alpha_status& as) const { if ( get_mode() == GENERAL && as.is_Gabriel()) std::cerr << as.alpha_min() ; else std::cerr << "--- " ; std::cerr << "\t"; std::cerr << as.alpha_mid() << "\t"; if(as.is_on_chull()) std::cerr << "--- "; else std::cerr << as.alpha_max(); std::cerr << std::endl; } CGAL_END_NAMESPACE #ifdef CGAL_USE_GEOMVIEW #include #endif #endif //CGAL_ALPHA_SHAPE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_eddy.h0000644000175000017500000000353511344301500026576 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_eddy.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_EDDY_H #define CGAL_CH_EDDY_H #include #include CGAL_BEGIN_NAMESPACE // same as |convex_hull_2(first,last,result)|. {\sc traits}: uses // |Traits::Point_2|, |Traits::Less_signed_distance_to_line_2|, // |Traits::Left_turn_2|, |Traits::Equal_2| and |Traits::Less_xy_2|. template OutputIterator ch_eddy(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits); template inline OutputIterator ch_eddy(InputIterator first, InputIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_eddy( first, last, result, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_EDDY_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesher_level.h0000644000175000017500000002724411344301500027614 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesher_level.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESHER_LEVEL_H #define CGAL_MESHER_LEVEL_H #include namespace CGAL { struct Null_mesh_visitor { const Null_mesh_visitor& previous_level() const { return *this; } template void before_conflicts(E, P) const {} template void before_insertion(E, P, Z) const {} template void after_insertion(V) const {} template void after_no_insertion(E, P, Z) const {} }; struct Null_mesher_level { template void refine(Visitor) {} template std::pair test_point_conflict_from_superior(P, Z) { return std::make_pair(true, true); } bool is_algorithm_done() const { return true; } template bool try_to_insert_one_point(Visitor) { return true; } template bool one_step(Visitor) { return true; } }; // end Null_mesher_level template < class Triangulation_traits, /**< Traits class that defines operations from the trianguilation. */ class Derived, /**< Derived class, that implements methods */ class Element, /**< Type of elements that this level refines. */ class Previous = Null_mesher_level /**< Previous level type, defaults to \c Null_level */ > class Mesher_level { public: /** Type of triangulation that is meshed. */ typedef typename Triangulation_traits::Triangulation Triangulation; /** Type of point that are inserted into the triangulation. */ typedef typename Triangulation_traits::Point Point; /** Type of vertex handles that are returns by insertions into the triangulation. */ typedef typename Triangulation_traits::Vertex_handle Vertex_handle; /** Type of the conflict zone for a point that can be inserted. */ typedef typename Triangulation_traits::Zone Zone; typedef Element Element_type; typedef Previous Previous_level; private: /** \name Private member functions */ /** Curiously recurring template pattern. */ //@{ Derived& derived() { return static_cast(*this); } const Derived& derived() const { return static_cast(*this); } //@} /** \name Private member datas */ Previous& previous_level; /**< The previous level of the refinement process. */ public: typedef Mesher_level Self; /** \name CONSTRUCTORS */ Mesher_level(Previous_level& previous) : previous_level(previous) { } /** \name FUNCTIONS IMPLEMENTED IN THE CLASS \c Derived */ /** Access to the triangulation */ //@{ Triangulation& triangulation() { return derived().get_triangulation_ref(); } const Triangulation& triangulation() const { return derived().get_triangulation_ref(); } //@} /** Access to the triangulation traits */ //@{ Triangulation_traits& triangulation_traits() { return derived().get_triangulation_traits(); } const Triangulation_traits& triangulation_traits() const { return derived().get_triangulation_traits(); } //@} /** Called before the first refinement, to initialized the queue of elements that should be refined. */ void scan_triangulation() { derived().do_scan_triangulation(); } /** Tells if, as regards the elements of type \c Element, the refinement is done. */ bool no_longer_element_to_refine() { return derived().is_no_longer_element_to_refine(); } /** Retrieves the next element that could be refined. */ Element get_next_element() { return derived().do_get_next_element(); } /** Remove from the list the next element that could be refined. */ void pop_next_element() { derived().do_pop_next_element(); } /** Gives the point that should be inserted to refine the element \c e */ Point refinement_point(const Element& e) { return derived().get_refinement_point(e); } /** Actions before testing conflicts for point \c p and element \c e */ template void before_conflicts(const Element& e, const Point& p, Mesh_visitor& visitor) { visitor.before_conflicts(e, p); derived().do_before_conflicts(e, p); } /** Tells if, as regards this level of the refinement process, if the point conflicts with something, and do what is needed. The return type is made of two booleans: - the first one tells if the point can be inserted, - in case of, the first one is \c false, the second one tells if the tested element should be reconsidered latter. */ std::pair private_test_point_conflict(const Point& p, Zone& zone) { return derived().do_private_test_point_conflict(p, zone); } /** Tells if, as regards this level of the refinement process, if the point conflicts with something, and do what is needed. The return type is made of two booleans: - the first one tells if the point can be inserted, - in case of, the first one is \c false, the second one tells if the tested element should be reconsidered latter. This function is called by the superior level, if any. */ std::pair test_point_conflict_from_superior(const Point& p, Zone& zone) { return derived().do_test_point_conflict_from_superior(p, zone); } /** * Actions before inserting the point \c p in order to refine the * element \c e. The zone of conflicts is \c zone. */ template void before_insertion(Element& e, const Point& p, Zone& zone, Mesh_visitor& visitor) { visitor.before_insertion(e, p, zone); derived().do_before_insertion(e, p, zone); } /** Actions after having inserted the point. * \param vh is the vertex handle of the inserted point, * \param visitor is the visitor. */ template void after_insertion(Vertex_handle vh, Mesh_visitor& visitor) { derived().do_after_insertion(vh); visitor.after_insertion(vh); } /** Actions after testing conflicts for point \c p and element \c e * if no point is inserted. */ template void after_no_insertion(const Element& e, const Point& p, Zone& zone, Mesh_visitor& visitor) { derived().do_after_no_insertion(e, p, zone); visitor.after_no_insertion(e, p, zone); } /** DEFAULT IMPLEMENTATION FUNCTIONS * * This bunch of functions should be implemented in the derived class: * * Tr& get_triangulation_ref(); * const Tr& get_triangulation_ref(); * * void do_scan_triangulation(); * * bool is_no_longer_element_to_refine(); * * Element do_get_next_element(); * * void pop_next_element(); * * Point get_refinement_point(Element); * * * The next ones have default implementations that do nothing: * */ // void do_before_conflicts(const Element&, const Point&) // { // } // void do_after_no_insertion(Element, Point, Zone) // { // } // std::pair // do_private_test_point_conflict(Point, Zone) // { // return std::make_pair(true, true); // } // std::pair // do_test_point_conflict_from_superior(Point, Zone) // { // return std::make_pair(true, true); // } // void do_before_insertion(Element, Point, Zone) // { // } // void do_after_insertion(Vertex_handle) // { // } /** \name MESHING PROCESS * * The following functions use the functions that are implemented in the * derived classes. * */ /** * Tells it the algorithm is done, regarding elements of type \c Element * or elements of previous levels. */ bool is_algorithm_done() { return ( previous_level.is_algorithm_done() && no_longer_element_to_refine() ); } /** Refines elements of this level and previous levels. */ template void refine(Mesh_visitor& visitor) { while(! is_algorithm_done() ) { previous_level.refine(visitor.previous_level()); if(! no_longer_element_to_refine() ) process_one_element(visitor); } } /** * This function takes one element from the queue, and try to refine * it. It returns \c true if one point has been inserted. * @todo Merge with try_to_refine_element(). */ template bool process_one_element(Mesh_visitor& visitor) { Element e = get_next_element(); const std::pair result = try_to_refine_element(e, visitor); if(result.second) pop_next_element(); return result.first; } template std::pair try_to_refine_element(Element e, Mesh_visitor& visitor) { const Point& p = refinement_point(e); before_conflicts(e, p, visitor); Zone zone = triangulation_traits().get_conflicts_zone(triangulation(), p); const std::pair result = test_point_conflict(p, zone); if(result.first) { before_insertion(e, p, zone, visitor); Vertex_handle v = triangulation_traits().insert(triangulation(), p, zone); after_insertion(v, visitor); return std::make_pair(true, true); } else after_no_insertion(e, p, zone, visitor); return result; } /** Return (can_split_the_element, drop_element). */ std::pair test_point_conflict(const Point& p, Zone& zone) { const std::pair result = previous_level.test_point_conflict_from_superior(p, zone); if( result.first == false ) return result; return private_test_point_conflict(p, zone); } /** \name STEP BY STEP FUNCTIONS */ /** * Inserts exactly one point, if possible, and returns \c false if no * point has been inserted because the algorithm is done. */ template bool try_to_insert_one_point(Mesh_visitor& visitor) { while(! is_algorithm_done() ) { if( previous_level.try_to_insert_one_point(visitor.previous_level()) ) return true; if(! no_longer_element_to_refine() ) if( process_one_element(visitor) ) return true; } return false; } /** * Applies one step of the algorithm: tries to refine one element of * previous level or one element of this level. Return \c false iff * is_algorithm_done()==true . */ template bool one_step(Mesh_visitor& visitor) { if( ! previous_level.is_algorithm_done() ) previous_level.one_step(visitor.previous_level()); else if( ! no_longer_element_to_refine() ) process_one_element(visitor); return ! is_algorithm_done(); } }; // end Mesher_level } // end namespace CGAL #endif // CGAL_MESHER_LEVEL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/functions_on_signs.h0000644000175000017500000000731311344301500031104 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/functions_on_signs.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_FUNCTIONS_ON_SIGNS_H #define CGAL_FUNCTIONS_ON_SIGNS_H #include CGAL_BEGIN_NAMESPACE #if 0 inline Sign operator*(const Sign &s1, const Sign &s2) { if ( s1 == ZERO || s2 == ZERO ) return ZERO; if ( s1 == s2 ) return POSITIVE; return NEGATIVE; } #endif template < class RT > Sign sign_a_plus_b_x_sqrt_c(const RT &a, const RT &b, const RT &c) { // computes the sign of quantity: a + b * sqrt(c) CGAL_assertion( !(CGAL::is_negative(c)) ); Sign sa = CGAL::sign(a); if ( CGAL::sign(c) == ZERO ) return sa; Sign sb = CGAL::sign(b); if ( sa == sb ) return sa; if ( sa == ZERO ) return sb; return Sign( sa * CGAL::compare( CGAL::square(a), c * CGAL::square(b) ) ); } template < class RT > Sign sign_a_x_sqrt_c_plus_b_x_sqrt_d(const RT &a, const RT &b, const RT &c, const RT &d) { // computes the sign of quantity: a * sqrt(c) + b * sqrt(d) CGAL_assertion( !(CGAL::is_negative(c)) ); CGAL_assertion( !(CGAL::is_negative(d)) ); Sign sb = CGAL::sign(b); if ( CGAL::sign(d) == ZERO ) return CGAL::sign(a * c); if ( CGAL::sign(c) == ZERO ) return sb; Sign sa = CGAL::sign(a); if ( sa == sb ) return sa; if ( sa == ZERO ) return sb; return Sign( sa * CGAL::compare( CGAL::square(a) * c, CGAL::square(b) * d ) ); } template < class RT > Sign sign_a_plus_b_x_sqrt_e_plus_c_x_sqrt_f(const RT &a, const RT &b, const RT &c, const RT &e, const RT &f) { // computes the sign of quantity: a + b * sqrt(e) + c * sqrt(f) CGAL_assertion( !(CGAL::is_negative(e)) ); CGAL_assertion( !(CGAL::is_negative(f)) ); Sign s_a_plus_b_x_sqrt_e = sign_a_plus_b_x_sqrt_c(a, b, e); if ( CGAL::sign(f) == ZERO ) return s_a_plus_b_x_sqrt_e; Sign sc = CGAL::sign(c); if ( s_a_plus_b_x_sqrt_e == sc ) return sc; if ( s_a_plus_b_x_sqrt_e == ZERO ) return sc; return s_a_plus_b_x_sqrt_e * sign_a_plus_b_x_sqrt_c(CGAL::square(a) + CGAL::square(b) * e - CGAL::square(c) * f, RT(2) * a * b, e); } template < class RT > Sign sign_a_plus_b_x_sqrt_e_plus_c_x_sqrt_f_plus_d_sqrt_e_x_f(const RT &a, const RT &b, const RT &c, const RT &d, const RT &e, const RT &f) { // computes the sign of quantity: // a + b * sqrt(e) + c * sqrt(f) + d * sqrt(e * f) CGAL_assertion( !(CGAL::is_negative(e)) ); CGAL_assertion( !(CGAL::is_negative(f)) ); Sign s_a_plus_b_sqrt_e = sign_a_plus_b_x_sqrt_c(a, b, e); Sign s_c_plus_d_sqrt_e = sign_a_plus_b_x_sqrt_c(c, d, e); if ( s_a_plus_b_sqrt_e == s_c_plus_d_sqrt_e ) return s_a_plus_b_sqrt_e; if ( s_a_plus_b_sqrt_e == ZERO ) return s_a_plus_b_sqrt_e; return s_a_plus_b_sqrt_e * sign_a_plus_b_x_sqrt_c(CGAL::square(a) + CGAL::square(b) * e - CGAL::square(c) * f - CGAL::square(d) * e * f, RT(2) * (a * b - c * d * f), e); } CGAL_END_NAMESPACE #include #endif // CGAL_FUNCTIONS_ON_SIGNS_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_hierarchy_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_hiera0000644000175000017500000001450311344301500031424 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_hierarchy_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_HIERARCHY_2_H #define CGAL_APOLLONIUS_GRAPH_HIERARCHY_2_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // parameterization of the hierarchy const unsigned int ag_hierarchy_2__ratio = 30; const unsigned int ag_hierarchy_2__minsize = 20; const unsigned int ag_hierarchy_2__maxlevel = 5; // maximal number of points is 30^5 = 24 millions ! template < class Gt, class Agds = Triangulation_data_structure_2< Apollonius_graph_hierarchy_vertex_base_2< Apollonius_graph_vertex_base_2 >, Triangulation_face_base_2 >, class LTag = Tag_false > class Apollonius_graph_hierarchy_2 : public Apollonius_graph_2< Gt, Agds, LTag > { private: typedef Apollonius_graph_2 Apollonius_graph_base; typedef Apollonius_graph_base Ag_base; typedef typename Ag_base::Vertex Vertex; public: typedef Agds Data_structure; typedef Gt Geom_traits; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typedef typename Ag_base::Vertex_handle Vertex_handle; typedef typename Ag_base::Face_handle Face_handle; typedef typename Ag_base::Edge Edge; typedef typename Ag_base::Face_circulator Face_circulator; typedef typename Ag_base::Edge_circulator Edge_circulator; typedef typename Ag_base::Vertex_circulator Vertex_circulator; typedef typename Ag_base::All_faces_iterator All_faces_iterator; typedef typename Ag_base::Finite_faces_iterator Finite_faces_iterator; typedef typename Ag_base::All_vertices_iterator All_vertices_iterator; typedef typename Ag_base::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Ag_base::All_edges_iterator All_edges_iterator; typedef typename Ag_base::Finite_edges_iterator Finite_edges_iterator; typedef typename Ag_base::Sites_iterator Sites_iterator; typedef typename Ag_base::Visible_sites_iterator Visible_sites_iterator; typedef typename Ag_base::Hidden_sites_iterator Hidden_sites_iterator; typedef typename Ag_base::size_type size_type; public: // CREATION //--------- Apollonius_graph_hierarchy_2 (const Geom_traits& gt = Geom_traits()); template Apollonius_graph_hierarchy_2(Input_iterator first, Input_iterator beyond, const Geom_traits& gt = Geom_traits()) : Apollonius_graph_base(gt) { init_hierarchy(gt); insert(first, beyond); } Apollonius_graph_hierarchy_2 (const Apollonius_graph_hierarchy_2& agh); Apollonius_graph_hierarchy_2& operator=(const Apollonius_graph_hierarchy_2& agh); ~Apollonius_graph_hierarchy_2(); protected: // used to initialize the hierarchy at construction time void init_hierarchy(const Geom_traits& gt); public: // INSERTION //---------- template < class Input_iterator > unsigned int insert(Input_iterator first, Input_iterator beyond) { // copy the sites to a local container typename Apollonius_graph_base::Site_list wp_list; // Site_list wp_list; for (Input_iterator it = first; it != beyond; ++it) { wp_list.push_back(*it); } // sort by decreasing weight typename Apollonius_graph_base::Site_less_than_comparator less_than(this->geom_traits()); std::sort(wp_list.begin(), wp_list.end(), less_than); // now insert typename Apollonius_graph_base::Site_list_iterator lit; for (lit = wp_list.begin(); lit != wp_list.end(); ++lit) { insert(*lit); } // store how many sites where in the range unsigned int num = wp_list.size(); // clear the local container wp_list.clear(); // return the number of sites in range return num; } Vertex_handle insert(const Site_2& p); Vertex_handle insert(const Site_2& p, Vertex_handle vnear) { // the following statement has been added in order to avoid // a g++3.2.1_FreeBSD-RELEASE warning vnear = Vertex_handle(); return insert(p); } public: // REMOVAL //-------- void remove(Vertex_handle v); public: // NEAREST NEIGHBOR LOCATION //-------------------------- public: Vertex_handle nearest_neighbor(const Point_2& p) const; inline Vertex_handle nearest_neighbor(const Point_2& p, Vertex_handle vnear) const { return nearest_neighbor(p); } public: // VALIDITY CHECK //--------------- bool is_valid(bool verbose = false, int level = 1) const; public: // MISCELLANEOUS //-------------- void clear(); void swap(Apollonius_graph_hierarchy_2& agh); private: // private methods void nearest_neighbor(const Point_2& p, Vertex_handle vnear[ag_hierarchy_2__maxlevel]) const; int random_level(); void copy(const Apollonius_graph_hierarchy_2 &agh); private: // class variables // here is the stack of graphs which form the hierarchy Apollonius_graph_base* hierarchy[ag_hierarchy_2__maxlevel]; Random random; // random generator }; CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif #endif // CGAL_APOLLONIUS_GRAPH_HIERARCHY_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Is_a_predicate.h0000644000175000017500000000462111344301500030067 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Is_a_predicate.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_IS_A_PREDICATE_H #define CGAL_IS_A_PREDICATE_H // How to determine if a kernel functor is a predicate or a construction. #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { // By default it's a construction template struct Return_type_of_predicate { typedef CGAL::Tag_false type; }; // Specializations for predicates template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; template <> struct Return_type_of_predicate { typedef CGAL::Tag_true type; }; } // namespace CGALi template struct Is_a_predicate { typedef typename CGALi::Return_type_of_predicate< typename Functor::result_type>::type type; }; CGAL_END_NAMESPACE #endif // CGAL_IS_A_PREDICATE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/0000755000175000017500000000000012146213677030500 5ustar debiandebian././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000755000175000017500000000000012146213677031353 5ustar debiandebian././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/builtin.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000000600411344301501031334 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/builtin.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_BUILTIN_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_BUILTIN_H CGAL_BEGIN_NAMESPACE struct Static_Filtered_sign_1 { static double _bound; static double _epsilon_0; static Sign update_epsilon( const Static_filter_error &a, double & epsilon_0) { epsilon_0 = a.error(); return ZERO; } static void new_bound (const double b) // , const double error = 0) { _bound = b; (void) update_epsilon(b,_epsilon_0); } static Sign epsilon_variant( const Restricted_double &a, const double & epsilon_0) { // return compare_SAF(a,0,epsilon); if (to_double(a)> epsilon_0) return POSITIVE; if (to_double(a)<-epsilon_0) return NEGATIVE; if (to_double(a)==0 && epsilon_0==0) return ZERO; Interval_nt_advanced::number_of_failures++; throw Interval_nt_advanced::unsafe_comparison(); } }; struct Static_Filtered_compare_2 { static double _bound; static double _epsilon_0; static Comparison_result update_epsilon( const Static_filter_error &a, const Static_filter_error &b, double & epsilon_0) { Static_filter_error c = a-b; epsilon_0 = c.error(); return EQUAL; } static void new_bound (const double b) // , const double error = 0) { _bound = b; (void) update_epsilon(b,b,_epsilon_0); } static Comparison_result epsilon_variant( const Restricted_double &a, const Restricted_double &b, const double & epsilon_0) { if (to_double(a) > to_double(b)+epsilon_0) return LARGER; if (to_double(a) < to_double(b)-epsilon_0) return SMALLER; if (to_double(a)==to_double(b) && epsilon_0==0) return EQUAL; Interval_nt_advanced::number_of_failures++; throw Interval_nt_advanced::unsafe_comparison(); } }; CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_BUILTIN_H ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/sign_of_determinant.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000005146311344301501031345 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/sign_of_determinant.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* inline */ Sign sign_of_determinant2x2( const Filtered_exact &a00, const Filtered_exact &a01, const Filtered_exact &a10, const Filtered_exact &a11) { try { CGAL_PROFILER("IA sign_of_determinant2x2 calls"); Protect_FPU_rounding Protection; return sign_of_determinant2x2( a00.interval(), a01.interval(), a10.interval(), a11.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA sign_of_determinant2x2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant2x2( a00.exact(), a01.exact(), a10.exact(), a11.exact()); } } template < class ET > /* inline */ Sign sign_of_determinant2x2( const Lazy_exact_nt &a00, const Lazy_exact_nt &a01, const Lazy_exact_nt &a10, const Lazy_exact_nt &a11) { try { CGAL_PROFILER("Lazy IA sign_of_determinant2x2 calls"); Protect_FPU_rounding Protection; return sign_of_determinant2x2( a00.interval(), a01.interval(), a10.interval(), a11.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA sign_of_determinant2x2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant2x2( a00.exact(), a01.exact(), a10.exact(), a11.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Sign sign_of_determinant3x3( const Filtered_exact &a00, const Filtered_exact &a01, const Filtered_exact &a02, const Filtered_exact &a10, const Filtered_exact &a11, const Filtered_exact &a12, const Filtered_exact &a20, const Filtered_exact &a21, const Filtered_exact &a22) { try { CGAL_PROFILER("IA sign_of_determinant3x3 calls"); Protect_FPU_rounding Protection; return sign_of_determinant3x3( a00.interval(), a01.interval(), a02.interval(), a10.interval(), a11.interval(), a12.interval(), a20.interval(), a21.interval(), a22.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA sign_of_determinant3x3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant3x3( a00.exact(), a01.exact(), a02.exact(), a10.exact(), a11.exact(), a12.exact(), a20.exact(), a21.exact(), a22.exact()); } } template < class ET > /* inline */ Sign sign_of_determinant3x3( const Lazy_exact_nt &a00, const Lazy_exact_nt &a01, const Lazy_exact_nt &a02, const Lazy_exact_nt &a10, const Lazy_exact_nt &a11, const Lazy_exact_nt &a12, const Lazy_exact_nt &a20, const Lazy_exact_nt &a21, const Lazy_exact_nt &a22) { try { CGAL_PROFILER("Lazy IA sign_of_determinant3x3 calls"); Protect_FPU_rounding Protection; return sign_of_determinant3x3( a00.interval(), a01.interval(), a02.interval(), a10.interval(), a11.interval(), a12.interval(), a20.interval(), a21.interval(), a22.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA sign_of_determinant3x3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant3x3( a00.exact(), a01.exact(), a02.exact(), a10.exact(), a11.exact(), a12.exact(), a20.exact(), a21.exact(), a22.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Sign sign_of_determinant4x4( const Filtered_exact &a00, const Filtered_exact &a01, const Filtered_exact &a02, const Filtered_exact &a03, const Filtered_exact &a10, const Filtered_exact &a11, const Filtered_exact &a12, const Filtered_exact &a13, const Filtered_exact &a20, const Filtered_exact &a21, const Filtered_exact &a22, const Filtered_exact &a23, const Filtered_exact &a30, const Filtered_exact &a31, const Filtered_exact &a32, const Filtered_exact &a33) { try { CGAL_PROFILER("IA sign_of_determinant4x4 calls"); Protect_FPU_rounding Protection; return sign_of_determinant4x4( a00.interval(), a01.interval(), a02.interval(), a03.interval(), a10.interval(), a11.interval(), a12.interval(), a13.interval(), a20.interval(), a21.interval(), a22.interval(), a23.interval(), a30.interval(), a31.interval(), a32.interval(), a33.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA sign_of_determinant4x4 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant4x4( a00.exact(), a01.exact(), a02.exact(), a03.exact(), a10.exact(), a11.exact(), a12.exact(), a13.exact(), a20.exact(), a21.exact(), a22.exact(), a23.exact(), a30.exact(), a31.exact(), a32.exact(), a33.exact()); } } template < class ET > /* inline */ Sign sign_of_determinant4x4( const Lazy_exact_nt &a00, const Lazy_exact_nt &a01, const Lazy_exact_nt &a02, const Lazy_exact_nt &a03, const Lazy_exact_nt &a10, const Lazy_exact_nt &a11, const Lazy_exact_nt &a12, const Lazy_exact_nt &a13, const Lazy_exact_nt &a20, const Lazy_exact_nt &a21, const Lazy_exact_nt &a22, const Lazy_exact_nt &a23, const Lazy_exact_nt &a30, const Lazy_exact_nt &a31, const Lazy_exact_nt &a32, const Lazy_exact_nt &a33) { try { CGAL_PROFILER("Lazy IA sign_of_determinant4x4 calls"); Protect_FPU_rounding Protection; return sign_of_determinant4x4( a00.interval(), a01.interval(), a02.interval(), a03.interval(), a10.interval(), a11.interval(), a12.interval(), a13.interval(), a20.interval(), a21.interval(), a22.interval(), a23.interval(), a30.interval(), a31.interval(), a32.interval(), a33.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA sign_of_determinant4x4 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant4x4( a00.exact(), a01.exact(), a02.exact(), a03.exact(), a10.exact(), a11.exact(), a12.exact(), a13.exact(), a20.exact(), a21.exact(), a22.exact(), a23.exact(), a30.exact(), a31.exact(), a32.exact(), a33.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Sign sign_of_determinant5x5( const Filtered_exact &a00, const Filtered_exact &a01, const Filtered_exact &a02, const Filtered_exact &a03, const Filtered_exact &a04, const Filtered_exact &a10, const Filtered_exact &a11, const Filtered_exact &a12, const Filtered_exact &a13, const Filtered_exact &a14, const Filtered_exact &a20, const Filtered_exact &a21, const Filtered_exact &a22, const Filtered_exact &a23, const Filtered_exact &a24, const Filtered_exact &a30, const Filtered_exact &a31, const Filtered_exact &a32, const Filtered_exact &a33, const Filtered_exact &a34, const Filtered_exact &a40, const Filtered_exact &a41, const Filtered_exact &a42, const Filtered_exact &a43, const Filtered_exact &a44) { try { CGAL_PROFILER("IA sign_of_determinant5x5 calls"); Protect_FPU_rounding Protection; return sign_of_determinant5x5( a00.interval(), a01.interval(), a02.interval(), a03.interval(), a04.interval(), a10.interval(), a11.interval(), a12.interval(), a13.interval(), a14.interval(), a20.interval(), a21.interval(), a22.interval(), a23.interval(), a24.interval(), a30.interval(), a31.interval(), a32.interval(), a33.interval(), a34.interval(), a40.interval(), a41.interval(), a42.interval(), a43.interval(), a44.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA sign_of_determinant5x5 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant5x5( a00.exact(), a01.exact(), a02.exact(), a03.exact(), a04.exact(), a10.exact(), a11.exact(), a12.exact(), a13.exact(), a14.exact(), a20.exact(), a21.exact(), a22.exact(), a23.exact(), a24.exact(), a30.exact(), a31.exact(), a32.exact(), a33.exact(), a34.exact(), a40.exact(), a41.exact(), a42.exact(), a43.exact(), a44.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Sign sign_of_determinant5x5( const Lazy_exact_nt &a00, const Lazy_exact_nt &a01, const Lazy_exact_nt &a02, const Lazy_exact_nt &a03, const Lazy_exact_nt &a04, const Lazy_exact_nt &a10, const Lazy_exact_nt &a11, const Lazy_exact_nt &a12, const Lazy_exact_nt &a13, const Lazy_exact_nt &a14, const Lazy_exact_nt &a20, const Lazy_exact_nt &a21, const Lazy_exact_nt &a22, const Lazy_exact_nt &a23, const Lazy_exact_nt &a24, const Lazy_exact_nt &a30, const Lazy_exact_nt &a31, const Lazy_exact_nt &a32, const Lazy_exact_nt &a33, const Lazy_exact_nt &a34, const Lazy_exact_nt &a40, const Lazy_exact_nt &a41, const Lazy_exact_nt &a42, const Lazy_exact_nt &a43, const Lazy_exact_nt &a44) { try { CGAL_PROFILER("Lazy IA sign_of_determinant5x5 calls"); Protect_FPU_rounding Protection; return sign_of_determinant5x5( a00.interval(), a01.interval(), a02.interval(), a03.interval(), a04.interval(), a10.interval(), a11.interval(), a12.interval(), a13.interval(), a14.interval(), a20.interval(), a21.interval(), a22.interval(), a23.interval(), a24.interval(), a30.interval(), a31.interval(), a32.interval(), a33.interval(), a34.interval(), a40.interval(), a41.interval(), a42.interval(), a43.interval(), a44.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA sign_of_determinant5x5 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant5x5( a00.exact(), a01.exact(), a02.exact(), a03.exact(), a04.exact(), a10.exact(), a11.exact(), a12.exact(), a13.exact(), a14.exact(), a20.exact(), a21.exact(), a22.exact(), a23.exact(), a24.exact(), a30.exact(), a31.exact(), a32.exact(), a33.exact(), a34.exact(), a40.exact(), a41.exact(), a42.exact(), a43.exact(), a44.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Sign sign_of_determinant6x6( const Filtered_exact &a00, const Filtered_exact &a01, const Filtered_exact &a02, const Filtered_exact &a03, const Filtered_exact &a04, const Filtered_exact &a05, const Filtered_exact &a10, const Filtered_exact &a11, const Filtered_exact &a12, const Filtered_exact &a13, const Filtered_exact &a14, const Filtered_exact &a15, const Filtered_exact &a20, const Filtered_exact &a21, const Filtered_exact &a22, const Filtered_exact &a23, const Filtered_exact &a24, const Filtered_exact &a25, const Filtered_exact &a30, const Filtered_exact &a31, const Filtered_exact &a32, const Filtered_exact &a33, const Filtered_exact &a34, const Filtered_exact &a35, const Filtered_exact &a40, const Filtered_exact &a41, const Filtered_exact &a42, const Filtered_exact &a43, const Filtered_exact &a44, const Filtered_exact &a45, const Filtered_exact &a50, const Filtered_exact &a51, const Filtered_exact &a52, const Filtered_exact &a53, const Filtered_exact &a54, const Filtered_exact &a55) { try { CGAL_PROFILER("IA sign_of_determinant6x6 calls"); Protect_FPU_rounding Protection; return sign_of_determinant6x6( a00.interval(), a01.interval(), a02.interval(), a03.interval(), a04.interval(), a05.interval(), a10.interval(), a11.interval(), a12.interval(), a13.interval(), a14.interval(), a15.interval(), a20.interval(), a21.interval(), a22.interval(), a23.interval(), a24.interval(), a25.interval(), a30.interval(), a31.interval(), a32.interval(), a33.interval(), a34.interval(), a35.interval(), a40.interval(), a41.interval(), a42.interval(), a43.interval(), a44.interval(), a45.interval(), a50.interval(), a51.interval(), a52.interval(), a53.interval(), a54.interval(), a55.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA sign_of_determinant6x6 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant6x6( a00.exact(), a01.exact(), a02.exact(), a03.exact(), a04.exact(), a05.exact(), a10.exact(), a11.exact(), a12.exact(), a13.exact(), a14.exact(), a15.exact(), a20.exact(), a21.exact(), a22.exact(), a23.exact(), a24.exact(), a25.exact(), a30.exact(), a31.exact(), a32.exact(), a33.exact(), a34.exact(), a35.exact(), a40.exact(), a41.exact(), a42.exact(), a43.exact(), a44.exact(), a45.exact(), a50.exact(), a51.exact(), a52.exact(), a53.exact(), a54.exact(), a55.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Sign sign_of_determinant6x6( const Lazy_exact_nt &a00, const Lazy_exact_nt &a01, const Lazy_exact_nt &a02, const Lazy_exact_nt &a03, const Lazy_exact_nt &a04, const Lazy_exact_nt &a05, const Lazy_exact_nt &a10, const Lazy_exact_nt &a11, const Lazy_exact_nt &a12, const Lazy_exact_nt &a13, const Lazy_exact_nt &a14, const Lazy_exact_nt &a15, const Lazy_exact_nt &a20, const Lazy_exact_nt &a21, const Lazy_exact_nt &a22, const Lazy_exact_nt &a23, const Lazy_exact_nt &a24, const Lazy_exact_nt &a25, const Lazy_exact_nt &a30, const Lazy_exact_nt &a31, const Lazy_exact_nt &a32, const Lazy_exact_nt &a33, const Lazy_exact_nt &a34, const Lazy_exact_nt &a35, const Lazy_exact_nt &a40, const Lazy_exact_nt &a41, const Lazy_exact_nt &a42, const Lazy_exact_nt &a43, const Lazy_exact_nt &a44, const Lazy_exact_nt &a45, const Lazy_exact_nt &a50, const Lazy_exact_nt &a51, const Lazy_exact_nt &a52, const Lazy_exact_nt &a53, const Lazy_exact_nt &a54, const Lazy_exact_nt &a55) { try { CGAL_PROFILER("Lazy IA sign_of_determinant6x6 calls"); Protect_FPU_rounding Protection; return sign_of_determinant6x6( a00.interval(), a01.interval(), a02.interval(), a03.interval(), a04.interval(), a05.interval(), a10.interval(), a11.interval(), a12.interval(), a13.interval(), a14.interval(), a15.interval(), a20.interval(), a21.interval(), a22.interval(), a23.interval(), a24.interval(), a25.interval(), a30.interval(), a31.interval(), a32.interval(), a33.interval(), a34.interval(), a35.interval(), a40.interval(), a41.interval(), a42.interval(), a43.interval(), a44.interval(), a45.interval(), a50.interval(), a51.interval(), a52.interval(), a53.interval(), a54.interval(), a55.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA sign_of_determinant6x6 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sign_of_determinant6x6( a00.exact(), a01.exact(), a02.exact(), a03.exact(), a04.exact(), a05.exact(), a10.exact(), a11.exact(), a12.exact(), a13.exact(), a14.exact(), a15.exact(), a20.exact(), a21.exact(), a22.exact(), a23.exact(), a24.exact(), a25.exact(), a30.exact(), a31.exact(), a32.exact(), a33.exact(), a34.exact(), a35.exact(), a40.exact(), a41.exact(), a42.exact(), a43.exact(), a44.exact(), a45.exact(), a50.exact(), a51.exact(), a52.exact(), a53.exact(), a54.exact(), a55.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/compare_quadratic.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000004440111344301501031337 0ustar debiandebian// Copyright (c) 1999,2000,2001,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/compare_quadratic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // Menelaos Karavelas // This file is automatically generated by // scripts/filtered_predicates_generator.pl // MK: January 19, 2004 // This file was originally automatically generated by // scripts/filtered_predicates_generator.pl // Modifications have been made on top of it. #ifndef CGAL_ARITHMETIC_FILTER_COMPARE_QUADRATIC_H #define CGAL_ARITHMETIC_FILTER_COMPARE_QUADRATIC_H #include CGAL_BEGIN_NAMESPACE template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result sqrt_compare_l1_l2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA sqrt_compare_l1_l2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return sqrt_compare_l1_l2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA sqrt_compare_l1_l2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sqrt_compare_l1_l2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result sqrt_compare_l1_r2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA sqrt_compare_l1_r2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return sqrt_compare_l1_r2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA sqrt_compare_l1_r2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sqrt_compare_l1_r2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result sqrt_compare_r1_l2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA sqrt_compare_r1_l2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return sqrt_compare_r1_l2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA sqrt_compare_r1_l2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sqrt_compare_r1_l2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result sqrt_compare_r1_r2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA sqrt_compare_r1_r2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return sqrt_compare_r1_r2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA sqrt_compare_r1_r2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return sqrt_compare_r1_r2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result dfmt_compare_l1_l2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA dfmt_compare_l1_l2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return dfmt_compare_l1_l2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA dfmt_compare_l1_l2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return dfmt_compare_l1_l2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result dfmt_compare_l1_r2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA dfmt_compare_l1_r2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return dfmt_compare_l1_r2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA dfmt_compare_l1_r2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return dfmt_compare_l1_r2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result dfmt_compare_r1_l2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA dfmt_compare_r1_l2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return dfmt_compare_r1_l2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA dfmt_compare_r1_l2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return dfmt_compare_r1_l2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result dfmt_compare_r1_r2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA dfmt_compare_r1_r2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return dfmt_compare_r1_r2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA dfmt_compare_r1_r2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return dfmt_compare_r1_r2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result ke_compare_l1_l2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ke_compare_l1_l2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ke_compare_l1_l2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ke_compare_l1_l2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ke_compare_l1_l2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result ke_compare_l1_r2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ke_compare_l1_r2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ke_compare_l1_r2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ke_compare_l1_r2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ke_compare_l1_r2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result ke_compare_r1_l2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ke_compare_r1_l2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ke_compare_r1_l2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ke_compare_r1_l2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ke_compare_r1_l2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Comparison_result ke_compare_r1_r2( const Filtered_exact &a1, const Filtered_exact &b1, const Filtered_exact &c1, const Filtered_exact &a2, const Filtered_exact &b2, const Filtered_exact &c2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ke_compare_r1_r2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ke_compare_r1_r2( a1.interval(), b1.interval(), c1.interval(), a2.interval(), b2.interval(), c2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ke_compare_r1_r2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ke_compare_r1_r2( a1.exact(), b1.exact(), c1.exact(), a2.exact(), b2.exact(), c2.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_COMPARE_QUADRATIC_H ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Apollonius_graph_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000012103511344301501031336 0ustar debiandebian// Copyright (c) 1999,2000,2001,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Apollonius_graph_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // Menelaos Karavelas // This file is automatically generated by // scripts/filtered_predicates_generator.pl // MK: January 19, 2004 // This file was originally automatically generated by // scripts/filtered_predicates_generator.pl // Modifications have been made on top of it. #ifndef CGAL_ARITHMETIC_FILTER_APOLLONIUS_GRAPH_FTC2_H #define CGAL_ARITHMETIC_FILTER_APOLLONIUS_GRAPH_FTC2_H #include CGAL_BEGIN_NAMESPACE template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ Orientation ag2_orientation_test_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ag2_orientation_test_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ag2_orientation_test_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ag2_orientation_test_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ag2_orientation_test_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ bool ad_is_hidden_test_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_is_hidden_test_alg_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_is_hidden_test_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_is_hidden_test_alg_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_is_hidden_test_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* inline */ bool ad_is_hidden_test_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_is_hidden_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_is_hidden_test_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_is_hidden_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_is_hidden_test_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* CGAL_MEDIUM_INLINE */ Comparison_result compare_ad_distances_test_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x, const Filtered_exact &y) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA compare_ad_distances_test_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return compare_ad_distances_test_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x.interval(), y.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA compare_ad_distances_test_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_ad_distances_test_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x.exact(), y.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* CGAL_MEDIUM_INLINE */ Comparison_result compare_ad_distances_test_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x, const Filtered_exact &y) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA compare_ad_distances_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return compare_ad_distances_test_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x.interval(), y.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA compare_ad_distances_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_ad_distances_test_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x.exact(), y.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ Sign ad_incircle_test_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_incircle_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_incircle_test_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), qx.interval(), qy.interval(), qw.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_incircle_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_incircle_test_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), qx.exact(), qy.exact(), qw.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ Sign ad_incircle_test_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_incircle_test_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_incircle_test_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), qx.interval(), qy.interval(), qw.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_incircle_test_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_incircle_test_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), qx.exact(), qy.exact(), qw.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ Sign ad_incircle_test_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_incircle_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_incircle_test_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), qx.interval(), qy.interval(), qw.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_incircle_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_incircle_test_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), qx.exact(), qy.exact(), qw.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ Sign ad_incircle_test_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_incircle_test_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_incircle_test_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), qx.interval(), qy.interval(), qw.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_incircle_test_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_incircle_test_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), qx.exact(), qy.exact(), qw.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_finite_edge_test_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &x4, const Filtered_exact &y4, const Filtered_exact &w4, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_finite_edge_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_finite_edge_test_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), x4.interval(), y4.interval(), w4.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_finite_edge_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_finite_edge_test_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), x4.exact(), y4.exact(), w4.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_finite_edge_test_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &x4, const Filtered_exact &y4, const Filtered_exact &w4, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_finite_edge_test_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_finite_edge_test_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), x4.interval(), y4.interval(), w4.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_finite_edge_test_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_finite_edge_test_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), x4.exact(), y4.exact(), w4.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_finite_edge_test_degenerated_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_finite_edge_test_degenerated_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_finite_edge_test_degenerated_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_finite_edge_test_degenerated_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_finite_edge_test_degenerated_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_finite_edge_test_degenerated_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_finite_edge_test_degenerated_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_finite_edge_test_degenerated_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_finite_edge_test_degenerated_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_finite_edge_test_degenerated_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_finite_edge_test_degenerated_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_finite_edge_test_degenerated_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_finite_edge_test_degenerated_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_finite_edge_test_degenerated_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_finite_edge_test_degenerated_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_finite_edge_test_degenerated_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_finite_edge_test_degenerated_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_finite_edge_test_degenerated_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_finite_edge_test_degenerated_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_finite_edge_test_degenerated_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_infinite_edge_test_sqrtf_C2( const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &x4, const Filtered_exact &y4, const Filtered_exact &w4, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_infinite_edge_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_infinite_edge_test_sqrtf_C2( x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), x4.interval(), y4.interval(), w4.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_infinite_edge_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_infinite_edge_test_sqrtf_C2( x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), x4.exact(), y4.exact(), w4.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_infinite_edge_test_ring_C2( const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &x4, const Filtered_exact &y4, const Filtered_exact &w4, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, bool b) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_infinite_edge_test_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_infinite_edge_test_ring_C2( x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), x4.interval(), y4.interval(), w4.interval(), qx.interval(), qy.interval(), qw.interval(), b); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_infinite_edge_test_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_infinite_edge_test_ring_C2( x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), x4.exact(), y4.exact(), w4.exact(), qx.exact(), qy.exact(), qw.exact(), b); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_is_degenerate_edge_test_sqrtf_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &x4, const Filtered_exact &y4, const Filtered_exact &w4) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_is_degenerate_edge_test_sqrtf_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_is_degenerate_edge_test_sqrtf_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), x4.interval(), y4.interval(), w4.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_is_degenerate_edge_test_sqrtf_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_is_degenerate_edge_test_sqrtf_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), x4.exact(), y4.exact(), w4.exact()); } } template < class CGAL_IA_CT, class CGAL_IA_ET, bool CGAL_IA_PROTECTED, class CGAL_IA_CACHE > /* */ bool ad_is_degenerate_edge_test_ring_C2( const Filtered_exact &x1, const Filtered_exact &y1, const Filtered_exact &w1, const Filtered_exact &x2, const Filtered_exact &y2, const Filtered_exact &w2, const Filtered_exact &x3, const Filtered_exact &y3, const Filtered_exact &w3, const Filtered_exact &x4, const Filtered_exact &y4, const Filtered_exact &w4) { try { #ifdef CGAL_PROFILE static Profile_counter calls("IA ad_is_degenerate_edge_test_ring_C2 calls"); ++calls; #endif Protect_FPU_rounding Protection; return ad_is_degenerate_edge_test_ring_C2( x1.interval(), y1.interval(), w1.interval(), x2.interval(), y2.interval(), w2.interval(), x3.interval(), y3.interval(), w3.interval(), x4.interval(), y4.interval(), w4.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { #ifdef CGAL_PROFILE static Profile_counter failures("IA ad_is_degenerate_edge_test_ring_C2 failures"); ++failures; #endif Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return ad_is_degenerate_edge_test_ring_C2( x1.exact(), y1.exact(), w1.exact(), x2.exact(), y2.exact(), w2.exact(), x3.exact(), y3.exact(), w3.exact(), x4.exact(), y4.exact(), w4.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_APOLLONIUS_GRAPH_FTC2_H ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000003134511344301501031342 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &pwt, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &qwt, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz, const Filtered_exact &rwt, const Filtered_exact &sx, const Filtered_exact &sy, const Filtered_exact &sz, const Filtered_exact &swt, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( px.interval(), py.interval(), pz.interval(), pwt.interval(), qx.interval(), qy.interval(), qz.interval(), qwt.interval(), rx.interval(), ry.interval(), rz.interval(), rwt.interval(), sx.interval(), sy.interval(), sz.interval(), swt.interval(), tx.interval(), ty.interval(), tz.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( px.exact(), py.exact(), pz.exact(), pwt.exact(), qx.exact(), qy.exact(), qz.exact(), qwt.exact(), rx.exact(), ry.exact(), rz.exact(), rwt.exact(), sx.exact(), sy.exact(), sz.exact(), swt.exact(), tx.exact(), ty.exact(), tz.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &qwt, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz, const Lazy_exact_nt &rwt, const Lazy_exact_nt &sx, const Lazy_exact_nt &sy, const Lazy_exact_nt &sz, const Lazy_exact_nt &swt, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( px.interval(), py.interval(), pz.interval(), pwt.interval(), qx.interval(), qy.interval(), qz.interval(), qwt.interval(), rx.interval(), ry.interval(), rz.interval(), rwt.interval(), sx.interval(), sy.interval(), sz.interval(), swt.interval(), tx.interval(), ty.interval(), tz.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( px.exact(), py.exact(), pz.exact(), pwt.exact(), qx.exact(), qy.exact(), qz.exact(), qwt.exact(), rx.exact(), ry.exact(), rz.exact(), rwt.exact(), sx.exact(), sy.exact(), sz.exact(), swt.exact(), tx.exact(), ty.exact(), tz.exact(), twt.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &pwt, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &qwt, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz, const Filtered_exact &rwt, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( px.interval(), py.interval(), pz.interval(), pwt.interval(), qx.interval(), qy.interval(), qz.interval(), qwt.interval(), rx.interval(), ry.interval(), rz.interval(), rwt.interval(), tx.interval(), ty.interval(), tz.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( px.exact(), py.exact(), pz.exact(), pwt.exact(), qx.exact(), qy.exact(), qz.exact(), qwt.exact(), rx.exact(), ry.exact(), rz.exact(), rwt.exact(), tx.exact(), ty.exact(), tz.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &qwt, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz, const Lazy_exact_nt &rwt, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( px.interval(), py.interval(), pz.interval(), pwt.interval(), qx.interval(), qy.interval(), qz.interval(), qwt.interval(), rx.interval(), ry.interval(), rz.interval(), rwt.interval(), tx.interval(), ty.interval(), tz.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( px.exact(), py.exact(), pz.exact(), pwt.exact(), qx.exact(), qy.exact(), qz.exact(), qwt.exact(), rx.exact(), ry.exact(), rz.exact(), rwt.exact(), tx.exact(), ty.exact(), tz.exact(), twt.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &pwt, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &qwt, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( px.interval(), py.interval(), pz.interval(), pwt.interval(), qx.interval(), qy.interval(), qz.interval(), qwt.interval(), tx.interval(), ty.interval(), tz.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( px.exact(), py.exact(), pz.exact(), pwt.exact(), qx.exact(), qy.exact(), qz.exact(), qwt.exact(), tx.exact(), ty.exact(), tz.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &qwt, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( px.interval(), py.interval(), pz.interval(), pwt.interval(), qx.interval(), qy.interval(), qz.interval(), qwt.interval(), tx.interval(), ty.interval(), tz.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( px.exact(), py.exact(), pz.exact(), pwt.exact(), qx.exact(), qy.exact(), qz.exact(), qwt.exact(), tx.exact(), ty.exact(), tz.exact(), twt.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testC3( const Filtered_exact &pwt, const Filtered_exact &qwt) { try { CGAL_PROFILER("IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( pwt.interval(), qwt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( pwt.exact(), qwt.exact()); } } template < class ET > /* */ Oriented_side power_testC3( const Lazy_exact_nt &pwt, const Lazy_exact_nt &qwt) { try { CGAL_PROFILER("Lazy IA power_testC3 calls"); Protect_FPU_rounding Protection; return power_testC3( pwt.interval(), qwt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC3( pwt.exact(), qwt.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000001501011344301501031331 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pwt, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qwt, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rwt, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testC2 calls"); Protect_FPU_rounding Protection; return power_testC2( px.interval(), py.interval(), pwt.interval(), qx.interval(), qy.interval(), qwt.interval(), rx.interval(), ry.interval(), rwt.interval(), tx.interval(), ty.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC2( px.exact(), py.exact(), pwt.exact(), qx.exact(), qy.exact(), qwt.exact(), rx.exact(), ry.exact(), rwt.exact(), tx.exact(), ty.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qwt, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rwt, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testC2 calls"); Protect_FPU_rounding Protection; return power_testC2( px.interval(), py.interval(), pwt.interval(), qx.interval(), qy.interval(), qwt.interval(), rx.interval(), ry.interval(), rwt.interval(), tx.interval(), ty.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC2( px.exact(), py.exact(), pwt.exact(), qx.exact(), qy.exact(), qwt.exact(), rx.exact(), ry.exact(), rwt.exact(), tx.exact(), ty.exact(), twt.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pwt, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qwt, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testC2 calls"); Protect_FPU_rounding Protection; return power_testC2( px.interval(), py.interval(), pwt.interval(), qx.interval(), qy.interval(), qwt.interval(), tx.interval(), ty.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC2( px.exact(), py.exact(), pwt.exact(), qx.exact(), qy.exact(), qwt.exact(), tx.exact(), ty.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qwt, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testC2 calls"); Protect_FPU_rounding Protection; return power_testC2( px.interval(), py.interval(), pwt.interval(), qx.interval(), qy.interval(), qwt.interval(), tx.interval(), ty.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testC2( px.exact(), py.exact(), pwt.exact(), qx.exact(), qy.exact(), qwt.exact(), tx.exact(), ty.exact(), twt.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/svd_predicates_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000003410111344301501031333 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/svd_predicates_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_FTC2_H #define CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_FTC2_H #include #include #include CGAL_BEGIN_NAMESPACE //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- static unsigned int num_failures_are_same_points = 0; static unsigned int num_failures_side_of_bisector = 0; static unsigned int num_failures_vertex_conflict = 0; static unsigned int num_failures_finite_edge_conflict = 0; static unsigned int num_failures_infinite_edge_conflict = 0; static unsigned int num_failures_is_degenerate_edge = 0; static unsigned int num_failures_arrangement_type = 0; static unsigned int num_failures_are_parallel = 0; static unsigned int num_failures_oriented_side = 0; //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- //---------------------------------------------------------------------------- template < class CT, class ET, bool Protected, class Cache, class ITag> class Svd_are_same_points_ftC2< Filtered_exact, ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_are_same_points_ftC2 IT_Predicate; typedef Svd_are_same_points_ftC2 ET_Predicate; public: inline bool operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[24]; for (unsigned int i = 0; i < 24; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_are_same_points++; ET v_ET[24]; for (unsigned int i = 0; i < 24; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template < class CT, class ET, bool Protected, class Cache, class ITag> class Svd_orientation_ftC2< Filtered_exact, ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_orientation_ftC2 IT_Predicate; typedef Svd_orientation_ftC2 ET_Predicate; public: inline Orientation operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[36]; for (unsigned int i = 0; i < 36; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_are_same_points++; ET v_ET[36]; for (unsigned int i = 0; i < 36; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template < class CT, class ET, bool Protected, class Cache, class MTag, class ITag> class Svd_oriented_side_of_bisector_ftC2< Filtered_exact, MTag,ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_oriented_side_of_bisector_ftC2 IT_Predicate; typedef Svd_oriented_side_of_bisector_ftC2 ET_Predicate; public: inline Oriented_side operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[36]; for (unsigned int i = 0; i < 36; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_side_of_bisector++; ET v_ET[36]; for (unsigned int i = 0; i < 36; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template < class CT, class ET, bool Protected, class Cache, class MTag, class ITag, int Num_sites> class Svd_vertex_conflict_ftC2< Filtered_exact, MTag,ITag,Num_sites> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_vertex_conflict_ftC2 IT_Predicate; typedef Svd_vertex_conflict_ftC2 ET_Predicate; public: inline Sign operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[12 * Num_sites]; for (unsigned int i = 0; i < 12 * Num_sites; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_vertex_conflict++; ET v_ET[12 * Num_sites]; for (unsigned int i = 0; i < 12 * Num_sites; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template < class CT, class ET, bool Protected, class Cache, class MTag, class ITag, int Num_sites> class Svd_finite_edge_conflict_ftC2< Filtered_exact, MTag,ITag,Num_sites> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_finite_edge_conflict_ftC2 IT_Predicate; typedef Svd_finite_edge_conflict_ftC2 ET_Predicate; public: inline bool operator()(const FT v[], Sign sgn, char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[12 * Num_sites]; for (unsigned int i = 0; i < 12 * Num_sites; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, sgn, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_finite_edge_conflict++; ET v_ET[12 * Num_sites]; for (unsigned int i = 0; i < 12 * Num_sites; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, sgn, site_types); } } }; //---------------------------------------------------------------------------- template class Svd_infinite_edge_conflict_ftC2< Filtered_exact, MTag,ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_infinite_edge_conflict_ftC2 IT_Predicate; typedef Svd_infinite_edge_conflict_ftC2 ET_Predicate; public: inline bool operator()(const FT v[], Sign sgn, const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[48]; for (unsigned int i = 0; i < 48; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, sgn, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_infinite_edge_conflict++; ET v_ET[48]; for (unsigned int i = 0; i < 48; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, sgn, site_types); } } }; //---------------------------------------------------------------------------- template class Svd_is_degenerate_edge_ftC2< Filtered_exact, MTag,ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_is_degenerate_edge_ftC2 IT_Predicate; typedef Svd_is_degenerate_edge_ftC2 ET_Predicate; public: inline bool operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[48]; for (unsigned int i = 0; i < 48; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_is_degenerate_edge++; ET v_ET[48]; for (unsigned int i = 0; i < 48; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template class Svd_arrangement_type_ftC2< Filtered_exact, MTag,ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_arrangement_type_ftC2 IT_Predicate; typedef Svd_arrangement_type_ftC2 ET_Predicate; public: typedef typename IT_Predicate::result_type result_type; inline result_type operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[24]; for (unsigned int i = 0; i < 24; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_arrangement_type++; ET v_ET[24]; for (unsigned int i = 0; i < 24; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template class Svd_are_parallel_ftC2< Filtered_exact, ITag> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_are_parallel_ftC2 IT_Predicate; typedef Svd_are_parallel_ftC2 ET_Predicate; public: inline bool operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[24]; for (unsigned int i = 0; i < 24; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_are_parallel++; ET v_ET[24]; for (unsigned int i = 0; i < 24; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- template class Svd_oriented_side_ftC2< Filtered_exact, MTag,ITag,Num_sites> { private: typedef Interval_nt_advanced IT; typedef Filtered_exact FT; typedef Svd_oriented_side_ftC2 IT_Predicate; typedef Svd_oriented_side_ftC2 ET_Predicate; public: inline Oriented_side operator()(const FT v[], const char site_types[]) const { try { Protect_FPU_rounding Protection; IT v_IT[12 * Num_sites]; for (unsigned int i = 0; i < 12 * Num_sites; i++) { v_IT[i] = v[i].interval(); } return IT_Predicate()(v_IT, site_types); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); num_failures_oriented_side++; ET v_ET[12 * Num_sites]; for (unsigned int i = 0; i < 12 * Num_sites; i++) { v_ET[i] = v[i].exact(); } return ET_Predicate()(v_ET, site_types); } } }; //---------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_SVD_PREDICATES_FTC2_H ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_rtH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000001467511344301501031351 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_rtH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testH3( const Filtered_exact &phx, const Filtered_exact &phy, const Filtered_exact &phz, const Filtered_exact &phw, const Filtered_exact &pwt, const Filtered_exact &qhx, const Filtered_exact &qhy, const Filtered_exact &qhz, const Filtered_exact &qhw, const Filtered_exact &qwt, const Filtered_exact &rhx, const Filtered_exact &rhy, const Filtered_exact &rhz, const Filtered_exact &rhw, const Filtered_exact &rwt, const Filtered_exact &shx, const Filtered_exact ­, const Filtered_exact &shz, const Filtered_exact &shw, const Filtered_exact &swt, const Filtered_exact &thx, const Filtered_exact &thy, const Filtered_exact &thz, const Filtered_exact &thw, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testH3 calls"); Protect_FPU_rounding Protection; return power_testH3( phx.interval(), phy.interval(), phz.interval(), phw.interval(), pwt.interval(), qhx.interval(), qhy.interval(), qhz.interval(), qhw.interval(), qwt.interval(), rhx.interval(), rhy.interval(), rhz.interval(), rhw.interval(), rwt.interval(), shx.interval(), shy.interval(), shz.interval(), shw.interval(), swt.interval(), thx.interval(), thy.interval(), thz.interval(), thw.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testH3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testH3( phx.exact(), phy.exact(), phz.exact(), phw.exact(), pwt.exact(), qhx.exact(), qhy.exact(), qhz.exact(), qhw.exact(), qwt.exact(), rhx.exact(), rhy.exact(), rhz.exact(), rhw.exact(), rwt.exact(), shx.exact(), shy.exact(), shz.exact(), shw.exact(), swt.exact(), thx.exact(), thy.exact(), thz.exact(), thw.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testH3( const Lazy_exact_nt &phx, const Lazy_exact_nt &phy, const Lazy_exact_nt &phz, const Lazy_exact_nt &phw, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qhx, const Lazy_exact_nt &qhy, const Lazy_exact_nt &qhz, const Lazy_exact_nt &qhw, const Lazy_exact_nt &qwt, const Lazy_exact_nt &rhx, const Lazy_exact_nt &rhy, const Lazy_exact_nt &rhz, const Lazy_exact_nt &rhw, const Lazy_exact_nt &rwt, const Lazy_exact_nt &shx, const Lazy_exact_nt ­, const Lazy_exact_nt &shz, const Lazy_exact_nt &shw, const Lazy_exact_nt &swt, const Lazy_exact_nt &thx, const Lazy_exact_nt &thy, const Lazy_exact_nt &thz, const Lazy_exact_nt &thw, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testH3 calls"); Protect_FPU_rounding Protection; return power_testH3( phx.interval(), phy.interval(), phz.interval(), phw.interval(), pwt.interval(), qhx.interval(), qhy.interval(), qhz.interval(), qhw.interval(), qwt.interval(), rhx.interval(), rhy.interval(), rhz.interval(), rhw.interval(), rwt.interval(), shx.interval(), shy.interval(), shz.interval(), shw.interval(), swt.interval(), thx.interval(), thy.interval(), thz.interval(), thw.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testH3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testH3( phx.exact(), phy.exact(), phz.exact(), phw.exact(), pwt.exact(), qhx.exact(), qhy.exact(), qhz.exact(), qhw.exact(), qwt.exact(), rhx.exact(), rhy.exact(), rhz.exact(), rhw.exact(), rwt.exact(), shx.exact(), shy.exact(), shz.exact(), shw.exact(), swt.exact(), thx.exact(), thy.exact(), thz.exact(), thw.exact(), twt.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H ././@LongLink0000000000000000000000000000021700000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/in_smallest_orthogonalcircle_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000001001111344301501031325 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/in_smallest_orthogonalcircle_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H #define CGAL_ARITHMETIC_FILTER_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* CGAL_MEDIUM_INLINE */ Bounded_side in_smallest_orthogonalcircleC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pw, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qw, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tw) { try { CGAL_PROFILER("IA in_smallest_orthogonalcircleC2 calls"); Protect_FPU_rounding Protection; return in_smallest_orthogonalcircleC2( px.interval(), py.interval(), pw.interval(), qx.interval(), qy.interval(), qw.interval(), tx.interval(), ty.interval(), tw.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA in_smallest_orthogonalcircleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return in_smallest_orthogonalcircleC2( px.exact(), py.exact(), pw.exact(), qx.exact(), qy.exact(), qw.exact(), tx.exact(), ty.exact(), tw.exact()); } } template < class ET > /* CGAL_MEDIUM_INLINE */ Bounded_side in_smallest_orthogonalcircleC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pw, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qw, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tw) { try { CGAL_PROFILER("Lazy IA in_smallest_orthogonalcircleC2 calls"); Protect_FPU_rounding Protection; return in_smallest_orthogonalcircleC2( px.interval(), py.interval(), pw.interval(), qx.interval(), qy.interval(), qw.interval(), tx.interval(), ty.interval(), tw.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA in_smallest_orthogonalcircleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return in_smallest_orthogonalcircleC2( px.exact(), py.exact(), pw.exact(), qx.exact(), qy.exact(), qw.exact(), tx.exact(), ty.exact(), tw.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/kernel_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000014404311344301501031342 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/kernel_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* inline */ bool parallelC2( const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l2a, const Filtered_exact &l2b) { try { CGAL_PROFILER("IA parallelC2 calls"); Protect_FPU_rounding Protection; return parallelC2( l1a.interval(), l1b.interval(), l2a.interval(), l2b.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA parallelC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC2( l1a.exact(), l1b.exact(), l2a.exact(), l2b.exact()); } } template < class ET > /* inline */ bool parallelC2( const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b) { try { CGAL_PROFILER("Lazy IA parallelC2 calls"); Protect_FPU_rounding Protection; return parallelC2( l1a.interval(), l1b.interval(), l2a.interval(), l2b.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA parallelC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC2( l1a.exact(), l1b.exact(), l2a.exact(), l2b.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ bool parallelC2( const Filtered_exact &s1sx, const Filtered_exact &s1sy, const Filtered_exact &s1tx, const Filtered_exact &s1ty, const Filtered_exact &s2sx, const Filtered_exact &s2sy, const Filtered_exact &s2tx, const Filtered_exact &s2ty) { try { CGAL_PROFILER("IA parallelC2 calls"); Protect_FPU_rounding Protection; return parallelC2( s1sx.interval(), s1sy.interval(), s1tx.interval(), s1ty.interval(), s2sx.interval(), s2sy.interval(), s2tx.interval(), s2ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA parallelC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC2( s1sx.exact(), s1sy.exact(), s1tx.exact(), s1ty.exact(), s2sx.exact(), s2sy.exact(), s2tx.exact(), s2ty.exact()); } } template < class ET > /* */ bool parallelC2( const Lazy_exact_nt &s1sx, const Lazy_exact_nt &s1sy, const Lazy_exact_nt &s1tx, const Lazy_exact_nt &s1ty, const Lazy_exact_nt &s2sx, const Lazy_exact_nt &s2sy, const Lazy_exact_nt &s2tx, const Lazy_exact_nt &s2ty) { try { CGAL_PROFILER("Lazy IA parallelC2 calls"); Protect_FPU_rounding Protection; return parallelC2( s1sx.interval(), s1sy.interval(), s1tx.interval(), s1ty.interval(), s2sx.interval(), s2sy.interval(), s2tx.interval(), s2ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA parallelC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC2( s1sx.exact(), s1sy.exact(), s1tx.exact(), s1ty.exact(), s2sx.exact(), s2sy.exact(), s2tx.exact(), s2ty.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_lineC2( const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l1c, const Filtered_exact &l2a, const Filtered_exact &l2b, const Filtered_exact &l2c) { try { CGAL_PROFILER("IA equal_lineC2 calls"); Protect_FPU_rounding Protection; return equal_lineC2( l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA equal_lineC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_lineC2( l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_lineC2( const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l1c, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b, const Lazy_exact_nt &l2c) { try { CGAL_PROFILER("Lazy IA equal_lineC2 calls"); Protect_FPU_rounding Protection; return equal_lineC2( l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA equal_lineC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_lineC2( l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_xC2( const Filtered_exact &px, const Filtered_exact &la, const Filtered_exact &lb, const Filtered_exact &lc, const Filtered_exact &ha, const Filtered_exact &hb, const Filtered_exact &hc) { try { CGAL_PROFILER("IA compare_xC2 calls"); Protect_FPU_rounding Protection; return compare_xC2( px.interval(), la.interval(), lb.interval(), lc.interval(), ha.interval(), hb.interval(), hc.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_xC2( px.exact(), la.exact(), lb.exact(), lc.exact(), ha.exact(), hb.exact(), hc.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_xC2( const Lazy_exact_nt &px, const Lazy_exact_nt &la, const Lazy_exact_nt &lb, const Lazy_exact_nt &lc, const Lazy_exact_nt &ha, const Lazy_exact_nt &hb, const Lazy_exact_nt &hc) { try { CGAL_PROFILER("Lazy IA compare_xC2 calls"); Protect_FPU_rounding Protection; return compare_xC2( px.interval(), la.interval(), lb.interval(), lc.interval(), ha.interval(), hb.interval(), hc.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_xC2( px.exact(), la.exact(), lb.exact(), lc.exact(), ha.exact(), hb.exact(), hc.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_xC2( const Filtered_exact &la, const Filtered_exact &lb, const Filtered_exact &lc, const Filtered_exact &h1a, const Filtered_exact &h1b, const Filtered_exact &h1c, const Filtered_exact &h2a, const Filtered_exact &h2b, const Filtered_exact &h2c) { try { CGAL_PROFILER("IA compare_xC2 calls"); Protect_FPU_rounding Protection; return compare_xC2( la.interval(), lb.interval(), lc.interval(), h1a.interval(), h1b.interval(), h1c.interval(), h2a.interval(), h2b.interval(), h2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_xC2( la.exact(), lb.exact(), lc.exact(), h1a.exact(), h1b.exact(), h1c.exact(), h2a.exact(), h2b.exact(), h2c.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_xC2( const Lazy_exact_nt &la, const Lazy_exact_nt &lb, const Lazy_exact_nt &lc, const Lazy_exact_nt &h1a, const Lazy_exact_nt &h1b, const Lazy_exact_nt &h1c, const Lazy_exact_nt &h2a, const Lazy_exact_nt &h2b, const Lazy_exact_nt &h2c) { try { CGAL_PROFILER("Lazy IA compare_xC2 calls"); Protect_FPU_rounding Protection; return compare_xC2( la.interval(), lb.interval(), lc.interval(), h1a.interval(), h1b.interval(), h1c.interval(), h2a.interval(), h2b.interval(), h2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_xC2( la.exact(), lb.exact(), lc.exact(), h1a.exact(), h1b.exact(), h1c.exact(), h2a.exact(), h2b.exact(), h2c.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_xC2( const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l1c, const Filtered_exact &h1a, const Filtered_exact &h1b, const Filtered_exact &h1c, const Filtered_exact &l2a, const Filtered_exact &l2b, const Filtered_exact &l2c, const Filtered_exact &h2a, const Filtered_exact &h2b, const Filtered_exact &h2c) { try { CGAL_PROFILER("IA compare_xC2 calls"); Protect_FPU_rounding Protection; return compare_xC2( l1a.interval(), l1b.interval(), l1c.interval(), h1a.interval(), h1b.interval(), h1c.interval(), l2a.interval(), l2b.interval(), l2c.interval(), h2a.interval(), h2b.interval(), h2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_xC2( l1a.exact(), l1b.exact(), l1c.exact(), h1a.exact(), h1b.exact(), h1c.exact(), l2a.exact(), l2b.exact(), l2c.exact(), h2a.exact(), h2b.exact(), h2c.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_xC2( const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l1c, const Lazy_exact_nt &h1a, const Lazy_exact_nt &h1b, const Lazy_exact_nt &h1c, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b, const Lazy_exact_nt &l2c, const Lazy_exact_nt &h2a, const Lazy_exact_nt &h2b, const Lazy_exact_nt &h2c) { try { CGAL_PROFILER("Lazy IA compare_xC2 calls"); Protect_FPU_rounding Protection; return compare_xC2( l1a.interval(), l1b.interval(), l1c.interval(), h1a.interval(), h1b.interval(), h1c.interval(), l2a.interval(), l2b.interval(), l2c.interval(), h2a.interval(), h2b.interval(), h2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_xC2( l1a.exact(), l1b.exact(), l1c.exact(), h1a.exact(), h1b.exact(), h1c.exact(), l2a.exact(), l2b.exact(), l2c.exact(), h2a.exact(), h2b.exact(), h2c.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_y_at_xC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &la, const Filtered_exact &lb, const Filtered_exact &lc) { try { CGAL_PROFILER("IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( px.interval(), py.interval(), la.interval(), lb.interval(), lc.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( px.exact(), py.exact(), la.exact(), lb.exact(), lc.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_y_at_xC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &la, const Lazy_exact_nt &lb, const Lazy_exact_nt &lc) { try { CGAL_PROFILER("Lazy IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( px.interval(), py.interval(), la.interval(), lb.interval(), lc.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( px.exact(), py.exact(), la.exact(), lb.exact(), lc.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_y_at_xC2( const Filtered_exact &px, const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l1c, const Filtered_exact &l2a, const Filtered_exact &l2b, const Filtered_exact &l2c) { try { CGAL_PROFILER("IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( px.interval(), l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( px.exact(), l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_y_at_xC2( const Lazy_exact_nt &px, const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l1c, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b, const Lazy_exact_nt &l2c) { try { CGAL_PROFILER("Lazy IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( px.interval(), l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( px.exact(), l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Comparison_result compare_y_at_xC2( const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l1c, const Filtered_exact &l2a, const Filtered_exact &l2b, const Filtered_exact &l2c, const Filtered_exact &ha, const Filtered_exact &hb, const Filtered_exact &hc) { try { CGAL_PROFILER("IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval(), ha.interval(), hb.interval(), hc.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact(), ha.exact(), hb.exact(), hc.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Comparison_result compare_y_at_xC2( const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l1c, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b, const Lazy_exact_nt &l2c, const Lazy_exact_nt &ha, const Lazy_exact_nt &hb, const Lazy_exact_nt &hc) { try { CGAL_PROFILER("Lazy IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval(), ha.interval(), hb.interval(), hc.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact(), ha.exact(), hb.exact(), hc.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Comparison_result compare_y_at_xC2( const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l1c, const Filtered_exact &l2a, const Filtered_exact &l2b, const Filtered_exact &l2c, const Filtered_exact &h1a, const Filtered_exact &h1b, const Filtered_exact &h1c, const Filtered_exact &h2a, const Filtered_exact &h2b, const Filtered_exact &h2c) { try { CGAL_PROFILER("IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval(), h1a.interval(), h1b.interval(), h1c.interval(), h2a.interval(), h2b.interval(), h2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact(), h1a.exact(), h1b.exact(), h1c.exact(), h2a.exact(), h2b.exact(), h2c.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Comparison_result compare_y_at_xC2( const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l1c, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b, const Lazy_exact_nt &l2c, const Lazy_exact_nt &h1a, const Lazy_exact_nt &h1b, const Lazy_exact_nt &h1c, const Lazy_exact_nt &h2a, const Lazy_exact_nt &h2b, const Lazy_exact_nt &h2c) { try { CGAL_PROFILER("Lazy IA compare_y_at_xC2 calls"); Protect_FPU_rounding Protection; return compare_y_at_xC2( l1a.interval(), l1b.interval(), l1c.interval(), l2a.interval(), l2b.interval(), l2c.interval(), h1a.interval(), h1b.interval(), h1c.interval(), h2a.interval(), h2b.interval(), h2c.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_y_at_xC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_xC2( l1a.exact(), l1b.exact(), l1c.exact(), l2a.exact(), l2b.exact(), l2c.exact(), h1a.exact(), h1b.exact(), h1c.exact(), h2a.exact(), h2b.exact(), h2c.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Comparison_result compare_y_at_x_segment_C2( const Filtered_exact &px, const Filtered_exact &s1sx, const Filtered_exact &s1sy, const Filtered_exact &s1tx, const Filtered_exact &s1ty, const Filtered_exact &s2sx, const Filtered_exact &s2sy, const Filtered_exact &s2tx, const Filtered_exact &s2ty) { try { CGAL_PROFILER("IA compare_y_at_x_segment_C2 calls"); Protect_FPU_rounding Protection; return compare_y_at_x_segment_C2( px.interval(), s1sx.interval(), s1sy.interval(), s1tx.interval(), s1ty.interval(), s2sx.interval(), s2sy.interval(), s2tx.interval(), s2ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_y_at_x_segment_C2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_x_segment_C2( px.exact(), s1sx.exact(), s1sy.exact(), s1tx.exact(), s1ty.exact(), s2sx.exact(), s2sy.exact(), s2tx.exact(), s2ty.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Comparison_result compare_y_at_x_segment_C2( const Lazy_exact_nt &px, const Lazy_exact_nt &s1sx, const Lazy_exact_nt &s1sy, const Lazy_exact_nt &s1tx, const Lazy_exact_nt &s1ty, const Lazy_exact_nt &s2sx, const Lazy_exact_nt &s2sy, const Lazy_exact_nt &s2tx, const Lazy_exact_nt &s2ty) { try { CGAL_PROFILER("Lazy IA compare_y_at_x_segment_C2 calls"); Protect_FPU_rounding Protection; return compare_y_at_x_segment_C2( px.interval(), s1sx.interval(), s1sy.interval(), s1tx.interval(), s1ty.interval(), s2sx.interval(), s2sy.interval(), s2tx.interval(), s2ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_y_at_x_segment_C2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_y_at_x_segment_C2( px.exact(), s1sx.exact(), s1sy.exact(), s1tx.exact(), s1ty.exact(), s2sx.exact(), s2sy.exact(), s2tx.exact(), s2ty.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_directionC2( const Filtered_exact &dx1, const Filtered_exact &dy1, const Filtered_exact &dx2, const Filtered_exact &dy2) { try { CGAL_PROFILER("IA equal_directionC2 calls"); Protect_FPU_rounding Protection; return equal_directionC2( dx1.interval(), dy1.interval(), dx2.interval(), dy2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA equal_directionC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_directionC2( dx1.exact(), dy1.exact(), dx2.exact(), dy2.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_directionC2( const Lazy_exact_nt &dx1, const Lazy_exact_nt &dy1, const Lazy_exact_nt &dx2, const Lazy_exact_nt &dy2) { try { CGAL_PROFILER("Lazy IA equal_directionC2 calls"); Protect_FPU_rounding Protection; return equal_directionC2( dx1.interval(), dy1.interval(), dx2.interval(), dy2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA equal_directionC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_directionC2( dx1.exact(), dy1.exact(), dx2.exact(), dy2.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_slopesC2( const Filtered_exact &l1a, const Filtered_exact &l1b, const Filtered_exact &l2a, const Filtered_exact &l2b) { try { CGAL_PROFILER("IA compare_slopesC2 calls"); Protect_FPU_rounding Protection; return compare_slopesC2( l1a.interval(), l1b.interval(), l2a.interval(), l2b.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_slopesC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_slopesC2( l1a.exact(), l1b.exact(), l2a.exact(), l2b.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_slopesC2( const Lazy_exact_nt &l1a, const Lazy_exact_nt &l1b, const Lazy_exact_nt &l2a, const Lazy_exact_nt &l2b) { try { CGAL_PROFILER("Lazy IA compare_slopesC2 calls"); Protect_FPU_rounding Protection; return compare_slopesC2( l1a.interval(), l1b.interval(), l2a.interval(), l2b.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_slopesC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_slopesC2( l1a.exact(), l1b.exact(), l2a.exact(), l2b.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_slopesC2( const Filtered_exact &s1_src_x, const Filtered_exact &s1_src_y, const Filtered_exact &s1_tgt_x, const Filtered_exact &s1_tgt_y, const Filtered_exact &s2_src_x, const Filtered_exact &s2_src_y, const Filtered_exact &s2_tgt_x, const Filtered_exact &s2_tgt_y) { try { CGAL_PROFILER("IA compare_slopesC2 calls"); Protect_FPU_rounding Protection; return compare_slopesC2( s1_src_x.interval(), s1_src_y.interval(), s1_tgt_x.interval(), s1_tgt_y.interval(), s2_src_x.interval(), s2_src_y.interval(), s2_tgt_x.interval(), s2_tgt_y.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_slopesC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_slopesC2( s1_src_x.exact(), s1_src_y.exact(), s1_tgt_x.exact(), s1_tgt_y.exact(), s2_src_x.exact(), s2_src_y.exact(), s2_tgt_x.exact(), s2_tgt_y.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result compare_slopesC2( const Lazy_exact_nt &s1_src_x, const Lazy_exact_nt &s1_src_y, const Lazy_exact_nt &s1_tgt_x, const Lazy_exact_nt &s1_tgt_y, const Lazy_exact_nt &s2_src_x, const Lazy_exact_nt &s2_src_y, const Lazy_exact_nt &s2_tgt_x, const Lazy_exact_nt &s2_tgt_y) { try { CGAL_PROFILER("Lazy IA compare_slopesC2 calls"); Protect_FPU_rounding Protection; return compare_slopesC2( s1_src_x.interval(), s1_src_y.interval(), s1_tgt_x.interval(), s1_tgt_y.interval(), s2_src_x.interval(), s2_src_y.interval(), s2_tgt_x.interval(), s2_tgt_y.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_slopesC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_slopesC2( s1_src_x.exact(), s1_src_y.exact(), s1_tgt_x.exact(), s1_tgt_y.exact(), s2_src_x.exact(), s2_src_y.exact(), s2_tgt_x.exact(), s2_tgt_y.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Comparison_result compare_deltax_deltayC2( const Filtered_exact &px, const Filtered_exact &qx, const Filtered_exact &ry, const Filtered_exact &sy) { try { CGAL_PROFILER("IA compare_deltax_deltayC2 calls"); Protect_FPU_rounding Protection; return compare_deltax_deltayC2( px.interval(), qx.interval(), ry.interval(), sy.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA compare_deltax_deltayC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_deltax_deltayC2( px.exact(), qx.exact(), ry.exact(), sy.exact()); } } template < class ET > /* inline */ Comparison_result compare_deltax_deltayC2( const Lazy_exact_nt &px, const Lazy_exact_nt &qx, const Lazy_exact_nt &ry, const Lazy_exact_nt &sy) { try { CGAL_PROFILER("Lazy IA compare_deltax_deltayC2 calls"); Protect_FPU_rounding Protection; return compare_deltax_deltayC2( px.interval(), qx.interval(), ry.interval(), sy.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA compare_deltax_deltayC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return compare_deltax_deltayC2( px.exact(), qx.exact(), ry.exact(), sy.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Orientation orientationC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &rx, const Filtered_exact &ry) { try { CGAL_PROFILER("IA orientationC2 calls"); Protect_FPU_rounding Protection; return orientationC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA orientationC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return orientationC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact()); } } template < class ET > /* inline */ Orientation orientationC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry) { try { CGAL_PROFILER("Lazy IA orientationC2 calls"); Protect_FPU_rounding Protection; return orientationC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA orientationC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return orientationC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Angle angleC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &rx, const Filtered_exact &ry) { try { CGAL_PROFILER("IA angleC2 calls"); Protect_FPU_rounding Protection; return angleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA angleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return angleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact()); } } template < class ET > /* inline */ Angle angleC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry) { try { CGAL_PROFILER("Lazy IA angleC2 calls"); Protect_FPU_rounding Protection; return angleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA angleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return angleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Oriented_side side_of_oriented_circleC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &tx, const Filtered_exact &ty) { try { CGAL_PROFILER("IA side_of_oriented_circleC2 calls"); Protect_FPU_rounding Protection; return side_of_oriented_circleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval(), tx.interval(), ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_oriented_circleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_circleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact(), tx.exact(), ty.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Oriented_side side_of_oriented_circleC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty) { try { CGAL_PROFILER("Lazy IA side_of_oriented_circleC2 calls"); Protect_FPU_rounding Protection; return side_of_oriented_circleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval(), tx.interval(), ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_oriented_circleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_circleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact(), tx.exact(), ty.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Bounded_side side_of_bounded_circleC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &tx, const Filtered_exact &ty) { try { CGAL_PROFILER("IA side_of_bounded_circleC2 calls"); Protect_FPU_rounding Protection; return side_of_bounded_circleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval(), tx.interval(), ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_bounded_circleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_circleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact(), tx.exact(), ty.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Bounded_side side_of_bounded_circleC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty) { try { CGAL_PROFILER("Lazy IA side_of_bounded_circleC2 calls"); Protect_FPU_rounding Protection; return side_of_bounded_circleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval(), tx.interval(), ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_bounded_circleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_circleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact(), tx.exact(), ty.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Bounded_side side_of_bounded_circleC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &tx, const Filtered_exact &ty) { try { CGAL_PROFILER("IA side_of_bounded_circleC2 calls"); Protect_FPU_rounding Protection; return side_of_bounded_circleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), tx.interval(), ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_bounded_circleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_circleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), tx.exact(), ty.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Bounded_side side_of_bounded_circleC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty) { try { CGAL_PROFILER("Lazy IA side_of_bounded_circleC2 calls"); Protect_FPU_rounding Protection; return side_of_bounded_circleC2( px.interval(), py.interval(), qx.interval(), qy.interval(), tx.interval(), ty.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_bounded_circleC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_circleC2( px.exact(), py.exact(), qx.exact(), qy.exact(), tx.exact(), ty.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Comparison_result cmp_dist_to_pointC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &rx, const Filtered_exact &ry) { try { CGAL_PROFILER("IA cmp_dist_to_pointC2 calls"); Protect_FPU_rounding Protection; return cmp_dist_to_pointC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA cmp_dist_to_pointC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_dist_to_pointC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact()); } } template < class ET > /* inline */ Comparison_result cmp_dist_to_pointC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry) { try { CGAL_PROFILER("Lazy IA cmp_dist_to_pointC2 calls"); Protect_FPU_rounding Protection; return cmp_dist_to_pointC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA cmp_dist_to_pointC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_dist_to_pointC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Comparison_result cmp_signed_dist_to_directionC2( const Filtered_exact &la, const Filtered_exact &lb, const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy) { try { CGAL_PROFILER("IA cmp_signed_dist_to_directionC2 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_directionC2( la.interval(), lb.interval(), px.interval(), py.interval(), qx.interval(), qy.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA cmp_signed_dist_to_directionC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_directionC2( la.exact(), lb.exact(), px.exact(), py.exact(), qx.exact(), qy.exact()); } } template < class ET > /* inline */ Comparison_result cmp_signed_dist_to_directionC2( const Lazy_exact_nt &la, const Lazy_exact_nt &lb, const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy) { try { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_directionC2 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_directionC2( la.interval(), lb.interval(), px.interval(), py.interval(), qx.interval(), qy.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_directionC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_directionC2( la.exact(), lb.exact(), px.exact(), py.exact(), qx.exact(), qy.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Comparison_result cmp_signed_dist_to_lineC2( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &sx, const Filtered_exact &sy) { try { CGAL_PROFILER("IA cmp_signed_dist_to_lineC2 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_lineC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval(), sx.interval(), sy.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA cmp_signed_dist_to_lineC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_lineC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact(), sx.exact(), sy.exact()); } } template < class ET > /* inline */ Comparison_result cmp_signed_dist_to_lineC2( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &sx, const Lazy_exact_nt &sy) { try { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_lineC2 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_lineC2( px.interval(), py.interval(), qx.interval(), qy.interval(), rx.interval(), ry.interval(), sx.interval(), sy.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_lineC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_lineC2( px.exact(), py.exact(), qx.exact(), qy.exact(), rx.exact(), ry.exact(), sx.exact(), sy.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Oriented_side side_of_oriented_lineC2( const Filtered_exact &a, const Filtered_exact &b, const Filtered_exact &c, const Filtered_exact &x, const Filtered_exact &y) { try { CGAL_PROFILER("IA side_of_oriented_lineC2 calls"); Protect_FPU_rounding Protection; return side_of_oriented_lineC2( a.interval(), b.interval(), c.interval(), x.interval(), y.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_oriented_lineC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_lineC2( a.exact(), b.exact(), c.exact(), x.exact(), y.exact()); } } template < class ET > /* inline */ Oriented_side side_of_oriented_lineC2( const Lazy_exact_nt &a, const Lazy_exact_nt &b, const Lazy_exact_nt &c, const Lazy_exact_nt &x, const Lazy_exact_nt &y) { try { CGAL_PROFILER("Lazy IA side_of_oriented_lineC2 calls"); Protect_FPU_rounding Protection; return side_of_oriented_lineC2( a.interval(), b.interval(), c.interval(), x.interval(), y.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_oriented_lineC2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_lineC2( a.exact(), b.exact(), c.exact(), x.exact(), y.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_rtH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000001735511344301501031347 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/Regular_triangulation_rtH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testH2( const Filtered_exact &phx, const Filtered_exact &phy, const Filtered_exact &phw, const Filtered_exact &pwt, const Filtered_exact &qhx, const Filtered_exact &qhy, const Filtered_exact &qhw, const Filtered_exact &qwt, const Filtered_exact &rhx, const Filtered_exact &rhy, const Filtered_exact &rhw, const Filtered_exact &rwt, const Filtered_exact &thx, const Filtered_exact &thy, const Filtered_exact &thw, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testH2 calls"); Protect_FPU_rounding Protection; return power_testH2( phx.interval(), phy.interval(), phw.interval(), pwt.interval(), qhx.interval(), qhy.interval(), qhw.interval(), qwt.interval(), rhx.interval(), rhy.interval(), rhw.interval(), rwt.interval(), thx.interval(), thy.interval(), thw.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testH2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testH2( phx.exact(), phy.exact(), phw.exact(), pwt.exact(), qhx.exact(), qhy.exact(), qhw.exact(), qwt.exact(), rhx.exact(), rhy.exact(), rhw.exact(), rwt.exact(), thx.exact(), thy.exact(), thw.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testH2( const Lazy_exact_nt &phx, const Lazy_exact_nt &phy, const Lazy_exact_nt &phw, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qhx, const Lazy_exact_nt &qhy, const Lazy_exact_nt &qhw, const Lazy_exact_nt &qwt, const Lazy_exact_nt &rhx, const Lazy_exact_nt &rhy, const Lazy_exact_nt &rhw, const Lazy_exact_nt &rwt, const Lazy_exact_nt &thx, const Lazy_exact_nt &thy, const Lazy_exact_nt &thw, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testH2 calls"); Protect_FPU_rounding Protection; return power_testH2( phx.interval(), phy.interval(), phw.interval(), pwt.interval(), qhx.interval(), qhy.interval(), qhw.interval(), qwt.interval(), rhx.interval(), rhy.interval(), rhw.interval(), rwt.interval(), thx.interval(), thy.interval(), thw.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testH2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testH2( phx.exact(), phy.exact(), phw.exact(), pwt.exact(), qhx.exact(), qhy.exact(), qhw.exact(), qwt.exact(), rhx.exact(), rhy.exact(), rhw.exact(), rwt.exact(), thx.exact(), thy.exact(), thw.exact(), twt.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ Oriented_side power_testH2( const Filtered_exact &phx, const Filtered_exact &phy, const Filtered_exact &phw, const Filtered_exact &pwt, const Filtered_exact &qhx, const Filtered_exact &qhy, const Filtered_exact &qhw, const Filtered_exact &qwt, const Filtered_exact &thx, const Filtered_exact &thy, const Filtered_exact &thw, const Filtered_exact &twt) { try { CGAL_PROFILER("IA power_testH2 calls"); Protect_FPU_rounding Protection; return power_testH2( phx.interval(), phy.interval(), phw.interval(), pwt.interval(), qhx.interval(), qhy.interval(), qhw.interval(), qwt.interval(), thx.interval(), thy.interval(), thw.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA power_testH2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testH2( phx.exact(), phy.exact(), phw.exact(), pwt.exact(), qhx.exact(), qhy.exact(), qhw.exact(), qwt.exact(), thx.exact(), thy.exact(), thw.exact(), twt.exact()); } } template < class ET > /* */ Oriented_side power_testH2( const Lazy_exact_nt &phx, const Lazy_exact_nt &phy, const Lazy_exact_nt &phw, const Lazy_exact_nt &pwt, const Lazy_exact_nt &qhx, const Lazy_exact_nt &qhy, const Lazy_exact_nt &qhw, const Lazy_exact_nt &qwt, const Lazy_exact_nt &thx, const Lazy_exact_nt &thy, const Lazy_exact_nt &thw, const Lazy_exact_nt &twt) { try { CGAL_PROFILER("Lazy IA power_testH2 calls"); Protect_FPU_rounding Protection; return power_testH2( phx.interval(), phy.interval(), phw.interval(), pwt.interval(), qhx.interval(), qhy.interval(), qhw.interval(), qwt.interval(), thx.interval(), thy.interval(), thw.interval(), twt.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA power_testH2 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return power_testH2( phx.exact(), phy.exact(), phw.exact(), pwt.exact(), qhx.exact(), qhy.exact(), qhw.exact(), qwt.exact(), thx.exact(), thy.exact(), thw.exact(), twt.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/kernel_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/pred0000644000175000017500000013370311344301501031343 0ustar debiandebian// Copyright (c) 1997-2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/predicates/kernel_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H #include CGAL_BEGIN_NAMESPACE template class Lazy_exact_nt; CGAL_END_NAMESPACE CGAL_BEGIN_NAMESPACE template < class CT, class ET, bool Protected, class Cache > /* inline */ bool parallelC3( const Filtered_exact &v1x, const Filtered_exact &v1y, const Filtered_exact &v1z, const Filtered_exact &v2x, const Filtered_exact &v2y, const Filtered_exact &v2z) { try { CGAL_PROFILER("IA parallelC3 calls"); Protect_FPU_rounding Protection; return parallelC3( v1x.interval(), v1y.interval(), v1z.interval(), v2x.interval(), v2y.interval(), v2z.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA parallelC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC3( v1x.exact(), v1y.exact(), v1z.exact(), v2x.exact(), v2y.exact(), v2z.exact()); } } template < class ET > /* inline */ bool parallelC3( const Lazy_exact_nt &v1x, const Lazy_exact_nt &v1y, const Lazy_exact_nt &v1z, const Lazy_exact_nt &v2x, const Lazy_exact_nt &v2y, const Lazy_exact_nt &v2z) { try { CGAL_PROFILER("Lazy IA parallelC3 calls"); Protect_FPU_rounding Protection; return parallelC3( v1x.interval(), v1y.interval(), v1z.interval(), v2x.interval(), v2y.interval(), v2z.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA parallelC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC3( v1x.exact(), v1y.exact(), v1z.exact(), v2x.exact(), v2y.exact(), v2z.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* */ bool parallelC3( const Filtered_exact &s1sx, const Filtered_exact &s1sy, const Filtered_exact &s1sz, const Filtered_exact &s1tx, const Filtered_exact &s1ty, const Filtered_exact &s1tz, const Filtered_exact &s2sx, const Filtered_exact &s2sy, const Filtered_exact &s2sz, const Filtered_exact &s2tx, const Filtered_exact &s2ty, const Filtered_exact &s2tz) { try { CGAL_PROFILER("IA parallelC3 calls"); Protect_FPU_rounding Protection; return parallelC3( s1sx.interval(), s1sy.interval(), s1sz.interval(), s1tx.interval(), s1ty.interval(), s1tz.interval(), s2sx.interval(), s2sy.interval(), s2sz.interval(), s2tx.interval(), s2ty.interval(), s2tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA parallelC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC3( s1sx.exact(), s1sy.exact(), s1sz.exact(), s1tx.exact(), s1ty.exact(), s1tz.exact(), s2sx.exact(), s2sy.exact(), s2sz.exact(), s2tx.exact(), s2ty.exact(), s2tz.exact()); } } template < class ET > /* */ bool parallelC3( const Lazy_exact_nt &s1sx, const Lazy_exact_nt &s1sy, const Lazy_exact_nt &s1sz, const Lazy_exact_nt &s1tx, const Lazy_exact_nt &s1ty, const Lazy_exact_nt &s1tz, const Lazy_exact_nt &s2sx, const Lazy_exact_nt &s2sy, const Lazy_exact_nt &s2sz, const Lazy_exact_nt &s2tx, const Lazy_exact_nt &s2ty, const Lazy_exact_nt &s2tz) { try { CGAL_PROFILER("Lazy IA parallelC3 calls"); Protect_FPU_rounding Protection; return parallelC3( s1sx.interval(), s1sy.interval(), s1sz.interval(), s1tx.interval(), s1ty.interval(), s1tz.interval(), s2sx.interval(), s2sy.interval(), s2sz.interval(), s2tx.interval(), s2ty.interval(), s2tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA parallelC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return parallelC3( s1sx.exact(), s1sy.exact(), s1sz.exact(), s1tx.exact(), s1ty.exact(), s1tz.exact(), s2sx.exact(), s2sy.exact(), s2sz.exact(), s2tx.exact(), s2ty.exact(), s2tz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool strict_dominanceC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz) { try { CGAL_PROFILER("IA strict_dominanceC3 calls"); Protect_FPU_rounding Protection; return strict_dominanceC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA strict_dominanceC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return strict_dominanceC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool strict_dominanceC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz) { try { CGAL_PROFILER("Lazy IA strict_dominanceC3 calls"); Protect_FPU_rounding Protection; return strict_dominanceC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA strict_dominanceC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return strict_dominanceC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool dominanceC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz) { try { CGAL_PROFILER("IA dominanceC3 calls"); Protect_FPU_rounding Protection; return dominanceC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA dominanceC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return dominanceC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool dominanceC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz) { try { CGAL_PROFILER("Lazy IA dominanceC3 calls"); Protect_FPU_rounding Protection; return dominanceC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA dominanceC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return dominanceC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool collinearC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz) { try { CGAL_PROFILER("IA collinearC3 calls"); Protect_FPU_rounding Protection; return collinearC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA collinearC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return collinearC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool collinearC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz) { try { CGAL_PROFILER("Lazy IA collinearC3 calls"); Protect_FPU_rounding Protection; return collinearC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA collinearC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return collinearC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Orientation orientationC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz, const Filtered_exact &sx, const Filtered_exact &sy, const Filtered_exact &sz) { try { CGAL_PROFILER("IA orientationC3 calls"); Protect_FPU_rounding Protection; return orientationC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), sx.interval(), sy.interval(), sz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA orientationC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return orientationC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), sx.exact(), sy.exact(), sz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Orientation orientationC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz, const Lazy_exact_nt &sx, const Lazy_exact_nt &sy, const Lazy_exact_nt &sz) { try { CGAL_PROFILER("Lazy IA orientationC3 calls"); Protect_FPU_rounding Protection; return orientationC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), sx.interval(), sy.interval(), sz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA orientationC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return orientationC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), sx.exact(), sy.exact(), sz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* inline */ Angle angleC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz) { try { CGAL_PROFILER("IA angleC3 calls"); Protect_FPU_rounding Protection; return angleC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA angleC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return angleC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact()); } } template < class ET > /* inline */ Angle angleC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz) { try { CGAL_PROFILER("Lazy IA angleC3 calls"); Protect_FPU_rounding Protection; return angleC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA angleC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return angleC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Bounded_side coplanar_side_of_bounded_circleC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz) { try { CGAL_PROFILER("IA coplanar_side_of_bounded_circleC3 calls"); Protect_FPU_rounding Protection; return coplanar_side_of_bounded_circleC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA coplanar_side_of_bounded_circleC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return coplanar_side_of_bounded_circleC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Bounded_side coplanar_side_of_bounded_circleC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz) { try { CGAL_PROFILER("Lazy IA coplanar_side_of_bounded_circleC3 calls"); Protect_FPU_rounding Protection; return coplanar_side_of_bounded_circleC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA coplanar_side_of_bounded_circleC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return coplanar_side_of_bounded_circleC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_directionC3( const Filtered_exact &dx1, const Filtered_exact &dy1, const Filtered_exact &dz1, const Filtered_exact &dx2, const Filtered_exact &dy2, const Filtered_exact &dz2) { try { CGAL_PROFILER("IA equal_directionC3 calls"); Protect_FPU_rounding Protection; return equal_directionC3( dx1.interval(), dy1.interval(), dz1.interval(), dx2.interval(), dy2.interval(), dz2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA equal_directionC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_directionC3( dx1.exact(), dy1.exact(), dz1.exact(), dx2.exact(), dy2.exact(), dz2.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_directionC3( const Lazy_exact_nt &dx1, const Lazy_exact_nt &dy1, const Lazy_exact_nt &dz1, const Lazy_exact_nt &dx2, const Lazy_exact_nt &dy2, const Lazy_exact_nt &dz2) { try { CGAL_PROFILER("Lazy IA equal_directionC3 calls"); Protect_FPU_rounding Protection; return equal_directionC3( dx1.interval(), dy1.interval(), dz1.interval(), dx2.interval(), dy2.interval(), dz2.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA equal_directionC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_directionC3( dx1.exact(), dy1.exact(), dz1.exact(), dx2.exact(), dy2.exact(), dz2.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_planeC3( const Filtered_exact &ha, const Filtered_exact &hb, const Filtered_exact &hc, const Filtered_exact &hd, const Filtered_exact &pa, const Filtered_exact &pb, const Filtered_exact &pc, const Filtered_exact &pd) { try { CGAL_PROFILER("IA equal_planeC3 calls"); Protect_FPU_rounding Protection; return equal_planeC3( ha.interval(), hb.interval(), hc.interval(), hd.interval(), pa.interval(), pb.interval(), pc.interval(), pd.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA equal_planeC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_planeC3( ha.exact(), hb.exact(), hc.exact(), hd.exact(), pa.exact(), pb.exact(), pc.exact(), pd.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ bool equal_planeC3( const Lazy_exact_nt &ha, const Lazy_exact_nt &hb, const Lazy_exact_nt &hc, const Lazy_exact_nt &hd, const Lazy_exact_nt &pa, const Lazy_exact_nt &pb, const Lazy_exact_nt &pc, const Lazy_exact_nt &pd) { try { CGAL_PROFILER("Lazy IA equal_planeC3 calls"); Protect_FPU_rounding Protection; return equal_planeC3( ha.interval(), hb.interval(), hc.interval(), hd.interval(), pa.interval(), pb.interval(), pc.interval(), pd.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA equal_planeC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return equal_planeC3( ha.exact(), hb.exact(), hc.exact(), hd.exact(), pa.exact(), pb.exact(), pc.exact(), pd.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Oriented_side side_of_oriented_planeC3( const Filtered_exact &a, const Filtered_exact &b, const Filtered_exact &c, const Filtered_exact &d, const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz) { try { CGAL_PROFILER("IA side_of_oriented_planeC3 calls"); Protect_FPU_rounding Protection; return side_of_oriented_planeC3( a.interval(), b.interval(), c.interval(), d.interval(), px.interval(), py.interval(), pz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_oriented_planeC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_planeC3( a.exact(), b.exact(), c.exact(), d.exact(), px.exact(), py.exact(), pz.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Oriented_side side_of_oriented_planeC3( const Lazy_exact_nt &a, const Lazy_exact_nt &b, const Lazy_exact_nt &c, const Lazy_exact_nt &d, const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz) { try { CGAL_PROFILER("Lazy IA side_of_oriented_planeC3 calls"); Protect_FPU_rounding Protection; return side_of_oriented_planeC3( a.interval(), b.interval(), c.interval(), d.interval(), px.interval(), py.interval(), pz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_oriented_planeC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_planeC3( a.exact(), b.exact(), c.exact(), d.exact(), px.exact(), py.exact(), pz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_LARGE_INLINE */ Oriented_side side_of_oriented_sphereC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz, const Filtered_exact &sx, const Filtered_exact &sy, const Filtered_exact &sz, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz) { try { CGAL_PROFILER("IA side_of_oriented_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_oriented_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), sx.interval(), sy.interval(), sz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_oriented_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), sx.exact(), sy.exact(), sz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class ET > /* CGAL_KERNEL_LARGE_INLINE */ Oriented_side side_of_oriented_sphereC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz, const Lazy_exact_nt &sx, const Lazy_exact_nt &sy, const Lazy_exact_nt &sz, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz) { try { CGAL_PROFILER("Lazy IA side_of_oriented_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_oriented_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), sx.interval(), sy.interval(), sz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_oriented_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_oriented_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), sx.exact(), sy.exact(), sz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Bounded_side side_of_bounded_sphereC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz, const Filtered_exact &sx, const Filtered_exact &sy, const Filtered_exact &sz, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz) { try { CGAL_PROFILER("IA side_of_bounded_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_bounded_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), sx.interval(), sy.interval(), sz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_bounded_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), sx.exact(), sy.exact(), sz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Bounded_side side_of_bounded_sphereC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz, const Lazy_exact_nt &sx, const Lazy_exact_nt &sy, const Lazy_exact_nt &sz, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz) { try { CGAL_PROFILER("Lazy IA side_of_bounded_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_bounded_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval(), sx.interval(), sy.interval(), sz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_bounded_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact(), sx.exact(), sy.exact(), sz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Bounded_side side_of_bounded_sphereC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz) { try { CGAL_PROFILER("IA side_of_bounded_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_bounded_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_bounded_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Bounded_side side_of_bounded_sphereC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz) { try { CGAL_PROFILER("Lazy IA side_of_bounded_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_bounded_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_bounded_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_INLINE */ Comparison_result cmp_dist_to_pointC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &rx, const Filtered_exact &ry, const Filtered_exact &rz) { try { CGAL_PROFILER("IA cmp_dist_to_pointC3 calls"); Protect_FPU_rounding Protection; return cmp_dist_to_pointC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA cmp_dist_to_pointC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_dist_to_pointC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact()); } } template < class ET > /* CGAL_KERNEL_INLINE */ Comparison_result cmp_dist_to_pointC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &rx, const Lazy_exact_nt &ry, const Lazy_exact_nt &rz) { try { CGAL_PROFILER("Lazy IA cmp_dist_to_pointC3 calls"); Protect_FPU_rounding Protection; return cmp_dist_to_pointC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), rx.interval(), ry.interval(), rz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA cmp_dist_to_pointC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_dist_to_pointC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), rx.exact(), ry.exact(), rz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Bounded_side side_of_bounded_sphereC3( const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz, const Filtered_exact &sx, const Filtered_exact &sy, const Filtered_exact &sz, const Filtered_exact &tx, const Filtered_exact &ty, const Filtered_exact &tz) { try { CGAL_PROFILER("IA side_of_bounded_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_bounded_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), sx.interval(), sy.interval(), sz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA side_of_bounded_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), sx.exact(), sy.exact(), sz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Bounded_side side_of_bounded_sphereC3( const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz, const Lazy_exact_nt &sx, const Lazy_exact_nt &sy, const Lazy_exact_nt &sz, const Lazy_exact_nt &tx, const Lazy_exact_nt &ty, const Lazy_exact_nt &tz) { try { CGAL_PROFILER("Lazy IA side_of_bounded_sphereC3 calls"); Protect_FPU_rounding Protection; return side_of_bounded_sphereC3( px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval(), sx.interval(), sy.interval(), sz.interval(), tx.interval(), ty.interval(), tz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA side_of_bounded_sphereC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return side_of_bounded_sphereC3( px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact(), sx.exact(), sy.exact(), sz.exact(), tx.exact(), ty.exact(), tz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result cmp_signed_dist_to_directionC3( const Filtered_exact &pa, const Filtered_exact &pb, const Filtered_exact &pc, const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz) { try { CGAL_PROFILER("IA cmp_signed_dist_to_directionC3 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_directionC3( pa.interval(), pb.interval(), pc.interval(), px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA cmp_signed_dist_to_directionC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_directionC3( pa.exact(), pb.exact(), pc.exact(), px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result cmp_signed_dist_to_directionC3( const Lazy_exact_nt &pa, const Lazy_exact_nt &pb, const Lazy_exact_nt &pc, const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz) { try { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_directionC3 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_directionC3( pa.interval(), pb.interval(), pc.interval(), px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_directionC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_directionC3( pa.exact(), pb.exact(), pc.exact(), px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class CT, class ET, bool Protected, class Cache > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result cmp_signed_dist_to_planeC3( const Filtered_exact &ppx, const Filtered_exact &ppy, const Filtered_exact &ppz, const Filtered_exact &pqx, const Filtered_exact &pqy, const Filtered_exact &pqz, const Filtered_exact &prx, const Filtered_exact &pry, const Filtered_exact &prz, const Filtered_exact &px, const Filtered_exact &py, const Filtered_exact &pz, const Filtered_exact &qx, const Filtered_exact &qy, const Filtered_exact &qz) { try { CGAL_PROFILER("IA cmp_signed_dist_to_planeC3 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_planeC3( ppx.interval(), ppy.interval(), ppz.interval(), pqx.interval(), pqy.interval(), pqz.interval(), prx.interval(), pry.interval(), prz.interval(), px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("IA cmp_signed_dist_to_planeC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_planeC3( ppx.exact(), ppy.exact(), ppz.exact(), pqx.exact(), pqy.exact(), pqz.exact(), prx.exact(), pry.exact(), prz.exact(), px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } template < class ET > /* CGAL_KERNEL_MEDIUM_INLINE */ Comparison_result cmp_signed_dist_to_planeC3( const Lazy_exact_nt &ppx, const Lazy_exact_nt &ppy, const Lazy_exact_nt &ppz, const Lazy_exact_nt &pqx, const Lazy_exact_nt &pqy, const Lazy_exact_nt &pqz, const Lazy_exact_nt &prx, const Lazy_exact_nt &pry, const Lazy_exact_nt &prz, const Lazy_exact_nt &px, const Lazy_exact_nt &py, const Lazy_exact_nt &pz, const Lazy_exact_nt &qx, const Lazy_exact_nt &qy, const Lazy_exact_nt &qz) { try { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_planeC3 calls"); Protect_FPU_rounding Protection; return cmp_signed_dist_to_planeC3( ppx.interval(), ppy.interval(), ppz.interval(), pqx.interval(), pqy.interval(), pqz.interval(), prx.interval(), pry.interval(), prz.interval(), px.interval(), py.interval(), pz.interval(), qx.interval(), qy.interval(), qz.interval()); } catch (Interval_nt_advanced::unsafe_comparison) { CGAL_PROFILER("Lazy IA cmp_signed_dist_to_planeC3 failures"); Protect_FPU_rounding Protection(CGAL_FE_TONEAREST); return cmp_signed_dist_to_planeC3( ppx.exact(), ppy.exact(), ppz.exact(), pqx.exact(), pqy.exact(), pqz.exact(), prx.exact(), pry.exact(), prz.exact(), px.exact(), py.exact(), pz.exact(), qx.exact(), qy.exact(), qz.exact()); } } CGAL_END_NAMESPACE #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/dispatch.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/disp0000644000175000017500000000541211344301501031343 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/dispatch.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_ARITHMETIC_FILTER_DISPATCH_H #define CGAL_ARITHMETIC_FILTER_DISPATCH_H #if !defined( CGAL_ARITHMETIC_FILTER_PREDICATES_BUILTIN_H ) #include #endif #if defined( CGAL_PREDICATES_SIGN_OF_DETERMINANT_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H ) #include #endif #if defined( CGAL_PREDICATES_KERNEL_FTC2_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H ) #include #endif #if defined( CGAL_PREDICATES_KERNEL_FTC3_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H ) #include #endif #if defined( CGAL_REGULAR_TRIANGULATION_FTC2_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H ) #include #endif /* #if defined( CGAL_REGULAR_TRIANGULATION_RTH2_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H ) #include #endif */ #if defined( CGAL_REGULAR_TRIANGULATION_FTC3_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H ) #include #endif /* #if defined( CGAL_REGULAR_TRIANGULATION_RTH3_H ) && \ !defined( CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H ) #include #endif */ #endif // CGAL_ARITHMETIC_FILTER_DISPATCH_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000755000175000017500000000000012146213677031374 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000755000175000017500000000000012146213677031374 5ustar debiandebian././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/builtin.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000303011344301501031351 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/builtin.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_ARITHMETIC_FILTER_STATIC_INFOS_BUILTIN_H #define CGAL_ARITHMETIC_FILTER_STATIC_INFOS_BUILTIN_H double CGAL_NTS Static_Filtered_sign_1::_bound=-1.0; double CGAL_NTS Static_Filtered_sign_1::_epsilon_0; double CGAL_NTS Static_Filtered_compare_2::_bound=-1.0; double CGAL_NTS Static_Filtered_compare_2::_epsilon_0; #endif // CGAL_ARITHMETIC_FILTER_STATIC_INFOS_BUILTIN_H ././@LongLink0000000000000000000000000000021600000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/sign_of_determinant.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000422311344301501031356 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/sign_of_determinant.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H_STATIC_INFO_H #include double Static_Filtered_sign_of_determinant2x2_4::_epsilon_0; double Static_Filtered_sign_of_determinant2x2_4::_bound = -1.0; double Static_Filtered_sign_of_determinant3x3_9::_epsilon_0; double Static_Filtered_sign_of_determinant3x3_9::_bound = -1.0; double Static_Filtered_sign_of_determinant4x4_16::_epsilon_0; double Static_Filtered_sign_of_determinant4x4_16::_bound = -1.0; double Static_Filtered_sign_of_determinant5x5_25::_epsilon_0; double Static_Filtered_sign_of_determinant5x5_25::_bound = -1.0; double Static_Filtered_sign_of_determinant6x6_36::_epsilon_0; double Static_Filtered_sign_of_determinant6x6_36::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_SIGN_OF_DETERMINANT_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000022500000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000453611344301501031365 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H_STATIC_INFO_H #include double Static_Filtered_power_testC3_20::_epsilon_0; double Static_Filtered_power_testC3_20::_bound = -1.0; double Static_Filtered_power_testC3_16::_epsilon_0; double Static_Filtered_power_testC3_16::_epsilon_1; double Static_Filtered_power_testC3_16::_epsilon_2; double Static_Filtered_power_testC3_16::_epsilon_3; double Static_Filtered_power_testC3_16::_epsilon_4; double Static_Filtered_power_testC3_16::_epsilon_5; double Static_Filtered_power_testC3_16::_bound = -1.0; double Static_Filtered_power_testC3_12::_epsilon_0; double Static_Filtered_power_testC3_12::_epsilon_1; double Static_Filtered_power_testC3_12::_epsilon_2; double Static_Filtered_power_testC3_12::_epsilon_3; double Static_Filtered_power_testC3_12::_epsilon_4; double Static_Filtered_power_testC3_12::_epsilon_5; double Static_Filtered_power_testC3_12::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC3_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000022500000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000360111344301501031355 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H_STATIC_INFO_H #include double Static_Filtered_power_testC2_12::_epsilon_0; double Static_Filtered_power_testC2_12::_bound = -1.0; double Static_Filtered_power_testC2_9::_epsilon_0; double Static_Filtered_power_testC2_9::_epsilon_1; double Static_Filtered_power_testC2_9::_epsilon_2; double Static_Filtered_power_testC2_9::_epsilon_3; double Static_Filtered_power_testC2_9::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_FTC2_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000022500000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_rtH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000317611344301501031364 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_rtH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H_STATIC_INFO_H #include double Static_Filtered_power_testH3_25::_epsilon_0; double Static_Filtered_power_testH3_25::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH3_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000023400000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/in_smallest_orthogonalcircle_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000327411344301501031363 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/in_smallest_orthogonalcircle_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H_STATIC_INFO_H #include double Static_Filtered_in_smallest_orthogonalcircleC2_9::_epsilon_0; double Static_Filtered_in_smallest_orthogonalcircleC2_9::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_IN_SMALLEST_ORTHOGONALCIRCLE_FTC2_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/kernel_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000001421311344301501031356 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/kernel_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H_STATIC_INFO_H #include double Static_Filtered_equal_lineC2_6::_epsilon_0; double Static_Filtered_equal_lineC2_6::_epsilon_1; double Static_Filtered_equal_lineC2_6::_epsilon_2; double Static_Filtered_equal_lineC2_6::_epsilon_3; double Static_Filtered_equal_lineC2_6::_epsilon_4; double Static_Filtered_equal_lineC2_6::_epsilon_5; double Static_Filtered_equal_lineC2_6::_epsilon_6; double Static_Filtered_equal_lineC2_6::_bound = -1.0; double Static_Filtered_compare_xC2_7::_epsilon_0; double Static_Filtered_compare_xC2_7::_epsilon_1; double Static_Filtered_compare_xC2_7::_bound = -1.0; double Static_Filtered_compare_xC2_9::_epsilon_0; double Static_Filtered_compare_xC2_9::_epsilon_1; double Static_Filtered_compare_xC2_9::_epsilon_2; double Static_Filtered_compare_xC2_9::_epsilon_3; double Static_Filtered_compare_xC2_9::_bound = -1.0; double Static_Filtered_compare_xC2_12::_epsilon_0; double Static_Filtered_compare_xC2_12::_epsilon_1; double Static_Filtered_compare_xC2_12::_epsilon_2; double Static_Filtered_compare_xC2_12::_bound = -1.0; double Static_Filtered_compare_y_at_xC2_5::_epsilon_0; double Static_Filtered_compare_y_at_xC2_5::_epsilon_1; double Static_Filtered_compare_y_at_xC2_5::_bound = -1.0; double Static_Filtered_compare_y_at_xC2_7::_epsilon_0; double Static_Filtered_compare_y_at_xC2_7::_epsilon_1; double Static_Filtered_compare_y_at_xC2_7::_epsilon_2; double Static_Filtered_compare_y_at_xC2_7::_bound = -1.0; double Static_Filtered_compare_y_at_xC2_9::_epsilon_0; double Static_Filtered_compare_y_at_xC2_9::_epsilon_1; double Static_Filtered_compare_y_at_xC2_9::_epsilon_2; double Static_Filtered_compare_y_at_xC2_9::_bound = -1.0; double Static_Filtered_compare_y_at_xC2_12::_epsilon_0; double Static_Filtered_compare_y_at_xC2_12::_epsilon_1; double Static_Filtered_compare_y_at_xC2_12::_epsilon_2; double Static_Filtered_compare_y_at_xC2_12::_epsilon_3; double Static_Filtered_compare_y_at_xC2_12::_bound = -1.0; double Static_Filtered_compare_y_at_x_segment_C2_9::_bound = -1.0; double Static_Filtered_equal_directionC2_4::_epsilon_0; double Static_Filtered_equal_directionC2_4::_epsilon_1; double Static_Filtered_equal_directionC2_4::_epsilon_2; double Static_Filtered_equal_directionC2_4::_epsilon_3; double Static_Filtered_equal_directionC2_4::_epsilon_4; double Static_Filtered_equal_directionC2_4::_bound = -1.0; double Static_Filtered_compare_slopesC2_4::_epsilon_0; double Static_Filtered_compare_slopesC2_4::_epsilon_1; double Static_Filtered_compare_slopesC2_4::_epsilon_2; double Static_Filtered_compare_slopesC2_4::_epsilon_3; double Static_Filtered_compare_slopesC2_4::_epsilon_4; double Static_Filtered_compare_slopesC2_4::_epsilon_5; double Static_Filtered_compare_slopesC2_4::_bound = -1.0; double Static_Filtered_compare_slopesC2_8::_epsilon_0; double Static_Filtered_compare_slopesC2_8::_epsilon_1; double Static_Filtered_compare_slopesC2_8::_epsilon_2; double Static_Filtered_compare_slopesC2_8::_epsilon_3; double Static_Filtered_compare_slopesC2_8::_epsilon_4; double Static_Filtered_compare_slopesC2_8::_epsilon_5; double Static_Filtered_compare_slopesC2_8::_epsilon_6; double Static_Filtered_compare_slopesC2_8::_epsilon_7; double Static_Filtered_compare_slopesC2_8::_epsilon_8; double Static_Filtered_compare_slopesC2_8::_epsilon_9; double Static_Filtered_compare_slopesC2_8::_epsilon_10; double Static_Filtered_compare_slopesC2_8::_epsilon_11; double Static_Filtered_compare_slopesC2_8::_bound = -1.0; double Static_Filtered_compare_deltax_deltayC2_4::_epsilon_0; double Static_Filtered_compare_deltax_deltayC2_4::_bound = -1.0; double Static_Filtered_orientationC2_6::_epsilon_0; double Static_Filtered_orientationC2_6::_bound = -1.0; double Static_Filtered_angleC2_6::_epsilon_0; double Static_Filtered_angleC2_6::_bound = -1.0; double Static_Filtered_side_of_oriented_circleC2_8::_epsilon_0; double Static_Filtered_side_of_oriented_circleC2_8::_bound = -1.0; double Static_Filtered_side_of_bounded_circleC2_8::_epsilon_0; double Static_Filtered_side_of_bounded_circleC2_8::_epsilon_1; double Static_Filtered_side_of_bounded_circleC2_8::_bound = -1.0; double Static_Filtered_side_of_bounded_circleC2_6::_epsilon_0; double Static_Filtered_side_of_bounded_circleC2_6::_bound = -1.0; double Static_Filtered_cmp_dist_to_pointC2_6::_epsilon_0; double Static_Filtered_cmp_dist_to_pointC2_6::_bound = -1.0; double Static_Filtered_cmp_signed_dist_to_directionC2_6::_epsilon_0; double Static_Filtered_cmp_signed_dist_to_directionC2_6::_bound = -1.0; double Static_Filtered_cmp_signed_dist_to_lineC2_8::_epsilon_0; double Static_Filtered_cmp_signed_dist_to_lineC2_8::_bound = -1.0; double Static_Filtered_side_of_oriented_lineC2_5::_epsilon_0; double Static_Filtered_side_of_oriented_lineC2_5::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC2_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000022500000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_rtH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000343611344301501031363 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/Regular_triangulation_rtH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H_STATIC_INFO_H #include double Static_Filtered_power_testH2_16::_epsilon_0; double Static_Filtered_power_testH2_16::_bound = -1.0; double Static_Filtered_power_testH2_12::_epsilon_0; double Static_Filtered_power_testH2_12::_epsilon_1; double Static_Filtered_power_testH2_12::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_REGULAR_TRIANGULATION_RTH2_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/kernel_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000001212711344301501031360 0ustar debiandebian// Copyright (c) 1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/predicates/kernel_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // This file is automatically generated by // scripts/filtered_predicates_generator.pl #ifndef CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H_STATIC_INFO_H #define CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H_STATIC_INFO_H #include double Static_Filtered_strict_dominanceC3_6::_epsilon_0; double Static_Filtered_strict_dominanceC3_6::_epsilon_1; double Static_Filtered_strict_dominanceC3_6::_epsilon_2; double Static_Filtered_strict_dominanceC3_6::_bound = -1.0; double Static_Filtered_dominanceC3_6::_epsilon_0; double Static_Filtered_dominanceC3_6::_epsilon_1; double Static_Filtered_dominanceC3_6::_epsilon_2; double Static_Filtered_dominanceC3_6::_bound = -1.0; double Static_Filtered_collinearC3_9::_epsilon_0; double Static_Filtered_collinearC3_9::_epsilon_1; double Static_Filtered_collinearC3_9::_epsilon_2; double Static_Filtered_collinearC3_9::_bound = -1.0; double Static_Filtered_orientationC3_12::_epsilon_0; double Static_Filtered_orientationC3_12::_bound = -1.0; double Static_Filtered_angleC3_9::_epsilon_0; double Static_Filtered_angleC3_9::_bound = -1.0; double Static_Filtered_coplanar_side_of_bounded_circleC3_12::_epsilon_0; double Static_Filtered_coplanar_side_of_bounded_circleC3_12::_bound = -1.0; double Static_Filtered_equal_directionC3_6::_epsilon_0; double Static_Filtered_equal_directionC3_6::_epsilon_1; double Static_Filtered_equal_directionC3_6::_epsilon_2; double Static_Filtered_equal_directionC3_6::_epsilon_3; double Static_Filtered_equal_directionC3_6::_epsilon_4; double Static_Filtered_equal_directionC3_6::_epsilon_5; double Static_Filtered_equal_directionC3_6::_epsilon_6; double Static_Filtered_equal_directionC3_6::_epsilon_7; double Static_Filtered_equal_directionC3_6::_epsilon_8; double Static_Filtered_equal_directionC3_6::_bound = -1.0; double Static_Filtered_equal_planeC3_8::_epsilon_0; double Static_Filtered_equal_planeC3_8::_epsilon_1; double Static_Filtered_equal_planeC3_8::_epsilon_2; double Static_Filtered_equal_planeC3_8::_epsilon_3; double Static_Filtered_equal_planeC3_8::_epsilon_4; double Static_Filtered_equal_planeC3_8::_epsilon_5; double Static_Filtered_equal_planeC3_8::_epsilon_6; double Static_Filtered_equal_planeC3_8::_epsilon_7; double Static_Filtered_equal_planeC3_8::_epsilon_8; double Static_Filtered_equal_planeC3_8::_epsilon_9; double Static_Filtered_equal_planeC3_8::_epsilon_10; double Static_Filtered_equal_planeC3_8::_epsilon_11; double Static_Filtered_equal_planeC3_8::_epsilon_12; double Static_Filtered_equal_planeC3_8::_epsilon_13; double Static_Filtered_equal_planeC3_8::_epsilon_14; double Static_Filtered_equal_planeC3_8::_epsilon_15; double Static_Filtered_equal_planeC3_8::_epsilon_16; double Static_Filtered_equal_planeC3_8::_epsilon_17; double Static_Filtered_equal_planeC3_8::_bound = -1.0; double Static_Filtered_side_of_oriented_planeC3_7::_epsilon_0; double Static_Filtered_side_of_oriented_planeC3_7::_bound = -1.0; double Static_Filtered_side_of_oriented_sphereC3_15::_epsilon_0; double Static_Filtered_side_of_oriented_sphereC3_15::_bound = -1.0; double Static_Filtered_side_of_bounded_sphereC3_15::_epsilon_0; double Static_Filtered_side_of_bounded_sphereC3_15::_epsilon_1; double Static_Filtered_side_of_bounded_sphereC3_15::_bound = -1.0; double Static_Filtered_side_of_bounded_sphereC3_9::_epsilon_0; double Static_Filtered_side_of_bounded_sphereC3_9::_bound = -1.0; double Static_Filtered_cmp_dist_to_pointC3_9::_epsilon_0; double Static_Filtered_cmp_dist_to_pointC3_9::_bound = -1.0; double Static_Filtered_side_of_bounded_sphereC3_12::_epsilon_0; double Static_Filtered_side_of_bounded_sphereC3_12::_bound = -1.0; double Static_Filtered_cmp_signed_dist_to_directionC3_9::_epsilon_0; double Static_Filtered_cmp_signed_dist_to_directionC3_9::_bound = -1.0; double Static_Filtered_cmp_signed_dist_to_planeC3_15::_epsilon_0; double Static_Filtered_cmp_signed_dist_to_planeC3_15::_bound = -1.0; #endif // CGAL_ARITHMETIC_FILTER_PREDICATES_KERNEL_FTC3_H_STATIC_INFO_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/dispatch.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/stat0000644000175000017500000000411611344301501031357 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arithmetic_filter/static_infos/dispatch.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_ARITHMETIC_FILTER_STATIC_INFOS_DISPATCH_H #define CGAL_ARITHMETIC_FILTER_STATIC_INFOS_DISPATCH_H #include #include #include #include // #include // #include #include #include // #include // #include #endif // CGAL_ARITHMETIC_FILTER_STATIC_INFOS_DISPATCH_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_base_with_info_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_b0000644000175000017500000000367411344301501031474 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_base_with_info_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_TRIANGULATION_VERTEX_BASE_WITH_INFO_3_H #define CGAL_TRIANGULATION_VERTEX_BASE_WITH_INFO_3_H #include CGAL_BEGIN_NAMESPACE template < typename Info_, typename GT, typename Vb = Triangulation_vertex_base_3 > class Triangulation_vertex_base_with_info_3 : public Vb { Info_ _info; public: typedef typename Vb::Cell_handle Cell_handle; typedef typename Vb::Point Point; typedef Info_ Info; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Triangulation_vertex_base_with_info_3 Other; }; Triangulation_vertex_base_with_info_3() : Vb() {} Triangulation_vertex_base_with_info_3(const Point & p) : Vb(p) {} Triangulation_vertex_base_with_info_3(const Point & p, Cell_handle c) : Vb(p, c) {} Triangulation_vertex_base_with_info_3(Cell_handle c) : Vb(c) {} const Info& info() const { return _info; } Info& info() { return _info; } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_VERTEX_BASE_WITH_INFO_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_min_items.h0000644000175000017500000000377011344301500031172 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_min_items.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_MIN_ITEMS_H #define CGAL_HALFEDGEDS_MIN_ITEMS_H 1 #ifndef CGAL_HALFEDGEDS_VERTEX_MIN_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_HALFEDGE_MIN_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_FACE_MIN_BASE_H #include #endif CGAL_BEGIN_NAMESPACE class HalfedgeDS_min_items { public: template < class Refs, class Traits> struct Vertex_wrapper { typedef HalfedgeDS_vertex_min_base< Refs> Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef HalfedgeDS_halfedge_min_base< Refs> Halfedge; }; template < class Refs, class Traits> struct Face_wrapper { typedef HalfedgeDS_face_min_base< Refs> Face; }; }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_MIN_ITEMS_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/width_assertions.h0000644000175000017500000000552211344301501030567 0ustar debiandebian// Copyright (c) 1997-2000 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/width_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Thomas Herrmann #ifndef CGAL_WIDTH_ASSERTIONS_H #define CGAL_WIDTH_ASSERTIONS_H 1 #ifdef SIMPLIFY #define GCD_COMPUTATION 1 #endif #ifdef DEBUG //Turn assertion output on/off #define ASSERTION_OUTPUT 0 #define EXPENSIVE_CHECKS_OUTPUT 0 //Turn on/off output in preparation_check #define PREPARATION_CHECK 0 //Turn on/off output in neighbors_of #define NEIGHBORS_OF 0 //Turn on/off output of setminus, setunion and setcut #define SETMINUS 0 #define SETUNION 0 #define SETCUT 0 //Turn on/off output of compute_plane_equation #define COMPUTE_PLANE_EQUATION 0 //Turn on/off output of solve_3x3 #define SOLVE_3X3 0 //Turn on/off output of solve_4x4 #define SOLVE_4X4 0 //Turn on/off output in check_feasibility #define CHECK_FEASIBILITY 0 //Turn on/off compilation and output of gcd computation #define GCD_OUTPUT 0 //Turn on/off output of simplify_solution #define SIMPLIFY_SOLUTION 0 //Turn on/off output in initial_VF_pair #define INITIAL_VF_PAIR 0 //Turn on/off output in check_about_VF-pairs #define CHECK_ABOUT_VF_PAIRS 0 #define VF_PAIR_OUTPUT 0 //Turn on/off output of update_width #define UPDATE_WIDTH 0 //Turn on/off output of EE_computation and EE_pairs #define EE_COMPUTATION 0 #define EE_PAIRS 0 //Turn on/off output in origin_inside_CH #define ORIGIN_INSIDE_CH 0 //Turn on/off output of width_3_convex #define WIDTH_3_CONVEX 0 #define EDGE_INITIALIZING 0 //Turn on/off output of stack go_on #define GO_ON_OUTPUT 0 //Turn infos on/off #define INFO 0 //Turn on/off output of verifications on edges #define VISITED_CHECK 0 #define IMPASSABLE_CHECK 0 #include #define DEBUGENDL(doit,msg,var)\ if(doit!=0) std::cout << msg << " " << var << endl; #define DEBUGPRINT(doit,msg,var)\ if(doit!=0) std::cout << msg << " " << var; #define DEBUGMSG(doit,msg)\ if(doit!=0) std::cout << msg << endl; #define INFOMSG(doit,msg)\ if(doit!=0) std::cerr< #endif //#WIDTH_DEBUG_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_sphere_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_sphere_d.0000644000175000017500000004366111344301500031363 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_sphere_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr // Bernd Gaertner #ifndef CGAL_OPTIMISATION_SPHERE_D_H #define CGAL_OPTIMISATION_SPHERE_D_H CGAL_BEGIN_NAMESPACE // Class declarations // ================== // general template template class Optimisation_sphere_d; template class Optimisation_sphere_d; template class Optimisation_sphere_d; CGAL_END_NAMESPACE // Class interfaces and implementation // ================================== // includes #include #include CGAL_BEGIN_NAMESPACE // Cartesian version // ----------------- template class Optimisation_sphere_d { private: typedef typename Traits::Access_coordinates_begin_d::Coordinate_iterator It; // hack needed for egcs, see also test programs typedef FT FT_; int d; // dimension int m; // |B| int s; // |B\cup S| FT** q; // the q_j's FT*** inv; // the A^{-1}_{B^j}'s FT* v_basis; // the vector v_B FT* x; // solution vector FT* v; // auxiliary vector FT* c; // center, for internal use PT ctr; // center, for external use FT sqr_r; // squared_radius Traits tco; public: Optimisation_sphere_d& get_sphere (Cartesian_tag) {return *this;} const Optimisation_sphere_d& get_sphere (Cartesian_tag) const {return *this;} Optimisation_sphere_d (const Traits& t = Traits()) : d(-1), m(0), s(0), tco (t) {} void set_tco (const Traits& tcobj) { tco = tcobj; } void init (int ambient_dimension) { d = ambient_dimension; m = 0; s = 0; sqr_r = -FT(1); q = new FT*[d+1]; inv = new FT**[d+1]; v_basis = new FT[d+2]; x = new FT[d+2]; v = new FT[d+2]; c = new FT[d]; for (int j=0; j class Optimisation_sphere_d { private: typedef typename Traits::Access_coordinates_begin_d::Coordinate_iterator It; // hack needed for egcs, see also test programs typedef RT RT_; int d; // dimension int m; // |B| int s; // |B\cup S| RT** q; // the q_j's RT*** inv; // the \tilde{A}^{-1}_{B^j}'s RT* denom; // corresponding denominators RT** v_basis; // the \tilde{v}_B^j RT* x; // solution vector mutable RT* v; // auxiliary vector RT* c; // center, for internal use PT ctr; // center, for external use RT sqr_r; // numerator of squared_radius Traits tco; public: Optimisation_sphere_d& get_sphere (Homogeneous_tag t) {return *this;} const Optimisation_sphere_d& get_sphere (Homogeneous_tag t) const {return *this;} Optimisation_sphere_d (const Traits& t = Traits()) : d(-1), m(0), s(0), tco(t) {} void set_tco (const Traits& tcobj) { tco = tcobj; } void init (int ambient_dimension) { d = ambient_dimension; m = 0; s = 0; sqr_r = -RT(1); q = new RT*[d+1]; inv = new RT**[d+1]; denom = new RT[d+1]; v_basis = new RT*[d+1]; x = new RT[d+2]; v = new RT[d+2]; c = new RT[d+1]; for (int j=0; j // Lutz Kettner // Sylvain Pion #ifndef CGAL_UTILITY_H #define CGAL_UTILITY_H 1 #include CGAL_BEGIN_NAMESPACE //+---------------------------------------------------------------------+ //| Triple class | //+---------------------------------------------------------------------+ template struct Triple { typedef T1 first_type; typedef T2 second_type; typedef T3 third_type; T1 first; T2 second; T3 third; Triple() {} Triple(const T1& a, const T2& b, const T3& c) : first(a), second(b), third(c) {} template Triple(const U& a, const V& b, const W& c) : first(a), second(b), third(c) {} template Triple& operator=(const Triple &t) { first = t.first; second = t.second; third = t.third; return *this; } }; template inline Triple make_triple(const T1& x, const T2& y, const T3& z) { return Triple(x, y, z); } template inline bool operator==(const Triple& x, const Triple& y) { return ( (x.first == y.first) && (x.second == y.second) && (x.third == y.third) ); } template inline bool operator<(const Triple& x, const Triple& y) { return ( x.first < y.first || ( !(y.first < x.first) && ( x.second < y.second || ( !(y.second < x.second) && x.third < y.third ) ) ) ); } //+---------------------------------------------------------------------+ //| Quadruple class | //+---------------------------------------------------------------------+ template struct Quadruple { typedef T1 first_type; typedef T2 second_type; typedef T3 third_type; typedef T4 fourth_type; T1 first; T2 second; T3 third; T4 fourth; Quadruple() {} Quadruple(const T1& a, const T2& b, const T3& c, const T4& d) : first(a), second(b), third(c), fourth(d) {} template Quadruple(const U& a, const V& b, const W& c, const X& d) : first(a), second(b), third(c), fourth(d) {} template Quadruple& operator=(const Quadruple &q) { first = q.first; second = q.second; third = q.third; fourth = q.fourth; return *this; } }; template inline Quadruple make_quadruple(const T1& x, const T2& y, const T3& z, const T4& zz) { return Quadruple(x, y, z, zz); } template inline bool operator==(const Quadruple& x, const Quadruple& y) { return ( (x.first == y.first) && (x.second == y.second) && (x.third == y.third) && (x.fourth == y.fourth) ); } template inline bool operator<(const Quadruple& x, const Quadruple& y) { return ( x.first < y.first || ( !(y.first < x.first) && ( x.second < y.second || ( !(y.second < x.second) && ( x.third < y.third || !(y.third < x.third) && x.fourth < y.fourth) ) ) ) ); } CGAL_END_NAMESPACE #endif // CGAL_UTILITY_H // // EOF // ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/halfedgeds_connected_components.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/halfedgeds_connected_c0000644000175000017500000000646511344301500031370 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/halfedgeds_connected_components.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_CONNECTED_COMPONENTS_H #define CGAL_HALFEDGEDS_CONNECTED_COMPONENTS_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template std::size_t halfedgeds_connected_components( HDS hds, Output_iterator result) { Unique_hash_map< Halfedge_iterator, bool> hedge_map( false); std::size_t count = 0; std::vector< Halfedge_handle> hstack; hstack.reserve( hds.size_of_halfedges() + 3/ 4); Halfedge_iterator scan = hds.halfedges_begin(); while ( scan != hds.halfedges_end()) { // first trace the component, then report it hstack.clear(); hstack.push_back( scan); while ( ! hstack.empty()) { Halfedge_handle h = hstack.back(); hstack.pop_back(); if ( ! hedge_map[ h] ) { hedge_map[ h] = true; hstack.push_back( h->next()); hstack.push_back( h->opposite()); } } ++count; *result++ = scan; while( hedge_map[ scan]) ++scan; } return count; } template std::size_t halfedgeds_connected_components( HDS& hds, Output_iterator result) { typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Halfedge_handle Halfedge_handle; return halfedgeds_connected_components( hds, result); } template std::size_t halfedgeds_connected_components( const HDS& hds, Output_iterator result) { typedef typename HDS::Halfedge_const_iterator Halfedge_iterator; typedef typename HDS::Halfedge_const_handle Halfedge_handle; return halfedgeds_connected_components( hds, result); } template std::size_t halfedgeds_connected_components( HDS& hds) { return halfedgeds_connected_components( hds, Emptyset_iterator()); } CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_CONNECTED_COMPONENTS_H // // EOF // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Segment_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Segment_2_inte0000644000175000017500000000566611344301500031214 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Segment_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POINT_2_SEGMENT_2_INTERSECTION_H #define CGAL_POINT_2_SEGMENT_2_INTERSECTION_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Segment_2 &seg, const K&) { return seg.has_on(pt); } template inline bool do_intersect(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Point_2 &pt, const K&) { return seg.has_on(pt); } template inline Object intersection(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Segment_2 &seg, const K&) { if (do_intersect(pt,seg)) { return make_object(pt); } return Object(); } template inline Object intersection( const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Point_2 &pt, const K&) { if (do_intersect(pt,seg)) { return make_object(pt); } return Object(); } } // namespace CGALi template inline bool do_intersect(const Segment_2 &seg, const Point_2 &pt) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, seg); } template inline bool do_intersect(const Point_2 &pt, const Segment_2 &seg) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, seg); } template inline Object intersection(const Segment_2 &seg, const Point_2 &pt) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, seg); } template inline Object intersection(const Point_2 &pt, const Segment_2 &seg) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, seg); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trivial_iterator.h0000644000175000017500000001113611344301501030517 0ustar debiandebian// Copyright (c) 2002 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Trivial_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_TRIVIAL_ITERATOR_H #define CGAL_TRIVIAL_ITERATOR_H #include #include CGAL_BEGIN_NAMESPACE // TODO : // - comparison operators should be global, but it causes problems... // - Have a look at Boost's concept_checking and archetypes : // http://www.boost.org/libs/concept_check/concept_check.htm class Trivial_iterator_tag{}; template class Trivial_iterator { public: typedef I Iterator; typedef Trivial_iterator Self; typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::difference_type difference_type; typedef typename std::iterator_traits::reference reference; typedef typename std::iterator_traits::pointer pointer; typedef Trivial_iterator_tag iterator_category; // Special for circulators. typedef I_Circulator_size_traits C_S_Traits; typedef typename C_S_Traits::size_type size_type; Trivial_iterator() {} Trivial_iterator(const I &i) : base_(i) {} // To allow conversion from iterator to const_iterator. template Trivial_iterator(const Trivial_iterator &t) : base_(t.base()) {} reference operator*() const { return *base_; } pointer operator->() const { return &*base_; } bool operator==(const Trivial_iterator &b) const { return base()==b.base(); } bool operator!=(const Trivial_iterator &b) const { return base()!=b.base(); } private: const Iterator & base() const { return base_; } Iterator base_; }; class Trivial_comparable_iterator_tag{}; template class Trivial_comparable_iterator { public: typedef I Iterator; typedef Trivial_comparable_iterator Self; typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::difference_type difference_type; typedef typename std::iterator_traits::reference reference; typedef typename std::iterator_traits::pointer pointer; typedef Trivial_comparable_iterator_tag iterator_category; // Special for circulators. typedef I_Circulator_size_traits C_S_Traits; typedef typename C_S_Traits::size_type size_type; Trivial_comparable_iterator() {} Trivial_comparable_iterator(const I &i) : base_(i) {} // To allow conversion from iterator to const_iterator. template Trivial_comparable_iterator(const Trivial_comparable_iterator &t) : base_(t.base()) {} reference operator*() const { return *base_; } pointer operator->() const { return &*base_; } bool operator==(const Trivial_comparable_iterator &b) const { return base()==b.base(); } bool operator!=(const Trivial_comparable_iterator &b) const { return base()!=b.base(); } bool operator< (const Trivial_comparable_iterator &b) const { return base()< b.base(); } bool operator> (const Trivial_comparable_iterator &b) const { return base()> b.base(); } bool operator<=(const Trivial_comparable_iterator &b) const { return base()<=b.base(); } bool operator>=(const Trivial_comparable_iterator &b) const { return base()>=b.base(); } private: const Iterator & base() const { return base_; } Iterator base_; }; // Some macros depending on CGAL_NO_CONCEPT_CHECKING. #ifndef CGAL_NO_CONCEPT_CHECKING # define CGAL_TRIVIAL_ITERATOR_CHECKER(X) CGAL::Trivial_iterator # define CGAL_TRIVIAL_COMPARABLE_ITERATOR_CHECKER(X) \ CGAL::Trivial_comparable_iterator #else # define CGAL_TRIVIAL_ITERATOR_CHECKER(X) X # define CGAL_TRIVIAL_COMPARABLE_ITERATOR_CHECKER(X) X #endif CGAL_END_NAMESPACE #endif // CGAL_TRIVIAL_ITERATOR_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_is_valid_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_is_valid_tra0000644000175000017500000000271711344301500031443 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_is_valid_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_2_IS_VALID_TRAITS_H #define CGAL_PARTITION_2_IS_VALID_TRAITS_H namespace CGAL { template class Partition_is_valid_traits_2 : public Traits { public: typedef typename Traits::Point_2 Point_2; typedef typename Traits::Polygon_2 Polygon_2; typedef typename Traits::Less_xy_2 Less_xy_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Orientation_2 Orientation_2; typedef PolygonIsValid Is_valid; Is_valid is_valid_object(const Traits& traits) const { return Is_valid(traits); } }; } #endif // CGAL_PARTITION_2_IS_VALID_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_3.h0000644000175000017500000000505611344301500026512 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_POINT_3_H #define CGAL_POINT_3_H #include CGAL_BEGIN_NAMESPACE template class Point_3 : public R_::Kernel_base::Point_3 { typedef typename R_::RT RT; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Kernel_base::Point_3 RPoint_3; public: typedef R_ R; Point_3() {} Point_3(const Origin& o) : RPoint_3(o) {} #if 1 Point_3(const RPoint_3& p) : RPoint_3(p) {} #endif Point_3(const RT& x, const RT& y, const RT& z) : RPoint_3(x, y, z) {} Point_3(const RT& hx, const RT& hy, const RT& hz, const RT& hw) : RPoint_3(hx, hy, hz, hw) {} }; template inline bool operator==(const Origin& o, const Point_3& p) { return p == o; } template inline bool operator!=(const Origin& o, const Point_3& p) { return p != o; } #if 0 //ndef CGAL_NO_OSTREAM_INSERT_POINT_3 template < class R > std::ostream& operator<<(std::ostream& os, const Point_3& p) { typedef typename R::Kernel_base::Point_3 RPoint_3; return os << static_cast(p); } #endif // CGAL_NO_OSTREAM_INSERT_POINT_3 #if 0 //ndef CGAL_NO_ISTREAM_EXTRACT_POINT_3 template < class R > std::istream& operator>>(std::istream& is, Point_3& p) { typedef typename R::Kernel_base::Point_3 RPoint_3; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_POINT_3 CGAL_END_NAMESPACE #endif // CGAL_POINT_3_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_cell_base_with_info_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_cell_bas0000644000175000017500000000437711344301501031423 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_cell_base_with_info_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion // cell of a triangulation of any dimension <=3 #ifndef CGAL_TRIANGULATION_CELL_BASE_WITH_INFO_3_H #define CGAL_TRIANGULATION_CELL_BASE_WITH_INFO_3_H #include CGAL_BEGIN_NAMESPACE template < typename Info_, typename GT, typename Cb = Triangulation_cell_base_3 > class Triangulation_cell_base_with_info_3 : public Cb { Info_ _info; public: typedef typename Cb::Vertex_handle Vertex_handle; typedef typename Cb::Cell_handle Cell_handle; typedef Info_ Info; template < typename TDS2 > struct Rebind_TDS { typedef typename Cb::template Rebind_TDS::Other Cb2; typedef Triangulation_cell_base_with_info_3 Other; }; Triangulation_cell_base_with_info_3() : Cb() {} Triangulation_cell_base_with_info_3(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) : Cb(v0, v1, v2, v3) {} Triangulation_cell_base_with_info_3(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Cell_handle n0, Cell_handle n1, Cell_handle n2, Cell_handle n3) : Cb(v0, v1, v2, v3, n0, n1, n2, n3) {} const Info& info() const { return _info; } Info& info() { return _info; } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_CELL_BASE_WITH_INFO_3_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_sweep_demo_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulat0000644000175000017500000001205211344301500031446 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_sweep_demo_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_CONSTRAINED_TRIANGULATION_SWEEP_DEMO_H #define CGAL_CONSTRAINED_TRIANGULATION_SWEEP_DEMO_H // #include #include #include CGAL_BEGIN_NAMESPACE template < class Gt, class Tds> class Constrained_triangulation_sweep_demo_2 : public Constrained_triangulation_sweep_2 { public: typedef typename Gt::Segment Segment; typedef Window_stream Window_stream; typedef Constrained_triangulation_sweep_2 Sweep; typedef typename Sweep::Out_edges Out_edges; typedef typename Sweep::Event_queue Event_queue; typedef typename Sweep::Sweep_status Sweep_status; Constrained_triangulation_sweep_demo_2() {} Constrained_triangulation_sweep_demo_2(Window_stream& W, std::list& lc, const Gt& t=Gt()) : Constrained_triangulation_sweep_2() { _t = t ; _lc = &lc; event_less= Event_less(); queue = Event_queue(event_less); status_comp = Status_comp(); status= Sweep_status(status_comp); upper_chain=Chain(); make_event_queue(); demo_build_triangulation(W); } private: void demo_build_triangulation(Window_stream& W); void draw_face(Face_handle f, Window_stream& W) { for(int i =0; i<3; i++){ W << Segment((f->vertex(i))->point(), (f->vertex(f->cw(i)))->point()); } return; } void draw_new_faces(Vertex_handle v, Window_stream& W) { drawing_mode dm=W.set_mode(leda_src_mode); W << BLUE; Face_handle f = v->face(); if (f == Face_handle() ) { return;} //first point, no face draw_face(f,W); while( f->neighbor(1) != Face_handle() ) { f = f->neighbor(1); draw_face(f,W); } } void draw_chain(Chain * pc,Window_stream& W) { Neighbor_list::iterator nit; Face_handle f; int i; nit = (pc->down_list())->begin(); while (nit != (pc-> down_list())->end()) { f = (*nit).first; i = (*nit).second; W << Segment(f->vertex(f->cw(i))->point(), f->vertex(f->ccw(i))->point()); nit++; } nit = (pc->up_list())->begin(); while (nit != (pc->up_list())->end()) { f = (*nit).first; i = (*nit).second; W << Segment(f->vertex(f->cw(i))->point(), f->vertex(f->ccw(i))->point()); nit++; } return; } void draw_status_chains(Window_stream& W) { drawing_mode dm=W.set_mode(leda_src_mode); W << GREEN; Chain * pc; typename Sweep_status::iterator status_it=status.begin(); while ( status_it != status.end()) { pc = (Chain *) ((*status_it).second); draw_chain(pc,W); status_it ++; } pc = & upper_chain; draw_chain(pc,W); return; } void draw_constraints(Window_stream& W) { drawing_mode dm=W.set_mode(leda_src_mode); W << RED; std::list::iterator cit=_lc->begin(); while(cit != _lc->end()){ W << Segment((*cit).first,(*cit).second); cit++; } return; } void draw_next_event(Window_stream& W) { return; } void any_button(Window_stream& W) { double x, y; cerr << "Press any button to continue" << std::endl; W.read_mouse(x,y); } }; template void Constrained_triangulation_sweep_demo_2:: demo_build_triangulation(Window_stream& W) { Point p; Vertex_handle v; Out_edges * out; typename Event_queue::iterator event; int count =0; while (! queue.empty()) { count++; event = queue.begin(); // locate (p,p) dans status p = (*event).first; out = (*event).second; typename Sweep_status::iterator loc=status.lower_bound(Constraint(p,p)); // deal with the contraints finishing at p v = treat_in_edges(event,loc); // insert constraint beginning at p treat_out_edges(event,loc); draw_new_faces(v,W); draw_constraints(W); draw_status_chains(W); draw_next_event(W); any_button(W); // delete event from event_queue out= (*event).second; CGAL_triangulation_assertion( (*out).empty()); delete out; queue.erase(event); //delete la liste out } // make inifinite vertex, infinite faces // at this stage status is empty // and the lists of upper_chain correspond to the convex hull CGAL_triangulation_assertion( status.empty()); the_vertex = set_infinite_faces(); return; } CGAL_END_NAMESPACE #endif //CONSTRAINED_TRIANGULATION_SWEEP_DEMO_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Euclidean_distance.h0000644000175000017500000000633511344301500030743 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Euclidean_distance.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_EUCLIDEAN_DISTANCE_H #define CGAL_EUCLIDEAN_DISTANCE_H #include namespace CGAL { template class Euclidean_distance { public: typedef typename SearchTraits::FT FT; typedef typename SearchTraits::Point_d Point_d; typedef Point_d Query_item; public: // default constructor Euclidean_distance() {} inline FT transformed_distance(const Query_item& q, const Point_d& p) const { FT distance = FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d qit = construct_it(q), qe = construct_it(q,1), pit = construct_it(p); for(; qit != qe; qit++, pit++){ distance += ((*qit)-(*pit))*((*qit)-(*pit)); } return distance; } inline FT min_distance_to_rectangle(const Query_item& q, const Kd_tree_rectangle& r) const { FT distance = FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d qit = construct_it(q), qe = construct_it(q,1); for(unsigned int i = 0;qit != qe; i++, qit++){ if((*qit) < r.min_coord(i)) distance += (r.min_coord(i)-(*qit))*(r.min_coord(i)-(*qit)); else if ((*qit) > r.max_coord(i)) distance += ((*qit)-r.max_coord(i))*((*qit)-r.max_coord(i)); } return distance; } inline FT max_distance_to_rectangle(const Query_item& q, const Kd_tree_rectangle& r) const { FT distance=FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d qit = construct_it(q), qe = construct_it(q,1); for(unsigned int i = 0;qit != qe; i++, qit++){ if ((*qit) <= (r.min_coord(i)+r.max_coord(i))/FT(2.0)) distance += (r.max_coord(i)-(*qit))*(r.max_coord(i)-(*qit)); else distance += ((*qit)-r.min_coord(i))*((*qit)-r.min_coord(i)); }; return distance; } inline FT new_distance(FT dist, FT old_off, FT new_off, int cutting_dimension) const { FT new_dist = dist + new_off*new_off - old_off*old_off; return new_dist; } inline FT transformed_distance(FT d) const { return d*d; } inline FT inverse_of_transformed_distance(FT d) const { return CGAL::sqrt(d); } }; // class Euclidean_distance } // namespace CGAL #endif // EUCLIDEAN_DISTANCE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/0000755000175000017500000000000012146213701030647 5ustar debiandebian././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box_traits_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box0000644000175000017500000001350311344301501031317 0ustar debiandebian// Copyright (c) 2004 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box_traits_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Andreas Meyer #ifndef CGAL_BOX_INTERSECTION_D_BOX_TRAITS_D_H #define CGAL_BOX_INTERSECTION_D_BOX_TRAITS_D_H #include #include CGAL_BEGIN_NAMESPACE namespace Box_intersection_d { enum Setting { COMPLETE, BIPARTITE }; enum Topology { HALF_OPEN, CLOSED }; template struct Box_traits_d { typedef const BoxHandle& Box_parameter; typedef typename BoxHandle::NT NT; typedef typename BoxHandle::ID ID; static NT min_coord(Box_parameter b, int dim) { return b.min_coord( dim);} static NT max_coord(Box_parameter b, int dim) { return b.max_coord( dim);} static ID id(Box_parameter b) { return b.id();} static int dimension() { return BoxHandle::dimension();} }; // box pointer traits template struct Box_traits_d { typedef const Box_* Box_parameter; typedef typename Box_::NT NT; typedef typename Box_::ID ID; static NT min_coord(Box_parameter b, int dim) { return b->min_coord(dim);} static NT max_coord(Box_parameter b, int dim) { return b->max_coord(dim);} static ID id(Box_parameter b) { return b->id();} static int dimension() { return Box_::dimension();} }; // box pointer traits template struct Box_traits_d { typedef const Box_* Box_parameter; typedef typename Box_::NT NT; typedef typename Box_::ID ID; static NT min_coord(Box_parameter b, int dim) { return b->min_coord(dim);} static NT max_coord(Box_parameter b, int dim) { return b->max_coord(dim);} static ID id(Box_parameter b) { return b->id();} static int dimension() { return Box_::dimension();} }; template< class BoxTraits, bool closed > struct Predicate_traits_d : public BoxTraits { typedef typename BoxTraits::Box_parameter Box_parameter; typedef typename BoxTraits::NT NT; template struct Bool_t {}; static bool hi_greater(NT hi, NT val, Bool_t b) { return hi >= val;} static bool hi_greater(NT hi, NT val, Bool_t b){ return hi > val;} static bool hi_greater (NT hi, NT val) { return hi_greater(hi,val, Bool_t()); } // compare dim a b = islolesslo a b dim class Compare : public std::binary_function { int dim; public: Compare(int dim) : dim(dim) {} bool operator()(Box_parameter a, Box_parameter b) const { return is_lo_less_lo(a,b,dim); } }; // loless val dim box = getlo box dim < val class Lo_less : public std::unary_function { NT value; int dim; public: Lo_less(NT value, int dim) : value(value), dim(dim) {} bool operator() (Box_parameter box) const { return BoxTraits::min_coord(box, dim) < value; } }; class Hi_greater : public std::unary_function { NT value; int dim; public: Hi_greater(NT value, int dim) : value(value), dim(dim) {} bool operator() (Box_parameter box) const { return hi_greater( BoxTraits::max_coord(box, dim), value); } }; // spanning lo hi dim box = getlo box dim < lo && gethi box dim > hi class Spanning : public std::unary_function { NT lo, hi; int dim; public: Spanning(NT lo, NT hi, int dim) : lo(lo), hi(hi), dim(dim) {} // returns true <=> box spans [lo,hi) in dimension dim bool operator() (Box_parameter box) const { return BoxTraits::min_coord(box,dim) < lo && BoxTraits::max_coord(box,dim) > hi; } }; static Compare compare_object(int dim) { return Compare(dim); } static Lo_less lo_less_object(NT value, int dim) { return Lo_less(value, dim); } static Hi_greater hi_greater_object(NT value, int dim) { return Hi_greater( value, dim ); } static Spanning spanning_object(NT lo, NT hi, int dim) { return Spanning( lo, hi, dim ); } static bool is_lo_less_lo(Box_parameter a, Box_parameter b, int dim) { return BoxTraits::min_coord(a,dim) < BoxTraits::min_coord(b,dim) || BoxTraits::min_coord(a,dim) == BoxTraits::min_coord(b,dim) && BoxTraits::id(a) < BoxTraits::id(b); } static bool is_lo_less_hi(Box_parameter a, Box_parameter b, int dim) { return hi_greater( BoxTraits::max_coord(b,dim), BoxTraits::min_coord(a,dim)); } static bool does_intersect (Box_parameter a, Box_parameter b, int dim) { return is_lo_less_hi(a,b,dim) && is_lo_less_hi(b,a,dim); } static bool contains_lo_point(Box_parameter a, Box_parameter b, int dim) { return is_lo_less_lo(a,b,dim) && is_lo_less_hi(b,a,dim); } }; } // end namespace Box_intersection_d CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/box_limits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/box0000644000175000017500000000363311344301501031362 0ustar debiandebian// Copyright (c) 2004 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/box_limits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Andreas Meyer #ifndef CGAL_BOX_INTERSECTION_D_BOX_LIMITS_H #define CGAL_BOX_INTERSECTION_D_BOX_LIMITS_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace Box_intersection_d { template struct box_limits {}; template<> struct box_limits { static int inf() { return INT_MIN; } static int sup() { return INT_MAX; } }; template<> struct box_limits { static unsigned int inf() { return 0; } static unsigned int sup() { return UINT_MAX; } }; template<> struct box_limits { static float inf() { return -sup(); } static float sup() { const UInteger32 i = 0x7f800000; return *reinterpret_cast(&i); } }; template<> struct box_limits { static double inf() { return -sup(); } static float sup() { const UInteger64 i = 0x7FF0000000000000ull; return *reinterpret_cast(&i); } }; } // end namespace Box_intersection_d CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/segment_tree.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/seg0000644000175000017500000003353011344301501031347 0ustar debiandebian// Copyright (c) 2004 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/segment_tree.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Andreas Meyer #ifndef CGAL_BOX_INTERSECTION_D_SEGMENT_TREE_H #define CGAL_BOX_INTERSECTION_D_SEGMENT_TREE_H #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace Box_intersection_d { #define BOX_INTERSECTION_DEBUG 0 template< class ForwardIter1, class ForwardIter2, class Callback, class Traits > void all_pairs( ForwardIter1 p_begin, ForwardIter1 p_end, ForwardIter2 i_begin, ForwardIter2 i_end, Callback callback, Traits traits, bool complete_case = false) { const int last_dim = Traits::dimension() - 1; for( ForwardIter1 p = p_begin; p != p_end; ++p ) { for( ForwardIter2 i = i_begin; i != i_end; ++i ) { if ((complete_case && Traits::id(*p) >= Traits::id(*i)) || Traits::id(*p) == Traits::id(*i)) continue; for( int dim = 0; dim <= last_dim; ++dim ) if( !Traits::does_intersect( *p, *i, dim ) ) goto no_intersection1; callback( *p, *i ); no_intersection1: ; } } } template< class ForwardIter, class Callback, class Traits > void all_pairs( ForwardIter p_begin, ForwardIter p_end, Callback callback, Traits traits) { const int last_dim = Traits::dimension() - 1; // loops actually only up to p_end-1, but we stay with the forward iterator // requirement and have one unnecessary but harmless additional iteration for( ForwardIter p = p_begin; p != p_end; ++p ) { ForwardIter i = p; ++i; for( ; i != p_end; ++i ) { for( int dim = 0; dim <= last_dim; ++dim ) if( !Traits::does_intersect( *p, *i, dim ) ) goto no_intersection1; callback( *p, *i ); no_intersection1: ; } } } template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class Traits > void one_way_scan( RandomAccessIter1 p_begin, RandomAccessIter1 p_end, RandomAccessIter2 i_begin, RandomAccessIter2 i_end, Callback callback, Traits traits, int last_dim, bool in_order = true ) { typedef typename Traits::Compare Compare; std::sort( p_begin, p_end, Compare( 0 ) ); std::sort( i_begin, i_end, Compare( 0 ) ); // for each box viewed as interval i for( RandomAccessIter2 i = i_begin; i != i_end; ++i ) { // look for the first box b with i.min <= p.min for( ; p_begin != p_end && Traits::is_lo_less_lo( *p_begin, *i, 0 ); ++p_begin ); // look for all boxes with p.min < i.max for( RandomAccessIter1 p = p_begin; p != p_end && Traits::is_lo_less_hi( *p, *i, 0 ); ++p ) { if( Traits::id( *p ) == Traits::id( *i ) ) continue; for( int dim = 1; dim <= last_dim; ++dim ) if( !Traits::does_intersect( *p, *i, dim ) ) goto no_intersection; if( in_order ) callback( *p, *i ); else callback( *i, *p ); no_intersection: ; } } } template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class Traits > void modified_two_way_scan( RandomAccessIter1 p_begin, RandomAccessIter1 p_end, RandomAccessIter2 i_begin, RandomAccessIter2 i_end, Callback callback, Traits traits, int last_dim, bool in_order = true ) { typedef typename Traits::Compare Compare; std::sort( p_begin, p_end, Compare( 0 ) ); std::sort( i_begin, i_end, Compare( 0 ) ); // for each box viewed as interval while( i_begin != i_end && p_begin != p_end ) { if( Traits::is_lo_less_lo( *i_begin, *p_begin, 0 ) ) { for( RandomAccessIter1 p = p_begin; p != p_end && Traits::is_lo_less_hi( *p, *i_begin, 0 ); ++p ) { if( Traits::id( *p ) == Traits::id( *i_begin ) ) continue; for( int dim = 1; dim <= last_dim; ++dim ) if( !Traits::does_intersect( *p, *i_begin, dim ) ) goto no_intersection1; if( Traits::contains_lo_point( *i_begin, *p, last_dim ) ) { if( in_order ) callback( *p, *i_begin ); else callback( *i_begin, *p ); } no_intersection1: ; } ++i_begin; } else { for( RandomAccessIter2 i = i_begin; i != i_end && Traits::is_lo_less_hi( *i, *p_begin, 0 ); ++i ) { if( Traits::id( *p_begin ) == Traits::id( *i ) ) continue; for( int dim = 1; dim <= last_dim; ++dim ) if( !Traits::does_intersect( *p_begin, *i, dim ) ) goto no_intersection2; if( Traits::contains_lo_point( *i, *p_begin, last_dim ) ) { if( in_order ) callback( *p_begin, *i ); else callback( *i, *p_begin ); } no_intersection2: ; } ++p_begin; } } } template< class RandomAccessIter, class Predicate_traits > RandomAccessIter median_of_three( RandomAccessIter a, RandomAccessIter b, RandomAccessIter c, Predicate_traits traits, int dim ) { if( Predicate_traits::is_lo_less_lo( *a, *b, dim ) ) if( Predicate_traits::is_lo_less_lo( *b, *c, dim ) ) return b; else if( Predicate_traits::is_lo_less_lo( *a, *c, dim ) ) return c; else return a; else if( Predicate_traits::is_lo_less_lo( *a, *c, dim ) ) return a; else if( Predicate_traits::is_lo_less_lo( *b, *c, dim ) ) return c; else return b; } template< class RandomAccessIter, class Predicate_traits > RandomAccessIter iterative_radon( RandomAccessIter begin, RandomAccessIter end, Predicate_traits traits, int dim, int num_levels ) { if( num_levels < 0 ) { const unsigned int rnd = CGAL::default_random.get_int( 0, INT_MAX ); return begin + rnd % std::distance( begin, end ); } return median_of_three( iterative_radon( begin, end, traits, dim, num_levels - 1 ), iterative_radon( begin, end, traits, dim, num_levels - 1 ), iterative_radon( begin, end, traits, dim, num_levels - 1 ), traits, dim ); } // returns iterator for first element in [begin,end) which does not satisfy // the Split_Points_Predicate: [begin,mid) contains only points strictly less // than mi. so, elements from [mid,end) are equal or higher than mi. template< class RandomAccessIter, class Predicate_traits, class T > RandomAccessIter split_points( RandomAccessIter begin, RandomAccessIter end, Predicate_traits traits, int dim, T& mi ) { // magic formula int levels = (int)(.91*log(((double)std::distance(begin,end))/137.0)+1); levels = (levels <= 0) ? 1 : levels; RandomAccessIter it = iterative_radon( begin, end, traits, dim, levels ); mi = Predicate_traits::min_coord( *it, dim ); return std::partition( begin, end, typename Predicate_traits::Lo_less( mi, dim ) ); } #if BOX_INTERSECTION_DEBUG static int level = -1; #define CGAL_BOX_INTERSECTION_DUMP(msg) { \ for( unsigned int i = level; i; --i ) \ std::cout << " "; \ std::cout << msg; \ } #else #define CGAL_BOX_INTERSECTION_DUMP(msg) ; #endif template< class ForwardIter, class Traits > void dump_points( ForwardIter begin, ForwardIter end, Traits traits, int dim ) { while( begin != end ) { std::cout << Traits::min_coord( *begin, dim ) << " "; ++begin; } std::cout << std::endl; } template< class ForwardIter, class Traits > void dump_intervals( ForwardIter begin, ForwardIter end, Traits traits, int dim ) { while( begin != end ) { std::cout << "[" << Traits::min_coord( *begin, dim ) << "," << Traits::max_coord( *begin, dim ) << ") "; ++begin; } std::cout << std::endl; } template< class ForwardIter, class Traits > void dump_box_numbers( ForwardIter begin, ForwardIter end, Traits traits ) { while( begin != end ) { std::cout << Traits::id( *begin ) << " "; ++begin; } std::cout << std::endl; } template< class T > struct Counter { T& value; Counter( T& value ) : value( value ) { ++value; } ~Counter() { --value; } }; template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class T, class Predicate_traits > void segment_tree( RandomAccessIter1 p_begin, RandomAccessIter1 p_end, RandomAccessIter2 i_begin, RandomAccessIter2 i_end, T lo, T hi, Callback callback, Predicate_traits traits, std::ptrdiff_t cutoff, int dim, bool in_order ) { typedef typename Predicate_traits::Spanning Spanning; typedef typename Predicate_traits::Lo_less Lo_less; typedef typename Predicate_traits::Hi_greater Hi_greater; const T inf = box_limits< T >::inf(); const T sup = box_limits< T >::sup(); #if BOX_INTERSECTION_DEBUG Counter bla( level ); CGAL_BOX_INTERSECTION_DUMP("range: [" << lo << "," << hi << ") dim " << dim << std::endl ) CGAL_BOX_INTERSECTION_DUMP("intervals: " ) //dump_box_numbers( i_begin, i_end, traits ); dump_intervals( i_begin, i_end, traits, dim ); CGAL_BOX_INTERSECTION_DUMP("points: " ) //dump_box_numbers( p_begin, p_end, traits ); dump_points( p_begin, p_end, traits, dim ); #endif #if SEGMENT_TREE_CHECK_INVARIANTS { // first: each point is inside segment [lo,hi) for( RandomAccessIter1 it = p_begin; it != p_end; ++it ) { assert( Lo_less( hi, dim )(*it) ); assert( Lo_less( lo, dim )(*it) == false ); } // second: each interval intersects segment [lo,hi) for( RandomAccessIter2 it = i_begin; it != i_end; ++it ) assert( Hi_greater( lo, dim )(*it) && Lo_less( hi, dim )(*it) ); } #endif if( p_begin == p_end || i_begin == i_end || lo >= hi ) return; if( dim == 0 ) { CGAL_BOX_INTERSECTION_DUMP( "dim = 0. scanning ... " << std::endl ) one_way_scan( p_begin, p_end, i_begin, i_end, callback, traits, dim, in_order ); return; } if( std::distance( p_begin, p_end ) < cutoff || std::distance( i_begin, i_end ) < cutoff ) { CGAL_BOX_INTERSECTION_DUMP( "scanning ... " << std::endl ) modified_two_way_scan( p_begin, p_end, i_begin, i_end, callback, traits, dim, in_order ); return; } RandomAccessIter2 i_span_end = lo == inf || hi == sup ? i_begin : std::partition( i_begin, i_end, Spanning( lo, hi, dim ) ); if( i_begin != i_span_end ) { CGAL_BOX_INTERSECTION_DUMP( "checking spanning intervals ... " << std::endl ) // make two calls for roots of segment tree at next level. segment_tree( p_begin, p_end, i_begin, i_span_end, inf, sup, callback, traits, cutoff, dim - 1, in_order ); segment_tree( i_begin, i_span_end, p_begin, p_end, inf, sup, callback, traits, cutoff, dim - 1, !in_order ); } T mi; RandomAccessIter1 p_mid = split_points( p_begin, p_end, traits, dim, mi ); if( p_mid == p_begin || p_mid == p_end ) { CGAL_BOX_INTERSECTION_DUMP( "unable to split points! ") //dump_points( p_begin, p_end, traits, dim ); CGAL_BOX_INTERSECTION_DUMP( "performing modified two_way_san ... " << std::endl ) modified_two_way_scan( p_begin, p_end, i_span_end, i_end, callback, traits, dim, in_order ); return; } RandomAccessIter2 i_mid; // separate left intervals. // left intervals have a low point strictly less than mi i_mid = std::partition( i_span_end, i_end, Lo_less( mi, dim ) ); CGAL_BOX_INTERSECTION_DUMP("->left" << std::endl ) segment_tree( p_begin, p_mid, i_span_end, i_mid, lo, mi, callback, traits, cutoff, dim, in_order ); // separate right intervals. // right intervals have a high point strictly higher than mi i_mid = std::partition( i_span_end, i_end, Hi_greater( mi, dim ) ); CGAL_BOX_INTERSECTION_DUMP("->right"<< std::endl ) segment_tree( p_mid, p_end, i_span_end, i_mid, mi, hi, callback, traits, cutoff, dim, in_order ); } #undef BOX_INTERSECTION_DEBUG } // end namespace Box_intersection_d CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box0000644000175000017500000001451311344301501031321 0ustar debiandebian// Copyright (c) 2004 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Andreas Meyer #ifndef CGAL_BOX_INTERSECTION_D_BOX_D_H #define CGAL_BOX_INTERSECTION_D_BOX_D_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace Box_intersection_d { // Pseudo template class to skip the need for a C file for the static counter template struct Unique_numbers { typedef std::size_t ID; Unique_numbers() : i(n++) {} std::size_t id() const { return i; } private: static std::size_t n; std::size_t i; }; template std::size_t Unique_numbers::n = 0; // Policies for id-number of boxes struct ID_NONE {}; struct ID_EXPLICIT {}; struct ID_FROM_BOX_ADDRESS {}; struct ID_FROM_HANDLE {}; // Generic template signature of boxes, specialized for policies template class Box_d; // ID_NONE is used as base class and cannot be used directly in the algorithms template class Box_d< NT_, N, ID_NONE> { protected: NT_ lo[N]; NT_ hi[N]; public: typedef NT_ NT; typedef std::size_t ID; Box_d() {} Box_d(bool complete) { init(complete); } Box_d(NT l[N], NT h[N]) { std::copy( l, l + N, lo ); std::copy( h, h + N, hi ); } void init (bool complete = false) { NT inf = box_limits::inf(); NT sup = box_limits::sup(); if(!complete) std::swap(inf,sup); std::fill( lo, lo+N, inf ); std::fill( hi, hi+N, sup ); } void extend(NT p[N]) { for( int dim = 0; dim < N; ++dim ) { lo[dim] = std::min( lo[dim], p[dim] ); hi[dim] = std::max( hi[dim], p[dim] ); } } static int dimension() { return N; } NT min_coord(int dim) const { return lo[dim]; } NT max_coord(int dim) const { return hi[dim]; } }; // Specialization for Bbox_2, i.e. double and dim 2. template<> class Box_d< double, 2, ID_NONE> { protected: Bbox_2 bbx; public: typedef double NT; typedef std::size_t ID; Box_d() {} Box_d(bool complete) { init(complete); } Box_d(NT l[2], NT h[2]) : bbx(l[0], l[1], h[0], h[1]) {} Box_d( const Bbox_2& b) : bbx( b) {} const Bbox_2& bbox() const { return bbx; } void init () { NT inf = box_limits::inf(); NT sup = box_limits::sup(); bbx = Bbox_2( sup, sup, inf, inf); } void init (bool complete) { NT inf = box_limits::inf(); NT sup = box_limits::sup(); if ( complete) bbx = Bbox_2( inf, inf, sup, sup); else bbx = Bbox_2( sup, sup, inf, inf); } void extend(NT p[2]) { bbx = Bbox_2( std::min( bbx.xmin(), p[0]), std::min( bbx.ymin(), p[1]), std::max( bbx.xmax(), p[0]), std::max( bbx.ymax(), p[1])); } static int dimension() { return 2; } NT min_coord(int dim) const { return (dim==0) ? bbx.xmin() : bbx.ymin();} NT max_coord(int dim) const { return (dim==0) ? bbx.xmax() : bbx.ymax();} }; // Specialization for Bbox_3, i.e. double and dim 3. template<> class Box_d< double, 3, ID_NONE> { protected: Bbox_3 bbx; public: typedef double NT; typedef std::size_t ID; Box_d() {} Box_d(bool complete) { init(complete); } Box_d(NT l[3], NT h[3]) : bbx(l[0], l[1], l[2], h[0], h[1], h[2]) {} Box_d( const Bbox_3& b) : bbx( b) {} const Bbox_3& bbox() const { return bbx; } void init () { NT inf = box_limits::inf(); NT sup = box_limits::sup(); bbx = Bbox_3( sup, sup, sup, inf, inf, inf); } void init (bool complete) { NT inf = box_limits::inf(); NT sup = box_limits::sup(); if ( complete) bbx = Bbox_3( inf, inf, inf, sup, sup, sup); else bbx = Bbox_3( sup, sup, sup, inf, inf, inf); } void extend(NT p[3]) { bbx = Bbox_3( std::min( bbx.xmin(), p[0]), std::min( bbx.ymin(), p[1]), std::min( bbx.zmin(), p[2]), std::max( bbx.xmax(), p[0]), std::max( bbx.ymax(), p[1]), std::max( bbx.zmax(), p[2])); } static int dimension() { return 3; } NT min_coord(int dim) const { return (dim==0) ? bbx.xmin() : ((dim==1) ? bbx.ymin() : bbx.zmin()); } NT max_coord(int dim) const { return (dim==0) ? bbx.xmax() : ((dim==1) ? bbx.ymax() : bbx.zmax()); } }; // ID_EXPLICIT template class Box_d< NT_, N, ID_EXPLICIT> : public Box_d< NT_, N, ID_NONE>, public Unique_numbers { public: typedef Box_d< NT_, N, ID_NONE> Base; typedef NT_ NT; typedef typename Unique_numbers::ID ID; Box_d() {} Box_d(bool complete) : Base(complete) {} Box_d(NT l[N], NT h[N]) : Base( l, h) {} Box_d( const Bbox_2& b) : Base( b) {} Box_d( const Bbox_3& b) : Base( b) {} }; // ID_FROM_BOX_ADDRESS template class Box_d< NT_, N, ID_FROM_BOX_ADDRESS> : public Box_d< NT_, N, ID_NONE> { public: typedef Box_d< NT_, N, ID_NONE> Base; typedef NT_ NT; typedef std::size_t ID; Box_d() {} Box_d(bool complete) : Base(complete) {} Box_d(NT l[N], NT h[N]) : Base( l, h) {} Box_d( const Bbox_2& b) : Base( b) {} Box_d( const Bbox_3& b) : Base( b) {} ID id() const { return reinterpret_cast(this); } }; } // end namespace Box_intersection_d CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box_with_handle_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box0000644000175000017500000000550311344301501031320 0ustar debiandebian// Copyright (c) 2004 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Box_intersection_d/Box_with_handle_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Andreas Meyer #ifndef CGAL_BOX_INTERSECTION_D_BOX_WITH_HANDLE_D_H #define CGAL_BOX_INTERSECTION_D_BOX_WITH_HANDLE_D_H #include #include CGAL_BEGIN_NAMESPACE namespace Box_intersection_d { // Generic template signature of boxes, specialized for ID_FROM_HANDLE policy template class Box_with_handle_d : public Box_d< NT_, N, IdPolicy> { protected: Handle_ m_handle; public: typedef Box_d< NT_, N, IdPolicy> Base; typedef NT_ NT; typedef Handle_ Handle; Box_with_handle_d() {} Box_with_handle_d( Handle h) : m_handle(h) {} Box_with_handle_d( bool complete, Handle h): Base(complete), m_handle(h) {} Box_with_handle_d(NT l[N], NT h[N], Handle n) : Base( l, h), m_handle(n) {} Box_with_handle_d( const Bbox_2& b, Handle h) : Base( b), m_handle(h) {} Box_with_handle_d( const Bbox_3& b, Handle h) : Base( b), m_handle(h) {} Handle handle() const { return m_handle; } }; // Specialization for ID_FROM_HANDLE policy template class Box_with_handle_d : public Box_d< NT_, N, ID_NONE> { protected: Handle_ m_handle; public: typedef Box_d< NT_, N, ID_NONE> Base; typedef NT_ NT; typedef Handle_ Handle; typedef std::size_t ID; Box_with_handle_d() {} Box_with_handle_d( Handle h) : m_handle(h) {} Box_with_handle_d( bool complete, Handle h): Base(complete), m_handle(h) {} Box_with_handle_d(NT l[N], NT h[N], Handle n) : Base( l, h), m_handle(n) {} Box_with_handle_d( const Bbox_2& b, Handle h) : Base( b), m_handle(h) {} Box_with_handle_d( const Bbox_3& b, Handle h) : Base( b), m_handle(h) {} Handle handle() const { return m_handle; } ID id() const { return reinterpret_cast( &* m_handle); } }; } // end namespace Box_intersection_d CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/normal_vector_newell_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/normal_vector_newell_30000644000175000017500000000635611344301500031417 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/normal_vector_newell_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_NORMAL_VECTOR_NEWELL_3_H #define CGAL_NORMAL_VECTOR_NEWELL_3_H 1 #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 79 #include CGAL_BEGIN_NAMESPACE template CGAL_MEDIUM_INLINE void newell_single_step_3( Handle p, Handle q, Vector& n ) { n = Vector( n.hx() * p->hw() * p->hw() * q->hw() * q->hw() + n.hw() * ( p->hy() * q->hw() - q->hy() * p->hw()) * ( p->hz() * q->hw() + q->hz() * p->hw()), n.hy() * p->hw() * p->hw() * q->hw() * q->hw() + n.hw() * ( p->hz() * q->hw() - q->hz() * p->hw()) * ( p->hx() * q->hw() + q->hx() * p->hw()), n.hz() * p->hw() * p->hw() * q->hw() * q->hw() + n.hw() * ( p->hx() * q->hw() - q->hx() * p->hw()) * ( p->hy() * q->hw() + q->hy() * p->hw()), n.hw() * p->hw() * p->hw() * q->hw() * q->hw() ); } template void normal_vector_newell_3( IC first, IC last, Vector& n ) // compute a facet normal n via the Newell-method for the facet // surrounded by the points in the range [`h', `last'), where `IC' // denotes either an iterator or a circulator with a point type as // value type. The Newell-method computes for non-planar facets the // best least-square-fit normal of the plane equation. Precondition: // The numbertype for the points and the vector n must be compatible // with `double'. The points and the vector n must have dimension // three. { CGAL_assertion( !CGAL::is_empty_range( first, last)); // Compute facet normals via the Newell-method as described in // Filippo Tampieri: Newell's Method for Computing the Plane // Equation of a Polygon. Graphics Gems III, David Kirk, // AP Professional, 1992. // The code works with cartesian and with semi-rational points. n = Vector( 0, 0, 0); // init current normal to 0 IC start_point = first; IC prev = first; ++first; while( first != last) { newell_single_step_3( prev, first, n); prev = first; ++first; } newell_single_step_3( prev, start_point, n); CGAL_NEF_TRACEN("newell normal vector "< #include #include CGAL_BEGIN_NAMESPACE template class Convex_hull_traits_2 : public K_ { public: typedef K_ K; typedef typename K::Point_2 Point_2; typedef typename K::Less_xy_2 Less_xy_2; typedef typename K::Less_yx_2 Less_yx_2; typedef typename K::Less_signed_distance_to_line_2 Less_signed_distance_to_line_2; typedef typename K::Less_rotate_ccw_2 Less_rotate_ccw_2; typedef typename K::Left_turn_2 Left_turn_2; typedef typename K::Equal_2 Equal_2; typedef typename K::Segment_2 Segment_2; Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Less_signed_distance_to_line_2 less_signed_distance_to_line_2_object( ) const { return Less_signed_distance_to_line_2( ); } Less_rotate_ccw_2 less_rotate_ccw_2_object() const { return Less_rotate_ccw_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Equal_2 equal_2_object() const { return Equal_2(); } }; template class convex_hull_traits_2 : public Convex_hull_traits_2 { }; CGAL_END_NAMESPACE #endif // CGAL_CONVEX_HULL_TRAITS_2_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Segment_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Segment_2_inter0000644000175000017500000000223511344301500031161 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Segment_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/random_selection.h0000644000175000017500000000523211344301500030520 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/random_selection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_RANDOM_SELECTION_H #define CGAL_RANDOM_SELECTION_H 1 #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif #ifndef CGAL_PROTECT_ITERATOR #include #define CGAL_PROTECT_ITERATOR #endif #ifndef CGAL_RANDOM_H #include #endif CGAL_BEGIN_NAMESPACE template OutputIterator random_selection( RandomAccessIterator first, RandomAccessIterator last, Size n, OutputIterator result, Random& rnd) // choose a random item from the range [`first',`last') and write it // to `first2', each item from the range with equal probability. // Repeat this n times, thus writing n items to `first2'. A single // random number is needed from `rnd' for each item. Returns the // value of `first2' after inserting the n items. { int m = int(last - first); for ( Size i = 0; i < n; i++) { *result++ = first[ rnd(m)]; } return result; } template OutputIterator random_selection( RandomAccessIterator first, RandomAccessIterator last, Size n, OutputIterator result) { return random_selection( first, last, n, result, default_random); } CGAL_END_NAMESPACE #endif // CGAL_RANDOM_SELECTION_H // // EOF // ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Point_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Point_2_intersec0000644000175000017500000000222711344301500031210 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Point_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_traits.h0000644000175000017500000000245011344301500030000 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_TRAITS_H #define CGAL_KERNEL_TRAITS_H CGAL_BEGIN_NAMESPACE template struct Kernel_traits { typedef typename T::R Kernel; }; CGAL_END_NAMESPACE #endif // CGAL_KERNEL_TRAITS_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_debug_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_debug_trai0000644000175000017500000003346611344301500031412 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_debug_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Eran Leiserowitz // Efi Fogel #ifndef CGAL_ARR_SEGMENT_DEBUG_EXACT_TRAITS_H #define CGAL_ARR_SEGMENT_DEBUG_EXACT_TRAITS_H #include #include #include CGAL_BEGIN_NAMESPACE template class My_arr_segment_traits_2 : public Pm_segment_traits_2 { public: class My_curve_2{ public: typedef typename Kernel_::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment; Segment seg; My_curve_2() {} My_curve_2(Segment s): seg(s) {} My_curve_2(Point_2 p1, Point_2 p2): seg(p1,p2) {} }; public: typedef Kernel_ Kernel; typedef int Info_face; typedef int Info_edge; typedef int Info_vertex; typedef Pm_segment_traits_2 Base; typedef typename Base::Has_left_category Has_left_category; typedef typename Base::Has_reflect_category Has_reflect_category; typedef typename Base::Point_2 Point_2; typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; typedef My_curve_2 Curve_2; // Obsolete, for backward compatibility typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; protected: typedef typename Kernel::Construct_vertex_2 Construct_vertex_2; typedef typename Kernel::Construct_segment_2 Construct_segment_2; typedef typename Kernel::Compare_x_2 Compare_x_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Compare_xy_2 Compare_xy_2; typedef typename Kernel::Compare_y_at_x_2 Compare_y_at_x_2; typedef typename Kernel::Is_vertical_2 Is_vertical_2; typedef typename Kernel::Equal_2 Equal_2; typedef typename Kernel::Orientation_2 Orientation_2; public: My_arr_segment_traits_2() : Base() { } /*! is_x_monotone() * \return true if the given curve is an x-monotone curve. False, otherwise. * For segments, this is always true */ // bool is_x_monotone(const Curve_2 &) {return true;} /*! curve_make_x_monotone() cuts the given curve into x-monotone subcurves * and inserts them to the given output iterator. The order in which they * are inserted defines their order in the hierarchy tree. * While segments are x_monotone, still need to pass them out. * \param cv the input curve * \param o the output iterator * \return the past-the-end iterator */ template OutputIterator curve_make_x_monotone(const Curve_2 & cv, OutputIterator o) const { *o++ = cv.seg; return o; } /*! curve_opposite() flips a given curve * \param cv the curve * \return a segment with source and target point interchanged */ X_monotone_curve_2 curve_opposite(const X_monotone_curve_2 & cv) const { return construct_opposite_segment_2_object()(cv.seg); } /*! curve_split() splits a given curve at a given split point into two * sub-curves. * \param cv the curve to split * \param c1 the output first part of the split curve.Its source is the * source of the original curve. * \param c2 the output second part of the split curve. Its target is the * target of the original curve * \param split_pt * \pre split_pt is on cv but is not an endpoint. */ void curve_split(const X_monotone_curve_2 & cv, X_monotone_curve_2 & c1, X_monotone_curve_2 & c2, const Point_2 & split_pt) const { //split curve at split point (x coordinate) into c1 and c2 CGAL_precondition(curve_compare_y_at_x(split_pt, cv) == EQUAL); CGAL_precondition_code(Equal_2 is_equal = equal_2_object()); CGAL_precondition(!is_equal(curve_source(cv), split_pt)); CGAL_precondition(!is_equal(curve_target(cv), split_pt)); Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & source = construct_vertex(cv.seg, 0); const Point_2 & target = construct_vertex(cv.seg, 1); Construct_segment_2 construct_segment = construct_segment_2_object(); c1 = construct_segment(source, split_pt); c2 = construct_segment(split_pt, target); } /*! nearest_intersection_to_right() finds the nearest intersection point of * two given curves to the right of a given point. Nearest is defined as the * lexicographically nearest not including the point itself with one * exception explained bellow.. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, then if the the source and target of the * subcurve are strickly to the right, they are returned through two * other point references p1 and p2. If pt is between the source and target * of the overlapping subcurve, or pt is its left endpoint, pt and the target * of the right endpoint of the subcurve are returned through p1 and p2 * respectively. * If the intersection of the two curves is a point to the right of pt, pt * is returned through the p1 and p2. * \param c1 the first curve * \param c2 the second curve * \param pt the point to compare against * \param p1 the first point reference * \param p2 the second point reference * \return true if c1 and c2 do intersect to the right of pt. Otherwise, * false */ bool nearest_intersection_to_right(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt, Point_2 & p1, Point_2 & p2) const { Object res = intersect_2_object()(c1.seg, c2.seg); // Empty object is returned - no intersection. if (res.is_empty()) return (false); // Intersection is a point Point_2 ip; if (assign(p1,res)) { // the intersection is a point: if (compare_xy_2_object()(p1, pt) == LARGER) { p2 = p1; return true; } return false; } // Intersection is a segment X_monotone_curve_2 seg; if (assign(seg.seg, res)) { // the intersection is a curve: Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & src = construct_vertex(seg.seg, 0); const Point_2 & trg = construct_vertex(seg.seg, 1); Compare_xy_2 compare_xy = compare_xy_2_object(); Comparison_result src_pt = compare_xy(src, pt); Comparison_result trg_pt = compare_xy(trg, pt); if (src_pt == LARGER && trg_pt == LARGER) { // the subcurve is completely to the right: p1 = src; p2 = trg; return true; } if (trg_pt != LARGER && src_pt == LARGER) { // target is to the left, source is to the right: p1 = pt; p2 = src; return true; } if (src_pt != LARGER && trg_pt == LARGER) { // source is to the left, target is to the right: p1 = pt; p2 = trg; return true; } // the subcurve is completely to the left: return false; } // the curves do not intersect: return false; } /*! nearest_intersection_to_left() finds the nearest intersection point of * two given curves to the left of a given point. Nearest is defined as the * lexicographically nearest not including the point itself with one * exception explained bellow.. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, then if the the source and target of the * subcurve are strickly to the left, they are returned through two * other point references p1 and p2. If pt is between the source and target * of the overlapping subcurve, or pt is its left endpoint, pt and the target * of the left endpoint of the subcurve are returned through p1 and p2 * respectively. * If the intersection of the two curves is a point to the left of pt, pt * is returned through the p1 and p2. * \param c1 the first curve * \param c2 the second curve * \param pt the point to compare against * \param p1 the first point reference * \param p2 the second point reference * \return true if c1 and c2 do intersect to the left of pt. Otherwise, * false */ bool nearest_intersection_to_left(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt, Point_2 & p1, Point_2 & p2) const { Object res = intersect_2_object()(c1.seg, c2.seg); // Empty object is returned - no intersection. if (res.is_empty()) return (false); // Intersection is a point if (assign(p1,res)) { // the intersection is a point: if (compare_xy_2_object()(p1, pt) == SMALLER) { p2 = p1; return true; } return false; } // Intersection is a segment bool same_curve=false; X_monotone_curve_2 seg; if (assign(seg.seg, res)) { if(same_curve) seg=c1.seg; // the intersection is a curve: Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & src = construct_vertex(seg.seg, 0); const Point_2 & trg = construct_vertex(seg.seg, 1); Compare_xy_2 compare_xy = compare_xy_2_object(); Comparison_result src_pt = compare_xy(src, pt); Comparison_result trg_pt = compare_xy(trg, pt); if (src_pt == SMALLER && trg_pt == SMALLER) { // the subcurve is completely to the left: p1 = src; p2 = trg; return true; } if (trg_pt != SMALLER && src_pt == SMALLER) { // target is to the right, source is to the left: p1 = pt; p2 = src; return true; } if (src_pt != SMALLER && trg_pt == SMALLER) { // source is to the right, target is to the left: p1 = pt; p2 = trg; return true; } // the subcurve is completely to the right: return false; } // the curves do not intersect: return false; } /*! curves_overlap() test overlapping between two given curves * \patam c1 the first curve * \patam c2 the second curve * \return true if c1 and c2 overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, false. */ bool curves_overlap(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & src2 = construct_vertex(cv2.seg, 0); const Point_2 & trg2 = construct_vertex(cv2.seg, 1); const Point_2 & src1 = construct_vertex(cv1.seg, 0); const Point_2 & trg1 = construct_vertex(cv1.seg, 1); Orientation_2 orient = orientation_2_object(); if ((!orient(src1, trg1, src2) == COLLINEAR) || (!orient(src1, trg1, trg2) == COLLINEAR)) return false; Is_vertical_2 is_vertical = is_vertical_2_object(); if (is_vertical(cv1.seg)) { if (is_vertical(cv2.seg)) { Compare_y_2 compare_y = compare_y_2_object(); Comparison_result res_ss = compare_y (src1, src2); Comparison_result res_st = compare_y (src1, trg2); if (res_ss == SMALLER) { if (res_st == LARGER) return true; if (compare_y (trg1, src2) == LARGER) return true; return (compare_y (trg1, trg2) == LARGER); } if (res_ss == LARGER) { if (res_st == SMALLER) return true; if (compare_y (trg1, src2) == SMALLER) return true; return (compare_y (trg1, trg2) == SMALLER); } // res_ss == EQUAL if (res_st == SMALLER) return (compare_y (trg1, src2) == LARGER); return (compare_y (trg1, src2) == SMALLER); } return false; } if (is_vertical(cv2.seg)) return false; Compare_x_2 compare_x = compare_x_2_object(); Comparison_result res_ss = compare_x (src1, src2); Comparison_result res_st = compare_x (src1, trg2); if (res_ss == SMALLER) { if (res_st == LARGER) return true; if (compare_x (trg1, src2) == LARGER) return true; return (compare_x (trg1, trg2) == LARGER); } if (res_ss == LARGER) { if (res_st == SMALLER) return true; if (compare_x (trg1, src2) == SMALLER) return true; return (compare_x (trg1, trg2) == SMALLER); } // res_ss == EQUAL if (res_st == SMALLER) return (compare_x (trg1, src2) == LARGER); return (compare_x (trg1, src2) == SMALLER); } Point_2 curve_source(const Curve_2 & cv) const { return construct_vertex_2_object()(cv.seg, 0); } Point_2 curve_target(const Curve_2 & cv) const { return construct_vertex_2_object()(cv.seg, 1); } Point_2 curve_source(const X_monotone_curve_2 & cv) const { return construct_vertex_2_object()(cv.seg, 0); } Point_2 curve_target(const X_monotone_curve_2 & cv) const { return construct_vertex_2_object()(cv.seg, 1); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000013056411344301501031401 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_2_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include /* Conventions: ------------ 1. we treat segments as open; the endpoints are separate objects 2. a segment of length zero is treated as a point 3. a point is deleted only if it has no segment adjacent to it 4. when a segment is deleted it's endpoints are not deleted 5. the user can force the deletion of endpoints; this is only done if condition 3 is met. 6. when objects are written to a stream we distinguish between points and segments; points start by a 'p' and segments by an 's'. */ CGAL_BEGIN_NAMESPACE namespace CGALi { template struct SVD_which_list; // use the in-place edge list template struct SVD_which_list { typedef E Edge; typedef In_place_edge_list List; }; // do not use the in-place edge list template struct SVD_which_list { typedef E Edge; // change the following to Tag_false in order to use // CGAL's Unique_hash_map typedef Tag_true Use_stl_map_tag; typedef Edge_list List; }; template < class Node > struct Svd_project_site_2 { typedef Node argument_type; typedef typename Node::Site_2 Site; typedef Site result_type; Site& operator()(const Node& x) const { static Site s; s = x.site(); return s; } // const Site& operator()(const Node& x) const { return x.site(); } }; template < class Node, class Site_t > struct Svd_project_input_to_site_2 { typedef Node argument_type; typedef Site_t Site; typedef Site result_type; Site& operator()(const Node& x) const { static Site s; if ( boost::tuples::get<2>(x) /*x.third*/ ) { // it is a point // s = Site::construct_site_2(*x.first); s = Site::construct_site_2( *boost::tuples::get<0>(x) ); } else { // s = Site::construct_site_2(*x.first, *x.second); s = Site::construct_site_2 (*boost::tuples::get<0>(x), *boost::tuples::get<1>(x)); } return s; } }; } // namespace CGALi template class Segment_Voronoi_diagram_hierarchy_2; template, Triangulation_face_base_2 >, class LTag = Tag_false > class Segment_Voronoi_diagram_2 : private Triangulation_2< Segment_Voronoi_diagram_traits_wrapper_2, DS > { friend class Segment_Voronoi_diagram_hierarchy_2; friend class Segment_Voronoi_diagram_hierarchy_2; protected: // LOCAL TYPES //------------ typedef Segment_Voronoi_diagram_2 Self; typedef Segment_Voronoi_diagram_traits_wrapper_2 Modified_traits; typedef Triangulation_2 DG; typedef DG Delaunay_graph; typedef typename DG::Vertex Vertex; typedef typename DG::Face Face; typedef LTag List_tag; public: // PUBLIC TYPES //------------- typedef DS Data_structure; typedef Gt Geom_traits; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typedef typename DS::Edge Edge; typedef typename DS::Vertex_handle Vertex_handle; typedef typename DS::Face_handle Face_handle; typedef typename DS::Vertex_circulator Vertex_circulator; typedef typename DS::Edge_circulator Edge_circulator; typedef typename DS::Face_circulator Face_circulator; typedef typename DS::Face_iterator All_faces_iterator; typedef typename DS::Vertex_iterator All_vertices_iterator; typedef typename DS::Edge_iterator All_edges_iterator; typedef typename DG::Finite_faces_iterator Finite_faces_iterator; typedef typename DG::Finite_vertices_iterator Finite_vertices_iterator; typedef typename DG::Finite_edges_iterator Finite_edges_iterator; protected: typedef typename Geom_traits::Arrangement_type_2 AT2; typedef typename AT2::Arrangement_type Arrangement_type; typedef std::set PC; typedef typename PC::iterator PH; // these containers should have point handles and should replace the // point container... typedef boost::tuples::tuple Site_rep_2; // typedef Triple Site_rep_2; typedef std::list Input_sites_container; typedef typename Input_sites_container::const_iterator All_inputs_iterator; typedef CGALi::Svd_project_input_to_site_2 Proj_input_to_site; public: typedef Simple_container_wrapper Point_container; typedef typename Point_container::iterator Point_handle; typedef typename DS::size_type size_type; protected: typedef CGALi::Svd_project_site_2 Proj_site; struct Point_handle_less_than { // less than bool operator()(const Point_handle& x, const Point_handle& y) const { return &(*x) < &(*y); } }; typedef std::pair Point_handle_pair; typedef std::map Handle_map; public: typedef Iterator_project Input_sites_iterator; typedef Iterator_project Output_sites_iterator; protected: // LOCAL VARIABLE(S) //------------------ // the container of points Point_container pc_; Input_sites_container isc_; protected: // MORE LOCAL TYPES //----------------- typedef typename Gt::Intersections_tag Intersections_tag; typedef std::map Face_map; typedef std::vector Edge_vector; typedef std::list Vertex_list; typedef typename Vertex_list::iterator Vertex_list_iterator; typedef Triple Vertex_triple; typedef std::pair Face_pair; typedef typename Data_structure::Vertex::Storage_site_2 Storage_site_2; // the edge list typedef typename CGALi::SVD_which_list::List List; public: // CREATION //--------- Segment_Voronoi_diagram_2(const Gt& gt=Gt()) : DG(gt) {} template< class Input_iterator > Segment_Voronoi_diagram_2(Input_iterator first, Input_iterator beyond, const Gt& gt=Gt()) : DG(gt) { insert(first, beyond); } Segment_Voronoi_diagram_2(const Self& other); Self& operator=(const Self& other); public: // ACCESS METHODS // -------------- const Geom_traits& geom_traits() const { return DG::geom_traits(); } const Data_structure& data_structure() const { return this->_tds; } const Point_container& point_container() const { return pc_; } inline size_type number_of_input_sites() const { return isc_.size(); } inline size_type number_of_output_sites() const { return number_of_vertices(); } inline size_type number_of_vertices() const { return DG::number_of_vertices(); } inline size_type number_of_faces() const { return DG::number_of_faces(); } inline Vertex_handle infinite_vertex() const { return DG::infinite_vertex(); } inline Face_handle infinite_face() const { return DG::infinite_face(); } inline Vertex_handle finite_vertex() const { return DG::finite_vertex(); } inline int dimension() const { return DG::dimension(); } using Delaunay_graph::cw; using Delaunay_graph::ccw; public: // TRAVERSAL OF THE DUAL GRAPH //---------------------------- inline Finite_faces_iterator finite_faces_begin() const { return DG::finite_faces_begin(); } inline Finite_faces_iterator finite_faces_end() const { return DG::finite_faces_end(); } inline Finite_vertices_iterator finite_vertices_begin() const { return DG::finite_vertices_begin(); } inline Finite_vertices_iterator finite_vertices_end() const { return DG::finite_vertices_end(); } inline Finite_edges_iterator finite_edges_begin() const { return DG::finite_edges_begin(); } inline Finite_edges_iterator finite_edges_end() const { return DG::finite_edges_end(); } inline All_faces_iterator all_faces_begin() const { return DG::all_faces_begin(); } inline All_faces_iterator all_faces_end() const { return DG::all_faces_end(); } inline All_vertices_iterator all_vertices_begin() const { return DG::all_vertices_begin(); } inline All_vertices_iterator all_vertices_end() const { return DG::all_vertices_end(); } inline All_edges_iterator all_edges_begin() const { return DG::all_edges_begin(); } inline All_edges_iterator all_edges_end() const { return DG::all_edges_end(); } inline Input_sites_iterator input_sites_begin() const { return Input_sites_iterator(isc_.begin()); } inline Input_sites_iterator input_sites_end() const { return Input_sites_iterator(isc_.end()); } inline Output_sites_iterator output_sites_begin() const { return Output_sites_iterator(finite_vertices_begin()); } inline Output_sites_iterator output_sites_end() const { return Output_sites_iterator(finite_vertices_end()); } public: // CIRCULATORS //------------ inline Face_circulator incident_faces(Vertex_handle v, Face_handle f = Face_handle()) const { return DG::incident_faces(v, f); } inline Vertex_circulator incident_vertices(Vertex_handle v, Face_handle f = Face_handle()) const { return DG::incident_vertices(v, f); } inline Edge_circulator incident_edges(Vertex_handle v, Face_handle f = Face_handle()) const { return DG::incident_edges(v, f); } public: // PREDICATES //----------- inline bool is_infinite(const Vertex_handle& v) const { return DG::is_infinite(v); } inline bool is_infinite(const Face_handle& f) const { return DG::is_infinite(f); } inline bool is_infinite(const Face_handle& f, int i) const { return DG::is_infinite(f, i); } inline bool is_infinite(const Edge& e) const { return is_infinite(e.first, e.second); } inline bool is_infinite(const Edge_circulator& ec) const { return DG::is_infinite(ec); } public: // INSERTION METHODS //------------------ template inline size_type insert(Input_iterator first, Input_iterator beyond) { return insert(first, beyond, Tag_false()); } template size_type insert(Input_iterator first, Input_iterator beyond, Tag_true) { std::vector site_vec; for (Input_iterator it = first; it != beyond; ++it) { site_vec.push_back(Site_2(*it)); } std::random_shuffle(site_vec.begin(), site_vec.end()); return insert(site_vec.begin(), site_vec.end(), Tag_false()); } template size_type insert(Input_iterator first, Input_iterator beyond, Tag_false) { // do it the obvious way: insert them as they come; // one might think though that it might be better to first insert // all end points and then all segments, or a variation of that. size_type n_before = number_of_vertices(); for (Input_iterator it = first; it != beyond; ++it) { insert(*it); } size_type n_after = number_of_vertices(); return n_after - n_before; } // insert a point inline Vertex_handle insert(const Point_2& p) { // update input site container Point_handle ph = register_input_site(p); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(ph); return insert_point(ss, p, Vertex_handle()); } inline Vertex_handle insert(const Point_2& p, Vertex_handle vnear) { // update input site container Point_handle ph = register_input_site(p); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(ph); return insert_point(ss, p, vnear); } protected: // insert a point without registering it in the input sites // container: useful for the hierarchy inline Vertex_handle insert_no_register(const Storage_site_2& ss, const Point_2& p, Vertex_handle vnear) { return insert_point(ss, p, vnear); } public: // insert a segment inline Vertex_handle insert(const Point_2& p0, const Point_2& p1) { // update input site container Point_handle_pair php = register_input_site(p0, p1); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(php.first, php.second); return insert_segment(ss, Site_2::construct_site_2(p0, p1), Vertex_handle()); } inline Vertex_handle insert(const Point_2& p0, const Point_2& p1, Vertex_handle vnear) { // update input site container Point_handle_pair php = register_input_site(p0, p1); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(php.first, php.second); return insert_segment(ss, Site_2::construct_site_2(p0, p1), vnear); } inline Vertex_handle insert(const Site_2& t) { return insert(t, Vertex_handle()); } Vertex_handle insert(const Site_2& t, Vertex_handle vnear) { // the intended use is to unify the calls to insert(...); // thus the site must be an exact one; CGAL_precondition( t.is_input() ); // update input site container if ( t.is_segment() ) { Point_handle_pair php = register_input_site( t.source_of_supporting_site(), t.target_of_supporting_site() ); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(php.first, php.second); return insert_segment(ss, t, vnear); } else if ( t.is_point() ) { Point_handle ph = register_input_site( t.point() ); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(ph); return insert_point(ss, t.point(), vnear); } else { CGAL_precondition ( t.is_defined() ); return Vertex_handle(); // to avoid compiler error } } protected: inline Point_handle register_input_site(const Point_2& p) { std::pair it = pc_.insert(p); Site_rep_2 rep(it.first, it.first, true); // isc_.insert( rep ); isc_.push_back( rep ); // isc_.insert( Site_rep_2(it.first, it.first, true) ); return it.first; } inline Point_handle_pair register_input_site(const Point_2& p0, const Point_2& p1) { std::pair it1 = pc_.insert(p0); std::pair it2 = pc_.insert(p1); Site_rep_2 rep(it1.first, it2.first, false); // isc_.insert( rep ); isc_.push_back( rep ); return Point_handle_pair(it1.first, it2.first); } Vertex_handle insert_first(const Storage_site_2& ss, const Point_2& p); Vertex_handle insert_second(const Storage_site_2& ss, const Point_2& p); Vertex_handle insert_third(const Storage_site_2& ss, const Point_2& p); Vertex_handle insert_third(const Site_2& t, const Storage_site_2& ss); Vertex_handle insert_third(const Storage_site_2& ss, Vertex_handle v0, Vertex_handle v1); Vertex_handle insert_point(const Storage_site_2& ss, const Point_2& p, Vertex_handle vnear); Vertex_handle insert_point(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnear); Vertex_handle insert_point2(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnear); Triple insert_point_on_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, const Tag_true&); Triple insert_exact_point_on_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle v); Vertex_handle insert_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle vnear); Vertex_handle insert_segment_interior(const Site_2& t, const Storage_site_2& ss, Vertex_handle vnear); template inline Vertex_handle insert_intersecting_segment(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, ITag tag) { return insert_intersecting_segment_with_tag(ss, t, v, tag); } Vertex_handle insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, Tag_false); Vertex_handle insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, Tag_true); public: // NEAREST NEIGHBOR LOCATION //-------------------------- inline Vertex_handle nearest_neighbor(const Point_2& p) const { return nearest_neighbor(Site_2::construct_site_2(p), Vertex_handle()); } inline Vertex_handle nearest_neighbor(const Point_2& p, Vertex_handle vnear) const { return nearest_neighbor(Site_2::construct_site_2(p), vnear); } protected: Vertex_handle nearest_neighbor(const Site_2& p, Vertex_handle vnear) const; public: // I/O METHODS //------------ template< class Stream > Stream& draw_dual(Stream& str) const { Finite_edges_iterator eit = finite_edges_begin(); for (; eit != finite_edges_end(); ++eit) { draw_dual_edge(*eit, str); } return str; } template < class Stream > Stream& draw_skeleton(Stream& str) const { Finite_edges_iterator eit = finite_edges_begin(); for (; eit != finite_edges_end(); ++eit) { Site_2 p = eit->first->vertex( cw(eit->second) )->site(); Site_2 q = eit->first->vertex( ccw(eit->second) )->site(); bool is_endpoint_of_seg = ( p.is_segment() && q.is_point() && is_endpoint_of_segment(q, p) ) || ( p.is_point() && q.is_segment() && is_endpoint_of_segment(p, q) ); if ( !is_endpoint_of_seg ) { draw_dual_edge(*eit, str); } } return str; } // MK: this has to be rewritten. all the checking must be done in // the geometric traits class. template< class Stream > Stream& draw_dual_edge(Edge e, Stream& str) const { CGAL_precondition( !is_infinite(e) ); typename Geom_traits::Line_2 l; typename Geom_traits::Segment_2 s; typename Geom_traits::Ray_2 r; CGAL::Parabola_segment_2 ps; Object o = primal(e); if (CGAL::assign(l, o)) str << l; if (CGAL::assign(s, o)) str << s; if (CGAL::assign(r, o)) str << r; if (CGAL::assign(ps, o)) ps.draw(str); return str; } template< class Stream > inline Stream& draw_dual_edge(Edge_circulator ec, Stream& str) const { return draw_dual_edge(*ec, str); } template< class Stream > inline Stream& draw_dual_edge(Finite_edges_iterator eit, Stream& str) const { return draw_dual_edge(*eit, str); } public: // VALIDITY CHECK //--------------- bool is_valid(bool verbose = false, int level = 1) const; public: // MISCELLANEOUS //-------------- void clear() { DG::clear(); pc_.clear(); isc_.clear(); } void swap(Segment_Voronoi_diagram_2& svd) { DG::swap(svd); pc_.swap(svd.pc_); isc_.swap(svd.isc_); } ////////////////////////////////////////////////////////////////////// // THE METHODS BELOW ARE LOCAL ////////////////////////////////////////////////////////////////////// protected: // THE COPY METHOD //------------------------------------------------------------------ // used in the copy constructor and assignment operator Storage_site_2 copy_storage_site(const Storage_site_2& ss_other, Handle_map& hm, const Tag_false&); Storage_site_2 copy_storage_site(const Storage_site_2& ss_other, Handle_map& hm, const Tag_true&); void copy(Segment_Voronoi_diagram_2& other); void copy(Segment_Voronoi_diagram_2& other, Handle_map& hm); protected: // HELPER METHODS FOR COMBINATORIAL OPERATIONS ON THE DATA STRUCTURE //------------------------------------------------------------------ // getting the symmetric edge inline Edge sym_edge(const Edge e) const { return sym_edge(e.first, e.second); } inline Edge sym_edge(const Face_handle& f, int i) const { Face_handle f_sym = f->neighbor(i); return Edge( f_sym, f_sym->index( f->mirror_vertex(i) ) ); } Edge flip(Face_handle& f, int i) { CGAL_precondition ( f != Face_handle() ); CGAL_precondition (i == 0 || i == 1 || i == 2); CGAL_precondition( this->dimension()==2 ); CGAL_precondition( f->vertex(i) != f->mirror_vertex(i) ); this->_tds.flip(f, i); return Edge(f, ccw(i)); } inline Edge flip(Edge e) { return flip(e.first, e.second); } inline bool is_degree_2(const Vertex_handle& v) const { Face_circulator fc = v->incident_faces(); Face_circulator fc1 = fc; ++(++fc1); return ( fc == fc1 ); } inline Vertex_handle insert_degree_2(Edge e) { return this->_tds.insert_degree_2(e.first,e.second); } inline Vertex_handle insert_degree_2(Edge e, const Storage_site_2& ss) { Vertex_handle v = insert_degree_2(e); v->set_site(ss); return v; } inline void remove_degree_2(Vertex_handle v) { CGAL_precondition( is_degree_2(v) ); this->_tds.remove_degree_2(v); } inline Vertex_handle create_vertex(const Storage_site_2& ss) { Vertex_handle v = this->_tds.create_vertex(); v->set_site(ss); return v; } inline Vertex_handle create_vertex_dim_up(const Storage_site_2& ss) { Vertex_handle v = this->_tds.insert_dim_up(infinite_vertex()); v->set_site(ss); return v; } protected: // HELPER METHODS FOR CREATING STORAGE SITES //------------------------------------------ #if 0 inline Storage_site_2 create_storage_site(const Point_2& p) { Point_handle ph = pc_.insert(p).first; return Storage_site_2::construct_storage_site_2(ph); } inline Storage_site_2 create_storage_site(Vertex_handle v0, Vertex_handle v1) { return Storage_site_2::construct_storage_site_2 ( v0->storage_site().point(), v1->storage_site().point() ); } #endif inline Storage_site_2 split_storage_site(const Storage_site_2& ss0, const Storage_site_2& ss1, unsigned int i, const Tag_false&) { // Split the first storage site which is a segment using the // second storage site which is a exact point // i denotes whether the first or second half is to be created CGAL_precondition( ss0.is_segment() && ss1.is_point() ); CGAL_precondition( ss1.is_input() ); CGAL_precondition( i < 2 ); if ( i == 0 ) { return Storage_site_2::construct_storage_site_2 (ss0.source_of_supporting_site(), ss1.point()); } else { return Storage_site_2::construct_storage_site_2 (ss1.point(), ss0.target_of_supporting_site()); } } Storage_site_2 split_storage_site(const Storage_site_2& ss0, const Storage_site_2& ss1, unsigned int i, const Tag_true&) { // Split the first storage site which is a segment using the // second storage site which is a exact point // i denotes whether the first or second half is to be created CGAL_precondition( ss0.is_segment() && ss1.is_point() ); // CGAL_precondition( ss1.is_input() ); CGAL_precondition( i < 2 ); if ( i == 0 ) { if ( ss0.is_input(0) ) { if ( ss1.is_input() ) { return Storage_site_2::construct_storage_site_2 (ss0.source_of_supporting_site(), ss1.point()); } else { Storage_site_2 supp0 = ss0.supporting_site(); Storage_site_2 supp1 = ss1.supporting_site(0); if ( are_parallel(supp0.site(), supp1.site()) ) { supp1 = ss1.supporting_site(1); } return Storage_site_2::construct_storage_site_2 ( supp0.source_of_supporting_site(), supp0.target_of_supporting_site(), supp1.source_of_supporting_site(), supp1.target_of_supporting_site(), true ); } } else { if ( ss1.is_input() ) { return Storage_site_2::construct_storage_site_2 ( ss0.source_of_supporting_site(), ss1.point(), ss0.source_of_crossing_site(0), ss0.target_of_crossing_site(0), false ); } else { Storage_site_2 supp0 = ss0.supporting_site(); Storage_site_2 supp1 = ss1.supporting_site(0); if ( are_parallel(supp0.site(), supp1.site()) ) { supp1 = ss1.supporting_site(1); } return Storage_site_2::construct_storage_site_2 ( supp0.source_of_supporting_site(), supp0.target_of_supporting_site(), ss0.source_of_crossing_site(0), ss0.target_of_crossing_site(0), supp1.source_of_supporting_site(), supp1.target_of_supporting_site() ); } } } else { // i == 1 if ( ss0.is_input(1) ) { if ( ss1.is_input() ) { return Storage_site_2::construct_storage_site_2 ( ss1.point(), ss0.target_of_supporting_site() ); } else { Storage_site_2 supp0 = ss0.supporting_site(); Storage_site_2 supp1 = ss1.supporting_site(0); if ( are_parallel(supp0.site(), supp1.site()) ) { supp1 = ss1.supporting_site(1); } return Storage_site_2::construct_storage_site_2 ( supp0.source_of_supporting_site(), supp0.target_of_supporting_site(), supp1.source_of_supporting_site(), supp1.target_of_supporting_site(), false ); } } else { if ( ss1.is_input() ) { return Storage_site_2::construct_storage_site_2 ( ss1.point(), ss0.target_of_supporting_site(), ss0.source_of_crossing_site(1), ss0.target_of_crossing_site(1), true ); } else { Storage_site_2 supp0 = ss0.supporting_site(); Storage_site_2 supp1 = ss1.supporting_site(0); if ( are_parallel(supp0.site(), supp1.site()) ) { supp1 = ss1.supporting_site(1); } return Storage_site_2::construct_storage_site_2 ( supp0.source_of_supporting_site(), supp0.target_of_supporting_site(), supp1.source_of_supporting_site(), supp1.target_of_supporting_site(), ss0.source_of_crossing_site(1), ss0.target_of_crossing_site(1) ); } } } } inline Storage_site_2 create_storage_site(const Storage_site_2& ss0, const Storage_site_2& ss1) { return Storage_site_2::construct_storage_site_2 ( ss0.source_of_supporting_site(), ss0.target_of_supporting_site(), ss1.source_of_supporting_site(), ss1.target_of_supporting_site() ); } inline Storage_site_2 create_storage_site(const Storage_site_2& ss0, const Storage_site_2& ss1, bool is_first_exact) { return Storage_site_2::construct_storage_site_2 ( ss0.source_of_supporting_site(), ss0.target_of_supporting_site(), ss1.source_of_supporting_site(), ss1.target_of_supporting_site(), is_first_exact ); } inline Storage_site_2 create_storage_site_type1(const Storage_site_2& ss0, const Storage_site_2& ss1, const Storage_site_2& ss2) { return Storage_site_2::construct_storage_site_2 ( ss0.source_of_supporting_site(), ss0.target_of_supporting_site(), ss1.source_of_crossing_site(0), ss1.target_of_crossing_site(0), ss2.source_of_supporting_site(), ss2.target_of_supporting_site() ); } inline Storage_site_2 create_storage_site_type2(const Storage_site_2& ss0, const Storage_site_2& ss1, const Storage_site_2& ss2) { return Storage_site_2::construct_storage_site_2 ( ss0.source_of_supporting_site(), ss0.target_of_supporting_site(), ss1.source_of_supporting_site(), ss1.target_of_supporting_site(), ss2.source_of_crossing_site(1), ss2.target_of_crossing_site(1) ); } public: // METHODS FOR ACCESSING THE PRIMAL GRAPH //--------------------------------------- // used primarily for visualization inline Point_2 primal(const Face_handle& f) const { return circumcenter(f); } Object primal(const Edge e) const; inline Object primal(const Edge_circulator& ec) const { return primal(*ec); } inline Object primal(const Finite_edges_iterator& ei) const { return primal(*ei); } protected: void print_error_message() const; void print_error_message(const Tag_false&) const { static int i = 0; if ( i == 0 ) { i++; std::cerr << "SVD::Insert aborted: intersecting segments found" << std::endl; } } void print_error_message(const Tag_true&) const {} //protected: public: // wrappers for constructions inline Point_2 circumcenter(const Face_handle& f) const { CGAL_precondition( this->dimension()==2 || !is_infinite(f) ); return circumcenter(f->vertex(0)->site(), f->vertex(1)->site(), f->vertex(2)->site()); } inline Point_2 circumcenter(const Site_2& t0, const Site_2& t1, const Site_2& t2) const { return geom_traits().construct_svd_vertex_2_object()(t0, t1, t2); } protected: // HELPER METHODS FOR INSERTION //----------------------------- void initialize_conflict_region(const Face_handle& f, List& l); std::pair find_faces_to_split(const Vertex_handle& v, const Site_2& t) const; void expand_conflict_region(const Face_handle& f, const Site_2& t, const Storage_site_2& ss, List& l, Face_map& fm, std::map& sign_map, Triple& vcross); Vertex_handle add_bogus_vertex(Edge e, List& l); Vertex_list add_bogus_vertices(List& l); void remove_bogus_vertices(Vertex_list& vl); void retriangulate_conflict_region(Vertex_handle v, List& l, Face_map& fm); protected: // TYPES AND ACCESS METHODS FOR VISUALIZATION //------------------------------------------- // types typedef CGAL::Construct_svd_circle_2 Construct_svd_circle_2; typedef CGAL::Construct_svd_bisector_2 Construct_svd_bisector_2; typedef CGAL::Construct_svd_bisector_ray_2 Construct_svd_bisector_ray_2; typedef CGAL::Construct_svd_bisector_segment_2 Construct_svd_bisector_segment_2; // access inline Construct_svd_circle_2 construct_svd_circle_2_object() const{ return Construct_svd_circle_2(); } inline Construct_svd_bisector_2 construct_svd_bisector_2_object() const { return Construct_svd_bisector_2(); } inline Construct_svd_bisector_ray_2 construct_svd_bisector_ray_2_object() const { return Construct_svd_bisector_ray_2(); } inline Construct_svd_bisector_segment_2 construct_svd_bisector_segment_2_object() const { return Construct_svd_bisector_segment_2(); } protected: // WRAPPERS FOR GEOMETRIC PREDICATES //---------------------------------- inline bool same_points(const Storage_site_2& p, const Storage_site_2& q) const { return geom_traits().equal_2_object()(p.site(), q.site()); } inline bool same_segments(const Storage_site_2& t, Vertex_handle v) const { if ( is_infinite(v) ) { return false; } if ( t.is_point() || v->storage_site().is_point() ) { return false; } return same_segments(t.site(), v->site()); } inline bool is_endpoint_of_segment(const Storage_site_2& p, const Storage_site_2& s) const { CGAL_precondition( p.is_point() && s.is_segment() ); return ( same_points(p, s.source_site()) || same_points(p, s.target_site()) ); } inline bool is_degenerate_segment(const Storage_site_2& s) const { CGAL_precondition( s.is_segment() ); return same_points(s.source_site(), s.target_site()); } // returns: // ON_POSITIVE_SIDE if q is closer to t1 // ON_NEGATIVE_SIDE if q is closer to t2 // ON_ORIENTED_BOUNDARY if q is on the bisector of t1 and t2 inline Oriented_side side_of_bisector(const Storage_site_2 &t1, const Storage_site_2 &t2, const Storage_site_2 &q) const { return geom_traits().oriented_side_of_bisector_2_object()(t1.site(), t2.site(), q.site()); } inline Sign incircle(const Storage_site_2 &t1, const Storage_site_2 &t2, const Storage_site_2 &t3, const Storage_site_2 &q) const { return geom_traits().vertex_conflict_2_object()(t1.site(), t2.site(), t3.site(), q.site()); } inline Sign incircle(const Storage_site_2 &t1, const Storage_site_2 &t2, const Storage_site_2 &q) const { return geom_traits().vertex_conflict_2_object()(t1.site(), t2.site(), q.site()); } inline Sign incircle(const Face_handle& f, const Storage_site_2& q) const { return incircle(f, q.site()); } inline bool finite_edge_interior(const Storage_site_2& t1, const Storage_site_2& t2, const Storage_site_2& t3, const Storage_site_2& t4, const Storage_site_2& q, Sign sgn) const { return geom_traits().finite_edge_interior_conflict_2_object() (t1.site(), t2.site(), t3.site(), t4.site(), q.site(), sgn); } inline bool finite_edge_interior(const Face_handle& f, int i, const Storage_site_2& q, Sign sgn) const { CGAL_precondition( !is_infinite(f) && !is_infinite(f->neighbor(i)) ); return finite_edge_interior( f->vertex( ccw(i) )->site(), f->vertex( cw(i) )->site(), f->vertex( i )->site(), f->mirror_vertex(i)->site(), q.site(), sgn); } inline bool finite_edge_interior(const Storage_site_2& t1, const Storage_site_2& t2, const Storage_site_2& t3, const Storage_site_2& q, Sign sgn) const { return geom_traits().finite_edge_interior_conflict_2_object()(t1.site(), t2.site(), t3.site(), q.site(), sgn); } inline bool finite_edge_interior(const Storage_site_2& t1, const Storage_site_2& t2, const Storage_site_2& q, Sign sgn) const { return geom_traits().finite_edge_interior_conflict_2_object()(t1.site(), t2.site(), q.site(), sgn); } bool finite_edge_interior(const Face_handle& f, int i, const Storage_site_2& p, Sign sgn, int j) const { return finite_edge_interior(f, i, p.site(), sgn, j); } inline bool infinite_edge_interior(const Storage_site_2& t2, const Storage_site_2& t3, const Storage_site_2& t4, const Storage_site_2& q, Sign sgn) const { return geom_traits().infinite_edge_interior_conflict_2_object() (t2.site(), t3.site(), t4.site(), q.site(), sgn); } inline bool infinite_edge_interior(const Face_handle& f, int i, const Storage_site_2& q, Sign sgn) const { return infinite_edge_interior(f, i, q, sgn); } inline bool edge_interior(const Face_handle& f, int i, const Storage_site_2& t, Sign sgn) const { return edge_interior(f, i, t.site(), sgn); } inline bool edge_interior(const Edge& e, const Storage_site_2& t, Sign sgn) const { return edge_interior(e.first, e.second, t, sgn); } inline Arrangement_type arrangement_type(const Storage_site_2& t, const Vertex_handle& v) const { if ( is_infinite(v) ) { return AT2::DISJOINT; } return arrangement_type(t, v->storage_site()); } inline Arrangement_type arrangement_type(const Storage_site_2& p, const Storage_site_2& q) const { return arrangement_type(p.site(), q.site()); } inline bool are_parallel(const Storage_site_2& p, const Storage_site_2& q) const { return geom_traits().are_parallel_2_object()(p.site(), q.site()); } inline Oriented_side oriented_side(const Storage_site_2& q, const Storage_site_2& supp, const Storage_site_2& p) const { CGAL_precondition( q.is_point() && supp.is_segment() && p.is_point() ); return geom_traits().oriented_side_2_object()(q.site(), supp.site(), p.site()); } inline Oriented_side oriented_side(const Storage_site_2& s1, const Storage_site_2& s2, const Storage_site_2& s3, const Storage_site_2& supp, const Storage_site_2& p) const { CGAL_precondition( supp.is_segment() && p.is_point() ); return geom_traits().oriented_side_2_object()(s1.site(), s2.site(), s3.site(), supp.site(), p.site()); } //------- inline bool same_points(const Site_2& p, const Site_2& q) const { return geom_traits().equal_2_object()(p, q); } inline bool same_segments(const Site_2& t, Vertex_handle v) const { if ( is_infinite(v) ) { return false; } if ( t.is_point() || v->site().is_point() ) { return false; } return same_segments(t, v->site()); } inline bool same_segments(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_segment() && q.is_segment() ); return (same_points(p.source_site(), q.source_site()) && same_points(p.target_site(), q.target_site())) || (same_points(p.source_site(), q.target_site()) && same_points(p.target_site(), q.source_site())); } inline bool is_endpoint_of_segment(const Site_2& p, const Site_2& s) const { CGAL_precondition( p.is_point() && s.is_segment() ); return ( same_points(p, s.source_site()) || same_points(p, s.target_site()) ); } inline bool is_degenerate_segment(const Site_2& s) const { CGAL_precondition( s.is_segment() ); return same_points(s.source_site(), s.target_site()); } // returns: // ON_POSITIVE_SIDE if q is closer to t1 // ON_NEGATIVE_SIDE if q is closer to t2 // ON_ORIENTED_BOUNDARY if q is on the bisector of t1 and t2 inline Oriented_side side_of_bisector(const Site_2 &t1, const Site_2 &t2, const Site_2 &q) const { return geom_traits().oriented_side_of_bisector_2_object()(t1, t2, q); } inline Sign incircle(const Site_2 &t1, const Site_2 &t2, const Site_2 &t3, const Site_2 &q) const { return geom_traits().vertex_conflict_2_object()(t1, t2, t3, q); } inline Sign incircle(const Site_2 &t1, const Site_2 &t2, const Site_2 &q) const { return geom_traits().vertex_conflict_2_object()(t1, t2, q); } inline Sign incircle(const Face_handle& f, const Site_2& q) const; inline Sign incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v) const { CGAL_precondition( !is_infinite(v0) && !is_infinite(v1) && !is_infinite(v) ); return incircle( v0->site(), v1->site(), v->site()); } Sign incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v) const; inline bool finite_edge_interior(const Site_2& t1, const Site_2& t2, const Site_2& t3, const Site_2& t4, const Site_2& q, Sign sgn) const { return geom_traits().finite_edge_interior_conflict_2_object() (t1,t2,t3,t4,q,sgn); } inline bool finite_edge_interior(const Face_handle& f, int i, const Site_2& q, Sign sgn) const { CGAL_precondition( !is_infinite(f) && !is_infinite(f->neighbor(i)) ); return finite_edge_interior( f->vertex( ccw(i) )->site(), f->vertex( cw(i) )->site(), f->vertex( i )->site(), f->mirror_vertex(i)->site(), q, sgn); } inline bool finite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign sgn) const { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) && !is_infinite(v3) && !is_infinite(v4) && !is_infinite(v) ); return finite_edge_interior( v1->site(), v2->site(), v3->site(), v4->site(), v->site(), sgn); } inline bool finite_edge_interior(const Site_2& t1, const Site_2& t2, const Site_2& t3, const Site_2& q, Sign sgn) const { return geom_traits().finite_edge_interior_conflict_2_object()(t1,t2,t3,q,sgn); } inline bool finite_edge_interior(const Site_2& t1, const Site_2& t2, const Site_2& q, Sign sgn) const { return geom_traits().finite_edge_interior_conflict_2_object()(t1,t2,q,sgn); } bool finite_edge_interior(const Face_handle& f, int i, const Site_2& p, Sign sgn, int) const; bool finite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign, int) const; inline bool infinite_edge_interior(const Site_2& t2, const Site_2& t3, const Site_2& t4, const Site_2& q, Sign sgn) const { return geom_traits().infinite_edge_interior_conflict_2_object() (t2,t3,t4,q,sgn); } bool infinite_edge_interior(const Face_handle& f, int i, const Site_2& q, Sign sgn) const; bool infinite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign sgn) const; bool edge_interior(const Face_handle& f, int i, const Site_2& t, Sign sgn) const; bool edge_interior(const Edge& e, const Site_2& t, Sign sgn) const { return edge_interior(e.first, e.second, t, sgn); } bool edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, Sign sgn) const; inline Arrangement_type arrangement_type(const Site_2& t, const Vertex_handle& v) const { if ( is_infinite(v) ) { return AT2::DISJOINT; } return arrangement_type(t, v->site()); } Arrangement_type arrangement_type(const Site_2& p, const Site_2& q) const; inline bool are_parallel(const Site_2& p, const Site_2& q) const { return geom_traits().are_parallel_2_object()(p, q); } inline Oriented_side oriented_side(const Site_2& q, const Site_2& supp, const Site_2& p) const { CGAL_precondition( q.is_point() && supp.is_segment() && p.is_point() ); return geom_traits().oriented_side_2_object()(q, supp, p); } inline Oriented_side oriented_side(const Site_2& s1, const Site_2& s2, const Site_2& s3, const Site_2& supp, const Site_2& p) const { CGAL_precondition( supp.is_segment() && p.is_point() ); return geom_traits().oriented_side_2_object()(s1, s2, s3, supp, p); } Vertex_handle first_endpoint_of_segment(const Vertex_handle& v) const { CGAL_assertion( v->is_segment() ); Site_2 fe = v->site().source_site(); Vertex_circulator vc_start = v->incident_vertices(); Vertex_circulator vc = vc_start; do { // Vertex_handle vv(vc); if ( !is_infinite(vc) && vc->is_point() ) { if ( same_points(fe, vc->site()) ) { return Vertex_handle(vc); } } vc++; } while ( vc != vc_start ); // we should never reach this point CGAL_assertion( false ); return Vertex_handle(); } Vertex_handle second_endpoint_of_segment(const Vertex_handle& v) const { CGAL_assertion( v->is_segment() ); Site_2 fe = v->site().target_site(); Vertex_circulator vc_start = v->incident_vertices(); Vertex_circulator vc = vc_start; do { // Vertex_handle vv(vc); if ( !is_infinite(vc) && vc->is_point() ) { if ( same_points(fe, vc->site()) ) { return Vertex_handle(vc); } } vc++; } while ( vc != vc_start ); // we should never reach this point CGAL_assertion( false ); return Vertex_handle(); } }; // Segment_Voronoi_diagram_2 CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_2_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Line_20000644000175000017500000000225111344301500031132 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/version.h0000644000175000017500000000031711344301501026660 0ustar debiandebian// This file is automatically created by create_internal_release. // Do not edit manually. #ifndef CGAL_VERSION_H #define CGAL_VERSION_H #define CGAL_VERSION 3.1 #define CGAL_VERSION_NR 1003001100 #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_list.h0000644000175000017500000000277211344301500030343 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_CIRCULATOR_LIST_H #define CGAL_CIRCULATOR_LIST_H #include #include namespace CGAL { template class Circulator_list : public std::list { public: Circulator_list() {} Circulator_list(Circulator first) { if (first == NULL) return; Circulator current = first; do { push_back(current); } while (++current != first); } }; template std::ostream& operator<<(std::ostream& os, const Circulator_list& c) { typename Circulator_list::const_iterator current; for (current = c.begin(); current != c.end(); current++) { os << **current << " "; } return os; } } #endif // CGAL_CIRCULATOR_LIST_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian_d.h0000644000175000017500000003332411344301500027412 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CARTESIAN_D_H #define CARTESIAN_D_H #ifndef NOCGALINCL #include #include #include #include #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template > class Cartesian_d { public: typedef Cartesian_d Self; typedef pFT RT; typedef pFT FT; typedef pLA LA; typedef Cartesian_tag Rep_tag; typedef PointCd2 Point_d_base; // renamed because of clash with Cartesian... typedef VectorCd Vector_d_base; typedef DirectionCd Direction_d_base; typedef HyperplaneCd Hyperplane_d_base; typedef Aff_transformationCd Aff_transformation_d_base; typedef CGAL::Point_d Point_d; typedef CGAL::Vector_d Vector_d; typedef CGAL::Direction_d Direction_d; typedef CGAL::Hyperplane_d Hyperplane_d; typedef CGAL::Aff_transformation_d Aff_transformation_d; typedef typename Point_d_base::Cartesian_const_iterator Cartesian_const_iterator_d; template class Construct_cartesian_const_iterator { typedef typename K::Point_d Point_d; typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator_d; public: typedef Cartesian_const_iterator_d result_type; typedef Arity_tag< 1> Arity; Cartesian_const_iterator_d operator()(const Point_d& p) const { return p.cartesian_begin(); } Cartesian_const_iterator_d operator()( const Point_d& p, int) const { return p.cartesian_end(); } }; // TODO: Make it work for the other values template class Construct_vertex { typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator_d; public: typedef Point_d result_type; typedef Arity_tag< 2> Arity; Point_d operator()(const Iso_box_d& b, int i) { if(i == 0){ return b.min(); } return b.max(); } }; typedef Construct_vertex Construct_vertex_d; typedef Construct_cartesian_const_iterator Construct_cartesian_const_iterator_d; Construct_cartesian_const_iterator_d construct_cartesian_const_iterator_d_object() const { return Construct_cartesian_const_iterator_d(); } template class Construct_min_vertex { typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; public: typedef Point_d result_type; typedef Arity_tag< 1 > Arity; Point_d operator()(const Iso_box_d& b) { return b.min(); } }; typedef Construct_min_vertex Construct_min_vertex_d; Construct_min_vertex_d construct_min_vertex_d_object() const { return Construct_min_vertex_d(); } template class Construct_max_vertex { typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; public: typedef Point_d result_type; typedef Arity_tag< 1 > Arity; Point_d operator()(const Iso_box_d& b) { return b.max(); } }; typedef Construct_max_vertex Construct_max_vertex_d; Construct_max_vertex_d construct_max_vertex_d_object() const { return Construct_max_vertex_d(); } // meta types (fit both kernels): typedef CGAL::Sphere_d Sphere_d; typedef CGAL::Iso_box_d Iso_box_d; typedef CGAL::Segment_d Segment_d; typedef CGAL::Ray_d Ray_d; typedef CGAL::Line_d Line_d; // construction objects: typedef CGALi::Construct Construct_point_d; Construct_point_d construct_point_d_object() const { return Construct_point_d(); } typedef CGALi::Construct Construct_vector_d; Construct_vector_d construct_vector_d_object() const { return Construct_vector_d(); } typedef CGALi::Construct Construct_direction_d; Construct_direction_d construct_direction_d_object() const { return Construct_direction_d(); } typedef CGALi::Construct Construct_segment_d; Construct_segment_d construct_segment_d_object() const { return Construct_segment_d(); } typedef CGALi::Construct Construct_ray_d; Construct_ray_d construct_ray_d_object() const { return Construct_ray_d(); } typedef CGALi::Construct Construct_line_d; Construct_line_d construct_line_d_object() const { return Construct_line_d(); } typedef CGALi::Construct Construct_iso_box_d; Construct_iso_box_d construct_iso_box_d_object() const { return Construct_iso_box_d(); } typedef CGALi::Construct Construct_hyperplane_d; Construct_hyperplane_d construct_hyperplane_d_object() const { return Construct_hyperplane_d(); } typedef CGALi::Construct Construct_sphere_d; Construct_sphere_d construct_sphere_d_object() const { return Construct_sphere_d(); } typedef CGALi::Construct Construct_aff_transformation_d; Construct_aff_transformation_d construct_aff_transformation_d_object() const { return Construct_aff_transformation_d(); } // function objects: typedef Lift_to_paraboloidCd Lift_to_paraboloid_d; typedef Project_along_d_axisCd Project_along_d_axis_d; typedef MidpointCd Midpoint_d; typedef Squared_distanceCd Squared_distance_d; typedef Position_on_lineCd Position_on_line_d; typedef Barycentric_coordinatesCd Barycentric_coordinates_d; typedef OrientationCd Orientation_d; typedef Side_of_oriented_sphereCd Side_of_oriented_sphere_d; typedef Side_of_bounded_sphereCd Side_of_bounded_sphere_d; typedef Contained_in_simplexCd Contained_in_simplex_d; typedef Contained_in_affine_hullCd Contained_in_affine_hull_d; typedef Affine_rankCd Affine_rank_d; typedef Affinely_independentCd Affinely_independent_d; typedef Compare_lexicographicallyCd Compare_lexicographically_d; typedef Lt_from_compare Less_lexicographically_d; typedef Le_from_compare Less_or_equal_lexicographically_d; typedef Eq_from_method Equal_d; typedef Center_of_sphereCd Center_of_sphere_d; typedef Contained_in_linear_hullCd Contained_in_linear_hull_d; typedef Linear_rankCd Linear_rank_d; typedef Linearly_independentCd Linearly_independent_d; typedef Linear_baseCd Linear_base_d; Lift_to_paraboloid_d lift_to_paraboloid_d_object() const { return Lift_to_paraboloid_d(); } Project_along_d_axis_d project_along_d_axis_d_object() const { return Project_along_d_axis_d(); } Midpoint_d midpoint_d_object() const { return Midpoint_d(); } Squared_distance_d squared_distance_d_object() const { return Squared_distance_d(); } Position_on_line_d position_on_line_d_object() const { return Position_on_line_d(); } Barycentric_coordinates_d barycentric_coordinates_d_object() const { return Barycentric_coordinates_d(); } Orientation_d orientation_d_object() const { return Orientation_d(); } Side_of_oriented_sphere_d side_of_oriented_sphere_d_object() const { return Side_of_oriented_sphere_d(); } Side_of_bounded_sphere_d side_of_bounded_sphere_d_object() const { return Side_of_bounded_sphere_d(); } Contained_in_simplex_d contained_in_simplex_d_object() const { return Contained_in_simplex_d(); } Contained_in_affine_hull_d contained_in_affine_hull_d_object() const { return Contained_in_affine_hull_d(); } Affine_rank_d affine_rank_d_object() const { return Affine_rank_d(); } Affinely_independent_d affinely_independent_d_object() const { return Affinely_independent_d(); } Equal_d equal_d_object() const { return Equal_d(); } Compare_lexicographically_d compare_lexicographically_d_object() const { return Compare_lexicographically_d(); } Less_lexicographically_d less_lexicographically_d_object() const { return Less_lexicographically_d(); } Less_or_equal_lexicographically_d less_or_equal_lexicographically_d_object() const { return Less_or_equal_lexicographically_d(); } Center_of_sphere_d center_of_sphere_d_object() const { return Center_of_sphere_d(); } Contained_in_linear_hull_d contained_in_linear_hull_d_object() const { return Contained_in_linear_hull_d(); } Linear_rank_d linear_rank_d_object() const { return Linear_rank_d(); } Linearly_independent_d linearly_independent_d_object() const { return Linearly_independent_d(); } Linear_base_d linear_base_d_object() const { return Linear_base_d(); } // Intersection objects: typedef CGAL::Line_line_intersectionCd Line_line_intersection_d; typedef CGAL::Line_hyperplane_intersectionCd Line_hyperplane_intersection_d; typedef CGAL::Line_d_Line_d_pair Line_d_Line_d_pair; typedef CGAL::Ray_d_Ray_d_pair Ray_d_Ray_d_pair; typedef CGAL::Segment_d_Segment_d_pair Segment_d_Segment_d_pair; typedef CGAL::Line_d_Ray_d_pair Line_d_Ray_d_pair; typedef CGAL::Line_d_Segment_d_pair Line_d_Segment_d_pair; typedef CGAL::Ray_d_Segment_d_pair Ray_d_Segment_d_pair; typedef CGAL::Line_d_Hyperplane_d_pair Line_d_Hyperplane_d_pair; typedef CGAL::Ray_d_Hyperplane_d_pair Ray_d_Hyperplane_d_pair; typedef CGAL::Segment_d_Hyperplane_d_pair Segment_d_Hyperplane_d_pair; typedef CGALi::Intersect Intersect_d; Intersect_d intersect_d_object() const { return Intersect_d(); } // FT - RT conversion and access : static FT make_FT(const RT & num, const RT& denom) { return num/denom; } static FT make_FT(const RT & num) { return FT(num); } static RT FT_numerator(const FT &r) { return r; } static RT FT_denominator(const FT &r) { return RT(1); } // special stuff for traits class character : struct Component_accessor_d { template int dimension(const C& c) const { return c.dimension(); } template RT homogeneous(const C& c, int i) { return c.homogeneous(i); } template FT cartesian(const C& c, int i) { return c.cartesian(i); } }; Component_accessor_d component_accessor_d_object() const { return Component_accessor_d(); } typedef CGALi::Call_has_on_positive_side Has_on_positive_side_d; Has_on_positive_side_d has_on_positive_side_d_object() const { return Has_on_positive_side_d(); } typedef CGALi::Call_oriented_side Oriented_side_d; Oriented_side_d oriented_side_d_object() const { return Oriented_side_d(); } struct Value_at_d { RT operator()(const Hyperplane_d& h, const Point_d& p) const { return h.value_at(p); } }; Value_at_d value_at_d_object() const { return Value_at_d(); } struct Point_to_vector_d { Vector_d operator()(const Point_d& p) const { return p-CGAL::ORIGIN; } }; Point_to_vector_d point_to_vector_d_object() const { return Point_to_vector_d(); } struct Vector_to_point_d { Point_d operator()(const Vector_d& v) const { return CGAL::ORIGIN+v; } }; Vector_to_point_d vector_to_point_d_object() const { return Vector_to_point_d(); } struct Orthogonal_vector_d { Vector_d operator()(const Hyperplane_d& h) const { return h.orthogonal_vector(); } }; Orthogonal_vector_d orthogonal_vector_d_object() const { return Orthogonal_vector_d(); } struct Point_of_sphere_d { Point_d operator()(const Sphere_d& S, int i) { return S.point(i); } }; Point_of_sphere_d point_of_sphere_d_object() const { return Point_of_sphere_d(); } }; // Cartesian_d CGAL_END_NAMESPACE #include #include #include #include #include #include #include #include #include #include #include #include #endif // CARTESIAN_D_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000000353011344301500031411 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_2_H #define CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_2_H namespace CGAL { template // algorithm to use class Min_sphere_of_spheres_d_traits_2 { public: // types: typedef FT_ FT; typedef FT_ Radius; typedef typename K_::Point_2 Point; typedef std::pair Sphere; typedef typename K_::Cartesian_const_iterator_2 Cartesian_const_iterator; typedef UseSqrt_ Use_square_roots; typedef Algorithm_ Algorithm; public: // constants: static const int D = 2; // dimension public: // accessors: static inline const FT& radius(const Sphere& s) { return s.second; } static inline Cartesian_const_iterator center_cartesian_begin(const Sphere& s) { return s.first.cartesian_begin(); } }; } // namespace CGAL #endif // CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Inverse_index.h0000644000175000017500000000247411344301500030002 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Inverse_index.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete; use instead. #include ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/range_search_delaunay_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/range_search_delaunay_0000644000175000017500000003200511344301500031405 0ustar debiandebian// Copyright (c) 1999 Martin-Luther-University Halle-Wittenberg (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/range_search_delaunay_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_RANGE_SEARCH_DELAUNAY_2_H #define CGAL_RANGE_SEARCH_DELAUNAY_2_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // was // std::map > template void dfs(const Dt& delau, MAP_TYPE& mark, typename Dt::Vertex_handle v, const Circle& C, OutputIterator res, bool first_vertex) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Vertex Vertex; typedef typename Dt::Vertex_circulator Vertex_circulator; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Bounded_side_2 Bounded_side_2; Bounded_side_2 test; if (! first_vertex) *res = v; //mark_vertex v mark[v] = true; // get incident vertices of v ... Vertex_circulator vc = delau.incident_vertices(v); Vertex_circulator start =vc; Vertex_handle act; // go through the vertices ... do { act = vc; if (! delau.is_infinite(act)) { // test, if act is marked ... bool is_marked = mark[act]; if ((! is_marked) && !( test(C,act->point()) == ON_UNBOUNDED_SIDE) ) dfs(delau, mark, act, C, res, false); } vc++; } while (vc != start); } // second dfs uses test - predicate function object ... template bool dfs(const Dt& delau, MAP_TYPE& mark, typename Dt::Vertex_handle v, const Circle& C, OutputIterator res, bool first_vertex, bool return_if_predicate_succeded, Pred& pred) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Vertex Vertex; typedef typename Dt::Vertex_circulator Vertex_circulator; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Bounded_side_2 Bounded_side_2; Bounded_side_2 test; if (! first_vertex) { if (pred(v->point())) { *res = v; if (return_if_predicate_succeded) return true; } } //mark_vertex v mark[v] = true; // get incident vertices of v ... Vertex_circulator vc = delau.incident_vertices(v); Vertex_circulator start =vc; Vertex_handle act; // go through the vertices ... do { act = vc; if (! delau.is_infinite(act)) { // test, if act is marked ... bool is_marked = mark[act]; if ((! is_marked) && !( test(C,act->point()) == ON_UNBOUNDED_SIDE) ) if (dfs(delau, mark, act, C, res, false, return_if_predicate_succeded, pred)) return true; } vc++; } while (vc != start); return false; } template void dfs_using_predicate(const Dt& delau, MAP_TYPE& mark, typename Dt::Vertex_handle v, const Circle& C, OutputIterator res, bool first_vertex, bool return_if_predicate_succeded, Pred& pred) { bool val = dfs(delau, mark, v, C, res, first_vertex, return_if_predicate_succeded, pred); pred.set_result(val); } // circular range search ... template OutputIterator range_search(Dt& delau, const Circle& C, OutputIterator res) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Vertex Vertex; typedef typename Dt::Vertex_iterator Vertex_iterator; typedef typename Gt::Bounded_side_2 Bounded_side_2; typedef typename Gt::Construct_center_2 Construct_center_2; Bounded_side_2 test; if (delau.number_of_vertices() == 0) return res; if (delau.number_of_vertices() == 1) { // get the one vertex ... Vertex_iterator vit = delau.finite_vertices_begin(); Point p = vit->point(); if (! (test(C, p) == ON_UNBOUNDED_SIDE)){ *res= vit; res++; } return res; } // normal case ... Point p = Construct_center_2()(C); Vertex_handle v = lookup(delau, p); bool new_v = false; // we have to insert the center ... if ( v == NULL ) { new_v = true; v = delau.insert(p); } //std::map > mark; Unique_hash_map mark; dfs(delau,mark,v,C,res,new_v); if (new_v) { delau.remove(v); } return res; } // triangular range search ... template OutputIterator range_search(Dt& delau, const typename Dt::Point& a, const typename Dt::Point& b, const typename Dt::Point& c, OutputIterator res) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Gt::Circle_2 Circle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Orientation_2 Orientation_2; typedef typename Gt::Construct_circle_2 Construct_circle_2; Orientation_2 test_ori; int orient = (int)(test_ori(a,b,c)); Circle C = Construct_circle_2()(a,b,c); std::list L; range_search(delau, C, std::back_inserter(L)); typename std::list::const_iterator it = L.begin(); for(;it != L.end();it++) { Point p = (*it)->point(); if ( ((int)(test_ori(a,b,p))) == - orient || ((int)(test_ori(b,c,p))) == - orient || ((int)(test_ori(c,a,p))) == - orient ) { } else { *res = *it; res++; } } return res; } // rectangular range search .... template OutputIterator range_search(Dt& delau, const typename Dt::Point& a1, const typename Dt::Point& b1, const typename Dt::Point& c1, const typename Dt::Point& d1, OutputIterator res) // a1 upper left, b1 lower left , c1 lower right { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Gt::Circle_2 Circle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Orientation_2 Orientation_2; typedef typename Gt::Construct_circle_2 Construct_circle_2; Point a=a1,b=b1,c=c1,d=d1; if (Orientation_2()(a,b,c) == RIGHT_TURN) { Point tmp = b; b = d; d = tmp; } Circle C = Construct_circle_2()(a,b,c); std::list L; range_search(delau, C, std::back_inserter(L)); typename std::list::const_iterator it = L.begin(); for(;it != L.end();it++) { Point p = (*it)->point(); if ( Orientation_2()(a,b,p) == RIGHT_TURN || Orientation_2()(b,c,p) == RIGHT_TURN || Orientation_2()(c,d,p) == RIGHT_TURN || Orientation_2()(d,a,p) == RIGHT_TURN ) { } else { *res = *it; res++; } } return res; } // ------------------------------------------------------------------------------------------------ // new range search variants using test function object ... // circular range search ... template OutputIterator range_search(Dt& delau, const Circle& C, OutputIterator res, Pred& pred, bool return_if_succeded) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Vertex Vertex; typedef typename Dt::Vertex_iterator Vertex_iterator; typedef typename Gt::Bounded_side_2 Bounded_side_2; typedef typename Gt::Construct_center_2 Construct_center_2; Bounded_side_2 test; if (delau.number_of_vertices() == 0) return res; if (delau.number_of_vertices() == 1) { // get the one vertex ... Vertex_iterator vit = delau.finite_vertices_begin(); Point p = vit->point(); if (! (test(C, p) == ON_UNBOUNDED_SIDE)){ *res= vit; res++; } bool val = pred(p); pred.set_result(val); return res; } // normal case ... Point p = Construct_center_2()(C); Vertex_handle v = lookup(delau, p); bool new_v = false; // we have to insert the center ... if ( v == NULL ) { new_v = true; v = delau.insert(p); } //std::map > mark; Unique_hash_map mark; dfs_using_predicate(delau,mark,v,C,res,new_v, return_if_succeded, pred); if (new_v) { delau.remove(v); } return res; } // triangular range search ... template OutputIterator range_search(Dt& delau, const typename Dt::Point& a, const typename Dt::Point& b, const typename Dt::Point& c, OutputIterator res, Pred& pred, bool return_if_succeded) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Gt::Circle_2 Circle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Orientation_2 Orientation_2; typedef typename Gt::Construct_circle_2 Construct_circle_2; Orientation_2 test_ori; int orient = (int)(test_ori(a,b,c)); Circle C = Construct_circle_2()(a,b,c); std::list L; range_search(delau, C, std::back_inserter(L), pred, return_if_succeded); if (return_if_succeded) return res; typename std::list::const_iterator it = L.begin(); for(;it != L.end();it++) { Point p = (*it)->point(); if ( ((int)(test_ori(a,b,p))) == - orient || ((int)(test_ori(b,c,p))) == - orient || ((int)(test_ori(c,a,p))) == - orient ) { } else { *res = *it; res++; } } return res; } // rectangular range search .... template OutputIterator range_search(Dt& delau, const typename Dt::Point& a1, const typename Dt::Point& b1, const typename Dt::Point& c1, const typename Dt::Point& d1, OutputIterator res, Pred& pred, bool return_if_succeded) // a1 upper left, b1 lower left , c1 lower right { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Gt::Circle_2 Circle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Orientation_2 Orientation_2; typedef typename Gt::Construct_circle_2 Construct_circle_2; Point a=a1,b=b1,c=c1,d=d1; if (Orientation_2()(a,b,c) == RIGHT_TURN) { Point tmp = b; b = d; d = tmp; } Circle C = Construct_circle_2()(a,b,c); std::list L; range_search(delau, C, std::back_inserter(L), pred, return_if_succeded); if (return_if_succeded) return res; typename std::list::const_iterator it = L.begin(); for(;it != L.end();it++) { Point p = (*it)->point(); if ( Orientation_2()(a,b,p) == RIGHT_TURN || Orientation_2()(b,c,p) == RIGHT_TURN || Orientation_2()(c,d,p) == RIGHT_TURN || Orientation_2()(d,a,p) == RIGHT_TURN ) { } else { *res = *it; res++; } } return res; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_lines_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_lines_2.0000644000175000017500000000241511344301500031255 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_lines_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_PREDICATES_ON_LINES_2_H #define CGAL_PREDICATES_ON_LINES_2_H // Kept for backward compatibility only. #endif // CGAL_PREDICATES_ON_LINES_2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_traits_20000644000175000017500000000362511344301500031241 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_ELLIPSE_2_TRAITS_2_H #define CGAL_MIN_ELLIPSE_2_TRAITS_2_H #ifndef CGAL_OPTIMISATION_ELLIPSE_2_H # include #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_ellipse_2; template < class K_ > class Min_ellipse_2_traits_2; // Class interface and implementation // ================================== template < class K_ > class Min_ellipse_2_traits_2 { public: // types typedef K_ K; typedef typename K::Point_2 Point; typedef CGAL::Optimisation_ellipse_2 Ellipse; private: // data members Ellipse ellipse; // current ellipse // friends friend class CGAL::Min_ellipse_2< CGAL::Min_ellipse_2_traits_2 >; public: // creation (use default implementations) // Min_ellipse_2_traits_2( ); // Min_ellipse_2_traits_2( Min_ellipse_2_traits_2 const&); }; CGAL_END_NAMESPACE #endif // CGAL_MIN_ELLIPSE_2_TRAITS_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_2.h0000644000175000017500000014202311344301500027621 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA // Andreas Fabri #ifndef CGAL_ALPHA_SHAPE_2_H #define CGAL_ALPHA_SHAPE_2_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CGAL_ALPHA_WINDOW_STREAM #include #endif CGAL_BEGIN_NAMESPACE template < class Dt > class Alpha_shape_2 : public Dt { // DEFINITION The class Alpha_shape_2
    represents the family // of alpha-shapes of points in a plane for all positive alpha. It // maintains the underlying Delaunay triangulation which represents // connectivity and order among its faces. Each k-dimensional face of the // Delaunay triangulation is associated with an interval that specifies // for which values of alpha the face belongs to the alpha-shape (sorted // linear arrays resp. multimaps or interval trees). There are links // between the intervals and the k-dimensional faces of the Delaunay // triangulation (multimaps resp. std::hashtables). // //------------------------- TYPES ------------------------------------ public: typedef typename Dt::Geom_traits Gt; typedef typename Dt::Triangulation_data_structure Tds; typedef typename Gt::FT Coord_type; typedef typename Gt::Point_2 Point; typedef typename Gt::Segment_2 Segment; typedef typename Gt::Ray_2 Ray; typedef typename Gt::Line_2 Line; typedef typename Dt::Face_handle Face_handle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Edge Edge; typedef typename Dt::Face_circulator Face_circulator; typedef typename Dt::Edge_circulator Edge_circulator; typedef typename Dt::Vertex_circulator Vertex_circulator; typedef typename Dt::Finite_faces_iterator Finite_faces_iterator; typedef typename Dt::Edge_iterator Edge_iterator; typedef typename Dt::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Dt::Locate_type Locate_type; using Dt::finite_vertices_begin; using Dt::finite_vertices_end; using Dt::faces_begin; using Dt::faces_end; using Dt::edges_begin; using Dt::edges_end; using Dt::number_of_vertices; using Dt::cw; using Dt::ccw; using Dt::VERTEX; using Dt::EDGE; using Dt::FACE; using Dt::OUTSIDE_CONVEX_HULL; using Dt::OUTSIDE_AFFINE_HULL; using Dt::dimension; // for backward compatibility typedef Finite_vertices_iterator Vertex_iterator; typedef Finite_faces_iterator Face_iterator; private: typedef std::multimap< Coord_type, Face_handle > Interval_face_map; typedef typename Interval_face_map::value_type Interval_face; typedef typename Tds::Face::Interval_3 Interval3; typedef std::multimap< Interval3, Edge > Interval_edge_map; typedef typename Interval_edge_map::value_type Interval_edge; typedef std::pair< Coord_type, Coord_type > Interval2; typedef std::multimap< Interval2, Vertex_handle > Interval_vertex_map; typedef typename Interval_vertex_map::value_type Interval_vertex; typedef Face_handle const const_void; typedef std::pair const_Edge; typedef std::vector< Coord_type > Alpha_spectrum; typedef std::vector< Segment > Vect_seg; typedef Unique_hash_map< Face_handle, bool > Marked_face_set; public: typedef typename std::list< Vertex_handle >::iterator Alpha_shape_vertices_iterator; typedef typename std::list< Edge >::iterator Alpha_shape_edges_iterator; typedef typename Alpha_spectrum::const_iterator Alpha_iterator; // An iterator that allow to traverse the sorted sequence of // different alpha-values. The iterator is bidirectional and // non-mutable. Its value-type is Coord_type enum Classification_type {EXTERIOR, SINGULAR, REGULAR, INTERIOR}; // Distinguishes the different cases for classifying a // k-dimensional face of the underlying Delaunay triangulation of // the alpha-shape. // // `EXTERIOR' if the face does not belong to the alpha-complex. // // `SINGULAR' if the face belongs to the boundary of the // alpha-shape, but is not incident to any higher-dimensional // face of the alpha-complex // // `REGULAR' if face belongs to the boundary of the alpha-shape // and is incident to a higher-dimensional face of the // alpha-complex // // `INTERIOR' if the face belongs to the alpha-complex, but does // not belong to the boundary of the alpha-shape enum Mode {GENERAL, REGULARIZED}; // In general, an alpha shape is a non-connected, mixed-dimension // polygon. Its regularized version is formed by the set of // regular edges and their vertices //------------------------ private VARIABLES ------------------------- private: // only finite edges and faces are inserted into the maps Interval_face_map _interval_face_map; Interval_edge_map _interval_edge_map; Interval_vertex_map _interval_vertex_map; Alpha_spectrum _alpha_spectrum; Coord_type _alpha; Mode _mode; // should be constants Coord_type Infinity; Coord_type UNDEFINED; mutable std::list< Vertex_handle > Alpha_shape_vertices_list; mutable std::list< Edge > Alpha_shape_edges_list; mutable bool use_vertex_cache; mutable bool use_edge_cache; public: //------------------------- CONSTRUCTORS ------------------------------ // Introduces an empty alpha-shape `A' for a positive // alpha-value `alpha'. Precondition: `alpha' >= 0. Alpha_shape_2(Coord_type alpha = Coord_type(0), Mode m = GENERAL) : _alpha(alpha), _mode(m), Infinity(-1), UNDEFINED(-2), use_vertex_cache(false), use_edge_cache(false) {} // Introduces an alpha-shape `A' for a positive alpha-value // `alpha' that is initialized with the points in the range // from first to last template Alpha_shape_2(const InputIterator& first, const InputIterator& last, const Coord_type& alpha = Coord_type(0), Mode m = GENERAL) : _alpha(alpha), _mode(m), Infinity(-1), UNDEFINED(-2) , use_vertex_cache(false), use_edge_cache(false) { Dt::insert(first, last); if (dimension() == 2) { // Compute the associated _interval_face_map initialize_interval_face_map(); // Compute the associated _interval_edge_map initialize_interval_edge_map(); // Compute the associated _interval_vertex_map initialize_interval_vertex_map(); // merge the two maps initialize_alpha_spectrum(); } } public: //----------- OUTPUT POINTS CONNECTED BY PAIRS ---------------------- std::list Output(); std::ostream& op_ostream(std::ostream& os) const; #ifdef CGAL_ALPHA_WINDOW_STREAM Window_stream& op_window(Window_stream& W) const; #endif //----------------------- OPERATIONS --------------------------------- // Introduces an alpha-shape `A' for a positive alpha-value // `alpha' that is initialized with the points in the range // from first to last template < class InputIterator > int make_alpha_shape(const InputIterator& first, const InputIterator& last) { clear(); int n = Dt::insert(first, last); if (dimension() == 2) { // Compute the associated _interval_face_map initialize_interval_face_map(); // Compute the associated _interval_edge_map initialize_interval_edge_map(); // Compute the associated _interval_vertex_map initialize_interval_vertex_map(); // merge the two maps initialize_alpha_spectrum(); } return n; } private : //--------------------- INITIALIZATION OF PRIVATE MEMBERS ----------- void initialize_interval_face_map(); void initialize_interval_edge_map(); void initialize_interval_vertex_map(); void initialize_alpha_spectrum(); //--------------------------------------------------------------------- public: void clear() { // clears the structure Dt::clear(); _interval_face_map.clear(); _interval_edge_map.clear(); _interval_vertex_map.clear(); _alpha_spectrum.clear(); Alpha_shape_vertices_list.clear(); Alpha_shape_edges_list.clear(); set_alpha(Coord_type(0)); set_mode(GENERAL); } //----------------------- PRIVATE MEMBERS -------------------------- private: struct Less { bool operator()(const Interval_edge& ie, const Coord_type& alpha) { return ie.first.first < alpha; } bool operator()( const Coord_type& alpha, const Interval_edge& ie) { return alpha < ie.first.first; } }; //----------------------- ACCESS TO PRIVATE MEMBERS ----------------- private: Coord_type find_interval(const Face_handle& f) const { return f->get_alpha(); // return the value Alpha f the face f } Interval3 find_interval(const_Edge e) const { // corriger le parametrage return (e.first)->get_ranges(e.second); // return the Interval3 for the edge n } //--------------------------------------------------------------------- public: Coord_type set_alpha(const Coord_type& alpha) { // Sets the alpha-value to `alpha'. Precondition: `alpha' >= 0. // Returns the previous alpha Coord_type previous_alpha = _alpha; _alpha = alpha; use_vertex_cache = false; use_edge_cache = false; return previous_alpha; } const Coord_type& get_alpha() const { // Returns the current alpha-value. return _alpha; } const Coord_type& get_nth_alpha(int n) const { // Returns the n-th alpha-value. // n < size() if (! _alpha_spectrum.empty()) return _alpha_spectrum[n]; else return UNDEFINED; } int number_of_alphas() const { // Returns the number of not necessary different alpha-values return _alpha_spectrum.size(); } //--------------------------------------------------------------------- private: // the dynamic version is not yet implemented // desactivate the triangulation member functions Vertex_handle insert(const Point& p); // Inserts point `p' in the alpha shape and returns the // corresponding vertex of the underlying Delaunay triangulation. // If point `p' coincides with an already existing vertex, this // vertex is returned and the alpha shape remains unchanged. // Otherwise, the vertex is inserted in the underlying Delaunay // triangulation and the associated intervals are updated. void remove(Vertex_handle v); // Removes the vertex from the underlying Delaunay triangulation. // The created hole is retriangulated and the associated intervals // are updated. //--------------------------------------------------------------------- public: Mode set_mode(Mode mode = GENERAL ) { // Sets `A' to its general or regularized version. Returns the // previous mode. Mode previous_mode = _mode; _mode = mode; return previous_mode; } Mode get_mode() const { // Returns whether `A' is general or regularized. return _mode; } //--------------------------------------------------------------------- private: void update_alpha_shape_vertex_list()const; //--------------------------------------------------------------------- void update_alpha_shape_edges_list() const; //--------------------------------------------------------------------- public: Alpha_shape_vertices_iterator alpha_shape_vertices_begin() const { if(!use_vertex_cache){ update_alpha_shape_vertex_list(); } return Alpha_shape_vertices_list.begin(); } // for backward compatibility Alpha_shape_vertices_iterator Alpha_shape_vertices_begin() { return alpha_shape_vertices_begin(); } //--------------------------------------------------------------------- Alpha_shape_vertices_iterator alpha_shape_vertices_end() const { return Alpha_shape_vertices_list.end(); } Alpha_shape_vertices_iterator Alpha_shape_vertices_end() const { return Alpha_shape_vertices_list.end(); } //--------------------------------------------------------------------- Alpha_shape_edges_iterator alpha_shape_edges_begin() const { if(!use_edge_cache){ update_alpha_shape_edges_list(); } return Alpha_shape_edges_list.begin(); } Alpha_shape_edges_iterator Alpha_shape_edges_begin() const { return alpha_shape_edges_begin(); } //--------------------------------------------------------------------- Alpha_shape_edges_iterator alpha_shape_edges_end() const { return Alpha_shape_edges_list.end(); } Alpha_shape_edges_iterator Alpha_shape_edges_end() const { return Alpha_shape_edges_list.end(); } public: // Traversal of the alpha-Values // // The alpha shape class defines an iterator that allows to // visit the sorted sequence of alpha-values. This iterator is // non-mutable and bidirectional. Its value type is Coord_type. Alpha_iterator alpha_begin() const { // Returns an iterator that allows to traverse the sorted sequence // of alpha-values of `A'. return _alpha_spectrum.begin(); } Alpha_iterator alpha_end() const { // Returns the corresponding past-the-end iterator. return _alpha_spectrum.end(); } Alpha_iterator alpha_find(const Coord_type& alpha) const { // Returns an iterator pointing to an element with alpha-value // `alpha', or the corresponding past-the-end iterator if such an // element is not found. return std::find(_alpha_spectrum.begin(), _alpha_spectrum.end(), alpha); } Alpha_iterator alpha_lower_bound(const Coord_type& alpha) const { // Returns an iterator pointing to the first element with // alpha-value not less than `alpha'. return std::lower_bound(_alpha_spectrum.begin(), _alpha_spectrum.end(), alpha); } Alpha_iterator alpha_upper_bound(const Coord_type& alpha) const { // Returns an iterator pointing to the first element with // alpha-value greater than `alpha'. return std::upper_bound(_alpha_spectrum.begin(), _alpha_spectrum.end(), alpha); } //--------------------- PREDICATES ----------------------------------- // the classification predicates take // amortized const time if STL_STD::HASH_TABLES // O(log #alpha_shape ) otherwise Classification_type classify(const Point& p ) const { return classify( p, get_alpha()); } Classification_type classify(const Point& p, const Coord_type& alpha) const { // Classifies a point `p' with respect to `A'. Locate_type type; int i; Face_handle pFace = locate(p, type, i); switch (type) { case VERTEX : return classify(pFace->vertex(i), alpha); case EDGE : return classify(pFace, i, alpha); case FACE : return classify(pFace, alpha); case OUTSIDE_CONVEX_HULL : case OUTSIDE_AFFINE_HULL : return EXTERIOR; default : return EXTERIOR; } } //--------------------------------------------------------------------- Classification_type classify(const Face_handle& f) const { // Classifies the face `f' of the underlying Delaunay // triangulation with respect to `A'. return classify(f, get_alpha()); } Classification_type classify(const Face_handle& f, const Coord_type& alpha) const { // Classifies the face `f' of the underlying Delaunay // triangulation with respect to `A'. // we consider open circles : // f->radius == alpha => f exterior // problem the operator [] is non-const if (is_infinite(f)) return EXTERIOR; // the version that computes the squared radius seems to be // much faster return (find_interval(f) < alpha) ? INTERIOR : EXTERIOR; } //--------------------------------------------------------------------- Classification_type classify(const Edge& edge) const { return classify(edge.first, edge.second, get_alpha()); } Classification_type classify(const Face_handle& f, int i) const { return classify(f, i, get_alpha()); } Classification_type classify(const Edge& edge, const Coord_type& alpha) const { return classify(edge.first, edge.second, alpha); } Classification_type classify(const Face_handle& f, int i, const Coord_type& alpha) const; //--------------------------------------------------------------------- Classification_type classify(const Vertex_handle& v) const { return classify(v, get_alpha()); } Classification_type classify(const Vertex_handle& v, const Coord_type& alpha) const; //--------------------- NB COMPONENTS --------------------------------- int number_solid_components() const { return number_of_solid_components(get_alpha()); } int number_of_solid_components() const { return number_of_solid_components(get_alpha()); } int number_solid_components(const Coord_type& alpha) const { return number_of_solid_components(get_alpha()); } int number_of_solid_components(const Coord_type& alpha) const; private: void traverse(const Face_handle& pFace, Marked_face_set& marked_face_set, const Coord_type alpha) const; class Line_face_circulator; //---------------------------------------------------------------------- public: Alpha_iterator find_optimal_alpha(int nb_components); private: Coord_type find_alpha_solid() const; //---------------------- PREDICATES ------------------------------------ private: bool is_attached(const Face_handle& f, int i) const { Bounded_side b = Gt().side_of_bounded_circle_2_object()(f->vertex(cw(i))->point(), f->vertex(ccw(i))->point(), f->vertex(i)->point()); return (b == ON_BOUNDED_SIDE) ? true : false; } //-------------------- GEOMETRIC PRIMITIVES ---------------------------- Coord_type squared_radius(const Face_handle& f) const { return Gt().compute_squared_radius_2_object()(f->vertex(0)->point(), f->vertex(1)->point(), f->vertex(2)->point()); } Coord_type squared_radius(const Face_handle& f, int i) const { return Gt().compute_squared_radius_2_object()(f->vertex(ccw(i))->point(), f->vertex(cw(i))->point()); } //--------------------------------------------------------------------- private: // prevent default copy constructor and default assigment Alpha_shape_2(const Alpha_shape_2& A); Alpha_shape_2& operator=(const Alpha_shape_2& A); }; //--------------------------------------------------------------------- //----------------------- MEMBER FUNCTIONS ----------------------------- //--------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::initialize_interval_face_map() { Coord_type alpha_f; // only finite faces for(Finite_faces_iterator face_it = faces_begin(); face_it != faces_end(); ++face_it) { alpha_f = squared_radius(face_it); _interval_face_map.insert(Interval_face(alpha_f, face_it)); // cross references face_it->set_alpha(alpha_f); } } //------------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::initialize_interval_edge_map() { Edge_iterator edge_it; Edge edge; // only finite faces for( edge_it = edges_begin(); edge_it != edges_end(); ++edge_it) { Interval3 interval; edge = (*edge_it); Face_handle pFace = edge.first; int i = edge.second; Face_handle pNeighbor = pFace->neighbor(i); int Neigh_i = pNeighbor->index(pFace); // not on the convex hull if(!is_infinite(pFace) && !is_infinite(pNeighbor)) { Coord_type squared_radius_Face = find_interval(pFace); Coord_type squared_radius_Neighbor = find_interval(pNeighbor); if (squared_radius_Neighbor < squared_radius_Face) { edge = Edge(pNeighbor, Neigh_i); Coord_type coord_tmp = squared_radius_Face; squared_radius_Face = squared_radius_Neighbor; squared_radius_Neighbor = coord_tmp; } interval = (is_attached(pFace, i) || is_attached(pNeighbor, Neigh_i)) ? make_triple(UNDEFINED, squared_radius_Face, squared_radius_Neighbor): make_triple(squared_radius(pFace, i), squared_radius_Face, squared_radius_Neighbor); } else { // on the convex hull if(is_infinite(pFace)) { if (!is_infinite(pNeighbor)) { interval = (is_attached(pNeighbor, Neigh_i)) ? make_triple(UNDEFINED, find_interval(pNeighbor), Infinity): make_triple(squared_radius(pNeighbor, Neigh_i), find_interval(pNeighbor), Infinity); edge = Edge(pNeighbor, Neigh_i); } else { // both faces are infinite by definition unattached // the edge is finite by construction CGAL_triangulation_precondition((is_infinite(pNeighbor) && is_infinite(pFace))); interval = make_triple(squared_radius(pFace, i), Infinity, Infinity); } } else { // is_infinite(pNeighbor) CGAL_triangulation_precondition((is_infinite(pNeighbor) && !is_infinite(pFace))); if (is_attached(pFace, i)) interval = make_triple(UNDEFINED, find_interval(pFace), Infinity); else interval = make_triple(squared_radius(pFace, i), find_interval(pFace), Infinity); } } _interval_edge_map.insert(Interval_edge(interval, edge)); // cross-links (edge.first)->set_ranges(edge.second,interval); } // Remark: // The interval_edge_map will be sorted as follows // first the attached edges on the convex hull // second not on the convex hull // third the un-attached edges on the convex hull // finally not on the convex hull // // if we are in regularized mode we should sort differently // by the second third first Key } //------------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::initialize_interval_vertex_map() { Coord_type alpha_mid_v; Coord_type alpha_max_v; Coord_type alpha_f; Finite_vertices_iterator vertex_it; for( vertex_it = finite_vertices_begin(); vertex_it != finite_vertices_end(); ++vertex_it) { Vertex_handle v = vertex_it; Face_handle f; alpha_max_v = Coord_type(0); alpha_mid_v = (!_interval_face_map.empty() ? (--_interval_face_map.end())->first : Coord_type(0)); //----------------- examine incident edges -------------------------- // // if we used Edelsbrunner and Muecke's definition // // singular means not incident to any higher-dimensional face // // regular means incident to a higher-dimensional face // Edge_circulator edge_circ = this->incident_edges(v), // edge_done(edge_circ); // do // { // f = (*edge_circ).first; // int i = (*edge_circ).second; // if (is_infinite(f, i)) // { // alpha_max_v = Infinity; // } // else // { // Interval3 interval3 = find_interval(const_Edge(f, i)); // alpha_mid_v = (interval3.first != UNDEFINED) ? // min(alpha_mid_v, interval3.first): // min(alpha_mid_v, interval3.second); // if (alpha_max_v != Infinity) // { // alpha_max_v = (interval3.third != Infinity) ? // max(alpha_max_v, interval3.third): // Infinity; // } // } // } // while(++edge_circ != edge_done); //-------------- examine incident faces -------------------------- // we use a different definition than Edelsbrunner and Muecke // singular means not incident to any 2-dimensional face // regular means incident to a 2-dimensional face Face_circulator face_circ = this->incident_faces(v), done = face_circ; if (!face_circ.is_empty()) { do { f = face_circ; if (is_infinite(f)) { alpha_max_v = Infinity; // continue; } else { alpha_f = find_interval(f); // if we define singular as not incident to a 2-dimensional // face alpha_mid_v = min(alpha_mid_v, alpha_f); if (alpha_max_v != Infinity) alpha_max_v = max(alpha_max_v, alpha_f); } } while(++face_circ != done); } Interval2 interval = std::make_pair(alpha_mid_v, alpha_max_v); _interval_vertex_map.insert(Interval_vertex(interval, vertex_it)); // cross references vertex_it->set_range(interval); } } //------------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::initialize_alpha_spectrum() { // skip the attached edges // <=> _interval_edge_map.first.first == UNDEFINED typename Interval_edge_map::iterator edge_it = std::upper_bound(_interval_edge_map.begin(), _interval_edge_map.end(), UNDEFINED, Less()); // merge the maps which is sorted and contains the alpha-values // of the unattached edges and the triangles. // eliminate duplicate values due to for example attached edges // merge and copy from STL since assignment should be function object typename Interval_face_map::iterator face_it = _interval_face_map.begin(); _alpha_spectrum.reserve(_interval_face_map.size() + _interval_edge_map.size()/ 2 ); // should be only the number of unattached edges // size_type nb_unattached_edges; // distance(edge_it, _interval_edge_map.end(), nb_unattached_edges); // however the distance function is expensive while (edge_it != _interval_edge_map.end() || face_it != _interval_face_map.end()) { if (face_it != _interval_face_map.end() && (edge_it == _interval_edge_map.end() || ((*face_it).first < (*edge_it).first.first))) { if (((_alpha_spectrum.empty() || _alpha_spectrum.back() < (*face_it).first)) && ((*face_it).first > Coord_type(0))) _alpha_spectrum.push_back((*face_it).first); face_it++; } else { if (((_alpha_spectrum.empty() || _alpha_spectrum.back() < (*edge_it).first.first)) && (((*edge_it).first.first) > Coord_type(0))) _alpha_spectrum.push_back((*edge_it).first.first); edge_it++; } } while (edge_it != _interval_edge_map.end()) { if (((_alpha_spectrum.empty() || _alpha_spectrum.back() < (*edge_it).first.first))&& (((*edge_it).first.first) > Coord_type(0))) _alpha_spectrum.push_back((*edge_it).first.first); edge_it++; } while (face_it != _interval_face_map.end()) { if (((_alpha_spectrum.empty() || _alpha_spectrum.back() < (*face_it).first))&& ((*face_it).first > Coord_type(0))) _alpha_spectrum.push_back((*face_it).first); face_it++; } } //------------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::update_alpha_shape_vertex_list()const { //typedef typename Alpha_shape_2
    ::Interval_vertex_map // Interval_vertex_map; typename Interval_vertex_map::const_iterator vertex_alpha_it; //const typename Alpha_shape_2
    ::Interval2* pInterval2; const Interval2* pInterval2; Vertex_handle v; Alpha_shape_vertices_list.clear(); // write the regular vertices for (vertex_alpha_it = _interval_vertex_map.begin(); vertex_alpha_it != _interval_vertex_map.end() && (*vertex_alpha_it).first.first < get_alpha(); ++vertex_alpha_it) { pInterval2 = &(*vertex_alpha_it).first; if((pInterval2->second >= get_alpha() || pInterval2->second == Infinity)) { // alpha must be larger than the min boundary // and alpha is smaller than the upper boundary // which might be infinity // write the vertex v = (*vertex_alpha_it).second; CGAL_triangulation_assertion((classify(v) == REGULAR)); Alpha_shape_vertices_list.push_back(v); } } if (get_mode() == Alpha_shape_2
    ::GENERAL) { // write the singular vertices for (; vertex_alpha_it != _interval_vertex_map.end(); ++vertex_alpha_it) { v = (*vertex_alpha_it).second; CGAL_triangulation_assertion((classify(v) == SINGULAR)); Alpha_shape_vertices_list.push_back(v); } } use_vertex_cache = true; } //------------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::update_alpha_shape_edges_list() const { // Writes the edges of the alpha shape `A' for the current $\alpha$-value // to the container where 'out' refers to. Returns an output iterator // which is the end of the constructed range. //typedef typename Alpha_shape_2
    ::Interval_edge_map Interval_edge_map; typename Interval_edge_map::const_iterator edge_alpha_it; //const typename Alpha_shape_2
    ::Interval3* pInterval; const Interval3* pInterval; Alpha_shape_edges_list.clear(); if (get_mode() == REGULARIZED) { // it is much faster looking at the sorted intervals // than looking at all sorted faces // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; CGAL_triangulation_assertion(pInterval->second != Infinity); // since this happens only for convex hull of dimension 2 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == REGULAR)); Alpha_shape_edges_list.push_back(Edge((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)); } } } else { // get_mode() == GENERAL ------------------------------------------- // draw the edges for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; if (pInterval->first == UNDEFINED) { CGAL_triangulation_assertion(pInterval->second != Infinity); // since this happens only for convex hull of dimension 2 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == REGULAR)); Alpha_shape_edges_list.push_back(Edge((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)); } } else { if(pInterval->third >= get_alpha() || pInterval->third == Infinity) { // if alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion(((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == REGULAR) || (classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == SINGULAR))); Alpha_shape_edges_list.push_back(Edge((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)); } } } } use_edge_cache = true; } //------------------------------------------------------------------------- template < class Dt > typename Alpha_shape_2
    ::Classification_type Alpha_shape_2
    ::classify(const Face_handle& f, int i, const Coord_type& alpha) const { // Classifies the edge `e' of the underlying Delaunay // triangulation with respect to `A'. // the version that uses a simplified version without crosslinks // is much slower if (is_infinite(f, i)) return EXTERIOR; // we store only finite edges in _edge_interval_map Interval3 interval = find_interval(const_Edge(f, i)); // (*(_edge_interval_map.find(const_Edge(f, i)))).second; if (alpha <= interval.second) { if (get_mode() == REGULARIZED || interval.first == UNDEFINED || alpha <= interval.first) return EXTERIOR; else // alpha > interval.first return SINGULAR; } else { // alpha > interval.second if (interval.third == Infinity || alpha <= interval.third) return REGULAR; else // alpha > interval.third return INTERIOR; } } //------------------------------------------------------------------------- template < class Dt > typename Alpha_shape_2
    ::Classification_type Alpha_shape_2
    ::classify(const Vertex_handle& v, const Coord_type& alpha) const { // Classifies the vertex `v' of the underlying Delaunay // triangulation with respect to `A'. Interval2 interval = v->get_range(); if (alpha <= interval.first) { if (get_mode() == REGULARIZED) return EXTERIOR; else // general => vertices are never exterior return SINGULAR; } else { // alpha > interval.first if (interval.second == Infinity || alpha <= interval.second) return REGULAR; else // alpha > interval.second return INTERIOR; } } //------------------------------------------------------------------------- template < class Dt > int Alpha_shape_2
    ::number_of_solid_components(const Coord_type& alpha) const { // Determine the number of connected solid components typedef typename Marked_face_set::Data Data; Marked_face_set marked_face_set(false); Finite_faces_iterator face_it; int nb_solid_components = 0; if (number_of_vertices()==0) return 0; // only finite faces for( face_it = faces_begin(); face_it != faces_end(); ++face_it) { Face_handle pFace = face_it; CGAL_triangulation_postcondition( pFace != NULL); if (classify(pFace, alpha) == INTERIOR){ Data& data = marked_face_set[pFace]; if(data == false) { // we traverse only interior faces traverse(pFace, marked_face_set, alpha); nb_solid_components++; } } } return nb_solid_components; } //------------------------------------------------------------------------- template < class Dt > void Alpha_shape_2
    ::traverse(const Face_handle& pFace, Marked_face_set& marked_face_set, const Coord_type alpha) const { typedef typename Marked_face_set::Data Data; std::list faces; faces.push_back(pFace); Face_handle pNeighbor; while(! faces.empty()){ pFace = faces.back(); faces.pop_back(); for (int i=0; i<=3; i++) { pNeighbor = pFace->neighbor(i); assert(pNeighbor != NULL); if (classify(pNeighbor, alpha) == INTERIOR){ Data& data = marked_face_set[pNeighbor]; if(data == false){ data = true; faces.push_back(pNeighbor); } } } } } //------------------------------------------------------------------------- template < class Dt > typename Alpha_shape_2
    ::Alpha_iterator Alpha_shape_2
    ::find_optimal_alpha(int nb_components) { // find the minimum alpha that satisfies the properties // (1) nb_components solid components // (2) all data points on the boundary or in its interior Coord_type alpha = find_alpha_solid(); // from this alpha on the alpha_solid satisfies property (2) Alpha_iterator first = alpha_lower_bound(alpha); if (number_of_solid_components(alpha) == nb_components) { if ((first+1) < alpha_end()) return (first+1); else return first; } // do binary search on the alpha values // number_of_solid_components() is a monotone function // if we start with find_alpha_solid Alpha_iterator last = alpha_end(); Alpha_iterator middle; std::ptrdiff_t len = last - first - 1; std::ptrdiff_t half; while (len > 0) { half = len / 2; middle = first + half; #ifdef CGAL_DEBUG_ALPHA_SHAPE_2 std::cout << "first : " << *first << " last : " << *(first+len) << " mid : " << *middle << " nb comps : " << number_of_solid_components(*middle) << std::endl; #endif // CGAL_DEBUG_ALPHA_SHAPE_2 if (number_of_solid_components(*middle) > nb_components) { first = middle + 1; len = len - half - 1; } else { // number_of_solid_components(*middle) <= nb_components len = half; } } if ((first+1) < alpha_end()) return (first+1); else return first; } //------------------------------------------------------------------------- template < class Dt > typename Alpha_shape_2
    ::Coord_type Alpha_shape_2
    ::find_alpha_solid() const { // compute the minumum alpha such that all data points // are either on the boundary or in the interior // not necessarily connected // starting point for searching // takes O(#alpha_shape) time Coord_type alpha_solid = 0; Finite_vertices_iterator vertex_it; // only finite vertices for( vertex_it = finite_vertices_begin(); vertex_it != finite_vertices_end(); ++vertex_it) { Coord_type alpha_min_v = (--_interval_face_map.end())->first; Face_circulator face_circ = this->incident_faces(vertex_it); Face_circulator done = face_circ; do { Face_handle f = face_circ; if (! is_infinite(f)) alpha_min_v = min(find_interval(f), alpha_min_v); } while (++face_circ != done); alpha_solid = max(alpha_min_v, alpha_solid); } return alpha_solid; } //------------------------------------------------------------------------- template < class Dt > std::ostream& Alpha_shape_2
    ::op_ostream(std::ostream& os) const { typedef typename Alpha_shape_2
    ::Interval_vertex_map Interval_vertex_map ; typename Interval_vertex_map::const_iterator vertex_alpha_it; const typename Alpha_shape_2
    ::Interval2* pInterval2; Unique_hash_map< Vertex_handle , int > V; int number_of_vertices = 0; typedef typename Alpha_shape_2
    ::Interval_edge_map Interval_edge_map; typename Interval_edge_map::const_iterator edge_alpha_it; const typename Alpha_shape_2
    ::Interval3* pInterval; if (get_mode() == Alpha_shape_2
    ::REGULARIZED) { typename Alpha_shape_2
    ::Vertex_handle v; for (vertex_alpha_it = _interval_vertex_map.begin(); vertex_alpha_it != _interval_vertex_map.end() && (*vertex_alpha_it).first.first < get_alpha(); ++vertex_alpha_it) { pInterval2 = &(*vertex_alpha_it).first; #ifdef CGAL_DEBUG_ALPHA_SHAPE_2 typename Alpha_shape_2
    ::Coord_type alpha = get_alpha(); typename Alpha_shape_2
    ::Coord_type alpha_mid = pInterval2->first; typename Alpha_shape_2
    ::Coord_type alpha_max = pInterval2->second; #endif // CGAL_DEBUG_ALPHA_SHAPE_2 if((pInterval2->second >= get_alpha() || pInterval2->second == Infinity)) { // alpha must be larger than the min boundary // and alpha is smaller than the upper boundary // which might be infinity // write the vertex v = (*vertex_alpha_it).second; CGAL_triangulation_assertion((classify(v) == Alpha_shape_2
    ::REGULAR)); // if we used Edelsbrunner and Muecke's definition // regular means incident to a higher-dimensional face // we would write too many vertices V[v] = number_of_vertices++; os << v->point() << std::endl; } } // the vertices are oriented counterclockwise typename Alpha_shape_2
    ::Face_handle f; int i; for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; CGAL_triangulation_assertion(pInterval->second != Infinity); // since this happens only for convex hull of dimension 1 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary f = (*edge_alpha_it).second.first; i = (*edge_alpha_it).second.second; // assure that all vertices are in ccw order if (classify(f) == Alpha_shape_2
    ::EXTERIOR) { // take the reverse face typename Alpha_shape_2
    ::Face_handle pNeighbor = f->neighbor(i); i = pNeighbor->index(f); f = pNeighbor; } CGAL_triangulation_assertion((classify(f) == Alpha_shape_2
    ::INTERIOR)); CGAL_triangulation_assertion((classify(f, i) == Alpha_shape_2
    ::REGULAR)); os << V[f->vertex(f->ccw(i))] << ' ' << V[f->vertex(f->cw(i))] << std::endl; } } } else { // get_mode() == GENERAL ----------------------------------------- typename Alpha_shape_2
    ::Vertex_handle v; // write the regular vertices for (vertex_alpha_it = _interval_vertex_map.begin(); vertex_alpha_it != _interval_vertex_map.end() && (*vertex_alpha_it).first.first < get_alpha(); ++vertex_alpha_it) { pInterval2 = &(*vertex_alpha_it).first; if((pInterval2->second >= get_alpha() || pInterval2->second == Infinity)) { // alpha must be larger than the min boundary // and alpha is smaller than the upper boundary // which might be infinity // write the vertex v = (*vertex_alpha_it).second; CGAL_triangulation_assertion((classify(v) == Alpha_shape_2
    ::REGULAR)); V[v] = number_of_vertices++; os << v->point() << std::endl; } } // write the singular vertices for (; vertex_alpha_it != _interval_vertex_map.end(); ++vertex_alpha_it) { v = (*vertex_alpha_it).second; CGAL_triangulation_assertion((classify(v) == Alpha_shape_2
    ::SINGULAR)); V[v] = number_of_vertices++; os << v->point() << std::endl; } // the vertices are oriented counterclockwise typename Alpha_shape_2
    ::Face_handle f; int i; for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; #ifdef CGAL_DEBUG_ALPHA_SHAPE_2 typename Alpha_shape_2
    ::Coord_type alpha = get_alpha(); typename Alpha_shape_2
    ::Coord_type alpha_min = pInterval->first; typename Alpha_shape_2
    ::Coord_type alpha_mid = pInterval->second; typename Alpha_shape_2
    ::Coord_type alpha_max = pInterval->third; #endif // CGAL_DEBUG_ALPHA_SHAPE_2 if(pInterval->third >= get_alpha() || pInterval->third == Infinity) { // if alpha is smaller than the upper boundary // which might be infinity // visualize the boundary f = (*edge_alpha_it).second.first; i = (*edge_alpha_it).second.second; // write the regular edges if (pInterval->second != Infinity && pInterval->second < get_alpha()) { CGAL_triangulation_assertion((classify(f, i) == Alpha_shape_2
    ::REGULAR)); // assure that all vertices are in ccw order if (classify(f) == Alpha_shape_2
    ::EXTERIOR) { // take the reverse face typename Alpha_shape_2
    ::Face_handle pNeighbor = f->neighbor(i); i = pNeighbor->index(f); f = pNeighbor; } CGAL_triangulation_assertion((classify(f) == Alpha_shape_2
    ::INTERIOR)); os << V[f->vertex(f->ccw(i))] << ' ' << V[f->vertex(f->cw(i))] << std::endl; } else { // pInterval->second == Infinity || // pInterval->second >= get_alpha()) // pInterval->second == Infinity happens only for convex hull // of dimension 1 thus singular // write the singular edges if (pInterval->first != UNDEFINED) { CGAL_triangulation_assertion((classify(f, i) == Alpha_shape_2
    ::SINGULAR)); os << V[f->vertex(f->ccw(i))] << ' ' << V[f->vertex(f->cw(i))] << std::endl; } } } } } return os; } //------------------------------------------------------------------- template < class Dt > std::ostream& operator<<(std::ostream& os, const Alpha_shape_2
    & A) { return A.op_ostream(os); } //------------------------------------------------------------------- template < class Dt > std::list::Point> Alpha_shape_2
    ::Output () { typename Interval_edge_map::const_iterator edge_alpha_it; const Interval3* pInterval; std::list L; if (get_mode() == REGULARIZED) { // it is much faster looking at the sorted intervals // than looking at all sorted faces // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; if (pInterval->second != Infinity) { // since this happens only for convex hull of dimension 1 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == REGULAR)); // if we used Edelsbrunner and Muecke's definition // regular means incident to a higher-dimensional face // thus we would write to many vertices L.push_back((segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)) .source()); L.push_back((segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)) .target()); } } } } else { // get_mode() == GENERAL // draw the edges for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; if (pInterval->first == UNDEFINED) { CGAL_triangulation_assertion(pInterval->second != Infinity); // since this happens only for convex hull of dimension 1 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == REGULAR)); L.push_back((segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)) .source()); L.push_back((segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)) .target()); } } else { if(pInterval->third >= get_alpha() || pInterval->third == Infinity) { // if alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion(((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == REGULAR) || (classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == SINGULAR))); L.push_back((segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)) .source()); L.push_back((segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second)) .target()); } } } } return L; } CGAL_END_NAMESPACE #ifdef CGAL_ALPHA_WINDOW_STREAM #include #endif #endif //CGAL_ALPHA_SHAPE_2_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Iso_rectangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Iso_rectangle_20000644000175000017500000002047511344301500031142 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Iso_rectangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_LINE_2_ISO_RECTANGLE_2_INTERSECTION_H #define CGAL_LINE_2_ISO_RECTANGLE_2_INTERSECTION_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Line_2_Iso_rectangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Line_2_Iso_rectangle_2_pair() ; Line_2_Iso_rectangle_2_pair(typename K::Line_2 const *pt, typename K::Iso_rectangle_2 const *iso); ~Line_2_Iso_rectangle_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: mutable bool _known; mutable Intersection_results _result; mutable typename K::FT _min, _max; typename K::Point_2 _ref_point; typename K::Vector_2 _dir; typename K::Point_2 _isomin; typename K::Point_2 _isomax; }; template inline bool do_intersect(const typename CGAL_WRAP(K)::Line_2 &p1, const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2, const K&) { typedef Line_2_Iso_rectangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2, const typename CGAL_WRAP(K)::Line_2 &p1, const K& k) { return CGALi::do_intersect(p1, p2, k); } template Line_2_Iso_rectangle_2_pair:: Line_2_Iso_rectangle_2_pair() { _known = false; } template Line_2_Iso_rectangle_2_pair:: Line_2_Iso_rectangle_2_pair(typename K::Line_2 const *line, typename K::Iso_rectangle_2 const *iso) : _known(false), _ref_point(line->point()), _dir(line->direction().to_vector()), _isomin(iso->min()), _isomax(iso->max()) {} template typename Line_2_Iso_rectangle_2_pair::Intersection_results Line_2_Iso_rectangle_2_pair::intersection_type() const { typedef typename K::Line_2 line_t; if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; typedef typename K::FT FT; typedef typename K::RT RT; bool all_values = true; typename K::Construct_cartesian_const_iterator_2 construct_cccit; typename K::Cartesian_const_iterator_2 ref_point_it = construct_cccit(_ref_point); typename K::Cartesian_const_iterator_2 end = construct_cccit(_ref_point, 0); typename K::Cartesian_const_iterator_2 isomin_it = construct_cccit(_isomin); typename K::Cartesian_const_iterator_2 isomax_it = construct_cccit(_isomax); for (unsigned int i=0; ref_point_it != end; ++i, ++ref_point_it, ++isomin_it, ++isomax_it) { if (_dir.homogeneous(i) == RT(0)) { if (*ref_point_it < *isomin_it) { _result = NO; return NO; } if (*ref_point_it > *isomax_it) { _result = NO; return NO; } } else { FT newmin, newmax; if (_dir.homogeneous(i) > RT(0)) { newmin = (*isomin_it - *ref_point_it) / _dir.cartesian(i); newmax = (*isomax_it - *ref_point_it) / _dir.cartesian(i); } else { newmin = (*isomax_it - *ref_point_it) / _dir.cartesian(i); newmax = (*isomin_it - *ref_point_it) / _dir.cartesian(i); } if (all_values) { _min = newmin; _max = newmax; } else { if (newmin > _min) _min = newmin; if (newmax < _max) _max = newmax; if (_max < _min) { _result = NO; return NO; } } all_values = false; } } CGAL_kernel_assertion(!all_values); if (_max == _min) { _result = POINT; return POINT; } _result = SEGMENT; return SEGMENT; } template bool Line_2_Iso_rectangle_2_pair:: intersection(typename K::Point_2 &result) const { typename K::Construct_translated_point_2 translated_point; typename K::Construct_scaled_vector_2 construct_scaled_vector; if (!_known) intersection_type(); if (_result != POINT) return false; result = translated_point(_ref_point, construct_scaled_vector(_dir, _min)); return true; } template bool Line_2_Iso_rectangle_2_pair:: intersection(typename K::Segment_2 &result) const { typename K::Construct_segment_2 construct_segment_2; typename K::Construct_translated_point_2 translated_point; typename K::Construct_scaled_vector_2 construct_scaled_vector; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = construct_segment_2(translated_point(_ref_point, construct_scaled_vector(_dir,_min)), translated_point(_ref_point, construct_scaled_vector(_dir,_max))); return true; } template Object intersection(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const K&) { typename K::Construct_object_2 construct_object; typedef Line_2_Iso_rectangle_2_pair is_t; is_t ispair(&line, &iso); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 ipt; ispair.intersection(ipt); return construct_object(ipt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return construct_object(iseg); } } } template inline Object intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { return CGALi::intersection(line, iso, k); } template class Iso_rectangle_2_Line_2_pair : public Line_2_Iso_rectangle_2_pair { public: Iso_rectangle_2_Line_2_pair( typename K::Iso_rectangle_2 const *iso, typename K::Line_2 const *line) : Line_2_Iso_rectangle_2_pair(line, iso) {} }; } // namespace CGALi template inline bool do_intersect( const Line_2 &p1, const Iso_rectangle_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline bool do_intersect( const Iso_rectangle_2 &p1, const Line_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p2, p1); } template Object intersection(const Line_2 &line, const Iso_rectangle_2 &iso) { typedef typename K::Intersect_2 Intersect; return Intersect()(line, iso); } template inline Object intersection(const Iso_rectangle_2 &iso, const Line_2 &line) { typedef typename K::Intersect_2 Intersect; return Intersect()(line, iso); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Double_map.h0000644000175000017500000001115711344301500027245 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Double_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DOUBLE_MAP_H #define CGAL_DOUBLE_MAP_H #include #include #include #include namespace CGAL { template , class _Reverse_order = std::less<_Data> > class Double_map { public: typedef _Key Key; typedef _Data Data; typedef _Direct_order Direct_order; typedef _Reverse_order Reverse_order; typedef std::map Direct_func; typedef std::multimap Reverse_func; typedef std::pair Direct_entry; typedef std::pair Reverse_entry; typedef typename Direct_func::size_type size_type; typedef typename Reverse_func::iterator reverse_iterator; typedef typename Direct_func::iterator direct_iterator; typedef reverse_iterator iterator; typedef typename Direct_func::const_iterator direct_const_iterator; typedef direct_const_iterator const_iterator; private: // Private members Direct_func direct_func; Reverse_func reverse_func; public : // The default constructor Double_map () {} // Queries bool empty() const { CGAL_assertion(is_valid()); return(direct_func.empty()); } size_type size() const { CGAL_assertion(is_valid()); return direct_func.size(); } bool is_valid() const { return(direct_func.size()==reverse_func.size()); } void clear() { direct_func.clear(); reverse_func.clear(); } // Assignation bool insert(const Key& k, const Data& d) { std::pair direct_result = direct_func.insert(Direct_entry(k, d)); if (direct_result.second != true) return false; reverse_func.insert(Reverse_entry(d, k)); CGAL_assertion(is_valid()); return(true); } void erase(Key& k); // Access reverse_iterator front() { CGAL_assertion(is_valid() && !empty()); return(reverse_func.begin()); } void pop_front() { CGAL_assertion(is_valid()); reverse_iterator rit = reverse_func.begin(); direct_iterator pos = direct_func.find(rit->second); assert(pos != direct_func.end()); direct_func.erase(pos); reverse_func.erase(rit); CGAL_assertion(is_valid()); } const_iterator begin() const { return direct_func.begin(); } const_iterator end() const { return direct_func.end(); } class Second_is { Key k; public: Second_is(const Key& _k): k(_k) {}; bool operator()(const Reverse_entry& p) const { return p.second == k; } }; void dump_direct_func(std::ostream& out) { for(typename Direct_func::iterator it = direct_func.begin(); it != direct_func.end(); ++it) out << it->second << " " << "(" << it->first->vertex(0)->point() << ", " << it->first->vertex(1)->point() << ", " << it->first->vertex(2)->point() << ")" << std::endl; } void dump_reverse_func(std::ostream& out) { for(typename Reverse_func::iterator it = reverse_func.begin(); it != reverse_func.end(); ++it) out << it->first << " " << "(" << it->second->vertex(0)->point() << ", " << it->second->vertex(1)->point() << ", " << it->second->vertex(2)->point() << ")" << std::endl; } }; template void Double_map<_Key, _Data, _Direct_order, _Reverse_order>:: erase(Key& k) { direct_iterator pos = direct_func.find(k); if (pos == direct_func.end()) return; else { const Data& d = pos->second; reverse_iterator lb = reverse_func.lower_bound(d); reverse_iterator ub = reverse_func.upper_bound(d); direct_func.erase(pos); reverse_func.erase(std::find_if(lb, ub, Second_is(k))); } CGAL_assertion(is_valid()); } } // end namespace CGAL #endif // CGAL_DOUBLE_MAP_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_tree_d.h0000644000175000017500000004605311344301500030125 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_tree_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef CGAL_Segment_tree_d__ #define CGAL_Segment_tree_d__ #include #include #include #include #include #include // A d-dimensional Segment Tree or a multilayer tree consisting of a Segment // and other trees that are derived public Tree_base can be constructed within this class. // C_Data: container class which contains the d-dim data the tree holds. // C_Window: Query window -- a d-dimensional interval // C_Interface: Interface for the class with functions that allow to access the // data. cf. file _interface.h for the requirements. CGAL_BEGIN_NAMESPACE template class Segment_tree_d; template struct Segment_tree_node: public Tree_node_base { typedef C_Data Data; typedef C_Window Window; typedef typename C_Interface::Key Key; typedef C_Interface Interface; typedef Tree_base< C_Data, C_Window> Tree_base_type; std::list< C_Data> objects; Key left_key; Key right_key; Tree_base *sublayer; public: friend class Segment_tree_d< C_Data, C_Window, C_Interface>; Segment_tree_node() : Tree_node_base(), sublayer(0) {} Segment_tree_node(const Key& p_left_key, const Key& p_right_key) : Tree_node_base(), left_key(p_left_key), right_key(p_right_key), sublayer(0) {} Segment_tree_node(Segment_tree_node * p_left, Segment_tree_node * p_right, const Key& p_left_key, const Key& p_right_key) : Tree_node_base(p_left,p_right), left_key(p_left_key), right_key(p_right_key), sublayer(0) {} ~Segment_tree_node(){ objects.clear(); if (sublayer != 0)//(tree_base_type *) delete sublayer; } }; template class Segment_tree_d: public Tree_base< C_Data, C_Window> { private: typedef C_Data Data; typedef C_Window Window; typedef typename C_Interface::Key Key; typedef C_Interface Interface; public: typedef Tree_base tbt; protected: Tree_base *sublayer_tree; // type of a vertex // struct Segment_tree_node; friend class Segment_tree_node; typedef Segment_tree_node Segment_tree_node_t; typedef Segment_tree_node *link_type; static std::allocator alloc; C_Interface interface; bool is_built; bool is_less_equal(const Key& x, const Key& y) const { return (!interface.comp(y,x)); } static link_type left(link_type x) { return static_cast(x->left_link); } static link_type right(link_type x) { return static_cast(x->right_link); } static link_type parent(link_type x) { return static_cast( x->parent_link); } link_type header; link_type node; link_type rightmost(){return right(header);} link_type leftmost(){return left(header);} link_type root() const{ if(header!=0) return static_cast(header->parent_link); return 0; } // returns true, if the object lies inside of win bool is_inside( C_Window const &win, C_Data const& object) const { if(is_less_equal(interface.get_left_win(win), interface.get_left(object)) && is_less_equal(interface.get_right(object), interface.get_right_win(win))) { return sublayer_tree->is_inside(win,object); } return false; } // this tree is not a recursion anchor bool is_anchor() const { return false;} void insert_segment(link_type v, C_Data& element) { if ((is_less_equal(interface.get_left(element), v->left_key) && is_less_equal(v->right_key, interface.get_right(element))) || left(v)==TREE_BASE_NULL) v->objects.push_back( element); else { if (!is_less_equal((*left(v)).right_key, interface.get_left(element))) insert_segment(left(v), element); if (!is_less_equal(interface.get_right(element), (*right(v)).left_key)) insert_segment(right(v), element); } } // according to the list of elements at vertex v, a sublayer tree for these // elements is created. void build_next_dimension(link_type v) { if(left(v)!=TREE_BASE_NULL) { build_next_dimension(left(v)); build_next_dimension(right(v)); } if(! v->objects.empty()) { typename std::list< C_Data>::iterator sub_first = v->objects.begin(); typename std::list< C_Data>::iterator sub_last = v->objects.end(); Tree_base *g = sublayer_tree->clone(); g->make_tree(sub_first, sub_last); v->sublayer = g; if (!v->sublayer->is_anchor()) { v->objects.clear(); } } } link_type new_Segment_tree_node_t(link_type l, link_type r, const Key& kl, const Key& kr) { Segment_tree_node_t node(l,r,kl,kr); Segment_tree_node_t* node_ptr = alloc.allocate(1); alloc.construct(node_ptr, node); return node_ptr; } link_type new_Segment_tree_node_t(const Key& kl, const Key& kr) { Segment_tree_node_t node(kl,kr); Segment_tree_node_t* node_ptr = alloc.allocate(1); alloc.construct(node_ptr, node); return node_ptr; } link_type new_Segment_tree_node_t() { Segment_tree_node_t node; Segment_tree_node_t* node_ptr = alloc.allocate(1); alloc.construct(node_ptr, node); return node_ptr; } // the skeleton of the segment tree is constructed here. void build_segment_tree(int n, link_type& leftchild, link_type& rightchild, link_type& prevchild, link_type& leftmostlink, int& index, int last, const std::vector& keys) { // only two elements ==> two leaves and a parent is constructed if (n==2) { link_type vright; link_type vleft = new_Segment_tree_node_t (keys[index], keys[index+1]); index++; if(index+1>last) { vright = new_Segment_tree_node_t (keys[index], keys[index]); } else { vright = new_Segment_tree_node_t (keys[index], keys[index+1]); } index++; link_type vparent = new_Segment_tree_node_t (vleft, vright, vleft->left_key, vright->right_key); vleft->parent_link = vparent; vright->parent_link = vparent; leftchild = vleft; rightchild = vright; prevchild = vparent; if(leftmostlink == TREE_BASE_NULL) leftmostlink = leftchild; } else // only one element ==> one leaf is constructed if(n==1) { link_type vright; if(index+1 > last){ vright = new_Segment_tree_node_t (keys[index], keys[index]); } else{ vright = new_Segment_tree_node_t (keys[index], keys[index+1]); } index++; prevchild = vright; rightchild = vright; } else { // recursiv call for the construction. the interval is devided. build_segment_tree(n - (int)n/2, leftchild, rightchild, prevchild, leftmostlink, index, last, keys); link_type vparent = new_Segment_tree_node_t (prevchild, TREE_BASE_NULL, prevchild->left_key, prevchild->left_key); prevchild->parent_link = vparent; build_segment_tree((int)n/2, leftchild, rightchild, prevchild, leftmostlink, index, last, keys); vparent->right_link = prevchild; prevchild->parent_link = vparent; vparent->right_key = prevchild->right_key; prevchild = vparent; } } void delete_tree(link_type v) { if(v->left_link!=TREE_BASE_NULL) { delete_tree(left(v)); delete_tree(right(v)); } delete_node(v); } void delete_node(Segment_tree_node_t* node_ptr) { alloc.destroy(node_ptr); alloc.deallocate(node_ptr,1); } // all elements that contain win are inserted into result template inline A enclosing_query( C_Window const &win, A result, link_type v) { if(is_less_equal(interface.get_right_win(win), v->left_key) || is_less_equal(v->right_key,interface.get_left_win(win))) return result; if (v->sublayer!=0 && (!v->sublayer->is_anchor())) //(tree_base_type *) { Tree_base *T = v->sublayer; std::list< C_Data> tmp_result; std::back_insert_iterator > tmp_back_inserter = std::back_inserter(tmp_result); T->enclosing_query(win, tmp_back_inserter); typename std::list< C_Data>::iterator tmp = tmp_result.begin(); while(tmp!=tmp_result.end()) { if(is_less_equal(interface.get_left(*tmp), interface.get_left_win(win))) { if(is_less_equal(interface.get_right_win(win), interface.get_right(*tmp))) if(is_less_equal(v->left_key, interface.get_left_win(win))) *result++=(*tmp); } tmp++; } } else { if(! v->objects.empty()) { typename std::list< C_Data>::iterator j=v->objects.begin(); while (j!= v->objects.end()) { if(is_less_equal(interface.get_left(*j), interface.get_left_win(win))) { if(is_less_equal(interface.get_right_win(win), interface.get_right(*j))) if(is_less_equal(v->left_key, interface.get_left_win(win))) *result++=(*j); } j++; } } } if(left(v)) { enclosing_query(win, result, left(v)); enclosing_query(win, result, right(v)); } return result; } // all elements that habe non empty intersection with win are put into result template inline A window_query( C_Window const &win, A result, const link_type& v) // af: was not const { if(is_less_equal(interface.get_right_win(win), v->left_key) || is_less_equal(v->right_key,interface.get_left_win(win))) return result; if (v->sublayer!=0 && (!v->sublayer->is_anchor())) //(tree_base_type *) { Tree_base *T = v->sublayer; std::list< C_Data> tmp_result; std::back_insert_iterator > tmp_back_inserter = std::back_inserter(tmp_result); T->window_query(win, tmp_back_inserter); typename std::list< C_Data>::iterator tmp = tmp_result.begin(); while(tmp!=tmp_result.end()) { if(interface.comp(interface.get_left(*tmp), interface.get_left_win(win))) { if(is_less_equal(v->left_key, interface.get_left_win(win))){ *result++=(*tmp); } } else { if(is_less_equal(v->left_key,interface.get_left(*tmp))){ *result++=(*tmp); } } tmp++; } } else { if(! v->objects.empty()) { typename std::list< C_Data>::iterator j=v->objects.begin(); while (j!= v->objects.end()) { if(interface.comp(interface.get_left(*j), interface.get_left_win(win))) { if(is_less_equal(v->left_key, interface.get_left_win(win))) { *result++=(*j); } } else if(is_less_equal(v->left_key,interface.get_left(*j))) { *result++=(*j); } j++; } } } if(left(v)) { window_query(win, result, left(v)); window_query(win, result, right(v)); } return result; } bool is_valid(const link_type& v) const // af:was not const reference { if (v->sublayer != 0)//(tree_base_type *) { Tree_base *T=v->sublayer; if(! T->is_valid()) return false; } if(left(v)!=TREE_BASE_NULL) { if(!is_valid(left(v))) return false; if(!is_valid(right(v))) return false; } if(! v->objects.empty()) { // true falls das Object das Segment enthaelt, // der parent aber das Segment nicht enthaelt. typename std::list< C_Data>::iterator j=v->objects.begin(); link_type parent_of_v = parent(v); while (j!= v->objects.end()) { if(!is_less_equal(interface.get_left(*j), v->left_key)) return false; if(!is_less_equal( v->right_key, interface.get_right(*j))) return false; if (parent_of_v != root()) if((is_less_equal(interface.get_left(*j), parent_of_v->left_key))&& (is_less_equal( parent_of_v->right_key, interface.get_right(*j)))) return false; j++; } } return true; } public: // construction of a tree Segment_tree_d(Segment_tree_d const &sub_tree, bool): sublayer_tree(sub_tree.sublayer_tree->clone()), is_built(false), header(TREE_BASE_NULL) {} // construction of a tree, definition of the prototype of sublayer tree Segment_tree_d(Tree_base const &sub_tree): sublayer_tree(sub_tree.clone()), is_built(false), header(TREE_BASE_NULL) {} // destruction ~Segment_tree_d() { link_type v=root(); if(v!=TREE_BASE_NULL) delete_tree(v); if (header!=0) delete_node(header); if(sublayer_tree!=0) delete sublayer_tree; } // clone creates a prototype Tree_base *clone() const { return new Segment_tree_d(*this, true); } bool make_tree(const typename std::list< C_Data>::iterator& beg, const typename std::list< C_Data>::iterator& end, typename tbt::lit * =0){ return make_tree_impl(beg,end); } #ifdef stlvector bool make_tree(const typename std::vector< C_Data>::iterator& beg, const typename std::vector< C_Data>::iterator& end, typename tbt::vbit * =0){ return make_tree_impl(beg,end); } #endif #ifdef carray bool make_tree(const C_Data *beg, const C_Data *end){ return make_tree_impl(beg,end); } #endif // the tree is build according to Data [first,last) template inline bool make_tree_impl(const A& first, const A& last) { if(!is_built) is_built = true; else return false; A count = first; int n=0; std::vector keys(2* std::distance(first, last)); while(count!=last) { if (interface.comp(interface.get_left(*count), interface.get_right(*count))) { keys[n++]=interface.get_left(*count); keys[n++]=interface.get_right(*count); } else { CGAL_Tree_warning_msg(interface.comp(interface.get_left(*count), interface.get_right(*count)), "invalid segment ignored"); } count++; } if(n==0) { is_built = false; return true; } std::sort(keys.begin(), keys.end(), interface.comp); std::vector keys2(2*n + 1); int m=0; int num=1; keys2[0]=keys[0]; for(m=1;mright_link = rightchild; header->parent_link = prevchild; prevchild->parent_link = prevchild; header->left_link = leftmostlink; A current = first; link_type r = root(); do { if (interface.comp(interface.get_left(*current), interface.get_right(*current))) insert_segment(r, *current); }while(++current!=last); link_type v=root(); build_next_dimension(v); return true; } std::back_insert_iterator< std::list< C_Data> > window_query ( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, typename tbt::lbit * =0){ return window_query_impl(win,out); } std::back_insert_iterator< std::vector< C_Data> > window_query ( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out, typename tbt::vbit * =0){ return window_query_impl(win,out); } #ifdef carray C_Data *window_query( C_Window const &win, C_Data *out){ return window_query_impl(win,out); } #endif #ifdef ostreamiterator std::ostream_iterator< C_Data> window_query( C_Window const &win, std::ostream_iterator< C_Data> out, typename tbt::oit *dummy=0){ return window_query_impl(win,out); } #endif // all elements that ly inside win are inserted into result template inline A window_query_impl( C_Window const &win, A result,typename tbt::lbit * =0) { if(is_less_equal(interface.get_right_win(win), interface.get_left_win(win))) { CGAL_Tree_warning_msg(interface.comp(interface.get_right_win(win), interface.get_left_win(win)), "invalid window -- query ignored"); return result; } link_type v = root(); if(v!=TREE_BASE_NULL) return window_query(win, result, v); return result; } std::back_insert_iterator< std::list< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, typename tbt::lbit * =0){ return enclosing_query_impl(win,out); } std::back_insert_iterator< std::vector< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out, typename tbt::vbit * =0){ return enclosing_query_impl(win,out); } #ifdef carray C_Data *enclosing_query( C_Window const &win, C_Data *out){ return enclosing_query_impl(win,out); } #endif #ifdef ostreamiterator std::ostream_iterator< C_Data> enclosing_query( C_Window const &win, std::ostream_iterator< C_Data> out, typename tbt::oit *dummy=0){ return enclosing_query_impl(win,out); } #endif // all objects that enclose win are inserted into result template inline A enclosing_query_impl( C_Window const &win, A result, typename tbt::lbit * =0) { if(is_less_equal(interface.get_right_win(win), interface.get_left_win(win))) { CGAL_Tree_warning_msg(interface.comp(interface.get_right_win(win), interface.get_left_win(win)), "invalid window -- query ignored"); return result; } link_type v = root(); if(v!=TREE_BASE_NULL) return enclosing_query(win, result, v); return result; } bool is_valid() const { link_type v= root(); if(v!=TREE_BASE_NULL) return is_valid(v); return true; } }; template std::allocator > Segment_tree_d::alloc; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polytope_distance_d.h0000644000175000017500000007754411344301500031202 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polytope_distance_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_POLYTOPE_DISTANCE_D_H #define CGAL_POLYTOPE_DISTANCE_D_H // includes // -------- #ifndef CGAL_OPTIMISATION_BASIC_H # include #endif #ifndef CGAL_FUNCTION_OBJECTS_H # include #endif #ifndef CGAL_FUNCTION_OBJECTS_ACCESS_BY_INDEX_H # include #endif #ifndef CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H # include #endif #ifndef CGAL_QP_SOLVER_H # include #endif #ifndef CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H # include #endif #ifndef CGAL_CONST_VALUE_ITERATOR_H # include #endif #ifndef CGAL_PARTIAL_EXACT_PRICING_H # include #endif #ifndef CGAL_PARTIAL_FILTERED_PRICING_H # include #endif #ifndef CGAL_PROTECT_VECTOR # include # define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_PROTECT_IOSTREAM # include # define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Polytope_distance_d; template < class ET_, class NT_, class Point, class Point_iterator, class Access_coord, class Access_dim > struct QP_rep_poly_dist_d; template < class NT > struct QP_rep_row_of_a { typedef std::vector argument_type; typedef typename argument_type::const_iterator result_type; result_type operator ( ) ( const argument_type& v) const { return v.begin(); } }; template < class Point, class Point_iterator > struct QP_rep_signed_point_iterator; template < class NT, class Point, class Access_coord, class Access_dim > class QP_rep_signed_inner_product; template < class NT, class Point, class Point_iterator, class Access_coord, class Access_dim > struct QP_rep_row_of_d; // Class interfaces // ================ template < class Traits_ > class Polytope_distance_d { public: // self typedef Traits_ Traits; typedef Polytope_distance_d Self; // types from the traits class typedef typename Traits::Point_d Point; typedef typename Traits::Rep_tag Rep_tag; typedef typename Traits::RT RT; typedef typename Traits::FT FT; typedef typename Traits::Access_dimension_d Access_dimension_d; typedef typename Traits::Access_coordinates_begin_d Access_coordinates_begin_d; typedef typename Traits::Construct_point_d Construct_point_d; typedef typename Traits::ET ET; typedef typename Traits::NT NT; private: // QP solver typedef CGAL::QP_rep_poly_dist_d< ET, NT, Point, typename std::vector::const_iterator, Access_coordinates_begin_d, Access_dimension_d > QP_rep; typedef CGAL::QP_solver< QP_rep > Solver; typedef typename Solver::Pricing_strategy Pricing_strategy; // private types typedef std::vector Point_vector; typedef std::vector ET_vector; typedef std::vector Index_vector; typedef CGAL::Access_by_index::const_iterator> Point_by_index; typedef std::vector NT_vector; typedef std::vector NT_matrix; public: // public types typedef typename Point_vector::const_iterator Point_iterator; typedef typename Index_vector::const_iterator IVCI; typedef CGAL::Join_random_access_iterator_1< IVCI, Point_by_index > Support_point_iterator; typedef typename ET_vector::const_iterator Coordinate_iterator; // creation Polytope_distance_d( const Traits& traits = Traits(), int verbose = 0, std::ostream& stream = std::cout) : tco( traits), d( -1), solver( verbose, stream) { set_pricing_strategy( NT()); } template < class InputIterator1, class InputIterator2 > Polytope_distance_d( InputIterator1 p_first, InputIterator1 p_last, InputIterator2 q_first, InputIterator2 q_last, const Traits& traits = Traits(), int verbose = 0, std::ostream& stream = std::cout) : tco( traits), solver( verbose, stream) { set_pricing_strategy( NT()); set( p_first, p_last, q_first, q_last); } // access to point sets int ambient_dimension( ) const { return d; } int number_of_points( ) const { return p_points.size()+q_points.size();} int number_of_points_p( ) const { return p_points.size(); } int number_of_points_q( ) const { return q_points.size(); } Point_iterator points_p_begin( ) const { return p_points.begin(); } Point_iterator points_p_end ( ) const { return p_points.end (); } Point_iterator points_q_begin( ) const { return q_points.begin(); } Point_iterator points_q_end ( ) const { return q_points.end (); } // access to support points int number_of_support_points( ) const { return is_finite() ? solver.number_of_basic_variables() : 0; } int number_of_support_points_p() const { return p_support_indices.size();} int number_of_support_points_q() const { return q_support_indices.size();} Support_point_iterator support_points_p_begin() const { return Support_point_iterator( p_support_indices.begin(), Point_by_index( p_points.begin())); } Support_point_iterator support_points_p_end() const { return Support_point_iterator( is_finite() ? p_support_indices.end() : p_support_indices.begin(), Point_by_index( p_points.begin())); } Support_point_iterator support_points_q_begin() const { return Support_point_iterator( q_support_indices.begin(), Point_by_index( q_points.begin())); } Support_point_iterator support_points_q_end() const { return Support_point_iterator( is_finite() ? q_support_indices.end() : q_support_indices.begin(), Point_by_index( q_points.begin())); } // access to realizing points (rational representation) Coordinate_iterator realizing_point_p_coordinates_begin( ) const { return p_coords.begin(); } Coordinate_iterator realizing_point_p_coordinates_end ( ) const { return p_coords.end (); } Coordinate_iterator realizing_point_q_coordinates_begin( ) const { return q_coords.begin(); } Coordinate_iterator realizing_point_q_coordinates_end ( ) const { return q_coords.end (); } // access to squared distance (rational representation) ET squared_distance_numerator ( ) const { return solver.solution_numerator(); } ET squared_distance_denominator( ) const { return solver.solution_denominator(); } // access to realizing points and squared distance // NOTE: an implicit conversion from ET to RT must be available! Point realizing_point_p( ) const { CGAL_optimisation_precondition( is_finite()); return tco.construct_point_d_object()( ambient_dimension(), realizing_point_p_coordinates_begin(), realizing_point_p_coordinates_end ()); } Point realizing_point_q( ) const { CGAL_optimisation_precondition( is_finite()); return tco.construct_point_d_object()( ambient_dimension(), realizing_point_q_coordinates_begin(), realizing_point_q_coordinates_end ()); } FT squared_distance( ) const { return FT( squared_distance_numerator ()) / FT( squared_distance_denominator()); } bool is_finite( ) const { return ( number_of_points_p() > 0) && ( number_of_points_q() > 0); } bool is_zero( ) const { return CGAL_NTS is_zero( squared_distance_numerator()); } bool is_degenerate( ) const { return ( ! is_finite()); } // modifiers template < class InputIterator1, class InputIterator2 > void set( InputIterator1 p_first, InputIterator1 p_last, InputIterator2 q_first, InputIterator2 q_last) { if ( p_points.size() > 0) p_points.erase( p_points.begin(), p_points.end()); if ( q_points.size() > 0) q_points.erase( q_points.begin(), q_points.end()); std::copy( p_first, p_last, std::back_inserter( p_points)); std::copy( q_first, q_last, std::back_inserter( q_points)); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( p_points.begin(), p_points.end()) && check_dimension( q_points.begin(), q_points.end()), "Not all points have the same dimension."); compute_distance(); } template < class InputIterator > void set_p( InputIterator p_first, InputIterator p_last) { if ( p_points.size() > 0) p_points.erase( p_points.begin(), p_points.end()); std::copy( p_first, p_last, std::back_inserter( p_points)); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( p_points.begin(), p_points.end()), "Not all points have the same dimension."); compute_distance(); } template < class InputIterator > void set_q( InputIterator q_first, InputIterator q_last) { if ( q_points.size() > 0) q_points.erase( q_points.begin(), q_points.end()); std::copy( q_first, q_last, std::back_inserter( q_points)); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( q_points.begin(), q_points.end()), "Not all points have the same dimension."); compute_distance(); } void insert_p( const Point& p) { CGAL_optimisation_precondition( ( ! is_finite()) || ( tco.access_dimension_d_object()( p) == d)); p_points.push_back( p); compute_distance(); } void insert_q( const Point& q) { CGAL_optimisation_precondition( ( ! is_finite()) || ( tco.access_dimension_d_object()( q) == d)); q_points.push_back( q); compute_distance(); } template < class InputIterator1, class InputIterator2 > void insert( InputIterator1 p_first, InputIterator1 p_last, InputIterator2 q_first, InputIterator2 q_last) { CGAL_optimisation_precondition_code( int old_r = p_points.size()); CGAL_optimisation_precondition_code( int old_s = q_points.size()); p_points.insert( p_points.end(), p_first, p_last); q_points.insert( q_points.end(), q_first, q_last); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( p_points.begin()+old_r, p_points.end()) && check_dimension( q_points.begin()+old_s, q_points.end()), "Not all points have the same dimension."); compute_distance(); } template < class InputIterator > void insert_p( InputIterator p_first, InputIterator p_last) { CGAL_optimisation_precondition_code( int old_r = p_points.size()); p_points.insert( p_points.end(), p_first, p_last); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( p_points.begin()+old_r, p_points.end()), "Not all points have the same dimension."); compute_distance(); } template < class InputIterator > void insert_q( InputIterator q_first, InputIterator q_last) { CGAL_optimisation_precondition_code( int old_s = q_points.size()); q_points.insert( q_points.end(), q_first, q_last); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( q_points.begin()+old_s, q_points.end()), "Not all points have the same dimension."); compute_distance(); } void clear( ) { p_points.erase( p_points.begin(), p_points.end()); q_points.erase( q_points.begin(), q_points.end()); compute_distance(); } // validity check bool is_valid( bool verbose = false, int level = 0) const; // traits class access const Traits& traits( ) const { return tco; } private: Traits tco; // traits class object Point_vector p_points; // points of P Point_vector q_points; // points of Q int d; // dimension of input points ET_vector p_coords; // realizing point of P ET_vector q_coords; // realizing point of Q Solver solver; // quadratic programming solver Index_vector p_support_indices; Index_vector q_support_indices; NT_matrix a_matrix; // matrix `A' of QP typename Solver::Pricing_strategy* // pricing strategy strategyP; // of the QP solver // set dimension of input points void set_dimension( ) { d = ( p_points.size() > 0 ? tco.access_dimension_d_object()( p_points[ 0]) : q_points.size() > 0 ? tco.access_dimension_d_object()( q_points[ 0]) : -1); } // check dimension of input points template < class InputIterator > bool check_dimension( InputIterator first, InputIterator last) { return ( std::find_if( first, last, CGAL::compose1_1( std::bind2nd( std::not_equal_to(), d), tco.access_dimension_d_object())) == last); } // compute (squared) distance void compute_distance( ) { // clear support points p_support_indices.erase( p_support_indices.begin(), p_support_indices.end()); q_support_indices.erase( q_support_indices.begin(), q_support_indices.end()); if ( ( p_points.size() == 0) || ( q_points.size() == 0)) return; // set up and solve QP int i, j; NT nt_0 = 0, nt_1 = 1; // matrix A a_matrix.erase( a_matrix.begin(), a_matrix.end()); a_matrix.insert( a_matrix.end(), number_of_points(), NT_vector( 2, nt_0)); for ( j = 0; j < number_of_points_p(); ++j) a_matrix[ j][ 0] = nt_1; for ( ; j < number_of_points (); ++j) a_matrix[ j][ 1] = nt_1; // set-up typedef QP_rep_signed_point_iterator< Point, Point_iterator > Signed_point_iterator; Signed_point_iterator signed_pts_it(p_points.begin(), p_points.size(), q_points.begin()); QP_rep_row_of_d< NT, Point, Signed_point_iterator, Access_coordinates_begin_d, Access_dimension_d > row_of_d( signed_pts_it, tco.access_coordinates_begin_d_object(), tco.access_dimension_d_object()); typedef typename QP_rep::A_iterator A_it; typedef typename QP_rep::B_iterator B_it; typedef typename QP_rep::C_iterator C_it; typedef typename QP_rep::D_iterator D_it; solver.set( number_of_points(), 2, d+2, A_it( a_matrix.begin()), B_it( 1), C_it( 0), D_it( signed_pts_it, row_of_d)); // solve solver.init(); solver.solve(); // compute support and realizing points ET et_0 = 0; int r = number_of_points_p(); p_coords.resize( ambient_dimension()+1); q_coords.resize( ambient_dimension()+1); std::fill( p_coords.begin(), p_coords.end(), et_0); std::fill( q_coords.begin(), q_coords.end(), et_0); for ( i = 0; i < solver.number_of_basic_variables(); ++i) { ET value = solver.basic_variables_numerator_begin()[ i]; int index = solver.basic_variables_index_begin()[ i]; if ( index < r) { for ( int j = 0; j < d; ++j) { p_coords[ j] += value * tco.access_coordinates_begin_d_object()( p_points[ index ])[ j]; } p_support_indices.push_back( index); } else { for ( int j = 0; j < d; ++j) { q_coords[ j] += value * tco.access_coordinates_begin_d_object()( q_points[ index-r])[ j]; } q_support_indices.push_back( index-r); } } p_coords[ d] = q_coords[ d] = solver.variables_common_denominator(); } template < class NT > void set_pricing_strategy( NT) { strategyP = new CGAL::Partial_filtered_pricing; solver.set_pricing_strategy( *strategyP); } #ifndef _MSC_VER void set_pricing_strategy( ET) { strategyP = new CGAL::Partial_exact_pricing; solver.set_pricing_strategy( *strategyP); } #endif }; template < class Point, class PointIterator > struct QP_rep_signed_point_iterator { public: typedef std::pair value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; typedef QP_rep_signed_point_iterator Self; typedef value_type Val; typedef difference_type Dist; typedef pointer Ptr; // forward operations QP_rep_signed_point_iterator( const PointIterator& it_p = PointIterator(), Dist n_p = 0, const PointIterator& it_q = PointIterator()) : p_it( it_p), q_it( it_q), n( n_p), curr( 0) { } bool operator == ( const Self& it) const { return (curr == it.curr);} bool operator != ( const Self& it) const { return (curr != it.curr);} Val operator * ( ) const { return ( curr < n) ? std::make_pair( *p_it, CGAL::POSITIVE) : std__make_pair( *q_it, CGAL::NEGATIVE); } Self& operator ++ ( ) { if ( ++curr <= n) ++p_it; else ++q_it; return *this; } Self operator ++ ( int) { Self tmp = *this; operator++(); return tmp; } // bidirectional operations Self& operator -- ( ) { if ( --curr < n) --p_it; else --q_it; return *this; } Self operator -- ( int) { Self tmp = *this; operator--(); return tmp; } // random access operations Self& operator += ( Dist i) { if ( curr+i <= n) { curr += i; p_it += i; } else { if ( curr < n) p_it += n-curr; curr += i; q_it += curr-n; } return *this; } Self& operator -= ( Dist i) { if ( curr-i < n) { if ( curr > n) q_it -= curr-n; curr -= i; p_it -= n-curr; } else { curr -= i; q_it -= i; } return *this; } Self operator + ( Dist i) const { Self tmp = *this; return tmp+=i; } Self operator - ( Dist i) const { Self tmp = *this; return tmp-=i; } Dist operator - ( const Self& it) const { return curr - it.curr; } Val operator [] ( int i) const { return ( curr+i < n) ? std::make_pair( p_it[ i ], CGAL::POSITIVE) : std::make_pair( q_it[ i-n], CGAL::NEGATIVE); } bool operator < ( const Self& it) const { return ( curr < it.curr); } bool operator > ( const Self& it) const { return ( curr > it.curr); } bool operator <= ( const Self& it) const { return ( curr <= it.curr); } bool operator >= ( const Self& it) const { return ( curr >= it.curr); } private: PointIterator p_it; PointIterator q_it; Dist n; Dist curr; }; template < class NT, class Point, class Access_coord, class Access_dim > class QP_rep_signed_inner_product { Point p_i; CGAL::Sign s_i; Access_coord da_coord; Access_dim da_dim; public: typedef std::pair argument_type; typedef NT result_type; QP_rep_signed_inner_product( ) { } QP_rep_signed_inner_product( const argument_type& p_signed, const Access_coord& ac, const Access_dim& ad) : p_i( p_signed.first), s_i( p_signed.second), da_coord( ac), da_dim( ad) { } NT operator( ) ( const argument_type& p_signed) const { NT ip = std::inner_product( da_coord( p_i), da_coord( p_i)+da_dim( p_i), da_coord( p_signed.first), NT( 0), std::plus(), std::multiplies()); return ( s_i*p_signed.second == CGAL::POSITIVE) ? ip : -ip; } }; template < class NT, class Point, class Signed_point_iterator, class Access_coord, class Access_dim > class QP_rep_row_of_d { Signed_point_iterator signed_pts_it; Access_coord da_coord; Access_dim da_dim; public: typedef CGAL::QP_rep_signed_inner_product< NT, Point, Access_coord, Access_dim > Signed_inner_product; typedef CGAL::Join_random_access_iterator_1< Signed_point_iterator, Signed_inner_product > Row_of_d; typedef std::pair argument_type; typedef Row_of_d result_type; QP_rep_row_of_d( ) { } QP_rep_row_of_d( const Signed_point_iterator& it, const Access_coord& ac, const Access_dim& ad) : signed_pts_it( it), da_coord( ac), da_dim( ad) { } Row_of_d operator( ) ( const argument_type& p_signed) const { return Row_of_d( signed_pts_it, Signed_inner_product( p_signed, da_coord, da_dim));} }; template < class ET_, class NT_, class Point, class Point_iterator, class Access_coord, class Access_dim > struct QP_rep_poly_dist_d { typedef ET_ ET; typedef NT_ NT; typedef std::vector< std::vector > NT_matrix; typedef CGAL::Join_random_access_iterator_1< typename NT_matrix::const_iterator, QP_rep_row_of_a > A_iterator; typedef CGAL::Const_value_iterator B_iterator; typedef CGAL::Const_value_iterator C_iterator; typedef CGAL::QP_rep_signed_point_iterator< Point, Point_iterator> Signed_point_iterator; typedef CGAL::Join_random_access_iterator_1< Signed_point_iterator, QP_rep_row_of_d< NT, Point, Signed_point_iterator, Access_coord, Access_dim > > D_iterator; typedef CGAL::Tag_false Is_lp; }; // Function declarations // ===================== // I/O operators template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Polytope_distance_d& poly_dist); template < class Traits_ > std::istream& operator >> ( std::istream& is, Polytope_distance_d& poly_dist); // ============================================================================ // Class implementation // ==================== // validity check template < class Traits_ > bool Polytope_distance_d:: is_valid( bool verbose, int level) const { CGAL_USING_NAMESPACE_STD CGAL::Verbose_ostream verr( verbose); verr << "CGAL::Polytope_distance_d::" << endl; verr << "is_valid( true, " << level << "):" << endl; verr << " |P+Q| = " << number_of_points_p() << '+' << number_of_points_q() << ", |S| = " << number_of_support_points_p() << '+' << number_of_support_points_q() << endl; if ( is_finite()) { // compute normal vector ET_vector normal( d), diff( d); ET et_0 = 0, den = solver.variables_common_denominator(); int i, j; for ( j = 0; j < d; ++j) normal[ j] = p_coords[ j] - q_coords[ j]; // check P // ------- verr << " checking P..." << flush; // check point set for ( i = 0; i < number_of_points_p(); ++i) { for ( j = 0; j < d; ++j) { diff[ j] = p_coords[ j] - den * tco.access_coordinates_begin_d_object()( p_points[ i])[ j]; } if ( std::inner_product( diff.begin(), diff.end(), normal.begin(), et_0) > et_0) return CGAL::_optimisation_is_valid_fail( verr, "polytope P is not separated by its hyperplane"); } verr << "passed." << endl; // check Q // ------- verr << " checking Q..." << flush; // check point set for ( i = 0; i < number_of_points_q(); ++i) { for ( j = 0; j < d; ++j) { diff[ j] = q_coords[ j] - den * tco.access_coordinates_begin_d_object()( q_points[ i])[ j]; } if ( std::inner_product( diff.begin(), diff.end(), normal.begin(), et_0) < et_0) return CGAL::_optimisation_is_valid_fail( verr, "polytope Q is not separated by its hyperplane"); } verr << "passed." << endl; } verr << " object is valid!" << endl; return( true); } // output operator template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Polytope_distance_d& poly_dist) { CGAL_USING_NAMESPACE_STD typedef typename Polytope_distance_d::Point Point; typedef ostream_iterator Os_it; typedef typename Traits_::ET ET; typedef ostream_iterator Et_it; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << "CGAL::Polytope_distance_d( |P+Q| = " << poly_dist.number_of_points_p() << '+' << poly_dist.number_of_points_q() << ", |S| = " << poly_dist.number_of_support_points_p() << '+' << poly_dist.number_of_support_points_q() << endl; os << " P = {" << endl; os << " "; copy( poly_dist.points_p_begin(), poly_dist.points_p_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " Q = {" << endl; os << " "; copy( poly_dist.points_q_begin(), poly_dist.points_q_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " S_P = {" << endl; os << " "; copy( poly_dist.support_points_p_begin(), poly_dist.support_points_p_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " S_Q = {" << endl; os << " "; copy( poly_dist.support_points_q_begin(), poly_dist.support_points_q_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " p = ( "; copy( poly_dist.realizing_point_p_coordinates_begin(), poly_dist.realizing_point_p_coordinates_end(), Et_it( os, " ")); os << ")" << endl; os << " q = ( "; copy( poly_dist.realizing_point_q_coordinates_begin(), poly_dist.realizing_point_q_coordinates_end(), Et_it( os, " ")); os << ")" << endl; os << " squared distance = " << poly_dist.squared_distance_numerator() << " / " << poly_dist.squared_distance_denominator() << endl; break; case CGAL::IO::ASCII: os << poly_dist.number_of_points_p() << endl; copy( poly_dist.points_p_begin(), poly_dist.points_p_end(), Os_it( os, "\n")); os << poly_dist.number_of_points_q() << endl; copy( poly_dist.points_q_begin(), poly_dist.points_q_end(), Os_it( os, "\n")); break; case CGAL::IO::BINARY: os << poly_dist.number_of_points_p() << endl; copy( poly_dist.points_p_begin(), poly_dist.points_p_end(), Os_it( os)); os << poly_dist.number_of_points_q() << endl; copy( poly_dist.points_q_begin(), poly_dist.points_q_end(), Os_it( os)); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } // input operator template < class Traits_ > std::istream& operator >> ( std::istream& is, CGAL::Polytope_distance_d& poly_dist) { CGAL_USING_NAMESPACE_STD /* switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: cerr << endl; cerr << "Stream must be in ascii or binary mode" << endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: typedef CGAL::Polytope_distance_d::Point Point; typedef istream_iterator Is_it; poly_dist.set( Is_it( is), Is_it()); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } */ return( is); } CGAL_END_NAMESPACE #endif // CGAL_POLYTOPE_DISTANCE_D_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_traits_20000644000175000017500000001367611344301501031376 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_traits_2.h,v $ // $Revision: 1.1.1.1 $ // $Name: $ // // author(s) : Eli Packer #ifndef CGAL_SNAP_ROUNDING_2_TRAITS_H #define CGAL_SNAP_ROUNDING_2_TRAITS_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Snap_rounding_traits_2 : public CGAL::Arr_segment_cached_traits_2 { public: // otherwise Segment_data cannot access the types typedef typename Base_kernel::FT NT; typedef typename Base_kernel::Point_2 Point_2; typedef typename Base_kernel::Segment_2 Segment_2; typedef typename Base_kernel::Iso_rectangle_2 Iso_rectangle_2; typedef typename Base_kernel::Compare_y_2 Compare_y_2; typedef typename Base_kernel::Compare_x_2 Compare_x_2; typedef typename Base_kernel::Construct_vertex_2 Construct_vertex_2; typedef typename Base_kernel::Construct_segment_2 Construct_segment_2; typedef typename Base_kernel::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef CGAL::To_double To_double; public: /*! Functor */ class Snap_2 { public: void operator()(Point_2 p, NT pixel_size, NT &x, NT &y) { NT x_tmp = p.x() / pixel_size; NT y_tmp = p.y() / pixel_size; double x_floor = floor(CGAL::to_double(x_tmp)); double y_floor = floor(CGAL::to_double(y_tmp)); x = NT(x_floor) * pixel_size + pixel_size / NT(2.0); y = NT(y_floor) * pixel_size + pixel_size / NT(2.0); } }; Snap_2 snap_2_object() const { return Snap_2(); } /*! Functor */ class Integer_grid_point_2 { public: Point_2 operator()(Point_2 p,NT pixel_size) { NT x = (p.x() - pixel_size / NT(2.0)) / pixel_size; NT y = (p.y() - pixel_size / NT(2.0)) / pixel_size; Point_2 out_p(x,y); return(out_p); } }; /*! */ Integer_grid_point_2 integer_grid_point_2_object() const { return Integer_grid_point_2(); } /*! Functor */ class Minkowski_sum_with_pixel_2 { private: typedef Snap_rounding_traits_2 Traits; typedef std::list Point_list; typedef typename Base_kernel::Compare_y_2 Compare_y_2; typedef typename Base_kernel::Compare_x_2 Compare_x_2; typedef typename Base_kernel::Construct_vertex_2 Construct_vertex_2; const Traits * m_gt; Minkowski_sum_with_pixel_2(const Traits * gt) : m_gt(gt) {} public: void operator()(Point_list & points_list, Segment_2 s, NT unit_square) { Construct_vertex_2 construct_ver = m_gt->construct_vertex_2_object(); Compare_y_2 compare_y = m_gt->compare_y_2_object(); Compare_x_2 compare_x = m_gt->compare_x_2_object(); Point_2 src = construct_ver(s, 0); Point_2 trg = construct_ver(s, 1); Comparison_result cx = compare_x(src, trg); Comparison_result cy = compare_y(src, trg); NT x1 = src.x(); NT y1 = src.y(); NT x2 = trg.x(); NT y2 = trg.y(); Point_2 ms1, ms2, ms3, ms4, ms5, ms6;// minkowski sum points if (cx == SMALLER) { if (cy == SMALLER) { // we use unit_square instead of unit_square / 2 in order to // find tangency points which are not supported by kd-tree ms1 = Point_2(x1 - unit_square, y1 - unit_square); ms2 = Point_2(x1 - unit_square, y1 + unit_square); ms3 = Point_2(x1 + unit_square, y1 - unit_square); ms4 = Point_2(x2 + unit_square, y2 - unit_square); ms5 = Point_2(x2 + unit_square, y2 + unit_square); ms6 = Point_2(x2 - unit_square, y2 + unit_square); } else { ms1 = Point_2(x1 - unit_square, y1 - unit_square); ms2 = Point_2(x1 - unit_square, y1 + unit_square); ms3 = Point_2(x1 + unit_square, y1 + unit_square); ms4 = Point_2(x2 + unit_square, y2 - unit_square); ms5 = Point_2(x2 + unit_square, y2 + unit_square); ms6 = Point_2(x2 - unit_square, y2 - unit_square); } } else { if(cy == SMALLER) { ms1 = Point_2(x1 + unit_square, y1 - unit_square); ms2 = Point_2(x1 + unit_square, y1 + unit_square); ms3 = Point_2(x1 - unit_square, y1 - unit_square); ms4 = Point_2(x2 + unit_square, y2 + unit_square); ms5 = Point_2(x2 - unit_square, y2 + unit_square); ms6 = Point_2(x2 - unit_square, y2 - unit_square); } else { ms1 = Point_2(x1 + unit_square, y1 - unit_square); ms2 = Point_2(x1 + unit_square, y1 + unit_square); ms3 = Point_2(x1 - unit_square, y1 + unit_square); ms4 = Point_2(x2 + unit_square, y2 - unit_square); ms5 = Point_2(x2 - unit_square, y2 - unit_square); ms6 = Point_2(x2 - unit_square, y2 + unit_square); } } points_list.push_back(ms1); points_list.push_back(ms2); points_list.push_back(ms3); points_list.push_back(ms4); points_list.push_back(ms5); points_list.push_back(ms6); } friend class Snap_rounding_traits_2; }; /*! */ Minkowski_sum_with_pixel_2 minkowski_sum_with_pixel_2_object() const { return Minkowski_sum_with_pixel_2(this); } }; CGAL_END_NAMESPACE #endif // CGAL_ISR_2_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Transform_iterator.h0000644000175000017500000000510111344301501031053 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Transform_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_TRANSFORM_ITERATOR_H) #define CGAL_TRANSFORM_ITERATOR_H 1 #include #include #include namespace std { struct _Unchecked_iterator_tag; }; CGAL_BEGIN_NAMESPACE template < class OutputIterator, class Operation > struct Transform_iterator { // Workaround. Added this non standard iterator category for VC8. Strange that no other iterator complains about this "feature" missing typedef std::_Unchecked_iterator_tag _Checked_iterator_category; typedef std::output_iterator_tag iterator_category; typedef Transform_iterator< OutputIterator, Operation > self; typedef typename Operation::argument_type argument_type; Transform_iterator( const OutputIterator& o, const Operation& op) : o_( o), op_( op) {} operator OutputIterator() { return o_; } self& operator*() { return *this; } self& operator++() { return *this; } self& operator++( int) { return *this; } self& operator=( const argument_type& a) { *(o_++) = op_( a); return *this; } private: OutputIterator o_; Operation op_; }; template < class OutputIterator, class Operation > inline Transform_iterator< OutputIterator, Operation > transform_iterator( const OutputIterator& o, const Operation& op) { return Transform_iterator< OutputIterator, Operation >( o, op); } template < class OutputIterator, class Operation > inline Iterator_tag query_circulator_or_iterator( const Transform_iterator< OutputIterator, Operation >&) { return Iterator_tag(); } CGAL_END_NAMESPACE #endif // ! (CGAL_TRANSFORM_ITERATOR_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/sorted_matrix_search.h0000644000175000017500000003012311344301501031402 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/sorted_matrix_search.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_SORTED_MATRIX_SEARCH_H) #define CGAL_SORTED_MATRIX_SEARCH_H 1 #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Matrix > class Padded_matrix { public: typedef typename Matrix::Value Value; Padded_matrix( const Matrix& m) : matrix( &m) {} Value operator()( int x, int y) const // padded access operator { return matrix->operator()( x < matrix->number_of_columns() ? x : matrix->number_of_columns() - 1, y < matrix->number_of_rows() ? y : matrix->number_of_rows() - 1); } bool is_sorted() // tests iff this matrix is sorted, i.e. in each column/row // the elements appear in increasing order // time complexity is proportional to the number of elements { for ( int i = 0; i < matrix->number_of_columns(); ++i) for ( int j = 0; j < matrix->number_of_rows(); ++j) { if ( i > 0 && (*matrix)( i - 1, j) > (*matrix)( i, j)) return false; if ( j > 0 && (*matrix)( i, j - 1) > (*matrix)( i, j)) return false; } return true; } private: const Matrix* matrix; }; template < class PaddedMatrix > class Matrix_cell { public: typedef typename PaddedMatrix::Value Value; Matrix_cell(PaddedMatrix m, int xpos = 0, int ypos = 0) : base_matrix(m), x(xpos), y(ypos) {} Value min() const { return base_matrix(x, y); } Value max(int offset) const // offset denotes the cell's dimension { return base_matrix(x + offset - 1, y + offset - 1); } int x_min() const { return x; } int y_min() const { return y; } PaddedMatrix matrix() const { return base_matrix; } void output(std::ostream& o, int dim) const { for (int i = 0; i < dim; ++i) { for (int j = 0; j < dim; ++j) o << base_matrix(x + i, y + j) << " "; o << std::endl; } } bool check_for(Value v, int dim) const { for (int i = 0; i < dim; ++i) for (int j = 0; j < dim; ++j) { if (CGAL_NTS abs(base_matrix(x + i, y + j) - v) < Value(1E-10)) std::cerr << "***" << base_matrix(x + i, y + j) << std::endl; if (base_matrix(x + i, y + j) == v) return true; } return false; } private: PaddedMatrix base_matrix; int x; int y; }; template < class Cell > struct Cell_min : public CGAL_STD::unary_function< Cell, typename Cell::Value > { typedef Arity_tag< 1 > Arity; typename Cell::Value operator()( const Cell& c) const { return c.min(); } }; template < class Cell > struct Cell_max : public CGAL_STD::unary_function< Cell, typename Cell::Value > { typedef Arity_tag< 1 > Arity; Cell_max( int offset) : ofs( offset) {} typename Cell::Value operator()( const Cell& c) const { return c.max( ofs); } private: int ofs; }; template < class InputIterator, class Traits > typename Traits::Value sorted_matrix_search(InputIterator f, InputIterator l, Traits t) { using std::max; using std::nth_element; using std::iter_swap; using std::find_if; using std::remove_if; using std::logical_or; using std::equal_to; typedef typename Traits::Matrix Matrix; typedef typename Traits::Value Value; typedef Padded_matrix< Matrix > PaddedMatrix; typedef Matrix_cell< PaddedMatrix > Cell; typedef std::vector< Cell > Cell_container; typedef typename Cell_container::iterator Cell_iterator; typedef typename Cell_container::reverse_iterator Cell_reverse_iterator; Cell_container active_cells; // set of input matrices must not be empty: CGAL_optimisation_precondition( f != l); // for each input matrix insert a cell into active_cells: InputIterator i( f); int maxdim( -1); while ( i != l) { CGAL_optimisation_expensive_precondition( PaddedMatrix( *i).is_sorted()); active_cells.push_back( Cell( PaddedMatrix( *i))); maxdim = max( max( (*i).number_of_columns(), (*i).number_of_rows()), maxdim); ++i; } CGAL_optimisation_precondition( maxdim > 0); // current cell dimension: int ccd( 1); // set ccd to a power of two >= maxdim: while ( ccd < maxdim) ccd <<= 1; // now start the search: for (;;) { if ( ccd > 1) { // ------------------------------------------------------ // divide cells: ccd >>= 1; // reserve is required here! // otherwise one of the insert operations might cause // a reallocation invalidating j // (should typically result in a segfault) active_cells.reserve( 4 * active_cells.size()); for ( Cell_reverse_iterator j( active_cells.rbegin()); j != active_cells.rend(); ++j) { // upper-left quarter: // Cell( (*j).matrix(), // (*j).x_min(), // (*j).y_min()) remains in active_cells, // since it is implicitly shortened by decreasing ccd // lower-left quarter: active_cells.push_back( Cell( (*j).matrix(), (*j).x_min(), (*j).y_min() + ccd)); // upper-right quarter: active_cells.push_back( Cell( (*j).matrix(), (*j).x_min() + ccd, (*j).y_min())); // lower-right quarter: active_cells.push_back( Cell( (*j).matrix(), (*j).x_min() + ccd, (*j).y_min() + ccd)); } // for all active cells } // if ( ccd > 1) else if ( active_cells.size() <= 1) //!!! maybe handle <= 3 break; // there has to be at least one cell left: CGAL_optimisation_assertion( active_cells.size() > 0); // ------------------------------------------------------ // compute medians of smallest and largest elements: int lower_median_rank = (active_cells.size() - 1) >> 1; int upper_median_rank = (active_cells.size() >> 1); // compute upper median of cell's minima: nth_element(active_cells.begin(), active_cells.begin() + upper_median_rank, active_cells.end(), compose( t.compare_strictly(), Cell_min< Cell >(), Cell_min< Cell >())); Cell_iterator lower_median_cell = active_cells.begin() + upper_median_rank; Value lower_median = lower_median_cell->min(); // compute lower median of cell's maxima: nth_element(active_cells.begin(), active_cells.begin() + lower_median_rank, active_cells.end(), compose( t.compare_strictly(), Cell_max< Cell >(ccd), Cell_max< Cell >(ccd))); Cell_iterator upper_median_cell = active_cells.begin() + lower_median_rank; Value upper_median = upper_median_cell->max(ccd); // restore lower_median_cell, if it has been displaced // by the second search if (lower_median_cell->min() != lower_median) lower_median_cell = find_if(active_cells.begin(), active_cells.end(), compose( bind_1(equal_to< Value >(), lower_median), Cell_min< Cell >())); CGAL_optimisation_assertion(lower_median_cell != active_cells.end()); // ------------------------------------------------------ // test feasibility of medians and remove cells accordingly: Cell_iterator new_end; if ( t.is_feasible( lower_median)) if ( t.is_feasible( upper_median)) { // lower_median and upper_median are feasible // discard cells with all entries greater than // min( lower_median, upper_median) except for // one cell defining this minimum Cell_iterator min_median_cell; Value min_median; if ( lower_median < upper_median) { min_median_cell = lower_median_cell; min_median = lower_median; } else { min_median_cell = upper_median_cell; min_median = upper_median; } // save min_median_cell: iter_swap( min_median_cell, active_cells.begin()); new_end = remove_if( active_cells.begin() + 1, active_cells.end(), compose( bind_1( t.compare_non_strictly(), min_median), Cell_min< Cell >())); } // lower_median and upper_median are feasible else { // lower_median is feasible, but upper_median is not // discard cells with all entries greater than // lower_median or all entries smaller than // upper_median except for the lower median cell // save lower_median_cell: iter_swap( lower_median_cell, active_cells.begin()); new_end = remove_if( active_cells.begin() + 1, active_cells.end(), compose_shared( logical_or< bool >(), compose( bind_1( t.compare_non_strictly(), lower_median), Cell_min< Cell >()), compose( bind_2( t.compare_non_strictly(), upper_median), Cell_max< Cell >( ccd)))); } // lower_median is feasible, but upper_median is not else if ( t.is_feasible( upper_median)) { // upper_median is feasible, but lower_median is not // discard cells with all entries greater than // upper_median or all entries smaller than // lower_median except for the upper median cell // save upper_median_cell: iter_swap( upper_median_cell, active_cells.begin()); new_end = remove_if( active_cells.begin() + 1, active_cells.end(), compose_shared( logical_or< bool >(), compose( bind_1( t.compare_non_strictly(), upper_median), Cell_min< Cell >()), compose( bind_2( t.compare_non_strictly(), lower_median), Cell_max< Cell >( ccd)))); } // upper_median is feasible, but lower_median is not else { // both upper_median and lower_median are infeasible // discard cells with all entries smaller than // max( lower_median, upper_median) new_end = remove_if( active_cells.begin(), active_cells.end(), compose( bind_2( t.compare_non_strictly(), max( lower_median, upper_median)), Cell_max< Cell >( ccd))); } // both upper_median and lower_median are infeasible active_cells.erase( new_end, active_cells.end()); } // for (;;) // there must be only one cell left: CGAL_optimisation_assertion( active_cells.size() == 1); CGAL_optimisation_assertion( ccd == 1); return (*active_cells.begin()).min(); } CGAL_END_NAMESPACE #endif // ! (CGAL_SORTED_MATRIX_SEARCH_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Iso_rectangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Iso_rectangle_0000644000175000017500000000604711344301500031261 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Iso_rectangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POINT_2_ISO_RECTANGLE_2_INTERSECTION_H #define CGAL_POINT_2_ISO_RECTANGLE_2_INTERSECTION_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const K&) { return !iso.has_on_unbounded_side(pt); } template inline bool do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const typename CGAL_WRAP(K)::Point_2 &pt, const K&) { return !iso.has_on_unbounded_side(pt); } template Object intersection(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const K& k) { if (CGALi::do_intersect(pt,iso,k)) { return make_object(pt); } return Object(); } template Object intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const typename CGAL_WRAP(K)::Point_2 &pt, const K& k) { if (CGALi::do_intersect(pt,iso,k)) { return make_object(pt); } return Object(); } } // namespace CGALi template inline bool do_intersect(const Iso_rectangle_2 &iso, const Point_2 &pt) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, iso); } template inline bool do_intersect(const Point_2 &pt, const Iso_rectangle_2 &iso) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, iso); } template inline Object intersection(const Iso_rectangle_2 &iso, const Point_2 &pt) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, iso); } template inline Object intersection(const Point_2 &pt, const Iso_rectangle_2 &iso) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, iso); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Memory_sizer.h0000644000175000017500000000773611344301500027672 0ustar debiandebian// Copyright (c) 2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Memory_sizer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion, Andreas Fabri #ifndef CGAL_MEMORY_SIZER_H #define CGAL_MEMORY_SIZER_H #include // This has only been implemented for Linux and VC++ for now. #if !defined _MSC_VER && !defined __linux__ # define CGAL_DONT_HAVE_MEMORY_SIZER #endif #if defined _MSC_VER # include # include "psapi.h" #elif defined __linux__ # include # include # include # include # include # include #endif #ifndef CGAL_DONT_HAVE_MEMORY_SIZER CGAL_BEGIN_NAMESPACE // A class giving access to the memory currently used by the process. // Both the virtual memory size and the resident size. // I put it in a class instead of free functions for similarity with Timer, // and in case we want to store some state. struct Memory_sizer { typedef std::size_t size_type; size_type virtual_size() const { return get(true); }; size_type resident_size() const { return get(false); }; private: size_type get (bool virtual_size) const { #ifdef _MSC_VER DWORD pid = GetCurrentProcessId(); size_type result; HANDLE hProcess; PROCESS_MEMORY_COUNTERS pmc; hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid ); if ( GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc)) ) { result = (virtual_size)? pmc.PagefileUsage : pmc.WorkingSetSize; } CloseHandle( hProcess ); return result; #else // Extract of "man proc" under Linux : // // vsize %u Virtual memory size // // rss %u Resident Set Size: number of pages // the process has in real memory, // minus 3 for administrative purposes. // This is just the pages which count // towards text, data, or stack space. // This does not include pages which // have not been demand-loaded in, or // which are swapped out. int pid; char name[1024]; char state; int ppid, pgrp, session, tty, tpgid; unsigned flags, minflt, cminflt, majflt, cmajflt; int utime, stime, cutime, cstime, counter, priority, timeout; unsigned itrealvalue, starttime, vsize = 0, rss = 0; FILE *f = fopen("/proc/self/stat", "r"); CGAL_assertion(f); fscanf(f, "%d %s %c %d %d %d %d %d %u " "%u %u %u %u %d %d %d " "%d %d %d %u %u %d " "%u %u", &pid, name, &state, &ppid, &pgrp, &session, &tty, &tpgid, &flags, &minflt, &cminflt, &majflt, &cmajflt, &utime, &stime, &cutime, &cstime, &counter, &priority, &timeout, &itrealvalue, &starttime, &vsize, &rss); fclose(f); return virtual_size ? vsize : rss * getpagesize(); #endif } }; CGAL_END_NAMESPACE #endif // CGAL_DONT_HAVE_MEMORY_SIZER #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesher_2.h0000644000175000017500000002167011344301500030525 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesher_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DELAUNAY_MESHER_2_H #define CGAL_DELAUNAY_MESHER_2_H #include #include #include namespace CGAL { template class Delaunay_mesher_2 { /** \name \c Tr types */ typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Edge Edge; typedef typename Tr::Point Point; /** \name Types needed for private member datas */ typedef Mesh_2::Refine_edges_with_clusters > Edges_level; typedef Mesh_2::Refine_faces Faces_level; public: typedef Tr Triangulation; typedef Crit Criteria; typedef Mesh_2::Clusters Clusters; /** \name Types needed to mark the domain for Delaunay_mesh_2 */ typedef std::list Seeds; typedef typename Seeds::const_iterator Seeds_iterator; typedef Seeds_iterator Seeds_const_iterator; private: // --- PRIVATE MEMBER DATAS --- Tr& tr; Criteria criteria; Null_mesher_level null_level; Null_mesh_visitor null_visitor; Clusters clusters_; Edges_level edges_level; Faces_level faces_level; Mesh_2::Refine_edges_visitor_from_faces visitor; Seeds seeds; bool seeds_mark; public: /** \name CONSTRUCTORS */ Delaunay_mesher_2(Tr& tr_, const Criteria& criteria_ = Criteria()) : tr(tr_), criteria(criteria_), null_level(), null_visitor(), clusters_(tr), edges_level(tr, clusters_, null_level), faces_level(tr, criteria, edges_level), visitor(faces_level, null_visitor), initialized(false) { } Delaunay_mesher_2(Tr& tr_, Edges_level& edges_level_, const Criteria& criteria_ = Criteria()) : tr(tr_), criteria(criteria_), null_level(), null_visitor(), clusters_(tr), edges_level(edges_level_), faces_level(tr, criteria, edges_level), visitor(faces_level, null_visitor), initialized(false) { } /** SEEDS HANDLING FUNCTIONS */ Seeds_const_iterator seeds_begin() const { return seeds.begin(); } Seeds_const_iterator seeds_end() const { return seeds.end(); } private: /** \name INITIALIZED */ bool initialized; public: /** \name MARKING FUNCTIONS */ /** The value type of \a InputIterator should be \c Point, and represents seeds. Connected components of seeds are marked with the value of \a mark. Other components are marked with \c !mark. The connected component of infinite faces is always marked with \c false. */ template void set_seeds(InputIterator b, InputIterator e, const bool mark = false, const bool do_it_now = false) { seeds.clear(); std::copy(b, e, std::back_inserter(seeds)); seeds_mark=mark; if(do_it_now) mark_facets(); } void clear_seeds() { seeds.clear(); seeds_mark = false; } void mark_facets() { mark_facets(tr, seeds.begin(), seeds.end(), seeds_mark); } /** Procedure that marks facets according to a list of seeds. */ template static void mark_facets(Tr& tr, Seeds_it begin, Seeds_it end, bool mark = false) { if (tr.dimension()<2) return; if( begin != end ) { for(typename Tr::All_faces_iterator it=tr.all_faces_begin(); it!=tr.all_faces_end(); ++it) it->set_marked(!mark); for(Seeds_it sit=begin; sit!=end; ++sit) { Face_handle fh=tr.locate(*sit); if(fh!=NULL) propagate_marks(fh, mark); } } else mark_convex_hull(tr); propagate_marks(tr.infinite_face(), false); } /** * Marks all faces of the convex hull but those connected to the * infinite faces. */ static void mark_convex_hull(Tr& tr) { for(typename Tr::All_faces_iterator fit=tr.all_faces_begin(); fit!=tr.all_faces_end(); ++fit) fit->set_marked(true); propagate_marks(tr.infinite_face(), false); } /** Propagates the mark \c mark recursivly. */ static void propagate_marks(const Face_handle fh, bool mark) { // std::queue only works with std::list on VC++6, and not with // std::deque, which is the default // But it should be fixed by VC++7 know. [Laurent Rineau 2003/03/24] std::queue*/> face_queue; fh->set_marked(mark); face_queue.push(fh); while( !face_queue.empty() ) { Face_handle fh = face_queue.front(); face_queue.pop(); for(int i=0;i<3;i++) { const Face_handle& nb = fh->neighbor(i); if( !fh->is_constrained(i) && (mark != nb->is_marked()) ) { nb->set_marked(mark); face_queue.push(nb); } } } } /** \name MESHING FUNCTIONS */ void refine_mesh() { if(initialized != true) init(); faces_level.refine(visitor); } /** \name REMESHING FUNCTIONS */ void set_criteria(const Criteria& criteria_, bool recalculate_bad_faces = true) { criteria = criteria_; if (recalculate_bad_faces) faces_level.scan_triangulation(); } const Criteria& get_criteria() const { return criteria; } template void set_bad_faces(Fh_it begin, Fh_it end) { faces_level.set_bad_faces(begin, end); } /** \name STEP BY STEP FUNCTIONS */ /** Initialize the data structures (The call of this function is REQUIRED before any step by step operation). */ void init() { mark_facets(); clusters_.create_clusters(); edges_level.scan_triangulation(); faces_level.scan_triangulation(); initialized = true; } bool is_refinement_done () { return faces_level.is_algorithm_done(); }; bool step_by_step_refine_mesh() { return faces_level.try_to_insert_one_point(visitor); } bool try_one_step_refine_mesh() { return faces_level.one_step(visitor); } /** \name ACCESS FUNCTIONS */ const Mesh_2::Clusters& clusters() const { return clusters_; } const Triangulation& triangulation() const { return tr; } /** \name DEBUGGING FUNCTIONS */ typedef typename Edges_level::Constrained_edge Constrained_edge; bool is_edges_refinement_done() { return edges_level.is_algorithm_done(); } Edge next_encroached_edge() { return edges_level.get_next_element(); } const Face_handle next_bad_face() { return faces_level.get_next_element(); } const Point next_refinement_point() { if( !edges_level.is_algorithm_done() ) return edges_level.get_refinement_point(next_encroached_edge()); else return faces_level.get_refinement_point(next_bad_face()); } typedef typename Edges_level::Edges_const_iterator Encroached_edges_const_iterator; typedef typename Faces_level::Bad_faces_const_iterator Bad_faces_const_iterator; Encroached_edges_const_iterator encroached_edges_begin() const { return edges_level.begin(); } Encroached_edges_const_iterator encroached_edges_end() const { return edges_level.end(); } Bad_faces_const_iterator bad_faces_begin() const { return faces_level.begin(); } Bad_faces_const_iterator bad_faces_end() const { return faces_level.end(); } }; // end class Delaunay_mesher_2 // --- GLOBAL FUNCTIONS --- template void refine_Delaunay_mesh_2(Tr& t, const Criteria& criteria = Criteria()) { typedef Delaunay_mesher_2 Mesher; Mesher mesher(t, criteria); mesher.refine_mesh(); } template void refine_Delaunay_mesh_2(Tr& t, InputIterator b, InputIterator e, const Criteria& criteria = Criteria(), bool mark = false) { typedef Delaunay_mesher_2 Mesher; Mesher mesher(t, criteria); mesher.set_seeds(b, e, mark); mesher.refine_mesh(); } } // end namespace CGAL #endif // CGAL_DELAUNAY_MESHER_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/MP_Float.h0000644000175000017500000001701011344301500026631 0ustar debiandebian// Copyright (c) 2001-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/MP_Float.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_MP_FLOAT_H #define CGAL_MP_FLOAT_H #include #include #include #include #include // MP_Float : multiprecision scaled integers. // Some invariants on the internal representation : // - zero is represented by an empty vector, and whatever exp. // - no leading or trailing zero in the vector => unique // The main algorithms are : // - Addition/Subtraction // - Multiplication // - Comparison // - to_double() / to_interval() // - Construction from a double. // - IOs // TODO : // - The exponent really overflows sometimes -> make it multiprecision. // - Write a generic wrapper that adds an exponent to be used by MP integers. // - Karatsuba (or other) ? Would be fun to implement at least. // - Division, sqrt... : different options : // - nothing // - convert to double, take approximation, compute over double, reconstruct // - exact division as separate function (for Bareiss...) // - returns the quotient of the division, forgetting the rest. CGAL_BEGIN_NAMESPACE class MP_Float; MP_Float operator+(const MP_Float &a, const MP_Float &b); MP_Float operator-(const MP_Float &a, const MP_Float &b); MP_Float operator*(const MP_Float &a, const MP_Float &b); MP_Float operator/(const MP_Float &a, const MP_Float &b); Comparison_result compare (const MP_Float & a, const MP_Float & b); class MP_Float { public: typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; typedef short limb; typedef int limb2; typedef double exponent_type; typedef std::vector V; typedef V::const_iterator const_iterator; typedef V::iterator iterator; private: void remove_leading_zeros() { while (!v.empty() && v.back() == 0) v.pop_back(); } void remove_trailing_zeros() { if (v.empty() || v.front() != 0) return; iterator i = v.begin(); for (++i; *i == 0; ++i) ; exp += i-v.begin(); v.erase(v.begin(), i); } // This union is used to convert an unsigned short to a short with // the same binary representation, without invoking implementation-defined // behavior (standard 4.7.3). // It is needed by PGCC, which behaves differently from the others. union to_signed { unsigned short us; short s; }; public: // Splits a limb2 into 2 limbs (high and low). static void split(limb2 l, limb & high, limb & low) { to_signed l2 = {l}; low = l2.s; high = (l - low) >> (8*sizeof(limb)); } // Given a limb2, returns the higher limb. static limb higher_limb(limb2 l) { limb high, low; split(l, high, low); return high; } void canonicalize() { remove_leading_zeros(); remove_trailing_zeros(); } MP_Float() : exp(0) { CGAL_assertion(sizeof(limb2) == 2*sizeof(limb)); CGAL_assertion(v.empty()); // Creates zero. } #if 0 // Causes ambiguities MP_Float(limb i) : v(1,i), exp(0) { remove_leading_zeros(); } #endif MP_Float(limb2 i) : v(2), exp(0) { split(i, v[1], v[0]); canonicalize(); } MP_Float(double d); MP_Float operator-() const { return MP_Float() - *this; } MP_Float& operator+=(const MP_Float &a) { return *this = *this + a; } MP_Float& operator-=(const MP_Float &a) { return *this = *this - a; } MP_Float& operator*=(const MP_Float &a) { return *this = *this * a; } MP_Float& operator/=(const MP_Float &a) { return *this = *this / a; } exponent_type max_exp() const { return v.size() + exp; } exponent_type min_exp() const { return exp; } limb of_exp(exponent_type i) const { if (i < exp || i >= max_exp()) return 0; return v[static_cast(i-exp)]; } bool is_zero() const { return v.empty(); } Sign sign() const { if (v.empty()) return ZERO; if (v.back()>0) return POSITIVE; CGAL_assertion(v.back()<0); return NEGATIVE; } void swap(MP_Float &m) { std::swap(v, m.v); std::swap(exp, m.exp); } // Converts to a rational type (e.g. Gmpq). template < typename T > T to_rational() const { const unsigned log_limb = 8 * sizeof(MP_Float::limb); if (is_zero()) return 0; MP_Float::const_iterator i; exponent_type exp = min_exp() * log_limb; T res = 0; for (i = v.begin(); i != v.end(); i++) { res += CGAL_CLIB_STD::ldexp(static_cast(*i), static_cast(exp)); exp += log_limb; } return res; } V v; exponent_type exp; }; inline void swap(MP_Float &m, MP_Float &n) { m.swap(n); } inline bool operator<(const MP_Float &a, const MP_Float &b) { return CGAL_NTS compare(a, b) == SMALLER; } inline bool operator>(const MP_Float &a, const MP_Float &b) { return b < a; } inline bool operator>=(const MP_Float &a, const MP_Float &b) { return ! (a < b); } inline bool operator<=(const MP_Float &a, const MP_Float &b) { return ! (a > b); } inline bool operator==(const MP_Float &a, const MP_Float &b) { return (a.v == b.v) && (a.v.empty() || (a.exp == b.exp)); } inline bool operator!=(const MP_Float &a, const MP_Float &b) { return ! (a == b); } inline Sign sign (const MP_Float &a) { return a.sign(); } MP_Float square(const MP_Float&); MP_Float sqrt(const MP_Float &d); // to_double() returns, not the closest double, but a one bit error is allowed. // We guarantee : to_double(MP_Float(double d)) == d. double to_double(const MP_Float &b); std::pair to_interval(const MP_Float &b); template < typename > class Quotient; // Overloaded in order to protect against overflow. double to_double(const Quotient &b); std::pair to_interval(const Quotient &b); inline void simplify_quotient(MP_Float & numerator, MP_Float & denominator) { // Currently only simplifies the two exponents. numerator.exp -= denominator.exp; denominator.exp = 0; } inline bool is_finite(const MP_Float &) { return true; } inline bool is_valid(const MP_Float &) { return true; } inline io_Operator io_tag(const MP_Float &) { return io_Operator(); } std::ostream & operator<< (std::ostream & os, const MP_Float &b); // This one is for debug. std::ostream & print (std::ostream & os, const MP_Float &b); std::istream & operator>> (std::istream & is, MP_Float &b); CGAL_END_NAMESPACE #endif // CGAL_MP_FLOAT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/point_generators_2.h0000644000175000017500000003733111344301500031003 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/point_generators_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_POINT_GENERATORS_2_H #define CGAL_POINT_GENERATORS_2_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template < class P, class Creator = Creator_uniform_2::Kernel::RT,P> > class Random_points_in_disc_2 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_in_disc_2 This; Random_points_in_disc_2( double r = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed in the open disc with radius r, i.e. |`*g'| < r . // Two random numbers are needed from `rnd' for each point. : Random_generator_base

    (r, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_in_disc_2:: generate_point() { typedef typename Creator::argument_type T; double alpha = this->_rnd.get_double() * 2.0 * CGAL_PI; double r = this->d_range * CGAL_CLIB_STD::sqrt( this->_rnd.get_double()); Creator creator; this->d_item = creator( T(r * CGAL_CLIB_STD::cos(alpha)), T(r * CGAL_CLIB_STD::sin(alpha))); } template < class P, class Creator = Creator_uniform_2::Kernel::RT, P> > class Random_points_on_circle_2 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_on_circle_2 This; Random_points_on_circle_2( double r = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed on the circle with radius r, i.e. |`*g'| == r . A // single random number is needed from `rnd' for each point. : Random_generator_base

    (r, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_on_circle_2:: generate_point() { typedef typename Creator::argument_type T; double a = this->_rnd.get_double() * 2.0 * CGAL_PI; Creator creator; this->d_item = creator( T(this->d_range * CGAL_CLIB_STD::cos(a)), T(this->d_range * CGAL_CLIB_STD::sin(a))); } template < class P, class Creator = Creator_uniform_2::Kernel::RT,P> > class Random_points_in_square_2 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_in_square_2 This; Random_points_in_square_2( double a = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed in the half-open square with side length a, // centered around the origin, i.e. \forall p = `*g': -\frac{a}{2} // <= p.x() < \frac{a}{2} and -\frac{a}{2} <= p.y() < \frac{a}{2} // . Two random numbers are needed from `rnd' for each point. : Random_generator_base

    ( a, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_in_square_2:: generate_point() { typedef typename Creator::argument_type T; Creator creator; this->d_item = creator( T(this->d_range * (2 * this->_rnd.get_double() - 1.0)), T(this->d_range * (2 * this->_rnd.get_double() - 1.0))); } template < class P, class Creator = Creator_uniform_2::Kernel::RT,P> > class Random_points_on_square_2 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_on_square_2 This; Random_points_on_square_2( double a = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed on the boundary of the square with side length a, // centered around the origin, i.e. \forall p = `*g': one // coordinate is either \frac{a}{2} or -\frac{a}{2} and for the // other coordinate c holds -\frac{a}{2} <= c < \frac{a}{2} . A // single random number is needed from `rnd' for each point. : Random_generator_base

    ( a, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_on_square_2:: generate_point() { typedef typename Creator::argument_type T; double d = this->_rnd.get_double() * 4.0; int k = int(d); d = this->d_range * (2 * (d - k) - 1.0); CGAL_assertion( - this->d_range <= d && d < this->d_range); Creator creator; switch (k) { case 0: this->d_item = creator( T(d), T(-this->d_range)); break; case 1: this->d_item = creator( T(d), T(this->d_range)); break; case 2: this->d_item = creator( T(-this->d_range), T(d)); break; case 3: this->d_item = creator( T( this->d_range), T(d)); break; } } template < class P, class Creator = Creator_uniform_2::Kernel::RT,P> > class Random_points_on_segment_2 : public Random_generator_base

    { P _p; P _q; void generate_point(); public: typedef Random_points_on_segment_2 This; Random_points_on_segment_2( const P& p = P( -1, 0), const P& q = P( 1, 0), Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed on the segment from p to q except q, i.e. `*g' == // \lambda p + (1-\lambda)\, q where 0 <= \lambda < 1 . A single // random number is needed from `rnd' for each point. : Random_generator_base

    ( max( max( to_double(p.x()), to_double(q.x())), max( to_double(p.y()), to_double(q.y()))), rnd) , _p(p), _q(q) { generate_point(); } const P& source() const { return _p; } const P& target() const { return _q; } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_on_segment_2:: generate_point() { typedef typename Creator::argument_type T; double la = this->_rnd.get_double(); double mu = 1.0 - la; Creator creator; this->d_item = creator(T(mu * to_double(_p.x()) + la * to_double(_q.x())), T(mu * to_double(_p.y()) + la * to_double(_q.y()))); } template < class P > class Points_on_segment_2 : public Generator_base

    { P _p; P _q; std::size_t d_i; std::size_t d_mx; void generate_point(); public: typedef Points_on_segment_2

    This; Points_on_segment_2() {} Points_on_segment_2( const P& p, const P& q, std::size_t mx, std::size_t i = 0) : Generator_base

    ( max( max( to_double(p.x()), to_double(q.x())), max( to_double(p.y()), to_double(q.y())))), _p(p), _q(q), d_i(i), d_mx(mx) { generate_point(); } const P& source() const { return _p; } const P& target() const { return _q; } // Sufficient equality test. bool operator==( const This& base) const { return ( d_i == base.d_i); } bool operator!=( const This& base) const { return ! operator==(base); } This& operator++() { d_i++; generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P > void Points_on_segment_2

    :: generate_point() { this->d_item = _p + (_q-_p) * d_i / (d_mx-1); } template OutputIterator points_on_square_grid_2( double a, std::size_t n, OutputIterator o, Creator creator) { typedef typename Creator::argument_type T; if (n == 0) return o; int m = int(CGAL_CLIB_STD::ceil(std::sqrt(static_cast(n)))); double base = -a; // Left and bottom boundary. double step = (2*a)/(m - 1); int j = 0; double px = base; double py = base; *o++ = creator( T(px), T(py)); for (std::size_t i = 1; i < n; i++) { j++; if ( j == m) { px = base; py = py + step; j = 0; } else { px = px + step; } *o++ = creator( T(px), T(py)); } return o; } template OutputIterator points_on_square_grid_2( double a, std::size_t n, OutputIterator o) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type P; return points_on_square_grid_2(a, n, o, Creator_uniform_2::Kernel::RT,P>()); } template OutputIterator points_on_segment_2( const P& p, const P& q, std::size_t n, OutputIterator o) // creates n points regular spaced on the segment from p to q, i.e. // \forall i: 0 <= i < n: o[i] := \frac{n-i-1}{n-1} p + \frac{i}{n-1 // } q. { for (std::size_t i = 0; i < n; i++) { *o++ = p + (q-p) * i / (n-1); } return o; } template void perturb_points_2( ForwardIterator first, ForwardIterator last, double xeps, double yeps, Random& rnd, Creator creator) // perturbs the points in the range [`first',`last') by replacing // each point with a random point from the rectangle `xeps' \times // `yeps' centered around the original point. Two random numbers are // needed from `rnd' for each point. Precondition: // The expression `to_double((*first).x())' and `to_double(( // *begin).y())' must be legal. { typedef typename Creator::argument_type T; xeps *= 2.0; yeps *= 2.0; for ( ; first != last; ++first) { double x = to_double( (*first).x()); double y = to_double( (*first).y()); x += xeps * (rnd.get_double() - 0.5); y += yeps * (rnd.get_double() - 0.5); *first = creator( T(x), T(y)); } } template void perturb_points_2( ForwardIterator first, ForwardIterator last, double xeps, double yeps, Random& rnd) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type P; perturb_points_2( first, last, xeps, yeps, rnd, Creator_uniform_2::Kernel::RT,P>()); } template inline void perturb_points_2( ForwardIterator first, ForwardIterator last, double xeps, Random& rnd) { perturb_points_2( first, last, xeps, xeps, rnd); } template void perturb_points_2( ForwardIterator first, ForwardIterator last, double xeps, double yeps) { perturb_points_2( first, last, xeps, yeps, default_random); } template void perturb_points_2( ForwardIterator first, ForwardIterator last, double xeps) { perturb_points_2( first, last, xeps, xeps, default_random); } template OutputIterator random_collinear_points_2( RandomAccessIterator first, RandomAccessIterator last, std::size_t n, OutputIterator first2, Random& rnd, Creator creator) { typedef typename Creator::result_type Point; typedef typename Creator::argument_type T; int m = last - first; for ( std::size_t i = 0; i < n; i++) { const Point& p = first[ rnd.get_int( 0, m-1)]; const Point& q = first[ rnd.get_int( 0, m-1)]; double la = rnd.get_double(); double mu = 1.0 - la; *first2++ = creator(T(mu * to_double(p.x()) + la * to_double(q.x())), T(mu * to_double(p.y()) + la * to_double(q.y()))); } return first2; } template OutputIterator random_collinear_points_2( RandomAccessIterator first, RandomAccessIterator last, std::size_t n, OutputIterator first2, Random& rnd) // choose two random points from the range [`first',`last'), create a // random third point on the segment connecting this two points, and // write it to `first2'. Repeat this n times, thus writing n points to // `first2' that are collinear with points in the range [`first', // `last'). Three random numbers are needed from `rnd' for each point. // Returns the value of `first2' after inserting the n points. // Precondition: The expression `to_double((*first).x() // )' and `to_double((*first).y())' must be legal. { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type P; return random_collinear_points_2( first, last, n, first2, rnd, Creator_uniform_2::Kernel::RT,P>()); } template OutputIterator random_collinear_points_2( RandomAccessIterator first, RandomAccessIterator last, std::size_t n, OutputIterator first2) { return random_collinear_points_2( first, last, n, first2, default_random); } CGAL_END_NAMESPACE #endif // CGAL_POINT_GENERATORS_2_H // // EOF // ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_circle_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_circle_2.0000644000175000017500000001350011344301500031241 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_circle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_OPTIMISATION_CIRCLE_2_H #define CGAL_OPTIMISATION_CIRCLE_2_H // includes #ifndef CGAL_BASIC_CONSTRUCTIONS_2_H # include #endif #ifndef CGAL_SQUARED_DISTANCE_2_H # include #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K_ > class Optimisation_circle_2; // Class interface // =============== template < class K_ > class Optimisation_circle_2 { public: // types typedef K_ K; typedef typename K::Point_2 Point; typedef typename K_::FT Distance; /************************************************************************** WORKAROUND: Some compilers are unable to match member functions defined outside the class template. Therefore, all member functions are implemented in the class interface. // creation Optimisation_circle_2( ); void set( ); void set( const Point& p); void set( const Point& p, const Point& q); void set( const Point& p, const Point& q, const Point& r); void set( const Point& center, const Distance& squared_radius); // access functions const Point& center ( ) const; const Distance& squared_radius( ) const // equality tests bool operator == ( const Optimisation_circle_2& c) const; bool operator != ( const Optimisation_circle_2& c) const; // predicates CGAL::Bounded_side bounded_side( const Point& p) const; bool has_on_bounded_side ( const Point& p) const; bool has_on_boundary ( const Point& p) const; bool has_on_unbounded_side ( const Point& p) const; bool is_empty ( ) const; bool is_degenerate( ) const; **************************************************************************/ private: // private data members Point _center; Distance _squared_radius; // ============================================================================ // Class implementation // ==================== public: // Constructor // ----------- inline Optimisation_circle_2( ) { } // Set functions // ------------- inline void set( ) { _center = Point( CGAL::ORIGIN); _squared_radius = -Distance( 1); } inline void set( const Point& p) { _center = p; _squared_radius = Distance( 0); } inline void set( const Point& p, const Point& q) { _center = CGAL::midpoint( p, q); _squared_radius = CGAL::squared_distance( p, _center); } inline void set( const Point& p, const Point& q, const Point& r) { _center = CGAL::circumcenter( p, q, r); _squared_radius = CGAL::squared_distance( p, _center); } inline void set( const Point& center, const Distance& squared_radius) { _center = center; _squared_radius = squared_radius; } // Access functions // ---------------- inline const Point& center( ) const { return( _center); } inline const Distance& squared_radius( ) const { return( _squared_radius); } // Equality tests // -------------- bool operator == ( const Optimisation_circle_2& c) const { return( ( _center == c._center ) && ( _squared_radius == c._squared_radius) ); } bool operator != ( const Optimisation_circle_2& c) const { return( ! operator==( c)); } // Predicates // ---------- inline CGAL::Bounded_side bounded_side( const Point& p) const { return( CGAL::Bounded_side( CGAL_NTS sign( _squared_radius - CGAL::squared_distance( p, _center)))); } inline bool has_on_bounded_side( const Point& p) const { return( CGAL::squared_distance( p, _center) < _squared_radius); } inline bool has_on_boundary( const Point& p) const { return( CGAL::squared_distance( p, _center) == _squared_radius); } inline bool has_on_unbounded_side( const Point& p) const { return( _squared_radius < CGAL::squared_distance( p, _center)); } inline bool is_empty( ) const { return( CGAL::is_negative( _squared_radius)); } inline bool is_degenerate( ) const { return( ! CGAL::is_positive( _squared_radius)); } }; // Function declarations // ===================== // I/O // --- template < class K_ > std::ostream& operator << ( std::ostream&, const CGAL::Optimisation_circle_2&); template < class K_ > std::istream& operator >> ( std::istream&, CGAL::Optimisation_circle_2&); CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_OPTIMISATION_CIRCLE_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2_3.h0000644000175000017500000000233311344301500030343 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTION_2_3_H #define CGAL_INTERSECTION_2_3_H #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filter_error.h0000644000175000017500000001323111344301501031177 0ustar debiandebian// Copyright (c) 1999,2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filter_error.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTER_ERROR_H #define CGAL_STATIC_FILTER_ERROR_H // This file contains the description of the class Static_filter_error. // The goal of this class is to be run by some overloaded predicates, // to compute error bound done in these functions. // // The original idea is from Olivier Devillers. // It is still EXPERIMENTAL. // TODO: // - I need to add some missing operators and functions, min/max... // - Remove the degree stuff, it's only meant for debug (?). // - Add __attribute__((const)) for optimizing ? #include #include CGAL_BEGIN_NAMESPACE struct Static_filter_error { typedef Static_filter_error Sfe; Static_filter_error () {} Static_filter_error (const int &i, const double &e = 0, const int &d = 1) : _b(i), _e(e), _d(d) {} Static_filter_error (const double &b, const double &e = 0, const int &d = 1) : _b(b), _e(e), _d(d) {} static double ulp () { FPU_CW_t backup = FPU_get_and_set_cw(CGAL_FE_UPWARD); double e = ulp(1); FPU_set_cw(backup); return e; } static double ulp (double d) { // You are supposed to call this function with rounding towards // +infinity, and on a positive number. d = CGAL_IA_FORCE_TO_DOUBLE(d); // stop constant propagation. CGAL_assertion(d>=0); double u; if (d == 1) // I need to special case to prevent infinite recursion. u = (d + CGAL_IA_MIN_DOUBLE) - d; else { // We need to use the d*ulp formula, in order for the formal proof // of homogeneisation to work. // u = (d + CGAL_IA_MIN_DOUBLE) - d; u = d * ulp(); } // Then add extra bonus, because of Intel's extended precision feature. // (ulp can be 2^-53 + 2^-64) u += u / (1<<11); CGAL_assertion(u!=0); return u; } Sfe operator+ (const Sfe &f) const { CGAL_warning_msg(_d == f._d, "you are adding variables of different homogeneous degree"); // We have to add an ulp, since the homogeneization could induce such // an error. FPU_CW_t backup = FPU_get_and_set_cw(CGAL_FE_UPWARD); double b = _b + f._b; double u = ulp(b) / 2; b += u; double e = u + _e + f._e; FPU_set_cw(backup); return Sfe(b, e, _d); } Sfe operator* (const Sfe &f) const { // We have to add an ulp, since the homogeneization could induce such // an error. FPU_CW_t backup = FPU_get_and_set_cw(CGAL_FE_UPWARD); double b = _b * f._b; double u = ulp(b) / 2; b += u; double e = u + _e * f._e + _e * f._b + _b * f._e; FPU_set_cw(backup); return Sfe(b, e, _d+f._d); } Sfe operator- (const Sfe &f) const { return *this + f; } Sfe operator- () const { return *this; } // Sfe operator/ (const Sfe &) const { CGAL_CLIB_STD::abort(); } // Division not supported. Sfe& operator+=(const Sfe &f) { return *this = *this + f; } Sfe& operator-=(const Sfe &f) { return *this = *this - f; } Sfe& operator*=(const Sfe &f) { return *this = *this * f; } // Sfe& operator/=(const Sfe &f) { return *this = *this / f; } double error() const { return _e; } double bound() const { return _b; } int degree() const { return _d; } bool operator< (const Sfe &f) const { Sfe e = *this + f; std::cerr << "Static error is : " << e.error() << std::endl; CGAL_CLIB_STD::abort(); return false; } bool operator> (const Sfe &f) const { return *this < f; } bool operator<=(const Sfe &f) const { return *this < f; } bool operator>=(const Sfe &f) const { return *this < f; } bool operator==(const Sfe &f) const { return *this < f; } bool operator!=(const Sfe &f) const { return *this < f; } private: // _b is a bound on the absolute value of the _double_ value of the // variable. // _e is a bound on the absolute error (difference between _b and the // _real_ value of the variable. // _d is the degree of the variable, it allows some additionnal checks. double _b, _e; int _d; }; inline Static_filter_error sqrt(const Static_filter_error &f) { CGAL_warning_msg(f.degree() & 1 == 0, "you really want a non integer degree ???"); // We have to add an ulp, since the homogeneization could induce such // an error. FPU_CW_t backup = FPU_get_and_set_cw(CGAL_FE_UPWARD); double b = CGAL_CLIB_STD::sqrt(f.bound()); double u = Static_filter_error::ulp(b) / 2; b += u; double e = CGAL_CLIB_STD::sqrt(f.error()) + u; FPU_set_cw(backup); return Static_filter_error(b, e, f.degree()/2); } CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTER_ERROR_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000001116611344301501031375 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------- // the Traits classes //----------------------------------------------------------------------- // this traits class does support intersecting segments template struct Segment_Voronoi_diagram_traits_2 : public Segment_Voronoi_diagram_traits_base_2 {}; template struct Segment_Voronoi_diagram_traits_2 : public Segment_Voronoi_diagram_traits_base_2 {}; // Concept checking template struct Segment_Voronoi_diagram_traits_2 : public Segment_Voronoi_diagram_traits_base_2 { Segment_Voronoi_diagram_traits_2() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( R() ); } }; template struct Segment_Voronoi_diagram_traits_2 : public Segment_Voronoi_diagram_traits_base_2 { Segment_Voronoi_diagram_traits_2() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( R() ); } }; // Specializations for filtered_kernel template struct Segment_Voronoi_diagram_traits_2,Field_tag> : public Segment_Voronoi_diagram_filtered_traits_2::EK, Field_tag, typename Filtered_kernel::FK, Sqrt_field_tag> {}; template struct Segment_Voronoi_diagram_traits_2,Sqrt_field_tag> : public Segment_Voronoi_diagram_filtered_traits_2::EK, Field_tag, typename Filtered_kernel::FK, Sqrt_field_tag> {}; //========================================================================= // this traits class does NOT support intersecting segments template struct Segment_Voronoi_diagram_traits_without_intersections_2 : public Segment_Voronoi_diagram_traits_base_2 {}; template struct Segment_Voronoi_diagram_traits_without_intersections_2 : public Segment_Voronoi_diagram_traits_base_2 { Segment_Voronoi_diagram_traits_without_intersections_2() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( R() ); } }; template struct Segment_Voronoi_diagram_traits_without_intersections_2 : public Segment_Voronoi_diagram_traits_base_2 { Segment_Voronoi_diagram_traits_without_intersections_2() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( R() ); } }; // Specialization for filtered_kernel template struct Segment_Voronoi_diagram_traits_without_intersections_2, Ring_tag> : public Segment_Voronoi_diagram_filtered_traits_without_intersections_2::EK, Ring_tag, typename Filtered_kernel::FK, Sqrt_field_tag> {}; template struct Segment_Voronoi_diagram_traits_without_intersections_2, Sqrt_field_tag> : public Segment_Voronoi_diagram_filtered_traits_without_intersections_2::EK, Ring_tag, typename Filtered_kernel::FK, Sqrt_field_tag> {}; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3.h0000644000175000017500000000242411344301501030734 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_DISTANCE_3_H #define CGAL_DISTANCE_3_H #include #include #include #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_items_decorator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_items_decor0000644000175000017500000004534511344301500031261 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_items_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_ITEMS_DECORATOR_H #define CGAL_HALFEDGEDS_ITEMS_DECORATOR_H 1 #include #include CGAL_BEGIN_NAMESPACE template < class p_HDS > class HalfedgeDS_items_decorator { public: // TYPES // ---------------------------------- typedef p_HDS HDS; typedef p_HDS HalfedgeDS; typedef typename HDS::Traits Traits; typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Face_iterator Face_iterator; typedef typename HDS::Face_const_iterator Face_const_iterator; typedef typename HDS::size_type size_type; typedef typename HDS::difference_type difference_type; typedef typename HDS::iterator_category iterator_category; // The following types are equal to either `Tag_true' or `Tag_false', // dependent whether the named feature is supported or not. typedef typename HDS::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename HDS::Supports_halfedge_prev Supports_halfedge_prev; typedef typename HDS::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename HDS::Supports_halfedge_face Supports_halfedge_face; typedef typename HDS::Supports_face_halfedge Supports_face_halfedge; typedef typename HDS::Supports_removal Supports_removal; protected: typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Halfedge::Base_base HBase_base; typedef typename Face::Base FBase; public: // CREATION // ---------------------------------- HalfedgeDS_items_decorator() {} // Access Functions // ---------------------------------- Halfedge_handle get_vertex_halfedge( Vertex_handle v) const { // returns the incident halfedge of v if supported, // `Halfedge_handle()' otherwise. return get_vertex_halfedge( v, Supports_vertex_halfedge()); } Vertex_handle get_vertex( Halfedge_handle h) const { // returns the incident vertex of h if supported, // `Vertex_handle()' otherwise. return get_vertex( h, Supports_halfedge_vertex()); } Halfedge_handle get_prev( Halfedge_handle h) const { // returns the previous halfedge of h if supported, // `Halfedge_handle()' otherwise. return get_prev( h, Supports_halfedge_prev()); } Halfedge_handle find_prev( Halfedge_handle h) const { // returns the previous halfedge of h. Uses the `prev()' method if // supported or performs a search around the face using `next()'. return find_prev( h, Supports_halfedge_prev()); } Halfedge_handle find_prev_around_vertex( Halfedge_handle h) const { // returns the previous halfedge of h. Uses the `prev()' method if // supported or performs a search around the vertex using `next()'. return find_prev_around_vertex( h, Supports_halfedge_prev()); } Face_handle get_face( Halfedge_handle h) const { // returns the incident face of h if supported, // `Face_handle()' otherwise. return get_face( h, Supports_halfedge_face()); } Halfedge_handle get_face_halfedge( Face_handle f) const { // returns the incident halfedge of f if supported, // `Halfedge_handle()' otherwise. return get_face_halfedge( f, Supports_face_halfedge()); } // Const Access Functions // ---------------------------------- Halfedge_const_handle get_vertex_halfedge( Vertex_const_handle v) const { return get_vertex_halfedge( v, Supports_vertex_halfedge()); } Vertex_const_handle get_vertex( Halfedge_const_handle h) const { return get_vertex( h, Supports_halfedge_vertex()); } Halfedge_const_handle get_prev( Halfedge_const_handle h) const { return get_prev( h, Supports_halfedge_prev()); } Halfedge_const_handle find_prev( Halfedge_const_handle h) const { return find_prev( h, Supports_halfedge_prev()); } Halfedge_const_handle find_prev_around_vertex( Halfedge_const_handle h) const { return find_prev_around_vertex( h, Supports_halfedge_prev()); } Face_const_handle get_face( Halfedge_const_handle h) const { return get_face( h, Supports_halfedge_face()); } Halfedge_const_handle get_face_halfedge( Face_const_handle f) const { return get_face_halfedge( f, Supports_face_halfedge()); } // Modifying Functions (Primitives) // ---------------------------------- void set_vertex_halfedge( Vertex_handle v, Halfedge_handle g) const { // sets the incident halfedge of v to g. set_vertex_halfedge( v, g, Supports_vertex_halfedge()); } void set_vertex_halfedge( Halfedge_handle h) const { // sets the incident halfedge of the vertex incident to h to h. set_vertex_halfedge( h, h, Supports_halfedge_vertex()); } void set_vertex( Halfedge_handle h, Vertex_handle v) const { // sets the incident vertex of h to v. set_vertex(h, v, Supports_halfedge_vertex()); } void set_prev( Halfedge_handle h, Halfedge_handle g) const { // sets the previous link of h to g. set_prev( h, g, Supports_halfedge_prev()); } void set_face( Halfedge_handle h, Face_handle f) const { // sets the incident face of h to f. set_face(h, f, Supports_halfedge_face()); } void set_face_halfedge( Face_handle f, Halfedge_handle g) const { // sets the incident halfedge of f to g. set_face_halfedge( f, g, Supports_face_halfedge()); } void set_face_halfedge( Halfedge_handle h) const { // sets the incident halfedge of the face incident to h to h. set_face_halfedge( h, h, Supports_halfedge_face()); } // Modifying Functions (Composed) // ---------------------------------- void close_tip( Halfedge_handle h) const { // makes `h->opposite()' the successor of h. h->HBase::set_next( h->opposite()); set_prev( h->opposite(), h); } void close_tip( Halfedge_handle h, Vertex_handle v) const { // makes `h->opposite()' the successor of h and sets the incident // vertex of h to v. h->HBase::set_next( h->opposite()); set_prev( h->opposite(), h); set_vertex( h, v); set_vertex_halfedge( h); } void insert_tip( Halfedge_handle h, Halfedge_handle v) const { // inserts the tip of the edge h into the halfedges around the // vertex pointed to by v. Halfedge `h->opposite()' is the new // successor of v and `h->next()' will be set to `v->next()'. The // vertex of h will be set to the vertex v refers to if vertices // are supported. h->HBase::set_next( v->next()); v->HBase::set_next( h->opposite()); set_prev( h->next(), h); set_prev( h->opposite(), v); set_vertex( h, get_vertex( v)); } void remove_tip( Halfedge_handle h) const { // removes the edge `h->next()->opposite()' from the halfedge // circle around the vertex referred to by h. The new successor // halfedge of h will be `h->next()->opposite()->next()'. h->HBase::set_next( h->next()->opposite()->next()); set_prev( h->next(), h); } void insert_halfedge( Halfedge_handle h, Halfedge_handle f) const { // inserts the halfedge h between f and `f->next()'. The face of h // will be the one f refers to if faces are supported. h->HBase::set_next( f->next()); f->HBase::set_next( h); set_prev( h->next(), h); set_prev( h, f); set_face( h, get_face( f)); } void remove_halfedge( Halfedge_handle h) const { // removes edge `h->next()' from the halfedge circle around the // face referred to by h. The new successor of h will be // `h->next()->next()'. h->HBase::set_next( h->next()->next()); set_prev( h->next(), h); } void set_vertex_in_vertex_loop( Halfedge_handle h, Vertex_handle v, Tag_false) const {} void set_vertex_in_vertex_loop( Halfedge_handle h, Vertex_handle v, Tag_true) const { CGAL_assertion_code( std::size_t termination_count = 0;) Halfedge_handle end = h; do { CGAL_assertion( ++termination_count != 0); h->HBase::set_vertex( v); h = h->next()->opposite(); } while ( h != end); } void set_vertex_in_vertex_loop( Halfedge_handle h, Vertex_handle v) const { // loops around the vertex incident to h and sets all vertex // pointers to v. Precondition: `h != Halfedge_handle()'. CGAL_precondition( h != Halfedge_handle()); set_vertex_in_vertex_loop( h, v, Supports_halfedge_vertex()); } void set_face_in_face_loop( Halfedge_handle h, Face_handle f, Tag_false) const {} void set_face_in_face_loop( Halfedge_handle h, Face_handle f, Tag_true) const { CGAL_assertion_code( std::size_t termination_count = 0;) Halfedge_handle end = h; do { CGAL_assertion( ++termination_count != 0); h->HBase::set_face( f); h = h->next(); } while ( h != end); } void set_face_in_face_loop( Halfedge_handle h, Face_handle f) const { // loops around the face incident to h and sets all face pointers // to f. Precondition: `h != Halfedge_handle()'. CGAL_precondition( h != Halfedge_handle()); set_face_in_face_loop( h, f, Supports_halfedge_face()); } Halfedge_handle flip_edge( Halfedge_handle h) const { // performs an edge flip. It returns h after // rotating the edge h one vertex in the direction of the face // orientation. Precondition: `h != Halfedge_handle()' and both // incident faces of h are triangles. CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( h == h->next()->next()->next()); CGAL_precondition( h->opposite() == h->opposite()->next()->next()->next()); Halfedge_handle hprev = h->next()->next(); Halfedge_handle gprev = h->opposite()->next()->next(); remove_tip( hprev); remove_tip( gprev); set_face_halfedge( hprev); set_face_halfedge( gprev); set_vertex_halfedge( hprev); set_vertex_halfedge( gprev); set_face( hprev->next(), hprev->face()); set_face( gprev->next(), gprev->face()); hprev = hprev->next(); gprev = gprev->next(); insert_tip( h, gprev); insert_tip( h->opposite(), hprev); CGAL_postcondition( h == h->next()->next()->next()); CGAL_postcondition( h->opposite() == h->opposite()->next()->next()->next()); return h; } // Implementing These Functions. // ==================================================== // Access Functions // ---------------------------------- Halfedge_handle get_vertex_halfedge( Vertex_handle , Tag_false) const { return Halfedge_handle(); } Halfedge_handle get_vertex_halfedge( Vertex_handle v, Tag_true) const { return v->halfedge(); } Vertex_handle get_vertex( Halfedge_handle , Tag_false) const { return Vertex_handle(); } Vertex_handle get_vertex( Halfedge_handle h, Tag_true) const { return h->vertex(); } Halfedge_handle get_prev( Halfedge_handle , Tag_false) const { return Halfedge_handle(); } Halfedge_handle get_prev( Halfedge_handle h, Tag_true) const { return h->HBase::prev(); } Halfedge_handle find_prev( Halfedge_handle h, Tag_true) const { return h->HBase::prev(); } Halfedge_handle find_prev( Halfedge_handle h, Tag_false) const { Halfedge_handle g = h; while ( g->next() != h) g = g->next(); return g; } Halfedge_handle find_prev_around_vertex( Halfedge_handle h, Tag_true) const { return h->HBase::prev(); } Halfedge_handle find_prev_around_vertex( Halfedge_handle h, Tag_false) const { Halfedge_handle g = h->opposite(); while ( g->next() != h) g = g->next()->opposite(); return g; } Face_handle get_face( Halfedge_handle , Tag_false) const { return Face_handle(); } Face_handle get_face( Halfedge_handle h, Tag_true) const { return h->face(); } Halfedge_handle get_face_halfedge( Face_handle , Tag_false) const { return Halfedge_handle(); } Halfedge_handle get_face_halfedge( Face_handle f, Tag_true) const { return f->halfedge(); } // Const Access Functions // ---------------------------------- Halfedge_const_handle get_vertex_halfedge( Vertex_const_handle ,Tag_false) const { return Halfedge_const_handle(); } Halfedge_const_handle get_vertex_halfedge( Vertex_const_handle v,Tag_true) const { return v->halfedge(); } Vertex_const_handle get_vertex( Halfedge_const_handle , Tag_false) const { return Vertex_const_handle(); } Vertex_const_handle get_vertex( Halfedge_const_handle h, Tag_true) const { return h->vertex(); } Halfedge_const_handle get_prev( Halfedge_const_handle , Tag_false) const { return Halfedge_const_handle(); } Halfedge_const_handle get_prev( Halfedge_const_handle h, Tag_true) const { return h->HBase::prev(); } Halfedge_const_handle find_prev( Halfedge_const_handle h, Tag_true) const { return h->HBase::prev(); } Halfedge_const_handle find_prev( Halfedge_const_handle h, Tag_false) const { Halfedge_const_handle g = h; while ( g->next() != h) g = g->next(); return g; } Halfedge_const_handle find_prev_around_vertex( Halfedge_const_handle h, Tag_true) const { return h->HBase::prev(); } Halfedge_const_handle find_prev_around_vertex( Halfedge_const_handle h, Tag_false) const { Halfedge_const_handle g = h->opposite(); while ( g->next() != h) g = g->next()->opposite(); return g; } Face_const_handle get_face( Halfedge_const_handle , Tag_false) const { return Face_const_handle(); } Face_const_handle get_face( Halfedge_const_handle h, Tag_true) const { return h->face(); } Halfedge_const_handle get_face_halfedge( Face_const_handle , Tag_false) const { return Halfedge_const_handle(); } Halfedge_const_handle get_face_halfedge( Face_const_handle f, Tag_true) const { return f->halfedge(); } // Modifying Function Primitives // ---------------------------------- void set_vertex_halfedge( Vertex_handle, Halfedge_handle, Tag_false) const {} void set_vertex_halfedge( Vertex_handle v, Halfedge_handle g, Tag_true) const { v->VBase::set_halfedge(g); } void set_vertex_halfedge( Halfedge_handle, Halfedge_handle, Tag_false) const {} void set_vertex_halfedge( Halfedge_handle h, Halfedge_handle g, Tag_true) const { set_vertex_halfedge( h->vertex(), g); } void set_vertex( Halfedge_handle, Vertex_handle, Tag_false) const {} void set_vertex( Halfedge_handle h, Vertex_handle v, Tag_true) const { h->HBase::set_vertex(v); } void set_prev( Halfedge_handle, Halfedge_handle, Tag_false) const {} void set_prev( Halfedge_handle h, Halfedge_handle g, Tag_true) const { h->HBase::set_prev( g); } void set_face( Halfedge_handle, Face_handle, Tag_false) const {} void set_face( Halfedge_handle h, Face_handle f, Tag_true) const { h->HBase::set_face(f); } void set_face_halfedge( Face_handle, Halfedge_handle, Tag_false) const {} void set_face_halfedge( Face_handle f, Halfedge_handle g, Tag_true) const { f->FBase::set_halfedge(g); } void set_face_halfedge( Halfedge_handle, Halfedge_handle, Tag_false) const {} void set_face_halfedge( Halfedge_handle h, Halfedge_handle g, Tag_true) const { set_face_halfedge( h->face(), g); } }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_ITEMS_DECORATOR_H // // EOF // ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_diagonal_list.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_diag0000644000175000017500000000267011344301500031447 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_diagonal_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_OPT_CVX_DIAGONAL_LIST_H #define CGAL_PARTITION_OPT_CVX_DIAGONAL_LIST_H #include #include #include typedef std::pair Partition_opt_cvx_diagonal; typedef std::list Partition_opt_cvx_diagonal_list; inline std::ostream& operator<<(std::ostream& os, const Partition_opt_cvx_diagonal_list& d) { Partition_opt_cvx_diagonal_list::const_iterator it; for (it = d.begin(); it != d.end(); it++) { os << "(" << (*it).first << ", " << (*it).second << ") "; } return os; } #endif // CGAL_PARTITION_OPT_CVX_DIAGONAL_LIST_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_min_items_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_min_items_30000644000175000017500000000331511344301500031356 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_min_items_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_POLYHEDRON_MIN_ITEMS_3_H #define CGAL_POLYHEDRON_MIN_ITEMS_3_H 1 #ifndef CGAL_HALFEDGEDS_VERTEX_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_HALFEDGE_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_FACE_BASE_H #include #endif CGAL_BEGIN_NAMESPACE class Polyhedron_min_items_3 { public: template < class Refs, class Traits> struct Vertex_wrapper { typedef typename Traits::Point_3 Point; typedef HalfedgeDS_vertex_base< Refs, Tag_false, Point> Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef HalfedgeDS_halfedge_base< Refs> Halfedge; }; template < class Refs, class Traits> struct Face_wrapper { typedef HalfedgeDS_face_base< Refs, Tag_false> Face; }; }; CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_MIN_ITEMS_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/long_long.h0000644000175000017500000000533011344301500027150 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/long_long.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra // ISO C++ does not support `long long', but ISO C does, which means the next // revision of ISO C++ probably will too. However, currently, g++ -pedantic // produces a warning so we don't include this file by default. #ifndef CGAL_LONG_LONG_H #define CGAL_LONG_LONG_H #include #include CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_true Has_gcd; typedef Tag_true Has_division; typedef Tag_false Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; inline long long int div(long long int i1, long long int i2) { return i1 / i2; } inline double to_double(long long int i) { return (double)i; } inline bool is_finite(long long int) { return true; } inline bool is_valid(long long int) { return true; } inline std::pair to_interval (const long long & z) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); Interval_nt approx ((double) z); FPU_set_cw(CGAL_FE_UPWARD); approx += Interval_nt::smallest(); return approx.pair(); } #if (defined(__sparc__) || defined(__sparc) || defined(sparc)) || \ (defined(__sgi__) || defined(__sgi) || defined(sgi)) || \ (defined(__i386__) || defined(__i386) || defined(i386)) || \ (defined(__ppc__) || defined(__ppc) || defined(ppc)) || \ (defined(__powerpc__) || defined(__powerpc) || defined(powerpc)) typedef long long int Integer64; typedef unsigned long long int UInteger64; #define CGAL_HAS_INTEGER64 #endif CGAL_END_NAMESPACE #endif // CGAL_LONG_LONG_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_vertex_circulator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_vertex_circu0000644000175000017500000001330211344301500031374 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_vertex_circulator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POLYGON_2_VERTEX_CIRCULATOR_H #define CGAL_POLYGON_2_VERTEX_CIRCULATOR_H namespace CGAL { template < class Ctnr> class Polygon_circulator { public: // TYPES typedef Polygon_circulator Self; typedef Circulator_from_container Mutable; typedef Ctnr Container; typedef typename Ctnr::iterator iterator; typedef typename Ctnr::const_iterator const_iterator; typedef typename Ctnr::value_type value_type; typedef typename Ctnr::const_reference reference; typedef const value_type* pointer; typedef typename Ctnr::size_type size_type; typedef typename Ctnr::difference_type difference_type; typedef std::iterator_traits ITraits; typedef typename ITraits::iterator_category Icategory; typedef I_Circulator_from_iterator_traits CTraits; typedef typename CTraits::iterator_category iterator_category; private: const Ctnr* ctnr; iterator i; public: // CREATION Polygon_circulator() : ctnr(NULL) {} Polygon_circulator( const Ctnr* c) : ctnr(c), i(c->begin()) {} Polygon_circulator( const Ctnr* c, iterator j) : ctnr(c), i(j) {} Polygon_circulator( const Mutable& c) : ctnr( c.container()), i( c.current_iterator()) {} // Gnu-bug workaround: define operator= explicitly. Self& operator=( const Self& c) { ctnr = c.ctnr; i = c.i; return *this; } // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return (ctnr == NULL) || (ctnr->begin() == ctnr->end()); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return i == c.i; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { CGAL_assertion( ctnr != NULL); CGAL_assertion( current_iterator() != ctnr->end()); return *i; } pointer operator->() const { CGAL_assertion( ctnr != NULL); CGAL_assertion( current_iterator() != ctnr->end()); return i.operator->(); } Self& operator++() { CGAL_assertion( ctnr != NULL); CGAL_assertion( current_iterator() != ctnr->end()); ++i; if ( current_iterator() == ctnr->end()) i = const_cast(ctnr)->begin(); return *this; } Self operator++(int) { Self tmp= *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( ctnr != NULL); CGAL_assertion( current_iterator() != ctnr->end()); if ( current_iterator() == ctnr->begin()) i = const_cast(ctnr)->end(); --i; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( difference_type n) { CGAL_assertion( ctnr != NULL); CGAL_assertion( current_iterator() != ctnr->end()); typename Ctnr::difference_type j = current_iterator() - ctnr->begin(); typename Ctnr::difference_type size = ctnr->size(); CGAL_assertion( j >= 0); CGAL_assertion( size >= 0); j = non_negative_mod( j + n, size); CGAL_assertion( j >= 0); CGAL_assertion( j < size); i = const_cast(ctnr)->begin() + j; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& c) const { CGAL_assertion( ctnr != NULL); CGAL_assertion( c.ctnr != NULL); return i - c.i; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return *tmp; } const_iterator current_iterator() const { return i;} iterator mod_iterator() const { return i;} Self min_circulator() const { return Self(ctnr); } const Ctnr* container() const { return ctnr; } }; template inline Polygon_circulator operator+( typename Polygon_circulator:: difference_type n, const Polygon_circulator& c) { Polygon_circulator tmp = c; return tmp += n; } } // end of namespace CGAL #endif // CGAL_POLYGON_2_VERTEX_CIRCULATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_akl_toussaint.h0000644000175000017500000000371611344301500030532 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_akl_toussaint.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_AKL_TOUSSAINT_H #define CGAL_CH_AKL_TOUSSAINT_H #include #include CGAL_BEGIN_NAMESPACE // same as |convex_hull_2(first,last,result)|. // {\sc traits}: operates on |Traits::Point_2| using |Traits::Less_xy_2|, // |Traits::Less_yx_2|, |Traits::Equal_2| and |Traits::Left_turn_2|. template OutputIterator ch_akl_toussaint(ForwardIterator first, ForwardIterator last, OutputIterator result, const Traits& ch_traits); template inline OutputIterator ch_akl_toussaint(ForwardIterator first, ForwardIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_akl_toussaint( first, last, result, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_AKL_TOUSSAINT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/copy_n.h0000644000175000017500000000372111344301500026463 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/copy_n.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete and exists only for backwards-compatibility. // Include instead. #ifndef CGAL_COPY_N_H #define CGAL_COPY_N_H 1 #include // copy_n is usually in the STL as well, but not in the official // standard. We provide our own copy_n. CGAL_BEGIN_NAMESPACE template OutputIterator copy_n( InputIterator first, Size n, OutputIterator result) { // copies the first `n' items from `first' to `result'. Returns // the value of `result' after inserting the `n' items. while( n--) { *result = *first; first++; result++; } return result; } CGAL_END_NAMESPACE #endif // CGAL_COPY_N_H // ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_face_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_face_bas0000644000175000017500000000372211344301500031330 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_face_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DELAUNAY_FACE_BASE_2_H #define CGAL_DELAUNAY_FACE_BASE_2_H #include namespace CGAL { template > class Delaunay_mesh_face_base_2 : public Fb { public: typedef Gt Geom_traits; typedef Constrained_triangulation_face_base_2 CTFb; typedef typename Fb::Vertex_handle Vertex_handle; typedef typename Fb::Face_handle Face_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename CTFb::template Rebind_TDS::Other Fb2; typedef Delaunay_mesh_face_base_2 Other; }; protected: bool marked; public: Delaunay_mesh_face_base_2(): Fb(), marked(false) {}; Delaunay_mesh_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Fb(v0,v1,v2), marked(false) {}; Delaunay_mesh_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Fb(v0,v1,v2,n0,n1,n2), marked(false) {}; inline bool is_marked() const { return marked; }; inline void set_marked(const bool b) { marked=b; }; }; }; // namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_default_dcel.h0000644000175000017500000004736011344301500030252 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_default_dcel.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_PM_DEFAULT_DCEL_H #define CGAL_PM_DEFAULT_DCEL_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*! Base vertex class */ template class Pm_vertex_base { protected: /*! An incident halfedge pointing at the vertex */ void * hdg; Pt pt; public: typedef Pt Point; Pm_vertex_base() {} Pm_vertex_base(const Pt & p) : pt(p) {} virtual ~Pm_vertex_base() {} void * halfedge() { return hdg; } const void * halfedge() const { return hdg; } void set_halfedge(void * h) { hdg = h; } Point & point() { return pt; } const Point & point() const { return pt; } void set_point(const Point & p) { pt = p; } // assign function for non-connectivity data virtual void assign(const Pm_vertex_base & v) { pt = v.pt; } }; /*! Base halfedge class */ template class Pm_halfedge_base { public: typedef X_curve Curve; /*! Parameterless Constructor */ Pm_halfedge_base() {} /*! Constructor */ Pm_halfedge_base(const X_curve & c) : cv(c) {} /*! Destructor */ virtual ~Pm_halfedge_base() {} /*! \brief obtains the opposite halfedge */ void * opposite() { return opp; } const void * opposite() const { return opp; } /*! \brief obtains the next halfedge along the face */ void * next() { return nxt; } const void * next() const { return nxt; } /*! \brief sets the opposite halfedge */ void set_opposite(void * h) { opp = h; } /*! \brief sets the next halfedge along the face */ void set_next(void * h) { nxt = h; } /*! \brief obtains the incident target vertex */ void * vertex() { return v; } const void * vertex() const { return v; } /*! \brief obtains the face to the left */ void * face() { return f; } const void * face() const { return f; } /*! \brief sets the incident target vertex */ void set_vertex(void * _v) { v = _v; } /*! \brief sets the face to the left */ void set_face(void * _f) { f = _f; } /*! \brief obtains the geometric x-monotone curve */ Curve & curve() { return cv; } const Curve & curve() const { return cv; } /*! \brief sets the geometric x-monotone curve */ void set_curve(const X_curve& c) { cv = c; } /*! assign function for non-connectivity data */ virtual void assign(const Pm_halfedge_base &e) { cv = e.cv; } protected: void * opp; void * nxt; void * v; // target void * f; // face X_curve cv; }; /*! Base face class */ class Pm_face_base { public: typedef std::list Holes_container; typedef Holes_container::iterator Holes_iterator; typedef Holes_container::const_iterator Holes_const_iterator; /*! Parameterless Constructor */ Pm_face_base() : holes() {}; /*! Destructor */ virtual ~Pm_face_base() {} void * halfedge() { return hdg;} const void * halfedge() const { return hdg;} void set_halfedge(void * h) {hdg = h;} Holes_iterator holes_begin() {return holes.begin();} Holes_iterator holes_end() {return holes.end();} Holes_const_iterator holes_begin() const {return holes.begin();} Holes_const_iterator holes_end() const {return holes.end();} void add_hole(void * halfedge_ptr) { holes.push_back(halfedge_ptr); } void erase_hole(Holes_iterator hit) { holes.erase(hit); } void erase_holes(Holes_iterator first, Holes_iterator last) { holes.erase(first,last); } // assign function for non-connectivity data virtual void assign(const Pm_face_base & f) { // The reason we do not assign anything here is because // we can't copy pointers of a face from another Pm_dcel. // The assign function of Pm_dcel does all the necessary updates. (void) f; // We avoid the `unused parameter' warning. } private: void * hdg; Holes_container holes; }; // Forward declarations: template class _Pm_Vertex; template class _Pm_Halfedge; template class _Pm_Face; /*! The vertex class */ template class _Pm_Vertex : public V, public In_place_list_base< _Pm_Vertex > { public: typedef V Base; typedef _Pm_Vertex Vertex; typedef _Pm_Halfedge Halfedge; typedef _Pm_Face Face; _Pm_Vertex() {} // _Pm_Vertex(const Point & p) : V(p) {} /*! \brief obtains an incident halfedge */ Halfedge * halfedge() { return (Halfedge*)(V::halfedge()); } /*! \brief obtains an incident halfedge */ const Halfedge * halfedge() const { return (const Halfedge*)(V::halfedge()); } /*! \brief sets an incident halfedge */ void set_halfedge(Halfedge * h) { V::set_halfedge(h); } #if 0 // Apparently the implementation of the In_place_list requires a copy // constructor of the value type! protected: // forbid copy constructor and assignment (only derived classes can use them) /*! Copy Constructor */ _Pm_Vertex(const _Pm_Vertex & v) {} /*! Assignment operator */ _Pm_Vertex & operator=(const _Pm_Vertex &) { return *this; } #endif }; /*! The halfdege class */ template class _Pm_Halfedge : public H, public In_place_list_base< _Pm_Halfedge > { public: typedef H Base; typedef _Pm_Vertex Vertex; typedef _Pm_Halfedge Halfedge; typedef _Pm_Face Face; _Pm_Halfedge() : H() {} //_Pm_Halfedge( const Curve& c) : H(c) {} /*! \brief obtains the opposite halfedge */ Halfedge * opposite() { return (Halfedge*)(H::opposite()); } //in the future will probably be implemented in a max base // const Halfedge* prev() const {return (const Halfedge*)(H::prev());} /*! \brief obtains the base halfedge */ Vertex * vertex() { return (Vertex*)(H::vertex()); } /*! \brief obtains the base halfedge */ const Vertex * vertex() const {return (const Vertex*)(H::vertex()); } /*! \brief obtains the incident base face */ Face * face() { return (Face*)(H::face()); } /*! \brief obtains the incident base face */ const Face * face() const {return (const Face*)(H::face()); } /*! \brief obtains the next halfedge along the face */ const Halfedge * next() const { return (const Halfedge*)(H::next()); } /*! \brief obtains the next halfedge along the face. */ Halfedge * next() { return (Halfedge*)(H::next()); } //in the future will probably be implemented in a max base // const Halfedge* prev() const {return (const Halfedge*)(H::prev()); } /*! \brief obtains the opposite halfedge */ const Halfedge * opposite() const { return (const Halfedge*)(H::opposite()); } /*! \brief sets the base vertex */ void set_vertex(Vertex * ve) { H::set_vertex(ve); } /*! \brief sets the next halfedge along the face */ void set_next(Halfedge * h) { H::set_next(h); } /*! \brief sets the incident base face */ void set_face(Face * face) { H::set_face(face); } //private: /*! \brief sets the opposite halfedge */ void set_opposite(void * h) { H::set_opposite(h); } #if 0 // Apparently the implementation of the In_place_list requires a copy // constructor of the value type! protected: //forbid copy constructor and assignment (only derived classes can use them) /*! Copy Constructor */ _Pm_Halfedge(const _Pm_Halfedge &) {} /*! Assignment Operator */ _Pm_Halfedge & operator=(const _Pm_Halfedge &) { return *this; } #endif }; /*! The face class */ template class _Pm_Face : public F, public In_place_list_base< _Pm_Face > { public: typedef F Base; typedef _Pm_Vertex Vertex; typedef _Pm_Halfedge Halfedge; typedef _Pm_Face Face; /*! Parameterless Constructor */ _Pm_Face() {} /*! \brief obtains an incident halfedge */ Halfedge * halfedge() { return (Halfedge*)(F::halfedge()); } /*! \brief obtains an incident halfedge */ const Halfedge * halfedge() const { return (const Halfedge*)(F::halfedge()); } /*! \brief sets an incident halfedge */ void set_halfedge(Halfedge * h) { F::set_halfedge(h); } typedef I_HalfedgeDS_iterator< typename F::Holes_iterator, Halfedge*, typename F::Holes_iterator::difference_type, typename F::Holes_iterator::iterator_category> Holes_iterator; typedef I_HalfedgeDS_const_iterator< typename F::Holes_const_iterator, typename F::Holes_iterator, const Halfedge*, typename F::Holes_const_iterator::difference_type, typename F::Holes_const_iterator::iterator_category> Holes_const_iterator; /*! \brief adds a hole */ void add_hole(Halfedge * h) { F::add_hole(h); } /*! \brief erases a hole */ void erase_hole(Holes_iterator hit) { F::erase_hole(hit.current_iterator()); } /*! \brief erases a range of holes */ void erase_holes(Holes_iterator first, Holes_iterator last) { F::erase_holes(first.current_iterator(), last.current_iterator()); } Holes_iterator holes_begin() {return F::holes_begin(); } Holes_iterator holes_end() {return F::holes_end(); } Holes_const_iterator holes_begin() const {return F::holes_begin(); } Holes_const_iterator holes_end() const {return F::holes_end(); } #if 0 // Apparently the implementation of the In_place_list requires a copy // constructor of the value type! protected: //forbid copy constructor and assignment (only derived classes can use them) /*! Copy Constructor */ _Pm_Face(const _Pm_Face &) {} /*! Assignment Operator */ _Pm_Face & operator=(const _Pm_Face &) { return * this; } #endif }; /*! A Dcel Class Using Lists */ template class Pm_dcel { public: typedef Pm_dcel Self; typedef _Pm_Vertex Vertex; typedef _Pm_Halfedge Halfedge; typedef _Pm_Face Face; protected: // Three managed in-place lists for the elements. typedef In_place_list Vertex_list; typedef In_place_list Halfedge_list; typedef In_place_list Face_list; public: typedef typename Halfedge_list::size_type Size; typedef typename Halfedge_list::size_type size_type; typedef typename Halfedge_list::difference_type difference_type; typedef typename Halfedge_list::difference_type Difference; typedef std::bidirectional_iterator_tag iterator_category; protected: Vertex_list vertices; Halfedge_list halfedges; Face_list faces; public: typedef typename Vertex_list::iterator Vertex_iterator; typedef typename Halfedge_list::iterator Halfedge_iterator; typedef typename Face_list::iterator Face_iterator; typedef CGAL::N_step_adaptor Edge_iterator; typedef typename Vertex_list::const_iterator Vertex_const_iterator; typedef typename Halfedge_list::const_iterator Halfedge_const_iterator; typedef typename Face_list::const_iterator Face_const_iterator; typedef CGAL::N_step_adaptor Edge_const_iterator; /*! Parameterless Constructor */ Pm_dcel() {} private: // Forbid copy constructor and assignment (will be implemented later). /*! Copy Constructor */ Pm_dcel(const Self & dcel) { // vertices = dcel.vertices; // halfedges = dcel.halfedges; // faces = dcel.faces; } /*! Assignment operator */ Self & operator=(const Self & dcel) { // vertices = dcel.vertices; // halfedges = dcel.halfedges; // faces = dcel.faces; return *this; } public: /*! Destructor */ ~Pm_dcel() { delete_all(); } public: Size size_of_vertices() const { return vertices.size(); } Size size_of_halfedges() const { return halfedges.size(); } Size size_of_faces() const { return faces.size(); } Vertex_iterator vertices_begin() { return vertices.begin(); } Vertex_iterator vertices_end() { return vertices.end(); } Halfedge_iterator halfedges_begin() { return halfedges.begin();} Halfedge_iterator halfedges_end() { return halfedges.end(); } Face_iterator faces_begin() { return faces.begin(); } Face_iterator faces_end() { return faces.end(); } Edge_iterator edges_begin() { return halfedges.begin(); } Edge_iterator edges_end() { return halfedges.end(); } // The constant iterators and circulators. Vertex_const_iterator vertices_begin() const { return vertices.begin(); } Vertex_const_iterator vertices_end() const { return vertices.end(); } Halfedge_const_iterator halfedges_begin() const { return halfedges.begin(); } Halfedge_const_iterator halfedges_end() const { return halfedges.end(); } Face_const_iterator faces_begin() const { return faces.begin(); } Face_const_iterator faces_end() const { return faces.end(); } Edge_const_iterator edges_begin() const { return halfedges.begin(); } Edge_const_iterator edges_end() const { return halfedges.end(); } // Insertion // // The following operations just allocate a new element of that type. // Halfedges are always allocated in pairs of opposite halfedges. The // opposite pointers are automatically set. Vertex* new_vertex() { Vertex* v = new Vertex; vertices.push_back( *v); return v; } Vertex* new_vertex( const Vertex* w) { Vertex* v = new Vertex(*w); vertices.push_back( *v); return v; } /* Vertex* new_vertex( const Point& p) { Vertex* v = new Vertex(p); vertices.push_back( *v); return v; } */ Halfedge * new_halfedge() { Halfedge * h = new Halfedge; halfedges.push_back(*h); return h; } Halfedge * new_halfedge(const Halfedge * he) { Halfedge * h = new Halfedge( *he); halfedges.push_back(*h); return h; } Halfedge * new_edge() { // creates a new pair of opposite halfedges. Halfedge * h = new_halfedge(); Halfedge * g = new_halfedge(); h->H::set_opposite(g); g->H::set_opposite(h); return h; } Halfedge * new_edge( const Halfedge * he) { Halfedge * h = new_halfedge(he); Halfedge * g = new_halfedge(he->opposite()); h->H::set_opposite(g); g->H::set_opposite(h); return h; } /* Halfedge* new_edge(const Curve& c) { Halfedge* h = new Halfedge(c); Halfedge* g = new Halfedge(c); //maybe change to flip?? // h->H::set_twin(g); //g->H::set_twin(h); h->H::set_opposite(g); g->H::set_opposite(h); halfedges.push_back( *h); halfedges.push_back( *g); return h; }*/ Face * new_face() { Face * f = new Face; faces.push_back(*f); return f; } Face * new_face(const Face * g) { Face * f = new Face(*g); faces.push_back(*f); return f; } // Removal // // The following operations erase an element referenced by a pointer. // Halfedges are always deallocated in pairs of opposite halfedges. Erase // of single elements is optional. The deletion of all is mandatory. void delete_vertex(Vertex * v) { vertices.erase(v); delete v; } void delete_halfedge(Halfedge * h) { halfedges.erase(h); delete h; } void delete_edge(Halfedge * h) { // deletes the pair of opposite halfedges h. Halfedge * g = h->opposite(); delete_halfedge(h); delete_halfedge(g); } void delete_face(Face * f) { faces.erase(f); delete f; } void delete_all() { for (Vertex_iterator vi = vertices.begin(); vi != vertices.end();) { Vertex_iterator curr = vi; ++vi; delete_vertex(&(*curr)); } for (Halfedge_iterator hi = halfedges.begin(); hi != halfedges.end();) { Halfedge_iterator curr = hi; ++hi; delete_halfedge(&(*curr)); } for (Face_iterator fi = faces.begin(); fi != faces.end();) { Face_iterator curr = fi; ++fi; delete_face(&(*curr)); } // vertices.destroy(); // halfedges.destroy(); // faces.destroy(); } /*! returns the unbounded face in the assigned map */ void * assign(const Self & d, void * u_face) { //typedef std::map VertexMap; //typedef std::map HalfedgeMap; //typedef std::map FaceMap; typedef std::map ConnectMap; delete_all(); ConnectMap vm, hm, fm; //VertexMap vm; //HalfedgeMap hm; //FaceMap fm; Vertex_const_iterator vit; Halfedge_const_iterator hit; Face_const_iterator fit; for (vit = d.vertices_begin(); vit != d.vertices_end(); vit++) { Vertex * nv = new_vertex(); nv->assign(*vit); vm.insert(ConnectMap::value_type((void*)&(*vit), (void*)nv)); } for (hit = d.halfedges_begin(); hit != d.halfedges_end(); hit++) { Halfedge * nh = new_halfedge(); nh->assign(*hit); hm.insert(ConnectMap::value_type((void*)(&(*hit)), (void*)nh)); } for (fit = d.faces_begin(); fit != d.faces_end(); fit++) { Face * nf = new_face(); nf->assign(*fit); fm.insert(ConnectMap::value_type((void*)&(*fit), (void*)nf)); } // update pointers for (vit = d.vertices_begin(); vit != d.vertices_end(); vit++) { void *he, *nhe, *nv, *v; v = (void*)(&(*vit)); nv = (void*)(vm.find(v)->second); he = (void*)vit->halfedge(); nhe = (void*)(hm.find(he)->second); ((Vertex*)nv)->set_halfedge((Halfedge*)nhe); } for (hit = d.halfedges_begin(); hit != d.halfedges_end(); hit++) { void *he, *nhe, *v, *nv, *f, *nf, *op, *nop, *xt, *nxt; he = (void*)(&(*hit)); nhe = hm.find(he)->second; v = (void*)hit->vertex(); f = (void*)hit->face(); op = (void*)hit->opposite(); xt = (void*)hit->next(); nv = vm.find(v)->second; nf = fm.find(f)->second; nop = hm.find(op)->second; nxt = hm.find(xt)->second; ((Halfedge*)nhe)->set_vertex((Vertex*)nv); ((Halfedge*)nhe)->set_face((Face*)nf); ((Halfedge*)nhe)->set_opposite((Halfedge*)nop); ((Halfedge*)nhe)->set_next((Halfedge*)nxt); } for (fit = d.faces_begin(); fit != d.faces_end(); fit++) { void *f, *nf, *he, *nhe, *h, *nh; typename Face::Holes_const_iterator holes; f = (void*)(&(*fit)); nf = fm.find(f)->second; he = (void*)fit->halfedge(); if (he != NULL) nhe = hm.find(he)->second; else nhe = NULL; ((Face*)nf)->set_halfedge((Halfedge*)nhe); for (holes = fit->holes_begin(); holes != fit->holes_end(); holes++) { h = (void*)(*holes); nh = hm.find(h)->second; ((Face*)nf)->add_hole((Halfedge*)nh); } } return fm.find(u_face)->second; } }; /*! * DEFAULT DCEL */ template class Pm_default_dcel : public Pm_dcel, Pm_halfedge_base, Pm_face_base> { public: Pm_default_dcel() {} }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_3.h0000644000175000017500000000475411344301500026160 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_RAY_3_H #define CGAL_RAY_3_H CGAL_BEGIN_NAMESPACE template class Ray_3 : public R_::Kernel_base::Ray_3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Kernel_base::Ray_3 RRay_3; public: typedef R_ R; Ray_3() {} Ray_3(const RRay_3& r) : RRay_3(r) {} Ray_3(const Point_3& sp, const Point_3& secondp) : RRay_3(sp, secondp) {} Ray_3(const Point_3& sp, const Vector_3& v) : RRay_3(sp, v) {} Ray_3(const Point_3& sp, const Direction_3& d) : RRay_3(sp, d) {} Ray_3(const Point_3& sp, const Line_3& l) : RRay_3(sp, l) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_RAY_3 template < class R > std::ostream& operator<<(std::ostream& os, const Ray_3& r) { typedef typename R::Kernel_base::Ray_3 RRay_3; return os << static_cast(r); } #endif // CGAL_NO_OSTREAM_INSERT_RAY_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_RAY_3 template < class R > std::istream& operator>>(std::istream& is, Ray_3& r) { typedef typename R::Kernel_base::Ray_3 RRay_3; return is >> static_cast(r); } #endif // CGAL_NO_ISTREAM_EXTRACT_RAY_3 CGAL_END_NAMESPACE #endif // CGAL_RAY_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/basic.h0000644000175000017500000000415111344301500026253 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/basic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner // Stefan Schirra #ifndef CGAL_BASIC_H #define CGAL_BASIC_H #include #include #include // Big endian or little endian machine. // ==================================== #ifdef CGAL_CFG_NO_BIG_ENDIAN # define CGAL_LITTLE_ENDIAN 1 #else # define CGAL_BIG_ENDIAN 1 #endif #ifndef CGAL_USE_LEDA # define CGAL_USE_CGAL_WINDOW #endif // Symbolic constants to tailor inlining. Inlining Policy. // ======================================================= #ifndef CGAL_MEDIUM_INLINE # define CGAL_MEDIUM_INLINE inline #endif #ifndef CGAL_LARGE_INLINE # define CGAL_LARGE_INLINE #endif #ifndef CGAL_HUGE_INLINE # define CGAL_HUGE_INLINE #endif #include #include #include #include #include #include #include #include // This should be removed ASAP. #include #include #endif // CGAL_BASIC_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Hyperbola_2.h0000644000175000017500000001632311344301500027344 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Hyperbola_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_HYPERBOLA_2_H #define CGAL_HYPERBOLA_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Gt > class Hyperbola_2 { public: typedef Gt Geom_traits; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Segment_2 Segment_2; typedef typename Gt::Point_2 Point_2; typedef typename Gt::FT FT; #if 0 typedef typename Kernel_traits::Kernel Kernel; typedef CGAL::Apollonius_site_2 Site_2; typedef typename Kernel::Segment_2 Segment_2; typedef Point Point_2; typedef typename Kernel::FT FT; #endif // typedef typename R::RT FT; // typedef double FT; // typedef CGAL::Point_2< Cartesian > Point_2; // typedef CGAL::Segment_2< Cartesian< double > > Segment_2; protected: FT STEP; Point_2 f1, f2; FT r; Point_2 o; inline Point_2 lchain(const FT &t) const { std::vector< Point_2 > p = compute_points(t); if ( right(p[0]) ) return p[1]; return p[0]; } inline Point_2 rchain(const FT &t) const { std::vector< Point_2 > p = compute_points(t); if ( right(p[0]) ) return p[0]; return p[1]; } inline FT norm2(const Point_2& p) const { return (CGAL::square(p.x()) + CGAL::square(p.y())); } inline FT distance2(const Point_2& p1, const Point_2& p2) const { FT dx = p1.x()-p2.x(); FT dy = p1.y()-p2.y(); return (CGAL::square(dx) + CGAL::square(dy)); } inline FT distance(const Point_2& p1, const Point_2& p2) const { return CGAL::sqrt( distance2(p1, p2) ); } void compute_origin() { FT dx = f2.x() - f1.x(); FT dy = f2.y() - f1.y(); FT a = CGAL::sqrt(CGAL::square(dx) + CGAL::square(dy)); FT t = (FT(1) + r / a) / FT(2); o = Point_2(dx * t + f1.x(), dy * t + f1.y()); } std::vector< Point_2 > compute_points(const FT &d) const { FT d1 = distance(o, f1) + d; FT d2 = distance(o, f2) + d; d1 *= d1; d2 *= d2; Point_2 df = Point_2(f2.x() - f1.x(), f2.y()-f1.y()); std::vector< Point_2 > p; if ( CGAL::is_negative(d) ) return p; if ( CGAL::is_zero(df.x()) ) { FT y = (d1 - d2 + norm2(f2) - norm2(f1)) / (FT(2) * df.y()); FT D = d1 - CGAL::square(y - f1.y()); D = CGAL::abs(D); FT x1 = CGAL::sqrt(D) + f1.x(); FT x2 = -CGAL::sqrt(D) + f1.x(); p.push_back(Point_2(x1, y)); p.push_back(Point_2(x2, y)); return p; } FT gamma = (d1 - d2 + norm2(f2) - norm2(f1)) / (FT(2) * df.x()); FT gamma1 = gamma - f1.x(); FT beta = df.y() / df.x(); FT a = FT(1) + CGAL::square(beta); FT b = -FT(2) * (gamma1 * beta + f1.y()); FT c = CGAL::square(f1.y()) + CGAL::square(gamma1) - d1; FT D = CGAL::square(b) - FT(4) * a * c; D = CGAL::abs(D); FT y1 = (-b + CGAL::sqrt(D)) / (FT(2) * a); FT y2 = (-b - CGAL::sqrt(D)) / (FT(2) * a); FT x1 = gamma - beta * y1; FT x2 = gamma - beta * y2; p.push_back(Point_2(x1, y1)); p.push_back(Point_2(x2, y2)); return p; } bool right(const Point_2& p) const { return CGAL::is_negative( det3x3_by_formula(f1.x(), f1.y(), 1, f2.x(), f2.y(), 1, p.x(), p.y(), 1) ); } inline Point_2 midpoint(const Point_2& p1, const Point_2& p2) const { FT t1 = t(p1); FT t2 = t(p2); FT midt = (t1+t2)/2; return f(midt); } inline Point_2 f(FT t) const { if ( CGAL::is_negative(t) ) return rchain(-t); return lchain(t); } inline FT t(const Point_2 &p) const { FT tt = distance(f1, p) - distance(f1, o); if ( right(p) ) return -tt; return tt; } public: Hyperbola_2() { STEP = FT(2); } Hyperbola_2(const Site_2 &f1, const Site_2 &f2) { STEP = FT(2); this->r = f1.weight() - f2.weight(); this->f1 = f1.point(); this->f2 = f2.point(); compute_origin(); } Oriented_side side_of_hyperbola(const Point_2 &p) const { double dist = distance(p, f1) - distance(p, f2) - r; if ( dist < 0 ) return ON_NEGATIVE_SIDE; if ( dist > 0 ) return ON_POSITIVE_SIDE; return ON_ORIENTED_BOUNDARY; } #if defined CGAL_USE_QT template void generate_points_qt(const QTWIDGET& W, std::vector& pleft, std::vector& pright) const { std::vector< Point_2 > p; pleft.push_back(o); pright.push_back(o); double width = W.x_max() - W.x_min(); double height = W.y_max() - W.y_min(); FT STEP; if ( width < height ) { STEP = width / 500.0; } else { STEP = height / 500.0; } // double mind = distance(o, f1) - r1; for (int i = 1; i <= 100; i++) { p = compute_points(FT(i * i) * STEP); if ( p.size() > 0 ) { if ( right(p[0]) ) { pright.push_back(p[0]); pleft.push_back(p[1]); } else { pright.push_back(p[1]); pleft.push_back(p[0]); } } } } template void draw_qt(QTWIDGET& W) const { std::vector< Point_2 > pleft, pright; generate_points_qt(pleft, pright); for (unsigned int i = 0; i < pleft.size() - 1; i++) { W << Segment_2(pleft[i], pleft[i+1]); } for (unsigned int i = 0; i < pright.size() - 1; i++) { W << Segment_2(pright[i], pright[i+1]); } } #endif void generate_points(std::vector& pleft, std::vector& pright) const { std::vector< Point_2 > p; pleft.push_back(o); pright.push_back(o); // double mind = distance(o, f1) - r1; for (int i = 1; i <= 100; i++) { p = compute_points(FT(i * i) * STEP); if ( p.size() > 0 ) { if ( right(p[0]) ) { pright.push_back(p[0]); pleft.push_back(p[1]); } else { pright.push_back(p[1]); pleft.push_back(p[0]); } } } } template< class Stream > void draw(Stream &W) const { std::vector< Point_2 > pleft, pright; generate_points(pleft,pright); for (unsigned int i = 0; i < pleft.size() - 1; i++) { W << Segment_2(pleft[i], pleft[i+1]); } for (unsigned int i = 0; i < pright.size() - 1; i++) { W << Segment_2(pright[i], pright[i+1]); } } }; template< class Stream, class Gt > inline Stream& operator<<(Stream& s, const Hyperbola_2 &H) { H.draw(s); return s; } CGAL_END_NAMESPACE #endif // CGAL_HYPERBOLA_2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_hyper_segment_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_hyper_segment_trai0000644000175000017500000003657111344301500031453 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_hyper_segment_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_ARR_HYPER_SEGMENT_TRAITS_2_H #define CGAL_ARR_HYPER_SEGMENT_TRAITS_2_H #include #include CGAL_BEGIN_NAMESPACE /*! * A traits class for maintaining an arrangement of x-monotone segments of * canonical hyperbolas. */ template class Arr_hyper_segment_traits_2 : public Kernel_ { public: typedef Kernel_ Kernel; typedef Tag_true Has_left_category; // Traits objects: typedef typename Kernel::Point_2 Point_2; typedef Hyper_segment_2 X_monotone_curve_2; typedef Hyper_segment_2 Curve_2; // For backward compatability: typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef X_monotone_curve_2 Curve; protected: // Functors: typedef typename Kernel::Less_x_2 Less_x_2; typedef typename Kernel::Equal_2 Equal_2; typedef typename Kernel::Compare_x_2 Compare_x_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Compare_xy_2 Compare_xy_2; public: /*! * Default constructor. */ Arr_hyper_segment_traits_2() {} /*! * Compare the x-coordinates of two given points. * \param p1 The first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL. */ Comparison_result compare_x(const Point_2 & p1, const Point_2 & p2) const { return (compare_x_2_object()(p1, p2)); } /*! * Compares lexigoraphically the two points: by x, then by y. * \param p1 Te first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL. */ Comparison_result compare_xy(const Point_2 & p1, const Point_2 & p2) const { return (compare_xy_2_object()(p1, p2)); } /*! * Check whether the given curve is a vertical segment. * \param cv The curve. * \return (true) if the curve is vertical. */ bool curve_is_vertical(const X_monotone_curve_2 & cv) const { // Currently no vertical segments are allowed: return (false); } /*! * Check whether the given point is in the x-range of the given curve. * In out case, the curve is a segment [s, t], check whether x(s)<=x(q)<=x(t) * or whether x(t)<=x(q)<=x(s). * \param cv The curve. * \param q The point. * \return (true) if q is in the x-range of cv. */ bool point_in_x_range(const X_monotone_curve_2 & cv, const Point_2 & q) const { return (cv.point_is_in_x_range(q)); } /*! * Get the relative status of two curves at the x-coordinate of a given * point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x-range of the two curves. * \return LARGER if cv1(x(q)) > cv2(x(q)); SMALLER if cv1(x(q)) < cv2(x(q)); * or else EQUAL. */ Comparison_result curves_compare_y_at_x(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { CGAL_precondition(point_in_x_range(cv1, q)); CGAL_precondition(point_in_x_range(cv2, q)); return (cv1.compare_y_at_x (cv2, q)); } /*! * Compares the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its left. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the left of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1)); CGAL_precondition(! curve_is_vertical(cv2)); // The two curve must be defined at q and also to its left. CGAL_precondition_code(Less_x_2 less_x = less_x_2_object();); CGAL_precondition (point_in_x_range(cv1, q)); CGAL_precondition (less_x(cv1.source(), q) || less_x(cv1.target(), q)); CGAL_precondition (point_in_x_range(cv2, q)); CGAL_precondition (less_x(cv2.source(), q) || less_x(cv2.target(), q)); // Notice q is a placeholder for the x coordinate of the two curves. // That is, if we compare them at x(q) the result should be EQUAL. CGAL_precondition(cv1.compare_y_at_x (cv2, q) == EQUAL); // Compare the slopes of the two segments to determine thir relative // position immediately to the left of q. // Notice we use the supporting lines in order to compare the slopes. return (cv2.compare_slopes (cv1, q)); } /*! * Compares the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its right. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the right of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_right(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1)); CGAL_precondition(! curve_is_vertical(cv2)); // The two curve must be defined at q and also to its right. CGAL_precondition_code(Less_x_2 less_x = less_x_2_object();); CGAL_precondition (point_in_x_range(cv1, q)); CGAL_precondition (less_x(q, cv1.source()) || less_x(q, cv1.target())); CGAL_precondition (point_in_x_range(cv2, q)); CGAL_precondition (less_x(q, cv2.source()) || less_x(q, cv2.target())); // Notice q is a placeholder for the x coordinate of the two curves. // That is, if we compare them at x(q) the result should be EQUAL. CGAL_precondition(cv1.compare_y_at_x (cv2, q) == EQUAL); // Compare the slopes of the two segments to determine thir relative // position immediately to the left of q. // Notice we use the supporting lines in order to compare the slopes. return (cv1.compare_slopes (cv2, q)); } /*! * Return the location of the given point with respect to the input curve. * \param cv The curve. * \param p The point. * \pre p is in the x-range of cv. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x(const Point_2 & p, const X_monotone_curve_2 & cv) const { CGAL_precondition(point_in_x_range(cv, p)); return (cv.point_position(p)); } /*! * Check if the two curves are the same (have the same graph). * \param cv1 The first curve. * \param cv2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { return (cv1.is_equal (cv2)); } /*! * Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal(const Point_2 & p1, const Point_2 & p2) const { return (equal_2_object()(p1, p2)); } /*! * Get the curve source. * \param cv The curve. * \return The source point. */ const Point_2& curve_source(const X_monotone_curve_2 & cv) const { return (cv.source()); } /*! * Get the curve target. * \param cv The curve. * \return The target point. */ const Point_2& curve_target(const X_monotone_curve_2 & cv) const { return (cv.target()); } /*! * Check whether the curve is x-monotone. * \param cv The curves. * \return (true) if the curve is x-monotone. In case of segments, the * function always returns (true), since all segments are x-monotone. * Vertical segments are also considered as 'weakly' x-monotone. */ bool is_x_monotone(const Curve_2 &) const { // Return true, since a hyper-segment is always x-monotone. return (true); } /*! * Cut the given curve into x-monotone subcurves and insert them to the * given output iterator. While segments are x_monotone, still need to pass * them out. * \param cv The curve. * \param o The output iterator * \return The past-the-end iterator */ template OutputIterator curve_make_x_monotone (const Curve_2& cv, OutputIterator oi) const { *oi++ = cv; return (oi); } /*! * Flip a given curve. * \param cv The input curve. * \return The flipped curve. In case of segments, if the input is [s,t], * then the flipped curve is simply [t,s]. */ X_monotone_curve_2 curve_opposite (const X_monotone_curve_2 & cv) const { return (cv.flip()); } /*! * Split a given curve at a given split point into two sub-curves. * \param cv the curve to split * \param c1 the output first part of the split curve. Its source is the * source of the original curve. * \param c2 the output second part of the split curve. Its target is the * target of the original curve. * \param p the split point. * \pre p lies on cv but is not one of its end-points. */ void curve_split(const X_monotone_curve_2& cv, X_monotone_curve_2& c1, X_monotone_curve_2& c2, const Point_2& p) const { cv.split (p, c1, c2); return; } /*! * Find the nearest intersection point (or points) of two given curves to * the right lexicographically of a given point not includin the point * itself, (with one exception explained below). * If the intersection of the two curves is an X_monotone_curve_2, that is, * they overlap at infinitely many points, then if the right endpoint and the * left endpoint of the overlapping subcurve are strickly to the right of * the given point, they are returned through the two other point * references respectively. If the given point is between the * overlapping-subcurve endpoints, or the point is its left endpoint, * the point and the right endpoint of the subcurve are returned through * the point references respectively. If the intersection of the two curves * is a point to the right of the given point, it is returned through the * point references. * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \param p1 The first output point. * \param p2 The second output point. * \return (true) if c1 and c2 do intersect to the right of p, or (false) * if no such intersection exists. */ bool nearest_intersection_to_right(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & p, Point_2 & p1, Point_2 & p2) const { int n_pts = cv1.intersect(cv2, p1, p2); if (n_pts == 0) { return (false); } else if (n_pts == 1) { // Check if the intersection is to p's right. if (compare_xy_2_object()(p1, p) == LARGER) { p2 = p1; return (true); } else return (false); } else // In case of an overlap. { // Notice that p1 < p2. if (compare_xy_2_object()(p1, p) == LARGER) { return (true); } else if (compare_xy_2_object()(p2, p) == LARGER) { p1 = p; return (true); } return (false); } } /*! * Find the nearest intersection point of two given curves to the left of * a given point. Nearest is defined as the lexicographically nearest not * including the point itself (with one exception explained below). * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, then if the the source and target of the * subcurve are strickly to the left, they are returned through two * other point references p1 and p2. If p is between the source and target * of the overlapping subcurve, or p is its right endpoint, p and the source * of the left endpoint of the subcurve are returned through p1 and p2 * respectively. * If the intersection of the two curves is a point to the left of p, it is * returned through the p1 and p2. * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \param p1 The first output point. * \param p2 The second output point. * \return (true) if c1 and c2 do intersect to the left of p, or (false) * if no such intersection exists. */ bool nearest_intersection_to_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & p, Point_2 & p1, Point_2 & p2) const { int n_pts = cv1.intersect(cv2, p1, p2); if (n_pts == 0) { return (false); } else if (n_pts == 1) { // Check if the intersection is to p's left. if (compare_xy_2_object()(p1, p) == SMALLER) { p2 = p1; return (true); } return (false); } else // In case of an overlap. { // Notice that p1 < p2. if (compare_xy_2_object()(p2, p) == SMALLER) { return (true); } else if (compare_xy_2_object()(p1, p) == SMALLER) { p2 = p; return (true); } return (false); } } /*! * Check whether the two given curves overlap. * \patam cv1 The first curve. * \patam cv2 The second curve. * \return (true) if the two curves overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, if they have a finite * number of intersection points, or none at all, return (false). */ bool curves_overlap(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { Point_2 p1, p2; return (cv1.intersect(cv2, p1, p2) == 2); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000002216211344301500031413 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_MINIBALL #define CGAL_MINIBALL_MINIBALL #include #include #include // for std::rand() #include #include #include #include #include namespace CGAL_MINIBALL_NAMESPACE { // We provide several algorithms to solve the Miniball problem. The // following types are used by the client to select the algorithm he // or she wants to run. struct LP_algorithm {}; struct Farthest_first_heuristic {}; typedef Farthest_first_heuristic Default_algorithm; template class Min_sphere_of_spheres_d { public: // some short hands: typedef typename Traits::Sphere Sphere; typedef typename Traits::FT FT; typedef typename Min_sphere_of_spheres_d_impl:: Selector::Result Result; typedef typename Min_sphere_of_spheres_d_impl:: Selector::Is_exact Is_exact; typedef typename Traits::Use_square_roots Use_sqrt; typedef typename Traits::Algorithm Algorithm; static const int D = Traits::D; typedef typename Traits::Cartesian_const_iterator CIt; private: // traits class: Traits t; // To allow the traits to not only vary at compile- but // also at runtime, we instantiate it here. private: // for internal consisteny checks: // The following variable is true if and only if the miniball // has been computed of all inserted balls, i.e. iff every checked-in // ball has been respected in the miniball computation. bool is_up_to_date; public: // iterators: typedef const Result *Cartesian_const_iterator; // coordinate iterator class Support_iterator { typedef typename std::vector::const_iterator It; It it; private: friend class Min_sphere_of_spheres_d; Support_iterator(It it) : it(it) {} public: const Sphere& operator*() { return *(*it); } Support_iterator& operator++() { ++it; return *this; } Support_iterator operator++(int) { Support_iterator old(*this); ++(*this); return old; } bool operator!=(const Support_iterator& i) { return it != i.it; } }; public: // construction and destruction: inline Min_sphere_of_spheres_d(const Traits& traits = Traits()); template inline Min_sphere_of_spheres_d(InputIterator begin,InputIterator end, const Traits& traits = Traits()) : t(traits), ss(t), e(0) { is_up_to_date = false; CGAL_MINIBALL_ASSERT(is_neg(ss.radius(),ss.disc())); insert(begin,end); // todo. better way? } inline void prepare(int size); inline void insert(const Sphere& b); template inline void insert(InputIterator begin,InputIterator end) { prepare(S.size()+(end-begin)); // todo. istream? while (begin != end) { insert(*begin); ++begin; } } inline void clear(); template inline void set(InputIterator begin,InputIterator end) { clear(); insert(begin,end); } public: // predicates and accessors: inline bool is_empty(); inline const Result& radius(); inline Cartesian_const_iterator center_cartesian_begin(); inline Cartesian_const_iterator center_cartesian_end(); inline const FT& discriminant(); inline Support_iterator support_begin(); inline Support_iterator support_end(); inline const Traits& traits() const { return t; } public: // validity check: bool is_valid(); private: bool is_valid(const Tag_true is_exact); bool is_valid(const Tag_false is_exact); private: void update(); void update(LP_algorithm); void update(Farthest_first_heuristic); bool find_farthest(int from,int to,int& i, Tag_true use_sqrt,Tag_false is_exact); bool find_farthest(int from,int to,int& i, Tag_true use_sqrt,Tag_true is_exact); bool find_farthest(int from,int to,int& i, Tag_false use_sqrt,Tag_false is_exact); bool find_farthest(int from,int to,int& i, Tag_false use_sqrt,Tag_true is_exact); private: std::vector S; // list of the added bals std::vector l; // list of pointers to the added bals Min_sphere_of_spheres_d_impl:: Support_set ss; // current support set int e; // l[0..(e-1)] is a basis private: // forbid copy constructing and assignment (because our // pointers in ss would be wrong then): Min_sphere_of_spheres_d(const Min_sphere_of_spheres_d&); Min_sphere_of_spheres_d& operator=(const Min_sphere_of_spheres_d&); }; template Min_sphere_of_spheres_d:: Min_sphere_of_spheres_d(const Traits& traits) : t(traits), ss(t), e(0) { is_up_to_date = true; CGAL_MINIBALL_ASSERT(is_neg(ss.radius(),ss.disc())); // makes sure // that initially no ball is enclosed (cf. contains()). } template void Min_sphere_of_spheres_d::prepare(int size) { S.reserve(size); // (The vector l will be reserve()'d in update().) } template void Min_sphere_of_spheres_d::insert(const Sphere& b) { CGAL_MINIBALL_ASSERT(t.radius(b) >= FT(0)); S.push_back(b); // (We push_back a pointer to S.back() in update().) is_up_to_date = false; } template void Min_sphere_of_spheres_d::clear() { S.clear(); l.clear(); ss.reset(); e = 0; is_up_to_date = true; } template bool Min_sphere_of_spheres_d::is_empty() { if (!is_up_to_date) update(); return is_neg(ss.radius(),ss.disc()); } template const typename Min_sphere_of_spheres_d::Result& Min_sphere_of_spheres_d::radius() { if (!is_up_to_date) update(); CGAL_MINIBALL_ASSERT(!is_empty()); return ss.radius(); } template typename Min_sphere_of_spheres_d::Cartesian_const_iterator Min_sphere_of_spheres_d::center_cartesian_begin() { if (!is_up_to_date) update(); CGAL_MINIBALL_ASSERT(!is_empty()); return ss.begin(); } template typename Min_sphere_of_spheres_d::Cartesian_const_iterator Min_sphere_of_spheres_d::center_cartesian_end() { if (!is_up_to_date) update(); CGAL_MINIBALL_ASSERT(!is_empty()); return ss.begin()+D; } template const typename Min_sphere_of_spheres_d::FT& Min_sphere_of_spheres_d::discriminant() { if (!is_up_to_date) update(); CGAL_MINIBALL_ASSERT(!is_empty()); return ss.disc(); } template inline void Min_sphere_of_spheres_d::update() { // set up the vector l containing pointers to the balls in S: CGAL_MINIBALL_ASSERT(l.size() == 0); for (typename std::vector::const_iterator it = S.begin(); it != S.end(); ++it) l.push_back(&(*it)); // compute the miniball: update(Algorithm()); is_up_to_date = true; } template inline bool Min_sphere_of_spheres_d::is_valid() { if (!is_up_to_date) update(); return is_valid(Is_exact()); } template inline typename Min_sphere_of_spheres_d::Support_iterator Min_sphere_of_spheres_d::support_begin() { if (!is_up_to_date) update(); return Support_iterator(*l.begin()); } template inline typename Min_sphere_of_spheres_d::Support_iterator Min_sphere_of_spheres_d::support_end() { if (!is_up_to_date) update(); return Support_iterator(*l.begin()+e); } } // namespace CGAL_MINIBALL_NAMESPACE // If the package is used with CGAL, we include some default // traits classes: #ifdef CGAL_VERSION #include #include #include #endif #ifdef CGAL_MINIBALL_NO_TEMPLATE_EXPORT #include #include #endif #endif // CGAL_MINIBALL_MINIBALL ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_simple_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_simple_point_locati0000644000175000017500000003466411344301500031451 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_simple_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Eyal Flato #ifndef CGAL_PM_SIMPLE_POINT_LOCATION_H #define CGAL_PM_SIMPLE_POINT_LOCATION_H #include #include #include CGAL_BEGIN_NAMESPACE template class Pm_simple_point_location : public Pm_point_location_base { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; typedef Pm_point_location_base Base; typedef Pm_simple_point_location Self; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Halfedge Halfedge; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef Pm_bounding_box_base Bounding_box; typedef typename Base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Base::Token Token; typedef std::list Halfedges_const_list; public: Pm_simple_point_location() : Pm_point_location_base(), traits(0) {} Pm_simple_point_location(Planar_map* _pm,Traits_wrap* _traits) : Pm_point_location_base(),traits(_traits),pm(_pm) {} void init(Planar_map & pmp, const Traits& tr) { pm = &pmp; traits = (Traits_wrap*)(&tr); } void insert(Halfedge_handle, const X_curve &) { } void find_relevant_halfedges(const Point& p, Halfedges_const_list &relevant) const { // find whether p is on a halfedge typename Planar_map::Halfedge_const_iterator hit; for (hit = pm->halfedges_begin(); hit != pm->halfedges_end(); ++hit) { if (traits->point_in_x_range(hit->curve(),p)) { relevant.push_back(hit); } } } Halfedge_const_handle locate(const Point& p, Locate_type& lt) const { // find whether p is on a vertex typename Planar_map::Vertex_const_iterator vit; for (vit=pm->vertices_begin(); vit!=pm->vertices_end(); ++vit) { if (traits->point_equal(p,vit->point()) ) { lt = Planar_map::VERTEX; Halfedge_const_handle h(vit->incident_halfedges()); return h; } } Halfedges_const_list relevant_halfedges; find_relevant_halfedges(p, relevant_halfedges); // find whether p is on a halfedge typename Halfedges_const_list::const_iterator hit; for (hit=relevant_halfedges.begin(); hit!=relevant_halfedges.end(); ++hit) { if (traits->point_in_x_range((*hit)->curve(),p) && traits->curve_compare_y_at_x(p, (*hit)->curve()) == EQUAL) { lt = Planar_map::EDGE; return *hit; } } lt = Planar_map::UNBOUNDED_FACE; Locate_type temp; Halfedge_const_handle h; h = vertical_ray_shoot(p, temp, true, relevant_halfedges); if( temp != Planar_map::UNBOUNDED_FACE ) { if (temp == Planar_map::VERTEX) { //since h points at the vertex and is the first h=h->twin(); //halfedge after the ray clockwise! then the face //is to its _right_ (maybe the specs will change in //the future) } if ( !(h->face()->is_unbounded()) ) lt=Planar_map::FACE; return h; } else //==the vertical ray shoot returned the halfedges_end() iterator. { if (pm->unbounded_face()->holes_begin() == pm->unbounded_face()->holes_end() ) //an empty map return h; //return halfedges_end() else { //- returns a halfedge on an inner ccb of the unbounded face typename Planar_map::Holes_iterator hot = pm->unbounded_face()->holes_begin(); return (*hot); } } } Halfedge_handle locate(const Point& p, Locate_type& lt) { ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); if (!((Bounding_box*)get_bounding_box())->locate(p,lt,h)) h=Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); return h; } Halfedge_const_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) const { Halfedges_const_list relevant_halfedges; find_relevant_halfedges(p, relevant_halfedges); return vertical_ray_shoot(p, lt, up, relevant_halfedges); } Halfedge_const_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up, const Halfedges_const_list &relevant_halfedges) const { typename Planar_map::Halfedge_const_iterator it, eit, closest_edge; bool first = false; Comparison_result point_above_under, res; Comparison_result curve_above_under; bool in_x_range; it = pm->halfedges_begin(); eit = pm->halfedges_end(); closest_edge = eit; lt = Planar_map::EDGE; // set the flags for comparison acording to the ray // direction (up/down) if (up) { point_above_under = SMALLER; curve_above_under = LARGER; } else { point_above_under = LARGER; curve_above_under = SMALLER; } typename Halfedges_const_list::const_iterator rel_it; for (rel_it = relevant_halfedges.begin(); rel_it != relevant_halfedges.end();) { it = *rel_it; in_x_range = traits->point_in_x_range(it->curve(), p); if (in_x_range) res = traits->curve_compare_y_at_x(p, it->curve()); if (in_x_range && (res == point_above_under)) { if (!first) { closest_edge = it; first = true; } else { if (traits->curves_compare_y_at_x(closest_edge->curve(), it->curve(), p) == curve_above_under) { closest_edge = it; } } } if (in_x_range && res == EQUAL && traits->curve_is_vertical(it->curve())) { // The vertical ray shoot is not including p itself, // thus we are interested only in vertical curves that // extend upwards // In this case the Locate type is always EDGE // Remark: This treatment was originally written in the walk PL. if (up && traits->point_is_right_top(traits->curve_righttop_most (it->curve()), p) || ! up && traits->point_is_left_low(traits->curve_leftlow_most (it->curve()), p)) /* x x | | p=x or p | x */ { lt = Planar_map::EDGE; if (up==traits->point_is_left_low(it->target()->point(), it->source()->point())) return it; else return it->twin(); } } ++rel_it; ++rel_it; } // if we didn't find any edge above p then it is the empty face if (!first) { lt=Planar_map::UNBOUNDED_FACE; Halfedge_const_handle h=pm->halfedges_end(); return h; //==NULL } // if the closest point is a vertex then find the first clockwise // edge from the vertical segment typename Planar_map::Vertex_const_handle v = pm->vertices_end(); bool maybe_vertical=false; // BUG fix (Oren) if ( traits->point_equal_x(closest_edge->target()->point(), p) ) { v = closest_edge->target(); maybe_vertical=true; // BUG fix (Oren) } if ( traits->point_equal_x( closest_edge->source()->point(), p) ) { if (!maybe_vertical || traits->point_is_right_top(closest_edge->target()->point(), closest_edge->source()->point())==up) // BUG fix (Oren) v = closest_edge->source(); /* special care for the vertical cases: x p | x and x | p x */ } //if (closest_is_vertex) if (v != pm->vertices_end()) { lt=Planar_map::VERTEX; if (up) closest_edge = find_lowest(v,traits, false); else closest_edge = find_lowest(v,traits, true); } Halfedge_const_handle h; if (lt==Planar_map::VERTEX) { h=closest_edge; } else if (up) { // return the edge that is going from right to left // such that p is to the left of this edge if ( traits->point_is_right( closest_edge->source()->point(), closest_edge->target()->point()) ) { h=closest_edge; //source is right of the target } else h=closest_edge->twin(); } else { if ( traits->point_is_left( closest_edge->source()->point(), closest_edge->target()->point()) ) h=closest_edge; else h=closest_edge->twin(); } return h; } Halfedge_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) { /* Make sure the source point is in the bounding box on the output */ ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); /* Apply the bounding box on the output */ if (!((Bounding_box*)get_bounding_box())->vertical_ray_shoot(p,lt,up,h)) { h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); CGAL_assertion(lt!=Planar_map::UNBOUNDED_FACE); } return h; } void split_edge(const X_curve &, Halfedge_handle, Halfedge_handle, const X_curve &, const X_curve &) { } void merge_edge(const X_curve &, const X_curve &, Halfedge_handle, const X_curve &) { } void remove_edge(Halfedge_handle) { } void remove_edge(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &) { } void clear() { } void update(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &, const Token & token) { token.rebuild_bounding_box(this); } public: inline const Bounding_box* get_bounding_box() const {return pm->get_bounding_box();} inline const Traits* get_traits() const {return traits;} protected: Halfedge_const_handle find_lowest(const Vertex_const_handle v, const Traits_wrap *traits, bool highest) const //find the first halfedge pointing at v, when going clockwise //if highest==true - start from 12 oclock, else start from 6 oclock { Halfedge_const_handle lowest_left = pm->halfedges_end(); Halfedge_const_handle lowest_right = pm->halfedges_end(); Halfedge_const_handle vertical_up = pm->halfedges_end(); Halfedge_const_handle vertical_down = pm->halfedges_end(); Halfedge_around_vertex_const_circulator first = v->incident_halfedges(); Halfedge_around_vertex_const_circulator curr = first; do { if ( traits->point_is_left(curr->source()->point(), v->point())) { if (lowest_left == pm->halfedges_end()) lowest_left = curr; if (traits->curves_compare_y_at_x_left(curr->curve(), lowest_left->curve(), v->point())==SMALLER) lowest_left = curr; } if ( traits->point_is_right(curr->source()->point(), v->point()) ) { if (lowest_right == pm->halfedges_end()) lowest_right = curr; if (traits->curves_compare_y_at_x_right(curr->curve(), lowest_right->curve(), v->point())==LARGER ) lowest_right = curr; } if (traits->curve_is_vertical(curr->curve())) { if (traits->compare_xy(v->point(), curr->source()->point()) == LARGER) //debug //{ std::cout << "vertical up = " << curr->curve() << std::endl; vertical_up=curr; //}//enddebug if (traits->compare_xy(v->point(), curr->source()->point())==SMALLER) //debug //{ std::cout << "vertical down = " << curr->curve() << std::endl; vertical_down=curr; //}//enddebug } } while (++curr != first); /* vertical_down | v <- lowest_right 'v' lowest_left-> ^ | vertical_up */ if (!highest) { if (lowest_left!= pm->halfedges_end()) return lowest_left; else if (vertical_down!= pm->halfedges_end()) return vertical_down; else return lowest_right; } else { //down if (lowest_right!=pm->halfedges_end()) return lowest_right; else if (vertical_up!=pm->halfedges_end()) return vertical_up; else return lowest_left; } } #ifdef CGAL_PM_DEBUG void debug(){} #endif protected: typedef const Self * const_Self_ptr; protected: Planar_map * pm; const Traits_wrap * traits; }; CGAL_END_NAMESPACE #endif //CGAL_PM_NAIVE_POINT_LOCATION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/algorithm.h0000644000175000017500000001035411344301500027162 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/algorithm.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_ALGORITHM_H #define CGAL_ALGORITHM_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template inline ForwardIterator successor( ForwardIterator it ) { return ++it; } template inline BidirectionalIterator predecessor( BidirectionalIterator it ) { return --it; } template < class ForwardIterator > std::pair< ForwardIterator, ForwardIterator > min_max_element(ForwardIterator first, ForwardIterator last) { typedef std::pair< ForwardIterator, ForwardIterator > FP; FP result(first, first); if (first != last) while (++first != last) { if (*first < *result.first) result.first = first; if (*result.second < *first) result.second = first; } return result; } template < class ForwardIterator, class CompareMin, class CompareMax > std::pair< ForwardIterator, ForwardIterator > min_max_element(ForwardIterator first, ForwardIterator last, CompareMin comp_min, CompareMax comp_max) { typedef std::pair< ForwardIterator, ForwardIterator > FP; FP result(first, first); if (first != last) while (++first != last) { if (comp_min(*first, *result.first)) result.first = first; if (comp_max(*result.second, *first)) result.second = first; } return result; } template < class ForwardIterator, class Predicate > ForwardIterator min_element_if(ForwardIterator first, ForwardIterator last, Predicate pred) { ForwardIterator result = first = std::find_if(first, last, pred); if (first != last) while (++first != last) if (*first < *result && pred(*first)) result = first; return result; } template < class ForwardIterator, class Compare, class Predicate > ForwardIterator min_element_if(ForwardIterator first, ForwardIterator last, Compare comp, Predicate pred) { ForwardIterator result = first = std::find_if(first, last, pred); if (first != last) while (++first != last) if (comp(*first, *result) && pred(*first)) result = first; return result; } template < class ForwardIterator, class Predicate > ForwardIterator max_element_if(ForwardIterator first, ForwardIterator last, Predicate pred) { ForwardIterator result = first = std::find_if(first, last, pred); if (first != last) while (++first != last) if (*result < *first && pred(*first)) result = first; return result; } template < class ForwardIterator, class Compare, class Predicate > ForwardIterator max_element_if(ForwardIterator first, ForwardIterator last, Compare comp, Predicate pred) { ForwardIterator result = first = std::find_if(first, last, pred); if (first != last) while (++first != last) if (comp(*result, *first) && pred(*first)) result = first; return result; } CGAL_END_NAMESPACE #endif // CGAL_ALGORITHM_H // // EOF // ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_euclidean_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000004745011344301500031455 0ustar debiandebian// Copyright (c) 1999,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_euclidean_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion // Monique Teillaud // Mariette Yvinec #ifndef CGAL_REGULAR_TRIANGULATION_EUCLIDEAN_TRAITS_3_H #define CGAL_REGULAR_TRIANGULATION_EUCLIDEAN_TRAITS_3_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // return the sign of the determinant of the lifted points // associated with p,q,r,s,t [P,Q,R,S,T] // where the P colum is [ p, p^2-wp,1] template < typename K > class Power_test_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef Arity_tag< 5 > Arity; typedef Oriented_side result_type; Oriented_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s, const Weighted_point_3 & t) const { return power_test(p,q,r,s,t); } Oriented_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s) const { return power_test(p,q,r,s); } Oriented_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { return power_test(p,q,r); } Oriented_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q) const { return power_test(p,q); } }; template < typename K > class Compare_power_distance_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Bare_point Point_3; typedef Arity_tag< 3 > Arity; typedef Comparison_result result_type; Comparison_result operator() ( const Point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { return compare_power_distance_3(p,q,r); } }; // operator () // return the sign of the power test of last weighted point // with respect to the smallest sphere orthogonal to the others template< typename K > class In_smallest_orthogonal_sphere_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef Arity_tag< 5 > Arity; typedef Sign result_type; Sign operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s, const Weighted_point_3 & t) const { K traits; typename K::Orientation_3 orientation = traits.orientation_3_object(); Orientation o = orientation(p,q,r,s); Oriented_side os = power_test(p,q,r,s,t); CGAL_triangulation_assertion( o != COPLANAR); return Sign( (-1) * o * os); } Sign operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s) const { return in_smallest_orthogonal_sphereC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight(), s.x(), s.y(), s.z(), s.weight()); } Sign operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { return in_smallest_orthogonal_sphereC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight()); } }; template < typename K > class Side_of_bounded_orthogonal_sphere_3 { public : typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::In_smallest_orthogonal_sphere_3 In_sphere; typedef Arity_tag< 5 > Arity; typedef Bounded_side result_type; Bounded_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s, const Weighted_point_3 & t) const { return Bounded_side( (-1) * In_sphere()(p,q,r,s,t)); } Bounded_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s) const { return Bounded_side ( (-1) * In_sphere()(p,q,r,s) ); } Bounded_side operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { return Bounded_side ( (-1) * In_sphere()(p,q,r) ); } }; // operator() returns true if the affine hull of the dual // to the given weighted points // intersect the simplex formed by the bare points template < typename K > class Does_simplex_intersect_dual_support_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef Arity_tag< 4 > Arity; typedef Bounded_side result_type; Bounded_side operator()(const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s) const { return does_simplex_intersect_dual_supportC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight(), s.x(), s.y(), s.z(), s.weight()); } Bounded_side operator()(const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { return does_simplex_intersect_dual_supportC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight()); } Bounded_side operator()(const Weighted_point_3 & p, const Weighted_point_3 & q) const { return does_simplex_intersect_dual_supportC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight()); } }; template < typename K > class Construct_weighted_circumcenter_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::Bare_point Bare_point; typedef typename K::FT FT; typedef Arity_tag< 4 > Arity; typedef Bare_point result_type; Bare_point operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s) const { FT x, y, z; weighted_circumcenterC3(p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight(), s.x(), s.y(), s.z(), s.weight(), x,y,z); return Bare_point(x,y,z); } Bare_point operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { FT x, y, z; weighted_circumcenterC3(p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight(), x,y,z); return Bare_point(x,y,z); } Bare_point operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q) const { FT x, y, z; weighted_circumcenterC3(p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), x,y,z); return Bare_point(x,y,z); } }; template < typename K > class Compute_power_product_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::FT FT; typedef Arity_tag< 2 > Arity; typedef FT result_type; FT operator() (const Weighted_point_3 & p, const Weighted_point_3 & q) const { return power_productC3(p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight()); } }; template < typename K > class Compute_squared_radius_smallest_orthogonal_sphere_3 { public: typedef typename K::Weighted_point_3 Weighted_point_3; typedef typename K::FT FT; typedef Arity_tag< 4 > Arity; typedef FT result_type; FT operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r, const Weighted_point_3 & s) const { return squared_radius_orthogonal_sphereC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight(), s.x(), s.y(), s.z(), s.weight()); } FT operator() ( const Weighted_point_3 & p, const Weighted_point_3 & q, const Weighted_point_3 & r) const { return squared_radius_smallest_orthogonal_sphereC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight(), r.x(), r.y(), r.z(), r.weight()); } FT operator() (const Weighted_point_3 & p, const Weighted_point_3 & q) const { return squared_radius_smallest_orthogonal_sphereC3( p.x(), p.y(), p.z(), p.weight(), q.x(), q.y(), q.z(), q.weight()); } }; template < class K, class Weight = typename K::RT > class Regular_triangulation_euclidean_traits_base_3 : public K { public: typedef typename K::FT FT; typedef typename K::Point_3 Bare_point; typedef CGAL::Weighted_point Weighted_point; typedef Weighted_point Weighted_point_3; typedef Weighted_point Point_3; //typedef typename K::Point_3 Point_3; typedef Regular_triangulation_euclidean_traits_base_3 Self; // The next typedef is there for backward compatibility // Some users take their point type from the traits class. // Before this type was Point typedef Point_3 Point; typedef CGAL::Power_test_3 Power_test_3; typedef CGAL::Compare_power_distance_3 Compare_power_distance_3; typedef CGAL::In_smallest_orthogonal_sphere_3 In_smallest_orthogonal_sphere_3; typedef CGAL::Side_of_bounded_orthogonal_sphere_3 Side_of_bounded_orthogonal_sphere_3; typedef CGAL::Does_simplex_intersect_dual_support_3 Does_simplex_intersect_dual_support_3; typedef CGAL::Construct_weighted_circumcenter_3 Construct_weighted_circumcenter_3; typedef CGAL::Compute_squared_radius_smallest_orthogonal_sphere_3 Compute_squared_radius_smallest_orthogonal_sphere_3; typedef CGAL::Compute_power_product_3 Compute_power_product_3; Power_test_3 power_test_3_object() const { return Power_test_3(); } Compare_power_distance_3 compare_power_distance_3_object() const { return Compare_power_distance_3(); } In_smallest_orthogonal_sphere_3 in_smallest_orthogonal_sphere_3_object() const { return In_smallest_orthogonal_sphere_3(); } Side_of_bounded_orthogonal_sphere_3 side_of_bounded_orthogonal_sphere_3_object() const { return Side_of_bounded_orthogonal_sphere_3(); } Does_simplex_intersect_dual_support_3 does_simplex_intersect_dual_support_3_object() const { return Does_simplex_intersect_dual_support_3(); } Construct_weighted_circumcenter_3 construct_weighted_circumcenter_3_object() const { return Construct_weighted_circumcenter_3(); } Compute_power_product_3 compute_power_product_3_object() const { return Compute_power_product_3(); } Compute_squared_radius_smallest_orthogonal_sphere_3 compute_squared_radius_smallest_orthogonal_sphere_3_object() const { return Compute_squared_radius_smallest_orthogonal_sphere_3(); } }; // We need to introduce a "traits_base_3" class in order to get the // specialization for Exact_predicates_inexact_constructions_kernel to work, // otherwise there is a cycle in the derivation. template < class K, class Weight = typename K::RT > class Regular_triangulation_euclidean_traits_3 : public Regular_triangulation_euclidean_traits_base_3 {}; // Cartesian versions. template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s, const Weighted_point &t, Cartesian_tag) { typedef typename pt::R::FT FT; return power_testC3(p.x(), p.y(), p.z(), FT(p.weight()), q.x(), q.y(), q.z(), FT(q.weight()), r.x(), r.y(), r.z(), FT(r.weight()), s.x(), s.y(), s.z(), FT(s.weight()), t.x(), t.y(), t.z(), FT(t.weight())); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &t, Cartesian_tag) { typedef typename pt::R::FT FT; return power_testC3(p.x(), p.y(), p.z(), FT(p.weight()), q.x(), q.y(), q.z(), FT(q.weight()), r.x(), r.y(), r.z(), FT(r.weight()), t.x(), t.y(), t.z(), FT(t.weight())); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &t, Cartesian_tag) { typedef typename pt::R::FT FT; return power_testC3(p.x(), p.y(), p.z(), FT(p.weight()), q.x(), q.y(), q.z(), FT(q.weight()), t.x(), t.y(), t.z(), FT(t.weight())); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, Cartesian_tag) { typedef typename pt::R::FT FT; return power_testC3(FT(p.weight()), FT(q.weight())); } template < class pt, class Weight > inline Comparison_result compare_power_distance_3 (const pt &p, const Weighted_point &q, const Weighted_point &r, Cartesian_tag) { typedef typename pt::R::FT FT; return compare_power_distanceC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), FT(q.weight()), r.x(), r.y(), r.z(), FT(r.weight())); } // Homogeneous versions. template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s, const Weighted_point &t, Homogeneous_tag) { typedef typename pt::R::RT RT; return power_testH3(p.hx(), p.hy(), p.hz(), p.hw(), RT(p.weight()), q.hx(), q.hy(), q.hz(), q.hw(), RT(q.weight()), r.hx(), r.hy(), r.hz(), r.hw(), RT(r.weight()), s.hx(), s.hy(), s.hz(), s.hw(), RT(s.weight()), t.hx(), t.hy(), t.hz(), t.hw(), RT(t.weight())); } // The followings call the cartesian version over FT, because an homogeneous // special version would be boring to write. template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &t, Homogeneous_tag) { typedef typename pt::R::FT FT; return power_testC3(p.x(), p.y(), p.z(), FT(p.weight()), q.x(), q.y(), q.z(), FT(q.weight()), r.x(), r.y(), r.z(), FT(r.weight()), t.x(), t.y(), t.z(), FT(t.weight())); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &t, Homogeneous_tag) { typedef typename pt::R::FT FT; return power_testC3(p.x(), p.y(), p.z(), FT(p.weight()), q.x(), q.y(), q.z(), FT(q.weight()), t.x(), t.y(), t.z(), FT(t.weight())); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, Homogeneous_tag) { typedef typename pt::R::FT FT; return power_testC3(FT(p.weight()), FT(q.weight())); } template < class Point, class Weight > inline Comparison_result compare_power_distance_3 (const Point &p, const Weighted_point &q, const Weighted_point &t, Homogeneous_tag) { typedef typename Point::R::FT FT; return compare_power_distanceC3(p.x(), p.y(), p.z(), FT(p.weight()), q.x(), q.y(), q.z(), FT(q.weight()), t.x(), t.y(), t.z(), FT(t.weight())); } // Kludges for M$. template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s, const Weighted_point &t) { typedef typename pt::R::Rep_tag Tag; return power_test(p,q,r,s,t, Tag()); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &t) { typedef typename pt::R::Rep_tag Tag; return power_test(p,q,r,t, Tag()); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &t) { typedef typename pt::R::Rep_tag Tag; return power_test(p,q,t, Tag()); } template < class pt, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q) { typedef typename pt::R::Rep_tag Tag; return power_test(p,q, Tag()); } template < class Point, class Weight > inline Comparison_result compare_power_distance_3 (const Point &p, const Weighted_point &q, const Weighted_point &r) { typedef typename Point::R::Rep_tag Tag; return compare_power_distance_3(p,q,r, Tag()); } CGAL_END_NAMESPACE // Partial specialization for Exact_predicates_inexact_constructions_kernel. #include #include CGAL_BEGIN_NAMESPACE template < typename T > class Regular_triangulation_euclidean_traits_3 : public Regular_triangulation_filtered_traits_3 {}; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_EUCLIDEAN_TRAITS_3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000011304511344301500031447 0ustar debiandebian// Copyright (c) 1999-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Monique Teillaud // Sylvain Pion // Christophe Delage #ifndef CGAL_REGULAR_TRIANGULATION_3_H #define CGAL_REGULAR_TRIANGULATION_3_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Gt, class Tds = Triangulation_data_structure_3 < Triangulation_vertex_base_3, Regular_triangulation_cell_base_3 > > class Regular_triangulation_3 : public Triangulation_3 { typedef Regular_triangulation_3 Self; typedef Triangulation_3 Tr_Base; public: typedef Tds Triangulation_data_structure; typedef Gt Geom_traits; typedef typename Tr_Base::Vertex_handle Vertex_handle; typedef typename Tr_Base::Cell_handle Cell_handle; typedef typename Tr_Base::Vertex Vertex; typedef typename Tr_Base::Cell Cell; typedef typename Tr_Base::Facet Facet; typedef typename Tr_Base::Edge Edge; typedef Triple Vertex_triple; typedef typename Tr_Base::Locate_type Locate_type; typedef typename Tr_Base::Cell_iterator Cell_iterator; typedef typename Tr_Base::Facet_iterator Facet_iterator; typedef typename Tr_Base::Edge_iterator Edge_iterator; typedef typename Tr_Base::Facet_circulator Facet_circulator; typedef typename Tr_Base::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Tr_Base::Finite_cells_iterator Finite_cells_iterator; typedef typename Tr_Base::Finite_facets_iterator Finite_facets_iterator; typedef typename Tr_Base::Finite_edges_iterator Finite_edges_iterator; typedef typename Tr_Base::All_cells_iterator All_cells_iterator; typedef typename Gt::Weighted_point_3 Weighted_point; typedef typename Gt::Bare_point Bare_point; typedef typename Gt::Segment_3 Segment; typedef typename Gt::Triangle_3 Triangle; typedef typename Gt::Tetrahedron_3 Tetrahedron; typedef typename Gt::Object_3 Object; //Tag to distinguish Delaunay from Regular triangulations typedef Tag_true Weighted_tag; using Tr_Base::cw; using Tr_Base::ccw; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Tr_Base::geom_traits; #endif using Tr_Base::number_of_vertices; using Tr_Base::dimension; using Tr_Base::finite_facets_begin; using Tr_Base::finite_facets_end; using Tr_Base::finite_vertices_begin; using Tr_Base::finite_vertices_end; using Tr_Base::finite_cells_begin; using Tr_Base::finite_cells_end; using Tr_Base::finite_edges_begin; using Tr_Base::finite_edges_end; using Tr_Base::tds; using Tr_Base::infinite_vertex; using Tr_Base::next_around_edge; using Tr_Base::vertex_triple_index; Regular_triangulation_3(const Gt & gt = Gt()) : Tr_Base(gt) {} // copy constructor duplicates vertices and cells Regular_triangulation_3(const Regular_triangulation_3 & rt) : Tr_Base(rt) { CGAL_triangulation_postcondition( is_valid() ); } //insertion template < typename InputIterator > Regular_triangulation_3(InputIterator first, InputIterator last, const Gt & gt = Gt()) : Tr_Base(gt) { insert(first, last); } template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } Vertex_handle insert(const Weighted_point & p, Cell_handle start = Cell_handle()); Vertex_handle insert(const Weighted_point & p, Locate_type lt, Cell_handle c, int li, int); void remove (Vertex_handle v); template < typename InputIterator > int remove(InputIterator first, InputIterator beyond) { int n = number_of_vertices(); while (first != beyond) { remove (*first); ++first; } return n - number_of_vertices(); } Vertex_handle move_point(Vertex_handle v, const Weighted_point & p); private: void remove_2D(Vertex_handle v); // void make_hole_2D(Vertex_handle v, std::list & hole); // void fill_hole_delaunay_2D(std::list & hole); void make_canonical(Vertex_triple& t) const; Vertex_triple make_vertex_triple(const Facet& f) const; #ifndef CGAL_CFG_NET2003_MATCHING_BUG void make_hole_3D(Vertex_handle v, std::map &outer_map, std::vector &hole); #else void make_hole_3D(Vertex_handle v, std::map &outer_map, std::vector &hole) { CGAL_triangulation_expensive_precondition( ! test_dim_down(v) ); incident_cells(v, std::back_inserter(hole)); for (typename std::vector::iterator cit = hole.begin(); cit != hole.end(); ++cit) { int indv = (*cit)->index(v); Cell_handle opp_cit = (*cit)->neighbor( indv ); Facet f(opp_cit, opp_cit->index(*cit)); Vertex_triple vt = make_vertex_triple(f); make_canonical(vt); outer_map[vt] = f; for (int i=0; i<4; i++) if ( i != indv ) (*cit)->vertex(i)->set_cell(opp_cit); } } #endif void remove_3D(Vertex_handle v); public: // Queries Bounded_side side_of_power_sphere( Cell_handle c, const Weighted_point &p) const; Bounded_side side_of_power_circle( const Facet & f, const Weighted_point & p) const { return side_of_power_circle(f.first, f.second, p); } Bounded_side side_of_power_circle( Cell_handle c, int i, const Weighted_point &p) const; Bounded_side side_of_power_segment( Cell_handle c, const Weighted_point &p) const; Vertex_handle nearest_power_vertex_in_cell(const Bare_point& p, const Cell_handle& c) const; Vertex_handle nearest_power_vertex(const Bare_point& p, Cell_handle c = Cell_handle()) const; bool is_Gabriel(Cell_handle c, int i) const; bool is_Gabriel(Cell_handle c, int i, int j) const; bool is_Gabriel(const Facet& f)const ; bool is_Gabriel(const Edge& e) const; bool is_Gabriel(Vertex_handle v) const; // Dual functions Bare_point dual(Cell_handle c) const; // Object dual(const Facet & f) const // { return dual( f.first, f.second ); } // Object dual(Cell_handle c, int i) const; template < class Stream> Stream& draw_dual(Stream & os) { typedef typename Gt::Line_3 Line; typedef typename Gt::Ray_3 Ray; Finite_facets_iterator fit = finite_facets_begin(); for (; fit != finite_facets_end(); ++fit) { Object o = dual(*fit); Bare_point p; Ray r; Segment s; if (CGAL::assign(p,o)) os << p; if (CGAL::assign(s,o)) os << s; if (CGAL::assign(r,o)) os << r; } return os; } bool is_valid(bool verbose = false, int level = 0) const; private: bool less_power_distance(const Bare_point &p, const Weighted_point &q, const Weighted_point &r) const { return geom_traits().compare_power_distance_3_object()(p, q, r) == SMALLER; } Bare_point construct_weighted_circumcenter(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s) const { return geom_traits().construct_weighted_circumcenter_3_object()(p,q,r,s); } Vertex_handle nearest_power_vertex(const Bare_point &p, Vertex_handle v, Vertex_handle w) const { // In case of equality, v is returned. CGAL_triangulation_precondition(v != w); if (is_infinite(v)) return w; if (is_infinite(w)) return v; return less_power_distance(p, w->point(), v->point()) ? w : v; } Oriented_side power_test(const Weighted_point &p, const Weighted_point &q) const { CGAL_precondition(equal(p, q)); return geom_traits().power_test_3_object()(p, q); } Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r) const { CGAL_precondition(collinear(p, q, r)); return geom_traits().power_test_3_object()(p, q, r); } Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s) const { CGAL_precondition(coplanar(p, q, r, s)); return geom_traits().power_test_3_object()(p, q, r, s); } Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s, const Weighted_point &t) const { return geom_traits().power_test_3_object()(p, q, r, s, t); } bool in_conflict_3(const Weighted_point &p, const Cell_handle c) const { return side_of_power_sphere(c, p) == ON_BOUNDED_SIDE; } bool in_conflict_2(const Weighted_point &p, const Cell_handle c, int i) const { return side_of_power_circle(c, i, p) == ON_BOUNDED_SIDE; } bool in_conflict_1(const Weighted_point &p, const Cell_handle c) const { return side_of_power_segment(c, p) == ON_BOUNDED_SIDE; } bool in_conflict_0(const Weighted_point &p, const Cell_handle c) const { return power_test(c->vertex(0)->point(), p) == ON_POSITIVE_SIDE; } class Conflict_tester_3 { const Weighted_point &p; const Self *t; mutable std::vector cv; public: Conflict_tester_3(const Weighted_point &pt, const Self *tr) : p(pt), t(tr) {} bool operator()(const Cell_handle c) const { // We mark the vertices so that we can find the deleted ones easily. if (t->in_conflict_3(p, c)) { for (int i=0; i<4; i++) { Vertex_handle v = c->vertex(i); if (v->cell() != Cell_handle()) { cv.push_back(v); v->set_cell(Cell_handle()); } } return true; } return false; } std::vector & conflict_vector() { return cv; } }; class Conflict_tester_2 { const Weighted_point &p; const Self *t; mutable std::vector cv; public: Conflict_tester_2(const Weighted_point &pt, const Self *tr) : p(pt), t(tr) {} bool operator()(const Cell_handle c) const { if (t->in_conflict_2(p, c, 3)) { for (int i=0; i<3; i++) { Vertex_handle v = c->vertex(i); if (v->cell() != Cell_handle()) { cv.push_back(v); v->set_cell(Cell_handle()); } } return true; } return false; } std::vector & conflict_vector() { return cv; } }; friend class Conflict_tester_3; friend class Conflict_tester_2; }; template < class Gt, class Tds > typename Regular_triangulation_3::Vertex_handle Regular_triangulation_3:: nearest_power_vertex_in_cell(const Bare_point& p, const Cell_handle& c) const // Returns the finite vertex of the cell c with smaller // power distance to p. { CGAL_triangulation_precondition(dimension() >= 1); Vertex_handle nearest = nearest_power_vertex(p, c->vertex(0), c->vertex(1)); if (dimension() >= 2) { nearest = nearest_power_vertex(p, nearest, c->vertex(2)); if (dimension() == 3) nearest = nearest_power_vertex(p, nearest, c->vertex(3)); } return nearest; } template < class Gt, class Tds > typename Regular_triangulation_3::Vertex_handle Regular_triangulation_3:: nearest_power_vertex(const Bare_point& p, Cell_handle start) const { if (number_of_vertices() == 0) return Vertex_handle(); // Use a brute-force algorithm if dimension < 3. if (dimension() < 3) { Finite_vertices_iterator vit = finite_vertices_begin(); Vertex_handle res = vit; for (++vit; vit != finite_vertices_end(); ++vit) res = nearest_power_vertex(p, res, vit); return res; } Locate_type lt; int li, lj; // I put the cast here temporarily // until we solve the traits class pb of regular triangulation Cell_handle c = locate(static_cast(p), lt, li, lj, start); // - start with the closest vertex from the located cell. // - repeatedly take the nearest of its incident vertices if any // - if not, we're done. Vertex_handle nearest = nearest_power_vertex_in_cell(p, c); std::vector vs; vs.reserve(32); while (true) { Vertex_handle tmp = nearest; incident_vertices(nearest, std::back_inserter(vs)); for (typename std::vector::const_iterator vsit = vs.begin(); vsit != vs.end(); ++vsit) tmp = nearest_power_vertex(p, tmp, *vsit); if (tmp == nearest) break; vs.clear(); nearest = tmp; } return nearest; } template < class Gt, class Tds > typename Regular_triangulation_3::Bare_point Regular_triangulation_3:: dual(Cell_handle c) const { CGAL_triangulation_precondition(dimension()==3); CGAL_triangulation_precondition( ! is_infinite(c) ); return construct_weighted_circumcenter( c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point() ); } template < class Gt, class Tds > Bounded_side Regular_triangulation_3:: side_of_power_sphere( Cell_handle c, const Weighted_point &p) const { CGAL_triangulation_precondition( dimension() == 3 ); int i3; if ( ! c->has_vertex( infinite_vertex(), i3 ) ) { return Bounded_side( power_test (c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point(), p) ); } // else infinite cell : int i0,i1,i2; if ( (i3%2) == 1 ) { i0 = (i3+1)&3; i1 = (i3+2)&3; i2 = (i3+3)&3; } else { i0 = (i3+2)&3; i1 = (i3+1)&3; i2 = (i3+3)&3; } // general case Orientation o = orientation(c->vertex(i0)->point(), c->vertex(i1)->point(), c->vertex(i2)->point(), p); if (o != ZERO) return Bounded_side(o); // else p coplanar with i0,i1,i2 return Bounded_side( power_test( c->vertex(i0)->point(), c->vertex(i1)->point(), c->vertex(i2)->point(), p ) ); } template < class Gt, class Tds > Bounded_side Regular_triangulation_3:: side_of_power_circle( Cell_handle c, int i, const Weighted_point &p) const { CGAL_triangulation_precondition( dimension() >= 2 ); int i3 = 5; if ( dimension() == 2 ) { CGAL_triangulation_precondition( i == 3 ); // the triangulation is supposed to be valid, ie the facet // with vertices 0 1 2 in this order is positively oriented if ( ! c->has_vertex( infinite_vertex(), i3 ) ) return Bounded_side( power_test(c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), p) ); // else infinite facet // v1, v2 finite vertices of the facet such that v1,v2,infinite // is positively oriented Vertex_handle v1 = c->vertex( ccw(i3) ), v2 = c->vertex( cw(i3) ); CGAL_triangulation_assertion(coplanar_orientation(v1->point(), v2->point(), (c->mirror_vertex(i3))->point()) == NEGATIVE); Orientation o = coplanar_orientation(v1->point(), v2->point(), p); if ( o != ZERO ) return Bounded_side( o ); // case when p collinear with v1v2 return Bounded_side( power_test( v1->point(), v2->point(), p ) ); }// dim 2 // else dimension == 3 CGAL_triangulation_precondition( (i >= 0) && (i < 4) ); if ( ( ! c->has_vertex(infinite_vertex(),i3) ) || ( i3 != i ) ) { // finite facet // initialization of i0 i1 i2, vertices of the facet positively // oriented (if the triangulation is valid) int i0 = (i>0) ? 0 : 1; int i1 = (i>1) ? 1 : 2; int i2 = (i>2) ? 2 : 3; CGAL_triangulation_precondition( coplanar ( c->vertex(i0)->point(), c->vertex(i1)->point(), c->vertex(i2)->point(), p) ); return Bounded_side( power_test(c->vertex(i0)->point(), c->vertex(i1)->point(), c->vertex(i2)->point(), p) ); } //else infinite facet // v1, v2 finite vertices of the facet such that v1,v2,infinite // is positively oriented Vertex_handle v1 = c->vertex( next_around_edge(i3,i) ), v2 = c->vertex( next_around_edge(i,i3) ); Orientation o = (Orientation) (coplanar_orientation( v1->point(), v2->point(), c->vertex(i)->point()) * coplanar_orientation( v1->point(), v2->point(), p)); // then the code is duplicated from 2d case if ( o != ZERO ) return Bounded_side( -o ); // because p is in f iff // it is not on the same side of v1v2 as c->vertex(i) // case when p collinear with v1v2 : return Bounded_side( power_test( v1->point(), v2->point(), p ) ); } template < class Gt, class Tds > Bounded_side Regular_triangulation_3:: side_of_power_segment( Cell_handle c, const Weighted_point &p) const { CGAL_triangulation_precondition( dimension() == 1 ); if ( ! is_infinite(c,0,1) ) return Bounded_side( power_test( c->vertex(0)->point(), c->vertex(1)->point(), p ) ); Locate_type lt; int i; Bounded_side soe = side_of_edge( p, c, lt, i ); if (soe != ON_BOUNDARY) return soe; // Either we compare weights, or we use the finite neighboring edge Cell_handle finite_neighbor = c->neighbor(c->index(infinite_vertex())); CGAL_assertion(!is_infinite(finite_neighbor,0,1)); return Bounded_side( power_test( finite_neighbor->vertex(0)->point(), finite_neighbor->vertex(1)->point(), p ) ); } template < class Gt, class Tds > bool Regular_triangulation_3:: is_Gabriel(const Facet& f) const { return is_Gabriel(f.first, f.second); } template < class Gt, class Tds > bool Regular_triangulation_3:: is_Gabriel(Cell_handle c, int i) const { CGAL_triangulation_precondition(dimension() == 3 && !is_infinite(c,i)); typename Geom_traits::Side_of_bounded_orthogonal_sphere_3 side_of_bounded_orthogonal_sphere = geom_traits().side_of_bounded_orthogonal_sphere_3_object(); if ((!is_infinite(c->vertex(i))) && side_of_bounded_orthogonal_sphere( c->vertex(vertex_triple_index(i,0))->point(), c->vertex(vertex_triple_index(i,1))->point(), c->vertex(vertex_triple_index(i,2))->point(), c->vertex(i)->point()) == ON_BOUNDED_SIDE ) return false; Cell_handle neighbor = c->neighbor(i); int in = neighbor->index(c); if ((!is_infinite(neighbor->vertex(in))) && side_of_bounded_orthogonal_sphere( c->vertex(vertex_triple_index(i,0))->point(), c->vertex(vertex_triple_index(i,1))->point(), c->vertex(vertex_triple_index(i,2))->point(), neighbor->vertex(in)->point()) == ON_BOUNDED_SIDE ) return false; return true; } template < class Gt, class Tds > bool Regular_triangulation_3:: is_Gabriel(const Edge& e) const { return is_Gabriel(e.first, e.second, e.third); } template < class Gt, class Tds > bool Regular_triangulation_3:: is_Gabriel(Cell_handle c, int i, int j) const { CGAL_triangulation_precondition(dimension() == 3 && !is_infinite(c,i,j)); typename Geom_traits::Side_of_bounded_orthogonal_sphere_3 side_of_bounded_orthogonal_sphere = geom_traits().side_of_bounded_orthogonal_sphere_3_object(); Facet_circulator fcirc = incident_facets(c,i,j), fdone(fcirc); Vertex_handle v1 = c->vertex(i); Vertex_handle v2 = c->vertex(j); do { // test whether the vertex of cc opposite to *fcirc // is inside the sphere defined by the edge e = (s, i,j) Cell_handle cc = (*fcirc).first; int ii = (*fcirc).second; if (!is_infinite(cc->vertex(ii)) && side_of_bounded_orthogonal_sphere( v1->point(), v2->point(), cc->vertex(ii)->point()) == ON_BOUNDED_SIDE ) return false; } while(++fcirc != fdone); return true; } template < class Gt, class Tds > bool Regular_triangulation_3:: is_Gabriel(Vertex_handle v) const { return nearest_power_vertex( v->point().point(), v->cell()) == v; } template < class Gt, class Tds > typename Regular_triangulation_3::Vertex_handle Regular_triangulation_3:: insert(const Weighted_point & p, Cell_handle start) { Locate_type lt; int li, lj; Cell_handle c = locate(p, lt, li, lj, start); return insert(p, lt, c, li, lj); } template < class Gt, class Tds > typename Regular_triangulation_3::Vertex_handle Regular_triangulation_3:: insert(const Weighted_point & p, Locate_type lt, Cell_handle c, int li, int) { switch (dimension()) { case 3: { // Case of same xyz coordinates, and same weight => point discarded. if ( lt == Tr_Base::VERTEX && power_test(p, c->vertex(li)->point() ) == 0 ) return c->vertex(li); if (! in_conflict_3(p, c)) { // new point is hidden c->hide_point(p); return Vertex_handle(); } // Should I mark c's vertices too ? Conflict_tester_3 tester(p, this); Vertex_handle v = insert_conflict_3(c, tester); v->set_point(p); for( typename std::vector::iterator it = tester.conflict_vector().begin(); it != tester.conflict_vector().end(); ++it) { if ((*it)->cell() == Cell_handle()) { // remember the hidden point Cell_handle hider = locate ((*it)->point(), v->cell()); hider->hide_point ((*it)->point()); // vertex has to be deleted tds().delete_vertex(*it); } } return v; } case 2: { switch (lt) { case Tr_Base::OUTSIDE_CONVEX_HULL: case Tr_Base::FACET: case Tr_Base::EDGE: case Tr_Base::VERTEX: { // Case of same xyz coordinates, and same weight => point discarded. if ( lt == Tr_Base::VERTEX && power_test(p, c->vertex(li)->point() ) == 0 ) return c->vertex(li); if (! in_conflict_2(p, c, 3)) { // new point is hidden c->hide_point (p); // remember the point return Vertex_handle(); } Conflict_tester_2 tester(p, this); Vertex_handle v = insert_conflict_2(c, tester); v->set_point(p); for( typename std::vector::iterator it = tester.conflict_vector().begin(); it != tester.conflict_vector().end(); ++it) { if ((*it)->cell() == Cell_handle()) { // remember the hidden point Cell_handle hider = locate ((*it)->point(), v->cell()); hider->hide_point ((*it)->point()); // vertex has to be deleted tds().delete_vertex(*it); } } return v; } case Tr_Base::OUTSIDE_AFFINE_HULL: { // if the 2d triangulation is Regular, the 3d // triangulation will be Regular return Tr_Base::insert_outside_affine_hull(p); } default: CGAL_triangulation_assertion(false); // CELL cannot happen in 2D. } }//dim 2 case 1: { switch (lt) { case Tr_Base::OUTSIDE_CONVEX_HULL: case Tr_Base::EDGE: case Tr_Base::VERTEX: { // Case of same xyz coordinates, and same weight => point discarded. if ( lt == Tr_Base::VERTEX && power_test(p, c->vertex(li)->point() ) == 0 ) return c->vertex(li); if (! in_conflict_1(p, c)) { // new point is hidden c->hide_point (p); // remember the point return Vertex_handle(); } Cell_handle bound[2]; // corresponding index: bound[j]->neighbor(1-j) is in conflict. std::vector hidden_vertices; std::vector conflicts; conflicts.push_back(c); // We get all cells in conflict, // and remember the 2 external boundaries. for (int j = 0; j<2; ++j) { Cell_handle n = c->neighbor(j); while ( in_conflict_1( p, n) ) { conflicts.push_back(n); hidden_vertices.push_back(n->vertex(j)); n = n->neighbor(j); } bound[j] = n; } // We preserve the order (like the orientation in 2D-3D). Vertex_handle v = tds().create_vertex(); v->set_point(p); Cell_handle c0 = tds().create_face(v, bound[0]->vertex(0), Vertex_handle()); Cell_handle c1 = tds().create_face(bound[1]->vertex(1), v, Vertex_handle()); tds().set_adjacency(c0, 1, c1, 0); tds().set_adjacency(bound[0], 1, c0, 0); tds().set_adjacency(c1, 1, bound[1], 0); bound[0]->vertex(0)->set_cell(bound[0]); bound[1]->vertex(1)->set_cell(bound[1]); v->set_cell(c0); for (typename std::vector::iterator i = hidden_vertices.begin(); i != hidden_vertices.end(); ++i) { Cell_handle hider = locate ((*i)->point(), c0); hider->hide_point ((*i)->point()); } tds().delete_cells(conflicts.begin(), conflicts.end()); tds().delete_vertices(hidden_vertices.begin(), hidden_vertices.end()); return v; } case Tr_Base::OUTSIDE_AFFINE_HULL: return Tr_Base::insert_outside_affine_hull(p); case Tr_Base::FACET: case Tr_Base::CELL: // impossible in dimension 1 CGAL_assertion(false); return Vertex_handle(); } } case 0: { // We need to compare the weights when the points are equal. if (lt == Tr_Base::VERTEX) { CGAL_assertion(li == 0); if (in_conflict_0(p, c)) { c->hide_point (c->vertex(li)->point()); c->vertex(li)->set_point(p); // replace by heavier point } else { c->hide_point (p); // hide new point } } else return Tr_Base::insert(p, c); } default : { return Tr_Base::insert(p, c); } } } template < class Gt, class Tds > void Regular_triangulation_3:: remove_2D(Vertex_handle) { // Not yet implemented std::cerr << "WARNING: RT3::remove() in 2D not implemented" << std::endl; } #ifndef CGAL_CFG_NET2003_MATCHING_BUG template < class Gt, class Tds > void Regular_triangulation_3:: make_hole_3D (Vertex_handle v, std::map& outer_map, std::vector & hole) { CGAL_triangulation_expensive_precondition( ! test_dim_down(v) ); incident_cells(v, std::back_inserter(hole)); for (typename std::vector::iterator cit = hole.begin(); cit != hole.end(); ++cit) { int indv = (*cit)->index(v); Cell_handle opp_cit = (*cit)->neighbor( indv ); Facet f(opp_cit, opp_cit->index(*cit)); Vertex_triple vt = make_vertex_triple(f); make_canonical(vt); outer_map[vt] = f; for (int i=0; i<4; i++) if ( i != indv ) (*cit)->vertex(i)->set_cell(opp_cit); } } #endif template < class Gt, class Tds > void Regular_triangulation_3:: make_canonical(Vertex_triple& t) const { int i = (&*(t.first) < &*(t.second))? 0 : 1; if(i==0) { i = (&*(t.first) < &*(t.third))? 0 : 2; } else { i = (&*(t.second) < &*(t.third))? 1 : 2; } Vertex_handle tmp; switch(i){ case 0: return; case 1: tmp = t.first; t.first = t.second; t.second = t.third; t.third = tmp; return; default: tmp = t.first; t.first = t.third; t.third = t.second; t.second = tmp; } } template < class Gt, class Tds > typename Regular_triangulation_3::Vertex_triple Regular_triangulation_3:: make_vertex_triple(const Facet& f) const { // static const int vertex_triple_index[4][3] = { {1, 3, 2}, {0, 2, 3}, // {0, 3, 1}, {0, 1, 2} }; Cell_handle ch = f.first; int i = f.second; return Vertex_triple(ch->vertex(vertex_triple_index(i,0)), ch->vertex(vertex_triple_index(i,1)), ch->vertex(vertex_triple_index(i,2))); } template < class Gt, class Tds > void Regular_triangulation_3:: remove_3D(Vertex_handle v) { std::vector hole; hole.reserve(64); // Construct the set of vertex triples on the boundary // with the facet just behind typedef std::map Vertex_triple_Facet_map; Vertex_triple_Facet_map outer_map; Vertex_triple_Facet_map inner_map; make_hole_3D (v, outer_map, hole); bool inf = false; unsigned int i; // collect all vertices on the boundary std::vector vertices; vertices.reserve(64); incident_vertices(v, std::back_inserter(vertices)); // create a Regular triangulation of the points on the boundary // and make a map from the vertices in aux towards the vertices in *this Self aux; Unique_hash_map vmap; Cell_handle ch = Cell_handle(); for(i=0; i < vertices.size(); i++){ if(! is_infinite(vertices[i])){ Vertex_handle vh = aux.insert(vertices[i]->point(), ch); ch = vh->cell(); vmap[vh] = vertices[i]; }else { inf = true; } } if(aux.dimension()==2){ Vertex_handle fake_inf = aux.insert(v->point()); vmap[fake_inf] = infinite_vertex(); } else { vmap[aux.infinite_vertex()] = infinite_vertex(); } CGAL_triangulation_assertion(aux.dimension() == 3); // Construct the set of vertex triples of aux // We reorient the vertex triple so that it matches those from outer_map // Also note that we use the vertices of *this, not of aux if(inf){ for(All_cells_iterator it = aux.all_cells_begin(); it != aux.all_cells_end(); ++it){ for(i=0; i < 4; i++){ Facet f = std::pair(it,i); Vertex_triple vt_aux = make_vertex_triple(f); Vertex_triple vt(vmap[vt_aux.first],vmap[vt_aux.third],vmap[vt_aux.second]); make_canonical(vt); inner_map[vt]= f; } } } else { for(Finite_cells_iterator it = aux.finite_cells_begin(); it != aux.finite_cells_end(); ++it){ for(i=0; i < 4; i++){ Facet f = std::pair(it,i); Vertex_triple vt_aux = make_vertex_triple(f); Vertex_triple vt(vmap[vt_aux.first],vmap[vt_aux.third],vmap[vt_aux.second]); make_canonical(vt); inner_map[vt]= f; } } } // Grow inside the hole, by extending the surface while(! outer_map.empty()){ typename Vertex_triple_Facet_map::iterator oit = outer_map.begin(); while(is_infinite(oit->first.first) || is_infinite(oit->first.second) || is_infinite(oit->first.third)){ ++oit; // otherwise the lookup in the inner_map fails // because the infinite vertices are different } typename Vertex_triple_Facet_map::value_type o_vt_f_pair = *oit; Cell_handle o_ch = o_vt_f_pair.second.first; unsigned int o_i = o_vt_f_pair.second.second; typename Vertex_triple_Facet_map::iterator iit = inner_map.find(o_vt_f_pair.first); CGAL_triangulation_assertion(iit != inner_map.end()); typename Vertex_triple_Facet_map::value_type i_vt_f_pair = *iit; Cell_handle i_ch = i_vt_f_pair.second.first; unsigned int i_i = i_vt_f_pair.second.second; // create a new cell and glue it to the outer surface Cell_handle new_ch = tds().create_cell(); new_ch->set_vertices(vmap[i_ch->vertex(0)], vmap[i_ch->vertex(1)], vmap[i_ch->vertex(2)], vmap[i_ch->vertex(3)]); o_ch->set_neighbor(o_i,new_ch); new_ch->set_neighbor(i_i, o_ch); // for the other faces check, if they can also be glued for(i = 0; i < 4; i++){ if(i != i_i){ Facet f = std::pair(new_ch,i); Vertex_triple vt = make_vertex_triple(f); make_canonical(vt); std::swap(vt.second,vt.third); typename Vertex_triple_Facet_map::iterator oit2 = outer_map.find(vt); if(oit2 == outer_map.end()){ std::swap(vt.second,vt.third); outer_map[vt]= f; } else { // glue the faces typename Vertex_triple_Facet_map::value_type o_vt_f_pair2 = *oit2; Cell_handle o_ch2 = o_vt_f_pair2.second.first; int o_i2 = o_vt_f_pair2.second.second; o_ch2->set_neighbor(o_i2,new_ch); new_ch->set_neighbor(i, o_ch2); outer_map.erase(oit2); } } } outer_map.erase(oit); } // reinsert hidden points typename std::vector::iterator hi, hend; for (hi = hole.begin(), hend = hole.end(); hi != hend; ++hi) { int hole_i = (*hi)->index(v); int out_i = (*hi)->mirror_index (hole_i); Cell_handle out_ch = (*hi)->neighbor (hole_i); typename Cell::Point_iterator pi, pend; for (pi = (*hi)->hidden_points_begin(), pend = (*hi)->hidden_points_end(); pi != pend; ++pi) { insert (*pi, out_ch->neighbor (out_i)); } } tds().delete_vertex(v); tds().delete_cells(hole.begin(), hole.end()); } template < class Gt, class Tds > void Regular_triangulation_3:: remove(Vertex_handle v) { CGAL_triangulation_precondition( v != Vertex_handle()); CGAL_triangulation_precondition( !is_infinite(v)); CGAL_triangulation_expensive_precondition( tds().is_vertex(v) ); if (dimension() >= 0 && test_dim_down(v)) { // collect all the hidden points std::vector hidden; Finite_cells_iterator ci, cend; for (ci = finite_cells_begin(), cend = finite_cells_end(); ci != cend; ++ci) { typename Cell::Point_iterator hi, hend; for (hi = ci->hidden_points_begin(), hend = ci->hidden_points_end(); hi != hend; ++hi) hidden.push_back(*hi); } tds().remove_decrease_dimension(v); // Now try to see if we need to re-orient. if (dimension() == 2) { Facet f = *finite_facets_begin(); if (coplanar_orientation(f.first->vertex(0)->point(), f.first->vertex(1)->point(), f.first->vertex(2)->point()) == NEGATIVE) tds().reorient(); } // reinsert the hidden points insert (hidden.begin(), hidden.end()); CGAL_triangulation_expensive_postcondition(is_valid()); return; } if (dimension() == 1) { tds().remove_from_maximal_dimension_simplex(v); CGAL_triangulation_expensive_postcondition(is_valid()); return; } if (dimension() == 2) { remove_2D(v); CGAL_triangulation_expensive_postcondition(is_valid()); return; } CGAL_triangulation_assertion( dimension() == 3 ); remove_3D(v); CGAL_triangulation_expensive_postcondition(is_valid()); } template < class Gt, class Tds > typename Regular_triangulation_3::Vertex_handle Regular_triangulation_3:: move_point(Vertex_handle v, const Weighted_point & p) { CGAL_triangulation_precondition(! is_infinite(v)); CGAL_triangulation_expensive_precondition(is_vertex(v)); // Dummy implementation for a start. // Remember an incident vertex to restart // the point location after the removal. Cell_handle c = v->cell(); Vertex_handle old_neighbor = c->vertex(c->index(v) == 0 ? 1 : 0); CGAL_triangulation_assertion(old_neighbor != v); remove(v); if (dimension() <= 0) return insert(p); return insert(p, old_neighbor->cell()); } template < class Gt, class Tds > bool Regular_triangulation_3:: is_valid(bool verbose, int level) const { if ( ! Tr_Base::is_valid(verbose,level) ) { if (verbose) std::cerr << "invalid base triangulation" << std::endl; CGAL_triangulation_assertion(false); return false; } switch ( dimension() ) { case 3: { Finite_cells_iterator it; for ( it = finite_cells_begin(); it != finite_cells_end(); ++it ) { is_valid_finite(it, verbose, level); for (int i=0; i<4; i++ ) { if ( !is_infinite (it->neighbor(i)->vertex(it->neighbor(i)->index(it))) ) { if ( side_of_power_sphere (it, it->neighbor(i)->vertex(it->neighbor(i)->index(it))->point()) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty sphere " << std::endl; CGAL_triangulation_assertion(false); return false; } } } } break; } case 2: { Finite_facets_iterator it; for ( it = finite_facets_begin(); it != finite_facets_end(); ++it ) { is_valid_finite((*it).first, verbose, level); for (int i=0; i<3; i++ ) { if( !is_infinite ((*it).first->neighbor(i)->vertex( (((*it).first)->neighbor(i)) ->index((*it).first))) ) { if ( side_of_power_circle ( (*it).first, 3, (*it).first->neighbor(i)-> vertex( (((*it).first)->neighbor(i)) ->index((*it).first) )->point() ) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty circle " << std::endl; CGAL_triangulation_assertion(false); return false; } } } } break; } case 1: { Finite_edges_iterator it; for ( it = finite_edges_begin(); it != finite_edges_end(); ++it ) { is_valid_finite((*it).first, verbose, level); for (int i=0; i<2; i++ ) { if( !is_infinite ((*it).first->neighbor(i)->vertex( (((*it).first)->neighbor(i)) ->index((*it).first))) ) { if ( side_of_power_segment ( (*it).first, (*it).first->neighbor(i)-> vertex( (((*it).first)->neighbor(i)) ->index((*it).first) )->point() ) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty edge " << std::endl; CGAL_triangulation_assertion(false); return false; } } } } break; } } if (verbose) std::cerr << "valid Regular triangulation" << std::endl; return true; } CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_3_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/MSVC_standard_header_fixes.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/MSVC_standard_header_f0000644000175000017500000000274711344301500031222 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/MSVC_standard_header_fixes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_MSVC_STANDARD_HEADER_FIXES_H #define CGAL_MSVC_STANDARD_HEADER_FIXES_H #pragma warning(once: 4291) #pragma warning(once:4503) #include namespace std { using ::sqrt; } #include namespace std{ using ::size_t; using ::ptrdiff_t; } #include namespace std{ using ::time_t; } #endif // CGAL_MSVC_STANDARD_HEADER_FIXES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_exact.h0000644000175000017500000004320611344301500030120 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_exact.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_FILTERED_EXACT_H #define CGAL_FILTERED_EXACT_H #define CGAL_ARITHMETIC_FILTER_H // for backward compatibility. // This file contains a wrapper type for number types, that helps for // specializing template predicates, to use interval arithmetic as a filter. // Note: This stuff will one day be made obsolete by a filtered scheme at the // kernel level. #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // CT = construction type // ET = exact type (used for exact predicate evaluation) // Type = Static/Dynamic // Protection = false/true (used to be Advanced/Protected) // Cache = Filter_Cache/No_Filter_Cache // // Static + Protected : static adaptative // Static + Advanced : really static (needs some way to initialize bounds) // Dynamic + Protected : the current old one, based on intervals // Dynamic + Advanced : rounding assumes +infty before entering predicates // // (Interval_nt_advanced) = used for filtering. // // 2 conversion functions must be provided: // - to_interval(CT) // which gives an interval SURELY containing the CT value. // - convert_to (CT) // which converts EXACTLY the CT value to ET. // // Let's add a .error() for when CT -> double is not exact. // The user can initialize bounds using: // Static_Filtered_orientationC2_6::new_bound(NEW_bound); struct Static {}; struct Dynamic {}; struct No_Filter_Cache {}; typedef Interval_nt_advanced Filter_Cache; template < class CT, class ET, class Type = Dynamic, bool Protection = true, class Cache = No_Filter_Cache > class Filtered_exact : private Cache // To benefit from the empty base class optimization. { typedef Filtered_exact Fil; typedef Interval_nt_advanced IA; // Cache managing functions. const IA & give_interval (const IA &inter) const { return inter; } IA give_interval (const No_Filter_Cache &) const { return Interval_nt_advanced(CGAL::to_interval(_value)); } void compute_cache (const No_Filter_Cache &) const {} void compute_cache (IA &inter) const { inter = give_interval (No_Filter_Cache()); } void update_cache() { compute_cache (cache()); } const Cache & cache() const { return *this; } Cache & cache() { return *this; } // Private data member. CT _value; public: typedef typename Number_type_traits::Has_gcd Has_gcd; typedef typename Number_type_traits::Has_division Has_division; typedef typename Number_type_traits::Has_sqrt Has_sqrt; typedef typename Number_type_traits::Has_exact_sqrt Has_exact_sqrt; typedef typename Number_type_traits::Has_exact_division Has_exact_division; typedef typename Number_type_traits::Has_exact_ring_operations Has_exact_ring_operations; Filtered_exact () {} Filtered_exact (const CT & ct) : _value(ct) { update_cache(); } template Filtered_exact (const NT & num, const NT & den) // For Quotient<>. : _value(num, den) { update_cache(); } // The access functions. const CT & value() const { return _value; } IA interval() const { return give_interval(cache()); } ET exact() const { return convert_to(_value); } double to_double() const { return CGAL::to_double(_value); } Restricted_double dbl() const { return Restricted_double(to_double()); } Fil operator- () const { return Fil(-_value); } #ifndef CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER Fil& operator+=(const Fil& fil) { _value += fil._value; update_cache(); return *this; } Fil& operator-=(const Fil& fil) { _value -= fil._value; update_cache(); return *this; } Fil& operator*=(const Fil& fil) { _value *= fil._value; update_cache(); return *this; } Fil& operator/=(const Fil& fil) { _value /= fil._value; update_cache(); return *this; } Fil& operator%=(const Fil& fil) { _value %= fil._value; update_cache(); return *this; } #endif // CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER }; #ifndef CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator+(const Filtered_exact& a, const Filtered_exact& b) { return a.value() + b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator-(const Filtered_exact& a, const Filtered_exact& b) { return a.value() - b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator*(const Filtered_exact& a, const Filtered_exact& b) { return a.value() * b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator/(const Filtered_exact& a, const Filtered_exact& b) { return a.value() / b.value(); } // mixed operators template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator+(const Filtered_exact& a, int b) { return a.value() + b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator-(const Filtered_exact& a, int b) { return a.value() - b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator*(const Filtered_exact& a, int b) { return a.value() * b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator/(const Filtered_exact& a, int b) { return a.value() / b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator+(int a, const Filtered_exact& b) { return a + b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator-(int a, const Filtered_exact& b) { return a - b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator*(int a, const Filtered_exact& b) { return a * b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact operator/(int a, const Filtered_exact& b) { return a / b.value(); } #endif // CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator<(const Filtered_exact& a, const Filtered_exact& b) { return a.value() < b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator>(const Filtered_exact& a, const Filtered_exact& b) { return a.value() > b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator<=(const Filtered_exact& a, const Filtered_exact& b) { return a.value() <= b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator>=(const Filtered_exact& a, const Filtered_exact& b) { return a.value() >= b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator==(const Filtered_exact& a, const Filtered_exact& b) { return a.value() == b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator!=(const Filtered_exact& a, const Filtered_exact& b) { return a.value() != b.value(); } // mixed operators template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator<(const Filtered_exact& a, int b) { return a.value() < b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator>(const Filtered_exact& a, int b) { return a.value() > b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator<=(const Filtered_exact& a, int b) { return a.value() <= b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator>=(const Filtered_exact& a, int b) { return a.value() >= b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator==(const Filtered_exact& a, int b) { return a.value() == b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator!=(const Filtered_exact& a, int b) { return a.value() != b; } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator<(int a, const Filtered_exact& b) { return a < b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator>(int a, const Filtered_exact& b) { return a > b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator<=(int a, const Filtered_exact& b) { return a <= b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator>=(int a, const Filtered_exact& b) { return a >= b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator==(int a, const Filtered_exact& b) { return a == b.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool operator!=(int a, const Filtered_exact& b) { return a != b.value(); } namespace CGALi { // gcd and div make no sense for Filtered_exact with double. // As we have to provide a full specialization of gcd and div // for this number type we have to make it compile and make // it issue a warning at runtime. template NT checked_gcd(const NT& n1, const NT& n2, Tag_true) { return CGAL_NTS gcd(n1,n2); } template NT checked_gcd(const NT& n1, const NT& n2, Tag_false) { bool THIS_FUNCTION_SHOULD_ONLY_BE_INSTANTIATED_ON_MSVC_7_0; CGAL_assertion_msg(false, "numbertype has no gcd"); return NT(); } template NT checked_div(const NT& n1, const NT& n2, Tag_true) { return CGAL_NTS div(n1,n2); } template NT checked_div(const NT& n1, const NT& n2, Tag_false) { bool THIS_FUNCTION_SHOULD_ONLY_BE_INSTANTIATED_ON_MSVC_7_0; CGAL_assertion_msg(false, "numbertype has no div"); return NT(); } } // namespace CGALi // We forward the following functions to the CT value: // sqrt, square, is_valid, is_finite, to_double, sign, compare, abs, min, max, // div, gcd, io_tag, operator>>, operator<<. #ifndef CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER template < class CT, class ET, bool Protected, class Cache > inline Filtered_exact div (const Filtered_exact& fil1, const Filtered_exact& fil2) { typedef typename Filtered_exact::Has_gcd Has_gcd; return CGAL::CGALi::checked_div(fil1.value(), fil2.value(), Has_gcd()); } template < class CT, class ET, class Type, bool Protected, class Cache > inline Filtered_exact sqrt (const Filtered_exact& fil) { return CGAL::sqrt(fil.value()); } template < class CT, class ET, bool Protected, class Cache > inline Filtered_exact gcd (const Filtered_exact& fil1, const Filtered_exact& fil2) { typedef typename Filtered_exact::Has_gcd Has_gcd; return CGAL::CGALi::checked_gcd(fil1.value(), fil2.value(), Has_gcd()); } template < class CT, class ET, bool Protected, class Cache > inline Filtered_exact square (const Filtered_exact& fil) { return CGAL_NTS square(fil.value()); } #endif // CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER template < class CT, class ET, class Type, bool Protected, class Cache > inline bool is_valid (const Filtered_exact& fil) { return CGAL::is_valid(fil.value()); } template < class CT, class ET, class Type, bool Protected, class Cache > inline bool is_finite (const Filtered_exact& fil) { return CGAL::is_finite(fil.value()); } template < class CT, class ET, class Type, bool Protected, class Cache > inline double to_double (const Filtered_exact& fil) { return CGAL::to_double(fil.value()); } template < class CT, class ET, class Type, bool Protected, class Cache > inline std::pair to_interval (const Filtered_exact& fil) { return CGAL::to_interval(fil.value()); } template < class CT, class ET, bool Protected, class Cache > inline Sign sign (const Filtered_exact& fil) { return CGAL_NTS sign(fil.value()); } template < class CT, class ET, bool Protected, class Cache > inline Comparison_result compare (const Filtered_exact& fil, const Filtered_exact& fil2) { return CGAL_NTS compare(fil.value(), fil2.value()); } template < class CT, class ET, bool Protected, class Cache > inline Filtered_exact abs (const Filtered_exact& fil) { return CGAL_NTS abs(fil.value()); } template < class CT, class ET, bool Protected, class Cache > inline Filtered_exact min (const Filtered_exact& fil, const Filtered_exact& fil2) { return min(fil.value(), fil2.value()); } template < class CT, class ET, bool Protected, class Cache > inline Filtered_exact max (const Filtered_exact& fil, const Filtered_exact& fil2) { return max(fil.value(), fil2.value()); } template < class CT, class ET, class Type, bool Protected, class Cache > inline io_Operator io_tag (const Filtered_exact &fil) { return io_tag(fil.value()); } template < class CT, class ET, class Type, bool Protected, class Cache > inline std::ostream & operator<< (std::ostream& os, const Filtered_exact& d) { return os << d.value(); } template < class CT, class ET, class Type, bool Protected, class Cache > inline std::istream & operator>> (std::istream &is, Filtered_exact& d) { CT e; is >> e; d = e; return is; } CGAL_END_NAMESPACE #include // the overloaded predicates #endif // CGAL_FILTERED_EXACT_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Ray_2_intersecti0000644000175000017500000002266311344301500031215 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_RAY_2_RAY_2_INTERSECTION_H #define CGAL_RAY_2_RAY_2_INTERSECTION_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Ray_2_Ray_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT, RAY}; Ray_2_Ray_2_pair() ; Ray_2_Ray_2_pair(typename K::Ray_2 const *ray1, typename K::Ray_2 const *ray2); ~Ray_2_Ray_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; bool intersection(typename K::Ray_2 &result) const; protected: typename K::Ray_2 const* _ray1; typename K::Ray_2 const * _ray2; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point, _other_point; }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Ray_2 &p1, const typename CGAL_WRAP(K)::Ray_2 &p2, const K& k) { typedef Ray_2_Ray_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Ray_2_Ray_2_pair::Ray_2_Ray_2_pair() { _ray1 = 0; _ray2 = 0; _known = false; } template Ray_2_Ray_2_pair::Ray_2_Ray_2_pair( typename K::Ray_2 const *ray1, typename K::Ray_2 const *ray2) { _ray1 = ray1; _ray2 = ray2; _known = false; } template typename Ray_2_Ray_2_pair::Intersection_results Ray_2_Ray_2_pair::intersection_type() const { if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; // if (!do_overlap(_ray1->bbox(), _ray2->bbox())) // return NO; const typename K::Line_2 &l1 = _ray1->supporting_line(); const typename K::Line_2 &l2 = _ray2->supporting_line(); Line_2_Line_2_pair linepair(&l1, &l2); switch ( linepair.intersection_type()) { case Line_2_Line_2_pair::NO: _result = NO; return _result; case Line_2_Line_2_pair::POINT: linepair.intersection(_intersection_point); _result = (_ray1->collinear_has_on(_intersection_point) && _ray2->collinear_has_on(_intersection_point) ) ? POINT : NO; return _result; case Line_2_Line_2_pair::LINE: { typedef typename K::RT RT; const typename K::Vector_2 &dir1 = _ray1->direction().to_vector(); const typename K::Vector_2 &dir2 = _ray2->direction().to_vector(); if (CGAL_NTS abs(dir1.x()) > CGAL_NTS abs(dir1.y())) { typedef typename K::FT FT; if (dir1.x() > FT(0)) { if (dir2.x() > FT(0)) { _intersection_point = (_ray1->source().x() < _ray2->source().x()) ? _ray2->source() : _ray1->source(); _result = RAY; return _result; } else { if (_ray1->source().x() > _ray2->source().x()) { _result = NO; return _result; } if (_ray1->source().x() == _ray2->source().x()) { _intersection_point = _ray1->source(); _result = POINT; return _result; } _result = SEGMENT; return _result; } } else { if (dir2.x() < FT(0)) { _intersection_point = (_ray1->source().x() > _ray2->source().x()) ? _ray2->source() : _ray1->source(); _result = RAY; return _result; } else { if (_ray1->source().x() < _ray2->source().x()) { _result = NO; return _result; } if (_ray1->source().x() == _ray2->source().x()) { _intersection_point = _ray1->source(); _result = POINT; return _result; } _result = SEGMENT; return _result; } } } else { typedef typename K::FT FT; if (dir1.y() > FT(0)) { if (dir2.y() > FT(0)) { _intersection_point = (_ray1->source().y() < _ray2->source().y()) ? _ray2->source() : _ray1->source(); _result = RAY; return _result; } else { if (_ray1->source().y() > _ray2->source().y()) { _result = NO; return _result; } if (_ray1->source().y() == _ray2->source().y()) { _intersection_point = _ray1->source(); _result = POINT; return _result; } _result = SEGMENT; return _result; } } else { if (dir2.y() < FT(0)) { _intersection_point = (_ray1->source().y() > _ray2->source().y()) ? _ray2->source() : _ray1->source(); _result = RAY; return _result; } else { if (_ray1->source().y() < _ray2->source().y()) { _result = NO; return _result; } if (_ray1->source().y() == _ray2->source().y()) { _intersection_point = _ray1->source(); _result = POINT; return _result; } _result = SEGMENT; return _result; } } } } default: CGAL_kernel_assertion(false); // should not be reached: return _result; } } template bool Ray_2_Ray_2_pair::intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Ray_2_Ray_2_pair::intersection(typename K::Segment_2 &result) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = Segment_2(_ray1->source(), _ray2->source()); return true; } template bool Ray_2_Ray_2_pair::intersection(typename K::Ray_2 &result) const { typedef typename K::Ray_2 Ray_2; if (!_known) intersection_type(); if (_result != RAY) return false; result = Ray_2(_intersection_point, _ray1->direction()); return true; } template Object intersection(const typename CGAL_WRAP(K)::Ray_2 &ray1, const typename CGAL_WRAP(K)::Ray_2 &ray2, const K&) { typedef Ray_2_Ray_2_pair is_t; is_t ispair(&ray1, &ray2); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } case is_t::RAY: { typename K::Ray_2 iray; ispair.intersection(iray); return make_object(iray); } } } } // namespace CGALi template inline bool do_intersect(const Ray_2 &ray1, const Ray_2 &ray2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(ray1, ray2); } template Object intersection(const Ray_2 &ray1, const Ray_2 &ray2) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray1, ray2); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2.h0000644000175000017500000000423011344301501027157 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_TRIANGLE_2_H #define CGAL_TRIANGLE_2_H CGAL_BEGIN_NAMESPACE template class Triangle_2 : public R_::Kernel_base::Triangle_2 { typedef typename R_::Point_2 Point_2; typedef typename R_::Kernel_base::Triangle_2 RTriangle_2; public: typedef R_ R; Triangle_2() {} Triangle_2(const RTriangle_2& t) : RTriangle_2(t) {} Triangle_2(const Point_2 &p, const Point_2 &q, const Point_2 &r) : RTriangle_2(p,q,r) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_TRIANGLE_2 template < class R > std::ostream & operator<<(std::ostream &os, const Triangle_2 &t) { typedef typename R::Kernel_base::Triangle_2 RTriangle_2; return os << (const RTriangle_2&)t; } #endif // CGAL_NO_OSTREAM_INSERT_TRIANGLE_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_TRIANGLE_2 template < class R > std::istream & operator>>(std::istream &is, Triangle_2 &t) { typedef typename R::Kernel_base::Triangle_2 RTriangle_2; return is >> (RTriangle_2&)t; } #endif // CGAL_NO_ISTREAM_EXTRACT_TRIANGLE_2 CGAL_END_NAMESPACE #endif // CGAL_TRIANGLE_2_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_short_names_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000000332211344301501031370 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_short_names_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_SHORT_NAMES_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_SHORT_NAMES_2_H #define Segment_Voronoi_diagram_site_2 Svds2 #define Segment_Voronoi_diagram_simple_site_2 Svdsims2 #define Segment_Voronoi_diagram_storage_site_2 Svdss2 #define Segment_Voronoi_diagram_simple_storage_site_2 Svdsimss2 #define Segment_Voronoi_diagram_2 Svd2 #define Segment_Voronoi_diagram_hierarchy_2 Svdh2 #define Segment_Voronoi_diagram_vertex_base_2 Svdvb2 #define Segment_Voronoi_diagram_hierarchy_vertex_base_2 Svdhvb2 #define Segment_Voronoi_diagram_traits_2 Svdt2 #define Segment_Voronoi_diagram_filtered_traits_2 Svdft2 #define Segment_Voronoi_diagram_traits_wrapper_2 Svdtw2 #define Segment_Voronoi_diagram_kernel_wrapper_2 Svdkw2 #endif //CGAL_SEGMENT_VORONOI_DIAGRAM_SHORT_NAMES_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_unbounding_box.h0000644000175000017500000001407711344301500030656 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_unbounding_box.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PM_UNBOUNDING_BOX_H #define CGAL_PM_UNBOUNDING_BOX_H #include #include CGAL_BEGIN_NAMESPACE template class Pm_unbounding_box : public Pm_bounding_box_base { public: typedef Planar_map_ Planar_map; typedef Pm_unbounding_box Self; // typedef Planar_map_2 Planar_map; /* typedef Planar_map_2 Base; typedef Planar_map_Bbox_2 Self; typedef Pm_traits_wrap_2 Traits_wrap; */ typedef typename Planar_map::Traits Traits; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Point_2 Point_2; typedef typename std::vector::iterator Point_iterator; typedef typename std::vector::iterator X_curve_iterator; /* typedef typename Traits::Bounding_box Bounding_box; typedef typename Traits::Boundary_type Boundary_type; typedef typename Traits::Point_boundary_container Point_boundary_container; typedef typename Traits::X_curve_boundary_container X_curve_boundary_container; */ typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Face_const_handle Face_const_handle; typedef typename Planar_map::Vertex_iterator Vertex_iterator; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Face_iterator Face_iterator; typedef typename Planar_map::Vertex_const_iterator Vertex_const_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Face_const_iterator Face_const_iterator; typedef typename Planar_map::Locate_type Locate_type; /* typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Vertex_iterator Vertex_iterator; typedef typename Base::Halfedge_iterator Halfedge_iterator; typedef typename Base::Face_iterator Face_iterator; typedef typename Base::Vertex_const_iterator Vertex_const_iterator; typedef typename Base::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Base::Face_const_iterator Face_const_iterator; typedef typename Base::Locate_type Locate_type; typedef Pm_point_location_base Point_location_base; // typedef std::list X_curve_container; // typedef Topological_map<_Dcel> TPM; typedef typename Base::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Base::Holes_iterator Holes_iterator; typedef typename Base::Holes_const_iterator Holes_const_iterator; typedef typename Base::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Base::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Base::Size Size; */ Pm_unbounding_box(){} ~Pm_unbounding_box(){} void init(Planar_map &, Traits &) { /* pm = &pmp; traits = (Traits_wrap*)(&tr); */ } bool insert(const Point_2 &) {return true;} #ifndef _MSC_VER bool insert(const Point_iterator &, const Point_iterator &) #else // workaround for MSVC6.0 bool insert(const Point_iterator &, const Point_iterator &, Point_2 * dummy = 0) #endif {return true;} bool insert(const X_monotone_curve_2 &) {return true;} #ifndef _MSC_VER bool insert(const X_curve_iterator &, const X_curve_iterator &) #else // workaround for MSVC6.0 bool insert(const X_curve_iterator &, const X_curve_iterator &, X_monotone_curve_2 * dummy = 0) #endif {return true;} /* The point location query function may updates the resulting halfedge handle and locate type as expected from the bounding box */ bool locate(const Point_2 &, Locate_type &, Halfedge_handle &) {return true;} bool vertical_ray_shoot(const Point_2 &, Locate_type &, bool, Halfedge_handle &) {return true;} void split_edge(const X_monotone_curve_2 &, Halfedge_handle, Halfedge_handle, const X_monotone_curve_2 &, const X_monotone_curve_2 &) {} void split_boundary_edge(const Halfedge_handle &, Halfedge_handle, Halfedge_handle, const Point_2 &) {} void merge_edge(const X_monotone_curve_2 &, const X_monotone_curve_2 &, Halfedge_handle, //additions by iddo for arrangement const X_monotone_curve_2 &) {} void remove_edge(Halfedge_handle) {} inline bool is_empty() const {return false;} #ifdef CGAL_PM_DEBUG void debug() const {} #endif }; CGAL_END_NAMESPACE #endif //CGAL_PM_UNBOUNDING_BOX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sixtuple.h0000644000175000017500000000276011344301501027014 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sixtuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL__SIXTUPLE_H #define CGAL__SIXTUPLE_H CGAL_BEGIN_NAMESPACE template < class T > class Sixtuple { public: T e0; T e1; T e2; T e3; T e4; T e5; Sixtuple() {} Sixtuple(const T & a0, const T & a1, const T & a2, const T & a3, const T & a4, const T & a5) : e0(a0), e1(a1), e2(a2), e3(a3), e4(a4), e5(a5) {} }; CGAL_END_NAMESPACE #endif // CGAL__SIXTUPLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_copy_3.h0000644000175000017500000000576311344301500030603 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_copy_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_POLYHEDRON_COPY_3_H #define CGAL_POLYHEDRON_COPY_3_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Poly, class HDS > class Polyhedron_copy_3 : public Modifier_base { protected: const Poly& source; public: typedef Poly Polyhedron; typedef HDS Halfedge_data_structure; Polyhedron_copy_3( const Polyhedron& poly) : source(poly) {} // creates the copy modifier and stores the `source' in its // internal state. void operator()( HDS& target); // copies the `source' known from creation time into the `target'. // Postcondition: the `target' is a valid polyhedral surface. }; template < class Poly, class HDS> void Polyhedron_copy_3:: operator()( HDS& target) { typedef typename Poly::Vertex_const_iterator Vertex_const_iterator; typedef typename Poly::Facet_const_iterator Facet_const_iterator; typedef Inverse_index< Vertex_const_iterator> Index; typedef typename HDS::Point Point; target.clear(); Polyhedron_incremental_builder_3 B( target); B.begin_surface( source.size_of_vertices(), source.size_of_facets(), source.size_of_halfedges()); for ( Vertex_const_iterator vi = source.vertices_begin(); vi != source.vertices_end(); ++vi) { B.add_vertex( Point( vi->point())); } Index index( source.vertices_begin(), source.vertices_end()); for ( Facet_const_iterator fi = source.facets_begin(); fi != source.facets_end(); ++fi) { B.begin_facet(); typedef typename Poly::Halfedge_around_facet_const_circulator Halfedge_around_facet_const_circulator; Halfedge_around_facet_const_circulator hc = fi->facet_begin(); Halfedge_around_facet_const_circulator hc_end = hc; CGAL_assertion( hc != NULL); do { B.add_vertex_to_facet( index[ hc->vertex()]); ++hc; } while( hc != hc_end); B.end_facet(); } B.end_surface(); target.normalize_border(); } CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_COPY_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/concept_archetype_2.h0000644000175000017500000001673411344301500031124 0ustar debiandebian// Copyright (c) 1999,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/concept_archetype_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_CONCEPT_ARCHETYPE_2 #define CGAL_CONCEPT_ARCHETYPE_2 // 2d CA types (and number types)... #define CGAL_concept_archetype_constructors(T) \ template T(const T1&) { } \ template T(const T1&,const T2&) { } \ template T(const T1&,const T2&,const T3&) { } \ template \ T(const T1&,const T2&,const T3&,const T4&) { } \ template \ T(const T1&,const T2&,const T3&,const T4&,const T5&) { } CGAL_BEGIN_NAMESPACE struct Point_2_archetype { Point_2_archetype() { } Point_2_archetype(const Point_2_archetype& t) { } Point_2_archetype& operator=(const Point_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Point_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Point_2_archetype& obj1, const Point_2_archetype& obj2) { return true; } inline bool operator!=(const Point_2_archetype& obj1, const Point_2_archetype& obj2) { return true; } #endif struct Segment_2_archetype { Segment_2_archetype() { } Segment_2_archetype(const Segment_2_archetype& t) { } Segment_2_archetype& operator=(const Segment_2_archetype& t) { return *this;} #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Segment_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Segment_2_archetype& obj1, const Segment_2_archetype& obj2) { return true; } inline bool operator!=(const Segment_2_archetype& obj1, const Segment_2_archetype& obj2) { return true; } #endif struct Line_2_archetype { Line_2_archetype() { } Line_2_archetype(const Line_2_archetype& t) { } Line_2_archetype& operator=(const Line_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Line_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Line_2_archetype& obj1, const Line_2_archetype& obj2) { return true; } inline bool operator!=(const Line_2_archetype& obj1, const Line_2_archetype& obj2) { return true; } #endif struct Ray_2_archetype { Ray_2_archetype() { } Ray_2_archetype(const Ray_2_archetype& t) { } Ray_2_archetype& operator=(const Ray_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Ray_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Ray_2_archetype& obj1, const Ray_2_archetype& obj2) { return true; } inline bool operator!=(const Ray_2_archetype& obj1, const Ray_2_archetype& obj2) { return true; } #endif struct Vector_2_archetype { Vector_2_archetype() { } Vector_2_archetype(const Vector_2_archetype& t) { } Vector_2_archetype& operator=(const Vector_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Vector_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Vector_2_archetype& obj1, const Vector_2_archetype& obj2) { return true; } inline bool operator!=(const Vector_2_archetype& obj1, const Vector_2_archetype& obj2) { return true; } #endif struct Direction_2_archetype { Direction_2_archetype() { } Direction_2_archetype(const Direction_2_archetype& t) { } Direction_2_archetype& operator=(const Direction_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Direction_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Direction_2_archetype& obj1, const Direction_2_archetype& obj2) { return true; } inline bool operator!=(const Direction_2_archetype& obj1, const Direction_2_archetype& obj2) { return true; } #endif struct Triangle_2_archetype { Triangle_2_archetype() { } Triangle_2_archetype(const Triangle_2_archetype& t) { } Triangle_2_archetype& operator=(const Triangle_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Triangle_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Triangle_2_archetype& obj1, const Triangle_2_archetype& obj2) { return true; } inline bool operator!=(const Triangle_2_archetype& obj1, const Triangle_2_archetype& obj2) { return true; } #endif struct Circle_2_archetype { Circle_2_archetype() { } Circle_2_archetype(const Circle_2_archetype& t) { } Circle_2_archetype& operator=(const Circle_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Circle_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Circle_2_archetype& obj1, const Circle_2_archetype& obj2) { return true; } inline bool operator!=(const Circle_2_archetype& obj1, const Circle_2_archetype& obj2) { return true; } #endif struct Iso_rectangle_2_archetype { Iso_rectangle_2_archetype() { } Iso_rectangle_2_archetype(const Iso_rectangle_2_archetype& t) { } Iso_rectangle_2_archetype& operator=(const Iso_rectangle_2_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Iso_rectangle_2_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Iso_rectangle_2_archetype& obj1, const Iso_rectangle_2_archetype& obj2) { return true; } inline bool operator!=(const Iso_rectangle_2_archetype& obj1, const Iso_rectangle_2_archetype& obj2) { return true; } #endif struct Cartesian_coordinate_const_iterator_2_archetype { Cartesian_coordinate_const_iterator_2_archetype() { } Cartesian_coordinate_const_iterator_2_archetype& operator=(const Cartesian_coordinate_const_iterator_2_archetype&) { return *this; } }; CGAL_END_NAMESPACE #undef CGAL_concept_archetype_constructors #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/distance_predicates_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/distance_predicates_2.0000644000175000017500000000237511344301500031246 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/distance_predicates_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_DISTANCE_PREDICATES_2_H #define CGAL_DISTANCE_PREDICATES_2_H // Kept for backward compatibility only. #endif // CGAL_DISTANCE_PREDICATES_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Plane_3.h0000644000175000017500000000557011344301500026461 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Plane_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_PLANE_3_H #define CGAL_PLANE_3_H CGAL_BEGIN_NAMESPACE template class Plane_3 : public R_::Kernel_base::Plane_3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Kernel_base::Plane_3 RPlane_3; public: typedef R_ R; Plane_3() {} Plane_3(const RPlane_3& p) : RPlane_3(p) {} Plane_3(const Point_3& p, const Point_3& q, const Point_3& r) : RPlane_3(p,q,r) {} Plane_3(const Point_3& p, const Direction_3& d) : RPlane_3(p,d) {} Plane_3(const Point_3& p, const Vector_3& v) : RPlane_3(p,v) {} Plane_3(const RT& a, const RT& b, const RT& c, const RT& d) : RPlane_3(a,b,c,d) {} Plane_3(const Line_3& l, const Point_3& p) : RPlane_3(l,p) {} Plane_3(const Segment_3& s, const Point_3& p) : RPlane_3(s,p) {} Plane_3(const Ray_3& r, const Point_3& p) : RPlane_3(r,p) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_PLANE_3 template < class R > std::ostream& operator<<(std::ostream& os, const Plane_3& p) { typedef typename R::Kernel_base::Plane_3 RPlane_3; return os << static_cast(p); } #endif // CGAL_NO_OSTREAM_INSERT_PLANE_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_PLANE_3 template < class R > std::istream& operator>>(std::istream& is, Plane_3& t) { typedef typename R::Kernel_base::Plane_3 RPlane_3; return is >> static_cast(t); } #endif // CGAL_NO_ISTREAM_EXTRACT_PLANE_3 CGAL_END_NAMESPACE #endif // CGAL_PLANE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_project.h0000644000175000017500000000763311344301500031037 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_project.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_CIRCULATOR_PROJECT_H #define CGAL_CIRCULATOR_PROJECT_H 1 #include CGAL_BEGIN_NAMESPACE template < class C, class Fct, class Ref = typename C::reference, class Ptr = typename C::pointer> class Circulator_project { protected: C nt; // The internal circulator. public: typedef C Circulator; typedef Circulator_project Self; typedef typename C::iterator_category iterator_category; typedef typename Fct::result_type value_type; typedef typename C::difference_type difference_type; typedef typename C::size_type size_type; typedef Ref reference; typedef Ptr pointer; // CREATION // -------- Circulator_project() {} Circulator_project( Circulator j) : nt(j) {} // OPERATIONS Forward Category // --------------------------- Circulator current_circulator() const { return nt;} Ptr ptr() const { Fct fct; return &(fct(*nt)); } bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == 0); return ( nt == 0); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } Ref operator*() const { return *ptr(); } Ptr operator->() const { return ptr(); } Self& operator++() { ++nt; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self min_circulator() const { return Self( nt.min_circulator()); } Self& operator+=( difference_type n) { nt += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; } Ref operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } }; template < class Dist, class Fct, class C, class Ref, class Ptr> inline Circulator_project operator+( Dist n, Circulator_project i) { return i += n; } CGAL_END_NAMESPACE #endif // CGAL_CIRCULATOR_PROJECT_H // // EOF // ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_0000644000175000017500000000311211344301501031134 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_TRIANGLE_2_TRIANGLE_2_INTERSECTION_H #define CGAL_TRIANGLE_2_TRIANGLE_2_INTERSECTION_H #include #include CGAL_BEGIN_NAMESPACE template inline Object intersection(const Triangle_2 &tr1, const Triangle_2& tr2) { typedef typename K::Intersect_2 Intersect; return Intersect()(tr1, tr2); } CGAL_END_NAMESPACE #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Direction_2.h0000644000175000017500000000513011344301500027331 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Direction_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_DIRECTION_2_H #define CGAL_DIRECTION_2_H CGAL_BEGIN_NAMESPACE template class Direction_2 : public R_::Kernel_base::Direction_2 { typedef typename R_::RT RT; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Kernel_base::Direction_2 RDirection_2; public: typedef R_ R; Direction_2() {} Direction_2(const RDirection_2& d) : RDirection_2(d) {} Direction_2(const Vector_2& v) : RDirection_2(v) {} Direction_2(const Line_2& l) : RDirection_2(l) {} Direction_2(const Ray_2& r) : RDirection_2(r) {} Direction_2(const Segment_2& s) : RDirection_2(s) {} Direction_2(const RT &x, const RT &y) : RDirection_2(x,y) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_DIRECTION_2 template < class R > std::ostream & operator<<(std::ostream &os, const Direction_2 &d) { typedef typename R::Kernel_base::Direction_2 RDirection_2; return os << static_cast(d); } #endif // CGAL_NO_OSTREAM_INSERT_DIRECTION_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_DIRECTION_2 template < class R > std::istream & operator>>(std::istream &is, Direction_2 &p) { typedef typename R::Kernel_base::Direction_2 RDirection_2; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_DIRECTION_2 CGAL_END_NAMESPACE #endif // CGAL_DIRECTION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_3.h0000644000175000017500000017607211344301500027553 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_POLYHEDRON_3_H #define CGAL_POLYHEDRON_3_H 1 #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif // CGAL_REP_CLASS_DEFINED CGAL_BEGIN_NAMESPACE template class I_Polyhedron_vertex : public VertexBase { public: typedef VertexBase Base; //typedef typename Base::HalfedgeDS HDS; typedef typename Base::Point Point; typedef Point Point_3; // Handles have to explicitly repeated, although they are derived typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Face_handle Facet_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Face_const_handle Facet_const_handle; typedef typename Base::Halfedge Halfedge; typedef typename Base::Face Face; typedef typename Base::Face Facet; // Supported options by HDS. typedef typename Base::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename Base::Supports_vertex_point Supports_vertex_point; // Circulator category. typedef typename Halfedge::Supports_halfedge_prev Supports_prev; public: // Circulator category. typedef HalfedgeDS_circulator_traits Ctr; typedef typename Ctr::iterator_category circulator_category; // Circulators around a vertex and around a facet. typedef I_HalfedgeDS_facet_circ< Halfedge_handle, circulator_category> Halfedge_around_facet_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_handle, circulator_category> Halfedge_around_vertex_circulator; typedef I_HalfedgeDS_facet_circ< Halfedge_const_handle, circulator_category> Halfedge_around_facet_const_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_const_handle, circulator_category> Halfedge_around_vertex_const_circulator; typedef typename Halfedge_around_vertex_circulator::size_type size_type; typedef typename Halfedge_around_vertex_circulator::difference_type difference_type; public: // We need to repeat the constructors here. I_Polyhedron_vertex() {} I_Polyhedron_vertex( const VertexBase& b) : VertexBase(b) {} I_Polyhedron_vertex( const Point_3& p) : VertexBase(p) {} // New Access Functions (not provided in VertexBase). Halfedge_around_vertex_circulator vertex_begin() { // a circulator of halfedges around the vertex (clockwise). return Halfedge_around_vertex_circulator( this->halfedge()); } Halfedge_around_vertex_const_circulator vertex_begin() const { // a circulator of halfedges around the vertex (clockwise). return Halfedge_around_vertex_const_circulator( this->halfedge()); } // the degree of the vertex, i.e., edges emanating from this vertex std::size_t vertex_degree() const { return this->halfedge()->vertex_degree(); } size_type degree() const { return vertex_degree(); } //backwards compatible // returns true if the vertex has exactly two incident edges bool is_bivalent() const { return this->halfedge()->is_bivalent(); } // returns true if the vertex has exactly three incident edges bool is_trivalent() const { return this->halfedge()->is_trivalent(); } // No longer hidden. Now the restricted version with precondition. // sets incident halfedge to h. Precondition: h is incident, i.e., // h->vertex() == v. void set_halfedge( Halfedge_handle hh) { CGAL_assertion( &*(hh->vertex()) == this); Base::set_halfedge(hh); } }; // A halfedge is an oriented edge. Both orientations exist, i.e. // an edge is represented by two opposite halfedges. The geometric // relations are as follows: // // _ _ _ . // / |\. // | \. // / \ next half // \ edge // / \. // // | O incident vertex // facet , // | /| | // / | | opposite // \ | | half edge // half | | // \ edge | | / // | |/ // \_ _ _ _ _ _ ' // template class I_Polyhedron_halfedge : public HalfedgeBase { public: typedef HalfedgeBase Base; typedef typename Base::HalfedgeDS HDS; // Handles have to explicitly repeated, although they are derived typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Face_handle Facet_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Face_const_handle Facet_const_handle; typedef typename Base::Vertex Vertex; typedef typename Base::Face Face; typedef typename Base::Face Facet; // Supported options by HDS. typedef typename Base::Supports_halfedge_prev Supports_halfedge_prev; typedef typename Base::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename Base::Supports_halfedge_face Supports_halfedge_face; // Circulator category. typedef typename Base::Supports_halfedge_prev Supports_prev; public: // Circulator category. typedef HalfedgeDS_circulator_traits Ctr; typedef typename Ctr::iterator_category circulator_category; // Circulators around a vertex and around a facet. typedef I_HalfedgeDS_facet_circ< Halfedge_handle, circulator_category> Halfedge_around_facet_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_handle, circulator_category> Halfedge_around_vertex_circulator; typedef I_HalfedgeDS_facet_circ< Halfedge_const_handle, circulator_category> Halfedge_around_facet_const_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_const_handle, circulator_category> Halfedge_around_vertex_const_circulator; public: I_Polyhedron_halfedge() {} I_Polyhedron_halfedge( const HalfedgeBase& b) : HalfedgeBase(b) {} // New Access Functions (not provided in HalfedgeBase). // Change semantic of prev: it is always available at this level. // If the HDS does not provide a prev-function, the previous // halfedge will be searched around the incident facet. private: Halfedge_handle find_prev( Halfedge_handle, Tag_true) { return Base::prev(); } Halfedge_const_handle find_prev( Halfedge_const_handle, Tag_true) const { return Base::prev(); } Halfedge_handle find_prev( Halfedge_handle h, Tag_false) const { CGAL_precondition( &*h != this); // we have at least 2-gons while ( &*(h->next()) != this) h = h->next(); return h; } Halfedge_const_handle find_prev( Halfedge_const_handle h, Tag_false) const{ CGAL_precondition( &*h != this); // we have at least 2-gons while ( &*(h->next()) != this) h = h->next(); return h; } public: Halfedge_handle prev() { return find_prev( this->next(), Supports_halfedge_prev()); } Halfedge_const_handle prev() const { return find_prev( this->next(), Supports_halfedge_prev()); } // Make face-functions also available as facet-functions. Face_handle facet() { return this->face();} Face_const_handle facet() const { return this->face();} // the next halfedge around the vertex (clockwise). This is equal to // `h.next()->opposite()'. Halfedge_handle next_on_vertex() { return this->next()->opposite(); } Halfedge_const_handle next_on_vertex() const { return this->next()->opposite(); } // the previous halfedge around the vertex (counterclockwise). Is // equal to `h.opposite()->prev()'. Halfedge_handle prev_on_vertex() { return this->opposite()->prev(); } Halfedge_const_handle prev_on_vertex() const { return this->opposite()->prev(); } bool is_border_edge() const { // is true if `h' or `h.opposite()' is a border halfedge. return (this->opposite()->is_border() || this->is_border()); } // a circulator of halfedges around the vertex (clockwise). Halfedge_around_vertex_circulator vertex_begin() { return Halfedge_around_vertex_circulator( HDS::halfedge_handle(this)); } Halfedge_around_vertex_const_circulator vertex_begin() const { return Halfedge_around_vertex_const_circulator( HDS::halfedge_handle(this)); } // a circulator of halfedges around the facet (counterclockwise). Halfedge_around_facet_circulator facet_begin() { return Halfedge_around_facet_circulator( HDS::halfedge_handle(this)); } Halfedge_around_facet_const_circulator facet_begin() const { return Halfedge_around_facet_const_circulator( HDS::halfedge_handle(this)); } // the degree of the incident vertex, i.e., edges emanating from this // vertex std::size_t vertex_degree() const { return circulator_size( vertex_begin()); } // the degree of the incident facet, i.e., edges on the boundary of this // facet std::size_t facet_degree() const { return circulator_size( facet_begin()); } // returns true if the incident vertex has exactly two incident edges bool is_bivalent() const { CGAL_precondition( this != &* (this->next()->opposite())); return (this == &* (this->next()->opposite()->next()->opposite())); } // returns true if the incident vertex has exactly three incident edges bool is_trivalent() const { CGAL_precondition( this != &* (this->next()->opposite())); return ( this != &* (this->next()->opposite()->next()->opposite()) && this == &* (this->next()->opposite()->next()->opposite() ->next()->opposite())); } // returns true if the incident facet is a triangle. bool is_triangle() const { CGAL_precondition( this != &* (this->next())); CGAL_precondition( this != &* (this->next()->next())); return (this == &* (this->next()->next()->next())); } // returns true if the incident facet is a quadrilateral. bool is_quad() const { CGAL_precondition( this != &* (this->next())); CGAL_precondition( this != &* (this->next()->next())); return (this == &* (this->next()->next()->next()->next())); } private: // Hide some other functions of H. void set_next( Halfedge_handle hh) { Base::set_next(hh);} void set_prev( Halfedge_handle hh) { Base::set_prev(hh);} void set_vertex( Vertex_handle vv) { Base::set_vertex(vv);} void set_face( Face_handle ff) { Base::set_face(ff);} void set_facet( Face_handle ff) { set_face(ff);} }; template class I_Polyhedron_facet : public FacetBase { public: typedef FacetBase Base; //typedef typename Base::HalfedgeDS HDS; typedef typename Base::Plane Plane; typedef Plane Plane_3; // Handles have to explicitly repeated, although they are derived typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Halfedge_handle Halfedge_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Face_handle Facet_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Face_const_handle Face_const_handle; typedef typename Base::Face_const_handle Facet_const_handle; typedef typename Base::Vertex Vertex; typedef typename Base::Halfedge Halfedge; // Supported options by HDS. typedef typename Base::Supports_face_halfedge Supports_face_halfedge; typedef typename Base::Supports_face_plane Supports_face_plane; // No longer required. typedef Tag_false Supports_face_normal; // Circulator category. typedef typename Halfedge::Supports_halfedge_prev Supports_prev; public: // Circulator category. typedef HalfedgeDS_circulator_traits Ctr; typedef typename Ctr::iterator_category circulator_category; // Circulators around a vertex and around a facet. typedef I_HalfedgeDS_facet_circ< Halfedge_handle, circulator_category> Halfedge_around_facet_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_handle, circulator_category> Halfedge_around_vertex_circulator; typedef I_HalfedgeDS_facet_circ< Halfedge_const_handle, circulator_category> Halfedge_around_facet_const_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_const_handle, circulator_category> Halfedge_around_vertex_const_circulator; typedef typename Halfedge_around_vertex_circulator::size_type size_type; typedef typename Halfedge_around_vertex_circulator::difference_type difference_type; public: // We need to repeat the constructors here. I_Polyhedron_facet() {} I_Polyhedron_facet( const FacetBase& b) : FacetBase(b) {} // New Access Functions (not provided in FacetBase). Halfedge_around_facet_circulator facet_begin() { // a circulator of halfedges around the facet (counterclockwise). return Halfedge_around_facet_circulator( this->halfedge()); } Halfedge_around_facet_const_circulator facet_begin() const { // a circulator of halfedges around the facet (counterclockwise). return Halfedge_around_facet_const_circulator( this->halfedge()); } // the degree of the incident facet, i.e., edges on the boundary of this // facet std::size_t facet_degree() const {return this->halfedge()->facet_degree();} size_type size() const { return facet_degree(); } // backwards compatible // returns true if the facet is a triangle. bool is_triangle() const { return this->halfedge()->is_triangle(); } // returns true if the facet is a quadrilateral. bool is_quad() const { return this->halfedge()->is_quad(); } // No longer hidden. Now the restricted version with precondition. // sets incident halfedge to h. Precondition: h is incident, i.e., // h->face() == v. void set_halfedge( Halfedge_handle hh) { CGAL_assertion( &*(hh->facet()) == this); Base::set_halfedge(hh); } }; template < class Items> class I_Polyhedron_derived_items_3 { public: template < class Refs, class Traits> class Vertex_wrapper { public: typedef typename Items::template Vertex_wrapper VWrap; typedef typename VWrap::Vertex Vertex_base; typedef I_Polyhedron_vertex< Vertex_base> Vertex; }; template < class Refs, class Traits> class Halfedge_wrapper { public: typedef typename Items::template Halfedge_wrapper HWrap; typedef typename HWrap::Halfedge Halfedge_base; typedef I_Polyhedron_halfedge< Halfedge_base> Halfedge; }; template < class Refs, class Traits> class Face_wrapper { public: typedef typename Items::template Face_wrapper FWrap; typedef typename FWrap::Face Face_base; typedef I_Polyhedron_facet< Face_base> Face; }; }; template < class PolyhedronTraits_3, class PolyhedronItems_3 = Polyhedron_items_3, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class T_HDS = HalfedgeDS_default, class Alloc = CGAL_ALLOCATOR(int)> class Polyhedron_3 { // // DEFINITION // // The boundary representation of a 3d-polyhedron P of the type // Polyhedron consists of vertices, edges and facets. The // vertices are points in space. The edges are straight line // segments. The facets are planar polygons. We restrict here // the facets to be simple planar polygons without holes and the // boundary of the polyhedron to be an oriented 2-manifold. Thus // facets are consistently oriented and an edge is incident to // exactly two facets. We restrict the representation further // that an edge has two distinct incident endpoints and // following duality that an edge has two distinct incident // facets. The class Polyhedron is able to guarantee // the combinatorial properties, but not all geometric // properties. Support functions are provided for testing // geometric properties, e.g. test for self intersections which // is too expensive to be guaranteed as a class invariant. public: typedef Polyhedron_3< PolyhedronTraits_3, PolyhedronItems_3, T_HDS, Alloc> Self; typedef PolyhedronTraits_3 Traits; typedef PolyhedronItems_3 Items; typedef I_Polyhedron_derived_items_3 Derived_items; #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM typedef T_HDS< Traits, Derived_items, Alloc> HDS; #else typedef typename T_HDS::template HDS< Traits, Derived_items, Alloc> HDS; #endif typedef HDS HalfedgeDS; // portability with older CGAL release typedef HDS Halfedge_data_structure; typedef Alloc Allocator; typedef Alloc allocator_type; // STL name // Container stuff. typedef typename HDS::size_type size_type; typedef typename HDS::difference_type difference_type; typedef typename HDS::iterator_category iterator_category; typedef typename HDS::Supports_removal Supports_removal; // Geometry typedef typename Traits::Point_3 Point_3; typedef typename Traits::Plane_3 Plane_3; // No longer required. //typedef typename Traits::Normal Normal; // Items typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Face::Base FBase; // Handles and Iterators typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Face_iterator Face_iterator; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face_const_iterator Face_const_iterator; // Auxiliary iterators for convenience typedef Project_point Proj_point; typedef Iterator_project Point_iterator; typedef Iterator_project Point_const_iterator; typedef Project_plane Proj_plane; typedef Iterator_project Plane_iterator; typedef Iterator_project Plane_const_iterator; typedef N_step_adaptor_derived Edge_iterator; typedef N_step_adaptor_derived Edge_const_iterator; // All face related types get a related facet type name. typedef Face Facet; typedef Face_handle Facet_handle; typedef Face_iterator Facet_iterator; typedef Face_const_handle Facet_const_handle; typedef Face_const_iterator Facet_const_iterator; // Supported options by HDS. typedef typename VBase::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename HBase::Supports_halfedge_prev Supports_halfedge_prev; typedef typename HBase::Supports_halfedge_prev Supports_prev; typedef typename HBase::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename HBase::Supports_halfedge_face Supports_halfedge_face; typedef typename FBase::Supports_face_halfedge Supports_face_halfedge; // Supported options especially for Polyhedron_3. typedef typename VBase::Supports_vertex_point Supports_vertex_point; typedef typename FBase::Supports_face_plane Supports_face_plane; // No longer required. typedef Tag_false Supports_face_normal; // Renamed versions for facet typedef Supports_halfedge_face Supports_halfedge_facet; typedef Supports_face_halfedge Supports_facet_halfedge; typedef Supports_face_plane Supports_facet_plane; // No longer required. typedef Supports_face_normal Supports_facet_normal; public: // Circulator category. typedef HalfedgeDS_circulator_traits Ctr; typedef typename Ctr::iterator_category circulator_category; // Circulators around a vertex and around a facet. typedef I_HalfedgeDS_facet_circ< Halfedge_handle, circulator_category> Halfedge_around_facet_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_handle, circulator_category> Halfedge_around_vertex_circulator; typedef I_HalfedgeDS_facet_circ< Halfedge_const_handle, circulator_category> Halfedge_around_facet_const_circulator; typedef I_HalfedgeDS_vertex_circ< Halfedge_const_handle, circulator_category> Halfedge_around_vertex_const_circulator; protected: HDS hds; // the boundary representation. Traits m_traits; // CREATION public: Polyhedron_3( const Traits& trts = Traits()) : m_traits(trts) {} // the empty polyhedron `P'. Polyhedron_3( size_type v, size_type h, size_type f, const Traits& traits = Traits()) : hds(v,h,f), m_traits(traits) {} // a polyhedron `P' with storage reserved for v vertices, h // halfedges, and f facets. The reservation sizes are a hint for // optimizing storage allocation. void reserve( size_type v, size_type h, size_type f) { // reserve storage for v vertices, h halfedges, and f facets. The // reservation sizes are a hint for optimizing storage allocation. // If the `capacity' is already greater than the requested size // nothing happens. If the `capacity' changes all iterators and // circulators invalidates. hds.reserve(v,h,f); } protected: Halfedge_handle make_triangle( Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) { HalfedgeDS_decorator decorator(hds); Halfedge_handle h = hds.edges_push_back( Halfedge(), Halfedge()); h->HBase::set_next( hds.edges_push_back( Halfedge(), Halfedge())); h->next()->HBase::set_next( hds.edges_push_back( Halfedge(), Halfedge())); h->next()->next()->HBase::set_next( h); decorator.set_prev( h, h->next()->next()); decorator.set_prev( h->next(), h); decorator.set_prev( h->next()->next(), h->next()); h->opposite()->HBase::set_next( h->next()->next()->opposite()); h->next()->opposite()->HBase::set_next( h->opposite()); h->next()->next()->opposite()->HBase::set_next( h->next()->opposite()); decorator.set_prev( h->opposite(), h->next()->opposite()); decorator.set_prev( h->next()->opposite(), h->next()->next()->opposite()); decorator.set_prev( h->next()->next()->opposite(), h->opposite()); // the vertices decorator.set_vertex( h, v1); decorator.set_vertex( h->next(), v2); decorator.set_vertex( h->next()->next(), v3); decorator.set_vertex( h->opposite(), v3); decorator.set_vertex( h->next()->opposite(), v1); decorator.set_vertex( h->next()->next()->opposite(), v2); decorator.set_vertex_halfedge( h); decorator.set_vertex_halfedge( h->next()); decorator.set_vertex_halfedge( h->next()->next()); // the facet Facet_handle f = decorator.faces_push_back( Facet()); decorator.set_face( h, f); decorator.set_face( h->next(), f); decorator.set_face( h->next()->next(), f); decorator.set_face_halfedge( h); return h; } Halfedge_handle make_tetrahedron( Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Vertex_handle v4) { HalfedgeDS_decorator decorator(hds); Halfedge_handle h = make_triangle(v1,v2,v3); // The remaining tip. Halfedge_handle g = hds.edges_push_back( Halfedge(), Halfedge()); decorator.insert_tip( g->opposite(), h->opposite()); decorator.close_tip( g); decorator.set_vertex( g, v4); Halfedge_handle e = hds.edges_push_back( Halfedge(), Halfedge()); Halfedge_handle d = hds.edges_push_back( Halfedge(), Halfedge()); decorator.insert_tip( e->opposite(), h->next()->opposite()); decorator.insert_tip( e, g); decorator.insert_tip( d->opposite(),h->next()->next()->opposite()); decorator.insert_tip( d, e); decorator.set_vertex_halfedge( g); // facets Facet_handle f = decorator.faces_push_back( Facet()); decorator.set_face( h->opposite(), f); decorator.set_face( g, f); decorator.set_face( e->opposite(), f); decorator.set_face_halfedge( g); f = decorator.faces_push_back( Facet()); decorator.set_face( h->next()->opposite(), f); decorator.set_face( e, f); decorator.set_face( d->opposite(), f); decorator.set_face_halfedge( e); f = decorator.faces_push_back( Facet()); decorator.set_face( h->next()->next()->opposite(), f); decorator.set_face( d, f); decorator.set_face( g->opposite(), f); decorator.set_face_halfedge( d); return h; } public: Halfedge_handle make_tetrahedron() { // the combinatorial structure of a tetrahedron is added to the // actual polyhedral surface. Returns an arbitrary halfedge of // this structure. reserve( 4 + size_of_vertices(), 12 + size_of_halfedges(), 4 + size_of_facets()); HalfedgeDS_decorator decorator(hds); return make_tetrahedron( decorator.vertices_push_back( Vertex()), decorator.vertices_push_back( Vertex()), decorator.vertices_push_back( Vertex()), decorator.vertices_push_back( Vertex())); } Halfedge_handle make_tetrahedron( const Point_3& p1, const Point_3& p2, const Point_3& p3, const Point_3& p4) { reserve( 4 + size_of_vertices(), 12 + size_of_halfedges(), 4 + size_of_facets()); HalfedgeDS_decorator decorator(hds); return make_tetrahedron( decorator.vertices_push_back( Vertex(p1)), decorator.vertices_push_back( Vertex(p2)), decorator.vertices_push_back( Vertex(p3)), decorator.vertices_push_back( Vertex(p4))); } Halfedge_handle make_triangle() { // the combinatorial structure of a single triangle with border // edges is added to the actual polyhedral surface. Returns an // arbitrary halfedge of this structure. reserve( 3 + size_of_vertices(), 6 + size_of_halfedges(), 1 + size_of_facets()); HalfedgeDS_decorator decorator(hds); return make_triangle( decorator.vertices_push_back( Vertex()), decorator.vertices_push_back( Vertex()), decorator.vertices_push_back( Vertex())); } Halfedge_handle make_triangle( const Point_3& p1, const Point_3& p2, const Point_3& p3) { // the single triangle p_1, p_2, p_3 with border edges is added to // the actual polyhedral surface. Returns an arbitrary halfedge of // this structure. reserve( 3 + size_of_vertices(), 6 + size_of_halfedges(), 1 + size_of_facets()); HalfedgeDS_decorator decorator(hds); return make_triangle( decorator.vertices_push_back( Vertex(p1)), decorator.vertices_push_back( Vertex(p2)), decorator.vertices_push_back( Vertex(p3))); } // Access Member Functions allocator_type get_allocator() const { return hds.get_allocator(); } size_type size_of_vertices() const { return hds.size_of_vertices();} // number of vertices. size_type size_of_halfedges() const { return hds.size_of_halfedges();} // number of all halfedges (including border halfedges). size_type size_of_facets() const { return hds.size_of_faces();} // number of facets. bool empty() const { return size_of_halfedges() == 0; } size_type capacity_of_vertices() const { // space reserved for vertices. return hds.capacity_of_vertices(); } size_type capacity_of_halfedges() const { // space reserved for halfedges. return hds.capacity_of_halfedges(); } size_type capacity_of_facets() const { // space reserved for facets. return hds.capacity_of_faces(); } std::size_t bytes() const { // bytes used for the polyhedron. return sizeof(Self) - sizeof(HDS) + hds.bytes(); } std::size_t bytes_reserved() const { // bytes reserved for the polyhedron. return sizeof(Self) - sizeof(HDS) + hds.bytes_reserved(); } Vertex_iterator vertices_begin() { return hds.vertices_begin();} // iterator over all vertices. Vertex_iterator vertices_end() { return hds.vertices_end();} Halfedge_iterator halfedges_begin() { return hds.halfedges_begin();} // iterator over all halfedges Halfedge_iterator halfedges_end() { return hds.halfedges_end();} Facet_iterator facets_begin() { return hds.faces_begin();} // iterator over all facets Facet_iterator facets_end() { return hds.faces_end();} // The constant iterators and circulators. Vertex_const_iterator vertices_begin() const { return hds.vertices_begin(); } Vertex_const_iterator vertices_end() const { return hds.vertices_end(); } Halfedge_const_iterator halfedges_begin() const { return hds.halfedges_begin(); } Halfedge_const_iterator halfedges_end() const { return hds.halfedges_end(); } Facet_const_iterator facets_begin() const { return hds.faces_begin();} Facet_const_iterator facets_end() const { return hds.faces_end();} // Auxiliary iterators for convinience Point_iterator points_begin() { return vertices_begin();} Point_iterator points_end() { return vertices_end();} Point_const_iterator points_begin() const { return vertices_begin();} Point_const_iterator points_end() const { return vertices_end();} Plane_iterator planes_begin() { return facets_begin();} Plane_iterator planes_end() { return facets_end();} Plane_const_iterator planes_begin() const { return facets_begin();} Plane_const_iterator planes_end() const { return facets_end();} Edge_iterator edges_begin() { return halfedges_begin();} // iterator over all edges. The iterator refers to halfedges, but // enumerates only one of the two corresponding opposite // halfedges. Edge_iterator edges_end() { return halfedges_end();} // end of the range over all edges. Edge_const_iterator edges_begin() const { return halfedges_begin();} Edge_const_iterator edges_end() const { return halfedges_end();} Traits& traits() { return m_traits; } const Traits& traits() const { return m_traits; } // Combinatorial Predicates bool is_closed() const { for ( Halfedge_const_iterator i = halfedges_begin(); i != halfedges_end(); ++i) { if ( i->is_border()) return false; } return true; } private: bool is_pure_bivalent( Tag_true) const { for ( Vertex_const_iterator i = vertices_begin(); i != vertices_end(); ++i) if ( ! i->is_bivalent()) return false; return true; } bool is_pure_bivalent( Tag_false) const { for ( Halfedge_const_iterator i = halfedges_begin(); i != halfedges_end(); ++i) if ( ! i->is_bivalent()) return false; return true; } public: // returns true if all vertices have exactly two incident edges bool is_pure_bivalent() const { return is_pure_bivalent( Supports_vertex_halfedge()); } private: bool is_pure_trivalent( Tag_true) const { for ( Vertex_const_iterator i = vertices_begin(); i != vertices_end(); ++i) if ( ! i->is_trivalent()) return false; return true; } bool is_pure_trivalent( Tag_false) const { for ( Halfedge_const_iterator i = halfedges_begin(); i != halfedges_end(); ++i) if ( ! i->is_trivalent()) return false; return true; } public: // returns true if all vertices have exactly three incident edges bool is_pure_trivalent() const { return is_pure_trivalent( Supports_vertex_halfedge()); } private: bool is_pure_triangle( Tag_true) const { for ( Facet_const_iterator i = facets_begin(); i != facets_end(); ++i) if ( ! i->is_triangle()) return false; return true; } bool is_pure_triangle( Tag_false) const { for ( Halfedge_const_iterator i = halfedges_begin(); i != halfedges_end(); ++i) if ( ! i->is_border() && ! i->is_triangle()) return false; return true; } public: // returns true if all facets are triangles bool is_pure_triangle() const { return is_pure_triangle( Supports_facet_halfedge()); } private: bool is_pure_quad( Tag_true) const { for ( Facet_const_iterator i = facets_begin(); i != facets_end(); ++i) if ( ! i->is_quad()) return false; return true; } bool is_pure_quad( Tag_false) const { for ( Halfedge_const_iterator i = halfedges_begin(); i != halfedges_end(); ++i) if ( ! i->is_border() && ! i->is_quad()) return false; return true; } public: // returns true if all facets are quadrilaterals bool is_pure_quad() const { return is_pure_quad( Supports_facet_halfedge()); } // Geometric Predicates bool is_triangle( Halfedge_const_handle h1) const { Halfedge_const_handle h2 = h1->next(); Halfedge_const_handle h3 = h1->next()->next(); // check halfedge combinatorics. // exact two edges at vertices 1, 2, 3. if ( h1->opposite()->next() != h3->opposite()) return false; if ( h2->opposite()->next() != h1->opposite()) return false; if ( h3->opposite()->next() != h2->opposite()) return false; // The facet is a triangle. if ( h1->next()->next()->next() != h1) return false; if ( check_tag( Supports_halfedge_face()) && ! h1->is_border_edge()) return false; // implies h2 and h3 CGAL_assertion( ! h1->is_border() || ! h1->opposite()->is_border()); // Assert consistency. CGAL_assertion( h1 != h2); CGAL_assertion( h1 != h3); CGAL_assertion( h3 != h2); // check prev pointer. CGAL_assertion_code( HalfedgeDS_items_decorator D;) CGAL_assertion(D.get_prev(h1) == Halfedge_handle() || D.get_prev(h1) == h3); CGAL_assertion(D.get_prev(h2) == Halfedge_handle() || D.get_prev(h2) == h1); CGAL_assertion(D.get_prev(h3) == Halfedge_handle() || D.get_prev(h3) == h2); // check vertices. CGAL_assertion( D.get_vertex(h1) == D.get_vertex( h2->opposite())); CGAL_assertion( D.get_vertex(h2) == D.get_vertex( h3->opposite())); CGAL_assertion( D.get_vertex(h3) == D.get_vertex( h1->opposite())); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h1) != D.get_vertex(h2)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h1) != D.get_vertex(h3)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h2) != D.get_vertex(h3)); // check facets. CGAL_assertion( D.get_face(h1) == D.get_face(h2)); CGAL_assertion( D.get_face(h1) == D.get_face(h3)); return true; } bool is_tetrahedron( Halfedge_const_handle h1) const { Halfedge_const_handle h2 = h1->next(); Halfedge_const_handle h3 = h1->next()->next(); Halfedge_const_handle h4 = h1->opposite()->next(); Halfedge_const_handle h5 = h2->opposite()->next(); Halfedge_const_handle h6 = h3->opposite()->next(); // check halfedge combinatorics. // at least three edges at vertices 1, 2, 3. if ( h4 == h3->opposite()) return false; if ( h5 == h1->opposite()) return false; if ( h6 == h2->opposite()) return false; // exact three edges at vertices 1, 2, 3. if ( h4->opposite()->next() != h3->opposite()) return false; if ( h5->opposite()->next() != h1->opposite()) return false; if ( h6->opposite()->next() != h2->opposite()) return false; // three edges at v4. if ( h4->next()->opposite() != h5) return false; if ( h5->next()->opposite() != h6) return false; if ( h6->next()->opposite() != h4) return false; // All facets are triangles. if ( h1->next()->next()->next() != h1) return false; if ( h4->next()->next()->next() != h4) return false; if ( h5->next()->next()->next() != h5) return false; if ( h6->next()->next()->next() != h6) return false; // all edges are non-border edges. if ( h1->is_border()) return false; // implies h2 and h3 CGAL_assertion( ! h2->is_border()); CGAL_assertion( ! h3->is_border()); if ( h4->is_border()) return false; if ( h5->is_border()) return false; if ( h6->is_border()) return false; // Assert consistency. CGAL_assertion( h1 != h2); CGAL_assertion( h1 != h3); CGAL_assertion( h3 != h2); CGAL_assertion( h4 != h5); CGAL_assertion( h5 != h6); CGAL_assertion( h6 != h4); // check prev pointer. CGAL_assertion_code( HalfedgeDS_items_decorator D;) CGAL_assertion(D.get_prev(h1) == Halfedge_handle() || D.get_prev(h1) == h3); CGAL_assertion(D.get_prev(h2) == Halfedge_handle() || D.get_prev(h2) == h1); CGAL_assertion(D.get_prev(h3) == Halfedge_handle() || D.get_prev(h3) == h2); CGAL_assertion(D.get_prev(h4) == Halfedge_handle() || D.get_prev(h4) == h1->opposite()); CGAL_assertion(D.get_prev(h5) == Halfedge_handle() || D.get_prev(h5) == h2->opposite()); CGAL_assertion(D.get_prev(h6) == Halfedge_handle() || D.get_prev(h6) == h3->opposite()); // check vertices. CGAL_assertion( D.get_vertex(h1) == D.get_vertex( h2->opposite())); CGAL_assertion( D.get_vertex(h1) == D.get_vertex( h5->opposite())); CGAL_assertion( D.get_vertex(h2) == D.get_vertex( h3->opposite())); CGAL_assertion( D.get_vertex(h2) == D.get_vertex( h6->opposite())); CGAL_assertion( D.get_vertex(h3) == D.get_vertex( h1->opposite())); CGAL_assertion( D.get_vertex(h3) == D.get_vertex( h4->opposite())); CGAL_assertion( D.get_vertex(h4) == D.get_vertex( h5)); CGAL_assertion( D.get_vertex(h4) == D.get_vertex( h6)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h1) != D.get_vertex(h2)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h1) != D.get_vertex(h3)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h1) != D.get_vertex(h4)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h2) != D.get_vertex(h3)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h2) != D.get_vertex(h4)); CGAL_assertion( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(h3) != D.get_vertex(h4)); // check facets. CGAL_assertion( D.get_face(h1) == D.get_face(h2)); CGAL_assertion( D.get_face(h1) == D.get_face(h3)); CGAL_assertion( D.get_face(h4) == D.get_face(h4->next())); CGAL_assertion( D.get_face(h4) == D.get_face(h1->opposite())); CGAL_assertion( D.get_face(h5) == D.get_face(h5->next())); CGAL_assertion( D.get_face(h5) == D.get_face(h2->opposite())); CGAL_assertion( D.get_face(h6) == D.get_face(h6->next())); CGAL_assertion( D.get_face(h6) == D.get_face(h3->opposite())); CGAL_assertion( ! check_tag( Supports_halfedge_face()) || D.get_face(h1) != D.get_face(h4)); CGAL_assertion( ! check_tag( Supports_halfedge_face()) || D.get_face(h1) != D.get_face(h5)); CGAL_assertion( ! check_tag( Supports_halfedge_face()) || D.get_face(h1) != D.get_face(h6)); CGAL_assertion( ! check_tag( Supports_halfedge_face()) || D.get_face(h4) != D.get_face(h5)); CGAL_assertion( ! check_tag( Supports_halfedge_face()) || D.get_face(h4) != D.get_face(h6)); CGAL_assertion( ! check_tag( Supports_halfedge_face()) || D.get_face(h5) != D.get_face(h6)); return true; } // Euler Operators (Combinatorial Modifications) // // The following Euler operations modify consistently the combinatorial // structure of the polyhedral surface. The geometry remains unchanged. Halfedge_handle split_facet( Halfedge_handle h, Halfedge_handle g) { // split the facet incident to `h' and `g' into two facets with // new diagonal between the two vertices denoted by `h' and `g' // respectively. The second (new) facet is a copy of the first // facet. It returns the new diagonal. The time is proportional to // the distance from `h' to `g' around the facet. Precondition: // `h' and `g' are incident to the same facet. `h != g' (no // loops). `h->next() != g' and `g->next() != h' (no multi-edges). reserve( size_of_vertices(), 2 + size_of_halfedges(), 1 + size_of_facets()); HalfedgeDS_decorator D(hds); CGAL_precondition( D.get_face(h) == D.get_face(g)); CGAL_precondition( h != g); CGAL_precondition( h != g->next()); CGAL_precondition( h->next() != g); return D.split_face( h, g); } Halfedge_handle join_facet( Halfedge_handle h) { // join the two facets incident to h. The facet incident to // `h->opposite()' gets removed. Both facets might be holes. // Returns the predecessor of h. The invariant `join_facet( // split_facet( h, g))' returns h and keeps the polyhedron // unchanged. The time is proportional to the size of the facet // removed and the time to compute `h.prev()'. Precondition: // `HDS' supports removal of facets. The degree of both // vertices incident to h is at least three (no antennas). HalfedgeDS_decorator D(hds); CGAL_precondition( circulator_size(h->vertex_begin()) >= size_type(3)); CGAL_precondition( circulator_size(h->opposite()->vertex_begin()) >= size_type(3)); return D.join_face(h); } Halfedge_handle split_vertex( Halfedge_handle h, Halfedge_handle g) { // split the vertex incident to `h' and `g' into two vertices and // connects them with a new edge. The second (new) vertex is a // copy of the first vertex. It returns the new edge. The time is // proportional to the distance from `h' to `g' around the vertex. // Precondition: `h' and `g' are incident to the same vertex. `h // != g' (no antennas). `h->next() != g' and `g->next() != h'. reserve( 1 + size_of_vertices(), 2 + size_of_halfedges(), size_of_facets()); HalfedgeDS_decorator D(hds); CGAL_precondition( D.get_vertex(h) == D.get_vertex(g)); CGAL_precondition( h != g); return D.split_vertex( h, g); } Halfedge_handle join_vertex( Halfedge_handle h) { // join the two vertices incident to h. The vertex denoted by // `h->opposite()' gets removed. Returns the predecessor of h. The // invariant `join_vertex( split_vertex( h, g))' returns h and // keeps the polyhedron unchanged. The time is proportional to // the degree of the vertex removed and the time to compute // `h.prev()'. // Precondition: `HDS' supports removal of vertices. The size of // both facets incident to h is at least four (no multi-edges) HalfedgeDS_decorator D(hds); CGAL_precondition( circulator_size( h->facet_begin()) >= size_type(4)); CGAL_precondition( circulator_size( h->opposite()->facet_begin()) >= size_type(4)); return D.join_vertex(h); } Halfedge_handle split_edge( Halfedge_handle h) { return split_vertex( h->prev(), h->opposite())->opposite(); } Halfedge_handle flip_edge( Halfedge_handle h) { HalfedgeDS_items_decorator D; return D.flip_edge(h); } Halfedge_handle create_center_vertex( Halfedge_handle h) { HalfedgeDS_decorator D(hds); CGAL_assertion( circulator_size( h->facet_begin()) >= size_type(3)); return D.create_center_vertex(h); } Halfedge_handle erase_center_vertex( Halfedge_handle h) { HalfedgeDS_decorator D(hds); return D.erase_center_vertex(h); } // Euler Operators Modifying Genus Halfedge_handle split_loop( Halfedge_handle h, Halfedge_handle i, Halfedge_handle j) { // cut the polyhedron into two parts along the cycle (h,i,j). // Three copies of the vertices and two new triangles will be // created. h,i,j will be incident to the first new triangle. The // returnvalue will be an halfedge iterator denoting the new // halfegdes of the second new triangle which was h beforehand. // Precondition: h,i,j are distinct, consecutive vertices of the // polyhedron and form a cycle: i.e. `h->vertex() == i->opposite() // ->vertex()', ..., `j->vertex() == h->opposite()->vertex()'. The // six facets incident to h,i,j are all distinct. reserve( 3 + size_of_vertices(), 6 + size_of_halfedges(), 2 + size_of_facets()); HalfedgeDS_decorator D(hds); CGAL_precondition( h != i); CGAL_precondition( h != j); CGAL_precondition( i != j); CGAL_precondition( D.get_vertex(h) == D.get_vertex(i->opposite())); CGAL_precondition( D.get_vertex(i) == D.get_vertex(j->opposite())); CGAL_precondition( D.get_vertex(j) == D.get_vertex(h->opposite())); CGAL_precondition( D.get_face(h) == Facet_handle() || D.get_face(h) != D.get_face(i)); CGAL_precondition( D.get_face(h) == Facet_handle() || D.get_face(h) != D.get_face(j)); CGAL_precondition( D.get_face(i) == Facet_handle() || D.get_face(i) != D.get_face(j)); CGAL_precondition( D.get_face(h) == Facet_handle() || D.get_face(h) != D.get_face(h->opposite())); CGAL_precondition( D.get_face(h) == Facet_handle() || D.get_face(h) != D.get_face(i->opposite())); CGAL_precondition( D.get_face(h) == Facet_handle() || D.get_face(h) != D.get_face(j->opposite())); CGAL_precondition( D.get_face(i) == Facet_handle() || D.get_face(i) != D.get_face(h->opposite())); CGAL_precondition( D.get_face(i) == Facet_handle() || D.get_face(i) != D.get_face(i->opposite())); CGAL_precondition( D.get_face(i) == Facet_handle() || D.get_face(i) != D.get_face(j->opposite())); CGAL_precondition( D.get_face(j) == Facet_handle() || D.get_face(j) != D.get_face(h->opposite())); CGAL_precondition( D.get_face(j) == Facet_handle() || D.get_face(j) != D.get_face(i->opposite())); CGAL_precondition( D.get_face(j) == Facet_handle() || D.get_face(j) != D.get_face(j->opposite())); CGAL_precondition( D.get_face(h->opposite()) == Facet_handle() || D.get_face(h->opposite()) != D.get_face(i->opposite())); CGAL_precondition( D.get_face(h->opposite()) == Facet_handle() || D.get_face(h->opposite()) != D.get_face(j->opposite())); CGAL_precondition( D.get_face(i->opposite()) == Facet_handle() || D.get_face(i->opposite()) != D.get_face(j->opposite())); return D.split_loop( h, i, j); } Halfedge_handle join_loop( Halfedge_handle h, Halfedge_handle g) { // glues the boundary of two facets together. Both facets and the // vertices of g gets removed. Returns an halfedge iterator for h. // The invariant `join_loop( h, split_loop( h, i, j))' returns h // and keeps the polyhedron unchanged. Precondition: `HDS' // supports removal of vertices and facets. The facets denoted by // h and g have equal size. HalfedgeDS_decorator D(hds); CGAL_precondition( D.get_face(h) == Facet_handle() || D.get_face(h) != D.get_face(g)); CGAL_precondition( circulator_size( h->facet_begin()) >= size_type(3)); CGAL_precondition( circulator_size( h->facet_begin()) == circulator_size( g->facet_begin())); return D.join_loop( h, g); } // Modifying Facets and Holes Halfedge_handle make_hole( Halfedge_handle h) { // removes incident facet and makes all halfedges incident to the // facet to border edges. Returns h. Precondition: `HDS' // supports removal of facets. `! h.is_border()'. HalfedgeDS_decorator D(hds); return D.make_hole(h); } Halfedge_handle fill_hole( Halfedge_handle h) { // fill a hole with a new created facet. Makes all border // halfedges of the hole denoted by h incident to the new facet. // Returns h. Precondition: `h.is_border()'. reserve( size_of_vertices(), size_of_halfedges(), 1 + size_of_facets()); HalfedgeDS_decorator D(hds); return D.fill_hole(h); } Halfedge_handle add_vertex_and_facet_to_border( Halfedge_handle h, Halfedge_handle g) { // creates a new facet within the hole incident to h and g by // connecting the tip of g with the tip of h with two new // halfedges and a new vertex and filling this separated part of // the hole with a new facet. Returns the new halfedge incident to // the new facet and the new vertex. Precondition: `h->is_border( // )', `g->is_border()', `h != g', and g can be reached along the // same hole starting with h. CGAL_precondition( h != g); reserve( 1 + size_of_vertices(), 4 + size_of_halfedges(), 1 + size_of_facets()); HalfedgeDS_decorator D(hds); Halfedge_handle hh = D.add_face_to_border( h, g); CGAL_assertion( hh == g->next()); D.split_vertex( g, hh->opposite()); return g->next(); } Halfedge_handle add_facet_to_border( Halfedge_handle h, Halfedge_handle g) { // creates a new facet within the hole incident to h and g by // connecting the tip of g with the tip of h with a new halfedge // and filling this separated part of the hole with a new facet. // Returns the new halfedge incident to the new facet. // Precondition: `h->is_border()', `g->is_border()', `h != g', // `h->next() != g', and g can be reached along the same hole // starting with h. CGAL_precondition( h != g); CGAL_precondition( h->next() != g); reserve( size_of_vertices(), 2 + size_of_halfedges(), 1 + size_of_facets()); HalfedgeDS_decorator D(hds); return D.add_face_to_border( h, g); } // Erasing void erase_facet( Halfedge_handle h) { // removes the incident facet of h and changes all halfedges // incident to the facet into border edges or removes them from // the polyhedral surface if they were already border edges. See // `make_hole(h)' for a more specialized variant. Precondition: // `Traits' supports removal. HalfedgeDS_decorator D(hds); D.erase_face(h); } void erase_connected_component( Halfedge_handle h) { // removes the vertices, halfedges, and facets that belong to the // connected component of h. Precondition: `Traits' supports // removal. HalfedgeDS_decorator D(hds); D.erase_connected_component(h); } void clear() { hds.clear(); } // removes all vertices, halfedges, and facets. void erase_all() { clear(); } // equivalent to `clear()'. Depricated. // Special Operations on Polyhedral Surfaces void delegate( Modifier_base& modifier) { // calls the `operator()' of the `modifier'. Precondition: The // `modifier' returns a consistent representation. modifier( hds); CGAL_expensive_postcondition( is_valid()); } // Operations with Border Halfedges size_type size_of_border_halfedges() const { // number of border halfedges. An edge with no incident facet // counts as two border halfedges. Precondition: `normalize_border // ()' has been called and no halfedge insertion or removal and no // change in border status of the halfedges have occured since // then. return hds.size_of_border_halfedges(); } size_type size_of_border_edges() const { // number of border edges. If `size_of_border_edges() == // size_of_border_halfedges()' all border edges are incident to a // facet on one side and to a hole on the other side. // Precondition: `normalize_border()' has been called and no // halfedge insertion or removal and no change in border status of // the halfedges have occured since then. return hds.size_of_border_edges(); } Halfedge_iterator border_halfedges_begin() { // halfedge iterator starting with the border edges. The range [ // `halfedges_begin(), border_halfedges_begin()') denotes all // non-border edges. The range [`border_halfedges_begin(), // halfedges_end()') denotes all border edges. Precondition: // `normalize_border()' has been called and no halfedge insertion // or removal and no change in border status of the halfedges have // occured since then. return hds.border_halfedges_begin(); } Halfedge_const_iterator border_halfedges_begin() const { return hds.border_halfedges_begin(); } // Convenient edge iterator Edge_iterator border_edges_begin() { return border_halfedges_begin(); } Edge_const_iterator border_edges_begin() const { return border_halfedges_begin(); } bool normalized_border_is_valid( bool verbose = false) const { // checks whether all non-border edges precedes the border edges. HalfedgeDS_const_decorator decorator(hds); bool valid = decorator.normalized_border_is_valid( verbose); for ( Halfedge_const_iterator i = border_halfedges_begin(); valid && (i != halfedges_end()); (++i, ++i)) { if ( i->is_border()) { Verbose_ostream verr(verbose); verr << " both halfedges of an edge are border " "halfedges." << std::endl; valid = false; } } return valid; } void normalize_border() { // sorts halfedges such that the non-border edges precedes the // border edges. hds.normalize_border(); CGAL_postcondition( normalized_border_is_valid()); } protected: // Supports_face_plane void inside_out_geometry( Tag_false) {} void inside_out_geometry( Tag_true) { typename Traits::Construct_opposite_plane_3 opp = traits().construct_opposite_plane_3_object(); std::transform( planes_begin(), planes_end(), planes_begin(), opp); } public: void inside_out() { // reverse facet orientation. HalfedgeDS_decorator decorator(hds); decorator.inside_out(); inside_out_geometry( Supports_face_plane()); } bool is_valid( bool verb = false, int level = 0) const { // checks the combinatorial consistency. Verbose_ostream verr(verb); verr << "begin CGAL::Polyhedron_3<...>::is_valid( verb=true, " "level = " << level << "):" << std::endl; HalfedgeDS_const_decorator D(hds); bool valid = D.is_valid( verb, level + 3); // All halfedges. Halfedge_const_iterator i = halfedges_begin(); Halfedge_const_iterator end = halfedges_end(); size_type n = 0; for( ; valid && (i != end); ++i) { verr << "halfedge " << n << std::endl; // At least triangular facets and distinct geometry. valid = valid && ( i->next() != i); valid = valid && ( i->next()->next() != i); valid = valid && ( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(i) != D.get_vertex(i->opposite())); valid = valid && ( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(i) != D.get_vertex(i->next())); valid = valid && ( ! check_tag( Supports_halfedge_vertex()) || D.get_vertex(i) != D.get_vertex(i->next()->next())); if ( ! valid) { verr << " incident facet is not at least a triangle." << std::endl; break; } // Distinct facets on each side of an halfegde. valid = valid && ( ! check_tag( Supports_halfedge_face()) || D.get_face(i) != D.get_face(i->opposite())); if ( ! valid) { verr << " both incident facets are equal." << std::endl; break; } ++n; } valid = valid && (n == size_of_halfedges()); if ( n != size_of_halfedges()) verr << "counting halfedges failed." << std::endl; verr << "end of CGAL::Polyhedron_3<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2_old/0000755000175000017500000000000012146213731030202 5ustar debiandebian././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2_old/Sweep_curves_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2_old/Sweep0000644000175000017500000020352711344301501031211 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2_old/Sweep_curves_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra // Ron Wein #ifndef CGAL_SWEEP_CURVES_BASE_2_H #define CGAL_SWEEP_CURVES_BASE_2_H #include #include #include #include #include #include #include #ifdef CGAL_SWEEP_LINE_DEBUG #define CGAL_SL_DEBUG(x) x #else #define CGAL_SL_DEBUG(x) #endif //#include //used for visualization - CGAL_BEGIN_NAMESPACE template class Sweep_curves_base_2 { public: typedef typename SweepLineTraits_2::X_curve X_curve; protected: typedef Sweep_curves_base_2 Self; /*! Curve_node_rep holds a curve participating in the sweep proccess. It contains a curve and a container of points. The points container refers to all the intersedction points (including edge points) calculated so far by the sweep line. These points are ordered from left to right on the curve, which means they are sorted in a way we get immidiately all the disjoint subcurves reduce by the curve. */ class Curve_node_rep; class Curve_node; class Intersection_point_node; // SUNPRO requires these friends. friend class Curve_node_rep; friend class Curve_node; friend class Intersection_point_node; class Curve_node_rep { public: typedef SweepLineTraits_2 Traits; typedef Point_plus_ Point_plus; typedef X_curve_plus_ X_curve_plus; typedef typename Traits::Point Point; typedef std::vector Points_container; Curve_node_rep(const X_curve_plus& cv, const Point& p, Traits* traits_) : cv_(cv), traits(traits_) { points.push_back( Point_plus(p) ); } Curve_node_rep(const X_curve_plus& cv, const Point_plus& p, Traits* traits_) : cv_(cv), traits(traits_) { points.push_back(p); } ~Curve_node_rep() {} // here we only compare addresses of represenattion. bool operator==(const Curve_node_rep& rep) const { // first at all comparing pointers to accelarate this operation. if (this == &rep) return true; if (&cv_ == &rep.cv_ && &points == &(rep.points)) return true; return false; } bool operator!=(const Curve_node_rep& rep) const { return !operator==(rep); } protected: friend class Curve_node; X_curve_plus cv_; // hold the left-most intersecting point. Points_container points; Traits *traits; private: const Point& leftmost(const Point &p1, const Point &p2) const { Comparison_result res = traits->compare_xy(p1,p2); return ((res == SMALLER) ? p1 : p2); } }; /*! A handle to a curve node. This is just a wrapper class with no members. */ // The handle to curve node. class Curve_node : public Handle_for { typedef Handle_for Handle_for_Curve_node_rep; public: typedef Point_plus_ Point_plus; typedef X_curve_plus_ X_curve_plus; typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; typedef typename Curve_node_rep::Points_container Points_container; typedef typename Points_container::iterator Points_iterator; typedef typename Points_container::const_iterator Points_const_iterator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Handle_for_Curve_node_rep::ptr; #endif Curve_node(Traits *traits_) : Handle_for_Curve_node_rep(traits_) { #ifdef CGAL_MAKE_PROFILING std::cout<<"alloc handle for DEFAULT Curve_node_rep"<points.push_back(event_point); } void erase_rightmost_point() { Points_iterator iter = ptr()->points.end(); iter--; ptr()->points.erase(iter); } const X_curve_plus& get_curve() const { return ptr()->cv_; } Point_plus& get_rightmost_point() { CGAL_assertion ( ptr()->points.size() > 0); return *(ptr()->points.rbegin()); } const Point_plus& get_rightmost_point() const { CGAL_assertion ( ptr()->points.size() > 0); return *(ptr()->points.rbegin()); } Points_iterator points_begin() { return ptr()->points.begin(); } Points_iterator points_end() { return ptr()->points.end(); } Points_const_iterator points_begin() const { return ptr()->points.begin(); } Points_const_iterator points_end() const { return ptr()->points.end(); } Self& operator=(const Self &cv_node) { Handle_for_Curve_node_rep::operator=(cv_node); return *this; } }; /*! A class describing an intersection point. It contains the point itself and a list of all curves going through that point, ordered by compare_at_x and compare_at_x_right of the traits. */ class Intersection_point_node { typedef Curve_node Curve_node_; public: typedef SweepLineTraits_2 Traits; typedef Point_plus_ Point_plus; typedef X_curve_plus_ X_curve_plus; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Point_2 Point_2; typedef Intersection_point_node Self; typedef std::vector Curve_node_container; typedef typename Curve_node_container::iterator Curve_node_iterator; typedef typename Curve_node_container::const_iterator Curve_node_const_iterator; typedef typename Traits::Has_left_category Has_left_category; // Obsolete typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; Intersection_point_node(Traits *traits_) : traits(traits_) {} Intersection_point_node(const Curve_node_& cv, Traits *traits_) : intersect_p(cv.get_rightmost_point()), traits(traits_) { curves.push_back(cv); } Intersection_point_node(const Curve_node_& cv, const Point_plus& ref_point, Traits *traits_) : intersect_p(ref_point), traits(traits_) { curves.push_back(cv); } Intersection_point_node(const Curve_node_& cv1, const Curve_node_& cv2, const Point_plus& ref_point, Traits *traits_) : intersect_p(ref_point), traits(traits_) { Comparison_result result = _curves_compare_y_at_x_right(cv1.get_curve(), cv2.get_curve(), ref_point.point()); if (result == SMALLER){ curves.push_back(cv1); curves.push_back(cv2); } else if (result == LARGER){ curves.push_back(cv2); curves.push_back(cv1); } else { //equal: if one of the curve is to left of ref_point - // this curve will be pushed first. if (traits->point_equal( rightmost(traits->curve_source(cv1.get_curve()), traits->curve_target(cv1.get_curve())), ref_point.point())) { curves.push_back(cv1); curves.push_back(cv2); } else { //include the case : // if (rightmost(traits.curve_source(cv2.get_curve()), // traits.curve_target(cv2.get_curve())) == ref_point) curves.push_back(cv2); curves.push_back(cv1); } } } /*! Merges the curves of the "this" point and the input node. The point in the input point node has to be the same as the point in this instance. This function orders all the curves enemating from intersect_p in counter clock wise order, particularly, the order when comparing the curves to the right of the intersection point is monotonicaly increasing. */ void merge(const Self& point_node) { CGAL_assertion (intersect_p == point_node.get_point()); CGAL_assertion (curves.size() > 0 && point_node.curves_begin() != point_node.curves_end()); Curve_node_container merged_left_curves, merged_right_curves; Curve_node_iterator cv_iter=curves.begin(); Curve_node_const_iterator point_node_cv_iter=point_node.curves_begin(); for ( ; cv_iter != curves.end() && point_node_cv_iter != point_node.curves_end(); ) { // both curves are defined to the left to the intersection point. if (is_left(traits->curve_source(cv_iter->get_curve()), intersect_p.point()) && is_left(traits->curve_source(point_node_cv_iter->get_curve()), intersect_p.point()) ) { // first handle with overlappings. if (traits->curves_overlap(cv_iter->get_curve(), point_node_cv_iter->get_curve())){ Point p1, p2; nearest_intersection_to_left (cv_iter->get_curve(), point_node_cv_iter->get_curve(), intersect_p.point(), p1, p2); if (traits->point_equal(p1, intersect_p.point())) { merged_left_curves.push_back(*cv_iter); cv_iter++; merged_left_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; continue; } } Comparison_result result = _curves_compare_y_at_x_left (cv_iter->get_curve(), point_node_cv_iter->get_curve(), intersect_p.point()); if (result == LARGER){ merged_left_curves.push_back(*cv_iter); cv_iter++; } else if (result == SMALLER){ merged_left_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; } else { // at least one of the curves is vertical. // Now we shall insert the non vertical curve before the // vertical one. if ( !traits->curve_is_vertical(cv_iter->get_curve()) ){ merged_left_curves.push_back(*cv_iter); cv_iter++; } else{ // *cv_iter is vertical , *point_node_cv_iter may or may // not be vertical, if it is not - has to come first, else the // order is trivial. merged_left_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; } // if both curves are vertical, they overlap and hence this case // is already has taken care. } } // if the curves are defined only to the right of the intersection // point. else if (traits->point_equal( traits->curve_source(cv_iter->get_curve()), intersect_p.point()) && traits->point_equal( traits->curve_source(point_node_cv_iter->get_curve()), intersect_p.point())) { // first handle with overlappings. if (traits->curves_overlap(cv_iter->get_curve(), point_node_cv_iter->get_curve())){ Point p1, p2; traits-> nearest_intersection_to_right(cv_iter->get_curve(), point_node_cv_iter->get_curve(), intersect_p.point(), p1, p2); if (traits->point_equal(p2, intersect_p.point())) { merged_right_curves.push_back(*cv_iter); cv_iter++; merged_right_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; continue; } } Comparison_result result = _curves_compare_y_at_x_right( cv_iter->get_curve(), point_node_cv_iter->get_curve(), intersect_p.point()); if (result == SMALLER){ merged_right_curves.push_back(*cv_iter); cv_iter++; } else if (result == LARGER){ merged_right_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; } else { //equal. We get here if one of the curves is vertical. // Now we shall insert the non vertical curve before the // vertical one. if ( !traits->curve_is_vertical(cv_iter->get_curve()) ){ merged_right_curves.push_back(*cv_iter); cv_iter++; } else{ // *cv_iter is vertical , *point_node_cv_iter may or may // not be vertical, if it is not - has to come first, else the // order is trivial. merged_right_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; } // if both curves are vertical, they overlap and hence this case // is already has taken care. } } else{ // Checking whether each curves starts at intersect_p - // it means that lexicographically it's not defined to the left of // intersect_p. if (is_left(traits->curve_source(cv_iter->get_curve()), intersect_p.point()) ){ merged_left_curves.push_back(*cv_iter); cv_iter++; } else if (traits->point_equal( traits->curve_source(cv_iter->get_curve()), intersect_p.point())) { merged_right_curves.push_back(*cv_iter); cv_iter++; } if (is_left(traits->curve_source(point_node_cv_iter->get_curve()), intersect_p.point() )){ merged_left_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; } else if (traits->point_equal( traits->curve_source(point_node_cv_iter->get_curve()), intersect_p.point())) { merged_right_curves.push_back(*point_node_cv_iter); point_node_cv_iter++; } } } for (; cv_iter != curves.end(); cv_iter++){ if (traits->point_equal(traits->curve_target(cv_iter->get_curve()), intersect_p.point())) merged_left_curves.push_back(*cv_iter); else if (is_right(traits->curve_target(cv_iter->get_curve()), intersect_p.point()) ) merged_right_curves.push_back(*cv_iter); } for (; point_node_cv_iter != point_node.curves_end(); point_node_cv_iter++){ if (traits->point_equal( traits->curve_target(point_node_cv_iter->get_curve()), intersect_p.point())) merged_left_curves.push_back(*point_node_cv_iter); else if (is_right(traits->curve_target( point_node_cv_iter->get_curve()), intersect_p.point()) ) merged_right_curves.push_back(*point_node_cv_iter); } // now, copying the two merged vector to curves. curves.clear(); std::copy(merged_left_curves.begin(), merged_left_curves.end(), std::back_inserter(curves)); std::copy(merged_right_curves.begin(), merged_right_curves.end(), std::back_inserter(curves)); } Point_plus& get_point() { return intersect_p; } const Point_plus& get_point() const { return intersect_p; } Curve_node_iterator curves_begin() { return curves.begin(); } Curve_node_iterator curves_end() { return curves.end(); } Curve_node_const_iterator curves_begin() const { return curves.begin(); } Curve_node_const_iterator curves_end() const { return curves.end(); } protected: const Point& rightmost(const Point &p1, const Point &p2) const { Comparison_result res = traits->compare_xy(p1,p2); return ((res == SMALLER) ? p2 : p1); } bool is_right(const Point &p1, const Point &p2) const { return (Compare_lexicographically_xy(p1, p2) == LARGER); } bool is_left(const Point &p1, const Point &p2) const { return (Compare_lexicographically_xy(p1, p2) == SMALLER); } bool nearest_intersection_to_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & pt, Point_2 & p1, Point_2 & p2) const { return nearest_intersection_to_left_imp(cv1, cv2, pt, p1, p2, Has_left_category()); } bool nearest_intersection_to_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & pt, Point_2 & p1, Point_2 & p2, Tag_true) const { return traits->nearest_intersection_to_left(cv1, cv2, pt, p1, p2); } bool nearest_intersection_to_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & pt, Point_2 & p1, Point_2 & p2, Tag_false) const { Point_2 rpt = traits->point_reflect_in_x_and_y( pt); X_monotone_curve_2 rcv1 = traits->curve_reflect_in_x_and_y( cv1); X_monotone_curve_2 rcv2 = traits->curve_reflect_in_x_and_y( cv2); Point_2 rp1, rp2; bool result = traits->nearest_intersection_to_right(rcv1, rcv2, rpt, rp1, rp2); p1 = traits->point_reflect_in_x_and_y( rp1); p2 = traits->point_reflect_in_x_and_y( rp2); return result; } Comparison_result Compare_lexicographically_xy(const Point& p1, const Point& p2) const { return (traits->compare_xy(p1,p2)); } // Imitate the previous behaviour of the two functions: that is, return // EQUAL in undefined cases. Comparison_result _curves_compare_y_at_x_right (const X_curve& cv1, const X_curve& cv2, const Point& p) const { // In case the point is not in the x-range of both curves or that // one of the curves is not defined at p's right, return EQUAL. Comparison_result res1 = traits->compare_x(traits->curve_source(cv1), traits->curve_target(cv1)); Comparison_result res2 = traits->compare_x(traits->curve_source(cv2), traits->curve_target(cv2)); const Point_2& left1 = (res1 == SMALLER) ? traits->curve_source(cv1) : traits->curve_target(cv1); const Point_2& right1 = (res1 == LARGER) ? traits->curve_source(cv1) : traits->curve_target(cv1); const Point_2& left2 = (res2 == SMALLER) ? traits->curve_source(cv2) : traits->curve_target(cv2); const Point_2& right2 = (res2 == LARGER) ? traits->curve_source(cv2) : traits->curve_target(cv2); if (traits->compare_x (right1, p) != LARGER) return (EQUAL); else if (traits->compare_x (left1, p) == LARGER) return (EQUAL); if (traits->compare_x (right2, p) != LARGER) return (EQUAL); else if (traits->compare_x (left2, p) == LARGER) return (EQUAL); // Compare using the traits function: Comparison_result res = traits->curves_compare_y_at_x (cv1, cv2, p); if (res != EQUAL) return (res); return (traits->curves_compare_y_at_x_right (cv1, cv2, p)); } Comparison_result _curves_compare_y_at_x_left (const X_curve& cv1, const X_curve& cv2, const Point& p) const { // In case the point is not in the x-range of both curves or that // one of the curves is not defined at p's left, return EQUAL. Comparison_result res1 = traits->compare_x(traits->curve_source(cv1), traits->curve_target(cv1)); Comparison_result res2 = traits->compare_x(traits->curve_source(cv2), traits->curve_target(cv2)); const Point_2& left1 = (res1 == SMALLER) ? traits->curve_source(cv1) : traits->curve_target(cv1); const Point_2& right1 = (res1 == LARGER) ? traits->curve_source(cv1) : traits->curve_target(cv1); const Point_2& left2 = (res2 == SMALLER) ? traits->curve_source(cv2) : traits->curve_target(cv2); const Point_2& right2 = (res2 == LARGER) ? traits->curve_source(cv2) : traits->curve_target(cv2); if (traits->compare_x (left1, p) != SMALLER) return (EQUAL); else if (traits->compare_x (right1, p) == SMALLER) return (EQUAL); if (traits->compare_x (left2, p) != SMALLER) return (EQUAL); else if (traits->compare_x (right2, p) == SMALLER) return (EQUAL); // Compare using the traits function: Comparison_result res = traits->curves_compare_y_at_x (cv1, cv2, p); if (res != EQUAL) return (res); return (traits->curves_compare_y_at_x_left (cv1, cv2, p)); } // hold the left most intersecting point. Point_plus intersect_p; Curve_node_container curves; Traits *traits; }; template class less_point_xy { public: typedef SweepLineTraits_2 Traits; less_point_xy(Traits *traits_) : traits(traits_) {} inline bool operator()(const Point& p1, const Point& p2) const { return (traits->compare_xy(p1,p2) == SMALLER); } private: Traits *traits; }; // A predicate ordering two Curve nodes. template class less_curve_xy { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; less_curve_xy(Traits *traits_) : traits(traits_) {} /*! Returns true if the first curve is "less" than the second curve. If both curves are "the same", it returns the one with a smaller id. */ inline bool operator()(const _Curve_node& cv1, const _Curve_node& cv2) const { Comparison_result result; const Point& ref_point = rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point()); // if both curves are vartical, we look at the ids if (traits->curve_is_vertical(cv2.get_curve()) && (traits->curve_is_vertical(cv1.get_curve()))) return ( cv1.get_curve().id() < cv2.get_curve().id() ); // if the rightmost points are different, we compare the curves relative // to the righmost of the two if ( cv1.get_rightmost_point() != cv2.get_rightmost_point() ) { result = curve_node_compare_at_x(cv1, cv2, ref_point); } else { // both curves enamting the same point. if ( traits->curve_is_vertical(cv1.get_curve()) ) // if one of the curves enamating from the point is vertical // then it will have larger value on the status. return false; else if ( traits->curve_is_vertical(cv2.get_curve()) ) return true; result = _curves_compare_y_at_x_right (cv1.get_curve(), cv2.get_curve(), ref_point); if (result == EQUAL) result = traits->curves_compare_y_at_x (cv1.get_curve(), cv2.get_curve(), ref_point); } if (result == SMALLER){ return true; } else if (result == LARGER){ return false; } else { // equal - the curves are overlapping. return ( cv1.get_curve().id() < cv2.get_curve().id() ); } } private: Comparison_result curve_node_compare_at_x(const _Curve_node &cv1, const _Curve_node &cv2, const Point &q) const { Comparison_result result; bool update_first_cv = false, update_second_cv = false; X_curve_plus first_cv , second_cv; // making an optimization. // taking care the edge case of vertical segments: if one is // vertical, then the order is set according the 'rightmost' // point (so far) of the vertical curve comparing the point that // a vertical line hits the other curve. if ( traits->curve_is_vertical(cv1.get_curve()) ) { // if the curve is vertical and the point is its target we // refer that curve as a point. if (traits->point_equal(traits->curve_target(cv1.get_curve()), cv1.get_rightmost_point().point())) { if (! traits->point_in_x_range (cv2.get_curve(), traits->curve_target(cv1.get_curve()))) return (EQUAL); Comparison_result cres = traits->curve_compare_y_at_x (traits->curve_target(cv1.get_curve()), cv2.get_curve()); if (cres == SMALLER || cres == EQUAL) // if the target is on cv2 its means that it tangent to // cv2 from below. return SMALLER; else return LARGER; } X_curve tmp_cv; if (!traits->point_equal(traits->curve_source(cv1.get_curve()), q)) { traits->curve_split(cv1.get_curve(), tmp_cv, first_cv, q); update_first_cv = true; } } if ( traits->curve_is_vertical(cv2.get_curve()) ){ // if the curve is vertical and the point is its target we // refer that curve as a point. if (traits->point_equal(traits->curve_target(cv2.get_curve()), cv2.get_rightmost_point().point())) { if (! traits->point_in_x_range (cv1.get_curve(), traits->curve_target(cv2.get_curve()))) return (EQUAL); Comparison_result cres = traits->curve_compare_y_at_x (traits->curve_target(cv2.get_curve()), cv1.get_curve()); // if the target is on cv1 its means that it tangent to cv1 // from below. if (cres == SMALLER || cres == EQUAL) return LARGER; else return SMALLER; } X_curve tmp_cv; if (!traits->point_equal(traits->curve_source(cv2.get_curve()), q)) { traits->curve_split(cv2.get_curve(), tmp_cv, second_cv, q); update_second_cv = true; } } // making this four cases in order to make an optimization for not // copying to first_cv and second_cv the original curves is not needed. if (!update_first_cv && !update_second_cv) result = _curves_compare_y_at_x_right (cv1.get_curve(), cv2.get_curve(), // making an optimization attemp: rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); else if (update_first_cv && !update_second_cv) result = _curves_compare_y_at_x_right (first_cv, cv2.get_curve(), rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); else if (!update_first_cv && update_second_cv) result = _curves_compare_y_at_x_right (cv1.get_curve(), second_cv, rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); else // update_first_cv && update_second_cv is true. result = _curves_compare_y_at_x_right (first_cv, second_cv, rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); if (result == EQUAL){ if (!update_first_cv && !update_second_cv) result = traits-> curves_compare_y_at_x(cv1.get_curve(), cv2.get_curve(), rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); else if (update_first_cv && !update_second_cv) result = traits-> curves_compare_y_at_x(first_cv, cv2.get_curve(), rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); else if (!update_first_cv && update_second_cv) result = traits-> curves_compare_y_at_x(cv1.get_curve(),second_cv, rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); else // update_first_cv && update_second_cv is true. result = traits-> curves_compare_y_at_x(first_cv, second_cv, rightmost(cv1.get_rightmost_point().point(), cv2.get_rightmost_point().point())); } // if one of the curves is vertical - EQUAL means that the other curve // is between the source and target point of the vertical curve, and // for our definition - it means that the verical curve comes first. if ( result == EQUAL && traits->curve_is_vertical(update_first_cv ? first_cv: cv1.get_curve()) ) { if (! traits->point_in_x_range (update_second_cv ? second_cv : cv2.get_curve(), traits->curve_source(update_first_cv ? first_cv : cv1.get_curve()))) result = SMALLER; // if first_cv is vertical and its source tangent to second_cv - // it means that first_cv is above second_cv. else if (traits->curve_compare_y_at_x (traits->curve_source(update_first_cv ? first_cv : cv1.get_curve()), update_second_cv ? second_cv : cv2.get_curve()) == EQUAL) result = LARGER; else result = SMALLER; } else if (result == EQUAL && traits->curve_is_vertical(update_second_cv? second_cv: cv2.get_curve())) { if (! traits->point_in_x_range (update_first_cv ? first_cv : cv1.get_curve(), traits->curve_source(update_second_cv ? second_cv : cv2.get_curve()))) result = LARGER; // if second_cv is vertical and its source tangent to first_cv - // it means that second_cv is above first_cv. else if (traits->curve_compare_y_at_x (traits->curve_source(update_second_cv ? second_cv : cv2.get_curve()), update_first_cv ? first_cv: cv1.get_curve()) == EQUAL) result = SMALLER; else result = LARGER; } return result; } const Point& rightmost(const Point &p1, const Point &p2) const { Comparison_result res = traits->compare_xy(p1,p2); return ((res == SMALLER) ? p2 : p1); } // Imitate the previous behaviour of the function: that is, return // EQUAL in undefined cases. Comparison_result _curves_compare_y_at_x_right (const X_curve& cv1, const X_curve& cv2, const Point& p) const { // In case the point is not in the x-range of both curves or that // one of the curves is not defined at p's right, return EQUAL. Comparison_result res1 = traits->compare_x(traits->curve_source(cv1), traits->curve_target(cv1)); Comparison_result res2 = traits->compare_x(traits->curve_source(cv2), traits->curve_target(cv2)); const Point& left1 = (res1 == SMALLER) ? traits->curve_source(cv1) : traits->curve_target(cv1); const Point& right1 = (res1 == LARGER) ? traits->curve_source(cv1) : traits->curve_target(cv1); const Point& left2 = (res2 == SMALLER) ? traits->curve_source(cv2) : traits->curve_target(cv2); const Point& right2 = (res2 == LARGER) ? traits->curve_source(cv2) : traits->curve_target(cv2); if (traits->compare_x (right1, p) != LARGER) return (EQUAL); else if (traits->compare_x (left1, p) == LARGER) return (EQUAL); if (traits->compare_x (right2, p) != LARGER) return (EQUAL); else if (traits->compare_x (left2, p) == LARGER) return (EQUAL); // Compare using the traits function: Comparison_result res = traits->curves_compare_y_at_x (cv1, cv2, p); if (res != EQUAL) return (res); return (traits->curves_compare_y_at_x_right (cv1, cv2, p)); } Traits *traits; }; public: typedef CurveInputIterator Curve_iterator; typedef SweepLineTraits_2 Traits; typedef Point_plus_ Point_plus; typedef typename Traits::Point Point; typedef X_curve_plus_ X_curve_plus; typedef typename Curve_node::Points_iterator Points_iterator; typedef typename Curve_node::Points_const_iterator Points_const_iterator; typedef typename Intersection_point_node::Curve_node_iterator Curve_node_iterator; typedef typename Intersection_point_node::Curve_node_const_iterator Curve_node_const_iterator; protected: typedef std::pair pair_Point_Point_plus; typedef std::pair pair_Point_Intersection_point_node; typedef std::pair pair_Curve_node_X_curve_plus; typedef less_point_xy Less_xy; typedef less_curve_xy Less_yx; public: typedef std::map Vertices_points_plus; typedef std::map Event_queue; typedef std::set Status_line; typedef std::list X_curve_list; typedef typename X_curve_list::iterator X_curve_list_iterator; typedef typename Event_queue::value_type Event_queue_value_type; typedef typename Status_line::value_type Status_line_value_type; typedef typename Event_queue::iterator Event_queue_iterator; typedef typename Status_line::iterator Status_line_iterator; typedef typename std::list::iterator list_Curve_node_iterator; Sweep_curves_base_2() : traits(new Traits), use_delete_traits(true), intersection_exist_(false) {} Sweep_curves_base_2(Traits *traits_) : traits(traits_), use_delete_traits(false), intersection_exist_(false) {} ~Sweep_curves_base_2() { if (use_delete_traits) delete traits; } protected: void reset() { intersection_exist_ = false; } // change it back to the original one. bool handle_one_event (Event_queue & event_queue, Status_line & status, const Point & event_point, Intersection_point_node & point_node) { bool event_terminated = true; bool point_node_first_on_status = false, point_node_last_on_status = false; // a container to hold the point_node curve nodes ordered as they // should on status. typedef std::set Local_status_line; typedef typename Local_status_line::iterator Local_status_line_iterator; Less_yx pred(traits); Local_status_line local_status(pred); // reserve the size of the // point_node enamating curves. Status_line_iterator hint = status.end(); Curve_node_iterator cv_iter = point_node.curves_begin(); if (cv_iter != point_node.curves_begin()) --cv_iter; for ( ; hint == status.end() && cv_iter != point_node.curves_end(); ++cv_iter) hint = std::find(status.begin(), status.end(), *cv_iter); if (hint == status.begin()) point_node_first_on_status = true; if (hint != status.end()){ ++hint; // getting the first curve node on status above the // highest *cv_iter of curve_node. if (hint == status.end()) point_node_last_on_status = true; } //bool hint_in_point_node = false; while (hint != status.end()){ for (cv_iter = point_node.curves_begin() ; cv_iter != point_node.curves_end(); ++cv_iter) if (*hint == *cv_iter) { break; } if (cv_iter != point_node.curves_end()) ++hint; else break; } Local_status_line_iterator local_status_hint = local_status.end(); for (cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter) { // trying to use general find in order to force it to use // operator == of Curve node. We only care here if *cv_iter is // on the status, we don't care where it should be put on status // according less_curve_xy predicate. Since we work with handles only // address comparing will be done. Status_line_iterator curr_cv_node = std::find(status.begin(), status.end(), *cv_iter); // the event point is not the right point of the curve - // insert curve to status if it's not already there. if (curr_cv_node != status.end()){ // remove cv_iter from status and reinsert it with the new point. status.erase(curr_cv_node); } CGAL_expensive_postcondition_code(is_valid(status)); // reinserting curve only if it's still on status. if (!traits->point_equal(event_point, cv_iter->get_rightmost_point().point())) cv_iter->push_event_point(point_node.get_point()); if (local_status_hint != local_status.end()){ ++local_status_hint; } if (Compare_lexicographically_xy( event_point, traits->curve_target(cv_iter->get_curve()) ) == CGAL::SMALLER){ local_status_hint = local_status.insert(local_status_hint, *cv_iter); //if (local_status_hint == local_status.end()) cout << "ERROR //- returned value of insert to local status is //local_status.end()"< overlapping_curves; Status_line_iterator lower = --curr_cv_node; ++curr_cv_node; for ( ;curr_cv_node != status.begin() && traits->curves_overlap(lower->get_curve(), curr_cv_node->get_curve()); --lower){ Point p1, p2; traits->nearest_intersection_to_right (curr_cv_node->get_curve(), lower->get_curve(), event_point, p1, p2); if (is_left(event_point, p1) || is_right(event_point, p2)) // means that the overlapping does not intersects the // status line. break; overlapping_curves.push_back(*curr_cv_node); status.erase(curr_cv_node); curr_cv_node = lower; Curve_node cv_node = *curr_cv_node; // now taking care of the events created by the overlapping curve Point xp; if (check_status_neighbors_intersections(event_queue, status, curr_cv_node, event_point)) // Edge case of tangency in the event point, // if it is this event will be taked cared again. // event_overlap_terminated = false; if (curr_cv_node != status.begin()){ --curr_cv_node; if (check_status_neighbors_intersections(event_queue, status, curr_cv_node, event_point)) // Edge case of tangency in the event point, // if it is - this event will be taked cared again. // event_overlap_terminated = false; ++curr_cv_node; } if (curr_cv_node != status.end() && Compare_lexicographically_xy ( event_point, traits->curve_target(curr_cv_node->get_curve()) ) == CGAL::EQUAL){ Status_line_iterator prev_cv_node; bool first = true; // hold the (lower) neighbor element of the current. if (curr_cv_node != status.begin()){ prev_cv_node = --curr_cv_node; ++curr_cv_node; first = false; } status.erase(curr_cv_node); CGAL_expensive_postcondition_code(is_valid(status)); if (!first){ if (check_status_neighbors_intersections(event_queue, status, prev_cv_node, event_point)) // Edge case of tangency in the event point, if it // is this event will be taked cared again. // event_overlap_terminated = false; ; } } } // reinsert to the status line all the overlapping removed curves. for (list_Curve_node_iterator ovlp_iter=overlapping_curves.begin(); ovlp_iter != overlapping_curves.end(); ++ovlp_iter) status.insert(Status_line_value_type(*ovlp_iter)); } } curr_cv_node = std::find(status.begin(), status.end(), *cv_iter); if (curr_cv_node != status.end()){ std::list overlapping_curves; Status_line_iterator upper = ++curr_cv_node; --curr_cv_node; for ( ;upper != status.end() && curr_cv_node != status.end() && traits->curves_overlap(curr_cv_node->get_curve(), upper->get_curve()); ++upper){ Point p1, p2; traits->nearest_intersection_to_right (curr_cv_node->get_curve(), upper->get_curve(), event_point , p1, p2); // means that the overlapping does not intersects the status line. if (is_left(event_point, p1) || is_right(event_point, p2)) break; overlapping_curves.push_back(*curr_cv_node); status.erase(curr_cv_node); curr_cv_node = upper; Curve_node cv_node = *curr_cv_node; // now taking care of the events created by the overlapping curve. Point xp; if (check_status_neighbors_intersections(event_queue, status, curr_cv_node, event_point)) // Edge case of tangency in the event point, // if it is this event will be taked cared again. // event_overlap_terminated = false; if (curr_cv_node != status.begin()){ --curr_cv_node; if (check_status_neighbors_intersections(event_queue, status, curr_cv_node, event_point)) // Edge case of tangency in the event point, // if it is - this event will be taked cared again. // event_overlap_terminated = false; ++curr_cv_node; } if (curr_cv_node != status.end() && Compare_lexicographically_xy ( event_point, traits->curve_target(curr_cv_node->get_curve()) ) == CGAL::EQUAL){ Status_line_iterator prev_cv_node; bool first = true; // hold the (lower) neighbor element of the current. if (curr_cv_node != status.begin()){ prev_cv_node = --curr_cv_node; ++curr_cv_node; first = false; } status.erase(curr_cv_node); CGAL_expensive_postcondition_code(is_valid(status)); if (!first){ //cout<<"checking neighbors after deletion\n"; if (check_status_neighbors_intersections(event_queue, status, prev_cv_node, event_point)) // Edge case of tangency in the event point, // if it is this event will be taked cared again. // event_overlap_terminated = false; ; } } } // reinsert to the status line all the overlapping removed curves. for (list_Curve_node_iterator ovlp_iter = overlapping_curves.begin(); ovlp_iter != overlapping_curves.end(); ++ovlp_iter) status.insert(Status_line_value_type(*ovlp_iter)); } } } bool point_is_on_curve_interior(const Point & p, const X_curve & cv) { return (!traits->point_equal(p, traits->curve_source(cv)) || !traits->point_equal(p, traits->curve_target(cv))); } // check whether two curves are tangent on a given point. bool curves_tangent_at_point(const X_curve& cv1, const X_curve& cv2, const Point& point) { return (traits->point_in_x_range(cv1, point) && traits->curve_compare_y_at_x(point, cv1) == EQUAL && traits->point_in_x_range(cv2, point) && traits->curve_compare_y_at_x(point, cv2) == EQUAL && (point_is_on_curve_interior(point, cv1) || point_is_on_curve_interior(point, cv2) ) ); } bool check_status_neighbors_intersections(Event_queue& event_queue, Status_line& status, Status_line_iterator lower_neighbor ,const Point &event_point) { const Curve_node& cv1 = *lower_neighbor; Status_line_iterator next_neighbor = ++lower_neighbor; if (next_neighbor == status.end()) return false; --lower_neighbor; const Curve_node& cv2 = *next_neighbor; // in each node - checking intersections between two // adjacent curves and updating the event queue if needed. const Point &xp1 = event_point; Point xp2, xp3; bool curves_tangent = curves_tangent_at_point(cv1.get_curve(), cv2.get_curve(), event_point); bool curves_intersect = traits->nearest_intersection_to_right(cv1.get_curve(), cv2.get_curve(), event_point, xp2, xp3); if (curves_tangent || curves_intersect) { // checking if the curves are already participate within the // intersection node, if at least one is not - we have a new // event here or a new curve particitating on it and the // function will return true. // handling overlapping. if (curves_intersect && (!traits->point_equal(xp2, xp3))) { Event_queue_iterator xp_event = event_queue.find(xp3); bool xp3_cv1_in_queue = false, xp3_cv2_in_queue = false; if (xp_event == event_queue.end()) xp_event = event_queue.insert(Event_queue_value_type (xp3, Intersection_point_node(cv1, cv2, xp3, traits) )).first; else{ // have to check whether the event is a new event. // (we might calculated this point before). for ( Curve_node_iterator cv_iter = xp_event->second.curves_begin(); cv_iter != xp_event->second.curves_end(); cv_iter++){ if (cv_iter->get_curve() == cv1.get_curve()) { xp3_cv1_in_queue = true; } if (cv_iter->get_curve() == cv2.get_curve()) { xp3_cv2_in_queue = true; } } if (!xp3_cv1_in_queue && !xp3_cv2_in_queue) xp_event->second.merge(Intersection_point_node(cv1, cv2, Point_plus(xp3), traits)); else if (!xp3_cv1_in_queue) xp_event->second.merge(Intersection_point_node(cv1, Point_plus(xp3), traits)); else if (!xp3_cv2_in_queue) xp_event->second.merge(Intersection_point_node(cv2, Point_plus(xp3), traits)); } } // handling intersection. bool xp2_cv1_in_queue = false, xp2_cv2_in_queue = false; if ( curves_intersect ) { Event_queue_iterator xp_event = event_queue.find(xp2); if (xp_event == event_queue.end()) xp_event = event_queue.insert( Event_queue_value_type(xp2, Intersection_point_node(cv1, cv2, xp2, traits))).first; else { // have to check whether the event is a new event. (we might // calculated this point before). for ( Curve_node_iterator cv_iter = xp_event->second.curves_begin(); cv_iter != xp_event->second.curves_end(); cv_iter++){ if (cv_iter->get_curve() == cv1.get_curve()) { xp2_cv1_in_queue = true; } if (cv_iter->get_curve() == cv2.get_curve()) { xp2_cv2_in_queue = true; } } if (!xp2_cv1_in_queue && !xp2_cv2_in_queue) xp_event->second.merge(Intersection_point_node(cv1, cv2, Point_plus(xp2), traits)); else if (!xp2_cv1_in_queue) xp_event->second.merge(Intersection_point_node(cv1, Point_plus(xp2), traits)); else if (!xp2_cv2_in_queue) xp_event->second.merge(Intersection_point_node(cv2, Point_plus(xp2), traits)); } } bool xp1_cv1_in_queue = false, xp1_cv2_in_queue = false; // if cv1 and cv2 have common edge point - we do not consider it // as an intersection point. if ( curves_tangent ) { Event_queue_iterator xp_event = event_queue.find(xp1); if (xp_event == event_queue.end()) xp_event=event_queue.insert(Event_queue_value_type( xp1, Intersection_point_node(cv1, cv2, xp1, traits))).first; else{ // have to check whether the event is a new event. // (we might calculated this point before). for ( Curve_node_iterator cv_iter = xp_event->second.curves_begin(); cv_iter != xp_event->second.curves_end(); ++cv_iter){ if (cv_iter->get_curve() == cv1.get_curve()) { xp1_cv1_in_queue = true; } if (cv_iter->get_curve() == cv2.get_curve()) { xp1_cv2_in_queue = true; } } if (!xp1_cv1_in_queue && !xp1_cv2_in_queue) xp_event->second.merge(Intersection_point_node(cv1, cv2, Point_plus(xp1), traits)); else if (!xp1_cv1_in_queue) xp_event->second.merge(Intersection_point_node(cv1, Point_plus(xp1), traits)); else if (!xp1_cv2_in_queue) xp_event->second.merge(Intersection_point_node(cv2, Point_plus(xp1), traits)); } } if (curves_intersect || curves_tangent) intersection_exist_ = true; if (curves_intersect && !curves_tangent) return ((!xp2_cv1_in_queue || !xp2_cv2_in_queue) && traits->point_equal(xp2, event_point)); else if (curves_tangent) return ((!xp1_cv1_in_queue || !xp1_cv2_in_queue) && traits->point_equal(xp1, event_point)); } return false; } // defining a lexicographically compare function here in order to // make a usage in traits. Comparison_result Compare_lexicographically_xy(const Point & p1, const Point & p2) const { return (traits->compare_xy(p1,p2)); } #if defined SWEEP_DEBUG_MODE //------------------------------------------------------- debuging functions //----------------------------------------- bool is_valid(Status_line& status) { std::list curve_nodes; std::list subcurves; for (typename Status_line::const_iterator iter = status.begin(); iter != status.end(); iter++) curve_nodes.push_back(*iter); get_subcurves(curve_nodes, subcurves); return (!do_intersect_subcurves(subcurves)); } void get_subcurves(const std::list& curves, std::list& subcurves) { for (std::list::const_iterator cv_iter = curves.begin(); cv_iter != curves.end(); cv_iter++){ X_curve cv = cv_iter->get_curve(), left_cv, right_cv = cv_iter->get_curve(); for (typename Curve_node::Points_const_iterator points_iter = cv_iter->points_begin(); points_iter != cv_iter->points_end(); points_iter++){ // make surve the splitting is not at the edge points. if (points_iter == cv_iter->points_begin()) continue; if (traits-> point_equal(*points_iter, rightmost( traits->curve_source(cv_iter->get_curve()), traits->curve_target(cv_iter->get_curve())))) left_cv = right_cv; else traits->curve_split(cv, left_cv, right_cv, points_iter->point()); subcurves.push_back(left_cv); cv = right_cv; } } } bool do_intersect_subcurves(const std::list& subcurves) { for (std::list::const_iterator scv_iter1 = subcurves.begin(); scv_iter1 != subcurves.end(); ++scv_iter1){ for (std::list::const_iterator scv_iter2 = scv_iter1; scv_iter2 != subcurves.end(); ++scv_iter2){ if (scv_iter2 == scv_iter1) continue; Point ref_point1, ref_point2, xp1, xp2; ref_point1 = leftmost(traits->curve_source(*scv_iter1), traits->curve_target(*scv_iter1)); ref_point2 = leftmost(traits->curve_source(*scv_iter2), traits->curve_target(*scv_iter2)); if (!traits->point_equal(ref_point1, ref_point2)) ref_point1 = leftmost(ref_point1, ref_point2); if (traits->nearest_intersection_to_right(*scv_iter1, *scv_iter2, ref_point1, xp1, xp2)) { if (traits->point_equal(xp1, ref_point1)) xp1 = xp2; if (!((traits->point_equal(xp1, traits->curve_source(*scv_iter1)) || traits->point_equal(xp1, traits->curve_target(*scv_iter1))) && (traits->point_equal(xp1, traits->curve_source(*scv_iter2)) || traits->point_equal(xp1, traits->curve_target(*scv_iter2))))) { return true; } } } } return false; } #endif // SWEEP_DEBUG_MODE bool is_left(const Point &p1, const Point &p2) const { return (Compare_lexicographically_xy(p1, p2) == SMALLER); } bool is_right(const Point &p1, const Point &p2) const { return (Compare_lexicographically_xy(p1, p2) == LARGER); } bool is_lower(const Point &p1, const Point &p2) const { return (Compare_lexicographically_yx(p1, p2) == SMALLER); } bool is_higher(const Point &p1, const Point &p2) const { return (Compare_lexicographically_yx(p1, p2) == LARGER); } const Point& leftmost(const Point &p1, const Point &p2) const { if ( is_left(p1, p2) ) return p1; return p2; } const Point& rightmost(const Point &p1, const Point &p2) const { if ( is_right(p1, p2) ) return p1; else return p2; } #if defined SWEEP_DEBUG_MODE //-------------------------------- debuging functions. template void print_status(const Status &status); template void print_points_on_curves(const _Curve_node& cv); #endif Traits *traits; bool use_delete_traits; bool intersection_exist_; }; //////////////////////////////////////////////////////////////////////// //// METHODS #if defined SWEEP_DEBUG_MODE // ---- debug functions ----- template template void Sweep_curves_base_2:: print_status(const Status &status) { cout<<"Curves on status are\n"; for (typename Status_line::const_iterator status_iter = status.begin(); status_iter != status.end(); status_iter++){ X_curve_plus cv1 = status_iter->get_curve(); cout< template void Sweep_curves_base_2:: print_points_on_curves(const _Curve_node& cv) { cout<<"list of points is "<point()<<" "; cout< #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_WRAPPER_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_WRAPPER_2_H #include CGAL_BEGIN_NAMESPACE template class Segment_Voronoi_diagram_traits_wrapper_2 : public Gt_base { private: typedef Segment_Voronoi_diagram_traits_wrapper_2 Self; public: struct Triangle_2 {}; Segment_Voronoi_diagram_traits_wrapper_2() {} Segment_Voronoi_diagram_traits_wrapper_2 (const Self&) {} Segment_Voronoi_diagram_traits_wrapper_2 operator=(const Self&) { return (*this); } Segment_Voronoi_diagram_traits_wrapper_2(const Gt_base&) {} }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_WRAPPER_2_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partitioned_polygon_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partitioned_polygon_2.0000644000175000017500000003042311344301500031275 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partitioned_polygon_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITIONED_POLYGON_2_H #define CGAL_PARTITIONED_POLYGON_2_H #include #include #include namespace CGAL { // this will order the diagonals around a vertex from previous to // next, which means a CW order if the polygon vertices are in CCW order template class Indirect_CW_diag_compare { public: typedef typename Traits::Point_2 Point_2; typedef typename Traits::Orientation_2 Orig_orientation; Indirect_CW_diag_compare(){} Indirect_CW_diag_compare(Point_2 vertex, Iterator prev_ref, Iterator next_ref) : _orientation(Traits().orientation_2_object()), _vertex(vertex), _prev_v_ref(prev_ref) { _vertex_orientation = _orientation(*_prev_v_ref, vertex, *next_ref); } bool operator()(Iterator d1, Iterator d2) { Orientation d1_orientation = _orientation(*_prev_v_ref, _vertex, *d1); Orientation d2_orientation = _orientation(*_prev_v_ref, _vertex, *d2); Orientation d1_to_d2 = _orientation(*d1, _vertex, *d2); // if both diagonals are on the same side of the line from previous // vertex to this vertex then d1 comes before d2 (in CW order from // the edge (previous, vertex)) if one makes a left turn from d1 to d2 if (d1_orientation == d2_orientation) return (d1_to_d2 == LEFT_TURN); // if d1 is on the line containing the edge (previous, vertex), then // the vertex must be a reflex vertex (otherwise the diagonal would // go outside the polygon) and d1 comes first if d2 is above the line // containing the three points, i.e., if it turns in the same // direction as the original edges around vertex. if (d1_orientation == COLLINEAR) return (d2_orientation == _vertex_orientation); // opposite sides of the line containing the previous edge // (again, vertex must be reflex) or d2 is collinear and d1 isn't. // In either case, d1 comes first if it is below the line containing // the previous edge. return (d1_orientation != _vertex_orientation); } private: Orig_orientation _orientation; Point_2 _vertex; Iterator _prev_v_ref; Orientation _vertex_orientation; }; template class Partition_vertex; // // requires // Traits::Polygon_2 // Traits::Point_2 // Traits::Left_turn_2 // Traits::Orientation_2 // template class Partitioned_polygon_2 : public CGALi::vector< Partition_vertex< Traits_ > > { public: typedef Traits_ Traits; typedef Partition_vertex Vertex; typedef typename CGALi::vector< Vertex >::iterator Iterator; typedef Circulator_from_iterator Circulator; typedef typename Traits::Polygon_2 Subpolygon_2; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef std::list Diagonal_list; typedef typename Diagonal_list::iterator Diagonal_iterator; Partitioned_polygon_2() : _left_turn(Traits().left_turn_2_object()) { } template Partitioned_polygon_2(InputIterator first, InputIterator beyond) : _left_turn(Traits().left_turn_2_object()) { for (; first != beyond; first++) { push_back(Vertex(*first)); } } void insert_diagonal(Circulator v1_ref, Circulator v2_ref) { (*v1_ref).insert_diagonal(v2_ref); (*v2_ref).insert_diagonal(v1_ref); } void prune_diagonals() { Circulator first(this->begin(), this->end(), this->begin()); Circulator c = first; Diagonal_iterator d; #ifdef CGAL_PARTITIONED_POLY_DEBUG std::cout << "pruning diagonals ..." << std::endl; #endif do { d = (*c).diagonals_begin(); while (d != (*c).diagonals_end()) { if (!diagonal_is_necessary(c, *d)) { #ifdef CGAL_PARTITIONED_POLY_DEBUG std::cout << " removing from " << *c << " to " << **d << std::endl; #endif (**d).diagonal_erase(c); d = (*c).diagonal_erase(d); } else { d++; } } #ifdef CGAL_PARTITIONED_POLY_DEBUG (*c).print_diagonals(); #endif (*c).reset_current_diagonal(); } while (++c != first); } // the pruning is probably no longer necessary template OutputIterator partition(OutputIterator result, bool prune) { // walk through each vertex and sort the diagonals Circulator first(this->begin(), this->end()); Circulator c = first; Circulator next; Circulator prev = c; prev--; do { next = c; next++; (*c).sort_diagonals(prev, next); #ifdef CGAL_PARTITIONED_POLY_DEBUG (*c).print_diagonals(); #endif prev = c; } while (++c != first); // now remove any diagonals that do not cut a reflex angle at one end if (prune) prune_diagonals(); #ifdef CGAL_PARTITIONED_POLY_DEBUG c = first; do { (*c).print_diagonals(); } while (++c != first); #endif make_polygon(first, result); return result; } private: template Circulator make_polygon(Circulator start, OutputIterator& result) { Subpolygon_2 new_polygon; Circulator next = start; do { new_polygon.push_back(*next); #ifdef CGAL_PARTITIONED_POLY_DEBUG std::cout << "adding vertex " << *next << std::endl; #endif Circulator diag; if ((*next).has_unused_diagonals()) { diag = (*next).current_diagonal(); #ifdef CGAL_PARTITIONED_POLY_DEBUG std::cout << "diagonal endpoint: " << *diag << std::endl; #endif (*next).advance_diagonal(); if (diag == start) { *result = new_polygon; result++; return next; } else { next = make_polygon(next, result); } } else next++; } while (next != start); *result = new_polygon; result++; return next; // if there are no diagonals at this vertex // push on the vertex // else if the first diagonal closes the polygon // close the polygon // return the current vertex (NOT the other end of the diagonal) // else // remove the first diagonal // recur, starting a new polygon at this vertex and return the // vertex where the new polygon ended // continue from the last vertex of the new polygon } bool cuts_reflex_angle(Circulator vertex_ref, Circulator diag_endpoint) { Circulator prev = vertex_ref; prev--; Circulator next = vertex_ref; next++; // find diag_endpoint in vertex_ref's list of diagonals Diagonal_iterator d_it; for (d_it = (*vertex_ref).diagonals_begin(); d_it != (*vertex_ref).diagonals_end() && diag_endpoint != *d_it; d_it++) { prev = *d_it; } Diagonal_iterator next_d_it = d_it; next_d_it++; if (next_d_it == (*vertex_ref).diagonals_end()) { next = vertex_ref; next++; } else next = *next_d_it; // return _right_turn(*prev, *vertex_ref, *next); return _left_turn(*vertex_ref, *prev, *next); } bool diagonal_is_necessary(Circulator diag_ref1, Circulator diag_ref2) { return (cuts_reflex_angle(diag_ref1, diag_ref2) || cuts_reflex_angle(diag_ref2, diag_ref1)); } Left_turn_2 _left_turn; }; template class Partition_vertex : public Traits_::Point_2 { public: typedef Traits_ Traits; typedef typename Traits::Point_2 Base_point; typedef typename Partitioned_polygon_2< Traits >::Circulator Circulator; typedef Partition_vertex Self; // // It might be better if this were a set that used Indirect_CW_diag_compare // as the Compare object, but the constructor for Indirect_CW_diag_compare // requires prev and next pointers, which would have to be supplied to // the constructor for a Partition_vertex as well, which is difficult to // do (perhaps impossible in general since you don't know what next and // previous will be until the whole polygon is constructed) // typedef std::list Diagonal_list; typedef typename Diagonal_list::iterator Diagonal_iterator; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES static Indirect_CW_diag_compare indirect_cw_diag_compare; static bool compare(const Circulator& circ1, const Circulator& circ2) { return indirect_cw_diag_compare(circ1, circ2); } #endif Partition_vertex(Base_point p): Base_point(p) {} void insert_diagonal(Circulator v_ref) { diag_endpoint_refs.push_back(v_ref); } Diagonal_iterator diagonal_erase(Diagonal_iterator d_ref) { return diag_endpoint_refs.erase(d_ref); } Diagonal_iterator diagonal_erase(Circulator diag_endpoint) { Diagonal_iterator d_it = diagonals_begin(); for (d_it = diagonals_begin(); d_it != diagonals_end() && *d_it != diag_endpoint; d_it++); if (d_it != diagonals_end()) return diag_endpoint_refs.erase(d_it); return d_it; } Diagonal_iterator diagonals_begin() { return diag_endpoint_refs.begin(); } Diagonal_iterator diagonals_end() { return diag_endpoint_refs.end(); } bool has_unused_diagonals( ) { return current_diag != diag_endpoint_refs.end(); } // sort the diagonals ccw around the point they have in common // and remove any duplicate diagonals void sort_diagonals(const Circulator& prev, const Circulator& next) { #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES indirect_cw_diag_compare = Indirect_CW_diag_compare(*this, prev, next); diag_endpoint_refs.sort(&Self::compare); #else diag_endpoint_refs.sort(Indirect_CW_diag_compare(*this, prev, next)); #endif diag_endpoint_refs.unique(); current_diag = diag_endpoint_refs.begin(); } void reset_current_diagonal( ) { current_diag = diag_endpoint_refs.begin(); } Circulator current_diagonal( ) const { return *current_diag; } void advance_diagonal() { if (current_diag != diag_endpoint_refs.end()) current_diag++; } void print_diagonals( ) const { std::cout << "from " << *this << std::endl; typename std::list::const_iterator it; for (it = diag_endpoint_refs.begin();it != diag_endpoint_refs.end(); it++) { std::cout << " to " << **it << std::endl; } } private: Diagonal_list diag_endpoint_refs; Diagonal_iterator current_diag; }; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES template Indirect_CW_diag_compare::Circulator,Traits> Partition_vertex::indirect_cw_diag_compare; #endif } #endif // CGAL_PARTITIONED_POLYGON_2_H ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions_on_weighted_points_cartesian_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions_on_weigh0000644000175000017500000000541111344301500031540 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/constructions_on_weighted_points_cartesian_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Julia Flototto, Mariette Yvinec #ifndef CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_CARTESIAN_2_H #define CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_CARTESIAN_2_H //#include CGAL_BEGIN_NAMESPACE template < class RT > void weighted_circumcenter_translateC2(const RT &dqx, const RT &dqy, const RT &dqw, const RT &drx, const RT &dry, const RT &drw, RT &dcx, RT &dcy) { // Given 3 points P, Q, R, this function takes as input: // qx-px, qy-py,qw-pw, rx-px, ry-py, rw-pw. And returns cx-px, cy-py, // where (cx, cy) are the coordinates of the circumcenter C. // What we do is intersect the radical axis RT r2 = CGAL_NTS square(drx) + CGAL_NTS square(dry) - drw; RT q2 = CGAL_NTS square(dqx) + CGAL_NTS square(dqy) - dqw; RT den = RT(2) * det2x2_by_formula(dqx, dqy, drx, dry); // The 3 points aren't collinear. // Hopefully, this is already checked at the upper level. CGAL_assertion ( den != RT(0) ); // One possible optimization here is to precompute 1/den, to avoid one // division. However, we loose precision, and it's maybe not worth it (?). dcx = det2x2_by_formula (dry, dqy, r2, q2) / den; dcy = - det2x2_by_formula (drx, dqx, r2, q2) / den; } //template < class RT > template < class RT, class We> void weighted_circumcenterC2( const RT &px, const RT &py, const We &pw, const RT &qx, const RT &qy, const We &qw, const RT &rx, const RT &ry, const We &rw, RT &x, RT &y ) { RT dqw = RT(qw-pw); RT drw = RT(rw-pw); weighted_circumcenter_translateC2(qx-px, qy-py, dqw,rx-px, ry-py,drw,x, y); x += px; y += py; } template < class RT , class We> void radical_axisC2(const RT &px, const RT &py, const We &pw, const RT &qx, const RT &qy, const We &qw, RT &a, RT &b, RT& c ) { a = RT(2)*(px - qx); b = RT(2)*(py - qy); c = - CGAL_NTS square(px) - CGAL_NTS square(py) + CGAL_NTS square(qx) + CGAL_NTS square(qy) +RT(pw) - RT(qw); } CGAL_END_NAMESPACE #endif //CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_CARTESIAN_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Fuzzy_iso_box.h0000644000175000017500000000671011344301500030046 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Fuzzy_iso_box.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_FUZZY_ISO_BOX_H #define CGAL_FUZZY_ISO_BOX_H #include namespace CGAL { template class Fuzzy_iso_box{ public: typedef typename SearchTraits::Point_d Point_d; typedef typename SearchTraits::Iso_box_d Iso_box_d; typedef typename SearchTraits::FT FT; typedef typename SearchTraits::Construct_min_vertex_d Construct_min_vertex_d; typedef typename SearchTraits::Construct_max_vertex_d Construct_max_vertex_d; typedef typename SearchTraits::Cartesian_const_iterator_d Cartesian_const_iterator_d; typedef typename SearchTraits::Construct_cartesian_const_iterator_d Construct_cartesian_const_iterator_d; private: Point_d min, max; Cartesian_const_iterator_d min_begin, max_begin; FT eps; unsigned int dim; public: // default constructor Fuzzy_iso_box() {} // constructor Fuzzy_iso_box(const Point_d& p, const Point_d& q, FT epsilon=FT(0)) : eps(epsilon) { Construct_cartesian_const_iterator_d construct_it; Cartesian_const_iterator_d begin = construct_it(p), end = construct_it(p,1); dim = end - begin; Iso_box_d box = typename SearchTraits::Construct_iso_box_d()(p,q); Construct_min_vertex_d construct_min_vertex_d; Construct_max_vertex_d construct_max_vertex_d; min = construct_min_vertex_d(box); max = construct_max_vertex_d(box); min_begin = construct_it(min); max_begin = construct_it(max); } bool contains(const Point_d& p) const { Construct_cartesian_const_iterator_d construct_it; Cartesian_const_iterator_d pit = construct_it(p); Cartesian_const_iterator_d minit= min_begin, maxit = max_begin; for (unsigned int i = 0; i < dim; ++i, ++pit, ++minit, ++maxit) { if ( ((*pit) < (*minit)) || ((*pit) >= (*maxit)) ) return false; } return true; } bool inner_range_intersects(const Kd_tree_rectangle& rectangle) const { Cartesian_const_iterator_d minit= min_begin, maxit = max_begin; for (unsigned int i = 0; i < dim; ++i, ++minit, ++maxit) { if ( ((*maxit)-eps < rectangle.min_coord(i)) || ((*minit)+eps >= rectangle.max_coord(i)) ) return false; } return true; } bool outer_range_contains(const Kd_tree_rectangle& rectangle) const { Cartesian_const_iterator_d minit= min_begin, maxit = max_begin; for (unsigned int i = 0; i < dim; ++i, ++minit, ++maxit) { if ( ((*maxit)+eps < rectangle.max_coord(i) ) || ((*minit)-eps >= rectangle.min_coord(i)) ) return false; } return true; } }; // class Fuzzy_iso_box } // namespace CGAL #endif // FUZZY_ISO_BOX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/polygon_assertions.h0000644000175000017500000003273111344301500031140 0ustar debiandebian // Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/polygon_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : script by Geert-Jan Giezeman and Sven Schoenherr // macro definitions // ================= // assertions // ---------- #if defined(CGAL_POLYGON_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_polygon_assertion(EX) (static_cast(0)) # define CGAL_polygon_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_assertion_code(CODE) #else # define CGAL_polygon_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_assertion_code(CODE) CODE #endif // CGAL_POLYGON_NO_ASSERTIONS #if defined(CGAL_POLYGON_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_polygon_exactness_assertion(EX) (static_cast(0)) # define CGAL_polygon_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_exactness_assertion_code(CODE) #else # define CGAL_polygon_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_exactness_assertion_code(CODE) CODE #endif // CGAL_POLYGON_NO_ASSERTIONS #if defined(CGAL_POLYGON_NO_ASSERTIONS) \ || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_assertion(EX) (static_cast(0)) # define CGAL_polygon_expensive_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_assertion_code(CODE) #else # define CGAL_polygon_expensive_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_assertion_code(CODE) CODE #endif // CGAL_POLYGON_NO_ASSERTIONS #if defined(CGAL_POLYGON_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_exactness_assertion(EX) (static_cast(0)) # define CGAL_polygon_expensive_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_exactness_assertion_code(CODE) #else # define CGAL_polygon_expensive_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_exactness_assertion_code(CODE) CODE #endif // CGAL_POLYGON_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_POLYGON_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_polygon_precondition(EX) (static_cast(0)) # define CGAL_polygon_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_precondition_code(CODE) #else # define CGAL_polygon_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_precondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_PRECONDITIONS #if defined(CGAL_POLYGON_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_polygon_exactness_precondition(EX) (static_cast(0)) # define CGAL_polygon_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_exactness_precondition_code(CODE) #else # define CGAL_polygon_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_exactness_precondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_PRECONDITIONS #if defined(CGAL_POLYGON_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_precondition(EX) (static_cast(0)) # define CGAL_polygon_expensive_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_precondition_code(CODE) #else # define CGAL_polygon_expensive_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_precondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_PRECONDITIONS #if defined(CGAL_POLYGON_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_exactness_precondition(EX) (static_cast(0)) # define CGAL_polygon_expensive_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_exactness_precondition_code(CODE) #else # define CGAL_polygon_expensive_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_exactness_precondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_POLYGON_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_polygon_postcondition(EX) (static_cast(0)) # define CGAL_polygon_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_postcondition_code(CODE) #else # define CGAL_polygon_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_postcondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_POSTCONDITIONS #if defined(CGAL_POLYGON_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_polygon_exactness_postcondition(EX) (static_cast(0)) # define CGAL_polygon_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_exactness_postcondition_code(CODE) #else # define CGAL_polygon_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_exactness_postcondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_POSTCONDITIONS #if defined(CGAL_POLYGON_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_postcondition(EX) (static_cast(0)) # define CGAL_polygon_expensive_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_postcondition_code(CODE) #else # define CGAL_polygon_expensive_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_postcondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_POSTCONDITIONS #if defined(CGAL_POLYGON_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_exactness_postcondition(EX) (static_cast(0)) # define CGAL_polygon_expensive_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_exactness_postcondition_code(CODE) #else # define CGAL_polygon_expensive_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_exactness_postcondition_code(CODE) CODE #endif // CGAL_POLYGON_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_POLYGON_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_polygon_warning(EX) (static_cast(0)) # define CGAL_polygon_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_warning_code(CODE) #else # define CGAL_polygon_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_warning_code(CODE) CODE #endif // CGAL_POLYGON_NO_WARNINGS #if defined(CGAL_POLYGON_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_polygon_exactness_warning(EX) (static_cast(0)) # define CGAL_polygon_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_exactness_warning_code(CODE) #else # define CGAL_polygon_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_exactness_warning_code(CODE) CODE #endif // CGAL_POLYGON_NO_WARNINGS #if defined(CGAL_POLYGON_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_warning(EX) (static_cast(0)) # define CGAL_polygon_expensive_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_warning_code(CODE) #else # define CGAL_polygon_expensive_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_warning_code(CODE) CODE #endif // CGAL_POLYGON_NO_WARNINGS #if defined(CGAL_POLYGON_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_POLYGON_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_POLYGON_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_polygon_expensive_exactness_warning(EX) (static_cast(0)) # define CGAL_polygon_expensive_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_polygon_expensive_exactness_warning_code(CODE) #else # define CGAL_polygon_expensive_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_polygon_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_polygon_expensive_exactness_warning_code(CODE) CODE #endif // CGAL_POLYGON_NO_WARNINGS ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_circulators_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_circu0000644000175000017500000004033111344301501031440 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_circulators_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec // Menelaos Karavelas #ifndef CGAL_TRIANGULATION_DS_CIRCULATORS_2_H #define CGAL_TRIANGULATION_DS_CIRCULATORS_2_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Tds> class Triangulation_ds_face_circulator_2 : public Bidirectional_circulator_base< typename Tds::Face, CGAL_CLIB_STD::ptrdiff_t, CGAL_CLIB_STD::size_t>, public Triangulation_cw_ccw_2 { private: typedef Bidirectional_circulator_base< typename Tds::Face, CGAL_CLIB_STD::ptrdiff_t, CGAL_CLIB_STD::size_t> Base_circulator; public: typedef Triangulation_ds_face_circulator_2 Face_circulator; typedef typename Tds::Face Face; typedef typename Tds::Vertex Vertex; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Vertex_handle Vertex_handle; private: Vertex_handle _v; Face_handle pos; public: Triangulation_ds_face_circulator_2() : _v(), pos() {} Triangulation_ds_face_circulator_2(Vertex_handle v, Face_handle f = Face_handle()); // MK: added to satisfy the mips CC 7.40 compiler Face_circulator& operator=(const Face_circulator& other); Face_circulator& operator++(); Face_circulator operator++(int); Face_circulator& operator--(); Face_circulator operator--(int); bool operator==(const Face_circulator &fc) const; bool operator!=(const Face_circulator &fc) const; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE bool operator==(const Face_handle &fh) const { return pos == fh; } bool operator!=(const Face_handle &fh) const { return pos != fh; } #endif bool is_empty() const; bool operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; bool operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; Face& operator*() const { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); return *pos; } Face* operator->() const { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); return &*pos; } Face_handle base() const {return pos;} #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE operator Face_handle() const {return pos;} #endif }; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE template < class Tds_ > bool operator==(typename Tds_::Face_handle fh, Triangulation_ds_face_circulator_2 fc) { return (fc==fh); } template < class Tds_ > bool operator!=(typename Tds_::Face_handle fh, Triangulation_ds_face_circulator_2 fc) { return (fc!=fh); } #endif template < class Tds > class Triangulation_ds_vertex_circulator_2 : public Bidirectional_circulator_base< typename Tds::Vertex, CGAL_CLIB_STD::ptrdiff_t, CGAL_CLIB_STD::size_t>, public Triangulation_cw_ccw_2 #ifdef CGAL_CFG_CONVERSION_OPERATOR_BUG // To work around the bug with the conversion operator, // we replace it by storing a vertex_handle as a base class, // so that we effectively get automatic conversion. , public Tds::Vertex_handle #endif { public: typedef Triangulation_ds_vertex_circulator_2 Vertex_circulator; typedef typename Tds::Face Face; typedef typename Tds::Vertex Vertex; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Vertex_handle Vertex_handle; private: Vertex_handle _v; Face_handle pos; int _ri; void update_base() { #ifdef CGAL_CFG_CONVERSION_OPERATOR_BUG static_cast(*this) = pos->vertex(_ri); #endif } public: Triangulation_ds_vertex_circulator_2() : _v(), pos() {} Triangulation_ds_vertex_circulator_2(Vertex_handle v, Face_handle f = Face_handle()); Vertex_circulator& operator++(); Vertex_circulator operator++(int); Vertex_circulator& operator--(); Vertex_circulator operator--(int); bool operator==(const Vertex_circulator &vc) const; bool operator!=(const Vertex_circulator &vc) const; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE bool operator==(const Vertex_handle &vh) const { return pos->vertex(_ri) == vh; } bool operator!=(const Vertex_handle &vh) const { return pos->vertex(_ri) != vh; } #endif bool is_empty() const; bool operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; bool operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; Vertex& operator*() const { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); return *(pos->vertex(_ri)); } Vertex* operator->() const { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); return &*(pos->vertex(_ri)); } Vertex_handle base() const {return pos->vertex(_ri);} #if defined CGAL_T2_USE_ITERATOR_AS_HANDLE && \ !defined CGAL_CFG_CONVERSION_OPERATOR_BUG operator Vertex_handle() const {return pos->vertex(_ri);} #endif }; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE template < class Tds_ > inline bool operator==(typename Tds_::Vertex_handle vh, Triangulation_ds_vertex_circulator_2 vc) { return (vc==vh); } template < class Tds_ > inline bool operator!=(typename Tds_::Vertex_handle vh, Triangulation_ds_vertex_circulator_2 vc) { return !(vc==vh); } #endif template < class Tds > class Triangulation_ds_edge_circulator_2 : public Bidirectional_circulator_base < typename Tds::Edge, CGAL_CLIB_STD::ptrdiff_t, CGAL_CLIB_STD::size_t>, public Triangulation_cw_ccw_2 { public: typedef Triangulation_ds_edge_circulator_2 Edge_circulator; typedef typename Tds::Face Face; typedef typename Tds::Vertex Vertex; typedef typename Tds::Edge Edge; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Vertex_handle Vertex_handle; private: int _ri; Vertex_handle _v; Face_handle pos; mutable Edge edge; public: Triangulation_ds_edge_circulator_2() : _v(), pos() {} Triangulation_ds_edge_circulator_2( Vertex_handle v, Face_handle f = Face_handle()); Edge_circulator& operator++(); Edge_circulator operator++(int); Edge_circulator& operator--(); Edge_circulator operator--(int); bool operator==(const Edge_circulator &vc) const; bool operator!=(const Edge_circulator &vc) const; bool is_empty() const; bool operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; bool operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; Edge* operator->() const { edge.first=pos; edge.second= _ri; return &edge; } Edge& operator*() const { edge.first=pos; edge.second= _ri; return edge; } }; template < class Tds > Triangulation_ds_face_circulator_2 :: Triangulation_ds_face_circulator_2(Vertex_handle v, Face_handle f) : _v(v), pos(f) { if (_v == Vertex_handle()) pos = Face_handle(); else if ( pos == Face_handle()) pos = v->face(); if (pos == Face_handle()|| pos->dimension() < 2) { _v = Vertex_handle() ; pos = Face_handle(); return;} else CGAL_triangulation_precondition( pos->has_vertex(v)); } template < class Tds > Triangulation_ds_face_circulator_2& Triangulation_ds_face_circulator_2 :: operator=(const Face_circulator& other) { static_cast(*this) = static_cast (other); _v = other._v; pos = other.pos; return *this; } template < class Tds > Triangulation_ds_face_circulator_2& Triangulation_ds_face_circulator_2 :: operator++() { CGAL_triangulation_precondition( pos != Face_handle() && _v != Vertex_handle()); int i = pos->index(_v); pos = pos->neighbor(ccw(i)); return *this; } template < class Tds > Triangulation_ds_face_circulator_2 Triangulation_ds_face_circulator_2 :: operator++(int) { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); Face_circulator tmp(*this); ++(*this); return tmp; } template < class Tds > Triangulation_ds_face_circulator_2& Triangulation_ds_face_circulator_2 :: operator--() { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); int i = pos->index(_v); pos = pos->neighbor(cw(i)); return *this; } template < class Tds > Triangulation_ds_face_circulator_2 Triangulation_ds_face_circulator_2 :: operator--(int) { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); Face_circulator tmp(*this); --(*this); return tmp; } template < class Tds > inline bool Triangulation_ds_face_circulator_2 :: operator==(const Face_circulator &fc) const { return (_v == fc._v) && (pos == fc.pos); } template < class Tds > inline bool Triangulation_ds_face_circulator_2 :: operator!=(const Face_circulator &fc) const { return ! (*this == fc); } template < class Tds > inline bool Triangulation_ds_face_circulator_2 :: is_empty() const { return (_v == Vertex_handle() || pos == Face_handle() ); } template < class Tds > inline bool Triangulation_ds_face_circulator_2 :: operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return (_v == Vertex_handle() || pos == Face_handle() ); } template < class Tds > inline bool Triangulation_ds_face_circulator_2 :: operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return ! (*this == NULL); } template < class Tds > Triangulation_ds_vertex_circulator_2 :: Triangulation_ds_vertex_circulator_2 (Vertex_handle v, Face_handle f) : _v( v ), pos(f) { if (_v == Vertex_handle()) { pos = Face_handle();} else if (pos == Face_handle()) {pos = v->face();} if (pos == Face_handle() || pos->dimension() < 1){ _v = Vertex_handle(); pos = Face_handle(); return;} int i = pos->index(_v); if (pos->dimension() == 2) {_ri = ccw(i);} else {_ri = 1-i;} update_base(); return; } template < class Tds > Triangulation_ds_vertex_circulator_2& Triangulation_ds_vertex_circulator_2 :: operator++() { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); int i = pos->index(_v); if (pos->dimension() == 1) { pos = pos->neighbor(1-i); _ri = 1 - pos->index(_v); } else{ pos = pos->neighbor(ccw(i)); i = pos->index(_v); _ri = ccw(i); } update_base(); return *this; } template < class Tds > Triangulation_ds_vertex_circulator_2 Triangulation_ds_vertex_circulator_2 :: operator++(int) { Vertex_circulator tmp(*this); ++(*this); return tmp; } template < class Tds > Triangulation_ds_vertex_circulator_2& Triangulation_ds_vertex_circulator_2 :: operator--() { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); int i = pos->index(_v); if (pos->dimension() == 1) { pos = pos->neighbor(1-i); _ri = 1 - pos->index(_v); } else{ pos = pos->neighbor(cw(i)); i = pos->index(_v); _ri = ccw(i); } update_base(); return *this; } template < class Tds > Triangulation_ds_vertex_circulator_2 Triangulation_ds_vertex_circulator_2 :: operator--(int) { Vertex_circulator tmp(*this); --(*this); return tmp; } template < class Tds > inline bool Triangulation_ds_vertex_circulator_2 :: operator==(const Vertex_circulator &vc) const { return (_v == vc._v) && (_ri == vc._ri) && (pos == vc.pos); } template < class Tds > inline bool Triangulation_ds_vertex_circulator_2 :: operator!=(const Vertex_circulator &vc) const { return ! (*this == vc); } template < class Tds > inline bool Triangulation_ds_vertex_circulator_2 :: is_empty() const { return (_v == Vertex_handle() || pos == Face_handle()); } template < class Tds > inline bool Triangulation_ds_vertex_circulator_2 :: operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return (_v == Vertex_handle() || pos == Face_handle()); } template < class Tds > inline bool Triangulation_ds_vertex_circulator_2 :: operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return !(*this == NULL); } template < class Tds > Triangulation_ds_edge_circulator_2 :: Triangulation_ds_edge_circulator_2(Vertex_handle v, Face_handle f) : _v(v), pos(f) { if (_v == Vertex_handle()) { pos = Face_handle();} else if (pos==Face_handle()) {pos = v->face();} if (pos == Face_handle() || pos->dimension() < 1){ _v = Vertex_handle(); pos = Face_handle();return;} int i = pos->index(_v); if (pos->dimension() == 2) {_ri = ccw(i);} else {_ri = 2;} return; } template < class Tds > Triangulation_ds_edge_circulator_2& Triangulation_ds_edge_circulator_2 :: operator++() { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); int i = pos->index(_v); if (pos->dimension() == 1) { pos = pos->neighbor(1-i); return *this; } else{ pos = pos->neighbor(ccw(i)); i = pos->index(_v); _ri = ccw(i); } return *this; } template < class Tds > Triangulation_ds_edge_circulator_2 Triangulation_ds_edge_circulator_2 :: operator++(int) { Edge_circulator tmp(*this); ++(*this); return tmp; } template < class Tds > Triangulation_ds_edge_circulator_2& Triangulation_ds_edge_circulator_2 :: operator--() { CGAL_triangulation_precondition(pos != Face_handle() && _v != Vertex_handle()); int i = pos->index(_v); if (pos->dimension() == 1) { pos = pos->neighbor(1-i); return *this; } else{ pos = pos->neighbor(cw(i)); i = pos->index(_v); _ri = ccw(i); } return *this; } template < class Tds > Triangulation_ds_edge_circulator_2 Triangulation_ds_edge_circulator_2 :: operator--(int) { Edge_circulator tmp(*this); --(*this); return tmp; } template < class Tds > inline bool Triangulation_ds_edge_circulator_2 :: operator==(const Edge_circulator &vc) const { return (_v == vc._v) && (_ri == vc._ri) && (pos == vc.pos); } template < class Tds > inline bool Triangulation_ds_edge_circulator_2 :: operator!=(const Edge_circulator &vc) const { return ! (*this == vc); } template < class Tds > inline bool Triangulation_ds_edge_circulator_2 :: is_empty() const { return (_v == Vertex_handle() || pos == Face_handle()); } template < class Tds > inline bool Triangulation_ds_edge_circulator_2 :: operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return (_v == Vertex_handle() || pos == Face_handle()); } template < class Tds > inline bool Triangulation_ds_edge_circulator_2 :: operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return !(*this == NULL); } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_DS_CIRCULATORS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_tree_k.h0000644000175000017500000003315311344301500030131 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_tree_k.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef __CGAL_Segment_tree_pre__ #define __CGAL_Segment_tree_pre__ // Predefined k-dimensional Segment Trees (k=1..4) // The trees can either be templated with d arbitrary types // (e.g., Segment_tree_3) // or with an unary type for each dimension // (e.g., Segment_tree_uni_4). // The container class and sequence container class as well as the // data accessors are defined in these classes. #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Segment_tree_1 { public: typedef C_Traits_1 Traits; typedef typename C_Traits_1::Key Key; typedef typename C_Traits_1::Interval Interval; typedef typename C_Traits_1::Key_1 Key_1; typedef typename C_Traits_1::key_1 key_1; typedef typename C_Traits_1::low_1 low_1; typedef typename C_Traits_1::high_1 high_1; typedef typename C_Traits_1::compare_1 compare_1; typedef tree_interval_traits I1; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; Segment_tree_1_type * segment_tree_1; Segment_tree_1() : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)) {} template Segment_tree_1(const T& first, const T& last) : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)) { segment_tree_1->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete segment_tree_1; delete anchor; anchor = new Tree_anchor_type; segment_tree_1 = new Segment_tree_1_type(*anchor); return segment_tree_1->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return segment_tree_1->window_query(win, result); } template T enclosing_query(Interval const &win, const T& result) { return segment_tree_1->enclosing_query(win, result); } ~Segment_tree_1() { if (segment_tree_1!=0) delete segment_tree_1; if (anchor!=0) delete anchor; } }; //------------------------------------------------------------------- // A two dimensional Segment Tree is defined in this class. // Ti is the type of each dimension of the tree. template class Segment_tree_2 { public: typedef C_Traits_2 Traits; typedef typename C_Traits_2::Key Key; typedef typename C_Traits_2::Interval Interval; typedef typename C_Traits_2::Key_2 Key_2; typedef typename C_Traits_2::Key_1 Key_1; typedef typename C_Traits_2::key_1 key_1; typedef typename C_Traits_2::key_2 key_2; typedef typename C_Traits_2::low_1 low_1; typedef typename C_Traits_2::high_1 high_1; typedef typename C_Traits_2::low_2 low_2; typedef typename C_Traits_2::high_2 high_2; typedef typename C_Traits_2::compare_1 compare_1; typedef typename C_Traits_2::compare_2 compare_2; typedef typename std::list::iterator l_iterator; typedef typename std::vector::iterator v_iterator; typedef tree_interval_traits I1; typedef tree_interval_traits I2; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; Segment_tree_1_type * segment_tree_1; typedef Segment_tree_d Segment_tree_2_type; Segment_tree_2_type *segment_tree_2; Segment_tree_2() : anchor( new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)) {} template Segment_tree_2(const T& first, const T& last) : anchor( new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)) { segment_tree_2->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete segment_tree_2; delete segment_tree_1; delete anchor; anchor = new Tree_anchor_type; segment_tree_1 = new Segment_tree_1_type(*anchor); segment_tree_2 = new Segment_tree_2_type(*segment_tree_1); return segment_tree_2->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return segment_tree_2->window_query(win, result); } template T enclosing_query(Interval const &win, const T& result) { return segment_tree_2->enclosing_query(win, result); } ~Segment_tree_2() { if (segment_tree_2!=0) delete segment_tree_2; if (segment_tree_1!=0) delete segment_tree_1; if (anchor!=0) delete anchor; } }; //------------------------------------------------------------------- // A three dimensional Segment Tree is defined in this class. // Ti is the type of each dimension of the tree. template class Segment_tree_3 { public: typedef C_Traits_3 Traits; typedef typename C_Traits_3::Key Key; typedef typename C_Traits_3::Interval Interval; typedef typename C_Traits_3::Key_1 Key_1; typedef typename C_Traits_3::Key_2 Key_2; typedef typename C_Traits_3::Key_3 Key_3; typedef typename C_Traits_3::key_1 key_1; typedef typename C_Traits_3::key_2 key_2; typedef typename C_Traits_3::key_3 key_3; typedef typename C_Traits_3::low_1 low_1; typedef typename C_Traits_3::high_1 high_1; typedef typename C_Traits_3::low_2 low_2; typedef typename C_Traits_3::high_2 high_2; typedef typename C_Traits_3::low_3 low_3; typedef typename C_Traits_3::high_3 high_3; typedef typename C_Traits_3::compare_1 compare_1; typedef typename C_Traits_3::compare_2 compare_2; typedef typename C_Traits_3::compare_3 compare_3; typedef typename std::list::iterator l_iterator; typedef typename std::vector::iterator v_iterator; typedef tree_interval_traits I1; typedef tree_interval_traits I2; typedef tree_interval_traits I3; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; Segment_tree_1_type * segment_tree_1; typedef Segment_tree_d Segment_tree_2_type; Segment_tree_2_type *segment_tree_2; typedef Segment_tree_d Segment_tree_3_type; Segment_tree_3_type *segment_tree_3; Segment_tree_3() : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)), segment_tree_3(new Segment_tree_3_type(*segment_tree_2)) {} template Segment_tree_3(const T& first, const T& last) : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)), segment_tree_3(new Segment_tree_3_type(*segment_tree_2)) { segment_tree_3->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete segment_tree_3; delete segment_tree_2; delete segment_tree_1; delete anchor; anchor = new Tree_anchor_type; segment_tree_1 = new Segment_tree_1_type(*anchor); segment_tree_2 = new Segment_tree_2_type(*segment_tree_1); segment_tree_3 = new Segment_tree_3_type(*segment_tree_2); return segment_tree_3->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return (*segment_tree_3).window_query(win, result); } template T enclosing_query(Interval const &win, const T& result) { return (*segment_tree_3).enclosing_query(win, result); } ~Segment_tree_3() { if (segment_tree_3!=0) delete segment_tree_3; if (segment_tree_2!=0) delete segment_tree_2; if (segment_tree_1!=0) delete segment_tree_1; if (anchor!=0) delete anchor; } }; //------------------------------------------------------------------- // A three dimensional Segment Tree is defined in this class. // Ti is the type of each dimension of the tree. template class Segment_tree_4 { public: typedef C_Traits_4 Traits; typedef typename C_Traits_4::Key Key; typedef typename C_Traits_4::Interval Interval; typedef typename C_Traits_4::Key_1 Key_1; typedef typename C_Traits_4::Key_2 Key_2; typedef typename C_Traits_4::Key_3 Key_3; typedef typename C_Traits_4::Key_4 Key_4; typedef typename C_Traits_4::key_1 key_1; typedef typename C_Traits_4::key_2 key_2; typedef typename C_Traits_4::key_4 key_4; typedef typename C_Traits_4::key_3 key_3; typedef typename C_Traits_4::low_1 low_1; typedef typename C_Traits_4::high_1 high_1; typedef typename C_Traits_4::low_2 low_2; typedef typename C_Traits_4::high_2 high_2; typedef typename C_Traits_4::low_3 low_3; typedef typename C_Traits_4::high_3 high_3; typedef typename C_Traits_4::low_4 low_4; typedef typename C_Traits_4::high_4 high_4; typedef typename C_Traits_4::compare_1 compare_1; typedef typename C_Traits_4::compare_2 compare_2; typedef typename C_Traits_4::compare_3 compare_3; typedef typename C_Traits_4::compare_4 compare_4; typedef typename std::list::iterator l_iterator; typedef typename std::vector::iterator v_iterator; typedef tree_interval_traits I1; typedef tree_interval_traits I2; typedef tree_interval_traits I3; typedef tree_interval_traits I4; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Segment_tree_d Segment_tree_1_type; Segment_tree_1_type * segment_tree_1; typedef Segment_tree_d Segment_tree_2_type; Segment_tree_2_type *segment_tree_2; typedef Segment_tree_d Segment_tree_3_type; Segment_tree_3_type *segment_tree_3; typedef Segment_tree_d Segment_tree_4_type; Segment_tree_4_type *segment_tree_4; Segment_tree_4() : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)), segment_tree_3(new Segment_tree_3_type(*segment_tree_2)), segment_tree_4(new Segment_tree_4_type(*segment_tree_3)) {} template Segment_tree_4(const T& first, const T& last) : anchor(new Tree_anchor_type), segment_tree_1(new Segment_tree_1_type(*anchor)), segment_tree_2(new Segment_tree_2_type(*segment_tree_1)), segment_tree_3(new Segment_tree_3_type(*segment_tree_2)), segment_tree_4(new Segment_tree_4_type(*segment_tree_3)) { segment_tree_4->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete segment_tree_4; delete segment_tree_3; delete segment_tree_2; delete segment_tree_1; delete anchor; anchor = new Tree_anchor_type; segment_tree_1 = new Segment_tree_1_type(*anchor); segment_tree_2 = new Segment_tree_2_type(*segment_tree_1); segment_tree_3 = new Segment_tree_3_type(*segment_tree_2); segment_tree_4 = new Segment_tree_4_type(*segment_tree_3); return segment_tree_4->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return (*segment_tree_4).window_query(win, result); } template T enclosing_query(Interval const &win, const T& result) { return (*segment_tree_4).enclosing_query(win, result); } ~Segment_tree_4() { if (segment_tree_4!=0) delete segment_tree_4; if (segment_tree_3!=0) delete segment_tree_3; if (segment_tree_2!=0) delete segment_tree_2; if (segment_tree_1!=0) delete segment_tree_1; if (anchor!=0) delete anchor; } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Segment_3_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Segment_3_d0000644000175000017500000002433611344301501031152 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Segment_3_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_3_SEGMENT_3_DO_INTERSECT_H #define CGAL_TRIANGLE_3_SEGMENT_3_DO_INTERSECT_H CGAL_BEGIN_NAMESPACE namespace CGALi { template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t, const typename CGAL_WRAP(K)::Segment_3 &s, const K & k) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; CGAL_kernel_precondition( ! k.is_degenerate_3_object()(s) ) ; typedef typename K::Point_3 Point_3; typename K::Construct_point_on_3 point_on = k.construct_point_on_3_object(); typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Orientation_3 orientation = k.orientation_3_object(); const Point_3 & a = vertex_on(t,0); const Point_3 & b = vertex_on(t,1); const Point_3 & c = vertex_on(t,2); const Point_3 & p = point_on(s,0); const Point_3 & q = point_on(s,1); const Orientation abcp = orientation(a,b,c,p); const Orientation abcq = orientation(a,b,c,q); switch ( abcp ) { case POSITIVE: switch ( abcq ) { case POSITIVE: // the segment lies in the positive open halfspaces defined by the // triangle's supporting plane return false; case NEGATIVE: // p sees the triangle in counterclockwise order return orientation(p,q,a,b) != POSITIVE && orientation(p,q,b,c) != POSITIVE && orientation(p,q,c,a) != POSITIVE; case COPLANAR: // q belongs to the triangle's supporting plane // p sees the triangle in counterclockwise order return orientation(p,q,a,b) != POSITIVE && orientation(p,q,b,c) != POSITIVE && orientation(p,q,c,a) != POSITIVE; default: // should not happen. CGAL_kernel_assertion(false); return false; } case NEGATIVE: switch ( abcq ) { case POSITIVE: // q sees the triangle in counterclockwise order return orientation(q,p,a,b) != POSITIVE && orientation(q,p,b,c) != POSITIVE && orientation(q,p,c,a) != POSITIVE; case NEGATIVE: // the segment lies in the negative open halfspaces defined by the // triangle's supporting plane return false; case COPLANAR: // q belongs to the triangle's supporting plane // p sees the triangle in clockwise order return orientation(q,p,a,b) != POSITIVE && orientation(q,p,b,c) != POSITIVE && orientation(q,p,c,a) != POSITIVE; default: // should not happen. CGAL_kernel_assertion(false); return false; } case COPLANAR: // p belongs to the triangle's supporting plane switch ( abcq ) { case POSITIVE: // q sees the triangle in counterclockwise order return orientation(q,p,a,b) != POSITIVE && orientation(q,p,b,c) != POSITIVE && orientation(q,p,c,a) != POSITIVE; case NEGATIVE: // q sees the triangle in clockwise order return orientation(p,q,a,b) != POSITIVE && orientation(p,q,b,c) != POSITIVE && orientation(p,q,c,a) != POSITIVE; case COPLANAR: // the segment is coplanar with the triangle's supporting plane // we test whether the segment intersects the triangle in the common // supporting plane return do_intersect_coplanar(t,s,k); default: // should not happen. CGAL_kernel_assertion(false); return false; } default: // should not happen. CGAL_kernel_assertion(false); return false; } } template inline bool do_intersect(const typename CGAL_WRAP(K)::Segment_3 &s, const typename CGAL_WRAP(K)::Triangle_3 &t, const K & k) { return do_intersect(t, s, k); } template bool do_intersect_coplanar(const Triangle_3 &t, const Segment_3 &s, const K & k ) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; CGAL_kernel_precondition( ! k.is_degenerate_3_object()(s) ) ; typedef typename K::Point_3 Point_3; typename K::Construct_point_on_3 point_on = k.construct_point_on_3_object(); typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); const Point_3 & p = point_on(s,0); const Point_3 & q = point_on(s,1); const Point_3 & A = vertex_on(t,0); const Point_3 & B = vertex_on(t,1); const Point_3 & C = vertex_on(t,2); const Point_3 * a = &A; const Point_3 * b = &B; const Point_3 * c = &C; // Determine the orientation of the triangle in the common plane if (coplanar_orientation(A,B,C) != POSITIVE) { // The triangle is not counterclockwise oriented // swap two vertices. b = &C; c = &B; } // Test whether the segment's supporting line intersects the // triangle in the common plane const Orientation pqa = coplanar_orientation(p,q,*a); const Orientation pqb = coplanar_orientation(p,q,*b); const Orientation pqc = coplanar_orientation(p,q,*c); switch ( pqa ) { case POSITIVE: switch ( pqb ) { case POSITIVE: if (pqc == POSITIVE) return false; // the triangle lies in the positive halfspace // defined by the segment's supporting line. // c is isolated on the negative side return coplanar_orientation(*b,*c,q) != NEGATIVE && coplanar_orientation(*c,*a,p) != NEGATIVE ; case NEGATIVE: if (pqc == POSITIVE) // b is isolated on the negative side return coplanar_orientation(*a,*b,q) != NEGATIVE && coplanar_orientation(*b,*c,p) != NEGATIVE ; // a is isolated on the positive side return coplanar_orientation(*a,*b,q) != NEGATIVE && coplanar_orientation(*c,*a,p) != NEGATIVE ; case COLLINEAR: if (pqc == POSITIVE) // b is isolated on the negative side return coplanar_orientation(*a,*b,q) != NEGATIVE && coplanar_orientation(*b,*c,p) != NEGATIVE ; // a is isolated on the positive side return coplanar_orientation(*a,*b,q) != NEGATIVE && coplanar_orientation(*c,*a,p) != NEGATIVE ; default:// should not happen. CGAL_kernel_assertion(false); return false; } case NEGATIVE: switch ( pqb ) { case POSITIVE: if (pqc == POSITIVE) // a is isolated on the negative side return coplanar_orientation(*a,*b,p) != NEGATIVE && coplanar_orientation(*c,*a,q) != NEGATIVE ; // b is isolated on the positive side return coplanar_orientation(*a,*b,p) != NEGATIVE && coplanar_orientation(*b,*c,q) != NEGATIVE ; case NEGATIVE: if (pqc == NEGATIVE) return false; // the triangle lies in the negative halfspace // defined by the segment's supporting line. // c is isolated on the positive side return coplanar_orientation(*b,*c,p) != NEGATIVE && coplanar_orientation(*c,*a,q) != NEGATIVE ; case COLLINEAR: if (pqc == NEGATIVE) // b is isolated on the positive side return coplanar_orientation(*a,*b,p) != NEGATIVE && coplanar_orientation(*b,*c,q) != NEGATIVE ; // a is isolated on the negative side return coplanar_orientation(*a,*b,p) != NEGATIVE && coplanar_orientation(*c,*a,q) != NEGATIVE ; default:// should not happen. CGAL_kernel_assertion(false); return false; } case COLLINEAR: switch ( pqb ) { case POSITIVE: if (pqc == POSITIVE) // a is isolated on the negative side return coplanar_orientation(*a,*b,p) != NEGATIVE && coplanar_orientation(*c,*a,q) != NEGATIVE ; // b is isolated on the positive side return coplanar_orientation(*a,*b,p) != NEGATIVE && coplanar_orientation(*b,*c,q) != NEGATIVE ; case NEGATIVE: if (pqc == NEGATIVE) // a is isolated on the positive side return coplanar_orientation(*a,*b,q) != NEGATIVE && coplanar_orientation(*c,*a,p) != NEGATIVE ; // b is isolated on the negative side return coplanar_orientation(*a,*b,q) != NEGATIVE && coplanar_orientation(*b,*c,p) != NEGATIVE ; case COLLINEAR: if (pqc == POSITIVE) // c is isolated on the positive side return coplanar_orientation(*b,*c,p) != NEGATIVE && coplanar_orientation(*c,*a,q) != NEGATIVE ; // c is isolated on the negative side return coplanar_orientation(*b,*c,q) != NEGATIVE && coplanar_orientation(*c,*a,p) != NEGATIVE ; // case pqc == COLLINEAR is impossible since the triangle is // assumed to be non flat default:// should not happen. CGAL_kernel_assertion(false); return false; } default:// should not happen. CGAL_kernel_assertion(false); return false; } } template bool do_intersect_coplanar(const Segment_3 &s, const Triangle_3 &t, const K & k ) { return do_intersect_coplanar(t, s, k); } } // namespace CGALi template inline bool do_intersect(const Segment_3 &s, const Triangle_3 &t) { return typename K::Do_intersect_3()(t,s); } template inline bool do_intersect(const Triangle_3 &t, const Segment_3 &s) { return typename K::Do_intersect_3()(t,s); } /* template inline bool do_intersect(const Segment_3 &s, const Triangle_3 &t, const K & k) { return CGALi::do_intersect(t,s,k); } */ CGAL_END_NAMESPACE #endif //CGAL_TRIANGLE_3_SEGMENT_3_DO_INTERSECT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Borland_fixes.h0000644000175000017500000001703611344301500027757 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Borland_fixes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Dimitri Pasechnik // Portions of code in this file are /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Copyright (c) 1996,1997 * Silicon Graphics Computer Systems, Inc. * * Copyright (c) 1997 * Moscow Center for SPARC Technology * * Copyright (c) 1999 * Boris Fomitchev * * This material is provided "as is", with absolutely no warranty expressed * or implied. Any use is at your own risk. * * Permission to use or copy this software for any purpose is hereby * granted * without fee, provided the above notices are retained on all copies. * Permission to modify the code and to distribute modified code is * granted, * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. * */ #if defined(__BORLANDC__) && __BORLANDC__ > 0x520 #include using std::size_t; #include // for time_t using std::time_t; #include #include #include #include class Borland_floating_point_initialiser { public: Borland_floating_point_initialiser(); }; inline Borland_floating_point_initialiser::Borland_floating_point_initialiser() { _control87(MCW_EM, MCW_EM); } extern void foogj() {} namespace { Borland_floating_point_initialiser bfpi; } namespace std { // Borland-specific, borrowed from STLPort template struct iterator_traits<_Tp* const> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef const _Tp* pointer; typedef const _Tp& reference; }; // borrowed from STLPort (HP STL compatibility, stl_iterator_base.h) template inline typename iterator_traits<_Iter>::iterator_category CGAL__iterator_category(const _Iter&) { typedef typename iterator_traits<_Iter>::iterator_category _Category; return _Category(); } template inline typename iterator_traits<_Iter>::difference_type* CGAL__distance_type(const _Iter&) { typedef typename iterator_traits<_Iter>::difference_type _diff_type; return static_cast<_diff_type*>(0); } template inline typename iterator_traits<_Iter>::value_type* CGAL__value_type(const _Iter&) { typedef typename iterator_traits<_Iter>::value_type _value_type; return static_cast<_value_type*>(0); } template inline typename iterator_traits<_Iter>::iterator_category iterator_category(const _Iter& __i) { return CGAL__iterator_category(__i); } template inline typename iterator_traits<_Iter>::difference_type* distance_type(const _Iter& __i) { return CGAL__distance_type(__i); } template inline typename iterator_traits<_Iter>::value_type* value_type(const _Iter& __i) { return CGAL__value_type(__i); } // Strange Borland-specific fix (DVP). // this fixes a matching problem in algorith.h template inline typename iterator_traits<_Iter>::value_type* __value_type(_Iter& const) { typedef typename iterator_traits<_Iter>::value_type _value_type; return static_cast<_value_type*>(0); } // quick (and dirty ?) fix for reverse_bidirectional_iterator template class reverse_bidirectional_iterator : public std::reverse_iterator {}; template class input_iterator : public iterator {}; class output_iterator : public iterator {}; // borrowed from STLPort // unary_compose and binary_compose (extensions, not part of the standard). template class unary_compose : public unary_function { protected: _Operation1 _M_fn1; _Operation2 _M_fn2; public: unary_compose(const _Operation1& __x, const _Operation2& __y) : _M_fn1(__x), _M_fn2(__y) {} typename _Operation1::result_type operator()(const typename _Operation2::argument_type& __x) const { return _M_fn1(_M_fn2(__x)); } }; template inline unary_compose<_Operation1,_Operation2> compose1(const _Operation1& __fn1, const _Operation2& __fn2) { return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); } template class binary_compose : public unary_function { protected: _Operation1 _M_fn1; _Operation2 _M_fn2; _Operation3 _M_fn3; public: binary_compose(const _Operation1& __x, const _Operation2& __y, const _Operation3& __z) : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } typename _Operation1::result_type operator()(const typename _Operation2::argument_type& __x) const { return _M_fn1(_M_fn2(__x), _M_fn3(__x)); } }; template inline binary_compose<_Operation1, _Operation2, _Operation3> compose2(const _Operation1& __fn1, const _Operation2& __fn2, const _Operation3& __fn3) { return binary_compose<_Operation1,_Operation2,_Operation3> (__fn1, __fn2, __fn3); } // Borrowed from STLPort (and modified) // copy_n (not part of the C++ standard) template inline std::pair<_InputIter, _OutputIter> __copy_n(_InputIter __first, _Size __count, _OutputIter __result, std::input_iterator_tag) { for ( ; __count > 0; --__count) { *__result = *__first; ++__first; ++__result; } return std::pair<_InputIter, _OutputIter>(__first, __result); } template inline std::pair<_RAIter, _OutputIter> __copy_n(_RAIter __first, _Size __count, _OutputIter __result, std::random_access_iterator_tag) { _RAIter __last = __first + __count; return std::pair<_RAIter, _OutputIter>(__last, std::copy(__first, __last, __result)); } template inline std::pair<_InputIter, _OutputIter> copy_n(_InputIter __first, _Size __count, _OutputIter __result) { return __copy_n(__first, __count, __result, std::iterator_category(__first)); } } // namespace std #endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/surface_neighbor_coordinates_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/surface_neighbor_coord0000644000175000017500000002377111344301501031451 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/surface_neighbor_coordinates_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Julia Floetotto // ATTENTION : the surface is supposed to be a closed surface #ifndef CGAL_SURFACE_NEIGHBOR_COORDINATES_3_H #define CGAL_SURFACE_NEIGHBOR_COORDINATES_3_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE template inline Triple< OutputIterator, typename Kernel::FT, bool > surface_neighbor_coordinates_3(InputIterator first, InputIterator beyond, const typename Kernel::Point_3& p, const typename Kernel::Vector_3& normal, OutputIterator out, const Kernel& K) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbor_coordinates_3(first, beyond, p, out, I_gt(p,normal)); } template Triple< OutputIterator, typename ITraits::FT, bool > surface_neighbor_coordinates_3(InputIterator first, InputIterator beyond, const typename ITraits::Point_2& p, OutputIterator out, const ITraits& traits) { //definition of the Voronoi intersection triangulation: typedef Regular_triangulation_2< ITraits> I_triangulation; //build Voronoi intersection triangulation: I_triangulation it(traits); it.insert(first,beyond); return regular_neighbor_coordinates_2(it, p, out); } //without Delaunay filtering but with certification: // a boolean is returned that indicates if a sufficiently large // neighborhood has been considered so that the // Voronoi cell of p is not affected by any point outside the smallest // ball centered on p containing all points in [first,beyond) template Quadruple< OutputIterator, typename Kernel::FT, bool, bool > surface_neighbor_coordinates_certified_3(InputIterator first, InputIterator beyond, const typename Kernel::Point_3& p, const typename Kernel::Vector_3& normal, OutputIterator out, const Kernel& K) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbor_coordinates_certified_3 (first, beyond, p, out, I_gt(p,normal)); } //this function takes the radius of the sphere centered on p // containing the points in [first, beyond] (i.e. the maximal // distance from p to [first,beyond) as add. parameter: template inline Quadruple< OutputIterator, typename Kernel::FT, bool, bool > surface_neighbor_coordinates_certified_3( InputIterator first, InputIterator beyond, const typename Kernel::Point_3& p, const typename Kernel::Vector_3& normal, const typename Kernel::FT& radius, OutputIterator out, const Kernel& K) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbor_coordinates_certified_3 (first, beyond, p, radius, out, I_gt(p,normal)); } // FIXME : this should probably be replaced by some kernel functor. //struct necessary to sort the points by distance to p: //also used in surface_neighbors_3.h template struct closer_to_point : public std::less { typedef typename Traits::Point_2 Point_2; closer_to_point(const Point_2& _p, const Traits& t) : p(_p), traits(t) {} bool operator()(const Point_2& q, const Point_2& r) const { return traits.less_distance_to_point_2_object()(p,q,r); } private: Point_2 p; Traits traits; }; // Versions with instantiated traits class: template Quadruple< OutputIterator, typename ITraits::FT, bool, bool > surface_neighbor_coordinates_certified_3(InputIterator first, InputIterator beyond, const typename ITraits::Point_2& p, OutputIterator out, const ITraits& traits) { //find the point in [first,beyond) furthest from p: InputIterator furthest = std::max_element(first, beyond, closer_to_point(p, traits)); return surface_neighbor_coordinates_certified_3 (first, beyond, p, traits.compute_squared_distance_2_object()(p,*furthest), out, traits); } //with radius(maximal distance from p to [first,beyond)) as // add. parameter: template Quadruple< OutputIterator, typename ITraits::FT, bool, bool > surface_neighbor_coordinates_certified_3(InputIterator first, InputIterator beyond, const typename ITraits::Point_2& p, const typename ITraits::FT& radius, OutputIterator out, const ITraits& traits) { //definition of the Voronoi intersection triangulation: typedef Regular_triangulation_2< ITraits> I_triangulation; //build Voronoi intersection triangulation: I_triangulation it(traits); it.insert(first,beyond); //collect the Voronoi vertices of the cell of p in order to //determine the furthest distance from p to the boundary of its cell std::vector< typename ITraits::Point_2 > vor_vertices; //unfortunately, there is no function call without Face_handle // "start" because this would cause type conflicts because // of resembling function signatures (-> default constructor) Triple< OutputIterator, typename ITraits::FT, bool > res = regular_neighbor_coordinates_2 (it, p, out, std::back_inserter(vor_vertices), typename I_triangulation::Face_handle()); typename ITraits::Point_2 furthest = *std::max_element(vor_vertices.begin(), vor_vertices.end(), closer_to_point(p,traits)); // if the distance to the furthest sample point is smaller // than twice the distance to the furthest vertex, not all neighbors // might be found: return false if(radius < 4* traits.compute_squared_distance_2_object() (p, furthest)) return make_quadruple(res.first, res.second, res.third, false); return make_quadruple(res.first, res.second,res.third, true); } // FIXME : //Sylvain: //this class should probably be moved to CGAL/function_objects.h // it is used in the (next two) functions // it is also used in surface_neighbors_3.h // //projection of Vertex_handle (or equiv. Vertices_iterator) to Point template < class NodeIterator> struct Project_vertex_iterator_to_point { typedef NodeIterator argument_type; typedef typename std::iterator_traits::value_type Node; typedef typename Node::Point Point; typedef Point result_type; typedef Arity_tag<1> Arity; Point& operator()( NodeIterator& x) const { return x->point(); } const Point& operator()( const NodeIterator& x) const { return x->point(); } }; //using Delaunay triangulation for candidate point filtering: // => no certification is necessary template inline Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > surface_neighbor_coordinates_3(const Dt& dt, const typename Dt::Geom_traits::Point_3& p, const typename Dt::Geom_traits::Vector_3& normal, OutputIterator out, typename Dt::Cell_handle start = typename Dt::Cell_handle()) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbor_coordinates_3(dt, p, out, I_gt(p,normal), start); } template Triple< OutputIterator, typename ITraits::FT, bool > surface_neighbor_coordinates_3(const Dt& dt, const typename ITraits::Point_2& p, OutputIterator out, const ITraits& traits, typename Dt::Cell_handle start = typename Dt::Cell_handle()) { typedef typename ITraits::FT Coord_type; typedef typename ITraits::Point_2 Point_3; typedef typename Dt::Cell_handle Cell_handle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Locate_type Locate_type; //the Vertex_handle is, in fact, an iterator over vertex: typedef Project_vertex_iterator_to_point< Vertex_handle> Proj_point; typedef Iterator_project< typename std::list< Vertex_handle >::iterator, Proj_point, const Point_3&, const Point_3*, std::ptrdiff_t, std::forward_iterator_tag> Point_iterator; Locate_type lt; int li, lj ; Cell_handle c = dt.locate(p, lt, li,lj,start); //if p is located on a vertex: the only neighbor is found if(lt == Dt::VERTEX){ *out++= std::make_pair(c->vertex(li)->point(), Coord_type(1)); return make_triple(out, Coord_type(1), true); } //the candidate points are the points of dt in conflict with p: typename std::list< Vertex_handle > conflict_vertices; dt.vertices_in_conflict(p,c, std::back_inserter(conflict_vertices)); for (typename std::list< Vertex_handle >::iterator it = conflict_vertices.begin(); it != conflict_vertices.end();){ if(dt.is_infinite(*it)){ typename std::list< Vertex_handle >::iterator itp = it; it++; conflict_vertices.erase(itp); } else { it++; } } return surface_neighbor_coordinates_3 (Point_iterator(conflict_vertices.begin()), Point_iterator(conflict_vertices.end()), p, out, traits); } CGAL_END_NAMESPACE #endif // CGAL_SURFACE_NEIGHBOR_COORDINATES_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Td_X_trapezoid.h0000644000175000017500000005751711344301501030130 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Td_X_trapezoid.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_TD_X_TRAPEZOID_H #define CGAL_TD_X_TRAPEZOID_H /* ------------------------------------------------------------------------ class CGAL::TD_X_trapezoid. parameters Td_traits, implementation of a trapezoid traits. inherited from CGAL::Handle. description Implements a trapezoid as two curves(top,bottom) and two points(left,right). ------------------------------------------------------------------------ */ #include CGAL_BEGIN_NAMESPACE template < class Td_traits_> class Td_X_trapezoid : public Handle { public: typedef Td_traits_ Traits; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef typename Traits::X_curve_ptr curve_pointer; typedef typename Traits::X_curve_ref curve_ref; typedef typename Traits::X_curve_const_ref curve_const_ref; typedef typename Traits::X_trapezoid X_trapezoid; typedef typename Traits::X_trapezoid_ptr pointer; typedef typename Traits::X_trapezoid_ref reference; typedef typename Traits::X_trapezoid_const_ref const_ref; typedef Td_ninetuple Boundary_type; typedef Trapezoidal_decomposition_2 TD; typedef typename TD::Unbounded Unbounded; typedef typename TD::Around_point_circulator Around_point_circulator; typedef typename TD::In_face_iterator In_face_iterator; friend class Trapezoidal_decomposition_2; #ifdef CGAL_PM_FRIEND_CLASS #if defined(__SUNPRO_CC) || defined(__PGI) || defined(__INTEL_COMPILER) friend class Trapezoidal_decomposition_2::Around_point_circulator; friend class Trapezoidal_decomposition_2::In_face_iterator; #elif defined(__GNUC__) #if ((__GNUC__ < 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ <= 2))) friend typename Trapezoidal_decomposition_2::Around_point_circulator; friend typename Trapezoidal_decomposition_2::In_face_iterator; #else friend class Trapezoidal_decomposition_2::Around_point_circulator; friend class Trapezoidal_decomposition_2::In_face_iterator; #endif #else friend class Around_point_circulator; friend class In_face_iterator; #endif #endif typedef typename TD::Data_structure Data_structure; // implementation for trapezoids with two sides parallel to y axis /* X_trapezoid abbriviates Planar trapezoid with vertical parallel left and right sides. Trapezoids are represented as two points called right and left and two curves called top and bottom. The points lie on the right and left boundaries of the trapezoid respectively and the curves bound the trapezoid from above and below. There are degenerate trapezoids called infinite trapezoid; this happens when one of the four sides degenerates into a point/X_curve at infinity. Trapezoids are created as active and become inactive when Remove() member function called. Each X_trapezoid has at most four neighbouring trapezoids. */ private: Boundary_type* ptr() const {return (Boundary_type*)(PTR);} #ifndef CGAL_TD_DEBUG #ifdef CGAL_PM_FRIEND_CLASS protected: #else public: // workaround #endif #else //CGAL_TD_DEBUG public: #endif //CGAL_TD_DEBUG Data_structure* node; void init_neighbours(pointer lb_=0,pointer lt_=0,pointer rb_=0,pointer rt_=0) {set_lb(lb_);set_lt(lt_);set_rb(rb_);set_rt(rt_);} void set_node(Data_structure* p) {node=p; #ifdef CGAL_TD_DEBUG CGAL_assertion(!p || **p==*this); #endif } void set_left(const Point& p) {ptr()->e0=p;ptr()->e4&=~CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED;} void set_right(const Point& p) {ptr()->e1=p;ptr()->e4&=~CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED;} void set_bottom(const X_curve& cv) {ptr()->e2=cv;ptr()->e4&=~CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED;} void set_top(const X_curve& cv) {ptr()->e3=cv;ptr()->e4&=~CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED;} void set_left_unbounded() {ptr()->e4|=CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED;} void set_right_unbounded() {ptr()->e4|=CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED;} void set_bottom_unbounded() {ptr()->e4|=CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED;} void set_top_unbounded() {ptr()->e4|=CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED;} void set_lb(X_trapezoid* lb) {ptr()->e5=lb;} void set_lt(X_trapezoid* lt) {ptr()->e6=lt;} void set_rb(X_trapezoid* rb) {ptr()->e7=rb;} void set_rt(X_trapezoid* rt) {ptr()->e8=rt;} public: Td_X_trapezoid(void) { PTR = new Boundary_type(Traits::get_point_at_left_top_infinity(), Traits::get_point_at_right_bottom_infinity(), Traits::get_curve_at_infinity(), Traits::get_curve_at_infinity(), CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOTALLY_UNBOUNDED, 0, 0, 0, 0); node = 0; } Td_X_trapezoid(const Point &l, const Point &r, const X_curve &b, const X_curve &t, unsigned char c = CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOUNDED, X_trapezoid *lb = 0, X_trapezoid *lt = 0, X_trapezoid *rb = 0, X_trapezoid *rt = 0, Data_structure *p = 0) { PTR = new Boundary_type(l, r, b, t, c, lb, lt, rb, rt); node = p; } Td_X_trapezoid(const Point *l, const Point *r , const X_curve *b, const X_curve *t, X_trapezoid *lb = 0, X_trapezoid *lt = 0, X_trapezoid *rb = 0, X_trapezoid *rt = 0, Data_structure *p = 0) { PTR = new Boundary_type (l ? *l : Traits::get_point_at_left_top_infinity(), r ? *r : Traits::get_point_at_right_bottom_infinity(), b ? *b : Traits::get_curve_at_infinity(), t ? *t : Traits::get_curve_at_infinity(), ((l ? 0 : CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED) | (r ? 0 : CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED) | (b ? 0 : CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED) | (t ? 0 : CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED)), lb, lt, rb, rt); node = p; } Td_X_trapezoid (const X_trapezoid &tr) : Handle(tr) { node = tr.node; } /* remark: operator= should not copy node (or otherwise update Data_structure::replace) */ X_trapezoid& operator=(const X_trapezoid& t2) { Handle::operator=(t2); return *this; } unsigned long id() const { return (unsigned long) PTR; } bool operator==(const X_trapezoid& t2) const { return CGAL::identical(*this,t2); } bool operator!=(const X_trapezoid& t2) const { return !(operator==(t2)); } const Point &left(void) const { return !is_left_unbounded() ? ptr()->e0 : Traits::get_point_at_left_top_infinity(); } const Point &right(void) const { return !is_right_unbounded() ? ptr()->e1 : Traits::get_point_at_right_bottom_infinity(); } // filters out the infinite case where at returns predefined dummy values const X_curve &bottom(void) const { return !is_bottom_unbounded() ? ptr()->e2 : Traits::get_curve_at_infinity(); } const X_curve &top(void) const { return !is_top_unbounded() ? ptr()->e3 : Traits::get_curve_at_infinity(); } unsigned char boundedness() const {return ptr()->e4;} bool is_left_unbounded() const { return (ptr()->e4&CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED)!=0;} bool is_right_unbounded() const { return (ptr()->e4&CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED)!=0;} bool is_bottom_unbounded() const { return (ptr()->e4&CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED)!=0;} bool is_top_unbounded() const { return (ptr()->e4&CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED)!=0;} bool is_unbounded() const { #ifdef CGAL_TD_DEBUG CGAL_assertion(is_active()); #endif return (ptr()->e4&CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOTALLY_UNBOUNDED)!=0; } pointer get_lb() const {return ptr()->e5;} pointer get_lt() const {return ptr()->e6;} pointer get_rb() const {return ptr()->e7;} pointer get_rt() const {return ptr()->e8;} pointer left_bottom_neighbour() const {return get_lb();} pointer left_top_neighbour() const {return get_lt();} pointer right_bottom_neighbour() const {return get_rb();} pointer right_top_neighbour() const {return get_rt();} Data_structure* get_node() const {return node;} bool is_active() const {return right_bottom_neighbour()!= (pointer)CGAL_TRAPEZOIDAL_DECOMPOSITION_2_DELETE_SIGNATURE;} void remove(Data_structure* left=0) { #ifndef CGAL_TD_DEBUG CGAL_warning(is_active()); #else CGAL_precondition(is_active()); #endif // mark trapezoid as deleted, set_rb((pointer)CGAL_TRAPEZOIDAL_DECOMPOSITION_2_DELETE_SIGNATURE); #ifdef CGAL_TD_DEBUG CGAL_warning(node); #endif // resets left son in data structure depending on input. if (left) node->set_left(*left); } /* precondition: both trapezoidal are active and have the same bounding edges from above and below and the trapezoids are adjacent to one another with the first to the left postcondition: this trapezoid is the union of the old this trapezoid and the input trapezoids */ void merge_trapezoid(X_trapezoid& right) { #ifdef CGAL_TD_DEBUG CGAL_assertion(!is_right_unbounded()); #endif bool right_unbounded = right.is_right_unbounded(); *this=X_trapezoid( !is_left_unbounded() ? &left() : 0, !right_unbounded ? &right.right() : 0, !is_bottom_unbounded() ? &bottom() : 0, !is_top_unbounded() ? &top() : 0, left_bottom_neighbour(),left_top_neighbour(), right.right_bottom_neighbour(), right.right_top_neighbour()); // if (right_unbounded) set_right_unbounded(); if (right_bottom_neighbour()) right_bottom_neighbour()->set_lb(this); if (right_top_neighbour()) right_top_neighbour()->set_lt(this); #ifdef CGAL_TD_DEBUG CGAL_assertion(is_right_unbounded()==right.is_right_unbounded()); #endif } #ifdef CGAL_TD_DEBUG bool is_valid(const Traits* traits) const { Comparison_result t; bool b; if (is_active()) { if (get_node() && **get_node()!=*this) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false); std::cerr << "\nget_node= "; write(std::cerr,**get_node(),*traits,false) << std::flush; CGAL_warning(**get_node()==*this); return false; } if (!is_left_unbounded() && !is_right_unbounded() && traits->point_is_left_low(right(),left())) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; CGAL_warning(!traits->point_is_left_low(right(),left())); return false; } if (!is_bottom_unbounded()) { if (is_left_unbounded() || is_right_unbounded()) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; CGAL_warning(!(is_left_unbounded() ||is_right_unbounded())); return false; } b = traits->point_in_x_range(bottom(),left()); if (b) { t = traits->curve_compare_y_at_x(left(), bottom()); if (t == LARGER) t = SMALLER; if (t == SMALLER) t = LARGER; } if (!b || t == LARGER) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; std::cerr << "\nt==" << t << std::flush; CGAL_warning(!b || t == LARGER); return false; } b=traits->point_in_x_range(bottom(),right()); if (b) { t = traits->curve_compare_y_at_x(right(), bottom()); if (t == LARGER) t = SMALLER; if (t == SMALLER) t = LARGER; } if (!b || t == LARGER) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; std::cerr << "\nt==" << t << std::flush; CGAL_warning(!b || t == LARGER); return false; } } if (!is_top_unbounded()) { if (is_left_unbounded() || is_right_unbounded()) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; CGAL_warning(!(is_left_unbounded() || is_right_unbounded())); return false; } b=traits->point_in_x_range(top(),left()); if (b) { t = traits->curve_compare_y_at_x(left(), top()); if (t == LARGER) t = SMALLER; if (t == SMALLER) t = LARGER; } if (!b || t == SMALLER) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; std::cerr << "\nt==" << t << std::flush; CGAL_warning(!b || t == SMALLER); return false; } b=traits->point_in_x_range(top(),right()); if (b) { t = traits->curve_compare_y_at_x(right(), top()); if (t == LARGER) t = SMALLER; if (t == SMALLER) t = LARGER; } if (!b || t == SMALLER) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; std::cerr << "\nt==" << t << std::flush; CGAL_warning(!b || t == SMALLER); return false; } } if (!traits->is_degenerate(*this)) { if (right_top_neighbour() && right_top_neighbour()->top()!=top() || left_top_neighbour() && left_top_neighbour()->top() != top() || right_bottom_neighbour() && right_bottom_neighbour()->bottom() != bottom() || left_bottom_neighbour() && left_bottom_neighbour()->bottom() != bottom() || right_top_neighbour() && traits->is_degenerate(*right_top_neighbour()) || left_top_neighbour() && traits->is_degenerate(*left_top_neighbour()) || right_bottom_neighbour() && traits->is_degenerate(*right_bottom_neighbour()) || left_bottom_neighbour() && traits->is_degenerate(*left_bottom_neighbour()) ) { std::cerr << "\nthis="; write(std::cerr,*this,*traits,false) << std::flush; CGAL_warning(!(right_top_neighbour() && right_top_neighbour()->top()!=top())); CGAL_warning(!(left_top_neighbour() && left_top_neighbour()->top() != top())); CGAL_warning(!(right_bottom_neighbour() && right_bottom_neighbour()->bottom()!=bottom())); CGAL_warning(!(left_bottom_neighbour() && left_bottom_neighbour()->bottom() != bottom())); CGAL_warning(!(right_top_neighbour() && traits->is_degenerate(*right_top_neighbour()))); CGAL_warning(!(left_top_neighbour() && traits->is_degenerate(*left_top_neighbour()))); CGAL_warning(!(right_bottom_neighbour() && traits->is_degenerate(*right_bottom_neighbour()))); CGAL_warning(!(left_bottom_neighbour() && traits->is_degenerate(*left_bottom_neighbour()))); return false; } if (right_top_neighbour()&&!right_top_neighbour()->is_active()|| left_top_neighbour()&&!left_top_neighbour()->is_active()|| right_bottom_neighbour()&&!right_bottom_neighbour()->is_active()|| left_bottom_neighbour()&&!left_bottom_neighbour()->is_active() ) { std::cerr << "\nleft=" << left() << " right=" << right() << " bottom=" << bottom() << " top=" << top() << std::flush; CGAL_warning(!(right_top_neighbour() && !right_top_neighbour()->is_active())); CGAL_warning(!(left_top_neighbour() && !left_top_neighbour()->is_active())); CGAL_warning(!(right_bottom_neighbour() && !right_bottom_neighbour()->is_active())); CGAL_warning(!(left_bottom_neighbour() && !left_bottom_neighbour()->is_active())); return false; } } else { /* if the trapezoid is degenerate, the left() and right() points should be on the top() and bottom() curves. In any case none of the geometric boundaries should be unbounded */ if (is_bottom_unbounded()|| is_top_unbounded()|| is_left_unbounded()|| is_right_unbounded() ) { std::cerr << "\nbottom()==" << bottom() << std::flush; std::cerr << "\ntop()==" << top() << std::flush; std::cerr << "\nleft()==" << left() << std::flush; std::cerr << "\nright()==" << right() << std::flush; CGAL_warning((!is_bottom_unbounded())); CGAL_warning((!is_top_unbounded())); CGAL_warning((!is_left_unbounded())); CGAL_warning((!is_right_unbounded())); return false; } if (!traits->point_in_x_range(bottom(),left()) || traits->curve_compare_y_at_x(left(), bottom()) != EQUAL) { std::cerr << "\nbottom()==" << bottom() << std::flush; std::cerr << "\nleft()==" << left() << std::flush; CGAL_warning(traits->point_in_x_range(bottom(),left()) && traits->curve_compare_y_at_x(left(), bottom()) == EQUAL); return false; } if (!traits->point_in_x_range(bottom(),right()) || traits->curve_compare_y_at_x(right(), bottom()) != EQUAL) { std::cerr << "\nbottom()==" << bottom() << std::flush; std::cerr << "\nright()==" << right() << std::flush; CGAL_warning(traits->point_in_x_range(bottom(),right()) && traits->curve_compare_y_at_x(right(), bottom()) == EQUAL); return false; } if (!traits->point_in_x_range(top(),left()) || traits->curve_compare_y_at_x(left(), top()) != EQUAL) { std::cerr << "\ntop()==" << top() << std::flush; std::cerr << "\nleft()==" << left() << std::flush; CGAL_warning(!traits->point_in_x_range(top(),left()) && traits->curve_compare_y_at_x(left(), top()) == EQUAL); return false; } if (!traits->point_in_x_range(top(),right()) || traits->curve_compare_y_at_x(right(), top()) != EQUAL) { std::cerr << "\ntop()==" << top() << std::flush; std::cerr << "\nright()==" << right() << std::flush; CGAL_warning(traits->point_in_x_range(top(),right()) && traits->curve_compare_y_at_x(right(), top()) == EQUAL); return false; } if (traits->is_degenerate_curve(*this)) { if (right_top_neighbour()&&!right_top_neighbour()->is_active()|| //!left_top_neighbour()||!left_top_neighbour()->is_active()|| right_bottom_neighbour() && !right_bottom_neighbour()->is_active()|| left_bottom_neighbour() && !left_bottom_neighbour()->is_active() ) { CGAL_warning(!right_top_neighbour() || right_top_neighbour()->is_active()); //CGAL_warning(!left_top_neighbour() || //left_top_neighbour()->is_active()); CGAL_warning(!right_bottom_neighbour() || right_bottom_neighbour()->is_active()); CGAL_warning(!left_bottom_neighbour() || left_bottom_neighbour()->is_active()); return false; } if ( /* if trapezoid is end relative to supporting X_curve, that is adjacent(trapezoid's right end point,supporting X_curve right end point) , right_top_neighbour() returns next such trapezoid around right() point in clockwise oriented order adjacent(trapezoid's left end point,supporting X_curve left end point), left_bottom_neighbour() returns next such trapezoid around left() point in clockwise oriented order */ /* right_bottom_neighbour() points to next trapezoid on supporting X_curve, if such exist */ right_top_neighbour() && !traits->is_degenerate_curve(*right_top_neighbour())|| // !left_top_neighbour() || // !traits->is_degenerate_curve(*left_top_neighbour())|| right_bottom_neighbour() && !traits->is_degenerate_curve(*right_bottom_neighbour())|| left_bottom_neighbour() && !traits->is_degenerate_curve(*left_bottom_neighbour()) ) { CGAL_warning(!right_top_neighbour() || traits->is_degenerate_curve(*right_top_neighbour())); //CGAL_warning(!left_top_neighbour() || //!traits->is_degenerate_curve(*left_top_neighbour())); CGAL_warning(!right_bottom_neighbour() || traits-> is_degenerate_curve(*right_bottom_neighbour())); CGAL_warning(!left_bottom_neighbour() || traits-> is_degenerate_curve(*left_bottom_neighbour())); return false; } } else if (traits->is_degenerate_point(*this)) { if (right_top_neighbour() && !traits->is_degenerate_curve(*right_top_neighbour())|| left_bottom_neighbour() && !traits->is_degenerate_curve(*left_bottom_neighbour()) ) { CGAL_warning(!right_top_neighbour() || traits->is_degenerate_curve(*right_top_neighbour())); CGAL_warning(!left_bottom_neighbour() || traits-> is_degenerate_curve(*left_bottom_neighbour())); return false; } if (right_top_neighbour()&&!right_top_neighbour()->is_active()|| left_bottom_neighbour()&&!left_bottom_neighbour()->is_active() ) { CGAL_warning(!right_top_neighbour() || right_top_neighbour()->is_active()); CGAL_warning(!left_bottom_neighbour() || left_bottom_neighbour()->is_active()); return false; } if (!traits->point_equal(left(),right())) { std::cerr << "\nleft()==" << left() << std::flush; std::cerr << "\nright()==" << right() << std::flush; CGAL_warning(traits->point_equal(left(),right())); return false; } } } } return true; } void debug() const // instantiate ptr functions. { ptr(); bottom(); top(); left(); right(); } #endif }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_debug_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_debug_trait0000644000175000017500000002633711344301500031425 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_debug_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Eyal Flato // Oren Nechushtan // Eti Ezra // Shai Hirsch // Eugene Lipovetsky // Efi Fogel // Ron Wein #ifndef CGAL_PM_SEGMENT_DEBUG_TRAITS_2_H #define CGAL_PM_SEGMENT_DEBUG_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE template class Pm_segment_traits_2 : public Kernel_190 { class My_x_curve_2{ public: typedef typename Kernel_::Point_2 Point_2; typedef typename Kernel_::Segment_2 Segment; Segment seg; My_x_curve_2() {} My_x_curve_2(Segment s): seg(s) {} My_x_curve_2(Point_2 p1, Point_2 p2): seg(p1,p2) {} }; public: typedef Kernel_ Kernel; // Categories: // #define HAS_LEFT_NOT #if !defined(HAS_LEFT_NOT) typedef Tag_true Has_left_category; #else typedef Tag_false Has_left_category; #endif // #define HAS_REFLECT #if !defined(HAS_REFLECT) typedef Tag_false Has_reflect_category; #else typedef Tag_true Has_reflect_category; #endif // Traits objects typedef typename Kernel::Point_2 Point_2; typedef My_x_curve_2 X_monotone_curve_2; // Backward compatability typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; protected: // Functors: typedef typename Kernel::Is_vertical_2 Is_vertical_2; typedef typename Kernel::Construct_vertex_2 Construct_vertex_2; typedef typename Kernel::Less_x_2 Less_x_2; typedef typename Kernel::Equal_2 Equal_2; public: // Creation Pm_segment_traits_2() {} // Operations // ---------- /*! compare_x() compares the x-coordinates of two given points * \param p1 the first point * \param p2 the second point * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL */ Comparison_result compare_x(const Point_2 & p1, const Point_2 & p2) const { return compare_x_2_object()(p1, p2); } /*! compare_xy() compares lexigoraphically the two points by x, then by y. * \param p1 the first point * \param p2 the second point * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL */ Comparison_result compare_xy(const Point_2 & p1, const Point_2 & p2) const { return compare_xy_2_object()(p1, p2); } /*! curve_is_vertical() * \param cv the curve * \return true iff the curve is vertical */ bool curve_is_vertical(const X_monotone_curve_2 & cv) const { return is_vertical_2_object()(cv.seg); } /*! point_in_x_range() * \param cv the curve * \param q the point * \return true if q is in the x range of cv * * \todo Intorduce Is_in_x_range_2() or perhaps Is_in_x_closed_range_2() * in kernel. Currently, this is implemented using existing traits (kernel) * functions (curve_source(), curve_target()) that return the source and * target points by value, which is not as efficient as possible. */ bool point_in_x_range(const X_monotone_curve_2 & cv, const Point_2 & q) const { Construct_vertex_2 construct_vertex = construct_vertex_2_object(); const Point_2 & source = construct_vertex(cv.seg, 0); const Point_2 & target = construct_vertex(cv.seg, 1); Less_x_2 less_x = less_x_2_object(); return !((less_x(source, q) && less_x(target, q)) || (less_x(q, source) && less_x(q, target))); } /*! curves_compare_y_at_x() compares the y-coordinate of two given curves at * the x-coordinate of a given point. * \param cv1 the first curve * \param cv2 the second curve * \param q the point * \return LARGER if cv1(x(q)) > cv2(x(q)); SMALLER if cv1(x(q)) < cv2(x(q)); * or else EQUAL. * \pre The point q is in the x range of the two curves. */ Comparison_result curves_compare_y_at_x(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { CGAL_precondition(point_in_x_range(cv1.seg, q)); CGAL_precondition(point_in_x_range(cv2.seg, q)); return compare_y_at_x_2_object()(q, cv1.seg, cv2.seg); } #if !defined(HAS_LEFT_NOT) /*! curves_compare_y_at_x_left() compares the y value of two curves in an * epsilon environment to the left of the x value of the input point * Preconditions: The point q is in the x range of the two curves, and both * of them must be also be defined to its left. The two curves must also * intersect at x(q). */ Comparison_result curves_compare_y_at_x_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1.seg)); CGAL_precondition(! curve_is_vertical(cv2.seg)); // The two curve must be defined at q and also to its left. CGAL_precondition_code( Construct_vertex_2 construct_vertex = construct_vertex_2_object(); Less_x_2 less_x = less_x_2_object(); const Point_2 & source1 = construct_vertex(cv1.seg, 0); const Point_2 & target1 = construct_vertex(cv1.seg, 1); const Point_2 & source2 = construct_vertex(cv2.seg, 0); const Point_2 & target2 = construct_vertex(cv2.seg, 1); ); CGAL_precondition (less_x(source1, q) || less_x(target1, q)); CGAL_precondition (!(less_x(source1, q) && less_x(target1, q))); CGAL_precondition (less_x(source2, q) || less_x(target2, q)); CGAL_precondition (!(less_x(source2, q) && less_x(target2, q))); // Since the curves are continuous, if they are not equal at q, the same // result also applies to q's left. CGAL_precondition (compare_y_at_x_2_object()(q, cv1.seg, cv2.seg)==EQUAL); // and meet at a point with the same x-coordinate as q // compare their derivatives. return compare_slope_2_object()(cv2.seg, cv1.seg); } #else /*! point_reflect_in_x_and_y() reflects the given point about the origin */ Point_2 point_reflect_in_x_and_y(const Point_2 & pt) const { Point_2 org = construct_point_2_object()(ORIGIN); typename Kernel::Vector_2 v = construct_vector_2_object()(pt, org); Point_2 reflected_pt(v); return reflected_pt; } /*! curve_reflect_in_x_and_y reflects the given curve about the origin */ X_monotone_curve_2 curve_reflect_in_x_and_y(const X_monotone_curve_2 & cv) const { X_monotone_curve_2 reflected_cv(point_reflect_in_x_and_y(cv.source()), point_reflect_in_x_and_y(cv.target())); return reflected_cv; } #endif /*! curves_compare_y_at_x_right() compares the y value of two curves in an * epsilon environment to the right of the x value of the input point * Preconditions: The point q is in the x range of the two curves, and both * of them must be also be defined to its right. The two curves must also * intersect at x(q). */ Comparison_result curves_compare_y_at_x_right(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1)); CGAL_precondition(! curve_is_vertical(cv2)); // The two curve must be defined at q and also to its right. CGAL_precondition_code( Construct_vertex_2 construct_vertex = construct_vertex_2_object(); Less_x_2 less_x = less_x_2_object(); const Point_2 & source1 = construct_vertex(cv1.seg, 0); const Point_2 & target1 = construct_vertex(cv1.seg, 1); const Point_2 & source2 = construct_vertex(cv2.seg, 0); const Point_2 & target2 = construct_vertex(cv2.seg, 1); ); CGAL_precondition (less_x(q, source1) || less_x(q, target1)); CGAL_precondition (!(less_x(q, source1) && less_x(q, target1))); CGAL_precondition (less_x(q, source2) || less_x(q, target2)); CGAL_precondition (!(less_x(q, source2) && less_x(q, target2))); // Since the curves are continuous, if they are not equal at q, the same // result also applies to q's left. CGAL_precondition (curves_compare_y_at_x(cv1, cv2, q) == EQUAL); // and meet at a point with the same x-coordinate as q // compare their derivatives return compare_slope_2_object()(cv1.seg, cv2.seg); } /*! Return the location of the given point with respect to the input curve. * \param cv The curve. * \param p The point. * \pre p is in the x-range of cv. * \return LARGER if y(p) > cv(x(p)); * SMALLER if y(p) < cv(x(p)); * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x (const Point_2 & p, const X_monotone_curve_2 & cv) const { CGAL_precondition(point_in_x_range(cv.seg, p)); return compare_y_at_x_2_object()(p, cv.seg); } /*! Check if the two curves are the same (have the same graph). * \param cv1 The first curve. * \param cv2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { Equal_2 equal = equal_2_object(); const X_monotone_curve_2 & ocv1 = construct_opposite_segment_2_object()(cv1.seg); return equal(cv1.seg, cv2.seg) || equal(ocv1.seg, cv2.seg); } /*! Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal(const Point_2 & p1, const Point_2 & p2) const { return equal_2_object()(p1, p2); } /*! Get the curve source. * \param cv The curve. * \return The source point. */ Point_2 curve_source(const X_monotone_curve_2 & cv) const { return construct_vertex_2_object()(cv.seg, 0); } /*! Get the curve target. * \param cv The curve. * \return The target point. */ Point_2 curve_target(const X_monotone_curve_2 & cv) const { return construct_vertex_2_object()(cv.seg, 1); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_2.h0000644000175000017500000001651311344301500027746 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CONVEX_HULL_2_H #define CGAL_CONVEX_HULL_2_H #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif // CGAL_REP_CLASS_DEFINED #include #include #include CGAL_BEGIN_NAMESPACE template inline OutputIterator CGAL_convex_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits, std::input_iterator_tag ) { return ch_bykat(first, last, result, ch_traits); } template inline OutputIterator CGAL_convex_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits, std::forward_iterator_tag ) { return ch_akl_toussaint(first, last, result, ch_traits); } template inline OutputIterator CGAL_convex_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits, std::bidirectional_iterator_tag ) { return ch_akl_toussaint(first, last, result, ch_traits); } template inline OutputIterator CGAL_convex_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits, std::random_access_iterator_tag ) { return ch_akl_toussaint(first, last, result, ch_traits); } template inline OutputIterator convex_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef std::iterator_traits ITraits; typedef typename ITraits::iterator_category Category; return CGAL_convex_hull_points_2(first, last, result, ch_traits, Category()); } template inline OutputIterator convex_hull_points_2(ForwardIterator first, ForwardIterator last, OutputIterator result ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef typename ITraits::iterator_category Category; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return CGAL_convex_hull_points_2(first, last, result, Kernel(), Category()); } // generates the counterclockwise sequence of extreme points // of the points in the range [|first|,|last|). The resulting sequence // is placed starting at position |result|, and the past-the-end iterator // for the resulting sequence is returned. It is not specified, at which // point the cyclic sequence of extreme points is cut into a linear // sequence. // {\it Preconditions:} // [|first|,|last|) does not contain |result|. // {\sc traits}: operates on |Traits::Point_2| using |Traits::Less_xy_2|, // |Traits::Equal_2|, |Traits::Less_yx_2|, and |Traits::Left_turn_2|. template inline OutputIterator convex_hull_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { return convex_hull_points_2(first, last, result, ch_traits); } template inline OutputIterator convex_hull_2(ForwardIterator first, ForwardIterator last, OutputIterator result ) { return convex_hull_points_2(first, last, result); } // generates the counterclockwise sequence of extreme points // on the lower hull of the points in the range [|first|,|last|). // The resulting sequence is placed starting at position |result|, // and the past-the-end iterator for the resulting sequence is returned. // The sequence starts with the leftmost point, the rightmost point is // not included. // {\it Preconditions:} // [|first|,|last|) does not contain |result|. // {\sc traits}: operates on |Traits::Point_2| using |Traits::Less_xy_2| // |Traits::Equal_2| and |Traits::Left_turn_2|. template inline OutputIterator lower_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { return ch_lower_hull_scan(first, last, result, ch_traits); } template inline OutputIterator lower_hull_points_2(ForwardIterator first, ForwardIterator last, OutputIterator result ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return lower_hull_points_2(first, last, result, Kernel()); } // generates the counterclockwise sequence of extreme points // on the upper hull of the points in the range [|first|,|last|). // The resulting sequence is placed starting at position |result|, // and the past-the-end iterator for the resulting sequence is returned. // The sequence starts with the rightmost point, the leftmost point is // not included. // {\it Preconditions:} // [|first|,|last|) does not contain |result|. // {\sc traits}: operates on |Traits::Point_2| using |Traits::Less_xy_2|, // |Traits::Equal_2| and |Traits::Left_turn_2|. template inline OutputIterator upper_hull_points_2(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { return ch_upper_hull_scan(first, last, result, ch_traits); } template inline OutputIterator upper_hull_points_2(ForwardIterator first, ForwardIterator last, OutputIterator result ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return upper_hull_points_2(first, last, result, Kernel()); } CGAL_END_NAMESPACE #endif // CGAL_CONVEX_HULL_2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_triangulation0000644000175000017500000003753511344301500031462 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_DELAUNAY_TRIANGULATION_2_H #define CGAL_DELAUNAY_TRIANGULATION_2_H #include #include CGAL_BEGIN_NAMESPACE template < class Gt, class Tds = Triangulation_data_structure_2 < Triangulation_vertex_base_2 > > class Delaunay_triangulation_2 : public Triangulation_2 { public: typedef Gt Geom_traits; typedef typename Geom_traits::Point_2 Point; typedef typename Geom_traits::Segment_2 Segment; typedef typename Geom_traits::Triangle_2 Triangle; typedef typename Geom_traits::Orientation_2 Orientation_2; typedef typename Geom_traits::Compare_x_2 Compare_x; typedef typename Geom_traits::Compare_y_2 Compare_y; typedef typename Geom_traits::Side_of_oriented_circle_2 Side_of_oriented_circle; typedef Triangulation_2 Triangulation; typedef typename Triangulation::Locate_type Locate_type; typedef typename Triangulation::Face_handle Face_handle; typedef typename Triangulation::Vertex_handle Vertex_handle; typedef typename Triangulation::Edge Edge; typedef typename Triangulation::Edge_circulator Edge_circulator; typedef typename Triangulation::Finite_edges_iterator Finite_edges_iterator; typedef typename Triangulation::Finite_faces_iterator Finite_faces_iterator; typedef typename Triangulation::Finite_vertices_iterator Finite_vertices_iterator; Delaunay_triangulation_2(const Gt& gt = Gt()) : Triangulation_2(gt) {} Delaunay_triangulation_2( const Delaunay_triangulation_2 &tr) : Triangulation_2(tr) { CGAL_triangulation_postcondition( is_valid() ); } // CHECK -QUERY bool is_valid(bool verbose = false, int level = 0) const; Vertex_handle nearest_vertex(const Point& p, Face_handle f= Face_handle()) const; bool does_conflict(const Point &p, Face_handle fh) const;// deprecated bool test_conflict(const Point &p, Face_handle fh) const; bool find_conflicts(const Point &p, //deprecated std::list& conflicts, Face_handle start= Face_handle() ) const; // //template member functions, declared and defined at the end // template // std::pair // get_conflicts_and_boundary(const Point &p, // OutputItFaces fit, // OutputItBoundaryEdges eit, // Face_handle start) const; // template // OutputItFaces // get_conflicts (const Point &p, // OutputItFaces fit, // Face_handle start ) const; // template // OutputItBoundaryEdges // get_boundary_of_conflicts(const Point &p, // OutputItBoundaryEdges eit, // Face_handle start ) const; // DUAL Point dual (Face_handle f) const; Object dual(const Edge &e) const ; Object dual(const Edge_circulator& ec) const; Object dual(const Finite_edges_iterator& ei) const; //INSERTION-REMOVAL Vertex_handle insert(const Point &p, Face_handle start = Face_handle() ); Vertex_handle insert(const Point& p, Locate_type lt, Face_handle loc, int li ); Vertex_handle push_back(const Point &p); void remove(Vertex_handle v ); void restore_Delaunay(Vertex_handle v); #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Triangulation::cw; using Triangulation::ccw; #endif private: void propagating_flip(Face_handle& f,int i); void remove_2D(Vertex_handle v ); Vertex_handle nearest_vertex_2D(const Point& p, Face_handle f) const; Vertex_handle nearest_vertex_1D(const Point& p) const; void look_nearest_neighbor(const Point& p, Face_handle f, int i, Vertex_handle& nn) const; public: template < class Stream> Stream& draw_dual(Stream & ps) { Finite_edges_iterator eit= this->finite_edges_begin(); for (; eit != this->finite_edges_end(); ++eit) { Object o = dual(eit); typename Geom_traits::Line_2 l; typename Geom_traits::Ray_2 r; Segment s; if (CGAL::assign(s,o)) ps << s; if (CGAL::assign(r,o)) ps << r; if (CGAL::assign(l,o)) ps << l; } return ps; } template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = this->number_of_vertices(); while(first != last){ insert(*first); ++first; } return this->number_of_vertices() - n; } template std::pair get_conflicts_and_boundary(const Point &p, OutputItFaces fit, OutputItBoundaryEdges eit, Face_handle start = Face_handle()) const { CGAL_triangulation_precondition( this->dimension() == 2); int li; Locate_type lt; Face_handle fh = locate(p,lt,li, start); switch(lt) { case Triangulation::OUTSIDE_AFFINE_HULL: case Triangulation::VERTEX: return std::make_pair(fit,eit); case Triangulation::FACE: case Triangulation::EDGE: case Triangulation::OUTSIDE_CONVEX_HULL: *fit++ = fh; //put fh in OutputItFaces std::pair pit = std::make_pair(fit,eit); pit = propagate_conflicts(p,fh,0,pit); pit = propagate_conflicts(p,fh,1,pit); pit = propagate_conflicts(p,fh,2,pit); return pit; } CGAL_triangulation_assertion(false); return std::make_pair(fit,eit); } template OutputItFaces get_conflicts (const Point &p, OutputItFaces fit, Face_handle start= Face_handle()) const { std::pair pp = get_conflicts_and_boundary(p,fit,Emptyset_iterator(),start); return pp.first; } template OutputItBoundaryEdges get_boundary_of_conflicts(const Point &p, OutputItBoundaryEdges eit, Face_handle start= Face_handle()) const { std::pair pp = get_conflicts_and_boundary(p,Emptyset_iterator(),eit,start); return pp.second; } private: template std::pair propagate_conflicts (const Point &p, Face_handle fh, int i, std::pair pit) const { Face_handle fn = fh->neighbor(i); OutputItFaces fit = pit.first; OutputItBoundaryEdges eit = pit.second; if (! test_conflict(p,fn)) { *eit++ = Edge(fn, fn->index(fh)); return std::make_pair(fit,eit); } *fit++ = fn; int j = fn->index(fh); pit = propagate_conflicts(p,fn,ccw(j),pit); pit = propagate_conflicts(p,fn,cw(j), pit); return pit; } }; template < class Gt, class Tds > inline bool Delaunay_triangulation_2:: test_conflict(const Point &p, Face_handle fh) const { // return true if P is inside the circumcircle of fh // if fh is infinite, return true when p is in the positive // halfspace or on the boundary and in the finite edge of fh Oriented_side os = side_of_oriented_circle(fh,p); if (os == ON_POSITIVE_SIDE) return true; if (os == ON_ORIENTED_BOUNDARY && is_infinite(fh)) { int i = fh->index(this->infinite_vertex()); return collinear_between(fh->vertex(cw(i))->point(), p, fh->vertex(ccw(i))->point() ); } return false; } template < class Gt, class Tds > inline bool Delaunay_triangulation_2:: does_conflict(const Point &p, Face_handle fh) const { return test_conflict(p,fh); } template < class Gt, class Tds > inline bool Delaunay_triangulation_2:: find_conflicts(const Point &p, std::list& conflicts, Face_handle start ) const { get_conflicts(p, std::back_inserter(conflicts), start); return (! conflicts.empty()); } template < class Gt, class Tds > bool Delaunay_triangulation_2:: is_valid(bool verbose, int level) const { bool result = Triangulation_2::is_valid(verbose, level); for( Finite_faces_iterator it = this->finite_faces_begin(); it != this->finite_faces_end() ; it++) { for(int i=0; i<3; i++) { if ( ! is_infinite( it->mirror_vertex(i))) { result = result && ON_POSITIVE_SIDE != side_of_oriented_circle( it, it->mirror_vertex(i)->point()); } CGAL_triangulation_assertion( result ); } } return result; } template < class Gt, class Tds > typename Delaunay_triangulation_2::Vertex_handle Delaunay_triangulation_2:: nearest_vertex(const Point &p, Face_handle f) const { switch (this->dimension()) { case 0: if (this->number_of_vertices() == 0) return Vertex_handle(); if (this->number_of_vertices() == 1) return this->finite_vertex(); //break; case 1: return nearest_vertex_1D(p); //break; case 2: return nearest_vertex_2D(p,f); //break; } return Vertex_handle(); } template < class Gt, class Tds > typename Delaunay_triangulation_2::Vertex_handle Delaunay_triangulation_2:: nearest_vertex_2D(const Point& p, Face_handle f) const { CGAL_triangulation_precondition(this->dimension() == 2); f = locate(p,f); typename Geom_traits::Compare_distance_2 compare_distance = this->geom_traits().compare_distance_2_object(); Vertex_handle nn = !is_infinite(f->vertex(0)) ? f->vertex(0):f->vertex(1); if ( !is_infinite(f->vertex(1)) && compare_distance(p, f->vertex(1)->point(), nn->point()) == SMALLER) nn=f->vertex(1); if ( !is_infinite(f->vertex(2)) && compare_distance(p, f->vertex(2)->point(), nn->point()) == SMALLER) nn=f->vertex(2); look_nearest_neighbor(p,f,0,nn); look_nearest_neighbor(p,f,1,nn); look_nearest_neighbor(p,f,2,nn); return nn; } template < class Gt, class Tds > typename Delaunay_triangulation_2::Vertex_handle Delaunay_triangulation_2:: nearest_vertex_1D(const Point& p) const { typename Geom_traits::Compare_distance_2 compare_distance = this->geom_traits().compare_distance_2_object(); Vertex_handle nn; Finite_vertices_iterator vit=this->finite_vertices_begin(); nn = vit; for ( ; vit != this->finite_vertices_end(); ++vit){ if (compare_distance(p, vit->point(), nn->point()) == SMALLER) nn = vit; } return nn; } template < class Gt, class Tds > void Delaunay_triangulation_2:: look_nearest_neighbor(const Point& p, Face_handle f, int i, Vertex_handle& nn) const { Face_handle ni=f->neighbor(i); if ( ON_POSITIVE_SIDE != side_of_oriented_circle(ni,p) ) return; typename Geom_traits::Compare_distance_2 compare_distance = this->geom_traits().compare_distance_2_object(); i = ni->index(f); if ( !is_infinite(ni->vertex(i)) && compare_distance(p, ni->vertex(i)->point(), nn->point()) == SMALLER) nn=ni->vertex(i); // recursive exploration of triangles whose circumcircle contains p look_nearest_neighbor(p, ni, ccw(i), nn); look_nearest_neighbor(p, ni, cw(i), nn); } //DUALITY template inline typename Delaunay_triangulation_2::Point Delaunay_triangulation_2:: dual (Face_handle f) const { CGAL_triangulation_precondition (this->dimension()==2); return circumcenter(f); } template < class Gt, class Tds > Object Delaunay_triangulation_2:: dual(const Edge &e) const { typedef typename Geom_traits::Line_2 Line; typedef typename Geom_traits::Ray_2 Ray; CGAL_triangulation_precondition (!is_infinite(e)); if( this->dimension()== 1 ){ const Point& p = (e.first)->vertex(cw(e.second))->point(); const Point& q = (e.first)->vertex(ccw(e.second))->point(); Line l = this->geom_traits().construct_bisector_2_object()(p,q); return make_object(l); } // dimension==2 if( (!is_infinite(e.first)) && (!is_infinite(e.first->neighbor(e.second))) ) { Segment s = this->geom_traits().construct_segment_2_object() (dual(e.first),dual(e.first->neighbor(e.second))); return make_object(s); } // one of the adjacent face is infinite Face_handle f; int i; if (is_infinite(e.first)) { f=e.first->neighbor(e.second); f->has_neighbor(e.first,i); } else { f=e.first; i=e.second; } const Point& p = f->vertex(cw(i))->point(); const Point& q = f->vertex(ccw(i))->point(); Line l = this->geom_traits().construct_bisector_2_object()(p,q); Ray r = this->geom_traits().construct_ray_2_object()(dual(f), l); return make_object(r); } template < class Gt, class Tds > inline Object Delaunay_triangulation_2:: dual(const Edge_circulator& ec) const { return dual(*ec); } template < class Gt, class Tds > inline Object Delaunay_triangulation_2:: dual(const Finite_edges_iterator& ei) const { return dual(*ei); } template < class Gt, class Tds > inline typename Delaunay_triangulation_2::Vertex_handle Delaunay_triangulation_2:: insert(const Point &p, Face_handle start) { Locate_type lt; int li; Face_handle loc = locate (p, lt, li, start); return insert(p, lt, loc, li); } template < class Gt, class Tds > inline typename Delaunay_triangulation_2::Vertex_handle Delaunay_triangulation_2:: push_back(const Point &p) { return insert(p); } template < class Gt, class Tds > inline typename Delaunay_triangulation_2::Vertex_handle Delaunay_triangulation_2:: insert(const Point &p, Locate_type lt, Face_handle loc, int li) { Vertex_handle v = Triangulation_2::insert(p,lt,loc,li); restore_Delaunay(v); return(v); } template < class Gt, class Tds > void Delaunay_triangulation_2:: restore_Delaunay(Vertex_handle v) { if(this->dimension() <= 1) return; Face_handle f=v->face(); Face_handle next; int i; Face_handle start(f); do { i = f->index(v); next = f->neighbor(ccw(i)); // turn ccw around v propagating_flip(f,i); f=next; } while(next != start); return; } template < class Gt, class Tds > void Delaunay_triangulation_2:: remove(Vertex_handle v ) { CGAL_triangulation_precondition( v != Vertex_handle()); CGAL_triangulation_precondition( !is_infinite(v)); if ( this->dimension() <= 1) Triangulation::remove(v); else remove_2D(v); return; } template < class Gt, class Tds > void Delaunay_triangulation_2:: propagating_flip(Face_handle& f,int i) { Face_handle n = f->neighbor(i); if ( ON_POSITIVE_SIDE != side_of_oriented_circle(n, f->vertex(i)->point()) ) { return; } flip(f, i); propagating_flip(f,i); i = n->index(f->vertex(i)); propagating_flip(n,i); } template void Delaunay_triangulation_2:: remove_2D(Vertex_handle v) { if (test_dim_down(v)) { this->_tds.remove_dim_down(v); } else { std::list hole; make_hole(v, hole); fill_hole_delaunay(hole); delete_vertex(v); } return; } CGAL_END_NAMESPACE #endif // CGAL_DELAUNAY_TRIANGULATION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iterator_identity.h0000644000175000017500000001061311344301500030674 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iterator_identity.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_ITERATOR_IDENTITY_H #define CGAL_ITERATOR_IDENTITY_H 1 #include CGAL_BEGIN_NAMESPACE template < class I, class Ref = typename std::iterator_traits::reference, class Ptr = typename std::iterator_traits::pointer, class Val = typename std::iterator_traits::value_type, class Dist = typename std::iterator_traits::difference_type, class Ctg = typename std::iterator_traits::iterator_category> class Iterator_identity { protected: I nt; // The internal iterator. public: typedef I Iterator; typedef Iterator_identity Self; typedef Ctg iterator_category; typedef Val value_type; typedef Dist difference_type; typedef Ref reference; typedef Ptr pointer; // CREATION // -------- Iterator_identity() {} Iterator_identity( Iterator j) : nt(j) {} // OPERATIONS Forward Category // --------------------------- Iterator current_iterator() const { return nt;} bool operator==( const Self& i) const { return ( nt == i.nt); //###// } bool operator!=( const Self& i) const { return !(*this == i); } Ref operator*() const { return *nt; //###// } Ptr operator->() const { return nt.operator->(); //###// } Self& operator++() { ++nt; //###// return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; //###// return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self& operator+=( difference_type n) { nt += n; //###// return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; //###// } Ref operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator<( const Self& i) const { return ( nt < i.nt); //###// } bool operator>( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; template < class I, class Ref, class Ptr, class Val, class Dist, class Ctg> inline Iterator_identity operator+( Dist n, Iterator_identity i) { return i += n; } CGAL_END_NAMESPACE #endif // CGAL_ITERATOR_IDENTITY_H // // EOF // ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_trapezoid_ric_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_trapezoid_ric_point0000644000175000017500000003040611344301500031451 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_trapezoid_ric_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_PM_TRAPEZOID_RIC_POINT_LOCATION_H #define CGAL_PM_TRAPEZOID_RIC_POINT_LOCATION_H #include #include #include #include CGAL_BEGIN_NAMESPACE //////////////////////////////////////////////////////////////////// // DEFAULT PLANAR MAP STRATEGY /////////////////////////////////////////////////////////////////// template class PL_X_curve_plus: public Planar_map_::Traits::X_curve { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; typedef typename Traits::X_curve curve; typedef typename Traits::Point Point; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; PL_X_curve_plus() : curve(),parent() {}; PL_X_curve_plus(const curve &cv,const Halfedge_handle& p) : curve(cv), parent(p) {} PL_X_curve_plus(const Halfedge_handle& p) : curve(p->curve()),parent(p){} // used when no Halfedge_handle is supplied. PL_X_curve_plus(const curve &cv) : curve(cv),parent() {}; PL_X_curve_plus(const PL_X_curve_plus &cv) : curve(cv),parent(cv.parent){} ~PL_X_curve_plus(){} PL_X_curve_plus& operator=(const PL_X_curve_plus &cv) { // Workaround a bug in the Irix compiler #if ((SGI == _sgi) && (_COMPILER_VERSION <= 730)) static_cast(*this) = cv; #else curve::operator=(cv); #endif parent=cv.get_parent(); return *this; } Halfedge_handle get_parent() const { return parent; } protected: Halfedge_handle parent; }; //------------------------------------------------------------------ template class Pm_trapezoid_ric_point_location : public Pm_point_location_base { public: typedef Planar_map_ Planar_map; typedef const Planar_map& const_Planar_map_ref; typedef const Planar_map* const_Planar_map_ptr; typedef Pm_point_location_base Base; typedef Pm_trapezoid_ric_point_location Self; typedef const Self & const_Self_ref; typedef const Self * const_Self_ptr; typedef typename Planar_map::Traits Pm_traits; typedef typename Planar_map::Traits_wrap Pm_traits_wrap; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef PL_X_curve_plus X_curve_plus; // SunPro gets confused (a bug) because of the two Td_traits in the same // class scope. We add the CGAL namespace as a workaround. typedef CGAL::Td_traits Td_traits; typedef const Td_traits& const_Td_traits_ref; typedef const Td_traits* const_Td_traits_ptr; typedef Trapezoidal_decomposition_2 Trapezoidal_decomposition; typedef Pm_bounding_box_base Bounding_box; typedef typename Pm_traits::Point Point; typedef typename Pm_traits::X_curve X_curve; typedef typename Pm_point_location_base:: Halfedge_handle_container Halfedge_handle_container; typedef typename Pm_point_location_base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Base::Token Token; protected: typedef Trapezoidal_decomposition TD; typedef Planar_map PM; public: Pm_trapezoid_ric_point_location(bool rebuild = true) : pm(NULL), traits(NULL) { td.set_needs_update(rebuild); } Pm_trapezoid_ric_point_location(const_Self_ref pl) : td(*pl.get_trapezoidal_decomposition()), pm(NULL) { const_Planar_map_ptr pm = pl.get_planar_map(); init(* ((Planar_map *) pm), *pl.get_traits()); } ~Pm_trapezoid_ric_point_location() { if (traits) delete traits; } /* Postcondition: h->curve() with a reference back to h is inserted into TD. */ void insert(Halfedge_handle h, const X_curve& cv) //additions by iddo for arrangement { td.insert(X_curve_plus(cv,h)); } Halfedge_const_handle locate(const Point& p, Locate_type& lt) const; Halfedge_handle locate(const Point& p, Locate_type& lt); Halfedge_const_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) const; Halfedge_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up); //the function is called after the combinatoric split //we want O(1) is it possible?? no! void split_edge(const X_curve &cv, Halfedge_handle e1, Halfedge_handle e2 //additions by iddo for arrangement ,const X_curve& cv1, const X_curve& cv2 //end additions ) { // td.split_edge(X_curve_plus(cv),X_curve_plus(e1),X_curve_plus(e2)); td.split_edge(X_curve_plus(cv),X_curve_plus(cv1,e1),X_curve_plus(cv2,e2)); } /* called after combinatoric merge e is the new edge cv1,cv2 are the original curves */ void merge_edge(const X_curve &cv1, const X_curve &cv2, Halfedge_handle e //additions by iddo for arrangement ,const X_curve& cv //end additions ) { td.merge_edge(X_curve_plus(cv1), X_curve_plus(cv2), // X_curve_plus(e) X_curve_plus(cv,e) ); } //called before combinatoric deletion void remove_edge(Halfedge_handle e) { td.remove(X_curve_plus(e)); } void remove_edge(const Halfedge_handle_iterator& begin, const Halfedge_handle_iterator& end) { std::vector c; Halfedge_handle_iterator it=begin; while (it!=end) { c.push_back((*it)->curve());++it;} td.remove(c.begin(),c.end()); } inline void clear() { td.clear(); } inline void update(const Halfedge_handle_iterator& begin, const Halfedge_handle_iterator& end, const Token& token) // Shuffle curves, remove them from the map and reinsert them afterwards. { #ifdef CGAL_PMBB_DEBUG std::cout << "\nPL::update called with traits = "; traits->debug(); #endif if (begin!=end) { Halfedge_handle_container c; Halfedge_handle_iterator it=begin; while (it!=end) { c.push_back(Halfedge_handle(*it)); ++it; } remove_edge(begin,end); Halfedge_handle_iterator cend=c.end(); it=c.begin(); token.rebuild_bounding_box(this); while(it!=cend) { insert(*it,(*it)->curve()); ++it; } } else { token.rebuild_bounding_box(this); } #ifdef CGAL_PMBB_DEBUG std::cout << "\nPL::update exited with traits = "; traits->debug(); #endif } const TD* get_trapezoidal_decomposition() const {return &td;} inline const Pm_traits* get_traits() const {return traits;} inline const_Planar_map_ptr get_planar_map() const {return pm;} inline const_Planar_map_ptr set_planar_map(const_Planar_map_ptr const pm_) { return pm=pm_; } void init(Planar_map & pmp, const Pm_traits & tr) { CGAL_precondition_msg(pm == NULL, "Point location instance should be uninitialized " "(Do not use the same instance for more than one map)."); pm = &pmp; if (traits) delete traits; traits = new Td_traits(tr); td.init_traits(traits); } #ifdef CGAL_PM_DEBUG public: void debug() { #ifdef CGAL_TD_DEBUG td.debug(); #endif } #endif protected: TD td; private: const_Planar_map_ptr pm; const_Td_traits_ptr traits; bool halfedge_represents_point(const Halfedge_const_handle& h, const Point& p) const { const Point &source=h->source()->point(), &target=h->target()->point(); return !(!traits->point_equal_x(target,p)|| traits->point_equal_x(source,p)&& (traits->point_is_right_top(p,target)&& traits->point_is_left_low(target,source)|| traits->point_is_left_low(p,target)&& traits->point_is_right_top(target,source) )); } /* description: returns if the point is located in the open halfplane on the right side of the input curve (considering the halfedge orientation) preconditions: the input curve is not vertical, p is in its x range but not on its closure */ bool halfedge_represents_point_inside_face(const Halfedge_const_handle& h, const Point& p) const { return (traits->point_in_x_range(h->curve(),p) && traits->curve_compare_y_at_x(p, h->curve()) == LARGER) == traits->point_is_left(h->source()->point(),h->target()->point()); } Halfedge_const_handle halfedge_representing_unbounded_face() const { CGAL_assertion(pm); if (pm->unbounded_face()->holes_begin()!=pm->unbounded_face()->holes_end()) { // case PM is not empty //return *(pm->unbounded_face()->holes_begin()); typename Planar_map::Holes_const_iterator hot = pm->unbounded_face()->holes_begin(); return (*hot); } else // case PM is empty return pm->halfedges_end(); } //use the latter //to workaround internal compiler error in egcs1.1 //Locate_type convert(const Point& p,const TD::Locate_type& lt, // Halfedge_handle& h,bool up=true) const Locate_type convert(const Point & p,const int & lt,Halfedge_const_handle & h, bool up = true) const { switch(lt) { // h->target() should represent p case TD::POINT: if (!halfedge_represents_point(h,p)) h=h->twin(); return PM::VERTEX; case TD::CURVE: /* special case: h->source()->point(),p,h->target()->point() have same x coardinates. return value should be h(no h->twin()). */ // orientation of h if (up==traits->point_is_left(h->source()->point(), h->target()->point())) h=h->twin(); return PM::EDGE; case TD::TRAPEZOID: if (!halfedge_represents_point_inside_face(h,p)) h=h->twin(); CGAL_postcondition(halfedge_represents_point_inside_face(h,p)); if (!h->face()->is_unbounded()) return PM::FACE; // otherwise pass to UNBOUNDED_TRAPEZOID case case TD::UNBOUNDED_TRAPEZOID: h=halfedge_representing_unbounded_face(); CGAL_postcondition(h->face()->is_unbounded()); return PM::UNBOUNDED_FACE; default: CGAL_assertion(lt==TD::POINT||lt==TD::CURVE||lt==TD::TRAPEZOID|| lt==TD::UNBOUNDED_TRAPEZOID); } return Locate_type(); } const Bounding_box* get_bounding_box() const {return pm->get_bounding_box();} }; CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif #endif /* X_curve msvc6 workaround: typedef typename Traits::X_curve X_curve; causes error C2086: '' : redefinition */ /* egcs workaround: To solve the internal compiler errors egcs had when dealing with nested templated classes we moved them outside: template class PL_X_curve_plus: public Planar_map_::Traits::X_curve */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_less_yx_2.h0000644000175000017500000001341111344301500030562 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_less_yx_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_SEGMENT_LESS_YX_2_H #define CGAL_SEGMENT_LESS_YX_2_H #include #include namespace CGAL { // // Compares two pairs of points representing two segments. The first is // "less than" the second if the second can see some point of the first // by looking straight down (i.e., in direction -pi/2). If the first can see // the second in this way, it is greater than the second. If neither sees // the other when looking in the direction -pi/2, the one that is farther // to the left is less than the one farther to the right. // template class Segment_less_yx_2 { typedef typename Traits::Point_2 Point_2; typedef std::pair Point_pair; typedef typename Traits::Less_xy_2 Less_xy_2; typedef typename Traits::Compare_x_2 Compare_x_2; typedef typename Traits::Compare_y_2 Compare_y_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef Turn_reverser Right_turn_2; public: Segment_less_yx_2() : _less_xy_2(Traits().less_xy_2_object()), _compare_x_2(Traits().compare_x_2_object()), _compare_y_2(Traits().compare_y_2_object()), _left_turn_2(Traits().left_turn_2_object()), _right_turn_2(Right_turn_2(_left_turn_2)) { } bool operator()(const Point_pair& p, const Point_pair& q) const { Point_2 p_smaller_xy, p_larger_xy; Point_2 q_smaller_xy, q_larger_xy; // order the point pairs by x value if (_less_xy_2(p.first, p.second)) { p_smaller_xy = p.first; p_larger_xy = p.second; } else { p_smaller_xy = p.second; p_larger_xy = p.first; } if (_less_xy_2(q.first, q.second)) { q_smaller_xy = q.first; q_larger_xy = q.second; } else { q_smaller_xy = q.second; q_larger_xy = q.first; } // x range of p comes before x range of q if (_compare_x_2(p_larger_xy, q_smaller_xy) == SMALLER) return true; else if (_compare_x_2(p_larger_xy, q_smaller_xy) == EQUAL) { // x range of p ends where x range of q starts Comparison_result y_comp = _compare_y_2(p_larger_xy, q_smaller_xy); if (y_comp == SMALLER) return true; else if (y_comp == LARGER) return false; else // y_comp == EQUAL, so p's x range comes before q's return true; } // x range of q comes before x range of p else if (_compare_x_2(q_larger_xy, p_smaller_xy) == SMALLER) return false; else if (_compare_x_2(q_larger_xy, p_smaller_xy) == EQUAL) { // x range of p starts where x range of q ends Comparison_result y_comp = _compare_y_2(p_smaller_xy, q_larger_xy); if (y_comp == SMALLER) return true; else if (y_comp == LARGER) return false; else // y_comp == EQUAL, so p's x range comes after q's return false; } // see if one of q's endpoints is contained in p's x range else if (_compare_x_2(p_smaller_xy,q_smaller_xy) == SMALLER && _compare_x_2(q_smaller_xy,p_larger_xy) == SMALLER) return _left_turn_2(p_smaller_xy,p_larger_xy,q_smaller_xy); else if (_compare_x_2(p_smaller_xy,q_larger_xy) == SMALLER && _compare_x_2(q_larger_xy,p_larger_xy) == SMALLER) return _left_turn_2(p_smaller_xy,p_larger_xy,q_larger_xy); // // neither of q's endpoints is in p's x-range so see if one of // p's endpoints is in q's x-range // else if (_compare_x_2(q_smaller_xy,p_smaller_xy) == SMALLER && _compare_x_2(p_smaller_xy,q_larger_xy) == SMALLER) return _right_turn_2(q_smaller_xy,q_larger_xy,p_smaller_xy); else if (_compare_x_2(q_smaller_xy,p_larger_xy) == SMALLER && _compare_x_2(p_larger_xy,q_larger_xy) == SMALLER ) return _right_turn_2(q_smaller_xy,q_larger_xy,p_larger_xy); else // the x ranges are exactly the same { Comparison_result y_comp = _compare_y_2(p_smaller_xy, q_smaller_xy); if (y_comp == SMALLER) return true; else if (y_comp == LARGER) return false; else // look at the other endpoint { y_comp = _compare_y_2(p_larger_xy, q_larger_xy); if (y_comp == SMALLER) return true; else if (y_comp == LARGER) return false; else // point pairs are identical return false; } } } private: Less_xy_2 _less_xy_2; Compare_x_2 _compare_x_2; Compare_y_2 _compare_y_2; Left_turn_2 _left_turn_2; Right_turn_2 _right_turn_2; }; } #endif // CGAL_SEGMENT_LESS_YX_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/leda_real.h0000644000175000017500000000524311344301500027105 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/leda_real.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_LEDA_REAL_H #define CGAL_LEDA_REAL_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_true Has_exact_division; typedef Tag_true Has_exact_sqrt; }; #ifndef CGAL_NO_NAMESPACE inline double to_double(const leda_real & r) { return r.to_double(); } #endif // CGAL_NO_NAMESPACE inline leda_real sqrt(const leda_real & r) { return CGAL_LEDA_SCOPE::sqrt(r); } inline bool is_finite(const leda_real &) { return true; } inline bool is_valid(const leda_real &) { return true; } inline io_Operator io_tag(const leda_real &) { return io_Operator(); } #ifndef CGAL_CFG_NO_NAMESPACE inline Sign sign(const leda_real& r) { return (Sign)CGAL_LEDA_SCOPE::sign(r); } inline Comparison_result compare(const leda_real& r1, const leda_real& r2) { int c = CGAL_LEDA_SCOPE::compare(r1,r2); return (c < 0) ? SMALLER : ((0 < c) ? LARGER : EQUAL); } #endif // CGAL_CFG_NO_NAMESPACE inline std::pair to_interval (const leda_real & z) { Protect_FPU_rounding P (CGAL_FE_TONEAREST); double approx = z.to_double(); double rel_error = z.get_double_error(); FPU_set_cw(CGAL_FE_UPWARD); Interval_nt_advanced ina(-rel_error,rel_error); ina += 1; ina *= approx; return ina.pair(); } CGAL_END_NAMESPACE #endif // CGAL_LEDA_REAL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_iterator.h0000644000175000017500000004357411344301500031045 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_HALFEDGEDS_ITERATOR_H #define CGAL_HALFEDGEDS_ITERATOR_H 1 #ifndef CGAL_CIRCULATOR_H #include #endif CGAL_BEGIN_NAMESPACE // These two outdated iterator adaptors are similar to Iterator_project // and Iterator_const_project, but they implement the arrow // operator -> in any case. This is possible here since the items // in a polyhedron are always classes with members. // (These are all reminiscences of old compilers having trouble // with the arrow operator.) template < class I, class Val, class Dist, class Ctg> class I_HalfedgeDS_iterator { protected: I nt; // The internal iterator. public: typedef I Iterator; typedef I_HalfedgeDS_iterator Self; typedef Ctg iterator_category; typedef Val value_type; typedef value_type& reference; typedef value_type* pointer; typedef Dist difference_type; // CREATION // -------- I_HalfedgeDS_iterator() {} I_HalfedgeDS_iterator( I j) : nt(j) {} // OPERATIONS Forward Category // --------------------------- Iterator current_iterator() const { return nt;} pointer ptr() const { return (pointer)(&(*nt)); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return *ptr(); } pointer operator->() const { return ptr(); } Self& operator++() { ++nt; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self& operator+=( difference_type n) { nt += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator< ( const Self& i) const { return ( nt < i.nt); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; CGAL_END_NAMESPACE // we don't need Koenig lookup here template < class D, class I, class Val, class Dist, class Ctg> inline CGAL::I_HalfedgeDS_iterator operator+( D n, CGAL::I_HalfedgeDS_iterator i) { return i += Dist(n); } CGAL_BEGIN_NAMESPACE template < class I, class II, class Val, class Dist, class Ctg> class I_HalfedgeDS_const_iterator { protected: I nt; // The internal iterator. public: typedef I Iterator; typedef I_HalfedgeDS_const_iterator Self; typedef Ctg iterator_category; typedef Val value_type; typedef const value_type& reference; typedef const value_type* pointer; typedef Dist difference_type; typedef I_HalfedgeDS_iterator mutable_iterator; // CREATION // -------- I_HalfedgeDS_const_iterator() {} I_HalfedgeDS_const_iterator( Iterator j) : nt(j) {} I_HalfedgeDS_const_iterator( mutable_iterator j) : nt( I(&*j)) {} // OPERATIONS Forward Category // --------------------------- Iterator current_iterator() const { return nt;} pointer ptr() const { return (pointer)(&(*nt)); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return *ptr(); } pointer operator->() const { return ptr(); } Self& operator++() { ++nt; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self& operator+=( difference_type n) { nt += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator< ( const Self& i) const { return ( nt < i.nt); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; CGAL_END_NAMESPACE // we don't need Koenig lookup here template < class D, class I, class II, class Val, class Dist, class Ctg> inline CGAL::I_HalfedgeDS_const_iterator operator+( D n, CGAL::I_HalfedgeDS_const_iterator i) { return i += Dist(n); } CGAL_BEGIN_NAMESPACE template < class It, class Ctg> class I_HalfedgeDS_facet_circ : public It { public: typedef It Iterator; typedef Ctg iterator_category; typedef I_HalfedgeDS_facet_circ Self; typedef std::iterator_traits Traits; typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef std::size_t size_type; typedef typename Traits::reference reference; typedef typename Traits::pointer pointer; // CREATION // -------- I_HalfedgeDS_facet_circ() {} explicit I_HalfedgeDS_facet_circ( It i) : It(i) {} template I_HalfedgeDS_facet_circ( const I_HalfedgeDS_facet_circ &c) : It((const It2&)(c)) {} // OPERATIONS Forward Category // --------------------------- // pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == 0); return It::operator==( It()); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } // operator* and operator-> are inherited. Self& operator++() { *((Iterator*)this) = (*this)->next(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { *((Iterator*)this) = (*this)->prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class It, class Ctg> class I_HalfedgeDS_vertex_circ : public It { public: typedef It Iterator; typedef Ctg iterator_category; typedef I_HalfedgeDS_vertex_circ Self; typedef std::iterator_traits Traits; typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef std::size_t size_type; typedef typename Traits::reference reference; typedef typename Traits::pointer pointer; // CREATION // -------- I_HalfedgeDS_vertex_circ() {} explicit I_HalfedgeDS_vertex_circ( It i) : It(i) {} template I_HalfedgeDS_vertex_circ( const I_HalfedgeDS_vertex_circ &c) : It((const It2&)(c)) {} // OPERATIONS Forward Category // --------------------------- // pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == 0); return It::operator==( It()); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } // operator* and operator-> are inherited. Self& operator++() { *((Iterator*)this) = (*this)->next()->opposite(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { *((Iterator*)this) = (*this)->opposite()->prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; // Determine the circulator category: If prev() is supported, // its bidirectional, otherwise its forward. template < class T> struct HalfedgeDS_circulator_traits {}; template <> struct HalfedgeDS_circulator_traits { typedef Bidirectional_circulator_tag iterator_category; }; template <> struct HalfedgeDS_circulator_traits { typedef Forward_circulator_tag iterator_category; }; // portability with other code using the old HalfedgeDS circulators template < class Node, class It, class Ctg> class _HalfedgeDS_facet_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _HalfedgeDS_facet_circ Self; typedef Ctg iterator_category; typedef Node value_type; typedef std::ptrdiff_t difference_type; typedef std::size_t size_type; typedef value_type& reference; typedef value_type* pointer; // CREATION // -------- _HalfedgeDS_facet_circ() : It(0) {} //_HalfedgeDS_facet_circ( pointer p) : It(p) {} _HalfedgeDS_facet_circ( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { this->nt = (*this->nt).next(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { this->nt = (*this->nt).prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class Node, class It, class Ctg> class _HalfedgeDS_facet_const_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _HalfedgeDS_facet_const_circ Self; typedef Ctg iterator_category; typedef Node value_type; typedef std::ptrdiff_t difference_type; typedef std::size_t size_type; typedef const value_type& reference; typedef const value_type* pointer; // CREATION // -------- _HalfedgeDS_facet_const_circ() : It(0) {} _HalfedgeDS_facet_const_circ( pointer p) : It(p) {} _HalfedgeDS_facet_const_circ( It i) : It(i) {} template _HalfedgeDS_facet_const_circ( const _HalfedgeDS_facet_circ& c) : It(c.ptr()) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { this->nt = (*this->nt).next(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { this->nt = (*this->nt).prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class Node, class It, class Ctg> class _HalfedgeDS_vertex_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _HalfedgeDS_vertex_circ Self; typedef Ctg iterator_category; typedef Node value_type; typedef std::ptrdiff_t difference_type; typedef std::size_t size_type; typedef value_type& reference; typedef value_type* pointer; // CREATION // -------- _HalfedgeDS_vertex_circ() : It(0) {} //_HalfedgeDS_vertex_circ( pointer p) : It(p) {} _HalfedgeDS_vertex_circ( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { this->nt = (*this->nt).next()->opposite(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { this->nt = (*this->nt).opposite()->prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class Node, class It, class Ctg> class _HalfedgeDS_vertex_const_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _HalfedgeDS_vertex_const_circ Self; typedef Ctg iterator_category; typedef Node value_type; typedef std::ptrdiff_t difference_type; typedef std::size_t size_type; typedef const value_type& reference; typedef const value_type* pointer; // CREATION // -------- _HalfedgeDS_vertex_const_circ() : It(0) {} _HalfedgeDS_vertex_const_circ( pointer p) : It(p) {} _HalfedgeDS_vertex_const_circ( It i) : It(i) {} template _HalfedgeDS_vertex_const_circ( const _HalfedgeDS_vertex_circ& c) : It(c.ptr()) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { this->nt = (*this->nt).next()->opposite(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { this->nt = (*this->nt).opposite()->prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_ITERATOR_H // // EOF // ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_incremental_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_incrementa0000644000175000017500000000341311344301500031477 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_incremental_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra // : Michael Seel #ifndef CGAL_CONVEX_HULL_INCREMENTAL_3_H #define CGAL_CONVEX_HULL_INCREMENTAL_3_H #include #include #include CGAL_BEGIN_NAMESPACE template void convex_hull_incremental_3(InputIterator first, InputIterator beyond, Polyhedron& P, bool test_correctness = false) { typedef typename Polyhedron::Traits PolyTraits; typedef typename PolyTraits::Kernel K; typedef Convex_hull_d_traits_3 ChullTraits; typedef Convex_hull_d< ChullTraits > ChullType; ChullType CH(3); for ( ; first != beyond ; ++first) CH.insert(*first); if ( test_correctness ) CGAL_assertion(CH.is_valid()); CGAL::convex_hull_d_to_polyhedron_3(CH,P); } CGAL_END_NAMESPACE #endif // CGAL_CONVEX_HULL_INCREMENTAL_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/0000755000175000017500000000000012146213703026741 5ustar debiandebian././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Tetrahedron_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Tetrahedron_0000644000175000017500000001636611344301501031307 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Tetrahedron_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_TETRAHEDRON_3_H #define CGAL_CARTESIAN_TETRAHEDRON_3_H #include #include #include CGAL_BEGIN_NAMESPACE template class TetrahedronC3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Tetrahedron_3 Tetrahedron_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Fourtuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; TetrahedronC3() {} TetrahedronC3(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) : base(p, q, r, s) {} const Point_3 & vertex(int i) const; const Point_3 & operator[](int i) const; bool operator==(const TetrahedronC3 &t) const; bool operator!=(const TetrahedronC3 &t) const; Bbox_3 bbox() const; Tetrahedron_3 transform(const Aff_transformation_3 &t) const { return TetrahedronC3(t.transform(vertex(0)), t.transform(vertex(1)), t.transform(vertex(2)), t.transform(vertex(3))); } Orientation orientation() const; Oriented_side oriented_side(const Point_3 &p) const; Bounded_side bounded_side(const Point_3 &p) const; bool has_on_boundary(const Point_3 &p) const; bool has_on_positive_side(const Point_3 &p) const; bool has_on_negative_side(const Point_3 &p) const; bool has_on_bounded_side(const Point_3 &p) const; bool has_on_unbounded_side(const Point_3 &p) const; bool is_degenerate() const; FT volume() const; }; template < class R > bool TetrahedronC3:: operator==(const TetrahedronC3 &t) const { if (CGAL::identical(base, t.base)) return true; if (orientation() != t.orientation()) return false; std::vector< Point_3 > V1; std::vector< Point_3 > V2; typename std::vector< Point_3 >::iterator uniq_end1; typename std::vector< Point_3 >::iterator uniq_end2; int k; for ( k=0; k < 4; k++) V1.push_back( vertex(k)); for ( k=0; k < 4; k++) V2.push_back( t.vertex(k)); typename R::Less_xyz_3 Less_object = R().less_xyz_3_object(); std::sort(V1.begin(), V1.end(), Less_object); std::sort(V2.begin(), V2.end(), Less_object); uniq_end1 = std::unique( V1.begin(), V1.end()); uniq_end2 = std::unique( V2.begin(), V2.end()); V1.erase( uniq_end1, V1.end()); V2.erase( uniq_end2, V2.end()); return V1 == V2; } template < class R > inline bool TetrahedronC3:: operator!=(const TetrahedronC3 &t) const { return !(*this == t); } template < class R > const typename TetrahedronC3::Point_3 & TetrahedronC3:: vertex(int i) const { if (i<0) i=(i%4)+4; else if (i>3) i=i%4; switch (i) { case 0: return get(base).e0; case 1: return get(base).e1; case 2: return get(base).e2; default: return get(base).e3; } } template < class R > inline const typename TetrahedronC3::Point_3 & TetrahedronC3:: operator[](int i) const { return vertex(i); } template < class R > CGAL_KERNEL_MEDIUM_INLINE typename TetrahedronC3::FT TetrahedronC3::volume() const { return R().compute_volume_3_object()(*this); } template < class R > Orientation TetrahedronC3:: orientation() const { return R().orientation_3_object()(vertex(0), vertex(1), vertex(2), vertex(3)); } template < class R > Oriented_side TetrahedronC3:: oriented_side(const typename TetrahedronC3::Point_3 &p) const { Orientation o = orientation(); if (o != ZERO) return Oriented_side(o * bounded_side(p)); CGAL_kernel_assertion (!is_degenerate()); return ON_ORIENTED_BOUNDARY; } template < class R > Bounded_side TetrahedronC3:: bounded_side(const typename TetrahedronC3::Point_3 &p) const { return R().bounded_side_3_object() (static_cast(*this), p); } template < class R > inline bool TetrahedronC3::has_on_boundary (const typename TetrahedronC3::Point_3 &p) const { return oriented_side(p) == ON_ORIENTED_BOUNDARY; } template < class R > inline bool TetrahedronC3::has_on_positive_side (const typename TetrahedronC3::Point_3 &p) const { return oriented_side(p) == ON_POSITIVE_SIDE; } template < class R > inline bool TetrahedronC3::has_on_negative_side (const typename TetrahedronC3::Point_3 &p) const { return oriented_side(p) == ON_NEGATIVE_SIDE; } template < class R > inline bool TetrahedronC3::has_on_bounded_side (const typename TetrahedronC3::Point_3 &p) const { return bounded_side(p) == ON_BOUNDED_SIDE; } template < class R > inline bool TetrahedronC3::has_on_unbounded_side (const typename TetrahedronC3::Point_3 &p) const { return bounded_side(p) == ON_UNBOUNDED_SIDE; } template < class R > inline bool TetrahedronC3::is_degenerate() const { return orientation() == COPLANAR; } template < class R > inline Bbox_3 TetrahedronC3::bbox() const { typename R::Construct_bbox_3 construct_bbox_3; return construct_bbox_3(vertex(0)) + construct_bbox_3(vertex(1)) + construct_bbox_3(vertex(2)) + construct_bbox_3(vertex(3)); } #ifndef CGAL_NO_OSTREAM_INSERT_TETRAHEDRONC3 template < class R > std::ostream & operator<<(std::ostream &os, const TetrahedronC3 &t) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << t[0] << ' ' << t[1] << ' ' << t[2] << ' ' << t[3]; case IO::BINARY : return os << t[0] << t[1] << t[2] << t[3]; default: os << "TetrahedronC3(" << t[0] << ", " << t[1] << ", " << t[2]; os << ", " << t[3] << ")"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_TETRAHEDRONC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_TETRAHEDRONC3 template < class R > std::istream & operator>>(std::istream &is, TetrahedronC3 &t) { typename R::Point_3 p, q, r, s; is >> p >> q >> r >> s; if (is) t = TetrahedronC3(p, q, r, s); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_TETRAHEDRONC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_TETRAHEDRON_3_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Direction_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Direction_3.0000644000175000017500000001166611344301501031107 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Direction_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_DIRECTION_3_H #define CGAL_CARTESIAN_DIRECTION_3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class DirectionC3 { typedef typename R_::FT FT; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; DirectionC3() {} DirectionC3(const Vector_3 &v) : base(v.x(), v.y(), v.z()) {} // { *this = v.direction(); } DirectionC3(const Line_3 &l) { *this = l.direction(); } DirectionC3(const Ray_3 &r) { *this = r.direction(); } DirectionC3(const Segment_3 &s) { *this = s.direction(); } DirectionC3(const FT &x, const FT &y, const FT &z) : base(x, y, z) {} bool operator==(const DirectionC3 &d) const; bool operator!=(const DirectionC3 &d) const; Vector_3 to_vector() const; Vector_3 vector() const { return to_vector(); } Direction_3 transform(const Aff_transformation_3 &t) const { return t.transform(*this); } Direction_3 operator-() const; const FT & delta(int i) const; const FT & dx() const { return get(base).e0; } const FT & dy() const { return get(base).e1; } const FT & dz() const { return get(base).e2; } const FT & hdx() const { return dx(); } const FT & hdy() const { return dy(); } const FT & hdz() const { return dz(); } FT hw() const { return FT(1); } }; template < class R > inline bool DirectionC3::operator==(const DirectionC3 &d) const { if (CGAL::identical(base, d.base)) return true; return equal_directionC3(dx(), dy(), dz(), d.dx(), d.dy(), d.dz()); } template < class R > inline bool DirectionC3::operator!=(const DirectionC3 &d) const { return !(*this == d); } template < class R > inline typename DirectionC3::Vector_3 DirectionC3::to_vector() const { return Vector_3(dx(), dy(), dz()); } template < class R > inline typename DirectionC3::Direction_3 DirectionC3::operator-() const { return DirectionC3(-dx(), -dy(), -dz()); } template < class R > const typename DirectionC3::FT & DirectionC3::delta(int i) const { CGAL_kernel_precondition( i >= 0 && i <= 2 ); if (i==0) return dx(); if (i==1) return dy(); return dz(); } #ifndef CGAL_NO_OSTREAM_INSERT_DIRECTIONC3 template < class R > std::ostream & operator<<(std::ostream &os, const DirectionC3 &d) { typename R::Vector_3 v = d.to_vector(); switch(os.iword(IO::mode)) { case IO::ASCII : return os << v.x() << ' ' << v.y() << ' ' << v.z(); case IO::BINARY : write(os, v.x()); write(os, v.y()); write(os, v.z()); return os; default: os << "DirectionC3(" << v.x() << ", " << v.y() << ", " << v.z() << ")"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_DIRECTIONC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_DIRECTIONC3 template < class R > std::istream & operator>>(std::istream &is, DirectionC3 &d) { typename R::FT x, y, z; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y >> z; break; case IO::BINARY : read(is, x); read(is, y); read(is, z); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) d = DirectionC3(x, y, z); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_DIRECTIONC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_DIRECTION_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/ft_constructions_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/ft_construct0000644000175000017500000000452611344301501031401 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/ft_constructions_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_FT_CONSTRUCTIONS_3_H #define CGAL_CARTESIAN_FT_CONSTRUCTIONS_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class K > inline typename K::FT squared_distance(const PointC3 &p, const PointC3 &q) { return squared_distanceC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z()); } template < class K > inline typename K::FT scaled_distance_to_plane(const PlaneC3 &h, const PointC3 &p) { return scaled_distance_to_planeC3(h.a(), h.b(), h.c(), h.d(), p.x(), p.y(), p.z()); } template < class K > inline typename K::FT scaled_distance_to_plane(const PointC3 &hp, const PointC3 &hq, const PointC3 &hr, const PointC3 &p) { return scaled_distance_to_planeC3(hp.x(), hp.y(), hp.z(), hq.x(), hq.y(), hq.z(), hr.x(), hr.y(), hr.z(), p.x(), p.y(), p.z()); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_FT_CONSTRUCTIONS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Circle_2.h0000644000175000017500000002216111344301501030527 0ustar debiandebian// Copyright (c) 1997-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Circle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_CIRCLE_2_H #define CGAL_CARTESIAN_CIRCLE_2_H #include #include #include CGAL_BEGIN_NAMESPACE template class CircleC2 { typedef typename R_::FT FT; typedef typename R_::Circle_2 Circle_2; typedef typename R_::Point_2 Point_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Triple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; CircleC2() {} CircleC2(const Point_2 ¢er, const FT &squared_radius = FT(0), const Orientation &orient = COUNTERCLOCKWISE) // Is this new? { CGAL_kernel_precondition( ( squared_radius >= FT(0) ) && ( orient != COLLINEAR) ); base = Rep(center, squared_radius, orient); } CircleC2(const Point_2 ¢er, const Orientation &orient) // Is this new? { CGAL_kernel_precondition( orient != COLLINEAR ); base = Rep(center, FT(0), orient); } CircleC2(const Point_2 &p, const Point_2 &q, const Orientation &orient = COUNTERCLOCKWISE) // And this too? { // FIXME : construction CGAL_kernel_precondition( orient != COLLINEAR); typename R::Compute_squared_distance_2 squared_distance; typename R::Construct_midpoint_2 midpoint; if (p != q) { Point_2 center = midpoint(p, q); base = Rep(center, squared_distance(p, center), orient); } else base = Rep(p, FT(0), orient); } CircleC2(const Point_2 &p, const Point_2 &q, const Point_2 &r) { // FIXME : construction typename R::Orientation_2 orientation; typename R::Compute_squared_distance_2 squared_distance; typename R::Construct_circumcenter_2 circumcenter; Orientation orient = orientation(p, q, r); CGAL_kernel_precondition( orient != COLLINEAR); Point_2 center = circumcenter(p, q, r); base = Rep(center, squared_distance(p, center), orient); } bool operator==(const CircleC2 &s) const; bool operator!=(const CircleC2 &s) const; const Point_2 & center() const { return get(base).first; } const FT & squared_radius() const { return get(base).second; } Orientation orientation() const { return get(base).third; } Circle_2 opposite() const; Circle_2 orthogonal_transform(const Aff_transformation_2 &t) const; Oriented_side oriented_side(const Point_2 &p) const; Bounded_side bounded_side(const Point_2 &p) const; bool has_on_boundary(const Point_2 &p) const; bool has_on_negative_side(const Point_2 &p) const; bool has_on_positive_side(const Point_2 &p) const; bool has_on_bounded_side(const Point_2 &p) const; bool has_on_unbounded_side(const Point_2 &p) const; bool is_degenerate() const; Bbox_2 bbox() const; }; template < class R > CGAL_KERNEL_INLINE bool CircleC2::operator==(const CircleC2 &c) const { // FIXME : predicate if (CGAL::identical(base, c.base)) return true; return center() == c.center() && squared_radius() == c.squared_radius() && orientation() == c.orientation(); } template < class R > inline bool CircleC2::operator!=(const CircleC2 &c) const { return !(*this == c); } template < class R > CGAL_KERNEL_MEDIUM_INLINE Oriented_side CircleC2:: oriented_side(const typename CircleC2::Point_2 &p) const { return Oriented_side(bounded_side(p) * orientation()); } template < class R > CGAL_KERNEL_INLINE Bounded_side CircleC2:: bounded_side(const typename CircleC2::Point_2 &p) const { typename R::Compute_squared_distance_2 squared_distance; return Bounded_side(CGAL_NTS compare(squared_radius(), squared_distance(center(),p))); } template < class R > inline bool CircleC2:: has_on_boundary(const typename CircleC2::Point_2 &p) const { return bounded_side(p) == ON_BOUNDARY; } template < class R > inline bool CircleC2:: has_on_bounded_side(const typename CircleC2::Point_2 &p) const { return bounded_side(p) == ON_BOUNDED_SIDE; } template < class R > inline bool CircleC2:: has_on_unbounded_side(const typename CircleC2::Point_2 &p) const { return bounded_side(p) == ON_UNBOUNDED_SIDE; } template < class R > CGAL_KERNEL_INLINE bool CircleC2:: has_on_negative_side(const typename CircleC2::Point_2 &p) const { if (orientation() == COUNTERCLOCKWISE) return has_on_unbounded_side(p); return has_on_bounded_side(p); } template < class R > CGAL_KERNEL_INLINE bool CircleC2:: has_on_positive_side(const typename CircleC2::Point_2 &p) const { if (orientation() == COUNTERCLOCKWISE) return has_on_bounded_side(p); return has_on_unbounded_side(p); } template < class R > inline bool CircleC2::is_degenerate() const { return CGAL_NTS is_zero(squared_radius()); } template < class R > inline typename CircleC2::Circle_2 CircleC2::opposite() const { return CircleC2(center(), squared_radius(), CGAL::opposite(orientation()) ); } template < class R > CGAL_KERNEL_INLINE Bbox_2 CircleC2::bbox() const { typename R::Construct_bbox_2 construct_bbox_2; Bbox_2 b = construct_bbox_2(center()); Interval_nt<> x (b.xmin(), b.xmax()); Interval_nt<> y (b.ymin(), b.ymax()); Interval_nt<> sqr = CGAL_NTS to_interval(squared_radius()); Interval_nt<> r = CGAL::sqrt(sqr); Interval_nt<> minx = x-r; Interval_nt<> maxx = x+r; Interval_nt<> miny = y-r; Interval_nt<> maxy = y+r; return Bbox_2(minx.inf(), miny.inf(), maxx.sup(), maxy.sup()); } template < class R > CGAL_KERNEL_INLINE typename CircleC2::Circle_2 CircleC2::orthogonal_transform (const typename CircleC2::Aff_transformation_2 &t) const { typename R::Vector_2 vec(FT(1), FT(0) ); // unit vector vec = vec.transform(t); // transformed FT sq_scale = vec.squared_length(); // squared scaling factor return CircleC2(t.transform(center()), sq_scale * squared_radius(), t.is_even() ? orientation() : CGAL::opposite(orientation())); } #ifndef CGAL_NO_OSTREAM_INSERT_CIRCLEC2 template < class R > CGAL_KERNEL_INLINE std::ostream & operator<<(std::ostream &os, const CircleC2 &c) { switch(os.iword(IO::mode)) { case IO::ASCII : os << c.center() << ' ' << c.squared_radius() << ' ' << static_cast(c.orientation()); break; case IO::BINARY : os << c.center(); write(os, c.squared_radius()); write(os, static_cast(c.orientation())); break; default: os << "CircleC2(" << c.center() << ", " << c.squared_radius() ; switch (c.orientation()) { case CLOCKWISE: os << ", clockwise)"; break; case COUNTERCLOCKWISE: os << ", counterclockwise)"; break; default: os << ", collinear)"; break; } break; } return os; } #endif // CGAL_NO_OSTREAM_INSERT_CIRCLEC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_CIRCLEC2 template < class R > CGAL_KERNEL_INLINE std::istream& operator>>(std::istream &is, CircleC2 &c) { typename R::Point_2 center; typename R::FT squared_radius; int o; switch(is.iword(IO::mode)) { case IO::ASCII : is >> center >> squared_radius >> o; break; case IO::BINARY : is >> center; read(is, squared_radius); is >> o; break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) c = CircleC2(center, squared_radius, static_cast(o)); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_CIRCLEC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_CIRCLE_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Iso_rectangle_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Iso_rectangl0000644000175000017500000002110211344301501031262 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Iso_rectangle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_ISO_RECTANGLE_2_H #define CGAL_CARTESIAN_ISO_RECTANGLE_2_H #include CGAL_BEGIN_NAMESPACE template class Iso_rectangleC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Iso_rectangle_2 Iso_rectangle_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef typename R_::Construct_point_2 Construct_point_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; Iso_rectangleC2() {} Iso_rectangleC2(const Point_2 &p, const Point_2 &q) { FT minx, maxx, miny, maxy; if (p.x() < q.x()) { minx = p.x(); maxx = q.x(); } else { minx = q.x(); maxx = p.x(); } if (p.y() < q.y()) { miny = p.y(); maxy = q.y(); } else { miny = q.y(); maxy = p.y(); } Construct_point_2 construct_point_2; base = Rep(construct_point_2(minx, miny), construct_point_2(maxx, maxy)); } Iso_rectangleC2(const Point_2 &left, const Point_2 &right, const Point_2 &bottom, const Point_2 &top) : base(Construct_point_2()(left.x(), bottom.y()), Construct_point_2()(right.x(), top.y())) { CGAL_kernel_assertion_code(typename R::Less_x_2 less_x;) CGAL_kernel_assertion_code(typename R::Less_y_2 less_y;) CGAL_kernel_assertion(!less_x(right, left)); CGAL_kernel_assertion(!less_y(top, bottom)); } Iso_rectangleC2(const FT& min_x, const FT& min_y, const FT& max_x, const FT& max_y) : base(Construct_point_2()(min_x, min_y), Construct_point_2()(max_x, max_y)) { CGAL_kernel_precondition(min_x <= max_x); CGAL_kernel_precondition(min_y <= max_y); } Iso_rectangleC2(const FT& min_hx, const FT& min_hy, const FT& max_hx, const FT& max_hy, const FT& hw) { Construct_point_2 construct_point_2; if (hw == FT(1)) base = Rep(construct_point_2(min_hx, min_hy), construct_point_2(max_hx, max_hy)); else base = Rep(construct_point_2(min_hx/hw, min_hy/hw), construct_point_2(max_hx/hw, max_hy/hw)); } bool operator==(const Iso_rectangleC2 &s) const; bool operator!=(const Iso_rectangleC2 &s) const; const Point_2 & min() const { return get(base).e0; } const Point_2 & max() const { return get(base).e1; } Point_2 vertex(int i) const; Point_2 operator[](int i) const; Iso_rectangle_2 transform(const Aff_transformation_2 &t) const { // FIXME : We need a precondition like this!!! // CGAL_kernel_precondition(t.is_axis_preserving()); return Iso_rectangleC2(t.transform(vertex(0)), t.transform(vertex(2))); } Bounded_side bounded_side(const Point_2 &p) const; bool has_on_boundary(const Point_2 &p) const; bool has_on_bounded_side(const Point_2 &p) const; bool has_on_unbounded_side(const Point_2 &p) const; bool is_degenerate() const; Bbox_2 bbox() const; const FT & xmin() const; const FT & ymin() const; const FT & xmax() const; const FT & ymax() const; const FT & min_coord(int i) const; const FT & max_coord(int i) const; FT area() const; }; template < class R > inline bool Iso_rectangleC2:: operator==(const Iso_rectangleC2 &r) const { if (CGAL::identical(base, r.base)) return true; return vertex(0) == r.vertex(0) && vertex(2) == r.vertex(2); } template < class R > inline bool Iso_rectangleC2:: operator!=(const Iso_rectangleC2 &r) const { return !(*this == r); } template < class R > inline const typename Iso_rectangleC2::FT & Iso_rectangleC2::xmin() const { return min().x(); } template < class R > inline const typename Iso_rectangleC2::FT & Iso_rectangleC2::ymin() const { return min().y(); } template < class R > inline const typename Iso_rectangleC2::FT & Iso_rectangleC2::xmax() const { return max().x(); } template < class R > inline const typename Iso_rectangleC2::FT & Iso_rectangleC2::ymax() const { return max().y(); } template < class R > inline const typename Iso_rectangleC2::FT & Iso_rectangleC2::min_coord(int i) const { CGAL_kernel_precondition( i == 0 || i == 1 ); if (i == 0) return xmin(); else return ymin(); } template < class R > inline const typename Iso_rectangleC2::FT & Iso_rectangleC2::max_coord(int i) const { CGAL_kernel_precondition( i == 0 || i == 1 ); if (i == 0) return xmax(); else return ymax(); } template < class R > typename Iso_rectangleC2::Point_2 Iso_rectangleC2::vertex(int i) const { Construct_point_2 construct_point_2; switch (i%4) { case 0: return min(); case 1: return construct_point_2(xmax(), ymin()); case 2: return max(); default: return construct_point_2(xmin(), ymax()); } } template < class R > inline typename Iso_rectangleC2::Point_2 Iso_rectangleC2::operator[](int i) const { return vertex(i); } template < class R > inline typename Iso_rectangleC2::FT Iso_rectangleC2::area() const { return (xmax()-xmin()) * (ymax()-ymin()); } template < class R > CGAL_KERNEL_MEDIUM_INLINE Bounded_side Iso_rectangleC2:: bounded_side(const typename Iso_rectangleC2::Point_2 &p) const { // FIXME : predicate bool x_incr = (xmin() < p.x()) && (p.x() < xmax()), y_incr = (ymin() < p.y()) && (p.y() < ymax()); if (x_incr) { if (y_incr) return ON_BOUNDED_SIDE; if ( (p.y() == ymin()) || (ymax() == p.y()) ) return ON_BOUNDARY; } if ( (p.x() == xmin()) || (xmax() == p.x()) ) if ( y_incr || (p.y() == ymin()) || (ymax() == p.y()) ) return ON_BOUNDARY; return ON_UNBOUNDED_SIDE; } template < class R > inline bool Iso_rectangleC2:: has_on_boundary(const typename Iso_rectangleC2::Point_2 &p) const { return bounded_side(p) == ON_BOUNDARY; } template < class R > inline bool Iso_rectangleC2:: has_on_bounded_side(const typename Iso_rectangleC2::Point_2 &p) const { return bounded_side(p) == ON_BOUNDED_SIDE; } template < class R > inline bool Iso_rectangleC2:: has_on_unbounded_side(const typename Iso_rectangleC2::Point_2 &p) const { return bounded_side(p) == ON_UNBOUNDED_SIDE; } template < class R > inline bool Iso_rectangleC2::is_degenerate() const { return (xmin() == xmax()) || (ymin() == ymax()); } template < class R > inline Bbox_2 Iso_rectangleC2::bbox() const { typename R::Construct_bbox_2 construct_bbox_2; return construct_bbox_2(min()) + construct_bbox_2(max()); } #ifndef CGAL_NO_OSTREAM_INSERT_ISO_RECTANGLEC2 template < class R > std::ostream & operator<<(std::ostream &os, const Iso_rectangleC2 &r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r[0] << ' ' << r[2]; case IO::BINARY : return os << r[0] << r[2]; default: return os << "Iso_rectangleC2(" << r[0] << ", " << r[2] << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_ISO_RECTANGLEC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_ISO_RECTANGLEC2 template < class R > CGAL_KERNEL_MEDIUM_INLINE std::istream & operator>>(std::istream &is, Iso_rectangleC2 &r) { typename R::Point_2 p, q; is >> p >> q; if (is) r = Iso_rectangleC2(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_ISO_RECTANGLEC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_ISO_RECTANGLE_2_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/basic_constructions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/basic_constr0000644000175000017500000000261711344301501031334 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/basic_constructions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_BASIC_CONSTRUCTIONS_2_H #define CGAL_CARTESIAN_BASIC_CONSTRUCTIONS_2_H #include #include #include #endif // CGAL_CARTESIAN_BASIC_CONSTRUCTIONS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Sphere_3.h0000644000175000017500000002455111344301501030562 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Sphere_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_SPHERE_3_H #define CGAL_CARTESIAN_SPHERE_3_H #include #include CGAL_BEGIN_NAMESPACE template class SphereC3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Sphere_3 Sphere_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Triple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; SphereC3() {} SphereC3(const Point_3 ¢er, const FT &squared_radius, const Orientation &o = COUNTERCLOCKWISE) { CGAL_kernel_precondition( (squared_radius >= FT(0)) && (o != COLLINEAR) ); base = Rep(center, squared_radius, o); } // Sphere passing through and oriented by p,q,r,s SphereC3(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { Orientation orient = CGAL::orientation(p, q, r, s); Point_3 center = circumcenter(p, q, r, s); FT squared_radius = squared_distance(p, center); base = Rep(center, squared_radius, orient); } // Sphere with great circle passing through p,q,r, oriented by o SphereC3(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Orientation &o = COUNTERCLOCKWISE) { CGAL_kernel_precondition(o != COLLINEAR); Point_3 center = circumcenter(p, q, r); FT squared_radius = squared_distance(p, center); base = Rep(center, squared_radius, o); } // Sphere with diameter pq and orientation o SphereC3(const Point_3 &p, const Point_3 &q, const Orientation &o = COUNTERCLOCKWISE) { CGAL_kernel_precondition(o != COLLINEAR); Point_3 center = midpoint(p, q); FT squared_radius = squared_distance(p, center); base = Rep(center, squared_radius, o); } SphereC3(const Point_3 ¢er, const Orientation& o = COUNTERCLOCKWISE) { CGAL_kernel_precondition(o != COLLINEAR); base = Rep(center, FT(0), o); } bool operator==(const SphereC3 &) const; bool operator!=(const SphereC3 &) const; const Point_3 & center() const { return get(base).first; } const FT & squared_radius() const { // Returns the square of the radius (instead of the radius itself, // which would require square roots) return get(base).second; } Orientation orientation() const { return get(base).third; } Sphere_3 orthogonal_transform(const Aff_transformation_3 &t) const { // FIXME: precond: t.is_orthogonal() (*UNDEFINED*) Vector_3 vec(FT(1), FT(0)); // unit vector vec = vec.transform(t); // transformed FT sq_scale = vec.squared_length(); // squared scaling factor return SphereC3(t.transform(center()), sq_scale * squared_radius(), t.is_even() ? orientation() : CGAL::opposite(orientation())); } // A circle is degenerate if its (squared) radius is null or negative bool is_degenerate() const; // Returns a circle with opposite orientation Sphere_3 opposite() const; Oriented_side oriented_side(const Point_3 &p) const; //! precond: ! x.is_degenerate() (when available) // Returns R::ON_POSITIVE_SIDE, R::ON_ORIENTED_BOUNDARY or // R::ON_NEGATIVE_SIDE bool has_on_boundary(const Point_3 &p) const; bool has_on_positive_side(const Point_3 &p) const; bool has_on_negative_side(const Point_3 &p) const; Bounded_side bounded_side(const Point_3 &p) const; //! precond: ! x.is_degenerate() (when available) // Returns R::ON_BOUNDED_SIDE, R::ON_BOUNDARY or R::ON_UNBOUNDED_SIDE bool has_on_bounded_side(const Point_3 &p) const; bool has_on_unbounded_side(const Point_3 &p) const; Bbox_3 bbox() const; }; template < class R > CGAL_KERNEL_INLINE bool SphereC3::operator==(const SphereC3 &t) const { if (CGAL::identical(base, t.base)) return true; return center() == t.center() && squared_radius() == t.squared_radius() && orientation() == t.orientation(); } template < class R > inline bool SphereC3::operator!=(const SphereC3 &t) const { return !(*this == t); } template < class R > CGAL_KERNEL_MEDIUM_INLINE Oriented_side SphereC3:: oriented_side(const typename SphereC3::Point_3 &p) const { return Oriented_side(bounded_side(p) * orientation()); } template < class R > CGAL_KERNEL_INLINE Bounded_side SphereC3:: bounded_side(const typename SphereC3::Point_3 &p) const { // FIXME: it's a predicate... return Bounded_side(CGAL_NTS compare(squared_radius(), squared_distance(center(),p))); } template < class R > inline bool SphereC3:: has_on_boundary(const typename SphereC3::Point_3 &p) const { // FIXME: it's a predicate... return squared_distance(center(),p) == squared_radius(); // NB: J'ai aussi trouve ailleurs : // return oriented_side(p)==ON_ORIENTED_BOUNDARY; // a voir... } template < class R > CGAL_KERNEL_INLINE bool SphereC3:: has_on_negative_side(const typename SphereC3::Point_3 &p) const { if (orientation() == COUNTERCLOCKWISE) return has_on_unbounded_side(p); return has_on_bounded_side(p); // NB: J'ai aussi trouve ailleurs : // return oriented_side(p)==ON_NEGATIVE_SIDE; } template < class R > CGAL_KERNEL_INLINE bool SphereC3:: has_on_positive_side(const typename SphereC3::Point_3 &p) const { if (orientation() == COUNTERCLOCKWISE) return has_on_bounded_side(p); return has_on_unbounded_side(p); // NB: J'ai aussi trouve ailleurs : // return oriented_side(p)==ON_POSITIVE_SIDE; } template < class R > inline bool SphereC3:: has_on_bounded_side(const typename SphereC3::Point_3 &p) const { // FIXME: it's a predicate... return squared_distance(center(),p) < squared_radius(); // NB: J'ai aussi trouve ailleurs : // return bounded_side(p)==ON_BOUNDED_SIDE; } template < class R > inline bool SphereC3:: has_on_unbounded_side(const typename SphereC3::Point_3 &p) const { // FIXME: it's a predicate... return squared_distance(center(),p) > squared_radius(); // NB: J'ai aussi trouve ailleurs : // return bounded_side(p)==ON_UNBOUNDED_SIDE; } template < class R > inline bool SphereC3:: is_degenerate() const { // FIXME: it's a predicate (?) return CGAL_NTS is_zero(squared_radius()); } template < class R > inline typename SphereC3::Sphere_3 SphereC3::opposite() const { return SphereC3(center(), squared_radius(), CGAL::opposite(orientation()) ); } template < class R > CGAL_KERNEL_INLINE Bbox_3 SphereC3::bbox() const { typename R::Construct_bbox_3 construct_bbox_3; Bbox_3 b = construct_bbox_3(center()); Interval_nt<> x (b.xmin(), b.xmax()); Interval_nt<> y (b.ymin(), b.ymax()); Interval_nt<> z (b.zmin(), b.zmax()); Interval_nt<> sqr = CGAL_NTS to_interval(squared_radius()); Interval_nt<> r = CGAL::sqrt(sqr); Interval_nt<> minx = x-r; Interval_nt<> maxx = x+r; Interval_nt<> miny = y-r; Interval_nt<> maxy = y+r; Interval_nt<> minz = z-r; Interval_nt<> maxz = z+r; return Bbox_3(minx.inf(), miny.inf(), minz.inf(), maxx.sup(), maxy.sup(), maxz.sup()); } /* template < class R > inline EllipseC3::FT> SphereC3::i transform(const Aff_transformationC3::FT> &t) const { return SphereC3(t.transform(center()), squared_radius(), orientation()); } */ #ifndef CGAL_NO_OSTREAM_INSERT_SPHEREC3 template < class R > CGAL_KERNEL_INLINE std::ostream & operator<<(std::ostream &os, const SphereC3 &c) { switch(os.iword(IO::mode)) { case IO::ASCII : os << c.center() << ' ' << c.squared_radius() << ' ' << static_cast(c.orientation()); break; case IO::BINARY : os << c.center(); write(os, c.squared_radius()); write(os, static_cast(c.orientation())); break; default: os << "SphereC3(" << c.center() << ", " << c.squared_radius(); switch (c.orientation()) { case CLOCKWISE: os << ", clockwise)"; break; case COUNTERCLOCKWISE: os << ", counterclockwise)"; break; default: os << ", collinear)"; break; } break; } return os; } #endif // CGAL_NO_OSTREAM_INSERT_SPHEREC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_SPHEREC3 template < class R > CGAL_KERNEL_INLINE std::istream & operator>>(std::istream &is, SphereC3 &c) { typename R::Point_3 center; typename R::FT squared_radius; int o; switch(is.iword(IO::mode)) { case IO::ASCII : is >> center >> squared_radius >> o; break; case IO::BINARY : is >> center; read(is, squared_radius); is >> o; break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) c = SphereC3(center, squared_radius, static_cast(o)); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_SPHEREC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_SPHERE_3_H ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_directions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_o0000644000175000017500000000331211344301501031315 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_directions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_PREDICATES_ON_DIRECTIONS_2_H #define CGAL_CARTESIAN_PREDICATES_ON_DIRECTIONS_2_H CGAL_BEGIN_NAMESPACE template < class K > inline bool equal_direction(const DirectionC2 &d1, const DirectionC2 &d2) { return equal_directionC2(d1.dx(), d1.dy(), d2.dx(), d2.dy()); } template < class K > inline Comparison_result compare_angle_with_x_axis(const DirectionC2 &d1, const DirectionC2 &d2) { return K().compare_angle_with_x_axis_2_object()(d1, d2); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_PREDICATES_ON_DIRECTIONS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Point_3.h0000644000175000017500000001217111344301501030420 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Point_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri and Herve Bronnimann #ifndef CGAL_CARTESIAN_POINT_3_H #define CGAL_CARTESIAN_POINT_3_H #include #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class PointC3 { typedef typename R_::FT FT; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Point_3 Point_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef const FT* Cartesian_const_iterator; typedef R_ R; PointC3() {} PointC3(const Origin &) : base(FT(0), FT(0), FT(0)) {} PointC3(const FT &x, const FT &y, const FT &z) : base(x, y, z) {} PointC3(const FT &x, const FT &y, const FT &z, const FT &w) { if (w != FT(1)) base = Rep(x/w, y/w, z/w); else base = Rep(x, y, z); } /* bool operator==(const PointC3 &p) const { if (CGAL::identical(base, p.base)) return true; return x_equal(*this, p) && y_equal(*this, p) && z_equal(*this, p); } bool operator!=(const PointC3 &p) const { return !(*this == p); } */ const FT & x() const { return get(base).e0; } const FT & y() const { return get(base).e1; } const FT & z() const { return get(base).e2; } const FT & hx() const { return x(); } const FT & hy() const { return y(); } const FT & hz() const { return z(); } FT hw() const { return FT(1); } const FT & cartesian(int i) const; const FT & operator[](int i) const; FT homogeneous(int i) const; Cartesian_const_iterator cartesian_begin() const { return & get(base).e0; } Cartesian_const_iterator cartesian_end() const { const FT* ptr = & get(base).e2; ptr++; return ptr; } int dimension() const { return 3; } Bbox_3 bbox() const; Point_3 transform(const Aff_transformation_3 &t) const { return t.transform(*this); } }; template < class R > inline const typename PointC3::FT & PointC3::cartesian(int i) const { CGAL_kernel_precondition( (i>=0) && (i<=2) ); return *(&(get(base).e0)+i); } template < class R > inline const typename PointC3::FT & PointC3::operator[](int i) const { return cartesian(i); } template < class R > inline typename PointC3::FT PointC3::homogeneous(int i) const { CGAL_kernel_precondition(i>=0 && i<=3); if (i<3) return cartesian(i); return FT(1); } template < class R > Bbox_3 PointC3::bbox() const { std::pair xp = CGAL_NTS to_interval(x()); std::pair yp = CGAL_NTS to_interval(y()); std::pair zp = CGAL_NTS to_interval(z()); return Bbox_3(xp.first, yp.first, zp.first, xp.second, yp.second, zp.second); } #ifndef CGAL_CARTESIAN_NO_OSTREAM_INSERT_POINTC3 template < class R > std::ostream & operator<<(std::ostream &os, const PointC3 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.x() << ' ' << p.y() << ' ' << p.z(); case IO::BINARY : write(os, p.x()); write(os, p.y()); write(os, p.z()); return os; default: os << "PointC3(" << p.x() << ", " << p.y() << ", " << p.z() << ")"; return os; } } #endif // CGAL_CARTESIAN_NO_OSTREAM_INSERT_POINTC3 #ifndef CGAL_CARTESIAN_NO_ISTREAM_EXTRACT_POINTC3 template < class R > std::istream & operator>>(std::istream &is, PointC3 &p) { typename R::FT x, y, z; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y >> z; break; case IO::BINARY : read(is, x); read(is, y); read(is, z); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) p = PointC3(x, y, z); return is; } #endif // CGAL_CARTESIAN_NO_ISTREAM_EXTRACT_POINTC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_POINT_3_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/plane_constructions_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/plane_constr0000644000175000017500000000414011344301501031343 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/plane_constructions_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann, Sylvain Pion #ifndef CGAL_CARTESIAN_PLANE_CONSTRUCTIONS_3_H #define CGAL_CARTESIAN_PLANE_CONSTRUCTIONS_3_H #include #include CGAL_BEGIN_NAMESPACE template CGAL_KERNEL_LARGE_INLINE PlaneC3 plane_from_points(const PointC3 &p, const PointC3 &q, const PointC3 &r) { typename R::FT a, b, c, d; plane_from_pointsC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), a, b, c, d); return PlaneC3(a, b, c, d); } template CGAL_KERNEL_LARGE_INLINE PlaneC3 plane_from_point_direction(const PointC3 &p, const DirectionC3 &d) { typename R::FT A, B, C, D; plane_from_point_directionC3(p.x(), p.y(), p.z(), d.dx(), d.dy(), d.dz(), A, B, C, D); return PlaneC3(A, B, C, D); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_PLANE_CONSTRUCTIONS_3_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Data_accessor_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Data_accesso0000644000175000017500000000346411344301501031235 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Data_accessor_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_DATA_ACCESSOR_2_H #define CGAL_CARTESIAN_DATA_ACCESSOR_2_H CGAL_BEGIN_NAMESPACE // 2D Cartesian point data accessor template < class R_ > class Data_accessorC2 { public: // Min_ellipse_2 wants FT public... typedef typename R_::FT FT; typedef typename R_::Point_2 Point; typedef R_ R; FT get_x( const Point &p) const { return( p.x()); } FT get_y( const Point &p) const { return( p.y()); } void get( const Point &p, FT &x, FT &y) const { x=get_x(p); y=get_y(p); } void set( Point& p, const FT &x, const FT &y) const { p=Point(x,y); } }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_DATA_ACCESSOR_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Ray_3.h0000644000175000017500000001327411344301501030067 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Ray_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_RAY_3_H #define CGAL_CARTESIAN_RAY_3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class RayC3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; RayC3() {} RayC3(const Point_3 &sp, const Point_3 &secondp) : base(sp, secondp) {} RayC3(const Point_3 &sp, const Vector_3 &v) : base(sp, sp + v) {} RayC3(const Point_3 &sp, const Direction_3 &d) : base(sp, sp + d.to_vector()) {} RayC3(const Point_3 &sp, const Line_3 &l) : base(sp, sp + l.to_vector()) {} bool operator==(const RayC3 &r) const; bool operator!=(const RayC3 &r) const; const Point_3 & start() const; const Point_3 & source() const { return get(base).e0; } const Point_3 & second_point() const { return get(base).e1; } Point_3 point(int i) const; Direction_3 direction() const; Vector_3 to_vector() const; Line_3 supporting_line() const; Ray_3 opposite() const; Ray_3 transform(const Aff_transformation_3 &t) const { return RayC3(t.transform(source()), t.transform(second_point())); } bool is_degenerate() const; bool has_on(const Point_3 &p) const; bool collinear_has_on(const Point_3 &p) const; }; template < class R > inline bool RayC3::operator==(const RayC3 &r) const { if (CGAL::identical(base, r.base)) return true; return source() == r.source() && direction() == r.direction(); } template < class R > inline bool RayC3::operator!=(const RayC3 &r) const { return !(*this == r); } template < class R > inline const typename RayC3::Point_3 & RayC3::start() const { return source(); } template < class R > CGAL_KERNEL_INLINE typename RayC3::Point_3 RayC3::point(int i) const { CGAL_kernel_precondition( i >= 0 ); if (i == 0) return source(); if (i == 1) return second_point(); return source() + FT(i) * (second_point() - source()); } template < class R > inline typename RayC3::Vector_3 RayC3::to_vector() const { return second_point() - source(); } template < class R > inline typename RayC3::Direction_3 RayC3::direction() const { return Direction_3( second_point() - source() ); } template < class R > inline typename RayC3::Line_3 RayC3::supporting_line() const { return Line_3(*this); } template < class R > inline typename RayC3::Ray_3 RayC3::opposite() const { return RayC3( source(), - direction() ); } template < class R > bool RayC3:: has_on(const typename RayC3::Point_3 &p) const { return (p == source()) || ( collinear(source(), p, second_point()) && ( Direction_3(p - source()) == direction() )); } template < class R > inline bool RayC3::is_degenerate() const { return source() == second_point(); } template < class R > inline bool RayC3:: collinear_has_on(const typename RayC3::Point_3 &p) const { CGAL_kernel_exactness_precondition( collinear(source(), p, second_point()) ); Comparison_result cx = compare_x(source(), second_point()); if (cx != EQUAL) return cx != compare_x(p, source()); Comparison_result cy = compare_y(source(), second_point()); if (cy != EQUAL) return cy != compare_y(p, source()); Comparison_result cz = compare_z(source(), second_point()); if (cz != EQUAL) return cz != compare_z(p, source()); return true; // p == source() } #ifndef CGAL_NO_OSTREAM_INSERT_RAYC3 template < class R > std::ostream & operator<<(std::ostream &os, const RayC3 &r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r.start() << ' ' << r.direction(); case IO::BINARY : return os<< r.start() << r.direction(); default: return os << "RayC3(" << r.start() << ", " << r.direction() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_RAYC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_RAYC3 template < class R > std::istream & operator>>(std::istream &is, RayC3 &r) { typename R::Point_3 p; typename R::Direction_3 d; is >> p >> d; if (is) r = RayC3(p, d); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_RAYC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_RAY_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Triangle_2.h0000644000175000017500000002005611344301501031074 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Triangle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_TRIANGLE_2_H #define CGAL_CARTESIAN_TRIANGLE_2_H #include #include CGAL_BEGIN_NAMESPACE template class TriangleC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Triangle_2 Triangle_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; TriangleC2() {} TriangleC2(const Point_2 &p, const Point_2 &q, const Point_2 &r) : base(p, q, r) {} bool operator==(const TriangleC2 &s) const; bool operator!=(const TriangleC2 &s) const; const Point_2 & vertex(int i) const; const Point_2 & operator[](int i) const; Triangle_2 opposite() const; Triangle_2 transform(const Aff_transformation_2 &t) const { return TriangleC2(t.transform(vertex(0)), t.transform(vertex(1)), t.transform(vertex(2))); } Orientation orientation() const; Oriented_side oriented_side(const Point_2 &p) const; Bounded_side bounded_side(const Point_2 &p) const; bool has_on_boundary(const Point_2 &p) const; bool has_on_bounded_side(const Point_2 &p) const; bool has_on_unbounded_side(const Point_2 &p) const; bool has_on_positive_side(const Point_2 &p) const; bool has_on_negative_side(const Point_2 &p) const; bool is_degenerate() const; Bbox_2 bbox() const; FT area() const; }; template < class R > CGAL_KERNEL_MEDIUM_INLINE bool TriangleC2::operator==(const TriangleC2 &t) const { if (CGAL::identical(base, t.base)) return true; int i; for(i=0; i<3; i++) if ( vertex(0) == t.vertex(i) ) break; return (i<3) && vertex(1) == t.vertex(i+1) && vertex(2) == t.vertex(i+2); } template < class R > inline bool TriangleC2::operator!=(const TriangleC2 &t) const { return !(*this == t); } template < class R > CGAL_KERNEL_MEDIUM_INLINE const typename TriangleC2::Point_2 & TriangleC2::vertex(int i) const { if (i>2) i = i%3; else if (i<0) i = (i%3) + 3; return (i==0) ? get(base).e0 : (i==1) ? get(base).e1 : get(base).e2; } template < class R > inline const typename TriangleC2::Point_2 & TriangleC2::operator[](int i) const { return vertex(i); } template < class R > CGAL_KERNEL_MEDIUM_INLINE typename TriangleC2::FT TriangleC2::area() const { typename R::Compute_area_2 compute_area; return compute_area(vertex(0), vertex(1), vertex(2)); } template < class R > inline Orientation TriangleC2::orientation() const { typename R::Orientation_2 orientation; return orientation(vertex(0), vertex(1), vertex(2)); } template < class R > CGAL_KERNEL_LARGE_INLINE Bounded_side TriangleC2:: bounded_side(const typename TriangleC2::Point_2 &p) const { typename R::Collinear_are_ordered_along_line_2 collinear_are_ordered_along_line; typename R::Orientation_2 orientation; Orientation o1 = orientation(vertex(0), vertex(1), p), o2 = orientation(vertex(1), vertex(2), p), o3 = orientation(vertex(2), vertex(3), p); if (o2 == o1 && o3 == o1) return ON_BOUNDED_SIDE; return (o1 == COLLINEAR && collinear_are_ordered_along_line(vertex(0), p, vertex(1))) || (o2 == COLLINEAR && collinear_are_ordered_along_line(vertex(1), p, vertex(2))) || (o3 == COLLINEAR && collinear_are_ordered_along_line(vertex(2), p, vertex(3))) ? ON_BOUNDARY : ON_UNBOUNDED_SIDE; } template < class R > CGAL_KERNEL_LARGE_INLINE Oriented_side TriangleC2:: oriented_side(const typename TriangleC2::Point_2 &p) const { typename R::Collinear_are_ordered_along_line_2 collinear_are_ordered_along_line; typename R::Orientation_2 orientation; // depends on the orientation of the vertices Orientation o1 = orientation(vertex(0), vertex(1), p), o2 = orientation(vertex(1), vertex(2), p), o3 = orientation(vertex(2), vertex(3), p), ot = orientation(vertex(0), vertex(1), vertex(2)); if (o1 == ot && o2 == ot && o3 == ot) // ot cannot be COLLINEAR return Oriented_side(ot); return (o1 == COLLINEAR && collinear_are_ordered_along_line(vertex(0), p, vertex(1))) || (o2 == COLLINEAR && collinear_are_ordered_along_line(vertex(1), p, vertex(2))) || (o3 == COLLINEAR && collinear_are_ordered_along_line(vertex(2), p, vertex(3))) ? ON_ORIENTED_BOUNDARY : Oriented_side(-ot); } template < class R > CGAL_KERNEL_LARGE_INLINE bool TriangleC2:: has_on_bounded_side(const typename TriangleC2::Point_2 &p) const { return bounded_side(p) == ON_BOUNDED_SIDE; } template < class R > CGAL_KERNEL_LARGE_INLINE bool TriangleC2:: has_on_unbounded_side(const typename TriangleC2::Point_2 &p) const { return bounded_side(p) == ON_UNBOUNDED_SIDE; } template < class R > inline bool TriangleC2:: has_on_boundary(const typename TriangleC2::Point_2 &p) const { return bounded_side(p) == ON_BOUNDARY; } template < class R > inline bool TriangleC2:: has_on_negative_side(const typename TriangleC2::Point_2 &p) const { return oriented_side(p) == ON_NEGATIVE_SIDE; } template < class R > inline bool TriangleC2:: has_on_positive_side(const typename TriangleC2::Point_2 &p) const { return oriented_side(p) == ON_POSITIVE_SIDE; } template < class R > inline bool TriangleC2::is_degenerate() const { typename R::Collinear_2 collinear; return collinear(vertex(0), vertex(1), vertex(2)); } template < class R > inline Bbox_2 TriangleC2::bbox() const { typename R::Construct_bbox_2 construct_bbox_2; return construct_bbox_2(vertex(0)) + construct_bbox_2(vertex(1)) + construct_bbox_2(vertex(2)); } template < class R > inline typename TriangleC2::Triangle_2 TriangleC2::opposite() const { return TriangleC2(vertex(0), vertex(2), vertex(1)); } #ifndef CGAL_NO_OSTREAM_INSERT_TRIANGLEC2 template < class R > std::ostream & operator<<(std::ostream &os, const TriangleC2 &t) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << t[0] << ' ' << t[1] << ' ' << t[2]; case IO::BINARY : return os << t[0] << t[1] << t[2]; default: return os<< "TriangleC2(" << t[0] << ", " << t[1] << ", " << t[2] <<")"; } } #endif // CGAL_NO_OSTREAM_INSERT_TRIANGLEC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_TRIANGLEC2 template < class R > std::istream & operator>>(std::istream &is, TriangleC2 &t) { typename R::Point_2 p, q, r; is >> p >> q >> r; if (is) t = TriangleC2(p, q, r); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_TRIANGLEC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_TRIANGLE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Plane_3.h0000644000175000017500000002115511344301501030370 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Plane_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_PLANE_3_H #define CGAL_CARTESIAN_PLANE_3_H #include CGAL_BEGIN_NAMESPACE template class PlaneC3 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Construct_point_3 Construct_point_3; typedef typename R_::Construct_point_2 Construct_point_2; typedef Fourtuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; PlaneC3() {} PlaneC3(const Point_3 &p, const Point_3 &q, const Point_3 &r) { *this = plane_from_points(p, q, r); } PlaneC3(const Point_3 &p, const Direction_3 &d) { *this = plane_from_point_direction(p, d); } PlaneC3(const Point_3 &p, const Vector_3 &v) { *this = plane_from_point_direction(p, v.direction()); } PlaneC3(const FT &a, const FT &b, const FT &c, const FT &d) : base(a, b, c, d) {} PlaneC3(const Line_3 &l, const Point_3 &p) { *this = plane_from_points(l.point(), l.point()+l.direction().to_vector(), p); } PlaneC3(const Segment_3 &s, const Point_3 &p) { *this = plane_from_points(s.start(), s.end(), p); } PlaneC3(const Ray_3 &r, const Point_3 &p) { *this = plane_from_points(r.start(), r.second_point(), p); } bool operator==(const PlaneC3 &p) const; bool operator!=(const PlaneC3 &p) const; const FT & a() const { return get(base).e0; } const FT & b() const { return get(base).e1; } const FT & c() const { return get(base).e2; } const FT & d() const { return get(base).e3; } Line_3 perpendicular_line(const Point_3 &p) const; Plane_3 opposite() const; Point_3 point() const; Point_3 projection(const Point_3 &p) const; Vector_3 orthogonal_vector() const; Direction_3 orthogonal_direction() const; Vector_3 base1() const; Vector_3 base2() const; Point_3 to_plane_basis(const Point_3 &p) const; Point_2 to_2d(const Point_3 &p) const; Point_3 to_3d(const Point_2 &p) const; Plane_3 transform(const Aff_transformation_3 &t) const { if (t.is_even()) return PlaneC3(t.transform(point()), t.transpose().inverse().transform(orthogonal_direction())); else return PlaneC3( t.transform(point()), - t.transpose().inverse().transform(orthogonal_direction())); } Oriented_side oriented_side(const Point_3 &p) const; bool has_on_positive_side(const Point_3 &l) const; bool has_on_negative_side(const Point_3 &l) const; bool has_on(const Point_3 &p) const { return oriented_side(p) == ON_ORIENTED_BOUNDARY; } bool has_on(const Line_3 &l) const { return has_on(l.point()) && has_on(l.point() + l.direction().to_vector()); } bool is_degenerate() const; }; template < class R > CGAL_KERNEL_INLINE bool PlaneC3::operator==(const PlaneC3 &p) const { if (CGAL::identical(base, p.base)) return true; return equal_plane(*this, p); } template < class R > inline bool PlaneC3::operator!=(const PlaneC3 &p) const { return !(*this == p); } template < class R > inline typename PlaneC3::Point_3 PlaneC3::point() const { return point_on_plane(*this); } template < class R > inline typename PlaneC3::Point_3 PlaneC3:: projection(const typename PlaneC3::Point_3 &p) const { return projection_plane(p, *this); } template < class R > inline typename PlaneC3::Vector_3 PlaneC3::orthogonal_vector() const { return R().construct_orthogonal_vector_3_object()(*this); } template < class R > inline typename PlaneC3::Direction_3 PlaneC3::orthogonal_direction() const { return Direction_3(a(), b(), c()); } template < class R > typename PlaneC3::Vector_3 PlaneC3::base1() const { return R().construct_base_vector_3_object()(*this, 1); } template < class R > typename PlaneC3::Vector_3 PlaneC3::base2() const { return R().construct_base_vector_3_object()(*this, 2); } template < class R > typename PlaneC3::Point_3 PlaneC3:: to_plane_basis(const typename PlaneC3::Point_3 &p) const { FT alpha, beta, gamma; Construct_point_3 construct_point_3; solve(base1(), base2(), orthogonal_vector(), p - point(), alpha, beta, gamma); return construct_point_3(alpha, beta, gamma); } template < class R > typename PlaneC3::Point_2 PlaneC3:: to_2d(const typename PlaneC3::Point_3 &p) const { FT alpha, beta, gamma; Construct_point_2 construct_point_2; solve(base1(), base2(), orthogonal_vector(), p - point(), alpha, beta, gamma); return construct_point_2(alpha, beta); } template < class R > inline typename PlaneC3::Point_3 PlaneC3:: to_3d(const typename PlaneC3::Point_2 &p) const { return R().construct_lifted_point_3_object()(*this, p); } template < class R > inline typename PlaneC3::Line_3 PlaneC3:: perpendicular_line(const typename PlaneC3::Point_3 &p) const { return Line_3(p, orthogonal_direction()); } template < class R > inline typename PlaneC3::Plane_3 PlaneC3::opposite() const { return PlaneC3(-a(), -b(), -c(), -d()); } template < class R > inline Oriented_side PlaneC3:: oriented_side(const typename PlaneC3::Point_3 &p) const { return side_of_oriented_plane(*this, p); } template < class R > inline bool PlaneC3:: has_on_positive_side(const typename PlaneC3::Point_3 &p) const { return oriented_side(p) == ON_POSITIVE_SIDE; } template < class R > inline bool PlaneC3:: has_on_negative_side(const typename PlaneC3::Point_3 &p) const { return oriented_side(p) == ON_NEGATIVE_SIDE; } template < class R > inline bool PlaneC3:: is_degenerate() const { // FIXME : predicate return CGAL_NTS is_zero(a()) && CGAL_NTS is_zero(b()) && CGAL_NTS is_zero(c()); } #ifndef CGAL_NO_OSTREAM_INSERT_PLANEC3 template < class R > std::ostream & operator<<(std::ostream &os, const PlaneC3 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.a() << ' ' << p.b() << ' ' << p.c() << ' ' << p.d(); case IO::BINARY : write(os, p.a()); write(os, p.b()); write(os, p.c()); write(os, p.d()); return os; default: os << "PlaneC3(" << p.a() << ", " << p.b() << ", "; os << p.c() << ", " << p.d() <<")"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_PLANEC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_PLANEC3 template < class R > std::istream & operator>>(std::istream &is, PlaneC3 &p) { typename R::FT a, b, c, d; switch(is.iword(IO::mode)) { case IO::ASCII : is >> a >> b >> c >> d; break; case IO::BINARY : read(is, a); read(is, b); read(is, c); read(is, d); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) p = PlaneC3(a, b, c, d); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_PLANEC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_PLANE_3_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Direction_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Direction_2.0000644000175000017500000001460711344301501031104 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Direction_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_DIRECTION_2_H #define CGAL_CARTESIAN_DIRECTION_2_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class DirectionC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; DirectionC2() {} DirectionC2(const Vector_2 &v) { *this = v.direction(); } DirectionC2(const Line_2 &l) { *this = l.direction(); } DirectionC2(const Ray_2 &r) { *this = r.direction(); } DirectionC2(const Segment_2 &s) { *this = s.direction(); } DirectionC2(const FT &x, const FT &y) : base(x, y) {} bool operator==(const DirectionC2 &d) const; bool operator!=(const DirectionC2 &d) const; bool operator>=(const DirectionC2 &d) const; bool operator<=(const DirectionC2 &d) const; bool operator>(const DirectionC2 &d) const; bool operator<(const DirectionC2 &d) const; bool counterclockwise_in_between( const Direction_2 &d1, const Direction_2 &d2) const; Vector_2 to_vector() const; Vector_2 vector() const { return to_vector(); } Direction_2 perpendicular(const Orientation &o) const; Direction_2 transform(const Aff_transformation_2 &t) const { return t.transform(*this); } Direction_2 operator-() const; const FT & delta(int i) const; const FT & dx() const { return get(base).e0; } const FT & dy() const { return get(base).e1; } }; template < class R > inline bool DirectionC2::operator==(const DirectionC2 &d) const { if (CGAL::identical(base, d.base)) return true; return equal_direction(*this, d); } template < class R > inline bool DirectionC2::operator!=(const DirectionC2 &d) const { return !( *this == d ); } template < class R > CGAL_KERNEL_MEDIUM_INLINE bool DirectionC2::operator<(const DirectionC2 &d) const { return compare_angle_with_x_axis(*this, d) == SMALLER; } template < class R > CGAL_KERNEL_INLINE bool DirectionC2::operator>(const DirectionC2 &d) const { return d < *this; } template < class R > CGAL_KERNEL_INLINE bool DirectionC2::operator>=(const DirectionC2 &d) const { return compare_angle_with_x_axis(*this, d) != SMALLER; } template < class R > CGAL_KERNEL_INLINE bool DirectionC2::operator<=(const DirectionC2 &d) const { return compare_angle_with_x_axis(*this, d) != LARGER; } template < class R > CGAL_KERNEL_INLINE bool DirectionC2:: counterclockwise_in_between(const typename DirectionC2::Direction_2 &d1, const typename DirectionC2::Direction_2 &d2) const // returns true, iff \ccVar\ is not equal to \ccc{d1}, and // while rotating counterclockwise starting at \ccc{d1}, // \ccVar\ is reached strictly before \ccc{d2} is reached. // Note that true is returned if \ccc{d1} == \ccc{d2}, unless // also \ccVar\ == \ccc{d1}. { return R().counterclockwise_in_between_2_object() (static_cast(*this), d1, d2); } template < class R > inline typename DirectionC2::Vector_2 DirectionC2::to_vector() const { return Vector_2(dx(), dy()); } template < class R > CGAL_KERNEL_MEDIUM_INLINE typename DirectionC2::Direction_2 DirectionC2::perpendicular(const Orientation &o) const { CGAL_kernel_precondition(o != COLLINEAR); if (o == COUNTERCLOCKWISE) return DirectionC2(-dy(), dx()); else return DirectionC2(dy(), -dx()); } template < class R > inline typename DirectionC2::Direction_2 DirectionC2::operator-() const { return DirectionC2(-dx(), -dy()); } template < class R > CGAL_KERNEL_INLINE const typename DirectionC2::FT & DirectionC2::delta(int i) const { CGAL_kernel_precondition( ( i == 0 ) || ( i == 1 ) ); return (i==0) ? dx() : dy(); } #ifndef CGAL_NO_OSTREAM_INSERT_DIRECTIONC2 template < class R > std::ostream& operator<<(std::ostream &os, const DirectionC2 &d) { typename R::Vector_2 v = d.to_vector(); switch(os.iword(IO::mode)) { case IO::ASCII : return os << v.x() << ' ' << v.y(); case IO::BINARY : write(os, v.x()); write(os, v.y()); return os; default: return os << "DirectionC2(" << v.x() << ", " << v.y() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_DIRECTIONC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_DIRECTIONC2 template < class R > std::istream& operator>>(std::istream &is, DirectionC2 &p) { typename R::FT x, y; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y; break; case IO::BINARY : read(is, x); read(is, y); break; default: std::cerr << std::endl << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) p = DirectionC2(x, y); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_DIRECTIONC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_DIRECTION_2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_points_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_o0000644000175000017500000000513611344301501031323 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_points_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_PREDICATES_ON_POINTS_3_H #define CGAL_CARTESIAN_PREDICATES_ON_POINTS_3_H #include CGAL_BEGIN_NAMESPACE template < class K > inline bool equal_xy(const PointC3 &p, const PointC3 &q) { return K().equal_xy_3_object()(p, q); } template < class K > inline bool equal_xyz(const PointC3 &p, const PointC3 &q) { return p.x() == q.x() && p.y() == q.y() && p.z() == q.z(); } template < class K > inline Comparison_result compare_xy(const PointC3 &p, const PointC3 &q) { return K().compare_xy_3_object()(p, q); } template < class K > inline Comparison_result compare_lexicographically_xy(const PointC3 &p, const PointC3 &q) { return K().compare_xy_3_object()(p, q); } template < class K > inline bool lexicographically_xy_smaller_or_equal(const PointC3 &p, const PointC3 &q) { return compare_lexicographically_xy(p, q) != LARGER; } template < class K > inline bool lexicographically_xy_smaller(const PointC3 &p, const PointC3 &q) { return K().less_xy_3_object()(p, q); } template < class K > inline bool strict_dominance(const PointC3 &p, const PointC3 &q) { return strict_dominanceC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z()); } template < class K > inline bool dominance(const PointC3 &p, const PointC3 &q) { return dominanceC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z()); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_PREDICATES_ON_POINTS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Vector_2.h0000644000175000017500000001544611344301501030600 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Vector_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_VECTOR_2_H #define CGAL_CARTESIAN_VECTOR_2_H #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class VectorC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; VectorC2() {} VectorC2(const Null_vector &n) { *this = R().construct_vector_2_object()(n); } VectorC2(const Point_2 &a, const Point_2 &b) { *this = R().construct_vector_2_object()(a, b); } VectorC2(const Segment_2 &s) { *this = R().construct_vector_2_object()(s); } VectorC2(const Ray_2 &r) { *this = R().construct_vector_2_object()(r); } VectorC2(const Line_2 &l) { *this = R().construct_vector_2_object()(l); } VectorC2(const FT &x, const FT &y) : base(x, y) {} VectorC2(const FT &hx, const FT &hy, const FT &hw) { if (hw != FT(1)) base = Rep(hx/hw, hy/hw); else base = Rep(hx, hy); } const FT & x() const { return get(base).e0; } const FT & y() const { return get(base).e1; } const FT & hx() const { return x(); } const FT & hy() const { return y(); } FT hw() const { return FT(1); } const FT & cartesian(int i) const; const FT & operator[](int i) const; FT homogeneous(int i) const; int dimension() const { return 2; } Vector_2 operator+(const VectorC2 &w) const; Vector_2 operator-(const VectorC2 &w) const; Vector_2 operator-() const; FT squared_length() const; Vector_2 operator/(const FT &c) const; Direction_2 direction() const; Vector_2 perpendicular(const Orientation &o) const; Vector_2 transform(const Aff_transformation_2 &t) const { return t.transform(*this); } }; template < class R > CGAL_KERNEL_INLINE bool operator==(const VectorC2 &v, const VectorC2 &w) { return w.x() == v.x() && w.y() == v.y(); } template < class R > inline bool operator!=(const VectorC2 &v, const VectorC2 &w) { return !(v == w); } template < class R > inline bool operator==(const VectorC2 &v, const Null_vector &) { return CGAL_NTS is_zero(v.x()) && CGAL_NTS is_zero(v.y()); } template < class R > inline bool operator==(const Null_vector &n, const VectorC2 &v) { return v == n; } template < class R > inline bool operator!=(const VectorC2 &v, const Null_vector &n) { return !(v == n); } template < class R > inline bool operator!=(const Null_vector &n, const VectorC2 &v) { return !(v == n); } template < class R > CGAL_KERNEL_INLINE const typename VectorC2::FT & VectorC2::cartesian(int i) const { CGAL_kernel_precondition( (i == 0) || (i == 1) ); return (i == 0) ? x() : y(); } template < class R > inline const typename VectorC2::FT & VectorC2::operator[](int i) const { return cartesian(i); } template < class R > CGAL_KERNEL_INLINE typename VectorC2::FT VectorC2::homogeneous(int i) const { return (i == 2) ? FT(1) : cartesian(i); } template < class R > CGAL_KERNEL_INLINE typename VectorC2::Vector_2 VectorC2::operator+(const VectorC2 &w) const { return VectorC2(x() + w.x(), y() + w.y()); } template < class R > CGAL_KERNEL_INLINE typename VectorC2::Vector_2 VectorC2::operator-(const VectorC2 &w) const { return VectorC2(x() - w.x(), y() - w.y()); } template < class R > inline typename VectorC2::Vector_2 VectorC2::operator-() const { return R().construct_opposite_vector_2_object()(*this); } template < class R > CGAL_KERNEL_INLINE typename VectorC2::FT VectorC2::squared_length() const { return CGAL_NTS square(x()) + CGAL_NTS square(y()); } template < class R > CGAL_KERNEL_INLINE typename VectorC2::Vector_2 VectorC2:: operator/(const typename VectorC2::FT &c) const { return VectorC2( x()/c, y()/c); } template < class R > inline typename VectorC2::Direction_2 VectorC2::direction() const { return Direction_2(x(), y()); } template < class R > CGAL_KERNEL_MEDIUM_INLINE typename VectorC2::Vector_2 VectorC2::perpendicular(const Orientation &o) const { CGAL_kernel_precondition( o != COLLINEAR ); if (o == COUNTERCLOCKWISE) return VectorC2(-y(), x()); else return VectorC2(y(), -x()); } #ifndef CGAL_NO_OSTREAM_INSERT_VECTORC2 template < class R > std::ostream & operator<<(std::ostream &os, const VectorC2 &v) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << v.x() << ' ' << v.y(); case IO::BINARY : write(os, v.x()); write(os, v.y()); return os; default: return os << "VectorC2(" << v.x() << ", " << v.y() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_VECTORC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_VECTORC2 template < class R > std::istream & operator>>(std::istream &is, VectorC2 &p) { typename R::FT x, y; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y; break; case IO::BINARY : read(is, x); read(is, y); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) p = VectorC2(x, y); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_VECTORC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_VECTOR_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Point_2.h0000644000175000017500000001155711344301501030426 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Point_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_POINT_2_H #define CGAL_CARTESIAN_POINT_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class PointC2 { typedef typename R_::FT FT; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Point_2 Point_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef const FT* Cartesian_const_iterator; typedef R_ R; PointC2() {} PointC2(const Origin &) : base(FT(0), FT(0)) {} PointC2(const FT &x, const FT &y) : base(x, y) {} PointC2(const FT &hx, const FT &hy, const FT &hw) { if (hw != FT(1)) base = Rep(hx/hw, hy/hw); else base = Rep(hx, hy); } const FT& x() const { return get(base).e0; } const FT& y() const { return get(base).e1; } const FT& hx() const { return x(); } const FT& hy() const { return y(); } FT hw() const { return FT(1); } const FT& cartesian(int i) const; FT homogeneous(int i) const; const FT& operator[](int i) const { return cartesian(i); } Cartesian_const_iterator cartesian_begin() const { return & get(base).e0; //return Cartesian_const_iterator(static_cast(this),0); } Cartesian_const_iterator cartesian_end() const { const FT* ptr = & get(base).e1; ptr++; return ptr; //return Cartesian_const_iterator(static_cast(this), 2); } int dimension() const { return 2; } bool operator==(const PointC2 &p) const { if (CGAL::identical(base, p.base)) return true; return equal_xy(*this, p); } bool operator!=(const PointC2 &p) const { return !(*this == p); } Bbox_2 bbox() const; Point_2 transform(const Aff_transformation_2 &t) const { return t.transform(static_cast(*this)); } }; template < class R > CGAL_KERNEL_INLINE const typename PointC2::FT & PointC2::cartesian(int i) const { CGAL_kernel_precondition( (i == 0) || (i == 1) ); return *(&(get(base).e0)+i); } template < class R > CGAL_KERNEL_INLINE typename PointC2::FT PointC2::homogeneous(int i) const { CGAL_kernel_precondition( (i>=0) && (i<=2) ); if (i<2) return cartesian(i); return FT(1); } template < class R > CGAL_KERNEL_INLINE Bbox_2 PointC2::bbox() const { std::pair xp = CGAL_NTS to_interval(x()); std::pair yp = CGAL_NTS to_interval(y()); return Bbox_2(xp.first, yp.first, xp.second, yp.second); } #ifndef CGAL_NO_OSTREAM_INSERT_POINTC2 template < class R > std::ostream & operator<<(std::ostream &os, const PointC2 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.x() << ' ' << p.y(); case IO::BINARY : write(os, p.x()); write(os, p.y()); return os; default: return os << "PointC2(" << p.x() << ", " << p.y() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_POINTC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_POINTC2 template < class R > std::istream & operator>>(std::istream &is, PointC2 &p) { typename R::FT x, y; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y; break; case IO::BINARY : read(is, x); read(is, y); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) p = PointC2(x, y); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_POINTC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_POINT_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Line_3.h0000644000175000017500000001177311344301501030225 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Line_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_LINE_3_H #define CGAL_CARTESIAN_LINE_3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class LineC3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef std::pair Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; LineC3() {} LineC3(const Point_3 &p, const Point_3 &q) { *this = R().construct_line_3_object()(p, q); } LineC3(const Segment_3 &s) { *this = R().construct_line_3_object()(s); } LineC3(const Ray_3 &r) { *this = R().construct_line_3_object()(r); } LineC3(const Point_3 &p, const Vector_3 &v) : base(p, v) {} LineC3(const Point_3 &p, const Direction_3 &d) { *this = R().construct_line_3_object()(p, d); } bool operator==(const LineC3 &l) const; bool operator!=(const LineC3 &l) const; Plane_3 perpendicular_plane(const Point_3 &p) const; Line_3 opposite() const; const Point_3 & point() const { return get(base).first; } const Vector_3 & to_vector() const { return get(base).second; } Direction_3 direction() const { return Direction_3(to_vector()); } Point_3 point(int i) const; Point_3 projection(const Point_3 &p) const; bool has_on(const Point_3 &p) const; bool is_degenerate() const; Line_3 transform(const Aff_transformation_3 &t) const { return LineC3(t.transform(point()), t.transform(direction())); } }; template < class R > inline bool LineC3::operator==(const LineC3 &l) const { if (CGAL::identical(base, l.base)) return true; return has_on(l.point()) && (direction() == l.direction()); } template < class R > inline bool LineC3::operator!=(const LineC3 &l) const { return !(*this == l); } template < class R > inline typename LineC3::Point_3 LineC3::point(int i) const { return point() + to_vector()*RT(i); } template < class R > inline typename LineC3::Plane_3 LineC3:: perpendicular_plane(const typename LineC3::Point_3 &p) const { return Plane_3(p, to_vector()); } template < class R > inline typename LineC3::Line_3 LineC3::opposite() const { return Line_3(point(), -to_vector()); } template < class R > inline typename LineC3::Point_3 LineC3:: projection(const typename LineC3::Point_3 &p) const { return R().construct_projected_point_3_object()(*this, p); } template < class R > inline bool LineC3:: has_on(const typename LineC3::Point_3 &p) const { return collinear(point(), point()+to_vector(), p); } template < class R > inline bool LineC3::is_degenerate() const { // FIXME : predicate return to_vector() == NULL_VECTOR; } #ifndef CGAL_CARTESIAN_NO_OSTREAM_INSERT_LINEC3 template < class R > std::ostream & operator<<(std::ostream &os, const LineC3 &l) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << l.point(0) << ' ' << l.point(1); case IO::BINARY : return os << l.point(0) << l.point(1); default: return os << "LineC3(" << l.point(0) << ", " << l.point(1) << ")"; } } #endif // CGAL_CARTESIAN_NO_OSTREAM_INSERT_LINEC3 #ifndef CGAL_CARTESIAN_NO_ISTREAM_EXTRACT_LINEC3 template < class R > std::istream & operator>>(std::istream &is, LineC3 &l) { typename R::Point_3 p, q; is >> p >> q; if (is) l = LineC3(p, q); return is; } #endif // CGAL_CARTESIAN_NO_ISTREAM_EXTRACT_LINEC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_LINE_3_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_points_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_o0000644000175000017500000000424211344301501031320 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_points_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_PREDICATES_ON_POINTS_2_H #define CGAL_CARTESIAN_PREDICATES_ON_POINTS_2_H #include #include CGAL_BEGIN_NAMESPACE template < class K > inline bool equal_xy(const PointC2 &p, const PointC2 &q) { return p.x() == q.x() && p.y() == q.y(); } template < class K > inline Comparison_result compare_deltax_deltay(const PointC2& p, const PointC2& q, const PointC2& r, const PointC2& s) { return compare_deltax_deltayC2(p.x(), q.x(), r.y(), s.y()); } template < class K > inline Comparison_result compare_yx(const PointC2 &p, const PointC2 &q) { return compare_lexicographically_xyC2(p.y(), p.x(), q.y(), q.x()); } template < class K > inline Comparison_result compare_lexicographically_yx(const PointC2 &p, const PointC2 &q) { return compare_lexicographically_xyC2(p.y(), p.x(), q.y(), q.x()); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_PREDICATES_ON_POINTS_2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_planes_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_o0000644000175000017500000000342711344301501031324 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/predicates_on_planes_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_PREDICATES_ON_PLANES_3_H #define CGAL_CARTESIAN_PREDICATES_ON_PLANES_3_H #include CGAL_BEGIN_NAMESPACE template < class K > inline Oriented_side side_of_oriented_plane(const PlaneC3 &h, const PointC3 &p) { return side_of_oriented_planeC3(h.a(), h.b(), h.c(), h.d(), p.x(), p.y(), p.z()); } template < class K > inline bool equal_plane(const PlaneC3 &h, const PlaneC3 &p) { return equal_planeC3(h.a(), h.b(), h.c(), h.d(), p.a(), p.b(), p.c(), p.d()); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_PREDICATES_ON_PLANES_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Vector_3.h0000644000175000017500000001533511344301501030576 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Vector_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author : Andreas Fabri #ifndef CGAL_CARTESIAN_VECTOR_3_H #define CGAL_CARTESIAN_VECTOR_3_H #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class VectorC3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; VectorC3() {} VectorC3(const Null_vector &n) { *this = R().construct_vector_3_object()(n); } VectorC3(const Point_3 &a, const Point_3 &b) { *this = R().construct_vector_3_object()(a, b); } VectorC3(const Segment_3 &s) { *this = R().construct_vector_3_object()(s); } VectorC3(const Ray_3 &r) { *this = R().construct_vector_3_object()(r); } VectorC3(const Line_3 &l) { *this = R().construct_vector_3_object()(l); } VectorC3(const FT &x, const FT &y, const FT &z) : base(x, y, z) {} VectorC3(const FT &x, const FT &y, const FT &z, const FT &w) { if (w != FT(1)) base = Rep(x/w, y/w, z/w); else base = Rep(x, y, z); } const FT & x() const { return get(base).e0; } const FT & y() const { return get(base).e1; } const FT & z() const { return get(base).e2; } const FT & hx() const { return x(); } const FT & hy() const { return y(); } const FT & hz() const { return z(); } FT hw() const { return FT(1); } const FT & cartesian(int i) const; const FT & operator[](int i) const; FT homogeneous(int i) const; int dimension() const { return 3; } Vector_3 operator+(const VectorC3 &w) const; Vector_3 operator-(const VectorC3 &w) const; Vector_3 operator-() const; Vector_3 operator/(const FT &c) const; FT squared_length() const; Direction_3 direction() const; Vector_3 transform(const Aff_transformation_3 &t) const { return t.transform(*this); } }; template < class R > inline bool operator==(const VectorC3 &v, const VectorC3 &w) { return w.x() == v.x() && w.y() == v.y() && w.z() == v.z(); } template < class R > inline bool operator!=(const VectorC3 &v, const VectorC3 &w) { return !(v == w); } template < class R > inline bool operator==(const VectorC3 &v, const Null_vector &) { return CGAL_NTS is_zero(v.x()) && CGAL_NTS is_zero(v.y()) && CGAL_NTS is_zero(v.z()); } template < class R > inline bool operator==(const Null_vector &n, const VectorC3 &v) { return v == n; } template < class R > inline bool operator!=(const VectorC3 &v, const Null_vector &n) { return !(v == n); } template < class R > inline bool operator!=(const Null_vector &n, const VectorC3 &v) { return !(v == n); } template < class R > inline const typename VectorC3::FT & VectorC3::cartesian(int i) const { CGAL_kernel_precondition( (i>=0) && (i<3) ); if (i==0) return x(); if (i==1) return y(); return z(); } template < class R > inline const typename VectorC3::FT & VectorC3::operator[](int i) const { return cartesian(i); } template < class R > typename VectorC3::FT VectorC3::homogeneous(int i) const { if (i==3) return FT(1); return cartesian(i); } template < class R > inline typename VectorC3::Vector_3 VectorC3:: operator+(const VectorC3 &w) const { return VectorC3(x() + w.x(), y() + w.y(), z() + w.z()); } template < class R > inline typename VectorC3::Vector_3 VectorC3::operator-(const VectorC3 &w) const { return VectorC3(x() - w.x(), y() - w.y(), z() - w.z()); } template < class R > inline typename VectorC3::Vector_3 VectorC3::operator-() const { return R().construct_opposite_vector_3_object()(*this); } template < class R > inline typename VectorC3::FT VectorC3::squared_length() const { return CGAL_NTS square(x()) + CGAL_NTS square(y()) + CGAL_NTS square(z()); } template < class R > inline typename VectorC3::Vector_3 VectorC3:: operator/(const typename VectorC3::FT &c) const { return VectorC3(x()/c, y()/c, z()/c); } template < class R > inline typename VectorC3::Direction_3 VectorC3::direction() const { return Direction_3(*this); } #ifndef CGAL_CARTESIAN_NO_OSTREAM_INSERT_VECTORC3 template < class R > std::ostream & operator<<(std::ostream &os, const VectorC3 &v) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << v.x() << ' ' << v.y() << ' ' << v.z(); case IO::BINARY : write(os, v.x()); write(os, v.y()); write(os, v.z()); return os; default: os << "VectorC3(" << v.x() << ", " << v.y() << ", " << v.z() << ")"; return os; } } #endif // CGAL_CARTESIAN_NO_OSTREAM_INSERT_VECTORC3 #ifndef CGAL_CARTESIAN_NO_ISTREAM_EXTRACT_VECTORC3 template < class R > std::istream & operator>>(std::istream &is, VectorC3 &p) { typename R::FT x, y, z; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y >> z; break; case IO::BINARY : read(is, x); read(is, y); read(is, z); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) p = VectorC3(x, y, z); return is; } #endif // CGAL_CARTESIAN_NO_ISTREAM_EXTRACT_VECTORC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_VECTOR_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Segment_2.h0000644000175000017500000001604511344301501030734 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Segment_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_SEGMENT_2_H #define CGAL_CARTESIAN_SEGMENT_2_H #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class SegmentC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; SegmentC2() {} SegmentC2(const Point_2 &sp, const Point_2 &ep) : base(sp, ep) {} bool is_horizontal() const; bool is_vertical() const; bool has_on(const Point_2 &p) const; bool collinear_has_on(const Point_2 &p) const; bool operator==(const SegmentC2 &s) const; bool operator!=(const SegmentC2 &s) const; const Point_2 & source() const { return get(base).e0; } const Point_2 & target() const { return get(base).e1; } const Point_2 & start() const; const Point_2 & end() const; const Point_2 & min() const; const Point_2 & max() const; const Point_2 & vertex(int i) const; const Point_2 & point(int i) const; const Point_2 & operator[](int i) const; FT squared_length() const; Direction_2 direction() const; Vector_2 to_vector() const; Line_2 supporting_line() const; Segment_2 opposite() const; Segment_2 transform(const Aff_transformation_2 &t) const { return SegmentC2(t.transform(source()), t.transform(target())); } bool is_degenerate() const; Bbox_2 bbox() const; }; template < class R > inline bool SegmentC2::operator==(const SegmentC2 &s) const { if (CGAL::identical(base, s.base)) return true; return source() == s.source() && target() == s.target(); } template < class R > inline bool SegmentC2::operator!=(const SegmentC2 &s) const { return !(*this == s); } template < class R > inline const typename SegmentC2::Point_2 & SegmentC2::start() const { return source(); } template < class R > inline const typename SegmentC2::Point_2 & SegmentC2::end() const { return target(); } template < class R > CGAL_KERNEL_INLINE const typename SegmentC2::Point_2 & SegmentC2::min() const { typename R::Less_xy_2 less_xy; return less_xy(source(),target()) ? source() : target(); } template < class R > CGAL_KERNEL_INLINE const typename SegmentC2::Point_2 & SegmentC2::max() const { typename R::Less_xy_2 less_xy; return less_xy(source(),target()) ? target() : source(); } template < class R > CGAL_KERNEL_INLINE const typename SegmentC2::Point_2 & SegmentC2::vertex(int i) const { return (i%2 == 0) ? source() : target(); } template < class R > inline const typename SegmentC2::Point_2 & SegmentC2::point(int i) const { return vertex(i); } template < class R > inline const typename SegmentC2::Point_2 & SegmentC2::operator[](int i) const { return vertex(i); } template < class R > CGAL_KERNEL_INLINE typename SegmentC2::FT SegmentC2::squared_length() const { return squared_distance(source(), target()); } template < class R > CGAL_KERNEL_INLINE typename SegmentC2::Direction_2 SegmentC2::direction() const { typename R::Construct_vector_2 construct_vector; return Direction_2( construct_vector( source(), target())); } template < class R > CGAL_KERNEL_INLINE typename SegmentC2::Vector_2 SegmentC2::to_vector() const { typename R::Construct_vector_2 construct_vector; return construct_vector( source(), target()); } template < class R > inline typename SegmentC2::Line_2 SegmentC2::supporting_line() const { typename R::Construct_line_2 construct_line; return construct_line(*this); } template < class R > inline typename SegmentC2::Segment_2 SegmentC2::opposite() const { return Segment_2(target(), source()); } template < class R > CGAL_KERNEL_INLINE Bbox_2 SegmentC2::bbox() const { typename R::Construct_bbox_2 construct_bbox_2; return construct_bbox_2(source()) + construct_bbox_2(target()); } template < class R > inline bool SegmentC2::is_degenerate() const { return R().equal_2_object()(source(), target()); } template < class R > CGAL_KERNEL_INLINE bool SegmentC2::is_horizontal() const { return R().equal_y_2_object()(source(), target()); } template < class R > CGAL_KERNEL_INLINE bool SegmentC2::is_vertical() const { return R().equal_x_2_object()(source(), target()); } template < class R > CGAL_KERNEL_INLINE bool SegmentC2:: has_on(const typename SegmentC2::Point_2 &p) const { return R().are_ordered_along_line_2_object()(source(), p, target()); } template < class R > inline bool SegmentC2:: collinear_has_on(const typename SegmentC2::Point_2 &p) const { return R().collinear_has_on_2_object() (static_cast(*this), p); } #ifndef CGAL_NO_OSTREAM_INSERT_SEGMENTC2 template < class R > std::ostream & operator<<(std::ostream &os, const SegmentC2 &s) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << s.source() << ' ' << s.target(); case IO::BINARY : return os << s.source() << s.target(); default: return os << "SegmentC2(" << s.source() << ", " << s.target() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_SEGMENTC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_SEGMENTC2 template < class R > std::istream & operator>>(std::istream &is, SegmentC2 &s) { typename R::Point_2 p, q; is >> p >> q; if (is) s = SegmentC2(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_SEGMENTC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_SEGMENT_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Segment_3.h0000644000175000017500000001447511344301501030742 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Segment_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_SEGMENT_3_H #define CGAL_CARTESIAN_SEGMENT_3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class SegmentC3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; SegmentC3() {} SegmentC3(const Point_3 &sp, const Point_3 &ep) : base(sp, ep) {} bool has_on(const Point_3 &p) const; bool collinear_has_on(const Point_3 &p) const; bool operator==(const SegmentC3 &s) const; bool operator!=(const SegmentC3 &s) const; const Point_3 & source() const { return get(base).e0; } const Point_3 & target() const { return get(base).e1; } const Point_3 & start() const; const Point_3 & end() const; const Point_3 & min() const; const Point_3 & max() const; const Point_3 & vertex(int i) const; const Point_3 & point(int i) const; const Point_3 & operator[](int i) const; FT squared_length() const; Direction_3 direction() const; Vector_3 to_vector() const; Line_3 supporting_line() const; Segment_3 opposite() const; Segment_3 transform(const Aff_transformation_3 &t) const { return SegmentC3(t.transform(source()), t.transform(target())); } bool is_degenerate() const; Bbox_3 bbox() const; }; template < class R > inline bool SegmentC3::operator==(const SegmentC3 &s) const { if (CGAL::identical(base, s.base)) return true; return source() == s.source() && target() == s.target(); } template < class R > inline bool SegmentC3::operator!=(const SegmentC3 &s) const { return !(*this == s); } template < class R > const typename SegmentC3::Point_3 & SegmentC3::start() const { return source(); } template < class R > const typename SegmentC3::Point_3 & SegmentC3::end() const { return target(); } template < class R > inline const typename SegmentC3::Point_3 & SegmentC3::min() const { return lexicographically_xyz_smaller(source(),target()) ? source() : target(); } template < class R > inline const typename SegmentC3::Point_3 & SegmentC3::max() const { return lexicographically_xyz_smaller(source(),target()) ? target() : source(); } template < class R > inline const typename SegmentC3::Point_3 & SegmentC3::vertex(int i) const { return (i%2 == 0) ? source() : target(); } template < class R > inline const typename SegmentC3::Point_3 & SegmentC3::point(int i) const { return vertex(i); } template < class R > inline const typename SegmentC3::Point_3 & SegmentC3::operator[](int i) const { return vertex(i); } template < class R > inline typename SegmentC3::FT SegmentC3::squared_length() const { return squared_distance(target(), source()); } template < class R > inline typename SegmentC3::Vector_3 SegmentC3::to_vector() const { return target() - source(); } template < class R > inline typename SegmentC3::Direction_3 SegmentC3::direction() const { return Direction_3( target() - source() ); } template < class R > inline typename SegmentC3::Line_3 SegmentC3::supporting_line() const { return Line_3(*this); } template < class R > inline typename SegmentC3::Segment_3 SegmentC3::opposite() const { return SegmentC3(target(), source()); } template < class R > inline bool SegmentC3::is_degenerate() const { return source() == target(); } template < class R > inline Bbox_3 SegmentC3::bbox() const { typename R::Construct_bbox_3 construct_bbox_3; return construct_bbox_3(source()) + construct_bbox_3(target()); } template < class R > inline bool SegmentC3:: has_on(const typename SegmentC3::Point_3 &p) const { return are_ordered_along_line(source(), p, target()); } template < class R > inline bool SegmentC3:: collinear_has_on(const typename SegmentC3::Point_3 &p) const { return collinear_are_ordered_along_line(source(), p, target()); } #ifndef CGAL_NO_OSTREAM_INSERT_SEGMENTC3 template < class R > std::ostream & operator<<(std::ostream &os, const SegmentC3 &s) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << s.source() << ' ' << s.target(); case IO::BINARY : return os << s.source() << s.target(); default: return os << "SegmentC3(" << s.source() << ", " << s.target() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_SEGMENTC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_SEGMENTC3 template < class R > std::istream & operator>>(std::istream &is, SegmentC3 &s) { typename R::Point_3 p, q; is >> p >> q; if (is) s = SegmentC3(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_SEGMENTC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_SEGMENT_3_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/basic_constructions_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/basic_constr0000644000175000017500000000262011344301501031326 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/basic_constructions_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_BASIC_CONSTRUCTIONS_3_H #define CGAL_CARTESIAN_BASIC_CONSTRUCTIONS_3_H #include #include #include #endif // CGAL_CARTESIAN_BASIC_CONSTRUCTIONS_3_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transfor0000644000175000017500000001425311344301501031274 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_AFF_TRANSFORMATION_3_H #define CGAL_CARTESIAN_AFF_TRANSFORMATION_3_H #include #include CGAL_BEGIN_NAMESPACE class Identity_transformation; template class Aff_transformation_rep_baseC3; template class Aff_transformation_repC3; template class Translation_repC3; template class Scaling_repC3; CGAL_END_NAMESPACE #include #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class Aff_transformationC3 : public Handle_for_virtual > { friend class PlaneC3; // FIXME: why ? typedef typename R_::FT FT; typedef Aff_transformation_rep_baseC3 Aff_t_base; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; public: typedef R_ R; Aff_transformationC3() { FT ft1(1), ft0(0); initialize_with(Aff_transformation_repC3(ft1, ft0, ft0, ft0, ft1, ft0, ft0, ft0, ft1)); } Aff_transformationC3(const Identity_transformation) { FT ft1(1), ft0(0); initialize_with(Aff_transformation_repC3(ft1, ft0, ft0, ft0, ft1, ft0, ft0, ft0, ft1)); } Aff_transformationC3(const Translation, const Vector_3 &v) { initialize_with(Translation_repC3(v)); } Aff_transformationC3(const Scaling, const FT &s, const FT &w = FT(1)) { if (w != FT(1)) initialize_with(Scaling_repC3(s/w)); else initialize_with(Scaling_repC3(s)); } // General form: without translation Aff_transformationC3(const FT& m11, const FT& m12, const FT& m13, const FT& m21, const FT& m22, const FT& m23, const FT& m31, const FT& m32, const FT& m33, const FT& w = FT(1)) { if (w != FT(1)) initialize_with(Aff_transformation_repC3(m11/w, m12/w, m13/w, m21/w, m22/w, m23/w, m31/w, m32/w, m33/w)); else initialize_with(Aff_transformation_repC3(m11, m12, m13, m21, m22, m23, m31, m32, m33)); } // General form: with translation Aff_transformationC3( const FT& m11, const FT& m12, const FT& m13, const FT& m14, const FT& m21, const FT& m22, const FT& m23, const FT& m24, const FT& m31, const FT& m32, const FT& m33, const FT& m34, const FT& w = FT(1)) { if (w != FT(1)) initialize_with(Aff_transformation_repC3(m11/w, m12/w, m13/w, m14/w, m21/w, m22/w, m23/w, m24/w, m31/w, m32/w, m33/w, m34/w)); else initialize_with(Aff_transformation_repC3(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34)); } Point_3 transform(const Point_3 &p) const { return this->Ptr()->transform(p); } Point_3 operator()(const Point_3 &p) const { return transform(p); } Vector_3 transform(const Vector_3 &v) const { return this->Ptr()->transform(v); } Vector_3 operator()(const Vector_3 &v) const { return transform(v); } Direction_3 transform(const Direction_3 &d) const { return this->Ptr()->transform(d); } Direction_3 operator()(const Direction_3 &d) const { return transform(d); } Plane_3 transform(const Plane_3& p) const { return p.transform(*this); } Plane_3 operator()(const Plane_3& p) const { return transform(p); } // FIXME : not compiled by the test-suite ! Aff_transformation_3 inverse() const { return this->Ptr()->inverse(); } bool is_even() const { return this->Ptr()->is_even(); } bool is_odd() const { return ! (this->Ptr()->is_even()); } FT cartesian(int i, int j) const { return this->Ptr()->cartesian(i,j); } FT homogeneous(int i, int j) const { return cartesian(i,j); } FT m(int i, int j) const { return cartesian(i,j); } FT hm(int i, int j) const { return cartesian(i,j); } Aff_transformation_3 operator*(const Aff_transformationC3 &t) const { return (*this->Ptr()) * (*t.Ptr()); } protected: Aff_transformation_3 transpose() const { return this->Ptr()->transpose(); } }; #ifndef CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATIONC3 template < class R > std::ostream &operator<<(std::ostream &os, const Aff_transformationC3 &t) { t.print(os); return os; } #endif // CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATIONC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_AFF_TRANSFORMATION_3_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_rep_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transfor0000644000175000017500000002055411344301501031275 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_rep_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Lutz Kettner #ifndef CGAL_CARTESIAN_AFF_TRANSFORMATION_REP_2_H #define CGAL_CARTESIAN_AFF_TRANSFORMATION_REP_2_H #include CGAL_BEGIN_NAMESPACE template < class R > class Aff_transformation_rep_baseC2 : public Ref_counted_virtual { public: typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; typedef typename R::Aff_transformation_2 Aff_transformation_2; virtual ~Aff_transformation_rep_baseC2() {} virtual Point_2 transform(const Point_2 &p) const = 0; virtual Vector_2 transform(const Vector_2 &v) const = 0; virtual Direction_2 transform(const Direction_2 &d) const=0; virtual Aff_transformation_2 operator*( const Aff_transformation_rep_baseC2 &t) const = 0; virtual Aff_transformation_2 compose( const Aff_transformation_repC2 &t) const = 0; virtual Aff_transformation_2 compose( const Translation_repC2 &t) const = 0; virtual Aff_transformation_2 compose( const Rotation_repC2 &t) const = 0; virtual Aff_transformation_2 compose( const Scaling_repC2 &t) const = 0; virtual Aff_transformation_2 inverse() const = 0; virtual bool is_even() const = 0; virtual FT cartesian(int i, int j) const = 0; virtual std::ostream &print(std::ostream &os) const = 0; }; template < class R > class Aff_transformation_repC2 : public Aff_transformation_rep_baseC2 { public: typedef typename R::FT FT; typedef Aff_transformation_repC2 Self; typedef Aff_transformation_rep_baseC2 Aff_t_base; typedef typename Aff_t_base::Point_2 Point_2; typedef typename Aff_t_base::Vector_2 Vector_2; typedef typename Aff_t_base::Direction_2 Direction_2; typedef typename Aff_t_base::Aff_transformation_2 Aff_transformation_2; friend class Translation_repC2; friend class Rotation_repC2; friend class Scaling_repC2; Aff_transformation_repC2() {} Aff_transformation_repC2( const FT& m11, const FT& m12, const FT& m21, const FT& m22) : t11(m11), t12(m12), t13(0), t21(m21), t22(m22), t23(0) {} Aff_transformation_repC2( const FT& m11, const FT& m12, const FT& m13, const FT& m21, const FT& m22, const FT& m23) : t11(m11), t12(m12), t13(m13), t21(m21), t22(m22), t23(m23) {} Point_2 transform(const Point_2& p) const { typename R::Construct_point_2 construct_point_2; return construct_point_2(t11 * p.x() + t12 * p.y() + t13, t21 * p.x() + t22 * p.y() + t23); } // note that a vector is not translated Vector_2 transform(const Vector_2& v) const // FIXME : construction { return Vector_2(t11 * v.x() + t12 * v.y(), t21 * v.x() + t22 * v.y()); } // note that a direction is not translated Direction_2 transform(const Direction_2& dir) const // FIXME : construction { Vector_2 v = dir.to_vector(); return Direction_2(t11 * v.x() + t12 * v.y(), t21 * v.x() + t22 * v.y()); } // Note that Aff_transformation is not defined yet, // so the following 6 functions have to be implemented later... Aff_transformation_2 inverse() const; Aff_transformation_2 operator*(const Aff_t_base &t) const; Aff_transformation_2 compose(const Self &t) const; Aff_transformation_2 compose(const Translation_repC2 &t) const; Aff_transformation_2 compose(const Rotation_repC2 &t) const; Aff_transformation_2 compose(const Scaling_repC2 &t) const; bool is_even() const { return sign_of_determinant2x2(t11, t12, t21, t22) == POSITIVE; } FT cartesian(int i, int j) const { switch (i) { case 0: switch (j) { case 0: return t11; case 1: return t12; case 2: return t13; } case 1: switch (j) { case 0: return t21; case 1: return t22; case 2: return t23; } case 2: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(1); } } return FT(0); } std::ostream &print(std::ostream &os) const { os <<"Aff_transformationC2(" < CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC2::Aff_transformation_2 Aff_transformation_repC2:: inverse() const { FT det = FT(1) / (t11 * t22 - t12 * t21); return Aff_transformation_2( det * t22, det * (-t12), det * (t12*t23-t13*t22), det * (-t21), det * t11 , det * (t13*t21-t11*t23)); } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repC2::Aff_transformation_2 Aff_transformation_repC2:: operator*(const Aff_transformation_rep_baseC2 &t) const { return t.compose(*this); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC2::Aff_transformation_2 Aff_transformation_repC2:: compose(const Aff_transformation_repC2 &t) const { return Aff_transformation_2(t.t11*t11 + t.t12*t21, t.t11*t12 + t.t12*t22, t.t11*t13 + t.t12*t23 + t.t13, t.t21*t11 + t.t22*t21, t.t21*t12 + t.t22*t22, t.t21*t13 + t.t22*t23 + t.t23 ); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC2::Aff_transformation_2 Aff_transformation_repC2:: compose(const Translation_repC2 &t) const { return Aff_transformation_2(t11, t12, t13 + t.translationvector_.x(), t21, t22, t23 + t.translationvector_.y()); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC2::Aff_transformation_2 Aff_transformation_repC2:: compose(const Rotation_repC2 &t) const { return Aff_transformation_2(t.cosinus_*t11 - t.sinus_*t21, t.cosinus_*t12 - t.sinus_*t22, t.cosinus_*t13 - t.sinus_*t23, t.sinus_*t11 + t.cosinus_*t21, t.sinus_*t12 + t.cosinus_*t22, t.sinus_*t13 + t.cosinus_*t23); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC2::Aff_transformation_2 Aff_transformation_repC2:: compose(const Scaling_repC2 &t) const { return Aff_transformation_2(t.scalefactor_ * t11, t.scalefactor_ * t12, t.scalefactor_ * t13, t.scalefactor_ * t21, t.scalefactor_ * t22, t.scalefactor_ * t23); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_AFF_TRANSFORMATION_REP_2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Iso_cuboid_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Iso_cuboid_30000644000175000017500000002253511344301501031165 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Iso_cuboid_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_ISO_CUBOID_3_H #define CGAL_CARTESIAN_ISO_CUBOID_3_H #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class Iso_cuboidC3 { typedef typename R_::FT FT; typedef typename R_::Iso_cuboid_3 Iso_cuboid_3; typedef typename R_::Point_3 Point_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef typename R_::Construct_point_3 Construct_point_3; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; Iso_cuboidC3() {} Iso_cuboidC3(const Point_3 &p, const Point_3 &q) { Construct_point_3 construct_point_3; FT minx, maxx, miny, maxy, minz, maxz; if (p.x() < q.x()) { minx = p.x(); maxx = q.x(); } else { minx = q.x(); maxx = p.x(); } if (p.y() < q.y()) { miny = p.y(); maxy = q.y(); } else { miny = q.y(); maxy = p.y(); } if (p.z() < q.z()) { minz = p.z(); maxz = q.z(); } else { minz = q.z(); maxz = p.z(); } base = Rep(construct_point_3(minx, miny, minz), construct_point_3(maxx, maxy, maxz)); } Iso_cuboidC3(const Point_3 &left, const Point_3 &right, const Point_3 &bottom, const Point_3 &top, const Point_3 &far_, const Point_3 &close) : base(Construct_point_3()(left.x(), bottom.y(), far_.z()), Construct_point_3()(right.x(), top.y(), close.z())) { CGAL_kernel_precondition(!less_x(right, left)); CGAL_kernel_precondition(!less_y(top, bottom)); CGAL_kernel_precondition(!less_z(close, far_)); } Iso_cuboidC3(const FT& min_x, const FT& min_y, const FT& min_z, const FT& max_x, const FT& max_y, const FT& max_z) : base(Construct_point_3()(min_x, min_y, min_z), Construct_point_3()(max_x, max_y, max_z)) { CGAL_kernel_precondition(min_x <= max_x); CGAL_kernel_precondition(min_y <= max_y); CGAL_kernel_precondition(min_z <= max_z); } Iso_cuboidC3(const FT& min_hx, const FT& min_hy, const FT& min_hz, const FT& max_hx, const FT& max_hy, const FT& max_hz, const FT& hw) { if (hw == FT(1)) base = Rep(Construct_point_3()(min_hx, min_hy, min_hz), Construct_point_3()(max_hx, max_hy, max_hz)); else base = Rep(Construct_point_3()(min_hx/hw, min_hy/hw, min_hz/hw), Construct_point_3()(max_hx/hw, max_hy/hw, max_hz/hw)); } bool operator==(const Iso_cuboidC3& s) const; bool operator!=(const Iso_cuboidC3& s) const; const Point_3 & min() const { return get(base).e0; } const Point_3 & max() const { return get(base).e1; } Point_3 vertex(int i) const; Point_3 operator[](int i) const; Iso_cuboid_3 transform(const Aff_transformation_3 &t) const { return Iso_cuboidC3(t.transform(min()), t.transform(max())); } Bounded_side bounded_side(const Point_3& p) const; bool has_on(const Point_3& p) const; bool has_on_boundary(const Point_3& p) const; bool has_on_bounded_side(const Point_3& p) const; bool has_on_unbounded_side(const Point_3& p) const; bool is_degenerate() const; Bbox_3 bbox() const; const FT & xmin() const; const FT & ymin() const; const FT & zmin() const; const FT & xmax() const; const FT & ymax() const; const FT & zmax() const; const FT & min_coord(int i) const; const FT & max_coord(int i) const; FT volume() const; }; template < class R > CGAL_KERNEL_INLINE bool Iso_cuboidC3::operator==(const Iso_cuboidC3& r) const { // FIXME : predicate if (CGAL::identical(base, r.base)) return true; return min() == r.min() && max() == r.max(); } template < class R > inline bool Iso_cuboidC3::operator!=(const Iso_cuboidC3& r) const { return !(*this == r); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::xmin() const { return min().x(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::ymin() const { return min().y(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::zmin() const { return min().z(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::xmax() const { return max().x(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::ymax() const { return max().y(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::zmax() const { return max().z(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::min_coord(int i) const { CGAL_kernel_precondition( i == 0 || i == 1 || i == 2 ); if (i == 0) return xmin(); else if (i == 1) return ymin(); else return zmin(); } template < class R > inline const typename Iso_cuboidC3::FT & Iso_cuboidC3::max_coord(int i) const { CGAL_kernel_precondition( i == 0 || i == 1 || i == 2 ); if (i == 0) return xmax(); else if (i == 1) return ymax(); else return zmax(); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Iso_cuboidC3::Point_3 Iso_cuboidC3::vertex(int i) const { Construct_point_3 construct_point_3; switch (i%8) { case 0: return min(); case 1: return construct_point_3(max().hx(), min().hy(), min().hz()); case 2: return construct_point_3(max().hx(), max().hy(), min().hz()); case 3: return construct_point_3(min().hx(), max().hy(), min().hz()); case 4: return construct_point_3(min().hx(), max().hy(), max().hz()); case 5: return construct_point_3(min().hx(), min().hy(), max().hz()); case 6: return construct_point_3(max().hx(), min().hy(), max().hz()); default: // case 7: return max(); } } template < class R > inline typename Iso_cuboidC3::Point_3 Iso_cuboidC3::operator[](int i) const { return vertex(i); } template < class R > inline typename Iso_cuboidC3::FT Iso_cuboidC3::volume() const { return (xmax()-xmin()) * (ymax()-ymin()) * (zmax()-zmin()); } template < class R > CGAL_KERNEL_MEDIUM_INLINE Bounded_side Iso_cuboidC3:: bounded_side(const typename Iso_cuboidC3::Point_3& p) const { if (strict_dominance(p, min()) && strict_dominance(max(), p) ) return ON_BOUNDED_SIDE; if (dominance(p, min()) && dominance(max(), p)) return ON_BOUNDARY; return ON_UNBOUNDED_SIDE; } template < class R > inline bool Iso_cuboidC3:: has_on_boundary(const typename Iso_cuboidC3::Point_3& p) const { return bounded_side(p) == ON_BOUNDARY; } template < class R > inline bool Iso_cuboidC3:: has_on(const typename Iso_cuboidC3::Point_3& p) const { return bounded_side(p) == ON_BOUNDARY; } template < class R > inline bool Iso_cuboidC3:: has_on_bounded_side(const typename Iso_cuboidC3::Point_3& p) const { return bounded_side(p) == ON_BOUNDED_SIDE; } template < class R > CGAL_KERNEL_INLINE bool Iso_cuboidC3:: has_on_unbounded_side(const typename Iso_cuboidC3::Point_3& p) const { return bounded_side(p) == ON_UNBOUNDED_SIDE; } template < class R > CGAL_KERNEL_INLINE bool Iso_cuboidC3::is_degenerate() const { // FIXME : predicate return min().hx() == max().hx() || min().hy() == max().hy() || min().hz() == max().hz(); } template < class R > inline Bbox_3 Iso_cuboidC3::bbox() const { typename R::Construct_bbox_3 construct_bbox_3; return construct_bbox_3(min()) + construct_bbox_3(max()); } #ifndef CGAL_NO_OSTREAM_INSERT_ISO_CUBOIDC3 template < class R > std::ostream & operator<<(std::ostream& os, const Iso_cuboidC3& r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r.min() << ' ' << r.max(); case IO::BINARY : return os << r.min() << r.max(); default: return os << "Iso_cuboidC3(" << r.min() << ", " << r.max() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_ISO_CUBOIDC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_ISO_CUBOIDC3 template < class R > std::istream & operator>>(std::istream& is, Iso_cuboidC3& r) { typename R::Point_3 p, q; is >> p >> q; if (is) r = Iso_cuboidC3(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_ISO_CUBOIDC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_ISO_CUBOID_3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Scaling_rep_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Scaling_rep_0000644000175000017500000001121011344301501031235 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Scaling_rep_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_SCALING_REP_3_H #define CGAL_CARTESIAN_SCALING_REP_3_H CGAL_BEGIN_NAMESPACE template < class R > class Scaling_repC3 : public Aff_transformation_rep_baseC3 { friend class Aff_transformation_repC3; friend class Translation_repC3; public: typedef typename R::FT FT; typedef Aff_transformation_rep_baseC3 Transformation_base_3; typedef Aff_transformation_repC3 Transformation_3; typedef Translation_repC3 Translation_3; typedef Scaling_repC3 Scaling_3; typedef typename Transformation_base_3::Point_3 Point_3; typedef typename Transformation_base_3::Vector_3 Vector_3; typedef typename Transformation_base_3::Direction_3 Direction_3; typedef typename Transformation_base_3::Aff_transformation_3 Aff_transformation_3; Scaling_repC3() {} Scaling_repC3(const FT &s) : scalefactor_(s) {} virtual ~Scaling_repC3() {} virtual Point_3 transform(const Point_3 &p) const { return Point_3(scalefactor_ * p.x(), scalefactor_ * p.y(), scalefactor_ * p.z()); } virtual Vector_3 transform(const Vector_3 &v) const { return Vector_3(scalefactor_ * v.x(), scalefactor_ * v.y(), scalefactor_ * v.z()); } virtual Direction_3 transform(const Direction_3 &d) const { return d; } virtual Aff_transformation_3 operator*(const Transformation_base_3 &t) const { return t.compose(*this); } virtual Aff_transformation_3 compose(const Transformation_3 &t) const { return Aff_transformation_3(scalefactor_ * t.t11, scalefactor_ * t.t12, scalefactor_ * t.t13, t.t14, scalefactor_ * t.t21, scalefactor_ * t.t22, scalefactor_ * t.t23, t.t24, scalefactor_ * t.t31, scalefactor_ * t.t32, scalefactor_ * t.t33, t.t34); } virtual Aff_transformation_3 compose(const Translation_3 &t) const { FT ft0(0); return Aff_transformation_3(scalefactor_, ft0, ft0, t.translationvector_.x(), ft0, scalefactor_, ft0, t.translationvector_.y(), ft0, ft0, scalefactor_, t.translationvector_.z()); } virtual Aff_transformation_3 compose(const Scaling_3 &t) const { return Aff_transformation_3(SCALING, scalefactor_*t.scalefactor_); } virtual Aff_transformation_3 inverse() const { return Aff_transformation_3(SCALING, FT(1)/scalefactor_); } virtual Aff_transformation_3 transpose() const { return Aff_transformation_3(SCALING, scalefactor_); } virtual bool is_even() const { return true; } virtual FT cartesian(int i, int j) const { if (i!=j) return FT(0); if (i==3) return FT(1); return scalefactor_; } virtual std::ostream &print(std::ostream &os) const { os << "Aff_transformationC3(" << scalefactor_ << ")"; return os; } private: FT scalefactor_; }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_SCALING_REP_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/ft_constructions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/ft_construct0000644000175000017500000000432611344301501031377 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/ft_constructions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_FT_CONSTRUCTIONS_2_H #define CGAL_CARTESIAN_FT_CONSTRUCTIONS_2_H CGAL_BEGIN_NAMESPACE template < class K > inline typename K::FT squared_distance(const PointC2 &p, const PointC2 &q) { return squared_distanceC2(p.x(), p.y(), q.x(), q.y()); } template < class K > inline typename K::FT scaled_distance_to_line(const LineC2 &l, const PointC2 &p) { return scaled_distance_to_lineC2(l.a(), l.b(), l.c(), p.x(), p.y()); } template < class K > inline typename K::FT scaled_distance_to_line(const PointC2 &p, const PointC2 &q, const PointC2 &r) { return scaled_distance_to_lineC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } template < class K > inline typename K::FT line_y_at_x(const LineC2 &l, const typename K::FT &x) { return line_y_at_xC2(l.a(), l.b(), l.c(), x); } template < class K > inline typename K::FT line_x_at_y(const LineC2 &l, const typename K::FT &y) { return line_y_at_xC2(l.b(), l.a(), l.c(), y); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_FT_CONSTRUCTIONS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Line_2.h0000644000175000017500000002014311344301501030213 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Line_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_LINE_2_H #define CGAL_CARTESIAN_LINE_2_H #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class LineC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; LineC2() {} LineC2(const Point_2 &p, const Point_2 &q) { *this = R().construct_line_2_object()(p, q); } LineC2(const FT &a, const FT &b, const FT &c) : base(a, b, c) {} LineC2(const Segment_2 &s) { *this = R().construct_line_2_object()(s); } LineC2(const Ray_2 &r) { *this = R().construct_line_2_object()(r); } LineC2(const Point_2 &p, const Direction_2 &d) { *this = R().construct_line_2_object()(p, d); } LineC2(const Point_2 &p, const Vector_2 &v) { *this = R().construct_line_2_object()(p, v); } bool operator==(const LineC2 &l) const; bool operator!=(const LineC2 &l) const; const FT & a() const { return get(base).e0; } const FT & b() const { return get(base).e1; } const FT & c() const { return get(base).e2; } FT x_at_y(const FT &y) const; FT y_at_x(const FT &x) const; Line_2 perpendicular(const Point_2 &p) const; Line_2 opposite() const; Point_2 point(int i) const; Point_2 point() const; Point_2 projection(const Point_2 &p) const; Direction_2 direction() const; Vector_2 to_vector() const; Oriented_side oriented_side(const Point_2 &p) const; bool has_on_boundary(const Point_2 &p) const; bool has_on_positive_side(const Point_2 &p) const; bool has_on_negative_side(const Point_2 &p) const; bool has_on(const Point_2 &p) const { return has_on_boundary(p); } bool is_horizontal() const; bool is_vertical() const; bool is_degenerate() const; Line_2 transform(const Aff_transformation_2 &t) const { return LineC2(t.transform(point(0)), t.transform(direction())); } }; template < class R > CGAL_KERNEL_INLINE bool LineC2::operator==(const LineC2 &l) const { if (CGAL::identical(base, l.base)) return true; return equal_lineC2(a(), b(), c(), l.a(), l.b(), l.c()); } template < class R > inline bool LineC2::operator!=(const LineC2 &l) const { return ! (*this == l); } template < class R > inline bool LineC2::is_horizontal() const { // FIXME : predicate return CGAL_NTS is_zero(a()); } template < class R > inline bool LineC2::is_vertical() const { // FIXME : predicate return CGAL_NTS is_zero(b()); } template < class R > CGAL_KERNEL_INLINE typename LineC2::FT LineC2::x_at_y(const typename LineC2::FT &y) const { CGAL_kernel_precondition_msg( ! is_horizontal(), "Line::x_at_y(FT y) is undefined for horizontal line"); return line_x_at_y(*this, y); } template < class R > CGAL_KERNEL_INLINE typename LineC2::FT LineC2::y_at_x(const typename LineC2::FT &x) const { CGAL_kernel_precondition_msg( ! is_vertical(), "Line::y_at_x(FT x) is undefined for vertical line"); return line_y_at_x(*this, x); } template < class R > inline typename LineC2::Line_2 LineC2:: perpendicular(const typename LineC2::Point_2 &p) const { typename R::FT fta, ftb, ftc; perpendicular_through_pointC2(a(), b(), p.x(), p.y(), fta, ftb, ftc); return Line_2(fta, ftb, ftc); } template < class R > inline typename LineC2::Line_2 LineC2::opposite() const { return LineC2( -a(), -b(), -c() ); } template < class R > CGAL_KERNEL_INLINE typename LineC2::Point_2 LineC2::point(int i) const { typename R::FT x, y; typename R::Construct_point_2 construct_point_2; line_get_pointC2(a(), b(), c(), i, x, y); return construct_point_2(x,y); } template < class R > CGAL_KERNEL_INLINE typename LineC2::Point_2 LineC2::point() const { typename R::FT x, y; typename R::Construct_point_2 construct_point_2; line_get_pointC2(a(), b(), c(), 0, x, y); return construct_point_2(x,y); } template < class R > CGAL_KERNEL_MEDIUM_INLINE typename LineC2::Point_2 LineC2:: projection(const typename LineC2::Point_2 &p) const { typename R::FT x, y; typename R::Construct_point_2 construct_point_2; line_project_pointC2(a(), b(), c(), p.x(), p.y(), x, y); return construct_point_2(x, y); } template < class R > inline typename LineC2::Direction_2 LineC2::direction() const { return Direction_2( b(), -a() ); } template < class R > inline typename LineC2::Vector_2 LineC2::to_vector() const { return Vector_2( b(), -a() ); } template < class R > CGAL_KERNEL_INLINE Oriented_side LineC2:: oriented_side(const typename LineC2::Point_2 &p) const { return side_of_oriented_lineC2(a(), b(), c(), p.x(), p.y()); } template < class R > inline bool LineC2:: has_on_boundary(const typename LineC2::Point_2 &p) const { return oriented_side(p) == ON_ORIENTED_BOUNDARY; } template < class R > inline bool LineC2:: has_on_positive_side(const typename LineC2::Point_2 &p) const { return oriented_side(p) == ON_POSITIVE_SIDE; } template < class R > CGAL_KERNEL_INLINE bool LineC2:: has_on_negative_side(const typename LineC2::Point_2 &p) const { return oriented_side(p) == ON_NEGATIVE_SIDE; } template < class R > inline bool LineC2::is_degenerate() const { return is_horizontal() && is_vertical(); } #ifndef CGAL_NO_OSTREAM_INSERT_LINEC2 template < class R > std::ostream & operator<<(std::ostream &os, const LineC2 &l) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << l.a() << ' ' << l.b() << ' ' << l.c(); case IO::BINARY : write(os, l.a()); write(os, l.b()); write(os, l.c()); return os; default: return os << "LineC2(" << l.a() << ", " << l.b() << ", " << l.c() <<')'; } } #endif // CGAL_NO_OSTREAM_INSERT_LINEC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_LINEC2 template < class R > std::istream & operator>>(std::istream &is, LineC2 &l) { typename R::FT a, b, c; switch(is.iword(IO::mode)) { case IO::ASCII : is >> a >> b >> c; break; case IO::BINARY : read(is, a); read(is, b); read(is, c); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) l = LineC2(a, b, c); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_LINEC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_LINE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/solve_3.h0000644000175000017500000000332611344301501030461 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/solve_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_CARTESIAN_SOLVE_3_H #define CGAL_CARTESIAN_CARTESIAN_SOLVE_3_H #include #include CGAL_BEGIN_NAMESPACE template void solve (const VectorC3 &v0, const VectorC3 &v1, const VectorC3 &v2, const VectorC3 &d, typename R::FT &alpha, typename R::FT &beta, typename R::FT &gamma) { solve(v0.x(), v0.y(), v0.z(), v1.x(), v1.y(), v1.z(), v2.x(), v2.y(), v2.z(), d.x(), d.y(), d.z(), alpha, beta, gamma); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_CARTESIAN_SOLVE_3_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/function_objects.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/function_obj0000644000175000017500000017062111344301501031343 0ustar debiandebian// Copyright (c) 1999-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/function_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion, Michael Hoffmann #ifndef CGAL_CARTESIAN_FUNCTION_OBJECTS_H #define CGAL_CARTESIAN_FUNCTION_OBJECTS_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CartesianKernelFunctors { using namespace CommonKernelFunctors; template class Angle_2 { typedef typename K::Point_2 Point_2; public: typedef Angle result_type; typedef Arity_tag< 3 > Arity; Angle operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return angleC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Angle_3 { typedef typename K::Point_3 Point_3; public: typedef Angle result_type; typedef Arity_tag< 3 > Arity; Angle operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return angleC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; template class Are_parallel_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()(const Line_2& l1, const Line_2& l2) const { return parallelC2(l1.a(), l1.b(), l2.a(), l2.b()); } bool operator()(const Segment_2& s1, const Segment_2& s2) const { return parallelC2(s1.source().x(), s1.source().y(), s1.target().x(), s1.target().y(), s2.source().x(), s2.source().y(), s2.target().x(), s2.target().y()); } bool operator()(const Ray_2& r1, const Ray_2& r2) const { return parallelC2(r1.source().x(), r1.source().y(), r1.second_point().x(), r1.second_point().y(), r2.source().x(), r2.source().y(), r2.second_point().x(), r2.second_point().y()); } }; template class Are_parallel_3 { typedef typename K::Line_3 Line_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Plane_3 Plane_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()(const Line_3& l1, const Line_3& l2) const { return parallelC3( l1.to_vector().x(), l1.to_vector().y(), l1.to_vector().z(), l2.to_vector().x(), l2.to_vector().y(), l2.to_vector().z()); } bool operator()(const Plane_3& h1, const Plane_3& h2) const { return parallelC3(h1.a(), h1.b(), h1.c(), h2.a(), h2.b(), h2.c()); } bool operator()(const Segment_3& s1, const Segment_3& s2) const { return parallelC3(s1.source().x(), s1.source().y(), s1.source().z(), s1.target().x(), s1.target().y(), s1.target().z(), s2.source().x(), s2.source().y(), s2.source().z(), s2.target().x(), s2.target().y(), s2.target().z()); } bool operator()(const Ray_3& r1, const Ray_3& r2) const { return parallelC3(r1.source().x(), r1.source().y(), r1.source().z(), r1.second_point().x(), r1.second_point().y(), r1.second_point().z(), r2.source().x(), r2.source().y(), r2.source().z(), r2.second_point().x(), r2.second_point().y(), r2.second_point().z()); } }; template class Bounded_side_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Bounded_side result_type; typedef Arity_tag< 2 > Arity; Bounded_side operator()( const Sphere_3& s, const Point_3& p) const { return s.bounded_side(p); } Bounded_side operator()( const Tetrahedron_3& t, const Point_3& p) const { FT alpha, beta, gamma; solve(t.vertex(1)-t.vertex(0), t.vertex(2)-t.vertex(0), t.vertex(3)-t.vertex(0), p - t.vertex(0), alpha, beta, gamma); if ( (alpha < 0) || (beta < 0) || (gamma < 0) || (alpha + beta + gamma > 1) ) return ON_UNBOUNDED_SIDE; if ( (alpha == 0) || (beta == 0) || (gamma == 0) || (alpha+beta+gamma == 1) ) return ON_BOUNDARY; return ON_BOUNDED_SIDE; } Bounded_side operator()( const Iso_cuboid_3& c, const Point_3& p) const { return c.bounded_side(p); } }; template class Collinear_are_ordered_along_line_2 { typedef typename K::Point_2 Point_2; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_2 Collinear_2; Collinear_2 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_ordered_along_line_2() {} Collinear_are_ordered_along_line_2(const Collinear_2& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); return collinear_are_ordered_along_lineC2 (p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Collinear_are_ordered_along_line_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_3 Collinear_3; Collinear_3 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_ordered_along_line_3() {} Collinear_are_ordered_along_line_3(const Collinear_3& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); return collinear_are_ordered_along_lineC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; template class Collinear_are_strictly_ordered_along_line_2 { typedef typename K::Point_2 Point_2; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_2 Collinear_2; Collinear_2 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_strictly_ordered_along_line_2() {} Collinear_are_strictly_ordered_along_line_2(const Collinear_2& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); return collinear_are_strictly_ordered_along_lineC2 (p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Collinear_are_strictly_ordered_along_line_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_3 Collinear_3; Collinear_3 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_strictly_ordered_along_line_3() {} Collinear_are_strictly_ordered_along_line_3(const Collinear_3& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); return collinear_are_strictly_ordered_along_lineC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; template class Collinear_has_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Construct_point_on_2 Construct_point_on_2; typedef typename K::Compare_x_2 Compare_x_2; typedef typename K::Compare_y_2 Compare_y_2; typedef typename K::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; Construct_point_on_2 cp; Compare_x_2 cx; Compare_y_2 cy; Collinear_are_ordered_along_line_2 co; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Collinear_has_on_2() {} Collinear_has_on_2(const Construct_point_on_2& cp_, const Compare_x_2& cx_, const Compare_y_2& cy_, const Collinear_are_ordered_along_line_2& co_) : cp(cp_), cx(cx_), cy(cy_), co(co_) {} bool operator()( const Ray_2& r, const Point_2& p) const { Point_2 source = cp(r,0); Point_2 second = cp(r,1); switch(cx(source, second)) { case SMALLER: return cx(source, p) != LARGER; case LARGER: return cx(p, source) != LARGER; default: switch(cy(source, second)){ case SMALLER: return cy(source, p) != LARGER; case LARGER: return cy(p, source) != LARGER; default: return true; // p == source } } // switch } bool operator()( const Segment_2& s, const Point_2& p) const { return co(cp(s,0), p, cp(s,1)); } }; template class Collinear_2 { typedef typename K::Point_2 Point_2; typedef typename K::Orientation_2 Orientation_2; Orientation_2 o; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Collinear_2() {} Collinear_2(const Orientation_2 o_) : o(o_) {} bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return o(p, q, r) == COLLINEAR; } }; template class Collinear_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return collinearC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; template class Compare_angle_with_x_axis_2 { typedef typename K::Direction_2 Direction_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()(const Direction_2& d1, const Direction_2& d2) const { return compare_angle_with_x_axisC2(d1.dx(), d1.dy(), d2.dx(), d2.dy()); } }; template class Compare_distance_2 { typedef typename K::Point_2 Point_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return cmp_dist_to_pointC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Compare_distance_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return cmp_dist_to_pointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; template class Compare_slope_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()(const Line_2& l1, const Line_2& l2) const { return compare_slopesC2(l1.a(), l1.b(), l2.a(), l2.b()); } Comparison_result operator()(const Segment_2& s1, const Segment_2& s2) const { return compare_slopesC2(s1.source().x(), s1.source().y(), s1.target().x(), s1.target().y(), s2.source().x(), s2.source().y(), s2.target().x(), s2.target().y()); } }; template class Compare_x_at_y_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()( const Point_2& p, const Line_2& h) const { return compare_y_at_xC2(p.y(), p.x(), h.b(), h.a(), h.c()); } Comparison_result operator()( const Point_2& p, const Line_2& h1, const Line_2& h2) const { return compare_y_at_xC2(p.y(), h1.b(), h1.a(), h1.c(), h2.b(), h2.a(), h2.c()); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h) const { return compare_y_at_xC2(l1.b(), l1.a(), l1.c(), l2.b(), l2.a(), l2.c(), h.b(), h.a(), h.c()); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { return compare_y_at_xC2(l1.b(), l1.a(), l1.c(), l2.b(), l2.a(), l2.c(), h1.b(), h1.a(), h1.c(), h2.b(), h2.a(), h2.c()); } }; template class Compare_xyz_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyzC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z()); } }; template class Compare_xy_2 { typedef typename K::Point_2 Point_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2& p, const Point_2& q) const { return compare_lexicographically_xyC2(p.x(), p.y(), q.x(), q.y()); } }; template class Compare_xy_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.x(), p.y(), q.x(), q.y()); } }; template class Compare_x_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2& p, const Point_2& q) const { return CGAL_NTS compare(p.x(), q.x()); } Comparison_result operator()( const Point_2& p, const Line_2& l, const Line_2& h) const { return compare_xC2(p.x(), l.a(), l.b(), l.c(), h.a(), h.b(), h.c()); } Comparison_result operator()( const Line_2& l, const Line_2& h1, const Line_2& h2) const { return compare_xC2(l.a(), l.b(), l.c(), h1.a(), h1.b(), h1.c(), h2.a(), h2.b(), h2.c()); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { return compare_xC2(l1.a(), l1.b(), l1.c(), l2.a(), l2.b(), l2.c(), h1.a(), h1.b(), h1.c(), h2.a(), h2.b(), h2.c()); } }; template class Compare_x_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return CGAL_NTS compare(p.x(), q.x()); } }; template class Compare_y_at_x_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()( const Point_2& p, const Line_2& h) const { return compare_y_at_xC2(p.x(), p.y(), h.a(), h.b(), h.c()); } Comparison_result operator()( const Point_2& p, const Line_2& h1, const Line_2& h2) const { return compare_y_at_xC2(p.x(), h1.a(), h1.b(), h1.c(), h2.a(), h2.b(), h2.c()); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h) const { return compare_y_at_xC2(l1.a(), l1.b(), l1.c(), l2.a(), l2.b(), l2.c(), h.a(), h.b(), h.c()); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { return compare_y_at_xC2(l1.a(), l1.b(), l1.c(), l2.a(), l2.b(), l2.c(), h1.a(), h1.b(), h1.c(), h2.a(), h2.b(), h2.c()); } Comparison_result operator()( const Point_2& p, const Segment_2& s) const { return compare_y_at_xC2(p.x(), p.y(), s.source().x(), s.source().y(), s.target().x(), s.target().y()); } Comparison_result operator()( const Point_2& p, const Segment_2& s1, const Segment_2& s2) const { return compare_y_at_x_segment_C2(p.x(), s1.source().x(), s1.source().y(), s1.target().x(), s1.target().y(), s2.source().x(), s2.source().y(), s2.target().x(), s2.target().y()); } }; template class Compare_y_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2& p, const Point_2& q) const { return CGAL_NTS compare(p.y(), q.y()); } Comparison_result operator()( const Point_2& p, const Line_2& l1, const Line_2& l2) const { return compare_xC2(p.y(), l1.b(), l1.a(), l1.c(), l2.b(), l2.a(), l2.c()); } Comparison_result operator()( const Line_2& l, const Line_2& h1, const Line_2& h2) const { return compare_xC2(l.b(), l.a(), l.c(), h1.b(), h1.a(), h1.c(), l.b(), l.a(), l.c(), h2.b(), h2.a(), h2.c()); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { return compare_xC2(l1.b(), l1.a(), l1.c(), l2.b(), l2.a(), l2.c(), h1.b(), h1.a(), h1.c(), h2.b(), h2.a(), h2.c()); } }; template class Compare_y_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return CGAL_NTS compare(p.y(), q.y()); } }; template class Compare_z_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return CGAL_NTS compare(p.z(), q.z()); } }; template class Compute_area_2 { typedef typename K::FT FT; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Point_2 Point_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Point_2& p, const Point_2& q, const Point_2& r ) const { FT v1x = q.x() - p.x(); FT v1y = q.y() - p.y(); FT v2x = r.x() - p.x(); FT v2y = r.y() - p.y(); return det2x2_by_formula(v1x, v1y, v2x, v2y)/2; } FT operator()( const Iso_rectangle_2& r ) const { return r.area(); } FT operator()( const Triangle_2& t ) const { return t.area(); } }; template class Compute_scalar_product_2 { typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()(const Vector_2& v, const Vector_2& w) const { return v.x() * w.x() + v.y() * w.y(); } }; template class Compute_scalar_product_3 { typedef typename K::FT FT; typedef typename K::Vector_3 Vector_3; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()(const Vector_3& v, const Vector_3& w) const { return v.x() * w.x() + v.y() * w.y() + v.z() * w.z(); } }; template class Compute_squared_area_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Triangle_3 Triangle_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Triangle_3& t ) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2)); } FT operator()( const Point_3& p, const Point_3& q, const Point_3& r ) const { return squared_areaC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; // FIXME template class Compute_squared_distance_Point_Point_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()( const Point_2& p, const Point_2& q) const { return squared_distanceC2(p.x(), p.y(), q.x(), q.y()); } }; // TODO ... template class Compute_squared_radius_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Circle_2& c) const { return c.squared_radius(); } FT operator()( const Point_2& p, const Point_2& q) const { return squared_radiusC2(p.x(), p.y(), q.x(), q.y()); } FT operator()( const Point_2& p, const Point_2& q, const Point_2& r) const { return squared_radiusC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Compute_squared_radius_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Sphere_3& s) const { return s.squared_radius(); } FT operator()( const Point_3& p, const Point_3& q) const { return squared_radiusC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z()); } FT operator()( const Point_3& p, const Point_3& q, const Point_3& r) const { return squared_radiusC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } FT operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { return squared_radiusC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z()); } }; template class Compute_volume_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()(const Point_3& p0, const Point_3& p1, const Point_3& p2, const Point_3& p3) const { return det3x3_by_formula(p1.x()-p0.x(), p1.y()-p0.y(), p1.z()-p0.z(), p2.x()-p0.x(), p2.y()-p0.y(), p2.z()-p0.z(), p3.x()-p0.x(), p3.y()-p0.y(), p3.z()-p0.z())/6; } FT operator()( const Tetrahedron_3& t ) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2), t.vertex(3)); } FT operator()( const Iso_cuboid_3& c ) const { return c.volume(); } }; template class Construct_base_vector_3 { typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; typedef typename K::FT FT; typedef typename K::Construct_cross_product_vector_3 Construct_cross_product_vector_3; typedef typename K::Construct_orthogonal_vector_3 Construct_orthogonal_vector_3; Construct_cross_product_vector_3 cp; Construct_orthogonal_vector_3 co; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Construct_base_vector_3() {} Construct_base_vector_3(const Construct_cross_product_vector_3& cp_, const Construct_orthogonal_vector_3& co_) : cp(cp_), co(co_) {} Vector_3 operator()( const Plane_3& h, int index ) const { if (index == 1) { if ( CGAL_NTS is_zero(h.a()) ) // parallel to x-axis return Vector_3(FT(1), FT(0), FT(0)); if ( CGAL_NTS is_zero(h.b()) ) // parallel to y-axis return Vector_3(FT(0), FT(1), FT(0)); if ( CGAL_NTS is_zero(h.c()) ) // parallel to z-axis return Vector_3(FT(0), FT(0), FT(1)); return Vector_3(-h.b(), h.a(), FT(0)); } else { return cp(co(h), this->operator()(h,1)); } } }; template class Construct_bisector_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Line_2 operator()(const Point_2& p, const Point_2& q) const { FT a, b, c; bisector_of_pointsC2(p.x(), p.y(), q.x(), q.y(), a, b, c); return Line_2(a, b, c); } Line_2 operator()(const Line_2& p, const Line_2& q) const { FT a, b, c; bisector_of_linesC2(p.a(), p.b(), p.c(), q.a(), q.b(), q.c(), a, b, c); return Line_2(a, b, c); } }; template class Construct_bisector_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()(const Point_3& p, const Point_3& q) const { FT a, b, c, d; bisector_of_pointsC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), a, b, c, d); return Plane_3(a, b, c, d); } Plane_3 operator()(const Plane_3& p, const Plane_3& q) const { FT a, b, c, d; bisector_of_planesC3(p.a(), p.b(), p.c(), p.d(), q.a(), q.b(), q.c(), q.d(), a, b, c, d); return Plane_3(a, b, c, d); } }; template class Construct_centroid_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 3 > Arity; Point_2 operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typename K::Construct_point_2 construct_point_2; FT x, y; centroidC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y(), x, y); return construct_point_2(x, y); } Point_2 operator()(const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& s) const { typename K::Construct_point_2 construct_point_2; FT x, y; centroidC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y(), s.x(), s.y(), x, y); return construct_point_2(x, y); } }; template class Construct_centroid_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 3 > Arity; Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { typename K::Construct_point_3 construct_point_3; FT x, y, z; centroidC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), x, y, z); return construct_point_3(x, y, z); } Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { typename K::Construct_point_3 construct_point_3; FT x, y, z; centroidC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z(), x, y, z); return construct_point_3(x, y, z); } }; template class Construct_circumcenter_2 { typedef typename K::Point_2 Point_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 3 > Arity; Point_2 operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typename K::Construct_point_2 construct_point_2; typedef typename K::FT FT; FT x, y; circumcenterC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y(), x, y); return construct_point_2(x, y); } Point_2 operator()(const Triangle_2& t) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2)); } }; template class Construct_circumcenter_3 { typedef typename K::FT FT; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 4 > Arity; Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { typename K::Construct_point_3 construct_point_3; FT x, y, z; circumcenterC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), x, y, z); return construct_point_3(x, y, z); } Point_3 operator()(const Triangle_3& t) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2)); } Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { typename K::Construct_point_3 construct_point_3; FT x, y, z; circumcenterC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z(), x, y, z); return construct_point_3(x, y, z); } Point_3 operator()(const Tetrahedron_3& t) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2), t.vertex(3)); } }; template class Construct_cross_product_vector_3 { typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()(const Vector_3& v, const Vector_3& w) const { return Vector_3(v.y() * w.z() - v.z() * w.y(), v.z() * w.x() - v.x() * w.z(), v.x() * w.y() - v.y() * w.x()); } }; template class Construct_lifted_point_3 { typedef typename K::Point_2 Point_2; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Construct_base_vector_3 Construct_base_vector_3; typedef typename K::Construct_point_on_3 Construct_point_on_3; typedef typename K::Construct_scaled_vector_3 Construct_scaled_vector_3; typedef typename K::Construct_translated_point_3 Construct_translated_point_3; Construct_base_vector_3 cb; Construct_point_on_3 cp; Construct_scaled_vector_3 cs; Construct_translated_point_3 ct; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Construct_lifted_point_3() {} Construct_lifted_point_3(const Construct_base_vector_3& cb_, const Construct_point_on_3& cp_, const Construct_scaled_vector_3& cs_, const Construct_translated_point_3& ct_) : cb(cb_), cp(cp_), cs(cs_), ct(ct_) {} Point_3 operator()(const Plane_3& h, const Point_2& p) const { return ct(ct(cp(h), cs(cb(h,1), p.x())), cs(cb(h,2), p.y())); } }; template class Construct_line_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Direction_2 Direction_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Line_2 Line_2; typedef typename K::Construct_point_on_2 Construct_point_on_2; Construct_point_on_2 c; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Construct_line_2() {} Construct_line_2(const Construct_point_on_2& c_) : c(c_) {} Line_2 operator()() const { return Line_2(); } // #ifndef CGAL_NO_DEPRECATED_CODE Line_2 operator()(const RT& a, const RT& b, const RT& cc) const { return Line_2(a, b, cc); } // #endif // CGAL_NO_DEPRECATED_CODE Line_2 operator()(const Point_2& p, const Point_2& q) const { FT a, b, cc; line_from_pointsC2(p.x(), p.y(), q.x(), q.y(), a, b, cc); return Line_2(a, b, cc); } Line_2 operator()(const Point_2& p, const Direction_2& d) const { FT a, b, cc; line_from_point_directionC2(p.x(), p.y(), d.dx(), d.dy(), a, b, cc); return Line_2(a, b, cc); } Line_2 operator()(const Point_2& p, const Vector_2& v) const { FT a, b, cc; line_from_point_directionC2(p.x(), p.y(), v.x(), v.y(), a, b, cc); return Line_2(a, b, cc); } Line_2 operator()(const Segment_2& s) const { return this->operator()(c(s, 0), c(s, 1)); } Line_2 operator()(const Ray_2& r) const { return this->operator()(c(r, 0), c(r, 1)); } }; template class Construct_line_3 { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Line_3 Line_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Construct_vector_3 Construct_vector_3; typedef typename K::Construct_direction_3 Construct_direction_3; typedef typename K::Construct_point_on_3 Construct_point_on_3; Construct_vector_3 cv; Construct_point_on_3 cp; public: typedef Line_3 result_type; typedef Arity_tag< 2 > Arity; Construct_line_3() {} Construct_line_3(const Construct_vector_3& cv_, const Construct_point_on_3& cp_) : cv(cv_), cp(cp_) {} Line_3 operator()() const { return Line_3(); } Line_3 operator()(const Point_3& p, const Point_3& q) const { return Line_3(p, cv(p, q)); } Line_3 operator()(const Point_3& p, const Direction_3& d) const { return operator()(p, cv(d.dx(), d.dy(), d.dz())); } Line_3 operator()(const Point_3& p, const Vector_3& v) const { return Line_3(p, v); } Line_3 operator()(const Segment_3& s) const { return Line_3(cp(s,0), cv(cp(s,0), cp(s,1))); } Line_3 operator()(const Ray_3& r) const { return Line_3(cp(r,0), cv(cp(r,0), cp(r,1))); } }; template class Construct_midpoint_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()(const Point_2& p, const Point_2& q) const { typename K::Construct_point_2 construct_point_2; FT x, y; midpointC2(p.x(), p.y(), q.x(), q.y(), x, y); return construct_point_2(x, y); } }; template class Construct_midpoint_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()(const Point_3& p, const Point_3& q) const { typename K::Construct_point_3 construct_point_3; FT x, y, z; midpointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), x, y, z); return construct_point_3(x, y, z); } }; template class Construct_opposite_vector_2 { typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 1 > Arity; Vector_2 operator()( const Vector_2& v) const { return Vector_2(-v.x(), -v.y()); } }; template class Construct_opposite_vector_3 { typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 1 > Arity; Vector_3 operator()( const Vector_3& v) const { return Vector_3(-v.x(), -v.y(), -v.z()); } }; template class Construct_orthogonal_vector_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; public: typedef Vector_3 result_type; typedef Arity_tag< 1 > Arity; Vector_3 operator()( const Plane_3& p ) const { return Vector_3(p.a(), p.b(), p.c()); } Vector_3 operator()( const Point_3& p, const Point_3& q, const Point_3& r ) const { FT rpx = p.x()-r.x(); FT rpy = p.y()-r.y(); FT rpz = p.z()-r.z(); FT rqx = q.x()-r.x(); FT rqy = q.y()-r.y(); FT rqz = q.z()-r.z(); // Cross product rp * rq FT vx = rpy*rqz - rqy*rpz; FT vy = rpz*rqx - rqz*rpx; FT vz = rpx*rqy - rqx*rpy; typename K::Construct_vector_3 construct_vector; return construct_vector(vx, vy, vz); } }; template class Construct_projected_point_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Line_3 Line_3; typedef typename K::FT FT; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Line_3& l, const Point_3& p ) const { // projects p on the line l FT lpx = l.point().x(); FT lpy = l.point().y(); FT lpz = l.point().z(); FT ldx = l.direction().dx(); FT ldy = l.direction().dy(); FT ldz = l.direction().dz(); FT dpx = p.x()-lpx; FT dpy = p.y()-lpy; FT dpz = p.z()-lpz; FT lambda = (ldx*dpx+ldy*dpy+ldz*dpz) / (ldx*ldx+ldy*ldy+ldz*ldz); return Point_3(lpx + lambda * ldx, lpy + lambda * ldy, lpz + lambda * ldz); } Point_3 operator()( const Plane_3& h, const Point_3& p ) const { return h.projection(p); } }; template class Construct_scaled_vector_2 { typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()( const Vector_2& v, const FT& c) const { return Vector_2(c * v.x(), c * v.y()); } }; template class Construct_scaled_vector_3 { typedef typename K::FT FT; typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()( const Vector_3& w, const FT& c) const { return Vector_3(c * w.x(), c * w.y(), c * w.z()); } }; template class Construct_translated_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Point_2& p, const Vector_2& v) const { typename K::Construct_point_2 construct_point_2; return construct_point_2(p.x() + v.x(), p.y() + v.y()); } Point_2 operator()( const Origin& , const Vector_2& v) const { typename K::Construct_point_2 construct_point_2; return construct_point_2(v.x(), v.y()); } }; template class Construct_translated_point_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Point_3& p, const Vector_3& v) const { typename K::Construct_point_3 construct_point_3; return construct_point_3(p.x() + v.x(), p.y() + v.y(), p.z() + v.z()); } Point_3 operator()( const Origin& , const Vector_3& v) const { typename K::Construct_point_3 construct_point_3; return construct_point_3(v.x(), v.y(), v.z()); } }; template class Construct_vector_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Line_2 Line_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Point_2 Point_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()() const { return Vector_2(); } Vector_2 operator()( const Point_2& p, const Point_2& q) const { return Vector_2(q.x() - p.x(), q.y() - p.y()); } Vector_2 operator()( const Origin&, const Point_2& q) const { return Vector_2(q.x(), q.y()); } Vector_2 operator()( const Point_2& p, const Origin& ) const { return Vector_2(-p.x(), -p.y()); } Vector_2 operator()( const Segment_2& s) const { return s.to_vector(); } Vector_2 operator()( const Ray_2& r) const { return r.to_vector(); } Vector_2 operator()( const Line_2& l) const { return l.to_vector(); } Vector_2 operator()( Null_vector) const { return Vector_2(FT(0), FT(0)); } // #ifndef CGAL_NO_DEPRECATED_CODE Vector_2 operator()( const RT& x, const RT& y) const { return Vector_2(x, y); } Vector_2 operator()( const RT& x, const RT& y, const RT& w) const { return Vector_2(x, y, w); } // #endif // CGAL_NO_DEPRECATED_CODE }; template class Construct_vector_3 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Line_3 Line_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()() const { return Vector_3(); } Vector_3 operator()( const Point_3& p, const Point_3& q) const { return Vector_3(q.x() - p.x(), q.y() - p.y(), q.z() - p.z()); } Vector_3 operator()( const Origin&, const Point_3& q) const { return Vector_3(q.x(), q.y(), q.z()); } Vector_3 operator()( const Point_3& p, const Origin&) const { return Vector_3(- p.x(), - p.y(), - p.z()); } Vector_3 operator()( const Segment_3& s) const { return s.to_vector(); } Vector_3 operator()( const Ray_3& r) const { return r.to_vector(); } Vector_3 operator()( const Line_3& l) const { return l.to_vector(); } Vector_3 operator()( const Null_vector&) const { return Vector_3(FT(0), FT(0), FT(0)); } // #ifndef CGAL_NO_DEPRECATED_CODE Vector_3 operator()( const RT& x, const RT& y, const RT& z) const { return Vector_3(x, y, z); } Vector_3 operator()( const RT& x, const RT& y, const RT& z, const RT& w) const { return Vector_3(x, y, z, w); } // #endif // CGAL_NO_DEPRECATED_CODE }; template class Coplanar_orientation_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Coplanar_3 Coplanar_3; typedef typename K::Collinear_3 Collinear_3; Coplanar_3 cp; Collinear_3 cl; #endif // CGAL_kernel_exactness_preconditions public: typedef Orientation result_type; typedef Arity_tag< 4 > Arity; #ifdef CGAL_kernel_exactness_preconditions Coplanar_orientation_3() {} Coplanar_orientation_3(const Coplanar_3& cp_, const Collinear_3& cl_) : cp(cp_), cl(cl_) {} #endif // CGAL_kernel_exactness_preconditions Orientation operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return coplanar_orientationC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } Orientation operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { // p,q,r,s supposed to be coplanar // p,q,r supposed to be non collinear // tests whether s is on the same side of p,q as r // returns : // COLLINEAR if pqr collinear // POSITIVE if qrp and qrs have the same orientation // NEGATIVE if qrp and qrs have opposite orientations CGAL_kernel_exactness_precondition( ! cl(p, q, r) ); CGAL_kernel_exactness_precondition( cp(p, q, r, s) ); return coplanar_orientationC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z()); } }; template class Coplanar_side_of_bounded_circle_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Coplanar_3 Coplanar_3; typedef typename K::Collinear_3 Collinear_3; Coplanar_3 cp; Collinear_3 cl; #endif // CGAL_kernel_exactness_preconditions public: typedef Bounded_side result_type; typedef Arity_tag< 4 > Arity; #ifdef CGAL_kernel_exactness_preconditions Coplanar_side_of_bounded_circle_3() {} Coplanar_side_of_bounded_circle_3(const Coplanar_3& cp_, const Collinear_3& cl_) : cp(cp_), cl(cl_) {} #endif // CGAL_kernel_exactness_preconditions Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& t) const { // p,q,r,t are supposed to be coplanar. // p,q,r determine an orientation of this plane (not collinear). // returns the equivalent of side_of_bounded_circle(p,q,r,t) // in this plane CGAL_kernel_exactness_precondition( cp(p,q,r,t) ); CGAL_kernel_exactness_precondition( !cl(p,q,r) ); return coplanar_side_of_bounded_circleC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), t.x(), t.y(), t.z()); } }; template class Equal_xy_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.x() == q.x() && p.y() == q.y(); } }; template class Equal_x_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return p.x() == q.x(); } }; template class Equal_x_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.x() == q.x(); } }; template class Equal_y_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return p.y() == q.y(); } }; template class Equal_y_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.y() == q.y(); } }; template class Equal_z_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.z() == q.z(); } }; template class Has_on_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Triangle_3 Triangle_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Line_3& l, const Point_3& p) const { return l.has_on(p); } bool operator()( const Ray_3& r, const Point_3& p) const { return r.has_on(p); } bool operator()( const Segment_3& s, const Point_3& p) const { return s.has_on(p); } bool operator()( const Plane_3& pl, const Point_3& p) const { return pl.has_on(p); } bool operator()( const Triangle_3& t, const Point_3& p) const { Point_3 o = t.vertex(0) + t.supporting_plane().orthogonal_vector(); Vector_3 v0 = t.vertex(0)-o, v1 = t.vertex(1)-o, v2 = t.vertex(2)-o; FT alpha, beta, gamma; solve(v0, v1, v2, p-o, alpha, beta, gamma); return (alpha >= FT(0)) && (beta >= FT(0)) && (gamma >= FT(0)) && ((alpha+beta+gamma == FT(1))); } }; template class Less_distance_to_point_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return has_smaller_dist_to_pointC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Less_distance_to_point_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return has_smaller_dist_to_pointC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } }; // TODO ... template class Less_signed_distance_to_line_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Equal_2 Equal_2; public: typedef bool result_type; typedef Arity_tag< 4 > Arity; bool operator()(const Point_2& a, const Point_2& b, const Point_2& c, const Point_2& d) const { CGAL_kernel_precondition_code(Equal_2 equal;) CGAL_kernel_precondition(! equal(a,b)); Comparison_result res = cmp_signed_dist_to_lineC2(a.x(), a.y(), b.x(), b.y(), c.x(), c.y(), d.x(), d.y()); if ( res == SMALLER ) return true; return false; } bool operator()(const Line_2& l, const Point_2& p, const Point_2& q) const { return has_smaller_signed_dist_to_directionC2(l.a(), l.b(), p.x(), p.y(), q.x(), q.y()); } }; template class Less_signed_distance_to_plane_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Collinear_3 Collinear_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()( const Plane_3& h, const Point_3& p, const Point_3& q) const { return has_smaller_signed_dist_to_directionC3(h.a(), h.b(), h.c(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z()); } bool operator()( const Point_3& hp, const Point_3& hq, const Point_3& hr, const Point_3& p, const Point_3& q) const { CGAL_kernel_precondition_code(Collinear_3 collinear_3;) CGAL_kernel_precondition(! collinear_3(hp, hq, hr)); return has_smaller_signed_dist_to_planeC3(hp.x(), hp.y(), hp.z(), hq.x(), hq.y(), hq.z(), hr.x(), hr.y(), hr.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z());; } }; template class Less_xyz_3 { typedef typename K::Point_3 Point_3; typedef typename K::Compare_xyz_3 Compare_xyz_3; Compare_xyz_3 c; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Less_xyz_3() {} Less_xyz_3(const Compare_xyz_3& c_) : c(c_) {} bool operator()( const Point_3& p, const Point_3& q) const { return c(p, q) == SMALLER; } }; template class Less_xy_2 { typedef typename K::Point_2 Point_2; typedef typename K::Compare_xy_2 Compare_xy_2; Compare_xy_2 c; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Less_xy_2() {} Less_xy_2(const Compare_xy_2& c_) : c(c_) {} bool operator()( const Point_2& p, const Point_2& q) const { return c(p, q) == SMALLER; } }; template class Less_xy_3 { typedef typename K::Point_3 Point_3; typedef typename K::Compare_xy_3 Compare_xy_3; Compare_xy_3 c; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Less_xy_3() {} Less_xy_3(const Compare_xy_3& c_) : c(c_) {} bool operator()( const Point_3& p, const Point_3& q) const { return c(p, q) == SMALLER; } }; template class Less_x_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return p.x() < q.x(); } }; template class Less_x_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.x() < q.x(); } }; template class Less_yx_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return compare_lexicographically_xyC2(p.y(), p.x(), q.y(), q.x()) == SMALLER; } }; template class Less_y_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return p.y() < q.y(); } }; template class Less_y_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.y() < q.y(); } }; template class Less_z_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.z() < q.z(); } }; template class Orientation_2 { typedef typename K::Point_2 Point_2; public: typedef Orientation result_type; typedef Arity_tag< 3 > Arity; Orientation operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return orientationC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y()); } }; template class Orientation_3 { typedef typename K::Point_3 Point_3; public: typedef Orientation result_type; typedef Arity_tag< 4 > Arity; Orientation operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { return orientationC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z()); } }; template class Side_of_bounded_circle_2 { typedef typename K::Point_2 Point_2; public: typedef Bounded_side result_type; typedef Arity_tag< 4 > Arity; Bounded_side operator()( const Point_2& p, const Point_2& q, const Point_2& t) const { return side_of_bounded_circleC2(p.x(), p.y(), q.x(), q.y(), t.x(), t.y()); } Bounded_side operator()( const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& t) const { return side_of_bounded_circleC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y(), t.x(), t.y()); } }; template class Side_of_bounded_sphere_3 { typedef typename K::Point_3 Point_3; public: typedef Bounded_side result_type; typedef Arity_tag< 5 > Arity; Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& test) const { return side_of_bounded_sphereC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), test.x(), test.y(), test.z()); } Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& test) const { return side_of_bounded_sphereC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), test.x(), test.y(), test.z()); } Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s, const Point_3& test) const { return side_of_bounded_sphereC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z(), test.x(), test.y(), test.z()); } }; template class Side_of_oriented_circle_2 { typedef typename K::Point_2 Point_2; public: typedef Oriented_side result_type; typedef Arity_tag< 4 > Arity; Oriented_side operator()( const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& t) const { return side_of_oriented_circleC2(p.x(), p.y(), q.x(), q.y(), r.x(), r.y(), t.x(), t.y()); } }; template class Side_of_oriented_sphere_3 { typedef typename K::Point_3 Point_3; public: typedef Oriented_side result_type; typedef Arity_tag< 5 > Arity; Oriented_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s, const Point_3& test) const { return side_of_oriented_sphereC3(p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), s.x(), s.y(), s.z(), test.x(), test.y(), test.z()); } }; } // namespace CartesianKernelFunctors CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_FUNCTION_OBJECTS_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Rotation_rep_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Rotation_rep0000644000175000017500000001343511344301501031330 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Rotation_rep_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_ROTATION_REP_2_H #define CGAL_CARTESIAN_ROTATION_REP_2_H #include CGAL_BEGIN_NAMESPACE template < class R > class Rotation_repC2: public Aff_transformation_rep_baseC2 { friend class Aff_transformation_repC2; friend class Translation_repC2; friend class Scaling_repC2; public: typedef Aff_transformation_rep_baseC2 Aff_t_base; typedef typename Aff_t_base::FT FT; typedef typename Aff_t_base::Point_2 Point_2; typedef typename Aff_t_base::Vector_2 Vector_2; typedef typename Aff_t_base::Direction_2 Direction_2; typedef typename Aff_t_base::Aff_transformation_2 Aff_transformation_2; typedef Aff_transformation_repC2 Transformation; typedef Translation_repC2 Translation; typedef Rotation_repC2 Rotation; typedef Scaling_repC2 Scaling; Rotation_repC2() {} Rotation_repC2(const FT &sinus, const FT &cosinus) : sinus_(sinus), cosinus_(cosinus) {} Rotation_repC2(const Direction_2 &d, const FT &eps_num, const FT &eps_den = FT(1)) { // FIXME : construction FT sin_num; FT cos_num; FT denom; rational_rotation_approximation(d.to_vector().x(), d.to_vector().y(), sin_num, cos_num, denom, eps_num, eps_den); sinus_ = sin_num/denom; cosinus_ = cos_num/denom; } Point_2 transform(const Point_2 &p) const { // FIXME : construction return Point_2(cosinus_ * p.x() - sinus_ * p.y(), sinus_ * p.x() + cosinus_ * p.y()); } Vector_2 transform(const Vector_2 &v) const { // FIXME : construction return Vector_2(cosinus_ * v.x() - sinus_ * v.y(), sinus_ * v.x() + cosinus_ * v.y()); } Direction_2 transform(const Direction_2 &d) const { // FIXME : construction Vector_2 v = d.to_vector(); return Direction_2(cosinus_ * v.x() - sinus_ * v.y(), sinus_ * v.x() + cosinus_ * v.y()); } Aff_transformation_2 inverse() const { // FIXME : construction return Aff_transformation_2(ROTATION, - sinus_, cosinus_, FT(1)); } Aff_transformation_2 operator*(const Aff_t_base &t) const { return t.compose(*this); } Aff_transformation_2 compose(const Translation &t) const { // FIXME : construction return Aff_transformation_2(cosinus_, -sinus_, t.translationvector_.x(), sinus_, cosinus_, t.translationvector_.y()); } Aff_transformation_2 compose(const Rotation &t) const { // FIXME : construction return Aff_transformation_2(ROTATION, t.sinus_*cosinus_ + t.cosinus_*sinus_, t.cosinus_*cosinus_-t.sinus_*sinus_ ); } Aff_transformation_2 compose(const Scaling &t) const { // FIXME : construction return Aff_transformation_2(t.scalefactor_*cosinus_, t.scalefactor_*-sinus_, t.scalefactor_*sinus_, t.scalefactor_*cosinus_); } Aff_transformation_2 compose(const Transformation &t) const { // FIXME : construction return Aff_transformation_2(cosinus_*t.t11 + sinus_*t.t12, -sinus_*t.t11 + cosinus_*t.t12, t.t13, cosinus_*t.t21 + sinus_*t.t22, -sinus_*t.t21 + cosinus_*t.t22, t.t23); } bool is_even() const { return true; } FT cartesian(int i, int j) const { // FIXME : construction switch (i) { case 0: switch (j) { case 0: return cosinus_; case 1: return -sinus_; case 2: return FT(0); } case 1: switch (j) { case 0: return sinus_; case 1: return cosinus_; case 2: return FT(0); } case 2: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(1); } } return FT(0); } std::ostream &print(std::ostream &os) const { os << "Aff_transformationC2(" << sinus_ << ", " << cosinus_ << ")"; return os; } private: FT sinus_, cosinus_; }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_ROTATION_REP_2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_rep_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transfor0000644000175000017500000002657111344301501031302 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_rep_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_AFF_TRANSFORMATION_REP_3_H #define CGAL_CARTESIAN_AFF_TRANSFORMATION_REP_3_H #include CGAL_BEGIN_NAMESPACE template < class R > class Aff_transformation_rep_baseC3 : public Ref_counted_virtual { public: typedef typename R::FT FT; typedef typename R::Point_3 Point_3; typedef typename R::Vector_3 Vector_3; typedef typename R::Direction_3 Direction_3; typedef typename R::Aff_transformation_3 Aff_transformation_3; virtual ~Aff_transformation_rep_baseC3(){} virtual Point_3 transform(const Point_3 &p) const = 0; virtual Vector_3 transform(const Vector_3 &v) const = 0; virtual Direction_3 transform(const Direction_3 &d) const = 0; virtual Aff_transformation_3 operator*( const Aff_transformation_rep_baseC3 &t) const = 0; virtual Aff_transformation_3 compose( const Translation_repC3 &t) const = 0; virtual Aff_transformation_3 compose( const Scaling_repC3 &t) const = 0; virtual Aff_transformation_3 compose( const Aff_transformation_repC3 &t) const = 0; virtual Aff_transformation_3 inverse() const = 0; virtual Aff_transformation_3 transpose() const = 0; virtual bool is_even() const = 0; virtual FT cartesian(int i, int j) const = 0; virtual std::ostream &print(std::ostream &os) const = 0; }; template < class R > class Aff_transformation_repC3 : public Aff_transformation_rep_baseC3 { friend class Translation_repC3; friend class Scaling_repC3; public: typedef typename R::FT FT; typedef Aff_transformation_repC3 Self; typedef Aff_transformation_rep_baseC3 Transformation_base_3; typedef Aff_transformation_repC3 Transformation_3; typedef Translation_repC3 Translation_3; typedef Scaling_repC3 Scaling_3; typedef typename Transformation_base_3::Point_3 Point_3; typedef typename Transformation_base_3::Vector_3 Vector_3; typedef typename Transformation_base_3::Direction_3 Direction_3; typedef typename Transformation_base_3:: Aff_transformation_3 Aff_transformation_3; Aff_transformation_repC3() {} Aff_transformation_repC3(const FT& m11, const FT& m12, const FT& m13, const FT& m21, const FT& m22, const FT& m23, const FT& m31, const FT& m32, const FT& m33) : t11(m11), t12(m12), t13(m13), t14(FT(0)), t21(m21), t22(m22), t23(m23), t24(FT(0)), t31(m31), t32(m32), t33(m33), t34(FT(0)) {} Aff_transformation_repC3( const FT& m11, const FT& m12, const FT& m13, const FT& m14, const FT& m21, const FT& m22, const FT& m23, const FT& m24, const FT& m31, const FT& m32, const FT& m33, const FT& m34 ) : t11(m11), t12(m12), t13(m13), t14(m14), t21(m21), t22(m22), t23(m23), t24(m24), t31(m31), t32(m32), t33(m33), t34(m34) {} virtual ~Aff_transformation_repC3() {} virtual Point_3 transform(const Point_3& p) const // FIXME : construction { typename R::Construct_point_3 construct_point_3; return construct_point_3(t11 * p.x() + t12 * p.y() + t13 * p.z() + t14, t21 * p.x() + t22 * p.y() + t23 * p.z() + t24, t31 * p.x() + t32 * p.y() + t33 * p.z() + t34); } // note that a vector is not translated virtual Vector_3 transform(const Vector_3& v) const // FIXME : construction { return Vector_3(t11 * v.x() + t12 * v.y() + t13 * v.z(), t21 * v.x() + t22 * v.y() + t23 * v.z(), t31 * v.x() + t32 * v.y() + t33 * v.z()); } // note that a direction is not translated virtual Direction_3 transform(const Direction_3& dir) const { // FIXME : construction Vector_3 v = dir.to_vector(); return Direction_3(t11 * v.x() + t12 * v.y() + t13 * v.z(), t21 * v.x() + t22 * v.y() + t23 * v.z(), t31 * v.x() + t32 * v.y() + t33 * v.z()); } // Note that Aff_transformation is not defined yet, // so the following 6 functions have to be implemented // outside class body virtual Aff_transformation_3 inverse() const; virtual Aff_transformation_3 transpose() const; virtual Aff_transformation_3 operator*(const Transformation_base_3 &t) const; virtual Aff_transformation_3 compose(const Transformation_3 &t) const; virtual Aff_transformation_3 compose(const Translation_3 &t) const; virtual Aff_transformation_3 compose(const Scaling_3 &t) const; virtual bool is_even() const { return sign_of_determinant3x3(t11, t12, t13, t21, t22, t23, t31, t32, t33) == POSITIVE; } virtual FT cartesian(int i, int j) const { switch (i) { case 0: switch (j) { case 0: return t11; case 1: return t12; case 2: return t13; case 3: return t14; } case 1: switch (j) { case 0: return t21; case 1: return t22; case 2: return t23; case 3: return t24; } case 2: switch (j) { case 0: return t31; case 1: return t32; case 2: return t33; case 3: return t34; } case 3: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(0); case 3: return FT(1); } } return FT(0); } virtual std::ostream &print(std::ostream &os) const { os <<"Aff_transformationC3("< CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC3::Aff_transformation_3 Aff_transformation_repC3::inverse() const // FIXME : construction { return Aff_transformation_3( det2x2_by_formula( t22, t23, t32, t33), // i 11 -det2x2_by_formula( t12, t13, t32, t33), // i 12 det2x2_by_formula( t12, t13, t22, t23), // i 13 -det3x3_by_formula( t12, t13, t14, t22, t23, t24, t32, t33, t34 ), -det2x2_by_formula( t21, t23, t31, t33), // i 21 det2x2_by_formula( t11, t13, t31, t33), // i 22 -det2x2_by_formula( t11, t13, t21, t23), // i 23 det3x3_by_formula( t11, t13, t14, t21, t23, t24, t31, t33, t34 ), det2x2_by_formula( t21, t22, t31, t32), // i 31 -det2x2_by_formula( t11, t12, t31, t32), // i 32 det2x2_by_formula( t11, t12, t21, t22), // i 33 -det3x3_by_formula( t11, t12, t14, t21, t22, t24, t31, t32, t34 ), det3x3_by_formula( t11, t12, t13, t21, t22, t23, t31, t32, t33 )); } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repC3::Aff_transformation_3 Aff_transformation_repC3:: operator*(const Aff_transformation_rep_baseC3 &t) const { return t.compose(*this); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC3::Aff_transformation_3 Aff_transformation_repC3:: compose(const Aff_transformation_repC3 &t) const // FIXME : construction { return Aff_transformation_3(t.t11*t11 + t.t12*t21 + t.t13*t31, t.t11*t12 + t.t12*t22 + t.t13*t32, t.t11*t13 + t.t12*t23 + t.t13*t33, t.t11*t14 + t.t12*t24 + t.t13*t34 + t.t14, t.t21*t11 + t.t22*t21 + t.t23*t31, t.t21*t12 + t.t22*t22 + t.t23*t32, t.t21*t13 + t.t22*t23 + t.t23*t33, t.t21*t14 + t.t22*t24 + t.t23*t34 + t.t24, t.t31*t11 + t.t32*t21 + t.t33*t31, t.t31*t12 + t.t32*t22 + t.t33*t32, t.t31*t13 + t.t32*t23 + t.t33*t33, t.t31*t14 + t.t32*t24 + t.t33*t34 + t.t34); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC3::Aff_transformation_3 Aff_transformation_repC3:: compose(const Translation_repC3 &t) const // FIXME : construction { return Aff_transformation_3(t11, t12, t13, t14 + t.translationvector_.x(), t21, t22, t23, t24 + t.translationvector_.y(), t31, t32, t33, t34 + t.translationvector_.z()); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC3::Aff_transformation_3 Aff_transformation_repC3:: compose(const Scaling_repC3 &t) const // FIXME : construction { return Aff_transformation_3(t.scalefactor_ * t11, t.scalefactor_ * t12, t.scalefactor_ * t13, t.scalefactor_ * t14, t.scalefactor_ * t21, t.scalefactor_ * t22, t.scalefactor_ * t23, t.scalefactor_ * t24, t.scalefactor_ * t31, t.scalefactor_ * t32, t.scalefactor_ * t33, t.scalefactor_ * t34); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repC3::Aff_transformation_3 Aff_transformation_repC3::transpose() const { return Aff_transformation_3( t11, t21, t31, t14, t12, t22, t32, t24, t13, t23, t33, t34); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_AFF_TRANSFORMATION_REP_3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Scaling_rep_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Scaling_rep_0000644000175000017500000001017311344301501031244 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Scaling_rep_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_SCALING_REP_2_H #define CGAL_CARTESIAN_SCALING_REP_2_H CGAL_BEGIN_NAMESPACE template < class R > class Scaling_repC2: public Aff_transformation_rep_baseC2 { friend class Aff_transformation_repC2; friend class Translation_repC2; friend class Rotation_repC2; public: typedef Aff_transformation_rep_baseC2 Aff_t_base; typedef typename Aff_t_base::FT FT; typedef typename Aff_t_base::Point_2 Point_2; typedef typename Aff_t_base::Vector_2 Vector_2; typedef typename Aff_t_base::Direction_2 Direction_2; typedef typename Aff_t_base::Aff_transformation_2 Aff_transformation_2; typedef Aff_transformation_repC2 Transformation; typedef Translation_repC2 Translation; typedef Rotation_repC2 Rotation; typedef Scaling_repC2 Scaling; Scaling_repC2() {} Scaling_repC2(const FT &scalefactor) : scalefactor_(scalefactor) {} ~Scaling_repC2() {} Point_2 transform(const Point_2 &p) const { return Point_2(scalefactor_ * p.x(), scalefactor_ * p.y()); } Vector_2 transform(const Vector_2 &p) const { return Vector_2(scalefactor_ * p.x(), scalefactor_ * p.y()); } Direction_2 transform(const Direction_2 &d) const { return d; } Aff_transformation_2 operator*(const Aff_t_base &t) const { return t.compose(*this); } Aff_transformation_2 compose(const Translation &t) const { FT ft0(0); return Aff_transformation_2(scalefactor_, ft0, t.translationvector_.x(), ft0, scalefactor_, t.translationvector_.y()); } Aff_transformation_2 compose(const Rotation &t) const { return Aff_transformation_2(scalefactor_ * t.cosinus_, scalefactor_ * -t.sinus_, scalefactor_ * t.sinus_, scalefactor_ * t.cosinus_); } Aff_transformation_2 compose(const Scaling &t) const { return Aff_transformation_2(SCALING, scalefactor_*t.scalefactor_); } Aff_transformation_2 compose(const Transformation &t) const { return Aff_transformation_2(scalefactor_ * t.t11, scalefactor_ * t.t12, t.t13, scalefactor_ * t.t21, scalefactor_ * t.t22, t.t23); } Aff_transformation_2 inverse() const { return Aff_transformation_2(SCALING, FT(1)/scalefactor_); } bool is_even() const { return true; } FT cartesian(int i, int j) const { if (i!=j) return FT(0); return (i==2) ? FT(1) : scalefactor_; } std::ostream &print(std::ostream &os) const { os << "Aff_transformationC2(" << scalefactor_ << ")"; return os; } private: FT scalefactor_; }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_SCALING_REP_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Triangle_3.h0000644000175000017500000001160111344301501031071 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Triangle_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_TRIANGLE_3_H #define CGAL_CARTESIAN_TRIANGLE_3_H #include CGAL_BEGIN_NAMESPACE template class TriangleC3 { typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Triangle_3 Triangle_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; TriangleC3() {} TriangleC3(const Point_3 &p, const Point_3 &q, const Point_3 &r) : base(p, q, r) {} bool operator==(const TriangleC3 &t) const; bool operator!=(const TriangleC3 &t) const; Plane_3 supporting_plane() const; Triangle_3 transform(const Aff_transformation_3 &t) const { return TriangleC3(t.transform(vertex(0)), t.transform(vertex(1)), t.transform(vertex(2))); } bool has_on(const Point_3 &p) const; bool is_degenerate() const; const Point_3 & vertex(int i) const; const Point_3 & operator[](int i) const; Bbox_3 bbox() const; FT squared_area() const; }; template < class R > bool TriangleC3::operator==(const TriangleC3 &t) const { if (CGAL::identical(base, t.base)) return true; int i; for(i=0; i<3; i++) if ( vertex(0) == t.vertex(i) ) break; return (i<3) && vertex(1) == t.vertex(i+1) && vertex(2) == t.vertex(i+2); } template < class R > inline bool TriangleC3::operator!=(const TriangleC3 &t) const { return !(*this == t); } template < class R > const typename TriangleC3::Point_3 & TriangleC3::vertex(int i) const { if (i<0) i=(i%3)+3; else if (i>2) i=i%3; return (i==0) ? get(base).e0 : (i==1) ? get(base).e1 : get(base).e2; } template < class R > inline const typename TriangleC3::Point_3 & TriangleC3::operator[](int i) const { return vertex(i); } template < class R > CGAL_KERNEL_MEDIUM_INLINE typename TriangleC3::FT TriangleC3::squared_area() const { return CGALi::squared_area(vertex(0), vertex(1), vertex(2), R()); } template < class R > inline typename TriangleC3::Plane_3 TriangleC3::supporting_plane() const { return Plane_3(vertex(0), vertex(1), vertex(2)); } template < class R > Bbox_3 TriangleC3::bbox() const { typename R::Construct_bbox_3 construct_bbox_3; return construct_bbox_3(vertex(0)) + construct_bbox_3(vertex(1)) + construct_bbox_3(vertex(2)); } template < class R > inline bool TriangleC3:: has_on(const typename TriangleC3::Point_3 &p) const { return R().has_on_3_object() (static_cast(*this), p); } template < class R > bool TriangleC3::is_degenerate() const { return collinear(vertex(0),vertex(1),vertex(2)); } #ifndef CGAL_NO_OSTREAM_INSERT_TRIANGLEC3 template < class R > std::ostream & operator<<(std::ostream &os, const TriangleC3 &t) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << t[0] << ' ' << t[1] << ' ' << t[2]; case IO::BINARY : return os << t[0] << t[1] << t[2]; default: os << "TriangleC3(" << t[0] << ", " << t[1] << ", " << t[2] <<")"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_TRIANGLEC3 #ifndef CGAL_NO_ISTREAM_EXTRACT_TRIANGLEC3 template < class R > std::istream & operator>>(std::istream &is, TriangleC3 &t) { typename R::Point_3 p, q, r; is >> p >> q >> r; if (is) t = TriangleC3(p, q, r); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_TRIANGLEC3 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_TRIANGLE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Ray_2.h0000644000175000017500000001455611344301501030072 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Ray_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_RAY_2_H #define CGAL_CARTESIAN_RAY_2_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class RayC2 { typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; typename R::Construct_translated_point_2 Construct_translated_point; RayC2() {} RayC2(const Point_2 &sp, const Point_2 &secondp) : base(sp, secondp) {} RayC2(const Point_2 &sp, const Direction_2 &d) : base(sp, Construct_translated_point( sp, d.to_vector())){} RayC2(const Point_2 &sp, const Vector_2 &v) : base(sp, Construct_translated_point(sp, v)){} RayC2(const Point_2 &sp, const Line_2 &l) : base(sp, Construct_translated_point(sp, l.to_vector())){} bool operator==(const RayC2 &r) const; bool operator!=(const RayC2 &r) const; const Point_2 & start() const; const Point_2 & source() const { return get(base).e0; } Point_2 point(int i) const; const Point_2 & second_point() const { return get(base).e1; } Direction_2 direction() const; Vector_2 to_vector() const; Line_2 supporting_line() const; Ray_2 opposite() const; Ray_2 transform(const Aff_transformation_2 &t) const { return RayC2(t.transform(source()), t.transform(second_point())); } bool is_horizontal() const; bool is_vertical() const; bool is_degenerate() const; bool has_on(const Point_2 &p) const; bool collinear_has_on(const Point_2 &p) const; }; template < class R > CGAL_KERNEL_INLINE bool RayC2::operator==(const RayC2 &r) const { if (CGAL::identical(base, r.base)) return true; return source() == r.source() && direction() == r.direction(); } template < class R > inline bool RayC2::operator!=(const RayC2 &r) const { return !(*this == r); } template < class R > inline const typename RayC2::Point_2 & RayC2::start() const { return source(); } template < class R > CGAL_KERNEL_INLINE typename RayC2::Point_2 RayC2::point(int i) const { CGAL_kernel_precondition( i >= 0 ); typename R::Construct_vector_2 construct_vector; typename R::Construct_scaled_vector_2 construct_scaled_vector; typename R::Construct_translated_point_2 construct_translated_point; if (i == 0) return source(); if (i == 1) return second_point(); return construct_translated_point(source(), construct_scaled_vector(construct_vector(source(), second_point()), FT(i))); } template < class R > inline typename RayC2::Vector_2 RayC2::to_vector() const { typename R::Construct_vector_2 construct_vector; return construct_vector(source(), second_point()); } template < class R > inline typename RayC2::Direction_2 RayC2::direction() const { typename R::Construct_vector_2 construct_vector; return Direction_2( construct_vector(source(), second_point()) ); } template < class R > inline typename RayC2::Line_2 RayC2::supporting_line() const { return Line_2(*this); } template < class R > inline typename RayC2::Ray_2 RayC2::opposite() const { return RayC2( source(), - direction() ); } template < class R > CGAL_KERNEL_INLINE bool RayC2::is_horizontal() const { return R().equal_y_2_object()(source(), second_point()); } template < class R > CGAL_KERNEL_INLINE bool RayC2::is_vertical() const { return R().equal_x_2_object()(source(), second_point()); } template < class R > CGAL_KERNEL_INLINE bool RayC2::is_degenerate() const { return source() == second_point(); } template < class R > CGAL_KERNEL_INLINE bool RayC2::has_on(const typename RayC2::Point_2 &p) const { typename R::Construct_vector_2 construct_vector; return p == source() || R().collinear_2_object()(source(), p, second_point()) && Direction_2(construct_vector( source(), p)) == direction(); } template < class R > inline bool RayC2:: collinear_has_on(const typename RayC2::Point_2 &p) const { return R().collinear_has_on_2_object() (static_cast(*this), p); } #ifndef CGAL_NO_OSTREAM_INSERT_RAYC2 template < class R > std::ostream & operator<<(std::ostream &os, const RayC2 &r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r.source() << ' ' << r.direction(); case IO::BINARY : return os << r.source() << r.direction(); default: return os << "RayC2(" << r.source() << ", " << r.direction() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_RAYC2 #ifndef CGAL_NO_ISTREAM_EXTRACT_RAYC2 template < class R > std::istream & operator>>(std::istream &is, RayC2 &r) { typename R::Point_2 p; typename R::Direction_2 d; is >> p >> d; if (is) r = RayC2(p, d); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_RAYC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_RAY_2_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Translation_rep_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Translation_0000644000175000017500000001116011344301501031311 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Translation_rep_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_TRANSLATION_REP_3_H #define CGAL_CARTESIAN_TRANSLATION_REP_3_H CGAL_BEGIN_NAMESPACE template < class R > class Translation_repC3 : public Aff_transformation_rep_baseC3 { friend class Aff_transformation_repC3; friend class Scaling_repC3; public: typedef typename R::FT FT; typedef Aff_transformation_rep_baseC3 Transformation_base_3; typedef Aff_transformation_repC3 Transformation_3; typedef Translation_repC3 Translation_3; typedef Scaling_repC3 Scaling_3; typedef typename Transformation_base_3::Point_3 Point_3; typedef typename Transformation_base_3::Vector_3 Vector_3; typedef typename Transformation_base_3::Direction_3 Direction_3; typedef typename Transformation_base_3::Aff_transformation_3 Aff_transformation_3; Translation_repC3() {} Translation_repC3(const Vector_3 &tv) : translationvector_(tv) {} virtual ~Translation_repC3() {} virtual Point_3 transform(const Point_3 &p) const { return p + translationvector_; } virtual Vector_3 transform(const Vector_3 &v) const { return v; } virtual Direction_3 transform(const Direction_3 &d) const { return d; } virtual Aff_transformation_3 operator*(const Transformation_base_3 &t) const { return t.compose(*this); } virtual Aff_transformation_3 compose(const Transformation_3 &t) const { return Aff_transformation_3(t.t11, t.t12, t.t13, t.t11 * translationvector_.x() + t.t12 * translationvector_.y() + t.t13 * translationvector_.z() + t.t14, t.t21, t.t22, t.t23, t.t21 * translationvector_.x() + t.t22 * translationvector_.y() + t.t23 * translationvector_.z() + t.t24, t.t31, t.t32, t.t33, t.t31 * translationvector_.x() + t.t32 * translationvector_.y() + t.t33 * translationvector_.z() + t.t34); } virtual Aff_transformation_3 compose(const Translation_3 &t) const { return Aff_transformation_3(TRANSLATION, translationvector_ + t.translationvector_); } virtual Aff_transformation_3 compose(const Scaling_3 &t) const { FT ft0(0); return Aff_transformation_3(t.scalefactor_, ft0, ft0, t.scalefactor_ * translationvector_.x(), ft0, t.scalefactor_, ft0, t.scalefactor_ * translationvector_.y(), ft0, ft0, t.scalefactor_, t.scalefactor_ * translationvector_.z()); } virtual Aff_transformation_3 inverse() const { return Aff_transformation_3(TRANSLATION, - translationvector_); } virtual Aff_transformation_3 transpose() const { return Aff_transformation_3(TRANSLATION, translationvector_); } virtual bool is_even() const { return true; } virtual FT cartesian(int i, int j) const { if (j==i) return FT(1); if (j==3) return translationvector_[i]; return FT(0); } virtual std::ostream &print(std::ostream &os) const { os << "Aff_transformationC3(VectorC3("<< translationvector_.x() << "," << translationvector_.y() << "," << translationvector_.z() << "))\n"; return os; } private: Vector_3 translationvector_; }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_TRANSLATION_REP_3_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/line_constructions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/line_constru0000644000175000017500000000345611344301501031371 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/line_constructions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_LINE_CONSTRUCTIONS_2_H #define CGAL_CARTESIAN_LINE_CONSTRUCTIONS_2_H #include #include CGAL_BEGIN_NAMESPACE template < class K > inline LineC2 line_from_point_direction(const PointC2 &p, const DirectionC2 &d) { return K().construct_line_2_object()(p, d); } template < class K > inline LineC2 perpendicular_through_point(const LineC2 &l, const PointC2 &p) { typename K::FT a, b, c; perpendicular_through_pointC2(l.a(), l.b(), p.x(), p.y(), a, b, c); return LineC2(a, b, c); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_LINE_CONSTRUCTIONS_2_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/point_constructions_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/point_constr0000644000175000017500000000360211344301501031377 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/point_constructions_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_POINT_CONSTRUCTIONS_3_H #define CGAL_CARTESIAN_POINT_CONSTRUCTIONS_3_H #include #include CGAL_BEGIN_NAMESPACE template CGAL_KERNEL_LARGE_INLINE PointC3 point_on_plane(const PlaneC3 &p) { typename K::FT x, y, z; point_on_planeC3(p.a(), p.b(), p.c(), p.d(), x, y, z); return PointC3(x, y, z); } template CGAL_KERNEL_LARGE_INLINE PointC3 projection_plane(const PointC3 &p, const PlaneC3 &h) { typename K::FT x, y, z; projection_planeC3(h.a(), h.b(), h.c(), h.d(), p.x(), p.y(), p.z(), x, y, z); return PointC3(x, y, z); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_POINT_CONSTRUCTIONS_3_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/point_constructions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/point_constr0000644000175000017500000000340511344301501031400 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/point_constructions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CARTESIAN_POINT_CONSTRUCTIONS_2_H #define CGAL_CARTESIAN_POINT_CONSTRUCTIONS_2_H #include CGAL_BEGIN_NAMESPACE template < class K > inline typename K::Point_2 line_get_point(const LineC2 &l, int i) { typename K::FT x, y; line_get_pointC2(l.a(), l.b(), l.c(), i, x, y); return PointC2(x, y); } template < class K > inline typename K::Point_2 line_project_point(const LineC2 &l, const PointC2 &p) { typename K::FT x, y; line_project_pointC2(l.a(), l.b(), l.c(), p.x(), p.y(), x, y); return PointC2(x, y); } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_POINT_CONSTRUCTIONS_2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Cartesian_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Cartesian_ba0000644000175000017500000001206511344301501031234 0ustar debiandebian// Copyright (c) 2000-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Cartesian_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_CARTESIAN_BASE_H #define CGAL_CARTESIAN_BASE_H #define CGAL_REP_CLASS_DEFINED #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename K_, typename FT_> struct Cartesian_base { typedef K_ Kernel; typedef Cartesian_tag Rep_tag; typedef Cartesian_tag Kernel_tag; typedef CGAL::Object Object_2; typedef CGAL::Object Object_3; typedef PointC2 Point_2; typedef VectorC2 Vector_2; typedef DirectionC2 Direction_2; typedef SegmentC2 Segment_2; typedef LineC2 Line_2; typedef RayC2 Ray_2; typedef TriangleC2 Triangle_2; typedef CircleC2 Circle_2; typedef Iso_rectangleC2 Iso_rectangle_2; typedef Aff_transformationC2 Aff_transformation_2; typedef PointC3 Point_3; typedef VectorC3 Vector_3; typedef DirectionC3 Direction_3; typedef LineC3 Line_3; typedef PlaneC3 Plane_3; typedef RayC3 Ray_3; typedef SegmentC3 Segment_3; typedef TriangleC3 Triangle_3; typedef TetrahedronC3 Tetrahedron_3; typedef Iso_cuboidC3 Iso_cuboid_3; typedef SphereC3 Sphere_3; typedef Aff_transformationC3 Aff_transformation_3; typedef const FT_* Cartesian_const_iterator_2; typedef const FT_* Cartesian_const_iterator_3; // Undocumented stuff. typedef Data_accessorC2 Data_accessor_2; typedef ConicCPA2 Conic_2; // Functors types and access functions. #define CGAL_Kernel_pred(Y,Z) typedef CartesianKernelFunctors::Y Y; \ Y Z() const { return Y(); } #define CGAL_Kernel_cons(Y,Z) CGAL_Kernel_pred(Y,Z) #include }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_BASE_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Translation_rep_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Translation_0000644000175000017500000001132611344301501031315 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Translation_rep_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Herve Bronnimann #ifndef CGAL_CARTESIAN_TRANSLATION_REP_2_H #define CGAL_CARTESIAN_TRANSLATION_REP_2_H CGAL_BEGIN_NAMESPACE template < class R > class Translation_repC2 : public Aff_transformation_rep_baseC2 { friend class Aff_transformation_repC2; friend class Rotation_repC2; friend class Scaling_repC2; public: typedef typename R::FT FT; typedef Aff_transformation_rep_baseC2 Aff_t_base; typedef Aff_transformation_repC2 Transformation; typedef Translation_repC2 Translation; typedef Rotation_repC2 Rotation; typedef Scaling_repC2 Scaling; typedef typename Aff_t_base::Point_2 Point_2; typedef typename Aff_t_base::Vector_2 Vector_2; typedef typename Aff_t_base::Direction_2 Direction_2; typedef typename Aff_t_base::Aff_transformation_2 Aff_transformation_2; Translation_repC2() {} Translation_repC2(const Vector_2 &tv) : translationvector_(tv) {} Point_2 transform(const Point_2 &p) const { typename R::Construct_translated_point_2 translated_point; return translated_point(p, translationvector_); } Vector_2 transform(const Vector_2 &v) const { return v; } Direction_2 transform(const Direction_2 &d) const { return d; } Aff_transformation_2 operator*(const Aff_t_base &t) const { return t.compose(*this); } Aff_transformation_2 compose(const Translation &t) const { return Aff_transformation_2(TRANSLATION, translationvector_ + t.translationvector_); } Aff_transformation_2 compose(const Rotation &t) const { return Aff_transformation_2(t.cosinus_, -t.sinus_, t.cosinus_*translationvector_.x() - t.sinus_*translationvector_.y(), t.sinus_, t.cosinus_, t.sinus_*translationvector_.x() + t.cosinus_*translationvector_.y()); } Aff_transformation_2 compose(const Scaling &t) const { return Aff_transformation_2(t.scalefactor_, FT(0), t.scalefactor_*translationvector_.x(), FT(0), t.scalefactor_, t.scalefactor_*translationvector_.y()); } Aff_transformation_2 compose(const Transformation &t) const { return Aff_transformation_2(t.t11, t.t12, t.t11 * translationvector_.x() + t.t12 * translationvector_.y() + t.t13, t.t21, t.t22, t.t21 * translationvector_.x() + t.t22*translationvector_.y() + t.t23); } Aff_transformation_2 inverse() const { return Aff_transformation_2(TRANSLATION, - translationvector_); } bool is_even() const { return true; } FT cartesian(int i, int j) const { if (j==i) return FT(1); if (j==2) return translationvector_[i]; return FT(0); } std::ostream &print(std::ostream &os) const { os << "Aff_transformationC2(VectorC2(" << translationvector_.x() << ", " << translationvector_.y() << "))"; return os; } private: Vector_2 translationvector_; }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_TRANSLATION_REP_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transfor0000644000175000017500000001375111344301501031276 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian/Aff_transformation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Lutz Kettner #ifndef CGAL_CARTESIAN_AFF_TRANSFORMATION_2_H #define CGAL_CARTESIAN_AFF_TRANSFORMATION_2_H #include #include CGAL_BEGIN_NAMESPACE class Identity_transformation; template < class R > class Aff_transformation_rep_baseC2; template < class R > class Aff_transformation_repC2; template < class R > class Translation_repC2; template < class R > class Rotation_repC2; template < class R > class Scaling_repC2; CGAL_END_NAMESPACE #include #include #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class Aff_transformationC2 : public Handle_for_virtual< Aff_transformation_rep_baseC2 > { typedef typename R_::FT FT; typedef Aff_transformation_rep_baseC2 Aff_t_base; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; public: typedef R_ R; Aff_transformationC2() { initialize_with(Aff_transformation_repC2(FT(1), FT(0), FT(0), FT(1))); } Aff_transformationC2(const Identity_transformation) { initialize_with(Aff_transformation_repC2(FT(1), FT(0), FT(0), FT(1))); } Aff_transformationC2(const Translation, const Vector_2 &v) { initialize_with(Translation_repC2(v)); } // Rational Rotation: Aff_transformationC2(const Rotation, const Direction_2 &d, const FT &num, const FT &den = FT(1)) { initialize_with(Rotation_repC2(d, num, den)); } Aff_transformationC2(const Rotation, const FT &sine, const FT &cosine, const FT &w = FT(1)) { if (w != FT(1)) initialize_with(Rotation_repC2(sine/w, cosine/w)); else initialize_with(Rotation_repC2(sine, cosine)); } Aff_transformationC2(const Scaling, const FT &s, const FT &w = FT(1)) { if (w != FT(1)) initialize_with(Scaling_repC2(s/w)); else initialize_with(Scaling_repC2(s)); } // The general case: // a 3x2 matrix for the operations combining rotation, scaling, translation Aff_transformationC2(const FT & m11, const FT & m12, const FT & m13, const FT & m21, const FT & m22, const FT & m23, const FT &w = FT(1)) { if (w != FT(1)) initialize_with(Aff_transformation_repC2(m11/w, m12/w, m13/w, m21/w, m22/w, m23/w)); else initialize_with(Aff_transformation_repC2(m11, m12, m13, m21, m22, m23)); } Aff_transformationC2(const FT & m11, const FT & m12, const FT & m21, const FT & m22, const FT &w = FT(1)) { initialize_with(Aff_transformation_repC2(m11/w, m12/w, m21/w, m22/w)); } Point_2 transform(const Point_2 &p) const { return this->Ptr()->transform(p); } Point_2 operator()(const Point_2 &p) const { return transform(p); } Vector_2 transform(const Vector_2 &v) const { return this->Ptr()->transform(v); } Vector_2 operator()(const Vector_2 &v) const { return transform(v); } // FIXME : not compiled by the test-suite. Direction_2 transform(const Direction_2 &d) const { return this->Ptr()->transform(d); } Direction_2 operator()(const Direction_2 &d) const { return transform(d); } Line_2 transform(const Line_2 &l) const { return l.transform(*this); } Line_2 operator()(const Line_2 &l) const { return transform(l); } Aff_transformation_2 inverse() const { return this->Ptr()->inverse(); } bool is_even() const { return this->Ptr()->is_even(); } bool is_odd() const { return ! (this->Ptr()->is_even()); } FT cartesian(int i, int j) const { return this->Ptr()->cartesian(i,j); } FT homogeneous(int i, int j) const { return cartesian(i,j); } FT m(int i, int j) const { return cartesian(i,j); } FT hm(int i, int j) const { return cartesian(i,j); } Aff_transformation_2 operator*(const Aff_transformationC2 &t) const { return (*(this->Ptr())) * (*t.Ptr()); } std::ostream & print(std::ostream &os) const; }; template < class R > std::ostream& Aff_transformationC2::print(std::ostream &os) const { this->Ptr()->print(os); return os; } #ifndef CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATIONC2 template < class R > std::ostream& operator<<(std::ostream& os, const Aff_transformationC2& t) { t.print(os); return os; } #endif // CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATIONC2 CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_AFF_TRANSFORMATION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_akl_toussaint.C0000644000175000017500000001166311344301500030465 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_akl_toussaint.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_AKL_TOUSSAINT_C #define CGAL_CH_AKL_TOUSSAINT_C #ifndef CGAL_CH_AKL_TOUSSAINT_H #include #endif // CGAL_CH_AKL_TOUSSAINT_H #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template OutputIterator ch_akl_toussaint(ForwardIterator first, ForwardIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_of_line; // added typedef typename Traits::Equal_2 Equal_2; Left_of_line left_turn = ch_traits.left_turn_2_object(); Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; ForwardIterator n, s, e, w; ch_nswe_point( first, last, n, s, w, e, ch_traits); if (equal_points(*n, *s) ) { *result = *w; ++result; return result; } std::vector< Point_2 > region1; std::vector< Point_2 > region2; std::vector< Point_2 > region3; std::vector< Point_2 > region4; region1.reserve(16); region2.reserve(16); region3.reserve(16); region4.reserve(16); region1.push_back( *w); region2.push_back( *s); region3.push_back( *e); region4.push_back( *n); CGAL_ch_postcondition_code( ForwardIterator save_first = first; ) for ( ; first != last; ++first ) { if ( left_turn(*e, *w, *first ) ) { if ( left_turn( *s, *w, *first ) ) region1.push_back( *first ); else if ( left_turn( *e, *s, *first ) ) region2.push_back( *first ); } else { if ( left_turn( *n, *e, *first ) ) region3.push_back( *first ); else if ( left_turn( *w, *n, *first ) ) region4.push_back( *first ); } } #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... std::sort( successor(region1.begin() ), region1.end(), ch_traits.less_xy_2_object() ); std::sort( successor(region2.begin() ), region2.end(), ch_traits.less_xy_2_object() ); std::sort( successor(region3.begin() ), region3.end(), swap_1(ch_traits.less_xy_2_object()) ); std::sort( successor(region4.begin() ), region4.end(), swap_1(ch_traits.less_xy_2_object()) ); if (! equal_points(*w,*s) ) { region1.push_back( *s ); ch__ref_graham_andrew_scan( region1.begin(), region1.end(), res, ch_traits); } if (! equal_points(*s,*e) ) { region2.push_back( *e ); ch__ref_graham_andrew_scan( region2.begin(), region2.end(), res, ch_traits); } if (! equal_points(*e,*n) ) { region3.push_back( *n ); ch__ref_graham_andrew_scan( region3.begin(), region3.end(), res, ch_traits); } if (! equal_points(*n,*w) ) { region4.push_back( *w ); ch__ref_graham_andrew_scan( region4.begin(), region4.end(), res, ch_traits); } CGAL_ch_postcondition_code( first = save_first; ) CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( res.output_so_far_begin(), \ res.output_so_far_end(), \ ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( \ first, last, \ res.output_so_far_begin(), res.output_so_far_end(), \ ch_traits) ); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } CGAL_END_NAMESPACE #endif // CGAL_CH_AKL_TOUSSAINT_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2.h0000644000175000017500000004657011344301500027055 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman // Wieger Wesselink #ifndef CGAL_POLYGON_2_H #define CGAL_POLYGON_2_H #include #ifdef CGAL_CFG_NO_MEMBER_TEMPLATES #include #include #endif #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif // CGAL_REP_CLASS_DEFINED #include #include #include #include CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Polygon_2 //-----------------------------------------------------------------------// #if defined(CGAL_POLYGON_2_CACHED) && !defined(CGAL_POLYGON_2_MOD_ITER) template inline typename std::iterator_traits::pointer address(It it) { return it.operator->(); } template inline Struct* address(Struct *p) { return p; } template inline Struct const* address(Struct const*p) { return p; } template struct Polygon_vertex_iterator_2 { typedef typename std::iterator_traits::value_type value_type; typedef typename std::iterator_traits::iterator_category iterator_category; typedef typename std::iterator_traits::difference_type difference_type; typedef value_type const * pointer; typedef value_type const & reference; // more typedefs Polygon_vertex_iterator_2() {} Polygon_vertex_iterator_2(It it) : m_it(it) {} Polygon_vertex_iterator_2 & operator=(Polygon_vertex_iterator_2 const & it) { m_it = it.m_it; return *this;} Polygon_vertex_iterator_2 operator=(It const & it) { m_it = it; return *this;} bool operator==(Polygon_vertex_iterator_2 const &o) const { return m_it == o.m_it; } bool operator!=(Polygon_vertex_iterator_2 const &o) const { return m_it != o.m_it; } reference operator*() const {return *m_it;} pointer operator->() const { return address(m_it);} Polygon_vertex_iterator_2 & operator++() { ++m_it; return *this;} Polygon_vertex_iterator_2 operator++(int) { Polygon_vertex_iterator_2 result = *this; ++m_it; return result;} // Bidirectional Iterator methods Polygon_vertex_iterator_2 & operator--() { --m_it; return *this;} Polygon_vertex_iterator_2 operator--(int) { Polygon_vertex_iterator_2 result = *this; --m_it; return result;} // Random Access Iterator methods Polygon_vertex_iterator_2 & operator+=(difference_type n) { m_it += n; return *this;} Polygon_vertex_iterator_2 & operator-=(difference_type n) { m_it -= n; return *this;} difference_type operator-(Polygon_vertex_iterator_2 o) { return m_it - o.m_it;} bool operator<(Polygon_vertex_iterator_2 o) { return m_it < o.m_it;} reference operator[](difference_type n) { return m_it[n];} // Access to internals It implementation_it() const {return m_it;} // should be private and friend of Polygon_2 private: It m_it; }; template inline Polygon_vertex_iterator_2 operator+(Polygon_vertex_iterator_2 it, typename Polygon_vertex_iterator_2::difference_type n) { Polygon_vertex_iterator_2 tmp = it; return tmp += n; } template inline Polygon_vertex_iterator_2 operator+(typename Polygon_vertex_iterator_2::difference_type n, Polygon_vertex_iterator_2 it) { Polygon_vertex_iterator_2 tmp = it; return tmp += n; } template inline Polygon_vertex_iterator_2 operator-(Polygon_vertex_iterator_2 it, typename Polygon_vertex_iterator_2::difference_type n) { Polygon_vertex_iterator_2 tmp = it; return tmp -= n; } template inline typename Polygon_vertex_iterator_2::difference_type operator-(Polygon_vertex_iterator_2 it1, Polygon_vertex_iterator_2 it2) { return it1.implementation_it() - it2.implementation_it(); } #endif // defined(...CACHED) template > class Polygon_2 { public: //-------------------------------------------------------- // Types //-------------------------------------------------------- typedef Traits_P Traits; typedef Container_P Container; typedef typename Traits_P::FT FT; typedef typename Traits_P::Point_2 Point_2; typedef typename Traits_P::Segment_2 Segment_2; typedef typename Container_P::difference_type difference_type; typedef typename Container_P::value_type value_type; typedef typename Container_P::pointer pointer; typedef typename Container_P::reference reference; typedef typename Container_P::const_reference const_reference; //-------------------------------------------------------// // this intermediary step is required by Sun C++ 4.1 typedef typename Container_P::iterator iterator; typedef typename Container_P::const_iterator const_iterator; //-------------------------------------------------------// #if defined(CGAL_POLYGON_2_CACHED) && !defined(CGAL_POLYGON_2_MOD_ITER) typedef Polygon_vertex_iterator_2 Vertex_iterator; typename Container::iterator get_container_iterator(Vertex_iterator vit) {return vit.implementation_it();} #else // defined(...CACHED) typedef typename Container::iterator Vertex_iterator; typename Container::iterator get_container_iterator(Vertex_iterator vit) {return vit;} #endif // defined(...CACHED) typedef Vertex_iterator Vertex_const_iterator; typedef Polygon_circulator Vertex_const_circulator; typedef Vertex_const_circulator Vertex_circulator; typedef Polygon_2_edge_iterator Edge_const_iterator; typedef Polygon_2_const_edge_circulator Edge_const_circulator; //-------------------------------------------------------- // Creation //-------------------------------------------------------- Polygon_2(Traits p_traits = Traits()) : traits(p_traits), m_flags(CF_EMPTY) { } Polygon_2(const Polygon_2& polygon) : d_container(polygon.d_container), traits(polygon.traits), m_flags(CF_EMPTY) { } Polygon_2& operator=(const Polygon_2& polygon) { if (this != &polygon) { d_container = polygon.d_container; invalidate_cache(); } return *this; } ~Polygon_2() { } template Polygon_2(InputIterator first, InputIterator last, Traits p_traits = Traits()) : d_container(), traits(p_traits), m_flags(CF_EMPTY) { // Sun STL switches off member templates for binary backward compatibility std::copy(first, last, std::back_inserter(d_container)); } //-------------------------------------------------------- // Operations //-------------------------------------------------------- void set(Vertex_iterator pos, const Point_2& x) { invalidate_cache(); *get_container_iterator(pos) = x; } #if defined(CGAL_POLYGON_2_CACHED) && !defined(CGAL_POLYGON_2_MOD_ITER) void set(Polygon_circulatorconst &pos, const Point_2& x) { invalidate_cache(); *pos.mod_iterator() = x; } #endif Vertex_iterator insert(Vertex_iterator pos, const Point_2& x) { invalidate_cache(); return d_container.insert(get_container_iterator(pos),x); } #if defined(CGAL_POLYGON_2_CACHED) && !defined(CGAL_POLYGON_2_MOD_ITER) Vertex_iterator insert(Vertex_circulator pos, const Point_2& x) { invalidate_cache(); return d_container.insert(pos.mod_iterator(),x); } #endif #ifndef CGAL_CFG_NO_MEMBER_TEMPLATES template void insert(Vertex_iterator pos, InputIterator first, InputIterator last) { d_container.insert(get_container_iterator(pos), first, last); } # if defined(CGAL_POLYGON_2_CACHED) && !defined(CGAL_POLYGON_2_MOD_ITER) template void insert(Vertex_circulator pos, InputIterator first, InputIterator last) { d_container.insert(pos.mod_iterator(), first, last); } # endif #endif void push_back(const Point_2& x) { invalidate_cache(); d_container.insert(d_container.end(), x); } void erase(Vertex_iterator pos) { invalidate_cache(); d_container.erase(get_container_iterator(pos)); } #if defined(CGAL_POLYGON_2_CACHED) && !defined(CGAL_POLYGON_2_MOD_ITER) void erase(Vertex_circulator pos) { invalidate_cache(); d_container.erase(pos.mod_iterator()); } #endif void erase(Vertex_iterator first, Vertex_iterator last) { invalidate_cache(); d_container.erase(get_container_iterator(first), get_container_iterator(last)); } void reverse_orientation() { if (size() <= 1) return; invalidate_cache(); typename Container_P::iterator i = d_container.begin(); std::reverse(++i, d_container.end()); } //-------------------------------------------------------- // Traversal of a polygon //-------------------------------------------------------- // Vertex_iterator vertices_begin() // { return d_container.begin(); } // Vertex_iterator vertices_end() // { return d_container.end(); } Vertex_const_iterator vertices_begin() const { return const_cast(*this).d_container.begin(); } Vertex_const_iterator vertices_end() const { return const_cast(*this).d_container.end(); } // Vertex_const_circulator vertices_circulator() const // { return Vertex_const_circulator(&d_container, d_container.begin()); } Vertex_const_circulator vertices_circulator() const { Polygon_2& self = const_cast(*this); return Vertex_const_circulator(&self.d_container, self.d_container.begin()); } Edge_const_iterator edges_begin() const { return Edge_const_iterator(&d_container, d_container.begin()); } Edge_const_iterator edges_end() const { return Edge_const_iterator(&d_container, d_container.end()); } Edge_const_circulator edges_circulator() const { return Edge_const_circulator(vertices_circulator()); } //-------------------------------------------------------- // Predicates //-------------------------------------------------------- bool is_simple() const { if (!is_cached(CF_SIMPLE)) { m_simple = is_simple_2(d_container.begin(),d_container.end(), traits); mark_cached(CF_SIMPLE); } return m_simple; } bool is_convex() const { if (!is_cached(CF_CONVEX)) { m_convex = is_convex_2(d_container.begin(),d_container.end(), traits); mark_cached(CF_CONVEX); } return m_convex; } Orientation orientation() const { if (!is_cached(CF_ORIENTATION)) { m_orientation = orientation_2(d_container.begin(), d_container.end(), traits); mark_cached(CF_ORIENTATION); } return m_orientation; } Oriented_side oriented_side(const Point_2& value) const { return oriented_side_2(d_container.begin(), d_container.end(), value, traits); } Bounded_side bounded_side(const Point_2& value) const { CGAL_polygon_precondition(is_simple()); return bounded_side_2(d_container.begin(), d_container.end(), value, traits); } Bbox_2 bbox() const { if (!is_cached(CF_BBOX)) { m_bbox = bbox_2(d_container.begin(), d_container.end()); mark_cached(CF_BBOX); } return m_bbox; } FT area() const { if (!is_cached(CF_AREA)) { area_2(d_container.begin(), d_container.end(), m_area, traits); mark_cached(CF_AREA); } return m_area; } Vertex_const_iterator left_vertex() const { if (!is_cached(CF_LEFT)) { Polygon_2 &self = const_cast(*this); m_left = left_vertex_2(self.d_container.begin(), self.d_container.end(), traits); mark_cached(CF_LEFT); } return m_left; } //Vertex_iterator left_vertex() //{ //return left_vertex_2(d_container.begin(), d_container.end(), traits); //} Vertex_const_iterator right_vertex() const { if (!is_cached(CF_RIGHT)) { Polygon_2 &self = const_cast(*this); m_right = right_vertex_2(self.d_container.begin(), self.d_container.end(), traits); mark_cached(CF_RIGHT); } return m_right; } // Vertex_iterator right_vertex() // { // return right_vertex_2(d_container.begin(), d_container.end(), traits); // } Vertex_const_iterator top_vertex() const { if (!is_cached(CF_TOP)) { Polygon_2 &self = const_cast(*this); m_top = top_vertex_2(self.d_container.begin(), self.d_container.end(), traits); mark_cached(CF_TOP); } return m_top; } // Vertex_iterator top_vertex() // { // return top_vertex_2(d_container.begin(), d_container.end(), traits); // } Vertex_const_iterator bottom_vertex() const { if (!is_cached(CF_BOTTOM)) { Polygon_2 &self = const_cast(*this); m_bottom = bottom_vertex_2(self.d_container.begin(), self.d_container.end(), traits); mark_cached(CF_BOTTOM); } return m_bottom; } // Vertex_iterator bottom_vertex() // { // return bottom_vertex_2(d_container.begin(), d_container.end(), traits); // } bool is_counterclockwise_oriented() const { return orientation() == COUNTERCLOCKWISE; } bool is_clockwise_oriented() const { return orientation() == CLOCKWISE; } bool is_collinear_oriented() const { return orientation() == COLLINEAR; } bool has_on_positive_side(const Point_2& q) const { return oriented_side(q) == ON_POSITIVE_SIDE; } bool has_on_negative_side(const Point_2& q) const { return oriented_side(q) == ON_NEGATIVE_SIDE; } bool has_on_boundary(const Point_2& q) const { return bounded_side(q) == ON_BOUNDARY; } bool has_on_bounded_side(const Point_2& q) const { return bounded_side(q) == ON_BOUNDED_SIDE; } bool has_on_unbounded_side(const Point_2& q) const { return bounded_side(q) == ON_UNBOUNDED_SIDE; } //-------------------------------------------------------- // Random access methods //-------------------------------------------------------- #ifndef CGAL_CFG_NO_LAZY_INSTANTIATION const Point_2& vertex(int i) const { return *(d_container.begin() + i); } // Point_2& vertex(int i) // { return *(d_container.begin() + i); } const Point_2& operator[](int i) const { return vertex(i); } // Point_2& operator[](int i) // { return vertex(i); } Segment_2 edge(int i) const { return *(edges_begin() + i); } #endif //-------------------------------------------------------- // Miscellaneous //-------------------------------------------------------- int size() const { return d_container.size(); } bool is_empty() const { return d_container.empty(); } const Container_P& container() const { return d_container; } bool identical(const Polygon_2 &q) const { return this == &q; } Traits_P const &traits_member() const { return traits;} private: enum Cache_flags {CF_EMPTY=0, CF_SIMPLE=1<<0, CF_CONVEX=1<<1, CF_ORIENTATION=1<<2, CF_BBOX=1<<3, CF_AREA=1<<4, CF_LEFT=1<<5, CF_RIGHT=1<<6, CF_BOTTOM=1<<7, CF_TOP=1<<8}; Container_P d_container; Traits_P traits; // cache mutable Cache_flags m_flags; mutable Bbox_2 m_bbox; mutable FT m_area; mutable Vertex_iterator m_left, m_right, m_bottom, m_top; mutable bool m_simple :1; mutable bool m_convex:1; mutable Orientation m_orientation:2; void invalidate_cache() { m_flags = CF_EMPTY;} bool is_cached(Cache_flags f) const { return m_flags & f;} #if defined(CGAL_POLYGON_2_CACHED) void mark_cached(Cache_flags f) const { m_flags = Cache_flags((m_flags & ~f) | f); } #else void mark_cached(Cache_flags ) const {} #endif }; //-----------------------------------------------------------------------// // Globally defined operators //-----------------------------------------------------------------------// template bool operator==( const Polygon_2 &x, const Polygon_2 &y ); template inline bool operator!=(const Polygon_2 &x, const Polygon_2 &y); #ifdef CGAL_REP_CLASS_DEFINED template Polygon_2 transform(const Transformation& t, const Polygon_2& p); #endif // CGAL_REP_CLASS_DEFINED //-----------------------------------------------------------------------// // I/O //-----------------------------------------------------------------------// template std::istream &operator>>(std::istream &is, Polygon_2& p); template std::ostream &operator<<(std::ostream &os, const Polygon_2& p); //-----------------------------------------------------------------------// // implementation //-----------------------------------------------------------------------// CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif CGAL_BEGIN_NAMESPACE template inline bool operator!=(const Polygon_2 &x, const Polygon_2 &y) { return !(x==y); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions_d.h0000644000175000017500000000601311344301500030411 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/constructions_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_CONSTRUCTIONS_D_H #define CGAL_CONSTRUCTIONS_D_H CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=constructions_d.man}*/ /*{\Mtext \setopdims{4cm}{2cm}\computewidths \headerline{Constructions}}*/ template Point_d lift_to_paraboloid(const Point_d& p) /*{\Mfunc returns $p = (x_0,\ldots,x_{d-1})$ lifted to the paraboloid of revolution . }*/ { typename R::Lift_to_paraboloid_d lift; return lift(p); } template Point_d project_along_d_axis(const Point_d& p) /*{\Mfunc returns |p| projected along the $d$-axis onto the hyperspace spanned by the first $d-1$ standard base vectors.}*/ { typename R::Project_along_d_axis_d proj; return proj(p); } template Point_d midpoint(const Point_d& p, const Point_d& q) /*{\Mfunc returns the midpoint of |p| and |q|. }*/ { typename R::Midpoint_d mp; return mp(p,q); } template Point_d center_of_sphere(Forward_iterator start, Forward_iterator end) { typename R::Center_of_sphereHd center; return center(start,end); } template typename R::FT squared_distance(const Point_d& p, const Point_d& q) /*{\Mfunc returns the squared distance between |p| and $q$. }*/ { typename R::Squared_distance_d dist; return dist(p,q); } template OutputIterator linear_base( ForwardIterator first, ForwardIterator last, OutputIterator result) /*{\Mfunc computes a basis of the linear space spanned by the vectors in |set [first,last)| and returns it via an iterator range starting in |result|. The returned iterator marks the end of the output. \precond value type of |ForwardIterator| and |OutputIterator| is |Vector_d|.}*/ { typedef typename std::iterator_traits:: value_type value_type; typedef typename value_type::R R; typename R::Linear_base_d base; return base(first,last,result); } CGAL_END_NAMESPACE #endif // CGAL_CONSTRUCTIONS_D_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_adapterH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_adapterH0000644000175000017500000002752711344301500031251 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2_adapterH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_ELLIPSE_2_ADAPTERH2_H #define CGAL_MIN_ELLIPSE_2_ADAPTERH2_H // includes #ifndef CGAL_CONICHPA2_H # include #endif #ifndef CGAL_OPTIMISATION_ASSERTIONS_H # include #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_ellipse_2; template < class PT_, class DA_ > class Min_ellipse_2_adapterH2; template < class PT_, class DA_ > class _Min_ellipse_2_adapterH2__Ellipse; // Class interface and implementation // ================================== template < class PT, class DA > bool are_ordered_along_lineH2( const PT& p, const PT& q, const PT& r, const DA& da) { typedef typename DA::RT RT; RT phx; RT phy; RT phw; RT qhx; RT qhy; RT qhw; RT rhx; RT rhy; RT rhw; da.get( p, phx, phy, phw); da.get( q, qhx, qhy, qhw); da.get( r, rhx, rhy, rhw); // p,q,r collinear? if ( ! CGAL_NTS is_zero( ( phx*rhw - rhx*phw) * ( qhy*rhw - rhy*qhw) - ( phy*rhw - rhy*phw) * ( qhx*rhw - rhx*qhw))) return( false); // p,q,r vertical? if ( phx*rhw != rhx*phw) return( ( ( phx*qhw < qhx*phw) && ( qhx*rhw < rhx*qhw)) || ( ( rhx*qhw < qhx*rhw) && ( qhx*phw < phx*qhw))); else return( ( ( phy*qhw < qhy*phw) && ( qhy*rhw < rhy*qhw)) || ( ( rhy*qhw < qhy*rhw) && ( qhy*phw < phy*qhw))); // keeps g++ happy return false; } template < class PT_, class DA_ > class Min_ellipse_2_adapterH2 { public: // types typedef PT_ PT; typedef DA_ DA; // nested types typedef PT Point; typedef _Min_ellipse_2_adapterH2__Ellipse Ellipse; private: DA dao; // data accessor object Ellipse ellipse; // current ellipse friend class Min_ellipse_2< Min_ellipse_2_adapterH2 >; public: // creation Min_ellipse_2_adapterH2( const DA& da = DA()) : dao( da), ellipse( da) { } // operations CGAL::Orientation orientation( const Point& p, const Point& q, const Point& r) const { typedef typename DA_::RT RT; RT phx; RT phy; RT phw; RT qhx; RT qhy; RT qhw; RT rhx; RT rhy; RT rhw; dao.get( p, phx, phy, phw); dao.get( q, qhx, qhy, qhw); dao.get( r, rhx, rhy, rhw); return( static_cast< CGAL::Orientation>( CGAL_NTS sign( ( phx*rhw - rhx*phw) * ( qhy*rhw - rhy*qhw) - ( phy*rhw - rhy*phw) * ( qhx*rhw - rhx*qhw)))); } }; // Nested type `Ellipse' template < class PT_, class DA_ > std::ostream& operator << ( std::ostream&, const CGAL::_Min_ellipse_2_adapterH2__Ellipse&); template < class PT_, class DA_ > std::istream& operator >> ( std::istream&, CGAL::_Min_ellipse_2_adapterH2__Ellipse&); template < class PT_, class DA_ > class _Min_ellipse_2_adapterH2__Ellipse { public: // typedefs typedef PT_ PT; typedef DA_ DA; typedef CGAL::ConicHPA2< PT, DA> CT; typedef typename DA_::RT RT; private: // data members int n_boundary_points; // number of boundary points PT boundary_point1, boundary_point2; // two boundary points CT conic1, conic2; // two conics RT dr, ds, dt, du, dv, dw; // the gradient vector friend std::ostream& operator << <> ( std::ostream&, const _Min_ellipse_2_adapterH2__Ellipse&); friend std::istream& operator >> <> ( std::istream&, _Min_ellipse_2_adapterH2__Ellipse&); public: // types typedef PT Point; // creation _Min_ellipse_2_adapterH2__Ellipse( const DA& da) : conic1( da), conic2( da) { } void set( ) { n_boundary_points = 0; } void set( const Point& p) { n_boundary_points = 1; boundary_point1 = p; } void set( const Point& p, const Point& q) { n_boundary_points = 2; boundary_point1 = p; boundary_point2 = q; } void set( const Point& p1, const Point& p2, const Point& p3) { n_boundary_points = 3; conic1.set_ellipse( p1, p2, p3); } void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4) { n_boundary_points = 4; CT::set_two_linepairs( p1, p2, p3, p4, conic1, conic2); dr = RT( 0); ds = conic1.r() * conic2.s() - conic2.r() * conic1.s(), dt = conic1.r() * conic2.t() - conic2.r() * conic1.t(), du = conic1.r() * conic2.u() - conic2.r() * conic1.u(), dv = conic1.r() * conic2.v() - conic2.r() * conic1.v(), dw = conic1.r() * conic2.w() - conic2.r() * conic1.w(); } void set( const Point&, const Point&, const Point&, const Point&, const Point& p5) { n_boundary_points = 5; conic1.set( conic1, conic2, p5); conic1.analyse(); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const { switch ( n_boundary_points) { case 0: return( CGAL::ON_UNBOUNDED_SIDE); case 1: return( ( p == boundary_point1) ? CGAL::ON_BOUNDARY : CGAL::ON_UNBOUNDED_SIDE); case 2: return( ( p == boundary_point1) || ( p == boundary_point2) || ( CGAL::are_ordered_along_lineH2( boundary_point1, p, boundary_point2, conic1.da())) ? CGAL::ON_BOUNDARY : CGAL::ON_UNBOUNDED_SIDE); case 3: case 5: return( conic1.convex_side( p)); case 4: { CT c( conic1.da()); c.set( conic1, conic2, p); c.analyse(); if ( ! c.is_ellipse()) { c.set_ellipse( conic1, conic2); c.analyse(); return( c.convex_side( p)); } else { int tau_star = c.vol_derivative( dr, ds, dt, du, dv, dw); return( CGAL::Bounded_side( CGAL_NTS sign( tau_star))); } } default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); } // keeps g++ happy return( CGAL::Bounded_side( 0)); } bool has_on_bounded_side( const Point& p) const { return( bounded_side( p) == CGAL::ON_BOUNDED_SIDE); } bool has_on_boundary( const Point& p) const { return( bounded_side( p) == CGAL::ON_BOUNDARY); } bool has_on_unbounded_side( const Point& p) const { return( bounded_side( p) == CGAL::ON_UNBOUNDED_SIDE); } bool is_empty( ) const { return( n_boundary_points == 0); } bool is_degenerate( ) const { return( n_boundary_points < 3); } // additional operations for checking bool operator == ( const CGAL::_Min_ellipse_2_adapterH2__Ellipse& e) const { if ( n_boundary_points != e.n_boundary_points) return( false); switch ( n_boundary_points) { case 0: return( true); case 1: return( boundary_point1 == e.boundary_point1); case 2: return( ( ( boundary_point1 == e.boundary_point1) && ( boundary_point2 == e.boundary_point2)) || ( ( boundary_point1 == e.boundary_point2) && ( boundary_point2 == e.boundary_point1))); case 3: case 5: return( conic1 == e.conic1); case 4: return( ( ( conic1 == e.conic1) && ( conic2 == e.conic2)) || ( ( conic1 == e.conic2) && ( conic2 == e.conic1))); default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5)); } // keeps g++ happy return( false); } bool operator != ( const CGAL::_Min_ellipse_2_adapterH2__Ellipse& e) const { return( ! ( *this == e)); } }; // I/O template < class PT_, class DA_ > std::ostream& operator << ( std::ostream& os, const CGAL::_Min_ellipse_2_adapterH2__Ellipse& e) { const char* const empty = ""; const char* const pretty_head = "CGAL::Min_ellipse_2_adapterH2::Ellipse( "; const char* const pretty_sep = ", "; const char* const pretty_tail = ")"; const char* const ascii_sep = " "; const char* head = empty; const char* sep = empty; const char* tail = empty; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: head = pretty_head; sep = pretty_sep; tail = pretty_tail; break; case CGAL::IO::ASCII: sep = ascii_sep; break; case CGAL::IO::BINARY: break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } os << head << e.n_boundary_points; switch ( e.n_boundary_points) { case 0: break; case 1: os << sep << e.boundary_point1; break; case 2: os << sep << e.boundary_point1 << sep << e.boundary_point2; break; case 3: case 5: os << sep << e.conic1; break; case 4: os << sep << e.conic1 << sep << e.conic2; break; } os << tail; return( os); } template < class PT_, class DA_ > std::istream& operator >> ( std::istream& is, CGAL::_Min_ellipse_2_adapterH2__Ellipse& e) { switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: CGAL::read( is, e.n_boundary_points); switch ( e.n_boundary_points) { case 0: break; case 1: is >> e.boundary_point1; break; case 2: is >> e.boundary_point1 >> e.boundary_point2; break; case 3: case 5: is >> e.conic1; break; case 4: is >> e.conic1 >> e.conic2; break; } break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE #endif // CGAL_MIN_ELLIPSE_2_ADAPTERH2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_points_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_points_30000644000175000017500000000242011344301500031376 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_points_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_PREDICATES_ON_POINTS_3_H #define CGAL_PREDICATES_ON_POINTS_3_H // Kept for backward compatibility only. #endif // CGAL_PREDICATES_ON_POINTS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Splitters.h0000644000175000017500000001723711344301501027175 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Splitters.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Hans Tangelder () // Defines rules used for constructing a split node. That is, it implements, // in several ways, the concept // Boxtree_splitter. #ifndef CGAL_SPLITTERS_H #define CGAL_SPLITTERS_H #include #include namespace CGAL { template class Splitter_base { private: unsigned int the_bucket_size; FT the_aspect_ratio; public: Splitter_base(unsigned int bucket_size = 3, FT aspect_ratio = FT(3)) : the_bucket_size(bucket_size), the_aspect_ratio(aspect_ratio) {} FT aspect_ratio() const { return the_aspect_ratio; } unsigned int bucket_size() const { return the_bucket_size; } }; template > class Median_of_max_spread : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Median_of_max_spread() : Base() {} Median_of_max_spread(unsigned int bucket_size) : Base(bucket_size) {} void operator() (Separator& sep, Container& c0, Container& c1) { sep=Separator(c0.max_tight_span_coord(),FT(0)); sep.set_cutting_value(c0.median(sep.cutting_dimension())); c0.split(c1,sep,true); } }; template > class Fair : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Fair() : Base() {} Fair(unsigned int bucket_size, FT aspect_ratio=FT(3)) : Base(bucket_size, aspect_ratio) {} void operator()(Separator& sep, Container& c0, Container& c1) { // find legal cut with max spread sep=Separator(c0.max_tight_span_coord_balanced(this->aspect_ratio()), FT(0)); sep.set_cutting_value(c0.balanced_fair(sep.cutting_dimension(), this->aspect_ratio())); c0.split(c1,sep); } }; template > class Sliding_fair : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Sliding_fair() : Base() {} Sliding_fair(unsigned int bucket_size, FT aspect_ratio=FT(3)) : Base(bucket_size, aspect_ratio) {} void operator() (Separator& sep, Container& c0, Container& c1) { // find legal cut with max spread sep = Separator(c0.max_tight_span_coord_balanced(this->aspect_ratio()), FT(0)); sep.set_cutting_value(c0.balanced_sliding_fair(sep.cutting_dimension(), this->aspect_ratio())); c0.split(c1,sep,true); } }; template > class Sliding_midpoint : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Sliding_midpoint() : Base() {} Sliding_midpoint(unsigned int bucket_size) : Base(bucket_size) {} void operator()(Separator& sep, Container& c0, Container& c1) { CGAL_assertion(c0.is_valid()); CGAL_assertion(c1.is_valid()); sep = Separator(c0.max_span_coord(), (c0.max_span_upper() + c0.max_span_lower())/FT(2)); FT max_span_lower = c0.tight_bounding_box().min_coord(c0.max_span_coord()); CGAL_assertion(max_span_lower >= c0.max_span_lower()); FT max_span_upper = c0.tight_bounding_box().max_coord(c0.max_span_coord()); CGAL_assertion(max_span_upper <= c0.max_span_upper()); if (max_span_upper <= sep.cutting_value()) { sep.set_cutting_value(max_span_upper); }; if (max_span_lower >= sep.cutting_value()) { sep.set_cutting_value(max_span_lower); }; c0.split(c1,sep,true); } }; template > class Median_of_rectangle : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Median_of_rectangle() : Base() {} Median_of_rectangle(unsigned int bucket_size) : Base(bucket_size) {} void operator() (Separator& sep, Container& c0, Container& c1) { sep = Separator(c0.max_span_coord(),FT(0)); sep.set_cutting_value(c0.median(sep.cutting_dimension())); c0.split(c1,sep,true); } }; template > class Midpoint_of_max_spread : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Midpoint_of_max_spread() : Base() {} Midpoint_of_max_spread(unsigned int bucket_size) : Base(bucket_size) {} void operator()(Separator& sep, Container& c0, Container& c1) { sep = Separator(c0.max_tight_span_coord(), (c0.max_tight_span_upper() + c0.max_tight_span_lower())/FT(2)); c0.split(c1,sep); } }; template > class Midpoint_of_rectangle : public Splitter_base { typedef Splitter_base Base; public: typedef typename SearchTraits::FT FT; typedef Point_container Container; typedef Separator_ Separator; Midpoint_of_rectangle() : Base() {} Midpoint_of_rectangle(unsigned int bucket_size) : Base(bucket_size) {} void operator()(Separator& sep, Container& c0, Container& c1) { sep = Separator(c0.max_span_coord(), (c0.max_span_upper() + c0.max_span_lower())/FT(2)); c0.split(c1,sep); } }; } // namespace CGAL #endif // CGAL_SPLITTERS ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Bbox_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Bbox_2_intersec0000644000175000017500000000222711344301500031145 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Bbox_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_new.h0000644000175000017500000000322011344301501031151 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_new.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_TOPOLOGICAL_MAP_H #define CGAL_TOPOLOGICAL_MAP_H #include #include CGAL_BEGIN_NAMESPACE template < class Traits, class TopologicalMapItems = Topological_map_items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class T_HDS = HalfedgeDS_default, class Alloc = CGAL_ALLOCATOR(int)> class Topological_map { typedef Topological_map < Traits, TopologicalMapItems, T_HDS, Alloc> Self; typedef TopologicalMapItems Items; #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM typedef T_HDS< Traits, Items, Alloc> HDS; #else typedef typename T_HDS::template HDS< Traits, Items, Alloc> HDS; #endif }; CGAL_END_NAMESPACE #endif // CGAL_TOPOLOGICAL_MAP_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_jarvis.h0000644000175000017500000000630311344301500027143 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_jarvis.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_JARVIS_H #define CGAL_CH_JARVIS_H #include #include CGAL_BEGIN_NAMESPACE // generates the counterclockwise ordered subsequence of // extreme points between |start_p| and |stop_p| of the points in the // range [|first|,|last|), starting at position result with point |start_p|. // The last point generated is the point preceding |stop_p| in the // counterclockwise order of extreme points. // {\it Precondition:} |start_p| and |stop_p| are extreme points with respect // to the points in the range [|first|,|last|) and |stop_p| is an element of // range [|first|,|last|). // {\sc traits}: uses |Traits::Point_2| $\equiv$ |Point|, |Traits::Equal_2| // and |Traits::Less_rotate_ccw_2|. template OutputIterator ch_jarvis_march(ForwardIterator first, ForwardIterator last, const Point& start_p, const Point& stop_p, OutputIterator result, const Traits& ch_traits); template inline OutputIterator ch_jarvis_march(ForwardIterator first, ForwardIterator last, const Point& start_p, const Point& stop_p, OutputIterator result ) { typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_jarvis_march( first, last, start_p, stop_p, result, Kernel()); } // same as |convex_hull_2(first,last,result)|. // {\sc traits}: uses |Traits::Point_2|, |Traits::Less_rotate_ccw_2|, // |Traits::Equal_2| and |Traits::Less_xy_2|. template OutputIterator ch_jarvis(ForwardIterator first, ForwardIterator last, OutputIterator result, const Traits& ch_traits); template inline OutputIterator ch_jarvis(ForwardIterator first, ForwardIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_jarvis( first, last, result, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_JARVIS_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_alpha_shape_euclidean_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_alpha_shape_e0000644000175000017500000001111311344301501031332 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_alpha_shape_euclidean_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA // Andreas Fabri #ifndef CGAL_WEIGHTED_ALPHA_SHAPE_EUCLIDEAN_TRAITS_H #define CGAL_WEIGHTED_ALPHA_SHAPE_EUCLIDEAN_TRAITS_H #include #include #include #include #include //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- //------------------ Function Objects---------------------------------- template < class return_type, class K > class Compute_squared_radius_orthogonalcircleC2 { public: typedef return_type result_type; typedef Arity_tag< 3 > Arity; typedef typename K::Point T; result_type operator()(const T& p, const T& q, const T& r) { typedef typename K::FT FT; FT px(p.point().x()); FT py(p.point().y()); FT pw(p.weight()); FT qx(q.point().x()); FT qy(q.point().y()); FT qw(q.weight()); FT rx(r.point().x()); FT ry(r.point().y()); FT rw(r.weight()); result_type res = squared_radius_orthogonalcircleC2(px, py, pw, qx, qy, qw, rx, ry, rw); return max(return_type(0), res); } result_type operator()(const T& p, const T& q) { typedef typename K::FT FT; FT px(p.point().x()); FT py(p.point().y()); FT pw(p.weight()); FT qx(q.point().x()); FT qy(q.point().y()); FT qw(q.weight()); result_type res = squared_radius_smallest_orthogonalcircleC2(px, py, pw, qx, qy, qw); return max(return_type(0), res); } }; //------------------------------------------------------------------- template < class K > class Side_of_bounded_orthogonalcircleC2 { public: typedef Bounded_side result_type; typedef Arity_tag< 3 > Arity; typedef typename K::Point Point; result_type operator()(const Point& p, const Point& q, const Point& t) { typedef typename K::FT FT; FT px(p.point().x()); FT py(p.point().y()); FT pw(p.weight()); FT qx(q.point().x()); FT qy(q.point().y()); FT qw(q.weight()); FT tx(t.point().x()); FT ty(t.point().y()); FT tw(t.weight()); return in_smallest_orthogonalcircleC2(px, py, pw, qx, qy, qw, tx, ty, tw); } }; //------------------ Traits class ------------------------------------- template< class R > class Weighted_alpha_shape_euclidean_traits_2 : public Regular_triangulation_euclidean_traits_2 { public: typedef Weighted_alpha_shape_euclidean_traits_2 Self; typedef Regular_triangulation_euclidean_traits_2 Base; typedef typename R::FT FT; typedef typename Base::Weighted_point_2 Point; typedef CGAL::Compute_squared_radius_orthogonalcircleC2 Compute_squared_radius_orthogonalcircle_2; typedef CGAL::Side_of_bounded_orthogonalcircleC2 Side_of_bounded_orthogonalcircle_2; //------------------------------------------------------------------ Compute_squared_radius_orthogonalcircle_2 compute_squared_radius_2_object() const { return Compute_squared_radius_orthogonalcircle_2(); } //------------------------------------------------------------------ Side_of_bounded_orthogonalcircle_2 side_of_bounded_circle_2_object() const { return Side_of_bounded_orthogonalcircle_2(); } }; //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_configure.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000001004611344301500031411 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_configure.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_CONFIGURE #define CGAL_MINIBALL_CONFIGURE // Remark: In case you want to fine-tune the code, feel free to change // the options below. // Option: Namespace name // // Background: By default, all data-structures and routines of the // package are placed in a namespace called CGAL. You can // change this name by altering the following #define. // // Default value: CGAL #define CGAL_MINIBALL_NAMESPACE CGAL // Option: Assertions // // Background: The package contains lots of assertions (i.e. internal // consistency checks). For instance, if assertions are enabled then // the package will complain when you add balls with negative radii. // If you disable assertions, such tests will not be made (with the // advantage that the code is slightly faster). Do *not* disable // assertions during development. // // Default setting: defined #ifndef CGAL_NO_ASSERTIONS #define CGAL_MINIBALL_DEBUG #endif #ifdef NDEBUG #undef CGAL_MINIBALL_DEBUG #endif // (You should not have to alter anything below here.) // If CGAL is not being used, we need to define certain things: #ifndef CGAL_VERSION namespace CGAL_MINIBALL_NAMESPACE { struct Tag_true {}; struct Tag_false {}; } #define CGAL_MINIBALL_NTS #else #include #define CGAL_MINIBALL_NTS CGAL_NTS #endif // Define some assertion macros used in the code. #ifdef CGAL_MINIBALL_DEBUG #define CGAL_MINIBALL_ASSERT(expr) assert(expr) #define CGAL_MINIBALL_DO_DEBUG(expr) expr #else #define CGAL_MINIBALL_ASSERT(expr) ; #define CGAL_MINIBALL_DO_DEBUG(expr) ; #endif // Currently, we include all code in the header files because most // compilers don't support exporting templates anyway: #define CGAL_MINIBALL_NO_TEMPLATE_EXPORT // Fixes for Metrowerks CodeWarrior 7 compilers on MacOS X: // Unfortunately, this compiler puts the following symbols into // the global namespace, so we put them back into std: // (This fix is not necessary any more for CW 8 or higher.) #if defined __MWERKS__ && defined __MACH__ && (__MWERKS__ < 0x3000) #include #include namespace std { int rand(void) { return ::rand(); } double sqrt(const double x) { return ::sqrt(x); } double abs(const double x) { return ::abs(x); } } #endif // Fixes for GCC series 2.95. (This fix is necessary for 2.95.2 at // least. But I guess it is needed for any earlier version of the 2.95 // series, too.) Apparently, GCC doesn't come with a bitset and sstream // implementation, that's why we include them here. #if defined(__GNUC__) && __GNUC__==2 && \ __GNUC_MINOR__==95 && __GNUC_PATCHLEVEL__ <= 2 #include #else #include #include #endif // Fixes for MIPSpro Compilers (Version 7.3.1.3m is where the problem // occurred): The library function std::rand() is not in namespace std // and so we put it there. (This is only necessary when the package // is used without CGAL; if you include any CGAL header, then CGAL will // have fixed it already.) #if !defined(CGAL_VERSION) && defined(__sgi) && (__COMILER_VERSION <= 731) #include #include namespace std { int rand(void) { return ::rand(); } double sqrt(const double x) { return ::sqrt(x); } double abs(const double x) { return ::abs(x); } } #endif #endif // CGAL_MINIBALL_CONFIGURE mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Conic_2.h0000644000175000017500000001743011344301500026452 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Conic_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Bernd Gaertner, Sven Schoenherr #ifndef CGAL_CONIC_2_H #define CGAL_CONIC_2_H #ifndef CGAL_IO_FORWARD_DECL_WINDOW_STREAM_H #include #endif #include CGAL_BEGIN_NAMESPACE template < class R_ > class Optimisation_ellipse_2; CGAL_END_NAMESPACE // Why is this outside namespace CGAL ??? template < class R_ > CGAL::Window_stream& operator << ( CGAL::Window_stream&, const CGAL::Optimisation_ellipse_2&); CGAL_BEGIN_NAMESPACE template < class R_> class Conic_2 : public R_::Kernel_base::Conic_2 { friend class Optimisation_ellipse_2; public: // types typedef R_ R; typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Kernel_base::Conic_2 _Conic_2; // construction Conic_2 () {} Conic_2 (RT r, RT s, RT t, RT u, RT v, RT w) : _Conic_2 (r, s, t, u, v, w) {} // general access RT r () const { return _Conic_2::r(); } RT s () const { return _Conic_2::s(); } RT t () const { return _Conic_2::t(); } RT u () const { return _Conic_2::u(); } RT v () const { return _Conic_2::v(); } RT w () const { return _Conic_2::w(); } CGAL::Point_2 center () const { return _Conic_2::center(); } // type related access Conic_type conic_type () const { return _Conic_2::conic_type(); } bool is_hyperbola () const { return _Conic_2::is_hyperbola(); } bool is_parabola () const { return _Conic_2::is_parabola(); } bool is_ellipse () const { return _Conic_2::is_ellipse(); } bool is_circle () const { return _Conic_2::is_circle(); } bool is_empty () const { return _Conic_2::is_empty(); } bool is_trivial () const { return _Conic_2::is_trivial(); } bool is_degenerate () const { return _Conic_2::is_degenerate(); } // orientation related access CGAL::Orientation orientation () const { return _Conic_2::orientation (); } CGAL::Oriented_side oriented_side (const CGAL::Point_2& p) const { return _Conic_2::oriented_side (p); } bool has_on_positive_side (const CGAL::Point_2& p) const { return _Conic_2::has_on_positive_side (p); } bool has_on_negative_side (const CGAL::Point_2& p) const { return _Conic_2::has_on_negative_side (p); } bool has_on_boundary (const CGAL::Point_2& p) const { return _Conic_2::has_on_boundary (p); } bool has_on (const CGAL::Point_2& p) const { return _Conic_2::has_on (p); } Convex_side convex_side (const CGAL::Point_2& p) const { return _Conic_2::convex_side (p); } bool has_on_convex_side (const CGAL::Point_2& p) const { return _Conic_2::has_on_convex_side (p); } bool has_on_nonconvex_side (const CGAL::Point_2& p) const { return _Conic_2::has_on_nonconvex_side (p); } // comparisons bool operator == ( const Conic_2& c) const { return _Conic_2::operator == ( (Conic_2)c); } bool operator != ( const Conic_2& c) const { return( ! operator == ( c)); } // set methods void set (RT r, RT s, RT t, RT u, RT v, RT w) { _Conic_2::set (r, s, t, u, v, w); } void set_opposite () { _Conic_2::set_opposite(); } void set_circle (const CGAL::Point_2& p1, const CGAL::Point_2& p2, const CGAL::Point_2& p3) { // the unique circle through the three points _Conic_2::set_circle(p1, p2, p3); } void set_linepair (const CGAL::Point_2& p1, const CGAL::Point_2& p2, const CGAL::Point_2& p3, const CGAL::Point_2& p4) { _Conic_2::set_linepair (p1, p2, p3, p4); } void set_ellipse (const CGAL::Point_2& p1, const CGAL::Point_2& p2, const CGAL::Point_2& p3) { _Conic_2::set_ellipse (p1, p2, p3); } void set_ellipse (const CGAL::Point_2& p1, const CGAL::Point_2& p2, const CGAL::Point_2& p3, const CGAL::Point_2& p4, CGAL::Orientation o = POSITIVE) { _Conic_2::set_ellipse (p1, p2, p3, p4, o); } void set (const CGAL::Point_2& p1, const CGAL::Point_2& p2, const CGAL::Point_2& p3, const CGAL::Point_2& p4, const CGAL::Point_2& p5, CGAL::Orientation o = POSITIVE) { _Conic_2::set (p1, p2, p3, p4, p5, o); } private: void set_linear_combination ( const RT& a1, const Conic_2& c1, const RT& a2, const Conic_2& c2) { _Conic_2::set_linear_combination (a1, c1, a2, c2); } static void set_two_linepairs (const CGAL::Point_2& p1, const CGAL::Point_2& p2, const CGAL::Point_2& p3, const CGAL::Point_2& p4, Conic_2& pair1, Conic_2& pair2) { _Conic_2::set_two_linepairs (p1, p2, p3, p4, pair1, pair2); } void set_ellipse (const Conic_2& pair1, const Conic_2& pair2) { _Conic_2::set_ellipse (pair1, pair2); } void set (const Conic_2& c1, const Conic_2& c2, const CGAL::Point_2& p) { _Conic_2::set( c1, c2, p); this->analyse(); } CGAL::Sign vol_derivative (RT dr, RT ds, RT dt, RT du, RT dv, RT dw) const { return _Conic_2::vol_derivative (dr, ds, dt, du, dv, dw); } double vol_minimum (RT dr, RT ds, RT dt, RT du, RT dv, RT dw) const { return _Conic_2::vol_minimum (dr, ds, dt, du, dv, dw); } }; #ifndef CGAL_NO_OSTREAM_INSERT_CONIC_2 template< class R_> std::ostream& operator << ( std::ostream& os, const Conic_2& c) { return( os << c.r() << ' ' << c.s() << ' ' << c.t() << ' ' << c.u() << ' ' << c.v() << ' ' << c.w()); } #endif // CGAL_NO_OSTREAM_INSERT_CONIC_2 CGAL_END_NAMESPACE #endif // CGAL_CONIC_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Straight_2.h0000644000175000017500000002576711344301501027221 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Straight_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_STRAIGHT_2_H #define CGAL_STRAIGHT_2_H #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { class Straight_2_base_ { public: enum states {EMPTY, POINT, SEGMENT, RAY, LINE}; enum bound_states {NO_UNBOUNDED=0, MIN_UNBOUNDED=1, MAX_UNBOUNDED=2, BOTH_UNBOUNDED = 3, LINE_EMPTY = 4}; protected: Straight_2_base_() ; int main_dir_; // support_ is x or y directed (0/1). int dir_sign_; // sign of main direction coord. unsigned int bound_state_; // 0, 1, 2, 3, 4. public: inline unsigned int bound_state() const {return bound_state_;} }; template class Straight_2_: public Straight_2_base_ { public: Straight_2_() ; Straight_2_(typename K::Point_2 const &point) ; Straight_2_(typename K::Line_2 const &line) ; Straight_2_(typename K::Ray_2 const &ray) ; Straight_2_(typename K::Ray_2 const &ray,bool cooriented) ; Straight_2_(typename K::Segment_2 const &seg) ; ~Straight_2_() {} void cut_right_off(typename K::Line_2 const & cutter) ; int collinear_order(typename K::Point_2 const & p1, typename K::Point_2 const &p2) const ; void current(typename K::Line_2 &line) const; void current(typename K::Ray_2 &ray) const; void current(typename K::Segment_2 &seg) const; void current(typename K::Point_2 &point) const; states current_state() const; bool operator==(const Straight_2_&) const; bool operator!=(const Straight_2_&other) const { return !(*this == other);} protected: typename K::Line_2 support_; // The supporting line. typename K::Point_2 min_; typename K::Point_2 max_; }; inline Straight_2_base_:: Straight_2_base_() { bound_state_ = LINE_EMPTY; } template Straight_2_base_::states Straight_2_:: current_state() const { switch (bound_state_) { case BOTH_UNBOUNDED: return LINE; case MIN_UNBOUNDED: case MAX_UNBOUNDED: return RAY; case NO_UNBOUNDED: return (collinear_order(min_, max_) == 0) ? POINT : SEGMENT; case LINE_EMPTY: default: return EMPTY; } } template Straight_2_:: Straight_2_() { bound_state_ = LINE_EMPTY; } template Straight_2_:: Straight_2_(typename K::Line_2 const &line) { support_ = line; typename K::Vector_2 const &dir = support_.direction().to_vector(); main_dir_ = (CGAL_NTS abs(dir.x()) > CGAL_NTS abs(dir.y()) ) ? 0 : 1; dir_sign_ = CGAL_NTS sign(support_.direction().to_vector().cartesian(main_dir_)); bound_state_ = BOTH_UNBOUNDED; } template Straight_2_:: Straight_2_(typename K::Point_2 const &point) { typedef typename K::Direction_2 Direction_2; typedef typename K::Line_2 Line_2; support_ = Line_2(point, Direction_2(K::RT(1), K::RT(0))); main_dir_ = 0; dir_sign_ = 1; bound_state_ = NO_UNBOUNDED; min_ = point; max_ = point; } template Straight_2_:: Straight_2_(typename K::Ray_2 const &ray) { support_ = ray.supporting_line(); typename K::Vector_2 const &dir = ray.direction().to_vector(); main_dir_ = (CGAL_NTS abs(dir.x()) > CGAL_NTS abs(dir.y()) ) ? 0 : 1; dir_sign_ = CGAL_NTS sign(support_.direction().to_vector().cartesian(main_dir_)); bound_state_ = MAX_UNBOUNDED; min_ = ray.source(); } template Straight_2_:: Straight_2_(typename K::Ray_2 const &ray_,bool cooriented) { typename K::Ray_2 const &ray = cooriented ? ray_ : ray_.opposite(); support_ = ray.supporting_line(); /* the supporting line is cooriented with the input ray iff cooriented is true */ typename K::Vector_2 const &dir = ray.direction().to_vector(); main_dir_ = (CGAL_NTS abs(dir.x()) > CGAL_NTS abs(dir.y()) ) ? 0 : 1; dir_sign_ = CGAL_NTS sign(support_.direction().to_vector().cartesian(main_dir_)); if (cooriented) { bound_state_ = MAX_UNBOUNDED; min_ = ray.source(); } else { bound_state_ = MIN_UNBOUNDED; max_ = ray.source(); } } template Straight_2_:: Straight_2_(typename K::Segment_2 const &seg) { support_ = seg.supporting_line(); typename K::Vector_2 const &dir = support_.direction().to_vector(); main_dir_ = (CGAL_NTS abs(dir.x()) > CGAL_NTS abs(dir.y()) ) ? 0 : 1; dir_sign_ = CGAL_NTS sign(support_.direction().to_vector().cartesian(main_dir_)); bound_state_ = NO_UNBOUNDED; min_ = seg.source(); max_ = seg.target(); } template void Straight_2_:: current(typename K::Line_2 &line) const { CGAL_kernel_assertion(bound_state_ == BOTH_UNBOUNDED); line = support_; } template void Straight_2_:: current(typename K::Ray_2 &ray) const { typedef typename K::Ray_2 Ray_2; CGAL_kernel_assertion(bound_state_ == MIN_UNBOUNDED || bound_state_ == MAX_UNBOUNDED); if (bound_state_ == MIN_UNBOUNDED) { ray = Ray_2(max_, -support_.direction()); } else { ray = Ray_2(min_, support_.direction()); } } template void Straight_2_:: current(typename K::Segment_2 &seg) const { typedef typename K::Segment_2 Segment_2; CGAL_kernel_assertion(bound_state_ == NO_UNBOUNDED && collinear_order(min_, max_) != 0); seg = Segment_2(min_, max_); } template void Straight_2_:: current(typename K::Point_2 &pt) const { CGAL_kernel_assertion(bound_state_ == NO_UNBOUNDED && collinear_order(min_, max_) == 0); pt = min_; } template bool Straight_2_::operator==(const Straight_2_& s) const { typedef Straight_2_ Straight_2; // enum bound_states {NO_UNBOUNDED=0, MIN_UNBOUNDED=1, MAX_UNBOUNDED=2, // BOTH_UNBOUNDED = 3, LINE_EMPTY = 4}; if (bound_state_!=s.bound_state()) return false; if (bound_state_==Straight_2::LINE_EMPTY) return true; // empty if (support_!=s.support_) return false; // on different lines, even if both are points. switch (bound_state_) { case Straight_2::NO_UNBOUNDED: return min_==s.min_ && max_==s.max_; case Straight_2::MAX_UNBOUNDED: return min_==s.min_; case Straight_2::MIN_UNBOUNDED: return max_==s.max_; case Straight_2::BOTH_UNBOUNDED: return true; } return false; } template int sign_of_cross(typename K::Direction_2 const &dir1, typename K::Direction_2 const &dir2, const K&) { return static_cast(CGALi::orientation(dir1.to_vector(), dir2.to_vector(), K())); } template void Straight_2_:: cut_right_off(typename K::Line_2 const & cutter) // cut off any part of this straight that is to the right of the cutter. { if (bound_state_ == LINE_EMPTY) return; typename K::Point_2 ispoint; bool new_point; Line_2_Line_2_pair pair(&support_, &cutter); switch (pair.intersection_type()) { case Line_2_Line_2_pair::NO: if (cutter.has_on_negative_side(support_.point())) bound_state_ = LINE_EMPTY; break; case Line_2_Line_2_pair::LINE: break; case Line_2_Line_2_pair::POINT: pair.intersection(ispoint); new_point = false; switch (sign_of_cross(support_.direction(), cutter.direction(), K())) { case -1: // new minimum. if (bound_state_ & MIN_UNBOUNDED) { new_point = true; bound_state_ ^= MIN_UNBOUNDED; // exclusive or removes flag. } else { if (collinear_order(ispoint, min_) == -1) new_point = true; } if (new_point) { if (!(bound_state_ & MAX_UNBOUNDED) && collinear_order(ispoint, max_) == -1) bound_state_ = LINE_EMPTY; else min_ = ispoint; } break; case 0: // should not happen CGAL_kernel_warning_msg(false, "Internal CGAL error."); break; case 1: // new maximum if (bound_state_ & MAX_UNBOUNDED) { new_point = true; bound_state_ ^= MAX_UNBOUNDED; // exclusive or removes flag. } else { if (collinear_order(ispoint, max_) == 1) new_point = true; } if (new_point) { if (!(bound_state_ & MIN_UNBOUNDED) && collinear_order(ispoint, min_) == 1) bound_state_ = LINE_EMPTY; else max_ = ispoint; } break; } break; } } template int Straight_2_:: collinear_order(typename K::Point_2 const &pt1, typename K::Point_2 const & pt2) const // Compare two points on the support_ line. // If the second point lies in the direction of the direction vector from // the first point, the result is 1. // Other results are -1 (other side) and 0 (coincidence). { typename K::Construct_cartesian_const_iterator_2 construct_cccit; typename K::Cartesian_const_iterator_2 ccit1 = construct_cccit(pt1) + main_dir_; typename K::Cartesian_const_iterator_2 ccit2 = construct_cccit(pt2) + main_dir_; int diffsign; diffsign = CGAL_NTS sign(*ccit2 - *ccit1); if (diffsign == 0) return 0; return (diffsign == dir_sign_) ? 1 : -1; } } // namespace CGALi CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_traits_2_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_traits_2_bas0000644000175000017500000000413611344301500031354 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_traits_2_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef PARTITION_TRAITS_2_BASE_H #define PARTITION_TRAITS_2_BASE_H #include #include namespace CGAL { template class Partition_traits_2_base { private: typedef Kernel_ Kernel; public: typedef typename Kernel::Point_2 Point_2; typedef ::std::list Container; typedef CGAL::Polygon_2 Polygon_2; typedef typename Kernel::Less_yx_2 Less_yx_2; typedef typename Kernel::Less_xy_2 Less_xy_2; typedef typename Kernel::Left_turn_2 Left_turn_2; typedef typename Kernel::Orientation_2 Orientation_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Compare_x_2 Compare_x_2; Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } }; } #endif // PARTITION_TRAITS_2_BASE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convexity_check_3.h0000644000175000017500000001547411344301500030613 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convexity_check_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert // : Amol Prakash #ifndef CGAL_CONVEXITY_CHECK_3_H #define CGAL_CONVEXITY_CHECK_3_H #include namespace CGAL { template void get_plane2(Plane& plane, Facet_handle f) { typedef typename Facet_handle::value_type Facet; typedef typename Facet::Halfedge_handle Halfedge_handle; Halfedge_handle h = (*f).halfedge(); plane = Plane(h->opposite()->vertex()->point(), h->vertex()->point(), h->next()->vertex()->point()); } template bool is_locally_convex(Facet_handle f_hdl, const Traits& traits) { // This function checks if all the faces around facet *f_hdl form part of // the convex hull typedef typename Facet_handle::value_type Facet; typedef typename Facet::Halfedge_around_facet_circulator Halfedge_circ; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Plane_3 Plane_3; typename Traits::Has_on_positive_side_3 has_on_positive_side = traits.has_on_positive_side_3_object(); Halfedge_circ h_circ = (*f_hdl).facet_begin(); do { // Take the point on the other facet not shared by this facet Point_3 point= h_circ->opposite()->next()->vertex()->point(); Plane_3 plane; get_plane2(plane, f_hdl); // Point must be on the plane or on the negative side if (has_on_positive_side(plane, point)) { return false; } h_circ++; } while ( h_circ != (*f_hdl).facet_begin()); return true; } // Pre: equations of facet planes have been computed template bool is_strongly_convex_3(Polyhedron& P, const Traits& traits) { typedef typename Polyhedron::Facet_iterator Facet_iterator; typedef typename Polyhedron::Vertex_iterator Vertex_iterator; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Ray_3 Ray_3; typedef typename Traits::Triangle_3 Triangle_3; typedef typename Traits::Plane_3 Plane_3; if (P.vertices_begin() == P.vertices_end()) return false; Facet_iterator f_it; for ( f_it = P.facets_begin(); f_it != P.facets_end(); ++f_it) if (!is_locally_convex(f_it, traits)) return false; // Check 2: see if a point interior to the hull is actually on the same // side of each facet of P typename Traits::Coplanar_3 coplanar = traits.coplanar_3_object(); Vertex_iterator v_it = P.vertices_begin(); Point_3 p; Point_3 q; Point_3 r; Point_3 s; // First take 3 arbitrary points p = v_it->point(); v_it++; q = v_it->point(); v_it++; r = v_it->point(); v_it++; // three vertices that form a single (triangular) facet if (v_it == P.vertices_end()) return P.facets_begin() != P.facets_end(); // Now take 4th point s.t. it's not coplaner with them while (v_it != P.vertices_end() && coplanar(p, q, r, (*v_it).point())) v_it++; // if no such point, all are coplanar so it is not strongly convex if( v_it == P.vertices_end() ){ return false; } s = (*v_it).point(); // else construct a point inside the polyhedron typename Traits::Construct_centroid_3 construct_centroid = traits.construct_centroid_3_object(); Point_3 inside_pt = construct_centroid(p,q,r,s); typename Traits::Oriented_side_3 oriented_side = traits.oriented_side_3_object(); f_it = P.facets_begin(); Plane_3 plane; get_plane2(plane, f_it); Oriented_side side = oriented_side(plane, inside_pt); // the point inside should not be on the facet plane if (side == ON_ORIENTED_BOUNDARY){ return false; } // now make sure this point that is inside the polyhedron is on the same // side of each facet for (f_it++; f_it != P.facets_end(); f_it++) { Plane_3 plane; get_plane2(plane, f_it); if ( oriented_side(plane, inside_pt) != side ){ return false; } } // Check 3 : see if a ray from the interior point to a point in the // middle of one of the facets intersects any other facets typename Traits::Construct_ray_3 construct_ray = traits.construct_ray_3_object(); typename Traits::Construct_triangle_3 construct_triangle = traits.construct_triangle_3_object(); typename Traits::Do_intersect_3 do_intersect = traits.do_intersect_3_object(); f_it = P.facets_begin(); Point_3 facet_pt = construct_centroid(f_it->halfedge()->opposite()->vertex()->point(), f_it->halfedge()->vertex()->point(), f_it->halfedge()->next()->vertex()->point()); Ray_3 ray = construct_ray(inside_pt, facet_pt); for ( ++f_it ; f_it != P.facets_end(); f_it++) { Triangle_3 facet_tri = construct_triangle(f_it->halfedge()->opposite()->vertex()->point(), f_it->halfedge()->vertex()->point(), f_it->halfedge()->next()->vertex()->point()); if (do_intersect(facet_tri, ray)){ return false; } } return true; } template bool CGAL_is_strongly_convex_3(Polyhedron& P, Point_3*) { return is_strongly_convex_3(P, R()); } template bool is_strongly_convex_3(Polyhedron& P) { typedef typename Polyhedron::Point_3 Point_3; return CGAL_is_strongly_convex_3(P, reinterpret_cast(0)); } template bool all_points_inside( ForwardIterator first, ForwardIterator last, Polyhedron& P, const Traits& traits) { typedef typename Traits::Plane_3 Plane_3; typedef typename Polyhedron::Facet_iterator Facet_iterator; typename Traits::Has_on_positive_side_3 has_on_positive_side = traits.has_on_positive_side_3_object(); for (ForwardIterator p_it = first; p_it != last; p_it++) { Facet_iterator f_it; for (f_it = P.facets_begin(); f_it != P.facets_end(); f_it++) { Plane_3 plane; get_plane2(plane, f_it); if (has_on_positive_side(plane,*p_it)){ return false; } } } return true; } } // namespace CGAL #endif // CGAL_CONVEXITY_CHECK_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filter_circulator.h0000644000175000017500000000451511344301500030652 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filter_circulator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_FILTRED_CIRCULATOR_H #define CGAL_FILTRED_CIRCULATOR_H namespace CGAL { template class Filter_circulator : public Circ { bool is_null; Pred test; public: typedef Filter_circulator Self; Filter_circulator(const Pred p=Pred()): is_null(true), test(p) {}; Filter_circulator(const Self& c): Circ(c), is_null(c.is_null), test(c.test) {}; Self& operator=(const Self& c) { //this->Circ::operator=(c); // This does not work with bcc //*this = c; // This does not work with VC++6 static_cast(*this) = static_cast(c); is_null=c.is_null; test=c.test; return *this; } Filter_circulator(const Circ& c, const Pred& p=Pred()) : Circ(c), is_null(false), test(p) { if(test(static_cast(*this))) is_null=false; else { Self end(*this); do { this->Circ::operator++(); } while( !test(static_cast(*this)) && (*this)!=end ); if((*this)==end) is_null=true; } }; bool operator==( CGAL_NULL_TYPE ) const { return is_null; } bool operator!=( CGAL_NULL_TYPE ) const { return !is_null; } bool operator==(const Self& c) const { return is_null==c.is_null && this->Circ::operator==(c); } bool operator!=( const Self& c) const { return !(*this == c); } Self& operator++() { CGAL_assertion(!is_null); do { this->Circ::operator++(); } while( !test(static_cast(*this)) ); return *this; } Self operator++(int) { Self tmp= *this; ++*this; return tmp; } }; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Parabola_segment_2.h0000644000175000017500000000733411344301500030664 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Parabola_segment_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_PARABOLA_SEGMENT_2_H #define CGAL_PARABOLA_SEGMENT_2_H #include CGAL_BEGIN_NAMESPACE template < class Gt > class Parabola_segment_2 : public Parabola_2< Gt > { typedef CGAL::Parabola_2 Base; typedef typename Base::Site_2 Site_2; typedef typename Base::FT FT; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::Line_2 Line_2; protected: Point_2 p1, p2; public: Parabola_segment_2() : Parabola_2< Gt >() {} template Parabola_segment_2(const ApolloniusSite &p, const Line_2 &l, const Point_2 &p1, const Point_2 &p2) : Parabola_2< Gt >(p, l) { this->p1 = p1; this->p2 = p2; } Parabola_segment_2(const Point_2 &p, const Line_2 &l, const Point_2 &p1, const Point_2 &p2) : Parabola_2< Gt >(p, l) { this->p1 = p1; this->p2 = p2; } void generate_points(std::vector& p) const { FT s[2]; s[0] = t(p1); s[1] = t(p2); if (CGAL::compare(s[0], s[1]) == LARGER) { #if defined(__GNUC__) && (__GNUC__ < 3) FT tmp = s[0]; s[0] = s[1]; s[1] = tmp; #else std::swap< FT >(s[0], s[1]); #endif } p.clear(); if ( !(CGAL::is_positive(s[0])) && !(CGAL::is_negative(s[1])) ) { FT tt; int k; p.push_back( this->o ); k = 1; tt = -this->STEP(); while ( CGAL::compare(tt, s[0]) == LARGER ) { p.insert( p.begin(), f(tt) ); k--; tt = -FT(k * k) * this->STEP(); } p.insert( p.begin(), f(s[0]) ); k = 1; tt = this->STEP(); while ( CGAL::compare(tt, s[1]) == SMALLER ) { p.push_back( f(tt) ); k++; tt = FT(k * k) * this->STEP(); } p.push_back( f(s[1]) ); } else if ( !(CGAL::is_negative(s[0])) && !(CGAL::is_negative(s[1])) ) { FT tt; int k; p.push_back( f(s[0]) ); tt = s[0]; k = int(CGAL::to_double(CGAL::sqrt(tt / this->STEP()))); while ( CGAL::compare(tt, s[1]) == SMALLER ) { if ( CGAL::compare(tt, s[0]) != SMALLER ) p.push_back( f(tt) ); k++; tt = FT(k * k) * this->STEP(); } p.push_back( f(s[1]) ); } else { FT tt; int k; p.push_back( f(s[1]) ); tt = s[1]; k = int(CGAL::to_double(-CGAL::sqrt(-tt / this->STEP()))); while ( CGAL::compare(tt, s[0]) == LARGER ) { if ( CGAL::compare(tt, s[1]) != LARGER ) p.push_back( f(tt) ); k--; tt = -FT(k * k) * this->STEP(); } p.push_back( f(s[0]) ); } } template< class Stream > void draw(Stream& W) const { std::vector< Point_2 > p; generate_points(p); for (unsigned int i = 0; i < p.size() - 1; i++) { W << Segment_2(p[i], p[i+1]); } } }; template< class Stream, class Gt > inline Stream& operator<<(Stream &s, const Parabola_segment_2 &P) { P.draw(s); return s; } CGAL_END_NAMESPACE #endif // CGAL_PARABOLA_SEGMENT_2_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_data_structure_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_data_0000644000175000017500000000226211344301500031403 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_data_structure_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_DATA_STRUCTURE_2_H #define CGAL_APOLLONIUS_GRAPH_DATA_STRUCTURE_2_H #include CGAL_BEGIN_NAMESPACE // For backward compatibility template class Apollonius_graph_data_structure_2 : public Triangulation_data_structure_2 {}; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_DATA_STRUCTURE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/memory.h0000644000175000017500000000333411344301500026504 0ustar debiandebian// Copyright (c) 1999, 2002, 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/memory.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel, Sylvain Pion #ifndef CGAL_MEMORY_H #define CGAL_MEMORY_H #include // CGAL_ALLOCATOR(t) defines the default allocator used by CGAL. // CGAL_MEMORY(t) overloads the new and delete operators for a given class. // When LEDA is there, the user could define these macros as // leda_allocator< T > and LEDA_MEMORY(T) for example. // For debugging with GCC, the following allocator can be useful : // std::__allocator > > #ifndef CGAL_ALLOCATOR # define CGAL_ALLOCATOR(T) std::allocator< T > #endif #ifndef CGAL_MEMORY # define CGAL_MEMORY(T) #endif #endif // CGAL_MEMORY_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_landmarks_point_location.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_landmarks_point_loc0000644000175000017500000011711211344301500031424 0ustar debiandebian// Copyright (c) 2004 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_landmarks_point_location.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Idit Haran #ifndef CGAL_PM_LANDMARKS_POINT_LOCATION_C #define CGAL_PM_LANDMARKS_POINT_LOCATION_C #include //#define CGAL_LM_DEBUG #define LM_CLOCK_DEBUG CGAL_BEGIN_NAMESPACE //---------------------------------------------------- /*! */ //if unbounded face - returns NULL or some edge on unbounded face //if its a vertex returns a halfedge pointing _at_ it template typename Pm_landmarks_point_location::Halfedge_const_handle Pm_landmarks_point_location ::locate(const Point_2 & p, Locate_type & lt) const { #ifdef CGAL_LM_DEBUG std::cout << "------ locate point "<< p << std::endl; #endif //CGAL_LM_DEBUG //init output Face_handle f = pm->unbounded_face(), last = pm->faces_end(); // invariant: p always lies in f's interior or holes Halfedge_const_handle e = pm->halfedges_end(); // closest halfedge so far lt = Planar_map::UNBOUNDED_FACE; //check that the nearest neigbor search data structure is updated if (pm->number_of_vertices() == 0) return e; if (! updated_nn) { std::cout << "ERROR 1: tree is not updated ! number of vertices in pm = " << pm->number_of_vertices() << std::endl; return e; } #ifdef LM_CLOCK_DEBUG clock_t nn_time_start = clock(); //check time - start #endif //get nearest vertex to point p double px = CGAL::to_double(p.x()); double py = CGAL::to_double(p.y()); NN_Point_2 nnp (px, py); NN_Point_2 nearest_point = nn.find_nearest_neighbor(nnp); #ifdef CGAL_LM_DEBUG std::cout << "nearest neighbor of point "<< p << " is " << nearest_point.x() <<','<" << e->target()->point() << std::endl; std::cout << std::endl << std::endl << std::endl; //getchar #endif //CGAL_LM_DEBUG return e; } //---------------------------------------------------- /*! */ template typename Pm_landmarks_point_location::Halfedge_handle Pm_landmarks_point_location:: locate(const Point_2 & p, Locate_type & lt) { Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); //Halfedge_handle h=((cPLp)this)->locate(p,lt); return h; } //---------------------------------------------------- /*! */ template typename Pm_landmarks_point_location::Halfedge_const_handle Pm_landmarks_point_location:: vertical_ray_shoot(const Point_2 & p, Locate_type & lt, bool up) const { //std::cout << "ERROR: Vertical ray shoot NOT suppored in CDT point location" //<< std::endl; CGAL_precondition_msg(false, "Vertical ray shoot NOT suppored in CDT point location"); assert(false); Halfedge_const_handle e = pm->halfedges_end(); // closest halfedge so far lt=Planar_map::UNBOUNDED_FACE; return e; } //---------------------------------------------------- /*! */ template typename Pm_landmarks_point_location::Halfedge_handle Pm_landmarks_point_location::vertical_ray_shoot( const Point_2& p, Locate_type& lt, bool up) { //Halfedge_const_handle h=((const_Self_ptr)this)->vertical_ray_shoot(p,lt,up); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->vertical_ray_shoot(p,lt,up)); return h; } //---------------------------------------------------- /*! insert an halfedge to the plannar map - add its end points to the landmarks tree */ template void Pm_landmarks_point_location::insert_halfedge_to_ln_tree (Halfedge_handle hh, const typename Planar_map::Traits::X_monotone_curve_2 &cv) { #ifdef CGAL_LM_DEBUG std::cout << "in insert_halfedge_to_ln_tree" << std::endl ; std::cout << "cv = "<< cv << std::endl; std::cout << hh->source()->point()<<" towards "<< hh->target()->point()<< std::endl; #endif //CGAL_LM_DEBUG create_landmarks_tree(); } //---------------------------------------------------- /*! go over all vertices, and insert each vertex to the landmarks tree. */ template void Pm_landmarks_point_location::create_landmarks_tree() { #ifdef CGAL_LM_DEBUG std::cout << "in create_landmarks_tree" << std::endl ; #endif //CGAL_LM_DEBUG if (pm->vertices_begin() == pm->vertices_end()) { updated_nn = true; #ifdef CGAL_LM_DEBUG std::cout << "empty pm. out create_landmarks_tree" << std::endl ; #endif //CGAL_LM_DEBUG } //Go over planar map, and create a triangulation of it Vertex_iterator vit; NN_Point_list plist; for (vit=pm->vertices_begin(); vit != pm->vertices_end(); vit++) { //get point from vertex Point_2 p = vit->point() ; double px = CGAL::to_double(p.x()); double py = CGAL::to_double(p.y()); Vertex_handle vh = vit; NN_Point_2 np (px, py, vh); //insert point into list plist.push_back(np); //print #ifdef CGAL_LM_DEBUG //std::cout << "point is= " << p << std::endl; #endif //CGAL_LM_DEBUG } #ifdef CGAL_LM_DEBUG std::cout << "before clean" << std::endl ; #endif //CGAL_LM_DEBUG nn.clean(); #ifdef CGAL_LM_DEBUG std::cout << "before init" << std::endl ; #endif //CGAL_LM_DEBUG nn.init(plist.begin(), plist.end()); //the triangulation is now updated updated_nn = true; #ifdef CGAL_LM_DEBUG std::cout << "out create_landmarks_tree" << std::endl ; #endif //CGAL_LM_DEBUG } //---------------------------------------------------- /*! walks from the vertex to the point * * Return the number of times that the segment s-->t intersects the curve * in segments this number can be 0 or 1 * * \param cv - the input curve (intersecting curve?) * \param s - start point of the input segment * \param t - end of point the segment * \param p - the output point. * \pre s is not equal to t * \return the number of times the curve intersects the segment. * 0 - no intersection, 1 - intersect, 2- overlap * */ template void //typename Pm_landmarks_point_location::Halfedge_const_handle Pm_landmarks_point_location:: walk(Vertex_handle nearest_vertex, //input const Point_2 & p, //input Halfedge_const_handle& e, //output Locate_type& lt) const //output { #ifdef CGAL_LM_DEBUG std::cout << "inside walk_from_vertex_to_point. p= "<< p << ", nearest_vertex = "<point() << std::endl; #endif //CGAL_LM_DEBUG bool new_vertex = false; bool found_face = false; bool found_vertex_or_edge = false; bool found_edge = false; bool found_vertex = false; Face_handle face; Vertex_handle out_vertex; Vertex_handle vh = nearest_vertex; Halfedge_handle out_edge; int debug_count = 0; do { debug_count++; #ifdef CGAL_LM_DEBUG std::cout << "inside first do loop. debug_count = " < "<< out_edge->target()->point() << std::endl; #endif //CGAL_LM_DEBUG e = out_edge; } else { // (lt == Planar_map::VERTEX) #ifdef CGAL_LM_DEBUG std::cout <<"out_vertex = " << out_vertex->point() << std::endl; #endif //CGAL_LM_DEBUG e = out_vertex->incident_halfedges(); } return; } if (new_vertex) { std::cout << "NEW vertex 1 " << std::endl; //check if the new vertex is really closer if (traits->compare_distance(p, out_vertex->point(), vh->point()) == SMALLER) { vh = out_vertex; } else { std::cout << "Error 2: new vertex is not closer to p than vh! "; std::cout << "out_vertex is: " << out_vertex->point() << std::endl; getchar(); return; } } } while (new_vertex); //get the face that is the best potentially contains p. if (found_face) { face = out_edge->face(); } else { std::cerr << "face not found" << std::endl; return; } /////////////////////////////IXXXXXXXXXXXXXXXXXXX //new algorithm should be: (after face was found) //1. check if p is in face. // yes: // go over holes. for each hole h: // is p in h? // yes: face = h. goto 1. // no: // call new function: // find_closest_intersection_in_face( gets face, v, p) that returns e and intersection point (if needed). // (the function go over all edges surrounding p. for each one- as done now - take out of the walk procedure) // face = e->twin. goto1. // if intersection not found --- ? error ? //////////////////////////////IXXXXXXXXXXXXXXXXXXX // IXXXXXXXXXX bool p_in_face = false; Ccb_halfedge_circulator h_circ; #ifdef LM_CLOCK_DEBUG clock_t na_time_start = clock(); //time start #endif #ifdef CGAL_LM_DEBUG std::cout << "start new algo " <is_unbounded()) { p_in_face = true; #ifdef CGAL_LM_DEBUG std::cout << "unbounded face " <outer_ccb(); p_in_face = is_point_in_face(p, h_circ, found_edge, found_vertex, out_edge); #ifdef CGAL_LM_DEBUG std::cout << "is_point_in_face returned "<< p_in_face <holes_begin(); Holes_iterator hole_end = face->holes_end(); bool p_in_hole; while (hole_it != hole_end) { #ifdef CGAL_LM_DEBUG std::cout << " loop on holes" <twin(); face = out_edge->face(); } else { std::cerr << "ERROR 10: intersection not found" << std::endl; } #ifdef LM_CLOCK_DEBUG clock_t fc_time_end = clock();//time end double fc_period = (double) (fc_time_end - fc_time_start); clock_fciif += fc_period; #endif hole_it = hole_end; //to get out of the loop p_in_face = false; } else { ++hole_it; } } } else { //find edge to switch face to (face is never unbounded) #ifdef LM_CLOCK_DEBUG clock_t fc_time_start = clock(); //time start #endif if ( find_closest_intersection_in_face (p, vh, face->outer_ccb() , out_edge) ) { out_edge = out_edge->twin(); face = out_edge->face(); #ifdef CGAL_LM_DEBUG std::cout << "after find_closest_intersection_in_face . out_edge changed to twin @ " <" << out_edge->target()->point() <unbounded_face()) lt = Planar_map::FACE; else lt = Planar_map::UNBOUNDED_FACE; e = out_edge; return; } //---------------------------------------------------- /*! * Return the edge around vh that is before cw to the segment vh->p * * \param p - the input point. * \param vh - the input vertex * \param found_vertex_or_edge - output bool, * if the point was found on a vertex or halfedge * \param new_vertex - output bool, if a closer vertex to p was found * \param out_vertex - the output vertex (if closer vertex found) * \param out_edge - the output edge, if found p on edge, * or if normally return the edge around vh closer (before cw) to p */ template void Pm_landmarks_point_location:: find_face (const Point_2 & p, Vertex_handle vh, bool & found_vertex_or_edge, bool & new_vertex, bool & found_face, Vertex_handle & out_vertex, Halfedge_handle & out_edge, Locate_type& lt ) const { #ifdef CGAL_LM_DEBUG std::cout << "inside find_face. p ="<< p <<" , vh = "<point() <point_equal(vh->point(), p)) { lt = Planar_map::VERTEX; out_edge = vh->incident_halfedges(); out_vertex = vh; found_vertex_or_edge = true; return; } //create a segment vh--p. Curve_2 seg(vh->point(), p); //circulate vh and find the two edges that vh-p lies between. bool cv_equal_cv1 = false; bool cv_equal_cv2 = false; bool is_btw = false; Halfedge_around_vertex_circulator circ = vh->incident_halfedges(); Halfedge_around_vertex_circulator circ_done (circ); Halfedge_handle first = circ; Halfedge_handle prev = circ; Curve_2 cv1, cv2; ++circ; int debug_count = 0; while (circ != circ_done) { debug_count++; //std::cout << " first loop in find face. debug_count = " <curve(); cv1 = prev->curve(); //std::cout << "circ = "<curve() << std::endl; //check if seg is between prev_cv and curr_cv //std::cout << " cv1 = " <source(); new_vertex = true; std::cout << "The new vertex is: "<< out_vertex->point() << std::endl; // check validity (the new vertex is vetween them on a line) @@@@ return; } else { //cv_equal_cv2 if (traits->point_equal(p,circ->source()->point())) { out_edge = circ; out_vertex = circ->source(); lt = Planar_map::VERTEX; found_vertex_or_edge = true; return; } if (traits->point_in_x_range(cv2,p) && traits->curve_compare_y_at_x(p,cv2) == EQUAL) { // p lies on cv1 out_edge = circ; lt = Planar_map::EDGE; found_vertex_or_edge = true; return; } //p does not lie on cv1 ==> // the target of the equal curve is a better vertex to p std::cout << " WARNING: found closer vertex " <source(); new_vertex = true; std::cout << "The new vertex is: "<< out_vertex->point() << std::endl; // check validity (the new vertex is vetween them on a line) @@@@ return; } } if (is_btw) { #ifdef CGAL_LM_DEBUG std::cout << " cv is between " << cv1 << " and " << cv2 << std::endl; #endif //CGAL_LM_DEBUG out_edge = prev; found_face = true; //std::cout << " before return from find_face. out_edge = " << out_edge->curve() << std::endl; return; } prev = circ; //std::cout << " prev = " <curve() << std::endl; ++circ; } //std::cout << " not found during first loop !" <first if ( !is_btw && !cv_equal_cv1 && !cv_equal_cv2) { cv1 = prev->curve(); cv2 = first->curve(); //std::cout << " before curve_is_between_cw "<< std::endl; //std::cout << " cv1 = " <source(); new_vertex = true; std::cout << "The new vertex is: "<< out_vertex->point() << std::endl; // check validity (the new vertex is vetween them on a line) @@@@ return; } else { //cv_equal_cv2 if (traits->point_equal(p,first->source()->point())) { out_edge = first; out_vertex = first->source(); lt = Planar_map::VERTEX; found_vertex_or_edge = true; return; } if (traits->point_in_x_range(cv2,p) && traits->curve_compare_y_at_x(p,cv2) == EQUAL) { // p lies on cv1 out_edge = first; lt = Planar_map::EDGE; found_vertex_or_edge = true; return; } //p does not lie on cv1 ==> // the target of the equal curve is a better vertex to p std::cout << " WARNING: found closer vertex " <source(); new_vertex = true; std::cout << "The new vertex is: "<< out_vertex->point() << std::endl; // check validity (the new vertex is vetween them on a line) @@@@ return; } } if (is_btw) { #ifdef CGAL_LM_DEBUG std::cout << " cv is between " << cv1 << " and " << cv2 << std::endl; #endif //CGAL_LM_DEBUG out_edge = prev; found_face = true; //std::cout << " before return from find_face. out_edge = " << out_edge->curve() << std::endl; return; } } std::cerr << "ERROR 4: edge above cw not found !" < void Pm_landmarks_point_location:: find_intersection (const Point_2 & p, //input seg src Curve_2 &seg, //input seg Halfedge_handle e, //input curve int & num_of_intersections, //out num intersections bool & change_side, //out did we move side? bool & found_edge, //out is p on e? Point_2 & closest_interect_point, //out return value bool & new_vertex, //out if closest to p? Vertex_handle & out_vertex ) const //out the closer vertex { //the idea is that the function checks whether the segment seg intersects e. //if it finds closer vertex to p than v, then it returns the new vertex in out_vertex, // and set the flag new_vertex to true. This can be the case if seg intersects e in its end point. // or if there is an overlap between seg and e. //if p is on e, then it changes the flag found_edge to be true. //if there is no intersection it returns all flags to be false, and num_of_intersections to be 0. //if there is a regular intersection (in a point), it returns the number of intersection (usually 1). // since this could be a specail point (like a tangent point), it also returns the flag change_side to check // whether the point p is on a different side of e than seg->source() is. //closest_intersect_point is the intersection point between seg and e. // if there is more than one intersection, this is the closest one to p. entries_to_fi++; #ifdef CGAL_LM_DEBUG std::cout << " inside find_intersection. p = " << p << ", seg = "<< seg <<", e = "<< e->curve() <point(), p); //seg in the reffered segment vh - p. Curve_2 seg1, seg2; Curve_2 cv = e->curve(); //bool is_vertical = traits->curve_is_vertical(seg); ??? //loop on all intersections of seg and e do { CGAL::Object res_obj; Point_2 inter_point; Curve_2 overlap_seg; Point_2 vp = traits->curve_source(seg); Comparison_result comp_xy_res = traits->compare_xy(p, vp); #ifdef LM_CLOCK_DEBUG clock_t ni_time_start = clock();//time start #endif switch (comp_xy_res) { case LARGER: //p is on the right of vp (or vertical and up) //find nearest intersection to the right of vp //std::cout << "check nearest intersection to the right of : "<< vp << "seg = "<point, ignore it ! if (traits->point_equal(seg.source(), inter_point)) { //std::cout << " intersection equals seg->source() = " << seg.source() <point_equal(e->source()->point(), inter_point)) { new_vertex = true; out_vertex = e->source(); //std::cout << " intersection found new vertex: e->source = " << e->source()->point() <point_equal(e->target()->point(), inter_point)) { new_vertex = true; out_vertex = e->target(); //std::cout << " intersection found new vertex: e->target = " << e->target()->point()< 1)) { std::cout << " warning: should not reach here if segments" <compare_distance(p, inter_point, closest_interect_point) == SMALLER)) { closest_interect_point = inter_point; // split seg and save the part of seg closer to p traits->curve_split(seg, seg1, seg2, inter_point); Point_2 seg1_src = traits->curve_source(seg1); Point_2 seg2_trg = traits->curve_target(seg2); if ((traits->compare_xy(seg1_src, seg2_trg)) == comp_xy_res) { seg = seg1; } else { seg = seg2; } //std::cout << "seg was split inside find_intersect. new seg = " <curve_source(overlap_seg); Point_2 ov_trg = traits->curve_target(overlap_seg); //if p equals on of the end points of the overlapped segment, then p is on e. if (traits->point_equal(p, ov_src) || traits->point_equal(p, ov_trg)) { found_edge = true; return; } //if the one of the end points of e equals on of the overlapped segment's end points, //then a new vertex is found (the endpoint of e) if (traits->point_equal(e->source()->point(), ov_src) || traits->point_equal(e->source()->point(), ov_trg)) { //e->source is equal new_vertex = true; out_vertex = e->source(); return; } if (traits->point_equal(e->target()->point(), ov_src) || traits->point_equal(e->target()->point(), ov_trg)) { //e->source is equal new_vertex = true; out_vertex = e->target(); return; } std::cout << "WARNING: this case was not implemented !!!" < 1)). otherwise, its irrelevant } else {// We should never reach here: CGAL_assertion (false); } // go on with the loop ++intersection_counter; } while ((num_of_intersections > 0) && ((!define_max) || (define_max && (intersection_counter < max_intersections)) ) ); } //---------------------------------------------------- /*! * Checks if p is inside the face * * \param p - the input point. * \param e - the input edge * \param found_edge - did we found the edge p lies on * \param new_vertex - output bool, if a closer vertex to p was found */ template bool Pm_landmarks_point_location:: is_point_in_face (const Point_2 & p, //input seg src const Ccb_halfedge_circulator & face, //input face bool & found_edge, //out is p on e? bool & found_vertex, //out is p equals e->target? Halfedge_handle & out_edge) const //output if on curve { #ifdef CGAL_LM_DEBUG std::cout << "inside is_point_in_face. face = " << face->source()->point() <<"-->" << face->target()->point()<is_unbounded()) // return (true); //loop on all edges in this face Ccb_halfedge_circulator curr = face; Ccb_halfedge_circulator last = curr; do { Curve_2 cv = curr->curve(); Point_2 p1 = curr->source()->point(); Point_2 p2 = curr->target()->point(); //check if p equals one of the endpoints of e if (traits->point_equal(p, p1)) { found_vertex = true; out_edge = curr->twin() ; return (true); } if (traits->point_equal(p, p2)) { found_vertex = true; out_edge = curr ; return (true); } //check in_x_range lexicographically. This is if p is on different sides from p1 and p2 if (traits->point_is_left_low(p, p1) != traits->point_is_left_low(p, p2) ) { //check cv to see it p is above, below or on cv compare_y_at_x_res = traits->curve_compare_y_at_x(p, cv); switch (compare_y_at_x_res) { case EQUAL: found_edge = true; out_edge = curr; break; case SMALLER: //p is below cv //count cv number_of_edges_above_p ++; break; case LARGER: //p is above cv //don't count cv. continue break; default: //should not be equal CGAL_assertion (false); } } ++curr; } while (curr != last); //if number_of_edges_above_p is odd, then p is inside the face, //else - p is outside f. //to check if number_of_edges_above_p is odd/even, simply do bitwise AND operator with 1. return (number_of_edges_above_p & 1) ; } //---------------------------------------------------- /*! * Finds the intersection curve between the segment v - p and the face. (out_edge) * if there is more than one intersection - return the closest edge to p. * returns false if there is no intersection. * * \param p - the input point. * \param v - the input vertex * \param face - the input face * \param out_edge - the output edge */ template bool Pm_landmarks_point_location:: find_closest_intersection_in_face (const Point_2 & p, //input seg src Vertex_handle v, //input vertex const Ccb_halfedge_circulator & face, //input face Halfedge_handle & out_edge) const //output if on curve { #ifdef CGAL_LM_DEBUG std::cout << "inside find_closest_intersection_in_face. " << std::endl; #endif //CGAL_LM_DEBUG Point_2 vp = v->point(); Curve_2 seg(vp, p); //create a segment vh--p. bool is_found_intersection = false; bool is_inter_point_updated = false; Point_2 inter_point; //loop on all edges in this face Ccb_halfedge_circulator curr = face; Ccb_halfedge_circulator last = curr; bool p_in_x_range, v_in_x_range, p1_in_x_range, p2_in_x_range; bool check_real_intersection; do { Curve_2 cv = curr->curve(); Point_2 p1 = curr->source()->point(); Point_2 p2 = curr->target()->point(); #ifdef CGAL_LM_DEBUG std::cout << "curr = " << p1 << "-->" << p2 <point_in_x_range(cv, p); v_in_x_range = traits->point_in_x_range(cv, vp); p1_in_x_range = traits->point_in_x_range(seg, p1); p2_in_x_range = traits->point_in_x_range(seg, p2); // #ifdef CGAL_LM_DEBUG std::cout << "p_in_x_range = " << p_in_x_range << " , v_in_x_range = " << v_in_x_range <compare_distance(p, temp_inter_point, inter_point) == SMALLER) { // the temp_inter point is closer to p inter_point = temp_inter_point; out_edge = curr; } is_inter_point_updated = true; } } else { #ifdef CGAL_LM_DEBUG std::cout << "find_real_intersection returned false " < bool Pm_landmarks_point_location:: find_real_intersection (const Point_2 & p, //input seg src Vertex_handle v, //input vertex Halfedge_handle e, //input curve Point_2 & out_point) const //output intersection point { bool new_vertex, found_edge, change_side; Curve_2 seg(v->point(), p); //seg in the reffered segment vh - p. int num_intersections; Vertex_handle temp_vertex; #ifdef LM_CLOCK_DEBUG clock_t fi_time_start = clock();//time start #endif find_intersection (p, seg, e, num_intersections, change_side, found_edge, out_point, new_vertex, temp_vertex); #ifdef LM_CLOCK_DEBUG clock_t fi_time_end = clock();//time end double fi_period = (double) (fi_time_end - fi_time_start); clock_fi += fi_period; #endif //check results if (new_vertex) { std::cerr << "ERROR 7: new vertex in find_real_intersection " << std::endl; //ixx: @@@@ maybe later we will also have to deal with this case return (false); } if (found_edge) { std::cerr << "ERROR 8: new edge in find_real_intersection " << std::endl; //ixx: @@@@ maybe later we will also have to deal with this case return (false); } return (change_side) ; } CGAL_END_NAMESPACE #endif //CGAL_PM_LANDMARKS_POINT_LOCATION_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vector_2.h0000644000175000017500000000520511344301501026657 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Vector_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_VECTOR_2_H #define CGAL_VECTOR_2_H #include CGAL_BEGIN_NAMESPACE template class Vector_2 : public R_::Kernel_base::Vector_2 { typedef typename R_::RT RT; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Point_2 Point_2; typedef typename R_::Kernel_base::Vector_2 RVector_2; public: typedef R_ R; Vector_2() {} Vector_2(const Point_2& a, const Point_2& b) : RVector_2(a, b) {} Vector_2(const RVector_2& v) : RVector_2(v) {} Vector_2(const Segment_2 &s) : RVector_2(s) {} Vector_2(const Ray_2 &r) : RVector_2(r) {} Vector_2(const Line_2 &l) : RVector_2(l) {} Vector_2(const Null_vector &v) : RVector_2(v) {} Vector_2(const RT &x, const RT &y) : RVector_2(x,y) {} Vector_2(const RT &x, const RT &y, const RT &w) : RVector_2(x,y,w) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_VECTOR_2 template < class R > std::ostream & operator<<(std::ostream &os, const Vector_2 &v) { typedef typename R::Kernel_base::Vector_2 RVector_2; return os << static_cast(v); } #endif // CGAL_NO_OSTREAM_INSERT_VECTOR_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_VECTOR_2 template < class R > std::istream & operator>>(std::istream &is, Vector_2 &p) { typedef typename R::Kernel_base::Vector_2 RVector_2; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_VECTOR_2 CGAL_END_NAMESPACE #endif // CGAL_VECTOR_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/gmpxx.h0000644000175000017500000001265111344301500026341 0ustar debiandebian// Copyright (c) 2002,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/gmpxx.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_GMPXX_H #define CGAL_GMPXX_H #include #include #include #include #include #include // This file gathers the necessary adaptors so that the following // C++ number types that come with GMP can be used by CGAL : // - mpz_class // - mpq_class // - mpf_class support is commented out until to_interval() is implemented. // It is probably not very useful with CGAL anyway. // Note that GMP++ use the expression template mechanism, which makes things // a little bit complicated in order to make square(x+y) work for example. // Reading gmpxx.h shows that ::__gmp_expr is the mp[zqf]_class proper, // while ::__gmp_expr is the others "expressions". CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_false Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_true Has_exact_division; typedef Tag_false Has_exact_sqrt; }; template <> struct Rational_traits { typedef mpz_class RT; RT numerator (const mpq_class & r) const { return r.get_num(); } RT denominator (const mpq_class & r) const { return r.get_den(); } mpq_class make_rational(const RT & n, const RT & d) const { return mpq_class(n, d); } }; template < typename T, typename U > inline ::__gmp_expr sqrt(const ::__gmp_expr &e) { return ::sqrt(e); } template < typename T, typename U > inline double to_double(const ::__gmp_expr & e) { return ::__gmp_expr(e).get_d(); } template < typename T, typename U > inline bool is_finite(const ::__gmp_expr &) { return true; } template < typename T, typename U > inline bool is_valid(const ::__gmp_expr &) { return true; } template < typename T, typename U > inline io_Operator io_tag(const ::__gmp_expr &) { return io_Operator(); } template < typename T, typename U > std::pair to_interval (const ::__gmp_expr & z) { // Calls the functions below after dealing with the expression template. return to_interval(::__gmp_expr(z)); } inline std::pair to_interval (const mpz_class & z) { mpfr_t x; mpfr_init2 (x, 53); /* Assume IEEE-754 */ mpfr_set_z (x, z.get_mpz_t(), GMP_RNDD); double i = mpfr_get_d (x, GMP_RNDD); /* EXACT but can overflow */ mpfr_set_z (x, z.get_mpz_t(), GMP_RNDU); double s = mpfr_get_d (x, GMP_RNDU); /* EXACT but can overflow */ mpfr_clear (x); return std::pair(i, s); } inline std::pair to_interval (const mpq_class & q) { mpfr_t x; mpfr_init2 (x, 53); /* Assume IEEE-754 */ mpfr_set_q (x, q.get_mpq_t(), GMP_RNDD); double i = mpfr_get_d (x, GMP_RNDD); /* EXACT but can overflow */ mpfr_set_q (x, q.get_mpq_t(), GMP_RNDU); double s = mpfr_get_d (x, GMP_RNDU); /* EXACT but can overflow */ mpfr_clear (x); return std::pair(i, s); } // These are necessary due to expression-templates. template < typename T, typename U > inline ::__gmp_expr abs(const ::__gmp_expr& x) { return ::abs(x); } template < typename T, typename U > inline ::__gmp_expr square(const ::__gmp_expr& x) { return x*x; } template < typename T, typename U > inline Sign sign(const ::__gmp_expr & e) { return (Sign) ::sgn(e); } template < typename T, typename U1, typename U2 > inline Comparison_result compare(const ::__gmp_expr & e1, const ::__gmp_expr & e2) { // cmp returns any int value, not just -1/0/1... return (Comparison_result) CGAL_NTS sign(::cmp(e1, e2)); } template < typename T, typename U > inline bool is_zero(const ::__gmp_expr & e) { return ::sgn(e) == 0; } template < typename T, typename U > inline bool is_one(const ::__gmp_expr & e) { return e == 1; } template < typename T, typename U > inline bool is_positive(const ::__gmp_expr & e) { return ::sgn(e) > 0; } template < typename T, typename U > inline bool is_negative(const ::__gmp_expr & e) { return ::sgn(e) < 0; } CGAL_END_NAMESPACE #endif // CGAL_GMPXX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Timer.h0000644000175000017500000000664111344301501026261 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Timer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Matthias Baesken #ifndef CGAL_TIMER_H #define CGAL_TIMER_H 1 #include CGAL_BEGIN_NAMESPACE // SECTION: A Timer for User-Process Time // ======================================================================== // // DEFINITION // // A timer `t' of type Timer is an object with a state. It is either // running or it is stopped. The state is controlled with `t.start()' // and `t.stop()'. The timer counts the time elapsed since its creation // or last reset. It counts only the time where it is in the running // state. The time information is given in seconds. class Timer { private: double elapsed; double started; int interv; bool running; static bool m_failed; double user_process_time() const; // in seconds double compute_precision() const; // in seconds public: Timer() : elapsed(0.0), started(0.0), interv(0), running(false) {} void start(); void stop (); void reset(); bool is_running() const { return running; } double time() const; int intervals() const { return interv; } double precision() const; // Returns timer precison. Computes it dynamically at first call. // Returns -1.0 if timer system call fails, which, for a proper coded // test towards precision leads to an immediate stop of an otherwise // infinite loop (fixed tolerance * total time >= precision). double max() const; }; // ----------------------------------------------------------------------- // Member functions for Timer // =========================== inline void Timer::start() { CGAL_precondition( ! running); started = user_process_time(); running = true; ++ interv; } inline void Timer::stop() { CGAL_precondition( running); double t = user_process_time(); elapsed += (t - started); started = 0.0; running = false; } inline void Timer::reset() { interv = 0; elapsed = 0.0; if (running) { started = user_process_time(); ++ interv; } else { started = 0.0; } } inline double Timer::time() const { if (running) { double t = user_process_time(); return elapsed + (t - started); } return elapsed; } CGAL_END_NAMESPACE #endif // CGAL_TIMER_H // // EOF // ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposit0000644000175000017500000027743311344301501031470 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_TRAPEZOIDAL_DECOMPOSITION_2_H #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_H #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE /* ////////////////////////////////////////////////////////////////////////// class Trapezoidal_decomposition_2 parameters Traits,X_curve Description Implementation for a planar trapezoidal map also known as trapezoidal decomposition and vertical decomposition. For requirements on Traits and X_curve classes see Trapezoidal_decomposition_2 documentation. ////////////////////////////////////////////////////////////////////////// */ template < class Td_traits> class Trapezoidal_decomposition_2 { public: enum Locate_type {POINT=0,CURVE,TRAPEZOID,UNBOUNDED_TRAPEZOID=8} ; class Base_trapezoid_iterator; class In_face_iterator; friend class In_face_iterator; class Around_point_circulator; struct Unbounded {}; typedef Td_traits Traits; typedef const Traits& const_Traits_ref; typedef const Traits* const_Traits_ptr; typedef Trapezoidal_decomposition_2 Self; typedef const Self& const_Self_ref; typedef const Self* const_Self_ptr; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef typename Traits::X_curve_ptr curve_pointer; typedef typename Traits::X_curve_ref curve_ref; typedef typename Traits::X_curve_const_ref curve_const_ref; typedef typename Traits::X_trapezoid X_trapezoid; typedef typename Traits::X_trapezoid_ptr pointer; typedef typename Traits::X_trapezoid_ref reference; typedef typename Traits::X_trapezoid_const_ref const_ref; typedef std::list list_container; typedef std::vector vector_container; typedef std::vector X_curve_container; typedef In_face_iterator Iterator; typedef class Base_trapezoid_iterator Base_trapezoid_circulator; // friend class Td_traits::X_trapezoid; typedef Td_active_trapezoid Td_active_trapezoid; typedef Td_active_non_degenerate_trapezoid Td_active_non_degenerate_trapezoid; typedef Td_active_right_degenerate_curve_trapezoid Td_active_right_degenerate_curve_trapezoid; typedef Td_dag< X_trapezoid> Data_structure; typedef std::map map_nodes; // typedef std::hash_map hash_map_tr_ptr; typedef Trapezoid_handle_less Trapezoid_ptr_less; typedef std::map hash_map_tr_ptr; /* * class Base_trapezoid_iterator * member of Trapezoidal_decomposition_2 * Description Implements a basic Trapezoid iterator */ class Base_trapezoid_iterator { public: Base_trapezoid_iterator() : traits(0),curr(0) {}; Base_trapezoid_iterator(const_Traits_ptr traits_,pointer currt=0): traits(traits_),curr(currt) {} Base_trapezoid_iterator(const Base_trapezoid_iterator &it): traits(it.traits),curr(it.curr){;} Base_trapezoid_iterator & operator=(const Base_trapezoid_iterator &it) { traits=it.traits; curr=it.curr; return *this; } bool operator==(const Base_trapezoid_iterator &it) const { return (curr==it.curr ); } bool operator!=(const Base_trapezoid_iterator &it) const { return !operator==(it); } reference operator*() const { CGAL_precondition(curr); return *curr; } pointer operator->() const { return curr; } bool operator!() const { return curr==0; } protected: const_Traits_ptr traits; pointer curr; }; /* ********************************************************************* class In_face_iterator member of Trapezoidal_decomposition_2 Description Implements a Trapezoid iterator along a X_curve ********************************************************************* */ class In_face_iterator : public Base_trapezoid_iterator { #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Base_trapezoid_iterator::curr; using Base_trapezoid_iterator::traits; #endif protected: const X_curve& sep; public: In_face_iterator(const_Traits_ptr traits_,const X_curve& sepc,pointer currt=0) : Base_trapezoid_iterator(traits_,currt),sep(sepc){} In_face_iterator(const In_face_iterator &it) : Base_trapezoid_iterator((Base_trapezoid_iterator&)it),sep(it.sep){} bool operator==(const In_face_iterator &it) const { return ( Base_trapezoid_iterator::operator==(it) && traits->curve_equal(sep,it.sep) ); } /* destription: advances curr to one of the right neighbours according to the relation between the seperating X_curve and the right() trapezoid point. precoditions: sep doesn't intersect no existing edges except possibly on common end points. postconditions: if the rightest trapezoid was traversed curr is set to NULL. remark: if the seperator is vertical, using the precondition assumptions it follows that there is exactly one trapezoid to travel. */ In_face_iterator& operator++() { if (!curr) return *this;// end reached, do nothing! #ifndef CGAL_TD_DEBUG CGAL_warning(traits); #else CGAL_assertion(traits); #endif Point right(curr->right()); #ifdef CGAL_TD_DEBUG CGAL_assertion(curr->is_active()); CGAL_assertion(!traits->is_degenerate_point(*curr)); #endif if (!traits->is_degenerate(*curr)) { #ifndef NDEBUG #ifndef CGAL_TD_DEBUG CGAL_warning_code(Data_structure* tt=curr->get_node();) CGAL_warning(!tt->is_inner_node()); #else CGAL_assertion_code(Data_structure* tt=curr->get_node();) CGAL_assertion(tt); CGAL_assertion(!tt->is_inner_node()); #endif #endif // handle degeneracies if (!traits->point_is_left_low(curr->left(), traits->curve_righttop_most(sep))) curr=0; else { switch(traits->curve_compare_y_at_x(right, sep)) { case SMALLER: curr = curr->right_top_neighbour(); break; case LARGER: curr = curr->right_bottom_neighbour(); break; case EQUAL: // end reached curr=0; break; default: curr=0; break; } } } else // pass along degenerate X_curve. { #ifndef NDEBUG #ifndef CGAL_TD_DEBUG CGAL_warning_code(Data_structure* tt=curr->get_node();) CGAL_warning(tt); CGAL_warning(tt->is_inner_node()); #else CGAL_assertion_code(Data_structure* tt=curr->get_node();) CGAL_assertion(tt); CGAL_assertion(tt->is_inner_node()); #endif #endif curr=curr->right_bottom_neighbour(); if (curr) { while(traits->is_degenerate_point(*curr)) curr=curr->get_node()->left().operator->(); #ifndef CGAL_TD_DEBUG CGAL_warning(traits->is_degenerate_curve(*curr)); #else CGAL_precondition(traits->is_degenerate_curve(*curr)); #endif } } return *this; } In_face_iterator operator++(int) { In_face_iterator tmp = *this; ++*this; return tmp; } const X_curve& seperator() { return sep; } }; /* * class Around_point_circulator * member of Trapezoidal_decomposition_2 * Description Implements a Trapezoid circulator around a point */ class Around_point_circulator : public Base_trapezoid_circulator { #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Base_trapezoid_circulator::curr; using Base_trapezoid_circulator::traits; #endif protected: const Point& fixed; public: #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Base_trapezoid_circulator::operator!; #endif Around_point_circulator(const_Traits_ptr traits_, const Point & fixedp, pointer currt) : Base_trapezoid_iterator(traits_,currt),fixed(fixedp) {}; Around_point_circulator(const Around_point_circulator &it) : Base_trapezoid_iterator(it),fixed(it.fixed){}; Around_point_circulator &operator++() { if (operator!()) return *this; #ifndef CGAL_TD_DEBUG CGAL_warning(!curr->is_left_unbounded() && traits->point_equal(fixed,curr->left()) || !curr->is_right_unbounded() && traits->point_equal(fixed,curr->right())); #else CGAL_precondition(!curr->is_left_unbounded() && traits->point_equal(fixed,curr->left()) || !curr->is_right_unbounded() && traits->point_equal(fixed,curr->right())); #endif curr=operator->(); return *this; } Around_point_circulator operator++(int) { Around_point_circulator tmp = *this; ++*this; return tmp; } pointer operator[](int i) const { Around_point_circulator c=*this; while(i-->0) c++; return c.curr; } /* returns reference to the next trapezoid on a clockwise orientation rotation with centre taken as the fixed point preconditions: ciruclator is not empty*/ reference operator*() const { CGAL_precondition(!operator!()); return *operator->(); } /* returns pointer to the next trapezoid on a clockwise orientation rotation with centre taken as the fixed point */ pointer operator->() const { pointer cand; if (operator!()) return curr; cand=is_right_rotation() ? curr->right_top_neighbour() : curr->left_bottom_neighbour(); if (traits->is_degenerate_curve(*cand)) return cand; // cand was splited by a point while(traits->is_degenerate_point(*cand)) cand=traits->point_is_left_low(cand->left(),fixed)? // move right using data structure cand->get_node()->right().operator->(): // move left using data structure cand->get_node()->left().operator->(); return cand; } bool is_valid() const { return (!curr)||(!curr->is_left_unbounded() && traits->point_equal(fixed,curr->left())) || (!curr->is_right_unbounded() && traits->point_equal(fixed,curr->right())); } /* description: inserts the input trapezoid between the current trapezoid and the next trapezoid on a clockwise orientation rotation with centre taken as the fixed point. preconditions: current trapezoid exist input trapezoid is adjacent to fixed point */ void insert(reference tr) { #ifndef CGAL_TD_DEBUG CGAL_precondition(curr); CGAL_warning(!tr.is_left_unbounded() && traits->point_equal(tr.left(), fixed) || !tr.is_right_unbounded()&& traits->point_equal(tr.right(), fixed)); #else CGAL_precondition(curr); CGAL_precondition(!tr.is_left_unbounded() && traits->point_equal(tr.left(),fixed) || !tr.is_right_unbounded() && traits->point_equal(tr.right(),fixed)); #endif if (!tr.is_left_unbounded()&&traits->point_equal(tr.left(),fixed)) tr.set_lb(operator->()); else tr.set_rt(operator->()); if (is_right_rotation()) curr->set_rt(&tr); else curr->set_lb(&tr); } /* precondition: curr!=NULL */ void remove() { #ifndef CGAL_TD_DEBUG CGAL_precondition(curr); CGAL_warning(!curr->is_left_unbounded() && traits->point_equal(curr->left(), fixed) || !curr->is_right_unbounded() && traits->point_equal(curr->right(), fixed)); #else CGAL_precondition(curr); CGAL_warning(!curr->is_left_unbounded() && traits->point_equal(curr->left(),fixed) || !curr->is_right_unbounded() && traits->point_equal(curr->right(),fixed)); #endif Around_point_circulator old=*this; old++; pointer next=old.operator->(); // handle 1-cycle and 2-cycles seperately if (curr!=next) { } // 2-cycle else if (*this!=old) { next=curr; } // 1-cycle else { if (is_right_rotation()) curr->set_rt(0); else curr->set_lb(0); curr=0; return; } if (is_right_rotation()) curr->set_rt(next); else curr->set_lb(next); if (old.is_right_rotation()) old[0]->set_rt(0); else old[0]->set_lb(0); } void replace(reference tr) { #ifndef CGAL_TD_DEBUG CGAL_precondition(curr); CGAL_warning(!curr->is_left_unbounded() && traits->point_equal(curr->left(),fixed) || !curr->is_right_unbounded() && traits->point_equal(curr->right(),fixed)); #else CGAL_precondition(curr); CGAL_precondition(!curr->is_left_unbounded() && traits->point_equal(curr->left(),fixed) || !curr->is_right_unbounded() && traits->point_equal(curr->right(),fixed)); #endif Around_point_circulator old=*this; old++; pointer next=old.operator->(); // handle 1-cycle and 2-cycles seperately if (curr!=next) { } // 2-cycle else if (*this!=old) { next=curr; } // 1-cycle else { curr=&tr; if (is_right_rotation()) curr->set_rt(curr); else curr->set_lb(curr); return; } if (!tr.is_right_unbounded()&&traits->point_equal(tr.right(),fixed)) tr.set_rt(next); else tr.set_lb(next); if (is_right_rotation()) curr->set_rt(&tr); else curr->set_lb(&tr); } bool is_right_rotation() const { return !curr->is_right_unbounded() && traits->point_equal(curr->right(),fixed); } const Point& fixed_point() const { return fixed; } }; ////////////////////////////////////////////// //Trapezoidal_decomposition_2 member functions: ////////////////////////////////////////////// #ifndef CGAL_TD_DEBUG protected: #else public: #endif /* input: X_curve, two Trapezoidal maps that corespond the the X_curve's source degenerate trapezoid and the X_curve's target degenerate trapezoid output: trapezoid iterator Description: the output (trapezoid iterator) is initialized with the leftmost and rightmost (non degenerate) trapezoids in the trapezoid interval that corresponds to the input from either the top side or the bottom side, depending on the up flag. preconditions: There exist non degenerate trapezoids between the roots of the input DS's */ In_face_iterator follow_curve(const Data_structure& left_end_point, const X_curve& cv, Comparison_result up) const { #ifndef CGAL_TD_DEBUG CGAL_warning(traits); CGAL_warning(traits->is_degenerate_point(*left_end_point)); if (!(traits->point_equal(traits->curve_leftlow_most(cv), left_end_point->left()))) { CGAL_warning(traits->point_equal(traits->curve_leftlow_most(cv), left_end_point->left())); } #else CGAL_assertion(traits); CGAL_precondition(traits->is_degenerate_point(*left_end_point)); CGAL_precondition(traits->point_equal(traits->curve_leftlow_most(cv), left_end_point->left())); #endif const Point& p1=left_end_point->left(); Data_structure left=left_end_point.right(); search_using_data_structure(left,traits,p1,&cv,up); return In_face_iterator(traits,cv,left.operator->()); } /* input: X_trapezoid reference X_trapezoid pointer output: bool preconditions: the referenced trapezoid is to the right of the pointered trapezoid description: if the two input Trapezoids can be merged they are , with one copy destroyed(the right one). postconfition: The reference points to the right trapezoid The returned value is true iff merging took place. */ bool merge_if_possible(pointer left,pointer right) { if (left && right && traits->trapezoid_top_curve_equal(*left,*right) && traits->trapezoid_bottom_curve_equal(*left,*right) && traits->point_equal(left->right(),right->left())) { left->merge_trapezoid(*right); #ifdef CGAL_TD_DEBUG CGAL_assertion(left->is_right_unbounded()==right->is_right_unbounded()); #endif return true; } return false; } /* Description: splits the trapezoid with vertical line through p */ /* Precondition: The trapezoid is active and contains p in its closure */ Data_structure& split_trapezoid_by_point( Data_structure& tt, const Point& p, const X_curve& cv_bottom_ray_shoot, const X_curve& cv_top_ray_shoot ) { #ifndef CGAL_TD_DEBUG CGAL_warning(!!tt); if (!tt) return tt; #else CGAL_precondition(!!tt); #endif reference curr=*tt; pointer lb=curr.left_bottom_neighbour(), lt=curr.left_top_neighbour(), rb=curr.right_bottom_neighbour(), rt=curr.right_top_neighbour(); #ifndef CGAL_TD_DEBUG CGAL_warning(curr.is_active()); CGAL_warning(traits->is_in_closure(curr,p)); #else CGAL_precondition(curr.is_active()); if (!traits->is_in_closure(curr,p)) { std::cout << "\ncurr="; write(std::cout,curr,*traits) << "\tp=" << p; } CGAL_precondition(traits->is_in_closure(curr,p)); #endif // left and right are set to the point itself, // bottom and top are set to the ray shooting resulting curves at this // stage. X_trapezoid sep(p,p,cv_bottom_ray_shoot,cv_top_ray_shoot); Data_structure leftDS = Data_structure(X_trapezoid(curr.left(), p, curr.bottom(), curr.top(), curr.boundedness() & (CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED | CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED | CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED) )); Data_structure rightDS=Data_structure(X_trapezoid(p, curr.right(), curr.bottom(),curr.top(), curr.boundedness()&(CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED | CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED | CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED) )); reference left = *leftDS; reference right = *rightDS; #ifndef CGAL_TD_DEBUG CGAL_warning(traits->trapezoid_top_curve_equal(left,right)); CGAL_warning(traits->trapezoid_bottom_curve_equal(left,right)); CGAL_warning(left.is_left_unbounded()==curr.is_left_unbounded()); CGAL_warning(right.is_right_unbounded()==curr.is_right_unbounded()); #else CGAL_warning(traits->trapezoid_top_curve_equal(left,right)); CGAL_warning(traits->trapezoid_bottom_curve_equal(left,right)); CGAL_assertion(left.is_left_unbounded()==curr.is_left_unbounded()); CGAL_assertion(right.is_right_unbounded()==curr.is_right_unbounded()); #endif if (!traits->is_degenerate_curve(curr)) { left.init_neighbours(lb,lt,&right,&right); right.init_neighbours(&left,&left,rb,rt); if (lb) lb->set_rb(&left); if (lt) lt->set_rt(&left); if (rb) rb->set_lb(&right); if (rt) rt->set_lt(&right); } else { left.set_bottom(cv_bottom_ray_shoot); left.set_top(cv_bottom_ray_shoot); right.set_bottom(cv_top_ray_shoot); right.set_top(cv_top_ray_shoot); left.set_rt(&right); left.set_lb(lb); left.set_rb(0); right.set_lb(&left); right.set_rt(rt); right.set_rb(rb); } tt.replace(sep,leftDS,rightDS); const Data_structure *leftPtr=&tt.left(), *rightPtr=&tt.right(); (*leftPtr)->set_node((Data_structure*)leftPtr); (*rightPtr)->set_node((Data_structure*)rightPtr); #ifdef CGAL_TD_DEBUG CGAL_assertion(&left==leftDS.operator->()); CGAL_assertion(&right==rightDS.operator->()); CGAL_assertion(left==*leftDS); CGAL_assertion(right==*rightDS); CGAL_assertion(left==*tt.left()); CGAL_assertion(right==*tt.right()); /* CGAL_assertion(left.get_node()==&tt.left()); CGAL_assertion(right.get_node()==&tt.right()); */ CGAL_assertion(**left.get_node()==left); CGAL_assertion(**right.get_node()==right); #endif return tt; } /* Description: the opposite operation for spliting the trapezoid with vertical line through p */ /* Precondition: The root trapezoid is degenerate point (p) and is active */ void remove_split_trapezoid_by_point( Data_structure& tt, const Point& p) { #ifndef CGAL_TD_DEBUG if (!tt|| !tt->is_active()|| !traits->is_degenerate_point(*tt)|| !traits->point_equal(tt->left(),p) ) { CGAL_warning(!!tt); CGAL_warning(tt->is_active()); CGAL_warning(traits->is_degenerate_point(*tt)); CGAL_warning(traits->point_equal(tt->left(),p)); return; } #else CGAL_precondition(!!tt); CGAL_precondition(tt->is_active()); CGAL_precondition(traits->is_degenerate_point(*tt)); CGAL_precondition(traits->point_equal(tt->left(),p)); #endif Data_structure tt_left=tt.left(), tt_right=tt.right(); search_using_data_structure(tt_left,traits,p,0); search_using_data_structure(tt_right,traits,p,0); #ifndef CGAL_TD_DEBUG merge_if_possible(&*tt_left,&*tt_right); CGAL_warning(!tt_left.is_inner_node()); CGAL_warning(!tt_right.is_inner_node()); CGAL_warning(tt_left->is_right_unbounded() == tt_right->is_right_unbounded()); #else std::cout << "\nremove_split_trapezoid_by_point(){"; std::cout << "\ntt_left="; write(std::cout,*tt_left,*traits); std::cout << "\ntt_right="; write(std::cout,*tt_right,*traits) << "}" << std::endl; bool merge_if_poss_left_right = merge_if_possible(&*tt_left,&*tt_right); std::cout << "\n->"; write(std::cout,*tt_left,*traits) << std::endl; CGAL_postcondition(merge_if_poss_left_right); CGAL_assertion(!tt_left.is_inner_node()); CGAL_assertion(!tt_right.is_inner_node()); CGAL_assertion(tt_left->is_right_unbounded() == tt_right->is_right_unbounded()); CGAL_assertion(**tt_left->get_node()==*tt_left); #endif tt_right->remove(&tt_left); // mark root as deleted tt->remove(); } /* Description: splits the trapezoid that corresponds to the root of the trapezoidal tree with an input edge cv*/ /* Precondition: The root trapezoid is active cv is non degenerate The root trapezoid is devided by cv or is equal to it and is vertical. */ Data_structure& split_trapezoid_by_curve( Data_structure& tt, pointer& prev, pointer& prev_bottom, pointer& prev_top, const X_curve& cv) { #ifndef CGAL_TD_DEBUG CGAL_warning(traits); #else CGAL_assertion(traits); #endif reference currt=*tt; Point p[2]; int i= traits->point_is_left_low( p[0]=traits->curve_source(cv), p[1]=traits->curve_target(cv) ) ? 0 : 1; // sets left and right accoring to curves source's and target's positions // sets bottom and top to X_curve itself X_trapezoid sep(p[i],p[1-i],cv,cv); /* creates a one-way path for all the X_curve-degenerate trapezoids that represent the X_curve. right_bottom_neighbour() is used to retrieve the next on path information */ Data_structure topBT = Data_structure(X_trapezoid(currt.left(), currt.right(), cv, currt.top(), currt.boundedness() & (CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED | CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED| CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED))), bottomBT = Data_structure(X_trapezoid(currt.left(),currt.right(), currt.bottom(), cv, currt.boundedness() & (CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED| CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED| CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED))); reference bottom=*bottomBT; reference top=*topBT; top.init_neighbours(prev_top, currt.left_top_neighbour(), 0, currt.right_top_neighbour()); bottom.init_neighbours(currt.left_bottom_neighbour(), prev_bottom,currt.right_bottom_neighbour(),0); if (prev_bottom) prev_bottom->set_rt(&bottom); if (prev_top) prev_top->set_rb(&top); if (currt.left_bottom_neighbour()) currt.left_bottom_neighbour()->set_rb(&bottom); if (currt.left_top_neighbour()) currt.left_top_neighbour()->set_rt(&top); if (currt.right_bottom_neighbour()) currt.right_bottom_neighbour()->set_lb(&bottom); if (currt.right_top_neighbour()) currt.right_top_neighbour()->set_lt(&top); tt.replace(sep,bottomBT,topBT); const Data_structure *bottomPtr=&tt.left(), *topPtr=&tt.right(); (*bottomPtr)->set_node((Data_structure*)bottomPtr); (*topPtr)->set_node((Data_structure*)topPtr); if (prev) prev->set_rb(tt.operator->()); prev_bottom=(*bottomPtr).operator->(); prev_top=(*topPtr).operator->(); prev=tt.operator->(); return tt; } /* replace X_curve-point adjacency in the data structure with a new one precondition: the X_curve represented by t is top-right relative to the point represented by sep if and only if top=true */ void replace_curve_at_point_using_geometry(reference t, reference sep, bool cv_top_right=true) { Point p(sep.left()); X_curve cv(t.top()); Around_point_circulator circ(traits,p,cv_top_right ? sep.right_top_neighbour() : sep.left_bottom_neighbour()); if (circ.operator->()) { if (cv_top_right) while(traits->curves_compare_y_at_x_from_top(circ->top(),cv,p)!=EQUAL) circ++; else while(traits->curves_compare_y_at_x_from_bottom(circ->bottom(), cv, p) != EQUAL) circ++; circ.replace(t); } } void insert_curve_at_point_using_geometry(reference sep, reference end_point) { #ifndef CGAL_TD_DEBUG CGAL_warning(traits); CGAL_warning(traits->is_degenerate_point(end_point)); CGAL_warning(traits->is_degenerate_curve(sep)); CGAL_warning(traits->point_equal(end_point.left(),sep.right()) || traits->point_equal(end_point.left(),sep.left())); #else CGAL_assertion(traits); CGAL_precondition(traits->is_degenerate_point(end_point)); CGAL_precondition(traits->is_degenerate_curve(sep)); CGAL_precondition(traits->point_equal(end_point.left(),sep.right()) || traits->point_equal(end_point.left(),sep.left())); #endif /* update (in this order) end_point.left_bottom_neighbour() if no curves adjacent to the point eminating toward up or right exist returns null, otherwise return the first X_curve sweeped using a counter clockwise sweep starting from up direction not including. end_point.right_top_neighbour() if no curves adjacent to the point eminating toward bottom or left exist returns null, otherwise return the first X_curve sweeped using a counter clockwise sweep starting from bottom direction not including. sep.right_top_neighbour() next clockwise degenerate_curve around rightmost end_point (possibly himself) sep.left_bottom_neighbour() next clockwise degenerate_curve around leftmost end_point (possibly himself) */ const X_curve& cv=sep.top(); const Point& p=end_point.left(); pointer rt = end_point.right_top_neighbour(), lb = end_point.left_bottom_neighbour(); if(!traits->point_equal(end_point.left(),sep.right())) { if (!rt && !lb) // empty circulator { end_point.set_rt(&sep); sep.set_lb(&sep); } else { /* set circ[0] to first X_curve on a counter clockwise sweep starting at cv */ Around_point_circulator circ(traits,p,rt ? rt : lb),stopper=circ; // if !rt set circ to lb // otherwise advance as required #ifdef CGAL_TD_DEBUG Around_point_circulator first_circ(circ); #endif while(traits->curves_compare_y_at_x_from_top(circ->top(),cv,p) ==SMALLER) { circ++; if (circ==stopper) break; #ifdef CGAL_TD_DEBUG CGAL_assertion(first_circ!=circ); CGAL_assertion(circ->is_active()); #endif } #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curves_compare_y_at_x_from_top(circ->top(), cv, p) != EQUAL); #endif circ.insert(sep); // set end_point.left_bottom_neighbour() // set end_point.right_top_neighbour(); if (lb) { Around_point_circulator lb_circ(traits,p,lb); if (!rt) end_point.set_rt(lb); if (lb_circ.operator->()==&sep) end_point.set_lb(&sep); } else { if (traits->curves_compare_y_at_x_from_bottom(rt->top(), cv, p) == SMALLER) end_point.set_rt(&sep); } } } else { if (!rt && !lb) // empty circulator { end_point.set_lb(&sep); sep.set_rt(&sep); } else { /* set circ[0] to first X_curve on a counter clockwise sweep starting at cv */ Around_point_circulator circ(traits,p,lb ? lb : rt),stopper=circ; // if !lb set circ to rt // otherwise advance as required while (traits->curves_compare_y_at_x_from_bottom(circ->top(),cv,p) == SMALLER) { circ++; if (circ==stopper) break; } #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curves_compare_y_at_x_from_bottom(circ->top(), cv, p) != EQUAL); #endif circ.insert(sep); if (rt) // set end_point.left_bottom_neighbour() { Around_point_circulator rt_circ(traits,p,rt); if (!lb) end_point.set_lb(rt); if (rt_circ.operator->()==&sep) end_point.set_rt(&sep); } else { // set end_point.right_top_neighbour(); if(traits->curves_compare_y_at_x_from_top(lb->top(),cv,p) ==SMALLER) end_point.set_lb(&sep); } } } } /* description: Update top(),bottom() for trapezoid Update rt,lb remarks: The point degenerate trapezoid representing a point p holds as its top and bottom curves the output for a vertical ray shoot quiries immidiately below the point toward up and immediately above the point toward down respectively. optimization: Each degenerate X_curve trapezoid eminating from the point p holds a pointer to the next trapezoid in a clockwise sweep around p(possibly to itself). This pointer is stored in rt or lb depending on the trapezoid is top right or bottom left of p. For the trapezoid representing p rt and lb hold the previous X_curve degenerate trapezoid in a clockwise sweep to the first top right and bottom left respectively. */ void remove_curve_at_point_using_geometry(const_ref sep,reference end_point) { #ifndef CGAL_TD_DEBUG CGAL_warning(traits); CGAL_warning(traits->is_degenerate_point(end_point)); CGAL_warning(traits->is_degenerate_curve(sep)); CGAL_warning(traits->point_equal(end_point.left(),sep.right()) || traits->point_equal(end_point.left(),sep.left())); CGAL_warning(end_point.is_active()); CGAL_warning(sep.is_active()); #else CGAL_assertion(traits); CGAL_precondition(traits->is_degenerate_point(end_point)); CGAL_precondition(traits->is_degenerate_curve(sep)); CGAL_precondition(traits->point_equal(end_point.left(),sep.right()) || traits->point_equal(end_point.left(),sep.left())); CGAL_precondition(end_point.is_active()); CGAL_precondition(sep.is_active()); #endif /* update (in this order) end_point.left_bottom_neighbour() if no curves adjacent to the point eminating toward up or right exist returns null, otherwise return the first X_curve sweeped using a counter clockwise sweep starting from up direction not including. end_point.right_top_neighbour() if no curves adjacent to the point eminating toward bottom or left exist returns null, otherwise return the first X_curve sweeped using a counter clockwise sweep starting from bottom direction not including. sep.right_top_neighbour() next clockwise degenerate_curve around rightmost end_point (possibly himself) sep.left_bottom_neighbour() next clockwise degenerate_curve around leftmost end_point (possibly himself) */ const X_curve& cv=sep.top(); const Point& p=end_point.left(); Around_point_circulator prev_top(traits,p,end_point.right_top_neighbour()), prev_bottom(traits,p,end_point.left_bottom_neighbour()); // update bottom if(traits->curve_equal(cv,end_point.bottom())) { Around_point_circulator bottom=(!!prev_bottom) ? prev_bottom : prev_top; bottom++; #ifdef CGAL_TD_DEBUG CGAL_assertion(!!bottom); #endif if (!bottom->is_bottom_unbounded()) end_point.set_bottom(bottom->bottom()); else end_point.set_bottom_unbounded(); } // update top if(traits->curve_equal(cv,end_point.top())) { Around_point_circulator top=(!!prev_top) ? prev_top : prev_bottom; top++; #ifdef CGAL_TD_DEBUG CGAL_assertion(!!top); #endif if (!top->is_top_unbounded()) end_point.set_top(top->top()); else end_point.set_top_unbounded(); } //update right top neighbour and left bottom neighbour bool b=traits->point_is_left_low(p,sep.right()); Around_point_circulator circ(traits,p,b ? end_point.right_top_neighbour() : end_point.left_bottom_neighbour()); #ifdef CGAL_TD_DEBUG CGAL_precondition(!!circ); #endif while(*circ!=sep)circ++; pointer removed=circ.operator->(); circ.remove(); if(!!circ) { pointer effective_curr=circ[0]; if (end_point.right_top_neighbour()==removed) end_point.set_rt(effective_curr); if (end_point.left_bottom_neighbour()==removed) end_point.set_lb(effective_curr); Around_point_circulator rt_circ(traits, p, end_point.right_top_neighbour()); if (!!rt_circ) { rt_circ++; if (rt_circ.is_right_rotation()) end_point.set_rt(0); } Around_point_circulator lb_circ(traits, p, end_point.left_bottom_neighbour()); if (!!lb_circ) { lb_circ++; if (!lb_circ.is_right_rotation()) end_point.set_lb(0); } } else { end_point.set_rt(0); end_point.set_lb(0); } } /*update tr.bottom() vertical_ray_shoot downward from tr tr.top() vertical_ray_shoot upward from tr */ reference insert_curve_at_point_using_geometry(const X_curve & cv, const Point& p, pointer & tr, const Locate_type & lt) { CGAL_assertion(traits); CGAL_precondition(lt==POINT); if (traits->curves_compare_y_at_x_from_top(cv,tr->top(),p)==SMALLER) tr->set_top(cv); if (traits->curves_compare_y_at_x_from_bottom(cv,tr->bottom(),p)==SMALLER) tr->set_bottom(cv); return *tr; } reference insert_curve_at_point_using_data_structure(const X_curve & cv, const Point & p, pointer & tr, const Locate_type & lt) { CGAL_precondition(lt==TRAPEZOID || lt==UNBOUNDED_TRAPEZOID); Data_structure *tt=tr->get_node(); #ifdef CGAL_TD_DEBUG CGAL_assertion(tr->get_node()); #endif return *split_trapezoid_by_point(*tt,p,cv,cv); //return *tr; } void replace_curve_at_point_using_geometry(const X_curve& old_cv, const X_curve& new_cv,reference sep) { #ifdef CGAL_TD_DEBUG CGAL_precondition(traits->is_degenerate_point(sep)); #endif if (!sep.is_top_unbounded() && traits->curve_equal(sep.top(), old_cv)) sep.set_top(new_cv); if (!sep.is_bottom_unbounded() && traits->curve_equal(sep.bottom(), old_cv)) sep.set_bottom(new_cv); } /* update geometric boundary(top and bottom) for trapezoids traveled along an iterator till end reached precondition: end==0 or end is on the path of the iterator postcondition: end is pointer to the last trapezoid encountered,if any */ void replace_curve_using_geometry(In_face_iterator & it, const X_curve & old_cv, const X_curve & new_cv,pointer & end) { pointer last=0; while (it.operator->()!=end) { if (!it->is_top_unbounded() && traits->curve_equal(it->top(),old_cv)) it->set_top(new_cv); if (!it->is_bottom_unbounded() && traits->curve_equal(it->bottom(),old_cv)) it->set_bottom(new_cv); last=it.operator->(); ++it; } end=last; } /* description: advances input Data structure using data structure,input point p and possibly X_curve cv till p is found(if cv hadn't been given) cv is found(if cv was given) or leaf node reached postcondition: output is the closest active trapezoid to p/cv remark: use this function with care! */ /*static */ Locate_type search_using_data_structure(Data_structure& curr,const_Traits_ptr traits, const Point& p,const X_curve* cv, Comparison_result up = EQUAL) const { const Point* pp; const X_curve* pc; #ifdef CGAL_TD_DEBUG pointer old = NULL; #endif while(true) { #ifdef CGAL_TD_DEBUG // unbounded loop CGAL_assertion(curr.operator->() != old); old = curr.operator->(); #endif if (traits->is_degenerate_point(*curr)) // point node conditional (separation) { // extract point from trapezoid pp = &curr->left(); if (traits->point_is_left_low(p, *pp)) { curr = curr.left(); continue; } else if (traits->point_is_left_low(*pp, p)) { curr = curr.right(); continue; } else if (traits->point_equal(*pp, p)) { if (!cv) { if ( up == EQUAL ) { // point found! if (curr->is_active()) return POINT; curr = curr.left(); } else if ( up == LARGER ) { // vertical ray shut up curr = curr.right(); } else /*if ( up == SMALLER ) */ { curr = curr.left(); // vertical ray shut down } continue; } else { #ifndef CGAL_TD_DEBUG CGAL_warning( traits->point_equal(traits->curve_leftlow_most(*cv), p) || traits->point_equal(traits->curve_righttop_most(*cv), p)); #else CGAL_assertion( traits->point_equal(traits->curve_leftlow_most(*cv), p) || traits->point_equal(traits->curve_righttop_most(*cv), p)); #endif curr = traits->point_equal(traits->curve_leftlow_most(*cv), p) ? curr.right() : curr.left(); // (Oren 14/4/02) ?? continue; } } else { #ifndef CGAL_TD_DEBUG CGAL_warning(traits->point_is_left_low(p,*pp) || traits->point_is_left_low(*pp,p) || traits->point_equal(*pp,p)); #else CGAL_assertion(traits->point_is_left_low(p,*pp) || traits->point_is_left_low(*pp,p) || traits->point_equal(*pp,p)); #endif return Locate_type(); } } if (traits->is_degenerate_curve(*curr)) { // CURVE SEPRATION pc = &curr->top(); Comparison_result cres = traits->curve_compare_y_at_x(p, *pc); if (cres == SMALLER) { curr = curr.left(); continue; } else if (cres == LARGER) { curr = curr.right(); continue; } else { // p on CURVE #ifndef CGAL_TD_DEBUG CGAL_warning(cres == EQUAL && !traits->point_is_right(p,traits->curve_rightmost(*pc))&& !traits->point_is_left(p,traits->curve_leftmost(*pc))); #else CGAL_postcondition(cres == EQUAL && !traits->point_is_right(p,traits->curve_rightmost(*pc))&& !traits->point_is_left(p,traits->curve_leftmost(*pc))); #endif if (!cv) { // For a vertical curve, we always visit it after visiting // one of its endpoints. if ((up == EQUAL) || traits->is_vertical(*curr)) { //std::cout << "EQUAL or VERTICAL" << std::endl; if (curr->is_active()) return CURVE; curr = curr.left(); } else if (up == LARGER) { curr = curr.right(); } else /* if (up==SMALLER) */ { curr = curr.left(); } continue; } else { #ifndef CGAL_TD_DEBUG CGAL_warning(traits->point_equal (traits->curve_leftlow_most(*cv), traits->curve_leftlow_most(*pc)) || traits->point_equal (traits->curve_righttop_most(*cv), traits->curve_righttop_most(*pc))); #else if (!(traits->point_equal (traits->curve_leftlow_most(*cv), traits->curve_leftlow_most(*pc))|| traits->point_equal (traits->curve_righttop_most(*cv), traits->curve_righttop_most(*pc)))) { std::cerr << "\npc " << *pc; std::cerr << "\ncv " << *cv << std::endl; CGAL_assertion(traits->point_equal (traits->curve_leftlow_most(*cv), traits->curve_leftlow_most(*pc)) || traits->point_equal (traits->curve_righttop_most(*cv), traits->curve_righttop_most(*pc))); } #endif Comparison_result res = traits->point_equal(traits->curve_leftlow_most(*cv), traits->curve_leftlow_most(*pc)) ? traits->curves_compare_y_at_x_from_top(*pc,*cv,p) : traits->curves_compare_y_at_x_from_bottom(*cv,*pc,p); switch(res) { case LARGER: curr = curr.right(); break; case SMALLER: curr = curr.left(); break; case EQUAL: switch(up) { case LARGER: curr = curr.right(); break; case SMALLER: curr = curr.left(); break; case EQUAL: if (curr->is_active()) return CURVE; curr = curr.left(); break; #ifdef CGAL_TD_DEBUG default: CGAL_assertion(up==LARGER||up==SMALLER||up==EQUAL); return Locate_type(); #endif } break; #ifdef CGAL_TD_DEBUG default: CGAL_assertion(res == LARGER || res == SMALLER || res == EQUAL); return Locate_type(); #endif } } } } else { // !is_degenerate() if (curr->is_active()) return curr->is_unbounded() ? UNBOUNDED_TRAPEZOID : TRAPEZOID; curr = curr.left(); continue; } } } Data_structure container2data_structure(map_nodes& ar, int left, int right) const { #ifndef CGAL_TD_DEBUG CGAL_warning(traits); #else CGAL_assertion(traits); #endif if (right>left) { int d=(int)CGAL_CLIB_STD::floor((double(right+left))/2); // Replacing operator [] of map with find to please MSVC 7 Point p = (ar.find(d)->second)->right(); //Point p=ar[d]->right(); Data_structure curr= Data_structure( X_trapezoid(&p,&p,0,0), container2data_structure(ar,left,d), container2data_structure(ar,d+1,right) ); curr.left()->set_node((Data_structure*)&curr.left()); curr.right()->set_node((Data_structure*)&curr.right()); curr->set_node(&curr);// fake temporary node curr->remove(); // mark as deleted curr->set_node(0); return curr; } else // Replacing operator [] of map with find to please MSVC 7 return ar.find(left)->second; //return ar[left]; } /*============================================== Trapezoidal_decomposition_2 public member functions ==============================================*/ public: Trapezoidal_decomposition_2(bool rebuild=true) : depth_threshold(CGAL_TD_DEFAULT_DEPTH_THRESHOLD), size_threshold(CGAL_TD_DEFAULT_SIZE_THRESHOLD) {init();set_needs_update(rebuild);} Trapezoidal_decomposition_2(const double& depth_th,const double& size_th) : depth_threshold(depth_th),size_threshold(size_th) {init();set_needs_update(rebuild);} Trapezoidal_decomposition_2(const_Self_ref td) : needs_update_(td.needs_update_), number_of_curves_(td.number_of_curves_), traits(td.traits), last_cv(NULL), prev_cv(NULL), depth_threshold(td.depth_threshold), size_threshold(td.size_threshold) { hash_map_tr_ptr htr; /*! \todo allocate hash_map size according to content. * \todo change vector<> to in_place_list and pointer hash to trapezoidal * hash.. */ vector_container vtr; int sz; Td_active_trapezoid pr; sz=X_trapezoid_filter(vtr, &td.get_data_structure()); //! \todo Reduce the 3 iterations to 1 (or 2) iterator. // First iteration: filter out the active trapezoids. typename vector_container::const_iterator it; for (it=vtr.begin(); it!=vtr.end(); ++it) { Data_structure* ds_copy=new Data_structure(*it); const X_trapezoid* cur=&*it; X_trapezoid* tr_copy=&*(*ds_copy); tr_copy->set_node(ds_copy); CGAL_assertion(&*(*tr_copy->get_node())==tr_copy); ds_copy->set_depth(cur->get_node()->depth()); // We cheat a little with the depth. htr.insert(typename hash_map_tr_ptr::value_type(cur, tr_copy)); // Second iteration: generate new copies of trapezoids and nodes. } for (it=vtr.begin(); it!=vtr.end(); ++it) { const X_trapezoid* cur=&*it; X_trapezoid* tr_copy=htr.find(cur)->second; const Data_structure *child; CGAL_assertion(tr_copy); tr_copy->set_rt(cur->get_rt() ? htr.find(cur->get_rt())->second : NULL); tr_copy->set_rb(cur->get_rb() ? htr.find(cur->get_rb())->second : NULL); tr_copy->set_lt(cur->get_lt() ? htr.find(cur->get_lt())->second : NULL); tr_copy->set_lb(cur->get_lb() ? htr.find(cur->get_lb())->second : NULL); if (cur->get_node()->is_inner_node()) { child=&cur->get_node()->right(); while (child && child->is_inner_node() && !pr(*(*child))) child=&child->left(); tr_copy->get_node()->set_right(*child); child=&cur->get_node()->left(); while (child && child->is_inner_node() && !pr(*(*child))) child=&child->left(); tr_copy->get_node()->set_left(*child); } // Third iteration: generate links in-between trapezoids // and in-between nodes . } DS=htr.find(&*(*td.DS))->second->get_node(); } /* TODO: Should we add another constructor with non const argument that rebuild the trapezoidal decomposition prior to copy construction? */ virtual ~Trapezoidal_decomposition_2() { #ifndef CGAL_TD_DEBUG CGAL_warning(DS); if (!DS) return; #else CGAL_assertion(DS); #endif delete DS; } /* Input: X_curve Output: if X_curve or twin already inserted the latter is returned. otherwise the left-low most edge-degenerate trapezoid that represents the input X_curve is returned Remark: Given an edge-degenerate trapezoid representing a X_curve, all the other trapezoids representing the X_curve can be extracted via moving continously to the left and right neighbours. */ X_trapezoid insert(curve_const_ref cv) { #ifdef CGAL_TD_DEBUG *cv.get_parent(); #endif /* Point tmp; // maintaining some bounding box for future use. if (!number_of_curves_) // give initiale values to bounding points when empty { POINT_AT_LEFT_TOP_INFINITY=POINT_AT_RIGHT_BOTTOM_INFINITY= traits->curve_source(cv); } if (!traits->point_is_left_low(POINT_AT_LEFT_TOP_INFINITY,tmp= traits->curve_leftlow_most(cv))) POINT_AT_LEFT_TOP_INFINITY=traits->point_to_left(tmp); if (!traits->point_is_right_top(POINT_AT_RIGHT_BOTTOM_INFINITY,tmp= traits->curve_righttop_most(cv))) POINT_AT_RIGHT_BOTTOM_INFINITY=traits->point_to_right(tmp); */ return insert_in_face_interior(cv); } /* Input: X_curve Output: if X_curve or twin already inserted the latter is returned. otherwise the left-low most edge-degenerate trapezoid that represents the input X_curve is returned Remark: Given an edge-degenerate trapezoid representing a X_curve, all the other trapezoids representing the X_curve can be extracted via moving continously to the left and right neighbours. */ const X_trapezoid insert_in_face_interior(curve_const_ref cv) { #ifdef CGAL_TD_DEBUG *cv.get_parent(); #endif #ifdef CGAL_TDBB_DEBUG std::cout << "\ninsert_in_face_interior(" << cv << ")" << "\nBbox " << traits->get_bounding_box(); #endif #ifdef CGAL_TD_DEBUG std::cout << "\nTD::insert_in_face_interior(" << cv << ") called with " << (is_valid(*DS) ? "valid" : "invalid") << " data structure" << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif if (needs_update_) update(); // locate the input X_curve end points in the X_trapezoid Dag CGAL_assertion(traits); #ifndef CGAL_TD_DEBUG CGAL_warning(!traits->point_equal(traits->curve_source(cv), traits->curve_target(cv))); #else CGAL_precondition(!traits->point_equal(traits->curve_source(cv), traits->curve_target(cv))); #endif Point p[2]; int i= traits->point_is_left_low( p[0]=traits->curve_source(cv), p[1]=traits->curve_target(cv) ) ? 0 : 1; Locate_type lt1,lt2; pointer tr1,tr2; #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_optimization(p[i],tr1,lt1); #else tr1=&locate(p[i],lt1); #endif if (lt1==CURVE) { CGAL_precondition_msg(lt1!=CURVE,"Input is not planar as\ one of the input point inside previously inserted X_curve."); return X_trapezoid(); } reference t_p1= (lt1==POINT) ? insert_curve_at_point_using_geometry(cv,p[i],tr1,lt1) : insert_curve_at_point_using_data_structure(cv,p[i],tr1,lt1); #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_optimization(p[1-i],tr2,lt2); locate_opt_empty(); #else tr2=&locate(p[1-i],lt2); #endif if (lt2==CURVE) { CGAL_precondition_msg(lt2!=CURVE,"Input is not planar as\ one of the input point inside previously inserted X_curve."); return X_trapezoid(); } reference t_p2= (lt2==POINT) ? insert_curve_at_point_using_geometry(cv,p[1-i],tr2,lt2) : insert_curve_at_point_using_data_structure(cv,p[1-i],tr2,lt2); // locate and insert end points of the input X_curve to the X_trapezoid // Dag if needed Data_structure tt_p1(*t_p1.get_node()); Data_structure tt_p2(*t_p2.get_node()); // create the X_trapezoid iterator for traveling along the Trapezoids that // intersect the input X_curve, using left-low to right-high order In_face_iterator it=follow_curve(tt_p1,cv,LARGER); pointer curr,prev=&t_p1,prev_bottom,prev_top; pointer old_output = it.operator->(), old_top = 0, old_bottom = 0; #ifndef CGAL_TD_DEBUG CGAL_warning(!traits->is_degenerate(*old_output)); #else CGAL_assertion(!traits->is_degenerate(*old_output)); #endif old_output=0; Data_structure *tt; bool first_time=true; while(!!it) { curr=it.operator->(); prev_bottom=curr->left_bottom_neighbour(); prev_top=curr->left_top_neighbour(); // pass using it along cv it++; tt = curr->get_node(); if(first_time) { #ifndef CGAL_TD_DEBUG if(!curr->is_top_unbounded()&&traits->curve_equal(curr->top(),cv)) { CGAL_warning(!traits->curve_equal(curr->top(),cv)); return X_trapezoid(); } #else CGAL_precondition(curr->is_top_unbounded()|| !traits->curve_equal(curr->top(),cv)); #endif } split_trapezoid_by_curve(*tt,old_output, old_bottom, old_top, cv); #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curve_equal((**tt).top(),cv)); #endif if(first_time) { insert_curve_at_point_using_geometry(*old_output,t_p1); first_time=false; } if (tt->is_inner_node()) { // merge adjacent trapezoids on input X_curve's bottom side if possible if(merge_if_possible( prev_bottom, tt->left().operator->() )) { tt->set_left(*(prev_bottom->get_node())); old_bottom = prev_bottom; } // merge adjacent trapezoids on input X_curve's top side if possible if(merge_if_possible( prev_top, tt->right().operator->() )) { tt->set_right(*(prev_top->get_node())); old_top=prev_top; } // update trapezoid's left/right neighbouring relations if(!traits->is_degenerate(*prev) && !traits->is_degenerate(*curr)) { curr->set_lb(prev); curr->set_lt(prev); prev->set_rb(curr); prev->set_rt(curr); } } else { #ifdef CGAL_TD_DEBUG CGAL_assertion(curr->is_valid(traits)); #endif break; } #ifdef CGAL_TD_DEBUG CGAL_assertion(curr->is_valid(traits)); #endif } #ifdef CGAL_TD_DEBUG CGAL_postcondition(traits->is_degenerate_curve(*old_output)); CGAL_postcondition(traits->curve_equal((const X_curve)old_output->top(), cv)); #endif insert_curve_at_point_using_geometry(*old_output,t_p2); number_of_curves_++; #ifdef CGAL_TD_DEBUG std::cout << "\nTD::insert_in_face_interior() exited with data structure" << is_valid(*DS) << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif return *old_output; } // removal functions void remove(curve_const_ref cv) // We assume here that the input curves are in planar position. { remove_in_face_interior(cv); } template void remove(curve_iterator begin, curve_iterator end) { if(begin == end) return; std::random_shuffle(begin,end); curve_iterator it=begin,next=it; while(it!=end) {++next;remove(*it);it=next;} } void clear() { delete DS; init(); } void remove_in_face_interior(curve_const_ref cv) // Assumes the map to be planar. { #ifdef CGAL_TD_DEBUG std::cout << "\nTD::remove_in_face_interior(" << cv << ") called with " << (is_valid(*DS) ? "valid" : "invalid") << " data structure" << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif if (needs_update_) update(); #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_opt_empty(); #endif #ifndef CGAL_TD_DEBUG CGAL_warning(traits); #else CGAL_assertion(traits); #endif // calculating leftmost and rightmost points of X_curve cv Point leftmost=traits->curve_leftlow_most(cv), rightmost=traits->curve_righttop_most(cv); Locate_type lt1,lt2; reference t1=locate(leftmost,lt1), t2=locate(rightmost,lt2); CGAL_warning(lt1==POINT && lt2==POINT); if (!(lt1==POINT && lt2==POINT)) return; #ifndef CGAL_TD_DEBUG CGAL_warning(t1.get_node()); CGAL_warning(t2.get_node()); #endif Data_structure &tt1=*t1.get_node(), &tt2=*t2.get_node(); /* calculate the immediate lower central and upper neighbourhood of the curve in the data structure */ In_face_iterator bottom_it(follow_curve(tt1,cv,SMALLER)), mid_it(follow_curve(tt1,cv,EQUAL)), top_it(follow_curve(tt1,cv,LARGER)); bool bottom, old_bottom = false, end_reached; map_nodes new_array; int last_index[]={0,0}; int sz=0; Point left=bottom_it->left(),right; pointer last_bottom,last_top,last=0,old; #ifndef CGAL_TD_DEBUG CGAL_warning(traits->point_equal(top_it->left(),left)); #else CGAL_precondition(traits->point_equal(top_it->left(),left)); #endif // remove adjacency at left end point const_ref first=*mid_it; //X_curve const * old_cv=&first.top(); #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curve_equal(first.top(),cv)); CGAL_assertion(traits->point_equal(t1.left(),leftmost)); #endif remove_curve_at_point_using_geometry(first,t1); do { // which of bottom_it,top_it to advance. bottom=traits->point_is_left_low(bottom_it->right(),top_it->right()); Iterator& it = bottom ? bottom_it : top_it; pointer& last_it = bottom ? last_bottom : last_top; right=it->right(); // copy trapezoid's content and node pointer. typename map_nodes::value_type pair(sz, Data_structure( X_trapezoid(&left,&right, !bottom_it->is_bottom_unbounded() ? &bottom_it->bottom() : 0, !top_it->is_top_unbounded() ? &top_it->top() : 0))); new_array.insert(pair); Data_structure & curr = (new_array.find(sz))->second; ++sz; curr->set_node(&curr); curr->set_lb(bottom_it->left_bottom_neighbour()); curr->set_lt(top_it->left_top_neighbour()); if (last) { if (traits->trapezoid_top_curve_equal(*last,*curr)) { curr->set_lt(last); } if (traits->trapezoid_bottom_curve_equal(*last,*curr)) { curr->set_lb(last); } } if (curr->left_bottom_neighbour()) curr->left_bottom_neighbour()->set_rb(curr.operator->()); if (curr->left_top_neighbour()) curr->left_top_neighbour()->set_rt(curr.operator->()); last=curr.operator->(); left=right; last_bottom=bottom_it.operator->(); last_top=top_it.operator->(); #ifdef CGAL_TD_DEBUG CGAL_warning(last_bottom); CGAL_warning(last_top); #endif old=it.operator->(); it++; end_reached=!bottom_it||!top_it; if (!bottom_it || bottom && !traits->trapezoid_bottom_curve_equal(*old,*it)) { pointer rb=old->right_bottom_neighbour(); if (rb) {rb->set_lb(last);last->set_rb(rb);} } if (!top_it || !bottom && !traits->trapezoid_top_curve_equal(*old,*it)) { pointer rt=old->right_top_neighbour(); if (rt) {rt->set_lt(last);last->set_rt(rt);} } #ifdef CGAL_TD_DEBUG CGAL_assertion(last->get_node()); #endif if (old_bottom != bottom) { Data_structure tmp=container2data_structure( new_array,last_index[bottom ? 0 : 1],sz-1); #ifdef CGAL_TD_DEBUG std::cout << "\nremove_in_face_interior allocated "; write(std::cout,tmp,*traits) << "\ninto "; write(std::cout,*last_it,*traits,false) << std::endl; #endif last_it->remove(&tmp); last_index[bottom ? 0 : 1] = sz; old_bottom = bottom; } else { Data_structure tmp=container2data_structure(new_array,sz-1,sz-1); #ifdef CGAL_TD_DEBUG std::cout << "\nremove_in_face_interior allocated "; write(std::cout,tmp,*traits) << "\ninto "; write(std::cout,*last_it,*traits,false) << std::endl; #endif last_it->remove(&tmp); last_index[bottom ? 0 : 1] = sz; } const Data_structure *real=&last_it->get_node()->left(); (*real)->set_node((Data_structure*)real); } while(!end_reached); Iterator & it = !old_bottom ? bottom_it : top_it; #ifdef CGAL_TD_DEBUG CGAL_warning(traits->point_equal(it->right(),rightmost)); #endif pointer rb=it->right_bottom_neighbour(),rt=it->right_top_neighbour(); Data_structure tmp=container2data_structure(new_array, last_index[!bottom ? 0 : 1],new_array.size()-1); #ifdef CGAL_TD_DEBUG std::cout << "\nremove_in_face_interior allocated "; write(std::cout,tmp,*traits) << "\ninto "; write(std::cout,*it,*traits,false) << std::endl; #endif it->remove(&tmp); const Data_structure *real=&it->get_node()->left(); (*real)->set_node((Data_structure*)real); if (rb) {last->set_rb(rb);rb->set_lb(last);} if (rt) {last->set_rt(rt);rt->set_lt(last);} Base_trapezoid_iterator last_mid=mid_it; while(!!++mid_it) { #ifdef CGAL_TD_DEBUG CGAL_warning(traits->is_degenerate_curve(*last_mid)); #endif last_mid->remove(); last_mid=mid_it; } // remove adjacency at right end point #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curve_equal(cv,last_mid->top())); CGAL_assertion(traits->point_equal(rightmost,t2.left())); #endif remove_curve_at_point_using_geometry(*last_mid,t2); last_mid->remove(); if (is_isolated_point(t1)) remove_split_trapezoid_by_point(tt1,leftmost); if (is_isolated_point(t2)) remove_split_trapezoid_by_point(tt2,rightmost); //freeing memory thasht was allocated for X_curve //delete old_cv; // reevaluating number of curves number_of_curves_--; #ifdef CGAL_TD_DEBUG std::cout << "\nTD::remove_in_face_interior() exited with data structure" << is_valid(*DS) << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif } /* output: The active trapezoid representing the input point. preconditions: The trapezoidal tree is not empty postcondition: the input locate type is set to the type of the output trapezoid. remarks: locate call may change the class */ reference locate(const Point& p,Locate_type &t) const { #ifdef CGAL_TD_DEBUG CGAL_assertion(traits); CGAL_assertion(DS); #endif Data_structure curr=*DS; #ifdef CGAL_TD_DEBUG CGAL_precondition(!!curr); #endif t=search_using_data_structure(curr,traits,p,0); #ifdef CGAL_TD_DEBUG CGAL_postcondition(t == POINT || t == CURVE || t == TRAPEZOID || t == UNBOUNDED_TRAPEZOID); #endif #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_opt_push(curr.operator->()); #endif return *curr; } /* preconditions: p is not on an edge or a vertex. */ curve_const_ref vertical_ray_shoot(const Point & p,Locate_type & t, const bool up_direction = true) const { #ifdef CGAL_TD_DEBUG CGAL_assertion(traits); #endif // We replace the following locate with a direct call to // search_using_data_structure because we need to deal // with cases where the source of shoot is a point/curve. // reference t_p = locate(p,t); Data_structure curr=*DS; #ifdef CGAL_TD_DEBUG CGAL_precondition(!!curr); #endif t = search_using_data_structure(curr, traits, p, NULL, up_direction ? CGAL::LARGER : CGAL::SMALLER); reference t_p = *curr; //std::cout << "t" << t << "\n"; #ifdef CGAL_TD_DEBUG CGAL_warning(t_p.get_node()); #endif reference tr = **t_p.get_node(); // std::cout << "tr" << tr << "\n"; // tr should be non degenerate trapezoid /* using exact traits, it may happen that p is on the right side of the trapezoid directly under its right point(analogouly directly above its left point). with the trapezoid extending to the left. In this case vertical ray shoot upwards(downwards) doesn't returns c as output. Example. x---x p x------x */ if (up_direction && !tr.is_right_unbounded() && traits->point_equal_x(p,tr.right()) && (tr.is_left_unbounded() || !traits->point_equal(tr.left(),tr.right())) || !up_direction && !tr.is_left_unbounded() && traits->point_equal_x(p,tr.left()) && (tr.is_right_unbounded() || !traits->point_equal(tr.left(),tr.right()))) { // recalculate vertical ray shoot using locate on point return up_direction ? locate(tr.right(),t).top() : locate(tr.left(),t).bottom(); } curve_const_ref c = up_direction ? tr.top() : tr.bottom(); if (up_direction ? tr.is_top_unbounded() : tr.is_bottom_unbounded()) { t=UNBOUNDED_TRAPEZOID; } else { // Now we know that the trapezoid is bounded on in the // direction of the shoot. t = (traits->point_equal(p,traits->curve_source(c)) || traits->point_equal(p,traits->curve_target(c))) ? POINT : CURVE; } return c; } /* Input: 1 whole curves 2 partial curves Output: X_curve precondition: c The first input X_curve is the union of the other two. The intersection of the latter is a point inside the interior of the former. The latter are ordered from left-down to right-up postcondition: The first input X_curve is broken into two curves corresponding to the input. The output is the degenerate point trapezoid that corresponds to the splitting point.*/ void split_edge(curve_const_ref cv,curve_const_ref cv1, curve_const_ref cv2) { #ifdef CGAL_TD_DEBUG std::cout << "\nTD::split_edge(" << cv << "," << cv1 << "," << cv2 << ") called with " << (is_valid(*DS) ? "valid" : "invalid") << " data structure" << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif if (needs_update_) update(); #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_opt_empty(); #endif #ifndef CGAL_TD_DEBUG if (!traits) { CGAL_warning(traits); return; } if (!traits->curve_merge_condition(cv,cv1,cv2)) { CGAL_warning(traits->curve_merge_condition(cv,cv1,cv2)); return; } #else if (!traits->curve_merge_condition(cv,cv1,cv2)) { std::cerr << "\ncv " << cv; std::cerr << "\ncv1 " << cv1; std::cerr << "\ncv2 " << cv2 << std::endl; } CGAL_precondition(traits); CGAL_precondition(traits->curve_merge_condition(cv,cv1,cv2)); #endif // spliting point Point p = traits->point_equal(traits->curve_target(cv1), traits->curve_source(cv2)) ? traits->curve_target(cv1) : traits->curve_target(cv2); #ifndef CGAL_TD_DEBUG CGAL_warning( traits->point_is_left_low( traits->curve_leftlow_most(cv),p)); CGAL_warning( traits->point_is_right_top( traits->curve_righttop_most(cv),p)); #else CGAL_precondition( traits->point_is_left_low( traits->curve_leftlow_most(cv),p)); CGAL_precondition( traits->point_is_right_top( traits->curve_righttop_most(cv),p)); #endif // extremal points Point leftmost=traits->curve_leftlow_most(cv), rightmost=traits->curve_righttop_most(cv); Locate_type lt1,lt2; // representing trapezoids for extremal points reference t1=locate(leftmost,lt1), t2=locate(rightmost,lt2); #ifndef CGAL_TD_DEBUG CGAL_warning(lt1==POINT && lt2==POINT); CGAL_warning(t1.is_active() && t2.is_active()); #else CGAL_precondition(lt1==POINT && lt2==POINT); CGAL_precondition(t1.is_active() && t2.is_active()); CGAL_warning(t1.get_node()); CGAL_warning(t2.get_node()); #endif Data_structure &tt1=*t1.get_node(); In_face_iterator bottom_it(follow_curve(tt1,cv,SMALLER)), mid_it(follow_curve(tt1,cv,EQUAL)), top_it(follow_curve(tt1,cv,LARGER)); Locate_type lt; reference old_t=locate(p,lt); //X_curve const * old_cv=&old_t.top(); #ifdef CGAL_TD_DEBUG CGAL_assertion(lt==CURVE); CGAL_precondition(old_t.is_active()); CGAL_warning(old_t.get_node()); #endif Data_structure &old_tt=*old_t.get_node(); // previous left and right sons of old_tt const Data_structure &old_left=old_tt.left(), &old_right=old_tt.right(); X_curve left_cv,right_cv; if (traits->point_equal(traits->curve_leftlow_most(cv2),p)) { left_cv=cv1; right_cv=cv2; } else { left_cv=cv2; right_cv=cv1; } const Data_structure &new_left_tt=Data_structure(X_trapezoid(old_t.left(), p, left_cv, left_cv), old_left, old_right), &new_right_tt=Data_structure(X_trapezoid(p, old_t.right(), right_cv, right_cv), old_left, old_right), &new_tt=Data_structure(X_trapezoid(p, p, left_cv, right_cv), new_left_tt, new_right_tt); reference new_left_t=*new_left_tt, new_right_t=*new_right_tt, new_t=*new_tt; /* locate trapezoid trees that correspond to the closest trapezoids above and below p */ pointer left_top_t=top_it.operator->(), left_bottom_t=bottom_it.operator->(); while(traits->point_is_left_low(left_top_t->right(),p)) left_top_t=left_top_t->right_bottom_neighbour(); while(traits->point_is_left_low(left_bottom_t->right(),p)) left_bottom_t=left_bottom_t->right_top_neighbour(); Data_structure left_top=*left_top_t->get_node(), left_bottom=*left_bottom_t->get_node(); replace_curve_at_point_using_geometry(cv,left_cv,t1); replace_curve_at_point_using_geometry(cv,right_cv,t2); // the point p belongs to cv interior new_t.set_rt(&new_left_t); new_t.set_lb(&new_right_t); new_left_t.set_lb(old_t.left_bottom_neighbour() != &old_t ? old_t.left_bottom_neighbour() : &new_left_t); new_left_t.set_rt(&new_right_t); new_right_t.set_lb(&new_left_t); new_right_t.set_rt(old_t.right_top_neighbour() != &old_t ? old_t.right_top_neighbour() : &new_right_t); // update geometric boundary for trapezoids representing cv pointer prev=0; while(*mid_it != old_t) { mid_it->set_top(left_cv); mid_it->set_bottom(left_cv); mid_it->set_right(p); prev=mid_it.operator->();mid_it++; } if (prev) { prev->set_rb(&new_left_t); } // new_left_t is leftmost representative for cv else { replace_curve_at_point_using_geometry(new_left_t,t1); } if (t1.right_top_neighbour()==&old_t) t1.set_rt(&new_left_t); if (t1.left_bottom_neighbour()==&old_t) t1.set_lb(&new_left_t); mid_it++; new_right_t.set_rb(mid_it.operator->()); prev=0; while(!!mid_it) { mid_it->set_top(right_cv); mid_it->set_bottom(right_cv); mid_it->set_left(p); prev=mid_it.operator->(); mid_it++; } if (prev) { new_right_t.set_rb(old_t.right_bottom_neighbour()); } else // new_right_t is rightmost representative for cv { replace_curve_at_point_using_geometry(new_right_t,t2,false); } if (t2.right_top_neighbour()==&old_t) t2.set_rt(&new_right_t); if (t2.left_bottom_neighbour()==&old_t) t2.set_lb(&new_right_t); /* update geometric boundary for trapezoids below cv*/ while (*bottom_it!=*left_bottom) { #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curve_equal(bottom_it->top() ,cv)); #endif bottom_it->set_top(left_cv); bottom_it++; } #ifdef CGAL_TD_DEBUG CGAL_assertion(*bottom_it==*left_bottom); #endif Data_structure &bottom_tt=*bottom_it->get_node(); bottom_it++; #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->is_in_closure(*bottom_tt,p)); #endif split_trapezoid_by_point(bottom_tt,p,left_cv,right_cv); // set the splitting trapezoid to be the same one that splits the // X_curve'like trapezoid *bottom_tt=new_t; // update top curves bottom_tt.left()->set_top(left_cv); bottom_tt.right()->set_top(right_cv); // left and right are not neighbours. bottom_tt.left()->set_rt(0); bottom_tt.right()->set_lt(0); while(!!bottom_it) { #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curve_equal(bottom_it->top(),cv)); #endif bottom_it->set_top(right_cv); bottom_it++; } /* update geometric boundary for trapezoids above cv*/ while (*top_it!=*left_top) { #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->curve_equal(top_it->bottom(),cv)); #endif top_it->set_bottom(left_cv); top_it++; } #ifdef CGAL_TD_DEBUG CGAL_assertion(*top_it==*left_top); #endif Data_structure &top_tt=*top_it->get_node(); top_it++; #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->is_in_closure(*bottom_tt,p)); #endif split_trapezoid_by_point(top_tt,p,left_cv,right_cv); // set the splitting trapezoid to be the same one that splits the // X_curve'like trapezoid *top_tt=new_t; // update bottom side top_tt.left()->set_bottom(left_cv); top_tt.right()->set_bottom(right_cv); // left and right aren't neighbours top_tt.left()->set_rb(0); top_tt.right()->set_lb(0); while(!!top_it) { #ifndef CGAL_TD_DEBUG CGAL_warning(traits->curve_equal(top_it->bottom(),cv)); #else if (!traits->curve_equal(top_it->bottom(),cv)) std::cout << "\ntop_it->bottom() "<< top_it->bottom() << "\t cv= " << cv; CGAL_assertion(traits->curve_equal(top_it->bottom(),cv)); #endif top_it->set_bottom(right_cv); top_it++; } // mark inactive trapezoids old_t.remove((Data_structure*)&new_tt); const Data_structure *newPtr=&old_t.get_node()->left(), *newleftPtr=&newPtr->left(), *newrightPtr=&newPtr->right(), *oldleftPtr=&newleftPtr->left(), *oldrightPtr=&newleftPtr->right(); (*newPtr)->set_node((Data_structure*)newPtr); (*newleftPtr)->set_node((Data_structure*)newleftPtr); (*newrightPtr)->set_node((Data_structure*)newrightPtr); (*oldleftPtr)->set_node((Data_structure*)oldleftPtr); (*oldrightPtr)->set_node((Data_structure*)oldrightPtr); #ifdef CGAL_TD_DEBUG CGAL_assertion(old_tt->is_valid(traits)); CGAL_assertion(new_tt->is_valid(traits)); CGAL_assertion((*newPtr)->is_valid(traits)); CGAL_assertion((*newleftPtr)->is_valid(traits)); CGAL_assertion((*newrightPtr)->is_valid(traits)); CGAL_assertion((*oldleftPtr)->is_valid(traits)); CGAL_assertion((*oldrightPtr)->is_valid(traits)); CGAL_assertion(top_tt->is_valid(traits)); CGAL_assertion(bottom_tt->is_valid(traits)); CGAL_assertion(old_left->is_valid(traits)); CGAL_assertion(old_right->is_valid(traits)); CGAL_assertion(traits->is_degenerate_point(**newPtr)); CGAL_assertion(traits->is_degenerate_curve(**newleftPtr)); CGAL_assertion(traits->is_degenerate_curve(**newrightPtr)); CGAL_assertion( traits->point_equal( traits->curve_leftlow_most((*newrightPtr)->bottom()), (*newPtr)->right() ) ); CGAL_assertion( traits->point_equal( traits->curve_righttop_most((*newleftPtr)->top()), (*newPtr)->left() ) ); #endif // reevaluating number of curves number_of_curves_++; #ifdef CGAL_TD_DEBUG std::cout << "\nTD::split_edge() exited with data structure" << is_valid(*DS) << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif } void merge_edge( curve_const_ref cv1 , curve_const_ref cv2, curve_const_ref cv) { #ifdef CGAL_TD_DEBUG std::cout << "\nTD::merge_edge(" << cv1 << "," << cv2 << "," << cv << ") called with " << (is_valid(*DS) ? "valid" : "invalid") << " data structure" << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif if (needs_update_) update(); #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_opt_empty(); #endif #ifndef CGAL_TD_DEBUG if (!traits) { CGAL_warning(traits); return; } if (!traits->curve_merge_condition(cv,cv1,cv2)) { CGAL_warning(traits->curve_merge_condition(cv,cv1,cv2)); return; } #else if (!traits->curve_merge_condition(cv,cv1,cv2)) { std::cerr << "\ncv " << cv; std::cerr << "\ncv1 " << cv1; std::cerr << "\ncv2 " << cv2 << std::endl; } CGAL_assertion(traits); CGAL_precondition(traits->curve_merge_condition(cv,cv1,cv2)); #endif Point p= // Calculate the common point of cv1 and cv2. // There should be one! traits->point_equal(traits->curve_target(cv1), traits->curve_source(cv2)) ? traits->curve_target(cv1) : // [-- cv1 -->] p [-- cv2 -->] or [<-- cv2 --] p [<-- cv1 --] traits->point_equal(traits->curve_source(cv1), traits->curve_target(cv2)) ? // [<-- cv1 --] p [<-- cv2 --] or [-- cv2 -->] p [-- cv1 -->] traits->curve_source(cv1) : // traits->point_equal(traits->curve_source(cv1), traits->curve_source(cv2)) ? // [<-- cv1 --] p [-- cv2 -->] traits->curve_source(cv1) : // [-- cv1 -->] p [<-- cv2 --] traits->curve_target(cv1); #ifdef CGAL_TD_DEBUG // p is interior to the union curve CGAL_precondition( traits->point_is_left_low( traits->curve_leftlow_most(cv),p )); CGAL_precondition( traits->point_is_right_top( traits->curve_righttop_most(cv),p )); #endif Point leftmost=traits->curve_leftlow_most(cv), rightmost=traits->curve_righttop_most(cv); Locate_type lt1,lt2,lt; reference t1=locate(leftmost,lt1), t2=locate(rightmost,lt2), t=locate(p,lt); #ifndef CGAL_TD_DEBUG CGAL_warning(t1.get_node()); CGAL_warning(t2.get_node()); CGAL_warning(t.get_node()); #else CGAL_precondition(lt1==POINT && lt2==POINT && lt==POINT); CGAL_precondition(t1.is_active() && t2.is_active() && t.is_active()); CGAL_assertion(t1.get_node()); CGAL_assertion(t2.get_node()); CGAL_assertion(t.get_node()); #endif X_curve left_cv,right_cv; if (traits->point_equal(traits->curve_leftlow_most(cv2),p)) { left_cv=cv1; right_cv=cv2; } else { left_cv=cv2; right_cv=cv1; } #ifdef CGAL_TD_DEBUG CGAL_assertion(traits->point_equal( t1.left(),leftmost )); CGAL_assertion(traits->point_equal( t2.right(),rightmost )); CGAL_assertion(traits->point_is_left_low( leftmost,p )); CGAL_assertion(traits->point_is_left_low( p,rightmost )); CGAL_assertion(traits->point_equal( traits->curve_leftlow_most(left_cv),leftmost )); CGAL_assertion(traits->point_equal( traits->curve_righttop_most(left_cv),p )); CGAL_assertion(traits->point_equal( traits->curve_leftlow_most(right_cv),p )); CGAL_assertion(traits->point_equal( traits->curve_righttop_most(right_cv),rightmost )); CGAL_assertion(traits->point_equal( traits->curve_leftlow_most(cv),leftmost )); CGAL_assertion(traits->point_equal( traits->curve_righttop_most(cv),rightmost )); #endif Data_structure &tt1=*t1.get_node(), &tt=*t.get_node(); In_face_iterator bottom_left_it(follow_curve(tt1,left_cv,SMALLER)), mid_left_it(follow_curve(tt1,left_cv,EQUAL)), top_left_it(follow_curve(tt1,left_cv,LARGER)), bottom_right_it(follow_curve(tt,right_cv,SMALLER)), mid_right_it(follow_curve(tt,right_cv,EQUAL)), top_right_it(follow_curve(tt,right_cv,LARGER)); #ifdef CGAL_TD_DEBUG CGAL_assertion(bottom_left_it.operator->()); CGAL_assertion(mid_left_it.operator->()); CGAL_assertion(top_left_it.operator->()); CGAL_assertion(bottom_right_it.operator->()); CGAL_assertion(mid_right_it.operator->()); CGAL_assertion(top_right_it.operator->()); CGAL_assertion(bottom_left_it->is_active()); CGAL_assertion(mid_left_it->is_active()); CGAL_assertion(top_left_it->is_active()); CGAL_assertion(bottom_right_it->is_active()); CGAL_assertion(mid_right_it->is_active()); CGAL_assertion(top_right_it->is_active()); #endif pointer left=mid_left_it.operator->(), mid_left=0, mid_right=mid_right_it.operator->(), top_left=0, top_right=top_right_it.operator->(), bottom_left=0, bottom_right=bottom_right_it.operator->(), right=0, dummy=0, dummy2=0; replace_curve_using_geometry(mid_left_it,left_cv,cv,mid_left); replace_curve_using_geometry(mid_right_it,right_cv,cv,right); replace_curve_using_geometry(top_left_it,left_cv,cv,top_left); replace_curve_using_geometry(top_right_it,right_cv,cv,dummy); replace_curve_using_geometry(bottom_left_it,left_cv,cv,bottom_left); replace_curve_using_geometry(bottom_right_it,right_cv,cv,dummy2); // merge trapezoids splited by the upward and downward // vertical extensions from p #ifndef CGAL_TD_DEBUG merge_if_possible(top_left,top_right); merge_if_possible(bottom_left,bottom_right); #else CGAL_warning(top_left); CGAL_warning(top_right); CGAL_warning(merge_if_possible(top_left,top_right)); CGAL_warning(bottom_left); CGAL_warning(bottom_right); CGAL_warning(merge_if_possible(bottom_left,bottom_right)); #endif // mark older trapezoids as inactive top_right->remove(top_left->get_node()); bottom_right->remove(bottom_left->get_node()); #ifdef CGAL_TD_DEBUG CGAL_warning(mid_left); CGAL_warning(mid_right); CGAL_warning(tt->is_active()); #endif // make p's representative inactive tt->remove(); mid_left->set_rb(mid_right); mid_left->set_right(mid_right->right()); mid_right->set_left(mid_left->left()); mid_left->set_rt(0); mid_right->set_lb(0); replace_curve_at_point_using_geometry(left_cv,cv,t1); replace_curve_at_point_using_geometry(right_cv,cv,t2); #ifdef CGAL_TD_DEBUG CGAL_warning(left); CGAL_warning(right); #endif replace_curve_at_point_using_geometry(*left,t1,true); replace_curve_at_point_using_geometry(*right,t2,false); // reevaluating number of curves number_of_curves_--; #ifdef CGAL_TD_DEBUG std::cout << "\nTD::merge_edge() exited with data structure" << is_valid(*DS) << std::endl; write(std::cout,*DS,*traits) << std::endl; #endif } unsigned long size() const { return DS->size(); } unsigned long depth() const { return DS->depth(); } unsigned long number_of_curves() const { return number_of_curves_; } void init_traits(const_Traits_ptr t) { traits = t; #ifdef CGAL_TD_DEBUG CGAL_assertion(!!*DS); #endif } /* update geometric boundary(top and bottom) for trapezoids traveled along an iterator till end reached precondition: end==0 or end is on the path of the iterator postcondition: end is pointer to the last trapezoid encountered,if any */ /*------------------------------------------------------------------ description: returns whether the Trapezoidal Dag is valid */ #ifdef CGAL_TD_DEBUG bool is_valid(const Data_structure& ds) const { return !ds || ds->is_valid(traits) && ds->get_node() && is_valid(ds.left()) && is_valid(ds.right()); } /*------------------------------------------------------------------ description: returns whether the member Trapezoidal data structure is valid */ bool is_valid() const { return is_valid(*DS); } void debug() { std::cout << "\nTrapezoidal_decomposition_2::debug()\n" << *this << std::endl; X_trapezoid x; x.debug(); } #endif /*------------------------------------------------------------------ description: Rebuilds the trapezoid data structure by reinserting the curves in a random order in an empty data structure. postcondition: The old and new data structures agree on their member curves. ------------------------------------------------------------------*/ Self& rebuild() { #ifdef CGAL_TD_DEBUG std::cout << "\nrebuild()" << std::flush; #endif X_curve_container container; unsigned long rep = X_curve_filter(container, &get_data_structure()); clear(); // initialize container to point to curves in X_trapezoid Tree if (rep>0) { bool o=set_needs_update(false); typename std::vector::iterator it = container.begin(), it_end = container.end(); while(it!=it_end) { insert(*it); ++it; } set_needs_update(o); } #ifdef CGAL_TD_DEBUG CGAL_assertion(is_valid()); unsigned long sz=number_of_curves(); if(sz!=rep) { std::cerr << "\nnumber_of_curves()=" << sz; std::cerr << "\nrepresentatives.size()=" << rep; CGAL_assertion(number_of_curves()==rep); } #endif container.clear(); return *this; } /* Input: a list of pointers to X_trapezoids and a X_trapezoid boolean predicate. Output: void Postcondition: the list pointers correspond to all the X_trapezoids in the data structure for which the predicate value is true. */ template void filter(Container& c, const Predicate& pr, const Data_structure* ds=&get_data_structure()) const { CGAL_assertion(ds); ds->filter(c,pr); } template unsigned long X_trapezoid_filter(Container& container, const Data_structure* ds) const /* Return a container for all active trapeozoids */ { ds->filter(container, Td_active_trapezoid()); return container.size(); } template unsigned long X_curve_filter(X_curve_container& container, const Data_structure* ds) const /* Return a container for all active curves */ { unsigned long sz=number_of_curves(); list_container representatives; ds->filter(representatives, Td_active_right_degenerate_curve_trapezoid(*traits)); #ifndef CGAL_TD_DEBUG CGAL_warning(sz==representatives.size()); #else unsigned long rep=representatives.size(); if (sz!=rep) { std::cerr << "\nnumber_of_curves()=" << sz; std::cerr << "\nrepresentatives.size()=" << rep; CGAL_assertion(number_of_curves()==representatives.size()); } #endif if (sz>0) { typename list_container::iterator it = representatives.begin(), it_end = representatives.end(); while(it!=it_end) { container.push_back(it->top()); ++it; } } if(! container.empty()) { std::random_shuffle(container.begin(),container.end()); } return sz; } /*------------------------------------------------------------------ Input: None Output: bool Description: determines according to pre defined conditions whether the current Trapezoidal_decomposition_2 needs update Postconditions: The output is true iff the depth of the Trapezoidal Tree is more then DepthThreshold times log of the X_curve count or the Trapezoidal Tree's size is more then SizeThreshold times the log of the last count. */ bool set_needs_update(bool u) { bool old=needs_update_; needs_update_=u; return old; } bool needs_update() { unsigned long sz = number_of_curves(); //to avoid signed / unsigned conversion warnings // rand() returns an int but a non negative one. if (static_cast(rand()) > RAND_MAX / (sz+1)) return false; /* INTERNAL COMPILER ERROR overide #ifndef __GNUC__ */ #ifdef CGAL_TD_REBUILD_DEBUG std::cout << "\n|heavy!" << std::flush; #endif return depth()>(get_depth_threshold()*(CGAL_CLIB_STD::log(double(sz+1)))) || size()>(get_size_threshold()*(sz+1)); /* #else // to avoid comparison between signed and unsigned return ((depth()/10)>log(sz+1))||((size()/10)>(sz+1)); //return ((((signed)depth())/10)>log(sz+1))|| ((((signed)size())/10)>(sz+1)); #endif */ } /*------------------------------------------------------------------ input: None output: bool Description: uses needs_update to determine whether the Trapezoidal_decomposition_2 needs update and calls rebuild accordingly Postcondition: the return value is true iff rebuilding took place. */ bool update() { #ifdef CGAL_TD_REBUILD_DEBUG std::cout << "\n|" << needs_update() << std::flush; #endif if (needs_update()) {rebuild();return true;} return false; } /* returns a reference to the internal data structure */ const Data_structure& get_data_structure() const {return *DS;} /* returns a reference to the internal data structure */ const_Traits_ref get_traits() const {return *traits;} /* returns a reference to the internal depth threshold constant */ const double& get_depth_threshold() const { return depth_threshold; } /* returns a reference to the internal size threshold constant */ const double& get_size_threshold() const { return size_threshold; } /* sets the internal depth threshold constant to the parameter and returns its reference */ const double& set_depth_threshold(const double& depth_th) { return depth_threshold=depth_th; } /* sets the internal size threshold constant to the parameter and returns its reference */ const double& set_size_threshold(const double& size_th) { return size_threshold=size_th; } protected: Data_structure* DS; bool needs_update_; unsigned long number_of_curves_; const_Traits_ptr traits; private: #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION mutable pointer last_cv,prev_cv; #endif void init() { // traits may be initialized later DS = new Data_structure(X_trapezoid()); (*DS)->set_node(DS); /* Point tmp; if (!traits->point_is_left_low(TD_X_trapezoid::POINT_AT_LEFT_TOP_INFINITY,tmp=TD_X_trapezoid::POINT_AT_RIGHT_BOTTOM_INFINITY)) TD_X_trapezoid::POINT_AT_LEFT_TOP_INFINITY=traits->point_to_left(tmp); */ #ifdef CGAL_TD_DEBUG CGAL_warning(!!*DS); #endif number_of_curves_=0; #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION locate_opt_empty(); #endif } #ifndef CGAL_NO_TRAPEZOIDAL_DECOMPOSITION_2_OPTIMIZATION void locate_opt_push(pointer cv) const { prev_cv=last_cv; last_cv=cv; } void locate_opt_empty() const { last_cv=prev_cv=0; } bool locate_opt_swap(pointer& cv) const { cv=last_cv; last_cv=prev_cv; prev_cv=cv; return (cv!=0); } void locate_optimization(const Point& p,pointer& tr,Locate_type& lt) const { // optimization if (locate_opt_swap(tr)&&tr->is_active()&& (traits->is_degenerate_point(*tr)&& traits->point_equal(tr->left(),p)|| !traits->is_degenerate(*tr)&& traits->is_inside(*tr,p) )|| locate_opt_swap(tr)&&tr->is_active()&& (traits->is_degenerate_point(*tr)&& traits->point_equal(tr->left(),p)|| !traits->is_degenerate(*tr)&& traits->is_inside(*tr,p) ) ) if(traits->is_degenerate_point(*tr)) lt=POINT; else lt=tr->is_unbounded()?UNBOUNDED_TRAPEZOID:TRAPEZOID; else tr=&locate(p,lt); } #endif protected: bool is_isolated_point(const_ref tr) const { #ifdef CGAL_TD_DEBUG CGAL_precondition(traits->is_degenerate_point(tr)); #endif return !tr.right_top_neighbour()&&!tr.left_bottom_neighbour(); } protected: double depth_threshold,size_threshold; }; CGAL_END_NAMESPACE #ifndef CGAL_TD_X_TRAPEZOID_H #include #endif #ifdef CGAL_TD_DEBUG #ifndef CGAL_TRAPEZOIDAL_DECOMPOSITION_2_IOSTREAM_H #include #endif #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_traits_3.h0000644000175000017500000000304511344301500031126 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_POLYHEDRON_TRAITS_3_H #define CGAL_POLYHEDRON_TRAITS_3_H 1 #include CGAL_BEGIN_NAMESPACE template < class Kernel_ > class Polyhedron_traits_3 { public: typedef Kernel_ Kernel; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Construct_opposite_plane_3 Construct_opposite_plane_3; private: Kernel m_kernel; public: Polyhedron_traits_3() {} Polyhedron_traits_3( const Kernel& kernel) : m_kernel(kernel) {} Construct_opposite_plane_3 construct_opposite_plane_3_object() const { return m_kernel.construct_opposite_plane_3_object(); } }; CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_TRAITS_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_checker.h0000644000175000017500000001464111344301500030103 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_checker.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_CHECKER_H #define CGAL_KERNEL_CHECKER_H // This file contains the definition of a kernel traits checker. // // TODO: // - At the moment, only predicates are checked. To handle constructions as // well, the best approach is probably to have objects be pairs, and do // everything in parallel (cf Curved_kernel's traits checker for an example). // So the template parameter will be a comparator, not a converter. #include #include #include CGAL_BEGIN_NAMESPACE // Class used by Kernel_checker. template class Predicate_checker { O1 o1; O2 o2; Conv c; public: Predicate_checker(const O1 &oo1 = O1(), const O2 &oo2 = O2()) : o1(oo1), o2(oo2) {} typedef typename O1::result_type result_type; typedef typename O1::Arity Arity; template result_type operator()(const A1 &a1) const { typename O1::result_type res1 = o1(a1); typename O2::result_type res2 = o2(c(a1)); if (res1 != res2) { std::cerr << "Kernel_checker error : " << res1 << " != " << res2 << " for the inputs : " << std::endl; std::cerr << a1 << std::endl; std::cerr << "functor first kernel : " << typeid(o1).name() << std::endl; std::cerr << "functor second kernel: " << typeid(o2).name() << std::endl; #ifdef __GNUG__ std::cerr << __PRETTY_FUNCTION__ << std::endl; #endif CGAL_kernel_assertion(false); } return res1; } template result_type operator()(const A1 &a1, const A2 &a2) const { typename O1::result_type res1 = o1(a1, a2); typename O2::result_type res2 = o2(c(a1), c(a2)); if (res1 != res2) { std::cerr << "Kernel_checker error : " << res1 << " != " << res2 << " for the inputs : " << std::endl; std::cerr << a1 << ", " << a2 << std::endl; std::cerr << "functor first kernel : " << typeid(o1).name() << std::endl; std::cerr << "functor second kernel: " << typeid(o2).name() << std::endl; #ifdef __GNUG__ std::cerr << __PRETTY_FUNCTION__ << std::endl; #endif CGAL_kernel_assertion(false); } return res1; } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3) const { typename O1::result_type res1 = o1(a1, a2, a3); typename O2::result_type res2 = o2(c(a1), c(a2), c(a3)); if (res1 != res2) { std::cerr << "Kernel_checker error : " << res1 << " != " << res2 << " for the inputs : " << std::endl; std::cerr << a1 << ", " << a2 << ", " << a3 << std::endl; std::cerr << "functor first kernel : " << typeid(o1).name() << std::endl; std::cerr << "functor second kernel: " << typeid(o2).name() << std::endl; #ifdef __GNUG__ std::cerr << __PRETTY_FUNCTION__ << std::endl; #endif CGAL_kernel_assertion(false); } return res1; } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const { typename O1::result_type res1 = o1(a1, a2, a3, a4); typename O2::result_type res2 = o2(c(a1), c(a2), c(a3), c(a4)); if (res1 != res2) { std::cerr << "Kernel_checker error : " << res1 << " != " << res2 << " for the inputs : " << std::endl; std::cerr << a1 << ", " << a2 << ", " << a3 << ", " << a4 << std::endl; std::cerr << "functor first kernel : " << typeid(o1).name() << std::endl; std::cerr << "functor second kernel: " << typeid(o2).name() << std::endl; #ifdef __GNUG__ std::cerr << __PRETTY_FUNCTION__ << std::endl; #endif CGAL_kernel_assertion(false); } return res1; } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const { typename O1::result_type res1 = o1(a1, a2, a3, a4, a5); typename O2::result_type res2 = o2(c(a1), c(a2), c(a3), c(a4), c(a5)); if (res1 != res2) { std::cerr << "Kernel_checker error : " << res1 << " != " << res2 << " for the inputs : " << std::endl; std::cerr << a1 << ", " << a2 << ", " << a3 << ", " << a4 << ", " << a5 << std::endl; std::cerr << "functor first kernel : " << typeid(o1).name() << std::endl; std::cerr << "functor second kernel: " << typeid(o2).name() << std::endl; #ifdef __GNUG__ std::cerr << __PRETTY_FUNCTION__ << std::endl; #endif CGAL_kernel_assertion(false); } return res1; } // Same thing with more arguments... }; // For now, we inherit all geometric objects and constructions from K1, and // just overload the predicates. template class Kernel_checker : public K1 { typedef K1 Kernel1; typedef K2 Kernel2; Kernel2 k2; typedef Conv c; // typedef std::pair Point_2; // ... Same thing for all objects. #define CGAL_check_pred(X, Y) \ typedef Predicate_checker X; \ X Y() const { return X(K1::Y(), k2.Y()); } #define CGAL_Kernel_pred(Y,Z) CGAL_check_pred(Y, Z) #define CGAL_Kernel_cons(Y,Z) public: #include }; CGAL_END_NAMESPACE #endif // CGAL_KERNEL_CHECKER_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d_traits_30000644000175000017500000001510411344301500031345 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CONVEX_HULL_D_TRAITS_3_H #define CONVEX_HULL_D_TRAITS_3_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template struct Convex_hull_d_traits_3 { typedef R_ R; typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_d; typedef typename R_::Plane_3 Hyperplane_d; typedef typename R_::Vector_3 Vector_d; typedef typename R_::Ray_3 Ray_d; typedef typename R::Oriented_side_3 Oriented_side_d; Oriented_side_d oriented_side_d_object() const { return Oriented_side_d(); } typedef typename R::Has_on_positive_side_3 Has_on_positive_side_d; Has_on_positive_side_d has_on_positive_side_d_object() const { return Has_on_positive_side_d(); } struct Orientation_d { template Orientation operator()(I s, I e) { Point_d A[4]; CGAL_assertion(s != e); A[0] = *s; ++s; CGAL_assertion(s != e); A[1] = *s; ++s; CGAL_assertion(s != e); A[2] = *s; ++s; CGAL_assertion(s != e); A[3] = *s; ++s; CGAL_assertion(s == e); return orientation(A[0],A[1],A[2],A[3]); } }; Orientation_d orientation_d_object() const { return Orientation_d(); } struct Affinely_independent_d { template bool operator()(I s, I e) { Point_d A[4]; CGAL_assertion(s != e); A[0] = *s; ++s; if(s == e){ return true; } A[1] = *s; ++s; if (s == e){ return A[0] != A[1]; } A[2] = *s; ++s; if (s == e){ return ! collinear( A[0], A[1], A[2] ); } A[3] = *s; ++s; if (s == e){ return !coplanar( A[0], A[1], A[2], A[3] ); } return false; } }; Affinely_independent_d affinely_independent_d_object() const { return Affinely_independent_d(); } struct Contained_in_simplex_d { template bool operator()(I s, I e, const Point_d& p) { Point_d A[4]; CGAL_assertion(s != e); A[0] = *s; ++s; if(s == e){ return A[0] == p; } A[1] = *s; ++s; if (s == e){ typename R_::Segment_3 s( A[0], A[1] ); return s.has_on(p); } A[2] = *s; ++s; if (s == e){ typename R_::Triangle_3 t( A[0], A[1], A[2] ); return t.has_on(p); } A[3] = *s; ++s; if (s == e){ typename R_::Tetrahedron_3 t( A[0], A[1], A[2], A[3] ); return !t.has_on_unbounded_side(p); } return false; // should be unreachable ! } }; Contained_in_simplex_d contained_in_simplex_d_object() const { return Contained_in_simplex_d(); } struct Contained_in_affine_hull_d { template bool operator()(I s, I e, const Point_d& p) { CGAL_assertion_code( Affinely_independent_d affinely_independent; ) CGAL_assertion( affinely_independent(s,e) ); Point_d A[3]; A[0] = *s; ++s; if(s == e){ return p == A[0]; } A[1] = *s; ++s; if (s == e){ return collinear( p, A[0], A[1] ); } A[2] = *s; ++s; if (s == e){ return coplanar( p, A[0], A[1], A[2] ); } return false; } }; Contained_in_affine_hull_d contained_in_affine_hull_d_object() const { return Contained_in_affine_hull_d(); } struct Component_accessor_d { template int dimension(const C& c) const { return c.dimension(); } template RT homogeneous(const C& c, int i) { return c.homogeneous(i); } template FT cartesian(const C& c, int i) { return c.cartesian(i); } }; Component_accessor_d component_accessor_d_object() const { return Component_accessor_d(); } struct Orthogonal_vector_d { Vector_d operator()(const Hyperplane_d& h) const { return h.orthogonal_vector(); } }; Orthogonal_vector_d orthogonal_vector_d_object() const { return Orthogonal_vector_d(); } struct Point_to_vector_d { Vector_d operator()(const Point_d& p) const { return p-CGAL::ORIGIN; } }; Point_to_vector_d point_to_vector_d_object() const { return Point_to_vector_d(); } struct Vector_to_point_d { Point_d operator()(const Vector_d& v) const { return CGAL::ORIGIN+v; } }; Vector_to_point_d vector_to_point_d_object() const { return Vector_to_point_d(); } struct Construct_vector_d { Vector_d operator()(int, Null_vector) const { return Vector_d(NULL_VECTOR); } }; Construct_vector_d construct_vector_d_object() const { return Construct_vector_d(); } struct Construct_hyperplane_d { template Hyperplane_d operator()(I s, I e, const Point_d& p, Oriented_side side) { Hyperplane_d pl; Point_d A[3]; A[0] = *s; ++s; if(s == e){ pl = Hyperplane_d( A[0], A[0] - p); } else { A[1] = *s; ++s; if(s == e){ typename R_::Point_3 hp = A[0] + cross_product( p - A[0], A[1] - A[0] ); pl = Hyperplane_d( A[0], A[1], hp ); } else { A[2] = *s; ++s; if(s == e){ pl = Hyperplane_d( A[0], A[1], A[2] ); } else { CGAL_assertion(false); } } } if (side != 0) { if ( pl.oriented_side(p) != side ) { pl = pl.opposite(); } } return pl; } }; Construct_hyperplane_d construct_hyperplane_d_object() const { return Construct_hyperplane_d(); } typedef typename R::Intersect_3 Intersect_d; Intersect_d intersect_d_object() const { return Intersect_d(); } }; CGAL_END_NAMESPACE #endif //CONVEX_HULL_D_TRAITS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/iterator.h0000644000175000017500000010026711344301500027030 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_ITERATOR_H #define CGAL_ITERATOR_H 1 #include #include #include CGAL_BEGIN_NAMESPACE // +----------------------------------------------------------------+ // | Emptyset_iterator // +----------------------------------------------------------------+ // | sends everything to /dev/null // +----------------------------------------------------------------+ struct Emptyset_iterator #if defined(__GNUC__) && (__GNUC__ < 3) : public std::output_iterator #else : public std::iterator< std::output_iterator_tag, void, void, void*, void > #endif // defined(__GNUC__) && (__GNUC__ < 3) { Emptyset_iterator() {} Emptyset_iterator(const Emptyset_iterator&) {} template< class T > Emptyset_iterator& operator=(const T&) { return *this; } Emptyset_iterator& operator++() { return *this; } Emptyset_iterator& operator++(int) { return *this; } Emptyset_iterator& operator*() { return *this; } }; // +---------------------------------------------------------------------+ // | Insert_iterator // +---------------------------------------------------------------------+ // | Insert output iterator, which calls insert(value) on the container. // | Similar to std::insert_iterator<> except it doesn't pass an iterator. // +---------------------------------------------------------------------+ template < class Container > class Insert_iterator #if defined(__GNUC__) && (__GNUC__ < 3) : public std::output_iterator #else : public std::iterator< std::output_iterator_tag, void, void, void*, void > #endif // defined(__GNUC__) && (__GNUC__ < 3) { protected: Container *container; public: typedef Container container_type; explicit Insert_iterator(Container &c) : container(&c) {} Insert_iterator& operator=(typename Container::const_reference value) { container->insert(value); return *this; } Insert_iterator& operator*() { return *this; } Insert_iterator& operator++() { return *this; } Insert_iterator operator++(int) { return *this; } }; template < class Container > inline Insert_iterator inserter(Container &x) { return Insert_iterator(x); } // +----------------------------------------------------------------+ // | Oneset_iterator // +----------------------------------------------------------------+ // | stores a pointer to an object of type T // | which will be affected by operator*(). // +----------------------------------------------------------------+ template < class T > class Oneset_iterator #if defined(__GNUC__) && (__GNUC__ < 3) : public std::output_iterator #else : public std::iterator< std::output_iterator_tag, void, void, void*, void > #endif // defined(__GNUC__) && (__GNUC__ < 3) { T* t; public: Oneset_iterator(T& tt) : t(&tt) {} Oneset_iterator& operator++() { return *this; } Oneset_iterator& operator++(int) { return *this; } T& operator*() { return *t; } }; // +----------------------------------------------------------------+ // | Counting_output_iterator // +----------------------------------------------------------------+ // | stores a pointer to an int, // | which will be incremented by operator=(). // +----------------------------------------------------------------+ // Undocumented, because there is some hope to merge it into Counting_iterator class Counting_output_iterator #if defined(__GNUC__) && (__GNUC__ < 3) : public std::output_iterator #else : public std::iterator< std::output_iterator_tag, void, void, void*, void > #endif // defined(__GNUC__) && (__GNUC__ < 3) { std::size_t c; public: Counting_output_iterator() : c(0) {} Counting_output_iterator& operator++() { return *this; } Counting_output_iterator& operator++(int) { return *this; } Counting_output_iterator& operator*() { return *this; } template void operator=(const T&) { ++c; } std::size_t current_counter() const { return c;} }; template < class I, class Val = typename std::iterator_traits::value_type > class Counting_iterator { protected: I nt; // The internal iterator. std::size_t d_i; // The internal counter. public: typedef I Iterator; typedef Counting_iterator Self; typedef std::input_iterator_tag iterator_category; typedef Val value_type; typedef std::ptrdiff_t difference_type; typedef const value_type& reference; typedef const value_type* pointer; // CREATION // -------- Counting_iterator( std::size_t i = 0) : d_i(i) {} Counting_iterator( Iterator j, std::size_t i = 0) : nt(j), d_i(i) {} // OPERATIONS Forward Category // --------------------------- Iterator current_iterator() const { return nt;} std::size_t current_counter() const { return d_i;} bool operator==( const Self& i) const { return ( d_i == i.d_i); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return *nt; } pointer operator->() const { return nt.operator->(); } Self& operator++() { ++nt; ++d_i; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class I, int N, class Ref = typename std::iterator_traits::reference, class Ptr = typename std::iterator_traits::pointer, class Val = typename std::iterator_traits::value_type, class Dist = typename std::iterator_traits::difference_type, class Ctg = typename std::iterator_traits::iterator_category > class N_step_adaptor { protected: I nt; // The internal iterator. public: typedef I Iterator; typedef N_step_adaptor Self; typedef std::iterator_traits ITI; typedef typename ITI::reference reference; typedef typename ITI::pointer pointer; typedef typename ITI::value_type value_type; typedef typename ITI::difference_type difference_type; typedef typename ITI::iterator_category iterator_category; // Special for circulators. typedef I_Circulator_size_traits C_S_Traits; typedef typename C_S_Traits::size_type size_type; // CREATION // -------- N_step_adaptor() {} N_step_adaptor( Iterator j) : nt(j) {} template N_step_adaptor( const N_step_adaptor& j) : nt( j.current_iterator()) {} // OPERATIONS Forward Category // --------------------------- // Circulator stuff. typedef I Circulator; Circulator current_circulator() const { return nt;} Iterator current_iterator() const { return nt;} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == 0); return ( nt == 0); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return *nt; } pointer operator->() const { return nt.operator->(); } Self& operator++() { std::advance( nt, N); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { std::advance( nt, -N); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self min_circulator() const { return Self( nt.min_circulator()); } Self& operator+=( difference_type n) { nt += difference_type(N * n); return *this; } Self operator+( difference_type n) const { Self tmp = *this; tmp.nt += difference_type(N * n); return tmp; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return (nt-i.nt)/N;} reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator<( const Self& i) const { return ( nt < i.nt); } bool operator>( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; // Microsoft 1300 cannot handle the default template parameters. Hence, ... template < class I, int N, class Ref, class Ptr, class Val, class Dist, class Ctg > inline N_step_adaptor operator+(typename N_step_adaptor::difference_type n, N_step_adaptor i) { return i += n; } template < class I, int N> class N_step_adaptor_derived : public I { public: typedef I Iterator; typedef I Circulator; typedef N_step_adaptor_derived Self; typedef typename I::iterator_category iterator_category; typedef typename I::value_type value_type; typedef typename I::difference_type difference_type; typedef typename I::reference reference; typedef typename I::pointer pointer; // Special for circulators. typedef I_Circulator_size_traits C_S_Traits; typedef typename C_S_Traits::size_type size_type; // CREATION // -------- N_step_adaptor_derived() {} N_step_adaptor_derived( Iterator j) : I(j) {} template N_step_adaptor_derived( const N_step_adaptor_derived& j) : I( j.current_iterator()) {} // OPERATIONS Forward Category // --------------------------- Circulator current_circulator() const { return *this;} Iterator current_iterator() const { return *this;} Self& operator++() { std::advance( (I&)*this, N); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { std::advance( (I&)*this, -N); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self min_circulator() const { return Self( I::min_circulator()); } Self& operator+=( difference_type n) { I::operator+=( difference_type(N * n)); return *this; } Self operator+( difference_type n) const { Self tmp = *this; tmp += n; return tmp; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return (I::operator-(i)) / N; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } }; template < class I, int N > inline N_step_adaptor_derived operator+( typename N_step_adaptor_derived::difference_type n, N_step_adaptor_derived i) { return i += n; } template < class I, class P > struct Filter_iterator; template < class I, class P > bool operator==(const Filter_iterator&, const Filter_iterator&); template < class I, class P > struct Filter_iterator { typedef I Iterator; typedef P Predicate; typedef Filter_iterator Self; typedef std::iterator_traits ITI; typedef typename ITI::reference reference; typedef typename ITI::pointer pointer; typedef typename ITI::value_type value_type; typedef typename ITI::difference_type difference_type; typedef typename ITI::iterator_category iterator_category; // Special for circulators. typedef I_Circulator_size_traits C_S_Traits; typedef typename C_S_Traits::size_type size_type; protected: Iterator e_; // past-the-end position. Iterator c_; // current position. Predicate p_; // Leave out x <==> p_(x). public: Filter_iterator() {} Filter_iterator(Iterator e, const Predicate& p) : e_(e), c_(e), p_(p) {} Filter_iterator(Iterator e, const Predicate& p, Iterator c) : e_(e), c_(c), p_(p) { while (c_ != e_ && p_(c_)) ++c_; } Self& operator++() { do { ++c_; } while (c_ != e_ && p_(c_)); return *this; } Self& operator--() { do { --c_; } while (p_(c_)); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } reference operator*() const { return *c_; } pointer operator->() const { return &*c_; } const Predicate& predicate() const { return p_; } Iterator base() const { return c_; } bool is_end() const { return (c_ == e_); } friend bool operator== <>(const Self&, const Self&); }; template < class I, class P > inline Filter_iterator< I, P > filter_iterator(I e, const P& p) { return Filter_iterator< I, P >(e, p); } template < class I, class P > inline Filter_iterator< I, P > filter_iterator(I e, const P& p, I c) { return Filter_iterator< I, P >(e, p, c); } template < class I, class P > inline bool operator==(const Filter_iterator& it1, const Filter_iterator& it2) { CGAL_precondition(it1.e_ == it2.e_); return it1.base() == it2.base(); } template < class I, class P > inline bool operator!=(const Filter_iterator& it1, const Filter_iterator& it2) { return !(it1 == it2); } template < class I1, class Creator > class Join_input_iterator_1 { // the join of one iterator `i1'. Applies `Creator' with // one argument `*i1'. `value_type' is equal to // `Creator::result_type'. public: typedef Join_input_iterator_1 Self; typedef std::input_iterator_tag iterator_category; typedef typename Creator::result_type value_type; typedef std::iterator_traits ITraits; typedef typename ITraits::difference_type difference_type; typedef const value_type& reference; typedef const value_type* pointer; protected: I1 j1; // The 1st internal iterator. value_type val; // The current (internal) value. public: // CREATION // -------- Join_input_iterator_1() {} Join_input_iterator_1( I1 i1) : j1(i1), val(Creator()(*j1)) {} // OPERATIONS Forward Category // --------------------------- I1 current_iterator1() const { return j1;} bool operator==( const Self& i) const { return ( j1 == i.j1); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return val; } pointer operator->() const { return &val; } Self& operator++() { ++j1; val = Creator()(*j1); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class I1, class I2, class Creator > class Join_input_iterator_2 { // the join of two iterators `i1' and `i2'. Applies `Creator' with // two arguments `*i1' and `*i2'. `value_type' is equal to // `Creator::result_type'. public: typedef Join_input_iterator_2 Self; typedef std::input_iterator_tag iterator_category; typedef typename Creator::result_type value_type; typedef std::iterator_traits ITraits; typedef typename ITraits::difference_type difference_type; typedef const value_type& reference; typedef const value_type* pointer; protected: I1 j1; // The 1st internal iterator. I2 j2; // The 2nd internal iterator. value_type val; // The current (internal) value. public: // CREATION // -------- Join_input_iterator_2() {} Join_input_iterator_2( I1 i1, I2 i2) : j1(i1), j2(i2), val(Creator()(*j1,*j2)) {} // OPERATIONS Forward Category // --------------------------- I1 current_iterator1() const { return j1;} I2 current_iterator2() const { return j2;} bool operator==( const Self& i) const { return ( j1 == i.j1 && j2 == i.j2); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return val; } pointer operator->() const { return &val; } Self& operator++() { ++j1; ++j2; val = Creator()(*j1,*j2); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class I1, class I2, class I3, class Creator > class Join_input_iterator_3 { // the join of two iterators `i1' up to `i3'. Applies `Creator' with // three arguments `*i1' up to `*i3'. `value_type' is equal to // `Creator::result_type'. public: typedef Join_input_iterator_3 Self; typedef std::input_iterator_tag iterator_category; typedef typename Creator::result_type value_type; typedef std::iterator_traits ITraits; typedef typename ITraits::difference_type difference_type; typedef const value_type& reference; typedef const value_type* pointer; protected: I1 j1; // The 1st internal iterator. I2 j2; // The 2nd internal iterator. I3 j3; // The 3rd internal iterator. value_type val; // The current (internal) value. public: // CREATION // -------- Join_input_iterator_3() {} Join_input_iterator_3( I1 i1, I2 i2, I3 i3) : j1(i1), j2(i2), j3(i3), val(Creator()(*j1,*j2,*j3)) {} // OPERATIONS Forward Category // --------------------------- I1 current_iterator1() const { return j1;} I2 current_iterator2() const { return j2;} I3 current_iterator3() const { return j3;} bool operator==( const Self& i) const { return ( j1 == i.j1 && j2 == i.j2 && j3 == i.j3); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return val; } pointer operator->() const { return &val; } Self& operator++() { ++j1; ++j2; ++j3; val = Creator()(*j1,*j2,*j3); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class I1, class I2, class I3, class I4, class Creator > class Join_input_iterator_4 { // the join of two iterators `i1' up to `i4'. Applies `Creator' with // four arguments `*i1' up to `*i4'. `value_type' is equal to // `Creator::result_type'. public: typedef Join_input_iterator_4 Self; typedef std::input_iterator_tag iterator_category; typedef typename Creator::result_type value_type; typedef std::iterator_traits ITraits; typedef typename ITraits::difference_type difference_type; typedef const value_type& reference; typedef const value_type* pointer; protected: I1 j1; // The 1st internal iterator. I2 j2; // The 2nd internal iterator. I3 j3; // The 3rd internal iterator. I4 j4; // The 4th internal iterator. value_type val; // The current (internal) value. public: // CREATION // -------- Join_input_iterator_4() {} Join_input_iterator_4( I1 i1, I2 i2, I3 i3, I4 i4) : j1(i1), j2(i2), j3(i3), j4(i4), val(Creator()(*j1,*j2,*j3,*j4)){} // OPERATIONS Forward Category // --------------------------- I1 current_iterator1() const { return j1;} I2 current_iterator2() const { return j2;} I3 current_iterator3() const { return j3;} I4 current_iterator4() const { return j4;} bool operator==( const Self& i) const { return ( j1 == i.j1 && j2 == i.j2 && j3 == i.j3 && j4 == i.j4); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return val; } pointer operator->() const { return &val; } Self& operator++() { ++j1; ++j2; ++j3; ++j4; val = Creator()(*j1,*j2,*j3,*j4); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class I1, class I2, class I3, class I4, class I5, class Creator > class Join_input_iterator_5 { // the join of two iterators `i1' up to `i5'. Applies `Creator' with // five arguments `*i1' up to `*i5'. `value_type' is equal to // `Creator::result_type'. public: typedef Join_input_iterator_5 Self; typedef std::input_iterator_tag iterator_category; typedef typename Creator::result_type value_type; typedef std::iterator_traits ITraits; typedef typename ITraits::difference_type difference_type; typedef const value_type& reference; typedef const value_type* pointer; protected: I1 j1; // The 1st internal iterator. I2 j2; // The 2nd internal iterator. I3 j3; // The 3rd internal iterator. I4 j4; // The 4th internal iterator. I5 j5; // The 5th internal iterator. value_type val; // The current (internal) value. public: // CREATION // -------- Join_input_iterator_5() {} Join_input_iterator_5( I1 i1, I2 i2, I3 i3, I4 i4, I5 i5) : j1(i1), j2(i2), j3(i3), j4(i4), j5(i5), val(Creator()(*j1,*j2,*j3,*j4,*j5)) {} // OPERATIONS Forward Category // --------------------------- I1 current_iterator1() const { return j1;} I2 current_iterator2() const { return j2;} I3 current_iterator3() const { return j3;} I4 current_iterator4() const { return j4;} I5 current_iterator5() const { return j5;} bool operator==( const Self& i) const { return ( j1 == i.j1 && j2 == i.j2 && j3 == i.j3 && j4 == i.j4 && j5 == i.j5); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return val; } pointer operator->() const { return &val; } Self& operator++() { ++j1; ++j2; ++j3; ++j4; ++j5; val = Creator()(*j1,*j2,*j3,*j4,*j5); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class IC> class Inverse_index { // DEFINITION // // The class Inverse_index constructs an inverse index for a // given range [i,j) of two iterators or circulators of type `IC' with the // value type `T'. The first element I in the // range [i,j) has the index 0. Consecutive elements are numbered // incrementally. The inverse index provides a query for a given iterator // or circulator k to retrieve its index number. For random access // iterators or circulators, it is done in constant time by subtracting i. // For other iterator categories, an STL `map' is used, which results in a // log j-i query time. A comparison operator `operator<' is needed for // `T*'. // // CREATION protected: typedef std::map< const void*, std::size_t, std::less > Index; Index idx; IC start; typedef typename Index::iterator Index_iterator; typedef typename Index::const_iterator Index_const_iterator; typedef typename Index::value_type Item; protected: void ini_idx( IC i, const IC& j, std::input_iterator_tag); void ini_idx( const IC& i, const IC& j, std::forward_iterator_tag){ ini_idx( i, j, std::input_iterator_tag()); } void ini_idx(const IC& i,const IC& j, std::bidirectional_iterator_tag){ ini_idx( i, j, std::input_iterator_tag()); } void ini_idx( const IC& i, const IC& j, Forward_circulator_tag) { ini_idx( i, j, std::input_iterator_tag()); } void ini_idx( const IC& i, const IC& j, Bidirectional_circulator_tag){ ini_idx( i, j, std::input_iterator_tag()); } void ini_idx( const IC&, const IC&, std::random_access_iterator_tag){} void ini_idx( const IC&, const IC&, Random_access_circulator_tag){} public: void init_index( const IC& i, const IC& j) { typedef typename std::iterator_traits::iterator_category ICC; ini_idx( i, j, ICC()); } protected: void push_back( const IC& k, std::input_iterator_tag) { std::size_t d = idx.size(); idx[ &*k] = d; } void push_back( const IC& k, std::forward_iterator_tag){ push_back( k, std::input_iterator_tag()); } void push_back( const IC& k, std::bidirectional_iterator_tag){ push_back( k, std::input_iterator_tag()); } void push_back( const IC& k, Forward_circulator_tag){ push_back( k, std::input_iterator_tag()); } void push_back( const IC& k, Bidirectional_circulator_tag){ push_back( k, std::input_iterator_tag()); } void push_back( const IC&, std::random_access_iterator_tag){} void push_back( const IC&, Random_access_circulator_tag){} public: void push_back( const IC& k) { // adds k at the end of the indices. typedef typename std::iterator_traits::iterator_category ICC; push_back( k, ICC()); } std::size_t find( const IC& k, std::random_access_iterator_tag) const { return std::size_t(k - start); } std::size_t find( const IC& k, Random_access_circulator_tag) const { return std::size_t(k - start); } std::size_t find( const IC& k, std::input_iterator_tag) const { // returns inverse index of k. Index_const_iterator i = idx.find( &*k); CGAL_assertion( i != idx.end()); return (*i).second; } std::size_t find( const IC& k, std::forward_iterator_tag) const { return find( k, std::input_iterator_tag()); } std::size_t find( const IC& k, std::bidirectional_iterator_tag) const { return find( k, std::input_iterator_tag()); } std::size_t find( const IC& k, Forward_circulator_tag) const { return find( k, std::input_iterator_tag()); } std::size_t find( const IC& k, Bidirectional_circulator_tag) const { return find( k, std::input_iterator_tag()); } typedef IC iterator; typedef IC Circulator; typedef std::size_t size_type; Inverse_index() : start(IC()) {} // invalid index. Inverse_index( const IC& i) : start(i) {}; // empty inverse index initialized to start at i. Inverse_index( const IC& i, const IC& j) : start(i) { // inverse index initialized with range [i,j). init_index( i, j); } // OPERATIONS std::size_t operator[]( const IC& k) const { // returns inverse index of k. typedef typename std::iterator_traits::iterator_category category; return find( k, category()); } }; #if (defined(__GNUC__) && (__GNUC__ >= 3)) template < class IC> void Inverse_index< IC>::ini_idx( IC i, const IC& j, std::input_iterator_tag) { std::size_t n = 0; if ( ! is_empty_range( i, j)) { do { idx.insert(Item( &*i, n)); n++; } while ((++i) != (j)); } } #else template < class IC> void Inverse_index< IC>::ini_idx( IC i, const IC& j, std::input_iterator_tag) { std::size_t n = 0; Index_iterator hint = idx.begin(); if ( ! is_empty_range( i, j)) { do { hint = idx.insert( hint, Item( &*i, n)); n++; } while ((++i) != (j)); } } #endif // (__GNUC__ >= 3) template < class IC> class Random_access_adaptor { // DEFINITION // // The class Random_access_adaptor provides a random access // for data structures. Either the data structure supports random access // iterators or circulators where this class maps function calls to the // iterator or circulator, or a STL `vector' is used to provide the random // access. The iterator or circulator of the data structure are of type // `IC'. // // CREATION protected: typedef std::vector< IC> Index; Index index; IC start; public: typedef typename Index::size_type size_type; void init_index( IC i, const IC& j, std::forward_iterator_tag); void init_index( const IC& i, const IC& j, std::bidirectional_iterator_tag){ init_index( i, j, std::forward_iterator_tag()); } void init_index( const IC& i, const IC&, std::random_access_iterator_tag){ start = i; } void init_index( const IC& i, const IC& j) { typedef typename std::iterator_traits::iterator_category ICC; init_index( i, j, ICC()); } void reserve( size_type r, std::forward_iterator_tag) { index.reserve( r); } void reserve( size_type r, std::bidirectional_iterator_tag){ reserve( r, std::forward_iterator_tag()); } void reserve( size_type, std::random_access_iterator_tag){} void push_back( const IC& k, std::forward_iterator_tag) { index.push_back(k); } void push_back( const IC& k, std::bidirectional_iterator_tag){ push_back( k, std::forward_iterator_tag()); } void push_back( const IC&, std::random_access_iterator_tag){} const IC& find( size_type n, std::forward_iterator_tag) const { // returns inverse index of k. CGAL_assertion( n < index.size()); return index[n]; } const IC& find( size_type n, std::bidirectional_iterator_tag) const { return find( n, std::forward_iterator_tag()); } IC find( size_type n, std::random_access_iterator_tag) const { return start + n; } typedef IC iterator; typedef IC Circulator; Random_access_adaptor() : start(IC()) {} // invalid index. Random_access_adaptor( const IC& i) : start(i) {} // empty random access index initialized to start at i. Random_access_adaptor( const IC& i, const IC& j) : start(i) { // random access index initialized with range [i,j). init_index( i, j); } void reserve( size_type r) { // reserve r entries, if a `vector' is used internally. typedef typename std::iterator_traits::iterator_category ICC; reserve( r, ICC()); } // OPERATIONS IC find( size_type n) const { // returns inverse index of k. typedef typename std::iterator_traits::iterator_category ICC; return find( n, ICC()); } IC operator[]( size_type n) const { return find(n); } void push_back( const IC& k) { // adds k at the end of the indices. typedef typename std::iterator_traits::iterator_category ICC; push_back( k, ICC()); } }; template < class IC> void Random_access_adaptor< IC>::init_index( IC i, const IC& j, std::forward_iterator_tag) { if ( ! is_empty_range( i, j)) { do { index.push_back( i); } while ((++i) != (j)); } } template < class IC, class T > class Random_access_value_adaptor : public Random_access_adaptor { public: typedef typename Random_access_adaptor::size_type size_type; Random_access_value_adaptor() {} // invalid index. Random_access_value_adaptor( const IC& i) : Random_access_adaptor(i) {} // empty random access index initialized to start at i. Random_access_value_adaptor( const IC& i, const IC& j) : Random_access_adaptor(i,j) {} // random access index initialized with range [i,j). // OPERATIONS T& operator[]( size_type n) const { // returns inverse index of k. return *(Random_access_adaptor::operator[](n)); } }; CGAL_END_NAMESPACE #endif // CGAL_ITERATOR_H // // EOF // ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Segment_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Segment_2_in0000644000175000017500000003636411344301500031173 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Segment_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SEGMENT_2_SEGMENT_2_INTERSECTION_H #define CGAL_SEGMENT_2_SEGMENT_2_INTERSECTION_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Segment_2_Segment_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Segment_2_Segment_2_pair() ; Segment_2_Segment_2_pair(typename K::Segment_2 const *seg1, typename K::Segment_2 const *seg2); ~Segment_2_Segment_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: typename K::Segment_2 const* _seg1; typename K::Segment_2 const * _seg2; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point, _other_point; }; template inline bool do_intersect(const typename K::Segment_2 &seg1, const typename K::Segment_2 &seg2); template bool seg_seg_do_intersect_crossing( const typename K::Point_2 &p1, const typename K::Point_2 &p2, const typename K::Point_2 &p3, const typename K::Point_2 &p4, const K& k) { typename K::Orientation_2 orientation; switch (orientation(p1,p2,p3)) { case LEFT_TURN: return ! (orientation(p3,p4,p2) == RIGHT_TURN); // right_turn(p3,p4,p2); case RIGHT_TURN: return ! (orientation(p3,p4,p2) == LEFT_TURN); //left_turn(p3,p4,p2); case COLLINEAR: return true; } CGAL_kernel_assertion(false); return false; } template bool seg_seg_do_intersect_contained( const typename K::Point_2 &p1, const typename K::Point_2 &p2, const typename K::Point_2 &p3, const typename K::Point_2 &p4, const K& k) { typename K::Orientation_2 orientation; switch (orientation(p1,p2,p3)) { case LEFT_TURN: return ! (orientation(p1,p2,p4) == LEFT_TURN); // left_turn(p1,p2,p4); case RIGHT_TURN: return ! (orientation(p1,p2,p4) == RIGHT_TURN); // right_turn(p1,p2,p4); case COLLINEAR: return true; } CGAL_kernel_assertion(false); return false; } template bool do_intersect(const typename CGAL_WRAP(K)::Segment_2 &seg1, const typename CGAL_WRAP(K)::Segment_2 &seg2, const K& k) { typename K::Point_2 const & A1 = seg1.source(); typename K::Point_2 const & A2 = seg1.target(); typename K::Point_2 const & B1 = seg2.source(); typename K::Point_2 const & B2 = seg2.target(); typename K::Less_xy_2 less_xy; typename K::Compare_xy_2 compare_xy; if (less_xy(A1,A2)) { if (less_xy(B1,B2)) { if (less_xy(A2,B1) || less_xy(B2,A1)) return false; } else { if (less_xy(A2,B2) || less_xy(B1,A1)) return false; } } else { if (less_xy(B1,B2)) { if (less_xy(A1,B1) || less_xy(B2,A2)) return false; } else { if (less_xy(A1,B2) || less_xy(B1,A2)) return false; } } if (less_xy(A1,A2)) { if (less_xy(B1,B2)) { switch(compare_xy(A1,B1)) { case SMALLER: switch(compare_xy(A2,B1)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(A2,B2)) { case SMALLER: return seg_seg_do_intersect_crossing(A1,A2,B1,B2, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(A1,A2,B1,B2, k); } } case EQUAL: return true; case LARGER: switch(compare_xy(B2,A1)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(B2,A2)) { case SMALLER: return seg_seg_do_intersect_crossing(B1,B2,A1,A2, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(B1,B2,A1,A2, k); } } } } else { switch(compare_xy(A1,B2)) { case SMALLER: switch(compare_xy(A2,B2)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(A2,B1)) { case SMALLER: return seg_seg_do_intersect_crossing(A1,A2,B2,B1, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(A1,A2,B2,B1, k); } } case EQUAL: return true; case LARGER: switch(compare_xy(B1,A1)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(B1,A2)) { case SMALLER: return seg_seg_do_intersect_crossing(B2,B1,A1,A2, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(B2,B1,A1,A2, k); } } } } } else { if (less_xy(B1,B2)) { switch(compare_xy(A2,B1)) { case SMALLER: switch(compare_xy(A1,B1)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(A1,B2)) { case SMALLER: return seg_seg_do_intersect_crossing(A2,A1,B1,B2, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(A2,A1,B1,B2, k); } } case EQUAL: return true; case LARGER: switch(compare_xy(B2,A2)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(B2,A1)) { case SMALLER: return seg_seg_do_intersect_crossing(B1,B2,A2,A1, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(B1,B2,A2,A1, k); } } } } else { switch(compare_xy(A2,B2)) { case SMALLER: switch(compare_xy(A1,B2)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(A1,B1)) { case SMALLER: return seg_seg_do_intersect_crossing(A2,A1,B2,B1, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(A2,A1,B2,B1, k); } } case EQUAL: return true; case LARGER: switch(compare_xy(B1,A2)) { case SMALLER: return false; case EQUAL: return true; case LARGER: switch(compare_xy(B1,A1)) { case SMALLER: return seg_seg_do_intersect_crossing(B2,B1,A2,A1, k); case EQUAL: return true; case LARGER: return seg_seg_do_intersect_contained(B2,B1,A2,A1, k); } } } } } CGAL_kernel_assertion(false); return false; } template Segment_2_Segment_2_pair::Segment_2_Segment_2_pair() { _seg1 = 0; _seg2 = 0; _known = false; } template Segment_2_Segment_2_pair::Segment_2_Segment_2_pair( typename K::Segment_2 const *seg1, typename K::Segment_2 const *seg2) { _seg1 = seg1; _seg2 = seg2; _known = false; } template typename Segment_2_Segment_2_pair::Intersection_results Segment_2_Segment_2_pair::intersection_type() const { typename K::Construct_vector_2 construct_vector; if (_known) return _result; _known = true; if (!do_intersect(*_seg1, *_seg2, K())) { _result = NO; return _result; } typename K::Line_2 const &l1 = _seg1->supporting_line(); typename K::Line_2 const &l2 = _seg2->supporting_line(); Line_2_Line_2_pair linepair(&l1, &l2); switch ( linepair.intersection_type()) { case Line_2_Line_2_pair::NO: _result = NO; break; case Line_2_Line_2_pair::POINT: linepair.intersection(_intersection_point); _result = POINT; break; case Line_2_Line_2_pair::LINE: { typedef typename K::RT RT; typename K::Point_2 const &start1 = _seg1->source(); typename K::Point_2 const &end1 = _seg1->target(); typename K::Point_2 const &start2 = _seg2->source(); typename K::Point_2 const &end2 = _seg2->target(); typename K::Vector_2 diff1 = construct_vector(start1, end1); typename K::Point_2 const *minpt; typename K::Point_2 const *maxpt; if (CGAL_NTS abs(diff1.x()) > CGAL_NTS abs(diff1.y())) { if (start1.x() < end1.x()) { minpt = &start1; maxpt = &end1; } else { minpt = &end1; maxpt = &start1; } if (start2.x() < end2.x()) { if (start2.x() > minpt->x()) { minpt = &start2; } if (end2.x() < maxpt->x()) { maxpt = &end2; } } else { if (end2.x() > minpt->x()) { minpt = &end2; } if (start2.x() < maxpt->x()) { maxpt = &start2; } } if (maxpt->x() < minpt->x()) { _result = NO; return _result; } if (maxpt->x() == minpt->x()) { _intersection_point = *minpt; _result = POINT; return _result; } _intersection_point = *minpt; _other_point = *maxpt; _result = SEGMENT; return _result; } else { if (start1.y() < end1.y()) { minpt = &start1; maxpt = &end1; } else { minpt = &end1; maxpt = &start1; } if (start2.y() < end2.y()) { if (start2.y() > minpt->y()) { minpt = &start2; } if (end2.y() < maxpt->y()) { maxpt = &end2; } } else { if (end2.y() > minpt->y()) { minpt = &end2; } if (start2.y() < maxpt->y()) { maxpt = &start2; } } if (maxpt->y() < minpt->y()) { _result = NO; return _result; } if (maxpt->y() == minpt->y()) { _intersection_point = *minpt; _result = POINT; return _result; } _intersection_point = *minpt; _other_point = *maxpt; _result = SEGMENT; return _result; } } } return _result; } template bool Segment_2_Segment_2_pair::intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Segment_2_Segment_2_pair::intersection(typename K::Segment_2 &result) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = Segment_2(_intersection_point, _other_point); return true; } template Object intersection(const typename CGAL_WRAP(K)::Segment_2 &seg1, const typename CGAL_WRAP(K)::Segment_2 &seg2, const K&) { typedef Segment_2_Segment_2_pair is_t; is_t ispair(&seg1, &seg2); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } } // namespace CGALi template inline bool do_intersect(const Segment_2 &seg1, const Segment_2 &seg2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(seg1, seg2); } template Object intersection(const Segment_2 &seg1, const Segment_2 &seg2) { typedef typename K::Intersect_2 Intersect; return Intersect()(seg1, seg2); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Indirect_less_xy_2.h0000644000175000017500000000241711344301500030725 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Indirect_less_xy_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_INDIRECT_LESS_XY_2_H #define CGAL_INDIRECT_LESS_XY_2_H namespace CGAL { template class Indirect_less_xy_2 { public: typedef typename Traits::Less_xy_2 Less_xy_2; Indirect_less_xy_2() : _less_xy_2(Traits().less_xy_2_object()) { } template bool operator()(Iterator p, Iterator q) const { return _less_xy_2(*p, *q); } private: Less_xy_2 _less_xy_2; }; } #endif // CGAL_INDIRECT_LESS_XY_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/sweep_observer.h0000644000175000017500000001466511344301501030240 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/sweep_observer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_SWEEP_OBSERVER_H #define CGAL_SWEEP_OBSERVER_H #include namespace CGAL { // TR is traits template class client_base { public: virtual void call(TR) const = 0; }; template class Event_hook { typedef client_base* p_client_base; typedef std::list< p_client_base > clientlist; protected: clientlist clients; public: Event_hook() : clients() {} ~Event_hook() { while ( !clients.empty() ) { delete (*clients.begin()); clients.pop_front(); } } void operator()(TR t) const { if ( clients.empty() ) return; for ( typename clientlist::const_iterator it=clients.begin(); it != clients.end(); ++it ) (*it)->call(t); } void attach(p_client_base psb) { clients.push_back(psb); } }; // TR is traits, OBS is observer template class client : public client_base { protected: OBS& obs_ref; void (OBS::* p_fnc)(TR); // pointer to member of Observer which works on an object of type TR public: client( OBS& obs, void (OBS::* p_fnc_init)(TR) ) : obs_ref(obs), p_fnc(p_fnc_init) {} void call(TR t) const { (obs_ref.*p_fnc)(t); } }; template inline void attach(Event_hook& h, OBS& obs, void (OBS::* p_fct)(TR t)) { client* ps = new client(obs,p_fct); h.attach( (client_base*) ps); } /*{\Moptions outfile=sweep_observer.man}*/ /*{\Manpage {sweep_observer}{GPS,VT} {Observing the plane sweep class}{Obs}}*/ /*{\Mdefinition The data type |\Mname| provides an observer approach to the visualization of a sweep algorithm realized by |GPS = generic_sweep| by means of an event mechanism. It allows to connect the events of an instance of |GPS| to the visualization operations provided by the traits class |VT|.}*/ template class sweep_observer { VT vt; typedef typename GPS::TRAITS GPSTRAITS; typedef typename VT::VDEVICE VDEVICE; void post_init_animation(GPSTRAITS& gpst) { vt.post_init_animation(gpst); } void pre_event_animation(GPSTRAITS& gpst) { vt.pre_event_animation(gpst); } void post_event_animation(GPSTRAITS& gpst) { vt.post_event_animation(gpst); } void post_completion_animation(GPSTRAITS& gpst) { vt.post_completion_animation(gpst); } public : /*{\Mcreation 3cm}*/ sweep_observer() : vt() {} /*{\Mcreate creates an object of type |VT| which can support a visualization device to visualize a sweep object of type |GPS|.}*/ sweep_observer(GPS& gps); /*{\Mcreate creates an object of type |VT| which can support a visualization device to visualize a sweep object of type |GPS| and makes it an observer of |gps|.}*/ /*{\Moperations 2cm 2cm}*/ void attach(GPS& gps); /*{\Mop makes |\Mvar| an observer of |gps|.}*/ VDEVICE& device() { return vt.device(); } }; /*{\Mexample A typical sweep observation based on |\Mname| looks like the following little program: \begin{Mverb} typedef generic_sweep triang_sweep; triang_sweep Ts(...); sweep_observer< triang_sweep, cgal_window_stream_ts_visualization > Obs(Ts); Ts.sweep(); \end{Mverb} This would visualize the sweep actions in the observer window by means of the visualization functions provided in |cgal_\-window_\-stream_\-ts_\-visualization| }*/ template sweep_observer:: sweep_observer(GPS& gps) : vt() { attach(gps); } template void sweep_observer::attach(GPS& gps) { CGAL::attach(gps.post_init_hook, *this, &sweep_observer::post_init_animation); CGAL::attach(gps.pre_event_hook, *this, &sweep_observer::pre_event_animation); CGAL::attach(gps.post_event_hook, *this, &sweep_observer::post_event_animation); CGAL::attach(gps.post_completion_hook, *this, &sweep_observer::post_completion_animation); } #ifdef THIS_IS_JUST_A_CONCEPT_DEFINITION /*{\Moptions outfile=vgps_concept.man}*/ /*{\Manpage {GPS_visualization_concept}{} {Visualization of the generic plane sweep}{C}}*/ class GPS_visualization_concept { /*{\Mdefinition |\Mtype| is the concept for the second template parameter |VT| of the sweep observer |sweep_observer| defined above. It provides the interface to adapt the sweep observation process to a visualization device. }*/ /*{\Mtypes 5}*/ typedef some_visualization_device VDEVICE; /*{\Mtypemember the visualization device}*/ /*{\Mcreation 3}*/ GPS_visualization_concept(); /*{\Mcreate can be used to initialize and display the visualization device.}*/ /*{\Moperations}*/ void post_init_animation(GPS::TRAITS& gpst) /*{\Mop animation actions after the initialization of the sweep.}*/ void pre_event_animation(GPS::TRAITS& gpst) /*{\Mop animation actions before each event handling.}*/ void post_event_animation(GPS::TRAITS& gpst) /*{\Mop animation actions after each event handling.}*/ void post_completion_animation(GPS::TRAITS& gpst) /*{\Mop animation actions after the completion phase of the sweep.}*/ VDEVICE& device() /*{\Mop access operation to the visualization device.}*/ /*{\Mtext Note that the entry point for visualization of the sweep is the access to an object |gpst| of type |GPS::TRAITS|. This is the sweep traits class triggering the sweep within the generic sweep framework and storing all status information of the sweep. Thereby it contains also all information necessary for visualization. |\Mvar| obtains access to this object at defined event points and can thereby analyze the status of |gpst| and trigger corresponding visualization actions via its visualization methods.}*/ }; #endif // THIS_IS_JUST_A_CONCEPT_DEFINITION } // namespace CGAL #endif // CGAL_SWEEP_OBSERVER_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_yz_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidea0000644000175000017500000000731711344301501031427 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_yz_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_YZ_3_H #define CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_YZ_3_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Orientation_yz_3 { public: typedef typename R::Point_3 Point; typename R::FT x(const Point &p) const { return p.y(); } typename R::FT y(const Point &p) const { return p.z(); } CGAL::Orientation operator()(const Point& p, const Point& q, const Point& r) { return orientationC2(x(p), y(p), x(q), y(q), x(r), y(r)); } }; template class Side_of_oriented_circle_yz_3 { public: typedef typename R::Point_3 Point; typename R::FT x(const Point &p) const { return p.y(); } typename R::FT y(const Point &p) const { return p.z(); } CGAL::Oriented_side operator() (const Point &p, const Point &q, const Point &r, const Point &s) { return side_of_oriented_circleC2(x(p), y(p), x(q), y(q), x(r), y(r), x(s), y(s)); } }; template < class R > class Triangulation_euclidean_traits_yz_3 { public: typedef Triangulation_euclidean_traits_yz_3 Traits; typedef R Rp; typedef typename Rp::Point_3 Point_2; typedef typename Rp::Segment_3 Segment_2; typedef typename Rp::Triangle_3 Triangle_2; typedef typename Rp::Compare_y_3 Compare_x_2; typedef typename Rp::Compare_z_3 Compare_y_2; typedef Orientation_yz_3 Orientation_2; typedef Side_of_oriented_circle_yz_3 Side_of_oriented_circle_2; typedef typename Rp::Construct_segment_3 Construct_segment_2; typedef typename Rp::Construct_triangle_3 Construct_triangle_2; // for compatibility with previous versions typedef Point_2 Point; typedef Segment_2 Segment; typedef Triangle_2 Triangle; Triangulation_euclidean_traits_yz_3(){} Triangulation_euclidean_traits_yz_3( const Triangulation_euclidean_traits_yz_3& ){} Triangulation_euclidean_traits_yz_3 &operator=( const Triangulation_euclidean_traits_yz_3& ){return *this;} typename Rp::FT x(const Point_2 &p) const { return p.y(); } typename Rp::FT y(const Point_2 &p) const { return p.z(); } Compare_x_2 compare_x_2_object() const { return Compare_x_2();} Compare_y_2 compare_y_2_object() const { return Compare_y_2();} Orientation_2 orientation_2_object() const { return Orientation_2();} Side_of_oriented_circle_2 side_of_oriented_circle_2_object() const {return Side_of_oriented_circle_2();} Construct_segment_2 construct_segment_2_object() const {return Construct_segment_2();} Construct_triangle_2 construct_triangle_2_object() const {return Construct_triangle_2();} }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_YZ_3_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_triangulation_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_triangulation0000644000175000017500000014732011344301500031454 0ustar debiandebian// Copyright (c) 1999-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_triangulation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Monique Teillaud // Sylvain Pion // Andreas Fabri #ifndef CGAL_DELAUNAY_TRIANGULATION_3_H #define CGAL_DELAUNAY_TRIANGULATION_3_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Tr > class Natural_neighbors_3; template < class Gt, class Tds = Triangulation_data_structure_3 < Triangulation_vertex_base_3, Triangulation_cell_base_3 > > class Delaunay_triangulation_3 : public Triangulation_3 { typedef Delaunay_triangulation_3 Self; typedef Triangulation_3 Tr_Base; friend class Natural_neighbors_3; public: typedef Tds Triangulation_data_structure; typedef Gt Geom_traits; typedef typename Gt::Point_3 Point; typedef typename Gt::Segment_3 Segment; typedef typename Gt::Triangle_3 Triangle; typedef typename Gt::Tetrahedron_3 Tetrahedron; // types for dual: typedef typename Gt::Line_3 Line; typedef typename Gt::Ray_3 Ray; typedef typename Gt::Plane_3 Plane; typedef typename Gt::Object_3 Object; typedef typename Tr_Base::Cell_handle Cell_handle; typedef typename Tr_Base::Vertex_handle Vertex_handle; typedef typename Tr_Base::Cell Cell; typedef typename Tr_Base::Vertex Vertex; typedef typename Tr_Base::Facet Facet; typedef typename Tr_Base::Edge Edge; typedef typename Tr_Base::Cell_circulator Cell_circulator; typedef typename Tr_Base::Facet_circulator Facet_circulator; typedef typename Tr_Base::Cell_iterator Cell_iterator; typedef typename Tr_Base::Facet_iterator Facet_iterator; typedef typename Tr_Base::Edge_iterator Edge_iterator; typedef typename Tr_Base::Vertex_iterator Vertex_iterator; typedef typename Tr_Base::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Tr_Base::Finite_cells_iterator Finite_cells_iterator; typedef typename Tr_Base::Finite_facets_iterator Finite_facets_iterator; typedef typename Tr_Base::Finite_edges_iterator Finite_edges_iterator; typedef typename Tr_Base::All_cells_iterator All_cells_iterator; typedef typename Tr_Base::Locate_type Locate_type; typedef Triple Vertex_triple; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Tr_Base::cw; using Tr_Base::ccw; using Tr_Base::geom_traits; using Tr_Base::number_of_vertices; using Tr_Base::dimension; using Tr_Base::finite_facets_begin; using Tr_Base::finite_facets_end; using Tr_Base::finite_vertices_begin; using Tr_Base::finite_vertices_end; using Tr_Base::finite_cells_begin; using Tr_Base::finite_cells_end; using Tr_Base::finite_edges_begin; using Tr_Base::finite_edges_end; using Tr_Base::tds; using Tr_Base::infinite_vertex; using Tr_Base::next_around_edge; using Tr_Base::vertex_triple_index; #endif protected: Oriented_side side_of_oriented_sphere(const Point &p0, const Point &p1, const Point &p2, const Point &p3, const Point &t, bool perturb = false) const; Bounded_side coplanar_side_of_bounded_circle(const Point &p, const Point &q, const Point &r, const Point &s, bool perturb = false) const; // for dual: Point construct_circumcenter(const Point &p, const Point &q, const Point &r) const { return geom_traits().construct_circumcenter_3_object()(p, q, r); } Point construct_circumcenter(const Point &p, const Point &q, const Point &r, const Point &s) const { return geom_traits().construct_circumcenter_3_object()(p, q, r, s); } Line construct_perpendicular_line(const Plane &pl, const Point &p) const { return geom_traits().construct_perpendicular_line_3_object()(pl, p); } Plane construct_plane(const Point &p, const Point &q, const Point &r) const { return geom_traits().construct_plane_3_object()(p, q, r); } Ray construct_ray(const Point &p, const Line &l) const { return geom_traits().construct_ray_3_object()(p, l); } Object construct_object(const Point &p) const { return geom_traits().construct_object_3_object()(p); } Object construct_object(const Segment &s) const { return geom_traits().construct_object_3_object()(s); } Object construct_object(const Ray &r) const { return geom_traits().construct_object_3_object()(r); } bool less_distance(const Point &p, const Point &q, const Point &r) const { return geom_traits().compare_distance_3_object()(p, q, r) == SMALLER; } public: Delaunay_triangulation_3(const Gt& gt = Gt()) : Tr_Base(gt) {} // copy constructor duplicates vertices and cells Delaunay_triangulation_3(const Delaunay_triangulation_3 & tr) : Tr_Base(tr) { CGAL_triangulation_postcondition( is_valid() ); } template < typename InputIterator > Delaunay_triangulation_3(InputIterator first, InputIterator last, const Gt& gt = Gt()) : Tr_Base(gt) { insert(first, last); } template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } Vertex_handle insert(const Point & p, Cell_handle start = Cell_handle()); Vertex_handle insert(const Point & p, Locate_type lt, Cell_handle c, int li, int); Vertex_handle move_point(Vertex_handle v, const Point & p); template Triple find_conflicts(const Point &p, Cell_handle c, OutputIteratorBoundaryFacets bfit, OutputIteratorCells cit, OutputIteratorInternalFacets ifit) const { CGAL_triangulation_precondition(dimension() >= 2); std::vector cells; cells.reserve(32); std::vector facets; facets.reserve(64); if (dimension() == 2) { Conflict_tester_2 tester(p, this); ifit = find_conflicts_2(c, tester, make_triple(std::back_inserter(facets), std::back_inserter(cells), ifit)).third; } else { Conflict_tester_3 tester(p, this); ifit = find_conflicts_3(c, tester, make_triple(std::back_inserter(facets), std::back_inserter(cells), ifit)).third; } // Reset the conflict flag on the boundary. for(typename std::vector::iterator fit=facets.begin(); fit != facets.end(); ++fit) { fit->first->neighbor(fit->second)->set_in_conflict_flag(0); *bfit++ = *fit; } // Reset the conflict flag in the conflict cells. for(typename std::vector::iterator ccit=cells.begin(); ccit != cells.end(); ++ccit) { (*ccit)->set_in_conflict_flag(0); *cit++ = *ccit; } return make_triple(bfit, cit, ifit); } template std::pair find_conflicts(const Point &p, Cell_handle c, OutputIteratorBoundaryFacets bfit, OutputIteratorCells cit) const { Triple t = find_conflicts(p, c, bfit, cit, Emptyset_iterator()); return std::make_pair(t.first, t.second); } // Returns the vertices on the boundary of the conflict hole. template OutputIterator vertices_in_conflict(const Point&p, Cell_handle c, OutputIterator res) const { CGAL_triangulation_precondition(dimension() >= 2); // Get the facets on the boundary of the hole. std::vector facets; find_conflicts(p, c, std::back_inserter(facets), Emptyset_iterator(), Emptyset_iterator()); // Then extract uniquely the vertices. std::set vertices; if (dimension() == 3) { for (typename std::vector::const_iterator i = facets.begin(); i != facets.end(); ++i) { vertices.insert(i->first->vertex((i->second+1)&3)); vertices.insert(i->first->vertex((i->second+2)&3)); vertices.insert(i->first->vertex((i->second+3)&3)); } } else { for (typename std::vector::const_iterator i = facets.begin(); i != facets.end(); ++i) { vertices.insert(i->first->vertex(cw(i->second))); vertices.insert(i->first->vertex(ccw(i->second))); } } return std::copy(vertices.begin(), vertices.end(), res); } // We return bool only for backward compatibility (it's always true). // The documentation mentions void. bool remove(Vertex_handle v); template < typename InputIterator > int remove(InputIterator first, InputIterator beyond) { int n = number_of_vertices(); while (first != beyond) { remove(*first); ++first; } return n - number_of_vertices(); } private: typedef Facet Edge_2D; void remove_2D(Vertex_handle v); void make_hole_2D(Vertex_handle v, std::list & hole); void fill_hole_delaunay_2D(std::list & hole); void make_canonical(Vertex_triple& t) const; Vertex_triple make_vertex_triple(const Facet& f) const; void remove_3D(Vertex_handle v); void remove_3D_new(Vertex_handle v); Bounded_side side_of_sphere(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Point &p, bool perturb) const; public: // Queries Bounded_side side_of_sphere(const Cell_handle& c, const Point & p, bool perturb = false) const { return side_of_sphere(c->vertex(0), c->vertex(1), c->vertex(2), c->vertex(3), p, perturb); } Bounded_side side_of_circle( const Facet & f, const Point & p, bool perturb = false) const { return side_of_circle(f.first, f.second, p, perturb); } Bounded_side side_of_circle( const Cell_handle& c, int i, const Point & p, bool perturb = false) const; Vertex_handle nearest_vertex_in_cell(const Point& p, const Cell_handle& c) const; Vertex_handle nearest_vertex(const Point& p, Cell_handle c = Cell_handle()) const; bool is_Gabriel(Cell_handle c, int i) const; bool is_Gabriel(Cell_handle c, int i, int j) const; bool is_Gabriel(const Facet& f)const ; bool is_Gabriel(const Edge& e) const; // Dual functions Point dual(Cell_handle c) const; Object dual(const Facet & f) const { return dual( f.first, f.second ); } Object dual(Cell_handle c, int i) const; bool is_valid(bool verbose = false, int level = 0) const; bool is_valid(Cell_handle c, bool verbose = false, int level = 0) const; template < class Stream> Stream& draw_dual(Stream & os) { Finite_facets_iterator fit = finite_facets_begin(); for (; fit != finite_facets_end(); ++fit) { Object o = dual(*fit); Point p; Ray r; Segment s; if (CGAL::assign(p,o)) os << p; if (CGAL::assign(s,o)) os << s; if (CGAL::assign(r,o)) os << r; } return os; } private: Vertex_handle nearest_vertex(const Point &p, Vertex_handle v, Vertex_handle w) const { // In case of equality, v is returned. CGAL_triangulation_precondition(v != w); if (is_infinite(v)) return w; if (is_infinite(w)) return v; return less_distance(p, w->point(), v->point()) ? w : v; } #ifndef CGAL_CFG_NET2003_MATCHING_BUG void make_hole_3D_ear( Vertex_handle v, std::vector & boundhole, std::vector & hole); #else void make_hole_3D_ear( Vertex_handle v, std::vector & boundhole, std::vector & hole) { CGAL_triangulation_expensive_precondition( ! test_dim_down(v) ); incident_cells(v, std::back_inserter(hole)); for (typename std::vector::iterator cit = hole.begin(); cit != hole.end(); ++cit) { int indv = (*cit)->index(v); Cell_handle opp_cit = (*cit)->neighbor( indv ); boundhole.push_back(Facet( opp_cit, opp_cit->index(*cit)) ); for (int i=0; i<4; i++) if ( i != indv ) (*cit)->vertex(i)->set_cell(opp_cit); } } #endif void fill_hole_3D_ear(const std::vector & boundhole); void make_hole_3D_new( Vertex_handle v, std::map& outer_map, std::vector & hole); class Conflict_tester_3 { const Point &p; const Self *t; public: Conflict_tester_3(const Point &pt, const Self *tr) : p(pt), t(tr) {} bool operator()(const Cell_handle c) const { return t->side_of_sphere(c, p, true) == ON_BOUNDED_SIDE; } }; class Conflict_tester_2 { const Point &p; const Self *t; public: Conflict_tester_2(const Point &pt, const Self *tr) : p(pt), t(tr) {} bool operator()(const Cell_handle c) const { return t->side_of_circle(c, 3, p, true) == ON_BOUNDED_SIDE; } }; class Perturbation_order { const Self *t; public: Perturbation_order(const Self *tr) : t(tr) {} bool operator()(const Point *p, const Point *q) const { return t->compare_xyz(*p, *q) == SMALLER; } }; friend class Perturbation_order; friend class Conflict_tester_3; friend class Conflict_tester_2; }; template < class Gt, class Tds > typename Delaunay_triangulation_3::Vertex_handle Delaunay_triangulation_3:: insert(const Point & p, Cell_handle start) { Locate_type lt; int li, lj; Cell_handle c = locate(p, lt, li, lj, start); return insert(p, lt, c, li, lj); } template < class Gt, class Tds > typename Delaunay_triangulation_3::Vertex_handle Delaunay_triangulation_3:: insert(const Point & p, Locate_type lt, Cell_handle c, int li, int) { switch (dimension()) { case 3: { if ( lt == Tr_Base::VERTEX ) return c->vertex(li); Conflict_tester_3 tester(p, this); Vertex_handle v = insert_conflict_3(c, tester); v->set_point(p); return v; }// dim 3 case 2: { switch (lt) { case Tr_Base::OUTSIDE_CONVEX_HULL: case Tr_Base::FACET: case Tr_Base::EDGE: { Conflict_tester_2 tester(p, this); Vertex_handle v = insert_conflict_2(c, tester); v->set_point(p); return v; } case Tr_Base::VERTEX: return c->vertex(li); case Tr_Base::OUTSIDE_AFFINE_HULL: // if the 2d triangulation is Delaunay, the 3d // triangulation will be Delaunay return Tr_Base::insert_outside_affine_hull(p); default: CGAL_triangulation_assertion(false); // CELL should not happen in 2D. } }//dim 2 default : // dimension <= 1 return Tr_Base::insert(p, c); } } template < class Gt, class Tds > typename Delaunay_triangulation_3::Vertex_handle Delaunay_triangulation_3:: move_point(Vertex_handle v, const Point & p) { CGAL_triangulation_precondition(! is_infinite(v)); CGAL_triangulation_expensive_precondition(is_vertex(v)); // Dummy implementation for a start. // Remember an incident vertex to restart // the point location after the removal. Cell_handle c = v->cell(); Vertex_handle old_neighbor = c->vertex(c->index(v) == 0 ? 1 : 0); CGAL_triangulation_assertion(old_neighbor != v); remove(v); if (dimension() <= 0) return insert(p); return insert(p, old_neighbor->cell()); } template < class Gt, class Tds > void Delaunay_triangulation_3:: remove_2D(Vertex_handle v) { CGAL_triangulation_precondition(dimension() == 2); std::list hole; make_hole_2D(v, hole); fill_hole_delaunay_2D(hole); tds().delete_vertex(v); } template void Delaunay_triangulation_3:: fill_hole_delaunay_2D(std::list & first_hole) { typedef std::list Hole; std::vector hole_list; Cell_handle f, ff, fn; int i, ii, in; hole_list.push_back(first_hole); while( ! hole_list.empty()) { Hole hole = hole_list.back(); hole_list.pop_back(); // if the hole has only three edges, create the triangle if (hole.size() == 3) { typename Hole::iterator hit = hole.begin(); f = (*hit).first; i = (*hit).second; ff = (* ++hit).first; ii = (*hit).second; fn = (* ++hit).first; in = (*hit).second; tds().create_face(f, i, ff, ii, fn, in); continue; } // else find an edge with two finite vertices // on the hole boundary // and the new triangle adjacent to that edge // cut the hole and push it back // first, ensure that a neighboring face // whose vertices on the hole boundary are finite // is the first of the hole while (1) { ff = (hole.front()).first; ii = (hole.front()).second; if ( is_infinite(ff->vertex(cw(ii))) || is_infinite(ff->vertex(ccw(ii)))) { hole.push_back(hole.front()); hole.pop_front(); } else break; } // take the first neighboring face and pop it; ff = (hole.front()).first; ii = (hole.front()).second; hole.pop_front(); Vertex_handle v0 = ff->vertex(cw(ii)); Vertex_handle v1 = ff->vertex(ccw(ii)); Vertex_handle v2 = infinite_vertex(); const Point &p0 = v0->point(); const Point &p1 = v1->point(); const Point *p2 = NULL; // Initialize to NULL to avoid warning. typename Hole::iterator hdone = hole.end(); typename Hole::iterator hit = hole.begin(); typename Hole::iterator cut_after(hit); // if tested vertex is c with respect to the vertex opposite // to NULL neighbor, // stop at the before last face; hdone--; for (; hit != hdone; ++hit) { fn = hit->first; in = hit->second; Vertex_handle vv = fn->vertex(ccw(in)); if (is_infinite(vv)) { if (is_infinite(v2)) cut_after = hit; } else { // vv is a finite vertex const Point &p = vv->point(); if (coplanar_orientation(p0, p1, p) == COUNTERCLOCKWISE) { if (is_infinite(v2) || coplanar_side_of_bounded_circle(p0, p1, *p2, p, true) == ON_BOUNDED_SIDE) { v2 = vv; p2 = &p; cut_after = hit; } } } } // create new triangle and update adjacency relations Cell_handle newf; //update the hole and push back in the Hole_List stack // if v2 belongs to the neighbor following or preceding *f // the hole remain a single hole // otherwise it is split in two holes fn = (hole.front()).first; in = (hole.front()).second; if (fn->has_vertex(v2, i) && i == ccw(in)) { newf = tds().create_face(ff, ii, fn, in); hole.pop_front(); hole.push_front(Edge_2D(newf, 1)); hole_list.push_back(hole); } else{ fn = (hole.back()).first; in = (hole.back()).second; if (fn->has_vertex(v2, i) && i == cw(in)) { newf = tds().create_face(fn, in, ff, ii); hole.pop_back(); hole.push_back(Edge_2D(newf, 1)); hole_list.push_back(hole); } else{ // split the hole in two holes newf = tds().create_face(ff, ii, v2); Hole new_hole; ++cut_after; while( hole.begin() != cut_after ) { new_hole.push_back(hole.front()); hole.pop_front(); } hole.push_front(Edge_2D(newf, 1)); new_hole.push_front(Edge_2D(newf, 0)); hole_list.push_back(hole); hole_list.push_back(new_hole); } } } } template void Delaunay_triangulation_3:: make_hole_2D(Vertex_handle v, std::list & hole) { std::vector to_delete; typename Tds::Face_circulator fc = tds().incident_faces(v); typename Tds::Face_circulator done(fc); // We prepare for deleting all interior cells. // We ->set_cell() pointers to cells outside the hole. // We push the Edges_2D of the boundary (seen from outside) in "hole". do { Cell_handle f = fc; int i = f->index(v); Cell_handle fn = f->neighbor(i); int in = fn->index(f); f->vertex(cw(i))->set_cell(fn); fn->set_neighbor(in, Cell_handle()); hole.push_back(Edge_2D(fn, in)); to_delete.push_back(f); ++fc; } while (fc != done); tds().delete_cells(to_delete.begin(), to_delete.end()); } template < class Gt, class Tds > void Delaunay_triangulation_3:: make_canonical(Vertex_triple& t) const { int i = (&*(t.first) < &*(t.second))? 0 : 1; if(i==0) { i = (&*(t.first) < &*(t.third))? 0 : 2; } else { i = (&*(t.second) < &*(t.third))? 1 : 2; } Vertex_handle tmp; switch(i){ case 0: return; case 1: tmp = t.first; t.first = t.second; t.second = t.third; t.third = tmp; return; default: tmp = t.first; t.first = t.third; t.third = t.second; t.second = tmp; } } template < class Gt, class Tds > typename Delaunay_triangulation_3::Vertex_triple Delaunay_triangulation_3:: make_vertex_triple(const Facet& f) const { // static const int vertex_triple_index[4][3] = { {1, 3, 2}, {0, 2, 3}, // {0, 3, 1}, {0, 1, 2} }; Cell_handle ch = f.first; int i = f.second; return Vertex_triple(ch->vertex(vertex_triple_index(i,0)), ch->vertex(vertex_triple_index(i,1)), ch->vertex(vertex_triple_index(i,2))); } template < class Gt, class Tds > void Delaunay_triangulation_3:: remove_3D(Vertex_handle v) { std::vector boundhole; // facets on the boundary of the hole boundhole.reserve(64); // 27 on average. std::vector hole; hole.reserve(64); make_hole_3D_ear(v, boundhole, hole); fill_hole_3D_ear(boundhole); tds().delete_vertex(v); tds().delete_cells(hole.begin(), hole.end()); } template < class Gt, class Tds > void Delaunay_triangulation_3:: remove_3D_new(Vertex_handle v) { std::vector hole; hole.reserve(64); // Construct the set of vertex triples on the boundary // with the facet just behind typedef std::map Vertex_triple_Facet_map; Vertex_triple_Facet_map outer_map; Vertex_triple_Facet_map inner_map; make_hole_3D_new(v, outer_map, hole); bool inf = false; unsigned int i; // collect all vertices on the boundary std::vector vertices; vertices.reserve(64); incident_vertices(v, std::back_inserter(vertices)); // create a Delaunay triangulation of the points on the boundary // and make a map from the vertices in aux towards the vertices in *this Self aux; Unique_hash_map vmap; Cell_handle ch = Cell_handle(); for(i=0; i < vertices.size(); i++){ if(! is_infinite(vertices[i])){ Vertex_handle vh = aux.insert(vertices[i]->point(), ch); ch = vh->cell(); vmap[vh] = vertices[i]; }else { inf = true; } } if(aux.dimension()==2){ Vertex_handle fake_inf = aux.insert(v->point()); vmap[fake_inf] = infinite_vertex(); } else { vmap[aux.infinite_vertex()] = infinite_vertex(); } CGAL_triangulation_assertion(aux.dimension() == 3); // Construct the set of vertex triples of aux // We reorient the vertex triple so that it matches those from outer_map // Also note that we use the vertices of *this, not of aux if(inf){ for(All_cells_iterator it = aux.all_cells_begin(); it != aux.all_cells_end(); ++it){ for(i=0; i < 4; i++){ Facet f = std::pair(it,i); Vertex_triple vt_aux = make_vertex_triple(f); Vertex_triple vt(vmap[vt_aux.first],vmap[vt_aux.third],vmap[vt_aux.second]); make_canonical(vt); inner_map[vt]= f; } } } else { for(Finite_cells_iterator it = aux.finite_cells_begin(); it != aux.finite_cells_end(); ++it){ for(i=0; i < 4; i++){ Facet f = std::pair(it,i); Vertex_triple vt_aux = make_vertex_triple(f); Vertex_triple vt(vmap[vt_aux.first],vmap[vt_aux.third],vmap[vt_aux.second]); make_canonical(vt); inner_map[vt]= f; } } } // Grow inside the hole, by extending the surface while(! outer_map.empty()){ typename Vertex_triple_Facet_map::iterator oit = outer_map.begin(); while(is_infinite(oit->first.first) || is_infinite(oit->first.second) || is_infinite(oit->first.third)){ ++oit; // otherwise the lookup in the inner_map fails // because the infinite vertices are different } typename Vertex_triple_Facet_map::value_type o_vt_f_pair = *oit; Cell_handle o_ch = o_vt_f_pair.second.first; unsigned int o_i = o_vt_f_pair.second.second; typename Vertex_triple_Facet_map::iterator iit = inner_map.find(o_vt_f_pair.first); CGAL_triangulation_assertion(iit != inner_map.end()); typename Vertex_triple_Facet_map::value_type i_vt_f_pair = *iit; Cell_handle i_ch = i_vt_f_pair.second.first; unsigned int i_i = i_vt_f_pair.second.second; // create a new cell and glue it to the outer surface Cell_handle new_ch = tds().create_cell(); new_ch->set_vertices(vmap[i_ch->vertex(0)], vmap[i_ch->vertex(1)], vmap[i_ch->vertex(2)], vmap[i_ch->vertex(3)]); o_ch->set_neighbor(o_i,new_ch); new_ch->set_neighbor(i_i, o_ch); // for the other faces check, if they can also be glued for(i = 0; i < 4; i++){ if(i != i_i){ Facet f = std::pair(new_ch,i); Vertex_triple vt = make_vertex_triple(f); make_canonical(vt); std::swap(vt.second,vt.third); typename Vertex_triple_Facet_map::iterator oit2 = outer_map.find(vt); if(oit2 == outer_map.end()){ std::swap(vt.second,vt.third); outer_map[vt]= f; } else { // glue the faces typename Vertex_triple_Facet_map::value_type o_vt_f_pair2 = *oit2; Cell_handle o_ch2 = o_vt_f_pair2.second.first; int o_i2 = o_vt_f_pair2.second.second; o_ch2->set_neighbor(o_i2,new_ch); new_ch->set_neighbor(i, o_ch2); outer_map.erase(oit2); } } } outer_map.erase(oit); } tds().delete_vertex(v); tds().delete_cells(hole.begin(), hole.end()); } template < class Gt, class Tds > bool Delaunay_triangulation_3:: remove(Vertex_handle v) { CGAL_triangulation_precondition( v != Vertex_handle()); CGAL_triangulation_precondition( !is_infinite(v)); CGAL_triangulation_expensive_precondition(is_vertex(v)); if (dimension() >= 0 && test_dim_down(v)) { tds().remove_decrease_dimension(v); // Now try to see if we need to re-orient. if (dimension() == 2) { Facet f = *finite_facets_begin(); if (coplanar_orientation(f.first->vertex(0)->point(), f.first->vertex(1)->point(), f.first->vertex(2)->point()) == NEGATIVE) tds().reorient(); } CGAL_triangulation_expensive_postcondition(is_valid()); return true; } if (dimension() == 1) { tds().remove_from_maximal_dimension_simplex(v); CGAL_triangulation_expensive_postcondition(is_valid()); return true; } if (dimension() == 2) { remove_2D(v); CGAL_triangulation_expensive_postcondition(is_valid()); return true; } CGAL_triangulation_assertion( dimension() == 3 ); #ifdef CGAL_DELAUNAY_3_OLD_REMOVE remove_3D(v); #else remove_3D_new(v); #endif CGAL_triangulation_expensive_postcondition(is_valid()); return true; } template < class Gt, class Tds > Oriented_side Delaunay_triangulation_3:: side_of_oriented_sphere(const Point &p0, const Point &p1, const Point &p2, const Point &p3, const Point &p, bool perturb) const { CGAL_triangulation_precondition( orientation(p0, p1, p2, p3) == POSITIVE ); Oriented_side os = geom_traits().side_of_oriented_sphere_3_object()(p0, p1, p2, p3, p); if (os != ON_ORIENTED_BOUNDARY || !perturb) return os; // We are now in a degenerate case => we do a symbolic perturbation. // We sort the points lexicographically. const Point * points[5] = {&p0, &p1, &p2, &p3, &p}; std::sort(points, points+5, Perturbation_order(this) ); // We successively look whether the leading monomial, then 2nd monomial // of the determinant has non null coefficient. // 2 iterations are enough (cf paper) for (int i=4; i>2; --i) { if (points[i] == &p) return ON_NEGATIVE_SIDE; // since p0 p1 p2 p3 are non coplanar // and positively oriented Orientation o; if (points[i] == &p3 && (o = orientation(p0,p1,p2,p)) != COPLANAR ) return Oriented_side(o); if (points[i] == &p2 && (o = orientation(p0,p1,p,p3)) != COPLANAR ) return Oriented_side(o); if (points[i] == &p1 && (o = orientation(p0,p,p2,p3)) != COPLANAR ) return Oriented_side(o); if (points[i] == &p0 && (o = orientation(p,p1,p2,p3)) != COPLANAR ) return Oriented_side(o); } CGAL_triangulation_assertion(false); return ON_NEGATIVE_SIDE; } template < class Gt, class Tds > Bounded_side Delaunay_triangulation_3:: coplanar_side_of_bounded_circle(const Point &p0, const Point &p1, const Point &p2, const Point &p, bool perturb) const { // In dim==2, we should even be able to assert orient == POSITIVE. CGAL_triangulation_precondition( coplanar_orientation(p0, p1, p2) != COLLINEAR ); Bounded_side bs = geom_traits().coplanar_side_of_bounded_circle_3_object()(p0, p1, p2, p); if (bs != ON_BOUNDARY || !perturb) return bs; // We are now in a degenerate case => we do a symbolic perturbation. // We sort the points lexicographically. const Point * points[4] = {&p0, &p1, &p2, &p}; std::sort(points, points+4, Perturbation_order(this) ); Orientation local = coplanar_orientation(p0, p1, p2); // we successively look whether the leading monomial, then 2nd monimial, // then 3rd monomial, of the determinant which has non null coefficient // [syl] : TODO : Probably it can be stopped earlier like the 3D version for (int i=3; i>0; --i) { if (points[i] == &p) return Bounded_side(NEGATIVE); // since p0 p1 p2 are non collinear // but not necessarily positively oriented Orientation o; if (points[i] == &p2 && (o = coplanar_orientation(p0,p1,p)) != COLLINEAR ) // [syl] : TODO : I'm not sure of the signs here (nor the rest :) return Bounded_side(o*local); if (points[i] == &p1 && (o = coplanar_orientation(p0,p,p2)) != COLLINEAR ) return Bounded_side(o*local); if (points[i] == &p0 && (o = coplanar_orientation(p,p1,p2)) != COLLINEAR ) return Bounded_side(o*local); } // case when the first non null coefficient is the coefficient of // the 4th monomial // moreover, the tests (points[] == &p) were false up to here, so the // monomial corresponding to p is the only monomial with non-zero // coefficient, it is equal to coplanar_orient(p0,p1,p2) == positive // so, no further test is required return Bounded_side(-local); //ON_UNBOUNDED_SIDE; } template < class Gt, class Tds > Bounded_side Delaunay_triangulation_3:: side_of_sphere(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Point &p, bool perturb) const { CGAL_triangulation_precondition( dimension() == 3 ); // TODO : // - avoid accessing points of infinite vertex // - share the 4 codes below (see old version) const Point &p0 = v0->point(); const Point &p1 = v1->point(); const Point &p2 = v2->point(); const Point &p3 = v3->point(); if (is_infinite(v0)) { Orientation o = orientation(p2, p1, p3, p); if (o != COPLANAR) return Bounded_side(o); return coplanar_side_of_bounded_circle(p2, p1, p3, p, perturb); } if (is_infinite(v1)) { Orientation o = orientation(p2, p3, p0, p); if (o != COPLANAR) return Bounded_side(o); return coplanar_side_of_bounded_circle(p2, p3, p0, p, perturb); } if (is_infinite(v2)) { Orientation o = orientation(p1, p0, p3, p); if (o != COPLANAR) return Bounded_side(o); return coplanar_side_of_bounded_circle(p1, p0, p3, p, perturb); } if (is_infinite(v3)) { Orientation o = orientation(p0, p1, p2, p); if (o != COPLANAR) return Bounded_side(o); return coplanar_side_of_bounded_circle(p0, p1, p2, p, perturb); } return (Bounded_side) side_of_oriented_sphere(p0, p1, p2, p3, p, perturb); } template < class Gt, class Tds > Bounded_side Delaunay_triangulation_3:: side_of_circle(const Cell_handle& c, int i, const Point & p, bool perturb) const // precondition : dimension >=2 // in dimension 3, - for a finite facet // returns ON_BOUNDARY if the point lies on the circle, // ON_UNBOUNDED_SIDE when exterior, ON_BOUNDED_SIDE // interior // for an infinite facet, considers the plane defined by the // adjacent finite facet of the same cell, and does the same as in // dimension 2 in this plane // in dimension 2, for an infinite facet // in this case, returns ON_BOUNDARY if the point lies on the // finite edge (endpoints included) // ON_BOUNDED_SIDE for a point in the open half-plane // ON_UNBOUNDED_SIDE elsewhere { CGAL_triangulation_precondition( dimension() >= 2 ); int i3 = 5; if ( dimension() == 2 ) { CGAL_triangulation_precondition( i == 3 ); // the triangulation is supposed to be valid, ie the facet // with vertices 0 1 2 in this order is positively oriented if ( ! c->has_vertex( infinite_vertex(), i3 ) ) return coplanar_side_of_bounded_circle( c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), p, perturb); // else infinite facet // v1, v2 finite vertices of the facet such that v1,v2,infinite // is positively oriented Vertex_handle v1 = c->vertex( ccw(i3) ), v2 = c->vertex( cw(i3) ); CGAL_triangulation_assertion(coplanar_orientation(v1->point(), v2->point(), (c->mirror_vertex(i3))->point()) == NEGATIVE); Orientation o = coplanar_orientation(v1->point(), v2->point(), p); if ( o != COLLINEAR ) return Bounded_side( o ); // because p is in f iff // it does not lie on the same side of v1v2 as vn int i_e; Locate_type lt; // case when p collinear with v1v2 return side_of_segment( p, v1->point(), v2->point(), lt, i_e ); } // else dimension == 3 CGAL_triangulation_precondition( i >= 0 && i < 4 ); if ( ( ! c->has_vertex(infinite_vertex(),i3) ) || ( i3 != i ) ) { // finite facet // initialization of i0 i1 i2, vertices of the facet positively // oriented (if the triangulation is valid) int i0 = (i>0) ? 0 : 1; int i1 = (i>1) ? 1 : 2; int i2 = (i>2) ? 2 : 3; CGAL_triangulation_precondition( coplanar( c->vertex(i0)->point(), c->vertex(i1)->point(), c->vertex(i2)->point(), p ) ); return coplanar_side_of_bounded_circle( c->vertex(i0)->point(), c->vertex(i1)->point(), c->vertex(i2)->point(), p, perturb); } //else infinite facet // v1, v2 finite vertices of the facet such that v1,v2,infinite // is positively oriented Vertex_handle v1 = c->vertex( next_around_edge(i3,i) ), v2 = c->vertex( next_around_edge(i,i3) ); Orientation o = (Orientation) (coplanar_orientation( v1->point(), v2->point(), c->vertex(i)->point()) * coplanar_orientation( v1->point(), v2->point(), p )); // then the code is duplicated from 2d case if ( o != COLLINEAR ) return Bounded_side( -o ); // because p is in f iff // it is not on the same side of v1v2 as c->vertex(i) int i_e; Locate_type lt; // case when p collinear with v1v2 return side_of_segment( p, v1->point(), v2->point(), lt, i_e ); } template < class Gt, class Tds > typename Delaunay_triangulation_3::Vertex_handle Delaunay_triangulation_3:: nearest_vertex_in_cell(const Point& p, const Cell_handle& c) const // Returns the finite vertex of the cell c which is the closest to p. { CGAL_triangulation_precondition(dimension() >= 1); Vertex_handle nearest = nearest_vertex(p, c->vertex(0), c->vertex(1)); if (dimension() >= 2) { nearest = nearest_vertex(p, nearest, c->vertex(2)); if (dimension() == 3) nearest = nearest_vertex(p, nearest, c->vertex(3)); } return nearest; } template < class Gt, class Tds > typename Delaunay_triangulation_3::Vertex_handle Delaunay_triangulation_3:: nearest_vertex(const Point& p, Cell_handle start) const { if (number_of_vertices() == 0) return Vertex_handle(); // Use a brute-force algorithm if dimension < 3. if (dimension() < 3) { Finite_vertices_iterator vit = finite_vertices_begin(); Vertex_handle res = vit; for (++vit; vit != finite_vertices_end(); ++vit) res = nearest_vertex(p, res, vit); return res; } Locate_type lt; int li, lj; Cell_handle c = locate(p, lt, li, lj, start); if (lt == Tr_Base::VERTEX) return c->vertex(li); // - start with the closest vertex from the located cell. // - repeatedly take the nearest of its incident vertices if any // - if not, we're done. Vertex_handle nearest = nearest_vertex_in_cell(p, c); std::vector vs; vs.reserve(32); while (true) { Vertex_handle tmp = nearest; incident_vertices(nearest, std::back_inserter(vs)); for (typename std::vector::const_iterator vsit = vs.begin(); vsit != vs.end(); ++vsit) tmp = nearest_vertex(p, tmp, *vsit); if (tmp == nearest) break; vs.clear(); nearest = tmp; } return nearest; } template < class Gt, class Tds > bool Delaunay_triangulation_3:: is_Gabriel(const Facet& f) const { return is_Gabriel(f.first, f.second); } template < class Gt, class Tds > bool Delaunay_triangulation_3:: is_Gabriel(Cell_handle c, int i) const { CGAL_triangulation_precondition(dimension() == 3 && !is_infinite(c,i)); typename Geom_traits::Side_of_bounded_sphere_3 side_of_bounded_sphere = geom_traits().side_of_bounded_sphere_3_object(); if ((!is_infinite(c->vertex(i))) && side_of_bounded_sphere ( c->vertex(vertex_triple_index(i,0))->point(), c->vertex(vertex_triple_index(i,1))->point(), c->vertex(vertex_triple_index(i,2))->point(), c->vertex(i)->point()) == ON_BOUNDED_SIDE ) return false; Cell_handle neighbor = c->neighbor(i); int in = neighbor->index(c); if ((!is_infinite(neighbor->vertex(in))) && side_of_bounded_sphere( c->vertex(vertex_triple_index(i,0))->point(), c->vertex(vertex_triple_index(i,1))->point(), c->vertex(vertex_triple_index(i,2))->point(), neighbor->vertex(in)->point()) == ON_BOUNDED_SIDE ) return false; return true; } template < class Gt, class Tds > bool Delaunay_triangulation_3:: is_Gabriel(const Edge& e) const { return is_Gabriel(e.first, e.second, e.third); } template < class Gt, class Tds > bool Delaunay_triangulation_3:: is_Gabriel(Cell_handle c, int i, int j) const { CGAL_triangulation_precondition(dimension() == 3 && !is_infinite(c,i,j)); typename Geom_traits::Side_of_bounded_sphere_3 side_of_bounded_sphere = geom_traits().side_of_bounded_sphere_3_object(); Facet_circulator fcirc = incident_facets(c,i,j), fdone(fcirc); Vertex_handle v1 = c->vertex(i); Vertex_handle v2 = c->vertex(j); do { // test whether the vertex of cc opposite to *fcirc // is inside the sphere defined by the edge e = (s, i,j) Cell_handle cc = (*fcirc).first; int ii = (*fcirc).second; if (!is_infinite(cc->vertex(ii)) && side_of_bounded_sphere( v1->point(), v2->point(), cc->vertex(ii)->point()) == ON_BOUNDED_SIDE ) return false; } while(++fcirc != fdone); return true; } template < class Gt, class Tds > typename Delaunay_triangulation_3::Point Delaunay_triangulation_3:: dual(Cell_handle c) const { CGAL_triangulation_precondition(dimension()==3); CGAL_triangulation_precondition( ! is_infinite(c) ); return construct_circumcenter( c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point() ); } template < class Gt, class Tds > typename Delaunay_triangulation_3::Object Delaunay_triangulation_3:: dual(Cell_handle c, int i) const { CGAL_triangulation_precondition(dimension()>=2); CGAL_triangulation_precondition( ! is_infinite(c,i) ); if ( dimension() == 2 ) { CGAL_triangulation_precondition( i == 3 ); return construct_object( construct_circumcenter(c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point()) ); } // dimension() == 3 Cell_handle n = c->neighbor(i); if ( ! is_infinite(c) && ! is_infinite(n) ) return construct_object(construct_segment( dual(c), dual(n) )); // either n or c is infinite int in; if ( is_infinite(c) ) in = n->index(c); else { n = c; in = i; } // n now denotes a finite cell, either c or c->neighbor(i) unsigned char ind[3] = {(in+1)&3,(in+2)&3,(in+3)&3}; if ( (in&1) == 1 ) std::swap(ind[0], ind[1]); const Point& p = n->vertex(ind[0])->point(); const Point& q = n->vertex(ind[1])->point(); const Point& r = n->vertex(ind[2])->point(); Line l = construct_perpendicular_line( construct_plane(p,q,r), construct_circumcenter(p,q,r) ); return construct_object(construct_ray( dual(n), l)); } template < class Gt, class Tds > bool Delaunay_triangulation_3:: is_valid(bool verbose, int level) const { if ( ! tds().is_valid(verbose,level) ) { if (verbose) std::cerr << "invalid data structure" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( infinite_vertex() == Vertex_handle() ) { if (verbose) std::cerr << "no infinite vertex" << std::endl; CGAL_triangulation_assertion(false); return false; } switch ( dimension() ) { case 3: { Finite_cells_iterator it; for ( it = finite_cells_begin(); it != finite_cells_end(); ++it ) { is_valid_finite(it); for (int i=0; i<4; i++ ) { if ( !is_infinite (it->neighbor(i)->vertex(it->neighbor(i)->index(it))) ) { if ( side_of_sphere (it, it->neighbor(i)->vertex(it->neighbor(i)->index(it))->point()) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty sphere " << std::endl; CGAL_triangulation_assertion(false); return false; } } } } break; } case 2: { Finite_facets_iterator it; for ( it = finite_facets_begin(); it != finite_facets_end(); ++it ) { is_valid_finite((*it).first); for (int i=0; i<3; i++ ) { if( !is_infinite ((*it).first->neighbor(i)->vertex( (((*it).first)->neighbor(i)) ->index((*it).first))) ) { if ( side_of_circle ( (*it).first, 3, (*it).first->neighbor(i)-> vertex( (((*it).first)->neighbor(i)) ->index((*it).first) )->point() ) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty circle " << std::endl; CGAL_triangulation_assertion(false); return false; } } } } break; } case 1: { Finite_edges_iterator it; for ( it = finite_edges_begin(); it != finite_edges_end(); ++it ) is_valid_finite((*it).first); break; } } if (verbose) std::cerr << "Delaunay valid triangulation" << std::endl; return true; } template < class Gt, class Tds > bool Delaunay_triangulation_3:: is_valid(Cell_handle c, bool verbose, int level) const { if ( ! c->is_valid(dimension(),verbose,level) ) { if (verbose) { std::cerr << "combinatorically invalid cell" ; for (int i=0; i <= dimension(); i++ ) std::cerr << c->vertex(i)->point() << ", " ; std::cerr << std::endl; } CGAL_triangulation_assertion(false); return false; } switch ( dimension() ) { case 3: { if ( ! is_infinite(c) ) { is_valid_finite(c,verbose,level); for (int i=0; i<4; i++ ) { if (side_of_sphere(c, c->vertex((c->neighbor(i))->index(c))->point()) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty sphere " << std::endl; CGAL_triangulation_assertion(false); return false; } } } break; } case 2: { if ( ! is_infinite(c,3) ) { for (int i=0; i<2; i++ ) { if (side_of_circle(c, 3, c->vertex(c->neighbor(i)->index(c))->point()) == ON_BOUNDED_SIDE ) { if (verbose) std::cerr << "non-empty circle " << std::endl; CGAL_triangulation_assertion(false); return false; } } } break; } } if (verbose) std::cerr << "Delaunay valid cell" << std::endl; return true; } #ifndef CGAL_CFG_NET2003_MATCHING_BUG template < class Gt, class Tds > void Delaunay_triangulation_3:: make_hole_3D_ear( Vertex_handle v, std::vector & boundhole, std::vector & hole) { CGAL_triangulation_expensive_precondition( ! test_dim_down(v) ); incident_cells(v, std::back_inserter(hole)); for (typename std::vector::iterator cit = hole.begin(); cit != hole.end(); ++cit) { int indv = (*cit)->index(v); Cell_handle opp_cit = (*cit)->neighbor( indv ); boundhole.push_back(Facet( opp_cit, opp_cit->index(*cit)) ); for (int i=0; i<4; i++) if ( i != indv ) (*cit)->vertex(i)->set_cell(opp_cit); } } #endif template < class Gt, class Tds > void Delaunay_triangulation_3:: make_hole_3D_new( Vertex_handle v, std::map& outer_map, std::vector & hole) { CGAL_triangulation_expensive_precondition( ! test_dim_down(v) ); incident_cells(v, std::back_inserter(hole)); for (typename std::vector::iterator cit = hole.begin(); cit != hole.end(); ++cit) { int indv = (*cit)->index(v); Cell_handle opp_cit = (*cit)->neighbor( indv ); Facet f(opp_cit, opp_cit->index(*cit)); Vertex_triple vt = make_vertex_triple(f); make_canonical(vt); outer_map[vt] = f; for (int i=0; i<4; i++) if ( i != indv ) (*cit)->vertex(i)->set_cell(opp_cit); } } template < class Gt, class Tds > void Delaunay_triangulation_3:: fill_hole_3D_ear(const std::vector & boundhole) { typedef Delaunay_remove_tds_3_2 Surface; typedef typename Surface::Face_3_2 Face_3_2; typedef typename Surface::Face_handle_3_2 Face_handle_3_2; typedef typename Surface::Vertex_handle_3_2 Vertex_handle_3_2; Surface surface(boundhole); Face_handle_3_2 f = surface.faces_begin(); Face_handle_3_2 last_op = f; // This is where the last ear was inserted int k = -1; // This is a loop over the halfedges of the surface of the hole // As edges are not explicitely there, we loop over the faces instead, // and an index. // The current face is f, the current index is k = -1, 0, 1, 2 for(;;) { next_edge: ; k++; if(k == 3) { // The faces form a circular list. With f->n() we go to the next face. f = f->n(); CGAL_assertion_msg(f != last_op, "Unable to find an ear"); k = 0; } // The edges are marked, if they are a candidate for an ear. // This saves time, for example an edge gets not considered // from both adjacent faces. if (!f->is_halfedge_marked(k)) continue; Vertex_handle_3_2 w0, w1, w2, w3; Vertex_handle v0, v1, v2, v3; int i = ccw(k); int j = cw(k); Face_handle_3_2 n = f->neighbor(k); int fi = n->index(f); w1 = f->vertex(i); w2 = f->vertex(j); v1 = w1->info(); v2 = w2->info(); if( is_infinite(v1) || is_infinite(v2) ){ // there will be another ear, so let's ignore this one, // because it is complicated to treat continue; } w0 = f->vertex(k); w3 = n->vertex(fi); v0 = w0->info(); v3 = w3->info(); if( !is_infinite(v0) && !is_infinite(v3) && orientation(v0->point(), v1->point(), v2->point(), v3->point()) != POSITIVE) continue; // the two faces form a concavity, in which we might plug a cell // we now look at all vertices that are on the boundary of the hole for(typename Surface::Vertex_iterator vit = surface.vertices_begin(); vit != surface.vertices_end(); ++vit) { Vertex_handle v = vit->info(); if (is_infinite(v) || v == v0 || v == v1 || v == v2 || v == v3) continue; if (side_of_sphere(v0,v1,v2,v3, v->point(), true) == ON_BOUNDED_SIDE) goto next_edge; } // we looked at all vertices Face_handle_3_2 m_i = f->neighbor(i); Face_handle_3_2 m_j = f->neighbor(j); bool neighbor_i = m_i == n->neighbor(cw(fi)); bool neighbor_j = m_j == n->neighbor(ccw(fi)); // Test if the edge that would get introduced is on the surface if ( !neighbor_i && !neighbor_j && surface.is_edge(f->vertex(k), n->vertex(fi))) continue; // none of the vertices violates the Delaunay property // We are ready to plug a new cell Cell_handle ch = tds().create_cell(v0, v1, v2, v3); // The new cell touches the faces that form the ear Facet fac = n->info(); tds().set_adjacency(ch, 0, fac.first, fac.second); fac = f->info(); tds().set_adjacency(ch, 3, fac.first, fac.second); // It may touch another face, // or even two other faces if it is the last cell if(neighbor_i) { fac = m_i->info(); tds().set_adjacency(ch, 1, fac.first, fac.second); } if(neighbor_j) { fac = m_j->info(); tds().set_adjacency(ch, 2, fac.first, fac.second); } if( !neighbor_i && !neighbor_j) { surface.flip(f,k); int fi = n->index(f); int ni = f->index(n); // The flipped edge is not a concavity f->unmark_edge(ni); // The adjacent edges may be a concavity // that is they are candidates for an ear // In the list of faces they get moved behind f f->mark_edge(cw(ni), f); f->mark_edge(ccw(ni), f); n->mark_edge(cw(fi), f); n->mark_edge(ccw(fi), f); f->set_info(Facet(ch,2)); n->set_info(Facet(ch,1)); } else if (neighbor_i && (! neighbor_j)) { surface.remove_degree_3(f->vertex(j), f); // all three edges adjacent to f are // candidate for an ear f->mark_adjacent_edges(); f->set_info(Facet(ch,2)); } else if ((! neighbor_i) && neighbor_j) { surface.remove_degree_3(f->vertex(i), f); f->mark_adjacent_edges(); f->set_info(Facet(ch,1)); } else { CGAL_assertion(surface.number_of_vertices() == 4); // when we leave the function the vertices and faces of the surface // are deleted by the destructor return; } // we successfully inserted a cell last_op = f; // we have to reconsider all edges incident to f k = -1; } // for(;;) } CGAL_END_NAMESPACE #endif // CGAL_DELAUNAY_TRIANGULATION_3_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_pivot.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000000623611344301500031417 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_pivot.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_PIVOT_C #define CGAL_MINIBALL_PIVOT_C #include namespace CGAL_MINIBALL_NAMESPACE { namespace Min_sphere_of_spheres_d_impl { template bool is_better(const FT& old,const FT& now,const Tag_false is_exact) { return now > old; } template bool is_better(const FT&,const FT&,const Tag_true is_exact) { return true; } template bool Support_set::pivot(std::vector& l, int& e, const int d) { // remember old radius: const Result old = radius(); // reset basis to {d}: reset(); push(*l[d]); // try all subsets: std::bitset T; int pos = e; bool up = true; while (pos >= 0) { if (pos == e) { bool isEnclosingSupporting = is_spanning(); if (isEnclosingSupporting) for(int i=0; i #ifndef CGAL_TRIANGULATION_VERTEX_BASE_3_H #define CGAL_TRIANGULATION_VERTEX_BASE_3_H #include #include #include CGAL_BEGIN_NAMESPACE template < typename GT, typename DSVb = Triangulation_ds_vertex_base_3<> > class Triangulation_vertex_base_3 : public DSVb { public: typedef typename DSVb::Cell_handle Cell_handle; typedef GT Geom_traits; typedef typename GT::Point_3 Point; template < typename TDS2 > struct Rebind_TDS { typedef typename DSVb::template Rebind_TDS::Other DSVb2; typedef Triangulation_vertex_base_3 Other; }; Triangulation_vertex_base_3() : DSVb() {} Triangulation_vertex_base_3(const Point & p) : DSVb(), _p(p) {} Triangulation_vertex_base_3(const Point & p, const Cell_handle& c) : DSVb(c), _p(p) {} Triangulation_vertex_base_3(const Cell_handle& c) : DSVb(c), _p() {} const Point & point() const { return _p; } Point & point() { return _p; } void set_point(const Point & p) { _p = p; } private: Point _p; }; template < class GT, class DSVb > std::istream& operator>>(std::istream &is, Triangulation_vertex_base_3 &v) // non combinatorial information. Default = point { return is >> static_cast(v) >> v.point(); } template < class GT, class DSVb > std::ostream& operator<<(std::ostream &os, const Triangulation_vertex_base_3 &v) // non combinatorial information. Default = point { return os << static_cast(v) << v.point(); } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_VERTEX_BASE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_d.h0000644000175000017500000000432411344301500030255 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Authors : Hans Tangelder () #ifndef CGAL_ISO_RECTANGLE_D_H #define CGAL_ISO_RECTANGLE_D_H #include #include #include #include namespace CGAL { template class Iso_rectangle_d { public: typedef typename R::FT FT; typedef typename R::Point_d Point_d; private: int dim; FT *lower; FT *upper; public: Iso_rectangle_d(const Point_d& p, const Point_d& q) { CGAL_assertion(p.dimension() == q.dimension()); dim = p.dimension(); lower = new FT[dim]; upper = new FT[dim]; for (int i = 0; i < dim; ++i) { if (p[i] <= q[i]) { lower[i]=p[i]; upper[i]=q[i]; } else { lower[i]=q[i]; upper[i]=p[i]; } } } // copy constructor Iso_rectangle_d(const Iso_rectangle_d& b) : dim(b.dim) { lower = new FT[dim]; upper = new FT[dim]; for (int i = 0; i < dim; ++i) { lower[i]=b.lower[i]; upper[i]=b.upper[i]; } } bool has_on_bounded_side(const Point_d& p) const { FT h; for (int i = 0; i < dimension(); ++i) { h=p[i]; if ( (h < lower[i]) || (h > upper[i]) ) return 0; } return 1; } inline int dimension() const { return dim;} inline FT min_coord(int i) const { return lower[i]; } inline FT max_coord(int i) const { return upper[i]; } }; // end of class } // namespace CGAL #endif // CGAL_ISO_RECTANGLE_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_d.h0000644000175000017500000011042111344301500027235 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel //--------------------------------------------------------------------- // file generated by notangle from delaunay.lw // please debug or modify LEDA web file // mails and bugs: Michael.Seel@mpi-sb.mpg.de // based on LEDA architecture by S. Naeher, C. Uhrig // coding: K. Mehlhorn, M. Seel // debugging and templatization: M. Seel //--------------------------------------------------------------------- #ifndef CGAL_DELAUNAY_D_H #define CGAL_DELAUNAY_D_H /*{\Manpage {Delaunay_d}{R,Lifted_R}{Delaunay Triangulations}{DT}}*/ /*{\Mdefinition An instance |\Mvar| of type |\Mname| is the nearest and furthest site Delaunay triangulation of a set |S| of points in some $d$-dimensional space. We call |S| the underlying point set and $d$ or |dim| the dimension of the underlying space. We use |dcur| to denote the affine dimension of |S|. The data type supports incremental construction of Delaunay triangulations and various kind of query operations (in particular, nearest and furthest neighbor queries and range queries with spheres and simplices). A Delaunay triangulation is a simplicial complex. All simplices in the Delaunay triangulation have dimension |dcur|. In the nearest site Delaunay triangulation the circumsphere of any simplex in the triangulation contains no point of $S$ in its interior. In the furthest site Delaunay triangulation the circumsphere of any simplex contains no point of $S$ in its exterior. If the points in $S$ are co-circular then any triangulation of $S$ is a nearest as well as a furthest site Delaunay triangulation of $S$. If the points in $S$ are not co-circular then no simplex can be a simplex of both triangulations. Accordingly, we view |\Mvar| as either one or two collection(s) of simplices. If the points in $S$ are co-circular there is just one collection: the set of simplices of some triangulation. If the points in $S$ are not co-circular there are two collections. One collection consists of the simplices of a nearest site Delaunay triangulation and the other collection consists of the simplices of a furthest site Delaunay triangulation. For each simplex of maximal dimension there is a handle of type |Simplex_handle| and for each vertex of the triangulation there is a handle of type |Vertex_handle|. Each simplex has |1 + dcur| vertices indexed from $0$ to |dcur|. For any simplex $s$ and any index $i$, |DT.vertex_of(s,i)| returns the $i$-th vertex of $s$. There may or may not be a simplex $t$ opposite to the vertex of $s$ with index $i$. The function |DT.opposite_simplex(s,i)| returns $t$ if it exists and returns |Simplex_handle()| otherwise. If $t$ exists then $s$ and $t$ share |dcur| vertices, namely all but the vertex with index $i$ of $s$ and the vertex with index |DT.index_of_vertex_in_opposite_simplex(s,i)| of $t$. Assume that $t = |DT.opposite_simplex(s,i)|$ exists and let $j = |DT.index_of_vertex_in_opposite_simplex(s,i)|$. Then |s = DT.opposite_simplex(t,j)| and |i = DT.index_of_vertex_in_opposite_simplex(t,j)|. In general, a vertex belongs to many simplices. Any simplex of |\Mvar| belongs either to the nearest or to the furthest site Delaunay triangulation or both. The test |DT.simplex_of_nearest(dt_simplex s)| returns true if |s| belongs to the nearest site triangulation and the test |DT.simplex_of_furthest(dt_simplex s)| returns true if |s| belongs to the furthest site triangulation. }*/ #include #include CGAL_BEGIN_NAMESPACE template class Delaunay_d : public Convex_hull_d { typedef Delaunay_d Self; typedef Convex_hull_d Base; using Base::origin_simplex_; public: using Base::dcur; /*{\Mgeneralization Convex_hull_d}*/ /*{\Mtypes 7}*/ typedef R_ R; typedef Lifted_R_ Lifted_R; typedef typename Base::Simplex_handle Simplex_handle; /*{\Mtypemember handles to the simplices of the complex.}*/ typedef typename Base::Vertex_handle Vertex_handle; /*{\Mtypemember handles to vertices of the complex.}*/ typedef typename Base::Simplex_const_handle Simplex_const_handle; typedef typename Base::Vertex_const_handle Vertex_const_handle; class Simplex_iterator; class Simplex_const_iterator; friend class Simplex_iterator; friend class Simplex_const_iterator; typedef typename R::Point_d Point_d; /*{\Mtypemember the point type}*/ typedef typename R::Sphere_d Sphere_d; /*{\Mtypemember the sphere type}*/ typedef typename R::FT FT; typedef typename Lifted_R::Point_d Lifted_point_d; typedef typename Lifted_R::Vector_d Lifted_vector_d; typedef typename Lifted_R::Hyperplane_d Lifted_hyperplane_d; typedef typename Lifted_R::RT RT; enum Delaunay_voronoi_kind { NEAREST, FURTHEST }; /*{\Menum interface flags}*/ /*{\Mtext To use these types you can typedef them into the global scope after instantiation of the class. We use |Vertex_handle| instead of |\Mname::Vertex_handle| from now on. Similarly we use |Simplex_handle|.}*/ private: enum type_of_S { unknown, non_cocircular, cocircular }; type_of_S ts; const R& Delaunay_kernel_; enum type_of_facet { lower_hull, upper_hull, vertical }; type_of_facet type_of(typename Base::Facet_const_handle f) const /*{\Xop returns the type of the facet $f$.}*/ { typename Lifted_R::Orthogonal_vector_d ortho = lifted_kernel().orthogonal_vector_d_object(); Lifted_vector_d normal = ortho(hyperplane_supporting(f)); typename Lifted_R::Component_accessor_d access = lifted_kernel().component_accessor_d_object(); int d = CGAL_NTS sign( access.homogeneous(normal,access.dimension(normal)-1)); if (d > 0) return upper_hull; if (d < 0) return lower_hull; return vertical; } type_of_facet type_of(typename Base::Facet_handle f) const { return type_of(static_cast(f)); } bool incident_simplex_search(Vertex_handle v, Simplex_handle s) const; public: typedef typename Base::Point_const_iterator Point_const_iterator; /*{\Mtypemember the iterator for points.}*/ typedef typename Base::Vertex_iterator Vertex_iterator; /*{\Mtypemember the iterator for vertices.}*/ typedef typename Base::Simplex_iterator CH_simplex_iterator; typedef typename Base::Simplex_const_iterator CH_simplex_const_iterator; class Simplex_iterator /*{\Mtypemember the iterator for simplices.}*/ : public CH_simplex_iterator { typedef Delaunay_d Delaunay; typedef CH_simplex_iterator Base_iterator; Delaunay* DT; type_of_facet tf; Base_iterator base() { return Base_iterator(*this); } public: Simplex_iterator(Base_iterator y = Base_iterator()) : Base_iterator(y) {} Simplex_iterator(Delaunay* x, Base_iterator y, Delaunay_voronoi_kind z = NEAREST) : Base_iterator(y), DT(x) /* if the facet is not nil we set the current marker to the facet and insert all it's neighbors into the candidates stack */ { CGAL_assertion(base() != Base_iterator()); tf = (z == NEAREST ? lower_hull : upper_hull); bool cocirc = DT->is_S_cocircular(); while ( base() != DT->simplices_end() && !( cocirc && DT->is_bounded_simplex(base()) || !cocirc && DT->is_unbounded_simplex(base()) && DT->type_of(base()) == tf ) ) { Base_iterator::operator++(); } } Simplex_iterator(const Simplex_iterator& it) : Base_iterator(it) {} Simplex_iterator& operator++() /* here we get a new candidate from the stack and insert all its not-visited neighbors */ { bool cocirc = DT->is_S_cocircular(); do { Base_iterator::operator++(); } while ( base() != DT->simplices_end() && !( cocirc && DT->is_bounded_simplex(base()) || !cocirc && DT->is_unbounded_simplex(base()) && DT->type_of(base()) == tf ) ); return *this; } Simplex_iterator operator++(int) { Simplex_iterator tmp = *this; ++(*this); return tmp; } // change modus: typedef std::forward_iterator_tag iterator_category; private: Simplex_iterator operator--(int); Simplex_iterator& operator--(); }; // Simplex_iterator class Simplex_const_iterator : public CH_simplex_const_iterator { typedef Delaunay_d Delaunay; typedef CH_simplex_const_iterator Base_iterator; const Delaunay* DT; type_of_facet tf; Base_iterator base() { return Base_iterator(*this); } public: Simplex_const_iterator(Base_iterator y = Base_iterator()) : Base_iterator(y) {} Simplex_const_iterator(const Delaunay* x, Base_iterator y, Delaunay_voronoi_kind z = NEAREST) : Base_iterator(y), DT(x) /* if the facet is not nil we set the current marker to the facet and insert all it's neighbors into the candidates stack */ { CGAL_assertion(base() != Base_iterator()); tf = (z == NEAREST ? lower_hull : upper_hull); bool cocirc = const_cast(DT)->is_S_cocircular(); while ( base() != DT->simplices_end() && !( cocirc && DT->is_bounded_simplex(base()) || !cocirc && DT->is_unbounded_simplex(base()) && DT->type_of(base()) == tf ) ) { Base_iterator::operator++(); } } Simplex_const_iterator(const Simplex_const_iterator& it) : Base_iterator(it) {} Simplex_const_iterator& operator++() /* here we get a new candidate from the stack and insert all its not-visited neighbors */ { bool cocirc = const_cast(DT)->is_S_cocircular(); do { Base_iterator::operator++(); } while ( base() != DT->simplices_end() && !( cocirc && DT->is_bounded_simplex(base()) || !cocirc && DT->is_unbounded_simplex(base()) && DT->type_of(base()) == tf ) ); return *this; } Simplex_const_iterator operator++(int) { Simplex_iterator tmp = *this; ++(*this); return tmp; } // change modus: typedef std::forward_iterator_tag iterator_category; private: Simplex_const_iterator operator--(int); Simplex_const_iterator& operator--(); }; // Simplex_iterator void project(Regular_complex_d& RC, int which = -1) const; /*{\Xop projects the upper (|which = 1|) or lower (|which = -1|) hull into regular complex |RC|. }*/ bool is_S_cocircular(); /*{\Xop returns |true| if the points of |S| are cocircular and returns |false| otherwise}*/ /*{\Mcreation 3}*/ Delaunay_d(int d, const R& k1 = R(), const Lifted_R& k2 = Lifted_R()) /*{\Mcreate creates an instance |\Mvar| of type |\Mtype|. The dimension of the underlying space is $d$ and |S| is initialized to the empty point set. The traits class |R| specifies the models of all types and the implementations of all geometric primitives used by the Delaunay class. The traits class |Lifted_R| specifies the models of all types and the implementations of all geometric primitives used by the base class of |\Mname|. The second template parameter defaults to the first: |Delaunay_d = Delaunay_d|.}*/ : Base(d+1,k2), Delaunay_kernel_(k1) { ts = unknown; } /*{\Mtext Both template arguments have to be models that fit a subset of requirements of the d-dimensional kernel. We list them at the end of this manual page.}*/ const R& kernel() const { return Delaunay_kernel_; } const R& lifted_kernel() const { return Base::kernel(); } private: /*{\Mtext The data type |\Mtype| offers neither copy constructor nor assignment operator.}*/ Delaunay_d(const Self&); Self& operator=(const Self&); public: /*{\Moperations 3 3}*/ /*{\Mtext All operations below that take a point |x| as an argument have the common precondition that $|x.dimension()| = |\Mvar.dimension()|$.}*/ int dimension() const /*{\Mop returns the dimension of ambient space}*/ { return (Base::dimension() - 1); } int current_dimension() const /*{\Mop returns the affine dimension of the current point set, i.e., $-1$ is $S$ is empty, $0$ if $S$ consists of a single point, $1$ if all points of $S$ lie on a common line, etcetera.}*/ { int d = Base::current_dimension(); if (d == -1) return d; return ( const_cast(this)->is_S_cocircular() ? d : d-1 ); } bool is_simplex_of_nearest(Simplex_handle s) const /*{\Mop returns true if |s| is a simplex of the nearest site triangulation.}*/ { if ( const_cast(this)->is_S_cocircular() ) return true; return ( type_of(s) == lower_hull ); } bool is_simplex_of_furthest(Simplex_handle s) const /*{\Mop returns true if |s| is a simplex of the furthest site triangulation.}*/ { if ( const_cast(this)->is_S_cocircular() ) return true; return (type_of(s) == upper_hull); } bool is_simplex_of_nearest(Simplex_const_handle s) const { if ( const_cast(this)->is_S_cocircular() ) return true; return ( type_of(s) == lower_hull ); } bool is_simplex_of_furthest(Simplex_const_handle s) const { if ( const_cast(this)->is_S_cocircular() ) return true; return (type_of(s) == upper_hull); } Vertex_handle vertex_of_simplex(Simplex_handle s, int i) const /*{\Mop returns the vertex associated with the $i$-th node of $s$. \precond $0 \leq i \leq |dcur|$. }*/ { if ( const_cast(this)->is_S_cocircular() ) return Base::vertex_of_simplex(s,i); else return Base::vertex_of_simplex(s,i+1); } Vertex_const_handle vertex_of_simplex(Simplex_const_handle s, int i) const { if ( const_cast(this)->is_S_cocircular() ) return Base::vertex_of_simplex(s,i); else return Base::vertex_of_simplex(s,i+1); } Point_d associated_point(Vertex_handle v) const /*{\Mop returns the point associated with vertex $v$.}*/ { typename Lifted_R::Project_along_d_axis_d project = lifted_kernel().project_along_d_axis_d_object(); return project(Base::associated_point(v)); } Point_d associated_point(Vertex_const_handle v) const { typename Lifted_R::Project_along_d_axis_d project = lifted_kernel().project_along_d_axis_d_object(); return project(Base::associated_point(v)); } Point_d point_of_simplex(Simplex_handle s,int i) const /*{\Mop returns the point associated with the $i$-th vertex of $s$. \precond $0 \leq i \leq |dcur|$. }*/ { return associated_point(vertex_of_simplex(s,i)); } Point_d point_of_simplex(Simplex_const_handle s,int i) const { return associated_point(vertex_of_simplex(s,i)); } Simplex_handle opposite_simplex(Simplex_handle s, int i) const /*{\Mop returns the simplex opposite to the $i$-th vertex of $s$ (|Simplex_handle()| if there is no such simplex). \precond $0 \leq i \leq |dcur|$. }*/ { if ( const_cast(this)->is_S_cocircular() ) { Simplex_handle f = Base::opposite_simplex(s,i); return ( Base::is_unbounded_simplex(f) ? Simplex_handle() : f ); } else { Simplex_handle f = Base::opposite_simplex(s,i+1); return ( type_of(f) == type_of(s) ? f : Simplex_handle() ); } } Simplex_const_handle opposite_simplex(Simplex_const_handle s, int i) const { if ( const_cast(this)->is_S_cocircular() ) { Simplex_const_handle f = Base::opposite_simplex(s,i); return ( Base::is_unbounded_simplex(f) ? Simplex_const_handle() : f ); } else { Simplex_const_handle f = Base::opposite_simplex(s,i+1); return ( type_of(f) == type_of(s) ? f : Simplex_const_handle() ); } } int index_of_vertex_in_opposite_simplex(Simplex_handle s,int i) const /*{\Mop returns the index of the vertex opposite to the $i$-th vertex of $s$. \precond $0 \leq i \leq |dcur|$.}*/ { if ( const_cast(this)->is_S_cocircular() ) return Base::index_of_vertex_in_opposite_simplex(s,i); else return Base::index_of_vertex_in_opposite_simplex(s,i+1) - 1; } int index_of_vertex_in_opposite_simplex(Simplex_const_handle s, int i) const { if ( const_cast(this)->is_S_cocircular() ) return Base::index_of_vertex_in_opposite_simplex(s,i); else return Base::index_of_vertex_in_opposite_simplex(s,i+1) - 1; } Simplex_handle simplex(Vertex_handle v) const; /*{\Mop returns a simplex of the nearest site triangulation incident to $v$.}*/ int index(Vertex_handle v) const; /*{\Mop returns the index of $v$ in |\Mvar.simplex(v)|.}*/ bool contains(Simplex_handle s, const Point_d& x) const; /*{\Mop returns true if |x| is contained in the closure of simplex |s|.}*/ bool empty() const /*{\Mop decides whether |\Mvar| is empty.}*/ { return (current_dimension() == -1); } void clear() /*{\Mop reinitializes |\Mvar| to the empty Delaunay triangulation.}*/ { int d = dimension(); Base::clear(d + 1); ts = unknown; } Vertex_handle insert(const Point_d& x) /*{\Mop inserts point $x$ into |\Mvar| and returns the corresponding |Vertex_handle|. More precisely, if there is already a vertex |v| in |\Mvar| positioned at $x$ (i.e., |associated_point(v)| is equal to |x|) then |associated_point(v)| is changed to |x| (i.e., |associated_point(v)| is made identical to |x|) and if there is no such vertex then a new vertex $v$ with |associated_point(v) = x| is added to |\Mvar|. In either case, $v$ is returned.}*/ { ts = unknown; typename Lifted_R::Lift_to_paraboloid_d lift = lifted_kernel().lift_to_paraboloid_d_object(); return Base::insert(lift(x)); } Simplex_handle locate(const Point_d& x) const; /*{\Mop returns a simplex of the nearest site triangulation containing |x| in its closure (returns |Simplex_handle()| if |x| lies outside the convex hull of $S$).}*/ Vertex_handle lookup(const Point_d& x) const /*{\Mop if |\Mvar| contains a vertex $v$ with |associated_point(v) = x| the result is $v$ otherwise the result is |Vertex_handle()|. }*/ { Simplex_handle s = locate(x); if ( s == Simplex_handle() ) return Vertex_handle(); for (int i = 0; i <= current_dimension(); i++) { Vertex_handle v = vertex_of_simplex(s,i); if ( x == associated_point(v) ) return v; } return Vertex_handle(); } Vertex_handle nearest_neighbor(const Point_d& x) const; /*{\Mop computes a vertex $v$ of |\Mvar| that is closest to $x$, i.e.,\\ $|dist(x,associated_point(v))| = \min \{ |dist(x, associated_point(u))| \mid u \in S\ \}$.}*/ /*{\Mtext \setopdims{5cm}{1cm}}*/ std::list range_search(const Sphere_d& C) const; /*{\Mop returns the list of all vertices contained in the closure of sphere $C$.}*/ std::list range_search(const std::vector& A) const; /*{\Mop returns the list of all vertices contained in the closure of the simplex whose corners are given by |A|. \precond |A| must consist of $d+1$ affinely independent points in base space.}*/ void all_vertices_below(const Lifted_hyperplane_d& h, Simplex_handle s, std::list& result, Unique_hash_map& is_new, bool is_cocircular) const; std::list all_simplices(Delaunay_voronoi_kind k = NEAREST) const; /*{\Mop returns a list of all simplices of either the nearest or the furthest site Delaunay triangulation of |S|.}*/ std::list all_vertices(Delaunay_voronoi_kind k = NEAREST) const; /*{\Mop returns a list of all vertices of either the nearest or the furthest site Delaunay triangulation of |S|.}*/ std::list all_points() const; /*{\Mop returns $S$. }*/ Point_const_iterator points_begin() const /*{\Mop returns the start iterator for points in |\Mvar|.}*/ { return Point_const_iterator(Base::points_begin()); } Point_const_iterator points_end() const /*{\Mop returns the past the end iterator for points in |\Mvar|.}*/ { return Point_const_iterator(Base::points_end()); } Simplex_iterator simplices_begin(Delaunay_voronoi_kind k = NEAREST) /*{\Mop returns the start iterator for simplices of |\Mvar|.}*/ { return Simplex_iterator(this,Base::simplices_begin(),k); } Simplex_iterator simplices_end() /*{\Mop returns the past the end iterator for simplices of |\Mvar|.}*/ { return Simplex_iterator(Base::simplices_end()); } Simplex_const_iterator simplices_begin(Delaunay_voronoi_kind k = NEAREST) const { return Simplex_const_iterator(this,Base::simplices_begin(),k); } Simplex_const_iterator simplices_end() const { return Simplex_const_iterator(Base::simplices_end()); } /*{\Mimplementation The data type is derived from |Convex_hull_d| via the lifting map. For a point $x$ in $d$-dimensional space let |lift(x)| be its lifting to the unit paraboloid of revolution. There is an intimate relationship between the Delaunay triangulation of a point set $S$ and the convex hull of |lift(S)|: The nearest site Delaunay triangulation is the projection of the lower hull and the furthest site Delaunay triangulation is the upper hull. For implementation details we refer the reader to the implementation report available from the CGAL server. The space requirement is the same as for convex hulls. The time requirement for an insert is the time to insert the lifted point into the convex hull of the lifted points.}*/ /*{\Mexample The abstract data type |Delaunay_d| has a default instantiation by means of the $d$-dimensional geometric kernel. \begin{Mverb} #include #include #include typedef leda_integer RT; typedef CGAL::Homogeneous_d Kernel; typedef CGAL::Delaunay_d Delaunay_d; typedef Delaunay_d::Point_d Point; typedef Delaunay_d::Simplex_handle Simplex_handle; typedef Delaunay_d::Vertex_handle Vertex_handle; int main() { Delaunay_d T(2); Vertex_handle v1 = T.insert(Point_d(2,11)); ... } \end{Mverb} }*/ /*{\Mtext\headerline{Traits requirements} |\Mname| requires the following types from the kernel traits |Lifted_R|: \begin{Mverb} RT Point_d Vector_d Ray_d Hyperplane_d \end{Mverb} and uses the following function objects from the kernel traits: \begin{Mverb} Construct_hyperplane_d Construct_vector_d Vector_to_point_d / Point_to_vector_d Orientation_d Orthogonal_vector_d Oriented_side_d / Has_on_positive_side_d Affinely_independent_d Contained_in_simplex_d Contained_in_affine_hull_d Intersect_d Lift_to_paraboloid_d / Project_along_d_axis_d Component_accessor_d \end{Mverb} |\Mname| requires the following types from the kernel traits |R|: \begin{Mverb} FT Point_d Sphere_d \end{Mverb} and uses the following function objects from the kernel traits |R|: \begin{Mverb} Construct_sphere_d Squared_distance_d Point_of_sphere_d Affinely_independent_d Contained_in_simplex_d \end{Mverb} }*/ }; // Delaunay_d template void Delaunay_d::project(Regular_complex_d& RC, int which) const { RC.clear(dimension()); Delaunay_voronoi_kind k = (which == -1 ? NEAREST : FURTHEST); Unique_hash_map project_simps; Unique_hash_map project_verts; int dc = current_dimension(); RC.set_current_dimension(dc); Simplex_const_iterator f; for(f = simplices_begin(k); f != simplices_end(); ++f) { Simplex_handle s = project_simps[f] = RC.new_simplex(); for (int i = 0; i <= dc; i++) { Vertex_const_handle v = vertex_of_simplex(f,i); Vertex_handle pv = project_verts[v]; if ( pv == Vertex_handle() ) { Point_d x = associated_point(v); pv = project_verts[v] = RC.new_vertex(x); } RC.associate_vertex_with_simplex(s,i,pv); } } /* in a second pass we set up neighbor connections */ Simplex_iterator s,t; for(f = simplices_begin(k); f != simplices_end(); ++f) { s = project_simps[f]; if ( s != Simplex_handle() ) { for (int i = 0; i <= dc; i++) { t = project_simps[opposite_simplex(f,i)]; if ( dc > 0 && t != Simplex_handle() ) { RC.set_neighbor(s,i,t, index_of_vertex_in_opposite_simplex(f,i)); } } } } } template bool Delaunay_d::is_S_cocircular() { if (ts == unknown) { int d = Base::current_dimension(); std::vector A(d + 1); typename Lifted_R::Project_along_d_axis_d project = lifted_kernel().project_along_d_axis_d_object(); for (int i = 0; i <= d; i++) A[i] = project( Base::point_of_simplex(origin_simplex_,i)); typename Lifted_R::Affinely_independent_d affinely_independent = lifted_kernel().affinely_independent_d_object(); ts = ( affinely_independent(A.begin(),A.end()) ? cocircular : non_cocircular ); if ( d == -1 && ts != cocircular ) CGAL_assertion_msg(0, "affinely independent works incorrectly for empty set"); } return (ts == cocircular); } template bool Delaunay_d:: incident_simplex_search(Vertex_handle v, Simplex_handle s) const { visited_mark(s) = true; if ( const_cast(this)->is_S_cocircular() == is_bounded_simplex(s) ) { // we have found a simplex of the desired kind int low = ( is_unbounded_simplex(s) ? 1 : 0 ); for ( int i = low; i <= Base::current_dimension(); i++) { if ( v == Base::vertex_of_simplex(s,i) ) { const_cast(this)->associate_vertex_with_simplex(s,i,v); return true; } } CGAL_assertion_msg(0, "Delaunay_d::incident_simplex_search: unreachable point."); } /* s does not have the desired kind; we visit all neighbors except the one opposite v */ bool incident = false; register int j; for (j = 0; j <= dcur; j++) if ( Base::vertex_of_simplex(s,j) == v ) incident = true; if ( !incident ) CGAL_assertion_msg(0,"reached a simplex that is not incident to v"); for (j = 0; j <= Base::current_dimension(); j++) { Simplex_handle t = Base::opposite_simplex(s,j); if ( Base::vertex_of_simplex(s,j) != v && !visited_mark(t) && incident_simplex_search(v,t) ) return true; } return false; } template typename Delaunay_d::Simplex_handle Delaunay_d::simplex(Vertex_handle v) const { Simplex_handle s = Base::simplex(v); if ( Base::vertex_of_simplex(s,Base::index(v)) != v ) CGAL_assertion_msg(0,"Delaunay_d::simplex: s is not incident to v."); incident_simplex_search(v,s); clear_visited_marks(s); return Base::simplex(v); } template int Delaunay_d::index(Vertex_handle v) const { simplex(v); int i = Base::index(v); return ( const_cast(this)->is_S_cocircular() ? i : i-1); } template bool Delaunay_d:: contains(Simplex_handle s, const Point_d& x) const { int d = current_dimension(); if (d < 0) return false; std::vector A(d + 1); for (int i = 0; i <= d; i++) A[i] = point_of_simplex(s,i); typename R::Contained_in_simplex_d contained_in_simplex = kernel().contained_in_simplex_d_object(); return contained_in_simplex(A.begin(),A.end(),x); } template typename Delaunay_d::Simplex_handle Delaunay_d:: locate(const Point_d& x) const { int d = current_dimension(); if (d < 0) return Simplex_handle(); if ( d == 0 ) { if ( x == point_of_simplex(origin_simplex_,0) ) return origin_simplex_; else return Simplex_handle(); } typename Lifted_R::Lift_to_paraboloid_d lift = lifted_kernel().lift_to_paraboloid_d_object();; Lifted_point_d lp = lift(x); if ( is_dimension_jump(lp) ) { Simplex_iterator s; for (s = const_cast(this)->simplices_begin(NEAREST); s != const_cast(this)->simplices_end(); ++s) if ( contains(s,x) ) return s; return Simplex_handle(); } // lift(p) is not a dimension jump std::list candidates; int dummy1 = 0; int loc = -1; // intialization is important Simplex_handle f; this -> visibility_search(origin_simplex_,lp,candidates,dummy1,loc,f); this -> clear_visited_marks(origin_simplex_); if ( f != Simplex_handle() ) return f; typename std::list::iterator it; for(it = candidates.begin(); it != candidates.end(); ++it) if ( contains(*it,x) ) return *it; return Simplex_handle(); } template typename Delaunay_d::Vertex_handle Delaunay_d:: nearest_neighbor(const Point_d& x) const { int d = current_dimension(); if (d < 0) return Vertex_handle(); if (d == 0) return Base::vertex_of_simplex(origin_simplex_,0); typename Lifted_R::Lift_to_paraboloid_d lift = lifted_kernel().lift_to_paraboloid_d_object();; Lifted_point_d lp = lift(x); std::list candidates; if ( is_dimension_jump(lp) ) candidates = all_simplices(NEAREST); else { // lift(x) is not a dimension jump int dummy1 = 0; int location = -1; typename Base::Facet_handle f; this -> visibility_search(origin_simplex_,lp,candidates,dummy1,location,f); this -> clear_visited_marks(origin_simplex_); CGAL_assertion_msg( location != -1, "Delaunay_d::nearest_neighbor: location cannot be -1"); if (location == 0) { // x must be one of the corners of f for (int i = 0; i < Base::current_dimension(); i++) { if ( point_of_facet(f,i) == lp ) return vertex_of_facet(f,i); } CGAL_assertion_msg(0,"Delaunay_d::nearest_neighbor: \ if loc = 1 then lp must be corner of f"); } } /* search through the vertices of the candidate simplices */ if ( candidates.empty() ) CGAL_assertion_msg(0,"Delaunay_d::nearest_neighbor: candidates is empty"); Vertex_handle nearest_v = vertex_of_simplex(*candidates.begin(),0); typename R::Squared_distance_d sqr_dist = kernel().squared_distance_d_object(); FT min_dist = sqr_dist(x,associated_point(nearest_v)); typename std::list::iterator it; for(it=candidates.begin(); it!=candidates.end(); ++it) { for (int i = 0; i <= d ; i++) { typename R::Squared_distance_d sqr_dist = kernel().squared_distance_d_object(); FT sidist = sqr_dist(x,point_of_simplex(*it,i)); if ( sidist < min_dist ) { min_dist = sidist ; nearest_v = vertex_of_simplex(*it,i); } } } return nearest_v; } template void Delaunay_d:: all_vertices_below(const Lifted_hyperplane_d& h, Simplex_handle s, std::list< Vertex_handle >& result, Unique_hash_map& is_new, bool is_cocircular) const { visited_mark(s) = true; bool some_vertex_on_or_below_h = false; register int i; int low = (is_cocircular ? 0 : 1); for (i = low; i <= Base::current_dimension(); i++) { Vertex_handle v = Base::vertex_of_simplex(s,i); typename Lifted_R::Oriented_side_d side = lifted_kernel().oriented_side_d_object(); if ( !(side(h, Base::associated_point(v)) == ON_POSITIVE_SIDE) ) { some_vertex_on_or_below_h = true; if ( is_new[v] ) { result.push_back(v); is_new[v] = false; } } } if ( !some_vertex_on_or_below_h ) return; for (i = low; i <= Base::current_dimension(); i++) { Simplex_handle t = Base::opposite_simplex(s,i); if ( !visited_mark(t) && (!is_cocircular || is_bounded_simplex(t)) ) all_vertices_below(h,t,result,is_new,is_cocircular); } } template std::list< typename Delaunay_d::Vertex_handle > Delaunay_d:: range_search(const Sphere_d& C) const { std::list result; int dc = current_dimension(); if ( dc < 0 ) return result; Point_d c = C.center(); Vertex_handle v = nearest_neighbor(c); if ( dc == 0 ) { if ( C.has_on_bounded_side(associated_point(v)) ) result.push_back(v); return result; } Simplex_handle s = simplex(v); bool is_cocircular = const_cast(this)->is_S_cocircular(); Unique_hash_map is_new(true); int d = dimension(); std::vector P(d + 1); typename Lifted_R::Lift_to_paraboloid_d lift = lifted_kernel().lift_to_paraboloid_d_object(); typename R::Point_of_sphere_d point_of_sphere = kernel().point_of_sphere_d_object(); for (int i = 0; i <= d; i++) P[i] = lift(point_of_sphere(C,i)); typedef typename Lifted_vector_d::Base_vector Base_vector; Lifted_point_d o = P[0] - Lifted_vector_d(d+1,Base_vector(),d); typename Lifted_R::Construct_hyperplane_d hyperplane_trough = lifted_kernel().construct_hyperplane_d_object(); Lifted_hyperplane_d h = hyperplane_trough(P.begin(),P.end(),o,ON_NEGATIVE_SIDE); // below is negative all_vertices_below(h,s,result,is_new,is_cocircular); clear_visited_marks(s); return result; } template std::list< typename Delaunay_d::Vertex_handle > Delaunay_d:: range_search(const std::vector& A) const { typename R::Affinely_independent_d affinely_independent = kernel().affinely_independent_d_object(); CGAL_assertion_msg( affinely_independent(A.begin(),A.end()), "Delaunay_d::range_search: simplex must be affinely independent."); typename R::Construct_sphere_d sphere_through = kernel().construct_sphere_d_object(); Sphere_d C = sphere_through(dimension(),A.begin(),A.end()); std::list result; std::list candidates = range_search(C); typename R::Contained_in_simplex_d contained_in_simplex = kernel().contained_in_simplex_d_object(); typename std::list::iterator it; for(it = candidates.begin(); it != candidates.end(); ++it) { if ( contained_in_simplex(A.begin(),A.end(),associated_point(*it)) ) result.push_back(*it); } return result; } template std::list< typename Delaunay_d::Simplex_handle > Delaunay_d:: all_simplices(Delaunay_voronoi_kind k) const { std::list result; if ( dcur < 0 ) return result; Simplex_iterator s; for (s = const_cast(this)->simplices_begin(k); s != const_cast(this)->simplices_end(); ++s) { result.push_back(s); } return result; } template std::list< typename Delaunay_d::Vertex_handle > Delaunay_d:: all_vertices(Delaunay_voronoi_kind k) const { Unique_hash_map is_new_vertex(true); std::list result; std::list hull_simplices = all_simplices(k); typename std::list::iterator it; for (it = hull_simplices.begin(); it != hull_simplices.end(); ++it) { for (int i = 0; i <= current_dimension(); i++) { Vertex_handle v = vertex_of_simplex(*it,i); if ( is_new_vertex[v] ) { is_new_vertex[v] = false; result.push_back(v); } } } return result; } template std::list< typename Delaunay_d::Point_d > Delaunay_d:: all_points() const { std::list result; std::list all_nearest_verts = all_vertices(NEAREST); typename std::list::iterator it; for(it = all_nearest_verts.begin(); it != all_nearest_verts.end(); ++it) result.push_back(associated_point(*it)); return result; } CGAL_END_NAMESPACE #endif // CGAL_DELAUNAY_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_2_1.h0000644000175000017500000006132311344301501031156 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_2_1.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman // Michel Hoffmann // Andreas Fabri #ifndef CGAL_SQUARED_DISTANCE_2_1_H #define CGAL_SQUARED_DISTANCE_2_1_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 & pt1, const typename CGAL_WRAP(K)::Point_2 & pt2, const K& k) { typename K::Vector_2 vec = k.construct_vector_2_object()(pt2, pt1); return (typename K::FT)k.compute_squared_length_2_object()(vec); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Line_2 &line, const K&, const Homogeneous_tag&) { typedef typename K::RT RT; RT a = line.a(); RT b = line.b(); RT w = pt.hw(); RT n = a*pt.hx() + b*pt.hy() + w * line.c(); RT d = (a*a+b*b) * w * w; return K::make_FT(n*n, d); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Line_2 &line, const K&, const Cartesian_tag&) { typedef typename K::FT FT; FT a = line.a(); FT b = line.b(); FT n = a*pt.x() + b*pt.y() + line.c(); FT d = a*a+b*b; return (n*n)/d; } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return squared_distance(pt, line, k, tag); } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Point_2 &pt, const K& k) { return CGALi::squared_distance(pt, line, k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { typedef typename K::Vector_2 Vector_2; typename K::Construct_vector_2 construct_vector; Vector_2 diff = construct_vector(ray.source(), pt); const Vector_2 &dir = ray.direction().vector(); if (!is_acute_angle(dir,diff, k) ) return (typename K::FT)k.compute_squared_length_2_object()(diff); return CGALi::squared_distance(pt, ray.supporting_line(), k); } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Point_2 &pt, const K& k) { return CGALi::squared_distance(pt, ray, k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { typename K::Construct_vector_2 construct_vector; typedef typename K::Vector_2 Vector_2; typedef typename K::RT RT; // assert that the segment is valid (non zero length). Vector_2 diff = construct_vector(seg.source(), pt); Vector_2 segvec = construct_vector(seg.source(), seg.target()); RT d = wdot(diff,segvec, k); if (d <= (RT)0) return (typename K::FT)k.compute_squared_length_2_object()(diff); RT e = wdot(segvec,segvec, k); if (wmult((K*)0 ,d, segvec.hw()) > wmult((K*)0, e, diff.hw())) return CGALi::squared_distance(pt, seg.target(), k); return CGALi::squared_distance(pt, seg.supporting_line(), k); } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Point_2 &pt, const K& k) { return CGALi::squared_distance(pt, seg, k); } template typename K::FT squared_distance_parallel(const typename CGAL_WRAP(K)::Segment_2 &seg1, const typename CGAL_WRAP(K)::Segment_2 &seg2, const K& k) { typedef typename K::Vector_2 Vector_2; const Vector_2 &dir1 = seg1.direction().vector(); const Vector_2 &dir2 = seg2.direction().vector(); if (same_direction(dir1, dir2, k)) { if (!is_acute_angle(seg1.source(), seg1.target(), seg2.source(), k)) return CGALi::squared_distance(seg1.target(), seg2.source(), k); if (!is_acute_angle(seg1.target(), seg1.source(), seg2.target(), k)) return CGALi::squared_distance(seg1.source(), seg2.target(), k); } else { if (!is_acute_angle(seg1.source(), seg1.target(), seg2.target(), k)) return CGALi::squared_distance(seg1.target(), seg2.target(), k); if (!is_acute_angle(seg1.target(), seg1.source(), seg2.source(), k)) return CGALi::squared_distance(seg1.source(), seg2.source(), k); } return CGALi::squared_distance(seg2.source(), seg1.supporting_line(), k); } template inline typename K::RT _distance_measure_sub(const typename K::RT &startwcross, const typename K::RT &endwcross, const typename CGAL_WRAP(K)::Point_2 &start, const typename CGAL_WRAP(K)::Point_2 &end) { return CGAL_NTS abs(wmult((K*)0, startwcross, end.hw())) - CGAL_NTS abs(wmult((K*)0, endwcross, start.hw())); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg1, const typename CGAL_WRAP(K)::Segment_2 &seg2, const K& k) { typedef typename K::RT RT; typedef typename K::FT FT; bool crossing1, crossing2; RT c1s, c1e, c2s, c2e; if (seg1.source() == seg1.target()) return CGALi::squared_distance(seg1.source(), seg2, k); if (seg2.source() == seg2.target()) return CGALi::squared_distance(seg2.source(), seg1, k); c1s = wcross(seg2.source(), seg2.target(), seg1.source(), k); c1e = wcross(seg2.source(), seg2.target(), seg1.target(), k); c2s = wcross(seg1.source(), seg1.target(), seg2.source(), k); c2e = wcross(seg1.source(), seg1.target(), seg2.target(), k); if (c1s < RT(0)) { crossing1 = (c1e >= RT(0)); } else { if (c1e <= RT(0)) { if (c1s == RT(0) && c1e == RT(0)) return CGALi::squared_distance_parallel(seg1, seg2, k); crossing1 = true; } else { crossing1 = (c1s == RT(0)); } } if (c2s < RT(0)) { crossing2 = (c2e >= RT(0)); } else { if (c2e <= RT(0)) { if (c2s == RT(0) && c2e == RT(0)) return CGALi::squared_distance_parallel(seg1, seg2, k); crossing2 = true; } else { crossing2 = (c2s == RT(0)); } } if (crossing1) { if (crossing2) return (FT)0; RT dm; dm = _distance_measure_sub(c2s,c2e, seg2.source(), seg2.target()); if (dm < RT(0)) { return CGALi::squared_distance(seg2.source(), seg1, k); } else { if (dm > RT(0)) { return CGALi::squared_distance(seg2.target(), seg1, k); } else { // parallel, should not happen (no crossing) return CGALi::squared_distance_parallel(seg1, seg2, k); } } } else { if (crossing2) { RT dm; dm = _distance_measure_sub(c1s, c1e,seg1.source(),seg1.target()); if (dm < RT(0)) { return CGALi::squared_distance(seg1.source(), seg2, k); } else { if (dm > RT(0)) { return CGALi::squared_distance(seg1.target(), seg2, k); } else { // parallel, should not happen (no crossing) return CGALi::squared_distance_parallel(seg1, seg2, k); } } } else { FT min1, min2; RT dm = _distance_measure_sub( c1s, c1e, seg1.source(), seg1.target()); if (dm == RT(0)) return CGALi::squared_distance_parallel(seg1, seg2, k); min1 = (dm < RT(0)) ? CGALi::squared_distance(seg1.source(), seg2, k): CGALi::squared_distance(seg1.target(), seg2, k); dm = _distance_measure_sub( c2s, c2e, seg2.source(), seg2.target()); if (dm == RT(0)) // should not happen. return CGALi::squared_distance_parallel(seg1, seg2, k); min2 = (dm < RT(0)) ? CGALi::squared_distance(seg2.source(), seg1, k): CGALi::squared_distance(seg2.target(), seg1, k); return (min1 < min2) ? min1 : min2; } } } template inline typename K::RT _distance_measure_sub(const typename K::RT &startwcross, const typename K::RT &endwcross, const typename CGAL_WRAP(K)::Vector_2 &start, const typename CGAL_WRAP(K)::Vector_2 &end) { return CGAL_NTS abs(wmult((K*)0, startwcross, end.hw())) - CGAL_NTS abs(wmult((K*)0, endwcross, start.hw())); } template typename K::FT squared_distance_parallel(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { typedef typename K::Vector_2 Vector_2; const Vector_2 &dir1 = seg.direction().vector(); const Vector_2 &dir2 = ray.direction().vector(); if (same_direction(dir1, dir2, k)) { if (!is_acute_angle(seg.source(), seg.target(), ray.source(), k)) return CGALi::squared_distance(seg.target(), ray.source(), k); } else { if (!is_acute_angle(seg.target(), seg.source(), ray.source(), k)) return CGALi::squared_distance(seg.source(), ray.source(), k); } return CGALi::squared_distance(ray.source(), seg.supporting_line(), k); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { typename K::Construct_vector_2 construct_vector; typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; const Vector_2 &raydir = ray.direction().vector(); Vector_2 startvec(construct_vector(ray.source(), seg.source())); Vector_2 endvec(construct_vector(ray.source(), seg.target())); typename K::Orientation_2 orientation; bool crossing1, crossing2; RT c1s, c1e; if (seg.source() == seg.target()) return CGALi::squared_distance(seg.source(), ray, k); c1s = wcross(raydir, startvec, k); c1e = wcross(raydir, endvec, k); if (c1s < RT(0)) { crossing1 = (c1e >= RT(0)); } else { if (c1e <= RT(0)) { if (c1s == RT(0) && c1e == RT(0)) return CGALi::squared_distance_parallel(seg, ray, k); crossing1 = true; } else { crossing1 = (c1s == RT(0)); } } switch (orientation(seg.source(), seg.target(), ray.source())) { case LEFT_TURN: crossing2 = right_turn(construct_vector(seg.source(), seg.target()), raydir, k); break; case RIGHT_TURN: crossing2 = left_turn(construct_vector(seg.source(), seg.target()), raydir, k); break; default: crossing2 = true; break; } if (crossing1) { if (crossing2) return FT(0); return CGALi::squared_distance(ray.source(), seg, k); } else { if (crossing2) { RT dm; dm = _distance_measure_sub(c1s, c1e, startvec, endvec); if (dm < RT(0)) { return CGALi::squared_distance(seg.source(), ray, k); } else { if (dm > RT(0)) { return CGALi::squared_distance(seg.target(), ray, k); } else { // parallel, should not happen (no crossing) return CGALi::squared_distance_parallel(seg, ray, k); } } } else { FT min1, min2; RT dm = _distance_measure_sub(c1s, c1e, startvec, endvec); if (dm == RT(0)) return CGALi::squared_distance_parallel(seg, ray, k); min1 = (dm < RT(0)) ? CGALi::squared_distance(seg.source(), ray, k) : CGALi::squared_distance(seg.target(), ray, k); min2 = CGALi::squared_distance(ray.source(), seg, k); return (min1 < min2) ? min1 : min2; } } } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { return CGALi::squared_distance(seg, ray, k); } template typename K::FT _sqd_to_line(const typename CGAL_WRAP(K)::Vector_2 &diff, const typename K::RT & wcross, const typename CGAL_WRAP(K)::Vector_2 &dir ) { typedef typename K::RT RT; typedef typename K::FT FT; RT numerator = wcross*wcross; RT denominator = wmult((K*)0, RT(wdot(dir,dir, K())), diff.hw(), diff.hw()); FT result = K::make_FT(numerator, denominator); return result; } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { typename K::Construct_vector_2 construct_vector; typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; typedef typename K::Point_2 Point_2; const Vector_2 &linedir = line.direction().vector(); const Point_2 &linepoint = line.point(); Vector_2 startvec(construct_vector(linepoint, seg.source())); Vector_2 endvec(construct_vector(linepoint, seg.target())); bool crossing1; RT c1s, c1e; if (seg.source() == seg.target()) return CGALi::squared_distance(seg.source(), line, k); c1s = wcross(linedir, startvec, k); c1e = wcross(linedir, endvec, k); if (c1s < RT(0)) { crossing1 = (c1e >= RT(0)); } else { if (c1e <= RT(0)) { crossing1 = true; } else { crossing1 = (c1s == RT(0)); } } if (crossing1) { return (FT)0; } else { RT dm; dm = _distance_measure_sub(c1s, c1e, startvec, endvec); if (dm <= RT(0)) { return _sqd_to_line(startvec, c1s, linedir); } else { return _sqd_to_line(endvec, c1e, linedir); } } } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { return CGALi::squared_distance(seg, line, k); } template typename K::FT ray_ray_squared_distance_parallel( const typename CGAL_WRAP(K)::Vector_2 &ray1dir, const typename CGAL_WRAP(K)::Vector_2 &ray2dir, const typename CGAL_WRAP(K)::Vector_2 &from1to2, const K& k) { typedef typename K::RT RT; typedef typename K::FT FT; if (!is_acute_angle(ray1dir, from1to2, k)) { if (!same_direction(ray1dir, ray2dir, k)) return (typename K::FT)k.compute_squared_length_2_object()(from1to2); } RT wcr, w; wcr = wcross(ray1dir, from1to2, k); w = from1to2.hw(); return (typename K::FT)(FT(wcr*wcr) / FT(wmult((K*)0, RT(wdot(ray1dir, ray1dir, k)), w, w))); } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray1, const typename CGAL_WRAP(K)::Ray_2 &ray2, const K& k) { typename K::Construct_vector_2 construct_vector; typedef typename K::Vector_2 Vector_2; typedef typename K::FT FT; const Vector_2 &ray1dir = ray1.direction().vector(); const Vector_2 &ray2dir = ray2.direction().vector(); Vector_2 diffvec(construct_vector(ray1.source(),ray2.source())); bool crossing1, crossing2; switch (orientation(ray1dir, ray2dir, k)) { case COUNTERCLOCKWISE: crossing1 = !clockwise(diffvec, ray2dir, k); crossing2 = !counterclockwise(ray1dir, diffvec, k); break; case CLOCKWISE: crossing1 = !counterclockwise(diffvec, ray2dir, k); crossing2 = !clockwise(ray1dir, diffvec, k); break; default: return ray_ray_squared_distance_parallel(ray1dir,ray2dir,diffvec,k); } if (crossing1) { if (crossing2) return (FT)0; return CGALi::squared_distance(ray2.source(), ray1, k); } else { if (crossing2) { return CGALi::squared_distance(ray1.source(), ray2, k); } else { FT min1, min2; min1 = CGALi::squared_distance(ray1.source(), ray2, k); min2 = CGALi::squared_distance(ray2.source(), ray1, k); return (min1 < min2) ? min1 : min2; } } } template typename K::FT squared_distance(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { typename K::Construct_vector_2 construct_vector; typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; Vector_2 normalvec(line.a(), line.b()); Vector_2 diff = construct_vector(line.point(), ray.source()); FT sign_dist = k.compute_scalar_product_2_object()(diff,normalvec); if (sign_dist < FT(0)) { if (is_acute_angle(normalvec, ray.direction().vector(), k) ) return (FT)0; } else { if (is_obtuse_angle(normalvec, ray.direction().vector(), k) ) return (FT)0; } return (typename K::FT)((sign_dist*sign_dist)/k.compute_squared_length_2_object()(normalvec)); } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { return CGALi::squared_distance(line, ray, k); } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Line_2 &line1, const typename CGAL_WRAP(K)::Line_2 &line2, const K& k) { typedef typename K::FT FT; if (CGALi::parallel(line1, line2, k)) return CGALi::squared_distance(line1.point(), line2, k); else return (FT)0; } template void distance_index(int &ind, const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { typename K::Construct_vector_2 construct_vector; if (!is_acute_angle(ray.direction().vector(), construct_vector(ray.source(), pt), k)) { ind = 0; return; } ind = -1; } template void distance_index(int &ind, const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { if (!is_acute_angle(seg.target(),seg.source(),pt, k)) { ind = 0; return; } if (!is_acute_angle(seg.source(),seg.target(),pt, k)) { ind = 1; return; } ind = -1; } template inline typename K::FT squared_distance_indexed(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Ray_2 &ray, int ind, const K& k) { if (ind == 0) return CGALi::squared_distance(pt, ray.source(), k); return CGALi::squared_distance(pt, ray.supporting_line(), k); } template inline typename K::FT squared_distance_indexed(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Segment_2 &seg, int ind, const K& k) { if (ind == 0) return CGALi::squared_distance(pt, seg.source(), k); if (ind == 1) return CGALi::squared_distance(pt, seg.target(), k); return CGALi::squared_distance(pt, seg.supporting_line(), k); } } // namespace CGALi template inline typename K::FT squared_distance(const Point_2 & pt1, const Point_2 & pt2) { return CGALi::squared_distance(pt1, pt2, K()); } template class Squared_distance_to_line { typename K::RT a, b, c, sqnorm; public: Squared_distance_to_line(typename K::Line_2 const &line) : a(line.a()), b(line.b()), c(line.c()) { sqnorm = a*a+b*b; } typename K::FT impl(typename K::Point_2 const &pt, const Homogeneous_tag&) const { typedef typename K::RT RT; RT w = pt.hw(); RT n = a*pt.hx() + b*pt.hy() + c * w; RT d = sqnorm * w * w; return K::make_FT(n*n, d); } typename K::FT impl(typename K::Point_2 const &pt, const Cartesian_tag&) const { typedef typename K::FT FT; FT n = a*pt.x() + b*pt.y() + c; return (n*n) / sqnorm; } typename K::FT operator()(typename K::Point_2 const &pt) const { typedef typename K::Kernel_tag Tag; Tag tag; return impl(pt, tag); } }; template inline typename K::FT squared_distance(const Point_2 &pt, const Line_2 &line) { return CGALi::squared_distance(pt, line, K()); } template inline typename K::FT squared_distance(const Line_2 & line, const Point_2 & pt) { return squared_distance(pt, line); } template class Squared_distance_to_ray { typename K::Vector_2 ray_dir; typename K::Point_2 ray_source; Squared_distance_to_line supline_dist; public: Squared_distance_to_ray(typename K::Ray_2 const &ray) : ray_dir(ray.direction().vector()), ray_source(ray.source()), supline_dist(ray.supporting_line()) { } typename K::FT operator()(typename K::Point_2 const &pt) const { typename K::Construct_vector_2 construct_vector; typename K::Compute_squared_length_2 compute_squared_length; typename K::Vector_2 diff = construct_vector(ray_source, pt); if (! CGALi::is_acute_angle(ray_dir,diff, K()) ) return (typename K::FT)compute_squared_length(diff); return supline_dist(pt); } }; template inline typename K::FT squared_distance(const Point_2 &pt, const Ray_2 &ray) { return CGALi::squared_distance(pt, ray, K()); } template inline typename K::FT squared_distance(const Ray_2 & ray, const Point_2 & pt) { return squared_distance(pt, ray); } template class Squared_distance_to_segment { typename K::Point_2 seg_source, seg_target; Squared_distance_to_line supline_dist; typename K::Vector_2 segvec; typename K::RT e; public: Squared_distance_to_segment(typename K::Segment_2 const &seg) : seg_source(seg.source()), seg_target(seg.target()), supline_dist(seg.supporting_line()) { typename K::Construct_vector_2 construct_vector; segvec = construct_vector(seg_source, seg_target); e = CGALi::wdot(segvec,segvec, K()); } typename K::FT operator()(typename K::Point_2 const &pt) const { typename K::Construct_vector_2 construct_vector; typename K::Compute_squared_length_2 compute_squared_length; typedef typename K::RT RT; // assert that the segment is valid (non zero length). typename K::Vector_2 diff = construct_vector(seg_source, pt); RT d = CGALi::wdot(diff,segvec, K()); if (d <= (RT)0) return (typename K::FT)compute_squared_length(diff); if (wmult((K*)0 ,d, segvec.hw()) > wmult((K*)0, e, diff.hw())) return CGALi::squared_distance(pt, seg_target, K()); return supline_dist(pt); } }; template inline typename K::FT squared_distance(const Point_2 &pt, const Segment_2 &seg) { return CGALi::squared_distance(pt, seg, K()); } template inline typename K::FT squared_distance(const Segment_2 & seg, const Point_2 & pt) { return CGALi::squared_distance(pt, seg, K()); } template inline typename K::FT squared_distance(const Segment_2 &seg1, const Segment_2 &seg2) { return CGALi::squared_distance(seg1, seg2, K()); } template inline typename K::FT squared_distance(const Segment_2 &seg, const Ray_2 &ray) { return CGALi::squared_distance(seg, ray, K()); } template inline typename K::FT squared_distance(const Ray_2 & ray, const Segment_2 & seg) { return CGALi::squared_distance(seg, ray, K()); } template inline typename K::FT squared_distance(const Segment_2 &seg, const Line_2 &line) { return CGALi::squared_distance(seg, line, K()); } template inline typename K::FT squared_distance(const Line_2 & line, const Segment_2 & seg) { return CGALi::squared_distance(seg, line, K()); } template inline typename K::FT squared_distance(const Ray_2 &ray1, const Ray_2 &ray2) { return CGALi::squared_distance(ray1, ray2, K()); } template inline typename K::FT squared_distance(const Line_2 &line, const Ray_2 &ray) { return CGALi::squared_distance(line, ray, K()); } template inline typename K::FT squared_distance(const Ray_2 & ray, const Line_2 & line) { return CGALi::squared_distance(line, ray, K()); } template inline typename K::FT squared_distance(const Line_2 &line1, const Line_2 &line2) { return CGALi::squared_distance(line1, line2, K()); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian_converter.h0000644000175000017500000001732311344301500031177 0ustar debiandebian// Copyright (c) 2001-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian_converter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion // Menelaos Karavelas #ifndef CGAL_CARTESIAN_CONVERTER_H #define CGAL_CARTESIAN_CONVERTER_H // This file contains the definition of a kernel converter, based on Cartesian // representation. It should work between *Cartesian and *Cartesian, // provided you give a NT converter from A to B. // There's a Homogeneous counterpart. #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Guess which compiler needs this work around ? namespace CGALi { template < typename K1, typename K2 > struct Default_converter { typedef typename K1::FT FT1; typedef typename K2::FT FT2; typedef ::CGAL::NT_converter Type; }; } // namespace CGALi template < class K1, class K2, // class Converter = NT_converter > class Converter = typename CGALi::Default_converter::Type > class Cartesian_converter : public Enum_converter { private: typedef Enum_converter Base; public: typedef K1 Source_kernel; typedef K2 Target_kernel; typedef Converter Number_type_converter; #ifdef CGAL_CFG_USING_BASE_MEMBER_BUG bool operator()(bool b) const { return Base::operator()(b); } Sign operator()(Sign s) const { return Base::operator()(s); } Oriented_side operator()(Oriented_side os) const { return Base::operator()(os); } Bounded_side operator()(Bounded_side bs) const { return Base::operator()(bs); } Comparison_result operator()(Comparison_result cr) const { return Base::operator()(cr); } Angle operator()(Angle a) const { return Base::operator()(a); } #else using Base::operator(); #endif Cartesian_converter() // To shut up a warning with SunPRO. : c(), k() {} Origin operator()(const Origin& o) const { return o; } Null_vector operator()(const Null_vector& n) const { return n; } Bbox_2 operator()(const Bbox_2& b) const { return b; } Bbox_3 operator()(const Bbox_3& b) const { return b; } typename K2::FT operator()(const typename K1::FT &a) const { return c(a); } typename K2::Point_2 operator()(const typename K1::Point_2 &a) const { typedef typename K2::Point_2 Point_2; return Point_2(c(a.x()), c(a.y())); } typename K2::Vector_2 operator()(const typename K1::Vector_2 &a) const { typedef typename K2::Vector_2 Vector_2; return Vector_2(c(a.x()), c(a.y())); } typename K2::Direction_2 operator()(const typename K1::Direction_2 &a) const { typedef typename K2::Direction_2 Direction_2; return Direction_2(c(a.dx()), c(a.dy())); } typename K2::Segment_2 operator()(const typename K1::Segment_2 &a) const { typedef typename K2::Segment_2 Segment_2; return Segment_2(operator()(a.source()), operator()(a.target())); } typename K2::Line_2 operator()(const typename K1::Line_2 &a) const { typedef typename K2::Line_2 Line_2; return Line_2(c(a.a()), c(a.b()), c(a.c())); } typename K2::Ray_2 operator()(const typename K1::Ray_2 &a) const { typedef typename K2::Ray_2 Ray_2; return Ray_2(operator()(a.source()), operator()(a.second_point())); } typename K2::Circle_2 operator()(const typename K1::Circle_2 &a) const { typedef typename K2::Circle_2 Circle_2; return Circle_2(operator()(a.center()), c(a.squared_radius()), a.orientation()); } typename K2::Triangle_2 operator()(const typename K1::Triangle_2 &a) const { typedef typename K2::Triangle_2 Triangle_2; return Triangle_2(operator()(a.vertex(0)), operator()(a.vertex(1)), operator()(a.vertex(2))); } typename K2::Iso_rectangle_2 operator()(const typename K1::Iso_rectangle_2 &a) const { typedef typename K2::Iso_rectangle_2 Iso_rectangle_2; return Iso_rectangle_2(operator()(a.min()), operator()(a.max())); } typename K2::Point_3 operator()(const typename K1::Point_3 &a) const { typedef typename K2::Point_3 Point_3; return Point_3(c(a.x()), c(a.y()), c(a.z())); } typename K2::Vector_3 operator()(const typename K1::Vector_3 &a) const { typedef typename K2::Vector_3 Vector_3; return Vector_3(c(a.x()), c(a.y()), c(a.z())); } typename K2::Direction_3 operator()(const typename K1::Direction_3 &a) const { typedef typename K2::Direction_3 Direction_3; return Direction_3(c(a.dx()), c(a.dy()), c(a.dz())); } typename K2::Segment_3 operator()(const typename K1::Segment_3 &a) const { typedef typename K2::Segment_3 Segment_3; return Segment_3(operator()(a.source()), operator()(a.target())); } typename K2::Line_3 operator()(const typename K1::Line_3 &a) const { typedef typename K2::Line_3 Line_3; return Line_3(operator()(a.point()), operator()(a.direction())); } typename K2::Ray_3 operator()(const typename K1::Ray_3 &a) const { typedef typename K2::Ray_3 Ray_3; return Ray_3(operator()(a.source()), operator()(a.second_point())); } typename K2::Sphere_3 operator()(const typename K1::Sphere_3 &a) const { typedef typename K2::Sphere_3 Sphere_3; return Sphere_3(operator()(a.center()), c(a.squared_radius()), a.orientation()); } typename K2::Triangle_3 operator()(const typename K1::Triangle_3 &a) const { typedef typename K2::Triangle_3 Triangle_3; return Triangle_3(operator()(a.vertex(0)), operator()(a.vertex(1)), operator()(a.vertex(2))); } typename K2::Tetrahedron_3 operator()(const typename K1::Tetrahedron_3 &a) const { typedef typename K2::Tetrahedron_3 Tetrahedron_3; return Tetrahedron_3(operator()(a.vertex(0)), operator()(a.vertex(1)), operator()(a.vertex(2)), operator()(a.vertex(3))); } typename K2::Plane_3 operator()(const typename K1::Plane_3 &a) const { typedef typename K2::Plane_3 Plane_3; return Plane_3(c(a.a()), c(a.b()), c(a.c()), c(a.d())); } typename K2::Iso_cuboid_3 operator()(const typename K1::Iso_cuboid_3 &a) const { typedef typename K2::Iso_cuboid_3 Iso_cuboid_3; return Iso_cuboid_3(operator()(a.min()), operator()(a.max())); } private: Converter c; K2 k; }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_CONVERTER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_graham_andrew.C0000644000175000017500000002474511344301500030411 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_graham_andrew.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_GRAHAM_ANDREW_C #define CGAL_CH_GRAHAM_ANDREW_C #ifndef CGAL_CH_GRAHAM_ANDREW_H #include #endif // CGAL_CH_GRAHAM_ANDREW_H #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS #include #include #include #include #include CGAL_BEGIN_NAMESPACE template OutputIterator ch_graham_andrew_scan( BidirectionalIterator first, BidirectionalIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn; std::vector< BidirectionalIterator > S; BidirectionalIterator alpha; BidirectionalIterator beta; BidirectionalIterator iter; CGAL_ch_precondition( first != last ); CGAL_ch_precondition( successor(first) != last ); --last; CGAL_ch_precondition( *first != *last ); S.push_back( last ); S.push_back( first ); Left_turn left_turn = ch_traits.left_turn_2_object(); iter = first; do { ++iter; } while (( iter != last ) && !left_turn(*last, *first, *iter) ); if ( iter != last ) { S.push_back( iter ); typedef typename std::vector::reverse_iterator rev_iterator; rev_iterator stack_rev_iter = S.rbegin(); alpha = iter; beta = *++stack_rev_iter; for ( ++iter ; iter != last; ++iter ) { if ( left_turn(*alpha, *iter, *last) ) { while ( !left_turn(*beta, *alpha, *iter) ) { S.pop_back(); alpha = beta; stack_rev_iter = S.rbegin(); beta = *++stack_rev_iter; CGAL_ch_assertion(S.size() >= 2); } S.push_back( iter ); beta = alpha; alpha = iter; } } } typedef typename std::vector< BidirectionalIterator >::iterator std_iterator; std_iterator stack_iter = S.begin(); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... for ( ++stack_iter; stack_iter != S.end(); ++stack_iter) { *res = **stack_iter; ++res; } CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( res.output_so_far_begin(), \ res.output_so_far_end(), \ ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_chain_check_2( \ first, last, \ res.output_so_far_begin(), res.output_so_far_end(), \ ch_traits)); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } template OutputIterator ch__ref_graham_andrew_scan( BidirectionalIterator first, BidirectionalIterator last, OutputIterator& result, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn; CGAL_ch_precondition_code( typedef typename Traits::Equal_2 Equal_2; Equal_2 equal_points = ch_traits.equal_2_object(); ) Left_turn left_turn = ch_traits.left_turn_2_object(); std::vector< BidirectionalIterator > S; BidirectionalIterator alpha; BidirectionalIterator beta; BidirectionalIterator iter; CGAL_ch_precondition( first != last ); CGAL_ch_precondition( successor(first) != last ); --last; CGAL_ch_precondition(! equal_points(*first,*last) ); S.push_back( last ); S.push_back( first ); iter = first; do { ++iter; } while (( iter != last ) && !left_turn(*last, *first, *iter) ); if ( iter != last ) { S.push_back( iter ); typedef typename std::vector::reverse_iterator rev_iterator; rev_iterator stack_rev_iter = S.rbegin(); alpha = iter; beta = *++stack_rev_iter; for ( ++iter ; iter != last; ++iter ) { if ( left_turn(*alpha, *iter, *last) ) { while ( !left_turn(*beta, *alpha, *iter) ) { S.pop_back(); alpha = beta; stack_rev_iter = S.rbegin(); beta = *++stack_rev_iter; CGAL_ch_assertion(S.size() >= 2); } S.push_back( iter ); beta = alpha; alpha = iter; } } } typedef typename std::vector< BidirectionalIterator >::iterator std_iterator; std_iterator stack_iter = S.begin(); for ( ++stack_iter; stack_iter != S.end(); ++stack_iter) { *result = **stack_iter; ++result; } return result; } template OutputIterator ch_graham_andrew( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn; typedef typename Traits::Equal_2 Equal_2; Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; std::vector< Point_2 > V; std::copy( first, last, std::back_inserter(V) ); std::sort( V.begin(), V.end(), ch_traits.less_xy_2_object() ); if (equal_points( *(V.begin()), *(V.rbegin())) ) { *result = *(V.begin()); ++result; return result; } #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... ch__ref_graham_andrew_scan( V.begin(), V.end(), res, ch_traits); ch__ref_graham_andrew_scan( V.rbegin(), V.rend(), res, ch_traits); CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( res.output_so_far_begin(), \ res.output_so_far_end(), \ ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( \ V.begin(), V.end(), \ res.output_so_far_begin(), res.output_so_far_end(), \ ch_traits)); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } template OutputIterator ch_lower_hull_scan( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn; typedef typename Traits::Equal_2 Equal_2; Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; std::vector< Point_2 > V; std::copy( first, last, std::back_inserter(V) ); std::sort( V.begin(), V.end(), ch_traits.less_xy_2_object() ); if (equal_points( *(V.begin()), *(V.rbegin())) ) { *result = *(V.begin()); ++result; return result; } #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... ch_graham_andrew_scan( V.begin(), V.end(), res, ch_traits); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } template OutputIterator ch_upper_hull_scan( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn; typedef typename Traits::Equal_2 Equal_2; Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; std::vector< Point_2 > V; std::copy( first, last, std::back_inserter(V) ); std::sort( V.begin(), V.end(), ch_traits.less_xy_2_object() ); if (equal_points( *(V.begin()), *(V.rbegin())) ) { return result; } #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... ch_graham_andrew_scan( V.rbegin(), V.rend(), res, ch_traits); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } CGAL_END_NAMESPACE #endif // CGAL_CH_GRAHAM_ANDREW_C ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interval_skip_list_interval.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interval_skip_list_int0000644000175000017500000000603011344301500031461 0ustar debiandebian// Copyright (c) 2003 GeometryFactory // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Interval_skip_list_interval.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_INTERVAL_SKIP_LIST_INTERVAL_H #define CGAL_INTERVAL_SKIP_LIST_INTERVAL_H #include namespace CGAL { template class Interval_skip_list_interval { public: typedef Value_ Value; private: bool lbound_; bool rbound_; Value inf_; Value sup_; public: Interval_skip_list_interval(){} Interval_skip_list_interval(const Value& inf_, const Value& sup_, bool lb = true, bool rb = true); const Value& inf() const {return inf_;} const Value& sup() const {return sup_;} bool inf_closed() const {return lbound_;} bool sup_closed() const {return rbound_;} bool contains(const Value& V) const; // true iff this contains (l,r) bool contains_interval(const Value& l, const Value& r) const; bool operator==(const Interval_skip_list_interval& I) const { return ( (inf() == I.inf()) && (sup() == I.sup()) && (inf_closed() == I.inf_closed()) && (sup_closed() == I.sup_closed()) ); } bool operator!=(const Interval_skip_list_interval& I) const { return ! (*this == I); } }; template std::ostream& operator<<(std::ostream& os, const Interval_skip_list_interval& i) { os << (i.inf_closed()?"[":"(") << i.inf() << ", " << i.sup() << (i.sup_closed()?"]":")"); return os; } template Interval_skip_list_interval::Interval_skip_list_interval( const Value& i, const Value& s, bool lb, bool rb) : lbound_(lb), rbound_(rb), inf_(i), sup_(s) { if ( inf_ > sup_ ) { std::cerr << "Error: " << *this << std::endl; exit(1); } } template bool Interval_skip_list_interval::contains_interval(const Value& i, const Value& s) const // true iff this contains (l,r) { return( (inf() <= i) && (sup() >= s) ); } template bool Interval_skip_list_interval::contains(const Value& v) const { // return true if this contains V, false otherwise if((v > inf()) && (v < sup())) return true; else if ((v == inf()) && inf_closed()) return true; else if ((v == sup()) && sup_closed()) return true; else return false; } } // namespace CGAL #endif // CGAL_INTERVAL_SKIP_LIST_INTERVAL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/functions_on_enums.h0000644000175000017500000000361011344301500031104 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/functions_on_enums.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_FUNCTIONS_ON_ENUMS_H #define CGAL_FUNCTIONS_ON_ENUMS_H #include #include CGAL_BEGIN_NAMESPACE template inline T opposite(const T& t) { return -t; } inline Sign opposite(Sign o) { return static_cast( - static_cast(o)); } inline Comparison_result opposite(Comparison_result o) { return static_cast( - static_cast(o)); } inline Oriented_side opposite(Oriented_side os) { return static_cast( - static_cast(os)); } inline Bounded_side opposite(Bounded_side bs) { return static_cast( - static_cast(bs)); } inline Angle opposite(Angle a) { return static_cast( - static_cast(a)); } CGAL_END_NAMESPACE #endif // CGAL_FUNCTIONS_ON_ENUMS_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_size_criteria_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_size_cri0000644000175000017500000001172011344301500031411 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_size_criteria_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DELAUNAY_MESH_SIZE_CRITERIA_2_H #define CGAL_DELAUNAY_MESH_SIZE_CRITERIA_2_H #include #include #include #include namespace CGAL { template class Delaunay_mesh_size_criteria_2 : public virtual Delaunay_mesh_criteria_2 { protected: double sizebound; public: typedef Delaunay_mesh_criteria_2 Base; Delaunay_mesh_size_criteria_2(const double aspect_bound = 0.125, const double size_bound = 0) : Base(aspect_bound), sizebound(size_bound) {}; inline double size_bound() const { return sizebound; }; inline void set_size_bound(const double sb) { sizebound = sb; }; // first: squared_minimum_sine // second: size struct Quality : public std::pair { typedef std::pair Base; Quality() : Base() {}; Quality(double _sine, double _size) : Base(_sine, _size) {}; const double& size() const { return second; } const double& sine() const { return first; } // q1 1 ) if( q.size() > 1 ) return ( size() > q.size() ); else return true; // *this is big but not q else if( q.size() > 1 ) return false; // q is big but not *this return( sine() < q.sine() ); } std::ostream& operator<<(std::ostream& out) const { return out << "(size=" << size() << ", sine=" << sine() << ")"; } }; class Is_bad: public Base::Is_bad { protected: const double squared_size_bound; // squared size bound on edge length public: typedef typename Base::Is_bad::Point_2 Point_2; Is_bad(const double aspect_bound, const double size_bound) : Base::Is_bad(aspect_bound), squared_size_bound(size_bound * size_bound) {}; Mesh_2::Face_badness operator()(const Quality q) const { if( q.size() > 1 ) return Mesh_2::IMPERATIVELY_BAD; if( q.sine() < this->B ) return Mesh_2::BAD; else return Mesh_2::NOT_BAD; } Mesh_2::Face_badness operator()(const typename CDT::Face_handle& fh, Quality& q) const { typedef typename CDT::Geom_traits Geom_traits; typedef typename Geom_traits::Compute_area_2 Compute_area_2; typedef typename Geom_traits::Compute_squared_distance_2 Compute_squared_distance_2; typedef typename Geom_traits::Construct_triangle_2 Construct_triangle_2; typedef typename Geom_traits::FT FT; Geom_traits traits; /** @warning traits with data!! */ Compute_squared_distance_2 squared_distance = traits.compute_squared_distance_2_object(); const Point_2& pa = fh->vertex(0)->point(); const Point_2& pb = fh->vertex(1)->point(); const Point_2& pc = fh->vertex(2)->point(); double a = CGAL::to_double(squared_distance(pb, pc)), b = CGAL::to_double(squared_distance(pc, pa)), c = CGAL::to_double(squared_distance(pa, pb)); double max_length; // squared max edge length double second_max_length; if(a 1 ) { q.first = 1; // (do not compute sine) return Mesh_2::IMPERATIVELY_BAD; } } Compute_area_2 area_2 = traits.compute_area_2_object(); double area = 2*CGAL::to_double(area_2(pa, pb, pc)); q.first = (area * area) / (max_length * second_max_length); // (sine) if( q.sine() < this->B ) return Mesh_2::BAD; else return Mesh_2::NOT_BAD; } }; Is_bad is_bad_object() const { return Is_bad(this->bound(), size_bound()); } }; } // end namespace CGAL #endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Point_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Point_2_interse0000644000175000017500000000223111344301500031174 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Point_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2.h0000644000175000017500000021206311344301500027470 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Planar_map_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Eyal Flato // Oren Nechushtan // Eti Ezra // Shai Hirsch // Eugene Lipovetsky #ifndef CGAL_PLANAR_MAP_2_H #define CGAL_PLANAR_MAP_2_H /*! \file * The implementation of the Planar_map_2 class. */ #include #include #include #ifndef CGAL_NO_PM_DEFAULT_POINT_LOCATION #include #include #include #include #include #endif // CGAL_NO_PM_DEFAULT_POINT_LOCATION // for solving the dynamic cast in the copy constructor, // these lines will be removed after writing // copy construtor for point location. #include #include #include #include // default bounding box for finite curves #include // default bounding box for infinite curves #include #include #include #include #include CGAL_BEGIN_NAMESPACE //////////////////////////////////////////////////////////////////////////// // PLANAR_MAP_2 /*! An object $pm$ of the class Planar_map_2 is the planar * subdivision induced by a set of $x$-monotone curves such that no curve * intersects the interior of any other curve. */ template class Planar_map_2 : public Topological_map { public: typedef PlanarMapDcel_2 Dcel; typedef PlanarMapTraits_2 Traits; typedef Planar_map_2 Planar_map; typedef Planar_map_2 Self; typedef Pm_traits_wrap_2 Traits_wrap; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Point_2 Point_2; typedef Topological_map TPM; typedef typename TPM::Halfedge Halfedge; typedef typename TPM::Vertex_iterator Vertex_iterator; typedef typename TPM::Halfedge_iterator Halfedge_iterator; typedef typename TPM::Edge_iterator Edge_iterator; typedef typename TPM::Face_iterator Face_iterator; typedef typename TPM::Vertex_const_iterator Vertex_const_iterator; typedef typename TPM::Halfedge_const_iterator Halfedge_const_iterator; typedef typename TPM::Edge_const_iterator Edge_const_iterator; typedef typename TPM::Face_const_iterator Face_const_iterator; typedef typename TPM::Vertex_handle Vertex_handle; typedef typename TPM::Vertex_const_handle Vertex_const_handle; typedef typename TPM::Halfedge_handle Halfedge_handle; typedef typename TPM::Face_handle Face_handle; typedef typename TPM::Halfedge_const_handle Halfedge_const_handle; typedef typename TPM::Face_const_handle Face_const_handle; typedef typename TPM::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename TPM::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; typedef typename TPM::Holes_iterator Holes_iterator; typedef typename TPM::Holes_const_iterator Holes_const_iterator; typedef typename TPM::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename TPM::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename TPM::Size Size; typedef Pm_point_location_base Point_location_base; typedef Pm_bounding_box_base Bounding_box_base; typedef Pm_change_notification Change_notification; // Obsolete, for backward compatability typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using TPM::halfedges_begin; using TPM::halfedges_end; using TPM::vertices_begin; using TPM::vertices_end; using TPM::number_of_faces; using TPM::unbounded_face; using TPM::u_face; using TPM::d; #endif // Implementation Types // -------------------- protected: typedef std::list X_monotone_curve_2_container; // sweep related types typedef Pm_less_point_xy PointLessFunctor; typedef typename X_monotone_curve_2_container::iterator X_monotone_curve_2_container_iterator; typedef Point_plus_handle Point_plus; typedef std::map PointContainer; typedef typename PointContainer::value_type PointContainer_value_type; typedef typename PointContainer::iterator PointContainer_iterator; typedef Pm_point_node Point_node; typedef std::map Event_queue; typedef typename Event_queue::value_type Event_queue_value_type; typedef typename Event_queue::iterator Event_queue_iterator; typedef Pm_curve_node Curve_node_; typedef typename Point_node::Curve_node_iterator Curve_node_iterator; public: typedef enum { VERTEX = 1, EDGE, FACE , UNBOUNDED_VERTEX, UNBOUNDED_EDGE, UNBOUNDED_FACE } Locate_type; /*! Parameterless Constructor */ Planar_map_2(); /*! Copy Constructor. */ Planar_map_2(const Self & pm); /*! Assignment Operator */ Self & operator=(const Self & pm); /*! Destructor */ virtual ~Planar_map_2(); //! A constructor given a point-location parameter. Planar_map_2(Point_location_base * pl_ptr); //! A constructor given a copy traits, point-location, and //! Bounding-box parameters. Planar_map_2(const Traits & tr_, Point_location_base * pl_ptr, Bounding_box_base * bb_ptr); //! A constructor given a traits, point-location, and Bounding-box //! parameters. set NULLs for defaults Planar_map_2(Traits_wrap * tr_ptr, Point_location_base * pl_ptr, Bounding_box_base * bb_ptr); //! reads a planar map. bool read(std::istream &in); //! reads a planar map. template bool read(std::istream &, Scanner & scanner) { clear(); return scan_planar_map(scanner); } //! inserts a given curve into the map. /*! insert() inserts the given curve into the map. * \param cv the given curve * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to a new halfedge directed in the same way as the curve * cv. That is, the curve source and target points coincide with the points * of the source and target vertices of the returned halfedge respectively. */ Halfedge_handle insert(const X_monotone_curve_2 & cv, Change_notification * en = NULL); //! iterates through a given range of curves, inserting the curves into the // map. /*! insert() inserts a range of curves, using a simplified sweep * algorithm. * \param begin the input iterator that points to the first curve in the * range. * \param end the input past-the-end iterator of the range. * \param en the notification class. * \return a handle to a new halfedge directed in the same way as the last * curve in the range. * \todo probably doesn't need to return anything. */ template Halfedge_iterator insert(const X_monotone_curve_2_iterator & begin, const X_monotone_curve_2_iterator & end, Change_notification * en = NULL) { return non_intersecting_insert(begin, end, en); } template Halfedge_iterator non_intersecting_insert(const X_monotone_curve_2_iterator & begin, const X_monotone_curve_2_iterator & end, Change_notification * en = NULL) { PointLessFunctor event_queue_pred(traits); Event_queue event_queue(event_queue_pred); init_for_insert(begin, end, event_queue); while ( !(event_queue.empty()) ) { Event_queue_iterator event = event_queue.begin(); update_subdivision(event->second, en); event_queue.erase(event); } return halfedges_begin(); } //! inserts a given curve into the map as a new inner component of a given // face /*! insert_in_face_interior() inserts the given curve into the map as a new * inner component of the given face. * \param cv the given curve. * \param f the given face. * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to a new halfedge directed in the same way as the curve * cv. That is, the curve source and target points coinside with the points * of the source and target vertices of the returned halfedge respectively. */ Halfedge_handle insert_in_face_interior(const X_monotone_curve_2 & cv, Face_handle f, Change_notification * en = NULL); //! inserts a given curve that one of its endpoints is held by the target // vertex of a given halfedge into the map. /*! insert_from_vertex() inserts the given curve cv into the map. One * endpoint of cv is the point of the target vertex, v, of the given halfedge * h. The returened twin halfedge is inserted immediately after h in the * circular list of halfedges that share the same target vertex v. This * method is the quick version of insert_from_vertex(), as the search for the * previous halfedge in the circular list of halfedges that share the same * target vertex is unnecessary, saving computation time. * \param cv the given curve. * \param prev the reference halfedge. Its target vertex v, is already * in the map. * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to a new halfedge that has v as its source vertex. */ Halfedge_handle insert_from_vertex(const X_monotone_curve_2 & cv, Halfedge_handle prev, Change_notification * en = NULL #ifdef _MSC_VER ,int dummy = 0 #endif ); //! inserts a given curve that one of its endpoints is held by a given // vertex into the map. /*! insert_from_vertex() the given curve cv into the map. One endpoint of cv * is the point of the given vertex v1, that is already in the map. * \param cv the given curve. * \param v1 the given vertex. * \param source indicates whether the target of the returned halfedge holds * the given curve (cv) target point. * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to a new halfedge that has v1 as its source vertex. */ Halfedge_handle insert_from_vertex(const X_monotone_curve_2 & cv, Vertex_handle v1, Change_notification * en = NULL); Halfedge_handle non_intersecting_insert_from_vertex(const X_monotone_curve_2 & cv, Vertex_handle v1, Change_notification * en = NULL); // Obsolete Halfedge_handle insert_from_vertex(const X_monotone_curve_2 & cv, Vertex_handle v1, bool source, Change_notification * en = NULL); //! inserts a given curve that both of its endpoints are held by the target // vertices of two given halfedges respectively into the map. /*! insert_at_vertices() the given curve into the map. The two endpoints of * cv are held by the two target vertices v1 and v2 of h1 and h2 * respectively. The returened halfedge is inserted immediately after h1 in * the circular list of halfedges that share the same target vertex v1. Its * twin halfedge is inserted immediately after h2 in the circular list of * halfedges that share the same target vertex v2. This method is the quick * version of insert_from_vertex(), as the search for the previous halfedges * in the circular lists of halfedges that share the same target vertices is * unnecessary, saving computation time. * \param cv the given curve. * \param prev1 the given halfedge that its target vertex is already in * the map, and will be the source vertex of the returned halfedge. * \param prev2 the given halfedge that its target vertex is already in * the map, and will be the target vertex of the returned halfedge. * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to to a new halfedge, that has v1 and v2 as its source * and target vertices respectively. */ Halfedge_handle insert_at_vertices(const X_monotone_curve_2 & cv, Halfedge_handle prev1, Halfedge_handle prev2, Change_notification * en = NULL #ifdef _MSC_VER ,int dummy = 0 #endif ); //! inserts a given curve that both of its endpoints are held by two given // vertices respectively into the map. /*! insert_at_vertices() inserts the given curve cv into the map. The two * endpoints of cv are held by the two given vertices v1 and v2 respectively, * that are already in the map. * \param cv the given curve. * \param v1 the vertex in the map that holds the curve source point. * \param v2 the vertex in the map that holds the curve target point. * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to a new halfedge that has v1 and v2 as its source and * target vertices respectively. */ Halfedge_handle insert_at_vertices(const X_monotone_curve_2 & cv, Vertex_handle v1, Vertex_handle v2, Change_notification * en = NULL); //! is the planar map empty? bool is_empty() const { return halfedges_begin() == halfedges_end(); } // Note that the return types are abstract base classes const Point_location_base * get_point_location() const { return pl; } const Bounding_box_base * get_bounding_box() const { return bb; } const Traits_wrap & get_traits() const { return *traits; } private: /*! Returns the length of the path from prev2 to prev1, if they are * connected, and -1 otherwise. Returns 0 if they are identical. */ int path_length(Halfedge_const_handle prev1, Halfedge_const_handle prev2); //! a private implementation which defines if prev1 is on an outer ccb of // the new face (returns true) or on an inner ccb (returns false) bool prev1_inside_hole(Halfedge_const_handle prev1, Halfedge_const_handle prev2, const X_monotone_curve_2& cv); public: Halfedge_handle split_edge(Halfedge_handle e, const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, Change_notification * en = NULL); Halfedge_handle merge_edge(Halfedge_handle e1, Halfedge_handle e2, const X_monotone_curve_2 & cv, Change_notification * en = NULL); Face_handle remove_edge(Halfedge_handle e); Halfedge_handle vertical_ray_shoot(const Point_2 & p, Locate_type & lt, bool up) { CGAL_precondition(pl); return pl->vertical_ray_shoot(p,lt,up); } Halfedge_const_handle vertical_ray_shoot(const Point_2& p, Locate_type <, bool up) const { CGAL_precondition(pl); return ((const Point_location_base*)pl)->vertical_ray_shoot(p,lt,up); // The type cast to const is there to ensure that the planar map // is not changed. } Halfedge_handle locate(const Point_2& p, Locate_type <) { CGAL_precondition(pl); return pl->locate(p,lt); } Halfedge_const_handle locate(const Point_2& p, Locate_type <) const { CGAL_precondition(pl); return ((const Point_location_base*)pl)->locate(p,lt); // The type cast to const is there to ensure that the planar map // is not changed. } //! determines whether a given point lies within the interior of a given //! face. /*! is_point_in_face() is a predicate that determines whether a given point * lies within the interior of a given face. * A point lies within a face interior, iff the number of intersections * between the face boundary and a ray emanating from the point is even. * Note that if the given face is the unbounded face, and it has no holes, * the point must lie within the face interior. * \param p the given point. * \param f a handle to the given face. * \return true if the given point lies within the interior of the given * face, and false otherwise. */ bool is_point_in_face(const Point_2 & p, Face_const_handle f) { if (!f->is_unbounded()) { // f is bounded: Halfedge_const_handle h = f->halfedge_on_outer_ccb(); if (!point_is_in(p, h, h->curve())) return false; } // Examine f holes: for (Holes_const_iterator it = f->holes_begin(); it != f->holes_end(); ++it) { Halfedge_const_handle h = *it; if (point_is_in(p, h, h->curve())) return false; } return true; } protected: //! determines whether a given point lies within the region bounded by //! a circular boundary given by a halfedge on the boundary. /*! point_is_in() is a predicate that determines whether a given point lies * within the geometrical region bounded by a circular boundary given by a * halfedge on the boundary. The halfedge curve is provided explicitly, in * case the halfedge hasn't been fully constructed yet. * A point lies within region, iff the number of intersections between the * region boundary and a ray emanating from the point is even. * This function counts the number of intersections with a vertical ray, by * counting the number of boundary halfedges that are above the input point, * and the input point is in their x-range. The functions carefuly handles * degenerate cases. For example, the vertical ray coinsides with a boundary * halfedge. * Note that this function iterates the given circular boundary only, and * ignores other objcts, such as holes that might be inside the boundary. * \param p the given point. * \param ne a handle to a halfedge incident to the face in question. * \param ncv the curve of the given halfedge (for cases where the * halfedge is premature curve-less) * \return true if the given point lies within the interior of the face * incident to the given halfedge, and false otherwise. */ bool point_is_in(const Point_2 & p, Halfedge_const_handle ne, const X_monotone_curve_2 & ncv) const; ///////////////////////////////////////////////////////// // Assignment functions // Those are temporary functions and it should not be used public: void assign(const Self &pm) { TPM::assign(pm); // traits->assign(pm->traits); // bb->assign(pm->bb); // pl->assign(pm->pl); } // used in implementation of operator=( void clear(); protected: // used in implementation of operator=( void x_curve_container(X_monotone_curve_2_container &l) const; // default initializer for the bounding box. #include #ifdef CGAL_PM_DEBUG // for private debugging use public: void debug() { if (pl) (pl->debug()); } #endif private: ///////////////////////////////////////////////////////////////////////// // Scanning Arrangement. ///////////////////////////////////////////////////////////////////////// template bool scan_planar_map (Scanner& scanner) { if (!build_dcel(scanner)) return false; return true; } template bool build_dcel (Scanner& scanner) { typedef typename Dcel::Vertex D_vertex; typedef typename Dcel::Halfedge D_halfedge; typedef typename Dcel::Face D_face; typedef typename Dcel::Vertex_iterator D_vetrex_iterator; typedef typename Dcel::Vertex_const_iterator D_vetrex_const_iterator; typedef typename Dcel::Halfedge_iterator D_halfedge_iterator; typedef typename Dcel::Halfedge_const_iterator D_halfedge_const_iterator; typedef typename Dcel::Face_iterator D_face_iterator; typedef typename Dcel::Face_const_iterator D_face_const_iterator; // keeping a vector of halfedges (to access them easily by their indices). std::vector halfedges_vec; std::vector vertices_vec; if ( ! scanner.in()) return 0; scanner.scan_pm_vhf_sizes(); if ( ! scanner.in()){ std::cerr << "can't read vhf values"<set_point(p); // for debug. //std::cout<<"Reading vertex no " <point()<insert(nv->point()); //scanner.skip_to_next_vertex(); //if ( ! scanner.in()){ // std::cerr << "can't skip to next vertex"<set_curve(cv); // scanner.scan_halfedge_attributes (nh->opposite()); // if ( ! scanner.in()){ // std::cerr << "can't read halfedge attributes"<opposite()); if ( ! scanner.in()){ std::cerr << "can't read halfedge"<opposite()->set_curve(cv); nv1 = vertices_vec[index1]; ((D_vertex*) nv1)->set_halfedge(nh); nh->set_vertex((D_vertex*) nv1); //for debug //std::cout<<((D_vertex*) nv1)->point()<set_halfedge(nh->opposite()); nh->opposite()->set_vertex((D_vertex*) nv2); //for debug //std::cout<<((D_vertex*) nv2)->point()<insert(D_halfedge_iterator(nh->opposite()), cv); bb->insert(cv); halfedges_vec.push_back(nh); halfedges_vec.push_back(nh->opposite()); //scanner.skip_to_next_halfedge(); //if ( ! scanner.in()){ // std::cerr << "can't skip to next halfedge"< 0) // else - allocate the bounded face. nf = d.new_face(); scanner.scan_face(nf); if ( ! scanner.in()){ std::cerr << "can't read face"< inline void init_for_insert(X_monotone_curve_2_iterator curves_begin, X_monotone_curve_2_iterator curves_end, Event_queue &event_queue) { X_monotone_curve_2_iterator cv_iter; X_monotone_curve_2_container_iterator xcv_iter; X_monotone_curve_2_container all_curves; // take the curves from the planar map and insert them to // the curve list. Clear the planar map. for (Halfedge_iterator h_iter = halfedges_begin(); h_iter != halfedges_end(); ++h_iter, ++h_iter) all_curves.push_back(h_iter->curve()); // clear the planar map clear(); // add the inout curves to the container for (cv_iter = curves_begin; cv_iter != curves_end; ++cv_iter) all_curves.push_back(*cv_iter); // Create the point_plus handles: for any pair of // overlapping points from the input we ensure we have only one // handle. - not having such a structure as input_vertices caused // a bug. PointLessFunctor pred(traits); PointContainer input_vertices(pred); for (xcv_iter = all_curves.begin(); xcv_iter != all_curves.end(); ++xcv_iter){ if (input_vertices.find(traits->curve_source(*xcv_iter)) == input_vertices.end()) input_vertices.insert( PointContainer_value_type (traits->curve_source(*xcv_iter), Point_plus(traits->curve_source(*xcv_iter))) ); if (input_vertices.find(traits->curve_target(*xcv_iter)) == input_vertices.end()) input_vertices.insert( PointContainer_value_type (traits->curve_target(*xcv_iter), Point_plus(traits->curve_target(*xcv_iter))) ); } // Create the Curve_node handles and the event queue. unsigned int id = 0; for(xcv_iter = all_curves.begin(); xcv_iter != all_curves.end(); ++xcv_iter, ++id) { X_curve cv(*xcv_iter); PointContainer_iterator curr_point_plus = input_vertices.find( traits->curve_source(cv) ); // defining one cv_node for both source and target event points. Curve_node_ cv_node = Curve_node_(cv, curr_point_plus->second, traits); // look for the interection point in the queue. if does not exist, // add it. if exists, merge it with the existing one (add the curve) Event_queue_iterator edge_point = event_queue.find( traits->curve_source(cv) ); if (edge_point == event_queue.end() || edge_point->second.get_point() != curr_point_plus->second) { Point_node new_ix = Point_node(cv_node, curr_point_plus->second, traits ); event_queue.insert(Event_queue_value_type(traits->curve_source(cv), new_ix)); } else { edge_point->second.add_curve(cv_node); } // same as above for the curve's target edge_point = event_queue.find( traits->curve_target(cv) ); curr_point_plus = input_vertices.find( traits->curve_target(cv) ); if (edge_point == event_queue.end() || edge_point->second.get_point() != curr_point_plus->second) { Point_node new_ix = Point_node(cv_node, curr_point_plus->second, traits ); event_queue.insert(Event_queue_value_type(traits->curve_target(cv), new_ix)); } else edge_point->second.add_curve(cv_node); } } void update_subdivision(Point_node& point_node, Change_notification *pm_change_notf); protected: // Remove the Halfedge_const_handle protections static inline Halfedge_handle Halfedge_handle_unconst(const Halfedge_const_handle hc) { return Halfedge_handle((Halfedge*)&*&*hc); } }; //----------------------------------------------------------------------------- // Member Function Definitions //----------------------------------------------------------------------------- /*! A parameter-less constructor. */ template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >::Planar_map_2() { traits = new Traits_wrap(); use_delete_traits = true; #ifndef CGAL_NO_PM_DEFAULT_POINT_LOCATION pl = new Pm_trapezoid_ric_point_location; use_delete_pl = true; pl->init(*this,*traits); #else CGAL_assertion_msg(false, "No default point location is defined; you must supply one."); #endif bb = init_default_bounding_box((Traits*)traits); use_delete_bb = true; bb->init(*this, *traits); } /*! A constructor given a point-location parameter. */ template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >:: Planar_map_2(typename Planar_map_2::Point_location_base * pl_ptr) { traits = new Traits_wrap(); use_delete_traits = true; pl = pl_ptr; use_delete_pl = false; pl->init(*this, *traits); bb = init_default_bounding_box((Traits*)traits); use_delete_bb = true; bb->init(*this, *traits); } /*! A constructor given a copy traits, point-location, and * Bounding-box parameters. */ template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >:: Planar_map_2( const typename Planar_map_2::Traits & tr_, typename Planar_map_2::Point_location_base * pl_ptr, typename Planar_map_2::Bounding_box_base * bb_ptr) { traits = new Traits_wrap(tr_); use_delete_traits = true; if (pl_ptr == NULL) { #ifndef CGAL_NO_PM_DEFAULT_POINT_LOCATION pl = new Pm_trapezoid_ric_point_location; use_delete_pl = true; pl->init(*this,*traits); #else CGAL_assertion_msg( false, "No default point location is defined; you must supply one."); #endif } else { pl = pl_ptr; use_delete_pl = false; pl->init(*this, *traits); } if (bb_ptr == NULL) { bb=init_default_bounding_box((Traits*)traits); use_delete_bb=true; bb->init(*this,*traits); } else { bb = bb_ptr; use_delete_bb = false; bb->init(*this,*traits); } } /*! A constructor given a copy traits wrap, point-location, and * Bounding-box parameters. */ template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >:: Planar_map_2( typename Planar_map_2< Dcel, Traits >::Traits_wrap * tr_ptr, typename Planar_map_2< Dcel, Traits >::Point_location_base * pl_ptr, typename Planar_map_2< Dcel, Traits >::Bounding_box_base * bb_ptr ) { if (tr_ptr == NULL) { traits = new Traits_wrap(); use_delete_traits = true; } else { traits = tr_ptr; use_delete_traits = false; } if (pl_ptr == NULL) { #ifndef CGAL_NO_PM_DEFAULT_POINT_LOCATION pl = new Pm_trapezoid_ric_point_location; use_delete_pl = true; pl->init(*this,*traits); #else CGAL_assertion_msg( false, "No default point location is defined; you must supply one."); #endif } else { pl = pl_ptr; use_delete_pl = false; pl->init(*this,*traits); } if (bb_ptr == NULL) { bb=init_default_bounding_box((Traits*)traits); use_delete_bb=true; bb->init(*this,*traits); } else { bb = bb_ptr; use_delete_bb = false; bb->init(*this,*traits); } } /*! Copy Constructor. * \todo get rid of the cast. Instead implement a copy constructor and a clone * operation for the various point location strategies. */ template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >:: Planar_map_2(const Planar_map_2 & pm) { typedef Pm_trapezoid_ric_point_location Pm_trapezoid_ric_point_location; // doing the same as Planar_map_2(pm.get_traits(),pm.get_point_location(), // pm.get_point_bbox()); typedef Pm_naive_point_location Pm_naive; typedef Pm_naive* Pm_naive_pointer; traits = new Traits_wrap(); use_delete_traits = true; if (dynamic_cast(pm.pl) ){ //cout<<"Naive"<; } else if (dynamic_cast*>(pm.pl) ){ pl = new Pm_simple_point_location; //cout<<"Walk"<*>(pm.pl) ){ pl = new Pm_walk_along_line_point_location; //cout<<"Walk"< set_planar_map(this); use_delete_pl = true; bb=init_default_bounding_box((Traits*)traits); use_delete_bb=true; bb->init(*this,*traits); return; #else CGAL_assertion_msg( false, "No default point location is defined; you must supply one."); #endif } use_delete_pl = true; pl->init(*this,*traits); bb=init_default_bounding_box((Traits*)traits); use_delete_bb=true; bb->init(*this,*traits); assign(pm); Halfedge_iterator h_iter; for (h_iter = halfedges_begin(); h_iter != halfedges_end(); h_iter++, h_iter++) pl->insert(h_iter, h_iter->curve()); for (Vertex_iterator v_iter = vertices_begin(); v_iter != vertices_end(); v_iter++) bb->insert(v_iter->point()); for (h_iter = halfedges_begin(); h_iter != halfedges_end(); h_iter++, h_iter++) bb->insert(h_iter->curve()); } //----------------------------------------------------------------------------- template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >::~Planar_map_2() { if (use_delete_pl) delete pl; if (use_delete_bb) delete bb; if (use_delete_traits) delete traits; } //----------------------------------------------------------------------------- template < class Dcel, class Traits > bool Planar_map_2< Dcel, Traits >:: read(std::istream & in) { clear(); Pm_file_scanner scanner(in); return scan_planar_map(scanner); } /*! */ template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert_in_face_interior( const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv, typename Planar_map_2< Dcel, Traits >::Face_handle f, Change_notification * en) { Halfedge_handle h = Topological_map::insert_in_face_interior(f); h->set_curve(cv); //should set the curve of the twin as well but for now h->twin()->set_curve(cv); //iddo - for arrangement //pl->insert(h,cv); h->source()->set_point(traits->curve_source(cv)); h->target()->set_point(traits->curve_target(cv)); //idit - moved for point location with triangulation pl->insert(h,cv); if (en != NULL) { en->add_edge(cv, h, true, false); en->add_hole(f, h); } return h; } /*! Inserts the given curve cv into the map. One * endpoint of cv is the point of the target vertex, v, of the given halfedge * h. The returened twin halfedge is inserted immediately after h in the * circular list of halfedges that share the same target vertex v. This * method is the quick version of insert_from_vertex(), as the search for the * previous halfedge in the circular list of halfedges that share the same * target vertex is unnecessary, saving computation time. * \param cv the given curve. * \param prev the reference halfedge. Its target vertex v, is already * in the map. * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. * \return a handle to a new halfedge that has v as its source vertex. */ template < class Dcel, class Traits > inline typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert_from_vertex (const typename Planar_map_2::X_monotone_curve_2 & cv, typename Planar_map_2::Halfedge_handle prev, Change_notification * en #ifdef _MSC_VER ,int #endif ) { CGAL_precondition_msg(traits->point_equal(prev->target()->point(), traits->curve_source(cv)) || traits->point_equal(prev->target()->point(), traits->curve_target(cv)), "Point of target vertex of input halfedge should be a curve endpoint."); Halfedge_handle h = Topological_map::insert_from_vertex(prev); h->set_curve(cv); h->twin()->set_curve(cv); bool source = traits->point_equal(prev->target()->point(), traits->curve_source(cv)); (source) ? h->target()->set_point(traits->curve_target(cv)) : h->target()->set_point(traits->curve_source(cv)); // Insert the curve into the auxiliary point-location data structure: pl->insert(h, cv); if (en != NULL) { en->add_edge(cv, h, source, false); } return h; } /*! */ template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert_from_vertex (const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv, typename Planar_map_2< Dcel, Traits >::Vertex_handle v1, Change_notification * en) { CGAL_precondition_msg(traits->point_equal(v1->point(), traits->curve_source(cv)) || traits->point_equal(v1->point(), traits->curve_target(cv)), "Point of input vertex should be a curve endpoint."); // Find the previous of cv: Halfedge_around_vertex_circulator prev = v1->incident_halfedges(), after = prev, infinite_loop = prev; ++after; if (after != prev) { while (!(traits->curve_is_between_cw(cv,prev->curve(), after->curve(),v1->point()))) { prev = after; ++after; if (prev == infinite_loop) // infinite loop indication { std::cerr << std::endl << "Planar_map_2::insert_from_vertex(" << "const X_monotone_curve_2& cv, Vertex_handle v1, " << "bool source) called with previously " << "inserted curve " << std::endl; return Halfedge_handle(); } } } return insert_from_vertex(cv, prev, en); } template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: non_intersecting_insert_from_vertex( const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv, typename Planar_map_2< Dcel, Traits >::Vertex_handle v1, Change_notification * en) { return insert_from_vertex(cv, v1, en); } // Obsolete template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert_from_vertex (const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv, typename Planar_map_2< Dcel, Traits >::Vertex_handle v1, bool source, Change_notification * en) { (void) source; // For some reason MSVC cannot handle the following call, even if the // definition is inlined in the class. Too many nested calls. Go figure... #if 0 return insert_from_vertex(cv, v1, en); #else // Find the previous of cv: Halfedge_around_vertex_circulator prev = v1->incident_halfedges(), after = prev, infinite_loop = prev; ++after; if (after != prev) { while (!(traits->curve_is_between_cw(cv,prev->curve(), after->curve(),v1->point()))) { prev = after; ++after; if (prev == infinite_loop) // infinite loop indication { std::cerr << std::endl << "Planar_map_2::insert_from_vertex(" << "const X_monotone_curve_2& cv, Vertex_handle v1, " << "bool source) called with previously " << "inserted curve " << std::endl; return Halfedge_handle(); } } } return insert_from_vertex(cv, prev, en); #endif } /*! Returns the length of the path from prev2 to prev1, if they are * connected, and -1 otherwise. Returns 0 if they are identical. */ template < class Dcel, class Traits > int Planar_map_2< Dcel, Traits >:: path_length(typename Planar_map_2< Dcel, Traits >::Halfedge_const_handle prev1, typename Planar_map_2< Dcel, Traits >::Halfedge_const_handle prev2) { Ccb_halfedge_const_circulator first(prev2), curr(prev2), last(prev1); ++last; int cnt = 0; for (++curr; curr != last; ++curr) { cnt++; if (curr == first) return -1; } return cnt; } /*! */ template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert_at_vertices (const typename Planar_map_2::X_monotone_curve_2 & cv, typename Planar_map_2::Halfedge_handle prev1, typename Planar_map_2::Halfedge_handle prev2, Change_notification * en #ifdef _MSC_VER ,int #endif ) { CGAL_precondition_msg(traits->point_equal(prev1->target()->point(), traits->curve_source(cv)) && traits->point_equal(prev2->target()->point(), traits->curve_target(cv)) || traits->point_equal(prev2->target()->point(), traits->curve_source(cv)) && traits->point_equal(prev1->target()->point(), traits->curve_target(cv)), "Points of target vertices of input halfedges should be curve endpoints."); Size num_before = number_of_faces(); bool prev1_before_prev2 = true; int cnt1 = path_length(prev1, prev2); // If the 2 halfedge (targets) are disconnected, the insertion of the curve // into the topological map does not generate a new face. Otherwise, it // much more efficient to calculate the shortest path and apply the test // to it. if (cnt1 != -1) { int cnt2 = path_length(prev2, prev1); prev1_before_prev2 = (cnt1 < cnt2) ? prev1_inside_hole(prev1, prev2, cv) : !prev1_inside_hole(prev2, prev1, cv); } // bool prev1_before_prev2 = prev1_inside_hole(prev1, prev2, cv); Halfedge_handle h = (prev1_before_prev2) ? Topological_map::insert_at_vertices(prev1, prev2) : Topological_map::insert_at_vertices(prev2, prev1); h->set_curve(cv); h->twin()->set_curve(cv); Size num_after = number_of_faces(); if (num_after - num_before) { // a face was added => move holes Face_handle nf = h->face(); // the new face is pointed at by h Face_handle of = h->twin()->face(); // old face Holes_iterator it = of->holes_begin(); while (it != of->holes_end()) { // check if the hole is inside new face // new for arrangement if (point_is_in((*it)->target()->point(), h, cv)) { Holes_iterator tmp = it; // deletion invalidates iterators so... ++it; // assumes only the erased iterator is invalidated (like stl // list) move_hole(tmp, of, nf); } else ++it; } } // v1 should be the source of h. if (!prev1_before_prev2) h = h->twin(); //pl->insert(h); //iddo - for arrangement pl->insert(h, cv); // Notifying change. if (en != NULL) { Face_handle orig_face = prev1_before_prev2 ? h->twin()->face() : h->face(); en->add_edge(cv, h, true, false); // After fixing the notifier we won't have to check that since // h->face() will be surely the new face. (h->face() == orig_face) ? en->split_face(h->face(), h->twin()->face()) : en->split_face(h->twin()->face(), h->face()); // we surely know h->face() is the new face. // en->split_face(h->twin()->face(), h->face()); } return h; } /*! */ template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert_at_vertices (const typename Planar_map_2::X_monotone_curve_2 & cv, typename Planar_map_2< Dcel, Traits >::Vertex_handle v1, typename Planar_map_2< Dcel, Traits >::Vertex_handle v2, Change_notification * en) { CGAL_precondition_msg(traits->point_equal(v1->point(), traits->curve_source(cv)) && traits->point_equal(v2->point(), traits->curve_target(cv)) || traits->point_equal(v2->point(), traits->curve_source(cv)) && traits->point_equal(v1->point(), traits->curve_target(cv)), "Points of input vertices should be curve endpoints."); Halfedge_around_vertex_circulator prev1 = v1->incident_halfedges(), after = prev1, infinite_loop = prev1; ++after; if (after != prev1) { while (!(traits->curve_is_between_cw(cv, prev1->curve(), after->curve(), v1->point()))) { prev1 = after; ++after; if (prev1 == infinite_loop) // infinite loop indication { std::cerr << std::endl << "Planar_map_2::insert_at_vertices(" << "const X_monotone_curve_2 & cv, Vertex_const_handle v1, " << "Vertex_const_handle v2) called with previously " << "inserted curve " << std::endl; return Halfedge_handle(); } } } Halfedge_around_vertex_circulator prev2 = v2->incident_halfedges(); after = prev2; infinite_loop = prev2; ++after; if (after != prev2) { while (!(traits->curve_is_between_cw(cv, prev2->curve(), after->curve(),v2->point()))) { prev2 = after; ++after; if (prev2 == infinite_loop) // infinite loop indication { std::cerr << std::endl << "Planar_map_2::insert_at_vertices(" << "const X_monotone_curve_2 & cv, Vertex_const_handle v1," << "Vertex_const_handle v2) called with previously " << "inserted curve " << std::endl; return Halfedge_handle(); } } } return insert_at_vertices(cv, prev1, prev2, en); } //----------------------------------------------------------------------------- template < class Dcel, class Traits > bool Planar_map_2< Dcel, Traits >:: prev1_inside_hole( typename Planar_map_2< Dcel, Traits >::Halfedge_const_handle prev1, typename Planar_map_2< Dcel, Traits >::Halfedge_const_handle prev2, const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv) { // Defining geometrically whether there is a new face. If there is, // finds if prev1 is on the outside of the new face (send // prev1,prev2) or on the inside of the new face (send prev2,prev1) // The algorithm: // 1. go over all the halfedges of the face which // will hold prev1 (since the new face is not constructed yet, // this is modeled by going from prev2->next to prev1 and // then over the new curve) // 2. find if the left-most-lower halfedge in the path (i.e, the one // with the leftmost down target and is the lowest to the right // among the incident edges of this vertex) is directed left (we are // on the outside) or right (we are inside ) (if not on same ccb // then it doesn't matter and return true) Ccb_halfedge_const_circulator left_edge(prev2); ++left_edge; Ccb_halfedge_const_circulator first(prev2),curr(left_edge), last(prev1); ++last; //we want the prev1 to be checked as well Point_2 left = prev2->target()->point(); bool b; do { //source b = false; if (traits->point_is_left( curr->source()->point(),left)) b = true; else if (traits->point_equal(curr->source()->point(),left)) { if (traits->curve_is_vertical(curr->curve()) && traits->point_is_left_low(curr->target()->point(),left) ) { b = true; } else { Comparison_result cres; if (traits->point_is_left(left, curr->target()->point()) && (((cres = traits->curves_compare_y_at_x(curr->curve(), left_edge->curve(), left)) == SMALLER) || (cres == EQUAL && traits->curves_compare_y_at_x_right(curr->curve(), left_edge->curve(), left) == SMALLER))) b = true; } } if (b) { left = curr->source()->point(); left_edge = curr; } //target b = false; if (traits->point_is_left( curr->target()->point(),left)) b = true; if (traits->point_equal(curr->target()->point(),left)) { if (traits->curve_is_vertical(curr->curve()) && traits->point_is_left_low(curr->source()->point(),left) ) { b = true; } else { Comparison_result cres; if (traits->point_is_left(left, curr->source()->point()) && (((cres = traits->curves_compare_y_at_x(curr->curve(), left_edge->curve(), left)) == SMALLER) || (cres == EQUAL && traits->curves_compare_y_at_x_right(curr->curve(), left_edge->curve(), left) == SMALLER))) { b = true; } //we want in the degenerate case to return the halfedge //pointing _at_ the left point else { if ( (curr)==(left_edge->twin()) ) b = true; } } } if (b) { left = curr->target()->point(); left_edge = curr; } ++curr; } while ( (curr != first) && (curr != last) ); //test the new curve against left_edge if (traits->point_equal(traits->curve_target(cv),left)|| traits->point_equal(traits->curve_source(cv),left)) { if (traits->curve_is_vertical(cv)) { return (traits->point_is_left_low(prev2->target()->point(), prev1->target()->point())); } else { Comparison_result cres; if ((traits->point_is_left(left, traits->curve_source(cv)) || traits->point_is_left(left, traits->curve_target(cv))) && (! traits->curve_is_vertical(left_edge->curve())) && (((cres = traits->curves_compare_y_at_x(cv,left_edge->curve(), left)) == SMALLER) || (cres == EQUAL && traits->curves_compare_y_at_x_right(cv,left_edge->curve(), left) == SMALLER))) { return (traits->point_is_left(prev1->target()->point(), prev2->target()->point())); } } } //check if left_edge is from left to right if (traits->curve_is_vertical(left_edge->curve())) { if (traits->point_is_left_low(left_edge->source()->point(), left_edge->target()->point())) return false; else return true; } return (traits->point_is_left(left_edge->source()->point(), left_edge->target()->point())); } /*! */ template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: insert(const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv, Change_notification * en) { CGAL_precondition_msg( ! traits->curve_is_degenerate(cv), "Curve length should be greater than zero."); CGAL_precondition_msg(bb, "Bounding box should not be null."); bb->insert(cv); Locate_type lt1, lt2; Point_2 src = traits->curve_source(cv); Point_2 tgt = traits->curve_target(cv); // The point location may not change the bounding box. Halfedge_handle h1 = Halfedge_handle_unconst(((const Point_location_base*)pl)->locate(src, lt1)); Halfedge_handle h2 = Halfedge_handle_unconst(((const Point_location_base*)pl)->locate(tgt, lt2)); // In principal, the result of a locate should not be an edge, // because the planar map does not accept proper intersections. // It is only possible in case a bounding box curve was hit. if (lt1 == EDGE || lt1 == UNBOUNDED_EDGE) { // the curve intersects the bounding box. Halfedge_handle h = h1, h2; bb->split_boundary_edge(h, h1, h2, src); // make sure the intersection point is in the map, // i.e. split the halfedge that contains its. lt1 = VERTEX; } if (lt2 == EDGE || lt2 == UNBOUNDED_EDGE) { Halfedge_handle h1, h = h2; bb->split_boundary_edge(h, h1, h2, tgt); // make sure the intersection point is in the map, // i.e. split the halfedge that contains its. lt2 = VERTEX; } if (lt1 == VERTEX && lt2 == VERTEX) return insert_at_vertices(cv, h1->target(), h2->target(), en); if (lt1 == VERTEX && lt2 != VERTEX) return insert_from_vertex(cv, h1->target(), true, en); if (lt1 != VERTEX && lt2 == VERTEX) return insert_from_vertex(cv, h2->target(), false, en)->twin(); if (lt1 == UNBOUNDED_FACE) return insert_in_face_interior(cv, unbounded_face(), en); if (lt1 == FACE) return insert_in_face_interior(cv, h1->face(), en); CGAL_assertion_msg(lt1 == VERTEX || lt1 == UNBOUNDED_FACE || lt1 == FACE, "Endpoints should not coinside with an edge. No intersections allowed."); return Halfedge_handle(); } //----------------------------------------------------------------------------- template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: split_edge (typename Planar_map_2< Dcel, Traits >::Halfedge_handle e, const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & c1, const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & c2, Change_notification * en ) { //CGAL_precondition(traits->point_equal(traits->curve_source(c2), // traits->curve_target(c1))); CGAL_precondition((traits->point_equal(traits->curve_source(c1), e->source()->point()) && traits->point_equal(traits->curve_target(c2), e->target()->point())) || (traits->point_equal(traits->curve_source(c1), e->target()->point()) && traits->point_equal(traits->curve_target(c2), e->source()->point()))); X_monotone_curve_2 cv(e->curve()); Halfedge_handle h = Topological_map::split_edge(e); if (traits->point_equal(traits->curve_source(c1),h->source()->point())) { h->set_curve(c1); h->twin()->set_curve(c1); h->next_halfedge()->set_curve(c2); h->next_halfedge()->twin()->set_curve(c2); h->target()->set_point(traits->curve_target(c1)); pl->split_edge(cv,h,h->next_halfedge(),c1,c2); if (en != NULL) en->split_edge(h, h->next_halfedge(), c1, c2); } else { h->set_curve(c2); h->twin()->set_curve(c2); h->next_halfedge()->set_curve(c1); h->next_halfedge()->twin()->set_curve(c1); h->target()->set_point(traits->curve_target(c1)); pl->split_edge(cv,h,h->next_halfedge(),c2,c1); if (en != NULL) en->split_edge(h, h->next_halfedge(), c2, c1); } //if (en != NULL) // en->split_edge(h, h->next_halfedge(), c1, c2); return h; } //----------------------------------------------------------------------------- template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Halfedge_handle Planar_map_2< Dcel, Traits >:: merge_edge (typename Planar_map_2< Dcel, Traits >::Halfedge_handle e1, typename Planar_map_2< Dcel, Traits >::Halfedge_handle e2, const typename Planar_map_2< Dcel, Traits >::X_monotone_curve_2 & cv, Change_notification * en) { //std::cout << "cv source " << traits->curve_source(cv) << std::endl; //std::cout << "cv target " << traits->curve_target(cv) << std::endl; //std::cout << "e1 source " << e1->source()->point() << std::endl; //std::cout << "e1 target " << e1->target()->point() << std::endl; //std::cout << "e2 source " << e2->source()->point() << std::endl; //std::cout << "e2 target " << e2->target()->point() << std::endl; //std::cout << "e1 source degree" << e1->source()->degree() << std::endl; //std::cout << "e1 target degree" << e1->target()->degree() << std::endl; //std::cout << "e2 source degree" << e2->source()->degree() << std::endl; //std::cout << "e2 target degree" << e2->target()->degree() << std::endl; CGAL_precondition((traits->point_equal(traits->curve_source(cv), e1->source()->point()) && traits->point_equal(traits->curve_target(cv), e2->target()->point())) || (traits->point_equal(traits->curve_source(cv), e1->source()->point()) && traits->point_equal(traits->curve_target(cv), e2->source()->point())) || (traits->point_equal(traits->curve_source(cv), e1->target()->point()) && traits->point_equal(traits->curve_target(cv), e2->source()->point())) || (traits->point_equal(traits->curve_source(cv), e1->target()->point()) && traits->point_equal(traits->curve_target(cv), e2->target()->point()))); // problematic: since we assume e1 will be the new merged halfedge // after merging. en->merge(e1,e2,cv); X_monotone_curve_2 c1(e1->curve()), c2(e2->curve()); Halfedge_handle h = Topological_map::merge_edge(e1,e2); h->set_curve(cv); h->twin()->set_curve(cv); //pl->merge_edge(c1,c2,h); //iddo - for arrangement pl->merge_edge(c1, c2, h, cv); // problematic: e2 does not exist anymore //if (en != NULL) // en->merge_edge(h, e1, e2, cv); return h; } //----------------------------------------------------------------------------- template < class Dcel, class Traits > typename Planar_map_2< Dcel, Traits >::Face_handle Planar_map_2< Dcel, Traits >:: remove_edge(typename Planar_map_2< Dcel, Traits >::Halfedge_handle e ) { // en->remove_edge(e); pl->remove_edge(e); //if a new hole can be created define geometrically the //halfedge (e or e->twin) that points at the new hole. //if the leftmost point in the path e...e->twin //is left of the leftmost point in the path e->twin ... e //then e->twin points at the hole created. if (e->face() == e->twin()->face() ) { Ccb_halfedge_circulator ccb_e=e->ccb() ; Ccb_halfedge_circulator ccb_t=e->twin()->ccb(); Point_2 e_left=e->target()->point(); Point_2 t_left=ccb_t->target()->point(); //find the leftmost point in the path from e to its twin Ccb_halfedge_circulator aux=ccb_e; do { if (traits->compare_x(aux->target()->point(),e_left)==SMALLER) { e_left=aux->target()->point(); } } while (++aux!=ccb_t); //find the leftmost point in the path from the twin to e aux=ccb_t; do { if (traits->compare_x(aux->target()->point(),t_left)==SMALLER) { t_left=aux->target()->point(); } } while (++aux!=ccb_e); //compare the two left points if (traits->compare_x(t_left,e_left) == SMALLER) //e points at hole return Topological_map::remove_edge(e); else return Topological_map::remove_edge(e->twin()); } else { return Topological_map::remove_edge(e); } } //----------------------------------------------------------------------------- template < class Dcel, class Traits > bool Planar_map_2< Dcel, Traits >:: point_is_in( const Point_2 & p, Halfedge_const_handle ne, const X_monotone_curve_2 & ncv) const { // count stores the number of curves that intersect the upward vertical // ray shot from p (except for a degenerate case which is explained in // the code) int count = 0; // 1. Find the first halfedge, whose curve is non-vertical, along // the ccb that includes input halfedge ne. Ccb_halfedge_const_circulator circ = ne; do { ++circ; } while ( circ != ne && traits->curve_is_vertical(circ->curve()) ); // If the whole ccb is vertical then there is no face, so point p // cannot be in it if ( circ == ne && traits->curve_is_vertical(ncv) ) return false; // 2. Go over all curves of the ccb and count those which are above p. Ccb_halfedge_const_circulator last = circ; do { // Put curve of current halfedge in circv. X_monotone_curve_2 circv; // If not on the new halfedge circ definitely has a curve if (circ != ne) { circv=circ->curve(); } // o/w, circ might not have a curve yet (e.g in arrangement) // so we take the input curve. else { circv=ncv; } // If query point is vertex point on the outer ccb if (traits->point_equal(circ->target()->point(), p)) return false; // If current curve is not vertical if ( ! traits->curve_is_vertical(circv)) { // If point is under current curve in the range (source,target] of it if (traits->point_in_x_range(circv,p) && (traits->curve_compare_y_at_x(p, circv) == SMALLER) && !(traits->point_equal_x(circ->source()->point(), p))) { // If p is exactly under a vertex of the ccb if (traits->point_equal_x(circ->target()->point(), p)) { // Put curve of next halfedge that is not vertical in nextcv Ccb_halfedge_const_circulator next = circ; ++next; X_monotone_curve_2 nextcv; if (next != ne) { nextcv = next->curve(); } else { nextcv = ncv; } if (traits->curve_is_vertical(nextcv)) { //advance to non-vertical edge while (traits->curve_is_vertical(nextcv)) { if (next!=ne) { nextcv=next->curve(); } else { nextcv=ncv; } ++next; } } // If nextcv is on the same side of the vertical line // from p as circv is if ((traits->point_is_right(circ->source()->point(), p) && traits->point_is_left(next->target()->point(), p)) || (traits->point_is_left(circ->source()->point(), p) && traits->point_is_right(next->target()->point(), p))) { // then we raise the count ++count; } } else { // o/w, point p is under the interior of the current curve // so we raise the count ++count; } } } // If current curve is not vertical } while (++circ != last); return (count%2 != 0); //if count is odd return true } //----------------------------------------------------------------------------- template < class Dcel, class Traits > Planar_map_2< Dcel, Traits >& Planar_map_2< Dcel, Traits >:: operator=(const Planar_map_2< Dcel, Traits >& pm) { if( this != &pm ){ clear(); assign(pm); Halfedge_iterator h_iter; for( h_iter = halfedges_begin(); h_iter != halfedges_end(); h_iter++, h_iter++) pl->insert(h_iter, h_iter->curve()); for( Vertex_iterator v_iter = vertices_begin(); v_iter != vertices_end(); v_iter++) bb->insert(v_iter->point()); for( h_iter = halfedges_begin(); h_iter != halfedges_end(); h_iter++, h_iter++) bb->insert(h_iter->curve()); } return *this; } //----------------------------------------------------------------------------- template < class Dcel, class Traits > void Planar_map_2< Dcel, Traits >:: clear() { pl->clear(); TPM::clear(); // Halfedge_iterator it=halfedges_begin(),prev=it,it_e=halfedges_end(); // while (it!=it_e) {++it;++it;remove_edge(prev);prev=it;} bb->clear(); } //----------------------------------------------------------------------------- template < class Dcel, class Traits > void Planar_map_2< Dcel, Traits >:: x_curve_container(X_monotone_curve_2_container &l) const { Halfedge_const_iterator it=halfedges_begin(),it_e=halfedges_end(); while (it!=it_e){ l.push_back(it->curve()); ++it; ++it; } } /*! * Given an intersection point, add all curves going through this * intersection point to the planar map. * * \param point_node a point to be handled * \param en the notification class. It's default value is NULL, which * implies no notification on insertion. */ template inline void Planar_map_2:: update_subdivision(Point_node& point_node, Change_notification *en) { for (Curve_node_iterator cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter) { // if the point is the source of the curve, we ignore it for now. // the curve will be handled when we get to its target if (traits->point_equal(traits->curve_source(cv_iter->get_curve()), point_node.get_point().point())) { continue; } Point_plus &source = cv_iter->get_point(); Halfedge_handle h; X_curve cv = cv_iter->get_curve(); // if the source file is already in the map... if (source.vertex() != Vertex_handle(NULL)){ //if the intersection pint is already int he map.... if (point_node.get_point().vertex() != Vertex_handle(NULL)) { h = insert_at_vertices(cv, cv_iter->get_point().vertex(), point_node.get_point().vertex(), en); } else { h = insert_from_vertex(cv, cv_iter->get_point().vertex(), en); } } else if (point_node.get_point().vertex() != Vertex_handle(NULL)) { h = insert_from_vertex(cv, point_node.get_point().vertex(), en); } else { h = insert_in_face_interior(cv, unbounded_face(), en); } // Update the vertex handle of each point, for future use if (traits->point_equal(h->source()->point(), cv_iter->get_point().point())) cv_iter->get_point().set_vertex(h->source()); else if (traits->point_equal(h->target()->point(), cv_iter->get_point().point())) cv_iter->get_point().set_vertex(h->target()); if (traits->point_equal(h->source()->point(), point_node.get_point().point())) point_node.get_point().set_vertex(h->source()); else if (traits->point_equal(h->target()->point(), point_node.get_point().point())) point_node.get_point().set_vertex(h->target()); } } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vector.h0000644000175000017500000007151211344301500030507 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vector.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_VECTOR_H #define CGAL_HALFEDGEDS_VECTOR_H 1 // Define this if HalfedgeDS_vector is based on CGAL internal vector. #define CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR 1 #include #include #include #include #include #include #include #ifdef CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR #include #else #include #endif CGAL_BEGIN_NAMESPACE template < class Traits_, class HalfedgeDSItems, class Alloc> class HalfedgeDS_vector_types { public: typedef HalfedgeDS_vector_types Self; typedef Traits_ Traits; typedef HalfedgeDSItems Items; typedef Alloc Allocator; typedef Alloc allocator_type; typedef typename Items::template Vertex_wrapper Vertex_wrapper; typedef typename Items::template Halfedge_wrapper Halfedge_wrapper; typedef typename Items::template Face_wrapper Face_wrapper; typedef typename Vertex_wrapper::Vertex Vertex; typedef typename Halfedge_wrapper::Halfedge Halfedge; typedef typename Face_wrapper::Face Face; typedef typename Allocator::template rebind< Vertex> Vertex_alloc_rebind; typedef typename Vertex_alloc_rebind::other Vertex_allocator; typedef typename Allocator::template rebind< Halfedge> Halfedge_alloc_rebind; typedef typename Halfedge_alloc_rebind::other Halfedge_allocator; typedef typename Allocator::template rebind< Face> Face_alloc_rebind; typedef typename Face_alloc_rebind::other Face_allocator; #ifdef CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR typedef CGALi::vector Vertex_vector; typedef typename Vertex_vector::iterator Vertex_I; typedef typename Vertex_vector::const_iterator Vertex_CI; typedef typename Vertex_vector::iterator Vertex_iterator; typedef typename Vertex_vector::const_iterator Vertex_const_iterator; typedef CGALi::vector Halfedge_vector; typedef typename Halfedge_vector::iterator Halfedge_I; typedef typename Halfedge_vector::const_iterator Halfedge_CI; typedef typename Halfedge_vector::iterator Halfedge_iterator; typedef typename Halfedge_vector::const_iterator Halfedge_const_iterator; typedef CGALi::vector Face_vector; typedef typename Face_vector::iterator Face_I; typedef typename Face_vector::const_iterator Face_CI; typedef typename Face_vector::iterator Face_iterator; typedef typename Face_vector::const_iterator Face_const_iterator; #else // CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR // typedef std::vector Vertex_vector; typedef typename Vertex_vector::iterator Vertex_I; typedef typename Vertex_vector::const_iterator Vertex_CI; typedef HalfedgeDS_iterator_adaptor Vertex_iterator; typedef HalfedgeDS_iterator_adaptor Vertex_const_iterator; typedef std::vector Halfedge_vector; typedef typename Halfedge_vector::iterator Halfedge_I; typedef typename Halfedge_vector::const_iterator Halfedge_CI; typedef HalfedgeDS_iterator_adaptor Halfedge_iterator; typedef HalfedgeDS_iterator_adaptor Halfedge_const_iterator; typedef std::vector Face_vector; typedef typename Face_vector::iterator Face_I; typedef typename Face_vector::const_iterator Face_CI; typedef HalfedgeDS_iterator_adaptor Face_iterator; typedef HalfedgeDS_iterator_adaptor Face_const_iterator; #endif // CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR // typedef Vertex_iterator Vertex_handle; typedef Vertex_const_iterator Vertex_const_handle; typedef Halfedge_iterator Halfedge_handle; typedef Halfedge_const_iterator Halfedge_const_handle; typedef Face_iterator Face_handle; typedef Face_const_iterator Face_const_handle; typedef typename Halfedge_vector::size_type size_type; typedef typename Halfedge_vector::difference_type difference_type; typedef std::random_access_iterator_tag iterator_category; static inline Vertex_handle vertex_handle( Vertex* v) { return Vertex_handle( Vertex_I(v)); } static inline Vertex_const_handle vertex_handle( const Vertex* v) { return Vertex_const_handle( Vertex_CI(v)); } static inline Halfedge_handle halfedge_handle( Halfedge* h) { return Halfedge_handle( Halfedge_I(h)); } static inline Halfedge_const_handle halfedge_handle( const Halfedge* h) { return Halfedge_const_handle( Halfedge_CI(h)); } static inline Face_handle face_handle( Face* f) { return Face_handle( Face_I(f)); } static inline Face_const_handle face_handle( const Face* f) { return Face_const_handle( Face_CI(f)); } }; #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class Traits_, class HalfedgeDSItems, class Alloc = CGAL_ALLOCATOR(int)> class HalfedgeDS_vector : public HalfedgeDS_vector_types { public: typedef HalfedgeDS_vector Self; #else struct HalfedgeDS_vector { template < class Traits_, class HalfedgeDSItems, class Alloc = CGAL_ALLOCATOR(int)> class HDS : public HalfedgeDS_vector_types { public: typedef HDS Self; #endif typedef HalfedgeDS_vector_types Types; typedef typename Types::Traits Traits; typedef typename Types::Items Items; typedef typename Types::Allocator Allocator; typedef typename Types::allocator_type allocator_type; typedef typename Types::Vertex Vertex; typedef typename Types::Halfedge Halfedge; typedef typename Types::Face Face; typedef typename Types::Vertex_vector Vertex_vector; typedef typename Types::Vertex_handle Vertex_handle; typedef typename Types::Vertex_const_handle Vertex_const_handle; typedef typename Types::Vertex_iterator Vertex_iterator; typedef typename Types::Vertex_const_iterator Vertex_const_iterator; typedef typename Types::Vertex_I Vertex_I; typedef typename Types::Vertex_CI Vertex_CI; typedef typename Types::Halfedge_vector Halfedge_vector; typedef typename Types::Halfedge_handle Halfedge_handle; typedef typename Types::Halfedge_const_handle Halfedge_const_handle; typedef typename Types::Halfedge_iterator Halfedge_iterator; typedef typename Types::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Types::Halfedge_I Halfedge_I; typedef typename Types::Halfedge_CI Halfedge_CI; typedef typename Types::Face_vector Face_vector; typedef typename Types::Face_handle Face_handle; typedef typename Types::Face_const_handle Face_const_handle; typedef typename Types::Face_iterator Face_iterator; typedef typename Types::Face_const_iterator Face_const_iterator; typedef typename Types::Face_I Face_I; typedef typename Types::Face_CI Face_CI; typedef typename Types::size_type size_type; typedef typename Types::difference_type difference_type; typedef typename Types::iterator_category iterator_category; typedef Tag_false Supports_removal; typedef typename Vertex::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename Halfedge::Supports_halfedge_prev Supports_halfedge_prev; typedef typename Halfedge::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename Halfedge::Supports_halfedge_face Supports_halfedge_face; typedef typename Face::Supports_face_halfedge Supports_face_halfedge; protected: typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Halfedge::Base_base HBase_base; typedef typename Face::Base FBase; Vertex_vector vertices; Halfedge_vector halfedges; Face_vector faces; size_type nb_border_halfedges; size_type nb_border_edges; Halfedge_iterator border_halfedges; #ifdef CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR Vertex_I get_v_iter( const Vertex_I& i) const { return i; } Vertex_CI get_v_iter( const Vertex_CI& i) const { return i; } Halfedge_I get_h_iter( const Halfedge_I& i) const { return i; } Halfedge_CI get_h_iter( const Halfedge_CI& i) const { return i; } Face_I get_f_iter( const Face_I& i) const { return i; } Face_CI get_f_iter( const Face_CI& i) const { return i; } #else // CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR // Vertex_I get_v_iter( const Vertex_iterator& i) const { return i.iterator(); } Vertex_CI get_v_iter( const Vertex_const_iterator& i) const { return i.iterator(); } Halfedge_I get_h_iter( const Halfedge_iterator& i) const { return i.iterator(); } Halfedge_CI get_h_iter( const Halfedge_const_iterator& i) const { return i.iterator(); } Face_I get_f_iter( const Face_iterator& i) const { return i.iterator(); } Face_CI get_f_iter( const Face_const_iterator& i) const { return i.iterator(); } #endif // CGAL__HALFEDGEDS_USE_INTERNAL_VECTOR // // CREATION private: #define CGAL__V_UPDATE(v) (((v) == Vertex_handle()) ? (v) : \ (v_new + ( Vertex_CI (get_v_iter(v)) - v_old))) #define CGAL__H_UPDATE(h) (((h) == Halfedge_handle()) ? (h) : \ (h_new + ( Halfedge_CI (get_h_iter(h)) - h_old))) #define CGAL__F_UPDATE(f) (((f) == Face_handle()) ? (f) : \ (f_new + ( Face_CI (get_f_iter(f)) - f_old))) void pointer_update( Vertex_CI v_old, Halfedge_CI h_old, Face_CI f_old) { // Update own pointers assuming that they lived previously // in a halfedge data structure with vector starting addresses // as given as parameters v_old, h_old, f_old. HalfedgeDS_items_decorator D; Vertex_iterator v_new = vertices.begin(); Halfedge_iterator h_new = halfedges.begin(); Face_iterator f_new = faces.begin(); for (Halfedge_iterator h = halfedges_begin();h != halfedges_end();++h){ h->HBase::set_next( CGAL__H_UPDATE( h->next())); h->HBase_base::set_opposite( CGAL__H_UPDATE( h->opposite())); D.set_prev( h, CGAL__H_UPDATE( D.get_prev(h))); D.set_vertex( h, CGAL__V_UPDATE( D.get_vertex(h))); D.set_face( h, CGAL__F_UPDATE( D.get_face(h))); } border_halfedges = CGAL__H_UPDATE( border_halfedges); if (check_tag( Supports_vertex_halfedge())) { for (Vertex_iterator v = vertices_begin();v != vertices_end();++v){ D.set_vertex_halfedge(v, CGAL__H_UPDATE( D.get_vertex_halfedge(v))); } } if (check_tag( Supports_face_halfedge())) { for ( Face_iterator f = faces_begin(); f != faces_end(); ++f) { D.set_face_halfedge(f,CGAL__H_UPDATE( D.get_face_halfedge(f))); } } } #undef CGAL__V_UPDATE #undef CGAL__H_UPDATE #undef CGAL__F_UPDATE public: #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM HalfedgeDS_vector() : nb_border_halfedges(0), nb_border_edges(0) {} // empty halfedge data structure. HalfedgeDS_vector( size_type v, size_type h, size_type f) : nb_border_halfedges(0), nb_border_edges(0) { // halfedge data structure with storage reserved for v vertices, h // halfedges, and f faces. The reservation sizes are a hint for // optimizing storage allocation. They are not used here. vertices.reserve(v); halfedges.reserve(h); faces.reserve(f); } HalfedgeDS_vector( const Self& hds) #else HDS() : nb_border_halfedges(0), nb_border_edges(0) {} HDS( size_type v, size_type h, size_type f) : nb_border_halfedges(0), nb_border_edges(0) { vertices.reserve(v); halfedges.reserve(h); faces.reserve(f); } HDS( const Self& hds) #endif // CGAL_CFG_NO_TMPL_IN_TMPL_PARAM // : vertices( hds.vertices), halfedges( hds.halfedges), faces( hds.faces), nb_border_halfedges( hds.nb_border_halfedges), nb_border_edges( hds.nb_border_edges), border_halfedges( hds.border_halfedges) { pointer_update( hds.vertices.begin(), hds.halfedges.begin(), hds.faces.begin()); } Self& operator=( const Self& hds) { if ( this != &hds) { clear(); vertices = hds.vertices; halfedges = hds.halfedges; faces = hds.faces; nb_border_halfedges = hds.nb_border_halfedges; nb_border_edges = hds.nb_border_edges; border_halfedges = hds.border_halfedges; pointer_update( hds.vertices.begin(), hds.halfedges.begin(), hds.faces.begin()); } return *this; } void reserve( size_type v, size_type h, size_type f) { // reserve storage for v vertices, h halfedges, and f faces. The // reservation sizes are a hint for optimizing storage allocation. // If the `capacity' is already greater than the requested size // nothing happens. If the `capacity' changes all iterators and // circulators invalidates. Function is void here. if ( (check_tag( Supports_halfedge_vertex()) && v > capacity_of_vertices()) || h > capacity_of_halfedges() || (check_tag( Supports_halfedge_face()) && f > capacity_of_faces())) { Vertex_CI v_old = vertices.begin(); Halfedge_CI h_old = halfedges.begin(); Face_CI f_old = faces.begin(); if ( check_tag( Supports_halfedge_vertex())) vertices.reserve(v); halfedges.reserve(h); if ( check_tag( Supports_halfedge_face())) faces.reserve(f); pointer_update( v_old, h_old, f_old); } } // Access Member Functions allocator_type get_allocator() const { return allocator_type(); } size_type size_of_vertices() const { return vertices.size();} size_type size_of_halfedges() const { return halfedges.size();} // number of all halfedges (including border halfedges). size_type size_of_faces() const { return faces.size();} size_type capacity_of_vertices() const { return vertices.capacity();} size_type capacity_of_halfedges() const { return halfedges.capacity();} size_type capacity_of_faces() const { return faces.capacity();} std::size_t bytes() const { return sizeof(Self) + vertices.size() * sizeof( Vertex) + halfedges.size() * sizeof( Halfedge) + faces.size() * sizeof( Face); } std::size_t bytes_reserved() const { return sizeof(Self) + vertices.capacity() * sizeof( Vertex) + halfedges.capacity() * sizeof( Halfedge) + faces.capacity() * sizeof( Face); } Vertex_iterator vertices_begin() { return vertices.begin();} Vertex_iterator vertices_end() { return vertices.end();} Halfedge_iterator halfedges_begin() { return halfedges.begin();} Halfedge_iterator halfedges_end() { return halfedges.end();} Face_iterator faces_begin() { return faces.begin();} Face_iterator faces_end() { return faces.end();} // The constant iterators and circulators. Vertex_const_iterator vertices_begin() const{ return vertices.begin();} Vertex_const_iterator vertices_end() const{ return vertices.end();} Halfedge_const_iterator halfedges_begin() const{ return halfedges.begin();} Halfedge_const_iterator halfedges_end() const{ return halfedges.end();} Face_const_iterator faces_begin() const{ return faces.begin();} Face_const_iterator faces_end() const{ return faces.end();} // Insertion // // The following operations simply allocate a new element of that type. // Halfedges are always allocated in pairs of opposite halfedges. The // opposite pointers are automatically set. Vertex_handle vertices_push_back( const Vertex& v) { CGAL_precondition( 1+size_of_vertices() <= capacity_of_vertices()); vertices.push_back(v); Vertex_handle vv = vertices.end(); return --vv; } Halfedge_handle edges_push_back( const Halfedge& h, const Halfedge& g) { // creates a new pair of opposite border halfedges. CGAL_precondition( 1 + size_of_halfedges() < capacity_of_halfedges()); halfedges.push_back(h); Halfedge_handle hh = halfedges.end(); --hh; halfedges.push_back(g); Halfedge_handle gg = halfedges.end(); --gg; CGAL_assertion( hh + 1 == gg); CGAL_assertion( (char*)(&*gg) - (char*)(&*hh) == sizeof( Halfedge)); hh->HBase_base::set_opposite(gg); gg->HBase_base::set_opposite(hh); return hh; } Halfedge_handle edges_push_back( const Halfedge& h) { CGAL_precondition( h.opposite() != Halfedge_const_handle()); return edges_push_back( h, *(h.opposite())); } Face_handle faces_push_back( const Face& f) { CGAL_precondition( 1+size_of_faces() <= capacity_of_faces()); faces.push_back(f); Face_handle ff = faces.end(); return --ff; } // Removal // // The following operations erase an element referenced by a handle. // Halfedges are always deallocated in pairs of opposite halfedges. Erase // of single elements is optional. The deletion of all is mandatory. void vertices_pop_back() { vertices.pop_back(); } void edges_pop_back() { CGAL_precondition(( halfedges_end()-1)->opposite() == ( halfedges_end()-2)); halfedges.pop_back(); halfedges.pop_back(); } void faces_pop_back() { faces.pop_back(); } void vertices_clear() { vertices.erase( vertices.begin(), vertices.end());} void edges_clear() { halfedges.erase( halfedges.begin(), halfedges.end()); nb_border_halfedges = 0; nb_border_edges = 0; border_halfedges = Halfedge_handle(); } void faces_clear() { faces.erase( faces.begin(), faces.end()); } void clear() { vertices_clear(); edges_clear(); faces_clear(); } // Special Operations on Polyhedral Surfaces protected: // Update operation used in pointer_update(...). void update_opposite( Halfedge_I h) { Halfedge_I g = h + 1; h->HBase_base::set_opposite(g); g->HBase_base::set_opposite(h); } // Operations with Border Halfedges public: size_type size_of_border_halfedges() const { return nb_border_halfedges;} // number of border halfedges. An edge with no incident face // counts as two border halfedges. Precondition: `normalize_border()' // has been called and no halfedge insertion or removal and no // change in border status of the halfedges have occured since // then. size_type size_of_border_edges() const { return nb_border_edges;} // number of border edges. If `size_of_border_edges() == // size_of_border_halfedges()' all border edges are incident to a // face on one side and to a hole on the other side. // Precondition: `normalize_border()' has been called and no // halfedge insertion or removal and no change in border status of // the halfedges have occured since then. Halfedge_iterator border_halfedges_begin() { // halfedge iterator starting with the border edges. The range [ // `halfedges_begin(), border_halfedges_begin()') denotes all // non-border edges. The range [`border_halfedges_begin(), // halfedges_end()') denotes all border edges. Precondition: // `normalize_border()' has been called and no halfedge insertion // or removal and no change in border status of the halfedges have // occured since then. return border_halfedges; } Halfedge_const_iterator border_halfedges_begin() const { return border_halfedges; } void normalize_border() { // sorts halfedges such that the non-border edges precedes the // border edges. For each border edge that is incident to a face // the halfedge iterator will reference the halfedge incident to // the face right before the halfedge incident to the hole. nb_border_halfedges = 0; nb_border_edges = 0; border_halfedges = halfedges_end(); // Lets run one partition step over the array of halfedges. // First find a pivot -- that means a border edge. Halfedge_I ll = halfedges.begin(); while ( ll != halfedges.end() && (! ll->is_border()) && (! ll->opposite()->is_border() )) ++ ++ll; if ( ll == halfedges.end()) // Done. No border edges found. return; // An array of pointers to update the changed halfedge pointers. typedef typename Allocator::template rebind< Halfedge_I> HI_alloc_rebind; typedef typename HI_alloc_rebind::other HI_allocator; typedef std::vector HVector; typedef typename HVector::iterator Hiterator; HVector hvector; // Initialize it. hvector.reserve( halfedges.size()); for ( Halfedge_I i = halfedges.begin(); i != halfedges.end(); ++i) { hvector.push_back(i); } Hiterator llhv = hvector.begin() + (ll-halfedges.begin()); // Start with the partitioning. Halfedge_I rr = halfedges.end(); -- --rr; Hiterator rrhv = hvector.end(); -- --rrhv; // The comments proove the invariant of the partitioning step. // Note that + 1 or - 1 denotes plus one edge or minus one edge, // so they mean actually + 2 and - 2. // Pivot is in *ll // Elements in [rr+1..end) >= pivot (border) // Elements in [begin..ll) < pivot (non border) while (ll < rr) { // Pivot is in *ll, ll <= rr. while ( rr > ll && (rr->is_border() || rr->opposite()->is_border())) { if ( ! rr->opposite()->is_border()) { CGAL_assertion( rr + 1 == get_h_iter(rr->opposite())); std::swap( *rr, *(rr+1)); update_opposite( rr); std::swap( *rrhv, *(rrhv+1)); } -- --rr; -- --rrhv; } // Elements in [rr+1..end) >= pivot (border) // *rr <= pivot, ll <= rr. CGAL_assertion( rr + 1 == get_h_iter( rr->opposite())); CGAL_assertion( ll + 1 == get_h_iter( ll->opposite())); std::swap( *(ll+1), *(rr+1)); std::swap( *ll, *rr); update_opposite( ll); update_opposite( rr); std::swap( *(llhv+1), *(rrhv+1)); std::swap( *llhv, *rrhv); // Elements in [begin..ll) < pivot // Pivot is in *rr, ll <= rr. while ( !ll->is_border() && ! ll->opposite()->is_border()) { ++ ++ll; ++ ++llhv; } // Elements in [begin..ll) < pivot // *ll >= pivot // ll <= rr (since *rr is pivot.) CGAL_assertion( ll <= rr); CGAL_assertion( llhv <= rrhv); CGAL_assertion( rr + 1 == get_h_iter( rr->opposite())); CGAL_assertion( ll + 1 == get_h_iter( ll->opposite())); std::swap( *(ll+1), *(rr+1)); std::swap( *ll, *rr); update_opposite( ll); update_opposite( rr); std::swap( *(llhv+1), *(rrhv+1)); std::swap( *llhv, *rrhv); if ( ! rr->opposite()->is_border()) { CGAL_assertion( rr + 1 == get_h_iter( rr->opposite())); std::swap( *rr, *(rr+1)); update_opposite( rr); std::swap( *rrhv, *(rrhv+1)); } -- --rr; -- --rrhv; // Elements in [rr+1..end) >= pivot // Pivot is in *ll } CGAL_assertion( llhv >= rrhv); // rr + 1 >= ll >= rr // Elements in [rr+1..end) >= pivot // Elemente in [begin..ll) < pivot // Pivot is in a[ll] if ( ll == rr) { // Check for the possibly missed swap. if ( rr->is_border() && ! rr->opposite()->is_border()) { CGAL_assertion( rr + 1 == get_h_iter (rr->opposite())); std::swap( *rr, *(rr+1)); update_opposite( rr); std::swap( *rrhv, *(rrhv+1)); } } CGAL_assertion( ll->opposite()->is_border()); CGAL_assertion( ll == halfedges.begin() || ! (ll-2)->is_border()); CGAL_assertion( ll == halfedges.begin() || ! (ll-1)->is_border()); border_halfedges = ll; nb_border_edges = (halfedges.end() - ll) / 2; nb_border_halfedges = 0; HVector inv_vector( halfedges.size()); // Initialize inverse index. for ( Hiterator k = hvector.begin(); k != hvector.end(); ++k){ inv_vector[*k - halfedges.begin()] = halfedges.begin() + (k - hvector.begin()); } // Update halfedge pointers. HalfedgeDS_items_decorator D; for (Halfedge_iterator h = halfedges_begin();h != halfedges_end();++h){ h->HBase::set_next( inv_vector[ h->next() - halfedges_begin()]); D.set_vertex_halfedge(h); if ( D.get_prev( h) == Halfedge_iterator()) D.set_prev( h, Halfedge_iterator()); else D.set_prev( h, inv_vector[ D.get_prev(h) - halfedges_begin()]); if ( h->is_border()) nb_border_halfedges++; else D.set_face_halfedge(h); } } }; #ifdef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM }; #endif CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_VECTOR_H // // EOF // ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_face_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_face_base_0000644000175000017500000000445611344301500031270 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_face_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_ALPHA_SHAPE_FACE_BASE_2_H #define CGAL_ALPHA_SHAPE_FACE_BASE_2_H #include CGAL_BEGIN_NAMESPACE template < class Gt, class Fb = Triangulation_face_base_2 > class Alpha_shape_face_base_2 : public Fb { typedef typename Fb::Triangulation_data_structure TDS; public: typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Face_handle Face_handle; typedef typename Gt::FT Coord_type; typedef Triple Interval_3; template < typename TDS2 > struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Fb2; typedef Alpha_shape_face_base_2 Other; }; private: Interval_3 vec_edge[3]; Coord_type A; public: Alpha_shape_face_base_2() : Fb() {} Alpha_shape_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Fb(v0, v1, v2) {} Alpha_shape_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Fb(v0, v1, v2, n0, n1, n2) {} const Coord_type & get_alpha() const { return A; } void set_alpha(const Coord_type & AA) { A = AA; } const Interval_3 & get_ranges(int i) const { return vec_edge[i]; } void set_ranges(int i, const Interval_3& Inter) { vec_edge[i]=Inter; } }; CGAL_END_NAMESPACE #endif //ALPHA_SHAPE_FACE_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_3.h0000644000175000017500000024047411344301501030247 0ustar debiandebian// Copyright (c) 1999-2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud // Sylvain Pion #ifndef CGAL_TRIANGULATION_3_H #define CGAL_TRIANGULATION_3_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class GT, class Tds > class Triangulation_3; template < class GT, class Tds > std::istream& operator>> (std::istream& is, Triangulation_3 &tr); template < class GT, class Tds > bool operator==(const Triangulation_3 &t1, const Triangulation_3 &t2); template < class GT, class Tds = Triangulation_data_structure_3 < Triangulation_vertex_base_3, Triangulation_cell_base_3 > > class Triangulation_3 :public Triangulation_utils_3 { friend std::istream& operator>> <> (std::istream& is, Triangulation_3 &tr); friend bool operator== <> (const Triangulation_3 &t1, const Triangulation_3 &t2); typedef Triangulation_3 Self; public: typedef Tds Triangulation_data_structure; typedef GT Geom_traits; typedef typename GT::Point_3 Point; typedef typename GT::Segment_3 Segment; typedef typename GT::Triangle_3 Triangle; typedef typename GT::Tetrahedron_3 Tetrahedron; typedef typename Tds::Vertex Vertex; typedef typename Tds::Cell Cell; typedef typename Tds::Facet Facet; typedef typename Tds::Edge Edge; typedef typename Tds::size_type size_type; typedef typename Tds::difference_type difference_type; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Cell_handle Cell_handle; typedef typename Tds::Cell_circulator Cell_circulator; typedef typename Tds::Facet_circulator Facet_circulator; typedef typename Tds::Cell_iterator Cell_iterator; typedef typename Tds::Facet_iterator Facet_iterator; typedef typename Tds::Edge_iterator Edge_iterator; typedef typename Tds::Vertex_iterator Vertex_iterator; typedef Cell_iterator All_cells_iterator; typedef Facet_iterator All_facets_iterator; typedef Edge_iterator All_edges_iterator; typedef Vertex_iterator All_vertices_iterator; private: // This class is used to generate the Finite_*_iterators. class Infinite_tester { const Self *t; public: Infinite_tester() {} Infinite_tester(const Self *tr) : t(tr) {} bool operator()(const Vertex_iterator & v) const { return t->is_infinite(v); } bool operator()(const Cell_iterator & c) const { return t->is_infinite(c); } bool operator()(const Edge_iterator & e) const { return t->is_infinite(*e); } bool operator()(const Facet_iterator & f) const { return t->is_infinite(*f); } }; public: // We derive in order to add a conversion to handle. class Finite_cells_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef Finite_cells_iterator Self; public: Finite_cells_iterator() : Base() {} Finite_cells_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator Cell_handle() const { return Base::base(); } }; // We derive in order to add a conversion to handle. class Finite_vertices_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef Finite_vertices_iterator Self; public: Finite_vertices_iterator() : Base() {} Finite_vertices_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator Vertex_handle() const { return Base::base(); } }; typedef Filter_iterator Finite_edges_iterator; typedef Filter_iterator Finite_facets_iterator; private: // Auxiliary iterators for convenience // do not use default template argument to please VC++ typedef Project_point Proj_point; public: typedef Iterator_project Point_iterator; typedef Point value_type; // to have a back_inserter typedef const value_type& const_reference; //Tag to distinguish triangulations with weighted_points typedef Tag_false Weighted_tag; enum Locate_type { VERTEX=0, EDGE, //1 FACET, //2 CELL, //3 OUTSIDE_CONVEX_HULL, //4 OUTSIDE_AFFINE_HULL };//5 protected: Tds _tds; GT _gt; Vertex_handle infinite; //infinite vertex mutable Random rng; Comparison_result compare_xyz(const Point &p, const Point &q) const { return geom_traits().compare_xyz_3_object()(p, q); } bool equal(const Point &p, const Point &q) const { return compare_xyz(p, q) == EQUAL; } Orientation orientation(const Point &p, const Point &q, const Point &r, const Point &s) const { return geom_traits().orientation_3_object()(p, q, r, s); } bool coplanar(const Point &p, const Point &q, const Point &r, const Point &s) const { return orientation(p, q, r, s) == COPLANAR; } Orientation coplanar_orientation(const Point &p, const Point &q, const Point &r) const { return geom_traits().coplanar_orientation_3_object()(p, q, r); } bool collinear(const Point &p, const Point &q, const Point &r) const { return coplanar_orientation(p, q, r) == COLLINEAR; } Segment construct_segment(const Point &p, const Point &q) const { return geom_traits().construct_segment_3_object()(p, q); } Triangle construct_triangle(const Point &p, const Point &q, const Point &r) const { return geom_traits().construct_triangle_3_object()(p, q, r); } Tetrahedron construct_tetrahedron(const Point &p, const Point &q, const Point &r, const Point &s) const { return geom_traits().construct_tetrahedron_3_object()(p, q, r, s); } enum COLLINEAR_POSITION {BEFORE, SOURCE, MIDDLE, TARGET, AFTER}; COLLINEAR_POSITION collinear_position(const Point &s, const Point &p, const Point &t) const // (s,t) defines a line, p is on that line. // Depending on the position of p wrt s and t, returns : // --------------- s ---------------- t -------------- // BEFORE SOURCE MIDDLE TARGET AFTER { CGAL_triangulation_precondition(!equal(s, t)); CGAL_triangulation_precondition(collinear(s, p, t)); Comparison_result ps = compare_xyz(p, s); if (ps == EQUAL) return SOURCE; Comparison_result st = compare_xyz(s, t); if (ps == st) return BEFORE; Comparison_result pt = compare_xyz(p, t); if (pt == EQUAL) return TARGET; if (pt == st) return MIDDLE; return AFTER; } void init_tds() { infinite = _tds.insert_increase_dimension(); } bool test_dim_down(Vertex_handle v) const; public: // CONSTRUCTORS Triangulation_3(const GT & gt = GT()) : _tds(), _gt(gt) { init_tds(); } // copy constructor duplicates vertices and cells Triangulation_3(const Triangulation_3 & tr) : _gt(tr._gt) { infinite = _tds.copy_tds(tr._tds, tr.infinite); CGAL_triangulation_expensive_postcondition(*this == tr); } template < typename InputIterator > Triangulation_3(InputIterator first, InputIterator last, const GT & gt = GT()) : _gt(gt) { init_tds(); insert(first, last); } void clear() { _tds.clear(); init_tds(); } Triangulation_3 & operator=(const Triangulation_3 & tr) { Triangulation_3 tmp = tr; swap(tmp); return *this; } // HELPING FUNCTIONS void swap(Triangulation_3 &tr) { std::swap(tr._gt, _gt); std::swap(tr.infinite, infinite); _tds.swap(tr._tds); } //ACCESS FUNCTIONS const GT & geom_traits() const { return _gt;} const Tds & tds() const { return _tds;} Tds & tds() { return _tds;} int dimension() const { return _tds.dimension();} size_type number_of_finite_cells() const; size_type number_of_cells() const; size_type number_of_finite_facets() const; size_type number_of_facets() const; size_type number_of_finite_edges() const; size_type number_of_edges() const; size_type number_of_vertices() const // number of finite vertices {return _tds.number_of_vertices()-1;} Vertex_handle infinite_vertex() const { return infinite; } Cell_handle infinite_cell() const { CGAL_triangulation_assertion(infinite_vertex()->cell()-> has_vertex(infinite_vertex())); return infinite_vertex()->cell(); } // GEOMETRIC ACCESS FUNCTIONS Tetrahedron tetrahedron(const Cell_handle c) const { CGAL_triangulation_precondition( dimension() == 3 ); CGAL_triangulation_precondition( ! is_infinite(c) ); return construct_tetrahedron(c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point()); } Triangle triangle(const Cell_handle c, int i) const; Triangle triangle(const Facet & f) const { return triangle(f.first, f.second); } Segment segment(const Cell_handle c, int i, int j) const; Segment segment(const Edge & e) const { return segment(e.first,e.second,e.third); } // TEST IF INFINITE FEATURES bool is_infinite(const Vertex_handle v) const { return v == infinite_vertex(); } bool is_infinite(const Cell_handle c) const { CGAL_triangulation_precondition( dimension() == 3 ); return c->has_vertex(infinite_vertex()); } bool is_infinite(const Cell_handle c, int i) const; bool is_infinite(const Facet & f) const { return is_infinite(f.first,f.second); } bool is_infinite(const Cell_handle c, int i, int j) const; bool is_infinite(const Edge & e) const { return is_infinite(e.first,e.second,e.third); } //QUERIES bool is_vertex(const Point & p, Vertex_handle & v) const; bool is_vertex(Vertex_handle v) const; bool is_edge(Vertex_handle u, Vertex_handle v, Cell_handle & c, int & i, int & j) const; bool is_facet(Vertex_handle u, Vertex_handle v, Vertex_handle w, Cell_handle & c, int & i, int & j, int & k) const; bool is_cell(Cell_handle c) const; bool is_cell(Vertex_handle u, Vertex_handle v, Vertex_handle w, Vertex_handle t, Cell_handle & c, int & i, int & j, int & k, int & l) const; bool is_cell(Vertex_handle u, Vertex_handle v, Vertex_handle w, Vertex_handle t, Cell_handle & c) const; bool has_vertex(const Facet & f, Vertex_handle v, int & j) const; bool has_vertex(Cell_handle c, int i, Vertex_handle v, int & j) const; bool has_vertex(const Facet & f, Vertex_handle v) const; bool has_vertex(Cell_handle c, int i, Vertex_handle v) const; bool are_equal(Cell_handle c, int i, Cell_handle n, int j) const; bool are_equal(const Facet & f, const Facet & g) const; bool are_equal(const Facet & f, Cell_handle n, int j) const; Cell_handle locate(const Point & p, Locate_type & lt, int & li, int & lj, Cell_handle start = Cell_handle()) const; Cell_handle locate(const Point & p, Cell_handle start = Cell_handle()) const { Locate_type lt; int li, lj; return locate( p, lt, li, lj, start); } // PREDICATES ON POINTS ``TEMPLATED'' by the geom traits Bounded_side side_of_tetrahedron(const Point & p, const Point & p0, const Point & p1, const Point & p2, const Point & p3, Locate_type & lt, int & i, int & j ) const; Bounded_side side_of_cell(const Point & p, Cell_handle c, Locate_type & lt, int & i, int & j) const; Bounded_side side_of_triangle(const Point & p, const Point & p0, const Point & p1, const Point & p2, Locate_type & lt, int & i, int & j ) const; Bounded_side side_of_facet(const Point & p, Cell_handle c, Locate_type & lt, int & li, int & lj) const; Bounded_side side_of_facet(const Point & p, const Facet & f, Locate_type & lt, int & li, int & lj) const { CGAL_triangulation_precondition( f.second == 3 ); return side_of_facet(p, f.first, lt, li, lj); } Bounded_side side_of_segment(const Point & p, const Point & p0, const Point & p1, Locate_type & lt, int & i ) const; Bounded_side side_of_edge(const Point & p, Cell_handle c, Locate_type & lt, int & li) const; Bounded_side side_of_edge(const Point & p, const Edge & e, Locate_type & lt, int & li) const { CGAL_triangulation_precondition( e.second == 0 ); CGAL_triangulation_precondition( e.third == 1 ); return side_of_edge(p, e.first, lt, li); } // MODIFIERS bool flip(const Facet &f) // returns false if the facet is not flippable // true other wise and // flips facet i of cell c // c will be replaced by one of the new cells { return flip( f.first, f.second); } bool flip(Cell_handle c, int i); void flip_flippable(const Facet &f) { flip_flippable( f.first, f.second); } void flip_flippable(Cell_handle c, int i); bool flip(const Edge &e) // returns false if the edge is not flippable // true otherwise and // flips edge i,j of cell c // c will be deleted { return flip( e.first, e.second, e.third ); } bool flip(Cell_handle c, int i, int j); void flip_flippable(const Edge &e) { flip_flippable( e.first, e.second, e.third ); } void flip_flippable(Cell_handle c, int i, int j); //INSERTION Vertex_handle insert(const Point & p, Cell_handle start = Cell_handle()); Vertex_handle insert(const Point & p, Locate_type lt, Cell_handle c, int li, int lj); template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } Vertex_handle insert_in_cell(const Point & p, Cell_handle c); Vertex_handle insert_in_facet(const Point & p, Cell_handle c, int i); Vertex_handle insert_in_facet(const Point & p, const Facet & f) { return insert_in_facet(p, f.first, f.second); } Vertex_handle insert_in_edge(const Point & p, Cell_handle c, int i, int j); Vertex_handle insert_in_edge(const Point & p, const Edge & e) { return insert_in_edge(p, e.first, e.second, e.third); } Vertex_handle insert_outside_convex_hull(const Point & p, Cell_handle c); Vertex_handle insert_outside_affine_hull(const Point & p); template Vertex_handle insert_in_hole(const Point & p, CellIt cell_begin, CellIt cell_end, Cell_handle begin, int i) { // Some geometric preconditions should be tested... Vertex_handle v = _tds.insert_in_hole(cell_begin, cell_end, begin, i); v->set_point(p); return v; } protected: // - c is the current cell, which must be in conflict. // - tester is the function object that tests if a cell is in conflict. // // in_conflict_flag value : // 0 -> unknown // 1 -> in conflict // 2 -> not in conflict (== on boundary) template Triple find_conflicts_2(Cell_handle c, const Conflict_test &tester, Triple it) const { CGAL_triangulation_precondition( dimension()==2 ); CGAL_triangulation_precondition( tester(c) ); c->set_in_conflict_flag(1); *it.second++ = c; for (int i=0; i<3; ++i) { Cell_handle test = c->neighbor(i); if (test->get_in_conflict_flag() == 1) { if (c < test) *it.third++ = Facet(c, i); // Internal facet. continue; // test was already in conflict. } if (test->get_in_conflict_flag() == 0) { if (tester(test)) { if (c < test) *it.third++ = Facet(c, i); // Internal facet. it = find_conflicts_2(test, tester, it); continue; } test->set_in_conflict_flag(2); // test is on the boundary. } *it.first++ = Facet(c, i); } return it; } // Note: the code duplication between _2 and _3 should be avoided one day. template Triple find_conflicts_3(Cell_handle c, const Conflict_test &tester, Triple it) const { CGAL_triangulation_precondition( dimension()==3 ); CGAL_triangulation_precondition( tester(c) ); c->set_in_conflict_flag(1); *it.second++ = c; for (int i=0; i<4; ++i) { Cell_handle test = c->neighbor(i); if (test->get_in_conflict_flag() == 1) { // test was already in conflict. if (c < test) *it.third++ = Facet(c, i); // Internal facet. continue; } if (test->get_in_conflict_flag() == 0) { if (tester(test)) { if (c < test) *it.third++ = Facet(c, i); // Internal facet. it = find_conflicts_3(test, tester, it); continue; } test->set_in_conflict_flag(2); // test is on the boundary. } *it.first++ = Facet(c, i); } return it; } // This one takes a function object to recursively determine the cells in // conflict, then calls _tds._insert_in_hole(). template < class Conflict_test > Vertex_handle insert_conflict_2(Cell_handle c, const Conflict_test &tester) { CGAL_triangulation_precondition( dimension() == 2 ); CGAL_triangulation_precondition( c != Cell_handle() ); CGAL_triangulation_precondition( tester(c) ); std::vector cells; cells.reserve(32); Facet facet; // Find the cells in conflict find_conflicts_2(c, tester, make_triple(Oneset_iterator(facet), std::back_inserter(cells), Emptyset_iterator())); // Create the new cells and delete the old. return _tds._insert_in_hole(cells.begin(), cells.end(), facet.first, facet.second); } // This one takes a function object to recursively determine the cells in // conflict, then calls _tds._insert_in_hole(). template < class Conflict_test > Vertex_handle insert_conflict_3(Cell_handle c, const Conflict_test &tester) { CGAL_triangulation_precondition( dimension() == 3 ); CGAL_triangulation_precondition( c != Cell_handle() ); CGAL_triangulation_precondition( tester(c) ); std::vector cells; cells.reserve(32); Facet facet; // Find the cells in conflict find_conflicts_3(c, tester, make_triple(Oneset_iterator(facet), std::back_inserter(cells), Emptyset_iterator())); // Create the new cells and delete the old. return _tds._insert_in_hole(cells.begin(), cells.end(), facet.first, facet.second); } private: // Here are the conflit tester function objects passed to // insert_conflict_[23]() by insert_outside_convex_hull(). class Conflict_tester_outside_convex_hull_3 { const Point &p; const Self *t; public: Conflict_tester_outside_convex_hull_3(const Point &pt, const Self *tr) : p(pt), t(tr) {} bool operator()(const Cell_handle c) const { Locate_type loc; int i, j; return t->side_of_cell( p, c, loc, i, j ) == ON_BOUNDED_SIDE; } }; class Conflict_tester_outside_convex_hull_2 { const Point &p; const Self *t; public: Conflict_tester_outside_convex_hull_2(const Point &pt, const Self *tr) : p(pt), t(tr) {} bool operator()(const Cell_handle c) const { Locate_type loc; int i, j; return t->side_of_facet( p, c, loc, i, j ) == ON_BOUNDED_SIDE; } }; // They access "Self", so need to be friend. friend class Conflict_tester_outside_convex_hull_3; friend class Conflict_tester_outside_convex_hull_2; friend class Infinite_tester; friend class Finite_vertices_iterator; friend class Finite_cells_iterator; public: //TRAVERSING : ITERATORS AND CIRCULATORS Finite_cells_iterator finite_cells_begin() const { if ( dimension() < 3 ) return finite_cells_end(); return filter_iterator(cells_end(), Infinite_tester(this), cells_begin()); } Finite_cells_iterator finite_cells_end() const { return filter_iterator(cells_end(), Infinite_tester(this)); } Cell_iterator cells_begin() const { return _tds.cells_begin(); } Cell_iterator cells_end() const { return _tds.cells_end(); } All_cells_iterator all_cells_begin() const { return _tds.cells_begin(); } All_cells_iterator all_cells_end() const { return _tds.cells_end(); } Finite_vertices_iterator finite_vertices_begin() const { if ( number_of_vertices() <= 0 ) return finite_vertices_end(); return filter_iterator(vertices_end(), Infinite_tester(this), vertices_begin()); } Finite_vertices_iterator finite_vertices_end() const { return filter_iterator(vertices_end(), Infinite_tester(this)); } Vertex_iterator vertices_begin() const { return _tds.vertices_begin(); } Vertex_iterator vertices_end() const { return _tds.vertices_end(); } All_vertices_iterator all_vertices_begin() const { return _tds.vertices_begin(); } All_vertices_iterator all_vertices_end() const { return _tds.vertices_end(); } Finite_edges_iterator finite_edges_begin() const { if ( dimension() < 1 ) return finite_edges_end(); return filter_iterator(edges_end(), Infinite_tester(this), edges_begin()); } Finite_edges_iterator finite_edges_end() const { return filter_iterator(edges_end(), Infinite_tester(this)); } Edge_iterator edges_begin() const { return _tds.edges_begin(); } Edge_iterator edges_end() const { return _tds.edges_end(); } All_edges_iterator all_edges_begin() const { return _tds.edges_begin(); } All_edges_iterator all_edges_end() const { return _tds.edges_end(); } Finite_facets_iterator finite_facets_begin() const { if ( dimension() < 2 ) return finite_facets_end(); return filter_iterator(facets_end(), Infinite_tester(this), facets_begin()); } Finite_facets_iterator finite_facets_end() const { return filter_iterator(facets_end(), Infinite_tester(this)); } Facet_iterator facets_begin() const { return _tds.facets_begin(); } Facet_iterator facets_end() const { return _tds.facets_end(); } All_facets_iterator all_facets_begin() const { return _tds.facets_begin(); } All_facets_iterator all_facets_end() const { return _tds.facets_end(); } Point_iterator points_begin() const { return Point_iterator(finite_vertices_begin()); } Point_iterator points_end() const { return Point_iterator(finite_vertices_end()); } // cells around an edge Cell_circulator incident_cells(const Edge & e) const { return _tds.incident_cells(e); } Cell_circulator incident_cells(Cell_handle c, int i, int j) const { return _tds.incident_cells(c, i, j); } Cell_circulator incident_cells(const Edge & e, Cell_handle start) const { return _tds.incident_cells(e, start); } Cell_circulator incident_cells(Cell_handle c, int i, int j, Cell_handle start) const { return _tds.incident_cells(c, i, j, start); } // facets around an edge Facet_circulator incident_facets(const Edge & e) const { return _tds.incident_facets(e); } Facet_circulator incident_facets(Cell_handle c, int i, int j) const { return _tds.incident_facets(c, i, j); } Facet_circulator incident_facets(const Edge & e, const Facet & start) const { return _tds.incident_facets(e, start); } Facet_circulator incident_facets(Cell_handle c, int i, int j, const Facet & start) const { return _tds.incident_facets(c, i, j, start); } Facet_circulator incident_facets(const Edge & e, Cell_handle start, int f) const { return _tds.incident_facets(e, start, f); } Facet_circulator incident_facets(Cell_handle c, int i, int j, Cell_handle start, int f) const { return _tds.incident_facets(c, i, j, start, f); } // around a vertex template OutputIterator incident_cells(Vertex_handle v, OutputIterator cells) const { return _tds.incident_cells(v, cells); } template OutputIterator incident_vertices(Vertex_handle v, OutputIterator vertices) const { return _tds.incident_vertices(v, vertices); } size_type degree(Vertex_handle v) const { return _tds.degree(v); } // CHECKING bool is_valid(bool verbose = false, int level = 0) const; bool is_valid(Cell_handle c, bool verbose = false, int level = 0) const; bool is_valid_finite(Cell_handle c, bool verbose = false, int level=0) const; }; template < class GT, class Tds > std::istream & operator>> (std::istream& is, Triangulation_3 &tr) // reads // the dimension // the number of finite vertices // the non combinatorial information on vertices (point, etc) // the number of cells // the cells by the indices of their vertices in the preceding list // of vertices, plus the non combinatorial information on each cell // the neighbors of each cell by their index in the preceding list of cells // when dimension < 3 : the same with faces of maximal dimension { typedef Triangulation_3 Triangulation; typedef typename Triangulation::Vertex_handle Vertex_handle; typedef typename Triangulation::Cell_handle Cell_handle; tr._tds.clear(); // infinite vertex deleted tr.infinite = tr._tds.create_vertex(); int n, d; is >> d >> n; tr._tds.set_dimension(d); std::map< int, Vertex_handle > V; V[0] = tr.infinite_vertex(); // the infinite vertex is numbered 0 for (int i=1; i <= n; i++) { V[i] = tr._tds.create_vertex(); is >> *V[i]; } std::map< int, Cell_handle > C; int m; tr._tds.read_cells(is, V, m, C); for (int j=0 ; j < m; j++) is >> *(C[j]); CGAL_triangulation_assertion( tr.is_valid(false) ); return is; } template < class GT, class Tds > std::ostream & operator<< (std::ostream& os, const Triangulation_3 &tr) // writes : // the dimension // the number of finite vertices // the non combinatorial information on vertices (point, etc) // the number of cells // the cells by the indices of their vertices in the preceding list // of vertices, plus the non combinatorial information on each cell // the neighbors of each cell by their index in the preceding list of cells // when dimension < 3 : the same with faces of maximal dimension { typedef Triangulation_3 Triangulation; typedef typename Triangulation::Vertex_handle Vertex_handle; typedef typename Triangulation::Vertex_iterator Vertex_iterator; typedef typename Triangulation::Cell_iterator Cell_iterator; typedef typename Triangulation::Edge_iterator Edge_iterator; typedef typename Triangulation::Facet_iterator Facet_iterator; // outputs dimension and number of vertices int n = tr.number_of_vertices(); if (is_ascii(os)) os << tr.dimension() << std::endl << n << std::endl; else os << tr.dimension() << n; if (n == 0) return os; std::vector TV(n+1); int i = 0; // write the vertices for (Vertex_iterator it=tr.vertices_begin(); it!=tr.vertices_end(); ++it) TV[i++] = it; CGAL_triangulation_assertion( i == n+1 ); CGAL_triangulation_assertion( tr.is_infinite(TV[0]) ); std::map V; V[tr.infinite_vertex()] = 0; for (i=1; i <= n; i++) { os << *TV[i]; V[TV[i]] = i; if (is_ascii(os)) os << std::endl; } // write the non combinatorial information on the cells // using the << operator of Cell // works because the iterator of the tds traverses the cells in the // same order as the iterator of the triangulation switch ( tr.dimension() ) { case 3: { for(Cell_iterator it=tr.cells_begin(); it != tr.cells_end(); ++it) os << *it; // other information break; } case 2: { for(Facet_iterator it=tr.facets_begin(); it != tr.facets_end(); ++it) os << *((*it).first); // other information break; } case 1: { for(Edge_iterator it=tr.edges_begin(); it != tr.edges_end(); ++it) os << *((*it).first); // other information break; } } // asks the tds for the combinatorial information tr.tds().print_cells(os, V); return os ; } template < class GT, class Tds > bool Triangulation_3:: test_dim_down(Vertex_handle v) const // tests whether removing v decreases the dimension of the triangulation // true iff // v is incident to all finite cells/facets // and all the other vertices are coplanar/collinear in dim3/2. { CGAL_triangulation_precondition(dimension() >= 0); CGAL_triangulation_precondition(! is_infinite(v) ); if (dimension() == 3) { Finite_cells_iterator cit = finite_cells_begin(); int iv; if ( ! cit->has_vertex(v,iv) ) return false; const Point &p1=cit->vertex((iv+1)&3)->point(); const Point &p2=cit->vertex((iv+2)&3)->point(); const Point &p3=cit->vertex((iv+3)&3)->point(); ++cit; for (; cit != finite_cells_end(); ++cit ) { if ( ! cit->has_vertex(v,iv) ) return false; for (int i=1; i<4; i++ ) if ( !coplanar(p1,p2,p3,cit->vertex((iv+i)&3)->point()) ) return false; } } else if (dimension() == 2) { Finite_facets_iterator cit = finite_facets_begin(); int iv; if ( ! cit->first->has_vertex(v,iv) ) return false; const Point &p1 = cit->first->vertex(cw(iv))->point(); const Point &p2 = cit->first->vertex(ccw(iv))->point(); ++cit; for (; cit != finite_facets_end(); ++cit ) { if ( ! cit->first->has_vertex(v,iv) ) return false; if ( !collinear(p1, p2, cit->first->vertex(cw(iv))->point()) || !collinear(p1, p2, cit->first->vertex(ccw(iv))->point()) ) return false; } } else // dimension() == 1 or 0 return number_of_vertices() == (size_type) dimension() + 1; return true; } template < class GT, class Tds > typename Triangulation_3::size_type Triangulation_3:: number_of_finite_cells() const { if ( dimension() < 3 ) return 0; return std::distance(finite_cells_begin(), finite_cells_end()); } template < class GT, class Tds > typename Triangulation_3::size_type Triangulation_3:: number_of_cells() const { return _tds.number_of_cells(); } template < class GT, class Tds > typename Triangulation_3::size_type Triangulation_3:: number_of_finite_facets() const { if ( dimension() < 2 ) return 0; return std::distance(finite_facets_begin(), finite_facets_end()); } template < class GT, class Tds > typename Triangulation_3::size_type Triangulation_3:: number_of_facets() const { return _tds.number_of_facets(); } template < class GT, class Tds > typename Triangulation_3::size_type Triangulation_3:: number_of_finite_edges() const { if ( dimension() < 1 ) return 0; return std::distance(finite_edges_begin(), finite_edges_end()); } template < class GT, class Tds > typename Triangulation_3::size_type Triangulation_3:: number_of_edges() const { return _tds.number_of_edges(); } template < class GT, class Tds > typename Triangulation_3::Triangle Triangulation_3:: triangle(const Cell_handle c, int i) const { CGAL_triangulation_precondition( dimension() == 2 || dimension() == 3 ); CGAL_triangulation_precondition( (dimension() == 2 && i == 3) || (dimension() == 3 && i >= 0 && i <= 3) ); CGAL_triangulation_precondition( ! is_infinite(Facet(c, i)) ); if ( (i&1)==0 ) return construct_triangle(c->vertex( (i+2)&3 )->point(), c->vertex( (i+1)&3 )->point(), c->vertex( (i+3)&3 )->point()); return construct_triangle(c->vertex( (i+1)&3 )->point(), c->vertex( (i+2)&3 )->point(), c->vertex( (i+3)&3 )->point()); } template < class GT, class Tds > typename Triangulation_3::Segment Triangulation_3:: segment(const Cell_handle c, int i, int j) const { CGAL_triangulation_precondition( i != j ); CGAL_triangulation_precondition( dimension() >= 1 && dimension() <= 3 ); CGAL_triangulation_precondition( i >= 0 && i <= dimension() && j >= 0 && j <= dimension() ); CGAL_triangulation_precondition( ! is_infinite(Edge(c, i, j)) ); return construct_segment( c->vertex(i)->point(), c->vertex(j)->point() ); } template < class GT, class Tds > inline bool Triangulation_3:: is_infinite(const Cell_handle c, int i) const { CGAL_triangulation_precondition( dimension() == 2 || dimension() == 3 ); CGAL_triangulation_precondition( (dimension() == 2 && i == 3) || (dimension() == 3 && i >= 0 && i <= 3) ); return is_infinite(c->vertex(i<=0 ? 1 : 0)) || is_infinite(c->vertex(i<=1 ? 2 : 1)) || is_infinite(c->vertex(i<=2 ? 3 : 2)); } template < class GT, class Tds > inline bool Triangulation_3:: is_infinite(const Cell_handle c, int i, int j) const { CGAL_triangulation_precondition( i != j ); CGAL_triangulation_precondition( dimension() >= 1 && dimension() <= 3 ); CGAL_triangulation_precondition( i >= 0 && i <= dimension() && j >= 0 && j <= dimension() ); return is_infinite( c->vertex(i) ) || is_infinite( c->vertex(j) ); } template < class GT, class Tds > bool Triangulation_3:: is_vertex(const Point & p, Vertex_handle & v) const { Locate_type lt; int li, lj; Cell_handle c = locate( p, lt, li, lj ); if ( lt != VERTEX ) return false; v = c->vertex(li); return true; } template < class GT, class Tds > inline bool Triangulation_3:: is_vertex(Vertex_handle v) const { return _tds.is_vertex(v); } template < class GT, class Tds > bool Triangulation_3:: is_edge(Vertex_handle u, Vertex_handle v, Cell_handle & c, int & i, int & j) const { return _tds.is_edge(u, v, c, i, j); } template < class GT, class Tds > bool Triangulation_3:: is_facet(Vertex_handle u, Vertex_handle v, Vertex_handle w, Cell_handle & c, int & i, int & j, int & k) const { return _tds.is_facet(u, v, w, c, i, j, k); } template < class GT, class Tds > inline bool Triangulation_3:: is_cell(Cell_handle c) const { return _tds.is_cell(c); } template < class GT, class Tds > bool Triangulation_3:: is_cell(Vertex_handle u, Vertex_handle v, Vertex_handle w, Vertex_handle t, Cell_handle & c, int & i, int & j, int & k, int & l) const { return _tds.is_cell(u, v, w, t, c, i, j, k, l); } template < class GT, class Tds > bool Triangulation_3:: is_cell(Vertex_handle u, Vertex_handle v, Vertex_handle w, Vertex_handle t, Cell_handle & c) const { int i,j,k,l; return _tds.is_cell(u, v, w, t, c, i, j, k, l); } template < class GT, class Tds > inline bool Triangulation_3:: has_vertex(const Facet & f, Vertex_handle v, int & j) const { return _tds.has_vertex(f.first, f.second, v, j); } template < class GT, class Tds > inline bool Triangulation_3:: has_vertex(Cell_handle c, int i, Vertex_handle v, int & j) const { return _tds.has_vertex(c, i, v, j); } template < class GT, class Tds > inline bool Triangulation_3:: has_vertex(const Facet & f, Vertex_handle v) const { return _tds.has_vertex(f.first, f.second, v); } template < class GT, class Tds > inline bool Triangulation_3:: has_vertex(Cell_handle c, int i, Vertex_handle v) const { return _tds.has_vertex(c, i, v); } template < class GT, class Tds > inline bool Triangulation_3:: are_equal(Cell_handle c, int i, Cell_handle n, int j) const { return _tds.are_equal(c, i, n, j); } template < class GT, class Tds > inline bool Triangulation_3:: are_equal(const Facet & f, const Facet & g) const { return _tds.are_equal(f.first, f.second, g.first, g.second); } template < class GT, class Tds > inline bool Triangulation_3:: are_equal(const Facet & f, Cell_handle n, int j) const { return _tds.are_equal(f.first, f.second, n, j); } template < class GT, class Tds > typename Triangulation_3::Cell_handle Triangulation_3:: locate(const Point & p, Locate_type & lt, int & li, int & lj, Cell_handle start ) const // returns the (finite or infinite) cell p lies in // starts at cell "start" // if lt == OUTSIDE_CONVEX_HULL, li is the // index of a facet separating p from the rest of the triangulation // in dimension 2 : // returns a facet (Cell_handle,li) if lt == FACET // returns an edge (Cell_handle,li,lj) if lt == EDGE // returns a vertex (Cell_handle,li) if lt == VERTEX // if lt == OUTSIDE_CONVEX_HULL, li, lj give the edge of c // separating p from the rest of the triangulation // lt = OUTSIDE_AFFINE_HULL if p is not coplanar with the triangulation { if ( dimension() >= 1 ) { // Make sure we continue from here with a finite cell. if ( start == Cell_handle() ) start = infinite_cell(); int ind_inf; if ( start->has_vertex(infinite, ind_inf) ) start = start->neighbor(ind_inf); } switch (dimension()) { case 3: { CGAL_triangulation_precondition( start != Cell_handle() ); CGAL_triangulation_precondition( ! start->has_vertex(infinite) ); // We implement the remembering visibility/stochastic walk. // Remembers the previous cell to avoid useless orientation tests. Cell_handle previous = Cell_handle(); Cell_handle c = start; // Stores the results of the 4 orientation tests. It will be used // at the end to decide if p lies on a face/edge/vertex/interior. Orientation o[4]; // Now treat the cell c. try_next_cell: // We know that the 4 vertices of c are positively oriented. // So, in order to test if p is seen outside from one of c's facets, // we just replace the corresponding point by p in the orientation // test. We do this using the array below. const Point* pts[4] = { &(c->vertex(0)->point()), &(c->vertex(1)->point()), &(c->vertex(2)->point()), &(c->vertex(3)->point()) }; // For the remembering stochastic walk, // we need to start trying with a random index : int i = rng.template get_bits<2>(); // For the remembering visibility walk (Delaunay only), we don't : // int i = 0; for (int j=0; j != 4; ++j, i = (i+1)&3) { Cell_handle next = c->neighbor(i); if (previous == next) { o[i] = POSITIVE; continue; } // We temporarily put p at i's place in pts. const Point* backup = pts[i]; pts[i] = &p; o[i] = orientation(*pts[0], *pts[1], *pts[2], *pts[3]); if ( o[i] != NEGATIVE ) { pts[i] = backup; continue; } if ( next->has_vertex(infinite, li) ) { // We are outside the convex hull. lt = OUTSIDE_CONVEX_HULL; return next; } previous = c; c = next; goto try_next_cell; } // now p is in c or on its boundary int sum = ( o[0] == COPLANAR ) + ( o[1] == COPLANAR ) + ( o[2] == COPLANAR ) + ( o[3] == COPLANAR ); switch (sum) { case 0: { lt = CELL; break; } case 1: { lt = FACET; li = ( o[0] == COPLANAR ) ? 0 : ( o[1] == COPLANAR ) ? 1 : ( o[2] == COPLANAR ) ? 2 : 3; break; } case 2: { lt = EDGE; li = ( o[0] != COPLANAR ) ? 0 : ( o[1] != COPLANAR ) ? 1 : 2; lj = ( o[li+1] != COPLANAR ) ? li+1 : ( o[li+2] != COPLANAR ) ? li+2 : li+3; CGAL_triangulation_assertion(collinear( p, c->vertex( li )->point(), c->vertex( lj )->point())); break; } case 3: { lt = VERTEX; li = ( o[0] != COPLANAR ) ? 0 : ( o[1] != COPLANAR ) ? 1 : ( o[2] != COPLANAR ) ? 2 : 3; break; } } return c; } case 2: { CGAL_triangulation_precondition( start != Cell_handle() ); CGAL_triangulation_precondition( ! start->has_vertex(infinite) ); Cell_handle c = start; //first tests whether p is coplanar with the current triangulation if ( orientation( c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), p ) != DEGENERATE ) { lt = OUTSIDE_AFFINE_HULL; li = 3; // only one facet in dimension 2 return c; } // if p is coplanar, location in the triangulation // only the facet numbered 3 exists in each cell while (1) { int inf; if ( c->has_vertex(infinite,inf) ) { // c must contain p in its interior lt = OUTSIDE_CONVEX_HULL; li = cw(inf); lj = ccw(inf); return c; } // else c is finite // we test its edges in a random order until we find a // neighbor to go further int i = rng.get_int(0, 3); const Point & p0 = c->vertex( i )->point(); const Point & p1 = c->vertex( ccw(i) )->point(); const Point & p2 = c->vertex( cw(i) )->point(); Orientation o[3]; CGAL_triangulation_assertion(coplanar_orientation(p0,p1,p2)==POSITIVE); o[0] = coplanar_orientation(p0,p1,p); if ( o[0] == NEGATIVE ) { c = c->neighbor( cw(i) ); continue; } o[1] = coplanar_orientation(p1,p2,p); if ( o[1] == NEGATIVE ) { c = c->neighbor( i ); continue; } o[2] = coplanar_orientation(p2,p0,p); if ( o[2] == NEGATIVE ) { c = c->neighbor( ccw(i) ); continue; } // now p is in c or on its boundary int sum = ( o[0] == COLLINEAR ) + ( o[1] == COLLINEAR ) + ( o[2] == COLLINEAR ); switch (sum) { case 0: { lt = FACET; li = 3; // useless ? break; } case 1: { lt = EDGE; li = ( o[0] == COLLINEAR ) ? i : ( o[1] == COLLINEAR ) ? ccw(i) : cw(i); lj = ccw(li); break; } case 2: { lt = VERTEX; li = ( o[0] != COLLINEAR ) ? cw(i) : ( o[1] != COLLINEAR ) ? i : ccw(i); break; } } return c; } } case 1: { CGAL_triangulation_precondition( start != Cell_handle() ); CGAL_triangulation_precondition( ! start->has_vertex(infinite) ); Cell_handle c = start; //first tests whether p is collinear with the current triangulation if ( ! collinear( p, c->vertex(0)->point(), c->vertex(1)->point()) ) { lt = OUTSIDE_AFFINE_HULL; return c; } // if p is collinear, location : while (1) { if ( c->has_vertex(infinite) ) { // c must contain p in its interior lt = OUTSIDE_CONVEX_HULL; return c; } // else c is finite // we test on which direction to continue the traversal switch (collinear_position(c->vertex(0)->point(), p, c->vertex(1)->point()) ) { case AFTER: c = c->neighbor(0); continue; case BEFORE: c = c->neighbor(1); continue; case MIDDLE: lt = EDGE; li = 0; lj = 1; return c; case SOURCE: lt = VERTEX; li = 0; return c; case TARGET: lt = VERTEX; li = 1; return c; } } } case 0: { Finite_vertices_iterator vit = finite_vertices_begin(); if ( ! equal( p, vit->point() ) ) { lt = OUTSIDE_AFFINE_HULL; } else { lt = VERTEX; li = 0; } return vit->cell(); } case -1: { lt = OUTSIDE_AFFINE_HULL; return Cell_handle(); } default: { CGAL_triangulation_assertion(false); return Cell_handle(); } } } template < class GT, class Tds > Bounded_side Triangulation_3:: side_of_tetrahedron(const Point & p, const Point & p0, const Point & p1, const Point & p2, const Point & p3, Locate_type & lt, int & i, int & j ) const // p0,p1,p2,p3 supposed to be non coplanar // tetrahedron p0,p1,p2,p3 is supposed to be well oriented // returns : // ON_BOUNDED_SIDE if p lies strictly inside the tetrahedron // ON_BOUNDARY if p lies on one of the facets // ON_UNBOUNDED_SIDE if p lies strictly outside the tetrahedron { CGAL_triangulation_precondition ( orientation(p0,p1,p2,p3) == POSITIVE ); Orientation o0,o1,o2,o3; if ( ((o0 = orientation(p,p1,p2,p3)) == NEGATIVE) || ((o1 = orientation(p0,p,p2,p3)) == NEGATIVE) || ((o2 = orientation(p0,p1,p,p3)) == NEGATIVE) || ((o3 = orientation(p0,p1,p2,p)) == NEGATIVE) ) { lt = OUTSIDE_CONVEX_HULL; return ON_UNBOUNDED_SIDE; } // now all the oi's are >=0 // sum gives the number of facets p lies on int sum = ( (o0 == ZERO) ? 1 : 0 ) + ( (o1 == ZERO) ? 1 : 0 ) + ( (o2 == ZERO) ? 1 : 0 ) + ( (o3 == ZERO) ? 1 : 0 ); switch (sum) { case 0: { lt = CELL; return ON_BOUNDED_SIDE; } case 1: { lt = FACET; // i = index such that p lies on facet(i) i = ( o0 == ZERO ) ? 0 : ( o1 == ZERO ) ? 1 : ( o2 == ZERO ) ? 2 : 3; return ON_BOUNDARY; } case 2: { lt = EDGE; // i = smallest index such that p does not lie on facet(i) // i must be < 3 since p lies on 2 facets i = ( o0 == POSITIVE ) ? 0 : ( o1 == POSITIVE ) ? 1 : 2; // j = larger index such that p not on facet(j) // j must be > 0 since p lies on 2 facets j = ( o3 == POSITIVE ) ? 3 : ( o2 == POSITIVE ) ? 2 : 1; return ON_BOUNDARY; } case 3: { lt = VERTEX; // i = index such that p does not lie on facet(i) i = ( o0 == POSITIVE ) ? 0 : ( o1 == POSITIVE ) ? 1 : ( o2 == POSITIVE ) ? 2 : 3; return ON_BOUNDARY; } default: { // impossible : cannot be on 4 facets for a real tetrahedron CGAL_triangulation_assertion(false); return ON_BOUNDARY; } } } template < class GT, class Tds > Bounded_side Triangulation_3:: side_of_cell(const Point & p, Cell_handle c, Locate_type & lt, int & i, int & j) const // returns // ON_BOUNDED_SIDE if p inside the cell // (for an infinite cell this means that p lies strictly in the half space // limited by its finite facet) // ON_BOUNDARY if p on the boundary of the cell // (for an infinite cell this means that p lies on the *finite* facet) // ON_UNBOUNDED_SIDE if p lies outside the cell // (for an infinite cell this means that p is not in the preceding // two cases) // lt has a meaning only when ON_BOUNDED_SIDE or ON_BOUNDARY { CGAL_triangulation_precondition( dimension() == 3 ); if ( ! is_infinite(c) ) { return side_of_tetrahedron(p, c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point(), lt, i, j); } else { int inf = c->index(infinite); Orientation o; Vertex_handle v1=c->vertex((inf+1)&3), v2=c->vertex((inf+2)&3), v3=c->vertex((inf+3)&3); if ( (inf&1) == 0 ) o = orientation(p, v1->point(), v2->point(), v3->point()); else o = orientation(v3->point(), p, v1->point(), v2->point()); switch (o) { case POSITIVE: { lt = CELL; return ON_BOUNDED_SIDE; } case NEGATIVE: return ON_UNBOUNDED_SIDE; case ZERO: { // location in the finite facet int i_f, j_f; Bounded_side side = side_of_triangle(p, v1->point(), v2->point(), v3->point(), lt, i_f, j_f); // lt need not be modified in most cases : switch (side) { case ON_BOUNDED_SIDE: { // lt == FACET ok i = inf; return ON_BOUNDARY; } case ON_BOUNDARY: { // lt == VERTEX OR EDGE ok i = ( i_f == 0 ) ? ((inf+1)&3) : ( i_f == 1 ) ? ((inf+2)&3) : ((inf+3)&3); if ( lt == EDGE ) { j = (j_f == 0 ) ? ((inf+1)&3) : ( j_f == 1 ) ? ((inf+2)&3) : ((inf+3)&3); } return ON_BOUNDARY; } case ON_UNBOUNDED_SIDE: { // p lies on the plane defined by the finite facet // lt must be initialized return ON_UNBOUNDED_SIDE; } default: { CGAL_triangulation_assertion(false); return ON_BOUNDARY; } } // switch side }// case ZERO default: { CGAL_triangulation_assertion(false); return ON_BOUNDARY; } } // switch o } // else infinite cell } // side_of_cell template < class GT, class Tds > Bounded_side Triangulation_3:: side_of_triangle(const Point & p, const Point & p0, const Point & p1, const Point & p2, Locate_type & lt, int & i, int & j ) const // p0,p1,p2 supposed to define a plane // p supposed to lie on plane p0,p1,p2 // triangle p0,p1,p2 defines the orientation of the plane // returns // ON_BOUNDED_SIDE if p lies strictly inside the triangle // ON_BOUNDARY if p lies on one of the edges // ON_UNBOUNDED_SIDE if p lies strictly outside the triangle { CGAL_triangulation_precondition( coplanar(p,p0,p1,p2) ); Orientation o012 = coplanar_orientation(p0,p1,p2); CGAL_triangulation_precondition( o012 != COLLINEAR ); Orientation o0; // edge p0 p1 Orientation o1; // edge p1 p2 Orientation o2; // edge p2 p0 if ((o0 = coplanar_orientation(p0,p1,p)) == opposite(o012) || (o1 = coplanar_orientation(p1,p2,p)) == opposite(o012) || (o2 = coplanar_orientation(p2,p0,p)) == opposite(o012)) { lt = OUTSIDE_CONVEX_HULL; return ON_UNBOUNDED_SIDE; } // now all the oi's are >=0 // sum gives the number of edges p lies on int sum = ( (o0 == ZERO) ? 1 : 0 ) + ( (o1 == ZERO) ? 1 : 0 ) + ( (o2 == ZERO) ? 1 : 0 ); switch (sum) { case 0: { lt = FACET; return ON_BOUNDED_SIDE; } case 1: { lt = EDGE; i = ( o0 == ZERO ) ? 0 : ( o1 == ZERO ) ? 1 : 2; if ( i == 2 ) j=0; else j = i+1; return ON_BOUNDARY; } case 2: { lt = VERTEX; i = ( o0 == o012 ) ? 2 : ( o1 == o012 ) ? 0 : 1; return ON_BOUNDARY; } default: { // cannot happen CGAL_triangulation_assertion(false); return ON_BOUNDARY; } } } template < class GT, class Tds > Bounded_side Triangulation_3:: side_of_facet(const Point & p, Cell_handle c, Locate_type & lt, int & li, int & lj) const // supposes dimension 2 otherwise does not work for infinite facets // returns : // ON_BOUNDED_SIDE if p inside the facet // (for an infinite facet this means that p lies strictly in the half plane // limited by its finite edge) // ON_BOUNDARY if p on the boundary of the facet // (for an infinite facet this means that p lies on the *finite* edge) // ON_UNBOUNDED_SIDE if p lies outside the facet // (for an infinite facet this means that p is not in the // preceding two cases) // lt has a meaning only when ON_BOUNDED_SIDE or ON_BOUNDARY // when they mean anything, li and lj refer to indices in the cell c // giving the facet (c,i) { CGAL_triangulation_precondition( dimension() == 2 ); if ( ! is_infinite(c,3) ) { // The following precondition is useless because it is written // in side_of_facet // CGAL_triangulation_precondition( coplanar (p, // c->vertex(0)->point, // c->vertex(1)->point, // c->vertex(2)->point) ); int i_t, j_t; Bounded_side side = side_of_triangle(p, c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), lt, i_t, j_t); // We protect the following code by this test to avoid valgrind messages. if (side == ON_BOUNDARY) { // indices in the original cell : li = ( i_t == 0 ) ? 0 : ( i_t == 1 ) ? 1 : 2; lj = ( j_t == 0 ) ? 0 : ( j_t == 1 ) ? 1 : 2; } return side; } // else infinite facet int inf = c->index(infinite); // The following precondition is useless because it is written // in side_of_facet // CGAL_triangulation_precondition( coplanar (p, // c->neighbor(inf)->vertex(0)->point(), // c->neighbor(inf)->vertex(1)->point(), // c->neighbor(inf)->vertex(2)->point())); int i2 = next_around_edge(inf,3); int i1 = 3-inf-i2; Vertex_handle v1 = c->vertex(i1), v2 = c->vertex(i2); CGAL_triangulation_assertion(coplanar_orientation(v1->point(), v2->point(), c->mirror_vertex(inf)->point()) == POSITIVE); switch (coplanar_orientation(v1->point(), v2->point(), p)) { case POSITIVE: // p lies on the same side of v1v2 as vn, so not in f return ON_UNBOUNDED_SIDE; case NEGATIVE: // p lies in f lt = FACET; li = 3; return ON_BOUNDED_SIDE; default: // case ZERO: // p collinear with v1v2 int i_e; switch (side_of_segment(p, v1->point(), v2->point(), lt, i_e)) { // computation of the indices in the original cell case ON_BOUNDED_SIDE: // lt == EDGE ok li = i1; lj = i2; return ON_BOUNDARY; case ON_BOUNDARY: // lt == VERTEX ok li = ( i_e == 0 ) ? i1 : i2; return ON_BOUNDARY; default: // case ON_UNBOUNDED_SIDE: // p lies on the line defined by the finite edge return ON_UNBOUNDED_SIDE; } } } template < class GT, class Tds > Bounded_side Triangulation_3:: side_of_segment(const Point & p, const Point & p0, const Point & p1, Locate_type & lt, int & i ) const // p0, p1 supposed to be different // p supposed to be collinear to p0, p1 // returns : // ON_BOUNDED_SIDE if p lies strictly inside the edge // ON_BOUNDARY if p equals p0 or p1 // ON_UNBOUNDED_SIDE if p lies strictly outside the edge { CGAL_triangulation_precondition( ! equal(p0, p1) ); CGAL_triangulation_precondition( collinear(p, p0, p1) ); switch (collinear_position(p0, p, p1)) { case MIDDLE: lt = EDGE; return ON_BOUNDED_SIDE; case SOURCE: lt = VERTEX; i = 0; return ON_BOUNDARY; case TARGET: lt = VERTEX; i = 1; return ON_BOUNDARY; default: // case BEFORE: case AFTER: lt = OUTSIDE_CONVEX_HULL; return ON_UNBOUNDED_SIDE; } } template < class GT, class Tds > Bounded_side Triangulation_3:: side_of_edge(const Point & p, Cell_handle c, Locate_type & lt, int & li) const // supposes dimension 1 otherwise does not work for infinite edges // returns : // ON_BOUNDED_SIDE if p inside the edge // (for an infinite edge this means that p lies in the half line // defined by the vertex) // ON_BOUNDARY if p equals one of the vertices // ON_UNBOUNDED_SIDE if p lies outside the edge // (for an infinite edge this means that p lies on the other half line) // lt has a meaning when ON_BOUNDED_SIDE and ON_BOUNDARY // li refer to indices in the cell c { CGAL_triangulation_precondition( dimension() == 1 ); if ( ! is_infinite(c,0,1) ) return side_of_segment(p, c->vertex(0)->point(), c->vertex(1)->point(), lt, li); // else infinite edge int inf = c->index(infinite); switch (collinear_position(c->vertex(1-inf)->point(), p, c->mirror_vertex(inf)->point())) { case SOURCE: lt = VERTEX; li = 1-inf; return ON_BOUNDARY; case BEFORE: lt = EDGE; return ON_BOUNDED_SIDE; default: // case MIDDLE: case AFTER: case TARGET: return ON_UNBOUNDED_SIDE; } } template < class GT, class Tds > bool Triangulation_3:: flip( Cell_handle c, int i ) { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (number_of_vertices() > 5) ); Cell_handle n = c->neighbor(i); int in = n->index(c); if ( is_infinite( c ) || is_infinite( n ) ) return false; if ( i%2 == 1 ) { if ( orientation( c->vertex((i+1)&3)->point(), c->vertex((i+2)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) != POSITIVE ) return false; if ( orientation( c->vertex((i+2)&3)->point(), c->vertex((i+3)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) != POSITIVE ) return false; if ( orientation( c->vertex((i+3)&3)->point(), c->vertex((i+1)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) != POSITIVE ) return false; } else { if ( orientation( c->vertex((i+2)&3)->point(), c->vertex((i+1)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) != POSITIVE ) return false; if ( orientation( c->vertex((i+3)&3)->point(), c->vertex((i+2)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) != POSITIVE ) return false; if ( orientation( c->vertex((i+1)&3)->point(), c->vertex((i+3)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) != POSITIVE ) return false; } _tds.flip_flippable(c, i); return true; } template < class GT, class Tds > void Triangulation_3:: flip_flippable( Cell_handle c, int i ) { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (number_of_vertices() > 5) ); CGAL_triangulation_precondition_code( Cell_handle n = c->neighbor(i); ); CGAL_triangulation_precondition_code( int in = n->index(c); ); CGAL_triangulation_precondition( ( ! is_infinite( c ) ) && ( ! is_infinite( n ) ) ); if ( i%2 == 1 ) { CGAL_triangulation_precondition( orientation( c->vertex((i+1)&3)->point(), c->vertex((i+2)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) == POSITIVE ); CGAL_triangulation_precondition( orientation( c->vertex((i+2)&3)->point(), c->vertex((i+3)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) == POSITIVE ); CGAL_triangulation_precondition( orientation( c->vertex((i+3)&3)->point(), c->vertex((i+1)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) == POSITIVE ); } else { CGAL_triangulation_precondition( orientation( c->vertex((i+2)&3)->point(), c->vertex((i+1)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) == POSITIVE ); CGAL_triangulation_precondition( orientation( c->vertex((i+3)&3)->point(), c->vertex((i+2)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) == POSITIVE ); CGAL_triangulation_precondition( orientation( c->vertex((i+1)&3)->point(), c->vertex((i+3)&3)->point(), n->vertex(in)->point(), c->vertex(i)->point() ) == POSITIVE ); } _tds.flip_flippable(c, i); } template < class GT, class Tds > bool Triangulation_3:: flip( Cell_handle c, int i, int j ) // flips edge i,j of cell c { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (0<=j) && (j<4) && ( i != j ) && (number_of_vertices() > 5) ); // checks that degree 3 and not on the convex hull int degree = 0; Cell_circulator ccir = incident_cells(c,i,j); Cell_circulator cdone = ccir; do { if ( is_infinite(ccir) ) return false; ++degree; ++ccir; } while ( ccir != cdone ); if ( degree != 3 ) return false; // checks that future tetrahedra are well oriented Cell_handle n = c->neighbor( next_around_edge(i,j) ); int in = n->index( c->vertex(i) ); int jn = n->index( c->vertex(j) ); if ( orientation( c->vertex(next_around_edge(i,j))->point(), c->vertex(next_around_edge(j,i))->point(), n->vertex(next_around_edge(jn,in))->point(), c->vertex(j)->point() ) != POSITIVE ) return false; if ( orientation( c->vertex(i)->point(), c->vertex(next_around_edge(j,i))->point(), n->vertex(next_around_edge(jn,in))->point(), c->vertex(next_around_edge(i,j))->point() ) != POSITIVE ) return false; _tds.flip_flippable(c, i, j); return true; } template < class GT, class Tds > void Triangulation_3:: flip_flippable( Cell_handle c, int i, int j ) // flips edge i,j of cell c { #if !defined CGAL_TRIANGULATION_NO_PRECONDITIONS && \ !defined CGAL_NO_PRECONDITIONS && !defined NDEBUG CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (0<=j) && (j<4) && ( i != j ) && (number_of_vertices() > 5) ); int degree = 0; Cell_circulator ccir = incident_cells(c,i,j); Cell_circulator cdone = ccir; do { CGAL_triangulation_precondition( ! is_infinite(ccir) ); ++degree; ++ccir; } while ( ccir != cdone ); CGAL_triangulation_precondition( degree == 3 ); Cell_handle n = c->neighbor( next_around_edge(i, j) ); int in = n->index( c->vertex(i) ); int jn = n->index( c->vertex(j) ); CGAL_triangulation_precondition ( orientation( c->vertex(next_around_edge(i,j))->point(), c->vertex(next_around_edge(j,i))->point(), n->vertex(next_around_edge(jn,in))->point(), c->vertex(j)->point() ) == POSITIVE ); CGAL_triangulation_precondition ( orientation( c->vertex(i)->point(), c->vertex(next_around_edge(j,i))->point(), n->vertex(next_around_edge(jn,in))->point(), c->vertex(next_around_edge(i,j))->point() ) == POSITIVE ); #endif _tds.flip_flippable(c, i, j); } template < class GT, class Tds > typename Triangulation_3::Vertex_handle Triangulation_3:: insert(const Point & p, Cell_handle start) { Locate_type lt; int li, lj; Cell_handle c = locate( p, lt, li, lj, start); return insert(p, lt, c, li, lj); } template < class GT, class Tds > typename Triangulation_3::Vertex_handle Triangulation_3:: insert(const Point & p, Locate_type lt, Cell_handle c, int li, int lj) { switch (lt) { case VERTEX: return c->vertex(li); case EDGE: return insert_in_edge(p, c, li, lj); case FACET: return insert_in_facet(p, c, li); case CELL: return insert_in_cell(p, c); case OUTSIDE_CONVEX_HULL: return insert_outside_convex_hull(p, c); case OUTSIDE_AFFINE_HULL: default: return insert_outside_affine_hull(p); } } template < class GT, class Tds > typename Triangulation_3::Vertex_handle Triangulation_3:: insert_in_cell(const Point & p, Cell_handle c) { CGAL_triangulation_precondition( dimension() == 3 ); CGAL_triangulation_precondition_code ( Locate_type lt; int i; int j; ); CGAL_triangulation_precondition ( side_of_tetrahedron( p, c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point(), lt,i,j ) == ON_BOUNDED_SIDE ); Vertex_handle v = _tds.insert_in_cell(c); v->set_point(p); return v; } template < class GT, class Tds > inline typename Triangulation_3::Vertex_handle Triangulation_3:: insert_in_facet(const Point & p, Cell_handle c, int i) { CGAL_triangulation_precondition( dimension() == 2 || dimension() == 3); CGAL_triangulation_precondition( (dimension() == 2 && i == 3) || (dimension() == 3 && i >= 0 && i <= 3) ); CGAL_triangulation_exactness_precondition_code ( Locate_type lt; int li; int lj; ); CGAL_triangulation_exactness_precondition ( coplanar( p, c->vertex((i+1)&3)->point(), c->vertex((i+2)&3)->point(), c->vertex((i+3)&3)->point() ) && side_of_triangle( p, c->vertex((i+1)&3)->point(), c->vertex((i+2)&3)->point(), c->vertex((i+3)&3)->point(), lt, li, lj) == ON_BOUNDED_SIDE ); Vertex_handle v = _tds.insert_in_facet(c, i); v->set_point(p); return v; } template < class GT, class Tds > typename Triangulation_3::Vertex_handle Triangulation_3:: insert_in_edge(const Point & p, Cell_handle c, int i, int j) { CGAL_triangulation_precondition( i != j ); CGAL_triangulation_precondition( dimension() >= 1 && dimension() <= 3 ); CGAL_triangulation_precondition( i >= 0 && i <= dimension() && j >= 0 && j <= dimension() ); CGAL_triangulation_exactness_precondition_code( Locate_type lt; int li; ); switch ( dimension() ) { case 3: case 2: { CGAL_triangulation_precondition( ! is_infinite(c, i, j) ); CGAL_triangulation_exactness_precondition( collinear( c->vertex(i)->point(), p, c->vertex(j)->point() ) && side_of_segment( p, c->vertex(i)->point(), c->vertex(j)->point(), lt, li ) == ON_BOUNDED_SIDE ); break; } case 1: { CGAL_triangulation_exactness_precondition( side_of_edge(p, c, lt, li) == ON_BOUNDED_SIDE ); break; } } Vertex_handle v = _tds.insert_in_edge(c, i, j); v->set_point(p); return v; } template < class GT, class Tds > typename Triangulation_3::Vertex_handle Triangulation_3:: insert_outside_convex_hull(const Point & p, Cell_handle c) // c is an infinite cell containing p // p is strictly outside the convex hull // dimension 0 not allowed, use outside-affine-hull { CGAL_triangulation_precondition( dimension() > 0 ); CGAL_triangulation_precondition( c->has_vertex(infinite) ); // the precondition that p is in c is tested in each of the // insertion methods called from this method switch ( dimension() ) { case 1: { // // p lies in the infinite edge neighboring c // // on the other side of li // return insert_in_edge(p,c->neighbor(1-li),0,1); return insert_in_edge(p,c,0,1); } case 2: { Conflict_tester_outside_convex_hull_2 tester(p, this); Vertex_handle v = insert_conflict_2(c, tester); v->set_point(p); return v; } default: // case 3: { Conflict_tester_outside_convex_hull_3 tester(p, this); Vertex_handle v = insert_conflict_3(c, tester); v->set_point(p); return v; } } } template < class GT, class Tds > typename Triangulation_3::Vertex_handle Triangulation_3:: insert_outside_affine_hull(const Point & p) { CGAL_triangulation_precondition( dimension() < 3 ); bool reorient; switch ( dimension() ) { case 1: { Cell_handle c = infinite_cell(); Cell_handle n = c->neighbor(c->index(infinite_vertex())); Orientation o = coplanar_orientation(n->vertex(0)->point(), n->vertex(1)->point(), p); CGAL_triangulation_precondition ( o != COLLINEAR ); reorient = o == NEGATIVE; break; } case 2: { Cell_handle c = infinite_cell(); Cell_handle n = c->neighbor(c->index(infinite_vertex())); Orientation o = orientation( n->vertex(0)->point(), n->vertex(1)->point(), n->vertex(2)->point(), p ); CGAL_triangulation_precondition ( o != COPLANAR ); reorient = o == NEGATIVE; break; } default: reorient = false; } Vertex_handle v = _tds.insert_increase_dimension(infinite_vertex()); v->set_point(p); if (reorient) _tds.reorient(); return v; } template < class GT, class Tds > bool Triangulation_3:: is_valid(bool verbose, int level) const { if ( ! _tds.is_valid(verbose,level) ) { if (verbose) std::cerr << "invalid data structure" << std::endl; CGAL_triangulation_assertion(false); return false; } if ( infinite_vertex() == Vertex_handle() ) { if (verbose) std::cerr << "no infinite vertex" << std::endl; CGAL_triangulation_assertion(false); return false; } switch ( dimension() ) { case 3: { Finite_cells_iterator it; for ( it = finite_cells_begin(); it != finite_cells_end(); ++it ) is_valid_finite(it, verbose, level); break; } case 2: { Finite_facets_iterator it; for ( it = finite_facets_begin(); it != finite_facets_end(); ++it ) is_valid_finite(it->first,verbose,level); break; } case 1: { Finite_edges_iterator it; for ( it = finite_edges_begin(); it != finite_edges_end(); ++it ) is_valid_finite(it->first,verbose,level); break; } } if (verbose) std::cerr << "valid triangulation" << std::endl; return true; } template < class GT, class Tds > bool Triangulation_3:: is_valid(Cell_handle c, bool verbose, int level) const { if ( ! c->is_valid(dimension(),verbose,level) ) { if (verbose) { std::cerr << "combinatorially invalid cell"; for (int i=0; i <= dimension(); i++ ) std::cerr << c->vertex(i)->point() << ", "; std::cerr << std::endl; } CGAL_triangulation_assertion(false); return false; } if ( ! is_infinite(c) ) is_valid_finite(c, verbose, level); if (verbose) std::cerr << "geometrically valid cell" << std::endl; return true; } template < class GT, class Tds > bool Triangulation_3:: is_valid_finite(Cell_handle c, bool verbose, int) const { switch ( dimension() ) { case 3: { if ( orientation(c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point(), c->vertex(3)->point()) != POSITIVE ) { if (verbose) std::cerr << "badly oriented cell " << c->vertex(0)->point() << ", " << c->vertex(1)->point() << ", " << c->vertex(2)->point() << ", " << c->vertex(3)->point() << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 2: { if (coplanar_orientation(c->vertex(0)->point(), c->vertex(1)->point(), c->vertex(2)->point()) != POSITIVE) { if (verbose) std::cerr << "badly oriented face " << c->vertex(0)->point() << ", " << c->vertex(1)->point() << ", " << c->vertex(2)->point() << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 1: { const Point & p0 = c->vertex(0)->point(); const Point & p1 = c->vertex(1)->point(); Vertex_handle v = c->neighbor(0)->vertex(c->neighbor(0)->index(c)); if ( ! is_infinite(v) ) { if ( collinear_position(p0, p1, v->point()) != MIDDLE ) { if (verbose) std::cerr << "badly oriented edge " << p0 << ", " << p1 << std::endl << "with neighbor 0" << c->neighbor(0)->vertex(1-c->neighbor(0)->index(c)) ->point() << ", " << v->point() << std::endl; CGAL_triangulation_assertion(false); return false; } } v = c->neighbor(1)->vertex(c->neighbor(1)->index(c)); if ( ! is_infinite(v) ) { if ( collinear_position(p1, p0, v->point()) != MIDDLE ) { if (verbose) std::cerr << "badly oriented edge " << p0 << ", " << p1 << std::endl << "with neighbor 1" << c->neighbor(1)->vertex(1-c->neighbor(1)->index(c)) ->point() << ", " << v->point() << std::endl; CGAL_triangulation_assertion(false); return false; } } break; } } return true; } namespace CGALi { // Internal function used by operator==. template bool test_next(const Tr &t1, const Tr &t2, typename Tr::Cell_handle c1, typename Tr::Cell_handle c2, std::map &Cmap, std::map &Vmap) { // This function tests and registers the 4 neighbors of c1/c2, // and recursively calls itself over them. // Returns false if an inequality has been found. // Precondition: c1, c2 have been registered as well as their 4 vertices. CGAL_triangulation_precondition(t1.dimension() >= 2); CGAL_triangulation_precondition(Cmap[c1] == c2); CGAL_triangulation_precondition(Vmap.find(c1->vertex(0)) != Vmap.end()); CGAL_triangulation_precondition(Vmap.find(c1->vertex(1)) != Vmap.end()); CGAL_triangulation_precondition(Vmap.find(c1->vertex(2)) != Vmap.end()); CGAL_triangulation_precondition(t1.dimension() == 2 || Vmap.find(c1->vertex(3)) != Vmap.end()); typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Cell_handle Cell_handle; typedef typename std::map::const_iterator Cit; typedef typename std::map::const_iterator Vit; for (int i=0; i <= t1.dimension(); ++i) { Cell_handle n1 = c1->neighbor(i); Cit cit = Cmap.find(n1); Vertex_handle v1 = c1->vertex(i); Vertex_handle v2 = Vmap[v1]; Cell_handle n2 = c2->neighbor(c2->index(v2)); if (cit != Cmap.end()) { // n1 was already registered. if (cit->second != n2) return false; continue; } // n1 has not yet been registered. // We check that the new vertices match geometrically. // And we register them. Vertex_handle vn1 = n1->vertex(n1->index(c1)); Vertex_handle vn2 = n2->vertex(n2->index(c2)); Vit vit = Vmap.find(vn1); if (vit != Vmap.end()) { // vn1 already registered if (vit->second != vn2) return false; } else { if (t2.is_infinite(vn2)) return false; // vn1 can't be infinite, // since it would have been registered. if (t1.geom_traits().compare_xyz_3_object()(vn1->point(), vn2->point()) != 0) return false; // We register vn1/vn2. Vmap.insert(std::make_pair(vn1, vn2)); } // We register n1/n2. Cmap.insert(std::make_pair(n1, n2)); // We recurse on n1/n2. if (!test_next(t1, t2, n1, n2, Cmap, Vmap)) return false; } return true; } } // namespace CGALi template < class GT, class Tds > bool operator==(const Triangulation_3 &t1, const Triangulation_3 &t2) { typedef typename Triangulation_3::Vertex_handle Vertex_handle; typedef typename Triangulation_3::Cell_handle Cell_handle; typedef typename Triangulation_3::Point Point; // Some quick checks. if (t1.dimension() != t2.dimension() || t1.number_of_vertices() != t2.number_of_vertices() || t1.number_of_cells() != t2.number_of_cells()) return false; int dim = t1.dimension(); // Special case for dimension < 1. // The triangulation is uniquely defined in these cases. if (dim < 1) return true; // Special case for dimension == 1. if (dim == 1) { // It's enough to test that the points are the same, // since the triangulation is uniquely defined in this case. #ifndef CGAL_CFG_MISSING_TEMPLATE_VECTOR_CONSTRUCTORS_BUG std::vector V1(t1.points_begin(), t1.points_end()); std::vector V2(t2.points_begin(), t2.points_end()); #else std::vector V1, V2; std::copy(t1.points_begin(), t1.points_end(), std::back_inserter(V1)); std::copy(t2.points_begin(), t2.points_end(), std::back_inserter(V2)); #endif std::sort(V1.begin(), V1.end(), compose(Is_negative(), t1.geom_traits().compare_xyz_3_object())); std::sort(V2.begin(), V2.end(), compose(Is_negative(), t2.geom_traits().compare_xyz_3_object())); return V1 == V2; } // We will store the mapping between the 2 triangulations vertices and // cells in 2 maps. std::map Vmap; std::map Cmap; // Handle the infinite vertex. Vertex_handle v1 = t1.infinite_vertex(); Vertex_handle iv2 = t2.infinite_vertex(); Vmap.insert(std::make_pair(v1, iv2)); // We pick one infinite cell of t1, and try to match it against the // infinite cells of t2. Cell_handle c = v1->cell(); Vertex_handle v2 = c->vertex((c->index(v1)+1)%(dim+1)); Vertex_handle v3 = c->vertex((c->index(v1)+2)%(dim+1)); Vertex_handle v4 = c->vertex((c->index(v1)+3)%(dim+1)); const Point &p2 = v2->point(); const Point &p3 = v3->point(); const Point &p4 = v4->point(); std::vector ics; t2.incident_cells(iv2, std::back_inserter(ics)); for (typename std::vector::const_iterator cit = ics.begin(); cit != ics.end(); ++cit) { int inf = (*cit)->index(iv2); if (t1.equal(p2, (*cit)->vertex((inf+1)%(dim+1))->point())) Vmap.insert(std::make_pair(v2, (*cit)->vertex((inf+1)%(dim+1)))); else if (t1.equal(p2, (*cit)->vertex((inf+2)%(dim+1))->point())) Vmap.insert(std::make_pair(v2, (*cit)->vertex((inf+2)%(dim+1)))); else if (dim == 3 && t1.equal(p2, (*cit)->vertex((inf+3)%(dim+1))->point())) Vmap.insert(std::make_pair(v2, (*cit)->vertex((inf+3)%(dim+1)))); else continue; // None matched v2. if (t1.equal(p3, (*cit)->vertex((inf+1)%(dim+1))->point())) Vmap.insert(std::make_pair(v3, (*cit)->vertex((inf+1)%(dim+1)))); else if (t1.equal(p3, (*cit)->vertex((inf+2)%(dim+1))->point())) Vmap.insert(std::make_pair(v3, (*cit)->vertex((inf+2)%(dim+1)))); else if (dim == 3 && t1.equal(p3, (*cit)->vertex((inf+3)%(dim+1))->point())) Vmap.insert(std::make_pair(v3, (*cit)->vertex((inf+3)%(dim+1)))); else continue; // None matched v3. if (dim == 3) { if (t1.equal(p4, (*cit)->vertex((inf+1)%(dim+1))->point())) Vmap.insert(std::make_pair(v4, (*cit)->vertex((inf+1)%(dim+1)))); else if (t1.equal(p4, (*cit)->vertex((inf+2)%(dim+1))->point())) Vmap.insert(std::make_pair(v4, (*cit)->vertex((inf+2)%(dim+1)))); else if (t1.equal(p4, (*cit)->vertex((inf+3)%(dim+1))->point())) Vmap.insert(std::make_pair(v4, (*cit)->vertex((inf+3)%(dim+1)))); else continue; // None matched v4. } // Found it ! Cmap.insert(std::make_pair(c, *cit)); break; } if (Cmap.size() == 0) return false; // We now have one cell, we need to propagate recursively. return CGALi::test_next(t1, t2, Cmap.begin()->first, Cmap.begin()->second, Cmap, Vmap); } template < class GT, class Tds > inline bool operator!=(const Triangulation_3 &t1, const Triangulation_3 &t2) { return ! (t1 == t2); } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d.h0000644000175000017500000016007211344301500027770 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel //--------------------------------------------------------------------- // file generated by notangle from Convex_hull_d.lw // please debug or modify web file // mails and bugs: Michael.Seel@mpi-sb.mpg.de // based on LEDA architecture by S. Naeher, C. Uhrig // coding: K. Mehlhorn, M. Seel // debugging and templatization: M. Seel //--------------------------------------------------------------------- #ifndef CGAL_CONVEX_HULL_D_H #define CGAL_CONVEX_HULL_D_H /*{\Manpage {Convex_hull_d}{R}{Convex Hulls}{C}}*/ /*{\Mdefinition An instance |\Mvar| of type |\Mname| is the convex hull of a multi-set |S| of points in $d$-dimensional space. We call |S| the underlying point set and $d$ or |dim| the dimension of the underlying space. We use |dcur| to denote the affine dimension of |S|. The data type supports incremental construction of hulls. The closure of the hull is maintained as a simplicial complex, i.e., as a collection of simplices. The intersection of any two is a face of both\footnote{The empty set if a facet of every simplex.}. In the sequel we reserve the word simplex for the simplices of dimension |dcur|. For each simplex there is a handle of type |Simplex_handlex| and for each vertex there is a handle of type |Vertex_handle|. Each simplex has $1 + |dcur|$ vertices indexed from $0$ to |dcur|; for a simplex $s$ and an index $i$, |C.vertex(s,i)| returns the $i$-th vertex of $s$. For any simplex $s$ and any index $i$ of $s$ there may or may not be a simplex $t$ opposite to the $i$-th vertex of $s$. The function |C.opposite_simplex(s,i)| returns $t$ if it exists and returns |Simplex_handle()| (the undefined handle) otherwise. If $t$ exists then $s$ and $t$ share |dcur| vertices, namely all but the vertex with index $i$ of $s$ and the vertex with index |C.index_of_vertex_in_opposite_simplex(s,i)| of $t$. Assume that $t$ exists and let |j = C.index_of_vertex_in_opposite_simplex(s,i)|. Then $s =$ |C.opposite_simplex(t,j)| and $i =$ |C.index_of_vertex_in_opposite_simplex(t,j)|. The boundary of the hull is also a simplicial complex. All simplices in this complex have dimension $|dcur| - 1$. For each boundary simplex there is a handle of type |Facet_handle|. Each facet has |dcur| vertices indexed from $0$ to $|dcur| - 1$. If |dcur > 1| then for each facet $f$ and each index $i$, $0 \le i < |dcur|$, there is a facet $g$ opposite to the $i$-th vertex of $f$. The function |C.opposite_facet(f,i)| returns $g$. Two neighboring facets $f$ and $g$ share |dcur - 1| vertices, namely all but the vertex with index $i$ of $f$ and the vertex with index |C.index_of_vertex_in_opposite_facet(f,i)| of $g$. Let |j = C.index_of_vertex_in_opposite_facet(f,i)|. Then |f = C.opposite_facet(g,j)| and |i = C.index_of_vertex_in_opposite_facet(g,j)|.}*/ #include #include #include #include #include #undef _DEBUG #define _DEBUG 93 #include CGAL_BEGIN_NAMESPACE template class Facet_iterator_rep_; template class Facet_iterator_; template class Facet_iterator_rep_ { CGAL::Unique_hash_map* pvisited_; std::list* pcandidates_; Hull_pointer hull_; Handle current_; friend class Facet_iterator_; void add_candidates() { CGAL_assertion(pvisited_ && pcandidates_ && hull_); for(int i = 1; i <= hull_->current_dimension(); ++i) { Handle f = hull_->opposite_simplex(current_,i); if ( !(*pvisited_)[f] ) { pcandidates_->push_front(f); (*pvisited_)[f] = true; } } } public: Facet_iterator_rep_() : pvisited_(0), pcandidates_(0), hull_(0), current_() {} Facet_iterator_rep_(Hull_pointer p, Handle h) : pvisited_(0), pcandidates_(0), hull_(p), current_(h) {} ~Facet_iterator_rep_() { if (pvisited_) delete pvisited_; if (pcandidates_) delete pcandidates_; } }; template class Facet_iterator_ : private Handle_for > { typedef Facet_iterator_ Self; typedef Facet_iterator_rep_ Rep; typedef Handle_for< Facet_iterator_rep_ > Base; using Base::ptr; public: typedef typename Handle::value_type value_type; typedef typename Handle::pointer pointer; typedef typename Handle::reference reference; typedef typename Handle::difference_type difference_type; typedef std::forward_iterator_tag iterator_category; Facet_iterator_() : Base( Rep() ) {} Facet_iterator_(Hull_pointer p, Handle h) : Base( Rep(p,h) ) { ptr()->pvisited_ = new Unique_hash_map(false); ptr()->pcandidates_ = new std::list; (*(ptr()->pvisited_))[ptr()->current_]=true; ptr()->add_candidates(); } reference operator*() const { return ptr()->current_.operator*(); } pointer operator->() const { return ptr()->current_.operator->(); } Self& operator++() { if ( ptr()->current_ == Handle() ) return *this; if ( ptr()->pcandidates_->empty() ) ptr()->current_ = Handle(); else { ptr()->current_ = ptr()->pcandidates_->back(); ptr()->pcandidates_->pop_back(); ptr()->add_candidates(); } return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } bool operator==(const Self& x) const { return ptr()->current_ == x.ptr()->current_; } bool operator!=(const Self& x) const { return !operator==(x); } operator Handle() { return ptr()->current_; } }; template class Hull_vertex_iterator_rep_; template class Hull_vertex_iterator_; template class Hull_vertex_iterator_rep_ { CGAL::Unique_hash_map* pvisited_; Hull_pointer hull_; VHandle v_; FHandle f_; int i_; friend class Hull_vertex_iterator_; void advance() { CGAL_assertion(pvisited_ && hull_); if ( f_ == FHandle() ) return; bool search_next = true; ++i_; while ( search_next ) { while(i_ < hull_->current_dimension()) { v_ = hull_->vertex_of_facet(f_,i_); if ( !(*pvisited_)[v_] ) { search_next=false; break; } ++i_; } if ( search_next ) { i_=0; ++f_; } if ( f_ == FHandle() ) { search_next=false; v_ = VHandle(); } } (*pvisited_)[v_] = true; } public: Hull_vertex_iterator_rep_() : pvisited_(0), hull_(0), i_(0) {} Hull_vertex_iterator_rep_(Hull_pointer p, FHandle f) : pvisited_(0), hull_(p), f_(f), i_(-1) {} ~Hull_vertex_iterator_rep_() { if (pvisited_) delete pvisited_; } }; template class Hull_vertex_iterator_ : private Handle_for< Hull_vertex_iterator_rep_ > { typedef Hull_vertex_iterator_ Self; typedef Hull_vertex_iterator_rep_ Rep; typedef Handle_for< Rep > Base; using Base::ptr; public: typedef typename VHandle::value_type value_type; typedef typename VHandle::pointer pointer; typedef typename VHandle::reference reference; typedef typename VHandle::difference_type difference_type; typedef std::forward_iterator_tag iterator_category; Hull_vertex_iterator_() : Base( Rep() ) {} Hull_vertex_iterator_(Hull_pointer p, FHandle f) : Base( Rep(p,f) ) { ptr()->pvisited_ = new Unique_hash_map(false); ptr()->advance(); } reference operator*() const { return ptr()->v_.operator*(); } pointer operator->() const { return ptr()->v_.operator->(); } Self& operator++() { if ( ptr()->v_ == VHandle() ) return *this; ptr()->advance(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } bool operator==(const Self& x) const { return ptr()->v_ == x.ptr()->v_; } bool operator!=(const Self& x) const { return !operator==(x); } operator VHandle() { return ptr()->v_; } }; template struct Point_from_Vertex { typedef Vertex argument_type; typedef Point result_type; result_type& operator()(argument_type& x) const { return x.point(); } const result_type& operator()(const argument_type& x) const { return x.point(); } }; template struct list_collector { std::list

    & L_; list_collector(std::list

    & L) : L_(L) {} void operator()(H2 f) const { L_.push_back(static_cast

    (f)); } }; template class Convex_hull_d : public Regular_complex_d { typedef Regular_complex_d Base; typedef Convex_hull_d Self; using Base::new_simplex; public: using Base::kernel; using Base::dcur; /*{\Xgeneralization Regular_complex_d}*/ /*{\Mtypes 6.5}*/ typedef R_ R; /*{\Mtypemember the representation class.}*/ typedef typename R::Point_d Point_d; /*{\Mtypemember the point type.}*/ typedef typename R::Hyperplane_d Hyperplane_d; /*{\Mtypemember the hyperplane type.}*/ typedef typename R::Vector_d Vector_d; typedef typename R::Ray_d Ray_d; typedef typename R::RT RT; typedef std::list Point_list; // make traits types locally available typedef typename Base::Simplex_handle Simplex_handle; /*{\Mtypemember handle for simplices.}*/ typedef typename Base::Simplex_handle Facet_handle; /*{\Mtypemember handle for facets.}*/ typedef typename Base::Vertex_handle Vertex_handle; /*{\Mtypemember handle for vertices.}*/ typedef typename Base::Simplex_iterator Simplex_iterator; /*{\Mtypemember iterator for simplices.}*/ typedef typename Base::Vertex_iterator Vertex_iterator; /*{\Mtypemember iterator for vertices.}*/ typedef Facet_iterator_ Facet_iterator; /*{\Mtypemember iterator for facets.}*/ typedef Hull_vertex_iterator_ Hull_vertex_iterator; /*{\Mtypemember iterator for vertices that are part of the convex hull.}*/ /*{\Mtext Note that each iterator fits the handle concept, i.e. iterators can be used as handles. Note also that all iterator and handle types come also in a const flavor, e.g., |Vertex_const_iterator| is the constant version of |Vertex_iterator|. Thus use the const version whenever the the convex hull object is referenced as constant.}*/ #define CGAL_USING(t) typedef typename Base::t t CGAL_USING(Simplex_const_iterator);CGAL_USING(Vertex_const_iterator); CGAL_USING(Simplex_const_handle);CGAL_USING(Vertex_const_handle); #undef CGAL_USING typedef Simplex_const_handle Facet_const_handle; typedef Facet_iterator_ Facet_const_iterator; typedef Hull_vertex_iterator_ Hull_vertex_const_iterator; typedef typename Point_list::const_iterator Point_const_iterator; /*{\Mtypemember const iterator for all inserted points.}*/ typedef typename Vertex_handle::value_type Vertex; typedef CGAL::Iterator_project< Hull_vertex_const_iterator, Point_from_Vertex, const Point_d&, const Point_d*> Hull_point_const_iterator; /*{\Mtypemember const iterator for all points of the hull.}*/ protected: Point_list all_pnts_; Vector_d quasi_center_; // sum of the vertices of origin simplex Simplex_handle origin_simplex_; // pointer to the origin simplex Facet_handle start_facet_; // pointer to some facet on the surface Vertex_handle anti_origin_; public: // until there are template friend functions possible Point_d center() const // compute center from quasi center { typename R::Vector_to_point_d to_point = kernel().vector_to_point_d_object(); return to_point(quasi_center_/RT(dcur + 1)); } const Vector_d& quasi_center() const { return quasi_center_; } Simplex_const_handle origin_simplex() const { return origin_simplex_; } Hyperplane_d base_facet_plane(Simplex_handle s) const { return s -> hyperplane_of_base_facet(); } Hyperplane_d base_facet_plane(Simplex_const_handle s) const { return s -> hyperplane_of_base_facet(); } bool& visited_mark(Simplex_handle s) const { return s->visited(); } protected: int num_of_bounded_simplices; int num_of_unbounded_simplices; int num_of_visibility_tests; int num_of_vertices; void compute_equation_of_base_facet(Simplex_handle s); /*{\Xop computes the equation of the base facet of $s$ and sets the |base_facet| member of $s$. The equation is normalized such that the origin simplex lies in the negative halfspace.}*/ bool is_base_facet_visible(Simplex_handle s, const Point_d& x) const { typename R::Has_on_positive_side_d has_on_positive_side = kernel().has_on_positive_side_d_object(); return has_on_positive_side(s->hyperplane_of_base_facet(),x); } /*{\Xop returns true if $x$ sees the base facet of $s$, i.e., lies in its positive halfspace.}*/ bool contains_in_base_facet(Simplex_handle s, const Point_d& x) const; /*{\Xop returns true if $x$ lies in the closure of the base facet of $s$.}*/ void visibility_search(Simplex_handle S, const Point_d& x, std::list& visible_simplices, int& num_of_visited_simplices, int& location, Facet_handle& f) const; /*{\Xop adds all unmarked unbounded simplices with $x$-visible base facet to |visible_simplices| and marks them. In |location| the procedure returns the position of |x| with respect to the current hull: $-1$ for inside, $0$ for on the the boundary, and $+1$ for outside; the initial value of |location| for the outermost call must be $-1$. If $x$ is contained in the boundary of |\Mvar| then a facet incident to $x$ is returned in $f$.}*/ void clear_visited_marks(Simplex_handle s) const; /*{\Xop removes the mark bits from all marked simplices reachable from $s$.}*/ void dimension_jump(Simplex_handle S, Vertex_handle x); /*{\Xop Adds a new vertex $x$ to the triangulation. The point associated with $x$ lies outside the affine hull of the current point set. }*/ void visible_facets_search(Simplex_handle S, const Point_d& x, std::list< Facet_handle >& VisibleFacets, int& num_of_visited_facets) const; public: /*{\Mcreation 3}*/ Convex_hull_d(int d, const R& Kernel = R()); /*{\Mcreate creates an instance |\Mvar| of type |\Mtype|. The dimension of the underlying space is $d$ and |S| is initialized to the empty point set. The traits class |R| specifies the models of all types and the implementations of all geometric primitives used by the convex hull class. The default model is one of the $d$-dimensional representation classes (e.g., |Homogeneous_d|).}*/ protected: /*{\Mtext The data type |\Mtype| offers neither copy constructor nor assignment operator.}*/ Convex_hull_d(const Self&); Convex_hull_d& operator=(const Self&); public: /*{\Moperations 3}*/ /*{\Mtext All operations below that take a point |x| as argument have the common precondition that |x| is a point of ambient space.}*/ int dimension() const { return Base::dimension(); } /*{\Mop returns the dimension of ambient space}*/ int current_dimension() const { return Base::current_dimension(); } /*{\Mop returns the affine dimension |dcur| of $S$.}*/ Point_d associated_point(Vertex_handle v) const { return Base::associated_point(v); } /*{\Mop returns the point associated with vertex $v$.}*/ Point_d associated_point(Vertex_const_handle v) const { return Base::associated_point(v); } Vertex_handle vertex_of_simplex(Simplex_handle s, int i) const { return Base::vertex(s,i); } /*{\Mop returns the vertex corresponding to the $i$-th vertex of $s$.\\ \precond $0 \leq i \leq |dcur|$. }*/ Vertex_const_handle vertex_of_simplex(Simplex_const_handle s, int i) const { return Base::vertex(s,i); } Point_d point_of_simplex(Simplex_handle s,int i) const { return associated_point(vertex_of_simplex(s,i)); } /*{\Mop same as |C.associated_point(C.vertex_of_simplex(s,i))|. }*/ Point_d point_of_simplex(Simplex_const_handle s,int i) const { return associated_point(vertex_of_simplex(s,i)); } Simplex_handle opposite_simplex(Simplex_handle s,int i) const { return Base::opposite_simplex(s,i); } /*{\Mop returns the simplex opposite to the $i$-th vertex of $s$ (|Simplex_handle()| if there is no such simplex). \precond $0 \leq i \leq |dcur|$. }*/ Simplex_const_handle opposite_simplex(Simplex_const_handle s,int i) const { return Base::opposite_simplex(s,i); } int index_of_vertex_in_opposite_simplex(Simplex_handle s,int i) const { return Base::index_of_opposite_vertex(s,i); } /*{\Mop returns the index of the vertex opposite to the $i$-th vertex of $s$. \precond $0 \leq i \leq |dcur|$ and there is a simplex opposite to the $i$-th vertex of $s$. }*/ int index_of_vertex_in_opposite_simplex(Simplex_const_handle s,int i) const { return Base::index_of_opposite_vertex(s,i); } Simplex_handle simplex(Vertex_handle v) const { return Base::simplex(v); } /*{\Mop returns a simplex of which $v$ is a node. Note that this simplex is not unique. }*/ Simplex_const_handle simplex(Vertex_const_handle v) const { return Base::simplex(v); } int index(Vertex_handle v) const { return Base::index(v); } /*{\Mop returns the index of $v$ in |simplex(v)|.}*/ int index(Vertex_const_handle v) const { return Base::index(v); } Vertex_handle vertex_of_facet(Facet_handle f, int i) const { return vertex_of_simplex(f,i+1); } /*{\Mop returns the vertex corresponding to the $i$-th vertex of $f$. \precond $0 \leq i < |dcur|$. }*/ Vertex_const_handle vertex_of_facet(Facet_const_handle f, int i) const { return vertex_of_simplex(f,i+1); } Point_d point_of_facet(Facet_handle f, int i) const { return point_of_simplex(f,i+1); } /*{\Mop same as |C.associated_point(C.vertex_of_facet(f,i))|.}*/ Point_d point_of_facet(Facet_const_handle f, int i) const { return point_of_simplex(f,i+1); } Facet_handle opposite_facet(Facet_handle f, int i) const { return opposite_simplex(f,i+1); } /*{\Mop returns the facet opposite to the $i$-th vertex of $f$ (|Facet_handle()| if there is no such facet). \precond $0 \leq i < |dcur|$ and |dcur > 1|. }*/ Facet_const_handle opposite_facet(Facet_const_handle f, int i) const { return opposite_simplex(f,i+1); } int index_of_vertex_in_opposite_facet(Facet_handle f, int i) const { return index_of_vertex_in_opposite_simplex(f,i+1) - 1; } /*{\Mop returns the index of the vertex opposite to the $i$-th vertex of $f$. \precond $0 \leq i < |dcur|$ and |dcur > 1|.}*/ int index_of_vertex_in_opposite_facet(Facet_const_handle f, int i) const { return index_of_vertex_in_opposite_simplex(f,i+1) - 1; } Hyperplane_d hyperplane_supporting(Facet_handle f) const { return f -> hyperplane_of_base_facet(); } /*{\Mop returns a hyperplane supporting facet |f|. The hyperplane is oriented such that the interior of |\Mvar| is on the negative side of it. \precond |f| is a facet of |\Mvar| and |dcur > 1|.}*/ Hyperplane_d hyperplane_supporting(Facet_const_handle f) const { return f -> hyperplane_of_base_facet(); } Vertex_handle insert(const Point_d& x); /*{\Mop adds point |x| to the underlying set of points. If $x$ is equal to (the point associated with) a vertex of the current hull this vertex is returned and its associated point is changed to $x$. If $x$ lies outside the current hull, a new vertex |v| with associated point $x$ is added to the hull and returned. In all other cases, i.e., if $x$ lies in the interior of the hull or on the boundary but not on a vertex, the current hull is not changed and |Vertex_handle()| is returned. If |CGAL_CHECK_EXPENSIVE| is defined then the validity check |is_valid(true)| is executed as a post condition.}*/ template void insert(Forward_iterator first, Forward_iterator last) { while (first != last) insert(*first++); } /*{\Mop adds |S = set [first,last)| to the underlying set of points. If any point |S[i]| is equal to (the point associated with) a vertex of the current hull its associated point is changed to |S[i]|.}*/ bool is_dimension_jump(const Point_d& x) const /*{\Mop returns true if $x$ is not contained in the affine hull of |S|.}*/ { if (current_dimension() == dimension()) return false; typename R::Contained_in_affine_hull_d contained_in_affine_hull = kernel().contained_in_affine_hull_d_object(); return ( !contained_in_affine_hull(origin_simplex_->points_begin(), origin_simplex_->points_begin()+current_dimension()+1,x) ); } std::list facets_visible_from(const Point_d& x); /*{\Mop returns the list of all facets that are visible from |x|.\\ \precond |x| is contained in the affine hull of |S|.}*/ Bounded_side bounded_side(const Point_d& x); /*{\Mop returns |ON_BOUNDED_SIDE| (|ON_BOUNDARY|,|ON_UNBOUNDED_SIDE|) if |x| is contained in the interior (lies on the boundary, is contained in the exterior) of |\Mvar|. \precond |x| is contained in the affine hull of |S|.}*/ bool is_unbounded_simplex(Simplex_handle S) const { return vertex_of_simplex(S,0) == anti_origin_; } bool is_unbounded_simplex(Simplex_const_handle S) const { return vertex_of_simplex(S,0) == anti_origin_; } bool is_bounded_simplex(Simplex_handle S) const { return vertex_of_simplex(S,0) != anti_origin_; } bool is_bounded_simplex(Simplex_const_handle S) const { return vertex_of_simplex(S,0) != anti_origin_; } void clear(int d) /*{\Mop reinitializes |\Mvar| to an empty hull in $d$-dimensional space.}*/ { typename R::Construct_vector_d create = kernel().construct_vector_d_object(); quasi_center_ = create(d,NULL_VECTOR); anti_origin_ = Vertex_handle(); origin_simplex_ = Simplex_handle(); all_pnts_.clear(); Base::clear(d); num_of_vertices = 0; num_of_unbounded_simplices = num_of_bounded_simplices = 0; num_of_visibility_tests = 0; } int number_of_vertices() const /*{\Mop returns the number of vertices of |\Mvar|.}*/ { return num_of_vertices; } int number_of_facets() const /*{\Mop returns the number of facets of |\Mvar|.}*/ { return num_of_unbounded_simplices; } int number_of_simplices() const /*{\Mop returns the number of bounded simplices of |\Mvar|.}*/ { return num_of_bounded_simplices; } void print_statistics() /*{\Mop gives information about the size of the current hull and the number of visibility tests performed.}*/ { std::cout << "Convex_hull_d (" << current_dimension() << "/" << dimension() << ") - statistic" << std::endl; std::cout<<" # points = " << all_pnts_.size() << std::endl; std::cout<<" # vertices = " << num_of_vertices << std::endl; std::cout<<" # unbounded simplices = " << num_of_unbounded_simplices << std::endl; std::cout<<" # bounded simplices = " << num_of_bounded_simplices << std::endl; std::cout<<" # visibility tests = " << num_of_visibility_tests << std::endl; } class chull_has_double_coverage {}; class chull_has_local_non_convexity {}; class chull_has_center_on_wrong_side_of_hull_facet {}; bool is_valid(bool throw_exceptions = false) const; /*{\Mop checks the validity of the data structure. If |throw_exceptions == thrue| then the program throws the following exceptions to inform about the problem.\\ [[chull_has_center_on_wrong_side_of_hull_facet]] the hyperplane supporting a facet has the wrong orientation.\\ [[chull_has_local_non_convexity]] a ridge is locally non convex.\\ [[chull_has_double_coverage]] the hull has a winding number larger than 1. }*/ template void initialize(Forward_iterator first, Forward_iterator last) /*{\Xop initializes the complex with the set |S = set [first,last)|. The initialization uses the quickhull approach.}*/ { CGAL_assertion(current_dimension()==-1); Vertex_handle z; Forward_iterator it(first); std::list< Point_d > OtherPoints; typename std::list< Point_d >::iterator pit, pred; while ( it != last ) { Point_d x = *it++; if ( current_dimension() == -1 ) { Simplex_handle outer_simplex; // a pointer to the outer simplex dcur = 0; // we jump from dimension - 1 to dimension 0 origin_simplex_ = new_simplex(); num_of_bounded_simplices ++; outer_simplex = new_simplex(); num_of_unbounded_simplices ++; start_facet_ = origin_simplex_; z = new_vertex(x); num_of_vertices ++; associate_vertex_with_simplex(origin_simplex_,0,z); // z is the only point and the peak associate_vertex_with_simplex(outer_simplex,0,anti_origin_); set_neighbor(origin_simplex_,0,outer_simplex,0); typename R::Point_to_vector_d to_vector = kernel().point_to_vector_d_object(); quasi_center_ = to_vector(x); } else if ( is_dimension_jump(x) ) { dcur++; z = new_vertex(x); num_of_vertices++; typename R::Point_to_vector_d to_vector = kernel().point_to_vector_d_object(); quasi_center_ = quasi_center_ + to_vector(x); dimension_jump(origin_simplex_, z); clear_visited_marks(origin_simplex_); Simplex_iterator S; forall_rc_simplices(S,*this) compute_equation_of_base_facet(S); num_of_unbounded_simplices += num_of_bounded_simplices; if (dcur > 1) { start_facet_ = opposite_simplex(origin_simplex_,dcur); CGAL_assertion(vertex_of_simplex(start_facet_,0)==Vertex_handle()); } } else { OtherPoints.push_back(x); } } all_pnts_.insert(all_pnts_.end(),first,last); // what is the point of this line? ... //int dcur = current_dimension(); Unique_hash_map > PointsOf; std::list FacetCandidates; typename R::Oriented_side_d side_of = kernel().oriented_side_d_object(); for (int i=0; i<=dcur; ++i) { Simplex_handle f = opposite_simplex(origin_simplex_,i); Hyperplane_d h = f->hyperplane_of_base_facet(); std::list& L = PointsOf[f]; pit = OtherPoints.begin(); while ( pit != OtherPoints.end() ) { if ( side_of(h,*pit) == ON_POSITIVE_SIDE ) { L.push_back(*pit); pred=pit; ++pit; OtherPoints.erase(pred); } else ++pit; // not above h } if ( !L.empty() ) FacetCandidates.push_back(f); } OtherPoints.clear(); while ( !FacetCandidates.empty() ) { Facet_handle f = *FacetCandidates.begin(); FacetCandidates.pop_front(); Hyperplane_d h = f->hyperplane_of_base_facet(); std::list& L = PointsOf[f]; if (L.empty()) { CGAL_assertion( is_bounded_simplex(f) ); continue; } Point_d p = *L.begin(); typename R::Value_at_d value_at = kernel().value_at_d_object(); RT maxdist = value_at(h,p), dist; for (pit = ++L.begin(); pit != L.end(); ++pit) { dist = value_at(h,*pit); if ( dist > maxdist ) { maxdist = dist; p = *pit; } } num_of_visibility_tests += L.size(); int num_of_visited_facets = 0; std::list VisibleFacets; VisibleFacets.push_back(f); visible_facets_search(f, p, VisibleFacets, num_of_visited_facets); num_of_visibility_tests += num_of_visited_facets; num_of_bounded_simplices += VisibleFacets.size(); clear_visited_marks(f); ++num_of_vertices; Vertex_handle z = new_vertex(p); std::list NewSimplices; typename std::list::iterator it; CGAL_assertion(OtherPoints.empty()); for (it = VisibleFacets.begin(); it != VisibleFacets.end(); ++it) { OtherPoints.splice(OtherPoints.end(),PointsOf[*it]); Facet_handle S = *it; associate_vertex_with_simplex(S,0,z); for (int k = 1; k <= dcur; ++k) { if (!is_base_facet_visible(opposite_simplex(S,k),p)) { Simplex_handle T = new_simplex(); NewSimplices.push_back(T); /* set the vertices of T as described above */ for (int i = 1; i < dcur; i++) { if ( i != k ) associate_vertex_with_simplex(T,i,vertex_of_simplex(S,i)); } if (k != dcur) associate_vertex_with_simplex(T,k,vertex_of_simplex(S,dcur)); associate_vertex_with_simplex(T,dcur,z); associate_vertex_with_simplex(T,0,anti_origin_); /* in the above, it is tempting to drop the tests ( i != k ) and ( k != dcur ) since the subsequent lines after will correct the erroneous assignment. This reasoning is fallacious as the procedure assoc_vertex_with_simplex also the internal data of the third argument. */ /* compute the equation of its base facet */ compute_equation_of_base_facet(T); /* record adjacency information for the two known neighbors */ set_neighbor(T,dcur,opposite_simplex(S,k), index_of_vertex_in_opposite_simplex(S,k)); set_neighbor(T,0,S,k); } } } num_of_unbounded_simplices -= VisibleFacets.size(); if ( vertex_of_simplex(start_facet_,0) != Vertex_handle() ) start_facet_ = *(--NewSimplices.end()); CGAL_assertion( vertex_of_simplex(start_facet_,0)==Vertex_handle() ); for (it = NewSimplices.begin(); it != NewSimplices.end(); ++it) { Simplex_handle Af = *it; for (int k = 1; k < dcur ; k++) { // neighbors 0 and dcur are already known if (opposite_simplex(Af,k) == Simplex_handle()) { // we have not performed the walk in the opposite direction yet Simplex_handle T = opposite_simplex(Af,0); int y1 = 0; while ( vertex_of_simplex(T,y1) != vertex_of_simplex(Af,k) ) y1++; // exercise: show that we can also start with y1 = 1 int y2 = index_of_vertex_in_opposite_simplex(Af,0); while ( vertex_of_simplex(T,0) == z ) { // while T has peak x do find new y_1 */ int new_y1 = 0; while (vertex_of_simplex(opposite_simplex(T,y1),new_y1) != vertex_of_simplex(T,y2)) new_y1++; // exercise: show that we can also start with new_y1 = 1 y2 = index_of_vertex_in_opposite_simplex(T,y1); T = opposite_simplex(T,y1); y1 = new_y1; } set_neighbor(Af,k,T,y1); // update adjacency information } } } for (it = NewSimplices.begin(); it != NewSimplices.end(); ++it) { Facet_handle f = *it; CGAL_assertion( is_unbounded_simplex(f) ); Hyperplane_d h = f->hyperplane_of_base_facet(); std::list& L = PointsOf[f]; pit = OtherPoints.begin(); while ( pit != OtherPoints.end() ) { if ( side_of(h,*pit) == ON_POSITIVE_SIDE ) { L.push_back(*pit); pred=pit; ++pit; OtherPoints.erase(pred); } else ++pit; // not above h } if ( !L.empty() ) FacetCandidates.push_back(f); } OtherPoints.clear(); } #ifdef CGAL_CHECK_EXPENSIVE CGAL_assertion(is_valid(true)); #endif } /*{\Mtext \headerline{Lists and Iterators} \setopdims{3.5cm}{3.5cm}}*/ Vertex_iterator vertices_begin() { return Base::vertices_begin(); } /*{\Mop returns an iterator to start iteration over all vertices of |\Mvar|.}*/ Vertex_iterator vertices_end() { return Base::vertices_end(); } /*{\Mop the past the end iterator for vertices.}*/ Simplex_iterator simplices_begin() { return Base::simplices_begin(); } /*{\Mop returns an iterator to start iteration over all simplices of |\Mvar|.}*/ Simplex_iterator simplices_end() { return Base::simplices_end(); } /*{\Mop the past the end iterator for simplices.}*/ Facet_iterator facets_begin() { return Facet_iterator(this,start_facet_); } /*{\Mop returns an iterator to start iteration over all facets of |\Mvar|.}*/ Facet_iterator facets_end() { return Facet_iterator(); } /*{\Mop the past the end iterator for facets.}*/ Hull_vertex_iterator hull_vertices_begin() { return Hull_vertex_iterator(this,facets_begin()); } /*{\Mop returns an iterator to start iteration over all hull vertex of |\Mvar|. Remember that the hull is a simplicial complex.}*/ Hull_vertex_iterator hull_vertices_end() { return Hull_vertex_iterator(); } /*{\Mop the past the end iterator for hull vertices.}*/ Point_const_iterator points_begin() const { return all_pnts_.begin(); } /*{\Mop returns the start iterator for all points that have been inserted to construct |\Mvar|.}*/ Point_const_iterator points_end() const { return all_pnts_.end(); } /*{\Mop returns the past the end iterator for all points.}*/ Hull_point_const_iterator hull_points_begin() const { return Hull_point_const_iterator(hull_vertices_begin()); } /*{\Mop returns an iterator to start iteration over all inserted points that are part of the convex hull |\Mvar|. Remember that the hull is a simplicial complex.}*/ Hull_point_const_iterator hull_points_end() const { return Hull_point_const_iterator(hull_vertices_end()); } /*{\Mop returns the past the end iterator for points of the hull.}*/ Vertex_const_iterator vertices_begin() const { return Base::vertices_begin(); } Vertex_const_iterator vertices_end() const { return Base::vertices_end(); } Simplex_const_iterator simplices_begin() const { return Base::simplices_begin(); } Simplex_const_iterator simplices_end() const { return Base::simplices_end(); } Facet_const_iterator facets_begin() const { return Facet_const_iterator(this,start_facet_); } Facet_const_iterator facets_end() const { return Facet_const_iterator(); } Hull_vertex_const_iterator hull_vertices_begin() const { return Hull_vertex_const_iterator(this,facets_begin()); } Hull_vertex_const_iterator hull_vertices_end() const { return Hull_vertex_const_iterator(); } /* We distinguish cases according to the current dimension. If the dimension is less than one then the hull has no facets, if the dimension is one then the hull has two facets which we extract by a scan through the set of all simplices, and if the hull has dimension at least two the boundary is a connected set and we construct the list of facets by depth first search starting at |start_facet_|.*/ /*{\Mtext\setopdims{5.5cm}{3.5cm}}*/ template void visit_all_facets(const Visitor& V) const /*{\Mop each facet of |\Mvar| is visited by the visitor object |V|. |V| has to have a function call operator:\\ |void operator()(Facet_handle) const|}*/ { if (current_dimension() > 1) { Unique_hash_map visited(false); std::list candidates; candidates.push_back(start_facet_); visited[start_facet_] = true; Facet_handle current; while ( !candidates.empty() ) { current = *(candidates.begin()); candidates.pop_front(); CGAL_assertion(vertex_of_simplex(current,0)==Vertex_handle()); V(current); for(int i = 1; i <= dcur; ++i) { Facet_handle f = opposite_simplex(current,i); if ( !visited[f] ) { candidates.push_back(f); visited[f] = true; } } } } else if ( current_dimension() == 1 ) { V(start_facet_); } } const std::list& all_points() const /*{\Mop returns a list of all points in |\Mvar|.}*/ { return all_pnts_; } std::list all_vertices() /*{\Mop returns a list of all vertices of |\Mvar| (also interior ones).}*/ { return Base::all_vertices(); } std::list all_vertices() const { return Base::all_vertices(); } std::list all_simplices() /*{\Mop returns a list of all simplices in |\Mvar|.}*/ { return Base::all_simplices(); } std::list all_simplices() const { return Base::all_simplices(); } std::list all_facets() /*{\Mop returns a list of all facets of |\Mvar|.}*/ { std::list L; list_collector visitor(L); visit_all_facets(visitor); return L; } std::list all_facets() const { std::list L; list_collector visitor(L); visit_all_facets(visitor); return L; } #define forall_ch_vertices(x,CH)\ for(x = (CH).vertices_begin(); x != (CH).vertices_end(); ++x) #define forall_ch_simplices(x,CH)\ for(x = (CH).simplices_begin(); x != (CH).simplices_end(); ++x) #define forall_ch_facets(x,CH)\ for(x = (CH).facets_begin(); x != (CH).facets_end(); ++x) /*{\Mtext \headerline{Iteration Statements} {\bf forall\_ch\_vertices}($v,C$) $\{$ ``the vertices of $C$ are successively assigned to $v$'' $\}$ {\bf forall\_ch\_simplices}($s,C$) $\{$ ``the simplices of $C$ are successively assigned to $s$'' $\}$ {\bf forall\_ch\_facets}($f,C$) $\{$ ``the facets of $C$ are successively assigned to $f$'' $\}$ }*/ /*{\Mimplementation The implementation of type |\Mtype| is based on \cite{cms:fourresults} and \cite{BMS:degeneracy}. The details of the implementation can be found in the implementation document available at the download site of this package. The time and space requirements are input dependent. Let $C_1$, $C_2$, $C_3$, \ldots be the sequence of hulls constructed and for a point $x$ let $k_i$ be the number of facets of $C_i$ that are visible from $x$ and that are not already facets of $C_{i-1}$. Then the time for inserting $x$ is $O(|dim| \sum_i k_i)$ and the number of new simplices constructed during the insertion of $x$ is the number of facets of the hull which were not already facets of the hull before the insertion. The data type |\Mtype| is derived from |Regular_complex_d|. The space requirement of regular complexes is essentially $12(|dim| +2)$ bytes times the number of simplices plus the space for the points. |\Mtype| needs an additional $8 + (4 + x)|dim|$ bytes per simplex where $x$ is the space requirement of the underlying number type and an additional $12$ bytes per point. The total is therefore $(16 + x)|dim| + 32$ bytes times the number of simplices plus $28 + x \cdot |dim|$ bytes times the number of points.}*/ /*{\Mtext\headerline{Traits requirements} |\Mname| requires the following types from the kernel traits |R|: \begin{Mverb} Point_d Vector_d Ray_d Hyperplane_d \end{Mverb} and uses the following function objects from the kernel traits: \begin{Mverb} Construct_vector_d Construct_hyperplane_d Vector_to_point_d / Point_to_vector_d Orientation_d Orthogonal_vector_d Oriented_side_d / Has_on_positive_side_d Affinely_independent_d Contained_in_simplex_d Contained_in_affine_hull_d Intersect_d \end{Mverb} }*/ }; // Convex_hull_d template Convex_hull_d::Convex_hull_d(int d, const R& Kernel) : Base(d,Kernel) { origin_simplex_ = Simplex_handle(); start_facet_ = Facet_handle(); anti_origin_ = Vertex_handle(); num_of_vertices = 0; num_of_unbounded_simplices = num_of_bounded_simplices = 0; num_of_visibility_tests = 0; typename R::Construct_vector_d create = kernel().construct_vector_d_object(); quasi_center_ = create(d,NULL_VECTOR); } template bool Convex_hull_d:: contains_in_base_facet(Simplex_handle s, const Point_d& x) const { typename R::Contained_in_simplex_d contained_in_simplex = kernel().contained_in_simplex_d_object(); return contained_in_simplex(s->points_begin()+1, s->points_begin()+current_dimension()+1,x); } template void Convex_hull_d:: compute_equation_of_base_facet(Simplex_handle S) { typename R::Construct_hyperplane_d hyperplane_through_points = kernel().construct_hyperplane_d_object(); S->set_hyperplane_of_base_facet( hyperplane_through_points( S->points_begin()+1, S->points_begin()+1+current_dimension(), center(), ON_NEGATIVE_SIDE)); // skip the first point ! #ifdef CGAL_CHECK_EXPENSIVE { /* Let us check */ typename R::Oriented_side_d side = kernel().oriented_side_d_object(); for (int i = 1; i <= current_dimension(); i++) CGAL_assertion_msg(side(S->hyperplane_of_base_facet(), point_of_simplex(S,i)) == ON_ORIENTED_BOUNDARY, " hyperplane does not support base "); CGAL_assertion_msg(side(S->hyperplane_of_base_facet(),center()) == ON_NEGATIVE_SIDE, " hyperplane has quasi center on wrong side "); } #endif } template typename Convex_hull_d::Vertex_handle Convex_hull_d::insert(const Point_d& x) { Vertex_handle z = Vertex_handle(); all_pnts_.push_back(x); if (current_dimension() == -1) { Simplex_handle outer_simplex; // a pointer to the outer simplex dcur = 0; // we jump from dimension - 1 to dimension 0 origin_simplex_ = new_simplex(); num_of_bounded_simplices ++; outer_simplex = new_simplex(); num_of_unbounded_simplices ++; start_facet_ = origin_simplex_; z = new_vertex(x); num_of_vertices ++; associate_vertex_with_simplex(origin_simplex_,0,z); // z is the only point and the peak associate_vertex_with_simplex(outer_simplex,0,anti_origin_); set_neighbor(origin_simplex_,0,outer_simplex,0); typename R::Point_to_vector_d to_vector = kernel().point_to_vector_d_object(); quasi_center_ = to_vector(x); } else if ( is_dimension_jump(x) ) { dcur++; z = new_vertex(x); num_of_vertices++; typename R::Point_to_vector_d to_vector = kernel().point_to_vector_d_object(); quasi_center_ = quasi_center_ + to_vector(x); dimension_jump(origin_simplex_, z); clear_visited_marks(origin_simplex_); Simplex_iterator S; forall_rc_simplices(S,*this) compute_equation_of_base_facet(S); num_of_unbounded_simplices += num_of_bounded_simplices; if (dcur > 1) { start_facet_ = opposite_simplex(origin_simplex_,dcur); CGAL_assertion(vertex_of_simplex(start_facet_,0)==Vertex_handle()); } } else { if ( current_dimension() == 0 ) { z = vertex_of_simplex(origin_simplex_,0); associate_point_with_vertex(z,x); return z; } std::list visible_simplices; int location = -1; Facet_handle f; int num_of_visited_simplices = 0; visibility_search(origin_simplex_, x, visible_simplices, num_of_visited_simplices, location, f); num_of_visibility_tests += num_of_visited_simplices; #ifdef COUNTS cout << "\nthe number of visited simplices in this iteration is "; cout << num_of_visited_simplices << endl; #endif clear_visited_marks(origin_simplex_); #ifdef COUNTS cout << "\nthe number of bounded simplices constructed "; cout << " in this iteration is " << visible_simplices.size() << endl; #endif num_of_bounded_simplices += visible_simplices.size(); switch (location) { case -1: return Vertex_handle(); case 0: { for (int i = 0; i < current_dimension(); i++) { if ( x == point_of_facet(f,i) ) { z = vertex_of_facet(f,i); associate_point_with_vertex(z,x); return z; } } return Vertex_handle(); } case 1: { num_of_vertices++; z = new_vertex(x); std::list NewSimplices; // list of new simplices typename std::list::iterator it; for (it = visible_simplices.begin(); it != visible_simplices.end(); ++it) { Simplex_handle S = *it; associate_vertex_with_simplex(S,0,z); for (int k = 1; k <= dcur; k++) { if (!is_base_facet_visible(opposite_simplex(S,k),x)) { Simplex_handle T = new_simplex(); NewSimplices.push_back(T); /* set the vertices of T as described above */ for (int i = 1; i < dcur; i++) { if ( i != k ) associate_vertex_with_simplex(T,i,vertex_of_simplex(S,i)); } if (k != dcur) associate_vertex_with_simplex(T,k,vertex_of_simplex(S,dcur)); associate_vertex_with_simplex(T,dcur,z); associate_vertex_with_simplex(T,0,anti_origin_); /* in the above, it is tempting to drop the tests ( i != k ) and ( k != dcur ) since the subsequent lines after will correct the erroneous assignment. This reasoning is fallacious as the procedure assoc_vertex_with_simplex also the internal data of the third argument. */ /* compute the equation of its base facet */ compute_equation_of_base_facet(T); /* record adjacency information for the two known neighbors */ set_neighbor(T,dcur,opposite_simplex(S,k), index_of_vertex_in_opposite_simplex(S,k)); set_neighbor(T,0,S,k); } } } num_of_unbounded_simplices -= visible_simplices.size(); if ( vertex_of_simplex(start_facet_,0) != Vertex_handle() ) start_facet_ = *(--NewSimplices.end()); CGAL_assertion( vertex_of_simplex(start_facet_,0)==Vertex_handle() ); for (it = NewSimplices.begin(); it != NewSimplices.end(); ++it) { Simplex_handle Af = *it; for (int k = 1; k < dcur ; k++) { // neighbors 0 and dcur are already known if (opposite_simplex(Af,k) == Simplex_handle()) { // we have not performed the walk in the opposite direction yet Simplex_handle T = opposite_simplex(Af,0); int y1 = 0; while ( vertex_of_simplex(T,y1) != vertex_of_simplex(Af,k) ) y1++; // exercise: show that we can also start with y1 = 1 int y2 = index_of_vertex_in_opposite_simplex(Af,0); while ( vertex_of_simplex(T,0) == z ) { // while T has peak x do find new y_1 */ int new_y1 = 0; while (vertex_of_simplex(opposite_simplex(T,y1),new_y1) != vertex_of_simplex(T,y2)) new_y1++; // exercise: show that we can also start with new_y1 = 1 y2 = index_of_vertex_in_opposite_simplex(T,y1); T = opposite_simplex(T,y1); y1 = new_y1; } set_neighbor(Af,k,T,y1); // update adjacency information } } } } } } #ifdef CGAL_CHECK_EXPENSIVE CGAL_assertion(is_valid(true)); #endif return z; } template void Convex_hull_d:: visibility_search(Simplex_handle S, const Point_d& x, std::list< Simplex_handle >& visible_simplices, int& num_of_visited_simplices, int& location, Simplex_handle& f) const { num_of_visited_simplices ++; S->visited() = true; // we have visited S and never come back ... for(int i = 0; i <= current_dimension(); ++i) { Simplex_handle T = opposite_simplex(S,i); // for all neighbors T of S if ( !T->visited() ) { typename R::Oriented_side_d side_of = kernel().oriented_side_d_object(); int side = side_of(T->hyperplane_of_base_facet(),x); if ( is_unbounded_simplex(T) ) { if ( side == ON_POSITIVE_SIDE ) { // T is an unbounded simplex with x-visible base facet visible_simplices.push_back(T); location = 1; } if ( side == ON_ORIENTED_BOUNDARY && location == -1 && contains_in_base_facet(T,x) ) { location = 0; f = T; return; } } if ( side == ON_POSITIVE_SIDE || (side == ON_ORIENTED_BOUNDARY && location == -1) ) { visibility_search(T,x,visible_simplices, num_of_visited_simplices,location,f); // do the recursive search } } // end visited else { } } // end for } template void Convex_hull_d::clear_visited_marks(Simplex_handle S) const { S->visited() = false; // clear the visit - bit for(int i = 0; i <= current_dimension(); i++) // for all neighbors of S if (opposite_simplex(S,i)->visited()) // if the i - th neighbor has been visited clear_visited_marks(opposite_simplex(S,i)); // clear its bit recursively } template std::list< typename Convex_hull_d::Simplex_handle > Convex_hull_d::facets_visible_from(const Point_d& x) { std::list visible_simplices; int location = -1; // intialization is important int num_of_visited_simplices = 0; // irrelevant Facet_handle f; // irrelevant visibility_search(origin_simplex_, x, visible_simplices, num_of_visited_simplices, location, f); clear_visited_marks(origin_simplex_); return visible_simplices; } template Bounded_side Convex_hull_d::bounded_side(const Point_d& x) { if ( is_dimension_jump(x) ) return ON_UNBOUNDED_SIDE; std::list visible_simplices; int location = -1; // intialization is important int num_of_visited_simplices = 0; // irrelevant Facet_handle f; visibility_search(origin_simplex_, x, visible_simplices, num_of_visited_simplices, location, f); clear_visited_marks(origin_simplex_); switch (location) { case -1: return ON_BOUNDED_SIDE; case 0: return ON_BOUNDARY; case 1: return ON_UNBOUNDED_SIDE; } CGAL_assertion(0); return ON_BOUNDARY; // never come here } template void Convex_hull_d:: dimension_jump(Simplex_handle S, Vertex_handle x) { Simplex_handle S_new; S->visited() = true; associate_vertex_with_simplex(S,dcur,x); if ( !is_unbounded_simplex(S) ) { // S is bounded S_new = new_simplex(); set_neighbor(S,dcur,S_new,0); associate_vertex_with_simplex(S_new,0,anti_origin_); for (int k = 1; k <= dcur; k++) { associate_vertex_with_simplex(S_new,k,vertex_of_simplex(S,k-1)); } } /* visit unvisited neighbors 0 to dcur - 1 */ for (int k = 0; k <= dcur - 1; k++) { if ( !opposite_simplex(S,k) -> visited() ) { dimension_jump(opposite_simplex(S,k), x); } } /* the recursive calls ensure that all neighbors exist */ if ( is_unbounded_simplex(S) ) { set_neighbor(S,dcur,opposite_simplex(opposite_simplex(S,0),dcur), index_of_vertex_in_opposite_simplex(S,0) + 1); } else { for (int k = 0; k < dcur; k++) { if ( is_unbounded_simplex(opposite_simplex(S,k)) ) { // if F' is unbounded set_neighbor(S_new,k + 1,opposite_simplex(S,k),dcur); // the neighbor of S_new opposite to v is S' and // x is in position dcur } else { // F' is bounded set_neighbor(S_new,k + 1,opposite_simplex(opposite_simplex(S,k),dcur), index_of_vertex_in_opposite_simplex(S,k) + 1); // neighbor of S_new opposite to v is S_new' // the vertex opposite to v remains the same but ... // remember the shifting of the vertices one step to the right } } } } template bool Convex_hull_d::is_valid(bool throw_exceptions) const { this->check_topology(); if (current_dimension() < 1) return true; /* Recall that center() gives us the center-point of the origin simplex. We check whether it is locally inside with respect to all hull facets. */ typename R::Oriented_side_d side = kernel().oriented_side_d_object(); Point_d centerpoint = center(); Simplex_const_iterator S; forall_rc_simplices(S,*this) { if ( is_unbounded_simplex(S) && side(S->hyperplane_of_base_facet(),centerpoint) != ON_NEGATIVE_SIDE) { if (throw_exceptions) throw chull_has_center_on_wrong_side_of_hull_facet(); return false; } } /* next we check convexity at every ridge. Let |S| be any hull simplex and let |v| be any vertex of its base facet. The vertex opposite to |v| must not be on the positive side of the base facet.*/ forall_rc_simplices(S,*this) { if ( is_unbounded_simplex(S) ) { for (int i = 1; i <= dcur; i++) { int k = index_of_vertex_in_opposite_simplex(S,i); if (side(S->hyperplane_of_base_facet(), point_of_simplex(opposite_simplex(S,i),k)) == ON_POSITIVE_SIDE) { if (throw_exceptions) throw chull_has_local_non_convexity(); return false; } } } } /* next we select one hull facet */ Simplex_const_handle selected_hull_simplex; forall_rc_simplices(S,*this) { if ( is_unbounded_simplex(S) ) { selected_hull_simplex = S; break; } } /* we compute the center of gravity of the base facet of the hull simplex */ typename R::Point_to_vector_d to_vector = kernel().point_to_vector_d_object(); typename R::Vector_to_point_d to_point = kernel().vector_to_point_d_object(); typename R::Construct_vector_d create = kernel().construct_vector_d_object(); Vector_d center_of_hull_facet = create(dimension(),NULL_VECTOR); for (int i = 1; i <= current_dimension(); i++) { center_of_hull_facet = center_of_hull_facet + to_vector(point_of_simplex(selected_hull_simplex,i)); } Point_d center_of_hull_facet_point = to_point(center_of_hull_facet/RT(dcur)); /* we set up the ray from the center to the center of the hull facet */ Ray_d l(centerpoint, center_of_hull_facet_point); /* and check whether it intersects the interior of any hull facet */ typename R::Contained_in_simplex_d contained_in_simplex = kernel().contained_in_simplex_d_object(); typename R::Intersect_d intersect = kernel().intersect_d_object(); forall_rc_simplices(S,*this) { if ( is_unbounded_simplex(S) && S != selected_hull_simplex ) { Point_d p; Object op; Hyperplane_d h = S->hyperplane_of_base_facet(); if ( (op = intersect(l,h), assign(p,op)) ) { if ( contained_in_simplex(S->points_begin()+1, S->points_begin()+1+current_dimension(),p) ) { if ( throw_exceptions ) throw chull_has_double_coverage(); return false; } } } } return true; } template void Convex_hull_d:: visible_facets_search(Simplex_handle S, const Point_d& x, std::list< Facet_handle >& VisibleFacets, int& num_of_visited_facets) const { ++num_of_visited_facets; S->visited() = true; // we have visited S and never come back ... for(int i = 1; i <= current_dimension(); ++i) { Simplex_handle T = opposite_simplex(S,i); // for all neighbors T of S if ( !T->visited() ) { typename R::Oriented_side_d side_of = kernel().oriented_side_d_object(); int side = side_of(T->hyperplane_of_base_facet(),x); CGAL_assertion( is_unbounded_simplex(T) ); if ( side == ON_POSITIVE_SIDE ) { VisibleFacets.push_back(T); visible_facets_search(T,x,VisibleFacets,num_of_visited_facets); // do the recursive search } } // end visited } // end for } CGAL_END_NAMESPACE #endif // CGAL_CONVEX_HULL_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_predicate.h0000644000175000017500000002626111344301500030756 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_predicate.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_FILTER_PREDICATE_H #define CGAL_FILTER_PREDICATE_H #include #include CGAL_BEGIN_NAMESPACE // This template class is a wrapper that implements the filtering for any // predicate (dynamic filters with IA). // TODO : // - We should specialize it for the static filters versions when possible... // - each predicate in the default kernel should define a tag that says if it // wants to be filtered or not (=> all homogeneous predicate define this // tag). We could even test-suite that automatically. It makes a strong // new requirement on the kernel though... // Could be done with a traits mecanism ? // A default template could use the current IA, but other tags or whatever // could specify no filtering at all, or static filtering... // - same thing for constructions => virtual operator() ? // - similarly, constructions should have a tag saying if they can throw or // not, or we let all this up to the compiler optimizer to figure out ? // - Some caching should be done at the Point_2 level. template class Filtered_predicate { EP Exact_predicate; AP Approx_predicate; C2E To_Exact; C2F To_Approx; public: typedef typename AP::result_type result_type; typedef typename AP::Arity Arity; // Should be the same type as EP::result_type. Filtered_predicate() {} // These constructors are used for constructive predicates. // You should try to avoid constructive predicates, as they will construct // the exact values systematically (in the ctor), rather than lazily. template Filtered_predicate(const O &o1) : Exact_predicate(To_Exact(o1)), Approx_predicate(To_Approx(o1)) {} template Filtered_predicate(const O &o1, const O &o2) : Exact_predicate(To_Exact(o1), To_Exact(o2)), Approx_predicate(To_Approx(o1), To_Approx(o2)) {} template result_type operator()(const A1 &a1) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1)); } } #endif template result_type operator()(const A1 &a1, const A2 &a2) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2)); } } #endif template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3)); } } #endif template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4)); } } #endif template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5)); } } #endif template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5), To_Approx(a6)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5), To_Exact(a6)); } } #endif template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7) const #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG ; #else { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5), To_Approx(a6), To_Approx(a7)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5), To_Exact(a6), To_Exact(a7)); } } #endif // Idem for more than 7 arguments. Do it on demand. }; #ifndef CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG template template typename Filtered_predicate::result_type Filtered_predicate:: operator()(const A1 &a1) const { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1)); } } template template typename Filtered_predicate::result_type Filtered_predicate:: operator()(const A1 &a1, const A2 &a2) const { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2)); } } template template typename Filtered_predicate::result_type Filtered_predicate:: operator()(const A1 &a1, const A2 &a2, const A3 &a3) const { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3)); } } template template typename Filtered_predicate::result_type Filtered_predicate:: operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4)); } } template template typename Filtered_predicate::result_type Filtered_predicate:: operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5)); } } template template typename Filtered_predicate::result_type Filtered_predicate:: operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6) const { try { Protect_FPU_rounding P; return Approx_predicate(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5), To_Approx(a6)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_predicate(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5), To_Exact(a6)); } } #endif CGAL_END_NAMESPACE #endif // CGAL_FILTER_PREDICATE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/double.h0000644000175000017500000000733611344301500026454 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/double.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_DOUBLE_H #define CGAL_DOUBLE_H #include #include #include #ifdef CGAL_CFG_IEEE_754_BUG # include #endif #ifdef __sgi # include #endif CGAL_BEGIN_NAMESPACE template<> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; inline const double & to_double(const double & d) { return d; } inline std::pair to_interval(double d) { return std::make_pair(d,d);} inline double sqrt(double d) { return std::sqrt(d); } #ifdef __sgi inline bool is_finite(double d) { switch (fp_class_d(d)) { case FP_POS_NORM: case FP_NEG_NORM: case FP_POS_ZERO: case FP_NEG_ZERO: case FP_POS_DENORM: case FP_NEG_DENORM: return true; case FP_SNAN: case FP_QNAN: case FP_POS_INF: case FP_NEG_INF: return false; } return false; // NOT REACHED } inline bool is_valid(double d) { switch (fp_class_d(d)) { case FP_POS_NORM: case FP_NEG_NORM: case FP_POS_ZERO: case FP_NEG_ZERO: case FP_POS_INF: case FP_NEG_INF: case FP_POS_DENORM: case FP_NEG_DENORM: return true; case FP_SNAN: case FP_QNAN: return false; } return false; // NOT REACHED } #elif defined CGAL_CFG_IEEE_754_BUG #define CGAL_EXPONENT_DOUBLE_MASK 0x7ff00000 #define CGAL_MANTISSA_DOUBLE_MASK 0x000fffff inline bool is_finite_by_mask_double(unsigned int h) { unsigned int e = h & CGAL_EXPONENT_DOUBLE_MASK; return ( ( e ^ CGAL_EXPONENT_DOUBLE_MASK ) != 0 ); } inline bool is_nan_by_mask_double(unsigned int h, unsigned int l) { if ( is_finite_by_mask_double(h) ) return false; return (( h & CGAL_MANTISSA_DOUBLE_MASK ) != 0) || (( l & 0xffffffff ) != 0); } inline bool is_finite( const double& dble) { double d = dble; IEEE_754_double* p = reinterpret_cast(&d); return is_finite_by_mask_double( p->c.H ); } inline bool is_valid( const double& dble) { double d = dble; IEEE_754_double* p = reinterpret_cast(&d); return ! ( is_nan_by_mask_double( p->c.H, p->c.L )); } #else inline bool is_valid(double d) { return (d == d); } inline bool is_finite(double d) { return (d == d) && (is_valid(d-d)); } #endif inline io_Operator io_tag(double) { return io_Operator(); } // GCC is faster with std::fabs(). #ifdef __GNUG__ inline double abs(const double& d) { return CGAL_CLIB_STD::fabs(d); } #endif CGAL_END_NAMESPACE #endif // CGAL_DOUBLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2_old.h0000644000175000017500000006173011344301501030352 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2_old.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_SWEEP_LINE_H #define CGAL_SWEEP_LINE_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class X_curve_plus_id; template class Point_handle; /*! * A utility class that supplies several methods that perform opearation * related to intersection between curves. The intersection calculations * are all implemented using the Sweep Line algorithm. * No pre condition applies to the curves. * * The following operations are supported: * - report the intersection points * - produce all sub curves created by intersecting the curves * - report the intersection points and a list of curves for each point * - query whether curves intersect. */ template class Sweep_line_2_old : public Sweep_curves_base_2, X_curve_plus_id > { public: typedef SweepLineTraits_2 Traits; typedef Point_handle Point_handle_traits; typedef X_curve_plus_id X_curve_plus; typedef typename Traits::X_monotone_curve_2 X_curve; typedef typename Traits::Point_2 Point; typedef Sweep_curves_base_2 Base; typedef typename Base::Point_plus Point_plus; typedef typename Base::Curve_node Curve_node; typedef typename Base::Intersection_point_node Intersection_point_node; typedef typename Base::Points_iterator Points_iterator; typedef typename Base::Points_const_iterator Points_const_iterator; typedef typename Base::Curve_node_iterator Curve_node_iterator; typedef typename Base::Curve_node_const_iterator Curve_node_const_iterator; typedef typename Base::X_curve_list X_curve_list; typedef typename Base::X_curve_list_iterator X_curve_list_iterator; typedef typename Base::Vertices_points_plus Vertices_points_plus; typedef typename Base::Event_queue Event_queue; typedef typename Base::Status_line Status_line; typedef typename Event_queue::value_type Event_queue_value_type; typedef typename Status_line::value_type Status_line_value_type; Sweep_line_2_old() : Base() {} Sweep_line_2_old(Traits *traits_) : Base(traits_) {} ~Sweep_line_2_old() {} /*! * Given a container of curves, this function returns a list of curves * that are created by intersecting the input curves. * \param curves_begin the input iterator that points to the first curve * in the range. * \param curves_end the input past-the-end iterator of the range. * \param subcurves an iterator to the first curve in the range * of curves created by intersecting the input curves. * \param overlapping indicates whether there are overlapping curves * in the input range. Defaults to false. */ template void get_subcurves(CurveInputIterator curves_begin, CurveInputIterator curves_end, OutpoutIterator subcurves, bool overlapping = false) { typename Base::Less_xy event_queue_pred(traits); Event_queue event_queue(event_queue_pred); typename Base::Less_yx status_pred(traits); Status_line status(status_pred); init(curves_begin, curves_end, event_queue, status); bool event_terminated = true; while ( !(event_queue.empty()) ) { typename Event_queue::iterator event = event_queue.begin(); const Point& event_point = event->first; Intersection_point_node& point_node = event->second; event_terminated = true; // reinitializing event_terminated // to true only after the updating of the subdivision. // now continue with the sweep line. event_terminated = handle_one_event (event_queue, status, event_point, point_node); handle_overlapping_curves(event_queue,status,event_point,point_node); if (!event_terminated){ handle_one_event (event_queue, status, event_point, point_node); } Curve_node_iterator ncv_iter; for (ncv_iter = point_node.curves_begin(); ncv_iter != point_node.curves_end(); ++ncv_iter){ if (!traits->point_equal(event_point, traits->curve_source(ncv_iter->get_curve())) && traits->point_equal(event_point, ncv_iter->get_rightmost_point().point())) ncv_iter->erase_rightmost_point(); } add_curves(point_node, subcurves, overlapping); // updating all the new intersection nodes of the curves // participating within the event. for (ncv_iter = point_node.curves_begin(); ncv_iter != point_node.curves_end(); ++ncv_iter){ if (!traits->point_equal(event_point, ncv_iter->get_rightmost_point().point())) ncv_iter->push_event_point(point_node.get_point()); } event_queue.erase(event); } CGAL_expensive_postcondition_code(is_valid(status)); reset(); } /*! * Given a range of curves, this function returns a list of points * that are the intersection points of the curves. * The intersections are calculated using the sweep algorithm. * \param curves_begin the input iterator that points to the first curve * in the range. * \param curves_end the input past-the-end iterator of the range. * \param subcurves an iterator to the first curve in the range * of curves created by intersecting the input curves. * \param endpoints if true, the end points of the curves are reported * as intersection points. Defaults to true. * \param overlapping indicates whether there are overlapping curves * in the input range. Defaults to false. */ template void get_intersection_points(CurveInputIterator curves_begin, CurveInputIterator curves_end, OutpoutIterator points, bool endpoints = true, bool overlapping = false) { typename Base::Less_xy event_queue_pred(traits); Event_queue event_queue(event_queue_pred); typename Base::Less_yx status_pred(traits); Status_line status(status_pred); init(curves_begin, curves_end, event_queue, status); // now starting the sweeping. bool event_terminated = true; while ( !(event_queue.empty()) ) { typename Event_queue::iterator event = event_queue.begin(); const Point& event_point = event->first; Intersection_point_node& point_node = event->second; event_terminated = true; // reinitializing event_terminated // to true only after the updating of the subdivision. // now continue with the sweep line. event_terminated = handle_one_event (event_queue, status, event_point, point_node); handle_overlapping_curves(event_queue,status,event_point,point_node); if (!event_terminated){ handle_one_event (event_queue, status, event_point, point_node); } Curve_node_iterator cvn_iter; for (cvn_iter = point_node.curves_begin(); cvn_iter != point_node.curves_end(); ++cvn_iter){ if (!traits->point_equal(event_point, traits->curve_source(cvn_iter->get_curve())) && traits->point_equal(event_point, cvn_iter->get_rightmost_point().point())) cvn_iter->erase_rightmost_point(); } // now, updating the points containter according the // curves enemating from the currnet event point. if (endpoints || !is_endpoint(point_node)) *points = point_node.get_point().point(); ++points; // updating all the new intersection nodes of the curves // participating within the event. for (cvn_iter = point_node.curves_begin(); cvn_iter != point_node.curves_end(); ++cvn_iter){ if (!traits->point_equal(event_point, cvn_iter->get_rightmost_point().point())) cvn_iter->push_event_point(point_node.get_point()); } //if (event_terminated) event_queue.erase(event); } CGAL_expensive_postcondition_code(is_valid(status)); reset(); } /*! * Given a range of curves, this function returns an iterator * to the beginning of a range that contains the list of curves * for each intersection point between any two curves in the * specified range. * The intersections are calculated using the sweep algorithm. * \param curves_begin the input iterator that points to the first curve * in the range. * \param curves_end the input past-the-end iterator of the range. * \param intersecting_curves an iterator to the output * \param endpoints if true, the end points of the curves are reported * as intersection points. Defaults to true. */ template void get_intersecting_curves(CurveInputIterator curves_begin, CurveInputIterator curves_end, OutputIterator intersecting_curves, bool endpoints = true) { typename Base::Less_xy event_queue_pred(traits); Event_queue event_queue(event_queue_pred); typename Base::Less_yx status_pred(traits); Status_line status(status_pred); init(curves_begin, curves_end, event_queue, status); bool event_terminated = true; while ( !(event_queue.empty()) ) { typename Event_queue::iterator event = event_queue.begin(); const Point& event_point = event->first; Intersection_point_node& point_node = event->second; event_terminated = true; // reinitializing event_terminated // to true only after the updating of the subdivision. // now continue with the sweep line. event_terminated = handle_one_event (event_queue, status, event_point, point_node); handle_overlapping_curves(event_queue,status,event_point,point_node); if (!event_terminated){ handle_one_event (event_queue, status, event_point, point_node); } if (intersection_exist_ || (endpoints && is_endpoint(point_node))) { std::pair > intersection_point_node; intersection_point_node.first = point_node.get_point().point(); Curve_node_iterator cv_iter; for (cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter) { intersection_point_node.second.push_back(cv_iter->get_curve()); } *intersecting_curves = intersection_point_node; ++intersecting_curves; } Curve_node_iterator cvn_iter; for (cvn_iter = point_node.curves_begin(); cvn_iter != point_node.curves_end(); ++cvn_iter){ if (!traits->point_equal(event_point, traits->curve_source(cvn_iter->get_curve())) && traits->point_equal(event_point, cvn_iter->get_rightmost_point().point())) cvn_iter->erase_rightmost_point(); } // updating all the new intersection nodes of the curves // participating within the event. for (cvn_iter = point_node.curves_begin(); cvn_iter != point_node.curves_end(); ++cvn_iter){ if (!traits->point_equal(event_point, cvn_iter->get_rightmost_point().point())) cvn_iter->push_event_point(point_node.get_point()); } event_queue.erase(event); } CGAL_expensive_postcondition_code(is_valid(status)); reset(); } bool do_curves_intersect(CurveInputIterator curves_begin, CurveInputIterator curves_end); private: void init(CurveInputIterator curves_begin, CurveInputIterator curves_end, Event_queue &event_queue, Status_line &status); // Checking whether the point of point_node is an edge point. bool is_endpoint(const Intersection_point_node& point_node) { const Point & p = point_node.get_point().point(); for (typename Intersection_point_node::Curve_node_const_iterator cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter) { if (traits->point_equal(traits->curve_source(cv_iter->get_curve()), p) || traits->point_equal(traits->curve_target(cv_iter->get_curve()), p)) return true; } return false; } template void add_curves(Intersection_point_node& point_node, OutpoutIterator subcurves, bool overlapping) { if (overlapping) add_curves_with_overlapping(point_node, subcurves); else add_curves_without_overlapping(point_node, subcurves); } /*! Updates the curves the hae overlapping. */ template void add_curves_with_overlapping(Intersection_point_node& point_node, OutpoutIterator subcurves) { X_curve prev_sub_cv; for (Curve_node_iterator cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter) { if (is_left(cv_iter->get_rightmost_point().point(), point_node.get_point().point())) { // means we have a new sub curve to insert. X_curve cv = cv_iter->get_curve(), sub_cv = cv_iter->get_curve(), right_cv = cv; // split the curve, if necessary if (!traits->point_equal(traits->curve_source(cv), cv_iter->get_rightmost_point().point()) && !traits->point_equal(traits->curve_target(cv), cv_iter->get_rightmost_point().point())) { traits->curve_split(cv, sub_cv, right_cv, cv_iter->get_rightmost_point().point()); cv = right_cv; } if (!traits->point_equal(traits->curve_source(cv), point_node.get_point().point()) && !traits->point_equal(traits->curve_target(cv), point_node.get_point().point())) traits->curve_split(cv, sub_cv, right_cv, point_node.get_point().point()); else sub_cv = right_cv; *subcurves = sub_cv; ++subcurves; } } } template void add_curves_without_overlapping( Intersection_point_node& point_node, OutpoutIterator subcurves) { X_curve prev_sub_cv; for (Curve_node_iterator cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter){ if (is_left(cv_iter->get_rightmost_point().point(), point_node.get_point().point())) { // means we have a new sub curve to insert. X_curve cv = cv_iter->get_curve(), sub_cv = cv_iter->get_curve(), right_cv = cv; if (!traits->point_equal(traits->curve_source(cv), cv_iter->get_rightmost_point().point()) && !traits->point_equal(traits->curve_target(cv), cv_iter->get_rightmost_point().point())) { traits->curve_split(cv, sub_cv, right_cv, cv_iter->get_rightmost_point().point()); cv = right_cv; } if (!traits->point_equal(traits->curve_source(cv), point_node.get_point().point()) && !traits->point_equal(traits->curve_target(cv), point_node.get_point().point())) traits->curve_split(cv, sub_cv, right_cv, point_node.get_point().point()); else sub_cv = right_cv; if (cv_iter != point_node.curves_begin()){ if (traits->curves_overlap(sub_cv, prev_sub_cv)) { continue; } } prev_sub_cv = sub_cv; *subcurves = sub_cv; ++subcurves; } // else - no new sub curve is inserted to the subdivision. } } }; /*! * Given a range of curves, this function returns true if any two * curves in the range intersects. Returns false otherwise. * The intersections are calculated using the sweep algorithm. * \param curves_begin the input iterator that points to the first curve * in the range. * \param curves_end the input past-the-end iterator of the range. */ template inline bool Sweep_line_2_old:: do_curves_intersect(CurveInputIterator curves_begin, CurveInputIterator curves_end) { typename Base::Less_xy pred1(traits); Event_queue event_queue(pred1); typename Base::Less_yx pred2(traits); Status_line status(pred2); init(curves_begin, curves_end, event_queue, status); // now starting the sweeping. bool event_terminated = true; while ( !(event_queue.empty()) ){ typename Event_queue::iterator event = event_queue.begin(); const Point& event_point = event->first; Intersection_point_node& point_node = event->second; event_terminated = true; // reinitializing event_terminated // to true only after the updating of the subdivision. // now continue with the sweep line. event_terminated = handle_one_event (event_queue, status, event_point, point_node); handle_overlapping_curves(event_queue,status,event_point,point_node); if (!event_terminated) { handle_one_event (event_queue, status, event_point, point_node); } if (intersection_exist_) { reset(); return true; } event_queue.erase(event); } CGAL_expensive_postcondition_code(is_valid(status)); bool tmp = intersection_exist_; reset(); return tmp; } /*! Initializes the data structures used in the sweep algorithm, including: - splitting all input curves so that they are x-monotone - initializing the event queue with the curves end points */ template inline void Sweep_line_2_old:: init(CurveInputIterator curves_begin, CurveInputIterator curves_end, Event_queue &event_queue, Status_line &status) { // Remove out of loop scope to compile undef MSVC: CurveInputIterator cv_iter; X_curve_list_iterator xcv_iter; CGAL_SL_DEBUG( unsigned int n = 0; for (cv_iter = curves_begin; cv_iter != curves_end; ++cv_iter, ++n); cout<<"number of edges on input "<< n <is_x_monotone(*cv_iter)) { X_curve_list x_monotone_subcurves; traits->curve_make_x_monotone(*cv_iter, std::back_inserter(x_monotone_subcurves)); for (X_curve_list_iterator iter = x_monotone_subcurves.begin(); iter != x_monotone_subcurves.end(); ++iter) { CGAL_SL_DEBUG(std::cout<<*iter<curve_source(*xcv_iter), traits->curve_target(*xcv_iter)) ) cv = traits->curve_opposite(*xcv_iter); typename Event_queue::iterator edge_point = event_queue.find( traits->curve_source(cv) ); // defining one cv_node for both source and target event points. Curve_node cv_node = Curve_node(X_curve_plus(cv, id), // ?? diff traits->curve_source(cv), traits ); Intersection_point_node source_point_node = Intersection_point_node(cv_node, traits->curve_source(cv), traits ); if (edge_point == event_queue.end() || edge_point->second.get_point() != source_point_node.get_point()) event_queue.insert(Event_queue_value_type(traits->curve_source(cv), source_point_node)); else edge_point->second.merge(source_point_node); edge_point = event_queue.find( traits->curve_target(cv) ); Intersection_point_node target_point_node = Intersection_point_node(cv_node, traits->curve_target(cv), traits ); if (edge_point == event_queue.end() || edge_point->second.get_point() != target_point_node.get_point()) event_queue.insert(Event_queue_value_type(traits->curve_target(cv), target_point_node)); else edge_point->second.merge(target_point_node); } } /////////////////////////////////////////////////////////////////// // // UTILITY CLASSES /*! Holds a curve and its id number. The addition of id number to a curve was made due to overlapping (in which some binary predicates return EQUAL, while we are interseted in sharp order relation. */ template class X_curve_plus_id : public SweepLineTraits_2::X_curve { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve X_Curve; typedef typename Traits::Point Point; X_curve_plus_id() : X_Curve() {}; X_curve_plus_id(const X_Curve &cv, unsigned int i) : X_Curve(cv) , _id(i) {} X_curve_plus_id(const X_curve_plus_id &cv) : X_Curve(cv) , _id(cv.id()) {} ~X_curve_plus_id(){} X_curve_plus_id& operator=(const X_curve_plus_id &cv) { X_Curve::operator=(cv); _id = cv.id(); return *this; } bool operator==(const X_curve_plus_id &cv) const { Traits traits; return (_id == cv.id() && traits.curve_equal(*this, cv)); } void set_id(unsigned int i) { _id = i; } unsigned int id() const { return _id; } protected: unsigned int _id; }; template class Point_handle; /*! A wrapper class to Point from the specified traits class. This is the equivalent of the Point_plus_rep class defined for the planar map version. */ template class Point_rep { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::Point Point; Point_rep() {} Point_rep(const Point& p) : p_(p) {} ~Point_rep() {} protected: friend class Point_handle; Point p_; }; /*! A handle class for the Point_rep class. * Handle_for is used instead of Handle, using the CGAL_allocator. */ template class Point_handle : public Handle_for > { typedef Handle_for > Handle_for_Point_rep; public: typedef SweepLineTraits_2 Traits; typedef typename Traits::Point Point; typedef Point_rep Point_rep_traits; Point_handle() : Handle_for_Point_rep() { #ifdef CGAL_MAKE_PROFILING std::cout<<"allocating handle for DEFAULT Point_rep_traits" << endl; #endif } Point_handle(const Point & p) : Handle_for_Point_rep(Point_rep_traits(p)) { #ifdef CGAL_MAKE_PROFILING std::cout<<"allocating handle for Point_rep_traits(p)" << p << endl; #endif } Point_handle(const Point_handle & p) : Handle_for_Point_rep(p) {} ~Point_handle() {} Point_handle & operator=(const Point_handle & p) { Handle_for_Point_rep::operator=(p); return *this; } bool operator==(const Point_handle & p) const { return ptr()->p_ == p.point(); } bool operator!=(const Point_handle & p) const { return !(operator==(p)); } void set_point(const Point& p) { ptr()->p_ = p; } const Point & point() const { return ptr()->p_; } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Tree_traits.h0000644000175000017500000000536511344301501027470 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Tree_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef __CGAL_tree_traits__ #define __CGAL_tree_traits__ // Implementation of a minimal tree traits for CGAL trees, derived // from Tree_base.h // (e.g. Range_tree_d.h and Segment_tree_d.h). // Any other interface must at least provide the interface of this class. CGAL_BEGIN_NAMESPACE // Interface as it is expected for one layer of a Range Tree template class tree_point_traits{ public: typedef C_Key Key; typedef C_Data Data; typedef C_Window Window; typedef C_Compare Compare; C_Key get_key(const C_Data& dt) const {return C_Data_func()(dt);} C_Key get_left(const C_Window& dt) const {return C_Window_left_func()(dt);} C_Key get_right(const C_Window& dt) const {return C_Window_right_func()(dt);} static bool comp( C_Key const& key1, C_Key const& key2) {return C_Compare()(key1, key2);} static bool key_comp( C_Data const& data1, C_Data const& data2) { const Key d1= C_Data_func()(data1); const Key d2= C_Data_func()(data2); return C_Compare()(d1,d2); } }; // Interface as it is expected for one layer of a Segment Tree template class tree_interval_traits{ public: typedef C_Data Data; typedef C_Window Window; typedef C_Key Key; typedef C_Compare Compare; C_Key get_left(const C_Data& dt) const {return C_Data_left_func()(dt);} C_Key get_right(const C_Data& dt) const {return C_Data_right_func()(dt);} C_Key get_left_win(const C_Window& dt) const {return C_Window_left_func()(dt);} C_Key get_right_win(const C_Window& dt) const {return C_Window_right_func()(dt);} static bool comp( C_Key const& key1, C_Key const& key2) {return C_Compare()(key1, key2);} }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vertex_min_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vertex_min_0000644000175000017500000000427411344301500031277 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vertex_min_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_VERTEX_MIN_BASE_H #define CGAL_HALFEDGEDS_VERTEX_MIN_BASE_H 1 #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE template < class Refs> class HalfedgeDS_vertex_min_base { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_vertex_min_base< Refs> Base; typedef Tag_false Supports_vertex_halfedge; typedef Tag_false Supports_vertex_point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Halfedge Halfedge; typedef typename Refs::Face Face; }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_VERTEX_MIN_BASE_H // // EOF // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circle_2_Circle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circle_2_Circle_2_inte0000644000175000017500000000375211344301500031115 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circle_2_Circle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_CIRCLE_2_CIRCLE_2_INTERSECTION_H #define CGAL_CIRCLE_2_CIRCLE_2_INTERSECTION_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template bool do_intersect(const typename CGAL_WRAP(K)::Circle_2 & circ1, const typename CGAL_WRAP(K)::Circle_2& circ2, const K&) { typedef typename K::FT FT; FT sr1 = circ1.squared_radius(); FT sr2 = circ2.squared_radius(); FT squared_dist = squared_distance(circ1.center(), circ2.center()); FT temp = sr1+sr2-squared_dist; return !(FT(4)*sr1*sr2 < temp*temp); } } // namespace CGALi template inline bool do_intersect(const Circle_2 & circ1, const Circle_2 & circ2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(circ1, circ2); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_3_1.C0000644000175000017500000005675511344301500030316 0ustar debiandebian// Copyright (c) 1997-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_3_1.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include CGAL_BEGIN_NAMESPACE namespace CGALi { template Object intersection(const typename CGAL_WRAP(K)::Plane_3 &plane, const typename CGAL_WRAP(K)::Line_3 &line, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; typedef typename K::RT RT; const Point_3 &line_pt = line.point(); const Direction_3 &line_dir = line.direction(); RT num, den; num = plane.a()*line_pt.hx() + plane.b()*line_pt.hy() + plane.c()*line_pt.hz() + wmult((K*)0, plane.d(), line_pt.hw()); den = plane.a()*line_dir.dx() + plane.b()*line_dir.dy() + plane.c()*line_dir.dz(); if (den == RT(0)) { if (num == RT(0)) { // all line return make_object(line); } else { // no intersection return Object(); } } return make_object(Point_3( den*line_pt.hx()-num*line_dir.dx(), den*line_pt.hy()-num*line_dir.dy(), den*line_pt.hz()-num*line_dir.dz(), wmult((K*)0, den, line_pt.hw()))); } template inline Object intersection(const typename CGAL_WRAP(K)::Line_3 &line, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { return intersection(plane, line, k); } template Object intersection(const typename CGAL_WRAP(K)::Plane_3 &plane1, const typename CGAL_WRAP(K)::Plane_3 &plane2, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Line_3 Line_3; typedef typename K::RT RT; const RT &a = plane1.a(); const RT &b = plane1.b(); const RT &c = plane1.c(); const RT &d = plane1.d(); const RT &p = plane2.a(); const RT &q = plane2.b(); const RT &r = plane2.c(); const RT &s = plane2.d(); const RT zero = RT(0); RT det; Point_3 is_pt; Direction_3 is_dir; det = a*q-p*b; if (det != zero) { is_pt = Point_3(b*s-d*q, p*d-a*s, zero, det); is_dir = Direction_3(b*r-c*q, p*c-a*r, det); return make_object(Line_3(is_pt, is_dir)); } det = a*r-p*c; if (det != zero) { is_pt = Point_3(c*s-d*r, zero, p*d-a*s, det); is_dir = Direction_3(c*q-b*r, det, p*b-a*q); return make_object(Line_3(is_pt, is_dir)); } det = b*r-c*q; if (det != zero) { is_pt = Point_3(zero, c*s-d*r, d*q-b*s, det); is_dir = Direction_3(det, c*p-a*r, a*q-b*p); return make_object(Line_3(is_pt, is_dir)); } // degenerate case if (a!=zero || p!=zero) { if (a*s == p*d) return make_object(plane1); else return Object(); } if (b!=zero || q!=zero) { if (b*s == q*d) return make_object(plane1); else return Object(); } if (c!=zero || r!=zero) { if (c*s == r*d) return make_object(plane1); else return Object(); } return make_object(plane1); } template Object intersection(const typename CGAL_WRAP(K)::Plane_3 &plane1, const typename CGAL_WRAP(K)::Plane_3 &plane2, const typename CGAL_WRAP(K)::Plane_3 &plane3, const K& k) { typedef typename K::Line_3 Line_3; typedef typename K::Plane_3 Plane_3; // Intersection between plane1 and plane2 can either be // a line, a plane, or empty. Object o12 = CGALi::intersection(plane1, plane2, k); Line_3 l; if (assign(l, o12)) return CGALi::intersection(plane3, l, k); Plane_3 pl; if (assign(pl, o12)) return CGALi::intersection(plane3, pl, k); return Object(); } template bool do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane, const typename CGAL_WRAP(K)::Line_3 &line, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; typedef typename K::RT RT; const Point_3 &line_pt = line.point(); const Direction_3 &line_dir = line.direction(); RT num, den; den = plane.a()*line_dir.dx() + plane.b()*line_dir.dy() + plane.c()*line_dir.dz(); if (den != RT(0)) return true; num = plane.a()*line_pt.hx() + plane.b()*line_pt.hy() + plane.c()*line_pt.hz() + wmult((K*)0, plane.d(), line_pt.hw()); if (num == RT(0)) { // all line return true; } else { // no intersection return false; } } template inline bool do_intersect(const typename CGAL_WRAP(K)::Line_3 &line, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { return do_intersect(plane, line, k); } template Object intersection(const typename CGAL_WRAP(K)::Plane_3 &plane, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { typedef typename K::Point_3 Point_3; const Object line_intersection = intersection(plane, ray.supporting_line(), k); Point_3 isp; if (assign(isp, line_intersection)) { if (ray.collinear_has_on(isp)) return line_intersection; else return Object(); } if (line_intersection.is_empty()) return line_intersection; return make_object(ray); } template inline Object intersection(const typename CGAL_WRAP(K)::Ray_3 &ray, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { return intersection(plane, ray, k); } template bool do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { typedef typename K::Point_3 Point_3; const Object line_intersection = intersection(plane, ray.supporting_line(), k); if (line_intersection.is_empty()) return false; Point_3 isp; if (assign(isp, line_intersection)) { if (ray.collinear_has_on(isp)) return true; else return false; } return true; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_3 &ray, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { return do_intersect(plane, ray, k); } template Object intersection(const typename CGAL_WRAP(K)::Plane_3 &plane, const typename CGAL_WRAP(K)::Segment_3 &seg, const K& k) { typedef typename K::Point_3 Point_3; const Point_3 &source = seg.source(); const Point_3 &target = seg.target(); Oriented_side source_side,target_side; source_side = plane.oriented_side(source); target_side = plane.oriented_side(target); switch (source_side) { case ON_ORIENTED_BOUNDARY: if (target_side == ON_ORIENTED_BOUNDARY) return make_object(seg); else return make_object(source); case ON_POSITIVE_SIDE: switch (target_side) { case ON_ORIENTED_BOUNDARY: return make_object(target); case ON_POSITIVE_SIDE: return Object(); case ON_NEGATIVE_SIDE: return intersection(plane, seg.supporting_line(), k); } case ON_NEGATIVE_SIDE: switch (target_side) { case ON_ORIENTED_BOUNDARY: return make_object(target); case ON_POSITIVE_SIDE: return intersection(plane, seg.supporting_line(), k); case ON_NEGATIVE_SIDE: return Object(); } } CGAL_kernel_assertion_msg(false, "Supposedly unreachable code."); return Object(); } template inline Object intersection(const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { return intersection(plane, seg, k); } template bool do_intersect(const typename CGAL_WRAP(K)::Plane_3 &plane, const typename CGAL_WRAP(K)::Segment_3 &seg, const K&) { typedef typename K::Point_3 Point_3; const Point_3 &source = seg.source(); const Point_3 &target = seg.target(); Oriented_side source_side,target_side; source_side = plane.oriented_side(source); target_side = plane.oriented_side(target); if ( source_side == target_side && target_side != ON_ORIENTED_BOUNDARY) { return false; } return true; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Plane_3 &plane, const K& k) { return do_intersect(plane, seg, k); } template Object intersection(const typename CGAL_WRAP(K)::Line_3 &line, const Bbox_3 &box, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; const Point_3 &linepoint = line.point(); const Direction_3 &linedir = line.direction(); return intersection_bl(box, CGAL::to_double(linepoint.x()), CGAL::to_double(linepoint.y()), CGAL::to_double(linepoint.z()), CGAL::to_double(linedir.dx()), CGAL::to_double(linedir.dy()), CGAL::to_double(linedir.dz()), true, true ); } template inline Object intersection(const Bbox_3 &box, const typename CGAL_WRAP(K)::Line_3 &line, const K& k) { return intersection(line, box, k); } template Object intersection(const typename CGAL_WRAP(K)::Ray_3 &ray, const Bbox_3 &box, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; const Point_3 &linepoint = ray.source(); const Direction_3 &linedir = ray.direction(); return intersection_bl(box, CGAL::to_double(linepoint.x()), CGAL::to_double(linepoint.y()), CGAL::to_double(linepoint.z()), CGAL::to_double(linedir.dx()), CGAL::to_double(linedir.dy()), CGAL::to_double(linedir.dz()), false, true ); } template inline Object intersection(const Bbox_3 &box, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { return intersection(ray, box, k); } template Object intersection(const typename CGAL_WRAP(K)::Segment_3 &seg, const Bbox_3 &box, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; const Point_3 &linepoint = seg.source(); const Vector_3 &diffvec = seg.target()-linepoint; return intersection_bl(box, CGAL::to_double(linepoint.x()), CGAL::to_double(linepoint.y()), CGAL::to_double(linepoint.z()), CGAL::to_double(diffvec.x()), CGAL::to_double(diffvec.y()), CGAL::to_double(diffvec.z()), false, false ); } template inline Object intersection(const Bbox_3 &box, const typename CGAL_WRAP(K)::Segment_3 &seg, const K& k) { return intersection(seg, box, k); } template Object intersection(const typename CGAL_WRAP(K)::Line_3 &line, const typename CGAL_WRAP(K)::Iso_cuboid_3 &box, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Segment_3 Segment_3; typedef typename K::RT RT; typedef typename K::FT FT; bool all_values = true; FT _min, _max; Point_3 const & _ref_point=line.point(); Vector_3 const & _dir=line.direction().vector(); Point_3 const & _iso_min=box.min(); Point_3 const & _iso_max=box.max(); int i; for (i=0; i< _ref_point.dimension(); i++) { if (_dir.homogeneous(i) == RT(0)) { if (_ref_point.cartesian(i) < _iso_min.cartesian(i)) { return Object(); } if (_ref_point.cartesian(i) > _iso_max.cartesian(i)) { return Object(); } } else { FT newmin, newmax; if (_dir.homogeneous(i) > RT(0)) { newmin = (_iso_min.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); newmax = (_iso_max.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); } else { newmin = (_iso_max.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); newmax = (_iso_min.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); } if (all_values) { _min = newmin; _max = newmax; } else { if (newmin > _min) _min = newmin; if (newmax < _max) _max = newmax; if (_max < _min) { return Object(); } } all_values = false; } } CGAL_kernel_assertion(!all_values); if (_max == _min) { return make_object(Point_3(_ref_point + _dir * _min )); } return make_object( Segment_3(_ref_point + _dir*_min, _ref_point + _dir*_max)); } template inline Object intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box, const typename CGAL_WRAP(K)::Line_3 &line, const K& k) { return intersection(line, box, k); } template Object intersection(const typename CGAL_WRAP(K)::Ray_3 &ray, const typename CGAL_WRAP(K)::Iso_cuboid_3 &box, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Segment_3 Segment_3; typedef typename K::RT RT; typedef typename K::FT FT; bool all_values = true; FT _min= FT(0), _max; Point_3 const & _ref_point=ray.source(); Vector_3 const & _dir=ray.direction().vector(); Point_3 const & _iso_min=box.min(); Point_3 const & _iso_max=box.max(); int i; for (i=0; i< _ref_point.dimension(); i++) { if (_dir.homogeneous(i) == RT(0)) { if (_ref_point.cartesian(i) < _iso_min.cartesian(i)) { return Object(); } if (_ref_point.cartesian(i) > _iso_max.cartesian(i)) { return Object(); } } else { FT newmin, newmax; if (_dir.homogeneous(i) > RT(0)) { newmin = (_iso_min.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); newmax = (_iso_max.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); } else { newmin = (_iso_max.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); newmax = (_iso_min.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); } if (all_values) { _max = newmax; } else { if (newmax < _max) _max = newmax; } if (newmin > _min) _min = newmin; if (_max < _min) return Object(); all_values = false; } } CGAL_kernel_assertion(!all_values); if (_max == _min) { return make_object(Point_3(_ref_point + _dir * _min )); } return make_object( Segment_3(_ref_point + _dir*_min, _ref_point + _dir*_max)); } template inline Object intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box, const typename CGAL_WRAP(K)::Ray_3 &ray, const K& k) { return intersection(ray, box, k); } template Object intersection(const typename CGAL_WRAP(K)::Segment_3 &seg, const typename CGAL_WRAP(K)::Iso_cuboid_3 &box, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Segment_3 Segment_3; typedef typename K::RT RT; typedef typename K::FT FT; FT _min= FT(0), _max; Point_3 const & _ref_point=seg.source(); Vector_3 const & _dir=seg.direction().vector(); Point_3 const & _iso_min=box.min(); Point_3 const & _iso_max=box.max(); int main_dir = (CGAL_NTS abs(_dir.x()) > CGAL_NTS abs(_dir.y()) ) ? (CGAL_NTS abs(_dir.x()) > CGAL_NTS abs(_dir.z()) ? 0 : 2) : (CGAL_NTS abs(_dir.y()) > CGAL_NTS abs(_dir.z()) ? 1 : 2); _max = (seg.target().cartesian(main_dir)-_ref_point.cartesian(main_dir)) / _dir.cartesian(main_dir); int i; for (i=0; i< _ref_point.dimension(); i++) { if (_dir.homogeneous(i) == RT(0)) { if (_ref_point.cartesian(i) < _iso_min.cartesian(i)) { return Object(); } if (_ref_point.cartesian(i) > _iso_max.cartesian(i)) { return Object(); } } else { FT newmin, newmax; if (_dir.homogeneous(i) > RT(0)) { newmin = (_iso_min.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); newmax = (_iso_max.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); } else { newmin = (_iso_max.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); newmax = (_iso_min.cartesian(i) - _ref_point.cartesian(i)) / _dir.cartesian(i); } if (newmax < _max) _max = newmax; if (newmin > _min) _min = newmin; if (_max < _min) return Object(); } } if (_max == _min) { return make_object(Point_3(_ref_point + _dir * _min )); } return make_object( Segment_3(_ref_point + _dir*_min, _ref_point + _dir*_max)); } template inline Object intersection(const typename CGAL_WRAP(K)::Iso_cuboid_3 &box, const typename CGAL_WRAP(K)::Segment_3 &seg, const K& k) { return intersection(seg, box, k); } template Object intersection( const typename CGAL_WRAP(K)::Iso_cuboid_3 &icub1, const typename CGAL_WRAP(K)::Iso_cuboid_3 &icub2, const K&) { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; Point_3 min_points[2]; Point_3 max_points[2]; min_points[0] = icub1.min(); min_points[1] = icub2.min(); max_points[0] = icub1.max(); max_points[1] = icub2.max(); typedef typename K::FT FT; const int DIM = 3; int min_idx[DIM]; int max_idx[DIM]; Point_3 newmin; Point_3 newmax; for (int dim = 0; dim < DIM; ++dim) { min_idx[dim] = min_points[0].cartesian(dim) >= min_points[1].cartesian(dim) ? 0 : 1; max_idx[dim] = max_points[0].cartesian(dim) <= max_points[1].cartesian(dim) ? 0 : 1; if (min_idx[dim] != max_idx[dim] && max_points[max_idx[dim]].cartesian(dim) < min_points[min_idx[dim]].cartesian(dim)) return Object(); } if (min_idx[0] == min_idx[1] && min_idx[0] == min_idx[2]) { newmin = min_points[min_idx[0]]; } else { newmin = Point_3( min_idx[0] == 0 ? wmult((K*)0, min_points[0].hx(), min_points[1].hw()) : wmult((K*)0, min_points[1].hx(), min_points[0].hw()) , min_idx[1] == 0 ? wmult((K*)0, min_points[0].hy(), min_points[1].hw()) : wmult((K*)0, min_points[1].hy(), min_points[0].hw()) , min_idx[2] == 0 ? wmult((K*)0, min_points[0].hz(), min_points[1].hw()) : wmult((K*)0, min_points[1].hz(), min_points[0].hw()) , wmult((K*)0, min_points[0].hw(), min_points[1].hw()) ); } if (max_idx[0] == max_idx[1] && max_idx[0] == max_idx[2]) { newmax = max_points[max_idx[0]]; } else { newmax = Point_3( max_idx[0] == 0 ? wmult((K*)0, max_points[0].hx(), max_points[1].hw()) : wmult((K*)0, max_points[1].hx(), max_points[0].hw()) , max_idx[1] == 0 ? wmult((K*)0, max_points[0].hy(), max_points[1].hw()) : wmult((K*)0, max_points[1].hy(), max_points[0].hw()) , max_idx[2] == 0 ? wmult((K*)0, max_points[0].hz(), max_points[1].hw()) : wmult((K*)0, max_points[1].hz(), max_points[0].hw()) , wmult((K*)0, max_points[0].hw(), max_points[1].hw()) ); } Object result = make_object(Iso_cuboid_3(newmin, newmax)); return result; } } // namespace CGALi template inline Object intersection(const Plane_3 &plane1, const Plane_3 &plane2) { return typename K::Intersect_3()(plane1, plane2); } template inline Object intersection(const Plane_3 &plane1, const Plane_3 &plane2, const Plane_3 &plane3) { return typename K::Intersect_3()(plane1, plane2, plane3); } template inline Object intersection(const Plane_3 &plane, const Line_3 &line) { return typename K::Intersect_3()(plane, line); } template inline bool do_intersect(const Plane_3 &plane, const Line_3 &line) { return typename K::Do_intersect_3()(plane, line); } template inline Object intersection(const Plane_3 &plane, const Ray_3 &ray) { return typename K::Intersect_3()(plane, ray); } template inline bool do_intersect(const Plane_3 &plane, const Ray_3 &ray) { return typename K::Do_intersect_3()(plane, ray); } template inline Object intersection(const Plane_3 &plane, const Segment_3 &seg) { return typename K::Intersect_3()(plane, seg); } template inline bool do_intersect(const Plane_3 &plane, const Segment_3 &seg) { return typename K::Do_intersect_3()(plane, seg); } template inline Object intersection(const Line_3 &line, const Bbox_3 &box) { return typename K::Intersect_3()(line, box); } template inline Object intersection(const Ray_3 &ray, const Bbox_3 &box) { return typename K::Intersect_3()(ray, box); } template inline Object intersection(const Segment_3 &seg, const Bbox_3 &box) { return typename K::Intersect_3()(seg, box); } template inline Object intersection(const Line_3 &line, const Iso_cuboid_3 &box) { return typename K::Intersect_3()(line, box); } template inline Object intersection(const Ray_3 &ray, const Iso_cuboid_3 &box) { return typename K::Intersect_3()(ray, box); } template inline Object intersection(const Segment_3 &seg, const Iso_cuboid_3 &box) { return typename K::Intersect_3()(seg, box); } template inline Object intersection(const Iso_cuboid_3 &icub1, const Iso_cuboid_3 &icub2) { return typename K::Intersect_3()(icub1, icub2); } CGAL_END_NAMESPACE ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_curve_data_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_curve_data_traits_0000644000175000017500000002732311344301500031420 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_curve_data_traits_2.h,v $ // $Revision: 1.1.1.1 $ // $Name: $ // // Author(s) : Ron Wein // Efi Fogel #ifndef CGAL_CURVE_DATA_TRAITS_2_H #define CGAL_CURVE_DATA_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE /*! A generic traits class for maintaining an arrangement of curves that have * an extra data field. This traits class is templated with a Data class an * an ordinary traits class which is also used as a based traits class to * inherit from. It extracts the original Curve_2 and X_monotone_curve_2 types * from the ordinary traits class, and redefines them to have Data as an extra * field. * * The Data field is updated when the curves are converted from Curve_2 to * X_monotone_curve_2, and when the X_monotone_curve_2 curves are split. All * other methods are inherited from the base ordinary traits class. */ template class Arr_curve_data_traits_2 : public Traits_ { public: typedef Traits_ Traits; typedef Data_ Data; typedef typename Traits::Curve_2 Org_curve_2; typedef typename Traits::X_monotone_curve_2 Org_x_monotone_curve_2; typedef typename Traits::Point_2 Point_2; /*! * Representation of an input curve with an addtional data field. */ class Curve_2 : public Org_curve_2 { private: Data m_data; public: /*! * Default constructor. */ Curve_2 () {} /*! * Construct a curve from an original curve and a data object. * \param cv The original curve. * \param data The data object. */ Curve_2 (const Org_curve_2 & cv, const Data & data) : Org_curve_2(cv), m_data(data) {} /*! * Get the data. * \return The data object associated with the curve. */ const Data & get_data () const { return m_data; } /*! * Set the curve data. * \param data The data object to be associated with the curve. */ void set_data (const Data & data) { m_data = data; return; } }; /*! * Representation of an x-monotone cuvre. As this curve may represent * an overlapping section of several input curves, we store a list of data * objects with it. */ class X_monotone_curve_2 : public Org_x_monotone_curve_2 { private: std::list m_data_list; public: /*! * Default constructor. */ X_monotone_curve_2() {} /*! * Construct a curve from an original x-monotone curve and a data object. * \param cv The original x-monotone curve. * \param data The data object. */ X_monotone_curve_2 (const Org_x_monotone_curve_2 & cv, const Data & data) : Org_x_monotone_curve_2(cv), m_data_list() { m_data_list.push_back(data); } /*! * Construct a curve from an original x-monotone curve and a range of * data objects. * \param cv The original x-monotone curve. * \param begin A begin iterator for the data range. * \param end A past-the-end iterator for the data range. */ template X_monotone_curve_2 (const Org_x_monotone_curve_2 & cv, const InputIterator & begin, const InputIterator & end) : Org_x_monotone_curve_2(cv), m_data_list() { InputIterator it; for (it = begin; it != end; it++) m_data_list.push_back(*it); } /*! * Get the number of data objects associated with the x-monotne curve. */ int number_of_data_objects () const { return (m_data_list.size()); } /*! * Get the first data object associated with the curve. * \pre number_of_data_objects() is not 0. */ const Data & get_data () const { CGAL_precondition (m_data_list.size() > 0); return (m_data_list.front()); } /*! * Get the data iterators (const version). */ typename std::list::const_iterator begin_data () const { return (m_data_list.begin()); } typename std::list::const_iterator end_data () const { return (m_data_list.end()); } /*! * Get the data iterators (non-const version). */ typename std::list::iterator begin_data () { return (m_data_list.begin()); } typename std::list::iterator end_data () { return (m_data_list.end()); } /*! * Add a data object to the curve. * \param data The additional data object. */ void add_data (const Data & data) { m_data_list.push_back (data); return; } /*! * Set a data object to the curve. * \param data The data object to set. */ void set_data (const Data & data) { clear_data(); add_data(data); return; } /*! * Add a range of data objects to the curve. * \param begin A begin iterator for the data range. * \param end A past-the-end iterator for the data range. */ template void add_data (const InputIterator & begin, const InputIterator & end) { InputIterator it; for (it = begin; it != end; it++) m_data_list.push_back(*it); return; } /*! * Clear the data objects. */ void clear_data () { m_data_list.clear(); return; } }; // For backward compatibility: typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; public: /*! * Default constructor. */ Arr_curve_data_traits_2 () : Traits() {} /*! * Cut the given curve into x-monotone subcurves and insert them to the * given output iterator. While segments are x_monotone, still need to pass * them out. * \param cv The curve. * \param o The output iterator. * \return The past-the-end iterator. */ template OutputIterator curve_make_x_monotone(const Curve_2 & cv, OutputIterator o) const { // Make the original curve x-monotone. std::list org_x_curves; Traits::curve_make_x_monotone (cv, std::back_inserter(org_x_curves)); // Attach the data to each of the resulting x-monotone curves. typename std::list::const_iterator it; for (it = org_x_curves.begin(); it != org_x_curves.end(); it++) *o++ = X_monotone_curve_2 (*it, cv.get_data()); return o; } /*! * Split a given curve at a given split point into two sub-curves. * \param cv The curve to split * \param c1 The output first part of the split curve. * Its source is the source of the original curve. * \param c2 The output second part of the split curve. * Its target is the target of the original curve. * \param p The split point. * \pre p lies on cv but is not one of its end-points. */ void curve_split(const X_monotone_curve_2 & cv, X_monotone_curve_2 & c1, X_monotone_curve_2 & c2, const Point_2 & p) const { // Split the original curve. Org_x_monotone_curve_2 org_c1, org_c2; Traits::curve_split (cv, org_c1, org_c2, p); // Attach data. c1 = X_monotone_curve_2 (org_c1, cv.begin_data(), cv.end_data()); c2 = X_monotone_curve_2 (org_c2, cv.begin_data(), cv.end_data()); return; } /*! * Find the nearest intersection of the two given curves to the right of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the right of the reference point (that is, whose * left endpoint is the projection of the reference point onto the * overlapping subcurve). * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the right of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_right (const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & p) const { // Use the base method and resturn the result as is in case there is // no intersection or if the intersection is a single point. CGAL::Object res = Traits::nearest_intersection_to_right (cv1, cv2, p); Point_2 ip; if (res.is_empty() || CGAL::assign (ip, res)) return (res); // In case we have an overlapping curve, attach data from both cv1 and cv2 // to it. Org_x_monotone_curve_2 iocv; bool assign_success; assign_success = CGAL::assign (iocv, res); CGAL_assertion (assign_success); X_monotone_curve_2 icv (iocv, cv1.begin_data(), cv1.end_data()); icv.add_data (cv2.begin_data(), cv2.end_data()); return (CGAL::make_object (icv)); } /*! * Find the nearest intersection of the two given curves to the left of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the left of the reference point (that is, whose * right endpoint is the projection of the reference point onto the * overlapping subcurve). * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the left of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_left (const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & p) const { // Use the base method and resturn the result as is in case there is // no intersection or if the intersection is a single point. CGAL::Object res = Traits::nearest_intersection_to_left (cv1, cv2, p); Point_2 ip; if (res.is_empty() || CGAL::assign (ip, res)) return (res); // In case we have an overlapping curve, attach data from both cv1 and cv2 // to it. Org_x_monotone_curve_2 iocv; bool assign_success; assign_success = CGAL::assign (iocv, res); CGAL_assertion (assign_success); X_monotone_curve_2 icv (iocv, cv1.begin_data(), cv1.end_data()); icv.add_data (cv2.begin_data(), cv2.end_data()); return (CGAL::make_object (icv)); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_extended_homogeneous.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_extended_homo0000644000175000017500000012633411344301500031414 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_extended_homogeneous.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_FILTERED_EXTENDED_HOMOGENEOUS_H #define CGAL_FILTERED_EXTENDED_HOMOGENEOUS_H #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 59 #include #define REDUCE_INTERSECTION_POINTS //#define KERNEL_ANALYSIS //#define KERNEL_CHECK #ifdef KERNEL_CHECK #include #define CHECK(c1,c2) CGAL_assertion((c1) == (c2)); #define PRINT_CHECK_ENABLED std::cout << "kernel check enabled!\n" #else #define CHECK(c1,c2) #define PRINT_CHECK_ENABLED std::cout << "no kernel check!\n" #endif #ifdef KERNEL_ANALYSIS #define DEFCOUNTER(c) \ static int c##_total=0; static int c##_exception=0; #define INCTOTAL(c) c##_total++ #define INCEXCEPTION(c) c##_exception++ #define PRINT_STATISTICS(c) \ std::cout << #c##" " << c##_exception << "/" << c##_total << std::endl #else #define DEFCOUNTER(c) #define INCTOTAL(c) #define INCEXCEPTION(c) #define PRINT_STATISTICS(c) #endif CGAL_BEGIN_NAMESPACE template class SPolynomial { RT _m,_n; public: SPolynomial() : _m(),_n() {} SPolynomial(const RT& m, const RT& n) : _m(m),_n(n) {} SPolynomial(const RT& n) : _m(),_n(n) {} SPolynomial(const SPolynomial& p) : _m(p._m),_n(p._n) {} SPolynomial& operator=(const SPolynomial& p) { _m=p._m; _n=p._n; return *this; } const RT& m() const { return _m; } const RT& n() const { return _n; } void negate() { _m=-_m; _n=-_n; } SPolynomial operator*(const RT& c) const { return SPolynomial(c*_m,c*_n); } SPolynomial operator+(const SPolynomial& p) const { return SPolynomial(_m+p._m,_n+p._n); } SPolynomial operator-(const SPolynomial& p) const { return SPolynomial(_m-p._m,_n-p._n); } SPolynomial operator-() const { return SPolynomial(-_m,-_n); } void operator /= (const RT& c) { _m /= c; _n /= c; } const RT& operator[](int i) { return (i%2 ? _n : _m); } const RT& operator[](int i) const { return (i%2 ? _n : _m); } bool is_zero() const { return (_m==0 && _n==0); } int sign() const { if ( _m != 0 ) return CGAL_NTS sign(_m); return CGAL_NTS sign(_n); } // only for visualization: static void set_R(const RT& R) { R_ = R; } RT eval_at(const RT& r) const { return _m*r+_n; } RT eval_at_R() const { return _m*R_+_n; } protected: static RT R_; }; template RT SPolynomial::R_; template int sign(const SPolynomial& p) { return p.sign(); } template bool operator==(const SPolynomial& p1, const SPolynomial& p2) { return (p1-p2).is_zero(); } template bool operator>(const SPolynomial& p1, const SPolynomial& p2) { return (p1-p2).sign()>0; } template bool operator<(const SPolynomial& p1, const SPolynomial& p2) { return (p1-p2).sign()<0; } template bool operator<(int i, const SPolynomial& p2) { SPolynomial p1(i); return (p1-p2).sign()<0; } template bool operator<(const SPolynomial& p1, int i) { SPolynomial p2(i); return (p1-p2).sign()<0; } template inline double to_double(const SPolynomial& p) { return (CGAL::to_double(p.eval_at(SPolynomial::R_))); } template std::ostream& operator<<(std::ostream& os, const SPolynomial& p) { switch( os.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : os << p.m() << " " << p.n(); break; case CGAL::IO::BINARY : CGAL::write(os,p.m());CGAL::write(os,p.n()); break; default: if ( p.m() == 0 ) os<<"["< std::istream& operator>>(std::istream& is, SPolynomial& p) { RT m,n; switch( is.iword(CGAL::IO::mode) ){ case CGAL::IO::ASCII : is >> m >> n; p = SPolynomial(m,n); break; case CGAL::IO::BINARY : CGAL::read(is,m);CGAL::read(is,n);break; default: CGAL_assertion_msg(0,"\nStream must be in ascii or binary mode\n"); break; } return is; } template /*CGAL_KERNEL_INLINE*/ CGAL::io_Operator io_tag(const SPolynomial&) { return CGAL::io_Operator(); } template class SQuotient { SPolynomial _p; RT _n; public: SQuotient() : _p(),_n() {} SQuotient(const SPolynomial& p, const RT& n) : _p(p),_n(n) {} SQuotient(const SQuotient& p) : _p(p._p),_n(p._n) {} SQuotient& operator=(const SQuotient& p) { _p=p._p; _n=p._n; return *this; } const SPolynomial& numerator() const { return _p; } const RT& denominator() const { return _n; } }; template inline double to_double(const SQuotient& q) { return (CGAL::to_double(q.numerator().eval_at_R())/ CGAL::to_double(q.denominator())); } template class Extended_point; template class Extended_point_rep; template class Extended_point_rep { friend class Extended_point; SPolynomial x_,y_; RT w_; typedef Interval_nt_advanced DT; DT mxd,myd,nxd,nyd,wd; public: Extended_point_rep(const RT& x, const RT& y, const RT& w) : x_(x),y_(y),w_(w) { CGAL_assertion_msg(w!=0,"denominator is zero."); nxd=CGAL::to_interval(x); nyd=CGAL::to_interval(y); wd=CGAL::to_interval(w); mxd=myd=0; } Extended_point_rep(const SPolynomial& x, const SPolynomial& y, const RT& w) : x_(x),y_(y),w_(w) { CGAL_assertion_msg(w!=0,"denominator is zero."); mxd=CGAL::to_interval(x.m()); myd=CGAL::to_interval(y.m()); nxd=CGAL::to_interval(x.n()); nyd=CGAL::to_interval(y.n()); wd=CGAL::to_interval(w); } Extended_point_rep() : x_(),y_(),w_() {} ~Extended_point_rep() {} void negate() { x_ = -x_; y_ = -y_; w_ = -w_; mxd = -mxd; myd = -myd; nxd = -nxd; nyd = -nyd; wd = -wd; } }; template class Extended_point : public Handle_for< Extended_point_rep > { typedef Extended_point_rep Rep; typedef Handle_for< Rep > Base; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::ptr; #endif public: typedef typename Rep::DT DT; typedef RT_ RT; typedef SPolynomial SP; Extended_point() : Base( Rep() ) {} Extended_point(const RT& x, const RT& y, const RT& w) : Base( Rep(x,y,w) ) { if (w < 0) this->ptr()->negate(); } Extended_point(const SPolynomial& x, const SPolynomial& y, const RT& w) : Base( Rep(x,y,w) ) { if (w < 0) this->ptr()->negate(); } Extended_point(const RT& mx, const RT& nx, const RT& my, const RT& ny, const RT& w) : Base( Rep(SP(mx,nx), SP(my,ny), w) ) { if (w < 0) this->ptr()->negate(); } Extended_point(const Extended_point& p) : Base(p) {} ~Extended_point() {} Extended_point& operator=(const Extended_point& p) { Base::operator=(p); return *this; } const RT& mx() const { return this->ptr()->x_.m(); } const RT& nx() const { return this->ptr()->x_.n(); } const RT& my() const { return this->ptr()->y_.m(); } const RT& ny() const { return this->ptr()->y_.n(); } const RT& hw() const { return this->ptr()->w_; } const DT& mxD() const { return this->ptr()->mxd; } const DT& nxD() const { return this->ptr()->nxd; } const DT& myD() const { return this->ptr()->myd; } const DT& nyD() const { return this->ptr()->nyd; } const DT& hwD() const { return this->ptr()->wd; } SQuotient x() const { return SQuotient(this->ptr()->x_, this->ptr()->w_); } SQuotient y() const { return SQuotient(this->ptr()->y_, this->ptr()->w_); } const SPolynomial hx() const { return this->ptr()->x_; } const SPolynomial hy() const { return this->ptr()->y_; } bool is_standard() const { return (mx()==0)&&(my()==0); } Extended_point opposite() const { return Extended_point(-mx(),nx(),-my(),ny(),this->w()); } #ifdef KERNEL_CHECK typedef CGAL::Extended_homogeneous CheckKernel; typedef typename CheckKernel::Point_2 CheckPoint; typedef typename CheckKernel::RT CheckRT; CheckRT convert(const CGAL::SPolynomial& p) const { return CheckRT(p.n(),p.m()); } CheckRT convert(const RT_& t) const { return CheckRT(t); } CheckPoint checkrep() const { return CheckPoint(convert(hx()),convert(hy()),convert(w())); } #endif // KERNEL_CHECK }; template std::ostream& operator<<(std::ostream& os, const Extended_point& p) { switch( os.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : os << p.hx() << " " << p.hy() << " " << p.hw(); break; case CGAL::IO::BINARY : CGAL::write(os,p.hx());CGAL::write(os,p.hy()); CGAL::write(os,p.hw()); break; default: os << "(" << p.hx() << "," << p.hy() << "," << p.hw() << ")"; #if 0 os << "((" << CGAL::to_double(p.nx())/CGAL::to_double(p.hw()) << "," << CGAL::to_double(p.ny())/CGAL::to_double(p.hw()) << "))"; #endif } return os; } template std::istream& operator>>(std::istream& is, Extended_point& p) { SPolynomial x,y; RT w; switch( is.iword(CGAL::IO::mode) ){ case CGAL::IO::ASCII : is >> x >> y >> w; break; case CGAL::IO::BINARY : CGAL::read(is,x);CGAL::read(is,y);CGAL::read(is,w); break; default: CGAL_assertion_msg(0,"\nStream must be in ascii or binary mode\n"); break; } p = Extended_point(x,y,w); return is; } template inline int orientation_coeff2(const NT& mx1, const NT& /*nx1*/, const NT& my1, const NT& /*ny1*/, const NT& w1, const NT& mx2, const NT& /*nx2*/, const NT& my2, const NT& /*ny2*/, const NT& w2, const NT& mx3, const NT& /*nx3*/, const NT& my3, const NT& /*ny3*/, const NT& w3) { NT coeff2 = mx1*w3*my2-mx1*w2*my3+mx3*w2*my1- mx2*w3*my1-mx3*w1*my2+mx2*w1*my3; return CGAL_NTS sign(coeff2); } template inline int orientation_coeff1(const NT& mx1, const NT& nx1, const NT& my1, const NT& ny1, const NT& w1, const NT& mx2, const NT& nx2, const NT& my2, const NT& ny2, const NT& w2, const NT& mx3, const NT& nx3, const NT& my3, const NT& ny3, const NT& w3) { NT coeff1 = mx1*w3*ny2-mx1*w2*ny3+nx1*w3*my2-mx2*w3*ny1- nx1*w2*my3+mx2*w1*ny3-nx2*w3*my1+mx3*w2*ny1+ nx2*w1*my3-mx3*w1*ny2+nx3*w2*my1-nx3*w1*my2; return CGAL_NTS sign(coeff1); } template inline int orientation_coeff0(const NT& /*mx1*/, const NT& nx1, const NT& /*my1*/, const NT& ny1, const NT& w1, const NT& /*mx2*/, const NT& nx2, const NT& /*my2*/, const NT& ny2, const NT& w2, const NT& /*mx3*/, const NT& nx3, const NT& /*my3*/, const NT& ny3, const NT& w3) { NT coeff0 = -nx2*w3*ny1+nx1*w3*ny2+nx2*w1*ny3- nx1*w2*ny3+nx3*w2*ny1-nx3*w1*ny2; return CGAL_NTS sign(coeff0); } DEFCOUNTER(or0) DEFCOUNTER(or1) DEFCOUNTER(or2) template int orientation(const Extended_point& p1, const Extended_point& p2, const Extended_point& p3) { CGAL_NEF_TRACEN("orientation "< Protection; res = orientation_coeff2(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or2); res = orientation_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); } if ( res != 0 ) return res; try { INCTOTAL(or1); Protect_FPU_rounding Protection; res = orientation_coeff1(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or1); res = orientation_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); } if ( res != 0 ) return res; try { INCTOTAL(or0); Protect_FPU_rounding Protection; res = orientation_coeff0(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(or0); res = orientation_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw()); } return res; } template inline int compare_expr(const NT& n1, const NT& d1, const NT& n2, const NT& d2) { return CGAL_NTS sign( n1*d2 - n2*d1 ); } DEFCOUNTER(cmpx0) DEFCOUNTER(cmpx1) template int compare_x(const Extended_point& p1, const Extended_point& p2) { int res; try { INCTOTAL(cmpx1); Protect_FPU_rounding Protection; res = compare_expr(p1.mxD(),p1.hwD(),p2.mxD(),p2.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx1); res = compare_expr(p1.mx(),p1.hw(),p2.mx(),p2.hw()); } if ( res != 0 ) return res; try { INCTOTAL(cmpx0); Protect_FPU_rounding Protection; res = compare_expr(p1.nxD(),p1.hwD(),p2.nxD(),p2.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpx0); res = compare_expr(p1.nx(),p1.hw(),p2.nx(),p2.hw()); } return res; } DEFCOUNTER(cmpy0) DEFCOUNTER(cmpy1) template int compare_y(const Extended_point& p1, const Extended_point& p2) { int res; try { INCTOTAL(cmpy1); Protect_FPU_rounding Protection; res = compare_expr(p1.myD(),p1.hwD(),p2.myD(),p2.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy1); res = compare_expr(p1.my(),p1.hw(),p2.my(),p2.hw()); } if ( res != 0 ) return res; try { INCTOTAL(cmpy0); Protect_FPU_rounding Protection; res = compare_expr(p1.nyD(),p1.hwD(),p2.nyD(),p2.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmpy0); res = compare_expr(p1.ny(),p1.hw(),p2.ny(),p2.hw()); } return res; } template inline int compare_xy(const Extended_point& p1, const Extended_point& p2) { int c1 = compare_x(p1,p2); if ( c1 != 0 ) return c1; else return compare_y(p1,p2); } template inline bool strictly_ordered_along_line(const Extended_point& p1, const Extended_point& p2, const Extended_point& p3) { return ( orientation(p1,p2,p3) == 0 ) && ( compare_xy(p1,p2) * compare_xy(p2,p3) == 1 ); } template inline bool operator==(const Extended_point& p1, const Extended_point& p2) { CHECK(bool(compare_xy(p1,p2) == 0),p1.checkrep()==p2.checkrep()) return (p1.identical(p2) || compare_xy(p1,p2) == 0); } template inline bool operator!=(const Extended_point& p1, const Extended_point& p2) { return !(p1==p2); } template inline int cmppd_coeff2(const NT& mx1, const NT& /*nx1*/, const NT& my1, const NT& /*ny1*/, const NT& w1, const NT& mx2, const NT& /*nx2*/, const NT& my2, const NT& /*ny2*/, const NT& w2, const NT& mx3, const NT& /*nx3*/, const NT& my3, const NT& /*ny3*/, const NT& w3, const NT& mx4, const NT& /*nx4*/, const NT& my4, const NT& /*ny4*/, const NT& w4) { NT w1Q(w1*w1), w2Q(w2*w2), w3Q(w3*w3), w4Q(w4*w4); NT w1w2Q(w1Q*w2Q), w3w4Q(w3Q*w4Q), two(2); NT coeff2 = w3w4Q * w2Q *mx1*mx1- two* w3w4Q *w2*mx1*w1*mx2+ w3w4Q * w1Q *mx2*mx2+ w3w4Q * w2Q *my1*my1- two* w3w4Q *w2*my1*w1*my2+ w3w4Q * w1Q *my2*my2- w1w2Q * w4Q *mx3*mx3+ two* w1w2Q *w4*mx3*w3*mx4- w1w2Q * w3Q *mx4*mx4- w1w2Q * w4Q *my3*my3+ two* w1w2Q *w4*my3*w3*my4- w1w2Q * w3Q *my4*my4; return CGAL_NTS sign(coeff2); } template inline int cmppd_coeff1(const NT& mx1, const NT& nx1, const NT& my1, const NT& ny1, const NT& w1, const NT& mx2, const NT& nx2, const NT& my2, const NT& ny2, const NT& w2, const NT& mx3, const NT& nx3, const NT& my3, const NT& ny3, const NT& w3, const NT& mx4, const NT& nx4, const NT& my4, const NT& ny4, const NT& w4) { NT w1Q(w1*w1), w2Q(w2*w2), w3Q(w3*w3), w4Q(w4*w4); NT w1w2Q(w1Q*w2Q), w3w4Q(w3Q*w4Q), two(2); NT coeff1 = two * (w3w4Q * w1Q * mx2*nx2- w3w4Q * w2*my1*w1*ny2+ w3w4Q * w1Q * my2*ny2+ w1w2Q * w4*nx3*w3*mx4- w1w2Q * w4Q *mx3*nx3+ w3w4Q * w2Q *mx1*nx1- w3w4Q * w2*mx1*w1*nx2- w3w4Q * w2*nx1*w1*mx2- w3w4Q * w2*ny1*w1*my2- w1w2Q * w4Q *my3*ny3+ w1w2Q * w4*my3*w3*ny4+ w1w2Q * w4*ny3*w3*my4+ w3w4Q * w2Q *my1*ny1- w1w2Q * w3Q *my4*ny4+ w1w2Q * w4*mx3*w3*nx4- w1w2Q * w3Q *mx4*nx4); return CGAL_NTS sign(coeff1); } template inline int cmppd_coeff0(const NT& /*mx1*/, const NT& nx1, const NT& /*my1*/, const NT& ny1, const NT& w1, const NT& /*mx2*/, const NT& nx2, const NT& /*my2*/, const NT& ny2, const NT& w2, const NT& /*mx3*/, const NT& nx3, const NT& /*my3*/, const NT& ny3, const NT& w3, const NT& /*mx4*/, const NT& nx4, const NT& /*my4*/, const NT& ny4, const NT& w4) { NT w1Q(w1*w1), w2Q(w2*w2), w3Q(w3*w3), w4Q(w4*w4); NT w1w2Q(w1Q*w2Q), w3w4Q(w3Q*w4Q), two(2); NT coeff0 = w3w4Q * (w1Q * ( nx2*nx2 + ny2*ny2 ) + w2Q * ( ny1*ny1 + nx1*nx1 )) - w1w2Q * (w4Q * ( nx3*nx3 + ny3*ny3 ) + w3Q * ( nx4*nx4 + ny4*ny4 )) + two* (- w3w4Q * (w2*nx1*w1*nx2 + w2*ny1*w1*ny2) + w1w2Q * (w4*ny3*w3*ny4 + w4*nx3*w3*nx4)); return CGAL_NTS sign(coeff0); } DEFCOUNTER(cmppd2) DEFCOUNTER(cmppd1) DEFCOUNTER(cmppd0) // leghth.mws template int compare_pair_dist( const Extended_point& p1, const Extended_point& p2, const Extended_point& p3, const Extended_point& p4) { int res; try { INCTOTAL(cmppd2); Protect_FPU_rounding Protection; res = cmppd_coeff2(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd2); res = cmppd_coeff2(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw()); } if ( res != 0 ) return res; try { INCTOTAL(cmppd1); Protect_FPU_rounding Protection; res = cmppd_coeff1(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd1); res = cmppd_coeff1(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw()); } if ( res != 0 ) return res; try { INCTOTAL(cmppd0); Protect_FPU_rounding Protection; res = cmppd_coeff0(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(cmppd0); res = cmppd_coeff0(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw()); } return res; } template class Extended_segment { Extended_point _p1,_p2; public: Extended_segment() : _p1(),_p2() {} Extended_segment(const Extended_point& p1, const Extended_point& p2) : _p1(p1), _p2(p2) {} Extended_segment(const Extended_segment& s) : _p1(s._p1), _p2(s._p2) {} Extended_segment& operator=(const Extended_segment& s) { _p1 = s._p1; _p2 = s._p2; return *this; } const Extended_point& source() const { return _p1; } const Extended_point& target() const { return _p2; } void line_equation(RT& a, RT& b, SPolynomial& c) const; }; template std::ostream& operator<<(std::ostream& os, const Extended_segment& s) { os << s.source() << s.target(); return os; } template std::istream& operator>>(std::istream& is, Extended_segment& s) { Extended_point p1,p2; is >> p1 >> p2; s=Extended_segment(p1,p2); return is; } template void Extended_segment:: line_equation(RT& a, RT& b, SPolynomial& c) const { bool sstandard = _p1.is_standard(); bool tstandard = _p2.is_standard(); if (sstandard && tstandard) { a = _p1.ny()*_p2.hw() - _p2.ny()*_p1.hw(); b = _p1.hw()*_p2.nx() - _p2.hw()*_p1.nx(); c = SPolynomial(_p1.nx()*_p2.ny() - _p2.nx()*_p1.ny()); return; } Extended_point p; bool correct_orientation=true; if (!sstandard && !tstandard) { bool x_equal = (_p1.hx()*_p2.hw() - _p2.hx()*_p1.hw()).is_zero(); bool y_equal = (_p1.hy()*_p2.hw() - _p2.hy()*_p1.hw()).is_zero(); if (x_equal && CGAL_NTS abs(_p1.mx())==_p1.hw() && _p1.nx()==0 ) { int dy = (_p2.hy()-_p1.hy()).sign(); a=-dy; b=0; c = SPolynomial(dy*_p1.hx().sign(),0); return; } if (y_equal && CGAL_NTS abs(_p1.my())==_p1.hw() && _p1.ny()==0 ) { int dx = (_p2.hx()-_p1.hx()).sign(); a=0; b=dx; c = SPolynomial(-dx*_p1.hy().sign(),0); return; } p = _p2; // evaluation according to mixed case } else if (sstandard && !tstandard) { p = _p2; } else if (!sstandard && tstandard) { p = _p1; correct_orientation=false; } RT w = p.hw(); RT ci; if ( correct_orientation ) { a = -p.my(); b = p.mx(); ci = (p.nx()*p.my()-p.ny()*p.mx())/w; } else { a = p.my(); b = -p.mx(); ci = (p.ny()*p.mx()-p.nx()*p.my())/w; } c = SPolynomial(ci); } template Extended_point intersection( const Extended_segment& s1, const Extended_segment& s2) { RT a1,b1,a2,b2; SPolynomial c1,c2; s1.line_equation(a1,b1,c1); s2.line_equation(a2,b2,c2); SPolynomial x = c2*b1 - c1*b2; SPolynomial y = c1*a2 - c2*a1; RT w = a1*b2 - a2*b1; CGAL_assertion(w!=0); #ifdef REDUCE_INTERSECTION_POINTS RT xgcd,ygcd; if ( x.m() == RT(0) ) xgcd = ( x.n() == 0 ? RT(1) : x.n() ); else /* != 0 */ xgcd = ( x.n() == 0 ? x.m() : CGAL_NTS gcd(x.m(),x.n()) ); if ( y.m() == RT(0) ) ygcd = ( y.n() == 0 ? RT(1) : y.n() ); else /* != 0 */ ygcd = ( y.n() == 0 ? y.m() : CGAL_NTS gcd(y.m(),y.n()) ); RT d = CGAL_NTS gcd(w,CGAL_NTS gcd(xgcd,ygcd)); x /= d; y /= d; w /= d; #endif // REDUCE_INTERSECTION_POINTS return Extended_point(x,y,w); } template inline int orientation(const Extended_segment& s, const Extended_point& p) { return orientation(s.source(),s.target(),p); } template inline bool is_degenerate(const Extended_segment& s) { return s.source()==s.target(); } template inline bool contains(const Extended_segment& s, const Extended_point& p) { int p_rel_source = compare_xy(p,s.source()); int p_rel_target = compare_xy(p,s.target()); return ( orientation(s,p) == 0 ) && ( p_rel_source >= 0 && p_rel_target <= 0 || p_rel_source <= 0 && p_rel_target >= 0 ); } template class Extended_direction { Extended_point _p1,_p2; public: Extended_direction() : _p1(),_p2() {} Extended_direction(const Extended_direction& d) : _p1(d._p1),_p2(d._p2) {} Extended_direction& operator=(const Extended_direction& d) { _p1 = d._p1; _p2 = d._p2; return *this; } Extended_direction(const Extended_point& p1, const Extended_point& p2) : _p1(p1),_p2(p2) {} Extended_direction(const RT& x, const RT& y) : _p1(0,0,1),_p2(x,y,1) {} const Extended_point& p1() const { return _p1; } const Extended_point& p2() const { return _p2; } int dx_sign() const { return (_p2.hx()*_p1.hw()-_p1.hx()*_p2.hw()).sign(); } int dy_sign() const { return (_p2.hy()*_p1.hw()-_p1.hy()*_p2.hw()).sign(); } }; template std::ostream& operator<<(std::ostream& os, const Extended_direction& d) { os << d.p1() << "," << d.p2(); return os; } template std::istream& operator>>(std::istream& is, Extended_direction& d) { Extended_point x,y; is >> x >> y; d = Extended_direction(x,y); return is; } template inline int coeff2_dor(const NT& mx1, const NT& /*nx1*/, const NT& my1, const NT& /*ny1*/, const NT& w1, const NT& mx2, const NT& /*nx2*/, const NT& my2, const NT& /*ny2*/, const NT& w2, const NT& mx3, const NT& /*nx3*/, const NT& my3, const NT& /*ny3*/, const NT& w3, const NT& mx4, const NT& /*nx4*/, const NT& my4, const NT& /*ny4*/, const NT& w4) { NT coeff2 = w1*mx2*w3*my4-w1*mx2*w4*my3-w2*mx1*w3*my4+w2*mx1*w4*my3- w1*my2*w3*mx4+w1*my2*w4*mx3+w2*my1*w3*mx4-w2*my1*w4*mx3; return CGAL_NTS sign(coeff2); } template inline int coeff1_dor(const NT& mx1, const NT& nx1, const NT& my1, const NT& ny1, const NT& w1, const NT& mx2, const NT& nx2, const NT& my2, const NT& ny2, const NT& w2, const NT& mx3, const NT& nx3, const NT& my3, const NT& ny3, const NT& w3, const NT& mx4, const NT& nx4, const NT& my4, const NT& ny4, const NT& w4) { NT coeff1 = -w1*my2*w3*nx4+w1*mx2*w3*ny4+w1*my2*w4*nx3-w1*mx2*w4*ny3+ w1*nx2*w3*my4-w1*nx2*w4*my3+w2*my1*w3*nx4-w2*mx1*w3*ny4- w2*my1*w4*nx3+w2*mx1*w4*ny3-w2*nx1*w3*my4+w2*nx1*w4*my3- w1*ny2*w3*mx4+w1*ny2*w4*mx3+w2*ny1*w3*mx4-w2*ny1*w4*mx3; return CGAL_NTS sign(coeff1); } template inline int coeff0_dor(const NT& /*mx1*/, const NT& nx1, const NT& /*my1*/, const NT& ny1, const NT& w1, const NT& /*mx2*/, const NT& nx2, const NT& /*my2*/, const NT& ny2, const NT& w2, const NT& /*mx3*/, const NT& nx3, const NT& /*my3*/, const NT& ny3, const NT& w3, const NT& /*mx4*/, const NT& nx4, const NT& /*my4*/, const NT& ny4, const NT& w4) { NT coeff0 = w1*nx2*w3*ny4-w1*nx2*w4*ny3-w2*nx1*w3*ny4+w2*nx1*w4*ny3- w1*ny2*w3*nx4+w1*ny2*w4*nx3+w2*ny1*w3*nx4-w2*ny1*w4*nx3; return CGAL_NTS sign(coeff0); } DEFCOUNTER(ord2) DEFCOUNTER(ord1) DEFCOUNTER(ord0) template inline int orientation(const Extended_direction& d1, const Extended_direction& d2) { Extended_point p1(d1.p1()), p2(d1.p2()), p3(d2.p1()), p4(d2.p2()); int res; try { INCTOTAL(ord2); Protect_FPU_rounding Protection; res = coeff2_dor(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord2); res = coeff2_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw()); } if ( res != 0 ) return res; try { INCTOTAL(ord1); Protect_FPU_rounding Protection; res = coeff1_dor(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord1); res = coeff1_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw()); } if ( res != 0 ) return res; try { INCTOTAL(ord0); Protect_FPU_rounding Protection; res = coeff0_dor(p1.mxD(),p1.nxD(),p1.myD(),p1.nyD(),p1.hwD(), p2.mxD(),p2.nxD(),p2.myD(),p2.nyD(),p2.hwD(), p3.mxD(),p3.nxD(),p3.myD(),p3.nyD(),p3.hwD(), p4.mxD(),p4.nxD(),p4.myD(),p4.nyD(),p4.hwD()); } catch (Interval_nt_advanced::unsafe_comparison) { INCEXCEPTION(ord0); res = coeff0_dor(p1.mx(),p1.nx(),p1.my(),p1.ny(),p1.hw(), p2.mx(),p2.nx(),p2.my(),p2.ny(),p2.hw(), p3.mx(),p3.nx(),p3.my(),p3.ny(),p3.hw(), p4.mx(),p4.nx(),p4.my(),p4.ny(),p4.hw()); } return res; } template inline bool operator==(const Extended_direction& d1, const Extended_direction& d2) { return orientation(d1,d2) == 0 && d1.dx_sign() == d2.dx_sign() && d1.dy_sign() == d2.dy_sign(); } template inline bool operator!=(const Extended_direction& d1, const Extended_direction& d2) { return !(d1==d2); } template bool strictly_ordered_ccw(const Extended_direction& d1, const Extended_direction& d2, const Extended_direction& d3) { if (d1 == d3) return (d1 != d2); int or12 = orientation(d1,d2); int or13 = orientation(d1,d3); int or32 = orientation(d3,d2); if ( or13 >= 0 ) // not right_turn return ( or12 > 0 && or32 < 0 ); else // ( or13 < 0 ) right_turn return ( or12 > 0 || or32 < 0 ); } template inline bool operator<(const Extended_direction& d1, const Extended_direction& d2) { Extended_direction d0(1,0); bool d0d1eq = (d1 == d0); bool d0d2eq = (d2 == d0); return (d0d1eq && !d0d2eq) || strictly_ordered_ccw(d0,d1,d2) && !d0d2eq; } template class Filtered_extended_homogeneous { typedef Filtered_extended_homogeneous Self; public: typedef CGAL::Homogeneous Standard_kernel; typedef typename Standard_kernel::RT Standard_RT; typedef typename Standard_kernel::FT Standard_FT; typedef typename Standard_kernel::Point_2 Standard_point_2; typedef typename Standard_kernel::Segment_2 Standard_segment_2; typedef typename Standard_kernel::Line_2 Standard_line_2; typedef typename Standard_kernel::Direction_2 Standard_direction_2; typedef typename Standard_kernel::Ray_2 Standard_ray_2; typedef typename Standard_kernel::Aff_transformation_2 Standard_aff_transformation_2; typedef SPolynomial RT; typedef SQuotient FT; typedef Extended_point Point_2; typedef Extended_segment Segment_2; typedef Extended_direction Direction_2; #ifdef KERNEL_CHECK typedef Extended_homogeneous CheckKernel; typedef typename CheckKernel::Point_2 CheckPoint; typedef typename CheckKernel::Direction_2 CheckDirection; typedef typename CheckKernel::Segment_2 CheckSegment; CheckKernel K; CheckSegment convert(const Segment_2& s) const { return CheckSegment(s.source().checkrep(), s.target().checkrep()); } CheckDirection convert(const Direction_2& d) const { return K.construct_direction(d.p2().checkrep(),d.p1().checkrep()); } #endif // KERNEL_CHECK enum Point_type { SWCORNER=1, LEFTFRAME, NWCORNER, BOTTOMFRAME, STANDARD, TOPFRAME, SECORNER, RIGHTFRAME, NECORNER }; Standard_RT dx(const Standard_line_2& l) const { return l.b(); } Standard_RT dy(const Standard_line_2& l) const { return -l.a(); } Standard_FT abscissa_distance(const Standard_line_2& l) const { return Standard_kernel::make_FT(-l.c(),l.b()); } Point_type determine_type(const Standard_line_2& l) const { // CGAL_NEF_TRACEN("determine_type "< 0 || cmp_dx_dy == 0 && sdy != (s=CGAL_NTS sign(abscissa_distance(l))))) { if (0 == s) return ( sdy < 0 ? SWCORNER : NWCORNER ); else return LEFTFRAME; } else if (sdx > 0 && ( cmp_dx_dy > 0 || cmp_dx_dy == 0 && sdy != (s=CGAL_NTS sign(abscissa_distance(l))))) { if (0 == s) return ( sdy < 0 ? SECORNER : NECORNER ); else return RIGHTFRAME; } else if (sdy < 0 && ( cmp_dx_dy < 0 || cmp_dx_dy == 0 && abscissa_distance(l) < Standard_FT(0))) { return BOTTOMFRAME; } else if (sdy > 0 && ( cmp_dx_dy < 0 || cmp_dx_dy == 0 && abscissa_distance(l) > Standard_FT(0))) { return TOPFRAME; } CGAL_assertion_msg(false," determine_type: degenerate line."); return (Point_type)-1; // never come here } Point_2 epoint(const Standard_RT& m1, const Standard_RT& n1, const Standard_RT& m2, const Standard_RT& n2, const Standard_RT& n3) const { return Point_2(m1,n1,m2,n2,n3); } public: Point_2 construct_point(const Standard_point_2& p) const { return Point_2(p.hx(), p.hy(), p.hw()); } Point_2 construct_point(const Standard_line_2& l, Point_type& t) const { t = determine_type(l); // CGAL_NEF_TRACEN("construct_point(line)"<ry) { if (sx > 0) return RIGHTFRAME; else return LEFTFRAME; } if (rx 0) return TOPFRAME; else return BOTTOMFRAME; } // now (rx == ry) if (sx==sy) { if (sx < 0) return SWCORNER; else return NECORNER; } else { CGAL_assertion(sx==-sy); if (sx < 0) return NWCORNER; else return SECORNER; } } bool is_standard(const Point_2& p) const { return p.is_standard(); } Standard_point_2 standard_point(const Point_2& p) const { CGAL_assertion(is_standard(p)); return Standard_point_2(p.nx(),p.ny(),p.hw()); } Standard_line_2 standard_line(const Point_2& p) const { CGAL_assertion(!p.is_standard()); Standard_point_2 p0(p.nx(),p.ny(),p.hw()); Standard_point_2 p1(p.mx()+p.nx(),p.my()+p.ny(),p.hw()); return Standard_line_2(p0,p1); } Standard_ray_2 standard_ray(const Point_2& p) const { CGAL_assertion(!p.is_standard()); Standard_line_2 l = standard_line(p); Standard_direction_2 d = l.direction(); Standard_point_2 q = l.point(0); return Standard_ray_2(q,d); } Point_2 NE() const { return construct_point(Standard_line_2(-1, 1,0)); } Point_2 SE() const { return construct_point(Standard_line_2( 1, 1,0)); } Point_2 NW() const { return construct_point(Standard_line_2(-1,-1,0)); } Point_2 SW() const { return construct_point(Standard_line_2( 1,-1,0)); } int orientation(const Point_2& p1, const Point_2& p2, const Point_2& p3) const { CHECK(K.orientation(p1.checkrep(),p2.checkrep(),p3.checkrep()), CGAL::orientation(p1,p2,p3)) return CGAL::orientation(p1,p2,p3); } bool left_turn(const Point_2& p1, const Point_2& p2, const Point_2& p3) const { return orientation(p1,p2,p3) > 0; } bool first_pair_closer_than_second( const Point_2& p1, const Point_2& p2, const Point_2& p3, const Point_2& p4) const { CHECK(K.first_pair_closer_than_second(p1.checkrep(),p2.checkrep(), p3.checkrep(),p4.checkrep()), CGAL::compare_pair_dist(p1,p2,p3,p4)<0) return CGAL::compare_pair_dist(p1,p2,p3,p4)<0; } int compare_xy(const Point_2& p1, const Point_2& p2) const { CHECK(K.compare_xy(p1.checkrep(),p2.checkrep()), CGAL::compare_xy(p1,p2)) return CGAL::compare_xy(p1,p2); } int compare_x(const Point_2& p1, const Point_2& p2) const { CHECK(K.compare_x(p1.checkrep(),p2.checkrep()), CGAL::compare_x(p1,p2)) return CGAL::compare_x(p1,p2); } int compare_y(const Point_2& p1, const Point_2& p2) const { CHECK(K.compare_y(p1.checkrep(),p2.checkrep()), CGAL::compare_y(p1,p2)) return CGAL::compare_y(p1,p2); } bool strictly_ordered_along_line( const Point_2& p1, const Point_2& p2, const Point_2& p3) const { CHECK(K.strictly_ordered_along_line( p1.checkrep(),p2.checkrep(),p3.checkrep()), CGAL::strictly_ordered_along_line(p1,p2,p3)) return CGAL::strictly_ordered_along_line(p1,p2,p3); } Segment_2 construct_segment(const Point_2& p, const Point_2& q) const { return Segment_2(p,q); } Point_2 source(const Segment_2& s) const { return s.source(); } Point_2 target(const Segment_2& s) const { return s.target(); } bool is_degenerate(const Segment_2& s) const { return s.source()==s.target(); } int orientation(const Segment_2& s, const Point_2& p) const { return orientation(s.source(),s.target(),p); } Point_2 intersection(const Segment_2& s1, const Segment_2& s2) const { CHECK(CGAL::intersection(s1,s2).checkrep(), K.intersection(convert(s1),convert(s2))) return CGAL::intersection(s1,s2); } bool contains(const Segment_2& s, const Point_2& p) const /*{\Mop returns true iff |s| contains |p|.}*/ { return CGAL::contains(s,p); } Direction_2 construct_direction( const Point_2& p1, const Point_2& p2) const { return Direction_2(p1,p2); } bool strictly_ordered_ccw(const Direction_2& d1, const Direction_2& d2, const Direction_2& d3) const { CHECK(K.strictly_ordered_ccw(convert(d1),convert(d2),convert(d3)), CGAL::strictly_ordered_ccw(d1,d2,d3)); return CGAL::strictly_ordered_ccw(d1,d2,d3); } void print_statistics() const { std::cout << "Statistics of filtered kernel:\n"; std::cout << "total failed double filter stages = "; std::cout << CGAL::Interval_nt_advanced::number_of_failures << std::endl; PRINT_CHECK_ENABLED; PRINT_STATISTICS(or2); PRINT_STATISTICS(or1); PRINT_STATISTICS(or0); PRINT_STATISTICS(cmpx1); PRINT_STATISTICS(cmpx0); PRINT_STATISTICS(cmpy1); PRINT_STATISTICS(cmpy0); PRINT_STATISTICS(cmppd2); PRINT_STATISTICS(cmppd1); PRINT_STATISTICS(cmppd0); PRINT_STATISTICS(ord2); PRINT_STATISTICS(ord1); PRINT_STATISTICS(ord0); } template void determine_frame_radius(Forward_iterator start, Forward_iterator end, Standard_RT& R0) const { Standard_RT R; while ( start != end ) { Point_2 p = *start; if ( is_standard(p) ) { R = CGAL_NTS max(CGAL_NTS abs(p.mx())/p.hw(), CGAL_NTS abs(p.my())/p.hw()); } else { RT rx = CGAL_NTS abs(p.hx()), ry = CGAL_NTS abs(p.hy()); if ( rx[1] > ry[1] ) R = CGAL_NTS abs(ry[0]-rx[0])/(rx[1]-ry[1]); else if ( rx[1] < ry[1] ) R = CGAL_NTS abs(rx[0]-ry[0])/(ry[1]-rx[1]); else /* rx[1] == ry[1] */ R = CGAL_NTS abs(rx[0]-ry[0])/(2*p.hw()); } R0 = CGAL_NTS max(R+1,R0); ++start; } } const char* output_identifier() const { return "Filtered_extended_homogeneous"; } }; CGAL_END_NAMESPACE #undef CHECK #undef KERNEL_CHECK #undef REDUCE_INTERSECTION_POINTS #undef KERNEL_ANALYSIS #undef COUNTER #undef INCTOTAL #undef INCEXCEPTION #undef PRINT_STATISTICS #undef PRINT_CHECK_ENABLED #endif // CGAL_FILTERED_EXTENDED_HOMOGENEOUS_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_face_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulat0000644000175000017500000000745211344301500031456 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_face_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_CONSTRAINED_TRIANGULATION_FACE_BASE_2_H #define CGAL_CONSTRAINED_TRIANGULATION_FACE_BASE_2_H #include #include #include CGAL_BEGIN_NAMESPACE template > class Constrained_triangulation_face_base_2 : public Fb { typedef Fb Base; typedef typename Fb::Triangulation_data_structure TDS; public: typedef Gt Geom_traits; typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Face_handle Face_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Fb2; typedef Constrained_triangulation_face_base_2 Other; }; protected: bool C[3]; public: Constrained_triangulation_face_base_2() : Base() { set_constraints(false,false,false); } Constrained_triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Base(v0,v1,v2) { set_constraints(false,false,false); } Constrained_triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Base(v0,v1,v2,n0,n1,n2) { set_constraints(false,false,false); } Constrained_triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2, bool c0, bool c1, bool c2 ) : Base(v0,v1,v2,n0,n1,n2) { set_constraints(c0,c1,c2); } bool is_constrained(int i) const ; void set_constraints(bool c0, bool c1, bool c2) ; void set_constraint(int i, bool b); void reorient(); void ccw_permute(); void cw_permute(); }; template inline void Constrained_triangulation_face_base_2:: set_constraints(bool c0, bool c1, bool c2) { C[0]=c0; C[1]=c1; C[2]=c2; } template inline void Constrained_triangulation_face_base_2:: set_constraint(int i, bool b) { CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2); C[i] = b; } template inline bool Constrained_triangulation_face_base_2:: is_constrained(int i) const { return(C[i]); } template inline void Constrained_triangulation_face_base_2:: reorient() { Base::reorient(); set_constraints(C[1],C[0],C[2]); } template inline void Constrained_triangulation_face_base_2:: ccw_permute() { Base::ccw_permute(); set_constraints(C[2],C[0],C[1]); } template inline void Constrained_triangulation_face_base_2:: cw_permute() { Base::cw_permute(); set_constraints(C[1],C[2],C[0]); } CGAL_END_NAMESPACE #endif //CGAL_CONSTRAINED_TRIANGULATION_FACE_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Simplicity_test.h0000644000175000017500000004636011344301501030370 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Simplicity_test.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Wieger Wesselink #ifndef CGAL_SIMPLICITY_TEST_H #define CGAL_SIMPLICITY_TEST_H #error "FILE IS OBSOLETE AND SHOULD NOT GET INCLUDED" // ==== This file is now OBSOLETE ===== // ==== The functionality has been placed in Polygon_2_simplicity.h ==== #include #include #include #include #include "CGAL/polygon_assertions.h" CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Simplicity_test_2 //-----------------------------------------------------------------------// // The simplicity test is implemented as a class. // The algorithm used is a sweep line algorithm. The sweep line is a // horizontal line that sweeps from top (big y) to bottom. // In the sweep status the edges are ordered from left (small) to right // (big). template class Simplicity_test_2 { protected: std::vector d_index; // the attribute d_index is just a mapping between the integers and the // sequence of points int d_eventpoint; // the index of the current event point // the current sweepline is the horizontal line through this point const Traits& d_traits; // the traits class for polygons public: typedef typename Traits::Point_2 Point_2; Simplicity_test_2(const Traits& tr): d_traits(tr) {} ~Simplicity_test_2() {} const Traits& traits() const { return d_traits; } const Point_2& Vertex(int i) const { return *d_index[i]; } int NumberOfVertices() const { return d_index.size(); } const Point_2& EventPoint() const { return Vertex(d_eventpoint); } // return the current event point bool Test(ForwardIterator first, ForwardIterator last); // tests if the polygon with points in the range [first,last) is simple bool EdgesDoIntersect(int e1, int e2) const; // tests if the edges e1 and e2 have an intersection // N.B. the common vertex of two consecutive edges is not counted // as an intersection! bool VertexCompare(int i, int j) const; // compares the (lexicographical) order of vertex(i) and vertex(j) class VertexComp { protected: const Simplicity_test_2* s; public: VertexComp() {} VertexComp( const Simplicity_test_2* s0): s(s0) {} bool operator() (int i, int j) const { return s->VertexCompare(i,j); } }; bool has_on_left_side(const Point_2& p, const Point_2& q, const Point_2& r ) const // returns true if point p is left of the point w, where w is the leftmost // intersection point of the horizontal line through p and the line // segment qr // N.B. if p lies on the segment qr, the result is indeterminate. { Comparison_result qr = d_traits.compare_y(q,r); if (qr == EQUAL) return (d_traits.compare_x(p,q) == SMALLER); else return ( d_traits.is_negative(d_traits.cross_product_2(p-q,r-q)) == (qr == SMALLER) ); } bool has_y_overlap(const Point_2& p, const Point_2& q, const Point_2& r ) const // returns true if the horizontal line through p intersects the segments qr { Comparison_result pq = d_traits.compare_y(p,q); Comparison_result pr = d_traits.compare_y(p,r); return (pq != pr) || (pq == EQUAL); } bool EdgeCompare(int e1, int e2) const; // computes the order of two edges e1 and e2 on the current sweepline bool edge_compare_consecutive(int e1, int e2) const; // computes the order of two edges e1 and e2 that share a vertex bool edge_compare_non_consecutive(int e1, int e2) const; // computes the order of two edges e1 and e2 that do not share a vertex bool consecutive_edges(int e1, int e2) const; // true if the edges e1 and e2 are not equal but share a vertex class EdgeComp { protected: const Simplicity_test_2* s; public: EdgeComp() {} EdgeComp( const Simplicity_test_2* s0): s(s0) {} bool operator() (int i, int j) const { return s->EdgeCompare(i,j); } }; class EventQueue { //-----------------------------------------------------------------// // g++ 2.7.2 seems to have problems with the following typedef // // typedef set::const_iterator const_iterator; //-----------------------------------------------------------------// protected: std::set queue; public: EventQueue(Simplicity_test_2* s) : queue(VertexComp(s)) {} bool insert(int i) { return queue.insert(i).second; } bool empty() const { return queue.empty(); } int pop() { int Result = *(queue.begin()); queue.erase(queue.begin()); return Result; } #ifdef CGAL_POLYGON_DEBUG void Show() const { cout << " event queue: "; typename std::set::const_iterator i; for (i = queue.begin(); i != queue.end(); ++i) cout << *i << " "; cout << endl; } #endif }; class SweepStatus { //-----------------------------------------------------------------// // g++ 2.7.2 seems to have problems with the following typedef // // typedef std::set::const_iterator const_iterator; //-----------------------------------------------------------------// protected: std::set status; // if i is an element of status, it means that std::vector::iterator> index; // the iterators of the edges are stored to enable fast deletion const Simplicity_test_2* s; // store a pointer to the Simplicity_test_2 class, to enable // access to the vertices public: SweepStatus( const Simplicity_test_2* s0, int n) : status(EdgeComp(s0)), s(s0) { index.insert(index.end(),n,status.end()); } bool is_valid() // A necessary condition for the sweep status to be valid is that // // 1) every edge in the status intersects the current sweepline // 2) the edges are ordered along the current sweepline { int n = s->NumberOfVertices(); typename std::set::const_iterator i; for (i = status.begin(); i != status.end(); ++i) { int v1 = *i; int v2 = (v1traits().compare_y(s->Vertex(v1), s->EventPoint()); Comparison_result c2 = s->traits().compare_y(s->Vertex(v2), s->EventPoint()); if (c1 == SMALLER && c2 == SMALLER) return false; if (c1 == LARGER && c2 == LARGER) return false; } return true; } #ifdef CGAL_POLYGON_DEBUG void Show() { cout << " sweep status: "; typename std::set::const_iterator i; for (i = status.begin(); i != status.end(); ++i) cout << *i << " "; cout << endl; } #endif // CGAL_POLYGON_DEBUG void insert(int e) { #ifdef CGAL_POLYGON_DEBUG { cout << endl << " inserting edge " << e << " into sweep status" << endl; } #endif // CGAL_POLYGON_DEBUG index[e] = status.insert(e).first; } void erase(int e) { #ifdef CGAL_POLYGON_DEBUG { cout << endl << " removing edge " << e << " from sweep status" << endl; } #endif // CGAL_POLYGON_DEBUG status.erase(index[e]); } int replace(int e1, int e2) { #ifdef CGAL_POLYGON_DEBUG { cout << endl << " replacing edge " << e1 << " by edge "<< e2 << " in sweep status" << endl; } #endif // CGAL_POLYGON_DEBUG typename std::set::iterator cur = index[e1]; status.erase(cur++); index[e2] = status.insert(cur, e2); return e2; } int left(int e) const { typename std::set::const_iterator i = index[e]; return (i == status.begin()) ? -1 : *(--i); } int right(int e) const { typename std::set::const_iterator i = index[e]; ++i; return (i == status.end()) ? -1 : *i; } }; }; template inline bool Simplicity_test_2::VertexCompare( int i, int j) const { return !d_traits.lexicographically_yx_smaller_or_equal(Vertex(i), Vertex(j)); } template inline bool Simplicity_test_2::EdgeCompare( int e1, int e2) const { // Edges must always be compared in the same order! This is to avoid problems // with overlapping edges: // // + v0 // / // -----------------+-v2----------------- sweepline // / // / // / // / // + v1 // // In this case the order of the edges e0 = (v0,v1) and e1 = (v1,v2) on the // sweepline is indeterminate. However, it will only be detected that these // edges overlap after they have been inserted in the sweep state. To make // sure that this insertion is done correctly, the choice for the order // between e0 and e1 needs to be made consistently. bool Result; if (consecutive_edges(e1,e2)) { if (e1 < e2) Result = edge_compare_consecutive(e1,e2); else Result = !edge_compare_consecutive(e2,e1); } else { if (e1 < e2) Result = edge_compare_non_consecutive(e1,e2); else Result = !edge_compare_non_consecutive(e2,e1); } return Result; } template bool Simplicity_test_2::edge_compare_consecutive( int e1, int e2) const // This function is used to compare two edges that share a vertex: // // + | // / \ | // e1 / \ e2 | // / \ | // / \ | // -------------+---------+------------- sweepline | // / \ | // + + | // // Preconditions: 1) the shared vertex is lexicographically smaller or // lexicographically bigger than both endpoints of the two // edges (this condition is always satisfied in the // sweepline algorithm) // // 2) both edges intersect the current sweepline { int n = NumberOfVertices(); int f1 = (e1 bool Simplicity_test_2::edge_compare_non_consecutive( int e1, int e2) const { int n = NumberOfVertices(); int f1 = (e1 bool Simplicity_test_2::Test(ForwardIterator first, ForwardIterator last) { int n = 0; EventQueue events(this); while (first != last) { d_index.push_back(first); if (!events.insert(n++)) // if two vertices coincide... return false; ++first; } if (d_index.size() < 3) return true; #ifdef CGAL_POLYGON_DEBUG { cout << endl; cout << "--- Simplicity test ----------------------------" << endl; cout << endl; cout << "Vertices:" << endl; typedef typename std::vector::size_type Size_type; Size_type i; for (i=0; i0) ? i-1 : i-1+n; int next = (i= 0) && (EdgesDoIntersect(left,e))) return false; int right = status.right(e); if ((right >= 0) && (EdgesDoIntersect(e,right))) return false; } else if (prev_less_than_i) { int e1 = prev; int e2 = i; status.insert(e1); status.insert(e2); CGAL_polygon_assertion(status.is_valid()); #ifdef CGAL_POLYGON_DEBUG { cout << endl; status.Show(); } #endif // CGAL_POLYGON_DEBUG // check for intersections of newly inserted edges e1 and e2 with // neighbors int left, right; left = status.left(e1); if ((left >= 0) && (EdgesDoIntersect(left,e1))) return false; right = status.right(e1); if ((right >= 0) && (EdgesDoIntersect(e1,right))) return false; left = status.left(e2); if ((left >= 0) && (left != e1) && (EdgesDoIntersect(left,e2))) return false; right = status.right(e2); if ((right >= 0) && (right != e1) &&(EdgesDoIntersect(e2,right))) return false; } else { // check for intersections between edges that become new neighbors // in the sweep status due to the deletion int left, right; if (status.left(prev) == i) { left = status.left(i); right = status.right(prev); } else { left = status.left(prev); right = status.right(i); } status.erase(prev); status.erase(i); if (left >=0 && right >=0 && EdgesDoIntersect(left, right)) return false; CGAL_polygon_assertion(status.is_valid()); #ifdef CGAL_POLYGON_DEBUG { cout << endl; status.Show(); } #endif // CGAL_POLYGON_DEBUG } } return true; } template bool Simplicity_test_2::EdgesDoIntersect( int e1, int e2) const { #ifdef CGAL_POLYGON_DEBUG { cout << " intersecting edges " << e1 << " and " << e2 << endl; } #endif int n = NumberOfVertices(); int f1 = (e1 inline bool Simplicity_test_2::consecutive_edges( int e1, int e2) const { int n = NumberOfVertices(); return ( CGAL_NTS abs(e2-e1) == 1 || CGAL_NTS abs(e2-e1) == n-1 ); } CGAL_END_NAMESPACE #endif // CGAL_SIMPLICITY_TEST_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2.h0000644000175000017500000000452011344301500026504 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_POINT_2_H #define CGAL_POINT_2_H #include CGAL_BEGIN_NAMESPACE template class Point_2 : public R_::Kernel_base::Point_2 { typedef typename R_::RT RT; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Kernel_base::Point_2 RPoint_2; public: typedef R_ R; Point_2() {} Point_2(const Origin& o) : RPoint_2(o) {} #if 1 // still needed by Min_ellipse_2... Point_2(const RPoint_2& p) : RPoint_2(p) {} #endif Point_2(const RT& x, const RT& y) : RPoint_2(x, y) {} Point_2(const RT& hx, const RT& hy, const RT& hw) : RPoint_2(hx, hy, hw) {} }; #if 0 //ndef CGAL_NO_OSTREAM_INSERT_POINT_2 template < class R > std::ostream& operator<<(std::ostream& os, const Point_2& p) { typedef typename R::Kernel_base::Point_2 RPoint_2; return os << static_cast(p); } #endif // CGAL_NO_OSTREAM_INSERT_POINT_2 #if 0 //ndef CGAL_NO_ISTREAM_EXTRACT_POINT_2 template < class R > std::istream& operator>>(std::istream& is, Point_2& p) { typedef typename R::Kernel_base::Point_2 RPoint_2; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_POINT_2 CGAL_END_NAMESPACE #endif // CGAL_POINT_2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_halfedge_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_halfedge_ba0000644000175000017500000003375511344301500031167 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_halfedge_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_HALFEDGE_BASE_H #define CGAL_HALFEDGEDS_HALFEDGE_BASE_H 1 #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE template < class Refs, class TP, class TV, class TF> struct HalfedgeDS_halfedge_base_base { // Base_base will be used to access set_opposite(), which is // made private in the normal halfedge bases. Since halfedges // come always in pairs, managed by the HDS, the set_opposite() // member function is protected from the user. typedef Refs HalfedgeDS; typedef HalfedgeDS_halfedge_base_base Base_base; typedef TP Supports_halfedge_prev; typedef TV Supports_halfedge_vertex; typedef TF Supports_halfedge_face; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Face Face; private: Halfedge_handle opp; Halfedge_handle nxt; public: Halfedge_handle opposite() { return opp;} Halfedge_const_handle opposite() const { return opp;} void set_opposite( Halfedge_handle h) { opp = h;} Halfedge_handle next() { return nxt;} Halfedge_const_handle next() const { return nxt;} void set_next( Halfedge_handle h) { nxt = h;} bool is_border() const { return false;} // is always false as long as faces are not supported. }; template < class Refs, class TP = Tag_true, class TV = Tag_true, class TF = Tag_true> class HalfedgeDS_halfedge_base; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_false, // prev Tag_false, // vertex Tag_false> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_false, Tag_false, Tag_false> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_true, // prev Tag_false, // vertex Tag_false> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_true, Tag_false, Tag_false> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Halfedge_handle prv; public: // the previous halfedge along the face. Halfedge_handle prev() { return prv; } Halfedge_const_handle prev() const { return prv; } void set_prev( Halfedge_handle h) { prv = h; } }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_false, // prev Tag_true, // vertex Tag_false> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_false, Tag_true, Tag_false> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Vertex_handle v; public: // the incident vertex. Vertex_handle vertex() { return v; } Vertex_const_handle vertex() const { return v; } void set_vertex( Vertex_handle w) { v = w; } }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_false, // prev Tag_false, // vertex Tag_true> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_false, Tag_false, Tag_true> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Face_handle f; public: // Explicit initialization of f to denote border halfedges // is needed if Face_handle is a C style pointer. HalfedgeDS_halfedge_base() : f( Face_handle()) {} // the face to the left. Face_handle face() { return f; } Face_const_handle face() const { return f; } void set_face( Face_handle g) { f = g; } bool is_border() const { return f == Face_handle();} // is true if `h' is a border halfedge. }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_true, // prev Tag_true, // vertex Tag_false> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_true, Tag_true, Tag_false> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Halfedge_handle prv; Vertex_handle v; public: // the previous halfedge along the face. Halfedge_handle prev() { return prv; } Halfedge_const_handle prev() const { return prv; } void set_prev( Halfedge_handle h) { prv = h; } // the incident vertex. Vertex_handle vertex() { return v; } Vertex_const_handle vertex() const { return v; } void set_vertex( Vertex_handle w) { v = w; } }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_true, // prev Tag_false, // vertex Tag_true> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_true, Tag_false, Tag_true> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Halfedge_handle prv; Face_handle f; public: // Explicit initialization of f to denote border halfedges // is needed if Face_handle is a C style pointer. HalfedgeDS_halfedge_base() : f( Face_handle()) {} // the previous halfedge along the face. Halfedge_handle prev() { return prv; } Halfedge_const_handle prev() const { return prv; } void set_prev( Halfedge_handle h) { prv = h; } // the face to the left. Face_handle face() { return f; } Face_const_handle face() const { return f; } void set_face( Face_handle g) { f = g; } bool is_border() const { return f == Face_handle();} // is true if `h' is a border halfedge. }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_false, // prev Tag_true, // vertex Tag_true> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_false, Tag_true, Tag_true> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Vertex_handle v; Face_handle f; public: // Explicit initialization of f to denote border halfedges // is needed if Face_handle is a C style pointer. HalfedgeDS_halfedge_base() : f( Face_handle()) {} // the incident vertex. Vertex_handle vertex() { return v; } Vertex_const_handle vertex() const { return v; } void set_vertex( Vertex_handle w) { v = w; } // the face to the left. Face_handle face() { return f; } Face_const_handle face() const { return f; } void set_face( Face_handle g) { f = g; } bool is_border() const { return f == Face_handle();} // is true if `h' is a border halfedge. }; template < class Refs > class HalfedgeDS_halfedge_base< Refs, Tag_true, // prev Tag_true, // vertex Tag_true> // face : public HalfedgeDS_halfedge_base_base< Refs, Tag_true, Tag_true, Tag_true> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef HalfedgeDS_halfedge_base Base; typedef HalfedgeDS_halfedge_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} Halfedge_handle prv; Vertex_handle v; Face_handle f; public: // Explicit initialization of f to denote border halfedges // is needed if Face_handle is a C style pointer. HalfedgeDS_halfedge_base() : f( Face_handle()) {} // the previous halfedge along the face. Halfedge_handle prev() { return prv; } Halfedge_const_handle prev() const { return prv; } void set_prev( Halfedge_handle h) { prv = h; } // the incident vertex. Vertex_handle vertex() { return v; } Vertex_const_handle vertex() const { return v; } void set_vertex( Vertex_handle w) { v = w; } // the face to the left. Face_handle face() { return f; } Face_const_handle face() const { return f; } void set_face( Face_handle g) { f = g; } bool is_border() const { return f == Face_handle();} // is true if `h' is a border halfedge. }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_HALFEDGE_BASE_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/basic_classes.h0000644000175000017500000000256211344301500027774 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/basic_classes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_BASIC_CLASSES_H #define CGAL_BASIC_CLASSES_H #include #include #include #include #include #endif // CGAL_BASIC_CLASSES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_decorator.h0000644000175000017500000011552111344301500031166 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_DECORATOR_H #define CGAL_HALFEDGEDS_DECORATOR_H 1 #ifndef CGAL_HALFEDGEDS_ITEMS_DECORATOR_H #include #endif #ifndef CGAL_HALFEDGEDS_CONST_DECORATOR_H #include #endif #ifndef CGAL_PROTECT_VECTOR #include #define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_IO_VERBOSE_OSTREAM_H #include #endif // CGAL_IO_VERBOSE_OSTREAM_H CGAL_BEGIN_NAMESPACE template < class p_HDS > class HalfedgeDS_decorator : public HalfedgeDS_items_decorator { // TYPES (inherited from Items_decorator, but have to be repeated) // --------------------------------------------------------------- public: typedef p_HDS HDS; typedef p_HDS HalfedgeDS; typedef typename HDS::Traits Traits; typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Face_iterator Face_iterator; typedef typename HDS::Face_const_iterator Face_const_iterator; typedef typename HDS::size_type size_type; typedef typename HDS::difference_type difference_type; typedef typename HDS::iterator_category iterator_category; // The following types are equal to either `Tag_true' or `Tag_false', // dependent whether the named feature is supported or not. typedef typename HDS::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename HDS::Supports_halfedge_prev Supports_halfedge_prev; typedef typename HDS::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename HDS::Supports_halfedge_face Supports_halfedge_face; typedef typename HDS::Supports_face_halfedge Supports_face_halfedge; typedef typename HDS::Supports_removal Supports_removal; protected: typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Halfedge::Base_base HBase_base; typedef typename Face::Base FBase; // PRIVATE MEMBER VARIABLES // ---------------------------------- private: p_HDS* hds; // CREATION // ---------------------------------- public: // No default constructor, keeps always a reference to a HDS! HalfedgeDS_decorator( p_HDS& h) : hds(&h) {} // keeps internally a reference to `hds'. // Creation of New Elements // ---------------------------------- Vertex_handle vertices_push_back( const Vertex& v) { // appends a copy of v to `hds' if vertices are supported. Returns // handle of the new vertex, or `Vertex_handle()' otherwise. return vertices_push_back( v, Supports_halfedge_vertex()); } Face_handle faces_push_back( const Face& f) { // appends a copy of f to `hds' if faces are supported. Returns // handle of the new face, or `Face_handle()' otherwise. return faces_push_back( f, Supports_halfedge_face()); } private: Vertex_handle vertices_push_back( Vertex_const_handle v) { // appends a copy of *v to `hds' if vertices are supported. Returns // handle of the new vertex, or `Vertex_handle()' otherwise. return vertices_push_back( v, Supports_halfedge_vertex()); } Face_handle faces_push_back( Face_const_handle f) { // appends a copy of *f to `hds' if faces are supported. Returns // handle of the new face, or `Face_handle()' otherwise. return faces_push_back( f, Supports_halfedge_face()); } public: // Creation of New Composed Items // ---------------------------------- Halfedge_handle create_loop() { // returns handle of a halfedge from a newly created loop in `hds' // consisting of a single closed edge, one vertex and two faces // (if supported respectively). Halfedge_handle h = hds->edges_push_back( Halfedge(), Halfedge()); h->HBase::set_next( h); h->opposite()->HBase::set_next( h->opposite()); set_prev( h, h); set_prev( h->opposite(), h->opposite()); set_vertex( h, vertices_push_back( Vertex())); set_vertex( h->opposite(), get_vertex(h)); set_face( h, faces_push_back( Face())); set_face( h->opposite(), faces_push_back( Face())); set_face_halfedge( h); set_face_halfedge( h->opposite()); set_vertex_halfedge( h); return h; } Halfedge_handle create_segment() { // returns a halfedge from a newly created segment in `hds' // consisting of a single open edge, two vertices and one face (if // supported respectively). Halfedge_handle h = hds->edges_push_back( Halfedge(), Halfedge()); h->HBase::set_next( h->opposite()); h->opposite()->HBase::set_next( h); set_prev( h, h->opposite()); set_prev( h->opposite(), h); set_vertex( h, vertices_push_back( Vertex())); set_vertex( h->opposite(), vertices_push_back( Vertex())); set_face( h, faces_push_back( Face())); set_face( h->opposite(), get_face(h)); set_face_halfedge( h); set_vertex_halfedge( h); set_vertex_halfedge( h->opposite()); return h; } // Removal of Elements // ---------------------------------- void vertices_pop_front() { // removes the first vertex if vertices are supported. // Precondition: `Supports_removal' == `Tag_true'. vertices_pop_front( Supports_halfedge_vertex()); } void vertices_pop_back() { // removes the last vertex if vertices are supported. vertices_pop_back( Supports_halfedge_vertex()); } void vertices_erase( Vertex_handle v) { // removes the vertex v if vertices are supported. Precondition: // `Supports_removal' == `Tag_true'. vertices_erase( v, Supports_halfedge_vertex()); } void vertices_erase( Vertex_handle first, Vertex_handle last) { // removes the range of vertices `[first,last)' if vertices // are supported. Precondition: `Supports_removal' == // `Tag_true'. vertices_erase( first, last, Supports_halfedge_vertex()); } void faces_pop_front() { // removes the first face if faces are supported. Precondition: // `Supports_removal' == `Tag_true'. faces_pop_front( Supports_halfedge_face()); } void faces_pop_back() { // removes the last face if faces are supported. faces_pop_back( Supports_halfedge_face()); } void faces_erase( Face_handle f) { // removes the face f if faces are supported. Precondition: // `Supports_removal' == `Tag_true'. faces_erase( f, Supports_halfedge_face()); } void faces_erase( Face_handle first, Face_handle last) { // removes the range of faces `[first,last)' if faces // are supported. Precondition: `Supports_removal' == // `Tag_true'. faces_erase( first, last, Supports_halfedge_face()); } // Modifying Functions (Euler Operators) // ------------------------------------- // The following Euler operations modify consistently the combinatorial // structure of the halfedge data structure. The geometry remains // unchanged. Note that well known graph operations are also captured with // these Euler operators, for example an edge contraction is equal to a // `join_vertex()' operation, or an edge removal to `join_face()'. // // Given a halfedge data structure `hds' and a halfedge handle h four // special applications of the Euler operators are worth mentioning: // `split_vertex(h,h)' results in an antenna emanating from the tip of `h'; // `split_vertex(h,h->next()->opposite())' results in an edge split of // the halfedge `h->next' with a new vertex in-between; `split_face(h,h)' // results in a loop directly following `h'; and `split_face(h,h->next())' // results in a bridge parallel to the halfedge `h->next' with a new face // in-between. Halfedge_handle split_face( Halfedge_handle h, Halfedge_handle g) { // splits the face incident to `h' and `g' into two faces with a // new diagonal between the two vertices denoted by `h' and `g' // respectively. The second (new) face obtained from `hds' is a // copy of the first face. The new diagonal is returned. The time // is proportional to the distance from `h' to `g' around the // face. Halfedge_handle hnew = hds->edges_push_back( Halfedge(), Halfedge()); Face_handle fnew = faces_push_back( get_face(h)); insert_tip( hnew, g); insert_tip( hnew->opposite(), h); set_face( hnew, get_face(h)); set_face_in_face_loop( hnew->opposite(), fnew); set_face_halfedge( hnew); set_face_halfedge( hnew->opposite()); return hnew; } Halfedge_handle join_face( Halfedge_handle h) { // joins the two faces incident to h. The face incident to // `h->opposite()' gets removed from `hds'. Both faces might be // holes. Returns the predecessor of h around the face. The // invariant `join_face( split_face( h, g))' returns h and keeps // the data structure unchanged. The time is proportional to the // size of the face removed and the time to compute `h->prev()'. // Precondition: `Supports_removal' == `Tag_true'. Assert_compile_time_tag( Tag_true(), Supports_removal()); Halfedge_handle hprev = find_prev( h); Halfedge_handle gprev = find_prev( h->opposite()); remove_tip( hprev); remove_tip( gprev); hds->edges_erase( h); if ( get_face( gprev) != Face_handle()) faces_erase( get_face( gprev)); h = hprev; // 'half' of the halfedges have their correct faces. // Here we do the remaining halfedges. CGAL_assertion_code( std::size_t termination_count = 0;) while ( h != gprev) { CGAL_assertion( ++termination_count != 0); h = h->next(); set_face( h, get_face( hprev)); } if ( get_face( hprev) != Face_handle()) set_face_halfedge( hprev); set_vertex_halfedge( hprev); set_vertex_halfedge( gprev); return hprev; } Halfedge_handle split_vertex( Halfedge_handle h, Halfedge_handle g) { // splits the vertex incident to `h' and `g' into two vertices and // connects them with a new edge. The second (new) vertex obtained // from `hds' is a copy of the first vertex. The new edge is // returned. The time is proportional to the distance from `h' to // `g' around the vertex. Halfedge_handle hnew = hds->edges_push_back( Halfedge(), Halfedge()); Vertex_handle vnew = vertices_push_back( get_vertex(h)); insert_halfedge( hnew, g); insert_halfedge( hnew->opposite(), h); set_vertex( hnew, get_vertex(h)); set_vertex_in_vertex_loop( hnew->opposite(), vnew); set_vertex_halfedge( hnew); set_vertex_halfedge( hnew->opposite()); return hnew; } Halfedge_handle join_vertex( Halfedge_handle h) { // joins the two vertices incident to h. The vertex denoted by // `h->opposite()' gets removed by `hds'. Returns the predecessor // of h around the vertex. The invariant `join_vertex( // split_vertex( h, g))' returns h and keeps the polyhedron // unchanged. The time is proportional to the degree of the vertex // removed and the time to compute `h->prev()'. Precondition: // `Supports_removal' == `Tag_true'. Assert_compile_time_tag( Tag_true(), Supports_removal()); Halfedge_handle hprev = find_prev( h->opposite()); Halfedge_handle gprev = find_prev( h); remove_halfedge( hprev); remove_halfedge( gprev); hds->edges_erase( h); vertices_erase( get_vertex( gprev)); // 'half' of the halfedges have their correct vertex. // Here we do the remaining halfedges. h = hprev; CGAL_assertion_code( std::size_t termination_count = 0;) while ( h != gprev) { CGAL_assertion( ++termination_count != 0); h = h->next()->opposite(); set_vertex( h, get_vertex( hprev)); } set_vertex_halfedge( hprev); if ( ! hprev->is_border()) set_face_halfedge( hprev); if ( ! gprev->is_border()) set_face_halfedge( gprev); return hprev; } Halfedge_handle create_center_vertex( Halfedge_handle h) { Halfedge_handle hnew = hds->edges_push_back( Halfedge(), Halfedge()); Vertex_handle vnew = vertices_push_back( get_vertex( h)); close_tip( hnew, vnew); insert_tip( hnew->opposite(), h); set_face( hnew, get_face( h)); set_face_halfedge( h); Halfedge_handle g = hnew->opposite()->next(); while ( g->next() != hnew) { Halfedge_handle gnew = hds->edges_push_back( Halfedge(), Halfedge()); insert_tip( gnew, hnew); insert_tip( gnew->opposite(), g); Face_handle fnew = faces_push_back( get_face(hnew)); set_face( g, fnew); set_face( gnew, fnew); set_face( gnew->next(), fnew); set_face_halfedge( g); g = gnew->opposite()->next(); } set_face( hnew->next(), get_face( hnew)); set_vertex_halfedge( hnew); return hnew; } Halfedge_handle erase_center_vertex( Halfedge_handle h) { // h points to the vertex that gets removed Halfedge_handle g = h->next()->opposite(); Halfedge_handle hret = find_prev( h); while ( g != h) { Halfedge_handle gprev = find_prev( g); set_vertex_halfedge( gprev); remove_tip( gprev); if ( get_face( g) != Face_handle()) faces_erase( get_face( g)); Halfedge_handle gnext = g->next()->opposite(); hds->edges_erase( g); g = gnext; } set_vertex_halfedge( hret); remove_tip( hret); vertices_erase( get_vertex( h)); hds->edges_erase( h); set_face_in_face_loop( hret, get_face( hret)); set_face_halfedge(hret); return hret; } Halfedge_handle split_loop( Halfedge_handle h, Halfedge_handle i, Halfedge_handle j) { // cuts the halfedge data structure into two parts along the cycle // (h,i,j). Three new vertices (one copy for each vertex in the // cycle) and three new halfedges (one copy for each halfedge in // the cycle), and two new triangles are created. h,i,j will be // incident to the first new triangle. The return value will be // the halfedge incident to the second new triangle which is the // copy of `h-opposite()'. Precondition: h,i,j denote distinct, // consecutive vertices of the halfedge data structure and form a // cycle: i.e. `h->vertex() == i->opposite()->vertex()', ..., // `j->vertex() == h->opposite()->vertex()'. CGAL_precondition( h != i); CGAL_precondition( h != j); CGAL_precondition( i != j); CGAL_precondition( get_vertex(h) == get_vertex(i->opposite())); CGAL_precondition( get_vertex(i) == get_vertex(j->opposite())); CGAL_precondition( get_vertex(j) == get_vertex(h->opposite())); // Create a copy of the triangle. Halfedge_handle hnew = hds->edges_push_back( *h); Halfedge_handle inew = hds->edges_push_back( *i); Halfedge_handle jnew = hds->edges_push_back( *j); close_tip( hnew, vertices_push_back( get_vertex( h))); close_tip( inew, vertices_push_back( get_vertex( i))); close_tip( jnew, vertices_push_back( get_vertex( j))); insert_tip( inew->opposite(), hnew); insert_tip( jnew->opposite(), inew); insert_tip( hnew->opposite(), jnew); // Make the new incidences with the old stucture. CGAL_assertion_code( std::size_t termination_count = 0;) if ( h->next() != i) { Halfedge_handle g = h->next(); h->HBase::set_next( i); set_prev( i, h); hnew->HBase::set_next( g); set_prev( g, hnew); g = g->opposite(); while ( g->next() != i) { CGAL_assertion( ++termination_count != 0); set_vertex( g, get_vertex( hnew)); g = g->next()->opposite(); } set_vertex( g, get_vertex( hnew)); g->HBase::set_next( inew); set_prev( inew, g); } if ( i->next() != j) { Halfedge_handle g = i->next(); i->HBase::set_next( j); set_prev( j, i); inew->HBase::set_next( g); set_prev( g, inew); g = g->opposite(); while ( g->next() != j) { CGAL_assertion( ++termination_count != 0); set_vertex( g, get_vertex( inew)); g = g->next()->opposite(); } set_vertex( g, get_vertex( inew)); g->HBase::set_next( jnew); set_prev( jnew, g); } if ( j->next() != h) { Halfedge_handle g = j->next(); j->HBase::set_next( h); set_prev( h, j); jnew->HBase::set_next( g); set_prev( g, jnew); g = g->opposite(); while ( g->next() != h) { CGAL_assertion( ++termination_count != 0); set_vertex( g, get_vertex( jnew)); g = g->next()->opposite(); } set_vertex( g, get_vertex( jnew)); g->HBase::set_next( hnew); set_prev( hnew, g); } // Fill the holes with two new faces. Face_handle f = faces_push_back( Face()); set_face( h, f); set_face( i, f); set_face( j, f); set_face_halfedge( h); f = faces_push_back( Face()); set_face( hnew->opposite(), f); set_face( inew->opposite(), f); set_face( jnew->opposite(), f); set_face_halfedge( hnew->opposite()); // Take care of maybe changed halfedge pointers. set_face_halfedge( hnew); set_face_halfedge( inew); set_face_halfedge( jnew); set_vertex_halfedge( hnew); set_vertex_halfedge( inew); set_vertex_halfedge( jnew); return hnew->opposite(); } Halfedge_handle join_loop( Halfedge_handle h, Halfedge_handle g) { // glues the boundary of the two faces denoted by h and g together // and returns h. Both faces and the vertices along the face // denoted by g gets removed. Both faces may be holes. The // invariant `join_loop( h, split_loop( h, i, j))' returns h and // keeps the data structure unchanged. Precondition: // `Supports_removal' == `Tag_true'. The faces denoted by h // and g are different and have equal degree (i.e. number of // edges). Assert_compile_time_tag( Tag_true(), Supports_removal()); CGAL_precondition( get_face(h) == Face_handle() || get_face(h) != get_face(g)); if ( get_face( h) != Face_handle()) faces_erase( get_face(h)); if ( get_face( g) != Face_handle()) faces_erase( get_face(g)); Halfedge_handle hi = h; Halfedge_handle gi = g; CGAL_assertion_code( std::size_t termination_count = 0;) do { CGAL_assertion( ++termination_count != 0); Halfedge_handle hii = hi; Halfedge_handle gii = gi; hi = hi->next(); // gi = find_prev(gi); // Replaced by search around vertex. set_face( hii, get_face( gii->opposite())); set_face_halfedge( hii); vertices_erase( get_vertex( gii->opposite())); if ( gii->opposite()->next()->opposite()->next() == gii) { gi = gii->opposite()->next()->opposite(); } else { hii->HBase::set_next( gii->opposite()->next()); set_prev( hii->next(), hii); gii = gii->opposite()->next()->opposite(); set_vertex( gii, get_vertex(hii)); while ( gii->next()->opposite()->next() != gi) { CGAL_assertion( ++termination_count != 0); gii = gii->next()->opposite(); set_vertex( gii, get_vertex(hii)); } gi = gii->next()->opposite(); gii->HBase::set_next( hi); set_prev( gii->next(), gii); } } while ( hi != h); CGAL_assertion( gi == g); do { Halfedge_handle gii = gi; gi = gi->next(); hds->edges_erase( gii); } while ( gi != g); return h; } protected: // supports face or not. void make_hole( Halfedge_handle, Tag_false) {} void fill_hole( Halfedge_handle, Tag_false) {} void fill_hole( Halfedge_handle, const Face&, Tag_false) {} void make_hole( Halfedge_handle h, Tag_true) { Assert_compile_time_tag( Tag_true(), Supports_removal()); CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( ! h->is_border()); hds->faces_erase( h->face()); set_face_in_face_loop( h, Face_handle()); } void fill_hole( Halfedge_handle h, Tag_true) { CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( h->is_border()); Face_handle f = faces_push_back( Face()); set_face_in_face_loop( h, f); set_face_halfedge( h); } void fill_hole( Halfedge_handle h, const Face& f, Tag_true) { CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( h->is_border()); Face_handle fh = faces_push_back( f); set_face_in_face_loop( h, fh); set_face_halfedge( h); } public: Halfedge_handle make_hole( Halfedge_handle h) { // removes the face incident to `h' from `hds' and creates a hole. // Precondition: `h != Halfedge_handle()' and `!(h->is_border())'. // If faces are supported, `Supports_removal' == `Tag_true'. make_hole( h, Supports_halfedge_face()); return h; } Halfedge_handle fill_hole( Halfedge_handle h) { // fills the hole incident to `h' with a new face from `hds'. // Precondition: `h != Halfedge_handle()' and `h->is_border()'. fill_hole( h, Supports_halfedge_face()); return h; } Halfedge_handle fill_hole( Halfedge_handle h, const Face& f) { // fills the hole incident to `h' with a copy of face f. // Precondition: `h != Halfedge_handle()' and `h->is_border()'. fill_hole( h, f, Supports_halfedge_face()); return h; } Halfedge_handle add_face_to_border( Halfedge_handle h, Halfedge_handle g, const Face& f) { // extends the surface with a copy of face f into the hole // incident to h and g. It creates a new edge connecting the tip // of g with the tip of h and fills this separated part of the // hole with a copy of face f, such that the new face is incident // to g. Returns the new halfedge that is incident to the new // face. Precondition: `h != Halfedge_handle()', `g != // Halfedge_handle()', `h->is_border()', `g->is_border()' and g // can be reached along the hole starting with h. CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( g != Halfedge_handle()); CGAL_precondition( h->is_border()); CGAL_precondition( g->is_border()); Halfedge_handle hh = hds->edges_push_back( Halfedge(), Halfedge()); insert_tip( hh, h); insert_tip( hh->opposite(), g); fill_hole( g, f); return hh; } Halfedge_handle add_face_to_border( Halfedge_handle h, Halfedge_handle g) { // extends the surface with a new face from `hds' into the hole // incident to h and g. It creates a new edge connecting the tip // of g with the tip of h and fills this separated part of the // hole with a new face, such that the new face is incident to g. // Returns the new halfedge that is incident to the new face. // Precondition: `h != Halfedge_handle()', `g != Halfedge_handle( // )', `h->is_border()', `g->is_border()' and g can be reached // along the hole starting with h. return add_face_to_border( h, g, Face()); } // Erasing // ---------------------------------- protected: // supports face or not. void erase_face( Halfedge_handle, Tag_false) {} void erase_face( Halfedge_handle h, Tag_true) { Assert_compile_time_tag( Tag_true(), Supports_removal()); CGAL_precondition( h != Halfedge_handle()); CGAL_precondition( ! h->is_border()); hds->faces_erase( h->face()); CGAL_assertion_code( std::size_t termination_count = 0;) Halfedge_handle end = h; do { CGAL_assertion( ++termination_count != 0); set_face( h, Face_handle()); Halfedge_handle g = h->next(); bool h_tag = h->opposite()->is_border(); bool g_tag = g->opposite()->is_border(); if ( h_tag && g_tag && g->opposite()->next() == h->opposite()){ vertices_erase( get_vertex(h)); if ( h != end) hds->edges_erase( h); } else { if ( g_tag) { set_vertex_halfedge(g->opposite()->next()->opposite()); remove_tip(h); } if ( h_tag) { set_vertex_halfedge(h->next()->opposite()); remove_tip( find_prev_around_vertex( h->opposite())); if ( h != end) hds->edges_erase(h); } } h = g; } while ( h != end); if ( h->opposite()->is_border()) hds->edges_erase( h); } public: void erase_face( Halfedge_handle h) { // removes the face incident to `h' from `hds' and changes all // halfedges incident to the face into border edges or removes // them from the halfedge data structure if they were already // border edges. See `make_hole(h)' for a more specialized // variant. Precondition: `h != Halfedge_handle()'. If faces are // supported, `Supports_removal' == `Tag_true'. erase_face( h, Supports_halfedge_face()); } protected: // Supports_halfedge_vertices void erase_connected_component_vertex( Halfedge_handle ,Tag_false){} void erase_connected_component_vertex( Halfedge_handle h, Tag_true) { // Erases the the vertex incident to h and sets all references // from halfedges around this vertex to Halfedge_handle(), // if the incident vertex handle is not already equal to // Halfedge_handle(). It is used to erase vertices as soon // as an vertex is encountered in the graph traversal. At this // point of the graph traversal the halfedge cycle around the // vertex is still closed. Lateron it will be broken. if ( h->vertex() != Vertex_handle()) { hds->vertices_erase( h->vertex()); set_vertex_in_vertex_loop( h, Vertex_handle()); } } void erase_connected_component_vertex( Halfedge_handle h) { erase_connected_component_vertex( h, Supports_halfedge_vertex()); } void erase_connected_component_face_cycle( Halfedge_handle h, std::vector& stack) { // Delete incident face and set all incidences to Face_handle(). if ( get_face(h) != Face_handle()) { faces_erase( get_face(h)); set_face_in_face_loop( h, Face_handle()); } // Cycle around face, delete incident vertices, push new // edges on the stack and mark edges as visited. erase_connected_component_vertex( h); Halfedge_handle g = h->next(); h->HBase::set_next( Halfedge_handle()); while (g != h) { erase_connected_component_vertex( g); if ( g->opposite()->next() != Halfedge_handle()) stack.push_back( g->opposite()); Halfedge_handle gg = g->next(); g->HBase::set_next( Halfedge_handle()); g = gg; } } public: void erase_connected_component( Halfedge_handle h) { // removes the vertices, halfedges, and facets that belong to the // connected component of h. Precondition: `Supports_removal' // == `Tag_true'. For all halfedges g in the connected // component `g.next() != Halfedge_handle()'. Assert_compile_time_tag( Tag_true(), Supports_removal()); typedef std::vector HVector; HVector stack; // Algorithm: The next() pointer is used as visited tag // for a graph search. If the next pointer of an halfedge // or its opposite halfedge is set to Halfedge_handle(), // this edge has already been visited and must not be put // on the stack again. // Initializing: Cycle through the face-cycle of h and put // all opposite halfedges on the stack. Put h->opposite() // on the stack. Note that even if the face cycle of h looks // ugly ( e.g. h->opposite() is also in the cycle), neither // h nor h->opposite() will be put on the stack. If // h->opposite() is in the cycle, when h will be popped from // the stack it will be immediately deleted. // Loop invariant: For each edge h on the stack h->opposite()-> // next() == Halfedge_handle(). // Looping: For each edge h on the stack, if h->next() is // not already equal to Halfedge_handle(), cycle through // the face-cycle of h and put all opposite halfedges on // the stack. Delete h. // Where: Cycle through a face means: If h->face() != // Halfedge_handle() delete h->face() and set all face // handles to Halfedge_handle(). Loop through the // halfedges g around the face, call // erase_connected_component_vertex for each g, push // g->opposite() on the stack if g->opposite()->next() // is not already Halfedge_handle(). This implies that // h->opposite() is not put on the stack again. erase_connected_component_face_cycle( h, stack); stack.push_back( h->opposite()); while ( ! stack.empty()) { h = stack.back(); stack.pop_back(); CGAL_assertion( h->opposite()->next() == Halfedge_handle()); if ( h->next() != Halfedge_handle()) erase_connected_component_face_cycle( h, stack); hds->edges_erase( h); } } // Implementing These Functions. // ==================================================== // Creation of New Elements // ---------------------------------- private: Vertex_handle vertices_push_back( const Vertex& , Tag_false) { return Vertex_handle(); } Vertex_handle vertices_push_back( const Vertex& v, Tag_true) { return hds->vertices_push_back(v); } Vertex_handle vertices_push_back( Vertex_const_handle , Tag_false) { return Vertex_handle(); } Vertex_handle vertices_push_back( Vertex_const_handle v, Tag_true) { return hds->vertices_push_back(*v); } Face_handle faces_push_back( const Face& , Tag_false) { return Face_handle(); } Face_handle faces_push_back( const Face& f, Tag_true) { return hds->faces_push_back(f); } Face_handle faces_push_back( Face_const_handle , Tag_false) { return Face_handle(); } Face_handle faces_push_back( Face_const_handle f, Tag_true) { return hds->faces_push_back(*f); } // Removal of Elements // ---------------------------------- void vertices_erase( Vertex_handle , Tag_false) {} void vertices_erase( Vertex_handle v, Tag_true) { hds->vertices_erase( v); } void vertices_pop_front( Tag_false) {} void vertices_pop_front( Tag_true) { hds->vertices_pop_front(); } void vertices_pop_back( Tag_false) {} void vertices_pop_back( Tag_true) { hds->vertices_pop_back(); } void faces_erase( Face_handle , Tag_false) {} void faces_erase( Face_handle f, Tag_true) { hds->faces_erase( f); } void faces_pop_front( Tag_false) {} void faces_pop_front( Tag_true) { hds->faces_pop_front(); } void faces_pop_back( Tag_false) {} void faces_pop_back( Tag_true) { hds->faces_pop_back(); } // Others // ---------------------------------- public: bool normalized_border_is_valid( bool verb = false) const { // returns `true' if the border halfedges are in normalized // representation, which is when enumerating all halfedges with // the halfedge iterator the following holds: The non-border edges // precede the border edges. For border edges, the second halfedge // is a border halfedge. (The first halfedge may or may not be a // border halfedge.) The halfedge iterator `border_halfedges_begin // ()' denotes the first border edge. If `verbose' is `true', // statistics are written to `cerr'. HalfedgeDS_const_decorator decorator(*hds); return decorator.normalized_border_is_valid( verb); } bool is_valid( bool verb = false, int level = 0) const { // returns `true' if the halfedge data structure `hds' is valid // with respect to the `level' value as defined in the reference // manual. If `verbose' is `true', statistics are written to // `cerr'. HalfedgeDS_const_decorator decorator(*hds); return decorator.is_valid( verb, level); } void reorient_face( Halfedge_handle first); // Supports: halfedge pointer in faces. void inside_out( Tag_false); void inside_out( Tag_true); void inside_out() { inside_out( Supports_face_halfedge()); } }; template < class p_HDS > CGAL_MEDIUM_INLINE void HalfedgeDS_decorator:: reorient_face( Halfedge_handle first) { if ( first == Halfedge_handle()) return; Halfedge_handle last = first; Halfedge_handle prev = first; Halfedge_handle start = first; first = first->next(); Vertex_handle new_v = get_vertex( start); while (first != last) { Vertex_handle tmp_v = get_vertex( first); set_vertex( first, new_v); set_vertex_halfedge( first); new_v = tmp_v; Halfedge_handle next = first->next(); first->HBase::set_next( prev); set_prev( first, next); prev = first; first = next; } set_vertex( start, new_v); set_vertex_halfedge( start); Halfedge_handle next = start->next(); start->HBase::set_next( prev); set_prev( start, next); } template < class p_HDS > void // Supports: halfedge pointer in faces. HalfedgeDS_decorator:: inside_out( Tag_false) { Halfedge_iterator begin = hds->halfedges_begin(); Halfedge_iterator end = hds->halfedges_end(); for( ; begin != end; ++begin) { // Define the halfedge with the `smallest' pointer // value as the one that is used to reorient the face. Halfedge_handle h = begin; bool is_min = true; Halfedge_handle c = h; Halfedge_handle d = c; do { CGAL_assertion( c != Halfedge_handle()); if ( &*h > &*c) is_min = false; c = c->next(); } while ( c != d && is_min); if ( is_min) reorient_face( h); } } template < class p_HDS > void // Supports: halfedge pointer in faces. HalfedgeDS_decorator:: inside_out( Tag_true) { Face_iterator begin = hds->faces_begin(); Face_iterator end = hds->faces_end(); for( ; begin != end; ++begin) reorient_face( begin->halfedge()); // Note: A border edge is now parallel to its opposite edge. // We scan all border edges for this property. If it holds, we // reorient the associated hole and search again until no border // edge with that property exists any longer. Then, all holes are // reoriented. Halfedge_iterator first = hds->halfedges_begin(); Halfedge_iterator last = hds->halfedges_end(); for( ; first != last; ++first) { if ( first->is_border() && first->vertex() == first->opposite()->vertex()) reorient_face( first); } } CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_DECORATOR_H // // EOF // ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_0000644000175000017500000001310311344301501031135 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_2_TRIANGLE_2_DO_INTERSECT_H #define CGAL_TRIANGLE_2_TRIANGLE_2_DO_INTERSECT_H #include CGAL_BEGIN_NAMESPACE namespace CGALi { template bool intersection_test_vertex(const typename K::Point_2 * P1, const typename K::Point_2 * Q1, const typename K::Point_2 * R1, const typename K::Point_2 * P2, const typename K::Point_2 * Q2, const typename K::Point_2 * R2, const K & k ){ CGAL_kernel_precondition( k.orientation_2_object() (*P1,*Q1,*R1) == POSITIVE); CGAL_kernel_precondition( k.orientation_2_object() (*P2,*Q2,*R2) == POSITIVE); typename K::Orientation_2 orientation = k.orientation_2_object(); if (orientation(*R2,*P2,*Q1) != NEGATIVE) { if (orientation(*R2,*Q2,*Q1) != POSITIVE) { if (orientation(*P1,*P2,*Q1) == POSITIVE) return orientation(*P1,*Q2,*Q1) != POSITIVE; return orientation(*P1,*P2,*R1) != NEGATIVE && orientation(*Q1,*R1,*P2) != NEGATIVE ; } return orientation(*P1,*Q2,*Q1) != POSITIVE && orientation(*R2,*Q2,*R1) != POSITIVE && orientation(*Q1,*R1,*Q2) != NEGATIVE ; } if (orientation(*R2,*P2,*R1) != NEGATIVE) { if (orientation(*Q1,*R1,*R2) != NEGATIVE) return orientation(*P1,*P2,*R1) != NEGATIVE; return orientation(*Q1,*R1,*Q2) != NEGATIVE && orientation(*R2,*R1,*Q2) != NEGATIVE; } return false; } template bool intersection_test_edge(const typename K::Point_2 * P1, const typename K::Point_2 * Q1, const typename K::Point_2 * R1, const typename K::Point_2 * P2, const typename K::Point_2 * Q2, const typename K::Point_2 * R2, const K & k ){ CGAL_kernel_precondition( k.orientation_2_object() (*P1,*Q1,*R1) == POSITIVE); CGAL_kernel_precondition( k.orientation_2_object() (*P2,*Q2,*R2) == POSITIVE); typename K::Orientation_2 orientation = k.orientation_2_object(); if (orientation(*R2,*P2,*Q1) != NEGATIVE) { if (orientation(*P1,*P2,*Q1) != NEGATIVE) return orientation(*P1,*Q1,*R2) != NEGATIVE; return orientation(*Q1,*R1,*P2) != NEGATIVE && orientation(*R1,*P1,*P2) != NEGATIVE; } if (orientation(*R2,*P2,*R1) != NEGATIVE) return orientation(*P1,*P2,*R1) != NEGATIVE && ( orientation(*P1,*R1,*R2) != NEGATIVE || orientation(*Q1,*R1,*R2) != NEGATIVE ) ; return false; } template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_2 &t1, const typename CGAL_WRAP(K)::Triangle_2 &t2, const K & k ){ CGAL_kernel_precondition( ! k.is_degenerate_2_object() (t1) ); CGAL_kernel_precondition( ! k.is_degenerate_2_object() (t2) ); typename K::Construct_vertex_2 vertex_on = k.construct_vertex_2_object(); typename K::Orientation_2 orientation = k.orientation_2_object(); typedef typename K::Point_2 Point_2; const Point_2 & P1 = vertex_on(t1,0); const Point_2 & Q1 = vertex_on(t1,1); const Point_2 & R1 = vertex_on(t1,2); const Point_2 & P2 = vertex_on(t2,0); const Point_2 & Q2 = vertex_on(t2,1); const Point_2 & R2 = vertex_on(t2,2); const Point_2 * p1 = &P1; const Point_2 * q1 = &Q1; const Point_2 * r1 = &R1; const Point_2 * p2 = &P2; const Point_2 * q2 = &Q2; const Point_2 * r2 = &R2; if ( orientation(P1,Q1,R1) != POSITIVE ) { q1 = &R1;; r1 = &Q1; } if ( orientation(P2,Q2,R2) != POSITIVE ) { q2 = &R2; r2 = &Q2; } if ( orientation(*p2,*q2,*p1) != NEGATIVE ) { if ( orientation(*q2,*r2,*p1) != NEGATIVE ) { if ( orientation(*r2,*p2,*p1) != NEGATIVE ) return true; return CGALi::intersection_test_edge(p1,q1,r1,p2,q2,r2,k); } if ( orientation(*r2,*p2,*p1) != NEGATIVE ) return CGALi::intersection_test_edge(p1,q1,r1,r2,p2,q2,k); return CGALi::intersection_test_vertex(p1,q1,r1,p2,q2,r2,k); } if ( orientation(*q2,*r2,*p1) != NEGATIVE ) { if ( orientation(*r2,*p2,*p1) != NEGATIVE ) return CGALi::intersection_test_edge(p1,q1,r1,q2,r2,p2,k); return CGALi::intersection_test_vertex(p1,q1,r1,q2,r2,p2,k); } return CGALi::intersection_test_vertex(p1,q1,r1,r2,p2,q2,k); } } // namespace CGALi template inline bool do_intersect(const Triangle_2 &t1, const Triangle_2 &t2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(t1,t2); } CGAL_END_NAMESPACE #endif //CGAL_TRIANGLE_2_TRIANGLE_2_DO_INTERSECT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_3.h0000644000175000017500000000524411344301500026307 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_LINE_3_H #define CGAL_LINE_3_H CGAL_BEGIN_NAMESPACE template class Line_3 : public R_::Kernel_base::Line_3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Kernel_base::Line_3 RLine_3; public: typedef R_ R; Line_3() {} Line_3(const Point_3 & p, const Point_3 & q) : RLine_3(p,q) {} // conversion impl -> interface class Line_3(const RLine_3& l) : RLine_3(l) {} Line_3(const Segment_3 & s) : RLine_3( s ) {} Line_3(const Ray_3 & r) : RLine_3( r ) {} Line_3(const Point_3 & p, const Direction_3 & d) : RLine_3( p, d ) {} Line_3(const Point_3 & p, const Vector_3 & v) : RLine_3( p, v ) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_LINE_3 template < class R > std::ostream& operator<<(std::ostream& os, const Line_3& l) { typedef typename R::Kernel_base::Line_3 RLine_3; return os << static_cast(l); } #endif // CGAL_NO_OSTREAM_INSERT_LINE_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_LINE_3 template < class R > std::istream& operator>>(std::istream & is, Line_3 & p) { typedef typename R::Kernel_base::Line_3 RLine_3; is >> static_cast(p); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_LINE_3 CGAL_END_NAMESPACE #endif // CGAL_LINE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_3.h0000644000175000017500000001005411344301500026305 0ustar debiandebian// Copyright (c) 1999,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_BBOX_3_H #define CGAL_BBOX_3_H #include #include #include CGAL_BEGIN_NAMESPACE class Bbox_3 { Sixtuple rep; public: Bbox_3() {} Bbox_3(double x_min, double y_min, double z_min, double x_max, double y_max, double z_max) : rep(x_min, y_min, z_min, x_max, y_max, z_max) {} double xmin() const; double ymin() const; double zmin() const; double xmax() const; double ymax() const; double zmax() const; Bbox_3 operator+(const Bbox_3& b) const; }; inline double Bbox_3::xmin() const { return rep.e0; } inline double Bbox_3::ymin() const { return rep.e1; } inline double Bbox_3::zmin() const { return rep.e2; } inline double Bbox_3::xmax() const { return rep.e3; } inline double Bbox_3::ymax() const { return rep.e4; } inline double Bbox_3::zmax() const { return rep.e5; } inline Bbox_3 Bbox_3::operator+(const Bbox_3& b) const { return Bbox_3(std::min(xmin(), b.xmin()), std::min(ymin(), b.ymin()), std::min(zmin(), b.zmin()), std::max(xmax(), b.xmax()), std::max(ymax(), b.ymax()), std::max(zmax(), b.zmax())); } inline bool do_overlap(const Bbox_3& bb1, const Bbox_3& bb2) { // check for emptiness ?? if (bb1.xmax() < bb2.xmin() || bb2.xmax() < bb1.xmin()) return false; if (bb1.ymax() < bb2.ymin() || bb2.ymax() < bb1.ymin()) return false; if (bb1.zmax() < bb2.zmin() || bb2.zmax() < bb1.zmin()) return false; return true; } #ifndef CGAL_NO_OSTREAM_INSERT_BBOX_3 inline std::ostream& operator<<(std::ostream &os, const Bbox_3& b) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << b.xmin() << ' ' << b.ymin() << ' ' << b.zmin() << ' ' << b.xmax() << ' ' << b.ymax() << ' ' << b.zmax(); case IO::BINARY : write(os, b.xmin()); write(os, b.ymin()); write(os, b.zmin()); write(os, b.xmax()); write(os, b.ymax()); write(os, b.zmax()); return os; default: os << "Bbox_3((" << b.xmin() << ", " << b.ymin() << ", " << b.zmin() << "), ("; os << b.xmax() << ", " << b.ymax() << ", " << b.zmax() << "))"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_BBOX_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_BBOX_3 inline std::istream& operator>>(std::istream &is, Bbox_3& b) { double xmin, ymin, zmin, xmax, ymax, zmax; switch(is.iword(IO::mode)) { case IO::ASCII : is >> xmin >> ymin >> zmin >> xmax >> ymax >> zmax; break; case IO::BINARY : read(is, xmin); read(is, ymin); read(is, zmin); read(is, xmax); read(is, ymax); read(is, zmax); break; } b = Bbox_3(xmin, ymin, zmin, xmax, ymax, zmax); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_BBOX_3 CGAL_END_NAMESPACE #endif // CGAL_BBOX_3_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulat0000644000175000017500000010515511344301500031455 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec, Jean Daniel Boissonnat #ifndef CGAL_CONSTRAINED_TRIANGULATION_2_H #define CGAL_CONSTRAINED_TRIANGULATION_2_H #include #include #include #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #include #endif CGAL_BEGIN_NAMESPACE struct No_intersection_tag{}; struct Exact_intersections_tag{}; // to be used with an exact number type struct Exact_predicates_tag{}; // to be used with filtered exact number template < class Gt, class Tds = Triangulation_data_structure_2 < Triangulation_vertex_base_2, Constrained_triangulation_face_base_2 >, class Itag = No_intersection_tag > class Constrained_triangulation_2 : public Triangulation_2 { public: typedef Triangulation_2 Triangulation; typedef Constrained_triangulation_2 Constrained_triangulation; typedef typename Triangulation::Edge Edge; typedef typename Triangulation::Vertex Vertex; typedef typename Triangulation::Vertex_handle Vertex_handle; typedef typename Triangulation::Face_handle Face_handle; typedef typename Triangulation::Locate_type Locate_type; typedef typename Triangulation::All_faces_iterator All_faces_iterator; typedef typename Triangulation::Face_circulator Face_circulator; typedef typename Triangulation::Edge_circulator Edge_circulator; typedef typename Triangulation::Vertex_circulator Vertex_circulator; typedef typename Triangulation::Line_face_circulator Line_face_circulator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Triangulation::number_of_vertices; using Triangulation::cw; using Triangulation::ccw; using Triangulation::dimension; using Triangulation::geom_traits; using Triangulation::all_faces_begin; using Triangulation::all_faces_end; #endif typedef Gt Geom_traits; typedef Itag Intersection_tag; typedef typename Geom_traits::Point_2 Point; typedef typename Geom_traits::Segment_2 Segment; typedef std::pair Constraint; typedef std::list List_edges; typedef std::list List_faces; typedef std::list List_vertices; typedef std::list List_constraints; // Tag to mark the presence of a hierarchy of constraints typedef Tag_false Constraint_hierarchy_tag; class Less_edge; typedef std::set Edge_set; Constrained_triangulation_2(const Gt& gt = Gt()) : Triangulation(gt) { } Constrained_triangulation_2(const Constrained_triangulation_2& ct) : Triangulation(ct) {} Constrained_triangulation_2(std::list& lc, const Gt& gt=Gt()) : Triangulation_2(gt) { typename List_constraints::iterator lcit=lc.begin(); for( ;lcit != lc.end(); lcit++) { insert( (*lcit).first, (*lcit).second); } CGAL_triangulation_postcondition( this->is_valid() ); } template Constrained_triangulation_2(InputIterator it, InputIterator last, const Gt& gt=Gt() ) : Triangulation_2(gt) { for ( ; it != last; it++) { insert_constraint((*it).first, (*it).second); } CGAL_triangulation_postcondition( this->is_valid() ); } //TODO Is that destructor correct ? virtual ~Constrained_triangulation_2() {} // INSERTION Vertex_handle insert(const Point& p, Face_handle start = Face_handle() ); Vertex_handle insert(const Point& p, Locate_type lt, Face_handle loc, int li ); Vertex_handle push_back(const Point& a); // template < class InputIterator > // int insert(InputIterator first, InputIterator last); void insert_constraint(const Point& a, const Point& b); void insert_constraint(Vertex_handle va, Vertex_handle vb); void push_back(const Constraint& c); void remove(Vertex_handle v); void remove_constrained_edge(Face_handle f, int i); void remove_incident_constraints(Vertex_handle v); // to be used by Constrained_triangulation_plus_2 template OutputItFaces remove_constrained_edge(Face_handle f, int i, OutputItFaces out) { remove_constrained_edge(f, i); return out; } //for backward compatibility void remove_constraint(Face_handle f, int i) {remove_constrained_edge(f,i);} void insert(Point a, Point b) { insert_constraint(a, b);} void insert(Vertex_handle va, Vertex_handle vb) {insert_constraint(va,vb);} // QUERY bool is_constrained(Edge e) const; bool are_there_incident_constraints(Vertex_handle v) const; bool is_valid(bool verbose = false, int level = 0) const; // template // OutputItEdges incident_constraints(Vertex_handle v, // OutputItEdges out) const; class Less_edge : public std::binary_function { public: Less_edge() {} bool operator() (const Edge& e1, const Edge& e2) const { int ind1=e1.second, ind2=e2.second; return( (&(*e1.first) < &(*e2.first)) || ( (&(*e1.first) == &(*e2.first)) && (ind1 < ind2))); } }; void file_output(std::ostream& os) const; protected: virtual Vertex_handle virtual_insert(const Point& a, Face_handle start = Face_handle()); virtual Vertex_handle virtual_insert(const Point& a, Locate_type lt, Face_handle loc, int li ); //Vertex_handle special_insert_in_edge(const Point & a, Face_handle f, int i); void update_constraints_incident(Vertex_handle va, Vertex_handle c1, Vertex_handle c2); void clear_constraints_incident(Vertex_handle va); void update_constraints_opposite(Vertex_handle va); void update_constraints(const List_edges &hole); void mark_constraint(Face_handle fr, int i); virtual Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb); Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, No_intersection_tag); Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_intersections_tag); Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_predicates_tag); public: // made public for Laurent to find out deleted faces // when inserting a constraint with most probably // no intersection bool find_intersected_faces(Vertex_handle va, Vertex_handle vb, List_faces & intersected_faces, List_edges & list_ab, List_edges & list_ba, Vertex_handle& vi); protected: virtual void triangulate_hole(List_faces& intersected_faces, List_edges& conflict_boundary_ab, List_edges& conflict_boundary_ba); void triangulate_hole(List_faces& intersected_faces, List_edges& conflict_boundary_ab, List_edges& conflict_boundary_ba, List_edges& new_edges); void triangulate_half_hole(List_edges & list_edges, List_edges & new_edges); void remove_1D(Vertex_handle v); void remove_2D(Vertex_handle v); //templated member function public: // the int parameter is a work around for VC7 to compile template < class InputIterator > #if defined(_MSC_VER) || defined(__SUNPRO_CC) int insert(InputIterator first, InputIterator last, int i = 0) #else int insert(InputIterator first, InputIterator last) #endif { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } //deprecated template bool are_there_incident_constraints(Vertex_handle v, OutputIterator out) const { Edge_circulator ec=incident_edges(v), done(ec); bool are_there = false; if (ec == 0) return are_there; do { if(is_constrained(*ec)) { *out++ = *ec; are_there = true; } ec++; } while (ec != done); return are_there; } template OutputItEdges incident_constraints(Vertex_handle v, OutputItEdges out) const { Edge_circulator ec=incident_edges(v), done(ec); if (ec == 0) return out; do { if(is_constrained(*ec)) *out++ = *ec; ec++; } while (ec != done); return out; } // the following fonctions are overloaded // to take care of constraint marks template Vertex_handle star_hole( const Point& p, EdgeIt edge_begin, EdgeIt edge_end) { std::list empty_list; return star_hole(p, edge_begin, edge_end, empty_list.begin(), empty_list.end()); } template Vertex_handle star_hole( const Point& p, EdgeIt edge_begin, EdgeIt edge_end, FaceIt face_begin, FaceIt face_end) { Vertex_handle v = Triangulation::star_hole(p, edge_begin, edge_end, face_begin, face_end); // restore constraint status for new faces. int vindex; Face_handle fh; int ih; Face_circulator fc = incident_faces(v), done(fc); do { vindex = fc->index(v); fc->set_constraint(cw(vindex), false); fc->set_constraint(ccw(vindex), false); fh = fc->neighbor(vindex); ih = fc->mirror_index(vindex); fc->set_constraint(vindex, fh->is_constrained(ih)); } while (++fc != done); return v; } }; template < class Gt, class Tds, class Itag > inline typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: virtual_insert(const Point& a, Face_handle start) // virtual version of insert { return insert(a,start); } template < class Gt, class Tds, class Itag > inline typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: virtual_insert(const Point& a, Locate_type lt, Face_handle loc, int li ) // virtual version of insert { return insert(a,lt,loc,li); } template < class Gt, class Tds, class Itag > inline typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: insert(const Point& a, Face_handle start) // inserts point a // in addition to what is done for non constrained triangulations // constrained edges are updated { Face_handle loc; int li; Locate_type lt; loc = locate(a, lt, li, start); return Constrained_triangulation::insert(a,lt,loc,li); } template < class Gt, class Tds, class Itag > typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: insert(const Point& a, Locate_type lt, Face_handle loc, int li) // insert a point p, whose localisation is known (lt, f, i) // in addition to what is done for non constrained triangulations // constrained edges are updated { Vertex_handle va; Vertex_handle v1, v2; bool insert_in_constrained_edge = false; if ( lt == Triangulation::EDGE && loc->is_constrained(li) ){ insert_in_constrained_edge = true; v1=loc->vertex(ccw(li)); //endpoint of the constraint v2=loc->vertex(cw(li)); // endpoint of the constraint } va = Triangulation::insert(a,lt,loc,li); if (insert_in_constrained_edge) update_constraints_incident(va, v1,v2); else if(lt != Triangulation::VERTEX) clear_constraints_incident(va); if (dimension() == 2) update_constraints_opposite(va); return va; } // template < class Gt, class Tds, class Itag > // typename Constrained_triangulation_2::Vertex_handle // Constrained_triangulation_2:: // special_insert_in_edge(const Point & a, Face_handle f, int i) // // insert point p in edge(f,i) // // bypass the precondition for point a to be in edge(f,i) // // update constrained status // { // Vertex_handle va; // Vertex_handle c1,c2; // c1 = f->vertex(cw(i)); //endpoint of edge // c2 = f->vertex(ccw(i)); //endpoint of edge // bool insert_in_constrained_edge = f->is_constrained(i); // va = this->_tds.insert_in_edge(f, i); // va->set_point(a); // if (insert_in_constrained_edge) update_constraints_incident(va, c1,c2); // else clear_constraints_incident(va); // if (dimension() == 2) update_constraints_opposite(va); // return va; // } template < class Gt, class Tds, class Itag > inline void Constrained_triangulation_2:: insert_constraint(const Point& a, const Point& b) // the algorithm first inserts a and b, // and then forces the constraint [va,vb] { Vertex_handle va= virtual_insert(a); Vertex_handle vb= virtual_insert(b); if ( va != vb) insert_constraint(va,vb); } template inline void Constrained_triangulation_2:: insert_constraint(Vertex_handle vaa, Vertex_handle vbb) // forces the constrained [va,vb] // [va,vb] will eventually be splitted into several edges // if a vertex vc of t lies on segment ab // of if ab intersect some constrained edges { CGAL_triangulation_precondition( vaa != vbb); Vertex_handle vi; Face_handle fr; int i; if(includes_edge(vaa,vbb,vi,fr,i)) { mark_constraint(fr,i); if (vi != vbb) { insert_constraint(vi,vbb); } return; } List_faces intersected_faces; List_edges conflict_boundary_ab, conflict_boundary_ba; bool intersection = find_intersected_faces( vaa, vbb, intersected_faces, conflict_boundary_ab, conflict_boundary_ba, vi); if ( intersection) { if (vi != vaa && vi != vbb) { insert_constraint(vaa,vi); insert_constraint(vi,vbb); } else insert_constraint(vaa,vbb); return; } triangulate_hole(intersected_faces, conflict_boundary_ab, conflict_boundary_ba); if (vi != vbb) { insert_constraint(vi,vbb); } return; } template bool Constrained_triangulation_2:: find_intersected_faces(Vertex_handle vaa, Vertex_handle vbb, List_faces & intersected_faces, List_edges & list_ab, List_edges & list_ba, Vertex_handle & vi) // vi is set to the first vertex of the triangulation on [vaa,vbb]. // Return true if an intersection with a constrained edge is // encountered, false otherwise // When false : // intersected_faces contains the list if faces intersected by [va,vi] // list_ab and list_ba represents the boundary of the union // of the intersected faces oriented cw // list_ab consists of the edges from vaa to vi (i.e. on the left of a->b) // list_ba " " from vi to vaa (i.e. on the right of a->b) { const Point& aa = vaa->point(); const Point& bb = vbb->point(); Line_face_circulator current_face=Line_face_circulator(vaa, this, bb); int ind=current_face->index(vaa); // to deal with the case where the first crossed edge // is constrained if(current_face->is_constrained(ind)) { vi=intersect(current_face, ind, vaa, vbb); return true; } Face_handle lf= current_face->neighbor(ccw(ind)); Face_handle rf= current_face->neighbor(cw(ind)); Orientation orient; Face_handle previous_face; Vertex_handle current_vertex; list_ab.push_back(Edge(lf, lf->index(current_face))); list_ba.push_front(Edge(rf, rf->index(current_face))); intersected_faces.push_front(current_face); // initcd previous_face=current_face; ++current_face; ind=current_face->index(previous_face); current_vertex=current_face->vertex(ind); // loop over triangles intersected by ab bool done = false; while (current_vertex != vbb && !done) { orient = orientation(aa,bb,current_vertex->point()); int i1, i2; switch (orient) { case COLLINEAR : done = true; // current_vertex is the new endpoint break; case LEFT_TURN : case RIGHT_TURN : if (orient == LEFT_TURN) { i1 = ccw(ind) ; //index of second intersected edge of current_face i2 = cw(ind); //index of non intersected edge of current_face } else { i1 = cw(ind) ; //index of second intersected edge of current_face i2 = ccw(ind); //index of non intersected edge of current_face } if(current_face->is_constrained(i1)) { vi = intersect(current_face, i1, vaa,vbb); return true; } else { lf= current_face->neighbor(i2); intersected_faces.push_front(current_face); if (orient == LEFT_TURN) list_ab.push_back(Edge(lf, lf->index(current_face))); else // orient == RIGHT_TURN list_ba.push_front(Edge(lf, lf->index(current_face))); previous_face=current_face; ++current_face; ind=current_face->index(previous_face); current_vertex=current_face->vertex(ind); } break; } } // last triangle vi = current_vertex; intersected_faces.push_front(current_face); lf= current_face->neighbor(cw(ind)); list_ab.push_back(Edge(lf, lf->index(current_face))); rf= current_face->neighbor(ccw(ind)); list_ba.push_front(Edge(rf, rf->index(current_face))); return false; } template typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb) { return intersect(f, i, vaa, vbb, Itag()); } template typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: intersect(Face_handle , int , Vertex_handle , Vertex_handle , No_intersection_tag) { std::cerr << " sorry, this triangulation does not deal with" << std::endl << " intersecting constraints" << std::endl; CGAL_triangulation_assertion(false); return Vertex_handle() ; } template typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_intersections_tag) // compute the intersection of the constraint edge (f,i) // with the subconstraint (vaa,vbb) being inserted // insert the intersection point // split constraint edge (f,i) // and return the Vertex_handle of the new Vertex { std::cerr << "You are using an exact number types" << std::endl; std::cerr << "using a Constrained_triangulation_plus_2 class" << std::endl; std::cerr << "would avoid cascading intersection computation" << std::endl; std::cerr << " and be much more efficient" << std::endl; const Point& pa = vaa->point(); const Point& pb = vbb->point(); const Point& pc = f->vertex(cw(i))->point(); const Point& pd = f->vertex(ccw(i))->point(); Point pi; Itag itag = Itag(); CGAL_triangulation_assertion_code( bool ok = ) intersection(geom_traits(), pa, pb, pc, pd, pi, itag ); CGAL_triangulation_assertion(ok); Vertex_handle vi = virtual_insert(pi, Triangulation::EDGE, f, i); return vi; } template typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_predicates_tag) { Vertex_handle vcc, vdd; vcc = f->vertex(cw(i)); vdd = f->vertex(ccw(i)); const Point& pa = vaa->point(); const Point& pb = vbb->point(); const Point& pc = vcc->point(); const Point& pd = vdd->point(); Point pi; //creator for point is required here Itag itag = Itag(); bool ok = intersection(geom_traits(), pa, pb, pc, pd, pi, itag ); Vertex_handle vi; if ( !ok) { //intersection detected but not computed int i = limit_intersection(geom_traits(), pa, pb, pc, pd, itag); switch(i){ case 0 : vi = vaa; break; case 1 : vi = vbb; break; case 2 : vi = vcc; break; case 3 : vi = vdd; break; } } else{ //intersection computed remove_constrained_edge(f, i); vi = virtual_insert(pi, f); } // vi == vc or vi == vd may happen even if intersection==true // due to approximate construction of the intersection if (vi != vcc && vi != vdd) { insert_constraint(vcc,vi); insert_constraint(vi, vdd); } else { insert_constraint(vcc,vdd); } return vi; } template inline typename Constrained_triangulation_2::Vertex_handle Constrained_triangulation_2:: push_back(const Point &p) { return insert(p); } template inline void Constrained_triangulation_2:: push_back(const Constraint &c) { insert(c.first, c.second); } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: update_constraints_incident(Vertex_handle va, Vertex_handle c1, Vertex_handle c2) // update status of edges incident to a // after insertion in the constrained edge c1c2 { if (dimension() == 0) return; if (dimension()== 1) { Edge_circulator ec=va->incident_edges(), done(ec); do { ((*ec).first)->set_constraint(2,true); }while (++ec != done); } else{ //dimension() ==2 int cwi, ccwi, indf; Face_circulator fc=va->incident_faces(), done(fc); CGAL_triangulation_assertion(fc != 0); do { indf = fc->index(va); cwi=cw(indf); ccwi=ccw(indf); if ((fc->vertex(cwi) == c1)||(fc->vertex(cwi) == c2)) { fc->set_constraint(ccwi,true); fc->set_constraint(cwi,false); } else { fc->set_constraint(ccwi,false); fc->set_constraint(cwi,true); } ++fc; } while (fc != done); } } template < class Gt, class Tds ,class Itag > void Constrained_triangulation_2:: clear_constraints_incident(Vertex_handle va) // make the edges incident to a newly created vertex unconstrained { Edge_circulator ec=va->incident_edges(), done(ec); Face_handle f; int indf; if ( ec != 0){ do { f = (*ec).first ; indf = (*ec).second; f->set_constraint(indf,false); if (dimension() == 2) { f->neighbor(indf)->set_constraint(f->mirror_index(indf),false); } } while (++ec != done); } return; } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: update_constraints_opposite(Vertex_handle va) // update status of edges opposite to a // after insertion of a { CGAL_triangulation_assertion(dimension()==2); Face_handle f=va->face(), start=f; int indf; do { indf = f->index(va); if (f->neighbor(indf)->is_constrained(f->mirror_index(indf)) ) { f->set_constraint(indf,true); } else { f->set_constraint(indf,false); } f= f->neighbor(ccw(indf)); // turns ccw around va } while (f != start); return; } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: update_constraints( const List_edges &hole) { typename List_edges::const_iterator it = hole.begin(); Face_handle f; int i; for ( ; it != hole.end(); it ++) { f =(*it).first; i = (*it).second; if ( f->is_constrained(i) ) (f->neighbor(i))->set_constraint(f->mirror_index(i),true); else (f->neighbor(i))->set_constraint(f->mirror_index(i),false); } } template < class Gt, class Tds, class Itag > inline void Constrained_triangulation_2:: mark_constraint(Face_handle fr, int i) { if (dimension()==1) fr->set_constraint(2, true); else{ fr->set_constraint(i,true); fr->neighbor(i)->set_constraint(fr->mirror_index(i),true); } return; } template < class Gt, class Tds, class Itag > inline void Constrained_triangulation_2:: triangulate_hole(List_faces& intersected_faces, List_edges& conflict_boundary_ab, List_edges& conflict_boundary_ba) { List_edges new_edges; triangulate_hole(intersected_faces, conflict_boundary_ab, conflict_boundary_ba, new_edges); } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: triangulate_hole(List_faces& intersected_faces, List_edges& conflict_boundary_ab, List_edges& conflict_boundary_ba, List_edges& new_edges) // triangulate the hole limited by conflict_boundary_ab // and conflict_boundary_ba // insert the new edges in new-edges // delete the faces of intersected_faces { if ( !conflict_boundary_ab.empty() ) { triangulate_half_hole(conflict_boundary_ab, new_edges); triangulate_half_hole(conflict_boundary_ba, new_edges); // the two faces that share edge ab are neighbors // their common edge ab is a constraint Face_handle fr,fl; fl=(*conflict_boundary_ab.begin()).first; fr=(*conflict_boundary_ba.begin()).first; fl->set_neighbor(2, fr); fr->set_neighbor(2, fl); fl->set_constraint(2, true); fr->set_constraint(2, true); // delete intersected faces while( ! intersected_faces.empty()) { fl = intersected_faces.front(); intersected_faces.pop_front(); delete_face(fl); } } } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: remove(Vertex_handle v) // remove a vertex and updates the constrained edges of the new faces // precondition : there is no incident constraints { CGAL_triangulation_precondition( v != Vertex_handle() ); CGAL_triangulation_precondition( ! is_infinite(v)); CGAL_triangulation_precondition( ! are_there_incident_constraints(v)); if (number_of_vertices() == 1) remove_first(v); else if (number_of_vertices() == 2) remove_second(v); else if ( dimension() == 1) remove_1D(v); else remove_2D(v); return; } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: remove_1D(Vertex_handle v) { Edge_circulator ec = incident_edges(v), done(ec); do { (*ec).first->set_constraint(2,false); } while (++ec != done); Triangulation::remove_1D(v); } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: remove_2D(Vertex_handle v) { if (test_dim_down(v)) { this->_tds.remove_dim_down(v);} else { List_edges hole; make_hole(v, hole); List_edges shell=hole; //save hole because it will be emptied by fill_hole fill_hole(v, hole); update_constraints(shell); delete_vertex(v); } return; } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: remove_constrained_edge(Face_handle f, int i) { f->set_constraint(i, false); if (dimension() == 2) (f->neighbor(i))->set_constraint(f->mirror_index(i), false); return; } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: remove_incident_constraints(Vertex_handle v) { Edge_circulator ec=incident_edges(v), done(ec); if (ec == 0) return; do { if(is_constrained(*ec)) { remove_constrained_edge((*ec).first, (*ec).second);} ec++; } while (ec != done); return; } template < class Gt, class Tds, class Itag > inline bool Constrained_triangulation_2:: are_there_incident_constraints(Vertex_handle v) const { return are_there_incident_constraints(v, Emptyset_iterator()); } template < class Gt, class Tds, class Itag > inline bool Constrained_triangulation_2:: is_valid(bool verbose, int level) const { bool result = Triangulation::is_valid(verbose,level); for( All_faces_iterator it = all_faces_begin(); it != all_faces_end() ; it++) { for(int i=0; i<3; i++) { Face_handle n = it->neighbor(i); result = result && it->is_constrained(i) == n->is_constrained(n->index(it)); } } return result; } template < class Gt, class Tds, class Itag > inline bool Constrained_triangulation_2:: is_constrained(Edge e) const { return (e.first)->is_constrained(e.second); } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: triangulate_half_hole(List_edges & list_edges, List_edges & new_edges) // triangulates the polygon whose boundary consists of list_edges // plus the edge ab joining the two endpoints of list_edges // the orientation of the polygon (as provided by list_edges) must // be cw // the edges of list_edges are assumed to be edges of a // triangulation that will be updated by the procedure // the edges that are created are put in list new_edges // takes linear time { Vertex_handle va,vb; // first and last vertices of list_edges Face_handle newlf; Face_handle n1,n2,n; int ind1, ind2,ind; Orientation orient; typename List_edges::iterator current, next, tempo; current=list_edges.begin(); tempo=list_edges.end(); --tempo; va=((*current).first)->vertex(ccw((*current).second)); vb=((*tempo).first)->vertex(cw((*tempo).second)); next=current; ++next; do { n1=(*current).first; ind1=(*current).second; // in case n1 is no longer a triangle of the new triangulation if ( n1->neighbor(ind1) != Face_handle() ) { n=n1->neighbor(ind1); //ind=n1->mirror_index(ind1); // mirror_index does not work in this case ind = cw(n->index(n1->vertex(cw(ind1)))); n1=n->neighbor(ind); ind1= n->mirror_index(ind); } n2=(*next).first; ind2=(*next).second; // in case n2 is no longer a triangle of the new triangulation if (n2->neighbor(ind2) != Face_handle() ) { n=n2->neighbor(ind2); // ind=n2->mirror_index(ind2); // mirror_index does not work in this case ind = cw(n->index(n2->vertex(cw(ind2)))); n2=n->neighbor(ind); ind2= n->mirror_index(ind); } Vertex_handle v0=n1->vertex(ccw(ind1)); Vertex_handle v1=n1->vertex(cw(ind1)); Vertex_handle v2=n2->vertex(cw(ind2)); orient= orientation(v0->point(),v1->point(),v2->point()); switch (orient) { case RIGHT_TURN : // creates the new triangle v0v1v2 // updates the neighbors, the constraints //and the list of new edges newlf = create_face(v0,v2,v1); new_edges.push_back(Edge(newlf,2)); newlf->set_neighbor(1, n1); newlf->set_neighbor(0, n2); n1->set_neighbor(ind1, newlf); n2->set_neighbor(ind2, newlf); if (n1->is_constrained(ind1)) { newlf->set_constraint(1,true); } if (n2->is_constrained(ind2)) { newlf->set_constraint(0,true); } // v0, v1 or v2.face() may have been removed v0->set_face(newlf); v1->set_face(newlf); v2->set_face(newlf); // update list_edges tempo=current; current=list_edges.insert(current, Edge(newlf,2)); list_edges.erase(tempo); list_edges.erase(next); next=current; if (v0 != va) {--current;} else {++next;} break; case LEFT_TURN : ++current; ++next; break; case COLLINEAR : ++current; ++next; break; } } while (list_edges.size()>1); } template < class Gt, class Tds, class Itag > void Constrained_triangulation_2:: file_output(std::ostream& os) const { Triangulation_2::file_output(os); // write constrained status typename Tds::Face_iterator ib = this->_tds.face_iterator_base_begin(); for( ; ib != this->_tds.face_iterator_base_end(); ++ib) { for(int j = 0; j < 3; ++j){ if (ib->is_constrained(j)) { os << "C";} else { os << "N";} if(is_ascii(os)){ if(j==2) { os << "\n"; } else { os << ' '; } } } } } template < class Gt, class Tds, class Itag > std::ostream & operator<<(std::ostream& os, const Constrained_triangulation_2 &ct) { ct.file_output(os); return os ; } //Helping functions to compute intersections of constrained edges template bool intersection(Gt , const typename Gt::Point_2& , const typename Gt::Point_2& , const typename Gt::Point_2& , const typename Gt::Point_2& , typename Gt::Point_2& , No_intersection_tag) { return false; } template bool intersection(Gt gt, const typename Gt::Point_2& pa, const typename Gt::Point_2& pb, const typename Gt::Point_2& pc, const typename Gt::Point_2& pd, typename Gt::Point_2& pi, Exact_intersections_tag) { return compute_intersection(gt,pa,pb,pc,pd,pi); } template inline bool intersection(Gt gt, const typename Gt::Point_2& pa, const typename Gt::Point_2& pb, const typename Gt::Point_2& pc, const typename Gt::Point_2& pd, typename Gt::Point_2& pi, Exact_predicates_tag) { return compute_intersection(gt,pa,pb,pc,pd,pi); } template bool compute_intersection(Gt gt, const typename Gt::Point_2& pa, const typename Gt::Point_2& pb, const typename Gt::Point_2& pc, const typename Gt::Point_2& pd, typename Gt::Point_2& pi) { typename Gt::Intersect_2 compute_intersec=gt.intersect_2_object(); typename Gt::Construct_segment_2 construct_segment=gt.construct_segment_2_object(); Object result = compute_intersec(construct_segment(pa,pb), construct_segment(pc,pd)); return assign(pi, result); } template int limit_intersection(Gt , const typename Gt::Point_2& , const typename Gt::Point_2& , const typename Gt::Point_2& , const typename Gt::Point_2& , No_intersection_tag) { return 0; } template int limit_intersection(Gt , const typename Gt::Point_2& , const typename Gt::Point_2& , const typename Gt::Point_2& , const typename Gt::Point_2& , Exact_intersections_tag) { return 0; } template int limit_intersection(Gt gt, const typename Gt::Point_2& pa, const typename Gt::Point_2& pb, const typename Gt::Point_2& pc, const typename Gt::Point_2& pd, Exact_predicates_tag) { typename Gt::Construct_line_2 line = gt.construct_line_2_object(); typename Gt::Compute_squared_distance_2 distance = gt.compute_squared_distance_2_object(); typename Gt::Line_2 l1 = line(pa,pb); typename Gt::Line_2 l2 = line(pc,pd); int i = 0; typename Gt::FT dx = distance(l2,pa); typename Gt::FT db = distance(l2,pb); typename Gt::FT dc = distance(l1,pc); typename Gt::FT dd = distance(l1,pd); if ( db < dx ) { dx = db; i = 1;} if ( dc < dx ) { dx = dc; i = 2;} if ( dd < dx ) { i = 3;} return i; } CGAL_END_NAMESPACE #endif //CGAL_CONSTRAINED_TRIANGULATION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/random_polygon_2.h0000644000175000017500000001156211344301500030446 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/random_polygon_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_RANDOM_POLYGON_2_H #define CGAL_RANDOM_POLYGON_2_H #include #include #include #include #include #include namespace CGAL { // // Using the provided point generator, generates a set of n points and // produces a simple polygon from the unique subset of points within this // set. // // Each of the p possible simple polygons for the unique point set is // generated with probability greater than 0 but the polygons are not // generated with uniform probability. // template OutputIterator random_polygon_2(int n, OutputIterator result, const PointGenerator& pg, const Traits& traits) { typedef typename Traits::Point_2 Point_2; typedef std::vector Vertex_list; typedef typename Vertex_list::iterator Iterator; Vertex_list vertices; copy_n_unique(pg, n, std::back_inserter(vertices), traits); CGAL_assertion(!duplicate_points(vertices.begin(), vertices.end(), traits)); std::random_shuffle(vertices.begin(), vertices.end()); make_simple_polygon(vertices.begin(), vertices.end(), traits); if (orientation_2(vertices.begin(), vertices.end()) == CLOCKWISE) std::reverse(vertices.begin(), vertices.end()); CGAL_assertion(is_simple_2(vertices.begin(), vertices.end())); for (Iterator it = vertices.begin(); it != vertices.end(); it++) { *result = *it; result++; } return result; } template inline OutputIterator random_polygon_2( int n, OutputIterator result, const PointGenerator& pg ) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return random_polygon_2(n, result, pg, K()); } template bool duplicate_points(ForwardIterator first, ForwardIterator beyond, const Traits& ) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Less_xy_2 Less_xy_2; std::set point_set; int i = 0; for (; first != beyond; first++, i++) if (!(point_set.insert(*first)).second) return true; return false; } template bool duplicate_points(ForwardIterator first, ForwardIterator beyond) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return duplicate_points(first, beyond, K()); } // Copies the first n points from the input iterator to the output iterator, // removing any duplicates. Thus fewer than n points may be inserted into // the output iterator. template OutputIterator copy_n_unique(InputIterator first, Size n, OutputIterator result, const Traits& ) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Less_xy_2 Less_xy_2; std::set sorted_point_set; int i; for (i = 0; i < n; i++) { if (sorted_point_set.insert(*first).second) { *result = *first; result++; } first++; } return result; } template inline OutputIterator copy_n_unique(InputIterator first, Size n, OutputIterator result) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return copy_n_unique(first, n, result, K()); } } // namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_on_node.h0000644000175000017500000000574711344301500031016 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_on_node.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_CIRCULATOR_ON_NODE_H #define CGAL_CIRCULATOR_ON_NODE_H 1 #include CGAL_BEGIN_NAMESPACE template < class Node, class Next, class Prev, class Ref = Node&, class Ptr = Node*, class Ctg = Bidirectional_circulator_tag> class Circulator_on_node { protected: Ptr nt; // The internal node ptr. public: typedef Circulator_on_node Self; typedef Ctg iterator_category; typedef Node value_type; typedef std::ptrdiff_t difference_type; typedef std::size_t size_type; typedef Ref reference; typedef Ptr pointer; // CREATION // -------- Circulator_on_node() : nt(0) {} Circulator_on_node( Ptr p) : nt(p) {} // OPERATIONS Forward Category // --------------------------- Ptr ptr() const { return nt;} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == 0); return ( nt == 0); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } Ref operator*() const { return *nt; } Ptr operator->() const { return nt; } Self& operator++() { Next next; nt = next(nt); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { Prev prev; nt = prev(nt); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; CGAL_END_NAMESPACE #endif // CGAL_CIRCULATOR_ON_NODE_H // // EOF // ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Ray_2_intersect0000644000175000017500000000222511344301500031170 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_filtered_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_filte0000644000175000017500000003453211344301500031443 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_filtered_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_FILTERED_TRAITS_2_H #define CGAL_APOLLONIUS_GRAPH_FILTERED_TRAITS_2_H #include #include // includes for the default parameters of the filtered traits #include #include #include #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- // the filtered Traits class //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- #if defined(__sun) && defined(__SUNPRO_CC) // workaround for the Sun CC-5.30 compiler; it does not like default // template parameters that are themselves templates and have // templated classes as parameters, which have then nested types as // arguments... oooof!!! // // In case you did understand what I just described you are most // probably crazy... If you did not, look below to see what kind of // code CC-5.30 did not like. namespace CGALi { template struct AG_SUNPRO_CC_Interval_converter : public Cartesian_converter > { }; } #endif template, class EK_MTag = CK_MTag, class FK_t = Simple_cartesian< Interval_nt >, class FK_MTag = CK_MTag, class C2E_t = Cartesian_converter, #if defined(__sun) && defined(__SUNPRO_CC) class C2F_t = CGALi::AG_SUNPRO_CC_Interval_converter > #else class C2F_t = Cartesian_converter > > #endif class Apollonius_graph_filtered_traits_2 { private: typedef Apollonius_graph_traits_2 CK_traits; typedef Apollonius_graph_traits_2 FK_traits; typedef Apollonius_graph_traits_2 EK_traits; typedef Apollonius_graph_kernel_wrapper_2 CK; typedef Apollonius_graph_kernel_wrapper_2 FK; typedef Apollonius_graph_kernel_wrapper_2 EK; typedef Apollonius_graph_cartesian_converter C2E; typedef Apollonius_graph_cartesian_converter C2F; // Types for the construction kernel typedef typename CK::Point_2 CK_Point_2; typedef typename CK::Site_2 CK_Site_2; typedef typename CK::Line_2 CK_Line_2; typedef typename CK::Ray_2 CK_Ray_2; typedef typename CK::Segment_2 CK_Segment_2; typedef typename CK::FT CK_FT; typedef typename CK::RT CK_RT; // Types for the exact kernel typedef typename EK::Point_2 EK_Point_2; typedef typename EK::Site_2 EK_Site_2; typedef typename EK::Line_2 EK_Line_2; typedef typename EK::Ray_2 EK_Ray_2; typedef typename EK::Segment_2 EK_Segment_2; typedef typename EK::FT EK_FT; typedef typename EK::RT EK_RT; // Types for the filtering kernel typedef typename FK::Point_2 FK_Point_2; typedef typename FK::Site_2 FK_Site_2; typedef typename FK::Line_2 FK_Line_2; typedef typename FK::Ray_2 FK_Ray_2; typedef typename FK::Segment_2 FK_Segment_2; typedef typename FK::FT FK_FT; typedef typename FK::RT FK_RT; public: //----------------------------------------------------------------------- // TYPE DEFINITIONS //----------------------------------------------------------------------- // BASIC TYPES //------------ typedef CK_t R; typedef CK_MTag Method_tag; typedef CK_traits Construction_traits; typedef FK_traits Filtering_traits; typedef EK_traits Exact_traits; typedef CK_MTag Construction_traits_method_tag; typedef FK_MTag Filtering_traits_method_tag; typedef EK_MTag Exact_traits_method_tag; typedef typename CK::Point_2 Point_2; typedef typename CK::Site_2 Site_2; typedef typename CK::Line_2 Line_2; typedef typename CK::Ray_2 Ray_2; typedef typename CK::Segment_2 Segment_2; typedef typename CK::Object_2 Object_2; typedef typename CK::FT FT; typedef typename CK::RT RT; public: // OBJECT CONSTRUCTION & ASSIGNMENT //--------------------------------- typedef typename CK_traits::Construct_object_2 Construct_object_2; typedef typename CK_traits::Assign_2 Assign_2; // CONSTRUCTIONS //-------------- // vertex and dual site typedef typename CK_traits::Construct_Apollonius_vertex_2 Construct_Apollonius_vertex_2; typedef typename CK_traits::Construct_Apollonius_site_2 Construct_Apollonius_site_2; private: // PREDICATES FOR THE TWO KERNELS //------------------------------- #if 1 // Predicates for the filtering kernel typedef typename FK_traits::Compare_x_2 FK_Compare_x_2; typedef typename FK_traits::Compare_y_2 FK_Compare_y_2; typedef typename FK_traits::Compare_weight_2 FK_Compare_weight_2; typedef typename FK_traits::Orientation_2 FK_Orientation_2; typedef typename FK_traits::Is_hidden_2 FK_Is_hidden_2; typedef typename FK_traits::Oriented_side_of_bisector_2 FK_Oriented_side_of_bisector_2; typedef typename FK_traits::Vertex_conflict_2 FK_Vertex_conflict_2; typedef typename FK_traits::Finite_edge_interior_conflict_2 FK_Finite_edge_interior_conflict_2; typedef typename FK_traits::Infinite_edge_interior_conflict_2 FK_Infinite_edge_interior_conflict_2; typedef typename FK_traits::Is_degenerate_edge_2 FK_Is_degenerate_edge_2; // Predicates for the exact kernel typedef typename EK_traits::Compare_x_2 EK_Compare_x_2; typedef typename EK_traits::Compare_y_2 EK_Compare_y_2; typedef typename EK_traits::Compare_weight_2 EK_Compare_weight_2; typedef typename EK_traits::Orientation_2 EK_Orientation_2; typedef typename EK_traits::Is_hidden_2 EK_Is_hidden_2; typedef typename EK_traits::Oriented_side_of_bisector_2 EK_Oriented_side_of_bisector_2; typedef typename EK_traits::Vertex_conflict_2 EK_Vertex_conflict_2; typedef typename EK_traits::Finite_edge_interior_conflict_2 EK_Finite_edge_interior_conflict_2; typedef typename EK_traits::Infinite_edge_interior_conflict_2 EK_Infinite_edge_interior_conflict_2; typedef typename EK_traits::Is_degenerate_edge_2 EK_Is_degenerate_edge_2; #else // Predicates for the filtering kernel typedef Ag2_compare_x_2 FK_Compare_x_2; // typedef typename FK_traits::Compare_x_2 FK_Compare_x_2; typedef Ag2_compare_y_2 FK_Compare_y_2; // typedef typename FK_traits::Compare_y_2 FK_Compare_y_2; typedef Ag2_compare_weight_2 FK_Compare_weight_2; // typedef typename FK_traits::Compare_weight_2 FK_Compare_weight_2; typedef Ag2_orientation_2 FK_Orientation_2; // typedef typename FK_traits::Orientation_2 FK_Orientation_2; typedef Ag2_is_hidden_C2 FK_Is_hidden_2; // typedef typename FK_traits::Is_hidden_2 FK_Is_hidden_2; typedef Ag2_oriented_side_of_bisector_C2 /* */ FK_Oriented_side_of_bisector_2; // typedef typename FK_traits::Oriented_side_of_bisector_2 // FK_Oriented_side_of_bisector_2; // typedef typename FK_traits::Vertex_conflict_2 FK_Vertex_conflict_2; typedef Incircle_test FK_Vertex_conflict_2; typedef Ag2_finite_edge_test_C2 /* */ FK_Finite_edge_interior_conflict_2; // typedef typename FK_traits::Finite_edge_interior_conflict_2 // FK_Finite_edge_interior_conflict_2; typedef Infinite_edge_test /* */ FK_Infinite_edge_interior_conflict_2; // typedef typename FK_traits::Infinite_edge_interior_conflict_2 // FK_Infinite_edge_interior_conflict_2; typedef Is_degenerate_edge_test FK_Is_degenerate_edge_2; // typedef typename FK_traits::Is_degenerate_edge_2 // FK_Is_degenerate_edge_2; // Predicates for the exact kernel typedef Ag2_compare_x_2 EK_Compare_x_2; // typedef typename EK_traits::Compare_x_2 EK_Compare_x_2; typedef Ag2_compare_y_2 EK_Compare_y_2; // typedef typename EK_traits::Compare_y_2 EK_Compare_y_2; typedef Ag2_compare_weight_2 EK_Compare_weight_2; // typedef typename EK_traits::Compare_weight_2 EK_Compare_weight_2; typedef Ag2_orientation_2 EK_Orientation_2; // typedef typename EK_traits::Orientation_2 EK_Orientation_2; typedef Ag2_is_hidden_C2 EK_Is_hidden_2; // typedef typename EK_traits::Is_hidden_2 EK_Is_hidden_2; typedef Ag2_oriented_side_of_bisector_C2 /* */ EK_Oriented_side_of_bisector_2; // typedef typename EK_traits::Oriented_side_of_bisector_2 // EK_Oriented_side_of_bisector_2; // typedef typename EK_traits::Vertex_conflict_2 EK_Vertex_conflict_2; typedef Incircle_test EK_Vertex_conflict_2; typedef Ag2_finite_edge_test_C2 /* */ EK_Finite_edge_interior_conflict_2; // typedef typename EK_traits::Finite_edge_interior_conflict_2 // EK_Finite_edge_interior_conflict_2; typedef Infinite_edge_test /* */ EK_Infinite_edge_interior_conflict_2; // typedef typename EK_traits::Infinite_edge_interior_conflict_2 // EK_Infinite_edge_interior_conflict_2; typedef Is_degenerate_edge_test EK_Is_degenerate_edge_2; // typedef typename EK_traits::Is_degenerate_edge_2 // EK_Is_degenerate_edge_2; #endif public: // PREDICATES //----------- typedef Filtered_predicate Compare_x_2; typedef Filtered_predicate Compare_y_2; typedef Filtered_predicate Compare_weight_2; typedef Filtered_predicate Orientation_2; typedef Filtered_predicate Is_hidden_2; typedef Filtered_predicate Oriented_side_of_bisector_2; typedef Filtered_predicate Vertex_conflict_2; typedef Filtered_predicate Finite_edge_interior_conflict_2; typedef Filtered_predicate Infinite_edge_interior_conflict_2; typedef Filtered_predicate Is_degenerate_edge_2; public: //----------------------------------------------------------------------- // ACCESS TO OBJECTS //----------------------------------------------------------------------- // OBJECT CONSTRUCTION & ASSIGNMENT Assign_2 assign_2_object() const { return Assign_2(); } Construct_object_2 construct_object_2_object() const { return Construct_object_2(); } // CONSTRUCTIONS //-------------- Construct_Apollonius_vertex_2 construct_Apollonius_vertex_2_object() const { return Construct_Apollonius_vertex_2(); } Construct_Apollonius_site_2 construct_Apollonius_site_2_object() const { return Construct_Apollonius_site_2(); } // PREDICATES //----------- Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Compare_weight_2 compare_weight_2_object() const { return Compare_weight_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Is_hidden_2 is_hidden_2_object() const { return Is_hidden_2(); } Oriented_side_of_bisector_2 oriented_side_of_bisector_2_object() const { return Oriented_side_of_bisector_2(); } Vertex_conflict_2 vertex_conflict_2_object() const { return Vertex_conflict_2(); } Finite_edge_interior_conflict_2 finite_edge_interior_conflict_2_object() const { return Finite_edge_interior_conflict_2(); } Infinite_edge_interior_conflict_2 infinite_edge_interior_conflict_2_object() const { return Infinite_edge_interior_conflict_2(); } Is_degenerate_edge_2 is_degenerate_edge_2_object() const { return Is_degenerate_edge_2(); } }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_FILTERED_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_traits_2.h0000644000175000017500000001062711344301500030757 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef PARTITION_TRAITS_2_H #define PARTITION_TRAITS_2_H #include #include #include #include namespace CGAL { template class Partition_traits_2 : public Partition_traits_2_base { private: typedef Kernel_ Kernel; typedef Partition_traits_2 Self; public: typedef typename Kernel::Point_2 Point_2; typedef ::std::list Container; typedef CGAL::Polygon_2 Polygon_2; typedef typename Kernel::Less_yx_2 Less_yx_2; typedef typename Kernel::Less_xy_2 Less_xy_2; typedef typename Kernel::Left_turn_2 Left_turn_2; typedef typename Kernel::Orientation_2 Orientation_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Compare_x_2 Compare_x_2; typedef CGAL::Is_convex_2 Is_convex_2; typedef CGAL::Is_y_monotone_2 Is_y_monotone_2; // needed by Indirect_edge_compare, used in y_monotone and greene_approx typedef typename Kernel::Line_2 Line_2; typedef typename Kernel::Construct_line_2 Construct_line_2; typedef typename Kernel::Compare_x_at_y_2 Compare_x_at_y_2; typedef typename Kernel::Is_horizontal_2 Is_horizontal_2; // needed by visibility graph and thus by optimal convex typedef typename Kernel::Ray_2 Ray_2; typedef typename Kernel::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; typedef typename Kernel::Are_strictly_ordered_along_line_2 Are_strictly_ordered_along_line_2; typedef typename Kernel::Intersect_2 Intersect_2; typedef typename Kernel::Assign_2 Assign_2; typedef typename Kernel::Object_2 Object_2; // needed by approx_convex (for constrained triangulation) // and optimal convex (for vis. graph) typedef typename Kernel::Segment_2 Segment_2; // needed by optimal convex (for vis. graph) typedef typename Kernel::Construct_segment_2 Construct_segment_2; typedef typename Kernel::Construct_ray_2 Construct_ray_2; Construct_line_2 construct_line_2_object() const { return Construct_line_2(); } Compare_x_at_y_2 compare_x_at_y_2_object() const { return Compare_x_at_y_2(); } Construct_segment_2 construct_segment_2_object() const { return Construct_segment_2(); } Construct_ray_2 construct_ray_2_object() const { return Construct_ray_2(); } Collinear_are_ordered_along_line_2 collinear_are_ordered_along_line_2_object() const { return Collinear_are_ordered_along_line_2(); } Are_strictly_ordered_along_line_2 are_strictly_ordered_along_line_2_object() const { return Are_strictly_ordered_along_line_2(); } Is_horizontal_2 is_horizontal_2_object() const { return Is_horizontal_2(); } Is_convex_2 is_convex_2_object(const Self& traits) const { return Is_convex_2(traits); } Is_y_monotone_2 is_y_monotone_2_object(const Self& traits) const { return Is_y_monotone_2(traits); } Intersect_2 intersect_2_object() const { return Intersect_2(); } Assign_2 assign_2_object() const { return Assign_2(); } }; } #endif // PARTITION_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_algorithms.h0000644000175000017500000002015711344301500031277 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_algorithms.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink #ifndef CGAL_POLYGON_2_ALGORITHMS_H #define CGAL_POLYGON_2_ALGORITHMS_H #include #include #include #include CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // algorithms for sequences of 2D points //-----------------------------------------------------------------------// template ForwardIterator left_vertex_2(ForwardIterator first, ForwardIterator last, const Traits& traits); template ForwardIterator right_vertex_2(ForwardIterator first, ForwardIterator last, const Traits& traits); template ForwardIterator top_vertex_2(ForwardIterator first, ForwardIterator last, const Traits& traits); template ForwardIterator bottom_vertex_2(ForwardIterator first, ForwardIterator last, const Traits& traits); template Bbox_2 bbox_2(InputIterator first, InputIterator last, const Traits& traits); template void area_2( ForwardIterator first, ForwardIterator last, typename Traits::FT &result, const Traits& traits) { typedef typename Traits::FT FT; result = FT(0); // check if the polygon is empty if (first == last) return; ForwardIterator second = first; ++second; // check if the polygon has only one point if (second == last) return; typename Traits::Compute_area_2 compute_area_2 = traits.compute_area_2_object(); ForwardIterator third = second; while (++third != last) { result = result + compute_area_2(*first, *second, *third); second = third; } } template typename Traits::FT polygon_area_2( ForwardIterator first, ForwardIterator last, const Traits& traits) { typedef typename Traits::FT FT; FT result = FT(0); // check if the polygon is empty if (first == last) return result; ForwardIterator second = first; ++second; // check if the polygon has only one point if (second == last) return result; typename Traits::Compute_area_2 compute_area_2 = traits.compute_area_2_object(); ForwardIterator third = second; while (++third != last) { result = result + compute_area_2(*first, *second, *third); second = third; } return result; } template bool is_convex_2(ForwardIterator first, ForwardIterator last, const Traits& traits); template bool is_simple_2(ForwardIterator first, ForwardIterator last, const Traits& traits); // In the following two functions we would like to use Traits::Point_2 instead // of Point, but this is not allowed by g++ 2.7.2. template Oriented_side oriented_side_2(ForwardIterator first, ForwardIterator last, const Point& point, const Traits& traits); template Bounded_side bounded_side_2(ForwardIterator first, ForwardIterator last, const Point& point, const Traits& traits); template Orientation orientation_2(ForwardIterator first, ForwardIterator last, const Traits& traits); //-----------------------------------------------------------------------// // implementation //-----------------------------------------------------------------------// #ifdef CGAL_REP_CLASS_DEFINED template inline ForwardIterator left_vertex_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return left_vertex_2(first, last, K()); } template inline ForwardIterator right_vertex_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return right_vertex_2(first, last, K()); } template inline ForwardIterator top_vertex_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return top_vertex_2(first, last, K()); } template inline ForwardIterator bottom_vertex_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return bottom_vertex_2(first, last, K()); } template inline Bbox_2 bbox_2(InputIterator first, InputIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return bbox_2(first, last, K()); } template inline void area_2(ForwardIterator first, ForwardIterator last, Numbertype& result) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; area_2(first, last, result, K()); } template inline bool is_convex_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return is_convex_2(first, last, K()); } template inline bool is_simple_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return is_simple_2(first, last, K()); } template inline Oriented_side oriented_side_2( ForwardIterator first, ForwardIterator last, const typename std::iterator_traits::value_type& point) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return oriented_side_2(first, last, point, K()); } template inline Bounded_side bounded_side_2( ForwardIterator first, ForwardIterator last, const typename std::iterator_traits::value_type& point) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return bounded_side_2(first, last, point, K()); } template inline Orientation orientation_2(ForwardIterator first, ForwardIterator last) { typedef typename Kernel_traits< typename std::iterator_traits::value_type>::Kernel K; return orientation_2(first, last, K()); } #endif // CGAL_REP_CLASS_DEFINED CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_POLYGON_2_ALGORITHMS_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Ray_3_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Ray_3_do_in0000644000175000017500000002305411344301501031144 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Ray_3_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_3_RAY_3_DO_INTERSECT_H #define CGAL_TRIANGLE_3_RAY_3_DO_INTERSECT_H CGAL_BEGIN_NAMESPACE namespace CGALi { template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t, const typename CGAL_WRAP(K)::Ray_3 &r, const K & k) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; CGAL_kernel_precondition( ! k.is_degenerate_3_object()(r) ) ; typedef typename K::Point_3 Point_3; typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Orientation_3 orientation = k.orientation_3_object(); const Point_3 & a = vertex_on(t,0); const Point_3 & b = vertex_on(t,1); const Point_3 & c = vertex_on(t,2); typename K::Construct_vector_3 construct_vector = k.construct_vector_3_object(); typename K::Construct_ray_3 construct_ray = k.construct_ray_3_object(); typename K::Construct_point_on_3 point_on = k.construct_point_on_3_object(); const Point_3 & p = point_on(r,0); const Point_3 & q = point_on(r,1); const Orientation ray_direction = orientation(a,b,c,point_on(construct_ray(a, construct_vector(r)),1)); if (ray_direction == COPLANAR ) { if (orientation(a,b,c,p) == COPLANAR) return do_intersect_coplanar(t,r,k); else return false; } const Orientation abcp = orientation(a,b,c,p); switch ( abcp ) { case POSITIVE: switch ( ray_direction ) { case POSITIVE: // the ray lies in the positive open halfspaces defined by the // triangle's supporting plane return false; case NEGATIVE: // The ray straddles the triangle's plane // p sees the triangle in counterclockwise order return orientation(p,q,a,b) != POSITIVE && orientation(p,q,b,c) != POSITIVE && orientation(p,q,c,a) != POSITIVE; // case COPLANAR: should not happen default: // should not happen. CGAL_kernel_assertion(false); return false; } case NEGATIVE: switch ( ray_direction ) { case POSITIVE: // The ray straddles the triangle's plane // q sees the triangle in counterclockwise order return orientation(q,p,a,b) != POSITIVE && orientation(q,p,b,c) != POSITIVE && orientation(q,p,c,a) != POSITIVE; case NEGATIVE: // the ray lies in the negative open halfspaces defined by the // triangle's supporting plane return false; // case COPLANAR: should not happen default: // should not happen. CGAL_kernel_assertion(false); return false; } case COPLANAR: // p belongs to the triangle's supporting plane switch ( ray_direction ) { case POSITIVE: // q sees the triangle in counterclockwise order return orientation(q,p,a,b) != POSITIVE && orientation(q,p,b,c) != POSITIVE && orientation(q,p,c,a) != POSITIVE; case NEGATIVE: // q sees the triangle in clockwise order return orientation(p,q,a,b) != POSITIVE && orientation(p,q,b,c) != POSITIVE && orientation(p,q,c,a) != POSITIVE; // case COPLANAR: should not happen default: // should not happen. CGAL_kernel_assertion(false); return false; } default: // should not happen. CGAL_kernel_assertion(false); return false; } } template inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_3 &r, const typename CGAL_WRAP(K)::Triangle_3 &t, const K & k) { return do_intersect(t,r, k); } template bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Triangle_3 &t, const typename CGAL_WRAP(K)::Ray_3 &r, const K & k ) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; CGAL_kernel_precondition( ! k.is_degenerate_3_object()(r) ) ; typedef typename K::Point_3 Point_3; typename K::Construct_point_on_3 point_on = k.construct_point_on_3_object(); typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); const Point_3 & p = point_on(r,0); const Point_3 & q = point_on(r,1); const Point_3 & A = vertex_on(t,0); const Point_3 & B = vertex_on(t,1); const Point_3 & C = vertex_on(t,2); const Point_3 * a = &A; const Point_3 * b = &B; const Point_3 * c = &C; // Determine the orientation of the triangle in the common plane if (coplanar_orientation(A,B,C) != POSITIVE) { // The triangle is not counterclockwise oriented // swap two vertices. b = &C; c = &B; } // Test whether the ray's supporting line intersects the // triangle in the common plane const Orientation pqa = coplanar_orientation(p,q,*a); const Orientation pqb = coplanar_orientation(p,q,*b); const Orientation pqc = coplanar_orientation(p,q,*c); switch ( pqa ) { case POSITIVE: switch ( pqb ) { case POSITIVE: if (pqc == POSITIVE) // the triangle lies in the positive halfspace // defined by the ray's supporting line. return false; // c is isolated on the negative side return coplanar_orientation(*a,*c,p) != POSITIVE ; case NEGATIVE: if (pqc == POSITIVE) // b is isolated on the negative side return coplanar_orientation(*c,*b,p) != POSITIVE ; // a is isolated on the positive side return coplanar_orientation(*a,*c,p) != POSITIVE ; case COLLINEAR: if (pqc == POSITIVE) // b is isolated on the negative side return coplanar_orientation(*c,*b,p) != POSITIVE ; // a is isolated on the positive side return coplanar_orientation(*a,*c,p) != POSITIVE ; default: // should not happen. CGAL_kernel_assertion(false); return false; } case NEGATIVE: switch ( pqb ) { case POSITIVE: if (pqc == POSITIVE) // a is isolated on the negative side return coplanar_orientation(*b,*a,p) != POSITIVE ; // b is isolated on the positive side return coplanar_orientation(*b,*a,p) != POSITIVE ; case NEGATIVE: if (pqc == NEGATIVE) // the triangle lies in the negative halfspace // defined by the ray's supporting line. return false; // c is isolated on the positive side return coplanar_orientation(*c,*b,p) != POSITIVE ; case COLLINEAR: if (pqc == NEGATIVE) // b is isolated on the positive side return coplanar_orientation(*b,*a,p) != POSITIVE ; // a is isolated on the negative side return coplanar_orientation(*b,*a,p) != POSITIVE ; default: // should not happen. CGAL_kernel_assertion(false); return false; } case COLLINEAR: switch ( pqb ) { case POSITIVE: if (pqc == POSITIVE) // a is isolated on the negative side return coplanar_orientation(*b,*a,p) != POSITIVE ; // b is isolated on the positive side return coplanar_orientation(*b,*a,p) != POSITIVE ; case NEGATIVE: if (pqc == NEGATIVE) // a is isolated on the positive side return coplanar_orientation(*a,*c,p) != POSITIVE ; // b is isolated on the negative side return coplanar_orientation(*c,*b,p) != POSITIVE ; case COLLINEAR: if (pqc == POSITIVE) // c is isolated on the positive side return coplanar_orientation(*c,*b,p) != POSITIVE ; // c is isolated on the negative side return coplanar_orientation(*a,*c,p) != POSITIVE ; // case pqc == COLLINEAR is imposiible default: // should not happen. CGAL_kernel_assertion(false); return false; } default: // should not happen. CGAL_kernel_assertion(false); return false; } } template inline bool do_intersect_coplanar(const typename CGAL_WRAP(K)::Ray_3 &r, const typename CGAL_WRAP(K)::Triangle_3 &t, const K & k ) { return do_intersect_coplanar(t, r, k); } } // namespace CGALi template inline bool do_intersect(const Ray_3 &r, const Triangle_3 &t) { return typename K::Do_intersect_3()(t,r); } template inline bool do_intersect(const Triangle_3 &t, const Ray_3 &r) { return typename K::Do_intersect_3()(t,r); } /* template inline bool do_intersect(const Ray_3 &r, const Triangle_3 &t, const K & k ) { return CGALi::do_intersect(t,r,k); } */ template inline bool do_intersect_coplanar(const Triangle_3 &t, const Ray_3 &r) { return CGALi::do_intersect_coplanar(t,r,K()); } CGAL_END_NAMESPACE #endif //CGAL_TRIANGLE_3_RAY_3_DO_INTERSECT_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_base_with_info_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_bas0000644000175000017500000000436011344301501031372 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_face_base_with_info_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec,Sylvain Pion // face of a triangulation of any dimension <=3 #ifndef CGAL_TRIANGULATION_FACE_BASE_WITH_INFO_2_H #define CGAL_TRIANGULATION_FACE_BASE_WITH_INFO_2_H #include CGAL_BEGIN_NAMESPACE template < typename Info_, typename GT, typename Fb = Triangulation_face_base_2 > class Triangulation_face_base_with_info_2 : public Fb { Info_ _info; public: typedef typename Fb::Vertex_handle Vertex_handle; typedef typename Fb::Face_handle Face_handle; typedef Info_ Info; template < typename TDS2 > struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Fb2; typedef Triangulation_face_base_with_info_2 Other; }; Triangulation_face_base_with_info_2() : Fb() {} Triangulation_face_base_with_info_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Fb(v0, v1, v2) {} Triangulation_face_base_with_info_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2 ) : Fb(v0, v1, v2, n0, n1, n2) {} const Info& info() const { return _info; } Info& info() { return _info; } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_FACE_BASE_WITH_INFO_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Conic_misc.h0000644000175000017500000001073111344301500027241 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Conic_misc.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Bernd Gaertner, Sven Schoenherr #ifndef CGAL_CONIC_MISC_H #define CGAL_CONIC_MISC_H #include #include CGAL_BEGIN_NAMESPACE template < class R> class Conic_2; enum Conic_type { HYPERBOLA = -1, PARABOLA, ELLIPSE }; typedef CGAL::Bounded_side Convex_side; const Convex_side ON_CONVEX_SIDE = CGAL::ON_BOUNDED_SIDE; const Convex_side ON_NONCONVEX_SIDE = CGAL::ON_UNBOUNDED_SIDE; template < class NT > NT best_value (NT *values, int nr_values, NT a2, NT a1, NT a0, NT b3, NT b2, NT b1, NT b0) { bool det_positive = false; NT d, q, max_det = 0, det, best = -1; for (int i=0; i max_det)) { max_det = det; best = x; det_positive = true; } } CGAL_kernel_precondition (det_positive); return best; } template < class NT > int solve_cubic (NT c3, NT c2, NT c1, NT c0, NT& r1, NT& r2, NT& r3) { if (c3 == 0.0) { // quadratic equation if (c2 == 0) { // linear equation CGAL_kernel_precondition (c1 != 0); r1 = -c0/c1; return 1; } NT D = c1*c1-4*c2*c0; if (D < 0.0) // only complex roots return 0; if (D == 0.0) { // one real root r1 = -c1/(2.0*c2); return 1; } // two real roots r1 = (-c1 + CGAL_NTS sqrt(D))/(2.0*c2); r2 = (-c1 - CGAL_NTS sqrt(D))/(2.0*c2); return 2; } // cubic equation // define the gamma_i NT g2 = c2/c3, g1 = c1/c3, g0 = c0/c3; // define a, b NT a = g1 - g2*g2/3.0, b = 2.0*g2*g2*g2/27.0 - g1*g2/3.0 + g0; if (a == 0) { // one real root /***** r1 = cbrt(-b) - g2/3.0; *****/ r1 = exp(log(-b)/3.0) - g2/3.0; return 1; } // define D NT D = a*a*a/27.0 + b*b/4.0; if (D >= 0.0) { // real case /***** NT u = cbrt(-b/2.0 + CGAL_NTS sqrt(D)), *****/ NT u = exp(log(-b/2.0 + CGAL_NTS sqrt(D))), alpha = 1.0 - a/(3.0*u*u); if (D == 0) { // two distinct real roots r1 = u*alpha - g2/3.0; r2 = -0.5*alpha*u - g2/3.0; return 2; } // one real root r1 = u*alpha - g2/3.0; return 1; } // complex case NT r_prime = CGAL_NTS sqrt(-a/3), phi_prime = acos (-b/(2.0*r_prime*r_prime*r_prime))/3.0, u_R = r_prime * cos (phi_prime), u_I = r_prime * sin (phi_prime); // three distinct real roots r1 = 2.0*u_R - g2/3.0; r2 = -u_R + u_I*std::sqrt(3.0) - g2/3.0; r3 = -u_R - u_I*std::sqrt(3.0) - g2/3.0; return 3; } CGAL_END_NAMESPACE #endif // CGAL_CONIC_MISC_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000016353411344301500031457 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Frederic Fichel, Mariette Yvinec, Julia Floetotto #ifndef CGAL_REGULAR_TRIANGULATION_2_H #define CGAL_REGULAR_TRIANGULATION_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < typename K_ > struct Weighted_point_mapper_2 : public K_ { typedef typename K_::Weighted_point_2 Point_2; Weighted_point_mapper_2() {} Weighted_point_mapper_2(const K_& k) : K_(k) {} }; template < class Gt, class Tds = Triangulation_data_structure_2 < Regular_triangulation_vertex_base_2, Regular_triangulation_face_base_2 > > class Regular_triangulation_2 : public Triangulation_2,Tds> { typedef Regular_triangulation_2 Self; typedef Triangulation_2,Tds> Base; public: typedef Tds Triangulation_data_structure; typedef Gt Geom_traits; typedef typename Gt::Point_2 Bare_point; typedef typename Gt::Weighted_point_2 Weighted_point; typedef typename Gt::Weight Weight; typedef typename Base::size_type size_type; typedef typename Base::Face_handle Face_handle; typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Vertex Vertex; typedef typename Base::Edge Edge; typedef typename Base::Locate_type Locate_type; typedef typename Base::Face_circulator Face_circulator; typedef typename Base::Edge_circulator Edge_circulator; typedef typename Base::Vertex_circulator Vertex_circulator; typedef typename Base::Finite_edges_iterator Finite_edges_iterator; typedef typename Base::All_edges_iterator All_edges_iterator; typedef typename Base::Finite_faces_iterator Finite_faces_iterator; typedef typename Base::All_faces_iterator All_faces_iterator; typedef typename Base::Face::Vertex_list Vertex_list; typedef typename Vertex_list::iterator Vertex_list_iterator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Base::cw; using Base::ccw; using Base::dimension; using Base::geom_traits; using Base::infinite_vertex; using Base::create_face; using Base::number_of_faces; using Base::all_faces_begin; using Base::all_faces_end; using Base::all_edges_begin; using Base::all_edges_end; using Base::finite_faces_begin; using Base::finite_faces_end; using Base::finite_edges_begin; using Base::finite_edges_end; using Base::OUTSIDE_AFFINE_HULL; using Base::VERTEX; using Base::FACE; using Base::EDGE; using Base::OUTSIDE_CONVEX_HULL; #endif private: typedef std::list Faces_around_stack; class Hidden_tester { public: bool operator()(const typename Base::All_vertices_iterator& it){ return it->is_hidden(); } bool operator()(const typename Base::Finite_vertices_iterator& it){ return it->is_hidden(); } }; class Unhidden_tester { public: bool operator()(const typename Base::Finite_vertices_iterator& it){ return ! it->is_hidden(); } }; typedef typename Base::All_vertices_iterator All_vib; typedef typename Base::Finite_vertices_iterator Finite_vib; public: // We derive in order to add a conversion to handle. class All_vertices_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef All_vertices_iterator Self; public: All_vertices_iterator() : Base() {} All_vertices_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator Vertex_handle() const { return Base::base(); } }; class Finite_vertices_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef Finite_vertices_iterator Self; public: Finite_vertices_iterator() : Base() {} Finite_vertices_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator Vertex_handle() const { return Base::base(); } }; class Hidden_vertices_iterator : public Filter_iterator { typedef Filter_iterator Base; typedef Hidden_vertices_iterator Self; public: Hidden_vertices_iterator() : Base() {} Hidden_vertices_iterator(const Base &b) : Base(b) {} Self & operator++() { Base::operator++(); return *this; } Self & operator--() { Base::operator--(); return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } operator Vertex_handle() const { return Base::base(); } }; //for backward compatibility typedef Finite_faces_iterator Face_iterator; typedef Finite_edges_iterator Edge_iterator; typedef Finite_vertices_iterator Vertex_iterator; //Tag to distinguish Delaunay from Regular triangulations typedef Tag_true Weighted_tag; private: size_type _hidden_vertices; public: Regular_triangulation_2(const Gt& gt=Gt()) : Base(Weighted_point_mapper_2(gt)), _hidden_vertices(0) {} Regular_triangulation_2(const Regular_triangulation_2 &rt); Regular_triangulation_2 & operator=(const Regular_triangulation_2 &tr); size_type number_of_vertices() const { return Base::number_of_vertices() - _hidden_vertices; } size_type number_of_hidden_vertices() const { return _hidden_vertices; } // CHECK - QUERY Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s) const; Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r) const; Oriented_side power_test(const Weighted_point &p, const Weighted_point &r) const; Oriented_side power_test(const Face_handle &f, const Weighted_point &p) const; Oriented_side power_test(const Face_handle& f, int i, const Weighted_point &p) const; bool is_valid(bool verbose = false, int level = 0) const; bool test_conflict(const Weighted_point &p, Face_handle fh) const; void show_face(Face_handle fh) const; void show_all() const; // //template member functions, declared and defined at the end // template // Triple // get_conflicts_and_boundary_and_hidden_vertices (const // Weighted_point &p, // OutputItFaces fit, // OutputItBoundaryEdges eit, // OutputItHiddenVertices vit, // Face_handle start = // Face_handle()) const; // template // std::pair // get_conflicts_and_boundary(const Weighted_point &p, // OutputItFaces fit, // OutputItBoundaryEdges eit, // Face_handle start) const; // template // OutputItFaces // get_conflicts (const Weighted_point &p, // OutputItFaces fit, // Face_handle start ) const; // template // OutputItBoundaryEdges // get_boundary_of_conflicts(const Weighted_point &p, // OutputItBoundaryEdges eit, // Face_handle start ) const; // template // std::pair // get_boundary_of_conflicts_and_hidden_vertices(const Weighted_point &p, // OutputItBoundaryEdges eit, // OutputItHiddenVertices vit, // Face_handle start= // Face_handle()) const; // template // OutputItHiddenVertices // get_hidden_vertices(const Weighted_point &p, // OutputItHiddenVertices vit, // Face_handle start= // Face_handle()) const; // DUAL Bare_point dual (Face_handle f) const; Object dual(const Edge &e) const ; Object dual(const Edge_circulator& ec) const; Object dual(const Finite_edges_iterator& ei) const; Bare_point weighted_circumcenter(Face_handle f) const; Bare_point weighted_circumcenter(const Weighted_point& p0, const Weighted_point& p1, const Weighted_point& p2) const; // Insertion, Deletion and Flip Vertex_handle push_back(const Weighted_point &p); Vertex_handle insert(const Weighted_point &p, Face_handle f = Face_handle() ); Vertex_handle insert(const Weighted_point &p, Locate_type lt, Face_handle loc, int li ); Vertex_handle insert_in_face(const Weighted_point &p, Face_handle f); Vertex_handle insert_in_edge(const Weighted_point &p, Face_handle f, int i); void flip(Face_handle f, int i); void remove_degree_3(Vertex_handle v, Face_handle f = Face_handle()); void remove(Vertex_handle v); All_vertices_iterator all_vertices_begin () const; All_vertices_iterator all_vertices_end () const; Finite_vertices_iterator finite_vertices_begin () const; Finite_vertices_iterator finite_vertices_end () const; Hidden_vertices_iterator hidden_vertices_begin () const; Hidden_vertices_iterator hidden_vertices_end () const; // Vertex_handle file_input(std::istream& is); // void file_output(std::ostream& os) const; public: void clear(); void copy_triangulation(const Self& tr); private: Vertex_handle reinsert(Vertex_handle v, Face_handle start); void regularize(Vertex_handle v); void remove_hidden(Vertex_handle v); void remove_2D(Vertex_handle v); void fill_hole_regular(std::list & hole); void set_face(Vertex_list& vl, const Face_handle& fh); void update_hidden_points_3_1(const Face_handle& f1, const Face_handle& f2, const Face_handle& f3); void update_hidden_points_2_2(const Face_handle& f1, const Face_handle& f2); void update_hidden_points_1_3(const Face_handle& f1, const Face_handle& f2, const Face_handle& f3); Vertex_handle hide_new_vertex(Face_handle f, const Weighted_point& p); void hide_remove_degree_3(Face_handle fh, Vertex_handle vh); void hide_vertex(Face_handle f, Vertex_handle v); void exchange_incidences(Vertex_handle va, Vertex_handle vb); void exchange_hidden(Vertex_handle va, Vertex_handle vb); void stack_flip(Vertex_handle v, Faces_around_stack &faces_around); void stack_flip_4_2(Face_handle f, int i, int j, Faces_around_stack &faces_around); void stack_flip_3_1(Face_handle f, int i, int j, Faces_around_stack &faces_around); void stack_flip_2_2(Face_handle f, int i, Faces_around_stack &faces_around); void stack_flip_dim1(Face_handle f, int i, Faces_around_stack &faces_around); bool is_valid_face(Face_handle fh) const; bool is_valid_vertex(Vertex_handle fh) const; public: template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = number_of_vertices(); while(first != last) { insert(*first); ++first; } return number_of_vertices() - n; } template < class Stream> Stream& draw_dual(Stream & ps) const { Finite_edges_iterator eit = finite_edges_begin(); for (; eit != finite_edges_end(); ++eit) { Object o = dual(eit); typename Geom_traits::Line_2 l; typename Geom_traits::Ray_2 r; typename Geom_traits::Segment_2 s; if (CGAL::assign(s,o)) ps << s; if (CGAL::assign(r,o)) ps << r; if (CGAL::assign(l,o)) ps << l; } return ps; } template Triple get_conflicts_and_boundary_and_hidden_vertices(const Weighted_point &p, OutputItFaces fit, OutputItBoundaryEdges eit, OutputItHiddenVertices vit, Face_handle start = Face_handle()) const { CGAL_triangulation_precondition( dimension() == 2); int li; Locate_type lt; Face_handle fh = locate(p,lt,li, start); switch(lt) { case OUTSIDE_AFFINE_HULL: return make_triple(fit, eit, vit); case VERTEX: case FACE: case EDGE: case OUTSIDE_CONVEX_HULL: //test whether p is not in conflict // with the first face: // this includes the cases that p is located // on a vertex and either equal or no conflict if (!test_conflict(p,fh)) return make_triple(fit, eit, vit); // region includes all faces in conflict so far detected // stack includes the faces in the region whose neighbors // have not yet been looked at std::set region; std::stack st; //collection of all boundary_vertices: std::set< Vertex_handle> boundary_vertices; //collection of potential_intern_vertices = vertices incident // to an edge incident to two faces in conflict and met // twice during the "walk": std::set< Vertex_handle> potential_intern_vertices; *fit++ = fh; //put fh in OutputItFaces region.insert(fh); st.push(Edge(fh,2)); st.push(Edge(fh,1)); st.push(Edge(fh,0)); while (! st.empty()){ Edge e = st.top(); st.pop(); Face_handle fh = e.first; Face_handle fn = fh->neighbor(e.second); int i = fn->index(fh); if( region.find(fn) == region.end() ){ if (test_conflict(p,fn)) { region.insert(fn); st.push(Edge(fn, cw(i))); st.push(Edge(fn,ccw(i))); *fit++ = fn; } else{ e = Edge(fn,i); *eit++ = e; if(!is_infinite(fn->vertex(cw(i)))) boundary_vertices.insert(fn->vertex(cw(i))); if(!is_infinite(fn->vertex(ccw(i)))) boundary_vertices.insert(fn->vertex(ccw(i))); } } else { //insert the vertices of the last edge into the set of // potential intern vertices: potential_intern_vertices.insert(fn->vertex(ccw(i))); potential_intern_vertices.insert(fn->vertex(cw(i))); } } if(!potential_intern_vertices.empty()){ //determine the hidden vertices: std::set_difference (potential_intern_vertices.begin(), potential_intern_vertices.end(), boundary_vertices.begin(), boundary_vertices.end(), vit); } return make_triple(fit, eit, vit); } CGAL_triangulation_assertion(false); return make_triple(fit, eit, vit); } template std::pair get_conflicts_and_boundary (const Weighted_point &p, OutputItFaces fit, OutputItBoundaryEdges eit, Face_handle start = Face_handle()) const { Triple pp = get_conflicts_and_boundary_and_hidden_vertices(p, fit, eit, Emptyset_iterator(), start); return std::make_pair(pp.first, pp.second); } template std::pair get_conflicts_and_hidden_vertices(const Weighted_point &p, OutputItFaces fit, OutputItHiddenVertices vit, Face_handle start = Face_handle()) const { Triple pp = get_conflicts_and_boundary_and_hidden_vertices(p,fit, Emptyset_iterator(), vit, start); return std::make_pair(pp.first,pp.third); } template std::pair get_boundary_of_conflicts_and_hidden_vertices(const Weighted_point &p, OutputItBoundaryEdges eit, OutputItHiddenVertices vit, Face_handle start = Face_handle()) const { Triple pp = get_conflicts_and_boundary_and_hidden_vertices(p, Emptyset_iterator(), eit,vit, start); return std::make_pair(pp.second,pp.third); } template OutputItFaces get_conflicts (const Weighted_point &p, OutputItFaces fit, Face_handle start= Face_handle()) const { Triple pp = get_conflicts_and_boundary_and_hidden_vertices(p, fit, Emptyset_iterator(), Emptyset_iterator(), start); return pp.first; } template OutputItBoundaryEdges get_boundary_of_conflicts(const Weighted_point &p, OutputItBoundaryEdges eit, Face_handle start= Face_handle()) const { Triple pp = get_conflicts_and_boundary_and_hidden_vertices(p, Emptyset_iterator(), eit, Emptyset_iterator(), start); return pp.second; } template OutputItHiddenVertices get_hidden_vertices(const Weighted_point &p, OutputItHiddenVertices vit, Face_handle start= Face_handle()) const { Triple pp = get_conflicts_and_boundary_and_hidden_vertices(p,Emptyset_iterator(), Emptyset_iterator(),vit, start); return pp.third; } }; template < class Gt, class Tds > inline bool Regular_triangulation_2:: test_conflict(const Weighted_point &p, Face_handle fh) const { return(power_test(fh,p) == ON_POSITIVE_SIDE); } template < class Gt, class Tds > void Regular_triangulation_2:: clear() { Base::clear(); _hidden_vertices = 0; } template < class Gt, class Tds > void Regular_triangulation_2:: copy_triangulation(const Self &tr ) { Base::copy_triangulation(tr); _hidden_vertices = tr._hidden_vertices; // the list of vertices have been copied member for member and are // not good // clear them and next // scan the hidden vertices to retablish the list in faces typename Tds::Face_iterator baseit= this->_tds.face_iterator_base_begin(); for( ; baseit != this->_tds.face_iterator_base_end(); baseit++){ baseit->vertex_list().clear(); } Hidden_vertices_iterator hvit = hidden_vertices_begin(); for( ; hvit != hidden_vertices_end() ; ++hvit){ hvit->face()->vertex_list().push_back(hvit); } CGAL_triangulation_postcondition(is_valid()); return; } template < class Gt, class Tds > Regular_triangulation_2:: Regular_triangulation_2(const Self &tr) { copy_triangulation(tr); } template Regular_triangulation_2 & Regular_triangulation_2:: operator=(const Self &tr) { copy_triangulation(tr); return *this; } template < class Gt, class Tds > Oriented_side Regular_triangulation_2:: power_test(const Face_handle &f, const Weighted_point &p) const { // p is supposed to be a finite point // if f is a finite face, // return ON_NEGATIVE_SIDE if p is above f // (p has to be hidden) if (dimension() == 1) return power_test(f->vertex(0)->point(), f->vertex(1)->point(),p); int i; if ( ! f->has_vertex(infinite_vertex(), i) ) return power_test(f->vertex(0)->point(), f->vertex(1)->point(), f->vertex(2)->point(),p); Orientation o = orientation(f->vertex(ccw(i))->point(), f->vertex( cw(i))->point(), p); if (o==COLLINEAR) return power_test(f->vertex(ccw(i))->point(), f->vertex( cw(i))->point(),p); return Oriented_side(o); } template < class Gt, class Tds > Oriented_side Regular_triangulation_2:: power_test(const Face_handle& f, int i, const Weighted_point &p) const { // f,i is supposed to be a finite edge // p is supposed to be on edge (f,i) // return ON_NEGATIVE_SIDE if p is above (f,i) // (p has to be hidden) CGAL_triangulation_precondition (!is_infinite(f,i) && orientation(f->vertex(ccw(i))->point(), f->vertex( cw(i))->point(), p) == COLLINEAR); return power_test(f->vertex(ccw(i))->point(), f->vertex( cw(i))->point(), p); } template < class Gt, class Tds > inline Oriented_side Regular_triangulation_2:: power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &s) const { return geom_traits().power_test_2_object()(p,q,r,s); } template < class Gt, class Tds > inline Oriented_side Regular_triangulation_2:: power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r) const { return geom_traits().power_test_2_object()(p,q,r); } template < class Gt, class Tds > inline Oriented_side Regular_triangulation_2:: power_test(const Weighted_point &p, const Weighted_point &r) const { return geom_traits().power_test_2_object()(p,r); } template < class Gt, class Tds > bool Regular_triangulation_2:: is_valid_face(Face_handle fh) const { bool result = true; if(is_infinite(fh)) result = result && fh->vertex_list().empty(); if (!result) { show_face(fh);} CGAL_triangulation_assertion(result); typename Vertex_list::iterator vlit = fh->vertex_list().begin(), vldone = fh->vertex_list().end(); for (; vlit != vldone; vlit++) { result = result && power_test(fh, (*vlit)->point()) == ON_NEGATIVE_SIDE; result = result && ((*vlit)->face() == fh); if (!result) show_face(fh); CGAL_triangulation_assertion(result); } return result; } template < class Gt, class Tds > bool Regular_triangulation_2:: is_valid_vertex(Vertex_handle vh) const { bool result = true; if (vh->is_hidden()) { Locate_type lt; int li; result = result && (!is_infinite(vh->face())); Face_handle loc = locate(vh->point(), lt, li, vh->face()); result = result && (loc == vh->face() || (lt == Base::VERTEX && vh->face()->has_vertex(loc->vertex(li))) || (lt == Base::EDGE && vh->face() == loc->neighbor(li)) ); CGAL_triangulation_assertion(result); result = result && power_test(vh->face(),vh->point()) == ON_NEGATIVE_SIDE; // if ( !result) { // std::cerr << " from is_valid_vertex " << std::endl; // std::cerr << "sommet cache " << &*(vh) // << "vh_point " <point() << " " << std::endl; // std::cerr << "vh_>face " << &*(vh->face()) << " " << std::endl; // std::cerr << "loc " << &*(loc ) // << " lt " << lt << " li " << li << std::endl; // show_face(vh->face()); // show_face(loc); // } } else { // normal vertex result = result && vh->face()->has_vertex(vh); // if ( !result) { // std::cerr << " from is_valid_vertex " << std::endl; // std::cerr << "normal vertex " << &(*vh) << std::endl; // std::cerr << vh->point() << " " << std::endl; // std::cerr << "vh_>face " << &*(vh->face()) << " " << std::endl; // show_face(vh->face()); // } } CGAL_triangulation_assertion(result); return result; } template < class Gt, class Tds > bool Regular_triangulation_2:: is_valid(bool verbose, int level) const { // cannot call for is_valid() of Base Triangulation class // because 1) number of vertices of base class does not match // tds.is_valid calls is_valid for each vertex // and the test is not fullfilled by hidden vertices ... // result = result && Triangulation_2::is_valid(verbose, level); bool result = true; for(All_faces_iterator fit = all_faces_begin(); fit != all_faces_end(); ++fit) { result = result && is_valid_face(fit); } for(All_vertices_iterator vit = all_vertices_begin(); vit != all_vertices_end(); ++vit) { result = result && is_valid_vertex(vit); } for(Hidden_vertices_iterator hvit = hidden_vertices_begin(); hvit != hidden_vertices_end(); ++hvit) { result = result && is_valid_vertex(hvit); } switch(dimension()) { case 0 : break; case 1: if (number_of_vertices() > 2 ) { Finite_vertices_iterator it1 = finite_vertices_begin(), it2(it1), it3(it1); ++it2; ++it3; ++it3; while( it3 != finite_vertices_end()) { Orientation s = orientation(it1->point(), it2->point(), it3->point()); result = result && s == COLLINEAR ; CGAL_triangulation_assertion(result); ++it1 ; ++it2; ++it3; } } break; case 2 : for(Finite_faces_iterator it=finite_faces_begin(); it!=finite_faces_end(); it++) { CGAL_triangulation_assertion( ! is_infinite(it)); Orientation s = orientation(it->vertex(0)->point(), it->vertex(1)->point(), it->vertex(2)->point()); CGAL_triangulation_assertion( s == LEFT_TURN ); result = result && ( s == LEFT_TURN ); for (int i = 0 ; i < 3 ; i++) { if (!is_infinite(it->vertex(i))) result = result && ON_POSITIVE_SIDE != power_test(it->neighbor(i), it->vertex(i)->point()); CGAL_triangulation_assertion(result); } } Vertex_circulator start = infinite_vertex()->incident_vertices(); Vertex_circulator pc(start); Vertex_circulator qc(start); ++qc; Vertex_circulator rc(start); ++rc; ++rc; do{ Orientation s = orientation(pc->point(), qc->point(), rc->point()); CGAL_triangulation_assertion( s != LEFT_TURN ); result = result && ( s != LEFT_TURN ); ++pc ; ++qc ; ++rc; } while(pc != start); // check number of faces. This cannot be done by the Tds // which does not know the number of components nor the genus result = result && (number_of_faces() == 2*(number_of_vertices()+1) - 4 - infinite_vertex()->degree()); CGAL_triangulation_assertion( result); break; } // in any dimension if(verbose) { std::cerr << " nombres de sommets " << number_of_vertices() << "\t" << "nombres de sommets caches " << number_of_hidden_vertices() << std::endl; } result = result && ( Base::number_of_vertices() == number_of_vertices() + number_of_hidden_vertices()); CGAL_triangulation_assertion( result); return result; } template void Regular_triangulation_2:: show_face(Face_handle fh) const { Base::show_face(fh); typename Vertex_list::iterator current; std::cerr << " +++++>>> "; for (current= fh->vertex_list().begin(); current!= fh->vertex_list().end() ; current++ ) { std::cerr <<"[ "<< ((*current)->point()) << " ] , "; } std::cerr < void Regular_triangulation_2:: show_all() const { std::cerr<< "AFFICHE TOUTE LA TRIANGULATION :" << std::endl; std::cerr << std::endl<<"====> "<< this ; std::cerr << " dimension " << dimension() << std::endl; std::cerr << "nb of vertices " << number_of_vertices() << " nb of hidden vertices " << number_of_hidden_vertices() << std::endl; if (dimension() < 1) return; if(dimension() == 1) { std::cerr<<" all edges "<first); } } else{ //dimension ==2 std::cerr<<" faces finies "<1) { std::cerr << "affichage des sommets de la triangulation reguliere" <face()) << std::endl; } std::cerr<face()) << std::endl; } return; } //DUALITY template < class Gt, class Tds > inline typename Regular_triangulation_2::Bare_point Regular_triangulation_2:: dual (Face_handle f) const { return weighted_circumcenter(f); } template < class Gt, class Tds > inline typename Regular_triangulation_2::Bare_point Regular_triangulation_2:: weighted_circumcenter(Face_handle f) const { CGAL_triangulation_precondition (dimension()==2 || !is_infinite(f)); return weighted_circumcenter(f->vertex(0)->point(), f->vertex(1)->point(), f->vertex(2)->point()); } template inline typename Regular_triangulation_2::Bare_point Regular_triangulation_2:: weighted_circumcenter(const Weighted_point& p0, const Weighted_point& p1, const Weighted_point& p2) const { return geom_traits().construct_weighted_circumcenter_2_object()(p0,p1,p2); } template < class Gt, class Tds > inline Object Regular_triangulation_2:: dual(const Edge &e) const { typedef typename Geom_traits::Line_2 Line; typedef typename Geom_traits::Ray_2 Ray; typedef typename Geom_traits::Segment_2 Segment; CGAL_triangulation_precondition (! is_infinite(e)); if( dimension()== 1 ){ const Weighted_point& p = (e.first)->vertex(cw(e.second))->point(); const Weighted_point& q = (e.first)->vertex(ccw(e.second))->point(); Line l = geom_traits().construct_radical_axis_2_object()(p,q); return make_object(l); } // dimension==2 if( (! is_infinite(e.first)) && (! is_infinite(e.first->neighbor(e.second))) ) { Segment s = geom_traits().construct_segment_2_object() (dual(e.first),dual(e.first->neighbor(e.second))); return make_object(s); } // one of the adjacent face is infinite Face_handle f; int i; if ( is_infinite(e.first)) { f=e.first->neighbor(e.second); f->has_neighbor(e.first,i); } else { f=e.first; i=e.second; } const Weighted_point& p = f->vertex( cw(i))->point(); const Weighted_point& q = f->vertex( ccw(i))->point(); Line l = geom_traits().construct_radical_axis_2_object()(p,q); Ray r = geom_traits().construct_ray_2_object()(dual(f), l); return make_object(r); } template < class Gt, class Tds > inline Object Regular_triangulation_2:: dual(const Edge_circulator& ec) const { return dual(*ec); } template < class Gt, class Tds > inline Object Regular_triangulation_2:: dual(const Finite_edges_iterator& ei) const { return dual(*ei); } //INSERTION-REMOVAL template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: push_back(const Weighted_point &p) { return insert(p); } template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: insert(const Weighted_point &p, Face_handle start) { Locate_type lt; int li; Face_handle loc = locate(p, lt, li, start); return insert(p, lt, loc, li); } template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: insert(const Weighted_point &p, Locate_type lt, Face_handle loc, int li) { if (number_of_vertices() <= 1) return Base::insert(p); Vertex_handle v; Oriented_side os; Vertex_handle vv; // helping vertex in case VERTEX switch (lt) { case Base::VERTEX: vv = loc->vertex(li); if (power_test(loc->vertex(li)->point(), p) != ON_POSITIVE_SIDE) return hide_new_vertex(loc,p); v = this->_tds.create_vertex(); v->set_point(p); exchange_incidences(v,loc->vertex(li)); hide_vertex(loc, vv); break; case Base::EDGE: os = dimension() == 1 ? power_test(loc,li,p) : power_test(loc,p); if (os == ON_NEGATIVE_SIDE) { //hide preferably in finite face if (is_infinite(loc)) loc = loc->neighbor(li); return hide_new_vertex(loc,p); } v = insert_in_edge(p,loc,li); break; case Base::FACE: if (power_test(loc,p) == ON_NEGATIVE_SIDE) return hide_new_vertex(loc,p); v = insert_in_face(p,loc); break; case Base::OUTSIDE_CONVEX_HULL: v = insert_outside_convex_hull(p,loc); break; case Base::OUTSIDE_AFFINE_HULL: v = insert_outside_affine_hull(p); //clear vertex list of infinite faces which have been copied for ( All_faces_iterator afi = all_faces_begin(); afi != all_faces_end(); afi++) { if(is_infinite(afi)) afi->vertex_list().clear(); } break; default: CGAL_triangulation_assertion_msg(false, "locate step failed"); } regularize(v); return v; } /* The reinsert function insert a weighted point which was in a hidden vertex. The new and old vertices are then exchanged ; this is required if the regular triangulation is used with a hierarchy because the old vertex has its up and down pointers set and other vertices pointing on him */ template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: reinsert(Vertex_handle v, Face_handle start) { CGAL_triangulation_assertion(v->is_hidden()); v->set_hidden(false); _hidden_vertices--; // //to debug // std::cerr << "from reinsert " << std::endl; // show_vertex(v); // Locate_type lt; // int li; // Face_handle loc = locate(v->point(), lt, li, start); // std::cerr << "locate " << &(*loc) << "\t" << lt << "\t" << li << // std::endl; // show_face(loc); // std::cerr << std::endl; Vertex_handle vh = insert(v->point(), start); if(vh->is_hidden()) exchange_hidden(v,vh); else exchange_incidences(v,vh); this->_tds.delete_vertex(vh); return v; } //push va instead of vb in the list of the face fb hiding vb // vb must be the last inserted vertex in the list of fb template < class Gt, class Tds > void Regular_triangulation_2:: exchange_hidden(Vertex_handle va, Vertex_handle vb) { CGAL_triangulation_assertion (vb->is_hidden()); CGAL_triangulation_assertion (vb == vb->face()->vertex_list().back()); // //to debug // std::cerr << "from exchange hidden 1" << std::endl; // show_vertex(vb); // std::cerr << " / face associee : " // << &*(vb->face()) << std::endl; vb->face()->vertex_list().pop_back(); _hidden_vertices--; hide_vertex(vb->face(), va); // //to debug // std::cerr << "from exchange hidden 1" << std::endl; // show_vertex(va); // std::cerr << " / face associee : " // << &*(va->face()) << std::endl << std::endl; } // set to va the incidences of vb template < class Gt, class Tds > void Regular_triangulation_2:: exchange_incidences(Vertex_handle va, Vertex_handle vb) { CGAL_triangulation_assertion ( !vb->is_hidden()); std::list faces; if (dimension() == 1) { faces.push_back(vb->face()); int i = vb->face()->index(vb); faces.push_back(vb->face()->neighbor(1-i)); } else { CGAL_triangulation_assertion (dimension() == 2); Face_circulator fc = vb->incident_faces(), done(fc); do { faces.push_back(fc); fc++; }while(fc != done); } va->set_face(*(faces.begin())); for(typename std::list::iterator it = faces.begin(); it != faces.end(); it++){ Face_handle fh = *it; fh->set_vertex(fh->index(vb), va); } return; } template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: insert_in_face(const Weighted_point &p, Face_handle f) { Vertex_handle v = Base::insert_in_face(p,f); update_hidden_points_1_3(f, f->neighbor(ccw(f->index(v))), f->neighbor( cw(f->index(v))) ); return v; } template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: insert_in_edge(const Weighted_point &p, Face_handle f, int i) { Vertex_handle v; if (dimension() == 1) { v = Base::insert_in_edge(p,f,i); Face_handle g = f->neighbor(1 - f->index(v)); update_hidden_points_2_2(f,g); } else { //dimension()==2 // don't use update_hidden_points_2_2 any more to split // hidden vertices list because new affectation of f and n // around new vertex is unknown Face_handle n = f->neighbor(i); Vertex_list p_list; p_list.splice(p_list.begin(),f->vertex_list()); p_list.splice(p_list.begin(),n->vertex_list()); v = Base::insert_in_edge(p,f,i); Face_handle loc; while ( ! p_list.empty() ){ loc = locate(p_list.front()->point(), n); if (is_infinite(loc)) loc = loc->neighbor(loc->index(infinite_vertex())); hide_vertex(loc, p_list.front()); p_list.pop_front(); } } return v; } template < class Gt, class Tds > void Regular_triangulation_2:: regularize(Vertex_handle v) { CGAL_triangulation_precondition( v != infinite_vertex()); Faces_around_stack faces_around; //initialise faces_around if (dimension() == 1) { faces_around.push_back(v->face()); faces_around.push_back(v->face()->neighbor(1- v->face()->index(v))); } else{ //dimension==2 Face_circulator fit = v->incident_faces(), done(fit); do { faces_around.push_back(fit++); } while(fit != done); } while( ! faces_around.empty() ) stack_flip(v, faces_around); return; } template < class Gt, class Tds > void Regular_triangulation_2:: flip(Face_handle f, int i) { Face_handle n = f->neighbor(i); Base::flip(f,i); update_hidden_points_2_2(f,n); } template < class Gt, class Tds > void Regular_triangulation_2:: remove_degree_3(Vertex_handle v, Face_handle f) { if (f == Face_handle()) f=v->face(); update_hidden_points_3_1(f, f->neighbor( cw(f->index(v))), f->neighbor(ccw(f->index(v)))); Base::remove_degree_3(v,f); if (is_infinite(f)) { //the list of f is given to its finite neighbor Face_handle fn = f->neighbor(f->index(infinite_vertex())); set_face(f->vertex_list(),fn); fn->vertex_list().splice(fn->vertex_list().begin(),f->vertex_list()); } } template < class Gt, class Tds > void Regular_triangulation_2:: remove_hidden(Vertex_handle v ) { _hidden_vertices--; v->face()->vertex_list().remove(v); delete_vertex(v); return; } template < class Gt, class Tds > void Regular_triangulation_2:: remove(Vertex_handle v ) { CGAL_triangulation_precondition( v != Vertex_handle() ); CGAL_triangulation_precondition(!is_infinite(v)); if (v->is_hidden()) { remove_hidden(v); return; } // remove the hidden vertices before removing the before last vertex if(number_of_vertices() == 2 ) { Hidden_vertices_iterator hit = hidden_vertices_begin(); for( ; hit != hidden_vertices_end(); hit = hidden_vertices_begin()) remove_hidden(hit); } // As we want to reinsert close to where the point we remove // is we take a neighbor face Face_handle neighboring = v->face()->neighbor(v->face()->index(v)); // Collect in p_list // the points hidden by the face to be deleted Vertex_list p_list; if (dimension() == 1) { Face_handle f = v->face(); Face_handle n = f->neighbor(1 - f->index(v)); p_list.splice(p_list.begin(), f->vertex_list()); p_list.splice(p_list.begin(), n->vertex_list()); } else if (dimension() == 2 ) { Face_circulator fc = v->incident_faces(),done(fc); do { p_list.splice(p_list.begin(), fc->vertex_list()); fc++; } while( fc != done); } if (dimension() <= 1) { Base::remove(v); neighboring = infinite_vertex()->face(); } else { remove_2D(v); } while (! p_list.empty()) { Vertex_handle v(p_list.front()); p_list.pop_front(); if (is_infinite(neighboring)) { neighboring=neighboring->neighbor(neighboring->index(infinite_vertex())); } reinsert(v, neighboring); neighboring = v->face(); } } template < class Gt, class Tds > void Regular_triangulation_2:: remove_2D(Vertex_handle v) { if (test_dim_down(v)) { this->_tds.remove_dim_down(v); } else { std::list hole; make_hole(v, hole); fill_hole_regular(hole); delete_vertex(v); } return; } template < class Gt, class Tds > void Regular_triangulation_2:: fill_hole_regular(std::list & first_hole) { typedef std::list Hole; typedef std::list Hole_list; Hole hole; Hole_list hole_list; Face_handle ff, fn; int i, ii, in; hole_list.push_front(first_hole); while (! hole_list.empty()) { hole = hole_list.front(); hole_list.pop_front(); typename Hole::iterator hit = hole.begin(); // if the hole has only three edges, create the triangle if (hole.size() == 3) { Face_handle newf = create_face(); hit = hole.begin(); for(int j=0; j<3; j++) { ff = (*hit).first; ii = (*hit).second; hit++; ff->set_neighbor(ii,newf); newf->set_neighbor(j,ff); newf->set_vertex(newf->ccw(j),ff->vertex(ff->cw(ii))); } continue; } // else find an edge with two finite vertices // on the hole boundary // and the new triangle adjacent to that edge // cut the hole and push it back // first, ensure that a neighboring face // whose vertices on the hole boundary are finite // is the first of the hole bool finite = false; while (!finite) { ff = hole.front().first; ii = hole.front().second; if ( is_infinite(ff->vertex(cw(ii))) || is_infinite(ff->vertex(ccw(ii)))) { hole.push_back(hole.front()); hole.pop_front(); } else finite = true; } // take the first neighboring face and pop it; ff = hole.front().first; ii = hole.front().second; hole.pop_front(); Vertex_handle v0 = ff->vertex(ff->cw(ii)); const Weighted_point& p0 = v0->point(); Vertex_handle v1 = ff->vertex(ff->ccw(ii)); const Weighted_point& p1 = v1->point(); Vertex_handle v2 = infinite_vertex(); Weighted_point p2; Vertex_handle vv; Weighted_point p; typename Hole::iterator hdone = hole.end(); hit = hole.begin(); typename Hole::iterator cut_after(hit); // if tested vertex is c with respect to the vertex opposite // to NULL neighbor, // stop at the before last face; hdone--; while (hit != hdone) { fn = (*hit).first; in = (*hit).second; vv = fn->vertex(ccw(in)); if (is_infinite(vv)) { if (is_infinite(v2)) cut_after = hit; } else { // vv is a finite vertex p = vv->point(); if (orientation(p0,p1,p) == COUNTERCLOCKWISE) { if (is_infinite(v2)) { v2=vv; p2=p; cut_after=hit; } else if (power_test(p0,p1,p2,p) == ON_POSITIVE_SIDE) { v2=vv; p2=p; cut_after=hit; } } } ++hit; } // create new triangle and update adjacency relations Face_handle newf = create_face(v0,v1,v2); newf->set_neighbor(2,ff); ff->set_neighbor(ii, newf); //update the hole and push back in the Hole_List stack // if v2 belongs to the neighbor following or preceding *f // the hole remain a single hole // otherwise it is split in two holes fn = hole.front().first; in = hole.front().second; if (fn->has_vertex(v2, i) && i == (int)fn->ccw(in)) { newf->set_neighbor(0,fn); fn->set_neighbor(in,newf); hole.pop_front(); hole.push_front(Edge(newf,1)); hole_list.push_front(hole); } else { fn = hole.back().first; in = hole.back().second; if (fn->has_vertex(v2, i) && i == (int)fn->cw(in)) { newf->set_neighbor(1,fn); fn->set_neighbor(in,newf); hole.pop_back(); hole.push_back(Edge(newf,0)); hole_list.push_front(hole); } else { // split the hole in two holes Hole new_hole; ++cut_after; while (hole.begin() != cut_after) { new_hole.push_back(hole.front()); hole.pop_front(); } hole.push_front(Edge(newf,1)); new_hole.push_front(Edge(newf,0)); hole_list.push_front(hole); hole_list.push_front(new_hole); } } } } template < class Gt, class Tds > void Regular_triangulation_2:: set_face(Vertex_list& vl, const Face_handle& fh) { for(typename Vertex_list::iterator it = vl.begin(); it != vl.end(); it++) (*it)->set_face(fh); } // add the vertex_list of f2 and f3 to the point list of f1 // for the 3-1 flip template < class Gt, class Tds > void Regular_triangulation_2:: update_hidden_points_3_1(const Face_handle& f1, const Face_handle& f2, const Face_handle& f3) { set_face(f2->vertex_list(), f1); set_face(f3->vertex_list(), f1); (f1->vertex_list()).splice(f1->vertex_list().begin(),f2->vertex_list()); (f1->vertex_list()).splice(f1->vertex_list().begin(),f3->vertex_list()); return; } // the points of the lists of 2 faces are sorted // because of a 2-2 flip template < class Gt, class Tds > void Regular_triangulation_2:: update_hidden_points_2_2(const Face_handle& f1, const Face_handle& f2) { CGAL_triangulation_assertion(f1->has_neighbor(f2)); Vertex_list p_list; p_list.splice(p_list.begin(),f1->vertex_list()); p_list.splice(p_list.begin(),f2->vertex_list()); // if one of the face is infinite, // the other face hide all the points if ( is_infinite(f1)) { set_face(p_list, f2); (f2->vertex_list()).splice(f2->vertex_list().begin(),p_list); return; } if ( is_infinite(f2)) { set_face(p_list, f1); (f1->vertex_list()).splice(f1->vertex_list().begin(),p_list); return; } if (dimension() == 1) { const Weighted_point& a1 = f1->vertex(f1->index(f2))->point(); const Weighted_point& a = f1->vertex(1-f1->index(f2))->point(); while ( ! p_list.empty() ) { if ( compare_x(a, p_list.front()->point()) == compare_x(a, a1) && compare_y(a, p_list.front()->point()) == compare_y(a, a1)) { hide_vertex(f1, p_list.front()); } else { hide_vertex(f2, p_list.front()); } p_list.pop_front(); } return; } // from here f1 and f2 are finite 2-dimensional faces int idx2 = f1->index(f2); Vertex_handle v0=f1->vertex(ccw(idx2)); Vertex_handle v1=f1->vertex(cw(idx2)); CGAL_triangulation_assertion( !is_infinite(v0) && !is_infinite(v1)); while ( ! p_list.empty() ) { if (orientation(v0->point(), v1->point(), p_list.front()->point()) == COUNTERCLOCKWISE) hide_vertex(f1, p_list.front()); else hide_vertex(f2, p_list.front()); p_list.pop_front(); } } // The point list of f1 is separated into 3 lists // for a 1-3 flip template < class Gt, class Tds > void Regular_triangulation_2:: update_hidden_points_1_3(const Face_handle& f1, const Face_handle& f2, const Face_handle& f3) { CGAL_triangulation_assertion(f1->has_neighbor(f2) && f2->has_neighbor(f3) && f3->has_neighbor(f1)); Vertex_list p_list; p_list.splice(p_list.begin(),f1->vertex_list()); if (p_list.empty()) return; // the following does not work if // two of f1,f2 and f3 are twice neighbors // but this cannot appear taking the assertion into account; int idx2 = f1->index(f2), idx3 = f1->index(f3); Vertex_handle v2 = f1->vertex(idx2), v3 = f1->vertex(idx3), v0 = f1->vertex(3-(idx2+idx3)), v1 = f2->vertex(f2->index(f1)); CGAL_triangulation_assertion(f2->has_vertex(v0) && f1->has_vertex(v0)); CGAL_triangulation_assertion(f3->has_vertex(v1)); CGAL_triangulation_assertion( ! is_infinite(v0)); // if two of f1, f2,and f3 are infinite // the list goes entirely to the third finite face // no orientation test necessary // because the point list of an infinite face // is only made of point projecting on its finite edge if ( is_infinite(f1 ) && is_infinite(f2)) { set_face(p_list, f3); f3->vertex_list().splice(f3->vertex_list().begin(), p_list); return; } if ( is_infinite(f1) && is_infinite(f3)) { set_face(p_list, f2); f2->vertex_list().splice(f2->vertex_list().begin(), p_list); return; } if ( is_infinite(f2) && is_infinite(f3)){ set_face(p_list, f1); f1->vertex_list().splice(f1->vertex_list().begin(), p_list); return; } // if here, v1,v2,v3 and v0 are finite vertices while(! p_list.empty()) { Vertex_handle v(p_list.front()); // if(orientation(v2->point(),v0->point(), v->point()) != // orientation(v2->point(),v0->point(),v3->point()) ) // { // not in f1 // if (orientation(v1->point(), v0->point(), v->point() ) != // orientation(v1->point(), v0->point(), v3->point() ) ) // // not in f2 // hide_vertex(f3, v); // else // hide_vertex(f2, v); // } // else // hide_vertex(f1, v); if(orientation(v2->point(),v0->point(), v->point()) == orientation(v2->point(),v0->point(),v3->point()) && orientation(v3->point(),v0->point(), v->point()) == orientation(v3->point(),v0->point(), v2->point())) hide_vertex(f1, v); else if (orientation(v1->point(), v0->point(), v->point()) == orientation(v1->point(), v0->point(), v3->point()) ) hide_vertex(f2,v); else hide_vertex(f3,v); p_list.pop_front(); } } // the vertex is a degree three vertex which has to removed // and hidden // create first a new hidden vertex and exchange with the vertex // to be removed by the tds : // this is required to keep up and down pointers right when using a hierarchy template < class Gt, class Tds > void Regular_triangulation_2:: hide_remove_degree_3(Face_handle fh, Vertex_handle vh) { Vertex_handle vnew= this->_tds.create_vertex(); exchange_incidences(vnew,vh); remove_degree_3(vnew, fh); hide_vertex(fh,vh); } // create a vertex and hide it template < class Gt, class Tds > typename Regular_triangulation_2::Vertex_handle Regular_triangulation_2:: hide_new_vertex(Face_handle f, const Weighted_point& p) { Vertex_handle v = this->_tds.create_vertex(); v->set_point(p); hide_vertex(f, v); return v; } // insert the vertex to the hidden vertex list template < class Gt, class Tds > void Regular_triangulation_2:: hide_vertex(Face_handle f, Vertex_handle vh) { // no hidden vertex in infinite face if(is_infinite(f)) f = f->neighbor(f->index(infinite_vertex())); if(! vh->is_hidden()) { vh->set_hidden(true); _hidden_vertices++; } vh->set_face(f); f->vertex_list().push_back(vh); } // template < class Gt, class Tds > // void // Regular_triangulation_2:: // hide_vertex(Face_handle f, void* ptr) // { // Vertex_handle v(static_cast(ptr)); // hide_vertex(f, v); // } template < class Gt, class Tds > void Regular_triangulation_2:: stack_flip(Vertex_handle v, Faces_around_stack &faces_around) { Face_handle f=faces_around.front(); faces_around.pop_front(); int i = f->index(v); Face_handle n = f->neighbor(i); if (dimension() == 1 ) { if ( is_infinite(f) || is_infinite(n) ) return; if ( power_test( v->point(), n->vertex(n->index(f))->point(), f->vertex(1-i)->point()) == ON_NEGATIVE_SIDE) stack_flip_dim1(f,i,faces_around); return; } // now dimension() == 2 //test the regularity of edge (f,i) //if( power_test(n, v->point()) == ON_NEGATIVE_SIDE) if( power_test(n, v->point()) != ON_POSITIVE_SIDE) return; if(is_infinite(f,i)) { int j = 3 - ( i + f->index(infinite_vertex())); if ( f->vertex(j)->degree() == 4) stack_flip_4_2(f,i,j,faces_around); return; } // now f and n are both finite faces int ni = n->index(f); Orientation occw = orientation(f->vertex(i)->point(), f->vertex(ccw(i))->point(), n->vertex(ni)->point()); Orientation ocw = orientation(f->vertex(i)->point(), f->vertex(cw(i))->point(), n->vertex(ni)->point()); if (occw == LEFT_TURN && ocw == RIGHT_TURN) { // quadrilater (f,n) is convex stack_flip_2_2(f,i, faces_around); return; } if (occw == RIGHT_TURN && f->vertex(ccw(i))->degree() == 3) { stack_flip_3_1(f,i,ccw(i),faces_around); return; } if (ocw == LEFT_TURN && f->vertex(cw(i))->degree() == 3) { stack_flip_3_1(f,i,cw(i),faces_around); return; } if (occw == COLLINEAR && f->vertex(ccw(i))->degree() == 4) { stack_flip_4_2(f,i,ccw(i),faces_around); return; } if (ocw == COLLINEAR && f->vertex(cw(i))->degree() == 4) stack_flip_4_2(f,i,cw(i),faces_around); return; } template < class Gt, class Tds > void Regular_triangulation_2:: stack_flip_4_2(Face_handle f, int i, int j, Faces_around_stack & faces_around) { int k = 3-(i+j); Face_handle g=f->neighbor(k); if (!faces_around.empty()) { if (faces_around.front() == g) faces_around.pop_front(); else if (faces_around.back() == g) faces_around.pop_back(); } //union f with g and f->neihgbor(i) with g->f->neihgbor(i) Face_handle fn = f->neighbor(i); //Face_handle gn = g->neighbor(g->index(f->vertex(i))); Vertex_handle vq = f->vertex(j); this->_tds.flip( f, i); //not using flip because the vertex j is flat. update_hidden_points_2_2(f,fn); Face_handle h1 = ( f->has_vertex(vq) ? fn : f); //hide_vertex(h1, vq); hide_remove_degree_3(g,vq); faces_around.push_front(g); faces_around.push_front(h1); } template < class Gt, class Tds > void Regular_triangulation_2:: stack_flip_3_1(Face_handle f, int i, int j, Faces_around_stack & faces_around) { int k = 3-(i+j); Face_handle g=f->neighbor(k); if (!faces_around.empty()) { if (faces_around.front()== g) faces_around.pop_front(); else if ( faces_around.back() == g) faces_around.pop_back(); } Vertex_handle vq= f->vertex(j); //hide_vertex(f,vq); hide_remove_degree_3(f,vq); faces_around.push_front(f); } template < class Gt, class Tds > void Regular_triangulation_2:: stack_flip_2_2(Face_handle f, int i, Faces_around_stack & faces_around) { Vertex_handle vq = f->vertex(ccw(i)); flip(f,i); if(f->has_vertex(vq)) { faces_around.push_front(f->neighbor(ccw(i))); faces_around.push_front(f); } else { faces_around.push_front(f); faces_around.push_front(f->neighbor(cw(i))); } } template < class Gt, class Tds > void Regular_triangulation_2:: stack_flip_dim1(Face_handle f, int i, Faces_around_stack &faces_around) { Vertex_handle va = f->vertex(1-i); Face_handle n= f->neighbor(i); int in = n->index(f); Vertex_handle vb = n->vertex(in); f->set_vertex(1-i, n->vertex(in)); vb->set_face(f); f->set_neighbor(i, n->neighbor(1-in)); n->neighbor(1-in)->set_neighbor(n->neighbor(1-in)->index(n), f); (f->vertex_list()).splice(f->vertex_list().begin(),n->vertex_list()); set_face(f->vertex_list(),f); delete_face(n); hide_vertex(f,va); faces_around.push_front(f); return; } template < class Gt, class Tds > typename Regular_triangulation_2::All_vertices_iterator Regular_triangulation_2:: all_vertices_begin () const { return filter_iterator(Base::all_vertices_end(), Hidden_tester(), Base::all_vertices_begin()); } template < class Gt, class Tds > typename Regular_triangulation_2::All_vertices_iterator Regular_triangulation_2:: all_vertices_end () const { return filter_iterator(Base::all_vertices_end(), Hidden_tester() ); } template < class Gt, class Tds > typename Regular_triangulation_2::Finite_vertices_iterator Regular_triangulation_2:: finite_vertices_begin () const { return filter_iterator(Base::finite_vertices_end(), Hidden_tester(), Base::finite_vertices_begin()); } template < class Gt, class Tds > typename Regular_triangulation_2::Finite_vertices_iterator Regular_triangulation_2:: finite_vertices_end () const { return filter_iterator(Base::finite_vertices_end(), Hidden_tester() ); } template < class Gt, class Tds > typename Regular_triangulation_2::Hidden_vertices_iterator Regular_triangulation_2:: hidden_vertices_begin () const { return filter_iterator(Base::finite_vertices_end(), Unhidden_tester(), Base::finite_vertices_begin() ); } template < class Gt, class Tds > typename Regular_triangulation_2::Hidden_vertices_iterator Regular_triangulation_2:: hidden_vertices_end () const { return filter_iterator(Base::finite_vertices_end(), Unhidden_tester() ); } CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_2_H ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_filtered_traits_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000003402411344301501031373 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_filtered_traits_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_FILTERED_TRAITS_BASE_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_FILTERED_TRAITS_BASE_2_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- // the filtered Traits class //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- template class Segment_Voronoi_diagram_filtered_traits_base_2 { private: typedef Segment_Voronoi_diagram_filtered_traits_base_2 Self; typedef Segment_Voronoi_diagram_traits_base_2 CK_traits; typedef Segment_Voronoi_diagram_traits_base_2 FK_traits; typedef Segment_Voronoi_diagram_traits_base_2 EK_traits; typedef Segment_Voronoi_diagram_kernel_wrapper_2 CK; typedef Segment_Voronoi_diagram_kernel_wrapper_2 FK; typedef Segment_Voronoi_diagram_kernel_wrapper_2 EK; typedef Svd_cartesian_converter C2E; typedef Svd_cartesian_converter C2F; typedef Cartesian_converter > F2C_t; typedef Svd_cartesian_converter F2C; typedef Cartesian_converter > E2C_t; typedef Svd_cartesian_converter E2C; // Types for the construction kernel typedef typename CK::Point_2 CK_Point_2; typedef typename CK::Line_2 CK_Line_2; typedef typename CK::Segment_2 CK_Segment_2; typedef typename CK::Ray_2 CK_Ray_2; typedef typename CK::Site_2 CK_Site_2; typedef typename CK::FT CK_FT; typedef typename CK::RT CK_RT; // Types for the exact kernel typedef typename EK::Point_2 EK_Point_2; typedef typename EK::Line_2 EK_Line_2; typedef typename EK::Segment_2 EK_Segment_2; typedef typename EK::Ray_2 EK_Ray_2; typedef typename EK::Site_2 EK_Site_2; typedef typename EK::FT EK_FT; typedef typename EK::RT EK_RT; // Types for the filtering kernel typedef typename FK::Point_2 FK_Point_2; typedef typename FK::Line_2 FK_Line_2; typedef typename FK::Segment_2 FK_Segment_2; typedef typename FK::Ray_2 FK_Ray_2; typedef typename FK::Site_2 FK_Site_2; typedef typename FK::FT FK_FT; typedef typename FK::RT FK_RT; public: //----------------------------------------------------------------------- // TYPE DEFINITIONS //----------------------------------------------------------------------- // BASIC TYPES //------------ typedef CK_t R; typedef CK_MTag Method_tag; typedef ITag Intersections_tag; typedef CK_t Construction_kernel; typedef FK_t Filtering_kernel; typedef EK_t Exact_kernel; typedef CK_traits Construction_traits; typedef FK_traits Filtering_traits; typedef EK_traits Exact_traits; typedef CK_MTag Construction_traits_method_tag; typedef FK_MTag Filtering_traits_method_tag; typedef EK_MTag Exact_traits_method_tag; typedef typename CK::Point_2 Point_2; typedef typename CK::Line_2 Line_2; typedef typename CK::Segment_2 Segment_2; typedef typename CK::Ray_2 Ray_2; // typedef typename CK::Circle_2 Circle_2; typedef typename CK::Site_2 Site_2; typedef typename CK::Object_2 Object_2; typedef typename CK::FT FT; typedef typename CK::RT RT; typedef typename CK::Rep_tag Rep_tag; typedef CGALi::Svd_arrangement_enum::Arrangement_type Arrangement_type; private: typedef typename CK_traits::Construct_svd_vertex_2 CK_Construct_svd_vertex_2; typedef typename FK_traits::Construct_svd_vertex_2 FK_Construct_svd_vertex_2; typedef typename EK_traits::Construct_svd_vertex_2 EK_Construct_svd_vertex_2; public: // OBJECT CONSTRUCTION & ASSIGNMENT //--------------------------------- typedef typename CK::Construct_object_2 Construct_object_2; typedef typename CK::Assign_2 Assign_2; // CONSTRUCTIONS //-------------- // vertex and Voronoi circle typedef Filtered_construction Construct_svd_vertex_2; // typedef typename CK::Construct_site_2 Construct_site_2; // typedef typename CK_traits::Construct_svd_circle_2 // Construct_svd_circle_2; private: // PREDICATES FOR THE TWO KERNELS //------------------------------- #if 0 // Predicates for the filtering kernel typedef typename FK_traits::Compare_x_2 FK_Compare_x_2; typedef typename FK_traits::Compare_y_2 FK_Compare_y_2; typedef typename FK_traits::Orientation_2 FK_Orientation_2; typedef typename FK_traits::Equal_2 FK_Equal_2; typedef typename FK_traits::Are_parallel_2 FK_Are_parallel_2; typedef typename FK_traits::Oriented_side_of_bisector_2 FK_Oriented_side_of_bisector_2; typedef typename FK_traits::Vertex_conflict_2 FK_Vertex_conflict_2; typedef typename FK_traits::Finite_edge_interior_conflict_2 FK_Finite_edge_interior_conflict_2; typedef typename FK_traits::Infinite_edge_interior_conflict_2 FK_Infinite_edge_interior_conflict_2; typedef typename FK_traits::Is_degenerate_edge_2 FK_Is_degenerate_edge_2; typedef typename FK_traits::Arrangement_type_2 FK_Arrangement_type_2; typedef typename FK_traits::Oriented_side_2 FK_Oriented_side_2; // Predicates for the exact kernel typedef typename EK_traits::Compare_x_2 EK_Compare_x_2; typedef typename EK_traits::Compare_y_2 EK_Compare_y_2; typedef typename EK_traits::Orientation_2 EK_Orientation_2; typedef typename EK_traits::Equal_2 EK_Equal_2; typedef typename EK_traits::Are_parallel_2 EK_Are_parallel_2; typedef typename EK_traits::Oriented_side_of_bisector_2 EK_Oriented_side_of_bisector_2; typedef typename EK_traits::Vertex_conflict_2 EK_Vertex_conflict_2; typedef typename EK_traits::Finite_edge_interior_conflict_2 EK_Finite_edge_interior_conflict_2; typedef typename EK_traits::Infinite_edge_interior_conflict_2 EK_Infinite_edge_interior_conflict_2; typedef typename EK_traits::Is_degenerate_edge_2 EK_Is_degenerate_edge_2; typedef typename EK_traits::Arrangement_type_2 EK_Arrangement_type_2; typedef typename EK_traits::Oriented_side_2 EK_Oriented_side_2; #else // Predicates for the filtering kernel typedef Svd_compare_x_2 FK_Compare_x_2; typedef Svd_compare_y_2 FK_Compare_y_2; typedef Svd_orientation_C2 FK_Orientation_2; typedef Svd_are_same_points_C2 FK_Equal_2; typedef Svd_are_parallel_C2 FK_Are_parallel_2; typedef Svd_oriented_side_of_bisector_C2 FK_Oriented_side_of_bisector_2; typedef Svd_incircle_2 FK_Vertex_conflict_2; typedef Svd_finite_edge_interior_2 FK_Finite_edge_interior_conflict_2; typedef Svd_infinite_edge_interior_2 FK_Infinite_edge_interior_conflict_2; typedef Svd_is_degenerate_edge_C2 FK_Is_degenerate_edge_2; typedef Svd_arrangement_type_C2 FK_Arrangement_type_2; typedef Svd_oriented_side_C2 FK_Oriented_side_2; // Predicates for the exact kernel typedef Svd_compare_x_2 EK_Compare_x_2; typedef Svd_compare_y_2 EK_Compare_y_2; typedef Svd_orientation_C2 EK_Orientation_2; typedef Svd_are_same_points_C2 EK_Equal_2; typedef Svd_are_parallel_C2 EK_Are_parallel_2; typedef Svd_oriented_side_of_bisector_C2 EK_Oriented_side_of_bisector_2; typedef Svd_incircle_2 EK_Vertex_conflict_2; typedef Svd_finite_edge_interior_2 EK_Finite_edge_interior_conflict_2; typedef Svd_infinite_edge_interior_2 EK_Infinite_edge_interior_conflict_2; typedef Svd_is_degenerate_edge_C2 EK_Is_degenerate_edge_2; typedef Svd_arrangement_type_C2 EK_Arrangement_type_2; typedef Svd_oriented_side_C2 EK_Oriented_side_2; #endif public: // PREDICATES //----------- typedef Filtered_predicate Compare_x_2; typedef Filtered_predicate Compare_y_2; typedef Filtered_predicate Orientation_2; typedef Filtered_predicate Equal_2; typedef Filtered_predicate Are_parallel_2; typedef Filtered_predicate Oriented_side_of_bisector_2; typedef Filtered_predicate Vertex_conflict_2; typedef Filtered_predicate Finite_edge_interior_conflict_2; typedef Filtered_predicate Infinite_edge_interior_conflict_2; typedef Filtered_predicate Is_degenerate_edge_2; private: typedef Filtered_predicate Arrangement_type_2_base; public: struct Arrangement_type_2 : public Arrangement_type_2_base, public CGALi::Svd_arrangement_enum {}; typedef Filtered_predicate Oriented_side_2; public: //----------------------------------------------------------------------- // ACCESS TO OBJECTS //----------------------------------------------------------------------- // OBJECT CONSTRUCTION & ASSIGNMENT //--------------------------------- Assign_2 assign_2_object() const { return Assign_2(); } Construct_object_2 construct_object_2_object() const { return Construct_object_2(); } // CONSTRUCTIONS //-------------- Construct_svd_vertex_2 construct_svd_vertex_2_object() const { return Construct_svd_vertex_2(); } /* Construct_site_2 construct_site_2_object() const { return Construct_site_2(); } */ /* Construct_svd_circle_2 construct_svd_circle_2_object() const { return Construct_svd_circle_2(); } */ // PREDICATES //----------- Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Equal_2 equal_2_object() const { return Equal_2(); } Are_parallel_2 are_parallel_2_object() const { return Are_parallel_2(); } Oriented_side_of_bisector_2 oriented_side_of_bisector_2_object() const { return Oriented_side_of_bisector_2(); } Vertex_conflict_2 vertex_conflict_2_object() const { return Vertex_conflict_2(); } Finite_edge_interior_conflict_2 finite_edge_interior_conflict_2_object() const { return Finite_edge_interior_conflict_2(); } Infinite_edge_interior_conflict_2 infinite_edge_interior_conflict_2_object() const { return Infinite_edge_interior_conflict_2(); } Is_degenerate_edge_2 is_degenerate_edge_2_object() const { return Is_degenerate_edge_2(); } Arrangement_type_2 arrangement_type_2_object() const { return Arrangement_type_2(); } Oriented_side_2 oriented_side_2_object() const { return Oriented_side_2(); } }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_FILTERED_TRAITS_BASE_2_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Segment_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Segmen0000644000175000017500000000225711344301500031246 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Segment_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_simple_storage_site_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000001250011344301501031366 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_simple_storage_site_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef SEGMENT_VORONOI_DIAGRAM_SIMPLE_STORAGE_SITE_H #define SEGMENT_VORONOI_DIAGRAM_SIMPLE_STORAGE_SITE_H #include #include #include CGAL_BEGIN_NAMESPACE /** A Site is either a point or a segment or a point defined as the intersection of two non-parallel segments (if defined) */ template class Segment_Voronoi_diagram_simple_storage_site_2 { public: typedef Gt Geom_traits; typedef typename Geom_traits::Site_2 Site_2; typedef typename std::set::iterator Point_handle; // typedef typename std::list::iterator // Point_handle; protected: typedef Point_handle Handle; typedef Segment_Voronoi_diagram_simple_storage_site_2 Self; public: // constructs point site using input point static Self construct_storage_site_2(const Handle& hp) { Self t; t.initialize_site(hp); return t; } // constructs segment site using input segment static Self construct_storage_site_2(const Handle& hp1, const Handle& hp2) { Self t; t.initialize_site(hp1, hp2); return t; } public: // DEFAULT CONSTRUCTOR //-------------------- Segment_Voronoi_diagram_simple_storage_site_2() : type_(0) {} // COPY CONSTRUCTOR //----------------- Segment_Voronoi_diagram_simple_storage_site_2(const Self& other) { copy_from(other); } // ASSIGNMENT OPERATOR //-------------------- Self& operator=(const Self& other) { copy_from(other); return *this; } public: // PREDICATES //----------- bool is_defined() const { return type_; } bool is_point() const { return type_ == 1; } bool is_segment() const { return type_ == 2; } bool is_input() const { return true; } bool is_input(unsigned int i) const { return true; } // ACCESS METHODS //--------------- const Handle& point() const { CGAL_precondition( is_point() && is_input() ); return h_[0]; } const Handle& source_of_supporting_site() const { CGAL_precondition( is_segment() ); return h_[0]; } const Handle& target_of_supporting_site() const { CGAL_precondition( is_segment() ); return h_[1]; } // the following methods should never be called; they have been // defined in order for this class to be a model of the // SegmentVoronoiDiagramStorageSite_2 concept. const Handle& source_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return h_[0]; } const Handle& target_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return h_[0]; } const Handle& source_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return h_[0]; } const Handle& target_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return h_[0]; } Site_2 site() const { if ( is_point() ) { return Site_2::construct_site_2(*h_[0]); } else { return Site_2::construct_site_2(*h_[0],*h_[1]); } } Self source_site() const { CGAL_precondition( is_segment() ); return construct_storage_site_2(h_[0]); } Self target_site() const { CGAL_precondition( is_segment() ); return construct_storage_site_2(h_[1]); } Self supporting_site() const { CGAL_precondition( is_segment() ); return construct_storage_site_2(h_[0], h_[1]); } Self supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() && i < 2 ); return construct_storage_site_2(h_[0], h_[0]); } Self crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input() ); CGAL_precondition( i < 2 && !is_input(i) ); return construct_storage_site_2(h_[0], h_[0]); } protected: // INITIALIZATION //--------------- void initialize_site(const Handle& hp) { type_ = 1; h_[0] = hp; } void initialize_site(const Handle& hp1, const Handle& hp2) { type_ = 2; h_[0] = hp1; h_[1] = hp2; } void copy_from(const Self& other) { type_ = other.type_; if ( !other.is_defined() ) { return; } h_[0] = other.h_[0]; if ( other.is_segment() ) { h_[1] = other.h_[1]; } } protected: Handle h_[2]; char type_; }; //------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // SEGMENT_VORONOI_DIAGRAM_SIMPLE_STORAGE_SITE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_bounding_box_base.h0000644000175000017500000001035011344301500031273 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_bounding_box_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PM_BOUNDING_BOX_BASE_H #define CGAL_PM_BOUNDING_BOX_BASE_H #ifndef CGAL_BASIC_H #include #endif #include CGAL_BEGIN_NAMESPACE //////////////////////////////////////////////////////////////////// // ABSTRACT BASE CLASS OF BOUNDING BOX ////////////////////////////////////////////////////////////////// template class Pm_point_location_base; template struct Pm_token { virtual void rebuild_bounding_box(const Pm_point_location_base*) const {}; }; template class Pm_bounding_box_base { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef typename std::vector::iterator Point_iterator; typedef typename std::vector::iterator X_curve_iterator; typedef Pm_point_location_base Point_location_base; typedef Pm_token Token; Pm_bounding_box_base() {} virtual void init(Planar_map& pmp, Traits& tr) = 0; virtual ~Pm_bounding_box_base() {} /* Returns true if bounding box remained unchanged */ virtual bool insert(const Point& p) = 0; virtual bool insert(const Point_iterator& begin,const Point_iterator& end #ifdef _MSC_VER ,Point* dummy=0 #endif )=0; virtual bool insert(const X_curve& cv) = 0; virtual bool insert(const X_curve_iterator& begin, const X_curve_iterator& end #ifdef _MSC_VER ,X_curve* dummy=0 #endif )=0; // workaround for MSVC6.0 /* The point location query function may updates the resulting halfedge handle and locate type as expected from the bounding box */ /* Returns true if bounding box remained unchanged */ virtual bool locate(const Point& p, Locate_type& lt,Halfedge_handle& h) = 0; virtual bool vertical_ray_shoot(const Point& p, Locate_type& lt, bool up, Halfedge_handle& h) = 0; //the function is called after the combinatoric split //cv is the original curve , e1 e2 are the new halfedges returned virtual void split_edge(const X_curve &cv, Halfedge_handle e1, Halfedge_handle e2, const X_curve& cv1, const X_curve& cv2 ) = 0; virtual void split_boundary_edge(const Halfedge_handle &h, Halfedge_handle h1, Halfedge_handle h2, const Point& p) =0; //called after combinatoric merge //e is the new edge cv1,cv2 are the original curves virtual void merge_edge(const X_curve &cv1, const X_curve &cv2, Halfedge_handle e //additions by iddo for arrangement ,const X_curve& cv //end additions ) = 0; //called before combinatoric deletion virtual void remove_edge(Halfedge_handle e) = 0; virtual void clear(){} virtual bool is_empty() const = 0; #ifdef CGAL_PM_DEBUG virtual void debug() const = 0; #endif }; CGAL_END_NAMESPACE #endif //CGAL_PM_BOUNDING_BOX_BASE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_2.h0000644000175000017500000006310611344301501030227 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_2.h,v $ // $Revision: 1.1.1.1 $ // $Name: $ // // author(s) : Eli Packer #ifndef CGAL_SNAP_ROUNDING_2_H #define CGAL_SNAP_ROUNDING_2_H #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE enum Direction {SEG_UP_RIGHT,SEG_UP_LEFT,SEG_DOWN_RIGHT,SEG_DOWN_LEFT, SEG_UP,SEG_DOWN,SEG_LEFT,SEG_RIGHT,SEG_POINT_SEG}; template class Segment_data { private: typedef Traits_ Traits; typedef typename Traits::FT NT; typedef typename Traits::Segment_2 Segment_2; typedef typename Traits::Point_2 Point_2; private: Point_2 p; Point_2 q; Traits m_gt; public: Segment_data(); Segment_data(const Point_2 & p_inp,const Point_2 & q_inp); Segment_2 segment() const { return(Segment_2(p, q)); } Point_2 source() const { return(p); } Point_2 target() const { return(q); } inline void set_data(const Point_2 & inp_p,const Point_2 & inp_q); void determine_direction(Direction & seg_dir); bool equal(const Segment_2 & s); Segment_data(const Segment_data & other); }; /*! */ template class Hot_pixel { private: typedef Traits_ Traits; typedef typename Traits::FT NT; typedef typename Traits::Segment_2 Segment_2; typedef typename Traits::Point_2 Point_2; typedef CGAL::Segment_data Segment_data; private: // p is the center of the hot pixel Point_2 p; Point_2 p_left; Point_2 p_right; Point_2 p_down; Point_2 p_up; Traits_ m_gt; NT pixel_size; Segment_2 *right_seg; Segment_2 *left_seg; Segment_2 *top_seg; Segment_2 *bot_seg; static Direction seg_dir; public: Hot_pixel(const Point_2 & inp_point, NT inp_pixel_size); ~Hot_pixel(); inline Point_2 get_center() const; inline Point_2 get_center(bool int_output) const; bool intersect_left(const Segment_2 & seg, Direction seg_dir) const; bool intersect_right(const Segment_2 & seg, Direction seg_dir) const; bool intersect_bot(const Segment_2 & seg, Direction seg_dir) const; bool intersect_top(const Segment_2 & seg, Direction seg_dir) const; bool intersect(Segment_data & seg, Direction seg_dir) const; void set_direction(Direction inp_seg_dir) { seg_dir = inp_seg_dir; } Direction get_direction() const { return(seg_dir); } }; /*! */ template Direction Hot_pixel::seg_dir; // a function for compare two hot pixels for the set of hot pixels template struct Hot_pixel_auclidian_cmp { typedef CGAL::Hot_pixel Hot_pixel; Traits_ m_gt; bool operator()(const Hot_pixel * h1, const Hot_pixel * h2) const; }; // a function for compare two hot pixels for the set of hot pixels a // certain segment intersect template struct Hot_pixel_dir_cmp { typedef CGAL::Hot_pixel Hot_pixel; Traits_ m_gt; bool operator()(const Hot_pixel * h1, const Hot_pixel * h2); }; #ifdef CGAL_SR_DEBUG int number_of_false_hp; #endif template class Snap_rounding_2 { private: typedef Traits_ Traits; typedef typename Traits::FT NT; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename OutputContainer::value_type Polyline_type; typedef CGAL::Hot_pixel Hot_pixel; typedef CGAL::Segment_data Segment_data; typedef CGAL::Multiple_kd_tree Multiple_kd_tree; typedef std::list Segment_data_list; typedef CGAL::Hot_pixel_dir_cmp Hot_pixel_dir_cmp; typedef std::set Hot_pixel_set; public: // friend class Segment_data; // friend class Hot_pixel; // friend struct Hot_pixel_dir_cmp; typedef typename Traits::Segment_2 Segment_2; typedef typename Traits::Point_2 Point_2; typedef std::list Point_list; void find_hot_pixels_and_create_kd_trees(NT pixel_size, unsigned int number_of_kd_trees, Segment_data_list & seg_list, Multiple_kd_tree ** mul_kd_tree); void iterate(OutputContainer & output_container, NT pixel_size, bool int_output, bool do_isr, Segment_data_list & seg_list, Multiple_kd_tree * mul_kd_tree); private: Traits m_gt; static const int default_number_of_kd_trees = 1; void find_intersected_hot_pixels(Segment_data & seg, Hot_pixel_set &hot_pixels_intersected_set, int &number_of_intersections, NT pixel_size, Multiple_kd_tree * mul_kd_tree); void reroute_sr(Hot_pixel_set & inp_hot_pixels_intersected_set, Polyline_type & seg_output, bool int_output); void reroute_isr(Hot_pixel_set & inp_hot_pixels_intersected_set, Polyline_type & seg_output, int number_of_intersections, bool first_time, NT pixel_size, bool int_output, Multiple_kd_tree * mul_kd_tree); }; /*! Constructor */ template Segment_data::Segment_data() {} /*! Constructor */ template Segment_data::Segment_data(const Point_2 & p_inp, const Point_2 & q_inp) : p(p_inp), q(q_inp) {} /*! Constructor */ template Segment_data::Segment_data(const Segment_data & other) { p = other.p; q = other.q; } /*! */ template inline void Segment_data::set_data(const Point_2 & inp_p, const Point_2 & inp_q) { p = inp_p; q = inp_q; } /*! */ template bool Segment_data::equal(const Segment_2 & s) { typedef typename Traits_::Construct_vertex_2 Construct_vertex_2; Construct_vertex_2 construct_vertex = m_gt.construct_vertex_2_object(); return(construct_vertex(s, 0) == p && construct_vertex(s, 1) == q); } /*! */ template void Segment_data::determine_direction(Direction & seg_dir) { typedef typename Traits_::Compare_y_2 Compare_y_2; typedef typename Traits_::Compare_x_2 Compare_x_2; Compare_x_2 compare_x = m_gt.compare_x_2_object(); Compare_y_2 compare_y = m_gt.compare_y_2_object(); Comparison_result cx = compare_x(p, q); Comparison_result cy = compare_y(p, q); if (cx == SMALLER) { if (cy == SMALLER) seg_dir = SEG_UP_RIGHT; else if (cy == EQUAL) seg_dir = SEG_RIGHT; else seg_dir = SEG_DOWN_RIGHT; } else if (cx == EQUAL) { if (cy == SMALLER) seg_dir = SEG_UP; else if (cy == EQUAL) seg_dir = SEG_POINT_SEG; else seg_dir = SEG_DOWN; } else { if (cy == SMALLER) seg_dir = SEG_UP_LEFT; else if (cy == EQUAL) seg_dir = SEG_LEFT; else seg_dir = SEG_DOWN_LEFT; } } // intersection pixel template Hot_pixel::Hot_pixel(const Point_2 & inp_point, NT inp_pixel_size) : pixel_size(inp_pixel_size) { NT x,y; m_gt.snap_2_object()(inp_point, pixel_size, x, y); NT left_coord = x - pixel_size / NT(2.0); NT right_coord = x + pixel_size / NT(2.0); NT bottom_coord = y - pixel_size / NT(2.0); NT top_coord = y + pixel_size / NT(2.0); p = Point_2(x, y); p_left = Point_2(left_coord, y); p_right = Point_2(right_coord, y); p_down = Point_2(x, bottom_coord); p_up = Point_2(x, top_coord); typedef typename Traits::Construct_segment_2 Construct_segment_2; Construct_segment_2 construct_seg = m_gt.construct_segment_2_object(); Point_2 lb(left_coord, bottom_coord); Point_2 rb(right_coord, bottom_coord); Point_2 lt(left_coord, top_coord); Point_2 rt(right_coord, top_coord); right_seg = new Segment_2(construct_seg(rb, rt)); left_seg = new Segment_2(construct_seg(lb, lt)); top_seg = new Segment_2(construct_seg(lt, rt)); bot_seg = new Segment_2(construct_seg(lb, rb)); } /*! */ template Hot_pixel::~Hot_pixel() { delete(right_seg); delete(left_seg); delete(top_seg); delete(bot_seg); } /*! */ template inline typename Hot_pixel::Point_2 Hot_pixel::get_center() const { return(p); } /*! */ template inline typename Hot_pixel::Point_2 Hot_pixel::get_center(bool int_output) const { if (int_output) { Point_2 out_p = m_gt.integer_grid_point_2_object()(p,pixel_size); return(out_p); } else return(p); } /*! */ template bool Hot_pixel::intersect_left(const Segment_2 & seg, Direction seg_dir) const { typedef typename Traits_::Compare_y_2 Compare_y_2; typedef typename Traits_::Construct_vertex_2 Construct_vertex_2; Object result; Point_2 p; Segment_2 s; result = intersection(seg, *left_seg); if (assign(p, result)) { Compare_y_2 compare_y = m_gt.compare_y_2_object(); Construct_vertex_2 construct_vertex = m_gt.construct_vertex_2_object(); Comparison_result c_p = compare_y(p, p_up); Comparison_result c_target = compare_y(construct_vertex(seg, 1), p_up); Comparison_result c_source = compare_y(construct_vertex(seg, 0), p_up); return(c_p != EQUAL || seg_dir == SEG_UP_LEFT && c_source != EQUAL || seg_dir == SEG_DOWN_RIGHT && c_target != EQUAL); } else if (assign(s,result)) return(true); else return(false); } /*! */ template bool Hot_pixel::intersect_right(const Segment_2 & seg, Direction seg_dir) const { typedef typename Traits_::Compare_y_2 Compare_y_2; typedef typename Traits_::Compare_x_2 Compare_x_2; typedef typename Traits_::Construct_vertex_2 Construct_vertex_2; Object result; Point_2 p; Segment_2 s; result = intersection(seg, *right_seg); if (assign(p,result)) { // bottom right point was checked in intersect_bot Compare_y_2 compare_y = m_gt.compare_y_2_object(); Construct_vertex_2 construct_vertex = m_gt.construct_vertex_2_object(); Comparison_result c1 = compare_y(p, p_up); Comparison_result c2 = compare_y(p, p_down); Point_2 src = construct_vertex(seg, 0); Point_2 trg = construct_vertex(seg, 1); Comparison_result c3 = compare_y(src, p_up); Comparison_result c4 = compare_y(trg, p_up); if (c1 == EQUAL) return(seg_dir == SEG_UP_RIGHT && c3 != EQUAL || seg_dir == SEG_DOWN_LEFT && c4 != EQUAL); else if (c2 == EQUAL) return(false);// was checked else { Compare_x_2 compare_x = m_gt.compare_x_2_object(); Comparison_result c_target = compare_x(p_right, trg); Comparison_result c_source = compare_x(p_right, src); return((seg_dir == SEG_LEFT || seg_dir == SEG_DOWN_LEFT || seg_dir == SEG_UP_LEFT) && c_target != EQUAL || (seg_dir == SEG_RIGHT || seg_dir == SEG_DOWN_RIGHT || seg_dir == SEG_UP_RIGHT) && c_source != EQUAL); } } else return(false); } /*! */ template bool Hot_pixel::intersect_bot(const Segment_2 & seg, Direction seg_dir) const { typedef typename Traits_::Compare_x_2 Compare_x_2; typedef typename Traits_::Construct_vertex_2 Construct_vertex_2; Object result; Point_2 p; Segment_2 s; result = intersection(seg,*bot_seg); if (assign(p,result)) { Compare_x_2 compare_x = m_gt.compare_x_2_object(); Construct_vertex_2 construct_vertex = m_gt.construct_vertex_2_object(); Comparison_result c_p = compare_x(p, p_right); Comparison_result c_target = compare_x(construct_vertex(seg, 1), p_right); Comparison_result c_source = compare_x(construct_vertex(seg, 0), p_right); return(c_p != EQUAL || seg_dir == SEG_UP_LEFT && c_target != EQUAL || seg_dir == SEG_DOWN_RIGHT && c_source != EQUAL); } else if (assign(s,result)) return(true); else return(false); } /*! */ template bool Hot_pixel::intersect_top(const Segment_2 & seg, Direction seg_dir) const { typedef typename Traits_::Compare_x_2 Compare_x_2; typedef typename Traits_::Compare_y_2 Compare_y_2; typedef typename Traits_::Construct_vertex_2 Construct_vertex_2; Object result; Point_2 p; Segment_2 s; result = intersection(seg, *top_seg); if (assign(p,result)) { Compare_x_2 compare_x = m_gt.compare_x_2_object(); Compare_y_2 compare_y = m_gt.compare_y_2_object(); Construct_vertex_2 construct_vertex = m_gt.construct_vertex_2_object(); // corner points was checked in intersect_bot Comparison_result c1 = compare_x(p, p_left); Comparison_result c2 = compare_x(p, p_right); Comparison_result c3 = compare_y(construct_vertex(seg, 1), p_up); Comparison_result c4 = compare_y(construct_vertex(seg, 0), p_up); if (c1 == EQUAL || c2 == EQUAL) return(false);// were checked else return((seg_dir == SEG_DOWN || seg_dir == SEG_DOWN_LEFT || seg_dir == SEG_DOWN_RIGHT) && c3 != EQUAL || (seg_dir == SEG_UP || seg_dir == SEG_UP_LEFT || seg_dir == SEG_UP_RIGHT) && c4 != EQUAL); } else return(false); } /*! */ template bool Hot_pixel::intersect(Segment_data & seg, Direction my_seg_dir) const { Segment_2 s = seg.segment(); return(intersect_bot(s,my_seg_dir) || intersect_left(s, my_seg_dir) || intersect_right(s, my_seg_dir) || intersect_top(s, my_seg_dir)); } // a function for compare two hot pixels for the set of hot pixels template bool Hot_pixel_auclidian_cmp:: operator()(const Hot_pixel * h1, const Hot_pixel * h2) const { typedef typename Traits_::Compare_x_2 Compare_x_2; typedef typename Traits_::Compare_y_2 Compare_y_2; Compare_x_2 compare_x = m_gt.compare_x_2_object(); Compare_y_2 compare_y = m_gt.compare_y_2_object(); Comparison_result cx = compare_x(h1.get_center(), h2.get_center()); Comparison_result cy = compare_y(h1.get_center(), h2.get_center()); return(cx == SMALLER || cx == EQUAL && cy == SMALLER); } // a function for compare two hot pixels for the set of hot pixels a certain // segment intersect template bool Hot_pixel_dir_cmp::operator ()(const Hot_pixel * h1, const Hot_pixel * h2) { typedef typename Traits_::Compare_x_2 Compare_x_2; typedef typename Traits_::Compare_y_2 Compare_y_2; Compare_x_2 compare_x = m_gt.compare_x_2_object(); Compare_y_2 compare_y = m_gt.compare_y_2_object(); Comparison_result cx = compare_x(h1->get_center(), h2->get_center()); Comparison_result cy = compare_y(h1->get_center(), h2->get_center()); Direction seg_dir = h1->get_direction(); // Point segment intersects only one pixel, thus ignored return(seg_dir == SEG_UP_RIGHT && (cx == SMALLER || cx == EQUAL && cy == SMALLER) || seg_dir == SEG_UP_LEFT && (cx == LARGER || cx == EQUAL && cy == SMALLER) || seg_dir == SEG_DOWN_RIGHT && (cx == SMALLER || cx == EQUAL && cy == LARGER) || seg_dir == SEG_DOWN_LEFT && (cx == LARGER || cx == EQUAL && cy == LARGER) || seg_dir == SEG_UP && cy == SMALLER || seg_dir == SEG_DOWN && cy == LARGER || seg_dir == SEG_LEFT && cx == LARGER || seg_dir == SEG_RIGHT && cx == SMALLER); } /*! */ template void Snap_rounding_2:: find_hot_pixels_and_create_kd_trees(NT pixel_size, unsigned int number_of_kd_trees, std::list & seg_list, Multiple_kd_tree ** mul_kd_tree) { typedef std::pair Point_hot_pixel_pair; typedef typename std::list::iterator Segment_data_iter; typedef std::list Segment_list; typedef typename Segment_list::iterator Segment_iter; typedef typename std::list::const_iterator Point_const_iter; typedef typename Traits::Construct_segment_2 Construct_segment_2; Construct_segment_2 construct_seg = m_gt.construct_segment_2_object(); Hot_pixel * hp; Segment_data_iter iter1; Object result; Point_2 p; std::list hot_pixels_list; Segment_list segments; if (seg_list.empty()) return; for (iter1 = seg_list.begin(); iter1 != seg_list.end(); ++iter1) { segments.push_back(construct_seg(iter1->source(), iter1->target())); } // get intersection points (with endpoints) Point_list mypointlist; Sweep_line_2 sl; sl.get_intersection_points(segments.begin(), segments.end(), std::back_inserter(mypointlist)); for (Point_const_iter v_iter = mypointlist.begin(); v_iter != mypointlist.end(); ++v_iter) { hp = new Hot_pixel(*v_iter, pixel_size); hot_pixels_list.push_back(Point_hot_pixel_pair(hp->get_center(), hp)); } // create kd multiple tree // create simple_list from seg_list Segment_list simple_seg_list; for (Segment_data_iter iter = seg_list.begin(); iter != seg_list.end(); ++iter) { simple_seg_list.push_back(construct_seg(iter->source(), iter->target())); } *mul_kd_tree = new Multiple_kd_tree(hot_pixels_list, number_of_kd_trees, simple_seg_list); } /*! */ template void Snap_rounding_2:: find_intersected_hot_pixels(Segment_data & seg, std::set & hot_pixels_intersected_set, int &number_of_intersections, NT pixel_size, Multiple_kd_tree * mul_kd_tree) { typedef typename std::list::iterator Hot_pixel_iter; Hot_pixel_iter iter; Direction seg_dir; hot_pixels_intersected_set.clear(); seg.determine_direction(seg_dir); number_of_intersections = 0; std::list hot_pixels_list; mul_kd_tree->get_intersecting_points(hot_pixels_list, Segment_2(seg.segment()), pixel_size); for (iter = hot_pixels_list.begin();iter != hot_pixels_list.end();++iter) { if ((*iter)->intersect(seg,seg_dir)) { (*iter)->set_direction(seg_dir); hot_pixels_intersected_set.insert(*iter); } #ifdef CGAL_SR_DEBUG else ++number_of_false_hp; #endif } number_of_intersections = hot_pixels_intersected_set.size(); } /*! */ template void Snap_rounding_2:: reroute_sr(std::set & inp_hot_pixels_intersected_set, Polyline_type & seg_output, bool int_output) { typedef typename std::set::iterator Hot_pixel_iter; Hot_pixel_iter hot_pixel_iter = inp_hot_pixels_intersected_set.begin(); ++hot_pixel_iter; while (hot_pixel_iter != inp_hot_pixels_intersected_set.end()) { seg_output.push_back((*hot_pixel_iter)->get_center(int_output)); ++hot_pixel_iter; } } /*! */ template void Snap_rounding_2:: reroute_isr(std::set & inp_hot_pixels_intersected_set, Polyline_type & seg_output, int number_of_intersections, bool first_time, NT pixel_size, bool int_output, Multiple_kd_tree * mul_kd_tree) { typedef std::set Hot_pixel_set; typedef typename std::set::iterator Hot_pixel_iter; Hot_pixel_iter hot_pixel_iter, next_hot_pixel_iter, before_last_hot_pixel_iter; Segment_data seg; Hot_pixel_set hot_pixels_intersected_set; Direction seg_dir; if (number_of_intersections > 2 || first_time) { before_last_hot_pixel_iter = inp_hot_pixels_intersected_set.end(); --before_last_hot_pixel_iter; for (hot_pixel_iter = inp_hot_pixels_intersected_set.begin(); hot_pixel_iter != before_last_hot_pixel_iter; ++hot_pixel_iter) { next_hot_pixel_iter = hot_pixel_iter; ++next_hot_pixel_iter; seg.set_data((*hot_pixel_iter)->get_center(), (*next_hot_pixel_iter)->get_center()); seg.determine_direction(seg_dir); find_intersected_hot_pixels(seg, hot_pixels_intersected_set, number_of_intersections, pixel_size, mul_kd_tree); reroute_isr(hot_pixels_intersected_set, seg_output, number_of_intersections,false, pixel_size, int_output, mul_kd_tree); } } else { // insert second hot pixel hot_pixel_iter = inp_hot_pixels_intersected_set.begin(); ++hot_pixel_iter; seg_output.push_back((*hot_pixel_iter)->get_center(int_output)); } } /*! */ template void Snap_rounding_2:: iterate(OutputContainer & output_container, NT pixel_size, bool int_output, bool do_isr, std::list & seg_list, Multiple_kd_tree * mul_kd_tree) { typedef std::set Hot_pixel_set; typedef typename std::set::iterator Hot_pixel_iter; typedef typename std::list::iterator Segment_data_iter; Polyline_type seg_output; Hot_pixel_set hot_pixels_intersected_set; Hot_pixel_iter hot_pixel_iter; int number_of_intersections; Hot_pixel * hp; Direction seg_dir; for (Segment_data_iter iter = seg_list.begin(); iter != seg_list.end(); ++iter) { seg_output.clear(); iter->determine_direction(seg_dir); find_intersected_hot_pixels(*iter, hot_pixels_intersected_set, number_of_intersections, pixel_size, mul_kd_tree); // hot_pixels_intersected_set must have at least two hot pixels when the // segment is not in entirely inside a hot pixel enter first hot pixel hot_pixel_iter = hot_pixels_intersected_set.begin(); if (hot_pixel_iter == hot_pixels_intersected_set.end()) { // segment entirely inside a pixel hp = new Hot_pixel(iter->source(), pixel_size); seg_output.push_back(hp->get_center(int_output)); delete(hp); } else { seg_output.push_back((*hot_pixel_iter)->get_center(int_output)); if (number_of_intersections > 1) { // segments that have at most one intersecting hot pixel are // done(it was inserted) if (do_isr) reroute_isr(hot_pixels_intersected_set, seg_output, number_of_intersections, true,pixel_size, int_output, mul_kd_tree); else reroute_sr(hot_pixels_intersected_set, seg_output, int_output); } } output_container.push_back(seg_output); } } /*! */ template void snap_rounding_2(InputIterator begin, InputIterator end, OutputContainer & output_container, typename Traits::FT pixel_size, bool do_isr = true, bool int_output = true, unsigned int number_of_kd_trees = 1) { #ifdef CGAL_SR_DEBUG number_of_false_hp = 0; #endif typedef CGAL::Hot_pixel Hot_pixel; typedef CGAL::Segment_data Segment_data; typedef CGAL::Multiple_kd_tree Multiple_kd_tree; typedef std::list Segment_data_list; Segment_data_list seg_list; Multiple_kd_tree * mul_kd_tree; output_container.clear(); // copy segments list while (begin != end) { seg_list.push_back(Segment_data(begin->source(), begin->target())); ++begin; } Snap_rounding_2 s; s.find_hot_pixels_and_create_kd_trees(pixel_size, number_of_kd_trees, seg_list, &mul_kd_tree); s.iterate(output_container, pixel_size, int_output, do_isr,seg_list, mul_kd_tree); #ifdef CGAL_SR_DEBUG std::cout << "Overall number of false hot pixels in all the queries : " << number_of_false_hp << std::endl; #endif } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_trait0000644000175000017500000006743511344301500031473 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_TRAITS_2_H #define CGAL_APOLLONIUS_GRAPH_TRAITS_2_H #ifndef CGAL_REP_CLASS_DEFINED #error no representation class defined #endif // CGAL_REP_CLASS_DEFINED #if defined CGAL_CARTESIAN_H || defined CGAL_SIMPLE_CARTESIAN_H #include #endif #if defined CGAL_HOMOGENEOUS_H || defined CGAL_SIMPLE_HOMOGENEOUS_H #include #endif #include #include CGAL_BEGIN_NAMESPACE //*********************************************************************** //*********************************************************************** // PREDICATES //*********************************************************************** //*********************************************************************** //----------------------------------------------------------------------- // Orientation //----------------------------------------------------------------------- template inline Orientation ag2_orientation_test_2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, Cartesian_tag) { return ag2_orientation_test_C2(p.x(), p.y(), p.weight(), q.x(), q.y(), q.weight(), r.x(), r.y(), r.weight()); } template inline Orientation ag2_orientation_test_2(const typename K::Site_2& p, const typename K::Site_2& q, const typename K::Site_2& r, Homogeneous_tag) { CGAL_assertion( false ); return COLLINEAR; } template< class K > class AG2_Orientation_test_2 { public: typedef typename K::Site_2 Site_2; typedef Orientation result_type; typedef Arity_tag<3> Arity; inline Orientation operator()(const Site_2 &p, const Site_2 &q, const Site_2 &r) const { typedef typename K::Rep_tag Tag; return ag2_orientation_test_2(p, q, r, Tag()); } }; //----------------------------------------------------------------------- // Is hidden //----------------------------------------------------------------------- template < class K > inline bool ad_is_hidden_test_2(const typename K::Site_2& p, const typename K::Site_2& q, Cartesian_tag, Sqrt_field_tag ) { return ad_is_hidden_test_sqrtf_C2(p.x(), p.y(), p.weight(), q.x(), q.y(), q.weight()); } template < class K > inline bool ad_is_hidden_test_2(const typename K::Site_2& p, const typename K::Site_2& q, Cartesian_tag, Ring_tag ) { return ad_is_hidden_test_ring_C2(p.x(), p.y(), p.weight(), q.x(), q.y(), q.weight()); } template < class K, class Method_tag > inline bool ad_is_hidden_test_2(const typename K::Site_2& p, const typename K::Site_2& q, Homogeneous_tag) { Sign s = sign_of_ad_distance2_testH2(p.hx(), p.hy(), p.hw(), p.weight(), q.hx(), q.hy(), q.hw(), q.weight()); if ( s == POSITIVE ) { return false; } return (CGAL::compare(p.weight(), q.weight()) != SMALLER); } template < class K, class Method_tag > inline bool ad_is_hidden_test_2(const typename K::Site_2& p, const typename K::Site_2& q, Cartesian_tag tag) { return ad_is_hidden_test_2< K >(p, q, tag, Method_tag()); } template< class K, class Method_tag > class Is_hidden_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<2> Arity; inline bool operator()(const Site_2 &p, const Site_2 &q) const { typedef typename K::Rep_tag Tag; return ad_is_hidden_test_2(p, q, Tag()); } }; //----------------------------------------------------------------------- // Oriented side of bisector //----------------------------------------------------------------------- template < class K > inline Comparison_result ad_distances_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Point_2& p, Cartesian_tag, Sqrt_field_tag ) { return compare_ad_distances_test_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p.x(), p.y()); } template < class K > inline Comparison_result ad_distances_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Point_2& p, Cartesian_tag, Ring_tag) { return compare_ad_distances_test_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p.x(), p.y()); } template < class K, class Method_tag > inline Comparison_result ad_distances_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Point_2& p, Cartesian_tag tag) { return ad_distances_test_2< K >(p1, p2, p, tag, Method_tag()); } template < class K, class Method_tag > inline Comparison_result ad_distances_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Point_2& p, Homogeneous_tag ) { return compare_ad_distances_testH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), p.hx(), p.hy(), p.hw()); } template < class K, class Method_tag > inline Comparison_result ad_distances_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Point_2& p) { typedef typename K::Rep_tag Tag; return ad_distances_test_2(p1, p2, p, Tag()); } template< class K, class Method_tag > class Oriented_side_of_bisector_2 { public: typedef typename K::Point_2 Point_2; typedef typename K::Site_2 Site_2; typedef Oriented_side result_type; typedef Arity_tag<3> Arity; inline Oriented_side operator()(const Site_2& p1, const Site_2& p2, const Point_2 &p) const { Comparison_result r = ad_distances_test_2(p1, p2, p); if ( r == EQUAL ) { return ON_ORIENTED_BOUNDARY; } return ( r == LARGER ) ? ON_NEGATIVE_SIDE : ON_POSITIVE_SIDE; } }; //----------------------------------------------------------------------- // Vertex conflict //----------------------------------------------------------------------- template < class K > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, Cartesian_tag, Sqrt_field_tag ) { return ad_incircle_test_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), q.x(), q.y(), q.weight()); } template < class K > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, Cartesian_tag, Ring_tag ) { return ad_incircle_test_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), q.x(), q.y(), q.weight()); } template < class K, class Method_tag > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, Cartesian_tag tag) { return ad_incircle_test_2< K >(p1, p2, q, tag, Method_tag()); } template < class K, class Method_tag > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, Homogeneous_tag ) { return ad_incircle_testH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), q.hx(), q.hy(), q.hw(), q.weight()); } //----------------------------------------------------------------------- template < class K > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, Cartesian_tag, Sqrt_field_tag ) { return ad_incircle_test_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), q.x(), q.y(), q.weight()); } template < class K > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, Cartesian_tag, Ring_tag ) { return ad_incircle_test_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), q.x(), q.y(), q.weight()); } template < class K, class Method_tag > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, Cartesian_tag tag) { return ad_incircle_test_2< K >(p1, p2, p3, q, tag, Method_tag()); } template < class K, class Method_tag > inline Sign ad_incircle_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, Homogeneous_tag ) { return ad_incircle_testH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), p3.hx(), p3.hy(), p3.hw(), p3.weight(), q.hx(), q.hy(), q.hw(), q.weight()); } template < class K, class Method_tag > class Vertex_conflict_2 { public: typedef typename K::Site_2 Site_2; typedef Sign result_type; struct Arity {}; inline Sign operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q) const { typedef typename K::Rep_tag Tag; return ad_incircle_test_2(p1, p2, p3, q, Tag()); } inline Sign operator()(const Site_2& p1, const Site_2& p2, const Site_2& q) const { typedef typename K::Rep_tag Tag; return ad_incircle_test_2(p1, p2, q, Tag()); } }; //----------------------------------------------------------------------- // Finite edge interior conflict //----------------------------------------------------------------------- template < class K > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, bool b, Cartesian_tag, Sqrt_field_tag) { return ad_finite_edge_test_degenerated_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), q.x(), q.y(), q.weight(), b); } template < class K > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, bool b, Cartesian_tag, Ring_tag) { return ad_finite_edge_test_degenerated_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), q.x(), q.y(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, bool b, Cartesian_tag tag) { return ad_finite_edge_test_2< K >(p1, p2, q, b, tag, Method_tag()); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, bool b, Homogeneous_tag) { return ad_finite_edge_test_degeneratedH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), q.hx(), q.hy(), q.hw(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& q, bool b) { typedef typename K::Rep_tag Tag; return ad_finite_edge_test_2(p1, p2, q, b, Tag()); } //----------------------------------------------------------------------- template < class K > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, bool b, Cartesian_tag, Sqrt_field_tag) { return ad_finite_edge_test_degenerated_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), q.x(), q.y(), q.weight(), b); } template < class K > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, bool b, Cartesian_tag, Ring_tag) { return ad_finite_edge_test_degenerated_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), q.x(), q.y(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, bool b, Cartesian_tag tag) { return ad_finite_edge_test_2< K >(p1, p2, p3, q, b, tag, Method_tag()); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, bool b, Homogeneous_tag) { return ad_finite_edge_test_degeneratedH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), p3.hx(), p3.hy(), p3.hw(), p3.weight(), q.hx(), q.hy(), q.hw(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& q, bool b) { typedef typename K::Rep_tag Tag; return ad_finite_edge_test_2(p1, p2, p3, q, b, Tag()); } //----------------------------------------------------------------------- template < class K > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Cartesian_tag, Sqrt_field_tag) { return ad_finite_edge_test_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), p4.x(), p4.y(), p4.weight(), q.x(), q.y(), q.weight(), b); } template < class K > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Cartesian_tag, Ring_tag) { return ad_finite_edge_test_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), p4.x(), p4.y(), p4.weight(), q.x(), q.y(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Cartesian_tag tag) { return ad_finite_edge_test_2< K >(p1, p2, p3, p4, q, b, tag, Method_tag()); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Homogeneous_tag) { return ad_Voronoi_diagram_finite_edge_testH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), p3.hx(), p3.hy(), p3.hw(), p3.weight(), p4.hx(), p4.hy(), p4.hw(), p4.weight(), q.hx(), q.hy(), q.hw(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_finite_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b) { typedef typename K::Rep_tag Tag; return ad_finite_edge_test_2 (p1, p2, p3, p4, q, b, Tag()); } template < class K, class Method_tag > class Finite_edge_interior_conflict_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; struct Arity {}; inline bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q, bool b) const { return ad_finite_edge_test_2(p1, p2, p3, q, b); } bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& q, bool b) const { return ad_finite_edge_test_2(p1, p2, q, b); } inline bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b) const { return ad_finite_edge_test_2(p1, p2, p3, p4, q, b); } }; //----------------------------------------------------------------------- // Infinite edge interior conflict //----------------------------------------------------------------------- template < class K > inline bool ad_infinite_edge_test_2(const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Cartesian_tag, Sqrt_field_tag) { return ad_infinite_edge_test_sqrtf_C2(p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), p4.x(), p4.y(), p4.weight(), q.x(), q.y(), q.weight(), b); } template < class K > inline bool ad_infinite_edge_test_2(const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Cartesian_tag, Ring_tag) { return ad_infinite_edge_test_ring_C2(p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), p4.x(), p4.y(), p4.weight(), q.x(), q.y(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_infinite_edge_test_2(const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Cartesian_tag tag) { return ad_infinite_edge_test_2(p2, p3, p4, q, b, tag, Method_tag()); } template < class K, class Method_tag > inline bool ad_infinite_edge_test_2(const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b, Homogeneous_tag) { return ad_infinite_edge_testH2(p2.hx(), p2.hy(), p2.hw(), p2.weight(), p3.hx(), p3.hy(), p3.hw(), p3.weight(), p4.hx(), p4.hy(), p4.hw(), p4.weight(), q.hx(), q.hy(), q.hw(), q.weight(), b); } template < class K, class Method_tag > inline bool ad_infinite_edge_test_2(const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, const typename K::Site_2& q, bool b) { typedef typename K::Rep_tag Tag; return ad_infinite_edge_test_2(p2, p3, p4, q, b, Tag()); } template < class K, class Method_tag > class Infinite_edge_interior_conflict_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<5> Arity; bool operator()(const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b) const { return ad_infinite_edge_test_2(p2, p3, p4, q, b); } }; //----------------------------------------------------------------------- // Is degenerate //----------------------------------------------------------------------- template < class K > inline bool ad_is_degenerate_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, Cartesian_tag, Sqrt_field_tag) { return ad_is_degenerate_edge_test_sqrtf_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), p4.x(), p4.y(), p4.weight()); } template < class K > inline bool ad_is_degenerate_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, Cartesian_tag, Ring_tag) { return ad_is_degenerate_edge_test_ring_C2(p1.x(), p1.y(), p1.weight(), p2.x(), p2.y(), p2.weight(), p3.x(), p3.y(), p3.weight(), p4.x(), p4.y(), p4.weight()); } template < class K, class Method_tag > inline bool ad_is_degenerate_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, Cartesian_tag tag) { return ad_is_degenerate_edge_test_2< K >(p1, p2, p3, p4, tag, Method_tag()); } template < class K, class Method_tag > inline bool ad_is_degenerate_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4, Homogeneous_tag) { return ad_is_degenerate_edge_testH2(p1.hx(), p1.hy(), p1.hw(), p1.weight(), p2.hx(), p2.hy(), p2.hw(), p2.weight(), p3.hx(), p3.hy(), p3.hw(), p3.weight(), p4.hx(), p4.hy(), p4.hw(), p4.weight()); } template < class K, class Method_tag > inline bool ad_is_degenerate_edge_test_2(const typename K::Site_2& p1, const typename K::Site_2& p2, const typename K::Site_2& p3, const typename K::Site_2& p4) { typedef typename K::Rep_tag Tag; return ad_is_degenerate_edge_test_2(p1, p2, p3, p4, Tag()); } template < class K, class Method_tag > class Is_degenerate_edge_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<4> Arity; inline bool operator()(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4) const { return ad_is_degenerate_edge_test_2(p1, p2, p3, p4); } }; //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- // the Traits class //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- template < class Rep, class MTag = Ring_tag > class Apollonius_graph_traits_2 { public: //----------------------------------------------------------------------- // TYPE DEFINITIONS //----------------------------------------------------------------------- // BASIC TYPES //------------ private: typedef Apollonius_graph_traits_2 Self; typedef Apollonius_graph_kernel_wrapper_2 Kernel; public: typedef Rep R; typedef MTag Method_tag; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Site_2 Site_2; typedef typename Kernel::Line_2 Line_2; typedef typename Kernel::Ray_2 Ray_2; typedef typename Rep::Segment_2 Segment_2; typedef typename Kernel::Object_2 Object_2; typedef typename Kernel::FT FT; typedef typename Kernel::RT RT; public: // OBJECT CONSTRUCTION & ASSIGNMENT //--------------------------------- typedef typename Kernel::Construct_object_2 Construct_object_2; typedef typename Kernel::Assign_2 Assign_2; // CONSTRUCTIONS //-------------- // vertex and dual site typedef CGAL::Construct_Apollonius_vertex_2 /* */ Construct_Apollonius_vertex_2; typedef CGAL::Construct_Apollonius_site_2 /* */ Construct_Apollonius_site_2; // PREDICATES //----------- typedef CGAL::Ag2_compare_x_2 Compare_x_2; typedef CGAL::Ag2_compare_y_2 Compare_y_2; typedef CGAL::Ag2_compare_weight_2 Compare_weight_2; typedef CGAL::AG2_Orientation_test_2 Orientation_2; typedef CGAL::Is_hidden_2 Is_hidden_2; typedef CGAL::Oriented_side_of_bisector_2 /* */ Oriented_side_of_bisector_2; typedef CGAL::Vertex_conflict_2 Vertex_conflict_2; typedef CGAL::Finite_edge_interior_conflict_2 /* */ Finite_edge_interior_conflict_2; typedef CGAL::Infinite_edge_interior_conflict_2 /* */ Infinite_edge_interior_conflict_2; typedef CGAL::Is_degenerate_edge_2 Is_degenerate_edge_2; public: //----------------------------------------------------------------------- // ACCESS TO OBJECTS //----------------------------------------------------------------------- // OBJECT CONSTRUCTION & ASSIGNMENT Assign_2 assign_2_object() const { return Assign_2(); } Construct_object_2 construct_object_2_object() const { return Construct_object_2(); } // CONSTRUCTIONS //-------------- Construct_Apollonius_vertex_2 construct_Apollonius_vertex_2_object() const { return Construct_Apollonius_vertex_2(); } Construct_Apollonius_site_2 construct_Apollonius_site_2_object() const { return Construct_Apollonius_site_2(); } // PREDICATES //----------- Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Compare_weight_2 compare_weight_2_object() const { return Compare_weight_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Is_hidden_2 is_hidden_2_object() const { return Is_hidden_2(); } Oriented_side_of_bisector_2 oriented_side_of_bisector_2_object() const { return Oriented_side_of_bisector_2(); } Vertex_conflict_2 vertex_conflict_2_object() const { return Vertex_conflict_2(); } Finite_edge_interior_conflict_2 finite_edge_interior_conflict_2_object() const { return Finite_edge_interior_conflict_2(); } Infinite_edge_interior_conflict_2 infinite_edge_interior_conflict_2_object() const { return Infinite_edge_interior_conflict_2(); } Is_degenerate_edge_2 is_degenerate_edge_2_object() const { return Is_degenerate_edge_2(); } }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/kernel_to_kernel.h0000644000175000017500000000661511344301500030523 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/kernel_to_kernel.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_KERNEL_TO_KERNEL_H #define CGAL_KERNEL_TO_KERNEL_H #ifdef CGAL_USE_LEDA #include #include #include #endif CGAL_BEGIN_NAMESPACE template struct Cartesian_double_to_Homogeneous { typedef Point_2< Homogeneous< NumberType> > Point2; typedef Segment_2< Homogeneous< NumberType> > Segment; Cartesian_double_to_Homogeneous() {} Point2 operator()( const Point_2 >& p) const { return Point2( NumberType(p.x()), NumberType(p.y()) ); } Segment operator()( const Segment_2 >& s) const { return Segment( Point2( NumberType(s.source().x()), NumberType(s.source().y()) ), Point2( NumberType(s.target().x()), NumberType(s.target().y()) ) ); } }; #ifdef CGAL_USE_LEDA struct Cartesian_double_to_H_double_int { typedef Point_2< Homogeneous< double> > Point2; typedef Segment_2< Homogeneous< double> > Segment; Segment operator()( const Segment_2< Cartesian< double> >& s) const { leda_rat_point rs = leda_point(s.source().x(), s.source().y()); leda_rat_point rt = leda_point(s.target().x(), s.target().y()); return Segment( Point2(CGAL_LEDA_SCOPE::to_double(rs.X()), CGAL_LEDA_SCOPE::to_double(rs.Y()), CGAL_LEDA_SCOPE::to_double(rs.W())), Point2(CGAL_LEDA_SCOPE::to_double(rt.X()), CGAL_LEDA_SCOPE::to_double(rt.Y()), CGAL_LEDA_SCOPE::to_double(rt.W())) ); } }; struct Cartesian_float_to_H_double_int { typedef Point_2< Homogeneous< double> > Point2; typedef Segment_2< Homogeneous< double> > Segment; Segment operator()( const Segment_2< Cartesian< float> >& s) const { leda_rat_point rs = leda_point(s.source().x(), s.source().y()); leda_rat_point rt = leda_point(s.target().x(), s.target().y()); return Segment( Point2(CGAL_LEDA_SCOPE::to_double(rs.X()), CGAL_LEDA_SCOPE::to_double(rs.Y()), CGAL_LEDA_SCOPE::to_double(rs.W())), Point2(CGAL_LEDA_SCOPE::to_double(rt.X()), CGAL_LEDA_SCOPE::to_double(rt.Y()), CGAL_LEDA_SCOPE::to_double(rt.W())) ); } }; #endif // CGAL_USE_LEDA CGAL_END_NAMESPACE #endif // CGAL_KERNEL_TO_KERNEL_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000000570511344301500031452 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_REGULAR_TRIANGULATION_VERTEX_BASE_2_H #define CGAL_REGULAR_TRIANGULATION_VERTEX_BASE_2_H #include CGAL_BEGIN_NAMESPACE template < class GT, class Vb = Triangulation_ds_vertex_base_2<> > class Regular_triangulation_vertex_base_2 : public Vb { typedef typename Vb::Triangulation_data_structure TDS; public: typedef GT Geom_traits; typedef typename GT::Point_2 Bare_point; typedef typename GT::Weighted_point_2 Weighted_point; typedef Weighted_point Point; typedef TDS Triangulation_data_structure; typedef typename TDS::Face_handle Face_handle; typedef typename TDS::Vertex_handle Vertex_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Regular_triangulation_vertex_base_2 Other; }; private: Weighted_point _p; bool _hidden; public: Regular_triangulation_vertex_base_2 () : Vb(), _hidden(false) {} Regular_triangulation_vertex_base_2(const Weighted_point & p) : Vb(), _p(p), _hidden(false) {} Regular_triangulation_vertex_base_2(const Weighted_point & p, Face_handle f) : Vb(f),_p(p), _hidden(false) {} void set_hidden(bool b) { _hidden = b; } bool is_hidden() { return _hidden ;} void set_point(const Weighted_point & p) { _p = p; } const Weighted_point& point() const { return _p; } //Weighted_point& point() const { return _p; } bool is_valid(bool /* verbose */ = false, int /* level */ = 0) const {return true;} }; template < class GT, class Vb > std::istream& operator>>(std::istream &is, Regular_triangulation_vertex_base_2 &v) // non combinatorial information. Default = point { return is >> static_cast(v) >> v.point(); } template < class GT, class Vb > std::ostream& operator<<(std::ostream &os, const Regular_triangulation_vertex_base_2 &v) // non combinatorial information. Default = point { return os << static_cast(v) << v.point(); } CGAL_END_NAMESPACE #endif //CGAL_REGULAR_TRIANGULATION_VERTEX_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Dynamic_matrix.h0000644000175000017500000000650211344301500030144 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Dynamic_matrix.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_DYNAMIC_MATRIX_H) #define CGAL_DYNAMIC_MATRIX_H 1 #include CGAL_BEGIN_NAMESPACE template < class Matrix > class Dynamic_matrix // adaptor for a matrix class // to allow replacement of columns in constant time // and extraction of all even rows in linear time { public: typedef std::vector< int > CoordContainer; typedef Dynamic_matrix< Matrix > ThisMatrixClass; typedef typename Matrix::Value Value; Dynamic_matrix( const Matrix& m, int r_p = 0) : matrix( &m), column_indices( m.number_of_columns()), row_power( r_p), row_offset( (1 << r_p) - 1) { for ( unsigned int i( 0); i < column_indices.size(); ++i) column_indices[i] = i; } int number_of_rows() const { return ( matrix->number_of_rows() + row_offset) >> row_power; } int number_of_columns() const { return column_indices.size(); } Value operator()( int r, int c) const { CGAL_optimisation_precondition( r >= 0 && r < number_of_rows()); CGAL_optimisation_precondition( c >= 0 && c < number_of_columns()); return (*matrix)( r << row_power, column_indices[c]); } Value operator()( std::pair< int, int > p) const { return (*this)( p.first, p.second); } void replace_column( int o, int n) { CGAL_optimisation_precondition( o >= 0 && o < number_of_columns()); CGAL_optimisation_precondition( n >= 0 && n < number_of_columns()); column_indices[o] = column_indices[n]; } void shrink_to_quadratic_size() { CGAL_optimisation_precondition( number_of_columns() >= number_of_rows()); column_indices.erase( column_indices.begin() + number_of_rows(), column_indices.end()); CGAL_optimisation_postcondition( number_of_columns() == number_of_rows()); } private: Dynamic_matrix( const Matrix* m, const CoordContainer& c_i, int r_p) : matrix( m), column_indices( c_i), row_power( r_p), row_offset( (1 << r_p) - 1) {} public: ThisMatrixClass* extract_all_even_rows() const { return new ThisMatrixClass( matrix, column_indices, row_power + 1); } private: const Matrix* matrix; CoordContainer column_indices; int row_power; int row_offset; }; template < class Matrix > inline Dynamic_matrix< Matrix > dynamic_matrix( const Matrix& m) { return Dynamic_matrix< Matrix >( m); } CGAL_END_NAMESPACE #endif // ! (CGAL_DYNAMIC_MATRIX_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_with_intersections.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_with_intersections.0000644000175000017500000014356011344301500031412 0ustar debiandebian// Copyright (c) 2000 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_with_intersections.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Eyal flato #ifndef CGAL_PLANAR_MAP_WITH_INTERSECTIONS_H #define CGAL_PLANAR_MAP_WITH_INTERSECTIONS_H #include #include #ifndef CGAL_NO_PM_DEFAULT_POINT_LOCATION #include #endif #include #include #include #ifndef CGAL_PM_COUNT_OPERATIONS_TIMES #define CGAL_PM_START_OP(x) #define CGAL_PM_END_OP(x) #define CGAL_DEFINE_COUNT_OP_TIMES_OBJECT #endif #if defined(CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG) #define CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG(msg) std::cout << msg; #define CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_CODE(code) code #else #define CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG(msg) #define CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_CODE(code) #endif CGAL_BEGIN_NAMESPACE template class Planar_map_with_intersections_2 : public Planar_map_ { public: typedef Planar_map_ Planar_map; typedef Planar_map_with_intersections_2 Self; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Traits_wrap Pm_traits_wrap; typedef Planar_map_with_intersections_traits_wrap Pmwx_traits_wrap; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::Point_2 Point_2; typedef typename Planar_map::Change_notification Change_notification; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; // Obsolete, for backward compatability typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; typedef Change_notification Pmwx_change_notification; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Planar_map::traits; using Planar_map::halfedges_end; using Planar_map::halfedges_begin; using Planar_map::unbounded_face; using Planar_map::pl; #endif CGAL_DEFINE_COUNT_OP_TIMES_OBJECT // Constructors // ------------ Planar_map_with_intersections_2() : #ifndef CGAL_NO_PM_DEFAULT_POINT_LOCATION Planar_map(new Pmwx_traits_wrap, new Pm_walk_along_line_point_location, NULL), #else Planar_map(new Pmwx_traits_wrap, NULL, NULL), #endif pmwx_use_delete_traits(true), pmwx_use_delete_pl(true) { pmwx_traits = (Pmwx_traits_wrap*)traits; } Planar_map_with_intersections_2(Pm_point_location_base *pl_ptr) : Planar_map(new Pmwx_traits_wrap, pl_ptr, NULL), pmwx_use_delete_traits(true), pmwx_use_delete_pl(false) { pmwx_traits = (Pmwx_traits_wrap*)traits; } Planar_map_with_intersections_2(const Traits& tr_, Pm_point_location_base *pl_ptr) : Planar_map(new Pmwx_traits_wrap(tr_), pl_ptr, NULL), pmwx_use_delete_traits(true), pmwx_use_delete_pl(false) { pmwx_traits = (Pmwx_traits_wrap*)traits; } Planar_map_with_intersections_2(Pmwx_traits_wrap *tr_ptr, Pm_point_location_base *pl_ptr) : Planar_map(tr_ptr, pl_ptr, NULL), pmwx_use_delete_traits(false), pmwx_use_delete_pl(false) { pmwx_traits = (Pmwx_traits_wrap*)traits; } /*! Copy Constructor */ Planar_map_with_intersections_2(const Self & rhs); /*! Planar_map converter */ Planar_map_with_intersections_2(const Planar_map & pm); /*! Destructor */ ~Planar_map_with_intersections_2(); // Operations // ---------- /*! Obtain the supporting curve of the given halfedge * \param he the halfedge * \param en the notification object * \return the supporting curve of he if exists */ const X_monotone_curve_2 & curve(Halfedge_handle he, Change_notification * en) { if (en == NULL) return he->curve(); if (!en->have_support_curve()) return he->curve(); return en->edge_support_curve(he); } // finds the intersection of directed with the // halfedge . The returned intersections is based on the intersection // of the supporting curves (if they exist). bool directed_nearest_intersection_with_halfedge(const X_monotone_curve_2 & cv, Halfedge_handle he, const Point_2 & ref_point, bool direction_right, Point_2 & xp1, Point_2 & xp2, X_monotone_curve_2 & overlap_cv, Change_notification * en) { Object res = (direction_right) ? pmwx_traits->nearest_intersection_to_right(cv, curve(he, en), ref_point) : pmwx_traits->nearest_intersection_to_left(cv, curve(he, en), ref_point); if (res.is_empty()) return (false); /* * check for an intersection on the real curves. assume there is none. * * since we are checking on the parent, we should make sure that the * intersection point is on the halfedge_cv and not only on the parent. * do not worry: we will get the same intersection point for the correct * halfedge_cv as well, and therefore we can throw it away if it's * not on halfedge_cv * no need to check for cv because the checked side of it is not * in the arrangement yet so there is no possibility for an * intersection point not on cv. */ const X_monotone_curve_2 & he_cv = he->curve(); if (CGAL::assign(xp1, res)) { // The intersection is a point: xp2 = xp1; //! \todo is this really needed? if (traits->point_in_x_range(he_cv, xp1) && traits->curve_compare_y_at_x(xp1, he_cv) == EQUAL) { return true; } return false; } if (CGAL::assign(overlap_cv, res)) { // There is an overlap, the intersection is a subcurve: xp1 = pmwx_traits->curve_source(overlap_cv); xp2 = pmwx_traits->curve_target(overlap_cv); if (!is_left_low(xp1, xp2)) std::swap(xp1, xp2); Point_2 left_point = traits->point_leftlow_most(pmwx_traits->curve_source(he_cv), pmwx_traits->curve_target(he_cv)); Point_2 right_point = traits->point_righttop_most(pmwx_traits->curve_source(he_cv), pmwx_traits->curve_target(he_cv)); if (is_left_low(xp1, left_point)) xp1 = left_point; if (is_left_low(right_point, xp2)) xp2 = right_point; if (is_left_low(xp1, xp2)) return (true); return (false); } return (false); } // input: cv.source is on vh // is_overlap is true if cv overlaps prev_halfedge around vh. void find_face_of_curve_around_vertex(const X_monotone_curve_2 & cv, const X_monotone_curve_2 & orig_cv, const Vertex_handle & vh, Halfedge_handle & prev_halfedge, Point_2 & overlap_end_pt, bool & is_overlap, X_monotone_curve_2 & overlap_cv, Change_notification * en) { CGAL_PM_START_OP(1); typename Planar_map::Halfedge_around_vertex_circulator next, prev, start, last_next_checked; X_monotone_curve_2 xcv; Point_2 xp1, xp2; const Point_2 & source_point = pmwx_traits->curve_source(cv); const Point_2 & target_point = pmwx_traits->curve_target(cv); bool direction_right = is_left_low(source_point, target_point); bool b; last_next_checked = halfedges_end(); start = vh->incident_halfedges(); prev = start; next = prev; ++next; do { if ((last_next_checked != prev) && (traits->curves_overlap(cv, prev->curve()))) { // cv overlapps prev->curve() b = directed_nearest_intersection_with_halfedge(orig_cv, prev, source_point, direction_right, xp1, xp2, overlap_cv, en); // Verify that there is indeed an intersection CGAL_assertion(b); // Verify that there is indeed an overlap CGAL_assertion(!point_equal(xp1, xp2)); // the overlapping part might not start from the source // vertex (in polyline for example), so if this is the case, // we ignore the overlap. if ((point_equal(xp1, source_point)) || (point_equal(xp2, source_point))) { if (point_equal(vh->point(), xp1)) { overlap_end_pt = xp2; } else { CGAL_assertion(point_equal(vh->point(), xp2)); overlap_end_pt = xp1; } prev_halfedge = prev; is_overlap = true; CGAL_PM_END_OP(1); return; } } // Same check as above is done now to next->curve() to prevent // unexpected behavior of is_between_cw when one of the curves // overlaps at vh. // last_next_checked is set to next so if the test fails // (namely, there is no overlap at vh) then it will not // be executed again at the next loop when prev will be this // next. this is for efficiency only. if (traits->curves_overlap(cv, next->curve())) { last_next_checked = next; // cv overlapps next->curve() b = directed_nearest_intersection_with_halfedge(orig_cv, next, source_point, direction_right, xp1, xp2, overlap_cv, en); // Verify that there is indeed an intersection CGAL_assertion(b); // Verify that there is indeed an overlap CGAL_assertion(!point_equal(xp1, xp2)); // the overlapping part might not start from the source // vertex (in polyline for example), so if this is the case, // we ignore the overlap. if ((point_equal(xp1, source_point)) || (point_equal(xp2, source_point))) { if (point_equal(vh->point(), xp1)) { overlap_end_pt = xp2; } else { CGAL_assertion(point_equal(vh->point(), xp2)); overlap_end_pt = xp1; } prev_halfedge = next; is_overlap = true; CGAL_PM_END_OP(1); return; } } /////////***** Eyal end // The following remarked test is not fully correct // since there can be an overlap that does not start at vh // but elsewhere on cv (e.g., polylines). // this condition is redundant if curve_is_between_cw does // not return true when overlap occurs, but it is needed // since it is not a defined behaviour (in specs). //// if (!traits->curves_overlap(cv, next->curve())) ---- if (next != prev) { if ((pmwx_traits->curve_is_between_cw(cv, prev->curve(), next->curve(), vh->point()))) { prev_halfedge = prev; is_overlap = false; CGAL_PM_END_OP(1); return; } } ++next; ++prev; } while (prev != start); // assuming no overlapping occurs, the only situation in // which we reached this line is when there is only one // edge from vh CGAL_assertion(next == prev); prev_halfedge = prev; is_overlap = false; CGAL_PM_END_OP(1); return; } /*! Find the first intersection in the direction cv.source --> cv.target * in . * The returned is the intersection curve of * and 's boundary. * returned is the halfedge on which the intersection occurs, * in case of intersection-point halfedge->source will contain this point * \return false if no intersection is found and true otherwise. */ bool find_first_intersection_in_face(const Face_handle & face, const X_monotone_curve_2 & cv, const X_monotone_curve_2 & orig_cv, Halfedge_handle & halfedge, Point_2 & best_xpnt1, Point_2 & best_xpnt2, Change_notification * en) { CGAL_PM_START_OP(2); Halfedge_handle best_halfedge_x; typename Planar_map::Ccb_halfedge_circulator che, che_beg; Point_2 xpnt, xp1, xp2; bool b, better_xcv; bool intersection_exist = false; const Point_2 & source_point = pmwx_traits->curve_source(cv); const Point_2 & target_point = pmwx_traits->curve_target(cv); bool direction_right = is_left_low(source_point, target_point); Point_2 best_point = pmwx_traits->curve_target(cv); if (!face->is_unbounded()) { che = face->outer_ccb(); che_beg = che; do { if (intersection_exist) { // optimization: comparing the // endpoints of the halfedge and the best intersection // point found so far, Improve performance. if (direction_right) { if (!is_left(leftmost(che->source()->point(), che->target()->point()), best_point)) { ++che; continue; } } else { if (!is_right(rightmost(che->source()->point(), che->target()->point()), best_point)) { ++che; continue; } } } // optimization: checking the x-range, Highly improve performance. if (!in_x_range(orig_cv,che->curve())) { ++che; continue; } X_monotone_curve_2 overlap_cv; b = directed_nearest_intersection_with_halfedge(orig_cv, che, source_point, direction_right, xp1, xp2, overlap_cv, en); if (b) { // direct xp1-xp2 to be like cv if (direction_right) { if (!is_left_low(xp1, xp2)) std::swap(xp1, xp2); } else { if (!is_right_top(xp1, xp2)) std::swap(xp1, xp2); } xpnt = xp1; if (direction_right) better_xcv = is_left_low(xpnt, best_point); else better_xcv = is_right_top(xpnt, best_point); if (better_xcv || (!intersection_exist)) { // xcv is better best_halfedge_x = che; best_point = xpnt; best_xpnt1 = xp1; best_xpnt2 = xp2; intersection_exist = true; } } ++che; } while (che != che_beg); } //if (intersection_exist) // { // halfedge = best_halfedge_x; // CGAL_PM_END_OP(2); // return intersection_exist; // } typename Planar_map::Holes_iterator holes; for (holes = face->holes_begin(); holes != face->holes_end(); holes++) { che = *holes; che_beg = che; do { if (intersection_exist) { if (direction_right) { if (!(is_left_low(leftmost(che->source()->point(), che->target()->point()), best_point))) { ++che; continue; } } else { if (!(is_right_top(rightmost(che->source()->point(), che->target()->point()), best_point))) { ++che; continue; } } } if (!in_x_range(orig_cv,che->curve())) { ++che; continue; } X_monotone_curve_2 overlap_cv; b = directed_nearest_intersection_with_halfedge(orig_cv, che, source_point, direction_right, xp1, xp2, overlap_cv, en); if (b) { // direct xp1-xp2 to be like cv if (direction_right) { if (!is_left_low(xp1, xp2)) std::swap(xp1, xp2); } else { if (!is_right_top(xp1, xp2)) std::swap(xp1, xp2); } xpnt = xp1; if (direction_right) better_xcv = is_left_low(xpnt, best_point); else better_xcv = is_right_top(xpnt, best_point); if (better_xcv || (!intersection_exist)) { // xcv is better best_halfedge_x = che; best_point = xpnt; best_xpnt1 = xp1; best_xpnt2 = xp2; intersection_exist = true; } } ++che; } while (che != che_beg); } halfedge = best_halfedge_x; CGAL_PM_END_OP(2); return intersection_exist; } /*! */ void get_vertex_of_point_on_halfedge ( const Point_2 &point, Halfedge_handle halfedge, Vertex_handle &vertex_of_point, // in case of split it is easy to compute: Halfedge_handle &vertex_of_point_prev_halfedge, // true if vertex_of_point_prev_halfedge is set : bool &vertex_of_point_prev_halfedge_set, Change_notification *en) { CGAL_PM_START_OP(3); if (point_equal(point, halfedge->source()->point())) { vertex_of_point = halfedge->source(); vertex_of_point_prev_halfedge_set = false; } else if (point_equal(point, halfedge->target()->point())) { vertex_of_point = halfedge->target(); vertex_of_point_prev_halfedge_set = false; } else { // intersection in the interior - split X_monotone_curve_2 split1, split2; Halfedge_handle he_split; if (point_equal(halfedge->source()->point(), pmwx_traits->curve_source(halfedge->curve()))) { pmwx_traits->directed_curve_split(halfedge->curve(), halfedge->source()->point(), point, split1, split2); he_split = Planar_map::split_edge(halfedge, split1, split2); if (en != NULL) en->split_edge(he_split, he_split->next_halfedge(), split1, split2); vertex_of_point = he_split->target(); vertex_of_point_prev_halfedge = he_split->next_halfedge()->twin(); vertex_of_point_prev_halfedge_set = true; } else { Halfedge_handle twin_halfedge = halfedge->twin(); pmwx_traits->directed_curve_split(twin_halfedge->curve(), twin_halfedge->source()->point(), point, split1, split2); he_split = Planar_map::split_edge(twin_halfedge, split1, split2); if (en != NULL) en->split_edge(he_split, he_split->next_halfedge(), split1, split2); // change he_split to be on the current face becase we spliited // the twin_halfedge and not halfedge - this is to be // consistent with // the arrangement code that is based on the fact the the // splitted halfedge // is the one that is directed like the curve he_split = he_split->next_halfedge()->twin(); vertex_of_point = he_split->target(); vertex_of_point_prev_halfedge = he_split->next_halfedge()->twin(); vertex_of_point_prev_halfedge_set = true; } } // in order to enable polyline overlap // (a little ugly solution. should be made nicer) : vertex_of_point_prev_halfedge_set = false; CGAL_PM_END_OP(3); } /*! Insert the first part of cv into the face source_face * returning: * 1. inserted edge * 2. remaining curve (the part that was not inserted) * 3. remaining curve source vertex */ void insert_intersecting_xcurve_in_face_interior (const X_monotone_curve_2 & cv, // inserted curve const X_monotone_curve_2 & orig_cv, Face_handle source_face, Halfedge_handle & inserted_halfedge, bool & remaining_curve_trivial, X_monotone_curve_2 & remaining_curve, Vertex_handle & remaining_curve_source_vertex, // in case of split it is easy to compute : Halfedge_handle & remaining_curve_prev_halfedge, // true if remaining_curve_face is set : bool &remaining_curve_prev_halfedge_set, Change_notification * en) { CGAL_PM_START_OP(4); remaining_curve_trivial = false; //std::cout << "iisifi " // << "insert_intersecting_xcurve_in_face_interior: " << cv << std::endl; Halfedge_handle intersection_he; Point_2 xpnt1, xpnt2; if (find_first_intersection_in_face(source_face, cv, orig_cv, intersection_he, xpnt1, xpnt2, en)) { Point_2 insert_point; X_monotone_curve_2 cv_first_part; bool direction_right = is_left_low(pmwx_traits->curve_source(cv), pmwx_traits->curve_target(cv)); insert_point = (direction_right) ? pmwx_traits->point_leftlow_most(xpnt1, xpnt2) : pmwx_traits->point_righttop_most(xpnt1, xpnt2); CGAL_assertion(!point_equal(pmwx_traits->curve_source(cv), insert_point)); remaining_curve_trivial = point_equal(pmwx_traits->curve_target(cv), insert_point); if (remaining_curve_trivial) cv_first_part = cv; else pmwx_traits->directed_curve_split(cv, pmwx_traits->curve_source(cv), insert_point, cv_first_part, remaining_curve); CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_CODE( std::cout << "cv " << cv << std::endl; std::cout << "xpnt1 " << xpnt1 << std::endl; std::cout << "xpnt2 " << xpnt2 << std::endl; std::cout << "insert_point " << insert_point << std::endl; std::cout << "cv_first_part " << cv_first_part << std::endl; std::cout << "remaining_curve " << remaining_curve << std::endl; std::cout << "intersection_he->curve() " << intersection_he->curve() << std::endl; ); get_vertex_of_point_on_halfedge(insert_point, intersection_he, remaining_curve_source_vertex, remaining_curve_prev_halfedge, remaining_curve_prev_halfedge_set, en); inserted_halfedge = Planar_map::insert_from_vertex(cv_first_part, remaining_curve_source_vertex); if (en != NULL) en->add_edge(cv_first_part, inserted_halfedge, false, false); CGAL_PM_END_OP(4); return; } inserted_halfedge = Planar_map::insert_in_face_interior(cv, source_face); if (en != NULL) { en->add_edge(cv, inserted_halfedge, true, false); en->add_hole(source_face, inserted_halfedge); } //std::cout << "iisifi inserted_halfedge " // << inserted_halfedge->source()->point() << // " ----> " << inserted_halfedge->target()->point() << std::endl; if (point_equal(inserted_halfedge->source()->point(), pmwx_traits->curve_source(cv))) remaining_curve_source_vertex = inserted_halfedge->target(); else remaining_curve_source_vertex = inserted_halfedge->source(); remaining_curve_trivial = true; remaining_curve_prev_halfedge_set = false; CGAL_PM_END_OP(4); } // source_prev_halfedge->face() is the face we are working on // source_prev_halfedge->target() is the vertex on whice cv's source is // assuming cv does not overlap an edge from source_prev_halfedge->target() // insert the first part of cv into face where cv's source is on the // boundary of face // returning: // 1. inserted edge // 2. remaining curve (the part that was not inserted) // 3. remaining curve source vertex void insert_intersecting_xcurve_from_boundary_of_face (const X_monotone_curve_2 & cv, // inserted curve const X_monotone_curve_2 & orig_cv, Halfedge_handle source_prev_halfedge, Halfedge_handle & inserted_halfedge, bool & remaining_curve_trivial, X_monotone_curve_2 & remaining_curve, Vertex_handle & remaining_curve_source_vertex, // in case of split it is easy to compute : Halfedge_handle & remaining_curve_prev_halfedge, // true if remaining_curve_face is set : bool &remaining_curve_prev_halfedge_set, Change_notification * en) { CGAL_PM_START_OP(5); remaining_curve_trivial = false; //std::cout << "iifbof " // << "insert_intersecting_xcurve_from_boundary_of_face: " // << cv << std::endl; //std::cout << "iifbof " // << " source_prev_halfedge: " // << source_prev_halfedge->source()->point() << // " ----> " << source_prev_halfedge->target()->point() << std::endl; Halfedge_handle intersection_he; Point_2 xpnt1, xpnt2; Face_handle orig_face = source_prev_halfedge->face(); if (find_first_intersection_in_face(source_prev_halfedge->face(), cv, orig_cv, intersection_he, xpnt1, xpnt2, en)) { Point_2 insert_point; X_monotone_curve_2 cv_first_part; // keep the source vertex. We can't rely on // source_prev_halfedge->target() because it might be changed if // source_prev_halfedge is intersected by the new curve Vertex_handle source_vertex(source_prev_halfedge->target()); bool direction_right = is_left_low(pmwx_traits->curve_source(cv), pmwx_traits->curve_target(cv)); insert_point = (direction_right) ? pmwx_traits->point_leftlow_most(xpnt1, xpnt2) : pmwx_traits->point_righttop_most(xpnt1, xpnt2); CGAL_assertion(!point_equal(pmwx_traits->curve_source(cv), insert_point)); remaining_curve_trivial = point_equal(pmwx_traits->curve_target(cv), insert_point); if (remaining_curve_trivial) cv_first_part = cv; else pmwx_traits->directed_curve_split(cv, pmwx_traits->curve_source(cv), insert_point, cv_first_part, remaining_curve); get_vertex_of_point_on_halfedge(insert_point, intersection_he, remaining_curve_source_vertex, remaining_curve_prev_halfedge, remaining_curve_prev_halfedge_set, en); //std::cout << "iifbob " << "insert_at_vertices: " << // cv_first_part << // " vx1: "<< source_prev_halfedge->target()->point() << // " prev_src: "<< source_prev_halfedge->source()->point() << // " vx2: "<< remaining_curve_source_vertex->point() << std::endl; CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_CODE( std::cout << "cv " << cv << std::endl; std::cout << "xpnt1 " << xpnt1 << std::endl; std::cout << "xpnt2 " << xpnt2 << std::endl; std::cout << "insert_point " << insert_point << std::endl; std::cout << "cv_first_part " << cv_first_part << std::endl; std::cout << "remaining_curve " << remaining_curve << std::endl; std::cout << "intersection_he->curve() " << intersection_he->curve() << std::endl; ); inserted_halfedge = Planar_map::insert_at_vertices(cv_first_part, source_vertex, remaining_curve_source_vertex); if (en != NULL) { en->add_edge(cv_first_part, inserted_halfedge, true, false); if (inserted_halfedge->face() == orig_face) en->split_face(inserted_halfedge->face(), inserted_halfedge->twin()->face()); else en->split_face(inserted_halfedge->twin()->face(), inserted_halfedge->face()); } CGAL_PM_END_OP(5); return; } inserted_halfedge = Planar_map::insert_from_vertex(cv, source_prev_halfedge->target()); if (en != NULL) en->add_edge(cv, inserted_halfedge,true, false); if (point_equal(inserted_halfedge->source()->point(), pmwx_traits->curve_source(cv))) remaining_curve_source_vertex = inserted_halfedge->target(); else remaining_curve_source_vertex = inserted_halfedge->source(); remaining_curve_trivial = true; remaining_curve_prev_halfedge_set = false; CGAL_PM_END_OP(5); } /*! */ Halfedge_handle insert_intersecting_xcurve(const X_monotone_curve_2 & cv_, // inserted curve Vertex_handle & source_vertex, // to be set by the function : Vertex_handle & target_vertex, bool source_valid, Change_notification * en = NULL) { CGAL_PM_START_OP(6); //if a vertex on which an endpoint of cv_ is known then set cv to //have this endpoint as it's source // at the end source_vertex and target_vertex will contain the // end-vertices of cv Vertex_handle curr_vertex = source_vertex; X_monotone_curve_2 cv = cv_; X_monotone_curve_2 orig_cv = cv; X_monotone_curve_2 split1, split2; Point_2 overlap_end_pt; Halfedge_handle inserted_he, prev_halfedge, last_edge; bool is_overlap; bool next_face_valid = false; bool remaining_curve_trivial = false; const Point_2 & source_point = pmwx_traits->curve_source(cv); if (!source_valid) { /* If the source is invalid, we need to locate the source if exists, * or create it by splitting an existing halfedge or insertion of the * new curve */ CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("!"); typename Planar_map::Locate_type lt; Halfedge_handle he; //-- locate pmwx_traits->curve_source(cv) CGAL_PM_START_OP(7); he = locate(source_point, lt); CGAL_PM_END_OP(7); if (lt == Planar_map::VERTEX) { // The source point exists! We simply set the source appropriately source_vertex = he->target(); curr_vertex = source_vertex; } else if (lt == Planar_map::EDGE) { /* The source point does not exist, but it lies on an existng * halfedge. In this case we split the halfedge and set the source * vertex appropriately */ Halfedge_handle he_split; X_monotone_curve_2 split1, split2; if (point_equal(he->source()->point(), pmwx_traits->curve_source(he->curve()))) { pmwx_traits->directed_curve_split(he->curve(), he->source()->point(), source_point, split1, split2); he_split = Planar_map::split_edge(he, split1, split2); } else { Halfedge_handle twin_he = he->twin(); pmwx_traits->directed_curve_split(twin_he->curve(), twin_he->source()->point(), source_point, split1, split2); he_split = Planar_map::split_edge(twin_he, split1, split2); } if (en != NULL) en->split_edge(he_split, he_split->next_halfedge(), split1, split2); source_vertex = he_split->target(); curr_vertex = source_vertex; } else { // The source point lies inside the unbounded or a general face. Face_handle face = (lt == Planar_map::UNBOUNDED_FACE) ? unbounded_face() : he->face(); // insert_intersecting_xcurve_in_face_interior(curr_vertex) X_monotone_curve_2 remaining_curve; insert_intersecting_xcurve_in_face_interior(cv, orig_cv, face, inserted_he, remaining_curve_trivial, remaining_curve, curr_vertex, prev_halfedge, next_face_valid, en); if (!remaining_curve_trivial) cv = remaining_curve; last_edge = inserted_he; target_vertex = curr_vertex; // temporary - can be changed later source_vertex = (inserted_he->source() == curr_vertex) ? inserted_he->target() : inserted_he->source(); //inserted_edges.push_back(inserted_he); } // by now: curr_vertex and source_vertex are set } while (!remaining_curve_trivial) { CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("@"); Halfedge_handle he_split; X_monotone_curve_2 split1, split2; if (!next_face_valid) { CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("#"); //-- locate cv around curr_vertex //std::cout << "iis " << " ---- curr_vertex: " //<< curr_vertex->point() << std::endl; X_monotone_curve_2 overlap_cv; find_face_of_curve_around_vertex(cv, orig_cv, curr_vertex, prev_halfedge, overlap_end_pt, is_overlap, overlap_cv, en); //std::cout << "iis " << " ---- prev_halfedge: " //<< prev_halfedge->source()->point() << // " ----> " << prev_halfedge->target()->point() << std::endl; if (is_overlap) { // if overlaps an edge from curr_vertex CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("$"); // rem: prev_halfedge->target == curr_vertex if (point_equal(prev_halfedge->source()->point(), overlap_end_pt)) { // whole edge is overlapped, proceed to its other end CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("%"); if (en != NULL) en->add_edge(overlap_cv, prev_halfedge, false, true); last_edge = prev_halfedge; // update cv CGAL_assertion(point_equal(pmwx_traits->curve_source(cv), curr_vertex->point())); remaining_curve_trivial = point_equal(pmwx_traits->curve_target(cv), prev_halfedge->source()->point()); if (!remaining_curve_trivial) { pmwx_traits->directed_curve_split(cv, curr_vertex->point(), prev_halfedge->source()->point(), split1, split2); cv = split2; } curr_vertex = prev_halfedge->source(); } else { // otherwise - split prev_halfedge and let curr_vertex //be the splitting point CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("^"); if (point_equal(prev_halfedge->twin()->source()->point(), pmwx_traits->curve_source(prev_halfedge->twin() ->curve()))) { pmwx_traits->directed_curve_split(prev_halfedge->curve(), curr_vertex->point(), overlap_end_pt, split1, split2); // split prev_halfedge->twin() so that the splitted edge // source will be the same as split1's source he_split = Planar_map::split_edge(prev_halfedge->twin(), split1, split2); if (en != NULL) { en->split_edge(he_split, he_split->next_halfedge(), split1, split2); en->add_edge(overlap_cv, he_split, true, true); } last_edge = he_split; // update cv remaining_curve_trivial = point_equal(pmwx_traits->curve_target(cv), he_split->target()->point()); if (!remaining_curve_trivial) { pmwx_traits->directed_curve_split(cv, pmwx_traits-> curve_source(cv), he_split->target()->point(), split1, split2); cv = split2; } curr_vertex = he_split->target(); } else { pmwx_traits-> directed_curve_split(prev_halfedge->twin()->curve(), pmwx_traits-> curve_source(prev_halfedge->twin()-> curve()), overlap_end_pt, split1, split2); // split prev_halfedge->twin() so that the splitted // edge // source will be the same as split1's source he_split = Planar_map::split_edge(prev_halfedge, split1, split2); if (en != NULL) { en->split_edge(he_split, he_split->next_halfedge(), split1, split2); en->add_edge(overlap_cv, he_split->next_halfedge()->twin(), true, true); } last_edge = he_split->next_halfedge()->twin(); // update cv remaining_curve_trivial = point_equal(pmwx_traits->curve_target(cv), he_split-> next_halfedge()->twin()->target()->point()); if (!remaining_curve_trivial) { pmwx_traits->directed_curve_split(cv, pmwx_traits-> curve_source(cv), he_split->next_halfedge()-> twin()->target()->point(), split1, split2); cv = split2; } curr_vertex = he_split->next_halfedge()->twin()->target(); } } target_vertex = curr_vertex; // temporary -can be changed later next_face_valid = false; continue; } // if not overlap then in face next_face_valid = true; } // now - we are sure that cv is in the interior of // prev_halfedge->face (does not overlaps an halfedge around // curr_vertex) CGAL_PM_WITH_INTERSECTIONS_PRINT_DEBUG_MSG("&"); X_monotone_curve_2 remaining_curve; insert_intersecting_xcurve_from_boundary_of_face(cv, orig_cv, prev_halfedge, inserted_he, remaining_curve_trivial, remaining_curve, curr_vertex, prev_halfedge, next_face_valid, en); if (!remaining_curve_trivial) cv = remaining_curve; last_edge = inserted_he; target_vertex = curr_vertex; // temporary - can be changed later } if (!point_equal(last_edge->target()->point(), pmwx_traits->curve_target(cv_))) last_edge = last_edge->twin(); CGAL_PM_END_OP(6); return last_edge; } /*! Insert a given curve into the map. One of its endpoints is conditionally * the mapping of a given vertex */ Halfedge_handle insert_intersecting_curve(const Curve_2 & c, Vertex_handle & source_vertex, bool source_valid, Change_notification * en = NULL) { typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef std::list X_monotone_curve_list; typedef typename X_monotone_curve_list::const_iterator X_monotone_curve_iter; Vertex_handle src = source_vertex; Vertex_handle trg; Halfedge_handle last_he; X_monotone_curve_list x_list; traits->curve_make_x_monotone(c, std::back_inserter(x_list)); X_monotone_curve_iter it = x_list.begin(); last_he = insert_intersecting_xcurve(*it, src, trg, source_valid, en); src = trg; for (it++; it != x_list.end(); it++) { last_he = insert_intersecting_xcurve(*it, src, trg, true, en); src = trg; } return last_he; } /*! Insert a given curve that one of its endpoints is the mapping of a given * vertex into the map. * \param cv the curve to insert * \param src an existing vertex in the map and one the endpoint of cv * \param en the notification * \return the last inserted halfedge. Its target maps to the target point of * the last inserted X-monotone curve */ Halfedge_handle insert_from_vertex(const Curve_2 & cv, Vertex_handle src, Change_notification * en = NULL) { CGAL_precondition(!point_equal(pmwx_traits->curve_source(cv), pmwx_traits->curve_target(cv))); return insert_intersecting_curve(cv, src, true, en); } // return the last inserted halfedge whose target points to the last // point of the inserted xcurve Halfedge_handle insert(const Curve_2 & c, Change_notification * en = NULL) { // If curve is x-monotone then its source is different from its target. // (which is not true for non x-monotone curves, e.g, triangles.) Vertex_handle src; return insert_intersecting_curve(c, src, false, en); } // inserts a given curve container into the map using Eti's sweep template Halfedge_iterator insert_old(const X_monotone_curve_2_iterator & begin, const X_monotone_curve_2_iterator & end, Change_notification * en = NULL) { typedef Pmwx_aggregate_insert_old Pmwx_agg_insert; Pmwx_agg_insert p(traits); p.insert_curves(begin, end, *this, en); return halfedges_begin(); } // inserts a given curve container into the map using Tali's sweep template Halfedge_iterator insert(const X_monotone_curve_2_iterator & begin, const X_monotone_curve_2_iterator & end, Change_notification * en = NULL) { typedef Pmwx_aggregate_insert Pmwx_agg_insert; Pmwx_agg_insert p(traits); p.insert_curves(begin, end, *this, en); return halfedges_begin(); } // Non intersecting insert methods: //! inserts a given curve into the map. Halfedge_handle non_intersecting_insert(const X_monotone_curve_2 & cv, Change_notification * en = NULL) { return Planar_map::insert(cv, en); } //! iterates through a given range of curves, inserting the curves into the // map. template Halfedge_iterator non_intersecting_insert(const X_monotone_curve_2_iterator & begin, const X_monotone_curve_2_iterator & end, Change_notification * en = NULL) { return Planar_map::insert(begin, end, en); } //! inserts a given curve as a new inner component of a given face. Halfedge_handle non_intersecting_insert_in_face_interior(const X_monotone_curve_2 & cv, Face_handle f, Change_notification * en = NULL) { return Planar_map::insert_in_face_interior(cv, f, en); } //! inserts a given curve that one of its endpoints is held by the target // vertex of a given halfedge into the map. Halfedge_handle non_intersecting_insert_from_vertex(const X_monotone_curve_2 & cv, Halfedge_handle h, Change_notification * en = NULL) { return Planar_map::insert_from_vertex(cv, h, en); } //! inserts a given curve that both of its endpoints are held by the target // vertices of two given halfedges respectively into the map. Halfedge_handle non_intersecting_insert_at_vertices(const X_monotone_curve_2 & cv, Halfedge_handle h1, Halfedge_handle h2, Change_notification * en = NULL) { return Planar_map::insert_at_vertices(cv, h1, h2, en); } //! inserts a given curve that one of its endpoints is held by a given vertex // into the map. Halfedge_handle non_intersecting_insert_from_vertex(const X_monotone_curve_2 & cv, Vertex_handle v1, Change_notification * en = NULL) { return Planar_map::insert_from_vertex(cv, v1, en); } //! inserts a given curve that both of its endpoints are held by two given // vertices respectively into the map. Halfedge_handle non_intersecting_insert_at_vertices(const X_monotone_curve_2 & cv, Vertex_handle v1, Vertex_handle v2, Change_notification * en = NULL) { return Planar_map::insert_at_vertices(cv, v1, v2, en); } protected: bool in_x_range(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) { return (curve_in_x_range(cv1,cv2) || curve_in_x_range(cv2,cv1)); } bool curve_in_x_range(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) { return ((traits->point_in_x_range(cv1, pmwx_traits->curve_source(cv2)) || traits->point_in_x_range(cv1, pmwx_traits->curve_target(cv2)))); } // Data fields: Pmwx_traits_wrap * pmwx_traits; bool pmwx_use_delete_traits; bool pmwx_use_delete_pl; private: bool is_left(const Point_2 &p1, const Point_2 &p2) const { return (traits->compare_x(p1, p2) == SMALLER); } bool is_right(const Point_2 &p1, const Point_2 &p2) const { return (traits->compare_x(p1, p2) == LARGER); } bool is_left_low(const Point_2 &p1, const Point_2 &p2) const { return (traits->compare_xy(p1, p2) == SMALLER); } bool is_right_top(const Point_2 & p1, const Point_2 & p2) const { return is_left_low(p2, p1); } const Point_2& leftmost(const Point_2 &p1, const Point_2 &p2) const { return (is_left(p1, p2) ? p1 : p2); } const Point_2& rightmost(const Point_2 &p1, const Point_2 &p2) const { return (is_right(p1, p2) ? p1 : p2); } /*! returns true iff the two points are the same */ bool point_equal(const Point_2 & p1, const Point_2 & p2) const { return traits->point_equal(p1, p2); } }; /*! Copy Constructor */ template Planar_map_with_intersections_2:: Planar_map_with_intersections_2(const Self & rhs) : Planar_map(rhs), pmwx_use_delete_traits(false), pmwx_use_delete_pl(false) { pmwx_traits = (Pmwx_traits_wrap*)traits; } /*! Copy Constructor */ template Planar_map_with_intersections_2:: Planar_map_with_intersections_2(const Planar_map & pm) : Planar_map(pm), pmwx_use_delete_traits(false), pmwx_use_delete_pl(false) { pmwx_traits = (Pmwx_traits_wrap*)traits; } /*! Destructor */ template Planar_map_with_intersections_2::~Planar_map_with_intersections_2() { if (pmwx_use_delete_traits) delete traits; if (pmwx_use_delete_pl) delete pl; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_utils_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_utils_2.0000644000175000017500000000327611344301501031313 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_utils_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec // Sylvain Pion // Andreas Fabri #ifndef CGAL_TRIANGULATION_UTILS_2_H #define CGAL_TRIANGULATION_UTILS_2_H CGAL_BEGIN_NAMESPACE template < class T = void > struct Triangulation_cw_ccw_static_2 { static const int ccw_map[3]; static const int cw_map[3]; }; template < class T > const int Triangulation_cw_ccw_static_2::ccw_map[3] = {1, 2, 0}; template < class T > const int Triangulation_cw_ccw_static_2::cw_map[3] = {2, 0, 1}; class Triangulation_cw_ccw_2 : public Triangulation_cw_ccw_static_2<> { public: static int ccw(const int i) { CGAL_triangulation_precondition( i >= 0 && i < 3); return ccw_map[i]; } static int cw(const int i) { CGAL_triangulation_precondition( i >= 0 && i < 3); return cw_map[i]; } }; CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_UTILS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_is_valid_2.h0000644000175000017500000002427211344301500031304 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_is_valid_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_IS_VALID_2_H #define CGAL_PARTITION_IS_VALID_2_H #include #include #include #include #include #include #include #include #include #include // NOTE: this could possibly be checked using a planar map overlay, but // then the traits class would have to require lots of other things // and you have to do many overlaps, not just one so it is // less efficient. namespace CGAL { template bool polygons_w_steiner_are_equal(Circulator1 orig_first, Circulator2 new_first) { typedef typename Circulator1::value_type Point_2; Circulator1 orig_circ; Circulator2 new_circ; // find the first (original) vertex in the list of vertices for (new_circ = new_first; *new_circ != *orig_first && ++new_circ != new_first;) {} if (new_circ == new_first) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "first vertex " << *orig_first << " not found " << std::endl; #endif // CGAL_PARTITION_CHECK_DEBUG return false; } // first becomes the first one you found; now look for the others new_first = new_circ; orig_circ = orig_first; Point_2 prev_pt = *new_first; // keep going until you find all the original vertices, or come back // to the first new vertex do { if (*new_circ == *orig_circ) // points correspond, so move both { prev_pt = *new_circ; new_circ++; orig_circ++; } else // points don't correspond { typedef typename Kernel_traits::Kernel K; typename K::Collinear_2 collinear; typename K::Collinear_are_ordered_along_line_2 collinear_are_ordered_along_line; if (!collinear(prev_pt, *new_circ, *orig_circ)) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << *new_circ << " is not collinear with " << prev_pt << " and " << *orig_circ << std::endl; #endif return false; } if (!collinear_are_ordered_along_line(prev_pt, *new_circ, *orig_circ)) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << *new_circ << " doesn't belong betweene " << prev_pt << " and " << *orig_circ << std::endl; #endif return false; } prev_pt = *new_circ; new_circ++; } } while (orig_circ != orig_first && new_circ != new_first); // if they didn't both come back to the beginning, then something is wrong return (orig_circ == orig_first && new_circ == new_first); } template bool polygons_are_equal(Circulator1 orig_first, Circulator2 new_first) { Circulator1 orig_circ = orig_first; Circulator2 new_circ; // find the first (original) vertex in the list of vertices for (new_circ = new_first; *new_circ != *orig_first && ++new_circ != new_first;) {} new_first = new_circ; // now look through both lists until you find a vertex that is not // the same or you reach the end of the vertices do { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << *new_first << " is in the right place " << std::endl; #endif orig_circ++; new_circ++; } while (*orig_circ == *new_circ && orig_circ != orig_first && new_circ != new_first); return (orig_circ == orig_first && new_circ == new_first); } template bool partition_is_valid_2 (InputIterator point_first, InputIterator point_last, ForwardIterator poly_first, ForwardIterator poly_last, const Traits& traits) { if (poly_first == poly_last) return (point_first == point_last); typedef typename Traits::Polygon_2::Vertex_iterator Poly_vtx_iterator; typedef typename Traits::Point_2 Point_2; typedef Partition_vertex_map P_Vertex_map; typedef typename Traits::Is_valid Is_valid; Poly_vtx_iterator vtx_begin, vtx_end; Is_valid is_valid = traits.is_valid_object(traits); std::list orig_poly; for (;point_first != point_last; point_first++) orig_poly.push_back(*point_first); CGAL_partition_precondition(orientation_2(orig_poly.begin(),orig_poly.end(), traits) == COUNTERCLOCKWISE); P_Vertex_map output_vertex_set(poly_first, poly_last); if (output_vertex_set.polygons_overlap()) return false; int poly_num = 0; for (; poly_first != poly_last; poly_first++, poly_num++) { vtx_begin = (*poly_first).vertices_begin(); vtx_end = (*poly_first).vertices_end(); #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "Polygon " << poly_num << " is " << std::endl; std::cout << *poly_first << std::endl; #endif CGAL_partition_assertion ( orientation_2(vtx_begin, vtx_end, traits) == COUNTERCLOCKWISE); if (!is_valid(vtx_begin, vtx_end)) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "It does NOT have the tested property." << std::endl; #endif return false; } } std::list union_polygon; output_vertex_set.union_vertices(std::back_inserter(union_polygon)); #ifdef CGAL_PARTITION_CHECK_DEBUG typename std::list::iterator poly_iterator; std::cout << "union polygon is " << std::endl; for (poly_iterator = union_polygon.begin(); poly_iterator != union_polygon.end(); poly_iterator++) { std::cout << *poly_iterator << " "; } std::cout << std::endl; #endif // CGAL_PARTITION_CHECK_DEBUG typedef typename std::list::iterator I; typedef Circulator_from_iterator Circulator; Circulator orig_poly_circ(orig_poly.begin(), orig_poly.end()); Circulator union_poly_circ(union_polygon.begin(), union_polygon.end()); if (orig_poly.size() == union_polygon.size()) return polygons_are_equal(orig_poly_circ, union_poly_circ); else return polygons_w_steiner_are_equal(orig_poly_circ, union_poly_circ); } template bool partition_is_valid_2 (InputIterator point_first, InputIterator point_last, FowardIterator poly_first, FowardIterator poly_last) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; typedef Partition_traits_2 Traits; typedef Is_vacuously_valid Is_valid; Partition_is_valid_traits_2 validity_traits; return partition_is_valid_2(point_first, point_last, poly_first, poly_last, validity_traits); } template bool convex_partition_is_valid_2(InputIterator point_first, InputIterator point_last, ForwardIterator poly_first, ForwardIterator poly_last, const Traits& ) { typedef typename Traits::Is_convex_2 Is_convex_2; Partition_is_valid_traits_2 validity_traits; return partition_is_valid_2(point_first, point_last, poly_first, poly_last, validity_traits); } template bool convex_partition_is_valid_2(InputIterator point_first, InputIterator point_last, ForwardIterator poly_first, ForwardIterator poly_last) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return convex_partition_is_valid_2(point_first, point_last, poly_first, poly_last, Partition_traits_2()); } template bool y_monotone_partition_is_valid_2(InputIterator point_first, InputIterator point_last, ForwardIterator poly_first, ForwardIterator poly_last, const Traits& ) { typedef typename Traits::Is_y_monotone_2 Is_y_monotone_2; Partition_is_valid_traits_2 validity_traits; return partition_is_valid_2(point_first, point_last, poly_first, poly_last, validity_traits); } template bool y_monotone_partition_is_valid_2(InputIterator point_first, InputIterator point_last, ForwardIterator poly_first, ForwardIterator poly_last) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return y_monotone_partition_is_valid_2(point_first, point_last, poly_first, poly_last, Partition_traits_2()); } } #endif // CGAL_PARTITION_IS_VALID_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Bbox_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Bbox_2_intersect0000644000175000017500000000504611344301500031177 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Bbox_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_RAY_2_BBOX_2_INTERSECTION_H #define CGAL_RAY_2_BBOX_2_INTERSECTION_H #include #include #include #include CGAL_BEGIN_NAMESPACE class Bbox_2_Ray_2_pair_impl; class Bbox_2_Ray_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; ~Bbox_2_Ray_2_pair() ; Bbox_2_Ray_2_pair() ; Bbox_2_Ray_2_pair(Bbox_2_Ray_2_pair const &o) ; Bbox_2_Ray_2_pair(Bbox_2 const &box, double x, double y, double dx, double dy) ; Bbox_2_Ray_2_pair& operator=(Bbox_2_Ray_2_pair const &o) ; Intersection_results intersection_type() const; bool intersection(double &x, double &y) const; bool intersection(double &x1, double &y1, double &x2, double &y2) const; protected: Bbox_2_Ray_2_pair_impl *pimpl; }; bool do_intersect_ray_2( const Bbox_2 &box, double x, double y, double dx, double dy); template bool do_intersect_ray_2( const Bbox_2 &box, const Ray &ray) { double startx = to_double(ray->start().x()); double starty = to_double(ray->start().y()); double dx = to_double(ray->direction().to_vector().x()); double dy = to_double(ray->direction().to_vector().y()); return do_intersect_ray_2(box, startx, starty, dx, dy); } template inline bool do_intersect_ray_2( const Ray &ray, const Bbox_2 &box) { return do_intersect_ray_2(box, ray); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convexity_check_2.h0000644000175000017500000001161611344301500030604 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convexity_check_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CONVEXITY_CHECK_2_H #define CGAL_CONVEXITY_CHECK_2_H #include #include CGAL_BEGIN_NAMESPACE // returns true, if the point elements in [|first|,|last|) form a // counterclockwise oriented strongly convex polygon. Strongly means, // there are no three collinear points. // {\sc traits}: uses |Traits::Left_turn_2|, |Traits::Equal_2| and |Traits::Less_xy_2|. template bool is_ccw_strongly_convex_2( ForwardIterator first, ForwardIterator last, const Traits& ch_traits); template inline bool is_ccw_strongly_convex_2( ForwardIterator first, ForwardIterator last ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return is_ccw_strongly_convex_2( first, last, Kernel()); } // returns true, if the point elements in [|first|,|last|) form a // clockwise oriented strongly convex polygon. Strongly means, there are // no three collinear points. // {\sc traits}: uses |Traits::Left_turn_2|, |Traits::Equal_2| and |Traits::Less_xy_2|. template bool is_cw_strongly_convex_2( ForwardIterator first, ForwardIterator last, const Traits& ch_traits); template inline bool is_cw_strongly_convex_2( ForwardIterator first, ForwardIterator last ) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return is_cw_strongly_convex_2( first, last, Kernel()); } // returns true, if all points in [|first1|,|last1|) are // not right of the lines defined by consecutive points in the range // [|first2|,|last2|), where the range is considered as a cycle. // {\sc traits}: uses |Traits::Left_turn_2|. template bool ch_brute_force_check_2(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, const Traits& ch_traits); template inline bool ch_brute_force_check_2(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_brute_force_check_2( first1, last1, first2, last2, Kernel() ); } // returns true, if all points in [|first1|,|last1|) are // not right of the lines defined by consecutive points in the range // [|first2|,|last2|). // {\sc traits}: uses |Traits::Left_turn_2|. template bool ch_brute_force_chain_check_2(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, const Traits& ch_traits); template inline bool ch_brute_force_chain_check_2(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_brute_force_chain_check_2( first1, last1, first2, last2, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CONVEXITY_CHECK_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/natural_neighbor_coordinates_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/natural_neighbor_coord0000644000175000017500000002323111344301500031455 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/natural_neighbor_coordinates_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Frank Da, Julia Floetotto #ifndef CGAL_NATURAL_NEIGHBOR_COORDINATES_2_H #define CGAL_NATURAL_NEIGHBOR_COORDINATES_2_H #include #include #include CGAL_BEGIN_NAMESPACE // the struct "Project_vertex_output_iterator" // is used in the (next two) functions // as well as in regular_neighbor_coordinates_2 and // in surface_neighbor_coordinates_3 // //projection of iterator over std::pair //to iterator over std::pair< Point, T> template < class OutputIterator> struct Project_vertex_output_iterator { // this class wraps the OutputIterator with value type // std::pair // into an output iterator with value type std::pair // Conditions: OutputIterator has value type std::pair // and Vertex_handle has a function ->point() // with return type const Point& OutputIterator _base; //creation: Project_vertex_output_iterator(OutputIterator o) : _base(o) {} OutputIterator base() {return _base;} Project_vertex_output_iterator& operator++(){_base++; return *this;} Project_vertex_output_iterator& operator++(int){_base++; return *this;} Project_vertex_output_iterator& operator*(){return *this;} template Project_vertex_output_iterator& operator=(const Vertex_pair& x){ _base=std::make_pair(x.first->point(), x.second); return *this; } }; // The following natural_neighbor_coordinate_2 functions fix the // traits class to be Dt::Geom_traits. The following signatures could // be used if one wants to pass a traits class as argument: // template // Triple< OutputIterator, typename Traits::FT, bool > // natural_neighbor_coordinates_2(const Dt& dt, // const typename Traits::Point_2& p, // OutputIterator out, const Traits& traits, // typename Dt::Face_handle start // = typename Dt::Face_handle()) // //template //Triple< OutputIterator, typename Traits::FT, bool > //natural_neighbor_coordinates_2(const Dt& dt, // typename Dt::Vertex_handle vh, // OutputIterator out, const Traits& traits) //the following two functions suppose that // OutputIterator has value type // std::pair //!!!they are not documented!!! template Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > natural_neighbor_coordinates_vertex_2(const Dt& dt, const typename Dt::Geom_traits::Point_2& p, OutputIterator out, typename Dt::Face_handle start = typename Dt::Face_handle()) { typedef typename Dt::Geom_traits Traits; typedef typename Traits::FT Coord_type; typedef typename Traits::Point_2 Point_2; typedef typename Dt::Face_handle Face_handle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Edge Edge; typedef typename Dt::Locate_type Locate_type; Locate_type lt; int li; Face_handle fh = dt.locate(p, lt, li, start); //the point must lie inside the convex hull: // otherwise return false if (lt == Dt::OUTSIDE_AFFINE_HULL || lt == Dt::OUTSIDE_CONVEX_HULL || (lt == Dt::EDGE && (dt.is_infinite(fh) || dt.is_infinite(fh->neighbor(li))))){ return make_triple(out, Coord_type(1), false); } if (lt == Dt::VERTEX) { *out++= std::make_pair(fh->vertex(li), Coord_type(1)); return make_triple(out, Coord_type(1), true); } std::list hole; dt.get_boundary_of_conflicts(p, std::back_inserter(hole), fh); return natural_neighbor_coordinates_vertex_2 (dt, p, out, hole.begin(), hole.end()); } //function call if the conflict zone is known: // OutputIterator has value type // std::pair template Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > natural_neighbor_coordinates_vertex_2(const Dt& dt, const typename Dt::Geom_traits::Point_2& p, OutputIterator out, EdgeIterator hole_begin, EdgeIterator hole_end) { CGAL_precondition(dt.dimension()==2); //precondition: p must lie inside the hole // (=^ inside convex hull of neighbors) typedef typename Dt::Geom_traits Traits; typedef typename Traits::FT Coord_type; typedef typename Traits::Point_2 Point_2; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Face_circulator Face_circulator; std::vector vor(3); Coord_type area_sum(0); EdgeIterator hit = hole_end; --hit; //in the beginning: prev is the "last" vertex of the hole: // later: prev is the last vertex processed (previously) Vertex_handle prev = hit->first->vertex(dt.cw(hit->second)); hit = hole_begin; while (hit != hole_end) { Coord_type area(0); Vertex_handle current = hit->first->vertex(dt.cw(hit->second)); vor[0] = dt.geom_traits().construct_circumcenter_2_object() (current->point(), hit->first->vertex(dt.ccw(hit->second))->point(), p); Face_circulator fc = dt.incident_faces(current, hit->first); ++fc; vor[1] = dt.dual(fc); while(!fc->has_vertex(prev)) { ++fc; vor[2] = dt.dual(fc); area += polygon_area_2(vor.begin(), vor.end(), dt.geom_traits()); vor[1] = vor[2]; }; vor[2] = dt.geom_traits().construct_circumcenter_2_object()(prev->point(), current->point(),p); area += polygon_area_2(vor.begin(), vor.end(), dt.geom_traits()); *out++= std::make_pair(current,area); area_sum += area; //update prev and hit: prev= current; ++hit; } return make_triple(out, area_sum, true); } ///////////////////////////////////////////////////////////// //the cast from vertex to point: // the following functions return an Output_iterator over // std::pair //=> OutputIterator has value type // std::pair< Dt::Geom_traits::Point_2, Dt::Geom_traits::FT> ///////////////////////////////////////////////////////////// template Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > natural_neighbor_coordinates_2(const Dt& dt, const typename Dt::Geom_traits::Point_2& p, OutputIterator out, typename Dt::Face_handle start = CGAL_TYPENAME_DEFAULT_ARG Dt::Face_handle() ) { Project_vertex_output_iterator op(out); Triple< Project_vertex_output_iterator, typename Dt::Geom_traits::FT, bool > result = natural_neighbor_coordinates_vertex_2 (dt, p, op, start); return make_triple(result.first.base(), result.second, result.third); } //OutputIterator has value type // std::pair< Dt::Geom_traits::Point_2, Dt::Geom_traits::FT> //function call if the conflict zone is known: template Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > natural_neighbor_coordinates_2(const Dt& dt, const typename Dt::Geom_traits::Point_2& p, OutputIterator out, EdgeIterator hole_begin, EdgeIterator hole_end) { Project_vertex_output_iterator op(out); Triple< Project_vertex_output_iterator, typename Dt::Geom_traits::FT, bool > result = natural_neighbor_coordinates_vertex_2 (dt, p, op, hole_begin,hole_end); return make_triple(result.first.base(), result.second, result.third); } /**********************************************************/ //compute the coordinates for a vertex of the triangulation // with respect to the other points in the triangulation //OutputIterator has value type // std::pair< Dt::Geom_traits::Point_2, Dt::Geom_traits::FT> template Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > natural_neighbor_coordinates_2(const Dt& dt, typename Dt::Vertex_handle vh, OutputIterator out) { //this functions creates a small triangulation of the // incident vertices of this vertex and computes the // natural neighbor coordinates of ch->point() wrt. it. typedef typename Dt::Vertex_circulator Vertex_circulator; Dt t2; Vertex_circulator vc = dt.incident_vertices(vh), done(vc); do{ assert(!dt.is_infinite(vc)); t2.insert(vc->point()); } while(++vc!=done); return natural_neighbor_coordinates_2(t2, vh->point(), out); } //class providing a function object: //OutputIterator has value type // std::pair< Dt::Geom_traits::Point_2, Dt::Geom_traits::FT> template class natural_neighbor_coordinates_2_object { public: Triple< OutputIterator, typename Dt::Geom_traits::FT, bool > operator()(const Dt& dt, typename Dt::Vertex_handle vh, OutputIterator out) const { return natural_neighbor_coordinates_2(dt, vh, out); } }; CGAL_END_NAMESPACE #endif // CGAL_NATURAL_NEIGHBOR_COORDINATES_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Width_3.h0000644000175000017500000016100011344301501026471 0ustar debiandebian// Copyright (c) 1997-2000 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Width_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Thomas Herrmann, Lutz Kettner #ifndef CGAL_WIDTH_3_H #define CGAL_WIDTH_3_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Width_3 { // +----------------------------------------------------------------------+ // | Typedef Area | // +----------------------------------------------------------------------+ private: typedef Traits_ Traits; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Vector_3 Vector_3; typedef typename Traits::Plane_3 Plane_3; typedef typename Traits::RT RT; // +----------------------------------------------------------------------+ // | Variable Declaration | // +----------------------------------------------------------------------+ private: //the current best plane coefficients: e1:Ax+By+Cz+1=0 // e2:Ax+By+Cz+D=0 RT A,B,C,D,K; // Width itself RT WNum,WDenom; // Planes and directions are derived from these variables // A list with all quadruples A/K, B/K, C/K, D/K std::vector< std::vector > allsolutions; // A list with all quadruples that give an optimal solution std::vector< std::vector > alloptimal; //The traits class object Traits tco; //The new origin to know how to translate back Point_3 neworigin; // +----------------------------------------------------------------------+ // | Access to Private Variables | // +----------------------------------------------------------------------+ public: void get_width_coefficients(RT& a, RT& b, RT& c, RT& d, RT& k) { d=-A*neworigin.hx()-B*neworigin.hy()-C*neworigin.hz()+D*neworigin.hw(); k=-A*neworigin.hx()-B*neworigin.hy()-C*neworigin.hz()+K*neworigin.hw(); a=A*neworigin.hw(); b=B*neworigin.hw(); c=C*neworigin.hw(); #ifdef GCD_COMPUTATION simplify_solution(a,b,c,d,k); #endif } void get_squared_width(RT& num, RT& denom) { num=WNum; denom=WDenom; } Vector_3 get_build_direction() { return tco.make_vector(A,B,C); } void get_width_planes(Plane_3& e1, Plane_3& e2) { RT a,b,c,d,k; get_width_coefficients(a,b,c,d,k); e1=tco.make_plane(a,b,c,d); e2=tco.make_plane(a,b,c,k); } void get_all_build_directions(std::vector& alldir) { typename std::vector< std::vector >::iterator it=alloptimal.begin(); RT a,b,c; while(it!=alloptimal.end()) { a=(*it)[0]; b=(*it)[1]; c=(*it)[2]; #ifdef GCD_COMPUTATION RT dummy1=0; RT dummy2=0; simplify_solution(a,b,c,dummy1,dummy2); #endif Vector_3 dir=tco.make_vector(a,b,c); alldir.push_back(dir); ++it; } } int get_number_of_optimal_solutions() { return int(alloptimal.size()); } int get_number_of_possible_solutions() { return int(allsolutions.size()); } void get_all_possible_solutions(std::vector< std::vector >& allsol) { allsol.clear(); typename std::vector< std::vector >::iterator it=allsolutions.begin(); while(it!=allsolutions.end()) { RT d=-((*it)[0])*neworigin.hx()-((*it)[1])*neworigin.hy() -((*it)[2])*neworigin.hz()+((*it)[3])*neworigin.hw(); RT k=-((*it)[0])*neworigin.hx()-((*it)[1])*neworigin.hy() -((*it)[2])*neworigin.hz()+((*it)[4])*neworigin.hw(); RT a=((*it)[0])*neworigin.hw(); RT b=((*it)[1])*neworigin.hw(); RT c=((*it)[2])*neworigin.hw(); #ifdef GCD_COMPUTATION simplify_solution(a,b,c,d,k); #endif std::vector sol; sol.push_back(a); sol.push_back(b); sol.push_back(c); sol.push_back(d); sol.push_back(k); allsol.push_back(sol); ++it; } } // +----------------------------------------------------------------------+ // | The Con- and Destructors | // +----------------------------------------------------------------------+ public: Width_3(): A(0), B(0), C(0), D(2), K(1), WNum(0), WDenom(1) {} template Width_3( InputIterator begin, InputIterator beyond): A(0), B(0), C(0), D(2), K(1), WNum(0), WDenom(1) { INFOMSG(INFO,"Waiting for new HDS to build class Width_Polyhedron!" < LocalPolyhedron; LocalPolyhedron P; convex_hull_3( begin, beyond, P, CHT()); width_3_convex(P); } template Width_3(InputPolyhedron& Poly): A(0), B(0), C(0), D(2), K(1), WNum(0), WDenom(1) { // Compute convex hull with new width_polyhedron structure INFOMSG(INFO,"Working with extern additional data structures."); width_3_convex(Poly); } ~Width_3() { allsolutions.clear(); alloptimal.clear(); } // +----------------------------------------------------------------------+ // | Begin of private function area | // +----------------------------------------------------------------------+ private: // Just to remember: // E1: -axh - byh - czh - kwh <= 0 axh + byh + czh + kwh >= 0 // E2: axh + byh + czh + dwh <= 0 // VF-pair: 3xE1 + 1xE2 // EE-pair: 2xE1 + 2xE2 // plane equation in facets: Ax + By + Cz + 1 = 0 // ax + by + cz + k = 0 (A=a/k,...) //----------------------------- //---Combinatorial functions--- //----------------------------- // *** PREPARATION_CHECK *** //--------------------------- //This function determines the next facet if the halfedge e is a //valable halfedge over which we can rotate. If so fnext is returned. //PRECONDITION: e is the LAST edge in the go_on or impassable list! template bool preparation_check(InputDA& dao, Halfedge_handle_& e, Facet_handle_& fnext, std::vector& go_on, std::vector& imp) { //If the halfedge flag impassable is set then we can pop e from the stack //of the possibale go_on edges DEBUGMSG(PREPARATION_CHECK,"\nBegin PREPARATION_CHECK"); DEBUGENDL(PREPARATION_CHECK,"Edge e: "<opposite()->vertex()->point() <<" --> ",e->vertex()->point()); CGAL_precondition(go_on.back()==e); DEBUGMSG(ASSERTION_OUTPUT,"e is last element on stack go_on. " <<"ASSERTION OK."); if ( dao.is_impassable(e) ) { DEBUGMSG(PREPARATION_CHECK," is impassable. Erase from go_on."); go_on.pop_back(); DEBUGMSG(PREPARATION_CHECK,"End PREPARATION_CHECK"); return false; } else { //If the opposite halfedge of e is already visited, then we insert //e in the impassable list an pop e from the stack of the go_on edges typename InputDA::Halfedge_handle h=e->opposite(); if(dao.is_visited(h)) { DEBUGMSG(PREPARATION_CHECK," has a visited opposite edge. Set " <<"impassable flag, push on impassable stack and erase" <<" from go_on"); imp.push_back(e); dao.set_impassable_flag(h,true); go_on.pop_back(); DEBUGMSG(PREPARATION_CHECK,"End PREPARATION_CHECK"); return false; } else { DEBUGMSG(PREPARATION_CHECK," is a valable candidate. Compute next " <<"facet and erase from go_on. Set visited flag of all to " <<"fnext incident edges."); //e is a valable candidate. Thus set fnext to the next facet we visit fnext=h->facet(); //Delete e from go_on and insert the edges of fnext (except opposite //of e) in the go_on list go_on.pop_back(); typename InputDA::Halfedge_handle h0=h; h=h->next(); while ( h!=h0) { DEBUGENDL(PREPARATION_CHECK,"Adding edge to go_on stack: ", h->opposite()->vertex()->point()<<" --> " <vertex()->point()); go_on.push_back(h); dao.set_visited_flag(h,true); h=h->next(); } DEBUGMSG(PREPARATION_CHECK,"End PREPARATION_CHECK"); return true; } } } // *** NEIGHBORS_OF *** //---------------------- //To compute the neighbors of a vertex. The vertex is implicitely given //as the vertex the halfedge points to. template void neighbors_of(const Halfedge_handle_& h, std::vector& V) { DEBUGMSG(NEIGHBORS_OF,"\nBegin NEIGHBORS_OF"); DEBUGENDL(NEIGHBORS_OF,"Determining the neighbors of: ", h->vertex()->point()); Halfedge_handle_ e=h; Halfedge_handle_ e0=e->opposite(); V.clear(); V.push_back(e0->vertex()); e=e->next(); //Now go around the vertex and store the neighbor vertices while ( e!=e0 ) { V.push_back(e->vertex()); e=e->opposite()->next(); } #if NEIGHBORS_OF typename std::vector::iterator vtxit=V.begin(); while(vtxit!=V.end()) { DEBUGENDL(NEIGHBORS_OF,"Neighbor: ",(*vtxit)->point()); ++vtxit; } #endif DEBUGMSG(NEIGHBORS_OF,"End NEIGHBORS_OF"); } //During the algorithm we have to build union and minus set //of two sets and check wheater two sets are cutting each othe ror not // *** SETMINUS *** //------------------ //Builds the set A\B where the set A is changed template void setminus(std::vector& res, const std::vector& without) { DEBUGMSG(SETMINUS,"\nBegin SETMINUS"); typename std::vector::iterator resit; typename std::vector::const_iterator withoutit=without.begin(); //Scan through all elements of without and check if they are also in res. //If so delete the element from res. while(withoutit!=without.end()) { resit=std::find(res.begin(),res.end(),*withoutit); if ( resit!=res.end() ) { CGAL_assertion((*resit)->point()==(*withoutit)->point()); DEBUGMSG(ASSERTION_OUTPUT,"Found an element to erase. ASSERTION OK."); DEBUGENDL(SETMINUS,"Erase point: ",(*resit)->point()); res.erase(resit); } ++withoutit; } DEBUGMSG(SETMINUS,"End SETMINUS"); } // *** SETUNION *** //------------------ //Builds the union of two sets A and B. The result is stored in A //POSTCONDITION: Every element in A is stored once. template void setunion(std::vector&res, std::vector& uni) { DEBUGMSG(SETUNION,"\nBegin SETUNION"); typename std::vector::iterator uniit=uni.begin(); typename std::vector::iterator resit; //Scan the uni set and add every new element in res while(uniit!=uni.end()) { resit=std::find(res.begin(),res.end(),*uniit); if ( resit==res.end() ) { DEBUGENDL(SETUNION,"Insert new point: ",(*uniit)->point()); res.push_back(*uniit); } ++uniit; } DEBUGMSG(SETUNION,"End SETUNION"); } // *** SETCUT *** //---------------- //Checks if two sets are cutting each other or not (the common elements are //not determined template bool setcut(std::vector& AA, std::vector& BB) { DEBUGMSG(SETCUT,"\nBegin SETCUT"); typename std::vector::iterator Ait=AA.begin(); typename std::vector::iterator Bfindit; while(Ait!=AA.end()) { Bfindit=std::find(BB.begin(),BB.end(),*Ait); if (Bfindit!=BB.end()) { DEBUGMSG(SETCUT,"The sets are cutting each other. Return true."); DEBUGMSG(SETCUT,"End SETCUT"); return true; } ++Ait; } DEBUGMSG(SETCUT,"No common element detected. Return false"); DEBUGMSG(SETCUT,"End SETCUT"); return false; } // ---Numerical functions--- // ************************* // *** COMPUTE_PLANE_EQUATION *** //-------------------------------- //We don't take the standard plane equation computation from CGAL, //because in the context of the width the coefficients have to //satisfy a system of linear inequations. //PRECONDITION: (0,0,0) is strictly inside the convex hull //POSTCONDITION:(0,0,0) is on the positive side of the plane <==> the normal // vector of the plane points to the side where (0,0,0) lies template void compute_plane_equation(InputDA, const Facet_handle_& f) { DEBUGMSG(COMPUTE_PLANE_EQUATION,"\nBegin COMPUTE_PLANE_EQUATION"); DEBUGENDL(COMPUTE_PLANE_EQUATION,"Compute plane equations of facet f: (" <halfedge()->opposite()->vertex()->point()<<"), (", f->halfedge()->vertex()->point()<<"), (" <halfedge()->next()->vertex()->point()<<")"); typename InputDA::Halfedge_handle e = f->halfedge(); typename InputDA::PolyPoint p,q,r; q = e -> opposite() -> vertex() -> point(); p = e -> vertex() -> point(); r = e -> next() -> vertex() -> point(); CGAL_assertion(r!=p && r!=q && p!=q); DEBUGMSG(ASSERTION_OUTPUT,"There are 3 different points. ASSERTION OK."); RT a,b,c,k; solve_3x3(InputDA(),p,q,r,a,b,c,k); f->plane()=tco.make_plane(a,b,c,k); DEBUGENDL(COMPUTE_PLANE_EQUATION,"Plane Coefficients: ",f->plane()); DEBUGMSG(COMPUTE_PLANE_EQUATION,"End COMPUTE_PLANE_EQUATION"); } // *** SOLVE_3X3 *** //------------------- //To solve a special 3x3 system. The rows of the coefficient matrix //are the (homogeneous) x,y,z-coordinates of points and the right //hand side is the homogeneous part of the point times the provided //coefficient. The system is solved with Cramer's Rule. The sign of //the coefficients is chosen in a way that (0,0,0) lies on the positive //side of the plane. template void solve_3x3(InputDA, const PolyPoint_& p, const PolyPoint_& q, const PolyPoint_& r, RT& a, RT& b, RT& c, RT& k) { DEBUGMSG(SOLVE_3X3,"\nBegin SOLVE_3X3"); RT px,py,pz,ph; tco.get_point_coordinates(p,px,py,pz,ph); RT qx,qy,qz,qh; tco.get_point_coordinates(q,qx,qy,qz,qh); RT rx,ry,rz,rh; tco.get_point_coordinates(r,rx,ry,rz,rh); CGAL_assertion(ph>0 && qh>0 && rh>0); DEBUGMSG(ASSERTION_OUTPUT,"All homogeneous parts >0. ASSERTION OK."); DEBUGMSG(SOLVE_3X3,"Matrix:"); DEBUGENDL(SOLVE_3X3,"",px<<" "< bool solve_4x4(InputDA, const PolyPoint_& p, const PolyPoint_& q, const PolyPoint_& r, const PolyPoint_& v, RT& a, RT& b, RT& c, RT& d, RT& k) { DEBUGMSG(SOLVE_4X4,"\nBegin SOLVE_4X4"); RT px,py,pz,ph; tco.get_point_coordinates(p,px,py,pz,ph); RT qx,qy,qz,qh; tco.get_point_coordinates(q,qx,qy,qz,qh); RT rx,ry,rz,rh; tco.get_point_coordinates(r,rx,ry,rz,rh); RT vx,vy,vz,vh; tco.get_point_coordinates(v,vx,vy,vz,vh); CGAL_assertion(ph>0 && qh>0 && vh>0 && rh>0); DEBUGMSG(ASSERTION_OUTPUT,"All homogeneous parts >0. ASSERTION OK."); DEBUGMSG(SOLVE_4X4,"Matrix: "); DEBUGENDL(SOLVE_4X4,"",px<<" "<k) { DEBUGMSG(SOLVE_4X4,"d>k: Interchange d and k"); RT tmp=d; d=k; k=tmp; CGAL_assertion(a*px+b*py+c*pz+d*ph==0); CGAL_assertion(a*qx+b*qy+c*qz+d*qh==0); CGAL_assertion(a*rx+b*ry+c*rz+k*rh==0); CGAL_assertion(a*vx+b*vy+c*vz+k*vh==0); DEBUGMSG(ASSERTION_OUTPUT,"Interchanged k and d. All Assertions ok."); } if (a==0 && b==0 && c==0) { DEBUGENDL(SOLVE_4X4,"Solution of 4x4:\n ",a< bool check_feasibility(InputDA, const RT& a, const RT& b, const RT& c, const RT& d, const RT& k, const std::vector& V) { DEBUGMSG(CHECK_FEASIBILITY,"\nBegin CHECK_FEASIBILITY"); if (d==k) { DEBUGMSG(CHECK_FEASIBILITY,"The planes e1 and e2 are the same. " <<"Not a feasible solution."); DEBUGMSG(CHECK_FEASIBILITY,"End CHECK_FEASIBILITY"); return false; } typename std::vector::const_iterator it=V.begin(); RT tmp; while ( it!=V.end() ) { RT px,py,pz,ph; tco.get_point_coordinates((*it)->point(),px,py,pz,ph); tmp = a*px+b*py+c*pz; //Check if the restrictions according to p are satisfied if (tmp+k*ph < 0 || tmp + d*ph > 0) { #if CHECK_FEASIBILITY DEBUGENDL(CHECK_FEASIBILITY,"Restriction to point ", (*it)->point()<<" failed."); if (tmp+k*ph < 0){ DEBUGENDL(CHECK_FEASIBILITY,"E1 not satisfied: ",tmp+k*ph); } else { DEBUGENDL(CHECK_FEASIBILITY,"E2 not satisfied: ",tmp+d*ph); } #endif DEBUGMSG(CHECK_FEASIBILITY,"Feasibility Check failed."); DEBUGMSG(CHECK_FEASIBILITY,"End CHECK_FEASIBILITY"); return false; } ++it; } //All restrictions are satisfied, thus the check returns true DEBUGMSG(CHECK_FEASIBILITY,"Feasibility Check was successful."); DEBUGMSG(CHECK_FEASIBILITY,"End CHECK_FEASIBILITY"); return true; } #if GCD_COMPUTATION // *** GCD *** //------------- //To compute the gcd of 2 integer numbers //PRECONDITION: abs(IntNum) must be defined! // %-operator must be defined! template IntNum gcd(const IntNum& a, const IntNum& b) { DEBUGMSG(GCD_OUTPUT,"\nBegin GCD"); DEBUGENDL(GCD_OUTPUT,"Compute gcd of ",a<<" and "< void simplify_solution(IntNum& a, IntNum& b, IntNum& c, IntNum& d, IntNum& k) { DEBUGMSG(SIMPLIFY_SOLUTION,"\nBegin SIMPLIFY_SOLUTION"); IntNum r=gcd(a,b); IntNum s=gcd(c,d); IntNum t=gcd(r,s); IntNum g=gcd(t,k); CGAL_assertion(g*(a/g)==a); a=a/g; CGAL_assertion(g*(b/g)==b); b=b/g; CGAL_assertion(g*(c/g)==c); c=c/g; CGAL_assertion(g*(d/g)==d); d=d/g; CGAL_assertion(g*(k/g)==k); k=k/g; DEBUGENDL(SIMPLIFY_SOLUTION,"Simplified solutions: ",a<<" "< void initial_VF_pair(InputDA& dao, Facet_handle_& f, Polyhedron_& P, std::vector& go_on) { DEBUGMSG(INITIAL_VF_PAIR,"\nBegin INITIAL_VF_PAIR"); DEBUGENDL(INITIAL_VF_PAIR,"Compute initial VF-pair with facet f: (" <halfedge()->opposite()->vertex()->point()<<"), (", f->halfedge()->vertex()->point()<<"), (" <halfedge()->next()->vertex()->point()<<")"); typedef typename InputDA::Vertex_handle Vertex_handle; //Compute the facet. ==> e2 is fixed tco.get_plane_coefficients(f->plane(),A,B,C,K); CGAL_assertion(K>0); DEBUGMSG(ASSERTION_OUTPUT,"K greater (strictly) than 0. ASSERTION OK."); //Start with an impossible configuration for the still unknown //coefficient D=K, ie plane E1 == plane E2 D=K; DEBUGENDL(INITIAL_VF_PAIR,"Starting with values:\nA:",A< apv; #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG)) typename InputDA::Vertex_iterator vtxitass = P.vertices_begin(); while(vtxitass!=P.vertices_end()) { RT px,py,pz,ph; tco.get_point_coordinates((*vtxitass).point(),px,py,pz,ph); CGAL_expensive_assertion(ph>0); CGAL_expensive_assertion(A*px+B*py+C*pz+K*ph>=0); ++vtxitass; } DEBUGMSG(ASSERTION_OUTPUT,"All points satisfy restriction " <<"type E1. ASSERTION OK>"); #endif typename InputDA::Vertex_iterator vtxit=P.vertices_begin(); RT maxdist=0; RT hompart=1; //Try every point to be an/the antipodal vertex of the facet f. Take the //one with the bigest distance from E1 DEBUGENDL(INITIAL_VF_PAIR,"Plane E1:",f->plane()); while (vtxit != P.vertices_end() ) { RT pix, piy, piz, pih; tco.get_point_coordinates((*vtxit).point(),pix,piy,piz,pih); DEBUGENDL(INITIAL_VF_PAIR,"Try Point: ",(*vtxit).point()); //Compute the sign of the distance from pi to the current plane e2 RT distpie1=A*pix + B*piy + C*piz; DEBUGENDL(INITIAL_VF_PAIR,"Distance from p to current plane e1: ", distpie1*hompart); //If pi is not between e1 and e2, compute a new plane e2 through pi //If pi is also ON the current plane e2, then insert pi in the list //of current antipodal vertices of the facet f if (hompart*distpie1 >= pih*maxdist) { DEBUGMSG(INITIAL_VF_PAIR,"Distance of this point is greater (or equal)" <<" than all the distances before." <<"Change plane antipodal vertices."); if (hompart*distpie1 > pih*maxdist) { DEBUGMSG(INITIAL_VF_PAIR,"Compute new plane e2!"); apv.clear(); hompart=pih; maxdist=distpie1; } apv.push_back(vtxit); } ++vtxit; } A=A*hompart; B=B*hompart; C=C*hompart; D=-maxdist; K=K*hompart; #ifdef GCD_COMPUTATION simplify_solution(A,B,C,D,K); #endif DEBUGENDL(INITIAL_VF_PAIR,"Initial Plane E1: ",A<<" "<=0); CGAL_expensive_assertion(A*px+B*py+C*pz+D*ph<=0); DEBUGENDL(ASSERTION_OUTPUT,"Restriction values: E1:", A*px+B*py+C*pz+K*ph<<" and E2: "< sol; sol.push_back(A); sol.push_back(B); sol.push_back(C); sol.push_back(D); sol.push_back(K); allsolutions.push_back(sol); alloptimal.push_back(sol); //Compute the squared width with the determined coefficients WNum=(K-D)*(K-D); WDenom=A*A+B*B+C*C; DEBUGENDL(INITIAL_VF_PAIR,"Initial squared width: ", WNum<<"/"<halfedge(); go_on.push_back(e); dao.set_visited_flag(e,true); typename InputDA::Halfedge_handle e0 = e; e = e->next(); while ( e != e0 ) { go_on.push_back(e); dao.set_visited_flag(e,true); e=e->next(); } DEBUGMSG(INITIAL_VF_PAIR,"End INITIAL_VF_PAIR"); } // *** CHECK_ABOUT_VF_PAIRS *** //------------------------------ //This function checks if a facet and a subset of a given set of vertices //build a vertex facet pair template bool check_about_VF_pairs(InputDA& dao, Facet_handle_& f, const std::vector& V) { DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"\nBegin CHECK_ABOUT_VF_PAIRS"); DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"Check, if f has antipodal vertices in " <<"a set."); RT a,b,c,d,k; typename std::vector ::const_iterator vtxit=V.begin(); std::vector W; typename std::vector ::iterator neighborit; bool feasible=false; std::vector apv; std::vector visited_points; while (vtxit!=V.end()) { RT vx,vy,vz,vh; tco.get_point_coordinates((*vtxit)->point(),vx,vy,vz,vh); tco.get_plane_coefficients(f->plane(),a,b,c,k); //assume plane e2 parallel to e1 through v: e2:axh+byh+czh+d=0 d = -a*vx - b*vy - c*vz; CGAL_assertion(vh > 0); DEBUGMSG(ASSERTION_OUTPUT,"vh is greater than zero (strictly). " <<"ASSERTION OK."); a=tco.get_a(f->plane())*vh; b=tco.get_b(f->plane())*vh; c=tco.get_c(f->plane())*vh; k=tco.get_d(f->plane())*vh; CGAL_assertion(a*vx+b*vy+c*vz+k*vh>=0); CGAL_assertion(a*vx+b*vy+c*vz+d*vh==0); DEBUGMSG(ASSERTION_OUTPUT,"Checked: Point on the right side of e1, and " <<"on e2. ASSERTION OK>"); //If v lies on plane e1 then we can continue (v is not antipodal) if (d == k) { CGAL_assertion(a*vx+b*vy+c*vz+k*vh==0); DEBUGENDL(CHECK_ABOUT_VF_PAIRS,"Point "<<(*vtxit)->point() <<" lies on plane ",f->plane()<<". Continue."); ++vtxit; continue; } CGAL_assertion(a*vx+b*vy+c*vz+k*vh>0); DEBUGMSG(ASSERTION_OUTPUT,"v not on e1. ASSERTION OK."); //Else we look if we can find a witness in the neighborhood of v that //shows that v is not an antipodal vertex of f neighbors_of((*vtxit)->halfedge(),W); //Assume there is no witness for infeasibility feasible = true; //Scan all possible witnesses while(!W.empty()) { neighborit=W.begin(); visited_points.push_back(*neighborit); RT nx,ny,nz,nh; tco.get_point_coordinates((*neighborit)->point(),nx,ny,nz,nh); //Check if n (neighbor of v) satisfies restriction type e2 //with the presumed plane e2, ie anx+bny+cnz-Dv<=0 CGAL_assertion(a*nx+b*ny+c*nz+k*nh>=0); DEBUGMSG(ASSERTION_OUTPUT,"Restrictions E1 is satisfied. " <<"ASSERTION OK."); if ( a*nx+b*ny+c*nz+d*nh >= 0 ) { //Could be a violation. Now check if v and n lie on the //same plane. If so no violation, othervise we can break if (a*nx+b*ny+c*nz+d*nh == 0 ) { DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"Additional Antipodal Vertex " <<"found. Expanding "<<"set of witnesses."); //v and n are both (so far) antipodal vertices ==>EF-pair apv.push_back(*neighborit); //There could now be more witnesses that give violating //restrictions. Therefore compute the new neighbors of n std::vector Wnew; neighbors_of((*neighborit)->halfedge(),Wnew); //Erase v from the vertices to be considered as new witnesses typename std::vector ::iterator res= std::find(Wnew.begin(),Wnew.end(),*vtxit); if ( res!=Wnew.end() ) Wnew.erase(res); //Erase all the elements we already considered from the new //set of witnesses setminus(Wnew,visited_points); //Erase the neighbor vertex itself from the set of witnesses W.erase(neighborit); //Compute the new whole set of witnesses, that is add the //remaining new ones to the old set of witnesses setunion(W,Wnew); } else { DEBUGENDL(CHECK_ABOUT_VF_PAIRS,"Violation found. Not a feasible " <<"solution. Violated Point:",(*neighborit)->point()); //there is a violation, so do a break feasible = false; break; } } else { DEBUGENDL(CHECK_ABOUT_VF_PAIRS,"Restriction E2 also satisfied by " <<"point:",(*neighborit)->point()); //There is no violating restriction according to the vertex n //Erase it from the set of witnesses W.erase(neighborit); } } //end while(!W.empty()) //Now we can determine if we have a feasible solution or not. Because //the feasible flag can only be set to false during the while-loop //we can be sure of the feasibility of our solution (no witness found) //if feasible is false then we have found a witness that v is not an //antipodal vertex. So we go on in the list of possible antipodal //vertices otherwise. if (feasible == true) { DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"All witnesses checked. " <<"Update width and antipodal vertices. Return true"); apv.push_back(*vtxit); #ifdef GCD_COMPUTATION simplify_solution(a,b,c,d,k); #endif update_width(a,b,c,d,k); dao.set_antipodal_vertices(f,apv); #ifdef VF_PAIR_OUTPUT DEBUGENDL(VF_PAIR_OUTPUT,"Antipodal vertices of plane: ", f->plane()); typename std::vector::iterator cavfpit=apv.begin(); while(cavfpit!=apv.end()) { DEBUGENDL(VF_PAIR_OUTPUT,"Antipodal Vertex: ", (*cavfpit)->point()); ++cavfpit; } #endif DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"End CHECK_ABOUT_VF_PAIRS"); return true; } ++vtxit; }//end while(vtxit!=V.end()) //If we could not return with antipodal vertices we return false DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"No new VF-pair found. Return false."); DEBUGMSG(CHECK_ABOUT_VF_PAIRS,"End CHECK_ABOUT_VF_PAIRS"); return false; } // *** UPDATE_WIDTH *** //---------------------- //This function we use to update the current best width. The old width is //compared with a new provided one and the better solution will we taken //as the new width. This function also saves all the possible quadruples //to be the width of the point set. void update_width(RT& a, RT& b, RT& c, RT& d, RT& k) { //Update the list of all possible solutions DEBUGMSG(UPDATE_WIDTH,"\nBegin UPDATE_WIDTH"); std::vector sol; sol.push_back(a); sol.push_back(b); sol.push_back(c); sol.push_back(d); sol.push_back(k); allsolutions.push_back(sol); //Compute the squared width provided by the new solution RT tocompareNum=(k-d)*(k-d); RT tocompareDenom=(a*a+b*b+c*c); DEBUGENDL(UPDATE_WIDTH,"New possible width: ",tocompareNum <<" / "<= tocompareNum*WDenom) { if (WNum*tocompareDenom > tocompareNum*WDenom){ DEBUGMSG(UPDATE_WIDTH,"Optimal width changes"); WNum=tocompareNum; WDenom=tocompareDenom; alloptimal.clear(); alloptimal.push_back(sol); A=a; B=b; C=c; D=d; K=k; } else { //now we have an additional optimal solution alloptimal.push_back(sol); } }//end if equal or better width DEBUGMSG(UPDATE_WIDTH,"End UPDATE_WIDTH"); } // *** EE_COMPUTATION *** //------------------------ //During the 3rd phase of the width-algorithm we have to rotate planes to //enumerate all possible edge-edge pairs. This rotating (in primal context) //resp. tracking edges (in the dual context) is made by the following //function. The edge we rotate about is called e. To ensure only to //enumerate a pair once (...only going forward) we need a set of //already visited vertices (Visited) and a set of vertices from that we know //they are antipodal to the first facet (V). In this function we don't //know the antipodal vertices of the second facet. template void EE_computation(InputDA, Halfedge_handle_& e, std::vector& V, std::vector& Visited, std::vector& Nnew) { DEBUGMSG(EE_COMPUTATION,"\nBegin EE_COMPUTATION"); //Compute end points of e and two witnesses: Each in one of the two //facets participating Point_3 p,q; p=e->opposite()->vertex()->point(); q=e->vertex()->point(); typename InputDA::Vertex_handle w1=e->next()->vertex(); typename InputDA::Vertex_handle w2=e->opposite()->next()->vertex(); //prepare for the rotating procedure Nnew.clear(); typename std::vector ::iterator vtxit=V.begin(); //Consider all the vertices in V. EE-pairs consist of p,q and the //vertex v in V and another neighbor vertex of v while(vtxit != V.end() ) { std::vector R; neighbors_of((*vtxit)->halfedge(),R); std::vector Witnesses; //The set of witnesses are all neighbor vertices of v (=R) and the //two vertices "on the other side" that ensure not rotating too far Witnesses.push_back(w1); Witnesses.push_back(w2); setunion(Witnesses,R); //The neighbor vertices of v that are also in the basic set V are of no //interest, so we exclude them setminus(R,V); //The set of all vertices we have already visited is also of no interest setminus(R,Visited); typename std::vector ::iterator rit=R.begin(); //Now look at the modified set of neighbor vertices. For each neighbor r //we assume (p,q) and (v,r) to be an EE-pair and want then to find //witnesses that against this quadruple. If no such witness exist //(p,q) and (v,r) are a legal EE-pair. In that case we break the //quest and update all the sets Visited Nnew and V. If we have considered //all vertices v in V and all the respective r in R and if we have //not found a legal EE-pair, then an error occurs while (rit!=R.end()) { RT a,b,c,d,k; //It could be that the system is not uniquely solvable we only want to //enumerate proper solutions no degenerate ones if(solve_4x4(InputDA(),p,q,(*rit)->point(),(*vtxit)->point(), a,b,c,d,k)){ DEBUGMSG(EE_COMPUTATION,"Now we check if the provided " <<"solution is a feasible one."); #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG)) RT px,py,pz,ph; tco.get_point_coordinates(p,px,py,pz,ph); CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0); CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0); tco.get_point_coordinates(q,px,py,pz,ph); CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0); CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0); tco.get_point_coordinates((*rit)->point(),px,py,pz,ph); CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0); CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0); tco.get_point_coordinates((*vtxit)->point(),px,py,pz,ph); CGAL_expensive_assertion(a*px+b*py+c*pz+k*ph>=0); CGAL_expensive_assertion(a*px+b*py+c*pz+d*ph<=0); DEBUGMSG(ASSERTION_OUTPUT,"All restrictions to the 4 points " <<"are satisfied. ASSERTION OK."); #endif if (check_feasibility(InputDA(),a,b,c,d,k,Witnesses)) { DEBUGMSG(EE_COMPUTATION,"Update Width and compute all " <<"active restrictions"); //Therefore we update the width update_width(a,b,c,d,k); //The next region we consider (because we only go forward) //contains (at least) r Nnew.push_back(*rit); //Now we look if we are in a special case, that is we look if //other restrictions according to neighboring vertices of r //are also active. If so Nnew is expanded we them. std::vector S; neighbors_of((*rit)->halfedge(),S); //Because we only go forward we exclude v from the neighbor set S std::vector vtemp; vtemp.push_back(*vtxit); setminus(S,vtemp); //The check of more than 4 active restrictions begins typename std::vector ::iterator sit; while(!S.empty()) { sit=S.begin(); RT sx,sy,sz,sh; tco.get_point_coordinates((*sit)->point(),sx,sy,sz,sh); if (a*sx+b*sy+c*sz+d*sh==0) { //This special case occurs now. Thus we extend Nnew Nnew.push_back(*sit); //In the neighborhood of this new active vertex could //also be other new active vertices but we are only interested //in new ones std::vector T; neighbors_of((*sit)->halfedge(),T); S.erase(sit); setunion(S,T); T.clear(); T.push_back(*vtxit); setminus(S,T); setminus(S,Nnew); } else { //s is not active and we can erase it S.erase(sit); } } //end while (!S.empty()) //Since we have now enumerated all EE-pairs with the active //restrictions according to p,q and v we can now leave //Nnew contains now all new active restrictions DEBUGMSG(EE_COMPUTATION,"End EE_COMPUTATION"); return; } //end if (feasible) }//end if(proper) //Try next r ++rit; }//end while(!R.empty()) //Try new v ++vtxit; } //There must be a new EE-pair. If not, an error occurs std::cerr<<"No new EE-pair found!"< void EE_pairs(InputDA& dao, Halfedge_handle_& e, std::vector& impassable) { DEBUGMSG(EE_PAIRS,"\nBegin EE_PAIRS"); Point_3 p,q; p=e->opposite()->vertex()->point(); q=e->vertex()->point(); typename InputDA::Vertex_handle w1=e->next()->vertex(); typename InputDA::Vertex_handle w2=e->opposite()->next()->vertex(); typename InputDA::Facet_handle f1=e->facet(); typename InputDA::Facet_handle f2=e->opposite()->facet(); std::vector V1; std::vector V2; dao.get_antipodal_vertices(f1,V1); dao.get_antipodal_vertices(f2,V2); std::vector N,V,Visited; V=V1; bool do_break = false; while (!setcut(V,V2)) { do_break = false; typename std::vector ::iterator vtxit=V.begin(); std::vector R; while (vtxit!=V.end()) { neighbors_of((*vtxit)->halfedge(),R); std::vector Witnesses; Witnesses.push_back(w1); Witnesses.push_back(w2); setunion(Witnesses,R); setminus(R,V); setminus(R,Visited); typename std::vector ::iterator rit=R.begin(); while (rit!=R.end()) { RT a,b,c,d,k; //It could be that the system is not uniquely solvable we only want //to enumerate proper solutions no degenerate ones if(solve_4x4(InputDA(),p,q,(*rit)->point(),(*vtxit)->point(), a,b,c,d,k)){ if (check_feasibility(InputDA(),a,b,c,d,k,Witnesses)) { update_width(a,b,c,d,k); N.push_back(*rit); std::vector S; neighbors_of((*rit)->halfedge(),S); setminus(S,V); typename std::vector ::iterator sit; while(!S.empty()) { sit=S.begin(); RT sx,sy,sz,sh; tco.get_point_coordinates((*sit)->point(),sx,sy,sz,sh); if (a*sx+b*sy+c*sz+d*sh== 0) { N.push_back(*sit); std::vector T; neighbors_of((*sit)->halfedge(),T); S.erase(sit); setunion(S,T); T.clear(); T.push_back(*vtxit); setminus(S,T); setminus(S,N); } else { S.erase(sit); } }//end while (!S.empty()) do_break=true; break; }//if (feasible) }//if(proper) ++rit; }//end while(!R.empty()) if (do_break == true) break; ++vtxit; }//end while(!V.end()) setunion(Visited,V); V=N; } impassable.pop_back(); //Go on with next edge DEBUGMSG(EE_PAIRS,"End EE_PAIRS"); } // *** ORIGIN_INSIDE_CH *** //------------------------- // To ensure that zero lies completly inside the convex hull of a point set. // Returns true if the point set is not coplanar, false otherwise // PRECONDITION: Iterator range has at least 3 points template bool origin_inside_CH(Vertex_iterator_& start, Vertex_iterator_& beyond, InputDA){ DEBUGMSG(ORIGIN_INSIDE_CH,"\nBegin ORIGIN_INSIDE_CH"); typename InputDA::Vertex_iterator first=start; //Take 4 points that build a tetrahedron. This tetrahedron is also //contained in the convex hull of the points. Thus every point //in/on this tetrahedron is a valable point for a new origin typename InputDA::PolyPoint p,q,r,s; p=(*first).point(); ++first; q=(*first).point(); ++first; r=(*first).point(); ++first; RT px,py,pz,ph,qx,qy,qz,qh,rx,ry,rz,rh; tco.get_point_coordinates(p,px,py,pz,ph); tco.get_point_coordinates(q,qx,qy,qz,qh); tco.get_point_coordinates(r,rx,ry,rz,rh); CGAL_assertion(ph>0 && qh>0 && rh>0); RT tmpa,tmpb,tmpc,tmpk; tmpk=px*(qy*rz-ry*qz)-qx*(py*rz-ry*pz)+rx*(py*qz-qy*pz); tmpa=-ph*(qy*rz-ry*qz)+qh*(py*rz-ry*pz)-rh*(py*qz-qy*pz); tmpb=px*(rh*qz-qh*rz)-qx*(rh*pz-ph*rz)+rx*(qh*pz-ph*qz); tmpc=px*(ry*qh-qy*rh)-qx*(ry*ph-py*rh)+rx*(qy*ph-py*qh); #ifdef GCD_COMPUTATION RT dummy=0; DEBUGENDL(ORIGIN_INSIDE_CH,"Solution of 3x3 (before GCD " <<"computation):\n",tmpa< sol; sol.push_back(A); sol.push_back(B); sol.push_back(C); sol.push_back(D); sol.push_back(K); allsolutions.push_back(sol); alloptimal.push_back(sol); DEBUGMSG(ORIGIN_INSIDE_CH,"End ORIGIN_INSIDE_CH"); return false; } else { s=(*first).point(); RT sx,sy,sz,sh; tco.get_point_coordinates(s,sx,sy,sz,sh); //Ensure that the 4 points are not coplanar. If so take another 4th point while (tmpa*sx+tmpb*sy+tmpc*sz+tmpk*sh==0 && first!=beyond) { s=(*first).point(); tco.get_point_coordinates(s,sx,sy,sz,sh); ++first; } //If we could not find a valable 4th point, then the set of the points //is coplanar. Therefore the width is zero and we can terminate the //algorithm if (tmpa*sx+tmpb*sy+tmpc*sz+tmpk*sh==0) { DEBUGMSG(ORIGIN_INSIDE_CH,"n coplanar Points. Compute plane through " <<"these points. Width=0."); WNum=0; WDenom=1; A=tmpa; B=tmpb; C=tmpc; K=tmpk; DEBUGENDL(ORIGIN_INSIDE_CH,"Solution of 3x3:\n",A< sol; sol.push_back(A); sol.push_back(B); sol.push_back(C); sol.push_back(D); sol.push_back(K); allsolutions.push_back(sol); alloptimal.push_back(sol); DEBUGMSG(ORIGIN_INSIDE_CH,"End ORIGIN_INSIDE_CH"); return false; } else { //Take center of tetrahedron pqrs RT ux,uy,uz,uh,vx,vy,vz,vh,nox,noy,noz,noh; ux=px*qh+ph*qx; vx=rx*sh+rh*sx; uy=py*qh+ph*qy; vy=ry*sh+rh*sy; uz=pz*qh+ph*qz; vz=rz*sh+rh*sz; uh=RT(2)*ph*qh; vh=RT(2)*rh*sh; nox=ux*vh+uh*vx; noy=uy*vh+uh*vy; noz=uz*vh+uh*vz; noh=RT(2)*uh*vh; neworigin=tco.make_point(nox,noy,noz,noh); CGAL_assertion(noh!=0); DEBUGENDL(ORIGIN_INSIDE_CH,"New Origin: ",neworigin); //Translate all the points first=start; while(first!=beyond) { typename InputDA::PolyPoint tmp=(*first).point(); RT tmpx,tmpy,tmpz,tmph; tco.get_point_coordinates(tmp,tmpx,tmpy,tmpz,tmph); RT newx,newy,newz,newh; newx=tmpx*noh-tmph*nox; newy=tmpy*noh-tmph*noy; newz=tmpz*noh-tmph*noz; newh=tmph*noh; DEBUGENDL(ORIGIN_INSIDE_CH,"Old Point: ",(*first).point()); #ifdef GCD_COMPUTATION RT dummy=0; simplify_solution(newx,newy,newz,newh,dummy); #endif (*first).point()=tco.make_point(newx,newy,newz,newh); DEBUGENDL(ORIGIN_INSIDE_CH,"New Point: ",(*first).point()); ++first; } DEBUGMSG(ORIGIN_INSIDE_CH,"Zero now inside polyhedron."); DEBUGMSG(ORIGIN_INSIDE_CH,"End ORIGIN_INSIDE_CH"); return true; } } } /* ****************************************************** */ /* *** --- *** The main enumeration functions *** --- *** */ /* ****************************************************** */ template void width_3_convex(InputPolyhedron &P) { DEBUGMSG(WIDTH_3_CONVEX,"\nBegin WIDTH_3_CONVEX"); typedef CGAL::Data_access DA; typedef typename DA::Polyhedron Polyhedron; typedef typename DA::Vertex Vertex; typedef typename DA::Facet Facet; typedef typename DA::Halfedge Halfedge; typedef typename DA::Facet_handle Facet_handle; typedef typename DA::Vertex_handle Vertex_handle; typedef typename DA::Halfedge_handle Halfedge_handle; typedef typename DA::PolyPoint PolyPoint; typedef typename DA::Plane Plane; typedef typename DA::Halfedge_iterator Halfedge_iterator; typedef typename DA::Vertex_iterator Vertex_iterator; typedef typename DA::Facet_iterator Facet_iterator; //Ensure that Polyhedron has at least one vertex CGAL_assertion_msg(P.size_of_vertices()>2, "Can not compute width of a 0, 1 or 2-vertex polyhedron"); Vertex_iterator first=P.vertices_begin(); Vertex_iterator beyond=P.vertices_end(); //Begin with Phase 2 if (origin_inside_CH(first,beyond,DA())) { DEBUGMSG(WIDTH_3_CONVEX,"Origin is now Inside the Polyhedron. " < go_on; std::vector impassable; //Ensure that the plane equations are determined because of the //compare operator in DA Facet_handle feq=P.facets_begin(); while(feq!=P.facets_end()) { compute_plane_equation(DA(),feq); ++feq; } DEBUGMSG(WIDTH_3_CONVEX,"All plane equations of all facets computed."); //ensure all flags are false #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG)) int halfedgecount=0; #endif Halfedge_handle esf=P.halfedges_begin(); while(esf!=P.halfedges_end()) { #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG)) ++halfedgecount; #endif DEBUGENDL(EDGE_INITIALIZING,"Edge e: " <opposite()->vertex()->point() <<" --> ",esf->vertex()->point()); dao.set_visited_flag(esf,false); dao.set_impassable_flag(esf,false); ++esf; } #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG)) CGAL_assertion(int(P.size_of_halfedges())==halfedgecount); DEBUGENDL(WIDTH_3_CONVEX,"Visited all ",halfedgecount <<" halfedges. ASSERTION OK."); CGAL_assertion(dao.size_of_visited()==halfedgecount); CGAL_assertion(dao.size_of_impassable()==halfedgecount); DEBUGMSG(WIDTH_3_CONVEX,"Map sizes of visited and impassable " <<"halfedges are correct. ASSERTION OK."); #endif DEBUGMSG(WIDTH_3_CONVEX,"All flags set to false."); //Now begin with the main enumeration Facet_handle f = P.facets_begin(); initial_VF_pair(dao,f,P,go_on); #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG)) Vertex_iterator vtxass=P.vertices_begin(); while(vtxass!=P.vertices_end()) { RT px,py,pz,ph; tco.get_point_coordinates(vtxass->point(),px,py,pz,ph); CGAL_expensive_assertion(A*px+B*py+C*pz+K*ph>=0); CGAL_expensive_assertion(A*px+B*py+C*pz+D*ph<=0); ++vtxass; } //Assert that the initial facet has antipodal vertices //and that all incident edges are visited (flag=true) but //that the impassable flag is not set yet. std::vector avass; dao.get_antipodal_vertices(f,avass); DEBUGENDL(ASSERTION_OUTPUT,"Size of avass: ",avass.size()); CGAL_expensive_assertion(avass.size()!=0); Halfedge_handle eass=f->halfedge(); Halfedge_handle eass0=eass; CGAL_expensive_assertion(dao.is_visited(eass)); CGAL_expensive_assertion(!dao.is_impassable(eass)); eass=eass->next(); while (eass != eass0) { CGAL_expensive_assertion(dao.is_visited(eass)); CGAL_expensive_assertion(!dao.is_impassable(eass)); eass=eass->next(); } DEBUGMSG(ASSERTION_OUTPUT,"All edges of the first initial facet " <<"has a visited flag."); #endif // Begin Phase 3 Facet_handle fnext; Halfedge_handle e; std::vector Visited; std::vector N; std::vector Nnew; //While there still exist an edge we can rotate an incident facet with //known antipodal vertices in the other facet with unknown antipodal //vertices then do this rotation while ( !go_on.empty()) { DEBUGENDL(WIDTH_3_CONVEX,"Size of go_on: ",go_on.size()); #ifdef GO_ON_OUTPUT DEBUGMSG(GO_ON_OUTPUT,"Edges on stack go_on:"); typename std::vector::iterator goonit=go_on.begin(); while(goonit!=go_on.end()) { DEBUGENDL(GO_ON_OUTPUT,"Edge: ", (*goonit)->opposite()->vertex()->point()<<" --> " <<(*goonit)->vertex()->point()); ++goonit; } #endif //Take last edge on stack go_on e=go_on.back(); //Check if e is a proper edge or not. If so determine fnext if (preparation_check(dao,e,fnext,go_on,impassable)) { DEBUGMSG(WIDTH_3_CONVEX,"Preparation Check succesful"); //f is the facet of which we know the antipodal vertices f=e->facet(); Visited.clear(); dao.get_antipodal_vertices(f,N); CGAL_assertion (!N.empty()); DEBUGMSG(ASSERTION_OUTPUT,"f has some antipodal vertices. Assertion " <<"succesful."); while(!check_about_VF_pairs(dao,fnext,N)) { DEBUGMSG(WIDTH_3_CONVEX,"No new VF-pair. Continue (Begin) " <<"rotation of the planes."); EE_computation(DA(),e,N,Visited,Nnew); DEBUGMSG(WIDTH_3_CONVEX,"Planes have been rotated. Check now " <<"for a new VF-pair"); setunion(Visited,N); N=Nnew; } } } #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE))\ || defined(NDEBUG)) Facet_handle fass=P.facets_begin(); while(fass!=P.facets_end()) { std::vector apvass; dao.get_antipodal_vertices(fass,apvass); DEBUGENDL(ASSERTION,"Current checking facet: ",fass->plane()); CGAL_assertion(!apvass.empty()); ++fass; } DEBUGMSG(ASSERTION,"All facets have antipodal vertices. " <<"ASSERTION OK."); Facet_handle fec = P.facets_begin(); std::vector fakego_on; DA daoec; while(fec!=P.facets_end()) { std::vector avec; std::vector avivf; initial_VF_pair(daoec,fec,P,fakego_on); daoec.get_antipodal_vertices(fec,avec); dao.get_antipodal_vertices(fec,avivf); CGAL_assertion(int(avivf.size())==int(avec.size())); CGAL_assertion(int(avec.size())>0); DEBUGENDL(EXPENSIVE_CHECKS_OUTPUT,"Antipodal vertices of facet: (" <halfedge()->opposite()->vertex()->point() <<"), (",fec->halfedge()->vertex()->point()<<"), (" <halfedge()->next()->vertex()->point()<<")"); std::vector::iterator vtxit=avec.begin(); while(vtxit!=avec.end()) { std::vector::iterator it; it=std::find(avivf.begin(),avivf.end(),*vtxit); CGAL_assertion(it!=avivf.end()); DEBUGENDL(EXPENSIVE_CHECKS_OUTPUT,"Antipodal vertex: ", (*vtxit)->point()); ++vtxit; } ++fec; } DEBUGMSG(EXPENSIVE_CHECKS_OUTPUT,"All VF-pairs verified. " <<"Expensive Check successful."); // // This assertion should not currently be true since the convex hull // polyhedron is triangulated; no postprocessing is done to merge coplanar // neighboring facets. // // CGAL_assertion(dao.size_of_antipodal_vertices() // ==int(P.size_of_facets())); #endif //Begin with phase 4. As long as the set of impassable edges is not empty //rotate one of the planes into the other sharing the impassable edge while(!impassable.empty()) { //Take top edge on stack impassable e=impassable.back(); EE_pairs(dao,e,impassable); //In EE_pairs the top element will be removed } } DEBUGMSG(WIDTH_3_CONVEX,"Width computed."); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/0000755000175000017500000000000012146213701027512 5ustar debiandebian././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2_core.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_ar0000644000175000017500000022662111344301501031156 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2_core.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_CONIC_ARC_2_CORE_H #define CGAL_CONIC_ARC_2_CORE_H #include #include #include #include #include #include #include #include #define CGAL_CONIC_ARC_USE_CACHING CGAL_BEGIN_NAMESPACE /*! * A class that stores additional information with the point's coordinates: * Namely the conic IDs of the generating curves. */ template class Point_ex_2 : public Kernel_::Point_2 { public: typedef Kernel_ Kernel; typedef typename Kernel::Point_2 Base; typedef Point_ex_2 Self; typedef typename Kernel::FT CoNT; private: int _id1; // The ID of the first generating conic (or 0). int _id2; // The ID of the second generating conic (or 0). public: // Constructors. Point_ex_2 () : Base(), _id1(0), _id2(0) {} Point_ex_2 (const CoNT& hx, const CoNT& hy, const CoNT& hz) : Base(hx,hy,hz), _id1(0), _id2(0) {} Point_ex_2 (const CoNT& hx, const CoNT& hy, const int& id1 = 0, const int& id2 = 0) : Base(hx,hy), _id1(id1), _id2(id2) {} Point_ex_2 (const Base& p) : Base(p), _id1(0), _id2(0) {} Point_ex_2 (const Base& p, const int& id1, const int& id2 = 0) : Base(p), _id1(id1), _id2(id2) {} // Set the generating conic IDs. void set_generating_conics (const int& id1, const int& id2 = 0) { _id1 = id1; _id2 = id2; return; } // Check if the given conic generates the point. bool is_generating_conic_id (const int& id) const { return (id != 0 && (id == _id1 || id == _id2)); } // Check whether two points are equal. bool equals (const Self& p) const { // If the two points are the same: if (this == &p) return (true); // Use the parent's equality operator. return ((*this) == p); } // Compare the x coordinates. Comparison_result compare_x (const Self& p) const { return (CGAL_NTS compare(x(), p.x())); } // Compare the y coordinates. Comparison_result compare_y (const Self& p) const { return (CGAL_NTS compare(y(), p.y())); } // Compare two points lexicographically. Comparison_result compare_lex_xy (const Self& p) const { Comparison_result res = this->compare_x (p); if (res != EQUAL) return (res); return (this->compare_y (p)); } }; /*! * Representation of a conic arc -- a bounded segment that lies on a conic * curve, the loci of all points satisfying the equation: * r*x^2 + s*y^2 + t*xy + u*x + v*y +w = 0 * * The class is templated with two parameters: * CfNT_ is a number type for representing the conic coefficients (integers). * Kernel_ is a geometric kernel, where Kernel_::FT is the number type for the * coordinates of points (which are algebraic numbers). */ static int _conics_count = 0; template class Arr_conic_traits_2; template class Conic_arc_2 { protected: typedef Conic_arc_2 Self; public: typedef CfNT_ CfNT; typedef Kernel_ Kernel; typedef typename Kernel::FT CoNT; typedef Point_ex_2 Point_2; typedef Segment_2 Segment_2; typedef Circle_2 Circle_2; protected: friend class Arr_conic_traits_2; enum { DEGREE_0 = 0, DEGREE_1 = 1, DEGREE_2 = 2, DEGREE_MASK = 1 + 2, FULL_CONIC = 4, X_MONOTONE = 8, X_MON_UNDEFINED = 8 + 16, FACING_UP = 32, FACING_DOWN = 64, FACING_MASK = 32 + 64, IS_CIRCLE = 128, IS_HYPERBOLA = 256 }; CfNT _r; // CfNT _s; // The coefficeint of the underlying conic curve: CfNT _t; // CfNT _u; // CfNT _v; // r*x^2 + s*y^2 + t*xy + u*x + v*y +w = 0 CfNT _w; // Orientation _orient; // The orientation of the conic. int _conic_id; // The id of the conic. Point_2 _source; // The source of the arc. Point_2 _target; // The target of the arc. int _info; // A bit array with extra information: // Bit 0 & 1 - The degree of the conic // (either 1 or 2). // Bit 2 - Whether the arc is a full conic. // Bit 3 & 4 - Whether the arc is x-monotone // (00, 01 or 11 - undefined). // Bit 5 & 6 - Indicate whether the arc is // facing upwards or downwards (for // x-monotone curves of degree 2). // Bit 7 - Is the underlying curve a circle. // Bit 8 - Is the underlying curve a hyperbola. // For arcs whose base is a hyperbola we store the axis (a*x + b*y + c = 0) // which separates the two bracnes of the hyperbola. We also store the side // (-1 or 1) that the arc occupies. struct Hyperbolic_arc_data { CoNT a; CoNT b; CoNT c; int side; }; // In case of a circle, is is convinient to store its center and radius. struct Circular_arc_data { CoNT x0; CoNT y0; CoNT r; }; #ifdef CGAL_CONIC_ARC_USE_CACHING struct Intersections { int id1; int id2; int n_points; Point_2 ps[4]; }; #endif union { Hyperbolic_arc_data *hyper_P; Circular_arc_data *circ_P; } _data; // Produce a unique id for a new conic. int _get_new_conic_id () { _conics_count++; return (_conics_count); } /*! * Protected constructor: Construct an arc which is a segment of the given * conic arc, with a new source and target points. * \param The copied arc. * \param source The new source point. * \param target The new target point. */ Conic_arc_2 (const Self & arc, const Point_2& source, const Point_2 & target) : _r(arc._r), _s(arc._s), _t(arc._t), _u(arc._u), _v(arc._v), _w(arc._w), _orient(arc._orient), _conic_id(arc._conic_id), _source(source), _target(target) { _info = (arc._info & DEGREE_MASK) | X_MON_UNDEFINED; // Check whether the conic is x-monotone. if (is_x_monotone()) { _info = (_info & ~X_MON_UNDEFINED) | X_MONOTONE; // Check whether the facing information is set for the orginating arc. // If it is, just copy it - otherwise calculate it if the degree is 2. Comparison_result facing_res = arc.facing(); if (facing_res != EQUAL) _info = _info | (facing_res == LARGER ? FACING_UP : FACING_DOWN); else if ((_info & DEGREE_MASK) == DEGREE_2) _set_facing(); } else { _info = (_info & ~X_MON_UNDEFINED); } // Copy the hyperbolic or circular data, if necessary. if ((arc._info & IS_HYPERBOLA) != 0) { _info = _info | IS_HYPERBOLA; _data.hyper_P = new Hyperbolic_arc_data (*(arc._data.hyper_P)); } else if ((arc._info & IS_CIRCLE) != 0) { _info = _info | IS_CIRCLE; _data.circ_P = new Circular_arc_data (*(arc._data.circ_P)); } else { _data.hyper_P = NULL; } } public: /*! * Default constructor. */ Conic_arc_2 () : _r(0), _s(0), _t(0), _u(0), _v(0), _w(0), _orient(CGAL::COLLINEAR), _conic_id(0), _info(X_MON_UNDEFINED) { _data.hyper_P = NULL; } /*! * Copy constructor. * \param arc The copied arc. */ Conic_arc_2 (const Self & arc) : _r(arc._r), _s(arc._s), _t(arc._t), _u(arc._u), _v(arc._v), _w(arc._w), _orient(arc._orient), _conic_id(arc._conic_id), _source(arc._source), _target(arc._target), _info(arc._info) { // Copy the hyperbolic or circular data, if necessary. if ((arc._info & IS_HYPERBOLA) != 0) { _data.hyper_P = new Hyperbolic_arc_data (*(arc._data.hyper_P)); } else if ((arc._info & IS_CIRCLE) != 0) { _data.circ_P = new Circular_arc_data (*(arc._data.circ_P)); } else { _data.hyper_P = NULL; } } /*! * Construct a conic arc which lies on the conic: * C: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 * \param orient The orientation of the arc (clockwise or couterclockwise). * \param source The source point. * \param target The target point. * \pre The source and the target must be on the conic boundary and must * not be the same. */ Conic_arc_2 (const CfNT& r, const CfNT& s, const CfNT& t, const CfNT& u, const CfNT& v, const CfNT& w, const Orientation& orient, const Point_2& source, const Point_2& target) : _r(r), _s(s), _t(t), _u(u), _v(v), _w(w), _source(source), _target(target), _info(X_MON_UNDEFINED) { // Make sure the conic contains the two end-points on its boundary. CGAL_precondition(_conic_has_on_boundary(source)); CGAL_precondition(_conic_has_on_boundary(target)); // Make sure that the source and the taget are not the same. CGAL_precondition(source != target); // Set the arc properties (no need to compute the orientation). _orient = orient; _set (false); } /*! * Construct a conic arc which is the full conic: * C: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 * \pre The conic C must be an ellipse (so 4rs - t^2 > 0). */ Conic_arc_2 (const CfNT& r, const CfNT& s, const CfNT& t, const CfNT& u, const CfNT& v, const CfNT& w) : _r(r), _s(s), _t(t), _u(u), _v(v), _w(w) { // Make sure the given curve is an ellipse. CGAL_precondition(CGAL_NTS compare(4*r*s - t*t, CfNT(0)) == LARGER); // Set the arc to be the full conic (and compute the orientation). _set_full (true); } /*! * Construct a conic arc from the given line segment, specified by its * end-points (x1,y1) and (x2, y2). */ Conic_arc_2 (const CfNT& x1, const CfNT& y1, const CfNT& x2, const CfNT& y2) : _source(CoNT(x1),CoNT(y1)), _target(CoNT(x2),CoNT(y2)) { const CfNT _zero = 0; const CfNT _one = 1; // Make sure that the source and the taget are not the same. CGAL_precondition(_source != _target); // The supporting conic is r=s=t=0, and u*x + v*y + w = 0 should hold // for both the source (x1,y1) and the target (x2, y2). if (CGAL_NTS compare (x1, x2) == EQUAL) { // The supporting conic is a vertical line, of the form x = CONST. _r = _zero; _s = _zero; _t = _zero; _u = _one; _v = _zero; _w = -x1; } else { // The supporting line is A*x + B*y + C = 0, where: // // A = y2 - y1, B = x1 - x2, C = x2*y1 - x1*y2 // _r = _zero; _s = _zero; _t = _zero; _u = y2 - y1; _v = x1 - x2; _w = x2*y1 - x1*y2; } // The orientation is zero in case of a linear object. _orient = CGAL::COLLINEAR; // Set the arc properties (no need to compute the orientation). _set (false); } /*! * Set a circular arc that lies on the given circle: * C: (x - x0)^2 + (y - y0)^2 = R^2 * \param orient The orientation of the circle. * \param source The source point. * \param target The target point. * \pre The source and the target must be on the conic boundary and must * not be the same. */ Conic_arc_2 (const CfNT& x0, const CfNT& y0, const CfNT& R, const Orientation& orient, const Point_2& source, const Point_2& target) : _source(source), _target(target), _info(X_MON_UNDEFINED) { // Produce the correponding conic: if the circle centre is (x0,y0) // and it radius is R, that its equation is: // x^2 + y^2 - 2*x0*x - 2*y0*y + (x0^2 + y0^2 - R^2) = 0 // Since this equation describes a curve with a negative (clockwise) // orientation, we multiply it by -1 if necessary to obtain a positive // (counterclockwise) orientation. const CfNT _zero = 0; if (orient == CGAL::COUNTERCLOCKWISE) { const CfNT _minus_one = -1; const CfNT _two = 2; _r = _minus_one; _s = _minus_one; _t = _zero; _u = _two*x0; _v = _two*y0; _w = R*R - x0*x0 - y0*y0; _orient = CGAL::COUNTERCLOCKWISE; } else { const CfNT _one = 1; const CfNT _minus_two = -2; _r = _one; _s = _one; _t = _zero; _u = _minus_two*x0; _v = _minus_two*y0; _w = x0*x0 + y0*y0 - R*R; _orient = CGAL::CLOCKWISE; } // Make sure the circle contains the two endpoints on its boundary. CGAL_precondition(_conic_has_on_boundary(source)); CGAL_precondition(_conic_has_on_boundary(target)); // Make sure that the source and the taget are not the same. CGAL_precondition(source != target); // Prepare the auxiliary data structure. Circular_arc_data *circ_data_P = new Circular_arc_data; circ_data_P->x0 = CoNT(x0); circ_data_P->y0 = CoNT(y0); circ_data_P->r = CoNT(R); // Set the arc properties (no need to compute the orientation). _set (false, circ_data_P); } /*! * Set a circular arc that corresponds to the full circle: * C: (x - x0)^2 + (y - y0)^2 = R^2 */ Conic_arc_2 (const CfNT& x0, const CfNT& y0, const CfNT& R) { // Produce the correponding conic: if the circle centre is (x0,y0) // and it radius is R, that its equation is: // x^2 + y^2 - 2*x0*x - 2*y0*y + (x0^2 + y0^2 - R^2) = 0 // Note that this equation describes a curve with a negative (clockwise) // orientation. const CfNT _zero = 0; const CfNT _one = 1; const CfNT _minus_two = -2; _r = _one; _s = _one; _t = _zero; _u = _minus_two*x0; _v = _minus_two*y0; _w = x0*x0 + y0*y0 - R*R; _orient = CGAL::CLOCKWISE; // Prepare the auxiliary data structure. Circular_arc_data *circ_data_P = new Circular_arc_data; circ_data_P->x0 = CoNT(x0); circ_data_P->y0 = CoNT(y0); circ_data_P->r = CoNT(R); // Set the arc to be the full conic (no need to compute the orientation). _set_full (false, circ_data_P); } /*! * Construct a circular arc from the given three points, specified by the * coordinates (x1,y1), (x2,y2) and (x3, y3). * (x1,y1) is the arc source and (x3,y3) is the arc target. * \pre The three points must not be collinear. */ Conic_arc_2 (const CfNT& x1, const CfNT& y1, const CfNT& x2, const CfNT& y2, const CfNT& x3, const CfNT& y3, const bool& ) : _source(CoNT(x1),CoNT(y1)), _target(CoNT(x3),CoNT(y3)), _info(X_MON_UNDEFINED) { const CfNT _zero = 0; const CfNT _two = 2; // Make sure that the source and the taget are not the same. CGAL_precondition(_source != _target); // Compute the lines: A1*x + B1*y + C1 = 0, // and: A2*x + B2*y + C2 = 0, // where: const CfNT A1 = _two*(x1 - x2); const CfNT B1 = _two*(y1 - y2); const CfNT C1 = y2*y2 - y1*y1 + x2*x2 - x1*x1; const CfNT A2 = _two*(x2 - x3); const CfNT B2 = _two*(y2 - y3); const CfNT C2 = y3*y3 - y2*y2 + x3*x3 - x2*x2; // Compute the coordinates of the intersection point between the // two lines, given by (Nx / D, Ny / D), where: const CfNT Nx = B1*C2 - B2*C1; const CfNT Ny = A2*C1 - A1*C2; const CfNT D = A1*B2 - A2*B1; // Make sure the three points are not collinear. CGAL_precondition_code( const bool points_collinear = (D == _zero); ); CGAL_precondition(!points_collinear); // The equation of the underlying circle is given by: _r = D*D; _s = D*D; _t = _zero; _u = -_two*D*Nx; _v = -_two*D*Ny; _w = Nx*Nx + Ny*Ny - ((D*x2 - Nx)*(D*x2 - Nx) + (D*y2 - Ny)*(D*y2 - Ny)); // Determine the orientation: If the mid-point forms a left-turn with // the source and the target points, the orientation is positive (going // counterclockwise). // Otherwise, it is negative (going clockwise). static Kernel ker; typename Kernel::Orientation_2 orient_f = ker.orientation_2_object(); Point_2 pmid = Point_2(CoNT(x2), CoNT(y2)); if (orient_f(_source, pmid, _target) == LEFT_TURN) _orient = CGAL::COUNTERCLOCKWISE; else _orient = CGAL::CLOCKWISE; // Prepare the auxiliary data structure. Circular_arc_data *circ_data_P = new Circular_arc_data; circ_data_P->x0 = CoNT(Nx) / CoNT(D); circ_data_P->y0 = CoNT(Ny) / CoNT(D); circ_data_P->r = CGAL::sqrt (CoNT((D*x2 - Nx)*(D*x2 - Nx) + (D*y2 - Ny)*(D*y2 - Ny)) / CoNT(D*D)); // Set the arc properties (no need to compute the orientation). _set (false, circ_data_P); } /*! * Destructor. */ virtual ~Conic_arc_2 () { if ((_info & IS_HYPERBOLA) != 0) delete _data.hyper_P; else if ((_info & IS_CIRCLE) != 0) delete _data.circ_P; _data.hyper_P = NULL; } /*! * Assignment operator. * \param arc The copied arc. */ const Self& operator= (const Self& arc) { if (this == &arc) return (*this); // Free any existing data. if ((_info & IS_HYPERBOLA) != 0) delete _data.hyper_P; else if ((_info & IS_CIRCLE) != 0) delete _data.circ_P; _data.hyper_P = NULL; // Copy the arc's attributes. _r = arc._r; _s = arc._s; _t = arc._t; _u = arc._u; _v = arc._v; _w = arc._w; _orient = arc._orient; _conic_id = arc._conic_id; _source = arc._source; _target = arc._target; _info = arc._info; // Duplicate the data for hyperbolic or circular arcs. if ((arc._info & IS_HYPERBOLA) != 0) { _data.hyper_P = new Hyperbolic_arc_data (*(arc._data.hyper_P)); } else if ((arc._info & IS_CIRCLE) != 0) { _data.circ_P = new Circular_arc_data (*(arc._data.circ_P)); } return (*this); } /*! * Get the coefficients of the underlying conic. */ const CfNT& r () const {return (_r);} const CfNT& s () const {return (_s);} const CfNT& t () const {return (_t);} const CfNT& u () const {return (_u);} const CfNT& v () const {return (_v);} const CfNT& w () const {return (_w);} /*! * Get the arc's source. * \return The source point. */ const Point_2& source () const { return (_source); } /*! * Get the arc's target. * \return The target point. */ const Point_2& target () const { return (_target); } /*! * Check whether the two arcs are the same (have the same graph). * \param arc The compared arc. * \return (true) if the two arcs are equal. */ bool equals (const Self& arc) const { // Check if (*this) and arc are really the same object: if (this == &arc) return (true); // Check whether all arc features are the same. if (_orient == arc._orient) { // Same orientation: The base conics must be the same and the sources // and targets must be equal. return (this->has_same_base_conic(arc) && _source.equals(arc._source) && _target.equals(arc._target)); } else { // Opposite orientation: The base conics must be the same and the sources // and targets must be flipped. return (this->has_same_base_conic(arc) && _source.equals(arc._target) && _target.equals(arc._source)); } } /*! * Check whether the two arcs have the same base conic. * \param arc The compared arc. * \return (true) if the two base conics are the same (have the same graph). */ bool has_same_base_conic (const Self& arc) const { // In case the two arcs originiat from the same base conic: if (_conic_id == arc._conic_id) return (true); // Check whether arc equals (*this) up to a constant factor. const CfNT _zero = 0; CfNT factor1 = 1, factor2 = 1; if (CGAL_NTS compare(_r, _zero) != EQUAL) factor1 = _r; else if (CGAL_NTS compare(_s, _zero) != EQUAL) factor1 = _s; else if (CGAL_NTS compare(_t, _zero) != EQUAL) factor1 = _t; else if (CGAL_NTS compare(_u, _zero) != EQUAL) factor1 = _u; else if (CGAL_NTS compare(_v, _zero) != EQUAL) factor1 = _v; else if (CGAL_NTS compare(_w, _zero) != EQUAL) factor1 = _w; if (CGAL_NTS compare(arc._r, _zero) != EQUAL) factor2 = arc._r; else if (CGAL_NTS compare(arc._s, _zero) != EQUAL) factor2 = arc._s; else if (CGAL_NTS compare(arc._t, _zero) != EQUAL) factor2 = arc._t; else if (CGAL_NTS compare(arc._u, _zero) != EQUAL) factor2 = arc._u; else if (CGAL_NTS compare(arc._v, _zero) != EQUAL) factor2 = arc._v; else if (CGAL_NTS compare(arc._w, _zero) != EQUAL) factor2 = arc._w; return (CGAL_NTS compare (_r * factor2, arc._r * factor1) == EQUAL && CGAL_NTS compare (_s * factor2, arc._s * factor1) == EQUAL && CGAL_NTS compare (_t * factor2, arc._t * factor1) == EQUAL && CGAL_NTS compare (_u * factor2, arc._u * factor1) == EQUAL && CGAL_NTS compare (_v * factor2, arc._v * factor1) == EQUAL && CGAL_NTS compare (_w * factor2, arc._w * factor1) == EQUAL); } /*! * Check whether the arc is a full conic (i.e. a non-degenerate ellipse). * \return (true) if the arc represents a full conic. */ bool is_full_conic () const { return ((_info & FULL_CONIC) != 0); } /*! * Check whether the arc is a circular arc. * \return (true) if the underlying conic curve is a circle. */ bool is_circular() const { return ((_info & IS_CIRCLE) != 0); } /*! * Check whether the arc is a line segment. * \return (true) if the underlying conic curve is of degree 1. */ bool is_segment () const { return ((_info & DEGREE_MASK) == 1); } /*! * Check whether the arc is a vertical segment. * \return (true) if the arc is a vertical segment. */ bool is_vertical_segment () const { // A vertical segment is contained in the degenerate conic: u*x + w = 0. const CfNT _zero = 0; return ((_info & DEGREE_MASK) == 1 && CGAL_NTS compare(_v, _zero) == EQUAL); } /*! * Get a bounding box for the conic arc. * \return The bounding box. */ Bbox_2 bbox () const { // Use the source and target to initialize the exterme points. bool source_left = CGAL::to_double(_source.x()) < CGAL::to_double(_target.x()); double x_min = source_left ? CGAL::to_double(_source.x()) : CGAL::to_double(_target.x()); double x_max = source_left ? CGAL::to_double(_target.x()) : CGAL::to_double(_source.x()); bool source_down = CGAL::to_double(_source.y()) < CGAL::to_double(_target.y()); double y_min = source_down ? CGAL::to_double(_source.y()) : CGAL::to_double(_target.y()); double y_max = source_down ? CGAL::to_double(_target.y()) : CGAL::to_double(_source.y()); // Go over the vertical tangency points and try to update the x-points. Point_2 tps[2]; int n_tps; int i; n_tps = vertical_tangency_points (tps); for (i = 0; i < n_tps; i++) { if (CGAL::to_double(tps[i].x()) < x_min) x_min = CGAL::to_double(tps[i].x()); if (CGAL::to_double(tps[i].x()) > x_max) x_max = CGAL::to_double(tps[i].x()); } // Go over the horizontal tangency points and try to update the y-points. n_tps = horizontal_tangency_points (tps); for (i = 0; i < n_tps; i++) { if (CGAL::to_double(tps[i].y()) < y_min) y_min = CGAL::to_double(tps[i].y()); if (CGAL::to_double(tps[i].y()) > y_max) y_max = CGAL::to_double(tps[i].y()); } // Return the resulting bounding box. return (Bbox_2 (x_min, y_min, x_max, y_max)); } /*! * Check whether the given point is on the conic arc. * \param q The query point. * \return (true) if the arc contains the point q. */ bool contains_point (const Point_2& q) const { // Check whether the conic contains the point (x,y). if (q.is_generating_conic_id(_conic_id) || _conic_has_on_boundary(q)) { // If the point is on the conic boundary, it is contained in the arc // either if the arc is a full conic, or if it is between the two // endpoints of the arc. return (is_full_conic() || _is_between_endpoints(q)); } // If the point is not on the conic boundary, it cannot be on the arc. return (false); } /*! * Calculate the vertical tangency points of the arc. * \param vpts The vertical tangency points -- should be allocated at the * size of 2). * \return The number of vertical tangency points. */ int vertical_tangency_points (Point_2* vpts) const { // No vertical tangency points for segments or for x-monotone curves: if ((_info & DEGREE_MASK) < 2 || (_info & X_MON_UNDEFINED) == X_MONOTONE) { return (0); } // Calculate the vertical tangency points of the conic. Point_2 ps[2]; int n; n = _conic_vertical_tangency_points (ps); // Return only the points that are contained in the arc interior. int m = 0; for (int i = 0; i < n; i++) { if (is_full_conic() || _is_strictly_between_endpoints(ps[i])) { vpts[m] = ps[i]; m++; } } // Return the number of vertical tangency points found. return (m); } /*! * Calculate the horizontal tangency points of the arc. * \param hpts The horizontal tangency points -- should be allocated at the * size of 2). * \return The number of horizontal tangency points. */ int horizontal_tangency_points (Point_2* hpts) const { // No horizontal tangency points for segments: if ((_info & DEGREE_MASK) < 2) return (0); // Calculate the horizontal tangency points of the conic. Point_2 ps[2]; int n; n = _conic_horizontal_tangency_points (ps); // Return only the points that are contained in the arc interior. int m = 0; for (int i = 0; i < n; i++) { if (is_full_conic() || _is_strictly_between_endpoints(ps[i])) { hpts[m] = ps[i]; m++; } } // Return the number of horizontal tangency points found. return (m); } /*! * Check whether the arc is x-monotone. * \return (true) if the arc is x-monotone. */ bool is_x_monotone() const { // If the answer is pre-calculated (and stored in the _info field), just // return it: int is_x_mon = _info & X_MON_UNDEFINED; if (is_x_mon == 0) return (false); else if (is_x_mon == X_MONOTONE) return (true); // Check the number of vertical tangency points. Point_2 vpts[2]; return (vertical_tangency_points(vpts) == 0); } /*! * Find all points on the arc with a given x-coordinate. * \param p A placeholder for the x-coordinate. * \param ps The point on the arc at x(p) -- should be allocated at the * size of 2. * \return The number of points found. */ int get_points_at_x (const Point_2& p, Point_2 *ps) const { // Get the y coordinates of the points on the conic. CoNT ys[2]; int n; n = _conic_get_y_coordinates (p.x(), ys); // Find all the points that are contained in the arc. int m = 0; for (int i = 0; i < n; i++) { ps[m] = Point_2 (p.x(), ys[i], _conic_id); if (is_full_conic() || _is_between_endpoints(ps[m])) m++; } // Return the number of points on the arc. return (m); } /*! * Find all points on the arc with a given y-coordinate. * \param p A placeholder for the y-coordinate. * \param ps The point on the arc at y(p) -- should be allocated at the * size of 2. * \return The number of points found. */ int get_points_at_y (const Point_2& p, Point_2 *ps) const { // Get the y coordinates of the points on the conic. CoNT xs[2]; int n; n = _conic_get_x_coordinates (p.y(), xs); // Find all the points that are contained in the arc. int m = 0; for (int i = 0; i < n; i++) { ps[m] = Point_2 (xs[i], p.y(), _conic_id); if (is_full_conic() || _is_between_endpoints(ps[m])) m++; } // Return the number of points on the arc. return (m); } /*! * Flip the conic arc: change its orientation and swap it source and target. * \return The flipped arc. */ Self flip () const { // Create a base conic with opposite orientation: Self opp_arc; opp_arc._r = -r; opp_arc._s = -s; opp_arc._t = -t; opp_arc._u = -u; opp_arc._v = -v; opp_arc._w = -w; if (_orient == CGAL::COUNTERCLOCKWISE) opp_arc._orient = CGAL::CLOCKWISE; else if (_orient == CGAL::CLOCKWISE) opp_arc._orient = CGAL::COUNTERCLOCKWISE; else opp_arc._orient = _orient; // Linear arc (a segment). opp_arc._conic_id = _conic_id; // Exchange the source and the target. opp_arc._source = _target; opp_arc._target = _source; opp_arc._info = _info; // These properties do not change. if ((_info & IS_HYPERBOLA) != 0) { opp_arc._data.hyper_P = new Hyperbolic_arc_data (*_data.hyper_P); } else if ((_info & IS_CIRCLE) != 0) { opp_arc._data.circ_P = new Circular_arc_data (*_data.circ_P); } else { opp_arc._data.hyper_P = NULL; } return (opp_arc); } /*! RWRW - Allow higher order derivatives. * Get the i'th order derivative by x of the conic at the point p=(x,y). * \param p The point where we derive. * \param i The order of the derivatives (either 1 or 2). * \param slope_numer The numerator of the slope. * \param slope_denom The denominator of the slope. * \pre i should be either 1 (first order) or 2 (second order). */ void derive_by_x_at (const Point_2& p, const int& i, CoNT& slope_numer, CoNT& slope_denom) const { // Make sure i is either 1 or 2. CGAL_precondition(i == 1 || i == 2); // Make sure p is contained in the arc. CGAL_precondition(contains_point(p)); // The derivative by x of the conic // C: {r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0} // at the point p=(x,y) is given by: // // 2r*x + t*y + u alpha // y' = - ---------------- = - ------- // 2s*y + t*x + v beta // const CoNT _two = 2; const CoNT sl_numer = _two*CoNT(_r)*p.x() + CoNT(_t)*p.y() + CoNT(_u); const CoNT sl_denom = _two*CoNT(_s)*p.y() + CoNT(_t)*p.x() + CoNT(_v); if (i == 1) { if (sl_denom > 0) { slope_numer = -sl_numer; slope_denom = sl_denom; } else { slope_numer = sl_numer; slope_denom = -sl_denom; } return; } // The second derivative is given by: // // s*alpha^2 - t*alpha*beta + r*beta^2 // y'' = -2 ------------------------------------- // beta^3 // const CoNT sl2_numer = CoNT(_s) * sl_numer * sl_numer - CoNT(_t) * sl_numer * sl_denom + CoNT(_r) * sl_denom * sl_denom; const CoNT sl2_denom = sl_denom * sl_denom * sl_denom; if (sl_denom > 0) // so sl2_denom > 0 as well ... { slope_numer = -_two *sl2_numer; slope_denom = sl2_denom; } else { slope_numer = _two *sl2_numer; slope_denom = -sl2_denom; } return; } /*! RWRW - Allow higher order derivatives. * Get the i'th order derivative by y of the conic at the point p=(x,y). * \param p The point where we derive. * \param i The order of the derivatives (either 1 or 2). * \param slope_numer The numerator of the slope. * \param slope_denom The denominator of the slope. * \pre i should be either 1 (first order) or 2 (second order). */ void derive_by_y_at (const Point_2& p, const int& i, CoNT& slope_numer, CoNT& slope_denom) const { // Make sure i is either 1 or 2. CGAL_precondition(i == 1 || i == 2); // Make sure p is contained in the arc. CGAL_precondition(contains_point(p)); // The derivative by y of the conic // C: {r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0} // at the point p=(x,y) is given by: // // 2s*y + t*x + v alpha // x' = - ---------------- = ------- // 2r*x + t*y + u beta // const CoNT _two = 2; const CoNT sl_numer = _two*CoNT(_s)*p.y() + CoNT(_t)*p.x() + CoNT(_v); const CoNT sl_denom = _two*CoNT(_r)*p.x() + CoNT(_t)*p.y() + CoNT(_u); if (i == 1) { if (sl_denom > 0) { slope_numer = -sl_numer; slope_denom = sl_denom; } else { slope_numer = sl_numer; slope_denom = -sl_denom; } return; } // The second derivative is given by: // // r*alpha^2 - t*alpha*beta + s*beta^2 // x'' = -2 ------------------------------------- // beta^3 // const CoNT sl2_numer = CoNT(_r) * sl_numer * sl_numer - CoNT(_t) * sl_numer * sl_denom + CoNT(_s) * sl_denom * sl_denom; const CoNT sl2_denom = sl_denom * sl_denom * sl_denom; if (sl_denom > 0) // so sl2_denom > 0 as well ... { slope_numer = -_two *sl2_numer; slope_denom = sl2_denom; } else { slope_numer = _two *sl2_numer; slope_denom = -sl2_denom; } return; } /*! * Calculate the intersection points with the given arc. * \param arc The arc to intersect. * \param ps The output intersection points. * This area must be allocated at the size of 4. * \param inter_list_P For caching purposes. * \pre The tow arcs do not lie on the same conic. * \return The number of the actual intersection points. */ int intersections_with (const Self& arc, Point_2* ps #ifdef CGAL_CONIC_ARC_USE_CACHING ,std::list *inter_list_P = NULL #endif ) const { // The two conics must not be the same. CGAL_precondition (! has_same_base_conic(arc)); // First make sure that (this->degree) is >= than (arc.degree). if ((arc._info & DEGREE_MASK) == DEGREE_2 && (_info & DEGREE_MASK) == DEGREE_1) { return (arc.intersections_with (*this, ps #ifdef CGAL_CONIC_ARC_USE_CACHING ,inter_list_P #endif )); } // Deal with vertical segments. if (arc.is_vertical_segment()) { if (is_vertical_segment()) { // Two vertical segments intersect only if they overlap. return (0); } // Find all points on our arc that have the same x coordinate as // the other vertical segment. int n_ys; Point_2 xps[2]; int j; int n = 0; n_ys = get_points_at_x (arc._source, xps); for (j = 0; j < n_ys; j++) { // Store this point only if it is contained on the other arc. if (arc.contains_point(xps[j])) { ps[n] = Point_2 (xps[j].x(), xps[j].y(), _conic_id, arc._conic_id); n++; } } return (n); } else if (is_vertical_segment()) { // Find all points on the other arc that have the same x coordinate as // our vertical segment. int n_ys; Point_2 xps[2]; int j; int n = 0; n_ys = arc.get_points_at_x (_source, xps); for (j = 0; j < n_ys; j++) { // Store this point only if it is contained on the other arc. if (contains_point(xps[j])) { ps[n] = Point_2 (xps[j].x(), xps[j].y(), _conic_id, arc._conic_id); n++; } } return (n); } // Find all intersection points between the two base conic curves. Point_2 ipts[4]; // The intersection points. int n_points = 0; // Their number. bool calc_points = true; #ifdef CGAL_CONIC_ARC_USE_CACHING Intersections inter; int k; if (inter_list_P != NULL && (_info & DEGREE_MASK) != DEGREE_1) { int id1 = _conic_id; int id2 = arc._conic_id; inter.id1 = id1 < id2 ? id1 : id2; inter.id2 = id1 > id2 ? id1 : id2; typename std::list::iterator iter; for (iter = inter_list_P->begin(); iter != inter_list_P->end(); iter++) { if ((*iter).id1 == inter.id1 && (*iter).id2 == inter.id2) { n_points = (*iter).n_points; for (k = 0; k < n_points; k++) ipts[k] = (*iter).ps[k]; calc_points = false; } } } #endif // (of ifdef CGAL_CONIC_ARC_USE_CACHING) if (calc_points) { // Find all potential x coordinates and y coordinates of the // intersection points. const CfNT _zero = 0; CoNT xs[4]; // The x coordinates of intersection points. int n_xs; // Number of x coordinates. CoNT ys[4]; // The y coordinates of intersection points. int n_ys; // Number of y coordinates. if (_s == _zero && arc._s != _zero) { n_xs = arc._x_coordinates_of_intersections_with (*this, xs); } else { n_xs = _x_coordinates_of_intersections_with (arc, xs); } if (_r == _zero && arc._r != _zero) { n_ys = arc._y_coordinates_of_intersections_with (*this, ys); } else { n_ys = _y_coordinates_of_intersections_with (arc, ys); } // Perform the pairing process od the x and y coordinates. n_points = _pair_intersection_points (arc, xs, n_xs, ys, n_ys, ipts); #ifdef CGAL_CONIC_ARC_USE_CACHING if (inter_list_P != NULL && (_info & DEGREE_MASK) != DEGREE_1) { inter.n_points = n_points; for (k = 0; k < n_points; k++) inter.ps[k] = ipts[k]; inter_list_P->push_front(inter); } #endif // (of ifdef CGAL_CONIC_ARC_USE_CACHING) } // Go over all intersection points between the two base conics and return // only those located on both arcs. int n = 0; int i; for (i = 0; i < n_points; i++) { // Check for an exact point. if (contains_point(ipts[i]) && arc.contains_point(ipts[i])) { ps[n] = ipts[i]; n++; } } return (n); } /*! * Check whether the two arcs overlap, and if so - compute the overlapping * portions. * \param arc The other conic arc. * \param ovlp_arc The output overlapping sub-arc. * This area should be allocated to the size of 2. * \return The number of overlapping sub-arcs. */ int overlaps (const Self& arc, Self* ovlp_arcs) const { // Two arcs can overlap only if their base conics are identical. if (! this->has_same_base_conic (arc)) return (0); // If the two arcs are completely equal, return one of them as the // overlapping arc. int orient1 = _orient; int orient2 = arc._orient; bool same_or = (orient1 == orient2); bool identical = false; if (orient1 == 0) { // That mean both arcs are really segments, so they are identical // if their endpoints are the same. if ((_source.equals(arc._source) && _target.equals(arc._target)) || (_source.equals(arc._target) && _target.equals(arc._source))) identical = true; } else { // If those are really curves of degree 2, than the points curves // are identical only if their source and target are the same and the // orientation is the same, or vice-versa if the orientation is opposite. if ((same_or && _source.equals(arc._source) && _target.equals(arc._target)) || (!same_or && _source.equals(arc._target) && _target.equals(arc._source))) identical = true; } if (identical) { ovlp_arcs[0] = arc; return (1); } // In case one of the arcs is a full conic, return the whole other conic. if (arc.is_full_conic()) { ovlp_arcs[0] = *this; return (1); } else if (is_full_conic()) { ovlp_arcs[0] = arc; return (1); } // In case the other arc has an opposite orientation, switch its source // and target (notice that in case of segments, when the orientation is 0, // we make sure the two segments have the same direction). const Point_2 *arc_sourceP; const Point_2 *arc_targetP; if (orient1 == 0) orient1 = (_source.compare_lex_xy(_target) == LARGER) ? 1 : -1; if (orient2 == 0) orient2 = (arc._source.compare_lex_xy(arc._target) == LARGER) ? 1 : -1; // Check the overlap cases: if (orient1 == orient2) { arc_sourceP = &(arc._source); arc_targetP = &(arc._target); } else { arc_sourceP = &(arc._target); arc_targetP = &(arc._source); } if (_is_strictly_between_endpoints(*arc_sourceP)) { if (_is_strictly_between_endpoints(*arc_targetP)) { // Check the next special case (when there are 2 overlapping arcs): if (arc._is_strictly_between_endpoints(_source) && arc._is_strictly_between_endpoints(_target)) { ovlp_arcs[0] = Self(*this,_source, *arc_targetP); ovlp_arcs[1] = Self(*this, *arc_sourceP, _target); return (2); } // Case 1 - *this: +-----------> // arc: +=====> ovlp_arcs[0] = Self(*this, *arc_sourceP,*arc_targetP); return (1); } else { // Case 2 - *this: +-----------> // arc: +=====> ovlp_arcs[0] = Self(*this, *arc_sourceP, _target); return (1); } } else if (_is_strictly_between_endpoints(*arc_targetP)) { // Case 3 - *this: +-----------> // arc: +=====> ovlp_arcs[0] = Self(*this, _source, *arc_targetP); return (1); } else if (arc._is_between_endpoints(_source) && arc._is_between_endpoints(_target) && (arc._is_strictly_between_endpoints(_source) || arc._is_strictly_between_endpoints(_target))) { // Case 4 - *this: +-----------> // arc: +================> ovlp_arcs[0] = *this; return (1); } // If we reached here, there are no overlaps: return (0); } /*! * Check whether the arc is facing up or facing down. * \return LARGER if the arcs is facing up, or SMALLER if it is facing down. * If the arc is a line segment, EQUAL is returned. */ Comparison_result facing () const { if ((_info & FACING_MASK) == 0) return (EQUAL); else if ((_info & FACING_UP) != 0) return (LARGER); else return (SMALLER); } protected: /*! * Set the properties of a conic arc (for the usage of the constructors). * \param comp_orient Should we compute the orientation of the given curve. * \param circ_data_P The center and radius of the base circle * (only if the arc lies on a circle). */ void _set (const bool& comp_orient, Circular_arc_data *circ_data_P = NULL) { // Initialize the information bits. _info = X_MON_UNDEFINED; // Set the orientation of conic arc. typename Cartesian::Conic_2 temp_conic (_r, _s, _t, _u, _v, _w); if (comp_orient) { // Compute the orientation. _orient = temp_conic.orientation(); } else if (_orient != temp_conic.orientation()) { // If the computed orientation does not match the current value, // multiply all conic coefficients by -1 (negate the curve). _r = - _r; _s = - _s; _t = - _t; _u = - _u; _v = - _v; _w = - _w; } // Find the degree and make sure the conic is not invalid. const CfNT _zero = 0; int deg; if (_r != _zero || _s != _zero || _t != _zero) { // In case one of the coefficients of x^2,y^2 or xy is not zero, the // degree is 2. deg = 2; CGAL_assertion (_orient != CGAL::COLLINEAR); } else if (_u != _zero || _v != _zero) { // In case of a line - the degree is 1. deg = 1; _orient = CGAL::COLLINEAR; } else { // Empty conic! deg = 0; } CGAL_precondition(deg > 0); // Store the degree information. _info = _info | deg; // In case the base conic is a hyperbola, build the hyperbolic data // (this happens when (4rs - t^2) < 0). if (deg == 2 && 4*_r*_s < _t*_t) { _info = _info | IS_HYPERBOLA; _build_hyperbolic_arc_data (); } // In case the base conic is a circle, set the circular data. else if (deg == 2 && circ_data_P != NULL) { _info = _info | IS_CIRCLE; _data.circ_P = circ_data_P; } else { _data.hyper_P = NULL; } // In case of a non-degenerate parabola or a hyperbola, make sure // the arc is not infinite. if (deg == 2 && 4*_r*_s <= _t*_t) { CGAL_precondition_code( const CoNT _two = 2; const Point_2 p_mid ((_source.x() + _target.x()) / _two, (_source.y() + _target.y()) / _two); Point_2 ps[2]; bool finite_at_x = (get_points_at_x(p_mid, ps) > 0); bool finite_at_y = (get_points_at_y(p_mid, ps) > 0); ); CGAL_precondition(finite_at_x && finite_at_y); } // If we reached here, the conic arc is legal: Get a new id for the conic. _conic_id = _get_new_conic_id(); _source.set_generating_conics (_conic_id); _target.set_generating_conics (_conic_id); // Check whether the conic is x-monotone. if (is_x_monotone()) { _info = (_info & ~X_MON_UNDEFINED) | X_MONOTONE; // In case the conic is od degree 2, determine where is it facing. if ((_info & DEGREE_MASK) == DEGREE_2) _set_facing(); } else { _info = (_info & ~X_MON_UNDEFINED); } return; } /*! * Set the properties of a conic arc that is really a full curve * (that is, an ellipse). * \param comp_orient Should we compute the orientation of the given curve. * \param circ_data_P The center and radius of the base circle * (only if the arc is a full circle). */ void _set_full (const bool& comp_orient, Circular_arc_data *circ_data_P = NULL) { // Initialize the information bits. _info = 0; // Set the orientation of conic arc. typename Cartesian::Conic_2 temp_conic (_r, _s, _t, _u, _v, _w); if (comp_orient) { // Compute the orientation. _orient = temp_conic.orientation(); } else if (_orient != temp_conic.orientation()) { // If the computed orientation does not match the current value, // multiply all conic coefficients by -1 (negate the curve). _r = - _r; _s = - _s; _t = - _t; _u = - _u; _v = - _v; _w = - _w; } // Make sure the conic is a non-degenerate ellipse: // The coefficients should satisfy (4rs - t^2) > 0. CGAL_precondition(4*_r*_s > _t*_t); // Set the information: a full conic, which is obvoiusly not x-monotone. _info = DEGREE_2 | FULL_CONIC; // Check if the conic is really a circle. if (circ_data_P != NULL) { _info = _info | IS_CIRCLE; _data.circ_P = circ_data_P; } else { _data.hyper_P = NULL; } // Assign one of the vertical tangency points as both the source and // the target of the conic arc. Point_2 vpts[2]; int n_vpts; if (circ_data_P != NULL) { vpts[0] = Point_2 (CoNT(circ_data_P->x0 + circ_data_P->r), CoNT(circ_data_P->y0)); } else { n_vpts = _conic_vertical_tangency_points (vpts); CGAL_assertion(n_vpts > 0); CGAL_assertion(_conic_has_on_boundary(vpts[0])); } // If we reached here, the conic arc is legal: Get a new id for the conic. _conic_id = _get_new_conic_id(); _source.set_generating_conics (_conic_id); _target.set_generating_conics (_conic_id); return; } /*! * Build the data for hyperbolic arc, contaning the characterization of the * hyperbolic branch the arc is placed on. */ void _build_hyperbolic_arc_data () { // Let phi be the rotation angle of the conic from its canonic form. // We can write: // // t // sin(2*phi) = ----------------------- // sqrt((r - s)^2 + t^2) // // r - s // cos(2*phi) = ----------------------- // sqrt((r - s)^2 + t^2) // const int or_fact = (_orient == CGAL::CLOCKWISE) ? -1 : 1; const CoNT r = or_fact * CoNT(_r); const CoNT s = or_fact * CoNT(_s); const CoNT t = or_fact * CoNT(_t); const CoNT cos_2phi = (r - s) / CGAL::sqrt((r-s)*(r-s) + t*t); const CoNT _zero = 0; const CoNT _one = 1; const CoNT _two = 2; CoNT sin_phi; CoNT cos_phi; // Calculate sin(phi) and cos(phi) according to the half-angle formulae: // // sin(phi)^2 = 0.5 * (1 - cos(2*phi)) // cos(phi)^2 = 0.5 * (1 + cos(2*phi)) if (t == _zero) { // sin(2*phi) == 0, so phi = 0 or phi = PI/2 if (cos_2phi > _zero) { // phi = 0. sin_phi = _zero; cos_phi = _one; } else { // phi = PI. sin_phi = _zero; cos_phi = -_one; } } else if (t > _zero) { // sin(2*phi) > 0 so 0 < phi < PI/2. sin_phi = CGAL::sqrt((_one + cos_2phi) / _two); cos_phi = CGAL::sqrt((_one - cos_2phi) / _two); } else { // sin(2*phi) < 0 so PI/2 < phi < PI. sin_phi = CGAL::sqrt((_one + cos_2phi) / _two); cos_phi = -CGAL::sqrt((_one - cos_2phi) / _two); } // Calculate the center (x0, y0) of the conic, given by the formulae: // // t*v - 2*s*u t*u - 2*r*v // x0 = ------------- , y0 = ------------- // 4*r*s - t^2 4*r*s - t^2 // // The denominator (4*r*s - t^2) must be negative for hyperbolas. const CoNT u = or_fact * CoNT(_u); const CoNT v = or_fact * CoNT(_v); const CoNT det = 4*r*s - t*t; CoNT x0, y0; CGAL_assertion (det < _zero); x0 = (t*v - _two*s*u) / det; y0 = (t*u - _two*r*v) / det; // The axis separating the two branches of the hyperbola is now given by: // // cos(phi)*x + sin(phi)*y - (cos(phi)*x0 + sin(phi)*y0) = 0 // _data.hyper_P = new Hyperbolic_arc_data; _data.hyper_P->a = cos_phi; _data.hyper_P->b = sin_phi; _data.hyper_P->c = - (cos_phi*x0 + sin_phi*y0); // Make sure that the two endpoints are located on the same branch // of the hyperbola. _data.hyper_P->side = _hyperbolic_arc_side(_source); CGAL_assertion (_data.hyper_P->side = _hyperbolic_arc_side(_target)); return; } /*! * Find on which branch of the hyperbola is the given point located. * The point is assumed to be on the hyperbola. * \param p The query point. * \return The branch ID (either -1 or 1). */ int _hyperbolic_arc_side (const Point_2& p) const { if (_data.hyper_P == NULL) return (0); CoNT val; val = _data.hyper_P->a*p.x() + _data.hyper_P->b*p.y() + _data.hyper_P->c; return ((val > 0) ? 1 : -1); } /*! * Check whether the given point is between the source and the target. * The point is assumed to be on the conic's boundary. * \param p The query point. * \return (true) if the point is between the two endpoints, * (false) if it is not. */ bool _is_between_endpoints (const Point_2& p) const { if (p.equals(_source) || p.equals(_target)) return (true); else return (_is_strictly_between_endpoints(p)); } /*! * Check whether the given point is strictly between the source and the * target (but not any of them). * The point is assumed to be on the conic's boundary. * \param p The query point. * \return (true) if the point is strictly between the two endpoints, * (false) if it is not. */ bool _is_strictly_between_endpoints (const Point_2& p) const { // In case this is a full conic, any point on its boundary is between // its end points. if (is_full_conic()) return (true); // In case of a hyperbolic arc, make sure the point is located on the // same branch as the arc. if ((_info & IS_HYPERBOLA) != 0) { if (_hyperbolic_arc_side(p) != _data.hyper_P->side) return (false); } // Act according to the conic degree. if ((_info & DEGREE_MASK) == DEGREE_1) { if (is_vertical_segment()) { // In case of a vertical segment - just check whether the y coordinate // of p is between those of the source's and of the target's. Comparison_result r1 = compare_y (p, _source); Comparison_result r2 = compare_y (p, _target); return ((r1 == SMALLER && r2 == LARGER) || (r1 == LARGER && r2 == SMALLER)); } else { // Otherwise, since the segment is x-monotone, just check whether the // x coordinate of p is between those of the source's and of the // target's. Comparison_result r1 = compare_x (p, _source); Comparison_result r2 = compare_x (p, _target); return ((r1 == SMALLER && r2 == LARGER) || (r1 == LARGER && r2 == SMALLER)); } } else { // In case of a conic of degree 2, make a decision based on the conic's // orientation and whether (source,p,target) is a right or a left turn. static Kernel ker; typename Kernel::Orientation_2 orient_f = ker.orientation_2_object(); if (_orient == CGAL::COUNTERCLOCKWISE) return (orient_f(_source, p, _target) == LEFT_TURN); else return (orient_f(_source, p, _target) == RIGHT_TURN); } } /*! * Check whether the underlying conic contains a point on its boundary. * \param q The query point. * \return (true) if the underlying conic contains the point on its boundary. */ bool _conic_has_on_boundary (const Point_2& q) const { return (_conic_has_on_boundary (q.x(), q.y())); } /*! * Check whether the underlying conic contains (x,y) on its boundary. * \param x The x coordinate of the query point. * \param y The y coordinate of the query point. * \return (true) if the underlying conic contains the point on its boundary. */ bool _conic_has_on_boundary (const CoNT& x, const CoNT& y) const { const CoNT _zero = 0; CoNT val; // The point must satisfy: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0. val = CoNT(_r)*x*x + CoNT(_s)*y*y + CoNT(_t)*x*y + CoNT(_u)*x + CoNT(_v)*y + CoNT(_w); return (val == _zero); } /*! * Find the y coordinates of the underlying conic at a given x coordinate. * \param x The x coordinate. * \param ys The output y coordinates. * This area must be allocated at the size of 2. * \return The number of y coordinates computed (either 0, 1 or 2). */ int _conic_get_y_coordinates (const CoNT& x, CoNT *ys) const { // Solve the quadratic equation for a given x and find the y values: // s*y^2 + (t*x + v)*y + (r*x^2 + u*x + w) = 0 return (solve_quadratic_eq (CoNT(_s), CoNT(_t)*x + CoNT(_v), (CoNT(_r)*x + CoNT(_u))*x + CoNT(_w), ys)); } /*! * Find the x coordinates of the underlying conic at a given y coordinate. * \param y The y coordinate. * \param xs The output x coordinates. * This area must be allocated at the size of 2. * \return The number of x coordinates computed (either 0, 1 or 2). */ int _conic_get_x_coordinates (const CoNT& y, CoNT *xs) const { // Solve the quadratic equation for a given y and find the x values: // r*x^2 + (t*y + u)*x + (s*y^2 + v*y + w) = 0 return (solve_quadratic_eq (CoNT(_r), CoNT(_t)*y + CoNT(_u), (CoNT(_s)*y + CoNT(_v))*y + CoNT(_w), xs)); } /*! * Find the vertical tangency points of the undelying conic. * \param ps The output points of vertical tangency. * This area must be allocated at the size of 2. * \return The number of vertical tangency points. */ int _conic_vertical_tangency_points (Point_2* ps) const { const CfNT _zero = 0; // In case the base conic is of degree 1 (and not 2), the arc has no // vertical tangency points. if ((_info & DEGREE_MASK) == DEGREE_1 || _s == _zero) return (0); // Special treatment for circles, where the vertical tangency points // are simply (x0-r,y0) and (x0+r,y0). if ((_info & IS_CIRCLE) != 0) { ps[0] = Point_2 (CoNT(_data.circ_P->x0 - _data.circ_P->r), CoNT(_data.circ_P->y0), _conic_id); ps[1] = Point_2 (CoNT(_data.circ_P->x0 + _data.circ_P->r), CoNT(_data.circ_P->y0), _conic_id); return (2); } // We are interested in the x coordinates where the quadratic equation: // s*y^2 + (t*x + v)*y + (r*x^2 + u*x + w) = 0 // has a single solution (obviously if s = 0, there are no such points). // We therefore demand that the discriminant of this equation is zero: // (t*x + v)^2 - 4*s*(r*x^2 + u*x + w) = 0 const CfNT _two = 2; const CfNT _four = 4; CoNT xs[2]; int n_xs; n_xs = solve_quadratic_eq (_t*_t - _four*_r*_s, _two*_t*_v - _four*_s*_u, _v*_v - _four*_s*_w, xs); // Find the y-coordinates of the vertical tangency points. CoNT ys[2]; int n_ys; if (_t == _zero) { // The two vertical tangency points have the same y coordinate: ys[0] = CoNT(-_v) / CoNT(_two*_s); n_ys = 1; } else { n_ys = solve_quadratic_eq (_four*_r*_s*_s - _s*_t*_t, _four*_r*_s*_v - _two*_s*_t*_u, _r*_v*_v - _t*_u*_v + _t*_t*_w, ys); } // Pair the x and y coordinates and obtain the vertical tangency points. int n = 0; int i, j; for (i = 0; i < n_xs; i++) { if (n_ys == 1) { ps[n] = Point_2 (xs[i], ys[0], _conic_id); n++; } else { for (j = 0; j < n_ys; j++) { if (ys[j] == -(CoNT(_t)*xs[i] + CoNT(_v)) / CoNT(_two*_s)) { ps[n] = Point_2 (xs[i], ys[j], _conic_id); n++; break; } } } } return (n); } /*! * Find the horizontal tangency points of the undelying conic. * \param ps The output points of horizontal tangency. * This area must be allocated at the size of 2. * \return The number of horizontal tangency points. */ int _conic_horizontal_tangency_points (Point_2* ps) const { const CfNT _zero = 0; // In case the base conic is of degree 1 (and not 2), the arc has no // vertical tangency points. if ((_info & DEGREE_MASK) == DEGREE_1 || _r == _zero) return (0); // Special treatment for circles, where the horizontal tangency points // are simply (x0,y0-r) and (x0,y0+r). if ((_info & IS_CIRCLE) != 0) { ps[0] = Point_2 (CoNT(_data.circ_P->x0), CoNT(_data.circ_P->y0 - _data.circ_P->r), _conic_id); ps[1] = Point_2 (CoNT(_data.circ_P->x0), CoNT(_data.circ_P->y0 + _data.circ_P->r), _conic_id); return (2); } // We are interested in the y coordinates were the quadratic equation: // r*x^2 + (t*y + u)*x + (s*y^2 + v*y + w) = 0 // has a single solution (obviously if r = 0, there are no such points). // We therefore demand that the discriminant of this equation is zero: // (t*y + u)^2 - 4*r*(s*y^2 + v*y + w) = 0 const CfNT _two = 2; const CfNT _four = 4; int n; CoNT ys[2]; n = solve_quadratic_eq (_t*_t - _four*_r*_s, _two*_t*_u - _four*_r*_v, _u*_u - _four*_r*_w, ys); // Compute the x coordinates and construct the horizontal tangency points. CoNT x; int i; for (i = 0; i < n; i++) { // Having computed y, x is the simgle solution to the quadratic equation // above, and since its discriminant is 0, x is simply given by: x = -(CoNT(_t)*ys[i] + CoNT(_u)) / CoNT(_two*_r); ps[i] = Point_2 (x, ys[i], _conic_id); } return (n); } /*! * Set the facing information for the (x-monotone) arc: It is facing up if * it lies above the line segments that connect its two endpoints, and facing * down if it lies below it. */ void _set_facing () { // Check whether the arc (which is x-monotone of degree 2) lies above or // below the segement that contects its two end-points (x1,y1) and (x2,y2). // To do that, we find the y coordinate of a point on the arc whose x // coordinate is (x1+x2)/2 and compare it to (y1+y2)/2. const CoNT _two = 2; const CoNT x_mid = (_source.x() + _target.x()) / _two; const CoNT y_mid = (_source.y() + _target.y()) / _two; Point_2 p_mid (x_mid, y_mid); Point_2 ps[2]; int n_ps; n_ps = get_points_at_x (p_mid, ps); CGAL_assertion (n_ps == 1); Comparison_result res = ps[0].compare_y (p_mid); if (res == LARGER) { // The arc is above the connecting segment, so it is facing upwards. _info = _info | FACING_UP; } else if (res == SMALLER) { // The arc is below the connecting segment, so it is facing downwards. _info = _info | FACING_DOWN; } CGAL_assertion(res != EQUAL); return; } /*! * Calculate all x coordinates of intersection points between the two * base conics of (*this) and the given arc. * \param arc The arc whose underlying conic we intersect. * \param xs The output x coordinates. * This area must be allocated to the size of 4. * \return The number of unique x coordinates. */ int _x_coordinates_of_intersections_with (const Self& arc, CoNT* xs) const { const CfNT _zero = 0; int n_roots; // The number of distinct x values. // Check whether both arcs are line segments. if ((_info & DEGREE_MASK) == DEGREE_1 && (arc._info & DEGREE_MASK) == DEGREE_1) { // The two conics are: u*x + v*y + w = 0 // and: u'*x + v'*y + w' = 0 // There's a single solution for x, which is: const CfNT denom = _v*arc._w - _w*arc._v; const CfNT numer = _u*arc._v - _v*arc._u; if (numer == _zero) { n_roots = 0; } else { xs[0] = CoNT(denom) / CoNT(numer); n_roots = 1; } } // Check whether the second arc is really a line segment. else if ((arc._info & DEGREE_MASK) == DEGREE_1) { // The two conics are: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 // and: a*x + b*y + c = 0 // There are therefore 2 possible x-values, the solutions for: const CfNT _two = 2; const CfNT& a = arc._u; const CfNT& b = arc._v; const CfNT& c = arc._w; n_roots = solve_quadratic_eq (a*a*_s + b*b*_r - a*b*_t, _two*a*c*_s + b*b*_u - a*b*_v - b*c*_t, c*c*_s + b*b*_w - b*c*_v, xs); } // Check if the two arcs are circular arcs. else if ((_info & IS_CIRCLE) != 0 && (arc._info & IS_CIRCLE) != 0) { // Special treatment for two circles. // The two curves are: r*x^2 + r*y^2 + u*x + v*y + w = 0 // and: r'*x^2 + r'*y^2 + u'*x + v'*y + w' = 0 // // Thus, r'*C1-r*C2 is a line whose equation is: a*x + b*y + = 0, where: const CfNT _two = 2; const CfNT a = arc._r*_u - _r*arc._u; const CfNT b = arc._r*_v - _r*arc._v; const CfNT c = arc._r*_w - _r*arc._w; if (b == _zero) { // The line a*x + c = 0 connects both intersection points of the two // circles, so the both have an x-coordinate of -c/a. if (a == _zero) { n_roots = 0; } else { xs[0] = -CoNT(c) / CoNT(a); n_roots = 1; } } else { // The intersection points of the two circles are the same as the // intersection points of one of the circles with a*x + b*y + c = 0. n_roots = solve_quadratic_eq (a*a*_s + b*b*_r - a*b*_t, _two*a*c*_s + b*b*_u - a*b*_v - b*c*_t, c*c*_s + b*b*_w - b*c*_v, xs); } } // Check if the two arcs lie of canonic parabolas. else if (_s == _zero && _t == _zero && arc._s == _zero && arc._t == _zero) { // Special treatment for canonic parabolas whose axes are parallel // to the y axis. // The two curves are: r*x^2 + u*x + v*y + w = 0 // and: r'*x^2 + u'*x + v'*y + w' = 0 // There are therefore 2 possible x-values, the solutions for: n_roots = solve_quadratic_eq (_r*arc._v - _v*arc._r, _u*arc._v - _v*arc._u, _w*arc._v - _v*arc._w, xs); } else { // If the two conics are: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 // and: r'*x^2 + s'*y^2 + t'*xy + u'*x + v'*y + w' = 0 // Let us define: // A = s'*r - s*r' if (s' != 0), otherwise A = r' // B = s'*u - s*u' if (s' != 0), otherwise B = u' // C = s'*w - s*w' if (s' != 0), otherwise C = w' // D = s'*t - s*t' if (s' != 0), otherwise A = t' // E = s'*v - s*v' if (s' != 0), otherwise A = v' CfNT A, B, C, D, E; if (arc._s != _zero) { const CfNT& s_tag = arc._s; A = s_tag*_r - _s*arc._r; B = s_tag*_u - _s*arc._u; C = s_tag*_w - _s*arc._w; D = s_tag*_t - _s*arc._t; E = s_tag*_v - _s*arc._v; } else { A = arc._r; B = arc._u; C = arc._w; D = arc._t; E = arc._v; } if (D == _zero && E == _zero) { // In this case: A*x^2 + B*x + C = 0, so: n_roots = solve_quadratic_eq (A, B, C, xs); } else { // Now we have: // // A*x^2 + B*x + C // y = - ----------------- // D*x + E // // Applying this two our conic's equation yields a quartic equation: // // c[4]*x^4 + c[3]*x^3 + c[2]*x^2 + c[1]*x + c[0] = 0 const CfNT _two = 2; CfNT cs[5]; if (_t == _zero && arc._t == _zero) { cs[4] = _s*A*A; cs[3] = _two*_s*A*B; cs[2] = _r*E*E + _two*_s*A*C + _s*B*B - _v*A*E; cs[1] = _u*E*E + _two*_s*B*C - _v*B*E; cs[0] = _w*E*E + _s*C*C - _v*C*E; } else { const CfNT F = _t*E + _v*D; cs[4] = _r*D*D + _s*A*A - _t*A*D; cs[3] = _two*_r*D*E + _u*D*D + _two*_s*A*B - _t*B*D - F*A; cs[2] = _r*E*E + _two*_u*D*E + _w*D*D + _two*_s*A*C + _s*B*B - _t*C*D - F*B - _v*A*E; cs[1] = _u*E*E + _two*_w*D*E + _two*_s*B*C - F*C - _v*B*E; cs[0] = _w*E*E + _s*C*C - _v*C*E; } // Solve the quartic equation. n_roots = solve_quartic_eq (cs[4], cs[3], cs[2], cs[1], cs[0], xs); } } return (n_roots); } /*! * Calculate all y coordinates of intersection points between the two * base conics of (*this) and the given arc. * \param arc The arc whose underlying conic we intersect. * \param ys The output y coordinates. * This area must be allocated to the size of 4. * \return The number of unique y coordinates. */ int _y_coordinates_of_intersections_with (const Self& arc, CoNT* ys) const { const CfNT _zero = 0; int n_roots; // The number of distinct y values. // Check whether both arcs are line segments. if ((_info & DEGREE_MASK) == DEGREE_1 && (arc._info & DEGREE_MASK) == DEGREE_1) { // The two conics are: u*x + v*y + w = 0 // and: u'*x + v'*y + w' = 0 // There's a single solution for y, which is: const CfNT denom = _u*arc._w - _w*arc._u; const CfNT numer = _v*arc._u - _u*arc._v; if (numer == _zero) { n_roots = 0; } else { ys[0] = CoNT(denom) / CoNT(numer); n_roots = 1; } } // Check whether the second arc is really a line segment. else if ((arc._info & DEGREE_MASK) == DEGREE_1) { // The two conics are: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 // and: a*x + b*y + c = 0 // There are therefore 2 possible y-values, the solutions for: const CfNT _two = 2; const CfNT& a = arc._u; const CfNT& b = arc._v; const CfNT& c = arc._w; // Solve the equation. n_roots = solve_quadratic_eq (b*b*_r + a*a*_s - a*b*_t, _two*b*c*_r + a*a*_v - a*b*_u - a*c*_t, c*c*_r + a*a*_w - a*c*_u, ys); } // Check if the two arcs are circular arcs. else if ((_info & IS_CIRCLE) != 0 && (arc._info & IS_CIRCLE) != 0) { // Special treatment for two circles. // The two curves are: r*x^2 + r*y^2 + u*x + v*y + w = 0 // and: r'*x^2 + r'*y^2 + u'*x + v'*y + w' = 0 // // Thus, r'*C1-r*C2 is a line whose equation is: a*x + b*y + = 0, where: const CfNT _two = 2; const CfNT a = arc._r*_u - _r*arc._u; const CfNT b = arc._r*_v - _r*arc._v; const CfNT c = arc._r*_w - _r*arc._w; if (a == _zero) { // The line b*y + c = 0 connects both intersection points of the two // circles, so the both have a y-coordinate of -c/b. if (b == _zero) { n_roots = 0; } else { ys[0] = -CoNT(c) / CoNT(b); n_roots = 1; } } else { // The intersection points of the two circles are the same as the // intersection points of one of the circles with a*x + b*y + c = 0. // Set the generating polynomial. n_roots = solve_quadratic_eq (b*b*_r + a*a*_s - a*b*_t, _two*b*c*_r + a*a*_v - a*b*_u - a*c*_t, c*c*_r + a*a*_w - a*c*_u, ys); } } // Check if the two arcs lie of canonic parabolas. else if (_r == _zero && _t == _zero && arc._r == _zero && arc._t == _zero) { // Special treatment for canonic parabolas whose axes are parallel // to the x axis. // The two curves are: s*y^2 + u*x + v*y + w = 0 // and: s'*y^2 + u'*x + v'*y + w' = 0 // There are therefore 2 possible y-values, the solutions for: n_roots = solve_quadratic_eq (_s*arc._u - _u*arc._s, _v*arc._u - _u*arc._v, _w*arc._u - _u*arc._w, ys); } else { // If the two conics are: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 // and: r'*x^2 + s'*y^2 + t'*xy + u'*x + v'*y + w' = 0 // Let us define: // A = r'*s - r*s' if (r' != 0), otherwise A = s' // B = r'*v - r*v' if (r' != 0), otherwise B = v' // C = r'*w - r*w' if (r' != 0), otherwise C = w' // D = r'*t - r*t' if (r' != 0), otherwise A = t' // E = r'*u - r*u' if (r' != 0), otherwise A = u' CfNT A, B, C, D, E; if (arc._r != _zero) { const CfNT& r_tag = arc._r; A = r_tag*_s - _r*arc._s; B = r_tag*_v - _r*arc._v; C = r_tag*_w - _r*arc._w; D = r_tag*_t - _r*arc._t; E = r_tag*_u - _r*arc._u; } else { A = arc._s; B = arc._v; C = arc._w; D = arc._t; E = arc._u; } if (D == _zero && E == _zero) { // In this case: A*y^2 + B*y + C = 0, so: n_roots = solve_quadratic_eq (A, B, C, ys); } else { // Now we have: // // A*y^2 + B*y + C // x = - ----------------- // D*y + E // // Applying this two our conic's equation yields a quartic equation: // // c[4]*y^4 + c[3]*y^3 + c[2]*y^2 + c[1]*y + c[0] = 0 const CfNT _two = 2; CfNT cs[5]; if (_t == _zero && arc._t == _zero) { cs[4] = _r*A*A; cs[3] = _two*_r*A*B; cs[2] = _s*E*E + _two*_r*A*C + _r*B*B - _u*A*E; cs[1] = _v*E*E + _two*_r*B*C - _u*B*E; cs[0] = _w*E*E + _r*C*C - _u*C*E; } else { const CfNT F = _t*E + _u*D; cs[4] = _s*D*D + _r*A*A - _t*A*D; cs[3] = _two*_s*D*E + _v*D*D + _two*_r*A*B - _t*B*D - F*A; cs[2] = _s*E*E + _two*_v*D*E + _w*D*D + _two*_r*A*C + _r*B*B - _t*C*D - F*B - _u*A*E; cs[1] = _v*E*E + _two*_w*D*E + _two*_r*B*C - F*C - _u*B*E; cs[0] = _w*E*E + _r*C*C - _u*C*E; } n_roots = solve_quartic_eq (cs[4], cs[3], cs[2], cs[1], cs[0], ys); } } return (n_roots); } /*! * Pair the x coordinates and the y coordinates of the intersection point * of the underlying conics of (*this) and arc, and return a vector of * intersection points. * \param arc The other arc. * \param xs The potentail x coordinates. * \param n_xs Number of x coordinates. * \param ys The potentail y coordinates. * \param n_ys Number of y coordinates. * \param ipts The points that lie on both conics. * This area must be allocated to the size of 4. * \return The number of intersection points between the conics. */ int _pair_intersection_points (const Self& arc, const CoNT* xs, const int& n_xs, const CoNT* ys, const int& n_ys, Point_2* ipts) const { int n_ipts = 0; int i; int j; for (i = 0; i < n_xs; i++) { for (j = 0; j < n_ys; j++) { // If the current pair of x and y coordinates lies on both underlying, // accept it. if (_conic_has_on_boundary (xs[i], ys[j]) && arc._conic_has_on_boundary (xs[i], ys[j])) { CGAL_assertion(n_ipts < 4); ipts[n_ipts] = Point_2 (xs[i], ys[j], _conic_id, arc._conic_id); n_ipts++; } } } return (n_ipts); } public: /*! * Get a segment (if the arc is indeed a line segment). * \return A segment equivalent ot the arc. * \pre The conic arc is indeed a line segment (it is of degree 1). */ Segment_2 segment() const { CGAL_precondition(is_segment()); return (Segment_2 (_source, _target)); } /*! * Get the underlying circle (if the arc is indeed a circular arc). * \return The underlying circle. * \pre The conic arc is indeed a circular arc. */ Circle_2 circle() const { CGAL_precondition(is_circular()); // Create the appropriate circle. const CoNT _zero = 0; const CoNT _two = 2; CoNT x0, y0, r2; if (_r > CfNT(0)) { // Positive orientation. The conic has the form: // x^2 + y^2 - (2*x0)*x - (2*y0)*y + (x0^2 + y0^2 - r^2) = 0 x0 = -CoNT(_u) / _two; y0 = -CoNT(_v) / _two; r2 = x0*x0 + y0*y0 - CoNT(_w); } else { // Negative orientation: // - x^2 - y^2 + (2*x0)*x + (2*y0)*y + (r^2 - x0^2 - y0^2) = 0 x0 = CoNT(_u) / _two; y0 = CoNT(_v) / _two; r2 = CoNT(_w) - (x0*x0 + y0*y0); } return (Circle_2 (Point_2(x0, y0), r2)); } }; #ifndef NO_OSTREAM_INSERT_CONIC_ARC_2 template std::ostream& operator<< (std::ostream& os, const Conic_arc_2 & arc) { typedef typename Conic_arc_2::Point_2 Point_2; const Point_2& source = arc.source(); const Point_2& target = arc.target(); os << "{" << CGAL::to_double(arc.r()) << "*x^2 + " << CGAL::to_double(arc.s()) << "*y^2 + " << CGAL::to_double(arc.t()) << "*xy + " << CGAL::to_double(arc.u()) << "*x + " << CGAL::to_double(arc.v()) << "*y + " << CGAL::to_double(arc.w()) << "} :" << "(" << CGAL::to_double(source.x()) << "," << CGAL::to_double(source.y()) << ") -> " << "(" << CGAL::to_double(target.x()) << "," << CGAL::to_double(target.y()) << ")"; return (os); } #endif // NO_OSTREAM_INSERT_CONIC_ARC_2 CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2_eq_core.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_ar0000644000175000017500000001235411344301501031152 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2_eq_core.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_CONIC_ARC_2_EQ_CORE_H #define CGAL_CONIC_ARC_2_EQ_CORE_H CGAL_BEGIN_NAMESPACE /*! * Solve the quadratic equation: a*x^2 + b*x + c = 0. * Note that the number types of the solutions and of the equation coefficients * need not be the same, but it should be possible to construct a SolNT number * from a CfNT. * \param a The coefficient of x^2. * \param b The coefficient of x. * \param c The free coefficient. * \param roots The solutions of the equation. * This area must be allocated to the size of 2. * \return The number of distinct solutions. */ template int solve_quadratic_eq (const CfNT& a, const CfNT& b, const CfNT& c, SolNT* roots) { // Check if this is really a linear equation. const CfNT _zero = 0; if (a == _zero) { // Solve a linear equation. if (b != _zero) { roots[0] = -SolNT(c) / SolNT(b); return (1); } else { return (0); } } // Act according to the discriminant. const CfNT _two = 2; const CfNT _four = 4; const CfNT disc = b*b - _four*a*c; Comparison_result res = CGAL_NTS compare(disc, _zero); if (res == SMALLER) { // No real roots. return (0); } else if (disc == EQUAL) { // One real root with mutliplicity 2. roots[0] = -SolNT(b) / SolNT(_two*a); return (1); } else { // Two real roots. const SolNT sqrt_disc = CGAL::sqrt(SolNT(disc)); roots[0] = (sqrt_disc - SolNT(b)) / SolNT(_two*a); roots[1] = -(sqrt_disc + SolNT(b)) / SolNT(_two*a); return (2); } } /*! * Solve a quartic equation: a*x^4 + b*x^3 + c*x^2 + d*x + e = 0. * Note that the number types of the solutions and of the equation coefficients * need not be the same, but it should be possible to construct a SolNT number * from a CfNT. * \param a The coefficient of x^4. * \param b The coefficient of x^3. * \param c The coefficient of x^2. * \param d The coefficient of x. * \param e The free coefficient. * \param roots The solutions of the equation. * This area must be allocated to the size of 4. * \return The number of distinct solutions. */ template int solve_quartic_eq (const CfNT& a, const CfNT& b, const CfNT& c, const CfNT& d, const CfNT& e, SolNT* roots) { // First check whether we have 0 as a multiple root. static const CfNT _zero = 0; if (e == _zero && d == _zero) { if (c == _zero) { if (b == _zero) { // Unless the equation is trivial, we have the root 0, // with multiplicity of 4. if (a == _zero) return (0); roots[0] = SolNT(_zero); return (1); } else { // Add the solution 0 (with multiplicity 3), and add the solution // to a*x + b = 0. if (a == _zero) return (0); roots[0] = SolNT(_zero); roots[1] = -SolNT(b) / SolNT(a); return (2); } } else { // Add the solution 0 (with multiplicity 2), // and solve a*x^2 + b*x + c*x = 0. roots[0] = SolNT(_zero); return (1 + solve_quadratic_eq (a, b, c, roots + 1)); } } // In case we have an equation of a lower degree: if (a == _zero && b == _zero) { // We have to solve c*x^2 + d*x + e = 0. return (solve_quadratic_eq (c, d, e, roots)); } // In case we have an equation of the form: // a*x^4 + c*x^2 + e = 0 // // Then by substituting y = x^2, we obtain a quadratic equation: // a*y^2 + c*y + e = 0 // if (b == _zero && d == _zero) { // Solve the equation for y = x^2. SolNT sq_roots[2]; int n_sq; n_sq = solve_quadratic_eq (a, c, e, sq_roots); // Convert to roots of the original equation: only positive roots for y // are relevant of course. int n = 0; int j; for (j = 0; j < n_sq; j++) { if (sq_roots[j] > SolNT(0)) { roots[n] = CGAL::sqrt(sq_roots[j]); roots[n+1] = -roots[n]; n += 2; } } return (n); } // Set a quadratic polynomial p(x) and compute its real-valued roots. std::vector coeffs(5); coeffs[4] = a; coeffs[3] = b; coeffs[2] = c; coeffs[1] = d; coeffs[0] = e; CORE::Polynomial p (coeffs); CORE::Sturm sturm (p); const int n_roots = sturm.numberOfRoots(); int i; for (i = 1; i <= n_roots; i++) { // Get the i'th real-valued root. roots[i - 1] = rootOf(p, i); } return (n_roots); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2_eq.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_ar0000644000175000017500000002050511344301501031147 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2_eq.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_CONIC_ARC_2_EQ_CORE_H #define CGAL_CONIC_ARC_2_EQ_CORE_H //#include //#include CGAL_BEGIN_NAMESPACE /*! * Solve the quadratic equation: a*x^2 + b*x + c = 0. * Note that the number types of the solutions and of the equation coefficients * need not be the same, but it should be possible to construct a SolNT number * from a CfNT. * \param a The coefficient of x^2. * \param b The coefficient of x. * \param c The free coefficient. * \param roots The solutions of the equation. * This area must be allocated to the size of 2. * \return The number of distinct solutions. */ template int solve_quadratic_eq (const CfNT& a, const CfNT& b, const CfNT& c, SolNT* roots) { // Check if this is really a linear equation. const CfNT _zero = 0; if (a == _zero) { // Solve a linear equation. if (b != _zero) { roots[0] = -SolNT(c) / SolNT(b); return (1); } else { return (0); } } // Act according to the discriminant. const CfNT _two = 2; const CfNT _four = 4; const CfNT disc = b*b - _four*a*c; Comparison_result res = CGAL_NTS compare(disc, _zero); if (res == SMALLER) { // No real roots. return (0); } else if (disc == EQUAL) { // One real root with mutliplicity 2. roots[0] = -SolNT(b) / SolNT(_two*a); return (1); } else { // Two real roots. const SolNT sqrt_disc = CGAL::sqrt(SolNT(disc)); roots[0] = (sqrt_disc - SolNT(b)) / SolNT(_two*a); roots[1] = -(sqrt_disc + SolNT(b)) / SolNT(_two*a); return (2); } } /*! * Make the given polynomial square-free. * \param p The polynomial. */ template void _make_square_free (CORE::Polynomial& p) { // Perform Euclid's algorithm with a(x) = p(x) and b(x) = p'(x). CORE::Polynomial a (p); CORE::Polynomial b = differentiate(p); CORE::Polynomial g; int k = 0; while (true) { if ((k % 2) == 0) { a.pseudoRemainder(b); if (zeroP(a)) { g = b; break; } } else { b.pseudoRemainder(a); if (zeroP(b)) { g = a; break; } } k++; } // Now we have g(x) = gcd (p(x), p'(x)): const int g_deg = g.getTrueDegree(); if (g_deg <= 0) return; // Make p(x) square-free by dividing it by g(x). To avoid complications, // make sure that p's leading coefficient is at least as large as g's. const int p_deg = p.getTrueDegree(); const int sf_deg = p_deg - g_deg; const CfNT lead_p = p.getCoeff(p_deg); std::vector cmul(1); cmul[0] = g.getCoeff(g_deg); p *= CORE::Polynomial(cmul); p = p.pseudoRemainder(g); // For some reason (IS THIS A BUG?), the leading coefficient of the // remainder is missing -- fix this problem. if (p.getTrueDegree() != sf_deg) { std::vector cadd(sf_deg+1); int i; for (i = 0; i < sf_deg; i++) cadd[i] = 0; cadd[sf_deg] = lead_p; p += CORE::Polynomial(cadd); } return; } /*! * Solve a cubic equation: a*x^3 + b*x^2 + c*x + d = 0. * Note that the number types of the solutions and of the equation coefficients * need not be the same, but it should be possible to construct a SolNT number * from a CfNT. * \param a The coefficient of x^3. * \param b The coefficient of x^2. * \param c The coefficient of x. * \param d The free coefficient. * \param roots The solutions of the equation. * This area must be allocated to the size of 3. * \return The number of distinct solutions. */ template int _solve_cubic_eq (const CfNT& a, const CfNT& b, const CfNT& c, const CfNT& d, SolNT* roots) { // Set a quadratic polynomial p(x) and compute its real-valued roots. std::vector coeffs(4); coeffs[3] = a; coeffs[2] = b; coeffs[1] = c; coeffs[0] = d; CORE::Polynomial p (coeffs); _make_square_free (p); CORE::Sturm sturm (p); const int n_roots = sturm.numberOfRoots(); int i; for (i = 1; i <= n_roots; i++) { // Get the i'th real-valued root. roots[i - 1] = rootOf(p, i); } return (n_roots); } /*! * Solve a quartic equation: a*x^4 + b*x^3 + c*x^2 + d*x + e = 0. * Note that the number types of the solutions and of the equation coefficients * need not be the same, but it should be possible to construct a SolNT number * from a CfNT. * \param a The coefficient of x^4. * \param b The coefficient of x^3. * \param c The coefficient of x^2. * \param d The coefficient of x. * \param e The free coefficient. * \param roots The solutions of the equation. * This area must be allocated to the size of 4. * \return The number of distinct solutions. */ template int solve_quartic_eq (const CfNT& a, const CfNT& b, const CfNT& c, const CfNT& d, const CfNT& e, SolNT* roots) { // In case we have an equation of a lower degree: static const CfNT _zero = 0; if (a == _zero) { if (b == _zero) { // We have to solve c*x^2 + d*x + e = 0. return (solve_quadratic_eq (c, d, e, roots)); } else { // We have to solve b*x^3 + c*x^2 + d*x + e = 0. return (_solve_cubic_eq (b, c, d, e, roots)); } } // First check whether we have 0 as a multiple root. if (e == _zero) { if (d == _zero) { if (c == _zero) { if (b == _zero) { // Unless the equation is trivial, we have the root 0, // with multiplicity of 4. if (a == _zero) return (0); roots[0] = SolNT(_zero); return (1); } else { // Add the solution 0 (with multiplicity 3), and add the solution // to a*x + b = 0. if (a == _zero) return (0); roots[0] = SolNT(_zero); roots[1] = -SolNT(b) / SolNT(a); return (2); } } else { // Add the solution 0 (with multiplicity 2), // and solve a*x^2 + b*x + c = 0. roots[0] = SolNT(_zero); return (1 + solve_quadratic_eq (a, b, c, roots + 1)); } } else { // Add the solution 0, and solve a*x^3 + b*x^2 + c*x + d = 0. roots[0] = SolNT(_zero); return (1 + _solve_cubic_eq (a, b, c, d, roots + 1)); } } // In case we have an equation of the form: // a*x^4 + c*x^2 + e = 0 // // Then by substituting y = x^2, we obtain a quadratic equation: // a*y^2 + c*y + e = 0 // if (b == _zero && d == _zero) { // Solve the equation for y = x^2. SolNT sq_roots[2]; int n_sq; n_sq = solve_quadratic_eq (a, c, e, sq_roots); // Convert to roots of the original equation: only positive roots for y // are relevant of course. int n = 0; int j; for (j = 0; j < n_sq; j++) { if (sq_roots[j] > SolNT(0)) { roots[n] = CGAL::sqrt(sq_roots[j]); roots[n+1] = -roots[n]; n += 2; } } return (n); } // Set a quadratic polynomial p(x) and compute its real-valued roots. std::vector coeffs(5); coeffs[4] = a; coeffs[3] = b; coeffs[2] = c; coeffs[1] = d; coeffs[0] = e; CORE::Polynomial p (coeffs); _make_square_free (p); CORE::Sturm sturm (p); const int n_roots = sturm.numberOfRoots(); int i; for (i = 1; i <= n_roots; i++) { // Get the i'th real-valued root. roots[i - 1] = rootOf(p, i); } return (n_roots); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Hyper_segment_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Hyper_se0000644000175000017500000004652711344301501031224 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Hyper_segment_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_HYPER_SEGMENT_2_H #define CGAL_HYPER_SEGMENT_2_H #include #include #include #include class CGAL::Window_stream; CGAL_BEGIN_NAMESPACE /*! * Representation of a segment of a simplified canonical hyperbola, * given by the equation: * a*x^2 + b*y2 + c*x + d = 0 * * We consider the upper part of the hyprobola (y > 0), thus the following * holds: * y = sqrt(A*x^2 + B*x + C) * * The end-points of the hyperbolic segment are defined by x_min and x_max. */ template class Hyper_segment_2 { protected: typedef Hyper_segment_2 Self; public: typedef Kernel_ Kernel; typedef typename Kernel::FT NT; typedef typename Kernel::Point_2 Point_2; private: bool _is_seg; // Is this hyper-segment actaully a line segment. NT _A; // The coefficients of the equation of NT _B; // the underlying canonical hyperbola: NT _C; // y = sqrt (A*x^2 + B*x + C) Point_2 _source; // The hyperbolic segment source. Point_2 _target; // The hyperbolic segment target. public: /*! * Default constructor. */ Hyper_segment_2 () : _is_seg(true) {} /*! * Construct a hyperbolic segment which lies on the canocial hyperbola: * a*x^2 + b*y2 + c*x + d = 0 * And bounded by x-min and x-max. * \param a The coefficient of x^2 in the equation of the hyperbola. * \param b The coefficient of y^2 in the equation of the hyperbola. * \param c The coefficient of x in the equation of the hyperbola. * \param d The free coefficient in the equation of the hyperbola. * \param x_min The x-coordinate of the leftmost end-point of the segment. * \param x_max The x-coordinate of the righttmost end-point of the segment. * \pre (a > 0) and (b < 0) -- to make sure this is indeed a hyperbola. * Furthermore, x_max > x_min. */ Hyper_segment_2 (const NT& a, const NT& b, const NT& c, const NT& d, const NT& x_min, const NT& x_max) : _is_seg(false) { CGAL_precondition_code (static const NT _zero = 0;); CGAL_precondition(_compare (a, _zero) == LARGER); CGAL_precondition(_compare (b, _zero) == SMALLER); CGAL_precondition(_compare (x_min, x_max) == SMALLER); // Set the normalized coefficients of the hyperbola. _A = -(a/b); _B = -(c/b); _C = -(d/b); // Set the end-points. bool source_ok = _get_point_at_x (x_min, _source); bool target_ok = _get_point_at_x (x_max, _target); if (! (source_ok && target_ok)) { CGAL_assertion (source_ok); CGAL_assertion (target_ok); } // Check that both end-points lie on the same hyperbolic branch. /* CGAL_assertion_code ( NT xs[2]; int n = _solve_quadratic_equation (_A, _B, _C, xs[0], xs[1]); Comparison_result res1; Comparison_result res2; int i; CGAL_assertion (n == 2); for (i = 0; i < 2; i++) { res1 = _compare (x_min, xs[i]); res2 = _compare (x_max, xs[i]); CGAL_assertion (res1 == EQUAL || res2 == EQUAL || res1 == res2); } ); */ } /*! * Construct a degenerate hyperbolic segment defined by a line segment. * \param ps The source point of the segment. * \param pt The target point of the segment. * \pre The segment is not vertical -- that is, x(ps) does not equal x(pt). * Furthermore, both points should lie above the x-axis. */ Hyper_segment_2 (const Point_2& ps, const Point_2& pt) : _is_seg(true) { // Make sure that the two points do not define a vertical segment. Comparison_result comp_x = _compare (ps.x(), pt.x()); CGAL_precondition(comp_x != EQUAL); // Make sure that both points are above the x-axis. CGAL_precondition_code (static const NT _zero = 0;); CGAL_precondition(_compare (ps.y(), _zero) == LARGER); CGAL_precondition(_compare (pt.y(), _zero) == LARGER); // Find the line (y = a*x + b) that connects the two points. const NT denom = ps.x() - pt.x(); const NT a = (ps.y() - pt.y()) / denom; const NT b = (ps.x()*pt.y() - pt.x()*ps.y()) / denom; // Set the underlying hyperbola to be the pair of lines: // y^2 = (a*x + b)^2 = (a^2)*x^2 + (2ab)*x + b^2 _A = a*a; _B = 2*a*b; _C = b*b; // Set the source and target point. if (comp_x != LARGER) { _source = ps; _target = pt; } else { _source = pt; _target = ps; } } /*! * Access the hyperblic coeffcients. */ const NT& A () const {return (_A);} const NT& B () const {return (_B);} const NT& C () const {return (_C);} /*! * Get the source of the hyper-segment. * \return The source point. */ const Point_2& source () const { return (_source); } /*! * Get the target of the hyper-segment. * \return The target point. */ const Point_2& target () const { return (_target); } /*! * Check whether the hyper-segment is actually a line segment. * \return (true) if the underlying hyperbola is actually a line segment. */ bool is_linear () const { return (_is_seg); } /*! * Check if the two hyper-segments are equal. * \param seg The compares hyper-segments. * \return (true) if seg equals (*this) or if it is its flipped version. */ bool is_equal (const Self& seg) const { if (this == &seg) return (true); // The underlying hyperbola must be the same: if (! _has_same_base_hyperbola(seg)) return (false); // Compare the source and target. if (_compare (_source.x(), seg._source.x()) && _compare (_target.x(), seg._target.x())) return (true); else if (_compare (_source.x(), seg._target.x()) && _compare (_target.x(), seg._source.x())) return (true); return (false); } /*! * Get a bounding box for the hyper-segment. * \return A bounding box. */ Bbox_2 bbox () const { // Use the source and target to find the exterme coordinates. double x1 = CGAL::to_double(_source.x()); double y1 = CGAL::to_double(_source.y()); double x2 = CGAL::to_double(_target.x()); double y2 = CGAL::to_double(_target.y()); double x_min, x_max; double y_min, y_max; if (x1 < x2) { x_min = x1; x_max = x2; } else { x_min = x2; x_max = x1; } if (y1 < y2) { y_min = y1; y_max = y2; } else { y_min = y2; y_max = y1; } // Try to check if any extreme points are contained in our segment. if (_A != 0) { // The x-coordinate of the extreme point is given by: double x_ext = CGAL::to_double(-_B / (2*_A)); if (x_min < x_ext && x_ext < x_max) { // The y-value at the extreme point is given by: double y_ext = (CGAL::to_double(_A)*x_ext + CGAL::to_double(_B))*x_ext + CGAL::to_double(_C); if (y_ext > 0) y_ext = CGAL::sqrt(y_ext); else y_ext = 0; if (y_ext < y_min) y_min = y_ext; else if (y_ext > y_max) y_max = y_ext; } } // Return the resulting bounding box. return (Bbox_2 (x_min, y_min, x_max, y_max)); } /*! * Check if the given point is in the x-range of the hyper-segment. * \param q The query point. * \return (true) if q is in the x-range of the hyper-segment. */ bool point_is_in_x_range (const Point_2& q) const { Comparison_result res1 = _compare (q.x(), _source.x()); Comparison_result res2 = _compare (q.x(), _target.x()); return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); } /*! * Check the position of the query point with respect to the hyper-segment. * \param q The query point. * \return SMALLER if q lies under the hyper-segment; * LARGER if it lies above the hyper-segment; * EQUAL if q lies on the hyper-segment. * \pre q is in the x-range of the hyper-segment. */ Comparison_result point_position (const Point_2& q) const { CGAL_precondition(point_is_in_x_range (q)); // Substitute q's x-coordinate into the equation of the hyperbola and // compare the result. return (_compare (q.y(), CGAL::sqrt(_A*q.x()*q.x() + _B*q.x() + _C))); } /*! * Return a flipped hyper-segment. * \return The flipped hyper-segment. */ Self flip () const { Self flipped (*this); flipped._source = _target; flipped._target = _source; return (flipped); } /*! * Compare the y-coordinates of two hyper-segments at a given x-coordinate. * \param seg The other segment. * \param q The point (a placeholder for the x-coordinate). * \return SMALLER if (*this) is below seg at q; * LARGER if it is above seg at q; * EQUAL if the two hyper-segment intersect at this x-coordinate. * \pre q is in the x-range of both hyper-segments. */ Comparison_result compare_y_at_x (const Self& seg, const Point_2& q) const { CGAL_precondition(this->point_is_in_x_range(q)); CGAL_precondition(seg.point_is_in_x_range(q)); // Compare y1 = A1*x^2 + B1*x + C1 // and y2 = A2*x^2 + B2*x + C2: return (_compare (_A*q.x()*q.x() + _B*q.x() + _C, seg._A*q.x()*q.x() + seg._B*q.x() + seg._C)); } /*! * Compare the slopes of two hyper-segments at their intersection point. * \param seg The other segment. * \param q A placeholder for the x-coordinate of the intersection point. * \return SMALLER if the slope of (*this) is less than seg's at q; * LARGER if it is larger at q; * EQUAL if the two slopes are equal (in case of an overlap). * \pre Both (*this) and seg are equal at q.x() */ Comparison_result compare_slopes (const Self& seg, const Point_2& q) const { // The underlying hyperbola is: // y = sqrt(A*x^2 + B*x + C) // // If we derive, we obtain: // 2A*x + B 2A*x + B // y' = ------------------------- = ---------- // 2*sqrt(A*x^2 + B*x + C) y // NT y2 = _A*q.x()*q.x() + _B*q.x() + _C; Comparison_result res = _compare (y2, 0); CGAL_precondition(_compare (y2, seg._A*q.x()*q.x() + seg._B*q.x() + seg._C) == EQUAL); CGAL_assertion(res != SMALLER); if (res == LARGER) { // The y-coordinate of the intersection point is greater than 0. // It is therefore sufficient to compare the numerators of the // expressions of the two derivatives: res = _compare (2*_A*q.x() + _B, 2*seg._A*q.x() + seg._B); if (res != EQUAL) return (res); // Compare the second derivatives, where: // // 2A*y^2 - (2A*x + B)^2 // y'' = ----------------------- // 2*y^3 // return (_compare (2*_A*y2 - (2*_A*q.x() + _B)*(2*_A*q.x() + _B), 2*seg._A*y2 - (2*seg._A*q.x() + seg._B)* (2*seg._A*q.x() + seg._B))); } else // (res == EQUAL), that is the y-coordinate is 0. { // Compare the second derivative by x, which in our case equals: return (_compare (2*_A*q.x() + _B, 2*seg._A*q.x() + seg._B)); } } /*! * Intersect the two hyper-segments. * \param seg The second hyper-segment. * \param p1 The output intersection point (if one exists). * \param p2 The second intersection point (in case of an overlap). * \return The number of intersection points computed: * 0 - No intersection. * 1 - A simple intersection returned as p1. * 2 - An overlapping segment, whose end-points are p1 and p2. */ int intersect (const Self& seg, Point_2& p1, Point_2& p2) const { // First check the case of overlapping hyper-segments. if (_has_same_base_hyperbola(seg)) { bool bs = point_is_in_x_range (seg._source); bool bt = point_is_in_x_range (seg._target); if (bs && bt) { // (*this) contains the second segment: if (_compare (seg._source.x(), seg._target.x()) == SMALLER) { p1 = seg._source; p2 = seg._target; } else { p2 = seg._source; p1 = seg._target; } return (2); } else if (bs || bt) { // Only one of the end-points is contained in (*this): const Point_2& p_in = bs ? seg._source : seg._target; const Point_2& p_out = bs ? seg._target : seg._source; bool to_right = (_compare(_source.x(), _target.x()) == SMALLER); Comparison_result res = _compare (p_out.x(), _source.x()); if (_compare (p_in.x(), _source.x()) == EQUAL) { // The two hyper-segments share just a common end-point. if ((to_right && res == SMALLER) || (!to_right && res == LARGER)) { p1 = p_in; return (1); } } else if (_compare (p_in.x(), _target.x()) == EQUAL) { // The two hyper-segments share just a common end-point. if ((to_right && res == LARGER) || (!to_right && res == SMALLER)) { p1 = p_in; return (1); } } if (res == SMALLER) { p1 = to_right ? _source : _target; p2 = p_in; } else { p1 = p_in; p2 = to_right ? _target : _source; } return (2); } else { // Check if seg contains (*this). bs = seg.point_is_in_x_range (_source); bt = seg.point_is_in_x_range (_target); if (bs && bt) { if (_compare (_source.x(), _target.x()) == SMALLER) { p1 = _source; p2 = _target; } else { p2 = _source; p1 = _target; } return (2); } } // The two segments are disjoint: return (0); } // The equations of the two underlying hyperbola are given by: // H1: y = A1*x^2 + B1*x + C1 // H2: y = A2*x^2 + B2*x + C2 // // So the following must hold for the x-coordinates of the intersection // points: // (A1 - A2)*x^2 + (B1 - B2)*x + (C1 - C2) = 0 // NT xs[2]; bool bs[2]; int n_xs; int i; n_xs = _solve_quadratic_equation (_A - seg._A, _B - seg._B, _C - seg._C, xs[0], xs[1]); // Check the legality of each of the x-coordinates. bs[0] = false; bs[1] = false; for (i = 0; i < n_xs; i++) { bs[i] = true; Comparison_result res1 = _compare(xs[i], _source.x()); Comparison_result res2 = _compare(xs[i], _target.x()); if (res1 != EQUAL && res2 != EQUAL && res1 == res2) bs[i] = false; else { res1 = _compare(xs[i], seg._source.x()); res2 = _compare(xs[i], seg._target.x()); if (res1 != EQUAL && res2 != EQUAL && res1 == res2) bs[i] = false; } } // Make sure we return one point at most. if (!bs[0] && !bs[1]) return (0); CGAL_assertion (!(bs[0] && bs[1])); if (bs[0]) _get_point_at_x (xs[0], p1); else _get_point_at_x (xs[1], p1); return (1); } /*! * Split a hyper-segment at a given point. * \param p The split point. * \param seg1 The first resulting hyper-segment. * \param seg2 The second resulting hyper-segment. * \pre p lies in the interior of the curve (and is not and end-point). */ void split (const Point_2& p, Self& seg1, Self& seg2) const { CGAL_precondition(point_position(p) == EQUAL); CGAL_precondition(_compare(_source.x(), p.x()) != EQUAL); CGAL_precondition(_compare(_target.x(), p.x()) != EQUAL); seg1 = (*this); seg1._target = p; seg2 = (*this); seg2._source = p; return; } /* * Trim the hyper-segment at the given x-coodinates. * \param p1 A placeholder for the x-coordinates of the new source. * \param p2 A placeholder for the x-coordinates of the new target. * \return The trimmed hyper-segment. * \pre p1 and p2 are both in the x-range of the hyper-segment. */ Self trim (const Point_2& p1, const Point_2& p2) const { CGAL_precondition(point_is_in_x_range(p1)); CGAL_precondition(point_is_in_x_range(p2)); Self trimmed (*this); _get_point_at_x (p1.x(), trimmed._source); _get_point_at_x (p2.x(), trimmed._target); return (trimmed); } protected: /*! * Compare two values. */ inline Comparison_result _compare (const NT& val1, const NT& val2) const { return (CGAL_NTS compare(val1, val2)); } /*! * Check whether the underlying hyperbola contains a point with the given * x-coordinate and compute it if it does. * \param x The x-coordinate. * \param p The output point. * \return (true) if the underlying hyperbola contains a point with the * given x-coordinate. */ bool _get_point_at_x (const NT& x, Point_2& p) const { // Try to compute the y-coordinate. NT val = _A*x*x + _B*x + _C; static const NT _zero = 0; if (_compare(val, _zero) == SMALLER) return (false); p = Point_2(x, CGAL::sqrt(val)); return (true); } /*! * Check whether the two hyper-segments lie on the same hyperbola. * \param seg The compared hyper-segment. * \return (true) if the two hyper-segments lie on the same hyperbola. */ bool _has_same_base_hyperbola (const Self& seg) const { return ((_compare (_A, seg._A) == EQUAL) && (_compare (_B, seg._B) == EQUAL) && (_compare (_C, seg._C) == EQUAL)); } /*! * Solve the equation a*x^2 + b*x + c = 0. * \return The number of solutions found. */ int _solve_quadratic_equation (const NT& a, const NT& b, const NT& c, NT& x1, NT& x2) const { static const NT _zero = 0; static const NT _two = 2; static const NT _four = 4; if (_compare (a, _zero) == EQUAL) { // If this is a linear equation: if (_compare (b, _zero) == EQUAL) return (0); x1 = -c / b; return (1); } // Act according to the sign of (b^2 - 4ac): const NT disc = b*b - _four*a*c; Comparison_result res = _compare (disc, _zero); if (res == SMALLER) { return (0); } else if (res == EQUAL) { x1 = (-b) / (_two*a); return (1); } const NT sqrt_disc = CGAL::sqrt (disc); x1 = (sqrt_disc - b) / (_two*a); x2 = -(sqrt_disc + b) / (_two*a); return (2); } }; #ifndef NO_OSTREAM_INSERT_CONIC_ARC_2 template std::ostream& operator<< (std::ostream& os, const Hyper_segment_2& seg) { os << "{ y^2 = " << CGAL::to_double(seg.A()) << "*x^2 + " << CGAL::to_double(seg.B()) << "*x + " << CGAL::to_double(seg.C()) << " } : " << "(" << CGAL::to_double(seg.source().x()) << "," << CGAL::to_double(seg.source().y()) << ") -> " << "(" << CGAL::to_double(seg.target().x()) << "," << CGAL::to_double(seg.target().y()) << ")"; return (os); } #endif // NO_OSTREAM_INSERT_CONIC_ARC_2 CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_ar0000644000175000017500000025622011344301501031154 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2/Conic_arc_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_CONIC_ARC_2_CORE_H #define CGAL_CONIC_ARC_2_CORE_H #include #include #include #include #include #include #include #include #define CGAL_CONIC_ARC_USE_CACHING CGAL_BEGIN_NAMESPACE /*! * A class that stores additional information with the point's coordinates: * Namely the conic IDs of the generating curves. */ template class Point_ex_2 : public Kernel_::Point_2 { public: typedef Kernel_ Kernel; typedef typename Kernel::Point_2 Base; typedef Point_ex_2 Self; typedef typename Kernel::FT CoNT; private: int _id1; // The ID of the first generating conic (or 0). int _id2; // The ID of the second generating conic (or 0). public: // Constructors. Point_ex_2 () : Base(), _id1(0), _id2(0) {} Point_ex_2 (const CoNT& hx, const CoNT& hy, const CoNT& hz) : Base(hx,hy,hz), _id1(0), _id2(0) {} Point_ex_2 (const CoNT& hx, const CoNT& hy, const int& id1 = 0, const int& id2 = 0) : Base(hx,hy), _id1(id1), _id2(id2) {} Point_ex_2 (const Base& p) : Base(p), _id1(0), _id2(0) {} Point_ex_2 (const Base& p, const int& id1, const int& id2 = 0) : Base(p), _id1(id1), _id2(id2) {} // Set the generating conic IDs. void set_generating_conics (const int& id1, const int& id2 = 0) { _id1 = id1; _id2 = id2; return; } // Check if the given conic generates the point. bool is_generating_conic_id (const int& id) const { return (id != 0 && (id == _id1 || id == _id2)); } // Check whether two points are equal. bool equals (const Self& p) const { // If the two points are the same: if (this == &p) return (true); // Use the parent's equality operator. return ((*this) == p); } // Compare the x coordinates. Comparison_result compare_x (const Self& p) const { return (CGAL_NTS compare(this->x(), p.x())); } // Compare the y coordinates. Comparison_result compare_y (const Self& p) const { return (CGAL_NTS compare(this->y(), p.y())); } // Compare two points lexicographically. Comparison_result compare_lex_xy (const Self& p) const { Comparison_result res = this->compare_x (p); if (res != EQUAL) return (res); return (this->compare_y (p)); } }; /*! * Representation of a conic arc -- a bounded segment that lies on a conic * curve, the loci of all points satisfying the equation: * r*x^2 + s*y^2 + t*xy + u*x + v*y +w = 0 * * The class is templated with two parameters: * Int_kernel_ is a kernel that provides the input points or coefficients. * Int_kernel_::FT must be of an integral type (e.g. CORE:BigInt). * Alg_kernel_ is a geometric kernel, where Kernel_::FT is the number type * for the coordinates of points, which are algebraic numbers * (preferably it is CORE::Expr). */ static int _conics_count = 0; template class Arr_conic_traits_2; template class Conic_arc_2 { protected: typedef Conic_arc_2 Self; public: typedef Int_kernel_ Int_kernel; typedef Alg_kernel_ Alg_kernel; // Define objects from the integral kernel. typedef typename Int_kernel::FT CfNT; typedef typename Int_kernel::Point_2 Int_point_2; typedef typename Int_kernel::Segment_2 Int_segment_2; typedef typename Int_kernel::Line_2 Int_line_2; typedef typename Int_kernel::Circle_2 Int_circle_2; // Define objects from the algebraic kernel. typedef typename Alg_kernel::FT CoNT; typedef Point_ex_2 Point_2; protected: friend class Arr_conic_traits_2; enum { DEGREE_0 = 0, DEGREE_1 = 1, DEGREE_2 = 2, DEGREE_MASK = 1 + 2, FULL_CONIC = 4, X_MONOTONE = 8, X_MON_UNDEFINED = 8 + 16, FACING_UP = 32, FACING_DOWN = 64, FACING_MASK = 32 + 64, IS_VERTICAL_SEGMENT = 128, IS_VALID = 256 }; CfNT _r; // CfNT _s; // The coefficeint of the underlying conic curve: CfNT _t; // CfNT _u; // CfNT _v; // r*x^2 + s*y^2 + t*xy + u*x + v*y +w = 0 CfNT _w; // Orientation _orient; // The orientation of the conic. int _conic_id; // The id of the conic. Point_2 _source; // The source of the arc. Point_2 _target; // The target of the arc. int _info; // A bit array with extra information: // Bit 0 & 1 - The degree of the conic // (either 1 or 2). // Bit 2 - Whether the arc is a full conic. // Bit 3 & 4 - Whether the arc is x-monotone // (00, 01 or 11 - undefined). // Bit 5 & 6 - Indicate whether the arc is // facing upwards or downwards (for // x-monotone curves of degree 2). // Bit 7 - Is the arc a vertical segment. // Bit 8 - Is the arc valid. // For arcs whose base is a hyperbola we store the axis (a*x + b*y + c = 0) // which separates the two bracnes of the hyperbola. We also store the side // (-1 or 1) that the arc occupies. struct Hyperbolic_arc_data { CoNT a; CoNT b; CoNT c; int side; }; #ifdef CGAL_CONIC_ARC_USE_CACHING struct Intersections { int id1; int id2; int n_points; Point_2 ps[4]; }; #endif Hyperbolic_arc_data *_hyper_P; // Produce a unique id for a new conic. int _get_new_conic_id () { _conics_count++; return (_conics_count); } /*! * Protected constructor: Construct an arc which is a segment of the given * conic arc, with a new source and target points. * \param The copied arc. * \param source The new source point. * \param target The new target point. */ Conic_arc_2 (const Self & arc, const Point_2& source, const Point_2 & target) : _r(arc._r), _s(arc._s), _t(arc._t), _u(arc._u), _v(arc._v), _w(arc._w), _orient(arc._orient), _conic_id(arc._conic_id), _source(source), _target(target), _hyper_P(NULL) { _info = (arc._info & DEGREE_MASK) | X_MON_UNDEFINED; // Copy the hyperbolic or circular data, if necessary. if (arc._hyper_P != NULL) _hyper_P = new Hyperbolic_arc_data (*(arc._hyper_P)); else _hyper_P = NULL; // Mark whether this is a vertical segment. if ((arc._info & IS_VERTICAL_SEGMENT) != 0) { _info = _info | IS_VERTICAL_SEGMENT; } // Check whether the conic is x-monotone. if (is_x_monotone()) { _info = (_info & ~X_MON_UNDEFINED) | X_MONOTONE; // Check whether the facing information is set for the orginating arc. // If it is, just copy it - otherwise calculate it if the degree is 2. Comparison_result facing_res = arc.facing(); if (facing_res != EQUAL) { _info = _info | (facing_res == LARGER ? FACING_UP : FACING_DOWN); } else if (_orient != CGAL::COLLINEAR) { bool legal_facing = _set_facing(); CGAL_assertion (legal_facing); if (! legal_facing) // Invalid arc: return; } } else { _info = (_info & ~X_MON_UNDEFINED); } // Mark the arc as valid. _info = (_info | IS_VALID); } public: /*! * Default constructor. */ Conic_arc_2 () : _r(0), _s(0), _t(0), _u(0), _v(0), _w(0), _orient(CGAL::COLLINEAR), _conic_id(0), _info(X_MON_UNDEFINED), _hyper_P(NULL) {} /*! * Copy constructor. * \param arc The copied arc. */ Conic_arc_2 (const Self & arc) : _r(arc._r), _s(arc._s), _t(arc._t), _u(arc._u), _v(arc._v), _w(arc._w), _orient(arc._orient), _conic_id(arc._conic_id), _source(arc._source), _target(arc._target), _info(arc._info), _hyper_P(NULL) { // Copy the hyperbolic or circular data, if necessary. if (arc._hyper_P != NULL) _hyper_P = new Hyperbolic_arc_data (*(arc._hyper_P)); else _hyper_P = NULL; } /*! * Construct a conic arc which lies on the conic: * C: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 * \param r,s,t,u,v,w The coefficients of the supporting conic curve. * \param orient The orientation of the arc. * \param source The source point. * \param target The target point. * \pre The source and the target must be on the conic boundary and must * not be the same. */ Conic_arc_2 (const CfNT& r, const CfNT& s, const CfNT& t, const CfNT& u, const CfNT& v, const CfNT& w, const Orientation& orient, const Point_2& source, const Point_2& target) : _r(r), _s(s), _t(t), _u(u), _v(v), _w(w), _source(source), _target(target), _info(X_MON_UNDEFINED), _hyper_P(NULL) { // Make sure the conic contains the two end-points on its boundary. const bool source_on_boundary = _conic_has_on_boundary(source); CGAL_precondition(source_on_boundary); const bool target_on_boundary = _conic_has_on_boundary(target); CGAL_precondition(target_on_boundary); // Make sure that the source and the target are not the same. const bool source_not_equals_target = (source != target); CGAL_precondition(source_not_equals_target); if (! (source_on_boundary && target_on_boundary && source_not_equals_target)) { // In this case, the arc is invalid. return; } // Set the arc properties (no need to compute the orientation). _orient = orient; _set (false); } /*! * Construct a conic arc which lies on the conic curve: * C: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 , * and whose endpoints are given by the intersections of C with a given line, * such that the arc lies on the positive half-plane defined by l. * \param r,s,t,u,v,w The coefficients of the supporting conic curve. * \param l The intersecting line. * \pre The line must have two intersection points with the conic curve. */ Conic_arc_2 (const CfNT& r, const CfNT& s, const CfNT& t, const CfNT& u, const CfNT& v, const CfNT& w, const Int_line_2& l) : _r(r), _s(s), _t(t), _u(u), _v(v), _w(w), _info(X_MON_UNDEFINED), _hyper_P(NULL) { // Make sure that the curve is of degree 2. const bool has_degree_2 = (CGAL_NTS compare(r, 0) != EQUAL || CGAL_NTS compare(s, 0) != EQUAL || CGAL_NTS compare(t, 0) != EQUAL); CGAL_precondition (has_degree_2); if (! has_degree_2) // In this case, the arc is invalid. return; // Find the intersection points with the line l: a*x + b*y + c = 0. const CfNT a = l.a(); const CfNT b = l.b(); const CfNT c = l.c(); Point_2 pmid; bool found_two_intersection_points; if (CGAL_NTS compare(b, 0) != EQUAL) { // Find the x-coordinates of the intersection points of the conic curve // and the line y = -(a*x + c) / b: CoNT xs[2]; int n_xs; n_xs = solve_quadratic_eq (b*b*r + a*(a*s - b*t), 2*a*c*s - b*(c*t + a*v + b*u), s*c*c + b*(b*w - c*v), xs); found_two_intersection_points = (n_xs == 2); if (! found_two_intersection_points) // The arc is invalid: return; _source = Point_2 (xs[0], -(a*xs[0] + c) / CoNT(b)); _target = Point_2 (xs[1], -(a*xs[1] + c) / CoNT(b)); // Get the conic points whose x-coordinate are in the middle of the // two endpoints. CoNT x_mid = (xs[0] + xs[1]) / 2; CoNT ys[2]; int n_ys; n_ys = _conic_get_y_coordinates (x_mid, ys); CGAL_precondition(n_ys > 0); if (CGAL_NTS compare (CoNT(a)*x_mid + CoNT(b)*ys[0] + CoNT(c), 0) == LARGER) { pmid = Point_2 (x_mid, ys[0]); } else { CGAL_assertion(CGAL_NTS compare (CoNT(a)*x_mid + CoNT(b)*ys[1] + CoNT(c), 0) == LARGER); pmid = Point_2 (x_mid, ys[1]); } } else { CGAL_precondition(CGAL_NTS compare(a, 0) != EQUAL); // Find the intersection of the vertical line x = -c / a: CoNT _x = CoNT(-c) / CoNT(a); CoNT ys[2]; int n_ys; n_ys = _conic_get_y_coordinates (_x, ys); found_two_intersection_points = (n_ys == 2); if (! found_two_intersection_points) // The arc is invalid: return; _source = Point_2 (_x, ys[0]); _target = Point_2 (_x, ys[1]); // Get the conic points whose y-coordinate are in the middle of the // two endpoints. CoNT y_mid = (ys[0] + ys[1]) / 2; CoNT xs[2]; int n_xs; n_xs = _conic_get_x_coordinates (y_mid, xs); CGAL_precondition(n_xs > 0); if (CGAL_NTS compare(CoNT(a)*xs[0] + CoNT(b)*y_mid + CoNT(c), 0) == LARGER) { pmid = Point_2 (xs[0], y_mid); } else { CGAL_assertion(CGAL_NTS compare (CoNT(a)*xs[1] + CoNT(b)*y_mid + CoNT(c), 0) == LARGER); pmid = Point_2 (xs[1], y_mid); } } // Determine the orientation: If the mid-point forms a left-turn with // the source and the target points, the orientation is positive (going // counterclockwise). // Otherwise, it is negative (going clockwise). static Alg_kernel ker; typename Alg_kernel::Orientation_2 orient_f = ker.orientation_2_object(); if (orient_f(_source, pmid, _target) == LEFT_TURN) _orient = CGAL::COUNTERCLOCKWISE; else _orient = CGAL::CLOCKWISE; // Set the arc properties (no need to compute the orientation). _set (false); } /*! * Construct a conic arc which is the full conic: * C: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 * \param r,s,t,u,v,w The coefficients of the conic curve. * \pre The conic C must be an ellipse (so 4rs - t^2 > 0). */ Conic_arc_2 (const CfNT& r, const CfNT& s, const CfNT& t, const CfNT& u, const CfNT& v, const CfNT& w) : _r(r), _s(s), _t(t), _u(u), _v(v), _w(w), _hyper_P(NULL) { // Make sure the given curve is an ellipse. bool is_ellipse = (CGAL_NTS compare(4*r*s - t*t, CfNT(0)) == LARGER); CGAL_precondition(is_ellipse); if (! is_ellipse) // In this case, the arc is invalid. return; // Set the arc to be the full conic (and compute the orientation). _set_full (true); } /*! * Construct a conic arc from the given line segment. * \param seg The line segment. */ Conic_arc_2 (const Int_segment_2& seg) : _hyper_P(NULL) { // Get the coordinates of the endpoints. const Int_point_2 src = seg.source(); const Int_point_2 trg = seg.target(); const CfNT x1 = src.x(), y1 = src.y(); const CfNT x2 = trg.x(), y2 = trg.y(); _source = Point_2 (CoNT(x1),CoNT(y1)); _target = Point_2 (CoNT(x2),CoNT(y2)); // Make sure that the source and the taget are not the same. CGAL_precondition(_source != _target); // The supporting conic is r=s=t=0, and u*x + v*y + w = 0 should hold // for both the source (x1,y1) and the target (x2, y2). const CfNT _zero = 0; const CfNT _one = 1; if (CGAL_NTS compare (x1, x2) == EQUAL) { // The supporting conic is a vertical line, of the form x = CONST. _r = _zero; _s = _zero; _t = _zero; _u = _one; _v = _zero; _w = -x1; } else { // The supporting line is A*x + B*y + C = 0, where: // // A = y2 - y1, B = x1 - x2, C = x2*y1 - x1*y2 // _r = _zero; _s = _zero; _t = _zero; _u = y2 - y1; _v = x1 - x2; _w = x2*y1 - x1*y2; } // The orientation is zero in case of a linear object. _orient = CGAL::COLLINEAR; // Set the arc properties (no need to compute the orientation). _set (false); } /*! * Set a circular arc that lies on a given circle. * \param circ The supporting circle. * \param orient The orientation of the circle. * \param source The source point. * \param target The target point. * \pre The source and the target must be on the conic boundary and must * not be the same. */ Conic_arc_2 (const Int_circle_2& circ, const Orientation& orient, const Point_2& source, const Point_2& target) : _source(source), _target(target), _info(X_MON_UNDEFINED), _hyper_P(NULL) { // Produce the correponding conic: if the circle centre is (x0,y0) // and it radius is R, that its equation is: // x^2 + y^2 - 2*x0*x - 2*y0*y + (x0^2 + y0^2 - R^2) = 0 // Since this equation describes a curve with a negative (clockwise) // orientation, we multiply it by -1 if necessary to obtain a positive // (counterclockwise) orientation. const Int_point_2 cc = circ.center(); const CfNT x0 = cc.x(), y0 = cc.y(); const CfNT R_sq = circ.squared_radius(); const CfNT _zero = 0; if (orient == CGAL::COUNTERCLOCKWISE) { const CfNT _minus_one = -1; const CfNT _two = 2; _r = _minus_one; _s = _minus_one; _t = _zero; _u = _two*x0; _v = _two*y0; _w = R_sq - x0*x0 - y0*y0; _orient = CGAL::COUNTERCLOCKWISE; } else { const CfNT _one = 1; const CfNT _minus_two = -2; _r = _one; _s = _one; _t = _zero; _u = _minus_two*x0; _v = _minus_two*y0; _w = x0*x0 + y0*y0 - R_sq; _orient = CGAL::CLOCKWISE; } // Make sure the conic contains the two end-points on its boundary. const bool source_on_boundary = _conic_has_on_boundary(source); CGAL_precondition(source_on_boundary); const bool target_on_boundary = _conic_has_on_boundary(target); CGAL_precondition(target_on_boundary); // Make sure that the source and the target are not the same. const bool source_not_equals_target = (source != target); CGAL_precondition(source_not_equals_target); if (! (source_on_boundary && target_on_boundary && source_not_equals_target)) { // In this case, the arc is invalid. return; } // Set the arc properties (no need to compute the orientation). _set (false); } /*! * Set a circular arc that corresponds a full circle: * \param circ The circle. */ Conic_arc_2 (const Int_circle_2& circ) : _hyper_P(NULL) { // Produce the correponding conic: if the circle centre is (x0,y0) // and it radius is R, that its equation is: // x^2 + y^2 - 2*x0*x - 2*y0*y + (x0^2 + y0^2 - R^2) = 0 // Note that this equation describes a curve with a negative (clockwise) // orientation. const Int_point_2 cc = circ.center(); const CfNT x0 = cc.x(), y0 = cc.y(); const CfNT R_sq = circ.squared_radius(); const CfNT _zero = 0; const CfNT _one = 1; const CfNT _minus_two = -2; _r = _one; _s = _one; _t = _zero; _u = _minus_two*x0; _v = _minus_two*y0; _w = x0*x0 + y0*y0 - R_sq; _orient = CGAL::CLOCKWISE; // Set the arc to be the full conic (no need to compute the orientation). _set_full (false); } /*! * Construct a circular arc from the given three points. * \param p1 The source point of the circular arc. * \param p2 A point between p1 and p3 on the arc. * \param p3 The target point of the circular arc. * \pre The three points must not be collinear. */ Conic_arc_2 (const Int_point_2& p1, const Int_point_2& p2, const Int_point_2& p3) : _info(X_MON_UNDEFINED), _hyper_P(NULL) { // Make sure that the source and the target are not the same. const bool source_not_equals_target = (p1 != p3); CGAL_precondition(source_not_equals_target); if (!source_not_equals_target) { // In this case, the arc is invalid. return; } // Get the coordinates of the points. const CfNT x1 = p1.x(), y1 = p1.y(); const CfNT x2 = p2.x(), y2 = p2.y(); const CfNT x3 = p3.x(), y3 = p3.y(); const CfNT _zero = 0; const CfNT _two = 2; // Compute the lines: A1*x + B1*y + C1 = 0, // and: A2*x + B2*y + C2 = 0, // where: const CfNT A1 = _two*(x1 - x2); const CfNT B1 = _two*(y1 - y2); const CfNT C1 = y2*y2 - y1*y1 + x2*x2 - x1*x1; const CfNT A2 = _two*(x2 - x3); const CfNT B2 = _two*(y2 - y3); const CfNT C2 = y3*y3 - y2*y2 + x3*x3 - x2*x2; // Compute the coordinates of the intersection point between the // two lines, given by (Nx / D, Ny / D), where: const CfNT Nx = B1*C2 - B2*C1; const CfNT Ny = A2*C1 - A1*C2; const CfNT D = A1*B2 - A2*B1; // Make sure the three points are not collinear. const bool points_collinear = (CGAL_NTS compare(D, _zero) == EQUAL); CGAL_precondition(!points_collinear); if (points_collinear) { // In this case, the arc is invalid. return; } // The equation of the underlying circle is given by: _r = D*D; _s = D*D; _t = _zero; _u = -_two*D*Nx; _v = -_two*D*Ny; _w = Nx*Nx + Ny*Ny - ((D*x2 - Nx)*(D*x2 - Nx) + (D*y2 - Ny)*(D*y2 - Ny)); // Set the endpoints. _source = Point_2 (CoNT(x1),CoNT(y1)); _target = Point_2 (CoNT(x3),CoNT(y3)); // Determine the orientation: If the mid-point forms a left-turn with // the source and the target points, the orientation is positive (going // counterclockwise). // Otherwise, it is negative (going clockwise). static Alg_kernel ker; typename Alg_kernel::Orientation_2 orient_f = ker.orientation_2_object(); Point_2 pmid = Point_2(CoNT(x2), CoNT(y2)); if (orient_f(_source, pmid, _target) == LEFT_TURN) _orient = CGAL::COUNTERCLOCKWISE; else _orient = CGAL::CLOCKWISE; // Set the arc properties (no need to compute the orientation). _set (false); } /*! * Construct a conic arc from the given five points, specified by the * points p1, p2, p3, p4 and p5. * \param p1 The source point of the given arc. * \param p2,p3,p4 Points lying on the conic arc, between p1 and p5. * \param p5 The target point of the given arc. * \pre No three points are collinear. */ Conic_arc_2 (const Int_point_2& p1, const Int_point_2& p2, const Int_point_2& p3, const Int_point_2& p4, const Int_point_2& p5) : _info(X_MON_UNDEFINED), _hyper_P(NULL) { // Make sure that the source and the target are not the same. const bool source_not_equals_target = (p1 != p5); CGAL_precondition(source_not_equals_target); if (!source_not_equals_target) { // In this case, the arc is invalid. return; } // Make sure that no three points are collinear. Int_kernel ker; typename Int_kernel::Orientation_2 orient_f = ker.orientation_2_object(); if (orient_f (p1, p2, p3) == CGAL::COLLINEAR || orient_f (p1, p2, p4) == CGAL::COLLINEAR || orient_f (p1, p2, p5) == CGAL::COLLINEAR || orient_f (p1, p3, p4) == CGAL::COLLINEAR || orient_f (p1, p3, p5) == CGAL::COLLINEAR || orient_f (p1, p4, p5) == CGAL::COLLINEAR || orient_f (p2, p3, p4) == CGAL::COLLINEAR || orient_f (p2, p3, p5) == CGAL::COLLINEAR || orient_f (p2, p4, p5) == CGAL::COLLINEAR || orient_f (p3, p4, p5) == CGAL::COLLINEAR) { // Invalid arc: return; } // Get the coordinates of the points. const CfNT x1 = p1.x(), y1 = p1.y(); const CfNT x5 = p5.x(), y5 = p5.y(); // Set a conic curve that passes through the five given point. typename Int_kernel::Conic_2 temp_conic; temp_conic.set (p1, p2, p3, p4, p5); // Get the conic coefficients. _r = temp_conic.r(); _s = temp_conic.s(); _t = temp_conic.t(); _u = temp_conic.u(); _v = temp_conic.v(); _w = temp_conic.w(); // Set the source and target points. _source = Point_2 (CoNT(x1), CoNT(y1)); _target = Point_2 (CoNT(x5), CoNT(y5)); // Determine the orientation: If one of the midpoints forms a left-turn // with the source and the target points, the orientation is positive // (going counterclockwise). // Otherwise, it is negative (going clockwise). const Orientation turn = orient_f(p1, p2, p5); bool same_turn; if (turn == LEFT_TURN) { _orient = CGAL::COUNTERCLOCKWISE; same_turn = (orient_f(p1, p3, p5) == LEFT_TURN) && (orient_f(p1, p4, p5) == LEFT_TURN); } else { _orient = CGAL::CLOCKWISE; same_turn = (orient_f(p1, p3, p5) != LEFT_TURN) && (orient_f(p1, p4, p5) != LEFT_TURN); } if (! same_turn) // In this case, the arc is invalid. return; // Set the arc properties (no need to compute the orientation). _set (false); // Make sure that all midpoints are strictly between the // source and the target. bool valid_midpoints = true; Point_2 mp2 (CoNT(p2.x()), CoNT(p2.y())); if (! _is_strictly_between_endpoints (mp2)) { valid_midpoints = false; } else { Point_2 mp3 (CoNT(p3.x()), CoNT(p3.y())); if (! _is_strictly_between_endpoints (mp3)) { valid_midpoints = false; } else { Point_2 mp4 (CoNT(p4.x()), CoNT(p4.y())); if (! _is_strictly_between_endpoints (mp4)) valid_midpoints = false; } } // If the midpoints are not valid, mark the arc as invalid. if (! valid_midpoints) _info = (_info & ~IS_VALID); } // Construct a conic arc which lies on the conic: // C: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0 // The source and the target are specified by the intersection of the // conic with: // C_1: r_1*x^2 + s_1*y^2 + t_1*xy + u_1*x + v_1*y + w_1 = 0 // C_2: r_2*x^2 + s_2*y^2 + t_2*xy + u_2*x + v_2*y + w_2 = 0 // The user must also specify the source and the target with approximated // coordinates. The actual intersection points that best fits the source // (or the target) will be selected. Conic_arc_2 (const CfNT& r, const CfNT& s, const CfNT& t, const CfNT& u, const CfNT& v, const CfNT& w, const Orientation& orient, const Point_2& app_source, const CfNT& r_1, const CfNT& s_1, const CfNT& t_1, const CfNT& u_1, const CfNT& v_1, const CfNT& w_1, const Point_2& app_target, const CfNT& r_2, const CfNT& s_2, const CfNT& t_2, const CfNT& u_2, const CfNT& v_2, const CfNT& w_2) : _r(r), _s(s), _t(t), _u(u), _v(v), _w(w), _info(X_MON_UNDEFINED), _hyper_P(NULL) { // Create the two auxiliary conic arcs. Conic_arc_2 aux_s_arc, aux_t_arc; aux_s_arc._r = r_1; aux_t_arc._r = r_2; aux_s_arc._s = s_1; aux_t_arc._s = s_2; aux_s_arc._t = t_1; aux_t_arc._t = t_2; aux_s_arc._u = u_1; aux_t_arc._u = u_2; aux_s_arc._v = v_1; aux_t_arc._v = v_2; aux_s_arc._w = w_1; aux_t_arc._w = w_2; // Compute the source and the target. const CfNT _zero = 0; int my_info; CoNT xs[4]; // The x coordinates of intersection points. int n_xs; // Number of x coordinates. CoNT ys[4]; // The y coordinates of intersection points. int n_ys; // Number of y coordinates. Point_2 ipts[4]; // The intersection points. int n_points; // Their number. CoNT dist, best_dist; int ind, best_ind; int k; if (CGAL_NTS compare(r, _zero) == EQUAL && CGAL_NTS compare(s, _zero) == EQUAL && CGAL_NTS compare(t, _zero) == EQUAL) { my_info = DEGREE_1; } else { my_info = DEGREE_2; } for (k = 0; k < 2; k++) { // Get the x- and y-coordinates of the intersection points with the // first (if k == 0) or the second (if k == 1) auxiliary curves. const Conic_arc_2& arc = (k == 0) ? aux_s_arc : aux_t_arc; int arc_info; if (CGAL_NTS compare(arc._r, _zero) == EQUAL && CGAL_NTS compare(arc._s, _zero) == EQUAL && CGAL_NTS compare(arc._t, _zero) == EQUAL) { arc_info = DEGREE_1; } else { arc_info = DEGREE_2; } n_xs = _x_coordinates_of_intersection_points (_r, _s, _t, _u, _v, _w, my_info, arc._r, arc._s, arc._t, arc._u, arc._v, arc._w, arc_info, xs); n_ys = _y_coordinates_of_intersection_points (_r, _s, _t, _u, _v, _w, my_info, arc._r, arc._s, arc._t, arc._u, arc._v, arc._w, arc_info, ys); // Perform the pairing process of the x and y coordinates. n_points = _pair_intersection_points (arc, xs, n_xs, ys, n_ys, ipts); if (n_points == 0) // In this case, the arc is invalid. return; // Choose the intersection point closest to the source // (or the target point). const Point_2& p = (k == 0) ? app_source : app_target; best_ind = -1; for (ind = 0; ind < n_points; ind++) { dist = CGAL::squared_distance (p, ipts[ind]); if (best_ind < 0 || CGAL_NTS compare(best_dist, dist) == LARGER) { best_dist = dist; best_ind = ind; } } // Set the source (or the target). if (k == 0) _source = ipts[best_ind]; else _target = ipts[best_ind]; } // Make sure that the source and the taget are not the same. if (_source == _target) // In this case, the arc is invalid. return; // Set the prescribed orientation. _orient = orient; // Set the arc properties (no need to compute the orientation). _set (false); } /*! * Destructor. */ virtual ~Conic_arc_2 () { if (_hyper_P) delete _hyper_P; _hyper_P = NULL; } /*! * Assignment operator. * \param arc The copied arc. */ const Self& operator= (const Self& arc) { if (this == &arc) return (*this); // Free any existing data. if (_hyper_P != NULL) delete _hyper_P; _hyper_P = NULL; // Copy the arc's attributes. _r = arc._r; _s = arc._s; _t = arc._t; _u = arc._u; _v = arc._v; _w = arc._w; _orient = arc._orient; _conic_id = arc._conic_id; _source = arc._source; _target = arc._target; _info = arc._info; // Duplicate the data for hyperbolic arcs. if (arc._hyper_P != NULL) _hyper_P = new Hyperbolic_arc_data (*(arc._hyper_P)); return (*this); } /*! * Get the coefficients of the underlying conic. */ const CfNT& r () const {return (_r);} const CfNT& s () const {return (_s);} const CfNT& t () const {return (_t);} const CfNT& u () const {return (_u);} const CfNT& v () const {return (_v);} const CfNT& w () const {return (_w);} /*! * Check if the arc is valid. * \return Whether the arc is valid. */ bool is_valid () const { return ((_info & IS_VALID) != 0); } /*! * Get the arc's source. * \return The source point. */ const Point_2& source () const { return (_source); } /*! * Get the arc's target. * \return The target point. */ const Point_2& target () const { return (_target); } /*! * Get the arc's orientation. * \return The orientation. */ Orientation orientation () const { return (_orient); } /*! * Check whether the two arcs are the same (have the same graph). * \param arc The compared arc. * \return (true) if the two arcs are equal. */ bool equals (const Self& arc) const { // Check if (*this) and arc are really the same object: if (this == &arc) return (true); // Check whether all arc features are the same. if (_orient == arc._orient) { // Same orientation: The base conics must be the same and the sources // and targets must be equal. return (this->has_same_base_conic(arc) && _source.equals(arc._source) && _target.equals(arc._target)); } else { // Opposite orientation: The base conics must be the same and the sources // and targets must be flipped. return (this->has_same_base_conic(arc) && _source.equals(arc._target) && _target.equals(arc._source)); } } /*! * Check whether the two arcs have the same base conic. * \param arc The compared arc. * \return (true) if the two base conics are the same (have the same graph). */ bool has_same_base_conic (const Self& arc) const { // In case the two arcs originiat from the same base conic: if (_conic_id == arc._conic_id) return (true); // In case both arcs are collinear, check if they have the same // supporting lines. if (_orient == CGAL::COLLINEAR && arc._orient == CGAL::COLLINEAR) { // Construct the two supporting lines and compare them. typename Alg_kernel::Line_2 l1 (_source, _target); typename Alg_kernel::Line_2 l2 (arc._source, arc._target); Alg_kernel ker; typename Alg_kernel::Equal_2 equal_f = ker.equal_2_object(); if (equal_f (l1, l2)) return (true); // Try to compare l1 with the opposite of l2. typename Alg_kernel::Line_2 op_l2 (arc._target, arc._source); return (equal_f (l1, op_l2)); } // Check whether arc equals (*this) up to a constant factor. const CfNT _zero = 0; CfNT factor1 = 1, factor2 = 1; if (CGAL_NTS compare(_r, _zero) != EQUAL) factor1 = _r; else if (CGAL_NTS compare(_s, _zero) != EQUAL) factor1 = _s; else if (CGAL_NTS compare(_t, _zero) != EQUAL) factor1 = _t; else if (CGAL_NTS compare(_u, _zero) != EQUAL) factor1 = _u; else if (CGAL_NTS compare(_v, _zero) != EQUAL) factor1 = _v; else if (CGAL_NTS compare(_w, _zero) != EQUAL) factor1 = _w; if (CGAL_NTS compare(arc._r, _zero) != EQUAL) factor2 = arc._r; else if (CGAL_NTS compare(arc._s, _zero) != EQUAL) factor2 = arc._s; else if (CGAL_NTS compare(arc._t, _zero) != EQUAL) factor2 = arc._t; else if (CGAL_NTS compare(arc._u, _zero) != EQUAL) factor2 = arc._u; else if (CGAL_NTS compare(arc._v, _zero) != EQUAL) factor2 = arc._v; else if (CGAL_NTS compare(arc._w, _zero) != EQUAL) factor2 = arc._w; return (CGAL_NTS compare (_r * factor2, arc._r * factor1) == EQUAL && CGAL_NTS compare (_s * factor2, arc._s * factor1) == EQUAL && CGAL_NTS compare (_t * factor2, arc._t * factor1) == EQUAL && CGAL_NTS compare (_u * factor2, arc._u * factor1) == EQUAL && CGAL_NTS compare (_v * factor2, arc._v * factor1) == EQUAL && CGAL_NTS compare (_w * factor2, arc._w * factor1) == EQUAL); } /*! * Check whether the arc is a full conic (i.e. a non-degenerate ellipse). * \return (true) if the arc represents a full conic. */ bool is_full_conic () const { return ((_info & FULL_CONIC) != 0); } /*! * Check whether the arc is a circular arc. * \return (true) if the underlying conic curve is a circle. */ bool is_circular() const { return (CGAL_NTS compare(_r, _s) == EQUAL && CGAL_NTS compare(_t, 0) == EQUAL); } /*! * Check whether the arc is a line segment. * \return (true) if the underlying conic curve is linear. */ bool is_segment () const { // Notice that the orientation is COLLINEAR if the underlying curve has // a degree 1, or when it is a line-pair. return (_orient == CGAL::COLLINEAR); } /*! * Check whether the arc is a vertical segment. * \return (true) if the arc is a vertical segment. */ bool is_vertical_segment () const { return ((_info & IS_VERTICAL_SEGMENT) != 0); } /*! * Get a bounding box for the conic arc. * \return The bounding box. */ Bbox_2 bbox () const { // Use the source and target to initialize the exterme points. bool source_left = CGAL::to_double(_source.x()) < CGAL::to_double(_target.x()); double x_min = source_left ? CGAL::to_double(_source.x()) : CGAL::to_double(_target.x()); double x_max = source_left ? CGAL::to_double(_target.x()) : CGAL::to_double(_source.x()); bool source_down = CGAL::to_double(_source.y()) < CGAL::to_double(_target.y()); double y_min = source_down ? CGAL::to_double(_source.y()) : CGAL::to_double(_target.y()); double y_max = source_down ? CGAL::to_double(_target.y()) : CGAL::to_double(_source.y()); // Go over the vertical tangency points and try to update the x-points. Point_2 tps[2]; int n_tps; int i; n_tps = vertical_tangency_points (tps); for (i = 0; i < n_tps; i++) { if (CGAL::to_double(tps[i].x()) < x_min) x_min = CGAL::to_double(tps[i].x()); if (CGAL::to_double(tps[i].x()) > x_max) x_max = CGAL::to_double(tps[i].x()); } // Go over the horizontal tangency points and try to update the y-points. n_tps = horizontal_tangency_points (tps); for (i = 0; i < n_tps; i++) { if (CGAL::to_double(tps[i].y()) < y_min) y_min = CGAL::to_double(tps[i].y()); if (CGAL::to_double(tps[i].y()) > y_max) y_max = CGAL::to_double(tps[i].y()); } // Return the resulting bounding box. return (Bbox_2 (x_min, y_min, x_max, y_max)); } /*! * Check whether the given point is on the conic arc. * \param q The query point. * \return (true) if the arc contains the point q. */ bool contains_point (const Point_2& q) const { // Check whether the conic contains the point (x,y). if (q.is_generating_conic_id(_conic_id) || _conic_has_on_boundary(q)) { // If the point is on the conic boundary, it is contained in the arc // either if the arc is a full conic, or if it is between the two // endpoints of the arc. return (is_full_conic() || _is_between_endpoints(q)); } // If the point is not on the conic boundary, it cannot be on the arc. return (false); } /*! * Calculate the vertical tangency points of the arc. * \param vpts The vertical tangency points -- should be allocated at the * size of 2). * \return The number of vertical tangency points. */ int vertical_tangency_points (Point_2* vpts) const { // No vertical tangency points for segments or for x-monotone curves: if ((_info & DEGREE_MASK) < 2 || (_info & X_MON_UNDEFINED) == X_MONOTONE) { return (0); } // Calculate the vertical tangency points of the conic. Point_2 ps[2]; int n; n = _conic_vertical_tangency_points (ps); // Return only the points that are contained in the arc interior. int m = 0; int i; for (i = 0; i < n; i++) { if (is_full_conic() || _is_strictly_between_endpoints(ps[i])) { vpts[m] = ps[i]; m++; } } // Return the number of vertical tangency points found. return (m); } /*! * Calculate the horizontal tangency points of the arc. * \param hpts The horizontal tangency points -- should be allocated at the * size of 2). * \return The number of horizontal tangency points. */ int horizontal_tangency_points (Point_2* hpts) const { // No horizontal tangency points for segments: if ((_info & DEGREE_MASK) < 2) return (0); // Calculate the horizontal tangency points of the conic. Point_2 ps[2]; int n; n = _conic_horizontal_tangency_points (ps); // Return only the points that are contained in the arc interior. int m = 0; int i; for (i = 0; i < n; i++) { if (is_full_conic() || _is_strictly_between_endpoints(ps[i])) { hpts[m] = ps[i]; m++; } } // Return the number of horizontal tangency points found. return (m); } /*! * Check whether the arc is x-monotone. * \return (true) if the arc is x-monotone. */ bool is_x_monotone() const { // If the answer is pre-calculated (and stored in the _info field), just // return it: int is_x_mon = _info & X_MON_UNDEFINED; if (is_x_mon == 0) return (false); else if (is_x_mon == X_MONOTONE) return (true); // Check the number of vertical tangency points. Point_2 vpts[2]; return (vertical_tangency_points(vpts) == 0); } /*! * Find all points on the arc with a given x-coordinate. * \param p A placeholder for the x-coordinate. * \param ps The point on the arc at x(p) -- should be allocated at the * size of 2. * \return The number of points found. */ int get_points_at_x (const Point_2& p, Point_2 *ps) const { // Get the y coordinates of the points on the conic. CoNT ys[2]; int n; n = _conic_get_y_coordinates (p.x(), ys); // Find all the points that are contained in the arc. int m = 0; int i; for (i = 0; i < n; i++) { ps[m] = Point_2 (p.x(), ys[i], _conic_id); if (is_full_conic() || _is_between_endpoints(ps[m])) m++; } // Return the number of points on the arc. return (m); } /*! * Find all points on the arc with a given y-coordinate. * \param p A placeholder for the y-coordinate. * \param ps The point on the arc at y(p) -- should be allocated at the * size of 2. * \return The number of points found. */ int get_points_at_y (const Point_2& p, Point_2 *ps) const { // Get the y coordinates of the points on the conic. CoNT xs[2]; int n; n = _conic_get_x_coordinates (p.y(), xs); // Find all the points that are contained in the arc. int m = 0; int i; for (i = 0; i < n; i++) { ps[m] = Point_2 (xs[i], p.y(), _conic_id); if (is_full_conic() || _is_between_endpoints(ps[m])) m++; } // Return the number of points on the arc. return (m); } /*! * Flip the conic arc: change its orientation and swap it source and target. * \return The flipped arc. */ Self flip () const { // Create a base conic with opposite orientation: Self opp_arc; opp_arc._r = -_r; opp_arc._s = -_s; opp_arc._t = -_t; opp_arc._u = -_u; opp_arc._v = -_v; opp_arc._w = -_w; if (_orient == CGAL::COUNTERCLOCKWISE) opp_arc._orient = CGAL::CLOCKWISE; else if (_orient == CGAL::CLOCKWISE) opp_arc._orient = CGAL::COUNTERCLOCKWISE; else opp_arc._orient = _orient; // Linear arc (a segment). opp_arc._conic_id = _conic_id; // Exchange the source and the target. opp_arc._source = _target; opp_arc._target = _source; opp_arc._info = _info; // These properties do not change. // Copy data for hyperbolic arcs. if (_hyper_P != NULL) opp_arc._hyper_P = new Hyperbolic_arc_data (*_hyper_P); else opp_arc._hyper_P = NULL; return (opp_arc); } /*! RWRW - Allow higher order derivatives. * Get the i'th order derivative by x of the conic at the point p=(x,y). * \param p The point where we derive. * \param i The order of the derivatives (either 1 or 2). * \param slope_numer The numerator of the slope. * \param slope_denom The denominator of the slope. * \pre i should be either 1 (first order) or 2 (second order). */ void derive_by_x_at (const Point_2& p, const int& i, CoNT& slope_numer, CoNT& slope_denom) const { // Make sure i is either 1 or 2. CGAL_precondition(i == 1 || i == 2); // Make sure p is contained in the arc. CGAL_precondition(contains_point(p)); // The derivative by x of the conic // C: {r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0} // at the point p=(x,y) is given by: // // 2r*x + t*y + u alpha // y' = - ---------------- = - ------- // 2s*y + t*x + v beta // const CoNT _two = 2; const CoNT sl_numer = _two*CoNT(_r)*p.x() + CoNT(_t)*p.y() + CoNT(_u); const CoNT sl_denom = _two*CoNT(_s)*p.y() + CoNT(_t)*p.x() + CoNT(_v); if (i == 1) { if (CGAL_NTS compare (sl_denom, 0) == LARGER) { slope_numer = -sl_numer; slope_denom = sl_denom; } else { slope_numer = sl_numer; slope_denom = -sl_denom; } return; } // The second derivative is given by: // // s*alpha^2 - t*alpha*beta + r*beta^2 // y'' = -2 ------------------------------------- // beta^3 // const CoNT sl2_numer = CoNT(_s) * sl_numer * sl_numer - CoNT(_t) * sl_numer * sl_denom + CoNT(_r) * sl_denom * sl_denom; const CoNT sl2_denom = sl_denom * sl_denom * sl_denom; if (CGAL_NTS compare(sl_denom, 0) == LARGER) // So sl2_denom > 0 as well. { slope_numer = -_two *sl2_numer; slope_denom = sl2_denom; } else { slope_numer = _two *sl2_numer; slope_denom = -sl2_denom; } return; } /*! RWRW - Allow higher order derivatives. * Get the i'th order derivative by y of the conic at the point p=(x,y). * \param p The point where we derive. * \param i The order of the derivatives (either 1 or 2). * \param slope_numer The numerator of the slope. * \param slope_denom The denominator of the slope. * \pre i should be either 1 (first order) or 2 (second order). */ void derive_by_y_at (const Point_2& p, const int& i, CoNT& slope_numer, CoNT& slope_denom) const { // Make sure i is either 1 or 2. CGAL_precondition(i == 1 || i == 2); // Make sure p is contained in the arc. CGAL_precondition(contains_point(p)); // The derivative by y of the conic // C: {r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0} // at the point p=(x,y) is given by: // // 2s*y + t*x + v alpha // x' = - ---------------- = ------- // 2r*x + t*y + u beta // const CoNT _two = 2; const CoNT sl_numer = _two*CoNT(_s)*p.y() + CoNT(_t)*p.x() + CoNT(_v); const CoNT sl_denom = _two*CoNT(_r)*p.x() + CoNT(_t)*p.y() + CoNT(_u); if (i == 1) { if (CGAL_NTS compare(sl_denom, 0) == LARGER) { slope_numer = -sl_numer; slope_denom = sl_denom; } else { slope_numer = sl_numer; slope_denom = -sl_denom; } return; } // The second derivative is given by: // // r*alpha^2 - t*alpha*beta + s*beta^2 // x'' = -2 ------------------------------------- // beta^3 // const CoNT sl2_numer = CoNT(_r) * sl_numer * sl_numer - CoNT(_t) * sl_numer * sl_denom + CoNT(_s) * sl_denom * sl_denom; const CoNT sl2_denom = sl_denom * sl_denom * sl_denom; if (CGAL_NTS compare(sl_denom, 0) == LARGER) // So sl2_denom > 0 as well. { slope_numer = -_two *sl2_numer; slope_denom = sl2_denom; } else { slope_numer = _two *sl2_numer; slope_denom = -sl2_denom; } return; } /*! * Calculate the intersection points with the given arc. * \param arc The arc to intersect. * \param ps The output intersection points. * This area must be allocated at the size of 4. * \param inter_list_P For caching purposes. * \pre The two arcs do not lie on the same conic. * \return The number of the actual intersection points. */ int intersections_with (const Self& arc, Point_2* ps #ifdef CGAL_CONIC_ARC_USE_CACHING ,std::list *inter_list_P = NULL #endif ) const { // The two conics must not be the same. CGAL_precondition (! has_same_base_conic(arc)); // First make sure that (this->degree) is >= than (arc.degree). if ((arc._info & DEGREE_MASK) == DEGREE_2 && (_info & DEGREE_MASK) == DEGREE_1) { return (arc.intersections_with (*this, ps #ifdef CGAL_CONIC_ARC_USE_CACHING ,inter_list_P #endif )); } // Deal with vertical segments. if (arc.is_vertical_segment()) { if (is_vertical_segment()) { // Two vertical segments intersect only if they overlap. return (0); } // Find all points on our arc that have the same x coordinate as // the other vertical segment. int n_ys; Point_2 xps[2]; int j; int n = 0; n_ys = get_points_at_x (arc._source, xps); for (j = 0; j < n_ys; j++) { // Store this point only if it is contained on the other arc. if (arc.contains_point(xps[j])) { ps[n] = Point_2 (xps[j].x(), xps[j].y(), _conic_id, arc._conic_id); n++; } } return (n); } else if (is_vertical_segment()) { // Find all points on the other arc that have the same x coordinate as // our vertical segment. int n_ys; Point_2 xps[2]; int j; int n = 0; n_ys = arc.get_points_at_x (_source, xps); for (j = 0; j < n_ys; j++) { // Store this point only if it is contained on the other arc. if (contains_point(xps[j])) { ps[n] = Point_2 (xps[j].x(), xps[j].y(), _conic_id, arc._conic_id); n++; } } return (n); } // Find all intersection points between the two base conic curves. Point_2 ipts[4]; // The intersection points. int n_points = 0; // Their number. bool calc_points = true; #ifdef CGAL_CONIC_ARC_USE_CACHING Intersections inter; int k; if (inter_list_P != NULL && (_info & DEGREE_MASK) != DEGREE_1) { int id1 = _conic_id; int id2 = arc._conic_id; inter.id1 = id1 < id2 ? id1 : id2; inter.id2 = id1 > id2 ? id1 : id2; typename std::list::iterator iter; for (iter = inter_list_P->begin(); iter != inter_list_P->end(); iter++) { if ((*iter).id1 == inter.id1 && (*iter).id2 == inter.id2) { n_points = (*iter).n_points; for (k = 0; k < n_points; k++) ipts[k] = (*iter).ps[k]; calc_points = false; } } } #endif // (of ifdef CGAL_CONIC_ARC_USE_CACHING) if (calc_points) { // Find all potential x coordinates and y coordinates of the // intersection points. const CfNT _zero = 0; CoNT xs[4]; // The x coordinates of intersection points. int n_xs; // Number of x coordinates. CoNT ys[4]; // The y coordinates of intersection points. int n_ys; // Number of y coordinates. n_xs = _x_coordinates_of_intersection_points (_r, _s, _t, _u, _v, _w, _info, arc._r, arc._s, arc._t, arc._u, arc._v, arc._w, arc._info, xs); n_ys = _y_coordinates_of_intersection_points (_r, _s, _t, _u, _v, _w, _info, arc._r, arc._s, arc._t, arc._u, arc._v, arc._w, arc._info, ys); // Perform the pairing process of the x and y coordinates. n_points = _pair_intersection_points (arc, xs, n_xs, ys, n_ys, ipts); #ifdef CGAL_CONIC_ARC_USE_CACHING if (inter_list_P != NULL && (_info & DEGREE_MASK) != DEGREE_1) { inter.n_points = n_points; for (k = 0; k < n_points; k++) inter.ps[k] = ipts[k]; inter_list_P->push_front(inter); } #endif // (of ifdef CGAL_CONIC_ARC_USE_CACHING) } // Go over all intersection points between the two base conics and return // only those located on both arcs. int n = 0; int i; for (i = 0; i < n_points; i++) { // Check for an exact point. if (contains_point(ipts[i]) && arc.contains_point(ipts[i])) { ps[n] = ipts[i]; n++; } } return (n); } /*! * Check whether the two arcs overlap, and if so - compute the overlapping * portions. * \param arc The other conic arc. * \param ovlp_arc The output overlapping sub-arc. * This area should be allocated to the size of 2. * \return The number of overlapping sub-arcs. */ int overlaps (const Self& arc, Self* ovlp_arcs) const { // Two arcs can overlap only if their base conics are identical. if (! this->has_same_base_conic (arc)) return (0); // If the two arcs are completely equal, return one of them as the // overlapping arc. int orient1 = _orient; int orient2 = arc._orient; bool same_or = (orient1 == orient2); bool identical = false; if (orient1 == 0) { // That mean both arcs are really segments, so they are identical // if their endpoints are the same. if ((_source.equals(arc._source) && _target.equals(arc._target)) || (_source.equals(arc._target) && _target.equals(arc._source))) identical = true; } else { // If those are really curves of degree 2, than the points curves // are identical only if their source and target are the same and the // orientation is the same, or vice-versa if the orientation is opposite. if ((same_or && _source.equals(arc._source) && _target.equals(arc._target)) || (!same_or && _source.equals(arc._target) && _target.equals(arc._source))) identical = true; } if (identical) { ovlp_arcs[0] = arc; return (1); } // In case one of the arcs is a full conic, return the whole other conic. if (arc.is_full_conic()) { ovlp_arcs[0] = *this; return (1); } else if (is_full_conic()) { ovlp_arcs[0] = arc; return (1); } // In case the other arc has an opposite orientation, switch its source // and target (notice that in case of segments, when the orientation is 0, // we make sure the two segments have the same direction). const Point_2 *arc_sourceP; const Point_2 *arc_targetP; if (orient1 == 0) orient1 = (_source.compare_lex_xy(_target) == LARGER) ? 1 : -1; if (orient2 == 0) orient2 = (arc._source.compare_lex_xy(arc._target) == LARGER) ? 1 : -1; // Check the overlap cases: if (orient1 == orient2) { arc_sourceP = &(arc._source); arc_targetP = &(arc._target); } else { arc_sourceP = &(arc._target); arc_targetP = &(arc._source); } if (_is_strictly_between_endpoints(*arc_sourceP)) { if (_is_strictly_between_endpoints(*arc_targetP)) { // Check the next special case (when there are 2 overlapping arcs): if (arc._is_strictly_between_endpoints(_source) && arc._is_strictly_between_endpoints(_target)) { ovlp_arcs[0] = Self(*this,_source, *arc_targetP); ovlp_arcs[1] = Self(*this, *arc_sourceP, _target); return (2); } // Case 1 - *this: +-----------> // arc: +=====> ovlp_arcs[0] = Self(*this, *arc_sourceP,*arc_targetP); return (1); } else { // Case 2 - *this: +-----------> // arc: +=====> ovlp_arcs[0] = Self(*this, *arc_sourceP, _target); return (1); } } else if (_is_strictly_between_endpoints(*arc_targetP)) { // Case 3 - *this: +-----------> // arc: +=====> ovlp_arcs[0] = Self(*this, _source, *arc_targetP); return (1); } else if (arc._is_between_endpoints(_source) && arc._is_between_endpoints(_target) && (arc._is_strictly_between_endpoints(_source) || arc._is_strictly_between_endpoints(_target))) { // Case 4 - *this: +-----------> // arc: +================> ovlp_arcs[0] = *this; return (1); } // If we reached here, there are no overlaps: return (0); } /*! * Check whether the arc is facing up or facing down. * \return LARGER if the arcs is facing up, or SMALLER if it is facing down. * If the arc is a line segment, EQUAL is returned. */ Comparison_result facing () const { if ((_info & FACING_MASK) == 0) return (EQUAL); else if ((_info & FACING_UP) != 0) return (LARGER); else return (SMALLER); } protected: /*! * Set the properties of a conic arc (for the usage of the constructors). * \param comp_orient Should we compute the orientation of the given curve. */ void _set (const bool& comp_orient) { // Initialize the information bits. _info = X_MON_UNDEFINED; // Set the orientation of conic arc. typename Cartesian::Conic_2 temp_conic (_r, _s, _t, _u, _v, _w); if (comp_orient) { // Compute the orientation. _orient = temp_conic.orientation(); } else if (_orient != temp_conic.orientation()) { // If the computed orientation does not match the current value, // multiply all conic coefficients by -1 (negate the curve). _r = - _r; _s = - _s; _t = - _t; _u = - _u; _v = - _v; _w = - _w; } // Find the degree and make sure the conic is not invalid. const CfNT _zero = 0; int deg; if (CGAL_NTS compare(_r, _zero) != EQUAL || CGAL_NTS compare(_s, _zero) != EQUAL || CGAL_NTS compare(_t, _zero) != EQUAL) { // In case one of the coefficients of x^2,y^2 or xy is not zero, the // degree is 2. deg = 2; } else if (CGAL_NTS compare(_u, _zero) != EQUAL || CGAL_NTS compare(_v, _zero) != EQUAL) { // In case of a line - the degree is 1. deg = 1; _orient = CGAL::COLLINEAR; } else { // Empty conic! deg = 0; } CGAL_precondition(deg > 0); if (deg == 0) // Invalid arc: return; // Store the degree information. _info = _info | deg; // In case the base conic is a hyperbola, build the hyperbolic data // (this happens when (4rs - t^2) < 0). const Comparison_result det = (CGAL_NTS compare(4*_r*_s, _t*_t)); if (deg == 2 && det == SMALLER && _orient != CGAL::COLLINEAR) _build_hyperbolic_arc_data (); else _hyper_P = NULL; // In case of a non-degenerate parabola or a hyperbola, make sure // the arc is not infinite. if (deg == 2 && det != LARGER && _orient != CGAL::COLLINEAR) { const CoNT _two = 2; const Point_2 p_mid ((_source.x() + _target.x()) / _two, (_source.y() + _target.y()) / _two); Point_2 ps[2]; bool finite_at_x = (get_points_at_x(p_mid, ps) > 0); bool finite_at_y = (get_points_at_y(p_mid, ps) > 0); if (! finite_at_x || ! finite_at_y) // The arc is invalid: return; } // If we reached here, the conic arc is legal: Get a new id for the conic. _conic_id = _get_new_conic_id(); _source.set_generating_conics (_conic_id); _target.set_generating_conics (_conic_id); // Check whether the conic is x-monotone. if (is_x_monotone()) { _info = (_info & ~X_MON_UNDEFINED) | X_MONOTONE; // In case the conic is od degree 2, determine where is it facing. if (_orient != CGAL::COLLINEAR) { if (! _set_facing()) // Invalid arc: return; } } else { _info = (_info & ~X_MON_UNDEFINED); } // Check if the arc is a vertical segment. if (_orient == CGAL::COLLINEAR) { // A vertical segment is contained in the degenerate conic: u*x + w = 0, // but it can also be a part of a line-pair -- in this case we just check // that the x-coordinates of the source and the target are the same. const CfNT _zero = 0; if (((_info & DEGREE_MASK) == 1 && CGAL_NTS compare(_v, _zero) == EQUAL) || _source.compare_x (_target) == EQUAL) { _info = _info | IS_VERTICAL_SEGMENT; } } // Mark that the arc is valid. _info = (_info | IS_VALID); return; } /*! * Set the properties of a conic arc that is really a full curve * (that is, an ellipse). * \param comp_orient Should we compute the orientation of the given curve. */ void _set_full (const bool& comp_orient) { // Initialize the information bits. _info = 0; // Set the orientation of conic arc. typename Cartesian::Conic_2 temp_conic (_r, _s, _t, _u, _v, _w); if (comp_orient) { // Compute the orientation. _orient = temp_conic.orientation(); } else if (_orient != temp_conic.orientation()) { // If the computed orientation does not match the current value, // multiply all conic coefficients by -1 (negate the curve). _r = - _r; _s = - _s; _t = - _t; _u = - _u; _v = - _v; _w = - _w; } // Set the information: a full conic, which is obvoiusly not x-monotone. _info = DEGREE_2 | FULL_CONIC; _hyper_P = NULL; // Assign one of the vertical tangency points as both the source and // the target of the conic arc. Point_2 vpts[2]; int n_vpts; n_vpts = _conic_vertical_tangency_points (vpts); CGAL_assertion(n_vpts > 0); CGAL_assertion(_conic_has_on_boundary(vpts[0])); // If we reached here, the conic arc is legal: Get a new id for the conic. _conic_id = _get_new_conic_id(); _source = _target = vpts[0]; _source.set_generating_conics (_conic_id); _target.set_generating_conics (_conic_id); // Mark that the arc is valid. _info = (_info | IS_VALID); return; } /*! * Build the data for hyperbolic arc, contaning the characterization of the * hyperbolic branch the arc is placed on. */ void _build_hyperbolic_arc_data () { // Let phi be the rotation angle of the conic from its canonic form. // We can write: // // t // sin(2*phi) = ----------------------- // sqrt((r - s)^2 + t^2) // // r - s // cos(2*phi) = ----------------------- // sqrt((r - s)^2 + t^2) // const int or_fact = (_orient == CGAL::CLOCKWISE) ? -1 : 1; const CoNT r = or_fact * CoNT(_r); const CoNT s = or_fact * CoNT(_s); const CoNT t = or_fact * CoNT(_t); const CoNT cos_2phi = (r - s) / CGAL::sqrt((r-s)*(r-s) + t*t); const CoNT _zero = 0; const CoNT _one = 1; const CoNT _two = 2; CoNT sin_phi; CoNT cos_phi; // Calculate sin(phi) and cos(phi) according to the half-angle formulae: // // sin(phi)^2 = 0.5 * (1 - cos(2*phi)) // cos(phi)^2 = 0.5 * (1 + cos(2*phi)) if (CGAL_NTS compare (t, _zero) == EQUAL) { // sin(2*phi) == 0, so phi = 0 or phi = PI/2 if (CGAL_NTS compare (cos_2phi, _zero) == LARGER) { // phi = 0. sin_phi = _zero; cos_phi = _one; } else { // phi = PI. sin_phi = _zero; cos_phi = -_one; } } else if (CGAL_NTS compare (t, _zero) == LARGER) { // sin(2*phi) > 0 so 0 < phi < PI/2. sin_phi = CGAL::sqrt((_one + cos_2phi) / _two); cos_phi = CGAL::sqrt((_one - cos_2phi) / _two); } else { // sin(2*phi) < 0 so PI/2 < phi < PI. sin_phi = CGAL::sqrt((_one + cos_2phi) / _two); cos_phi = -CGAL::sqrt((_one - cos_2phi) / _two); } // Calculate the center (x0, y0) of the conic, given by the formulae: // // t*v - 2*s*u t*u - 2*r*v // x0 = ------------- , y0 = ------------- // 4*r*s - t^2 4*r*s - t^2 // // The denominator (4*r*s - t^2) must be negative for hyperbolas. const CoNT u = or_fact * CoNT(_u); const CoNT v = or_fact * CoNT(_v); const CoNT det = 4*r*s - t*t; CoNT x0, y0; CGAL_assertion (CGAL_NTS compare(det, _zero) == SMALLER); x0 = (t*v - _two*s*u) / det; y0 = (t*u - _two*r*v) / det; // The axis separating the two branches of the hyperbola is now given by: // // cos(phi)*x + sin(phi)*y - (cos(phi)*x0 + sin(phi)*y0) = 0 // _hyper_P = new Hyperbolic_arc_data; _hyper_P->a = cos_phi; _hyper_P->b = sin_phi; _hyper_P->c = - (cos_phi*x0 + sin_phi*y0); // Make sure that the two endpoints are located on the same branch // of the hyperbola. _hyper_P->side = _hyperbolic_arc_side(_source); CGAL_assertion (_hyper_P->side = _hyperbolic_arc_side(_target)); return; } /*! * Find on which branch of the hyperbola is the given point located. * The point is assumed to be on the hyperbola. * \param p The query point. * \return The branch ID (either -1 or 1). */ int _hyperbolic_arc_side (const Point_2& p) const { if (_hyper_P == NULL) return (0); CoNT val; val = _hyper_P->a*p.x() + _hyper_P->b*p.y() + _hyper_P->c; return ((CGAL_NTS compare(val, 0) == LARGER) ? 1 : -1); } /*! * Check whether the given point is between the source and the target. * The point is assumed to be on the conic's boundary. * \param p The query point. * \return (true) if the point is between the two endpoints, * (false) if it is not. */ bool _is_between_endpoints (const Point_2& p) const { if (p.equals(_source) || p.equals(_target)) return (true); else return (_is_strictly_between_endpoints(p)); } /*! * Check whether the given point is strictly between the source and the * target (but not any of them). * The point is assumed to be on the conic's boundary. * \param p The query point. * \return (true) if the point is strictly between the two endpoints, * (false) if it is not. */ bool _is_strictly_between_endpoints (const Point_2& p) const { // In case this is a full conic, any point on its boundary is between // its end points. if (is_full_conic()) return (true); // In case of a hyperbolic arc, make sure the point is located on the // same branch as the arc. if (_hyper_P != NULL) { if (_hyperbolic_arc_side(p) != _hyper_P->side) return (false); } // In case of a line-pair (curve of degree 2 with a collinear orientation) // first make sure that p is collinear with the source and target. if ((_info & DEGREE_MASK) == DEGREE_2 && _orient == CGAL::COLLINEAR) { static Alg_kernel ker; typename Alg_kernel::Orientation_2 orient_f = ker.orientation_2_object(); if (orient_f(_source, p, _target) != COLLINEAR) return (false); } // Act according to the degree and orientation of the conic. if ((_info & DEGREE_MASK) == DEGREE_1 || _orient == CGAL::COLLINEAR) { // The underlying curve is a straight line (or a line-pair). if (is_vertical_segment()) { // In case of a vertical segment - just check whether the y coordinate // of p is between those of the source's and of the target's. Comparison_result r1 = compare_y (p, _source); Comparison_result r2 = compare_y (p, _target); return ((r1 == SMALLER && r2 == LARGER) || (r1 == LARGER && r2 == SMALLER)); } else { // Otherwise, since the segment is x-monotone, just check whether the // x coordinate of p is between those of the source's and of the // target's. Comparison_result r1 = compare_x (p, _source); Comparison_result r2 = compare_x (p, _target); return ((r1 == SMALLER && r2 == LARGER) || (r1 == LARGER && r2 == SMALLER)); } } else { // In case of a conic of degree 2, make a decision based on the conic's // orientation and whether (source,p,target) is a right or a left turn. static Alg_kernel ker; typename Alg_kernel::Orientation_2 orient_f = ker.orientation_2_object(); if (_orient == CGAL::COUNTERCLOCKWISE) return (orient_f(_source, p, _target) == LEFT_TURN); else return (orient_f(_source, p, _target) == RIGHT_TURN); } } /*! * Check whether the underlying conic contains a point on its boundary. * \param q The query point. * \return (true) if the underlying conic contains the point on its boundary. */ bool _conic_has_on_boundary (const Point_2& q) const { return (_conic_has_on_boundary (q.x(), q.y())); } /*! * Check whether the underlying conic contains (x,y) on its boundary. * \param x The x coordinate of the query point. * \param y The y coordinate of the query point. * \return (true) if the underlying conic contains the point on its boundary. */ bool _conic_has_on_boundary (const CoNT& x, const CoNT& y) const { const CoNT _zero = 0; CoNT val; // The point must satisfy: r*x^2 + s*y^2 + t*xy + u*x + v*y + w = 0. val = (CoNT(_r)*x + CoNT(_t)*y + CoNT(_u))*x + (CoNT(_s)*y + CoNT(_v))*y + CoNT(_w); return (CGAL_NTS compare (val, _zero) == EQUAL); } /*! * Find the y coordinates of the underlying conic at a given x coordinate. * \param x The x coordinate. * \param ys The output y coordinates. * This area must be allocated at the size of 2. * \return The number of y coordinates computed (either 0, 1 or 2). */ int _conic_get_y_coordinates (const CoNT& x, CoNT *ys) const { // Solve the quadratic equation for a given x and find the y values: // s*y^2 + (t*x + v)*y + (r*x^2 + u*x + w) = 0 return (solve_quadratic_eq (CoNT(_s), CoNT(_t)*x + CoNT(_v), (CoNT(_r)*x + CoNT(_u))*x + CoNT(_w), ys)); } /*! * Find the x coordinates of the underlying conic at a given y coordinate. * \param y The y coordinate. * \param xs The output x coordinates. * This area must be allocated at the size of 2. * \return The number of x coordinates computed (either 0, 1 or 2). */ int _conic_get_x_coordinates (const CoNT& y, CoNT *xs) const { // Solve the quadratic equation for a given y and find the x values: // r*x^2 + (t*y + u)*x + (s*y^2 + v*y + w) = 0 return (solve_quadratic_eq (CoNT(_r), CoNT(_t)*y + CoNT(_u), (CoNT(_s)*y + CoNT(_v))*y + CoNT(_w), xs)); } /*! * Find the vertical tangency points of the undelying conic. * \param ps The output points of vertical tangency. * This area must be allocated at the size of 2. * \return The number of vertical tangency points. */ int _conic_vertical_tangency_points (Point_2* ps) const { const CfNT _zero = 0; // In case the base conic is of degree 1 (and not 2), the arc has no // vertical tangency points. if ((_info & DEGREE_MASK) == DEGREE_1 || CGAL_NTS compare(_s,_zero) == EQUAL) { return (0); } // We are interested in the x coordinates where the quadratic equation: // s*y^2 + (t*x + v)*y + (r*x^2 + u*x + w) = 0 // has a single solution (obviously if s = 0, there are no such points). // We therefore demand that the discriminant of this equation is zero: // (t*x + v)^2 - 4*s*(r*x^2 + u*x + w) = 0 const CfNT _two = 2; const CfNT _four = 4; CoNT xs[2]; int n_xs; n_xs = solve_quadratic_eq (_t*_t - _four*_r*_s, _two*_t*_v - _four*_s*_u, _v*_v - _four*_s*_w, xs); // Find the y-coordinates of the vertical tangency points. CoNT ys[2]; int n_ys; if (CGAL_NTS compare(_t, _zero) == EQUAL) { // The two vertical tangency points have the same y coordinate: ys[0] = CoNT(-_v) / CoNT(_two*_s); n_ys = 1; } else { n_ys = solve_quadratic_eq (_four*_r*_s*_s - _s*_t*_t, _four*_r*_s*_v - _two*_s*_t*_u, _r*_v*_v - _t*_u*_v + _t*_t*_w, ys); } // Pair the x and y coordinates and obtain the vertical tangency points. int n = 0; int i, j; for (i = 0; i < n_xs; i++) { if (n_ys == 1) { ps[n] = Point_2 (xs[i], ys[0], _conic_id); n++; } else { for (j = 0; j < n_ys; j++) { if (CGAL_NTS compare (ys[j], -(CoNT(_t)*xs[i] + CoNT(_v)) / CoNT(_two*_s)) == EQUAL) { ps[n] = Point_2 (xs[i], ys[j], _conic_id); n++; break; } } } } return (n); } /*! * Find the horizontal tangency points of the undelying conic. * \param ps The output points of horizontal tangency. * This area must be allocated at the size of 2. * \return The number of horizontal tangency points. */ int _conic_horizontal_tangency_points (Point_2* ps) const { const CfNT _zero = 0; // In case the base conic is of degree 1 (and not 2), the arc has no // vertical tangency points. if ((_info & DEGREE_MASK) == DEGREE_1 || CGAL_NTS compare(_r, _zero) == EQUAL) { return (0); } // We are interested in the y coordinates were the quadratic equation: // r*x^2 + (t*y + u)*x + (s*y^2 + v*y + w) = 0 // has a single solution (obviously if r = 0, there are no such points). // We therefore demand that the discriminant of this equation is zero: // (t*y + u)^2 - 4*r*(s*y^2 + v*y + w) = 0 const CfNT _two = 2; const CfNT _four = 4; int n; CoNT ys[2]; n = solve_quadratic_eq (_t*_t - _four*_r*_s, _two*_t*_u - _four*_r*_v, _u*_u - _four*_r*_w, ys); // Compute the x coordinates and construct the horizontal tangency points. CoNT x; int i; for (i = 0; i < n; i++) { // Having computed y, x is the simgle solution to the quadratic equation // above, and since its discriminant is 0, x is simply given by: x = -(CoNT(_t)*ys[i] + CoNT(_u)) / CoNT(_two*_r); ps[i] = Point_2 (x, ys[i], _conic_id); } return (n); } /*! * Set the facing information for the (x-monotone) arc: It is facing up if * it lies above the line segments that connect its two endpoints, and facing * down if it lies below it. */ bool _set_facing () { // Check whether the arc (which is x-monotone of degree 2) lies above or // below the segement that contects its two end-points (x1,y1) and (x2,y2). // To do that, we find the y coordinate of a point on the arc whose x // coordinate is (x1+x2)/2 and compare it to (y1+y2)/2. const CoNT _two = 2; const CoNT x_mid = (_source.x() + _target.x()) / _two; const CoNT y_mid = (_source.y() + _target.y()) / _two; Point_2 p_mid (x_mid, y_mid); Point_2 ps[2]; int n_ps; n_ps = get_points_at_x (p_mid, ps); if (n_ps != 1) return (false); Comparison_result res = ps[0].compare_y (p_mid); if (res == LARGER) { // The arc is above the connecting segment, so it is facing upwards. _info = _info | FACING_UP; } else if (res == SMALLER) { // The arc is below the connecting segment, so it is facing downwards. _info = _info | FACING_DOWN; } if (res == EQUAL) return (false); return (true); } /*! * Compute the x-coordinates of the intersection points of the two conics: * C1: r1*x^2 + s1*y^2 + t1*xy + u1*x + v1*y + w1 = 0, * and: * C2: r2*x^2 + s2*y^2 + t2*xy + u2*x + v2*y + w2 = 0. * \param xs The output x-coordinates (must be allocated to the size of 4). * \return The number of distinct x-coordinates. */ int _x_coordinates_of_intersection_points (const CfNT& r1, const CfNT& s1, const CfNT& t1, const CfNT& u1, const CfNT& v1, const CfNT& w1, const int& info1, const CfNT& r2, const CfNT& s2, const CfNT& t2, const CfNT& u2, const CfNT& v2, const CfNT& w2, const int& info2, CoNT* xs) const { if ((info1 & DEGREE_MASK) == DEGREE_2 && (info2 & DEGREE_MASK) == DEGREE_1) { // If necessary, swap roles between the two curves, so that the first // curve always has the minimal degree. return (_x_coordinates_of_intersection_points (r2, s2, t2, u2, v2, w2, info2, r1, s1, t1, u1, v1, w1, info1, xs)); } const CfNT _zero = 0; const CfNT _two = 2; CfNT c[5]; // Check the case that the first conic has no quadratic coefficients. if ((info1 & DEGREE_MASK) == DEGREE_1) { if (CGAL_NTS compare(v1, _zero) == EQUAL) { // The first line is u1*x + w1 = 0, therefore: xs[0] = CoNT(-w1) / CoNT(u1); return (1); } // We can write the first curve as: y = (u1*x + w1) / v1. if ((info2 & DEGREE_MASK) == DEGREE_1) { // The second curve is also a line. We therefore get the linear // equation c[1]*x + c[0] = 0: c[1] = v1*u2 - u1*v2; c[0] = v1*w2 - w1*v2; if (CGAL_NTS compare(c[1], _zero) == EQUAL) return (0); xs[0] = CoNT(-c[0]) / CoNT(c[1]); return (1); } // We substitute this expression into the equation of the second // conic, and get the quadratic equation c[2]*x^2 + c[1]*x + c[0] = 0: c[2] = u1*u1*s2 - u1*v1*t2 + v1*v1*r2; c[1] = _two*u1*w1*s2 - u1*v1*v2 - v1*w1*t2 + v1*v1*u2; c[0] = w1*w1*s2 - v1*w1*v2 + v1*v1*w2; return (solve_quadratic_eq (c[2], c[1], c[0], xs)); } // At this stage, both curves have degree 2. We obtain a qaurtic polynomial // whose roots are the x-coordinates of the intersection points. if (CGAL_NTS compare(s1, _zero) == EQUAL && CGAL_NTS compare(s2, _zero) == EQUAL) { // If both s1 and s2 are zero, we can write the two curves as: // C1: (t1*x + v1)*y + (r1*x^2 + u1*x + w1) = 0 // C2: (t2*x + v2)*y + (r2*x^2 + u2*x + w2) = 0 // By writing the resultant of these two polynomials we get: c[4] = _zero; c[3] = r2*t1 - r1*t2; c[2] = t1*u2 - t2*u1 + r2*v1 - r1*v2; c[1] = t1*w2 - t2*w1 + u2*v1 - u1*v2; c[0] = v1*w2 - v2*w1; } else { // We can write the two curves as: // C1: (s1)*y^2 + (t1*x + v1)*y + (r1*x^2 + u1*x + w1) = 0 // C2: (s2)*y^2 + (t2*x + v2)*y + (r2*x^2 + u2*x + w2) = 0 // By writing the resultant of these two polynomials we get: c[4] = -_two*s1*s2*r1*r2 + s1*t2*t2*r1 - s1*t2*t1*r2 + s1*s1*r2*r2 - s2*t1*r1*t2 + s2*t1*t1*r2 + s2*s2*r1*r1; c[3] = -t2*r1*v1*s2 - u2*t1*t2*s1 - v2*r1*t1*s2 - r2*t1*v2*s1 - _two*s1*s2*r1*u2 - t2*u1*t1*s2 + u2*t1*t1*s2 - r2*v1*t2*s1 + u1*t2*t2*s1 + _two*v2*r1*t2*s1 + _two*u2*r2*s1*s1 + _two*r2*v1*t1*s2 + _two*u1*r1*s2*s2 - _two*s1*s2*u1*r2; c[2] = -r2*v1*v2*s1 + u2*u2*s1*s1 + _two*w2*r2*s1*s1 + _two*u2*v1*t1*s2 - u2*v1*t2*s1 + w2*t1*t1*s2 - _two*s1*s2*u1*u2 - w2*t1*t2*s1 + v2*v2*r1*s1 + u1*u1*s2*s2 - v2*r1*v1*s2 + _two*w1*r1*s2*s2 - u2*t1*v2*s1 - t2*u1*v1*s2 - _two*s1*s2*r1*w2 - _two*s1*s2*w1*r2 + r2*v1*v1*s2 + w1*t2*t2*s1 - v2*u1*t1*s2 - t2*w1*t1*s2 + _two*v2*u1*t2*s1; c[1] = _two*w2*u2*s1*s1 + _two*w2*v1*t1*s2 - w2*v1*t2*s1 + _two*v2*w1*t2*s1 + _two*w1*u1*s2*s2 - v2*u1*v1*s2 - _two*s1*s2*u1*w2 - v2*w1*t1*s2 + u2*v1*v1*s2 - t2*w1*v1*s2 - w2*t1*v2*s1 + v2*v2*u1*s1 - u2*v1*v2*s1 - _two*s1*s2*w1*u2; c[0] = s2*v1*v1*w2 - s1*v2*v1*w2 - s2*v1*w1*v2 + s2*s2*w1*w1 - _two*s1*s2*w1*w2 + s1*w1*v2*v2 + s1*s1*w2*w2; } // Now solve the quartic equation: // c[4]*x^4 + c[3]*x^3 + c[2]*x^2 + c[1]*x + c[0] = 0. return (solve_quartic_eq (c[4], c[3], c[2], c[1], c[0], xs)); } /*! * Compute the y-coordinates of the intersection points of the two conics: * C1: r1*x^2 + s1*y^2 + t1*xy + u1*x + v1*y + w1 = 0, * and: * C2: r2*x^2 + s2*y^2 + t2*xy + u2*x + v2*y + w2 = 0. * \param ys The output y-coordinates (must be allocated to the size of 4). * \return The number of distinct y-coordinates. */ int _y_coordinates_of_intersection_points (const CfNT& r1, const CfNT& s1, const CfNT& t1, const CfNT& u1, const CfNT& v1, const CfNT& w1, const int& info1, const CfNT& r2, const CfNT& s2, const CfNT& t2, const CfNT& u2, const CfNT& v2, const CfNT& w2, const int& info2, CoNT* ys) const { // Swap roles between x and y and compute the x-coordinates. return (_x_coordinates_of_intersection_points (s1, r1, t1, v1, u1, w1, info1, s2, r2, t2, v2, u2, w2, info2, ys)); } /*! * Pair the x coordinates and the y coordinates of the intersection point * of the underlying conics of (*this) and arc, and return a vector of * intersection points. * \param arc The other arc. * \param xs The potential x coordinates. * \param n_xs Number of x coordinates. * \param ys The potential y coordinates. * \param n_ys Number of y coordinates. * \param ipts The points that lie on both conics. * This area must be allocated to the size of 4. * \return The number of intersection points between the conics. */ int _pair_intersection_points (const Self& arc, const CoNT* xs, const int& n_xs, const CoNT* ys, const int& n_ys, Point_2* ipts) const { int n_ipts = 0; int i; int j; for (i = 0; i < n_xs; i++) { for (j = 0; j < n_ys; j++) { // If the current pair of x and y coordinates lies on both underlying // conic curves, accept it. if (_conic_has_on_boundary (xs[i], ys[j]) && arc._conic_has_on_boundary (xs[i], ys[j])) { CGAL_assertion(n_ipts < 4); ipts[n_ipts] = Point_2 (xs[i], ys[j], _conic_id, arc._conic_id); n_ipts++; } } } return (n_ipts); } }; #ifndef NO_OSTREAM_INSERT_CONIC_ARC_2 template std::ostream& operator<< (std::ostream& os, const Conic_arc_2 & arc) { typedef typename Conic_arc_2::Point_2 Point_2; const Point_2& source = arc.source(); const Point_2& target = arc.target(); os << "{" << arc.r() << "*x^2 + " << arc.s() << "*y^2 + " << arc.t() << "*xy + " << arc.u() << "*x + " << arc.v() << "*y + " << arc.w() << "} :" << "(" << CGAL::to_double(source.x()) << "," << CGAL::to_double(source.y()) << ") -> " << "(" << CGAL::to_double(target.x()) << "," << CGAL::to_double(target.y()) << ")"; return (os); } #endif // NO_OSTREAM_INSERT_CONIC_ARC_2 CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_2.h0000644000175000017500000006642711344301500030737 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_2_H #define CGAL_APOLLONIUS_GRAPH_2_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template struct AG2_which_list; // use the in-place edge list template struct AG2_which_list { typedef E Edge; typedef In_place_edge_list List; }; // do not use the in-place edge list template struct AG2_which_list { typedef E Edge; // change the following to Tag_false in order to use // CGAL's Unique_hash_map typedef Tag_true Use_stl_map_tag; typedef Edge_list List; }; template < class Node > struct Project_site_2 { typedef Node argument_type; typedef typename Node::Site_2 Site; typedef Site result_type; Site& operator()( Node& x) const { return x.site(); } const Site& operator()( const Node& x) const { return x.site(); } }; } // namespace CGALi template < class Gt, class Agds = Triangulation_data_structure_2 < Apollonius_graph_vertex_base_2, Triangulation_face_base_2 >, class LTag = Tag_false> class Apollonius_graph_2 : private Triangulation_2,Agds> { private: // types and access methods needed for visualization //-------------------------------------------------- // types typedef CGAL::Construct_Apollonius_bisector_2 Construct_Apollonius_bisector_2; typedef CGAL::Construct_Apollonius_bisector_ray_2 Construct_Apollonius_bisector_ray_2; typedef CGAL::Construct_Apollonius_bisector_segment_2 Construct_Apollonius_bisector_segment_2; typedef CGAL::Construct_Apollonius_primal_ray_2 Construct_Apollonius_primal_ray_2; typedef CGAL::Construct_Apollonius_primal_segment_2 Construct_Apollonius_primal_segment_2; // access Construct_Apollonius_bisector_2 construct_Apollonius_bisector_2_object() const { return Construct_Apollonius_bisector_2(); } Construct_Apollonius_bisector_ray_2 construct_Apollonius_bisector_ray_2_object() const { return Construct_Apollonius_bisector_ray_2(); } Construct_Apollonius_bisector_segment_2 construct_Apollonius_bisector_segment_2_object() const { return Construct_Apollonius_bisector_segment_2(); } Construct_Apollonius_primal_ray_2 construct_Apollonius_primal_ray_2_object() const { return Construct_Apollonius_primal_ray_2(); } Construct_Apollonius_primal_segment_2 construct_Apollonius_primal_segment_2_object() const { return Construct_Apollonius_primal_segment_2(); } protected: // some local types typedef Apollonius_graph_traits_wrapper_2 Modified_traits; typedef Triangulation_2 DG; typedef DG Delaunay_graph; typedef typename DG::Vertex Vertex; typedef typename DG::Face Face; public: // TYPES //------ typedef Agds Data_structure; typedef Gt Geom_traits; typedef typename Gt::Point_2 Point_2; typedef typename Gt::Site_2 Site_2; typedef typename DG::Edge Edge; typedef typename DG::Vertex_handle Vertex_handle; typedef typename DG::Face_handle Face_handle; typedef typename DG::Vertex_circulator Vertex_circulator; typedef typename DG::Edge_circulator Edge_circulator; typedef typename DG::Face_circulator Face_circulator; typedef typename DG::All_faces_iterator All_faces_iterator; typedef typename DG::Finite_faces_iterator Finite_faces_iterator; typedef typename DG::All_vertices_iterator All_vertices_iterator; typedef typename DG::Finite_vertices_iterator Finite_vertices_iterator; typedef typename DG::All_edges_iterator All_edges_iterator; typedef typename DG::Finite_edges_iterator Finite_edges_iterator; typedef typename DG::size_type size_type; // Auxiliary iterators for convenience // do not use default template argument to please VC++ typedef CGALi::Project_site_2 Proj_site; typedef Iterator_project /* */ Visible_sites_iterator; typedef Apollonius_graph_vertex_base_nested_iterator_traits< Finite_vertices_iterator> Hidden_sites_nested_iterator_traits; typedef Nested_iterator /* */ Hidden_sites_iterator; typedef Concatenate_iterator Sites_iterator; typedef Site_2 value_type; // to have a back_inserter typedef const value_type& const_reference; typedef value_type& reference; public: struct Vertex_iterator {}; struct Face_iterator {}; struct Edge_iterator {}; protected: // some more local types // typedef typename Agds::Vertex Vertex; // point lists typedef std::vector Site_list; typedef typename Site_list::iterator Site_list_iterator; typedef std::map Face_map; typedef std::map Face_face_map; typedef std::map Vertex_map; typedef std::set Edge_list; typedef std::list Vertex_list; typedef typename Vertex_list::iterator Vertex_list_iterator; typedef Vertex_handle Vh_triple[3]; // the edge list typedef typename CGALi::AG2_which_list::List List; typedef enum { NO_CONFLICT = -1, INTERIOR, LEFT_VERTEX, RIGHT_VERTEX, BOTH_VERTICES, ENTIRE_EDGE } Conflict_type; static Conflict_type opposite(const Conflict_type& ct) { if ( ct == RIGHT_VERTEX ) { return LEFT_VERTEX; } if ( ct == LEFT_VERTEX ) { return RIGHT_VERTEX; } return ct; } protected: // Less_than comparator for site weights; // used to sort sites by decreasing weight when a sequence of sites // is inserted class Site_less_than_comparator { private: const Gt& gt; public: Site_less_than_comparator(const Gt& gt) : gt(gt) {} bool operator ()(const Site_2& p, const Site_2& q) { Comparison_result result = gt.compare_weight_2_object()(p, q); return (result == LARGER); } }; public: // CREATION //--------- Apollonius_graph_2(const Gt& gt=Gt()) : DG( Modified_traits(gt) ) {} template< class Input_iterator > Apollonius_graph_2(Input_iterator first, Input_iterator beyond, const Gt& gt=Gt()) : DG( Modified_traits(gt) ) { insert(first, beyond); } Apollonius_graph_2(const Apollonius_graph_2 &ag) : DG(ag) { CGAL_postcondition( is_valid() ); } Apollonius_graph_2& operator=(const Apollonius_graph_2& ag) { if ( this != &ag ) { DG::operator=(ag); } return (*this); } public: // ACCESS METHODS // -------------- const Geom_traits& geom_traits() const { return DG::geom_traits(); } int dimension() const { return this->_tds.dimension(); } size_type number_of_faces() const { return this->_tds.number_of_faces(); } size_type number_of_vertices() const { return DG::number_of_vertices(); } size_type number_of_visible_sites() const { return number_of_vertices(); } size_type number_of_hidden_sites() const { // if ( !Vertex::StoreHidden ) { return 0; } int n_hidden(0); for (Finite_vertices_iterator vit = finite_vertices_begin(); vit != finite_vertices_end(); ++vit) { n_hidden += vit->number_of_hidden_sites(); } return n_hidden; } Vertex_handle infinite_vertex() const { return DG::infinite_vertex(); } Face_handle infinite_face() const { return DG::infinite_face(); } Vertex_handle finite_vertex() const { return DG::finite_vertex(); } protected: using Delaunay_graph::cw; using Delaunay_graph::ccw; public: // TRAVERSAL OF THE APOLLONIUS GRAPH //---------------------------------- Finite_faces_iterator finite_faces_begin() const { return DG::finite_faces_begin(); } Finite_faces_iterator finite_faces_end() const { return DG::finite_faces_end(); } Finite_vertices_iterator finite_vertices_begin() const { return DG::finite_vertices_begin(); } Finite_vertices_iterator finite_vertices_end() const { return DG::finite_vertices_end(); } Finite_edges_iterator finite_edges_begin() const { return DG::finite_edges_begin(); } Finite_edges_iterator finite_edges_end() const { return DG::finite_edges_end(); } Sites_iterator sites_begin() const { return Sites_iterator(visible_sites_end(), hidden_sites_begin(), visible_sites_begin()); } Sites_iterator sites_end() const { return Sites_iterator(visible_sites_end(), hidden_sites_begin(), hidden_sites_end(),0); } Visible_sites_iterator visible_sites_begin() const { return Visible_sites_iterator(finite_vertices_begin()); } Visible_sites_iterator visible_sites_end() const { return Visible_sites_iterator(finite_vertices_end()); } Hidden_sites_iterator hidden_sites_begin() const { return Hidden_sites_iterator(finite_vertices_end(), finite_vertices_begin()); } Hidden_sites_iterator hidden_sites_end() const { return Hidden_sites_iterator(finite_vertices_end(), finite_vertices_end()); } All_faces_iterator all_faces_begin() const { return DG::all_faces_begin(); } All_faces_iterator all_faces_end() const { return DG::all_faces_end(); } All_vertices_iterator all_vertices_begin() const { return DG::all_vertices_begin(); } All_vertices_iterator all_vertices_end() const { return DG::all_vertices_end(); } All_edges_iterator all_edges_begin() const { return DG::all_edges_begin(); } All_edges_iterator all_edges_end() const { return DG::all_edges_end(); } public: // CIRCULATORS //------------ Face_circulator incident_faces(Vertex_handle v, Face_handle f = Face_handle()) const { return DG::incident_faces(v, f); } Vertex_circulator incident_vertices(Vertex_handle v, Face_handle f = Face_handle()) const { return DG::incident_vertices(v, f); } Edge_circulator incident_edges(Vertex_handle v, Face_handle f = Face_handle()) const { return DG::incident_edges(v, f); } public: // PREDICATES //----------- bool is_infinite(const Vertex_handle& v) const { return DG::is_infinite(v); } bool is_infinite(const Face_handle& f) const { return DG::is_infinite(f); } bool is_infinite(const Face_handle& f, int i) const { return DG::is_infinite(f, i); } bool is_infinite(const Edge& e) const { return is_infinite(e.first, e.second); } bool is_infinite(const Edge_circulator& ec) const { return DG::is_infinite(ec); } public: // INSERTION //---------- template< class Input_iterator > unsigned int insert(Input_iterator first, Input_iterator beyond) { // copy to a local container Site_list wp_list; for (Input_iterator it = first; it != beyond; ++it) { wp_list.push_back(*it); } // sort by decreasing weight Site_less_than_comparator less_than(geom_traits()); std::sort(wp_list.begin(), wp_list.end(), less_than); // now insert Site_list_iterator lit; for (lit = wp_list.begin(); lit != wp_list.end(); ++lit) { insert(*lit); } // store how many sites where in the range unsigned int num = wp_list.size(); // clear the local container wp_list.clear(); // return the number of sites in range return num; } Vertex_handle insert(const Site_2& p) { return insert(p, Vertex_handle()); } Vertex_handle insert(const Site_2& p, Vertex_handle vnear); public: // REMOVAL //-------- void remove(Vertex_handle v); public: // NEAREST NEIGHBOR LOCATION //-------------------------- Vertex_handle nearest_neighbor(const Point_2& p) const; Vertex_handle nearest_neighbor(const Point_2& p, Vertex_handle vnear) const; public: // ACCESS TO THE DUAL //------------------- typename Gt::Object_2 dual(const Face_handle& f) const; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE //af: all_faces_iterator == Face_handle #else typename Gt::Object_2 dual(const All_faces_iterator& it) const { return dual(*it); } #endif Site_2 dual(const Finite_faces_iterator& it) const { typename Gt::Object_2 o = dual(Face_handle(it)); Site_2 s; if ( assign(s, o) ) { return s; } else { bool the_assign_statement_must_always_work(false); CGAL_assertion( the_assign_statement_must_always_work ); } return s; } private: typename Gt::Object_2 dual(const Edge e) const; typename Gt::Object_2 dual(const Edge_circulator& ec) const { return dual(*ec); } typename Gt::Object_2 dual(const Finite_edges_iterator& ei) const { return dual(*ei); } public: // I/O //---- template< class Stream > Stream& draw_primal(Stream &str) const { if ( number_of_vertices() < 2 ) { // do nothing } else if ( number_of_vertices() == 2 ) { Vertex_handle v1(finite_vertices_begin()); Vertex_handle v2(++finite_vertices_begin()); Site_2 p1 = v1->site(); Site_2 p2 = v2->site(); typename Geom_traits::Segment_2 seg = construct_Apollonius_primal_segment_2_object()(p1,p2); typename Geom_traits::Ray_2 ray1 = construct_Apollonius_primal_ray_2_object()(p1,p2,p2); typename Geom_traits::Ray_2 ray2 = construct_Apollonius_primal_ray_2_object()(p2,p1,p1); str << seg; str << ray1; str << ray2; } else { All_edges_iterator eit = all_edges_begin(); for (; eit != all_edges_end(); ++eit) { draw_primal_edge< Stream >(eit, str); } } return str; } template < class Stream > Stream& draw_dual(Stream &str) const { Finite_edges_iterator eit = finite_edges_begin(); for (; eit != finite_edges_end(); ++eit) { typename Gt::Object_2 o = dual(eit); typename Geom_traits::Line_2 l; typename Geom_traits::Segment_2 s; typename Geom_traits::Ray_2 r; CGAL::Hyperbola_2 h; CGAL::Hyperbola_segment_2 hs; CGAL::Hyperbola_ray_2 hr; if (assign(hs, o)) hs.draw(str); if (assign(s, o)) str << s; if (assign(hr, o)) hr.draw(str); if (assign(r, o)) str << r; if (assign(h, o)) h.draw(str); if (assign(l, o)) str << l; } return str; } protected: template< class Stream > Stream& draw_primal_vertex(const Finite_vertices_iterator& it, Stream &str) const { return str << it->site().point(); } template< class Stream > Stream& draw_dual_vertex(const Finite_faces_iterator& it, Stream &str) const { return str << dual(it); } public: template< class Stream > Stream& draw_primal_edge(const Finite_edges_iterator& eit, Stream &str) const { return draw_primal_edge(*eit, str); } template< class Stream > Stream& draw_primal_edge(const All_edges_iterator& eit, Stream &str) const { return draw_primal_edge(*eit, str); } template < class Stream > Stream& draw_dual_edge(const Finite_edges_iterator& eit, Stream &str) const { return draw_dual_edge(*eit, str); } template< class Stream > Stream& draw_primal_edge(const Edge& e, Stream &str) const { // if ( is_infinite(e) ) { return str; } typename Gt::Object_2 o = primal(e); typename Geom_traits::Segment_2 s; typename Geom_traits::Ray_2 r; CGAL::Hyperbola_segment_2 hs; CGAL::Parabola_segment_2 ps; if (assign(hs, o)) hs.draw(str); if (assign(s, o)) str << s; if (assign(ps, o)) ps.draw(str); if (assign(r, o)) str << r; // if (assign(hr, o)) str << hr; // if (assign(h, o)) str << h; // if (assign(l, o)) str << l; return str; } template < class Stream > Stream& draw_dual_edge(const Edge& e, Stream &str) const { if ( is_infinite(e) ) { return str; } typename Gt::Object_2 o = dual(e); typename Geom_traits::Line_2 l; typename Geom_traits::Segment_2 s; typename Geom_traits::Ray_2 r; CGAL::Hyperbola_2 h; CGAL::Hyperbola_segment_2 hs; CGAL::Hyperbola_ray_2 hr; if (assign(hs, o)) hs.draw(str); if (assign(s, o)) str << s; if (assign(hr, o)) hr.draw(str); if (assign(r, o)) str << r; if (assign(h, o)) h.draw(str); if (assign(l, o)) str << l; return str; } protected: template< class Stream > Stream& draw_primal_face(All_faces_iterator fit, Stream &str) const { for (int i = 0; i < 3; i++) { draw_primal_edge< Stream >(Edge(Face_handle(fit), i), str); } return str; } template< class Stream > Stream& draw_dual_face(const All_vertices_iterator& vit, Stream &str) const { Edge_circulator ec_start = incident_edges(Vertex_handle(vit)); Edge_circulator ec = ec_start; do { draw_dual_edge< Stream >(*ec, str); ++ec; } while ( ec_start != ec ); return str; } protected: template < class Stream > Stream& draw_dual_sites(Stream &str) const { All_faces_iterator fit = all_faces_begin(); for (; fit != all_faces_end(); ++fit) { Face_handle f(fit); if ( is_infinite(f) ) { if ( is_infinite(f->vertex(0)) ) { str << circumcircle( f->vertex(1)->site(), f->vertex(2)->site() ); } else if ( is_infinite(f->vertex(1)) ){ str << circumcircle( f->vertex(2)->site(), f->vertex(0)->site() ); } else { str << circumcircle( f->vertex(0)->site(), f->vertex(1)->site() ); } } else { Site_2 wp = circumcircle(f); typename Gt::Rep::Circle_2 c(wp.point(), CGAL::square(wp.weight())); str << c; } } return str; } public: // VALIDITY CHECK //--------------- bool is_valid(bool verbose = false, int level = 1) const; public: // MISCELLANEOUS //-------------- void clear() { DG::clear(); } void swap(Apollonius_graph_2& ag) { DG::swap(ag); } public: // MK: THE FOLLOWING ARE NOT IN THE SPEC //====================================== // Primal typename Gt::Object_2 primal(const Edge e) const; typename Gt::Object_2 primal(const Edge_circulator& ec) const { return primal(*ec); } typename Gt::Object_2 primal(const Finite_edges_iterator& ei) const { return primal(*ei); } protected: // wrappers for the geometric predicates // checks is q is contained inside p bool is_hidden(const Site_2 &p, const Site_2 &q) const; // returns: // ON_POSITIVE_SIDE if q is closer to p1 // ON_NEGATIVE_SIDE if q is closer to p2 // ON_ORIENTED_BOUNDARY if q is on the bisector of p1 and p2 Oriented_side side_of_bisector(const Site_2 &p1, const Site_2 &p2, const Point_2 &q) const; Sign incircle(const Site_2 &p1, const Site_2 &p2, const Site_2 &p3, const Site_2 &q) const; Sign incircle(const Site_2 &p1, const Site_2 &p2, const Site_2 &q) const; Sign incircle(const Face_handle& f, const Site_2& q) const; Sign incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v) const; Sign incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v) const; bool finite_edge_interior(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool endpoints_in_conflict) const; bool finite_edge_interior(const Face_handle& f, int i, const Site_2& q, bool endpoints_in_conflict) const; bool finite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool endpoints_in_conflict) const; bool finite_edge_interior_degenerated(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q, bool endpoints_in_conflict) const; bool finite_edge_interior_degenerated(const Site_2& p1, const Site_2& p2, const Site_2& q, bool endpoints_in_conflict) const; bool finite_edge_interior_degenerated(const Face_handle& f, int i, const Site_2& p, bool endpoints_in_conflict) const; bool finite_edge_interior_degenerated(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool endpoints_in_conflict) const; bool infinite_edge_interior(const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool endpoints_in_conflict) const; bool infinite_edge_interior(const Face_handle& f, int i, const Site_2& p, bool endpoints_in_conflict) const; bool infinite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool endpoints_in_conflict) const; Conflict_type finite_edge_conflict_type_degenerated(const Site_2& p1, const Site_2& p2, const Site_2& q) const; bool edge_interior(const Face_handle& f, int i, const Site_2& p, bool b) const; bool edge_interior(const Edge& e, const Site_2& p, bool b) const { return edge_interior(e.first, e.second, p, b); } bool edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool endpoints_in_conflict) const; bool is_degenerate_edge(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4) const { return geom_traits().is_degenerate_edge_2_object() (p1, p2, p3, p4); } bool is_degenerate_edge(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4) const { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) && !is_infinite(v3) && !is_infinite(v4) ); return is_degenerate_edge(v1->site(), v2->site(), v3->site(), v4->site()); } bool is_degenerate_edge(const Face_handle& f, int i) const { Vertex_handle v1 = f->vertex( ccw(i) ); Vertex_handle v2 = f->vertex( cw(i) ); Vertex_handle v3 = f->vertex( i ); Vertex_handle v4 = f->mirror_vertex(i); return is_degenerate_edge(v1, v2, v3, v4); } bool is_degenerate_edge(const Edge& e) const { return is_degenerate_edge(e.first, e.second); } protected: // wrappers for constructions Point_2 circumcenter(const Face_handle& f) const; Point_2 circumcenter(const Site_2& p0, const Site_2& p1, const Site_2& p2) const; Site_2 circumcircle(const Face_handle& f) const; Site_2 circumcircle(const Site_2& p0, const Site_2& p1, const Site_2& p2) const; typename Gt::Line_2 circumcircle(const Site_2& p0, const Site_2& p1) const; protected: // wrappers for combinatorial operations on the data structure // getting the symmetric edge Edge sym_edge(const Edge e) const { return sym_edge(e.first, e.second); } Edge sym_edge(const Face_handle& f, int i) const { Face_handle f_sym = f->neighbor(i); return Edge( f_sym, f_sym->index( f->mirror_vertex(i) ) ); } Edge flip(Face_handle& f, int i); Edge flip(Edge e); Vertex_handle insert_in_face(Face_handle& f, const Site_2& p); bool is_degree_2(const Vertex_handle& v) const; Vertex_handle insert_degree_2(Edge e); Vertex_handle insert_degree_2(Edge e, const Site_2& p); void remove_degree_2(Vertex_handle v); void remove_degree_3(Vertex_handle v); #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE void remove_degree_3(Vertex_handle v, Face_handle f); #else void remove_degree_3(Vertex_handle v, Face* f); #endif // this was defined because the hierarchy needs it Vertex_handle create_vertex() { return this->_tds.create_vertex(); } protected: // insertion of the first three sites Vertex_handle insert_first(const Site_2& p); Vertex_handle insert_second(const Site_2& p); Vertex_handle insert_third(const Site_2& p); // methods for insertion void initialize_conflict_region(const Face_handle& f, List& l); bool check_edge_for_hidden_sites(const Face_handle& f, int i, const Site_2& p, Vertex_map& vm); void expand_conflict_region(const Face_handle& f, const Site_2& p, List& l, Face_map& fm, Vertex_map& vm, std::vector* fe); Vertex_handle add_bogus_vertex(Edge e, List& l); Vertex_list add_bogus_vertices(List& l); void remove_bogus_vertices(Vertex_list& vl); void move_hidden_sites(Vertex_handle& vold, Vertex_handle& vnew); // MK: this is not currently used std::vector get_faces_for_recycling(Face_map& fm, unsigned int n_wanted); void remove_hidden_vertices(Vertex_map& vm); Vertex_handle retriangulate_conflict_region(const Site_2& p, List& l, Face_map& fm, Vertex_map& vm); protected: // methods for removal void remove_first(Vertex_handle v); void remove_second(Vertex_handle v); void remove_third(Vertex_handle v); void remove_degree_d_vertex(Vertex_handle v); void minimize_degree(Vertex_handle v); void find_conflict_region_remove(const Vertex_handle& v, const Vertex_handle& vnearest, List& l, Face_map& fm, Vertex_map& vm, std::vector* fe); protected: // methods for I/O template bool assign(T& t2, const typename Gt::Object_2& o2) const { return geom_traits().assign_2_object()(t2, o2); } }; // Apollonius_graph_2 CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif #endif // CGAL_APOLLONIUS_GRAPH_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Hyperbola_ray_2.h0000644000175000017500000000642411344301500030220 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Hyperbola_ray_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_HYPERBOLA_RAY_2_H #define CGAL_HYPERBOLA_RAY_2_H #include CGAL_BEGIN_NAMESPACE template < class Gt > class Hyperbola_ray_2 : public Hyperbola_segment_2< Gt > { public: typedef Sign Hyperbola_direction; typedef CGAL::Hyperbola_segment_2 Base; typedef typename Base::Site_2 Site_2; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Gt::Ray_2 Ray_2; typedef typename Base::FT FT; // typedef typename R::RT FT; // typedef double FT; // typedef CGAL::Point_2< Cartesian > Point_2; // typedef CGAL::Segment_2< Cartesian > Segment_2; // typedef CGAL::Ray_2< Cartesian > Ray_2; protected: static const FT& OFFSET() { static FT offset_(10000); return offset_; } template< class Stream > inline void draw_ray(Stream &W) const { W << Ray_2(this->p1, this->p2); } Site_2 _f1, _f2; Point_2 _p; Hyperbola_direction _dir; public: Hyperbola_ray_2() : Hyperbola_segment_2< Gt >() {} Hyperbola_ray_2(const Site_2 &f1, const Site_2 &f2, const Point_2 &p, const Hyperbola_direction& direction) : Hyperbola_segment_2< Gt >(f1, f2, p, p), _f1(f1), _f2(f2), _p(p), _dir(direction) { FT t1 = t(this->p1); if ( direction == POSITIVE ) { this->p2 = f(t1 + this->STEP * OFFSET()); } else { this->p2 = f(t1 - this->STEP * OFFSET()); } } #ifdef CGAL_USE_QT template void draw_qt(QTWIDGET& s) { if ( CGAL::is_zero(this->r) ) { draw_ray(s); return; } double width = s.x_max() - s.x_min(); double height = s.y_max() - s.y_min(); if ( width > height ) { this->STEP = height / 100.0; } else { this->STEP = width / 100.0; } FT t1 = t(this->p1); if ( _dir == POSITIVE ) { this->p2 = f(t1 + this->STEP * OFFSET()); } else { this->p2 = f(t1 - this->STEP * OFFSET()); } Hyperbola_segment_2< Gt >::draw(s); } #endif template< class Stream > inline void draw(Stream& s) const { if ( CGAL::is_zero(this->r) ) { draw_ray(s); return; } Hyperbola_segment_2< Gt >::draw(s); } }; template< class Stream, class Gt > inline Stream& operator<<(Stream &s, const Hyperbola_ray_2 &H) { H.draw(s); return s; } CGAL_END_NAMESPACE #endif // CGAL_HYPERBOLA_RAY_2_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_indirect_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_indirect0000644000175000017500000000740711344301501031455 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_indirect_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_TRIANGULATION_INDIRECT_TRAITS_2_H #define CGAL_TRIANGULATION_INDIRECT_TRAITS_2_H #include namespace CGAL { template class Indirect_segment { public: Indirect_segment() {} Indirect_segment(Circulator s, Circulator t) : _source_ref(s), _target_ref(t) {} Circulator source() {return _source_ref;} Circulator target() {return _target_ref;} private: Circulator _source_ref; Circulator _target_ref; }; template class Indirect_triangle { public: Indirect_triangle() {} Indirect_triangle(Circulator p0, Circulator p1, Circulator p2): _p0(p0), _p1(p1), _p2(p2) {} private: Circulator _p0, _p1, _p2; }; template class Indirect_compare_x_2 { public: Indirect_compare_x_2(): _compare_x_2(Compare_x_2()) {} template Comparison_result operator()(Point_2_ptr p1, Point_2_ptr p2) { return _compare_x_2(*p1, *p2); } private: Compare_x_2 _compare_x_2; }; template class Indirect_compare_y_2 { public: Indirect_compare_y_2(): _compare_y_2(Compare_y_2()) {} template Comparison_result operator()(Point_2_ptr p1, Point_2_ptr p2) { return _compare_y_2(*p1, *p2); } private: Compare_y_2 _compare_y_2; }; template class Indirect_orientation_2 { public: Indirect_orientation_2(): _orientation_2(Orientation_2()) {} template Orientation operator()(Point_2_ptr p1, Point_2_ptr p2, Point_2_ptr p3) { return _orientation_2(*p1, *p2, *p3); } private: Orientation_2 _orientation_2; }; template class Construct_indirect_segment_2 { public: typedef Indirect_segment I_segment; I_segment operator()(Circulator p1, Circulator p2) { return I_segment(p1, p2); } }; template class Triangulation_indirect_traits_2 { public: typedef Circulator Point_2; typedef Indirect_segment Segment_2; typedef Indirect_triangle Triangle_2; typedef Indirect_orientation_2 Orientation_2; typedef Indirect_compare_x_2 Compare_x_2; typedef Indirect_compare_y_2 Compare_y_2; typedef Construct_indirect_segment_2 Construct_segment_2; Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Construct_segment_2 construct_segment_2_object() const { return Construct_segment_2(); } private: Orientation_2 _orientation_2; Compare_x_2 _compare_x_2; Compare_y_2 _compare_y_2; }; } #endif // CGAL_TRIANGULATION_INDIRECT_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2.h0000644000175000017500000001053111344301500026304 0ustar debiandebian// Copyright (c) 1999,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_BBOX_2_H #define CGAL_BBOX_2_H #include #include #include CGAL_BEGIN_NAMESPACE class Bbox_2 { typedef Fourtuple BBox_rep_2; BBox_rep_2 rep; public: Bbox_2() {} Bbox_2(double x_min, double y_min, double x_max, double y_max) : rep(x_min, y_min, x_max, y_max) {} inline bool operator==(const Bbox_2 &b) const; inline bool operator!=(const Bbox_2 &b) const; inline int dimension() const; inline double xmin() const; inline double ymin() const; inline double xmax() const; inline double ymax() const; inline double max(int i) const; inline double min(int i) const; inline Bbox_2 operator+(const Bbox_2 &b) const; }; inline double Bbox_2::xmin() const { return rep.e0; } inline double Bbox_2::ymin() const { return rep.e1; } inline double Bbox_2::xmax() const { return rep.e2; } inline double Bbox_2::ymax() const { return rep.e3; } inline bool Bbox_2::operator==(const Bbox_2 &b) const { return xmin() == b.xmin() && xmax() == b.xmax() && ymin() == b.ymin() && ymax() == b.ymax(); } inline bool Bbox_2::operator!=(const Bbox_2 &b) const { return ! (b == *this); } inline int Bbox_2::dimension() const { return 2; } inline double Bbox_2::min(int i) const { CGAL_kernel_precondition( (i == 0 ) || ( i == 1 ) ); if(i == 0) { return xmin(); } return ymin(); } inline double Bbox_2::max(int i) const { CGAL_kernel_precondition( (i == 0 ) || ( i == 1 ) ); if(i == 0) { return xmax(); } return ymax(); } inline Bbox_2 Bbox_2::operator+(const Bbox_2 &b) const { return Bbox_2(std::min(xmin(), b.xmin()), std::min(ymin(), b.ymin()), std::max(xmax(), b.xmax()), std::max(ymax(), b.ymax())); } inline bool do_overlap(const Bbox_2 &bb1, const Bbox_2 &bb2) { // check for emptiness ?? if (bb1.xmax() < bb2.xmin() || bb2.xmax() < bb1.xmin()) return false; if (bb1.ymax() < bb2.ymin() || bb2.ymax() < bb1.ymin()) return false; return true; } #ifndef CGAL_NO_OSTREAM_INSERT_BBOX_2 inline std::ostream& operator<<(std::ostream &os, const Bbox_2 &b) { switch(os.iword(IO::mode)) { case IO::ASCII : os << b.xmin() << ' ' << b.ymin() << ' ' << b.xmax() << ' ' << b.ymax(); break; case IO::BINARY : write(os, b.xmin()); write(os, b.ymin()); write(os, b.xmax()); write(os, b.ymax()); break; default: os << "Bbox_2(" << b.xmin() << ", " << b.ymin() << ", " << b.xmax() << ", " << b.ymax() << ")"; break; } return os; } #endif // CGAL_NO_OSTREAM_INSERT_BBOX_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_BBOX_2 inline std::istream& operator>>(std::istream &is, Bbox_2 &b) { double xmin, ymin, xmax, ymax; switch(is.iword(IO::mode)) { case IO::ASCII : is >> xmin >> ymin >> xmax >> ymax; break; case IO::BINARY : read(is, xmin); read(is, ymin); read(is, xmax); read(is, ymax); break; } b = Bbox_2(xmin, ymin, xmax, ymax); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_BBOX_2 CGAL_END_NAMESPACE #endif // CGAL_BBOX_2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_points_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_points_20000644000175000017500000000242111344301500031376 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates_on_points_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_PREDICATES_ON_POINTS_2_H #define CGAL_PREDICATES_ON_POINTS_2_H // Kept for backward compatibility only. #endif // CGAL_PREDICATES_ON_POINTS_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Line_3_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Line_3_do_i0000644000175000017500000000737711344301501031134 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Line_3_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_3_LINE_3_DO_INTERSECT_H #define CGAL_TRIANGLE_3_LINE_3_DO_INTERSECT_H CGAL_BEGIN_NAMESPACE namespace CGALi { template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t, const typename CGAL_WRAP(K)::Line_3 &l, const K & k ) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t) ) ; CGAL_kernel_precondition( ! k.is_degenerate_3_object()(l) ) ; typedef typename K::Point_3 Point_3; typename K::Construct_point_on_3 point_on = k.construct_point_on_3_object(); typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Orientation_3 orientation = k.orientation_3_object(); typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); const Point_3 & a = vertex_on(t,0); const Point_3 & b = vertex_on(t,1); const Point_3 & c = vertex_on(t,2); const Point_3 & p = point_on(l,0); const Point_3 & q = point_on(l,1); if ( ( orientation(a,b,c,p) != COPLANAR ) || ( orientation(a,b,c,q) != COPLANAR ) ) { const Orientation pqab = orientation(p,q,a,b); const Orientation pqbc = orientation(p,q,b,c); switch ( pqab ) { case POSITIVE: return pqbc != NEGATIVE && orientation(p,q,c,a) != NEGATIVE ; case NEGATIVE: return pqbc != POSITIVE && orientation(p,q,c,a) != POSITIVE ; case COLLINEAR: switch ( pqbc ) { case POSITIVE: return orientation(p,q,c,a) != NEGATIVE ; case NEGATIVE: return orientation(p,q,c,a) != POSITIVE ; case COLLINEAR: return true; default: // should not happen. CGAL_kernel_assertion(false); return false; } default: // should not happen. CGAL_kernel_assertion(false); return false; } } // Coplanar case const Orientation pqa = coplanar_orientation(p,q,a); return coplanar_orientation(p,q,b) != pqa || coplanar_orientation(p,q,c) != pqa ; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Line_3 &l, const typename CGAL_WRAP(K)::Triangle_3 &t, const K & k ) { return do_intersect(t, l, k); } } // namespace CGALi template bool do_intersect(const Triangle_3 &t, const Line_3 &l) { return typename K::Do_intersect_3()(t,l); } template inline bool do_intersect(const Line_3 &l, const Triangle_3 &t) { return typename K::Do_intersect_3()(t,l); } /* template inline bool do_intersect(const Line_3 &l, const Triangle_3 &t, const K & k ) { return do_intersect(t,l,k); } */ CGAL_END_NAMESPACE #endif //CGAL_TRIANGLE_3_LINE_3_DO_INTERSECT_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_alpha_shape_euclidean_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_alpha_shape_e0000644000175000017500000000520211344301501031334 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_alpha_shape_euclidean_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_WEIGHTED_ALPHA_SHAPE_EUCLIDEAN_TRAITS_3_H #define CGAL_WEIGHTED_ALPHA_SHAPE_EUCLIDEAN_TRAITS_3_H #include CGAL_BEGIN_NAMESPACE //------------------ Traits class ------------------------------------- template class Weighted_alpha_shape_euclidean_traits_3 : public Regular_triangulation_euclidean_traits_3 { public: typedef Regular_triangulation_euclidean_traits_3 Base; typedef typename Base::Side_of_bounded_orthogonal_sphere_3 Side_of_bounded_sphere_3; class Compute_squared_radius_3 { typedef typename Base::Weighted_point Weighted_point_3; typedef typename Base::FT FT; typedef typename Base::Compute_squared_radius_smallest_orthogonal_sphere_3 Compute_squared_radius_base; public: FT operator() (Weighted_point_3 p, Weighted_point_3 q , Weighted_point_3 r, Weighted_point_3 s) { return Compute_squared_radius_base()(p,q,r,s); } FT operator() (Weighted_point_3 p, Weighted_point_3 q , Weighted_point_3 r) { return Compute_squared_radius_base()(p,q,r); } FT operator() (Weighted_point_3 p, Weighted_point_3 q ) { return Compute_squared_radius_base()(p,q); } FT operator() (Weighted_point_3 p) { return -p.weight();} }; //--------------------------------------------------------------------- Compute_squared_radius_3 compute_squared_radius_3_object() const { return Compute_squared_radius_3(); } //--------------------------------------------------------------------- Side_of_bounded_sphere_3 side_of_bounded_sphere_3_object() const { return Side_of_bounded_sphere_3(); } }; CGAL_END_NAMESPACE #endif //CGAL_WEIGHTED_ALPHA_SHAPE_EUCLIDEAN_TRAITS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/extremal_polygon_2.h0000644000175000017500000005375111344301500031015 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/extremal_polygon_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_EXTREMAL_POLYGON_2_H) #define CGAL_EXTREMAL_POLYGON_2_H 1 #include #include #include #include #include #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif // CGAL_REP_CLASS_DEFINED CGAL_BEGIN_NAMESPACE //!!! This will eventually be integrated into function_objects.h template < class Array, class Index, class Element > struct Index_operator : public CGAL_STD::binary_function< Array, Index, Element > { typedef Arity_tag< 2 > Arity; Element& operator()( Array& a, const Index& i) const { return a[i]; } const Element& operator()( const Array& a, const Index& i) const { return a[i]; } }; template < class RandomAccessIC_object_, class RandomAccessIC_value_, class Operation_ > // This class describes the kind of matrices used for the // computation of extremal polygons. // // RandomAccessIC_object is a random access iterator or circulator // with value type Object // RandomAccessIC_value is a random access iterator or circulator // with value type Value // Operation is an adatable binary function: // Object x Object -> Value // // objects can be constructed using the helper function // extremal_polygon_matrix. // class Extremal_polygon_matrix { public: typedef RandomAccessIC_object_ RandomAccessIC_object; typedef RandomAccessIC_value_ RandomAccessIC_value; typedef Operation_ Operation; typedef typename std::iterator_traits< RandomAccessIC_object >::value_type Object; typedef typename std::iterator_traits< RandomAccessIC_value >::value_type Value; Extremal_polygon_matrix( RandomAccessIC_object begin_row, RandomAccessIC_object end_row, RandomAccessIC_object begin_col, RandomAccessIC_object end_col, RandomAccessIC_value begin_value, RandomAccessIC_value CGAL_optimisation_precondition_code(end_value), const Operation& o) // initialization with two ranges [begin_row, end_row) and // [begin_col, end_col) of Objects, a range [begin_value, end_value) // of Values and an Operation o. // // an entry (r, c) of this matrix is then defined as: // begin_value[c] + op( begin_row[r], begin_col[c]). // : op( o), begin_row_( begin_row), begin_col_( begin_col), begin_value_( begin_value), n_rows( iterator_distance( begin_row, end_row)), n_cols( iterator_distance( begin_col, end_col)) { CGAL_optimisation_precondition( iterator_distance( begin_value, end_value) == n_cols); CGAL_optimisation_assertion( n_rows > 0 && n_cols > 0); } int number_of_rows() const { return n_rows; } int number_of_columns() const { return n_cols; } Value operator()( int r, int c) const { CGAL_optimisation_precondition( r >= 0 && r < n_rows); CGAL_optimisation_precondition( c >= 0 && c < n_cols); return begin_value_[c] + op( begin_row_[r], begin_col_[c]); } private: Operation op; RandomAccessIC_object begin_row_; RandomAccessIC_object begin_col_; RandomAccessIC_value begin_value_; int n_rows; int n_cols; }; template < class RandomAccessIC_object, class RandomAccessIC_value, class Operation > inline Extremal_polygon_matrix< RandomAccessIC_object, RandomAccessIC_value, Operation > extremal_polygon_matrix( RandomAccessIC_object begin_row, RandomAccessIC_object end_row, RandomAccessIC_object begin_col, RandomAccessIC_object end_col, RandomAccessIC_value begin_value, RandomAccessIC_value end_value, const Operation& o) { return Extremal_polygon_matrix< RandomAccessIC_object, RandomAccessIC_value, Operation > ( begin_row, end_row, begin_col, end_col, begin_value, end_value, o); } template < class RandomAccessIC, class Outputiterator, class Traits > Outputiterator CGAL_maximum_inscribed_rooted_k_gon_2( RandomAccessIC points_begin, RandomAccessIC points_end, int k, typename Traits::FT& max_area, Outputiterator o, const Traits& t) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // n > k, // * k >= t.min_k() // * value_type of RandomAccessIC is Traits::Point_2 // * OutputIterator accepts Traits::Point_2 as value_type // // functionality: // -------------- // computes maximum (as specified by t) inscribed k-gon $P_k$ // of the polygon $P$, // that is rooted at points_begin[0], // sets max_area to its associated value (as specified by t) // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { // check preconditions: CGAL_optimisation_precondition( k >= t.min_k()); int number_of_points( iterator_distance( points_begin, points_end)); CGAL_optimisation_precondition( number_of_points > k); typedef std::vector< int > Index_cont; if ( k == t.min_k()) // compute min_k gon: return t.compute_min_k_gon( points_begin, points_end, max_area, o); // current i-gon (i = 2/3...k) Index_cont gon( k + 1); // compute initial min_k-gon: int i( t.min_k()); t.compute_min_k_gon( points_begin, points_end, max_area, gon.rbegin() + k + 1 - i); for (;;) { CGAL_optimisation_assertion( gon[0] == 0); gon[i] = number_of_points - 1; if ( ++i >= k) break; CGAL_maximum_inscribed_rooted_k_gon_2( points_begin, points_end, 0, gon.begin(), gon.begin() + i - 1, gon.begin() + 1, gon.begin() + i, max_area, gon.rbegin() + k + 1 - i, t); } // for (;;) return CGAL_maximum_inscribed_rooted_k_gon_2( points_begin, points_end, 0, gon.begin(), gon.begin() + k - 1, gon.begin() + 1, gon.begin() + k, max_area, o, t); } // CGAL_maximum_inscribed_rooted_k_gon_2( ... ) template < class RandomAccessIC_point, class RandomAccessIC_int, class OutputIterator, class Traits > OutputIterator CGAL_maximum_inscribed_rooted_k_gon_2( RandomAccessIC_point points_begin, RandomAccessIC_point points_end, int root, RandomAccessIC_int left_c_begin, RandomAccessIC_int CGAL_optimisation_precondition_code(left_c_end), RandomAccessIC_int right_c_begin, RandomAccessIC_int right_c_end, typename Traits::FT& max_area, OutputIterator o, const Traits& t) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // * value_type of RandomAccessIC_point is Traits::Point // * value_type of RandomAccessIC_int is int // * OutputIterator accepts int as value type // * length := right_c_end - right_c_begin == left_c_end - left_c_begin // >= t.min_k() - 1 (the root is already fixed) // * [left_c_begin, left_c_end) resp. [right_c_begin, right_c_end) // describe two subpolygons of $P$ by giving the indices of its // vertices relative to points_begin and for any 0 <= i < length: // left_c_begin[i] <= right_c_begin[i] // * for any 0 <= i < length: o + i must not be contained in // the range [right_c_begin, right_c_begin + length - i - 2]. // (NOT checked!) // // functionality: // -------------- // computes maximum (as specified by t) inscribed k-gon $P_k$ // of the polygon $P$, // that is rooted at points_begin[left_c_begin[0]] // such that for any 0 <= i < length: // left_c_begin[i] <= vertex i of $P_k$ <= right_c_begin[i], // sets max_area to its associated value (as specified by t), // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { using std::max_element; // counter :) int i; // compute size of ranges: int number_of_points( iterator_distance( points_begin, points_end)); int size_of_gon( iterator_distance( right_c_begin, right_c_end)); // check preconditions: CGAL_optimisation_precondition( number_of_points > t.min_k()); CGAL_optimisation_precondition( size_of_gon >= t.min_k() - 1); CGAL_optimisation_precondition( iterator_distance( left_c_begin, left_c_end) == iterator_distance( right_c_begin, right_c_end)); CGAL_optimisation_precondition( left_c_begin[0] >= 0); CGAL_optimisation_precondition( right_c_begin[0] >= 0); CGAL_optimisation_precondition( left_c_begin[size_of_gon-1] < number_of_points); CGAL_optimisation_precondition( right_c_begin[size_of_gon-1] < number_of_points); CGAL_optimisation_expensive_precondition_code( for ( i = 0; i < size_of_gon; ++i) { CGAL_optimisation_expensive_precondition( left_c_begin[i] >= 0); CGAL_optimisation_expensive_precondition( right_c_begin[i] >= 0); CGAL_optimisation_expensive_precondition( left_c_begin[i] < number_of_points); CGAL_optimisation_expensive_precondition( right_c_begin[i] < number_of_points); CGAL_optimisation_expensive_precondition( left_c_begin[i] <= right_c_begin[i]); }) typedef typename Traits::FT FT; typedef std::vector< FT > FT_cont; typedef std::vector< int > Index_cont; typedef typename Traits::Operation Operation; //!!! static ??? // area container: FT_cont area( number_of_points); // last vertex container: Index_cont last_vertex( number_of_points); // matrix operation: Operation op( t.operation( points_begin[root])); // initialize area and last vertex containers: for ( i = left_c_begin[0]; i <= right_c_begin[0]; ++i) { area[i] = t.init( points_begin[i], points_begin[root]); last_vertex[i] = root; } for ( i = 1; i < size_of_gon; ++i) { monotone_matrix_search( dynamic_matrix( extremal_polygon_matrix( points_begin + left_c_begin[i], points_begin + right_c_begin[i] + 1, points_begin + left_c_begin[i-1], points_begin + right_c_begin[i-1] + 1, area.begin() + left_c_begin[i-1], area.begin() + right_c_begin[i-1] + 1, op)), last_vertex.begin() + left_c_begin[i]); // compute new area values and adjust last_vertex values // (they are relative to left_c_begin[i-1] now) int j; for ( j = right_c_begin[i]; j >= left_c_begin[i]; --j) { last_vertex[j] += left_c_begin[i-1]; area[j] = area[last_vertex[j]] + op( points_begin[j], points_begin[last_vertex[j]]); } } // for ( i = 1; i < size_of_gon; ++i) // find maximum in last range: int maxi = iterator_distance( area.begin(), max_element( area.begin() + left_c_begin[size_of_gon - 1], area.begin() + right_c_begin[size_of_gon - 1] + 1)); // set max_area: max_area = area[maxi]; // construct gon: *o++ = maxi; maxi = last_vertex[maxi]; for ( i = size_of_gon - 1; i > 0; --i) { // We must not place the "*o++ = maxi" here, // since o might be the same as left_c_begin + i ... if ( maxi != right_c_begin[i-1]) { *o++ = maxi; maxi = last_vertex[maxi]; } else { *o++ = maxi; maxi = right_c_begin[i-2]; } } // for ( i = size_of_gon - 1; i > 0; --i) *o++ = root; return o; } // CGAL_maximum_inscribed_rooted_k_gon_2( p, k, result) template < class RandomAccessIC, class OutputIterator, class Traits > inline OutputIterator extremal_polygon_2( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o, const Traits& t) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // * k >= t.min_k() // * value_type of RandomAccessIC is Traits::Point_2 // * OutputIterator accepts Traits::Point_2 as value_type // // functionality: // -------------- // computes maximum (as specified by t) inscribed k-gon $P_k$ // of the polygon $P$, // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { using std::bind1st; // check preconditions: CGAL_optimisation_precondition_code( int number_of_points( iterator_distance( points_begin, points_end));) CGAL_optimisation_precondition( number_of_points >= t.min_k()); CGAL_optimisation_expensive_precondition( is_convex_2( points_begin, points_end, t)); typedef typename Traits::Point_2 Point_2; return CGAL_maximum_inscribed_k_gon_2( points_begin, points_end, k, transform_iterator( o, bind1st( Index_operator< RandomAccessIC, int, Point_2 >(), points_begin)), t); } // backwards compatibility template < class RandomAccessIC, class OutputIterator, class Traits > inline OutputIterator extremal_polygon( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o, const Traits& t) { return extremal_polygon_2(points_begin, points_end, k, o, t); } template < class RandomAccessIC, class OutputIterator, class Traits > OutputIterator CGAL_maximum_inscribed_k_gon_2( RandomAccessIC points_begin, RandomAccessIC points_end, int k, OutputIterator o, const Traits& t) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // * k >= t.min_k() // * value_type of RandomAccessIC is Traits::Point_2 // * OutputIterator accepts Traits::Point_2 as value_type // // functionality: // -------------- // computes maximum (as specified by t) inscribed k-gon $P_k$ // of the polygon $P$, // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { // check preconditions: CGAL_optimisation_precondition( k >= t.min_k()); int number_of_points( iterator_distance( points_begin, points_end)); CGAL_optimisation_precondition( number_of_points > 0); using std::min; using std::copy; typedef typename Traits::FT FT; typedef std::vector< int > Index_cont; if ( number_of_points <= k) { for ( int j( k - 1); j >= 0; --j) *o++ = min( j, number_of_points - 1); return o; } // compute k-gon rooted at points_begin[0] Index_cont P_0( k + 1); FT area_0; CGAL_maximum_inscribed_rooted_k_gon_2( points_begin, points_end, k, area_0, P_0.rbegin() + 1, t); P_0[k] = number_of_points - 1; CGAL_optimisation_assertion( P_0[0] == 0); // compute k-gon rooted at points_begin[P_0[1]] Index_cont P_1( k); FT area_1; CGAL_maximum_inscribed_rooted_k_gon_2( points_begin, points_end, P_0[1], P_0.begin() + 1, P_0.begin() + k, P_0.begin() + 2, P_0.begin() + k + 1, area_1, P_1.rbegin(), t); CGAL_optimisation_assertion( P_1[0] == P_0[1]); // start recursive computation: FT area_r( 0); Index_cont P_r( k); if ( P_0[1] - P_0[0] > 1) { CGAL_maximum_inscribed_k_gon_2( points_begin, points_end, P_0[0] + 1, P_0[1] - 1, P_0.begin() + 1, P_0.begin() + k, P_0.begin() + 2, P_0.begin() + k + 1, k, area_r, P_r.rbegin(), t); } if ( area_r > area_0) if ( area_r > area_1) // recursive is maximum copy( P_r.begin(), P_r.end(), o); else // P_1 is maximum copy( P_1.begin(), P_1.end(), o); else if ( area_0 > area_1) // P_0 is maximum copy( P_0.begin(), P_0.begin() + k, o); else // P_1 is maximum copy( P_1.begin(), P_1.end(), o); return o; } // CGAL_maximum_inscribed_k_gon_2( ... ) template < class RandomAccessIC_point, class RandomAccessIC_int, class OutputIterator, class Traits > OutputIterator CGAL_maximum_inscribed_k_gon_2( RandomAccessIC_point points_begin, RandomAccessIC_point points_end, int left_index, int right_index, RandomAccessIC_int left_c_begin, RandomAccessIC_int left_c_end, RandomAccessIC_int right_c_begin, RandomAccessIC_int right_c_end, int k, typename Traits::FT& max_area, OutputIterator o, const Traits& t) // // preconditions: // -------------- // * Traits fulfills the requirements for an extremal polygon // traits class // * the range [points_begin, points_end) of size n > 0 // describes the vertices of a convex polygon $P$ // enumerated clock- or counterclockwise // * value_type of RandomAccessIC_point is Traits::Point // * value_type of RandomAccessIC_int is int // * OutputIterator accepts int as value type // * 0 <= left_index <= right_index < |points_end - points_begin| // * |left_c_end - left_c_begin| == |right_c_end - right_c_begin| == k - 1 // * [left_c_begin, left_c_end) resp. [right_c_begin, right_c_end) // describe two subpolygons $P_l$ resp $P_r$ of $P$ by giving // the indices of its vertices relative to points_begin and // for any 0 <= i < k - 1: // left_c_begin[i] <= right_c_begin[i] // * k >= t.min_k() // // functionality: // -------------- // computes maximum (as specified by t) inscribed k-gon $P_k$ // of the polygon $P$, // * that is rooted at one of the vertices [points_begin[left_index], // points_begin[right_index]] and // * interleaves with both $P_l$ and $P_r$, // sets max_area to its associated value (as specified by t), // writes the indices (relative to points_begin) // of $P_k$'s vertices to o and // returns the past-the-end iterator of that sequence. { // typedefs typedef typename Traits::FT FT; typedef std::vector< int > Index_cont; using std::copy; // check preconditions: CGAL_optimisation_precondition( k >= t.min_k()); CGAL_optimisation_precondition( left_index <= right_index); CGAL_optimisation_precondition( left_index >= 0); CGAL_optimisation_precondition( right_index >= 0); CGAL_optimisation_precondition_code( int number_of_points( iterator_distance( points_begin, points_end));) CGAL_optimisation_precondition( left_index < number_of_points); CGAL_optimisation_precondition( right_index < number_of_points); CGAL_optimisation_precondition( iterator_distance( left_c_begin, left_c_end) == k - 1); CGAL_optimisation_precondition( iterator_distance( right_c_begin, right_c_end) == k - 1); CGAL_optimisation_expensive_precondition_code( for ( int i( 0); i < k - 1; ++i) { CGAL_optimisation_expensive_precondition( left_c_begin[i] >= 0); CGAL_optimisation_expensive_precondition( right_c_begin[i] >= 0); CGAL_optimisation_expensive_precondition( left_c_begin[i] < number_of_points); CGAL_optimisation_expensive_precondition( right_c_begin[i] < number_of_points); CGAL_optimisation_expensive_precondition( left_c_begin[i] <= right_c_begin[i]); }) int middle_index( (left_index + right_index) >> 1); Index_cont P_m( k); FT area_middle; CGAL_maximum_inscribed_rooted_k_gon_2( points_begin, points_end, middle_index, left_c_begin, left_c_end, right_c_begin, right_c_end, area_middle, P_m.rbegin(), t); CGAL_optimisation_assertion( P_m[0] == middle_index); // left recursive branch: FT area_left( 0); Index_cont P_l( k); if ( left_index < middle_index) { CGAL_maximum_inscribed_k_gon_2( points_begin, points_end, left_index, middle_index - 1, left_c_begin, left_c_end, P_m.begin() + 1, P_m.end(), k, area_left, P_l.rbegin(), t); } // if ( left_index < middle_index) // right recursive branch: FT area_right( 0); Index_cont P_r( k); if ( right_index > middle_index) { CGAL_maximum_inscribed_k_gon_2( points_begin, points_end, middle_index + 1, right_index, P_m.begin() + 1, P_m.end(), right_c_begin, right_c_end, k, area_right, P_r.rbegin(), t); } // if ( right_index > middle_index) if ( area_left > area_right) if ( area_left > area_middle) { // left is maximum max_area = area_left; copy( P_l.begin(), P_l.end(), o); } else { // middle is maximum max_area = area_middle; copy( P_m.begin(), P_m.end(), o); } else if ( area_right > area_middle) { // right is maximum max_area = area_right; copy( P_r.begin(), P_r.end(), o); } else { // middle is maximum max_area = area_middle; copy( P_m.begin(), P_m.end(), o); } return o; } // CGAL_maximum_inscribed_k_gon_2( ... ) CGAL_END_NAMESPACE #endif // ! (CGAL_EXTREMAL_POLYGON_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iterator_project.h0000644000175000017500000001315711344301500030517 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iterator_project.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_ITERATOR_PROJECT_H #define CGAL_ITERATOR_PROJECT_H 1 CGAL_BEGIN_NAMESPACE // Relies on iterator traits. Quite simplified compared to earlier version. // The pointer type and the reference type in the Iterator_project // are based on the value type from the projector, but the base iterator // determines whether they are const or mutable. The following template // class and its partial specialization helps creating the derived types. // If T === T1 return R1 else return R2 template struct I_TYPE_MATCH_IF { typedef R2 Result; }; // else clause template struct I_TYPE_MATCH_IF { typedef R1 Result; }; // then clause // keep 4 dummy template parameters around for backwards compatibility template < class I, class Fct, class D1 = int, class D2 = int, class D3 = int, class D4 = int > class Iterator_project { protected: I nt; // The internal iterator. public: typedef Iterator_project Self; typedef I Iterator; // base iterator typedef std::iterator_traits traits; typedef typename traits::difference_type difference_type; typedef typename traits::iterator_category iterator_category; typedef typename traits::value_type base_value_type; typedef typename traits::pointer base_pointer; typedef typename traits::reference base_reference; typedef typename Fct::argument_type argument_type; typedef typename Fct::result_type value_type; // Use I_TYPE_MATCH_IF to find correct pointer and reference type. typedef I_TYPE_MATCH_IF< base_reference, const base_value_type &, const value_type &, value_type &> Match1; typedef typename Match1::Result reference; typedef I_TYPE_MATCH_IF< base_pointer, const base_value_type *, const value_type *, value_type *> Match2; typedef typename Match2::Result pointer; // CREATION // -------- Iterator_project() {} Iterator_project( I j) : nt(j) {} // make two iterators assignable if the underlying iterators are template Iterator_project( const Iterator_project& i2) : nt( i2.current_iterator()) {} template Self& operator= ( const Iterator_project& i2) { nt = i2.current_iterator(); return *this; } // OPERATIONS Forward Category // --------------------------- Iterator current_iterator() const { return nt;} pointer ptr() const { Fct fct; return &(fct(*nt)); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator* () const { return *ptr(); } pointer operator->() const { return ptr(); } Self& operator++() { ++nt; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self& operator+=( difference_type n) { nt += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator< ( const Self& i) const { return ( nt < i.nt); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; template < class Dist, class Fct, class I, class D1, class D2, class D3, class D4> inline Iterator_project operator+( Dist n, Iterator_project i) { return i += n; } CGAL_END_NAMESPACE #endif // CGAL_ITERATOR_PROJECT_H // // EOF // ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_conformer_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_conforme0000644000175000017500000001531111344301501031455 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_conformer_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_TRIANGULATION_CONFORMER_2_H #define CGAL_TRIANGULATION_CONFORMER_2_H #include namespace CGAL { template class Triangulation_conformer_2 { typedef typename Tr::Finite_edges_iterator Finite_edges_iterator; typedef typename Tr::Vertex_handle Vertex_handle; typedef Mesh_2::Refine_edges_with_clusters > Edges_level_Gabriel; typedef Mesh_2::Refine_edges_with_clusters > Edges_level_Delaunay; protected: /** \name INITIALIZED */ enum Initialization { NONE, /**< \c this is not initialized. */ CLUSTERS, /**< \c this clusters are initialized. */ DELAUNAY, /**< \c this has been \e Delaunay-initialized. */ GABRIEL /**< \c this has been \e Gabriel-initialized. */ }; // --- PROTECTED DATAS --- Initialization initialized; Tr& tr; Null_mesher_level null_level; Null_mesh_visitor null_visitor; Mesh_2::Clusters clusters; Edges_level_Gabriel edges_level_Gabriel; Edges_level_Delaunay edges_level_Delaunay; public: /** \name CONSTRUCTORS */ Triangulation_conformer_2(Tr& tr_) : initialized(NONE), tr(tr_), null_level(), null_visitor(), clusters(tr_), edges_level_Gabriel(tr, clusters, null_level), edges_level_Delaunay(tr, clusters, null_level) { } private: /** \name CHECKING METHODS*/ template bool is_conforming_XXX(Is_locally_conforming is_locally_conforming) const { for(Finite_edges_iterator ei = tr.finite_edges_begin(); ei != tr.finite_edges_end(); ++ei) if(ei->first->is_constrained(ei->second) && !is_locally_conform(this, ei->first, ei->second) ) return false; return true; } public: /** \name ACCESS TO CLUSTERS */ typedef typename Mesh_2::Clusters::Cluster_vertices_iterator Cluster_vertices_iterator; typedef typename Mesh_2::Clusters::Vertices_in_cluster_iterator Vertices_in_cluster_iterator; public: /** \name ACCESS FUNCTIONS */ /** Access to the private initialized member data. */ //@{ void set_initialized(Initialization init) { initialized = init; } Initialization get_initialized() const { return initialized; } //@} int number_of_constrained_edges() { int nedges = 0; for(typename Tr::Finite_edges_iterator eit = tr.finite_edges_begin(); eit != tr.finite_edges_end(); ++eit) if(eit->first->is_constrained(eit->second)) ++nedges; return nedges; } int number_of_clusters_vertices() const { return clusters.size(); } Cluster_vertices_iterator clusters_vertices_begin() const { return clusters.clusters_vertices_begin(); } Cluster_vertices_iterator clusters_vertices_end() const { return clusters.clusters_vertices_end(); } unsigned int number_of_clusters_at_vertex(const Vertex_handle& vh) { return clusters.number_of_clusters_at_vertex(vh); } // returns the sequence of vertices bellonging to the n-th cluster of vh std::pair vertices_in_cluster_sequence(const Vertex_handle& vh, const unsigned int n) { return clusters.vertices_in_cluster_sequence(); } public: /** \name CHECKING METHODS */ bool is_conforming_Delaunay() { typedef typename Mesh_2::Is_locally_conforming_Delaunay Is_loc_conf; return is_conforming_XXX(Is_loc_conf()); } bool is_conforming_Gabriel() { typedef typename Mesh_2::Is_locally_conforming_Gabriel Is_loc_conf; return is_conforming_XXX(Is_loc_conf()); } /** \name CONFORMING FUNCTIONS */ void make_conforming_Delaunay() { if(initialized!=DELAUNAY) init_Delaunay(); edges_level_Delaunay.refine(null_visitor); } void make_conforming_Gabriel() { if(initialized!=GABRIEL) init_Gabriel(); edges_level_Gabriel.refine(null_visitor); } /** \name STEP BY STEP FUNCTIONS */ // Note: step by step functions are not efficient at all! private: void init_clusters() { if(initialized == NONE) clusters.create_clusters(); initialized = CLUSTERS; } public: /** Initializes the data structures (The call of this function is REQUIRED before any step by step operation). */ //@{ void init_Delaunay() { init_clusters(); initialized = DELAUNAY; edges_level_Delaunay.scan_triangulation(); } void init_Gabriel() { init_clusters(); initialized = GABRIEL; edges_level_Gabriel.scan_triangulation(); } //@} /** Tells if all constrained edges are conformed. */ bool is_conforming_done() // This function cannot be "const" because, as edges_to_be_conformed is // filtred, its empty() method is not const. { return ( edges_level_Gabriel.no_longer_element_to_refine() && edges_level_Delaunay.no_longer_element_to_refine() ); } /** Execute on step of the algorithm. init_XXX() should have been called before. */ //@{ bool try_one_step_conforming_Delaunay() { return edges_level_Delaunay.one_step(null_visitor); } bool try_one_step_conforming_Gabriel() { return edges_level_Gabriel.one_step(null_visitor); } bool step_by_step_conforming_Delaunay() { return edges_level_Delaunay.try_to_insert_one_point(null_visitor); } bool step_by_step_conforming_Gabriel() { return edges_level_Gabriel.try_to_insert_one_point(null_visitor); } //@} }; // end Triangulation_conformer_2 // --- GLOBAL FUNCTIONS --- template void make_conforming_Gabriel_2(Tr& t) { typedef Triangulation_conformer_2 Conform; Conform conform(t); conform.make_conforming_Gabriel(); } template void make_conforming_Delaunay_2(Tr& t) { typedef Triangulation_conformer_2 Conform; Conform conform(t); conform.make_conforming_Delaunay(); } } // end namespace CGAL #endif // CGAL_TRIANGULATION_CONFORMER_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vector_3.h0000644000175000017500000000537311344301501026666 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Vector_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_VECTOR_3_H #define CGAL_VECTOR_3_H #include CGAL_BEGIN_NAMESPACE template class Vector_3 : public R_::Kernel_base::Vector_3 { typedef typename R_::RT RT; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Point_3 Point_3; typedef typename R_::Kernel_base::Vector_3 RVector_3; public: typedef R_ R; Vector_3() {} Vector_3(const Point_3& a, const Point_3& b) : RVector_3(a, b) {} Vector_3(const Segment_3& s) : RVector_3(s) {} Vector_3(const Ray_3& r) : RVector_3(r) {} Vector_3(const Line_3& l) : RVector_3(l) {} Vector_3(const RVector_3& v) : RVector_3(v) {} Vector_3(const Null_vector& v) : RVector_3(v) {} Vector_3(const RT& x, const RT& y, const RT& z) : RVector_3(x, y, z) {} Vector_3(const RT& x, const RT& y, const RT& z, const RT& w) : RVector_3(x, y, z, w) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_VECTOR_3 template < class R > std::ostream& operator<<(std::ostream& os, const Vector_3& v) { typedef typename R::Kernel_base::Vector_3 RVector_3; return os << static_cast(v); } #endif // CGAL_NO_OSTREAM_INSERT_VECTOR_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_VECTOR_3 template < class R > std::istream& operator>>(std::istream& is, Vector_3& p) { typedef typename R::Kernel_base::Vector_3 RVector_3; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_VECTOR_3 CGAL_END_NAMESPACE #endif // CGAL_VECTOR_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Counted_number.h0000644000175000017500000001772411344301500030155 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Counted_number.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_COUNTED_NUMBER_H #define CGAL_COUNTED_NUMBER_H #include #include #include CGAL_BEGIN_NAMESPACE template class Counted_number { static unsigned long s_neg_count, s_add_count, s_sub_count, s_mul_count, s_div_count, s_sqrt_count, s_eq_count, s_comp_count ; NT m_rep; public: static void reset() { s_neg_count=0; s_add_count=0; s_sub_count=0; s_mul_count=0; s_div_count=0; s_sqrt_count=0; s_eq_count=0; s_comp_count = 0; } static void inc_neg_count() {++s_neg_count;} static void inc_add_count() {++s_add_count;} static void inc_sub_count() {++s_sub_count;} static void inc_mul_count() {++s_mul_count;} static void inc_div_count() {++s_div_count;} static void inc_sqrt_count() {++s_sqrt_count;} static void inc_eq_count() {++s_eq_count;} static void inc_comp_count() {++s_comp_count;} static unsigned long neg_count() {return s_neg_count;} static unsigned long add_count() {return s_add_count;} static unsigned long sub_count() {return s_sub_count;} static unsigned long mul_count() {return s_mul_count;} static unsigned long div_count() {return s_div_count;} static unsigned long sqrt_count() {return s_sqrt_count;} static unsigned long eq_count() {return s_eq_count;} static unsigned long comp_count() {return s_comp_count;} static unsigned long count() { return s_neg_count + s_add_count + s_sub_count + s_mul_count + s_div_count + s_sqrt_count + s_eq_count + s_comp_count; } static void report(std::ostream &os); NT rep() const {return m_rep;} Counted_number() {} explicit Counted_number(int n) :m_rep(n){} explicit Counted_number(NT n) :m_rep(n){} Counted_number operator-() const {inc_neg_count();return Counted_number(-m_rep);} Counted_number const & operator+=(Counted_number const &n) { inc_add_count(); m_rep += n.m_rep; return *this;} Counted_number const & operator-=(Counted_number const &n) {inc_sub_count(); m_rep -= n.m_rep; return *this;} Counted_number const & operator*=(Counted_number const &n) {inc_mul_count(); m_rep *= n.m_rep; return *this;} Counted_number const & operator/=(Counted_number const &n) {inc_div_count(); m_rep /= n.m_rep; return *this;} typedef typename Number_type_traits::Has_gcd Has_gcd; typedef typename Number_type_traits::Has_division Has_division; typedef typename Number_type_traits::Has_sqrt Has_sqrt; typedef typename Number_type_traits::Has_exact_sqrt Has_exact_sqrt; typedef typename Number_type_traits::Has_exact_division Has_exact_division; typedef typename Number_type_traits::Has_exact_ring_operations Has_exact_ring_operations; }; template unsigned long Counted_number::s_neg_count=0; template unsigned long Counted_number::s_add_count=0; template unsigned long Counted_number::s_sub_count=0; template unsigned long Counted_number::s_mul_count=0; template unsigned long Counted_number::s_div_count=0; template unsigned long Counted_number::s_sqrt_count=0; template unsigned long Counted_number::s_eq_count=0; template unsigned long Counted_number::s_comp_count=0; template Counted_number operator+(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_add_count(); return Counted_number(n1.rep() + n2.rep()); } template Counted_number operator-(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_sub_count(); return Counted_number(n1.rep() - n2.rep()); } template Counted_number operator*(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_mul_count(); return Counted_number(n1.rep() * n2.rep()); } template Counted_number operator/(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_div_count(); return Counted_number(n1.rep() / n2.rep()); } template Counted_number sqrt(Counted_number const &n1) { Counted_number::inc_sqrt_count(); return Counted_number(sqrt(n1.rep())); } template bool operator==(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_eq_count(); return (n1.rep() == n2.rep()); } template bool operator!=(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_eq_count(); return (n1.rep() != n2.rep()); } template bool operator<(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_comp_count(); return (n1.rep() < n2.rep()); } template bool operator>(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_comp_count(); return (n1.rep() > n2.rep()); } template bool operator<=(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_comp_count(); return (n1.rep() <= n2.rep()); } template bool operator>=(Counted_number const &n1, Counted_number const &n2) { Counted_number::inc_comp_count(); return (n1.rep() >= n2.rep()); } template inline double to_double(Counted_number n) { return to_double(n.rep()); } template inline bool is_finite(Counted_number n) { return is_finite(n.rep()); } template inline bool is_valid(Counted_number n) { return is_valid(n.rep()); } template void Counted_number::report(std::ostream &os) { os << count() << " operations\n"; if (neg_count() > 0) os << " " << neg_count() << " negations\n"; if (add_count() > 0) os << " " << add_count() << " additions\n"; if (sub_count() > 0) os << " " << sub_count() << " subtractions\n"; if (mul_count() > 0) os << " " << mul_count() << " multiplications\n"; if (div_count() > 0) os << " " << div_count() << " divisions\n"; if (sqrt_count() > 0) os << " " << sqrt_count() << " square roots\n"; if (eq_count() > 0) os << " " << eq_count() << " equality tests\n"; if (comp_count() > 0) os << " " << comp_count() << " comparisons\n"; } template inline io_Operator io_tag(Counted_number const &n) { return io_tag(n.rep());} template std::ostream& operator<<(std::ostream &os, Counted_number const &n) { return os << n.rep(); } template std::istream& operator>>(std::istream &is, Counted_number &n) { NT num; is >> num; if (is) n = Counted_number(num); return is; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_remove_tds_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_remove_tds_3.0000644000175000017500000002454711344301500031250 0ustar debiandebian// Copyright (c) 2001 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_remove_tds_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Monique Teillaud #ifndef CGAL_DELAUNAY_REMOVE_TDS_3_H #define CGAL_DELAUNAY_REMOVE_TDS_3_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Should this be documented as a Triangulation_ds_vertex_base_with_info_2 ? template < class I, class Vb = Triangulation_ds_vertex_base_2<> > class Delaunay_remove_tds_vertex_3_2 : public Vb { I _info; public : template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Delaunay_remove_tds_vertex_3_2 Other; }; void set_info(const I &info) { _info = info; } const I & info() const { return _info; } }; /* We derive the face class, because we need additional pointers to a successor and predecessor. We want to change the order to avoid looking at faces too often. When we make an operation (flip of an edge / removal of a vertex) we mark the adjacent four / three edges and move them right after the current face of the traversal. As they are marked they must be considered later, and no faces with unmarked edges are traversed to reach them. */ template < class I, class Fb = Triangulation_ds_face_base_2<> > class Delaunay_remove_tds_face_3_2 : public Fb { public: typedef typename Fb::Face_handle Face_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Fb2; typedef Delaunay_remove_tds_face_3_2 Other; }; void set_info(const I &i) { inf = i; } const I& info() const { return inf; } // Handling the doubly connected list of faces // These functions should not be public, but private // and the tds should be declared friend. // Returns the sucessor Face_handle n() const {return _n;} // Returns the predecessor Face_handle p() const {return _p;} void set_p(Face_handle f) {_p = f;} void set_n(Face_handle f) {_n = f;} private: // Dirty, so we should avoid it in another way Face_handle handle() const { Face_handle n = this->neighbor(0); int i = Triangulation_utils_3::ccw(n->index(this->vertex(1))); return n->neighbor(i); } protected: // Remove this face from the list void remove_from_list() { // Q: Can't we be sure that there is always a predecessor // and successor?? This might pose a problem when we // remove the final tetrahedron, that is we have to // check whether that one still performs the // Surface::remove_vertex_3() method if(&*_p) _p->set_n(_n); if(&*_n) _n->set_p(_p); } public: // Remove neighbor cw(i) and ccw(i) from the list void remove_neighbors_from_list(int i) { Face_handle n = this->neighbor(Triangulation_utils_3::cw(i)); n->remove_from_list(); n = this->neighbor(Triangulation_utils_3::ccw(i)); n->remove_from_list(); } // Marks edge i, that is marks one of the two half-edges, // namely the one in the face with the smaller address, // of the faces this and neighbor(i) // // Additionally, this face is then moved right behind face h, // because it is a candidate for an ear. void mark_edge(int i, Face_handle h) { Face_handle n = this->neighbor(i); if (n < handle()) { n->mark_halfedge(n->index(handle())); unmark_halfedge(i); h->move_after_this(n); } else { n->unmark_halfedge(n->index(handle())); mark_halfedge(i); if (h != handle()) h->move_after_this(handle()); } } // unmarks the two halfedges void unmark_edge(int i) { Face_handle n = this->neighbor(i); unmark_halfedge(i); int fi = n->index(handle()); n->unmark_halfedge(fi); } // marks all edges adjacent to the face void mark_adjacent_edges() { for(int i = 0; i < 3; i++) mark_edge(i, handle()); } bool is_halfedge_marked(int i) const { return _edge[i]; } void set_edge(int i, bool b) { _edge[i] = b; } protected: // Move face f after this. void move_after_this(Face_handle f) { if (_n == f) return; Face_handle p = f->p(); Face_handle n = f->n(); p->set_n(n); n->set_p(p); n = _n; _n = f; f->set_n(n); n->set_p(f); f->set_p(handle()); } void unmark_halfedge(int i) { _edge[i] = false; } void mark_halfedge(int i) { _edge[i] = true; } I inf; Face_handle _p, _n; bool _edge[3]; }; // This class is used to represent the boundary of a hole in a polyhedron. // It only implements a constructor, the rest is inherited template class Delaunay_remove_tds_3_2 : public Triangulation_data_structure_2< Delaunay_remove_tds_vertex_3_2, Delaunay_remove_tds_face_3_2 > { public: typedef typename T::Facet Facet; typedef typename T::Cell_handle Cell_handle; typedef typename T::Vertex_handle Vertex_handle; private: typedef Triangulation_data_structure_2< Delaunay_remove_tds_vertex_3_2, Delaunay_remove_tds_face_3_2 > TDS_2; public: typedef typename TDS_2::Face_iterator Face_iterator; typedef typename TDS_2::Face Face_3_2; typedef typename TDS_2::Vertex_handle Vertex_handle_3_2; typedef typename TDS_2::Face_handle Face_handle_3_2; using TDS_2::create_face; using TDS_2::create_vertex; using TDS_2::cw; using TDS_2::ccw; using TDS_2::set_dimension; using TDS_2::faces_begin; using TDS_2::faces_end; private: struct Halfedge : public std::pair { typedef std::pair Pair; Face_handle_3_2 third; int fourth; Halfedge(Vertex_handle_3_2 a, Vertex_handle_3_2 b, Face_handle_3_2 c, int d) : Pair(a, b), third(c), fourth(d) {} }; public: Delaunay_remove_tds_3_2(const std::vector & boundhole ); void remove_degree_3(Vertex_handle_3_2 v, Face_handle_3_2 f) { int i = f->index(v); // As f->neighbor(cw(i)) and f->neighbor(ccw(i)) will be removed, // we first remove it from the list we maintain. f->remove_neighbors_from_list(i); // we are ready to call the method of the base class TDS_2::remove_degree_3(v,f); } }; template Delaunay_remove_tds_3_2:: Delaunay_remove_tds_3_2(const std::vector & boundhole) { // FIXME : similar to operator>>(), isn't it ? Should we try to factorize ? std::vector halfedges; halfedges.reserve(3*boundhole.size()); std::map vertex_map; typename std::map::iterator map_it; for(typename std::vector::const_iterator fit = boundhole.begin(); fit != boundhole.end(); ++fit) { Face_handle_3_2 f = create_face(); Facet facet = *fit; Cell_handle h = facet.first; int k = facet.second; // All 2d faces must have the same orientation, // so we need a mapping from 3d to 2d indices. // Furthermore the triangles are seen "from the other side" int i0 = 0, i1 = 2, i2 = 3; switch (k) { case 0: i0 = 1; break; case 1: i1 = 3; i2 = 2; break; case 2: i1 = 1; break; default: i2 = 1; } // We create as many 2d vertices as there are 3d vertices. Vertex_handle_3_2 v0, v1, v2; Vertex_handle w0 = h->vertex(i0); if((map_it = vertex_map.find(w0)) == vertex_map.end()) { v0 = create_vertex(); v0->set_info(w0); vertex_map.insert(std::make_pair(w0, v0)); } else { v0 = map_it->second; } Vertex_handle w1 = h->vertex(i1); if((map_it = vertex_map.find(w1)) == vertex_map.end()) { v1 = create_vertex(); v1->set_info(w1); vertex_map.insert(std::make_pair(w1, v1)); } else { v1 = map_it->second; } Vertex_handle w2 = h->vertex(i2); if((map_it = vertex_map.find(w2)) == vertex_map.end()) { v2 = create_vertex(); v2->set_info(w2); vertex_map.insert(std::make_pair(w2, v2)); } else { v2 = map_it->second; } v0->set_face(f); v1->set_face(f); v2->set_face(f); f->set_vertices(v0, v1, v2); f->set_info(facet); for(int j = 0; j < 3; j++) { Vertex_handle_3_2 v = f->vertex(j); Vertex_handle_3_2 w = f->vertex(cw(j)); halfedges.push_back((v < w) ? Halfedge(v, w, f, ccw(j)) : Halfedge(w, v, f, ccw(j))); } } std::sort(halfedges.begin(), halfedges.end()); // The halfedges that are opposite to each other are neighbors // in the sorted list. for(typename std::vector::iterator it = halfedges.begin(); it != halfedges.end(); ++it) { Halfedge e1 = *it; ++it; Halfedge e2 = *it; e1.third->set_neighbor(e1.fourth, e2.third); e2.third->set_neighbor(e2.fourth, e1.third); } // The TDS cannot know that it is 2D because we constructed it // with advanced functions set_dimension(2); Face_iterator fit2 = faces_begin(); Face_handle_3_2 first = fit2, f = fit2; for(int i = 0; i < 3; i++) { // we mark an edge only on one side f->set_edge(i, f < f->neighbor(i)); } for(++fit2; fit2 != faces_end(); ++fit2) { f->set_n(fit2); fit2->set_p(f); f = fit2; for(int i = 0; i < 3; i++) { // we mark an edge only on one side f->set_edge(i, f < f->neighbor(i)); } } // f points to the last face f->set_n(first); first->set_p(f); } CGAL_END_NAMESPACE #endif // CGAL_DELAUNAY_REMOVE_TDS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Handle_for.h0000644000175000017500000001370611344301500027241 0ustar debiandebian// Copyright (c) 1999,2001,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Handle_for.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion #ifndef CGAL_HANDLE_FOR_H #define CGAL_HANDLE_FOR_H #include #include CGAL_BEGIN_NAMESPACE template class Handle_for { // Wrapper that adds the reference counter. struct RefCounted { T t; unsigned int count; }; typedef typename Alloc::template rebind::other Allocator; typedef typename Allocator::pointer pointer; static Allocator allocator; pointer ptr_; public: typedef T element_type; Handle_for() { // Use a unique static instance to speed up default construction. // It's a static variable of a function instead of the class to // avoid the requirement of a default constructor for T(). static const Handle_for def = Handle_for(T()); ptr_ = def.ptr_; ++(ptr_->count); } Handle_for(const Handle_for& h) : ptr_(h.ptr_) { ++(ptr_->count); } // TODO : // We should also think about providing template constructors in // order to forward the functionality of T to Handle_for without // the need to an intermediate copy. // Currently it's not working, because some places use conversions. Handle_for(const T& t) : ptr_(allocator.allocate(1)) { new (&(ptr_->t)) T(t); ptr_->count = 1; } /* I comment this one for now, since it's preventing the automatic conversions to take place. We'll see if it's a problem later. template < typename T1 > Handle_for(const T1& t1) : ptr_(allocator.allocate(1)) { new (&(ptr_->t)) T(t1); ptr_->count = 1; } */ template < typename T1, typename T2 > Handle_for(const T1& t1, const T2& t2) : ptr_(allocator.allocate(1)) { new (&(ptr_->t)) T(t1, t2); ptr_->count = 1; } template < typename T1, typename T2, typename T3 > Handle_for(const T1& t1, const T2& t2, const T3& t3) : ptr_(allocator.allocate(1)) { new (&(ptr_->t)) T(t1, t2, t3); ptr_->count = 1; } template < typename T1, typename T2, typename T3, typename T4 > Handle_for(const T1& t1, const T2& t2, const T3& t3, const T4& t4) : ptr_(allocator.allocate(1)) { new (&(ptr_->t)) T(t1, t2, t3, t4); ptr_->count = 1; } ~Handle_for() { if (! is_shared() ) { allocator.destroy( ptr_); allocator.deallocate( ptr_, 1); } else --(ptr_->count); } Handle_for& operator=(const Handle_for& h) { Handle_for tmp = h; swap(tmp); return *this; } Handle_for& operator=(const T &t) { if (is_shared()) *this = Handle_for(t); else ptr_->t = t; return *this; } void initialize_with(const T& t) { // kept for backward compatibility. Use operator=(t) instead. *this = t; } bool identical(const Handle_for& h) const { return ptr_ == h.ptr_; } long int id() const { return reinterpret_cast(&*ptr_); } // Ptr() is the "public" access to the pointer to the object. // The non-const version asserts that the instance is not shared. const T * Ptr() const { return &(ptr_->t); } /* // The assertion triggers in a couple of places, so I comment it for now. T * Ptr() { CGAL_assertion(!is_shared()); return &(ptr_->t); } */ bool is_shared() const { return ptr_->count > 1; } void swap(Handle_for& h) { std::swap(ptr_, h.ptr_); } protected: void copy_on_write() { if ( is_shared() ) { pointer tmp_ptr = allocator.allocate(1); new (&(tmp_ptr->t)) T(ptr_->t); tmp_ptr->count = 1; --(ptr_->count); ptr_ = tmp_ptr; } } // ptr() is the protected access to the pointer. Both const and non-const. // Redundant with Ptr(). T * ptr() { return &(ptr_->t); } const T * ptr() const { return &(ptr_->t); } }; template typename Handle_for::Allocator Handle_for::allocator; template inline void swap(Handle_for &h1, Handle_for &h2) { h1.swap(h2); } template inline bool identical(const Handle_for &h1, const Handle_for &h2) { return h1.identical(h2); } template inline bool identical(const T &t1, const T &t2) { return &t1 == &t2; } template inline const T& get(const Handle_for &h) { return *(h.Ptr()); } template inline const T& get(const T &t) { return t; } CGAL_END_NAMESPACE #endif // CGAL_HANDLE_FOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iterator_list.h0000644000175000017500000000231111344301500030012 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iterator_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_ITERATOR_LIST_H #define CGAL_ITERATOR_LIST_H #include namespace CGAL { template class Iterator_list : public std::list { public: Iterator_list() {} Iterator_list(Iterator first, Iterator beyond) { if (first == beyond) return; for (Iterator current = first; current != beyond; current++) { push_back(current); } } }; } #endif // CGAL_ITERATOR_LIST_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Quotient.h0000644000175000017500000004223211344301500027004 0ustar debiandebian// Copyright (c) 1999-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Quotient.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion // The template class Quotient is based on the LEDA class // leda_rational written by Stefan Naeher and Christian Uhrig. // It is basically a templated version with restricted functionality // of the version of rational in LEDA release 3.3. // The modification was done by Stefan.Schirra@mpi-sb.mpg.de // The include is done before the protect macro on purpose, because // of a cyclic dependency. #include #ifndef CGAL_QUOTIENT_H #define CGAL_QUOTIENT_H #include #ifndef CGAL_CFG_NO_LOCALE # include #else # include #endif #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { // Mini helper to prevent clashes when NT == int. template < typename T > struct Int_if_not_int { typedef int type; }; template <> struct Int_if_not_int { struct type{}; }; } // namespace CGALi #define CGAL_int(T) typename CGALi::Int_if_not_int::type // Simplify the quotient numerator/denominator. // Currently the default template doesn't do anything. // This function is not documented as a number type requirement for now. template < typename NT > inline void simplify_quotient(NT &, NT &) {} template class Quotient { public: typedef NT_ NT; typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef typename Number_type_traits::Has_sqrt Has_sqrt; typedef Tag_true Has_exact_division; typedef typename Number_type_traits::Has_exact_sqrt Has_exact_sqrt; typedef typename Number_type_traits::Has_exact_ring_operations Has_exact_ring_operations; Quotient() : num(0), den(1) {} template Quotient(const T& n) : num(n), den(1) {} template Quotient(const T1& n, const T2& d) : num(n), den(d) { CGAL_precondition( d != 0 ); } Quotient& operator+= (const Quotient& r); Quotient& operator-= (const Quotient& r); Quotient& operator*= (const Quotient& r); Quotient& operator/= (const Quotient& r); Quotient& operator+= (const NT& r); Quotient& operator-= (const NT& r); Quotient& operator*= (const NT& r); Quotient& operator/= (const NT& r); Quotient& operator+= (const CGAL_int(NT)& r); Quotient& operator-= (const CGAL_int(NT)& r); Quotient& operator*= (const CGAL_int(NT)& r); Quotient& operator/= (const CGAL_int(NT)& r); Quotient& normalize(); const NT& numerator() const { return num; } const NT& denominator() const { return den; } void swap(Quotient &q) { using std::swap; swap(num, q.num); swap(den, q.den); } public: NT num; NT den; }; template inline void swap(Quotient &p, Quotient &q) { p.swap(q); } template Quotient sqrt(const Quotient &q) { CGAL_precondition(q > 0); return Quotient(CGAL_NTS sqrt(q.numerator()*q.denominator()), q.denominator()); } template CGAL_MEDIUM_INLINE Quotient& Quotient::normalize() { if (num == den) { num = den = 1; return *this; } if (-num == den) { num = -1; den = 1; return *this; } NT ggt = gcd(num, den); if (ggt != 1 ) { num /= ggt; den /= ggt; } return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator+= (const Quotient& r) { num = num * r.den + r.num * den; den *= r.den; simplify_quotient(num, den); return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator-= (const Quotient& r) { num = num * r.den - r.num * den; den *= r.den; simplify_quotient(num, den); return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator*= (const Quotient& r) { num *= r.num; den *= r.den; simplify_quotient(num, den); return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator/= (const Quotient& r) { CGAL_precondition( r.num != 0 ); num *= r.den; den *= r.num; simplify_quotient(num, den); return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator+= (const NT& r) { num += r * den; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator-= (const NT& r) { num -= r * den; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator*= (const NT& r) { num *= r; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator/= (const NT& r) { CGAL_precondition( r != 0 ); den *= r; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator+= (const CGAL_int(NT)& r) { num += r * den; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator-= (const CGAL_int(NT)& r) { num -= r * den; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator*= (const CGAL_int(NT)& r) { num *= r; return *this; } template CGAL_MEDIUM_INLINE Quotient& Quotient::operator/= (const CGAL_int(NT)& r) { CGAL_precondition( r != 0 ); den *= r; return *this; } template CGAL_MEDIUM_INLINE Comparison_result quotient_cmp(const Quotient& x, const Quotient& y) { // No assumptions on the sign of den are made // code assumes that SMALLER == - 1; CGAL_precondition( SMALLER == static_cast(-1) ); int xsign = CGAL_NTS sign(x.num) * CGAL_NTS sign(x.den) ; int ysign = CGAL_NTS sign(y.num) * CGAL_NTS sign(y.den) ; if (xsign == 0) return static_cast(-ysign); if (ysign == 0) return static_cast(xsign); // now (x != 0) && (y != 0) int diff = xsign - ysign; if (diff == 0) { int msign = CGAL_NTS sign(x.den) * CGAL_NTS sign(y.den); NT leftop = x.num * y.den * msign; NT rightop = y.num * x.den * msign; return CGAL_NTS compare(leftop, rightop); } else { return (xsign < ysign) ? SMALLER : LARGER; } } template inline Comparison_result compare(const Quotient& x, const Quotient& y) { return quotient_cmp(x, y); } template std::ostream& operator<<(std::ostream& s, const Quotient& r) { return s << r.numerator() << "/" << r.denominator(); } template std::istream& operator>>(std::istream& in, Quotient& r) { /* format num/den or simply num */ char c = 0; #ifndef CGAL_CFG_NO_LOCALE while (in.get(c) && std::isspace(c, std::locale::classic() )); #else while (in.get(c) && CGAL_CLIB_STD::isspace(c)); #endif // CGAL_CFG_NO_LOCALE if ( !in ) return in; in.putback(c); NT num; NT den(1); in >> num; #ifndef CGAL_CFG_NO_LOCALE while (in.get(c) && std::isspace(c, std::locale::classic() )); #else while (in.get(c) && CGAL_CLIB_STD::isspace(c)); #endif // CGAL_CFG_NO_LOCALE if (( in ) && ( c == '/')) { #ifndef CGAL_CFG_NO_LOCALE while (in.get(c) && std::isspace(c, std::locale::classic() )); #else while (in.get(c) && CGAL_CLIB_STD::isspace(c)); #endif // CGAL_CFG_NO_LOCALE CGAL_assertion( in ); in.putback(c); in >> den; } else { in.putback(c); if ( in.eof() ) in.clear(); } r = Quotient( num, den); return in; } template inline io_Operator io_tag(const Quotient&) { return io_Operator(); } template CGAL_MEDIUM_INLINE Quotient operator+(const Quotient& x, const Quotient& y) { Quotient z = x; return z += y; } template CGAL_MEDIUM_INLINE Quotient operator-(const Quotient& x, const Quotient& y) { return (Quotient(x) -= y); } template CGAL_MEDIUM_INLINE Quotient operator*(const Quotient& x, const Quotient& y) { Quotient z = x; return z *= y; } template CGAL_MEDIUM_INLINE Quotient operator/(const Quotient& x, const Quotient& y) { Quotient z = x; return z /= y; } template inline Quotient operator-(const Quotient& x) { return Quotient(-x.num,x.den); } template CGAL_MEDIUM_INLINE Quotient operator+(const NT& x, const Quotient& y) { Quotient z(x); return z += y; } template CGAL_MEDIUM_INLINE Quotient operator+(const Quotient& x, const NT& y) { Quotient z = x; return z += y; } template CGAL_MEDIUM_INLINE Quotient operator+(const Quotient& x, const CGAL_int(NT)& y) { Quotient z = x; return z += NT(y); } template CGAL_MEDIUM_INLINE Quotient operator+(const CGAL_int(NT)& x, const Quotient& y) { return y + x; } template CGAL_MEDIUM_INLINE Quotient operator-(const NT& x, const Quotient& y) { Quotient z(x); return z -= y; } template CGAL_MEDIUM_INLINE Quotient operator-(const Quotient& x, const NT& y) { Quotient z = x; return z -= y; } template CGAL_MEDIUM_INLINE Quotient operator-(const Quotient& x, const CGAL_int(NT)& y) { Quotient z = x; return z -= NT(y); } template CGAL_MEDIUM_INLINE Quotient operator-(const CGAL_int(NT)& x, const Quotient& y) { Quotient z = x; return z -= y; } template CGAL_MEDIUM_INLINE Quotient operator*(const NT& x, const Quotient& y) { Quotient z(x); return z *= y; } template CGAL_MEDIUM_INLINE Quotient operator*(const Quotient& x, const NT& y) { Quotient z = x; return z *= y; } template CGAL_MEDIUM_INLINE Quotient operator*(const Quotient& x, const CGAL_int(NT)& y) { Quotient z = x; return z *= NT(y); } template inline Quotient operator*(const CGAL_int(NT)& x, const Quotient& y) { return y*x; } template CGAL_MEDIUM_INLINE Quotient operator/(const NT& x, const Quotient& y) { Quotient z(x) ; return z /= y; } template CGAL_MEDIUM_INLINE Quotient operator/(const Quotient& x, const NT& y) { Quotient z = x; return z /= y; } template CGAL_MEDIUM_INLINE Quotient operator/(const Quotient& x, const CGAL_int(NT)& y) { Quotient z = x; return z /= NT(y); } template CGAL_MEDIUM_INLINE Quotient operator/(const CGAL_int(NT)& x, const Quotient& y) { Quotient z = x; return z /= y; } template CGAL_MEDIUM_INLINE NT quotient_truncation(const Quotient& r) { return (r.num / r.den); } template CGAL_MEDIUM_INLINE bool operator==(const Quotient& x, const Quotient& y) { return x.num * y.den == x.den * y.num; } template CGAL_MEDIUM_INLINE bool operator==(const Quotient& x, const NT& y) { return x.den * y == x.num; } template inline bool operator==(const NT& x, const Quotient& y) { return y == x; } template CGAL_MEDIUM_INLINE bool operator==(const CGAL_int(NT) & x, const Quotient& y) { return y.den * x == y.num; } template inline bool operator==(const Quotient& x, const CGAL_int(NT) & y) { return y == x; } template inline bool operator!=(const Quotient& x, const Quotient& y) { return ! (x == y); } template inline bool operator!=(const Quotient& x, const NT& y) { return ! (x == y); } template inline bool operator!=(const NT& x, const Quotient& y) { return ! (x == y); } template inline bool operator!=(const CGAL_int(NT) & x, const Quotient& y) { return ! (x == y); } template inline bool operator!=(const Quotient& x, const CGAL_int(NT) & y) { return ! (x == y); } template CGAL_MEDIUM_INLINE bool operator<(const Quotient& x, const Quotient& y) { return quotient_cmp(x,y) == SMALLER; } template CGAL_MEDIUM_INLINE bool operator<(const Quotient& x, const NT& y) { return quotient_cmp(x,Quotient(y)) == SMALLER; } template CGAL_MEDIUM_INLINE bool operator<(const NT& x, const Quotient& y) { return quotient_cmp(Quotient(x),y) == SMALLER; } template CGAL_MEDIUM_INLINE bool operator<(const CGAL_int(NT)& x, const Quotient& y) { return quotient_cmp(Quotient(x),y) == SMALLER; } template CGAL_MEDIUM_INLINE bool operator<(const Quotient& x, const CGAL_int(NT)& y) { return quotient_cmp(x,Quotient(y)) == SMALLER; } template inline bool operator>(const Quotient& x, const Quotient& y) { return y < x; } template inline bool operator>(const Quotient& x, const NT& y) { return y < x; } template inline bool operator>(const NT& x, const Quotient& y) { return y < x; } template inline bool operator>(const Quotient& x, const CGAL_int(NT)& y) { return y < x; } template inline bool operator>(const CGAL_int(NT)& x, const Quotient& y) { return y < x; } template inline bool operator<=(const Quotient& x, const Quotient& y) { return ! (y < x); } template inline bool operator<=(const Quotient& x, const NT& y) { return ! (y < x); } template inline bool operator<=(const NT& x, const Quotient& y) { return ! (y < x); } template inline bool operator<=(const Quotient& x, const CGAL_int(NT)& y) { return ! (y < x); } template inline bool operator<=(const CGAL_int(NT)& x, const Quotient& y) { return ! (y < x); } template inline bool operator>=(const Quotient& x, const Quotient& y) { return ! (x < y); } template inline bool operator>=(const Quotient& x, const NT& y) { return ! (x < y); } template inline bool operator>=(const NT& x, const Quotient& y) { return ! (x < y); } template inline bool operator>=(const Quotient& x, const CGAL_int(NT)& y) { return ! (x < y); } template inline bool operator>=(const CGAL_int(NT)& x, const Quotient& y) { return ! (x < y); } template double to_double(const Quotient& q) /* TODO */ { if (q.num == 0 ) return 0; double nd = CGAL_NTS to_double( q.num ); if (q.den == 1 ) return nd; double dd = CGAL_NTS to_double( q.den ); if ( is_finite( q.den ) && is_finite( q.num ) ) return nd/dd; if ( CGAL_NTS abs(q.num) > CGAL_NTS abs(q.den) ) { NT nt_div = q.num / q.den; double divd = CGAL_NTS to_double(nt_div); if ( divd >= CGAL_CLIB_STD::ldexp(1.0,53) ) { return divd; } } if ( CGAL_NTS abs(q.num) < CGAL_NTS abs(q.den) ) { return 1.0 / CGAL_NTS to_double( NT(1) / q ); } return nd/dd; } template std::pair to_interval (const Quotient& z) { Interval_nt<> quot = Interval_nt<>(CGAL_NTS to_interval(z.numerator())) / Interval_nt<>(CGAL_NTS to_interval(z.denominator())); return std::make_pair(quot.inf(), quot.sup()); } template bool is_valid(const Quotient& q) { return is_valid(q.num) && is_valid(q.den); } template bool is_finite(const Quotient& q) { return is_finite(q.num) && is_finite(q.den); } template inline const NT& denominator(const Quotient& q) { return q.den ; } template inline const NT& numerator(const Quotient& q) { return q.num ; } // The min/max are functions are needed since LEDA defines template // min/max functions which clash with std::min/max with ADL. template inline const Quotient& min(const Quotient& p, const Quotient& q) { return std::min(p, q); } template inline const Quotient& max(const Quotient& p, const Quotient& q) { return std::max(p, q); } /* template NT gcd(const NT&, const NT&) { return NT(1); } */ #undef CGAL_int // Rational traits template < class NT > struct Rational_traits< Quotient > { typedef NT RT; RT numerator (const Quotient& r) const { return r.numerator(); } RT denominator (const Quotient& r) const { return r.denominator(); } Quotient make_rational(const RT & n, const RT & d) const { return Quotient(n, d); } }; CGAL_END_NAMESPACE #endif // CGAL_QUOTIENT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/predicates_d.h0000644000175000017500000002162411344301500027624 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/predicates_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_PREDICATES_D_H #define CGAL_PREDICATES_D_H #ifndef NOCGALINCL #include #include #endif CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=predicates_d.man}*/ /*{\Mtext \setopdims{4cm}{2cm}\computewidths \headerline{Linear and affine predicates} For an iterator range |[first,last)| we define |T = tuple [first,last)| as the ordered tuple $(|T[0]|,|T[1]|, \ldots |T[d-1]|)$ where $|T[i]| = |*| |++|^{(i)}|first|$ (the element obtained by $i$ times forwarding the iterator by operator |++| and then dereferencing it to get the value to which it points). We write |d = size [first,last)|. This extends the syntax of random access iterators to input iterators. If we index the tuple as above then we require that $|++|^{(d+1)}|first == last|$. In the following we require the Iterators to be globally of value type |Point_d|. Also if we are handed over an iterator range |[first,last)|, then all points in |T = tuple [first,last)| have the same dimension |dim|. }*/ template OutputIterator barycentric_coordinates( ForwardIterator first, ForwardIterator last, const Point_d& p, OutputIterator result) /*{\Xfunc returns the barycentric coordinates of a point $p \in R^d$ in a affine space of dimension $k$ spanned by the points in |tuple [first,last)|. \precond value type of |ForwardIterator| is |Point_d|, |affinely_independed(first,last)| and |affine_rank(tuple [first,last),p)==k|.}*/ { typename R::Barycentric_coordinates_d coords; return coords(first,last,p,result); } template Orientation orientation(ForwardIterator first, ForwardIterator last) /*{\Mfunc determines the orientation of the points in the tuple |A = tuple [first,last)| where $A$ consists of $d + 1$ points in $d$ - space. This is the sign of the determinant \[ \left\Lvert \begin{array}{cccc} 1 & 1 & 1 & 1 \\ A[0] & A[1] & \dots & A[d] \end{array} \right\Lvert \] where |A[i]| denotes the cartesian coordinate vector of the $i$-th point in $A$. \precond |size [first,last) == d+1| and |A[i].dimension() == d| $\forall 0 \leq i \leq d$ and the value type of |ForwardIterator| is |Point_d|.}*/ { typedef typename std::iterator_traits::value_type PointD; typedef typename PointD::R R; typename R::Orientation_d or_; return or_(first,last); } template Oriented_side side_of_oriented_sphere( ForwardIterator first, ForwardIterator last, const Point_d& x) /*{\Mfuncl determines to which side of the sphere $S$ defined by the points in |A = tuple [first,last)| the point $x$ belongs, where $A$ consists of $d + 1$ points in $d$ - space. The positive side is determined by the positive sign of the determinant \[ \left\Lvert \begin{array}{ccccc} 1 & 1 & 1 & 1 & 1\\ |lift(A[0])| & |lift(A[1])| & \dots & |lift(A[d])| & |lift(x)| \end{array} \right\Lvert \] where for a point $p$ with cartesian coordinates $p_i$ we use |lift(p)| to denote the $d + 1$-dimensional point with cartesian coordinate vector $(p_0, \ldots,p_{d-1},\sum_{0 \le i < d}p_i^2)$. If the points in $A$ are positively oriented then the positive side is the inside of the sphere and the negative side is the outside of the sphere. \precond value type of |ForwardIterator| is |Point_d|.}*/ { typename R::Side_of_oriented_sphere_d side; return side(first,last,x); } template Bounded_side side_of_bounded_sphere( ForwardIterator first, ForwardIterator last, const Point_d &p) /*{\Mfunc determines whether the point |p| lies |ON_BOUNDED_SIDE|, |ON_BOUNDARY|, or |ON_UNBOUNDED_SIDE| of the sphere defined by the points in |A = tuple [first,last)| where $A$ consists of $d+1$ points in $d$-space. \precond value type of |ForwardIterator| is |Point_d| and $|orientation(first,last)| \neq |ZERO|$.}*/ { typename R::Side_of_bounded_sphere_d side; return side(first,last,p); } template bool contained_in_simplex( ForwardIterator first, ForwardIterator last, const Point_d& p) /*{\Mfunc determines whether |p| is contained in the simplex spanned by the points in |A = tuple [first,last)|. |A| may consists of up to $d + 1$ points. \precond value type of |ForwardIterator| is |Point_d| and the points in |A| are affinely independent.}*/ { typename R::Contained_in_simplex_d contained; return contained(first,last,p); } template bool contained_in_affine_hull( ForwardIterator first, ForwardIterator last, const Point_d& p) /*{\Mfunc determines whether $p$ is contained in the affine hull of the points in |A = tuple [first,last)|. \precond value type of |ForwardIterator| is |Point_d|.}*/ { typename R::Contained_in_affine_hull_d contained; return contained(first,last,p); } template int affine_rank(ForwardIterator first, ForwardIterator last) /*{\Mfunc computes the affine rank of the points in |A = tuple [first,last)|. \precond value type of |ForwardIterator| is |Point_d|.}*/ { typedef typename std::iterator_traits::value_type PointD; typedef typename PointD::R R; typename R::Affine_rank_d rank; return rank(first,last); } template bool affinely_independent(ForwardIterator first, ForwardIterator last) /*{\Mfunc decides whether the points in |A = tuple [first,last)| are affinely independent. \precond value type of |ForwardIterator| is |Point_d|.}*/ { typedef typename std::iterator_traits::value_type PointD; typedef typename PointD::R R; typename R::Affinely_independent_d ind; return ind(first,last); } template Comparison_result compare_lexicographically( const Point_d& p1, const Point_d& p2) /*{\Mfunc compares the Cartesian coordiantes of points |p1| and |p2| lexicographically.}*/ { typename R::Compare_lexicographically_d cmp; return cmp(p1,p2); } template bool lexicographically_smaller( const Point_d& p1, const Point_d& p2) /*{\Mfunc returns true iff $|p1| < |p2|$ in the Cartesian lexicographic order of points.}*/ { typename R::Less_lexicographically_d lt; return lt(p1,p2); } template bool lexicographically_smaller_or_equal( const Point_d& p1, const Point_d& p2) /*{\Mfunc returns true iff $|p1| \leq |p2|$ in the Cartesian lexicographic order of points.}*/ { typename R::Less_or_equal_lexicographically_d le; return le(p1,p2); } template bool contained_in_linear_hull( ForwardIterator first, ForwardIterator last, const Vector_d& x) /*{\Mfunc determines whether $x$ is contained in the linear hull of the vectors in |A = tuple [first,last)|. \precond value type of |ForwardIterator| is |Vector_d|.}*/ { typename R::Contained_in_linear_hull_d contained; return contained(first,last,x); } template int linear_rank( ForwardIterator first, ForwardIterator last) /*{\Mfunc computes the linear rank of the vectors in |A = tuple [first,last)|. \precond value type of |ForwardIterator| is |Vector_d|.}*/ { typedef typename std::iterator_traits:: value_type value_type; typedef typename value_type::R R; typename R::Linear_rank_d rank; return rank(first,last); } template bool linearly_independent( ForwardIterator first, ForwardIterator last) /*{\Mfunc decides whether the vectors in $A$ are linearly independent. \precond value type of |ForwardIterator| is |Vector_d|.}*/ { TUPLE_DIM_CHECK(first,last,linearly_independent); typedef typename std::iterator_traits:: value_type value_type; typedef typename value_type::R R; typename R::Linearly_independent_d independent; return independent(first,last); } CGAL_END_NAMESPACE #endif // CGAL_PREDICATES_D_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_2_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_2_traits0000644000175000017500000000650711344301501031403 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_2_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_2_TRAITS_3_H #define CGAL_TRIANGULATION_2_TRAITS_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Compare_yz_3 { public: typedef typename R::Point_3 Point; Comparison_result operator() (Point p, Point q){ Comparison_result r; r = CGAL::compare_y(p,q); if (r == EQUAL) r = CGAL::compare_z(p,q); return r; } }; template class Side_of_oriented_circle_2_3 { // 2d triangulation needs a side_of_oriented_circle // that in fact is a side_of_bounded_circle // meaning that // bounded side of circle = positive side public: typedef typename R::Point_3 Point; typedef typename R::Coplanar_side_of_bounded_circle_3 Side_of_bounded_circle_2_3; Oriented_side operator() (const Point& p, const Point& q, const Point& r, const Point& s) { Side_of_bounded_circle_2_3 side; Bounded_side bs = side(p,q,r,s); return ( bs == ON_UNBOUNDED_SIDE) ? ON_NEGATIVE_SIDE : (bs == ON_BOUNDED_SIDE ) ? ON_POSITIVE_SIDE : ON_ORIENTED_BOUNDARY; } }; template < class R > class Triangulation_2_traits_3 { public: typedef R Rep; typedef typename Rep::Point_3 Point_2; typedef typename Rep::Segment_3 Segment_2; typedef typename Rep::Triangle_3 Triangle_2; typedef typename Rep::Compare_x_3 Compare_x_2; typedef Compare_yz_3 Compare_y_2; typedef typename Rep::Coplanar_orientation_3 Orientation_2; typedef Side_of_oriented_circle_2_3 Side_of_oriented_circle_2; typedef typename Rep::Construct_segment_3 Construct_segment_2; typedef typename Rep::Construct_triangle_3 Construct_triangle_2; // for compatibility with previous versions typedef Point_2 Point; typedef Segment_2 Segment; typedef Triangle_2 Triangle; Compare_x_2 compare_x_2_object() const { return Compare_x_2();} Compare_y_2 compare_y_2_object() const { return Compare_y_2();} Orientation_2 orientation_2_object() const { return Orientation_2();} Side_of_oriented_circle_2 side_of_oriented_circle_2_object() const {return Side_of_oriented_circle_2();} Construct_segment_2 construct_segment_2_object() const {return Construct_segment_2();} Construct_triangle_2 construct_triangle_2_object() const {return Construct_triangle_2();} }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_2_TRAITS_3_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_geom_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_geom_tra0000644000175000017500000000606011344301501031443 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_geom_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Monique Teillaud // // geometric traits for a <=3 D triangulation // // ============================================================================ // OBSOLETE !!!!!!!!!!!!!!!!! #ifndef CGAL_TRIANGULATION_GEOM_TRAITS_3_H #define CGAL_TRIANGULATION_GEOM_TRAITS_3_H #include #include #include CGAL_BEGIN_NAMESPACE template < class Repres > class Triangulation_geom_traits_3 : public Repres { public: Triangulation_geom_traits_3() { bool The_class_Triangulation_geom_traits_3_is_obsolete; } typedef Repres Rep; typedef typename Rep::Object_3 Object_3; typedef typename Rep::Point_3 Point_3; typedef typename Rep::Segment_3 Segment_3; typedef typename Rep::Triangle_3 Triangle_3; typedef typename Rep::Tetrahedron_3 Tetrahedron_3; typedef typename Rep::Ray_3 Ray_3; typedef typename Rep::Line_3 Line_3; typedef typename Rep::Plane_3 Plane_3; // The next typedef is there for backward compatibility // Some users take their point type from the traits class. // Before this type was Point typedef Point_3 Point; typedef typename Rep::Compare_x_3 Compare_x_3; typedef typename Rep::Compare_y_3 Compare_y_3; typedef typename Rep::Compare_z_3 Compare_z_3; typedef typename Rep::Equal_3 Equal_3; typedef typename Rep::Orientation_3 Orientation_3; typedef typename Rep::Coplanar_orientation_3 Coplanar_orientation_3; typedef typename Rep::Side_of_oriented_sphere_3 Side_of_oriented_sphere_3; typedef typename Rep::Coplanar_side_of_bounded_circle_3 Coplanar_side_of_bounded_circle_3; typedef typename Rep::Construct_segment_3 Construct_segment_3; typedef typename Rep::Construct_triangle_3 Construct_triangle_3; typedef typename Rep::Construct_tetrahedron_3 Construct_tetrahedron_3; typedef typename Rep::Construct_object_3 Construct_object_3; // For the hierarchy : typedef typename Rep::Compare_distance_3 Compare_distance_3; }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_GEOM_TRAITS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/kdtree_d.h0000644000175000017500000006503311344301500026761 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/kdtree_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sariel Har-Peled (sariel@math.tau.ac.il) // Eyal Flato (flato@math.tau.ac.il) #ifndef CGAL_KDTREE_D_H #define CGAL_KDTREE_D_H #include #include using std::list; // to avoid compiler crash on MSVC++ CGAL_BEGIN_NAMESPACE /*======================================================================= * Kdtree_interface - * This is the default interface of point. It assume that PT (the * point type have the following properties: * default constructor * int dimension() * const coord_type & operator[]( int ) const * ... operator=( const Pt & ) - copy operator \*=======================================================================*/ template class Kdtree_interface { public: typedef PT Point; static int dimension( const PT & pnt ) { // return pnt.dimensions(); return pnt.dimension(); } static int compare( int d, const PT & a, const PT & b ) { if ( a[ d ] < b[ d ] ) return -1; if ( a[ d ] > b[ d ] ) return 1; return 0; } static void copy_coord( int d, PT & a, const PT & b ) { a[ d ] = b[ d ]; } }; template class Kdtree_interface_2d { public: typedef PT Point; static int dimension( const PT & pnt ) { // return pnt.dimensions(); return pnt.dimension(); } static int compare( int d, const PT & a, const PT & b ) { if ( a[ d ] < b[ d ] ) return -1; if ( a[ d ] > b[ d ] ) return 1; return 0; } static void copy_coord( int d, PT & a, const PT & b ) { if ( d == 0 ) a = PT( b[ 0 ], a[1] ); else if ( d == 1 ) a = PT( a[ 0 ], b[1] ); else { assert( 0 ); } } }; template class Kdtree_interface_3d { public: typedef PT Point; static int dimension( const PT & pnt ) { // return pnt.dimensions(); return pnt.dimension(); } static int compare( int d, const PT & a, const PT & b ) { if ( a[ d ] < b[ d ] ) return -1; if ( a[ d ] > b[ d ] ) return 1; return 0; } static void copy_coord( int d, PT & a, const PT & b ) { if ( d == 0 ) a = PT( b[ 0 ], a[1], a[ 2 ] ); else if ( d == 1 ) a = PT( a[ 0 ], b[1], a[ 2 ] ); else if ( d == 2 ) a = PT( a[ 0 ], a[1], b[ 2 ] ); else { assert( 0 ); } } }; /*========================================================================= * kdtree_d - * A the kdtree class. * * Remark: The kd-trees allocates all the memory it needs in advance, * This results in a rather efficient memory management, and a fast * iplementation. \*=========================================================================*/ template class Kdtree_d { class Plane; public: typedef typename Traits::Point Point; typedef list List_points; //------------------------------------------------------------------------- // Extended_Point_d - // A class for representing an extended d-dimal point: with // ability to support +/- infinity. Templated by the kd-treee interface // type. //------------------------------------------------------------------------- class ExtPoint { private: class coordinate_type { public: const Point * p_pnt; int type; //signed char type; }; coordinate_type * p_arr; int dim; Point def_pnt; void init( int _dim ) { assert( _dim > 0 ); dim = _dim; p_arr = (coordinate_type *)malloc( sizeof( coordinate_type ) * dim ); //printf( "p_arr(new): %p\n", (void *)p_arr ); assert( p_arr != NULL ); CGAL_CLIB_STD::memset( p_arr, 0, sizeof( coordinate_type ) * dim ); } public: enum { MINUS_INFINITY = -1, FINITE = 0, PLUS_INFINITY = 1 }; ExtPoint( int _type, int _dim ) { assert( _type == MINUS_INFINITY || _type == PLUS_INFINITY ); init( _dim ); for ( int ind = 0; ind < dim; ind++ ) p_arr[ ind ].type = _type; } ExtPoint() { p_arr = NULL; dim = -1; } ExtPoint( const ExtPoint & p ) { init( p.dim ); def_pnt = p.def_pnt; for ( int ind = 0; ind < dim; ind++ ) { p_arr[ ind ] = p.p_arr[ ind ]; if ( p.p_arr[ ind ].p_pnt == &p.def_pnt ) p_arr[ ind ].p_pnt = &def_pnt; } } ExtPoint & operator=( const ExtPoint & p ) { term(); init( p.dim ); def_pnt = p.def_pnt; for ( int ind = 0; ind < dim; ind++ ) { p_arr[ ind ] = p.p_arr[ ind ]; if ( p.p_arr[ ind ].p_pnt == &p.def_pnt ) p_arr[ ind ].p_pnt = &def_pnt; } return *this; } ExtPoint( const Point & point, int dim ) { init( dim ); def_pnt = point; for ( int ind = 0; ind < dim; ind++ ) { p_arr[ ind ].p_pnt = &def_pnt; p_arr[ ind ].type = FINITE; } } void term() { if ( p_arr != NULL ) { //printf( "a: %p\n", p_arr ); free( p_arr ); //printf( "_a\n" ); p_arr = NULL; } dim = 0; } ~ExtPoint() { term(); } void set_coord( int k, Point & point ) { assert( 0 <= k && k < dim ); p_arr[ k ].type = FINITE; //p_arr[ k ].p_pnt = &point; Traits::copy_coord( k, def_pnt, point ); p_arr[ k ].p_pnt = &def_pnt; } void set_coord( int k, const ExtPoint & point ) { assert( 0 <= k && k < dim ); assert( 0 <= k && k < point.dim ); p_arr[ k ] = point.p_arr[ k ]; if ( p_arr[ k ].type == FINITE ) { Traits::copy_coord( k, def_pnt, *(p_arr[ k ].p_pnt) ); p_arr[ k ].p_pnt = &def_pnt; } } int compare( int k, const ExtPoint & point ) const { assert( 0 <= k && k < dim ); // the following does not compile on msvc++... // coordinate_type & a( p_arr[ k ] ), // & b( point.p_arr[ k ] ); coordinate_type & a = p_arr[ k ]; coordinate_type & b = point.p_arr[ k ]; if ( a.type != FINITE ) { if ( b.type != FINITE ) { return a.type - b.type; } else { return a.type; } } else { if ( b.type != FINITE ) return -b.type; else return Traits::compare( k, *a.p_pnt, *b.p_pnt ); } } int compare_vector( const ExtPoint & point ) const { int ind, res; for ( ind = 0; ind < dim; ind++ ) { res = compare( ind, point ); if ( res != 0 ) return res; } return 0; } int compare( int k, const Point & point ) const { assert( 0 <= k && k < dim ); // coordinate_type & a( p_arr[ k ] ); coordinate_type & a = p_arr[ k ]; if ( a.type != FINITE ) return a.type; else return Traits::compare( k, *a.p_pnt, point ); } int dimension() const { return dim; } int get_coord_status( int d ) const { assert( 0 <= d && d < dim ); return p_arr[ d ].type; } const Point * get_coord_point( int d ) const { assert( 0 <= d && d < dim ); return p_arr[ d ].p_pnt; } }; // Box - represents an axis parallel box. class Box { public: int dim; ExtPoint left, right; private: friend class Plane; ExtPoint & get_vertex( bool f_left ) { return f_left? left : right; } public: // constructors //CHECK Box() { } Box( const Box & box ) { dim = box.dim; left = box.left; right = box.right; } Box( const Point &l, const Point &r, int _dim ) { dim = _dim; left = ExtPoint( l, dim ); right = ExtPoint( r, dim ); } Box( int _dim ) : left( ExtPoint::MINUS_INFINITY, _dim ), right( ExtPoint::PLUS_INFINITY, _dim ) { dim = _dim; } // data access void set_left( Point &l) { left = ExtPoint( l, dim ); }; void set_right( Point &r) { right = ExtPoint( r, dim ); } const ExtPoint &get_left() const { return left; } const ExtPoint &get_right() const { return right; } void set_coord_left( int k, Point & p ) { left.set_coord( k, p ); } void set_coord_right( int k, Point & p ) { right.set_coord( k, p ); } // operations bool is_in( const Box &o) const // checks if o is completely inside { int dim = left.dimension(); for (int i = 0; i < dim; i++) { if ( (left.compare(i, o.get_left()) > 0 ) || (right.compare(i, o.get_right()) < 0 ) ) return false; } return true; } bool is_in( const Point & o ) const // checks if o is completely inside { int dim = left.dimension(); for (int i = 0; i < dim; i++) { if ( (left.compare( i, o ) > 0 ) || (right.compare( i, o ) <= 0 ) ) return false; } return true; } bool is_coord_in_range( int k, const Point & o ) const // checks if o is completely inside { return ( ! ( (left.compare( k, o ) > 0 ) || (right.compare( k, o ) <= 0 ) ) ); } bool is_intersect( const Box &o) const // checks if there is an intersection between o and this { int dim = left.dimension(); for (int i = 0; i < dim; i++) { if ( (left.compare(i, o.get_right()) >= 0) || (right.compare(i, o.get_left()) <= 0) ) return false; } return true; } // checks if there is an intersection between o and this box // only in a specific coordinate... bool is_intersect_in_dim( int d, const Box & o ) const { return (! ( (left.compare( d, o.get_right() ) >= 0 ) || (right.compare( d, o.get_left() ) <= 0) )); } // checks if there is an intersection between o and this box // only in a specific coordinate... bool is_intersect_in_dim_closed( int d, const Box & o ) const { return (! ( (left.compare( d, o.get_right() ) > 0 ) || (right.compare( d, o.get_left() ) < 0) )); } bool intersect(Box &o) // intersects this with o. the intersection will be in this // returns false if intersection is empty { int dim = left.dimension(); for (int i = 0; i < dim; i++) { // left is the maximal of the lefts if (left.compare(i, o.get_left()) == -1) left.set_coord(i, o.get_left()); // right is the minimal of the rights if (right.compare(i, o.get_right()) == 1) right.set_coord(i, o.get_right()); } return !(is_empty()); } bool is_empty() const // return true if this is not an interval (left[k] > right[k]) { int dim = left.dimension(); for (int i = 0; i < dim; i++) { if (left.compare(i, right) == 1) return true; } return false; } bool is_empty_open() const // return true if this is not an interval (left[k] > right[k]) { int dim = left.dimension(); for (int i = 0; i < dim; i++) { if ( left.compare(i, right) >= 0 ) return true; } return false; } int comp( const Box & o ) const { int res; res = left.compare_vector( o.left ); if ( res != 0 ) return res; return right.compare_vector( o.right ); } // destructor - needed in ...recursive ... DVP ~Box() { left.term(); right.term(); dim = 0; } }; private: class Plane { private: int coord; Point * normal; bool f_plus; // orientation of half space // is (0, 0, ... , +inifinity, 0, ..., 0) inside plane public: Plane() { normal = NULL; coord = 0; } Plane( int k, Point & p ) { normal = &p; coord = k; } Plane( const Plane & p ) { coord = p.coord; normal = p.normal; } void dump( void ) { std::cout << "(" << coord << ": " << *normal << ")"; } bool is_in( const Point & p ) const { int cmp; cmp = Traits::compare( coord, p, *normal ); if ( ! f_plus ) cmp = -cmp; return cmp >= 0; } void set_plane(int k, Point &p) { coord = k; normal = &p; //normal->copy( coord, p ); } void split( Box & region, bool f_neg ) { ExtPoint * p_p = &(region.get_vertex( ! f_neg )); if ( f_neg ) { if ( p_p->compare( coord, *normal ) > 0 ) p_p->set_coord( coord, *normal ); } else if ( p_p->compare( coord, *normal ) < 0 ) p_p->set_coord( coord, *normal ); } void orient_half_space( bool f_neg_side ) { f_plus = ! f_neg_side; } int get_coord() const { return coord; } }; private: class Node { public: Plane plane; Point * pnt; Node * left, * right; enum { LEFT, RIGHT }; const Plane & get_hs( int side ) const { ((Plane *)&plane)->orient_half_space( side == LEFT ); return plane; } bool is_points_in_hs( const Plane & pl ) const { if ( is_point() ) return pl.is_in( *pnt ); if ( left != NULL && ( ! left->is_points_in_hs( pl ) ) ) return false; if ( right != NULL && ( ! right->is_points_in_hs( pl ) ) ) return false; return true; } bool is_valid() const { if ( is_point() ) return true; if ( left != NULL ) if ( ! left->is_points_in_hs( get_hs( LEFT ) ) ) return false; if ( right != NULL ) if ( ! right->is_points_in_hs( get_hs( RIGHT ) ) ) return false; return true; } void dump( int depth ) { int ind; for ( ind = 0; ind < depth; ind++ ) std::cout << " "; if ( is_point() ) { std::cout << *pnt << "\n"; return; } plane.dump(); std::cout << "\n"; left->dump( depth + 1 ); for ( ind = 0; ind < depth; ind++ ) std::cout << " "; std::cout << "!!!!!!!!!!!!\n"; right->dump( depth + 1 ); } bool is_point() const { return ((left == NULL) && (right == NULL)); } typedef std::back_insert_iterator back_iter; Node() : plane() { left = right = NULL; } void copy_subtree_points( back_iter & result, const Box & rect ) { if ( is_point() ) { if ( rect.is_in( *pnt ) ) (*result++) = *pnt; return; } if ( left != NULL ) left->copy_subtree_points( result, rect ); if ( right != NULL ) right->copy_subtree_points( result, rect ); } static void search_recursive( back_iter & result, Node * node, const Box & rect, Box & _region, Plane & plane, bool f_split_plus ) { //printf( "search_recusrive\n" ); Box * p_r = new Box( _region ); //printf( "z" ); //fflush( stdout ); plane.split( *p_r, f_split_plus ); //printf( "c" ); //fflush( stdout ); assert( node != NULL ); //printf( "b" ); //fflush( stdout ); if ( rect.is_in( *p_r ) ) { //printf( "5" ); //fflush( stdout ); node->copy_subtree_points( result, rect ); //printf( "\tsearch_recursive done...\n" ); //printf( "6" ); //fflush( stdout ); delete p_r; return; } //printf( "v" ); //fflush( stdout ); if ( rect.is_intersect_in_dim_closed( plane.get_coord(), *p_r ) ) node->search( result, rect, *p_r ); //printf( "x" ); //fflush( stdout ); delete p_r; } void search( std::back_insert_iterator result, const Box &rect, Box ®ion ) { if (is_point()) { if ( rect.is_in( *pnt ) ) (*result++) = *pnt; return; } //this is not a point so it is a hypeplane if ( left != NULL ) search_recursive( result, left, rect, region, plane, true ); if ( right != NULL ) search_recursive( result, right, rect, region, plane, false ); } }; // SunPro requires this : friend class Box; friend class Node; typedef Point * Point_ptr; int size; Point * p_arr_pt; Node *root; int dim; Node * p_node_arr; int node_count; Node * malloc_node( void ) { Node * p_ret; p_ret = &(p_node_arr[ node_count ]); node_count++; assert( node_count <= ( 2 * size )); *p_ret = Node(); return p_ret; } static int comp( const Point & a, const Point & b, int dim ) { return Traits::compare( dim, a, b ); } static int partition( Point_ptr * arr, int left, int right, Point * p_pivot, int dim ) { int i, j; Point_ptr tmp; if ( left >= right ) return left; i = left; j = right; while ( i < j ) { if ( comp( *(arr[ i ]), *(arr[ j ]), dim ) > 0 ) { tmp = arr[ i ]; arr[ i ] = arr[ j ]; arr[ j ] = tmp; } if ( comp( *(arr[ i ]), *p_pivot, dim ) < 0 ) { i++; } else if ( comp( *p_pivot, *(arr[ j ]), dim ) <= 0 ) j--; } return (i > left)? i - 1 : left; } /* split the array into two sub-arrays, such that all the elements * from left to pos_mid are smaller than the elements from pos+1 to * right. */ static void split_arr( Point_ptr * arr, int left, int right, int pos_mid, int dim ) { int pos; if ( left >= right ) return; pos = partition( arr, left, right, arr[ (left + right ) / 2 ], dim ); if ( pos == pos_mid ) return; if ( pos < pos_mid ) split_arr( arr, pos+1, right, pos_mid, dim ); else split_arr( arr, left, pos, pos_mid, dim ); } static Point_ptr get_max_element( Point_ptr * arr, int left, int right, int d ) { int max_pos = left; Point mx = *(arr[ max_pos ]); for ( int ind = left + 1; ind <= right; ind++ ) if ( comp( mx, *(arr[ ind ]), d ) < 0 ) { mx = *(arr[ ind ]); max_pos = ind; } return arr[ max_pos ]; } Node *build_r( Point_ptr * arr, int left, int right, int d ) { int num, pos, next_d; Node * n; num = right - left + 1; if ( num < 1) return NULL; // if the list contains only one point, // construct a leaf for this node if ( num == 1) { //n = new node; n = malloc_node(); n->pnt = arr[ left ]; return n; } // else divide space into two regions in // dim-dim and cotinue recursively pos = (left + right) / 2; split_arr( arr, left, right, pos, d ); Point * p_median = get_max_element( arr, left, pos, d ); // create division plane; Plane plane( d, *p_median ); //n = new node; // assert( n != NULL ); n = malloc_node(); n->plane = plane; next_d = d + 1; if ( next_d >= dim ) next_d = 0; // build left sub-tree n->left = build_r( arr, left, pos, next_d ); // build right sub-tree n->right = build_r( arr, pos + 1, right, next_d ); return n; } public: typedef list list_points; Kdtree_d(int k = 2) { dim = k; root = NULL; p_arr_pt = NULL; p_node_arr = NULL; } ~Kdtree_d() { delete_all(); } bool is_valid( bool verbose = false, int level = 0 ) const { (void)verbose; (void)level; if ( root == NULL ) return true; return root->is_valid(); } void dump() { root->dump( 0); } void delete_all() { root = NULL; if ( p_arr_pt != NULL ) delete[] p_arr_pt; p_arr_pt = NULL; if ( p_node_arr != NULL ) delete[] p_node_arr; p_node_arr = NULL; } void search( std::back_insert_iterator result, Box & rect ) { if (root == NULL) return; // it is an empty tree - nothing to search in Box region = Box( dim ); root->search( result, rect, region ); } void build(list &l) { int i; Point_ptr * p_arr; size = l.size(); p_arr_pt = new Point[ size ]; assert( p_arr_pt != NULL ); p_arr = new Point_ptr[ size ]; assert( p_arr != NULL ); p_node_arr = new Node[ 2 * size ]; assert( p_node_arr != NULL ); node_count = 0; /* fill the array */ i = 0; for ( typename std::list::iterator j = l.begin(); j != l.end(); j++ ) { p_arr_pt[ i ] = (*j); p_arr[ i ] = p_arr_pt + i; i++; } // recursively build the tree from the sorted list // starting to divide it in coordinate 0 root = build_r( p_arr, 0, size - 1, 0 ); //printf( "b\n" ); delete[] p_arr; } }; CGAL_END_NAMESPACE #else /* CGAL_KDTREE_D_H */ #error Header file kdtree_d.h included twice #endif /* CGAL_KDTREE_D_H */ /*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=* * * kdtree_d.h - End of File \*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/ ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_iterator_adaptor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_iterator_ad0000644000175000017500000001526511344301500031257 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_iterator_adaptor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_ITERATOR_ADAPTOR_H #define CGAL_HALFEDGEDS_ITERATOR_ADAPTOR_H 1 #ifndef CGAL_PROTECT_ITERATOR #include #define CGAL_PROTECT_ITERATOR #endif CGAL_BEGIN_NAMESPACE // The iterator identity adaptor will be used for the HDS implementations // that are based on STL (or other) container classes which do not // guarantee that the default construction of its iterator gives always // the same singular value (i.e. something like NULL). This adaptor // assumes that iterator traits are fully supported. It works for all // kinds of iterators, from input iterators to random access iterators. // It does no longer require that these iterators have a constructor // accepting zero as an argument (e.g. a pointer). This approach has // failed with the KCC compiler (Kai's C++). // Instead, we rely now on a static local variable. Static variables are // first of all zero-initialized (Section 3.6.2), which guarantees that // pointers and such are set to zero even if the construtor does not // initialize them (Section 8.5). With static variables, the order of // initialization could be critical, if the initialization of one // requires another one to be initialized already (I have not seen such a // design for iterator yet, but who knows, maybe if reference counting // come into play). If global static variables are in different // compilation units, there order of initialization is unspecified. // However, if the static variable is a local variable, the // initialization happens before the surrounding function is called if // the type is a POD, otherwise the initialization happens when the // control flow passes through the declaration of the static variable the // first time (Section 6.7), which costs performance but makes it safe // for weird static initialization situations. Usually the std::vector // class uses a plain C-pointer as iterator, which would be a POD and // thus efficient. However, the std::list iterators might not be POD's if // they define their own copy contructor. This is the case for // std::list::iterator of the current SGI STL, but not for the // std::list::const_iterator, which is a funny side-effect of having // only a single class for both and a constructor that allows iterator to // const_iterator conversions. The bottom line is, std::vector is fine, // std::list could cost a bit performance and In_place_list might be // preferable. template < class I> class HalfedgeDS_iterator_adaptor { private: I nt; // The internal iterator. // keep the local static variable for the null iterator // in a small inline function, optimizers might like that // better than a static function. const I& null_iterator() const { static I it = I(); // zero-initialized and a default constructor return it; } public: typedef I Iterator; typedef HalfedgeDS_iterator_adaptor Self; typedef std::iterator_traits Traits; typedef typename Traits::reference reference; typedef typename Traits::pointer pointer; typedef typename Traits::value_type value_type; typedef typename Traits::difference_type difference_type; typedef typename Traits::iterator_category iterator_category; // CREATION // -------- // explicitly set to 0 HalfedgeDS_iterator_adaptor() : nt( null_iterator()) {} HalfedgeDS_iterator_adaptor( Iterator j) : nt(j) {} // down cast template < class J> HalfedgeDS_iterator_adaptor( const HalfedgeDS_iterator_adaptor& j) : nt(j.iterator()) {} // OPERATIONS Forward Category // --------------------------- Iterator iterator() const { return nt;} bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return *nt; } pointer operator->() const { return &*nt; } Self& operator++() { ++nt; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self& operator+=( difference_type n) { nt += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator< ( const Self& i) const { return ( nt < i.nt); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; CGAL_END_NAMESPACE // we don't need Koenig lookup here template < class D, class I> inline CGAL::HalfedgeDS_iterator_adaptor operator+( D n, CGAL::HalfedgeDS_iterator_adaptor i) { return i += Dist(n); } #endif // CGAL_HALFEDGEDS_ITERATOR_ADAPTOR_H // // EOF // ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dummy_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dummy_point_locatio0000644000175000017500000000775311344301500031471 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_dummy_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Efi Fogel #ifndef CGAL_PM_DUMMY_POINT_LOCATION_H #define CGAL_PM_DUMMY_POINT_LOCATION_H #include #include CGAL_BEGIN_NAMESPACE template class Pm_dummy_point_location : public Pm_point_location_base { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; typedef Pm_point_location_base Base; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Halfedge Halfedge; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Traits::Point_2 Point_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef Pm_bounding_box_base Bounding_box; typedef typename Base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Base::Token Token; public: Pm_dummy_point_location() : Pm_point_location_base(), m_traits(0) {} Pm_dummy_point_location(Planar_map *, Traits_wrap * traits) : Pm_point_location_base(), m_traits(traits) {} void init(Planar_map &, const Traits & traits) { m_traits = (const Traits_wrap*)(&traits); } void insert(Halfedge_handle, const X_monotone_curve_2 &) {} inline const Traits * get_traits() const {return m_traits;} Halfedge_const_handle locate(const Point_2 &, Locate_type &) const { CGAL_assertion_msg(false, "Dummy point location - locate not allowed"); Halfedge_const_handle h; return h; } Halfedge_handle locate(const Point_2 &, Locate_type &) { CGAL_assertion_msg(false, "Dummy point location - locate not allowed"); Halfedge_handle h; return h; } Halfedge_const_handle vertical_ray_shoot(const Point_2 &, Locate_type &, bool) const { CGAL_assertion_msg(false, "Dummy point location - locate not allowed"); Halfedge_const_handle h; return h; } Halfedge_handle vertical_ray_shoot(const Point_2 &, Locate_type &, bool) { CGAL_assertion_msg(false, "Dummy point location - locate not allowed"); Halfedge_handle h; return h; } void split_edge(const X_monotone_curve_2 &, Halfedge_handle, Halfedge_handle, const X_monotone_curve_2 &, const X_monotone_curve_2 &) {} void merge_edge(const X_monotone_curve_2 &, const X_monotone_curve_2 &, Halfedge_handle, const X_monotone_curve_2 &) {} void remove_edge(Halfedge_handle) {} void remove_edge(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &) {} void clear() {} void update(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &, const Token & token) {} #ifdef CGAL_PM_DEBUG void debug(){} #endif protected: const Traits_wrap * m_traits; }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rat_leda_in_CGAL_2.h0000644000175000017500000001370311344301500030445 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/rat_leda_in_CGAL_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef RAT_LEDA_IN_CGAL_H #define RAT_LEDA_IN_CGAL_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE inline bool left_turn( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return CGAL_LEDA_SCOPE::left_turn(p,q,r); } inline bool right_turn( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return CGAL_LEDA_SCOPE::right_turn(p,q,r); } /* #ifndef CGAL_CFG_NO_NAMESPACE inline bool collinear( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return ::collinear(p,q,r); } #endif // CGAL_CFG_NO_NAMESPACE */ #ifndef CGAL_CFG_NO_NAMESPACE inline Orientation orientation( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return (Orientation)CGAL_LEDA_SCOPE::orientation(p,q,r); } #endif // CGAL_CFG_NO_NAMESPACE inline bool lexicographically_xy_smaller( const leda_rat_point & p, const leda_rat_point & q) { return ( leda_rat_point::cmp_xy(p,q) < 0 ); } inline bool lexicographically_yx_smaller( const leda_rat_point & p, const leda_rat_point & q) { return ( leda_rat_point::cmp_yx(p,q) < 0 ); } inline bool lexicographically_xy_larger( const leda_rat_point & p, const leda_rat_point & q) { return ( leda_rat_point::cmp_xy(p,q) > 0 ); } inline bool lexicographically_yx_larger( const leda_rat_point & p, const leda_rat_point & q) { return ( leda_rat_point::cmp_yx(p,q) > 0 ); } inline bool lexicographically_xy_smaller_or_equal( const leda_rat_point & p, const leda_rat_point & q) { return ( leda_rat_point::cmp_xy(p,q) <= 0 ); } inline bool lexicographically_yx_smaller_or_equal( const leda_rat_point & p, const leda_rat_point & q) { return ( leda_rat_point::cmp_yx(p,q) <= 0 ); } inline Comparison_result compare_lexicographically_xy(const leda_rat_point & p, const leda_rat_point & q) { return (Comparison_result)leda_rat_point::cmp_xy(p,q); } inline Comparison_result compare_lexicographically_yx(const leda_rat_point & p, const leda_rat_point & q) { return (Comparison_result)leda_rat_point::cmp_yx(p,q); } inline bool collinear_are_ordered_along_line( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return leda_rat_segment(p,r).contains(q); } inline bool collinear_are_strictly_ordered_along_line( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return (leda_rat_segment(p,r).contains(q) && ( q != p ) && ( q != r )); } inline bool are_ordered_along_line( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return ( CGAL_LEDA_SCOPE::collinear(p,q,r) && collinear_are_ordered_along_line(p,q,r)); } inline bool are_strictly_ordered_along_line( const leda_rat_point & p, const leda_rat_point & q, const leda_rat_point & r) { return ( CGAL_LEDA_SCOPE::collinear(p,q,r) && collinear_are_strictly_ordered_along_line(p,q,r) ); } inline Comparison_result cmp_signed_dist_to_line(const leda_rat_point& p, const leda_rat_point& q, const leda_rat_point& r, const leda_rat_point& s) { #if ( __LEDA__ >= 360 ) return (Comparison_result)CGAL_LEDA_SCOPE::cmp_signed_dist(p,q,r,s); #else leda_rat_line l(p,q); int r_or = CGAL_LEDA_SCOPE::orientation( l, r ); int s_or = CGAL_LEDA_SCOPE::orientation( l, s ); if ( r_or != s_or ) { return (Comparison_result)( r_or < s_or ); } else { return (Comparison_result)(r_or *( CGAL::sign(l.sqr_dist(r) - l.sqr_dist(s) ))); } #endif // __LEDA__ >= 360 } inline bool has_smaller_signed_dist_to_line(const leda_rat_point& p, const leda_rat_point& q, const leda_rat_point& r, const leda_rat_point& s) { return ( cmp_signed_dist_to_line(p,q,r,s) == SMALLER ); } inline bool has_larger_signed_dist_to_line(const leda_rat_point& p, const leda_rat_point& q, const leda_rat_point& r, const leda_rat_point& s) { return ( cmp_signed_dist_to_line(p,q,r,s) == LARGER ); } CGAL_END_NAMESPACE #endif // RAT_LEDA_IN_CGAL_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_convex_set_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_convex_set_trai0000644000175000017500000000662311344301500031446 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Random_convex_set_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_RANDOM_CONVEX_SET_TRAITS_2_H) #define CGAL_RANDOM_CONVEX_SET_TRAITS_2_H 1 #include CGAL_BEGIN_NAMESPACE template < class Kernel > struct Random_convex_set_traits_2 { typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Direction_2 Direction_2; typedef typename Kernel::FT FT; Random_convex_set_traits_2() : _origin( ORIGIN) {} Point_2 origin() const { return _origin; } struct Max_coordinate : public CGAL_STD::unary_function< Point_2, FT > { FT operator()( const Point_2& p) const { return max( CGAL_NTS abs( p.x()), CGAL_NTS abs( p.y())); } }; struct Sum : public CGAL_STD::binary_function< Point_2, Point_2, Point_2 > { Point_2 operator()( const Point_2& p, const Point_2& q) const { return p + (q - ORIGIN); } }; struct Scale : public CGAL_STD::binary_function< Point_2, FT, Point_2 > { Point_2 operator()( const Point_2& p, const FT& k) const { return ORIGIN + (p - ORIGIN) * k; } }; struct Angle_less : public CGAL_STD::binary_function< Point_2, Point_2, bool > { bool operator()( const Point_2& p, const Point_2& q) const { return Direction_2( p - ORIGIN) < Direction_2( q - ORIGIN); } }; private: Point_2 _origin; }; template struct Random_convex_set_traits : public Random_convex_set_traits_2 {}; template < class OutputIterator, class Point_generator > inline OutputIterator random_convex_set_2( int n, OutputIterator o, const Point_generator& pg) { typedef typename Point_generator::value_type Point_2; return CGAL_random_convex_set_2(n, o, pg, reinterpret_cast(0)); } template < class OutputIterator, class Point_generator, class R > inline OutputIterator CGAL_random_convex_set_2( int n, OutputIterator o, const Point_generator& pg, Point_2< R >*) { return random_convex_set_2( n, o, pg, Random_convex_set_traits_2< R >()); } CGAL_END_NAMESPACE #endif // ! (CGAL_RANDOM_CONVEX_SET_TRAITS_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/float.h0000644000175000017500000000700711344301500026302 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/float.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_FLOAT_H #define CGAL_FLOAT_H #include #include #include #ifdef CGAL_CFG_IEEE_754_BUG # include #endif #ifdef __sgi # include #endif CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; inline double to_double(float f) { return static_cast(f); } inline std::pair to_interval(float f) { return std::pair(f, f); } #ifdef __sgi inline bool is_finite(float f) { switch (fp_class_f(f)) { case FP_POS_NORM: case FP_NEG_NORM: case FP_POS_ZERO: case FP_NEG_ZERO: case FP_POS_DENORM: case FP_NEG_DENORM: return true; case FP_SNAN: case FP_QNAN: case FP_POS_INF: case FP_NEG_INF: return false; } return false; // NOT REACHED } inline bool is_valid(float d) { switch (fp_class_f(d)) { case FP_POS_NORM: case FP_NEG_NORM: case FP_POS_ZERO: case FP_NEG_ZERO: case FP_POS_INF: case FP_NEG_INF: case FP_POS_DENORM: case FP_NEG_DENORM: return true; case FP_SNAN: case FP_QNAN: return false; } return false; // NOT REACHED } #elif defined CGAL_CFG_IEEE_754_BUG #define CGAL_EXPONENT_FLOAT_MASK 0x7f800000 #define CGAL_MANTISSA_FLOAT_MASK 0x007fffff inline bool is_finite_by_mask_float(unsigned int u) { unsigned int e = u & CGAL_EXPONENT_FLOAT_MASK; return ( (e ^ CGAL_EXPONENT_FLOAT_MASK) != 0); } inline bool is_nan_by_mask_float(unsigned int u) { if ( is_finite_by_mask_float(u) ) return false; // unsigned int m = u & CGAL_MANTISSA_FLOAT_MASK; return ( (u & CGAL_MANTISSA_FLOAT_MASK) != 0); } inline bool is_finite( const float& flt) { float f = flt; IEEE_754_float* p = reinterpret_cast(&f); return is_finite_by_mask_float( p->c ); } inline bool is_valid( const float& flt) { float f = flt; IEEE_754_float* p = reinterpret_cast(&f); return !is_nan_by_mask_float( p->c ); } #else inline bool is_valid(float d) { return (d == d); } inline bool is_finite(float d) { return (d == d) && (is_valid(d-d)); } #endif inline io_Operator io_tag(float) { return io_Operator(); } CGAL_END_NAMESPACE #endif // CGAL_FLOAT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2.h0000644000175000017500000026746211344301500027676 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arrangement_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel, // Eti Ezra , // Shai Hirsch #ifndef CGAL_ARRANGEMENT_2_H #define CGAL_ARRANGEMENT_2_H //for now, since the arrangement default ctr is currently with the walk pl. #include #include #include #include //for circulators #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template > class Arrangement_2 { public: typedef _Dcel Dcel; typedef _Traits Traits; typedef Pm_traits_wrap_2 Traits_wrap; typedef Planar_map_2 Planar_map; typedef Pm_walk_along_line_point_location WalkPL; typedef Planar_map_with_intersections_2 Pmwx; typedef typename Pmwx::Change_notification Change_notification; typedef Arrangement_2<_Dcel,_Traits,Base_node> Self; typedef typename Traits::Point Point_2; typedef typename Traits::X_curve X_monotone_curve_2; typedef typename Traits::Curve Curve_2; typedef typename Planar_map::Halfedge_handle Pm_halfedge_handle; typedef typename Planar_map::Face_handle Pm_face_handle; //for size and stuff typedef typename Dcel::Size Size; typedef typename Dcel::size_type size_type; typedef typename Dcel::difference_type difference_type; typedef typename Dcel::difference_type Difference; typedef typename Dcel::iterator_category iterator_category; // Obsolete, for backward compatability typedef Change_notification Pmwx_change_notification; typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; enum Locate_type { VERTEX = Planar_map::VERTEX, EDGE = Planar_map::EDGE, FACE = Planar_map::FACE, UNBOUNDED_VERTEX = Planar_map::UNBOUNDED_VERTEX, UNBOUNDED_EDGE = Planar_map::UNBOUNDED_EDGE, UNBOUNDED_FACE = Planar_map::UNBOUNDED_FACE }; //forward declerations class Subcurve_node; class Curve_node; class Edge_node; class Vertex; class Halfedge; class Face; /////////////////////////////////////////////////////////////////////// // ITERATOR DEFINITIONS //for heirarchy tree (H...) typedef typename In_place_list::size_type HSize; typedef typename In_place_list::size_type Hsize_type; typedef typename In_place_list::difference_type Hdifference_type; typedef typename In_place_list::difference_type HDifference; typedef std::bidirectional_iterator_tag Hiterator_category; // typedefs for iterators (for curve nodes, edge_nodes, sub_curve_nodes and // HVF) typedef typename In_place_list::iterator Subcurve_iterator; typedef typename In_place_list::const_iterator Subcurve_const_iterator; typedef I_HalfedgeDS_iterator< Subcurve_iterator, Curve_node, HDifference, Hiterator_category> Curve_iterator; typedef I_HalfedgeDS_const_iterator< Subcurve_const_iterator, Subcurve_iterator, Curve_node, HDifference, Hiterator_category> Curve_const_iterator; typedef I_HalfedgeDS_iterator< Subcurve_iterator, Edge_node, HDifference, Hiterator_category> Edge_iterator; typedef I_HalfedgeDS_const_iterator< Subcurve_const_iterator, Subcurve_iterator, Edge_node, HDifference, Hiterator_category> Edge_const_iterator; //wrappers for planar map iterators typedef I_HalfedgeDS_iterator< typename Planar_map::Vertex_iterator, Vertex, Difference, typename Planar_map::iterator_category> Vertex_iterator; typedef I_HalfedgeDS_const_iterator< typename Planar_map::Vertex_const_iterator, typename Planar_map::Vertex_iterator, Vertex, Difference, typename Planar_map::iterator_category> Vertex_const_iterator; typedef I_HalfedgeDS_iterator< typename Planar_map::Halfedge_iterator, Halfedge, Difference, typename Planar_map::iterator_category> Halfedge_iterator; typedef I_HalfedgeDS_const_iterator< typename Planar_map::Halfedge_const_iterator, typename Planar_map::Halfedge_iterator, Halfedge, Difference, typename Planar_map::iterator_category> Halfedge_const_iterator; typedef I_HalfedgeDS_iterator< typename Planar_map::Face_iterator, Face, Difference, typename Planar_map::iterator_category> Face_iterator; typedef I_HalfedgeDS_const_iterator< typename Planar_map::Face_const_iterator, typename Planar_map::Face_iterator, Face, Difference, typename Planar_map::iterator_category> Face_const_iterator; //the following define the overlap circulators //(might be changed to iterators) typedef Arr_overlap_circulator< Edge_node,Edge_iterator,Bidirectional_circulator_tag> Overlap_circulator; typedef Arr_overlap_const_circulator< Edge_node, Edge_const_iterator, Bidirectional_circulator_tag> Overlap_const_circulator; //handles typedef Vertex_iterator Vertex_handle; typedef Vertex_const_iterator Vertex_const_handle; typedef Halfedge_iterator Halfedge_handle; typedef Halfedge_const_iterator Halfedge_const_handle; typedef Face_iterator Face_handle; typedef Face_const_iterator Face_const_handle; typedef _Arr_face_circ< Halfedge, Halfedge_iterator, Forward_circulator_tag> Ccb_halfedge_circulator; typedef _Arr_face_const_circ< Halfedge, Halfedge_const_iterator, Forward_circulator_tag> Ccb_halfedge_const_circulator; typedef _Arr_vertex_circ< Halfedge, Halfedge_iterator, Forward_circulator_tag> Halfedge_around_vertex_circulator; typedef _Arr_vertex_const_circ< Halfedge, Halfedge_const_iterator, Forward_circulator_tag> Halfedge_around_vertex_const_circulator; typedef I_HalfedgeDS_iterator< typename Planar_map::Holes_iterator, Ccb_halfedge_circulator, Difference, std::bidirectional_iterator_tag> Holes_iterator; typedef I_HalfedgeDS_const_iterator< typename Planar_map::Holes_const_iterator, typename Planar_map::Holes_iterator, Ccb_halfedge_const_circulator, Difference, std::bidirectional_iterator_tag> Holes_const_iterator; //TREE NODES: //subcurve_node : Base_node + hides pointers - returns handles/iterators //curve_node : sub_curve_node + adds levels //edge_node : sub_curve_node + adds halfedges /////////////////////////////////////////////////////////////////////////// // SUBCURVE_NODE /////////////////////////////////////////////////////////////////////////// class Subcurve_node : public Base_node, public In_place_list_base { #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 protected: using Base_node::cv_wrap; #endif public: friend class Arrangement_2; //to enable access of Overlap_iterators into begin_child and past_end_child //friend class Overlap_circulator; //friend class Overlap_const_circulator; //the above are not recognized by MSVC, so we use this instead friend class Arr_overlap_circulator; friend class Arr_overlap_const_circulator; Subcurve_node(int construct_curve=1) : ftr(0),begin_child(0), past_end_child(0) { if(construct_curve) cv_wrap.x_cv=new X_monotone_curve_2; } virtual ~Subcurve_node() {} virtual bool is_edge_node() const { return false; } Subcurve_iterator parent() { return Subcurve_iterator(ftr); } Subcurve_const_iterator parent() const { return Subcurve_const_iterator(ftr); } Subcurve_iterator children_begin() { return Subcurve_iterator(begin_child); } Subcurve_const_iterator children_begin() const { return Subcurve_const_iterator(begin_child); } Subcurve_iterator children_end() { return Subcurve_iterator(past_end_child); } Subcurve_const_iterator children_end() const { return Subcurve_const_iterator(past_end_child); } Curve_iterator curve_node() { Subcurve_node * curr = this; while (curr->ftr) curr = curr->ftr; return Curve_iterator(curr); } Curve_const_iterator curve_node() const { const Subcurve_node * curr = this; while (curr->ftr) curr = curr->ftr; return Curve_const_iterator(curr); } Edge_iterator edges_begin() { Subcurve_node* curr=this; while (!curr->is_edge_node()) curr = curr->begin_child; return Edge_iterator(curr); } Edge_const_iterator edges_begin() const { const Subcurve_node * curr = this; while (!curr->is_edge_node()) curr = curr->begin_child; return Edge_const_iterator(curr); } Edge_iterator edges_end() { Subcurve_node * curr = this; while (!curr->is_edge_node()) //curr will never be a past_end_value: curr = curr->past_end_child->prev_link; return Edge_iterator(curr->next_link); } Edge_const_iterator edges_end() const { const Subcurve_node * curr = this; while (!curr->is_edge_node()) curr=curr->past_end_child->prev_link; return Edge_const_iterator(curr->next_link); } //the set_curve is not protected. how do I protect it? (maybe friend the //arrangement and make it protected?) protected: Subcurve_node * ftr; Subcurve_node * begin_child; Subcurve_node * past_end_child; }; //////////////////////////////////////////////////////////////////// // EDGE_NODE //////////////////////////////////////////////////////////////////// class Edge_node : public Subcurve_node { public: friend class Arrangement_2; //need to make them friend of Subcurve_node and not Edge_node //friend class Overlap_circulator; //friend class Overlap_const_circulator; Edge_node() : Subcurve_node(), hdg() { //the following is needed for the circular overlap list (see the function //push_in_edge_list below). if we want to implement a linear list //it needs to be removed (begin_child and past_end_child should then be //NULL) this->begin_child = this; this->past_end_child = this; } ~Edge_node() {} //overrides the virtual dtr in Subcurve node Halfedge_handle halfedge() { return hdg; } Halfedge_const_handle halfedge() const { return hdg; } bool is_edge_node() const { return true; } private: //maybe protected // void set_halfedge(Halfedge_const_handle h) {hdg=h;} void set_halfedge(Halfedge_handle h) { hdg = h; } private: Halfedge_handle hdg; }; /////////////////////////////////////////////////////////////////////////// // CURVE_NODE /////////////////////////////////////////////////////////////////////////// class Curve_node : public Subcurve_node { public: friend class Arrangement_2; Curve_node() : Subcurve_node(0), levels(), edge_level() { this->cv_wrap.cv = new Curve_2; } ~Curve_node() {} //overrides the virtual dtr in Subcurve_node //number of subcurve levels (not including curve level and edge level) unsigned int number_of_sc_levels() const { return levels.size(); } Subcurve_iterator level_begin(unsigned int i) { CGAL_precondition(i > levels; //level0 is the one beneath the root In_place_list edge_level; }; //Planar map wrappers //halfedge : Pm::Halfedge + hides pointer into iterator (and adds curve node) //face : Pm::Face + returns Arr::Halfedge and not Pm::Halfedge etc. //Vertex : Pm::Vertex + returns Arr::Halfedge and not Pm::Halfedge etc. ////////////////////////////////////////////////////////////////////// // VERTEX ////////////////////////////////////////////////////////////////////// class Vertex : public Planar_map::Vertex { public: typedef typename Planar_map::Vertex PmVertex; Vertex() : PmVertex() {} //can also be PmVertex(v) Vertex(PmVertex * v) : PmVertex(*v) {} Vertex(PmVertex & v) : PmVertex(v) {} bool is_incident_edge(Halfedge_const_handle e) const { return (PmVertex::is_incident_edge(e.current_iterator())); } bool is_incident_face(Face_const_handle f) const { return (PmVertex::is_incident_face(f.current_iterator())); } /*redundant - use inheritance int degree() const { return PmVertex::degree(); }*/ Halfedge_around_vertex_circulator incident_halfedges() { return Halfedge_around_vertex_circulator (Halfedge_handle(PmVertex::incident_halfedges())); } Halfedge_around_vertex_const_circulator incident_halfedges() const { return Halfedge_around_vertex_const_circulator (Halfedge_const_handle(PmVertex::incident_halfedges())); } }; /////////////////////////////////////////////////////////////////////// // HALFEDGE ////////////////////////////////////////////////////////////////////// class Halfedge : public Planar_map::Halfedge { public: friend class Arrangement_2; typedef typename Planar_map::Halfedge PmHalfedge; Halfedge() : Planar_map::Halfedge() {} Halfedge(typename Planar_map::Halfedge *e) : Planar_map::Halfedge(*e) {} Halfedge(typename Planar_map::Halfedge& e) : Planar_map::Halfedge(e) {} Vertex_handle source() { return Vertex_handle(PmHalfedge::source()); } Vertex_const_handle source() const { return Vertex_const_handle(PmHalfedge::source()); } Vertex_handle target() { return Vertex_handle(PmHalfedge::target()); } Vertex_const_handle target() const { return Vertex_const_handle(PmHalfedge::target()); } Face_handle face() { return Face_handle(PmHalfedge::face()); } Face_const_handle face() const { return Face_const_handle(PmHalfedge::face()); } Halfedge_handle twin() { return Halfedge_handle(PmHalfedge::twin()); } Halfedge_const_handle twin() const { return Halfedge_const_handle(PmHalfedge::twin()); } Halfedge_handle next_halfedge() { return Halfedge_handle(PmHalfedge::next_halfedge()); } Halfedge_const_handle next_halfedge() const { return Halfedge_const_handle(PmHalfedge::next_halfedge()); } Ccb_halfedge_circulator ccb() { return Ccb_halfedge_circulator(Halfedge_handle(PmHalfedge::ccb())); } Ccb_halfedge_const_circulator ccb() const { return Ccb_halfedge_const_circulator (Halfedge_const_handle(PmHalfedge::ccb())); } Edge_iterator edge_node() { return Edge_iterator (Subcurve_iterator (static_cast(PmHalfedge::edge_node()))); } Edge_const_iterator edge_node() const { return Edge_const_iterator (Subcurve_const_iterator (static_cast(PmHalfedge::edge_node()))); } //Overlap traversal Overlap_circulator overlap_edges() { return Overlap_circulator(edge_node()); } Overlap_const_circulator overlap_edges() const { return Overlap_const_circulator(edge_node()); } //the curve and set curve functions in the base classes //will be required to be blank. maybe thats a problem with //other functions of the pm that we use here (check it out) //is there a better solution ? protected: //(private?) void set_edge_node(Edge_node* b) {PmHalfedge::set_edge_node(b);} private: //disallow this function - allowed only for an Edge_node //this overloading works for egcs, if doesn't work for other //compilers then this will be the only version . void set_edge_node(Base_node* b) {PmHalfedge::set_edge_node(b);} }; /////////////////////////////////////////////////////////////////// // FACE ////////////////////////////////////////////////////////////////// class Face : public Planar_map::Face { public: typedef typename Planar_map::Face PmFace; #ifndef _MSC_VER // the following two typedefs are needed for compilation on irix64 (CC7.30) typedef typename Arrangement_2<_Dcel,_Traits,Base_node>::Holes_iterator Holes_iterator; typedef typename Arrangement_2<_Dcel,_Traits,Base_node>::Holes_const_iterator Holes_const_iterator; #endif Face() : PmFace() {} Face(PmFace *f) : PmFace(*f) {} Face(PmFace& f) : PmFace(f) {} /* redundant - use inheritance bool is_unbounded() const { // face is not bounded iff it has no outer boundary return (dface::halfedge() == NULL); } */ Holes_iterator holes_begin() { return Holes_iterator(PmFace::holes_begin()); } Holes_const_iterator holes_begin() const { return Holes_const_iterator(PmFace::holes_begin()); } Holes_iterator holes_end() { return Holes_iterator(PmFace::holes_end()); } Holes_const_iterator holes_end() const { return Holes_const_iterator(PmFace::holes_end()); } bool is_halfedge_on_inner_ccb(Halfedge_const_handle e) const { return PmFace::is_halfedge_on_inner_ccb(e.current_iterator()); } bool is_halfedge_on_outer_ccb(Halfedge_const_handle e) const { return PmFace::is_halfedge_on_outer_ccb(e.current_iterator()); } //redundant - use inheritance /* bool does_outer_ccb_exist() const { return PmFace::does_outer_ccb_exist(); }*/ Halfedge_handle halfedge_on_outer_ccb() { typename Planar_map::Halfedge_handle pmh = PmFace::halfedge_on_outer_ccb(); return Halfedge_handle(pmh); } Halfedge_const_handle halfedge_on_outer_ccb() const { typename Planar_map::Halfedge_const_handle pmh = PmFace::halfedge_on_outer_ccb(); return Halfedge_const_handle(pmh); } Ccb_halfedge_circulator outer_ccb() { return (halfedge_on_outer_ccb())->ccb(); } Ccb_halfedge_const_circulator outer_ccb() const { return (halfedge_on_outer_ccb())->ccb(); } }; ////////////////////////////////////////////////////////// // ARRANGEMENT 2 /////////////////////////////////////////////////////////// public: //in future need to arrange for the pl to be an Arr_pl, //and public for the arrangement /* //for the first public release we use the default ctr below (with walk pl) - //currently it is faster Arrangement_2(const Traits& tr=Traits()) : traits(tr), pm(tr), //do_update(true) { last_updated=curve_node_end(); } */ //default ctr with the walk as default point location Arrangement_2() : pm(Traits(), new WalkPL), do_update(true) { //new Traits_wrap(tr) last_updated=curve_node_end(); use_delete_pl=true; //a bool flag for dtr traits = (Traits_wrap *)(&pm.get_traits()); use_delete_traits = false; } Arrangement_2(const Traits& tr, Pm_point_location_base * pl_ptr) : pm(Traits(), pl_ptr), do_update(true) { last_updated=curve_node_end(); use_delete_pl = false; //a bool flag for dtr traits = (Traits_wrap *)(&pm.get_traits()); use_delete_traits = false; } Arrangement_2(Pm_point_location_base * pl_ptr) : pm(pl_ptr), do_update(true) { last_updated = curve_node_end(); use_delete_pl=false; traits = (Traits_wrap *)(&pm.get_traits()); use_delete_traits = false; } /*! Copy constructor. */ Arrangement_2(const Self & arr) : pm(arr.pm), do_update(true) { last_updated = curve_node_end(); use_delete_pl = false; //a bool flag for dtr // these traits is the newly allocated traits for pm. traits = (Traits_wrap *)(&pm.get_traits()); use_delete_traits = false; copy_hierarchy_tree(arr); } /* Arrangement_2(Traits_wrap * tr_ptr, Pm_point_location_base * pl_ptr) : pm(tr_ptr, pl_ptr, NULL), do_update(true) { last_updated=curve_node_end(); traits = (Traits_wrap *)(&pm.get_traits()); use_delete_pl = false; use_delete_traits = false; } */ /*! Destructor * need to delete the walk */ ~Arrangement_2() { if (use_delete_pl) //casting away the constness before deletion : delete(const_cast*> (pm.get_point_location())); if (use_delete_traits) delete traits; } Self & operator=(const Self & arr) { pm = arr.pm; copy_hierarchy_tree(arr); return *this; } ///////////////////////////////////////////////////////////////////////////// // Reading Arrangement functions. //////////////////////////////////////////////////////////////////////////// bool read (std::istream & in) { clear(); Arr_file_scanner scanner(in); return scan_arr(scanner); } template bool read (std::istream & in, Scanner & scanner) { clear(); return scan_arr(scanner); } Traits & get_traits(){return * traits;} const Traits & get_traits() const {return * traits;} const Pmwx & get_planar_map() const {return pm;} public: Curve_iterator curve_node_begin() { return Curve_iterator(curve_list.begin()); } Curve_const_iterator curve_node_begin() const { return Curve_const_iterator(curve_list.begin()); } Curve_iterator curve_node_end() { return Curve_iterator(curve_list.end()); } Curve_const_iterator curve_node_end() const { return Curve_const_iterator(curve_list.end()); } Halfedge_iterator halfedges_begin() { return Halfedge_iterator(pm.halfedges_begin()); } Halfedge_const_iterator halfedges_begin() const { return Halfedge_const_iterator(pm.halfedges_begin()); } Halfedge_iterator halfedges_end() { return Halfedge_iterator(pm.halfedges_end()); } Halfedge_const_iterator halfedges_end() const { return Halfedge_const_iterator(pm.halfedges_end()); } Vertex_iterator vertices_begin() { return Vertex_iterator(pm.vertices_begin()); } Vertex_const_iterator vertices_begin() const { return Vertex_const_iterator(pm.vertices_begin()); } Vertex_iterator vertices_end() { return Vertex_iterator(pm.vertices_end()); } Vertex_const_iterator vertices_end() const { return Vertex_const_iterator(pm.vertices_end()); } Face_iterator faces_begin() { return Face_iterator(pm.faces_begin()); } Face_const_iterator faces_begin() const { return Face_const_iterator(pm.faces_begin()); } Face_iterator faces_end() { return Face_iterator(pm.faces_end()); } Face_const_iterator faces_end() const { return Face_const_iterator(pm.faces_end()); } Size number_of_faces() const { return pm.number_of_faces(); } //counts every halfedge (i.e always even) Size number_of_halfedges() const { return pm.number_of_halfedges(); } Size number_of_vertices() const { return pm.number_of_vertices(); } Size number_of_curve_nodes() const { return curve_list.size(); } Face_handle unbounded_face() { return Face_handle(pm.unbounded_face()); } Face_const_handle unbounded_face() const { return Face_const_handle(pm.unbounded_face()); } //checks validity of planar map and arrangement's hierarchy tree structures bool is_valid(bool verbose = false) const { CGAL::Verbose_ostream verr(verbose); //std::ostream& verr = std::cerr; bool valid = true; verr << std::endl; verr << "CGAL::Arrangment_2::"; verr << "is_valid( true ):" << std::endl; // Planar Map Check verr << "a) planar_map check... " << std::endl; if (pm.is_valid()) verr << "passed." << std::endl; else valid = false; // Check each Curve Hierarchy tree Curve_const_iterator cit; Edge_const_iterator eit; Subcurve_const_iterator sit, child_it, parent_it; unsigned curve_counter = 1; bool curve_node_curve_node = true, curve_node_is_edge_node = true, curve_node_null_parent = true, curve_node_children_parent = true, curve_node_children_curve_node = true, edge_is_edge_node = true, edge_node_curve_node = true, subcurve_is_edge_node = true, subcurve_curve_node = true, subcurve_edges_curve_node = true, subcurve_edges_parent = true, level_structure_ok = true, not_curve_node, circ_curve_is_next_curve = true, circ_curve_is_halfedge_curve = true, edge_curve_is_halfedge_curve = true; verr << "b) hierarchy tree check:" << std::endl; // for each curve tree for (cit = curve_node_begin(); cit != curve_node_end(); cit++, curve_counter++) { // check curve node properties // --------------------------- // is_edge_node() should return false for a Curve_node curve_node_is_edge_node &= (cit->is_edge_node() == false); // curve_node() should point at this current curve curve_node_curve_node &= (cit->curve_node() == cit); // parent() should return NULL curve_node_null_parent &= (cit->parent() == NULL); // children's parent should equal this curve node sit = cit->children_begin(); for (;sit != cit->children_end(); sit++) { curve_node_children_curve_node &= (sit->curve_node() == cit); //parent() always returns Subcurve_iterator while cit is of type // Curve_iterator. to check that a child's parent indeed points at cit // I use the following combined test curve_node_children_parent &= (sit->parent()->parent() == NULL && sit->parent()->curve_node() == cit); } // check edges properties // ---------------------- eit = cit->edges_begin(); for (;eit != cit->edges_end(); eit++) { // is_edge_node() should return true for an edge node edge_is_edge_node &= (eit->is_edge_node() == true); // edged mutual reference check edge_node_curve_node &= eit->curve_node() == cit; // checking the vaildity of overlappings. Overlap_const_circulator ovlp_circ = eit->halfedge()->overlap_edges(); edge_curve_is_halfedge_curve &= (traits->curve_equal(eit->x_curve(), eit->halfedge()->curve())); do { Overlap_const_circulator next = ovlp_circ; ++next; circ_curve_is_next_curve &= traits->curve_equal(ovlp_circ->x_curve(), next->x_curve()); circ_curve_is_halfedge_curve &= (traits->curve_equal(ovlp_circ->x_curve(), eit->halfedge()->curve())); } while (++ovlp_circ != eit->halfedge()->overlap_edges()); } // check subcurves properties // -------------------------- int i, levels; levels = cit->number_of_sc_levels(); if (levels > 0) { for (i = 0; i < levels; i++) { sit = cit->level_begin(i); // check that level i is indeed i deep in this tree // go up to curve node i times, expect not too find parent // not too soon, not too late int j; for (j = i, not_curve_node = true, parent_it = sit; j >= 0 && not_curve_node; j--, parent_it = parent_it->parent()) { // parent found too soon? if (parent_it->parent() == NULL) not_curve_node = false; } level_structure_ok &= not_curve_node; // parent found too late : level_structure_ok &= (parent_it->parent()==NULL); // for each subcurve in level i for (;sit != cit->level_end(i) ; sit++) { // is_edge_node() should return false for a Subcurve_node subcurve_is_edge_node &= (sit->is_edge_node() == false); // subcurve - curve check subcurve_curve_node &= (sit->curve_node() == cit); // subcurve - edge check eit = sit->edges_begin(); for (;eit != sit->edges_end(); eit++) { // ADD CHECK TO PARENT() !! subcurve_edges_curve_node &= eit->curve_node() == cit; } child_it = sit->children_begin(); for (;child_it != sit->children_end(); child_it++) { // ADD CHECK TO PARENT() !! subcurve_edges_parent &= (child_it->parent() == sit); } } // for (;sit != ... } // for (i = 0 ... } // if } verr << std::endl; verr << "let cn denote the root Curve_node of the "; verr << "arrangement hierarchy tree," << std::endl; verr << " sn denote a Subcurve_node in that tree," << std::endl; verr << "and en denote an Edge_node in that tree." << std::endl; verr << "(&x stands for an iterator that points at x)" << std::endl; verr << std::endl; verr << "Curve checks:" << std::endl; verr << "for all cn : cn.is_edge_node() == false ---"; verr << (curve_node_is_edge_node ? "PASS" : "FAIL") << std::endl; verr << "for all cn : cn.curve_node() == &cn ---"; verr << (curve_node_curve_node ? "PASS" : "FAIL") << std::endl; verr << "for all cn : cn.parent() == NULL ---"; verr << (curve_node_null_parent ? "PASS" : "FAIL") << std::endl; verr << "for all children ch of cn : ch.curve_node_node() == &cn ---"; verr << (curve_node_children_curve_node ? "PASS" : "FAIL") << std::endl; verr << "for all children ch of cn : ch.parent() is indeed cn ---"; verr << (curve_node_children_parent ? "PASS" : "FAIL") << std::endl; verr << "level i is indeed i deep in tree ---"; verr << (level_structure_ok ? "PASS" : "FAIL") << std::endl; verr << std::endl; verr << "Subcurve checks:" << std::endl; verr << "for all sn : sn.is_edge_node() == false ---"; verr << (subcurve_is_edge_node ? "PASS" : "FAIL") << std::endl; verr << "for all sn : sn->curve_node() == &cn ---"; verr << (subcurve_curve_node ? "PASS" : "FAIL") << std::endl; verr << "for all en in an sn subtree: en->curve_node() == &cn ---"; verr << (subcurve_edges_curve_node ? "PASS" : "FAIL") << std::endl; verr << "for each child ch of sn : ch->parent() == &sn ---"; verr << (subcurve_edges_curve_node ? "PASS" : "FAIL") << std::endl; verr << std::endl; verr << "Edge checks:" << std::endl; verr << "for all en : en.is_edge_node() == true ---"; verr << (edge_is_edge_node ? "PASS" : "FAIL") << std::endl; verr << "for all en : en->curve_node() == &cn ---"; verr << (edge_node_curve_node ? "PASS" : "FAIL") << std::endl; verr << "for all en : en->curve() == en->halfedge()->curve() ---"; verr << (edge_curve_is_halfedge_curve ? "PASS" : "FAIL") << std::endl; verr << "for all en : all overlapping circulators have the same curve ---"; verr << (circ_curve_is_next_curve ? "PASS" : "FAIL") << std::endl; verr << "for all en : all circulators curves == en->halfedge()->curve() ---"; verr << (circ_curve_is_halfedge_curve ? "PASS" : "FAIL") << std::endl; valid = valid & curve_node_curve_node & curve_node_is_edge_node & curve_node_null_parent & curve_node_children_parent & curve_node_children_curve_node & edge_is_edge_node & edge_node_curve_node & subcurve_is_edge_node & subcurve_curve_node & subcurve_edges_curve_node & subcurve_edges_parent & level_structure_ok & edge_curve_is_halfedge_curve & circ_curve_is_next_curve & circ_curve_is_halfedge_curve; // Final Result verr << std::endl; if (valid) verr << " object is valid! " << std::endl; else verr << "object is INVALID!" << std::endl; verr << "------------------" << std::endl; return valid; } /////////////////////////////////////////////////////////////////// // INSERTION FUNCTIONS Curve_iterator insert_from_vertex(const Curve_2 & cv, Vertex_handle src, Change_notification * en = NULL) { CGAL_precondition(traits->point_equal(src->point(), traits->curve_source(cv))); CGAL_precondition(!traits->point_equal(traits->curve_source(cv), traits->curve_target(cv)) || !traits->is_x_monotone(cv)); //either add Arr to pm as friend class or make public functions Curve_node* cn= new Curve_node; cn->set_curve(cv); if (!traits->is_x_monotone(cv)) { //get an x_monotone sub_curve list and push it in. cn->levels.push_back(In_place_list()); //cut cv into x_monotone curves and insert them into l std::list x_list; traits->curve_make_x_monotone(cv, std::back_inserter(x_list)); typename std::list::iterator lit=x_list.begin(); for (; lit!=x_list.end(); ++lit) { Subcurve_node* scn=new Subcurve_node; scn->ftr=cn; scn->set_x_monotone_curve(*lit); cn->levels[0].push_back(*scn); } cn->begin_child=&(*(cn->levels[0].begin())); cn->past_end_child=&(*(cn->levels[0].end())); //so far - inserted subcurve level, we insert the edge level only if // we are in update mode. if (do_update) { Vertex_handle curr_v = src; Subcurve_iterator scit=cn->levels[0].begin(); In_place_list edge_list; for (; scit!=cn->levels[0].end(); ++scit) { Arr_hierarchy_ops aho(this, edge_list, &(*scit), en); Halfedge_handle h = pm.insert_from_vertex (scit->curve(), curr_v.current_iterator(), &aho); curr_v = h->target(); // vertex for next insertion scit->begin_child=&(*(edge_list.begin())); //add edge_list at end of edge_level : cn->edge_level.splice(cn->edge_level.end(),edge_list); } scit=cn->levels[0].begin(); Subcurve_iterator aux=scit; ++aux; for (; aux!=cn->levels[0].end(); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } //the last past_end_child : scit->past_end_child=&(*(cn->edge_level.end())); } //if (do_update) } else { //insert x_curve directly - sub_curve vector is empty if (do_update) { //insertion of edge level only if in update mode Arr_hierarchy_ops aho(this, cn->edge_level, cn, en); pm.insert_from_vertex(cv, src.current_iterator(), &aho); cn->past_end_child=&(*(cn->edge_level.end())); cn->begin_child=&(*(cn->edge_level.begin())); } } Curve_iterator ci=curve_list.insert(curve_list.end(),*cn); if (do_update) last_updated=ci; return ci; } Curve_iterator insert(const Curve_2 & cv, Change_notification * en = NULL) { //either add Arr to pm as friend class or make public functions Curve_node* cn= new Curve_node; cn->set_curve(cv); //get an x_monotone sub_curve list and push it in. cn->levels.push_back(In_place_list()); //cut cv into x_monotone curves and insert them into l std::list x_list; traits->curve_make_x_monotone(cv, std::back_inserter(x_list)); typename std::list::iterator lit=x_list.begin(); for (; lit!=x_list.end(); ++lit) { Subcurve_node* scn=new Subcurve_node; scn->ftr=cn; scn->set_x_monotone_curve(*lit); cn->levels[0].push_back(*scn); } cn->begin_child=&(*(cn->levels[0].begin())); cn->past_end_child=&(*(cn->levels[0].end())); //so far - inserted subcurve level, we insert the edge level only if // we are in update mode. if (do_update) { Vertex_handle curr_v; Halfedge_handle h; bool first_insert(true); Subcurve_iterator scit=cn->levels[0].begin(); In_place_list edge_list; for (; scit!=cn->levels[0].end(); ++scit) { Arr_hierarchy_ops aho(this, edge_list, &(*scit), en); if (first_insert) { typename Planar_map::Vertex_handle src, tgt; h = pm.insert_intersecting_xcurve(scit->x_curve(), src, tgt, false, &aho); first_insert = false; } else { typename Planar_map::Vertex_handle src(curr_v.current_iterator()), tgt; h = pm.insert_intersecting_xcurve(scit->x_curve(), src, tgt, true, &aho); } curr_v = h->target(); // vertex for next insertion scit->begin_child=&(*(edge_list.begin())); //add edge_list at end of edge_level : cn->edge_level.splice(cn->edge_level.end(),edge_list); } scit=cn->levels[0].begin(); Subcurve_iterator aux=scit; ++aux; for (; aux!=cn->levels[0].end(); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } //the last past_end_child : scit->past_end_child=&(*(cn->edge_level.end())); } //if (do_update) Curve_iterator ci=curve_list.insert(curve_list.end(),*cn); if (do_update) last_updated=ci; return ci; } ///////////////////////////////////////////////////////////////////// // insertion with user defined intersection functions template Curve_iterator insert(const Curve_2 & cv, F_iterator F_begin, F_iterator F_end, Change_notification * en = NULL) { if (F_begin==F_end) return insert(cv); //if list is empty return regular insert function Curve_node* cn= new Curve_node; cn->set_curve(cv); typename std::vector >::size_type sz=0; //distance(F_begin,F_end,sz); //find size of vector of in place lists //(currently not all STL distance is implemented same - //so I implement it myself); F_iterator first=F_begin; while(first++!=F_end) ++sz; //! the following line is _crucial_ to avoid unreferencing //of the lists afterwards cn->levels.reserve(sz); //step 1: insert the first level of subcurves (level 0) cn->levels.push_back(In_place_list()); //cut cv into curves and insert them into l std::list c_list; (*(*F_begin))(cv,c_list); ++F_begin; typename std::list::iterator lit=c_list.begin(); for (; lit!=c_list.end(); ++lit) { Subcurve_node* scn=new Subcurve_node; scn->ftr=cn; scn->set_x_monotone_curve(*lit); cn->levels[0].push_back(*scn); } cn->begin_child=&(*(cn->levels[0].begin())); cn->past_end_child=&(*(cn->levels[0].end())); //step 2: insert the rest of the levels of subcurves //(until no more split functions) int i=1; //current level for (; F_begin!=F_end ; ++F_begin, ++i ) { cn->levels.push_back(In_place_list()); Subcurve_iterator scit=cn->levels[i-1].begin(); for (; scit!=cn->levels[i-1].end(); ++scit) { //cut cv into curves and insert them into l std::list c_list; (*(*F_begin))(scit->x_curve(),c_list); //split the curve Subcurve_iterator aux=cn->levels[i].end(); if (!cn->levels[i].empty()) { --aux; } typename std::list::iterator lit=c_list.begin(); for (; lit!=c_list.end(); ++lit) { Subcurve_node* scno=new Subcurve_node; scno->ftr=&(*scit); scno->set_x_monotone_curve(*lit); cn->levels[i].push_back(*scno); } if (!cn->levels[i].empty()) { ++aux; } //the begin_child is the one directly after the last one of before.: scit->begin_child=&(*aux); } (cn->levels[i-1].begin())->begin_child=&(*(cn->levels[i].begin())); //the begin child of the first - now all begin children are well defined //defining the past end child pointer of level[i-1] scit=cn->levels[i-1].begin(); Subcurve_iterator aux=scit; ++aux; for (; aux!=cn->levels[i-1].end(); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } //the last past_end_child scit->past_end_child=&(*(cn->levels[i].end())); } //ALL the subcurve levels are now inserted. //step 3: insert the edge level. if (do_update) { Subcurve_iterator scit=cn->levels[i-1].begin(); In_place_list edge_list; for (; scit!=cn->levels[i-1].end(); ++scit) { Arr_hierarchy_ops aho(this, edge_list, &(*scit), en); pm.insert(scit->x_curve(), &aho); scit->begin_child=&(*(edge_list.begin())); //add edge_list at end of edge_level : cn->edge_level.splice(cn->edge_level.end(),edge_list); } scit=cn->levels[i-1].begin(); Subcurve_iterator aux=scit; ++aux; for (; aux!=cn->levels[i-1].end(); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } //the last past_end_child : scit->past_end_child=&(*(cn->edge_level.end())); } //if (do_update) //insert in curve list and return Curve_iterator ci=curve_list.insert(curve_list.end(),*cn); if (do_update) last_updated=ci; return ci; } /////////////////////////////////////////////////////////////// // SPLIT EDGE //add a new edge_node after e->edge_node(), split the edge in the pm, //update the curves and halfedge pointers in the nodes and halfedges void handle_split_edge(Pm_halfedge_handle orig_edge, Pm_halfedge_handle new_edge, const typename Traits::X_curve& c1, const typename Traits::X_curve& c2) { Halfedge_handle e = orig_edge; Edge_iterator eit=e->edge_node(); Curve_iterator cit=eit->curve_node(); Edge_node* en=new Edge_node; //!! bug fix (two weeks of debugging) en->ftr=eit->ftr; if (traits->point_equal(traits->curve_source(c1), orig_edge->source()->point())) { en->set_x_monotone_curve(c2); orig_edge->edge_node()->set_x_monotone_curve(c1); } else { en->set_x_monotone_curve(c1); orig_edge->edge_node()->set_x_monotone_curve(c2); } //insert en after eit in the edge_node list ++eit; (cit->edge_level).insert(eit.current_iterator(),*en); en->set_halfedge(Halfedge_handle(new_edge)); new_edge->set_edge_node(en); new_edge->twin()->set_edge_node(en); //deal with overlapping edges of eit (if there were any) if (((Edge_node*)(orig_edge->edge_node()))->begin_child != (Subcurve_node*)&(*(orig_edge->edge_node()))) { //eit has overlapping edges (it doesn't point to itself) //split all overlapping edge_nodes and create the circular list of //the edges corresponding to the new edge Overlap_circulator occ= (Halfedge_handle(orig_edge))->overlap_edges(); ++occ; //we have already dealt with the first edge do { //add a new edge before/after edge_iterator(occ); //set its curve,ftr,begin_child,past_end_child,halfedge eit=occ; cit=eit->curve_node(); Edge_node* nen=new Edge_node; nen->ftr=eit->ftr; //insert nen into circular list before en nen->begin_child=en->begin_child; nen->past_end_child=en; en->begin_child->past_end_child=nen; en->begin_child=nen; eit->set_x_monotone_curve(orig_edge->curve()); nen->set_x_monotone_curve(new_edge->curve()); //insert en before/after eit in the edge_node list if (eit->halfedge()== Halfedge_handle(orig_edge->twin())) { //eit is directed opposite orig_edge->edge_node() //we take advantage of our knowledge of the pm //split function to know this nen->set_halfedge(Halfedge_handle(new_edge->twin())); //en will be inserted before eit } else { nen->set_halfedge(Halfedge_handle(new_edge)); ++eit; //en should be inserted after eit } //insertion into the in_place edge list (cit->edge_level).insert(eit.current_iterator(),*nen); } while (++occ != (Halfedge_handle(orig_edge))->overlap_edges()); } } Halfedge_handle split_edge(Halfedge_handle e, const typename Traits::X_curve& c1, const typename Traits::X_curve& c2) { Edge_iterator eit = e->edge_node(); //find the representative halfedge of the edge node //(the one with the same direction as the curve) Halfedge_handle e_rep = eit->halfedge(); typename Planar_map::Halfedge_handle pmh = pm.split_edge(e_rep.current_iterator(),c1,c2); handle_split_edge(pmh, pmh->next_halfedge(), c1, c2); return Halfedge_handle(pmh); } //////////////////////////// //LOCATE //////////////////////////// Halfedge_handle locate(const typename Traits::Point_2& p,Locate_type& lt) { typename Planar_map::Locate_type pmlt; typename Planar_map::Halfedge_handle pmh=pm.locate(p,pmlt); switch(pmlt) { case Planar_map::VERTEX : //workaround since MSVC does not approve the automatic cast here : lt=static_cast(VERTEX); break; case Planar_map::EDGE : lt=static_cast(EDGE); break; case Planar_map::FACE : lt=static_cast(FACE); break; case Planar_map::UNBOUNDED_VERTEX : lt=static_cast(UNBOUNDED_VERTEX); break; case Planar_map::UNBOUNDED_EDGE : lt=static_cast(UNBOUNDED_EDGE); break; case Planar_map::UNBOUNDED_FACE : lt=static_cast(UNBOUNDED_FACE); break; } return Halfedge_handle(pmh); } Halfedge_const_handle locate(const typename Traits::Point_2& p, Locate_type& lt) const { typename Planar_map::Locate_type pmlt; typename Planar_map::Halfedge_const_handle pmh=pm.locate(p,pmlt); switch(pmlt) { case Planar_map::VERTEX : //workaround since MSVC does not approve the automatic cast here lt = static_cast(VERTEX); break; case Planar_map::EDGE : lt = static_cast(EDGE); break; case Planar_map::FACE : lt = static_cast(FACE); break; case Planar_map::UNBOUNDED_VERTEX : lt = static_cast(UNBOUNDED_VERTEX); break; case Planar_map::UNBOUNDED_EDGE : lt = static_cast(UNBOUNDED_EDGE); break; case Planar_map::UNBOUNDED_FACE : lt = static_cast(UNBOUNDED_FACE); break; } return Halfedge_const_handle(pmh); } ////////////////////////////////////////////////////// // VERTICAL RAY SHOOT ////////////////////////////////////////////////////// Halfedge_handle vertical_ray_shoot(const typename Traits::Point_2& p, Locate_type& lt, bool up) { typename Planar_map::Locate_type pmlt; typename Planar_map::Halfedge_handle pmh=pm.vertical_ray_shoot(p,pmlt,up); switch(pmlt) { case Planar_map::VERTEX : //workaround since MSVC does not approve the automatic cast here : lt = static_cast(VERTEX); break; case Planar_map::EDGE : lt = static_cast(EDGE); break; case Planar_map::FACE : lt = static_cast(FACE); break; case Planar_map::UNBOUNDED_VERTEX : lt = static_cast(UNBOUNDED_VERTEX); break; case Planar_map::UNBOUNDED_EDGE : lt = static_cast(UNBOUNDED_EDGE); break; case Planar_map::UNBOUNDED_FACE : lt = static_cast(UNBOUNDED_FACE); break; } return Halfedge_handle(pmh); } Halfedge_const_handle vertical_ray_shoot(const typename Traits::Point_2& p, Locate_type& lt) const { typename Planar_map::Locate_type pmlt; typename Planar_map::Halfedge_const_handle pmh = pm.vertical_ray_shoot(p,pmlt); switch(pmlt) { case Planar_map::VERTEX : //workaround since MSVC does not approve the automatic cast here : lt = static_cast(VERTEX); break; case Planar_map::EDGE : lt = static_cast(EDGE); break; case Planar_map::FACE : lt = static_cast(FACE); break; case Planar_map::UNBOUNDED_VERTEX : lt = static_cast(UNBOUNDED_VERTEX); break; case Planar_map::UNBOUNDED_EDGE : lt = static_cast(UNBOUNDED_EDGE); break; case Planar_map::UNBOUNDED_FACE : lt = static_cast(UNBOUNDED_FACE); break; } return Halfedge_const_handle(pmh); } /////////////////////////////////////////////////////////////// // REMOVE CURVE ///////////////////////////////////////////////////////////// //removes the curve ,its heirarchy tree, and the edges in the pm void remove_curve(Curve_iterator cit) { Edge_iterator eit=cit->edges_begin(); for (; eit!=cit->edges_end(); ++eit) { if (eit->begin_child == &(*eit)) { //no overlap pm.remove_edge((eit->halfedge()).current_iterator()); //deletes edges } else { //eit overlaps - don't remove the halfedges from planar map eit->begin_child->past_end_child=eit->past_end_child; eit->past_end_child->begin_child=eit->begin_child; //set the edge_node ptr of halfedges to something that is not deleted eit->halfedge()->set_edge_node(eit->begin_child); eit->halfedge()->twin()->set_edge_node(eit->begin_child); } } typename std::vector >::iterator vit=(cit->levels).begin(); for (; vit!=(cit->levels).end(); ++vit) (*vit).destroy(); //deletes subcurve lists curve_list.erase(&(*cit)); //deletes from curve list } /////////////////////////////////////////////////////////////// // CLEAR /////////////////////////////////////////////////////////////// void clear() { pm.clear(); for (Curve_iterator cv_iter = curve_node_begin(); cv_iter != curve_node_end(); cv_iter++){ // destroying all subcurves levels. for (unsigned int i = 0; i < cv_iter->number_of_sc_levels(); i++) cv_iter->levels[i].destroy(); // destroying edge node level. cv_iter->edge_level.destroy(); } curve_list.destroy(); } /////////////////////////////////////////////////////////////// // UPDATE /////////////////////////////////////////////////////////////// void set_update(bool u) { do_update=u; if (u) { //go from last_updated to curve_node_end(), and insert x_curves if (last_updated!=curve_node_end()) //for the very first update ++last_updated; else last_updated=curve_node_begin(); for (; last_updated!=curve_node_end(); ++last_updated) { unsigned int num=last_updated->number_of_sc_levels(); if (num>0) { In_place_list edge_list; Subcurve_iterator scit=last_updated->level_begin(num - 1); for (; scit!=last_updated->level_end(num - 1); ++scit) { Arr_hierarchy_ops aho(this, edge_list, &(*scit)); pm.insert(scit->x_curve(), &aho); scit->begin_child=&(*(edge_list.begin())); //add edge_list at end of edge_level : last_updated->edge_level.splice(last_updated->edge_level.end(), edge_list); } scit=last_updated->level_begin(num - 1); Subcurve_iterator aux=scit; ++aux; for (; aux!=last_updated->level_end(num-1); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } //the last past_end_child : scit->past_end_child=&(*(last_updated->edge_level.end())); } else { //num==0, no subcurve level, insert Curve directly. Arr_hierarchy_ops aho(this, last_updated->edge_level, &(*last_updated)); pm.insert(last_updated->x_curve(), &aho); last_updated->past_end_child=&(*(last_updated->edge_level.end())); last_updated->begin_child=&(*(last_updated->edge_level.begin())); } } //now last_update==curve_node_end() - take the one before --last_updated; } } // object given as a parameter to insert function of pmwx // such that insert will not know about curve hirarchy class Arr_hierarchy_ops : public Change_notification { public: typedef Self Arr; Arr_hierarchy_ops(Arr *arr_, In_place_list& edge_list_, Subcurve_node* ftr_, Change_notification *user_notifier_ = NULL ) : arr(arr_), edge_list(edge_list_), ftr(ftr_), user_notifier(user_notifier_) {} void add_edge(const typename Traits::X_curve& cv, Pm_halfedge_handle e, bool original_direction, bool overlap=false) { arr->push_in_edge_list(cv, e, ftr, edge_list, original_direction, overlap); if (user_notifier != NULL) user_notifier->add_edge(cv, e, original_direction, overlap); } void split_edge(Pm_halfedge_handle orig_edge, Pm_halfedge_handle new_edge, const typename Traits::X_curve& c1, const typename Traits::X_curve& c2) { arr->handle_split_edge(orig_edge, new_edge, c1, c2); if (user_notifier != NULL) user_notifier->split_edge(orig_edge, new_edge, c1, c2); } void split_face(Pm_face_handle orig_face, Pm_face_handle new_face) { if (user_notifier != NULL) user_notifier->split_face(orig_face, new_face); } void add_hole(Pm_face_handle in_face, Pm_halfedge_handle new_hole) { if (user_notifier != NULL) user_notifier->add_hole(in_face, new_hole); } // return in support_cv the suuporting curve of edge. // if not avilable returns false const typename Traits::X_curve &edge_support_curve(Pm_halfedge_handle edge) { Halfedge_handle arr_handle = edge; return arr_handle->edge_node()->parent()->x_curve(); } bool have_support_curve() { return true; } Arr *arr; In_place_list &edge_list; Subcurve_node* ftr; Change_notification *user_notifier; }; friend class Arr_hierarchy_ops; // Pushes the curve cv corresponding to halfedge e to the edge_node_list // push_back if original_direction // push_front otherwise - will be called from insert after // inserting cv into the pm and getting e // // *** Edge_node class: // Edge_node holds a curve that is used also as the curve of its // associated halfedge. There are two halfedges (an halfedge and its // twin) which point to the Edge_node. The Edge_node contains a // handle to one of these halfedges of which has the same orientation // as the curve the Edge_node holds. Edge_node also contains two // pointers named begin_child and past_end_child which are two // pointers in a circulat list of all overlapping curves on the // specific edge. // // *** Historical comment (Eti and Eyal, January 2002) // original_direction was a boolean flag indicating whether cv and // ftr->curve() have the same orientation. Pm_with_intersections // calculated this value and passed it through the add_edge // function of the notifier However, this value was miscalculated // and had an error value. As a result, we do not use // original_direction. Instead we compare the directions of cv and // ftr->curve(). // void push_in_edge_list(const typename Traits::X_curve& cv, Pm_halfedge_handle phe, Subcurve_node* ftr, In_place_list& edge_list, bool /* original_direction */, bool overlap=false) { Halfedge_handle e = phe; Edge_node* en=new Edge_node; en->ftr=ftr; // The following condition replaces the original functionality // of original_direction, as described in the histroial comment above. // The original condition: if (original_direction) if (traits->compare_xy(traits->curve_source(ftr->x_curve()), traits->curve_target(ftr->x_curve())) == traits->compare_xy(traits->curve_source(cv), traits->curve_target(cv))) en->set_x_monotone_curve(cv); else en->set_x_monotone_curve(traits->curve_opposite(cv)); // DEALING WITH OVERLAP: // We use the 2 redundant pointers - begin_child and past_end_child // to create a circular linked list of overlapping edges (for the // same halfedge) // 2 options: circular bidircetionsl list(bi-circulator) , // or linear single directional list (forward iterator), // bidirectional iterator can't be implemented because we can't // have a sentinel for the past_the_end value. //we implement below a bi-dircetional circular list, when no overlap //en points at itself - this implies that the default ctr of the //edge node has begin_child and past_end_child initialized to this //(whereas if we implement a forward list, it is initialized to NULL). if (overlap) { //pointer shuffling to insert en into circular list //past_end_child == next, begin_child == prev Edge_node* aux=&(*e->edge_node()); en->past_end_child = aux; en->begin_child = aux->begin_child; aux->begin_child->past_end_child = en; aux->begin_child = en; } else { //initialization of circular list with en - not needed - done in the ctr //en->past_end_child=en; //en->begin_child=en; } //the following code should replace the above code if we want a single list //if (overlap) // en->past_end_child=&(*e->edge_node()); e->set_edge_node(en); e->twin()->set_edge_node(en); if (traits->point_equal(e->target()->point(), traits->curve_target(en->x_curve()))) en->set_halfedge(Halfedge_handle(e)); else en->set_halfedge(Halfedge_handle(e->twin())); edge_list.push_back(*en); } ////////////////////////////////////////////////////////////////////////// // The following function is implemented for the Adaptive arr of Bezier // curves - a local project that is not (currently) in CGAL. //debug //public: protected: //replace the subtree rooted at sc, with the list of curves cv_list //then continue to subdivide with the rest of the levels. //assumes sc is not a Curve_node and not an edge_node template Subcurve_iterator replace(Subcurve_iterator sc, const std::list & cv_list, F_iterator F_begin, F_iterator F_end) { Subcurve_node* cn= sc->ftr; //define the level we're in and finding the curve_node (the root) int level_number=-1; Subcurve_node* curr = &(*sc); while (curr->ftr) { curr=curr->ftr; ++level_number; } Curve_iterator root(curr); //step 0: define the past_end levels std::vector::iterator > level_begin; std::vector::iterator > level_end; Edge_node* past_end_edge; Edge_node* begin_edge; Subcurve_iterator begin_aux=sc; Subcurve_iterator end_aux=sc; ++end_aux; level_end.push_back(end_aux); end_aux=(--end_aux)->children_end(); level_begin.push_back(begin_aux); begin_aux=begin_aux->children_begin(); while (!begin_aux->is_edge_node()) { level_begin.push_back(begin_aux); level_end.push_back(end_aux); end_aux=(--end_aux)->children_end(); begin_aux=begin_aux->children_begin(); } past_end_edge = (Edge_node*)(&(*(end_aux))); //use static_cast ? begin_edge = (Edge_node*)(&(*begin_aux)); //step 1: insert the first level of subcurves (the one given in cv_list) //do it with vector and splice at the end //will hold the new subtree std::vector > levels; typename std::vector >::size_type sz=0; //distance(F_begin,F_end,sz); //find size of vector of in place lists //(currently not all STL distance is implemented same - //so I implement it myself); F_iterator first=F_begin; while(first++!=F_end) ++sz; //!to avoid unreferencing of the lists afterwards //(sz+1) because the first is also inserted into the vector levels.reserve(sz+1); levels.push_back(In_place_list() ); typename std::list::const_iterator lit=cv_list.begin(); for (; lit!=cv_list.end(); ++lit) { Subcurve_node* scn=new Subcurve_node; scn->ftr=cn; scn->set_x_monotone_curve(*lit); levels[0].push_back(*scn); } //step 2: insert the rest of the levels of subcurves (until no more //split functions) int i=1; //current level for (; F_begin!=F_end ; ++F_begin, ++i ) { levels.push_back(In_place_list()); Subcurve_iterator scit=levels[i-1].begin(); for (; scit!=levels[i-1].end(); ++scit) { //cut cv into curves and insert them into l std::list c_list; (*(*F_begin))(scit->curve(),c_list); //split the curve Subcurve_iterator aux=levels[i].end(); --aux; //aux keeps the last place we inserted before the coming insertion typename std::list::iterator lit=c_list.begin(); for (; lit!=c_list.end(); ++lit) { Subcurve_node* scn=new Subcurve_node; scn->ftr=&(*scit); scn->set_x_monotone_curve(*lit); levels[i].push_back(*scn); } ++aux; scit->begin_child=&(*aux); } //the begin child of the first - now all begin children are well defined (levels[i-1].begin())->begin_child=&(*(levels[i].begin())); //defining the past end child pointer of level[i-1] scit=levels[i-1].begin(); Subcurve_iterator aux=scit; ++aux; for (; aux!=levels[i-1].end(); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } } //ALL the subcurve levels are now inserted. //step 3: insert the edge level. //first remove edges from pm then insert. //assumes there will always be a pointer ctr for Edge_iterator Edge_iterator start_edges(begin_edge), end_edges(past_end_edge); while (start_edges!=end_edges) { Edge_iterator tmp=start_edges++; //pm.remove_edge((tmp->halfedge()).current_iterator()); //the previous line is replaced by the following to deal with overlaps if (tmp->begin_child == &(*tmp)) { //no overlap pm.remove_edge((tmp->halfedge()).current_iterator()); //deletes edges //debug //Ccb_halfedge_circulator cc= *(unbounded_face()->holes_begin()); //do { //debug //std::cout << "cc->face=" << &(*cc->face()) << " unbounded=" //<< &(*unbounded_face()) << std::endl; //CGAL_assertion(cc->face()==unbounded_face()); //++cc; //} while (cc != *(unbounded_face()->holes_begin()) ); //debug //Face_handle ff=faces_begin(); //std::cout << "faces=" << &(*ff); ++ff; //std::cout << " " << &(*ff) << std::endl; } else { //tmp overlaps - don't remove the halfedges from planar map tmp->begin_child->past_end_child=tmp->past_end_child; tmp->past_end_child->begin_child=tmp->begin_child; //set the edge_node ptr of halfedges to something that is not deleted tmp->halfedge()->set_edge_node(tmp->begin_child); tmp->halfedge()->twin()->set_edge_node(tmp->begin_child); } } In_place_list edge_list; Subcurve_iterator scit=levels[i-1].begin(); Subcurve_iterator aux; for (; scit!=levels[i-1].end(); ++scit) { In_place_list el; Arr_hierarchy_ops aho(this, el, &(*scit)); pm.insert(scit->curve(), &aho); scit->begin_child=&(*(el.begin())); edge_list.splice(edge_list.end(),el); //add el at end of edge_list } scit=levels[i-1].begin(); aux=scit; ++aux; for (; aux!=levels[i-1].end(); ++scit,++aux) { scit->past_end_child=&(*(aux->begin_child)); } //step 4: insert the whole subtree back into its place and do the //finish on the stitches //number of levels in the new subtree is the same as in the old one : CGAL_assertion((unsigned int)i==level_begin.size()); Subcurve_node* return_value = &(*levels[0].begin()); //step 4.1: replacing level[0] //erasing the first node and replacing it with the new //if sc was a first child then make the new one a first child : if (sc==cn->children_begin()) { cn->begin_child=&(*levels[0].begin()); //if cn is not a curve_node, need to update previous past-end-child : if (cn->ftr!=0) { Subcurve_iterator prev_cn=cn; --prev_cn; prev_cn->past_end_child=&(*levels[0].begin()); } } (root->levels[level_number]).erase(level_begin[0],level_end[0]); level_begin[0] = level_end[0]; --level_begin[0]; //keeping the one before //insert the new level[0] into its place : (root->levels[level_number]).splice(level_end[0],levels[0]); //step 4.2: replacing the rest of the subcurve_levels //erasing the subcurve levels and replacing them with the new int k; for (k=1; klevels[k+level_number]).erase(level_begin[k],level_end[k]); level_begin[k] = level_end[k]; --level_begin[k]; //keeping the one before //for later use //define the past-end-child of the node before the inserted in //previous level //maybe need to check before I do this if the node before //(level_begin[k-1]) is not past-end of levels[k-1] level_begin[k-1]->past_end_child=&(*(levels[k].begin())); //insert the new level[k] into its place (root->levels[level_number+k]).splice(level_end[k],levels[k]); //define the past-end-child of last node inserted in the previous level Subcurve_iterator prev_last=level_end[k-1]; --prev_last; prev_last->past_end_child=&(*(level_end[k])); } //step 4.3: replacing the edge_level //do the same for the edge_level root->edge_level.erase(begin_edge,past_end_edge); //define the past-end-child of node before the inserted in previous level (level_begin[k-1])->past_end_child=&(*(edge_list.begin())); //define the past-end-child of the last node inserted in the previous level Subcurve_iterator prev_last=level_end[k-1]; --prev_last; //prev_last->past_end_child=&(*(edge_level_end)); prev_last->past_end_child=&(*(past_end_edge)); //insert the new level[k] into its place (root->edge_level).splice(past_end_edge,edge_list); return Subcurve_iterator(return_value); } /////////////////////////////////////////////////////////////////////////// // Scanning Arrangement. ///////////////////////////////////////////////////////////////////////// private: void copy_hierarchy_tree(const Self& arr) { typedef std::map ConnectMap; typedef std::map Pointer_halfedge_Map; // mapping all halfedges pointers of the two arrangements. ConnectMap cross_halfedges; Halfedge_iterator h_iter1; Halfedge_const_iterator h_iter2; // we need this for overlapping edge nodes which share pointers to // edge nodes on different hirarchies trees. ConnectMap all_edges_map; // assuming that the two containers are in the SAME order. for (h_iter1 = halfedges_begin(), h_iter2 = arr.halfedges_begin(); h_iter1 != halfedges_end() && h_iter2 != arr.halfedges_end(); ++h_iter1, ++h_iter2) cross_halfedges.insert(ConnectMap::value_type((const void*) &(*h_iter2), (void*) &(*h_iter1))); // mapping the arrangement halfedges pointers to halfedges handles. Pointer_halfedge_Map current_halfedges_pointers; for (h_iter1 = halfedges_begin(); h_iter1 != halfedges_end(); ++h_iter1) { current_halfedges_pointers.insert (Pointer_halfedge_Map::value_type((void*) &(*h_iter1), h_iter1)); } // for each curve node Curve_const_iterator cv_iter; for (cv_iter = arr.curve_list.begin(); cv_iter != arr.curve_list.end(); ++cv_iter) { // first creating the curve node. Curve_node* cn = new Curve_node; cn->assign(*cv_iter); // creating subcurve nodes. ConnectMap scn_map; unsigned int i; // for each level for (i = 0; i < cv_iter->levels.size(); ++i) { // the current level to be created In_place_list level; // for each subcurve node Subcurve_const_iterator scv_iter; for (scv_iter = cv_iter->levels[i].begin(); scv_iter != cv_iter->levels[i].end(); ++scv_iter){ Subcurve_node* scn = new Subcurve_node; scn->assign(*scv_iter); level.push_back(*scn); } // inserting the i'th level to current curve node. cn->levels.push_back(level); // copy the original items in cn->levels[i] - otherwise makes a // copy. Notice that the vector of levels is NOT in place and // hence mapping the scn pointers instead of the original values // will cause a bug!. Subcurve_iterator new_scv_iter; for (scv_iter = cv_iter->levels[i].begin(), new_scv_iter = cn->levels[i].begin(); scv_iter != cv_iter->levels[i].end() && new_scv_iter != cn->levels[i].end(); ++scv_iter, ++new_scv_iter) { scn_map.insert(ConnectMap::value_type((const void*)&(*scv_iter), (void*) &(*new_scv_iter))); } // Notice that arrangement uses the pointers of end() at each // level, instead of the expected NULL pointer. scn_map.insert(ConnectMap::value_type ((const void*) cv_iter->levels[i].end().operator->(), (void*) (cn->levels[i].end().operator->()) )); } // creating edge nodes mapping, we use it (in spite we have // all_edge_nodes) for efficientcy. ConnectMap edge_map; ConnectMap halfedge_edge_map; Edge_const_iterator edge_iter; for (edge_iter = cv_iter->edge_level.begin(); edge_iter != cv_iter->edge_level.end(); ++edge_iter){ Edge_node* en = new Edge_node; en->assign(*edge_iter); halfedge_edge_map.insert (ConnectMap::value_type((const void*) &(*edge_iter), (void*) &*(edge_iter->halfedge()) )); cn->edge_level.push_back(*en); } Edge_iterator new_edge_iter; for (edge_iter = cv_iter->edge_level.begin(), new_edge_iter = cn->edge_level.begin(); edge_iter != cv_iter->edge_level.end() && new_edge_iter != cn->edge_level.end(); ++edge_iter, ++new_edge_iter) { edge_map.insert(ConnectMap::value_type((const void*) &(*edge_iter), (void*) &(*new_edge_iter))); all_edges_map.insert(ConnectMap::value_type ((const void*) &(*edge_iter), (void*) &(*new_edge_iter))); } edge_map.insert(ConnectMap::value_type ((const void*) cv_iter->edge_level.end().operator->(), (void*) (cn->edge_level.end().operator->()) )); all_edges_map.insert(ConnectMap::value_type ((const void*)cv_iter-> edge_level.end().operator->(), (void*) (cn->edge_level.end().operator->()) )); // updating all edge nodes vector - we need this for overlapping // edge nodes which share pointers to edge nodes on different // hirarchies trees. // updating pointers between sub curve nodes. for (i = 0; i < cv_iter->levels.size(); ++i) { Subcurve_const_iterator scv_iter; Subcurve_iterator new_scv_iter; for (scv_iter = cv_iter->levels[i].begin(), new_scv_iter = cn->levels[i].begin(); scv_iter != cv_iter->levels[i].end() && new_scv_iter != cn->levels[i].end(); ++scv_iter, ++new_scv_iter) { Subcurve_node* scn = &*new_scv_iter; // if it's the first level, than the father pointer is to the // curve node cn; if (i == 0) scn->ftr = cn; else { Subcurve_node* scn_ftr = (Subcurve_node*) (scn_map.find((const void*) &*(scv_iter->ftr))->second); scn->ftr = scn_ftr; } // if the level is not the last one. if (i+1 < cv_iter->levels.size()) { Subcurve_node* scn_begin_child = (Subcurve_node*)(scn_map.find ((const void*) scv_iter->begin_child)->second); scn->begin_child = scn_begin_child; // pay attention to the fact that the past_end_child can be end(). Subcurve_node* scn_past_end_child = (Subcurve_node*) (scn_map.find((const void*) scv_iter->past_end_child)->second); scn->past_end_child = scn_past_end_child; } else { // last level - the next level is the edge node. Edge_node* scn_begin_child = (Edge_node*) (edge_map.find((const void*) scv_iter->begin_child)->second); scn->begin_child = scn_begin_child; // pay attention to the fact that the past_end_child can be end() Edge_node* scn_past_end_child = (Edge_node*) (edge_map.find((const void*) scv_iter->past_end_child)->second); scn->past_end_child = scn_past_end_child; } } } // updating the father pointer of edge node. new_edge_iter = cn->edge_level.begin(); edge_iter = cv_iter->edge_level.begin(); for (edge_iter = cv_iter->edge_level.begin(), new_edge_iter = cn->edge_level.begin(); edge_iter != cv_iter->edge_level.end() && new_edge_iter != cn->edge_level.end(); ++edge_iter, ++new_edge_iter) { Edge_node* en = &*new_edge_iter; if (cn->levels.size() == 0) en->ftr = cn; else en->ftr = (Subcurve_node*) (scn_map.find((const void*) edge_iter->ftr)->second); } // updating cn begin and end children pointers. if (cn->levels.size()) { cn->begin_child = &(*(cn->levels[0].begin())); cn->past_end_child = &(*(cn->levels[0].end())); } else { cn->begin_child = &(*(cn->edge_level.begin())); cn->past_end_child = &(*(cn->edge_level.end())); } cn->ftr = 0; curve_list.push_back(*cn); } // running on both curve lists and upfdating edge node pointers. // Notice that when updating edge node childrens we need all edge // nodes to be defined since when there are overlappings edge nodes // will points to other edge nodes on different curve lists. Curve_iterator new_cv_iter; for (cv_iter = arr.curve_list.begin(), new_cv_iter = curve_list.begin(); cv_iter != arr.curve_list.end() && new_cv_iter != curve_list.end(); ++cv_iter, ++new_cv_iter){ Edge_iterator new_edge_iter = new_cv_iter->edge_level.begin(); Edge_const_iterator edge_iter = cv_iter->edge_level.begin(); for (edge_iter = cv_iter->edge_level.begin(), new_edge_iter = new_cv_iter->edge_level.begin(); edge_iter != cv_iter->edge_level.end() && new_edge_iter != new_cv_iter->edge_level.end(); ++edge_iter, ++new_edge_iter) { Edge_node* en = &*new_edge_iter; Edge_node* en_begin_child = (Edge_node*) (all_edges_map.find ((const void*) &*(edge_iter->begin_child))->second); en->begin_child = en_begin_child; Edge_node* en_past_end_child = (Edge_node*) (all_edges_map.find ((const void*) &*(edge_iter->past_end_child))->second); en->past_end_child = en_past_end_child; Halfedge* hp = (Halfedge*) (cross_halfedges.find(&*(edge_iter->halfedge() ))->second); Halfedge_handle curr_h = current_halfedges_pointers.find(hp)->second; curr_h->set_edge_node(en); curr_h->twin()->set_edge_node(en); // notice the fact that curr_h is in the direction of en->curve(), // since cross_halfedges maps the halfedge pointers 1-1. en->hdg = curr_h; } } } template bool scan_arr (Scanner& scanner) { typedef typename Dcel::Vertex D_vertex; typedef typename Dcel::Halfedge D_halfedge; typedef typename Dcel::Face D_face; typedef typename Dcel::Vertex_iterator D_vetrex_iterator; typedef typename Dcel::Vertex_const_iterator D_vetrex_const_iterator; typedef typename Dcel::Halfedge_iterator D_halfedge_iterator; typedef typename Dcel::Halfedge_const_iterator D_halfedge_const_iterator; typedef typename Dcel::Face_iterator D_face_iterator; typedef typename Dcel::Face_const_iterator D_face_const_iterator; typedef std::pair Index_pair; // keeping a vector of halfedges (to access them easily by their indices) std::vector halfedges_vec; if (!scanner.in()) return false; if (!pm.read(scanner.in(), scanner)) { std::cerr << "can't read planar map"< > en_ovlp_child_indices_all_lists; std::size_t number_of_curves; scanner.scan_index(number_of_curves); if (!scanner.in()) { std::cerr << "can't read number of curves"< > begin_child_indices_table, end_child_indices_table; //std::vector > scn_table; unsigned int j; for (j = 0; j < number_of_levels; j++) { // reading level j. std::size_t number_of_subcurves; scanner.scan_index(number_of_subcurves); if (!scanner.in()) { std::cerr << "can't read number of subcurves"< scn_list; std::vector begin_child_indices_vec, end_child_indices_vec; //std::vector scn_vec; for (unsigned int k = 0; k < number_of_subcurves; k++) { std::size_t begin_child_index, end_child_index; scanner.scan_index(begin_child_index); if (! scanner.in()){ std::cerr << "can't read begin child index"<ftr = cn; scn_list.push_back(*scn); // update the tmp vector for finding scn pointers according indices. //scn_vec.push_back(scn); } begin_child_indices_table.push_back(begin_child_indices_vec); end_child_indices_table.push_back(end_child_indices_vec); (cn->levels).push_back(scn_list); } // now scanning edge nodes. std::size_t number_of_edge_nodes; scanner.scan_index(number_of_edge_nodes); if (! scanner.in()){ std::cerr << "can't read numberof edge nodes"< en_ovlp_child_indices_list; for (j = 0; j < number_of_edge_nodes; j++) { //std::vector en_ovlp_child_indices_vec; Edge_node* en = new Edge_node; std::size_t halfedge_index; std::size_t cn_ovlp_index, en_ovlp_index; // scanning the past to end child of edge node // (this pointer indicates the overlapping edge nodes). scanner.scan_index(cn_ovlp_index); if (! scanner.in()){ std::cerr << "can't read begin overlapping index"<hdg = halfedges_vec[halfedge_index]; en->ftr = cn; // update the pointer in halfedge and its twin to edge_nodes. halfedges_vec[halfedge_index]->set_edge_node(en); halfedges_vec[halfedge_index]->twin()->set_edge_node(en); // updating cn list. cn->edge_level.push_back(*en); } en_ovlp_child_indices_all_lists.push_back(en_ovlp_child_indices_list); // updating cn begin and end children pointers. if (number_of_levels){ cn->begin_child = &(*(cn->levels[0].begin())); cn->past_end_child = &(*(cn->levels[0].end())); } else { cn->begin_child = cn->edge_level.begin().operator->(); cn->past_end_child = cn->edge_level.end().operator->(); } // now updating begin and past end children pointers of each // subcurve node and also its pointer to its father. for (j = 0; j < number_of_levels; j++) { unsigned int k = 0, l = 0, m = 0; Subcurve_iterator scn_child_iter; Edge_iterator en_child_iter = cn->edges_begin(); if (j+1 < number_of_levels) // else - we use the en_child_iter. scn_child_iter = cn->level_begin(j+1); for (Subcurve_iterator scn_iter = cn->level_begin(j); scn_iter != cn->level_end(j); scn_iter++, k++){ if (j+1 < number_of_levels){ // not including the last one. std::size_t begin_child_index = begin_child_indices_table[j][k]; for (; l < begin_child_index && scn_child_iter != cn->level_end(j+1); scn_child_iter++, l++); scn_iter->begin_child = &(*scn_child_iter); std::size_t past_end_child_index = end_child_indices_table[j][k]; // running the pointer and also updating father field. for (; l < past_end_child_index && scn_child_iter != cn->level_end(j+1); scn_child_iter++, l++){ scn_child_iter->ftr = scn_iter.operator->(); } scn_iter->past_end_child = &(*scn_child_iter); } else { //the last one should point to the edge nodes. std::size_t begin_child_index = begin_child_indices_table[j][k]; for(; m < begin_child_index && en_child_iter != cn->edges_end(); en_child_iter++, m++) ; scn_iter->begin_child = &(*en_child_iter); std::size_t past_end_child_index = end_child_indices_table[j][k]; // running the pointer and also updating father field. for(; m < past_end_child_index && en_child_iter != cn->edges_end(); en_child_iter++, m++){ en_child_iter->ftr = scn_iter.operator->(); } scn_iter->past_end_child = &(*en_child_iter); } } } curve_list.push_back(*cn); } // now updating edge node childs, which indicates overlapping edge nodes. Curve_iterator cn_iter = curve_node_begin(); std::list >::iterator all_lists_iter = en_ovlp_child_indices_all_lists.begin(); for (; all_lists_iter != en_ovlp_child_indices_all_lists.end() && cn_iter != curve_node_end(); all_lists_iter++, cn_iter++){ Edge_iterator en_iter = cn_iter->edges_begin(); for (std::list::iterator list_iter = (*all_lists_iter).begin(); list_iter != (*all_lists_iter).end() && en_iter != cn_iter->edges_end(); list_iter++, en_iter++) { std::size_t cn_ovlp_index = list_iter->first; std::size_t en_ovlp_index = list_iter->second; unsigned int j; Curve_iterator tmp_cn_iter; for (tmp_cn_iter = curve_node_begin(), j = 0; tmp_cn_iter != curve_node_end() && j < cn_ovlp_index; tmp_cn_iter++, j++); // now tmp_cn_iter is the cn_ovlp_index'th curve node. Edge_iterator tmp_en_iter; for (tmp_en_iter = tmp_cn_iter->edges_begin(), j = 0; tmp_en_iter != tmp_cn_iter->edges_end() && j < en_ovlp_index; tmp_en_iter++, j++); // now tmp_en_iter is the en_ovlp_index'th edge node. en_iter->past_end_child = tmp_en_iter.operator->(); } } return true; } /////////////////////////////////////////////////////////////////////////// private: bool use_delete_pl; bool use_delete_traits; protected: //debug //public: Traits_wrap *traits; Pmwx pm; In_place_list curve_list; //for UPDATE mode bool do_update; Curve_iterator last_updated; /* //debug public: friend ::std::ostream& operator<<(::std::ostream& o, const Curve_iterator& cn) { o << "Curve_node: " << cn->curve() << std::endl; for (unsigned int i=0; inumber_of_sc_levels(); ++i) { o << "Level" << i << ": "; for (Subcurve_iterator scit=cn->level_begin(i); scit!=cn->level_end(i); ++scit) { o << scit->curve() << " , " ; } o << std::endl; } o <<"Edge level: "; for (Edge_iterator eit=cn->edges_begin(); eit!=cn->edges_end(); ++eit) { o << eit->curve() << " , " ; } o << std::endl; return o; } */ }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/edge_list.h0000644000175000017500000002112011344301500027124 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/edge_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_EDGE_LIST_H #define CGAL_EDGE_LIST_H #include CGAL_BEGIN_NAMESPACE namespace CGALi { class Edge_hash_function : public Handle_hash_function { private: typedef Handle_hash_function Base; public: typedef Base::result_type result_type; template result_type operator()(const Edge& e) const { return (Base::operator()(e.first)) << e.second; } }; template class Edge_list_item { public: typedef Edge_t Edge; private: typedef typename Edge::first_type Face_handle; private: Edge prev_; Edge next_; public: // remove the following method and make SENTINEL_EDGE a static const // member of the class. static const Edge& sentinel_edge() { static Edge SENTINEL_EDGE = Edge(Face_handle(), sentinel_index()); return SENTINEL_EDGE; } private: static int sentinel_index() { return -1; } public: Edge_list_item() : prev_(sentinel_edge()), next_(sentinel_edge()) {} Edge_list_item(const Edge& prev, const Edge& next) : prev_(prev), next_(next) {} bool is_in_list() const { return ( next_.second != sentinel_index() || prev_.second != sentinel_index() ); } void set_next(const Edge& next) { next_ = next; } void set_previous(const Edge& prev) { prev_ = prev; } const Edge& next() const { return next_; } const Edge& previous() const { return prev_; } void reset() { Edge SENTINEL_EDGE = sentinel_edge(); next_ = prev_ = SENTINEL_EDGE; } }; template struct Edge_list_which_map; // use STL's map template struct Edge_list_which_map { typedef E_t Edge; typedef ListItem List_item; typedef std::map Edge_map; }; // use CGAL's Unique_hash_map template struct Edge_list_which_map { typedef E_t Edge; typedef ListItem List_item; typedef CGALi::Edge_hash_function Hash_function; typedef Unique_hash_map Edge_map; }; } // namespace CGALi template class Edge_list { public: // TYPES //====== typedef std::size_t size_type; typedef Edge_t Edge; typedef USE_STL_MAP_Tag Use_stl_map_tag; private: typedef CGALi::Edge_list_item List_item; typedef CGALi::Edge_list_which_map Which_map; typedef typename Which_map::Edge_map Edge_map; private: // PRIVATE DATA MEMBERS //===================== Edge_map emap; Edge front_; size_type size_; private: // PRIVATE METHODS //================ void increase_size() { size_++; } void decrease_size() { size_--; } void insert_before_nocheck(const Edge& e, const Edge& new_e) { List_item& li_e = emap[e]; const Edge& prev_e = li_e.previous(); List_item& li_prev_e = emap[prev_e]; emap[new_e] = List_item(prev_e, e); li_e.set_previous(new_e); li_prev_e.set_next(new_e); increase_size(); } // check whether the edge is in the list; // the map used is STL's map bool is_in_list_with_tag(const Edge& e, const Tag_true&) const { if ( emap.find(e) == emap.end() ) { return false; } return emap.find(e)->second.is_in_list(); } // check whether the edge is in the list; // the map used is CGAL's Unique_hash_map bool is_in_list_with_tag(const Edge& e, const Tag_false&) const { if ( !emap.is_defined(e) ) { return false; } return emap[e].is_in_list(); } // return the next edge in the list; // the map used is STL's map const Edge& next_with_tag(const Edge& e, const Tag_true&) const { return emap.find(e)->second.next(); } // return the next edge in the list; // the map used is CGAL's Unique_hash_map const Edge& next_with_tag(const Edge& e, const Tag_false&) const { return emap[e].next(); } // return the previous edge in the list; // the map used is STL's map const Edge& previous_with_tag(const Edge& e, const Tag_true&) const { return emap.find(e)->second.previous(); } // return the previous edge in the list; // the map used is CGAL's Unique_hash_map const Edge& previous_with_tag(const Edge& e, const Tag_false&) const { return emap[e].previous(); } public: // CONSTRUCTOR //============ #ifdef _MSC_VER Edge_list(const Edge& e = Edge(typename Edge::first_type(),-1) ) : emap(), front_(e), size_(0) {} #else Edge_list(const Edge& e = List_item::sentinel_edge() ) : emap(), front_(e), size_(0) {} #endif // PREDICATES //=========== bool is_valid() const { return true; } bool is_in_list(const Edge& e) const { static Use_stl_map_tag map_tag; return is_in_list_with_tag(e, map_tag); } // ACCESS METHODS //=============== size_type size() const { return size_; } const Edge& next(const Edge& e) const { CGAL_precondition( is_in_list(e) ); static Use_stl_map_tag map_tag; return next_with_tag(e, map_tag); } const Edge& previous(const Edge& e) const { CGAL_precondition( is_in_list(e) ); static Use_stl_map_tag map_tag; return previous_with_tag(e, map_tag); } const Edge& front() const { CGAL_precondition( size() > 0 ); return front_; } const Edge& back() const { CGAL_precondition( size() > 0 ); return previous(front_); } // INSERTION //========== void push_front(const Edge& e) { push_back(e); front_ = e; } void push_back(const Edge& e) { CGAL_precondition( !is_in_list(e) ); if ( size() == 0 ) { emap[e] = List_item(e,e); front_ = e; increase_size(); return; } insert_before_nocheck(front_, e); } void insert_after(const Edge& e, const Edge& new_e) { CGAL_precondition( is_in_list(e) ); CGAL_precondition( !is_in_list(new_e) ); List_item& li_e = emap[e]; const Edge& next_e = li_e.next(); List_item& li_next_e = emap[next_e]; emap[new_e] = List_item(e, next_e); li_e.set_next(new_e); li_next_e.set_previous(new_e); increase_size(); } void insert_before(const Edge& e, const Edge& new_e) { CGAL_precondition( is_in_list(e) ); CGAL_precondition( !is_in_list(new_e) ); insert_before_nocheck(e, new_e); } // REPLACEMENT //============ void replace(const Edge& e, const Edge& new_e) { CGAL_precondition( is_in_list(e) ); CGAL_precondition( !is_in_list(new_e) ); List_item& li_e = emap[e]; if ( size() == 1 ) { emap[new_e] = List_item(new_e, new_e); front_ = new_e; li_e.reset(); } const Edge& next_e = li_e.next(); const Edge& prev_e = li_e.previous(); emap[prev_e].set_next(new_e); emap[next_e].set_previous(new_e); emap[new_e] = List_item(prev_e, next_e); li_e.reset(); if ( e == front_ ) { front_ = new_e; } } // REMOVAL //======== void remove(const Edge& e) { CGAL_precondition( is_in_list(e) ); if ( size() == 1 ) { front_ = List_item::sentinel_edge(); emap[e].reset(); decrease_size(); return; } List_item& li_e = emap[e]; const Edge& next_e = li_e.next(); const Edge& prev_e = li_e.previous(); emap[prev_e].set_next(next_e); emap[next_e].set_previous(prev_e); if ( e == front_ ) { // front_ = next_e; front_ = next_e; } li_e.reset(); decrease_size(); } // MISCELLANEOUS //============== void clear() { emap.clear(); } }; CGAL_END_NAMESPACE #endif // CGAL_EDGE_LIST_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Line_2_inte0000644000175000017500000000223711344301501031145 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_xy_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidea0000644000175000017500000000731211344301501031422 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_xy_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_XY_3_H #define CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_XY_3_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Orientation_xy_3 { public: typedef typename R::Point_3 Point; typename R::FT x(const Point &p) const { return p.x(); } typename R::FT y(const Point &p) const { return p.y(); } CGAL::Orientation operator()(const Point& p, const Point& q, const Point& r) { return orientationC2(x(p), y(p), x(q), y(q), x(r), y(r)); } }; template class Side_of_oriented_circle_xy_3 { public: typedef typename R::Point_3 Point; typename R::FT x(const Point &p) const { return p.x(); } typename R::FT y(const Point &p) const { return p.y(); } CGAL::Oriented_side operator() (const Point &p, const Point &q, const Point &r, const Point &s) { return side_of_oriented_circleC2(x(p), y(p), x(q), y(q), x(r), y(r), x(s), y(s)); } }; template < class R > class Triangulation_euclidean_traits_xy_3 { public: typedef Triangulation_euclidean_traits_xy_3 Traits; typedef R Rp; typedef typename Rp::Point_3 Point_2; typedef typename Rp::Segment_3 Segment_2; typedef typename Rp::Triangle_3 Triangle_2; typedef typename Rp::Compare_x_3 Compare_x_2; typedef typename Rp::Compare_y_3 Compare_y_2; typedef Orientation_xy_3 Orientation_2; typedef Side_of_oriented_circle_xy_3 Side_of_oriented_circle_2; typedef typename Rp::Construct_segment_3 Construct_segment_2; typedef typename Rp::Construct_triangle_3 Construct_triangle_2; // for compatibility with previous versions typedef Point_2 Point; typedef Segment_2 Segment; typedef Triangle_2 Triangle; Triangulation_euclidean_traits_xy_3(){} Triangulation_euclidean_traits_xy_3( const Triangulation_euclidean_traits_xy_3&){} Triangulation_euclidean_traits_xy_3 &operator=( const Triangulation_euclidean_traits_xy_3&){return *this;} typename Rp::FT x(const Point_2 &p) const { return p.x(); } typename Rp::FT y(const Point_2 &p) const { return p.y(); } Compare_x_2 compare_x_2_object() const { return Compare_x_2();} Compare_y_2 compare_y_2_object() const { return Compare_y_2();} Orientation_2 orientation_2_object() const { return Orientation_2();} Side_of_oriented_circle_2 side_of_oriented_circle_2_object() const {return Side_of_oriented_circle_2();} Construct_segment_2 construct_segment_2_object() const {return Construct_segment_2();} Construct_triangle_2 construct_triangle_2_object() const {return Construct_triangle_2();} }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_XY_3_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_face_min_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_face_min_ba0000644000175000017500000000447211344301500031163 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_face_min_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_FACE_MIN_BASE_H #define CGAL_HALFEDGEDS_FACE_MIN_BASE_H 1 #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE template < class Refs> class HalfedgeDS_face_min_base { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_face_min_base< Refs> Base; typedef Tag_false Supports_face_halfedge; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Halfedge Halfedge; // Additional tags required by Polyhedron. typedef Tag_false Supports_face_plane; struct Plane_not_supported {}; typedef Plane_not_supported Plane; }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_FACE_MIN_BASE_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Range_tree_k.h0000644000175000017500000003021011344301500027552 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Range_tree_k.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef __CGAL_Range_tree_k__ #define __CGAL_Range_tree_k__ // Predefined k-dimensional Range Trees (k=1..4) // The trees can either be templated with d arbitrary types // (e.g., Range_tree_3) // or with an unary type for each dimension // (e.g., Range_tree_uni_4). // The container class and sequence container class as well as the // interfaces are defined in these classes. #include #include #include #include #include //------------------------------------------------------------------- // A one dimensional Range Tree is defined in this class. // Ti is the type of each dimension of the tree. CGAL_BEGIN_NAMESPACE template class Range_tree_1 { public: typedef C_Traits_1 Traits; typedef typename C_Traits_1::Key Key; typedef typename C_Traits_1::Interval Interval; typedef typename C_Traits_1::Key_1 Key_1; typedef typename C_Traits_1::key_1 key_1; typedef typename C_Traits_1::low_1 low_1; typedef typename C_Traits_1::high_1 high_1; typedef typename C_Traits_1::compare_1 compare_1; typedef tree_point_traits I1; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; Range_tree_1_type * range_tree_1; Range_tree_1() { anchor = new Tree_anchor_type; range_tree_1 = new Range_tree_1_type(*anchor); } template Range_tree_1(const T& first, const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)) { range_tree_1->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete range_tree_1; delete anchor; anchor = new Tree_anchor_type; range_tree_1 = new Range_tree_1_type(*anchor); return range_tree_1->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return range_tree_1->window_query(win, result); } ~Range_tree_1() { if (range_tree_1!=0) delete range_tree_1; if (anchor!=0) delete anchor; } }; //------------------------------------------------------------------- // A two dimensional Range Tree is defined in this class. // Ti is the type of each dimension of the tree. template class Range_tree_2 { public: typedef C_Traits_2 Traits; typedef typename C_Traits_2::Key Key; typedef typename C_Traits_2::Interval Interval; typedef typename C_Traits_2::Key_2 Key_2; typedef typename C_Traits_2::Key_1 Key_1; typedef typename C_Traits_2::key_1 key_1; typedef typename C_Traits_2::key_2 key_2; typedef typename C_Traits_2::low_1 low_1; typedef typename C_Traits_2::high_1 high_1; typedef typename C_Traits_2::low_2 low_2; typedef typename C_Traits_2::high_2 high_2; typedef typename C_Traits_2::compare_1 compare_1; typedef typename C_Traits_2::compare_2 compare_2; typedef tree_point_traits I1; typedef tree_point_traits I2; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; Range_tree_1_type * range_tree_1; typedef Range_tree_d Range_tree_2_type; Range_tree_2_type *range_tree_2; Range_tree_2() : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)) {} template Range_tree_2(const T& first, const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)) { range_tree_2->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete range_tree_2; delete range_tree_1; delete anchor; anchor = new Tree_anchor_type; range_tree_1 = new Range_tree_1_type(*anchor); range_tree_2 = new Range_tree_2_type(*range_tree_1); return range_tree_2->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return range_tree_2->window_query(win, result); } ~Range_tree_2() { if (range_tree_2!=0) delete range_tree_2; if (range_tree_1!=0) delete range_tree_1; if (anchor!=0) delete anchor; } }; //------------------------------------------------------------------- // A three dimensional Range Tree is defined in this class. // Ti is the type of each dimension of the tree. template class Range_tree_3 { public: typedef C_Traits_3 Traits; typedef typename C_Traits_3::Key Key; typedef typename C_Traits_3::Interval Interval; typedef typename C_Traits_3::Key_1 Key_1; typedef typename C_Traits_3::Key_2 Key_2; typedef typename C_Traits_3::Key_3 Key_3; typedef typename C_Traits_3::key_1 key_1; typedef typename C_Traits_3::key_2 key_2; typedef typename C_Traits_3::key_3 key_3; typedef typename C_Traits_3::low_1 low_1; typedef typename C_Traits_3::high_1 high_1; typedef typename C_Traits_3::low_2 low_2; typedef typename C_Traits_3::high_2 high_2; typedef typename C_Traits_3::low_3 low_3; typedef typename C_Traits_3::high_3 high_3; typedef typename C_Traits_3::compare_1 compare_1; typedef typename C_Traits_3::compare_2 compare_2; typedef typename C_Traits_3::compare_3 compare_3; typedef tree_point_traits I1; typedef tree_point_traits I2; typedef tree_point_traits I3; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; Range_tree_1_type * range_tree_1; typedef Range_tree_d Range_tree_2_type; Range_tree_2_type * range_tree_2; typedef Range_tree_d Range_tree_3_type; Range_tree_3_type *range_tree_3; Range_tree_3() : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)), range_tree_3(new Range_tree_3_type(*range_tree_2)) {} template Range_tree_3(const T& first, const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)), range_tree_3(new Range_tree_3_type(*range_tree_2)) { range_tree_3->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete range_tree_3; delete range_tree_2; delete range_tree_1; delete anchor; anchor = new Tree_anchor_type; range_tree_1 = new Range_tree_1_type(*anchor); range_tree_2 = new Range_tree_2_type(*range_tree_1); range_tree_3 = new Range_tree_3_type(*range_tree_2); return range_tree_3->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return range_tree_3->window_query(win, result); } ~Range_tree_3() { if (range_tree_3!=0) delete range_tree_3; if (range_tree_2!=0) delete range_tree_2; if (range_tree_1!=0) delete range_tree_1; if (anchor!=0) delete anchor; } }; //------------------------------------------------------------------- // A three dimensional Range Tree is defined in this class. // Ti is the type of each dimension of the tree. template class Range_tree_4 { public: typedef C_Traits_4 Traits; typedef typename C_Traits_4::Key Key; typedef typename C_Traits_4::Interval Interval; typedef typename C_Traits_4::Key_1 Key_1; typedef typename C_Traits_4::Key_2 Key_2; typedef typename C_Traits_4::Key_3 Key_3; typedef typename C_Traits_4::Key_4 Key_4; typedef typename C_Traits_4::key_1 key_1; typedef typename C_Traits_4::key_2 key_2; typedef typename C_Traits_4::key_4 key_4; typedef typename C_Traits_4::key_3 key_3; typedef typename C_Traits_4::low_1 low_1; typedef typename C_Traits_4::high_1 high_1; typedef typename C_Traits_4::low_2 low_2; typedef typename C_Traits_4::high_2 high_2; typedef typename C_Traits_4::low_3 low_3; typedef typename C_Traits_4::high_3 high_3; typedef typename C_Traits_4::low_4 low_4; typedef typename C_Traits_4::high_4 high_4; typedef typename C_Traits_4::compare_1 compare_1; typedef typename C_Traits_4::compare_2 compare_2; typedef typename C_Traits_4::compare_3 compare_3; typedef typename C_Traits_4::compare_4 compare_4; typedef tree_point_traits I1; typedef tree_point_traits I2; typedef tree_point_traits I3; typedef tree_point_traits I4; typedef Tree_anchor Tree_anchor_type; Tree_anchor_type *anchor; typedef Range_tree_d Range_tree_1_type; Range_tree_1_type * range_tree_1; typedef Range_tree_d Range_tree_2_type; Range_tree_2_type * range_tree_2; typedef Range_tree_d Range_tree_3_type; Range_tree_3_type *range_tree_3; typedef Range_tree_d Range_tree_4_type; Range_tree_4_type *range_tree_4; Range_tree_4() : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)), range_tree_3(new Range_tree_3_type(*range_tree_2)), range_tree_4(new Range_tree_4_type(*range_tree_3)) {} template Range_tree_4(const T& first, const T& last) : anchor(new Tree_anchor_type), range_tree_1(new Range_tree_1_type(*anchor)), range_tree_2(new Range_tree_2_type(*range_tree_1)), range_tree_3(new Range_tree_3_type(*range_tree_2)), range_tree_4(new Range_tree_4_type(*range_tree_3)) { range_tree_4->make_tree(first,last); } template bool make_tree(const T& first, const T& last) { delete range_tree_4; delete range_tree_3; delete range_tree_2; delete range_tree_1; delete anchor; anchor = new Tree_anchor_type; range_tree_1 = new Range_tree_1_type(*anchor); range_tree_2 = new Range_tree_2_type(*range_tree_1); range_tree_3 = new Range_tree_3_type(*range_tree_2); range_tree_4 = new Range_tree_4_type(*range_tree_3); return range_tree_4->make_tree(first,last); } template T window_query(Interval const &win, const T& result) { return range_tree_4->window_query(win, result); } ~Range_tree_4() { if (range_tree_4!=0) delete range_tree_4; if (range_tree_3!=0) delete range_tree_3; if (range_tree_2!=0) delete range_tree_2; if (range_tree_1!=0) delete range_tree_1; if (anchor!=0) delete anchor; } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/is_degenerate_polygon_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/is_degenerate_polygon_0000644000175000017500000000427711344301500031461 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/is_degenerate_polygon_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_IS_DEGENERATE_POLYGON_2_H #define CGAL_IS_DEGENERATE_POLYGON_2_H namespace CGAL { // tests if a sequence of points represents a degenerate polygon (i.e. // one of zero area) template bool is_degenerate_polygon_2(BidirectionalIterator first, BidirectionalIterator last, const Traits& traits) { if (first == last) return true; BidirectionalIterator prev = last; prev--; BidirectionalIterator curr = first; BidirectionalIterator next = first; next++; // fewer than three vertices if (prev == first) return true; if (next == last) return true; typedef typename Traits::Orientation_2 Orientation_2; Orientation_2 orientation = traits.orientation_2_object(); while (curr != last) { if (orientation(*prev, *curr, *next) != COLLINEAR) return false; prev++; if (prev == last) prev = first; next++; if (next == last) next = first; curr++; } return true; } template bool is_degenerate_polygon_2(InputIterator first, InputIterator last) { if (first == last) return true; typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return is_degenerate_polygon_2(first, last, K()); } } #endif // CGAL_IS_DEGENERATE_POLYGON_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config.h0000644000175000017500000001053411344301500026441 0ustar debiandebian// Copyright (c) 1997-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/config.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink // Michael Hoffmann // Sylvain Pion #ifndef CGAL_CONFIG_H #define CGAL_CONFIG_H #include //----------------------------------------------------------------------// // include platform specific workaround flags (CGAL_CFG_...) //----------------------------------------------------------------------// #include //----------------------------------------------------------------------// // do some post processing for the flags //----------------------------------------------------------------------// #ifdef CGAL_CFG_NO_STL # error "This compiler does not have a working STL" #endif #ifdef CGAL_CFG_NO_NAMESPACE # define CGAL_USING_NAMESPACE_STD # define CGAL_STD # define CGAL std #else # define CGAL_USING_NAMESPACE_STD using namespace std; # define CGAL_STD std # ifndef CGAL_USE_NAMESPACE # define CGAL_USE_NAMESPACE 1 # endif #endif #if CGAL_USE_NAMESPACE # define CGAL_BEGIN_NAMESPACE namespace CGAL { # define CGAL_END_NAMESPACE } #else # define CGAL_BEGIN_NAMESPACE # define CGAL_END_NAMESPACE #endif #ifdef CGAL_CFG_NO_STDC_NAMESPACE # define CGAL_CLIB_STD #else # define CGAL_CLIB_STD std #endif #ifndef CGAL_CFG_NO_LONG_LONG # define CGAL_USE_LONG_LONG #endif // FIXME: what is the problem with Sun 5.5? MATCHING_BUG_4 is not // triggered, but there are runtime errors, e.g., with Distance_3, // that do not appear when using the wrapper... #if defined(CGAL_CFG_MATCHING_BUG_4) || \ (defined(__sun) && defined(__SUNPRO_CC)) namespace CGAL { template < typename T > struct Self { typedef T Type; }; } # define CGAL_WRAP(K) CGAL::Self::Type #else # define CGAL_WRAP(K) K #endif #ifndef CGAL_CFG_TYPENAME_BEFORE_DEFAULT_ARGUMENT_BUG # define CGAL_TYPENAME_DEFAULT_ARG typename #else # define CGAL_TYPENAME_DEFAULT_ARG #endif //----------------------------------------------------------------------// // include separate workaround files //----------------------------------------------------------------------// #ifdef _MSC_VER # include #endif #if defined(__BORLANDC__) && __BORLANDC__ > 0x520 #include #endif #if defined(__sun) && defined(__SUNPRO_CC) #include #endif //--------------------------------------------------------------------// // This addresses a bug in VC++ 7.0 that (re)defines min(a, b) // and max(a, b) in windows.h and windef.h //-------------------------------------------------------------------// #ifdef _MSC_VER # define NOMINMAX 1 #endif //-------------------------------------------------------------------// // When the global min and max are no longer defined (as macros) // because of NOMINMAX flag definition, we define our own global // min/max functions to make the Microsoft headers compile. (afxtempl.h) // Users that does not want the global min/max // should define CGAL_NOMINMAX //-------------------------------------------------------------------// #include #if defined NOMINMAX && !defined CGAL_NOMINMAX using std::min; using std::max; #endif // Is Geomview usable ? #if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__) # define CGAL_USE_GEOMVIEW #endif #endif // CGAL_CONFIG_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/New_delete_allocator.h0000644000175000017500000000457011344301500031312 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/New_delete_allocator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_NEW_DELETE_ALLOCATOR_H #define CGAL_NEW_DELETE_ALLOCATOR_H #include CGAL_BEGIN_NAMESPACE template class New_delete_allocator { public: typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef T value_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; typedef const T& const_reference; template struct rebind { typedef New_delete_allocator other; }; New_delete_allocator() {} // Uses the default constructor of T. pointer allocate(size_type n, const_pointer = 0) const { return new T[n]; } // p should have an appropriate type // That's why we need the parameterization // T should have a virtual destructor void deallocate(pointer p, size_type) const { delete[] p; } pointer address(reference) const { return static_cast(0); } const_pointer address(const_reference) const { return static_cast(0); } void construct(pointer ptr, const_reference ref) const { *ptr = ref; } // We can't do anything here. void destroy(pointer) const { } size_type max_size() const { return 0; } }; CGAL_END_NAMESPACE #endif // CGAL_NEW_DELETE_ALLOCATOR_H ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_filtered_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000002617511344301501031403 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_filtered_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_FILTERED_TRAITS_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_FILTERED_TRAITS_2_H #include #include // includes for the default parameters of the filtered traits #ifdef CGAL_USE_GMP #include #else #include #include #endif #include #include #include #include CGAL_BEGIN_NAMESPACE #if defined(__sun) && defined(__SUNPRO_CC) // workaround for the Sun CC-5.30 compiler; it does not like default // template parameters that are themselves templates and have // templated classes as parameters, which have then nested types as // arguments... oooof!!! // // In case you did understand what I just described you are most // probably crazy... If you did not, look below to see what kind of // code CC-5.30 did not like. namespace CGALi { template struct SVD_SUNPRO_CC_Interval_converter : public Cartesian_converter > { }; } #endif namespace CGALi { template struct SVD_Concept_check_tags {}; template struct SVD_Concept_check_tags { SVD_Concept_check_tags() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags { SVD_Concept_check_tags() { THE_4TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags { SVD_Concept_check_tags() { THE_6TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( D() ); } }; //------------------------------------------------------------------------- template struct SVD_Concept_check_tags { SVD_Concept_check_tags() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags { SVD_Concept_check_tags() { THE_4TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags { SVD_Concept_check_tags() { THE_6TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Field_tag_OR_Sqrt_field_tag ( D() ); } }; //========================================================================= template struct SVD_Concept_check_tags_wi {}; template struct SVD_Concept_check_tags_wi { SVD_Concept_check_tags_wi() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags_wi { SVD_Concept_check_tags_wi() { THE_4TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags_wi { SVD_Concept_check_tags_wi() { THE_6TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( D() ); } }; //------------------------------------------------------------------------- template struct SVD_Concept_check_tags_wi { SVD_Concept_check_tags_wi() { THE_2ND_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags_wi { SVD_Concept_check_tags_wi() { THE_4TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( D() ); } }; template struct SVD_Concept_check_tags_wi { SVD_Concept_check_tags_wi() { THE_6TH_TEMPLATE_PARAMETER_MUST_EITHER_BE_Ring_tag_OR_Sqrt_field_tag ( D() ); } }; } //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- // the filtered Traits classes //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- // this traits class does support intersecting segments template, #else class EK = Simple_cartesian< Quotient >, #endif class EK_MTag = Field_tag, class FK = Simple_cartesian< Interval_nt >, class FK_MTag = Sqrt_field_tag, class C2E = Cartesian_converter, #if defined(__sun) && defined(__SUNPRO_CC) class C2F = CGALi::SVD_SUNPRO_CC_Interval_converter > #else class C2F = Cartesian_converter > > #endif struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); CGALi::SVD_Concept_check_tags(); CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { public: Segment_Voronoi_diagram_filtered_traits_2() { CGALi::SVD_Concept_check_tags(); } }; template struct Segment_Voronoi_diagram_filtered_traits_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 {}; //========================================================================= // this traits class does NOT support intersecting segments template, #else class EK = Simple_cartesian< MP_Float >, #endif class EK_MTag = Ring_tag, class FK = Simple_cartesian< Interval_nt >, class FK_MTag = Sqrt_field_tag, class C2E = Cartesian_converter, #if defined(__sun) && defined(__SUNPRO_CC) class C2F = CGALi::SVD_SUNPRO_CC_Interval_converter > #else class C2F = Cartesian_converter > > #endif struct Segment_Voronoi_diagram_filtered_traits_without_intersections_2 : public Segment_Voronoi_diagram_filtered_traits_base_2 { Segment_Voronoi_diagram_filtered_traits_without_intersections_2() { CGALi::SVD_Concept_check_tags_wi(); CGALi::SVD_Concept_check_tags_wi(); CGALi::SVD_Concept_check_tags_wi(); } }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_FILTERED_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2.h0000644000175000017500000000441011344301500027013 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_SEGMENT_2_H #define CGAL_SEGMENT_2_H CGAL_BEGIN_NAMESPACE template class Segment_2 : public R_::Kernel_base::Segment_2 { typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Kernel_base::Segment_2 RSegment_2; public: typedef R_ R; Segment_2() {} Segment_2(const Point_2 &sp, const Point_2 &ep) : RSegment_2(sp,ep) {} // conversion from implementation class object to interface class object Segment_2(const RSegment_2& s) : RSegment_2(s) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_SEGMENT_2 template < class R> std::ostream & operator<<(std::ostream &os, const Segment_2 &s) { typedef typename R::Kernel_base::Segment_2 RSegment_2; return os << static_cast(s); } #endif // CGAL_NO_OSTREAM_INSERT_SEGMENT_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_SEGMENT_2 template < class R> std::istream & operator>>(std::istream &is, Segment_2 &s) { typedef typename R::Kernel_base::Segment_2 RSegment_2; return is >> static_cast(s); } #endif // CGAL_NO_ISTREAM_EXTRACT_SEGMENT_2 CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_polyhedron_3.h0000644000175000017500000014151711344301500030377 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_polyhedron_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_NEF_POLYHEDRON_3_H #define CGAL_NEF_POLYHEDRON_3_H #include #include #include #include #include #include #include #include //#include //#include #include #include #include #include #include #include #include #include #ifdef CGAL_NEF3_CGAL_NEF3_SM_VISUALIZOR #include #endif // CGAL_NEF3_SM_VISUALIZOR #include #include #include #include #include #include #include // || (circulator_size(c) != 2 && !result)); #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 11 #include CGAL_BEGIN_NAMESPACE template class Nef_polyhedron_3; template class Nef_polyhedron_3_rep; template std::ostream& operator<<(std::ostream& os, Nef_polyhedron_3& NP); template std::istream& operator>>(std::istream& os, Nef_polyhedron_3& NP); template class Nef_polyhedron_3_rep { typedef Nef_polyhedron_3_rep Self; friend class Nef_polyhedron_3; public: typedef CGAL::SNC_structure SNC_structure; typedef CGAL::SNC_decorator SNC_decorator; typedef CGAL::SNC_const_decorator SNC_const_decorator; // typedef CGAL::SNC_binop SNC_binop; typedef CGAL::SNC_constructor SNC_constructor; //typedef CGAL::SNC_walker SNC_walker; typedef CGAL::SNC_point_locator SNC_point_locator; typedef CGAL::SNC_simplify SNC_simplify; #ifdef CGAL_NEF3_POINT_LOCATOR_NAIVE typedef CGAL::SNC_point_locator_naive SNC_point_locator_default; #else typedef CGAL::SNC_point_locator_by_spatial_subdivision SNC_point_locator_default; #endif typedef typename SNC_structure::Sphere_map Sphere_map; typedef CGAL::SM_decorator SM_decorator; typedef CGAL::SM_const_decorator SM_const_decorator; typedef CGAL::SNC_SM_overlayer SM_overlayer; typedef CGAL::SM_point_locator SM_point_locator; typedef CGAL::SM_io_parser SM_io_parser; #ifdef CGAL_NEF3_SM_VISUALIZOR typedef CGAL::SNC_SM_visualizor SM_visualizor; #endif // CGAL_NEF3_SM_VISUALIZOR private: SNC_structure snc_; SNC_point_locator* pl_; public: Nef_polyhedron_3_rep() : snc_(), pl_() {} ~Nef_polyhedron_3_rep() { CGAL_NEF_TRACEN( "Nef_polyhedron_3_rep: destroying SNC structure "<<&snc_<< ", point locator "< class Nef_polyhedron_3 : public CGAL::Handle_for< Nef_polyhedron_3_rep >, public SNC_const_decorator > { public: /*{\Mtypes 7}*/ typedef Kernel_ Kernel; typedef Kernel_ Traits; typedef Items_ Items; typedef Mark_ Mark; typedef Nef_polyhedron_3 Self; typedef Nef_polyhedron_3 Nef_polyhedron; typedef Handle_for< Nef_polyhedron_3_rep > Base; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Vector_3 Vector_3; typedef typename Kernel::Segment_3 Segment_3; typedef typename Kernel::Aff_transformation_3 Aff_transformation_3; enum Boundary { EXCLUDED=0, INCLUDED=1 }; /*{\Menum construction selection.}*/ typedef enum { EMPTY=0, COMPLETE=1 } Content; /*{\Menum construction selection}*/ typedef enum { DEFAULT, NAIVE, WALKING, SPATIAL_SUBDIVISION } Location_mode; /*{\Menum selection flag for the point location mode.}*/ protected: struct AND { Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const { return b1&&b2; } }; struct OR { Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const { return b1||b2; } }; struct DIFF { Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const { if(inverted) return !b1&&b2; return b1&&!b2; } }; struct XOR { Mark operator()(const Mark& b1, const Mark& b2, bool inverted=false) const { return (b1&&!b2)||(!b1&&b2); } }; public: typedef Nef_polyhedron_3_rep Nef_rep; typedef typename Nef_rep::SNC_structure SNC_structure; protected: typedef typename Nef_rep::SNC_decorator SNC_decorator; typedef typename Nef_rep::SNC_const_decorator SNC_const_decorator; typedef typename Nef_rep::SNC_constructor SNC_constructor; // typedef typename Nef_rep::SNC_binop SNC_binop; //typedef typename Nef_rep::SNC_walker SNC_walker; typedef typename Nef_rep::SNC_point_locator SNC_point_locator; typedef typename Nef_rep::SNC_point_locator_default SNC_point_locator_default; typedef typename Nef_rep::SM_decorator SM_decorator; typedef typename Nef_rep::SM_const_decorator SM_const_decorator; typedef typename Nef_rep::SM_overlayer SM_overlayer; typedef typename Nef_rep::SM_point_locator SM_point_locator; typedef typename Nef_rep::SM_io_parser SM_io_parser; typedef typename Nef_rep::SNC_simplify SNC_simplify; #ifdef CGAL_NEF3_SM_VISUALIZOR typedef typename Nef_rep::SM_visualizor SM_visualizor; #endif // CGAL_NEF3_SM_VISUALIZOR typedef typename Nef_rep::Sphere_map Sphere_map; public: typedef Nef_polyhedron_S2 Nef_polyhedron_S2; protected: SNC_structure& snc() { return this->ptr()->snc_; } const SNC_structure& snc() const { return this->ptr()->snc_; } SNC_point_locator*& pl() { return this->ptr()->pl_; } const SNC_point_locator* pl() const { return this->ptr()->pl_; } friend std::ostream& operator<< <> (std::ostream& os, Nef_polyhedron_3& NP); friend std::istream& operator>> <> (std::istream& is, Nef_polyhedron_3& NP); typedef typename SNC_decorator::Vertex_handle Vertex_handle; typedef typename SNC_decorator::Halfedge_handle Halfedge_handle; typedef typename SNC_decorator::Halffacet_handle Halffacet_handle; typedef typename SNC_decorator::Volume_handle Volume_handle; public: typedef typename SNC_structure::Sphere_point Sphere_point; typedef typename SNC_structure::Sphere_segment Sphere_segment; typedef typename SNC_structure::Sphere_circle Sphere_circle; typedef typename SNC_structure::Vertex_base Vertex; typedef typename SNC_structure::Halfedge_base Halfedge; typedef typename SNC_structure::Halffacet_base Halffacet; typedef typename SNC_structure::Volume_base Volume; typedef typename SNC_structure::Vertex_const_handle Vertex_const_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Volume_const_handle Volume_const_handle; typedef typename SNC_structure::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename SNC_structure::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; typedef typename SNC_structure::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename SNC_structure::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; typedef typename SNC_structure::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_const_circulator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Infi_box Infi_box; typedef typename SNC_structure::Size_type Size_type; typedef Size_type size_type; typedef typename Kernel::RT RT; public: typedef typename SM_decorator::SVertex_handle SVertex_handle; typedef typename SM_decorator::SHalfedge_handle SHalfedge_handle; typedef typename SM_decorator::SFace_handle SFace_handle; typedef typename SM_decorator::SVertex_const_handle SVertex_const_handle; typedef typename SM_decorator::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SM_decorator::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SM_decorator::SFace_const_handle SFace_const_handle; typedef typename SNC_decorator::Vertex_iterator Vertex_iterator; typedef typename SNC_decorator::Halfedge_iterator Halfedge_iterator; typedef typename SNC_decorator::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Shell_entry_iterator Shell_entry_iterator; typedef typename SNC_decorator::Volume_iterator Volume_iterator; typedef typename SNC_structure::Vertex_const_iterator Vertex_const_iterator; typedef typename SNC_structure::Halfedge_const_iterator Halfedge_const_iterator; typedef typename SNC_structure::Halffacet_const_iterator Halffacet_const_iterator; typedef typename SNC_structure::Volume_const_iterator Volume_const_iterator; typedef typename SNC_structure::Shell_entry_const_iterator Shell_entry_const_iterator; typedef typename SM_decorator::SVertex_iterator SVertex_iterator; typedef typename SM_decorator::SHalfedge_iterator SHalfedge_iterator; typedef typename SM_decorator::SFace_iterator SFace_iterator; typedef typename SM_decorator::SVertex_const_iterator SVertex_const_iterator; typedef typename SM_decorator::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename SM_decorator::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename SM_decorator::SFace_const_iterator SFace_const_iterator; typedef typename SNC_decorator::SFace_cycle_const_iterator SFace_cycle_const_iterator; protected: void initialize_infibox_vertices(Content space) { SNC_constructor C(snc()); Infi_box::initialize_infibox_vertices(C, space == COMPLETE); } void check_h_for_intersection_of_12_cube_edges_and_add_vertices (const Plane_3& p); void create_intersection_vertex_of_h_and_e(); void init_cube_vertices_depending_on_h(const Plane_3& p); void add_h_to_local_view_of_v(); public: void build_external_structure() { SNC_constructor C(snc(), pl()); C.build_external_structure(); } public: /*{\Mcreation 3}*/ Nef_polyhedron_3( Content space = EMPTY, SNC_point_locator* _pl = new SNC_point_locator_default); /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to the empty set if |space == EMPTY| and to the whole space if |space == COMPLETE|.}*/ Nef_polyhedron_3(const Plane_3& p, Boundary b = INCLUDED, SNC_point_locator* _pl = new SNC_point_locator_default); /*{\Mcreate creates a Nef polyhedron |\Mvar| containing the halfspace on the positive side of |p| including |p| if |b==INCLUDED|, excluding |p| if |b==EXCLUDED|.}*/ Nef_polyhedron_3(const Nef_polyhedron_3& N1) : Base(N1) { set_snc(snc()); } Nef_polyhedron_3& operator=(const Nef_polyhedron_3& N1) { Base::operator=(N1); set_snc(snc()); return (*this); } ~Nef_polyhedron_3() { CGAL_NEF_TRACEN("~Nef_polyhedron_3: destructor called for snc "<<&snc()<< ", pl "< Polyhedron; #if (defined __GNUC__) && (__GNUC_MAJOR__ < 3) template Nef_polyhedron_3( CGAL::Polyhedron_3& P, SNC_point_locator* _pl = new SNC_point_locator_default) { CGAL_NEF_TRACEN("construction from Polyhedron_3"); SNC_structure rsnc; *this = Nef_polyhedron_3(rsnc, _pl, false); initialize_infibox_vertices(EMPTY); polyhedron_3_to_nef_3 , SNC_structure>( P, snc()); build_external_structure(); simplify(); set_snc(snc()); CGAL_assertion(orientation() == 1); } #else template #endif class T3, class T4 > Nef_polyhedron_3( CGAL::Polyhedron_3& P, SNC_point_locator* _pl = new SNC_point_locator_default) { CGAL_NEF_TRACEN("construction from Polyhedron_3"); SNC_structure rsnc; *this = Nef_polyhedron_3(rsnc, _pl, false); initialize_infibox_vertices(EMPTY); polyhedron_3_to_nef_3 , SNC_structure>( P, snc()); build_external_structure(); simplify(); set_snc(snc()); CGAL_assertion(orientation() == 1); } #endif protected: template class Build_polyhedron : public CGAL::Modifier_base { class Visitor { const Object_index& VI; Polyhedron_incremental_builder_3& B; SNC_const_decorator& D; public: Visitor(Polyhedron_incremental_builder_3& BB, SNC_const_decorator& sd, Object_index& vi) : VI(vi), B(BB), D(sd){} void visit(Halffacet_const_handle opposite_facet) { CGAL_NEF_TRACEN("Build_polyhedron: visit facet " << D.plane(opposite_facet)); CGAL_assertion(Infi_box::is_standard(D.plane(opposite_facet))); SHalfedge_const_handle se; Halffacet_cycle_const_iterator fc; Halffacet_const_handle f = opposite_facet->twin(); B.begin_facet(); fc = f->facet_cycles_begin(); se = SHalfedge_const_handle(fc); CGAL_assertion(se!=0); SHalfedge_around_facet_const_circulator hc_start(se); SHalfedge_around_facet_const_circulator hc_end(hc_start); CGAL_For_all(hc_start,hc_end) { CGAL_NEF_TRACEN(" add vertex " << hc_start->source()->center_vertex()->point()); B.add_vertex_to_facet(VI[hc_start->source()->center_vertex()]); } B.end_facet(); } void visit(SFace_const_handle s) {} void visit(Halfedge_const_handle e) {} void visit(Vertex_const_handle v) {} void visit(SHalfedge_const_handle se) {} void visit(SHalfloop_const_handle sl) {} }; public: SNC_const_decorator& scd; Object_index VI; Build_polyhedron(SNC_const_decorator& s) : scd(s), VI(s.vertices_begin(),s.vertices_end(),'V') {} void operator()( HDS& hds) { Polyhedron_incremental_builder_3 B(hds, true); int skip_volumes; if(Infi_box::extended_kernel()) { B.begin_surface(scd.number_of_vertices()-8, scd.number_of_facets()-6, scd.number_of_edges()-12); skip_volumes = 2; } else { B.begin_surface(scd.number_of_vertices(), scd.number_of_facets(), scd.number_of_edges()); skip_volumes = 1; } int vertex_index = 0; Vertex_const_iterator v; CGAL_forall_vertices(v,scd) { if(Infi_box::is_standard(v->point())) { VI[v]=vertex_index++; B.add_vertex(v->point()); } } Visitor V(B,scd,VI); Volume_const_handle c; CGAL_forall_volumes(c,scd) if(skip_volumes-- <= 0) scd.visit_shell_objects(SFace_const_handle(c->shells_begin()),V); B.end_surface(); } }; int orientation() { // Function does not work correctly with every Nef_polyhedron. // It works correctly if v_max is 2-manifold CGAL_NEF_TRACEN("orientation"); typedef typename SM_decorator::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; if ( this->number_of_vertices() == 0) return 0; // Find top-most vertex v_max (top-most also works fine for terrains) SNC_decorator D(snc()); bool first = true; Vertex_handle v_max; Vertex_handle vh; CGAL_forall_vertices(vh, D) { CGAL_NEF_TRACEN(" is_standard " << vh->point() << " " << Infi_box::is_standard(D.point(vh))); if (Infi_box::is_standard(D.point(vh)) && (first || D.point(vh).z() > D.point(v_max).z())) { first = false; v_max = vh; } } CGAL_NEF_TRACEN(" vmax " << v_max->point()); CGAL_assertion_msg(!first, "off file is empty"); SM_decorator SD(&*v_max); // Add up z-coord. of all normalized normal vectors of the incident facets double z=1.0; first = true; SFace_handle sf; CGAL_forall_sfaces(sf, SD) { if(D.volume(sf) != Infi_box::getNirvana(snc())) continue; CGAL_assertion_msg(first, "function shall not be used on this polyhedron"); SHalfedge_around_sface_circulator estart(sf->sface_cycles_begin()), eend(estart); CGAL_For_all(estart,eend) { Sphere_circle c(SD.circle(estart)); CGAL_NEF_TRACEN(" circle " << c); double delta_z = CGAL::to_double(c.orthogonal_vector().hz()); CGAL_NEF_TRACEN(" delta_z " << delta_z); Point_3 target = ORIGIN + c.orthogonal_vector(); Segment_3 s(Point_3(0,0,0), target); delta_z /= CGAL::sqrt(CGAL::to_double(s.squared_length())); z += delta_z; CGAL_NEF_TRACEN(" z " << z); } first = false; } return sign(z); } public: typedef typename Polyhedron::HalfedgeDS HalfedgeDS; void convert_to_Polyhedron(Polyhedron& P) { CGAL_precondition(is_simple()); Build_polyhedron bp(*this); P.delegate(bp); } // void dump(bool sorted = false, std::ostream& os = std::cout) // { SNC_io_parser::dump( snc(), os, sorted); } bool is_valid( bool verb = false, int level = 0) { // checks the combinatorial consistency. Verbose_ostream verr(verb); verr << "begin CGAL::Nef_polyhedron_3<...>::is_valid( verb=true, " "level = " << level << "):" << std::endl; SNC_decorator D(snc()); bool valid = D.is_valid(verb, level); verr << "end of CGAL::Nef_polyhedron_3<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } bool is_simple() { Halfedge_iterator e; CGAL_forall_edges(e,snc()) if(!is_edge_2manifold(e)) return false; Vertex_iterator v; CGAL_forall_vertices(v,snc()) if(!is_vertex_2manifold(v)) return false; Halffacet_iterator f; CGAL_forall_halffacets(f,snc()) if(!is_facet_simple(f)) return false; return true; } private: bool is_edge_2manifold(const Halfedge_handle& e) { SM_decorator SD; SHalfedge_around_svertex_circulator c(SD.first_out_edge(e)), c2(c); if(c == 0) { CGAL_assertion(circulator_size(c) !=2); return false; } if(++c == c2){ CGAL_assertion(circulator_size(c) !=2); return false; } if(++c != c2) { CGAL_assertion(circulator_size(c) !=2); return false; } CGAL_assertion(circulator_size(c) == 2); return true; } bool is_vertex_2manifold(const Vertex_handle& v) { SFace_iterator sfi(v->sfaces_begin()); if (++sfi != v->sfaces_last()) return false; return true; } bool is_facet_simple(const Halffacet_const_handle& f) { bool found_first = false; Halffacet_cycle_const_iterator it; CGAL_forall_facet_cycles_of(it,f) if (found_first || !it.is_shalfedge()) return false; else found_first = true; return true; } public: void clear(Content space = EMPTY) { *this = Nef_polyhedron_3(space, pl()->clone()); } /*{\Mop makes |\Mvar| the empty set if |space == EMPTY| and the full space if |space == COMPLETE|.}*/ bool is_empty() const { /*{\Mop returns true if |\Mvar| is empty, false otherwise.}*/ if(Infi_box::extended_kernel()) return this->number_of_vertices() == 8 && this->number_of_edges() == 12 && this->number_of_facets() == 6 && this->number_of_volumes() == 2 && mark(++this->volumes_begin()) == false; else return this->number_of_vertices() == 0 && this->number_of_edges() == 0 && this->number_of_facets() == 0 && this->number_of_volumes() == 1 && mark(this->volumes_begin()) == false; } bool is_space() const { /*{\Mop returns true if |\Mvar| is the whole space, false otherwise.}*/ if(Infi_box::extended_kernel()) return this->number_of_vertices() == 8 && this->number_of_edges() == 12 && this->number_of_facets() == 6 && this->number_of_volumes() == 2 && mark(++this->volumes_begin()) == true; else return this->number_of_vertices() == 0 && this->number_of_edges() == 0 && this->number_of_facets() == 0 && this->number_of_volumes() == 1 && mark(this->volumes_begin()) == true; } /*{\Xtext \headerline{Destructive Operations}}*/ protected: void clone_rep() { *this = Nef_polyhedron_3(snc(), pl()); } void empty_rep() { SNC_structure rsnc; *this = Nef_polyhedron_3(rsnc, new SNC_point_locator_default); } public: Nef_polyhedron_3( const SNC_structure& W, SNC_point_locator* _pl = new SNC_point_locator_default, bool clone_pl = true, bool clone_snc = true); /*{\Xcreate makes |\Mvar| a new object. If |cloneit==true| then the underlying structure of |W| is copied into |\Mvar|.}*/ // TODO: granados: define behavior when clone=false /*{\Moperations 4 3 }*/ void simplify() { SNC_simplify simp(snc()); bool simplified = simp.simplify(); CGAL_NEF_TRACEN( "simplify(): structure simplified? "< V(false, snc().number_of_vertices()); Unique_hash_map E(false, snc().number_of_halfedges()); Unique_hash_map F(false, snc().number_of_halffacets()); Vertex_iterator v; Halfedge_iterator e; Halffacet_iterator f; CGAL_forall_vertices( v, snc()) V[Vertex_handle(v)] = true; CGAL_forall_halfedges( e, snc()) E[Halfedge_handle(e)] = true; CGAL_forall_halffacets( f, snc()) F[Halffacet_handle(f)] = true; bool updated = pl()->update( V, E, F); CGAL_NEF_TRACEN("simplify(): point locator structure updated? " << updated); #else SNC_point_locator* old_pl = pl(); pl() = pl()->clone(); pl()->initialize(&snc()); delete old_pl; #endif } } public: Nef_polyhedron_S2 get_sphere_map(Vertex_const_handle v) { return Nef_polyhedron_S2(*v); } void extract_complement(); /*{\Xop converts |\Mvar| to its complement. }*/ void extract_interior(); /*{\Xop converts |\Mvar| to its interior. }*/ void extract_boundary(); /*{\Xop converts |\Mvar| to its boundary. }*/ void extract_closure() /*{\Xop converts |\Mvar| to its closure. }*/ { CGAL_NEF_TRACEN("extract closure"); if( this->is_shared()) clone_rep(); extract_complement(); extract_interior(); extract_complement(); } void extract_regularization() /*{\Xop converts |\Mvar| to its regularization. }*/ { CGAL_NEF_TRACEN("extract regularization"); if( this->is_shared()) clone_rep(); extract_interior(); extract_closure(); } /*{\Mtext \headerline{Constructive Operations}}*/ Nef_polyhedron_3 complement() const /*{\Mop returns the complement of |\Mvar| in the plane. }*/ { Nef_polyhedron_3 res = *this; res.extract_complement(); return res; } Nef_polyhedron_3 interior() const /*{\Mop returns the interior of |\Mvar|. }*/ { Nef_polyhedron_3 res = *this; res.extract_interior(); return res; } Nef_polyhedron_3 closure() const /*{\Mop returns the closure of |\Mvar|. }*/ { Nef_polyhedron_3 res = *this; res.extract_closure(); return res; } Nef_polyhedron_3 boundary() const /*{\Mop returns the boundary of |\Mvar|. }*/ { Nef_polyhedron_3 res = *this; res.extract_boundary(); return res; } Nef_polyhedron_3 regularization() const /*{\Mop returns the regularized polyhedron (closure of the interior).}*/ { Nef_polyhedron_3 res = *this; res.extract_regularization(); return res; } Nef_polyhedron_3 intersection(const Nef_polyhedron_3& N1) const /*{\Mop returns |\Mvar| $\cap$ |N1|. }*/ { CGAL_NEF_TRACEN(" intersection between nef3 "<<&*this<<" and "<<&N1); AND _and; //CGAL::binop_intersection_tests_allpairs tests_impl; SNC_structure rsnc; Nef_polyhedron_3 res(rsnc, new SNC_point_locator_default, false); SNC_decorator D( res.snc()); D.binary_operation(res.pl(), snc(), pl(), N1.snc(), N1.pl(), _and); return res; } Nef_polyhedron_3 join(const Nef_polyhedron_3& N1) const /*{\Mop returns |\Mvar| $\cup$ |N1|. }*/ { CGAL_NEF_TRACEN(" join between nef3 "<<&*this<<" and "<<&N1); OR _or; //CGAL::binop_intersection_tests_allpairs tests_impl; SNC_structure rsnc; Nef_polyhedron_3 res(rsnc, new SNC_point_locator_default, false); SNC_decorator D( res.snc()); D.binary_operation(res.pl(), snc(), pl(), N1.snc(), N1.pl(), _or); return res; } Nef_polyhedron_3 difference(const Nef_polyhedron_3& N1) const /*{\Mop returns |\Mvar| $-$ |N1|. }*/ { CGAL_NEF_TRACEN(" difference between nef3 "<<&*this<<" and "<<&N1); DIFF _diff; //CGAL::binop_intersection_tests_allpairs tests_impl; SNC_structure rsnc; Nef_polyhedron_3 res(rsnc, new SNC_point_locator_default, false); SNC_decorator D( res.snc()); D.binary_operation(res.pl(), snc(), pl(), N1.snc(), N1.pl(), _diff); return res; } Nef_polyhedron_3 symmetric_difference(const Nef_polyhedron_3& N1) const /*{\Mop returns the symmectric difference |\Mvar - T| $\cup$ |T - \Mvar|. }*/ { CGAL_NEF_TRACEN(" symmetic difference between nef3 "<<&*this<<" and "<<&N1); XOR _xor; //CGAL::binop_intersection_tests_allpairs tests_impl; SNC_structure rsnc; Nef_polyhedron_3 res(rsnc, new SNC_point_locator_default, false); SNC_decorator D( res.snc()); D.binary_operation(res.pl(), snc(), pl(), N1.snc(), N1.pl(), _xor); return res; } /*{\Mtext Additionally there are operators |*,+,-,^,!| which implement the binary operations \emph{intersection}, \emph{union}, \emph{difference}, \emph{symmetric difference}, and the unary operation \emph{complement}. There are also the corresponding modification operations |*=,+=,-=,^=|.}*/ Nef_polyhedron_3 operator*(const Nef_polyhedron_3& N1) const { return intersection(N1); } Nef_polyhedron_3 operator+(const Nef_polyhedron_3& N1) const { return join(N1); } Nef_polyhedron_3 operator-(const Nef_polyhedron_3& N1) const { return difference(N1); } Nef_polyhedron_3 operator^(const Nef_polyhedron_3& N1) const { return symmetric_difference(N1); } Nef_polyhedron_3 operator!() const { return complement(); } Nef_polyhedron_3& operator*=(const Nef_polyhedron_3& N1) { *this = intersection(N1); return *this; } Nef_polyhedron_3& operator+=(const Nef_polyhedron_3& N1) { *this = join(N1); return *this; } Nef_polyhedron_3& operator-=(const Nef_polyhedron_3& N1) { *this = difference(N1); return *this; } Nef_polyhedron_3& operator^=(const Nef_polyhedron_3& N1) { *this = symmetric_difference(N1); return *this; } /*{\Mtext There are also comparison operations like |<,<=,>,>=,==,!=| which implement the relations subset, subset or equal, superset, superset or equal, equality, inequality.}*/ bool operator==(const Nef_polyhedron_3& N1) const { CGAL_NEF_TRACEN(" equality comparision between nef3 "<<&*this<<" and "<<&N1); return symmetric_difference(N1).is_empty(); } bool operator!=(const Nef_polyhedron_3& N1) const { CGAL_NEF_TRACEN(" inequality comparision between nef3 "<<&*this<<" and "<<&N1); return !operator==(N1); } bool operator<(const Nef_polyhedron_3& N1) const { return !N1.difference(*this).is_empty() && difference(N1).is_empty(); } bool operator>(const Nef_polyhedron_3& N1) const { return difference(*this).is_empty() && !difference(N1).is_empty(); } bool operator<=(const Nef_polyhedron_3& N1) const { return difference(N1).is_empty(); } bool operator>=(const Nef_polyhedron_3& N1) const { return N1.difference(*this).is_empty(); } /* void transform( const Aff_transformation_3& aff) { // precondition: the polyhedron as a bounded boundary // (needs to be explicitly tested at some time) if( is_shared()) clone_rep(); // only linear transform for the origin-centered sphere maps Aff_transformation_3 linear( aff.hm(0,0), aff.hm(0,1), aff.hm(0,2), aff.hm(1,0), aff.hm(1,1), aff.hm(1,2), aff.hm(2,0), aff.hm(2,1), aff.hm(2,2), aff.hm(3,3)); SNC_decorator deco( snc()); list vertex_list; Vertex_iterator vi; CGAL_forall_vertices( vi, snc()) { CGAL_NEF_TRACEN("transform vertex "); if (!is_standard(vi)) { vertex_list.push_bach(vi); } else { vi->point() = vi->point().transform( aff); SM_decorator sdeco(&*vi); sdeco.transform( linear); } } CGAL_forall_halffacets(fi, snc()) { if (!deco.is_standard( fi)) { Halffacet_cycle_iterator fc = fi.facet_cycles_begin(); CGAL_assertion(fc.is_shalfedge()); SHalfedge_around_facet_circulator fcc(SHalfedge(fc)), fend(fcc); CGAL_For_all(fcc,fend) { deco.add_interim_points(point(source(fcc)),point(target(fcc))); } } } typename list::iterator li; for(li = vertex_list.begin(); li != vertex_list.end(); li++){ deco.transform_sphere(*li); } if(!is_finite()) { build_external_structure(); } else { Halffacet_iterator fi; CGAL_forall_halffacets(fi,snc()) { fi->plane() = fi->plane().transform( aff); } } if(aff.homogeneous(0,1) != 0 || aff.homogeneous(0,2) != 0 || aff.homogeneous(1,0) != 0 || aff.homogeneous(1,2) != 0 || aff.homogeneous(2,0) != 0 || aff.homogeneous(2,1) != 0 || aff.homogeneous(0,0) != aff.homogeneous(1,1) || aff.homogeneous(0,0) != aff.homogeneous(2,2)) { SNC_point_locator* old_pl = pl(); pl() = pl()->clone(); pl()->initialize(&snc()); delete old_pl; } else pl()->transform(aff); } */ bool is_90degree_rotation(const Aff_transformation_3& aff) const { if(aff.hm(0,3) != 0) return false; if(aff.hm(1,3) != 0) return false; if(aff.hm(2,3) != 0) return false; if(CGAL_NTS abs(aff.hm(0,0)) + CGAL_NTS abs(aff.hm(0,1)) + CGAL_NTS abs(aff.hm(0,2)) != aff.hm(3,3)) return false; if(CGAL_NTS abs(aff.hm(1,0)) + CGAL_NTS abs(aff.hm(1,1)) + CGAL_NTS abs(aff.hm(1,2)) != aff.hm(3,3)) return false; if(CGAL_NTS abs(aff.hm(2,0)) + CGAL_NTS abs(aff.hm(2,1)) + CGAL_NTS abs(aff.hm(2,2)) != aff.hm(3,3)) return false; if(CGAL_NTS abs(aff.hm(0,0)) + CGAL_NTS abs(aff.hm(1,0)) + CGAL_NTS abs(aff.hm(2,0)) != aff.hm(3,3)) return false; if(CGAL_NTS abs(aff.hm(0,1)) + CGAL_NTS abs(aff.hm(1,1)) + CGAL_NTS abs(aff.hm(2,1)) != aff.hm(3,3)) return false; if(CGAL_NTS abs(aff.hm(0,2)) + CGAL_NTS abs(aff.hm(1,2)) + CGAL_NTS abs(aff.hm(2,2)) != aff.hm(3,3)) return false; return true; } bool is_scaling(const Aff_transformation_3& aff) const { if(aff.hm(0,3) != 0) return false; if(aff.hm(1,3) != 0) return false; if(aff.hm(2,3) != 0) return false; if(aff.hm(0,1) != 0) return false; if(aff.hm(0,2) != 0) return false; if(aff.hm(1,0) != 0) return false; if(aff.hm(1,2) != 0) return false; if(aff.hm(2,0) != 0) return false; if(aff.hm(2,1) != 0) return false; if(aff.hm(0,0) != aff.hm(1,1)) return false; if(aff.hm(0,0) != aff.hm(2,2)) return false; return true; } void transform( const Aff_transformation_3& aff) { CGAL_precondition(aff.is_even()); // precondition: the polyhedron as a bounded boundary // (needs to be explicitly tested at some time) if( this->is_shared()) clone_rep(); // only linear transform for the origin-centered sphere maps Aff_transformation_3 linear( aff.hm(0,0), aff.hm(0,1), aff.hm(0,2), aff.hm(1,0), aff.hm(1,1), aff.hm(1,2), aff.hm(2,0), aff.hm(2,1), aff.hm(2,2), aff.hm(3,3)); SNC_constructor cstr(snc()); std::list vertex_list; std::list corner_list; std::list delete_list; typename std::list::iterator li; typename std::list::iterator li2; bool ninety = is_90degree_rotation(aff); bool scale = is_scaling(aff); Vertex_iterator vi; CGAL_forall_vertices( vi, snc()) { CGAL_NEF_TRACEN("transform vertex "); if(scale) { if(is_standard(vi)) vi->point() = vi->point().transform( aff); else if(!Infi_box::is_infibox_corner(vi->point())) { vi->point() = normalized(Infi_box::normalize_transformed_vertex(vi->point().transform(aff))); } } else if (!is_standard(vi) && !ninety) { if(Infi_box::is_infibox_corner(vi->point())) corner_list.push_back(vi); vertex_list.push_back(vi); } else { vi->point() = vi->point().transform( aff); SM_decorator sdeco(&*vi); sdeco.transform( linear); } } if(!this->is_bounded() && !ninety && !scale) { Halffacet_iterator fi; CGAL_forall_facets(fi, snc()) { if(!is_standard(fi) || is_bounded(fi)) continue; Plane_3 pt = fi->plane(); pt = pt.transform(aff); std::list points(Infi_box::find_points_of_box_with_plane(cstr,pt)); std::list newVertices; newVertices = Infi_box::create_vertices_on_infibox(cstr, pt, points, fi->mark(), fi->twin()->incident_volume()->mark(), fi->incident_volume()->mark()); for(li = newVertices.begin(); li != newVertices.end(); ++li) { if(Infi_box::is_infibox_corner(point(*li))) { li2 = corner_list.begin(); while(li2 != corner_list.end() && point(*li2) != point(*li)) ++li2; CGAL_assertion(li2 != corner_list.end()); delete_list.push_back(*li2); *li2 = *li; } } } for(li = vertex_list.begin(); li != vertex_list.end();++li) { SM_decorator SD(&**li); if(Infi_box::is_complex_facet_infibox_intersection(**li)) { Halffacet_handle hf[2]; int i=0; SHalfedge_iterator sei; CGAL_forall_sedges(sei,SD) { if(!Infi_box::is_sedge_on_infibox(sei)) { hf[i] = sei->facet(); if(hf[i]->is_twin()) hf[i] = hf[i]->twin(); ++i; } if(i>1) break; } } } cstr.clear_external_structure(); for(li = vertex_list.begin(); li != vertex_list.end();++li){ if(Infi_box::is_complex_facet_infibox_intersection(**li)) { Vertex_handle v2; Vertex_handle v1 = cstr.create_for_infibox_overlay(*li); v1->point() = normalized(Infi_box::normalize_transformed_vertex(point(*li).transform(aff))); SM_decorator sdeco(&*v1); sdeco.transform(linear); switch(Infi_box::type_of_infibox_point(v1->point())) { case 1: v2 = cstr.create_from_point_on_infibox_facet(v1->point()); break; case 2: v2 = cstr.create_from_point_on_infibox_edge(v1->point()); break; case 3: v2 = cstr.create_from_point_on_infibox_vertex(v1->point()); li2 = corner_list.begin(); while(li2 != corner_list.end() && point(*li2) != v2->point()) ++li2; if(li2 != corner_list.end()) delete_list.push_back(*li2); break; default: CGAL_assertion_msg(false, "wrong value"); } Vertex_handle v = snc().new_vertex(v1->point(), mark(*li)); SM_overlayer O(&*v); O.subdivide(&*v1,&*v2); AND _and; O.select(_and); O.simplify(); snc().delete_vertex(v1); snc().delete_vertex(v2); } if(Infi_box::is_infibox_corner(point(*li))) { SM_decorator SD(&**li); if(SD.number_of_svertices() < 4) continue; li2 = corner_list.begin(); while(li2 != corner_list.end() && point(*li2) != point(*li)) ++li2; CGAL_assertion(li2 != corner_list.end()); if(*li == *li2) { delete_list.push_back(*li2); *li2 = cstr.create_from_point_on_infibox_vertex(point(*li)); } } else snc().delete_vertex(*li); } for(li = delete_list.begin(); li != delete_list.end(); ++li) snc().delete_vertex(*li); while(cstr.erase_redundant_vertices()); cstr.correct_infibox_sedge_marks(); build_external_structure(); cstr.correct_infibox_sface_marks(); SNC_point_locator* old_pl = pl(); pl() = pl()->clone(); pl()->initialize(&snc()); delete old_pl; } else { Halffacet_iterator fi; CGAL_forall_halffacets(fi,snc()) { if(is_standard(fi) || ninety) fi->plane() = fi->plane().transform( aff); } if(aff.homogeneous(0,1) != 0 || aff.homogeneous(0,2) != 0 || aff.homogeneous(1,0) != 0 || aff.homogeneous(1,2) != 0 || aff.homogeneous(2,0) != 0 || aff.homogeneous(2,1) != 0 || aff.homogeneous(0,0) != aff.homogeneous(1,1) || aff.homogeneous(0,0) != aff.homogeneous(2,2) || !this->is_bounded()) { SNC_point_locator* old_pl = pl(); pl() = pl()->clone(); pl()->initialize(&snc()); delete old_pl; } else pl()->transform(aff); } } /*{\Mtext \headerline{Exploration} As Nef polyhedra are the result of forming complements and intersections starting from a set |H| of halfspaces which are defined by oriented planes in three space. The corresponding structure is represented by an extended wuerzburg structure $W = (V,E,F,C)$. For topological queries within |W| the following types and operations allow exploration access to this structure.}*/ /*{\Mtypes 3}*/ typedef CGAL::SNC_SM_explorer SM_explorer; SM_explorer SMexplorer(Vertex_const_handle v) const { SM_const_decorator SMCD(&*v); return SM_explorer(SMCD); } typedef typename SNC_structure::Object_list Object_list; typedef typename SNC_structure::Object_handle Object_handle; /*{\Mtypemember a generic handle to an object of the underlying plane map. The kind of object |(vertex, halfedge, face)| can be determined and the object can be assigned to a corresponding handle by the three functions:\\ |bool assign(Vertex_const_handle& h, Object_handle)|\\ |bool assign(Edge_const_handle& h, Object_handle)|\\ |bool assign(Facet_const_handle& h, Object_handle)|\\ |bool assign(Volume_const_handle& h, Object_handle)|\\ where each function returns |true| iff the assignment to |h| was done.}*/ /*{\Moperations 3 1 }*/ bool contains(Object_handle h) const /*{\Mop returns true iff the object |h| is contained in the set represented by |\Mvar|.}*/ // { SNC_point_locator PL(snc()); return PL.mark(h);} { CGAL_assertion_msg( 0, "not implemented."); return false;} bool contained_in_boundary(Object_handle h) const /*{\Mop returns true iff the object |h| is contained in the $2$-skeleton of |\Mvar|.}*/ { Vertex_const_handle v; Halfedge_const_handle e; Halffacet_const_handle f; return ( assign(v,h) || assign(e,h) || assign(f,h) ); } Object_handle locate(const Point_3& p) const /*{\Mop returns a generic handle |h| to an object (vertex, edge, facet, volume) of the underlying SNC which contains the point |p| in its relative interior. The point |p| is contained in the set represented by |\Mvar| if |\Mvar.contains(h)| is true.}*/ { CGAL_NEF_TRACEN( "locating point..."); CGAL_assertion( pl() != NULL); Object_handle o = pl()->locate(p); Vertex_handle v; Halfedge_handle e; Halffacet_handle f; Volume_handle c; if(assign(v,o)) return Vertex_const_handle(v); if(assign(e,o)) return Halfedge_const_handle(e); if(assign(f,o)) return Halffacet_const_handle(f); if(assign(c,o)) return Volume_const_handle(c); return Object_handle(); } /*{\Mimplementation Nef polyhedra are implemented on top of an extended Wuerzburg structure data structure (EWS) and use linear space in the number of vertices, edges and facets. Operations like empty take constant time. The operations clear, complement, interior, closure, boundary, regularization, input and output take linear time. All binary set operations and comparison operations take time $O(N^2)$ where $N$ is the size of the output plus the size of the input. The point location operations run in linear query time without any preprocessing.}*/ /*{\Mexample Nef polyhedra are parameterized by a so called extended geometric kernel. There's currently only one such kernel based on a homogeneous representation of extended points called |Extended_homogeneous|. The kernel is parameterized by a multiprecision integer type. The member types of |Nef_polyhedron_3< Extended_homogeneous_3 >| map to corresponding types of the CGAL geometry kernel (e.g. |Nef_polyhedron::Plane_3| equals |CGAL::Homogeneous::Plane_3| in the example below). \begin{Mverb} #include #include #include #include using namespace CGAL; typedef Extended_homogeneous Extended_kernel; typedef Nef_polyhedron_3 Nef_polyhedron; typedef Nef_polyhedron::Plane_3 Plane_3; int main() { Nef_polyhedron N1(Plane_3(1,0,0,0)); Nef_polyhedron N2(Plane_3(0,1,0,0), Nef_polyhedron::EXCLUDED); Nef_polyhedron N3 = N1 * N2; // line (*) return 0; } \end{Mverb} After line (*) |N3| is the intersection of |N1| and |N2|.}*/ std::size_t bytes() { // bytes used for the Nef_polyhedron_3. return sizeof(Self) + (snc().bytes() - sizeof(SNC_structure)); } std::size_t bytes_reduced() { // bytes used for the Nef_polyhedron_3. std::cout << sizeof(Self) + (snc().bytes_reduced2() - sizeof(SNC_structure)) << std::endl; return sizeof(Self) + (snc().bytes_reduced() - sizeof(SNC_structure)); } }; // end of Nef_polyhedron_3 template Nef_polyhedron_3:: Nef_polyhedron_3( Content space, SNC_point_locator* _pl) { CGAL_NEF_TRACEN("construction from empty or space."); SNC_structure rsnc; empty_rep(); set_snc(snc()); pl() = _pl; if(Infi_box::extended_kernel()) { initialize_infibox_vertices(space); build_external_structure(); } else { build_external_structure(); SNC_decorator D(snc()); D.mark(D.volumes_begin()) = (space == COMPLETE) ? 1 : 0; } } template Nef_polyhedron_3:: Nef_polyhedron_3(const Plane_3& h, Boundary b, SNC_point_locator* _pl) { CGAL_NEF_TRACEN("construction from plane "< Nef_polyhedron_3:: Nef_polyhedron_3( const SNC_structure& W, SNC_point_locator* _pl, bool clone_pl, bool clone_snc) { CGAL_assertion( clone_snc == true || clone_pl == false); // TODO: granados: define behavior when clone=false // CGAL_NEF_TRACEN("construction from an existing SNC structure (clone="<copy_on_write(); if(clone_snc) { snc() = W; set_snc(snc()); } if(clone_pl) { pl() = _pl->clone(); pl()->initialize(&snc()); } else pl() = _pl; } template void Nef_polyhedron_3:: extract_complement() { CGAL_NEF_TRACEN("extract complement"); if( this->is_shared()) clone_rep(); SNC_decorator D(snc()); Vertex_iterator v; CGAL_forall_vertices(v,D){ D.mark(v) = !D.mark(v); SM_decorator SM(&*v); SM.extract_complement(); } Halffacet_iterator f; CGAL_forall_halffacets(f,D) D.mark(f) = !D.mark(f); Volume_iterator c; CGAL_forall_volumes(c,D) // if(!(Infi_box::extended_kernel && c==D.volumes_begin())) D.mark(c) = !D.mark(c); } template void Nef_polyhedron_3:: extract_interior() { CGAL_NEF_TRACEN("extract interior"); if (this->is_shared()) clone_rep(); SNC_decorator D(snc()); Vertex_iterator v; CGAL_forall_vertices(v,D){ D.mark(v) = false; SM_decorator SM(&*v); SM.extract_interior(); } Halffacet_iterator f; CGAL_forall_halffacets(f,D) D.mark(f) = false; simplify(); } template void Nef_polyhedron_3:: extract_boundary() { CGAL_NEF_TRACEN("extract boundary"); if (this->is_shared()) clone_rep(); SNC_decorator D(snc()); Vertex_iterator v; CGAL_forall_vertices(v,D) { D.mark(v) = true; SM_decorator SM(&*v); SM.extract_boundary(); } Halffacet_iterator f; CGAL_forall_halffacets(f,D) D.mark(f) = true; Volume_iterator c; CGAL_forall_volumes(c,D) D.mark(c) = false; simplify(); } CGAL_END_NAMESPACE #endif //CGAL_NEF_POLYHEDRON_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Handle.h0000644000175000017500000000444311344301500026371 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Handle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : #ifndef CGAL_HANDLE_H #define CGAL_HANDLE_H #include CGAL_BEGIN_NAMESPACE class Rep { friend class Handle; protected: Rep() { count = 1; } virtual ~Rep() {} int count; }; class Handle { public: Handle() : PTR(static_cast(0)) {} Handle(const Handle& x) { CGAL_kernel_precondition( x.PTR != static_cast(0) ); PTR = x.PTR; PTR->count++; } ~Handle() { if ( PTR && (--PTR->count == 0)) delete PTR; } Handle& operator=(const Handle& x) { CGAL_kernel_precondition( x.PTR != static_cast(0) ); x.PTR->count++; if ( PTR && (--PTR->count == 0)) delete PTR; PTR = x.PTR; return *this; } int refs() const { return PTR->count; } friend unsigned long id(const Handle& x); friend bool identical(const Handle& h1, const Handle& h2); protected: Rep* PTR; }; inline unsigned long id(const Handle& x) { return reinterpret_cast(x.PTR); } inline bool identical(const Handle &h1, const Handle &h2) { return reinterpret_cast(h1.PTR) == reinterpret_cast(h2.PTR); } CGAL_END_NAMESPACE #endif // CGAL_HANDLE_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_triangle_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_triangle_point_loca0000644000175000017500000002172411344301500031421 0ustar debiandebian// Copyright (c) 2004 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_triangle_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Idit Haran #ifndef CGAL_PM_TRIANGLE_POINT_LOCATION_H #define CGAL_PM_TRIANGLE_POINT_LOCATION_H #include //#include //#define CGAL_PM_WALK_DEBUG //#define CGAL_PM_DEBUG //---------------------------------------------------------- // triangulation includes //---------------------------------------------------------- // file : examples/Triangulation_2/constrained.C #include #include #include #include #include #include #include //---------------------------------------------------------- //Pm includes //---------------------------------------------------------- #include #include #include #include //#include #include //#include //#include //////////////////////////////////////////////////////// // TRIANGLE STRATEGY //////////////////////////////////////////////////////// CGAL_BEGIN_NAMESPACE template class Pm_triangle_point_location : public Pm_point_location_base { public: //---------------------------------------------------------- // Pm Types //---------------------------------------------------------- typedef typename Planar_map_::Traits Traits; //typedef typename Traits::FT FT; //typedef Cartesian Kernel; typedef typename Traits::Kernel Kernel; //typedef Quotient Coord_type; //typedef Cartesian Kernel; // typedef Arr_segment_cached_traits_2 Traits; //---------------------------------------------------------- // Pm Types //---------------------------------------------------------- typedef typename Kernel::Segment_2 Segment; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef Planar_map_ Planar_map; //typedef Pm_default_dcel Dcel; //typedef typename Planar_map_2 Planar_map; //typedef Planar_map_with_intersections_2 Pmwx; typedef Pm_point_location_base Base; typedef Pm_triangle_point_location Self; typedef typename Planar_map::Face_iterator Face_iterator; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Vertex_iterator Vertex_iterator; typedef typename Planar_map::Edge_iterator Edge_iterator; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Halfedge_around_vertex_circulator Halfedge_around_vertex_circulator; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Base::Token Token; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Traits_wrap Traits_wrap; //---------------------------------------------------------- //---------------------------------------------------------- // Triangulation Types //---------------------------------------------------------- typedef Triangulation_vertex_base_with_info_2 Vb; typedef Triangulation_face_base_with_info_2 Fbt; typedef Constrained_triangulation_face_base_2 Fb; typedef Triangulation_data_structure_2 TDS; typedef Exact_predicates_tag Itag; typedef Constrained_Delaunay_triangulation_2 CDT; typedef typename CDT::Point CDT_Point; typedef typename CDT::Edge CDT_Edge; typedef typename CDT::Face_handle CDT_Face_handle; typedef typename CDT::Vertex_handle CDT_Vertex_handle; typedef typename CDT::Finite_faces_iterator CDT_Finite_faces_iterator; typedef typename CDT::Finite_vertices_iterator CDT_Finite_vertices_iterator; typedef typename CDT::Finite_edges_iterator CDT_Finite_edges_iterator; typedef typename CDT::Locate_type CDT_Locate_type; //---------------------------------------------------------- protected: typedef const Self* cPLp; public: // Constructor Pm_triangle_point_location() : Pm_point_location_base(), pm(0), traits(0), updated_cdt(false) {} void init(Planar_map & pmp, const Traits & tr) { #ifdef CGAL_PM_DEBUG std::cout << "init PL" << std::endl; #endif CGAL_precondition_msg(pm == NULL, "Point location instance should be uninitialized " "(Do not use the same instance for more than one map)."); pm = &pmp; traits = (Traits_wrap*)(&tr); triangulate_pm(); } inline void insert(Halfedge_handle hh, const X_monotone_curve_2 & cv) {insert_to_cdt(hh, cv); } Halfedge_const_handle locate(const typename Planar_map::Traits::Point_2 & p, Locate_type & lt) const; Halfedge_handle locate(const typename Planar_map::Traits::Point_2 & p, Locate_type & lt); Halfedge_const_handle vertical_ray_shoot(const typename Planar_map::Traits::Point_2& p, Locate_type& lt, bool up) const; Halfedge_handle vertical_ray_shoot(const typename Planar_map::Traits::Point_2& p, Locate_type& lt, bool up); inline void split_edge(const X_monotone_curve_2 &, Halfedge_handle, Halfedge_handle, //additions by iddo for arrangement const X_monotone_curve_2 &, const X_monotone_curve_2 &) {updated_cdt = false; triangulate_pm(); } inline void merge_edge(const X_monotone_curve_2 &, const X_monotone_curve_2 &, Halfedge_handle, //additions by iddo for arrangement const X_monotone_curve_2 &) {updated_cdt = false; triangulate_pm();} inline void remove_edge(Halfedge_handle) {updated_cdt = false; triangulate_pm();} inline void remove_edge(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &) {updated_cdt = false; triangulate_pm(); }; inline void clear() {updated_cdt = false; triangulate_pm();} inline void update(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &, const Token& token) {updated_cdt = false; triangulate_pm(); } //function that does the triangulation void triangulate_pm() ; void insert_to_cdt(Halfedge_handle hh, const typename Planar_map::Traits::X_monotone_curve_2 &cv) ; private: #ifdef CGAL_PM_DEBUG void debug() {} void debug(const Halfedge_handle& e) const { { if (e!=pm->halfedges_end()) std::cerr << "(" << e->source()->point() << "," << e->target()->point() << ")" << std::flush; else std::cerr << "(oo)"; } } #endif public: inline const Traits * get_traits() const {return traits;} protected: Planar_map * pm; const Traits_wrap * traits; CDT cdt; bool updated_cdt; }; CGAL_END_NAMESPACE //#ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include //#endif #endif //PM_TRIANGLE_POINT_LOCATION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/circulator_impl.h0000644000175000017500000005354411344301500030374 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/circulator_impl.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_CIRCULATOR_IMPL_H #define CGAL_CIRCULATOR_IMPL_H 1 #ifndef CGAL_CIRCULATOR_H #include #endif CGAL_BEGIN_NAMESPACE template < class S> class Forward_circulator_over_struct : public Forward_circulator_ptrbase{ public: // DEFINITION // // Given a structure `S' that have a data member `S* next' that realizes a // ring like data structure the adaptor // `Forward_circulator_over_struct< S>' provides a forward circulator // for it. If the structure `S' has additionally a second data member of // type `S* prev' that realizes the reverse direction the adaptor // `Bidirectional_circulator_over_struct< S>' provides a bidirectional // circulator for it. In addition, adaptors for const circulators are // provided with the names `Forward_const_circulator_over_struct< S>' // and `Bidirectional_const_circulator_over_struct< S>'. A circulator // becomes invalid whenever the object it refers to gets deleted from the // data structure. typedef Forward_circulator_over_struct Self; typedef Forward_circulator_ptrbase Base1; typedef typename Base1::reference reference; typedef typename Base1::pointer pointer; // CREATION // // New creation variable is: `circ' Forward_circulator_over_struct() {} // a circulator `circ' with singular value. Forward_circulator_over_struct( S* ptr) : Forward_circulator_ptrbase( ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { return *(S*)this->_ptr;} pointer operator->() const { return (S*)this->_ptr;} Self& operator++() { this->_ptr = ((S*)this->_ptr)->next; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class S> class Forward_const_circulator_over_struct : public Forward_circulator_ptrbase{ public: typedef Forward_const_circulator_over_struct Self; typedef const S& reference; typedef const S* pointer; // CREATION Forward_const_circulator_over_struct() {} // a circulator `circ' with singular value. Forward_const_circulator_over_struct( const S* ptr) : Forward_circulator_ptrbase((void*)ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { return *(const S*)this->_ptr;} pointer operator->() const { return (const S*)this->_ptr;} Self& operator++() { this->_ptr = ((S*)this->_ptr)->next; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class S> class Bidirectional_circulator_over_struct : public Bidirectional_circulator_ptrbase{ public: typedef Bidirectional_circulator_over_struct Self; typedef Bidirectional_circulator_ptrbase Base1; typedef typename Base1::reference reference; typedef typename Base1::pointer pointer; // CREATION // // New creation variable is: `circ' Bidirectional_circulator_over_struct() {} // a circulator `circ' with singular value. Bidirectional_circulator_over_struct( S* ptr) : Bidirectional_circulator_ptrbase( ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { return *(S*)this->_ptr;} pointer operator->() const { return (S*)this->_ptr;} Self& operator++() { this->_ptr = ((S*)this->_ptr)->next; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { this->_ptr = ((S*)this->_ptr)->prev; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class S> class Bidirectional_const_circulator_over_struct : public Bidirectional_circulator_ptrbase{ public: typedef Bidirectional_const_circulator_over_struct Self; typedef const S& reference; typedef const S* pointer; // CREATION Bidirectional_const_circulator_over_struct() {} // a circulator `circ' with singular value. Bidirectional_const_circulator_over_struct( const S* ptr) : Bidirectional_circulator_ptrbase( (void*)ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { return *(const S*)this->_ptr;} pointer operator->() const { return (const S*)this->_ptr;} Self& operator++() { this->_ptr = ((S*)this->_ptr)->next; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { this->_ptr = ((S*)this->_ptr)->prev; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class C> class Forward_circulator_over_class : public Forward_circulator_ptrbase{ public: typedef Forward_circulator_over_class Self; // DEFINITION // // Given a class `C' that has a member function `C* next()' that realizes // a ring like data structure the adaptor // `Forward_circulator_over_class' provides a forward circulator // for it. If the class `C' has additionally a second member function `C* // prev()' that realizes the reverse direction the adaptor // `Bidirectional_circulator_over_class' provides a bidirectional // circulator for it. In addition, adaptors for const circulators are // provided with the names `Forward_const_circulator_over_class' // and `Bidirectional_const_circulator_over_class'. A circulator // becomes invalid whenever the object it refers to gets deleted from the // data structure. Forward_circulator_over_class() {} // a circulator `circ' with a singular value. Forward_circulator_over_class( C* ptr) : Forward_circulator_ptrbase( ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } C& operator*() const { return *(C*)this->_ptr;} C* operator->() const { return (C*)this->_ptr;} Self& operator++() { this->_ptr = ((C*)this->_ptr)->next(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class C> class Forward_const_circulator_over_class : public Forward_circulator_ptrbase{ public: typedef Forward_const_circulator_over_class Self; Forward_const_circulator_over_class() {} // a circulator `circ' with singular value. Forward_const_circulator_over_class( const C* ptr) : Forward_circulator_ptrbase ((void*)ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } const C& operator*() const { return *(C*)this->_ptr;} const C* operator->() const { return (C*)this->_ptr;} Self& operator++() { this->_ptr = (void*)(((C*)this->_ptr)->next()); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } }; template < class C> class Bidirectional_circulator_over_class : public Bidirectional_circulator_ptrbase{ public: typedef Bidirectional_circulator_over_class Self; Bidirectional_circulator_over_class() {} // a circulator `circ' with singular value. Bidirectional_circulator_over_class( C* ptr) : Bidirectional_circulator_ptrbase (ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } C& operator*() const { return *(C*)this->_ptr;} C* operator->() const { return (C*)this->_ptr;} Self& operator++() { this->_ptr = ((C*)this->_ptr)->next(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { this->_ptr = ((C*)this->_ptr)->prev(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class C> class Bidirectional_const_circulator_over_class : public Bidirectional_circulator_ptrbase{ public: typedef Bidirectional_const_circulator_over_class Self; // // CREATION Bidirectional_const_circulator_over_class() {} // a circulator `circ' with singular value. Bidirectional_const_circulator_over_class( const C* ptr) : Bidirectional_circulator_ptrbase( (void*)ptr) {} // a circulator `circ' initialized to point to the element `*ptr'. // // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return this->_ptr == NULL; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return this->_ptr == c._ptr; } bool operator!=( const Self& c) const { return !(*this == c); } const C& operator*() const { return *(C*)this->_ptr;} const C* operator->() const { return (C*)this->_ptr;} Self& operator++() { this->_ptr = (void*)(((C*)this->_ptr)->next()); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { this->_ptr = (void*)(((C*)this->_ptr)->prev()); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class A, class T, class U, class I> class Circulator_over_array : public Random_access_circulator_ptrbase{ U _size; U _i; public: // DEFINITION // // Given a data structure `A' that provides random access with an index of // type `U' to its sequence of stored elements of type `T' with the member // function `operator[]' the adaptor `Circulator_over_array< A, T, U, // I>' provides a random access circulator for `A'. The corresponding // const circulator is `Const_circulator_over_array< A, T, U, I>'. All // circulators for an array `a' become invalid whenever `a' changes its // size (due to deletions or insertions). // // `A' is a random access data structure and `T' its value type. `U' is // the unsigned integral type carrying the size of the array and the // actual index within the container. `I' is the signed integral type used // as distance type and as index type in the random access circulator. // TYPES typedef A Array; typedef Circulator_over_array Self; // CREATION Circulator_over_array() : _size(0), _i(0) {} // a circulator `circ' with singular value. Circulator_over_array( A& array, U size, U start = 0) : Random_access_circulator_ptrbase( &array), _size( size), _i(start) {} // a circulator `circ' initialized to refer to the element // `(array.*access)(start)'. The circulator `circ' contains a // singular value if `start >= size'. Precondition: The // expressions `(array.*access)(i)' are valid in the range // 0 <= i < `size' . // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return _i >= _size; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { CGAL_assertion( this->_ptr == c._ptr); // belong to the same array? CGAL_assertion( _size == c._size); // same size when instantiated ? return _i == c._i; } bool operator!=( const Self& c) const { return !(*this == c); } T& operator*() const { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); return ((A*)this->_ptr)->operator[](_i); } T* operator->() const { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); return &(((A*)this->_ptr)->operator[](_i)); } Self& operator++() { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); ++ _i; if ( _i >= _size) _i = 0; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); if ( _i <= 0) _i = _size - 1; else -- _i; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( I n); Self operator+( I n) const { Self tmp = *this; return tmp += n; } Self& operator-=( I n) { return operator+=( -n); } Self operator-( I n) const { Self tmp = *this; return tmp += -n; } I operator-( const Self& c) const { CGAL_assertion( this->_ptr == c._ptr); // belong to the same array? CGAL_assertion( _size == c._size); // same size when instantiated ? return _i - c._i; } T& operator[](I n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } Self min_circulator() { return Self( *((A*)this->_ptr), _size); } // no relational ordering }; template < class Dist, class A, class T, class U, class I> inline Circulator_over_array< A, T, U, I> operator+( Dist n, const Circulator_over_array< A, T, U, I>& circ) { Circulator_over_array< A, T, U, I> tmp = circ; return tmp += I(n); } template < class A, class T, class U, class I> Circulator_over_array< A, T, U, I>& Circulator_over_array< A, T, U, I>:: operator+=( I n) { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); _i = non_negative_mod( (I)(_i) + n, _size); CGAL_assertion( _i < _size); return *this; } template < class A, class T, class U, class I> class Const_circulator_over_array : public Random_access_circulator_ptrbase { U _size; U _i; public: // TYPES typedef A Array; typedef Const_circulator_over_array Self; // New creation variable is: `circ' // // CREATION Const_circulator_over_array() : _size(0), _i(0) {} // a const circulator `circ' with singular value. Const_circulator_over_array( const A& array, U size, U start = 0) : Random_access_circulator_ptrbase( (void*)(&array)), _size( size), _i(start) {} // a const circulator `circ' initialized to refer to the element // `(array.*access)(start)'. The circulator `circ' contains a // singular value if `start >= size'. Precondition: The // expressions `(array.*access)(i)' are valid in the range // 0 <= i < `size' . // // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return _i >= _size; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { CGAL_assertion( this->_ptr == c._ptr); // belong to the same array? CGAL_assertion( _size == c._size); // same size when instantiated ? return _i == c._i; } bool operator!=( const Self& c) const { return !(*this == c); } const T& operator*() const { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); return ((const A*)this->_ptr)->operator[](_i); } const T* operator->() const { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); return &(((const A*)this->_ptr)->operator[](_i)); } Self& operator++() { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); ++ _i; if ( _i >= _size) _i = 0; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); if ( _i <= 0) _i = _size - 1; else -- _i; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( I n); Self operator+( I n) const { Self tmp = *this; return tmp += n; } Self& operator-=( I n) { return operator+=( -n); } Self operator-( I n) const { Self tmp = *this; return tmp += -n; } I operator-( const Self& c) const { CGAL_assertion( this->_ptr == c._ptr); // belong to the same array? CGAL_assertion( _size == c._size); // same size when instantiated ? return _i - c._i; } const T& operator[](I n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } Self min_circulator() { return Self( *((const A*)this->_ptr), _size); } // no relational ordering }; template < class Dist, class A, class T, class U, class I> inline Const_circulator_over_array< A, T, U, I> operator+( Dist n, const Const_circulator_over_array& circ) { Const_circulator_over_array< A, T, U, I> tmp = circ; return tmp += I(n); } template < class A, class T, class U, class I> Const_circulator_over_array< A, T, U, I>& Const_circulator_over_array< A, T, U, I>:: operator+=( I n) { CGAL_assertion( this->_ptr != NULL); CGAL_assertion( _i < _size); _i = non_negative_mod( (I)(_i) + n, _size); CGAL_assertion( _i < _size); return *this; } CGAL_END_NAMESPACE #endif // CGAL_CIRCULATOR_IMPL_H // // EOF // ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Ray_2_intersec0000644000175000017500000000554211344301500031213 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POINT_2_RAY_2_INTERSECTION_H #define CGAL_POINT_2_RAY_2_INTERSECTION_H #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Ray_2 &ray, const K&) { return ray.has_on(pt); } template inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Point_2 &pt, const K&) { return ray.has_on(pt); } template Object intersection(const typename CGAL_WRAP(K)::Point_2 &pt, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { if (do_intersect(pt,ray, k)) { return make_object(pt); } return Object(); } template Object intersection(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Point_2 &pt, const K& k) { if (do_intersect(pt,ray, k)) { return make_object(pt); } return Object(); } } // namespace CGALi template inline bool do_intersect(const Ray_2 &ray, const Point_2 &pt) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, ray); } template inline bool do_intersect(const Point_2 &pt, const Ray_2 &ray) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(pt, ray); } template inline Object intersection(const Ray_2 &ray, const Point_2 &pt) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, ray); } template inline Object intersection(const Point_2 &pt, const Ray_2 &ray) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt, ray); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Ray_2_inter0000644000175000017500000000223511344301501031171 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/leda_bigfloat.h0000644000175000017500000000501211344301500027743 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/leda_bigfloat.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_LEDA_BIGFLOAT_H #define CGAL_LEDA_BIGFLOAT_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; #ifndef CGAL_CFG_NO_NAMESPACE inline double to_double(const leda_bigfloat & b) { return CGAL_LEDA_SCOPE::to_double(b); } #endif // CGAL_CFG_NO_NAMESPACE inline leda_bigfloat sqrt(const leda_bigfloat & b) { return CGAL_LEDA_SCOPE::sqrt(b); } inline bool is_finite(const leda_bigfloat & b) { return !( CGAL_LEDA_SCOPE::isInf(b) || CGAL_LEDA_SCOPE::isNaN(b) ); } inline bool is_valid(const leda_bigfloat & b) { return !( CGAL_LEDA_SCOPE::isNaN(b) ); } inline io_Operator io_tag(const leda_bigfloat &) { return io_Operator(); } inline std::pair to_interval (const leda_bigfloat & z) { // assuming leda_bigfloat guarantee 1 bit error max Protect_FPU_rounding P (CGAL_FE_TONEAREST); Interval_nt_advanced approx (CGAL_LEDA_SCOPE::to_double(z)); FPU_set_cw(CGAL_FE_UPWARD); approx += Interval_nt::smallest(); return approx.pair(); } CGAL_END_NAMESPACE #endif // CGAL_LEDA_BIGFLOAT_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Euclidean_distance_sphere_point.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Euclidean_distance_sph0000644000175000017500000000760111344301500031364 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Euclidean_distance_sphere_point.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_EUCLIDEAN_DISTANCE_SPHERE_POINT_H #define CGAL_EUCLIDEAN_DISTANCE_SPHERE_POINT_H #include namespace CGAL { template class Euclidean_distance_sphere_point { public: typedef typename SearchTraits::Point_d Point_d; typedef typename SearchTraits::Sphere_d Sphere_d; typedef typename SearchTraits::FT FT; typedef typename SearchTraits::Construct_center_d Construct_center_d; typedef typename SearchTraits::Compute_squared_radius_d Compute_squared_radius_d; typedef typename SearchTraits::Construct_cartesian_const_iterator_d Construct_cartesian_const_iterator_d; typedef typename SearchTraits::Cartesian_const_iterator_d Cartesian_const_iterator_d; typedef Sphere_d Query_item; public: // default constructor Euclidean_distance_sphere_point() {} inline FT transformed_distance(const Sphere_d& q, const Point_d& p) const { Point_d c= Construct_center_d()(q); FT distance = FT(0); Construct_cartesian_const_iterator_d construct_it; Cartesian_const_iterator_d cit = construct_it(c), ce = construct_it(c,1), pit = construct_it(p); for(; cit != ce; cit++, pit++){ distance += ((*cit)-(*pit))*((*cit)-(*pit)); } distance += - Compute_squared_radius_d()(q); if (distance<0) distance=FT(0); return distance; } inline FT min_distance_to_rectangle(const Sphere_d& q, const Kd_tree_rectangle& r) const { Point_d c= Construct_center_d()(q); FT distance = FT(0); Construct_cartesian_const_iterator_d construct_it; Cartesian_const_iterator_d cit = construct_it(c), ce = construct_it(c,1); for (unsigned int i = 0; cit != ce; ++i, ++cit) { if ((*cit) < r.min_coord(i)) distance += (r.min_coord(i)-(*cit))*(r.min_coord(i)-(*cit)); else if ((*cit) > r.max_coord(i)) distance += ((*cit)-r.max_coord(i))*((*cit)-r.max_coord(i)); }; distance += - Compute_squared_radius_d()(q); if (distance<0) distance=FT(0); return distance; } inline FT max_distance_to_rectangle(const Sphere_d& q, const Kd_tree_rectangle& r) const { Construct_center_d construct_center_d; Point_d c = construct_center_d(q); FT distance=FT(0); Construct_cartesian_const_iterator_d construct_it; Cartesian_const_iterator_d cit = construct_it(c), ce = construct_it(c,1); for (unsigned int i = 0; cit != ce; ++i, ++cit) { if ((*cit) <= (r.min_coord(i)+r.max_coord(i))/FT(2.0)) distance += (r.max_coord(i)-(*cit))*(r.max_coord(i)-(*cit)); else distance += ((*cit)-r.min_coord(i))*((*cit)-r.min_coord(i)); }; distance += - Compute_squared_radius_d()(q); if (distance<0) distance=FT(0); return distance; } inline FT transformed_distance(FT d) const { return d*d; } inline FT inverse_of_transformed_distance(FT d) const { return CGAL::sqrt(d); } }; // class Euclidean_distance_sphere_point } // namespace CGAL #endif // EUCLIDEAN_DISTANCE_SPHERE_POINT_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_Line_2_intersec0000644000175000017500000000614411344301500031147 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_BBOX_2_LINE_2_INTERSECTION_H #define CGAL_BBOX_2_LINE_2_INTERSECTION_H #include #include //#include //#include #include #include CGAL_BEGIN_NAMESPACE class Bbox_2_Line_2_pair_impl; class Bbox_2_Line_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Bbox_2_Line_2_pair() ; Bbox_2_Line_2_pair(Bbox_2_Line_2_pair const &); Bbox_2_Line_2_pair(Bbox_2 const &bbox, double line_a, double line_b, double line_c); ~Bbox_2_Line_2_pair() ; Bbox_2_Line_2_pair &operator=(Bbox_2_Line_2_pair const &o); // set_bbox(Bbox_2 const &bbox); // set_line(double line_a, double line_b, double line_c); Intersection_results intersection_type() const; bool intersection(double &x, double &y) const; bool intersection(double &x1, double &y1, double &x2, double &y2) const; protected: Bbox_2_Line_2_pair_impl *pimpl; }; template Bbox_2_Line_2_pair intersection_computer_line_2( Bbox_2 const &bbox, Line const &line) { return Bbox_2_Line_2_pair(bbox, to_double(line->a()), to_double(line->b()), to_double(line->c())); } inline bool do_intersect_line_2( const Bbox_2 &box, double line_a, double line_b, double line_c) { Bbox_2_Line_2_pair pair(box, line_a, line_b, line_c); return pair.intersection_type() != Bbox_2_Line_2_pair::NO; } template bool do_intersect_line_2( Bbox_2 const &bbox, Line const &line) { return do_intersect_line_2(bbox, to_double(line->a()), to_double(line->b()), to_double(line->c())); } template bool do_intersect_line_2( Line const &line, Bbox_2 const &bbox) { return do_intersect_line_2(bbox, to_double(line->a()), to_double(line->b()), to_double(line->c())); } template inline bool do_intersect( const Line_2 &line, const Bbox_2 &box) { return do_intersect(box, line); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/circulator.h0000644000175000017500000011120511344301500027340 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/circulator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_CIRCULATOR_H #define CGAL_CIRCULATOR_H #include #include #include #include #include #ifndef CGAL_NULL_TYPE #if defined( __GNUG__ ) // (__GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 91)) #define CGAL_NULL_TYPE const void* #define CGAL_CIRC_NULL 0 #else // __GNUG__ // #define CGAL_NULL_TYPE int #define CGAL_CIRC_NULL NULL #endif // __GNUG__ // #endif // CGAL_NULL_TYPE // // These are name redefinitions for backwards compatibility // with the pre iterator-traits style adaptors. #define Forward_container_from_circulator \ Container_from_circulator #define Bidirectional_container_from_circulator \ Container_from_circulator #define Random_access_container_from_circulator \ Container_from_circulator #define Forward_circulator_from_iterator \ Circulator_from_iterator #define Forward_const_circulator_from_iterator \ Circulator_from_iterator #define Bidirectional_circulator_from_iterator \ Circulator_from_iterator #define Bidirectional_const_circulator_from_iterator \ Circulator_from_iterator #define Random_access_circulator_from_iterator \ Circulator_from_iterator #define Random_access_const_circulator_from_iterator \ Circulator_from_iterator #define Forward_circulator_from_container \ Circulator_from_container #define Bidirectional_circulator_from_container \ Circulator_from_container #define Random_access_circulator_from_container \ Circulator_from_container #define Forward_const_circulator_from_container \ Const_circulator_from_container #define Bidirectional_const_circulator_from_container \ Const_circulator_from_container #define Random_access_const_circulator_from_container \ Const_circulator_from_container CGAL_BEGIN_NAMESPACE template struct I_Circulator_traits { typedef Iterator_tag category; }; template <> struct I_Circulator_traits { typedef Circulator_tag category; }; template <> struct I_Circulator_traits { typedef Circulator_tag category; }; template <> struct I_Circulator_traits { typedef Circulator_tag category; }; // Circulator_size_traits are used by general adaptors for // iterators and circulators. For example the N_step_adaptor // works for iterators as well as for circulators. Circulators // need a local type called size_type which is not needed for // iterators. But a general adaptor has to declare this type // in any case and the following Circulator_size_traits helps // in this case. It declares size_type to be std::size_t for // iterators and to be C::size_type for any circulator C. template struct I_Circulator_size_traits { typedef std::size_t size_type; }; template struct I_Circulator_size_traits< Forward_circulator_tag, C> { typedef typename C::size_type size_type; }; template struct I_Circulator_size_traits< Bidirectional_circulator_tag, C> { typedef typename C::size_type size_type; }; template struct I_Circulator_size_traits< Random_access_circulator_tag, C> { typedef typename C::size_type size_type; }; template struct I_Iterator_from_circulator_traits { typedef CCtg iterator_category; }; template <> struct I_Iterator_from_circulator_traits< Forward_circulator_tag> { typedef std::forward_iterator_tag iterator_category; }; template <> struct I_Iterator_from_circulator_traits< Bidirectional_circulator_tag> { typedef std::bidirectional_iterator_tag iterator_category; }; template <> struct I_Iterator_from_circulator_traits< Random_access_circulator_tag> { typedef std::random_access_iterator_tag iterator_category; }; template struct I_Circulator_from_iterator_traits { typedef ICtg iterator_category; }; template <> struct I_Circulator_from_iterator_traits< std::forward_iterator_tag> { typedef Forward_circulator_tag iterator_category; }; template <> struct I_Circulator_from_iterator_traits { typedef Bidirectional_circulator_tag iterator_category; }; template <> struct I_Circulator_from_iterator_traits { typedef Random_access_circulator_tag iterator_category; }; template struct Circulator_traits { typedef std::iterator_traits traits; typedef typename traits::iterator_category ICAT; typedef I_Circulator_traits C_traits; typedef typename C_traits::category category; typedef I_Iterator_from_circulator_traits Ic_traits; typedef typename Ic_traits::iterator_category iterator_category; typedef I_Circulator_from_iterator_traits Ci_traits; typedef typename Ci_traits::iterator_category circulator_category; }; template typename Circulator_traits::category query_circulator_or_iterator( const C&) { typedef typename Circulator_traits::category category; return category(); } /* A function that asserts a specific compile time tag */ /* forcing its two arguments to have equal type. */ /* It is encapsulated with #ifdef since it will be defined also elsewhere. */ #ifndef CGAL_ASSERT_COMPILE_TIME_TAG #define CGAL_ASSERT_COMPILE_TIME_TAG 1 template struct I_Assert_tag_class { void match_compile_time_tag( const Base&) const {} }; template< class Tag, class Derived> inline void Assert_compile_time_tag( const Tag&, const Derived& b) { I_Assert_tag_class x; x.match_compile_time_tag(b); } #endif template inline void Assert_circulator( const C &) { typedef typename Circulator_traits::category category; Assert_compile_time_tag( Circulator_tag(), category()); } template inline void Assert_iterator( const I &) { typedef typename Circulator_traits::category category; Assert_compile_time_tag( Iterator_tag(), category()); } template inline void Assert_input_category( const I &/*i*/) { typedef typename std::iterator_traits::iterator_category category; Assert_compile_time_tag( std::input_iterator_tag(), category()); } template inline void Assert_output_category( const I &/*i*/) { typedef typename std::iterator_traits::iterator_category category; Assert_compile_time_tag( std::output_iterator_tag(), category()); } template inline void Assert_forward_category( const IC &/*ic*/) { typedef typename std::iterator_traits::iterator_category category; Assert_compile_time_tag( std::forward_iterator_tag(), category()); } template inline void Assert_bidirectional_category( const IC &/*ic*/) { typedef typename std::iterator_traits::iterator_category category; Assert_compile_time_tag( std::bidirectional_iterator_tag(), category()); } template inline void Assert_random_access_category( const IC &/*ic*/) { typedef typename std::iterator_traits::iterator_category category; Assert_compile_time_tag( std::random_access_iterator_tag(), category()); } // The assert at-least-category functions use the following // functions to resolve properly. Note the proper order of the // arguments: 1st is the to be type, 2nd is the actual type. inline void I_Has_to_be_at_least( std::input_iterator_tag, std::input_iterator_tag){} inline void I_Has_to_be_at_least( std::input_iterator_tag, std::forward_iterator_tag){} inline void I_Has_to_be_at_least( std::input_iterator_tag, std::bidirectional_iterator_tag){} inline void I_Has_to_be_at_least( std::input_iterator_tag, std::random_access_iterator_tag){} inline void I_Has_to_be_at_least( std::output_iterator_tag, std::output_iterator_tag){} inline void I_Has_to_be_at_least( std::output_iterator_tag, std::forward_iterator_tag){} inline void I_Has_to_be_at_least( std::output_iterator_tag, std::bidirectional_iterator_tag){} inline void I_Has_to_be_at_least( std::output_iterator_tag, std::random_access_iterator_tag){} inline void I_Has_to_be_at_least( std::forward_iterator_tag, std::forward_iterator_tag){} inline void I_Has_to_be_at_least( std::forward_iterator_tag, std::bidirectional_iterator_tag){} inline void I_Has_to_be_at_least( std::forward_iterator_tag, std::random_access_iterator_tag){} inline void I_Has_to_be_at_least( std::bidirectional_iterator_tag, std::bidirectional_iterator_tag){} inline void I_Has_to_be_at_least( std::bidirectional_iterator_tag, std::random_access_iterator_tag){} inline void I_Has_to_be_at_least( std::random_access_iterator_tag, std::random_access_iterator_tag){} // The is-at-least assertions. template inline void Assert_is_at_least_input_category( const I& /*i*/) { typedef typename std::iterator_traits::iterator_category category; I_Has_to_be_at_least( std::input_iterator_tag(), category()); } template inline void Assert_is_at_least_output_category( const I& /*i*/) { typedef typename std::iterator_traits::iterator_category category; I_Has_to_be_at_least( std::output_iterator_tag(), category()); } template inline void Assert_is_at_least_forward_category( const IC& /*ic*/) { typedef typename std::iterator_traits::iterator_category category; I_Has_to_be_at_least( std::forward_iterator_tag(), category()); } template inline void Assert_is_at_least_bidirectional_category( const IC& /*ic*/) { typedef typename std::iterator_traits::iterator_category category; I_Has_to_be_at_least( std::bidirectional_iterator_tag(), category()); } template inline void Assert_is_at_least_random_access_category( const IC& /*ic*/) { typedef typename std::iterator_traits::iterator_category category; I_Has_to_be_at_least( std::random_access_iterator_tag(), category()); } template< class C> inline bool I_is_empty_range( const C& c1, const C&, Circulator_tag){ return c1 == CGAL_CIRC_NULL; } template< class I> inline bool I_is_empty_range( const I& i1, const I& i2, Iterator_tag){ return i1 == i2; } template< class IC> inline bool is_empty_range( const IC& ic1, const IC& ic2){ // is `true' if the range [`ic1, ic2') is empty, `false' otherwise. // Precondition: `T' is either a circulator or an iterator type. The // range [`ic1, ic2') is valid. typedef typename Circulator_traits::category category; return I_is_empty_range( ic1, ic2, category()); } struct Circulator_or_iterator_tag {}; // any circulator or iterator. inline Circulator_or_iterator_tag check_circulator_or_iterator( Circulator_tag ){ return Circulator_or_iterator_tag(); } inline Circulator_or_iterator_tag check_circulator_or_iterator( Iterator_tag ){ return Circulator_or_iterator_tag(); } template< class IC> inline void Assert_circulator_or_iterator( const IC &){ typedef typename Circulator_traits::category category; Assert_compile_time_tag( Circulator_or_iterator_tag(), check_circulator_or_iterator( category())); } #define CGAL_For_all( ic1, ic2) \ for ( bool _circ_loop_flag = ! ::CGAL::is_empty_range( ic1, ic2); \ _circ_loop_flag; \ _circ_loop_flag = ((++ic1) != (ic2)) ) #define CGAL_For_all_backwards( ic1, ic2) \ for ( bool _circ_loop_flag = ! ::CGAL::is_empty_range( ic1, ic2); \ _circ_loop_flag; \ _circ_loop_flag = ((ic1) != (--ic2)) ) template inline typename C::size_type I_min_circulator_size( const C& c) { Assert_circulator(c); Assert_random_access_category(c); typedef typename C::size_type size_type; size_type n = 0; if ( c != CGAL_CIRC_NULL) { n = (c-1) - c + 1; CGAL_assertion(n > 0); } return n; } template typename C::size_type I_circulator_size( const C& c, Forward_circulator_tag) { // Simply count. if ( c == CGAL_CIRC_NULL) return 0; typedef typename C::size_type size_type; size_type n = 0; C d = c; do { ++n; ++d; } while( c != d); return n; } template inline typename C::size_type I_circulator_size( const C& c, Bidirectional_circulator_tag) { return I_circulator_size( c, Forward_circulator_tag()); } template inline typename C::size_type I_circulator_size( const C& c, Random_access_circulator_tag) { return I_min_circulator_size( c.min_circulator()); } template inline typename C::size_type circulator_size( const C& c) { typedef typename std::iterator_traits::iterator_category category; return I_circulator_size( c, category()); } template typename C::difference_type I_circulator_distance( C c, const C& d, Forward_circulator_tag) { // Simply count. if ( c == CGAL_CIRC_NULL) return 0; typedef typename C::difference_type difference_type; difference_type n = 0; do { ++n; } while( ++c != d); return n; } template inline typename C::difference_type I_circulator_distance( const C& c, const C& d, Bidirectional_circulator_tag) { return I_circulator_distance( c, d, Forward_circulator_tag()); } template inline typename C::difference_type I_circulator_distance( const C& c, const C& d, Random_access_circulator_tag) { typedef typename C::difference_type difference_type; typedef typename C::size_type size_type; if ( d - c > 0) return (d - c); return difference_type( size_type( I_min_circulator_size( c.min_circulator()))) - (c-d); } template inline typename C::difference_type circulator_distance( const C& c, const C& d) { typedef typename std::iterator_traits::iterator_category category; return I_circulator_distance( c, d, category()); } template inline #ifdef __SUNPRO_CC ptrdiff_t #else typename std::iterator_traits::difference_type #endif // __SUNPRO_CC I_iterator_distance(const C& c1, const C& c2, Circulator_tag) { return circulator_distance( c1, c2); } template inline #ifdef __SUNPRO_CC ptrdiff_t #else typename std::iterator_traits::difference_type #endif // __SUNPRO_CC I_iterator_distance(const I& i1, const I& i2, Iterator_tag) { return std::distance( i1, i2); } template inline #ifdef __SUNPRO_CC ptrdiff_t #else typename std::iterator_traits::difference_type #endif // __SUNPRO_CC iterator_distance(const IC& ic1, const IC& ic2) { typedef typename Circulator_traits::category category; return I_iterator_distance( ic1, ic2, category()); } template inline C I_get_min_circulator( C c, Forward_circulator_tag) { return c; } template inline C I_get_min_circulator( C c, Bidirectional_circulator_tag) { return c; } template inline C I_get_min_circulator( C c, Random_access_circulator_tag) { return c.min_circulator(); } template inline C get_min_circulator( C c) { typedef std::iterator_traits Traits; typedef typename Traits::iterator_category Category; return I_get_min_circulator( c, Category()); } template inline I non_negative_mod(I n, U m) { CGAL_precondition( m > 0); #if (-1 % 3) > 0 n = n % m; #else if (n < 0) n = - (( - n - 1) % m) + m - 1; else n = n % m; #endif CGAL_postcondition( n >= 0); return n; } template < class C, class Ref, class Ptr> class Iterator_from_circulator { private: // The m_anchor is normalized to be a minimal circulator. const C* m_anchor; C current; int m_winding; typedef std::iterator_traits I_traits; typedef typename I_traits::iterator_category I_Iter_cat; typedef I_Iterator_from_circulator_traits I__traits; public: // // TYPES typedef C Circulator; typedef Iterator_from_circulator Self; typedef typename I__traits::iterator_category iterator_category; typedef typename C::value_type value_type; typedef typename C::difference_type difference_type; typedef typename C::size_type size_type; typedef typename C::reference reference; typedef typename C::pointer pointer; // // CREATION Iterator_from_circulator() : m_anchor(0), m_winding(0) {} Iterator_from_circulator( const C* circ, int n) : m_anchor( circ), current( *circ), m_winding(n) {} // Allow construction from Iterator_from_circulator with // assignment compatible circulator CC: template Iterator_from_circulator( const Iterator_from_circulator& c) : m_anchor( c.anchor()), current( c.current_circulator()), m_winding(c.winding()) {} // // OPERATIONS bool operator==( const Self& i) const { CGAL_assertion( m_anchor == i.m_anchor); // same anchor? return ( current == i.current) && ( m_winding == i.m_winding); } bool operator!=( const Self& i) const { return !(*this == i); } Ref operator*() const { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); return Ref(*current); } Ptr operator->() const { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); return Ptr(current.operator->()); } Self& operator++() { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); ++current; if ( current == *m_anchor) ++m_winding; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); if ( current == *m_anchor) --m_winding; --current; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( difference_type n) { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); if ( n < 0 && current == *m_anchor) // We are leaving the anchor. --m_winding; current += n; if ( n > 0 && current == *m_anchor) // Back again at the anchor. ++m_winding; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); CGAL_assertion( m_anchor == i.m_anchor); if ( m_winding != i.m_winding) { difference_type s = I_min_circulator_size( *m_anchor); return (current - *m_anchor) - (i.current - *m_anchor) + s * (m_winding - i.m_winding); } return (current - *m_anchor) - (i.current - *m_anchor); } Ref operator[](difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator<( const Self& i) const { CGAL_assertion( m_anchor != CGAL_CIRC_NULL); CGAL_assertion( current != CGAL_CIRC_NULL); CGAL_assertion( m_anchor == i.m_anchor); return ( (m_winding < i.m_winding) || ( (m_winding == i.m_winding) && (current - *m_anchor) < (i.current - *m_anchor) ) ); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } const C* anchor() const { return m_anchor;} int winding() const { return m_winding;} Circulator current_circulator() const { return current;} }; template < class Dist, class C, class Ref, class Ptr> Iterator_from_circulator operator+( Dist n, const Iterator_from_circulator& circ) { Iterator_from_circulator tmp = circ; return tmp += n; } template < class C > class Container_from_circulator { private: C anchor; public: // // CREATION Container_from_circulator() {} // the resulting iterators will have a singular value. Container_from_circulator(const C& c) // The anchor is normalized to be a minimal circulator. : anchor(get_min_circulator(c)) {} // the resulting iterators will have a singular value if the // circulator `c' is singular. // // TYPES typedef C Circulator; typedef typename C::value_type value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; typedef typename C::size_type size_type; typedef typename C::difference_type difference_type; typedef Iterator_from_circulator< C, reference, pointer> iterator; typedef Iterator_from_circulator< C, const_reference, const_pointer> const_iterator; // // OPERATIONS iterator begin() { // the start iterator. return iterator( &anchor, 0); } const_iterator begin() const { // the start const iterator. return const_iterator( &anchor, 0); } iterator end() { // the past-the-end iterator. return anchor == CGAL_CIRC_NULL ? iterator( &anchor, 0) : iterator( &anchor, 1); } const_iterator end() const { // the past-the-end const iterator. return anchor == CGAL_CIRC_NULL ? const_iterator( &anchor, 0) : const_iterator( &anchor, 1); } }; template < class Ctnr> class Circulator_from_container { public: // TYPES typedef Circulator_from_container Self; typedef Ctnr Container; typedef typename Ctnr::iterator iterator; typedef typename Ctnr::value_type value_type; typedef typename Ctnr::reference reference; typedef value_type* pointer; typedef typename Ctnr::size_type size_type; typedef typename Ctnr::difference_type difference_type; typedef std::iterator_traits ITraits; typedef typename ITraits::iterator_category Icategory; typedef I_Circulator_from_iterator_traits CTraits; typedef typename CTraits::iterator_category iterator_category; private: Ctnr* ctnr; iterator i; public: // CREATION Circulator_from_container() : ctnr(NULL) {} Circulator_from_container( Ctnr* c) : ctnr(c), i(c->begin()) {} Circulator_from_container( Ctnr* c, iterator j) : ctnr(c), i(j) {} // Gnu-bug workaround: define operator= explicitly. Self& operator=( const Self& c) { ctnr = c.ctnr; i = c.i; return *this; } // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return (ctnr == NULL) || (ctnr->begin() == ctnr->end()); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return i == c.i; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); return *i; } pointer operator->() const { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); return i.operator->(); } Self& operator++() { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); ++i; if ( i == ctnr->end()) i = ctnr->begin(); return *this; } Self operator++(int) { Self tmp= *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); if ( i == ctnr->begin()) i = ctnr->end(); --i; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( difference_type n) { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); typename Ctnr::difference_type j = i - ctnr->begin(); typename Ctnr::difference_type size = ctnr->size(); CGAL_assertion( j >= 0); CGAL_assertion( size >= 0); j = non_negative_mod( j + n, size); CGAL_assertion( j >= 0); CGAL_assertion( j < size); i = ctnr->begin() + j; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& c) const { CGAL_assertion( ctnr != NULL); CGAL_assertion( c.ctnr != NULL); return i - c.i; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return *tmp; } iterator current_iterator() const { return i;} Self min_circulator() const { return Self(ctnr); } Ctnr* container() const { return ctnr; } }; template inline Circulator_from_container operator+( typename Circulator_from_container::difference_type n, const Circulator_from_container& c) { Circulator_from_container tmp = c; return tmp += n; } template < class Ctnr> class Const_circulator_from_container { public: // TYPES typedef Const_circulator_from_container Self; typedef Circulator_from_container Mutable; typedef Ctnr Container; typedef typename Ctnr::const_iterator const_iterator; typedef typename Ctnr::value_type value_type; typedef typename Ctnr::const_reference reference; typedef const value_type* pointer; typedef typename Ctnr::size_type size_type; typedef typename Ctnr::difference_type difference_type; typedef std::iterator_traits ITraits; typedef typename ITraits::iterator_category Icategory; typedef I_Circulator_from_iterator_traits CTraits; typedef typename CTraits::iterator_category iterator_category; private: const Ctnr* ctnr; const_iterator i; public: // CREATION Const_circulator_from_container() : ctnr(NULL) {} Const_circulator_from_container( const Ctnr* c) : ctnr(c), i(c->begin()) {} Const_circulator_from_container( const Ctnr* c, const_iterator j) : ctnr(c), i(j) {} Const_circulator_from_container( const Mutable& c) : ctnr( c.container()), i( c.current_iterator()) {} // Gnu-bug workaround: define operator= explicitly. Self& operator=( const Self& c) { ctnr = c.ctnr; i = c.i; return *this; } // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); return (ctnr == NULL) || (ctnr->begin() == ctnr->end()); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return i == c.i; } bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); return *i; } pointer operator->() const { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); return i.operator->(); } Self& operator++() { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); ++i; if ( i == ctnr->end()) i = ctnr->begin(); return *this; } Self operator++(int) { Self tmp= *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); if ( i == ctnr->begin()) i = ctnr->end(); --i; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( difference_type n) { CGAL_assertion( ctnr != NULL); CGAL_assertion( i != ctnr->end()); typename Ctnr::difference_type j = i - ctnr->begin(); typename Ctnr::difference_type size = ctnr->size(); CGAL_assertion( j >= 0); CGAL_assertion( size >= 0); j = non_negative_mod( j + n, size); CGAL_assertion( j >= 0); CGAL_assertion( j < size); i = ctnr->begin() + j; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& c) const { CGAL_assertion( ctnr != NULL); CGAL_assertion( c.ctnr != NULL); return i - c.i; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return *tmp; } const_iterator current_iterator() const { return i;} Self min_circulator() const { return Self(ctnr); } const Ctnr* container() const { return ctnr; } }; template inline Const_circulator_from_container operator+( typename Const_circulator_from_container::difference_type n, const Const_circulator_from_container& c) { Const_circulator_from_container tmp = c; return tmp += n; } // Note: TT, SS, and DD are here for backwards compatibility, they are // not used. template < class I, class TT = int, class SS = int, class DD = int> class Circulator_from_iterator { public: // TYPES typedef Circulator_from_iterator Self; typedef I iterator; typedef std::iterator_traits Traits; typedef typename Traits::value_type value_type; typedef std::size_t size_type; typedef typename Traits::difference_type difference_type; typedef typename Traits::reference reference; typedef typename Traits::pointer pointer; typedef typename Traits::iterator_category Icategory; typedef I_Circulator_from_iterator_traits CTraits; typedef typename CTraits::iterator_category iterator_category; private: I m_begin; I m_end; I current; // The following static iterator is needed so that we have a value // that can be uniquely compared (the default constructed one can be // different each time). static I null_iterator; public: // CREATION Circulator_from_iterator() : m_begin( null_iterator), m_end( null_iterator), current( null_iterator) {} Circulator_from_iterator( const I& bgn, const I& end) : m_begin(bgn), m_end(end), current(bgn) {} Circulator_from_iterator( const I& bgn, const I& end, const I& cur) : m_begin(bgn), m_end(end), current(cur) {} Circulator_from_iterator( const Self& c, const I& cur) : m_begin( c.m_begin), m_end( c.m_end), current(cur) {} template // Allow construction from Circulator_from_iterator with // assignment compatible iterator II: Circulator_from_iterator( const Circulator_from_iterator& ii) : m_begin( ii.begin()), m_end( ii.end()), current(ii.current_iterator()) {} // // OPERATIONS bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == CGAL_CIRC_NULL); CGAL_assertion((m_end == m_begin) || (current != m_end)); return m_end == m_begin; } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& c) const { return current == c.current;} bool operator!=( const Self& c) const { return !(*this == c); } reference operator*() const { CGAL_assertion( current != m_end); return *current; } pointer operator->() const { CGAL_assertion( current != m_end); return &(*current); } Self& operator++() { CGAL_assertion( current != m_end); ++current; if ( current == m_end) current = m_begin; return *this; } Self operator++(int) { Self tmp= *this; ++*this; return tmp; } Self& operator--() { CGAL_assertion( current != m_end); if ( current == m_begin) current = m_end; --current; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } Self& operator+=( difference_type n) { CGAL_assertion( current != m_end); difference_type i = current - m_begin; difference_type size = m_end - m_begin; CGAL_assertion( i >= 0); CGAL_assertion( size >= 0); i = non_negative_mod( i + n, size); CGAL_assertion( i >= 0); CGAL_assertion( i < size); current = m_begin + i; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { CGAL_assertion((m_begin == i.m_begin) && (m_end == i.m_end)); return current - i.current; } reference operator[](difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } iterator begin() const { return m_begin;} iterator end() const { return m_end;} iterator current_iterator() const { return current;} Self min_circulator() const { return Self( m_begin, m_end); } }; template < class I, class T, class Size, class Dist> I Circulator_from_iterator< I, T, Size, Dist>::null_iterator = I(); template < class D, class I, class T, class Size, class Dist> inline Circulator_from_iterator< I, T, Size, Dist> operator+( D n, const Circulator_from_iterator< I, T, Size, Dist>& circ) { Circulator_from_iterator< I, T, Size, Dist> tmp = circ; return tmp += Dist(n); } CGAL_END_NAMESPACE #endif // CGAL_CIRCULATOR_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/NT_converter.h0000644000175000017500000000277711344301500027616 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/NT_converter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_NT_CONVERTER_H #define CGAL_NT_CONVERTER_H #include CGAL_BEGIN_NAMESPACE // A number type converter usable as default, using the conversion operator. template < class NT1, class NT2 > struct NT_converter : public CGAL_STD::unary_function< NT1, NT2 > { NT2 operator()(const NT1 &a) const { return NT2(a); } }; CGAL_END_NAMESPACE #endif // CGAL_NT_CONVERTER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_d.C0000644000175000017500000000647311344301500027532 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_d.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr // Bernd Gaertner #include CGAL_BEGIN_NAMESPACE // Class implementation (continued) // ================================ // I/O // --- template < class Traits > std::ostream& operator << ( std::ostream& os, const Min_sphere_d& min_sphere) { typedef typename Min_sphere_d::Point Point; switch ( get_mode( os)) { case IO::PRETTY: os << std::endl; os << "Min_sphere_d( |P| = " << min_sphere.number_of_points() << ", |S| = " << min_sphere.number_of_support_points() << std::endl; os << " P = {" << std::endl; os << " "; std::copy( min_sphere.points_begin(), min_sphere.points_end(), std::ostream_iterator( os, ",\n ")); os << "}" << std::endl; os << " S = {" << std::endl; os << " "; std::copy( min_sphere.support_points_begin(), min_sphere.support_points_end(), std::ostream_iterator( os, ",\n ")); os << "}" << std::endl; os << " center = " << min_sphere.center() << std::endl; os << " squared radius = " << min_sphere.squared_radius() << std::endl; os << ")" << std::endl; break; case IO::ASCII: os << min_sphere.number_of_points() << std::endl; std::copy( min_sphere.points_begin(), min_sphere.points_end(), std::ostream_iterator( os, "\n")); break; case IO::BINARY: os << min_sphere.number_of_points() << " "; std::copy( min_sphere.points_begin(), min_sphere.points_end(), std::ostream_iterator( os, " ")); break; default: CGAL_optimisation_assertion_msg ( false, "get_mode( os) invalid!"); break; } return( os); } template < class Traits > std::istream& operator >> ( std::istream& is, Min_sphere_d& min_sphere) { switch ( get_mode( is)) { case IO::PRETTY: std::cerr << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; case IO::ASCII: case IO::BINARY: { min_sphere.clear(); int n; is >> n; typename Min_sphere_d::Point p; for (int i=0; i> p; min_sphere.insert (p); } } break; default: CGAL_optimisation_assertion_msg( false, "IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Level_interval.h0000644000175000017500000000605611344301500030153 0ustar debiandebian// Copyright (c) 2003 GeometryFactory // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Level_interval.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_LEVEL_INTERVAL_H #define CGAL_LEVEL_INTERVAL_H #include #include namespace CGAL { template class Level_interval { public: typedef typename FaceHandle::value_type Face; typedef typename Face::Vertex Vertex; typedef typename Vertex::Point Point; typedef typename Kernel_traits::Kernel K; typedef typename K::FT Value; private: FaceHandle fh_; Value inf_; Value sup_; // left and right boundary values public: Level_interval(){} Level_interval(FaceHandle fh); const Value& inf() const {return inf_;} const Value& sup() const {return sup_;} FaceHandle face_handle() const { return fh_;} bool contains(const Value& V) const; // true iff this contains (l,r) bool contains_interval(const Value& l, const Value& r) const; bool operator==(const Level_interval& I) const { // there is no need to compare inf and sup, as these are derived from the face return face_handle() == I.face_handle(); } bool operator!=(const Level_interval& I) const { return face_handle() != I.face_handle(); } }; template std::ostream& operator<<(std::ostream& os, const Level_interval& i) { os << i.face_handle()->vertex(0)->point() << ", " << i.face_handle()->vertex(1)->point() << ", " << i.face_handle()->vertex(2)->point() << std::endl; return os; } template Level_interval::Level_interval(FaceHandle fh) : fh_(fh), inf_(fh->vertex(0)->point().z()), sup_(inf_) { double z = fh->vertex(1)->point().z(); sup_= (z>sup_)? z : sup_; inf_ = (zvertex(2)->point().z(); sup_ = (z>sup_)? z : sup_; inf_ = (z bool Level_interval::contains_interval(const Value& i, const Value& s) const // true iff this contains (l,r) { return( (inf() <= i) && (sup() >= s) ); } template bool Level_interval::contains(const Value& v) const { // return true if this contains V, false otherwise if((v >= inf()) && (v <= sup())) return true; else return false; } } // namespace CGAL #endif // CGAL_LEVEL_INTERVAL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_items_2.h0000644000175000017500000000404711344301500030546 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_items_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_ITEMS_2_H #define CGAL_HALFEDGEDS_ITEMS_2_H 1 #ifndef CGAL_HALFEDGEDS_VERTEX_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_HALFEDGE_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_FACE_BASE_H #include #endif CGAL_BEGIN_NAMESPACE class HalfedgeDS_items_2 { public: template < class Refs, class Traits> struct Vertex_wrapper { typedef typename Traits::Point_2 Point; typedef HalfedgeDS_vertex_base< Refs, Tag_true, Point> Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef HalfedgeDS_halfedge_base< Refs> Halfedge; }; template < class Refs, class Traits> struct Face_wrapper { typedef HalfedgeDS_face_base< Refs> Face; }; }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_ITEMS_2_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/0000755000175000017500000000000012146213731027344 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_event.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_lin0000644000175000017500000004170611344301501031214 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_event.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_SWEEP_LINE_EVENT_H #define CGAL_SWEEP_LINE_EVENT_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*! @class Sweep_line_event * * A class associated with an event in a sweep line algorithm. * An intersection point in the sweep line algorithm is refered to as an event. * This class contains the information that is associated with any given * event point. This information contains the following: * - the actual point * - a list of curves that pass through the event point and defined to * the left of the event point. * - a list of curves that pass through the event point and defined to * the right of the event point. * - a list of vertical curves that pass through the event * - a list of points that are intersection points on the vertical curves * and some more data that is used to help with the algorithm. * * The class mostly exists to store information and does not have any * significant functionality otherwise. * * TODO - implement this class with a set to hold the left and right curves * TODO - implement the vertical points array as a set */ template class Sweep_line_event { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Point_2 Point_2; //typedef Sweep_line_subcurve SubCurve; typedef CurveWrap SubCurve; typedef std::list SubcurveContainer; //TODO - change it to SET (faster?) typedef typename SubcurveContainer::iterator SubCurveIter; typedef Status_line_curve_less_functor StatusLineCurveLess; typedef std::set StatusLine; typedef typename StatusLine::iterator StatusLineIter; typedef Point_less_functor PointLess; typedef std::set VerticalXPointSet; typedef typename VerticalXPointSet::iterator VerticalXPointSetIter; typedef std::list VerticalCurveList; typedef typename VerticalCurveList::iterator VerticalCurveListIter; /*! Constructor */ Sweep_line_event(const Point_2 &point, Traits *traits) : m_point(point), m_traits(traits), m_isInitialized(false), m_isInternalIntersectionPoint(false), m_containsOverlap(false) { m_verticalCurveXPoints = new VerticalXPointSet(PointLess(m_traits)); m_leftCurves = new SubcurveContainer(); m_rightCurves = new SubcurveContainer(); } /*! Destructor. Deletes the lists of curves, without deleting the curves themselves. */ virtual ~Sweep_line_event() { delete m_leftCurves; delete m_rightCurves; } /*! Adds a new curve to the event. The curve is added only to the list/s * in which it is defined (left or/and right). * If the curve is vertical, it is added to the list of vertical curves. * * Precondition: The event point has to be either the source or the * target of the curve. * @param curve a pointer to the curve. */ void add_curve(SubCurve *scurve) { const X_monotone_curve_2 &curve = scurve->get_curve(); const Point_2 &source = m_traits->curve_source(curve); const Point_2 &target = m_traits->curve_target(curve); if ( m_traits->curve_is_vertical(curve) ) { m_verticalCurves.push_back(scurve); } else { const Point_2 *rel = &(source); if ( m_traits->point_equal(m_point, source) ) rel = &(target); if ( m_traits->compare_x(m_point, *rel) == LARGER ) { add_curve_to_left(scurve, m_rightmostPointToLeft, true); } else { add_curve_to_right(scurve); } } } /*! Adds a new curve that is defined to the left of the event point. * The insertion is performed so that the curves remain sorted by their * Y values to the left of the event.
    * If the curve is already in the list of curves, it is removed and * re-inserted. This way the curves remain sorted. * * @param curve a pointer to the curve. * @pram ref a reference point to perform the compare by * @param isInitStage true when thie method is called at the * initialization stage (in which case some extra tests are performed). * * TODO - check to see in which cases the curve is re-inserted with * a different ordering. Probably in case of conics. */ void add_curve_to_left(SubCurve *curve, const Point_2 &ref, bool isInitStage=false) { if ( isInitStage ) { if ( !m_isInitialized ) { if ( curve->is_source_left_to_target()) { m_rightmostPointToLeft = curve->get_source(); } else{ m_rightmostPointToLeft = curve->get_target(); } m_isInitialized = true; } else { update_rightmost_point(curve); } } else if ( !curve->is_end_point(m_point) ) { m_isInternalIntersectionPoint = true; } // now insert the curve at the right place... if (m_leftCurves->empty()) { m_leftCurves->push_back(curve); return; } SubCurveIter iter = m_leftCurves->begin(); const X_monotone_curve_2 &cv = curve->get_curve(); // look for the curve, and if exists, erase it. while ( iter != m_leftCurves->end() ) { if ( (*iter)->getId() == curve->getId()) { m_leftCurves->erase(iter); break; } ++iter; } // insert the curve so that the list remains sorted... Comparison_result res = SMALLER; iter = m_leftCurves->begin(); while ( iter != m_leftCurves->end() ) { if ( m_traits->point_in_x_range((*iter)->get_curve(), ref)) { const Point_2 &ref_point = largest_point(curve->get_last_point(), (*iter)->get_last_point()); res = m_traits->curves_compare_y_at_x (cv, (*iter)->get_curve(), ref_point); if (res == EQUAL) { res = m_traits->curves_compare_y_at_x_right(cv, (*iter)->get_curve(), ref_point); } } else { const Point_2 &ref_point = largest_point(curve->get_last_point(), (*iter)->get_last_point()); res = m_traits->curves_compare_y_at_x (cv, (*iter)->get_curve(), ref_point); if (res == EQUAL) res = m_traits->curves_compare_y_at_x_right(cv, (*iter)->get_curve(), ref_point); } if ( res != LARGER ) break; ++iter; } while ( iter != m_leftCurves->end() && res == EQUAL && curve->getId() > (*iter)->getId() ) { m_containsOverlap = true; ++iter; if ( iter == m_leftCurves->end()) break; const Point_2 &ref_point = largest_point(curve->get_last_point(), (*iter)->get_last_point()); res = m_traits->curves_compare_y_at_x (cv, (*iter)->get_curve(), ref_point); if (res == EQUAL) res = m_traits->curves_compare_y_at_x_right(cv, (*iter)->get_curve(), ref_point); } // insert the curve. If the curve is already in the list, it is not added m_leftCurves->insert(iter, curve); } /*! Adds a new curve that is defined to the right of the event point. * The insertion is performed so that the curves remain sorted by their Y * values to the right of the event. * @param curve a pointer to the curve. */ void add_curve_to_right(SubCurve *curve) { if ( !curve->is_end_point(m_point) ) m_isInternalIntersectionPoint = true; if (m_rightCurves->empty()) { m_rightCurves->push_back(curve); return; } SubCurveIter iter = m_rightCurves->begin(); Comparison_result res; while (((res = m_traits->curves_compare_y_at_x (curve->get_curve(), (*iter)->get_curve(), m_point)) == LARGER) || (res == EQUAL && (res = m_traits->curves_compare_y_at_x_right(curve->get_curve(), (*iter)->get_curve(), m_point)) == LARGER)) { ++iter; if ( iter == m_rightCurves->end()) { m_rightCurves->insert(iter, curve); return; } } while ( res == EQUAL && curve->getId() > (*iter)->getId() ) { m_containsOverlap = true; ++iter; if ( iter == m_rightCurves->end() ) { m_rightCurves->insert(iter, curve); return; } res = m_traits->curves_compare_y_at_x (curve->get_curve(), (*iter)->get_curve(), m_point); if (res == EQUAL) res = m_traits->curves_compare_y_at_x_right(curve->get_curve(), (*iter)->get_curve(), m_point); } // insert the curve only if it is not already in... if ( (*iter)->getId() != curve->getId()) { m_rightCurves->insert(iter, curve); } } /*! Returns an iterator to the first curve to the left of the event */ SubCurveIter left_curves_begin() { return m_leftCurves->begin(); } /*! Returns an iterator to the one past the last curve to the left of the event */ SubCurveIter left_curves_end() { return m_leftCurves->end(); } /*! Returns an iterator to the first curve to the right of the event */ SubCurveIter right_curves_begin() { return m_rightCurves->begin(); } /*! Returns an iterator to the one past the last curve to the right of the event */ SubCurveIter right_curves_end() { return m_rightCurves->end(); } /*! Returns the number of intersecting curves that are defined to the right of the event point. */ int get_num_right_curves() { return m_rightCurves->size(); } /*! Returns the number of intersecting curves that are defined to the left of the event point. */ int get_num_left_curves() { return m_leftCurves->size(); } /*! Returns true if at least one intersecting curve is defined to the left of the point. */ bool has_left_curves() { return !m_leftCurves->empty(); } /*! Returns the actual point of the event */ const Point_2 &get_point() { return m_point; } /*! @return returns true if at least one of the curves passign through the event is vertical. */ bool does_contain_vertical_curve() const { return !m_verticalCurves.empty(); } /*!returns the list of vertical curves passing through the event point. @return a reference to the list of curves. */ VerticalCurveList &get_vertical_curves() { return m_verticalCurves; } /*! Insert a new intersection point on any of the vertical curves. * The list of points is sorted by their y values.
    * If the requireSort flag is true, the appripriate place in the list * is searched for. If not, the point is assumed to have the largest y * value, and is inserted at the end of the list.
    * If the pioint already exists, the point is not inserted again. * @param p a reference to the point * @param requireSort false if the point is to be added at the end * of the list. * */ void add_vertical_curve_x_point(const Point_2 &p, bool requireSort=false) { m_verticalCurveXPoints->insert(p); } /* if ( m_verticalCurveXPoints.empty() ) { m_verticalCurveXPoints.push_back(p); return; } if ( !requireSort ) { if (!m_traits->point_equal(p, m_verticalCurveXPoints.back())) { m_verticalCurveXPoints.push_back(p); } } else { VerticalXPointSetIter iter = m_verticalCurveXPoints.begin(); while ( iter != m_verticalCurveXPoints.end() ) { if ( m_traits->compare_xy(*iter, p) == SMALLER ) ++iter; else break; } if ( iter == m_verticalCurveXPoints.end() ) m_verticalCurveXPoints.push_back(p); else if (!m_traits->point_equal(p, *iter)) { m_verticalCurveXPoints.insert(iter, p); } } } */ /*! * Returns a referece to the list of intersection points on the * vertical curves passign through the event. If no vertical curves * pass through the event or no intersection curves exist, the list * will be empty. * @return a reference to the list of points. */ VerticalXPointSet &get_vertical_x_point_list() { return *m_verticalCurveXPoints; } /*! Mark the event as an intersection point at an interior of a curve. */ void mark_internal_intersection_point() { m_isInternalIntersectionPoint = true; } /*! @return returns true if the event is an intersection point at the interior of at least one of the curves passing throuogh the event point. */ bool is_internal_intersection_point() const { return m_isInternalIntersectionPoint; } /*! @return true if the any two curves in the event overlap, false otherwise. */ bool does_contain_overlap() const { return m_containsOverlap; } #ifndef NDEBUG void Print(); void PrintVerticalXPoints(); #endif protected: /*! Whenever a new curve is added to the event at the initialization * stage, the right most end point to the left of the event point is * updated. * Precondition: the event is either the source or destination of the curve. * @param curve a pointer to a new curve added to the event. */ void update_rightmost_point(SubCurve *curve) { if ( curve->is_source_left_to_target()) { if ( curve->is_target(m_point) ) if ( m_traits->compare_x(curve->get_source(), m_rightmostPointToLeft) == LARGER ) m_rightmostPointToLeft = curve->get_source(); } else { if ( curve->is_source(m_point) ) if ( m_traits->compare_x(curve->get_target(), m_rightmostPointToLeft) == LARGER ) m_rightmostPointToLeft = curve->get_target(); } } /*! The point of the event */ Point_2 m_point; /*! A pointer to a traits class */ Traits *m_traits; /*! A list of curves on the left side of the event, sorted by their y value to the left of the point */ SubcurveContainer *m_leftCurves; /*! A list of curves on the right side of the event, sorted by their y value to the right of the point */ SubcurveContainer *m_rightCurves; /*! The rightmost curve end point that is to the left of the event point. This point is used as a reference point when curves are compared to the left of the event point. */ Point_2 m_rightmostPointToLeft; /*! An indication whether this event has been initialized. The event is initialized after the first curve has been added to the left of the event. */ bool m_isInitialized; /*! a list of vertical curves going through this event */ VerticalCurveList m_verticalCurves; /*! a list of intersection points on the vertical curves */ VerticalXPointSet* m_verticalCurveXPoints; /*! a flag that inidcates whether the event is an "interior" intersection point, or just an end point of all curves passing through it. */ bool m_isInternalIntersectionPoint; /*! true if any two curves passing through the event overlap. */ bool m_containsOverlap; const Point_2 &largest_point(const Point_2 &p1, const Point_2 &p2) { if ( m_traits->compare_x(p1, p2) == LARGER ) return p1; return p2; } #ifndef NDEBUG public: int id; #endif }; #ifndef NDEBUG template void Sweep_line_event:: Print() { std::cout << "\tEvent id: " << id << "\n" ; std::cout << "\t" << m_point << "\n" ; std::cout << "\tLeft curves: \n" ; for ( SubCurveIter iter = m_leftCurves->begin() ; iter != m_leftCurves->end() ; ++iter ) { std::cout << "\t"; (*iter)->Print(); std::cout << "\n"; } std::cout << std::endl; std::cout << "\tRight curves: \n" ; for ( SubCurveIter iter1 = m_rightCurves->begin() ; iter1 != m_rightCurves->end() ; ++iter1 ) { std::cout << "\t"; (*iter1)->Print(); std::cout << "\n"; } std::cout <<"\tVertical curves: \n" ; for( VerticalCurveListIter iter2 = m_verticalCurves.begin() ; iter2 != m_verticalCurves.end() ; ++iter2) { std::cout<<"\t"; (*iter2)->Print(); std::cout<<"\n"; } std::cout << std::endl; } template void Sweep_line_event:: PrintVerticalXPoints() { std::cout << "Vertical intersection points for " << m_point << ":\n"; typename std::list::iterator iter = m_verticalCurveXPoints->begin(); while ( iter != m_verticalCurveXPoints->end() ) { std::cout << "\t" << *iter << "\n"; ++iter; } } #endif // NDEBUG CGAL_END_NAMESPACE #endif // CGAL_SWEEP_LINE_EVENT_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_subcurve.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_lin0000644000175000017500000002060511344301501031207 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_subcurve.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_SWEEP_LINE_SUBCURVE_H #define CGAL_SWEEP_LINE_SUBCURVE_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*! @class Sweep_line_subcurve * * This is a wrapper class to Curve_2 in the traits class, that contains * data that is used when applying the sweep algorithm on a set of curves. * * The information contained in this class is: * - the curve itself * - two points which are the source and target of the curve. We keep * the points in order to avoid many calls to the source() and * target() methods of the traits class * - an indication for the direction of the curve (source point * is left or right to the target point). * - a reference point that is used when comparing the y values of * any two curves. Since the curves are inserted in to a balanced * tree, and at any given time they are sorted on the status line, * and since their order may change, depending on the position of * the status line, we need to be able to compare the curves * relative to a point that will produce a correct answer. * - a reference to the last event point on the curve that was already * handled and also the curve that is the portion of the original * curve that is to the right of the last event point mentioned. * This is stored to avoid unneccesary splits of the curve. * */ template class Sweep_line_subcurve { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef Sweep_line_subcurve Self; typedef Status_line_curve_less_functor StatusLineCurveLess; typedef std::set StatusLine; typedef typename StatusLine::iterator StatusLineIter; typedef Sweep_line_event Event; Sweep_line_subcurve(int id, X_monotone_curve_2 &curve, Point_2 *reference, SweepLineTraits_2 *traits); virtual ~Sweep_line_subcurve() {} int getId() const { return m_id; } /*! @return a reference to the curve */ const X_monotone_curve_2 &get_curve() const { return m_curve; } /*! @return the pointer to the reference point */ const Point_2 *get_reference_point() const { return m_referencePoint; } /*! @return a reference to the rightmost intersection point */ const Point_2 &get_last_point() const { return m_lastPoint; } /*! Updates the rightmost intersection point. @param point a reference to the point */ void set_last_point(const Point_2 &point) { m_lastPoint = point; } /*! @return a reference to the last intersecing curve so far */ const X_monotone_curve_2 &get_last_curve() const { return m_lastCurve; } /*! updates the last intersecting curve so far. @param cv a reference to the curve */ void set_last_curve(const X_monotone_curve_2 &cv) { m_lastCurve = cv; } const X_monotone_curve_2 &get_last_subcurve() const { return m_lastSubCurve; } void set_last_subcurve(const X_monotone_curve_2 &cv) { m_lastSubCurve = cv; } bool is_source_left_to_target() const { return m_isRightSide; } bool is_source(const Point_2 &p) { return m_traits->point_equal(p, m_source); } bool is_target(const Point_2 &p) { return m_traits->point_equal(p, m_target); } /*! returns true if the specified point is the source or the target of the curve. Returns false otherwise. */ bool is_end_point(const Point_2 &p) { return is_target(p) || is_source(p); } /*! returns true if the last point is an end point and the specified point is an end point. Otherwise returns false; */ bool is_unsplit_curve(const Point_2 &p) { if ( is_end_point(p) && is_end_point(m_lastPoint) ) return true; return false; } const Point_2 &get_source() const { return m_source; } const Point_2 &get_target() const { return m_target; } bool is_left_end(const Point_2 &p) { if ( is_source_left_to_target() && is_source(p) ) return true; if ( !is_source_left_to_target() && is_target(p) ) return true; return false; } bool is_right_end(const Point_2 &p) { if ( is_source_left_to_target() && is_target(p) ) return true; if ( !is_source_left_to_target() && is_source(p) ) return true; return false; } bool is_bottom_end(const Point_2 &p) { CGAL_assertion(m_traits->curve_is_vertical(m_curve)==true); return is_left_end(p); } bool is_top_end(const Point_2 &p) { CGAL_assertion(m_traits->curve_is_vertical(m_curve)==true); return is_right_end(p); } const Point_2 &get_right_end() const { if ( is_source_left_to_target() ) return m_target; return m_source; } const Point_2 &get_left_end() const { if ( is_source_left_to_target() ) return m_source; return m_target; } const Point_2 &get_top_end() const { CGAL_assertion(m_traits->curve_is_vertical(m_curve)==true); return get_right_end(); } const Point_2 &get_bottom_end() const { CGAL_assertion(m_traits->curve_is_vertical(m_curve)==true); return get_left_end(); } // returns true if the point is in the range of the curve and is not // one of its ends bool is_point_in_range(const Point_2 &p) { if (! m_traits->point_in_x_range(m_curve, p) || m_traits->curve_compare_y_at_x(p, m_curve) != EQUAL) return false; if ( is_end_point(p) ) return false; return true; } void set_hint(StatusLineIter hint) { m_hint = hint; } StatusLineIter get_hint() const { return m_hint; } #ifndef NDEBUG void Print() const; #endif private: int m_id; /*! a pointer to the traits object */ Traits *m_traits; /*! thecurve */ X_monotone_curve_2 m_curve; /* a pointer to a point that is used as a reference point when two curves are compared. This is used when inserting and erasing curves from the status line. */ Point_2 *m_referencePoint; /*! the rightmost point handled so far on the curve. It is initialized to the left end of the curve and is updated with every intersection point on the curve. */ Point_2 m_lastPoint; /*! the portion of the curve to the right of the last event point on the curve */ X_monotone_curve_2 m_lastCurve; /*! the last subcurve that was reported */ X_monotone_curve_2 m_lastSubCurve; /*! true if the source of the curve is to the left of the target. */ bool m_isRightSide; /*! the source of the curve */ Point_2 m_source; /*! the target of the curve */ Point_2 m_target; /*! */ StatusLineIter m_hint; }; template inline Sweep_line_subcurve:: Sweep_line_subcurve(int id, X_monotone_curve_2 &curve, Point_2 *reference, SweepLineTraits_2 *traits) : m_id(id), m_traits(traits) { m_curve = curve; m_referencePoint = reference; m_source = traits->curve_source(curve); m_target = traits->curve_target(curve); Comparison_result res = traits->compare_xy(m_source, m_target); if ( res == LARGER ) { m_lastPoint = m_target; m_isRightSide = false; } else if ( res == SMALLER ) { m_lastPoint = m_source; m_isRightSide = true; } m_lastCurve = curve; } #ifndef NDEBUG template void Sweep_line_subcurve:: Print() const { std::cout << "Curve " << m_id << " (" << m_curve << ") " << "last P = (" << m_lastPoint << ")" << std::endl; } #endif CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_sweep_line_event.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_swee0000644000175000017500000001704611344301501031245 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_sweep_line_event.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_PMWX_SWEEP_LINE_EVENT_H #define CGAL_PMWX_SWEEP_LINE_EVENT_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*! @class Pmwx_sweep_line_event * * Stores the data associated with an event. * In addition to the information stored in Sweep_line_event, when * constructing a * planar map, additional information is kept, in * order to speed insertion of curves into the planar map. * * The additional infomation contains the following: * - among the left curves of the event, we keep the highest halfedge that * was inserted into the planar map at any given time. * - an array of booleans that indicates for each curve to the right of * the event, whether it is already in the planar map or not. This is * used to speed insertions of curves into the planar map. * - an array of events that occur on the vertical curves that go through * this event. This is used instead of the array of points that is kept * in the base class. * * Inherits from Sweep_line_event. * \sa Sweep_line_event */ template class Pmwx_sweep_line_event : public Sweep_line_event { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Point_2 Point_2; typedef Sweep_line_event Base; typedef Pmwx_sweep_line_event Self; typedef CurveWrap SubCurve; typedef std::list SubcurveContainer; typedef typename SubcurveContainer::iterator SubCurveIter; typedef typename CurveWrap::PmwxInsertInfo PmwxInsertInfo; typedef Event_less_functor EventLess; typedef std::set VerticalXEventSet; typedef typename VerticalXEventSet::iterator VerticalXEventSetIter; // repeated typedefs of Base to avoid warnings typedef typename Base::VerticalCurveList VerticalCurveList; typedef typename Base::VerticalCurveListIter VerticalCurveListIter; typedef typename PmwxInsertInfo::Halfedge_handle Halfedge_handle; /*! Constructor */ Pmwx_sweep_line_event(const Point_2 &point, Traits *traits) : Base(point, traits) { m_verticalCurveXEvents = new VerticalXEventSet(EventLess(this->m_traits)); } /*! destructor */ ~Pmwx_sweep_line_event() { delete m_verticalCurveXEvents; } PmwxInsertInfo *get_insert_info() { return &m_insertInfo; } /*! Insert a new intersection point on any of the vertical curves. * The list of points is sorted by their y values. * If the requireSort flag is true, the appripriate place in the list * is searched for. If not, the point is assumed to have the largest y * value, and is inserted at the end of the list. * If the point already exists, the point is not inserted again. * * @param p a reference to the point * @param requireSort false if the point is to be added at the end * of the list. * * */ void add_vertical_curve_x_event(Self *e, bool requireSort=false) { m_verticalCurveXEvents->insert(e); } /* if ( m_verticalCurveXEvents.empty() ) { m_verticalCurveXEvents.push_back(e); return; } if ( !requireSort ) { if ( m_verticalCurveXEvents.back() != e ) { m_verticalCurveXEvents.push_back(e); } } else { VerticalXEventListIter iter = m_verticalCurveXEvents.begin(); while ( iter != m_verticalCurveXEvents.end() ) { if ( m_traits->compare_xy((*iter)->get_point(), e->get_point()) == SMALLER ) { ++iter; } else break; } if ( iter == m_verticalCurveXEvents.end() ) m_verticalCurveXEvents.push_back(e); else if (m_verticalCurveXEvents.back() != e) { m_verticalCurveXEvents.insert(iter, e); } } }*/ VerticalXEventSet &get_vertical_x_event_set() { return *m_verticalCurveXEvents; } /*! Initialize the array that indicates wheter a curve to the right of the * event was already inserted into the planar map. */ void init_right_curves() { m_isCurveInPm.resize(this->get_num_right_curves()); for ( int i = 0 ; i < this->get_num_right_curves() ; i++ ) m_isCurveInPm[i] = false; } /*! Caculates the number of halfedges in the planar map between the highest * halfedge to the left of the event (which is stored in the insertInfo * member) and the position of the the specified curve around the vertex * in the planar map. * * @param curve a pointer to a curve that is going to be inserted * @return the number of halfedges to skip before inserting the curve */ int get_halfedge_jump_count(CurveWrap *curve) { int i = 0; int counter = 0; int skip = 0; for (unsigned int j = 0 ; j < m_isCurveInPm.size() ; j++ ) { if ( m_isCurveInPm[j] == true ) { skip++; } } skip--; // now 'skip' holds the amount of the right curves of the event // that are already inserted to the planar map - 1 (minus 1) SubCurveIter iter = this->m_rightCurves->end(); --iter; // a boolean indictes if there is a vertical that was inserted to the map with endpoint as the // event point. bool exist_vertical = m_insertInfo.get_vertical_below_event_flag() || m_insertInfo.get_vertical_above_event_flag(); for ( ; iter != this->m_rightCurves->begin() ; --iter ) { if ( curve->getId() == (*iter)->getId() ) { m_isCurveInPm[counter] = true; if (( i == 0 ) && ( this->get_num_left_curves() == 0 ) && !exist_vertical) { return skip; } if ( this->get_num_left_curves() == 0 && !exist_vertical ) { return i-1; } return i; } if ( m_isCurveInPm[counter] == true ) i++; counter++; } CGAL_assertion(curve->getId() == (*iter)->getId()); m_isCurveInPm[counter] = true; if ( this->get_num_left_curves() == 0 && !exist_vertical ) i--; return i; } /*! Returns true if the curve is the highest one among the right curves * that were already inserted into the planar map. */ bool is_curve_largest(CurveWrap *curve) { int counter = 0; SubCurveIter iter = this->m_rightCurves->end(); --iter; while ( curve->getId() != (*iter)->getId() ) { if ( m_isCurveInPm[counter] == true ) return false; counter++; --iter; } return true; } private: PmwxInsertInfo m_insertInfo; std::vector m_isCurveInPm; VerticalXEventSet* m_verticalCurveXEvents; }; CGAL_END_NAMESPACE #endif // CGAL_PMWX_SWEEP_LINE_EVENT_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_aggregate_insert_old.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_aggr0000644000175000017500000004145411344301501031222 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_aggregate_insert_old.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_PMWX_AGGREGATE_INSERT_OLD_H #define CGAL_PMWX_AGGREGATE_INSERT_OLD_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE struct Sweep_curves_to_planar_map_utils { // X_curve_plus_id: // holds a curve and its id number. // The addition of id number to a curve was made due to overlapping // (in which some binary predicates return EQUAL, // while we are interseted in sharp order relation. template class X_curve_plus_id : public SweepLineTraits_2::X_curve { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve curve; typedef typename Traits::Point Point; X_curve_plus_id() : curve() {}; X_curve_plus_id(const curve &cv, unsigned int i) : curve(cv) , _id(i) {} X_curve_plus_id(const X_curve_plus_id &cv) : curve(cv) , _id(cv.id()) {} ~X_curve_plus_id(){} X_curve_plus_id& operator=(const X_curve_plus_id &cv) { curve::operator=(cv); _id = cv.id(); return *this; } bool operator==(const X_curve_plus_id &cv) const { Traits traits; return (_id == cv.id() && traits.curve_equal(*this, cv)); } void set_id(unsigned int i) { _id = i; } unsigned int id() const { return _id; } protected: unsigned int _id; }; }; template class Pmwx_aggregate_insert_old : public Sweep_curves_base_2< CurveInputIterator, SweepLineTraits_2, Point_plus_handle, Sweep_curves_to_planar_map_utils:: X_curve_plus_id > { public: typedef CurveInputIterator Curve_iterator; typedef PM_ PM; typedef Change_notification_ Change_notification; typedef typename PM::Vertex_handle Vertex_handle; typedef typename PM::Halfedge_handle Halfedge_handle; typedef typename PM::Vertex_const_handle Vertex_const_handle; typedef typename PM::Halfedge_const_handle Halfedge_const_handle; typedef typename PM::Vertex_iterator Vertex_iterator; typedef typename PM::Vertex_const_iterator Vertex_const_iterator; typedef typename PM::Halfedge_iterator Halfedge_iterator; typedef typename PM::Halfedge_const_iterator Halfedge_const_iterator; typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; typedef Point_plus_handle Point_plus; typedef Sweep_curves_to_planar_map_utils::X_curve_plus_id X_curve_plus; typedef Sweep_curves_base_2 Base; typedef typename Base::Curve_node Curve_node; typedef typename Base::Intersection_point_node Intersection_point_node; typedef typename Base::Points_iterator Points_iterator; typedef typename Base::Points_const_iterator Points_const_iterator; typedef typename Base::Curve_node_iterator Curve_node_iterator; typedef typename Base::Curve_node_const_iterator Curve_node_const_iterator; typedef typename Base::X_curve_list X_curve_list; typedef typename Base::X_curve_list_iterator X_curve_list_iterator; typedef typename Base::Vertices_points_plus Vertices_points_plus; typedef typename Base::Event_queue Event_queue; typedef typename Base::Status_line Status_line; typedef typename Vertices_points_plus::value_type Vertices_points_plus_value_type; typedef typename Event_queue::value_type Event_queue_value_type; typedef typename Status_line::value_type Status_line_value_type; typedef typename Vertices_points_plus::iterator Vertices_points_plus_iterator; typedef typename Event_queue::iterator Event_queue_iterator; typedef typename Status_line::iterator Status_line_iterator; typedef typename std::list::iterator list_Curve_node_iterator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::traits; using Base::is_right; #endif Pmwx_aggregate_insert_old() : Base() {} Pmwx_aggregate_insert_old(Traits *traits_) : Base(traits_) {} ~Pmwx_aggregate_insert_old() {} void insert_curves(Curve_iterator curves_begin, Curve_iterator curves_end, PM &result, Change_notification* change_notification) { Curve_iterator cv_iter; X_curve_list_iterator xcv_iter; typename Base::Less_xy event_queue_pred(traits); Event_queue event_queue(event_queue_pred); typename Base::Less_yx status_pred(traits); Status_line status(status_pred); // building a container of all curves in the input planar // map and the curves specified (which we break into x_monotone first) X_curve_list x_monotone_curves; for (Halfedge_iterator h_iter = result.halfedges_begin(); h_iter != result.halfedges_end(); ++h_iter, ++h_iter) { x_monotone_curves.push_back(h_iter->curve()); } result.clear(); // splitting all curves to x-monotone curves. for (cv_iter = curves_begin; cv_iter != curves_end; ++cv_iter){ X_curve_list x_monotone_subcurves; traits->curve_make_x_monotone(*cv_iter, std::back_inserter(x_monotone_subcurves)); for(X_curve_list_iterator iter = x_monotone_subcurves.begin(); iter != x_monotone_subcurves.end(); ++iter) { x_monotone_curves.push_back(*iter); } } // creating a container of all (unique) vertices typename Base::Less_xy pred(traits); Vertices_points_plus input_vertices(pred); for (xcv_iter = x_monotone_curves.begin(); xcv_iter != x_monotone_curves.end(); ++xcv_iter){ if (input_vertices.find(traits->curve_source(*xcv_iter)) == input_vertices.end()) input_vertices.insert( Vertices_points_plus_value_type (traits->curve_source(*xcv_iter), Point_plus(traits->curve_source(*xcv_iter))) ); if (input_vertices.find(traits->curve_target(*xcv_iter)) == input_vertices.end()) input_vertices.insert( Vertices_points_plus_value_type (traits->curve_target(*xcv_iter), Point_plus(traits->curve_target(*xcv_iter))) ); } // initializing the event queue with all edge points unsigned int id = 0; for ( xcv_iter = x_monotone_curves.begin(); xcv_iter != x_monotone_curves.end(); ++xcv_iter, ++id) { X_curve cv(*xcv_iter); if (is_right(traits->curve_source(*xcv_iter), traits->curve_target(*xcv_iter)) ) cv = traits->curve_opposite(*xcv_iter); Vertices_points_plus_iterator curr_point_plus = input_vertices.find( traits->curve_source(cv) ); // defining one cv_node for both source and target event points. Curve_node cv_node = Curve_node(X_curve_plus(cv, id), curr_point_plus->second, traits); // creating the "event" for the queue Intersection_point_node source_point_node = Intersection_point_node(cv_node, curr_point_plus->second, traits ); // if the "event" does not exist, we add it. Otherwise, we merge it // with the existing one. Event_queue_iterator edge_point = event_queue.find( traits->curve_source(cv) ); if (edge_point == event_queue.end() || edge_point->second.get_point() != source_point_node.get_point()) event_queue.insert(Event_queue_value_type (traits->curve_source(cv), source_point_node)); else edge_point->second.merge(source_point_node); // the same to the "target" point edge_point = event_queue.find( traits->curve_target(cv) ); curr_point_plus = input_vertices.find( traits->curve_target(cv) ); Intersection_point_node target_point_node = Intersection_point_node(cv_node, curr_point_plus->second, traits ); if (edge_point == event_queue.end() || edge_point->second.get_point() != target_point_node.get_point()) event_queue.insert(Event_queue_value_type(traits->curve_target(cv), target_point_node)); else edge_point->second.merge(target_point_node); } // end of initialization stage ... bool event_terminated = true; while ( !(event_queue.empty()) ) { Event_queue_iterator event = event_queue.begin(); const Point& event_point = event->first; Intersection_point_node& point_node = event->second; event_terminated = true; event_terminated = handle_one_event (event_queue, status, event_point, point_node); handle_overlapping_curves(event_queue,status,event_point,point_node); if (!event_terminated) { handle_one_event (event_queue, status, event_point, point_node); } Curve_node_iterator cvn_iter; for (cvn_iter = point_node.curves_begin(); cvn_iter != point_node.curves_end(); ++cvn_iter){ if (event_point != traits->curve_source(cvn_iter->get_curve()) && event_point == cvn_iter->get_rightmost_point().point()) cvn_iter->erase_rightmost_point(); } // now, updating the planar map (or arrangement) according the curves // enemating from the currnet event point. update_subdivision(point_node, change_notification, result); // updating all the new intersection nodes of the curves // participating within the event. for (cvn_iter = point_node.curves_begin(); cvn_iter != point_node.curves_end(); ++cvn_iter){ if (event_point != cvn_iter->get_rightmost_point().point()) cvn_iter->push_event_point(point_node.get_point()); } event_queue.erase(event); } CGAL_expensive_postcondition_code(is_valid(status)); } private: void update_subdivision(Intersection_point_node& point_node, Change_notification *pm_change_notf, PM &pm) { X_curve prev_sub_cv; for (Curve_node_iterator cv_iter = point_node.curves_begin(); cv_iter != point_node.curves_end(); ++cv_iter) { bool overlap=false; if (is_left(cv_iter->get_rightmost_point().point(), point_node.get_point().point())) { // means we have a new sub curve to insert. Halfedge_handle h; // first splitting the curve in the points // cv_iter->get_rightmost_point().point() // and point_node.get_point().point(). X_curve cv = cv_iter->get_curve(); X_curve sub_cv = cv_iter->get_curve(), right_cv = cv; if (traits->curve_source(cv) != cv_iter->get_rightmost_point().point() && traits->curve_target(cv) != cv_iter->get_rightmost_point().point() ) { traits->curve_split(cv, sub_cv, right_cv, cv_iter->get_rightmost_point().point()); cv = right_cv; } if (traits->curve_source(cv) != point_node.get_point().point() && traits->curve_target(cv) != point_node.get_point().point()) traits->curve_split(cv, sub_cv, right_cv, point_node.get_point().point()); else sub_cv = right_cv; if (cv_iter != point_node.curves_begin()){ if (traits->curves_overlap(sub_cv, prev_sub_cv)){ overlap=true; } } if (overlap){ // special case of overlapping: We do not insert the // overlapped curve. // However, we have to call add_edge of // the notifier in order to update attributes of the current // halfedge. if (pm_change_notf){ h = find_halfedge(sub_cv, pm); pm_change_notf->add_edge(sub_cv, h, true, true); } } else { prev_sub_cv = sub_cv; if (cv_iter->get_rightmost_point().vertex() != Vertex_handle(NULL)) { if (point_node.get_point().vertex() != Vertex_handle(NULL)) { h = pm.insert_at_vertices( sub_cv, cv_iter->get_rightmost_point().vertex(), point_node.get_point().vertex(), pm_change_notf); } else { h = pm.non_intersecting_insert_from_vertex( sub_cv, cv_iter->get_rightmost_point().vertex(), pm_change_notf); } } else if (point_node.get_point().vertex() != Vertex_handle(NULL)) { h = pm.non_intersecting_insert_from_vertex(sub_cv, point_node.get_point().vertex(), pm_change_notf); } else { h = pm.insert_in_face_interior(sub_cv, pm.unbounded_face(), pm_change_notf); // the point is that if the curve has no source to start // the insertion from, it has to be inserted to the // unbounded face, because all the curves to the right of // it have not inserted yet, and in that stage of the // sweep line, the curve is on the unbounded face - later // on it will be updated automatically by the Planar map // (Arrangement) insert functions. } } // now update the vertex handle of each point. if (!overlap || pm_change_notf) { if (h->source()->point() == cv_iter->get_rightmost_point().point()) cv_iter->get_rightmost_point().set_vertex(h->source()); else if (h->target()->point() == cv_iter->get_rightmost_point().point()) cv_iter->get_rightmost_point().set_vertex(h->target()); } if (!overlap || pm_change_notf) { if (h->source()->point() == point_node.get_point().point()) point_node.get_point().set_vertex(h->source()); else if (h->target()->point() == point_node.get_point().point()) point_node.get_point().set_vertex(h->target()); } // else - no new sub curve is inserted to the subdivision. } } } Halfedge_handle find_halfedge(const X_curve& cv, PM& pm) { typename PM::Locate_type lt; Halfedge_handle h = pm.locate(traits->curve_source(cv),lt); if (traits->curve_equal(h->curve(),cv) || traits->curve_equal(h->curve(),traits->curve_opposite(cv)) ) return h; Vertex_handle v; if (h->source()->point() == traits->curve_source(cv)) v = h->source(); else v = h->target(); typename PM::Halfedge_around_vertex_circulator circ = v->incident_halfedges(); do { if (traits->curve_equal(circ->curve(),cv) || traits->curve_equal(circ->curve(),traits->curve_opposite(cv))) return Halfedge_handle(circ); } while (++circ != v->incident_halfedges()); CGAL_assertion(0); return Halfedge_handle(0); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_sweep_line_curve.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_swee0000644000175000017500000000615411344301501031243 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_sweep_line_curve.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_PMWX_SWEEP_LINE_CURVE_H #define CGAL_PMWX_SWEEP_LINE_CURVE_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*! @class Pmwx_sweep_line_curve * * a class that holds information about a curve that is added to * the planar map. * In addition to the information that is contained in Sweep_line_subcurve, * when a planar map is constructed, a reference to an event that was * handled last on the curve is stored. This information is used to retrieve * hints when a subcurve of this curve is inserted into the planar map. * * Inherits from Sweep_line_subcurve * \sa Sweep_line_subcurve */ template class Pmwx_sweep_line_curve : public Sweep_line_subcurve { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef Sweep_line_subcurve Base; typedef Pmwx_sweep_line_curve Self; typedef Status_line_curve_less_functor StatusLineCurveLess; typedef std::set StatusLine; typedef typename StatusLine::iterator StatusLineIter; typedef Pmwx_insert_info PmwxInsertInfo; typedef Pmwx_sweep_line_event Event; Pmwx_sweep_line_curve(int id, X_monotone_curve_2 &curve, Point_2 *reference, SweepLineTraits_2 *traits) : Base(id, curve, reference, traits) , m_insertInfo(0), m_lastEvent(0) { } void set_hint(StatusLineIter hint) { m_hint1 = hint; } StatusLineIter get_hint() const { return m_hint1; } void set_insert_info(PmwxInsertInfo *insertInfo) { m_insertInfo = insertInfo; } PmwxInsertInfo *get_insert_info() const { return m_insertInfo; } void set_last_event(Event *e) { m_lastEvent = e; } Event *get_last_event() const { return m_lastEvent; } private: /* the insert information of this curve */ PmwxInsertInfo *m_insertInfo; /*! the last event that was handled on the curve */ Event *m_lastEvent; /*! */ StatusLineIter m_hint1; }; CGAL_END_NAMESPACE #endif // CGAL_PMWX_SWEEP_LINE_CURVE_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_2_impl.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_lin0000644000175000017500000022005411344301501031207 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_2_impl.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_SWEEP_LINE_2_IMPL_H #define CGAL_SWEEP_LINE_2_IMPL_H #include #include #include #include #ifndef VERBOSE #define SL_DEBUG(a) #define PRINT_INSERT(a) #define PRINT_ERASE(a) #define PRINT_NEW_EVENT(p, e) #define DBG(a) #define STORE_RESULT(a) #else #define SL_DEBUG(a) {a} #define PRINT_INSERT(a) { std::cout << "+++ inserting "; \ (a)->Print(); \ std::cout << " currentPos = " << m_currentPos \ << "\n"; \ } #define PRINT_ERASE(a) { std::cout << "--- erasing " ; \ (a)->Print(); } #define PRINT_NEW_EVENT(p, e) \ { std::cout << "%%% a new event was created at " << (p) << std::endl; \ (e)->Print(); } #define DBG(a) { std::cout << a << std::endl; } #define STORE_RESULT(a) {a} #endif #include CGAL_BEGIN_NAMESPACE /*! Sweep_line_2_impl is a class that implements the sweep line algorithm based on the algorithm of Bentley and Ottmann. It extends the algorithm to support not only segments but polylines and general curves as well. The curves are defined by the traits class that is one of the template arguments. The algorithm is also extended to support the following degenerate cases: - non x-monotone curves - vertical segments - multiple (more then two) segments intersecting at one point - curves beginning and ending on other curves. - overlapping curves There are two main functionalities supported by this algorithm: 1. calculate the non intersecting curves that are a product of intersecting a set of input curves 2. calculate all the intersection points between the curves specified An extension of this algorithm is used to produce a planar map containing the input curves efficiently. \sa Pmwx_aggregate_insert. General flow: After the initialization stage, the events are handled from left to right. For each event First pass - handles special cases in which curves start or end at the interior of another curve Handle vertical curve (bottom) - special caring if the event is a bottom end of a vertical curve Handle vertical overlapping curves - special caring if there are overlapping vertical curves passing through the event. Handle left curves - iterate over the curves that intersect at the event point and defined to the left of the event. This is mostly where the output (sub curves or intersection points) is produced. Handle vertical curve (top) - special caring if the event id the upper end of a vertical curve. In case of vertical curves, this is where the output is produced. Handle right curves - iterate over the curves that intersect the event point and defined to the right of the event point. This is where new intersection points are calculated. End Convensions through out the code: In order to make the code as readable as possible, some convensions were made in regards to variable naming: xp - is the intersection point between two curves slIter - an iterator to the status line, always points to a curve. out - always refer to the output iterator */ template class Sweep_line_2_impl { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef SweepEvent Event; typedef Point_less_functor PointLess; typedef std::map EventQueue; typedef typename EventQueue::iterator EventQueueIter; typedef typename EventQueue::value_type EventQueueValueType; typedef std::vector EventPtrContainer; typedef typename EventPtrContainer::iterator EventPtrContainerIter; typedef typename Event::SubCurveIter EventCurveIter; typedef CurveWrap Subcurve; typedef std::list SubCurveList; typedef typename SubCurveList::iterator SubCurveListIter; typedef Status_line_curve_less_functor StatusLineCurveLess; typedef typename StatusLineCurveLess::Compare_param CompareParams; typedef std::set StatusLine; typedef typename StatusLine::iterator StatusLineIter; typedef typename Event::VerticalCurveList VerticalCurveList; typedef typename Event::VerticalCurveListIter VerticalCurveListIter; typedef typename Event::VerticalXPointSet VerticalXPointList; typedef typename Event::VerticalXPointSetIter VerticalXPointListIter; typedef std::list EventList; typedef typename EventList::iterator EventListIter; typedef std::list CurveList; typedef typename CurveList::iterator CurveListIter; class SweepLineGetSubCurves {}; class SweepLineGetPoints {}; class SweepLineGetInterCurveList {}; class SweepLinePlanarmap {}; Sweep_line_2_impl() : m_traits(new Traits()), m_traitsOwner(true), m_includeEndPoints(true), m_found_intersection(false), is_first_point(true) { } Sweep_line_2_impl(Traits *t) : m_traits(t), m_traitsOwner(false), m_includeEndPoints(true), m_found_intersection(false), is_first_point(true) { } virtual ~Sweep_line_2_impl(); /*! * Given a container of curves, this function returns a list of curves * that are created by intersecting the input curves. * \param curves_begin the input iterator that points to the first curve * in the range. * \param curves_end the input past-the-end iterator of the range. * \param subcurves an iterator to the first curve in the range * of curves created by intersecting the input curves. * \param overlapping indicates whether overlapping curves should be * reported once or multiple times. If false, the * overlapping curves are reported once only. */ template void get_subcurves(CurveInputIterator begin, CurveInputIterator end, OutpoutIterator subcurves, bool overlapping = false) { init(begin, end); SL_DEBUG( PrintSubCurves(); PrintEventQueue(); ) m_overlapping = overlapping; sweep(subcurves, SweepLineGetSubCurves()); } /*! * Given a range of curves, this function returns a list of points * that are the intersection points of the curves. * The intersections are calculated using the sweep algorithm. * \param curves_begin the input iterator that points to the first curve * in the range. * \param curves_end the input past-the-end iterator of the range. * \param subcurves an iterator to the first curve in the range * of curves created by intersecting the input curves. * \param endpoints if true, the end points of the curves are reported * as intersection points. Defaults to true. * \param overlapping indicates whether there are overlapping curves * in the input range. Defaults to false. */ template void get_intersection_points(CurveInputIterator begin, CurveInputIterator end, OutpoutIterator points, bool includeEndPoints = true) { init(begin, end); SL_DEBUG( PrintSubCurves(); PrintEventQueue(); ) m_includeEndPoints = includeEndPoints; m_found_intersection = false; sweep(points, SweepLineGetPoints()); } /*! * Given a range of curves, this function returns an iterator * to the beginning of a range that contains the list of curves * for each intersection point between any two curves in the * specified range. * The intersections are calculated using the sweep algorithm. * \param begin the input iterator that points to the first curve * in the range. * \param end the input past-the-end iterator of the range. * \param intersecting_curves an iterator to the output * \param endpoints if true, the end points of the curves are reported * as intersection points. Defaults to true. */ template void get_intersecting_curves(CurveInputIterator begin, CurveInputIterator end, OutputIterator intersecting_curves, bool endpoints = true) { // TODO - implement... SweepLineGetInterCurveList tag; (void) tag; } bool do_curves_intersect(CurveInputIterator begin, CurveInputIterator end) { init(begin, end); SL_DEBUG( PrintSubCurves(); PrintEventQueue(); ) m_includeEndPoints = false; std::vector dummy; m_stop_at_first_int = true; m_found_intersection = false; sweep(std::back_inserter(dummy), SweepLineGetPoints(), true); return m_found_intersection; } protected: void init(CurveInputIterator begin, CurveInputIterator end); void init_curve(X_monotone_curve_2 &curve); /*! The main loop to calculate intersections among the curves * Looping over the events in the queue, for each event we first * handle the curves that are tothe left of the event point (i.e., * curves that we are done with), and then we look at the curves * to the right of the point, which means we attept to find intersections * between them and their neighbours on the sweep line. */ template void sweep(OutpoutIterator out, Op tag, bool stop_at_first_int=false) { EventQueueIter eventIter = m_queue->begin(); m_prevPos = *eventIter->first; m_sweepLinePos = *(eventIter->first); while ( eventIter != m_queue->end() ) { const Point_2 *p = (eventIter->first); if ( m_traits->compare_x(m_sweepLinePos, *p) == SMALLER ) { m_prevPos = m_sweepLinePos; m_verticals.clear(); m_verticalSubCurves.clear(); } m_sweepLinePos = *p; m_currentPos = *p; p = (eventIter->first); m_currentEvent = eventIter->second; SL_DEBUG(std::cout << "------------- " << *p << " --------------" << std::endl; PrintStatusLine(); m_currentEvent->Print(); ) if ( m_traits->compare_x(*(eventIter->first), m_sweepLinePos) != EQUAL) { SL_DEBUG(std::cout << "====================== clearing miniq " << eventIter->first << " " << m_prevPos << "\n";) m_miniq.clear(); } m_miniq.push_back(m_currentEvent); handle_vertical_curve_bottom(tag); handle_vertical_overlap_curves(); handle_left_curves(out, tag); m_queue->erase(eventIter); handle_vertical_curve_top(out, tag); handle_right_curves(out, tag); eventIter = m_queue->begin(); } if ( stop_at_first_int && m_found_intersection ) return; } void handle_vertical_curve_bottom(SweepLineGetSubCurves &tag); void handle_vertical_curve_bottom(SweepLineGetPoints &tag); void handle_vertical_overlap_curves(); /*! For each left-curve, if it is the "last" subcurve, i.e., the * event point is the right-edge of the original curve, the * last sub curve is created and added to the result. Otherwise * the curve is added as is to the result. */ template void handle_left_curves(OutpoutIterator out, SweepLineGetSubCurves &tag) { SL_DEBUG(std::cout << "Handling left curve" << std::endl;) SL_DEBUG(m_currentEvent->Print();) EventCurveIter leftCurveIter = m_currentEvent->left_curves_begin(); m_currentPos = m_prevPos; const Point_2 &eventPoint = m_currentEvent->get_point(); m_use_hint_for_erase = false; while ( leftCurveIter != m_currentEvent->left_curves_end() ) // ** fix here { Subcurve *leftCurve = *leftCurveIter; const X_monotone_curve_2 &cv = leftCurve->get_curve(); const Point_2 &lastPoint = leftCurve->get_last_point(); if ( leftCurve->is_source(eventPoint)) { if ( !leftCurve->is_target(lastPoint) ) { X_monotone_curve_2 a,b; m_traits->curve_split(cv, a, b, lastPoint); add_curve_to_output(a, leftCurve, out); } else { add_curve_to_output(cv, leftCurve, out); } } else if ( leftCurve->is_target(eventPoint)) { if ( !leftCurve->is_source(lastPoint)) { X_monotone_curve_2 a,b; m_traits->curve_split(cv, a, b, lastPoint); add_curve_to_output(b, leftCurve, out); } else { add_curve_to_output(cv, leftCurve, out); } } else { X_monotone_curve_2 a,b; if ( leftCurve->is_source(lastPoint)) { m_traits->curve_split(cv, a, b, eventPoint); add_curve_to_output(a, leftCurve, out); } else if ( leftCurve->is_target(lastPoint)) { m_traits->curve_split(cv, b, a, eventPoint); add_curve_to_output(a, leftCurve, out); } else { const X_monotone_curve_2 &lastCurve = leftCurve->get_last_curve(); if ( leftCurve->is_source_left_to_target() ) { m_traits->curve_split(lastCurve, a, b, eventPoint); add_curve_to_output(a, leftCurve, out); } else { m_traits->curve_split(lastCurve, b, a, eventPoint); add_curve_to_output(a, leftCurve, out); } } leftCurve->set_last_point(eventPoint); leftCurve->set_last_curve(b); } // remove curve from the status line (also checks intersection // between the neighbouring curves) remove_curve_from_status_line(leftCurve); m_use_hint_for_erase = true; m_currentPos = m_prevPos; ++leftCurveIter; } SL_DEBUG(std::cout << "Handling left curve END" << std::endl;) } /*! * Handle a vertical curve when the event being processed is the top end * of the curve. In this situation, the event contains a list of * intersection points on the vertical curve. We go through this list and * outpt the subcurves induced by these intersection points. * If the curve is not vertical, returns without doing anything. * * @param out an iterator to the output * @param tag a tag that indicates the version of the method */ template void handle_vertical_curve_top(OutpoutIterator out, SweepLineGetSubCurves &tag) { SL_DEBUG(std::cout<<"handle_vertical_curve_top... (" << m_currentEvent->get_point() << ")\n";) if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout<<"exiting\n ";) return; } SL_DEBUG(std::cout<<"\n ";) VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); while ( vciter !=vcurves.end() ) { Subcurve *vcurve = *vciter; const Point_2 &topPoint = m_currentEvent->get_point(); // if this is the bottom point, nothing to do here if ( vcurve->is_bottom_end(topPoint)) { SL_DEBUG(std::cout<<"this is the bottom. skipping.\n";) ++vciter; continue; } SL_DEBUG(std::cout<<"handling top point of vertical curve\n";) // the following while loop comes to handle | // in the case where a new curve begins at |------ // a vertical curve | // find the "position" of the curve of the status line StatusLineIter slIter = m_statusLine->lower_bound(vcurve); if ( slIter != m_statusLine->end() ) { SL_DEBUG(std::cout<<"starting at curve \n";) SL_DEBUG((*slIter)->Print();) while (slIter != m_statusLine->end() && m_traits->point_in_x_range((*slIter)->get_curve(), topPoint) && m_traits->curve_compare_y_at_x( topPoint, (*slIter)->get_curve()) == LARGER && m_traits->point_in_x_range((*slIter)->get_curve(), vcurve->get_bottom_end()) && m_traits->curve_compare_y_at_x( vcurve->get_bottom_end(), (*slIter)->get_curve()) == SMALLER) { SL_DEBUG(std::cout<<"checking \n";) SL_DEBUG((*slIter)->Print();) if ( m_traits->compare_x( (*slIter)->get_left_end(), topPoint) == EQUAL) { m_currentEvent->add_vertical_curve_x_point( (*slIter)->get_left_end(), true); } ++slIter; } } // now we go over the list of intersection points on the vertical // curve in at the event and process them... SL_DEBUG(std::cout<<"handling the splitting now\n";) VerticalXPointList &pointList = m_currentEvent->get_vertical_x_point_list(); if ( pointList.empty() ) { add_vertical_curve_to_output(out, vcurve->get_curve()); ++vciter; continue; } X_monotone_curve_2 a, b, c; a = vcurve->get_curve(); SL_DEBUG(std::cout << "there are " << pointList.size() << " points\n";) SL_DEBUG(m_currentEvent->PrintVerticalXPoints();) for ( VerticalXPointListIter i = pointList.begin() ; i != pointList.end(); ++i ) { SL_DEBUG(std::cout<< "splitting: " << a << " at " << *i ;) if ( !vcurve->is_point_in_range(*i) ) { SL_DEBUG(std::cout << " not !\n";) continue; } SL_DEBUG(std::cout << " yes! \n";) m_traits->curve_split(a, b, c, *i); if ( vcurve->is_source_left_to_target()) { add_vertical_curve_to_output(out, b); a = c; } else { add_vertical_curve_to_output(out, c); a = b; } } if ( vcurve->is_source_left_to_target() ) { add_vertical_curve_to_output(out, c); } else { add_vertical_curve_to_output(out, b); } ++vciter; } } /*! Loop over the curves to the right of the status line and handle them: * - if we are at the beginning of the curve, we insert it to the status * line, then we look if it intersects any of its neighbours. * - if we are at an intersection point between two curves, we add them * to the status line and attempt to intersect them with their neighbours. * - We also check to see if the two intersect again to the right of the * point. */ template void handle_right_curves(OutpoutIterator out, SweepLineGetSubCurves &tag) { SL_DEBUG(std::cout << "Handling right curves (" ;) SL_DEBUG(std::cout << m_currentEvent->get_point() << ")\n";) int numRightCurves = m_currentEvent->get_num_right_curves(); if ( numRightCurves == 0 ) return; m_currentPos = m_sweepLinePos; if ( numRightCurves == 1 ) { SL_DEBUG(std::cout << " - beginning of curve " << std::endl;) SL_DEBUG( Subcurve *tmp1 = *(m_currentEvent->right_curves_begin()); PRINT_INSERT(tmp1); ) StatusLineIter slIter = m_statusLine->insert( m_status_line_insert_hint, *(m_currentEvent->right_curves_begin())); (*(m_currentEvent->right_curves_begin()))->set_hint(slIter); //xxx m_status_line_insert_hint = slIter; ++m_status_line_insert_hint; SL_DEBUG(PrintStatusLine();) // if this is the only curve on the status line, nothing else to do if ( m_statusLine->size() == 1 ) return; StatusLineIter prev = slIter; StatusLineIter next = slIter; ++next; SubCurveList mylist; if ( slIter != m_statusLine->begin() ) { --prev; StatusLineIter tmp = prev; mylist.push_back(*prev); while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp) ) mylist.push_back(*tmp); else break; } } if ( next != m_statusLine->end() ) { StatusLineIter tmp = next; mylist.push_back(*next); ++tmp; while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp) ) { mylist.push_back(*tmp); ++tmp; } else break; } } intersect_curve_group(*(m_currentEvent->right_curves_begin()), mylist, out); } else { /* this block takes care of // // / // / // -------- // \ // \ */ int numLeftCurves = m_currentEvent->get_num_left_curves(); if ( numLeftCurves == 0 ) { SL_DEBUG(std::cout << " - handling special case " << std::endl;) StatusLineIter slIter; EventCurveIter currentOne = m_currentEvent->right_curves_begin(); while ( currentOne != m_currentEvent->right_curves_end() ) { slIter = m_statusLine->lower_bound(*currentOne); if ( slIter != m_statusLine->end() ) { Subcurve *c = *slIter; if ( CurveStartsAtCurve(*currentOne, c)) { m_currentEvent->add_curve_to_left(c, m_sweepLinePos); m_currentEvent->add_curve_to_right(c); X_monotone_curve_2 a,b; if ( c->is_source_left_to_target() ) { m_traits->curve_split(c->get_last_curve(), a, b, m_currentEvent->get_point()); } else { m_traits->curve_split(c->get_last_curve(), b, a, m_currentEvent->get_point()); } c->set_last_point(m_currentEvent->get_point()); c->set_last_curve(b); add_curve_to_output(a, c, out); break; } } currentOne++; } } // end block ... SubCurveList mylist; SubCurveList prevlist; SubCurveList currentlist; SL_DEBUG(std::cout << " - intersection point " << std::endl;); EventCurveIter firstOne = m_currentEvent->right_curves_begin(); EventCurveIter lastOne = m_currentEvent->right_curves_end(); --lastOne; EventCurveIter rightCurveEnd = m_currentEvent->right_curves_end(); PRINT_INSERT(*firstOne); StatusLineIter slIter = m_statusLine->insert(m_status_line_insert_hint, *firstOne); (*firstOne)->set_hint(slIter); SL_DEBUG(PrintStatusLine();); if ( slIter != m_statusLine->begin() ) { StatusLineIter prev = slIter; --prev; // find all curves that are overlapping with the prev curve StatusLineIter tmp = prev; prevlist.push_back(*prev); while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp)) prevlist.push_back(*tmp); else break; } intersect_curve_group(*slIter, prevlist, out); } currentlist.push_back(*firstOne); EventCurveIter currentOne = firstOne; ++currentOne; EventCurveIter prevOne = firstOne; while ( currentOne != rightCurveEnd ) { m_currentPos = m_sweepLinePos; PRINT_INSERT(*currentOne); ++slIter; slIter = m_statusLine->insert(slIter, *currentOne); (*currentOne)->set_hint(slIter); SL_DEBUG(PrintStatusLine();); if ( do_curves_overlap(*currentOne, *prevOne)) { intersect_curve_group(*currentOne, currentlist, out); currentlist.push_back(*currentOne); } else { prevlist = currentlist; currentlist.clear(); currentlist.push_back(*currentOne); } intersect_curve_group(*currentOne, prevlist, out); prevOne = currentOne; ++currentOne; } m_status_line_insert_hint = slIter; ++m_status_line_insert_hint; lastOne = currentOne; --lastOne; m_currentPos = m_sweepLinePos; //PRINT_INSERT(*lastOne); SL_DEBUG(PrintStatusLine();) StatusLineIter next = slIter; ++next; if ( next != m_statusLine->end() ) { intersect_curve_group(*next, currentlist, out, true); StatusLineIter tmp = next; ++tmp; while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp)) { intersect_curve_group(*tmp, currentlist, out, true); ++tmp; } else break; } } } } template void handle_right_curves(OutpoutIterator out, SweepLineGetPoints &tag) { SL_DEBUG(std::cout << "Handling right curves (" ;); SL_DEBUG(std::cout << m_currentEvent->get_point() << ")\n";); int numRightCurves = m_currentEvent->get_num_right_curves(); if ( numRightCurves == 0 ) return; m_currentPos = m_sweepLinePos; if ( numRightCurves == 1 ) { SL_DEBUG(std::cout << " - beginning of curve " << std::endl;); SL_DEBUG( Subcurve *tmp1 = *(m_currentEvent->right_curves_begin()); PRINT_INSERT(tmp1); ); StatusLineIter slIter = m_statusLine->insert( m_status_line_insert_hint, *(m_currentEvent->right_curves_begin())); (*(m_currentEvent->right_curves_begin()))->set_hint(slIter); m_status_line_insert_hint = slIter; ++m_status_line_insert_hint; SL_DEBUG(PrintStatusLine();); // if this is the only curve on the status line, nothing else to do if ( m_statusLine->size() == 1 ) return; StatusLineIter prev = slIter; StatusLineIter next = slIter; ++next; SubCurveList mylist; if ( slIter != m_statusLine->begin() ) { --prev; if ( CurveStartsAtCurve(*slIter, *prev) && !m_includeEndPoints) { SL_DEBUG(std::cout << "Reporting point (4): " << (*slIter)->get_left_end() << "\n";); //*out = (*slIter)->get_left_end(); ++out; add_point_to_output((*slIter)->get_left_end(), out); m_found_intersection = true; } StatusLineIter tmp = prev; mylist.push_back(*prev); while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp) ) mylist.push_back(*tmp); else break; } } if ( next != m_statusLine->end() ) { if ( CurveStartsAtCurve(*slIter, *next) && !m_includeEndPoints) { SL_DEBUG(std::cout << "Reporting point (5): " << (*slIter)->get_left_end() << "\n";); //*out = (*slIter)->get_left_end(); ++out; add_point_to_output((*slIter)->get_left_end(), out); m_found_intersection = true; } StatusLineIter tmp = next; mylist.push_back(*next); ++tmp; while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp) ) { mylist.push_back(*tmp); ++tmp; } else break; } } intersect_curve_group(*(m_currentEvent->right_curves_begin()), mylist); } else { /* this block takes care of // // / // / // -------- // \ // \ */ int numLeftCurves = m_currentEvent->get_num_left_curves(); if ( numLeftCurves == 0 ) { SL_DEBUG(std::cout << " - handling special case " << std::endl;); StatusLineIter slIter; EventCurveIter currentOne = m_currentEvent->right_curves_begin(); while ( currentOne != m_currentEvent->right_curves_end() ) { slIter = m_statusLine->lower_bound(*currentOne); if ( slIter != m_statusLine->end() ) { Subcurve *c = *slIter; if ( CurveStartsAtCurve(*currentOne, c) && !m_includeEndPoints) { SL_DEBUG(std::cout << "Reporting point (8): " << (*currentOne)->get_left_end() << "\n";); //*out = (*currentOne)->get_left_end(); ++out; add_point_to_output((*currentOne)->get_left_end(), out); m_found_intersection = true; break; } } currentOne++; } } // end block .. SubCurveList mylist; SubCurveList prevlist; SubCurveList currentlist; SL_DEBUG(std::cout << " - intersection point " << std::endl;); EventCurveIter firstOne = m_currentEvent->right_curves_begin(); EventCurveIter lastOne = m_currentEvent->right_curves_end(); --lastOne; EventCurveIter rightCurveEnd = m_currentEvent->right_curves_end(); PRINT_INSERT(*firstOne); StatusLineIter slIter = m_statusLine->insert(m_status_line_insert_hint, *firstOne); (*firstOne)->set_hint(slIter); SL_DEBUG(PrintStatusLine();); if ( slIter != m_statusLine->begin() ) { StatusLineIter prev = slIter; --prev; if ( CurveStartsAtCurve(*slIter, *prev) && !m_includeEndPoints) { SL_DEBUG(std::cout << "Reporting point (6): " << (*slIter)->get_left_end() << "\n";); //*out = (*slIter)->get_left_end(); ++out; add_point_to_output((*slIter)->get_left_end(), out); m_found_intersection = true; } // find all curves that are overlapping with the prev curve StatusLineIter tmp = prev; prevlist.push_back(*prev); while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp)) prevlist.push_back(*tmp); else break; } intersect_curve_group(*slIter, prevlist); } currentlist.push_back(*firstOne); EventCurveIter currentOne = firstOne; ++currentOne; EventCurveIter prevOne = firstOne; while ( currentOne != rightCurveEnd ) { m_currentPos = m_sweepLinePos; PRINT_INSERT(*currentOne); ++slIter; slIter = m_statusLine->insert(slIter, *currentOne); (*currentOne)->set_hint(slIter); SL_DEBUG(PrintStatusLine();); if ( do_curves_overlap(*currentOne, *prevOne)) { intersect_curve_group(*currentOne, currentlist); currentlist.push_back(*currentOne); } else { prevlist = currentlist; currentlist.clear(); currentlist.push_back(*currentOne); } intersect_curve_group(*currentOne, prevlist); prevOne = currentOne; ++currentOne; } m_status_line_insert_hint = slIter; ++m_status_line_insert_hint; lastOne = currentOne; --lastOne; m_currentPos = m_sweepLinePos; PRINT_INSERT(*lastOne); SL_DEBUG(PrintStatusLine();); StatusLineIter next = slIter; ++next; if ( next != m_statusLine->end() ) { if ( CurveStartsAtCurve(*slIter, *next) && !m_includeEndPoints) { SL_DEBUG(std::cout << "Reporting point (7): " << (*slIter)->get_left_end() << "\n";); //*out = (*slIter)->get_left_end(); ++out; add_point_to_output((*slIter)->get_left_end(), out); m_found_intersection = true; } intersect_curve_group(*next, currentlist); StatusLineIter tmp = next; ++tmp; while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp)) { intersect_curve_group(*tmp, currentlist); ++tmp; } else break; } } } } // utility methods bool intersect(Subcurve *c1, Subcurve *c2); void intersect_curve_group(Subcurve *c1, SubCurveList &mylist); // reverse = false ==> we check if the curve starts at the list of curves // reverse = true ==> we check if any of the curves in the list start at // the single curve template void intersect_curve_group(Subcurve *c1, SubCurveList &mylist, OutpoutIterator out, bool reverse=false) { m_tmpOut.clear(); SL_DEBUG(std::cout << "intersect_curve_group (with out)\n";) SL_DEBUG(std::cout << "intersecting with " << mylist.size() << " curves\n";) SubCurveListIter i = mylist.begin(); while ( i != mylist.end()) { bool flag; if ( reverse ) { flag = CurveStartsAtCurve(*i, c1); if ( flag && (c1->get_last_point() != m_currentEvent->get_point()) ) { SL_DEBUG(std::cout << "CurveStartsAtCurve 3 \n";) m_currentEvent->add_curve_to_right(c1); m_currentEvent->add_curve_to_left(c1, m_prevPos); X_monotone_curve_2 a,b; SL_DEBUG(std::cout << "splitting " << (c1)->get_last_curve() << " at " << m_currentEvent->get_point() << "\n";) if ( (c1)->is_source_left_to_target() ) m_traits->curve_split((c1)->get_last_curve(), a, b, m_currentEvent->get_point()); else m_traits->curve_split((c1)->get_last_curve(), b, a, m_currentEvent->get_point()); (c1)->set_last_point(m_currentEvent->get_point()); (c1)->set_last_curve(b); (c1)->set_last_subcurve(a); m_tmpOut.push_back(c1); } } else { flag = CurveStartsAtCurve(c1, *i); if ( flag && ((*i)->get_last_point() != m_currentEvent->get_point())) { SL_DEBUG(std::cout << "CurveStartsAtCurve 3 \n";) m_currentEvent->add_curve_to_right(*i); m_currentEvent->add_curve_to_left(*i, m_prevPos); X_monotone_curve_2 a,b; SL_DEBUG(std::cout << "splitting " << (*i)->get_last_curve() << " at " << m_currentEvent->get_point() << "\n";) if ( (*i)->is_source_left_to_target() ) m_traits->curve_split((*i)->get_last_curve(), a, b, m_currentEvent->get_point()); else m_traits->curve_split((*i)->get_last_curve(), b, a, m_currentEvent->get_point()); (*i)->set_last_point(m_currentEvent->get_point()); (*i)->set_last_curve(b); (*i)->set_last_subcurve(a); m_tmpOut.push_back(*i); } } intersect(c1, *i); ++i; } for ( SubCurveListIter iter = m_tmpOut.begin() ; iter != m_tmpOut.end(); ++iter) { add_curve_to_output((*iter)->get_last_subcurve(), *iter, out); } } void remove_curve_from_status_line(Subcurve *leftCurve); bool is_internal_x_point(const Point_2 &p); bool handle_vertical_curve_x_at_end(Subcurve *vcurve, Subcurve *curve, Event *topEndEvent, SweepLineGetSubCurves tag); bool handle_vertical_curve_x_at_end(Subcurve *vcurve, Subcurve *curve, Event *topEndEvent, SweepLineGetPoints tag); bool do_curves_overlap(Subcurve *c1, Subcurve *c2); bool similar_curves(const X_monotone_curve_2 &a, const X_monotone_curve_2 &b); bool vertical_subcurve_exists(const X_monotone_curve_2 &a); /*! Adds a new curve to the output list. If the overlapping flag is false, each unique curve is reported only once. @param out an iterator to the output container @param cv the curve to be added */ template void add_curve_to_output(const X_monotone_curve_2 &cv, Subcurve *curve, OutpoutIterator out) { static Subcurve *prevCurve = 0; static X_monotone_curve_2 prevXCv; if ( m_overlapping ) { *out = cv; ++out; } else { if ( prevCurve && similar_curves(cv, prevXCv)) { SL_DEBUG(std::cout << " curve already reported... " << std::endl;) return; } prevCurve = curve; prevXCv = cv; *out = cv; ++out; } } template void add_point_to_output(const Point_2 p, OutpoutIterator out) { SL_DEBUG(std::cout << "Reporting point " << p;) if ( is_first_point ) { is_first_point = false; *out = p; m_lastReportedPoint = p; ++out; SL_DEBUG(std::cout << " YES - first time\n";) } else { if ( m_lastReportedPoint != p ) { *out = p; ++out; m_lastReportedPoint = p; SL_DEBUG(std::cout << " YES\n";) } else { SL_DEBUG(std::cout << " NO\n";) } } } template void add_vertical_curve_to_output(OutpoutIterator out, const X_monotone_curve_2 &cv) { if ( m_overlapping ) { *out = cv; ++out; } else { if ( vertical_subcurve_exists(cv)) { SL_DEBUG(std::cout << " curve already reported... " << std::endl;) return; } m_verticalSubCurves.push_back(cv); *out = cv; ++out; } } /*! * Returns true if the point is in the interior of the curve. * Returns false if the point is outside the range of the curve or * if the point is either the source or the target of the curve. * @return true if the point is int he interior of the curve. */ bool is_point_in_curve_interior(const X_monotone_curve_2 &c, const Point_2 &p) { if (! m_traits->point_in_x_range(c,p) || m_traits->curve_compare_y_at_x(p, c) != EQUAL) return false; if ( is_end_point(p) ) return false; return true; } // // a second implementation for the get_intersection_points functionality // /*! * Handle a vertical curve when the event being processed is the top end * of the curve. In this situation, the event contains a list of * intersection points on the vertical curve. We go through this list and * output the intersection points. * If the curve is not vertical, returns without doing anything. * * @param out an iterator to the output * @param tag a tag that indicates the version of the method */ template void handle_vertical_curve_top(OutpoutIterator out, SweepLineGetPoints &tag) { SL_DEBUG(std::cout<<"handle_vertical_curve_top... ";) if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout<<"exiting\n ";) return; } SL_DEBUG(std::cout<<"\n ";) VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); while ( vciter != vcurves.end() ) { Subcurve *vcurve = *vciter; const Point_2 &topPoint = m_currentEvent->get_point(); if ( vcurve->is_bottom_end(topPoint)) { SL_DEBUG(std::cout<<"this is the bottom. skipping.\n";) ++vciter; continue; } SL_DEBUG(std::cout<<"handling top point of vertical curve\n";) StatusLineIter slIter = m_statusLine->lower_bound(vcurve); if ( slIter != m_statusLine->end() ) { SL_DEBUG(std::cout<<"starting at curve \n";) SL_DEBUG((*slIter)->Print();) const Point_2 &bottomPoint = vcurve->get_bottom_end(); while (slIter != m_statusLine->end() && m_traits->point_in_x_range((*slIter)->get_curve(), topPoint) && m_traits->curve_compare_y_at_x(topPoint, (*slIter)->get_curve()) == LARGER && m_traits->point_in_x_range((*slIter)->get_curve(), bottomPoint) && m_traits->curve_compare_y_at_x(bottomPoint, (*slIter)->get_curve()) == SMALLER) { SL_DEBUG(std::cout<<"checking \n";) SL_DEBUG((*slIter)->Print();) if ( m_traits->compare_x((*slIter)->get_left_end(),topPoint) == EQUAL) { m_currentEvent->add_vertical_curve_x_point( (*slIter)->get_left_end()); // if this point was not an event, we need to report the point // test40/42 if ( !m_includeEndPoints && !is_internal_x_point((*slIter)->get_left_end())) { SL_DEBUG(std::cout << "Reporting point (1): " << (*slIter)->get_left_end() << "\n";) //*out = (*slIter)->get_left_end(); ++out; add_point_to_output((*slIter)->get_left_end(), out); m_found_intersection = true; } } ++slIter; } } ++vciter; } } /*! For each left-curve, if it is the "last" subcurve, i.e., the * event point is the right-edge of the original curve, the * last sub curve is created and added to the result. Otherwise * the curve is added as is to the result. */ template void handle_left_curves(OutpoutIterator out, SweepLineGetPoints &tag) { SL_DEBUG(std::cout << "Handling left curve" << std::endl;) SL_DEBUG(m_currentEvent->Print();) const Point_2 &eventPoint = m_currentEvent->get_point(); if ( !m_currentEvent->has_left_curves()) { if (m_includeEndPoints || m_currentEvent->is_internal_intersection_point()) { SL_DEBUG(std::cout << "Reporting point (2): " << eventPoint << "\n";) //*out = eventPoint; ++out; add_point_to_output(eventPoint, out); m_found_intersection = true; } return; } // delete the curve from the status line EventCurveIter leftCurveIter = m_currentEvent->left_curves_begin(); m_currentPos = m_prevPos; m_use_hint_for_erase = false; while ( leftCurveIter != m_currentEvent->left_curves_end() ) { // before deleting check new neighbors that will become after deletion remove_curve_from_status_line(*leftCurveIter); m_use_hint_for_erase = true; PRINT_ERASE((*leftCurveIter)); m_currentPos = m_prevPos; Subcurve *leftCurve = *leftCurveIter; leftCurve->set_last_point(eventPoint); ++leftCurveIter; } if ( m_includeEndPoints || m_currentEvent->is_internal_intersection_point() ) { SL_DEBUG(std::cout << "Reporting point (3): " << eventPoint << "\n";) //*out = eventPoint; ++out; add_point_to_output(eventPoint, out); m_found_intersection = true; } } #ifndef NDEBUG void PrintEventQueue(); void PrintSubCurves(); void PrintStatusLine(); void PrintVerticals(); #endif protected: /*! a pointer to a traits object */ Traits *m_traits; /*! an indication to whether the traits should be deleted in the distructor */ bool m_traitsOwner; /*! if false, overlapping subcurves are reported only one. Otherwise, they are reported as many times as they appeard. */ bool m_overlapping; /*! if true, end points are reported as intersection points */ bool m_includeEndPoints; /*! this is true when get_intersection_points() is called */ bool m_stop_at_first_int; /*! used to hold all event, processed or not, so that they can ` all be deleted at the end */ EventPtrContainer m_events; /*! the queue of events (intersection points) to handle */ EventQueue *m_queue; /*! The subcurves, as created on the fly */ SubCurveList m_subCurves; /*! The status line */ StatusLine *m_statusLine; /*! a struct that holds params associated with the curve compare functor */ CompareParams *m_comp_param; /*! A reference point that is used for comapring curves. It is used when inserting/erasing curves from the status line. */ Point_2 m_currentPos; /*! A reference point that is used for comapring curves */ Point_2 m_prevPos; /*! The current position (in X) of the sweep line */ Point_2 m_sweepLinePos; /*! if non x-monotone are specified, this hold the x-monotone curves created when splitting them into x-monotone curves. */ std::vector m_xcurves; /*! a pointer to the current event */ Event *m_currentEvent; /*! a queue that holds all the events that have the same x coordinate as the status line. */ EventList m_miniq; /*! a list of vertical curves at the x coordinate of the current event point.*/ SubCurveList m_verticals; CurveList m_verticalSubCurves; /*! when an intersection point is found this is turned to true */ bool m_found_intersection; /*! An iterator of the status line that is used as a hint for inserts. */ StatusLineIter m_status_line_insert_hint; /*! A an indication wether the hint can be used to erase from the status line */ bool m_use_hint_for_erase; SubCurveList m_tmpOut; Point_2 m_lastReportedPoint; bool is_first_point; /*! a counter the is used to assign unique ids to the curves. */ int m_curveId; #ifndef NDEBUG int m_eventId; #endif bool CurveStartsAtCurve(Subcurve *one, Subcurve *two) { SL_DEBUG(std::cout << "CurveStartsAtCurve: \n";) SL_DEBUG(std::cout << one->get_curve() << "\n" << two->get_curve() << "\n";) if ( m_traits->point_equal(one->get_left_end(),two->get_left_end())) return false; if ( !m_traits->point_equal(one->get_left_end(), m_currentEvent->get_point()) ) return false; if ( m_traits->curve_compare_y_at_x(one->get_left_end(), two->get_curve()) == EQUAL ) return true; return false; } }; template Sweep_line_2_impl:: ~Sweep_line_2_impl() { if ( m_traitsOwner ) delete m_traits; for ( SubCurveListIter sci = m_subCurves.begin() ; sci != m_subCurves.end() ; ++sci) { delete *sci; } for ( EventPtrContainerIter ei = m_events.begin(); ei != m_events.end() ; ++ei) { delete *ei; } delete m_queue; delete m_statusLine; delete m_comp_param; } /*! initializes the data structures to work with: * - x-monotonize the inf\put curves * - for each end point of each curve create an event * - initialize the event queue * - */ template inline void Sweep_line_2_impl:: init(CurveInputIterator begin, CurveInputIterator end) { PointLess pred(m_traits); m_queue = new EventQueue(pred); m_comp_param = new CompareParams(m_traits); StatusLineCurveLess slcurveless(m_comp_param); m_statusLine = new StatusLine(slcurveless); m_status_line_insert_hint = m_statusLine->begin(); #ifndef NDEBUG m_eventId = 0; #endif m_curveId = 0; int count = 0; CurveInputIterator iter; for ( iter = begin ; iter != end ; ++iter) { std::list xcurves; m_traits->curve_make_x_monotone(*iter, std::back_inserter(xcurves)); SL_DEBUG( std::cout << "curve " << *iter << " was split into " << xcurves.size() << " curves." << std::endl; ) for (typename std::list::iterator i = xcurves.begin(); i != xcurves.end() ; ++i ) { m_xcurves.push_back(*i); init_curve(m_xcurves[count]); count++; } } } /*! Given an x-monotone curve, create events for each end (if * one doesn't exist already). * For each curve create a Subcurve instance. */ template inline void Sweep_line_2_impl:: init_curve(X_monotone_curve_2 &curve) { const Point_2 &source = m_traits->curve_source(curve); const Point_2 &target = m_traits->curve_target(curve); Event *e = 0; Subcurve *subCv = new Subcurve(m_curveId++, curve, &m_currentPos, m_traits); m_subCurves.push_back(subCv); // handle the source point EventQueueIter eventIter = m_queue->find(&source); if ( eventIter != m_queue->end() ) // check if the event already in the event queue { SL_DEBUG(std::cout << "event " << source << " already exists\n";) e = eventIter->second; } else // the event is not in the event-queue { e = new Event(source, m_traits); #ifndef NDEBUG e->id = m_eventId++; #endif m_events.push_back(e); m_queue->insert(EventQueueValueType(&(e->get_point()), e)); } e->add_curve(subCv); PRINT_NEW_EVENT(source, e); // handle the target point eventIter = m_queue->find(&target); if ( eventIter != m_queue->end() ) { SL_DEBUG(std::cout << "event " << target << " already exists\n";) e = eventIter->second; } else { e = new Event(target, m_traits); #ifndef NDEBUG e->id = m_eventId++; #endif m_events.push_back(e); m_queue->insert(EventQueueValueType(&(e->get_point()), e)); } e->add_curve(subCv); PRINT_NEW_EVENT(target, e); } /*! * Handles the degenerate case of vertical curves. Most of the cases * that occur with vertical curves are handled by this method and * handle_vertical_curve_top method. * When the current event is the bottom end of a vertical curve, we look * for intersection points between the vertical curve and any curve * in the status line that in the y-range that is defined by the bottom * and top ends of the vertical curve. When those are found, we create * new events, unless ones already exist, in which case we update the events. * * @param tag a tag that indicates the version of this method * \sa handle_vertical_curve_top */ template inline void Sweep_line_2_impl:: handle_vertical_curve_bottom(SweepLineGetSubCurves &tag) { SL_DEBUG(std::cout<<"\nhandle_vertical_curve_bottom... (" << m_currentEvent->get_point() << ")\n";) if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout<<" - not vertical - exiting\n ";) return; } SL_DEBUG(std::cout<<"\n ";) VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); const Point_2 ¤tPoint = m_currentEvent->get_point(); SL_DEBUG(std::cout << vcurves.size() << " vertical curves in event\n";) while ( vciter != vcurves.end() ) { Subcurve *vcurve = *vciter; SL_DEBUG(std::cout << "working on " << vcurve->get_curve() << "\n";) if ( vcurve->is_top_end(currentPoint)) { vciter++; continue; } SL_DEBUG(std::cout<<"handling bottom point of vertical curve\n";) StatusLineIter slIter = m_statusLine->lower_bound(vcurve); if ( slIter == m_statusLine->end() ) { SL_DEBUG(std::cout<<"no curves intersecting. exiting\n";) vciter++; continue; } SL_DEBUG(std::cout<<"starting at curve \n";) SL_DEBUG((*slIter)->Print();) const Point_2 &topEnd = vcurve->get_top_end(); EventQueueIter topEndEventIter = m_queue->find(&topEnd); CGAL_assertion(topEndEventIter!=m_queue->end()); Event *topEndEvent = topEndEventIter->second; bool lastEventCreatedHere = false; Event *prevEvent = 0; while (slIter != m_statusLine->end() && (! m_traits->point_in_x_range((*slIter)->get_curve(), topEnd) || m_traits->curve_compare_y_at_x( topEnd, (*slIter)->get_curve()) != SMALLER) && (! m_traits->point_in_x_range((*slIter)->get_curve(), currentPoint) || m_traits->curve_compare_y_at_x(currentPoint, (*slIter)->get_curve()) != LARGER)) { SL_DEBUG(std::cout<<"intersecting with \n";) SL_DEBUG((*slIter)->Print();) if ( handle_vertical_curve_x_at_end(vcurve, *slIter, topEndEvent, tag)) { ++slIter; continue; } // handle a curve that goes through the interior of the vertical curve const X_monotone_curve_2 &cv1 = vcurve->get_curve(); const X_monotone_curve_2 &cv2 = (*slIter)->get_curve(); Object res = m_traits->nearest_intersection_to_right(cv1, cv2, currentPoint); CGAL_assertion(!res.is_empty()); Point_2 xp; if (!CGAL::assign(xp, res)) CGAL_assertion(0); EventQueueIter eqi = m_queue->find(&xp); Event *e = 0; if ( eqi == m_queue->end() ) { e = new Event(xp, m_traits); #ifndef NDEBUG e->id = m_eventId++; #endif m_events.push_back(e); e->add_curve_to_left(*slIter, m_sweepLinePos); e->add_curve_to_right(*slIter); PRINT_NEW_EVENT(xp, e); m_queue->insert(EventQueueValueType(&(e->get_point()), e)); lastEventCreatedHere = true; } else { e = eqi->second; // the only time we need to update the event is when the event // is created here (which also includes overlapping curves) if ( e == prevEvent ) { if ( lastEventCreatedHere ) { if ( !(*slIter)->is_left_end(xp) ) e->add_curve_to_left(*slIter, m_sweepLinePos); if ( !(*slIter)->is_right_end(xp) ) e->add_curve_to_right(*slIter); } } else lastEventCreatedHere = false; SL_DEBUG(std::cout << "Updating event \n";) SL_DEBUG(e->Print();) } topEndEvent->add_vertical_curve_x_point(xp); ++slIter; prevEvent = e; } vciter++; } SL_DEBUG(std::cout<<"Done Handling vertical\n";) } /*! * Handles overlapping vertical curves. * If the current event point does not contain vertical curves, nothing is * done here. * Fo the current event point, we go through the list of vertical curves * defined in the same x coordinate (m_verticals). For each curve, we check * if the event point is in the interior of the vertical curve. If so, * the event is set to be an intersection point (between the two * vertical curves). * While going through the vertical curves, if we reach a curve that the * event point is above the curve, we remove the curve from the list. * * Finally, we go thorugh the vertical curves of the event. If the event * point is the bottom end of a vertical curve, we add the vertical curve * to the list of vertical curves (m_verticals). */ template inline void Sweep_line_2_impl:: handle_vertical_overlap_curves() { SL_DEBUG(std::cout<<"\nhandle_vertical_overlap_curves... (" << m_currentEvent->get_point() << ")";) if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout << "no vertical - exiting\n";) return; } SL_DEBUG(std::cout << "\n";) SL_DEBUG(PrintVerticals();) const Point_2 &point = m_currentEvent->get_point(); SubCurveListIter iter = m_verticals.begin(); while ( iter != m_verticals.end() ) { Subcurve *curve = *iter; if (m_traits->point_in_x_range(curve->get_curve(), point) && m_traits->curve_compare_y_at_x(point, curve->get_curve()) == LARGER) { iter = m_verticals.erase(iter); } else if (!curve->is_end_point(point)) { EventQueueIter eventIter = m_queue->find(&(curve->get_top_end())); CGAL_assertion(eventIter!=m_queue->end()); (eventIter->second)->add_vertical_curve_x_point(point, true); m_currentEvent->mark_internal_intersection_point(); ++iter; } else { ++iter; } } VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); while ( vciter != vcurves.end() ) { Subcurve *vcurve = *vciter; if ( vcurve->is_bottom_end(point) ) { m_verticals.push_back(vcurve); } ++vciter; } } /*! * Perform intersection between the specified curve and all curves in the * given group of curves. */ template inline void Sweep_line_2_impl:: intersect_curve_group(Subcurve *c1, SubCurveList &mylist) { m_tmpOut.clear(); SL_DEBUG(std::cout << "intersecting with " << mylist.size() << " curves\n";) SubCurveListIter i = mylist.begin(); while ( i != mylist.end()) { intersect(c1, *i); ++i; } } /*! * When a curve is removed from the status line for good, its top and * bottom neighbors become neighbors. This method finds these cases and * looks for the itnersection point, if one exists. * * @param leftCurve a pointer to the curve that is about to be deleted * @return an iterator to the position where the curve will be removed from. */ template inline void Sweep_line_2_impl:: remove_curve_from_status_line(Subcurve *leftCurve) { SL_DEBUG(std::cout << "remove_curve_from_status_line\n";) SL_DEBUG(PrintStatusLine();) SL_DEBUG(leftCurve->Print();) StatusLineIter sliter; sliter = leftCurve->get_hint(); m_status_line_insert_hint = sliter; ++m_status_line_insert_hint; if ( !leftCurve->is_end_point(m_currentEvent->get_point())) { m_statusLine->erase(sliter); SL_DEBUG(std::cout << "remove_curve_from_status_line Done\n";) return; } m_currentPos = m_prevPos; CGAL_assertion(sliter!=m_statusLine->end()); StatusLineIter end = m_statusLine->end(); --end; if ( sliter != m_statusLine->begin() && sliter != end ) { SubCurveList mylist; StatusLineIter prev = sliter; --prev; // collect all curves that overlap with *prev StatusLineIter tmp = prev; mylist.push_back(*prev); while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp)) mylist.push_back(*tmp); else break; } StatusLineIter next = sliter; ++next; // intersect *next with the the *prev curve and all overlaps tmp = next; intersect_curve_group(*tmp, mylist); // if there are curves that overlap with the *next curve, intersect // them with the *prev curve and all overlaps ++tmp; while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp)) { intersect_curve_group(*tmp, mylist); ++tmp; } else break; } } m_statusLine->erase(sliter); SL_DEBUG(std::cout << "remove_curve_from_status_line Done\n";) } /*! * Finds intersection between two curves. * If the two curves intersect, create a new event (or use the event that * already exits in the intersection point) and insert the curves to the * event. * @param curve1 a pointer to the first curve * @param curve2 a pointer to the second curve * @return true if the two curves overlap. */ template inline bool Sweep_line_2_impl:: intersect(Subcurve *c1, Subcurve *c2) { SL_DEBUG(std::cout << "Looking for intersection between:\n\t";) SL_DEBUG(c1->Print();) SL_DEBUG(std::cout << "\t";) SL_DEBUG(c2->Print();) SL_DEBUG(std::cout << "\n";) SL_DEBUG(std::cout << "relative to " << m_currentEvent->get_point() << "\n";) if ( c1->getId() == c2->getId() ) { SL_DEBUG(std::cout << "same curve, returning....\n";) return false; } Subcurve *scv1 = c1; Subcurve *scv2 = c2; const X_monotone_curve_2 &cv1 = scv1->get_curve(); const X_monotone_curve_2 &cv2 = scv2->get_curve(); bool isOverlap = false; Object res = m_traits->nearest_intersection_to_right(cv1, cv2, m_currentEvent->get_point()); if (!res.is_empty()) { Point_2 xp; if (!CGAL::assign(xp, res)) { X_monotone_curve_2 cv; if (CGAL::assign(cv, res)) { xp = m_traits->curve_source(cv); Point_2 xp1 = m_traits->curve_target(cv); if ( m_traits->compare_x(xp1, xp) == LARGER ) xp = xp1; SL_DEBUG(std::cout << "overlap detected\n";) isOverlap = true; } } SL_DEBUG( std::cout << " a new event is created between:\n\t"; scv1->Print(); std::cout << "\t"; scv2->Print(); std::cout << "\trelative to (" << m_sweepLinePos << ")\n\t at (" << xp << ")" << std::endl; ) // check to see if an event at this point already exists... EventQueueIter eqi = m_queue->find(&xp); Event *e = 0; if ( eqi == m_queue->end() ) { e = new Event(xp, m_traits); #ifndef NDEBUG e->id = m_eventId++; #endif m_events.push_back(e); e->add_curve_to_left(c1, m_sweepLinePos); e->add_curve_to_left(c2, m_sweepLinePos); e->add_curve_to_right(c1); e->add_curve_to_right(c2); PRINT_NEW_EVENT(xp, e); m_queue->insert(EventQueueValueType(&(e->get_point()), e)); return isOverlap; } else { SL_DEBUG(std::cout << "event already exists,updating.. (" << xp <<")\n";) e = eqi->second; e->add_curve_to_left(c1, m_sweepLinePos); if ( !scv1->is_end_point(xp)) { e->add_curve_to_right(c1); } e->add_curve_to_left(c2, m_sweepLinePos); if ( !scv2->is_end_point(xp) ) { e->add_curve_to_right(c2); } SL_DEBUG(e->Print();) } return isOverlap; } SL_DEBUG(std::cout << "not found 2\n";) return isOverlap; } template inline bool Sweep_line_2_impl:: is_internal_x_point(const Point_2 &p) { EventListIter itt = m_miniq.begin(); while ( itt != m_miniq.end() ) { if ( m_traits->point_equal(p, (*itt)->get_point())) { if ((*itt)->is_internal_intersection_point()) { return true; } (*itt)->mark_internal_intersection_point(); // this is to handle cases: |/ . return false; // (test 50/51) |\ . } ++itt; } CGAL_assertion(0); return false; } /*! * Handles the case in which a curve ont he status line passes through * one of the end points of the vertical curve. * * @param vcurve the vertical curve we are dealing with * @param curve a cerve that intersects with the vertical curve * @param topEndEvent the event attached to the top end of the vertical curve * @param tag * @return returns true if the curve passed through one of the ends of the * vertical curve. Returns false otherwise. */ template inline bool Sweep_line_2_impl:: handle_vertical_curve_x_at_end(Subcurve *vcurve, Subcurve *curve, Event *topEndEvent, SweepLineGetSubCurves tag) { const Point_2 &topEnd = vcurve->get_top_end(); // handle a curve that goes through the top point of the vertical curve if (m_traits->point_in_x_range(curve->get_curve(), topEnd) && m_traits->curve_compare_y_at_x(topEnd, curve->get_curve()) == EQUAL) { if ( !curve->is_left_end(topEnd)) { topEndEvent->add_curve_to_left(curve, m_prevPos); } if ( ! curve->is_right_end(topEnd)) { topEndEvent->add_curve_to_right(curve); } return true; } // handle a curve that goes through the bottom point of the vertical curve const Point_2 ¤tPoint = m_currentEvent->get_point(); if (m_traits->point_in_x_range((curve)->get_curve(), currentPoint) && m_traits->curve_compare_y_at_x(currentPoint, (curve)->get_curve()) == EQUAL) { if ( !(curve)->is_left_end(currentPoint)) { m_currentEvent->add_curve_to_left(curve, m_prevPos); } if ( ! (curve)->is_right_end(currentPoint)) { m_currentEvent->add_curve_to_right(curve); } return true; } return false; } template inline bool Sweep_line_2_impl:: do_curves_overlap(Subcurve *c1, Subcurve *c2) { SL_DEBUG(std::cout << "do_curves_overlap " << m_sweepLinePos << "\n" << "\t" << c1->get_curve() << "\n" << "\t" << c2->get_curve() << "\n";) const Point_2 *p = &(c2->get_last_point()); if ( m_traits->compare_x(c1->get_last_point(), c2->get_last_point()) == LARGER ) p = &(c1->get_last_point()); if ((m_traits->curves_compare_y_at_x(c1->get_curve(), c2->get_curve(), *p) != EQUAL)) return false; if ( m_traits->curves_overlap(c1->get_curve(),c2->get_curve()) ) return true; return false; } template inline bool Sweep_line_2_impl:: similar_curves(const X_monotone_curve_2 &a, const X_monotone_curve_2 &b) { if ( m_traits->curve_equal(a, b)) return true; return false; } template inline bool Sweep_line_2_impl:: vertical_subcurve_exists(const X_monotone_curve_2 &a) { for (typename std::list::iterator iter = m_verticalSubCurves.begin() ; iter != m_verticalSubCurves.end() ; ++iter) { if (similar_curves(*iter, a)) return true; } return false; } //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// // point implementation of the methods // //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// /*! * Handles the degenerate case of vertical curves. Most of the cases * that occur with vertical curves are handled by this method and the * handle_vertical_curve_top method. * * When the current event is the bottom end of a vertical curve, we look * for intersection points between the vertical curve and any curve * in the status line that in the y-range that is defined by the bottom * and top ends of the vertical curve. When those are found, we create * new events, unless ones already exist, in which case we update the events. * * @param tag a tag that indicates the version of this method * \sa handle_vertical_curve_top */ template inline void Sweep_line_2_impl:: handle_vertical_curve_bottom(SweepLineGetPoints &tag) { SL_DEBUG(std::cout<<"handle_vertical_curve_bottom... ";) if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout<<"exiting\n ";) return; } SL_DEBUG(std::cout<<"\n ";) VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); const Point_2 ¤tPoint = m_currentEvent->get_point(); while ( vciter != vcurves.end() ) { Subcurve *vcurve = *vciter; if ( vcurve->is_top_end(currentPoint)) { ++vciter; continue; } SL_DEBUG(std::cout<<"handling bottom point of vertical curve\n";); StatusLineIter slIter = m_statusLine->lower_bound(vcurve); if ( slIter == m_statusLine->end() ) { SL_DEBUG(std::cout<<"no curves intersecting. exiting\n";); ++vciter; continue; } SL_DEBUG(std::cout<<"starting at curve \n";); SL_DEBUG((*slIter)->Print();); const Point_2 &topEnd = vcurve->get_top_end(); EventQueueIter topEndEventIter = m_queue->find(&topEnd); CGAL_assertion(topEndEventIter!=m_queue->end()); Event *topEndEvent = topEndEventIter->second; while (slIter != m_statusLine->end() && (! m_traits->point_in_x_range((*slIter)->get_curve(), topEnd) || m_traits->curve_compare_y_at_x(topEnd, (*slIter)->get_curve()) != SMALLER) && (! m_traits->point_in_x_range((*slIter)->get_curve(), currentPoint) || m_traits->curve_compare_y_at_x(currentPoint, (*slIter)->get_curve()) != LARGER)) { SL_DEBUG(std::cout<<"intersecting with \n";) SL_DEBUG((*slIter)->Print();) if ( handle_vertical_curve_x_at_end(vcurve, *slIter, topEndEvent, tag)) { ++slIter; continue; } Object res = m_traits->nearest_intersection_to_right(vcurve->get_curve(), (*slIter)->get_curve(), currentPoint); CGAL_assertion(!res.is_empty()); Point_2 xp; if (!CGAL::assign(xp, res)) CGAL_assertion(0); EventQueueIter eqi = m_queue->find(&xp); Event *e = 0; if ( eqi == m_queue->end() ) { e = new Event(xp, m_traits); #ifndef NDEBUG e->id = m_eventId++; #endif m_events.push_back(e); e->add_curve_to_left(*slIter, m_sweepLinePos); e->add_curve_to_right(*slIter); PRINT_NEW_EVENT(xp, e); m_queue->insert(EventQueueValueType(&(e->get_point()), e)); } else { e = eqi->second; e->mark_internal_intersection_point(); SL_DEBUG(std::cout << "Updating event \n";) SL_DEBUG(e->Print();) e->add_curve(vcurve); // test41 e->add_curve_to_left(*slIter, (*slIter)->get_left_end()); if ( m_traits->compare_x((*slIter)->get_right_end(), m_currentEvent->get_point()) == LARGER ) e->add_curve_to_right(*slIter); } topEndEvent->add_vertical_curve_x_point(xp); ++slIter; } ++vciter; } SL_DEBUG(std::cout<<"Done Handling vertical\n";) } /*! * Handles the case in which a curve ont he status line passes through * one of the end points of the vertical curve. * * @param vcurve the vertical curve we are dealing with * @param curve a cerve that intersects with the vertical curve * @param topEndEvent the event attached to the top end of the vertical curve * @param tag * @return returns true if the curve passed through one of the ends of the * vertical curve. Returns false otherwise. */ template inline bool Sweep_line_2_impl:: handle_vertical_curve_x_at_end(Subcurve *vcurve, Subcurve *curve, Event *topEndEvent, SweepLineGetPoints tag) { const Point_2 &topEnd = vcurve->get_top_end(); // handle a curve that goes through the top point of the vertical curve if (m_traits->point_in_x_range((curve)->get_curve(), topEnd) && m_traits->curve_compare_y_at_x(topEnd, (curve)->get_curve()) == EQUAL) { if ( !curve->is_end_point(topEnd)) { topEndEvent->mark_internal_intersection_point(); } return true; } // handle a curve that goes through the bottom point of the vertical curve if (m_traits->point_in_x_range((curve)->get_curve(), m_currentEvent->get_point()) && m_traits->curve_compare_y_at_x(m_currentEvent->get_point(), (curve)->get_curve()) == EQUAL) { if ( !curve->is_end_point(m_currentEvent->get_point())) { m_currentEvent->mark_internal_intersection_point(); } return true; } return false; } //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// // DEBUG UTILITIES // //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// #ifndef NDEBUG template inline void Sweep_line_2_impl:: PrintEventQueue() { SL_DEBUG(std::cout << std::endl << "Event queue: " << std::endl;) EventQueueIter iter = m_queue->begin(); while ( iter != m_queue->end() ) { SL_DEBUG(std::cout << "Point (" << iter->first << ")" << std::endl;) Event *e = iter->second; e->Print(); ++iter; } SL_DEBUG(std::cout << "--------------------------------" << std::endl;) } template inline void Sweep_line_2_impl:: PrintSubCurves() { SL_DEBUG(std::cout << std::endl << "Sub curves: " << std::endl;) SubCurveListIter iter = m_subCurves.begin(); while ( iter != m_subCurves.end() ) { (*iter)->Print(); ++iter; } } template inline void Sweep_line_2_impl:: PrintStatusLine() { if ( m_statusLine->size() == 0) { std::cout << std::endl << "Status line: empty" << std::endl; return; } std::cout << std::endl << "Status line: (" << m_currentPos << ")" << std::endl; StatusLineIter iter = m_statusLine->begin(); while ( iter != m_statusLine->end() ) { (*iter)->Print(); ++iter; } std::cout << "Status line - end" << std::endl; } template inline void Sweep_line_2_impl:: PrintVerticals() { if ( m_verticals.size() == 0) { std::cout << std::endl << "Verticals: empty" << std::endl; return; } std::cout << std::endl << "Verticals: " << m_verticals.size() << " (" << m_currentEvent->get_point() << ")" << std::endl; SubCurveListIter iter = m_verticals.begin(); while ( iter != m_verticals.end() ) { (*iter)->Print(); ++iter; } std::cout << "Verticals - end" << std::endl; } #endif CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_functors.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_lin0000644000175000017500000001003011344301501031176 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Sweep_line_functors.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_SWEEP_LINE_FUNCTORS_H #define CGAL_SWEEP_LINE_FUNCTORS_H CGAL_BEGIN_NAMESPACE template class Point_less_functor { public: typedef SweepLineTraits_2 Traits; Point_less_functor(Traits * traits) : m_traits(traits) {} bool operator()(const Point * p1, const Point * p2) const { return (m_traits->compare_xy(*p1,*p2) == SMALLER); } bool operator()( const Point& p1,const Point& p2) const { return (m_traits->compare_xy(p1,p2) == SMALLER); } private: /*! a pointer to a traits class */ Traits * m_traits; }; template class Status_line_curve_less_functor { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::Point_2 Point_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef bool (Status_line_curve_less_functor::*func) (const Subcurve*, const Subcurve*) const; struct Compare_param { Compare_param(Traits *t) : m_compare_func(1), m_traits(t) {} int m_compare_func; Traits * m_traits; }; Status_line_curve_less_functor(Compare_param *p) : m_compare_param(p) { m_compare[0] = &Status_line_curve_less_functor::compare_at; m_compare[1] = &Status_line_curve_less_functor::compare_right; } bool operator()(const Subcurve * c1, const Subcurve * c2) const { return (this->*m_compare[m_compare_param->m_compare_func])(c1, c2); } bool compare_at(const Subcurve * c1, const Subcurve * c2) const { const Point_2 * p = &(c2->get_last_point()); if ( m_compare_param->m_traits->compare_x(c1->get_last_point(), c2->get_last_point()) == LARGER ) p = &(c1->get_last_point()); Comparison_result r = m_compare_param->m_traits->curves_compare_y_at_x(c1->get_curve(), c2->get_curve(), *p); if ( r == SMALLER) { return true; } return false; } bool compare_right(const Subcurve * c1, const Subcurve * c2) const { const X_monotone_curve_2 &cv1 = c1->get_curve(); const X_monotone_curve_2 &cv2 = c2->get_curve(); Traits *t = m_compare_param->m_traits; if ( t->curve_is_vertical(cv1) ) { if (t->point_in_x_range(cv2, c1->get_source()) && t->curve_compare_y_at_x(c1->get_top_end(), cv2) == SMALLER ) { return true; } return false; } if ( t->curve_is_vertical(cv2)) { if (t->point_in_x_range(cv1, c2->get_source()) && t->curve_compare_y_at_x(c2->get_bottom_end(), cv1) == LARGER) { return true; } return false; } const Point_2 *p = &(c2->get_last_point()); if ( m_compare_param->m_traits->compare_x(c1->get_last_point(), c2->get_last_point()) == LARGER ) p = &c1->get_last_point(); // non of the curves is vertical... Comparison_result r = t->curves_compare_y_at_x (c1->get_curve(), c2->get_curve(), *p); if (r == EQUAL) r = t->curves_compare_y_at_x_right(c1->get_curve(), c2->get_curve(), *p); if ( r == SMALLER) { return true; } if ( r == LARGER ) { return false; } // r = EQUAL return ( c1->getId() < c2->getId() ); } Compare_param * m_compare_param; private: func m_compare[2]; }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_insert_info.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_inse0000644000175000017500000000411211344301501031226 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_insert_info.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_PMWX_INSERT_INFO_H #define CGAL_PMWX_INSERT_INFO_H CGAL_BEGIN_NAMESPACE template class Pmwx_insert_info { public: typedef _Halfedge_handle Halfedge_handle; /*! Constructor */ Pmwx_insert_info() : m_halfedge(Halfedge_handle(NULL)), vertical_above_event_flag(false), vertical_below_event_flag(false) { } void set_halfedge_handle(Halfedge_handle h) { m_halfedge = h; } Halfedge_handle get_halfedge_handle() const { return m_halfedge; } bool get_vertical_above_event_flag() const { return vertical_above_event_flag; } bool get_vertical_below_event_flag() const { return vertical_below_event_flag; } void set_vertical_below_event_flag(bool flag) { vertical_below_event_flag = flag; } void set_vertical_above_event_flag(bool flag) { vertical_above_event_flag = flag; } void Print() { if ( m_halfedge == Halfedge_handle(NULL)) std::cout << "halfedge: NULL\n"; else std::cout << "halfedge: " << m_halfedge->source()->point() << " " << m_halfedge->target()->point() << "\n"; } private: Halfedge_handle m_halfedge; //Baruch bool vertical_above_event_flag; bool vertical_below_event_flag; }; CGAL_END_NAMESPACE #endif // CGAL_PMWX_INSERT_INFO_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_sweep_line_functors.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_swee0000644000175000017500000000101611344301501031233 0ustar debiandebian#ifndef CGAL_PMWX_SWEEP_LINE_FUNCTORS_H #define CGAL_PMWX_SWEEP_LINE_FUNCTORS_H CGAL_BEGIN_NAMESPACE template class Event_less_functor { public: typedef SweepLineTraits_2 Traits; Event_less_functor( Traits *traits) : m_traits(traits) {} bool operator()( Event* e1, Event* e2) const { return (m_traits->compare_xy(e1->get_point(), e2->get_point()) == SMALLER); } private: /*! a pointer to a traits class */ Traits *m_traits; }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_aggregate_insert.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_aggr0000644000175000017500000013612211344301501031217 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2/Pmwx_aggregate_insert.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_PMWX_AGGREGATE_INSERT_H #define CGAL_PMWX_AGGREGATE_INSERT_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Pmwx_aggregate_insert : public Sweep_line_2_impl > , Pmwx_sweep_line_curve > { public: typedef SweepLineTraits_2 Traits; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Traits::Point_2 Point_2; typedef PM_ PM; typedef typename PM::Halfedge_iterator Halfedge_iterator; typedef typename PM::Halfedge_handle Halfedge_handle; //typedef typename PM::Locate_type Locate_type; typedef Pmwx_sweep_line_curve SubCurve; typedef Pmwx_sweep_line_event Event; typedef typename SubCurve::PmwxInsertInfo PmwxInsertInfo; typedef Change_notification_ Change_notification; typedef Sweep_line_2_impl Base; typedef typename Event::VerticalXEventSet VerticalXEventSet; typedef typename Event::VerticalXEventSetIter VerticalXEventSetIter; typedef Pmwx_sweep_line_curve Subcurve; // repeated typedefs from the base class to avoid warnings typedef typename Base::EventQueueIter EventQueueIter; typedef typename Base::EventCurveIter EventCurveIter; typedef typename Base::VerticalCurveList VerticalCurveList; typedef typename Base::VerticalCurveListIter VerticalCurveListIter; typedef typename Base::StatusLineIter StatusLineIter; typedef typename Base::SubCurveList SubCurveList; typedef typename Base::SubCurveListIter SubCurveListIter; typedef typename Base::SweepLinePlanarmap SweepLinePlanarmap; typedef typename Base::EventQueueValueType EventQueueValueType; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::m_queue; using Base::m_prevPos; using Base::m_traits; using Base::m_sweepLinePos; using Base::m_verticals; using Base::m_verticalSubCurves; using Base::m_currentPos; using Base::m_currentEvent; using Base::m_miniq; using Base::m_use_hint_for_erase; using Base::m_statusLine; using Base::m_tmpOut; using Base::m_status_line_insert_hint; using Base::m_events; #endif Pmwx_aggregate_insert() : Base(), m_change_not(NULL) {} Pmwx_aggregate_insert(Traits *traits_) : Base(traits_), m_change_not(NULL) {} virtual ~Pmwx_aggregate_insert() {} /*! Initializes the data structures to work with: - x-monotonize the input curves - for each end point of each curve create an event - for each curve in the planarmap do the same - initialize the event queue - */ void init(CurveInputIterator begin, CurveInputIterator end, PM &pm) { Base::init(begin, end); Halfedge_iterator eit; for (eit = pm.halfedges_begin(); eit != pm.halfedges_end(); ++eit, ++eit) { init_curve(eit->curve()); } pm.clear(); } void insert_curves(CurveInputIterator begin, CurveInputIterator end, PM &planarMap, Change_notification* change_notification) { m_change_not = change_notification; std::vector subcurves; init(begin, end, planarMap); // initialize the last event in each event for ( EventQueueIter qiter = m_queue->begin(); qiter != m_queue->end() ; ++qiter ) { Event *e = qiter->second; for (EventCurveIter rightCurveIter = e->right_curves_begin() ; rightCurveIter != e->right_curves_end() ; ++rightCurveIter ) (*rightCurveIter)->set_last_event(e); VerticalCurveList &vcurves = e->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); while ( vciter != vcurves.end() ) { if ((*vciter)->is_bottom_end(e->get_point())) (*vciter)->set_last_event(e); ++vciter; } } SL_DEBUG( PrintSubCurves(); PrintEventQueue(); ); sweep(planarMap, SweepLinePlanarmap()); } protected: /*! The main loop to calculate intersections among the curves Looping over the events in the queue, for each event we first handle the curves that are to the left of the event point (i.e., curves that we are done with), and then we look at the curves to the right of the point, which means we attempt to find intersections between them and their neighbours on the sweep line. */ template void sweep(_PM_ &pm, Op tag) { EventQueueIter eventIter = m_queue->begin(); m_prevPos = *((*eventIter).first); // Point_2 referencePoint; while ( eventIter != m_queue->end() ) { const Point_2 *p = (*eventIter).first; if ( m_traits->compare_x(m_sweepLinePos, *p) == SMALLER ) { m_prevPos = m_sweepLinePos; m_verticals.clear(); m_verticalSubCurves.clear(); } m_sweepLinePos = *p; m_currentPos = *p; // p = (*eventIter).first; m_currentEvent = eventIter->second; SL_DEBUG(std::cout << "------------- " << *p << " --------------" << std::endl; PrintStatusLine(); m_currentEvent->Print(); ); if ( m_traits->compare_x(*((*eventIter).first), m_sweepLinePos) != EQUAL) { SL_DEBUG(std::cout << "clearing miniq " << (*eventIter).first << " " << m_prevPos << "\n";); m_miniq.clear(); } m_miniq.push_back(m_currentEvent); handle_vertical_curve_bottom(tag); handle_vertical_overlap_curves(); handle_left_curves(pm, tag); m_queue->erase(eventIter); handle_vertical_curve_top(pm, tag); handle_right_curves(pm, tag); eventIter = m_queue->begin(); } } /*! For each left-curve, if it is the "last" subcurve, i.e., the event point is the right-edge of the original curve, the last sub curve is created and added to the result. Otherwise the curve is added as is to the result. */ void handle_left_curves(PM &pm, SweepLinePlanarmap &tag) { SL_DEBUG(std::cout << "Handling left curve" << std::endl;); SL_DEBUG(m_currentEvent->Print();); SL_DEBUG((m_currentEvent->get_insert_info()->Print());); EventCurveIter leftCurveIter = m_currentEvent->left_curves_begin(); m_currentPos = m_prevPos; const Point_2 &eventPoint = m_currentEvent->get_point(); Halfedge_handle h(NULL); m_use_hint_for_erase = false; SubCurve *leftCurvePrev = 0; bool are_overlap = false; while ( leftCurveIter != m_currentEvent->left_curves_end() ) { SubCurve *leftCurve = *leftCurveIter; const X_monotone_curve_2 &cv = leftCurve->get_curve(); const Point_2 &lastPoint = leftCurve->get_last_point(); if(leftCurvePrev && do_curves_overlap(leftCurvePrev,leftCurve) ) are_overlap = true; if ( leftCurve->is_source(eventPoint)) { if ( !leftCurve->is_target(lastPoint) ) { X_monotone_curve_2 a,b; m_traits->curve_split(cv, a, b, lastPoint); if(!are_overlap) h = insert_to_pm(a, leftCurve, h, pm); } else { if(!are_overlap) h = insert_to_pm(cv, leftCurve, h, pm); } } else if ( leftCurve->is_target(eventPoint)) { if ( !leftCurve->is_source(lastPoint)) { X_monotone_curve_2 a,b; m_traits->curve_split(cv, a, b, lastPoint); if(!are_overlap) h = insert_to_pm(b, leftCurve, h, pm); } else { if(!are_overlap) h = insert_to_pm(cv, leftCurve, h, pm); } } else // the event point passes through the interior of 'cv' { X_monotone_curve_2 a,b; if ( leftCurve->is_source(lastPoint)) { m_traits->curve_split(cv, a, b, eventPoint); if(!are_overlap) h = insert_to_pm(a, leftCurve, h, pm); } else if ( leftCurve->is_target(lastPoint)) { m_traits->curve_split(cv, b, a, eventPoint); if(!are_overlap) h = insert_to_pm(a, leftCurve, h, pm); } else { const X_monotone_curve_2 &lastCurve = leftCurve->get_last_curve(); if ( leftCurve->is_source_left_to_target() ) { m_traits->curve_split(lastCurve, a, b, eventPoint); if(!are_overlap) h = insert_to_pm(a, leftCurve, h, pm); } else { m_traits->curve_split(lastCurve, b, a, eventPoint); if(!are_overlap) h = insert_to_pm(a, leftCurve, h, pm); } } leftCurve->set_last_point(eventPoint); leftCurve->set_last_curve(b); leftCurve->set_last_event(m_currentEvent); } // before deleting check new neighbors that will become after deletion remove_curve_from_status_line(leftCurve); m_use_hint_for_erase = true; m_currentPos = m_prevPos; leftCurvePrev = *leftCurveIter; ++leftCurveIter; are_overlap = false; } // when done handling the left curves, we prepare for the right curves m_currentEvent->init_right_curves(); } /*! * Handles the degenerate case of vertical curves. Most of the cases * that occur with vertical curves are handled by this method and * HandleVerticalCurveTop method. * When the current event is the bottom end of a vertical curve, we look * for intersection points between the vertical curve and any curve * in the status line that in the y-range that is defined by the bottom * and top ends of the vertical curve. When those are found, we create * new events, unless ones already exist, in which case we update the events. * * @param tag a tag that indicates the version of this method * \sa HandleVerticalCurveTop */ void handle_vertical_curve_bottom(SweepLinePlanarmap &tag) { SL_DEBUG(std::cout << "\nhandle_vertical_curve_bottom... (" << m_currentEvent->get_point() << ")\n";); if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout<<" - not vertical - exiting\n ";); return; } SL_DEBUG(std::cout<<"\n ";); VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); const Point_2 ¤tPoint = m_currentEvent->get_point(); SL_DEBUG(std::cout << vcurves.size() << " vertical curves in event\n";); while ( vciter != vcurves.end() ) { Subcurve *vcurve = *vciter; SL_DEBUG(std::cout << "working on " << vcurve->get_curve() << "\n";); if ( vcurve->is_top_end(currentPoint)) { vciter++; continue; } SL_DEBUG(std::cout<<"handling bottom point of vertical curve\n";); StatusLineIter slIter = m_statusLine->lower_bound(vcurve); if ( slIter == m_statusLine->end() ) { SL_DEBUG(std::cout<<"no curves intersecting. exiting\n";); vciter++; continue; } SL_DEBUG(std::cout<<"starting at curve \n";); SL_DEBUG((*slIter)->Print();); const Point_2 &topEnd = vcurve->get_top_end(); EventQueueIter topEndEventIter = m_queue->find(&topEnd); CGAL_assertion(topEndEventIter != m_queue->end()); Event *topEndEvent = topEndEventIter->second; bool lastEventCreatedHere = false; Event *prevEvent = 0; while (slIter != m_statusLine->end() && (! m_traits->point_in_x_range((*slIter)->get_curve(), topEnd) || m_traits->curve_compare_y_at_x(topEnd, (*slIter)->get_curve()) != SMALLER) && (! m_traits->point_in_x_range((*slIter)->get_curve(), currentPoint) || m_traits->curve_compare_y_at_x(currentPoint, (*slIter)->get_curve()) != LARGER)) { SL_DEBUG(std::cout<<"intersecting with \n";); SL_DEBUG((*slIter)->Print();); if ( handle_vertical_curve_x_at_end(vcurve, *slIter, topEndEvent, tag)) { ++slIter; continue; } // handle a curve that goes through the interior of the vertical curve const X_monotone_curve_2 &cv1 = vcurve->get_curve(); const X_monotone_curve_2 &cv2 = (*slIter)->get_curve(); Object res = m_traits->nearest_intersection_to_right(cv1, cv2, currentPoint); Point_2 p; if (!CGAL::assign(p, res)) CGAL_assertion(0); EventQueueIter eqi = m_queue->find(&p); Event *e = 0; if ( eqi == m_queue->end() ) { e = new Event(p, m_traits); SL_DEBUG(e->id = m_eventId++;); m_events.push_back(e); e->add_curve_to_left(*slIter, m_sweepLinePos); e->add_curve_to_right(*slIter); PRINT_NEW_EVENT(p, e); m_queue->insert(EventQueueValueType(&(e->get_point()), e)); lastEventCreatedHere = true; } else { e = eqi->second; if ( e == prevEvent ) { if ( lastEventCreatedHere ) { if ( !(*slIter)->is_left_end(p) ) e->add_curve_to_left(*slIter, m_sweepLinePos); if ( !(*slIter)->is_right_end(p) ) e->add_curve_to_right(*slIter); } } else { lastEventCreatedHere = false; } SL_DEBUG(std::cout << "Updating event \n";); SL_DEBUG(e->Print();); } topEndEvent->add_vertical_curve_x_event(e); ++slIter; prevEvent = e; } vciter++; } SL_DEBUG(std::cout<<"Done Handling vertical\n";); } /*! * Handle a vertical curve when the event being processed is the top end * of the curve. In this situation, the event contains a list of * intersection points on the vertical curve. We go through this list and * outpt the subcurves induced by these intersection points. * If the curve is not vertical, returns without doing anything. * * @param out an iterator to the output * @param tag a tag that indicates the version of the method */ void handle_vertical_curve_top(PM &pm, SweepLinePlanarmap &tag) { SL_DEBUG(std::cout << "handle_vertical_curve_top... (" << m_currentEvent->get_point() << ")\n";); if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout<<"exiting\n ";); return; } SL_DEBUG(std::cout<<"\n ";); VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); while ( vciter !=vcurves.end() ) { Subcurve *vcurve = *vciter; const Point_2 &topPoint = m_currentEvent->get_point(); // if this is the bottom point, nothing to do here if ( vcurve->is_bottom_end(topPoint)) { SL_DEBUG(std::cout<<"this is the bottom. skipping.\n";); ++vciter; continue; } SL_DEBUG(std::cout<<"handling top point of vertical curve\n";); // the following while loop comes to handle | // in the case where a new curve begins at |------ // a vertical curve | // find the "position" of the curve of the status line StatusLineIter slIter = m_statusLine->lower_bound(vcurve); if ( slIter != m_statusLine->end() ) { SL_DEBUG(std::cout<<"starting at curve \n";); SL_DEBUG((*slIter)->Print();); for( ; slIter != m_statusLine->end() ; ++slIter) { if( m_traits->point_in_x_range((*slIter)->get_curve(), topPoint) && m_traits->curve_compare_y_at_x(topPoint, (*slIter)->get_curve()) == LARGER && m_traits->point_in_x_range((*slIter)->get_curve(), vcurve->get_bottom_end()) && m_traits->curve_compare_y_at_x(vcurve->get_bottom_end(), (*slIter)->get_curve()) == SMALLER) { SL_DEBUG(std::cout<<"checking \n";); SL_DEBUG((*slIter)->Print();); if ( m_traits->compare_x((*slIter)->get_left_end(), topPoint) == EQUAL) { m_currentEvent->add_vertical_curve_x_event( (*slIter)->get_last_event(), true); } } } // (comment the next whilw loop) /*while (slIter != m_statusLine->end() && m_traits->point_in_x_range((*slIter)->get_curve(), topPoint) && m_traits->curve_compare_y_at_x(topPoint, (*slIter)->get_curve()) == LARGER && m_traits->point_in_x_range((*slIter)->get_curve(), vcurve->get_bottom_end()) && m_traits->curve_compare_y_at_x(vcurve->get_bottom_end(), (*slIter)->get_curve()) == SMALLER) { SL_DEBUG(std::cout<<"checking \n";); SL_DEBUG((*slIter)->Print();); if ( m_traits->compare_x((*slIter)->get_left_end(), topPoint) == EQUAL) { m_currentEvent->add_vertical_curve_x_event( (*slIter)->get_last_event(), true); } ++slIter; } */ } // now we go over the list of intersection points on the vertical // curve in at the event and process them... SL_DEBUG(std::cout<<"handling the splitting now\n";); VerticalXEventSet &pointList = m_currentEvent->get_vertical_x_event_set(); if ( pointList.empty() ) { //in that case there aren't any intersection point on the vertical //curve , so no need to split at. just insert it to the planar map insert_to_pm_v(vcurve->get_curve(), vcurve, m_currentEvent, vcurve->get_last_event(), pm); ++vciter; continue; } X_monotone_curve_2 a, b, c; a = vcurve->get_curve(); SL_DEBUG(std::cout << "there are " << pointList.size() << " points\n";); Event *prevEvent = vcurve->get_last_event(); for ( VerticalXEventSetIter i = pointList.begin() ; i != pointList.end(); ++i ) { SL_DEBUG(std::cout<< "splitting: " << a << " at " <<(*i)->get_point();); if ( !vcurve->is_point_in_range((*i)->get_point()) ) { SL_DEBUG(std::cout << " not !\n";); continue; } SL_DEBUG(std::cout << " yes! \n";); // before we call to 'curve_split' we have to make sure we dont try to split // the curve at one of its endpoint (if this is the case , continue to the // next iteration) if (m_traits->point_equal(m_traits->curve_source(a) , (*i)->get_point()) || m_traits->point_equal(m_traits->curve_target(a) , (*i)->get_point())) continue; m_traits->curve_split(a, b, c, (*i)->get_point()); if ( vcurve->is_source_left_to_target()) { insert_to_pm_v(b, vcurve, *i, prevEvent, pm); a = c; } else { insert_to_pm_v(c, vcurve, *i, prevEvent, pm); a = b; } vcurve->set_last_event(*i); prevEvent = *i; } insert_to_pm_v(a,vcurve, m_currentEvent , prevEvent, pm); ++vciter; } } /*! * Handles the case in which a curve on the status line passes through * one of the end points of the vertical curve. * * @param vcurve the vertical curve we are dealing with * @param curve a cerve that intersects with the vertical curve * @param topEndEvent the event attached to the top end of the vertical curve * @param tag * @return returns true if the curve passed through one of the ends of the * vertical curve. Returns false otherwise. */ bool handle_vertical_curve_x_at_end(Subcurve *vcurve, Subcurve *curve, Event *topEndEvent, SweepLinePlanarmap &tag) { const Point_2 &topEnd = vcurve->get_top_end(); // handle a curve that goes through the top point of the vertical curve if (m_traits->point_in_x_range(curve->get_curve(), topEnd) && m_traits->curve_compare_y_at_x(topEnd, curve->get_curve()) == EQUAL) { if ( !curve->is_left_end(topEnd)) { topEndEvent->add_curve_to_left(curve, m_prevPos); } if ( ! curve->is_right_end(topEnd)) { topEndEvent->add_curve_to_right(curve); } return true; } // handle a curve that goes through the bottom point of the vertical curve const Point_2 ¤tPoint = m_currentEvent->get_point(); if (m_traits->point_in_x_range((curve)->get_curve(), currentPoint) && m_traits->curve_compare_y_at_x(currentPoint, (curve)->get_curve()) == EQUAL) { if ( !(curve)->is_left_end(currentPoint)) { m_currentEvent->add_curve_to_left(curve, m_prevPos); } if ( ! (curve)->is_right_end(currentPoint)) { m_currentEvent->add_curve_to_right(curve); } return true;; } return false; } void handle_vertical_overlap_curves() { SL_DEBUG(std::cout << "\nhandle_vertical_overlap_curves... (" << m_currentEvent->get_point() << ")";); if ( !m_currentEvent->does_contain_vertical_curve() ) { SL_DEBUG(std::cout << "no vertical - exiting\n";); return; } SL_DEBUG(std::cout << "\n";); SL_DEBUG(PrintVerticals();); const Point_2 &point = m_currentEvent->get_point(); SubCurveListIter iter = m_verticals.begin(); while ( iter != m_verticals.end() ) { Subcurve *curve = *iter; if (m_traits->point_in_x_range(curve->get_curve(), point) && m_traits->curve_compare_y_at_x(point, curve->get_curve()) == LARGER) { iter = m_verticals.erase(iter); } else if (!curve->is_end_point(point)) { EventQueueIter eventIter = m_queue->find(&(curve->get_top_end())); CGAL_assertion(eventIter != m_queue->end()); (eventIter->second)->add_vertical_curve_x_event(m_currentEvent, true); ++iter; } else { ++iter; } } VerticalCurveList &vcurves = m_currentEvent->get_vertical_curves(); VerticalCurveListIter vciter = vcurves.begin(); while ( vciter != vcurves.end() ) { Subcurve *vcurve = *vciter; if ( vcurve->is_bottom_end(point) ) { m_verticals.push_back(vcurve); } ++vciter; } } // reverse = false ==> we check if the curve starts at the list of curves // reverse = true ==> we check if any of the curves in the list start at // the single curve void intersect_curve_group(Subcurve *c1, SubCurveList &mylist, PM &pm, bool reverse=false) { m_tmpOut.clear(); SL_DEBUG(std::cout << "intersect_curve_group (with out)\n";); SL_DEBUG(std::cout << "Intersecting with " << mylist.size() << " curves\n";); SubCurveListIter i = mylist.begin(); SubCurve *prevSubCurve = 0; //the last SubCurve that was handled; bool are_overlap = false; // are current SubCurve and previous SubCurve overlap while ( i != mylist.end()) { //check overlaping of curren and previous SubCurve if(prevSubCurve && do_curves_overlap(prevSubCurve,*i) ) are_overlap = true; bool flag; if ( reverse ) { flag = CurveStartsAtCurve(*i, c1); if ( flag && (c1->get_last_point() != m_currentEvent->get_point()) ) { SL_DEBUG(std::cout << "CurveStartsAtCurve 3 \n";); m_currentEvent->add_curve_to_right(c1); m_currentEvent->add_curve_to_left(c1, m_prevPos); X_monotone_curve_2 a,b; SL_DEBUG(std::cout << "splitting " << (c1)->get_last_curve() << " at " << m_currentEvent->get_point() << "\n";); if ( (c1)->is_source_left_to_target() ) m_traits->curve_split((c1)->get_last_curve(), a, b, m_currentEvent->get_point()); else m_traits->curve_split((c1)->get_last_curve(), b, a, m_currentEvent->get_point()); if(!are_overlap) { Halfedge_handle h(NULL); h = insert_to_pm(a, c1, h, pm); } (c1)->set_last_point(m_currentEvent->get_point()); (c1)->set_last_curve(b); (c1)->set_last_subcurve(a); (c1)->set_last_event(m_currentEvent); m_tmpOut.push_back(c1); } } else { flag = CurveStartsAtCurve(c1, *i); if ( flag && ((*i)->get_last_point() != m_currentEvent->get_point())) { SL_DEBUG(std::cout << "CurveStartsAtCurve 3 \n";); m_currentEvent->add_curve_to_right(*i); m_currentEvent->add_curve_to_left(*i, m_prevPos); X_monotone_curve_2 a,b; SL_DEBUG(std::cout << "splitting " << (*i)->get_last_curve() << " at " << m_currentEvent->get_point() << "\n";); if ( (*i)->is_source_left_to_target() ) m_traits->curve_split((*i)->get_last_curve(), a, b, m_currentEvent->get_point()); else m_traits->curve_split((*i)->get_last_curve(), b, a, m_currentEvent->get_point()); if(!are_overlap) { Halfedge_handle h(NULL); h = insert_to_pm(a, *i, h, pm); } (*i)->set_last_point(m_currentEvent->get_point()); (*i)->set_last_curve(b); (*i)->set_last_subcurve(a); (*i)->set_last_event(m_currentEvent); m_tmpOut.push_back(*i); } } intersect(c1, *i); prevSubCurve= *i; //update current SubCurve to be the previous ++i; are_overlap = false; } } private: /*! Loop over the curves to the right of the status line and handle them: * - if we are at the beginning of the curve, we insert it to the status * line, then we look if it intersects any of its neighbours. * - if we are at an intersection point between two curves, we add them * to the status line and attempt to intersect them with their neighbours. * - We also check to see if the two intersect again to the right of the point. */ void handle_right_curves(PM &pm, SweepLinePlanarmap &tag) { SL_DEBUG(std::cout << "Handling right curves (" ;); SL_DEBUG(std::cout << m_currentEvent->get_point() << ")\n";); int numRightCurves = m_currentEvent->get_num_right_curves(); if ( numRightCurves == 0 ) //no right cures, return return; m_currentPos = m_sweepLinePos; if ( numRightCurves == 1 ) { SL_DEBUG(std::cout << " - beginning of curve " << std::endl;); SL_DEBUG( Subcurve *tmp1 = *(m_currentEvent->right_curves_begin()); PRINT_INSERT(tmp1); ); StatusLineIter slIter = m_statusLine->insert(m_status_line_insert_hint, *(m_currentEvent->right_curves_begin())); (*(m_currentEvent->right_curves_begin()))->set_hint(slIter); //xxx m_status_line_insert_hint = slIter; ++m_status_line_insert_hint; SL_DEBUG(PrintStatusLine();); // if this is the only curve on the status line, nothing else to do if ( m_statusLine->size() == 1 ) return; StatusLineIter prev = slIter; // the previous neighbour of the curve at the status line StatusLineIter next = slIter; // the next neighbour of the curve at the status line ++next; // 'mylist' will hold the two neighbours of the curve , // and all of their overlapped curves SubCurveList mylist; if ( slIter != m_statusLine->begin() ) { --prev; StatusLineIter tmp = prev; mylist.push_back(*prev); //find all of the curves that overlap with *prev and push them to 'mylist' while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp) ) mylist.push_back(*tmp); else break; } } if ( next != m_statusLine->end() ) { StatusLineIter tmp = next; mylist.push_back(*next); ++tmp; //find all of the curves that overlap with *next and push them to 'mylist' while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp) ) { mylist.push_back(*tmp); ++tmp; } else break; } } intersect_curve_group(*(m_currentEvent->right_curves_begin()), mylist, pm); } else // if we've reached here , numRightCurves > 1 { /* this block takes care of // // / // / // -------- // \ // \ */ int numLeftCurves = m_currentEvent->get_num_left_curves(); if ( numLeftCurves == 0 ) { SL_DEBUG(std::cout << " - handling special case " << std::endl;); StatusLineIter slIter; EventCurveIter currentOne = m_currentEvent->right_curves_begin(); while ( currentOne != m_currentEvent->right_curves_end() ) { //find an iterator to the first Subcurve in the statusLine // that is equal to or greater than currentOne slIter = m_statusLine->lower_bound(*currentOne); if ( slIter != m_statusLine->end() ) { Subcurve *c = *slIter; if ( CurveStartsAtCurve(*currentOne, c)) { m_currentEvent->add_curve_to_left(c, m_sweepLinePos); m_currentEvent->add_curve_to_right(c); X_monotone_curve_2 a,b; if ( c->is_source_left_to_target() ) { m_traits->curve_split(c->get_last_curve(), a, b, m_currentEvent->get_point()); } else { m_traits->curve_split(c->get_last_curve(), b, a, m_currentEvent->get_point()); } Halfedge_handle h(NULL); insert_to_pm(a, c, h, pm); c->set_last_point(m_currentEvent->get_point()); c->set_last_curve(b); c->set_last_event(m_currentEvent); break; } } currentOne++; } } // end block ... ( numLeftCurves == 0 ) SubCurveList mylist; SubCurveList prevlist; SubCurveList currentlist; SL_DEBUG(std::cout << " - intersection point " << std::endl;); EventCurveIter firstOne = m_currentEvent->right_curves_begin(); EventCurveIter lastOne = m_currentEvent->right_curves_end(); --lastOne; EventCurveIter rightCurveEnd = m_currentEvent->right_curves_end(); PRINT_INSERT(*firstOne); StatusLineIter slIter = m_statusLine->insert(m_status_line_insert_hint, *firstOne); (*firstOne)->set_hint(slIter);//xxx SL_DEBUG(PrintStatusLine();); if ( slIter != m_statusLine->begin() ) { StatusLineIter prev = slIter; --prev; // find all curves that are overlapping with the prev curve StatusLineIter tmp = prev; prevlist.push_back(*prev); while ( tmp != m_statusLine->begin() ) { --tmp; if ( do_curves_overlap(*prev, *tmp)) prevlist.push_back(*tmp); else break; } intersect_curve_group(*slIter, prevlist, pm); } currentlist.push_back(*firstOne); EventCurveIter currentOne = firstOne; ++currentOne; EventCurveIter prevOne = firstOne; while ( currentOne != rightCurveEnd ) { m_currentPos = m_sweepLinePos; PRINT_INSERT(*currentOne); ++slIter; slIter = m_statusLine->insert(slIter, *currentOne); (*currentOne)->set_hint(slIter);//xxx SL_DEBUG(PrintStatusLine();); if ( do_curves_overlap(*currentOne, *prevOne)) { intersect_curve_group(*currentOne, currentlist, pm); currentlist.push_back(*currentOne); } else { prevlist = currentlist; currentlist.clear(); currentlist.push_back(*currentOne); } intersect_curve_group(*currentOne, prevlist, pm); prevOne = currentOne; ++currentOne; } m_status_line_insert_hint = slIter; ++m_status_line_insert_hint; lastOne = currentOne; --lastOne; m_currentPos = m_sweepLinePos; PRINT_INSERT(*lastOne); SL_DEBUG(PrintStatusLine();); StatusLineIter next = slIter; ++next; if ( next != m_statusLine->end() ) { intersect_curve_group(*next, currentlist, pm, true); StatusLineIter tmp = next; ++tmp; while ( tmp != m_statusLine->end() ) { if ( do_curves_overlap(*next, *tmp)) { intersect_curve_group(*tmp, currentlist, pm, true); ++tmp; } else break; } } } } /*! Insert a curve to the planar map. * If an identical curve was already inserted into the planarmap, it is * not inserted again. * * @param cv the curve to insert * @param leftCurve the original curve * @param hhandle a prev halfedge handle (may be NULL) * @param pm a reference to the planar map */ Halfedge_handle insert_to_pm(const X_monotone_curve_2 &cv, SubCurve *leftCurve, Halfedge_handle hhandle, PM &pm) { SL_DEBUG(std::cout << "*X inserting " << cv << "(" << leftCurve->getId() << ")\n";); static SubCurve *prevCurve = 0; static X_monotone_curve_2 prevXCv; Event *lastEvent = leftCurve->get_last_event(); PmwxInsertInfo *insertInfo = lastEvent->get_insert_info(); SL_DEBUG(std::cout << "lastEvent = " << lastEvent << "\n"; lastEvent->Print(); insertInfo->Print();); // if this is the same as the previous curve, don't add it again if ( prevCurve && similar_curves(cv, prevXCv)) { leftCurve->set_last_event(m_currentEvent); if ( m_change_not ) { m_change_not->add_edge(cv, hhandle, true, true); } return hhandle; } prevCurve = leftCurve; prevXCv = cv; Halfedge_handle res; SL_DEBUG(std::cout << "get_halfedge_jump_count : curve is " << leftCurve->get_curve() << "\n";); int jump = lastEvent->get_halfedge_jump_count(leftCurve); Point_2 p1, p2; if (m_traits->compare_xy(m_traits->curve_source(cv), m_traits->curve_target(cv)) == SMALLER) { p1 = m_traits->curve_source(cv); p2 = m_traits->curve_target(cv); } else { p2 = m_traits->curve_source(cv); p1 = m_traits->curve_target(cv); } // if the previous event on the curve is not in the planar map yet if ( insertInfo->get_halfedge_handle() == Halfedge_handle(NULL) ) { // we have a handle from the previous insert if ( hhandle != Halfedge_handle(NULL) ) { if ( !m_traits->point_equal( hhandle->target()->point(), p2 )) hhandle = hhandle->twin(); SL_DEBUG(std::cout << " from vertex (1)"; std::cout << hhandle->source()->point() << " " << hhandle->target()->point() << "\n";); res = pm.non_intersecting_insert_from_vertex(cv, hhandle, m_change_not); } else { // if this is the first left curve being inserted SL_DEBUG(std::cout << " in face interior\n";); //// for assertion //Locate_type lt1, lt2; //pm.locate(m_traits->curve_source(cv) , lt1); //pm.locate(m_traits->curve_target(cv) , lt2); //CGAL_assertion((lt1 == PM::UNBOUNDED_FACE) && (lt2 == PM::UNBOUNDED_FACE)); //end assertion res = pm.insert_in_face_interior(cv, pm.unbounded_face(), m_change_not); } } else // the previous event on the curve is already in the planar map. // Let's use it. { Halfedge_handle prev = insertInfo->get_halfedge_handle(); if ( !m_traits->point_equal( prev->target()->point(), p1 )) prev = prev->twin(); // skip to the right halfedge SL_DEBUG(std::cout << "Skipping " << jump << " steps\n";); for ( int i = 0 ; i < jump ; i++ ) prev = (prev->next_halfedge())->twin(); // we have a handle from the previous insert if ( hhandle != Halfedge_handle(NULL) ) { if ( !m_traits->point_equal( hhandle->target()->point(), p2 )) hhandle = hhandle->twin(); //// before calling 'insert_at_vertices' we need to make sure //// that prev->face() == hhandle->face() (and if this is not the case //// we need to change one of the halfedges //if(prev->face() != hhandle->face()) //{ // Halfedge_handle temp_prev , temp_hhandle; // temp_prev = prev->next_halfedge()->twin(); // temp_hhandle = hhandle->next_halfedge()->twin(); // // if(temp_prev->face() == hhandle->face()) // prev = temp_prev; // else // if(prev->face() == temp_hhandle->face()) // hhandle = temp_hhandle; // else // if(temp_prev->face() == temp_hhandle->face()) // { // prev = temp_prev; // hhandle = temp_hhandle; // } // else // CGAL_assertion(prev->face() == hhandle->face()); //} CGAL_assertion(prev->face() == hhandle->face()); SL_DEBUG(std::cout << " at vertices"; std::cout << prev->source()->point() << " " << prev->target()->point() << " --- "; std::cout << hhandle->source()->point() << " " << hhandle->target()->point() << "\n";); res = pm.non_intersecting_insert_at_vertices(cv, prev, hhandle, m_change_not); } else { SL_DEBUG(std::cout << " from vertex (2)"; std::cout << prev->source()->point() << " " << prev->target()->point() << "\n";); res = pm.non_intersecting_insert_from_vertex(cv, prev, m_change_not); } } SL_DEBUG(std::cout << "*** returning: (" << res->source()->point() << " " << res->target()->point() << ")\n\n";); // update the information in the events so they can be used in the future bool exist_vertical = insertInfo->get_vertical_below_event_flag() || insertInfo->get_vertical_above_event_flag(); if ( lastEvent->get_num_left_curves() == 0 && lastEvent->is_curve_largest(leftCurve) && !exist_vertical ) { insertInfo->set_halfedge_handle(res->twin()); } insertInfo = m_currentEvent->get_insert_info(); insertInfo->set_halfedge_handle(res); return res; } void insert_to_pm_v(const X_monotone_curve_2 &a, SubCurve *origCurve, Event *topEvent, Event *bottomEvent, PM &pm); Change_notification *m_change_not; }; /*! Insert a vertical curve to the planar map. * If an identical curve was already inserted into the planarmap, it is * not inserted again. * * @param a the curve * @param origCurve the original curve * @param topEvent a pointer to the event at the top end of the curve * @param bottomEvent a pointer to the event at the bottom end of the curve * @param pm a reference to the planar map */ template void Pmwx_aggregate_insert:: insert_to_pm_v(const X_monotone_curve_2 &cv, SubCurve *origCurve, Event *topEvent, Event *bottomEvent, PM &pm) { SL_DEBUG(std::cout << "insert_to_pm_v \n"; std::cout << "*V inserting " << cv << ")\n";); PmwxInsertInfo *topII = topEvent->get_insert_info(); PmwxInsertInfo *bottomII = bottomEvent->get_insert_info(); Halfedge_handle res; // if the curve is already in the planar map, update the data and return if (vertical_subcurve_exists(cv)) { origCurve->set_last_event(m_currentEvent); SL_DEBUG(std::cout << "*** returning (curve already exists\n\n";); return; } m_verticalSubCurves.push_back(cv); if ( topII->get_halfedge_handle() == Halfedge_handle(NULL)) { if ( bottomII->get_halfedge_handle() == Halfedge_handle(NULL)) { SL_DEBUG(std::cout << " in face interior\n";); //// for assertion //Locate_type lt1, lt2; //pm.locate(m_traits->curve_source(cv) , lt1); //pm.locate(m_traits->curve_target(cv) , lt2); //CGAL_assertion((lt1 == PM::UNBOUNDED_FACE) && (lt2 == PM::UNBOUNDED_FACE)); // //end assertion res = pm.insert_in_face_interior(cv, pm.unbounded_face(), m_change_not); if ( !origCurve->is_source_left_to_target() ){ res = res->twin(); } } else { SL_DEBUG(std::cout << " from vertex (1) "; std::cout << bottomII->get_halfedge_handle()->source()->point() << bottomII->get_halfedge_handle()->target()->point() << "\n";); Halfedge_handle h1 = bottomII->get_halfedge_handle(); if ( h1->target()->point() != m_traits->curve_source(cv) && h1->target()->point() != m_traits->curve_target(cv) ) h1 = h1->twin(); res = pm.non_intersecting_insert_from_vertex(cv, h1, m_change_not); } } else { if ( bottomII->get_halfedge_handle() == Halfedge_handle(NULL)) { SL_DEBUG(std::cout << " from vertex (2) "; std::cout << topII->get_halfedge_handle()->source()->point() << topII->get_halfedge_handle()->target()->point() << "\n";); Halfedge_handle h1 = topII->get_halfedge_handle(); if ( h1->target()->point() != m_traits->curve_source(cv) && h1->target()->point() != m_traits->curve_target(cv) ) h1 = h1->twin(); res = pm.non_intersecting_insert_from_vertex(cv, h1, m_change_not); res = res->twin(); } else { SL_DEBUG(std::cout << " at vertices"; std::cout << bottomII->get_halfedge_handle()->source()->point(); std::cout << bottomII->get_halfedge_handle()->target()->point(); std::cout << topII->get_halfedge_handle()->source()->point(); std::cout << topII->get_halfedge_handle()->target()->point() << "\n";); Halfedge_handle h1 = bottomII->get_halfedge_handle(); Halfedge_handle h2 = topII->get_halfedge_handle(); if ( h1->target()->point() != m_traits->curve_source(cv) && h1->target()->point() != m_traits->curve_target(cv) ) h1 = h1->twin(); if ( h2->target()->point() != m_traits->curve_source(cv) && h2->target()->point() != m_traits->curve_target(cv) ) h2 = h2->twin(); //// before calling 'insert_at_vertices' we need to make sure //// that prev->face() == hhandle->face() (and if this is not the case //// we need to change one of the halfedges //if(h1->face() != h2->face()) //{ // Halfedge_handle temp_h1 , temp_h2; // temp_h1 = h1->next_halfedge()->twin(); // temp_h2 = h2->next_halfedge()->twin(); // // if(temp_h1->face() == h2->face()) // h1 = temp_h1; // else // if(h1->face() == temp_h2->face()) // h2 = temp_h2; // else // if(temp_h1->face() == temp_h2->face()) // { // h1 = temp_h1; // h2 = temp_h2; // } // else // CGAL_assertion(h1->face() == h2->face()); //} CGAL_assertion(h1->face() == h2->face()); res = pm.non_intersecting_insert_at_vertices(cv, h1, h2, m_change_not); } } if ( topEvent->get_num_left_curves() == 0 ) { if(topII->get_vertical_above_event_flag())/*res->twin() != res->next_halfedge()*/ { topII->set_halfedge_handle(res->next_halfedge()->twin()); topII->set_vertical_above_event_flag(true); } else { topII->set_halfedge_handle(res); } } topII->set_vertical_below_event_flag(true); bottomII->set_halfedge_handle(res->twin()); bottomII->set_vertical_above_event_flag(true); SL_DEBUG(std::cout << "*** returning: (" << res->source()->point() << " " << res->target()->point() << ")\n\n";); } CGAL_END_NAMESPACE #endif // CGAL_PMWX_AGGREGATE_INSERT_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_structure_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_str0000644000175000017500000017204511344301501031456 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_structure_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DATA_STRUCTURE_2_H #define CGAL_TRIANGULATION_DATA_STRUCTURE_2_H #include #include #include #include #include #include #include #include #include #if (!defined _MSC_VER || defined __INTEL_COMPILER) && !defined __sgi # define CGAL_T2_USE_ITERATOR_AS_HANDLE #endif #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Vb = Triangulation_ds_vertex_base_2<>, class Fb = Triangulation_ds_face_base_2<> > class Triangulation_data_structure_2 :public Triangulation_cw_ccw_2 { typedef Triangulation_data_structure_2 Tds; typedef typename Vb::template Rebind_TDS::Other Vertex_base; typedef typename Fb::template Rebind_TDS::Other Face_base; friend class Triangulation_ds_edge_iterator_2; friend class Triangulation_ds_face_circulator_2; friend class Triangulation_ds_edge_circulator_2; friend class Triangulation_ds_vertex_circulator_2; public: typedef Triangulation_ds_vertex_2 Vertex; typedef Triangulation_ds_face_2 Face; private: typedef Compact_container Face_container; typedef Compact_container Vertex_container; public: typedef typename Face_container::size_type size_type; typedef typename Face_container::difference_type difference_type; typedef typename Face_container::iterator Face_iterator; typedef typename Vertex_container::iterator Vertex_iterator; typedef Triangulation_ds_edge_iterator_2 Edge_iterator; typedef Triangulation_ds_face_circulator_2 Face_circulator; typedef Triangulation_ds_vertex_circulator_2 Vertex_circulator; typedef Triangulation_ds_edge_circulator_2 Edge_circulator; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE typedef Vertex_iterator Vertex_handle; typedef Face_iterator Face_handle; #else // Defining nested classes for the handles instead of typedefs // considerably shortens the symbol names (and compile times). // It makes error messages more readable as well. class Vertex_handle { Vertex_iterator _v; public: typedef Vertex value_type; typedef value_type * pointer; typedef value_type & reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef void iterator_category; Vertex_handle() : _v() {} Vertex_handle(const Vertex_iterator& v) : _v(v) {} Vertex_handle(const Vertex_circulator& v) : _v(v.base()._v) {} Vertex_handle(void * CGAL_triangulation_precondition_code(n)) : _v() { CGAL_triangulation_precondition(n == NULL); } Vertex* operator->() const { return &*_v; } Vertex& operator*() const { return *_v; } bool operator==(Vertex_handle v) const { return _v == v._v; } bool operator!=(Vertex_handle v) const { return _v != v._v; } // For std::set and co. bool operator<(Vertex_handle v) const { return &*_v < &*v._v; } // Should be private to the TDS : const Vertex_iterator & base() const { return _v; } Vertex_iterator & base() { return _v; } void * for_compact_container() const { return _v.for_compact_container(); } void * & for_compact_container() { return _v.for_compact_container(); } }; class Face_handle { Face_iterator _f; public: typedef Face value_type; typedef value_type * pointer; typedef value_type & reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef void iterator_category; Face_handle() : _f() {} Face_handle(const Face_iterator& f) : _f(f) {} Face_handle(const Face_circulator& f) : _f(f.base()._f) {} //Face_handle(Face_circulator f) : _f(f.base()._f) {} Face_handle(void * CGAL_triangulation_precondition_code(n)) : _f() { CGAL_triangulation_precondition(n == NULL); } Face* operator->() const { return &*_f; } Face& operator*() const { return *_f; } bool operator==(Face_handle f) const { return _f == f._f; } bool operator!=(Face_handle f) const { return _f != f._f; } // For std::set and co. bool operator<(Face_handle f) const { return &*_f < &*f._f; } // These should be private to the TDS : const Face_iterator & base() const { return _f; } Face_iterator & base() { return _f; } void * for_compact_container() const { return _f.for_compact_container(); } void * & for_compact_container() { return _f.for_compact_container(); } }; #endif typedef std::pair Edge; typedef std::list List_edges; protected: int _dimension; Face_container _face_container; Vertex_container _vertex_container; //CREATORS - DESTRUCTORS public: Triangulation_data_structure_2(); Triangulation_data_structure_2(const Tds &tds); ~Triangulation_data_structure_2(); Tds& operator= (const Tds &tds); void swap(Tds &tds); //ACCESS FUNCTIONS private: // We need the const_cast<>s because TDS is not const-correct. Face_container& face_container() { return _face_container;} Face_container& face_container() const { return const_cast(this)->_face_container;} Vertex_container& vertex_container() {return _vertex_container;} Vertex_container& vertex_container() const {return const_cast(this)->_vertex_container;} public: int dimension() const { return _dimension; } size_type number_of_vertices() const {return vertex_container().size();} size_type number_of_faces() const ; size_type number_of_edges() const; size_type number_of_full_dim_faces() const; //number of faces stored by tds // TEST FEATURES bool is_vertex(Vertex_handle v) const; bool is_edge(Face_handle fh, int i) const; bool is_edge(Vertex_handle va, Vertex_handle vb) const; bool is_edge(Vertex_handle va, Vertex_handle vb, Face_handle& fr, int& i) const; bool is_face(Face_handle fh) const; bool is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) const; bool is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle& fr) const; // ITERATORS AND CIRCULATORS public: // The face_iterator_base_begin gives the possibility to iterate over all // faces in the container independently of the dimension. // public for the need of file_ouput() of Constrained triangulation // should be made private later Face_iterator face_iterator_base_begin() const { return face_container().begin(); } Face_iterator face_iterator_base_end() const { return face_container().end(); } public: Face_iterator faces_begin() const { if (dimension() < 2) return faces_end(); return face_container().begin(); } Face_iterator faces_end() const { return face_container().end(); } Vertex_iterator vertices_begin() const { return vertex_container().begin(); } Vertex_iterator vertices_end() const { return vertex_container().end(); } Edge_iterator edges_begin() const { return Edge_iterator(this); } Edge_iterator edges_end() const { return Edge_iterator(this,1); } Face_circulator incident_faces(Vertex_handle v, Face_handle f = Face_handle()) const{ return Face_circulator(v,f); } Vertex_circulator incident_vertices(Vertex_handle v, Face_handle f = Face_handle()) const { return Vertex_circulator(v,f); } Edge_circulator incident_edges(Vertex_handle v, Face_handle f = Face_handle()) const{ return Edge_circulator(v,f); } // MODIFY void flip(Face_handle f, int i); Vertex_handle insert_first(); Vertex_handle insert_second(); Vertex_handle insert_in_face(Face_handle f); Vertex_handle insert_in_edge(Face_handle f, int i); Vertex_handle insert_dim_up(Vertex_handle w = Vertex_handle(), bool orient=true); void remove_degree_3(Vertex_handle v, Face_handle f = Face_handle()); void remove_1D(Vertex_handle v); void remove_second(Vertex_handle v); void remove_first(Vertex_handle v); void remove_dim_down(Vertex_handle v); Vertex_handle star_hole(List_edges& hole); void star_hole(Vertex_handle v, List_edges& hole); void make_hole(Vertex_handle v, List_edges& hole); // template< class EdgeIt> // Vertex_handle star_hole(EdgeIt edge_begin,EdgeIt edge_end); // template< class EdgeIt> // void star_hole(Vertex_handle v, EdgeIt edge_begin, EdgeIt edge_end); // template< class EdgeIt, class FaceIt> // Vertex_handle star_hole(EdgeIt edge_begin, // EdgeIt edge_end, // FaceIt face_begin, // FaceIt face_end); // template< class EdgeIt, class FaceIt> // void star_hole(Vertex_handle v, // EdgeIt edge_begin, // EdgeIt edge_end, // FaceIt face_begin, // FaceIt face_end); Vertex_handle create_vertex(const Vertex &v = Vertex()); Vertex_handle create_vertex(Vertex_handle v); //calls copy constructor Face_handle create_face(const Face& f = Face()); Face_handle create_face(Face_handle f); //calls copy constructor Face_handle create_face(Face_handle f1, int i1, Face_handle f2, int i2, Face_handle f3, int i3); Face_handle create_face(Face_handle f1, int i1, Face_handle f2, int i2); Face_handle create_face(Face_handle f1, int i1, Vertex_handle v); Face_handle create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3); Face_handle create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle f1, Face_handle f2, Face_handle f3); void set_adjacency(Face_handle f0, int i0, Face_handle f1, int i1) const; void delete_face(Face_handle); void delete_vertex(Vertex_handle); // split and join operations protected: Vertex_handle join_vertices(Face_handle f, int i, Vertex_handle v); typedef boost::tuples::tuple Fourtuple; public: Fourtuple split_vertex(Vertex_handle v, Face_handle f1, Face_handle g1); inline Vertex_handle join_vertices(Face_handle f, int i) { return join_vertices(f, i, f->vertex( ccw(i) )); } inline Vertex_handle join_vertices(Edge e) { return join_vertices(e.first, e.second); } inline Vertex_handle join_vertices(Edge_iterator eit) { return join_vertices(*eit); } inline Vertex_handle join_vertices(Edge_circulator ec) { return join_vertices(*ec); } // insert_degree_2 and remove_degree_2 operations Vertex_handle insert_degree_2(Face_handle f, int i); void remove_degree_2(Vertex_handle v); // CHECKING bool is_valid(bool verbose = false, int level = 0) const; // HELPING private: typedef std::pair Vh_pair; void set_adjacency(Face_handle fh, int ih, std::map< Vh_pair, Edge>& edge_map); void reorient_faces(); public: void clear(); Vertex_handle copy_tds(const Tds &tds, Vertex_handle = Vertex_handle()); // I/O Vertex_handle file_input(std::istream& is, bool skip_first=false); void file_output(std::ostream& os, Vertex_handle v = Vertex_handle(), bool skip_first=false) const; Vertex_handle off_file_input(std::istream& is, bool verbose=false); void vrml_output(std::ostream& os, Vertex_handle v = Vertex_handle(), bool skip_first=false) const; // SETTING (had to make them public for use in remove from Triangulations) void set_dimension (int n) {_dimension = n ;} // template members definition public: template< class EdgeIt> Vertex_handle star_hole(EdgeIt edge_begin, EdgeIt edge_end) // creates a new vertex // and stars from it // the hole described by the range [edge_begin,edge_end[ // the triangulation is assumed to have dim=2 // hole is supposed to be ccw oriented { Vertex_handle newv = create_vertex(); star_hole(newv, edge_begin, edge_end); return newv; } template< class EdgeIt> void star_hole(Vertex_handle v, EdgeIt edge_begin, EdgeIt edge_end) // uses vertex v // to star the hole described by the range [edge_begin,edge_end[ // the triangulation is assumed to have dim=2 // the hole is supposed to be ccw oriented { std::list empty_list; star_hole(v, edge_begin, edge_end, empty_list.begin(), empty_list.end()); return; } template< class EdgeIt, class FaceIt> Vertex_handle star_hole(EdgeIt edge_begin, EdgeIt edge_end, FaceIt face_begin, FaceIt face_end) // creates a new vertex // and stars from it // the hole described by the range [edge_begin,edge_end[ // reusing the faces in the range [face_begin,face_end[ // the triangulation is assumed to have dim=2 // the hole is supposed to be ccw oriented { Vertex_handle newv = create_vertex(); star_hole(newv, edge_begin, edge_end, face_begin, face_end); return newv; } template< class EdgeIt, class FaceIt> void star_hole(Vertex_handle newv, EdgeIt edge_begin, EdgeIt edge_end, FaceIt face_begin, FaceIt face_end) // uses vertex v // to star the hole described by the range [edge_begin,edge_end[ // reusing the faces in the range [face_begin,face_end[ // the triangulation is assumed to have dim=2 // hole is supposed to be ccw oriented { CGAL_triangulation_precondition(dimension() == 2); EdgeIt eit = edge_begin; FaceIt fit = face_begin; Face_handle fn = (*eit).first; int in = (*eit).second; fn->vertex(cw(in))->set_face(fn); Face_handle first_f = reset_or_create_face(fn, in , newv, fit, face_end); Face_handle previous_f=first_f, next_f; ++eit; for( ; eit != edge_end ; eit++) { fn = (*eit).first; in = (*eit).second; fn->vertex(cw(in))->set_face(fn); next_f = reset_or_create_face(fn, in , newv, fit, face_end); next_f->set_neighbor(1, previous_f); previous_f->set_neighbor(0, next_f); previous_f=next_f; } next_f->set_neighbor(0, first_f); first_f->set_neighbor(1, next_f); newv->set_face(first_f); return; } private: template< class FaceIt> Face_handle reset_or_create_face(Face_handle fn, int in, Vertex_handle v, FaceIt& fit, const FaceIt& face_end) { if (fit == face_end) return create_face(fn, in, v); (*fit)->set_vertices(fn->vertex(cw(in)), fn->vertex(ccw(in)), v); (*fit)->set_neighbors(Face_handle(),Face_handle(),fn); fn->set_neighbor(in, *fit); return *fit++; } }; //for backward compatibility template < class Gt , class Vb, class Fb> class Triangulation_default_data_structure_2 : public Triangulation_data_structure_2 { public: typedef Triangulation_data_structure_2 Tds; typedef Triangulation_default_data_structure_2 Tdds; typedef Gt Geom_traits; Triangulation_default_data_structure_2(const Geom_traits& gt=Geom_traits()) : Tds() {} Triangulation_default_data_structure_2(const Tdds &tdds) : Tds(tdds) {} }; //for backward compatibility template class Triangulation_data_structure_using_list_2 :public Triangulation_data_structure_2 { public: typedef Triangulation_data_structure_2 Tds; typedef Triangulation_data_structure_using_list_2 Tdsul; Triangulation_data_structure_using_list_2(): Tds() {} Triangulation_data_structure_using_list_2(const Tdsul &tdsul) : Tds(tdsul) {} }; template < class Vb, class Fb> Triangulation_data_structure_2 :: Triangulation_data_structure_2() : _dimension(-2) { } template < class Vb, class Fb> Triangulation_data_structure_2 :: Triangulation_data_structure_2(const Tds &tds) { copy_tds(tds); } template < class Vb, class Fb> Triangulation_data_structure_2 :: ~Triangulation_data_structure_2() { clear(); } //assignement template < class Vb, class Fb> Triangulation_data_structure_2& Triangulation_data_structure_2 :: operator= (const Tds &tds) { copy_tds(tds); return *this; } template < class Vb, class Fb> void Triangulation_data_structure_2:: clear() { face_container().clear(); vertex_container().clear(); set_dimension(-2); return; } template < class Vb, class Fb> void Triangulation_data_structure_2:: swap(Tds &tds) { CGAL_triangulation_expensive_precondition(tds.is_valid() && is_valid()); std::swap(_dimension, tds._dimension); face_container().swap(tds.face_container()); vertex_container().swap(tds.vertex_container()); return; } //ACCESS FUNCTIONS template inline typename Triangulation_data_structure_2::size_type Triangulation_data_structure_2 :: number_of_faces() const { if (dimension() < 2) return 0; return face_container().size(); } template inline typename Triangulation_data_structure_2::size_type Triangulation_data_structure_2:: number_of_edges() const { switch (dimension()) { case 1: return number_of_vertices(); case 2: return 3*number_of_faces()/2; default: return 0; } } template typename Triangulation_data_structure_2::size_type Triangulation_data_structure_2:: number_of_full_dim_faces() const { return face_container().size(); } template inline bool Triangulation_data_structure_2:: is_vertex(Vertex_handle v) const { Vertex_iterator vit = vertices_begin(); while (vit != vertices_end() && v != vit) ++vit; return v == vit; } template inline bool Triangulation_data_structure_2:: is_edge(Face_handle fh, int i) const { if ( dimension() == 0 ) return false; if ( dimension() == 1 && i != 2) return false; if (i > 2) return false; Face_iterator fit = face_iterator_base_begin(); while (fit != face_iterator_base_end() && fh != fit ) ++fit; return fh == fit; } template bool Triangulation_data_structure_2:: is_edge(Vertex_handle va, Vertex_handle vb) const // returns true (false) if the line segment ab is (is not) an edge of t //It is assumed that va is a vertex of t { Vertex_circulator vc = incident_vertices(va), done(vc); if ( vc == 0) return false; do { if( vb == vc ) {return true;} } while (++vc != done); return false; } template bool Triangulation_data_structure_2:: is_edge(Vertex_handle va, Vertex_handle vb, Face_handle &fr, int & i) const // assume va is a vertex of t // returns true (false) if the line segment ab is (is not) an edge of t // if true is returned (fr,i) is the edge ab // with face fr on the right of a->b { Face_handle fc = va->face(); Face_handle start = fc; if (fc == 0) return false; int inda, indb; do { inda=fc->index(va); indb = (dimension() == 2 ? cw(inda) : 1-inda); if(fc->vertex(indb) == vb) { fr=fc; i = 3 - inda - indb; //works in dim 1 or 2 return true; } fc=fc->neighbor(indb); //turns ccw around va } while (fc != start); return false; } template inline bool Triangulation_data_structure_2:: is_face(Face_handle fh) const { if (dimension() < 2) return false; Face_iterator fit = faces_begin(); while (fit != faces_end() && fh != fit ) ++fit; return fh == fit; } template inline bool Triangulation_data_structure_2:: is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) const { Face_handle f; return is_face(v1,v2,v3,f); } template bool Triangulation_data_structure_2:: is_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle &f) const { if (dimension() != 2) return false; int i; bool b = is_edge(v1,v2,f,i); if (!b) return false; else if (v3== f->vertex(i)) return true; f = f-> neighbor(i); int ind1= f->index(v1); int ind2= f->index(v2); if (v3 == f->vertex(3-ind1-ind2)) { return true;} return false; } template void Triangulation_data_structure_2:: flip(Face_handle f, int i) { CGAL_triangulation_precondition( dimension()==2); Face_handle n = f->neighbor(i); int ni = f->mirror_index(i); //ni = n->index(f); Vertex_handle v_cw = f->vertex(cw(i)); Vertex_handle v_ccw = f->vertex(ccw(i)); // bl == bottom left, tr == top right Face_handle tr = f->neighbor(ccw(i)); int tri = f->mirror_index(ccw(i)); Face_handle bl = n->neighbor(ccw(ni)); int bli = n->mirror_index(ccw(ni)); f->set_vertex(cw(i), n->vertex(ni)); n->set_vertex(cw(ni), f->vertex(i)); // update the neighborhood relations f->set_neighbor(i, bl); bl->set_neighbor(bli, f); f->set_neighbor(ccw(i), n); n->set_neighbor(ccw(ni), f); n->set_neighbor(ni, tr); tr->set_neighbor(tri, n); if(v_cw->face() == f) { v_cw->set_face(n); } if(v_ccw->face() == n) { v_ccw->set_face(f); } } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: insert_first( ) { CGAL_triangulation_precondition( number_of_vertices() == 0 && dimension()==-2 ); return insert_dim_up(); } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: insert_second() { CGAL_triangulation_precondition( number_of_vertices() == 1 && dimension()==-1 ); return insert_dim_up(); } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: insert_in_face(Face_handle f) // New vertex will replace f->vertex(0) in face f { CGAL_triangulation_precondition( f != Face_handle() && dimension()== 2); Vertex_handle v = create_vertex(); Vertex_handle v0 = f->vertex(0); Vertex_handle v2 = f->vertex(2); Vertex_handle v1 = f->vertex(1); Face_handle n1 = f->neighbor(1); Face_handle n2 = f->neighbor(2); Face_handle f1 = create_face(v0, v, v2, f, n1, Face_handle()); Face_handle f2 = create_face(v0, v1, v, f, Face_handle(), n2); f1->set_neighbor(2, f2); f2->set_neighbor(1, f1); if (n1 != Face_handle()) { int i1 = f->mirror_index(1); //int i1 = n1->index(f); n1->set_neighbor(i1,f1); } if (n2 != Face_handle()) { int i2 = f->mirror_index(2);//int i2 = n2->index(f); n2->set_neighbor(i2,f2);} f->set_vertex(0, v); f->set_neighbor(1, f1); f->set_neighbor(2, f2); if( v0->face() == f ) { v0->set_face(f2); } v->set_face(f); return v; } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: insert_in_edge(Face_handle f, int i) //insert in the edge opposite to vertex i of face f { CGAL_triangulation_precondition(f != Face_handle() && dimension() >= 1); if (dimension() == 1) {CGAL_triangulation_precondition(i == 2);} if (dimension() == 2) {CGAL_triangulation_precondition(i == 0 || i == 1 || i == 2);} Vertex_handle v; if (dimension() == 1) { v = create_vertex(); Face_handle ff = f->neighbor(0); Vertex_handle vv = f->vertex(1); Face_handle g = create_face(v,vv,Vertex_handle(),ff, f, Face_handle()); f->set_vertex(1,v);f->set_neighbor(0,g); ff->set_neighbor(1,g); v->set_face(g); vv->set_face(ff); } else { //dimension() ==2 Face_handle n = f->neighbor(i); int in = f->mirror_index(i); //n->index(f); v = insert_in_face(f); flip(n,in); } return v; } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: insert_dim_up(Vertex_handle w, bool orient) { // the following function insert // a vertex v which is outside the affine hull of Tds // The triangulation will be starred from v and w // ( geometrically w= // the infinite vertex ) // w=NULL for first and second insertions // orient governs the orientation of the resulting triangulation Vertex_handle v = create_vertex(); set_dimension( dimension() + 1); Face_handle f1; Face_handle f2; switch (dimension()) { //it is the resulting dimension case -1: f1 = create_face(v,Vertex_handle(),Vertex_handle()); v->set_face(f1); break; case 0 : f1 = face_iterator_base_begin(); f2 = create_face(v,Vertex_handle(),Vertex_handle()); f1->set_neighbor(0,f2); f2->set_neighbor(0,f1); v->set_face(f2); break; case 1 : case 2 : { std::list faces_list; Face_iterator ib= face_iterator_base_begin(); Face_iterator ib_end = face_iterator_base_end(); for (; ib != ib_end ; ++ib){ faces_list.push_back( ib); } std::list to_delete; typename std::list::iterator lfit = faces_list.begin(); int i = dimension(); // maximun non NULL index in faces Face_handle f, g; for ( ; lfit != faces_list.end() ; ++lfit) { f = * lfit; g = create_face(f); //calls copy constructor of face f->set_vertex(i,v); f->set_neighbor(i,g); g->set_vertex(i,w); g->set_neighbor(i,f); if (f->has_vertex(w)) to_delete.push_back(g); // flat face to delete } lfit = faces_list.begin(); for ( ; lfit != faces_list.end() ; ++lfit) { f = * lfit; g = f->neighbor(i); for(int j = 0; j < i ; ++j) { g->set_neighbor(j, f->neighbor(j)->neighbor(i)); } } // couldn't unify the code for reorientation mater lfit = faces_list.begin() ; if (dimension() == 1){ if (orient) { (*lfit)->reorient(); ++lfit ; (*lfit)->neighbor(1)->reorient(); } else { (*lfit)->neighbor(1)->reorient(); ++lfit ; (*lfit)->reorient(); } } else { // dimension == 2 for( ;lfit != faces_list.end(); ++lfit ) { if (orient) {(*lfit)->neighbor(2)->reorient();} else { (*lfit)->reorient();} } } lfit = to_delete.begin(); int i1, i2; for ( ;lfit != to_delete.end(); ++lfit){ f = *lfit ; int j ; if (f->vertex(0) == w) {j=0;} else {j=1;} f1= f->neighbor(i); i1= f->mirror_index(i); //f1->index(f); f2= f->neighbor(j); i2= f->mirror_index(j); //f2->index(f); f1->set_neighbor(i1,f2); f2->set_neighbor(i2,f1); delete_face(f); } v->set_face( *(faces_list.begin())); } break; default: CGAL_triangulation_assertion(false); break; } return v; } template void Triangulation_data_structure_2:: remove_degree_3(Vertex_handle v, Face_handle f) // remove a vertex of degree 3 { CGAL_triangulation_precondition(v != Vertex_handle()); CGAL_triangulation_precondition(v->degree() == 3); if (f == Face_handle()) {f= v->face();} else { CGAL_triangulation_assertion( f->has_vertex(v));} int i = f->index(v); Face_handle left = f->neighbor(cw(i)); int li = f->mirror_index(cw(i)); Face_handle right = f->neighbor(ccw(i)); int ri = f->mirror_index(ccw(i)); Face_handle ll, rr; Vertex_handle q = left->vertex(li); CGAL_triangulation_assertion( left->vertex(li) == right->vertex(ri)); ll = left->neighbor(cw(li)); if(ll != Face_handle()) { int lli = left->mirror_index(cw(li)); ll->set_neighbor(lli, f); } f->set_neighbor(cw(i), ll); if (f->vertex(ccw(i))->face() == left) f->vertex(ccw(i))->set_face(f); rr = right->neighbor(ccw(ri)); if(rr != Face_handle()) { int rri = right->mirror_index(ccw(ri)); //rr->index(right); rr->set_neighbor(rri, f); } f->set_neighbor(ccw(i), rr); if (f->vertex(cw(i))->face() == right) f->vertex(cw(i))->set_face(f); f->set_vertex(i, q); if (q->face() == right || q->face() == left) { q->set_face(f); } delete_face(right); delete_face(left); delete_vertex(v); } template void Triangulation_data_structure_2:: remove_dim_down(Vertex_handle v) { Face_handle f; switch( dimension()){ case -1: delete_face(v->face()); break; case 0: f = v->face(); f->neighbor(0)->set_neighbor(0,Face_handle()); delete_face(v->face()); break; case 1: case 2: CGAL_triangulation_precondition ( (dimension() == 1 && number_of_vertices() == 3) || (dimension() == 2 && number_of_vertices() > 3) ); // the faces incident to v are down graded one dimension // the other faces are deleted std::list to_delete; std::list to_downgrade; Face_iterator ib = face_iterator_base_begin(); for( ; ib != face_iterator_base_end(); ++ib ){ if ( ! ib->has_vertex(v) ) { to_delete.push_back(ib);} else { to_downgrade.push_back(ib);} } typename std::list::iterator lfit = to_downgrade.begin(); int j; for( ; lfit != to_downgrade.end() ; ++lfit) { f = *lfit; j = f->index(v); if (dimension() == 1) { if (j == 0) f->reorient(); f->set_vertex(1,Vertex_handle()); f->set_neighbor(1, Face_handle()); } else { //dimension() == 2 if (j == 0) f->cw_permute(); else if(j == 1) f->ccw_permute(); f->set_vertex(2, Vertex_handle()); f->set_neighbor(2, Face_handle()); } f->vertex(0)->set_face(f); } lfit = to_delete.begin(); for( ; lfit != to_delete.end() ; ++lfit) { delete_face(*lfit); } } delete_vertex(v); set_dimension(dimension() -1); return; } template < class Vb, class Fb> void Triangulation_data_structure_2:: remove_1D(Vertex_handle v) { CGAL_triangulation_precondition( dimension() == 1 && number_of_vertices() > 3); Face_handle f = v->face(); int i = f->index(v); if (i==0) {f = f->neighbor(1);} CGAL_triangulation_assertion( f->index(v) == 1); Face_handle g= f->neighbor(0); f->set_vertex(1, g->vertex(1)); f->set_neighbor(0,g->neighbor(0)); g->neighbor(0)->set_neighbor(1,f); g->vertex(1)->set_face(f); delete_face(g); delete_vertex(v); return; } template inline void Triangulation_data_structure_2:: remove_second(Vertex_handle v) { CGAL_triangulation_precondition(number_of_vertices()== 2 && dimension() == 0); remove_dim_down(v); return; } template inline void Triangulation_data_structure_2:: remove_first(Vertex_handle v) { CGAL_triangulation_precondition(number_of_vertices()== 1 && dimension() == -1); remove_dim_down(v); return; } template inline typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: star_hole(List_edges& hole) { Vertex_handle newv = create_vertex(); star_hole(newv, hole); return newv; } template void Triangulation_data_structure_2:: star_hole(Vertex_handle newv, List_edges& hole) // star the hole represented by hole around newv // the triangulation is assumed to have dim=2 // hole is supposed to be ccw oriented { star_hole(newv, hole.begin(), hole.end()); return; } template void Triangulation_data_structure_2:: make_hole(Vertex_handle v, List_edges& hole) // delete the faces incident to v and v // and return the dscription of the hole in hole { CGAL_triangulation_precondition(dimension() == 2); std::list to_delete; Face_handle f, fn; int i =0, in =0; Vertex_handle vv; Face_circulator fc = incident_faces(v); Face_circulator done(fc); do { f = fc ; i = f->index(v); fn = f->neighbor(i); in = f->mirror_index(i); //fn->index(f); vv = f->vertex(cw(i)); if( vv->face()== f) vv->set_face(fn); vv = fc->vertex(ccw(i)); if( vv->face()== f) vv->set_face(fn); fn->set_neighbor(in, Face_handle()); hole.push_back(Edge(fn,in)); to_delete.push_back(f); } while(++fc != done); while (! to_delete.empty()){ delete_face(to_delete.front()); to_delete.pop_front(); } delete_vertex(v); return; } template inline typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: create_vertex(const Vertex &v) { return vertex_container().insert(v); } template inline typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: create_vertex(Vertex_handle vh) { return vertex_container().insert(*vh); } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face(const Face& f) { return face_container().insert(f); } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face( Face_handle fh) { return create_face(*fh); } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face(Face_handle f1, int i1, Face_handle f2, int i2, Face_handle f3, int i3) { Face_handle newf = face_container().construct_insert(f1->vertex(cw(i1)), f2->vertex(cw(i2)), f3->vertex(cw(i3)), f2, f3, f1); f1->set_neighbor(i1,newf); f2->set_neighbor(i2,newf); f3->set_neighbor(i3,newf); return newf; } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face(Face_handle f1, int i1, Face_handle f2, int i2) { Face_handle newf = face_container().construct_insert(f1->vertex(cw(i1)), f2->vertex(cw(i2)), f2->vertex(ccw(i2)), f2, Face_handle(), f1); f1->set_neighbor(i1,newf); f2->set_neighbor(i2,newf); return newf; } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face(Face_handle f1, int i1, Vertex_handle v) { Face_handle newf = create_face(); newf->set_vertices(f1->vertex(cw(i1)), f1->vertex(ccw(i1)), v); newf->set_neighbors(Face_handle(), Face_handle(), f1); f1->set_neighbor(i1,newf); return newf; } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) { Face_handle newf = face_container().construct_insert(v1, v2, v3); return newf; } template typename Triangulation_data_structure_2::Face_handle Triangulation_data_structure_2:: create_face(Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Face_handle f1, Face_handle f2, Face_handle f3) { Face_handle newf = face_container().construct_insert(v1, v2, v3, f1, f2, f3); return(newf); } template inline void Triangulation_data_structure_2:: set_adjacency(Face_handle f0, int i0, Face_handle f1, int i1) const { CGAL_triangulation_assertion(i0 >= 0 && i0 <= dimension()); CGAL_triangulation_assertion(i1 >= 0 && i1 <= dimension()); CGAL_triangulation_assertion(f0 != f1); f0->set_neighbor(i0,f1); f1->set_neighbor(i1,f0); } template inline void Triangulation_data_structure_2:: delete_face(Face_handle f) { CGAL_triangulation_expensive_precondition( dimension() != 2 || is_face(f)); CGAL_triangulation_expensive_precondition( dimension() != 1 || is_edge(f,2)); CGAL_triangulation_expensive_precondition( dimension() != 0 || is_vertex(f->vertex(0)) ); #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE face_container().erase(f); #else face_container().erase(f.base()); #endif } template inline void Triangulation_data_structure_2:: delete_vertex(Vertex_handle v) { CGAL_triangulation_expensive_precondition( is_vertex(v) ); #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE vertex_container().erase(v); #else vertex_container().erase(v.base()); #endif } // split and join operations template typename Triangulation_data_structure_2::Fourtuple Triangulation_data_structure_2:: split_vertex(Vertex_handle v, Face_handle f1, Face_handle g1) { /* // The following method preforms a split operation of the vertex v // using the faces f1 and g1. The split operation is shown // below. // The names of the variables in the method correspond to the // quantities in the drawings below // // The configuration before the split: // // cw(i1) v3 ccw(i2) // *-----*-----* // / \ | / \ // / \ f1|f2 / \ // / \ | / \ // / \ | / \ // / \|/v \ // *-----------*-----------* // \ /|\ / // \ / | \ / // \ / | \ / // \ / g2|g1 \ / // \ / | \ / // *-----*-----* // ccw(j2) v4 cw(j1) // // // The configuration after the split: // // // cw(i1) v3 ccw(i2) // *---------*---------* // / \ / \ / \ // / \ f1 / \ f2 / \ // / \ / f \ / \ // / \ / v2\ / \ // *---------*---------*---------* // \ / \v1 / \ / // \ / \ g / \ / // \ / g2 \ / g1 \ / // \ / \ / \ / // *---------*---------* // ccw(j2) v4 cw(j1) // */ CGAL_triangulation_expensive_precondition( is_valid() ); CGAL_triangulation_precondition( dimension() == 2 ); CGAL_triangulation_precondition( f1 != Face_handle() && f1->has_vertex(v) ); CGAL_triangulation_precondition( g1 != Face_handle() && g1->has_vertex(v) ); // 1. first we read some information that we will need int i1 = f1->index(v); int j1 = g1->index(v); Face_handle f2 = f1->neighbor( cw(i1) ); Face_handle g2 = g1->neighbor( cw(j1) ); int i2 = f2->index(v); int j2 = g2->index(v); Vertex_handle v3 = f1->vertex( ccw(i1) ); Vertex_handle v4 = g1->vertex( ccw(j1) ); // lst is the list of faces adjecent to v stored in // counterclockwise order from g2 to f1) inclusive. // the list idx contains the indices of v in the // faces in lst. std::list lst; std::list idx; Face_circulator fc(v, g1); Face_handle ff(fc); while ( ff != f2 ) { lst.push_back( ff ); idx.push_back( ff->index(v) ); fc++; ff = Face_handle(fc); } lst.push_back( ff ); idx.push_back( ff->index(v) ); // 2. we create the new vertices and the two new faces Vertex_handle v1 = v; Vertex_handle v2 = create_vertex(); Face_handle f = create_face(v1, v2, v3); Face_handle g = create_face(v2, v1, v4); // 3. we update the adjacency information for the new vertices and // the new faces f->set_neighbor(0, f2); f->set_neighbor(1, f1); f->set_neighbor(2, g); g->set_neighbor(0, g2); g->set_neighbor(1, g1); g->set_neighbor(2, g); v1->set_face(f); v2->set_face(g); // 4. update the vertex for the faces f2 through g1 in // counterclockwise order typename std::list::iterator fit = lst.begin(); typename std::list::iterator iit = idx.begin(); for (; fit != lst.end(); ++fit, ++iit) { (*fit)->set_vertex(*iit, v2); } lst.clear(); idx.clear(); // 5. make f and g the new neighbors of f1, f2 and g1, g2 // respectively. f1->set_neighbor( cw(i1), f ); f2->set_neighbor( ccw(i2), f ); g1->set_neighbor( cw(j1), g ); g2->set_neighbor( ccw(j2), g ); CGAL_triangulation_expensive_postcondition( is_valid() ); // 6. return the new stuff return Fourtuple(v1, v2, f, g); } template typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: join_vertices(Face_handle f, int i, Vertex_handle v) { CGAL_triangulation_expensive_precondition( is_valid() ); CGAL_triangulation_precondition( f != Face_handle() ); CGAL_triangulation_precondition( i >= 0 && i <= 2 ); // this methods does the "join"-operation and preserves // the vertex v among the two vertices that define the edge (f, i) Vertex_handle v1 = f->vertex( ccw(i) ); Vertex_handle v2 = f->vertex( cw(i) ); CGAL_triangulation_precondition( v == v1 || v == v2 ); if ( v == v2 ) { return join_vertices(f->neighbor(i), f->mirror_index(i), v); } int deg2 = v2->degree(); CGAL_triangulation_precondition( deg2 >= 3 ); if ( deg2 == 3 ) { remove_degree_3(v2, f); return v1; } if ( deg2 == 2 ) { remove_degree_2(v2); return v1; } /* // The following drawing corrsponds to the variables // used in this part... // The vertex v1 is returned... // // itl i=v3 itr // *---------*---------* // \ / \ / // \ tl / \ tr / // \ / f \ / // \ / \ / // v1=ccw(i) *---------* cw(i)=v2 // / \ / \ // / \ g / \ // / bl \ / br \ // / \ / \ // *---------*---------* // ibl j=v4 ibr // // The situation after the "join"-operation is as follows: // // i // *-----*-----* // \ | / // \ tl|tr / // \ | / // \ | / // \|/ // * v1 // /|\ // / | \ // / | \ // / bl|br \ // / | \ // *-----*-----* // */ // first we register all the needed info Face_handle g = f->neighbor(i); int j = f->mirror_index(i); Face_handle tl = f->neighbor( cw(i) ); Face_handle tr = f->neighbor( ccw(i) ); int itl = f->mirror_index( cw(i) ); int itr = f->mirror_index( ccw(i) ); Face_handle bl = g->neighbor( ccw(j) ); Face_handle br = g->neighbor( cw(j) ); int ibl = g->mirror_index( ccw(j) ); int ibr = g->mirror_index( cw(j) ); // we need to store the faces adjacent to v2 as well as the // indices of v2 w.r.t. these faces, so that afterwards we can set // v1 to be the vertex for these faces std::vector star_faces_of_v2; std::vector star_indices_of_v2; Face_circulator fc_start(v2); Face_circulator fc = fc_start; do { Face_handle ff(fc); star_faces_of_v2.push_back(ff); star_indices_of_v2.push_back(ff->index(v2)); ++fc; } while ( fc != fc_start ); CGAL_triangulation_assertion( int(star_faces_of_v2.size()) == deg2 ); // from this point and on we modify the values // first set the neighbors tl->set_neighbor(itl, tr); tr->set_neighbor(itr, tl); bl->set_neighbor(ibl, br); br->set_neighbor(ibr, bl); // make sure that all the faces containing v2 as a vertex, now // contain v1 for (unsigned int k = 0; k < star_faces_of_v2.size(); k++) { int id = star_indices_of_v2[k]; CGAL_triangulation_assertion( star_faces_of_v2[k]->vertex(id) == v2 ); star_faces_of_v2[k]->set_vertex( id, v1 ); } // then make sure that all the vertices have correct pointers to // faces Vertex_handle v3 = f->vertex(i); Vertex_handle v4 = g->vertex(j); if ( v3->face() == f ) v3->set_face(tr); if ( v4->face() == g ) v4->set_face(br); if ( v1->face() == f || v1->face() == g ) v1->set_face(tl); #ifndef CGAL_NO_ASSERTIONS for (Face_iterator fit = faces_begin(); fit != faces_end(); ++fit) { int id; CGAL_triangulation_assertion( !fit->has_vertex(v2, id) ); } #endif // memory management star_faces_of_v2.clear(); star_indices_of_v2.clear(); delete_face(f); delete_face(g); delete_vertex(v2); CGAL_triangulation_expensive_postcondition( is_valid() ); return v1; } // insert_degree_2 and remove_degree_2 operations template typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: insert_degree_2(Face_handle f, int i) { /* // This method basically does the following transformation // The remove_degree_2 method performs the same operation in the // opposite direction // // // * // i / \ // * / \ // / \ / f \ // / \ / _____ \ // / f \ / / f1 \ \ // / \ |/ v \| // v0=ccw(i) *---------* v1=cw(i) ===> v0 *----*----* v1 // \ / |\ f2 /| // \ g / \ \_____/ / // \ / \ / // \ / \ g / // * \ / // j \ / // * // */ Face_handle g = f->neighbor(i); int j = f->mirror_index(i); Vertex_handle v = create_vertex(); Vertex_handle v0 = f->vertex( ccw(i) ); Vertex_handle v1 = f->vertex( cw(i) ); Face_handle f_undef; Face_handle f1 = create_face(v0, v, v1, f_undef, f, f_undef); Face_handle f2 = create_face(v0, v1, v, f_undef, f_undef, g); f1->set_neighbor(0, f2); f1->set_neighbor(2, f2); f2->set_neighbor(0, f1); f2->set_neighbor(1, f1); f->set_neighbor(i, f1); g->set_neighbor(j, f2); v->set_face(f1); return v; } template void Triangulation_data_structure_2:: remove_degree_2(Vertex_handle v) { CGAL_precondition( v->degree() == 2 ); Face_handle f1 = v->face(); int i = f1->index(v); Face_handle f2 = f1->neighbor( ccw(i) ); int j = f2->index(v); Face_handle ff1 = f1->neighbor( i ); Face_handle ff2 = f2->neighbor( j ); int id1 = f1->mirror_index(i); int id2 = f2->mirror_index(j); ff1->set_neighbor(id1, ff2); ff2->set_neighbor(id2, ff1); Vertex_handle v1 = f1->vertex( ccw(i) ); // if ( v1->face() == f1 || v1->face() == f2 ) { v1->set_face(ff1); // } Vertex_handle v2 = f1->vertex( cw(i) ); // if ( v2->face() == f1 || v2->face() == f2 ) { v2->set_face(ff2); // } delete_face(f1); delete_face(f2); delete_vertex(v); } // CHECKING template < class Vb, class Fb> bool Triangulation_data_structure_2:: is_valid(bool verbose, int level) const { if(number_of_vertices() == 0){ return (dimension() == -2); } bool result = (dimension()>= -1); CGAL_triangulation_assertion(result); //count and test the validity of the faces (for positive dimensions) Face_iterator ib = face_iterator_base_begin(); Face_iterator ib_end = face_iterator_base_end(); size_type count_stored_faces =0; for ( ; ib != ib_end ; ++ib){ count_stored_faces += 1; if (dimension()>= 0) { result = result && ib->is_valid(verbose,level); CGAL_triangulation_assertion(result); } } result = result && (count_stored_faces == number_of_full_dim_faces()); CGAL_triangulation_assertion( count_stored_faces == number_of_full_dim_faces()); // vertex count size_type vertex_count = 0; for(Vertex_iterator vit = vertices_begin(); vit != vertices_end(); ++vit) { CGAL_triangulation_assertion( vit->face() != Face_handle()); result = result && vit->is_valid(verbose,level); CGAL_triangulation_assertion( result ); ++vertex_count; } result = result && (number_of_vertices() == vertex_count); CGAL_triangulation_assertion( number_of_vertices() == vertex_count ); //edge count size_type edge_count = 0; for(Edge_iterator eit = edges_begin(); eit != edges_end(); ++eit) { ++edge_count; } // face count size_type face_count = 0; for(Face_iterator fit = faces_begin(); fit != faces_end(); ++fit) { ++face_count; } switch(dimension()) { case -1: result = result && vertex_count == 1 && face_count == 0 && edge_count == 0; CGAL_triangulation_assertion(result); break; case 0: result = result && vertex_count == 2 && face_count == 0 && edge_count == 0; CGAL_triangulation_assertion(result); break; case 1: result = result && edge_count == vertex_count; CGAL_triangulation_assertion(result); result = result && face_count == 0; CGAL_triangulation_assertion(result); break; case 2: result = result && edge_count == 3*face_count/2 ; CGAL_triangulation_assertion(edge_count == 3*face_count/2); break; default: result = false; CGAL_triangulation_assertion(result); } return result; } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: copy_tds(const Tds &tds, Vertex_handle vh) // return the vertex corresponding to vh in the new tds { if (this == &tds) return Vertex_handle(); if (vh != Vertex_handle()) CGAL_triangulation_precondition( tds.is_vertex(vh)); clear(); size_type n = tds.number_of_vertices(); set_dimension(tds.dimension()); // Number of pointers to cell/vertex to copy per cell. int dim = std::max(1, dimension() + 1); if(n == 0) {return Vertex_handle();} //initializes maps std::map vmap; std::map fmap; // create vertices Vertex_iterator vit1 = tds.vertices_begin(); for( ; vit1 != tds.vertices_end(); ++vit1) { vmap[vit1] = create_vertex(vit1); } //create faces Face_iterator fit1 = tds.face_container().begin(); for( ; fit1 != tds.faces_end(); ++fit1) { fmap[fit1] = create_face(fit1); } //link vertices to a cell vit1 = tds.vertices_begin(); for ( ; vit1 != tds.vertices_end(); vit1++) { vmap[vit1]->set_face(fmap[vit1->face()]); } //update vertices and neighbor pointers fit1 = tds.face_container().begin(); for ( ; fit1 != tds.faces_end(); ++fit1) { for (int j = 0; j < dim ; ++j) { fmap[fit1]->set_vertex(j, vmap[fit1->vertex(j)] ); fmap[fit1]->set_neighbor(j, fmap[fit1->neighbor(j)]); } } // remove the post condition because it is false when copying the // TDS of a regular triangulation because of hidden vertices // CGAL_triangulation_postcondition( is_valid() ); return (vh == Vertex_handle()) ? Vertex_handle() : vmap[vh]; } template < class Vb, class Fb> void Triangulation_data_structure_2:: file_output( std::ostream& os, Vertex_handle v, bool skip_first) const { // ouput to a file // if non NULL, v is the vertex to be output first // if skip_first is true, the point in the first vertex is not output // (it may be for instance the infinite vertex of the triangulation) size_type n = number_of_vertices(); size_type m = number_of_full_dim_faces(); if(is_ascii(os)) os << n << ' ' << m << ' ' << dimension() << std::endl; else os << n << m << dimension(); if (n==0) return; std::map V; std::map F; // first vertex int inum = 0; if ( v != Vertex_handle()) { V[v] = inum++; if( ! skip_first){ // os << v->point(); os << *v ; if(is_ascii(os)) os << std::endl; } } // other vertices for( Vertex_iterator vit= vertices_begin(); vit != vertices_end() ; ++vit) { if ( v != vit ) { V[vit] = inum++; // os << vit->point(); os << *vit; if(is_ascii(os)) os << "\n"; } } if(is_ascii(os)) os << "\n"; // vertices of the faces inum = 0; int dim = (dimension() == -1 ? 1 : dimension() + 1); for( Face_iterator ib = face_iterator_base_begin(); ib != face_iterator_base_end(); ++ib) { F[ib] = inum++; for(int j = 0; j < dim ; ++j) { os << V[ib->vertex(j)]; if(is_ascii(os)) os << " "; } os << *ib ; if(is_ascii(os)) os << "\n"; } if(is_ascii(os)) os << "\n"; // neighbor pointers of the faces for( Face_iterator it = face_iterator_base_begin(); it != face_iterator_base_end(); ++it) { for(int j = 0; j < dimension()+1; ++j){ os << F[it->neighbor(j)]; if(is_ascii(os)) os << " "; } if(is_ascii(os)) os << "\n"; } return ; } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: file_input( std::istream& is, bool skip_first) { //input from file //return a pointer to the first input vertex // if skip_first is true, a first vertex is added (infinite_vertex) //set this first vertex as infinite_Vertex if(number_of_vertices() != 0) clear(); size_type n, m; int d; is >> n >> m >> d; if (n==0){ return Vertex_handle();} set_dimension(d); std::vector V(n); std::vector F(m); // read vertices size_type i = 0; if(skip_first){ V[0] = create_vertex(); ++i; } for( ; i < n; ++i) { V[i] = create_vertex(); is >> *(V[i]); } // Creation of the faces int index; int dim = (dimension() == -1 ? 1 : dimension() + 1); { for(i = 0; i < m; ++i) { F[i] = create_face() ; for(int j = 0; j < dim ; ++j){ is >> index; F[i]->set_vertex(j, V[index]); // The face pointer of vertices is set too often, // but otherwise we had to use a further map V[index]->set_face(F[i]); } // read in non combinatorial info of the face is >> *(F[i]) ; } } // Setting the neighbor pointers { for(i = 0; i < m; ++i) { for(int j = 0; j < dimension()+1; ++j){ is >> index; F[i]->set_neighbor(j, F[index]); } } } return V[0]; } template < class Vb, class Fb> void Triangulation_data_structure_2:: vrml_output( std::ostream& os, Vertex_handle v, bool skip_infinite) const { // ouput to a vrml file style // Point are assumed to be 3d points with a stream oprator << // if non NULL, v is the vertex to be output first // if skip_inf is true, the point in the first vertex is not output // and the faces incident to v are not output // (it may be for instance the infinite vertex of the terrain) os << "#VRML V2.0 utf8" << std::endl; os << "Shape {" << std::endl; os << "\tgeometry IndexedFaceSet {" << std::endl; os << "\t\tcoord Coordinate {" << std::endl; os << "\t\t\tpoint [" << std::endl; std::map vmap; Vertex_iterator vit; Face_iterator fit; //first vertex int inum = 0; if ( v != Vertex_handle()) { vmap[v] = inum++; if( ! skip_infinite) os << "\t\t\t\t" << *v << std::endl; } //other vertices for( vit= vertices_begin(); vit != vertices_end() ; ++vit) { if ( v != vit) { vmap[vit] = inum++; os << "\t\t\t\t" << *vit << std::endl; } } os << "\t\t\t]" << std::endl; os << "\t\t}" << std::endl; os << "\t\tcoordIndex [" << std::endl; // faces for(fit= faces_begin(); fit != faces_end(); ++fit) { if (!skip_infinite || !fit->has_vertex(v)) { os << "\t\t\t"; os << vmap[(*fit).vertex(0)] << ", "; os << vmap[(*fit).vertex(1)] << ", "; os << vmap[(*fit).vertex(2)] << ", "; os << "-1, " << std::endl; } } os << "\t\t]" << std::endl; os << "\t}" << std::endl; os << "}" << std::endl; return; } template < class Vb, class Fb> typename Triangulation_data_structure_2::Vertex_handle Triangulation_data_structure_2:: off_file_input( std::istream& is, bool verbose) { // input from an OFF file // assume a dimension 2 triangulation // create an infinite-vertex and infinite faces with the // boundary edges if any. // return the infinite vertex if created Vertex_handle vinf; File_scanner_OFF scanner(is, verbose); if (! is) { if (scanner.verbose()) { std::cerr << " " << std::endl; std::cerr << "TDS::off_file_input" << std::endl; std::cerr << " input error: file format is not OFF." << std::endl; } return vinf; } if(number_of_vertices() != 0) clear(); int dim = 2; set_dimension(dim); std::vector vvh(scanner.size_of_vertices()); std::map edge_map; typedef typename Vb::Point Point; // read vertices int i; for ( i = 0; i < scanner.size_of_vertices(); i++) { Point p; file_scan_vertex( scanner, p); vvh[i] = create_vertex(); vvh[i]->set_point(p); scanner.skip_to_next_vertex( i); } if ( ! is ) { is.clear( std::ios::badbit); return vinf; } //vinf = vvh[0]; // create the facets for ( i = 0; i < scanner.size_of_facets(); i++) { Face_handle fh = create_face(); Integer32 no; scanner.scan_facet( no, i); if( ! is || no != 3) { if ( scanner.verbose()) { std::cerr << " " << std::endl; std::cerr << "TDS::off_file_input" << std::endl; std::cerr << "facet " << i << "does not have 3 vertices." << std::endl; } is.clear( std::ios::badbit); return vinf; } for ( int j = 0; j < no; ++j) { Integer32 index; scanner.scan_facet_vertex_index( index, i); fh->set_vertex(j, vvh[index]); vvh[index]->set_face(fh); } for (int ih = 0; ih < no; ++ih) { set_adjacency(fh, ih, edge_map); } } // deal with boundaries if ( !edge_map.empty()) { vinf = create_vertex(); std::map inf_edge_map; while (!edge_map.empty()) { Face_handle fh = edge_map.begin()->second.first; int ih = edge_map.begin()->second.second; Face_handle fn = create_face( vinf, fh->vertex(cw(ih)), fh->vertex(ccw(ih))); vinf->set_face(fn); set_adjacency(fn, 0, fh, ih); set_adjacency(fn, 1, inf_edge_map); set_adjacency(fn, 2, inf_edge_map); edge_map.erase(edge_map.begin()); } CGAL_triangulation_assertion(inf_edge_map.empty()); } // coherent orientation reorient_faces(); return vinf; } template < class Vb, class Fb> void Triangulation_data_structure_2:: set_adjacency(Face_handle fh, int ih, std::map< Vh_pair, Edge>& edge_map) { // set adjacency to (fh,ih) using the the map edge_map // or insert (fh,ih) in edge map Vertex_handle vhcw = fh->vertex(cw(ih)); Vertex_handle vhccw = fh->vertex(ccw(ih)); Vh_pair vhp = vhcw < vhccw ? std::make_pair(vhcw, vhccw) : std::make_pair(vhccw, vhcw) ; typename std::map::iterator emapit = edge_map.find(vhp); if (emapit == edge_map.end()) {// not found, insert edge edge_map.insert(std::make_pair(vhp, Edge(fh,ih))); } else { //found set adjacency and erase Edge e = emapit->second; set_adjacency( fh,ih, e.first, e.second); edge_map.erase(emapit); } } template < class Vb, class Fb> void Triangulation_data_structure_2:: reorient_faces() { // reorient the faces of a triangulation // needed for example in off_file_input // because the genus is not known, the number of faces std::set oriented_set; std::stack st; Face_iterator fit = faces_begin(); int nf = std::distance(faces_begin(),faces_end()); while (static_cast(oriented_set.size()) != nf) { while ( oriented_set.find(fit->handle()) != oriented_set.end()){ ++fit; // find a germ for non oriented components } // orient component oriented_set.insert(fit->handle()); st.push(fit->handle()); while ( ! st.empty()) { Face_handle fh = st.top(); st.pop(); for(int ih = 0 ; ih < 3 ; ++ih){ Face_handle fn = fh->neighbor(ih); if (oriented_set.find(fn) == oriented_set.end()){ int in = fn->index(fh); if (fn->vertex(cw(in)) != fh->vertex(ccw(ih))) fn->reorient(); oriented_set.insert(fn); st.push(fn); } } } } return; } template < class Vb, class Fb> std::istream& operator>>(std::istream& is, Triangulation_data_structure_2& tds) { tds.file_input(is); return is; } template < class Vb, class Fb> std::ostream& operator<<(std::ostream& os, const Triangulation_data_structure_2 &tds) { tds.file_output(os); return os; } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_DATA_STRUCTURE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/is_y_monotone_2.h0000644000175000017500000000473311344301500030302 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/is_y_monotone_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_IS_Y_MONOTONE_2_H #define CGAL_IS_Y_MONOTONE_2_H #include #include #include #include namespace CGAL { template bool is_y_monotone_2(InputIterator first, InputIterator last, const Traits& traits) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Less_yx_2 Less_yx_2; typedef std::list Vertex_list; typedef typename Vertex_list::iterator I; typedef Circulator_from_iterator Circulator; Vertex_list polygon(first, last); I n_point_ref; I s_point_ref; // find the extreme north and south points ch_n_point(polygon.begin(), polygon.end(), n_point_ref, traits); ch_s_point(polygon.begin(), polygon.end(), s_point_ref, traits); Circulator north_c(polygon.begin(), polygon.end(), n_point_ref); Circulator south_c(polygon.begin(), polygon.end(), s_point_ref); Less_yx_2 less_yx = traits.less_yx_2_object(); Circulator prev_c = south_c; Circulator c = south_c; for (c++; c != north_c; c++) { if (!less_yx(*prev_c, *c)) return false; prev_c = c; } prev_c = north_c; c = north_c; for (c++; c != south_c; c++) { if (!less_yx(*c, *prev_c)) return false; prev_c = c; } return true; } template bool is_y_monotone_2(InputIterator first, InputIterator last) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return is_y_monotone_2(first, last, K()); } } #endif // CGAL_IS_Y_MONOTONE_2_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_xz_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidea0000644000175000017500000000727511344301501031432 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_xz_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_XZ_3_H #define CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_XZ_3_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Orientation_xz_3 { public: typedef typename R::Point_3 Point; typename R::FT x(const Point &p) const { return p.x(); } typename R::FT y(const Point &p) const { return p.z(); } CGAL::Orientation operator()(const Point& p, const Point& q, const Point& r) { return orientationC2(x(p), y(p), x(q), y(q), x(r), y(r)); } }; template class Side_of_oriented_circle_xz_3 { public: typedef typename R::Point_3 Point; typename R::FT x(const Point &p) const { return p.x(); } typename R::FT y(const Point &p) const { return p.z(); } CGAL::Oriented_side operator() (const Point &p, const Point &q, const Point &r, const Point &s) { return side_of_oriented_circleC2(x(p), y(p), x(q), y(q), x(r), y(r), x(s), y(s)); } }; template < class R > class Triangulation_euclidean_traits_xz_3 { public: typedef Triangulation_euclidean_traits_xz_3 Traits; typedef R Rp; typedef typename Rp::Point_3 Point_2; typedef typename Rp::Segment_3 Segment_2; typedef typename Rp::Triangle_3 Triangle_2; typedef typename Rp::Compare_x_3 Compare_x_2; typedef typename Rp::Compare_z_3 Compare_y_2; typedef Orientation_xz_3 Orientation_2; typedef Side_of_oriented_circle_xz_3 Side_of_oriented_circle_2; typedef typename Rp::Construct_segment_3 Construct_segment_2; typedef typename Rp::Construct_triangle_3 Construct_triangle_2; // for compatibility with previous versions typedef Point_2 Point; typedef Segment_2 Segment; typedef Triangle_2 Triangle; Triangulation_euclidean_traits_xz_3(){} Triangulation_euclidean_traits_xz_3( const Triangulation_euclidean_traits_xz_3& ){} Triangulation_euclidean_traits_xz_3 &operator=( const Triangulation_euclidean_traits_xz_3& ){return *this;} typename Rp::FT x(const Point_2 &p) const { return p.x(); } typename Rp::FT y(const Point_2 &p) const { return p.z(); } Compare_x_2 compare_x_2_object() const { return Compare_x_2();} Compare_y_2 compare_y_2_object() const { return Compare_y_2();} Orientation_2 orientation_2_object() const { return Orientation_2();} Side_of_oriented_circle_2 side_of_oriented_circle_2_object() const {return Side_of_oriented_circle_2();} Construct_segment_2 construct_segment_2_object() const {return Construct_segment_2();} Construct_triangle_2 construct_triangle_2_object() const {return Construct_triangle_2();} }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_XZ_3_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidea0000644000175000017500000000745511344301501031432 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_euclidean_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_2_H #define CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_2_H #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class R > class Triangulation_euclidean_traits_2 { public: typedef R Rep; typedef typename R::Point_2 Point_2; typedef typename R::Segment_2 Segment_2; typedef typename R::Triangle_2 Triangle_2; typedef typename R::Line_2 Line_2; typedef typename R::Ray_2 Ray_2; typedef typename R::Compare_x_2 Compare_x_2; typedef typename R::Compare_y_2 Compare_y_2; typedef typename R::Orientation_2 Orientation_2; typedef typename R::Side_of_oriented_circle_2 Side_of_oriented_circle_2; typedef typename R::Construct_circumcenter_2 Construct_circumcenter_2; typedef typename R::Construct_bisector_2 Construct_bisector_2; typedef typename R::Compare_distance_2 Compare_distance_2; typedef typename R::Construct_segment_2 Construct_segment_2; typedef typename R::Construct_triangle_2 Construct_triangle_2; typedef typename R::Construct_direction_2 Construct_direction_2; typedef typename R::Construct_ray_2 Construct_ray_2; // for compatibility with previous versions typedef Point_2 Point; typedef Segment_2 Segment; typedef Triangle_2 Triangle; typedef Ray_2 Ray; typedef Line_2 Line; Triangulation_euclidean_traits_2() {} Triangulation_euclidean_traits_2(const Triangulation_euclidean_traits_2 &) {} Triangulation_euclidean_traits_2 &operator= (const Triangulation_euclidean_traits_2 &) {return *this;} Compare_x_2 compare_x_2_object() const { return Compare_x_2();} Compare_y_2 compare_y_2_object() const { return Compare_y_2();} Orientation_2 orientation_2_object() const { return Orientation_2();} Side_of_oriented_circle_2 side_of_oriented_circle_2_object() const {return Side_of_oriented_circle_2();} Construct_circumcenter_2 construct_circumcenter_2_object() const { return Construct_circumcenter_2();} Construct_bisector_2 construct_bisector_2_object() const {return Construct_bisector_2();} Compare_distance_2 compare_distance_2_object() const {return Compare_distance_2();} Construct_segment_2 construct_segment_2_object() const {return Construct_segment_2();} Construct_triangle_2 construct_triangle_2_object() const {return Construct_triangle_2();} Construct_direction_2 construct_direction_2_object() const {return Construct_direction_2();} Construct_ray_2 construct_ray_2_object() const {return Construct_ray_2();} }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_EUCLIDEAN_TRAITS_2_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Line_2_inter0000644000175000017500000001377711344301500031176 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SEGMENT_2_LINE_2_INTERSECTION_H #define CGAL_SEGMENT_2_LINE_2_INTERSECTION_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Segment_2_Line_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Segment_2_Line_2_pair() ; Segment_2_Line_2_pair(typename K::Segment_2 const *seg, typename K::Line_2 const *line); ~Segment_2_Line_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: typename K::Segment_2 const*_seg; typename K::Line_2 const * _line; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Segment_2 &p1, const typename CGAL_WRAP(K)::Line_2 &p2, const K&) { typedef Segment_2_Line_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Object intersection(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Line_2 &line, const K&) { typedef Segment_2_Line_2_pair is_t; is_t ispair(&seg, &line); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: return make_object(seg); } } template Object intersection(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { return CGALi::intersection(seg, line, k); } template class Line_2_Segment_2_pair: public Segment_2_Line_2_pair { public: Line_2_Segment_2_pair( typename K::Line_2 const *line, typename K::Segment_2 const *seg) : Segment_2_Line_2_pair(seg, line) {} }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Line_2 &p1, const typename CGAL_WRAP(K)::Segment_2 &p2, const K&) { typedef Line_2_Segment_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Segment_2_Line_2_pair::Segment_2_Line_2_pair() { _seg = 0; _line = 0; _known = false; } template Segment_2_Line_2_pair::Segment_2_Line_2_pair( typename K::Segment_2 const *seg, typename K::Line_2 const *line) { _seg = seg; _line = line; _known = false; } template typename Segment_2_Line_2_pair::Intersection_results Segment_2_Line_2_pair::intersection_type() const { if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; const typename K::Line_2 &l1 = _seg->supporting_line(); Line_2_Line_2_pair linepair(&l1, _line); switch ( linepair.intersection_type()) { case Line_2_Line_2_pair::NO: _result = NO; break; case Line_2_Line_2_pair::POINT: linepair.intersection(_intersection_point); _result = (_seg->collinear_has_on(_intersection_point) ) ? POINT : NO; break; case Line_2_Line_2_pair::LINE: _result = SEGMENT; break; } return _result; } template bool Segment_2_Line_2_pair::intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Segment_2_Line_2_pair::intersection(typename K::Segment_2 &result) const { if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = *_seg; return true; } } // namespace CGALi template inline bool do_intersect(const Segment_2 &seg, const Line_2 &line) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(seg, line); } template inline bool do_intersect(const Line_2 &line, const Segment_2 &seg) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect_2(line, seg); } template inline Object intersection(const Line_2 &line, const Segment_2 &seg) { typedef typename K::Intersect_2 Intersect; return Intersect()(seg, line); } template inline Object intersection(const Segment_2 &seg, const Line_2 &line) { typedef typename K::Intersect_2 Intersect; return Intersect()(line, seg); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/triangulation_assertions.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/triangulation_assertio0000644000175000017500000003372211344301501031544 0ustar debiandebian// Copyright (c) 2001 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/triangulation_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : script by Geert-Jan Giezeman and Sven Schoenherr // macro definitions // ================= // assertions // ---------- #if defined(CGAL_TRIANGULATION_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_triangulation_assertion(EX) (static_cast(0)) # define CGAL_triangulation_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_assertion_code(CODE) #else # define CGAL_triangulation_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_assertion_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_ASSERTIONS #if defined(CGAL_TRIANGULATION_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_triangulation_exactness_assertion(EX) (static_cast(0)) # define CGAL_triangulation_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_exactness_assertion_code(CODE) #else # define CGAL_triangulation_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_exactness_assertion_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_ASSERTIONS #if defined(CGAL_TRIANGULATION_NO_ASSERTIONS) \ || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_assertion(EX) (static_cast(0)) # define CGAL_triangulation_expensive_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_assertion_code(CODE) #else # define CGAL_triangulation_expensive_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_assertion_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_ASSERTIONS #if defined(CGAL_TRIANGULATION_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_exactness_assertion(EX) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_assertion_code(CODE) #else # define CGAL_triangulation_expensive_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_exactness_assertion_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_TRIANGULATION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_triangulation_precondition(EX) (static_cast(0)) # define CGAL_triangulation_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_precondition_code(CODE) #else # define CGAL_triangulation_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_precondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_PRECONDITIONS #if defined(CGAL_TRIANGULATION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_triangulation_exactness_precondition(EX) (static_cast(0)) # define CGAL_triangulation_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_exactness_precondition_code(CODE) #else # define CGAL_triangulation_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_exactness_precondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_PRECONDITIONS #if defined(CGAL_TRIANGULATION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_precondition(EX) (static_cast(0)) # define CGAL_triangulation_expensive_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_precondition_code(CODE) #else # define CGAL_triangulation_expensive_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_precondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_PRECONDITIONS #if defined(CGAL_TRIANGULATION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_exactness_precondition(EX) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_precondition_code(CODE) #else # define CGAL_triangulation_expensive_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_exactness_precondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_TRIANGULATION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_triangulation_postcondition(EX) (static_cast(0)) # define CGAL_triangulation_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_postcondition_code(CODE) #else # define CGAL_triangulation_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_postcondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_POSTCONDITIONS #if defined(CGAL_TRIANGULATION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_triangulation_exactness_postcondition(EX) (static_cast(0)) # define CGAL_triangulation_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_exactness_postcondition_code(CODE) #else # define CGAL_triangulation_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_exactness_postcondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_POSTCONDITIONS #if defined(CGAL_TRIANGULATION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_postcondition(EX) (static_cast(0)) # define CGAL_triangulation_expensive_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_postcondition_code(CODE) #else # define CGAL_triangulation_expensive_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_postcondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_POSTCONDITIONS #if defined(CGAL_TRIANGULATION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_exactness_postcondition(EX) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_postcondition_code(CODE) #else # define CGAL_triangulation_expensive_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_exactness_postcondition_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_TRIANGULATION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_triangulation_warning(EX) (static_cast(0)) # define CGAL_triangulation_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_warning_code(CODE) #else # define CGAL_triangulation_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_warning_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_WARNINGS #if defined(CGAL_TRIANGULATION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_triangulation_exactness_warning(EX) (static_cast(0)) # define CGAL_triangulation_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_exactness_warning_code(CODE) #else # define CGAL_triangulation_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_exactness_warning_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_WARNINGS #if defined(CGAL_TRIANGULATION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_warning(EX) (static_cast(0)) # define CGAL_triangulation_expensive_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_warning_code(CODE) #else # define CGAL_triangulation_expensive_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_warning_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_WARNINGS #if defined(CGAL_TRIANGULATION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_TRIANGULATION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TRIANGULATION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_triangulation_expensive_exactness_warning(EX) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_triangulation_expensive_exactness_warning_code(CODE) #else # define CGAL_triangulation_expensive_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_triangulation_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_triangulation_expensive_exactness_warning_code(CODE) CODE #endif // CGAL_TRIANGULATION_NO_WARNINGS mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Origin.h0000644000175000017500000000254711344301500026430 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Origin.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_ORIGIN_H #define CGAL_ORIGIN_H #include CGAL_BEGIN_NAMESPACE class Origin {}; extern const Origin ORIGIN; class Null_vector {}; extern const Null_vector NULL_VECTOR; CGAL_END_NAMESPACE #endif // CGAL_ORIGIN_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Incremental_neighbor_search.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Incremental_neighbor_s0000644000175000017500000003121611344301500031406 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Incremental_neighbor_search.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef INCREMENTAL_NEIGHBOR_SEARCH_H #define INCREMENTAL_NEIGHBOR_SEARCH_H #include #include #include #include #include #include #include namespace CGAL { template , class Splitter_ = Sliding_midpoint, class Tree_=Kd_tree > class Incremental_neighbor_search { public: typedef Distance_ Distance; typedef Tree_ Tree; typedef typename SearchTraits::Point_d Point_d; typedef typename SearchTraits::FT FT; typedef typename Tree::Point_d_iterator Point_d_iterator; typedef typename Tree::Node_handle Node_handle; typedef typename Tree::Splitter Splitter; typedef Kd_tree_rectangle Node_box; typedef typename Distance::Query_item Query_item; class Cell { private: Node_box* the_box; Node_handle the_node; public: // constructor Cell (Node_box* Nb, Node_handle N) :the_box(Nb), the_node(N) {} Node_box* box() { return the_box; } Node_handle node() { return the_node; } }; typedef std::pair Point_with_transformed_distance; typedef std::pair Cell_with_distance; class iterator; typedef std::vector Cell_with_distance_vector; typedef std::vector Point_with_distance_vector; typedef std::vector Distance_vector; iterator *start; iterator *past_the_end; public: // constructor Incremental_neighbor_search(Tree& tree, const Query_item& q, FT Eps=FT(0.0), bool search_nearest=true, const Distance& tr=Distance()) { start = new iterator(tree,q,tr,Eps,search_nearest); past_the_end = new iterator(); } // destructor ~Incremental_neighbor_search() { delete start; delete past_the_end; } iterator begin() { return *start; } iterator end() { return *past_the_end; } std::ostream& statistics(std::ostream& s) { start->statistics(s); return s; } class iterator { public: typedef std::input_iterator_tag iterator_category; typedef Point_with_transformed_distance value_type; typedef int distance_type; class Iterator_implementation; Iterator_implementation *ptr; // default constructor iterator() : ptr(0) {} int the_number_of_items_visited() { return ptr->number_of_items_visited; } // constructor iterator(const Tree& tree, const Query_item& q, const Distance& tr, FT eps, bool search_nearest) : ptr(new Iterator_implementation(tree, q, tr, eps, search_nearest)) {} // copy constructor iterator(const iterator& Iter) : ptr(Iter.ptr) { if (ptr != 0) ptr->reference_count++; } Point_with_transformed_distance& operator* () { return *(*ptr); } // prefix operator iterator& operator++() { ++(*ptr); return *this; } // postfix operator iterator operator++(int) { iterator tmp(*this); ++(*this); return tmp; } bool operator==(const iterator& It) const { if ( ((ptr == 0) || ptr->Item_PriorityQueue.empty()) && ((It.ptr == 0) || It.ptr->Item_PriorityQueue.empty()) ) return true; // else return (ptr == It.ptr); } bool operator!=(const iterator& It) const { return !(*this == It); } std::ostream& statistics (std::ostream& s) { ptr->statistics(s); return s; } ~iterator() { if (ptr != 0) { ptr->reference_count--; if (ptr->reference_count==0) { delete ptr; ptr = 0; } } } class Iterator_implementation { private: FT multiplication_factor; Query_item query_point; int total_item_number; FT distance_to_root; bool search_nearest_neighbour; FT rd; class Priority_higher { public: bool search_nearest; Priority_higher(bool search_the_nearest_neighbour) : search_nearest(search_the_nearest_neighbour) {} //highest priority is smallest distance bool operator() (Cell_with_distance* n1, Cell_with_distance* n2) const { return (search_nearest)? (n1->second > n2->second) : (n2->second > n1->second); } }; class Distance_smaller { public: bool search_nearest; Distance_smaller(bool search_the_nearest_neighbour) :search_nearest(search_the_nearest_neighbour) {} //highest priority is smallest distance bool operator() (Point_with_transformed_distance* p1, Point_with_transformed_distance* p2) const { return (search_nearest) ? (p1->second > p2->second) : (p2->second > p1->second); } }; std::priority_queue PriorityQueue; public: std::priority_queue Item_PriorityQueue; Distance distance; public: int reference_count; int number_of_internal_nodes_visited; int number_of_leaf_nodes_visited; int number_of_items_visited; int number_of_neighbours_computed; // constructor Iterator_implementation(const Tree& tree, const Query_item& q,const Distance& tr, FT Eps, bool search_nearest) : query_point(q), search_nearest_neighbour(search_nearest), PriorityQueue(Priority_higher(search_nearest)), Item_PriorityQueue(Distance_smaller(search_nearest)), distance(tr), reference_count(1), number_of_internal_nodes_visited(0), number_of_leaf_nodes_visited(0), number_of_items_visited(0), number_of_neighbours_computed(0) { multiplication_factor= distance.transformed_distance(FT(1)+Eps); Node_box *bounding_box = new Node_box((tree.bounding_box())); if (search_nearest) distance_to_root= distance.min_distance_to_rectangle(q,*bounding_box); else distance_to_root= distance.max_distance_to_rectangle(q,*bounding_box); total_item_number=tree.size(); Cell *Root_Cell = new Cell(bounding_box,tree.root()); Cell_with_distance *The_Root = new Cell_with_distance(Root_Cell,distance_to_root); PriorityQueue.push(The_Root); // rd is the distance of the top of the priority queue to q rd=The_Root->second; Compute_the_next_nearest_neighbour(); } // * operator Point_with_transformed_distance& operator* () { return *(Item_PriorityQueue.top()); } // prefix operator Iterator_implementation& operator++() { Delete_the_current_item_top(); Compute_the_next_nearest_neighbour(); return *this; } // Print statistics of the general priority search process. std::ostream& statistics (std::ostream& s) { s << "General priority search statistics:" << std::endl; s << "Number of internal nodes visited:" << number_of_internal_nodes_visited << std::endl; s << "Number of leaf nodes visited:" << number_of_leaf_nodes_visited << std::endl; s << "Number of points visited:" << number_of_items_visited << std::endl; s << "Number of neighbours computed:" << number_of_neighbours_computed << std::endl; return s; } //destructor ~Iterator_implementation() { while (! PriorityQueue.empty()) { Cell_with_distance* The_top=PriorityQueue.top(); PriorityQueue.pop(); delete The_top->first->box(); delete The_top->first; delete The_top; } while (! Item_PriorityQueue.empty()) { Point_with_transformed_distance* The_top=Item_PriorityQueue.top(); Item_PriorityQueue.pop(); delete The_top; } } private: void Delete_the_current_item_top() { Point_with_transformed_distance* The_item_top=Item_PriorityQueue.top(); Item_PriorityQueue.pop(); delete The_item_top; } void Compute_the_next_nearest_neighbour() { // compute the next item bool next_neighbour_found=false; if (!(Item_PriorityQueue.empty())) { if (search_nearest_neighbour) next_neighbour_found = (multiplication_factor*rd > Item_PriorityQueue.top()->second); else next_neighbour_found = (rd < multiplication_factor*Item_PriorityQueue.top()->second); } while ((!next_neighbour_found) && (!PriorityQueue.empty())) { Cell_with_distance* The_node_top = PriorityQueue.top(); Node_handle N = The_node_top->first->node(); Node_box* B = The_node_top->first->box(); PriorityQueue.pop(); delete The_node_top->first; delete The_node_top; while (!(N->is_leaf())) { number_of_internal_nodes_visited++; int new_cut_dim = N->cutting_dimension(); FT new_cut_val = N->cutting_value(); Node_box* lower_box = new Node_box(*B); Node_box* upper_box = new Node_box(*B); lower_box->split(*upper_box,new_cut_dim, new_cut_val); delete B; if (search_nearest_neighbour) { FT distance_to_box_lower = distance.min_distance_to_rectangle(query_point, *lower_box); FT distance_to_box_upper = distance.min_distance_to_rectangle(query_point, *upper_box); if (distance_to_box_lower <= distance_to_box_upper) { Cell* C_upper = new Cell(upper_box, N->upper()); Cell_with_distance *Upper_Child = new Cell_with_distance(C_upper,distance_to_box_upper); PriorityQueue.push(Upper_Child); N=N->lower(); B=lower_box; } else { Cell* C_lower = new Cell(lower_box, N->lower()); Cell_with_distance *Lower_Child = new Cell_with_distance(C_lower,distance_to_box_lower); PriorityQueue.push(Lower_Child); N=N->upper(); B=upper_box; } } else { // search furthest FT distance_to_box_lower = distance.max_distance_to_rectangle(query_point, *lower_box); FT distance_to_box_upper = distance.max_distance_to_rectangle(query_point, *upper_box); if (distance_to_box_lower >= distance_to_box_upper) { Cell* C_upper = new Cell(upper_box, N->upper()); Cell_with_distance *Upper_Child = new Cell_with_distance(C_upper,distance_to_box_upper); PriorityQueue.push(Upper_Child); N=N->lower(); B=lower_box; } else { Cell* C_lower = new Cell(lower_box, N->lower()); Cell_with_distance *Lower_Child = new Cell_with_distance(C_lower,distance_to_box_lower); PriorityQueue.push(Lower_Child); N=N->upper(); B=upper_box; } } } delete B; number_of_leaf_nodes_visited++; if (N->size() > 0) { for (Point_d_iterator it = N->begin(); it != N->end(); it++) { number_of_items_visited++; FT distance_to_query_point= distance.transformed_distance(query_point,**it); Point_with_transformed_distance *NN_Candidate= new Point_with_transformed_distance(**it,distance_to_query_point); Item_PriorityQueue.push(NN_Candidate); } // old top of PriorityQueue has been processed, // hence update rd if (!PriorityQueue.empty()) { rd = PriorityQueue.top()->second; if (search_nearest_neighbour) next_neighbour_found = (multiplication_factor*rd > Item_PriorityQueue.top()->second); else next_neighbour_found = (multiplication_factor*rd < Item_PriorityQueue.top()->second); } else // priority queue empty => last neighbour found { next_neighbour_found=true; }; number_of_neighbours_computed++; } } // next_neighbour_found or priority queue is empty // in the latter case also the item priority queue is empty } }; // class Iterator_implementation }; // class iterator }; // class } // namespace CGAL #endif // INCREMENTAL_NEIGHBOR_SEARCH_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/cartesian_homogeneous_conversion.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/cartesian_homogeneous_0000644000175000017500000000776211344301500031477 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/cartesian_homogeneous_conversion.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CARTESIAN_HOMOGENEOUS_CONVERSION_H #define CGAL_CARTESIAN_HOMOGENEOUS_CONVERSION_H CGAL_BEGIN_NAMESPACE template Point_2< Cartesian > homogeneous_to_cartesian(const Point_2< Homogeneous >& hp) { return Point_2< Cartesian >(hp.hx(), hp.hy(), hp.hw() ); } template Point_2< Homogeneous > cartesian_to_homogeneous(const Point_2< Cartesian >& cp) { return Point_2< Homogeneous >(cp.hx(), cp.hy()); } template Point_3< Cartesian > homogeneous_to_cartesian(const Point_3< Homogeneous >& hp) { return Point_3< Cartesian >(hp.hx(), hp.hy(), hp.hz(), hp.hw() ); } template Point_3< Homogeneous > cartesian_to_homogeneous(const Point_3< Cartesian >& cp) { return Point_3< Homogeneous >(cp.hx(), cp.hy(), cp.hz() ); } template Point_2< Cartesian > > homogeneous_to_quotient_cartesian( const Point_2 >& hp) { typedef Quotient QT; return Point_2< Cartesian >( QT( hp.hx(), hp.hw() ), QT( hp.hy(), hp.hw() ) ); } template Point_2< Homogeneous > quotient_cartesian_to_homogeneous( const Point_2< Cartesian< Quotient > >& cp) { typedef Point_2 > HPoint; if ( cp.x().denominator() != cp.y().denominator() ) { return HPoint( cp.x().numerator() * cp.y().denominator(), cp.y().numerator() * cp.x().denominator(), cp.x().denominator()* cp.y().denominator()); } else { return HPoint( cp.x().numerator(), cp.y().numerator(), cp.x().denominator()); } } template Point_3< Cartesian > > homogeneous_to_quotient_cartesian( const Point_3 >& hp) { typedef Quotient QT; return Point_3< Cartesian >( QT( hp.hx(), hp.hw() ), QT( hp.hy(), hp.hw() ), QT( hp.hz(), hp.hw() ) ); } template Point_3< Homogeneous > quotient_cartesian_to_homogeneous( const Point_3< Cartesian< Quotient > >& cp) { typedef Point_3 > HPoint; if ( (cp.x().denominator() != cp.y().denominator() ) ||(cp.x().denominator() != cp.z().denominator() ) ) { return HPoint(cp.x().numerator() *cp.y().denominator()*cp.z().denominator(), cp.y().numerator() *cp.x().denominator()*cp.z().denominator(), cp.z().numerator() *cp.x().denominator()*cp.y().denominator(), cp.x().denominator()*cp.y().denominator()*cp.z().denominator()); } else { return HPoint( cp.x().numerator(), cp.y().numerator(), cp.z().numerator(), cp.x().denominator()); } } CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_HOMOGENEOUS_CONVERSION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/number_type_basic.h0000644000175000017500000002721211344301500030667 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/number_type_basic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_NUMBER_TYPE_BASIC_H #define CGAL_NUMBER_TYPE_BASIC_H #define CGAL_PI 3.14159265358979323846 #define CGAL_NTS CGAL:: // #define CGAL_NTS CGAL::NTS:: #if ((__GNUC__ == 2) && (__GNUC_MINOR__ == 95)) #include #endif // CGAL uses std::min and std::max #include CGAL_BEGIN_NAMESPACE using std::min; using std::max; CGAL_END_NAMESPACE #include #include #include #include #include // Including all number type files is necessary for compilers implementing // two-stage name lookup (like g++ >= 3.4). // A nicer solution needs more thought. #ifdef CGAL_CFG_HAS_TWO_STAGE_NAME_LOOKUP CGAL_BEGIN_NAMESPACE // MP_Float class MP_Float; Comparison_result compare(const MP_Float&, const MP_Float&); Sign sign(const MP_Float &); MP_Float square(const MP_Float&); MP_Float sqrt(const MP_Float&); double to_double(const MP_Float&); std::pair to_interval(const MP_Float &); bool is_finite(const MP_Float &); bool is_valid(const MP_Float &); // long double to_double(long); std::pair to_interval(const long &); bool is_finite(long); bool is_valid(long); // long long #ifdef CGAL_USE_LONG_LONG double to_double(long long); std::pair to_interval(const long long &); bool is_finite(long long); bool is_valid(long long); long long int div(long long int, long long int); #endif // CGAL_USE_LONG_LONG // Fixed_precision_nt class Fixed_precision_nt; double to_double(Fixed_precision_nt); bool is_finite(Fixed_precision_nt); bool is_valid(Fixed_precision_nt); std::pair to_interval(Fixed_precision_nt); // Quotient template class Quotient; template Quotient sqrt(const Quotient &); template Comparison_result compare(const Quotient&, const Quotient&); template double to_double(const Quotient&); template std::pair to_interval (const Quotient&); template bool is_valid(const Quotient&); template bool is_finite(const Quotient&); // Lazy_exact_nt template class Lazy_exact_nt; template double to_double(const Lazy_exact_nt &); template std::pair to_interval(const Lazy_exact_nt &); template Sign sign(const Lazy_exact_nt &); template Comparison_result compare(const Lazy_exact_nt &, const Lazy_exact_nt &); template Lazy_exact_nt abs(const Lazy_exact_nt &); template Lazy_exact_nt square(const Lazy_exact_nt &); template Lazy_exact_nt sqrt(const Lazy_exact_nt &); template Lazy_exact_nt min(const Lazy_exact_nt &, const Lazy_exact_nt &); template Lazy_exact_nt max(const Lazy_exact_nt &, const Lazy_exact_nt &); template bool is_finite(const Lazy_exact_nt &); template bool is_valid(const Lazy_exact_nt &); // Interval_nt template class Interval_nt; template double to_double (const Interval_nt &); template std::pair to_interval (const Interval_nt &); template bool is_valid (const Interval_nt &); template bool is_finite (const Interval_nt &); template Interval_nt sqrt (const Interval_nt &); template Interval_nt min (const Interval_nt &, const Interval_nt &); template Interval_nt max (const Interval_nt &, const Interval_nt &); template Interval_nt square (const Interval_nt &); template Interval_nt abs (const Interval_nt &); template Sign sign (const Interval_nt &); template Comparison_result compare (const Interval_nt &, const Interval_nt &); // Filtered_exact template < class, class, class, bool, class > class Filtered_exact; struct Dynamic; #ifndef CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER template < class CT, class ET, bool Protected, class Cache > Filtered_exact div (const Filtered_exact&, const Filtered_exact&); template < class CT, class ET, class Type, bool Protected, class Cache > Filtered_exact sqrt (const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Filtered_exact gcd (const Filtered_exact&, const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Filtered_exact square (const Filtered_exact&); #endif // CGAL_DENY_INEXACT_OPERATIONS_ON_FILTER template < class CT, class ET, class Type, bool Protected, class Cache > bool is_valid (const Filtered_exact&); template < class CT, class ET, class Type, bool Protected, class Cache > bool is_finite (const Filtered_exact&); template < class CT, class ET, class Type, bool Protected, class Cache > double to_double (const Filtered_exact&); template < class CT, class ET, class Type, bool Protected, class Cache > std::pair to_interval (const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Sign sign (const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Comparison_result compare (const Filtered_exact&, const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Filtered_exact abs (const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Filtered_exact min (const Filtered_exact&, const Filtered_exact&); template < class CT, class ET, bool Protected, class Cache > Filtered_exact max (const Filtered_exact&, const Filtered_exact&); // Polynomial template class Polynomial; template double to_double(const Polynomial &); template std::pair to_interval(const Polynomial &); template Sign sign(const Polynomial &); template Polynomial abs(const Polynomial &); template bool is_finite(const Polynomial &); template bool is_valid(const Polynomial &); template Polynomial gcd(const Polynomial &, const Polynomial &); // Nef_polynomial template class Nef_polynomial; template double to_double(const Nef_polynomial &); template Nef_polynomial gcd(const Nef_polynomial &, const Nef_polynomial &); #ifdef CGAL_USE_GMP // Gmpz class Gmpz; double to_double(const Gmpz&); Sign sign(const Gmpz &); bool is_valid(const Gmpz &); bool is_finite(const Gmpz &); Gmpz sqrt(const Gmpz &); Gmpz div(const Gmpz &, const Gmpz &); Gmpz gcd(const Gmpz &, const Gmpz &); Gmpz gcd(const Gmpz &, int); std::pair to_interval (const Gmpz &); // Gmpq class Gmpq; double to_double(const Gmpq&); Sign sign(const Gmpq &); bool is_valid(const Gmpq &); bool is_finite(const Gmpq &); std::pair to_interval (const Gmpq &); #endif // CGAL_USE_GMP #ifdef CGAL_USE_GMPXX // GMPXX CGAL_END_NAMESPACE template class __gmp_expr; class __gmpz_value; class __gmpq_value; typedef __gmp_expr<__gmpz_value, __gmpz_value> mpz_class; typedef __gmp_expr<__gmpq_value, __gmpq_value> mpq_class; CGAL_BEGIN_NAMESPACE template < typename T, typename U > ::__gmp_expr sqrt(const ::__gmp_expr &); template < typename T, typename U > double to_double(const ::__gmp_expr &); template < typename T, typename U > bool is_finite(const ::__gmp_expr &); template < typename T, typename U > bool is_valid(const ::__gmp_expr &); template < typename T, typename U > std::pair to_interval (const ::__gmp_expr &); std::pair to_interval (const mpz_class &); std::pair to_interval (const mpq_class &); template < typename T, typename U > ::__gmp_expr abs(const ::__gmp_expr&); template < typename T, typename U > ::__gmp_expr square(const ::__gmp_expr&); template < typename T, typename U > Sign sign(const ::__gmp_expr &); template < typename T, typename U1, typename U2 > Comparison_result compare(const ::__gmp_expr &, const ::__gmp_expr &); template < typename T, typename U > bool is_zero(const ::__gmp_expr &); template < typename T, typename U > bool is_one(const ::__gmp_expr &); template < typename T, typename U > bool is_positive(const ::__gmp_expr &); template < typename T, typename U > bool is_negative(const ::__gmp_expr &); #endif // CGAL_USE_GMPXX // CORE::Expr #ifdef CGAL_USE_CORE CGAL_END_NAMESPACE namespace CORE { class Expr; } CGAL_BEGIN_NAMESPACE double to_double(const CORE::Expr &); CORE::Expr sqrt(const CORE::Expr &); bool is_finite(const CORE::Expr &); bool is_valid(const CORE::Expr &); Sign sign(const CORE::Expr&); Comparison_result compare(const CORE::Expr&, const CORE::Expr&); std::pair to_interval (const CORE::Expr &); #endif // CGAL_USE_CORE // Integer and Double from _QP_solver CGAL_END_NAMESPACE #include CGAL_BEGIN_NAMESPACE // specializations for Quotient CGAL_END_NAMESPACE #include #ifdef CGAL_USE_GMP # include #endif // CGAL_USE_GMP #include CGAL_BEGIN_NAMESPACE #ifdef CGAL_USE_GMP double to_double(const Quotient&); #endif // CGAL_USE_GMP double to_double(const Quotient&); std::pair to_interval(const Quotient&); CGAL_END_NAMESPACE #endif // CGAL_CFG_HAS_TWO_STAGE_NAME_LOOKUP #include #endif // CGAL_NUMBER_TYPE_BASIC_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2.h0000644000175000017500000001220311344301501027503 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sweep_line_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_SWEEP_2_H #define CGAL_SWEEP_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*! @class Sweep_line_2 Sweep_line_2 is a wrapper class to Sweep_line_2_impl. It is used as an interface to the Sweep algorithm. The sweep suupport the following degenerate cases: - non x-monotone curves - vertical segments - multiple (more then two) segments intersecting at one point - curves beginning and ending on other curves. - overlapping curves There are two main functionalities supported by this algorithm: 1. calculate the non intersecting curves that are a product of intersecting a set of input curves 2. calculate all the intersection points between the curves specified An extension of this algorithm is used to produce a planar map containing the input curves efficiently. \sa Pmwx_aggregate_insert. */ template class Sweep_line_2 : public Sweep_line_2_impl< CurveInputIterator, SweepLineTraits_2, Sweep_line_event >, Sweep_line_subcurve > { public: typedef SweepLineTraits_2 Traits; typedef Sweep_line_2_impl< CurveInputIterator, SweepLineTraits_2, Sweep_line_event >, Sweep_line_subcurve > Base; Sweep_line_2() : Base() {} Sweep_line_2(Traits *t) : Base(t) {} virtual ~Sweep_line_2() {} /*! * Given a container of curves, this function returns a list of curves * that are created by intersecting the input curves. * \param begin the input iterator that points to the first curve * in the range. * \param end the input past-the-end iterator of the range. * \param subcurves an iterator to the first curve in the range * of curves created by intersecting the input curves. * \param overlapping indicates whether overlapping curves should be * reported once or multiple times. If false, the * overlapping curves are reported once only. */ template void get_subcurves(CurveInputIterator begin, CurveInputIterator end, OutpoutIterator subcurves, bool overlapping = false) { Base::get_subcurves(begin, end, subcurves, overlapping); } /*! * Given a range of curves, this function returns a list of points * that are the intersection points of the curves. * The intersections are calculated using the sweep algorithm. * \param begin the input iterator that points to the first curve * in the range. * \param end the input past-the-end iterator of the range. * \param points an iterator to the first point in the range * of points created by intersecting the input curves. * \param includeEndPoints if true, the end points of the curves are * reported as intersection points. Defaults to true. */ template void get_intersection_points(CurveInputIterator begin, CurveInputIterator end, OutpoutIterator points, bool includeEndPoints = true) { Base::get_intersection_points(begin, end, points, includeEndPoints); } /*! * Given a range of curves, this function returns an iterator * to the beginning of a range that contains the list of curves * for each intersection point between any two curves in the * specified range. * The intersections are calculated using the sweep algorithm. * \param begin the input iterator that points to the first curve * in the range. * \param end the input past-the-end iterator of the range. * \param intersecting_curves an iterator to the output * \param endpoints if true, the end points of the curves are reported * as intersection points. Defaults to true. */ template void get_intersecting_curves(CurveInputIterator begin, CurveInputIterator end, OutputIterator intersecting_curves, bool endpoints = true) { Base::get_intersecting_curves(begin, end, intersecting_curves, endpoints); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_filtered_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000001115511344301500031446 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_filtered_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_REGULAR_TRIANGULATION_FILTERED_TRAITS_3_H #define CGAL_REGULAR_TRIANGULATION_FILTERED_TRAITS_3_H #include #include #include CGAL_BEGIN_NAMESPACE // The Weighted_converter is parametrized by a usual kernel converter, // and adds the conversions for the Weighted_point. template < typename Converter > struct Weighted_converter_3 : public Converter { typedef typename Converter::Source_kernel Source_kernel; typedef typename Converter::Target_kernel Target_kernel; typedef typename Regular_triangulation_euclidean_traits_base_3 ::Weighted_point_3 Source_wp; typedef typename Regular_triangulation_euclidean_traits_base_3 ::Weighted_point_3 Target_wp; Target_wp operator()(const Source_wp &wp) const { return Target_wp(Converter::operator()(wp.point()), Converter::operator()(wp.weight())); } }; // The argument is supposed to be a Filtered_kernel like kernel. template < typename K > class Regular_triangulation_filtered_traits_3 : public Regular_triangulation_euclidean_traits_base_3 { // Exact traits is based on the exact kernel. typedef Regular_triangulation_euclidean_traits_3 Exact_traits; // Filtering traits is based on the filtering kernel. typedef Regular_triangulation_euclidean_traits_3 Filtering_traits; typedef typename K::C2E C2E; typedef typename K::C2F C2F; public: typedef Filtered_predicate< typename Exact_traits::Power_test_3, typename Filtering_traits::Power_test_3, Weighted_converter_3, Weighted_converter_3 > Power_test_3; typedef Filtered_predicate< typename Exact_traits::Compare_power_distance_3, typename Filtering_traits::Compare_power_distance_3, Weighted_converter_3, Weighted_converter_3 > Compare_power_distance_3; typedef Filtered_predicate< typename Exact_traits::In_smallest_orthogonal_sphere_3, typename Filtering_traits::In_smallest_orthogonal_sphere_3, Weighted_converter_3, Weighted_converter_3 > In_smallest_orthogonal_sphere_3; typedef Filtered_predicate< typename Exact_traits::Side_of_bounded_orthogonal_sphere_3, typename Filtering_traits::Side_of_bounded_orthogonal_sphere_3, Weighted_converter_3, Weighted_converter_3 > Side_of_bounded_orthogonal_sphere_3; typedef Filtered_predicate< typename Exact_traits::Does_simplex_intersect_dual_support_3, typename Filtering_traits::Does_simplex_intersect_dual_support_3, Weighted_converter_3, Weighted_converter_3 > Does_simplex_intersect_dual_support_3; Power_test_3 power_test_3_object() const { return Power_test_3();} Compare_power_distance_3 compare_power_distance_3_object() const { return Compare_power_distance_3();} In_smallest_orthogonal_sphere_3 in_smallest_orthogonal_sphere_3_object() const { return In_smallest_orthogonal_sphere_3(); } Side_of_bounded_orthogonal_sphere_3 side_of_bounded_orthogonal_sphere_3_object() const { return Side_of_bounded_orthogonal_sphere_3(); } Does_simplex_intersect_dual_support_3 does_simplex_intersect_dual_support_3_object() const { return Does_simplex_intersect_dual_support_3(); } // The following are inherited since they are constructions : // Construct_weighted_circumcenter_3 // Compute_squared_radius_smallest_orthogonal_sphere_3 // Compute_power_product_3 }; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_FILTERED_TRAITS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/tags.h0000644000175000017500000000421211344301501026127 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/tags.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_TAGS_H #define CGAL_TAGS_H #include #include CGAL_BEGIN_NAMESPACE // Two struct's to denote boolean compile time decisions. struct Tag_true {}; struct Tag_false {}; inline bool check_tag( Tag_true) {return true;} inline bool check_tag( Tag_false) {return false;} // A function that asserts a specific compile time tag // forcing its two arguments to have equal type. // It is encapsulated with #ifdef since it will be defined also elsewhere. // ====================================================== #ifndef CGAL_ASSERT_COMPILE_TIME_TAG #define CGAL_ASSERT_COMPILE_TIME_TAG 1 template struct Assert_tag_class { void match_compile_time_tag( const Base&) const {} }; template inline void Assert_compile_time_tag( const Tag&, const Derived& b) { Assert_tag_class x; x.match_compile_time_tag(b); } #endif // CGAL_ASSERT_COMPILE_TIME_TAG template < class T> inline void assert_equal_types( const T&, const T&) {} CGAL_END_NAMESPACE #endif // CGAL_TAGS_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_short_names_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_short_na0000644000175000017500000000410211344301501031456 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_short_names_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud #ifndef CGAL_TRIANGULATION_SHORT_NAMES_3_H #define CGAL_TRIANGULATION_SHORT_NAMES_3_H #define Triangulation_vertex_base_3 T_vb3 #define Triangulation_cell_base_3 T_cb3 #define Triangulation_data_structure_3 TDS3 #define Triangulation_ds_vertex_base_3 TDS_vb3 #define Triangulation_ds_cell_base_3 TDS_cb3 #define Triangulation_ds_vertex_3 TDS_v3 #define Triangulation_ds_cell_3 TDS_c3 #define Triangulation_ds_edge_iterator_3 TDS_eit3 #define Triangulation_ds_facet_iterator_3 TDS_fit3 #define Triangulation_ds_cell_circulator_3 TDS_ccir3 #define Triangulation_ds_facet_circulator_3 TDS_fcir3 #define Triangulation_3 TR3 #define Delaunay_triangulation_3 DT3 #define Delaunay_remove_tds_face_3_2 DRf32 #define Delaunay_remove_tds_vertex_3_2 DRv32 #define Regular_triangulation_euclidean_traits_3 R_gt3 #define Regular_triangulation_filtered_traits_3 R_ft3 #define Regular_triangulation_3 RT3 #define Triangulation_hierarchy_3 TH3 #define Triangulation_hierarchy_vertex_base_3 TH_vb3 #endif // CGAL_TRIANGULATION_SHORT_NAMES_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Range_tree_d.h0000644000175000017500000003765711344301500027571 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Range_tree_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef CGAL_RANGE_TREE_D_H #define CGAL_RANGE_TREE_D_H #include #include #include #include #include #include // A d-dimensional Range Tree or a multilayer tree consisting of Range // and other trees that are derived public // Tree_base // can be construced within this class. // C_Data: container class which contains the d-dimensional data the tree holds. // C_Window: Query window -- a d-dimensional interval // C_Interface: Interface for the class with functions that allow to // access the data. // cf. file Tree_interface.h, class point_interface for the requirements. CGAL_BEGIN_NAMESPACE template class Range_tree_d; template struct Range_tree_node: public Tree_node_base { private: typedef C_Data Data; typedef C_Window Window; typedef typename C_Interface::Key Key; typedef C_Interface Interface; typedef typename Tree_base< C_Data, C_Window>::Tree_base_type Tree_base_type; // protected: //typedef Range_tree_d< C_Data, C_Window, C_Interface> rT_d; public: friend class Range_tree_d< C_Data, C_Window, C_Interface>; Range_tree_node() : sublayer(0) {} Range_tree_node( Range_tree_node * p_left, Range_tree_node * p_right, const Data & v_obj, const Key & v_key ) : Tree_node_base(p_left, p_right), object( v_obj ), key( v_key ), sublayer(0) {} Range_tree_node( Range_tree_node * p_left, Range_tree_node * p_right, const Key & v_key ) : Tree_node_base(p_left, p_right), key( v_key ), sublayer(0) {} virtual ~Range_tree_node() { if (sublayer != 0) delete sublayer; } Data object; Key key; Tree_base_type *sublayer; }; template class Range_tree_d: public Tree_base< C_Data, C_Window> { private: typedef C_Data Data; typedef C_Window Window; typedef typename C_Interface::Key Key; typedef C_Interface Interface; typedef Tree_base< C_Data, C_Window> tbt; protected: // typedef Range_tree_d< C_Data, C_Window, C_Interface> rT_d; Tree_base *sublayer_tree; C_Interface interface; int is_built; // A vertex is of this type: // struct Range_tree_node; friend class Range_tree_node; typedef Range_tree_node Range_tree_node2; typedef Range_tree_node *link_type; static link_type& left(link_type x) { return CGAL__static_cast(link_type&, (*x).left_link); } static link_type& right(link_type x) { return CGAL__static_cast(link_type&, (*x).right_link); } static link_type& parent(link_type x) { return CGAL__static_cast(link_type&, (*x).parent_link); } link_type header; link_type node; link_type rightmost(){return right(header);} link_type leftmost(){return left(header);} link_type root() const { if(header!=0) return CGAL__static_cast(link_type&, header->parent_link); // return parent(header); else return 0; } bool is_less_equal(const Key& x, const Key& y) const { return (!interface.comp(y,x)); } // this tree is not a recursion anchor bool is_anchor() const {return false;} // returns true, if the object lies inside of win bool is_inside( C_Window const &win, C_Data const& object) const { if(is_less_equal(interface.get_left(win), interface.get_key(object)) && interface.comp(interface.get_key(object),interface.get_right(win))) //half open // && is_less_equal(interface.get_key(object),interface.get_right(win))) //closed interval { return sublayer_tree->is_inside(win,object); } return false; } // merge sort algorithms that takes O(n) time if the sequence to // be sorted consists of two sorted subsequences. template void dynamic_merge(const T& first, const T& last) // af: was not const { T prev, current=first; T current_first, current_middle, current_last; std::list startpoints, tmp_startpoints; startpoints.push_back(current); prev = current++; while(current!=last) { if (interface.comp(interface.get_key(*current),interface.get_key(*prev))) startpoints.push_back(current); prev = current++; } while(startpoints.size()>1) { while(startpoints.size()>1) { current_first = startpoints.front(); startpoints.erase(startpoints.begin()); current_middle = startpoints.front(); startpoints.erase(startpoints.begin()); if(startpoints.size()>0) current_last = startpoints.front(); else current_last = last; tmp_startpoints.push_back(current_first); std::inplace_merge(current_first, current_middle, current_last, interface.key_comp); } if(startpoints.size()>0) { tmp_startpoints.push_back(startpoints.front()); startpoints.erase(startpoints.begin()); } startpoints.swap(tmp_startpoints); } } // recursive function // (current,last) describe an interval of length n of sorted elements, // for this interval a tree is build containing these elements. // the most left child is returend in prevchild. template void build_range_tree(int n, link_type& leftchild, link_type& rightchild, link_type& prevchild, link_type& leftmostlink, T& current, const T& last, T& sublevel_first, T& sublevel_last) { // only two elements ==> two leaves and a parent is constructed if (n==2) { sublevel_first = current; link_type vleft = new Range_tree_node2( 0, 0, (*current), interface.get_key(*current) ); //CGAL_NIL CGAL_NIL first two arguments CGAL_Tree_assertion( vleft != 0); ++current; link_type vright = new Range_tree_node2( 0,0, (*current), interface.get_key(*current) ); //CGAL_NIL CGAL_NIL first two arguments CGAL_Tree_assertion( vright != 0); current++; sublevel_last = current; link_type vparent = new Range_tree_node2( vleft, vright, vleft->key ); CGAL_Tree_assertion( vparent != 0); vleft->parent_link = vparent; vright->parent_link = vparent; leftchild = vleft; rightchild = vright; prevchild = vparent; if ( leftmostlink == 0) leftmostlink = leftchild; Tree_base *g = sublayer_tree->clone(); T sub_first = sublevel_first; T sub_last = sublevel_last; g->make_tree(sub_first, sub_last); vparent->sublayer= g; } else // only one element ==> one leaf is constructed if(n==1) { sublevel_first = current; link_type vright = new Range_tree_node2( 0, 0, (*current), interface.get_key(*current) ); //CGAL_NIL CGAL_NIL first two arguments CGAL_Tree_assertion( vright != 0); //CGAL_NIL current++; sublevel_last = current; prevchild = vright; rightchild = vright; } else { // recursiv call for the construction. the interval is devided. T sublevel_left, sublevel_right; build_range_tree(n - (int)n/2, leftchild, rightchild, prevchild, leftmostlink, current, last, sublevel_first, sublevel_left); link_type vparent = new Range_tree_node2( prevchild, 0, rightchild->key ); //CGAL_NIL argument CGAL_Tree_assertion( vparent != 0); prevchild->parent_link = vparent; build_range_tree((int)n/2, leftchild, rightchild, prevchild, leftmostlink, current, last, sublevel_right, sublevel_last); vparent->right_link = prevchild; prevchild->parent_link = vparent; prevchild = vparent; Tree_base *g = sublayer_tree->clone(); T sub_first = sublevel_first; T sub_last = sublevel_last; g->make_tree(sub_first, sub_last); vparent->sublayer = g; } } void delete_tree(link_type v) { if (v->left_link != 0) { delete_tree(left(v)); delete_tree(right(v)); } delete v; } // the vertex from that the way from root to the left interval bound // and the right interval bound splits. link_type findSplitNode(Window const &key) { link_type v = root(); while(v->left_link!=0) { // if(interface.comp(interface.get_right(key), v->key)) if(is_less_equal(interface.get_right(key), v->key)) v = left(v); else if(interface.comp(v->key, interface.get_left(key))) v = right(v); else break; } return v; } template void report_subtree(link_type v, T result) { if(left(v)!=0) { report_subtree(left(v), result); report_subtree(right(v), result); } else (*result++)=v->object; } bool is_valid(link_type& v, link_type& leftmost_child, link_type& rightmost_child) const { link_type leftmost_child_l, rightmost_child_l, leftmost_child_r, rightmost_child_r; if (v->sublayer != 0) { Tree_base *T= v->sublayer; if(! T->is_valid()) return false; } if(left(v)!=0) { if(!is_valid(left(v), leftmost_child_l, rightmost_child_l)) return false; if(!is_valid(right(v), leftmost_child_r, rightmost_child_r)) return false; if(interface.comp(v->key, rightmost_child_l->key) || interface.comp(rightmost_child_l->key, v->key)) return false; rightmost_child = rightmost_child_r; leftmost_child = leftmost_child_l; } else { rightmost_child = v; leftmost_child = v; } return true; } public: // construction of a tree Range_tree_d(Range_tree_d const &fact, bool): sublayer_tree(fact.sublayer_tree->clone()), is_built(false), header(0) {} // construction of a tree Range_tree_d(Tree_base const &fact): sublayer_tree(fact.clone()), is_built(false), header(0) {} // destruction virtual ~Range_tree_d() { link_type v=root(); if (v!=0) delete_tree(v); if (header!=0) delete header; if (sublayer_tree!=0) delete sublayer_tree; } // a prototype of the tree is returned Tree_base *clone() const { return new Range_tree_d(*this, true); } bool make_tree(const typename std::list< C_Data>::iterator& beg, const typename std::list< C_Data>::iterator& end, typename tbt::lit * =0){ return make_tree_impl(beg,end); } #ifdef stlvector bool make_tree(const typename std::vector< C_Data>::iterator& beg, const typename std::vector< C_Data>::iterator& end, typename tbt::vbit * =0){ return make_tree_impl(beg,end); } #endif #ifdef carray bool make_tree(const C_Data *beg, const C_Data *end){ return make_tree_impl(beg,end); } #endif // the tree is build according to the input elements in [first,last) template inline bool make_tree_impl(T first, T last) // af: was & todo: can we turn it in const& ?? { link_type leftchild, rightchild, prevchild, leftmostlink; if(!is_built) is_built = true; else return false; int n = std::distance(first, last); if(n==0) { is_built = false; return true; } dynamic_merge(first, last); leftmostlink = 0; T sublevel_first, sublevel_last; build_range_tree(n, leftchild, rightchild, prevchild, leftmostlink, first, last, sublevel_first, sublevel_last); header = new Range_tree_node2(); header->right_link = rightchild; header->parent_link = prevchild; header->left_link = leftmostlink; return true; } std::back_insert_iterator< std::list< C_Data> > window_query ( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, typename tbt::lbit * =0){ return window_query_impl(win,out); } std::back_insert_iterator< std::vector< C_Data> > window_query ( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out, typename tbt::vbit * =0){ return window_query_impl(win,out); } #ifdef carray C_Data *window_query( C_Window const &win, C_Data *out){ return window_query_impl(win,out); } #endif #ifdef ostreamiterator std::ostream_iterator< C_Data> window_query( C_Window const &win, std::ostream_iterator< C_Data> out, typename tbt::oit *dummy=0){ return window_query_impl(win,out); } #endif // all elements that ly in win are inserted in result template inline X window_query_impl( C_Window const &win, X result) { if(is_less_equal(interface.get_right(win), interface.get_left(win))) return result; if(root()==0) return result; link_type split_node = findSplitNode(win); if(left(split_node)==0) { if(is_inside(win,split_node->object)) (*result++)=split_node->object; } else { link_type v = (link_type) split_node->left_link; while(left(v)!=0) { if(is_less_equal(interface.get_left(win),v->key)) { link_type w = right(v); if(left(w)!=0) { Tree_base *T= (w)->sublayer; if(T->is_anchor()) report_subtree(w,result); else T->window_query(win, result); } else if(is_inside(win,w->object)) (*result++)=(w)->object; v = left(v); } else v = right(v); } // end while if(is_inside(win,v->object)) (*result++)=v->object; v = right(split_node); while(right(v)!=0) { // if(is_less_equal(v->key, interface.get_right(win))) closed interval if(interface.comp(v->key, interface.get_right(win))) //half open interval { if(left(left(v))!=0) { Tree_base *T= (left(v))->sublayer; if(T->is_anchor()) report_subtree(left(v),result); else T->window_query(win, result); } else { if(is_inside(win,left(v)->object)) (*result++)=left(v)->object; } v = right(v); } else v = left(v); }//end while if(is_inside(win,v->object)) { (*result++)=v->object; } } return result; } std::back_insert_iterator< std::list< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, typename tbt::lbit * =0){ return enclosing_query_impl(win,out); } std::back_insert_iterator< std::vector< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out, typename tbt::vbit * =0){ return enclosing_query_impl(win,out); } #ifdef carray C_Data *enclosing_query( C_Window const &win, C_Data *out){ return enclosing_query_impl(win,out); } #endif #ifdef ostreamiterator std::ostream_iterator< C_Data> enclosing_query( C_Window const &win, std::ostream_iterator< C_Data> out, typename tbt::oit *dummy=0){ return enclosing_query_impl(win,out); } #endif // a window query is performed template inline T enclosing_query_impl(C_Window const &win, T result) { return window_query_impl(win, result); } bool is_valid() const { link_type u,v,w; u=v=w=root(); if(v!=0) return is_valid(u, v, w); return true; } }; CGAL_END_NAMESPACE #endif // CGAL_RANGE_TREE_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_conic_traits_2.h0000644000175000017500000012164311344301500030706 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_conic_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_ARR_CONIC_TRAITS_2_CORE_H #define CGAL_ARR_CONIC_TRAITS_2_CORE_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*! * Arrangement traits for conic arcs. * * The class is templated with two parameters: * Int_kernel_ is a kernel that provides the input points or coefficients. * Int_kernel_::FT must be of an integral type (e.g. CORE:BigInt). * Alg_kernel_ is a geometric kernel, where Kernel_::FT is the number type * for the coordinates of points, which are algebraic numbers * (preferably it is CORE::Expr). */ template class Arr_conic_traits_2 { public: typedef Int_kernel_ Int_kernel; typedef Alg_kernel_ Alg_kernel; typedef typename Int_kernel::FT CfNT; typedef typename Int_kernel::Point_2 Int_point_2; typedef typename Int_kernel::Segment_2 Int_segment_2; typedef typename Int_kernel::Line_2 Int_line_2; typedef typename Int_kernel::Circle_2 Int_circle_2; typedef typename Alg_kernel::FT CoNT; typedef Tag_true Has_left_category; typedef Tag_false Has_reflect_category; // The difference between Curve_2 and X_monotone_curve_2 is semantical only, // NOT syntactical. typedef Conic_arc_2 Curve_2; typedef Curve_2 X_monotone_curve_2; typedef typename Curve_2::Alg_kernel R; typedef typename Curve_2::Point_2 Point_2; // For backward compatibility: typedef Curve_2 Curve; typedef X_monotone_curve_2 X_curve; typedef Point_2 Point; #ifdef CGAL_CONIC_ARC_USE_CACHING private: typedef typename Curve_2::Intersections Intersections; mutable std::list inter_list; // For caching intersections. #endif public: /*! * Constructor. */ Arr_conic_traits_2() {} /*! * Destructor. */ ~Arr_conic_traits_2() { #ifdef CGAL_CONIC_ARC_USE_CACHING inter_list.clear(); #endif } ////////// Planar Map methods: ////////// /*! * Compare the x-coordinates of two given points. * \param p1 The first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL. */ Comparison_result compare_x(const Point_2& p1, const Point_2& p2) const { return (p1.compare_x (p2)); } /*! * Compares lexigoraphically the two points: by x, then by y. * \param p1 Te first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL. */ Comparison_result compare_xy(const Point_2& p1, const Point_2& p2) const { return (p1.compare_lex_xy (p2)); } /*! * Check whether the given curve is a vertical segment. * \param curve The curve. * \return (true) if the curve is vertical. */ bool curve_is_vertical(const X_monotone_curve_2& curve) const { CGAL_precondition (curve.is_valid()); return (curve.is_vertical_segment()); } /*! * Check whether the given point is in the x-range of the given curve. * In out case, the curve is a segment [s, t], check whether x(s)<=x(q)<=x(t) * or whether x(t)<=x(q)<=x(s). * \param curve The curve. * \param q The point. * \return (true) if q is in the x-range of cv. */ bool point_in_x_range(const X_monotone_curve_2& curve, const Point_2& p) const { CGAL_precondition (curve.is_valid()); CGAL_precondition(is_x_monotone(curve)); if (curve.is_vertical_segment()) { // Check if the vertical segment's x coordinate is the same as p's. return (compare_x (curve.source(), p) == EQUAL); } else { // Since the curve is x-monotone, if the point x coordinate is to the // left (or to the right of both curve's source and target points), then // the point is obviously not in the curve's x range. Comparison_result res1 = compare_x(p, curve.source()); Comparison_result res2 = compare_x(p, curve.target()); return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); } } /*! * Get the relative status of two curves at the x-coordinate of a given * point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p The point. * \pre The point p is in the x-range of the two curves. * \return LARGER if cv1(x(p)) > cv2(x(p)); SMALLER if cv1(x(p)) < cv2(x(p)); * or else EQUAL. */ Comparison_result curves_compare_y_at_x (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); CGAL_precondition(point_in_x_range(curve1, p)); CGAL_precondition(point_in_x_range(curve2, p)); // If both curves contain p, they are obviously equal at x(p). if (curve1.contains_point(p) && curve2.contains_point(p)) return (EQUAL); // Get the points on curve1 with the same x coordinate as p. int n1; Point_2 ps1[2]; if (curve1.is_vertical_segment()) { // In case curve1 is a vertical segment, both the source and target // of the curve has the same x coordinate as p. // Make sure that ps1[0] has a smaller y value than ps1[1]. n1 = 2; if (curve1.source().compare_y (curve1.target()) == SMALLER) { ps1[0] = curve1.source(); ps1[1] = curve1.target(); } else { ps1[0] = curve1.target(); ps1[1] = curve1.source(); } } else if (compare_x(p, curve1.source()) == EQUAL) { ps1[0] = curve1.source(); n1 = 1; } else if (compare_x(p, curve1.target()) == EQUAL) { ps1[0] = curve1.target(); n1 = 1; } else { // Find all points on curve1 with the same x coordinate as p. n1 = curve1.get_points_at_x (p, ps1); CGAL_assertion(n1 == 1); } // Get the points on curve2 with the same x coordinate as p. int n2; Point_2 ps2[2]; if (curve2.is_vertical_segment()) { // In case curve2 is a vertical segment, both the source and target // of the curve has the same x coordinate as p. // Make sure that ps2[0] has a smaller y value than ps2[1]. n2 = 2; if (curve2.source().compare_y (curve2.target()) == SMALLER) { ps2[0] = curve2.source(); ps2[1] = curve2.target(); } else { ps2[0] = curve2.target(); ps2[1] = curve2.source(); } } else if (compare_x(p, curve2.source()) == EQUAL) { ps2[0] = curve2.source(); n2 = 1; } else if (compare_x(p, curve2.target()) == EQUAL) { ps2[0] = curve2.target(); n2 = 1; } else { // Find all points on curve2 with the same x coordinate as p. n2 = curve2.get_points_at_x (p, ps2); CGAL_assertion(n2 == 1); } // Deal with vertical segments: if (n1 == 2) { // Check if the vertical segment curve1 contains ps2[0] or ps2[1]. if (ps1[0].compare_y (ps2[0]) != LARGER && ps1[1].compare_y (ps2[0]) != SMALLER) { return (EQUAL); } if (n2 == 2) { if (ps1[0].compare_y (ps2[1]) != LARGER && ps1[1].compare_y (ps2[1]) != SMALLER) { return (EQUAL); } } } else if (n2 == 2) { // Check if the vertical segment curve2 contains ps1[0]. if (ps2[0].compare_y (ps1[0]) != LARGER && ps2[1].compare_y (ps1[0]) != SMALLER) { return (EQUAL); } } // None of the curves is a vertical segments and both have exactly // one point with the given x coordinate: // Compare the y coordinates of these two points. return (ps1[0].compare_y (ps2[0])); } /*! * Compare the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p The point. * \pre The point p is in the x range of the two curves, and both of them * must be also be defined to its left. Furthermore, cv1(x(p) == cv2(x(p)). * \return The relative position of cv1 with respect to cv2 to the left of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_left (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // The two curve must not be vertical segments. CGAL_precondition(! curve1.is_vertical_segment()); CGAL_precondition(! curve2.is_vertical_segment()); // Check that both curves are defined to the left of p. CGAL_precondition((compare_x(curve1.source(), p) == SMALLER) || (compare_x(curve1.target(), p) == SMALLER)); CGAL_precondition((compare_x(curve2.source(), p) == SMALLER) || (compare_x(curve2.target(), p) == SMALLER)); // Get the points on curve1 with the same x coordinate as p. int n1; Point_2 ps1[2]; if (curve1.contains_point(p)) { ps1[0] = p; n1 = 1; } else { n1 = curve1.get_points_at_x (p, ps1); } // Make sure that there is exactly one point. CGAL_assertion(n1 == 1); // Get the points on curve2 with the same x coordinate as p. int n2; Point_2 ps2[2]; if (curve2.contains_point(p)) { ps2[0] = p; n2 = 1; } else { n2 = curve2.get_points_at_x (p, ps2); } // Make sure that there is exactly one point. CGAL_assertion(n2 == 1); // The two curves must intersect at x(p). CGAL_precondition (ps1[0].compare_y (ps2[0]) == EQUAL); // If the two curves are equal: if (curve1.equals (curve2)) return (EQUAL); // The two curves intersect at ps1[0] = ps2[0] - proceed from here. return (_curve_compare_at_intersection_left (curve1, curve2, ps1[0])); } /*! * Compare the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p The point. * \pre The point p is in the x range of the two curves, and both of them * must be also be defined to its right. Furthermore, cv1(x(p) == cv2(x(p)). * \return The relative position of cv1 with respect to cv2 to the right of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_right (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // The two curve must not be vertical segments. CGAL_precondition(! curve1.is_vertical_segment()); CGAL_precondition(! curve2.is_vertical_segment()); // Check that both curves are defined to the right of p. CGAL_precondition((compare_x(curve1.source(), p) == LARGER) || (compare_x(curve1.target(), p) == LARGER)); CGAL_precondition((compare_x(curve2.source(), p) == LARGER) || (compare_x(curve2.target(), p) == LARGER)); // Get the points on curve1 with the same x coordinate as p. int n1; Point_2 ps1[2]; if (curve1.contains_point(p)) { ps1[0] = p; n1 = 1; } else { n1 = curve1.get_points_at_x (p, ps1); } // Make sure we have a single point. CGAL_assertion(n1 == 1); // Get the points on curve2 with the same x coordinate as p. int n2; Point_2 ps2[2]; if (curve2.contains_point(p)) { ps2[0] = p; n2 = 1; } else { n2 = curve2.get_points_at_x (p, ps2); } // Make sure we have a single point. CGAL_assertion(n2 == 1); // The two curves must intersect at p(x). CGAL_precondition (ps1[0].compare_y (ps2[0]) == EQUAL); // If the two curves are equal: if (curve1.equals (curve2)) return (EQUAL); // The two curves intersect at ps1[0] = ps2[0] - proceed from here: return (_curve_compare_at_intersection_right (curve1, curve2, ps1[0])); } /*! * Return the location of the given point with respect to the input curve. * \param p The point. * \param curve The curve (cv). * \pre p is in the x-range of the curve. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x(const Point_2& p, const X_monotone_curve_2& curve) const { CGAL_precondition (curve.is_valid()); CGAL_precondition(is_x_monotone(curve)); CGAL_precondition(point_in_x_range(curve,p)); // A special treatment for vertical segments: if (curve.is_vertical_segment()) { // In case p has the same x c-ordinate of the vertical segment, compare // it to the segment endpoints to determine its position. Comparison_result res1 = p.compare_y (curve.source()); Comparison_result res2 = p.compare_y (curve.target()); if (res1 == res2) return (res1); else return (EQUAL); } // Check whether the point is exactly on the curve. if (curve.contains_point(p)) return (EQUAL); // Get the points on the arc with the same x coordinate as p. int n; Point_2 ps[2]; if (compare_x(p, curve.source()) == EQUAL) { ps[0] = curve.source(); n = 1; } else if (compare_x(p, curve.target()) == EQUAL) { ps[0] = curve.target(); n = 1; } else { n = curve.get_points_at_x (p, ps); } // Make sure there is exactly one point. CGAL_assertion(n == 1); // Compare p with the a point of the curve with the same x coordinate. return (p.compare_y(ps[0])); } /*! * Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal (const Point_2& p1, const Point_2& p2) const { return (p1.equals(p2)); } /*! * Check if the two curves are the same (have the same graph). * \param curve1 The first curve. * \param curve2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); return (curve1.equals (curve2)); } /*! * Get the curve source. * \param curve The curve. * \return The source point. */ const Point_2& curve_source (const X_monotone_curve_2& curve) const { CGAL_precondition (curve.is_valid()); return (curve.source()); } /*! * Get the curve target. * \param curve The curve. * \return The target point. */ const Point_2& curve_target (const X_monotone_curve_2& curve) const { CGAL_precondition (curve.is_valid()); return (curve.target()); } /*! * Flip a given curve (swap the source and target and flip the orientation). * \param curve The input curve. * \return The flipped curve. */ X_monotone_curve_2 curve_opposite (const X_monotone_curve_2& curve) const { CGAL_precondition (curve.is_valid()); // Flip the arc. return (curve.flip()); } /*! * Check whether the curve is x-monotone. * \param curve The curve. * \return (true) if the curve is x-monotone. */ bool is_x_monotone (const Curve_2& curve) const { return (curve.is_x_monotone()); } /*! Cut the given curve into x-monotone subcurves and inserts them to the * given output iterator. * \param curve the input curve * \param o the output iterator * \return The past-the-end iterator */ template OutputIterator curve_make_x_monotone (const Curve_2& curve, OutputIterator o) const { CGAL_precondition (curve.is_valid()); // Find the points of vertical tangency and act accordingly. int n; Point_2 ps[2]; n = curve.vertical_tangency_points (ps); if (n == 0) { // In case the given curve is already x-monotone: *o++ = curve; return (o); } // Split the conic arc into x-monotone sub-curves. if (curve.is_full_conic()) { // Make sure we have two vertical tangency points. CGAL_assertion(n == 2); // In case the curve is a full conic, split it to two x-monotone curves, // one going from ps[0] to ps[1], and the other from ps[1] to ps[0]. *o++ = X_monotone_curve_2 (curve, ps[0], ps[1]); *o++ = X_monotone_curve_2 (curve, ps[1], ps[0]); } else { X_monotone_curve_2 sub_curve1; X_monotone_curve_2 sub_curve2; X_monotone_curve_2 sub_curve3; if (n == 1) { // Split the arc into two x-monotone sub-curves: one going from the // arc source to ps[0], and the other from ps[0] to the target. _curve_split (curve, sub_curve1, sub_curve2, ps[0]); *o++ = sub_curve1; *o++ = sub_curve2; } else if (n == 2) { // Split the arc into three x-monotone sub-curves: one going from the // arc source to ps[0], one from ps[0] to ps[1], and the last one // from ps[1] to the target. // Notice that ps[0] and ps[1] might switch places. X_monotone_curve_2 temp; _curve_split (curve, sub_curve1, sub_curve2, ps[0]); if (sub_curve2.contains_point(ps[1])) { temp = sub_curve2; _curve_split (temp, sub_curve2, sub_curve3, ps[1]); } else if (sub_curve1.contains_point(ps[1])) { // Actually we switch between ps[0] and ps[1]. temp = sub_curve1; sub_curve3 = sub_curve2; _curve_split (temp, sub_curve1, sub_curve2, ps[1]); } else { // We should never reach here: CGAL_assertion(false); } *o++ = sub_curve1; *o++ = sub_curve2; *o++ = sub_curve3; } else { // We should never reach here: CGAL_assertion(false); } } return (o); } /*! * Split a given curve at a given split point into two sub-curves. * \param curve The curve to split. * \param sub_curve1 The output first part of the split curve. * Its source is the source of the original curve. * \param sub_curve2 The output second part of the split curve. * Its target is the target of the original curve. * \param p the split point. * \pre p lies on the curve but is not one of its end-points. */ void curve_split (const X_monotone_curve_2& curve, X_monotone_curve_2& sub_curve1, X_monotone_curve_2& sub_curve2, const Point_2& p) const { CGAL_precondition (curve.is_valid()); CGAL_precondition(is_x_monotone(curve)); // Make sure the point is on the curve and is not an end-point. CGAL_precondition(curve.contains_point(p)); CGAL_precondition(! p.equals(curve.source())); CGAL_precondition(! p.equals(curve.target())); // Split the curve. _curve_split (curve, sub_curve1, sub_curve2, p); return; } /*! * Merge a two given curves into one curve. * \param sub_curve1 The first curve to be merged. * \param sub_curve2 The second curve to be merged. * \param curve The resulting merged curve. * \pre The two input curves have the same supporting conic and share * a common endpoint. */ void curve_merge (const X_monotone_curve_2& sub_curve1, const X_monotone_curve_2& sub_curve2, Curve_2& curve) const { CGAL_precondition (sub_curve1.is_valid()); CGAL_precondition (sub_curve2.is_valid()); CGAL_precondition(is_x_monotone(sub_curve1)); CGAL_precondition(is_x_monotone(sub_curve2)); CGAL_precondition(sub_curve1.has_same_base_conic(sub_curve2)); // Make sure the point is on the curve and is not an end-point. if (sub_curve2.source().equals(sub_curve1.target())) { curve = X_monotone_curve_2 (sub_curve1, sub_curve1.source(), sub_curve2.target()); } else if (sub_curve2.source().equals(sub_curve1.source())) { curve = X_monotone_curve_2 (sub_curve1, sub_curve1.target(), sub_curve2.target()); } else if (sub_curve2.target().equals(sub_curve1.target())) { curve = X_monotone_curve_2 (sub_curve1, sub_curve1.source(), sub_curve2.source()); } else if (sub_curve2.target().equals(sub_curve1.source())) { curve = X_monotone_curve_2 (sub_curve2, sub_curve2.source(), sub_curve1.target()); } else { // No common endpoint found. bool found_common_endpoint = false; CGAL_precondition (found_common_endpoint); } return; } /*! * Find the nearest intersection of the two given curves to the right of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the right of the reference point (that is, whose * left endpoint is the projection of the reference point onto the * overlapping subcurve). * \param curve1 The first curve. * \param curve2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the right of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_right (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // Deal with overlapping curves: X_monotone_curve_2 ovlp_arcs[2]; const int n_ovlps = curve1.overlaps (curve2, ovlp_arcs); CGAL_assertion (n_ovlps < 2); if (n_ovlps == 1) { Point_2 p1, p2; // An overlapping sub-arc was found. Trim it so it would be entirely // to the right of p. Point_2 ovlp_source = ovlp_arcs[0].source(); Point_2 ovlp_target = ovlp_arcs[0].target(); if (ovlp_source.compare_lex_xy(p) == LARGER && ovlp_target.compare_lex_xy(p) == LARGER) { // The entire overlapping arc is to the right of p: p1 = ovlp_source; p2 = ovlp_target; } else if (ovlp_source.compare_lex_xy(p) != LARGER && ovlp_target.compare_lex_xy(p) == LARGER) { // The source is to the left of p, and the traget is to its right. Point_2 vps[2]; CGAL_assertion_code(int n_ps = curve1.get_points_at_x (p, vps);) CGAL_assertion (n_ps == 1); p1 = vps[0]; p2 = ovlp_target; } else if (ovlp_source.compare_lex_xy(p) == LARGER && ovlp_target.compare_lex_xy(p) != LARGER) { // The source is to the right of p, and the traget is to its left. Point_2 vps[2]; CGAL_assertion_code(int n_ps = curve1.get_points_at_x (p, vps);) CGAL_assertion (n_ps == 1); p1 = ovlp_source; p2 = vps[0]; } else { // The entire overlapping arc is to the left of p: return Object(); } // Return the overlapping conic arc. return (CGAL::make_object (X_monotone_curve_2 (curve1, p1, p2))); } // In case there are no overlaps and the base conics are the same, // there cannot be any intersection points, unless the two x-monotone // curves share an end point. if (curve1.has_same_base_conic(curve2)) { const Point_2 *nearest_end_P = NULL; if ((curve1.source().equals(curve2.source()) || curve1.source().equals(curve2.target())) && curve1.source().compare_lex_xy(p) == LARGER) { nearest_end_P = &(curve1.source()); } if ((curve1.target().equals(curve2.source()) || curve1.target().equals(curve2.target())) && curve1.target().compare_lex_xy(p) == LARGER) { if (nearest_end_P == NULL || nearest_end_P->compare_lex_xy (curve1.target()) == LARGER) { nearest_end_P = &(curve1.target()); } } if (nearest_end_P != NULL) { // A common end point was found: return (CGAL::make_object (*nearest_end_P)); } else { // No intersection: return Object(); } } // Find the intersection points and choose the one nearest to p. int n; Point_2 ps[4]; const Point_2 *nearest_inter_P = NULL; int i; #ifdef CGAL_CONIC_ARC_USE_CACHING n = curve1.intersections_with (curve2, ps, &inter_list); #else n = curve1.intersections_with (curve2, ps); #endif for (i = 0; i < n; i++) { // Check if the current point is to the right of p. if (ps[i].compare_lex_xy(p) == LARGER) { // Compare with the nearest point so far. if (nearest_inter_P == NULL || nearest_inter_P->compare_lex_xy (ps[i]) == LARGER) { nearest_inter_P = &(ps[i]); } } } if (nearest_inter_P != NULL) { // Return the nearest intersection point. return (CGAL::make_object (*nearest_inter_P)); } // No intersection found to the right of p: return Object(); } /*! * Find the nearest intersection of the two given curves to the left of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the left of the reference point (that is, whose * right endpoint is the projection of the reference point onto the * overlapping subcurve). * \param curve1 The first curve. * \param curve2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the left of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_left (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // Deal with overlapping curves: X_monotone_curve_2 ovlp_arcs[2]; const int n_ovlps = curve1.overlaps (curve2, ovlp_arcs); CGAL_assertion (n_ovlps < 2); if (n_ovlps == 1) { Point_2 p1, p2; // An overlapping sub-arc was found. Trim it so it would be entirely // to the left of p. Point_2 ovlp_source = ovlp_arcs[0].source(); Point_2 ovlp_target = ovlp_arcs[0].target(); if (ovlp_source.compare_lex_xy(p) == SMALLER && ovlp_target.compare_lex_xy(p) == SMALLER) { // The entire overlapping arc is to the left of p: p1 = ovlp_source; p2 = ovlp_target; } else if (ovlp_source.compare_lex_xy(p) != SMALLER && ovlp_target.compare_lex_xy(p) == SMALLER) { // The source is to the right of p, and the traget is to its left. Point_2 vps[2]; CGAL_assertion_code(int n_ps = curve1.get_points_at_x (p, vps);) CGAL_assertion (n_ps == 1); p1 = vps[0]; p2 = ovlp_target; } else if (ovlp_source.compare_lex_xy(p) == SMALLER && ovlp_target.compare_lex_xy(p) != SMALLER) { // The source is to the left of p, and the traget is to its right. Point_2 vps[2]; CGAL_assertion_code(int n_ps = curve1.get_points_at_x (p, vps);) CGAL_assertion (n_ps == 1); p1 = ovlp_source; p2 = vps[0]; } else { // The entire overlapping arc is to the right of p: return Object(); } // Return the overlapping conic arc. return (CGAL::make_object (X_monotone_curve_2 (curve1, p1, p2))); } // In case there are no overlaps and the base conics are the same, // there cannot be any intersection points, unless the two x-monotone // curves share an end point. if (curve1.has_same_base_conic(curve2)) { const Point_2 *nearest_end_P = NULL; if ((curve1.source().equals(curve2.source()) || curve1.source().equals(curve2.target())) && curve1.source().compare_lex_xy(p) == SMALLER) { nearest_end_P = &(curve1.source()); } if ((curve1.target().equals(curve2.source()) || curve1.target().equals(curve2.target())) && curve1.target().compare_lex_xy(p) == SMALLER) { if (nearest_end_P == NULL || nearest_end_P->compare_lex_xy (curve1.target()) == SMALLER) { nearest_end_P = &(curve1.target()); } } if (nearest_end_P != NULL) { // A common end point was found: return (CGAL::make_object (*nearest_end_P)); } else { // No intersection: return Object(); } } // Find the intersection points and choose the one nearest to p. int n; Point_2 ps[4]; const Point_2 *nearest_inter_P = NULL; int i; #ifdef CGAL_CONIC_ARC_USE_CACHING n = curve1.intersections_with (curve2, ps, &inter_list); #else n = curve1.intersections_with (curve2, ps); #endif for (i = 0; i < n; i++) { // Check if the current point is to the left of p. if (ps[i].compare_lex_xy(p) == SMALLER) { // Compare with the nearest point so far. if (nearest_inter_P == NULL || nearest_inter_P->compare_lex_xy (ps[i]) == SMALLER) { nearest_inter_P = &(ps[i]); } } } if (nearest_inter_P != NULL) { // Return the nearest intersection point. return (CGAL::make_object (*nearest_inter_P)); } // No intersection found to the left of p: return Object(); } /*! * Check whether the two given curves overlap. * \patam curve1 The first curve. * \patam curve2 The second curve. * \return (true) if the two curves overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, if they have a finite * number of intersection points, or none at all, return (false). */ bool curves_overlap (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2) const { CGAL_precondition (curve1.is_valid()); CGAL_precondition (curve2.is_valid()); CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); X_monotone_curve_2 ovlp_arcs[2]; return (curve1.overlaps (curve2, ovlp_arcs) > 0); } private: ////////// Private auxiliary methods: ////////// /*! * Split the given curve into two sub-curves at the given point which lies * on the curve's interior. * \param curve The curve to split. * \param sub_curve1 The output first part of the split curve. * Its source is the source of the original curve. * \param sub_curve2 The output second part of the split curve. * Its target is the target of the original curve. * \param p the split point. */ void _curve_split (const X_monotone_curve_2& curve, X_monotone_curve_2& sub_curve1, X_monotone_curve_2& sub_curve2, const Point_2& p) const { // Split the curve to source->p and p->target. sub_curve1 = X_monotone_curve_2 (curve, curve.source(), p); sub_curve2 = X_monotone_curve_2 (curve, p, curve.target()); return; } /*! * Compare the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p_int Their intersection point. * \return The relative position of cv1 with respect to cv2 to the left of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result _curve_compare_at_intersection_left (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p_int) const { // In case one arc is facing upwards and another facing downwards, it is // very clear that the one facing upward is above the one facing downwards. if (curve1.has_same_base_conic(curve2)) { Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); } // Otherwise, since the two curves do intersect at p_int, make a decision // based on their partial derivatives. const CoNT _zero = 0; CoNT slope1_numer, slope1_denom; CoNT slope2_numer, slope2_denom; curve1.derive_by_x_at (p_int, 1, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 1, slope2_numer, slope2_denom); const bool is_vertical_slope1 = (slope1_denom == _zero); const bool is_vertical_slope2 = (slope2_denom == _zero); if (!is_vertical_slope1 && !is_vertical_slope2) { // The two curves have derivatives at p_int: use it to determine which // one is above the other (the one with a smaller slope in above). Comparison_result slope_res = CGAL::compare(slope2_numer*slope1_denom, slope1_numer*slope2_denom); if (slope_res != EQUAL) return (slope_res); // Use the second order derivative. curve1.derive_by_x_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 2, slope2_numer, slope2_denom); slope_res = CGAL::compare (slope2_numer*slope1_denom, slope1_numer*slope2_denom); return ((slope_res == LARGER) ? SMALLER : LARGER); } else if (!is_vertical_slope2) { // The first curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac1 = curve1.facing(); CGAL_assertion(fac1 != EQUAL); return (fac1); } else if (!is_vertical_slope1) { // The second curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac2 = curve2.facing(); CGAL_assertion(fac2 != EQUAL); return ((fac2 == LARGER) ? SMALLER : LARGER); } else { // The two curves have vertical slopes at p_int: // First check whether one is facing up and one down. In this case the // comparison result is trivial. Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); // Compute the second order derivative by y and act according to it. curve1.derive_by_y_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_y_at (p_int, 2, slope2_numer, slope2_denom); Comparison_result slope_res = CGAL::compare(slope2_numer*slope1_denom, slope1_numer*slope2_denom); CGAL_assertion(slope_res != EQUAL); if (fac1 == LARGER && fac2 == LARGER) { // Both are facing up. return ((slope_res == LARGER) ? SMALLER : LARGER); } else { // Both are facing down. return (slope_res); } } // We should never reach here: CGAL_assertion(false); return (EQUAL); } /*! * Compare the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p_int Their intersection point. * \return The relative position of cv1 with respect to cv2 to the left of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result _curve_compare_at_intersection_right (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p_int) const { // In case one arc is facing upwards and another facing downwards, it is // very clear that the one facing upward is above the one facing downwards. if (curve1.has_same_base_conic(curve2)) { Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); } // Otherwise, the two curves do intersect at p_int, make a decision based // on their partial derivatives. const CoNT _zero = 0; CoNT slope1_numer, slope1_denom; CoNT slope2_numer, slope2_denom; curve1.derive_by_x_at (p_int, 1, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 1, slope2_numer, slope2_denom); const bool is_vertical_slope1 = (slope1_denom == _zero); const bool is_vertical_slope2 = (slope2_denom == _zero); if (!is_vertical_slope1 && !is_vertical_slope2) { // The two curves have derivatives at p_int: use it to determine which // one is above the other (the one with a larger slope is below). Comparison_result slope_res = CGAL::compare (slope1_numer*slope2_denom, slope2_numer*slope1_denom); if (slope_res != EQUAL) return (slope_res); // Use the second order derivative. curve1.derive_by_x_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 2, slope2_numer, slope2_denom); slope_res = CGAL::compare (slope1_numer*slope2_denom, slope2_numer*slope1_denom); return (slope_res); } else if (!is_vertical_slope2) { // The first curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac1 = curve1.facing(); CGAL_assertion(fac1 != EQUAL); return (fac1); } else if (!is_vertical_slope1) { // The second curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac2 = curve2.facing(); CGAL_assertion(fac2 != EQUAL); return ((fac2 == LARGER) ? SMALLER : LARGER); } else { // The two curves have vertical slopes at p_int: // First check whether one is facing up and one down. In this case the // comparison result is trivial. Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); // Compute the second order derivative by y and act according to it. curve1.derive_by_y_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_y_at (p_int, 2, slope2_numer, slope2_denom); Comparison_result slope_res = CGAL::compare (slope1_numer*slope2_denom, slope2_numer*slope1_denom); CGAL_assertion(slope_res != EQUAL); if (fac1 == LARGER && fac2 == LARGER) { // Both are facing up. return ((slope_res == LARGER) ? SMALLER : LARGER); } else { // Both are facing down. return (slope_res); } } // We should never reach here: CGAL_assertion(false); return (EQUAL); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_simplicity.h0000644000175000017500000004236611344301500031322 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_simplicity.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POLYGON_2_SIMPLICITY_H #define CGAL_POLYGON_2_SIMPLICITY_H #include #include #include #include #include /* A polygon is called simple of no edges intersect each other, except consecutive edges, which intersect in their common vertex. The test for simplicity is implemented by means of a sweep line algorithm. The vertical line is swept from left to right. The edges of the polygon that are crossed by the sweep line are stored in a tree from bottom to top. We discern three types of events: - insertion events. When both edges of a polygon vertex extend to the right we need to insert both edges in the tree. We need to search with the vertex to find out between which edges the new edges are to be inserted. - deletion events. When both edges extend to the left of the vertex we need to remove both edges from the tree. We have to check that the vertex lies between the edges above and below the removed edges. - replacement event. In the other case we need to replace the edge that extends to the left by the edge that extends to the right. We need to check that the vertex lies between the edges above and below the current edge. We represent the tree by a std::set. This is not a perfect fit for the operations described above. In particular, the fact that we search with a VERTEX, while the set contains EDGES, is not directly supported. The insertion of edges is also complicated by the fact that we need to insert two edges starting at the same vertex. The order in which they are inserted in the tree does matter, because the edges go in separate directions. Because of this the set needs a special associated comparison function. Every edge has a flag 'is_in_tree', which is true for the edges in the tree but false for the edges when they are inserted. The comparison function treats the latter type of edge as a vertex. Another flag, is_left_to_right, tells which of the two vertices to take. The problem of the coinciding vertices is solved by the convention that the highest edges is always inserted first. The comparison function uses this fact. Vertex indices of the polygon play a double role. The number v can be used to identify vertex v or the edge from vertex v to vertex v+1. */ namespace CGAL { namespace i_polygon { // namespace CGAL::i_polygon is used for internal functions typedef std::vector::size_type Index_t; struct Vertex_index { Vertex_index() {} explicit Vertex_index(Index_t i): m_i(i) {} Index_t as_int() const {return m_i;} Vertex_index operator++() {++m_i; return *this; } private: Index_t m_i; }; struct Vertex_order { explicit Vertex_order(Index_t i): m_i(i) {} Index_t as_int() {return m_i;} private: Index_t m_i; }; template class Vertex_data ; template class Less_segments { typedef VertexData Vertex_data; Vertex_data *m_vertex_data; bool less_than_in_tree(Vertex_index i, Vertex_index j); public: Less_segments(Vertex_data *vertex_data) : m_vertex_data(vertex_data) {} bool operator()(Vertex_index i, Vertex_index j); }; // The data in Edge_data is attached to an edge when it is (about to be) // inserted in the tree. // Although conceptually this data belongs in the tree, it is stored with // the vertices in the Vertex_data structure. template struct Edge_data { typedef std::set Tree; Edge_data() : is_in_tree(false) {} Edge_data(typename Tree::iterator it) : tree_it(it), is_in_tree(false) {} typename Tree::iterator tree_it; // The iterator of the edge in the tree. // Needed for cross reference. If edge j // is in the tree: *edges[j].tree_it == j bool is_in_tree :1; // Must be set -after- inserting the edge // in the tree. Plays a role in the // comparison function of the tree. bool is_left_to_right :1; // Direction of edge from vertex v to v+1 }; template class Vertex_data_base { public: typedef typename PolygonTraits::Point_2 Point_2; // ForwardIterator points_start; std::vector iterators; std::vector m_order_of; std::vector m_idx_at_rank; std::vector::size_type m_size; typename PolygonTraits::Orientation_2 orientation_2; typename PolygonTraits::Less_xy_2 less_xy_2; bool is_simple_result; Vertex_data_base(ForwardIterator begin, ForwardIterator end, const PolygonTraits& pgnt); bool ordered_left_to_right(Vertex_index v1, Vertex_index v2) { return m_order_of[v1.as_int()].as_int() < m_order_of[v2.as_int()].as_int();} Vertex_index index_at_rank(Vertex_order vo) const { return m_idx_at_rank[vo.as_int()];} Vertex_index next(Vertex_index k) const { ++k; return k.as_int() == m_size ? Vertex_index(0) : k;} Vertex_index prev(Vertex_index k) const { return k.as_int() == 0 ? Vertex_index(m_size-1) : Vertex_index(k.as_int()-1); } Point_2 point(Vertex_index i) { return *iterators[i.as_int()];} // { return points_start[i.as_int()];} }; template class Vertex_data : public Vertex_data_base { public: typedef Vertex_data Self; // Indirection needed by Borland compiler typedef Less_segments Less_segs; typedef std::set Tree; typedef Vertex_data_base Base_class; using Base_class::ordered_left_to_right; using Base_class::next; using Base_class::prev; using Base_class::index_at_rank; using Base_class::point; std::vector > edges; Vertex_data(ForwardIterator begin, ForwardIterator end, const PolygonTraits& pgnt); void init(Tree *tree); void left_and_right_index(Vertex_index &left, Vertex_index &right, Vertex_index edge); Vertex_index left_index(Vertex_index edge) { return edges[edge.as_int()].is_left_to_right ? edge : next(edge); } void sweep(Tree *tree); bool insertion_event(Tree *tree, Vertex_index i, Vertex_index j, Vertex_index k); bool replacement_event(Tree *tree, Vertex_index cur, Vertex_index to_insert); bool deletion_event(Tree *tree, Vertex_index i, Vertex_index j); bool on_right_side(Vertex_index vt, Vertex_index edge, bool above); }; template class Less_vertex_data { VertexData *m_vertex_data; public: Less_vertex_data(VertexData *vd) : m_vertex_data(vd) {} bool operator()(Vertex_index i, Vertex_index j); }; } // end of namespace i_polygon // ----- implementation of i_polygon functions. ----- namespace i_polygon { template bool Less_segments:: operator()(Vertex_index i, Vertex_index j) { if (m_vertex_data->edges[j.as_int()].is_in_tree) { return less_than_in_tree(i,j); } else { return !less_than_in_tree(j,i); } } template bool Less_segments:: less_than_in_tree(Vertex_index new_edge, Vertex_index tree_edge) { CGAL_polygon_precondition( m_vertex_data->edges[tree_edge.as_int()].is_in_tree); CGAL_polygon_precondition( !m_vertex_data->edges[new_edge.as_int()].is_in_tree); Vertex_index left, mid, right; m_vertex_data->left_and_right_index(left, right, tree_edge); mid = m_vertex_data->left_index(new_edge); if (mid.as_int() == left.as_int()) { return true; } switch (m_vertex_data->orientation_2( m_vertex_data->point(left), m_vertex_data->point(mid), m_vertex_data->point(right))) { case LEFT_TURN: return true; case RIGHT_TURN: return false; case COLLINEAR: break; } m_vertex_data->is_simple_result = false; return true; } template bool Less_vertex_data:: operator()(Vertex_index i, Vertex_index j) { return m_vertex_data->less_xy_2( m_vertex_data->point(i), m_vertex_data->point(j)); } template Vertex_data_base:: Vertex_data_base(ForwardIterator begin, ForwardIterator end, const PolygonTraits& pgn_traits) : orientation_2(pgn_traits.orientation_2_object()), less_xy_2(pgn_traits.less_xy_2_object()) { m_size = std::distance(begin, end); is_simple_result = true; m_idx_at_rank.reserve(m_size); iterators.reserve(m_size); m_order_of.insert(m_order_of.end(), m_size, Vertex_order(0)); for (Index_t i = 0; i< m_size; ++i, ++begin) { m_idx_at_rank.push_back(Vertex_index(i)); iterators.push_back(begin); } std::sort(m_idx_at_rank.begin(), m_idx_at_rank.end(), Less_vertex_data(this)); for (Index_t j = 0; j < m_size; ++j) { Vertex_order vo(j); m_order_of[index_at_rank(vo).as_int()] = vo; } } template void Vertex_data:: left_and_right_index(Vertex_index &left, Vertex_index &right, Vertex_index edge) { if (edges[edge.as_int()].is_left_to_right) { left = edge; right = next(edge); } else { right = edge; left = next(edge); } } template Vertex_data:: Vertex_data(ForwardIterator begin, ForwardIterator end, const PolygonTraits& pgn_traits) : Base_class(begin, end, pgn_traits) {} template void Vertex_data::init(Tree *tree) { // The initialization cannot be done in the constructor, // otherwise we copy singular valued iterators. edges.insert(edges.end(), this->m_size, Edge_data(tree->end())); } template bool Vertex_data:: insertion_event(Tree *tree, Vertex_index prev_vt, Vertex_index mid_vt, Vertex_index next_vt) { // check which endpoint is above the other bool left_turn; switch(orientation_2(point(prev_vt), point(mid_vt), point(next_vt))) { case LEFT_TURN: left_turn = true; break; case RIGHT_TURN: left_turn = false; break; default: return false; } Edge_data &td_prev = edges[prev_vt.as_int()], &td_mid = edges[mid_vt.as_int()]; td_prev.is_in_tree = false; td_prev.is_left_to_right = false; td_mid.is_in_tree = false; td_mid.is_left_to_right = true; // insert the highest chain first std::pair result; if (left_turn) { result = tree->insert(prev_vt); // CGAL_polygon_assertion(result.second) td_prev.tree_it = result.first; td_prev.is_in_tree = true; result = tree->insert(mid_vt); // CGAL_polygon_assertion(result.second) td_mid.tree_it = result.first; td_mid.is_in_tree = true; } else { result = tree->insert(mid_vt); // CGAL_polygon_assertion(result.second) td_mid.tree_it = result.first; td_mid.is_in_tree = true; result = tree->insert(prev_vt); // CGAL_polygon_assertion(result.second) td_prev.tree_it = result.first; td_prev.is_in_tree = true; } return true; } template bool Vertex_data:: on_right_side(Vertex_index vt, Vertex_index edge_id, bool above) { Orientation turn = orientation_2(point(edge_id), point(vt), point(next(edge_id))); bool left_turn = edges[edge_id.as_int()].is_left_to_right ? above : !above; if (left_turn) { if (turn != RIGHT_TURN) { return false; } } else { if (turn != LEFT_TURN) { return false; } } return true; } template bool Vertex_data:: replacement_event(Tree *tree, Vertex_index cur_edge, Vertex_index next_edge) { // check if continuation point is on the right side of neighbor segments typedef typename Tree::iterator It; Edge_data &td = edges[cur_edge.as_int()]; CGAL_polygon_assertion(td.is_in_tree); It cur_seg = td.tree_it; Vertex_index cur_vt = (td.is_left_to_right) ? next_edge : cur_edge; if (cur_seg != tree->begin()) { It seg_below = cur_seg; --seg_below; if (!on_right_side(cur_vt, *seg_below, true)) { return false; } } It seg_above = cur_seg; ++ seg_above; if (seg_above != tree->end()) { if (!on_right_side(cur_vt, *seg_above, false)) { return false; } } // replace the segment Edge_data &new_td = edges[next_edge.as_int()]; new_td.is_left_to_right = td.is_left_to_right; new_td.is_in_tree = false; tree->erase(cur_seg); td.is_in_tree = false; new_td.tree_it = tree->insert(seg_above, next_edge); new_td.is_in_tree = true; return true; } template bool Vertex_data:: deletion_event(Tree *tree, Vertex_index prev_vt, Vertex_index mid_vt) { // check if continuation point is on the right side of neighbor segments typedef typename Tree::iterator It; Edge_data &td_prev = edges[prev_vt.as_int()], &td_mid = edges[mid_vt.as_int()]; It prev_seg = td_prev.tree_it, mid_seg = td_mid.tree_it; Vertex_index cur_vt = (td_prev.is_left_to_right) ? mid_vt : prev_vt; It seg_above = prev_seg; ++seg_above; if (seg_above == mid_seg) { ++seg_above; } else { // mid_seg was not above prev_seg, so prev_seg should be above mid_seg // We check this to see if the edges are really neighbors in the tree. It prev_seg_copy = mid_seg; ++prev_seg_copy; if (prev_seg_copy != prev_seg) return false; } // remove the segments tree->erase(prev_seg); td_prev.is_in_tree = false; tree->erase(mid_seg); td_mid.is_in_tree = false; // Check if the vertex that is removed lies between the two tree edges. if (seg_above != tree->end()) { if (!on_right_side(cur_vt, *seg_above, false)) return false; } if (seg_above != tree->begin()) { --seg_above; // which turns it in seg_below if (!on_right_side(cur_vt, *seg_above, true)) return false; } return true; } template void Vertex_data:: sweep(Tree *tree) { if (this->m_size < 3) return; bool succes = true; for (Index_t i=0; i< this->m_size; ++i) { Vertex_index cur = index_at_rank(Vertex_order(i)); Vertex_index prev_vt = prev(cur), next_vt = next(cur); if (ordered_left_to_right(cur, next_vt)) { if (ordered_left_to_right(cur, prev_vt)) succes = insertion_event(tree, prev_vt, cur, next_vt); else succes = replacement_event(tree, prev_vt, cur); } else { if (ordered_left_to_right(cur, prev_vt)) succes = replacement_event(tree, cur, prev_vt); else succes = deletion_event(tree, prev_vt, cur); } if (!succes) break; } if (!succes) this->is_simple_result = false; } } // ----- End of implementation of i_polygon functions. ----- template bool is_simple_polygon(Iterator points_begin, Iterator points_end, const PolygonTraits& polygon_traits) { typedef Iterator ForwardIterator; typedef i_polygon::Vertex_data Vertex_data; typedef std::set > Tree; Vertex_data vertex_data(points_begin, points_end, polygon_traits); Tree tree(&vertex_data); vertex_data.init(&tree); vertex_data.sweep(&tree); return vertex_data.is_simple_result; } } // end of namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Matrix.h0000644000175000017500000000317511344301500026443 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Matrix.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_MATRIX_H #define CGAL_MATRIX_H #include #include #include namespace CGAL { template class Matrix : public std::vector< std::vector > { public: Matrix(std::size_t x = 0, std::size_t y = 0) : std::vector< std::vector > (x, std::vector(y)), _rows(x), _columns(y) {} std::size_t rows() const { return _rows; } std::size_t columns() const { return _columns; } protected: std::size_t _rows; std::size_t _columns; }; template std::ostream& operator<<(std::ostream& os, const Matrix& m) { typedef typename Matrix::size_type size_type; for (size_type i = 0; i < m.rows(); i++) { os << std::endl << i << " : "; for (size_type j = 0; j < m.columns(); j++) { os << m[i][j] << " "; } } return os; } } #endif // CGAL_MATRIX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_container.h0000644000175000017500000002457711344301500030343 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_container.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () // custom point container #ifndef CGAL_POINT_CONTAINER_H #define CGAL_POINT_CONTAINER_H #include #include #include #include #include namespace CGAL { template class Point_container { private: typedef typename Traits::Point_d Point_d; typedef std::vector Point_vector; public: typedef typename Traits::FT FT; typedef typename Point_vector::iterator iterator; private: iterator b, e; // the iterator range of the Point_container int built_coord; // a coordinate for which the pointer list is built Kd_tree_rectangle bbox; // bounding box, i.e. rectangle of node Kd_tree_rectangle tbox; // tight bounding box, // i.e. minimal enclosing bounding // box of points public: inline const Kd_tree_rectangle& bounding_box() const { return bbox; } inline const Kd_tree_rectangle& tight_bounding_box() const { return tbox; } inline int dimension() const { return bbox.dimension(); } inline int built_coordinate() const { return built_coord; } // coordinate of the maximal span inline int max_span_coord() const { return bbox.max_span_coord(); } // coordinate of the maximal tight span inline int max_tight_span_coord() const { return tbox.max_span_coord(); } inline FT max_span_lower() const { return bbox.min_coord(max_span_coord()); } inline FT max_tight_span_lower() const { return tbox.min_coord(max_tight_span_coord()); } inline FT max_span_upper() const { return bbox.max_coord(max_span_coord()); } inline FT max_tight_span_upper() const { return tbox.max_coord(max_tight_span_coord()); } inline FT max_spread() const { return max_span_upper() - max_span_lower(); } inline FT max_tight_spread() const { return max_tight_span_upper() - max_tight_span_lower(); } int max_tight_span_coord_balanced(FT Aspect_ratio) const { int cut_dim(-1); FT max_spread_points(FT(-1)); FT max_length = max_spread(); // length of longest side of box int dim = dimension(); for (int d=0; d max_spread_points) { max_spread_points = spread; cut_dim = d; } } } // CGAL_assertion(cut_dim >= 0); return cut_dim; } FT max_span_upper_without_dim(int d) const { FT max_span(FT(0)); int dim=dimension(); for (int i=0; i max_span) max_span=span; } return max_span; } FT balanced_fair(int d, FT Aspect_ratio) { FT small_piece = max_span_upper_without_dim(d) / Aspect_ratio; FT low_cut = bbox.min_coord(d) + small_piece; // lowest legal cut; FT high_cut = bbox.max_coord(d) - small_piece; //highest legal cut; // CGAL_assertion (high_cut >= low_cut); FT split_value = median(d); if (split_value < low_cut) split_value = low_cut; if (split_value > high_cut) split_value = high_cut; return split_value; } FT balanced_sliding_fair(int d, FT Aspect_ratio) { FT small_piece = max_span_upper_without_dim(d) / Aspect_ratio; FT low_cut = bbox.min_coord(d) + small_piece; // lowest legal cut; FT high_cut = bbox.max_coord(d) - small_piece; //highest legal cut; // CGAL_assertion (high_cut >= low_cut); FT split_value = median(d); FT max_span_lower = tbox.min_coord(d); FT max_span_upper = tbox.max_coord(d); if (split_value < low_cut) split_value= max_span_lower; if (split_value > high_cut) split_value = max_span_upper; return split_value; } // points inline unsigned int size() const { return e - b; } inline iterator begin() const { return b; } inline iterator end() const { return e; } inline bool empty() const { return b == e; } // building the container from a sequence of Point_d* Point_container(const int d, iterator begin, iterator end) : b(begin), e(end), bbox(d, begin, end), tbox(bbox) { built_coord = max_span_coord(); } void set_range(iterator begin, iterator end) { b = begin; e = end; } // building an empty container Point_container(const int d) : b(NULL), e(NULL), bbox(d), tbox(d) {} template struct Cmp { typedef typename Traits2::FT FT; typedef typename Traits2::Point_d Point_d; typedef std::vector Point_vector; int split_coord; FT value; typename Traits2::Construct_cartesian_const_iterator_d construct_it; Cmp(int s, FT c) : split_coord(s), value(c) {} bool operator()(Point_d* pt) const { typename Traits2::Cartesian_const_iterator_d ptit; ptit = construct_it(*pt); return *(ptit+split_coord) < value; } }; template struct Between { typedef typename Traits2::FT FT; typedef typename Traits2::Point_d Point_d; typedef std::vector Point_vector; int split_coord; FT low, high; typename Traits2::Construct_cartesian_const_iterator_d construct_it; Between(int s, FT l, FT h) : split_coord(s), low(l), high(h) {} bool operator()(Point_d* pt) const { typename Traits2::Cartesian_const_iterator_d ptit; ptit = construct_it(*pt); if(! ( *(ptit+split_coord) <= high ) ){ // std::cerr << "Point " << *pt << " exceeds " << high << " in dimension " << split_coord << std::endl; return false; } if(! ( *(ptit+split_coord) >= low ) ){ //std::cerr << "Point " << *pt << " below " << low << " in dimension " << split_coord << std::endl; return false; } return true; } }; void recompute_tight_bounding_box() { tbox.update_from_point_pointers(begin(), end()); } bool is_valid() const { if(empty()) return true; bool b = true; for (int i = 0; i < dimension(); i++){ CGAL_assertion( b = (b && (bbox.min_coord(i) <= tbox.min_coord(i)))); CGAL_assertion( b = (b && (bbox.max_coord(i) >= tbox.max_coord(i)))); Between between(i,tbox.min_coord(i), tbox.max_coord(i)); for(iterator it = begin(); it != end(); it++){ b = (b && between(*it)); } } return b; } // note that splitting is restricted to the built coordinate template void split(Point_container& c, Separator& sep, bool sliding=false) { CGAL_assertion(dimension()==c.dimension()); CGAL_assertion(is_valid()); c.bbox=bbox; const int split_coord = sep.cutting_dimension(); FT cutting_value = sep.cutting_value(); built_coord=split_coord; c.built_coord=split_coord; typename Traits::Construct_cartesian_const_iterator_d construct_it; Cmp cmp(split_coord, cutting_value); iterator it = std::partition(begin(), end(), cmp); // now [begin,it) are lower and [it,end) are upper if (sliding) { // avoid empty lists if (it == begin()) { iterator minelt = std::min_element(begin(),end(),comp_coord_val(split_coord)); if(minelt != it){ std::iter_swap(minelt,it); } cutting_value = *(construct_it(**it)+split_coord); sep.set_cutting_value(cutting_value); it++; } if (it == end()) { iterator maxelt = std::max_element(begin(),end(),comp_coord_val(split_coord)); it--; if(maxelt != it){ std::iter_swap(maxelt,it); } cutting_value = *(construct_it(**it)+split_coord); sep.set_cutting_value(cutting_value); } } c.set_range(begin(), it); set_range(it, end()); // adjusting boxes bbox.set_lower_bound(split_coord, cutting_value); tbox.update_from_point_pointers(begin(), end()); c.bbox.set_upper_bound(split_coord, cutting_value); c.tbox.update_from_point_pointers(c.begin(), c.end()); CGAL_assertion(is_valid()); CGAL_assertion(c.is_valid()); } template struct comp_coord_val { private: Value coord; typedef typename Traits2::Point_d Point_d; public: comp_coord_val (const Value& coordinate) : coord(coordinate) {} bool operator()(const Point_d *a, const Point_d *b) const { typename Traits2::Construct_cartesian_const_iterator_d construct_it; typename Traits2::Cartesian_const_iterator_d ait = construct_it(*a), bit = construct_it(*b); return *(ait+coord) < *(bit+coord); } }; FT median(const int split_coord) { typename Point_vector::iterator mid = begin() + (end() - begin())/2; std::nth_element(begin(), mid, end(),comp_coord_val(split_coord)); typename Traits::Construct_cartesian_const_iterator_d construct_it; typename Traits::Cartesian_const_iterator_d mpit = construct_it((*(*mid))); FT val1 = *(mpit+split_coord); mid++; mpit = construct_it((*(*mid))); FT val2 = *(mpit+split_coord); return (val1+val2)/FT(2); } private: explicit Point_container() {} // disable default constructor }; template std::ostream& operator<< (std::ostream& s, Point_container& c) { s << "Points container of size " << c.size() << "\n cell:"; s << c.bounding_box(); s << "\n minimal box enclosing points:"; s << c.tight_bounding_box(); return s; } } // namespace CGAL #endif // CGAL_POINT_CONTAINER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/0000755000175000017500000000000012146213733027750 5ustar debiandebian././@LongLink0000000000000000000000000000021300000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/constructions_on_weighted_points_cartesian_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/construc0000644000175000017500000002711611344301501031530 0ustar debiandebian#ifndef CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_CARTESIAN_3_H #define CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_CARTESIAN_3_H CGAL_BEGIN_NAMESPACE template void determinants_for_weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &sx, const FT &sy, const FT &sz, const FT &sw, FT &num_x, FT &num_y, FT &num_z, FT& den) { // translate origin to p // and compute determinants for weighted_circumcenter and // circumradius FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz) - qw + pw; FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz) - rw + pw; FT spx = sx-px; FT spy = sy-py; FT spz = sz-pz; FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) + CGAL_NTS square(spz) - sw + pw; num_x = det3x3_by_formula(qpy,qpz,qp2, rpy,rpz,rp2, spy,spz,sp2); num_y = det3x3_by_formula(qpx,qpz,qp2, rpx,rpz,rp2, spx,spz,sp2); num_z = det3x3_by_formula(qpx,qpy,qp2, rpx,rpy,rp2, spx,spy,sp2); den = det3x3_by_formula(qpx,qpy,qpz, rpx,rpy,rpz, spx,spy,spz); } template < class FT> void weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &sx, const FT &sy, const FT &sz, const FT &sw, FT &x, FT &y, FT &z) { // this function compute the weighted circumcenter point only // Translate p to origin and compute determinants FT num_x, num_y, num_z, den; determinants_for_weighted_circumcenterC3(px, py, pz, pw, qx, qy, qz, qw, rx, ry, rz, rw, sx, sy, sz, sw, num_x, num_y, num_z,den); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); FT inv = FT(1)/(FT(2) * den); x = px + num_x*inv; y = py - num_y*inv; z = pz + num_z*inv; } template < class FT> void weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &sx, const FT &sy, const FT &sz, const FT &sw, FT &x, FT &y, FT &z, FT &w) { // this function compute the weighted circumcenter point // and the squared weighted circumradius // Translate p to origin and compute determinants FT num_x, num_y, num_z, den; determinants_for_weighted_circumcenterC3(px, py, pz, pw, qx, qy, qz, qw, rx, ry, rz, rw, sx, sy, sz, sw, num_x, num_y, num_z, den); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); FT inv = FT(1)/(FT(2) * den); x = px + num_x*inv; y = py - num_y*inv; z = pz + num_z*inv; w = (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) *CGAL_NTS square(inv) - pw; } template< class FT > FT squared_radius_orthogonal_sphereC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, const FT &sx, const FT &sy, const FT &sz, const FT &sw) { // this function compute the squared weighted circumradius only // Translate p to origin and compute determinants FT num_x, num_y, num_z, den; determinants_for_weighted_circumcenterC3(px, py, pz, pw, qx, qy, qz, qw, rx, ry, rz, rw, sx, sy, sz, sw, num_x, num_y, num_z,den); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); FT inv = FT(1)/(FT(2) * den); return (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) *CGAL_NTS square(inv) - pw; } template void determinants_for_weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, FT &num_x, FT &num_y, FT &num_z, FT &den) { // translate origin to p // and compute determinants for weighted_circumcenter and // circumradius // Translate s to origin to simplify the expression. FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz) - qw + pw; FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz) - rw + pw; FT sx = qpy*rpz-qpz*rpy; FT sy = qpz*rpx-qpx*rpz; FT sz = qpx*rpy-qpy*rpx; // The following determinants can be developped and simplified. // // FT num_x = det3x3_by_formula(qpy,qpz,qp2, // rpy,rpz,rp2, // sy,sz,FT(0)); // FT num_y = det3x3_by_formula(qpx,qpz,qp2, // rpx,rpz,rp2, // sx,sz,FT(0)); // FT num_z = det3x3_by_formula(qpx,qpy,qp2, // rpx,rpy,rp2, // sx,sy,FT(0)); num_x = qp2 * det2x2_by_formula(rpy,rpz,sy,sz) - rp2 * det2x2_by_formula(qpy,qpz,sy,sz); num_y = qp2 * det2x2_by_formula(rpx,rpz,sx,sz) - rp2 * det2x2_by_formula(qpx,qpz,sx,sz); num_z = qp2 * det2x2_by_formula(rpx,rpy,sx,sy) - rp2 * det2x2_by_formula(qpx,qpy,sx,sy); den = det3x3_by_formula(qpx,qpy,qpz, rpx,rpy,rpz, sx,sy,sz); } template < class FT > void weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, FT &x, FT &y, FT &z) { // this function compute the weighted circumcenter point only // Translate p to origin and compute determinants FT num_x, num_y, num_z, den; determinants_for_weighted_circumcenterC3(px, py, pz, pw, qx, qy, qz, qw, rx, ry, rz, rw, num_x, num_y, num_z, den); CGAL_kernel_assertion( den != FT(0) ); FT inv = FT(1)/(FT(2) * den); x = px + num_x*inv; y = py - num_y*inv; z = pz + num_z*inv; } template < class FT > void weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw, FT &x, FT &y, FT &z, FT &w) { // this function compute the weighted circumcenter and // the weighted squared circumradius // Translate p to origin and compute determinants FT num_x, num_y, num_z, den; determinants_for_weighted_circumcenterC3(px, py, pz, pw, qx, qy, qz, qw, rx, ry, rz, rw, num_x, num_y, num_z, den); CGAL_kernel_assertion( den != FT(0) ); FT inv = FT(1)/(FT(2) * den); x = px + num_x*inv; y = py - num_y*inv; z = pz + num_z*inv; w = (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) *CGAL_NTS square(inv) - pw; } template< class FT > CGAL_MEDIUM_INLINE FT squared_radius_smallest_orthogonal_sphereC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, const FT &rx, const FT &ry, const FT &rz, const FT &rw) { // this function compute the weighted squared circumradius only // Translate p to origin and compute determinants FT num_x, num_y, num_z, den; determinants_for_weighted_circumcenterC3(px, py, pz, pw, qx, qy, qz, qw, rx, ry, rz, rw, num_x, num_y, num_z, den); CGAL_kernel_assertion( den != FT(0) ); FT inv = FT(1)/(FT(2) * den); return (CGAL_NTS square(num_x)+CGAL_NTS square(num_y)+CGAL_NTS square(num_z)) *CGAL_NTS square(inv) - pw; } template < class FT > void weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, FT &x, FT &y, FT &z) { // this function compute the weighted circumcenter point only FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT inv = FT(1)/(FT(2)*qp2); FT alpha = 1/FT(2) + (pw-qw)*inv; x = px + alpha * qpx; y = py + alpha * qpy; z = pz + alpha * qpz; } template < class FT > void weighted_circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw, FT &x, FT &y, FT &z, FT &w) { // this function compute the weighted circumcenter point and // the weighted circumradius FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT inv = FT(1)/(FT(2)*qp2); FT alpha = 1/FT(2) + (pw-qw)*inv; x = px + alpha * qpx; y = py + alpha * qpy; z = pz + alpha * qpz; w = CGAL_NTS square(alpha)*qp2 - pw; } template< class FT > CGAL_MEDIUM_INLINE FT squared_radius_smallest_orthogonal_sphereC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw) { // this function computes // the weighted circumradius only FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT inv = FT(1)/(FT(2)*qp2); FT alpha = 1/FT(2) + (pw-qw)*inv; return CGAL_NTS square(alpha)*qp2 - pw; } template< class FT > FT power_productC3( const FT &px, const FT &py, const FT &pz, const FT &pw, const FT &qx, const FT &qy, const FT &qz, const FT &qw) { // computes the power product of two weighted points FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); return qp2 - pw - qw ; } template < class RT , class We> void radical_axisC3(const RT &px, const RT &py, const RT &pz, const We &pw, const RT &qx, const RT &qy, const RT &qz, const We &qw, const RT &rx, const RT &ry, const RT &rz, const We &rw, RT &a, RT &b, RT& c ) { RT dqx=qx-px, dqy=qy-py, dqz=qz-pz, drx=rx-px, dry=ry-py, drz=rz-pz; //il manque des tests... a= RT(1)*det2x2_by_formula(dqy, dqz, dry, drz); b= - RT(1)*det2x2_by_formula(dqx, dqz, drx, drz); c= RT(1)*det2x2_by_formula(dqx, dqy, drx, dry); } // I will use this to test if the radial axis of three spheres // intersect the triangle formed by the centers. // // resolution of the system (where we note c the center) // // | dc^2 = cw + rw // // | (dp-dc)^2 = pw + cw // // | (dq-dc)^2 = qw + cw // // | dc = Lamdba*dp + Mu*dq // FT FT2(2); // FT dpx = px-rx; // FT dpy = py-ry; // FT dpz = pz-rz; // FT dp = CGAL_NTS square(dpx)+CGAL_NTS square(dpy)+CGAL_NTS square(dpz); // FT dpp = dp-pw+rw; // FT dqx = qx-rx; // FT dqy = qy-ry; // FT dqz = qz-rz; // FT dq = CGAL_NTS square(dqx)+CGAL_NTS square(dqy)+CGAL_NTS square(dqz); // FT dqq = dq-qw+rw; // FT dpdq = dpx*dqx+dpy*dqy+dpz*dqz; // FT denom = FT2*(dp*dq-CGAL_NTS square(dpdq)); // FT Lambda = (dpp*dq-dqq*dpdq)/denom; // FT Mu = (dqq*dp-dpp*dpdq)/denom; // return (CGAL_NTS square(Lambda)*dp+CGAL_NTS square(Mu)*dq // +FT2*Lambda*Mu*dpdq - rw); CGAL_END_NAMESPACE #endif //CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_CARTESIAN_3_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/kernel_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/kernel_f0000644000175000017500000002112411344301501031446 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/constructions/kernel_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr, Herve Bronnimann, Sylvain Pion #ifndef CGAL_CONSTRUCTIONS_KERNEL_FTC2_H #define CGAL_CONSTRUCTIONS_KERNEL_FTC2_H #include CGAL_BEGIN_NAMESPACE template < class FT > CGAL_KERNEL_INLINE void midpointC2( const FT &px, const FT &py, const FT &qx, const FT &qy, FT &x, FT &y ) { x = (px+qx) / FT(2); y = (py+qy) / FT(2); } template < class FT > CGAL_KERNEL_LARGE_INLINE void circumcenter_translateC2(const FT &dqx, const FT &dqy, const FT &drx, const FT &dry, FT &dcx, FT &dcy) { // Given 3 points P, Q, R, this function takes as input: // qx-px, qy-py, rx-px, ry-py. And returns cx-px, cy-py, // where (cx, cy) are the coordinates of the circumcenter C. // What we do is intersect the bisectors. FT r2 = CGAL_NTS square(drx) + CGAL_NTS square(dry); FT q2 = CGAL_NTS square(dqx) + CGAL_NTS square(dqy); FT den = FT(2) * det2x2_by_formula(dqx, dqy, drx, dry); // The 3 points aren't collinear. // Hopefully, this is already checked at the upper level. CGAL_kernel_assertion ( ! CGAL_NTS is_zero(den) ); // One possible optimization here is to precompute 1/den, to avoid one // division. However, we loose precision, and it's maybe not worth it (?). dcx = det2x2_by_formula (dry, dqy, r2, q2) / den; dcy = - det2x2_by_formula (drx, dqx, r2, q2) / den; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE void circumcenterC2( const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, FT &x, FT &y ) { circumcenter_translateC2(qx-px, qy-py, rx-px, ry-py, x, y); x += px; y += py; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE void centroidC2( const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, FT &x, FT &y) { x = (px + qx + rx)/FT(3); y = (py + qy + ry)/FT(3); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE void centroidC2( const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, const FT &sx, const FT &sy, FT &x, FT &y) { x = (px + qx + rx + sx)/FT(4); y = (py + qy + ry + sy)/FT(4); } template < class FT > inline void line_from_pointsC2(const FT &px, const FT &py, const FT &qx, const FT &qy, FT &a, FT &b, FT &c) { // The horizontal and vertical line get a special treatment // in order to make the intersection code robust for doubles if(py == qy){ a = 0 ; if(qx > px){ b = 1; c = -py; } else if(qx == px){ b = 0; c = 0; }else{ b = -1; c = py; } } else if(qx == px){ b = 0; if(qy > py){ a = -1; c = px; } else if (qy == py){ a = 0; c = 0; } else { a = 1; c = -px; } } else { a = py - qy; b = qx - px; c = -px*a - py*b; } } template < class FT > inline void line_from_point_directionC2(const FT &px, const FT &py, const FT &dx, const FT &dy, FT &a, FT &b, FT &c) { a = - dy; b = dx; c = px*dy - py*dx; } template < class FT > CGAL_KERNEL_INLINE void bisector_of_pointsC2(const FT &px, const FT &py, const FT &qx, const FT &qy, FT &a, FT &b, FT& c ) { a = FT(2)*(px - qx); b = FT(2)*(py - qy); c = CGAL_NTS square(qx) + CGAL_NTS square(qy) - CGAL_NTS square(px) - CGAL_NTS square(py); } template < class FT > CGAL_KERNEL_INLINE void bisector_of_linesC2(const FT &pa, const FT &pb, const FT &pc, const FT &qa, const FT &qb, const FT &qc, FT &a, FT &b, FT &c) { // We normalize the equations of the 2 lines, and we then add them. FT n1 = CGAL_NTS sqrt(CGAL_NTS square(pa) + CGAL_NTS square(pb)); FT n2 = CGAL_NTS sqrt(CGAL_NTS square(qa) + CGAL_NTS square(qb)); a = n2 * pa + n1 * qa; b = n2 * pb + n1 * qb; c = n2 * pc + n1 * qc; // Care must be taken for the case when this produces a degenerate line. if (a == 0 && b == 0) { a = n2 * pa - n1 * qa; b = n2 * pb - n1 * qb; c = n2 * pc - n1 * qc; } } template < class FT > inline FT line_y_at_xC2(const FT &a, const FT &b, const FT &c, const FT &x) { return (-a*x-c) / b; } template < class FT > inline void line_get_pointC2(const FT &a, const FT &b, const FT &c, int i, FT &x, FT &y) { if (CGAL_NTS is_zero(b)) { x = (-b-c)/a + FT(i)*b; y = FT(1) - FT(i)*a; } else { x = FT(1) + FT(i)*b; y = -(a+c)/b - FT(i)*a; } } template < class FT > inline void perpendicular_through_pointC2(const FT &la, const FT &lb, const FT &px, const FT &py, FT &a, FT &b, FT &c) { a = -lb; b = la; c = lb * px - la * py; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE void line_project_pointC2(const FT &la, const FT &lb, const FT &lc, const FT &px, const FT &py, FT &x, FT &y) { #if 1 // FIXME // Original old version if (CGAL_NTS is_zero(la)) // horizontal line { x = px; y = -lc/lb; } else if (CGAL_NTS is_zero(lb)) // vertical line { x = -lc/la; y = py; } else { FT ab = la/lb, ba = lb/la, ca = lc/la; y = ( -px + ab*py - ca ) / ( ba + ab ); x = -ba * y - ca; } #else // New version, with more multiplications, but less divisions and tests. // Let's compare the results of the 2, benchmark them, as well as check // the precision with the intervals. FT a2 = CGAL_NTS square(la); FT b2 = CGAL_NTS square(lb); FT d = a2 + b2; x = (la * (lb * py - lc) - px * b2) / d; y = (lb * (lc - la * px) + py * a2) / d; #endif } template < class FT > CGAL_KERNEL_MEDIUM_INLINE FT squared_radiusC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry, FT &x, FT &y ) { circumcenter_translateC2(qx-px, qy-py, rx-px, ry-py, x, y); FT r2 = CGAL_NTS square(x) + CGAL_NTS square(y); x += px; y += py; return r2; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE FT squared_radiusC2(const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { FT x, y; circumcenter_translateC2(qx-px, qy-py, rx-px, ry-py, x, y); return CGAL_NTS square(x) + CGAL_NTS square(y); } template < class FT > inline FT squared_distanceC2( const FT &px, const FT &py, const FT &qx, const FT &qy) { return CGAL_NTS square(px-qx) + CGAL_NTS square(py-qy); } template < class FT > inline FT squared_radiusC2(const FT &px, const FT &py, const FT &qx, const FT &qy) { return squared_distanceC2(px, py,qx, qy)/FT(4); } template < class FT > CGAL_KERNEL_INLINE FT scaled_distance_to_lineC2( const FT &la, const FT &lb, const FT &lc, const FT &px, const FT &py) { // for comparisons, use distance_to_directionsC2 instead // since lc is irrelevant return la*px + lb*py + lc; } template < class FT > CGAL_KERNEL_INLINE FT scaled_distance_to_directionC2( const FT &la, const FT &lb, const FT &px, const FT &py) { // scalar product with direction return la*px + lb*py; } template < class FT > CGAL_KERNEL_MEDIUM_INLINE FT scaled_distance_to_lineC2( const FT &px, const FT &py, const FT &qx, const FT &qy, const FT &rx, const FT &ry) { return det2x2_by_formula(px-rx, py-ry, qx-rx, qy-ry); } CGAL_END_NAMESPACE #endif // CGAL_CONSTRUCTIONS_KERNEL_FTC2_H ././@LongLink0000000000000000000000000000022300000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/constructions_for_voronoi_intersection_cartesian_2_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/construc0000644000175000017500000001567011344301501031532 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /CVSROOT/CGAL/Packages/Interpolation/include/CGAL/constructions_for_voronoi_intersection_cartesian_2_3.h // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_CONSTRUCTIONS_FOR_VORONOI_INTERSECTION_CARTESIAN_2_3_H #define CGAL_CONSTRUCTIONS_FOR_VORONOI_INTERSECTION_CARTESIAN_2_3_H CGAL_BEGIN_NAMESPACE template < class RT> void plane_centered_circumcenter_translateC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &qx, const RT &qy, const RT &qz, const RT &rx, const RT &ry, const RT &rz, RT &x, RT &y, RT &z) { RT den = RT(2) * det3x3_by_formula(nx,qx,rx, ny,qy,ry, nz,qz,rz); // The 3 points aren't collinear. // Hopefully, this is already checked at the upper level. CGAL_assertion ( den != RT(0) ); RT q2 = CGAL_NTS square(qx) + CGAL_NTS square(qy) + CGAL_NTS square(qz); RT r2 = CGAL_NTS square(rx) + CGAL_NTS square(ry) + CGAL_NTS square(rz); RT na = nx*ax + ny*ay + nz*az; na *= RT(2.0); x = det3x3_by_formula(ny,nz,na, qy,qz,q2, ry,rz,r2)/ den ; y = - det3x3_by_formula(nx,nz,na, qx,qz,q2, rx,rz,r2)/ den ; z = det3x3_by_formula(nx,ny,na, qx,qy,q2, rx,ry,r2)/ den ; } template < class RT> void plane_centered_circumcenterC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &px, const RT &py, const RT &pz, const RT &qx, const RT &qy, const RT &qz, const RT &rx, const RT &ry, const RT &rz, RT &x, RT &y, RT &z) { // resolution of the system (where we note c the center) // // ((a-c)*n)= 0 //the center lies in the plane (a, n) // (c-p)(c-p)=(c-q)(c-q)=(c-r)(c-r) // p,q,r on a sphere(center c) // //precondition: p,q,r aren't collinear. //method: // - tranlation of p to the origin. plane_centered_circumcenter_translateC3(ax-px, ay-py, az-pz, nx, ny, nz, qx-px, qy-py,qz-pz, rx-px, ry-py,rz-pz, x, y, z); x+=px; y+=py; z+=pz; } template < class RT> void bisector_plane_intersection_translateC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &qx, const RT &qy, const RT &qz, const RT& den, RT &x1, RT &y1, RT &x2, RT &y2, bool& swapped) { // c: a point on l must be the center of a sphere passing // through p and q, c lies in h. 2 equations: // c^2 = (q-c)^2 //p and q on the sphere's boundary // (c-a)n = 0 //c in the plane h // the line is defined by p1 and p2 with //=> p1: z1 =0, p2: z2=1 // precondition: (nx!=0 || ny!=0) && (qx!=0 && qy!=0) && den!=0 // where RT den = RT(2.0) * det2x2_by_formula(qx,qy,nx, ny); RT q2 = CGAL_NTS square(qx) + CGAL_NTS square(qy) + CGAL_NTS square(qz); RT na = nx*ax + ny*ay + nz*az; na *= RT(2.0); x1 = det2x2_by_formula(ny, na, qy, q2); y1 = - det2x2_by_formula(nx, na, qx, q2); x2 = x1 + RT(2.0) * det2x2_by_formula(qy,qz,ny, nz); y2 = y1 - RT(2.0) * det2x2_by_formula(qx,qz,nx, nz); x1 /= den; x2 /= den; y1 /= den; y2 /= den; //we need to orient the line such that // if p is on the positive side of the plane //(<=> (p-a)*n >0 <=> na < 0) then orientation (pq p1 p2) is ccw // if not: permutation of p1 and p2 if((sign_of_determinant3x3(qx,qy,qz, x1,y1,RT(0),x2 ,y2,RT(1)) * CGAL_NTS sign (-na)) > 0 ) { RT x3(x1),y3(y1); x1 =x2; y1 =y2; x2 = x3; y2 = y3; swapped =true; } } template < class RT> void bisector_plane_intersection_permuteC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &px, const RT &py, const RT &pz, const RT &qx, const RT &qy, const RT &qz, const RT &den, RT &x1, RT &y1, RT& z1, RT &x2, RT &y2, RT& z2) { //translation of p to the origin bool swapped =false; CGAL_precondition((nx!=RT(0) || ny!=RT(0)) && (qx!=px || qy!=py) &&den!=RT(0)); bisector_plane_intersection_translateC3(ax-px, ay-py, az-pz, nx, ny, nz, qx-px, qy-py,qz-pz,den, x1, y1,x2,y2,swapped); // re-translation of the origin to p: x1+=px; y1+=py; z1 = pz; x2+=px; y2+=py; z2 = pz+RT(1); if (swapped){ z1 += RT(1); z2 =pz; } } template < class RT> void bisector_plane_intersectionC3(const RT &ax, const RT &ay, const RT &az, const RT &nx, const RT &ny, const RT &nz, const RT &px, const RT &py, const RT &pz, const RT &qx, const RT &qy, const RT &qz, RT &x1, RT &y1, RT& z1, RT &x2, RT &y2, RT& z2) { // constructs the line l = (p1,p2)= ((x1,y1,z1),(x2,y2,z2)) // the intersection line between the bisector of (p,q) and // h: plane containing a orthogonal to n. // l is oriented such that if p is on the positive side of h, // then (pq p1 p2) is ccw, otherwise (pq p1 p2) is cw // // precondition: (pq) is not parallel to n // // method: computing the intersection points of l // with the planes (z=0/z=1) or (x=0/x=1) or (y=0/y=1) depending if // 1) the line is not parallel to the plane // 2) the projection of n and (p-q) onto the plane is not // identical // computation for (z=0) with adequate permutations RT den = RT(2.0) * det2x2_by_formula(qx-px,qy-py,nx, ny); if ((nx!=0 || ny!=0) && (qx!=px || qy!=py) && den!=RT(0)) //den==0 <=> projections of (qx,qy) and (nx,ny) are identical //intersection with z=0/z=1 bisector_plane_intersection_permuteC3(ax,ay,az,nx,ny,nz,px,py,pz, qx,qy,qz,den, x1,y1,z1,x2,y2,z2); else{ den = RT(2.0) * det2x2_by_formula(qy-py,qz-pz,ny,nz); if ((ny!=0 || nz!=0) && (qy!=py || qz!=pz) && den!=RT(0)) //intersection with x=0/x=1 => permutations bisector_plane_intersection_permuteC3(ay,az,ax,ny,nz,nx,py,pz,px, qy,qz,qx,den, y1,z1,x1,y2,z2,x2); else{ den = RT(2.0) * det2x2_by_formula(qz-pz,qx-px,nz,nx); CGAL_assertion((nx!=0 || nz!=0) && (qx!=px || qz!=pz) && den!=RT(0)); //intersection with y=0/y=1 => permutations bisector_plane_intersection_permuteC3(az,ax,ay,nz,nx,ny,pz,px,py, qz,qx,qy,den, z1,x1,y1,z2,x2,y2); } } } CGAL_END_NAMESPACE #endif // CGAL_CONSTRUCTIONS_FOR_VORONOI_INTERSECTION_CARTESIAN_2_3_H ././@LongLink0000000000000000000000000000021400000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/squared_radius_smallest_orthogonalcircle_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/squared_0000644000175000017500000000455011344301501031470 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/constructions/squared_radius_smallest_orthogonalcircle_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_SQUARED_RADIUS_SMALLEST_ORTHOGONALCIRCLE_FTC2_H #define CGAL_SQUARED_RADIUS_SMALLEST_ORTHOGONALCIRCLE_FTC2_H #include #include //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- template< class FT > CGAL_MEDIUM_INLINE FT squared_radius_orthogonalcircleC2( const FT &px, const FT &py, const FT &pw, const FT &qx, const FT &qy, const FT &qw, const FT &rx, const FT &ry, const FT &rw) { FT FT4(4); FT dpx = px-rx; FT dpy = py-ry; FT dqx = qx-rx; FT dqy = qy-ry; FT dpp = CGAL_NTS square(dpx)+CGAL_NTS square(dpy)-pw+rw; FT dqq = CGAL_NTS square(dqx)+CGAL_NTS square(dqy)-qw+rw; FT det0 = det2x2_by_formula(dpx, dpy, dqx, dqy); FT det1 = det2x2_by_formula(dpp, dpy, dqq, dqy); FT det2 = det2x2_by_formula(dpx, dpp, dqx, dqq); return (CGAL_NTS square(det1)+CGAL_NTS square(det2))/ (FT4*CGAL_NTS square(det0)) - rw; } template< class FT > CGAL_MEDIUM_INLINE FT squared_radius_smallest_orthogonalcircleC2( const FT &px, const FT &py, const FT &pw, const FT &qx, const FT &qy, const FT &qw) { FT FT4(4); FT dpz = CGAL_NTS square(px-qx)+CGAL_NTS square(py-qy); return (CGAL_NTS square(dpz-pw+qw)/(FT4*dpz)-qw); } //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif //CGAL_SQUARED_RADIUS_SMALLEST_ORTHOGONALCIRCLE_ftC2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/kernel_ftC3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions/kernel_f0000644000175000017500000003160711344301501031455 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/constructions/kernel_ftC3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann #ifndef CGAL_CONSTRUCTIONS_KERNEL_FTC3_H #define CGAL_CONSTRUCTIONS_KERNEL_FTC3_H #include CGAL_BEGIN_NAMESPACE template < class FT > CGAL_KERNEL_INLINE void midpointC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, FT &x, FT &y, FT &z) { FT half = FT(1) / FT(2); x = (px+qx) * half; y = (py+qy) * half; z = (pz+qz) * half; } template < class FT > void circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz, FT &x, FT &y, FT &z) { // Translate p to origin to simplify the expression. FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz); FT spx = sx-px; FT spy = sy-py; FT spz = sz-pz; FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) + CGAL_NTS square(spz); FT num_x = det3x3_by_formula(qpy,qpz,qp2, rpy,rpz,rp2, spy,spz,sp2); FT num_y = det3x3_by_formula(qpx,qpz,qp2, rpx,rpz,rp2, spx,spz,sp2); FT num_z = det3x3_by_formula(qpx,qpy,qp2, rpx,rpy,rp2, spx,spy,sp2); FT den = det3x3_by_formula(qpx,qpy,qpz, rpx,rpy,rpz, spx,spy,spz); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); FT inv = FT(1)/(FT(2) * den); x = px + num_x*inv; y = py - num_y*inv; z = pz + num_z*inv; } template < class FT > void circumcenterC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &sx, const FT &sy, const FT &sz, FT &x, FT &y, FT &z) { // Translate s to origin to simplify the expression. FT psx = px-sx; FT psy = py-sy; FT psz = pz-sz; FT ps2 = CGAL_NTS square(psx) + CGAL_NTS square(psy) + CGAL_NTS square(psz); FT qsx = qx-sx; FT qsy = qy-sy; FT qsz = qz-sz; FT qs2 = CGAL_NTS square(qsx) + CGAL_NTS square(qsy) + CGAL_NTS square(qsz); FT rsx = psy*qsz-psz*qsy; FT rsy = psz*qsx-psx*qsz; FT rsz = psx*qsy-psy*qsx; // The following determinants can be developped and simplified. // // FT num_x = det3x3_by_formula(psy,psz,ps2, // qsy,qsz,qs2, // rsy,rsz,FT(0)); // FT num_y = det3x3_by_formula(psx,psz,ps2, // qsx,qsz,qs2, // rsx,rsz,FT(0)); // FT num_z = det3x3_by_formula(psx,psy,ps2, // qsx,qsy,qs2, // rsx,rsy,FT(0)); FT num_x = ps2 * det2x2_by_formula(qsy,qsz,rsy,rsz) - qs2 * det2x2_by_formula(psy,psz,rsy,rsz); FT num_y = ps2 * det2x2_by_formula(qsx,qsz,rsx,rsz) - qs2 * det2x2_by_formula(psx,psz,rsx,rsz); FT num_z = ps2 * det2x2_by_formula(qsx,qsy,rsx,rsy) - qs2 * det2x2_by_formula(psx,psy,rsx,rsy); FT den = det3x3_by_formula(psx,psy,psz, qsx,qsy,qsz, rsx,rsy,rsz); CGAL_kernel_assertion( den != FT(0) ); FT inv = FT(1)/(FT(2) * den); x = sx + num_x*inv; y = sy - num_y*inv; z = sz + num_z*inv; } template < class FT > void centroidC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz, FT &x, FT &y, FT &z) { x = (px + qx + rx + sx)/FT(4); y = (py + qy + ry + sy)/FT(4); z = (pz + qz + rz + sz)/FT(4); } template < class FT > void centroidC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, FT &x, FT &y, FT &z) { x = (px + qx + rx)/FT(3); y = (py + qy + ry)/FT(3); z = (pz + qz + rz)/FT(3); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE FT squared_radiusC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, const FT &sx, const FT &sy, const FT &sz) { // Translate p to origin to simplify the expression. FT qpx = qx-px; FT qpy = qy-py; FT qpz = qz-pz; FT qp2 = CGAL_NTS square(qpx) + CGAL_NTS square(qpy) + CGAL_NTS square(qpz); FT rpx = rx-px; FT rpy = ry-py; FT rpz = rz-pz; FT rp2 = CGAL_NTS square(rpx) + CGAL_NTS square(rpy) + CGAL_NTS square(rpz); FT spx = sx-px; FT spy = sy-py; FT spz = sz-pz; FT sp2 = CGAL_NTS square(spx) + CGAL_NTS square(spy) + CGAL_NTS square(spz); FT num_x = det3x3_by_formula(qpy,qpz,qp2, rpy,rpz,rp2, spy,spz,sp2); FT num_y = det3x3_by_formula(qpx,qpz,qp2, rpx,rpz,rp2, spx,spz,sp2); FT num_z = det3x3_by_formula(qpx,qpy,qp2, rpx,rpy,rp2, spx,spy,sp2); FT den = det3x3_by_formula(qpx,qpy,qpz, rpx,rpy,rpz, spx,spy,spz); CGAL_kernel_assertion( ! CGAL_NTS is_zero(den) ); return (CGAL_NTS square(num_x) + CGAL_NTS square(num_y) + CGAL_NTS square(num_z)) / CGAL_NTS square(FT(2) * den); } template < class FT > CGAL_KERNEL_MEDIUM_INLINE FT squared_radiusC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &sx, const FT &sy, const FT &sz) { // Translate s to origin to simplify the expression. FT psx = px-sx; FT psy = py-sy; FT psz = pz-sz; FT ps2 = CGAL_NTS square(psx) + CGAL_NTS square(psy) + CGAL_NTS square(psz); FT qsx = qx-sx; FT qsy = qy-sy; FT qsz = qz-sz; FT qs2 = CGAL_NTS square(qsx) + CGAL_NTS square(qsy) + CGAL_NTS square(qsz); FT rsx = psy*qsz-psz*qsy; FT rsy = psz*qsx-psx*qsz; FT rsz = psx*qsy-psy*qsx; FT num_x = ps2 * det2x2_by_formula(qsy,qsz,rsy,rsz) - qs2 * det2x2_by_formula(psy,psz,rsy,rsz); FT num_y = ps2 * det2x2_by_formula(qsx,qsz,rsx,rsz) - qs2 * det2x2_by_formula(psx,psz,rsx,rsz); FT num_z = ps2 * det2x2_by_formula(qsx,qsy,rsx,rsy) - qs2 * det2x2_by_formula(psx,psy,rsx,rsy); FT den = det3x3_by_formula(psx,psy,psz, qsx,qsy,qsz, rsx,rsy,rsz); CGAL_kernel_assertion( den != FT(0) ); return (CGAL_NTS square(num_x) + CGAL_NTS square(num_y) + CGAL_NTS square(num_z)) / CGAL_NTS square(FT(2) * den); } template CGAL_KERNEL_MEDIUM_INLINE void plane_from_pointsC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz, FT &pa, FT &pb, FT &pc, FT &pd) { FT rpx = px-rx; FT rpy = py-ry; FT rpz = pz-rz; FT rqx = qx-rx; FT rqy = qy-ry; FT rqz = qz-rz; // Cross product rp * rq pa = rpy*rqz - rqy*rpz; pb = rpz*rqx - rqz*rpx; pc = rpx*rqy - rqx*rpy; pd = - pa*rx - pb*ry - pc*rz; } template CGAL_KERNEL_MEDIUM_INLINE void plane_from_point_directionC3(const FT &px, const FT &py, const FT &pz, const FT &dx, const FT &dy, const FT &dz, FT &pa, FT &pb, FT &pc, FT &pd) { // d is the normal direction pa = dx; pb = dy; pc = dz; pd = -dx*px - dy*py - dz*pz; } template CGAL_KERNEL_MEDIUM_INLINE void point_on_planeC3(const FT &pa, const FT &pb, const FT &pc, const FT &pd, FT &x, FT &y, FT &z) { x = y = z = FT(0); if (! CGAL_NTS is_zero(pa)) x = -pd/pa; else if (! CGAL_NTS is_zero(pb)) y = -pd/pb; else z = -pd/pc; } template CGAL_KERNEL_MEDIUM_INLINE void projection_planeC3(const FT &pa, const FT &pb, const FT &pc, const FT &pd, const FT &px, const FT &py, const FT &pz, FT &x, FT &y, FT &z) { // the equation of the plane is Ax+By+Cz+D=0 // the normal direction is (A,B,C) // the projected point is p-lambda(A,B,C) where // A(x-lambda A) + B(y-lambda B) + C(z-lambda C) + D = 0 FT num = pa*px + pb*py + pc*pz + pd; FT den = pa*pa + pb*pb + pc*pc; FT lambda = num / den; x = px - lambda * pa; y = py - lambda * pb; z = pz - lambda * pc; } template < class FT > CGAL_KERNEL_INLINE FT squared_distanceC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return CGAL_NTS square(px-qx) + CGAL_NTS square(py-qy) + CGAL_NTS square(pz-qz); } template < class FT > CGAL_KERNEL_INLINE FT squared_radiusC3( const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz) { return squared_distanceC3(px, py, pz, qx, qy, qz)/FT(4); } template < class FT > CGAL_KERNEL_INLINE FT scaled_distance_to_directionC3(const FT &pa, const FT &pb, const FT &pc, const FT &px, const FT &py, const FT &pz) { return pa*px + pb*py + pc*pz; } template < class FT > CGAL_KERNEL_INLINE FT scaled_distance_to_planeC3( const FT &pa, const FT &pb, const FT &pc, const FT &pd, const FT &px, const FT &py, const FT &pz) { return pa*px + pb*py + pc*pz + pd; } template < class FT > CGAL_KERNEL_INLINE FT scaled_distance_to_planeC3( const FT &ppx, const FT &ppy, const FT &ppz, const FT &pqx, const FT &pqy, const FT &pqz, const FT &prx, const FT &pry, const FT &prz, const FT &px, const FT &py, const FT &pz) { return det3x3_by_formula(ppx-px,ppy-py,ppz-pz, pqx-px,pqy-py,pqz-pz, prx-px,pry-py,prz-pz); } template < class FT > CGAL_KERNEL_INLINE void bisector_of_pointsC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, FT &a, FT &b, FT &c, FT &d) { a = 2*(px - qx); b = 2*(py - qy); c = 2*(pz - qz); d = CGAL_NTS square(qx) + CGAL_NTS square(qy) + CGAL_NTS square(qz) - CGAL_NTS square(px) - CGAL_NTS square(py) - CGAL_NTS square(pz); } template < class FT > void bisector_of_planesC3(const FT &pa, const FT &pb, const FT &pc, const FT &pd, const FT &qa, const FT &qb, const FT &qc, const FT &qd, FT &a, FT &b, FT &c, FT &d) { // We normalize the equations of the 2 planes, and we then add them. FT n1 = CGAL_NTS sqrt(CGAL_NTS square(pa) + CGAL_NTS square(pb) + CGAL_NTS square(pc)); FT n2 = CGAL_NTS sqrt(CGAL_NTS square(qa) + CGAL_NTS square(qb) + CGAL_NTS square(qc)); a = n2 * pa + n1 * qa; b = n2 * pb + n1 * qb; c = n2 * pc + n1 * qc; d = n2 * pd + n1 * qd; // Care must be taken for the case when this produces a degenerate line. if (a == 0 && b == 0 && c == 0) { a = n2 * pa - n1 * qa; b = n2 * pb - n1 * qb; c = n2 * pc - n1 * qc; d = n2 * pd - n1 * qd; } } template < class FT > FT squared_areaC3(const FT &px, const FT &py, const FT &pz, const FT &qx, const FT &qy, const FT &qz, const FT &rx, const FT &ry, const FT &rz) { // Compute vectors pq and pr, then the cross product, // then 1/4 of its squared length. FT dqx = qx-px; FT dqy = qy-py; FT dqz = qz-pz; FT drx = rx-px; FT dry = ry-py; FT drz = rz-pz; FT vx = dqy*drz-dqz*dry; FT vy = dqz*drx-dqx*drz; FT vz = dqx*dry-dqy*drx; return (CGAL_NTS square(vx) + CGAL_NTS square(vy) + CGAL_NTS square(vz))/4; } CGAL_END_NAMESPACE #endif // CGAL_CONSTRUCTIONS_KERNEL_FTC3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/sibson_gradient_fitting.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/sibson_gradient_fittin0000644000175000017500000001203011344301501031467 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/sibson_gradient_fitting.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_SIBSON_GRADIENT_FITTING_H #define CGAL_SIBSON_GRADIENT_FITTING_H #include #include #include CGAL_BEGIN_NAMESPACE template < class ForwardIterator, class Functor, class Traits> typename Traits::Vector_d sibson_gradient_fitting(ForwardIterator first, ForwardIterator beyond, const typename std::iterator_traits:: value_type::second_type& norm, const typename std::iterator_traits::value_type ::first_type& p, Functor function_value, const Traits& traits) { CGAL_precondition( first!=beyond && norm!=0); typedef typename Traits::Aff_transformation_d Aff_transformation; typedef typename Traits::FT Coord_type; typename Functor::result_type fn = function_value(p); CGAL_assertion(fn.second); //function value of p is valid typename Traits::Vector_d pn = traits.construct_vector_d_object()(NULL_VECTOR); Aff_transformation scaling, m, Hn(traits.construct_null_matrix_d_object()()); for(;first!=beyond; ++first){ Coord_type square_dist = traits.compute_squared_distance_d_object() (first->first, p); CGAL_assertion(square_dist != 0); Coord_type scale = first->second/(norm*square_dist); typename Traits::Vector_d d= traits.construct_vector_d_object()(p, first->first); //compute the vector pn: typename Functor::result_type f = function_value(first->first); CGAL_assertion(f.second);//function value of first->first is valid pn = pn + traits.construct_scaled_vector_d_object() (d,scale * (f.first - fn.first)); //compute the matrix Hn: m = traits.construct_outer_product_d_object()(d); scaling = traits.construct_scaling_matrix_d_object()(scale); Hn = traits.construct_sum_matrix_d_object()(Hn, scaling * m); } return Hn.inverse().transform(pn); } template < class Triangul, class OutputIterator, class Functor, class CoordFunctor, class Traits> OutputIterator sibson_gradient_fitting(const Triangul& tr, OutputIterator out, Functor function_value, CoordFunctor compute_coordinates, const Traits& traits) { typedef typename Traits::Point_d Point; typedef typename Traits::FT Coord_type; std::vector< std::pair< Point, Coord_type > > coords; Coord_type norm; typename Triangul::Finite_vertices_iterator vit = tr.finite_vertices_begin(); for(; vit != tr.finite_vertices_end(); ++vit){ //test if vit is a convex hull vertex: //otherwise do nothing if (!tr.is_edge(vit, tr.infinite_vertex())) { norm = compute_coordinates(tr, vit, std::back_inserter(coords)).second; *out++ = std::make_pair(vit->point(), sibson_gradient_fitting(coords.begin(), coords.end(), norm, vit->point(), function_value, traits)); coords.clear(); } } return out; } //the following functions allow to fit the gradients for all points in // a triangulation except the convex hull points. // -> _nn2: natural_neighbor_coordinates_2 // -> _rn2: regular_neighbor_coordinates_2 // -> _sn2_3: surface_neighbor_coordinates_2_3 template < class Dt, class OutputIterator, class Functor, class Traits> OutputIterator sibson_gradient_fitting_nn_2(const Dt& dt, OutputIterator out, Functor function_value, const Traits& traits) { typedef typename std::back_insert_iterator< std::vector< std::pair< typename Traits::Point_d,typename Traits::FT > > > CoordInserter; return sibson_gradient_fitting (dt, out, function_value, natural_neighbor_coordinates_2_object< Dt, CoordInserter >(), traits); } template < class Rt, class OutputIterator, class Functor, class Traits> OutputIterator sibson_gradient_fitting_rn_2(const Rt& rt, OutputIterator out, Functor function_value, const Traits& traits) { typedef typename std::back_insert_iterator< std::vector< std::pair< typename Traits::Point_d,typename Traits::FT > > > CoordInserter; return sibson_gradient_fitting (rt, out, function_value, regular_neighbor_coordinates_2_object< Rt, CoordInserter >(), traits); } CGAL_END_NAMESPACE #endif // CGAL_SIBSON_GRADIENT_FITTING_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_d_new.h0000644000175000017500000005330711344301500030446 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_d_new.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Bernd Gaertner, Sven Schoenherr #ifndef CGAL_MIN_SPHERE_D_H #define CGAL_MIN_SPHERE_D_H // includes // -------- #ifndef CGAL_OPTIMISATION_BASIC_H # include #endif #ifndef CGAL_FUNCTION_OBJECTS_H # include #endif #ifndef CGAL_IDENTITY_H # include #endif #ifndef CGAL_FUNCTION_OBJECTS_ACCESS_BY_INDEX_H # include #endif #ifndef CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H # include #endif #ifndef CGAL_QP_SOLVER_H # include #endif #ifndef CGAL_CONST_VALUE_ITERATOR_H # include #endif #ifndef CGAL_PARTIAL_EXACT_PRICING_H # include #endif #ifndef CGAL_PARTIAL_FILTERED_PRICING_H # include #endif #ifndef CGAL_PROTECT_VECTOR # include # define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_PROTECT_IOSTREAM # include # define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_sphere_d; template < class ET_, class NT_, class Point, class Point_iterator, class Access_coord, class Access_dim > struct QP_rep_min_sphere_d; template < class NT, class Point, class Point_iterator, class Access_coord, class Access_dim > struct QP_rep_row_of_d; // Class interfaces // ================ template < class Traits_ > class Min_sphere_d { public: // self typedef Traits_ Traits; typedef Min_sphere_d Self; // types from the traits class typedef typename Traits::Point_d Point; typedef typename Traits::Rep_tag Rep_tag; typedef typename Traits::RT RT; typedef typename Traits::FT FT; typedef typename Traits::Access_dimension_d Access_dimension_d; typedef typename Traits::Access_coordinates_begin_d Access_coordinates_begin_d; typedef typename Traits::Construct_point_d Construct_point_d; typedef typename Traits::ET ET; typedef typename Traits::NT NT; private: // QP solver typedef CGAL::QP_rep_min_sphere_d< ET, NT, Point, typename std::vector::const_iterator, Access_coordinates_begin_d, Access_dimension_d > QP_rep; typedef CGAL::QP_solver< QP_rep > Solver; typedef typename Solver::Pricing_strategy Pricing_strategy; // types from the QP solver typedef typename Solver::Basic_variable_index_iterator Basic_variable_index_iterator; // private types typedef std::vector Point_vector; typedef std::vector ET_vector; typedef CGAL::Access_by_index::const_iterator> Point_by_index; public: // public types typedef typename Point_vector::const_iterator Point_iterator; typedef CGAL::Join_random_access_iterator_1< Basic_variable_index_iterator, Point_by_index > Support_point_iterator; typedef typename ET_vector::const_iterator Coordinate_iterator; // creation Min_sphere_d( const Traits& traits = Traits(), int verbose = 0, std::ostream& stream = std::cout) : tco( traits), d( -1), solver( verbose, stream) { set_pricing_strategy( NT()); } template < class InputIterator > Min_sphere_d( InputIterator first, InputIterator last, const Traits& traits = Traits(), int verbose = 0, std::ostream& stream = std::cout) : tco( traits), solver( verbose, stream) { set_pricing_strategy( NT()); set( first, last); } // access to point set int ambient_dimension( ) const { return d; } int number_of_points( ) const { return points.size(); } Point_iterator points_begin( ) const { return points.begin(); } Point_iterator points_end ( ) const { return points.end (); } // access to support points int number_of_support_points( ) const { return is_empty() ? 0 : solver.number_of_basic_variables(); } Support_point_iterator support_points_begin() const { return Support_point_iterator( solver.basic_variables_index_begin(), Point_by_index( points.begin())); } Support_point_iterator support_points_end() const { return Support_point_iterator( is_empty() ? solver.basic_variables_index_begin() : solver.basic_variables_index_end(), Point_by_index( points.begin())); } // access to center (rational representation) Coordinate_iterator center_coordinates_begin( ) const { return center_coords.begin(); } Coordinate_iterator center_coordinates_end ( ) const { return center_coords.end (); } // access to squared radius (rational representation) ET squared_radius_numerator ( ) const { return sqr_rad_numer; } ET squared_radius_denominator( ) const { return sqr_rad_denom; } // access to center and squared radius // NOTE: an implicit conversion from ET to RT must be available! Point center( ) const { CGAL_optimisation_precondition( ! is_empty()); return tco.construct_point_d_object()( ambient_dimension(), center_coordinates_begin(), center_coordinates_end()); } FT squared_radius( ) const { CGAL_optimisation_precondition( ! is_empty()); return FT( squared_radius_numerator ()) / FT( squared_radius_denominator()); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); return CGAL::Bounded_side( CGAL_NTS sign( sqr_rad_numer - sqr_dist( p))); } bool has_on_bounded_side( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); return ( sqr_dist( p) < sqr_rad_numer); } bool has_on_boundary( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); return ( sqr_dist( p) == sqr_rad_numer); } bool has_on_unbounded_side( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); return( sqr_dist( p) > sqr_rad_numer); } bool is_empty ( ) const { return number_of_points() == 0; } bool is_degenerate( ) const { return number_of_support_points() < 2; } // modifiers template < class InputIterator > void set( InputIterator first, InputIterator last) { if ( points.size() > 0) points.erase( points.begin(), points.end()); std::copy( first, last, std::back_inserter( points)); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension(), "Not all points have the same dimension."); compute_min_sphere(); } void insert( const Point& p) { CGAL_optimisation_precondition( is_empty() || ( tco.access_dimension_d_object()( p) == d)); points.push_back( p); compute_min_sphere(); } template < class InputIterator > void insert( InputIterator first, InputIterator last) { CGAL_optimisation_precondition_code( int old_n = points.size()); points.insert( points.end(), first, last); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( old_n), "Not all points have the same dimension."); compute_min_sphere(); } void clear( ) { points.erase( points.begin(), points.end()); compute_min_sphere(); } // validity check bool is_valid( bool verbose = false, int level = 0) const; // traits class access const Traits& traits( ) const { return tco; } private: Traits tco; // traits class object Point_vector points; // input points int d; // dimension of input points ET_vector center_coords; // center of small.encl.sphere ET sqr_rad_numer; // squared radius of ET sqr_rad_denom; // smallest enclosing sphere Solver solver; // quadratic programming solver std::vector c_vector; // vector `c' of QP typename Solver::Pricing_strategy* // pricing strategy strategyP; // of the QP solver // squared distance to center ET sqr_dist( const Point& p) const { return std::inner_product( center_coords.begin(), center_coords.end()-1, tco.access_coordinates_begin_d_object()( p), ET( 0), std::plus(), CGAL::compose1_2( CGAL::compose2_1( std::multiplies(), CGAL::identity(), CGAL::identity()), CGAL::compose2_2( std::minus(), CGAL::identity(), std::bind2nd( std::multiplies(), center_coords.back())))); } // set dimension of input points void set_dimension( ) { d = ( points.size() == 0 ? -1 : tco.access_dimension_d_object()( points[ 0])); } // check dimension of input points bool check_dimension( unsigned int offset = 0) { return ( std::find_if( points.begin()+offset, points.end(), CGAL::compose1_1( std::bind2nd( std::not_equal_to(), d), tco.access_dimension_d_object())) == points.end()); } // compute smallest enclosing sphere void compute_min_sphere( ) { if ( is_empty()) { center_coords.resize( 1); sqr_rad_numer = -ET( 1); return; } // set up and solve QP c_vector.resize( points.size()); int i; for ( i = 0; i < number_of_points(); ++i) { c_vector[ i] = -std::inner_product( tco.access_coordinates_begin_d_object()( points[ i]), tco.access_coordinates_begin_d_object()( points[ i])+d, tco.access_coordinates_begin_d_object()( points[ i]), NT( 0), std::plus(), std::multiplies()); } typedef typename QP_rep::A_iterator A_it; typedef typename QP_rep::B_iterator B_it; typedef typename QP_rep::D_iterator D_it; B_it const_one( 1); solver.set( points.size(), 1, d+1, A_it( const_one), const_one, c_vector.begin(), D_it( points.begin(), CGAL::QP_rep_row_of_d< NT, Point, Point_iterator, Access_coordinates_begin_d, Access_dimension_d >( points.begin(), tco.access_coordinates_begin_d_object(), tco.access_dimension_d_object()))); solver.init(); solver.solve(); // compute center and squared radius center_coords.resize( ambient_dimension()+1); std::fill( center_coords.begin(), center_coords.end(), ET( 0)); for ( i = 0; i < solver.number_of_basic_variables(); ++i) { ET value = solver.basic_variables_numerator_begin()[ i]; int index = solver.basic_variables_index_begin()[ i]; for ( int j = 0; j < d; ++j) center_coords[ j] += value * tco.access_coordinates_begin_d_object()( points[ index])[ j]; } center_coords[ d] = solver.variables_common_denominator(); sqr_rad_numer = -solver.solution_numerator(); sqr_rad_denom = center_coords[ d] * center_coords[ d]; } #ifdef _MSC_VER template < class NT > void set_pricing_strategy( NT) { } #else template < class NT > void set_pricing_strategy( NT) { strategyP = new CGAL::Partial_filtered_pricing; solver.set_pricing_strategy( *strategyP); } void set_pricing_strategy( ET) { strategyP = new CGAL::Partial_exact_pricing; solver.set_pricing_strategy( *strategyP); } #endif }; template < class NT, class Point, class Access_coord, class Access_dim > class QP_rep_inner_product : public std::unary_function< Point, NT > { Point p_i; Access_coord da_coord; Access_dim da_dim; public: QP_rep_inner_product( ) { } QP_rep_inner_product( const Point& p, const Access_coord& ac, const Access_dim& ad) : p_i( p), da_coord( ac), da_dim( ad) { } NT operator( ) ( const Point& p_j) const { return std::inner_product( da_coord( p_i), da_coord( p_i)+da_dim( p_i), da_coord( p_j), NT( 0), std::plus(), std::multiplies()); } }; template < class NT, class Point, class Point_iterator, class Access_coord, class Access_dim > class QP_rep_row_of_d { Point_iterator pts_it; Access_coord da_coord; Access_dim da_dim; public: typedef CGAL::QP_rep_inner_product< NT, Point, Access_coord, Access_dim > Inner_product; typedef CGAL::Join_random_access_iterator_1< Point_iterator, Inner_product > Row_of_d; typedef Point argument_type; typedef Row_of_d result_type; QP_rep_row_of_d( ) { } QP_rep_row_of_d( const Point_iterator& it, const Access_coord& ac, const Access_dim& ad) : pts_it( it), da_coord( ac), da_dim( ad) { } Row_of_d operator( ) ( const Point& p_i) const { return Row_of_d( pts_it, Inner_product( p_i, da_coord, da_dim));} }; template < class ET_, class NT_, class Point, class Point_iterator, class Access_coord, class Access_dim > struct QP_rep_min_sphere_d { typedef ET_ ET; typedef NT_ NT; typedef CGAL::Const_value_iterator< CGAL::Const_value_iterator > A_iterator; typedef CGAL::Const_value_iterator B_iterator; typedef typename std::vector::const_iterator C_iterator; typedef CGAL::Join_random_access_iterator_1< Point_iterator, QP_rep_row_of_d< NT, Point, Point_iterator, Access_coord, Access_dim > > D_iterator; typedef CGAL::Tag_false Is_lp; }; // Function declarations // ===================== // I/O operators template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_sphere_d& min_sphere); template < class Traits_ > std::istream& operator >> ( std::istream& is, Min_sphere_d& min_sphere); // ============================================================================ // Class implementation // ==================== // validity check template < class Traits_ > bool Min_sphere_d:: is_valid( bool verbose, int level) const { CGAL_USING_NAMESPACE_STD CGAL::Verbose_ostream verr( verbose); verr << "CGAL::Min_sphere_d::" << endl; verr << "is_valid( true, " << level << "):" << endl; verr << " |P| = " << number_of_points() << ", |S| = " << number_of_support_points() << endl; // containment check (a) // --------------------- verr << " (a) containment check..." << flush; Point_iterator point_it = points_begin(); for ( ; point_it != points_end(); ++point_it) { if ( has_on_unbounded_side( *point_it)) return CGAL::_optimisation_is_valid_fail( verr, "sphere does not contain all points"); } verr << "passed." << endl; // support set check (b) // --------------------- verr << " (b) support set check..." << flush; // all support points on boundary? Support_point_iterator support_point_it = support_points_begin(); for ( ; support_point_it != support_points_end(); ++support_point_it) { if ( ! has_on_boundary( *support_point_it)) return CGAL::_optimisation_is_valid_fail( verr, "sphere does not have all support points on its boundary"); } // center strictly in convex hull of support points? typename Solver::Basic_variable_numerator_iterator num_it = solver.basic_variables_numerator_begin(); for ( ; num_it != solver.basic_variables_numerator_end(); ++num_it) { if ( ! ( CGAL_NTS is_positive( *num_it) && *num_it <= solver.variables_common_denominator())) return CGAL::_optimisation_is_valid_fail( verr, "center does not lie strictly in convex hull of support points"); } verr << "passed." << endl; verr << " object is valid!" << endl; return( true); } // output operator template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_sphere_d& min_sphere) { CGAL_USING_NAMESPACE_STD typedef typename Min_sphere_d::Point Point; typedef ostream_iterator Os_it; typedef typename Traits_::ET ET; typedef ostream_iterator Et_it; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << "CGAL::Min_sphere_d( |P| = " << min_sphere.number_of_points() << ", |S| = " << min_sphere.number_of_support_points() << endl; os << " P = {" << endl; os << " "; copy( min_sphere.points_begin(), min_sphere.points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " S = {" << endl; os << " "; copy( min_sphere.support_points_begin(), min_sphere.support_points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " center = ( "; copy( min_sphere.center_coordinates_begin(), min_sphere.center_coordinates_end(), Et_it( os, " ")); os << ")" << endl; os << " squared radius = " << min_sphere.squared_radius_numerator() << " / " << min_sphere.squared_radius_denominator() << endl; os << ")" << endl; break; case CGAL::IO::ASCII: copy( min_sphere.points_begin(), min_sphere.points_end(), Os_it( os, "\n")); break; case CGAL::IO::BINARY: copy( min_sphere.points_begin(), min_sphere.points_end(), Os_it( os)); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } // input operator template < class Traits_ > std::istream& operator >> ( std::istream& is, CGAL::Min_sphere_d& min_sphere) { CGAL_USING_NAMESPACE_STD switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: cerr << endl; cerr << "Stream must be in ascii or binary mode" << endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: typedef typename CGAL::Min_sphere_d::Point Point; typedef istream_iterator Is_it; min_sphere.set( Is_it( is), Is_it()); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE #endif // CGAL_MIN_SPHERE_D_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Minimum_enclosing_quadrilateral_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Minimum_enclosing_quad0000644000175000017500000000243711344301500031437 0ustar debiandebian// Copyright (c) 1999-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Minimum_enclosing_quadrilateral_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann and // Emo Welzl #if ! (CGAL_MINIMUM_ENCLOSING_QUADRILATERAL_TRAITS_2_H) #define CGAL_MINIMUM_ENCLOSING_QUADRILATERAL_TRAITS_2_H 1 #ifndef CGAL_NO_DEPRECATED_CODE #include #endif // CGAL_NO_DEPRECATED_CODE #endif // ! (CGAL_MINIMUM_ENCLOSING_QUADRILATERAL_TRAITS_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/surface_neighbors_3.h0000644000175000017500000002111511344301501031104 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/surface_neighbors_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_SURFACE_NEIGHBORS_3_H #define CGAL_SURFACE_NEIGHBORS_3_H #include #include #include #include //contains the definition of the Comparator "closer_to_point" and // the function object Project_vertex_iterator_to_point #include CGAL_BEGIN_NAMESPACE //without Delaunay filtering template inline OutputIterator surface_neighbors_3(InputIterator first, InputIterator beyond, const typename Kernel::Point_3& p, const typename Kernel::Vector_3& normal, OutputIterator out, const Kernel& K) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbors_3(first, beyond, p, out, I_gt(p,normal)); } template OutputIterator surface_neighbors_3(InputIterator first, InputIterator beyond, const typename ITraits::Point_2& p, OutputIterator out, const ITraits& traits) { //definition of the Voronoi intersection triangulation: typedef Regular_triangulation_2< ITraits> I_triangulation; typedef typename I_triangulation::Vertex_handle Vertex_handle; typedef typename I_triangulation::Face_handle Face_handle; typedef typename I_triangulation::Locate_type Locate_type; //build Voronoi intersection triangulation: I_triangulation it(traits); it.insert(first,beyond); Locate_type lt; int li; Face_handle fh = it.locate(p, lt, li); if(lt == I_triangulation::VERTEX){ *out++ =p; return out; } Vertex_handle vh = it.insert(p, fh); typename I_triangulation::Vertex_circulator vc(it.incident_vertices(vh)), done(vc); do{ *out++= vc->point(); assert(! it.is_infinite(vc)); } while(vc++!=done); return out; } //without Delaunay filtering -- certified version: // a boolean is returned that indicates if a sufficiently large // neighborhood has been considered so that the // Voronoi cell of p is not affected by any point outside the smallest // ball centered on p containing all points in [first,beyond) template std::pair< OutputIterator, bool > surface_neighbors_certified_3(InputIterator first, InputIterator beyond, const typename Kernel::Point_3& p, const typename Kernel::Vector_3& normal, OutputIterator out, const Kernel& K) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbors_certified_3(first, beyond, p, out, I_gt(p,normal)); } //this function takes the radius of the sphere centered on p // containing the points in [first, beyond] (i.e. the maximal // distance from p to [first,beyond) as add. parameter: template std::pair< OutputIterator, bool > surface_neighbors_certified_3(InputIterator first, InputIterator beyond, const typename Kernel::Point_3& p, const typename Kernel::Vector_3& normal, const typename Kernel::FT& radius, OutputIterator out, const Kernel& K) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbors_certified_3(first, beyond, p, radius, out, I_gt(p,normal)); } // Versions with instantiated traits class: template std::pair< OutputIterator, bool > surface_neighbors_certified_3(InputIterator first, InputIterator beyond, const typename ITraits::Point_2& p, OutputIterator out, const ITraits& traits) { //find the point in [first,beyond) furthest from p: InputIterator furthest = std::max_element(first, beyond, closer_to_point(p, traits)); return surface_neighbors_certified_3 (first, beyond, p, traits.compute_squared_distance_2_object()(p,*furthest), out, traits); } template std::pair< OutputIterator, bool > surface_neighbors_certified_3(InputIterator first, InputIterator beyond, const typename ITraits::Point_2& p, const typename ITraits::FT& radius, OutputIterator out, const ITraits& traits) { //definition of the Voronoi intersection triangulation: typedef Regular_triangulation_2< ITraits> I_triangulation; typedef typename I_triangulation::Vertex_handle Vertex_handle; typedef typename I_triangulation::Face_handle Face_handle; typedef typename I_triangulation::Vertex_circulator Vertex_circulator; typedef typename I_triangulation::Face_circulator Face_circulator; typedef typename I_triangulation::Locate_type Locate_type; //build Voronoi intersection triangulation: I_triangulation it(traits); it.insert(first,beyond); Locate_type lt; int li; Face_handle fh = it.locate(p, lt, li); if(lt == I_triangulation::VERTEX){ *out++ =p; return std::make_pair(out,true); } Vertex_handle vh = it.insert(p, fh); CGAL_assertion(vh->is_valid()); //determine the furthest distance from p to a vertex of its cell bool valid(false); Face_circulator fc(it.incident_faces(vh)), fdone(fc); do valid = (!it.is_infinite(fc) && (4*radius > traits.compute_squared_distance_2_object() (p, it.dual(fc)))); while(!valid && ++fc!=fdone); //get the neighbor points: Vertex_circulator vc(it.incident_vertices(vh)), vdone(vc); do *out++= vc->point(); while(++vc!=vdone); return std::make_pair(out, valid); } //using Delaunay triangulation for candidate point filtering: // => no certification is necessary template inline OutputIterator surface_neighbors_3(const Dt& dt, const typename Dt::Geom_traits::Point_3& p, const typename Dt::Geom_traits::Vector_3& normal, OutputIterator out, typename Dt::Cell_handle start =typename Dt::Cell_handle()) { typedef Voronoi_intersection_2_traits_3 I_gt; return surface_neighbors_3(dt, p, out, I_gt(p,normal),start); } template OutputIterator surface_neighbors_3(const Dt& dt, const typename ITraits::Point_2& p, OutputIterator out, const ITraits& traits, typename Dt::Cell_handle start = typename Dt::Cell_handle()) { typedef typename ITraits::FT Coord_type; typedef typename ITraits::Point_2 Point_3; typedef typename Dt::Cell_handle Cell_handle; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Locate_type Locate_type; //the Vertex_handle is, in fact, an iterator over vertex: typedef Project_vertex_iterator_to_point< Vertex_handle> Proj_point; typedef Iterator_project< typename std::list< Vertex_handle >::iterator, Proj_point, const Point_3&, const Point_3*, std::ptrdiff_t, std::forward_iterator_tag> Point_iterator; Locate_type lt; int li, lj ; Cell_handle c = dt.locate(p, lt, li,lj,start); //if p is located on a vertex: the only neighbor is found if(lt == Dt::VERTEX){ *out++= (c->vertex(li))->point(); return out; } //otherwise get vertices in conflict typename std::list< Vertex_handle > conflict_vertices; dt.vertices_in_conflict(p,c, std::back_inserter(conflict_vertices)); for (typename std::list< Vertex_handle >::iterator it = conflict_vertices.begin(); it != conflict_vertices.end();){ if(dt.is_infinite(*it)){ typename std::list< Vertex_handle >::iterator itp = it; it++; conflict_vertices.erase(itp); } else { it++; } } return surface_neighbors_3(Point_iterator(conflict_vertices.begin()), Point_iterator(conflict_vertices.end()), p, out, traits); } CGAL_END_NAMESPACE #endif // CGAL_SURFACE_NEIGHBORS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/0000755000175000017500000000000012146213710025335 5ustar debiandebian././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Geomview_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Geomview_stream.0000644000175000017500000000274411344301501031131 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Geomview_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_PM_GEOMVIEW_STREAM_H #define CGAL_IO_PM_GEOMVIEW_STREAM_H #ifndef CGAL_PLANAR_MAP_2_H #include #endif /* #ifndef CGAL_IO_PM_BOUNDING_BOX_BASE_WINDOW_STREAM_H #include #endif */ #ifndef CGAL_IO_PM_DRAWER_H #include #endif #ifndef CGAL_IO_DRAW_PM_H #include #endif CGAL_BEGIN_NAMESPACE template Geomview_stream& operator<< (Geomview_stream & os, const Planar_map_2 & pm) { Pm_drawer< Planar_map_2, Geomview_stream> drawer(os); draw_pm(pm, drawer, os); return os; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_inventor_ostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_inventor0000644000175000017500000000301311344301501031317 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_inventor_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_POLYHEDRON_INVENTOR_OSTREAM_H #define CGAL_IO_POLYHEDRON_INVENTOR_OSTREAM_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> Inventor_ostream_base& operator<<( Inventor_ostream_base& out, const Polyhedron_3& P) { File_writer_inventor writer; generic_print_polyhedron( out.os(), P, writer); return out; } CGAL_END_NAMESPACE #endif // CGAL_IO_POLYHEDRON_INVENTOR_OSTREAM_H // // EOF // ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Postscript_file_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Postscript_file_str0000644000175000017500000004721311344301501031323 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Postscript_file_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_POSTSCRIPT_FILE_STREAM_H #define CGAL_POSTSCRIPT_FILE_STREAM_H #include #include #ifdef LEDA_PS_FILE_H # error Internal CGAL error: should not have been included yet #else # include # include # include # include # include # include # include # include # include # if (__LEDA__ >= 400) # include # endif // 400 # include # include # if (__LEDA__ >= 400) # include # include # endif // 400 # define private protected # include # undef private #endif // LEDA_PS_FILE_H #include CGAL_BEGIN_NAMESPACE typedef CGAL_LEDA_SCOPE::ps_file leda_ps_file; class Postscript_file_stream : public leda_ps_file { public: Postscript_file_stream(double w,double h, leda_string name="CGAL_unnamed.ps") : leda_ps_file(w/40.0, h/40.0, name) {} Postscript_file_stream(leda_string name="CGAL_unnamed.ps") : leda_ps_file( name ) { set_draw_bb(false); } void display() {} void display(int, int) {} int read_mouse(double& , double& ) {return 1;} leda_color set_fg_color(leda_color c) { return set_color(c); } void set_font(const leda_string& ls) { set_text_font(ls); } void change_rgb(const Color&); bool is_in_colormode(); }; inline void Postscript_file_stream::change_rgb(const Color& c) { file << double(c.r())/255.0 << " " << double(c.g())/255.0 << " " << double(c.b())/255.0 << " srgb\n"; } inline bool Postscript_file_stream::is_in_colormode() { return (outputmode== CGAL_LEDA_SCOPE::colored_mode); } inline Postscript_file_stream& operator<<(Postscript_file_stream& w, const Color& c) { assert( w.is_in_colormode() ); w.change_rgb(c); return w; } inline void cgalize(Postscript_file_stream& w) { w.set_line_width( 1); } inline Postscript_file_stream* create_demo_postscript_file_stream( float w = 512.0, float h = 512.0, const char* str = "CGAL_unnamed.ps", double x_extension = 1.0) { Postscript_file_stream* Wptr = new Postscript_file_stream( w, h, str); cgalize( *Wptr); double y_extension = x_extension * h / w; Wptr->init(-x_extension, x_extension, -y_extension); return Wptr; } inline Postscript_file_stream* create_and_display_demo_postscript_file_stream(float w = 512.0, float h = 512.0, const char* str = "CGAL_unnamed.ps", double x_extension = 1.0) { Postscript_file_stream* Wptr = new Postscript_file_stream( w, h, str); cgalize( *Wptr); double y_extension = x_extension * h / w; Wptr->init(-x_extension, x_extension, -y_extension); return Wptr; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_H // Each of the following operators is individually // protected against multiple inclusion. #ifdef CGAL_POINT_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_POINT_2 #define CGAL_POSTSCRIPT_FILE_STREAM_POINT_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Point_2& p) { double x = CGAL::to_double(p.x()); double y = CGAL::to_double(p.y()); w.draw_point(x,y); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Point_2& p) { typedef typename R::RT RT; leda_point l_p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if (w >> l_p) { double x = l_p.xcoord(); double y = l_p.ycoord(); w << l_p; w.set_mode( save); w.draw_point(x,y); p = Point_2( RT(x), RT(y)); } else { w.set_mode( save); } return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Point_2& p) { typedef typename R::RT RT; leda_point l_p; if (w >> l_p) { double x = l_p.xcoord(); double y = l_p.ycoord(); p = Point_2( RT(x), RT(y)); } return w; } template void read_mouse_plus(Postscript_file_stream& w, Point_2& p, int& button) { typedef typename R::RT RT; double x, y; button = w.read_mouse(x,y); w.draw_point(x,y); p = Point_2(RT(x), RT(y)); } #endif // CGAL_POSTSCRIPT_FILE_STREAM_POINT_2 #endif // CGAL_POINT_2_H #ifdef CGAL_SEGMENT_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_SEGMENT_2 #define CGAL_POSTSCRIPT_FILE_STREAM_SEGMENT_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Segment_2& s) { w.draw_segment(CGAL::to_double(s.source().x()), CGAL::to_double(s.source().y()), CGAL::to_double(s.target().x()), CGAL::to_double(s.target().y())); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Segment_2& s) { typedef typename R::RT RT; leda_segment l_s; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); w.set_mode( save); w.draw_segment(x1,y1, x2, y2); s = Segment_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } else { w.set_mode( save); } return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Segment_2& s) { typedef typename R::RT RT; leda_segment l_s; if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); s = Segment_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_SEGMENT_2 #endif // CGAL_SEGMENT_2_H #ifdef CGAL_LINE_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_LINE_2 #define CGAL_POSTSCRIPT_FILE_STREAM_LINE_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Line_2& l) { Point_2 p1 = l.point(), p2 = p1 + l.direction().vector(); w.draw_line(CGAL::to_double(p1.x()), CGAL::to_double(p1.y()), CGAL::to_double(p2.x()), CGAL::to_double(p2.y())); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Line_2& l) { typedef typename R::RT RT; leda_segment l_s; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); w.set_mode( save); w.draw_line(x1,y1, x2, y2); l = Line_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } else { w.set_mode( save); } return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Line_2& l) { typedef typename R::RT RT; leda_segment l_s; if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); l = Line_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_LINE_2 #endif //CGAL_LINE_2_H #ifdef CGAL_RAY_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_RAY_2 #define CGAL_POSTSCRIPT_FILE_STREAM_RAY_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Ray_2& r) { Point_2 p = r.point(0); Point_2 q = r.point(1); w.draw_ray(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(q.x()), CGAL::to_double(q.y())); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Ray_2& r) { typedef typename R::RT RT; leda_segment l_s; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); w.set_mode( save); r = Ray_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); w << r; } else { w.set_mode( save); } return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Ray_2& r) { typedef typename R::RT RT; leda_segment l_s; if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); r = Ray_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_RAY_2 #endif //CGAL_RAY_2_H #ifdef CGAL_TRIANGLE_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_TRIANGLE_2 #define CGAL_POSTSCRIPT_FILE_STREAM_TRIANGLE_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Triangle_2& t) { double x0 = CGAL::to_double(t.vertex(0).x()), y0 = CGAL::to_double(t.vertex(0).y()), x1 = CGAL::to_double(t.vertex(1).x()), y1 = CGAL::to_double(t.vertex(1).y()), x2 = CGAL::to_double(t.vertex(2).x()), y2 = CGAL::to_double(t.vertex(2).y()); w.draw_segment(x0, y0, x1, y1); w.draw_segment(x1, y1, x2, y2); w.draw_segment(x2, y2, x0, y0); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Triangle_2& t) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second, third, p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w >> first)) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_seg( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( first.xcoord(), first.ycoord(), x, y); second = leda_point( x, y); } key = w.read_mouse_seg( second.xcoord(), second.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w << leda_segment( first, second ); w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( second.xcoord(), second.ycoord(), x, y); third = leda_point( x, y); } w << leda_segment( first, second ); w << leda_segment( second, third ); double x0 = first.xcoord(); double y0 = first.ycoord(); double x1 = second.xcoord(); double y1 = second.ycoord(); double x2 = third.xcoord(); double y2 = third.ycoord(); w.set_mode( save); w.draw_segment(x0,y0, x1, y1); w.draw_segment(x1,y1, x2, y2); w.draw_segment(x2,y2, x0, y0); t = Triangle_2(Point_2( RT(x0), RT(y0)), Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Triangle_2& t) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second, third, p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w >> first)) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_seg( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( first.xcoord(), first.ycoord(), x, y); second = leda_point( x, y); } key = w.read_mouse_seg( second.xcoord(), second.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w << leda_segment( first, second ); w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( second.xcoord(), second.ycoord(), x, y); third = leda_point( x, y); } w << leda_segment( first, second ); w << leda_segment( second, third ); double x0 = first.xcoord(); double y0 = first.ycoord(); double x1 = second.xcoord(); double y1 = second.ycoord(); double x2 = third.xcoord(); double y2 = third.ycoord(); w.set_mode( save); t = Triangle_2(Point_2( RT(x0), RT(y0)), Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_TRIANGLE_2 #endif // CGAL_TRIANGLE_2_H #ifdef CGAL_CIRCLE_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_CIRCLE_2 #define CGAL_POSTSCRIPT_FILE_STREAM_CIRCLE_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Circle_2& c) { double cx = CGAL::to_double(c.center().x()), cy = CGAL::to_double(c.center().y()), r = CGAL::to_double(c.squared_radius()); w.draw_circle(cx, cy , sqrt(r)); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Circle_2& c) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( p))) { w.set_mode( save); return w; } double cx = p.xcoord(); double cy = p.ycoord(); Point_2 center = Point_2( RT(cx), RT(cy)); int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_circle(cx, cy, x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } double dx = x - cx; double dy = y - cy; double sqr = dx*dx+dy*dy; w.set_mode( save); w.set_buttons( save_but); w.draw_circle(cx, cy , sqrt(sqr)); c = Circle_2(center, RT(sqr)); return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Circle_2& c) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( p))) { w.set_mode( save); return w; } double cx = p.xcoord(); double cy = p.ycoord(); Point_2 center = Point_2( RT(cx), RT(cy)); int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_circle(cx, cy, x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } double dx = x - cx; double dy = y - cy; double sqr = dx*dx+dy*dy; w.set_mode( save); w.set_buttons( save_but); c = Circle_2(center, RT(sqr)); return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_CIRCLE_2 #endif // CGAL_CIRCLE_2_H #ifdef CGAL_ISO_RECTANGLE_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_ISO_RECTANGLE_2 #define CGAL_POSTSCRIPT_FILE_STREAM_ISO_RECTANGLE_2 template< class R > Postscript_file_stream& operator<<(Postscript_file_stream& w, const Iso_rectangle_2& r) { double xmin = CGAL::to_double(r.min().x()), ymin = CGAL::to_double(r.min().y()), xmax = CGAL::to_double(r.max().x()), ymax = CGAL::to_double(r.max().y()); w.draw_segment(xmin, ymin, xmax, ymin); w.draw_segment(xmax, ymin, xmax, ymax); w.draw_segment(xmax, ymax, xmin, ymax); w.draw_segment(xmin, ymax, xmin, ymin); return w; } template< class R > Postscript_file_stream& operator>>(Postscript_file_stream& w, Iso_rectangle_2& r) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_rect( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } r = Iso_rectangle_2(Point_2( RT(first.xcoord()), RT(first.ycoord())), Point_2( RT(x), RT(y))); w.set_mode( save); w.draw_rectangle( first.xcoord(), first.ycoord(), x, y); w.set_buttons( save_but); return w; } template< class R > Postscript_file_stream& read(Postscript_file_stream& w, Iso_rectangle_2& r) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_rect( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } r = Iso_rectangle_2(Point_2( RT(first.xcoord()), RT(first.ycoord())), Point_2( RT(x), RT(y))); w.set_mode( save); w.set_buttons( save_but); return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_ISO_RECTANGLE_2 #endif // CGAL_ISO_RECTANGLE_2_H #ifdef CGAL_BBOX_2_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_BBOX_2 #define CGAL_POSTSCRIPT_FILE_STREAM_BBOX_2 inline Postscript_file_stream& operator<<(Postscript_file_stream& w, const Bbox_2& b) { #if (__LEDA__ >= 400) leda_line_style style = w.set_line_style(leda_dotted); #else line_style style = w.set_line_style(leda_dotted); #endif // 400 double xmin = b.xmin(), ymin = b.ymin(), xmax = b.xmax(), ymax = b.ymax(); w.draw_segment(xmin, ymin, xmax, ymin); w.draw_segment(xmax, ymin, xmax, ymax); w.draw_segment(xmax, ymax, xmin, ymax); w.draw_segment(xmin, ymax, xmin, ymin); w.set_line_style(style); return w; } #endif // CGAL_POSTSCRIPT_FILE_STREAM_BBOX_2 #endif // CGAL_BBOX_2_H CGAL_END_NAMESPACE mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Window_stream.h0000644000175000017500000000315211344301501030760 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_PM_WINDOW_STREAM_H #define CGAL_IO_PM_WINDOW_STREAM_H #include #include #include #include CGAL_BEGIN_NAMESPACE template Window_stream & operator << (Window_stream & os, const Planar_map_2 & pm) { Pm_drawer< Planar_map_2, Window_stream> drawer(os); draw_pm(pm, drawer, os); return os; } /*template Window_stream& write(Window_stream& os, Planar_map_2 &m) { // os << *m.get_bounding_box(); Halfedge_iterator it = m.halfedges_begin(), end = m.halfedges_end(); const Traits& traits=m.get_traits(); while(it != end){ write(os,it->curve(),traits); ++it;++it; } return os; } */ CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_help_window.h0000644000175000017500000000474111344301501030472 0ustar debiandebian// Copyright (c) 1997-2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_help_window.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_HELP_WINDOW_H #define CGAL_QT_HELP_WINDOW_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include class QComboBox; class QPopupMenu; namespace CGAL{ class Qt_help_window : public QMainWindow { Q_OBJECT public: Qt_help_window( const QString& home_, const QString& path, QWidget* parent = 0, const char *name=0 ); ~Qt_help_window(); public slots: void print(); private slots: void setBackwardAvailable( bool ); void setForwardAvailable( bool ); void pathSelected( const QString & ); void histChosen( int ); private: void readHistory(); QTextBrowser* browser; QComboBox *pathCombo; int backwardId, forwardId; QStringList history; QPopupMenu *hist; QMap mHistory; }; } //end CGAL namespace #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_poly.h0000644000175000017500000001070111344301501027422 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_poly.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_FILE_POLY_H #define CGAL_FILE_POLY_H namespace CGAL { template inline void read_triangle_poly_file(CDT& t, std::istream &f) { read_triangle_poly_file(t, f, Emptyset_iterator()); } //the function that reads a Shewchuk Triangle .poly file template void read_triangle_poly_file(CDT& t, std::istream &f, OutputIterator seeds) { typedef typename CDT::Vertex_handle Vertex_handle; typedef typename CDT::Point Point; t.clear(); unsigned int number_of_points; skip_comment_OFF(f); f >> number_of_points; skip_until_EOL(f); skip_comment_OFF(f); // read vertices std::vector vertices(number_of_points); for(unsigned int i = 0; i < number_of_points; ++i) { unsigned int j; Point p; f >> j >> p; skip_until_EOL(f); skip_comment_OFF(f); vertices[--j] = t.insert(p); } // read segments unsigned int number_of_segments; f >> number_of_segments; skip_until_EOL(f); skip_comment_OFF(f); for(unsigned int k = 0; k < number_of_segments; ++k) { unsigned int l, v1, v2; f >> l >> v1 >> v2; skip_until_EOL(f); skip_comment_OFF(f); t.insert_constraint(vertices[--v1], vertices[--v2]); } // read holes unsigned int number_of_holes; f >> number_of_holes; for(unsigned int m = 0; m < number_of_holes; ++m) { unsigned int n; Point p; f >> n >> p; skip_until_EOL(f); skip_comment_OFF(f); *seeds++ = p; } } //the function that write a Shewchuk Triangle .poly file template void write_triangle_poly_file(const CDT& t, std::ostream &f, InputIterator begin, InputIterator end) { typedef typename CDT::Vertex_handle Vertex_handle; typedef typename CDT::Finite_vertices_iterator Finite_vertices_iterator; typedef typename CDT::Finite_edges_iterator Finite_edges_iterator; std::map index; // write vertices f << "# Shewchuk Triangle .poly file, produced by the CGAL::Mesh_2 package" << std::endl << "# Neither attributes nor boundary markers are used." << std::endl << t.number_of_vertices() << " " << 2 << " " << 0 << " " << 0 << std::endl; f << std::endl; unsigned int vertices_counter = 0; for(Finite_vertices_iterator vit = t.finite_vertices_begin(); vit != t.finite_vertices_end(); ++vit) { f << ++vertices_counter << " " << vit->point() << std::endl; index[vit] = vertices_counter; } f << std::endl; // write constrained edges int number_of_constrained_edges = 0; for(Finite_edges_iterator it = t.finite_edges_begin(); it != t.finite_edges_end(); ++it) if(it->first->is_constrained(it->second)) ++number_of_constrained_edges; f << number_of_constrained_edges << " " << 0 << std::endl; unsigned int edges_counter = 0; for(Finite_edges_iterator eit = t.finite_edges_begin(); eit != t.finite_edges_end(); ++eit) if(eit->first->is_constrained(eit->second)) f << ++edges_counter << " " << index[eit->first->vertex(t.cw(eit->second))] << " " << index[eit->first->vertex(t.ccw(eit->second))] << std::endl; f << std::endl; // write seeds, assuming that the seeds unmarks faces f << std::distance(begin, end) << std::endl; unsigned int seeds_counter = 0; for(InputIterator sit = begin; sit!=end; ++sit) f << ++seeds_counter << " " << *sit << std::endl; } //the same without holes. template void write_triangle_poly_file(const CDT& t, std::ostream &f) { std::list l; write_triangle_poly_file(t, f, l.begin(), l.end()); } } // end namespace CGAL #endif // CGAL_FILE_POLY_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/write_arr.h0000644000175000017500000002236511344301501027507 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/write_arr.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_WRITE_ARR_H #define CGAL_IO_WRITE_ARR_H #ifndef CGAL_BASIC_H #include #endif #include #include #include #include CGAL_BEGIN_NAMESPACE template void write_arr(const Arr & arr, Writer & writer, std::ostream & o) { typedef typename Arr::Planar_map PM; typedef typename Arr::Vertex Vertex; typedef typename Arr::Face Face; typedef typename Arr::Halfedge Halfedge; typedef typename Arr::Curve_iterator Curve_iterator; typedef typename Arr::Subcurve_iterator Subcurve_iterator; typedef typename Arr::Edge_iterator Edge_iterator; typedef typename Arr::Curve_const_iterator Curve_const_iterator; typedef typename Arr::Subcurve_const_iterator Subcurve_const_iterator; typedef typename Arr::Edge_const_iterator Edge_const_iterator; typedef typename Arr::Vertex_handle Vertex_handle; typedef typename Arr::Halfedge_handle Halfedge_handle; typedef typename Arr::Face_handle Face_handle; typedef typename Arr::Vertex_const_handle Vertex_const_handle; typedef typename Arr::Halfedge_const_handle Halfedge_const_handle; typedef typename Arr::Face_const_handle Face_const_handle; typedef typename Arr::Vertex_iterator Vertex_iterator; typedef typename Arr::Vertex_const_iterator Vertex_const_iterator; typedef typename Arr::Halfedge_iterator Halfedge_iterator; typedef typename Arr::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Arr::Face_iterator Face_iterator; typedef typename Arr::Face_const_iterator Face_const_iterator; typedef typename Arr::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Arr::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Arr::Holes_iterator Holes_iterator; typedef typename Arr::Holes_const_iterator Holes_const_iterator; typedef typename Arr::Overlap_circulator Overlap_circulator; typedef typename Arr::Overlap_const_circulator Overlap_const_circulator; typedef typename Arr::Locate_type Locate_type; typedef Inverse_index H_index; typedef Inverse_index Cn_index; typedef Inverse_index Scv_index; typedef Inverse_index En_index; H_index h_index(arr.halfedges_begin(), arr.halfedges_end()); writer.write_title("Printing Arrangement"); write_pm(arr.get_planar_map(), writer, o); writer.write_comment("Printing curve hierachy"); std::vector en_index_table; // creating curve indices. Cn_index cn_index(arr.curve_node_begin(), arr.curve_node_end()); // creating the edge node indices table. Curve_const_iterator cv_iter; for (cv_iter = arr.curve_node_begin(); cv_iter != arr.curve_node_end(); cv_iter++){ En_index en_index(cv_iter->edges_begin(), cv_iter->edges_end()); en_index_table.push_back(en_index); } int number_of_curves = 0; for (cv_iter = arr.curve_node_begin(); cv_iter != arr.curve_node_end(); cv_iter++, number_of_curves++); writer.write_comment("number of curves"); writer.write_value(number_of_curves); unsigned int curve_index = 0; for (cv_iter = arr.curve_node_begin(); cv_iter != arr.curve_node_end(); cv_iter++, curve_index++){ unsigned int number_of_edge_nodes = 0; writer.write_comment("'th curve", curve_index+1); //cout<curve()<number_of_sc_levels()); // making a table of indices for all scv levels. std::vector scv_index; unsigned int i; for (i = 0; i < cv_iter->number_of_sc_levels(); i++){ //Subcurve_const_iterator tmp_begin, tmp_end; // for debug. //tmp_begin = cv_iter->level_begin(i); //tmp_end = cv_iter->level_end(i); Scv_index one_scv_index(cv_iter->level_begin(i), cv_iter->level_end(i)); scv_index.push_back(one_scv_index); } En_index en_index(cv_iter->edges_begin(), cv_iter->edges_end()); for (i = 0; i < cv_iter->number_of_sc_levels(); i++){ writer.write_comment("'th level", i+1); unsigned int number_of_subcurves = 0; Subcurve_const_iterator sc_iter; for (sc_iter = cv_iter->level_begin(i); sc_iter != cv_iter->level_end(i); sc_iter++, number_of_subcurves++); writer.write_value(number_of_subcurves); for (sc_iter = cv_iter->level_begin(i); sc_iter != cv_iter->level_end(i); sc_iter++){ if (i+1 < cv_iter->number_of_sc_levels()){ if (!writer.verbose()){ writer.write_comment( "begin and past end indices of children subcurve nodes"); Subcurve_const_iterator last_child = sc_iter->children_end(); writer.write_value((scv_index[i+1])[sc_iter->children_begin()], ' '); writer.write_value((scv_index[i+1])[--last_child] + 1); } else { writer.write_comment("All children subcurve nodes"); Subcurve_const_iterator child_iter; for (child_iter = sc_iter->children_begin(); child_iter != sc_iter->children_end(); child_iter++) writer.write_subcurve (child_iter); } } else{ // getting to the edge nodes. if (!writer.verbose()){ writer.write_comment ("begin and past end indices of children edge nodes"); Edge_const_iterator last_child = sc_iter->edges_end(); writer.write_value(en_index[sc_iter->edges_begin()], ' '); writer.write_value(en_index[--last_child] + 1); } else{ writer.write_comment("All children edge nodes"); for (Edge_const_iterator child_iter = sc_iter->edges_begin(); child_iter != sc_iter->edges_end(); child_iter++) writer.write_edge(child_iter); } } //writer.skip_line(); writer.write_comment("subcurve of current level"); writer.write_subcurve(sc_iter); } } writer.write_comment("number of edge nodes"); for (Edge_const_iterator edge_count_iter = cv_iter->edges_begin(); edge_count_iter != cv_iter->edges_end(); edge_count_iter++, number_of_edge_nodes++); writer.write_value(number_of_edge_nodes); writer.write_comment("----------------------- Edge nodes childrens:"); for (Edge_const_iterator edge_iter = cv_iter->edges_begin(); edge_iter != cv_iter->edges_end(); edge_iter++){ if (!writer.verbose()){ // printing next overlapping edge node. writer.write_comment("pair indices (curve node and its edge node) " "for next overlapping edge node :"); //cout<<"edge_iter->curve()"<curve()<children_end()); std::size_t j = cn_index[edge_past_end_child->curve_node()]; std::size_t k = (en_index_table[j])[edge_past_end_child]; writer.write_value(j, ' '); writer.write_value(k); //cout<children_begin()->curve(); //writer.write_index(en_index[edge_iter->children_begin()]); //writer.write_index(en_index[edge_iter->children_end()]); writer.write_comment("Halfedge indices associated with edge nodes"); writer.write_value (h_index[Halfedge_const_iterator(edge_iter->halfedge())]); } else{ writer.write_comment("Halfedge associated with edge nodes"); writer.write_halfedge_verbose(edge_iter->halfedge()); } //writer.skip_line(); writer.write_comment("Edge node curve"); writer.write_edge(edge_iter); } writer.write_comment("finished current level"); //writer.write_edge_nodes_end(); } writer.write_title("End of Arrangement"); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Alpha_shape_3_VRML_2_ostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Alpha_shape_3_VRML_0000644000175000017500000000734211344301501030707 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Alpha_shape_3_VRML_2_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_ALPHA_SHAPE_3_VRML_2_OSTREAM_H #define CGAL_ALPHA_SHAPE_3_VRML_2_OSTREAM_H #include #include #ifdef CGAL_ALPHA_SHAPE_3_H CGAL_BEGIN_NAMESPACE template VRML_2_ostream& operator<<(VRML_2_ostream& os, Alpha_shape_3
    &as) { // Finite vertices coordinates. Alpha_shape_3
    ::Alpha_shape_vertices_iterator Vlist_it, Vlist_begin = as.alpha_shape_vertices_begin(), Vlist_end = as.alpha_shape_vertices_end(); std::map::Vertex_handle, int> V; int number_of_vertex = 0; for( Vlist_it = Vlist_begin; Vlist_it != Vlist_end; Vlist_it++) { V[*Vlist_it] = number_of_vertex++; } typename Alpha_shape_3
    ::Alpha_shape_facets_iterator Flist_it, Flist_begin = as.alpha_shape_facets_begin(), Flist_end = as.alpha_shape_facets_end(); std::map::Facet, int> F; int number_of_facets = 0; for( Flist_it = Flist_begin; Flist_it != Flist_end; Flist_it++) { F[*Flist_it] = number_of_facets++; } const char *Indent = " "; os << " Group {\n" " children [\n" " Shape {\n" " appearance USE A1\n" " geometry\n" " IndexedFaceSet {\n" " coord Coordinate {\n" " point [ \n" << Indent << " "; for( Vlist_it = Vlist_begin; Vlist_it != Vlist_end; Vlist_it++) { os << CGAL::to_double((*Vlist_it)->point().x()) << " "; os << CGAL::to_double((*Vlist_it)->point().y()) << " "; os << CGAL::to_double((*Vlist_it)->point().z()) << ",\n" << Indent << " "; } os << "\n ]\n" " } # coord\n" " solid FALSE\n" << Indent << "coordIndex [\n"; // Finite facets indices. for( Flist_it = Flist_begin; Flist_it != Flist_end; Flist_it++){ os << Indent << " "; for (int i=0; i<4; i++) if (i != (*Flist_it).second){ os << V[(*Flist_it).first->vertex(i)]; os << ", "; } if (Flist_it != Flist_end) os << "-1,\n"; else os << "-1 \n"; } os << Indent << "]\n"; " } #IndexedFaceSet\n" " } #Shape\n" " ] #children\n" " } #Group\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_ALPHA_SHAPE_3_H #endif CGAL_ALPHA_SHAPE_3_VRML_2_OSTREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_file_scanner.h0000644000175000017500000002004711344301501030570 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_file_scanner.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_PM_FILE_SCANNER_H #define CGAL_IO_PM_FILE_SCANNER_H 1 #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_KNOWN_BIT_SIZE_INTEGERS_H #include #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif #ifndef CGAL_IO_BINARY_FILE_IO_H #include #endif // CGAL_IO_BINARY_FILE_IO_H #ifndef CGAL_IO_FILE_HEADER_H #include #endif // CGAL_IO_FILE_HEADER_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE template class Pm_file_scanner : public File_header { public: typedef PM_ Planar_map; typedef typename Planar_map::Traits Traits; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef typename Planar_map::Dcel::Vertex D_vertex; typedef typename Planar_map::Dcel::Halfedge D_halfedge; typedef typename Planar_map::Dcel::Face D_face; Pm_file_scanner(std::istream & in) : File_header(), m_in(in) { skip_comment(); } Pm_file_scanner(std::istream & in, const File_header & header) : File_header(header), m_in(in) { skip_comment(); } std::istream& in() { return m_in; } void scan_pm_vhf_sizes (){ std::size_t v, h, f; in() >> v >> h >> f; set_number_of_vertices(v); set_number_of_halfedges(h); set_number_of_faces(f); } void scan_vertex (D_vertex* v){ Point p; skip_comment(); // providing default reading function. in() >> p; if ( !in()){ std::cerr << "can't read face number"<set_point(p); } X_curve scan_halfedge (D_halfedge* h){ // providing default reading function. X_curve cv; skip_comment(); in() >> cv; if ( !in()){ std::cerr << "can't read face number"<set_curve(cv); halfedges_vec.push_back(h); return cv; } //void update_halfedges_vec(D_halfedge* h) // { // halfedges_vec.push_back(h); // } void scan_face(D_face* f) { std::size_t num_of_holes, num_halfedges_on_outer_ccb, i = 0; scan_face_number(num_halfedges_on_outer_ccb, i); if ( !in()){ std::cerr << "can't read face number"< 0){ std::size_t index, prev_index = 0, first_index = 0; for (unsigned int j = 0; j < num_halfedges_on_outer_ccb; j++) { scan_index(index); if ( !in()){ std::cerr << "can't read halfedge's index on face"<vertex()->point()< 0) { D_halfedge* prev_nh = halfedges_vec[prev_index]; prev_nh->set_next(nh); } else { f->set_halfedge(nh); first_index = index; } nh->set_face(f); prev_index = index; } // making the last halfedge point to the first one (cyclic order). D_halfedge* nh = halfedges_vec[first_index]; D_halfedge* prev_nh = halfedges_vec[prev_index]; prev_nh->set_next(nh); } scan_face_number(num_of_holes, i); if ( !in()){ std::cerr << "can't read number holes in face"<vertex()->point()< 0) { D_halfedge* prev_nh = halfedges_vec[prev_index]; prev_nh->set_next(nh); } else { f->add_hole(nh); first_index = index; } nh->set_face(f); prev_index = index; } // making the last halfedge point to the first one (cyclic order). D_halfedge* nh = halfedges_vec[first_index]; D_halfedge* prev_nh = halfedges_vec[prev_index]; prev_nh->set_next(nh); } skip_to_next_face(); if ( !in()){ std::cerr << "can't skip to next face"<> index; if( ! in()) { return; } index -= index_offset(); } protected: std::istream& m_in; std::vector halfedges_vec; void scan_face_vertex_index(std::size_t& index , std::size_t current_face){ in() >> index; if( ! in()) { return; } index -= index_offset(); /* if( index < 0 || index >= size_of_halfedges()) { in().clear( std::ios::badbit); std::cerr << " " << std::endl; std::cerr << "File_scanner_pm::" << std::endl; std::cerr << "scan_facet_vertex_index(): input error: " "facet " << current_face << ": vertex index " << index + index_offset() << ": is out of range." << std::endl; //set_off_header( false); return; }*/ //std::cout<< index <> size; //std::cout<< size <> skip_until_EOL skip_until_EOL(in()); } void skip_to_next_halfedge(){ skip_until_EOL(in()); } void skip_to_next_face(){ skip_until_EOL(in()); } void skip_comment() { char c; while( (in() >> c) && c == '#'){ in().putback(c); skip_comment_OFF(in()); //in() >> skip_comment_OFF; } in().putback(c); } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_SCANNER_PM_H // // EOF // ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_VRML_2_ostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_VRML_2_o0000644000175000017500000000303111344301501030772 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_VRML_2_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_POLYHEDRON_VRML_2_OSTREAM_H #define CGAL_IO_POLYHEDRON_VRML_2_OSTREAM_H 1 #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> VRML_2_ostream& operator<<( VRML_2_ostream& out, const Polyhedron_3& P) { File_writer_VRML_2 writer; generic_print_polyhedron( out.os(), P, writer); return out; } CGAL_END_NAMESPACE #endif // CGAL_IO_POLYHEDRON_VRML_2_OSTREAM_H // // EOF // ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Delaunay_d_window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Delaunay_d_window_s0000644000175000017500000000460311344301501031234 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Delaunay_d_window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_DELAUNAY_D_WINDOW_STREAM_H #define CGAL_DELAUNAY_D_WINDOW_STREAM_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*{\Mtext \headerline{Low Dimensional Output Routines} include || \setopdims{2cm}{1cm}}*/ template void d2_show(const Delaunay_d& D, CGAL::Window_stream& W, typename Delaunay_d::Delaunay_voronoi_kind k = Delaunay_d::NEAREST) /*{\Mfunc draws the underlying simplicial complex |D| into window |W|.\\ \precond |dim == 2|. }*/ { CGAL_assertion_msg(D.dimension() == 2, "d2_map: dim != 2."); Regular_complex_d RC(2); D.project(RC, (k == Delaunay_d::NEAREST ? -1 : +1)); CGAL::d2_show(RC,W); } template void d2_map(const Delaunay_d& D, CGAL_LEDA_SCOPE::GRAPH< typename Delaunay_d::Point_d, int >& DTG, typename Delaunay_d::Delaunay_voronoi_kind k = Delaunay_d::NEAREST) /*{\Mfunc constructs a LEDA graph representation of the nearest (|kind = NEAREST| or the furthest (|kind = FURTHEST|) site Delaunay triangulation.\\ \precond |dim() == 2|. }*/ { CGAL_assertion_msg(D.dimension() == 2, "d2_map: dim != 2."); Regular_complex_d RC(2); D.project(RC, (k == NEAREST ? -1 : +1)); d2_map(RC,DTG); } CGAL_END_NAMESPACE #endif //CGAL_DELAUNAY_D_WINDOW_STREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Nef_2.h0000644000175000017500000002026011344301501030441 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Nef_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_NEF_2_H #define CGAL_QT_WIDGET_NEF_2_H #include #include #include #include #include namespace CGAL{ template CGAL::Quotient d_to_q(double x) { NT num = 0; NT den = 1; if (x != 0.0) { int neg = (x < 0); if (neg) x = -x; const unsigned shift = 15; // a safe shift per step const unsigned int shift_pow = 32768; // = 2^shift const double width = 32768; // = 2^shift const int maxiter = 20; // ought not be necessary, but just in case, // max 300 bits of precision int expt; double mantissa = frexp(x, &expt); long exponent = expt; double intpart; int k = 0; while (mantissa != 0.0 && k++ < maxiter) { mantissa *= width; // shift double mantissa mantissa = modf(mantissa, &intpart); num *= shift_pow; num += (long)intpart; exponent -= shift; } int expsign = (exponent>0 ? +1 : (exponent<0 ? -1 : 0)); exponent *= expsign; NT twopot(2); NT exppot(1); while (exponent!=0) { if (exponent & 1) exppot *= twopot; exponent >>= 1; twopot *= twopot; } if (expsign > 0) num *= exppot; else if (expsign < 0) den *= exppot; if (neg) num = -num; } CGAL::Quotient q(num,den); q.normalize(); return q; } template CGAL::Qt_widget& operator<<(CGAL::Qt_widget& ws, const Nef_polyhedron_2& P) { typedef Nef_polyhedron_2 Polyhedron; typedef typename T::RT RT; typedef typename T::Standard_RT Standard_RT; typedef typename T::Standard_segment_2 Standard_segment_2; typedef typename T::Standard_line_2 Standard_line_2; typedef typename T::Standard_point_2 Standard_point_2; typedef typename Polyhedron::Explorer TExplorer; typedef typename TExplorer::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; typedef typename TExplorer::Hole_const_iterator Hole_const_iterator; typedef typename TExplorer::Isolated_vertex_const_iterator Isolated_vertex_const_iterator; typedef typename TExplorer::Ray Ray; typedef typename TExplorer::Point Point; typedef typename TExplorer::Vertex_const_handle Vertex_const_handle; typedef typename TExplorer::Halfedge_const_handle Halfedge_const_handle; typedef typename TExplorer::Face_const_handle Face_const_handle; typedef typename TExplorer::Vertex_const_iterator Vertex_const_iterator; typedef typename TExplorer::Halfedge_const_iterator Halfedge_const_iterator; typedef typename TExplorer::Face_const_iterator Face_const_iterator; //get the background color, fill color, and the object color QColor bgcolor = ws.backgroundColor(); QColor fillcolor = ws.fillColor(); QColor color = ws.color(); //QPixmap //QPainter painter QPixmap &widget_pixmap = ws.get_pixmap(); QPixmap copy_of_pixmap = (QPixmap)widget_pixmap; widget_pixmap.fill(bgcolor); //Get the screen rectangle to intersect with the current Nef CGAL::Quotient wsxq = d_to_q(ws.x_min()-1); CGAL::Quotient wsyq = d_to_q(ws.y_min()-1); Standard_RT wsx = wsxq.numerator() * wsyq.denominator(); Standard_RT wsy = wsyq.numerator() * wsxq.denominator(); Standard_RT wsh = wsxq.denominator() * wsyq.denominator(); Standard_point_2 p1(wsx, wsy, wsh); wsxq = d_to_q(ws.x_min()-1); wsyq = d_to_q(ws.y_max()+1); wsx = wsxq.numerator() * wsyq.denominator(); wsy = wsyq.numerator() * wsxq.denominator(); wsh = wsxq.denominator() * wsyq.denominator(); Standard_point_2 p2(wsx, wsy, wsh); wsxq = d_to_q(ws.x_max()+1); wsyq = d_to_q(ws.y_max()+1); wsx = wsxq.numerator() * wsyq.denominator(); wsy = wsyq.numerator() * wsxq.denominator(); wsh = wsxq.denominator() * wsyq.denominator(); Standard_point_2 p3(wsx, wsy, wsh); wsxq = d_to_q(ws.x_max()+1); wsyq = d_to_q(ws.y_min()-1); wsx = wsxq.numerator() * wsyq.denominator(); wsy = wsyq.numerator() * wsxq.denominator(); wsh = wsxq.denominator() * wsyq.denominator(); Standard_point_2 p4(wsx, wsy, wsh); Standard_point_2 rect1[4] = {p4, p3, p2, p1}; Nef_polyhedron_2 N1(rect1, rect1+4); Nef_polyhedron_2 N2 = P.intersection(N1); TExplorer D = N2.explorer(); //TExplorer D = P.explorer(); //The faces Face_const_iterator fit = D.faces_begin(), fend = D.faces_end(); // we don't draw the first face outside the box: for ( ++fit; fit != fend; ++fit) { Qt::RasterOp old_raster = ws.rasterOp(); ws.setRasterOp(Qt::CopyROP); //save the initial raster mode if(D.mark(fit)) ws.setFillColor(fillcolor); else ws.setFillColor(bgcolor); std::list l; Halfedge_around_face_const_circulator fcirc(D.halfedge(fit)), fend(fcirc); CGAL_For_all(fcirc, fend){ if(D.is_standard(D.target(fcirc))) l.push_back(D.point(D.target(fcirc))); } QPointArray array(l.size());int i=0; typename std::list::const_iterator it = l.begin(); while(it!=l.end()){ array.setPoint(i++, ws.x_pixel(to_double((*it).x())), ws.y_pixel(to_double((*it).y()))); it++; } ws.get_painter().drawPolygon(array); ws.setRasterOp(old_raster); /* Isolated_vertex_const_iterator iv_it; for (iv_it = D.isolated_vertices_begin(fit); iv_it != D.isolated_vertices_end(fit); ++iv_it) { if(D.mark(iv_it)) ws.setColor(color); else ws.setColor(bgcolor); if(D.is_standard(iv_it)) ws << D.point(iv_it); } */ }//endfor Face_const_iterator //save the initial raster mode Qt::RasterOp old_raster = ws.rasterOp(); ws.setRasterOp(Qt::CopyROP); // draw segments underlying halfedges: Halfedge_const_iterator hit, hend = D.halfedges_end(); for (hit = D.halfedges_begin(); hit != hend; ++(++hit)) { if(D.mark(hit)) ws.setColor(color); else ws.setColor(bgcolor); if(D.is_standard(D.source(hit)) && D.is_standard(D.target(hit))) ws << Standard_segment_2(D.point(D.source(hit)), D.point(D.target(hit))); } // draw points underlying vertices: Vertex_const_iterator vit, vend = D.vertices_end(); for (vit = D.vertices_begin(); vit != vend; ++vit){ if(D.mark(vit)) ws.setColor(color); else ws.setColor(bgcolor); if(D.is_standard(vit)) ws << D.point(vit); } ws.setRasterOp(old_raster); bitBlt(&widget_pixmap, 0, 0, ©_of_pixmap, 0, 0, ws.width(), ws.height(), Qt::XorROP, true); return ws; } }//end namespace CGAL #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/polygon_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/polygon_Window_stre0000644000175000017500000000553611344301501031337 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/polygon_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Wieger Wesselink, Geert-Jan Giezeman, Matthias Baesken // Window_stream I/O operators // =========================== // Polygon_2 // --------- #ifdef CGAL_POLYGON_2_H #ifndef CGAL_WINDOW_STREAM_POLYGON_2_H #define CGAL_WINDOW_STREAM_POLYGON_2_H #if defined(CGAL_USE_CGAL_WINDOW) #include #endif CGAL_BEGIN_NAMESPACE template Window_stream& operator<<(Window_stream& ws, const Polygon_2 &polygon) { typedef typename Polygon_2::Edge_const_circulator EI; typedef typename Traits::Point_2 Point_2; EI e = polygon.edges_circulator(); #if defined(CGAL_USE_CGAL_WINDOW) CGAL::color cl = ws.get_fill_color(); if (cl != CGAL::invisible) { std::list LP; if (e != NULL) { EI end = e; do { Point_2 p = (*e).source(); double x = CGAL::to_double(p.x()); double y = CGAL::to_double(p.y()); LP.push_back(CGAL::window_point(x,y)); ++e; } while (e != end); } ws.draw_filled_polygon(LP,cl); } #else leda_color cl = ws.get_fill_color(); if (cl != leda_invisible) { // draw filled polygon ... leda_list LP; if (e != NULL) { EI end = e; do { Point_2 p = (*e).source(); double x = CGAL::to_double(p.x()); double y = CGAL::to_double(p.y()); LP.append(leda_point(x,y)); ++e; } while (e != end); } ws.draw_filled_polygon(LP,cl); } #endif else { if (e != NULL) { EI end = e; do { ws << *e; ws << (*e).source(); ++e; } while (e != end); } } return ws; } CGAL_END_NAMESPACE #endif // CGAL_WINDOW_STREAM_POLYGON_2_H #endif // CGAL_POLYGON_2_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_window_redefine.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_window_redefin0000644000175000017500000000701711344301501031251 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_window_redefine.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Matthias Baesken #include #if defined(CGAL_USE_CGAL_WINDOW) #define leda_color CGAL::color #define leda_string std::string #define leda_panel CGAL::panel #define leda_window CGAL::window #define leda_invisible CGAL::invisible #define leda_white CGAL::white #define leda_black CGAL::black #define leda_red CGAL::red #define leda_green CGAL::green #define leda_blue CGAL::blue #define leda_yellow CGAL::yellow #define leda_violet CGAL::violet #define leda_orange CGAL::orange #define leda_cyan CGAL::cyan #define leda_brown CGAL::brown #define leda_pink CGAL::pink #define leda_green2 CGAL::green2 #define leda_blue2 CGAL::blue2 #define leda_grey1 CGAL::grey1 #define leda_grey2 CGAL::grey2 #define leda_grey3 CGAL::grey3 #define leda_ivory CGAL::ivory #define leda_line_style CGAL::line_style #define leda_solid CGAL::solid #define leda_dashed CGAL::dashed #define leda_dotted CGAL::dotted #define leda_point_style CGAL::point_style #define leda_pixel_point CGAL::pixel_point #define leda_cross_point CGAL::cross_point #define leda_plus_point CGAL::plus_point #define leda_circle_point CGAL::circle_point #define leda_disc_point CGAL::disc_point #define leda_rect_point CGAL::rect_point #define leda_box_point CGAL::box_point #define leda_text_mode CGAL::text_mode #define leda_transparent CGAL::transparent #define leda_opaque CGAL::opaque #define leda_drawing_mode CGAL::drawing_mode #define leda_src_mode CGAL::src_mode #define leda_xor_mode CGAL::xor_mode #define leda_or_mode CGAL::or_mode #define leda_and_mode CGAL::and_mode #define grid_style CGAL::grid_style #define invisible_grid CGAL::invisible_grid #define point_grid CGAL::point_grid #define line_grid CGAL::line_grid // events #define key_press_event CGAL::key_press_event #define key_release_event CGAL::key_release_event #define button_press_event CGAL::button_press_event #define button_release_event CGAL::button_release_event #define panel_press_event CGAL::panel_press_event #define configure_event CGAL::configure_event #define exposure_event CGAL::exposure_event #define motion_event CGAL::motion_event #define destroy_event CGAL::destroy_event #define timer_event CGAL::timer_event #define no_event CGAL::no_event #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Conic_arc_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Conic_arc0000644000175000017500000000630411344301501031145 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Conic_arc_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Efi Fogel #ifndef CGAL_QT_WIDGET_CONIC_ARC_2_H #define CGAL_QT_WIDGET_CONIC_ARC_2_H #include #include CGAL_BEGIN_NAMESPACE template Qt_widget & operator<< (Qt_widget & ws, const Conic_arc_2& cv) { typedef typename Alg_kernel::FT CoNT; typedef typename Conic_arc_2::Point_2 Point_2; // Get the co-ordinates of the curve's source and target. double sx = CGAL::to_double(cv.source().x()), sy = CGAL::to_double(cv.source().y()), tx = CGAL::to_double(cv.target().x()), ty = CGAL::to_double(cv.target().y()); if (cv.is_segment()) { // The curve is a segment - simply draw it. ws.get_painter().drawLine(ws.x_pixel(sx), ws.y_pixel(sy), ws.x_pixel(tx), ws.y_pixel(ty)); return (ws); } // Draw a non-linear conic arc. if (cv.is_x_monotone()) { // If the curve is monotone, than its source and its target has the // extreme x co-ordinates on this curve. bool is_source_left = (sx < tx); int x_min = is_source_left ? ws.x_pixel(sx) : ws.x_pixel(tx); int x_max = is_source_left ? ws.x_pixel(tx) : ws.x_pixel(sx); double prev_y = is_source_left ? sy : ty; double end_x = is_source_left ? tx : sx; double end_y = is_source_left ? ty : sy; double curr_x, curr_y; int x; Point_2 ps[2]; Point_2 q; int nps; ws.get_painter().moveTo(x_min, ws.y_pixel(prev_y)); for (x = x_min + 1; x < x_max; x++) { curr_x = ws.x_real(x); q = Point_2 (CoNT(curr_x), CoNT(0)); nps = cv.get_points_at_x (q, ps); if (nps == 1) { curr_y = CGAL::to_double(ps[0].y()); ws.get_painter().lineTo(x, ws.y_pixel(curr_y)); } } ws.get_painter().lineTo(ws.x_pixel(end_x), ws.y_pixel(end_y)); return (ws); } else { // Break the arc into x-monotone sub-curves and draw each one separately. Arr_conic_traits_2 traits; std::list > x_mon_curves; typename std::list >::iterator xit; traits.curve_make_x_monotone (cv, std::back_inserter (x_mon_curves)); for (xit = x_mon_curves.begin(); xit != x_mon_curves.end(); xit++) ws << *xit; } return (ws); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Conic_2_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Conic_2_Window_stre0000644000175000017500000001013011344301501031106 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Conic_2_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Bernd Gaertner, Sven Schoenherr // Each of the following operators is individually // protected against multiple inclusion. // Window_stream I/O operators // =========================== // Conic_2 // ------- #ifdef CGAL_CONIC_2_H #ifndef CGAL_IO_WINDOW_STREAM_CONIC_2 #define CGAL_IO_WINDOW_STREAM_CONIC_2 template< class R > CGAL::Window_stream& operator << ( CGAL::Window_stream& ws, const CGAL::Conic_2& c) { // length of a pixel in window-coordinates double pixel = 1/ws.scale(); // pixel dimensions of window int width = (int)((ws.xmax() - ws.xmin()) * ws.scale()) + 1, height = (int)((ws.ymax() - ws.ymin()) * ws.scale()) + 1, dim = std::max( width, height); // pixel coordinates, stored for faster output double *X = new double [2*dim]; double *Y = new double [2*dim]; // actual number of pixels to be drawn int pixels; // conic coordinates double r = CGAL::to_double (c.r()), s = CGAL::to_double (c.s()), t = CGAL::to_double (c.t()), u = CGAL::to_double (c.u()), v = CGAL::to_double (c.v()), w = CGAL::to_double (c.w()); // Phase I (drawing in x-direction) pixels = 0; // solve conic equation for y if (s != 0.0) for (double x = ws.xmin(); x <= ws.xmax(); x+=pixel) { double discr = (t*t-4.0*r*s)*(x*x) + (2.0*t*v-4.0*s*u)*x + v*v - 4.0*s*w; if (discr >= 0.0) { double y1 = (-t*x - v - CGAL::sqrt(discr))/(2.0*s); double y2 = (-t*x - v + CGAL::sqrt(discr))/(2.0*s); X[pixels] = x; Y[pixels++] = y1; X[pixels] = x; Y[pixels++] = y2; } } else for (double x = ws.xmin(); x <= ws.xmax(); x+=pixel) { double denom = t*x + v; if (denom != 0.0) { double y = -(r*x*x + u*x + w)/denom; X[pixels] = x; Y[pixels++] = y; } } ws.draw_pixels (pixels, X, Y); // Phase II (drawing in y-direction) pixels = 0; // solve conic equation for x if (r != 0.0) for (double y = ws.ymin(); y <= ws.ymax(); y+=pixel) { double discr = (t*t-4.0*r*s)*(y*y) + (2.0*t*u-4.0*r*v)*y + u*u - 4.0*r*w; if (discr >= 0.0) { double x1 = (-t*y - u - CGAL::sqrt(discr))/(2.0*r); double x2 = (-t*y - u + CGAL::sqrt(discr))/(2.0*r); X[pixels] = x1; Y[pixels++] = y; X[pixels] = x2; Y[pixels++] = y; } } else for (double y = ws.ymin(); y <= ws.ymax(); y+=pixel) { double denom = t*y + u; if (denom != 0.0) { double x = -(s*y*y + v*y + w)/denom; X[pixels] = x; Y[pixels++] = y; } } ws.draw_pixels (pixels, X, Y); // free memory delete[] Y; delete[] X; return( ws); } #endif // CGAL_IO_WINDOW_STREAM_CONIC_2 #endif // CGAL_CONIC_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_OpenGL.h0000644000175000017500000000616111344301501030640 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_OpenGL.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_QT_WIDGET_OPENGL_H #define CGAL_QT_WIDGET_OPENGL_H // #include // #include #include #include #include #include #include #include #include #include namespace CGAL { class Qt_widget_OpenGL : public QGLWidget { Q_OBJECT typedef CGAL::OGL::OGL_base_object::Affine_3 Affine_3; typedef CGAL::OGL::OGL_base_object::Double_vector Double_vector; // typedef CGAL::Simple_cartesian::Aff_transformation_3 Affine_3; protected: enum MenuEntriesS2 { ROTATE, SCALE, TRANSLATE, TRANS_Z, RESET_CONTROL, PERSP, FULLSCREEN, QUIT }; CGAL::OGL::OGL_base_object* object_; int window_width; // Breite und int window_height; // Hoehe des Fensters int window_radius; // min(width,height) / 2 bool perspective; bool fullscreen; int mouse_x, mouse_y; // Mauskoordinaten linker button int interaction; // type of interaction in motion fct. int motion_mode; // Bewegen der Maus bei Mouse1 gedrueckt int submenu1, submenu2; long double dx; // Translation long double dy; // Translation long double dz; // Translation in Z long double s; // Skalierung long double init_s; Affine_3 rotation; // Rotation long double factor_s; // Umrechnungsfaktor fuer Skalierung long double factor_w; long double factor_d; QPopupMenu* main; QPopupMenu* sub1; QPopupMenu* sub2; QPopupMenu* sub3; protected: Affine_3 virtual_sphere_transformation( double old_x, double old_y, double new_x, double new_y); protected slots: void slotControlMenu(int index); void slotRenderMenu(int index); void slotOptionsMenu(int index); void slotFullscreen(); void slotPerspective(); protected: virtual void mouseMoveEvent( QMouseEvent* event); virtual void mousePressEvent( QMouseEvent* event); virtual void mouseReleaseEvent( QMouseEvent* event); public: Qt_widget_OpenGL(int width, int height, double scale); virtual void paintGL(); virtual void initializeGL(); virtual void resizeGL(int w, int h); }; } // namespace CGAL #endif // CGAL_QT_WIDGET_OPENGL_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Postscript_file_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Postscript_file_0000644000175000017500000000255611344301501031227 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_Postscript_file_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_PM_POSTSCRIPT_FILE_STREAM_H #define CGAL_IO_PM_POSTSCRIPT_FILE_STREAM_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE template Postscript_file_stream & operator << (Postscript_file_stream & ps, const Planar_map_2 & pm) { Pm_drawer< Planar_map_2 , Postscript_file_stream> drawer(ps); draw_pm(pm, drawer, ps); return ps; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Hyperbola_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Hyperbola0000644000175000017500000000245311344301501031213 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Hyperbola_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_QT_WIDGET_HYPERBOLA_2_H #define CGAL_QT_WIDGET_HYPERBOLA_2_H #if defined CGAL_USE_QT #include #include #include CGAL_BEGIN_NAMESPACE template< class Gt > inline Qt_widget& operator<<(Qt_widget& s, const Hyperbola_2< Gt > &H) { H.draw_qt(s); return s; } template< class Gt > inline Qt_widget& operator<<(Qt_widget &s, Hyperbola_ray_2 &H) { H.draw_qt(s); return s; } CGAL_END_NAMESPACE #endif #endif // CGAL_QT_WIDGET_HYPERBOLA_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/leda_ps_file.h0000644000175000017500000000237211344301501030113 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/leda_ps_file.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #include #include CGAL_BEGIN_NAMESPACE typedef Postscript_file_stream ps_file; CGAL_END_NAMESPACE mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_file_scanner.h0000644000175000017500000000576211344301501030747 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_file_scanner.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_ARR_FILE_SCANNER_H #define CGAL_IO_ARR_FILE_SCANNER_H 1 #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_KNOWN_BIT_SIZE_INTEGERS_H #include #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif #ifndef CGAL_IO_BINARY_FILE_IO_H #include #endif // CGAL_IO_BINARY_FILE_IO_H //#ifndef CGAL_IO_FILE_HEADER_PM_H //#include //#endif // CGAL_IO_FILE_HEADER_PM_H #ifndef CGAL_IO_PM_FILE_SCANNER_H #include #endif // CGAL_IO_PM_FILE_SCANNER_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE template class Arr_file_scanner : public Pm_file_scanner { public: typedef Pm_file_scanner Base; typedef typename Arrangement::Curve_node Curve_node; typedef typename Arrangement::Subcurve_node Subcurve_node; typedef typename Arrangement::Edge_node Edge_node; typedef typename Arrangement::Traits Traits; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef typename Traits::Curve Curve; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::skip_comment; using Base::in; #endif Arr_file_scanner(std::istream& in) : Pm_file_scanner(in) {} Arr_file_scanner(std::istream& in, const File_header& h) : Pm_file_scanner(in, h) {} void scan_Curve_node(Curve_node* cn){ skip_comment(); // providing default reading function. Curve curve; in() >> curve; cn->set_curve(curve); } void scan_Subcurve_node(Subcurve_node* scn){ skip_comment(); // providing default reading function. X_curve curve; in() >> curve; scn->set_x_monotone_curve(curve); } void scan_Edge_node(Edge_node* en){ skip_comment(); // providing default reading function. X_curve curve; in() >> curve; en->set_x_monotone_curve(curve); } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_SCANNER_PM_H // // EOF // ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_VRML_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_VRML_2.0000644000175000017500000000452611344301501030674 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_VRML_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_WRITER_VRML_2_H #define CGAL_IO_FILE_WRITER_VRML_2_H 1 #ifndef CGAL_BASIC_H #include #endif // CGAL_BASIC_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif CGAL_BEGIN_NAMESPACE class File_writer_VRML_2 { std::ostream* m_out; std::size_t m_facets; public: File_writer_VRML_2() {} std::ostream& out() const { return *m_out; } void write_header( std::ostream& o, std::size_t vertices, std::size_t halfedges, std::size_t facets); void write_footer() const; void write_vertex( const double& x, const double& y, const double& z) { out() << " " << x << ' ' << y << ' ' << z << ',' << '\n'; } void write_facet_header() const; void write_facet_begin( std::size_t) { out() << " "; } void write_facet_vertex_index( std::size_t idx) { out() << idx << ',';} void write_facet_end() { out() << "-1,\n"; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_WRITER_VRML_2_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/io_tags.h0000644000175000017500000000242211344301501027126 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/io_tags.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_IO_TAGS_H #define CGAL_IO_TAGS_H CGAL_BEGIN_NAMESPACE struct io_Read_write{}; struct io_Extract_insert{}; struct io_Operator{}; CGAL_END_NAMESPACE #endif // CGAL_IO_TAGS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_inventor.h0000644000175000017500000000276111344301501030567 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_inventor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_PRINT_INVENTOR_H #define CGAL_IO_PRINT_INVENTOR_H 1 #include CGAL_BEGIN_NAMESPACE template void print_polyhedron_inventor( std::ostream& out, const Polyhedron& P) { Inventor_ostream os( out); os << P; } // Deprecated global functions, replaced with functions above template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void print_inventor( std::ostream& out, const Polyhedron_3& P) { Inventor_ostream os( out); os << P; } CGAL_END_NAMESPACE #endif // CGAL_IO_PRINT_INVENTOR_H // // EOF // ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_bounding_box_base_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_bounding_box_bas0000644000175000017500000000243111344301501031211 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_bounding_box_base_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_IO_PM_BOUNDING_BOX_BASE_WINDOW_STREAM_H #define CGAL_IO_PM_BOUNDING_BOX_BASE_WINDOW_STREAM_H #ifndef CGAL_PM_BOUNDING_BOX_BASE_H #include #endif #ifndef CGAL_LEDA_WINDOW_H #include #endif CGAL_BEGIN_NAMESPACE template inline Window_stream& operator<<(Window_stream& os, const Pm_bounding_box_base &b) {} CGAL_END_NAMESPACE #endif // CGAL_IO_PM_BOUNDING_BOX_BASE_WINDOW_STREAM_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/alpha_shapes_2_window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/alpha_shapes_2_wind0000644000175000017500000001205411344301501031147 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/alpha_shapes_2_window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifdef CGAL_ALPHA_WINDOW_STREAM //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- template < class Dt > Window_stream& Alpha_shape_2
    ::op_window(Window_stream& W) const { typedef typename Alpha_shape_2
    ::Interval_edge_map Interval_edge_map; typename Interval_edge_map::const_iterator edge_alpha_it; const typename Alpha_shape_2
    ::Interval3* pInterval; if (get_mode() == Alpha_shape_2
    ::REGULARIZED) { // it is much faster looking at the sorted intervals // than looking at all sorted faces // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; CGAL_triangulation_assertion(pInterval->second != Infinity); // since this happens only for convex hull of dimension 1 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == Alpha_shape_2
    ::REGULAR)); // if we used Edelsbrunner and Muecke's definition // regular means incident to a higher-dimensional face // thus we would write to many vertices W << segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second); // to debug the edge descrition... // W << Segment((*edge_alpha_it).second.first->vertex(0)->point(), // (*edge_alpha_it).second.first->vertex(1)->point()); // W << Segment((*edge_alpha_it).second.first->vertex(1)->point(), // (*edge_alpha_it).second.first->vertex(2)->point()); // W << Segment((*edge_alpha_it).second.first->vertex(2)->point(), // (*edge_alpha_it).second.first->vertex(0)->point()); } } } else { // get_mode() == GENERAL // draw the edges for (edge_alpha_it = _interval_edge_map.begin(); edge_alpha_it != _interval_edge_map.end() && (*edge_alpha_it).first.first < get_alpha(); ++edge_alpha_it) { pInterval = &(*edge_alpha_it).first; if (pInterval->first == UNDEFINED) { CGAL_triangulation_assertion(pInterval->second != Infinity); // since this happens only for convex hull of dimension 1 // thus singular if(pInterval->second < get_alpha() && (pInterval->third >= get_alpha() || pInterval->third == Infinity)) { // alpha must be larger than the mid boundary // and alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == Alpha_shape_2
    ::REGULAR)); W << segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second); } } else { if(pInterval->third >= get_alpha() || pInterval->third == Infinity) { // if alpha is smaller than the upper boundary // which might be infinity // visualize the boundary CGAL_triangulation_assertion(((classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == Alpha_shape_2
    ::REGULAR) || (classify((*edge_alpha_it).second.first, (*edge_alpha_it).second.second) == Alpha_shape_2
    ::SINGULAR))); W << segment((*edge_alpha_it).second.first, (*edge_alpha_it).second.second); } } } } return W; } //------------------------------------------------------------------- template < class Dt > Window_stream& operator<<(Window_stream& W, const Alpha_shape_2
    & As) { return As.op_window(W); } //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif//CGAL_ALPHA_WINDOW_STREAM ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_iostream_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_iost0000644000175000017500000000327411344301501031272 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_iostream_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_NEF_POLYHEDRON_IOSTREAM_3_H #define CGAL_NEF_POLYHEDRON_IOSTREAM_3_H #include #include CGAL_BEGIN_NAMESPACE template std::ostream& operator<< (std::ostream& os, Nef_polyhedron_3& NP) { typedef typename Nef_polyhedron_3::SNC_structure SNC_structure; CGAL::SNC_io_parser O(os, NP.snc(),true); O.print(); return os; } template std::istream& operator>> (std::istream& is, Nef_polyhedron_3& NP) { typedef typename Nef_polyhedron_3::SNC_structure SNC_structure; CGAL::SNC_io_parser I(is, NP.snc()); I.read(); NP.pl()->initialize(&NP.snc()); return is; } CGAL_END_NAMESPACE #endif //CGAL_NEF_POLYHEDRON_IOSTREAM_3_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_geomview_ostream_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_geomv0000644000175000017500000000615011344301501031272 0ustar debiandebian// Copyright (c) 2000 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_geomview_ostream_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_IO_TRIANGULATION_GEOMVIEW_OSTREAM_3_H #define CGAL_IO_TRIANGULATION_GEOMVIEW_OSTREAM_3_H #include #include // TODO : // - Check the correctness when dimension < 3. // - Use the stream color instead of built-in constant/random. // - If interfaces were more similar, we could think of sharing 2d and 3d ? CGAL_BEGIN_NAMESPACE // This one is to show the edges of a 3D triangulation. template < class GT, class TDS > void show_triangulation_edges(Geomview_stream &gv, const Triangulation_3 &T) { // Header. gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("triangulationedge") << " {appearance {}{ SKEL \n" << T.number_of_vertices() << T.number_of_finite_edges() << "\n"; // Finite vertices coordinates. std::map::Vertex_handle, int> V; int inum = 0; for( typename Triangulation_3::Finite_vertices_iterator vit = T.finite_vertices_begin(); vit != T.finite_vertices_end(); ++vit) { V[vit] = inum++; gv << vit->point() << "\n"; } // Finite edges indices. for( typename Triangulation_3::Finite_edges_iterator eit = T.finite_edges_begin(); eit != T.finite_edges_end(); ++eit) { gv << 2 << V[(*eit).first->vertex((*eit).second)] << V[(*eit).first->vertex((*eit).third)] << "\n"; // without color. // << 4 << drand48() << drand48() << drand48() << 1.0; // random color. } } template < class GT, class TDS > Geomview_stream& operator<<( Geomview_stream &gv, const Triangulation_3 &T) { if (gv.get_wired()) { // We draw the edges. bool ascii_bak = gv.get_ascii_mode(); bool raw_bak = gv.set_raw(true); show_triangulation_edges(gv, T); // Footer. gv << "}})"; gv.set_raw(raw_bak); gv.set_ascii_mode(ascii_bak); } else { // We draw the facets. std::vector triangles; for (typename Triangulation_3::Finite_facets_iterator fit = T.finite_facets_begin(); fit != T.finite_facets_end(); ++fit) triangles.push_back(T.triangle(*fit)); gv.draw_triangles(triangles.begin(), triangles.end()); } return gv; } CGAL_END_NAMESPACE #endif // CGAL_IO_TRIANGULATION_GEOMVIEW_OSTREAM_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/draw_pm.h0000644000175000017500000000260111344301501027131 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/draw_pm.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_DRAW_PM_H #define CGAL_IO_DRAW_PM_H #ifndef CGAL_BASIC_H #include #endif //#ifndef CGAL_PLANAR_MAP_2_H //#include //#endif #ifndef CGAL_INVERSE_INDEX_H #include #endif #include CGAL_BEGIN_NAMESPACE template void draw_pm(const PM& pm, Drawer& drawer, Window& w) { drawer.draw_faces(pm.faces_begin(), pm.faces_end()); drawer.draw_halfedges(pm.halfedges_begin(), pm.halfedges_end()); drawer.draw_vertices(pm.vertices_begin(), pm.vertices_end()); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/alpha_shape_geomview_ostream_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/alpha_shape_geomvie0000644000175000017500000001120611344301501031233 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/alpha_shape_geomview_ostream_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_IO_ALPHA_SHAPE_GEOMVIEW_OSTREAM_3_H #define CGAL_IO_ALPHA_SHAPE_GEOMVIEW_OSTREAM_3_H #include #include // TODO : // - Check the correctness when dimension < 3. // - Use the stream color instead of built-in constant/random. // - If interfaces were more similar, we could think of sharing 2d and 3d ? //------------------------------------------------------------------- CGAL_BEGIN_NAMESPACE //------------------------------------------------------------------- // This one is to show the edges of a 3D triangulation. // template < class GT, class TDS > // void // show_triangulation_edges(Geomview_stream &gv, // const Alpha_shape_3 &T) // { // // Header. // gv.set_ascii_mode(); // gv << "(geometry " << gv.get_new_id("triangulationedge") // << " {appearance {}{ SKEL \n" // << T.number_of_vertices() << T.number_of_finite_edges() << "\n"; // // Finite vertices coordinates. // std::map::Vertex_handle, int> V; // int inum = 0; // for( Alpha_shape_3::Vertex_iterator // vit = T.finite_vertices_begin(); vit != T.vertices_end(); ++vit) { // V[vit] = inum++; // gv << vit->point() << "\n"; // } // // Finite edges indices. // for( Alpha_shape_3::Edge_iterator // eit = T.finite_edges_begin(); eit != T.edges_end(); ++eit) { // gv << 2 // << V[(*eit).first->vertex((*eit).second)] // << V[(*eit).first->vertex((*eit).third)] // << "\n"; // without color. // // << 4 << drand48() << drand48() << drand48() << 1.0; // random color // } // } //------------------------------------------------------------------- // This one outputs the facets. template < class Dt > void Alpha_shape_3
    ::show_alpha_shape_faces(Geomview_stream &gv) const { // Finite vertices coordinates. typename Alpha_shape_3
    ::Alpha_shape_vertices_iterator Vlist_it, Vlist_begin = Alpha_shape_vertices_begin(), Vlist_end = Alpha_shape_vertices_end(); std::map::Vertex_handle, int> V; int number_of_vertex = 0; for( Vlist_it = Vlist_begin; Vlist_it != Vlist_end; Vlist_it++) { V[*Vlist_it] = number_of_vertex++; } typename Alpha_shape_3
    ::Alpha_shape_facets_iterator Flist_it, Flist_begin = Alpha_shape_facets_begin(), Flist_end = Alpha_shape_facets_end(); std::map::Facet, int> F; int number_of_facets = 0; for( Flist_it = Flist_begin; Flist_it != Flist_end; Flist_it++) { F[*Flist_it] = number_of_facets++; } // Header. gv.set_binary_mode(); gv << "(geometry " << gv.get_new_id("alpha_shape") << " {appearance {}{ OFF BINARY\n" << number_of_vertex << number_of_facets << 0; for( Vlist_it = Vlist_begin; Vlist_it != Vlist_end; Vlist_it++) { gv << (*Vlist_it)->point(); } // Finite facets indices. for( Flist_it = Flist_begin; Flist_it != Flist_end; Flist_it++){ gv << 3; for (int i=0; i<4; i++) if (i != (*Flist_it).second) gv << V[(*Flist_it).first->vertex(i)]; gv << 0; // without color. // gv << 4 << drand48() << drand48() << drand48() << 1.0; // random color } } //------------------------------------------------------------------- template < class Dt > Geomview_stream& operator<<( Geomview_stream &gv, Alpha_shape_3
    & A) { bool ascii_bak = gv.get_ascii_mode(); bool raw_bak = gv.set_raw(true); // if (gv.get_wired()) // show_alpha_shape_edges(gv, T); // else A.show_alpha_shape_faces(gv); // Footer. gv << "}})"; gv.set_raw(raw_bak); gv.set_ascii_mode(ascii_bak); return gv; } //------------------------------------------------------------------- CGAL_END_NAMESPACE //------------------------------------------------------------------- #endif // CGAL_IO_ALPHA_SHAPE_GEOMVIEW_OSTREAM_3_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_show_mouse_coordinates.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_show_mous0000644000175000017500000000402211344301501031303 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_show_mouse_coordinates.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ursu Radu #ifndef CGAL_QT_WIDGET_SHOW_MOUSE_COORDINATES_H #define CGAL_QT_WIDGET_SHOW_MOUSE_COORDINATES_H #include #include #include #include #include namespace CGAL { class Qt_widget_show_mouse_coordinates : public Qt_widget_layer { public: Qt_widget_show_mouse_coordinates(QMainWindow &mw, QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), qmw(mw) {}; void draw(){}; void mouseMoveEvent(QMouseEvent *e) { QString s("x=%1 y=%2"); double xcoord, ycoord; widget->x_real(e->x(), xcoord); widget->y_real(e->y(), ycoord); qmw.statusBar()->message(s.arg(xcoord, -20, 'g', 15). arg(ycoord, -20,'g', 15)); }; private: void deactivating(){ qmw.statusBar()->clear(); } QMainWindow &qmw; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_SEGMENT_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header_extended_OFF.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header_extende0000644000175000017500000001226511344301501031164 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header_extended_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_HEADER_EXTENDED_OFF_H #define CGAL_IO_FILE_HEADER_EXTENDED_OFF_H 1 #ifndef CGAL_BASIC_H #include #endif #include #include CGAL_BEGIN_NAMESPACE class File_header_extended_OFF { bool m_verbose; // Print error messages if true. bool m_polyhedral_surface; int m_halfedges; bool m_triangulated; bool m_non_empty_facets; bool m_terrain; bool m_normalized_to_sphere; double m_radius; bool m_rounded; int m_rounded_bits; bool m_off_header; public: typedef File_header_extended_OFF Self; File_header_extended_OFF( bool verbose = false) : m_verbose ( verbose), m_polyhedral_surface ( false), m_halfedges ( 0), m_triangulated ( false), m_non_empty_facets ( false), m_terrain ( false), m_normalized_to_sphere ( false), m_radius ( 0.0), m_rounded ( false), m_rounded_bits ( 0), m_off_header ( true) {} // Access: bool verbose() const { return m_verbose; } bool polyhedral_surface() const { return m_polyhedral_surface; } int halfedges() const { return m_halfedges; } int size_of_halfedges() const { return m_halfedges; } bool triangulated() const { return m_triangulated; } bool non_empty_facets() const { return m_non_empty_facets; } bool terrain() const { return m_terrain; } bool normalized_to_sphere() const { return m_normalized_to_sphere; } double radius() const { return m_radius; } bool rounded() const { return m_rounded; } int rounded_bits() const { return m_rounded_bits; } bool off_header() const { return m_off_header; } // Derived predicates about the file format. bool is_OFF() const { return m_off_header; } bool is_POL() const; bool is_CBP() const; bool is_TRN() const; int is_CBPn() const; int is_TRNn() const; // The proper file suffix with respect to file format. std::string suffix() const; // The proper format name. std::string format_name() const; // Set values: void set_verbose( bool b) { m_verbose = b; } void set_polyhedral_surface( bool b) { m_polyhedral_surface = b; } void set_halfedges( int h) { m_halfedges = h; } void set_triangulated( bool b) { m_triangulated = b; } void set_non_empty_facets( bool b) { m_non_empty_facets = b; } void set_terrain( bool b) { m_terrain = b; } void set_normalized_to_sphere( bool b) { m_normalized_to_sphere = b;} void set_radius( double d) { m_radius = d; } void set_rounded( bool b) { m_rounded = b; } void set_rounded_bits( int i) { m_rounded_bits = i; } void set_off_header( bool b) { m_off_header = b; } Self& operator+=( const Self& header); // union of two headers }; // Write extended header incl. CGAL/ENDCBP keywords. std::ostream& operator<<( std::ostream& out, const File_header_extended_OFF& h); // Scan extended header. The CBP keyword must be read already. std::istream& operator>>( std::istream& in, File_header_extended_OFF& h); // istream modifier skips chars until end of line. inline std::istream& skip_until_EOL( std::istream& in) { char c; while ( in.get(c) && c != '\n') ; return in; } // istream modifier that checks for OFF comments and removes them. inline std::istream& skip_comment_OFF( std::istream& in) { char c; while( (in >> c) && c == '#') in >> skip_until_EOL; in.putback(c); return in; } CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_HEADER_EXTENDED_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/io.h0000644000175000017500000000732311344301501026115 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/io.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_IO_H #define CGAL_IO_H #include #include #include #include CGAL_BEGIN_NAMESPACE class IO { public: static int mode; enum Mode {ASCII = 0, PRETTY, BINARY}; }; IO::Mode get_mode(std::ios& i); IO::Mode set_ascii_mode(std::ios& i); IO::Mode set_binary_mode(std::ios& i); IO::Mode set_pretty_mode(std::ios& i); IO::Mode set_mode(std::ios& i, IO::Mode m); bool is_pretty(std::ios& i); bool is_ascii(std::ios& i); bool is_binary(std::ios& i); inline io_Read_write io_tag(char){ return io_Read_write(); } template < class T > inline void write(std::ostream& os, const T& t, const io_Read_write&) { os.write(static_cast(&t), sizeof(t)); } template < class T > inline void write(std::ostream& os, const T& t, const io_Operator&) { os << t; } template < class T > inline void write(std::ostream& os, const T& t, const io_Extract_insert&) { insert(os, t); } template < class T > inline void write(std::ostream& os, const T& t) { write(os, t, io_tag(t)); } template < class T > inline void read(std::istream& is, T& t, const io_Read_write&) { is.read(static_cast(&t), sizeof(t)); } template < class T > inline void read(std::istream& is, T& t, const io_Operator&) { is >> t; } template < class T > inline void read(std::istream& is, T& t, const io_Extract_insert&) { extract(is, t); } template < class T > inline void read(std::istream& is, T& t) { read(is, t, io_tag(t)); } inline std::ostream& operator<<( std::ostream& out, const Color& col) { switch(out.iword(IO::mode)) { case IO::ASCII : return out << static_cast(col.red()) << ' ' << static_cast(col.green()) << ' ' << static_cast(col.blue()); case IO::BINARY : write(out, static_cast(col.red())); write(out, static_cast(col.green())); write(out, static_cast(col.blue())); return out; default: return out << "Color(" << static_cast(col.red()) << ", " << static_cast(col.green()) << ", " << static_cast(col.blue()) << ')'; } } inline std::istream &operator>>(std::istream &is, Color& col) { int r, g, b; switch(is.iword(IO::mode)) { case IO::ASCII : is >> r >> g >> b; break; case IO::BINARY : read(is, r); read(is, g); read(is, b); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } col = Color(r,g,b); return is; } CGAL_END_NAMESPACE #endif // CGAL_IO_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_wavefront.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_wavefro0000644000175000017500000000476611344301501031274 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_wavefront.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_WRITER_WAVEFRONT_H #define CGAL_IO_FILE_WRITER_WAVEFRONT_H 1 #ifndef CGAL_IO_BINARY_FILE_IO_H #include #endif // CGAL_IO_BINARY_FILE_IO_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif CGAL_BEGIN_NAMESPACE class File_writer_wavefront { std::ostream* m_out; std::size_t m_facets; public: std::ostream& out() const { return *m_out; } void write_header( std::ostream& out, std::size_t vertices, std::size_t halfedges, std::size_t facets); void write_footer() const { out() << "\n# End of Wavefront obj format #" << std::endl; } void write_vertex( const double& x, const double& y, const double& z) { out() << "v " << x << ' ' << y << ' ' << z << '\n'; } void write_facet_header() { out() << "\n# " << m_facets << " facets\n"; out() << "# ------------------------------------------\n\n"; } void write_facet_begin( std::size_t) { out() << "f "; } void write_facet_vertex_index( std::size_t idx) { out() << ' ' << idx+1; } void write_facet_end() { out() << '\n'; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_WRITER_WAVEFRONT_H // // EOF // ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_straight_traits_2_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_straight_traits_0000644000175000017500000000635311344301501031270 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_straight_traits_2_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan // Shai Hirsch #ifndef CGAL_IO_PM_STRAIGHT_TRAITS_2_WINDOW_STREAM_H #define CGAL_IO_PM_STRAIGHT_TRAITS_2_WINDOW_STREAM_H #ifndef CGAL_PM_STRAIGHT_TRAITS_2_H #include #endif #ifndef CGAL_LEDA_WINDOW_H #include #endif CGAL_BEGIN_NAMESPACE template leda_window& operator<<(leda_window& os,const Straight_2_& cv) { typedef Straight_2_ Straight; switch(cv.current_state()) { case Straight::EMPTY: return os; case Straight::POINT: { Point_2 p; cv.current(p); return os << p; } case Straight::SEGMENT: { Segment_2 seg; cv.current(seg); return os << seg; } case Straight::RAY: { Ray_2 ray; cv.current(ray); return os << ray; } case Straight::LINE: { Line_2 line; cv.current(line); return os << line; } } CGAL_assertion_msg( cv.current_state()==Straight::EMPTY|| cv.current_state()==Straight::POINT|| cv.current_state()==Straight::SEGMENT|| cv.current_state()==Straight::RAY|| cv.current_state()==Straight::LINE, "\nUnknown type in leda_window& operator<<(leda_window& os,\ const Straight& cv)"); return os; } template leda_window& operator>>(leda_window& os,const Straight_2_& cv) { typedef Straight_2_ Straight; switch(cv.current_state()) { case Straight::EMPTY: return os; case Straight::POINT: { Point_2 p; cv.current(p); return os >> p; } case Straight::SEGMENT: { Segment_2 seg; cv.current(seg); return os >> seg; } case Straight::RAY: { Ray_2 ray; cv.current(ray); return os >> ray; } case Straight::LINE: { Line_2 line; cv.current(line); return os >> line; } } CGAL_assertion_msg( cv.get_type()==Straight::EMPTY|| cv.get_type()==Straight::POINT|| cv.get_type()==Straight::SEGMENT|| cv.get_type()==Straight::RAY|| cv.get_type()==Straight::LINE, "\nUnknown type in leda_window& operator>>(leda_window& os," << "const Straight& cv)"); return os; } template Window_stream& write( Window_stream& os, const typename Pm_straight_traits_2::X_curve& cv, const Pm_straight_traits_2& traits) { typedef Pm_straight_traits_2 Traits; typedef typename Traits::X_bounded_curve X_bounded_curve; return os << X_bounded_curve( traits.curve_source(cv), traits.curve_target(cv)); } CGAL_END_NAMESPACE #endif // CGAL_IO_PM_STRAIGHT_TRAITS_2_WINDOW_STREAM_H // EOF ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Planar_map_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Planar_map_Window_s0000644000175000017500000000365311344301501031205 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Planar_map_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_IO_PLANAR_MAP_WINDOW_STREAM_H #define CGAL_IO_PLANAR_MAP_WINDOW_STREAM_H #ifndef CGAL_LEDA_WINDOW_H #include #endif #ifndef CGAL_PLANAR_MAP_2_H #include #endif /* #ifndef CGAL_IO_PM_BOUNDING_BOX_BASE_WINDOW_STREAM_H #include #endif */ CGAL_BEGIN_NAMESPACE template Window_stream& operator<<(Window_stream& os, Planar_map_2 &m) { // os << *m.get_bounding_box(); Halfedge_iterator it = m.halfedges_begin(), end = m.halfedges_end(); while(it != end){ os << it->curve(); os << it->target()->point(); os << it->source()->point(); ++it;++it; } return os; } template Window_stream& write(Window_stream& os, Planar_map_2 &m) { // os << *m.get_bounding_box(); Halfedge_iterator it = m.halfedges_begin(), end = m.halfedges_end(); const Traits& traits=m.get_traits(); while(it != end){ write(os,it->curve(),traits); ++it;++it; } return os; } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/VRML_2_ostream.h0000644000175000017500000002444311344301501030243 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/VRML_2_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Lutz Kettner // Herve Bronnimann // Mariette Yvinec #ifndef CGAL_IO_VRML_2_OSTREAM_H #define CGAL_IO_VRML_2_OSTREAM_H #include #include CGAL_BEGIN_NAMESPACE class VRML_2_ostream { public: VRML_2_ostream() : m_os(0) {} VRML_2_ostream(std::ostream& o) : m_os(&o) { header();} ~VRML_2_ostream() { close(); } void open(std::ostream& o) { m_os = &o; header(); } void close() { if ( m_os) footer(); m_os = 0; } typedef const void* Const_void_ptr; operator Const_void_ptr () const { if ( m_os) return *m_os; return 0; } std::ostream& os() { // The behaviour if m_os == 0 could be changed to return // cerr or a file handle to /dev/null. The latter one would // mimick the behaviour that one can still use a stream with // an invalid stream, but without producing any output. CGAL_assertion( m_os); return *m_os; } private: void header() { os() << "#VRML V2.0 utf8\n" "# File written with the help of the CGAL Library\n" "#-- Begin of file header\n" "Group {\n" " children [\n" " Shape {\n" " appearance DEF A1 Appearance {\n" " material Material {\n" " diffuseColor .6 .5 .9\n" " }\n }\n" " appearance\n" " Appearance {\n" " material DEF Material Material {}\n" " }\n" " geometry NULL\n" " }\n" " #-- End of file header" << std::endl; } void footer() { os() << " #-- Begin of file footer\n" " ]\n" "}\n" "#-- End of file footer" << std::endl; } std::ostream* m_os; }; VRML_2_ostream& operator<<(VRML_2_ostream& os, const char* s) { os.os() << s; return os; } VRML_2_ostream& operator<<(VRML_2_ostream& os, const double& d) { os.os() << d; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_2_OSTREAM_H #ifdef CGAL_TETRAHEDRON_3_H #ifndef CGAL_IO_VRML_2_TETRAHEDRON_3 #define CGAL_IO_VRML_2_TETRAHEDRON_3 CGAL_BEGIN_NAMESPACE template VRML_2_ostream& operator<<(VRML_2_ostream& os, const Tetrahedron_3 &t) { const char *Indent = " "; os << " Group {\n" " children [\n" " Shape {\n" " appearance\n" " Appearance {\n" " material USE Material\n" " } #Appearance\n" " geometry\n" " IndexedFaceSet {\n" " coord Coordinate {\n" " point [ \n" << Indent << "point [\n" << Indent << " " << CGAL::to_double(t[0].x()) << " " << CGAL::to_double(t[0].y()) << " " << CGAL::to_double(t[0].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[1].x()) << " " << CGAL::to_double(t[1].y()) << " " << CGAL::to_double(t[1].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[2].x()) << " " << CGAL::to_double(t[2].y()) << " " << CGAL::to_double(t[2].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[3].x()) << " " << CGAL::to_double(t[3].y()) << " " << CGAL::to_double(t[3].z()) << " ]" "\n ]\n" " }\n" " solid FALSE\n" << Indent << "coordIndex [ 0,1,2,-1, 1,3,2,-1,\n" << Indent << " 0,2,3,-1, 0,3,1,-1 ]\n" " } #IndexedFaceSet\n" " } #Shape\n" " ] #children\n" " } #Group\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_2_TETRAHEDRON_3 #endif // CGAL_TETRAHEDRON_3_H #ifdef CGAL_POINT_3_H #ifndef CGAL_IO_VRML_2_POINT_3 #define CGAL_IO_VRML_2_POINT_3 CGAL_BEGIN_NAMESPACE template VRML_2_ostream& operator<<(VRML_2_ostream& os, const Point_3 &p) { const char *Indent = " "; os << " Group {\n" " children [\n" " Shape {\n" " appearance USE A1\n" " geometry\n" " PointSet {\n" " coord Coordinate {\n" " point [ "; os << CGAL::to_double(p.x()) << " " << CGAL::to_double(p.y()) << " " << CGAL::to_double(p.z()) << " ]\n"; os << Indent << "}\n"; os << Indent << "} # PointSet\n"; os << " } #Shape\n" " ] #children\n" " } #Group\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_2_POINT_3 #endif // CGAL_POINT_3_H #ifdef CGAL_TRIANGLE_3_H #ifndef CGAL_IO_VRML_2_TRIANGLE_3 #define CGAL_IO_VRML_2_TRIANGLE_3 CGAL_BEGIN_NAMESPACE template VRML_2_ostream& operator<<(VRML_2_ostream& os, const Triangle_3 &t) { const char *Indent = " "; os << " Group {\n" " children [\n" " Shape {\n" " appearance USE A1\n" " geometry\n" " IndexedLineSet {\n" " coord Coordinate {\n" " point [ \n"; os << Indent ; os << CGAL::to_double(t[0].x()) << " " << CGAL::to_double(t[0].y()) << " " << CGAL::to_double(t[0].z()) << ",\n"; os << Indent; os << CGAL::to_double(t[1].x()) << " " << CGAL::to_double(t[1].y()) << " " << CGAL::to_double(t[1].z()) << ",\n"; os << Indent; os << CGAL::to_double(t[2].x()) << " " << CGAL::to_double(t[2].y()) << " " << CGAL::to_double(t[2].z()) << " ]\n"; os << Indent << "}\n" << Indent << "coordIndex [ 0 1, 1 2, 2 0 -1 ]\n"; os << Indent << "} # IndexedLineSet\n"; os << " } #Shape\n" " ] #children\n" " } #Group\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_2_TRIANGLE_3 #endif // CGAL_TRIANGLE_3_H #ifdef CGAL_SEGMENT_3_H #ifndef CGAL_IO_VRML_2_SEGMENT_3 #define CGAL_IO_VRML_2_SEGMENT_3 CGAL_BEGIN_NAMESPACE template VRML_2_ostream& operator<<(VRML_2_ostream& os, const Segment_3 &s) { const char *Indent = " "; os << " Group {\n" " children [\n" " Shape {\n" " appearance USE A1\n" " geometry\n" " IndexedLineSet {\n" " coord Coordinate {\n" " point [ \n"; os << Indent << CGAL::to_double(s.source().x()); os << " " << CGAL::to_double(s.source().y()) << " " << CGAL::to_double(s.source().z()) << ",\n"; os << Indent; os << CGAL::to_double(s.target().x()) << " " << CGAL::to_double(s.target().y()) << " " << CGAL::to_double(s.target().z()) << " ]\n"; os << Indent << "}\n" << Indent << "coordIndex [ 0 1 -1 ]\n"; os << Indent << "} # IndexedLineSet\n"; os << " } #Shape\n" " ] #children\n" " } #Group\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_2_SEGMENT_3 #endif // CGAL_SEGMENT_3_H #ifdef CGAL_SPHERE_3_H #ifndef CGAL_IO_VRML_2_SPHERE_3 #define CGAL_IO_VRML_2_SPHERE_3 CGAL_BEGIN_NAMESPACE template VRML_2_ostream& operator<<(VRML_2_ostream& os, const Sphere_3 &s) { os << " Group {\n" " children [\n" " Transform {\n" " translation "; os << CGAL::to_double(s.center().x()) << " " << CGAL::to_double(s.center().y()) << " " << CGAL::to_double(s.center().z()) << "\n"; os << " children Shape {\n" " appearance USE A1\n" " geometry\n" " Sphere { " "radius "; os << ::sqrt(CGAL::to_double(s.squared_radius())) <<" }\n"; os << " } #children Shape\n" " } # Transform\n" " ] #children\n" " } #Group\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_2_SEGMENT_3 #endif // CGAL_SPHERE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_iostream.h0000644000175000017500000000330311344301501027757 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_iostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_PM_IOSTREAM_H #define CGAL_PM_IOSTREAM_H #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_PLANAR_MAP_2_H #include #endif //#ifndef CGAL_INVERSE_INDEX_H //#include //#endif #ifndef CGAL_IO_PM_FILE_WRITER_H #include #endif // CGAL_IO_PM_FILE_WRITER_H #ifndef CGAL_IO_WRITE_PM_H #include #endif // CGAL_IO_WRITE_PM_H #include CGAL_BEGIN_NAMESPACE template inline ::std::ostream & operator << (::std::ostream & o, const Planar_map_2 & pm) { Pm_file_writer< Planar_map_2 > writer(o, pm); write_pm(pm, writer, o); return o; } template inline ::std::istream & operator >> (std::istream& in, Planar_map_2 & pm) { pm.read(std::cin); return in; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_straight_exact_traits_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_straight_exact_t0000644000175000017500000000202411344301501031241 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_straight_exact_traits_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan // Shai Hirsch #ifndef CGAL_IO_PM_STRAIGHT_EXACT_TRAITS_STREAM_H #define CGAL_IO_PM_STRAIGHT_EXACT_TRAITS_STREAM_H #include #endif // CGAL_IO_PM_STRAIGHT_EXACT_TRAITS_STREAM_H // EOF mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_drawer.h0000644000175000017500000000776211344301501027435 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_drawer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_PM_DRAWER_H #define CGAL_IO_PM_DRAWER_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif CGAL_BEGIN_NAMESPACE template class Pm_drawer { public: typedef PM_ PM; typedef typename PM::Vertex_iterator Vertex_iterator; typedef typename PM::Halfedge_iterator Halfedge_iterator; typedef typename PM::Face_iterator Face_iterator; typedef typename PM::Vertex_const_iterator Vertex_const_iterator; typedef typename PM::Halfedge_const_iterator Halfedge_const_iterator; typedef typename PM::Face_const_iterator Face_const_iterator; typedef typename PM::Vertex_handle Vertex_handle; typedef typename PM::Halfedge_handle Halfedge_handle; typedef typename PM::Face_handle Face_handle; typedef typename PM::Vertex_const_handle Vertex_const_handle; typedef typename PM::Halfedge_const_handle Halfedge_const_handle; typedef typename PM::Face_const_handle Face_const_handle; typedef Window_ Window; Pm_drawer (Window& w) { m_window = &w; } Window& window() { return *m_window; } //void draw_vertex_attributes(const Point& p) {} void draw_vertex(Vertex_handle v) { window() << v->point(); } void draw_vertex(Vertex_const_handle v) { window() << v->point(); } //void draw_halfedge_attributes(const Curve& cv) {} void draw_halfedge(Halfedge_handle h) { window() << h->curve(); } void draw_halfedge(Halfedge_const_handle h) { window() << h->curve(); } void draw_face(Face_handle f) {} void draw_face(Face_const_handle f) {} void draw_vertices(Vertex_iterator Vertices_begin, Vertex_iterator Vertices_end) { for (Vertex_iterator v_iter = Vertices_begin; v_iter != Vertices_end; v_iter++) draw_vertex(v_iter); } void draw_vertices(Vertex_const_iterator Vertices_begin, Vertex_const_iterator Vertices_end) { for (Vertex_const_iterator v_iter = Vertices_begin; v_iter != Vertices_end; v_iter++) draw_vertex(v_iter); } void draw_halfedges(Halfedge_iterator Halfedges_begin, Halfedge_iterator Halfedges_end) { for (Halfedge_iterator h_iter = Halfedges_begin; h_iter != Halfedges_end; h_iter++) draw_halfedge(h_iter); } void draw_halfedges(Halfedge_const_iterator Halfedges_begin, Halfedge_const_iterator Halfedges_end) { for (Halfedge_const_iterator h_iter = Halfedges_begin; h_iter != Halfedges_end; h_iter++) draw_halfedge(h_iter); } void draw_faces(Face_iterator Faces_begin, Face_iterator Faces_end) { for (Face_iterator f_iter = Faces_begin; f_iter != Faces_end; f_iter++) draw_face(f_iter); } void draw_faces(Face_const_iterator Faces_begin, Face_const_iterator Faces_end) { for (Face_const_iterator f_iter = Faces_begin; f_iter != Faces_end; f_iter++) draw_face(f_iter); } protected: Window *m_window; }; CGAL_END_NAMESPACE #endif // CGAL_IO_PM_DRAWER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/leda_window.h0000644000175000017500000004712211344301501030003 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/leda_window.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_LEDA_WINDOW_H #define CGAL_LEDA_WINDOW_H #include #include #include #include CGAL_BEGIN_NAMESPACE // #if ( __LEDA__ < 360 ) // #define leda_window window // #define leda_color color // #endif #if ( __LEDA__ < 361 ) #define leda_black black #define leda_dotted dotted #define leda_xor_mode xor_mode #define leda_blue blue #define leda_red red #endif #if (( __LEDA__ < 362 ) || defined(NOTEBOOK)) #define leda_drawing_mode drawing_mode #endif #define Str(x) #x #define Xstr(x) Str(x) #define OP CGAL CGAL_VERSION typedef leda_window Window_stream; inline leda_window& operator<<(leda_window& w, const Color& c) { w.set_fg_color(leda_color(c.red(), c.green(), c.blue())); return w; } inline void cgalize(leda_window& w) { w.set_frame_label(Xstr(OP)); w.set_icon_label("CGAL"); w.set_line_width( 2); w.set_icon_pixrect( w.create_pixrect(cgal_logo)); } inline leda_window* create_demo_window( float w = 512.0, float h = 512.0, const char* str = "CGAL", double x_extension = 1.0) { #if __LEDA__ >= 420 leda_window* Wptr = new leda_window((int) w, (int) h); #else leda_window* Wptr = new leda_window( w, h); #endif cgalize( *Wptr); double y_extension = x_extension * h / w; Wptr->init(-x_extension, x_extension, -y_extension); Wptr->set_frame_label( str); return Wptr; } inline leda_window* create_and_display_demo_window(float w = 512.0, float h = 512.0, const char* str = "CGAL", double x_extension = 1.0) { #if __LEDA__ >= 420 leda_window* Wptr = new leda_window( (int) w, (int) h); #else leda_window* Wptr = new leda_window( w, h); #endif cgalize( *Wptr); double y_extension = x_extension * h / w; Wptr->init(-x_extension, x_extension, -y_extension); Wptr->set_frame_label( str); Wptr->display(); return Wptr; } CGAL_END_NAMESPACE #endif // CGAL_LEDA_WINDOW_H CGAL_BEGIN_NAMESPACE // Each of the following operators is individually // protected against multiple inclusion. #ifdef CGAL_POINT_2_H #ifndef CGAL_LEDA_WINDOW_POINT_2 #define CGAL_LEDA_WINDOW_POINT_2 template< class R > leda_window& operator<<(leda_window& w, const Point_2& p) { double x = CGAL::to_double(p.x()); double y = CGAL::to_double(p.y()); w.draw_point(x,y); return w; } template< class R > leda_window& operator>>(leda_window& w, Point_2& p) { typedef typename R::RT RT; leda_point l_p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if (w >> l_p) { double x = l_p.xcoord(); double y = l_p.ycoord(); w << l_p; w.set_mode( save); w.draw_point(x,y); p = Point_2( RT(x), RT(y)); } else { w.set_mode( save); } return w; } template< class R > leda_window& read(leda_window& w, Point_2& p) { typedef typename R::RT RT; leda_point l_p; if (w >> l_p) { double x = l_p.xcoord(); double y = l_p.ycoord(); p = Point_2( RT(x), RT(y)); } return w; } template void read_mouse_plus(leda_window& w, Point_2& p, int& button) { typedef typename R::RT RT; double x, y; button = w.read_mouse(x,y); w.draw_point(x,y); p = Point_2(RT(x), RT(y)); } #endif // CGAL_LEDA_WINDOW_POINT_2 #endif // CGAL_POINT_2_H #ifdef CGAL_SEGMENT_2_H #ifndef CGAL_LEDA_WINDOW_SEGMENT_2 #define CGAL_LEDA_WINDOW_SEGMENT_2 template< class R > leda_window& operator<<(leda_window& w, const Segment_2& s) { w.draw_segment(CGAL::to_double(s.source().x()), CGAL::to_double(s.source().y()), CGAL::to_double(s.target().x()), CGAL::to_double(s.target().y())); return w; } template< class R > leda_window& operator>>(leda_window& w, Segment_2& s) { typedef typename R::RT RT; leda_segment l_s; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); w.set_mode( save); w.draw_segment(x1,y1, x2, y2); s = Segment_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } else { w.set_mode( save); } return w; } template< class R > leda_window& read(leda_window& w, Segment_2& s) { typedef typename R::RT RT; leda_segment l_s; if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); s = Segment_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_LEDA_WINDOW_SEGMENT_2 #endif // CGAL_SEGMENT_2_H #ifdef CGAL_LINE_2_H #ifndef CGAL_LEDA_WINDOW_LINE_2 #define CGAL_LEDA_WINDOW_LINE_2 template< class R > leda_window& operator<<(leda_window& w, const Line_2& l) { Point_2 p1 = l.point(), p2 = p1 + l.direction().vector(); w.draw_line(CGAL::to_double(p1.x()), CGAL::to_double(p1.y()), CGAL::to_double(p2.x()), CGAL::to_double(p2.y())); return w; } template< class R > leda_window& operator>>(leda_window& w, Line_2& l) { typedef typename R::RT RT; leda_segment l_s; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); w.set_mode( save); w.draw_line(x1,y1, x2, y2); l = Line_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } else { w.set_mode( save); } return w; } template< class R > leda_window& read(leda_window& w, Line_2& l) { typedef typename R::RT RT; leda_segment l_s; if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); l = Line_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_LEDA_WINDOW_LINE_2 #endif //CGAL_LINE_2_H #ifdef CGAL_RAY_2_H #ifndef CGAL_LEDA_WINDOW_RAY_2 #define CGAL_LEDA_WINDOW_RAY_2 template< class R > leda_window& operator<<(leda_window& w, const Ray_2& r) { Point_2 p = r.point(0); Point_2 q = r.point(1); w.draw_ray(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(q.x()), CGAL::to_double(q.y())); return w; } template< class R > leda_window& operator>>(leda_window& w, Ray_2& r) { typedef typename R::RT RT; leda_segment l_s; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); w.set_mode( save); r = Ray_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); w << r; } else { w.set_mode( save); } return w; } template< class R > leda_window& read(leda_window& w, Ray_2& r) { typedef typename R::RT RT; leda_segment l_s; if ( w.read( l_s)) { double x1 = l_s.xcoord1(); double y1 = l_s.ycoord1(); double x2 = l_s.xcoord2(); double y2 = l_s.ycoord2(); r = Ray_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_LEDA_WINDOW_RAY_2 #endif //CGAL_RAY_2_H #ifdef CGAL_TRIANGLE_2_H #ifndef CGAL_LEDA_WINDOW_TRIANGLE_2 #define CGAL_LEDA_WINDOW_TRIANGLE_2 template< class R > leda_window& operator<<(leda_window& w, const Triangle_2& t) { double x0 = CGAL::to_double(t.vertex(0).x()), y0 = CGAL::to_double(t.vertex(0).y()), x1 = CGAL::to_double(t.vertex(1).x()), y1 = CGAL::to_double(t.vertex(1).y()), x2 = CGAL::to_double(t.vertex(2).x()), y2 = CGAL::to_double(t.vertex(2).y()); leda_color cl = w.get_fill_color(); if (cl != leda_invisible) { // draw filled triangle ... w.draw_filled_triangle(leda_point(x0,y0), leda_point(x1,y1), leda_point(x2,y2), cl); } w.draw_segment(x0, y0, x1, y1); w.draw_segment(x1, y1, x2, y2); w.draw_segment(x2, y2, x0, y0); return w; } template< class R > leda_window& operator>>(leda_window& w, Triangle_2& t) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second, third, p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w >> first)) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_seg( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( first.xcoord(), first.ycoord(), x, y); second = leda_point( x, y); } key = w.read_mouse_seg( second.xcoord(), second.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w << leda_segment( first, second ); w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( second.xcoord(), second.ycoord(), x, y); third = leda_point( x, y); } w << leda_segment( first, second ); w << leda_segment( second, third ); double x0 = first.xcoord(); double y0 = first.ycoord(); double x1 = second.xcoord(); double y1 = second.ycoord(); double x2 = third.xcoord(); double y2 = third.ycoord(); w.set_mode( save); leda_color cl = w.get_fill_color(); if (cl != leda_invisible) { // draw filled triangle ... w.draw_filled_triangle(leda_point(x0,y0), leda_point(x1,y1), leda_point(x2,y2), cl); } w.draw_segment(x0,y0, x1, y1); w.draw_segment(x1,y1, x2, y2); w.draw_segment(x2,y2, x0, y0); t = Triangle_2(Point_2( RT(x0), RT(y0)), Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); return w; } template< class R > leda_window& read(leda_window& w, Triangle_2& t) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second, third, p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w >> first)) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_seg( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( first.xcoord(), first.ycoord(), x, y); second = leda_point( x, y); } key = w.read_mouse_seg( second.xcoord(), second.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w << leda_segment( first, second ); w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } else { w << leda_segment( second.xcoord(), second.ycoord(), x, y); third = leda_point( x, y); } w << leda_segment( first, second ); w << leda_segment( second, third ); double x0 = first.xcoord(); double y0 = first.ycoord(); double x1 = second.xcoord(); double y1 = second.ycoord(); double x2 = third.xcoord(); double y2 = third.ycoord(); w.set_mode( save); t = Triangle_2(Point_2( RT(x0), RT(y0)), Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); return w; } #endif // CGAL_LEDA_WINDOW_TRIANGLE_2 #endif // CGAL_TRIANGLE_2_H #ifdef CGAL_CIRCLE_2_H #ifndef CGAL_LEDA_WINDOW_CIRCLE_2 #define CGAL_LEDA_WINDOW_CIRCLE_2 template< class R > leda_window& operator<<(leda_window& w, const Circle_2& c) { double cx = CGAL::to_double(c.center().x()), cy = CGAL::to_double(c.center().y()), r = CGAL::to_double(c.squared_radius()); leda_color cl = w.get_fill_color(); if (cl != leda_invisible) { // draw filled circle ... w.draw_disc(cx, cy , std::sqrt(r), cl); } w.draw_circle(cx, cy , std::sqrt(r)); return w; } template< class R > leda_window& operator>>(leda_window& w, Circle_2& c) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( p))) { w.set_mode( save); return w; } double cx = p.xcoord(); double cy = p.ycoord(); Point_2 center = Point_2( RT(cx), RT(cy)); int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_circle(cx, cy, x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } double dx = x - cx; double dy = y - cy; double sqr = dx*dx+dy*dy; w.set_mode( save); w.set_buttons( save_but); leda_color cl = w.get_fill_color(); if (cl != leda_invisible) { // draw filled circle ... w.draw_disc(cx, cy , std::sqrt(sqr), cl); } w.draw_circle(cx, cy , std::sqrt(sqr)); c = Circle_2(center, RT(sqr)); return w; } template< class R > leda_window& read(leda_window& w, Circle_2& c) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point p; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( p))) { w.set_mode( save); return w; } double cx = p.xcoord(); double cy = p.ycoord(); Point_2 center = Point_2( RT(cx), RT(cy)); int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_circle(cx, cy, x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } double dx = x - cx; double dy = y - cy; double sqr = dx*dx+dy*dy; w.set_mode( save); w.set_buttons( save_but); c = Circle_2(center, RT(sqr)); return w; } #endif // CGAL_LEDA_WINDOW_CIRCLE_2 #endif // CGAL_CIRCLE_2_H #ifdef CGAL_ISO_RECTANGLE_2_H #ifndef CGAL_LEDA_WINDOW_ISO_RECTANGLE_2 #define CGAL_LEDA_WINDOW_ISO_RECTANGLE_2 template< class R > leda_window& operator<<(leda_window& w, const Iso_rectangle_2& r) { double xmin = CGAL::to_double(r.min().x()), ymin = CGAL::to_double(r.min().y()), xmax = CGAL::to_double(r.max().x()), ymax = CGAL::to_double(r.max().y()); leda_color cl = w.get_fill_color(); if (cl != leda_invisible) { // draw filled rectangle ... w.draw_filled_rectangle(xmin, ymin, xmax, ymax, cl); } w.draw_segment(xmin, ymin, xmax, ymin); w.draw_segment(xmax, ymin, xmax, ymax); w.draw_segment(xmax, ymax, xmin, ymax); w.draw_segment(xmin, ymax, xmin, ymin); return w; } template< class R > leda_window& operator>>(leda_window& w, Iso_rectangle_2& r) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_rect( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } r = Iso_rectangle_2(Point_2( RT(first.xcoord()), RT(first.ycoord())), Point_2( RT(x), RT(y))); w.set_mode( save); leda_color cl = w.get_fill_color(); if (cl != leda_invisible) { // draw filled rectangle ... w.draw_filled_rectangle(first.xcoord(), first.ycoord(), x, y, cl); } w.draw_rectangle( first.xcoord(), first.ycoord(), x, y); w.set_buttons( save_but); return w; } template< class R > leda_window& read(leda_window& w, Iso_rectangle_2& r) { typedef typename R::RT RT; double x,y; int key = 0; #if ( __LEDA__ < 362 ) w.state = 1; #else w.set_state( 1); #endif // __LEDA__ < ... leda_point first, second; leda_drawing_mode save = w.set_mode(leda_xor_mode); if ( !( w.read( first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_rect( first.xcoord(), first.ycoord(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); #if ( __LEDA__ < 362 ) w.state = 0; #else w.set_state( 0); #endif // __LEDA__ < ... return w; } r = Iso_rectangle_2(Point_2( RT(first.xcoord()), RT(first.ycoord())), Point_2( RT(x), RT(y))); w.set_mode( save); w.set_buttons( save_but); return w; } #endif // CGAL_LEDA_WINDOW_ISO_RECTANGLE_2 #endif // CGAL_ISO_RECTANGLE_2_H #ifdef CGAL_BBOX_2_H #ifndef CGAL_LEDA_WINDOW_BBOX_2 #define CGAL_LEDA_WINDOW_BBOX_2 inline leda_window& operator<<(leda_window& w, const Bbox_2& b) { #if (__LEDA__ >= 400) leda_line_style style = w.set_line_style(leda_dotted); #else line_style style = w.set_line_style(leda_dotted); #endif double xmin = b.xmin(), ymin = b.ymin(), xmax = b.xmax(), ymax = b.ymax(); w.draw_segment(xmin, ymin, xmax, ymin); w.draw_segment(xmax, ymin, xmax, ymax); w.draw_segment(xmax, ymax, xmin, ymax); w.draw_segment(xmin, ymax, xmin, ymin); w.set_line_style(style); return w; } #endif // CGAL_LEDA_WINDOW_BBOX_2 #endif // CGAL_BBOX_2_H CGAL_END_NAMESPACE #ifndef IO_TRIANGULATION_WINDOW_STREAM_H #include #endif // IO_TRIANGULATION_WINDOW_STREAM_H #include #include #ifndef IO_POLYGON_WINDOW_STREAM_H #include #endif // IO_POLYGON_WINDOW_STREAM_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Triangula0000644000175000017500000000430311344301501031210 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_TRIANGULATION_2_H #define CGAL_QT_WIDGET_TRIANGULATION_2_H #include #include #include namespace CGAL { template class Draw_triangulation { private: const Triangulation_2& t; Qt_widget& w; public: Draw_triangulation(const Triangulation_2& _t, Qt_widget& _w) : t(_t), w(_w) {} void operator()(typename Triangulation_2::Face_handle fh) { for (int i=0; i<3; i++) if (fh < fh->neighbor(i) || t.is_infinite(fh->neighbor(i))) w << t.segment(fh,i); } }; template < class Gt, class Tds> Qt_widget& operator<<(Qt_widget& w, const Triangulation_2 &t) { if (t.dimension()<2) { t.draw_triangulation(w); return w; } typedef typename Triangulation_2::Point OpPoint; w.lock(); Draw_triangulation draw(t, w); apply_to_range(t, OpPoint(w.x_min(), w.y_max()), OpPoint(w.x_max(), w.y_min()), draw); w.unlock(); return w; } }// end namespace CGAL #endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Filtered_extended_homogeneous_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Filtered_extended_h0000644000175000017500000000351711344301501031206 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Filtered_extended_homogeneous_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef FILTERED_EXTENDED_HOMOGENEOUS_WINDOW_STREAM_H #define FILTERED_EXTENDED_HOMOGENEOUS_WINDOW_STREAM_H #ifdef CGAL_USE_LEDA #include #include CGAL_BEGIN_NAMESPACE template CGAL::Window_stream& operator<<(CGAL::Window_stream& w, const Extended_point& p) { w.draw_filled_node(CGAL::to_double(p.x()),CGAL::to_double(p.y())); return w; } template CGAL::Window_stream& operator<<(CGAL::Window_stream& w, const Extended_segment& s) { w.draw_segment(CGAL::to_double(s.source().x()), CGAL::to_double(s.source().y()), CGAL::to_double(s.target().x()), CGAL::to_double(s.target().y())); return w; } template leda_point pnt(const Extended_point& p) { return leda_point(CGAL::to_double(p.x()),CGAL::to_double(p.y())); } CGAL_END_NAMESPACE #endif // CGAL_USE_LEDA #endif // FILTERED_EXTENDED_HOMOGENEOUS_WINDOW_STREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Generic_writer.h0000644000175000017500000001415511344301501030457 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Generic_writer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_GENERIC_WRITER_H #define CGAL_IO_GENERIC_WRITER_H 1 #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_PROTECT_ITERATOR #include #define CGAL_PROTECT_ITERATOR #endif CGAL_BEGIN_NAMESPACE template class I_Generic_writer_vertex_proxy { Writer& m_writer; public: typedef typename Writer::Point Point; I_Generic_writer_vertex_proxy( Writer& w) : m_writer(w) {} void operator= ( const Point& p) { m_writer.write_vertex(p); } }; template class I_Generic_writer_vertex_iterator { Writer& m_writer; public: typedef std::output_iterator_tag iterator_category; typedef typename Writer::Point value_type; typedef std::ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef I_Generic_writer_vertex_proxy< Writer> Proxy; typedef I_Generic_writer_vertex_iterator< Writer> Self; I_Generic_writer_vertex_iterator( Writer& w) : m_writer(w) {} Self& operator++() { return *this; } Self& operator++(int) { return *this; } Proxy operator*() const { return Proxy( m_writer); } }; template class I_Generic_writer_facet_proxy { Writer& m_writer; public: I_Generic_writer_facet_proxy( Writer& w) : m_writer(w) {} void operator= ( std::size_t i) { m_writer.write_facet_index(i); } }; template class I_Generic_writer_facet_iterator { Writer& m_writer; public: typedef std::output_iterator_tag iterator_category; typedef std::size_t value_type; typedef std::ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef I_Generic_writer_facet_proxy Proxy; typedef I_Generic_writer_facet_iterator Self; I_Generic_writer_facet_iterator( Writer& w) : m_writer(w) {} Self& operator++() { return *this; } Self& operator++(int) { return *this; } Proxy operator*() const { return Proxy( m_writer); } }; // The Generic_writer class contains also the state necessary for all // its iterators. Since these iterators are of the category // output_iterator, they could not be used more than once and their // positional state can be kept in Generic_writer, which simplifies // the situation where the iterators are copied by value. template < class Writer, class Pt > class Generic_writer { Writer m_writer; std::size_t m_vertices; std::size_t m_halfedges; std::size_t m_facets; std::size_t m_vcnt; std::size_t m_fcnt; std::size_t m_icnt; public: typedef Pt Point; typedef Generic_writer< Writer, Pt> Self; typedef I_Generic_writer_vertex_iterator Vertex_iterator; typedef I_Generic_writer_facet_iterator Facet_iterator; Generic_writer( const Writer& writer, std::ostream& out, std::size_t v, std::size_t h, std::size_t f) : m_writer( writer), m_vertices(v), m_halfedges(h), m_facets(f), m_vcnt(0), m_fcnt(0), m_icnt(0) { m_writer.write_header( out, v, h, f); } const Writer& writer() const { return m_writer; } std::size_t size_of_vertices() const { return m_vertices; } std::size_t size_of_halfedges() const { return m_halfedges; } std::size_t size_of_facets() const { return m_facets; } Vertex_iterator vertices_begin() { return Vertex_iterator( *this); } Facet_iterator facets_begin() { if ( m_vcnt != m_vertices) { std::cerr << "error: Generic_writer: wrong number of " "vertices written, " << m_vcnt << " instead of " << m_vertices << "." << std::endl; m_writer.out().clear( std::ios::badbit); } m_writer.write_facet_header(); if ( m_facets == 0) m_writer.write_footer(); return Facet_iterator( *this); } // Interface used by the iterators and their proxies. void write_vertex( const Point& p) { ++m_vcnt; m_writer.write_vertex( ::CGAL::to_double( p.x()), ::CGAL::to_double( p.y()), ::CGAL::to_double( p.z())); } void write_facet_index( std::size_t i) { if ( m_fcnt > m_facets) { std::cerr << "error: Generic_writer: too many facets written." << std::endl; m_writer.out().clear( std::ios::badbit); } if ( m_icnt == 0) { m_writer.write_facet_begin( i); m_icnt = i; } else { m_writer.write_facet_vertex_index( i); m_icnt --; if ( m_icnt == 0) { m_writer.write_facet_end(); m_fcnt ++; if (m_fcnt == m_facets) m_writer.write_footer(); } } } }; CGAL_END_NAMESPACE #endif // CGAL_IO_GENERIC_WRITER_H // // EOF // ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_VRML_1_ostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_VRML_1_o0000644000175000017500000000177011344301501031001 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_VRML_1_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_POLYHEDRON_VRML_1_OSTREAM_H #define CGAL_IO_POLYHEDRON_VRML_1_OSTREAM_H 1 #include #include #endif // CGAL_IO_POLYHEDRON_VRML_1_OSTREAM_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Ostream_iterator.h0000644000175000017500000000445611344301501031035 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Ostream_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_OSTREAM_ITERATOR_H #define CGAL_IO_OSTREAM_ITERATOR_H #include CGAL_BEGIN_NAMESPACE // This proxy is for the Ostream_iterator. template class Ostream_proxy { Stream& stream; public: Ostream_proxy( Stream& s) : stream(s) {} Ostream_proxy& operator=( const T& t) { stream << t; return *this; } }; template class Ostream_iterator { Stream& stream; public: typedef T value_type; typedef T& reference; typedef const T& const_reference; typedef T* pointer; typedef const T* const_pointer; typedef std::ptrdiff_t difference_type; typedef std::output_iterator_tag iterator_category; Ostream_iterator( Stream& s) : stream(s) {} Ostream_iterator& operator++() { return *this;} Ostream_iterator operator++(int) { return *this;} Ostream_proxy operator*() const { return Ostream_proxy(stream); } }; CGAL_END_NAMESPACE #endif // CGAL_IO_OSTREAM_ITERATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Window_stream.h0000644000175000017500000000301011344301501031121 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_ARR_WINDOW_STREAM_H #define CGAL_IO_ARR_WINDOW_STREAM_H #ifndef CGAL_ARRANGEMENT_2_H #include #endif #ifndef CGAL_LEDA_WINDOW_H #include #endif #ifndef CGAL_IO_FILE_DRAWER_H #include #endif #ifndef CGAL_IO_DRAW_PM_H #include #endif CGAL_BEGIN_NAMESPACE template Window_stream& operator << (Window_stream& os, const Arrangement_2& arr) { Pm_drawer< Arrangement_2 , Window_stream> drawer(os); draw_pm(arr, drawer, os); return os; } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_OFF.h0000644000175000017500000000573211344301501027336 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_PRINT_OFF_H #define CGAL_IO_PRINT_OFF_H 1 #include #include #include #include #include CGAL_BEGIN_NAMESPACE template void print_polyhedron_with_header_OFF( std::ostream& out, const Polyhedron& P, const File_header_OFF& header) { File_writer_OFF writer( header); writer.header().set_polyhedral_surface( true); writer.header().set_halfedges( P.size_of_halfedges()); generic_print_polyhedron( out, P, writer); } template void print_polyhedron_OFF( std::ostream& out, const Polyhedron& P, bool verbose = false) { File_header_OFF header( verbose); header.set_binary( is_binary( out)); header.set_no_comments( ! is_pretty( out)); print_polyhedron_with_header_OFF( out, P, header); } // Deprecated global functions, replaced with functions above template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void print_OFF( std::ostream& out, const Polyhedron_3& P, bool verbose = false) { File_writer_OFF writer( verbose); writer.header().set_binary( is_binary( out)); writer.header().set_no_comments( ! is_pretty( out)); writer.header().set_polyhedral_surface( true); writer.header().set_halfedges( P.size_of_halfedges()); generic_print_polyhedron( out, P, writer); } template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void print_OFF( std::ostream& out, const Polyhedron_3& P, const File_header_OFF& header) { File_writer_OFF writer( header); writer.header().set_polyhedral_surface( true); writer.header().set_halfedges( P.size_of_halfedges()); generic_print_polyhedron( out, P, writer); } CGAL_END_NAMESPACE #endif // CGAL_IO_PRINT_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_file_writer.h0000644000175000017500000000541711344301501030627 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_file_writer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_ARR_FILE_WRITER_H #define CGAL_IO_ARR_FILE_WRITER_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template class Arr_file_writer : public Pm_file_writer { public: typedef Pm_file_writer Base; typedef typename Arrangement::Curve_iterator Curve_iterator; typedef typename Arrangement::Subcurve_iterator Subcurve_iterator; typedef typename Arrangement::Edge_iterator Edge_iterator; typedef typename Arrangement::Curve_const_iterator Curve_const_iterator; typedef typename Arrangement::Subcurve_const_iterator Subcurve_const_iterator; typedef typename Arrangement::Edge_const_iterator Edge_const_iterator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::out; #endif Arr_file_writer(std::ostream & o, const Arrangement & arr, bool verbose = false) : Pm_file_writer(o, arr, verbose) {} Arr_file_writer(std::ostream & o, const File_header& h) : Pm_file_writer(o, h) {} void write_curve (Curve_iterator cv){ out () << cv->curve() << std::endl; } void write_curve (Curve_const_iterator cv){ out () << cv->curve() << std::endl; } void write_subcurve (Subcurve_iterator scv){ out () << scv->x_curve() << std::endl; } void write_subcurve (Subcurve_const_iterator scv){ out () << scv->x_curve() << std::endl; } void write_edge(Edge_iterator edge){ out () << edge->x_curve() << std::endl; } void write_edge(Edge_const_iterator edge){ out () << edge->x_curve() << std::endl; } //void write_edge_nodes_end() { // out() << std::endl; // } /*void write_footer() { if (m_header.comments()) out() << "#------------------- End of Arrangement #"; out() << std::endl; } */ }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_WRITER_ARR_H // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Apollonius_site_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Apolloniu0000644000175000017500000000255611344301501031234 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Apollonius_site_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_QT_WIDGET_APOLLONIUS_SITE_2_H #define CGAL_QT_WIDGET_APOLLONIUS_SITE_2_H #ifdef CGAL_USE_QT #include #include CGAL_BEGIN_NAMESPACE template Qt_widget& operator<<(Qt_widget &qt_w, const Apollonius_site_2& wp) { typedef typename K::Circle_2 Circle_2; typedef typename K::Point_2 Point_2; Point_2 p(wp.point()); Circle_2 c(p, CGAL::square(wp.weight())); return qt_w << p << c; } CGAL_END_NAMESPACE #include #endif #endif // CGAL_QT_WIDGET_APOLLONIUS_SITE_2_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Min_circle_2_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Min_circle_2_Window0000644000175000017500000000461511344301501031075 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Min_circle_2_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner // Each of the following operators is individually // protected against multiple inclusion. // Window_stream I/O operators // =========================== // Optimisation_circle_2 // --------------------- #ifdef CGAL_OPTIMISATION_CIRCLE_2_H #ifndef CGAL_IO_WINDOW_STREAM_OPTIMISATION_CIRCLE_2 #define CGAL_IO_WINDOW_STREAM_OPTIMISATION_CIRCLE_2 template< class K_ > CGAL::Window_stream& operator << ( CGAL::Window_stream &ws, const CGAL::Optimisation_circle_2& oc) { double cx( CGAL::to_double( oc.center().x())); double cy( CGAL::to_double( oc.center().y())); double sr( CGAL::to_double( oc.squared_radius())); if ( ! CGAL_NTS is_negative( sr)) ws.draw_circle( cx, cy, CGAL::sqrt( sr)); return( ws); } #endif // CGAL_IO_WINDOW_STREAM_OPTIMISATION_CIRCLE_2 #endif // CGAL_OPTIMISATION_CIRCLE_2_H // Min_circle_2 // ------------ #ifdef CGAL_MIN_CIRCLE_2_H #ifndef CGAL_IO_WINDOW_STREAM_MIN_CIRCLE_2 #define CGAL_IO_WINDOW_STREAM_MIN_CIRCLE_2 template< class Traits_ > CGAL::Window_stream& operator << ( CGAL::Window_stream &ws, const CGAL::Min_circle_2& min_circle) { typedef typename CGAL::Min_circle_2::Point_iterator Point_iterator; Point_iterator first( min_circle.points_begin()); Point_iterator last ( min_circle.points_end()); for ( ; first != last; ++first) ws << *first; return( ws << min_circle.circle()); } #endif // CGAL_IO_WINDOW_STREAM_MIN_CIRCLE_2 #endif // CGAL_MIN_CIRCLE_2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Tee_for_output_iterator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Tee_for_output_iter0000644000175000017500000000527211344301501031307 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Tee_for_output_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_IO_TEE_FOR_OUTPUT_ITERATOR_H #define CGAL_IO_TEE_FOR_OUTPUT_ITERATOR_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class _Tee_for_output_iterator_rep; template class Tee_for_output_iterator : public Handle { typedef std::vector container; typedef typename container::iterator iterator; typedef T value_type; typedef std::output_iterator_tag iterator_category; typedef std::iterator_traits iter_traits; typedef typename iter_traits::pointer pointer; typedef typename iter_traits::reference reference; public: Tee_for_output_iterator(const OutputIterator& o) : o_it(o) { PTR = (Rep*) new _Tee_for_output_iterator_rep(); } Tee_for_output_iterator& operator=(const T& value) { ptr()->output_so_far.push_back(value); *o_it = value; return *this; } Tee_for_output_iterator& operator*() { return *this; } Tee_for_output_iterator& operator++() { ++o_it; return *this; } Tee_for_output_iterator operator++(int) { Tee_for_output_iterator tmp = *this; o_it++; return tmp; } iterator output_so_far_begin() { return ptr()->output_so_far.begin(); } iterator output_so_far_end() { return ptr()->output_so_far.end(); } OutputIterator& to_output_iterator() { return o_it; } _Tee_for_output_iterator_rep* ptr() { return (_Tee_for_output_iterator_rep*)PTR; } protected: OutputIterator o_it; }; template class _Tee_for_output_iterator_rep : public Rep { public: std::vector output_so_far; }; CGAL_END_NAMESPACE #endif // CGAL_IO_TEE_FOR_OUTPUT_ITERATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header.h0000644000175000017500000001036211344301501027672 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_FILE_HEADER_H #define CGAL_IO_FILE_HEADER_H 1 #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE // Info structure for PM file headers // =================================== class File_header { private: // Publicly accessible file informations. std::size_t n_vertices; std::size_t n_halfedges; std::size_t n_faces; bool m_verbose; // printing a format that a 'human' can read. bool m_no_comments; // no comments in output. bool m_ascii; // ascii format. int m_offset; // index offset for vertices, usually 0. // Publicly accessible but not that well supported file informations. bool m_colors; // COFF detected. // More privately used file informations to scan the file. int m_dim; // dimension for PM (will not be supported). public: typedef File_header Self; File_header(bool verbose = false, bool no_comments = false, bool ascii = true, int offset = 0, bool colors = false, int dim = 2) : n_vertices(0), n_halfedges(0), n_faces(0), m_verbose(verbose), m_no_comments(no_comments), m_ascii(ascii), m_offset(offset), m_colors(colors), m_dim(dim) {} // copy constructor File_header(const Self & file_header): n_vertices(file_header.number_of_vertices()), n_halfedges(file_header.number_of_halfedges()), n_faces(file_header.number_of_faces()), m_verbose(file_header.verbose()), m_no_comments(file_header.no_comments()), m_ascii(file_header.ascii()), m_offset(file_header.index_offset()), m_colors(file_header.has_colors()), m_dim(file_header.dimension()) {} /*Self& operator= ( const Base& base) { (Base&)(*this) = base; return *this; }*/ std::size_t number_of_vertices() const { return n_vertices; } std::size_t number_of_halfedges() const { return n_halfedges; } std::size_t number_of_faces() const { return n_faces; } bool verbose() const { return m_verbose; } bool ascii() const { return m_ascii; } // ASCII format. bool no_comments() const { return m_no_comments; } bool comments() const { return ! m_no_comments; } int index_offset() const { return m_offset; } bool has_colors() const { return m_colors; } // COFF detected. int dimension() const { return m_dim; } void set_number_of_vertices( std::size_t n) { n_vertices = n; } void set_number_of_halfedges( std::size_t n) { n_halfedges = n; } void set_number_of_faces( std::size_t n) { n_faces = n; } void set_verbose( bool b) { m_verbose = b; } void set_ascii( bool b) { m_ascii = b; } void set_no_comments( bool b) { m_no_comments = b; } void set_index_offset( int i) { m_offset = i; } void set_colors( bool b) { m_colors = b; } void set_dimension( int i) { m_dim = i; } // ---- io functions for header file ---- // istream modifier skips chars until end of line. inline std::istream& skip_until_EOL( std::istream& in) { char c; while ( in.get(c) && c != '\n') ; return in; } // istream modifier that checks for OFF comments and removes them. inline std::istream& skip_comment_OFF( std::istream& in) { char c; while( (in >> c) && c == '#') skip_until_EOL(in); in.putback(c); return in; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_HEADER_PM_H // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Color.h0000644000175000017500000000506111344301501026561 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Color.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #include #ifndef CGAL_COLOR_H #define CGAL_COLOR_H CGAL_BEGIN_NAMESPACE class Color { public: Color() {} Color(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha = 120) : _red(red), _green(green), _blue(blue), _alpha(alpha) {} unsigned char r() const {return _red;} unsigned char g() const {return _green;} unsigned char b() const {return _blue;} unsigned char red() const {return _red;} unsigned char green() const {return _green;} unsigned char blue() const {return _blue;} unsigned char alpha() const {return _alpha;} void set_alpha(unsigned char a) {_alpha=a;} bool operator==(const Color &c) const { return ( (red() == c.red()) && (green() == c.green()) && (blue() == c.blue()) ); } bool operator!=(const Color &c) const { return !( (*this) == c); } Color& operator=(const Color &c) { _red = c.red(); _green = c.green(); _blue = c.blue(); _alpha = c.alpha(); return *this; } private: unsigned char _red; unsigned char _green; unsigned char _blue; unsigned char _alpha; }; extern const Color BLACK ; extern const Color WHITE ; extern const Color GRAY ; extern const Color RED ; extern const Color GREEN ; extern const Color DEEPBLUE ; extern const Color BLUE ; extern const Color PURPLE ; extern const Color VIOLET ; extern const Color ORANGE ; extern const Color YELLOW ; CGAL_END_NAMESPACE #endif // CGAL_COLOR_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Alpha_shape_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Alpha_sha0000644000175000017500000000406411344301501031146 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Alpha_shape_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_ALPHA_SHAPE_2_H #define CGAL_QT_WIDGET_ALPHA_SHAPE_2_H #include #include namespace CGAL{ template< class Dt > Qt_widget& operator << ( Qt_widget& ws, const CGAL::Alpha_shape_2
    & As) { //return As.op_window(ws); typedef typename Alpha_shape_2
    ::Alpha_shape_edges_iterator Edges_iterator; typedef typename Alpha_shape_2
    ::Segment Segment_2; if (As.get_mode() == Alpha_shape_2
    ::REGULARIZED) { for (Edges_iterator edge_alpha_it = As.alpha_shape_edges_begin(); edge_alpha_it != As.alpha_shape_edges_end(); edge_alpha_it++) { ws << As.segment(*edge_alpha_it); }//endfor } else { for (Edges_iterator edge_alpha_it = As.alpha_shape_edges_begin(); edge_alpha_it != As.alpha_shape_edges_end(); edge_alpha_it++) { ws << As.segment(*edge_alpha_it); }//endfor } return ws; } }//end namespace CGAL #endif ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Regular_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Regular_t0000644000175000017500000000277311344301501031217 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Regular_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_REGULAR_TRIANGULATION_2_H #define CGAL_QT_WIDGET_REGULAR_TRIANGULATION_2_H #include #include namespace CGAL{ template < class Gt, class Tds > Qt_widget& operator<<(Qt_widget& w, Regular_triangulation_2 &t) { w.lock(); t.draw_triangulation(w); w.unlock(); return w; } }//end namespace CGAL #endif ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Constrained_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Constrain0000644000175000017500000000302511344301501031222 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Constrained_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_CONSTRAINED_TRIANGULATION_2_H #define CGAL_QT_WIDGET_CONSTRAINED_TRIANGULATION_2_H #include #include namespace CGAL{ template < class Gt, class Tds> Qt_widget& operator<<(Qt_widget& w, const Constrained_triangulation_2 &t) { w.lock(); t.draw_triangulation(w); w.unlock(); return w; } }//end namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Window_stream.h0000644000175000017500000000320011344301501030316 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra // use the port of the LEDA window (CGAL::window) or the "normal" LEDA window ... #if defined(CGAL_USE_CGAL_WINDOW) #include #else #include #endif #ifndef IO_TRIANGULATION_WINDOW_STREAM_H #include #endif // IO_TRIANGULATION_WINDOW_STREAM_H #include #include #ifndef IO_POLYGON_WINDOW_STREAM_H #include #endif // IO_POLYGON_WINDOW_STREAM_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_zoomrect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_zoomrect.0000644000175000017500000001270711344301501031211 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_zoomrect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_ZOOMRECT_H #define CGAL_QT_WIDGET_ZOOMRECT_H #include #include #include #include #ifndef CGAL_QT_WIDGET_ZOOMRECT_BUTTON #define CGAL_QT_WIDGET_ZOOMRECT_BUTTON Qt::LeftButton #endif namespace CGAL { class Qt_widget_zoomrect : public Qt_widget_layer { public: int first_x, first_y, x2, y2; bool widgetrepainted; bool on_first; QWidget::FocusPolicy oldpolicy; Qt_widget_zoomrect(QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), widgetrepainted(TRUE), on_first(FALSE) {}; private: QCursor oldcursor; bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void draw(){ widgetrepainted = TRUE; }; void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_ZOOMRECT_BUTTON && is_pure(e->state())) { if (!on_first) { first_x = e->x(); first_y = e->y(); on_first = true; } } }; void mouseReleaseEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_ZOOMRECT_BUTTON && is_pure(e->state())) { if((e->x() != first_x) && (e->y() != first_y)) { double x, y, xfirst2, yfirst2; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->x_real(first_x, xfirst2); widget->y_real(first_y, yfirst2); double xmin, xmax, ymin, ymax; if(x < xfirst2) {xmin = x; xmax = xfirst2;} else {xmin = xfirst2; xmax = x;}; if(y < yfirst2) {ymin = y; ymax = yfirst2;} else {ymin = yfirst2; ymax = y;}; widget->set_window(xmin, xmax, ymin, ymax); on_first = FALSE; } } } void mouseMoveEvent(QMouseEvent *e) { if(on_first) { int x = e->x(); int y = e->y(); *widget << noFill; RasterOp old = widget->rasterOp(); //save the initial raster mode QColor old_color=widget->color(); widget->setRasterOp(XorROP); widget->lock(); widget->setColor(Qt::green); if(!widgetrepainted) widget->get_painter().drawRect(first_x, first_y, x2 - first_x, y2 - first_y); widget->get_painter().drawRect(first_x, first_y, x - first_x, y - first_y); widget->unlock(); widget->setColor(old_color); widget->setRasterOp(old); //save the last coordinates to redraw the screen x2 = x; y2 = y; widgetrepainted = false; } }; void keyPressEvent(QKeyEvent *e) { switch ( e->key() ) { case Key_Escape: // key_escape if (on_first) { widget->lock(); *widget << noFill; RasterOp old = widget->rasterOp(); //save the initial raster mode QColor old_color=widget->color(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; if(!widgetrepainted) widget->get_painter().drawRect(first_x, first_y, x2 - first_x, y2 - first_y); widget->setColor(old_color); widget->setRasterOp(old); widgetrepainted = true; widget->unlock(); on_first = false; } break; }//endswitch } void leaveEvent(QEvent *) { if (on_first) { widget->lock(); *widget << noFill; RasterOp old = widget->rasterOp(); //save the initial raster mode QColor old_color=widget->color(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; if(!widgetrepainted) widget->get_painter().drawRect(first_x, first_y, x2 - first_x, y2 - first_y); widget->setColor(old_color); widget->setRasterOp(old); widgetrepainted = true; widget->unlock(); } } void activating() { oldpolicy = widget->focusPolicy(); widget->setFocusPolicy(QWidget::StrongFocus); oldcursor = widget->cursor(); widget->setCursor(crossCursor); widgetrepainted = true; }; void deactivating() { widget->setCursor(oldcursor); widget->setFocusPolicy(oldpolicy); on_first = false; widget->redraw(); }; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_ZOOMRECT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Istream_iterator.h0000644000175000017500000000540611344301501031023 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Istream_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_ISTREAM_ITERATOR_H #define CGAL_IO_ISTREAM_ITERATOR_H #include CGAL_BEGIN_NAMESPACE template class Istream_iterator { protected: Stream* stream; T value; void read() { if ( stream) { if ( *stream) { *stream >> value; if ( ! *stream) stream = 0; } else stream = 0; } } public: typedef T value_type; typedef const T& reference; typedef const T& const_reference; typedef const T* pointer; typedef const T* const_pointer; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::input_iterator_tag iterator_category; typedef Istream_iterator Self; Istream_iterator() : stream(0) {} Istream_iterator( Stream& s) : stream(&s) { read(); } bool operator==( const Self& i) const { return stream == i.stream; } bool operator!=( const Self& i) const { return stream != i.stream; } reference operator*() const { return value; } #ifdef CGAL_ARROW_OPERATOR pointer operator->() const { return &(operator*()); } #endif Self& operator++() { read(); return *this; } Self operator++(int) { Self tmp = *this; read(); return tmp; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_ISTREAM_ITERATOR_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_segment.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_segme0000644000175000017500000001200311344301501031215 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_segment.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_GET_SEGMENT_H #define CGAL_QT_WIDGET_GET_SEGMENT_H #include #include #ifndef CGAL_QT_WIDGET_GET_POINT_BUTTON #define CGAL_QT_WIDGET_GET_POINT_BUTTON Qt::LeftButton #endif namespace CGAL { template class Qt_widget_get_segment : public Qt_widget_layer { public: typedef typename R::Point_2 Point; typedef typename R::Segment_2 Segment; typedef typename R::FT FT; Qt_widget_get_segment(const QCursor c=QCursor(Qt::crossCursor), QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), cursor(c), firstpoint(false), firsttime(true){}; protected: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && !firstpoint && is_pure(e->state())) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); x1 = x; y1 = y; x2 = x; y2 = y; firstpoint = TRUE; } else if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && is_pure(e->state())){ FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); if(x1!=x || y1!=y) { widget->new_object( make_object(Segment(Point(x1,y1),Point(x,y)))); firstpoint = FALSE; } } } void keyPressEvent(QKeyEvent *e) { switch ( e->key() ) { case Key_Escape: // key_escape if(firstpoint) { firstpoint = false; RasterOp old_raster = widget->rasterOp(); QColor old_color = widget->color(); widget->lock(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; *widget << Segment(Point(x1,y1), Point(x2,y2)); widget->setRasterOp(old_raster); widget->setColor(old_color); widget->unlock(); firsttime = true; } break; }//endswitch } void leaveEvent(QEvent *e) { if(firstpoint) { RasterOp old_raster = widget->rasterOp();//save the initial raster mode QColor old_color = widget->color(); widget->lock(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; *widget << Segment(Point(x1,y1), Point(x2,y2)); widget->setRasterOp(old_raster); widget->setColor(old_color); widget->unlock(); firsttime = true; } } void mouseMoveEvent(QMouseEvent *e) { if(firstpoint) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); RasterOp old_raster = widget->rasterOp();//save the initial raster mode QColor old_color = widget->color(); widget->setRasterOp(XorROP); widget->lock(); *widget << CGAL::GREEN; if(!firsttime) *widget << Segment(Point(x1,y1),Point(x2,y2)); *widget << Segment(Point(x1,y1),Point(x,y)); widget->unlock(); widget->setRasterOp(old_raster); widget->setColor(old_color); //save the last coordinates to redraw the screen x2 = x; y2 = y; firsttime = false; } }; void activating() { oldpolicy = widget->focusPolicy(); widget->setFocusPolicy(QWidget::StrongFocus); oldcursor = widget->cursor(); widget->setCursor(cursor); }; void deactivating() { widget->setFocusPolicy(oldpolicy); widget->setCursor(oldcursor); firstpoint = false; }; QCursor oldcursor; QCursor cursor; FT x1, //the X of the first point y1; //the Y of the first point FT x2, //the old second point's X y2; //the old second point's Y bool firstpoint, //true if the user left clicked once firsttime; //true if the line is not drawn QWidget::FocusPolicy oldpolicy; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_SEGMENT_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_geomview_ostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_geomview0000644000175000017500000000521511344301501031303 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_geomview_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_POLYHEDRON_GEOMVIEW_OSTREAM_H #define CGAL_IO_POLYHEDRON_GEOMVIEW_OSTREAM_H 1 #include #include #include CGAL_BEGIN_NAMESPACE class Polyhedron_writer_geomview { Geomview_stream* out; public: Polyhedron_writer_geomview( Geomview_stream& geo) : out(&geo) {} void write_header( std::ostream&, std::size_t vertices, std::size_t, std::size_t facets) { // ignore ostream. Output goes to Geomview_stream. // Print header. out->set_ascii_mode(); *out << "(geometry " << out->get_new_id("polyhedron") << " {appearance {}{ "; out->set_binary_mode(); *out << "OFF BINARY\n" << int(vertices) << int(facets) << 0 ; } void write_footer() { *out << "}})"; out->set_ascii_mode(); } void write_vertex( const double& x, const double& y, const double& z) { *out << x << y << z; } void write_facet_header() {} void write_facet_begin( std::size_t no) { *out << int(no); } void write_facet_vertex_index( std::size_t index) { *out << int(index); } void write_facet_end() { double r = out->fcr(), g = out->fcg(), b = out->fcb(); *out << 4 << r << g << b << 1.0; } }; template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> Geomview_stream& operator<<( Geomview_stream &gv, const Polyhedron_3 &P) { Polyhedron_writer_geomview writer(gv); generic_print_polyhedron( std::cerr, P, writer); // note: cerr not used. return gv; } CGAL_END_NAMESPACE #endif // CGAL_IO_POLYHEDRON_GEOMVIEW_OSTREAM_H // // EOF // ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_handtool.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_handtool.0000644000175000017500000001172311344301501031154 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_handtool.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_HANDTOOL_H #define CGAL_QT_WIDGET_HANDTOOL_H #include #include #include #include #include #include #include #ifndef CGAL_QT_WIDGET_GET_POINT_BUTTON #define CGAL_QT_WIDGET_GET_POINT_BUTTON Qt::LeftButton #endif namespace CGAL { class Qt_widget_handtool : public Qt_widget_layer { public: Qt_widget_handtool(QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), wasrepainted(TRUE), on_first(FALSE){}; private: QCursor oldcursor; void draw(){ wasrepainted = TRUE; }; void timerEvent( QTimerEvent *) { if(on_first) widget->setCursor(QCursor( QPixmap( (const char**)holddown_xpm))); else widget->setCursor(QCursor( QPixmap( (const char**)hand_xpm))); } bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && is_pure(e->state())) { widget->setCursor(QCursor( QPixmap( (const char**)holddown_xpm))); if (!on_first){ first_x = e->x(); first_y = e->y(); on_first = TRUE; } } }; void mouseReleaseEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && is_pure(e->state())) { widget->setCursor(QCursor( QPixmap( (const char**)hand_xpm))); double x, y, xfirst2, yfirst2; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->x_real(first_x, xfirst2); widget->y_real(first_y, yfirst2); double xmin, xmax, ymin, ymax, distx, disty; if(x < xfirst2) {xmin = x; xmax = xfirst2;} else {xmin = xfirst2; xmax = x;}; if(y < yfirst2) {ymin = y; ymax = yfirst2;} else {ymin = yfirst2; ymax = y;}; distx = xfirst2 - x; disty = yfirst2 - y; widget->move_center(distx, disty); on_first = FALSE; } } void mouseMoveEvent(QMouseEvent *e) { char tempc1[130], tempc2[40]; double xcoord, ycoord; if(on_first) { int x = e->x(); int y = e->y(); //save the initial raster mode RasterOp old = widget->rasterOp(); widget->setRasterOp(XorROP); widget->lock(); *widget << CGAL::GRAY; if(!wasrepainted) { widget->x_real(x2 - first_x, xcoord); widget->x_real(y2 - first_y, ycoord); CGAL_CLIB_STD::sprintf(tempc1, " dx=%20.6f", xcoord); CGAL_CLIB_STD::sprintf(tempc2, ", dy=%20.6f", ycoord); strcat(tempc1, tempc2); widget->get_painter().drawLine(first_x, first_y, x2, y2); *widget << CGAL::GREEN; widget->get_painter().drawText(x2, y2, tempc1, 49); *widget << CGAL::GRAY; } widget->x_real(x - first_x, xcoord); widget->x_real(y - first_y, ycoord); CGAL_CLIB_STD::sprintf(tempc1, " dx=%20.6f", xcoord); CGAL_CLIB_STD::sprintf(tempc2, ", dy=%20.6f", ycoord); strcat(tempc1, tempc2); widget->get_painter().drawLine(first_x, first_y, x, y); *widget << CGAL::GREEN; widget->get_painter().drawText(x, y, tempc1, 49); widget->unlock(); widget->setRasterOp(old); //save the last coordinates to redraw the screen x2 = x; y2 = y; wasrepainted = FALSE; } }; void activating() { oldcursor = widget->cursor(); widget->setCursor(QCursor( QPixmap( (const char**)hand_xpm))); wasrepainted = TRUE; startTimer( 100 ); }; void deactivating() { widget->setCursor(oldcursor); killTimers(); }; int first_x, first_y; int x2, y2; bool wasrepainted; bool on_first; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_HANDTOOL_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_standard_toolbar.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_standard_0000644000175000017500000000441611344301501031226 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_standard_toolbar.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_STANDARD_TOOLBAR_H #define CGAL_QT_WIDGET_STANDARD_TOOLBAR_H #include #include #include #include namespace CGAL { class Qt_widget; class Qt_widget_history; class Qt_widget_standard_toolbar : public QToolBar { Q_OBJECT public: Qt_widget_standard_toolbar(Qt_widget *w, QMainWindow *parent = 0, const char* name = 0); Qt_widget_standard_toolbar(Qt_widget *w, QMainWindow *mw, QWidget* parent, bool newLine = true, const char* name = 0); ~Qt_widget_standard_toolbar() { delete button_group; } // CGAL-2.4 compatibility QToolBar* toolbar(){return this;} public slots: void back(); void forward(); void clear_history(); private slots: void zoomin(); void zoomout(); void group_clicked(int i); private: void fill_toolbar(QMainWindow *mw); private: Qt_widget *widget; Qt_widget_history *history; QButtonGroup* button_group; // this group has no parent and is destroyed manually in the // destructor QToolButton* nolayerBt; };//end class };//end namespace #endif //CGAL_QT_WIDGET_STANDARD_TOOLBAR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/scan_OFF.h0000644000175000017500000000435411344301501027125 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/scan_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_SCAN_OFF_H #define CGAL_IO_SCAN_OFF_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void scan_OFF( std::istream& in, Polyhedron_3& P, File_header_OFF& header) { // reads a polyhedron from `in' and appends it to P. // Returns also the File_header_OFF structure of the object. typedef Polyhedron_3 Polyhedron; typedef typename Polyhedron::HalfedgeDS HalfedgeDS; typedef Polyhedron_scan_OFF Scanner; Scanner scanner( in, header.verbose()); P.delegate(scanner); header = scanner.header(); } template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void scan_OFF( std::istream& in, Polyhedron_3& P, bool verbose = false) { // reads a polyhedron from `in' and appends it to P. typedef Polyhedron_3 Polyhedron; typedef typename Polyhedron::HalfedgeDS HalfedgeDS; typedef Polyhedron_scan_OFF Scanner; Scanner scanner( in, verbose); P.delegate(scanner); } CGAL_END_NAMESPACE #endif // CGAL_IO_SCAN_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Inventor_ostream.h0000644000175000017500000001074311344301501031044 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Inventor_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Lutz Kettner // Herve Bronnimann // Mariette Yvinec #ifndef CGAL_IO_INVENTOR_OSTREAM_H #define CGAL_IO_INVENTOR_OSTREAM_H #ifndef CGAL_BASIC_H #include #endif // CGAL_BASIC_H #ifndef CGAL_PROTECT_IOSTREAM_H #include #define CGAL_PROTECT_IOSTREAM_H #endif // CGAL_PROTECT_IOSTREAM_H // OpenInventor and VRML 1.0 are quite similar formats, so // output operators could be shared if they use the following // base class, which is common for both output streams. CGAL_BEGIN_NAMESPACE class Inventor_ostream_base { private: std::ostream* m_os; public: Inventor_ostream_base() : m_os(0) {} Inventor_ostream_base(std::ostream& o) : m_os(&o) {} ~Inventor_ostream_base() { close(); } void open(std::ostream& o) { m_os = &o; } void close() { if ( m_os) os() << std::endl; m_os = 0; } typedef const void* Const_void_ptr; operator Const_void_ptr () const { if ( m_os) return *m_os; return 0; } std::ostream& os() { // The behaviour if m_os == 0 could be changed to return // cerr or a file handle to /dev/null. The latter one would // mimick the behaviour that one can still use a stream with // an invalid stream, but without producing any output. CGAL_assertion( m_os); return *m_os; } }; class Inventor_ostream : public Inventor_ostream_base { public: Inventor_ostream() {} Inventor_ostream(std::ostream& o) : Inventor_ostream_base(o) { header(); } void open(std::ostream& o) { Inventor_ostream_base::open(o); header(); } private: void header() { os() << "#Inventor V2.0 ascii" << std::endl; os() << "# File written with the help of the CGAL Library" << std::endl; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_INVENTOR_OSTREAM_H #ifdef CGAL_TETRAHEDRON_3_H #ifndef CGAL_INVENTOR_TETRAHEDRON_3 #define CGAL_INVENTOR_TETRAHEDRON_3 CGAL_BEGIN_NAMESPACE template Inventor_ostream& operator<<(Inventor_ostream& os, const Tetrahedron_3 &t) { const char *Indent = " "; os.os() << "\n Separator {"; os.os() << "\n Coordinate3 { \n" << Indent << "point [\n" << Indent << " " << CGAL::to_double(t[0].x()) << " " << CGAL::to_double(t[0].y()) << " " << CGAL::to_double(t[0].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[1].x()) << " " << CGAL::to_double(t[1].y()) << " " << CGAL::to_double(t[1].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[2].x()) << " " << CGAL::to_double(t[2].y()) << " " << CGAL::to_double(t[2].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[3].x()) << " " << CGAL::to_double(t[3].y()) << " " << CGAL::to_double(t[3].z()) << " ]" << "\n } #Coordinate3" ; os.os() << "\n IndexedFaceSet {" << Indent << "coordIndex [ 0,1,2,-1, 1,3,2,-1,\n" << Indent << " 0,2,3,-1, 0,3,1,-1 ]\n" << "\n } #IndexedFaceSet" << "\n } #Separator\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_INVENTOR_TETRAHEDRON_3 #endif // CGAL_TETRAHEDRON_3_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Regular_complex_d_window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Regular_complex_d_w0000644000175000017500000002005611344301501031237 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Regular_complex_d_window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : ? #ifndef CGAL_REGULAR_COMPLEX_D_WINDOW_STREAM_H #define CGAL_REGULAR_COMPLEX_D_WINDOW_STREAM_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*{\Mtext \headerline{Visualization and conversion in low dimensions} The corresponding operations can be found in |Regular_complex_d_window_stream.h|}*/ template void d2_show(const Regular_complex_d& RC, Window_stream& W); /*{\Mfunc displays the regular complex R in window W. \precond |dim == 2|.}*/ template void d2_map(const Regular_complex_d& RC, CGAL_LEDA_SCOPE::GRAPH& G); /*{\Mfunc constructs the representation of |R| as a bidirected graph |G|. \precond |dim == 2|.}*/ template void d3_graph(const Regular_complex_d& RC, CGAL_LEDA_SCOPE::GRAPH& G); /*{\Mfunc constructs the representation of |R| as a bidirected graph |G|. \precond |dim == 3|.}*/ template leda_point to_leda_point(const Pnt_2& p) { return leda_point(CGAL::to_double(p.x()), CGAL::to_double(p.y())); } template void d2_show(const Regular_complex_d& RC, CGAL::Window_stream& W) { CGAL_assertion_msg(RC.dimension() == 2,"show_rc: dimension not 2."); W.set_line_width(1); typename Regular_complex_d::Simplex_const_iterator s; forall_rc_simplices(s,RC) { for (int v = 0; v <= RC.current_dimension(); v++) { W << to_leda_point(RC.associated_point(s,v)); for (int e = v + 1; e <= RC.current_dimension(); e++) { leda_segment seg(to_leda_point(RC.associated_point(s,v)), to_leda_point(RC.associated_point(s,e))); W << seg; } } } } template void d2_map(const Regular_complex_d& RC, CGAL_LEDA_SCOPE::GRAPH& G) { typedef typename Regular_complex_d::Simplex_const_iterator Simplex_iterator; typedef typename Regular_complex_d::Vertex_const_iterator Vertex_iterator; typedef typename Regular_complex_d::Vertex_const_handle Vertex_handle; typedef typename Regular_complex_d::Simplex_const_handle Simplex_handle; Vertex_iterator v; Simplex_iterator s; if (RC.dimension() != 2) CGAL_assertion_msg(0,"d2_map: dim must be 2."); G.clear(); Unique_hash_map node_for(nil); forall_rc_vertices(v,RC) { node_for[v] = G.new_node(to_leda_point(RC.associated_point(v))); } if (RC.current_dimension() <= 0) return; if (RC.current_dimension() == 1) { forall_rc_simplices(s,RC) { leda_node v0 = node_for[RC.vertex(s,0)]; leda_node v1 = node_for[RC.vertex(s,1)]; leda_edge e01 = G.new_edge(v0,v1); // every dart is a clockwise boundary dart leda_edge e10 = G.new_edge(v1,v0); G.set_reversal(e01,e10); } return; } int T_num(0); // number of triangles int B_num(0); // number of boundary edges forall_rc_simplices(s,RC) { ++T_num; for (int i = 0; i <= RC.current_dimension(); i++) if (RC.opposite_simplex(s,i) == Simplex_handle()) ++B_num; } int N = G.number_of_nodes(); if (((B_num + T_num) % 2 != 0) || (N != 1 + (B_num +T_num)/2)) CGAL_assertion_msg(0,"d2_map: wrong number of vertices"); leda_node_array untreated(G,true); forall_rc_simplices(s,RC) { for (int i = 0; i <= RC.current_dimension(); i++) { leda_node vi = node_for[RC.vertex(s,i)]; if ( untreated[vi] ) { untreated[vi] = false; // a vertex different from i; int j = (i + 1) % (RC.current_dimension() + 1); int k = (i + 2) % (RC.current_dimension() + 1); leda_node vj = node_for[RC.vertex(s,j)]; leda_node vk = node_for[RC.vertex(s,k)]; if ( orientation(G[vi],G[vj],G[vk])<0) { leda_swap(vk,vj); leda_swap(j,k); } leda_edge efirst = G.new_edge(vi,vk); // first edge incident to vi Simplex_handle scur = s; int jcur = j; int kcur = k; int icur = i; while ( RC.opposite_simplex(scur,jcur) != Simplex_handle() && RC.opposite_simplex(scur,jcur) != s ) { // we have not reached the end nor closed the cycle kcur = RC.index_of_opposite_vertex(scur,jcur); scur = RC.opposite_simplex(scur,jcur); for (icur = 0; icur <= 2; icur++) if (node_for[RC.vertex(scur,icur)] == vi) break; jcur = 3 - icur - kcur; vk = node_for[RC.vertex(scur,kcur)]; G.new_edge(vi,vk); } if (RC.opposite_simplex(scur,jcur) == Simplex_handle()) { /* we also need to walk in the other direction */ efirst = G.new_edge(efirst,vj,0,LEDA::before); // 0 is etype scur = s; jcur = j; kcur = k; icur = i; // restore initial situation while ( RC.opposite_simplex(scur,kcur) != Simplex_handle() ) { // we have not reached the end jcur = RC.index_of_opposite_vertex(scur,kcur); scur = RC.opposite_simplex(scur,kcur); for (icur = 0; icur <= 2; icur++) if (node_for[RC.vertex(scur,icur)] == vi) break; kcur = 3 - jcur -icur; vj = node_for[RC.vertex(scur,jcur)]; efirst = G.new_edge(efirst,vj,0,LEDA::before); //as above } //end while }// end if }// end if untreated }// end for i }// end forall if (G.number_of_edges() != (3*T_num + B_num)) CGAL_assertion_msg(0,"Regular_complex_d::d2_map: wrong number of edges"); if (!G.make_map()) CGAL_assertion_msg(0,"Regular_complex_d::d2_map:not bidirected"); } template void d3_graph(const Regular_complex_d& RC, CGAL_LEDA_SCOPE::GRAPH< typename Regular_complex_d::Point_d ,int>& G) { typedef typename Regular_complex_d::Simplex_const_iterator Simplex_iterator; typedef typename Regular_complex_d::Vertex_const_iterator Vertex_iterator; typedef typename Regular_complex_d::Vertex_const_handle Vertex_handle; Simplex_iterator s; Vertex_iterator v; CGAL_assertion_msg(RC.dimension() == 3,"d3_graph: dim must be 3."); G.clear(); CGAL_LEDA_SCOPE::node_map2 connected(G); Unique_hash_map node_for(nil); forall_rc_vertices(v,RC) { node_for[v] = G.new_node(RC.associated_point(v)); } forall_rc_simplices(s,RC) { for (int i = 0; i <= RC.current_dimension(); i++) for (int j = 0; j <= RC.current_dimension(); j++) { Vertex_handle vert1 = RC.vertex(s,i); Vertex_handle vert2 = RC.vertex(s,j); if (vert1 != Vertex_handle() && vert2 != Vertex_handle()) { leda_node v1 = node_for[vert1]; leda_node v2 = node_for[vert2]; if (v1 == nil || v2 == nil) CGAL_assertion_msg(0,"why is this shitty node not initialized?"); if (!connected(v1,v2)) { connected(v1,v2) = connected(v2,v1) = true; leda_edge e1 = G.new_edge(v1,v2); leda_edge e2 = G.new_edge(v2,v1); G.set_reversal(e1,e2); } } } } } CGAL_END_NAMESPACE #endif //CGAL_REGULAR_COMPLEX_D_WINDOW_STREAM_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_iostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_iostream0000644000175000017500000000366111344301501031307 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_iostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_POLYHEDRON_IOSTREAM_H #define CGAL_IO_POLYHEDRON_IOSTREAM_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> std::ostream& operator<<( std::ostream& out, const Polyhedron_3& P) { // writes P to `out' in PRETTY, ASCII or BINARY format // as the stream indicates. File_header_OFF header( is_binary( out), ! is_pretty( out), false); CGAL::print_polyhedron_with_header_OFF( out, P, header); return out; } template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> std::istream& operator>>(std::istream& in, Polyhedron_3& P) { // reads a polyhedron from `in' and appends it to P. CGAL::scan_OFF( in, P); return in; } CGAL_END_NAMESPACE #endif // CGAL_IO_POLYHEDRON_IOSTREAM_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Nef_S2.h0000644000175000017500000000513011344301501030563 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Nef_S2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_QT_WIDGET_NEF_S2_H #define CGAL_QT_WIDGET_NEF_S2_H #include #include CGAL_BEGIN_NAMESPACE template class Qt_widget_Nef_S2 : public Qt_widget_OpenGL { public: Qt_widget_Nef_S2(const Nef_polyhedron& N) : Qt_widget_OpenGL(300,300,1.5) { object_ = new CGAL::OGL::Unit_sphere(CGAL::OGL::NefS2_to_UnitSphere::convert(N)); resize(window_width, window_height); main = new QPopupMenu; sub1 = new QPopupMenu; sub2 = new QPopupMenu; sub3 = new QPopupMenu; sub1->insertItem("Reset", RESET_CONTROL); sub1->insertItem("Rotate", ROTATE); sub1->insertItem("Scale", SCALE); sub1->insertItem("Translate in XY", TRANSLATE); // sub1->insertItem("Translate in Z", TRANS_Z); QObject::connect(sub1, SIGNAL(activated(int)), this, SLOT(slotControlMenu(int))); sub2->insertItem("Faces", CGAL::OGL::SM_FACES); sub2->insertItem("Skeleton", CGAL::OGL::SM_SKELETON); sub2->insertItem("Triangulation",CGAL::OGL::SM_TRIANGULATION); QObject::connect(sub2, SIGNAL(activated(int)), this, SLOT(slotRenderMenu(int))); sub3->insertItem("Toggle Axes", CGAL::OGL::SM_AXES); sub3->insertItem("Toggle Unity Cube", CGAL::OGL::SM_CUBE); QObject::connect(sub3, SIGNAL(activated(int)), this, SLOT(slotOptionsMenu(int))); main->insertItem("&Control", sub1); main->insertItem("&Render", sub2); main->insertItem("&Options", sub3); // main->insertItem("&Persp/Ortho", this, SLOT(slotPerspective())); main->insertItem("&Toggle Fullscreen", this, SLOT(slotFullscreen())); main->insertItem("&Quit", qApp, SLOT(quit())); } ~Qt_widget_Nef_S2() { delete object_; } }; CGAL_END_NAMESPACE #endif // CGAL_QT_WIDGET_NEF_S2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Scanner_OFF.h0000644000175000017500000002457111344301501027575 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Scanner_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_SCANNER_OFF_H #define CGAL_IO_SCANNER_OFF_H 1 #include #include #include #include #include CGAL_BEGIN_NAMESPACE // The Facet_iterator's value type is vector // that contains the vertex indices. template class I_Scanner_OFF_vertex_iterator { public: typedef std::input_iterator_tag iterator_category; typedef Pt value_type; typedef std::ptrdiff_t difference_type; typedef const Pt* pointer; typedef const Pt& reference; private: File_scanner_OFF* m_scan; std::ptrdiff_t m_cnt; Pt m_point; void next_vertex() { CGAL_assertion( m_scan != NULL); if ( m_cnt < m_scan->size_of_vertices()) { file_scan_vertex( *m_scan, m_point); m_scan->skip_to_next_vertex( m_cnt); ++m_cnt; } else m_cnt = m_scan->size_of_vertices() + 1; } public: typedef Pt Point; typedef File_scanner_OFF Scanner; typedef I_Scanner_OFF_vertex_iterator Self; I_Scanner_OFF_vertex_iterator( int cnt) : m_scan(0), m_cnt(cnt+1) {} I_Scanner_OFF_vertex_iterator( Scanner& s, int cnt) : m_scan(&s), m_cnt(cnt) { next_vertex(); } std::ptrdiff_t count() const { return m_cnt; } bool operator==( const Self& i) const { return m_cnt == i.m_cnt; } bool operator!=( const Self& i) const { return m_cnt != i.m_cnt; } Self& operator++() { next_vertex(); return *this; } Self operator++(int) { Self tmp = *this; ++(*this); return tmp; } const Point& operator*() const { CGAL_assertion( m_scan != NULL); return m_point; } const Point* operator->() const { return & operator*(); } }; template class I_Scanner_OFF_vertex_and_normals_iterator { public: typedef Pt Point; typedef Nrm Normal; typedef File_scanner_OFF Scanner; typedef I_Scanner_OFF_vertex_and_normals_iterator Self; typedef std::input_iterator_tag iterator_category; typedef std::pair value_type; typedef std::ptrdiff_t difference_type; typedef const value_type* pointer; typedef const value_type& reference; private: File_scanner_OFF* m_scan; std::ptrdiff_t m_cnt; value_type m_current; void next() { CGAL_assertion( m_scan != NULL); if ( m_cnt < m_scan->size_of_vertices()) { file_scan_vertex( *m_scan, m_current.first); if ( m_scan->has_normals()) file_scan_normal( *m_scan, m_current.second); m_scan->skip_to_next_vertex( m_cnt); ++m_cnt; } else m_cnt = m_scan->size_of_vertices() + 1; } public: I_Scanner_OFF_vertex_and_normals_iterator( int cnt) : m_scan(0), m_cnt(cnt+1) {} I_Scanner_OFF_vertex_and_normals_iterator( Scanner& s, int cnt) : m_scan(&s), m_cnt(cnt) { next(); } std::ptrdiff_t count() const { return m_cnt; } bool operator==( const Self& i) const { return m_cnt == i.m_cnt; } bool operator!=( const Self& i) const { return m_cnt != i.m_cnt; } Self& operator++() { next(); return *this; } Self operator++(int) { Self tmp = *this; ++(*this); return tmp; } reference operator*() const { CGAL_assertion( m_scan != NULL); return m_current; } pointer operator->() const { return & operator*(); } }; class I_Scanner_OFF_facet_iterator { public: typedef std::input_iterator_tag iterator_category; typedef std::vector< Integer32> value_type; typedef std::ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; private: File_scanner_OFF* m_scan; std::ptrdiff_t m_cnt; value_type m_indices; void next_facet() { CGAL_assertion( m_scan != NULL); if ( m_cnt < m_scan->size_of_facets()) { m_indices.erase( m_indices.begin(), m_indices.end()); Integer32 no; m_scan->scan_facet( no, m_cnt); m_indices.reserve( no); Integer32 index = -1; for ( Integer32 i = 0; i < no; ++i) { m_scan->scan_facet_vertex_index( index, m_cnt); m_indices.push_back( index); } m_scan->skip_to_next_facet( m_cnt); ++ m_cnt; } else m_cnt = m_scan->size_of_facets() + 1; } public: typedef File_scanner_OFF Scanner; typedef I_Scanner_OFF_facet_iterator Self; typedef value_type::iterator iterator; I_Scanner_OFF_facet_iterator( int cnt) : m_scan(0), m_cnt(cnt+1) {} I_Scanner_OFF_facet_iterator( Scanner& s, int cnt) : m_scan(&s), m_cnt(cnt) { next_facet(); } std::ptrdiff_t count() const { return m_cnt; } bool operator==( const Self& i) const { return m_cnt == i.m_cnt; } bool operator!=( const Self& i) const { return m_cnt != i.m_cnt; } Self& operator++() { next_facet(); return *this; } Self operator++(int) { Self tmp = *this; ++(*this); return tmp; } value_type& operator*() { CGAL_assertion( m_scan != NULL); return m_indices; } const value_type& operator*() const { CGAL_assertion( m_scan != NULL); return m_indices; } value_type* operator->() { return & operator*(); } const value_type* operator->() const { return & operator*(); } }; // The distance function is implemented to work in // constant time for both iterators. template inline void distance( const I_Scanner_OFF_vertex_iterator& first, const I_Scanner_OFF_vertex_iterator& last, Distance& n) { n = Distance( last.count() - first.count()); } template inline void distance( const I_Scanner_OFF_facet_iterator& first, const I_Scanner_OFF_facet_iterator& last, Distance& n) { n = Distance( last.count() - first.count()); } template inline std::ptrdiff_t distance( const I_Scanner_OFF_vertex_iterator& first, const I_Scanner_OFF_vertex_iterator& last) { return last.count() - first.count(); } inline std::ptrdiff_t distance( const I_Scanner_OFF_facet_iterator& first, const I_Scanner_OFF_facet_iterator& last) { return last.count() - first.count(); } template class Scanner_OFF { File_scanner_OFF m_scan; public: typedef Pt Point; typedef typename Pt::Vector Normal; typedef Scanner_OFF Self; typedef I_Scanner_OFF_vertex_iterator Vertex_iterator; typedef I_Scanner_OFF_vertex_and_normals_iterator Vertex_and_normals_iterator; typedef I_Scanner_OFF_facet_iterator Facet_iterator; typedef I_Scanner_OFF_facet_iterator::iterator Index_iterator; Scanner_OFF( std::istream& in, bool verbose = false) : m_scan( in, verbose) {} Scanner_OFF( std::istream& in, const File_header_OFF& header) : m_scan( in, header) {} int size_of_vertices() const { return m_scan.size_of_vertices(); } int size_of_halfedges() const { return m_scan.size_of_halfedges();} int size_of_facets() const { return m_scan.size_of_facets(); } bool verbose() const { return m_scan.verbose(); } bool skel() const { return m_scan.skel(); } bool off() const { return m_scan.off(); } bool binary() const { return m_scan.binary(); } bool ascii() const { return m_scan.ascii(); } bool has_colors() const { return m_scan.has_colors(); } bool has_normals() const { return m_scan.has_normals(); } File_header_OFF& header() { return m_scan; } const File_header_OFF& header() const { return m_scan; } Vertex_iterator vertices_begin(){ return Vertex_iterator( m_scan,0);} Vertex_iterator vertices_end() { return Vertex_iterator( size_of_vertices()); } Facet_iterator facets_begin() { return Facet_iterator( m_scan,0); } Facet_iterator facets_end() { return Facet_iterator( size_of_facets()); } Vertex_and_normals_iterator vertices_and_normals_begin(){ return Vertex_and_normals_iterator( m_scan,0); } Vertex_and_normals_iterator vertices_and_normals_end() { return Vertex_and_normals_iterator( size_of_vertices()); } }; CGAL_END_NAMESPACE #endif // CGAL_IO_SCANNER_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header_OFF.h0000644000175000017500000001255011344301501030365 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_header_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_HEADER_OFF_H #define CGAL_IO_FILE_HEADER_OFF_H 1 #ifndef CGAL_IO_FILE_HEADER_EXTENDED_OFF_H #include #endif // CGAL_IO_FILE_HEADER_EXTENDED_OFF_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE // Info structure for OFF file headers // =================================== class File_header_OFF : public File_header_extended_OFF { private: // Publicly accessible file informations. int n_vertices; int n_facets; bool m_skel; // SKEL format instead of OFF. bool m_binary; // OFF in binary format. bool m_no_comments; // no comments in output. int m_offset; // index offset for vertices, usually 0. // Publicly accessible but not that well supported file informations. bool m_colors; // COFF detected. bool m_normals; // NOFF format stores also normals at vertices. // More privately used file informations to scan the file. bool m_tag4; // 4OFF detected. bool m_tagDim; // nOFF detected (will not be supported). int m_dim; // dimension for nOFF (will not be supported). public: typedef File_header_OFF Self; typedef File_header_extended_OFF Base; explicit File_header_OFF( bool verbose = false); File_header_OFF( bool binary, bool noc, bool skel, bool verbose = false); //File_header_OFF( int v, int h, int f, bool verbose = false); File_header_OFF( int v, int h, int f, bool binary, bool noc, bool skel, bool verbose = false); File_header_OFF( const File_header_extended_OFF& ext_header); File_header_OFF( const File_header_extended_OFF& ext_header, bool binary, bool noc, bool skel); File_header_OFF( int v, int h, int f, const File_header_extended_OFF& ext_header); File_header_OFF( int v, int h, int f, const File_header_extended_OFF& ext_header, bool binary, bool noc, bool skel); Self& operator= ( const Base& base) { (Base&)(*this) = base; return *this; } int size_of_vertices() const { return n_vertices; } int size_of_facets() const { return n_facets; } bool skel() const { return m_skel; } // SKEL format. bool off() const { return ! m_skel; } // OFF format. bool binary() const { return m_binary; } // binary format. bool ascii() const { return ! m_binary; } // ASCII format. bool no_comments() const { return m_no_comments; } bool comments() const { return ! m_no_comments; } int index_offset() const { return m_offset; } bool has_colors() const { return m_colors; } // COFF detected. bool has_normals() const { return m_normals;} // NOFF format. bool is_homogeneous() const { return m_tag4; } // 4OFF detected. // nOFF detected. (will not be supported). bool n_dimensional() const { return m_tagDim; } // dimension for nOFF (will not be supported). int dimension() const { return m_dim; } void set_vertices( int n) { n_vertices = n; } void set_facets( int n) { n_facets = n; } void set_skel( bool b) { m_skel = b; } void set_binary( bool b) { m_binary = b; } void set_no_comments( bool b) { m_no_comments = b; } void set_index_offset( int i) { m_offset = i; } void set_colors( bool b) { m_colors = b; } void set_normals( bool b) { m_normals = b;} void set_homogeneous( bool b) { m_tag4 = b; } void set_dimensional( bool b) { m_tagDim = b; } void set_dimension( int i) { m_dim = i; } Self& operator+=( const Self& header); }; // Write header. std::ostream& operator<<( std::ostream& out, const File_header_OFF& h); // Scan header. Marks streams badbit if not in SKEL format nor in OFF. std::istream& operator>>( std::istream& in, File_header_OFF& h); CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_HEADER_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Navigation_layer.h0000644000175000017500000000425211344301501030777 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Navigation_layer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_NAVIGATION_LAYER_H #define CGAL_NAVIGATION_LAYER_H #include class Navigation_layer : public CGAL::Qt_widget_layer { public: Navigation_layer(QObject *parent=0, const char* name=0) : Qt_widget_layer(parent, name){} void draw(){}; protected: void keyPressEvent(QKeyEvent *e){ const double dx = widget->x_real(10) - widget->x_real(0); const double dy = widget->y_real(10) - widget->y_real(0); const double ypage = widget->y_max() - widget->y_min(); if ( e->key() == Qt::Key_Left ){ widget->move_center(dx, 0); } else if ( e->key() == Qt::Key_Right ){ widget->move_center(-dx, 0); } else if ( e->key() == Qt::Key_Down ){ widget->move_center(0, -dy); } else if ( e->key() == Qt::Key_Up ){ widget->move_center(0, dy); } else if ( e->key() == Qt::Key_Prior ){ //PageUp widget->move_center(0, -ypage/2); } else if ( e->key() == Qt::Key_Next ){ //PageDown widget->move_center(0, ypage/2); } } void activating(){ widget->setFocusPolicy(QWidget::ClickFocus); } }; #endif././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Leda_rat.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Leda_rat.0000644000175000017500000000313711344301501031057 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Leda_rat.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Efi Fogel #ifndef CGAL_QT_WIDGET_LEDA_RAT_H #define CGAL_QT_WIDGET_LEDA_RAT_H #include #include #include #include CGAL_BEGIN_NAMESPACE Qt_widget & operator<<(Qt_widget & ws, const leda::rat_point & p) { int x = ws.x_pixel(p.xcoordD()); int y = ws.y_pixel(p.ycoordD()); // ws.get_painter().drawPoint(x,y); ws.get_painter().setBrush(ws.get_painter().pen().color()); ws.get_painter().drawEllipse(x-2, y-2, 4, 4); return ws; } Qt_widget & operator<<(Qt_widget & ws, const leda::rat_segment & seg) { ws.get_painter().drawLine(ws.x_pixel(seg.xcoord1D()), ws.y_pixel(seg.ycoord1D()), ws.x_pixel(seg.xcoord2D()), ws.y_pixel(seg.ycoord2D())); return ws; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_2_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_2_Wi0000644000175000017500000000401211344301501031103 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_2_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef NEF_POLYHEDRON_2_WINDOW_STREAM_H #define NEF_POLYHEDRON_2_WINDOW_STREAM_H #include #include CGAL_BEGIN_NAMESPACE static long frame_default = 100; static bool show_triangulation = false; template CGAL::Window_stream& operator<<(CGAL::Window_stream& ws, const Nef_polyhedron_2& P) { typedef Nef_polyhedron_2 Polyhedron; typedef typename T::RT RT; typedef typename T::Standard_RT Standard_RT; typedef typename Polyhedron::Topological_explorer TExplorer; typedef typename Polyhedron::Point Point; typedef typename Polyhedron::Line Line; typedef CGAL::PM_BooleColor BooleColor; typedef CGAL::PM_visualizor Visualizor; TExplorer D = P.explorer(); const T& E = Nef_polyhedron_2::EK; Standard_RT frame_radius = frame_default; E.determine_frame_radius(D.points_begin(),D.points_end(),frame_radius); RT::set_R(frame_radius); Visualizor PMV(ws,D); PMV.draw_map(); if (show_triangulation) { P.init_locator(); Visualizor V(ws,P.locator().triangulation()); V.draw_skeleton(CGAL::BLUE); } return ws; } CGAL_END_NAMESPACE #endif // NEF_POLYHEDRON_2_WINDOW_STREAM_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_inventor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_invento0000644000175000017500000000444311344301501031275 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_inventor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_WRITER_INVENTOR_H #define CGAL_IO_FILE_WRITER_INVENTOR_H 1 #ifndef CGAL_BASIC_H #include #endif // CGAL_BASIC_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif CGAL_BEGIN_NAMESPACE class File_writer_inventor { std::ostream* m_out; std::size_t m_facets; public: File_writer_inventor() {} std::ostream& out() const { return *m_out; } void write_header( std::ostream& o, std::size_t vertices, std::size_t halfedges, std::size_t facets); void write_footer() const; void write_vertex( const double& x, const double& y, const double& z) { out() << " " << x << ' ' << y << ' ' << z << ',' <<'\n'; } void write_facet_header() const; void write_facet_begin( std::size_t) { out() << " "; } void write_facet_vertex_index( std::size_t idx) { out() << idx << ',';} void write_facet_end() { out() << "-1,\n"; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_WRITER_INVENTOR_H // // EOF // ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Optimisation_circle_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Optimisat0000644000175000017500000000333111344301501031233 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Optimisation_circle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_OPTIMISATION_CIRCLE_2_H #define CGAL_QT_WIDGET_OPTIMISATION_CIRCLE_2_H #include namespace CGAL{ template Qt_widget& operator << (Qt_widget &ws, const CGAL::Optimisation_circle_2& oc){ typedef typename Traits::Point_2 Point_2; typedef typename Traits::Circle_2 Circle_2; double cx( CGAL::to_double( oc.center().x())); double cy( CGAL::to_double( oc.center().y())); double sr( CGAL::to_double( oc.squared_radius())); if( ! CGAL_NTS is_negative(sr)) ws << Circle_2( Point_2(cx, cy), sr); return ws; } }//end namespace #endif ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_polyline_traits_Postscript_file_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_polyline_traits0000644000175000017500000000346411344301501031307 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_polyline_traits_Postscript_file_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifdef CGAL_ARR_POLYLINE_TRAITS_H #ifndef CGAL_ARR_POLYLINE_TRAITS_POSTSCRIPT_FILE_STREAM_H #define CGAL_ARR_POLYLINE_TRAITS_POSTSCRIPT_FILE_STREAM_H #include #include CGAL_BEGIN_NAMESPACE template Postscript_file_stream& operator<< (Postscript_file_stream& ps, const Polyline_2& pl) { typedef Polyline_2 Curve_2; typedef typename Curve_2::const_iterator Points_iterator; typedef typename Curve_2::Segment_2 Segment_2; Points_iterator its = pl.begin(); // Disregard empty polylines: if (its == pl.end()) return (ps); // Draw the first point. ps << (*its); // Draw each segment of the polyline. Points_iterator itt = pl.begin(); itt++; while (itt != pl.end()) { ps << Segment_2(*its, *itt); its++; itt++; } // Now (*its) is the last polyline point -- draw it as well. ps << (*its); return (ps); } CGAL_END_NAMESPACE #endif #endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_geomview_ostream_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_geomv0000644000175000017500000000731511344301501031276 0ustar debiandebian// Copyright (c) 2000 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_geomview_ostream_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_IO_TRIANGULATION_GEOMVIEW_OSTREAM_2_H #define CGAL_IO_TRIANGULATION_GEOMVIEW_OSTREAM_2_H #include #include CGAL_BEGIN_NAMESPACE // There are 2 drawing functions for triangulations : depending on the wired // mode of the Geomview_stream, we draw either the edges or the faces. // TODO : // - Check the correctness when dimension < 2. // - Use the current stream color instead of built-in constant. template < class GT, class TDS > void show_triangulation_edges(Geomview_stream &gv, const Triangulation_2 &T) { // Header. gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("triangulationedge") << " {appearance {}{ SKEL \n" << T.number_of_vertices() << T.number_of_vertices() + T.number_of_faces()-1 << "\n"; // Finite vertices coordinates. std::map::Vertex_handle, int> V; int inum = 0; for( typename Triangulation_2::Vertex_iterator vit = T.vertices_begin(); vit != T.vertices_end(); ++vit) { V[vit] = inum++; gv << vit->point() << "\n"; } // Finite edges indices. for( typename Triangulation_2::Edge_iterator eit = T.edges_begin(); eit != T.edges_end(); ++eit) { gv << 2 << V[(*eit).first->vertex(T.ccw((*eit).second))] << V[(*eit).first->vertex(T. cw((*eit).second))] << "\n"; // without color. // << 4 << drand48() << drand48() << drand48() << 1.0; // random color } } template < class GT, class TDS > void show_triangulation_faces(Geomview_stream &gv, const Triangulation_2 &T) { // Header. gv.set_binary_mode(); gv << "(geometry " << gv.get_new_id("triangulation") << " {appearance {}{ OFF BINARY\n" << T.number_of_vertices() << T.number_of_faces() << 0; // Finite vertices coordinates. std::map::Vertex_handle, int> V; int inum = 0; for( typename Triangulation_2::Vertex_iterator vit = T.vertices_begin(); vit != T.vertices_end(); ++vit) { V[vit] = inum++; gv << vit->point(); } // Finite faces indices. for( typename Triangulation_2::Face_iterator fit = T.faces_begin(); fit != T.faces_end(); ++fit) { gv << 3; for (int i=0; i<3; i++) gv << V[fit->vertex(i)]; gv << 0; // without color. // gv << 4 << drand48() << drand48() << drand48() << 1.0; // random color } } template < class GT, class TDS > Geomview_stream& operator<<( Geomview_stream &gv, const Triangulation_2 &T) { bool ascii_bak = gv.get_ascii_mode(); bool raw_bak = gv.set_raw(true); if (gv.get_wired()) show_triangulation_edges(gv, T); else show_triangulation_faces(gv, T); // Footer. gv << "}})"; gv.set_raw(raw_bak); gv.set_ascii_mode(ascii_bak); return gv; } CGAL_END_NAMESPACE #endif // CGAL_IO_TRIANGULATION_GEOMVIEW_OSTREAM_2_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_circle.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_circl0000644000175000017500000001241611344301501031221 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_circle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_GET_CIRCLE_H #define CGAL_QT_WIDGET_GET_CIRCLE_H #include #include #include #ifndef CGAL_QT_WIDGET_GET_POINT_BUTTON #define CGAL_QT_WIDGET_GET_POINT_BUTTON Qt::LeftButton #endif namespace CGAL { template class Qt_widget_get_circle : public Qt_widget_layer { public: typedef typename R::Point_2 Point; typedef typename R::Circle_2 Circle; typedef typename R::FT FT; Qt_widget_get_circle(const QCursor c=QCursor(Qt::crossCursor), QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), cursor(c), firstpoint(false), firsttime(true){}; void draw(){ firsttime = true; } protected: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && !firstpoint && is_pure(e->state())) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); x1 = x; y1 = y; x2 = x; y2 = y; firstpoint = true; } else if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON){ FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->new_object(make_object(Circle(Point(x1,y1), squared_distance(Point(x1, y1), Point(x,y))))); firstpoint = false; firsttime = true; } }; void keyPressEvent(QKeyEvent *e) { switch ( e->key() ) { case Key_Escape: // key_escape if(firstpoint) { firstpoint = false; RasterOp old_raster = widget->rasterOp(); QColor old_color = widget->color(); widget->lock(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; *widget << Circle(Point(x1,y1), squared_distance(Point(x1, y1), Point(x2,y2))); widget->setRasterOp(old_raster); widget->setColor(old_color); widget->unlock(); firsttime = true; } break; }//endswitch } void leaveEvent(QEvent *) { if(firstpoint) { QColor old_color = widget->color(); RasterOp old_raster = widget->rasterOp();//save the initial raster mode widget->lock(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; *widget << Circle(Point(x1,y1), squared_distance(Point(x1, y1), Point(x2,y2))); widget->unlock(); widget->setRasterOp(old_raster); widget->setColor(old_color); firsttime = true; } } void mouseMoveEvent(QMouseEvent *e) { if(firstpoint==TRUE) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); QColor old_color = widget->color(); RasterOp old_raster = widget->rasterOp();//save the initial raster mode widget->setRasterOp(XorROP); widget->lock(); *widget << CGAL::GREEN; if(!firsttime) *widget << Circle(Point(x1,y1), squared_distance(Point(x1, y1), Point(x2,y2))); *widget << Circle(Point(x1,y1), squared_distance(Point(x1, y1), Point(x,y))); widget->unlock(); widget->setRasterOp(old_raster); widget->setColor(old_color); //save the last coordinates to redraw the screen x2 = x; y2 = y; firsttime = false; } }; void activating() { oldpolicy = widget->focusPolicy(); widget->setFocusPolicy(QWidget::StrongFocus); oldcursor = widget->cursor(); widget->setCursor(cursor); }; void deactivating() { widget->setFocusPolicy(oldpolicy); widget->setCursor(oldcursor); firstpoint = false; }; QCursor cursor; QCursor oldcursor; FT x1, //the X of the first point y1; //the Y of the first point FT x2, //the old second point's X y2; //the old second point's Y bool firstpoint, //true if the user left clicked once firsttime; //true if the line is not drawn QWidget::FocusPolicy oldpolicy; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_SEGMENT_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Trapezoidal_decomposition_2_iostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Trapezoidal_decompo0000644000175000017500000001464611344301501031252 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Trapezoidal_decomposition_2_iostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_TRAPEZOIDAL_DECOMPOSITION_2_IOSTREAM_H #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_IOSTREAM_H #ifndef CGAL_TRAPEZOIDAL_DECOMPOSITION_2_H #include #endif CGAL_BEGIN_NAMESPACE template < class Traits> std::ostream& operator<<( std::ostream &out, const typename Trapezoidal_decomposition_2::In_face_iterator& it) { out << "In_face_iterator("; if (it.operator->()) out << *it; else out <<"end"; return out << ")" << std::flush; } template < class Traits> std::ostream& write( std::ostream &out,const Trapezoidal_decomposition_2& td) { return out << td; } template < class Traits> std::ostream& operator<<( std::ostream &out,const Trapezoidal_decomposition_2& td) { return write(out,td.get_data_structure(),td.get_traits()); } template < class Traits> std::ostream& write(std::ostream &out,const Td_X_trapezoid& t, const Traits& traits,bool validate=true) { typedef Trapezoidal_decomposition_2 TD; typedef Td_X_trapezoid X_trapezoid; typedef X_trapezoid* pointer; out << "("; if (!t.is_left_unbounded()) out << t.left(); else out << "-oo"; out << ","; if (!t.is_right_unbounded()) out << t.right(); else out << "+oo"; out << "," << std::flush; if (!t.is_bottom_unbounded()) out << t.bottom(); else out << "-oo"; out << ","; if (!t.is_top_unbounded()) out << t.top(); else out << "+oo"; out << ",neighbours(" << std::flush; // debug neighbours equivalence relation int max_size=4+1; int null_size=2,size=null_size,i,j; X_trapezoid* value[] = { 0, (X_trapezoid*)CGAL_TRAPEZOIDAL_DECOMPOSITION_2_DELETE_SIGNATURE, t.left_bottom_neighbour(), t.left_top_neighbour(), t.right_bottom_neighbour(), t.right_top_neighbour() }; typedef char debug_string[256]; debug_string name[]= { "none", "deleted", "lb", "lt", "rb", "rt" }; for (j=null_size;j<=max_size;j++) { for (i=0;i std::ostream& operator<<(std::ostream &out,const Td_X_trapezoid& t) { typedef Trapezoidal_decomposition_2 TD; typedef Td_X_trapezoid X_trapezoid; typedef X_trapezoid* pointer; Traits traits; out << "("; if (!t.is_left_unbounded()) out << t.left(); else out << "-oo"; out << ","; if (!t.is_right_unbounded()) out << t.right(); else out << "+oo"; out << "," << std::flush; if (!t.is_bottom_unbounded()) out << t.bottom(); else out << "-oo"; out << ","; if (!t.is_top_unbounded()) out << t.top(); else out << "+oo"; out << ",neighbours(" << std::flush; // debug neighbours equivalence relation int max_size=4+1; int null_size=2,size=null_size,i,j; X_trapezoid* value[] = { 0, (X_trapezoid*)CGAL_TRAPEZOIDAL_DECOMPOSITION_2_DELETE_SIGNATURE, t.left_bottom_neighbour(), t.left_top_neighbour(), t.right_bottom_neighbour(), t.right_top_neighbour() }; typedef char debug_string[256]; debug_string name[]= { "none", "deleted", "lb", "lt", "rb", "rt" }; for (j=null_size;j<=max_size;j++) { for (i=0;i class Custom_zoom_layer : public CGAL::Qt_widget_zoomrect{ public: Custom_zoom_layer(QObject* parent = 0, const char* name = 0) : Qt_widget_zoomrect(parent, name){} protected: void keyPressEvent(QKeyEvent *e){ if ( e->key() == Qt::Key_Plus ){ widget->zoom(2); } else if ( e->key() == Qt::Key_Minus){ widget->zoom(0.5); } } void mousePressEvent(QMouseEvent *e) { if(e->button() == Qt::LeftButton && (e->state() & Qt::ControlButton)) { if (!on_first){ first_x = e->x(); first_y = e->y(); on_first = true; } } } void mouseReleaseEvent(QMouseEvent *e) { if(e->button() == Qt::LeftButton && (e->state() & Qt::ControlButton)) { if((e->x() != first_x) && (e->y() != first_y)) { double x, y, xfirst2, yfirst2; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->x_real(first_x, xfirst2); widget->y_real(first_y, yfirst2); double xmin, xmax, ymin, ymax; if(x < xfirst2) {xmin = x; xmax = xfirst2;} else {xmin = xfirst2; xmax = x;}; if(y < yfirst2) {ymin = y; ymax = yfirst2;} else {ymin = yfirst2; ymax = y;}; widget->set_window(xmin, xmax, ymin, ymax); on_first = false; } } } void activating(){ widget->setFocusPolicy(QWidget::ClickFocus); oldcursor = widget->cursor(); widget->setCursor(crossCursor); } QCursor oldcursor; }; #endif././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Geomview_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Geomview_stream0000644000175000017500000000303111344301501031211 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Geomview_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_ARR_GEOMVIEW_STREAM_H #define CGAL_IO_ARR_GEOMVIEW_STREAM_H #ifndef CGAL_ARRANGEMENT_2_H #include #endif #ifndef CGAL_GEOMVIEW_STREAM_H #include #endif #ifndef CGAL_IO_FILE_DRAWER_H #include #endif #ifndef CGAL_IO_DRAW_PM_H #include #endif CGAL_BEGIN_NAMESPACE template Geomview_stream& operator << (Geomview_stream& os, const Arrangement_2& arr) { Pm_drawer< Arrangement_2 , Geomview_stream> drawer(os); draw_pm(arr, drawer, os); return os; } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_file_writer.h0000644000175000017500000002375611344301501030465 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Pm_file_writer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_PM_FILE_WRITER_H #define CGAL_IO_PM_FILE_WRITER_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Pm_file_writer : public File_header{ public: typedef typename PM::Vertex_iterator Vertex_iterator; typedef typename PM::Halfedge_iterator Halfedge_iterator; typedef typename PM::Face_iterator Face_iterator; typedef typename PM::Vertex_const_iterator Vertex_const_iterator; typedef typename PM::Halfedge_const_iterator Halfedge_const_iterator; typedef typename PM::Face_const_iterator Face_const_iterator; typedef typename PM::Vertex_handle Vertex_handle; typedef typename PM::Halfedge_handle Halfedge_handle; typedef typename PM::Face_handle Face_handle; typedef typename PM::Vertex_const_handle Vertex_const_handle; typedef typename PM::Halfedge_const_handle Halfedge_const_handle; typedef typename PM::Face_const_handle Face_const_handle; typedef typename PM::Holes_const_iterator Holes_const_iterator; typedef typename PM::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef Inverse_index H_index; typedef Inverse_index V_index; Pm_file_writer(std::ostream & o, const PM & pm, bool verbose = false) : File_header(verbose), m_out(&o), m_pm(pm), m_h_index(0), m_v_index(0) { } Pm_file_writer(std::ostream & o, const PM & pm, const File_header & h) : File_header(h), m_out(&o), m_pm(pm), m_h_index(0), m_v_index(0) { } std::ostream & out() const { return *m_out; } void write_title(const char * feature_name) const { if (comments()){ out() <<"# ------------------------------------- "<< feature_name << std::endl; out() <<"# --------------------------------------------------------" << std::endl; } } void write_comment(const char * str) const { if (comments()) out() <<"# "<< str << std::endl; } void write_comment(const char * str, int i) const { if (comments()){ out() <<"# "<< i <<" "<point() << std::endl; } public: void write_halfedges_header() const { if (no_comments()) out() << std::endl; else { out() << "# " << number_of_halfedges() << " halfedges "<< std::endl; out() << "# ------------------------------------------"<< std::endl; } } /* void write_halfedge(Halfedge_handle h) { if (verbose()) write_vertex(h->target()); else write_index(v_index[ Vertex_const_iterator(h->target())]); out() << h->curve() << std::endl; } void write_halfedge(Halfedge_const_handle h) { if (verbose()) write_vertex(h->target()); else write_index(v_index[ Vertex_const_iterator(h->target())]); out() << h->curve() << std::endl; }*/ void write_halfedge_verbose(Halfedge_const_handle h) const { out() << h->curve(); out() << " towards "; write_vertex(h->target()); } protected: virtual void write_halfedge(Halfedge_const_handle h) const { if (verbose()) write_halfedge_verbose(h); else { write_index(get_v_index(Vertex_const_iterator(h->target()))); out() << h->curve() << std::endl; } } public: void write_faces_header() const { if (no_comments()) out() << std::endl; else { out() << "# " << number_of_faces() << " faces "<< std::endl; out() << "# ------------------------------------------"<< std::endl; } } protected: virtual void write_face(Face_const_handle f) { int ck; Holes_const_iterator iccbit; write_comment("writing face"); out() << "# ------------------------------------------"<< std::endl; if (f->is_unbounded()){ write_comment("UNBOUNDED"); write_comment("number halfedges on outer boundary"); write_value(0); } else { write_comment("outer ccb"); Ccb_halfedge_const_circulator first = f->outer_ccb(), iter = first; std::size_t n = 0; do { n++; iter++; } while (iter != first); write_comment("number halfedges on outer boundary"); write_value(n); do{ if (verbose()) write_halfedge_verbose(iter); else write_index(get_h_index(Halfedge_const_iterator(iter))); ++iter; } while (iter != first); out() << std::endl; } for (ck=0, iccbit = (Holes_const_iterator)f->holes_begin(); iccbit != (Holes_const_iterator)f->holes_end(); ++iccbit, ck++); write_comment("number of holes"); write_value(ck); for (iccbit = (Holes_const_iterator)f->holes_begin(); iccbit != (Holes_const_iterator)f->holes_end(); ++iccbit) { write_comment("inner ccb"); Ccb_halfedge_const_circulator ccb_circ = (*iccbit); Ccb_halfedge_const_circulator iter = ccb_circ; std::size_t n = 0; do { n++; iter++; } while (iter != ccb_circ); write_comment("number halfedges on inner boundary"); write_value(n); do { if (verbose()) write_halfedge_verbose(iter); else write_index(get_h_index(Halfedge_const_iterator(iter))); ++iter; } while (iter != ccb_circ); out() < #include #include namespace CGAL { template class Qt_widget_get_polygon : public Qt_widget_layer { public: typedef typename Polygon::Point_2 Point_2; typedef typename Polygon::Segment_2 Segment_2; typedef typename Polygon::Edge_const_iterator ECI; typedef typename Polygon::Vertex_iterator VI; typedef typename Polygon::FT FT; Qt_widget_get_polygon(const QCursor c=QCursor(Qt::crossCursor), QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), active(false), first_time(true), cursor(c) {} void draw() { if(poly.size() > 1) { widget->lock(); RasterOp old_rasterop=widget->rasterOp(); widget->get_painter().setRasterOp(XorROP); *widget << CGAL::GREEN; ECI before_end = poly.edges_end(); --before_end; // --poly.edges_end() doesn't work on g++-2.95 // with std::vector as the container for the polygon for(ECI it = poly.edges_begin(); it != before_end; it++) *widget << *it; widget->setRasterOp(old_rasterop); widget->unlock(); } return; }; protected: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == Qt::LeftButton && is_pure(e->state())) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); if(!active) { active=true; last_of_poly = Point_2(x, y); poly.push_back(Point_2(x, y)); } else{ if (last_of_poly == Point_2(x,y)) return; rubber_old = Point_2(x, y); if(is_simple()){ poly.push_back(Point_2(x,y)); //show the last rubber as edge of the polygon widget->lock(); RasterOp old_rasterop=widget->rasterOp(); widget->get_painter().setRasterOp(XorROP); *widget << CGAL::WHITE; *widget << Segment_2(rubber, last_of_poly); *widget << CGAL::GREEN; *widget << Segment_2(rubber, last_of_poly); widget->setRasterOp(old_rasterop); widget->unlock(); last_of_poly = Point_2(x, y); } } return; }; if(e->button() == Qt::RightButton && is_pure(e->state())) { if (active) { widget->new_object(make_object(poly)); active = false; first_time = true; poly.erase(poly.vertices_begin(), poly.vertices_end()); widget->redraw(); } }; };//end mousePressEvent void keyPressEvent(QKeyEvent *e) { switch ( e->key() ) { case Key_Escape: // key_escape if(poly.size() > 1){ widget->lock(); RasterOp old_rasterop=widget->rasterOp(); widget->get_painter().setRasterOp(XorROP); *widget << CGAL::GREEN; // g++-2.95 doesn't like --poly.vertices_end() if the // container of the polygon is std::vector VI last_of_poly_it = poly.vertices_end(); --last_of_poly_it; VI before_last_of_poly_it = last_of_poly_it; --before_last_of_poly_it; *widget << Segment_2(*before_last_of_poly_it, last_of_poly); *widget << CGAL::WHITE; *widget << Segment_2(rubber, last_of_poly); *widget << Segment_2(rubber, *before_last_of_poly_it); widget->setRasterOp(old_rasterop); widget->unlock(); last_of_poly = *before_last_of_poly_it; poly.erase(last_of_poly_it); } break; }//endswitch } void mouseMoveEvent(QMouseEvent *e) { if(active) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); rubber = Point_2(x, y); if(e->state() == Qt::ShiftButton){ FT dx, dy; dx = last_of_poly.x() > x ? last_of_poly.x() - x : x - last_of_poly.x(); dy = last_of_poly.y() > y ? last_of_poly.y() - y : y - last_of_poly.y(); widget->lock(); RasterOp old_rasterop=widget->rasterOp(); widget->get_painter().setRasterOp(XorROP); *widget << CGAL::WHITE; if(!first_time) *widget << Segment_2(rubber_old, last_of_poly); if(dx < dy) rubber = Point_2(last_of_poly.x(), y); else rubber = Point_2(x, last_of_poly.y()); *widget << Segment_2(rubber, last_of_poly); widget->unlock(); first_time = false; rubber_old = rubber; widget->cursor().setPos(widget->mapToGlobal( QPoint(widget->x_pixel(CGAL::to_double(rubber.x())), widget->y_pixel(CGAL::to_double(rubber.y()))))); widget->setRasterOp(old_rasterop); } else { widget->lock(); RasterOp old_rasterop=widget->rasterOp(); widget->get_painter().setRasterOp(XorROP); *widget << CGAL::WHITE; if(!first_time) *widget << Segment_2(rubber_old, last_of_poly); *widget << Segment_2(rubber, last_of_poly); first_time = false; rubber_old = rubber; widget->setRasterOp(old_rasterop); widget->unlock(); } } }; void activating() { oldcursor = widget->cursor(); widget->setCursor(cursor); oldpolicy = widget->focusPolicy(); widget->setFocusPolicy(QWidget::StrongFocus); }; void deactivating() { poly.erase(poly.vertices_begin(), poly.vertices_end()); active = false; first_time = true; widget->setCursor(oldcursor); widget->setFocusPolicy(oldpolicy); widget->redraw(); }; void leaveEvent(QEvent *) { if (active) { widget->lock(); RasterOp old_rasterop=widget->rasterOp(); widget->get_painter().setRasterOp(XorROP); *widget << CGAL::WHITE; *widget << Segment_2(rubber_old, last_of_poly); widget->setRasterOp(old_rasterop); widget->unlock(); first_time = true; } } private: virtual bool is_simple() { return true; } protected: bool active, //true if the first point was inserted first_time; //true if it is the first time when //draw the rubber band Point_2 rubber, //the new point of the rubber band last_of_poly, //the last point of the polygon rubber_old; //the old point of the rubber band Polygon poly; //the polygon QWidget::FocusPolicy oldpolicy; QCursor oldcursor; QCursor cursor; }; } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_POLYGON_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Optimisation_ellipse_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Optimisat0000644000175000017500000000461511344301501031241 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Optimisation_ellipse_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_OPTIMISATION_ELLIPSE_2_H #define CGAL_QT_WIDGET_OPTIMISATION_ELLIPSE_2_H #include #include namespace CGAL{ template< class Traits_ > Qt_widget& operator << ( Qt_widget &ws, const CGAL::Optimisation_ellipse_2& oe) { typedef Cartesian Rep; typedef Point_2 Point; typedef Segment_2 Segment; switch ( oe.n_boundary_points) { case 0: break; case 1: ws << oe.boundary_point1; break; case 2: { double px1( CGAL::to_double( oe.boundary_point1.x())); double py1( CGAL::to_double( oe.boundary_point1.y())); double px2( CGAL::to_double( oe.boundary_point2.x())); double py2( CGAL::to_double( oe.boundary_point2.y())); ws << Segment( Point(px1, py1), Point(px2, py2)); } break; case 3: case 4: case 5: { typedef CGAL::Conic_2 > DoubleConic_2; DoubleConic_2 dc2; oe.double_conic(dc2); ws << dc2; } break; default: CGAL_optimisation_assertion( ( oe.n_boundary_points >= 0) && ( oe.n_boundary_points <= 5) ); } return( ws); } }//end namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_OFF.h0000644000175000017500000001024711344301501030452 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_writer_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_WRITER_OFF_H #define CGAL_IO_FILE_WRITER_OFF_H 1 #ifndef CGAL_IO_BINARY_FILE_IO_H #include #endif // CGAL_IO_BINARY_FILE_IO_H #ifndef CGAL_IO_FILE_HEADER_OFF_H #include #endif // CGAL_IO_FILE_HEADER_OFF_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif CGAL_BEGIN_NAMESPACE class File_writer_OFF { std::ostream* m_out; File_header_OFF m_header; public: File_writer_OFF( bool verbose = false) : m_header( verbose) {} File_writer_OFF( const File_header_OFF& h) : m_header( h) {} std::ostream& out() { return *m_out; } File_header_OFF& header() { return m_header; } const File_header_OFF& header() const { return m_header; } void write_header( std::ostream& out, std::size_t vertices, std::size_t halfedges, std::size_t facets, bool normals = false); void write_footer() { if ( m_header.ascii() && m_header.comments()) out() << "\n\n# End of OFF #"; out() << std::endl; } void write_vertex( const double& x, const double& y, const double& z) { if ( m_header.binary()) { I_Binary_write_big_endian_float32( out(), float(x)); I_Binary_write_big_endian_float32( out(), float(y)); I_Binary_write_big_endian_float32( out(), float(z)); } else { out() << '\n' << x << ' ' << y << ' ' << z; } } void write_normal( const double& x, const double& y, const double& z) { if ( m_header.binary()) { I_Binary_write_big_endian_float32( out(), float(x)); I_Binary_write_big_endian_float32( out(), float(y)); I_Binary_write_big_endian_float32( out(), float(z)); } else { out() << ' ' << ' ' << x << ' ' << y << ' ' << z; } } void write_facet_header() { if ( m_header.ascii()) { if ( m_header.no_comments()) out() << '\n'; else { out() << "\n\n# " << m_header.size_of_facets() << " facets\n"; out() << "# ------------------------------------------" "\n\n"; } } } void write_facet_begin( std::size_t no) { if ( m_header.binary()) I_Binary_write_big_endian_integer32( out(), no); else out() << no << ' '; } void write_facet_vertex_index( std::size_t index) { if ( m_header.binary()) I_Binary_write_big_endian_integer32( out(), index); else out() << ' ' << index; } void write_facet_end() { if ( m_header.binary()) I_Binary_write_big_endian_integer32( out(), 0); else out() << '\n'; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_WRITER_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_focus.h0000644000175000017500000000705411344301501030635 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_focus.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_FOCUS_H #define CGAL_QT_WIDGET_FOCUS_H #include #include #include #include #include #include #include #include #include #include #include #include #include namespace CGAL { class Qt_widget_focus : public Qt_widget_layer { private: int x2, y2; QPixmap *mouse_ico1, *mouse_ico2, *mouse_ico3; QCursor *cursor1, *cursor2, *cursor3; QBitmap cb, cm; int cycle; QCursor oldcursor; public: Qt_widget_focus(QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), cycle(0) { mouse_ico1 = new QPixmap( (const char**)focus1_xpm); mouse_ico2 = new QPixmap( (const char**)focus2_xpm); mouse_ico3 = new QPixmap( (const char**)focus3_xpm); QPixmap *mouse_ico_mask1 = new QPixmap((const char**)focus1_mask_xpm); QPixmap *mouse_ico_mask2 = new QPixmap((const char**)focus2_mask_xpm); QPixmap *mouse_ico_mask3 = new QPixmap((const char**)focus3_mask_xpm); cb = *mouse_ico1; cm = *mouse_ico_mask1; mouse_ico1->setMask(cm); cursor1 = new QCursor(*mouse_ico1); cb = *mouse_ico2; cm = *mouse_ico_mask2; mouse_ico2->setMask(cm); cursor2 = new QCursor(*mouse_ico2); cb = *mouse_ico3; cm = *mouse_ico_mask3; mouse_ico3->setMask(cm); cursor3 = new QCursor(*mouse_ico3); }; void timerEvent( QTimerEvent *) { switch(cycle){ case 1: widget->setCursor(*cursor1); cycle++; break; case 2: widget->setCursor(*cursor2); cycle++; break; case 3: widget->setCursor(*cursor3); cycle=1; break; } } private: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == Qt::LeftButton && is_pure(e->state())) { double x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->set_center(x, y); } }; void deactivating() { widget->setCursor(oldcursor); killTimers(); }; void activating() { oldcursor = widget->cursor(); startTimer( 200 ); cycle = 1; }; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_FOCUS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Writer_OFF.h0000644000175000017500000000414411344301501027452 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Writer_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_WRITER_OFF_H #define CGAL_IO_WRITER_OFF_H 1 #ifndef CGAL_IO_FILE_WRITER_OFF_H #include #endif // CGAL_IO_FILE_WRITER_OFF_H #ifndef CGAL_IO_GENERIC_WRITER_H #include #endif // CGAL_IO_GENERIC_WRITER_H CGAL_BEGIN_NAMESPACE template < class Pt > class Writer_OFF : public Generic_writer { public: Writer_OFF( std::ostream& out, std::size_t v, std::size_t h, std::size_t f, bool verbose = false) : Generic_writer( File_writer_OFF( verbose), out, v, h, f ) {} Writer_OFF( std::ostream& out, std::size_t v, std::size_t h, std::size_t f, const File_header_OFF& header) : Generic_writer( File_writer_OFF( header), out, v, h, f ) {} }; CGAL_END_NAMESPACE #endif // CGAL_IO_WRITER_OFF_H // // EOF // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Convex_hull_d_window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Convex_hull_d_windo0000644000175000017500000002235411344301501031252 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Convex_hull_d_window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_CONVEX_HULL_D_WINDOW_STREAM_H #define CGAL_CONVEX_HULL_D_WINDOW_STREAM_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*{\Mtext \headerline{Low Dimensional Output Routines} include || \setopdims{2cm}{3cm}}*/ template void d2_show(const Convex_hull_d& C, CGAL::Window_stream& W); /*{\Mfunc draws the convex hull |C| in window |W|.\\ \precond |dim == 2|. }*/ template void d3_surface_map(const Convex_hull_d& C, CGAL_LEDA_SCOPE::GRAPH< typename Convex_hull_d::Point_d ,int>& G); /*{\Mfunc constructs the representation of the surface of |\Mvar| as a bidirected LEDA graph |G|.\\ \precond |dim == 3|.}*/ template void d2_show(const Convex_hull_d& C, CGAL::Window_stream& W) { /* We first draw every simplex*/ typedef typename Convex_hull_d::Simplex_const_handle Simplex_handle; typedef typename Convex_hull_d::Vertex_const_handle Vertex_handle; Simplex_handle S; forall_rc_simplices(S,C) { for (int v = ( C.is_unbounded_simplex(S) ? 1 : 0); v <= C.current_dimension(); v++) { // for each vertex except the anti - origin for (int e = v + 1; e <= C.current_dimension(); e++) { // draw undrawn edges incident to vertex if ( C.is_unbounded_simplex(S) ) W.set_line_width(3); else W.set_line_width(1); W.draw_segment(to_leda_point(C.point_of_simplex(S,v)), to_leda_point(C.point_of_simplex(S,e))); } } } /* Now we draw every point */ typename Convex_hull_d::Point_const_iterator pit; for (pit = C.points_begin(); pit != C.points_end(); ++pit) { W.draw_point(to_leda_point(*pit)); } } template void d3_surface_map(const Convex_hull_d& C, CGAL_LEDA_SCOPE::GRAPH< typename Convex_hull_d::Point_d ,int>& G) { typedef typename Convex_hull_d::Vertex_const_handle Vertex_handle; typedef typename Convex_hull_d::Simplex_const_handle Simplex_handle; typedef typename Convex_hull_d::Facet_const_handle Facet_handle; typedef typename Convex_hull_d::Point_d Point_d; typedef typename R::RT RT; G.clear(); if (C.dimension() != 3) CGAL_assertion_msg(0,"d3_surface_map: dim must be 3"); if (C.current_dimension() < 3) { Unique_hash_map node_for(nil); Vertex_handle v; Simplex_handle s; forall_rc_vertices(v,C) { node_for[v] = G.new_node(C.associated_point(v)); } if (C.current_dimension() <= 0) { return; } if (C.current_dimension() == 1) { forall_rc_simplices(s,C) { if (C.is_bounded_simplex(s)) { leda_node v0 = node_for[C.vertex(s,0)]; leda_node v1 = node_for[C.vertex(s,1)]; leda_edge e01 = G.new_edge(v0,v1); leda_edge e10 = G.new_edge(v1,v0); G.set_reversal(e01,e10); } } return; } if (C.current_dimension() == 2) { leda_node_array untreated(G,true); typename R::Orthogonal_vector_d ortho_vector = C.kernel().orthogonal_vector_d_object(); typename R::Point_d pc = C.center() + ortho_vector(C.base_facet_plane(C.origin_simplex())); forall_rc_simplices(s,C) { if (C.is_bounded_simplex(s)) { for (int i = 0; i <= C.current_dimension(); i++) { leda_node vi = node_for[C.vertex(s,i)]; if ( untreated[vi] ) { untreated[vi] = false; int j = (i + 1) % (C.current_dimension() + 1); // a vertex different from i; int k = (i + 2) % (C.current_dimension() + 1); leda_node vj = node_for[C.vertex(s,j)]; leda_node vk = node_for[C.vertex(s,k)]; std::vector< Point_d > V(4); V[0]=G[vi]; V[1]=G[vj]; V[2]=G[vk]; V[3]=pc; typename R::Orientation_d orientation = C.kernel().orientation_d_object(); if ( orientation(V.begin(),V.end()) == POSITIVE ) { std::swap(vj,vk); std::swap(j,k); } leda_edge efirst = G.new_edge(vi,vk); // first edge incident to vi Simplex_handle scur = s; int jcur = j, kcur = k, icur = i; while ( C.is_bounded_simplex(C.opposite_simplex(scur,jcur)) && C.opposite_simplex(scur,jcur) != s ) { // we have not reached the end nor closed the cycle kcur = C.index_of_opposite_vertex(scur,jcur); scur = C.opposite_simplex(scur,jcur); for (icur = 0; icur <= 2; icur++) if (node_for[C.vertex(scur,icur)] == vi) break; jcur = 3 - icur - kcur; vk = node_for[C.vertex(scur,kcur)]; G.new_edge(vi,vk); } if (C.is_unbounded_simplex(C.opposite_simplex(scur,jcur))) { /* we also need to walk in the other direction */ efirst = G.new_edge(efirst,vj,0,LEDA::before); // 0 is etype scur = s; jcur = j; kcur = k; icur = i; // restore initial situation while ( C.is_bounded_simplex( C.opposite_simplex(scur,kcur)) ) { // we have not reached the end jcur = C.index_of_opposite_vertex(scur,kcur); scur = C.opposite_simplex(scur,kcur); for (icur = 0; icur <= 2; icur++) if (node_for[C.vertex(scur,icur)] == vi) break; kcur = 3 - jcur -icur; vj = node_for[C.vertex(scur,jcur)]; efirst = G.new_edge(efirst,vj,0,LEDA::before); //as above } //end while }// end if }// end if untreated }// end for i }// end if bounded }// end forall if (!G.make_map()) CGAL_LEDA_SCOPE::error_handler(1, "chull::surface_graphrep: not bidirected"); return; } } Facet_handle f; Vertex_handle v; Unique_hash_map node_for(nil); int facet_num = 0; std::list Surface = C.all_facets(); typename std::list::iterator it; for(it = Surface.begin(); it != Surface.end(); ++it) { f = *it; ++facet_num; for (int i=0; i < C.current_dimension(); i++) { v = C.vertex_of_facet(f,i); if (!node_for[v]) node_for[v] = G.new_node(C.associated_point(v)); } } if ( 2*G.number_of_nodes() != facet_num + 4) CGAL_LEDA_SCOPE::error_handler(1,"d3_surface_map: node equation wrong."); leda_node_array untreated(G,true); for(it = Surface.begin(); it != Surface.end(); ++it) { f = *it; for (int i = 0; i < C.current_dimension(); i++) { leda_node vi = node_for[C.vertex_of_facet(f,i)]; if ( untreated[vi] ) { untreated[vi] = false; int j = (i + 1) % C.current_dimension(); // a vertex different from i; int k = (i + 2) % C.current_dimension(); leda_node vj = node_for[C.vertex_of_facet(f,j)]; leda_node vk = node_for[C.vertex_of_facet(f,k)]; typename R::Orientation_d orientation_ = C.kernel().orientation_d_object(); std::vector< Point_d > V(4); V[0]=G[vi]; V[1]=G[vj]; V[2]=G[vk]; V[3]=C.center(); if ( orientation_(V.begin(),V.end()) == POSITIVE ) { std::swap(vk,vj); std::swap(k,j); } G.new_edge(vi,vk); // first edge incident to vi Facet_handle fcur = f; int jcur = j; int kcur = k; int icur = i; while ( C.opposite_facet(fcur,jcur) != f ) { // we have not reached the end kcur = C.index_of_vertex_in_opposite_facet(fcur,jcur); fcur = C.opposite_facet(fcur,jcur); for (icur = 0; icur < 3; icur++) if ( node_for[C.vertex_of_facet(fcur,icur)] == vi ) break; jcur = 3 - icur - kcur; vk = node_for[C.vertex_of_facet(fcur,kcur)]; G.new_edge(vi,vk); } } // end if untreated } // end for i } // end forall if (G.number_of_edges() != (3*facet_num)) CGAL_LEDA_SCOPE::error_handler(1,"d3_surface_map: wrong number of edges"); if (!G.make_map()) CGAL_LEDA_SCOPE::error_handler(1,"d3_surface_map: not bidirected"); } CGAL_END_NAMESPACE #endif //CGAL_CONVEX_HULL_D_WINDOW_STREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/VRML_1_ostream.h0000644000175000017500000000746011344301501030242 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/VRML_1_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Lutz Kettner // Herve Bronnimann // Mariette Yvinec #ifndef CGAL_IO_VRML_1_OSTREAM_H #define CGAL_IO_VRML_1_OSTREAM_H #ifndef CGAL_BASIC_H #include #endif // CGAL_BASIC_H #ifndef CGAL_PROTECT_IOSTREAM_H #include #define CGAL_PROTECT_IOSTREAM_H #endif // CGAL_PROTECT_IOSTREAM_H // Declare the common base class for OpenInventor and VRML 1.0 format. #ifndef CGAL_IO_INVENTOR_OSTREAM_H #include #endif // CGAL_IO_INVENTOR_OSTREAM_H // OpenInventor and VRML 1.0 are quite similar formats, so // output operators could be shared if they use the common // base class Inventor_ostream_base, which is common for // both output streams. CGAL_BEGIN_NAMESPACE class VRML_1_ostream : public Inventor_ostream_base { public: VRML_1_ostream() {} VRML_1_ostream(std::ostream& o) : Inventor_ostream_base(o) { header(); } void open(std::ostream& o) { Inventor_ostream_base::open(o); header(); } private: void header() { os() << "#VRML V1.0 ascii" << std::endl; os() << "# File written with the help of the CGAL Library" << std::endl; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_1_OSTREAM_H #ifdef CGAL_TETRAHEDRON_3_H #ifndef CGAL_IO_VRML_1_TETRAHEDRON_3 #define CGAL_IO_VRML_1_TETRAHEDRON_3 CGAL_BEGIN_NAMESPACE template VRML_1_ostream& operator<<(VRML_1_ostream& os, const Tetrahedron_3 &t) { const char *Indent = " "; os.os() << "\n Separator {"; os.os() << "\n Coordinate3 { \n" << Indent << "point [\n" << Indent << " " << CGAL::to_double(t[0].x()) << " " << CGAL::to_double(t[0].y()) << " " << CGAL::to_double(t[0].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[1].x()) << " " << CGAL::to_double(t[1].y()) << " " << CGAL::to_double(t[1].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[2].x()) << " " << CGAL::to_double(t[2].y()) << " " << CGAL::to_double(t[2].z()) << " ,\n" << Indent << " " << CGAL::to_double(t[3].x()) << " " << CGAL::to_double(t[3].y()) << " " << CGAL::to_double(t[3].z()) << " ]" << "\n } #Coordinate3" ; os.os() << "\n IndexedFaceSet {" << Indent << "coordIndex [ 0,1,2,-1, 1,3,2,-1,\n" << Indent << " 0,2,3,-1, 0,3,1,-1 ]\n" << "\n } #IndexedFaceSet" << "\n } #Separator\n"; return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_VRML_1_TETRAHEDRON_3 #endif // CGAL_TETRAHEDRON_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Verbose_ostream.h0000644000175000017500000000442311344301501030643 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Verbose_ostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_VERBOSE_OSTREAM_H #define CGAL_IO_VERBOSE_OSTREAM_H #include CGAL_BEGIN_NAMESPACE #define CGAL__VERB(x) if (b) *o << x; return *this class Verbose_ostream { bool b; std::ostream* o; public: Verbose_ostream( bool active = false, std::ostream& out = std::cerr) : b(active), o(&out){} bool verbose() const { return b; } void set_verbose(bool active) { b = active; } std::ostream& out() { return *o; } template < class T > Verbose_ostream& operator<<(const T& t) { CGAL__VERB(t); } Verbose_ostream& operator<<( std::ostream& (*f)(std::ostream&)) { CGAL__VERB(f); } Verbose_ostream& operator<<( std::ios& (*f)(std::ios&)) { CGAL__VERB(f); } Verbose_ostream& flush() { if (b) o->flush(); return *this; } Verbose_ostream& put(char c) { if (b) o->put(c); return *this; } Verbose_ostream& write(const char* s, int n) { if (b) o->write(s, n); return *this; } }; CGAL_END_NAMESPACE #endif // CGAL_IO_VERBOSE_OSTREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/binary_file_io.h0000644000175000017500000000622111344301501030454 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/binary_file_io.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_BINARY_FILE_IO_H #define CGAL_IO_BINARY_FILE_IO_H #include #include #include CGAL_BEGIN_NAMESPACE inline void I_Binary_write_integer32(std::ostream& out, Integer32 i) { out.write( (char*)(&i), 4); } inline void I_Binary_write_float32(std::ostream& out, float f) { out.write( (char*)(&f), 4); } inline void I_Binary_read_integer32(std::istream& in, Integer32& i) { in.read( (char*)(&i), 4); } inline void I_Binary_read_float32(std::istream& in, float& f) { in.read( (char*)(&f), 4); } inline void I_swap_to_big_endian( UInteger32& u) { (void) u; #ifdef CGAL_LITTLE_ENDIAN u = ((u >> 24) | (u << 24) | ((u >> 8) & 0xff00) | ((u << 8) & 0xff0000)); #endif } inline void I_swap_to_big_endian( Integer32& i) { // We need to use a union instead of the 2 lines below, // otherwise we get aliasing issues. // UInteger32& u = (UInteger32&)i; // I_swap_to_big_endian( u); union { Integer32 in; UInteger32 ui; } u; u.in = i; I_swap_to_big_endian(u.ui); i = u.in; } inline void I_swap_to_big_endian( float& f) { // We need to use a union instead of the 2 lines below, // otherwise we get aliasing issues. // UInteger32& u = (UInteger32&)f; // I_swap_to_big_endian( u); union { UInteger32 ui; float fl; } u; u.fl = f; I_swap_to_big_endian(u.ui); f = u.fl; } inline void I_Binary_write_big_endian_integer32(std::ostream& out, Integer32 i) { I_swap_to_big_endian( i); out.write( (char*)(&i), 4); } inline void I_Binary_write_big_endian_float32(std::ostream& out, float f) { I_swap_to_big_endian( f); out.write( (char*)(&f), 4); } inline void I_Binary_read_big_endian_integer32(std::istream& in, Integer32& i) { in.read( (char*)(&i), 4); I_swap_to_big_endian( i); } inline void I_Binary_read_big_endian_float32(std::istream& in, float& f) { in.read( (char*)(&f), 4); I_swap_to_big_endian( f); } CGAL_END_NAMESPACE #endif // CGAL_IO_BINARY_FILE_IO_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Delaunay_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Delaunay_0000644000175000017500000000301111344301501031156 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Delaunay_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_DELAUNAY_TRIANGULATION_2_H #define CGAL_QT_WIDGET_DELAUNAY_TRIANGULATION_2_H #include #include namespace CGAL{ template < class Gt, class Tds > Qt_widget& operator<<(Qt_widget& w, const Delaunay_triangulation_2 &dt) { w.lock(); dt.draw_triangulation(w); w.unlock(); return w; } }//end namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_wavefront.h0000644000175000017500000000324011344301501030727 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_wavefront.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_PRINT_WAVEFRONT_H #define CGAL_IO_PRINT_WAVEFRONT_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template void print_polyhedron_wavefront( std::ostream& out, const Polyhedron& P) { File_writer_wavefront writer; generic_print_polyhedron( out, P, writer); } // Deprecated global functions, replaced with functions above template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void print_wavefront( std::ostream& out, const Polyhedron_3& P) { File_writer_wavefront writer; generic_print_polyhedron( out, P, writer); } CGAL_END_NAMESPACE #endif // CGAL_IO_PRINT_WAVEFRONT_H // // EOF // ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Planar_map_iostream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Planar_map_iostream0000644000175000017500000000665511344301501031244 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Planar_map_iostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_PLANAR_MAP_2_H #include #endif #include CGAL_BEGIN_NAMESPACE template ::std::ostream& operator<<(::std::ostream& o, const Planar_map_2& pm) { o << "Vertices ---------------" << std::endl; typename Planar_map_2::Vertex_const_iterator vi; for (vi = pm.vertices_begin(); vi != pm.vertices_end(); ++vi) { o << "(" << vi->point() << ")" << std::endl; } o << "Halfedges ------------------" << std::endl; typename Planar_map_2::Halfedge_const_iterator ei; for (ei = pm.halfedges_begin(); ei != pm.halfedges_end(); ++ei) { o << "{" << ei->curve() << "}" << std::endl; } o << "Faces ------------------" << std::endl; typename Planar_map_2::Face_const_iterator fi; typename Planar_map_2::Holes_const_iterator iccbit; //typename Planar_map_2::Holes_iterator iccbit; typename Planar_map_2::Ccb_halfedge_const_circulator ccb_circ; //typename Planar_map_2::Ccb_halfedge_circulator ccb_circ; int ck; int fc_counter; for (fc_counter=0,fi = pm.faces_begin(); fi != pm.faces_end(); ++fi,fc_counter++) { o << "Face " << fc_counter << " :\n"; o << "outer ccb: " ; if (fi->is_unbounded()) { o << "UNBOUNDED" << std::endl; } else { // typename Planar_map_2::Ccb_halfedge_circulator typename Planar_map_2::Ccb_halfedge_const_circulator first = fi->outer_ccb(), iter = first; o << "["; do { o << "(" << iter->source()->point() << ")-"; ++iter; } while (iter != first); o << "(" << first->source()->point() << ")]" << std::endl; } for (ck=0, iccbit = (*fi).holes_begin(); iccbit != (*fi).holes_end(); ++iccbit, ck++) { o << "inner ccb " << ck << ": " ; ccb_circ = (*iccbit); typename Planar_map_2::Ccb_halfedge_const_circulator //typename Planar_map_2::Ccb_halfedge_circulator iter = ccb_circ; o << "["; do { o << "(" << iter->source()->point() << ")-"; ++iter; } while (iter != ccb_circ); o << "(" << ccb_circ->source()->point() << ")]" ; } o << std::endl; } return o; } CGAL_END_NAMESPACE ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_simple_polygon.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_simpl0000644000175000017500000000604011344301501031245 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_simple_polygon.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent Rineau && Radu Ursu #ifndef CGAL_QT_WIDGET_GET_SIMPLE_POLYGON_H #define CGAL_QT_WIDGET_GET_SIMPLE_POLYGON_H #include #include #include #include namespace CGAL { template class Qt_widget_get_simple_polygon : public Qt_widget_get_polygon { public: typedef Qt_widget_get_polygon Get_polygon; typedef typename Polygon::Point_2 Point_2; typedef typename Polygon::Segment_2 Segment_2; typedef typename Polygon::Edge_const_iterator ECI; Qt_widget_get_simple_polygon(const QCursor c=QCursor(Qt::crossCursor),QObject* parent = 0, const char* name = 0) : Qt_widget_get_polygon(c, parent, name){} protected: void mousePressEvent(QMouseEvent *e) { if(e->button() == Qt::RightButton && is_pure(e->state())) { if (this->active) { if(!this->poly.is_simple()) return; if(this->poly.is_clockwise_oriented()) this->poly.reverse_orientation (); assert( ! this->poly.is_clockwise_oriented()); } } Get_polygon::mousePressEvent(e); }; private: bool is_simple() { Segment_2 rubber_segment(this->rubber, this->last_of_poly); if(this->poly.size() > 1) { ECI before_last_it = this->poly.edges_end(); --before_last_it; --before_last_it; ECI it; for(it = this->poly.edges_begin(); it != before_last_it; it++) { if(do_intersect(*it, rubber_segment)) return false; } //if I'm out of this means that all the edges, //didn't intersect the last one ++it; Object o = intersection(*it, rubber_segment); Point_2 p; if(assign(p, o)) return true; else return false; } else return true; } }; } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_SIMPLE_POLYGON_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Postscript_file_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Postscript_file0000644000175000017500000000330211344301501031226 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_Postscript_file_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_ARR_POSTSCRIPT_FILE_STREAM_H #define CGAL_IO_ARR_POSTSCRIPT_FILE_STREAM_H #ifndef CGAL_POSTSCRIPT_FILE_STREAM_H #include #endif #ifndef CGAL_ARRANGEMENT_2_H #include #endif /* #ifndef CGAL_IO_PM_BOUNDING_BOX_BASE_WINDOW_STREAM_H #include #endif */ #ifndef CGAL_IO_FILE_DRAWER_H #include #endif #ifndef CGAL_IO_DRAW_PM_H #include #endif CGAL_BEGIN_NAMESPACE template Postscript_file_stream& operator << (Postscript_file_stream & ps, const Arrangement_2& arr) { Pm_drawer< Arrangement_2 , Postscript_file_stream> drawer(ps); draw_pm(arr, drawer, ps); return ps; } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_history.h0000644000175000017500000000536711344301501031224 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_history.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu & Laurent Rineau #ifndef CGAL_QT_WIDGET_HISTORY_H #define CGAL_QT_WIDGET_HISTORY_H #include #include #include namespace CGAL { class History_atom { public: History_atom() {}; virtual ~History_atom() {}; void save(const Qt_widget& widget){ xmin = widget.x_min(); ymin = widget.y_min(); xmax = widget.x_max(); ymax = widget.y_max(); } void restore(Qt_widget& widget) const { widget.set_window(xmin, xmax, ymin, ymax); } private: double xmin, xmax, ymin, ymax; }; class Qt_widget_history : public QObject { Q_OBJECT public: Qt_widget_history(Qt_widget* parent, const char* name = 0 ); signals: void backwardAvaillable(bool); void forwardAvaillable(bool); public slots: void backward(); void forward(); private: struct Free { void operator()(History_atom* atom) const { delete atom; } }; public slots: void save(); void clear() { std::for_each(history_list.begin(), history_list.end(), Free()); history_list.clear(); it = history_list.begin(); emit backwardAvaillable(false); emit forwardAvaillable(false); } private: void restore(){ disconnect( widget, SIGNAL(rangesChanged()), this, SLOT(save())); (*it)->restore(*widget); connect(widget, SIGNAL(rangesChanged()), this, SLOT(save())); widget->redraw(); } private: std::list history_list; std::list::iterator it; Qt_widget* widget; }; } // namespace CGAL end #endif // CGAL_QT_WIDGET_HISTORY_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/forward_decl_window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/forward_decl_window0000644000175000017500000000306011344301501031274 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/forward_decl_window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_IO_FORWARD_DECL_WINDOW_STREAM_H #define CGAL_IO_FORWARD_DECL_WINDOW_STREAM_H #if defined(CGAL_USE_CGAL_WINDOW) CGAL_BEGIN_NAMESPACE class window; CGAL_END_NAMESPACE #else #include class leda_window; #endif CGAL_BEGIN_NAMESPACE #if defined(CGAL_USE_CGAL_WINDOW) typedef CGAL::window Window_stream; #else typedef leda_window Window_stream; #endif CGAL_END_NAMESPACE #endif // CGAL_IO_FORWARD_DECL_WINDOW_STREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Nef_3.h0000644000175000017500000000504011344301501030441 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Nef_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_QT_WIDGET_NEF_3_H #define CGAL_QT_WIDGET_NEF_3_H #include #include CGAL_BEGIN_NAMESPACE template class Qt_widget_Nef_3 : public Qt_widget_OpenGL { public: Qt_widget_Nef_3(const Nef_polyhedron& N) : Qt_widget_OpenGL(600,600,0.5) { object_ = new CGAL::OGL::Polyhedron(); CGAL::OGL::Nef3_Converter::convert_to_OGLPolyhedron(N, static_cast(object_)); resize(window_width,window_height); main = new QPopupMenu; sub1 = new QPopupMenu; sub2 = new QPopupMenu; sub3 = new QPopupMenu; sub1->insertItem("Reset", RESET_CONTROL); sub1->insertItem("Rotate", ROTATE); sub1->insertItem("Scale", SCALE); sub1->insertItem("Translate in XY", TRANSLATE); // sub1->insertItem("Translate in Z", TRANS_Z); QObject::connect(sub1, SIGNAL(activated(int)), this, SLOT(slotControlMenu(int))); sub2->insertItem("Boundary", CGAL::OGL::SNC_BOUNDARY); sub2->insertItem("Skeleton", CGAL::OGL::SNC_SKELETON); QObject::connect(sub2, SIGNAL(activated(int)), this, SLOT(slotRenderMenu(int))); sub3->insertItem("Toggle Axes", CGAL::OGL::SNC_AXES); QObject::connect(sub3, SIGNAL(activated(int)), this, SLOT(slotOptionsMenu(int))); main->insertItem("&Control", sub1); main->insertItem("&Render", sub2); main->insertItem("&Options", sub3); // main->insertItem("&Persp/Ortho", this, SLOT(slotPerspective())); main->insertItem("&Toggle Fullscreen", this, SLOT(slotFullscreen())); main->insertItem("&Quit", qApp, SLOT(quit())); } ~Qt_widget_Nef_3() { delete object_; } }; CGAL_END_NAMESPACE #endif // CGAL_QT_WIDGET_NEF_3_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/triangulation_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/triangulation_Windo0000644000175000017500000000706511344301501031303 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/triangulation_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Olivier Devillers // Andreas Fabri // Monique Teillaud // Mariette Yvinec #ifdef CGAL_TRIANGULATION_2_H #ifndef CGAL_WINDOW_STREAM_TRIANGULATION_2_H #define CGAL_WINDOW_STREAM_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds> Window_stream& operator<<(Window_stream& os, const Triangulation_2 &t) { return t.draw_triangulation(os); } CGAL_END_NAMESPACE #endif // CGAL_WINDOW_STREAM_TRIANGULATION_2_H #endif // CGAL_TRIANGULATION_2_H #ifdef CGAL_DELAUNAY_TRIANGULATION_2_H #ifndef CGAL_WINDOW_STREAM_DELAUNAY_TRIANGULATION_2_H #define CGAL_WINDOW_STREAM_DELAUNAY_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds > Window_stream& operator<<(Window_stream& os, const Delaunay_triangulation_2 &dt) { return dt.draw_triangulation(os); } CGAL_END_NAMESPACE #endif // CGAL_WINDOW_STREAM_DELAUNAY_TRIANGULATION_2_H #endif // CGAL_DELAUNAY_TRIANGULATION_2_H #ifdef CGAL_CONSTRAINED_TRIANGULATION_2_H #ifndef CGAL_WINDOW_STREAM_CONSTRAINED_TRIANGULATION_2_H #define CGAL_WINDOW_STREAM_CONSTRAINED_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds> Window_stream& operator<<(Window_stream& os, const Constrained_triangulation_2 &t) { return t.draw_triangulation(os); } CGAL_END_NAMESPACE #endif // CGAL_WINDOW_STREAM_CONSTRAINED_TRIANGULATION_2_H #endif // CGAL_CONSTRAINED_TRIANGULATION_2_H #ifdef CGAL_WEIGHTED_POINT_H #ifndef CGAL_WINDOW_STREAM_WEIGHTED_POINT_H #define CGAL_WINDOW_STREAM_WEIGHTED_POINT_H CGAL_BEGIN_NAMESPACE template < class Point, class We > Window_stream& operator<<(Window_stream& os, const Weighted_point< Point, We > &p) { double cx = to_double(p.point().x()), cy = to_double(p.point().y()), rr = to_double(p.weight()); os< Window_stream& operator>>(Window_stream &os, Weighted_point< Point, We > &wp) { double cx, cy, x1, y1; os.read_mouse(cx,cy); os.read_mouse_circle(cx,cy, x1, y1); //os.read_mouse(x1,y1); Point center(cx,cy); We sr = We(CGAL_CLIB_STD::sqrt( CGAL_NTS square(cx-x1)+ CGAL_NTS square(cy-y1) ) ); os.draw_circle(cx, cy , sr); wp = Weighted_point< Point, We >(center, CGAL_NTS square(sr)); return os; } CGAL_END_NAMESPACE #endif // CGAL_WINDOW_STREAM_WEIGHTED_POINT_H #endif // CGAL_WEIGHTED_POINT_H #ifdef CGAL_REGULAR_TRIANGULATION_2_H #ifndef CGAL_WINDOW_STREAM_REGULAR_TRIANGULATION_2_H #define CGAL_WINDOW_STREAM_REGULAR_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds > Window_stream& operator<<(Window_stream& os, Regular_triangulation_2 &t) { return t.draw_triangulation(os); } CGAL_END_NAMESPACE #endif // CGAL_WINDOW_STREAM_REGULAR_TRIANGULATION_2_H #endif // CGAL_REGULAR_TRIANGULATION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_window.h0000644000175000017500000004431711344301501030007 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_window.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_LEDA_WINDOW_H #define CGAL_LEDA_WINDOW_H #include #include #include #include #define Str(x) #x #define Xstr(x) Str(x) #define OP CGAL CGAL_VERSION CGAL_BEGIN_NAMESPACE typedef CGAL::window Window_stream; inline CGAL::window& operator<<(CGAL::window& w, const Color& c) { w.set_fg_color(CGAL::color(c.red(), c.green(), c.blue())); return w; } inline void cgalize(CGAL::window& w) { w.set_frame_label(Xstr(OP)); w.set_icon_label("CGAL"); w.set_line_width( 2); w.set_icon_pixrect( w.create_pixrect((const char**) cgal_logo)); } inline CGAL::window* create_demo_window( float w = 512.0, float h = 512.0, const char* str = "CGAL", double x_extension = 1.0) { CGAL::window* Wptr = new CGAL::window((int) w, (int) h); cgalize( *Wptr); double y_extension = x_extension * h / w; Wptr->init(-x_extension, x_extension, -y_extension); Wptr->set_frame_label( str); return Wptr; } inline CGAL::window* create_and_display_demo_window(float w = 512.0, float h = 512.0, const char* str = "CGAL", double x_extension = 1.0) { CGAL::window* Wptr = new CGAL::window((int) w, (int) h); cgalize( *Wptr); double y_extension = x_extension * h / w; Wptr->init(-x_extension, x_extension, -y_extension); Wptr->set_frame_label( str); Wptr->display(); return Wptr; } CGAL_END_NAMESPACE #endif // CGAL_LEDA_WINDOW_H CGAL_BEGIN_NAMESPACE // Each of the following operators is individually // protected against multiple inclusion. #ifdef CGAL_POINT_2_H #ifndef CGAL_LEDA_WINDOW_POINT_2 #define CGAL_LEDA_WINDOW_POINT_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Point_2& p) { double x = CGAL::to_double(p.x()); double y = CGAL::to_double(p.y()); w.draw_point(x,y); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Point_2& p) { typedef typename R::RT RT; CGAL::window_point l_p; drawing_mode save = w.set_mode(xor_mode); if (w.read(l_p)) { double x = l_p.xcoord(); double y = l_p.ycoord(); w.draw_point(x,y); w.set_mode( save); w.draw_point(x,y); p = Point_2( RT(x), RT(y)); } else { w.set_mode( save); } return w; } template< class R > CGAL::window& read(CGAL::window& w, Point_2& p) { typedef typename R::RT RT; CGAL::window_point l_p; if (w.read(l_p)) { double x = l_p.xcoord(); double y = l_p.ycoord(); p = Point_2( RT(x), RT(y)); } return w; } template void read_mouse_plus(CGAL::window& w, Point_2& p, int& button) { typedef typename R::RT RT; double x, y; button = w.read_mouse(x,y); w.draw_point(x,y); p = Point_2(RT(x), RT(y)); } #endif // CGAL_LEDA_WINDOW_POINT_2 #endif // CGAL_POINT_2_H #ifdef CGAL_SEGMENT_2_H #ifndef CGAL_LEDA_WINDOW_SEGMENT_2 #define CGAL_LEDA_WINDOW_SEGMENT_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Segment_2& s) { w.draw_segment(CGAL::to_double(s.source().x()), CGAL::to_double(s.source().y()), CGAL::to_double(s.target().x()), CGAL::to_double(s.target().y())); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Segment_2& s) { typedef typename R::RT RT; CGAL::window_point l_p1, l_p2; drawing_mode save = w.set_mode(xor_mode); if ( w.read( l_p1, l_p2)) { double x1 = l_p1.xcoord(); double y1 = l_p1.ycoord(); double x2 = l_p2.xcoord(); double y2 = l_p2.ycoord(); w.set_mode( save); w.draw_segment(x1,y1, x2, y2); s = Segment_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } else { w.set_mode( save); } return w; } template< class R > CGAL::window& read(CGAL::window& w, Segment_2& s) { typedef typename R::RT RT; CGAL::window_point l_p1, l_p2; if ( w.read( l_p1, l_p2)) { double x1 = l_p1.xcoord(); double y1 = l_p1.ycoord(); double x2 = l_p2.xcoord(); double y2 = l_p2.ycoord(); s = Segment_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_LEDA_WINDOW_SEGMENT_2 #endif // CGAL_SEGMENT_2_H #ifdef CGAL_LINE_2_H #ifndef CGAL_LEDA_WINDOW_LINE_2 #define CGAL_LEDA_WINDOW_LINE_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Line_2& l) { Point_2 p1 = l.point(), p2 = p1 + l.direction().vector(); w.draw_line(CGAL::to_double(p1.x()), CGAL::to_double(p1.y()), CGAL::to_double(p2.x()), CGAL::to_double(p2.y())); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Line_2& l) { typedef typename R::RT RT; CGAL::window_point l_p1, l_p2; drawing_mode save = w.set_mode(xor_mode); if ( w.read( l_p1, l_p2)) { double x1 = l_p1.xcoord(); double y1 = l_p1.ycoord(); double x2 = l_p2.xcoord(); double y2 = l_p2.ycoord(); w.set_mode( save); w.draw_line(x1,y1, x2, y2); l = Line_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } else { w.set_mode( save); } return w; } template< class R > CGAL::window& read(CGAL::window& w, Line_2& l) { typedef typename R::RT RT; CGAL::window_point l_p1, l_p2; if ( w.read( l_p1,l_p2)) { double x1 = l_p1.xcoord(); double y1 = l_p1.ycoord(); double x2 = l_p2.xcoord(); double y2 = l_p2.ycoord(); l = Line_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_LEDA_WINDOW_LINE_2 #endif //CGAL_LINE_2_H #ifdef CGAL_RAY_2_H #ifndef CGAL_LEDA_WINDOW_RAY_2 #define CGAL_LEDA_WINDOW_RAY_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Ray_2& r) { Point_2 p = r.point(0); Point_2 q = r.point(1); w.draw_ray(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(q.x()), CGAL::to_double(q.y())); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Ray_2& r) { typedef typename R::RT RT; CGAL::window_point l_p1, l_p2; drawing_mode save = w.set_mode(xor_mode); if ( w.read( l_p1, l_p2)) { double x1 = l_p1.xcoord(); double y1 = l_p1.ycoord(); double x2 = l_p2.xcoord(); double y2 = l_p2.ycoord(); w.set_mode( save); r = Ray_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); w << r; } else { w.set_mode( save); } return w; } template< class R > CGAL::window& read(CGAL::window& w, Ray_2& r) { typedef typename R::RT RT; CGAL::window_point l_p1, l_p2; if ( w.read( l_p1, l_p2)) { double x1 = l_p1.xcoord(); double y1 = l_p1.ycoord(); double x2 = l_p2.xcoord(); double y2 = l_p2.ycoord(); r = Ray_2(Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); } return w; } #endif // CGAL_LEDA_WINDOW_RAY_2 #endif //CGAL_RAY_2_H #ifdef CGAL_TRIANGLE_2_H #ifndef CGAL_LEDA_WINDOW_TRIANGLE_2 #define CGAL_LEDA_WINDOW_TRIANGLE_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Triangle_2& t) { double x0 = CGAL::to_double(t.vertex(0).x()), y0 = CGAL::to_double(t.vertex(0).y()), x1 = CGAL::to_double(t.vertex(1).x()), y1 = CGAL::to_double(t.vertex(1).y()), x2 = CGAL::to_double(t.vertex(2).x()), y2 = CGAL::to_double(t.vertex(2).y()); CGAL::color cl = w.get_fill_color(); if (cl != CGAL::invisible) { // draw filled triangle ... w.draw_filled_triangle(CGAL::window_point(x0,y0), CGAL::window_point(x1,y1), CGAL::window_point(x2,y2), cl); } w.draw_segment(x0, y0, x1, y1); w.draw_segment(x1, y1, x2, y2); w.draw_segment(x2, y2, x0, y0); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Triangle_2& t) { typedef typename R::RT RT; double x,y; int key = 0; w.set_state( 1); CGAL::window_point first, second, third; drawing_mode save = w.set_mode(xor_mode); if ( !( w.read(first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_seg( first.x(), first.y(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } else { w.draw_segment( first.x(), first.y(), x, y); second = CGAL::window_point( x, y); } key = w.read_mouse_seg( second.x(), second.y(), x, y); if ( key == MOUSE_BUTTON(3)) { w.draw_segment( first.x(), first.y(), second.x(), second.y() ); w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } else { w.draw_segment( second.x(), second.y(), x, y); third = CGAL::window_point( x, y); } w.draw_segment( first.x(), first.y(), second.x(), second.y() ); w.draw_segment( second.x(), second.y(), third.x(), third.y() ); double x0 = first.x(); double y0 = first.y(); double x1 = second.x(); double y1 = second.y(); double x2 = third.x(); double y2 = third.y(); w.set_mode( save); CGAL::color cl = w.get_fill_color(); if (cl != CGAL::invisible) { // draw filled triangle ... w.draw_filled_triangle(CGAL::window_point(x0,y0), CGAL::window_point(x1,y1), CGAL::window_point(x2,y2), cl); } w.draw_segment(x0,y0, x1, y1); w.draw_segment(x1,y1, x2, y2); w.draw_segment(x2,y2, x0, y0); t = Triangle_2(Point_2( RT(x0), RT(y0)), Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); return w; } template< class R > CGAL::window& read(CGAL::window& w, Triangle_2& t) { typedef typename R::RT RT; double x,y; int key = 0; w.set_state( 1); CGAL::window_point first, second, third; drawing_mode save = w.set_mode(xor_mode); if ( !( w.read(first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_seg( first.x(), first.y(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } else { w.draw_segment( first.x(), first.y(), x, y); second = CGAL::window_point( x, y); } key = w.read_mouse_seg( second.x(), second.y(), x, y); if ( key == MOUSE_BUTTON(3)) { w.draw_segment( first.x(), first.y(), second.x(), second.y() ); w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } else { w.draw_segment( second.x(), second.y(), x, y); third = CGAL::window_point( x, y); } w.draw_segment( first.x(), first.y(), second.x(), second.y() ); w.draw_segment( second.x(), second.y(), third.x(), third.y() ); double x0 = first.x(); double y0 = first.y(); double x1 = second.x(); double y1 = second.y(); double x2 = third.x(); double y2 = third.y(); w.set_mode( save); t = Triangle_2(Point_2( RT(x0), RT(y0)), Point_2( RT(x1), RT(y1)), Point_2( RT(x2), RT(y2))); return w; } #endif // CGAL_LEDA_WINDOW_TRIANGLE_2 #endif // CGAL_TRIANGLE_2_H #ifdef CGAL_CIRCLE_2_H #ifndef CGAL_LEDA_WINDOW_CIRCLE_2 #define CGAL_LEDA_WINDOW_CIRCLE_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Circle_2& c) { double cx = CGAL::to_double(c.center().x()), cy = CGAL::to_double(c.center().y()), r = CGAL::to_double(c.squared_radius()); CGAL::color cl = w.get_fill_color(); if (cl != CGAL::invisible) { // draw filled circle ... w.draw_disc(cx, cy , std::sqrt(r), cl); } w.draw_circle(cx, cy , std::sqrt(r)); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Circle_2& c) { typedef typename R::RT RT; double x,y; int key = 0; w.set_state( 1); CGAL::window_point p; drawing_mode save = w.set_mode(xor_mode); if ( !( w.read( p))) { w.set_mode( save); return w; } double cx = p.x(); double cy = p.y(); Point_2 center = Point_2( RT(cx), RT(cy)); int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_circle(cx, cy, x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } double dx = x - cx; double dy = y - cy; double sqr = dx*dx+dy*dy; w.set_mode( save); w.set_buttons( save_but); CGAL::color cl = w.get_fill_color(); if (cl != CGAL::invisible) { // draw filled circle ... w.draw_disc(cx, cy , std::sqrt(sqr), cl); } w.draw_circle(cx, cy , std::sqrt(sqr)); c = Circle_2(center, RT(sqr)); return w; } template< class R > CGAL::window& read(CGAL::window& w, Circle_2& c) { typedef typename R::RT RT; double x,y; int key = 0; w.set_state( 1); CGAL::window_point p; drawing_mode save = w.set_mode(xor_mode); if ( !( w.read( p))) { w.set_mode( save); return w; } double cx = p.x(); double cy = p.y(); Point_2 center = Point_2( RT(cx), RT(cy)); int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_circle(cx, cy, x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } double dx = x - cx; double dy = y - cy; double sqr = dx*dx+dy*dy; w.set_mode( save); w.set_buttons( save_but); c = Circle_2(center, RT(sqr)); return w; } #endif // CGAL_LEDA_WINDOW_CIRCLE_2 #endif // CGAL_CIRCLE_2_H #ifdef CGAL_ISO_RECTANGLE_2_H #ifndef CGAL_LEDA_WINDOW_ISO_RECTANGLE_2 #define CGAL_LEDA_WINDOW_ISO_RECTANGLE_2 template< class R > CGAL::window& operator<<(CGAL::window& w, const Iso_rectangle_2& r) { double xmin = CGAL::to_double(r.min().x()), ymin = CGAL::to_double(r.min().y()), xmax = CGAL::to_double(r.max().x()), ymax = CGAL::to_double(r.max().y()); CGAL::color cl = w.get_fill_color(); if (cl != CGAL::invisible) { // draw filled rectangle ... w.draw_filled_rectangle(xmin, ymin, xmax, ymax, cl); } w.draw_segment(xmin, ymin, xmax, ymin); w.draw_segment(xmax, ymin, xmax, ymax); w.draw_segment(xmax, ymax, xmin, ymax); w.draw_segment(xmin, ymax, xmin, ymin); return w; } template< class R > CGAL::window& operator>>(CGAL::window& w, Iso_rectangle_2& r) { typedef typename R::RT RT; double x,y; int key = 0; w.set_state( 1); CGAL::window_point first; drawing_mode save = w.set_mode(xor_mode); if ( !( w.read( first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_rect( first.x(), first.y(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } r = Iso_rectangle_2(Point_2( RT(first.x()), RT(first.y())), Point_2( RT(x), RT(y))); w.set_mode( save); CGAL::color cl = w.get_fill_color(); if (cl != CGAL::invisible) { // draw filled rectangle ... w.draw_filled_rectangle(first.x(), first.y(), x, y, cl); } w.draw_rectangle( first.x(), first.y(), x, y); w.set_buttons( save_but); return w; } template< class R > CGAL::window& read(CGAL::window& w, Iso_rectangle_2& r) { typedef typename R::RT RT; double x,y; int key = 0; w.set_state( 1); CGAL::window_point first; drawing_mode save = w.set_mode(xor_mode); if ( !( w.read( first))) { w.set_mode( save); return w; } int save_but[8]; w.std_buttons(save_but); key = w.read_mouse_rect( first.x(), first.y(), x, y); if ( key == MOUSE_BUTTON(3)) { w.set_buttons( save_but); w.set_mode( save); w.set_state( 0); return w; } r = Iso_rectangle_2(Point_2( RT(first.x()), RT(first.y())), Point_2( RT(x), RT(y))); w.set_mode( save); w.set_buttons( save_but); return w; } #endif // CGAL_LEDA_WINDOW_ISO_RECTANGLE_2 #endif // CGAL_ISO_RECTANGLE_2_H #ifdef CGAL_BBOX_2_H #ifndef CGAL_LEDA_WINDOW_BBOX_2 #define CGAL_LEDA_WINDOW_BBOX_2 inline CGAL::window& operator<<(CGAL::window& w, const Bbox_2& b) { line_style style = w.set_line_style(dotted); double xmin = b.xmin(), ymin = b.ymin(), xmax = b.xmax(), ymax = b.ymax(); w.draw_segment(xmin, ymin, xmax, ymin); w.draw_segment(xmax, ymin, xmax, ymax); w.draw_segment(xmax, ymax, xmin, ymax); w.draw_segment(xmin, ymax, xmin, ymin); w.set_line_style(style); return w; } #endif // CGAL_LEDA_WINDOW_BBOX_2 #endif // CGAL_BBOX_2_H CGAL_END_NAMESPACE #ifndef IO_TRIANGULATION_WINDOW_STREAM_H #include #endif // IO_TRIANGULATION_WINDOW_STREAM_H #include #include #ifndef IO_POLYGON_WINDOW_STREAM_H #include #endif // IO_POLYGON_WINDOW_STREAM_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_rotation_layer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_rotation_0000644000175000017500000001532311344301501031264 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_rotation_layer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_ROTATION_LAYER_H #define CGAL_QT_WIDGET_ROTATION_LAYER_H #include #include #include #include #include #include #include #include typedef CGAL::Simple_cartesian SCD; typedef CGAL::Point_2 Point; typedef CGAL::Vector_2 Vector; typedef CGAL::Direction_2 Direction; typedef CGAL::Aff_transformation_2 Transformation; namespace CGAL { class Qt_widget_rotation_layer : public Qt_widget_layer { public: Qt_widget_rotation_layer(QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), wasrepainted(true), on_first(false){}; private: QCursor oldcursor; void draw(){ wasrepainted = true; }; /* void timerEvent( QTimerEvent *) { if(on_first) widget->setCursor(QCursor( QPixmap( (const char**)holddown_xpm))); else widget->setCursor(QCursor( QPixmap( (const char**)hand_xpm))); } */ bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == Qt::LeftButton && is_pure(e->state())) { widget->setCursor(QCursor( QPixmap( (const char**)holddown_xpm))); if (!on_first){ first_x = e->x(); first_y = e->y(); on_first = true; } Point end_point[4] = {Point(11, 25), Point(11, 25), Point(11, 25), Point(11, 25)}; for(int i=0; i<4; i++) end_point[i] = (*t)(end_point[i]); //Point_2 first_line_end1(11, 25), first_line_end2(11, 0); //Point_2 second_line_end1(25, 0), second_line_end2(25, 13); //first_line_end1 = (*t)(first_arrow_end); //second_arrow_end = (*t)(second_arrow_end); //save the initial raster mode RasterOp old = widget->rasterOp(); widget->setRasterOp(XorROP); widget->lock(); *widget << CGAL::WHITE; widget->get_painter().drawLine(11, 0, 11, 25); widget->get_painter().drawLine(0, 13, 25, 13); widget->get_painter().drawLine(11, 0, 9, 5); widget->get_painter().drawLine(11, 0, 13, 5); widget->get_painter().drawLine(25, 13, 20, 11); widget->get_painter().drawLine(25, 13, 20, 15); *widget << CGAL::RED; widget->unlock(); widget->setRasterOp(old); } }; void mouseReleaseEvent(QMouseEvent *e) { if(e->button() == Qt::LeftButton && is_pure(e->state())) { /* double x, y, xfirst2, yfirst2; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->x_real(first_x, xfirst2); widget->y_real(first_y, yfirst2); double xmin, xmax, ymin, ymax, distx, disty; if(x < xfirst2) {xmin = x; xmax = xfirst2;} else {xmin = xfirst2; xmax = x;}; if(y < yfirst2) {ymin = y; ymax = yfirst2;} else {ymin = yfirst2; ymax = y;}; distx = xfirst2 - x; disty = yfirst2 - y; widget->move_center(distx, disty); */ /* //(*t) = tprim * (*t); on_first = false; */ double xc = widget->x_min() + (widget->x_max() - widget->x_min())/2; double yc = widget->y_min() + (widget->y_max() - widget->y_min())/2; Transformation tprim(CGAL::ROTATION, Direction(xc+0.0001, yc+0.0001), 1, 100); //Transformation tprim(CGAL::TRANSLATION, Vector(-0.5, 0)); //Transformation tprim(CGAL::SCALING, 1.2); (*t) = (*t) * tprim; on_first = false; widget->setCursor(QCursor( QPixmap( (const char**)hand_xpm))); widget->redraw(); } } /* void mouseMoveEvent(QMouseEvent *e) { char tempc1[130], tempc2[40]; double xcoord, ycoord; if(on_first) { int x = e->x(); int y = e->y(); //save the initial raster mode RasterOp old = widget->rasterOp(); widget->setRasterOp(XorROP); widget->lock(); *widget << CGAL::GRAY; if(!wasrepainted) { widget->x_real(x2 - first_x, xcoord); widget->x_real(y2 - first_y, ycoord); CGAL_CLIB_STD::sprintf(tempc1, " dx=%20.6f", xcoord); CGAL_CLIB_STD::sprintf(tempc2, ", dy=%20.6f", ycoord); strcat(tempc1, tempc2); widget->get_painter().drawLine(first_x, first_y, x2, y2); *widget << CGAL::GREEN; widget->get_painter().drawText(x2, y2, tempc1, 49); *widget << CGAL::GRAY; } widget->x_real(x - first_x, xcoord); widget->x_real(y - first_y, ycoord); CGAL_CLIB_STD::sprintf(tempc1, " dx=%20.6f", xcoord); CGAL_CLIB_STD::sprintf(tempc2, ", dy=%20.6f", ycoord); strcat(tempc1, tempc2); widget->get_painter().drawLine(first_x, first_y, x, y); *widget << CGAL::GREEN; widget->get_painter().drawText(x, y, tempc1, 49); widget->unlock(); widget->setRasterOp(old); //save the last coordinates to redraw the screen x2 = x; y2 = y; wasrepainted = false; } }; */ void activating() { t = widget->get_transformation(); oldcursor = widget->cursor(); widget->setCursor(QCursor( QPixmap( (const char**)hand_xpm))); wasrepainted = true; // startTimer( 100 ); }; void deactivating() { widget->setCursor(oldcursor); // killTimers(); }; int first_x, first_y; int x2, y2; bool wasrepainted; bool on_first; Transformation *t; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_ROTATION_LAYER_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/generic_print_polyhedron.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/generic_print_polyh0000644000175000017500000000514711344301501031325 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/generic_print_polyhedron.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_GENERIC_PRINT_POLYHEDRON_H #define CGAL_IO_GENERIC_PRINT_POLYHEDRON_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template void generic_print_polyhedron( std::ostream& out, const Polyhedron& P, Writer& writer) { // writes P to `out' in the format provided by `writer'. typedef typename Polyhedron::Vertex Vertex; typedef typename Polyhedron::Vertex_const_iterator VCI; typedef typename Polyhedron::Facet_const_iterator FCI; typedef typename Polyhedron::Halfedge_around_facet_const_circulator HFCC; // Print header. writer.write_header( out, P.size_of_vertices(), P.size_of_halfedges(), P.size_of_facets()); for( VCI vi = P.vertices_begin(); vi != P.vertices_end(); ++vi) { writer.write_vertex( ::CGAL::to_double( vi->point().x()), ::CGAL::to_double( vi->point().y()), ::CGAL::to_double( vi->point().z())); } typedef Inverse_index< VCI> Index; Index index( P.vertices_begin(), P.vertices_end()); writer.write_facet_header(); for( FCI fi = P.facets_begin(); fi != P.facets_end(); ++fi) { HFCC hc = fi->facet_begin(); HFCC hc_end = hc; std::size_t n = circulator_size( hc); CGAL_assertion( n >= 3); writer.write_facet_begin( n); do { writer.write_facet_vertex_index( index[ VCI(hc->vertex())]); ++hc; } while( hc != hc_end); writer.write_facet_end(); } writer.write_footer(); } CGAL_END_NAMESPACE #endif // CGAL_IO_GENERIC_PRINT_POLYHEDRON_H // // EOF // ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_polyline_traits_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_polyline_traits0000644000175000017500000000340111344301501031276 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_polyline_traits_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifdef CGAL_ARR_POLYLINE_TRAITS_H #ifndef CGAL_ARR_POLYLINE_TRAITS_WINDOW_STREAM_H #define CGAL_ARR_POLYLINE_TRAITS_WINDOW_STREAM_H #include #include CGAL_BEGIN_NAMESPACE template Window_stream& operator<< (Window_stream& ws, const Polyline_2& pl) { typedef Polyline_2 Curve_2; typedef typename Curve_2::const_iterator Points_iterator; typedef typename Curve_2::Segment_2 Segment_2; Points_iterator its = pl.begin(); // Disregard empty polylines: if (its == pl.end()) return (ws); // Draw the first point. ws << (*its); // Draw each segment of the polyline. Points_iterator itt = pl.begin(); itt++; while (itt != pl.end()) { ws << Segment_2(*its, *itt); its++; itt++; } // Now (*its) is the last polyline point -- draw it as well. ws << (*its); return (ws); } CGAL_END_NAMESPACE #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_layer.h0000644000175000017500000000527311344301501030633 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_layer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent Rineau & Radu Ursu #ifndef CGAL_QT_WIDGET_LAYER_H #define CGAL_QT_WIDGET_LAYER_H #include #include #include #include namespace CGAL { class Qt_widget_layer : public QObject { Q_OBJECT public: Qt_widget_layer(QObject* parent = 0, const char* name = 0) : QObject(parent, name), does_eat_events(false), active(false){}; // Event handlers virtual void mousePressEvent(QMouseEvent *) {} ; virtual void mouseReleaseEvent(QMouseEvent *) {}; virtual void wheelEvent(QWheelEvent *) {}; virtual void mouseDoubleClickEvent(QMouseEvent *) {}; virtual void mouseMoveEvent(QMouseEvent *) {}; virtual void keyPressEvent(QKeyEvent *) {}; virtual void keyReleaseEvent(QKeyEvent *) {}; virtual void enterEvent(QEvent *) {}; virtual void leaveEvent(QEvent *) {}; virtual bool event(QEvent *e) {QObject::event(e); return true;}; bool is_active(){return active;}; //return true if this layer is active bool does_eat_events; public slots: virtual void draw(){}; void stateChanged(int); bool activate(); //activate and return true if it was not active bool deactivate();//deactivate and return true if it was active signals: void activated(Qt_widget_layer*); void deactivated(Qt_widget_layer*); private: void attach(Qt_widget *w);//attach Qt_widget to the tool bool active; //true if this layers is active friend class Qt_widget; protected: Qt_widget *widget;//the pointer to the widget virtual void activating(){}; virtual void deactivating(){}; }; } // namespace CGAL end #endif // CGAL_QT_WIDGET_LAYER_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Min_ellipse_2_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Min_ellipse_2_Windo0000644000175000017500000000571411344301501031103 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Min_ellipse_2_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner // Each of the following operators is individually // protected against multiple inclusion. // Window_stream I/O operators // =========================== // includes #include #include // Optimisation_ellipse_2 // ---------------------- #ifdef CGAL_OPTIMISATION_ELLIPSE_2_H #ifndef CGAL_IO_WINDOW_STREAM_OPTIMISATION_ELLIPSE_2 #define CGAL_IO_WINDOW_STREAM_OPTIMISATION_ELLIPSE_2 template< class Traits_ > CGAL::Window_stream& operator << ( CGAL::Window_stream &ws, const CGAL::Optimisation_ellipse_2& oe) { switch ( oe.n_boundary_points) { case 0: break; case 1: ws << oe.boundary_point1; break; case 2: { double px1( CGAL::to_double( oe.boundary_point1.x())); double py1( CGAL::to_double( oe.boundary_point1.y())); double px2( CGAL::to_double( oe.boundary_point2.x())); double py2( CGAL::to_double( oe.boundary_point2.y())); ws.draw_segment( px1, py1, px2, py2); } break; case 3: case 4: case 5: Cartesian::Conic_2 dc; oe.double_conic(dc); ws << dc; break; default: CGAL_optimisation_assertion( ( oe.n_boundary_points >= 0) && ( oe.n_boundary_points <= 5) ); } return( ws); } #endif // CGAL_IO_WINDOW_STREAM_OPTIMISATION_ELLIPSE_2 #endif // CGAL_OPTIMISATION_ELLIPSE_2_H // Min_ellipse_2 // ------------- #ifdef CGAL_MIN_ELLIPSE_2_H #ifndef CGAL_IO_WINDOW_STREAM_MIN_ELLIPSE_2 #define CGAL_IO_WINDOW_STREAM_MIN_ELLIPSE_2 template< class Traits_ > CGAL::Window_stream& operator << ( CGAL::Window_stream &ws, const CGAL::Min_ellipse_2& min_ellipse) { typedef typename CGAL::Min_ellipse_2::Point_iterator Point_iterator; Point_iterator first( min_ellipse.points_begin()); Point_iterator last ( min_ellipse.points_end()); for ( ; first != last; ++first) ws << *first; return( ws << min_ellipse.ellipse()); } #endif // CGAL_IO_WINDOW_STREAM_MIN_ELLIPSE_2 #endif // CGAL_MIN_ELLIPSE_2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Polygon_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Polygon_20000644000175000017500000000334311344301501031135 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Polygon_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_POLYGON_2_H #define CGAL_QT_WIDGET_POLYGON_2_H #include #include namespace CGAL{ template Qt_widget& operator<<(Qt_widget& w, const Polygon_2& pol) { typedef typename Polygon_2::Vertex_const_iterator VI; QPointArray array; array.resize(pol.size()); unsigned int n=0; for(VI i=pol.vertices_begin();i!=pol.vertices_end();i++) { array.setPoint(n++,w.x_pixel(to_double(i->x())), w.y_pixel(to_double(i->y()))); } w.get_painter().drawPolygon(array); w.do_paint(); return w; } }//end namespace CGAL #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_scan_OFF.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_scan_OFF0000644000175000017500000001073511344301501031102 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Polyhedron_scan_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_POLYHEDRON_SCAN_OFF_H #define CGAL_IO_POLYHEDRON_SCAN_OFF_H 1 #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class HDS> class Polyhedron_scan_OFF : public Modifier_base { protected: std::istream& m_in; File_header_OFF m_file_header; public: typedef HDS Halfedge_data_structure; // DEFINITION // // Polyhedron_scan_OFF is a polyhedral surface builder. // It scans a polyhedron given in OFF from a stream and appends it // incrementally using the incremental builder. Polyhedron_scan_OFF( std::istream& in, bool verbose = false) : m_in(in), m_file_header( verbose) {} // Activation void operator()( HDS& hds); const File_header_OFF& header() const { return m_file_header; } }; template < class HDS > void Polyhedron_scan_OFF:: operator()( HDS& target) { File_scanner_OFF scanner( m_in, m_file_header.verbose()); if ( ! m_in) { if ( scanner.verbose()) { std::cerr << " " << std::endl; std::cerr << "Polyhedron_scan_OFF::" << std::endl; std::cerr << "operator(): input error: file format is not in " "OFF." << std::endl; } return; } m_file_header = scanner; // Remember file header after return. Polyhedron_incremental_builder_3 B( target, scanner.verbose()); B.begin_surface( scanner.size_of_vertices(), scanner.size_of_facets(), scanner.size_of_halfedges()); typedef typename HDS::Traits Traits; typedef typename Traits::Point_3 Point; // read in all vertices int i; for ( i = 0; i < scanner.size_of_vertices(); i++) { Point p; file_scan_vertex( scanner, p); B.add_vertex( p); scanner.skip_to_next_vertex( i); } if ( ! m_in || B.error()) { B.rollback(); m_in.clear( std::ios::badbit); return; } // read in all facets for ( i = 0; i < scanner.size_of_facets(); i++) { B.begin_facet(); Integer32 no; scanner.scan_facet( no, i); if( ! m_in || B.error() || no < 3) { if ( scanner.verbose()) { std::cerr << " " << std::endl; std::cerr << "Polyhedron_scan_OFF::" << std::endl; std::cerr << "operator()(): input error: facet " << i << " has less than 3 vertices." << std::endl; } B.rollback(); m_in.clear( std::ios::badbit); return; } for ( int j = 0; j < no; j++) { Integer32 index; scanner.scan_facet_vertex_index( index, i); B.add_vertex_to_facet( index); } B.end_facet(); scanner.skip_to_next_facet( i); } if ( ! m_in || B.error()) { B.rollback(); m_in.clear( std::ios::badbit); return; } if ( B.check_unconnected_vertices()) { if ( ! B.remove_unconnected_vertices()) { if ( scanner.verbose()) { std::cerr << " " << std::endl; std::cerr << "Polyhedron_scan_OFF::" << std::endl; std::cerr << "operator()(): input error: cannot " "succesfully remove isolated vertices." << std::endl; } B.rollback(); m_in.clear( std::ios::badbit); return; } } B.end_surface(); } CGAL_END_NAMESPACE #endif // CGAL_IO_POLYHEDRON_SCAN_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/generic_copy_OFF.h0000644000175000017500000000737711344301501030657 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/generic_copy_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_GENERIC_COPY_OFF_H #define CGAL_IO_GENERIC_COPY_OFF_H 1 #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif #ifndef CGAL_IO_FILE_HEADER_OFF_H #include #endif // CGAL_IO_FILE_HEADER_OFF_H #ifndef CGAL_IO_FILE_SCANNER_OFF_H #include #endif // CGAL_IO_FILE_SCANNER_OFF_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE template void generic_copy_OFF( File_scanner_OFF& scanner, std::ostream& out, Writer& writer) { std::istream& in = scanner.in(); // scans a polyhedral surface in OFF from `in' and writes it // to `out' in the format provided by `writer'. if ( ! in) { if ( scanner.verbose()) { std::cerr << " " << std::endl; std::cerr << "generic_copy_OFF(): " "input error: file format is not in OFF." << std::endl; } return; } // Print header. Number of halfedges is only trusted if it is // a polyhedral surface. writer.write_header( out, scanner.size_of_vertices(), scanner.polyhedral_surface() ? scanner.size_of_halfedges() : 0, scanner.size_of_facets()); // read in all vertices double x, y, z; // Point coordinates. int i; for ( i = 0; i < scanner.size_of_vertices(); i++) { scanner.scan_vertex( x, y, z); writer.write_vertex( x, y, z); scanner.skip_to_next_vertex( i); } // read in all facets writer.write_facet_header(); for ( i = 0; i < scanner.size_of_facets(); i++) { if ( ! in) return; Integer32 no; scanner.scan_facet( no, i); writer.write_facet_begin( no); for ( int j = 0; j < no; j++) { Integer32 index; scanner.scan_facet_vertex_index( index, i); writer.write_facet_vertex_index( index); } writer.write_facet_end(); scanner.skip_to_next_facet( i); } writer.write_footer(); } template void generic_copy_OFF( std::istream& in, std::ostream& out, Writer& writer, bool verbose = false) { // scans a polyhedral surface in OFF from `in' and writes it // to `out' in the format provided by `writer'. File_scanner_OFF scanner( in, verbose); generic_copy_OFF( scanner, out, writer); } CGAL_END_NAMESPACE #endif // CGAL_IO_GENERIC_COPY_OFF_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Straight_2_stream.h0000644000175000017500000000532111344301501031063 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Straight_2_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_IO_PM_STRAIGHT_2_STREAM_H #define CGAL_IO_PM_STRAIGHT_2_STREAM_H #ifndef CGAL_STRAIGHT_2_H #include #endif #include CGAL_BEGIN_NAMESPACE template std::ostream& operator<<(std::ostream& os,const Straight_2_& cv) { typedef Straight_2_ Straight; switch(cv.current_state()) { case Straight::EMPTY: return os; case Straight::POINT: { Point_2 p; cv.current(p); return os << p; } case Straight::SEGMENT: { Segment_2 seg; cv.current(seg); return os << seg; } case Straight::RAY: { Ray_2 ray; cv.current(ray); return os << ray; } case Straight::LINE: { Line_2 line; cv.current(line); return os << line; } } CGAL_assertion_msg( cv.current_state()==Straight::EMPTY|| cv.current_state()==Straight::POINT|| cv.current_state()==Straight::SEGMENT|| cv.current_state()==Straight::RAY|| cv.current_state()==Straight::LINE, "\nUnknown type in leda_window& operator<<(leda_window& os,\ const Straight& cv)"); return os; } template std::istream& operator>>(std::istream& os,const Straight_2_& cv) { typedef Straight_2_ Straight; switch(cv.current_state()) { case Straight::EMPTY: return os; case Straight::POINT: { Point_2 p; cv.current(p); return os >> p; } case Straight::SEGMENT: { Segment_2 seg; cv.current(seg); return os >> seg; } case Straight::RAY: { Ray_2 ray; cv.current(ray); return os >> ray; } case Straight::LINE: { Line_2 line; cv.current(line); return os >> line; } } CGAL_assertion_msg( cv.get_type()==Straight::EMPTY|| cv.get_type()==Straight::POINT|| cv.get_type()==Straight::SEGMENT|| cv.get_type()==Straight::RAY|| cv.get_type()==Straight::LINE, "\nUnknown type in leda_window& operator>>(leda_window& os," << "const Straight& cv)"); return os; } CGAL_END_NAMESPACE #endif // CGAL_IO_PM_STRAIGHT_2_STREAM_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Min_ellipse_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Min_ellip0000644000175000017500000000325111344301501031173 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Min_ellipse_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_MIN_ELLIPSE_2_H #define CGAL_QT_WIDGET_MIN_ELLIPSE_2_H #include #include namespace CGAL{ template< class Traits_ > Qt_widget& operator<<(Qt_widget &ws, const CGAL::Min_ellipse_2& min_ellipse) { typedef CGAL::Min_ellipse_2::Point_iterator Point_iterator; Point_iterator first( min_ellipse.points_begin()); Point_iterator last ( min_ellipse.points_end()); for ( ; first != last; ++first) ws << *first; return ws; } }//end namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget.h0000644000175000017500000005101111344301501027426 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent Rineau #ifndef CGAL_QT_WIDGET_H #define CGAL_QT_WIDGET_H #include #include #include //temporary, should remove next line!! #include #include #ifdef CGAL_USE_GMP #include #include #include typedef CGAL::Quotient CGAL_Rational; #include #endif //CGAL_USE_GMP #include #include #include #include #include #include #include #include namespace CGAL { class Qt_widget_layer; enum PointStyle { PIXEL, CROSS, PLUS, CIRCLE, DISC, RECT, BOX }; class Qt_widget : public QWidget { Q_OBJECT public: // constructor Qt_widget(QWidget *parent = 0, const char *name = 0); // destructor ~Qt_widget() {}; // initialization of coordinates system void set_window(const double x_min, const double x_max, const double y_min, const double y_max, bool const_ranges = false); void zoom(double ratio); void zoom(double ratio, double xc, double yc); void set_x_scale(const double xscale){ xscal = xscale; } void set_y_scale(const double yscale){ yscal = yscale; } void move_center(const double distx, const double disty); void set_center(const double x, const double y); // painting system inline QPainter& get_painter() { return (*painter); }; inline QPixmap& get_pixmap() { return (*pixmap); }; inline QWMatrix& get_matrix() { return (*matrix); }; void lock() { ++Locked; }; void unlock() { if (Locked>0) --Locked; do_paint(); }; void do_paint() { if (Locked==0) repaint(FALSE); }; virtual QSize sizeHint() const {return QSize(geometry().width(), geometry().height());} // properties // ~~~~~~~~~~ // color QColor color() const; void setColor(const QColor c); // backGroundColor QColor backgroundColor() const; void setBackgroundColor(const QColor& c); // fillColor QColor fillColor() const; void setFillColor(const QColor c); // isFilled bool isFilled() const; void setFilled(const bool f); // lineWidth uint lineWidth() const; void setLineWidth(const uint i); // pointSize uint pointSize() const; void setPointSize(const uint i); // pointStyle typedef CGAL::PointStyle PointStyle; PointStyle pointStyle() const; void setPointStyle(const PointStyle s); // rasterOp RasterOp rasterOp() {return painter->rasterOp();} void setRasterOp(const RasterOp r) {painter->setRasterOp(r);} // CGAL version of setFooColor // used by the manipulators system // DO NOT USE THESE THREE UNDOCUMENTED FUNCTIONS !! inline void setColor(const Color c) { setColor(CGAL2Qt_Color(c)); }; inline void setBackgroundColor(const Color c) { setBackgroundColor(CGAL2Qt_Color(c)); }; inline void setFillColor(const Color c) { setFillColor(CGAL2Qt_Color(c)); }; // set pen() color to c, cf. manipulators below for setting // backgroundColor and fillColor Qt_widget& operator<<(const Color& c); // set point style Qt_widget& operator<<(const PointStyle& ps); // clear the Widget, fill it with backgroundColor() void clear(); // coordinates system // ~~~~~~~~~~~~~~~~~~ // real world coordinates double x_real(int x) const; double y_real(int y) const; template void x_real(int, FT&) const; template void y_real(int y, FT&) const; #ifdef CGAL_USE_GMP void x_real(int, Gmpq&) const; void y_real(int, Gmpq&) const; #endif double x_real_dist(double d) const; double y_real_dist(double d) const; // pixel coordinates int x_pixel(double x) const; int y_pixel(double y) const; int x_pixel_dist(double d) const; int y_pixel_dist(double d) const; inline double x_min() const { return xmin; }; inline double y_min() const { return ymin; }; inline double x_max() const { return xmax; }; inline double y_max() const { return ymax; }; inline double x_scal() { return xscal; } inline double y_scal() { return yscal; } void new_object(CGAL::Object obj) { emit(new_cgal_object(obj)); }; //layers void attach(Qt_widget_layer *layer); // remove a layer from the list of displayable scenes void detach(Qt_widget_layer* s); signals: void s_mousePressEvent(QMouseEvent *e); void s_mouseReleaseEvent(QMouseEvent *e); void s_mouseMoveEvent(QMouseEvent *e); void s_paintEvent(QPaintEvent *e); void s_resizeEvent(QResizeEvent *e); void s_wheelEvent(QWheelEvent *e); void s_mouseDoubleClickEvent(QMouseEvent *e); void s_keyPressEvent(QKeyEvent *e); void s_keyReleaseEvent(QKeyEvent *e); void s_enterEvent(QEvent *e); void s_leaveEvent(QEvent *e); void s_event(QEvent *e); void custom_redraw(); //deprecated: if user want to draw something //after layers replaced by redraw_on_front void redraw_on_front(); //called by redraw at the end void redraw_on_back(); //called by redraw at the beginning void new_cgal_object(CGAL::Object); //this signal is emited every time an //attached tool constructed an object void rangesChanged(); // triggered when ranges (xmin, xmax, ymin,...) are changed public slots: void print_to_ps(); virtual void redraw(); // backward-compatibility with CGAL-2.4, back() and forth() are // deprecated, as well as add_to_history() or clear_history(). signals: void internal_back(); void internal_forth(); void internal_add_to_history(); void internal_clear_history(); public slots: bool back() { emit(internal_back()); return true; } bool forth() { emit(internal_forth()); return true; } public: void add_to_history() { emit(internal_add_to_history()); } void clear_history() { emit(internal_clear_history()); } protected: void paintEvent(QPaintEvent *e); void resizeEvent(QResizeEvent *e); void showEvent(QShowEvent *e); void mousePressEvent(QMouseEvent *e); void mouseReleaseEvent(QMouseEvent *e); void mouseMoveEvent(QMouseEvent *e); void wheelEvent(QWheelEvent *e); void mouseDoubleClickEvent(QMouseEvent *e); void keyPressEvent(QKeyEvent *e); void keyReleaseEvent(QKeyEvent *e); void enterEvent(QEvent *e); void leaveEvent(QEvent *e); bool event(QEvent *e); private: // private functions // ~~~~~~~~~~~~~~~~~ void resize_pixmap(); // resize properly the pixmap size, saving then restoring the // painter properties void set_scales(); // set xscal and yscal. Update ranges if const_ranges is false. // color types convertors static QColor CGAL2Qt_Color(Color c); static Color Qt2CGAL_color(QColor c); void attach_standard(Qt_widget_layer *layer); bool is_standard_active(); bool does_standard_eat_events(); friend class Qt_widget_standard_toolbar; // private member datas // ~~~~~~~~~~~~~~~~~~~~ bool set_scales_to_be_done; // this flag is set when the widget is not visible and should // postpone the set_scales() call. unsigned int Locked; // point style and size uint _pointSize; PointStyle _pointStyle; QPixmap *pixmap; // the pixmap on which paints the painter QPainter *painter; // the painter QPrinter *printer; // the printer QWMatrix *matrix; // the world matrix QBrush savedBrush; // saved brush, to be able to restore it on // setFilled(true) double xmin, xmax, ymin, ymax; // real dimensions double xmin_old, xmax_old, ymin_old, ymax_old; //backup ranges for resize double xscal, yscal; // scales int/double bool constranges; // tell if the ranges should be const //for layers std::list qt_layers; std::list qt_standard_layers; };//end Qt_widget class // manipulators // ~~~~~~~~~~~~ // single manipulators inline Qt_widget& operator<<(Qt_widget& w, Qt_widget& (*m)(Qt_widget&)) { return m(w); }; // w << noFill << ... stop the filling of geometrical object inline Qt_widget& noFill(Qt_widget& w) { w.setFilled(false); return w; } // manipulators with one argument template struct Qt_widgetManip { Qt_widget& (*f)(Qt_widget&, Param); Param p; Qt_widgetManip(Qt_widget& (*ff)(Qt_widget&, Param), Param pp) : f(ff), p(pp) {} }; // usage: w << manip(Param) f ... template Qt_widget& operator<<(Qt_widget& w, Qt_widgetManip m) { return m.f(w, m.p); } #define CGAL_QTWIDGET_MANIP(param,function) \ inline \ Qt_widget& __Qt_widgetManip##function##Aux (Qt_widget& w, param p) \ { w.set##function(p); return w; } \ inline \ Qt_widgetManip function(param p) \ { return Qt_widgetManip( __Qt_widgetManip##function##Aux, p); } // w << BackgroundColor(c) << ... sets the background color CGAL_QTWIDGET_MANIP( Color, BackgroundColor ) // w << FillColor(c) << ... sets the fill color CGAL_QTWIDGET_MANIP( Color, FillColor ) // w << LineWidth(i) << ... sets lines width CGAL_QTWIDGET_MANIP( unsigned int, LineWidth ) // w << PointSize(i) << ... sets points size CGAL_QTWIDGET_MANIP( unsigned int, PointSize ) // color types convertors // ~~~~~~~~~~~~~~~~~~~~~~ inline QColor Qt_widget::CGAL2Qt_Color(Color c) { return QColor(c.red(), c.green(), c.blue()); } inline Color Qt_widget::Qt2CGAL_color(QColor c) { return Color(c.red(),c.green(),c.blue()); } // properties // ~~~~~~~~~~ inline QColor Qt_widget::color() const { return painter->pen().color(); }; inline void Qt_widget::setColor(const QColor c) { QPen p=get_painter().pen(); p.setColor(c); get_painter().setPen(p); } inline QColor Qt_widget::backgroundColor() const { return painter->backgroundColor(); } inline void Qt_widget::setBackgroundColor(const QColor& c) { QWidget::setPaletteBackgroundColor(c); get_painter().setBackgroundColor(c); clear(); } inline QColor Qt_widget::fillColor() const { return painter->brush().color(); } inline void Qt_widget::setFillColor(const QColor c) { setFilled(true); get_painter().setBrush(c); } inline bool Qt_widget::isFilled() const { return( painter->brush().style()==Qt::NoBrush ); } inline void Qt_widget::setFilled(const bool f) { if (f) painter->setBrush(savedBrush); else { savedBrush=painter->brush(); painter->setBrush(QBrush()); }; } inline uint Qt_widget::lineWidth() const { return( painter->pen().width()); } inline void Qt_widget::setLineWidth(const unsigned int i) { QPen p=get_painter().pen(); p.setWidth(i); get_painter().setPen(p); } inline uint Qt_widget::pointSize() const { return _pointSize; } inline void Qt_widget::setPointSize(const unsigned int i) { _pointSize=i; } inline PointStyle Qt_widget::pointStyle() const { return _pointStyle; } inline void Qt_widget::setPointStyle(const PointStyle ps) { _pointStyle=ps; } // drawing methods // ~~~~~~~~~~~~~~~ template Qt_widget& operator<<(Qt_widget& w, const Point_2& p) { int x = w.x_pixel(CGAL::to_double(p.x())); int y = w.y_pixel(CGAL::to_double(p.y())); uint size=w.pointSize(); PointStyle ps=w.pointStyle(); switch (ps) { case PIXEL: { w.get_painter().drawPoint(x,y); break; } case CROSS: { w.get_painter().drawLine(x-size/2, y-size/2, x+size/2, y+size/2); w.get_painter().drawLine(x-size/2, y+size/2, x+size/2, y-size/2); break; } case PLUS: { w.get_painter().drawLine(x, y-size/2, x, y+size/2); w.get_painter().drawLine(x-size/2, y, x+size/2, y); break; } case CIRCLE: { QBrush old_brush=w.get_painter().brush(); w.get_painter().setBrush(QBrush()); w.get_painter().drawEllipse(x-size/2, y-size/2, size, size); w.get_painter().setBrush(old_brush); break; } case DISC: { QBrush old_brush=w.get_painter().brush(); w.get_painter().setBrush(w.get_painter().pen().color()); w.get_painter().drawEllipse(x-size/2, y-size/2, size, size); w.get_painter().setBrush(old_brush); break; } case RECT: { QBrush old_brush=w.get_painter().brush(); w.get_painter().setBrush(QBrush()); w.get_painter().drawRect(x-size/2, y-size/2, size, size); w.get_painter().setBrush(old_brush); break; } case BOX: { QBrush old_brush=w.get_painter().brush(); w.get_painter().setBrush(w.get_painter().pen().color()); w.get_painter().drawRect(x-size/2, y-size/2, size, size); w.get_painter().setBrush(old_brush); break; } }; w.do_paint(); return w; } #ifdef CGAL_SEGMENT_2_H template Qt_widget& operator<<(Qt_widget& w, const Segment_2& s) { typedef Simple_cartesian RT; double xr1, yr1, xr2, yr2; double scs_x, scs_y, sct_x, sct_y; scs_x = CGAL::to_double(s.source().x()); scs_y = CGAL::to_double(s.source().y()); sct_x = CGAL::to_double(s.target().x()); sct_y = CGAL::to_double(s.target().y()); xr1 = w.x_real(0); xr2 = w.x_real(w.geometry().width()); //next condition true if is outside on the X axes if((scs_x < xr1 && sct_x < xr1) || (scs_x > xr2 && sct_x > xr2)) return w; else{ yr2 = w.y_real(0); yr1 = w.y_real(w.geometry().height()); //next condition true if is outside on the Y axes if((scs_y < yr1 && sct_y < yr1) || (scs_y > yr2 && sct_y > yr2)) return w; } //if is here, the segment intersect the screen boundaries or is inside int x1, y1, x2, y2; Segment_2 sr; sr = Segment_2(Point_2(scs_x, scs_y), Point_2(sct_x, sct_y));; //next condition true if the segment is inside if(!(scs_x >= xr1 && scs_x <= xr2 && sct_x >= xr1 && sct_x <= xr2 && scs_y >= yr1 && scs_y <= yr2 && sct_y >= yr1 && sct_y <= yr2)) { Iso_rectangle_2 r = Iso_rectangle_2(Point_2(xr1, yr1), Point_2(xr2, yr2)); CGAL::Object obj = CGAL::intersection(r, sr); Point_2 p; if (CGAL::assign(p, obj)){ w << p; return w; } else CGAL::assign(sr, obj); } x1 = w.x_pixel(CGAL::to_double(sr.source().x())); x2 = w.x_pixel(CGAL::to_double(sr.target().x())); y1 = w.y_pixel(CGAL::to_double(sr.source().y())); y2 = w.y_pixel(CGAL::to_double(sr.target().y())); w.get_painter().drawLine(x1, y1, x2, y2); w.do_paint(); return w; } #endif // CGAL_SEGMENT_2_H #ifdef CGAL_LINE_2_H template Qt_widget& operator<<(Qt_widget& w, const Line_2& l) { typedef Simple_cartesian Rep; typedef Point_2 Point; const Point_2 p1=l.point(), p2=p1+l.direction().vector(); const Point p1d=Point(CGAL::to_double(p1.x()),CGAL::to_double(p1.y())), p2d=Point(CGAL::to_double(p2.x()),CGAL::to_double(p2.y())); double x1=w.x_min(), y1=w.y_min(), x2=w.x_max(), y2=w.y_max(); const double dx=p1d.x()-p2d.x(), dy=p1d.y()-p2d.y(); if (dx==0 && dy==0) return w; if (fabs(dx)>fabs(dy)) { y1=p1d.y()+(x1-p1d.x())*dy/dx; y2=p1d.y()+(x2-p1d.x())*dy/dx; } else { x1=p1d.x()+(y1-p1d.y())*dx/dy; x2=p1d.x()+(y2-p1d.y())*dx/dy; } w.get_painter().drawLine(w.x_pixel(x1),w.y_pixel(y1), w.x_pixel(x2),w.y_pixel(y2)); return w; } #endif // CGAL_LINE_2_H #ifdef CGAL_RAY_2_H template Qt_widget& operator<<(Qt_widget& w, const Ray_2& r) { typedef Simple_cartesian Rep; typedef Point_2 Point; const Point_2 p1=r.point(0), p2=r.point(1); const Point p1d=Point(CGAL::to_double(p1.x()),CGAL::to_double(p1.y())), p2d=Point(CGAL::to_double(p2.x()),CGAL::to_double(p2.y())); const double dx=p1d.x()-p2d.x(), dy=p1d.y()-p2d.y(); if (dx==0 && dy==0) return w; double x,y; if (fabs(dx)>fabs(dy)) { if (p1d.x() Qt_widget& operator<<(Qt_widget& w, const Triangle_2& t) { CGAL::Iso_rectangle_2 r( Point_2(w.x_real(0), w.y_real(0)), Point_2(w.x_real(w.geometry().width()), w.y_real(w.geometry().height()))); CGAL::Object obj = CGAL::intersection(t, r); Point_2 pi; Segment_2 si; Triangle_2 ti; typedef Point_2 Point; std::vector vi; if(CGAL::assign(pi, obj)) w << pi; if(CGAL::assign(si, obj)) w << si; if(CGAL::assign(ti, obj)) { QPointArray array(3); array[0] = QPoint(w.x_pixel(CGAL::to_double(t.vertex(0).x())), w.y_pixel(CGAL::to_double(t.vertex(0).y()))); array[1] = QPoint(w.x_pixel(CGAL::to_double(t.vertex(1).x())), w.y_pixel(CGAL::to_double(t.vertex(1).y()))); array[2] = QPoint(w.x_pixel(CGAL::to_double(t.vertex(2).x())), w.y_pixel(CGAL::to_double(t.vertex(2).y()))); w.get_painter().drawPolygon(array); } if(CGAL::assign(vi, obj)){ QPointArray array(int(vi.size())); typename std::vector::const_iterator it = vi.begin(); int pos = 0; while(it != vi.end()){ array[pos] = QPoint(w.x_pixel(CGAL::to_double((*it).x())), w.y_pixel(CGAL::to_double((*it).y()))); pos++; it++; } w.get_painter().drawPolygon(array); } w.do_paint(); return w;} #endif #ifdef CGAL_CIRCLE_2_H template < class R> Qt_widget& operator<<(Qt_widget& w, const Circle_2& c) { int cx=w.x_pixel(CGAL::to_double(c.center().x())), cy=w.y_pixel(CGAL::to_double(c.center().y())), rx=w.x_pixel_dist((std::sqrt(CGAL::to_double(c.squared_radius())))), ry=w.y_pixel_dist((std::sqrt(CGAL::to_double(c.squared_radius())))); w.get_painter().drawEllipse(cx-rx,cy-ry,2*rx,2*ry); w.do_paint(); return w; } #endif // CGAL_CIRCLE_2_H #ifdef CGAL_ISO_RECTANGLE_2_H template< class R > Qt_widget& operator<<(Qt_widget& w, const Iso_rectangle_2& r) { int xmin = w.x_pixel(CGAL::to_double(r.xmin())); int ymin = w.y_pixel(CGAL::to_double(r.ymin())); int xmax = w.x_pixel(CGAL::to_double(r.xmax())); int ymax = w.y_pixel(CGAL::to_double(r.ymax())); w.get_painter().drawRect(xmin,ymin,xmax-xmin,ymax-ymin); w.do_paint(); return w; } #endif // CGAL_ISO_RECTANGLE_2_H #ifdef CGAL_BBOX_2_H Qt_widget& operator<<(Qt_widget& w, const Bbox_2& r); // see Qt_widget for the implementation of this non-template function #endif // CGAL_BBOX_2_H // templated x_real and y_real template void Qt_widget::x_real(int x, FT& return_t) const { if(xscal<1) return_t = static_cast(xmin+(int)(x/xscal)); else{ #ifdef CGAL_USE_GMP CGAL_Rational r = simplest_rational_in_interval( xmin+x/xscal-(x/xscal-(x-1)/xscal)/2, xmin+x/xscal+((x+1)/xscal-x/xscal)/2); return_t = static_cast(CGAL::to_double(r)); #else return_t = static_cast(xmin+x/xscal); #endif } } template void Qt_widget::y_real(int y, FT& return_t) const { if(yscal<1) return_t = static_cast(ymax-(int)(y/yscal)); else{ #ifdef CGAL_USE_GMP CGAL_Rational r = simplest_rational_in_interval( ymax - y/yscal-(y/yscal-(y-1)/yscal)/2, ymax - y/yscal+((y+1)/yscal-y/yscal)/2); return_t = static_cast(CGAL::to_double(r)); #else return_t = static_cast(ymax-y/yscal); #endif } } } // namespace CGAL #endif // CGAL_QT_WIDGET_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_VRML_2.h0000644000175000017500000000273411344301501027724 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_VRML_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_PRINT_VRML_2_H #define CGAL_IO_PRINT_VRML_2_H 1 #include CGAL_BEGIN_NAMESPACE template void print_polyhedron_VRML_2( std::ostream& out, const Polyhedron& P) { VRML_2_ostream os( out); os << P; } // Deprecated global functions, replaced with functions above template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void print_VRML_2( std::ostream& out, const Polyhedron_3& P) { VRML_2_ostream os( out); os << P; } CGAL_END_NAMESPACE #endif // CGAL_IO_PRINT_VRML_2_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Conic_2.h0000644000175000017500000000724311344301501030772 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_Conic_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_CONIC_2_H #define CGAL_QT_WIDGET_CONIC_2_H #include #include #include namespace CGAL{ template< class R > Qt_widget& operator << ( Qt_widget& ws, const CGAL::Conic_2& c) { // pixel dimensions of window int dim = std::max( ws.width(), ws.height()); // length of a pixel in window-coordinates double pixel_x = (ws.x_max() - ws.x_min())/dim; double pixel_y = (ws.y_max() - ws.y_min())/dim; // pixel coordinates, stored for faster output typedef CGAL::Simple_cartesian::Point_2 Point; std::vector vcoordinates; // conic coordinates double r = CGAL::to_double (c.r()), s = CGAL::to_double (c.s()), t = CGAL::to_double (c.t()), u = CGAL::to_double (c.u()), v = CGAL::to_double (c.v()), w = CGAL::to_double (c.w()); // Phase I (drawing in x-direction) // solve conic equation for y if (s != 0.0) for (double x = ws.x_min(); x <= ws.x_max(); x+=pixel_x) { double discr = (t*t-4.0*r*s)*(x*x) + (2.0*t*v-4.0*s*u)*x + v*v - 4.0*s*w; if (discr >= 0.0) { double y1 = (-t*x - v - CGAL::sqrt(discr))/(2.0*s); double y2 = (-t*x - v + CGAL::sqrt(discr))/(2.0*s); vcoordinates.push_back(Point(x, y1)); vcoordinates.push_back(Point(x, y2));} } else for (double x = ws.x_min(); x <= ws.x_max(); x+=pixel_x) { double denom = t*x + v; if (denom != 0.0) { double y = -(r*x*x + u*x + w)/denom; vcoordinates.push_back(Point(x, y)); } } // Phase II (drawing in y-direction) // solve conic equation for x if (r != 0.0) for (double y = ws.y_min(); y <= ws.y_max(); y+=pixel_y) { double discr = (t*t-4.0*r*s)*(y*y) + (2.0*t*u-4.0*r*v)*y + u*u - 4.0*r*w; if (discr >= 0.0) { double x1 = (-t*y - u - CGAL::sqrt(discr))/(2.0*r); double x2 = (-t*y - u + CGAL::sqrt(discr))/(2.0*r); vcoordinates.push_back(Point(x1, y)); vcoordinates.push_back(Point(x2, y));} } else for (double y = ws.y_min(); y <= ws.y_max(); y+=pixel_y) { double denom = t*y + u; if (denom != 0.0) { double x = -(s*y*y + v*y + w)/denom; vcoordinates.push_back(Point(x, y));} } typedef typename std::vector::const_iterator CIT; for(CIT it1 = vcoordinates.begin(); it1!= vcoordinates.end(); ++it1) ws << *it1; return ws; } }//end namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_VRML_1.h0000644000175000017500000000273511344301501027724 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/print_VRML_1.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_PRINT_VRML_1_H #define CGAL_IO_PRINT_VRML_1_H 1 #include CGAL_BEGIN_NAMESPACE template void print_polyhedron_VRML_1( std::ostream& out, const Polyhedron& P) { VRML_1_ostream os( out); os << P; } // Deprecated global functions, replaced with functions above template < class Traits, class Items, #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class T, class I, class A> #endif class HDS, class Alloc> void print_VRML_1( std::ostream& out, const Polyhedron_3& P) { VRML_1_ostream os( out); os << P; } CGAL_END_NAMESPACE #endif // CGAL_IO_PRINT_VRML_1_H // // EOF // ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Conic_arc_2_Window_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Conic_arc_2_Window_0000644000175000017500000000642011344301501031044 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Conic_arc_2_Window_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_CONIC_ARC_2_WINDOW_STREAM_H #define CGAL_CONIC_ARC_2_WINDOW_STREAM_H #include #include CGAL_BEGIN_NAMESPACE template Window_stream& operator<<(Window_stream& ws, const Conic_arc_2& cv) { typedef typename Alg_kernel::FT CoNT; typedef typename Conic_arc_2::Point_2 Point_2; // Get the co-ordinates of the curve's source and target. double sx = CGAL::to_double(cv.source().x()), sy = CGAL::to_double(cv.source().y()), tx = CGAL::to_double(cv.target().x()), ty = CGAL::to_double(cv.target().y()); if (cv.is_segment()) { // The curve is a segment - simply draw it. ws << leda_segment(sx, sy, tx, ty); } else { // Draw a conic arc of degree 2. if (cv.is_x_monotone()) { // If the curve is monotone, than its source and its target has the // extreme x co-ordinates on this curve. bool is_source_left = (sx < tx); int x_min = is_source_left ? ws.real_to_pix(sx) : ws.real_to_pix(tx); int x_max = is_source_left ? ws.real_to_pix(tx) : ws.real_to_pix(sx); double prev_x = ws.pix_to_real(x_min); double prev_y = is_source_left ? sy : ty; double end_x = is_source_left ? tx : sx; double end_y = is_source_left ? ty : sy; double curr_x, curr_y; int x; Point_2 q; Point_2 ps[2]; int nps; for (x = x_min + 1; x < x_max; x++) { curr_x = ws.pix_to_real(x); q = Point_2 (CoNT(curr_x), 0); nps = cv.get_points_at_x (q, ps); if (nps == 1) { curr_y = CGAL::to_double(ps[0].y()); ws << leda_segment(prev_x, prev_y, curr_x, curr_y); prev_x = curr_x; prev_y = curr_y; } } ws << leda_segment(prev_x, prev_y, end_x, end_y); } else { // Break the arc into x-monotone sub-curves and draw each one separately. Arr_conic_traits_2 traits; std::list > x_mon_curves; typename std::list >::iterator xit; traits.curve_make_x_monotone (cv, std::back_inserter (x_mon_curves)); for (xit = x_mon_curves.begin(); xit != x_mon_curves.end(); xit++) ws << *xit; } } return (ws); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/window_stream_xy_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/window_stream_xy_3.0000644000175000017500000002270711344301501031165 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/window_stream_xy_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner // Note: This file could be included multiple times. Thus, the // usual protection against multiple inclusion is not used. // The following section protects itself against multiple inclusion // with a non-standard macro name to hinder redundant protection // guards in other files to exclude this file from inclusion. // (This section is currently empty.) #ifndef CGAL_IO_WINDOW_STREAM_XY_3_H_1 #define CGAL_IO_WINDOW_STREAM_XY_3_H_1 1 #endif // CGAL_IO_WINDOW_STREAM_XY_3_H_1 // // Each of the following operators is individually // protected against multiple inclusion. // Check first, whether the related 2d files are included. // ------------------------------------------------------- #if defined(CGAL_POINT_3_H) && ! defined(CGAL_POINT_2_H) #include #endif #if defined(CGAL_VECTOR_3_H) && ! defined(CGAL_VECTOR_2_H) #include #endif #if defined(CGAL_DIRECTION_3_H) && ! defined(CGAL_DIRECTION_2_H) #include #endif #if defined(CGAL_LINE_3_H) && ! defined(CGAL_LINE_2_H) #include #endif #if defined(CGAL_RAY_3_H) && ! defined(CGAL_RAY_2_H) #include #endif #if defined(CGAL_SEGMENT_3_H) && ! defined(CGAL_SEGMENT_2_H) #include #endif #if defined(CGAL_TRIANGLE_3_H) && ! defined(CGAL_TRIANGLE_2_H) #include #endif #if defined(CGAL_TETRAHEDRON_3_H) && ! defined(CGAL_SEGMENT_2_H) #include #endif #if defined(CGAL_TETRAHEDRON_3_H) && ! defined(CGAL_TRIANGLE_2_H) #include #endif #if defined(CGAL_BBOX_3_H) && ! defined(CGAL_BBOX_2_H) #include #endif #if defined(CGAL_LINE_3_H) || defined(CGAL_RAY_3_H) \ || defined(CGAL_SEGMENT_3_H) || defined(CGAL_TRIANGLE_3_H) \ || defined(CGAL_TETRAHEDRON_3_H) #ifndef CGAL_POINT_2_H #include #endif #ifndef CGAL_POINT_3_H #include #endif #endif // Define necessary 2d stream operators. // ------------------------------------- #ifndef CGAL_IO_WINDOW_STREAM_H #include #endif // CGAL_IO_WINDOW_STREAM_H CGAL_BEGIN_NAMESPACE // Define the stream operators for the xy projected 3d objects. // Note that data structures like polygons and triangulations // work independant from the dimension of the stored geometry. // ------------------------------------------------------------ #ifdef CGAL_POINT_3_H #ifndef CGAL_WINDOW_STREAM_POINT_3 #define CGAL_WINDOW_STREAM_POINT_3 template< class R > inline Window_stream& operator<<( Window_stream &w, const Point_3 &p) { return w << Point_2( p.hx(), p.hy(), p.hw()); } template< class R > Window_stream& operator>>( Window_stream &w, Point_3 &p) { typedef typename R::RT RT; Point_2 q; w >> q; p = Point_3( q.hx(), q.hy(), RT(0), q.hw()); return w; } #endif // CGAL_WINDOW_STREAM_POINT_3 #endif // CGAL_POINT_3_H #ifdef CGAL_VECTOR_3_H #ifndef CGAL_WINDOW_STREAM_VECTOR_3 #define CGAL_WINDOW_STREAM_VECTOR_3 template< class R > inline Window_stream& operator<<( Window_stream &w, const Vector_3 &v) { return w << Vector_2( v.hx(), v.hy(), v.hw()); } template< class R > Window_stream& operator>>( Window_stream &w, Vector_3 &v) { typedef typename R::RT RT; Vector_2 q; w >> q; v = Vector_3( q.hx(), q.hy(), RT(0), q.hw()); return w; } #endif // CGAL_WINDOW_STREAM_VECTOR_3 #endif // CGAL_VECTOR_3_H #ifdef CGAL_DIRECTION_3_H #ifndef CGAL_WINDOW_STREAM_DIRECTION_3 #define CGAL_WINDOW_STREAM_DIRECTION_3 template< class R > Window_stream& operator<<( Window_stream &w, const Direction_3 &d) { return w << Direction_2( d.dx(), d.dy()); } template< class R > Window_stream& operator>>( Window_stream &w, Direction_3 &d) { typedef typename R::RT RT; Direction_2 q; w >> q; d = Direction_3( q.dx(), q.dy(), RT(0)); return w; } #endif // CGAL_WINDOW_STREAM_DIRECTION_3 #endif // CGAL_DIRECTION_3_H #ifdef CGAL_LINE_3_H #ifndef CGAL_WINDOW_STREAM_LINE_3 #define CGAL_WINDOW_STREAM_LINE_3 template< class R > Window_stream& operator<<( Window_stream &w, const Line_3 &l) { return w << Line_2( Point_2( l.point(0).hx(), l.point(0).hy(), l.point(0).hw()), Point_2( l.point(1).hx(), l.point(1).hy(), l.point(1).hw())); } template< class R > Window_stream& operator>>( Window_stream &w, Line_3 &l) { Line_2 q; w >> q; l = Line_3( Point_3( q.point(0).hx(),q.point(0).hy(),0,q.point(0).hw()), Point_3( q.point(1).hx(),q.point(1).hy(),0,q.point(1).hw())); return w; } #endif // CGAL_WINDOW_STREAM_LINE_3 #endif // CGAL_LINE_3_H #ifdef CGAL_RAY_3_H #ifndef CGAL_WINDOW_STREAM_RAY_3 #define CGAL_WINDOW_STREAM_RAY_3 template< class R > Window_stream& operator<<( Window_stream &w, const Ray_3 &r) { return w << Ray_2( Point_2( r.point(0).hx(), r.point(0).hy(), r.point(0).hw()), Point_2( r.point(1).hx(), r.point(1).hy(), r.point(1).hw())); } template< class R > Window_stream& operator>>( Window_stream &w, Ray_3 &r) { Ray_2 q; w >> q; r = Ray_3( Point_3( q.point(0).hx(),q.point(0).hy(),0,q.point(0).hw()), Point_3( q.point(1).hx(),q.point(1).hy(),0,q.point(1).hw())); return w; } #endif // CGAL_WINDOW_STREAM_RAY_3 #endif // CGAL_RAY_3_H #ifdef CGAL_SEGMENT_3_H #ifndef CGAL_WINDOW_STREAM_SEGMENT_3 #define CGAL_WINDOW_STREAM_SEGMENT_3 template< class R > Window_stream& operator<<( Window_stream &w, const Segment_3 &s) { return w << Segment_2( Point_2( s.source().hx(), s.source().hy(), s.source().hw()), Point_2( s.target().hx(), s.target().hy(), s.target().hw())); } template< class R > Window_stream& operator>>( Window_stream &w, Segment_3 &s) { Segment_2 q; w >> q; s = Segment_3( Point_3( q.source().hx(),q.source().hy(),0,q.source().hw()), Point_3( q.target().hx(),q.target().hy(),0,q.target().hw())); return w; } #endif // CGAL_WINDOW_STREAM_SEGMENT_3 #endif // CGAL_SEGMENT_3_H #ifdef CGAL_TRIANGLE_3_H #ifndef CGAL_WINDOW_STREAM_TRIANGLE_3 #define CGAL_WINDOW_STREAM_TRIANGLE_3 template< class R > Window_stream& operator<<( Window_stream &w, const Triangle_3 &t) { return w << Triangle_2( Point_2( t[0].hx(), t[0].hy(), t[0].hw()), Point_2( t[1].hx(), t[1].hy(), t[1].hw()), Point_2( t[2].hx(), t[2].hy(), t[2].hw())); } template< class R > Window_stream& operator>>( Window_stream &w, Triangle_3 &t) { Triangle_2 q; w >> q; t = Triangle_3( Point_3( q[0].hx(), q[0].hy(), 0, q[0].hw()), Point_3( q[1].hx(), q[1].hy(), 0, q[1].hw()), Point_3( q[2].hx(), q[2].hy(), 0, q[2].hw())); return w; } #endif // CGAL_WINDOW_STREAM_TRIANGLE_3 #endif // CGAL_TRIANGLE_3_H #ifdef CGAL_TETRAHEDRON_3_H #ifndef CGAL_WINDOW_STREAM_TETRAHEDRON_3 #define CGAL_WINDOW_STREAM_TETRAHEDRON_3 template< class R > Window_stream& operator<<( Window_stream &w, const Tetrahedron_3 &t) { w << Segment_3( t[0], t[1]); w << Segment_3( t[1], t[2]); w << Segment_3( t[2], t[0]); w << Segment_3( t[0], t[3]); w << Segment_3( t[1], t[3]); w << Segment_3( t[2], t[3]); return w; } template< class R > Window_stream& operator>>( Window_stream &w, Tetrahedron_3 &t) { typedef typename R::RT RT; Triangle_3 q; w >> q; double x0 = to_double( q[0].x()); double y0 = to_double( q[0].y()); double x1, y1; w.read_mouse_seg(x0, y0, x1, y1); Point_3 p = Point_3( RT(x1), RT(y1), RT(0)); w << Segment_3( q[0], p); w << Segment_3( q[1], p); w << Segment_3( q[2], p); t = Tetrahedron_3( q[0], q[1], q[2], p); return w; } #endif // CGAL_WINDOW_STREAM_TETRAHEDRON_3 #endif // CGAL_TETRAHEDRON_3_H #ifdef CGAL_BBOX_3_H #ifndef CGAL_WINDOW_STREAM_BBOX_3 #define CGAL_WINDOW_STREAM_BBOX_3 inline Window_stream& operator<<( Window_stream &w, const Bbox_3 &b) { return w << Bbox_2( b.xmin(), b.ymin(), b.xmax(), b.ymax()); } inline Window_stream& operator>>( Window_stream &w, Bbox_3 &b) { double x0, y0, x1, y1; w.read_mouse(x0,y0); w.read_mouse_rect(x0,y0, x1, y1); if ( x1 < x0) { double tmp = x0; x0 = x1; x1 = tmp; } if ( y1 < y0) { double tmp = y0; y0 = y1; y1 = tmp; } b = Bbox_3( x0, y0, 0, x1, y1, 0); w << b; return w; } #endif // CGAL_WINDOW_STREAM_BBOX_3 #endif // CGAL_BBOX_3_H CGAL_END_NAMESPACE // EOF // ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_S2_OGLUT_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_S2_O0000644000175000017500000000353111344301501031052 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_S2_OGLUT_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef NEF_POLYHEDRON_S2_OGLUT_STREAM_H #define NEF_POLYHEDRON_S2_OGLUT_STREAM_H #include #include #include CGAL_BEGIN_NAMESPACE struct OGLUT_stream { // dummy class OGLUT_stream() {} void display() { CGAL::OGL::start_viewer(); } }; static OGLUT_stream ogl; template CGAL::OGLUT_stream& operator<<(CGAL::OGLUT_stream& ogls, const Nef_polyhedron_S2& P) { typedef Nef_polyhedron_S2 Polyhedron; typedef typename Polyhedron::Sphere_map Sphere_map; typedef typename Polyhedron::Sphere_kernel Sphere_kernel; typedef CGAL::SM_visualizor Visualizor; CGAL::OGL::add_sphere(); Visualizor V(&P,CGAL::OGL::spheres_.back()); V.draw_map(); // CGAL::OGL::spheres_.back().print(); return ogls; } static CGAL::OGLUT_stream& operator<<(CGAL::OGLUT_stream& ogls, const char* s) { CGAL::OGL::titles_.push_back(std::string(s)); return ogls; } CGAL_END_NAMESPACE #endif // NEF_POLYHEDRON_S2_OGLUT_STREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/write_pm.h0000644000175000017500000000364511344301501027337 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/write_pm.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_IO_WRITE_PM_H #define CGAL_IO_WRITE_PM_H #ifndef CGAL_BASIC_H #include #endif #include #ifndef CGAL_PLANAR_MAP_2_H #include #endif #ifndef CGAL_INVERSE_INDEX_H #include #endif CGAL_BEGIN_NAMESPACE template void write_pm(const PM & pm, Writer & writer, std::ostream &) { // Print header. write #vertices, #halfedges, #faces. writer.write_title("Begin Planar Map"); writer.write_comment("Number of vertices halfedges and faces in Planar map"); writer.write_pm_vhf_sizes(pm.number_of_vertices(), pm.number_of_halfedges(), pm.number_of_faces()); writer.write_comment("vertices", pm.number_of_vertices()); writer.write_vertices(pm.vertices_begin(), pm.vertices_end()); writer.write_comment("halfedges", pm.number_of_halfedges()); writer.write_halfedges(pm.halfedges_begin(), pm.halfedges_end()); writer.write_comment("faces", pm.number_of_faces()); writer.write_faces(pm.faces_begin(), pm.faces_end()); writer.write_title("End Planar Map"); //writer.write_footer(); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_point.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_point0000644000175000017500000000462511344301501031261 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_point.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent Rineau #ifndef CGAL_QT_WIDGET_GET_POINT_H #define CGAL_QT_WIDGET_GET_POINT_H #include #include #include #ifndef CGAL_QT_WIDGET_GET_POINT_BUTTON #define CGAL_QT_WIDGET_GET_POINT_BUTTON Qt::LeftButton #endif namespace CGAL { template class Qt_widget_get_point : public Qt_widget_layer { public: typedef typename R::Point_2 Point; typedef typename R::FT FT; Qt_widget_get_point(const QCursor c=QCursor(Qt::crossCursor), QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), cursor(c) {}; protected: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && is_pure(e->state())) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->new_object(make_object(Point(x, y))); } }; void activating() { oldcursor = widget->cursor(); widget->setCursor(cursor); }; void deactivating() { widget->setCursor(oldcursor); }; QCursor cursor; QCursor oldcursor; }; } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_POINT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_iostream.h0000644000175000017500000000326511344301501030136 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Arr_iostream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Eti Ezra #ifndef CGAL_ARR_IOSTREAM_H #define CGAL_ARR_IOSTREAM_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE template inline ::std::ostream & operator << (::std::ostream & o, const Arrangement_2 & arr) { typedef Arrangement_2 Arr_2; typedef Arr_file_writer Writer; //print_OFF(o, arr); Writer writer(o, arr); write_arr(arr, writer, o); return o; } template inline ::std::istream & operator >> (std::istream & in, Arrangement_2 & arr) { // reads a polyhedron from `in' and appends it to P. arr.read(in); return in; } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Geomview_stream.h0000644000175000017500000003720511344301501030645 0ustar debiandebian// Copyright (c) 1997,1998,1999,2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Geomview_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Sylvain Pion #ifndef CGAL_GEOMVIEW_STREAM_H #define CGAL_GEOMVIEW_STREAM_H #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE class Geomview_stream { public: Geomview_stream(const Bbox_3 &bbox = Bbox_3(0,0,0, 1,1,1), const char *machine = NULL, const char *login = NULL); ~Geomview_stream(); Geomview_stream &operator<<(const Color &c); Geomview_stream &operator<<(const std::string & s); Geomview_stream &operator<<(int i); Geomview_stream &operator<<(unsigned int i); Geomview_stream &operator<<(long i); Geomview_stream &operator<<(unsigned long i); Geomview_stream &operator<<(double d); template < class InputIterator > void draw_triangles(InputIterator begin, InputIterator end); Geomview_stream &operator>>(char *expr); void clear(); void look_recenter(); void set_bg_color(const Color &c); Color get_vertex_color() const; Color get_edge_color() const; Color get_face_color() const; Color set_vertex_color(const Color&); Color set_edge_color(const Color&); Color set_face_color(const Color&); double vcr() const; double vcg() const; double vcb() const; double ecr() const; double ecg() const; double ecb() const; double fcr() const; double fcg() const; double fcb() const; double get_vertex_radius() const { return radius; } double set_vertex_radius(double r) { std::swap(r, radius); return r; } int get_line_width() const { return line_width; } int set_line_width(int w) { std::swap(w, line_width); return w; } bool set_wired(bool b) { std::swap(b, wired_flag); return b; } bool get_wired() const { return wired_flag; } bool set_echo(bool b) { std::swap(b, echo_flag); return b; } bool get_echo() const { return echo_flag; } bool set_raw(bool b) { std::swap(b, raw_flag); return b; } bool get_raw() const { return raw_flag; } bool set_trace(bool b) { std::swap(b, trace_flag); return b; } bool get_trace() const { return trace_flag; } void trace(const std::string s) const { if (get_trace()) std::cerr << s; } void trace(double d) const { if (get_trace()) std::cerr << d << ' '; } void trace(int i) const { if (get_trace()) std::cerr << i << ' '; } void trace(unsigned int i) const { if (get_trace()) std::cerr << i << ' '; } bool set_binary_mode(bool b = true) { std::swap(b, binary_flag); return b; } bool set_ascii_mode(bool b = true) { return !set_binary_mode(!b); } bool get_binary_mode() const { return binary_flag; } bool get_ascii_mode() const { return !binary_flag; } std::string get_new_id(const std::string & s); const Bbox_3 & get_bbox() { return bb; } void pickplane() { pickplane(get_bbox()); } static char* nth(char* s, int count); static void parse_point(const char* pickpoint, double &x, double &y, double &z, double &w); private: void setup_geomview(const char *machine, const char *login); void frame(const Bbox_3 &bbox); void pickplane(const Bbox_3 &bbox); Bbox_3 bb; Color vertex_color, edge_color, face_color; bool wired_flag; // decides if we draw surfaces or edges. bool echo_flag; // decides if we echo the point we get back to Geomview. bool raw_flag; // decides if we output footers and headers. bool trace_flag; // makes operator<<() write a trace on cerr. bool binary_flag; // makes operator<<() write binary format int line_width; // width of edges double radius; // radius of vertices int in, out; // file descriptors for input and output pipes int pid; // the geomview process identification std::map id; // used to get a unique ID per type. }; // Factorize code for Point_2 and Point_3. template < class FT > void output_point(Geomview_stream &gv, const FT &x, const FT &y, const FT &z) { bool ascii_bak = true; // the initialization value shuts up the compiler. if (!gv.get_raw()) { ascii_bak = gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("P") << " {appearance {linewidth 5 material {edgecolor " << gv.vcr() << gv.vcg() << gv.vcb() << "}}{SKEL 1 1 "; } gv << CGAL::to_double(x) << CGAL::to_double(y) << CGAL::to_double(z); if (!gv.get_raw()) { gv << "1 0\n}})"; gv.set_ascii_mode(ascii_bak); } } #if defined CGAL_POINT_2_H && \ !defined CGAL_GV_OUT_POINT_2_H #define CGAL_GV_OUT_POINT_2_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Point_2 &p) { typename R::FT zero(0); output_point(gv, p.x(), p.y(), zero); return gv; } #endif #if defined CGAL_POINT_3_H && \ !defined CGAL_GV_OUT_POINT_3_H #define CGAL_GV_OUT_POINT_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Point_3 &p) { output_point(gv, p.x(), p.y(), p.z()); return gv; } #endif // The following code is the same for Segment_2 and Segment_3. template < class Segment > void output_segment(Geomview_stream &gv, const Segment &segment) { bool ascii_bak = gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("Seg") << " {appearance {linewidth " << gv.get_line_width() << "}{VECT " << 1 << 2 << 1 // 1 polyline, two vertices, 1 color << 2 // the first polyline contains 2 vertices << 1; // and it has 1 color // here are start and end points bool raw_bak = gv.set_raw(true); gv << segment.source() << segment.target(); gv.set_raw(raw_bak); // and the color of the segment and its opaqueness gv << gv.ecr() << gv.ecg() << gv.ecb() << 1.0 << "}})"; gv.set_ascii_mode(ascii_bak); } #if defined CGAL_SEGMENT_2_H && \ !defined CGAL_GV_OUT_SEGMENT_2_H #define CGAL_GV_OUT_SEGMENT_2_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Segment_2 &segment) { output_segment(gv, segment); return gv; } #endif #if defined CGAL_SEGMENT_3_H && \ !defined CGAL_GV_OUT_SEGMENT_3_H #define CGAL_GV_OUT_SEGMENT_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Segment_3 &segment) { output_segment(gv, segment); return gv; } #endif // The following code is the same for Triangle_2 and Triangle_3. template < class Triangle > void output_triangle(Geomview_stream &gv, const Triangle &triangle) { bool ascii_bak = gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("Tr") << " {appearance {+edge material {edgecolor " << gv.ecr() << gv.ecg() << gv.ecb() << " } shading constant}{ "; gv.set_binary_mode(); // it's a planar polygon gv << "OFF BINARY\n" // it has 3 vertices, 1 face and 3 edges << 3 << 1 << 3; bool raw_bak = gv.set_raw(true); for(int i=0; i<3; i++) gv << triangle[i]; gv.set_raw(raw_bak); // the face gv << 3 << 0 << 1 << 2 << 4 << gv.fcr() << gv.fcg() << gv.fcb() << 1.0 << "}})"; gv.set_ascii_mode(ascii_bak); } // Draws a set of triangles as OFF format (it's faster than one by one). template < class InputIterator > void Geomview_stream::draw_triangles(InputIterator begin, InputIterator end) { typedef typename std::iterator_traits::value_type Triangle; typedef typename Kernel_traits::Kernel Kernel; typedef typename Kernel::Point_3 Point; typedef typename Kernel::Less_xyz_3 Comp; // We first copy everything in a vector to only require an InputIterator. std::vector triangles(begin, end); typedef typename std::vector::const_iterator Tit; // Put the points in a map and a vector. // The index of a point in the vector is the value associated // to it in the map. typedef std::map Point_map; Point_map point_map(Kernel().less_xyz_3_object()); std::vector points; for (Tit i = triangles.begin(); i != triangles.end(); ++i) for (int j = 0; j < 3; ++j) if (point_map.insert(typename Point_map::value_type(i->vertex(j), points.size())).second) points.push_back(i->vertex(j)); bool ascii_bak = get_ascii_mode(); bool raw_bak = set_raw(true); // Header. set_binary_mode(); (*this) << "(geometry " << get_new_id("triangles") << " {appearance {}{ OFF BINARY\n" << points.size() << triangles.size() << 0; // Points coordinates. std::copy(points.begin(), points.end(), Ostream_iterator(*this)); // Triangles vertices indices. for (Tit tit = triangles.begin(); tit != triangles.end(); ++tit) { (*this) << 3; for (int j = 0; j < 3; ++j) (*this) << point_map[tit->vertex(j)]; (*this) << 0; // without color. } // Footer. (*this) << "}})"; set_raw(raw_bak); set_ascii_mode(ascii_bak); } #if defined CGAL_TRIANGLE_2_H && \ !defined CGAL_GV_OUT_TRIANGLE_2_H #define CGAL_GV_OUT_TRIANGLE_2_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Triangle_2 &triangle) { output_triangle(gv, triangle); return gv; } #endif #if defined CGAL_TRIANGLE_3_H && \ !defined CGAL_GV_OUT_TRIANGLE_3_H #define CGAL_GV_OUT_TRIANGLE_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Triangle_3 &triangle) { output_triangle(gv, triangle); return gv; } #endif #if defined CGAL_TETRAHEDRON_3_H && \ !defined CGAL_GV_OUT_TETRAHEDRON_3_H #define CGAL_GV_OUT_TETRAHEDRON_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Tetrahedron_3 &t) { bool ascii_bak = gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("Tetra") << " {appearance {}{ "; gv.set_binary_mode(); gv << "OFF BINARY\n" // it has 4 vertices, 4 face and 6 edges << 4 << 4 << 6 ; // the vertices bool raw_bak = gv.set_raw(true); for(int i=0; i<4; i++) gv << t[i]; gv.set_raw(raw_bak); // the faces double r = gv.fcr(), g = gv.fcg(), b = gv.fcb(); gv << 3 << 0 << 1 << 2 << 4 << r << g << b << 1.0 << 3 << 3 << 0 << 1 << 4 << r << g << b << 1.0 << 3 << 3 << 1 << 2 << 4 << r << g << b << 1.0 << 3 << 3 << 0 << 2 << 4 << r << g << b << 1.0 << "}})"; gv.set_ascii_mode(ascii_bak); return gv; } #endif #if defined CGAL_SPHERE_3_H && \ !defined CGAL_GV_OUT_SPHERE_3_H #define CGAL_GV_OUT_SPHERE_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Sphere_3 &S) { bool ascii_bak = gv.set_ascii_mode(); gv << "(geometry " << gv.get_new_id("Sph") << " {appearance {+edge material {edgecolor " << gv.ecr() << gv.ecg() << gv.ecb() << "} shading constant}{ " << "SPHERE\n" << CGAL_CLIB_STD::sqrt(CGAL::to_double(S.squared_radius())) << "\n"; bool raw_bak = gv.set_raw(true); gv << Point_3(S.center()) << "}})"; gv.set_raw(raw_bak); gv.set_ascii_mode(ascii_bak); return gv; } #endif #if defined CGAL_RAY_2_H && \ !defined CGAL_GV_OUT_RAY_2_H #define CGAL_GV_OUT_RAY_2_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Ray_2 &r) { // Note: it won't work if double is not convertible to an RT... const Bbox_3 & bb = gv.get_bbox(); Object result = intersection(Iso_rectangle_2( Point_2(bb.xmin(), bb.ymin()), Point_2(bb.xmax(), bb.ymax())), r); Point_2 ipoint; Segment_2 iseg; if (assign(ipoint, result)) gv << ipoint; else if (assign(iseg, result)) gv << iseg; return gv; } #endif #if defined CGAL_LINE_2_H && \ !defined CGAL_GV_OUT_LINE_2_H #define CGAL_GV_OUT_LINE_2_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Line_2 &r) { // Note: it won't work if double is not convertible to an RT... const Bbox_3 & bb = gv.get_bbox(); Object result = intersection(Iso_rectangle_2( Point_2(bb.xmin(), bb.ymin()), Point_2(bb.xmax(), bb.ymax())), r); Point_2 ipoint; Segment_2 iseg; if (assign(ipoint, result)) gv << ipoint; else if (assign(iseg, result)) gv << iseg; return gv; } #endif // Ray and Line drawing should be done by intersecting them with the BBox // of the Geomview_stream. But for now we take the easy approach. #if defined CGAL_RAY_3_H && \ !defined CGAL_GV_OUT_RAY_3_H #define CGAL_GV_OUT_RAY_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Ray_3 &r) { typename R::Segment_3 s(r.source(), r.point(1)); gv << s; return gv; } #endif #if defined CGAL_LINE_3_H && \ !defined CGAL_GV_OUT_LINE_3_H #define CGAL_GV_OUT_LINE_3_H template < class R > Geomview_stream& operator<<(Geomview_stream &gv, const Line_3 &r) { typename R::Segment_3 s(r.point(-1), r.point(1)); gv << s; return gv; } #endif Geomview_stream& operator<<(Geomview_stream &gv, const Bbox_2 &bbox); Geomview_stream& operator<<(Geomview_stream &gv, const Bbox_3 &bbox); #if defined CGAL_POINT_3_H && !defined CGAL_GV_IN_POINT_3_H #define CGAL_GV_IN_POINT_3_H template < class R > Geomview_stream& operator>>(Geomview_stream &gv, Point_3 &point) { const char *gclpick = "(pick world pickplane * nil nil nil nil nil nil nil)"; bool ascii_bak = gv.set_ascii_mode(); gv << "(pickable pickplane yes) (ui-target pickplane yes)" << "(interest " << gclpick << ")"; char sexpr[1024]; gv >> sexpr; // this reads a gcl expression const char* pickpoint = Geomview_stream::nth(sexpr, 3); // this gives something as: (0.0607123 0.0607125 4.76837e-07 0.529628) double x, y, z, w; Geomview_stream::parse_point(pickpoint, x, y, z, w); point = Point_3(x, y, z, w); // we echo the input if (gv.get_echo()) gv << point; // we are done and tell geomview to stop sending pick events gv << "(uninterest " << gclpick << ") (pickable pickplane no)"; gv.set_ascii_mode(ascii_bak); return gv; } #endif CGAL_END_NAMESPACE #endif // CGAL_GEOMVIEW_STREAM_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_ps_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_ps_st0000644000175000017500000000376311344301501031314 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Triangulation_ps_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Carine Bonetto // Mariette Yvinec #ifndef CGAL_TRIANGULATION_PS_STREAM_H #define CGAL_TRIANGULATION_PS_STREAM_H #ifdef CGAL_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template PS_Stream& operator << (PS_Stream& ps, const Triangulation_2 &t) { t.draw_triangulation(ps); return ps; } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_2_H #ifdef CGAL_DELAUNAY_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds > PS_Stream& operator << (PS_Stream& ps, const Delaunay_triangulation_2 &t) { t.draw_triangulation(ps); return ps; } CGAL_END_NAMESPACE #endif // CGAL_DELAUNAY_TRIANGULATION_2_H #ifdef CGAL_CONSTRAINED_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds> PS_Stream& operator<<(PS_Stream& ps, const Constrained_triangulation_2 &t) { t.draw_triangulation(ps); return ps; } CGAL_END_NAMESPACE #endif // CGAL_CONSTRAINED_TRIANGULATION_2_H #ifdef CGAL_REGULAR_TRIANGULATION_2_H CGAL_BEGIN_NAMESPACE template < class Gt, class Tds > PS_Stream& operator << (PS_Stream& ps, Regular_triangulation_2 &t) { t.draw_triangulation(ps); return ps; } CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_2_H #endif //CGAL_TRIANGULATION_PS_STREAM mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/0000755000175000017500000000000012146213710027016 5ustar debiandebian././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/alpha_shape.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/alpha_shape0000644000175000017500000000015111344301501031176 0ustar debiandebian/* XPM */ extern const char * alpha_shape_xpm[]; /* XPM */ extern const char * alpha_shape_small_xpm[]; ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus2_mask.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus2_mask0000644000175000017500000000006111344301501031145 0ustar debiandebian/* XPM */ extern const char * focus2_mask_xpm[]; ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/ymonotone.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/ymonotone.x0000644000175000017500000000014411344301501031230 0ustar debiandebian/* XPM */ extern const char * ymonotone_xpm[]; /* XPM */ extern const char * ymonotone_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/line.xpm0000644000175000017500000000013211344301501030462 0ustar debiandebian/* XPM */ extern const char * line_xpm[]; /* XPM */ extern const char * line_small_xpm[]; ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/movepoint.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/movepoint.x0000644000175000017500000000014411344301501031221 0ustar debiandebian/* XPM */ extern const char * movepoint_xpm[]; /* XPM */ extern const char * movepoint_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus.xpm0000644000175000017500000000005311344301501030654 0ustar debiandebian/* XPM */ extern const char * focus_xpm[]; ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus1_mask.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus1_mask0000644000175000017500000000006111344301501031144 0ustar debiandebian/* XPM */ extern const char * focus1_mask_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/zoom_in.xpm0000644000175000017500000000005411344301501031210 0ustar debiandebian/* XPM */ extern const char * zoomin_xpm[]; ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/greene_approx.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/greene_appr0000644000175000017500000000015411344301501031223 0ustar debiandebian/* XPM */ extern const char * greene_approx_xpm[]; /* XPM */ extern const char * greene_approx_small_xpm[]; ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/zoom_in_rect.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/zoom_in_rec0000644000175000017500000000006111344301501031234 0ustar debiandebian/* XPM */ extern const char * zoomin_rect_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus1.xpm0000644000175000017500000000005411344301501030736 0ustar debiandebian/* XPM */ extern const char * focus1_xpm[]; ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/holddown.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/holddown.xp0000644000175000017500000000005611344301501031201 0ustar debiandebian/* XPM */ extern const char * holddown_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/circle.xpm0000644000175000017500000000013611344301501031000 0ustar debiandebian/* XPM */ extern const char * circle_xpm[]; /* XPM */ extern const char * circle_small_xpm[]; ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/nearest_vertex.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/nearest_ver0000644000175000017500000000015611344301501031253 0ustar debiandebian/* XPM */ extern const char * nearest_vertex_xpm[]; /* XPM */ extern const char * nearest_vertex_small_xpm[]; ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/iso_rectangle.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/iso_rectang0000644000175000017500000000015411344301501031231 0ustar debiandebian/* XPM */ extern const char * iso_rectangle_small_xpm[]; /* XPM */ extern const char * iso_rectangle_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/point.xpm0000644000175000017500000000013411344301501030666 0ustar debiandebian/* XPM */ extern const char * point_xpm[]; /* XPM */ extern const char * point_small_xpm[]; ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/demoicon.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/demoicon.xp0000644000175000017500000000005711344301501031161 0ustar debiandebian/* XPM */ extern const char * demoicon_xpm[]; ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/show_polygon.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/show_polygo0000644000175000017500000000015211344301501031303 0ustar debiandebian/* XPM */ extern const char * show_polygon_xpm[]; /* XPM */ extern const char * show_polygon_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus3.xpm0000644000175000017500000000005411344301501030740 0ustar debiandebian/* XPM */ extern const char * focus3_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/arrow.xpm0000644000175000017500000000013411344301501030667 0ustar debiandebian/* XPM */ extern const char * arrow_xpm[]; /* XPM */ extern const char * arrow_small_xpm[]; ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/triangulation.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/triangulati0000644000175000017500000000015411344301501031257 0ustar debiandebian/* XPM */ extern const char * triangulation_xpm[]; /* XPM */ extern const char * triangulation_small_xpm[]; ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/handtool.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/handtool.xp0000644000175000017500000000005611344301501031173 0ustar debiandebian/* XPM */ extern const char * handtool_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/back.xpm0000644000175000017500000000013211344301501030433 0ustar debiandebian/* XPM */ extern const char * back_xpm[]; /* XPM */ extern const char * back_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/forward.xpm0000644000175000017500000000014011344301501031176 0ustar debiandebian/* XPM */ extern const char * forward_xpm[]; /* XPM */ extern const char * forward_small_xpm[]; ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/min_rectangle.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/min_rectang0000644000175000017500000000015411344301501031222 0ustar debiandebian/* XPM */ extern const char * min_rectangle_xpm[]; /* XPM */ extern const char * min_rectangle_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/voronoi.xpm0000644000175000017500000000014011344301501031225 0ustar debiandebian/* XPM */ extern const char * voronoi_xpm[]; /* XPM */ extern const char * voronoi_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/notool.xpm0000644000175000017500000000013611344301501031051 0ustar debiandebian/* XPM */ extern const char * notool_xpm[]; /* XPM */ extern const char * notool_small_xpm[]; ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/optimal_convex.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/optimal_con0000644000175000017500000000015611344301501031242 0ustar debiandebian/* XPM */ extern const char * optimal_convex_xpm[]; /* XPM */ extern const char * optimal_convex_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/points.xpm0000644000175000017500000000013711344301501031054 0ustar debiandebian/* XPM */ extern const char * points_xpm[]; /* XPM */ extern const char * points_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus2.xpm0000644000175000017500000000005411344301501030737 0ustar debiandebian/* XPM */ extern const char * focus2_xpm[]; ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/constrained.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/constrained0000644000175000017500000000015011344301501031241 0ustar debiandebian/* XPM */ extern const char * constrained_xpm[]; /* XPM */ extern const char * constrained_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/polygon.xpm0000644000175000017500000000014011344301501031221 0ustar debiandebian/* XPM */ extern const char * polygon_xpm[]; /* XPM */ extern const char * polygon_small_xpm[]; ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus3_mask.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/focus3_mask0000644000175000017500000000006111344301501031146 0ustar debiandebian/* XPM */ extern const char * focus3_mask_xpm[]; ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/zoom_out.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/zoom_out.xp0000644000175000017500000000005511344301501031235 0ustar debiandebian/* XPM */ extern const char * zoomout_xpm[]; ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/rotation.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/rotation.xp0000644000175000017500000000013011344301501031213 0ustar debiandebian/* XPM */ extern const char *rotation_xpm[]; extern const char *rotation_small_xpm[]; ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/mouse_coord.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/mouse_coord0000644000175000017500000000006111344301501031247 0ustar debiandebian/* XPM */ extern const char * mouse_coord_xpm[]; ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/min_parallelogram.xpmmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/min_paralle0000644000175000017500000000016411344301501031220 0ustar debiandebian/* XPM */ extern const char * min_parallelogram_xpm[]; /* XPM */ extern const char * min_parallelogram_small_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/pixmaps/hand.xpm0000644000175000017500000000005211344301501030446 0ustar debiandebian/* XPM */ extern const char * hand_xpm[]; mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_scanner_OFF.h0000644000175000017500000003552111344301501030571 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/File_scanner_OFF.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_IO_FILE_SCANNER_OFF_H #define CGAL_IO_FILE_SCANNER_OFF_H 1 #ifndef CGAL_BASIC_H #include #endif #ifndef CGAL_KNOWN_BIT_SIZE_INTEGERS_H #include #endif #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif #ifndef CGAL_IO_BINARY_FILE_IO_H #include #endif // CGAL_IO_BINARY_FILE_IO_H #ifndef CGAL_IO_FILE_HEADER_OFF_H #include #endif // CGAL_IO_FILE_HEADER_OFF_H #ifndef CGAL_PROTECT_IOSTREAM #include #define CGAL_PROTECT_IOSTREAM #endif #include #include CGAL_BEGIN_NAMESPACE class File_scanner_OFF : public File_header_OFF { std::istream& m_in; bool normals_read; void skip_comment() { m_in >> skip_comment_OFF; } public: File_scanner_OFF( std::istream& in, bool verbose = false) : File_header_OFF(verbose), m_in(in), normals_read(false) { in >> static_cast( *this); } File_scanner_OFF( std::istream& in, const File_header_OFF& header) : File_header_OFF(header), m_in(in), normals_read(false) {} std::istream& in() { return m_in; } // The scan_vertex() routine is provided for multiple // coordinate types to support parameterized polytopes. void scan_vertex( float& x, float& y, float& z) { if ( binary()) { I_Binary_read_big_endian_float32( m_in, x); I_Binary_read_big_endian_float32( m_in, y); I_Binary_read_big_endian_float32( m_in, z); if ( is_homogeneous()) { float w; I_Binary_read_big_endian_float32( m_in, w); x /= w; y /= w; z /= w; } } else { skip_comment(); m_in >> x >> y >> z; if ( is_homogeneous()) { float w; m_in >> w; x /= w; y /= w; z /= w; } } } void scan_vertex( double& x, double& y, double& z) { if ( binary()) { float f; I_Binary_read_big_endian_float32( m_in, f); x = f; I_Binary_read_big_endian_float32( m_in, f); y = f; I_Binary_read_big_endian_float32( m_in, f); z = f; if ( is_homogeneous()) { I_Binary_read_big_endian_float32( m_in, f); x /= f; y /= f; z /= f; } } else { skip_comment(); m_in >> x >> y >> z; if ( is_homogeneous()) { double w; m_in >> w; x /= w; y /= w; z /= w; } } } void scan_vertex( int& x, int& y, int& z) { if ( binary()) { float fx, fy, fz; I_Binary_read_big_endian_float32( m_in, fx); I_Binary_read_big_endian_float32( m_in, fy); I_Binary_read_big_endian_float32( m_in, fz); if ( is_homogeneous()) { float fw; I_Binary_read_big_endian_float32( m_in, fw); x = int( fx / fw); y = int( fy / fw); y = int( fz / fw); } else { x = int(fx); y = int(fy); z = int(fz); } } else { skip_comment(); if ( is_homogeneous()) { double fx, fy, fz, fw; m_in >> fx >> fy >> fz >> fw; x = int( fx / fw); y = int( fy / fw); y = int( fz / fw); } else { double d; m_in >> d; x = int(d); m_in >> d; y = int(d); m_in >> d; z = int(d); } } } void scan_vertex( float& x, float& y, float& z, float& w) { w = 1; if ( binary()) { I_Binary_read_big_endian_float32( m_in, x); I_Binary_read_big_endian_float32( m_in, y); I_Binary_read_big_endian_float32( m_in, z); if ( is_homogeneous()) I_Binary_read_big_endian_float32( m_in, w); } else { skip_comment(); m_in >> x >> y >> z; if ( is_homogeneous()) m_in >> w; } } void scan_vertex( double& x, double& y, double& z, double& w) { w = 1; if ( binary()) { float f; I_Binary_read_big_endian_float32( m_in, f); x = f; I_Binary_read_big_endian_float32( m_in, f); y = f; I_Binary_read_big_endian_float32( m_in, f); z = f; if ( is_homogeneous()) { I_Binary_read_big_endian_float32( m_in, f); w = f; } } else { skip_comment(); m_in >> x >> y >> z; if ( is_homogeneous()) m_in >> w; } } void scan_vertex( int& x, int& y, int& z, int& w) { w = 1; if ( binary()) { float f; I_Binary_read_big_endian_float32( m_in, f); x = int(f); I_Binary_read_big_endian_float32( m_in, f); y = int(f); I_Binary_read_big_endian_float32( m_in, f); z = int(f); if ( is_homogeneous()) { I_Binary_read_big_endian_float32( m_in, f); w = int(f); } } else { skip_comment(); double d; m_in >> d; x = int(d); m_in >> d; y = int(d); m_in >> d; z = int(d); if ( is_homogeneous()) { m_in >> d; w = int(d); } } } void scan_normal( float& x, float& y, float& z) { if ( has_normals()) { normals_read = true; if ( binary()) { I_Binary_read_big_endian_float32( m_in, x); I_Binary_read_big_endian_float32( m_in, y); I_Binary_read_big_endian_float32( m_in, z); if ( is_homogeneous()) { float w; I_Binary_read_big_endian_float32( m_in, w); x /= w; y /= w; z /= w; } } else { m_in >> x >> y >> z; if ( is_homogeneous()) { float w; m_in >> w; x /= w; y /= w; z /= w; } } } } void scan_normal( double& x, double& y, double& z) { if ( has_normals()) { normals_read = true; if ( binary()) { float fx, fy, fz; I_Binary_read_big_endian_float32( m_in, fx); I_Binary_read_big_endian_float32( m_in, fy); I_Binary_read_big_endian_float32( m_in, fz); if ( is_homogeneous()) { float fw; I_Binary_read_big_endian_float32( m_in, fw); x = fx / fw; y = fy / fw; y = fz / fw; } else { x = fx; y = fy; z = fz; } } else { if ( is_homogeneous()) { float fx, fy, fz, fw; m_in >> fx >> fy >> fz >> fw; x = fx / fw; y = fy / fw; y = fz / fw; } else m_in >> x >> y >> z; } } } void scan_normal( int& x, int& y, int& z) { if ( has_normals()) { normals_read = true; if ( binary()) { float fx, fy, fz; I_Binary_read_big_endian_float32( m_in, fx); I_Binary_read_big_endian_float32( m_in, fy); I_Binary_read_big_endian_float32( m_in, fz); if ( is_homogeneous()) { float fw; I_Binary_read_big_endian_float32( m_in, fw); x = int( fx / fw); y = int( fy / fw); y = int( fz / fw); } else { x = int(fx); y = int(fy); z = int(fz); } } else { if ( is_homogeneous()) { float fx, fy, fz, fw; m_in >> fx >> fy >> fz >> fw; x = int( fx / fw); y = int( fy / fw); y = int( fz / fw); } else { double d; m_in >> d; x = int(d); m_in >> d; y = int(d); m_in >> d; z = int(d); } } } } void scan_normal( float& x, float& y, float& z, float& w) { w = 1; if ( has_normals()) { normals_read = true; if ( binary()) { I_Binary_read_big_endian_float32( m_in, x); I_Binary_read_big_endian_float32( m_in, y); I_Binary_read_big_endian_float32( m_in, z); if ( is_homogeneous()) I_Binary_read_big_endian_float32( m_in, w); } else { m_in >> x >> y >> z; if ( is_homogeneous()) m_in >> w; } } } void scan_normal( double& x, double& y, double& z, double& w) { w = 1; if ( has_normals()) { normals_read = true; if ( binary()) { float f; I_Binary_read_big_endian_float32( m_in, f); x = f; I_Binary_read_big_endian_float32( m_in, f); y = f; I_Binary_read_big_endian_float32( m_in, f); z = f; if ( is_homogeneous()) { I_Binary_read_big_endian_float32( m_in, f); w = f; } } else { m_in >> x >> y >> z; if ( is_homogeneous()) m_in >> w; } } } void scan_normal( int& x, int& y, int& z, int& w) { w = 1; if ( has_normals()) { normals_read = true; if ( binary()) { float f; I_Binary_read_big_endian_float32( m_in, f); x = int(f); I_Binary_read_big_endian_float32( m_in, f); y = int(f); I_Binary_read_big_endian_float32( m_in, f); z = int(f); if ( is_homogeneous()) { I_Binary_read_big_endian_float32( m_in, f); w = int(f); } } else { double d; m_in >> d; x = int(d); m_in >> d; y = int(d); m_in >> d; z = int(d); if ( is_homogeneous()) { m_in >> d; w = int(d); } } } } void skip_to_next_vertex( int current_vertex); void scan_facet( Integer32& size, int current_facet) { CGAL_assertion( current_facet < size_of_facets()); if ( binary()) I_Binary_read_big_endian_integer32( m_in, size); else { skip_comment(); m_in >> size; } } void scan_facet_vertex_index( Integer32& index, int current_facet) { if ( binary()) I_Binary_read_big_endian_integer32( m_in, index); else m_in >> index; if( ! m_in) { if ( verbose()) { std::cerr << " " << std::endl; std::cerr << "File_scanner_OFF::" << std::endl; std::cerr << "scan_facet_vertex_index(): input error: " "cannot read OFF file beyond facet " << current_facet << "." << std::endl; } set_off_header( false); return; } index -= index_offset(); if( index < 0 || index >= size_of_vertices()) { m_in.clear( std::ios::badbit); if ( verbose()) { std::cerr << " " << std::endl; std::cerr << "File_scanner_OFF::" << std::endl; std::cerr << "scan_facet_vertex_index(): input error: " "facet " << current_facet << ": vertex index " << index + index_offset() << ": is out of range." << std::endl; } set_off_header( false); return; } } void skip_to_next_facet( int current_facet); }; template < class Point> inline Point& file_scan_vertex( File_scanner_OFF& scanner, Point& p) { typedef typename Point::R R; typedef typename R::RT RT; double x, y, z, w; scanner.scan_vertex( x, y, z, w); if ( w == 1) p = Point( RT(x), RT(y), RT(z)); else p = Point( RT(x), RT(y), RT(z), RT(w)); return p; } template < class Vector> inline Vector& file_scan_normal( File_scanner_OFF& scanner, Vector& v) { typedef typename Vector::R R; typedef typename R::RT RT; double x, y, z, w; scanner.scan_normal( x, y, z, w); if ( w == 1) v = Vector( RT(x), RT(y), RT(z)); else v = Vector( RT(x), RT(y), RT(z), RT(w)); return v; } CGAL_END_NAMESPACE #endif // CGAL_IO_FILE_SCANNER_OFF_H // // EOF // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_iso_rectangle.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_iso_r0000644000175000017500000001335411344301501031242 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_iso_rectangle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Radu Ursu #ifndef CGAL_QT_WIDGET_GET_ISO_RECTANGLE_H #define CGAL_QT_WIDGET_GET_ISO_RECTANGLE_H #include #include #include #include #ifndef CGAL_QT_LEFT_BUTTON #define CGAL_QT_LEFT_BUTTON Qt::LeftButton #endif namespace CGAL { template class Qt_widget_get_iso_rectangle : public Qt_widget_layer { private: QCursor cursor; QCursor oldcursor; public: int first_x, first_y, x2, y2; bool widgetrepainted; bool on_first; QWidget::FocusPolicy oldpolicy; typedef typename T::Iso_rectangle_2 Iso_rectangle_2; typedef typename T::RT RT; Qt_widget_get_iso_rectangle(const QCursor c=QCursor(Qt::crossCursor), QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), cursor(c), widgetrepainted(true), on_first(false) {}; void draw(){ widgetrepainted = true; }; protected: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_LEFT_BUTTON && is_pure(e->state())) { if (!on_first) { first_x = e->x(); first_y = e->y(); on_first = true; } else { if((e->x() != first_x) && (e->y() != first_y)) { RT x, y, xfirst2, yfirst2; widget->x_real(e->x(), x); widget->y_real(e->y(), y); widget->x_real(first_x, xfirst2); widget->y_real(first_y, yfirst2); RT xmin, xmax, ymin, ymax; if(x < xfirst2) {xmin = x; xmax = xfirst2;} else {xmin = xfirst2; xmax = x;}; if(y < yfirst2) {ymin = y; ymax = yfirst2;} else {ymin = yfirst2; ymax = y;}; widget->new_object( make_object(Iso_rectangle_2(xmin, ymin, xmax, ymax))); on_first = false; widgetrepainted = true; } } } }; void mouseMoveEvent(QMouseEvent *e) { if(on_first) { int x = e->x(); int y = e->y(); *widget << noFill; RasterOp old = widget->rasterOp(); //save the initial raster mode QColor old_color=widget->color(); widget->setRasterOp(XorROP); widget->lock(); widget->setColor(Qt::green); if(!widgetrepainted) widget->get_painter().drawRect(first_x, first_y, x2 - first_x, y2 - first_y); widget->get_painter().drawRect(first_x, first_y, x - first_x, y - first_y); widget->unlock(); widget->setColor(old_color); widget->setRasterOp(old); //save the last coordinates to redraw the screen x2 = x; y2 = y; widgetrepainted = false; } }; void keyPressEvent(QKeyEvent *e) { switch ( e->key() ) { case Key_Escape: // key_escape if (on_first) { widget->lock(); *widget << noFill; RasterOp old = widget->rasterOp(); //save the initial raster mode QColor old_color=widget->color(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; if(!widgetrepainted) widget->get_painter().drawRect(first_x, first_y, x2 - first_x, y2 - first_y); widget->setColor(old_color); widget->setRasterOp(old); widgetrepainted = true; widget->unlock(); on_first = false; } break; }//endswitch } void leaveEvent(QEvent *) { if (on_first) { widget->lock(); *widget << noFill; RasterOp old = widget->rasterOp(); //save the initial raster mode QColor old_color=widget->color(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; if(!widgetrepainted) widget->get_painter().drawRect(first_x, first_y, x2 - first_x, y2 - first_y); widget->setColor(old_color); widget->setRasterOp(old); widgetrepainted = true; widget->unlock(); } } void activating() { oldpolicy = widget->focusPolicy(); widget->setFocusPolicy(QWidget::StrongFocus); oldcursor = widget->cursor(); widget->setCursor(cursor); widgetrepainted = true; }; void deactivating() { widget->setCursor(oldcursor); widget->setFocusPolicy(oldpolicy); on_first = false; }; };//end class } // namespace CGAL #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_logo.h0000644000175000017500000000252211344301501027430 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/cgal_logo.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_LOGO_H #define CGAL_LOGO_H CGAL_BEGIN_NAMESPACE #if !defined(__LEDA__) || (__LEDA__ > 400) extern const char * cgal_logo[]; #else extern char * cgal_logo[]; #endif // __LEDA__ CGAL_END_NAMESPACE #endif // CGAL_LOGO_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_2_PS_stream.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_2_PS0000644000175000017500000000750611344301501031061 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Nef_polyhedron_2_PS_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel #ifndef NEF_POLYHEDRON_2_PS_STREAM_H #define NEF_POLYHEDRON_2_PS_STREAM_H #include #include #include #include CGAL_BEGIN_NAMESPACE static int frame_default = 100; template leda_list face_cycle(CIRC c) { leda_list L; CIRC c_end(c); CGAL_For_all(c,c_end) { L.append(leda_point(CGAL::to_double(c->vertex()->point().x()), CGAL::to_double(c->vertex()->point().y()))); } return L; } template ps_file& operator<<(ps_file& PS, const Nef_polyhedron_2& P) { typedef Nef_polyhedron_2 NefPoly; typedef typename NefPoly::Const_decorator PMCDec; typedef typename NefPoly::Point Point; typedef typename NefPoly::Line Line; typedef typename T::RT RT; typedef typename T::Standard_RT Standard_RT; PMCDec D = P.explorer(); const T& E = Nef_polyhedron_2::EK; Standard_RT frame_radius = frame_default; E.determine_frame_radius(D.points_begin(),D.points_end(),frame_radius); RT::set_R(frame_radius); double r = CGAL::to_double(frame_radius); PS.init(-r,r,-r); typedef typename PMCDec::Vertex_const_iterator Vertex_const_iterator; typedef typename PMCDec::Halfedge_const_iterator Halfedge_const_iterator; typedef typename PMCDec::Face_const_iterator Face_const_iterator; typedef typename PMCDec::Hole_const_iterator Hole_const_iterator; typedef typename PMCDec::Halfedge_around_face_const_circulator Halfedge_around_face_const_circulator; Face_const_iterator fit = D.faces_begin(); for (++fit; fit != D.faces_end(); ++fit) { leda_list LP; Halfedge_around_face_const_circulator hfc(fit->halfedge()); LP.append(leda_polygon(face_cycle(hfc),leda_polygon::NO_CHECK)); Hole_const_iterator hit; for (hit = fit->fc_begin(); hit != fit->fc_end(); ++hit) { hfc = Halfedge_around_face_const_circulator(hit); LP.append(leda_polygon(face_cycle(hfc),leda_polygon::NO_CHECK)); } leda_gen_polygon GP(LP,leda_gen_polygon::NO_CHECK); if ( fit->mark() ) PS.set_fill_color(leda_grey3); else PS.set_fill_color(leda_white); PS << GP; } Halfedge_const_iterator hit; for (hit = D.halfedges_begin(); hit != D.halfedges_end(); ++(++hit)) { leda_segment s(CGAL::to_double(hit->vertex()->point().x()), CGAL::to_double(hit->vertex()->point().y()), CGAL::to_double(hit->opposite()->vertex()->point().x()), CGAL::to_double(hit->opposite()->vertex()->point().y())); if ( hit->mark() ) PS.set_color(leda_black); else PS.set_color(leda_grey1); PS << s; } PS.set_node_width(3); Vertex_const_iterator v; for (v = D.vertices_begin(); v != D.vertices_end(); ++v) { leda_point p(CGAL::to_double(v->point().x()), CGAL::to_double(v->point().y())); leda_color pc; if ( v->mark() ) pc = leda_black; else pc = leda_grey1; PS.draw_filled_node(p,pc); } return PS; } CGAL_END_NAMESPACE #endif // NEF_POLYHEDRON_2_PS_STREAM_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_line.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_line.0000644000175000017500000001201511344301501031125 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IO/Qt_widget_get_line.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Ursu Radu #ifndef CGAL_QT_WIDGET_GET_LINE_H #define CGAL_QT_WIDGET_GET_LINE_H #include #include #include #ifndef CGAL_QT_WIDGET_GET_POINT_BUTTON #define CGAL_QT_WIDGET_GET_POINT_BUTTON Qt::LeftButton #endif namespace CGAL { template class Qt_widget_get_line : public Qt_widget_layer { public: typedef typename R::Point_2 Point; typedef typename R::Line_2 Line; typedef typename R::FT FT; Qt_widget_get_line(const QCursor c = QCursor(Qt::crossCursor), QObject* parent = 0, const char* name = 0) : Qt_widget_layer(parent, name), cursor(c), firstpoint(false), firsttime(true){}; void draw(){ firsttime = true; } protected: bool is_pure(Qt::ButtonState s){ if((s & Qt::ControlButton) || (s & Qt::ShiftButton) || (s & Qt::AltButton)) return 0; else return 1; } void mousePressEvent(QMouseEvent *e) { if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && !firstpoint && is_pure(e->state())) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); x1 = x; y1 = y; x2 = x; y2 = y; firstpoint = TRUE; } else if(e->button() == CGAL_QT_WIDGET_GET_POINT_BUTTON && is_pure(e->state())){ FT x, y; widget->x_real(e->x(), x), widget->y_real(e->y(), y); if(x1!=x || y1!=y) { widget->new_object(make_object(Line(Point(x1,y1),Point(x,y)))); firstpoint = FALSE; } } } void keyPressEvent(QKeyEvent *e) { switch ( e->key() ) { case Key_Escape: // key_escape if(firstpoint) { firstpoint = false; RasterOp old_raster = widget->rasterOp(); QColor old_color = widget->color(); widget->lock(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; *widget << Line(Point(x1,y1),Point(x2,y2)); widget->setRasterOp(old_raster); widget->setColor(old_color); widget->unlock(); firsttime = true; } break; }//endswitch } void leaveEvent(QEvent *) { if(firstpoint) { RasterOp old_raster = widget->rasterOp();//save the initial raster mode QColor old_color = widget->color(); widget->lock(); widget->setRasterOp(XorROP); *widget << CGAL::GREEN; *widget << Line(Point(x1,y1),Point(x2,y2)); widget->setRasterOp(old_raster); widget->setColor(old_color); widget->unlock(); firsttime = true; } } void mouseMoveEvent(QMouseEvent *e) { if(firstpoint) { FT x, y; widget->x_real(e->x(), x); widget->y_real(e->y(), y); RasterOp old_raster = widget->rasterOp();//save the initial raster mode QColor old_color = widget->color(); widget->setRasterOp(XorROP); widget->lock(); *widget << CGAL::GREEN; if(!firsttime) *widget << Line(Point(x1,y1),Point(x2,y2)); *widget << Line(Point(x1,y1),Point(x,y)); widget->unlock(); widget->setRasterOp(old_raster); widget->setColor(old_color); //save the last coordinates to redraw the screen x2 = x; y2 = y; firsttime = false; } }; void activating() { oldpolicy = widget->focusPolicy(); widget->setFocusPolicy(QWidget::StrongFocus); oldcursor = widget->cursor(); widget->setCursor(cursor); }; void deactivating() { widget->setFocusPolicy(oldpolicy); widget->setCursor(oldcursor); firstpoint = false; }; QCursor oldcursor; QCursor cursor; FT x1, //the X of the first point y1; //the Y of the first point FT x2, //the old second point's X y2; //the old second point's Y bool firstpoint, //true if the user left clicked once firsttime; //true if the line is not drawn QWidget::FocusPolicy oldpolicy; };//end class } // namespace CGAL #endif // CGAL_QT_WIDGET_GET_LINE_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Plane_3_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Plane_3_do_0000644000175000017500000000557311344301501031127 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Plane_3_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_3_PLANE_3_DO_INTERSECT_H #define CGAL_TRIANGLE_3_PLANE_3_DO_INTERSECT_H CGAL_BEGIN_NAMESPACE namespace CGALi { template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t, const typename CGAL_WRAP(K)::Plane_3 &h, const K & k) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t)) ; CGAL_kernel_precondition( ! k.is_degenerate_3_object()(h)) ; typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Oriented_side_3 oriented_side = k.oriented_side_3_object(); switch ( oriented_side(h,vertex_on(t,0)) ) { case ON_POSITIVE_SIDE: return oriented_side(h,vertex_on(t,1)) != ON_POSITIVE_SIDE || oriented_side(h,vertex_on(t,2)) != ON_POSITIVE_SIDE; case ON_NEGATIVE_SIDE: return oriented_side(h,vertex_on(t,1)) != ON_NEGATIVE_SIDE || oriented_side(h,vertex_on(t,2)) != ON_NEGATIVE_SIDE ; case ON_ORIENTED_BOUNDARY: return true; default:// should not happen. CGAL_kernel_assertion(false); return false; } } template inline bool do_intersect(const typename CGAL_WRAP(K)::Plane_3 &h, const typename CGAL_WRAP(K)::Triangle_3 &t, const K & k) { return do_intersect(t, h, k); } } // namespace CGALi template inline bool do_intersect(const Triangle_3 &t, const Plane_3 &h) { return typename K::Do_intersect_3()(t,h); } template inline bool do_intersect(const Plane_3 &h, const Triangle_3 &t) { return typename K::Do_intersect_3()(t,h); } /* template inline bool do_intersect(const Plane_3 &h, const Triangle_3 &t, const K & k) { return do_intersect(t,h,k); } */ CGAL_END_NAMESPACE #endif //CGAL_TRIANGLE_3_PLANE_3_DO_INTERSECT_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_euclidean_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_euclidean_0000644000175000017500000000343011344301500031320 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_euclidean_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_ALPHA_SHAPE_EUCLIDEAN_TRAITS_3_H #define CGAL_ALPHA_SHAPE_EUCLIDEAN_TRAITS_3_H CGAL_BEGIN_NAMESPACE template class Alpha_shape_euclidean_traits_3 : public K { /* public: */ /* class Compute_squared_radius_3 { */ /* typedef typename K::Point_3 Point_3; */ /* typedef typename K::FT FT; */ /* typedef typename K::Compute_squared_radius_3 Base; */ /* public: */ /* FT operator() (Point_3 p, Point_3 q , Point_3 r, Point_3 s) { */ /* return Base()(p,q,r,s); } */ /* FT operator() (Point_3 p, Point_3 q , Point_3 r) { */ /* return Base()(p,q,r); } */ /* FT operator() (Point_3 p, Point_3 q ) { */ /* return Base()(p,q); } */ /* FT operator() (Point_3 p) { */ /* return FT(0);} */ /* }; */ /* Compute_squared_radius_3 */ /* compute_squared_radius_3_object() const { */ /* return Compute_squared_radius_3(); } */ }; CGAL_END_NAMESPACE #endif //CGAL_ALPHA_SHAPE_EUCLIDEAN_TRAITS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_pair.h0000644000175000017500000000651611344301500030323 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_pair.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_CIRC_PAIR_H #define CGAL_CIRC_PAIR_H namespace CGAL { // // "before" always means a point between front and back in the indicated // direction // // "after" always means a point just beyond the range of [front,back] // template class Circ_pair { public: Circ_pair(BidirectionalCirculator back, BidirectionalCirculator front) : _front(front), _back(back), _direction(COUNTERCLOCKWISE) {} Circ_pair(BidirectionalCirculator back, BidirectionalCirculator front, Orientation dir) : _front(front), _back(back), _direction(dir) {} Circ_pair(BidirectionalCirculator front_and_back, Orientation dir) : _front(front_and_back), _back(front_and_back), _direction(dir) {} void initialize(BidirectionalCirculator new_back_and_front) { _back = _front = new_back_and_front; } void push_back(BidirectionalCirculator new_back) { _back = new_back; } void pop_back() { _back = before_back(); } void push_front(BidirectionalCirculator new_front) { _front = new_front; } void pop_front() { _front = before_front(); } BidirectionalCirculator front() const { return _front; } BidirectionalCirculator back() const { return _back; } Orientation direction() const { return _direction; } void set_direction(Orientation direction) { _direction = direction; } void change_dir() { if (_direction == CLOCKWISE) _direction = COUNTERCLOCKWISE; else _direction = CLOCKWISE; } BidirectionalCirculator before_back() { BidirectionalCirculator temp = _back; if (_direction == COUNTERCLOCKWISE) return ++temp; else return --temp; } BidirectionalCirculator after_back() { BidirectionalCirculator temp = _back; if (_direction == COUNTERCLOCKWISE) return --temp; else return ++temp; } BidirectionalCirculator before_front() { BidirectionalCirculator temp = _front; if (_direction == COUNTERCLOCKWISE) return --temp; else return ++temp; } BidirectionalCirculator after_front() { BidirectionalCirculator temp = _front; if (_direction == COUNTERCLOCKWISE) return ++temp; else return --temp; } private: BidirectionalCirculator _front, _back; Orientation _direction; }; } #endif // CGAL_CIRC_PAIR_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_constructions_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_const0000644000175000017500000003006011344301500031456 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_constructions_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_2_H #define CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE //*********************************************************************** //*********************************************************************** // CONSTRUCTIONS //*********************************************************************** //*********************************************************************** //----------------------------------------------------------------------- // Apollonius vertex //----------------------------------------------------------------------- template < class Gt > inline typename Gt::Point_2 ad_circumcenter_2(const typename Gt::Site_2& p, const typename Gt::Site_2& q, const typename Gt::Site_2& r) { typedef typename Gt::Point_2 Point_2; typename Gt::FT x,y; ad_circumcenterC2(p.x(),p.y(),p.weight(), q.x(),q.y(),q.weight(), r.x(),r.y(),r.weight(),x,y); return Point_2(x,y); } template < class Gt > class Construct_Apollonius_vertex_2 { public: typedef typename Gt::Point_2 Point_2; typedef typename Gt::Site_2 Site_2; Point_2 operator() (const Site_2& p, const Site_2& q, const Site_2& r) const { return ad_circumcenter_2< Gt >(p,q,r); } }; //----------------------------------------------------------------------- // Apollonius site (dual site) //----------------------------------------------------------------------- template < class Gt > inline typename Gt::Site_2 ad_circumcircle_2(const typename Gt::Site_2& p, const typename Gt::Site_2& q, const typename Gt::Site_2& r) { typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typename Gt::FT x, y, wt; ad_circumcircleC2(p.x(),p.y(),p.weight(), q.x(),q.y(),q.weight(), r.x(),r.y(),r.weight(),x,y,wt); return Site_2(Point_2(x,y), wt); } template < class Gt > inline typename Gt::Line_2 ad_left_bitangent_line_2(const typename Gt::Site_2& p, const typename Gt::Site_2& q) { typedef typename Gt::Line_2 Line_2; typename Gt::FT a, b, c; ad_left_bitangent_lineC2(p.x(),p.y(),p.weight(), q.x(),q.y(),q.weight(), a,b,c); return Line_2(a, b, c); } template < class Gt > class Construct_Apollonius_site_2 { public: typedef typename Gt::Line_2 Line_2; typedef typename Gt::Point_2 Point_2; typedef typename Gt::Site_2 Site_2; inline Site_2 operator()(const Site_2& p, const Site_2& q, const Site_2& r) const { // CGAL_precondition( ! collinear(p, q, r) ); return ad_circumcircle_2< Gt >(p,q,r); } inline Line_2 operator()(const Site_2 &p, const Site_2 &q) const { return ad_left_bitangent_line_2< Gt >(p, q); } }; //----------------------------------------------------------------------- // Apollonius bisector //----------------------------------------------------------------------- template< class Gt > class Construct_Apollonius_bisector_2 { public: typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Object_2 Object_2; typedef typename Gt::Construct_object_2 Construct_object_2; typedef CGAL::Hyperbola_2 Hyperbola_2; private: template Object_2 make_object(const T& t) const { return Construct_object_2()(t); } public: Object_2 operator() (const Site_2& p, const Site_2& q) const { Comparison_result cr = CGAL::compare(p.weight(), q.weight()); if ( cr == EQUAL ) { Line_2 l1(p.point(), q.point()); Line_2 l = l1.perpendicular(midpoint(p.point(), q.point())); return make_object(l); } Hyperbola_2 h(p, q); return make_object(h); } }; //----------------------------------------------------------------------- // Apollonius bisector ray //----------------------------------------------------------------------- template< class Gt > class Construct_Apollonius_bisector_ray_2 { public: typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::Ray_2 Ray_2; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Object_2 Object_2; typedef typename Gt::Construct_object_2 Construct_object_2; typedef CGAL::Hyperbola_ray_2 Hyperbola_ray_2; typedef CGAL::Sign Hyperbola_direction; typedef CGAL::Construct_Apollonius_vertex_2 Apollonius_vertex_2; private: template Object_2 make_object(const T& t) const { return Construct_object_2()(t); } public: Object_2 operator() (const Site_2& p, const Site_2& q, const Point_2& r, const Hyperbola_direction& direction) const { // Comparison_result cr = CGAL::compare(p.weight(), q.weight()); if ( cr == EQUAL ) { Line_2 l1(q, p); Line_2 l = l1.perpendicular(midpoint(p.point(), q.point())); Ray_2 ray(r, l.direction()); return make_object(ray); } Hyperbola_ray_2 hr(p, q, r, direction); return make_object(hr); } Object_2 operator() (const Site_2& p, const Site_2& q, const Site_2& r) const { Point_2 c = Apollonius_vertex_2()(p, q, r); Comparison_result cr = CGAL::compare(p.weight(), q.weight()); if ( cr == EQUAL ) { Line_2 l1(q.point(), p.point()); Line_2 l = l1.perpendicular(midpoint(p.point(), q.point())); Ray_2 ray(c, l.direction()); return make_object(ray); } Hyperbola_ray_2 hr(p, q, c, NEGATIVE); return make_object(hr); } }; //----------------------------------------------------------------------- // Apollonius bisector segment //----------------------------------------------------------------------- template< class Gt > class Construct_Apollonius_bisector_segment_2 { public: typedef typename Gt::Point_2 Point_2; typedef typename Gt::Segment_2 Segment_2; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Object_2 Object_2; typedef typename Gt::Construct_object_2 Construct_object_2; typedef CGAL::Hyperbola_segment_2 Hyperbola_segment_2; typedef CGAL::Construct_Apollonius_vertex_2 Apollonius_vertex_2; private: template Object_2 make_object(const T& t) const { return Construct_object_2()(t); } public: inline Object_2 operator() (const Site_2& p, const Site_2& q, const Point_2& r, const Point_2& s) const { // Comparison_result cr = CGAL::compare(p.weight(), q.weight()); if ( cr == EQUAL ) { Segment_2 seg(r, s); return make_object(seg); } Hyperbola_segment_2 hs(p, q, r, s); return make_object(hs); } inline Object_2 operator() (const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s) const { Apollonius_vertex_2 apollonius_vertex_2; Point_2 c_pqr = apollonius_vertex_2(p,q,r); Point_2 c_qps = apollonius_vertex_2(q,p,s); // Comparison_result cr = CGAL::compare(p.weight(), q.weight()); if ( cr == EQUAL ) { Segment_2 seg(c_pqr, c_qps); return make_object(seg); } Hyperbola_segment_2 hs(p, q, c_pqr, c_qps); return make_object(hs); } }; //----------------------------------------------------------------------- // Apollonius primal ray //----------------------------------------------------------------------- template< class Gt > class Construct_Apollonius_primal_ray_2 { private: typedef typename Gt::RT RT; public: typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::Ray_2 Ray_2; typedef typename Gt::Site_2 Site_2; typedef CGAL::Construct_Apollonius_site_2 Apollonius_circle_2; inline Ray_2 operator() (const Site_2& p, const Site_2& r, const Site_2& s) const { // Apollonius_circle_2 apollonius_circle_2; Line_2 l1 = apollonius_circle_2(r, p); Line_2 l2 = apollonius_circle_2(p, s); RT d1 = CGAL::sqrt( CGAL::square(l1.a()) + CGAL::square(l1.b()) ); RT d2 = CGAL::sqrt( CGAL::square(l2.a()) + CGAL::square(l2.b()) ); RT a = l1.a() / d1 - l2.a() / d2; RT b = l1.b() / d1 - l2.b() / d2; Point_2 c(p.x() + b, p.y() - a); return Ray_2(p.point(), c); } }; //----------------------------------------------------------------------- // Apollonius primal segment //----------------------------------------------------------------------- template< class Gt > class Construct_Apollonius_primal_segment_2 { public: typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::Segment_2 Segment_2; typedef typename Gt::Site_2 Site_2; typedef typename Gt::Object_2 Object_2; typedef typename Gt::Construct_object_2 Construct_object_2; typedef typename Gt::RT Weight; typedef CGAL::Hyperbola_segment_2 Hyperbola_segment_2; typedef CGAL::Parabola_segment_2 Parabola_segment_2; typedef CGAL::Construct_Apollonius_site_2 Apollonius_circle_2; private: template Object_2 make_object(const T& t) const { return Construct_object_2()(t); } public: inline Segment_2 operator() (const Site_2& p, const Site_2& q) const { // return Segment_2(p.point(), q.point()); } inline Object_2 operator() (const Site_2& p, const Site_2& q, const Point_2& r, const Point_2& s) const { // Comparison_result cr = CGAL::compare(p.weight(), q.weight()); if ( cr == EQUAL ) { Segment_2 seg(r, s); return make_object(seg); } Hyperbola_segment_2 hs(p, q, r, s); return make_object(hs); } inline Object_2 operator() (const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s) const { Apollonius_circle_2 apollonius_circle_2; Site_2 c_pqr = apollonius_circle_2(p, q, r); Site_2 c_qps = apollonius_circle_2(q, p, s); // Comparison_result cr = CGAL::compare(c_pqr.weight(), c_qps.weight()); if ( cr == EQUAL ) { Segment_2 seg(p.point(), q.point()); return make_object(seg); } Hyperbola_segment_2 hs(c_pqr, c_qps, p.point(), q.point()); return make_object(hs); } inline Parabola_segment_2 operator() (const Site_2& p, const Site_2& q, const Site_2& r) const { // Apollonius_circle_2 apollonius_circle_2; Site_2 c = apollonius_circle_2(p, q, r); Line_2 l = apollonius_circle_2(q, p); return Parabola_segment_2(c, l, q.point(), p.point()); } }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_C2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposit0000755000175000017500000000000012146213731031456 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/Td_predicates.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposit0000644000175000017500000000445711344301501031462 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/Td_predicates.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_TD_PREDICATES_H #define CGAL_TD_PREDICATES_H #ifndef CGAL_BASIC_H #include #endif #include CGAL_BEGIN_NAMESPACE template < class Td_traits> class Trapezoidal_decomposition_2; template struct Td_active_trapezoid : public std::unary_function { bool operator()(const X_trapezoid& tr) const { return tr.is_active(); } }; template struct Td_active_non_degenerate_trapezoid : public std::unary_function { Td_active_non_degenerate_trapezoid(Traits& t) : traits(t) {} bool operator()(const X_trapezoid& tr) const { return tr.is_active() && !traits.is_degenerate(tr); } protected: const Traits& traits; }; template struct Td_active_right_degenerate_curve_trapezoid: public std::unary_function { typedef const Traits& const_Traits_ref; Td_active_right_degenerate_curve_trapezoid(const_Traits_ref t) : traits(t) {} bool operator()(const X_trapezoid& tr) const { return tr.is_active() && traits.is_degenerate_curve(tr) && !tr.right_bottom_neighbour(); } protected: const Traits& traits; }; template struct Trapezoid_handle_less : public std::binary_function<_Tp, _Tp, bool> { bool operator()(const _Tp& __x, const _Tp& __y) const { return __x->id() < __y->id(); } }; /* Return if two trapezoids are the same */ CGAL_END_NAMESPACE #endif //CGAL_TD_PREDICATES_H ././@LongLink0000000000000000000000000000021500000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/Trapezoidal_decomposition_2_misc.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposit0000644000175000017500000000404411344301501031452 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/Trapezoidal_decomposition_2_misc.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_TRAPEZOIDAL_DECOMPOSITION_2_MISC_H #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_MISC_H #ifndef CGAL_TD_TENTUPLE_H #include #endif #ifndef CGAL_TWOTUPLE_H #include #endif #ifndef CGAL_TD_DAG_H #include #endif #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_DELETE_SIGNATURE 0xffffffff #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED 0x1 #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED 0x2 #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED 0x4 #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED 0x8 #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOTALLY_UNBOUNDED \ (CGAL_TRAPEZOIDAL_DECOMPOSITION_2_LEFT_UNBOUNDED| \ CGAL_TRAPEZOIDAL_DECOMPOSITION_2_RIGHT_UNBOUNDED| \ CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOTTOM_UNBOUNDED| \ CGAL_TRAPEZOIDAL_DECOMPOSITION_2_TOP_UNBOUNDED) #define CGAL_TRAPEZOIDAL_DECOMPOSITION_2_BOUNDED 0 #define CGAL_TD_DEFAULT_DEPTH_THRESHOLD 2 #define CGAL_TD_DEFAULT_SIZE_THRESHOLD 2 #ifndef _MSC_VER #ifndef __BORLANDC__ #if !defined __GNUC__ || __GNUC__>2 || __GNUC__==2 && __GNUC_MINOR__>=95 #define CGAL_PM_FRIEND_CLASS #endif #endif #endif #endif ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/Td_ninetuple.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposit0000644000175000017500000000317511344301501031456 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Trapezoidal_decomposition_2/Td_ninetuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_TD_NINETUPLE_H #define CGAL_TD_NINETUPLE_H CGAL_BEGIN_NAMESPACE template class Td_ninetuple : public Rep { public: F0 e0; F1 e1; F2 e2; F3 e3; F4 e4; F5 e5; F6 e6; F7 e7; F8 e8; Td_ninetuple() {} Td_ninetuple(const F0 & a0, const F1 & a1, const F2 & a2, const F3 & a3, const F4 & a4, const F5 & a5, const F6 & a6, const F7 & a7, const F8 & a8) : e0(a0),e1(a1),e2(a2),e3(a3),e4(a4),e5(a5),e6(a6),e7(a7),e8(a8) {} Td_ninetuple(const Td_ninetuple & a) : e0(a.e0),e1(a.e1),e2(a.e2),e3(a.e3),e4(a.e4),e5(a.e5),e6(a.e6),e7(a.e7), e8(a.e8) {} ~Td_ninetuple() {} }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sorted_matrix_search_traits_adaptor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sorted_matrix_search_t0000644000175000017500000000436511344301501031450 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sorted_matrix_search_traits_adaptor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_SORTED_MATRIX_SEARCH_TRAITS_ADAPTOR_H) #define CGAL_SORTED_MATRIX_SEARCH_TRAITS_ADAPTOR_H 1 CGAL_BEGIN_NAMESPACE template < class FeasibilityTest_, class Matrix_ > class Sorted_matrix_search_traits_adaptor { public: typedef FeasibilityTest_ FeasibilityTest; typedef Matrix_ Matrix; typedef typename Matrix::Value Value; typedef std::less< Value > Compare_strictly; typedef std::less_equal< Value > Compare_non_strictly; Sorted_matrix_search_traits_adaptor(FeasibilityTest ft) : ft_( ft) {} Compare_strictly compare_strictly() const { return Compare_strictly(); } Compare_non_strictly compare_non_strictly() const { return Compare_non_strictly(); } bool is_feasible(Value a) { return ft_( a); } protected: FeasibilityTest ft_; }; //!!! with iterator traits we replace const Matrix& // by an iterator with value type Matrix template < class FeasibilityTest, class Matrix > Sorted_matrix_search_traits_adaptor< FeasibilityTest, Matrix > sorted_matrix_search_traits_adaptor(FeasibilityTest f, const Matrix&) { typedef Sorted_matrix_search_traits_adaptor< FeasibilityTest, Matrix > Traits; return Traits(f); } // sorted_matrix_search_traits_adaptor( ... ) CGAL_END_NAMESPACE #endif // ! (CGAL_SORTED_MATRIX_SEARCH_TRAITS_ADAPTOR_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous.h0000644000175000017500000000471311344301500027466 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_H #define CGAL_HOMOGENEOUS_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename RT_, typename FT_, typename Kernel > struct Homogeneous_base_ref_count : public Homogeneous_base< Kernel > { typedef RT_ RT; typedef FT_ FT; // The mecanism that allows to specify reference-counting or not. template < typename T > struct Handle { typedef Handle_for type; }; template < typename Kernel2 > struct Base { typedef Homogeneous_base_ref_count Type; }; // TODO: cleanup (use Rational_traits<> instead) static FT make_FT(const RT & num, const RT& denom) { return FT(num, denom); } static FT make_FT(const RT & num) { return FT(num); } static RT FT_numerator(const FT &r) { return r.numerator(); } static RT FT_denominator(const FT &r) { return r.denominator(); } }; template < typename RT_, typename FT_ = Quotient > struct Homogeneous : public Type_equality_wrapper< Homogeneous_base_ref_count >, Homogeneous > {}; CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/concept_archetype_3.h0000644000175000017500000002172611344301500031122 0ustar debiandebian// Copyright (c) 1999,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/concept_archetype_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_CONCEPT_ARCHETYPE_3 #define CGAL_CONCEPT_ARCHETYPE_3 // 3d CA types ... #define CGAL_concept_archetype_constructors(T) \ template T(const T1&) { } \ template T(const T1&,const T2&) { } \ template T(const T1&,const T2&,const T3&) { } \ template \ T(const T1&,const T2&,const T3&,const T4&) { } \ template \ T(const T1&,const T2&,const T3&,const T4&,const T5&) { } CGAL_BEGIN_NAMESPACE struct Point_3_archetype { Point_3_archetype() { } Point_3_archetype(const Point_3_archetype& t) { } Point_3_archetype& operator=(const Point_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Point_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Point_3_archetype& obj1, const Point_3_archetype& obj2) { return true; } inline bool operator!=(const Point_3_archetype& obj1, const Point_3_archetype& obj2) { return true; } #endif struct Segment_3_archetype { Segment_3_archetype() { } Segment_3_archetype(const Segment_3_archetype& t) { } Segment_3_archetype& operator=(const Segment_3_archetype& t){return *this;} #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Segment_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Segment_3_archetype& obj1, const Segment_3_archetype& obj2) { return true; } inline bool operator!=(const Segment_3_archetype& obj1, const Segment_3_archetype& obj2) { return true; } #endif struct Line_3_archetype { Line_3_archetype() { } Line_3_archetype(const Line_3_archetype& t) { } Line_3_archetype& operator=(const Line_3_archetype& t){return *this;} #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Line_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Line_3_archetype& obj1, const Line_3_archetype& obj2) { return true; } inline bool operator!=(const Line_3_archetype& obj1, const Line_3_archetype& obj2) { return true; } #endif struct Ray_3_archetype { Ray_3_archetype() { } Ray_3_archetype(const Ray_3_archetype& t) { } Ray_3_archetype& operator=(const Ray_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Ray_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Ray_3_archetype& obj1, const Ray_3_archetype& obj2) { return true; } inline bool operator!=(const Ray_3_archetype& obj1, const Ray_3_archetype& obj2) { return true; } #endif struct Vector_3_archetype { Vector_3_archetype() { } Vector_3_archetype(const Vector_3_archetype& t) { } Vector_3_archetype& operator=(const Vector_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Vector_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Vector_3_archetype& obj1, const Vector_3_archetype& obj2) { return true; } inline bool operator!=(const Vector_3_archetype& obj1, const Vector_3_archetype& obj2) { return true; } #endif struct Direction_3_archetype { Direction_3_archetype() { } Direction_3_archetype(const Direction_3_archetype& t) { } Direction_3_archetype& operator=(const Direction_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Direction_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Direction_3_archetype& obj1, const Direction_3_archetype& obj2) { return true; } inline bool operator!=(const Direction_3_archetype& obj1, const Direction_3_archetype& obj2) { return true; } #endif struct Plane_3_archetype { Plane_3_archetype() { } Plane_3_archetype(const Plane_3_archetype& t) { } Plane_3_archetype& operator=(const Plane_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Plane_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Plane_3_archetype& obj1, const Plane_3_archetype& obj2) { return true; } inline bool operator!=(const Plane_3_archetype& obj1, const Plane_3_archetype& obj2) { return true; } #endif struct Iso_cuboid_3_archetype { Iso_cuboid_3_archetype() { } Iso_cuboid_3_archetype(const Iso_cuboid_3_archetype& t) { } Iso_cuboid_3_archetype& operator=(const Iso_cuboid_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Iso_cuboid_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Iso_cuboid_3_archetype& obj1, const Iso_cuboid_3_archetype& obj2) { return true; } inline bool operator!=(const Iso_cuboid_3_archetype& obj1, const Iso_cuboid_3_archetype& obj2) { return true; } #endif struct Sphere_3_archetype { Sphere_3_archetype() { } Sphere_3_archetype(const Sphere_3_archetype& t) { } Sphere_3_archetype& operator=(const Sphere_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Sphere_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Sphere_3_archetype& obj1, const Sphere_3_archetype& obj2) { return true; } inline bool operator!=(const Sphere_3_archetype& obj1, const Sphere_3_archetype& obj2) { return true; } #endif struct Triangle_3_archetype { Triangle_3_archetype() { } Triangle_3_archetype(const Triangle_3_archetype& t) { } Triangle_3_archetype& operator=(const Triangle_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Triangle_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Triangle_3_archetype& obj1, const Triangle_3_archetype& obj2) { return true; } inline bool operator!=(const Triangle_3_archetype& obj1, const Triangle_3_archetype& obj2) { return true; } #endif struct Tetrahedron_3_archetype { Tetrahedron_3_archetype() { } Tetrahedron_3_archetype(const Tetrahedron_3_archetype& t) { } Tetrahedron_3_archetype& operator=(const Tetrahedron_3_archetype& t) { return *this; } #if defined(CGAL_CONCEPT_ARCHETYPE_PROVIDE_CONSTRUCTORS) CGAL_concept_archetype_constructors(Tetrahedron_3_archetype) #endif }; #if defined(CGAL_CONCEPT_ARCHETYPE_ALLOW_COMPARISONS) inline bool operator==(const Tetrahedron_3_archetype& obj1, const Tetrahedron_3_archetype& obj2) { return true; } inline bool operator!=(const Tetrahedron_3_archetype& obj1, const Tetrahedron_3_archetype& obj2) { return true; } #endif struct Cartesian_coordinate_const_iterator_3_archetype { Cartesian_coordinate_const_iterator_3_archetype() { } Cartesian_coordinate_const_iterator_3_archetype& operator=(const Cartesian_coordinate_const_iterator_3_archetype&) { return *this; } }; CGAL_END_NAMESPACE #undef CGAL_concept_archetype_constructors #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_vertex_map.h0000644000175000017500000003561011344301500031401 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_vertex_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_VERTEX_MAP_H #define CGAL_PARTITION_VERTEX_MAP_H #include #include #include #include #include namespace CGAL { const int PARTITION_VMAP_UNSHARED_EDGE = -1; template class Partition_vertex_map; template class Edge_info; template class CW_indirect_edge_info_compare { public: typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Less_xy_2 Less_xy_2; typedef typename Traits::Point_2 Point_2; typedef CGAL::Edge_info Edge_info; CW_indirect_edge_info_compare(){} CW_indirect_edge_info_compare (Iterator v_it) : vertex_it(v_it), left_turn(Traits().left_turn_2_object()), less_xy(Traits().less_xy_2_object()) {} bool operator()(Edge_info e1, Edge_info e2) { bool e1_less = less_xy((*e1.endpoint()), *vertex_it); bool e2_less = less_xy((*e2.endpoint()), *vertex_it); bool e1_to_e2_left_turn = left_turn((*e1.endpoint()), *vertex_it, (*e2.endpoint())); // if both edges are on the same side of the vertical line through // _vertex then e1 comes before e2 (in CW order from the vertical line) // if one makes a left turn going from e1 to e2 if (e1_less == e2_less) return e1_to_e2_left_turn; else // e1 comes first if it is to the right of the vertical line return !e1_less; } private: Iterator vertex_it; Left_turn_2 left_turn; Less_xy_2 less_xy; }; template class Edge_info { public: Edge_info() {} Edge_info(Iterator e_ref, int p_num1, int p_num2) : _endpoint_ref(e_ref), _poly_num1(p_num1), _poly_num2(p_num2) { } Edge_info(Iterator e_ref, int p_num1) : _endpoint_ref(e_ref), _poly_num1(p_num1), _poly_num2(PARTITION_VMAP_UNSHARED_EDGE) { } void set_poly_num1(int p_num) { _poly_num1 = p_num; } void set_poly_num2(int p_num) { _poly_num2 = p_num; } void set_endpoint(Iterator e_ref) { _endpoint_ref = e_ref; } bool same_edge(Iterator e_ref) { return e_ref == endpoint(); } Iterator endpoint() const { return _endpoint_ref; } int poly_num1() const { return _poly_num1; } int poly_num2() const { return _poly_num2; } private: Iterator _endpoint_ref; int _poly_num1; int _poly_num2; }; template class Pvm_edge_list : public std::list< Edge_info > { public: typedef Traits_ Traits; typedef Pvm_edge_list Self; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Orientation_2 Orientation_pred; typedef typename Traits::Polygon_2::Vertex_iterator Vertex_iterator; typedef Edge_info Edge; typedef typename std::list::iterator Self_iterator; typedef typename std::list::const_iterator Self_const_iterator; typedef Circulator_from_iterator Self_const_circulator; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES static CW_indirect_edge_info_compare cw_indirect_edge_info_compare; static bool compare(const Edge& e1, const Edge& e2) { return cw_indirect_edge_info_compare(e1,e2); } #endif void insert_next(Vertex_iterator endpoint_ref, int num) { Self_iterator e_it; for (e_it = this->begin(); e_it != this->end() && (*e_it).endpoint() != endpoint_ref; e_it++) {} if (e_it != this->end()) (*e_it).set_poly_num2(num); else push_back(Edge(endpoint_ref, num)); } void insert_prev(Vertex_iterator endpoint_ref, int num) { Self_iterator e_it; for (e_it = this->begin(); e_it != this->end() && (*e_it).endpoint() != endpoint_ref; e_it++) {} if (e_it != this->end()) (*e_it).set_poly_num2(num); else push_front(Edge(endpoint_ref, num)); } // PRE: polygons must be simple bool edges_overlap(Vertex_iterator vertex_it) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "before sort: edges for " << *vertex_it << std::endl; std::cout << *this << std::endl; #endif int num_unshared = 0; // Don't want to sort the edges for vertices of degree 2 because they // are already in CCW order (since the partition polygons were in CCW // order), and this is what you need when you construct the union // polygon. if (this->size() > 2){ #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES cw_indirect_edge_info_compare = CW_indirect_edge_info_compare(vertex_it); sort(&Self::compare); #else sort(CW_indirect_edge_info_compare(vertex_it)); #endif } #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "after sort: edges for " << *vertex_it << std::endl; std::cout << *this << std::endl; #endif Self_const_iterator prev_e_it = this->begin(); Self_const_iterator e_it; for (e_it = this->begin(); e_it != this->end(); e_it++) { if ((*e_it).poly_num1() == PARTITION_VMAP_UNSHARED_EDGE) num_unshared++; if ((*e_it).poly_num2() == PARTITION_VMAP_UNSHARED_EDGE) num_unshared++; if ((*prev_e_it).poly_num1() != (*e_it).poly_num1() && (*prev_e_it).poly_num1() != (*e_it).poly_num2() && (*prev_e_it).poly_num2() != (*e_it).poly_num1() && (*prev_e_it).poly_num2() != (*e_it).poly_num2()) { return true; } prev_e_it = e_it; } if ((*prev_e_it).poly_num1() != (*this->begin()).poly_num1() && (*prev_e_it).poly_num1() != (*this->begin()).poly_num2() && (*prev_e_it).poly_num2() != (*this->begin()).poly_num1() && (*prev_e_it).poly_num2() != (*this->begin()).poly_num2()) { return true; } return (num_unshared > 2); } // NOTE: the edges here are sorted in CW order so the next CCW edge // comes BEFORE the edge with endpoint v_it in the sorted list Edge next_ccw_edge_info(Vertex_iterator v_it) const { Self_const_circulator first_e(this->begin(), this->end(), this->begin()); Self_const_circulator e_circ = first_e; do { if ((*e_circ).endpoint() == v_it) { e_circ--; // go to the previous endpoint return *e_circ; } } while (++e_circ != first_e); return *first_e; // shouldn't get here unless v_it is not in list } }; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES template CW_indirect_edge_info_compare Pvm_edge_list::cw_indirect_edge_info_compare; #endif template std::ostream& operator<<(std::ostream& os, const Pvm_edge_list& edges) { typename Pvm_edge_list::const_iterator e_it; for (e_it = edges.begin(); e_it != edges.end(); e_it++) { os << " " << (*(*e_it).endpoint()) << " from poly #" << (*e_it).poly_num1() << " and poly #" << (*e_it).poly_num2() << std::endl; } return os; } template class Partition_vertex_map : public std::map, Indirect_less_xy_2 > { public: typedef Partition_vertex_map Self; typedef typename std::map, Indirect_less_xy_2 >::iterator Self_iterator; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Polygon_2::Vertex_iterator Vertex_iterator; typedef Edge_info Edge; Partition_vertex_map() {} #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES static CW_indirect_edge_info_compare cw_indirect_edge_info_compare; static bool compare(const Edge & e1, const Edge& e2) { return cw_indirect_edge_info_compare(e1, e2); } #endif template Partition_vertex_map(InputIterator first_poly, InputIterator last_poly) { build(first_poly, last_poly); } template void build(InputIterator poly_first, InputIterator poly_last) { typedef std::pair Location_pair; typedef Pvm_edge_list Pvm_edge_list; typedef std::pair P_Vertex; Location_pair v_loc_pair; Location_pair begin_v_loc_pair; Location_pair prev_v_loc_pair; Vertex_iterator vtx_begin; Vertex_iterator vtx_end; Vertex_iterator v_it; int poly_num = 0; for (; poly_first != poly_last; poly_first++, poly_num++) { vtx_begin = (*poly_first).vertices_begin(); vtx_end = (*poly_first).vertices_end(); begin_v_loc_pair = insert(P_Vertex(vtx_begin, Pvm_edge_list())); prev_v_loc_pair = begin_v_loc_pair; v_it = vtx_begin; for (v_it++; v_it != vtx_end; v_it++) { v_loc_pair = insert(P_Vertex(v_it, Pvm_edge_list())); insert_next_edge(prev_v_loc_pair.first, v_loc_pair.first, poly_num); insert_prev_edge(v_loc_pair.first, prev_v_loc_pair.first, poly_num); prev_v_loc_pair = v_loc_pair; } insert_next_edge(prev_v_loc_pair.first, begin_v_loc_pair.first, poly_num); insert_prev_edge(begin_v_loc_pair.first, prev_v_loc_pair.first, poly_num); } } void insert_next_edge(Self_iterator& v1_ref, Self_iterator& v2_ref, int num) { (*v1_ref).second.insert_next((*v2_ref).first, num); } void insert_prev_edge(Self_iterator& v1_ref, Self_iterator& v2_ref, int num) { (*v1_ref).second.insert_prev((*v2_ref).first, num); } bool polygons_overlap() { Self_iterator v_it; for (v_it = this->begin(); v_it != this->end(); v_it++) { if ((*v_it).second.edges_overlap((*v_it).first)) return true; } return false; } template OutputIterator union_vertices(OutputIterator result) { if (this->empty()) return result; Self_iterator m_it = this->begin(); Vertex_iterator v_it; Vertex_iterator first_v_it; Vertex_iterator prev_v_it; Vertex_iterator next_v_it; // find a vertex with degree 2 (there must be at least one) while (m_it != this->end() && (*m_it).second.size() != 2) m_it++; CGAL_assertion (m_it != this->end()); // insert this vertex and the two around it first_v_it = prev_v_it = (*(*m_it).second.begin()).endpoint(); #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "union_vertices: inserting " << (*prev_v_it) << std::endl; #endif *result = *prev_v_it; result++; #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "union_vertices: inserting "<< *(*m_it).first << std::endl; #endif *result = *(*m_it).first; result++; next_v_it = (*m_it).second.back().endpoint(); #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "union_vertices: inserting " << *next_v_it << std::endl; #endif *result = *next_v_it; result++; // find the map iterator corresponding to the next vertex prev_v_it = (*m_it).first; v_it = next_v_it; m_it = find(v_it); while (v_it != first_v_it && m_it != this->end()) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "union_vertices: prev_v_it " << (*prev_v_it) << " v_it " << (*v_it) << " next_v_it " << (*next_v_it) << std::endl; #endif // Don't want to sort the edges for vertices of degree 2 because they // are already in CCW order (since the partition polygons were in CCW // order), and this is what you need to begin the construction // of the union polygon. if ((*m_it).second.size() > 2){ #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES cw_indirect_edge_info_compare = CW_indirect_edge_info_compare((*m_it).first); (*m_it).second.sort(&Self::compare); #else (*m_it).second.sort( CW_indirect_edge_info_compare((*m_it).first)); #endif } // find the previous vertex in this vertex's list next_v_it=(*m_it).second.next_ccw_edge_info(prev_v_it).endpoint(); if (next_v_it != first_v_it) { #ifdef CGAL_PARTITION_CHECK_DEBUG std::cout << "union_vertices: inserting " << *next_v_it << std::endl; #endif *result = *next_v_it; result++; } prev_v_it = v_it; v_it = next_v_it; m_it = find(v_it); CGAL_assertion (m_it == this->end() || (*m_it).first == v_it); } #ifdef CGAL_PARTITION_CHECK_DEBUG if (v_it == first_v_it) std::cout << "union_vertices: stopped because first was reached " << std::endl; else std::cout << "union_vertices: stopped because end was reached " << std::endl; #endif return result; } }; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES template CW_indirect_edge_info_compare Partition_vertex_map::cw_indirect_edge_info_compare; #endif } #endif // CGAL_PARTITION_VERTEX_MAP_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Orthogonal_k_neighbor_search.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Orthogonal_k_neighbor_0000644000175000017500000001515311344301500031412 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Orthogonal_k_neighbor_search.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef ORTHOGONAL_K_NEIGHBOR_SEARCH_H #define ORTHOGONAL_K_NEIGHBOR_SEARCH_H #include #include #include #include #include #include #include #include namespace CGAL { template , class Splitter_= Sliding_midpoint , class Tree_= Kd_tree > class Orthogonal_k_neighbor_search { public: typedef Splitter_ Splitter; typedef Tree_ Tree; typedef Distance_ Distance; typedef typename SearchTraits::Point_d Point_d; typedef typename Distance::Query_item Query_item; typedef typename SearchTraits::FT FT; typedef std::pair Point_with_transformed_distance; typedef typename Tree::Node_handle Node_handle; typedef typename Tree::Point_d_iterator Point_d_iterator; private: int number_of_internal_nodes_visited; int number_of_leaf_nodes_visited; int number_of_items_visited; bool search_nearest; FT multiplication_factor; Query_item query_object; int total_item_number; FT distance_to_root; typedef std::list NN_list; public: typedef typename NN_list::const_iterator iterator; private: NN_list l; int max_k; int actual_k; Distance distance_instance; bool branch(FT distance) { if (actual_ksecond); else return ( distance > l.begin()->second * multiplication_factor); } void insert(Point_d* I, FT dist) { bool insert; if (actual_ksecond ); else insert=(dist > l.rbegin()->second); if (insert) { actual_k++; typename NN_list::iterator it=l.begin(); if (search_nearest) for (; (it != l.end()); ++it) { if (dist < it->second) break;} else for (; (it != l.end()); ++it) { if (dist > it->second) break;} Point_with_transformed_distance NN_Candidate(*I,dist); l.insert(it,NN_Candidate); if (actual_k > max_k) { actual_k--; l.pop_back(); } } } public: iterator begin() const { return l.begin(); } iterator end() const { return l.end(); } // constructor Orthogonal_k_neighbor_search(Tree& tree, const Query_item& q, int k=1, FT Eps=FT(0.0), bool Search_nearest=true, const Distance& d=Distance()) : number_of_internal_nodes_visited(0), number_of_leaf_nodes_visited(0), number_of_items_visited(0), search_nearest(Search_nearest), multiplication_factor(d.transformed_distance(1.0+Eps)), query_object(q), total_item_number(tree.size()), max_k(k), actual_k(0), distance_instance(d) { if (search_nearest) distance_to_root = d.min_distance_to_rectangle(q, tree.bounding_box()); else distance_to_root = d.max_distance_to_rectangle(q, tree.bounding_box()); compute_neighbors_orthogonally(tree.root(), distance_to_root); } // Print statistics of the k_neighbor search process. std::ostream& statistics (std::ostream& s) { s << "K_Neighbor search statistics:" << std::endl; s << "Number of internal nodes visited:" << number_of_internal_nodes_visited << std::endl; s << "Number of leaf nodes visited:" << number_of_leaf_nodes_visited << std::endl; s << "Number of items visited:" << number_of_items_visited << std::endl; return s; } private: void compute_neighbors_orthogonally(Node_handle N, FT rd) { typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d query_object_it = construct_it(query_object); if (!(N->is_leaf())) { number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); FT old_off, new_rd; FT new_off = *(query_object_it + new_cut_dim) - N->cutting_value(); if ( ((new_off < FT(0.0)) && (search_nearest)) || (( new_off >= FT(0.0)) && (!search_nearest)) ) { compute_neighbors_orthogonally(N->lower(),rd); if (search_nearest) { old_off= *(query_object_it + new_cut_dim)- N->low_value(); if (old_off>FT(0.0)) old_off=FT(0.0); } else { old_off= *(query_object_it + new_cut_dim) - N->high_value(); if (old_offupper(), new_rd); } else { // compute new distance compute_neighbors_orthogonally(N->upper(),rd); if (search_nearest) { old_off= N->high_value() - *(query_object_it + new_cut_dim); if (old_off>FT(0.0)) old_off=FT(0.0); } else { old_off= N->low_value() - *(query_object_it + new_cut_dim); if (old_offlower(), new_rd); } } else { // n is a leaf number_of_leaf_nodes_visited++; if (N->size() > 0) for (Point_d_iterator it=N->begin(); it != N->end(); it++) { number_of_items_visited++; FT distance_to_query_object= distance_instance.transformed_distance(query_object,**it); insert(*it,distance_to_query_object); } } } }; // class } // namespace CGAL #endif // ORTHOGONAL_K_NEIGHBOR_SEARCH ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/nearest_neighbor_delaunay_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/nearest_neighbor_delau0000644000175000017500000001721011344301500031434 0ustar debiandebian// Copyright (c) 1999 Martin-Luther-University Halle-Wittenberg (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/nearest_neighbor_delaunay_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_NEAREST_NEIGHBOR_DELAUNAY_2_H #define CGAL_NEAREST_NEIGHBOR_DELAUNAY_2_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // compare function objects for the priority queues used in nearest neighbor search template class compare_vertices { public: //std::map > *pmap; MAP_TYPE* pmap; compare_vertices(MAP_TYPE *p){ pmap=p; } bool operator()(VP e1, VP e2) // get the priorities from the map and return result of comparison ... { NT& v1 = (*pmap)[e1]; NT& v2 = (*pmap)[e2]; return (v1 > v2); } }; template typename Dt::Vertex_handle nearest_neighbor(const Dt& delau, typename Dt::Vertex_handle v) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Point Point; typedef typename Dt::Vertex_circulator Vertex_circulator; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Gt::Compare_distance_2 Compare_dist_2; if (delau.number_of_vertices() <= 1) return NULL; Point p = v->point(); Vertex_circulator vc = delau.incident_vertices(v); Vertex_circulator start =vc; Vertex_handle min_v = vc; if (delau.is_infinite(min_v)){ vc++; min_v = vc; } Vertex_handle act; // go through the vertices ... do { act = vc; if (! delau.is_infinite(act)) { if ( Compare_dist_2()(p,act->point(), min_v->point()) == SMALLER ) min_v = act; } vc++; } while (vc != start); return min_v; } template typename Dt::Vertex_handle lookup(const Dt& delau, const typename Dt::Point& p) { typedef typename Dt::Face Face; typedef typename Dt::Locate_type Locate_type; typedef typename Dt::Face_handle Face_handle; if (delau.number_of_vertices() == 0) return NULL; // locate ... Locate_type lt; int li; Face_handle fh = delau.locate(p,lt,li); if (lt == Dt::VERTEX){ Face f = *fh; return f.vertex(li); } else return NULL; } template OutputIterator nearest_neighbors(Dt& delau, const typename Dt::Point& p, int k, OutputIterator res) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Vertex_iterator Vertex_iterator; int n = delau.number_of_vertices(); if ( k <= 0 ) return res; if ( n <= k ) { // return all finite vertices ... Vertex_iterator vit = delau.finite_vertices_begin(); for (; vit != delau.finite_vertices_end(); vit++) { *res= vit; res++; } return res; } // insert p, if necessary Vertex_handle vh = lookup(delau,p); bool old_node = true; // we have to add a new vertex ... if (vh == NULL){ vh = delau.insert(p); old_node = false; k++; } std::list res_list; nearest_neighbors_list(delau, vh, k, res_list); if ( !old_node ) { res_list.pop_front(); delau.remove(vh); } typename std::list::iterator it = res_list.begin(); for (; it != res_list.end(); it++) { *res= *it; res++; } return res; } template OutputIterator nearest_neighbors(const Dt& delau, typename Dt::Vertex_handle v, int k, OutputIterator res) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Vertex_iterator Vertex_iterator; int n = delau.number_of_vertices(); if ( k <= 0 ) return res; if ( n <= k ) { // return all (finite) vertices ... Vertex_iterator vit = delau.finite_vertices_begin(); for (; vit != delau.finite_vertices_end(); vit++) { *res= vit; res++; } return res; } std::list res_list; nearest_neighbors_list(delau, v, k, res_list); typename std::list::iterator it = res_list.begin(); for (; it != res_list.end(); it++) { *res= *it; res++; } return res; } template OutputIterator get_vertices(const Dt& delau, OutputIterator res) { typedef typename Dt::Vertex_iterator Vertex_iterator; Vertex_iterator vit = delau.finite_vertices_begin(); for (; vit != delau.finite_vertices_end(); vit++) { *res= vit; res++; } return res; } // second template argument for VC ... template void nearest_neighbors_list(const Dt& delau, typename Dt::Vertex_handle v, int k, std::list& res) { typedef typename Dt::Geom_traits Gt; typedef typename Dt::Vertex_handle Vertex_handle; typedef typename Dt::Vertex_iterator Vertex_iterator; typedef typename Dt::Vertex_circulator Vertex_circulator; typedef typename Dt::Vertex Vertex; typedef typename Dt::Point Point; typedef typename Gt::FT Numb_type; // field number type ... typedef typename Gt::Compute_squared_distance_2 Compute_squared_distance_2; typedef Unique_hash_map MAP_TYPE; int n = delau.number_of_vertices(); if ( k <= 0 ) return; if ( n <= k ) { get_vertices(delau, std::back_inserter(res)); return; } Point p = v->point(); Unique_hash_map mark; int cur_mark = 1; MAP_TYPE priority_number; // here we save the priorities ... compare_vertices comp(& priority_number); // comparison object ... std::priority_queue, CGAL::compare_vertices > PQ(comp); priority_number[v] = 0; PQ.push(v); // mark vertex v mark[v] = cur_mark; while ( k > 0 ) { // find minimum from PQ ... Vertex_handle w = PQ.top(); PQ.pop(); res.push_back(w); k--; // get the incident vertices of w ... Vertex_circulator vc = delau.incident_vertices(w); Vertex_circulator start =vc; Vertex_handle act; do { act = vc; // test, if act is marked ... bool is_marked = mark.is_defined(act); if ( (! is_marked) && (! delau.is_infinite(act)) ) { priority_number[act] = Compute_squared_distance_2()(p,act->point()); PQ.push(act); mark[act] = cur_mark; } vc++; } while (vc != start); } } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_3.h0000644000175000017500000000431311344301500027016 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_SEGMENT_3_H #define CGAL_SEGMENT_3_H CGAL_BEGIN_NAMESPACE template class Segment_3 : public R_::Kernel_base::Segment_3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Kernel_base::Segment_3 RSegment_3; public: typedef R_ R; Segment_3() {} Segment_3(const Point_3& sp, const Point_3& ep) : RSegment_3(sp,ep) {} Segment_3(const RSegment_3& s) : RSegment_3(s) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_SEGMENT_3 template < class R> std::ostream& operator<<(std::ostream& os, const Segment_3& s) { typedef typename R::Kernel_base::Segment_3 RSegment_3; return os << static_cast(s); } #endif // CGAL_NO_OSTREAM_INSERT_SEGMENT_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_SEGMENT_3 template < class R> std::istream& operator>>(std::istream& is, Segment_3& s) { typedef typename R::Kernel_base::Segment_3 RSegment_3; return is >> static_cast(s); } #endif // CGAL_NO_ISTREAM_EXTRACT_SEGMENT_3 CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/circulator_bases.h0000644000175000017500000001300711344301500030516 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/circulator_bases.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_CIRCULATOR_BASES_H #define CGAL_CIRCULATOR_BASES_H 1 #ifndef CGAL_PROTECT_CSTDDEF #include #define CGAL_PROTECT_CSTDDEF #endif #ifndef CGAL_PROTECT_ITERATOR #include #define CGAL_PROTECT_ITERATOR #endif CGAL_BEGIN_NAMESPACE struct Circulator_tag {}; // any circulator. struct Iterator_tag {}; // any iterator. struct Forward_circulator_tag : public CGAL_STD::forward_iterator_tag {}; struct Bidirectional_circulator_tag : public CGAL_STD::bidirectional_iterator_tag {}; struct Random_access_circulator_tag : public CGAL_STD::random_access_iterator_tag {}; template struct Forward_circulator_base { typedef T value_type; typedef Dist difference_type; typedef Size size_type; typedef T* pointer; typedef T& reference; typedef Forward_circulator_tag iterator_category; }; template struct Bidirectional_circulator_base { typedef T value_type; typedef Dist difference_type; typedef Size size_type; typedef T* pointer; typedef T& reference; typedef Bidirectional_circulator_tag iterator_category; }; template struct Random_access_circulator_base { typedef T value_type; typedef Dist difference_type; typedef Size size_type; typedef T* pointer; typedef T& reference; typedef Random_access_circulator_tag iterator_category; }; template < class Category, class T, class Distance = std::ptrdiff_t, class Size = std::size_t, class Pointer = T*, class Reference = T&> struct Circulator_base { typedef Category iterator_category; typedef T value_type; typedef Distance difference_type; typedef Size size_type; typedef Pointer pointer; typedef Reference reference; }; // variant base classes // --------------------- template class Forward_circulator_ptrbase // forward circulator. { protected: void* _ptr; public: typedef Forward_circulator_tag iterator_category; typedef T value_type; typedef Dist difference_type; typedef Size size_type; typedef T* pointer; typedef T& reference; Forward_circulator_ptrbase() : _ptr(NULL) {} Forward_circulator_ptrbase(void* p) : _ptr(p) {} }; template class Bidirectional_circulator_ptrbase // bidirectional circulator. { protected: void* _ptr; public: typedef Bidirectional_circulator_tag iterator_category; typedef T value_type; typedef Dist difference_type; typedef Size size_type; typedef T* pointer; typedef T& reference; Bidirectional_circulator_ptrbase() : _ptr(NULL) {} Bidirectional_circulator_ptrbase(void* p) : _ptr(p) {} }; template class Random_access_circulator_ptrbase // random access circulator. { protected: void* _ptr; public: typedef Random_access_circulator_tag iterator_category; typedef T value_type; typedef Dist difference_type; typedef Size size_type; typedef T* pointer; typedef T& reference; Random_access_circulator_ptrbase() : _ptr(NULL) {} Random_access_circulator_ptrbase(void* p) : _ptr(p) {} }; CGAL_END_NAMESPACE #endif // CGAL_CIRCULATOR_BASES_H // // EOF // ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Point_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Point_2_inters0000644000175000017500000000406611344301500031241 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_2_Point_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_POINT_2_POINT_2_INTERSECTION_H #define CGAL_POINT_2_POINT_2_INTERSECTION_H #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template inline bool do_intersect(const typename CGAL_WRAP(K)::Point_2 &pt1, const typename CGAL_WRAP(K)::Point_2 &pt2) { return pt1 == pt2; } template Object intersection(const typename CGAL_WRAP(K)::Point_2 &pt1, const typename CGAL_WRAP(K)::Point_2 &pt2) { if (pt1 == pt2) { return make_object(pt1); } return Object(); } }// namespace CGALi template inline bool do_intersect(const Point_2 &pt1, const Point_2 &pt2) { typedef typename K::Do_intersect_2 Do_intersect; return o_intersect(pt1, pt2); } template inline Object intersection(const Point_2 &pt1, const Point_2 &pt2) { typedef typename K::Intersect_2 Intersect; return Intersect()(pt1, pt2); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/min_quadrilateral_2.h0000644000175000017500000005760211344301500031121 0ustar debiandebian// Copyright (c) 1999-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/min_quadrilateral_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann and // Emo Welzl #if ! (CGAL_MIN_QUADRILATERAL_2_H) #define CGAL_MIN_QUADRILATERAL_2_H 1 #include #include #include #include #include #ifdef CGAL_OPTIMISATION_EXPENSIVE_PRECONDITION_TAG #include #endif CGAL_BEGIN_NAMESPACE template < class ForwardIterator, class OutputIterator, class Traits > OutputIterator convex_bounding_box_2( ForwardIterator f, ForwardIterator l, OutputIterator o, Traits& t) // PRE: // * f != l // * value type of ForwardIterator is Traits::Point_2 // * [f,l) form a the vertices of a convex polygon // oriented counterclockwise // * OutputIterator accepts ForwardIterator as value type // POST: // writes to o iterators from [f,l) referring to the last points with // - smallest y coordinate // - largest x coordinate // - largest y coordinate // - smallest x coordinate // in that order. { CGAL_precondition(f != l); // make sure that we have two distinct points, such that it // can be determined in which quadrant of the polygon we are ForwardIterator first; do { first = f; // catch the one-element case: if (++f == l) { f = first; break; } } while (t.equal_2_object()(*first, *f)); // Four extremes ForwardIterator minx = first; ForwardIterator maxx; ForwardIterator miny; ForwardIterator maxy; typedef typename Traits::Less_xy_2 Less_xy_2; typedef typename Traits::Less_yx_2 Less_yx_2; typedef typename Swap::Type Greater_xy_2; typedef typename Swap::Type Greater_yx_2; Less_xy_2 less_xy_2 = t.less_xy_2_object(); Less_yx_2 less_yx_2 = t.less_yx_2_object(); Greater_xy_2 greater_xy_2 = swap_1(less_xy_2); Greater_yx_2 greater_yx_2 = swap_1(less_yx_2); if (less_xy_2(*minx, *f) || less_yx_2(*minx, *f) && !less_xy_2(*f, *minx)) if (less_yx_2(*minx, *f)) // first quadrant for (;;) { maxx = f; if (++f == l) { maxy = minx = miny = maxx; break; } if (less_xy_2(*f, *maxx)) { f = maxx; for (;;) { maxy = f; if (++f == l) { minx = miny = maxy; break; } if (less_yx_2(*f, *maxy)) { f = maxy; for (;;) { minx = f; if (++f == l) { miny = minx; break; } if (greater_xy_2(*f, *minx)) { f = minx; do miny = f; while (++f != l && !greater_yx_2(*f, *miny)); break; } } // for (;;) break; } // if (less_yx_2(*f, *maxy)) } // for (;;) break; } // if (less_xy_2(*f, *maxx)) } // for (;;) else // fourth quadrant for (;;) { miny = f; if (++f == l) { maxx = maxy = minx = miny; break; } if (greater_yx_2(*f, *miny)) { f = miny; for (;;) { maxx = f; if (++f == l) { maxy = minx = maxx; break; } if (less_xy_2(*f, *maxx)) { f = maxx; for (;;) { maxy = f; if (++f == l) { minx = maxy; break; } if (less_yx_2(*f, *maxy)) { f = maxy; do minx = f; while (++f != l && !greater_xy_2(*f, *minx)); break; } } // for (;;) break; } // if (less_xy_2(*f, *maxx)) } // for (;;) break; } // if (greater_yx_2(*f, *miny)) } // for (;;) else if (less_yx_2(*f, *minx)) // third quadrant for (;;) { minx = f; if (++f == l) { miny = maxx = maxy = minx; break; } if (greater_xy_2(*f, *minx)) { f = minx; for (;;) { miny = f; if (++f == l) { maxx = maxy = miny; break; } if (greater_yx_2(*f, *miny)) { f = miny; for (;;) { maxx = f; if (++f == l) { maxy = maxx; break; } if (less_xy_2(*f, *maxx)) { f = maxx; do maxy = f; while (++f != l && !less_yx_2(*f, *maxy)); break; } } // for (;;) break; } // if (greater_yx_2(*f, *miny)) } // for (;;) break; } // if (greater_xy_2(*f, *minx)) } // for (;;) else // second quadrant for (;;) { maxy = f; if (++f == l) { minx = miny = maxx = maxy; break; } if (less_yx_2(*f, *maxy)) { f = maxy; for (;;) { minx = f; if (++f == l) { miny = maxx = minx; break; } if (greater_xy_2(*f, *minx)) { f = minx; for (;;) { miny = f; if (++f == l) { maxx = miny; break; } if (greater_yx_2(*f, *miny)) { f = miny; do maxx = f; while (++f != l && !less_xy_2(*f, *maxx)); break; } } // for (;;) break; } // if (greater_xy_2(*f, *minx)) } // for (;;) break; } // if (less_yx_2(*f, *maxy)) } // for (;;) // Output *o++ = less_yx_2(*first, *miny) ? first : miny; *o++ = less_xy_2(*maxx, *first) ? first : maxx; *o++ = less_yx_2(*maxy, *first) ? first : maxy; *o++ = less_xy_2(*first, *minx) ? first : minx; return o; } // convex_bounding_box_2(f, l, o, t) namespace Optimisation { // Adds certain redundant functionality for convenience template < typename Traits > struct Min_quadrilateral_traits_wrapper : public Traits { typedef Traits Base; // types inherited from Traits typedef typename Base::Point_2 Point_2; typedef typename Base::Direction_2 Direction_2; // predicates and constructions inherited from Traits typedef typename Base::Has_on_negative_side_2 HONS; typedef typename Base::Construct_vector_2 CV2; typedef typename Base::Construct_direction_2 CD2; typedef typename Base::Construct_line_2 Construct_line_2; typedef typename Base::Compare_angle_with_x_axis_2 CAWXA; using Traits::has_on_negative_side_2_object; using Traits::construct_line_2_object; using Traits::construct_vector_2_object; using Traits::compare_angle_with_x_axis_2_object; Min_quadrilateral_traits_wrapper(const Traits& bt) : Base(bt) {} // --------------------------------------------------------------- // Right_of_implicit_line_2 // --------------------------------------------------------------- typedef typename Swap::Type SWHONS; typedef Identity IDP; typedef typename Compose::Type Right_of_implicit_line_2; Right_of_implicit_line_2 right_of_implicit_line_2_object() const { return compose(swap_1(has_on_negative_side_2_object()), IDP(), construct_line_2_object()); } typedef typename Compose::Type Construct_direction_2; Construct_direction_2 construct_direction_2_object() const { return compose(Base::construct_direction_2_object(), construct_vector_2_object()); } template < class Kernel > class Rdbmop : public CGAL_STD::binary_function< Direction_2, int, Direction_2 > { typename Kernel::Construct_perpendicular_vector_2 cperpvec; typename Kernel::Construct_vector_from_direction_2 cvec; typename Kernel::Construct_direction_2 dir; typename Kernel::Construct_opposite_direction_2 oppdir; public: Rdbmop() {} Rdbmop(const Kernel& k) : cperpvec(k.construct_perpendicular_vector_2_object()), cvec(k.construct_vector_from_direction_2_object()), dir(k.construct_direction_2_object()), oppdir(k.construct_opposite_direction_2_object()) {} Direction_2 operator()(const Direction_2& d, int i) const { // FIXME: here I would like to construct a vector from a // direction, but this is not in the kernel concept // maybe, we can get rid of directions soon... CGAL_precondition(i >= 0 && i < 4); if (i == 0) return d; if (i == 1) return dir(cperpvec(cvec(d), CLOCKWISE)); if (i == 2) return oppdir(d); return dir(cperpvec(cvec(d), COUNTERCLOCKWISE)); } }; typedef Rdbmop Rotate_direction_by_multiple_of_pi_2; Rotate_direction_by_multiple_of_pi_2 rotate_direction_by_multiple_of_pi_2_object() const { return Rotate_direction_by_multiple_of_pi_2(*this); } typedef std::equal_to EQCR; typedef Bind::Type BEQCR; typedef typename Compose::Type Less_angle_with_x_axis_2; Less_angle_with_x_axis_2 less_angle_with_x_axis_2_object() const { return compose(bind_2(EQCR(), SMALLER), compare_angle_with_x_axis_2_object()); } }; } // namespace Optimisation template < class ForwardIterator, class OutputIterator, class BTraits > OutputIterator min_rectangle_2( ForwardIterator f, ForwardIterator l, OutputIterator o, BTraits& bt) { typedef Optimisation::Min_quadrilateral_traits_wrapper Traits; Traits t(bt); CGAL_optimisation_expensive_precondition(is_convex_2(f, l, t)); CGAL_optimisation_expensive_precondition( orientation_2(f, l, t) == COUNTERCLOCKWISE); // check for trivial cases if (f == l) return o; ForwardIterator tst = f; if (++tst == l) { // all points are equal for (int i = 0; i < 4; ++i) *o++ = *f; return o; } // types from the traits class typedef typename Traits::Rectangle_2 Rectangle_2; typedef typename Traits::Direction_2 Direction_2; typedef typename Traits::Construct_direction_2 Construct_direction_2; typedef typename Traits::Construct_rectangle_2 Construct_rectangle_2; Construct_direction_2 direction = t.construct_direction_2_object(); Construct_rectangle_2 rectangle = t.construct_rectangle_2_object(); typename Traits::Rotate_direction_by_multiple_of_pi_2 rotate = t.rotate_direction_by_multiple_of_pi_2_object(); typename Traits::Less_angle_with_x_axis_2 less_angle = t.less_angle_with_x_axis_2_object(); typename Traits::Area_less_rectangle_2 area_less = t.area_less_rectangle_2_object(); // quadruple of points defining the current rectangle ForwardIterator curr[4]; // initialised to the points defining the bounding box convex_bounding_box_2(f, l, curr, t); // curr[i] can be advanced (cyclically) until it reaches limit[i] ForwardIterator limit[4]; limit[0] = curr[1], limit[1] = curr[2], limit[2] = curr[3], limit[3] = curr[0]; // quadruple of direction candidates defining the current rectangle Direction_2 dir[4]; for (int i = 0; i < 4; i++) { ForwardIterator cp = curr[i]; if (++cp == l) cp = f; dir[i] = rotate(direction(*(curr[i]), *cp), i); } int yet_to_finish = 0; for (int i1 = 0; i1 < 4; ++i1) { CGAL_optimisation_assertion(limit[i1] != l); if (curr[i1] != limit[i1]) ++yet_to_finish; } int low = less_angle(dir[0], dir[1]) ? 0 : 1; int upp = less_angle(dir[2], dir[3]) ? 2 : 3; int event = less_angle(dir[low], dir[upp]) ? low : upp; Rectangle_2 rect_so_far = rectangle(*(curr[0]), dir[event], *(curr[1]), *(curr[2]), *(curr[3])); for (;;) { if (++curr[event] == l) curr[event] = f; ForwardIterator cp = curr[event]; if (++cp == l) cp = f; dir[event] = rotate(direction(*(curr[event]), *cp), event); if (curr[event] == limit[event]) if (--yet_to_finish <= 0) break; if (event < 2) low = less_angle(dir[0], dir[1]) ? 0 : 1; else upp = less_angle(dir[2], dir[3]) ? 2 : 3; event = less_angle(dir[low], dir[upp]) ? low : upp; Rectangle_2 test_rect = rectangle(*(curr[0]), dir[event], *(curr[1]), *(curr[2]), *(curr[3])); if (t.area_less_rectangle_2_object()(test_rect, rect_so_far)) rect_so_far = test_rect; } // for (;;) return t.copy_rectangle_vertices_2(rect_so_far, o); } // min_rectangle_2( f, l, o , t) template < class ForwardIterator, class OutputIterator, class BTraits > OutputIterator min_parallelogram_2(ForwardIterator f, ForwardIterator l, OutputIterator o, BTraits& bt) { typedef Optimisation::Min_quadrilateral_traits_wrapper Traits; Traits t(bt); CGAL_optimisation_expensive_precondition(is_convex_2(f, l, t)); // types from the traits class typedef typename Traits::Direction_2 Direction_2; typedef typename Traits::Parallelogram_2 Parallelogram_2; typedef typename Traits::Construct_direction_2 Construct_direction_2; typedef typename Traits::Equal_2 Equal_2; Equal_2 equal = t.equal_2_object(); Construct_direction_2 direction = t.construct_direction_2_object(); typename Traits::Construct_parallelogram_2 parallelogram = t.construct_parallelogram_2_object(); typename Traits::Less_angle_with_x_axis_2 less_angle = t.less_angle_with_x_axis_2_object(); typename Traits::Area_less_parallelogram_2 area_less = t.area_less_parallelogram_2_object(); typename Traits::Right_of_implicit_line_2 right_of_line = t.right_of_implicit_line_2_object(); // check for trivial cases if (f == l) return o; ForwardIterator first; do { first = f; if (++f == l) { // all points are equal for (int i = 0; i < 4; ++i) *o++ = *first; return o; } } while (equal(*first, *f)); // quadruple of points defining the bounding box ForwardIterator curr[4]; // initialised to the points defining the bounding box convex_bounding_box_2(first, l, curr, t); ForwardIterator low = curr[0]; ForwardIterator upp = curr[2]; ForwardIterator right = low; ForwardIterator left = upp; int yet_to_finish = 2; // initialize parallelogram ForwardIterator ln = low; do if (++ln == l) ln = first; while (equal(*ln, *low)); Direction_2 d_low = direction(*low, *ln); ForwardIterator un = upp; do if (++un == l) un = first; while (equal(*un, *upp)); Direction_2 d_upp = direction(*un, *upp); bool low_goes_next = less_angle(d_low, d_upp); Direction_2 next_dir = low_goes_next ? d_low : d_upp; Direction_2 d_leftright = next_dir; for (;;) { // compute the next left/right candidate and store it to d_leftright ForwardIterator rig = right; do if (++rig == l) rig = first; while (equal(*rig, *right)); Direction_2 d_right = direction(*right, *rig); ForwardIterator len = left; do if (++len == l) len = first; while (equal(*len, *left)); Direction_2 d_left = direction(*len, *left); if (less_angle(d_right, d_left)) if (right_of_line(*rig, *left, next_dir)) right = rig; else { d_leftright = d_right; break; } else if (right_of_line(*right, *len, next_dir)) left = len; else { d_leftright = d_left; break; } } // for (;;) Parallelogram_2 para_so_far = parallelogram(*low, next_dir, *right, d_leftright, *upp, *left); for (;;) { if (low_goes_next) { low = ln; if (low == curr[2]) if (--yet_to_finish <= 0) break; } else { upp = un; if (upp == curr[0]) if (--yet_to_finish <= 0) break; } // compute the next lower/upper candidate ln = low; do if (++ln == l) ln = first; while (equal(*ln, *low)); d_low = direction(*low, *ln); un = upp; do if (++un == l) un = first; while (equal(*un, *upp)); d_upp = direction(*un, *upp); low_goes_next = less_angle(d_low, d_upp); next_dir = low_goes_next ? d_low : d_upp; for (;;) { // compute the next left/right candidate and store it to d_leftright ForwardIterator rig = right; do if (++rig == l) rig = first; while (equal(*rig, *right)); Direction_2 d_right = direction(*right, *rig); ForwardIterator len = left; do if (++len == l) len = first; while (equal(*len, *left)); Direction_2 d_left = direction(*len, *left); if (less_angle(d_right, d_left)) if (right_of_line(*rig, *left, next_dir)) right = rig; else { d_leftright = d_right; break; } else if (right_of_line(*right, *len, next_dir)) left = len; else { d_leftright = d_left; break; } } // for (;;) // check whether we found a smaller parallelogram Parallelogram_2 test_para = parallelogram(*low, next_dir, *right, d_leftright, *upp, *left); if (area_less(test_para, para_so_far)) para_so_far = test_para; } // for (;;) return t.copy_parallelogram_vertices_2(para_so_far, o); } // min_parallelogram_2(f, l, o , t) template < class ForwardIterator, class OutputIterator, class BTraits > OutputIterator min_strip_2(ForwardIterator f, ForwardIterator l, OutputIterator o, BTraits& bt) { typedef Optimisation::Min_quadrilateral_traits_wrapper Traits; Traits t(bt); CGAL_optimisation_expensive_precondition(is_convex_2(f, l, t)); // types from the traits class typedef typename Traits::Direction_2 Direction_2; typedef typename Traits::Strip_2 Strip_2; typedef typename Traits::Equal_2 Equal_2; typedef typename Traits::Construct_direction_2 Construct_direction_2; typedef typename Traits::Construct_strip_2 Construct_strip_2; typedef typename Traits::Width_less_strip_2 Width_less_strip_2; Equal_2 equal = t.equal_2_object(); Construct_direction_2 direction = t.construct_direction_2_object(); Construct_strip_2 strip = t.construct_strip_2_object(); Width_less_strip_2 width_less = t.width_less_strip_2_object(); typename Traits::Less_angle_with_x_axis_2 less_angle = t.less_angle_with_x_axis_2_object(); // check for trivial cases if (f == l) return o; ForwardIterator first; do { first = f; if (++f == l) // strip undefined, if no two distinct points exist return o; } while (equal(*first, *f)); // quadruple of points defining the bounding box ForwardIterator curr[4]; // initialised to the points defining the bounding box convex_bounding_box_2(first, l, curr, t); ForwardIterator low = curr[0]; ForwardIterator upp = curr[2]; int yet_to_finish = 2; ForwardIterator nlow = low; if (++nlow == l) nlow = first; Direction_2 low_dir = direction(*low, *nlow); ForwardIterator nupp = upp; if (++nupp == l) nupp = first; Direction_2 upp_dir = direction(*nupp, *upp); bool low_goes_next = less_angle(low_dir, upp_dir); Strip_2 strip_so_far = low_goes_next ? strip(*low, low_dir, *upp) : strip(*low, upp_dir, *upp); for (;;) { // compute next direction if (low_goes_next) { low = nlow; if (low == curr[2]) if (--yet_to_finish <= 0) break; if (++nlow == l) nlow = first; low_dir = direction(*low, *nlow); } else { upp = nupp; if (upp == curr[0]) if (--yet_to_finish <= 0) break; if (++nupp == l) nupp = first; upp_dir = direction(*nupp, *upp); } low_goes_next = less_angle(low_dir, upp_dir); Strip_2 test_strip = low_goes_next ? strip(*low, low_dir, *upp) : strip(*low, upp_dir, *upp); if (width_less(test_strip, strip_so_far)) strip_so_far = test_strip; } // for (;;) // return the result return t.copy_strip_lines_2(strip_so_far, o); } // min_strip_2(f, l, o, t) #ifdef CGAL_REP_CLASS_DEFINED CGAL_END_NAMESPACE #include CGAL_BEGIN_NAMESPACE template < class ForwardIterator, class OutputIterator > inline OutputIterator min_rectangle_2(ForwardIterator f, ForwardIterator l, OutputIterator o) { typedef typename std::iterator_traits< ForwardIterator >::value_type VT; typedef typename Kernel_traits::Kernel Kernel; Min_quadrilateral_default_traits_2 t; return min_rectangle_2(f, l, o, t); } // min_rectangle_2(f, l, o) #ifndef CGAL_NO_DEPRECATED_CODE // backwards compatibility template < class ForwardIterator, class OutputIterator > inline OutputIterator minimum_enclosing_rectangle_2(ForwardIterator f, ForwardIterator l, OutputIterator o) { return min_rectangle_2(f, l, o); } #endif // CGAL_NO_DEPRECATED_CODE template < class ForwardIterator, class OutputIterator > inline OutputIterator min_parallelogram_2(ForwardIterator f, ForwardIterator l, OutputIterator o) { typedef typename std::iterator_traits< ForwardIterator >::value_type VT; typedef typename Kernel_traits::Kernel Kernel; Min_quadrilateral_default_traits_2 t; return min_parallelogram_2(f, l, o, t); } // min_parallelogram_2(f, l, o) #ifndef CGAL_NO_DEPRECATED_CODE // backwards compatibility template < class ForwardIterator, class OutputIterator > inline OutputIterator minimum_enclosing_parallelogram_2(ForwardIterator f, ForwardIterator l, OutputIterator o) { return min_parallelogram_2(f, l, o); } #endif // CGAL_NO_DEPRECATED_CODE template < class ForwardIterator, class OutputIterator > inline OutputIterator min_strip_2(ForwardIterator f, ForwardIterator l, OutputIterator o) { typedef typename std::iterator_traits< ForwardIterator >::value_type VT; typedef typename Kernel_traits::Kernel Kernel; Min_quadrilateral_default_traits_2 t; return min_strip_2(f, l, o, t); } // min_strip_2(f, l, o) #ifndef CGAL_NO_DEPRECATED_CODE // backwards compatibility template < class ForwardIterator, class OutputIterator > inline OutputIterator minimum_enclosing_strip_2(ForwardIterator f, ForwardIterator l, OutputIterator o) { return min_strip_2(f, l, o); } #endif // CGAL_NO_DEPRECATED_CODE #endif // CGAL_REP_CLASS_DEFINED CGAL_END_NAMESPACE #endif // ! (CGAL_MIN_QUADRILATERAL_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_Ray_2_intersect0000644000175000017500000000222611344301500031174 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Bbox_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_face_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_face_0000644000175000017500000001752611344301501031402 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_face_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DS_FACE_BASE_2_H #define CGAL_TRIANGULATION_DS_FACE_BASE_2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename TDS = void> class Triangulation_ds_face_base_2 { public: typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Face_handle Face_handle; // Borland requires this. template struct Rebind_TDS { typedef Triangulation_ds_face_base_2 Other; }; private: Vertex_handle V[3]; Face_handle N[3]; public: Triangulation_ds_face_base_2(); Triangulation_ds_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2); Triangulation_ds_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2); Vertex_handle vertex(int i) const; bool has_vertex(Vertex_handle v) const; bool has_vertex(Vertex_handle v, int& i) const ; int index(Vertex_handle v) const ; Face_handle neighbor(int i) const ; bool has_neighbor(Face_handle n) const; bool has_neighbor(Face_handle n, int& i) const; int index(Face_handle n) const; void set_vertex(int i, Vertex_handle v); void set_vertices(); void set_vertices(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2); void set_neighbor(int i, Face_handle n) ; void set_neighbors(); void set_neighbors(Face_handle n0, Face_handle n1, Face_handle n2); void reorient(); void ccw_permute(); void cw_permute(); int dimension() const; //the following trivial is_valid to allow // the user of derived face base classes // to add their own purpose checking bool is_valid(bool /* verbose */ = false, int /* level */ = 0) const {return true;} // For use by Compact_container. void * for_compact_container() const {return N[0].for_compact_container(); } void * & for_compact_container() { return N[0].for_compact_container();} }; template Triangulation_ds_face_base_2 :: Triangulation_ds_face_base_2() { set_vertices(); set_neighbors(); } template Triangulation_ds_face_base_2 :: Triangulation_ds_face_base_2( Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) { set_vertices(v0, v1, v2); set_neighbors(); } template Triangulation_ds_face_base_2 :: Triangulation_ds_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) { set_vertices(v0, v1, v2); set_neighbors(n0, n1, n2); } template inline typename Triangulation_ds_face_base_2::Vertex_handle Triangulation_ds_face_base_2:: vertex(int i) const { CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2); return V[i]; } template inline bool Triangulation_ds_face_base_2 :: has_vertex(Vertex_handle v) const { return (V[0] == v) || (V[1] == v) || (V[2]== v); } template inline bool Triangulation_ds_face_base_2 :: has_vertex(Vertex_handle v, int& i) const { if (v == V[0]) { i = 0; return true; } if (v == V[1]) { i = 1; return true; } if (v == V[2]) { i = 2; return true; } return false; } template inline int Triangulation_ds_face_base_2 :: index(Vertex_handle v) const { if (v == V[0]) return 0; if (v == V[1]) return 1; CGAL_triangulation_assertion( v == V[2] ); return 2; } template inline typename Triangulation_ds_face_base_2::Face_handle Triangulation_ds_face_base_2:: neighbor(int i) const { CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2); return N[i]; } template inline bool Triangulation_ds_face_base_2 :: has_neighbor(Face_handle n) const { return (N[0] == n) || (N[1] == n) || (N[2] == n); } template inline bool Triangulation_ds_face_base_2 :: has_neighbor(Face_handle n, int& i) const { if(n == N[0]){ i = 0; return true; } if(n == N[1]){ i = 1; return true; } if(n == N[2]){ i = 2; return true; } return false; } template inline int Triangulation_ds_face_base_2 :: index(Face_handle n) const { if (n == N[0]) return 0; if (n == N[1]) return 1; CGAL_triangulation_assertion( n == N[2] ); return 2; } template inline void Triangulation_ds_face_base_2 :: set_vertex(int i, Vertex_handle v) { CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2); V[i] = v; } template inline void Triangulation_ds_face_base_2 :: set_neighbor(int i, Face_handle n) { CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2); N[i] = n; } template inline void Triangulation_ds_face_base_2 :: set_vertices() { V[0] = V[1] = V[2] = Vertex_handle(); } template inline void Triangulation_ds_face_base_2 :: set_vertices(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) { V[0] = v0; V[1] = v1; V[2] = v2; } template inline void Triangulation_ds_face_base_2 :: set_neighbors() { N[0] = N[1] = N[2] = Face_handle(); } template inline void Triangulation_ds_face_base_2 :: set_neighbors(Face_handle n0,Face_handle n1, Face_handle n2) { N[0] = n0; N[1] = n1; N[2] = n2; } template void Triangulation_ds_face_base_2 :: reorient() { //exchange the vertices 0 and 1 set_vertices (V[1],V[0],V[2]); set_neighbors(N[1],N[0],N[2]); } template inline void Triangulation_ds_face_base_2 :: ccw_permute() { set_vertices (V[2],V[0],V[1]); set_neighbors(N[2],N[0],N[1]); } template inline void Triangulation_ds_face_base_2 :: cw_permute() { set_vertices (V[1],V[2],V[0]); set_neighbors(N[1],N[2],N[0]); } template < class TDS> inline int Triangulation_ds_face_base_2 :: dimension() const { if (V[2] != Vertex_handle()) {return 2;} else return( V[1] != Vertex_handle() ? 1 : 0); } template < class TDS > inline std::istream& operator>>(std::istream &is, Triangulation_ds_face_base_2 &) // non combinatorial information. Default = nothing { return is; } template < class TDS > inline std::ostream& operator<<(std::ostream &os, const Triangulation_ds_face_base_2 &) // non combinatorial information. Default = nothing { return os; } // Specialisation for void. template <> class Triangulation_ds_face_base_2 { public: typedef Dummy_tds_2 Triangulation_data_structure; typedef Triangulation_data_structure::Vertex_handle Vertex_handle; typedef Triangulation_data_structure::Face_handle Face_handle; template struct Rebind_TDS { typedef Triangulation_ds_face_base_2 Other; }; }; CGAL_END_NAMESPACE #endif //CGAL_DS_TRIANGULATION_FACE_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_traits_checker.h0000644000175000017500000001140211344301500030615 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_traits_checker.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan /* Edited by Iddo Hanniel Oren Nechushtan */ #ifndef CGAL_PM_TRAITS_CHECKER_H #define CGAL_PM_TRAITS_CHECKER_H /* Pm_traits_checker is a traits template that recieves two template parameters, which are traits themselves. The predicates will work well iff all of the parameter traits predicates did, giving the same answer. It is assumed through out this traits that the parameter traits do not require any storage. */ CGAL_BEGIN_NAMESPACE // Tr1 and Tr2 are traits with the same predicate names // C is a convertion between the geometric objects of Tr1 to those of Tr2 template class Pm_traits_checker_default_adaptor; template > class Pm_traits_checker : public Tr1 /* The inheritance here is to ensure that constants, enumerations, public classes, etc are inherited to the checker whenever this is required */ { Tr1 t; Tr2 b; C P; //P converts Tr1 objects to Tr2 objects (to enable comparison) public: typedef typename Tr1::X_curve X_curve; typedef typename Tr1::Point_2 Point; typedef typename Tr1::Point_2 Point_2; Pm_traits_checker() : Tr1(),t(),b(),P() {}; ~Pm_traits_checker() {} Point curve_source(const X_curve & cv) const { CGAL_assertion(P(t.curve_source(cv))==b.curve_source(P(cv))); return t.curve_source(cv); } Point curve_target(const X_curve & cv) const { CGAL_assertion(P(t.curve_target(cv))==b.curve_target(P(cv))); return t.curve_target(cv); } bool curve_is_vertical(const X_curve & cv) const { CGAL_assertion(t.curve_is_vertical(cv)==b.curve_is_vertical(P(cv))); return t.curve_is_vertical(cv); } bool point_in_x_range(const X_curve & cv, const Point & q) const { CGAL_assertion(t.point_in_x_range(cv,q) == b.point_in_x_range(P(cv),P(q))); return t.point_in_x_range(cv,q); } Comparison_result curve_compare_y_at_x (const Point & p, const X_curve & cv) const { CGAL_assertion(t.curve_compare_y_at_x(p, cv) == b.curve_compare_y_at_x(P(p), P(cv))); return t.curve_compare_y_at_x(p, cv); } Comparison_result curves_compare_y_at_x(const X_curve &cv1, const X_curve &cv2, const Point &q) const { CGAL_assertion(t.curves_compare_y_at_x(cv1,cv2,q) == b.curves_compare_y_at_x(P(cv1),P(cv2),P(q))); return t.curves_compare_y_at_x(cv1,cv2,q); } Comparison_result curves_compare_y_at_x_left(const X_curve &cv1, const X_curve &cv2, const Point &q) const { CGAL_assertion(t.curves_compare_y_at_x_left(cv1,cv2,q) == b.curves_compare_y_at_x_left(P(cv1),P(cv2),P(q))); return t.curves_compare_y_at_x_left(cv1,cv2,q); } Comparison_result curves_compare_y_at_x_right(const X_curve & cv1, const X_curve & cv2, const Point & q) const { CGAL_assertion(t.curves_compare_y_at_x_right(cv1,cv2,q) == b.curves_compare_y_at_x_right(P(cv1),P(cv2),P(q))); return t.curves_compare_y_at_x_right(cv1,cv2,q); } Comparison_result compare_x(const Point &p1, const Point &p2) const { CGAL_assertion(t.compare_x(p1,p2)==b.compare_x(P(p1),P(p2))); return t.compare_x(p1,p2); } Comparison_result compare_xy(const Point &p1, const Point &p2) const { CGAL_assertion(t.compare_xy(p1,p2)==b.compare_xy(P(p1),P(p2))); return t.compare_xy(p1,p2); } bool curve_equal(const X_curve &cv1, const X_curve &cv2) const { CGAL_assertion(t.curve_equal(cv1,cv2)==b.curve_equal(P(cv1),P(cv2))); return t.curve_equal(cv1,cv2); } }; template class Pm_traits_checker_default_adaptor { public: const typename Tr2::Point operator()(const typename Tr1::Point& p) const {return typename Tr2::Point(p);} const typename Tr2::X_curve operator()(const typename Tr1::X_curve& c) const {return typename Tr2::X_curve(c);} }; CGAL_END_NAMESPACE #endif // CGAL_PM_SEGMENT_EXACT_TRAITS_CHECKER_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_const_decorator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_const_decor0000644000175000017500000003477511344301500031273 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_const_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_CONST_DECORATOR_H #define CGAL_HALFEDGEDS_CONST_DECORATOR_H 1 #ifndef CGAL_HALFEDGEDS_ITEMS_DECORATOR_H #include #endif #ifndef CGAL_PROTECT_VECTOR #include #define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_IO_VERBOSE_OSTREAM_H #include #endif // CGAL_IO_VERBOSE_OSTREAM_H CGAL_BEGIN_NAMESPACE template < class p_HDS > class HalfedgeDS_const_decorator : public HalfedgeDS_items_decorator { // TYPES (inherited from Items_decorator, but have to be repeated) // --------------------------------------------------------------- public: typedef p_HDS HDS; typedef p_HDS HalfedgeDS; typedef typename HDS::Traits Traits; typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Vertex_const_handle Vertex_const_handle; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Vertex_const_iterator Vertex_const_iterator; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Halfedge_const_handle Halfedge_const_handle; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef typename HDS::Halfedge_const_iterator Halfedge_const_iterator; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_const_handle Face_const_handle; typedef typename HDS::Face_iterator Face_iterator; typedef typename HDS::Face_const_iterator Face_const_iterator; typedef typename HDS::size_type size_type; typedef typename HDS::difference_type difference_type; typedef typename HDS::iterator_category iterator_category; // The following types are equal to either `Tag_true' or `Tag_false', // dependent whether the named feature is supported or not. typedef typename HDS::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename HDS::Supports_halfedge_prev Supports_halfedge_prev; typedef typename HDS::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename HDS::Supports_halfedge_face Supports_halfedge_face; typedef typename HDS::Supports_face_halfedge Supports_face_halfedge; typedef typename HDS::Supports_removal Supports_removal; protected: typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Halfedge::Base_base HBase_base; typedef typename Face::Base FBase; // PRIVATE MEMBER VARIABLES // ---------------------------------- private: const p_HDS* hds; // CREATION // ---------------------------------- public: // No default constructor, keeps always a reference to a HDS! HalfedgeDS_const_decorator( const p_HDS& h) : hds(&h) {} // keeps internally a const reference to `hds'. bool is_valid( bool verb = false, int level = 0) const; // returns `true' if the halfedge data structure `hds' is valid // with respect to the `level' value as defined in the reference // manual. If `verbose' is `true', statistics are written to // `cerr'. bool normalized_border_is_valid( bool verb = false) const; // returns `true' if the border halfedges are in normalized // representation, which is when enumerating all halfedges with // the halfedge iterator the following holds: The non-border edges // precede the border edges. For border edges, the second halfedge // is a border halfedge. (The first halfedge may or may not be a // border halfedge.) The halfedge iterator `border_halfedges_begin // ()' denotes the first border edge. If `verbose' is `true', // statistics are written to `cerr'. }; template < class p_HDS > bool HalfedgeDS_const_decorator:: normalized_border_is_valid( bool verb) const { bool valid = true; Verbose_ostream verr(verb); verr << "begin CGAL::HalfedgeDS_const_decorator::" "normalized_border_is_valid( verb=true):" << std::endl; Halfedge_const_iterator e = hds->halfedges_begin(); size_type count = 0; while( e != hds->halfedges_end() && ! e->is_border() && ! e->opposite()->is_border()) { ++e; ++e; ++count; } verr << " non-border edges: " << count << std::endl; if ( e != hds->border_halfedges_begin()) { verr << " first border edge does not start at " "border_halfedges_begin()" << std::endl; valid = false; } else { count = 0; while( valid && e != hds->halfedges_end() && e->opposite()->is_border()) { ++e; ++e; ++count; } verr << " border edges: " << count << std::endl; verr << " total edges: " << hds->size_of_halfedges()/2 << std::endl; if ( e != hds->halfedges_end()) { if ( e->is_border()) { verr << " border edge " << count << ": wrong orientation." << std::endl; } verr << " the sum of full + border equals not total edges." << std::endl; valid = false; } } verr << "end of CGAL::HalfedgeDS_const_decorator::normalized_" "border_is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } template < class p_HDS > bool HalfedgeDS_const_decorator:: is_valid( bool verb, int level) const { Verbose_ostream verr(verb); verr << "begin CGAL::HalfedgeDS_const_decorator::is_valid(" " verb=true, level = " << level << "):" << std::endl; bool valid = ( 1 != (hds->size_of_halfedges() & 1)); if ( ! valid) verr << "number of halfedges is odd." << std::endl; // All halfedges. Halfedge_const_iterator begin = hds->halfedges_begin(); Halfedge_const_iterator end = hds->halfedges_end(); size_type n = 0; size_type nb = 0; for( ; valid && (begin != end); begin++) { verr << "halfedge " << n << std::endl; if ( begin->is_border()) verr << " is border halfedge" << std::endl; // Pointer integrity. valid = valid && ( begin->next() != Halfedge_const_handle()); valid = valid && ( begin->opposite() != Halfedge_const_handle()); if ( ! valid) { verr << " pointer integrity corrupted (ptr==0)." << std::endl; break; } // opposite integrity. valid = valid && ( begin->opposite() != begin); valid = valid && ( begin->opposite()->opposite() == begin); if ( ! valid) { verr << " opposite pointer integrity corrupted." << std::endl; break; } // previous integrity. valid = valid && ( ! check_tag( Supports_halfedge_prev()) || get_prev(begin->next()) == begin); if ( ! valid) { verr << " previous pointer integrity corrupted." << std::endl; break; } if ( level > 0) { // vertex integrity. valid = valid && ( ! check_tag( Supports_halfedge_vertex()) || get_vertex( begin) != Vertex_const_handle()); if ( ! valid) { verr << " vertex pointer integrity corrupted." << std::endl; break; } valid = valid && ( get_vertex( begin) == get_vertex( begin->next()->opposite())); if ( ! valid) { verr << " vertex pointer integrity2 corrupted." << std::endl; break; } // face integrity. valid = valid && ( ! check_tag( Supports_halfedge_face()) || begin->is_border() || get_face(begin) != Face_const_handle()); if ( ! valid) { verr << " face pointer integrity corrupted." << std::endl; break; } valid = valid && ( get_face(begin) == get_face(begin->next())); if ( ! valid) { verr << " face pointer integrity2 corrupted." << std::endl; break; } } ++n; if ( begin->is_border()) ++nb; } verr << "summe border halfedges (2*nb) = " << 2 * nb << std::endl; if ( valid && n != hds->size_of_halfedges()) verr << "counting halfedges failed." << std::endl; if ( valid && level >= 4 && (nb != hds->size_of_border_halfedges())) verr << "counting border halfedges failed." << std::endl; valid = valid && ( n == hds->size_of_halfedges()); valid = valid && ( level < 4 || (nb == hds->size_of_border_halfedges())); // All vertices. Vertex_const_iterator vbegin = hds->vertices_begin(); Vertex_const_iterator vend = hds->vertices_end(); size_type v = 0; n = 0; for( ; valid && (vbegin != vend); ++vbegin) { verr << "vertex " << v << std::endl; // Pointer integrity. if ( get_vertex_halfedge( vbegin) != Halfedge_const_handle()) valid = valid && ( ! check_tag( Supports_halfedge_vertex()) || get_vertex( get_vertex_halfedge( vbegin)) == vbegin); else valid = valid && (! check_tag( Supports_vertex_halfedge())); if ( ! valid) { verr << " halfedge pointer in vertex corrupted." << std::endl; break; } // cycle-around-vertex test. Halfedge_const_handle h = get_vertex_halfedge( vbegin); if ( level >= 2 && h != Halfedge_const_handle()) { Halfedge_const_handle g = h; do { verr << " halfedge " << n << std::endl; ++n; h = h->next()->opposite(); valid = valid && ( n <= hds->size_of_halfedges() && n!=0); if ( ! valid) verr << " too many halfedges around vertices." << std::endl; } while ( valid && (h != g)); } ++v; } if ( valid && v != hds->size_of_vertices()) verr << "counting vertices failed." << std::endl; if ( valid && level >= 2 && ( check_tag( Supports_vertex_halfedge()) && n != hds->size_of_halfedges())) verr << "counting halfedges via vertices failed." << std::endl; valid = valid && ( v == hds->size_of_vertices()); valid = valid && ( level < 2 || ! check_tag( Supports_vertex_halfedge()) || n == hds->size_of_halfedges()); // All faces. Face_const_iterator fbegin = hds->faces_begin(); Face_const_iterator fend = hds->faces_end(); size_type f = 0; n = 0; for( ; valid && (fbegin != fend); ++fbegin) { verr << "face " << f << std::endl; // Pointer integrity. if ( get_face_halfedge( fbegin) != Halfedge_const_handle()) valid = valid && ( ! check_tag( Supports_halfedge_face()) || get_face( get_face_halfedge( fbegin)) == fbegin); else valid = valid && (! check_tag( Supports_face_halfedge()) || begin->is_border()); if ( ! valid) { verr << " halfedge pointer in face corrupted." << std::endl; break; } // cycle-around-face test. Halfedge_const_handle h = get_face_halfedge( fbegin); if ( level >= 3 && h != Halfedge_const_handle()) { Halfedge_const_handle g = h; do { verr << " halfedge " << n << std::endl; ++n; h = h->next(); valid = valid && ( n <= hds->size_of_halfedges() && n!=0); if ( ! valid) verr << " too many halfedges around faces." << std::endl; } while ( valid && (h != g)); } ++f; } if ( valid && f != hds->size_of_faces()) verr << "counting faces failed." << std::endl; if ( valid && level >= 3 && check_tag( Supports_face_halfedge()) && n + nb != hds->size_of_halfedges()) verr << "counting halfedges via faces failed." << std::endl; valid = valid && ( f == hds->size_of_faces()); valid = valid && ( level < 3 || ! check_tag( Supports_face_halfedge()) || n + nb == hds->size_of_halfedges()); if ( level >= 4) { verr << "level 4: normalized_border_is_valid( verbose = true)" << std::endl; valid = valid && ( normalized_border_is_valid( verb)); } verr << "end of CGAL::HalfedgeDS_const_decorator::" "is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_CONST_DECORATOR_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/0000755000175000017500000000000012146213727030015 5ustar debiandebian././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Coplanar_orientation_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Coplana0000644000175000017500000001262411344301501031305 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Coplanar_orientation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_COPLANAR_ORIENTATION_3_H #define CGAL_STATIC_FILTERS_COPLANAR_ORIENTATION_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE // XXX : // Is this really useful to optimize this predicate ? // I de-prioritize it for now. // This one is easy : it's just 3 Orientation_2. template < typename P3 > struct Point_23_xy { const P3 &p; Point_23_xy(const P3& pp) : p(pp) {} const FT& x() const { return p.x(); } const FT& y() const { return p.y(); } }; template < typename Kernel > class SF_Coplanar_orientation_3 : public Kernel::Coplanar_orientation_3 { typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Coplanar_orientation_3 Base; public: typedef Orientation result_type; Orientation operator()(const Point_3 &p, const Point_3 &q, const Point_3 &r) const { return opti_coplanar_orientationC3( to_double(p.x()), to_double(p.y()), to_double(p.z()), to_double(q.x()), to_double(q.y()), to_double(q.z()), to_double(r.x()), to_double(r.y()), to_double(r.z())); } Orientation operator()(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) const { return opti_coplanar_orientationC3( to_double(p.x()), to_double(p.y()), to_double(p.z()), to_double(q.x()), to_double(q.y()), to_double(q.z()), to_double(r.x()), to_double(r.y()), to_double(r.z()), to_double(s.x()), to_double(s.y()), to_double(s.z())); } private: Orientation opti_coplanar_orientationC3(double px, double py, double pz, double qx, double qy, double qz, double rx, double ry, double rz) const { CGAL_PROFILER("Coplanar_orientation_3 #1 calls"); std::pair oxy_pqr = orient_2d(px,py,qx,qy,rx,ry); if (oxy_pqr != COLLINEAR) return oxy_pqr; CGAL_PROFILER("Coplanar_orientation_3 #1 step2"); Orientation oyz_pqr = orient_2d(py,pz,qy,qz,ry,rz); if (oyz_pqr != COLLINEAR) return oyz_pqr; CGAL_PROFILER("Coplanar_orientation_3 #1 step3"); return orient_2d(px,pz,qx,qz,rx,rz); } Orientation opti_coplanar_orientationC3(double px, double py, double pz, double qx, double qy, double qz, double rx, double ry, double rz, double sx, double sy, double sz) const { CGAL_PROFILER("Coplanar_orientation_3 #2 calls"); Orientation oxy_pqr = orient_2d(px,py,qx,qy,rx,ry); if (oxy_pqr != COLLINEAR) return Orientation( oxy_pqr * orient_2d(px,py,qx,qy,sx,sy)); CGAL_PROFILER("Coplanar_orientation_3 #2 step2"); Orientation oyz_pqr = orient_2d(py,pz,qy,qz,ry,rz); if (oyz_pqr != COLLINEAR) return Orientation( oyz_pqr * orient_2d(py,pz,qy,qz,sy,sz)); CGAL_PROFILER("Coplanar_orientation_3 #2 step3"); Orientation oxz_pqr = orient_2d(px,pz,qx,qz,rx,rz); CGAL_kernel_assertion(oxz_pqr != COLLINEAR); return Orientation( oxz_pqr * orient_2d(px,pz,qx,qz,sx,sz)); } // FIXME : Some code duplicated from Orientation_2... std::pair orient_2d(double px, double py, double qx, double qy, double rx, double ry) const { /* double px = p.x(); double py = p.y(); double qx = q.x(); double qy = q.y(); double rx = r.x(); double ry = r.y(); */ CGAL_PROFILER("orient2d calls"); double pqx = qx-px; double pqy = qy-py; double prx = rx-px; double pry = ry-py; double det = det2x2_by_formula(pqx, pqy, prx, pry); // Then semi-static filter. double maxx = fabs(px); if (maxx < fabs(qx)) maxx = fabs(qx); if (maxx < fabs(rx)) maxx = fabs(rx); double maxy = fabs(py); if (maxy < fabs(qy)) maxy = fabs(qy); if (maxy < fabs(ry)) maxy = fabs(ry); double eps = 3.55271e-15 * maxx * maxy; if (det > eps) return std::make_pair(true, POSITIVE); if (det < -eps) return std::make_pair(true, NEGATIVE); CGAL_PROFILER("orient2d semi-static failures"); return std::make_pair(false, ZERO); } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_COPLANAR_ORIENTATION_3_H ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Side_of_oriented_circle_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Side_of0000644000175000017500000001012611344301501031273 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Side_of_oriented_circle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_SIDE_OF_ORIENTED_CIRCLE_2_H #define CGAL_STATIC_FILTERS_SIDE_OF_ORIENTED_CIRCLE_2_H #include #include CGAL_BEGIN_NAMESPACE template < typename K_base > class SF_Side_of_oriented_circle_2 : public K_base::Side_of_oriented_circle_2 { typedef typename K_base::Point_2 Point_2; typedef typename K_base::Side_of_oriented_circle_2 Base; public: Oriented_side operator()(const Point_2 &p, const Point_2 &q, const Point_2 &r, const Point_2 &t) const { CGAL_PROFILER("In_circle_2 calls"); double px, py, qx, qy, rx, ry, tx, ty; if (fit_in_double(p.x(), px) && fit_in_double(p.y(), py) && fit_in_double(q.x(), qx) && fit_in_double(q.y(), qy) && fit_in_double(r.x(), rx) && fit_in_double(r.y(), ry) && fit_in_double(t.x(), tx) && fit_in_double(t.y(), ty)) { CGAL_PROFILER("In_circle_2 semi-static attempts"); double qpx = qx-px; double qpy = qy-py; double rpx = rx-px; double rpy = ry-py; double tpx = tx-px; double tpy = ty-py; double tqx = tx-qx; double tqy = ty-qy; double rqx = rx-qx; double rqy = ry-qy; double det = det2x2_by_formula(qpx*tpy - qpy*tpx, tpx*tqx + tpy*tqy, qpx*rpy - qpy*rpx, rpx*rqx + rpy*rqy); // We compute the semi-static bound. double maxx = fabs(qpx); if (maxx < fabs(rpx)) maxx = fabs(rpx); if (maxx < fabs(tpx)) maxx = fabs(tpx); if (maxx < fabs(tqx)) maxx = fabs(tqx); if (maxx < fabs(rqx)) maxx = fabs(rqx); double maxy = fabs(qpy); if (maxy < fabs(rpy)) maxy = fabs(rpy); if (maxy < fabs(tpy)) maxy = fabs(tpy); if (maxy < fabs(tqy)) maxy = fabs(tqy); if (maxy < fabs(rqy)) maxy = fabs(rqy); double maxt = maxx; if (maxt < maxy) maxt = maxy; double eps = 8.887856576200131e-15 * maxx * maxy * (maxt*maxt); // Protect against underflow in the computation of eps. if (maxx < 1e-73 || maxy < 1e-73) { if (maxx == 0 || maxy == 0) return ON_ORIENTED_BOUNDARY; } else { if (det > eps) return ON_POSITIVE_SIDE; if (det < -eps) return ON_NEGATIVE_SIDE; } CGAL_PROFILER("In_circle_2 semi-static failures"); } return Base::operator()(p, q, r, t); } // Computes the epsilon for In_circle_2. static double compute_epsilon() { typedef CGAL::Static_filter_error F; F t1 = F(1, F::ulp()/2); // First translation F a = t1*t1 - t1*t1; F b = t1*t1 + t1*t1; F det = det2x2_by_formula(a, b, a, b); double err = det.error(); std::cerr << "*** epsilon for In_circle_2 = " << err << std::endl; return err; } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_SIDE_OF_ORIENTED_CIRCLE_2_H ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Coplanar_side_of_bounded_circle_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Coplana0000644000175000017500000001205311344301501031301 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Coplanar_side_of_bounded_circle_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_COPLANAR_SIDE_OF_BOUNDED_CIRCLE_3_H #define CGAL_STATIC_FILTERS_COPLANAR_SIDE_OF_BOUNDED_CIRCLE_3_H #include #include #include #include // #include // Only used to precompute constants CGAL_BEGIN_NAMESPACE template class SF_Side_of_bounded_circle_3 { // Computes the epsilon for In_circle_3. static double cir_3() { // NOTE : This produces a buggy degree warning. // Maybe there's a bug in the formula. typedef CGAL::Static_filter_error F; F t1 = F(1)-F(1); // First translation F sq = t1*t1+t1*t1+t1*t1; // squares F n1 = t1*t1 - t1*t1; // normal vector F sq_n1 = n1*n1 + n1*n1 + n1*n1; F det = det4x4_by_formula(t1, t1, t1, sq, t1, t1, t1, sq, t1, t1, t1, sq, n1, n1, n1, sq_n1); // Full det double err = det.error(); std::cerr << "*** epsilon for In_circle_3 = " << err << std::endl; return err; } public: typedef Bounded_side result_type; Bounded_side operator()(const Point &p, const Point &q, const Point &r, const Point &t) const { return opti_coplanar_in_circleC3( to_double(p.x()), to_double(p.y()), to_double(p.z()), to_double(q.x()), to_double(q.y()), to_double(q.z()), to_double(r.x()), to_double(r.y()), to_double(r.z()), to_double(t.x()), to_double(t.y()), to_double(t.z())); } Bounded_side opti_coplanar_in_circleC3(double px, double py, double pz, double qx, double qy, double qz, double rx, double ry, double rz, double tx, double ty, double tz) const { CGAL_PROFILER("In_circle_3 calls"); double ptx = px - tx; double pty = py - ty; double ptz = pz - tz; double pt2 = CGAL_NTS square(ptx) + CGAL_NTS square(pty) + CGAL_NTS square(ptz); double qtx = qx - tx; double qty = qy - ty; double qtz = qz - tz; double qt2 = CGAL_NTS square(qtx) + CGAL_NTS square(qty) + CGAL_NTS square(qtz); double rtx = rx - tx; double rty = ry - ty; double rtz = rz - tz; double rt2 = CGAL_NTS square(rtx) + CGAL_NTS square(rty) + CGAL_NTS square(rtz); double pqx = qx - px; double pqy = qy - py; double pqz = qz - pz; double prx = rx - px; double pry = ry - py; double prz = rz - pz; double vx = pqy*prz - pqz*pry; double vy = pqz*prx - pqx*prz; double vz = pqx*pry - pqy*prx; double v2 = CGAL_NTS square(vx) + CGAL_NTS square(vy) + CGAL_NTS square(vz); double det = det4x4_by_formula(ptx,pty,ptz,pt2, rtx,rty,rtz,rt2, qtx,qty,qtz,qt2, vx,vy,vz,v2); // Compute the semi-static bound. double maxx = fabs(px); if (maxx < fabs(qx)) maxx = fabs(qx); if (maxx < fabs(rx)) maxx = fabs(rx); if (maxx < fabs(tx)) maxx = fabs(tx); double maxy = fabs(py); if (maxy < fabs(qy)) maxy = fabs(qy); if (maxy < fabs(ry)) maxy = fabs(ry); if (maxy < fabs(ty)) maxy = fabs(ty); double maxz = fabs(pz); if (maxz < fabs(qz)) maxz = fabs(qz); if (maxz < fabs(rz)) maxz = fabs(rz); if (maxz < fabs(tz)) maxz = fabs(tz); double d = std::max(maxx, std::max(maxy, maxz)); double eps = 3.27418e-11 * d * d * d * d * d * d; if (det > eps) return ON_BOUNDED_SIDE; if (det < -eps) return ON_UNBOUNDED_SIDE; CGAL_PROFILER("In_circle_3 semi-static failures"); typedef Simple_cartesian > K; typedef K::Point_3 P; return coplanar_side_of_bounded_circle(P(px,py,pz), P(qx,qy,qz), P(rx,ry,rz), P(tx,ty,tz)); } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_COPLANAR_SIDE_OF_BOUNDED_CIRCLE_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Orientation_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Orienta0000644000175000017500000001012311344301501031321 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Orientation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_ORIENTATION_3_H #define CGAL_STATIC_FILTERS_ORIENTATION_3_H #include #include CGAL_BEGIN_NAMESPACE template < typename K_base > class SF_Orientation_3 : public K_base::Orientation_3 { typedef typename K_base::Point_3 Point_3; typedef typename K_base::Orientation_3 Base; public: Orientation operator()(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) const { CGAL_PROFILER("Orientation_3 calls"); double px, py, pz, qx, qy, qz, rx, ry, rz, sx, sy, sz; if (fit_in_double(p.x(), px) && fit_in_double(p.y(), py) && fit_in_double(p.z(), pz) && fit_in_double(q.x(), qx) && fit_in_double(q.y(), qy) && fit_in_double(q.z(), qz) && fit_in_double(r.x(), rx) && fit_in_double(r.y(), ry) && fit_in_double(r.z(), rz) && fit_in_double(s.x(), sx) && fit_in_double(s.y(), sy) && fit_in_double(s.z(), sz)) { CGAL_PROFILER("Orientation_3 semi-static attempts"); double pqx = qx - px; double pqy = qy - py; double pqz = qz - pz; double prx = rx - px; double pry = ry - py; double prz = rz - pz; double psx = sx - px; double psy = sy - py; double psz = sz - pz; // Then semi-static filter. double maxx = fabs(pqx); if (maxx < fabs(prx)) maxx = fabs(prx); if (maxx < fabs(psx)) maxx = fabs(psx); double maxy = fabs(pqy); if (maxy < fabs(pry)) maxy = fabs(pry); if (maxy < fabs(psy)) maxy = fabs(psy); double maxz = fabs(pqz); if (maxz < fabs(prz)) maxz = fabs(prz); if (maxz < fabs(psz)) maxz = fabs(psz); double eps = 5.1107127829973276e-15 * maxx * maxy * maxz; double det = det3x3_by_formula(pqx, pqy, pqz, prx, pry, prz, psx, psy, psz); // Protect against underflow in the computation of eps. if (maxx < 1e-97 || maxy < 1e-97 || maxz < 1e-97) { if (maxx == 0 || maxy == 0 || maxz == 0) return ZERO; } else { if (det > eps) return POSITIVE; if (det < -eps) return NEGATIVE; } CGAL_PROFILER("Orientation_3 semi-static failures"); } return Base::operator()(p, q, r, s); } // Computes the epsilon for Orientation_3. static double compute_epsilon() { typedef Static_filter_error F; F t1 = F(1, F::ulp()/2); // First translation F det = det3x3_by_formula(t1, t1, t1, t1, t1, t1, t1, t1, t1); // Full det double err = det.error(); std::cerr << "*** epsilon for Orientation_3 = " << err << std::endl; return err; } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_ORIENTATION_3_H ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Side_of_oriented_sphere_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Side_of0000644000175000017500000001243511344301501031300 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Side_of_oriented_sphere_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_SIDE_OF_ORIENTED_SPHERE_3_H #define CGAL_STATIC_FILTERS_SIDE_OF_ORIENTED_SPHERE_3_H #include #include CGAL_BEGIN_NAMESPACE template < typename K_base > class SF_Side_of_oriented_sphere_3 : public K_base::Side_of_oriented_sphere_3 { typedef typename K_base::Point_3 Point_3; typedef typename K_base::Side_of_oriented_sphere_3 Base; public: Oriented_side operator()(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s, const Point_3 &t) const { CGAL_PROFILER("In_sphere_3 calls"); double px, py, pz, qx, qy, qz, rx, ry, rz, sx, sy, sz, tx, ty, tz; if (fit_in_double(p.x(), px) && fit_in_double(p.y(), py) && fit_in_double(p.z(), pz) && fit_in_double(q.x(), qx) && fit_in_double(q.y(), qy) && fit_in_double(q.z(), qz) && fit_in_double(r.x(), rx) && fit_in_double(r.y(), ry) && fit_in_double(r.z(), rz) && fit_in_double(s.x(), sx) && fit_in_double(s.y(), sy) && fit_in_double(s.z(), sz) && fit_in_double(t.x(), tx) && fit_in_double(t.y(), ty) && fit_in_double(t.z(), tz)) { CGAL_PROFILER("In_sphere_3 semi-static attempts"); double ptx = px - tx; double pty = py - ty; double ptz = pz - tz; double pt2 = CGAL_NTS square(ptx) + CGAL_NTS square(pty) + CGAL_NTS square(ptz); double qtx = qx - tx; double qty = qy - ty; double qtz = qz - tz; double qt2 = CGAL_NTS square(qtx) + CGAL_NTS square(qty) + CGAL_NTS square(qtz); double rtx = rx - tx; double rty = ry - ty; double rtz = rz - tz; double rt2 = CGAL_NTS square(rtx) + CGAL_NTS square(rty) + CGAL_NTS square(rtz); double stx = sx - tx; double sty = sy - ty; double stz = sz - tz; double st2 = CGAL_NTS square(stx) + CGAL_NTS square(sty) + CGAL_NTS square(stz); // Compute the semi-static bound. double maxx = fabs(ptx); if (maxx < fabs(qtx)) maxx = fabs(qtx); if (maxx < fabs(rtx)) maxx = fabs(rtx); if (maxx < fabs(stx)) maxx = fabs(stx); double maxy = fabs(pty); if (maxy < fabs(qty)) maxy = fabs(qty); if (maxy < fabs(rty)) maxy = fabs(rty); if (maxy < fabs(sty)) maxy = fabs(sty); double maxz = fabs(ptz); if (maxz < fabs(qtz)) maxz = fabs(qtz); if (maxz < fabs(rtz)) maxz = fabs(rtz); if (maxz < fabs(stz)) maxz = fabs(stz); double maxt = maxx; if (maxt < maxy) maxt = maxy; if (maxt < maxz) maxt = maxz; double eps = 1.246613653102729e-13 * maxx * maxy * maxz * (maxt * maxt); double det = det4x4_by_formula(ptx,pty,ptz,pt2, rtx,rty,rtz,rt2, qtx,qty,qtz,qt2, stx,sty,stz,st2); // Protect against underflow in the computation of eps. if (maxx < 1e-59 || maxy < 1e-59 || maxz < 1e-59) { if (maxx == 0 || maxy == 0 || maxz == 0) return ON_ORIENTED_BOUNDARY; } else { if (det > eps) return ON_POSITIVE_SIDE; if (det < -eps) return ON_NEGATIVE_SIDE; } CGAL_PROFILER("In_sphere_3 semi-static failures"); } return Base::operator()(p, q, r, s, t); } // Computes the epsilon for In_sphere_3. static double compute_epsilon() { typedef CGAL::Static_filter_error F; F t1 = F(1,F::ulp()/2); // First translation F sq = t1*t1+t1*t1+t1*t1; // squares F det = det4x4_by_formula(t1, t1, t1, sq, t1, t1, t1, sq, t1, t1, t1, sq, t1, t1, t1, sq); // Full det double err = det.error(); std::cerr << "*** epsilon for In_sphere_3 = " << err << std::endl; return err; } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_SIDE_OF_ORIENTED_SPHERE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/tools.h0000644000175000017500000000473111344301501031316 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/tools.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_TOOLS_H #define CGAL_STATIC_FILTERS_TOOLS_H #include CGAL_BEGIN_NAMESPACE // Utility function to check a posteriori that a subtraction was performed // without rounding error. inline bool diff_was_exact(double a, double b, double ab) { return ab+b == a && a-ab == b; } // Auxiliary function to check if static filters can be applied, that is, // if to_double() does not add roundoff errors. // TODO : // - generalize it to other number types. // - promote it as a number type requirement ? // - naming : is_representable_in_double() ? // is_representable() for representable in T ? // Current semantics : bool fit_in_double(const NT& n, double &) // // - returns true means that "n" is exactly representable by a double, // _and_ then "returns" it in the reference. // - it is fine to return false conservatively. template < typename T > inline bool fit_in_double(const T&, double&) { return false; } inline bool fit_in_double(const double& d, double& r) { r = d; return true; } inline bool fit_in_double(const float& f, double& r) { r = f; return true; } inline bool fit_in_double(const int& i, double& r) { r = i; return true; } template < typename ET > class Lazy_exact_nt; template < typename ET > inline bool fit_in_double(const Lazy_exact_nt&, double&); CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_TOOLS_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Orientation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Orienta0000644000175000017500000000642311344301501031331 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters/Orientation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_ORIENTATION_2_H #define CGAL_STATIC_FILTERS_ORIENTATION_2_H #include #include CGAL_BEGIN_NAMESPACE template < typename K_base > class SF_Orientation_2 : public K_base::Orientation_2 { typedef typename K_base::Point_2 Point_2; typedef typename K_base::Orientation_2 Base; public: Orientation operator()(const Point_2 &p, const Point_2 &q, const Point_2 &r) const { CGAL_PROFILER("Orientation_2 calls"); double px, py, qx, qy, rx, ry; if (fit_in_double(p.x(), px) && fit_in_double(p.y(), py) && fit_in_double(q.x(), qx) && fit_in_double(q.y(), qy) && fit_in_double(r.x(), rx) && fit_in_double(r.y(), ry)) { CGAL_PROFILER("Orientation_2 semi-static attempts"); double pqx = qx - px; double pqy = qy - py; double prx = rx - px; double pry = ry - py; double det = det2x2_by_formula(pqx, pqy, prx, pry); // Then semi-static filter. double maxx = fabs(pqx); if (maxx < fabs(prx)) maxx = fabs(prx); double maxy = fabs(pqy); if (maxy < fabs(pry)) maxy = fabs(pry); double eps = 8.8872057372592758e-16 * maxx * maxy; // Protect against underflow in the computation of eps. if (maxx < 1e-146 || maxy < 1e-146) { if (maxx == 0 || maxy == 0) return ZERO; } else { if (det > eps) return POSITIVE; if (det < -eps) return NEGATIVE; } CGAL_PROFILER("Orientation_2 semi-static failures"); } return Base::operator()(p, q, r); } // Computes the epsilon for Orientation_2. static double compute_epsilon() { typedef Static_filter_error F; F t1 = F(1, F::ulp()/2); // First translation F det = det2x2_by_formula(t1, t1, t1, t1); // Full det double err = det.error(); std::cerr << "*** epsilon for Orientation_2 = " << err << std::endl; return err; } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_ORIENTATION_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_graph_2.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_grap0000644000175000017500000006344211344301501031512 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_graph_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Susan Hert namespace CGAL { /* // ??? need to finish this ??? template template bool Vertex_visibility_graph_2::is_valid(ForwardIterator first, ForwardIterator beyond) { std::vector vertices(first, beyond); bool edge_there[vertices.size()]; // for each edge in the graph determine if it is either an edge of the // polygon or, if not, if it intersects the polygon in the interior of the // edge. for (iterator e_it = edges.begin(); e_it != edges.end(); e_it++) { Segment_2 s = construct_segment_2((*e_it).first, (*e_it).second); if (is_an_edge(*e_it)) edge_there[edge_num] = true; else if (do_intersect_in_interior(s, first, beyond)) return false; } // check if all the edges of the polygon are present // // ??? how do you check if there are missing edges ??? } */ // want to determine, for each vertex p of the polygon, the line segment // immediately below it. For vertical edges, the segment below is not the // one that begins at the other endpoint of the edge. template void Vertex_visibility_graph_2::initialize_vertex_map( const Polygon& polygon, Vertex_map& vertex_map) { typedef typename Vertex_map::value_type Map_pair; // Create an event list that is a list of circulators for the polygon Iterator_list iterator_list(polygon.begin(), polygon.end()); // Sort the event list (iterators to points) from left to right // (using less_xy) #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES iterator_list.sort(&Self::compare); #else iterator_list.sort(Indirect_less_xy_2()); #endif // Create an ordered list of edge endpoints (iterators), initially empty typedef std::set< Point_pair, Segment_less_yx_2 > Ordered_edge_set; typedef typename Ordered_edge_set::iterator Ordered_edge_set_iterator; Ordered_edge_set ordered_edges; Ordered_edge_set_iterator edge_it; Vertex_map_iterator vm_it; Vertex_map_iterator vis_it; Polygon_const_iterator event_it; Polygon_const_iterator next_endpt; Polygon_const_iterator prev_endpt; // initialize the map by associating iterators and points and indicating // that no points can see anything. for (Polygon_const_iterator it = polygon.begin();it != polygon.end();it++) { vertex_map.insert(Map_pair(*it, Iterator_pair(it, polygon.end()))); } // now go through the events in sorted order. while (!iterator_list.empty()) { event_it = iterator_list.front(); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "event = " << *event_it << std::endl; #endif next_endpt = event_it; next_endpt++; if (next_endpt == polygon.end()) next_endpt = polygon.begin(); iterator_list.pop_front(); // the first edge that is not less than (below) this edge, so ... edge_it = ordered_edges.lower_bound(Point_pair(*event_it,*next_endpt)); // ...if there is no edge below this one then nothing is visible, // otherwise.... if (edge_it != ordered_edges.begin()) { edge_it--; // ...the first visible edge is the previous edge // find the event point in the vertex map vm_it = vertex_map.find(*event_it); // Find the entry for the edge's first endpoint in the vertex map. vis_it = vertex_map.find((*edge_it).first); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "the potential visibility point is " << (*vis_it).first << endl; #endif // an edge that ends at this event point cannot be below this // endpoint if (!is_next_to(polygon, (*vis_it).second.first, event_it)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "the edge beginning at " << *(*vis_it).second.first << " is visible" << endl; #endif // set the visibility iterator for this point to the iterator // corresponding to the edge endpoint that is to the left of // the vertical line if (less_xy_2((*vis_it).first, (*vm_it).first)) { Polygon_const_iterator next_vtx = (*vis_it).second.first; next_vtx++; if (next_vtx == polygon.end()) next_vtx = polygon.begin(); (*vm_it).second.second = next_vtx; } else (*vm_it).second.second = (*vis_it).second.first; } // skip over the edge that ends at this event point. If there // is another edge above this event's edge then it is visible. // since it can't also end at the event point. else if (edge_it != ordered_edges.begin() && --edge_it != ordered_edges.begin()) { vis_it = vertex_map.find((*edge_it).first); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "the edge beginning at " << *(*vis_it).second.first << " is visible" << endl; #endif // set the visibility iterator for this point to the iterator // corresponding to the edge endpoint that is to the left of // the vertical line if (less_xy_2((*vis_it).first, (*vm_it).first)) { Polygon_const_iterator next_vtx = (*vis_it).second.first; next_vtx++; if (next_vtx == polygon.end()) next_vtx = polygon.begin(); (*vm_it).second.second = next_vtx; } else (*vm_it).second.second = (*vis_it).second.first; } #ifdef CGAL_VISIBILITY_GRAPH_DEBUG else std::cout << "nothing is visible " << endl; #endif } #ifdef CGAL_VISIBILITY_GRAPH_DEBUG else cout << "nothing is visible " << endl; #endif prev_endpt = event_it; if (prev_endpt == polygon.begin()) prev_endpt = polygon.end(); prev_endpt--; // if the other endpoint of the next edge is to the right of the // sweep line, then insert this edge if (less_xy_2(*event_it, *next_endpt)) { ordered_edges.insert(Point_pair(*event_it,*next_endpt)); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "inserting edge from " << *event_it << " to " << *next_endpt << endl; #endif } else // other endpoint not to the right, so erase it { ordered_edges.erase(Point_pair(*event_it,*next_endpt)); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "erasing edge from " << *event_it << " to " << *next_endpt << endl; #endif } // if the other endpoint of the previous edge is to the right of the // sweep line, insert it if (less_xy_2(*event_it, *prev_endpt)) { ordered_edges.insert(Point_pair(*prev_endpt,*event_it)); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "inserting edge from " << *prev_endpt << " to " << *event_it << endl; #endif } else // other endpoint is not to the right, so erase it { ordered_edges.erase(Point_pair(*prev_endpt,*event_it)); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "erasing edge from " << *prev_endpt << " to " << *event_it << endl; #endif } } } // determines if one makes a left turn going from p to q to q's parent. // if q's parent is p_infinity, then a left turn is made when p's x value // is less than q's x value or the x values are the same and p's y value is // less than q's. // if p, q, and q's parent are collinear, then one makes a "left turn" // if q is between p and q's parent (since this means that p can't see // q's parent and thus should not become a child of that node) template bool Vertex_visibility_graph_2::left_turn_to_parent( Tree_iterator p, Tree_iterator q, Tree& tree) { if (tree.parent_is_p_infinity(q)) { return (less_xy_2(*p, *q)); } else if (orientation_2(*p, *q, *(*q).parent()) == COLLINEAR && (collinear_ordered_2(*p, *q, *(*q).parent()) || collinear_ordered_2(*p, *q, *(*q).parent()))) { return true; } else { return left_turn_2(*p, *q, *(*q).parent()); } } // returns true if the diagonal from p to q cuts the interior angle at p template bool Vertex_visibility_graph_2::diagonal_in_interior( const Polygon& polygon, Polygon_const_iterator p, Polygon_const_iterator q) { Turn_reverser right_turn(left_turn_2); Polygon_const_iterator before_p; if (p == polygon.begin()) before_p = polygon.end(); else before_p = p; before_p--; Polygon_const_iterator after_p = p; after_p++; if (after_p == polygon.end()) after_p = polygon.begin(); if (right_turn(*before_p, *p, *after_p)) { if (right_turn(*before_p, *p, *q) && right_turn(*q, *p, *after_p)) return false; } else // left turn or straight at vertex { /* // p should not be able to see q through its own edge if (are_strictly_ordered_along_line(*p, *after_p, *q)) return false; */ if (right_turn(*before_p, *p, *q) || right_turn(*q, *p, *after_p)) return false; } return true; } // returns true if the looker can see the point_to_see template bool Vertex_visibility_graph_2::point_is_visible( const Polygon& polygon, Polygon_const_iterator point_to_see, Vertex_map_iterator looker) { // Collect pointers to the current visibility segments for the looker // (the current visibility point and the two vertices flanking this vertex) Polygon_const_iterator vis_endpt = (*looker).second.second; Polygon_const_iterator next_vis_endpt = vis_endpt; next_vis_endpt++; if (next_vis_endpt == polygon.end()) next_vis_endpt = polygon.begin(); Polygon_const_iterator prev_vis_endpt; if (vis_endpt == polygon.begin()) prev_vis_endpt = polygon.end(); else prev_vis_endpt = vis_endpt; prev_vis_endpt--; #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker is " << (*looker).first << " point to see is " << *point_to_see; cout << " visibility points are prev: " << *prev_vis_endpt << " vis: " << *vis_endpt << " next: " << *next_vis_endpt << endl; #endif // if the point to see is the current visibility point or if the looker // and the point to see flank the old visibility point, they are visible // to each other since it is known at this point that the edge from // the looker to the point to see goes through the interior of the polygon if ((*looker).second.second == point_to_see) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "looker sees point" << std::endl; #endif return true; } else if (((*looker).second.first == prev_vis_endpt && point_to_see == next_vis_endpt) || ((*looker).second.first == next_vis_endpt && point_to_see == prev_vis_endpt)) { if (orientation_2(*prev_vis_endpt, *vis_endpt, *next_vis_endpt) == COLLINEAR && (collinear_ordered_2((*looker).first, *vis_endpt, *point_to_see) || collinear_ordered_2(*point_to_see, *vis_endpt, (*looker).first))) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker does NOT see point" << endl; #endif return false; } else { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker sees point" << endl; #endif return true; } } else if ((*looker).second.first == prev_vis_endpt || point_to_see == prev_vis_endpt) // point to see or looker is not adjacent to old visibility, so check // intersection with next visibility segment { if (orientation_2(*vis_endpt, *next_vis_endpt, (*looker).first) != orientation_2(*vis_endpt, *next_vis_endpt, *point_to_see) && orientation_2((*looker).first, *point_to_see, *vis_endpt) != orientation_2((*looker).first, *point_to_see, *next_vis_endpt)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker does NOT see point" << endl; #endif return false; } else { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker sees point" << endl; #endif return true; } } else if ((*looker).second.first == next_vis_endpt || point_to_see == next_vis_endpt) // point to see or looker is not adjacent to old visibility, so check // intersection with previous visibility segment { if (orientation_2(*vis_endpt, *prev_vis_endpt, (*looker).first) != orientation_2(*vis_endpt, *prev_vis_endpt, *point_to_see) && orientation_2((*looker).first, *point_to_see, *vis_endpt) != orientation_2((*looker).first, *point_to_see, *prev_vis_endpt)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker does NOT see point" << endl; #endif return false; } else { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker sees point" << endl; #endif return true; } } else // neither is adjacent to the old visibility point so check intersection // with both visibility segments { if (orientation_2(*vis_endpt, *next_vis_endpt, (*looker).first) != orientation_2(*vis_endpt, *next_vis_endpt, *point_to_see) && orientation_2((*looker).first, *point_to_see, *vis_endpt) != orientation_2((*looker).first, *point_to_see, *next_vis_endpt)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker does NOT see point" << endl; #endif return false; } else if (orientation_2(*vis_endpt, *prev_vis_endpt, (*looker).first) != orientation_2(*vis_endpt, *prev_vis_endpt, *point_to_see) && orientation_2((*looker).first, *point_to_see, *vis_endpt) != orientation_2((*looker).first, *point_to_see, *prev_vis_endpt)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker does NOT see point" << endl; #endif return false; } else // no intersection { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "looker sees point" << endl; #endif return true; } } } template void Vertex_visibility_graph_2::update_visibility( Vertex_map_iterator p_it, Vertex_map_iterator q_it, const Polygon& polygon, int are_adjacent) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "updating visibility: " << std::endl; #endif Polygon_const_iterator prev_q; Polygon_const_iterator turn_q; if ((*q_it).second.first == polygon.begin()) prev_q = polygon.end(); else prev_q = (*q_it).second.first; prev_q--; // determine if the vertex before or after q is the one that will // be encountered next when moving in the direction from p to q. if (prev_q == (*p_it).second.first) { turn_q = (*q_it).second.first; turn_q++; if (turn_q == polygon.end()) turn_q = polygon.begin(); } else turn_q = prev_q; #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "prev_q = " << *prev_q << " turn_q = " << *turn_q << std::endl; #endif if (are_adjacent) { if (orientation_2((*p_it).first, (*q_it).first, *turn_q) == RIGHT_TURN) { (*p_it).second.second = (*q_it).second.second; // p sees what q sees #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "adjacent with right turn; p now sees what q sees" << std::endl; #endif } else // turn left or go straight { (*p_it).second.second = (*q_it).second.first; // p sees q #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "adjacent and NOT right turn; p now sees q " << std::endl; #endif } } // if not adjacent, the edge was an interior one and so the "next" vertex // (the turn vertex) has to be the one that follows q. // // if Segment(q) == vis(p), i.e., p already sees q's segment else if ((*q_it).second.first == (*p_it).second.second || prev_q == (*p_it).second.second) { turn_q = (*q_it).second.first; turn_q++; if (turn_q == polygon.end()) turn_q = polygon.begin(); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "prev_q = " << *prev_q << " turn_q = " << *turn_q << std::endl; #endif // q sees nothing or there is not a right turn to the point after q if ((*q_it).second.second == polygon.end() || orientation_2((*p_it).first, (*q_it).first, *turn_q) != RIGHT_TURN) { (*p_it).second.second = (*q_it).second.first; // p sees q #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p sees q's segment, q sees nothing and not right to " << " next point; p sees q " << std::endl; #endif } else { (*p_it).second.second = (*q_it).second.second; // p sees what q sees #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p sees q's segment, q sees something;" << " p sees what q sees" << std::endl; #endif } } // Before(p,q,vis(p)) == true if q lies nearer to p than segment vis(p) // NOTE: it is known that p is always looking to the right. else if ((*p_it).second.second != polygon.end()) // if p sees something { Polygon_const_iterator next_v_p = (*p_it).second.second; next_v_p++; if (next_v_p == polygon.end()) next_v_p = polygon.begin(); // don't need to do this for the previous visibility point since // if it were closer to p than q when looking from p to q, q would // not be visible. Segment_2 next_seg = construct_segment_2(*(*p_it).second.second, *next_v_p); Ray_2 ray = construct_ray_2((*p_it).first, (*q_it).first); Segment_2 i_seg; Point_2 i_point; Object_2 next_result = intersect_2(next_seg, ray); if (assign_2(i_point, next_result)) { if (collinear_ordered_2((*p_it).first, (*q_it).first, i_point)) { (*p_it).second.second = (*q_it).second.first; #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p sees something in direction of q, but q is closer;" << " p sees q" << std::endl; #endif } #ifdef CGAL_VISIBILITY_GRAPH_DEBUG else { std::cout << "p sees something in direction of q that's closer " << "than q; p doesn't see q" << std::endl; } #endif } else if (assign_2(i_seg, next_result)) { if (collinear_ordered_2((*p_it).first,(*q_it).first,i_seg.source()) && collinear_ordered_2((*p_it).first,(*q_it).first,i_seg.target())) { (*p_it).second.second = (*q_it).second.first; #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p sees something in direction of q, but q is closer;" << " p sees q" << std::endl; #endif } #ifdef CGAL_VISIBILITY_GRAPH_DEBUG else { std::cout << "p sees something in direction of q that's closer " << " than q; p doesn't see q" << std::endl; } #endif } else { (*p_it).second.second = (*q_it).second.first; #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p doesn't see something in direction of q; p sees q" << std::endl; #endif } } else // p sees what q sees { (*p_it).second.second = (*q_it).second.first; #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p sees nothing; p sees what q sees" << std::endl; #endif } } template void Vertex_visibility_graph_2::update_collinear_visibility( Vertex_map_iterator p_it, Vertex_map_iterator q_it, const Polygon& polygon) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "updating collinear visibility" << std::endl; #endif Polygon_const_iterator prev_q; if ((*q_it).second.first == polygon.begin()) prev_q = polygon.end(); else prev_q = (*q_it).second.first; prev_q--; Polygon_const_iterator next_q = (*q_it).second.first; next_q++; if (next_q == polygon.end()) next_q = polygon.begin(); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "q's neighbors are: prev " << *prev_q << " q " << (*q_it).first << " next " << *next_q << std::endl; #endif // if the point before q is above the line containing p and q, make // this p's visibility point if (left_turn_2((*p_it).first, (*q_it).first, *prev_q)) { if (point_is_visible(polygon, prev_q, p_it)) (*p_it).second.second = prev_q; } // check the same thing for the point after q and, if it is still visible // (even after possibly updating the visibility in the above if) the // update again. if (left_turn_2((*p_it).first, (*q_it).first, *next_q)) { if (point_is_visible(polygon, next_q, p_it)) (*p_it).second.second = next_q; } } // The segment between points p and q is a potential visibility edge // This function determines if the edge should be added or not (based // on p's current visibility point) and updates p's visibility point // where appropriate template void Vertex_visibility_graph_2::handle(Tree_iterator p, Tree_iterator q, const Polygon& polygon, Vertex_map& vertex_map) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "Handling edge from " << (*p).x() << " " << (*p).y() << " to " << (*q).x() << " " << (*q).y() << std::endl; #endif Vertex_map_iterator p_it = vertex_map.find(*p); Vertex_map_iterator q_it = vertex_map.find(*q); CGAL_assertion (p_it != vertex_map.end()); CGAL_assertion (q_it != vertex_map.end()); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p currently sees : "; if ((*p_it).second.second != polygon.end()) std::cout << *((*p_it).second.second) << endl; else std::cout << " NADA" << endl; #endif // if p and q are adjacent if (are_adjacent(polygon, (*p_it).second.first, (*q_it).second.first)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "are adjacent" << endl; #endif insert_edge(Point_pair(*p,*q)); update_visibility(p_it, q_it, polygon, 1); } else { bool interior_at_p = diagonal_in_interior(polygon, (*p_it).second.first, (*q_it).second.first); bool interior_at_q = diagonal_in_interior(polygon, (*q_it).second.first, (*p_it).second.first); // line of site is through the interior of the polygon if (interior_at_p && interior_at_q) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "both interior" << endl; #endif // if p sees something and q is visible only through collinear // points then update p's visibility if one of the points adjacent // to q is above the line unless p's current visibility point // obscures the view. if ((*p_it).second.second != polygon.end() && are_strictly_ordered_along_line_2((*p_it).first, *(*p_it).second.second, (*q_it).first)) { update_collinear_visibility(p_it, q_it, polygon); } // p current sees nothing or q is visible to p else if ((*p_it).second.second == polygon.end() || point_is_visible(polygon, (*q_it).second.first, p_it)) { insert_edge(Point_pair(*p,*q)); update_visibility(p_it, q_it, polygon, 0); } } else if (!interior_at_p && !interior_at_q) // both points exterior { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG cout << "both exterior" << endl; #endif // p currently sees nothing or q is visible to p if ((*p_it).second.second == polygon.end() || point_is_visible(polygon, (*q_it).second.first, p_it)) { (*p_it).second.second = (*q_it).second.first; } } } #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "p now sees : "; if ((*p_it).second.second != polygon.end()) std::cout << *((*p_it).second.second) << endl; else std::cout << " NADA" << endl; #endif } } ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/minimum_enclosing_quadrilateral_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/minimum_enclosing_quad0000644000175000017500000000237411344301500031477 0ustar debiandebian// Copyright (c) 1999-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/minimum_enclosing_quadrilateral_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann and // Emo Welzl #if ! (CGAL_MINIMUM_ENCLOSING_QUADRILATERAL_2_H) #define CGAL_MINIMUM_ENCLOSING_QUADRILATERAL_2_H 1 #ifndef CGAL_NO_DEPRECATED_CODE #include #endif // CGAL_NO_DEPRECATED_CODE #endif // ! (CGAL_MINIMUM_ENCLOSING_QUADRILATERAL_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Ray_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Ray_2_0000644000175000017500000000224711344301500031142 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Ray_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_walk_along_line_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_walk_along_line_poi0000644000175000017500000001625211344301500031401 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_walk_along_line_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_PM_WALK_ALONG_LINE_POINT_LOCATION_H #define CGAL_PM_WALK_ALONG_LINE_POINT_LOCATION_H #include #include //#define CGAL_PM_WALK_DEBUG //#define CGAL_PM_DEBUG #ifdef CGAL_PM_DEBUG #ifndef CGAL_NAIVE_POINT_LOCATION_H #include #endif #endif //////////////////////////////////////////////////////// // WALK_ALONG_LINE STRATEGY //////////////////////////////////////////////////////// CGAL_BEGIN_NAMESPACE template class Pm_walk_along_line_point_location : public Pm_point_location_base { public: typedef Planar_map_ Planar_map; typedef Pm_point_location_base Base; typedef Pm_walk_along_line_point_location Self; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Traits_wrap::Point Point; typedef typename Traits_wrap::X_curve X_curve; typedef typename Traits::Point_2 Point_2; typedef typename Traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Face_const_handle Face_const_handle; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Planar_map::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Planar_map::Holes_iterator Holes_iterator; typedef typename Planar_map::Holes_const_iterator Holes_const_iterator; typedef typename Planar_map::Halfedge_around_vertex_const_circulator Avcc; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef Pm_bounding_box_base Bounding_box; typedef typename Base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Base::Token Token; protected: typedef const Self* const_Self_ptr; public: // Constructor Pm_walk_along_line_point_location() : Pm_point_location_base(), pm(0), traits(0) {} void init(Planar_map & pmp, const Traits & tr) { CGAL_precondition_msg(pm == NULL, "Point location instance should be uninitialized " "(Do not use the same instance for more than one map)."); pm = &pmp; traits = (Traits_wrap*)(&tr); } inline void insert(Halfedge_handle, const X_curve &) {} Halfedge_const_handle locate(const Point & p, Locate_type & lt) const; Halfedge_handle locate(const Point & p, Locate_type & lt); Halfedge_const_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) const; Halfedge_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up); inline void split_edge(const X_curve &, Halfedge_handle, Halfedge_handle, //additions by iddo for arrangement const X_curve &, const X_curve &) {} inline void merge_edge(const X_curve &, const X_curve &, Halfedge_handle, //additions by iddo for arrangement const X_curve &) {} inline void remove_edge(Halfedge_handle) {} inline void remove_edge(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &) {}; inline void clear() {} inline void update(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &, const Token& token) { token.rebuild_bounding_box(this); } private: void walk_along_line(const Point & p, bool up, bool including, Halfedge_const_handle & e, Locate_type & lt) const ; /* Simulates a walk along a vertical ray shoot whose shape is determined by 'up' and 'including'. e is the returned edge. */ Halfedge_const_handle find_vertex_representation(Halfedge_const_handle e, const Point & p, bool up) const /* find the first halfedge pointing to p, when going clockwise if up==true - start from 6 oclock, else start from 12 oclock precondition: e points to p. postcondition: returned value points to p. */ { #ifdef CGAL_PM_DEBUG CGAL_precondition(traits->point_equal(e->target()->point(),p)); #endif Avcc first = e,curr=first; ++curr; if (up) while(curr!=first) { if (traits->curves_compare_y_at_x_from_bottom(curr->curve(),e->curve(),p) ==SMALLER) { e=curr; break;// this can't be improved } ++curr; } else while(curr!=first) { if (traits->curves_compare_y_at_x_from_top(curr->curve(),e->curve(),p) ==SMALLER) { e=curr; break;// this can't be improved } ++curr; } #ifdef CGAL_PM_DEBUG CGAL_postcondition(e!=pm->halfedges_end()); CGAL_postcondition(traits->point_equal(e->target()->point(),p)); #endif return e; } bool find_closest(const Point & p, const Ccb_halfedge_const_circulator & c, bool up, bool including, Halfedge_const_handle & e, Locate_type & lt) const; /* Finds the closest halfedge on a ccb along a vertical ray shoot. The bools 'up' and 'including' set the vertical ray shoot's shape. The return value is true iff such an halfedge exists. Locate type is UNBOUNDED_FACE if point is outside ccb FACE if inside EDGE of on edge-boundary VERTEX if on vertex-boundary. */ #ifdef CGAL_PM_DEBUG void debug() {} void debug(const Halfedge_handle& e) const { { if (e!=pm->halfedges_end()) std::cerr << "(" << e->source()->point() << "," << e->target()->point() << ")" << std::flush; else std::cerr << "(oo)"; } } #endif public: inline const Traits * get_traits() const {return traits;} protected: inline const Bounding_box * get_bounding_box() const { return pm->get_bounding_box(); } Planar_map * pm; const Traits_wrap * traits; }; CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif #endif //PM_WALK_ALONG_LINE_POINT_LOCATION_H ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_filtered_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000000563511344301500031454 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_filtered_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_REGULAR_TRIANGULATION_FILTERED_TRAITS_2_H #define CGAL_REGULAR_TRIANGULATION_FILTERED_TRAITS_2_H #include #include #include CGAL_BEGIN_NAMESPACE // The Weighted_converter is parametrized by a usual kernel converter, // and adds the conversions for the Weighted_point. template < typename Converter > struct Weighted_converter_2 : Converter { typedef typename Converter::Source_kernel Source_kernel; typedef typename Converter::Target_kernel Target_kernel; typedef typename Regular_triangulation_euclidean_traits_base_2 ::Weighted_point_2 Source_wp; typedef typename Regular_triangulation_euclidean_traits_base_2 ::Weighted_point_2 Target_wp; Target_wp operator()(const Source_wp &wp) const { return Target_wp(Converter::operator()(wp.point()), Converter::operator()(wp.weight())); } }; // The argument is supposed to be a Filtered_kernel like kernel. template < typename K > class Regular_triangulation_filtered_traits_2 : public Regular_triangulation_euclidean_traits_base_2 { // Exact traits is based on the exact kernel. typedef Regular_triangulation_euclidean_traits_2 Exact_traits; // Filtering traits is based on the filtering kernel. typedef Regular_triangulation_euclidean_traits_2 Filtering_traits; typedef typename K::C2E C2E; typedef typename K::C2F C2F; public: typedef Filtered_predicate< typename Exact_traits::Power_test_2, typename Filtering_traits::Power_test_2, Weighted_converter_2, Weighted_converter_2 > Power_test_2; Power_test_2 power_test_2_object() const { return Power_test_2();} // The following are inherited since they are constructions : // Construct_weighted_circumcenter_2 // Construct_radical_axis_2 }; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_FILTERED_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/0000755000175000017500000000000012146213714026147 5ustar debiandebian././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Filtered_queue_container.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Filtered_queue_0000644000175000017500000000451111344301501031163 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Filtered_queue_container.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_FILTRED_QUEUE_CONTAINER_H #define CGAL_FILTRED_QUEUE_CONTAINER_H #include #include namespace CGAL { namespace Mesh_2 { /** This container is a filtered queue: front() and empty() use an object predicate to test if the element is ok. */ template class Filtered_queue_container { public: typedef Elt Element; typedef Pred Predicate; typedef typename std::deque::const_iterator const_iterator; private: // --- private datas --- std::deque d; Predicate test; public: Filtered_queue_container(Predicate p) : d(), test(p) {} Filtered_queue_container() : test() {} void clear() { d.clear(); } bool empty() { if(d.empty()) return true; while( !test(d.front()) ) { d.pop_front(); if( d.empty() ) return true; } return false; } Element& get_next_element() { while( !test(d.front()) ) d.pop_front(); return d.front(); } void add_element(const Element& e) { d.push_back(e); } void remove_next_element() { d.pop_front(); } const_iterator begin() const { return d.begin(); } const_iterator end() const { return d.end(); } }; // end Simple_queue_container } // end namespace Mesh_2 } // end namespace CGAL #endif // CGAL_FILTRED_QUEUE_CONTAINER_H ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Triangulation_mesher_level_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Triangulation_m0000644000175000017500000000476611344301501031232 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Triangulation_mesher_level_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_TRIANGULATION_MESHER_LEVEL_TRAITS_2_H #define CGAL_MESH_2_TRIANGULATION_MESHER_LEVEL_TRAITS_2_H #include namespace CGAL { template struct Triangulation_mesher_level_traits_2 { typedef Tr Triangulation; typedef typename Tr::Point Point; typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Edge Edge; struct Zone { typedef std::list Faces; typedef std::list Edges; public: typedef typename Faces::iterator Faces_iterator; typedef typename Edges::iterator Edges_iterator; Faces faces; Edges boundary_edges; }; static Zone get_conflicts_zone(Tr& t, const Point& p) { Zone zone; t.get_conflicts_and_boundary(p, std::back_inserter(zone.faces), std::back_inserter(zone.boundary_edges) ); #ifdef DEBUG std::cerr << "get_conflicts_and_boundary(" << p << "):" << std::endl << "faces: " << zone.faces.size() << std::endl << "edges: " << zone.boundary_edges.size() << std::endl; #endif // DEBUG return zone; } static Vertex_handle insert(Tr&t, const Point& p, Zone& zone) { #ifdef DEBUG std::cerr << "insert(" << p << "): " << zone.boundary_edges.size() << " edges." << std::endl; #endif return t.star_hole(p, zone.boundary_edges.begin(), zone.boundary_edges.end(), zone.faces.begin(), zone.faces.end()); } }; // end Triangulation_mesher_level_traits_2 }; // end namespace CGAL #endif // CGAL_MESH_2_TRIANGULATION_MESHER_LEVEL_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Clusters.h0000644000175000017500000003715511344301501030126 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Clusters.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_CLUSTERS_H #define CGAL_MESH_2_CLUSTERS_H #include #include #include namespace CGAL { namespace Mesh_2 { namespace details { template class Is_edge_constrained { public: typedef typename Tr::Edge_circulator Edge_circulator; Is_edge_constrained() {} bool operator()(const Edge_circulator& ec) const { return ec->first->is_constrained(ec->second); } }; } // end namespace details template class Clusters { typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Point Point; typedef typename Tr::Geom_traits Geom_traits; typedef typename Geom_traits::FT FT; typedef FT Squared_length; /** > Constrained_edge_circulator; public: /** \name Clusters public types */ /** * \c Cluster register several informations about clusters. * A cluster is a set of vertices v_i incident to one vertice * v_0, so that angles between segments [v_0, v_i] is less than 60 * degres. */ struct Cluster { bool reduced ; /**< Is the cluster reduced? */ /** * Smallest_angle gives the two vertices defining the * smallest angle in the cluster. */ std::pair smallest_angle; FT rmin; // @fixme: rmin has no meaning if reduced=false!!! Squared_length minimum_squared_length; /** * The following map tells what vertices are in the cluster and if * the corresponding segment has been splitted once. */ typedef std::map Vertices_map; Vertices_map vertices; bool is_reduced() const { return reduced; } bool is_reduced(const Vertex_handle v) { return vertices[v]; } }; private: /** \name Clusters associated types */ typedef std::multimap Cluster_map; template struct Pair_get_first: public std::unary_function { typedef typename Pair::first_type result; const result& operator()(const Pair& p) const { return p.first; } }; typedef typename Cluster::Vertices_map Cluster_vertices_map; private: /* --- protected datas --- */ Tr& tr; /**< The triangulation itself. */ /** * Multimap \c Vertex_handle -> \c Cluster * Each vertex can have several clusters. */ Cluster_map cluster_map; public: typedef typename Cluster_map::const_iterator const_iterator; typedef typename Cluster_map::iterator iterator; Clusters(Tr& tr_) : tr(tr_) { } /** For all vertices, calls create_clusters_of_vertex(). */ void create_clusters(); private: /** * Computes clusters of the vertex \c v, using the auxiliary function * construct_cluster(). */ void create_clusters_of_vertex(const Vertex_handle v); /** * Adds the sequence [\c begin, \c end] to the cluster \c c and adds it * to the clusters of the vertex \c v. */ void construct_cluster(const Vertex_handle v, Constrained_edge_circulator begin, const Constrained_edge_circulator& end, Cluster c = Cluster()); public: /** \name Functions to manage clusters during the refinement process. */ /** * Update the cluster of [\c va,\c vb], putting \c vm instead of \c vb. * If reduction=false, the edge [va,vm] is not set reduced. */ void update_cluster(Cluster& c, iterator it, const Vertex_handle va, const Vertex_handle vb, const Vertex_handle vm, bool reduction = true); /** * Returns the cluster of [\c va,\c vb] in \c c and return true * if it is in a cluster. Returns also a const_iterator in \c it. */ bool get_cluster(const Vertex_handle va, const Vertex_handle vb, Cluster& c, iterator& it); /** Const version of get_cluster(). */ bool get_cluster(const Vertex_handle va, const Vertex_handle vb, Cluster& c, const_iterator& it) const; /** \name Auxiliary functions that return a boolean. */ /** * Tells if the angle is less than 60 degres. * Uses squared_cosine_of_angle_times_4() and used by * create_clusters_of_vertex(). */ bool is_small_angle(const Point& pleft, const Point& pmiddle, const Point& pright) const; private: /** \name Helping computing functions */ /** Returns the squared cosine of the angle times 4. */ FT squared_cosine_of_angle_times_4(const Point& pleft, const Point& pmiddle, const Point& pright) const; /** Helper functions to access the two vertices of an Edge source is the vertex around which the circulator turns. */ //@{ Vertex_handle source(const Edge_circulator& ec) const { return ec->first->vertex(tr.cw(ec->second)); } Vertex_handle target(const Edge_circulator& ec) const { return ec->first->vertex(tr.ccw(ec->second)); } //@} public: /** \name CONST ACCESS FUNCTIONS */ typedef typename boost::transform_iterator< Pair_get_first, typename Cluster_map::const_iterator> Cluster_vertices_iterator; typedef typename boost::transform_iterator< Pair_get_first, typename Cluster_vertices_map::const_iterator> Vertices_in_cluster_iterator; int size() const { return cluster_map.size(); } Cluster_vertices_iterator clusters_vertices_begin() const { return Cluster_vertices_iterator(cluster_map.begin()); } Cluster_vertices_iterator clusters_vertices_end() const { return Cluster_vertices_iterator(cluster_map.end()); } unsigned int number_of_clusters_at_vertex(const Vertex_handle& vh) const { typedef typename Cluster_map::const_iterator Iterator; typedef std::pair Range; Range range = cluster_map.equal_range(vh); return std::distance(range.first, range.second); } // returns the sequence of vertices bellonging to the n-th cluster of vh std::pair vertices_in_cluster_sequence(const Vertex_handle& vh, const unsigned int n) const { typedef typename Cluster_map::const_iterator Iterator; typedef std::pair Range; typedef typename Range::first_type Clusters_iterator; typedef Pair_get_first Get_first; Range range = cluster_map.equal_range(vh); Iterator first = range.first; std::advance(first, n); const Cluster& c = first->second; return std::make_pair(Vertices_in_cluster_iterator(c.vertices.begin()), Vertices_in_cluster_iterator(c.vertices.end())); } }; // end class Clusters template void Clusters:: update_cluster(Cluster& c, iterator it, Vertex_handle va, Vertex_handle vb, Vertex_handle vm, bool reduction) { typename Geom_traits::Compute_squared_distance_2 squared_distance = tr.geom_traits().compute_squared_distance_2_object(); cluster_map.erase(it); c.vertices.erase(vb); c.vertices[vm] = reduction; if(vb==c.smallest_angle.first) c.smallest_angle.first = vm; if(vb==c.smallest_angle.second) c.smallest_angle.second = vm; FT l = squared_distance(va->point(),vm->point()); if(lfirst)) ++it; // @todo: use std::find and an object class if(it==c.vertices.end()) c.reduced = true; } if(c.is_reduced()) c.rmin = squared_distance(c.smallest_angle.first->point(), c.smallest_angle.second->point())/FT(4); cluster_map.insert(std::make_pair(va,c)); } template bool Clusters:: get_cluster(Vertex_handle va, Vertex_handle vb, Cluster& c, const_iterator& it) const { typedef std::pair Range; Range range = cluster_map.equal_range(va); for(it = range.first; it != range.second; it++) { const Cluster &cl = it->second; if(cl.vertices.find(vb)!=cl.vertices.end()) { c = it->second; return true; } } return false; } template bool Clusters:: get_cluster(Vertex_handle va, Vertex_handle vb, Cluster& c, iterator& it) { typedef std::pair Range; Range range = cluster_map.equal_range(va); for(it = range.first; it != range.second; it++) { const Cluster &cl = it->second; if(cl.vertices.find(vb)!=cl.vertices.end()) { c = it->second; return true; } } return false; } template void Clusters:: create_clusters() { cluster_map.clear(); #ifndef CGAL_IT_IS_A_CONSTRAINED_TRIANGULATION_PLUS for(typename Tr::Finite_vertices_iterator vit = tr.finite_vertices_begin(); vit != tr.finite_vertices_end(); vit++) create_clusters_of_vertex(vit); #else Unique_hash_map created(false); for(typename Tr::Subconstraint_iterator it = tr.subconstraints_begin(); it != tr.subconstraints_end(); ++it) { Vertex_handle vh = it->first.first; if(!created[vh]){ created[vh] = true; create_clusters_of_vertex(vh); } vh = it->first.second; if(!created[vh]){ created[vh] = true; create_clusters_of_vertex(vh); } } #endif } template void Clusters:: create_clusters_of_vertex(const Vertex_handle v) { details::Is_edge_constrained test; Constrained_edge_circulator begin(tr.incident_edges(v),test); // This circulator represents all constrained edges around the // vertex v. An edge [v,v'] is represented by the vertex v'. if(begin == 0) return; // if there is only one vertex Constrained_edge_circulator current(begin), next(begin), cluster_begin(begin); ++next; // next is always just after current. if(current == next) return; bool in_a_cluster = false; do { if(is_small_angle(target(current)->point(), v->point(), target(next)->point())) { if(!in_a_cluster) { // at this point, current is the beginning of a cluster in_a_cluster = true; cluster_begin = current; } } else if(in_a_cluster) { // at this point, current is the end of a cluster and // cluster_begin is its beginning construct_cluster(v, cluster_begin, current); in_a_cluster = false; } ++next; ++current; } while( current!=begin ); if(in_a_cluster) { Cluster c; iterator it; if(get_cluster(v, target(begin), c, it)) { // get the cluster and erase it from the clusters map cluster_map.erase(it); construct_cluster(v, cluster_begin, begin, c); } else construct_cluster(v, cluster_begin, current); } } template void Clusters:: construct_cluster(Vertex_handle v, Constrained_edge_circulator begin, const Constrained_edge_circulator& end, Cluster c) { typename Geom_traits::Compute_squared_distance_2 squared_distance = tr.geom_traits().compute_squared_distance_2_object(); if(c.vertices.empty()) { c.reduced = false; // c.rmin is not initialized because // reduced=false! c.minimum_squared_length = squared_distance(v->point(), target(begin)->point()); Constrained_edge_circulator second(begin); ++second; c.smallest_angle.first = target(begin); c.smallest_angle.second = target(second); } bool all_edges_in_cluster=false; // tell if all incident edges are // in the cluster if(begin==end) all_edges_in_cluster=true; const Point& vp = v->point(); FT greatest_cosine = squared_cosine_of_angle_times_4(c.smallest_angle.first->point(), v->point(), c.smallest_angle.second->point()); Constrained_edge_circulator next(begin); ++next; do { c.vertices[target(begin)] = false; Squared_length l = squared_distance(vp, target(begin)->point()); c.minimum_squared_length = std::min(l,c.minimum_squared_length); if(all_edges_in_cluster || begin!=end) { FT cosine = squared_cosine_of_angle_times_4(target(begin)->point(), v->point(), target(next)->point()); if(cosine>greatest_cosine) { greatest_cosine = cosine; c.smallest_angle.first = target(begin); c.smallest_angle.second = target(next); } } } while(next++,begin++!=end); typedef typename Cluster_map::value_type Value_key_pair; cluster_map.insert(Value_key_pair(v,c)); } template bool Clusters:: is_small_angle(const Point& pleft, const Point& pmiddle, const Point& pright) const { typename Geom_traits::Angle_2 angle = tr.geom_traits().angle_2_object(); typename Geom_traits::Orientation_2 orient = tr.geom_traits().orientation_2_object(); if( angle(pleft, pmiddle, pright)==OBTUSE ) return false; if( orient(pmiddle,pleft,pright)==RIGHT_TURN) return false; FT cos_alpha = squared_cosine_of_angle_times_4(pleft, pmiddle, pright); if(cos_alpha > 1) { return true; //the same cluster } else { return false; //another cluster } } template typename Clusters::FT Clusters:: squared_cosine_of_angle_times_4(const Point& pb, const Point& pa, const Point& pc) const { typename Geom_traits::Compute_squared_distance_2 squared_distance = tr.geom_traits().compute_squared_distance_2_object(); const FT a = squared_distance(pb, pc), b = squared_distance(pa, pb), c = squared_distance(pa, pc); const FT num = a-(b+c); return (num*num)/(b*c); } } // end namespace Mesh_2 } // end namespace CGAL #endif // CGAL_MESH_2_CLUSTERS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges.h0000644000175000017500000004676111344301501030704 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_REFINE_EDGES_H #define CGAL_MESH_2_REFINE_EDGES_H #include #include #include #include #include #include #include namespace CGAL { /** * \namespace Mesh_2 * Defines classes that are not yet documented. * * \namespace Mesh_2::details * Namespace for internal use. */ namespace Mesh_2 { template class Refine_edges_triangulation_mesher_level_traits_2 { public: typedef Tr Triangulation; typedef typename Tr::Point Point; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Edge Edge; typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Locate_type Locate_type; typedef Triangulation_mesher_level_traits_2 Std_traits; typedef typename Std_traits::Zone Zone; private: Edge edge; public: void set_edge(const Edge e) { edge = e; } Zone get_conflicts_zone(Tr& t, const Point& p) { Zone zone; typedef std::back_insert_iterator OutputItFaces; typedef std::back_insert_iterator OutputItEdges; OutputItFaces faces_out(zone.faces); OutputItEdges edges_out(zone.boundary_edges); const Face_handle& f = edge.first; const int& i = edge.second; *faces_out++ = f; const Face_handle n = f->neighbor(i); *faces_out++ = n; const int ni = f->mirror_index(i); std::pair pit = std::make_pair(faces_out,edges_out); pit = t.propagate_conflicts(p,f,t.ccw(i),pit); pit = t.propagate_conflicts(p,f,t. cw(i),pit); pit = t.propagate_conflicts(p,n,t.ccw(ni),pit); pit = t.propagate_conflicts(p,n,t. cw(ni),pit); return zone; } static Vertex_handle insert(Tr&t, const Point& p, Zone& zone) { return Std_traits::insert(t, p, zone); } }; // end Refine_edges_triangulation_mesher_level_traits_2 namespace details { /** This class defines several auxiliary types for \c Refine_edges. */ template struct Refine_edges_base_types { typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef std::pair Constrained_edge; /** Object predicate that tests if a given \c Constrained_Edge is really an edge of the triangulation and is constrained. */ class Is_really_a_constrained_edge { const Tr& tr; public: /** \param tr_ points to the triangulation. */ explicit Is_really_a_constrained_edge(const Tr& tr_) : tr(tr_) {} bool operator()(const Constrained_edge& ce) const { Face_handle fh; int i; return tr.is_edge(ce.first, ce.second, fh,i) && fh->is_constrained(i); } }; typedef ::CGAL::Mesh_2::Filtered_queue_container Default_container; }; }; // end namespace details /** * Predicate class that verifies that an edge is locally conforming * Gabriel. Moreover, This classes defines a predicate that test if an * edge is encroached by a given point. * \param Tr The type of the trianglation. */ template struct Is_locally_conforming_Gabriel { typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Point Point; typedef typename Tr::Geom_traits Geom_traits; /** Operator that takes an edge (\c fh, \c index). */ bool operator()(Tr& ct, const Face_handle& fh, const int i) const { typedef typename Geom_traits::Angle_2 Angle_2; const Angle_2 angle = ct.geom_traits().angle_2_object(); const Vertex_handle& va = fh->vertex(ct. cw(i)); const Vertex_handle& vb = fh->vertex(ct.ccw(i)); const Point& a = va->point(); const Point& b = vb->point(); const Vertex_handle& vi = fh->vertex(i); const Vertex_handle& mvi = fh->mirror_vertex(i); return( ( ct.is_infinite(vi) || angle(a, vi->point(), b) != OBTUSE) && ( ct.is_infinite(mvi) || angle(a, mvi->point(), b) != OBTUSE) ); } /** Operator that takes an edge (\c va, \c vb). */ bool operator()(Tr& ct, const Vertex_handle& va, const Vertex_handle& vb) const { Face_handle fh; int i; CGAL_assertion_code( bool should_be_true = ) ct.is_edge(va, vb, fh, i); CGAL_assertion( should_be_true == true ); return this->operator()(ct, fh, i); } /** * Operator that takes an edge (\c fh, \c index) and a point \c p. * Tests if the point encroached the edge. */ bool operator()(Tr& ct, const Face_handle& fh, const int i, const Point& p) const { return this->operator()(ct, fh->vertex(ct. cw(i)), fh->vertex(ct.ccw(i)), p); } /** * Operator that takes an edge (\c va, \c vb) and a point \c p. * Tests if the point encroached the edge. */ bool operator()(Tr& ct, const Vertex_handle& va, const Vertex_handle& vb, const Point& p) const { typedef typename Geom_traits::Angle_2 Angle_2; const Angle_2 angle = ct.geom_traits().angle_2_object(); const Point& a = va->point(); const Point& b = vb->point(); return( angle(a, p, b) != OBTUSE ); } }; /** * Predicate class that verifies that an edge is locally conforming * Delaunay. * \param Tr The type of the trianglation. */ template struct Is_locally_conforming_Delaunay { typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Point Point; typedef typename Tr::Geom_traits Geom_traits; /** Operator that takes an edge (\c fh, \c index). */ bool operator()(Tr& ct, const Face_handle& fh, const int i) const { typedef typename Geom_traits::Side_of_oriented_circle_2 Side_of_oriented_circle_2; Side_of_oriented_circle_2 in_circle = ct.geom_traits().side_of_oriented_circle_2_object(); const Vertex_handle& vi = fh->vertex(i); const Vertex_handle& mvi = fh->mirror_vertex(i); if(ct.is_infinite(vi) || ct.is_infinite(mvi)){ return true; } const Point& a = fh->vertex(ct. cw(i))->point(); const Point& b = fh->vertex(ct.ccw(i))->point(); const Point& c = vi->point(); const Point& d = mvi->point(); return( in_circle(c, b, a, d) == ON_NEGATIVE_SIDE ); } /** Operator that takes an edge (\c va, \c vb). */ bool operator()(Tr& ct, const Vertex_handle& va, const Vertex_handle& vb) const { typedef typename Geom_traits::Side_of_oriented_circle_2 Side_of_oriented_circle_2; Side_of_oriented_circle_2 in_circle = ct.geom_traits().side_of_oriented_circle_2_object(); Face_handle fh; int i; CGAL_assertion_code( bool test = ) ct.is_edge(va, vb, fh, i); CGAL_assertion( test == true ); const Vertex_handle& vi = fh->vertex(i); const Vertex_handle& mvi = fh->mirror_vertex(i); if(ct.is_infinite(vi) || ct.is_infinite(mvi)){ return true; } const Point& a = va->point(); const Point& b = vb->point(); const Point& c = vi->point(); const Point& d = mvi->point(); return( in_circle(c, b, a, d) == ON_NEGATIVE_SIDE ); } }; /** * This class is the base for the first level of Mesh_2: the edge * conforming level. It does not handle clusters. * * \param Tr is the type of triangulation on which the level acts. * \param Is_locally_conform defines the locally conform criterion: Gabriel * or Delaunay. It defaults to the Garbriel criterion. * \param Container is the type of container. It defaults to a filtered * queue of \c Vertex_handle pair (see \c Filtered_queue_container). */ template < class Tr, class Is_locally_conform = Is_locally_conforming_Gabriel, class Container = typename details::Refine_edges_base_types::Default_container > class Refine_edges_base { public: typedef typename Tr::Finite_edges_iterator Finite_edges_iterator; typedef typename Tr::Face_circulator Face_circulator; typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Edge Edge; typedef typename Tr::Point Point; typedef typename Tr::Geom_traits Geom_traits; typedef typename Triangulation_mesher_level_traits_2::Zone Zone; typedef Refine_edges_triangulation_mesher_level_traits_2 Triangulation_traits; typedef typename details::Refine_edges_base_types::Constrained_edge Constrained_edge; protected: /* --- protected datas --- */ Tr& tr; /**< The triangulation itself. */ Triangulation_traits traits; /** Predicates to filter edges. */ typedef typename details::Refine_edges_base_types ::Is_really_a_constrained_edge Is_really_a_constrained_edge; const Is_really_a_constrained_edge is_really_a_constrained_edge; Container edges_to_be_conformed; /**< Edge queue */ /** The object predicate that defines the locally conform criteria. */ Is_locally_conform is_locally_conform; Vertex_handle va, vb; bool imperatively; public: /** \name CONSTRUCTORS */ Refine_edges_base(Tr& tr_) : tr(tr_), traits(), is_really_a_constrained_edge(tr_), edges_to_be_conformed(is_really_a_constrained_edge), is_locally_conform(), imperatively(false), converter(tr_) { } /** \name HELPING FUNCTIONS */ void clear() { edges_to_be_conformed.clear(); } void set_imperative_refinement(bool b) { imperatively = b; } /** \name Functions that this level must declare. */ Tr& get_triangulation_ref() { return tr; } const Tr& get_triangulation_ref() const { return tr; } Triangulation_traits& get_triangulation_traits() { return traits; } const Triangulation_traits& get_triangulation_traits() const { return traits; } /** Scans all constrained edges and put them in the queue if they are encroached. */ void do_scan_triangulation() { clear(); #ifndef CGAL_IT_IS_A_CONSTRAINED_TRIANGULATION_PLUS for(Finite_edges_iterator ei = tr.finite_edges_begin(); ei != tr.finite_edges_end(); ++ei) if(ei->first->is_constrained(ei->second) && !is_locally_conform(tr, ei->first, ei->second) ) add_constrained_edge_to_be_conformed(*ei); #else for(typename Tr::Subconstraint_iterator it = tr.subconstraints_begin(); it != tr.subconstraints_end(); ++it) { const Vertex_handle& v1 = it->first.first; const Vertex_handle& v2 = it->first.second; if(fh->is_constrained(i) && !is_locally_conform(tr, v1, v2) ) add_constrained_edge_to_be_conformed(v1, v2); } #endif } // end do_scan_triangulation() /** Tells if the queue of edges to be conformed is empty or not. */ bool is_no_longer_element_to_refine() { return edges_to_be_conformed.empty(); } /** Get the next edge to conform. */ Edge do_get_next_element() { Constrained_edge edge = edges_to_be_conformed.get_next_element(); Face_handle fh; int index; CGAL_assertion_code( bool should_be_true =) tr.is_edge(edge.first, edge.second, fh, index); CGAL_assertion( should_be_true == true ); return Edge(fh, index); } /** Pop the first edge of the queue. */ void do_pop_next_element() { edges_to_be_conformed.remove_next_element(); } /** This version computes the refinement point without handling clusters. The refinement point of an edge is just the middle point of the segment. Saves the handles of the edge that will be splitted. This function is overridden in class Refine_edge_with_clusters. */ Point get_refinement_point(const Edge& edge) { typename Geom_traits::Construct_midpoint_2 midpoint = tr.geom_traits().construct_midpoint_2_object(); va = edge.first->vertex(tr.cw (edge.second)); vb = edge.first->vertex(tr.ccw(edge.second)); return midpoint(va->point(), vb->point()); } /** Passes the edge to the triangulation traits. */ void do_before_conflicts(const Edge& e, const Point&) { traits.set_edge(e); } /** Do nothing. */ void do_after_no_insertion(const Edge&, const Point&, const Zone& ) { } /** * Test if the edges of the boundary are locally conforming. * Push which that are not in the list of edges to be conformed. */ std::pair do_test_point_conflict_from_superior(const Point& p, Zone& z) { bool no_edge_is_encroached = true; for(typename Zone::Edges_iterator eit = z.boundary_edges.begin(); eit != z.boundary_edges.end(); ++eit) { const Face_handle& fh = eit->first; const int& i = eit->second; if(fh->is_constrained(i) && !is_locally_conform(tr, fh, i, p)) { add_constrained_edge_to_be_conformed(*eit); no_edge_is_encroached = false; } } return std::make_pair(no_edge_is_encroached, false); } /** Do nothing. */ std::pair do_private_test_point_conflict(Point, Zone) { return std::make_pair(true, true); } /** Unmark as constrained. */ void do_before_insertion(const Edge& e, const Point&, const Zone&) { const Face_handle& f = e.first; const int& i = e.second; f->set_constraint(i, false); (f->neighbor(i))->set_constraint(f->mirror_index(i), false); } /** * Scans the edges of the star boundary, to test if they are both * locally conforming. If not, push them in the list of edges to be * conformed. * */ void do_after_insertion(const Vertex_handle& v) { // @todo Perhaps we should remove destroyed edges too. // @warning This code has been rewroten! Face_circulator fc = tr.incident_faces(v), fcbegin(fc); if( fc == 0 ) return; do { const int i = fc->index(v); CGAL_assertion( i>=0 && i < 4); if( fc->is_constrained(i) && !is_locally_conform(tr, fc, i) ) add_constrained_edge_to_be_conformed(Edge(fc, i)); ++fc; } while( fc != fcbegin ); Face_handle fh; int index; CGAL_assertion_code(bool should_be_true = ) tr.is_edge(va, v, fh, index); CGAL_assertion(should_be_true == true); fh->set_constraint(index,true); fh->neighbor(index)->set_constraint(fh->mirror_index(index),true); CGAL_assertion_code( should_be_true = ) tr.is_edge(vb, v, fh, index); CGAL_assertion(should_be_true == true); fh->set_constraint(index,true); fh->neighbor(index)->set_constraint(fh->mirror_index(index),true); if(!is_locally_conform(tr, va, v)) add_constrained_edge_to_be_conformed(va, v); if(!is_locally_conform(tr, vb, v)) add_constrained_edge_to_be_conformed(vb, v); } // end do_after_insertion protected: /** \name Auxiliary functions */ /** Add an \c Edge \c e in the queue. */ void add_constrained_edge_to_be_conformed(const Edge& e) { const Vertex_handle& va = e.first->vertex(tr. cw(e.second)); const Vertex_handle& vb = e.first->vertex(tr.ccw(e.second)); edges_to_be_conformed.add_element(std::make_pair(va, vb)); } /** Add an edge (\c va,\c vb) in the queue. */ void add_constrained_edge_to_be_conformed(const Vertex_handle& va, const Vertex_handle& vb) { edges_to_be_conformed.add_element(std::make_pair(va, vb)); } private: /** \name DEBUGGING TYPES AND DATAS */ class From_pair_of_vertex_to_edge : public std::unary_function { Tr& tr; public: From_pair_of_vertex_to_edge(Tr& t) : tr(t) {}; const Edge operator()(const Constrained_edge edge) const { Face_handle fh; int index; tr.is_edge(edge.first, edge.second, fh, index); return Edge(fh, index); } }; // end From_pair_of_vertex_to_edge // -- private data member -- From_pair_of_vertex_to_edge converter; private: typedef boost::filter_iterator Aux_edges_filter_iterator; public: /** \name DEBUGGING FUNCTIONS */ typedef boost::transform_iterator< From_pair_of_vertex_to_edge, Aux_edges_filter_iterator> Edges_const_iterator; Edges_const_iterator begin() const { return Edges_const_iterator( Aux_edges_filter_iterator(is_really_a_constrained_edge, this->edges_to_be_conformed.begin(), this->edges_to_be_conformed.end()), converter); } Edges_const_iterator end() const { return Edges_const_iterator( Aux_edges_filter_iterator(is_really_a_constrained_edge, this->edges_to_be_conformed.end(), this->edges_to_be_conformed.end()), converter); } }; // end class Refine_edges_base namespace details { template struct Refine_edges_types { typedef Refine_edges_triangulation_mesher_level_traits_2 Triangulation_traits; typedef Mesher_level < Triangulation_traits, Self, typename Tr::Edge, Null_mesher_level > Edges_mesher_level; }; // end Refine_edges_types } // end namespace details template , typename Base = Refine_edges_base > struct Refine_edges : public Base, public details::Refine_edges_types >::Edges_mesher_level { typedef Refine_edges Self; typedef typename details::Refine_edges_types Types; typedef typename Types::Edges_mesher_level Mesher; public: Refine_edges(Tr& t, Null_mesher_level& null_level) : Base(t), Mesher(null_level) { } }; // end Refine_edges } // end namespace Mesh_2 } // end namespace CGAL #endif // CGAL_MESH_2_REFINE_EDGES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_faces.h0000644000175000017500000002716611344301501030674 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_faces.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_REFINE_FACES_H #define CGAL_MESH_2_REFINE_FACES_H #include #include #include namespace CGAL { namespace Mesh_2 { // Previous is the whole previous edges_level. template class Refine_faces_base { /** \name Types from Tr. */ typedef typename Tr::Geom_traits Geom_traits; typedef typename Geom_traits::FT FT; typedef FT Squared_length; typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Face_circulator Face_circulator; typedef typename Tr::Finite_faces_iterator Finite_faces_iterator; typedef typename Tr::All_faces_iterator All_faces_iterator; typedef typename Tr::Point Point; typedef Triangulation_mesher_level_traits_2 Triangulation_traits; typedef typename Triangulation_traits::Zone Zone; protected: // --- PROTECTED TYPES --- /** Meshing criteria. */ typedef typename Criteria::Is_bad s_bad; typedef typename Criteria::Quality Quality; /** \name typedefs for private members types */ typedef CGAL::Double_map Bad_faces; protected: // --- PROTECTED MEMBER DATAS --- Tr& tr; /**< The triangulation itself. */ Triangulation_mesher_level_traits_2 traits; Criteria& criteria; /**is_marked() ) { Quality q; Mesh_2::Face_badness badness = is_bad(fit, q); if( badness != Mesh_2::NOT_BAD ) push_in_bad_faces(fit, q); } } } /** Tells if the map of faces to be conformed is empty or not. */ bool is_no_longer_element_to_refine() const { return bad_faces.empty(); } /** Get the next face to conform. */ Face_handle do_get_next_element() { Face_handle fh = bad_faces.front()->second; current_badness = is_bad(bad_faces.front()->first); CGAL_assertion_code(typename Geom_traits::Orientation_2 orientation = tr.geom_traits().orientation_2_object()); CGAL_assertion(orientation(fh->vertex(0)->point(), fh->vertex(1)->point(), fh->vertex(2)->point()) != COLLINEAR ); return fh; } /** Pop the first face of the map. */ void do_pop_next_element() { bad_faces.pop_front(); } /** Returns the circumcenter of the face. */ Point get_refinement_point(const Face_handle& f) const { return tr.circumcenter(f); } /** Do nothing */ void do_before_conflicts(const Face_handle&, const Point&) { previous.set_imperative_refinement(current_badness == Mesh_2::IMPERATIVELY_BAD); } /** Do nothing */ std::pair do_test_point_conflict_from_superior(const Point&, Zone&) { return std::make_pair(true, true); } /** Do nothing */ std::pair do_private_test_point_conflict(const Point&, Zone& ) const { return std::make_pair(true, true); } /** Remove the conflicting faces from the bad faces map. */ void do_before_insertion(const Face_handle& fh, const Point&, Zone& zone) { /** @todo Perhaps this function is useless. */ for(typename Zone::Faces_iterator fh_it = zone.faces.begin(); fh_it != zone.faces.end(); ++fh_it) { if(*fh_it != fh && (*fh_it)->is_marked() ) remove_bad_face(*fh_it); (*fh_it)->set_marked(false); } } /** Do nothing. */ void do_after_no_insertion(const Face_handle&, const Point&, Zone&) { } /** Restore markers in the star of \c v. */ void do_after_insertion(const Vertex_handle& v) { typename Tr::Face_circulator fc = tr.incident_faces(v), fcbegin(fc); do { fc->set_marked(true); } while (++fc != fcbegin); compute_new_bad_faces(v); } private: /** \name AUXILIARY FUNCTIONS */ /** Auxiliary function called to put a new face in the map. */ void push_in_bad_faces(Face_handle fh, const Quality& q); public: /** \name Functions that maintain the map of bad faces. */ /** * Updates the map with faces incident to the vertex \a v. * @todo The visitor should be made friend, instead of this function to * be public. */ void compute_new_bad_faces(Vertex_handle v); /** Auxiliary function called to erase a face handle from the map. */ void remove_bad_face(Face_handle fh); public: /** \name ACCESS FUNCTION */ Mesh_2::Face_badness is_bad(const Face_handle fh, Quality& q) const; Mesh_2::Face_badness is_bad(const Face_handle fh) const; Mesh_2::Face_badness is_bad(Quality q) const; /** * Adds the sequence [\c begin, \c end[ to the list * of bad faces. * Use this overriden function if the list of bad faces can be * computed easily without testing all faces. * \param Fh_it is an iterator of \c Face_Handle. */ template void set_bad_faces(Fh_it begin, Fh_it end) { bad_faces.clear(); for(Fh_it pfit=begin; pfit!=end; ++pfit) push_in_bad_faces(*pfit, Quality()); } }; // end class Refine_faces_base // --- PRIVATE MEMBER FUNCTIONS --- template inline void Refine_faces_base:: push_in_bad_faces(Face_handle fh, const Quality& q) { #ifdef DEBUG std::cerr << "push_in_bad_faces(" << fh->vertex(0)->point() << "," << fh->vertex(1)->point() << "," << fh->vertex(2)->point() << ")\n"; #endif // DEBUG CGAL_assertion_code(typename Geom_traits::Orientation_2 orientation = tr.geom_traits().orientation_2_object()); CGAL_assertion( orientation(fh->vertex(0)->point(), fh->vertex(1)->point(), fh->vertex(2)->point()) != COLLINEAR ); CGAL_assertion(fh->is_marked()); bad_faces.insert(fh, q); } template inline void Refine_faces_base:: remove_bad_face(Face_handle fh) { #ifdef DEBUG std::cerr << "bad_faces.erase(" << fh->vertex(0)->point() << "," << fh->vertex(1)->point() << "," << fh->vertex(2)->point() << ")\n"; #endif // DEBUG bad_faces.erase(fh); } template void Refine_faces_base:: compute_new_bad_faces(Vertex_handle v) { typename Tr::Face_circulator fc = v->incident_faces(), fcbegin(fc); do { if(!tr.is_infinite(fc)) if( fc->is_marked() ) { Quality q; Mesh_2::Face_badness badness = is_bad(fc, q); if( badness != Mesh_2::NOT_BAD ) push_in_bad_faces(fc, q); } fc++; } while(fc!=fcbegin); } template inline Mesh_2::Face_badness Refine_faces_base:: is_bad(const Face_handle f, Quality& q) const { return criteria.is_bad_object()(f, q); } template inline Mesh_2::Face_badness Refine_faces_base:: is_bad(const Face_handle f) const { Quality q; return criteria.is_bad_object()(f, q); } template inline Mesh_2::Face_badness Refine_faces_base:: is_bad(Quality q) const { return criteria.is_bad_object()(q); } namespace details { template struct Refine_faces_types { typedef Mesher_level < Triangulation_mesher_level_traits_2, Self, typename Tr::Face_handle, Previous > Faces_mesher_level; }; // end Refine_faces_types } // end namespace details template > class Refine_faces : public Base, public details::Refine_faces_types, Previous>::Faces_mesher_level { typedef typename Tr::Geom_traits Geom_traits; template struct Pair_get_first: public std::unary_function { typedef typename Pair::first_type result; const result& operator()(const Pair& p) const { return p.first; } }; public: typedef Refine_faces Self; typedef typename details::Refine_faces_types ::Faces_mesher_level Mesher; typedef typename Base::Bad_faces Bad_faces; typedef typename boost::transform_iterator< Pair_get_first, typename Bad_faces::const_iterator> Bad_faces_const_iterator; public: Refine_faces(Tr& t, Criteria& criteria, Previous& previous) : Base(t, criteria, previous), Mesher(previous) { } /** \name DEBUGGING FUNCTIONS */ Bad_faces_const_iterator begin() const { return Bad_faces_const_iterator(this->bad_faces.begin()); } Bad_faces_const_iterator end() const { return Bad_faces_const_iterator(this->bad_faces.end()); } bool check_bad_faces() { CGAL_assertion_code(typename Geom_traits::Orientation_2 orientation = this->tr.geom_traits().orientation_2_object()); for(Bad_faces_const_iterator fit = begin(); fit != end(); ++fit) if( orientation((*fit)->vertex(0)->point(), (*fit)->vertex(1)->point(), (*fit)->vertex(2)->point()) == COLLINEAR ) { std::cerr << "collinear(" << (*fit)->vertex(0)->point() << ", " << (*fit)->vertex(1)->point() << ", " << (*fit)->vertex(2)->point()<< ") == true" << std::endl; std::cerr << "Dump of bad_faces:" << std::endl; this->bad_faces.dump_direct_func(std::cerr); return false; } return true; } }; // end Refine_faces } // end namespace Mesh_2 } // end namespace CGAL #endif // CGAL_MESH_2_REFINE_FACES_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges_visitor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges_vi0000644000175000017500000001076211344301501031144 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges_visitor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_REFINE_EDGES_VISITOR_H #define CGAL_MESH_2_REFINE_EDGES_VISITOR_H #include namespace CGAL { namespace Mesh_2 { /** * This class is the visitor needed when Refine_edges if called from * Refine_faces. * \param Faces_base should be instanciated with Refine_face_base. */ template class Refine_edges_visitor : public ::CGAL::Null_mesh_visitor { public: typedef typename Mesher_base::Triangulation Tr; typedef typename Tr::Edge Edge; typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Point Point; typedef typename Triangulation_mesher_level_traits_2::Zone Zone; typedef typename details::Refine_edges_base_types::Constrained_edge Constrained_edge; private: Mesher_base& mesher_base; Vertex_handle va, vb; bool mark_at_right, mark_at_left; Null_mesh_visitor& null_mesh_visitor; public: Refine_edges_visitor(Mesher_base& mesher_base_, Null_mesh_visitor& null) : mesher_base(mesher_base_), null_mesh_visitor(null) { } Null_mesh_visitor previous_level() const { return null_mesh_visitor; } /** * Store vertex handles and markers at left and right of the edge \c e. */ void before_conflicts(const Edge& e, const Point&) { const Face_handle& fh = e.first; const int edge_index = e.second; va = fh->vertex(Tr::cw (edge_index)); vb = fh->vertex(Tr::ccw(edge_index)); mark_at_right = fh->is_marked(); mark_at_left = fh->neighbor(edge_index)->is_marked(); } void before_insertion(const Edge&, const Point& p, Zone& z) { mesher_base.do_before_insertion(Face_handle(), p, z); } /** Restore markers in the star of \c v. */ void after_insertion(const Vertex_handle& v) { Tr& tr = mesher_base.get_triangulation_ref(); int dummy; // if we put edge_index instead of dummy, Intel C++ does not find // a matching function for is_edge Face_handle fh; tr.is_edge(va, v, fh, dummy); // set fh to the face at the right of [va,v] typename Tr::Face_circulator fc = tr.incident_faces(v, fh), fcbegin(fc); // circulators are counter-clockwise, so we start at the right of // [va,v] do { if( !tr.is_infinite(fc) ) fc->set_marked(mark_at_right); ++fc; } while ( fc->vertex(tr.ccw(fc->index(v))) != vb ); // we are now at the left of [va,vb] do { if( !tr.is_infinite(fc) ) fc->set_marked(mark_at_left); ++fc; } while ( fc != fcbegin ); // then let's update bad faces mesher_base.compute_new_bad_faces(v); CGAL_expensive_assertion(mesher_base.check_bad_faces()); } template void after_no_insertion(E, P, Z) const {} }; // end class Refine_edges_visitor /** * This class is the visitor for Refine_faces. */ template class Refine_edges_visitor_from_faces { public: typedef Refine_edges_visitor Previous_level; private: Previous_level previous; public: Refine_edges_visitor_from_faces(Mesher_base& mesher_base, Null_mesh_visitor& null) : previous(mesher_base, null) { } Previous_level& previous_level() { return previous; } template void before_conflicts(E, P) const {} template void before_insertion(E, P, Z) const {} template void after_insertion(V) const {} template void after_no_insertion(E, P, Z) const {} }; // end class Refine_edges_visitor_from_faces } // end namespace Mesh_2 } // end namespace CGAL #endif // CGAL_MESH_2_REFINE_EDGES_VISITOR_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges_with_clusters.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges_wi0000644000175000017500000002401111344301501031135 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Refine_edges_with_clusters.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_REFINE_EDGES_WITH_CLUSTERS_H #define CGAL_MESH_2_REFINE_EDGES_WITH_CLUSTERS_H #include #include namespace CGAL { namespace Mesh_2 { /** * This class is the base for the first level of Mesh_2: the edge * conforming level. It \e does handle clusters. * To handle clusters, an helping \c Clusters object is used. * * \param Tr is the type of triangulation on which the level acts. * \param Is_locally_conform defines the locally conform criterion: Gabriel * or Delaunay. It defaults to the Garbriel criterion. * \param Container is the type of container. It defaults to a filtered * queue of \c Vertex_handle pair (see \c Filtered_queue_container). */ template < class Tr, class Is_locally_conform = Is_locally_conforming_Gabriel, class Container = typename details::Refine_edges_base_types::Default_container > class Refine_edges_base_with_clusters : public Refine_edges_base { typedef Refine_edges_base Super; typedef typename Tr::Vertex_handle Vertex_handle; typedef typename Tr::Face_handle Face_handle; typedef typename Tr::Edge Edge; typedef typename Tr::Point Point; typedef typename Tr::Geom_traits Geom_traits; typedef typename Geom_traits::FT FT; typedef typename Tr::Finite_edges_iterator Finite_edges_iterator; typedef typename Tr::Face_circulator Face_circulator; typedef typename Triangulation_mesher_level_traits_2::Zone Zone; typedef typename Clusters::Cluster Cluster; typedef typename Clusters::iterator clusters_iterator; /* --- private data --- */ Clusters& clusters; bool va_has_a_cluster, vb_has_a_cluster; bool cluster_splitted; Cluster ca, cb; clusters_iterator ca_it, cb_it; public: /** \name CONSTRUCTORS */ Refine_edges_base_with_clusters(Tr& tr_, Clusters& c_) : Super(tr_), clusters(c_) { } /*\name FUNCTIONS NEEDED BY \c Mesher_level OVERIDDEN BY THIS CLASS. */ Point get_refinement_point(const Edge& edge) { typename Geom_traits::Construct_midpoint_2 midpoint = this->tr.geom_traits().construct_midpoint_2_object(); this->va = edge.first->vertex(Tr::cw (edge.second)); this->vb = edge.first->vertex(Tr::ccw(edge.second)); // std::cerr << "get_refinement_point\n" << this->va->point() << " / " // << this->vb->point() << std::endl; va_has_a_cluster = false; vb_has_a_cluster = false; cluster_splitted = false; // true bellow to remove ca and cb because they will // be restored by update_cluster(...). if( clusters.get_cluster(this->va,this->vb,ca,ca_it) ) { if( clusters.get_cluster(this->vb,this->va,cb,cb_it) ) { // both ends are clusters va_has_a_cluster = true; vb_has_a_cluster = true; return midpoint(this->va->point(), this->vb->point()); } else { // va only is a cluster va_has_a_cluster = true; return split_cluster_point(this->va,this->vb,ca); } } else if( clusters.get_cluster(this->vb,this->va,cb,cb_it) ){ // vb only is a cluster vb_has_a_cluster = true; return split_cluster_point(this->vb,this->va,cb); }else{ // no cluster return midpoint(this->va->point(), this->vb->point()); } }; void do_after_insertion(const Vertex_handle& v) { #ifdef DEBUG std::cerr << "update_clusters" << std::endl; std::cerr << "va_has_a_cluster=" << va_has_a_cluster << std::endl << "vb_has_a_cluster=" << vb_has_a_cluster << std::endl; std::cerr << "clusters.size()=" << clusters.size() << std::endl; #endif // DEBUG Super::do_after_insertion(v); if( va_has_a_cluster ) clusters.update_cluster(ca,ca_it,this->va,this->vb,v,cluster_splitted); if( vb_has_a_cluster ) clusters.update_cluster(cb,cb_it,this->vb,this->va,v,cluster_splitted); #ifdef DEBUG std::cerr << "clusters.size() after update_cluster=" << clusters.size() << std::endl; #endif // DEBUG } /** * Test if the edges of the boundary are locally conforming. * Push which that are not in the list of edges to be conformed. */ std::pair do_test_point_conflict_from_superior(const Point& p, Zone& z) { bool split_the_face = true; bool remove_the_bad_face = true; for(typename Zone::Edges_iterator eit = z.boundary_edges.begin(); eit != z.boundary_edges.end(); ++eit) { const Face_handle& fh = eit->first; const int& i = eit->second; if(fh->is_constrained(i) && !is_locally_conform(this->tr, fh, i, p)) { const Vertex_handle& v1 = fh->vertex( this->tr.cw (i)); const Vertex_handle& v2 = fh->vertex( this->tr.ccw(i)); split_the_face = false; bool v1_has_a_cluster = clusters.get_cluster(v1,v2,ca,ca_it); bool v2_has_a_cluster = clusters.get_cluster(v2,v1,cb,cb_it); if( ( v1_has_a_cluster && v2_has_a_cluster) || (!v1_has_a_cluster && !v2_has_a_cluster) ) { // two clusters or no cluster add_constrained_edge_to_be_conformed(v1, v2); remove_the_bad_face = false; } else { // only one cluster: c or c2 if(v2_has_a_cluster) ca = cb; // What Shewchuk says: // - If the cluster is not reduced (all segments don't have the same // length as [v1,v2]), then split the edge // - Else, let rmin be the minimum insertion radius introduced by the // potential split, let T be the triangle whose circumcenter // encroaches [v1,v2] and let rg be the length of the shortest edge // of T. If rmin >= rg, then split the edge. if( this->imperatively || !ca.is_reduced() || ca.rmin >= shortest_edge_squared_length(fh) ) { add_constrained_edge_to_be_conformed(v1,v2); remove_the_bad_face = false; } } } }; // after here edges encroached by p are in the list of edges to // be conformed. return std::make_pair(split_the_face, remove_the_bad_face); } private: /** \name Auxiliary functions to handle clusters. */ FT shortest_edge_squared_length(Face_handle f) { typename Geom_traits::Compute_squared_distance_2 squared_distance = this->tr.geom_traits().compute_squared_distance_2_object(); const Point& pa = (f->vertex(0))->point(); const Point& pb = (f->vertex(1))->point(); const Point& pc = (f->vertex(2))->point(); FT a, b, c; a = squared_distance(pb, pc); b = squared_distance(pc, pa); c = squared_distance(pa, pb); return (min(a, min(b, c))); } Point split_cluster_point(Vertex_handle va, Vertex_handle vb, Cluster& c) { typename Geom_traits::Construct_vector_2 vector = this->tr.geom_traits().construct_vector_2_object(); typename Geom_traits::Construct_scaled_vector_2 scaled_vector = this->tr.geom_traits().construct_scaled_vector_2_object(); typename Geom_traits::Compute_squared_distance_2 squared_distance = this->tr.geom_traits().compute_squared_distance_2_object(); typename Geom_traits::Construct_midpoint_2 midpoint = this->tr.geom_traits().construct_midpoint_2_object(); typename Geom_traits::Construct_translated_point_2 translate = this->tr.geom_traits().construct_translated_point_2_object(); typedef typename Geom_traits::FT FT; cluster_splitted = true; const Point& a = va->point(); const Point& b = vb->point(); if( c.is_reduced() ) return midpoint(a, b); else { const Point m = midpoint(a, b); typename Geom_traits::Vector_2 v = vector(a,m); v = scaled_vector(v,CGAL_NTS sqrt(c.minimum_squared_length / squared_distance(a,b))); Point i = translate(a,v), i2(i); do { i = translate(a,v); v = scaled_vector(v,FT(2)); i2 = translate(a,v); } while(squared_distance(a,i2) <= squared_distance(a,m)); if( squared_distance(i,m) > squared_distance(m,i2) ) i = i2; //here i is the best point for splitting return i; } } protected: }; // end class Refine_edges_base_with_clusters template < typename Tr, typename Is_locally_conform = Is_locally_conforming_Gabriel, typename Base = Refine_edges_base_with_clusters > struct Refine_edges_with_clusters : public Base, public details::Refine_edges_types >::Edges_mesher_level { typedef Refine_edges_with_clusters Self; typedef typename details::Refine_edges_types::Edges_mesher_level Mesher; public: Refine_edges_with_clusters(Tr& t, Clusters& c, Null_mesher_level& null_level) : Base(t, c), Mesher(null_level) { } }; // end Refine_edges_with_clusters } // end namespace Mesh_2 } // end namespace CGAL #endif // CGAL_MESH_2_REFINE_EDGES_WITH_CLUSTERS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Face_badness.h0000644000175000017500000000170711344301501030651 0ustar debiandebian// Copyright (c) 2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Mesh_2/Face_badness.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_MESH_2_FACE_BADNESS_H #define CGAL_MESH_2_FACE_BADNESS_H namespace CGAL { namespace Mesh_2 { enum Face_badness { NOT_BAD, BAD, IMPERATIVELY_BAD }; } } #endif // CGAL_MESH_2_FACE_BADNESS_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Line_2_intersec0000644000175000017500000001466411344301500031152 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_LINE_2_LINE_2_INTERSECTION_H #define CGAL_LINE_2_LINE_2_INTERSECTION_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Line_2_Line_2_pair { public: enum Intersection_results {NO, POINT, LINE}; Line_2_Line_2_pair() ; Line_2_Line_2_pair(typename K::Line_2 const *line1, typename K::Line_2 const *line2); ~Line_2_Line_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Line_2 &result) const; protected: typename K::Line_2 const* _line1; typename K::Line_2 const * _line2; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Line_2 &p1, const typename CGAL_WRAP(K)::Line_2 &p2, const K&) { typedef Line_2_Line_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Object intersection(const typename CGAL_WRAP(K)::Line_2 &line1, const typename CGAL_WRAP(K)::Line_2 &line2, const K&) { typedef Line_2_Line_2_pair is_t; is_t linepair(&line1, &line2); switch (linepair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; linepair.intersection(pt); return make_object(pt); } case is_t::LINE: return make_object(line1); } } template bool construct_if_finite(POINT &pt, RT x, RT y, RT w, R &, const Cartesian_tag &) { typename R::Construct_point_2 construct_point; typedef typename R::FT FT; CGAL_kernel_precondition(CGAL_NTS is_finite(x) && CGAL_NTS is_finite(y) && w != RT(0)); FT xw = FT(x)/FT(w); FT yw = FT(y)/FT(w); if (!CGAL_NTS is_finite(xw) || !CGAL_NTS is_finite(yw)) return false; pt = construct_point(xw, yw); return true; } template bool construct_if_finite(POINT &pt, RT x, RT y, RT w, R &, const Homogeneous_tag&) { typename R::Construct_point_2 construct_point; typedef typename R::FT FT; CGAL_kernel_precondition(CGAL_NTS is_finite(x) && CGAL_NTS is_finite(y) && w != RT(0)); FT xw = FT(x)/FT(w); FT yw = FT(y)/FT(w); if (!CGAL_NTS is_finite(xw) || !CGAL_NTS is_finite(yw)) return false; pt = construct_point(x, y, w); return true; } template inline bool construct_if_finite(POINT &pt, RT x, RT y, RT w, const R &r) { typedef typename R::Kernel_tag Tag; Tag tag; return construct_if_finite(pt, x, y, w, r, tag); } template Line_2_Line_2_pair::Line_2_Line_2_pair() { _line1 = 0; _line2 = 0; _known = false; } template Line_2_Line_2_pair::Line_2_Line_2_pair( typename K::Line_2 const *line1, typename K::Line_2 const *line2) { _line1 = line1; _line2 = line2; _known = false; } template typename Line_2_Line_2_pair::Intersection_results Line_2_Line_2_pair::intersection_type() const { typedef typename K::RT RT; if (_known) return _result; RT nom1, nom2, denom; // The non const this pointer is used to cast away const. _known = true; denom = _line1->a()*_line2->b() - _line2->a()*_line1->b(); if (denom == RT(0)) { if (RT(0) == (_line1->a()*_line2->c() - _line2->a()*_line1->c()) && RT(0) == (_line1->b()*_line2->c() - _line2->b()*_line1->c())) _result = LINE; else _result = NO; return _result; } nom1 = (_line1->b()*_line2->c() - _line2->b()*_line1->c()); if (!CGAL_NTS is_finite(nom1)) { _result = NO; return _result; } nom2 = (_line2->a()*_line1->c() - _line1->a()*_line2->c()); if (!CGAL_NTS is_finite(nom2)) { _result = NO; return _result; } K dummyR; if (!construct_if_finite(_intersection_point, nom1, nom2, denom, dummyR)){ _result = NO; return _result; } _result = POINT; return _result; } template bool Line_2_Line_2_pair::intersection(typename K::Point_2 &pt) const { if (!_known) intersection_type(); if (_result != POINT) return false; pt = _intersection_point; return true; } template bool Line_2_Line_2_pair::intersection(typename K::Line_2 &l) const { if (!_known) intersection_type(); if (_result != LINE) return false; l = *_line1; return true; } } // namespace CGALi template inline bool do_intersect( const Line_2 &p1, const Line_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template Object intersection(const Line_2 &line1, const Line_2 &line2) { typedef typename K::Intersect_2 Intersect; return Intersect()(line1, line2); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Segment_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Segment_2_i0000644000175000017500000000224511344301501031150 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Segment_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_access_value_adaptor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_access_value_ad0000644000175000017500000000242111344301500031343 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Random_access_value_adaptor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #include ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/basic_constructions_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/basic_constructions_3.0000644000175000017500000000237511344301500031330 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/basic_constructions_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_BASIC_CONSTRUCTIONS_3_H #define CGAL_BASIC_CONSTRUCTIONS_3_H // Only kept for backward compatibility. #endif // CGAL_BASIC_CONSTRUCTIONS_3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_naive_point_location.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_naive_point_locatio0000644000175000017500000001120411344301500031422 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_naive_point_location.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan // Efi Fogel #ifndef CGAL_PM_NAIVE_POINT_LOCATION_H #define CGAL_PM_NAIVE_POINT_LOCATION_H #include #include CGAL_BEGIN_NAMESPACE template class Pm_naive_point_location : public Pm_point_location_base { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; typedef Pm_point_location_base Base; typedef Pm_naive_point_location Self; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Face_const_handle Face_const_handle; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Planar_map::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Halfedge Halfedge; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Traits::Point Point; typedef typename Traits::X_curve X_curve; typedef Pm_bounding_box_base Bounding_box; typedef typename Base::Halfedge_handle_iterator Halfedge_handle_iterator; typedef typename Base::Token Token; public: // Constructors Pm_naive_point_location() : Pm_point_location_base(), pm(0), traits(0) {} Pm_naive_point_location(Planar_map * _pm,Traits_wrap * _traits) : Pm_point_location_base(), traits(_traits), pm(_pm) {} inline void init(Planar_map & pmp, const Traits & tr) { CGAL_precondition_msg(pm == NULL, "Point location instance should be uninitialized " "(Do not use the same instance for more than one map)."); pm = &pmp; traits = (Traits_wrap*)(&tr); } inline void insert(Halfedge_handle, const X_curve &) {} Halfedge_const_handle locate(const Point & p, Locate_type & lt) const; Halfedge_handle locate(const Point & p, Locate_type & lt); Halfedge_const_handle vertical_ray_shoot(const Point & p, Locate_type & lt, bool up) const; Halfedge_handle vertical_ray_shoot(const Point & p, Locate_type & lt, bool up); inline void split_edge(const X_curve &, Halfedge_handle, Halfedge_handle, const X_curve &, const X_curve &) {} inline void merge_edge(const X_curve &, const X_curve &, Halfedge_handle, const X_curve &) {} inline void remove_edge(Halfedge_handle) {} inline void remove_edge(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &) {}; inline void clear() {} inline void update(const Halfedge_handle_iterator &, const Halfedge_handle_iterator &, const Token & token) { token.rebuild_bounding_box(this); } public: inline const Bounding_box * get_bounding_box() const {return pm->get_bounding_box();} inline const Traits * get_traits() const {return traits;} protected: Halfedge_const_handle find_lowest(Vertex_const_handle v, bool highest) const; #ifdef CGAL_PM_DEBUG void debug(){} #endif protected: typedef const Self * const_Self_ptr; protected: Planar_map * pm; const Traits_wrap * traits; }; CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif #endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_selected_extreme_points_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_selected_extreme_po0000644000175000017500000001711311344301500031437 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_selected_extreme_points_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_SELECTED_EXTREME_POINTS_2_H #define CGAL_CH_SELECTED_EXTREME_POINTS_2_H #include #include CGAL_BEGIN_NAMESPACE // traverses the range [|first|,|last|). After execution, the value of |n| is // an iterator in the range such that |*n| $\ge_{\rm yx}$ |*it| for // all iterators |it| in the range. Similarly, for |s|, |w|, and |e| // the inequations |*s| $\le_{\rm yx}$ |*it|, |*w| $\le_{\rm xy}$ |*it|, // and |*e| $\ge_{\rm yx}$ |*it| hold respectively for all iterators // |it| in the range. // {\sc traits}: uses |Traits::Less_xy_2| and |Traits::Less_yx_2|. template void ch_nswe_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, ForwardIterator& s, ForwardIterator& w, ForwardIterator& e, const Traits& ch_traits); template inline void ch_nswe_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, ForwardIterator& s, ForwardIterator& w, ForwardIterator& e) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_nswe_point(first, last, n, s, w, e, Kernel()); } // traverses the range [|first|,|last|). After execution, the value of |n| is // an iterator in the range such that |*n| $\ge_{\rm yx}$ |*it| for // all iterators |it| in the range. Similarly, for |s| the inequation // |*s| $\le_{\rm yx}$ |*it| holds for all iterators |it| in the range. // {\sc traits}: uses function object type |Traits::Less_yx_2|. template void ch_ns_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, ForwardIterator& s, const Traits& ch_traits ); template inline void ch_ns_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, ForwardIterator& s) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_ns_point(first, last, n, s, Kernel()); } // traverses the range [|first|,|last|). After execution, the value of |w| is // an iterator in the range such that |*w| $\le_{\rm xy}$ |*it| for // all iterators |it| in the range. Similarly, for |e| the inequation // |*e| $\ge_{\rm yx}$ |*it| holds for all iterators |it| in the range. // {\sc traits}: uses function object type |Traits::Less_xy_2|. template void ch_we_point( ForwardIterator first, ForwardIterator last, ForwardIterator& w, ForwardIterator& e, const Traits& ch_traits ); template inline void ch_we_point( ForwardIterator first, ForwardIterator last, ForwardIterator& w, ForwardIterator& e) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_we_point(first, last, w, e, Kernel()); } // traverses the range [|first|,|last|). After execution, the value of |n| is // an iterator in the range such that |*n| $\ge_{\rm yx}$ |*it| for // all iterators |it| in the range. // {\sc traits}: uses |Traits::Less_yx_2|. template void ch_n_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, const Traits& ch_traits ); template inline void ch_n_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_n_point(first, last, n, Kernel()); } // traverses the range [|first|,|last|). After execution, the value of |s| is // an iterator in the range such that |*s| $\le_{\rm yx}$ |*it| for // all iterators |it| in the range. // {\sc traits}: uses |Traits::Less_yx_2|. template void ch_s_point( ForwardIterator first, ForwardIterator last, ForwardIterator& s, const Traits& ch_traits ); template inline void ch_s_point( ForwardIterator first, ForwardIterator last, ForwardIterator& s) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_s_point(first, last, s, Kernel()); } // traverses the range [|first|,|last|). After execution, the value of |e| is // an iterator in the range such that |*e| $\ge_{\rm yx}$ |*it| for // for all iterators |it| in the range. // {\sc traits}: uses |Traits::Less_xy_2|. template void ch_e_point( ForwardIterator first, ForwardIterator last, ForwardIterator& e, const Traits& ch_traits ); template inline void ch_e_point( ForwardIterator first, ForwardIterator last, ForwardIterator& e) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_e_point(first, last, e, Kernel()); } // traverses the range [|first|,|last|). After execution, the value of |w| is // an iterator in the range such that |*w| $\le_{\rm yx}$ |*it| for // for all iterators |it| in the range. // {\sc traits}: uses |Traits::Less_yx_2|. template void ch_w_point( ForwardIterator first, ForwardIterator last, ForwardIterator& w, const Traits& ch_traits ); template inline void ch_w_point( ForwardIterator first, ForwardIterator last, ForwardIterator& w) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; ch_w_point(first, last, w, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_SELECTED_EXTREME_POINTS_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Line_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Line_2_intersect0000644000175000017500000001342711344301500031176 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Line_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_RAY_2_LINE_2_INTERSECTION_H #define CGAL_RAY_2_LINE_2_INTERSECTION_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Ray_2_Line_2_pair { public: enum Intersection_results {NO, POINT, RAY}; Ray_2_Line_2_pair() ; Ray_2_Line_2_pair(typename K::Ray_2 const *ray, typename K::Line_2 const *line); ~Ray_2_Line_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Ray_2 &result) const; protected: typename K::Ray_2 const * _ray; typename K::Line_2 const * _line; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Ray_2 &p1, const typename CGAL_WRAP(K)::Line_2 &p2) { typedef Ray_2_Line_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Object intersection(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { typedef Ray_2_Line_2_pair is_t; is_t ispair(&ray, &line); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::RAY: { return make_object(ray); } } } template inline Object intersection(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { return CGALi::intersection(ray, line, k); } template class Line_2_Ray_2_pair: public Ray_2_Line_2_pair { public: Line_2_Ray_2_pair(typename K::Line_2 const *line, typename K::Ray_2 const *ray) : Ray_2_Line_2_pair(ray, line) {} }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Line_2 &p1, const typename CGAL_WRAP(K)::Ray_2 &p2, const K& k) { typedef Line_2_Ray_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Ray_2_Line_2_pair::Ray_2_Line_2_pair() { _ray = 0; _line = 0; _known = false; } template Ray_2_Line_2_pair::Ray_2_Line_2_pair( typename K::Ray_2 const *ray, typename K::Line_2 const *line) { _ray = ray; _line = line; _known = false; } template typename Ray_2_Line_2_pair::Intersection_results Ray_2_Line_2_pair::intersection_type() const { if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; const typename K::Line_2 &l1 = _ray->supporting_line(); Line_2_Line_2_pair linepair(&l1, _line); switch ( linepair.intersection_type()) { case Line_2_Line_2_pair::NO: _result = NO; break; case Line_2_Line_2_pair::POINT: linepair.intersection(_intersection_point); _result = (_ray->collinear_has_on(_intersection_point) ) ? POINT : NO; break; case Line_2_Line_2_pair::LINE: _result = RAY; break; } return _result; } template bool Ray_2_Line_2_pair::intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Ray_2_Line_2_pair::intersection(typename K::Ray_2 &result) const { if (!_known) intersection_type(); if (_result != RAY) return false; result = *_ray; return true; } } // namespace CGALi template inline bool do_intersect(const Line_2 &p1, const Ray_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline bool do_intersect(const Ray_2 &p2, const Line_2 &p1) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline Object intersection(const Line_2 &line, const Ray_2 &ray) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, line); } template inline Object intersection(const Ray_2 &ray, const Line_2 &line) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, line); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective_xz_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective0000644000175000017500000001153711344301500031472 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_projective_xz_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CONVEX_HULL_PROJECTIVE_XZ_TRAITS_2_H #define CONVEX_HULL_PROJECTIVE_XZ_TRAITS_2_H #include #include #include #include namespace CGAL { template class Less_xy_plane_xz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.x(), p.z(), q.x(), q.z()) == SMALLER; } }; template class Equal_xy_plane_xz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.x(), p.z(), q.x(), q.z()) == EQUAL; } }; template class Less_yx_plane_xz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q) const { return compare_lexicographically_xyC2(p.z(), p.x(), q.z(), q.x()) == SMALLER; } }; template class Left_turn_plane_xz_2 { public: typedef bool result_type; typedef Arity_tag<2> Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return orientationC2(p.x(), p.z(), q.x(), q.z(), r.x(), r.z()) == LEFT_TURN; } }; template class Less_dist_to_line_plane_xz_2 { public: typedef bool result_type; typedef Arity_tag<4> Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { Comparison_result res = cmp_signed_dist_to_lineC2(p.x(), p.z(), q.x(), q.z(), r.x(), r.z(), s.x(), s.z()); if ( res == LARGER ) return false; else if ( res == SMALLER ) return true; else return compare_lexicographically_xyC2(r.x(), r.z(), s.x(), s.z()) == SMALLER; } }; template class Less_rotate_ccw_plane_xz_2 { public: typedef bool result_type; typedef Arity_tag<3> Arity; bool operator()(const Point_3& r, const Point_3& p, const Point_3& q) const { Orientation orient = orientationC2(r.x(), r.z(), p.x(), p.z(), q.x(), q.z()); if ( orient == LEFT_TURN ) return true; else if ( orient == RIGHT_TURN ) return false; else { if (p.x() == r.x() && p.z() == r.z()) return false; if (q.x() == r.x() && q.z() == r.z()) return true; if (p.x() == q.x() && p.z() == q.z()) return false; return collinear_are_ordered_along_lineC2(r.x(), r.z(), q.x(), q.z(), p.x(), p.z()); } } }; template class Convex_hull_projective_xz_traits_2 { public: typedef Point_3 Point_2; typedef Less_xy_plane_xz_2 Less_xy_2; typedef Equal_xy_plane_xz_2 Equal_2; typedef Less_yx_plane_xz_2 Less_yx_2; typedef Left_turn_plane_xz_2 Left_turn_2; typedef Less_rotate_ccw_plane_xz_2 Less_rotate_ccw_2; typedef Less_dist_to_line_plane_xz_2 Less_signed_distance_to_line_2; Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Equal_2 equal_2_object() const { return Equal_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Less_rotate_ccw_2 less_rotate_ccw_2_object() const { return Less_rotate_ccw_2(); } Less_signed_distance_to_line_2 less_signed_distance_to_line_2_object() const { return Less_signed_distance_to_line_2(); } }; } #endif // CONVEX_HULL_PROJECTIVE_XZ_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Gmpq.h0000644000175000017500000002063611344301500026104 0ustar debiandebian// Copyright (c) 2002,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Gmpq.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Sylvain Pion #ifndef CGAL_GMPQ_H #define CGAL_GMPQ_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE class Gmpq_rep { public: mpq_t mpQ; Gmpq_rep() { mpq_init(mpQ); } Gmpq_rep(const mpq_t z) { mpq_init(mpQ); mpq_set(mpQ, z); } Gmpq_rep(const Gmpq_rep & g) { mpq_init(mpQ); mpq_set(mpQ, g.mpQ); } Gmpq_rep & operator= (const Gmpq_rep & g) { if (&g != this) { mpq_clear(mpQ); mpq_set(mpQ, g.mpQ); } return *this; } Gmpq_rep(int si) { mpq_init(mpQ); mpq_set_si(mpQ, si, 1); } Gmpq_rep(long si) { mpq_init(mpQ); mpq_set_si(mpQ, si, 1); } Gmpq_rep(unsigned long ui) { mpq_init(mpQ); mpq_set_ui(mpQ, ui, 1); } Gmpq_rep(const Gmpz& z) { mpq_init(mpQ); mpq_set_z(mpQ, z.mpz()); } Gmpq_rep(unsigned long int ui1, unsigned long int ui2) { mpq_init(mpQ); mpq_set_ui(mpQ, ui1, ui2); mpq_canonicalize(mpQ); } Gmpq_rep(signed long int si, unsigned long int ui) { mpq_init(mpQ); mpq_set_si(mpQ, si, ui); mpq_canonicalize(mpQ); } Gmpq_rep(int num, int den) { mpq_init(mpQ); if(den < 0) { num = -num; den = -den; } mpq_set_si(mpQ, num, den); mpq_canonicalize(mpQ); } Gmpq_rep(const Gmpz& n, const Gmpz& d) { mpq_init(mpQ); mpz_set(mpq_numref(mpQ), n.mpz()); mpz_set(mpq_denref(mpQ), d.mpz()); mpq_canonicalize(mpQ); } Gmpq_rep(double d) { mpq_init(mpQ); mpq_set_d(mpQ, d); } Gmpq_rep(const std::string& str) { mpq_init(mpQ); mpq_set_str(mpQ, str.c_str(), 10); mpq_canonicalize(mpQ); } Gmpq_rep(const std::string& str, int base) { mpq_init(mpQ); mpq_set_str(mpQ, str.c_str(), base); mpq_canonicalize(mpQ); } ~Gmpq_rep() { mpq_clear(mpQ); } }; class Gmpq : public Handle_for { typedef Handle_for Base; public: typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_false Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_true Has_exact_division; typedef Tag_false Has_exact_sqrt; Gmpq() // {} we can't do that since the non-const mpq() is called. : Base(Gmpq_rep()) {} Gmpq(const mpq_t z) : Base(Gmpq_rep(z)) {} Gmpq(int n) : Base(Gmpq_rep(n)) {} Gmpq(long n) : Base(Gmpq_rep(n)) {} Gmpq(unsigned long n) : Base(Gmpq_rep(n)) {} Gmpq(const Gmpz& n) : Base(Gmpq_rep(n)) {} Gmpq(int n, int d) : Base(Gmpq_rep(n, d)) {} Gmpq(signed long n, unsigned long d) : Base(Gmpq_rep(n, d)) {} Gmpq(unsigned long n, unsigned long d) : Base(Gmpq_rep(n, d)) {} Gmpq(const Gmpz& n, const Gmpz& d) : Base(Gmpq_rep(n,d)) {} Gmpq(double d) : Base(Gmpq_rep(d)) {} Gmpq(const std::string& str) : Base(Gmpq_rep(str)) {} Gmpq(const std::string& str, int base) : Base(Gmpq_rep(str, base)) {} Gmpz numerator() const { return Gmpz(mpq_numref(mpq())); } Gmpz denominator() const { return Gmpz(mpq_denref(mpq())); } Gmpq operator-() const; Gmpq& operator+=(const Gmpq &z); Gmpq& operator-=(const Gmpq &z); Gmpq& operator*=(const Gmpq &z); Gmpq& operator/=(const Gmpq &z); double to_double() const; Sign sign() const; const mpq_t & mpq() const { return Ptr()->mpQ; } mpq_t & mpq() { return ptr()->mpQ; } }; inline bool operator==(const Gmpq &a, const Gmpq &b) { return mpq_equal(a.mpq(), b.mpq()); } inline bool operator<(const Gmpq &a, const Gmpq &b) { return mpq_cmp(a.mpq(), b.mpq()) < 0; } inline bool operator<=(const Gmpq &a, const Gmpq &b) { return ! (b < a); } inline bool operator>(const Gmpq &a, const Gmpq &b) { return b < a; } inline bool operator>=(const Gmpq &a, const Gmpq &b) { return ! (a < b); } inline bool operator!=(const Gmpq &a, const Gmpq &b) { return ! (a == b); } // mixed operators. inline bool operator<(const Gmpq &a, int b) { return mpq_cmp_si(a.mpq(), b, 1) < 0; } inline bool operator<(int a, const Gmpq &b) { return mpq_cmp_si(b.mpq(), a, 1) > 0; } inline bool operator==(const Gmpq &a, int b) { return mpq_cmp_si(a.mpq(), b, 1) == 0; } inline bool operator==(int a, const Gmpq &b) { return b == a; } inline bool operator<=(const Gmpq &a, int b) { return ! (b < a); } inline bool operator<=(int a, const Gmpq &b) { return ! (b < a); } inline bool operator>(const Gmpq &a, int b) { return b < a; } inline bool operator>(int a, const Gmpq &b) { return b < a; } inline bool operator>=(const Gmpq &a, int b) { return ! (a < b); } inline bool operator>=(int a, const Gmpq &b) { return ! (a < b); } inline bool operator!=(const Gmpq &a, int b) { return ! (a == b); } inline bool operator!=(int a, const Gmpq &b) { return ! (a == b); } inline Gmpq Gmpq::operator-() const { Gmpq Res; mpq_neg(Res.mpq(), mpq()); return Res; } inline Gmpq operator+(const Gmpq &a, const Gmpq &b) { Gmpq Res; mpq_add(Res.mpq(), a.mpq(), b.mpq()); return Res; } inline Gmpq& Gmpq::operator+=(const Gmpq &z) { *this = *this + z; return *this; } inline Gmpq operator-(const Gmpq &a, const Gmpq &b) { Gmpq Res; mpq_sub(Res.mpq(), a.mpq(), b.mpq()); return Res; } inline Gmpq& Gmpq::operator-=(const Gmpq &z) { *this = *this - z; return *this; } inline Gmpq operator*(const Gmpq &a, const Gmpq &b) { Gmpq Res; mpq_mul(Res.mpq(), a.mpq(), b.mpq()); return Res; } inline Gmpq& Gmpq::operator*=(const Gmpq &z) { *this = *this * z; return *this; } inline Gmpq operator/(const Gmpq &a, const Gmpq &b) { CGAL_precondition(b != 0); Gmpq Res; mpq_div(Res.mpq(), a.mpq(), b.mpq()); return Res; } inline Gmpq& Gmpq::operator/=(const Gmpq &z) { *this = *this / z; return *this; } inline double Gmpq::to_double() const { return mpq_get_d(mpq()); } inline io_Operator io_tag(const Gmpq&) { return io_Operator(); } inline Sign Gmpq::sign() const { return static_cast(mpq_sgn(mpq())); } inline double to_double(const Gmpq &z) { return z.to_double(); } inline Sign sign(const Gmpq &z) { return z.sign(); } inline bool is_valid(const Gmpq &) { return true; } inline bool is_finite(const Gmpq &) { return true; } inline std::ostream& operator<<(std::ostream& os, const Gmpq &z) { os << z.numerator() << "/" << z.denominator(); return os; } inline std::istream& operator>>(std::istream& is, Gmpq &z) { char c; Gmpz n, d; is >> n; is >> c; CGAL_assertion(!is || c == '/'); is >> d; if (is) z = Gmpq(n,d); return is; } inline std::pair to_interval (const Gmpq& z) { mpfr_t x; mpfr_init2 (x, 53); /* Assume IEEE-754 */ mpfr_set_q (x, z.mpq(), GMP_RNDD); double i = mpfr_get_d (x, GMP_RNDD); /* EXACT but can overflow */ mpfr_set_q (x, z.mpq(), GMP_RNDU); double s = mpfr_get_d (x, GMP_RNDU); /* EXACT but can overflow */ mpfr_clear (x); return std::pair(i, s); } template <> struct Rational_traits { typedef Gmpz RT; RT numerator (const Gmpq & r) const { return r.numerator(); } RT denominator (const Gmpq & r) const { return r.denominator(); } Gmpq make_rational (const RT & n, const RT & d) const { return Gmpq(n, d); } }; CGAL_END_NAMESPACE #endif // CGAL_GMPQ_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Parabola_2.h0000644000175000017500000001514011344301500027134 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Parabola_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_PARABOLA_2_H #define CGAL_PARABOLA_2_H #include CGAL_BEGIN_NAMESPACE template < class Gt > class Parabola_2 { public: typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typedef typename Gt::Segment_2 Segment_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::FT FT; // typedef CGAL::Point_2< Cartesian > Point_2; // typedef CGAL::Segment_2< Cartesian > Segment_2; // typedef CGAL::Line_2< Cartesian > Line_2; protected: // static stuff #if defined(__POWERPC__) && \ defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ == 4) // hack to avoid nasty warning for G++ 3.4 on Darwin static FT STEP() { return FT(2); } #else static const FT& STEP() { static FT step_(2); return step_; } #endif inline static FT square(const FT &x) { return x * x; } inline static FT norm2(const Point_2& p) { return square(p.x()) + square(p.y()); } inline static FT distance2(const Point_2& p1, const Point_2& p2) { FT dx = p1.x()-p2.x(); FT dy = p1.y()-p2.y(); return square(dx) + square(dy); } inline static FT distance(const Point_2& p1, const Point_2& p2) { return CGAL::sqrt( distance2(p1, p2) ); } inline static FT distance(const Point_2& p, const Line_2& l) { return ( p.x() * l.a() + p.y() * l.b() + l.c() ) / CGAL::sqrt( square(l.a()) + square(l.b()) ); } // instance stuff Point_2 c; Line_2 l; Point_2 o; inline Point_2 lchain(const FT &t) const { std::vector< Point_2 > p = compute_points(t); if ( right(p[0]) ) return p[1]; return p[0]; } inline Point_2 rchain(const FT &t) const { std::vector< Point_2 > p = compute_points(t); if ( right(p[0]) ) return p[0]; return p[1]; } std::vector< Point_2 > compute_points(const FT &d) const { assert(d >= 0); FT d1 = distance(o, c) + d; FT d2 = distance(o, l) + d; d2 = d1; d1 *= d1; std::vector< Point_2 > p; if ( l.a() == ZERO ) { FT y = d2 * CGAL::sign(l.b()) - l.c() / l.b(); FT C = CGAL::square(y) - FT(2) * c.y() * y + square(c.x()) + square(c.y()) - d1; FT D = square(c.x()) - C; D = CGAL::abs(D); FT x1 = CGAL::sqrt(D) + c.x(); FT x2 = -CGAL::sqrt(D) + c.x(); p.push_back(Point_2(x1, y)); p.push_back(Point_2(x2, y)); return p; } FT A = d2 * CGAL::sqrt( CGAL::square(l.a()) + CGAL::square(l.b()) ) - l.c(); FT B = CGAL::square(c.x()) + CGAL::square(c.y()) - d1; FT alpha = FT(1) + CGAL::square(l.b() / l.a()); FT beta = A * l.b() / CGAL::square(l.a()) + c.y() - c.x() * l.b() / l.a(); FT gamma = CGAL::square(A / l.a()) + B - FT(2) * c.x() * A / l.a(); FT D = CGAL::square(beta) - alpha * gamma; D = CGAL::abs(D); FT y1 = (beta + CGAL::sqrt(D)) / alpha; FT y2 = (beta - CGAL::sqrt(D)) / alpha; FT x1 = (A - l.b() * y1) / l.a(); FT x2 = (A - l.b() * y2) / l.a(); p.push_back(Point_2(x1, y1)); p.push_back(Point_2(x2, y2)); return p; } bool right(const Point_2& p) const { return CGAL::is_positive( det3x3_by_formula(c.x(), c.y(), FT(1), o.x(), o.y(), FT(1), p.x(), p.y(), FT(1)) ); } inline Point_2 midpoint(const Point_2& p1, const Point_2& p2) const { FT t1 = t(p1); FT t2 = t(p2); FT midt = (t1+t2)/2; return f(midt); } inline Point_2 f(FT t) const { if ( CGAL::is_negative(t) ) return rchain(-t); return lchain(t); } inline FT t(const Point_2 &p) const { FT tt = distance(p, c) - distance(c, o); if ( right(p) ) return -tt; return tt; } void compute_origin() { FT d = (l.a() * c.x() + l.b() * c.y() + l.c()) / ( FT(2) * ( square(l.a()) + square(l.b()) ) ); o = Point_2(c.x() - l.a() * d, c.y() - l.b() * d); } public: Parabola_2() {} template Parabola_2(const ApolloniusSite &p, const Line_2 &l1) { this->c = p.point(); FT d_a = CGAL::to_double(l1.a()); FT d_b = CGAL::to_double(l1.b()); FT len = CGAL::sqrt(CGAL::square(d_a) + CGAL::square(d_b)); FT r = p.weight() * len; this->l = Line_2(-l1.a(), -l1.b(), -l1.c() + r); compute_origin(); } Parabola_2(const Point_2 &p, const Line_2 &line) { this->c = p; if ( line.has_on_positive_side(p) ) { this->l = line; } else { this->l = line.opposite(); } compute_origin(); } Oriented_side side_of_parabola(const Point_2& p) const { Point_2 q(CGAL::to_double(p.x()), CGAL::to_double(p.y())); FT d = distance(q, c) - fabs(distance(q, l)); if ( d < 0 ) return ON_NEGATIVE_SIDE; if ( d > 0 ) return ON_POSITIVE_SIDE; return ON_ORIENTED_BOUNDARY; } inline Line_2 line() const { return l; } inline Point_2 center() const { return c; } template< class Stream > void draw(Stream& W) const { std::vector< Point_2 > p; std::vector< Point_2 > pleft, pright; pleft.push_back(o); pright.push_back(o); for (int i = 1; i <= 100; i++) { p = compute_points(i * i * STEP()); W << p[0]; W << p[1]; if ( p.size() > 0 ) { if ( right(p[0]) ) { pright.push_back(p[0]); pleft.push_back(p[1]); } else { pright.push_back(p[1]); pleft.push_back(p[0]); } } } for (unsigned int i = 0; i < pleft.size() - 1; i++) { W << Segment_2(pleft[i], pleft[i+1]); } for (unsigned int i = 0; i < pright.size() - 1; i++) { W << Segment_2(pright[i], pright[i+1]); } W << o; } }; template< class Stream, class Gt > inline Stream& operator<<(Stream& s, const Parabola_2 &P) { P.draw(s); return s; } CGAL_END_NAMESPACE #endif // CGAL_PARABOLA_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_annulus_d.h0000644000175000017500000006220111344301500027765 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_annulus_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_MIN_ANNULUS_D_H #define CGAL_MIN_ANNULUS_D_H // includes // -------- #ifndef CGAL_OPTIMISATION_BASIC_H # include #endif #ifndef CGAL_FUNCTION_OBJECTS_H # include #endif #ifndef CGAL_IDENTITY_H # include #endif #ifndef CGAL_FUNCTION_OBJECTS_ACCESS_BY_INDEX_H # include #endif #ifndef CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H # include #endif #ifndef CGAL_QP_SOLVER_H # include #endif #ifndef CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H # include #endif #ifndef CGAL_PARTIAL_EXACT_PRICING_H # include #endif #ifndef CGAL_PARTIAL_FILTERED_PRICING_H # include #endif #ifndef CGAL_PROTECT_VECTOR # include # define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_PROTECT_IOSTREAM # include # define CGAL_PROTECT_IOSTREAM #endif #ifndef CGAL_PROTECT_FUNCTIONAL_H # include # define CGAL_PROTECT_FUNCTIONAL_H #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_annulus_d; template < class ET_, class NT_, class Point, class PointIterator, class Access_coord, class Access_dim > struct LP_rep_min_annulus_d; template < class NT > struct LP_rep_row_of_a { typedef std::vector argument_type; typedef typename argument_type::const_iterator result_type; result_type operator ( ) ( const argument_type& v) const { return v.begin(); } }; // Class interfaces // ================ template < class Traits_ > class Min_annulus_d { public: // self typedef Traits_ Traits; typedef Min_annulus_d Self; // types from the traits class typedef typename Traits::Point_d Point; typedef typename Traits::Rep_tag Rep_tag; typedef typename Traits::RT RT; typedef typename Traits::FT FT; typedef typename Traits::Access_dimension_d Access_dimension_d; typedef typename Traits::Access_coordinates_begin_d Access_coordinates_begin_d; typedef typename Traits::Construct_point_d Construct_point_d; typedef typename Traits::ET ET; typedef typename Traits::NT NT; private: // LP solver typedef CGAL::LP_rep_min_annulus_d< ET, NT, Point, typename std::vector::const_iterator, Access_coordinates_begin_d, Access_dimension_d > LP_rep; typedef CGAL::QP_solver< LP_rep > Solver; typedef typename Solver::Pricing_strategy Pricing_strategy; // types from the QP solver typedef typename Solver::Basic_variable_index_iterator Basic_variable_index_iterator; // private types typedef std::vector Point_vector; typedef std::vector ET_vector; typedef CGAL::Access_by_index::const_iterator> Point_by_index; typedef std::binder2nd< std::divides > Divide; typedef std::vector Index_vector; typedef std::vector NT_vector; typedef std::vector NT_matrix; public: // public types typedef typename Point_vector::const_iterator Point_iterator; typedef CGAL::Join_random_access_iterator_1< Basic_variable_index_iterator, CGAL::Unary_compose_1 > Support_point_iterator; typedef typename Index_vector::const_iterator IVCI; typedef CGAL::Join_random_access_iterator_1< IVCI, Point_by_index > Inner_support_point_iterator; typedef CGAL::Join_random_access_iterator_1< IVCI, Point_by_index > Outer_support_point_iterator; typedef typename ET_vector::const_iterator Coordinate_iterator; // creation Min_annulus_d( const Traits& traits = Traits(), int verbose = 0, std::ostream& stream = std::cout) : tco( traits), d( -1), solver( verbose, stream) { set_pricing_strategy( NT()); } template < class InputIterator > Min_annulus_d( InputIterator first, InputIterator last, const Traits& traits = Traits(), int verbose = 0, std::ostream& stream = std::cout) : tco( traits), solver( verbose, stream) { set_pricing_strategy( NT()); set( first, last); } // access to point set int ambient_dimension( ) const { return d; } int number_of_points( ) const { return points.size(); } Point_iterator points_begin( ) const { return points.begin(); } Point_iterator points_end ( ) const { return points.end (); } // access to support points int number_of_support_points( ) const { return number_of_points() < 2 ? number_of_points() : solver.number_of_basic_variables(); } Support_point_iterator support_points_begin() const { return Support_point_iterator( solver.basic_variables_index_begin(), CGAL::compose1_1( Point_by_index( points.begin()), std::bind2nd( std::divides(), 2)));} Support_point_iterator support_points_end() const { return Support_point_iterator( number_of_points() < 2 ? solver.basic_variables_index_begin() : solver.basic_variables_index_end(), CGAL::compose1_1( Point_by_index( points.begin()), std::bind2nd( std::divides(), 2)));} int number_of_inner_support_points() const { return inner_indices.size();} int number_of_outer_support_points() const { return outer_indices.size();} Inner_support_point_iterator inner_support_points_begin() const { return Inner_support_point_iterator( inner_indices.begin(), Point_by_index( points.begin())); } Inner_support_point_iterator inner_support_points_end() const { return Inner_support_point_iterator( inner_indices.end(), Point_by_index( points.begin())); } Outer_support_point_iterator outer_support_points_begin() const { return Outer_support_point_iterator( outer_indices.begin(), Point_by_index( points.begin())); } Outer_support_point_iterator outer_support_points_end() const { return Outer_support_point_iterator( outer_indices.end(), Point_by_index( points.begin())); } // access to center (rational representation) Coordinate_iterator center_coordinates_begin( ) const { return center_coords.begin(); } Coordinate_iterator center_coordinates_end ( ) const { return center_coords.end (); } // access to squared radii (rational representation) ET squared_inner_radius_numerator( ) const { return sqr_i_rad_numer; } ET squared_outer_radius_numerator( ) const { return sqr_o_rad_numer; } ET squared_radii_denominator ( ) const { return sqr_rad_denom; } // access to center and squared radii // NOTE: an implicit conversion from ET to RT must be available! Point center( ) const { CGAL_optimisation_precondition( ! is_empty()); return tco.construct_point_d_object()( ambient_dimension(), center_coordinates_begin(), center_coordinates_end()); } FT squared_inner_radius( ) const { CGAL_optimisation_precondition( ! is_empty()); return FT( squared_inner_radius_numerator()) / FT( squared_radii_denominator()); } FT squared_outer_radius( ) const { CGAL_optimisation_precondition( ! is_empty()); return FT( squared_outer_radius_numerator()) / FT( squared_radii_denominator()); } // predicates CGAL::Bounded_side bounded_side( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); return CGAL::Bounded_side( CGAL_NTS sign( sqr_d - sqr_i_rad_numer) * CGAL_NTS sign( sqr_o_rad_numer - sqr_d)); } bool has_on_bounded_side( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); return ( ( sqr_i_rad_numer < sqr_d) && ( sqr_d < sqr_o_rad_numer)); } bool has_on_boundary( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); return (( sqr_d == sqr_i_rad_numer) || ( sqr_d == sqr_o_rad_numer));} bool has_on_unbounded_side( const Point& p) const { CGAL_optimisation_precondition( is_empty() || tco.access_dimension_d_object()( p) == d); ET sqr_d = sqr_dist( p); return ( ( sqr_d < sqr_i_rad_numer) || ( sqr_o_rad_numer < sqr_d)); } bool is_empty ( ) const { return number_of_points() == 0; } bool is_degenerate( ) const { return ! CGAL_NTS is_positive( sqr_o_rad_numer); } // modifiers template < class InputIterator > void set( InputIterator first, InputIterator last) { if ( points.size() > 0) points.erase( points.begin(), points.end()); std::copy( first, last, std::back_inserter( points)); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension(), "Not all points have the same dimension."); compute_min_annulus(); } void insert( const Point& p) { if ( is_empty()) d = tco.access_dimension_d_object()( p); CGAL_optimisation_precondition( tco.access_dimension_d_object()( p) == d); points.push_back( p); compute_min_annulus(); } template < class InputIterator > void insert( InputIterator first, InputIterator last) { CGAL_optimisation_precondition_code( int old_n = points.size()); points.insert( points.end(), first, last); set_dimension(); CGAL_optimisation_precondition_msg( check_dimension( old_n), "Not all points have the same dimension."); compute_min_annulus(); } void clear( ) { points.erase( points.begin(), points.end()); compute_min_annulus(); } // validity check bool is_valid( bool verbose = false, int level = 0) const; // traits class access const Traits& traits( ) const { return tco; } private: Traits tco; // traits class object Point_vector points; // input points int d; // dimension of input points ET_vector center_coords; // center of small.encl.annulus ET sqr_i_rad_numer; // squared inner radius of ET sqr_o_rad_numer; // ---"--- outer ----"---- ET sqr_rad_denom; // smallest enclosing annulus Solver solver; // linear programming solver Index_vector inner_indices; Index_vector outer_indices; NT_matrix a_matrix; // matrix `A' of dual LP NT_vector b_vector; // vector `b' of dual LP NT_vector c_vector; // vector `c' of dual LP typename Solver::Pricing_strategy* // pricing strategy strategyP; // of the QP solver // squared distance to center ET sqr_dist( const Point& p) const { return std::inner_product( center_coords.begin(), center_coords.end()-1, tco.access_coordinates_begin_d_object()( p), ET( 0), std::plus(), CGAL::compose1_2( CGAL::compose2_1( std::multiplies(), CGAL::identity(), CGAL::identity()), CGAL::compose2_2( std::minus(), CGAL::identity(), std::bind2nd( std::multiplies(), center_coords.back())))); } // set dimension of input points void set_dimension( ) { d = ( points.size() == 0 ? -1 : tco.access_dimension_d_object()( points[ 0])); } // check dimension of input points bool check_dimension( unsigned int offset = 0) { return ( std::find_if( points.begin()+offset, points.end(), CGAL::compose1_1( std::bind2nd( std::not_equal_to(), d), tco.access_dimension_d_object())) == points.end()); } // compute smallest enclosing annulus void compute_min_annulus( ) { // clear inner and outer support points inner_indices.erase( inner_indices.begin(), inner_indices.end()); outer_indices.erase( outer_indices.begin(), outer_indices.end()); if ( is_empty()) { center_coords.resize( 1); sqr_i_rad_numer = -ET( 1); sqr_o_rad_numer = -ET( 1); return; } if ( number_of_points() == 1) { inner_indices.push_back( 0); outer_indices.push_back( 0); center_coords.resize( d+1); std::copy( tco.access_coordinates_begin_d_object()( points[ 0]), tco.access_coordinates_begin_d_object()( points[ 0])+d, center_coords.begin()); center_coords[ d] = ET( 1); sqr_i_rad_numer = ET( 0); sqr_o_rad_numer = ET( 0); sqr_rad_denom = ET( 1); return; } // set up and solve dual LP int i, j; NT nt_0 = 0, nt_1 = 1, nt_2 = 2; NT nt_minus_1 = -nt_1, nt_minus_2 = -nt_2; // vector b b_vector.resize( d+2); for ( j = 0; j < d; ++j) b_vector[ j] = nt_0; b_vector[ d ] = nt_1; b_vector[ d+1] = nt_minus_1; // matrix A, vector c a_matrix.erase( a_matrix.begin(), a_matrix.end()); a_matrix.insert( a_matrix.end(), 2*points.size(), NT_vector( d+2)); c_vector.resize( 2*points.size()); for ( i = 0; i < number_of_points(); ++i) { typename Traits::Access_coordinates_begin_d::Coordinate_iterator coord_it = tco.access_coordinates_begin_d_object()( points[i]); NT sum = 0; for ( j = 0; j < d; ++j) { a_matrix[ 2*i ][ j] = nt_2*coord_it[ j]; a_matrix[ 2*i+1][ j] = nt_minus_2*coord_it[ j]; sum += NT( coord_it[ j])*NT( coord_it[ j]); } a_matrix[ 2*i ][ d ] = nt_1; a_matrix[ 2*i+1][ d ] = nt_0; a_matrix[ 2*i ][ d+1] = nt_0; a_matrix[ 2*i+1][ d+1] = nt_minus_1; c_vector[ 2*i ] = sum; c_vector[ 2*i+1] = -sum; } typedef typename LP_rep::A_iterator A_it; typedef typename LP_rep::D_iterator D_it; solver.set( 2*points.size(), d+2, d+2, A_it( a_matrix.begin()), b_vector.begin(), c_vector.begin(), D_it()); solver.init(); solver.solve(); // compute center and squared radius ET sqr_sum = 0; center_coords.resize( ambient_dimension()+1); for ( i = 0; i < d; ++i) { center_coords[ i] = -solver.dual_variable( i); sqr_sum += center_coords[ i] * center_coords[ i]; } center_coords[ d] = solver.variables_common_denominator(); sqr_i_rad_numer = sqr_sum - solver.dual_variable( d )*center_coords[ d]; sqr_o_rad_numer = sqr_sum - solver.dual_variable( d+1)*center_coords[ d]; sqr_rad_denom = center_coords[ d] * center_coords[ d]; // split up support points for ( i = 0; i < solver.number_of_basic_variables(); ++i) { int index = solver.basic_variables_index_begin()[ i]; if ( index % 2 == 0) { inner_indices.push_back( index/2); } else { outer_indices.push_back( index/2); } } } template < class NT > void set_pricing_strategy( NT) { strategyP = new CGAL::Partial_filtered_pricing; solver.set_pricing_strategy( *strategyP); } #ifndef _MSC_VER void set_pricing_strategy( ET) { strategyP = new CGAL::Partial_exact_pricing; solver.set_pricing_strategy( *strategyP); } #endif }; template < class ET_, class NT_, class Point, class PointIterator, class Access_coord, class Access_dim > struct LP_rep_min_annulus_d { typedef ET_ ET; typedef NT_ NT; typedef std::vector NT_vector; typedef std::vector NT_matrix; typedef typename NT_matrix::const_iterator NTMCI; typedef CGAL::Join_random_access_iterator_1< NTMCI, LP_rep_row_of_a > A_iterator; typedef typename NT_vector::const_iterator B_iterator; typedef typename NT_vector::const_iterator C_iterator; typedef A_iterator D_iterator; // dummy typedef CGAL::Tag_true Is_lp; }; // Function declarations // ===================== // I/O operators template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_annulus_d& min_annulus); template < class Traits_ > std::istream& operator >> ( std::istream& is, Min_annulus_d& min_annulus); // ============================================================================ // Class implementation // ==================== // validity check template < class Traits_ > bool Min_annulus_d:: is_valid( bool verbose, int level) const { CGAL_USING_NAMESPACE_STD CGAL::Verbose_ostream verr( verbose); verr << "CGAL::Min_annulus_d::" << endl; verr << "is_valid( true, " << level << "):" << endl; verr << " |P| = " << number_of_points() << ", |S| = " << number_of_support_points() << endl; // containment check (a) // --------------------- verr << " (a) containment check..." << flush; Point_iterator point_it = points_begin(); for ( ; point_it != points_end(); ++point_it) { if ( has_on_unbounded_side( *point_it)) return CGAL::_optimisation_is_valid_fail( verr, "annulus does not contain all points"); } verr << "passed." << endl; // support set check (b) // --------------------- verr << " (b) support set check..." << flush; // all inner support points on inner boundary? Inner_support_point_iterator i_pt_it = inner_support_points_begin(); for ( ; i_pt_it != inner_support_points_end(); ++i_pt_it) { if ( sqr_dist( *i_pt_it) != sqr_i_rad_numer) return CGAL::_optimisation_is_valid_fail( verr, "annulus does not have all inner support points on its inner boundary"); } // all outer support points on outer boundary? Outer_support_point_iterator o_pt_it = outer_support_points_begin(); for ( ; o_pt_it != outer_support_points_end(); ++o_pt_it) { if ( sqr_dist( *o_pt_it) != sqr_o_rad_numer) return CGAL::_optimisation_is_valid_fail( verr, "annulus does not have all outer support points on its outer boundary"); } /* // center strictly in convex hull of support points? typename Solver::Basic_variable_numerator_iterator num_it = solver.basic_variables_numerator_begin(); for ( ; num_it != solver.basic_variables_numerator_end(); ++num_it) { if ( ! ( CGAL_NTS is_positive( *num_it) && *num_it <= solver.variables_common_denominator())) return CGAL::_optimisation_is_valid_fail( verr, "center does not lie strictly in convex hull of support points"); } */ verr << "passed." << endl; verr << " object is valid!" << endl; return( true); } // output operator template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_annulus_d& min_annulus) { CGAL_USING_NAMESPACE_STD typedef typename Min_annulus_d::Point Point; typedef ostream_iterator Os_it; typedef typename Traits_::ET ET; typedef ostream_iterator Et_it; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << "CGAL::Min_annulus_d( |P| = " << min_annulus.number_of_points() << ", |S| = " << min_annulus.number_of_inner_support_points() << '+' << min_annulus.number_of_outer_support_points() << endl; os << " P = {" << endl; os << " "; copy( min_annulus.points_begin(), min_annulus.points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " S_i = {" << endl; os << " "; copy( min_annulus.inner_support_points_begin(), min_annulus.inner_support_points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " S_o = {" << endl; os << " "; copy( min_annulus.outer_support_points_begin(), min_annulus.outer_support_points_end(), Os_it( os, ",\n ")); os << "}" << endl; os << " center = ( "; copy( min_annulus.center_coordinates_begin(), min_annulus.center_coordinates_end(), Et_it( os, " ")); os << ")" << endl; os << " squared inner radius = " << min_annulus.squared_inner_radius_numerator() << " / " << min_annulus.squared_radii_denominator() << endl; os << " squared outer radius = " << min_annulus.squared_outer_radius_numerator() << " / " << min_annulus.squared_radii_denominator() << endl; break; case CGAL::IO::ASCII: copy( min_annulus.points_begin(), min_annulus.points_end(), Os_it( os, "\n")); break; case CGAL::IO::BINARY: copy( min_annulus.points_begin(), min_annulus.points_end(), Os_it( os)); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::get_mode( os) invalid!"); break; } return( os); } // input operator template < class Traits_ > std::istream& operator >> ( std::istream& is, CGAL::Min_annulus_d& min_annulus) { CGAL_USING_NAMESPACE_STD switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: cerr << endl; cerr << "Stream must be in ascii or binary mode" << endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: typedef typename CGAL::Min_annulus_d::Point Point; typedef istream_iterator Is_it; min_annulus.set( Is_it( is), Is_it()); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE #endif // CGAL_MIN_ANNULUS_D_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Aff_transformation_3.h0000644000175000017500000000725211344301500031243 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Aff_transformation_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_AFF_TRANSFORMATION_3_H #define CGAL_AFF_TRANSFORMATION_3_H CGAL_BEGIN_NAMESPACE template class Aff_transformation_3 : public R_::Kernel_base::Aff_transformation_3 { typedef typename R_::RT RT; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Kernel_base::Aff_transformation_3 RAff_transformation_3; public: typedef R_ R; Aff_transformation_3() {} Aff_transformation_3(const RAff_transformation_3& t) : RAff_transformation_3(t) {} Aff_transformation_3(const Identity_transformation& tag) : RAff_transformation_3(tag) {} Aff_transformation_3(const Translation tag, const Vector_3& v) : RAff_transformation_3(tag, v) {} Aff_transformation_3(const Scaling tag, const RT& s, const RT& w= RT(1) ) : RAff_transformation_3(tag, s, w) {} // the general case: Aff_transformation_3( const RT& m11, const RT& m12, const RT& m13, const RT& m14, const RT& m21, const RT& m22, const RT& m23, const RT& m24, const RT& m31, const RT& m32, const RT& m33, const RT& m34, const RT& w= RT(1) ) : RAff_transformation_3(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, w) {} Aff_transformation_3( const RT& m11, const RT& m12, const RT& m13, const RT& m21, const RT& m22, const RT& m23, const RT& m31, const RT& m32, const RT& m33, const RT& w = RT(1) ) : RAff_transformation_3(m11, m12, m13, m21, m22, m23, m31, m32, m33, w) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATION_3 template < class R > std::ostream& operator<<(std::ostream& os, const CGAL::Aff_transformation_3& t) { typedef typename R::Kernel_base::Aff_transformation_3 RAff_transformation_3; return os << static_cast(t); } #endif // CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATION_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_AFF_TRANSFORMATION_3 template < class R > std::istream& operator>>(std::istream& is, CGAL::Aff_transformation_3& t) { typedef typename R::Kernel_base::Aff_transformation_3 RAff_transformation_3; return is >> static_cast(t); } #endif // CGAL_NO_ISTREAM_EXTRACT_AFF_TRANSFORMATION_3 CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATION_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_halfedge_min_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_halfedge_mi0000644000175000017500000000700411344301500031176 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_halfedge_min_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_HALFEDGE_MIN_BASE_H #define CGAL_HALFEDGEDS_HALFEDGE_MIN_BASE_H 1 #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE template < class Refs> struct HalfedgeDS_halfedge_min_base_base { // Base_base will be used to access set_opposite(), which is // made private in the normal halfedge bases. Since halfedges // come always in pairs, managed by the HDS, the set_opposite() // member function is protected from the user. typedef Refs HalfedgeDS; typedef HalfedgeDS_halfedge_min_base_base Base_base; typedef Tag_false Supports_halfedge_prev; typedef Tag_false Supports_halfedge_vertex; typedef Tag_false Supports_halfedge_face; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Face Face; private: Halfedge_handle opp; Halfedge_handle nxt; public: Halfedge_handle opposite() { return opp;} Halfedge_const_handle opposite() const { return opp;} void set_opposite( Halfedge_handle h) { opp = h;} Halfedge_handle next() { return nxt;} Halfedge_const_handle next() const { return nxt;} void set_next( Halfedge_handle h) { nxt = h;} bool is_border() const { return false;} // is always false as long as faces are not supported. }; template < class Refs> class HalfedgeDS_halfedge_min_base : public HalfedgeDS_halfedge_min_base_base< Refs> { public: typedef typename Refs::Halfedge_handle Halfedge_handle; typedef HalfedgeDS_halfedge_min_base Base; typedef HalfedgeDS_halfedge_min_base_base Base_base; private: void set_opposite( Halfedge_handle h) { Base_base::set_opposite(h);} }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_HALFEDGE_MIN_BASE_H // // EOF // ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_edge_iterator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_edge_iterato0000644000175000017500000001530511344301500031332 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_edge_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink, Geert-Jan Giezeman #ifndef CGAL_POLYGON_2_EDGE_ITERATOR_H #define CGAL_POLYGON_2_EDGE_ITERATOR_H #include #include CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Polygon_2_edge_iterator //-----------------------------------------------------------------------// // Ideally the class Polygon_2_edge_iterator would be a nested class of // Polygon_2, but this leads to compiler problems with SGI C++ 4.0 // with the iterator_category() function template class Polygon_2; template class Polygon_2__Segment_ptr { public: typedef Segment_ Segment; Polygon_2__Segment_ptr(Segment const &seg) :m_seg(seg){} Segment* operator->() {return &m_seg;} private: Segment m_seg; }; template class Polygon_2_edge_iterator { public: #ifdef CGAL_CFG_NO_LAZY_INSTANTIATION typedef std::forward_iterator_tag iterator_category; #else typedef std::random_access_iterator_tag iterator_category; #endif typedef typename Traits_::Segment_2 Segment_2; typedef typename Traits_::Segment_2 value_type; typedef Container_ Container; typedef typename Container_::const_iterator const_iterator; typedef typename Container_::difference_type difference_type; typedef Segment_2* pointer; typedef Segment_2& reference; private: const Container_* container; // needed for dereferencing the last edge const_iterator first_vertex; // points to the first vertex of the edge public: Polygon_2_edge_iterator() {} Polygon_2_edge_iterator(const Container_* c, const_iterator f) : container(c), first_vertex(f) {} bool operator==( const Polygon_2_edge_iterator& x) const { return first_vertex == x.first_vertex; } bool operator!=( const Polygon_2_edge_iterator& x) const { return !(first_vertex == x.first_vertex); } Segment_2 operator*() { const_iterator second_vertex = first_vertex; ++second_vertex; if (second_vertex == container->end()) second_vertex = container->begin(); typename Traits_::Construct_segment_2 construct_segment_2 = Traits_().construct_segment_2_object(); return construct_segment_2(*first_vertex, *second_vertex); } Polygon_2__Segment_ptr operator->() {return Polygon_2__Segment_ptr(operator*());} Polygon_2_edge_iterator& operator++() { ++first_vertex; return *this; } Polygon_2_edge_iterator operator++(int) { Polygon_2_edge_iterator tmp = *this; ++*this; return tmp; } Polygon_2_edge_iterator& operator--() { --first_vertex; return *this; } Polygon_2_edge_iterator operator--(int) { Polygon_2_edge_iterator tmp = *this; --*this; return tmp; } #ifndef CGAL_CFG_NO_LAZY_INSTANTIATION // random access iterator requirements Polygon_2_edge_iterator& operator+=(difference_type n) { first_vertex += n; return *this; } Polygon_2_edge_iterator operator+(difference_type n) { return Polygon_2_edge_iterator( container, first_vertex + n); } Polygon_2_edge_iterator& operator-=(difference_type n) { return (*this) -= n; } Polygon_2_edge_iterator operator-(difference_type n) { return Polygon_2_edge_iterator( container, first_vertex - n); } difference_type operator-(const Polygon_2_edge_iterator& a) { return first_vertex - a.first_vertex; } Segment_2 operator[](int n) { return *Polygon_2_edge_iterator( container, first_vertex+n); } bool operator<(const Polygon_2_edge_iterator& a) { return first_vertex < a.first_vertex; } bool operator>(const Polygon_2_edge_iterator& a) { return first_vertex > a.first_vertex; } bool operator<=(const Polygon_2_edge_iterator& a) { return first_vertex <= a.first_vertex; } bool operator>=(const Polygon_2_edge_iterator& a) { return first_vertex >= a.first_vertex; } #endif }; template typename Container_::difference_type distance_type(const Polygon_2_edge_iterator&) { return Container_::difference_type(); } template typename Traits_::Segment_2* value_type(const Polygon_2_edge_iterator&) { return (typename Traits_::Segment_2 *)(0); } //-----------------------------------------------------------------------// // implementation //-----------------------------------------------------------------------// //--------------------------------------------------------------------// // I don't know how to implement the following function: // // template // inline // Polygon_2_edge_iterator // operator+(Container_::difference_type n, // Polygon_2_edge_iterator& a) // { return a+n; } //--------------------------------------------------------------------// CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/N_step_adaptor_derived.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/N_step_adaptor_derived0000644000175000017500000000250511344301500031411 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/N_step_adaptor_derived.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete; use instead. #include ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Voronoi_intersection_2_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Voronoi_intersection_20000644000175000017500000004152011344301501031410 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Voronoi_intersection_2_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_VORONOI_INTERSECTION_2_TRAITS_3_H #define CGAL_VORONOI_INTERSECTION_2_TRAITS_3_H #include #ifndef CGAL_REP_CLASS_DEFINED #error no representation class defined #endif // CGAL_REP_CLASS_DEFINED #if defined CGAL_CARTESIAN_H || defined CGAL_SIMPLE_CARTESIAN_H #include #include #endif #if defined CGAL_HOMOGENEOUS_H || defined CGAL_SIMPLE_HOMOGENEOUS_H #include #include #endif CGAL_BEGIN_NAMESPACE template class Orientation_with_normal_plane_2_3 { public: typedef typename Traits::Point_3 Point; typedef typename Traits::Vector_3 Vector; Orientation_with_normal_plane_2_3(const Vector& _normal, const Traits& _traits) : normal(_normal), traits(_traits) {} Orientation operator()(const Point &p, const Point &q, const Point &r) const { return traits.orientation_3_object()(p,q,q+normal,r); } private: Vector normal; const Traits& traits; }; template < typename K > class Side_of_plane_centered_sphere_2_3 { public: typedef Oriented_side result_type; typedef typename K::Point_3 Point; typedef typename K::Vector_3 Vector; typedef typename K::Plane_3 Plane; typedef typename K::Direction_3 Direction; Side_of_plane_centered_sphere_2_3(const Point& _p, const Vector& _normal) : a(_p), normal(_normal) {} Oriented_side operator()(const Point &p, const Point &q, const Point &r, const Point &t) const { return side_of_plane_centered_sphere(a,normal,p,q,r,t); } Oriented_side operator()(const Point &p, const Point &q, const Point &r) const { return side_of_plane_centered_sphere(a,normal,p,q,r); } Oriented_side operator() (const Point &p, const Point &q) const { return side_of_plane_centered_sphere(a,normal,p,q); } private: Point a; Vector normal; }; template < typename K > class Construct_plane_centered_circumcenter_3 { public: typedef typename K::Point_3 Point; typedef typename K::Vector_3 Vector; Construct_plane_centered_circumcenter_3(const Point& _p, const Vector& _normal) : a(_p), normal(_normal) {} Point operator()(const Point &p, const Point &q, const Point &r) const { return plane_centered_circumcenter_3(a,normal,p,q,r); } private: Point a; Vector normal; }; template < typename K > class Construct_plane_intersected_bisector_3 { public: typedef typename K::Point_3 Point; typedef typename K::Vector_3 Vector; typedef typename K::Line_3 Line; Construct_plane_intersected_bisector_3(const Point& _a, const Vector& _normal) : a(_a), normal(_normal) {} Line operator() (const Point &p, const Point &q) const { return plane_intersected_bisector_3(a, normal, p, q); } private: Point a; Vector normal; }; template < typename K > class Compare_first_projection_3 { //compares the projection of two points onto a second (non-trivial) // vector in the projection plane: public: typedef typename K::Point_3 Point; typedef typename K::Vector_3 Vector; typedef typename K::FT Coord_type; Compare_first_projection_3(const Vector& _normal) : normal(_normal) {} Comparison_result operator() (const Point &p, const Point &q) const { if(normal.x()!=Coord_type(0)) return (Comparison_result) CGAL_NTS sign(Vector(normal.y(),-normal.x(),Coord_type(0))*(p-q)); if(normal.y()!= Coord_type(0)) return (Comparison_result) CGAL_NTS sign(Vector(-normal.y(),normal.x(),Coord_type(0))*(p-q)); CGAL_assertion(normal.z()!= Coord_type(0)); return (Comparison_result) CGAL_NTS sign(Vector(-normal.z(),Coord_type(0),normal.x())*(p-q)); } private: Vector normal; }; template < typename K > class Compare_second_projection_3 { //compares the projection of two points onto a second (non-trivial) // vector in the projection plane: public: typedef typename K::FT Coord_type; typedef typename K::Vector_3 Vector; typedef typename K::Point_3 Point; Compare_second_projection_3(const Vector& _normal) : normal(_normal) {} Comparison_result operator()(const Point &p, const Point &q) const { if(normal.x()!=Coord_type(0)) return (Comparison_result) CGAL_NTS sign(Vector(normal.z(),Coord_type(0),-normal.x())*(p-q)); if(normal.y()!= Coord_type(0)) return (Comparison_result) CGAL_NTS sign(Vector(Coord_type(0),normal.z(),-normal.y())*(p-q)); CGAL_assertion(normal.z()!= Coord_type(0)); return (Comparison_result) CGAL_NTS sign(Vector(Coord_type(0),-normal.z(),normal.y())*(p-q)); } private: Vector normal; }; namespace Interpolation { template < typename K > class Compute_area_3 { //squareroot of compute_squared_area_3: //-> if no sqrt is supported, cast to double public: typedef typename K::FT FT; typedef typename K::Point_3 Point; typedef typename K::Compute_squared_area_3 Compute_squared_area_3; FT operator()(const Point& p, const Point& q, const Point& r) const { FT squared_area = Compute_squared_area_3()(p,q,r); return cast_sqrt_to_double(squared_area, typename Number_type_traits::Has_sqrt()); } private: FT cast_sqrt_to_double(const FT& squared_area, Tag_true) const { return CGAL_NTS sqrt(squared_area); } FT cast_sqrt_to_double(const FT& squared_area, Tag_false) const { double approx = CGAL_NTS to_double(squared_area); return CGAL_NTS sqrt(approx); } }; } // namespace Interpolation template < class K > class Voronoi_intersection_2_traits_3 { public: typedef K Rep; typedef typename Rep::RT Weight; typedef typename Rep::FT FT; //other types needed: typedef typename Rep::Point_3 Point_2; typedef typename Rep::Segment_3 Segment_2; typedef typename Rep::Triangle_3 Triangle_2; typedef typename Rep::Line_3 Line_2; typedef typename Rep::Ray_3 Ray_2; typedef typename Rep::Vector_3 Vector_2; typedef typename Rep::Construct_ray_3 Construct_ray_2; typedef typename Rep::Construct_segment_3 Construct_segment_2; typedef typename Rep::Construct_triangle_3 Construct_triangle_2; typedef typename Rep::Compare_distance_3 Compare_distance_2; //if no sqrt is supported, it casts to double: typedef Interpolation::Compute_area_3 Compute_area_2; //the regular triangulation traits model: //Traits::Point_2 is a 3D point!! typedef Point_2 Weighted_point_2; typedef Point_2 Bare_point; //specific tests: typedef Orientation_with_normal_plane_2_3 Orientation_2; typedef Side_of_plane_centered_sphere_2_3 Power_test_2; typedef Construct_plane_centered_circumcenter_3 Construct_weighted_circumcenter_2; typedef Construct_plane_intersected_bisector_3 Construct_radical_axis_2; typedef Compare_first_projection_3 Compare_x_2; typedef Compare_second_projection_3 Compare_y_2; //for certificated coordinate/neighbor computation: typedef typename Rep::Less_distance_to_point_3 Less_distance_to_point_2; typedef typename Rep::Compute_squared_distance_3 Compute_squared_distance_2; //instantiations and creation of functors: //for the triangulation: Orientation_2 orientation_2_object() const { return Orientation_2(normal, Rep()); } Power_test_2 power_test_2_object() const { return Power_test_2(a,normal); } Compare_distance_2 compare_distance_2_object() const { return Compare_distance_2(); } Compare_x_2 compare_x_2_object() const { return Compare_x_2(normal); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(normal); } //for the coordinate computation: Compute_area_2 compute_area_2_object() const { return Compute_area_2(); } //for constructions of dual: Construct_weighted_circumcenter_2 construct_weighted_circumcenter_2_object() const { return Construct_weighted_circumcenter_2(a,normal); } Construct_radical_axis_2 construct_radical_axis_2_object() const { return Construct_radical_axis_2(a,normal); } Construct_ray_2 construct_ray_2_object() const { return Construct_ray_2(); } Construct_segment_2 construct_segment_2_object() const { return Construct_segment_2(); } Construct_triangle_2 construct_triangle_2_object() const { return Construct_triangle_2(); } //for certification of coordinate/neighbor computation: Less_distance_to_point_2 less_distance_to_point_2_object() const { return Less_distance_to_point_2(); } Compute_squared_distance_2 compute_squared_distance_2_object() const { return Compute_squared_distance_2(); } Voronoi_intersection_2_traits_3(const Point_2& _p = Point_2(), const Vector_2& _normal = NULL_VECTOR) : a(_p), normal(_normal) {} const Vector_2& get_normal() const { return normal; } const Point_2& get_point() const { return a; } private: //defining the intersection plane: Point_2 a; Vector_2 normal; }; //put the homogeneous or cartesian tag template < class Point, class Vector > inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, const Point &t) { typedef typename Point::R::Rep_tag Tag; return side_of_plane_centered_sphere(a,n,p,q,r,t, Tag()); } template < class Point, class Vector > inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r) { typedef typename Point::R::Rep_tag Tag; return side_of_plane_centered_sphere(a,n,p,q,r,Tag()); } template < class Point, class Vector > inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q) { typedef typename Point::R::RT RT; Comparison_result r = Compare()(-CGAL_NTS square(Vector(a,p)*n), -CGAL_NTS square(Vector(a,q)*n)); if(r == LARGER) return ON_NEGATIVE_SIDE; else if (r == SMALLER) return ON_POSITIVE_SIDE; return ON_ORIENTED_BOUNDARY; } template < class Point, class Vector > inline Point plane_centered_circumcenter_3(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r) { typedef typename Point::R::Rep_tag Tag; return plane_centered_circumcenter_3(a,n,p,q,r, Tag()); } template < class Point, class Vector > inline typename Point::R::Line_3 plane_intersected_bisector_3(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q) { typedef typename Point::R::Rep_tag Tag; return plane_intersected_bisector_3(a,n,p,q, Tag()); } ///----------------------------------------------------------- //#if defined CGAL_CARTESIAN_H || defined CGAL_SIMPLE_CARTESIAN_H template < class Point, class Vector> inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, const Point &t, Cartesian_tag) { return side_of_plane_centered_sphereC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), t.x(), t.y(), t.z()); } template < class Point, class Vector > inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, Cartesian_tag) { return side_of_plane_centered_sphereC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } template < class Point, class Vector > inline Point plane_centered_circumcenter_3(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, Cartesian_tag) { typename Point::R::RT x,y,z; plane_centered_circumcenterC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(),x,y,z); return Point(x,y,z); } template < class Point, class Vector> inline typename Point::R::Line_3 plane_intersected_bisector_3(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, Cartesian_tag) { typename Point::R::RT x1,y1,z1, x2,y2,z2; typedef typename Point::R::Line_3 Line; bisector_plane_intersectionC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), x1,y1,z1,x2,y2,z2); return Line(Point(x1,y1,z1), Point(x2,y2,z2)); } //#endif // CGAL_CARTESIAN_H //#if defined CGAL_HOMOGENEOUS_H || defined CGAL_SIMPLE_HOMOGENEOUS_H // The 3 following call the cartesian version over FT, because an // homogeneous special version has not yet been written. template inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, const Point &t, Homogeneous_tag) { return side_of_plane_centered_sphereC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(), t.x(), t.y(), t.z()); } template < class Point, class Vector > inline Oriented_side side_of_plane_centered_sphere(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, Homogeneous_tag) { return side_of_plane_centered_sphereC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z()); } template < class Point, class Vector > inline Point plane_centered_circumcenter_3(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, const Point &r, Homogeneous_tag) { typename Point::R::RT x,y,z; plane_centered_circumcenterC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(), r.x(), r.y(), r.z(),x,y,z); return Point(x,y,z); } template < class Point, class Vector > inline typename Point::R::Line_3 plane_intersected_bisector_3(const Point &a, const Vector& n, /*defines the plane*/ const Point &p, const Point &q, Homogeneous_tag) { typename Point::R::RT x1,y1,z1, x2,y2,z2; typedef typename Point::R::Line_3 Line; bisector_plane_intersectionC3(a.x(), a.y(), a.z(), n.x(), n.y(), n.z(), p.x(), p.y(), p.z(), q.x(), q.y(), q.z(),x1,y1,z1,x2,y2,z2); return Line(Point(x1,y1,z1), Point(x2,y2,z2)); } //#endif // CGAL_HOMOGENEOUS_H CGAL_END_NAMESPACE #endif // CGAL_VORONOI_INTERSECTION_2_TRAITS_3_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Point_3_do_intersect.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Point_3_do_0000644000175000017500000000652711344301501031161 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3_Point_3_do_intersect.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Philippe Guigue #ifndef CGAL_TRIANGLE_3_POINT_3_DO_INTERSECT_H #define CGAL_TRIANGLE_3_POINT_3_DO_INTERSECT_H CGAL_BEGIN_NAMESPACE namespace CGALi { template bool do_intersect(const typename CGAL_WRAP(K)::Triangle_3 &t, const typename CGAL_WRAP(K)::Point_3 &p, const K & k ) { CGAL_kernel_precondition( ! k.is_degenerate_3_object()(t)); typedef typename K::Point_3 Point_3; typename K::Construct_vertex_3 vertex_on = k.construct_vertex_3_object(); typename K::Orientation_3 orientation = k.orientation_3_object(); typename K::Coplanar_orientation_3 coplanar_orientation = k.coplanar_orientation_3_object(); const Point_3 & a = vertex_on(t,0); const Point_3 & b = vertex_on(t,1); const Point_3 & c = vertex_on(t,2); if (orientation(a,b,c,p) != COPLANAR) return false; const Orientation abp = coplanar_orientation(a,b,p); const Orientation bcp = coplanar_orientation(b,c,p); switch ( abp ) { case POSITIVE: return bcp != NEGATIVE && coplanar_orientation(c,a,p) != NEGATIVE ; case NEGATIVE: return bcp != POSITIVE && coplanar_orientation(c,a,p) != POSITIVE ; case COLLINEAR: switch ( bcp ) { case POSITIVE: return coplanar_orientation(c,a,p) != NEGATIVE ; case NEGATIVE: return coplanar_orientation(c,a,p) != POSITIVE ; case COLLINEAR: return true; default: // should not happen. CGAL_kernel_assertion(false); return false; } default: // should not happen. CGAL_kernel_assertion(false); return false; } } template bool do_intersect(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Triangle_3 &t, const K & k ) { return do_intersect(t, p, k); } } // namespace CGALi template inline bool do_intersect(const Point_3 &p, const Triangle_3 &t) { return typename K::Do_intersect_3()(t,p); } template inline bool do_intersect(const Triangle_3 &t, const Point_3 &p) { return typename K::Do_intersect_3()(t,p); } /* template inline bool do_intersect(const Point_3 &p, const Triangle_3 &t, const K & k) { return do_intersect(t,p,k); } */ CGAL_END_NAMESPACE #endif // CGAL_TRIANGLE_3_POINT_3_DO_INTERSECT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/leda_in_CGAL_2.h0000644000175000017500000000674011344301500027602 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/leda_in_CGAL_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef LEDA_IN_CGAL_H #define LEDA_IN_CGAL_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE inline bool left_turn( const leda_point & p, const leda_point & q, const leda_point & r) { return CGAL_LEDA_SCOPE::left_turn(p,q,r); } inline bool right_turn( const leda_point & p, const leda_point & q, const leda_point & r) { return CGAL_LEDA_SCOPE::right_turn(p,q,r); } #ifndef CGAL_CFG_NO_NAMESPACE inline Orientation orientation( const leda_point & p, const leda_point & q, const leda_point & r) { return (Orientation)CGAL_LEDA_SCOPE::orientation(p,q,r); } #endif // CGAL_CFG_NO_NAMESPACE inline bool lexicographically_xy_smaller( const leda_point & p, const leda_point & q) { return ( leda_point::cmp_xy(p,q) < 0 ); } inline bool lexicographically_yx_smaller( const leda_point & p, const leda_point & q) { return ( leda_point::cmp_yx(p,q) < 0 ); } inline bool lexicographically_xy_larger( const leda_point & p, const leda_point & q) { return ( leda_point::cmp_xy(p,q) > 0 ); } inline bool lexicographically_yx_larger( const leda_point & p, const leda_point & q) { return ( leda_point::cmp_yx(p,q) > 0 ); } inline bool collinear_are_ordered_along_line( const leda_point & p, const leda_point & q, const leda_point & r) { return ( (( leda_point::cmp_xy(p,q)<=0 )&&( leda_point::cmp_xy(q,r)<=0 )) ||(( leda_point::cmp_xy(r,q)<=0 )&&( leda_point::cmp_xy(q,p)<=0 )) ); } inline Comparison_result cmp_signed_dist_to_line( const leda_point & p, const leda_point & q, const leda_point & r, const leda_point & s ) { #if ( __LEDA__ >= 360 ) return (Comparison_result)CGAL_LEDA_SCOPE::cmp_signed_dist(p,q,r,s); #else leda_line l(p,q); int r_or = CGAL_LEDA_SCOPE::orientation( l, r ); int s_or = CGAL_LEDA_SCOPE::orientation( l, s ); if ( r_or != s_or ) { return (Comparison_result)( r_or < s_or ); } else { return (Comparison_result)(r_or *( CGAL::sign(l.sqr_dist(r) - l.sqr_dist(s) ))); } #endif // __LEDA__ >= 360 } CGAL_END_NAMESPACE #endif // LEDA_IN_CGAL_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_edge_circulator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_edge_circula0000644000175000017500000001577711344301500031322 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_edge_circulator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink #ifndef CGAL_POLYGON_2_EDGE_CIRCULATOR_H #define CGAL_POLYGON_2_EDGE_CIRCULATOR_H #include #include #include #include CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Polygon_2_const_edge_circulator //-----------------------------------------------------------------------// // Ideally the class Polygon_2_const_edge_circulator would be a nested // class of Polygon_2, but this leads to compiler problems with // SGI C++ 4.0 with the iterator_category() function template class Polygon_2; template class Polygon_2_const_edge_circulator { public: typedef _Traits Traits; typedef typename _Traits::Segment_2 Segment_2; typedef _Container Container; // typedef Bidirectional_const_circulator_from_container<_Container> typedef Polygon_circulator<_Container> Vertex_const_circulator; typedef Segment_2 value_type; typedef typename _Container::difference_type difference_type; typedef typename _Container::size_type size_type; typedef Segment_2* pointer; typedef const Segment_2* const_pointer; typedef Segment_2& reference; typedef const Segment_2& const_reference; typedef Bidirectional_circulator_tag iterator_category; private: Vertex_const_circulator first_vertex; public: Polygon_2_const_edge_circulator() {} Polygon_2_const_edge_circulator(Vertex_const_circulator f) : first_vertex(f) {} bool operator==( CGAL_NULL_TYPE p ) const { CGAL_polygon_assertion( p == 0); return (first_vertex == 0); } bool operator!=( CGAL_NULL_TYPE p ) const { return !(*this == p); } bool operator==( const Polygon_2_const_edge_circulator<_Traits, _Container>& x) const { return first_vertex == x.first_vertex; } bool operator!=( const Polygon_2_const_edge_circulator<_Traits, _Container>& x) const { return !(first_vertex == x.first_vertex); } Segment_2 operator*() const { Vertex_const_circulator second_vertex = first_vertex; ++second_vertex; typename Traits::Construct_segment_2 construct_segment_2 = Traits().construct_segment_2_object(); return construct_segment_2(*first_vertex, *second_vertex); } Polygon_2_const_edge_circulator<_Traits, _Container>& operator++() { ++first_vertex; return *this; } Polygon_2_const_edge_circulator<_Traits, _Container> operator++(int) { Polygon_2_const_edge_circulator<_Traits, _Container> tmp = *this; ++*this; return tmp; } Polygon_2_const_edge_circulator<_Traits, _Container>& operator--() { --first_vertex; return *this; } Polygon_2_const_edge_circulator<_Traits, _Container> operator--(int) { Polygon_2_const_edge_circulator<_Traits, _Container> tmp = *this; --*this; return tmp; } #ifndef CGAL_CFG_NO_LAZY_INSTANTIATION // random access iterator requirements Polygon_2_const_edge_circulator<_Traits, _Container>& operator+=(difference_type n) { first_vertex += n; return *this; } Polygon_2_const_edge_circulator<_Traits, _Container> operator+(difference_type n) { return Polygon_2_const_edge_circulator<_Traits, _Container>( this->container, first_vertex + n); } Polygon_2_const_edge_circulator<_Traits, _Container>& operator-=(difference_type n) { return (*this) -= n; } Polygon_2_const_edge_circulator<_Traits, _Container> operator-(difference_type n) { return Polygon_2_const_edge_circulator<_Traits, _Container>( this->container, first_vertex - n); } difference_type operator-( const Polygon_2_const_edge_circulator<_Traits, _Container>& a) { return first_vertex - a.first_vertex; } Segment_2 operator[](int n) { return *Polygon_2_const_edge_circulator<_Traits, _Container>( this->container, first_vertex+n); } bool operator<( const Polygon_2_const_edge_circulator<_Traits, _Container>& a) { return first_vertex < a.first_vertex; } bool operator>( const Polygon_2_const_edge_circulator<_Traits, _Container>& a) { return first_vertex > a.first_vertex; } bool operator<=( const Polygon_2_const_edge_circulator<_Traits, _Container>& a) { return first_vertex <= a.first_vertex; } bool operator>=( const Polygon_2_const_edge_circulator<_Traits, _Container>& a) { return first_vertex >= a.first_vertex; } #endif }; /* template typename _Container::difference_type distance_type( const Polygon_2_const_edge_circulator<_Traits,_Container>&) { return typename _Container::difference_type(); } template typename _Traits::Segment_2* value_type(const Polygon_2_const_edge_circulator<_Traits,_Container>&) { return (typename _Traits::Segment_2*)(0); } */ //-----------------------------------------------------------------------// // implementation //-----------------------------------------------------------------------// //--------------------------------------------------------------------// // I don't know how to implement the following function: // // template // inline // Polygon_2_const_edge_circulator<_Traits, _Container> // operator+(_Container::difference_type n, // Polygon_2_const_edge_circulator<_Traits, _Container>& a) // { return a+n; } //--------------------------------------------------------------------// CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_3_1.h0000644000175000017500000001126711344301500030350 0ustar debiandebian// Copyright (c) 1997-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_3_1.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTION_3_1_H #define CGAL_INTERSECTION_3_1_H #include #include CGAL_BEGIN_NAMESPACE template Object intersection(const Plane_3 &plane1, const Plane_3&plane2); template inline bool do_intersect(const Plane_3 &plane1, const Plane_3&plane2) { return ! intersection(plane1, plane2).is_empty(); } template Object intersection(const Plane_3 &plane1, const Plane_3&plane2, const Plane_3&plane3); template inline bool do_intersect(const Plane_3 &plane1, const Plane_3&plane2, const Plane_3&plane3) { return ! intersection(plane1, plane2, plane3).is_empty(); } template Object intersection(const Plane_3 &plane, const Line_3&line); template inline Object intersection(const Line_3&line, const Plane_3 &plane) { return intersection(plane,line); } template bool do_intersect(const Plane_3 &p2, const Line_3 &p1); template inline bool do_intersect(const Line_3 &p1, const Plane_3 &p2) { return do_intersect(p2,p1); } template Object intersection(const Plane_3 &plane, const Ray_3&ray); template inline Object intersection(const Ray_3&ray, const Plane_3 &plane) { return intersection(plane,ray); } template bool do_intersect(const Plane_3 &p1, const Ray_3 &p2); template inline bool do_intersect( const Ray_3 &p1, const Plane_3 &p2) { return do_intersect(p2,p1); } template Object intersection(const Plane_3 &plane, const Segment_3&seg); template inline Object intersection(const Segment_3&seg, const Plane_3 &plane) { return intersection(plane,seg); } template bool do_intersect(const Plane_3 &p1, const Segment_3 &p2); template inline bool do_intersect(const Segment_3 &p1, const Plane_3 &p2) { return do_intersect(p2,p1); } template Object intersection(const Line_3 &line, const Bbox_3 &box) ; template inline Object intersection(const Bbox_3 &box, const Line_3 &line) { return intersection(line, box); } template Object intersection(const Ray_3 &ray, const Bbox_3 &box) ; template inline Object intersection(const Bbox_3 &box, const Ray_3 &ray) { return intersection(ray, box); } template Object intersection(const Segment_3 &seg, const Bbox_3 &box) ; template inline Object intersection(const Bbox_3 &box, const Segment_3 &seg) { return intersection(seg, box); } template Object intersection(const Line_3 &line, const Iso_cuboid_3 &box) ; template inline Object intersection(const Iso_cuboid_3 &box, const Line_3 &line) { return intersection(line, box); } template Object intersection(const Ray_3 &ray, const Iso_cuboid_3 &box) ; template inline Object intersection(const Iso_cuboid_3 &box, const Ray_3 &ray) { return intersection(ray, box); } template Object intersection(const Segment_3 &seg, const Iso_cuboid_3 &box) ; template inline Object intersection(const Iso_cuboid_3 &box, const Segment_3 &seg) { return intersection(seg, box); } template Object intersection(const Iso_cuboid_3 &box1, const Iso_cuboid_3 &box2) ; CGAL_END_NAMESPACE #include #endif // CGAL_INTERSECTION_3_1_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_hierarchy_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000003067411344301501031402 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_hierarchy_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_HIERARCHY_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_HIERARCHY_2_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- //-------------------------------------------------------------------- // parameterization of the hierarchy #ifdef CGAL_SVD_HIERARCHY_DEMO const unsigned int svd_hierarchy_2__ratio = 3; const unsigned int svd_hierarchy_2__minsize = 5; #else const unsigned int svd_hierarchy_2__ratio = 30; const unsigned int svd_hierarchy_2__minsize = 20; #endif const unsigned int svd_hierarchy_2__maxlevel = 5; // maximal number of points is 30^5 = 24 millions ! //-------------------------------------------------------------------- //-------------------------------------------------------------------- template < class Gt, class STag = Tag_false, class DS = Triangulation_data_structure_2< Segment_Voronoi_diagram_hierarchy_vertex_base_2< Segment_Voronoi_diagram_vertex_base_2 >, Triangulation_face_base_2 >, class LTag = Tag_false> class Segment_Voronoi_diagram_hierarchy_2 : public Segment_Voronoi_diagram_2 { protected: typedef Segment_Voronoi_diagram_hierarchy_2 Self; public: // PUBLIC TYPES //------------- typedef Segment_Voronoi_diagram_2 Base; typedef typename Base::Geom_traits Geom_traits; typedef typename Geom_traits::Point_2 Point_2; typedef typename Geom_traits::Site_2 Site_2; typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Face_handle Face_handle; typedef typename Base::Edge Edge; typedef typename Base::Vertex_circulator Vertex_circulator; typedef typename Base::Edge_circulator Edge_circulator; typedef typename Base::Face_circulator Face_circulator; typedef typename Base::All_faces_iterator All_faces_iterator; typedef typename Base::Finite_faces_iterator Finite_faces_iterator; typedef typename Base::All_vertices_iterator All_vertices_iterator; typedef typename Base::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Base::All_edges_iterator All_edges_iterator; typedef typename Base::Finite_edges_iterator Finite_edges_iterator; typedef typename Base::Input_sites_iterator Input_sites_iterator; typedef typename Base::Output_sites_iterator Output_sites_iterator; typedef typename Base::Point_handle Point_handle; protected: typedef typename Base::Handle_map Handle_map; typedef typename Base::Point_handle_pair Point_handle_pair; public: typedef typename Base::Point_container Point_container; typedef typename Base::size_type size_type; typedef typename Base::Intersections_tag Intersections_tag; typedef STag Insert_segments_in_hierarchy_tag; typedef STag Segments_in_hierarchy_tag; protected: // LOCAL TYPES //------------ typedef typename Base::Storage_site_2 Storage_site_2; typedef typename Base::List List; typedef typename Base::Face_map Face_map; typedef typename Base::Vertex_triple Vertex_triple; typedef typename Base::Arrangement_type Arrangement_type; typedef typename Base::AT2 AT2; protected: // LOCAL VARIABLES //---------------- static const int UNDEFINED_LEVEL = -1; // here is the stack of triangulations which form the hierarchy Base* hierarchy[svd_hierarchy_2__maxlevel]; Random random; // random number generator public: // CONSTRUCTORS //------------- Segment_Voronoi_diagram_hierarchy_2(const Gt& gt = Gt()); template Segment_Voronoi_diagram_hierarchy_2(Input_iterator first, Input_iterator beyond, const Gt& gt=Gt()) : Base(gt), random((long)0) { init_hierarchy(gt); insert(first, beyond); } Segment_Voronoi_diagram_hierarchy_2(const Self& svd); Self& operator=(const Self& svd); // DESTRUCTOR //----------- ~Segment_Voronoi_diagram_hierarchy_2(); public: // ACCESS METHODS //--------------- const Base& diagram(unsigned int i) const { CGAL_precondition( i < svd_hierarchy_2__maxlevel ); return *hierarchy[i]; } public: // INSERTION METHODS //------------------ template size_type insert(Input_iterator first, Input_iterator beyond) { return insert(first, beyond, Tag_false()); } template size_type insert(Input_iterator first, Input_iterator beyond, Tag_true) { std::vector site_vec; for (Input_iterator it = first; it != beyond; ++it) { site_vec.push_back(Site_2(*it)); } std::random_shuffle(site_vec.begin(), site_vec.end()); return insert(site_vec.begin(), site_vec.end(), Tag_false()); } template size_type insert(Input_iterator first, Input_iterator beyond, Tag_false) { // do it the obvious way: insert them as they come; // one might think though that it might be better to first insert // all end points and then all segments, or a variation of that. size_type n_before = this->number_of_vertices(); for (Input_iterator it = first; it != beyond; ++it) { insert(*it); } size_type n_after = this->number_of_vertices(); return n_after - n_before; } Vertex_handle insert(const Point_2& p) { Point_handle ph = this->register_input_site(p); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(ph); return insert_point(p, ss, UNDEFINED_LEVEL); } Vertex_handle insert(const Point_2& p0, const Point_2& p1) { Point_handle_pair php = this->register_input_site(p0,p1); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(php.first, php.second); return insert_segment(p0, p1, ss, UNDEFINED_LEVEL); } Vertex_handle insert(const Point_2& p, Vertex_handle) { return insert(p); } Vertex_handle insert(const Point_2& p0, const Point_2& p1, Vertex_handle) { return insert(p0, p1); } Vertex_handle insert(const Site_2& t) { // the intended use is to unify the calls to insert(...); // thus the site must be an exact one; CGAL_precondition( t.is_input() ); if ( t.is_segment() ) { Point_handle_pair php = this->register_input_site(t.source(), t.target()); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(php.first, php.second); return insert_segment(t.source(), t.target(), ss, UNDEFINED_LEVEL); } else if ( t.is_point() ) { Point_handle ph = this->register_input_site( t.point() ); Storage_site_2 ss = Storage_site_2::construct_storage_site_2(ph); return insert_point(t.point(), ss, UNDEFINED_LEVEL); } else { CGAL_precondition ( t.is_defined() ); return Vertex_handle(); // to avoid compiler error } } Vertex_handle insert(const Site_2& t, Vertex_handle) { return insert(t); } protected: Vertex_handle insert_point(const Point_2& p, const Storage_site_2& ss, int level) { if ( level == UNDEFINED_LEVEL ) { level = random_level(); } Vertex_handle vertices[svd_hierarchy_2__maxlevel]; insert_point(p, ss, level, vertices); return vertices[0]; } void insert_point(const Point_2& p, const Storage_site_2& ss, int level, Vertex_handle* vertices); void insert_point(const Site_2& t, const Storage_site_2& ss, int low, int high, Vertex_handle vbelow, Vertex_handle* vertices); Vertex_handle insert_segment(const Point_2& p0, const Point_2& p1, const Storage_site_2& ss, int level); Vertex_handle insert_segment_interior(const Site_2& t, const Storage_site_2& ss, const Vertex_handle* vertices0, int level); void insert_segment_in_upper_levels(const Site_2& t, const Storage_site_2& ss, Vertex_handle vbelow, const Vertex_handle* vertices0, int level, Tag_true); void insert_segment_in_upper_levels(const Site_2& t, const Storage_site_2& ss, Vertex_handle vbelow, const Vertex_handle* vertices, int level, Tag_false) {} Vertex_handle insert_segment_on_point(const Storage_site_2& ss, const Vertex_handle& v, int level, Tag_false stag, int which) { return Vertex_handle(); } Vertex_handle insert_segment_on_point(const Storage_site_2& ss, const Vertex_handle& v, int level, Tag_true stag, int which); template Vertex_handle insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, int level, Tag_false itag, Tag) { #if defined(__POWERPC__) && \ defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ == 4) // hack to avoid nasty warning for G++ 3.4 on Darwin static int i; #else static int i = 0; #endif if ( i == 0 ) { i = 1; print_error_message(); } return Vertex_handle(); } Vertex_handle insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, int level, Tag_true itag, Tag_false stag); Vertex_handle insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, int level, Tag_true itag, Tag_true stag); public: // NEAREST NEIGHBOR LOCATION //-------------------------- Vertex_handle nearest_neighbor(const Point_2& p, bool force_point = false) const; Vertex_handle nearest_neighbor(const Point_2& p, Vertex_handle) { return nearest_neighbor(p); } protected: void nearest_neighbor(const Site_2& p, Vertex_handle vnear[svd_hierarchy_2__maxlevel], bool force_point) const; public: // MISCELLANEOUS //-------------- void init_hierarchy(const Geom_traits& gt); void copy(const Segment_Voronoi_diagram_hierarchy_2& svdh); void swap(Segment_Voronoi_diagram_hierarchy_2& svdh); void clear(); public: // VALIDITY CHECK //--------------- bool is_valid(bool verbose = false, int level = 1) const; protected: // LOCAL HELPER METHODS //--------------------- int random_level() { unsigned int l = 0; while ( true ) { if ( random(svd_hierarchy_2__ratio) ) break; ++l; } if (l >= svd_hierarchy_2__maxlevel) l = svd_hierarchy_2__maxlevel - 1; return l; } size_type find_level(Vertex_handle v) const { CGAL_precondition( v != Vertex_handle() ); size_type level = 0; Vertex_handle vertex = v; while ( vertex->up() != Vertex_handle() ) { vertex = vertex->up(); level++; } return level; } Vertex_handle vertex_at_level(const Vertex_handle& v, size_type k) const { CGAL_precondition( k <= svd_hierarchy_2__maxlevel ); size_type level = 0; Vertex_handle v_at_level = v; while ( level < k ) { v_at_level = v_at_level->up(); level++; } return v_at_level; } void print_error_message() const; }; CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_HIERARCHY_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Fuzzy_sphere.h0000644000175000017500000000754311344301500027677 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Fuzzy_sphere.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_FUZZY_SPHERE_H #define CGAL_FUZZY_SPHERE_H #include namespace CGAL { template class Fuzzy_sphere{ public: typedef typename SearchTraits::FT FT; typedef typename SearchTraits::Point_d Point_d; private: Point_d c; FT r; FT eps; unsigned int dim; public: // default constructor Fuzzy_sphere() {} // constructor Fuzzy_sphere(const Point_d& center, FT radius, FT epsilon=FT(0)) : c(center), r(radius), eps(epsilon), dim(c.dimension()) { // avoid problems if eps > r if (eps>r) eps=r; } bool contains(const Point_d& p) const { // test whether the squared distance // between P and c // is at most the squared_radius FT squared_radius = r*r; FT distance=FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d cit = construct_it(c), pit = construct_it(p); for (unsigned int i = 0; (i < dim) && (distance <= squared_radius); ++i, ++cit, ++pit) { distance += ((*cit)-(*pit))*((*cit)-(*pit)); } return (distance < squared_radius); } bool inner_range_intersects(const Kd_tree_rectangle& rectangle) const { // test whether the interior of a sphere // with radius (r-eps) intersects r, i.e. // if the minimal distance of r to c is less than r-eps FT distance = FT(0); FT squared_radius = (r-eps)*(r-eps); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d cit = construct_it(c); for (unsigned int i = 0; (i < dim) && (distance < squared_radius); ++i, ++cit) { if ((*cit) < rectangle.min_coord(i)) distance += (rectangle.min_coord(i)-(*cit))*(rectangle.min_coord(i)-(*cit)); if ((*cit) > rectangle.max_coord(i)) distance += ((*cit)-rectangle.max_coord(i))*((*cit)-rectangle.max_coord(i)); } return (distance < squared_radius); } bool outer_range_contains(const Kd_tree_rectangle& rectangle) const { // test whether the interior of a sphere // with radius (r+eps) is contained by r, i.e. // if the minimal distance of the boundary of r // to c is less than r+eps FT distance=FT(0); FT squared_radius = (r+eps)*(r+eps); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d cit = construct_it(c); for (unsigned int i = 0; (i < dim) && (distance < squared_radius) ; ++i, ++cit) { if ((*cit) <= (rectangle.min_coord(i)+rectangle.max_coord(i))/FT(2)) distance += (rectangle.max_coord(i)-(*cit))*(rectangle.max_coord(i)-(*cit)); else distance += ((*cit)-rectangle.min_coord(i))*((*cit)-rectangle.min_coord(i)); } return (distance < squared_radius); } ~Fuzzy_sphere() {} }; // class Fuzzy_sphere } // namespace CGAL #endif // FUZZY_SPHERE_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_polygon_2_sweep.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_polygon_2_sweep0000644000175000017500000005140611344301500031364 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Random_polygon_2_sweep.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman // : Susan Hert #ifndef CGAL_RANDOM_POLYGON_2_SWEEP_H #define CGAL_RANDOM_POLYGON_2_SWEEP_H #include #include #include #include #include #include /* A polygon is called simple of no edges intersect each other, except consecutive edges, which intersect in their common vertex. The test for simplicity is implemented by means of a sweep line algorithm. The vertical line is swept from left to right. The edges of the polygon that are crossed by the sweep line are stored in a tree from bottom to top. We discern three types of events: - insertion events. When both edges of a polygon vertex extend to the right we need to insert both edges in the tree. We need to search with the vertex to find out between which edges the new edges are to be inserted. - deletion events. When both edges extend to the left of the vertex we need to remove both edges from the tree. We have to check that the vertex lies between the edges above and below the removed edges. - replacement event. In the other case we need to replace the edge that extends to the left by the edge that extends to the right. We need to check that the vertex lies between the edges above and below the current edge. We represent the tree by a std::set. This is not a perfect fit for the operations described above. In particular, the fact that we search with a VERTEX, while the set contains EDGES, is not directly supported. The insertion of edges is also complicated by the fact that we need to insert two edges starting at the same vertex. The order in which they are inserted in the tree does matter, because the edges go in separate directions. Because of this the set needs a special associated comparison function. Every edge has a flag 'is_in_tree', which is true for the edges in the tree but false for the edges when they are inserted. The comparison function treats the latter type of edge as a vertex. Another flag, is_left_to_right, tells which of the two vertices to take. The problem of the coinciding vertices is solved by the convention that the highest edges is always inserted first. The comparison function uses this fact. Vertex indices of the polygon play a double role. The number v can be used to identify vertex v or the edge from vertex v to vertex v+1. */ namespace CGAL { namespace i_generator_polygon { // namespace CGAL::i_generator_polygon is used for internal functions typedef i_polygon::Index_t Index_t; typedef i_polygon::Vertex_index Vertex_index; typedef i_polygon::Vertex_order Vertex_order; template class Vertex_data ; template class Less_segments { Vertex_data *m_vertex_data; bool less_than_in_tree(Vertex_index i, Vertex_index j); public: Less_segments(Vertex_data *vertex_data) : m_vertex_data(vertex_data) {} bool operator()(Vertex_index i, Vertex_index j); }; template class Vertex_data : public i_polygon::Vertex_data_base { public: typedef Less_segments Less_segs; typedef std::set Tree; typedef i_polygon::Edge_data Edge_data; typedef i_polygon::Vertex_data_base Base_class; using Base_class::next; using Base_class::prev; using Base_class::point; using Base_class::index_at_rank; using Base_class::ordered_left_to_right; std::vector edges; Vertex_index conflict1, conflict2; // Intersecting edges. Vertex_data(ForwardIterator begin, ForwardIterator end, const PolygonTraits& pgnt); void init(Tree *tree); void left_and_right_index(Vertex_index &left, Vertex_index &right, Vertex_index edge); Vertex_index left_index(Vertex_index edge) { return edges[edge.as_int()].is_left_to_right ? edge : next(edge); } void sweep(Tree *tree); bool insertion_event(Tree *tree, Vertex_index i, Vertex_index j, Vertex_index k); bool replacement_event(Tree *tree, Vertex_index cur, Vertex_index to_insert); bool deletion_event(Tree *tree, Vertex_index i, Vertex_index j); bool on_right_side(Vertex_index vt, Vertex_index edge, bool above); void find_conflict(Tree *tree, Vertex_index cur_vt, typename Tree::iterator seg1, typename Tree::iterator seg2); void find_conflict_between(Tree *, Vertex_index cur_vt, typename Tree::iterator seg1, typename Tree::iterator seg2); }; } // end of namespace i_generator_polygon // ----- implementation of i_generator_polygon functions. ----- namespace i_generator_polygon { template bool Less_segments:: operator()(Vertex_index i, Vertex_index j) { if (m_vertex_data->edges[j.as_int()].is_in_tree) { return less_than_in_tree(i,j); } else { return !less_than_in_tree(j,i); } } template bool Less_segments:: less_than_in_tree(Vertex_index new_edge, Vertex_index tree_edge) { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "less_than_in_tree" << std::endl; #endif CGAL_polygon_precondition( m_vertex_data->edges[tree_edge.as_int()].is_in_tree); CGAL_polygon_precondition( !m_vertex_data->edges[new_edge.as_int()].is_in_tree); Vertex_index left, mid, right; m_vertex_data->left_and_right_index(left, right, tree_edge); mid = m_vertex_data->left_index(new_edge); if (mid.as_int() == left.as_int()) { return true; } switch (m_vertex_data->orientation_2( m_vertex_data->point(left), m_vertex_data->point(mid), m_vertex_data->point(right))) { case LEFT_TURN: return true; case RIGHT_TURN: return false; case COLLINEAR: break; } assert (m_vertex_data->less_xy_2(m_vertex_data->point(left), m_vertex_data->point(mid))); assert (m_vertex_data->less_xy_2(m_vertex_data->point(mid), m_vertex_data->point(right))); m_vertex_data->is_simple_result = false; Vertex_index mid_succ = m_vertex_data->next(mid); if (mid_succ.as_int() <= min(left.as_int(), right.as_int())) { // // have one of these two situations: // x+k x x+k+1 OR x+k+1 x x+k // left mid right left mid right // and need to swap x and x+1 (so reverse the range (x-1, x+k]) // m_vertex_data->conflict1 = m_vertex_data->prev(mid); } else { // have one of these two situations: // x x+k x+1 OR x+1 x+k x // left mid right left mid right // and need to swap x+1 and x+2 (so reverse range (x, x+k]) m_vertex_data->conflict1 = mid; } Vertex_index left_succ = m_vertex_data->next(left); if (left_succ.as_int() == right.as_int()) { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is left" << std::endl; #endif m_vertex_data->conflict2 = left; } else { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is left" << std::endl; #endif m_vertex_data->conflict2 = right; } return true; } template Vertex_data:: Vertex_data(ForwardIterator begin, ForwardIterator end, const PolygonTraits& pgn_traits) : Base_class(begin, end, pgn_traits) {} template void Vertex_data::init(Tree *tree) { // The initialization cannot be done in the constructor, // otherwise we copy singular valued iterators. edges.insert(edges.end(), this->m_size, Edge_data(tree->end())); } template void Vertex_data:: left_and_right_index(Vertex_index &left, Vertex_index &right, Vertex_index edge) { if (edges[edge.as_int()].is_left_to_right) { left = edge; right = next(edge); } else { right = edge; left = next(edge); } } template bool Vertex_data:: insertion_event(Tree *tree, Vertex_index prev_vt, Vertex_index mid_vt, Vertex_index next_vt) { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "insertion_event" << std::endl; #endif // check which endpoint is above the other bool left_turn; switch(orientation_2(point(prev_vt), point(mid_vt), point(next_vt))) { case LEFT_TURN: left_turn = true; break; case RIGHT_TURN: left_turn = false; break; default: //found conflict prev_vt-seg - mid_vt-seg #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is next_vt" << std::endl; #endif conflict1 = prev_vt; conflict2 = next_vt; return false; } Edge_data &td_prev = edges[prev_vt.as_int()], &td_mid = edges[mid_vt.as_int()]; td_prev.is_in_tree = false; td_prev.is_left_to_right = false; td_mid.is_in_tree = false; td_mid.is_left_to_right = true; // insert the highest chain first std::pair result; if (left_turn) { result = tree->insert(prev_vt); // assert(result.second) td_prev.tree_it = result.first; td_prev.is_in_tree = true; if (!this->is_simple_result) return false; result = tree->insert(mid_vt); // assert(result.second) td_mid.tree_it = result.first; td_mid.is_in_tree = true; if (!this->is_simple_result) return false; } else { result = tree->insert(mid_vt); // assert(result.second) td_mid.tree_it = result.first; td_mid.is_in_tree = true; if (!this->is_simple_result) return false; result = tree->insert(prev_vt); // assert(result.second) td_prev.tree_it = result.first; td_prev.is_in_tree = true; if (!this->is_simple_result) return false; } return true; } template bool Vertex_data:: on_right_side(Vertex_index vt, Vertex_index edge_id, bool above) { Orientation turn = orientation_2(point(edge_id), point(vt), point(next(edge_id))); bool left_turn = edges[edge_id.as_int()].is_left_to_right ? above : !above; if (left_turn) { if (turn != RIGHT_TURN) { return false; } } else { if (turn != LEFT_TURN) { return false; } } return true; } template bool Vertex_data:: replacement_event(Tree *tree, Vertex_index cur_edge, Vertex_index next_edge) { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "replacement_event" << std::endl; #endif // check if continuation point is on the right side of neighbor segments typedef typename Tree::iterator It; Edge_data &td = edges[cur_edge.as_int()]; CGAL_polygon_assertion(td.is_in_tree); It cur_seg = td.tree_it; Vertex_index cur_vt = (td.is_left_to_right) ? next_edge : cur_edge; if (cur_seg != tree->begin()) { It seg_below = cur_seg; --seg_below; if (!on_right_side(cur_vt, *seg_below, true)) { // found conflict cur_seg - seg_below #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is seg_below" << std::endl; #endif conflict1 = *cur_seg; conflict2 = *seg_below; return false; } } It seg_above = cur_seg; ++ seg_above; if (seg_above != tree->end()) { if (!on_right_side(cur_vt, *seg_above, false)) { // found conflict cur_seg - seg_above #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is seg_above" << std::endl; #endif conflict1 = *cur_seg; conflict2 = *seg_above; return false; } } // replace the segment Edge_data &new_td = edges[next_edge.as_int()]; new_td.is_left_to_right = td.is_left_to_right; new_td.is_in_tree = false; tree->erase(cur_seg); td.is_in_tree = false; new_td.tree_it = tree->insert(seg_above, next_edge); new_td.is_in_tree = true; return this->is_simple_result; } template void Vertex_data:: find_conflict(Tree *tree, Vertex_index cur_vt, typename Tree::iterator seg1, typename Tree::iterator seg2) { typedef typename Tree::iterator It; It cur = seg1; ++cur; while (cur != tree->end() && cur != seg2) ++cur; if (cur == seg2) find_conflict_between(tree, cur_vt, seg1, seg2); else find_conflict_between(tree, cur_vt, seg2, seg1); } template void Vertex_data:: find_conflict_between(Tree *, Vertex_index cur_vt, typename Tree::iterator seg1, typename Tree::iterator seg2) { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "find_conflict_between" << std::endl; #endif typedef typename Tree::iterator It; It between_seg = seg1; ++between_seg; if (!on_right_side(cur_vt, *between_seg, false)) { // found conflict between_seg - seg1 #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict1 is seg1" << std::endl; #endif conflict1 = *seg1; conflict2 = *between_seg; } else { // found conflict between_seg - seg2 #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict1 is seg2" << std::endl; #endif conflict1 = *seg2; conflict2 = *between_seg; } } template bool Vertex_data:: deletion_event(Tree *tree, Vertex_index prev_vt, Vertex_index mid_vt) { #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "deletion_event" << std::endl; #endif // check if continuation point is on the right side of neighbor segments typedef typename Tree::iterator It; Edge_data &td_prev = edges[prev_vt.as_int()], &td_mid = edges[mid_vt.as_int()]; It prev_seg = td_prev.tree_it, mid_seg = td_mid.tree_it; Vertex_index cur_vt = (td_prev.is_left_to_right) ? mid_vt : prev_vt; It seg_above = prev_seg; ++seg_above; if (seg_above == mid_seg) { ++seg_above; } else { // mid_seg was not above prev_seg, so prev_seg should be above mid_seg // We check this to see if the edges are really neighbors in the tree. It prev_seg_copy = mid_seg; ++prev_seg_copy; if (prev_seg_copy != prev_seg) { find_conflict(tree, cur_vt, prev_seg, mid_seg); return false; } } // remove the segments tree->erase(prev_seg); td_prev.is_in_tree = false; tree->erase(mid_seg); td_mid.is_in_tree = false; // Check if the vertex that is removed lies between the two tree edges. if (seg_above != tree->end()) { if (!on_right_side(cur_vt, *seg_above, false)) { // found conflicts prev_seg - seg_above and mid_seg - seg_above #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is seg_above" << std::endl; #endif conflict1 = prev_vt; conflict2 = *seg_above; return false; } } if (seg_above != tree->begin()) { --seg_above; // which turns it into seg_below if (!on_right_side(cur_vt, *seg_above, true)) { // found conflicts prev_seg - seg_below and mid_seg - seg_below #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << "conflict2 is --seg_above" << std::endl; #endif conflict1 = prev_vt; conflict2 = *seg_above; return false; } } return true; } template void Vertex_data:: sweep(Tree *tree) { if (this->m_size < 3) return; bool success = true; for (Index_t i=0; i< this->m_size; ++i) { Vertex_index cur = index_at_rank(Vertex_order(i)); Vertex_index prev_vt = prev(cur), next_vt = next(cur); if (ordered_left_to_right(cur, next_vt)) { if (ordered_left_to_right(cur, prev_vt)) success = insertion_event(tree, prev_vt, cur, next_vt); else success = replacement_event(tree, prev_vt, cur); } else { if (ordered_left_to_right(cur, prev_vt)) success = replacement_event(tree, cur, prev_vt); else success = deletion_event(tree, prev_vt, cur); } if (!success) break; } if (!success) this->is_simple_result = false; } } // ----- End of implementation of i_generator_polygon functions. ----- template std::pair check_simple_polygon(Iterator points_begin, Iterator points_end, const PolygonTraits& polygon_traits) { typedef Iterator ForwardIterator; typedef std::set > Tree; i_generator_polygon::Vertex_data vertex_data(points_begin, points_end, polygon_traits); Tree tree(&vertex_data); vertex_data.init(&tree); vertex_data.sweep(&tree); std::pair result; if (vertex_data.is_simple_result) { result.first = result.second = -1; return result; } // swap with vertex_data.conflict1, vertex_data.conflict2; if (vertex_data.conflict1.as_int() < vertex_data.conflict2.as_int()) { result.first = vertex_data.conflict1.as_int(); result.second = vertex_data.conflict2.as_int(); } else { result.first = vertex_data.conflict2.as_int(); result.second = vertex_data.conflict1.as_int(); } return result; } template void make_simple_polygon(Iterator points_begin, Iterator points_end, const PolygonTraits& polygon_traits) { std::pair swap_interval; #if defined(CGAL_POLY_GENERATOR_DEBUG) Iterator it; std::cout << "In make_simple_polygon the points are: " << std::endl; int size = 0; for (it = points_begin; it != points_end; it++, size++) std::cout << *it << " "; std::cout << std::endl; #endif do { swap_interval = check_simple_polygon(points_begin, points_end, polygon_traits); #if defined(CGAL_POLY_GENERATOR_DEBUG) std::cout << swap_interval.first << " " << swap_interval.second << std::endl; CGAL_assertion(swap_interval.first >= -1 && swap_interval.second >= -1 && swap_interval.first < size && swap_interval.second < size); #endif // will break out when a negative nonsense value is selected // or with -1 is given indicating that the polygon was simple. // For positive nonsense values, one needs to know the how // many points there are... if (swap_interval.first <= -1 || swap_interval.second <= -1) break; // swap with vertex_data.conflict1, vertex_data.conflict2; Iterator b = points_begin; std::advance(b, swap_interval.first+1); Iterator e = b; std::advance(e, swap_interval.second-swap_interval.first); std::reverse(b, e); } while (true); } } // end of namespace CGAL #endif // CGAL_RANDOM_POLYGON_2_SWEEP_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_kernel_wrapper_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_kerne0000644000175000017500000000425711344301500031445 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_kernel_wrapper_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_KERNEL_WRAPPER_2_H #define CGAL_APOLLONIUS_GRAPH_KERNEL_WRAPPER_2_H #include #include #include CGAL_BEGIN_NAMESPACE template class Apollonius_graph_kernel_wrapper_2 : public Kernel_base_2 { public: typedef CGAL::Apollonius_site_2 Site_2; typedef Kernel_base_2 Base; }; template class Apollonius_graph_cartesian_converter : public Converter { private: typedef typename K2::Site_2 K2_Site_2; typedef typename K2::Point_2 K2_Point_2; typedef Converter Base; typedef typename Converter::Number_type_converter NT_converter; public: #if defined(_MSC_VER) || defined(__sgi) \ || defined(CGAL_CFG_USING_BASE_MEMBER_BUG) bool operator()(bool b) const { return Base::operator()(b); } K2_Point_2 operator()(const typename K1::Point_2& p) const { return Base::operator()(p); } #else using Base::operator(); #endif K2_Site_2 operator()(const typename K1::Site_2& t) const { NT_converter nt_cv; return K2_Site_2( Base::operator()(t.point()), nt_cv(t.weight()) ); } }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_KERNEL_WRAPPER_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Tools/0000755000175000017500000000000012146213731026131 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Tools/chained_map.h0000644000175000017500000002117111344301501030524 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Tools/chained_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Courtesy of LEDA #ifndef CGAL_CHAINED_MAP_H #define CGAL_CHAINED_MAP_H CGAL_BEGIN_NAMESPACE namespace CGALi { template class chained_map; template class chained_map_elem; template class chained_map_elem { friend class chained_map; unsigned long k; T i; chained_map_elem* succ; }; template class chained_map { const unsigned long NULLKEY; const unsigned long NONNULLKEY; chained_map_elem STOP; chained_map_elem* table; chained_map_elem* table_end; chained_map_elem* free; int table_size; int table_size_1; chained_map_elem* old_table; chained_map_elem* old_table_end; chained_map_elem* old_free; int old_table_size; int old_table_size_1; unsigned long old_index; public: T& xdef() { return STOP.i; } const T& cxdef() const { return STOP.i; } private: void init_inf(T& x) const { x = STOP.i; } chained_map_elem* HASH(unsigned long x) const { return table + (x & table_size_1); } void init_table(int t); void rehash(); void del_old_table(); inline void insert(unsigned long x, T y); public: typedef chained_map_elem* chained_map_item; typedef chained_map_item item; unsigned long index(chained_map_item it) const { return it->k; } T& inf(chained_map_item it) const { return it->i; } chained_map(int n = 1); chained_map(const chained_map& D); chained_map& operator=(const chained_map& D); void clear_entries(); void clear(); ~chained_map() { if (old_table) delete[] old_table; delete[] table; } T& access(chained_map_item p, unsigned long x); T& access(unsigned long x); chained_map_item lookup(unsigned long x) const; chained_map_item first_item() const; chained_map_item next_item(chained_map_item it) const; void statistics() const; }; template inline T& chained_map::access(unsigned long x) { chained_map_item p = HASH(x); if (old_table) del_old_table(); if ( p->k == x ) { old_index = x; return p->i; } else { if ( p->k == NULLKEY ) { p->k = x; init_inf(p->i); // initializes p->i to xdef old_index = x; return p->i; } else return access(p,x); } } template void chained_map::init_table(int t) { table_size = t; table_size_1 = t-1; table = new chained_map_elem[t + t/2]; free = table + t; table_end = table + t + t/2; for (chained_map_item p = table; p < free; p++) { p->succ = &STOP; p->k = NULLKEY; } table->k = NONNULLKEY; } template inline void chained_map::insert(unsigned long x, T y) { chained_map_item q = HASH(x); if ( q->k == NULLKEY ) { q->k = x; q->i = y; } else { free->k = x; free->i = y; free->succ = q->succ; q->succ = free++; } } template void chained_map::rehash() { old_table = table; old_table_end = table_end; old_table_size = table_size; old_table_size_1 = table_size_1; old_free = free; chained_map_item old_table_mid = table + table_size; init_table(2*table_size); chained_map_item p; for(p = old_table + 1; p < old_table_mid; p++) { unsigned long x = p->k; if ( x != NULLKEY ) // list p is non-empty { chained_map_item q = HASH(x); q->k = x; q->i = p->i; } } while (p < old_table_end) { unsigned long x = p->k; insert(x,p->i); p++; } } template void chained_map::del_old_table() { chained_map_item save_table = table; chained_map_item save_table_end = table_end; chained_map_item save_free = free; int save_table_size = table_size; int save_table_size_1 = table_size_1; table = old_table; table_end = old_table_end; table_size = old_table_size; table_size_1 = old_table_size_1; free = old_free; old_table = 0; T p = access(old_index); delete[] table; table = save_table; table_end = save_table_end; table_size = save_table_size; table_size_1 = save_table_size_1; free = save_free; access(old_index) = p; } template T& chained_map::access(chained_map_item p, unsigned long x) { STOP.k = x; chained_map_item q = p->succ; while (q->k != x) q = q->succ; if (q != &STOP) { old_index = x; return q->i; } // index x not present, insert it if (free == table_end) // table full: rehash { rehash(); p = HASH(x); } if (p->k == NULLKEY) { p->k = x; init_inf(p->i); // initializes p->i to xdef return p->i; } q = free++; q->k = x; init_inf(q->i); // initializes q->i to xdef q->succ = p->succ; p->succ = q; return q->i; } template chained_map::chained_map(int n) : NULLKEY(0), NONNULLKEY(1), old_table(0) { if (n < 512) init_table(512); else { int ts = 1; while (ts < n) ts <<= 1; init_table(ts); } } template chained_map::chained_map(const chained_map& D) : NULLKEY(0), NONNULLKEY(1), old_table(0) { init_table(D.table_size); STOP.i = D.STOP.i; // xdef for(chained_map_item p = D.table + 1; p < D.free; p++) { if (p->k != NULLKEY || p >= D.table + D.table_size) { insert(p->k,p->i); //D.copy_inf(p->i); // see chapter Implementation } } } template chained_map& chained_map::operator=(const chained_map& D) { clear_entries(); delete[] table; init_table(D.table_size); STOP.i = D.STOP.i; // xdef for(chained_map_item p = D.table + 1; p < D.free; p++) { if (p->k != NULLKEY || p >= D.table + D.table_size) { insert(p->k,p->i); //copy_inf(p->i); // see chapter Implementation } } return *this; } template void chained_map::clear_entries() { for(chained_map_item p = table + 1; p < free; p++) if (p->k != NULLKEY || p >= table + table_size) p->i = T(); } template void chained_map::clear() { clear_entries(); delete[] table; init_table(512); } template typename chained_map::chained_map_item chained_map::lookup(unsigned long x) const { chained_map_item p = HASH(x); ((unsigned long &)STOP.k) = x; // cast away const while (p->k != x) { p = p->succ; } return (p == &STOP) ? 0 : p; } template typename chained_map::chained_map_item chained_map::first_item() const { return next_item(table); } template typename chained_map::chained_map_item chained_map::next_item(chained_map_item it) const { if (it == 0) return 0; do it++; while (it < table + table_size && it->k == NULLKEY); return (it < free ? it : 0); } template void chained_map::statistics() const { std::cout << "table_size: " << table_size <<"\n"; int n = 0; for (chained_map_item p = table + 1; p < table + table_size; p++) if (p ->k != NULLKEY) n++; int used_in_overflow = free - (table + table_size ); n += used_in_overflow; std::cout << "number of entries: " << n << "\n"; std::cout << "fraction of entries in first position: " << ((double) (n - used_in_overflow))/n <<"\n"; std::cout << "fraction of empty lists: " << ((double) (n - used_in_overflow))/table_size<<"\n"; } } // namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_CHAINED_MAP_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/kernel_assertions.h0000644000175000017500000003405411344301500030731 0ustar debiandebian // Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/kernel_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : script by Geert-Jan Giezeman and Sven Schoenherr // macro definitions // ================= // assertions // ---------- #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_kernel_assertion(EX) (static_cast(0)) # define CGAL_kernel_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_assertion_code(CODE) #else # define CGAL_kernel_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_assertion_code(CODE) CODE # define CGAL_kernel_assertions 1 #endif // CGAL_KERNEL_NO_ASSERTIONS #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_kernel_exactness_assertion(EX) (static_cast(0)) # define CGAL_kernel_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_exactness_assertion_code(CODE) #else # define CGAL_kernel_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_exactness_assertion_code(CODE) CODE # define CGAL_kernel_exactness_assertions 1 #endif // CGAL_KERNEL_NO_ASSERTIONS #if defined(CGAL_KERNEL_NO_ASSERTIONS) \ || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_assertion(EX) (static_cast(0)) # define CGAL_kernel_expensive_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_assertion_code(CODE) #else # define CGAL_kernel_expensive_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_assertion_code(CODE) CODE # define CGAL_kernel_expensive_assertions 1 #endif // CGAL_KERNEL_NO_ASSERTIONS #if defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_exactness_assertion(EX) (static_cast(0)) # define CGAL_kernel_expensive_exactness_assertion_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_exactness_assertion_code(CODE) #else # define CGAL_kernel_expensive_exactness_assertion(EX) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_exactness_assertion_code(CODE) CODE # define CGAL_kernel_expensive_exactness_assertions 1 #endif // CGAL_KERNEL_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_kernel_precondition(EX) (static_cast(0)) # define CGAL_kernel_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_precondition_code(CODE) #else # define CGAL_kernel_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_precondition_code(CODE) CODE # define CGAL_kernel_preconditions 1 #endif // CGAL_KERNEL_NO_PRECONDITIONS #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_kernel_exactness_precondition(EX) (static_cast(0)) # define CGAL_kernel_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_exactness_precondition_code(CODE) #else # define CGAL_kernel_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_exactness_precondition_code(CODE) CODE # define CGAL_kernel_exactness_preconditions 1 #endif // CGAL_KERNEL_NO_PRECONDITIONS #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_precondition(EX) (static_cast(0)) # define CGAL_kernel_expensive_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_precondition_code(CODE) #else # define CGAL_kernel_expensive_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_precondition_code(CODE) CODE # define CGAL_kernel_expensive_preconditions 1 #endif // CGAL_KERNEL_NO_PRECONDITIONS #if defined(CGAL_KERNEL_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_exactness_precondition(EX) (static_cast(0)) # define CGAL_kernel_expensive_exactness_precondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_exactness_precondition_code(CODE) #else # define CGAL_kernel_expensive_exactness_precondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_exactness_precondition_code(CODE) CODE # define CGAL_kernel_expensive_exactness_preconditions 1 #endif // CGAL_KERNEL_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_kernel_postcondition(EX) (static_cast(0)) # define CGAL_kernel_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_postcondition_code(CODE) #else # define CGAL_kernel_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_postcondition_code(CODE) CODE # define CGAL_kernel_postconditions 1 #endif // CGAL_KERNEL_NO_POSTCONDITIONS #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_kernel_exactness_postcondition(EX) (static_cast(0)) # define CGAL_kernel_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_exactness_postcondition_code(CODE) #else # define CGAL_kernel_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_exactness_postcondition_code(CODE) CODE # define CGAL_kernel_exactness_postconditions 1 #endif // CGAL_KERNEL_NO_POSTCONDITIONS #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_postcondition(EX) (static_cast(0)) # define CGAL_kernel_expensive_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_postcondition_code(CODE) #else # define CGAL_kernel_expensive_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_postcondition_code(CODE) CODE # define CGAL_kernel_expensive_postconditions 1 #endif // CGAL_KERNEL_NO_POSTCONDITIONS #if defined(CGAL_KERNEL_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_exactness_postcondition(EX) (static_cast(0)) # define CGAL_kernel_expensive_exactness_postcondition_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_exactness_postcondition_code(CODE) #else # define CGAL_kernel_expensive_exactness_postcondition(EX) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_exactness_postcondition_code(CODE) CODE # define CGAL_kernel_expensive_exactness_postconditions 1 #endif // CGAL_KERNEL_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_kernel_warning(EX) (static_cast(0)) # define CGAL_kernel_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_warning_code(CODE) #else # define CGAL_kernel_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_warning_code(CODE) CODE # define CGAL_kernel_warnings 1 #endif // CGAL_KERNEL_NO_WARNINGS #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_kernel_exactness_warning(EX) (static_cast(0)) # define CGAL_kernel_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_exactness_warning_code(CODE) #else # define CGAL_kernel_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_exactness_warning_code(CODE) CODE # define CGAL_kernel_exactness_warnings 1 #endif // CGAL_KERNEL_NO_WARNINGS #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_warning(EX) (static_cast(0)) # define CGAL_kernel_expensive_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_warning_code(CODE) #else # define CGAL_kernel_expensive_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_warning_code(CODE) CODE # define CGAL_kernel_expensive_warnings 1 #endif // CGAL_KERNEL_NO_WARNINGS #if defined(CGAL_KERNEL_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_KERNEL_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_KERNEL_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_kernel_expensive_exactness_warning(EX) (static_cast(0)) # define CGAL_kernel_expensive_exactness_warning_msg(EX,MSG) (static_cast(0)) # define CGAL_kernel_expensive_exactness_warning_code(CODE) #else # define CGAL_kernel_expensive_exactness_warning(EX) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_kernel_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?(static_cast(0)): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_kernel_expensive_exactness_warning_code(CODE) CODE # define CGAL_kernel_expensive_exactness_warnings 1 #endif // CGAL_KERNEL_NO_WARNINGS ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interpolation_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interpolation_traits_20000644000175000017500000000405311344301500031403 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Interpolation_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_INTERPOLATION_TRAITS_2_H #define CGAL_INTERPOLATION_TRAITS_2_H CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Interpolation_traits_2 //-----------------------------------------------------------------------// // The class Interpolation_traits_2 is needed to define the geometric // operations used by the interpolation methods. template class Interpolation_traits_2 { public: typedef typename R::FT FT; typedef typename R::Point_2 Point_d; typedef typename R::Vector_2 Vector_d; typedef typename R::Construct_vector_2 Construct_vector_d; typedef typename R::Construct_scaled_vector_2 Construct_scaled_vector_d; typedef typename R::Compute_squared_distance_2 Compute_squared_distance_d; Construct_scaled_vector_d construct_scaled_vector_d_object()const {return Construct_scaled_vector_d();} Construct_vector_d construct_vector_d_object()const {return Construct_vector_d();} Compute_squared_distance_d compute_squared_distance_d_object()const {return Compute_squared_distance_d();} }; CGAL_END_NAMESPACE #endif // CGAL_INTERPOLATION_TRAITS_2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Iso_rectangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Iso_rectangle_2_0000644000175000017500000002041711344301500031141 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Iso_rectangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_RAY_2_ISO_RECTANGLE_2_INTERSECTION_H #define CGAL_RAY_2_ISO_RECTANGLE_2_INTERSECTION_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Ray_2_Iso_rectangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Ray_2_Iso_rectangle_2_pair() ; Ray_2_Iso_rectangle_2_pair(typename K::Ray_2 const *ray, typename K::Iso_rectangle_2 const *rect) ; Intersection_results intersection_type() const; bool intersection( typename K::Point_2 &result) const; bool intersection( typename K::Segment_2 &result) const; protected: mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _ref_point; mutable typename K::Vector_2 _dir; mutable typename K::Point_2 _isomin; mutable typename K::Point_2 _isomax; mutable typename K::FT _min, _max; }; template inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &p1, const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2, const K& k) { typedef Ray_2_Iso_rectangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2, const typename CGAL_WRAP(K)::Ray_2 &p1, const K& k) { return do_intersect(p1, p2, k); } template Object intersection(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const K& k) { typedef Ray_2_Iso_rectangle_2_pair is_t; is_t ispair(&ray, &iso); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 ipt; ispair.intersection(ipt); return make_object(ipt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } template Object intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { return intersection(ray, iso, k); } template Ray_2_Iso_rectangle_2_pair::Ray_2_Iso_rectangle_2_pair() { _known = false; } template Ray_2_Iso_rectangle_2_pair:: Ray_2_Iso_rectangle_2_pair( typename K::Ray_2 const *ray, typename K::Iso_rectangle_2 const *iso) { _known = false; _isomin = iso->min(); _isomax = iso->max(); _ref_point = ray->source(); _dir = ray->direction().to_vector(); _min = (typename K::FT)(0); } template typename Ray_2_Iso_rectangle_2_pair::Intersection_results Ray_2_Iso_rectangle_2_pair::intersection_type() const { typedef typename K::RT RT; typedef typename K::FT FT; if (_known) return _result; _known = true; bool to_infinity = true; typename K::Construct_cartesian_const_iterator_2 construct_cccit; typename K::Cartesian_const_iterator_2 ref_point_it = construct_cccit(_ref_point); typename K::Cartesian_const_iterator_2 end = construct_cccit(_ref_point, 0); typename K::Cartesian_const_iterator_2 isomin_it = construct_cccit(_isomin); typename K::Cartesian_const_iterator_2 isomax_it = construct_cccit(_isomax); for (unsigned int i=0; ref_point_it != end; ++i, ++ref_point_it, ++isomin_it, ++isomax_it) { if (_dir.homogeneous(i) == RT(0)) { if ((*ref_point_it) < (*isomin_it)) { _result = NO; return _result; } if ((*ref_point_it) > (*isomax_it)) { _result = NO; return _result; } } else { FT newmin, newmax; if (_dir.homogeneous(i) > RT(0)) { newmin = (*isomin_it - *ref_point_it) / _dir.cartesian(i); newmax = (*isomax_it - *ref_point_it) / _dir.cartesian(i); } else { newmin = (*isomax_it - *ref_point_it) / _dir.cartesian(i); newmax = (*isomin_it - *ref_point_it) / _dir.cartesian(i); } if (newmin > _min) _min = newmin; if (to_infinity) { _max = newmax; } else { if (newmax < _max) _max = newmax; } if (_max < _min) { _result = NO; return _result; } to_infinity = false; } } CGAL_kernel_assertion(!to_infinity); if (_max == _min) { _result = POINT; return _result; } _result = SEGMENT; return _result; } template bool Ray_2_Iso_rectangle_2_pair:: intersection(typename K::Segment_2 &seg) const { typedef typename K::Segment_2 Segment_2; typename K::Construct_translated_point_2 translated_point; typename K::Construct_scaled_vector_2 construct_scaled_vector; if (!_known) intersection_type(); if (_result != SEGMENT) return false; typename K::Point_2 p1(translated_point(_ref_point, construct_scaled_vector(_dir,_min))); typename K::Point_2 p2(translated_point(_ref_point, construct_scaled_vector(_dir,_max))); seg = Segment_2(p1, p2); return true; } template bool Ray_2_Iso_rectangle_2_pair:: intersection(typename K::Point_2 &pt) const { typedef typename K::Point_2 Point_2; typename K::Construct_translated_point_2 translated_point; typename K::Construct_scaled_vector_2 construct_scaled_vector; if (!_known) intersection_type(); if (_result != POINT) return false; pt = Point_2(translated_point(_ref_point, construct_scaled_vector(_dir, _min))); return true; } template class Iso_rectangle_2_Ray_2_pair: public Ray_2_Iso_rectangle_2_pair { public: Iso_rectangle_2_Ray_2_pair() {} Iso_rectangle_2_Ray_2_pair(typename K::Iso_rectangle_2 const *rect, typename K::Ray_2 const *ray) :Ray_2_Iso_rectangle_2_pair (ray, rect){} }; } // namespace CGALi template inline bool do_intersect(const Iso_rectangle_2 &p1, const Ray_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline bool do_intersect(const Ray_2 &p2, const Iso_rectangle_2 &p1) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline Object intersection(const Iso_rectangle_2&iso, const Ray_2&ray) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, iso); } template inline Object intersection(const Ray_2&ray, const Iso_rectangle_2&iso) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, iso); } CGAL_END_NAMESPACE #endif // CGAL_RAY_2_iSO_RECTANGLE_2_INTERSECTION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Td_traits.C0000644000175000017500000000553011344301501027065 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Td_traits.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_TD_TRAITS_H #include #endif CGAL_BEGIN_NAMESPACE template const typename Td_traits::Point& Td_traits::get_point_at_left_top_infinity(){ /* static typename Td_traits::Point Td_traits::POINT_AT_LEFT_TOP_INFINITY; return Td_traits::POINT_AT_LEFT_TOP_INFINITY; */ // static Point POINT_AT_LEFT_TOP_INFINITY; if (!POINT_AT_LEFT_TOP_INFINITY) POINT_AT_LEFT_TOP_INFINITY = new Point(); return *POINT_AT_LEFT_TOP_INFINITY; } template const typename Td_traits::Point& Td_traits::get_point_at_right_bottom_infinity(){ /* static typename Td_traits::Point Td_traits::POINT_AT_RIGHT_BOTTOM_INFINITY; return Td_traits::POINT_AT_RIGHT_BOTTOM_INFINITY; */ // static Point POINT_AT_RIGHT_BOTTOM_INFINITY; if (!POINT_AT_RIGHT_BOTTOM_INFINITY) POINT_AT_RIGHT_BOTTOM_INFINITY = new Point(); return *POINT_AT_RIGHT_BOTTOM_INFINITY; } template const typename Td_traits::X_curve& Td_traits::get_curve_at_infinity(){ /* static typename typename Traits::X_curveTraits::X_curve Td_traits::CURVE_AT_INFINITY; return Td_traits::CURVE_AT_INFINITY; */ // static X_curve CURVE_AT_INFINITY; if (!CURVE_AT_INFINITY) CURVE_AT_INFINITY = new X_curve(); return *CURVE_AT_INFINITY; } template typename Td_traits::Point * Td_traits::POINT_AT_LEFT_TOP_INFINITY = 0; template typename Td_traits::Point * Td_traits::POINT_AT_RIGHT_BOTTOM_INFINITY = 0; template typename Td_traits::X_curve * Td_traits::CURVE_AT_INFINITY = 0; CGAL_END_NAMESPACE mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/0000755000175000017500000000000012146213732026277 5ustar debiandebian././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/i686_Linux-2.4.21-27.0.2.EL_g++-3.2.3/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/i686_Linux-2.4.0000755000175000017500000000000012146213732030452 5ustar debiandebian././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/i686_Linux-2.4.21-27.0.2.EL_g++-3.2.3/CGAL/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/i686_Linux-2.4.0000755000175000017500000000000012146213732030452 5ustar debiandebian././@LongLink0000000000000000000000000000022200000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/i686_Linux-2.4.21-27.0.2.EL_g++-3.2.3/CGAL/compiler_config.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/i686_Linux-2.4.0000644000175000017500000003270311344301501030450 0ustar debiandebian// Copyright (c) 1996-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // Author(s): the install_cgal script // Compiler specific configuration file for CGAL 3.1 // System: i686_Linux-2.4.21-27.0.2.EL_g++-3.2.3 // generated by install_cgal 1.271.2.2 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_CCTYPE_MACRO_BUG is set, if a compiler defines the //| standard C library functions in cctype (isdigit etc.) as macros. //| According to the standard they have to be functions. //+-------------------------------------------------------------------------- //#define CGAL_CFG_CCTYPE_MACRO_BUG 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_CONVERSION_OPERATOR_BUG is set, if a compiler //| crashes with some conversion operators. G++ 3.3.0 is affected by //| this bug (it hits Darwin severely since it is the system compiler). //+-------------------------------------------------------------------------- //#define CGAL_CFG_CONVERSION_OPERATOR_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs when handling denormal values at //| compile time. At least PGCC 5.1-3 has the bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_DENORMALS_COMPILE_BUG 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_HAS_TWO_STAGE_NAME_LOOKUP is set, //| if a compiler supports the two stage name lookup. //| This is a feature of G++ >= 3.4. //| Note that the program fails when the feature works, //| which is different from the other test programs. //+-------------------------------------------------------------------------- //#define CGAL_CFG_HAS_TWO_STAGE_NAME_LOOKUP 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs with special features with IEEE 754 //| handling, concerning is_valid() and is_finite() testing of infinity and //| nans. The workaround is to use bitfield operations. //| At least VC++, Borland and PGCC have the bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_IEEE_754_BUG 1 //+-------------------------------------------------------------------------- //| If a compiler (or assembler or linker) has problems with long names //| CGAL_CFG_LONGNAME_BUG is set. //+-------------------------------------------------------------------------- //#define CGAL_CFG_LONGNAME_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set, if the compiler does not match function arguments //| of pointer type correctly, when the return type depends on //| the parameter's type. (e.g. sun C++ 5.3) //+-------------------------------------------------------------------------- //#define CGAL_CFG_MATCHING_BUG_3 1 //+-------------------------------------------------------------------------- //| This flag is set, if a compiler cannot distinguish the signature //| of overloaded function templates, which have arguments whose type //| depends on the template parameter. //| This bug appears for example on Sunpro 5.3 and 5.4. //+-------------------------------------------------------------------------- //#define CGAL_CFG_MATCHING_BUG_4 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_MISSING_TEMPLATE_VECTOR_CONSTRUCTORS_BUG is set, //| if the std::vector class does not have defined template constructors. //| This is a feature of SunPro 5.5. //+-------------------------------------------------------------------------- //#define CGAL_CFG_MISSING_TEMPLATE_VECTOR_CONSTRUCTORS_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set, if the compiler does not match a member //| definition to an existing declaration (eg., cl1310 Beta). //+-------------------------------------------------------------------------- //#define CGAL_CFG_NET2003_MATCHING_BUG 1 //+-------------------------------------------------------------------------- //| When template implementation files are not included in the source files, //| a compiler may attempt to find the unincluded template bodies //| automatically. For example, suppose that the following conditions are //| all true. //| //| - template entity ABC::f is declared in file xyz.h //| - an instantiation of ABC::f is required in a compilation //| - no definition of ABC::f appears in the source code processed by the //| compilation //| //| In this case, the compiler may look to see if the source file xyz.n exists, //| where n is .c, .C, .cpp, .CPP, .cxx, .CXX, or .cc. If this feature is //| missing, the flag CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION is set. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION 1 //+-------------------------------------------------------------------------- //| The byte order of a machine architecture distinguishes into //| big-endian and little-endian machines. //| The following definition is set if it is a little-endian machine. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_BIG_ENDIAN 1 //+-------------------------------------------------------------------------- //| Tests if CORE is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_CORE 1 //+-------------------------------------------------------------------------- //| Tests if GMP is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_GMP 1 //+-------------------------------------------------------------------------- //| Tests if GMPXX is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_GMPXX 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support the operator Koenig //| lookup. That is, it does not search in the namespace of the arguments for //| the function. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_KOENIG_LOOKUP 1 //+-------------------------------------------------------------------------- //| Tests if LEDA is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_LEDA 1 //+-------------------------------------------------------------------------- //| If a compiler doesn't know (g++-2.95) //| or has a bug in the implementation (Sun CC 5.4, MipsPro CC) //| CGAL_CFG_NO_LIMITS is set. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_LIMITS 1 //+-------------------------------------------------------------------------- //| If a compiler doesn't know the locale classic //| CGAL_CFG_NO_LOCALE is set. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_LOCALE 1 //+-------------------------------------------------------------------------- //| The long long built-in integral type is not part of the ISO C++ standard, //| but many compilers support it nevertheless since it's part of the ISO //| C standard. //| The following definition is set if it is supported. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_LONG_LONG 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support the FENV_ACCESS pragma. //| This pragma is supported by the ISO C99 standard. //| Note : GCC (<= 3.4 at least) only warns that it does not support it. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_PRAGMA_FENV_ACCESS 1 //+-------------------------------------------------------------------------- //| Tests if QT is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_QT 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support the SFINAE principle //| (Substitution Failure Is Not An Error), which we eventually plan to use //| for the next version of the kernel design. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_SFINAE 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_NO_STDC_NAMESPACE is set, if a compiler does not //| put the parts of the standard library inherited from the standard //| C library in namespace std. (only tests for the symbols used in CGAL) //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_STDC_NAMESPACE 1 //+-------------------------------------------------------------------------- //| A basic test for the STL. //| If it fails, it probably means a bad CGAL installation. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_STL 1 //+-------------------------------------------------------------------------- //| G++ 2.95.2 has problems with member functions implemented outside of //| the class body if this member function has a parameter type that is //| dependant on a template in the template parameter list of the class. A //| workaround would be to implement the member function inline in the class. //| The following definition is set if this error error occurs. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_TMPL_IN_TMPL_DEPENDING_FUNCTION_PARAM 1 //+-------------------------------------------------------------------------- //| Nested templates in template parameter, such as 'template < //| template class A>' are not supported by any compiler. //| The following definition is set if they are not supported. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_TMPL_IN_TMPL_PARAM 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG_2 is set, //| if a compiler does not support the definition of member templates //| out of line, i.e. outside class scope. The solution is to put the //| definition inside the class. //| The difference with CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG //| is the return type of the member template.SunPro 5.5 should be OK with //| this code. //+-------------------------------------------------------------------------- //#define CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG_2 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG is set, //| if a compiler does not support the definition of member templates //| out of line, i.e. outside class scope. The solution is to put the //| definition inside the class. This is a feature of SunPro 5.5. //+-------------------------------------------------------------------------- //#define CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG 1 //+-------------------------------------------------------------------------- //+-------------------------------------------------------------------------- //#define CGAL_CFG_TYPENAME_BEFORE_DEFAULT_ARGUMENT_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs with some "using Base::Member;" in //| a derived class. The workaround is to write a forwarder or not use using. //| At least SunPro CC 5.3 has this bug where the typical error message is : //| "Error: The function B::g() has not had a body defined." //| Note that the subtlely is that the error message does not mention //| "Member"... //+-------------------------------------------------------------------------- //#define CGAL_CFG_USING_BASE_MEMBER_BUG_2 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs with some "using Base::Member;" in //| a derived class, when there is a typedef of the base class. //| The workaround is to write a forwarder or not use using. //| At least MipsPRO CC 7.4 has this bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_USING_BASE_MEMBER_BUG_3 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support "using Base::Member;" in //| a derived class. The workaround is to write a forwarder. //| At least g++ 2.95 and SunPro CC 5.3 have this bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_USING_BASE_MEMBER_BUG 1 ././@LongLink0000000000000000000000000000021400000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/x86-64_Linux-2.6.27.35-170.2.94.fc10.x86-64_g++-4.3.2/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/x86-64_Linux-2.0000755000175000017500000000000012146213732030470 5ustar debiandebian././@LongLink0000000000000000000000000000022100000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/x86-64_Linux-2.6.27.35-170.2.94.fc10.x86-64_g++-4.3.2/CGAL/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/x86-64_Linux-2.0000755000175000017500000000000012146213732030470 5ustar debiandebian././@LongLink0000000000000000000000000000024200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/x86-64_Linux-2.6.27.35-170.2.94.fc10.x86-64_g++-4.3.2/CGAL/compiler_config.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/config/x86-64_Linux-2.0000644000175000017500000003272311344301501030470 0ustar debiandebian// Copyright (c) 1996-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // Author(s): the install_cgal script // Compiler specific configuration file for CGAL 3.1 // System: x86-64_Linux-2.6.27.35-170.2.94.fc10.x86-64_g++-4.3.2 // generated by install_cgal 1.271.2.2 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_CCTYPE_MACRO_BUG is set, if a compiler defines the //| standard C library functions in cctype (isdigit etc.) as macros. //| According to the standard they have to be functions. //+-------------------------------------------------------------------------- //#define CGAL_CFG_CCTYPE_MACRO_BUG 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_CONVERSION_OPERATOR_BUG is set, if a compiler //| crashes with some conversion operators. G++ 3.3.0 is affected by //| this bug (it hits Darwin severely since it is the system compiler). //+-------------------------------------------------------------------------- //#define CGAL_CFG_CONVERSION_OPERATOR_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs when handling denormal values at //| compile time. At least PGCC 5.1-3 has the bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_DENORMALS_COMPILE_BUG 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_HAS_TWO_STAGE_NAME_LOOKUP is set, //| if a compiler supports the two stage name lookup. //| This is a feature of G++ >= 3.4. //| Note that the program fails when the feature works, //| which is different from the other test programs. //+-------------------------------------------------------------------------- #define CGAL_CFG_HAS_TWO_STAGE_NAME_LOOKUP 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs with special features with IEEE 754 //| handling, concerning is_valid() and is_finite() testing of infinity and //| nans. The workaround is to use bitfield operations. //| At least VC++, Borland and PGCC have the bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_IEEE_754_BUG 1 //+-------------------------------------------------------------------------- //| If a compiler (or assembler or linker) has problems with long names //| CGAL_CFG_LONGNAME_BUG is set. //+-------------------------------------------------------------------------- //#define CGAL_CFG_LONGNAME_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set, if the compiler does not match function arguments //| of pointer type correctly, when the return type depends on //| the parameter's type. (e.g. sun C++ 5.3) //+-------------------------------------------------------------------------- //#define CGAL_CFG_MATCHING_BUG_3 1 //+-------------------------------------------------------------------------- //| This flag is set, if a compiler cannot distinguish the signature //| of overloaded function templates, which have arguments whose type //| depends on the template parameter. //| This bug appears for example on Sunpro 5.3 and 5.4. //+-------------------------------------------------------------------------- //#define CGAL_CFG_MATCHING_BUG_4 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_MISSING_TEMPLATE_VECTOR_CONSTRUCTORS_BUG is set, //| if the std::vector class does not have defined template constructors. //| This is a feature of SunPro 5.5. //+-------------------------------------------------------------------------- //#define CGAL_CFG_MISSING_TEMPLATE_VECTOR_CONSTRUCTORS_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set, if the compiler does not match a member //| definition to an existing declaration (eg., cl1310 Beta). //+-------------------------------------------------------------------------- //#define CGAL_CFG_NET2003_MATCHING_BUG 1 //+-------------------------------------------------------------------------- //| When template implementation files are not included in the source files, //| a compiler may attempt to find the unincluded template bodies //| automatically. For example, suppose that the following conditions are //| all true. //| //| - template entity ABC::f is declared in file xyz.h //| - an instantiation of ABC::f is required in a compilation //| - no definition of ABC::f appears in the source code processed by the //| compilation //| //| In this case, the compiler may look to see if the source file xyz.n exists, //| where n is .c, .C, .cpp, .CPP, .cxx, .CXX, or .cc. If this feature is //| missing, the flag CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION is set. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION 1 //+-------------------------------------------------------------------------- //| The byte order of a machine architecture distinguishes into //| big-endian and little-endian machines. //| The following definition is set if it is a little-endian machine. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_BIG_ENDIAN 1 //+-------------------------------------------------------------------------- //| Tests if CORE is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_CORE 1 //+-------------------------------------------------------------------------- //| Tests if GMP is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_GMP 1 //+-------------------------------------------------------------------------- //| Tests if GMPXX is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_GMPXX 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support the operator Koenig //| lookup. That is, it does not search in the namespace of the arguments for //| the function. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_KOENIG_LOOKUP 1 //+-------------------------------------------------------------------------- //| Tests if LEDA is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_LEDA 1 //+-------------------------------------------------------------------------- //| If a compiler doesn't know (g++-2.95) //| or has a bug in the implementation (Sun CC 5.4, MipsPro CC) //| CGAL_CFG_NO_LIMITS is set. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_LIMITS 1 //+-------------------------------------------------------------------------- //| If a compiler doesn't know the locale classic //| CGAL_CFG_NO_LOCALE is set. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_LOCALE 1 //+-------------------------------------------------------------------------- //| The long long built-in integral type is not part of the ISO C++ standard, //| but many compilers support it nevertheless since it's part of the ISO //| C standard. //| The following definition is set if it is supported. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_LONG_LONG 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support the FENV_ACCESS pragma. //| This pragma is supported by the ISO C99 standard. //| Note : GCC (<= 3.4 at least) only warns that it does not support it. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_PRAGMA_FENV_ACCESS 1 //+-------------------------------------------------------------------------- //| Tests if QT is available. //+-------------------------------------------------------------------------- #define CGAL_CFG_NO_QT 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support the SFINAE principle //| (Substitution Failure Is Not An Error), which we eventually plan to use //| for the next version of the kernel design. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_SFINAE 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_NO_STDC_NAMESPACE is set, if a compiler does not //| put the parts of the standard library inherited from the standard //| C library in namespace std. (only tests for the symbols used in CGAL) //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_STDC_NAMESPACE 1 //+-------------------------------------------------------------------------- //| A basic test for the STL. //| If it fails, it probably means a bad CGAL installation. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_STL 1 //+-------------------------------------------------------------------------- //| G++ 2.95.2 has problems with member functions implemented outside of //| the class body if this member function has a parameter type that is //| dependant on a template in the template parameter list of the class. A //| workaround would be to implement the member function inline in the class. //| The following definition is set if this error error occurs. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_TMPL_IN_TMPL_DEPENDING_FUNCTION_PARAM 1 //+-------------------------------------------------------------------------- //| Nested templates in template parameter, such as 'template < //| template class A>' are not supported by any compiler. //| The following definition is set if they are not supported. //+-------------------------------------------------------------------------- //#define CGAL_CFG_NO_TMPL_IN_TMPL_PARAM 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG_2 is set, //| if a compiler does not support the definition of member templates //| out of line, i.e. outside class scope. The solution is to put the //| definition inside the class. //| The difference with CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG //| is the return type of the member template.SunPro 5.5 should be OK with //| this code. //+-------------------------------------------------------------------------- //#define CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG_2 1 //+-------------------------------------------------------------------------- //| The flag CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG is set, //| if a compiler does not support the definition of member templates //| out of line, i.e. outside class scope. The solution is to put the //| definition inside the class. This is a feature of SunPro 5.5. //+-------------------------------------------------------------------------- //#define CGAL_CFG_OUTOFLINE_TEMPLATE_MEMBER_DEFINITION_BUG 1 //+-------------------------------------------------------------------------- //+-------------------------------------------------------------------------- //#define CGAL_CFG_TYPENAME_BEFORE_DEFAULT_ARGUMENT_BUG 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs with some "using Base::Member;" in //| a derived class. The workaround is to write a forwarder or not use using. //| At least SunPro CC 5.3 has this bug where the typical error message is : //| "Error: The function B::g() has not had a body defined." //| Note that the subtlely is that the error message does not mention //| "Member"... //+-------------------------------------------------------------------------- //#define CGAL_CFG_USING_BASE_MEMBER_BUG_2 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler bugs with some "using Base::Member;" in //| a derived class, when there is a typedef of the base class. //| The workaround is to write a forwarder or not use using. //| At least MipsPRO CC 7.4 has this bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_USING_BASE_MEMBER_BUG_3 1 //+-------------------------------------------------------------------------- //| This flag is set if the compiler doesn't support "using Base::Member;" in //| a derived class. The workaround is to write a forwarder. //| At least g++ 2.95 and SunPro CC 5.3 have this bug. //+-------------------------------------------------------------------------- //#define CGAL_CFG_USING_BASE_MEMBER_BUG 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_cuboid_3.h0000644000175000017500000000564311344301500027502 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_cuboid_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_ISO_CUBOID_3_H #define CGAL_ISO_CUBOID_3_H CGAL_BEGIN_NAMESPACE template class Iso_cuboid_3 : public R_::Kernel_base::Iso_cuboid_3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Kernel_base::Iso_cuboid_3 RIso_cuboid_3; public: typedef R_ R; Iso_cuboid_3() {} Iso_cuboid_3(const RIso_cuboid_3& r) : RIso_cuboid_3(r) {} Iso_cuboid_3(const Point_3& p, const Point_3& q) : RIso_cuboid_3(p,q) {} Iso_cuboid_3(const Point_3 &left, const Point_3 &right, const Point_3 &bottom, const Point_3 &top, const Point_3 &far_, const Point_3 &close) : RIso_cuboid_3(left, right, bottom, top, far_, close) {} Iso_cuboid_3(const RT& min_hx, const RT& min_hy, const RT& min_hz, const RT& max_hx, const RT& max_hy, const RT& max_hz, const RT& hw) : RIso_cuboid_3(min_hx, min_hy, min_hz, max_hx, max_hy, max_hz, hw) {} Iso_cuboid_3(const RT& min_hx, const RT& min_hy, const RT& min_hz, const RT& max_hx, const RT& max_hy, const RT& max_hz) : RIso_cuboid_3(min_hx, min_hy, min_hz, max_hx, max_hy, max_hz) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_ISO_CUBOID_3 template < class R > std::ostream& operator<<(std::ostream& os, const Iso_cuboid_3& r) { typedef typename R::Kernel_base::Iso_cuboid_3 RIso_cuboid_3; return os << (const RIso_cuboid_3& )r; } #endif // CGAL_NO_OSTREAM_INSERT_ISO_CUBOID_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_ISO_CUBOID_3 template < class R > std::istream& operator>>(std::istream& is, Iso_cuboid_3& r) { typedef typename R::Kernel_base::Iso_cuboid_3 RIso_cuboid_3; is >> (RIso_cuboid_3& )r; return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_ISO_CUBOID_3 CGAL_END_NAMESPACE #endif // CGAL_ISO_CUBOID_3_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_hierarchy_2.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000007635111344301501031404 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_hierarchy_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas // class implementation continued //================================= CGAL_BEGIN_NAMESPACE //=========================================================================== //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // constructors //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template void Segment_Voronoi_diagram_hierarchy_2:: init_hierarchy(const Geom_traits& gt) { hierarchy[0] = this; for(unsigned int i = 1; i < svd_hierarchy_2__maxlevel; ++i) { hierarchy[i] = new Base(gt); } } template Segment_Voronoi_diagram_hierarchy_2:: Segment_Voronoi_diagram_hierarchy_2(const Gt& gt) : Base(gt), random((long)0) { init_hierarchy(gt); } // copy constructor duplicates vertices and faces template Segment_Voronoi_diagram_hierarchy_2:: Segment_Voronoi_diagram_hierarchy_2 (const Segment_Voronoi_diagram_hierarchy_2 &svd) : Base(svd.geom_traits()), random((long)0) { // create an empty triangulation to be able to delete it ! init_hierarchy(svd.geom_traits()); copy(svd); } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // destructor //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template Segment_Voronoi_diagram_hierarchy_2:: ~Segment_Voronoi_diagram_hierarchy_2() { clear(); for(unsigned int i = 1; i < svd_hierarchy_2__maxlevel; ++i){ delete hierarchy[i]; } } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // assignment operator //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template Segment_Voronoi_diagram_hierarchy_2 & Segment_Voronoi_diagram_hierarchy_2:: operator=(const Segment_Voronoi_diagram_hierarchy_2 &svd) { if ( this != &svd ) { copy(svd); } return *this; } //==================================================================== //==================================================================== // METHODS FOR INSERTION //==================================================================== //==================================================================== //-------------------------------------------------------------------- // insertion of a point //-------------------------------------------------------------------- template void Segment_Voronoi_diagram_hierarchy_2:: insert_point(const Point_2& p, const Storage_site_2& ss, int level, Vertex_handle* vertices) { CGAL_precondition( level != UNDEFINED_LEVEL ); int new_level = level; Vertex_handle vertex; Vertex_handle vnear[svd_hierarchy_2__maxlevel]; Site_2 t = Site_2::construct_site_2(p); nearest_neighbor(t, vnear, false); size_type n = hierarchy[0]->number_of_vertices(); if ( n > 2 ) { Arrangement_type at_res = this->arrangement_type(t, vnear[0]); CGAL_assertion( at_res == AT2::DISJOINT || at_res == AT2::INTERIOR || at_res == AT2::IDENTICAL ); if ( vnear[0]->is_point() ) { if ( at_res == AT2::IDENTICAL ) { vertex = vnear[0]; } else { vertex = hierarchy[0]->insert_point2(ss, t, vnear[0]); } } else { // nearest neighbor is a segment CGAL_assertion( vnear[0]->is_segment() ); CGAL_assertion( at_res == AT2::DISJOINT || at_res == AT2::INTERIOR ); if ( at_res == AT2::INTERIOR ) { CGAL_assertion( t.is_input() ); int vnear_level = find_level(vnear[0]); // I need to find the level of the nearest neighbor that t // lies on and update the level of t if ( new_level < vnear_level ) { new_level = vnear_level; } Vertex_triple vt = hierarchy[0]->insert_exact_point_on_segment(ss, t, vnear[0]); vertex = vt.first; } else { vertex = hierarchy[0]->insert_point2(ss, t, vnear[0]); } } } else if ( n == 0 ) { vertex = hierarchy[0]->insert_first(ss, p); } else if ( n == 1 ) { vertex = hierarchy[0]->insert_second(ss, p); } else if ( n == 2 ) { vertex = hierarchy[0]->insert_third(ss, p); } CGAL_assertion( vertex != Vertex_handle() ); if ( vertices != NULL ) { vertices[0] = vertex; } // insert at other levels Vertex_handle previous = vertex; // Storage_site_2 ss = vertex->storage_site(); int k = 1; while ( k <= new_level ) { int nv = hierarchy[k]->number_of_vertices(); if ( nv > 2 ) { vertex = hierarchy[k]->insert_point(ss, t, vnear[k]); } else if ( nv == 2 ) { vertex = hierarchy[k]->insert_third(t, ss); } else { // nv == 0 || nv == 1 vertex = hierarchy[k]->insert_no_register(ss, p, vnear[k]); } CGAL_assertion( vertex != Vertex_handle() ); if ( vertices != NULL ) { vertices[k] = vertex; } vertex->set_down(previous); // link with other levels previous->set_up(vertex); previous = vertex; k++; } } template void Segment_Voronoi_diagram_hierarchy_2:: insert_point(const Site_2& t, const Storage_site_2& ss, int low, int high, Vertex_handle vbelow, Vertex_handle* vertices) { CGAL_precondition( low >= 0 && low <= high ); CGAL_precondition( (low == 0 && vbelow == Vertex_handle()) || (low > 0 && vbelow != Vertex_handle()) ); Vertex_handle vertex; Vertex_handle vnear[svd_hierarchy_2__maxlevel]; nearest_neighbor(t, vnear, false); Vertex_handle previous = vbelow; // insert at all levels int k = low; while ( k <= high ) { // MK::ERROR: this is a hack. I need to change the code in the // segment Voronoi diagram class, so that I can insert sites as // the first, second, or third site...; actually this is // problematic only if the number of vertices is exactly 2; it // cannot be smaller since we already have added the endpoints // of the segment at level k. size_type n = hierarchy[k]->number_of_vertices(); if ( n > 2 ) { vertex = hierarchy[k]->insert_point(ss, t, vnear[k]); } else if ( n == 2 ) { vertex = hierarchy[k]->insert_third(t, ss); } else { if ( ss.is_input() ) { vertex = hierarchy[k]->insert_no_register(ss, t.point(), vnear[k]); } else { break; } // ideally what should be instead of the break-statement above is the // following statement(s) in the #if-#endif block #if 0 } else if ( n == 1 ) { vertex = hierarchy[k]->insert_second(t, ss); } else { CGAL_assertion( n == 0 ); vertex = hierarchy[k]->insert_first(t, ss); #endif } CGAL_assertion( vertex != Vertex_handle() ); if ( vertices != NULL ) { vertices[k] = vertex; } vertex->set_down(previous); // link with other levels previous->set_up(vertex); previous = vertex; k++; } } //-------------------------------------------------------------------- // insertion of a segment //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_hierarchy_2::Vertex_handle Segment_Voronoi_diagram_hierarchy_2:: insert_segment(const Point_2& p0, const Point_2& p1, const Storage_site_2& ss, int level/*, Tag_true stag*/) { // the tag is true so we DO insert segments in hierarchy if ( level == UNDEFINED_LEVEL ) { level = random_level(); } Site_2 t = Site_2::construct_site_2(p0, p1); if ( is_degenerate_segment(t) ) { return insert_point(p0, ss.source_site(), level); } Vertex_handle vertices0[svd_hierarchy_2__maxlevel]; Vertex_handle vertices1[svd_hierarchy_2__maxlevel]; insert_point(p0, ss.source_site(), level, vertices0); #if 0 insert_point(p1, level, vertices1); #else // this way may be faster... vertices1[0] = hierarchy[0]->insert_no_register(ss.target_site(), p1, vertices0[0]); if ( level >= 1 ) { Storage_site_2 ss1 = vertices1[0]->storage_site(); insert_point(ss1.site(), ss1, 1, level, vertices1[0], vertices1); } #endif CGAL_assertion( vertices0[0] != Vertex_handle() ); CGAL_assertion( vertices1[0] != Vertex_handle() ); Vertex_handle vertex; if ( hierarchy[0]->number_of_vertices() == 2 ) { static Segments_in_hierarchy_tag stag; vertex = hierarchy[0]->insert_third(ss, vertices0[0], vertices1[0]); insert_segment_in_upper_levels(t, vertex->storage_site(), vertex, vertices0, level, stag); } else { vertex = insert_segment_interior(t, ss, vertices0, level); } return vertex; } template typename Segment_Voronoi_diagram_hierarchy_2::Vertex_handle Segment_Voronoi_diagram_hierarchy_2:: insert_segment_interior(const Site_2& t, const Storage_site_2& ss, const Vertex_handle* vertices, int level) { // insert the interior of a segment, and DO insert segments in // upper levels of the hierarchy CGAL_precondition( t.is_segment() ); CGAL_precondition( this->number_of_vertices() >= 2 ); CGAL_assertion( vertices[0] != Vertex_handle() ); // MK: add here code that checks if the inserted segment has already // been inserted; MAYBE THIS IS NOT NEEDED; I ALREADY DO IT IN // arrangement_type // the tags static Intersections_tag itag; static Segments_in_hierarchy_tag stag; // find the first conflict // first look if there are intersections... Vertex_circulator vc = vertices[0]->incident_vertices(); Vertex_circulator vc_start = vc; do { Vertex_handle vv(vc); if ( is_infinite(vv) ) { vc++; continue; } Arrangement_type at_res = this->arrangement_type(t, vv); if ( vv->is_segment() ) { if ( at_res == AT2::DISJOINT || at_res == AT2::TOUCH_1 || at_res == AT2::TOUCH_2 || at_res == AT2::TOUCH_11 || at_res == AT2::TOUCH_12 || at_res == AT2::TOUCH_21 || at_res == AT2::TOUCH_22 ) { // do nothing } else if ( at_res == AT2::IDENTICAL ) { return vv; } else if ( at_res == AT2::CROSSING ) { return insert_intersecting_segment_with_tag(ss, t, vv, level, itag, stag); } else if ( at_res == AT2::TOUCH_11_INTERIOR_1 ) { #if 1 Vertex_handle vp = second_endpoint_of_segment(vv); return insert_segment_on_point(ss, vp, level, stag, 1); #else Vertex_handle vp = second_endpoint_of_segment(vv); Storage_site_2 ssvp = vp->storage_site(); Site_2 svp = ssvp.site(); Vertex_handle vp_vnear[svd_hierarchy_2__maxlevel]; nearest_neighbor(svp, vp_near, false); int vp_level = find_level(vp); if ( vp_level < level ) { Vertex_handle vbelow = vp_vertices[vp_level]; insert_point(svp, ssvp, vp_level + 1, level, vbelow, vp_vnear); } Storage_site_2 sss = split_storage_site(ss, svp, 1, itag); return insert_segment_interior(sss.site(), sss, vp_vnear, level); #endif } else if ( at_res == AT2::TOUCH_12_INTERIOR_1 ) { #if 1 Vertex_handle vp = first_endpoint_of_segment(vv); return insert_segment_on_point(ss, vp, level, stag, 0); #else Vertex_handle vp = first_endpoint_of_segment(vv); Storage_site_2 ssvp = vp->storage_site(); Site_2 svp = ssvp.site(); Vertex_handle vp_vnear[svd_hierarchy_2__maxlevel]; nearest_neighbor(svp, vp_near, false); int vp_level = find_level(vp); if ( vp_level < level ) { Vertex_handle vbelow = vp_vertices[vp_level]; insert_point(svp, ssvp, vp_level + 1, level, vbelow, vp_vnear); } Storage_site_2 sss = split_storage_site(ss, ssvp, 0, itag); return insert_segment_interior(sss.site(), sss, vp_vnear, level); #endif } else { // this should never be reached; the only possible values for // at_res are DISJOINT, CROSSING, TOUCH_11_INTERIOR_1 // and TOUCH_12_INTERIOR_1 CGAL_assertion( false ); } } else { CGAL_assertion( vv->is_point() ); if ( at_res == AT2::INTERIOR ) { Storage_site_2 svv = vv->storage_site(); if ( svv.is_input() ) { #if 1 return insert_segment_on_point(ss, vv, level, stag, 2); #else //************************************************************ //************************************************************ //************************************************************ //************************************************************ // here I need a new method: insert_segment_on_point // which will do the splitting and arrange the hierarchy // pointers //************************************************************ //************************************************************ //************************************************************ //************************************************************ Storage_site_2 ss1 = this->split_storage_site(ss, svv, 0, itag); Storage_site_2 ss2 = this->split_storage_site(ss, svv, 1, itag); CGAL_assertion( false ); return Vertex_handle(); // insert_segment_interior(ss1.site(), ss1, vv); // return insert_segment_interior(ss2.site(), ss2, vv); #endif } else { // MK::ERROR:: not ready yet CGAL_assertion( false ); } } } ++vc; } while ( vc != vc_start ); // first look for conflict with vertex Face_circulator fc_start = vertices[0]->incident_faces(); Face_circulator fc = fc_start; Face_handle start_f; Sign s; std::map sign_map; do { Face_handle f(fc); s = incircle(f, t); sign_map[f] = s; if ( s == NEGATIVE ) { start_f = f; break; } ++fc; } while ( fc != fc_start ); // segments must have a conflict with at least one vertex CGAL_assertion( s == NEGATIVE ); // we are in conflict with a Voronoi vertex; start from that and // find the entire conflict region and then repair the diagram List l; Face_map fm; Triple vcross(false, Vertex_handle(), AT2::DISJOINT); hierarchy[0]->initialize_conflict_region(start_f, l); hierarchy[0]->expand_conflict_region(start_f, t, ss, l, fm, sign_map, vcross); CGAL_assertion( vcross.third == AT2::DISJOINT || vcross.third == AT2::CROSSING || vcross.third == AT2::INTERIOR ); // the following condition becomes true only if intersecting // segments are found if ( vcross.first ) { if ( t.is_segment() ) { if ( vcross.third == AT2::CROSSING ) { Intersections_tag itag; return insert_intersecting_segment_with_tag(ss, t, vcross.second, level, itag, stag); } else if ( vcross.third == AT2::INTERIOR ) { #if 1 return insert_segment_on_point(ss, vcross.second, level, stag, 2); #else Storage_site_2 ssvv = vcross.second->storage_site(); Intersections_tag itag; //************************************************************ //************************************************************ //************************************************************ //************************************************************ // here I need a new method: insert_segment_on_point // which will do the splitting and arrange the hierarchy // pointers //************************************************************ //************************************************************ //************************************************************ //************************************************************ Storage_site_2 ss1 = this->split_storage_site(ss, ssvv, 0, itag); Storage_site_2 ss2 = this->split_storage_site(ss, ssvv, 1, itag); CGAL_assertion( false ); return Vertex_handle(); // insert_segment_interior(ss1.site(), ss1, vcross.second); // return insert_segment_interior(ss2.site(), ss2, vcross.second); #endif } else { // this should never be reached; the only possible values for // vcross.third are CROSSING, INTERIOR and DISJOINT CGAL_assertion( false ); } } } // no intersecting segment has been found; we insert the segment as // usual... Vertex_handle v = hierarchy[0]->create_vertex(ss); hierarchy[0]->retriangulate_conflict_region(v, l, fm); insert_segment_in_upper_levels(t, ss, v, vertices, level, stag); return v; } template void Segment_Voronoi_diagram_hierarchy_2:: insert_segment_in_upper_levels(const Site_2& t, const Storage_site_2& ss, Vertex_handle vbelow, const Vertex_handle* vertices, int level, Tag_true stag) { CGAL_precondition( vertices != NULL ); // insert at all upper levels Vertex_handle previous = vbelow; Vertex_handle vertex = vbelow; int k = 1; while ( k <= level ) { if ( hierarchy[k]->number_of_vertices() == 2 ) { Vertex_handle v0(hierarchy[k]->finite_vertices_begin()); Vertex_handle v1(++(hierarchy[k]->finite_vertices_begin())); CGAL_precondition( v0 != Vertex_handle() && v1 != Vertex_handle() ); vertex = hierarchy[k]->insert_third(ss, v0, v1); } else { vertex = hierarchy[k]->insert_segment_interior(t, ss, vertices[k]); } CGAL_assertion( vertex != Vertex_handle() ); vertex->set_down(previous); // link with level above previous->set_up(vertex); previous = vertex; k++; } } //-------------------------------------------------------------------- // insertion of a segment that goes through a point //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_hierarchy_2::Vertex_handle Segment_Voronoi_diagram_hierarchy_2:: insert_segment_on_point(const Storage_site_2& ss, const Vertex_handle& v, int level, Tag_true stag, int which) { // inserts the segment represented by ss in the case where this // segment goes through a point which has already been inserted and // corresponds to the vertex handle v CGAL_precondition( ss.is_segment() ); CGAL_precondition( v->is_point() ); Storage_site_2 ssv = v->storage_site(); Site_2 sv = ssv.site(); Vertex_handle vnear[svd_hierarchy_2__maxlevel]; nearest_neighbor(sv, vnear, false); int v_level = find_level(v); if ( v_level < level ) { Vertex_handle vbelow = vnear[v_level]; insert_point(sv, ssv, v_level + 1, level, vbelow, vnear); } Intersections_tag itag; if ( which == 2 ) { Storage_site_2 ss1 = this->split_storage_site(ss, ssv, 0, itag); Storage_site_2 ss2 = this->split_storage_site(ss, ssv, 1, itag); insert_segment_interior(ss1.site(), ss1, vnear, level); return insert_segment_interior(ss2.site(), ss2, vnear, level); } else { Storage_site_2 ss1 = this->split_storage_site(ss, ssv, which, itag); return insert_segment_interior(ss1.site(), ss1, vnear, level); } } //-------------------------------------------------------------------- // insertion of an intersecting segment //-------------------------------------------------------------------- template typename Segment_Voronoi_diagram_hierarchy_2::Vertex_handle Segment_Voronoi_diagram_hierarchy_2:: insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, int level, Tag_true itag, Tag_false stag) { CGAL_precondition( t.is_segment() && v->is_segment() ); const Storage_site_2& ssitev = v->storage_site(); Site_2 sitev = ssitev.site(); if ( same_segments(t, sitev) ) { return v; } Vertex_triple vt = hierarchy[0]->insert_point_on_segment(ss, t, v, itag); Vertex_handle verticesx[svd_hierarchy_2__maxlevel]; Vertex_handle vsx = vt.first; verticesx[0] = vsx; bool compute_new_level = true; int new_level = compute_new_level ? random_level() : level; if ( new_level > 0 ) { Storage_site_2 ssx = vsx->storage_site(); Site_2 sx = ssx.site(); insert_point(sx, ssx, 1, new_level, vsx, verticesx); } Storage_site_2 ss3, ss4; Site_2 s3, s4; if ( t.is_input(0) ) { ss3 = create_storage_site(ss, ssitev, true); } else { ss3 = create_storage_site_type1(ss, ss, ssitev); } s3 = ss3.site(); if ( t.is_input(1) ) { ss4 = create_storage_site(ss, ssitev, false); } else { ss4 = create_storage_site_type2(ss, ssitev, ss); } s4 = ss4.site(); insert_segment_interior(s3, ss3, verticesx, level); insert_segment_interior(s4, ss4, verticesx, level); return vsx; } template typename Segment_Voronoi_diagram_hierarchy_2::Vertex_handle Segment_Voronoi_diagram_hierarchy_2:: insert_intersecting_segment_with_tag(const Storage_site_2& ss, const Site_2& t, Vertex_handle v, int level, Tag_true itag, Tag_true stag) { CGAL_precondition( t.is_segment() && v->is_segment() ); CGAL_expensive_precondition( arrangement_type(t, v->site()) ); const Storage_site_2& ssitev = v->storage_site(); Site_2 sitev = ssitev.site(); if ( same_segments(t, sitev) ) { // MK::ERROR: I may need to insert it to levels higher than its // previous level... return v; } Vertex_handle verticesx[svd_hierarchy_2__maxlevel]; int levelv = find_level(v); Vertex_handle vcross = v; Vertex_handle v1_old, v2_old, vsx_old; int k = 0; while ( k <= levelv ) { // MK::ERROR: I have to remove this; too expensive... CGAL_expensive_precondition( arrangement_type(t, vertex->site()) ); Vertex_handle vcross_up = vcross->up(); Vertex_triple vt = hierarchy[k]->insert_point_on_segment(ss, t, vcross, itag); // now I need to update the sites for vertices v1 and v2 Vertex_handle vsx = vt.first; Vertex_handle v1 = vt.second; Vertex_handle v2 = vt.third; CGAL_assertion( v1->is_segment() && v2->is_segment() ); if ( k > 0 ) { if ( same_segments(v1->site(), v1_old->site()) ) { v1->set_down(v1_old); v2->set_down(v2_old); v1_old->set_up(v1); v2_old->set_up(v2); } else { v1->set_down(v2_old); v2->set_down(v1_old); v1_old->set_up(v2); v2_old->set_up(v1); } vsx_old->set_up(vsx); vsx->set_down(vsx_old); } v1_old = v1; v2_old = v2; vsx_old = vsx; verticesx[k] = vsx; vcross = vcross_up; k++; } if ( levelv < level ) { Storage_site_2 ssx = verticesx[0]->storage_site(); Site_2 sx = ssx.site(); insert_point(sx, ssx, levelv + 1, level, verticesx[levelv], verticesx); } Storage_site_2 ss3, ss4; Site_2 s3, s4; if ( t.is_input(0) ) { ss3 = create_storage_site(ss, ssitev, true); } else { ss3 = create_storage_site_type1(ss, ss, ssitev); } s3 = ss3.site(); if ( t.is_input(1) ) { ss4 = create_storage_site(ss, ssitev, false); } else { ss4 = create_storage_site_type2(ss, ssitev, ss); } s4 = ss4.site(); insert_segment_interior(s3, ss3, verticesx, level); insert_segment_interior(s4, ss4, verticesx, level); return verticesx[0]; } //=========================================================================== //=========================================================================== //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // nearest neighbor location //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template typename Segment_Voronoi_diagram_hierarchy_2::Vertex_handle Segment_Voronoi_diagram_hierarchy_2:: nearest_neighbor(const Point_2& p, bool force_point) const { Vertex_handle vnear[svd_hierarchy_2__maxlevel]; // nearest_neighbor(Site_2(p), vnear, force_point); Site_2 t = Site_2::construct_site_2(p); nearest_neighbor(t, vnear, force_point); return vnear[0]; } template void Segment_Voronoi_diagram_hierarchy_2:: nearest_neighbor(const Site_2& t, Vertex_handle vnear[svd_hierarchy_2__maxlevel], bool force_point) const { CGAL_precondition( t.is_point() ); Vertex_handle nearest; int level = svd_hierarchy_2__maxlevel; // find the highest level with enough vertices while ( hierarchy[--level]->number_of_vertices() < svd_hierarchy_2__minsize ) { if ( !level ) break; // do not go below 0 } for (unsigned int i = level + 1; i < svd_hierarchy_2__maxlevel; i++) { vnear[i] = Vertex_handle(); } while ( level > 0 ) { vnear[level] = nearest = hierarchy[level]->nearest_neighbor(t, nearest); CGAL_assertion( !hierarchy[level]->is_infinite(vnear[level]) ); CGAL_assertion( vnear[level] != Vertex_handle() ); // go at the same vertex on level below nearest = nearest->down(); --level; } vnear[0] = hierarchy[0]->nearest_neighbor(t, nearest); // at level 0 } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // miscellaneous methods //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template void Segment_Voronoi_diagram_hierarchy_2:: copy(const Segment_Voronoi_diagram_hierarchy_2 &svd) { #ifndef CGAL_NO_ASSERTIONS for (unsigned int i = 1; i < svd_hierarchy_2__maxlevel; ++i) { CGAL_assertion( hierarchy[i]->pc_.size() == 0 ); CGAL_assertion( hierarchy[i]->isc_.size() == 0 ); CGAL_assertion( svd.hierarchy[i]->pc_.size() == 0 ); CGAL_assertion( svd.hierarchy[i]->isc_.size() == 0 ); } #endif // first copy the point container and input point container this->pc_ = svd.pc_; // first create a map between the old point handles and the new ones Handle_map hm; Point_handle it_other = svd.hierarchy[0]->pc_.begin(); Point_handle it_this = hierarchy[0]->pc_.begin(); for (; it_other != svd.hierarchy[0]->pc_.end(); ++it_other, ++it_this) { hm.insert( Point_handle_pair(it_other, it_this) ); } { for(unsigned int i = 0; i < svd_hierarchy_2__maxlevel; ++i) { hierarchy[i]->copy(*svd.hierarchy[i], hm); } } //up and down have been copied in straightforward way // compute a map at lower level std::map< Vertex_handle, Vertex_handle > V; { for(Finite_vertices_iterator it = hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) { if ( it->up() != Vertex_handle() ) { V[ it->up()->down() ] = it; } } } { for(unsigned int i = 1; i < svd_hierarchy_2__maxlevel; ++i) { for(Finite_vertices_iterator it = hierarchy[i]->finite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) { // down pointer goes in original instead in copied triangulation it->set_down(V[it->down()]); // make reverse link it->down()->set_up( it ); // make map for next level if ( it->up() != Vertex_handle() ) { V[ it->up()->down() ] = it; } } } } // the point container and the input sites container are copied by // the operator= of the one-level classes // hierarchy[0]->pc_ = svd.hierarchy[0]->pc_; // hierarchy[0]->isc_ = svd.hierarchy[0]->isc_; } template void Segment_Voronoi_diagram_hierarchy_2:: clear() { for(unsigned int i = 0; i < svd_hierarchy_2__maxlevel; ++i) { hierarchy[i]->clear(); } } template void Segment_Voronoi_diagram_hierarchy_2:: swap(Segment_Voronoi_diagram_hierarchy_2& other) { Base* temp; Base::swap(other); for(unsigned int i = 1; i < svd_hierarchy_2__maxlevel; ++i) { temp = hierarchy[i]; hierarchy[i] = other.hierarchy[i]; other.hierarchy[i]= temp; } } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // validity check //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template bool Segment_Voronoi_diagram_hierarchy_2:: is_valid(bool verbose, int level) const { bool result(true); //verify correctness of triangulation at all levels for(unsigned int i = 0; i < svd_hierarchy_2__maxlevel; ++i) { if ( verbose ) { std::cerr << "Level " << i << ": " << std::flush; } result = result && hierarchy[i]->is_valid(verbose, level); if ( verbose ) { std::cerr << std::endl; } } //verify that lower level has no down pointers for( Finite_vertices_iterator it = hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) { result = result && ( it->down() == Vertex_handle() ); } //verify that other levels has down pointer and reciprocal link is fine for(unsigned int i = 1; i < svd_hierarchy_2__maxlevel; ++i) { for( Finite_vertices_iterator it = hierarchy[i]->finite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) { Vertex_handle vit(it); result = result && ( it->down()->up() == vit ); } } return result; } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- // local helper methods //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- template void Segment_Voronoi_diagram_hierarchy_2:: print_error_message() const { std::cerr << std::endl; std::cerr << "WARNING:" << std::endl; std::cerr << "A segment-segment intersection was found." << std::endl; std::cerr << "The segment Voronoi diagram class is not configured" << " to handle this situation." << std::endl; std::cerr << "Please look at the documentation on how to handle" << " this behavior." << std::endl; std::cerr << std::endl; } //-------------------------------------------------------------------- CGAL_END_NAMESPACE // EOF mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2_2.h0000644000175000017500000000321611344301500030343 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTION_2_2_H #define CGAL_INTERSECTION_2_2_H #include #include #include #include #include #include #include #include #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Td_dag.h0000644000175000017500000002467111344301501026366 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Td_dag.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan /* Directed acyclic binary graph template class */ #ifndef CGAL_TD_DAG_H #define CGAL_TD_DAG_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Td_dag_base : public Handle { public: //iddo (for CC-7.2) maybe protected? typedef T * pointer; typedef T & reference; typedef const T & const_reference; protected: void init() { PTR = 0; } public: Td_dag_base() {init();} Td_dag_base(const Td_dag_base & x) : Handle(x) {} Td_dag_base & operator=(const Td_dag_base & x) {Handle::operator=(x); return *this; } bool operator!() const { return PTR == 0; } }; template class Td_dag : public Td_dag_base { public: typedef T* pointer; typedef T& reference; typedef const T& const_reference; typedef Td_dag_base Td_dag_handle; typedef Td_dag Self; typedef std::list list_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 public: using Td_dag_handle::PTR; using Td_dag_handle::operator!; #endif protected: class node : public Rep { #ifndef __BORLANDC__ friend class Td_dag; #else typedef Td_dag Td_dag; friend class Td_dag; #endif public: node(const T& e,unsigned long _depth=0) : data(e),leftPtr(),rightPtr(),depth_(_depth){} node(const T& e, const Td_dag_handle& left, const Td_dag_handle& right,unsigned long _depth=0) : data(e),leftPtr(left),rightPtr(right),depth_(_depth){} // node(const T& e) : data(e),leftPtr(),rightPtr(){} // node(const T& e, const Td_dag_handle& left, // const Td_dag_handle& right) : data(e),leftPtr(left),rightPtr(right) {} ~node(){} bool is_inner_node() const {return !!leftPtr && !!rightPtr;} bool visited() const {return visited_;} protected: T data; // information stored in node Td_dag_handle leftPtr,rightPtr; mutable unsigned long depth_; mutable bool visited_; }; public: /* -------constructors destructors -----*/ Td_dag(){} Td_dag(const Td_dag_handle& dag):Td_dag_handle(dag){} Td_dag(const Self& dag):Td_dag_handle(dag){} Td_dag(const T& rootValue){PTR = new node(rootValue);} Td_dag(const T& rootValue, const Self& left, const Self& right) {PTR = new node(rootValue, left, right); rebalance_depth();} ~Td_dag(){} /* --------information retrieval -------*/ const Self& left() const { CGAL_precondition(!operator!()); return *(const Self*)&ptr()->leftPtr; } const Self& right() const { CGAL_precondition(!operator!()); return *(const Self*)&ptr()->rightPtr; } reference get_data() const { CGAL_precondition(!operator!()); return ptr()->data; } reference operator*() const { return get_data(); } pointer get_data_ptr() const { CGAL_precondition(!operator!()); return &operator*(); } pointer operator->() const { return get_data_ptr(); } bool is_inner_node() const {return !operator!() && ptr()->is_inner_node();} unsigned long size() const { visit_none(); return recursive_size(); } unsigned long depth() const { visit_none(); return recursive_depth(); } bool operator==(const Self& b) const { return PTR==b.PTR; } bool operator!=(const Self& b) const { return !operator==(b); } /* dynamic management ---------*/ /* description: Shallow copy */ Self& operator=(const Self& b) { Handle::operator=(b); return *this; } /* Self& deep_copy(const Self& b) { if (this != &b) { clear(); operator=(b); } return *this; } void clear() { if (!operator!()) { left().clear(); right().clear(); operator=(Self()); } } void detach_left() { if (!operator!()) { // create dummy Td_dag T tmp; Self dummy(tmp); // detach left son,redirect to dummy set_left(dummy); // set left son pointer to 0 ptr()->leftPtr.PTR=0; // delete dummy Td_dag delete dummy.ptr(); } } void detach_right() { if (!operator!()) { // create dummy Td_dag T tmp; Self dummy(tmp); // detach right son,redirect to dummy set_right(dummy); // set right son pointer to 0 ptr()->rightPtr.PTR=0; // delete dummy Td_dag delete dummy.ptr(); } } void detach() { detach_left(); detach_right(); } */ void set_data(const T& data) { if (!operator!()) ptr()->data=data; else operator=(Self(data)); } void set_depth(unsigned long _depth) const { ptr()->depth_=_depth; } void set_left(const Self& left) { CGAL_precondition(!operator!()); ptr()->leftPtr=left; if (left.depth()depth_=depth()+1; left.rebalance_depth(); // does nothing if right is a leaf } void set_right(const Self& right) { CGAL_precondition(!operator!()); ptr()->rightPtr=right; if (right.depth()depth_=depth()+1; right.rebalance_depth(); // does nothing if right is a leaf } void replace(const T& data,const Self& left,const Self& right) { set_data(data); set_left(left); set_right(right); } // Td_dag implementation not thread safe! void visit_none() const { if (!operator!()) { ptr()->visited_=false; left().visit_none(); right().visit_none(); } } void visit_one() const { if (!operator!()) ptr()->visited_=true; } /* -----output ---------------*/ #ifdef CGAL_PRE_IN_POST_ORDER void preorder() const { if (!operator!()) { std::cout << operator*() << '\t'; left().preorder(); right().preorder(); } } void inorder() const { if (!operator!()) { left().inorder(); std::cout << operator*() << '\t'; right().inorder(); } } void postorder() const { if (!operator!()) { left().postorder(); right().postorder(); std::cout << operator*() << '\t'; } } #endif #if _MSC_VER>=1100 friend std::ostream& operator<<(std::ostream& out, const Self& t); #endif template Container& filter(Container& c,const Predicate& pr) const { visit_none(); return recursive_filter(c,pr); } #if 0 template Container& hash_filter(Container& c,const Predicate& pr) const { visit_none(); return recursive_hash_filter(c,pr); } #endif protected: void rebalance_depth() const { if (is_inner_node()) { unsigned long depth_=depth(); if (left().depth()visited()) return 1+left().recursive_size()+right().recursive_size(); else return 0; } unsigned long recursive_depth() const { if (!operator!() && !ptr()->visited()) return 1+ std::max(left().recursive_depth(),right().recursive_depth()); else return 0; } template Container& recursive_filter(Container& c,const Predicate& pr) const { if (!operator!() && !ptr()->visited()) { if (pr(operator*())) c.insert(c.end(),operator*()); visit_one(); left().recursive_filter(c,pr); right().recursive_filter(c,pr); } return c; } #if 0 template Container& recursive_hash_filter(Container& c, const Predicate& ptr) const /* Generate a copy of the Dag filtered according to the predicate */ { if (!operator!() && !ptr()->visited()) { if (pr(operator*())) c.insert(pair<&operator*(), new X_trapezoid(operator*())); // The hash links between the old trapezoid to the new one. visit_one(); left().recursive_hash_filter(c,pr); right().recursive_hash_filter(c,pr); } return c; } #endif private: node* ptr() const {return (node*)PTR;} }; template std::ostream& write(std::ostream& out, const Td_dag& t, const Traits& traits) { static int depth; int i; if (!!t) { out << "\n"; for(i=0;i"; out << "Data="; write(out,*t,traits); { depth++; out << "\n"; for(i=0;i"; out << "left="; write(out,t.left(),traits); out << "\n"; for(i=0;i"; out << "right="; write(out,t.right(),traits); depth--; } } else { out << "Empty"; } return out ; } template std::ostream& operator<<(std::ostream& out, const Td_dag& t) { static int depth; int i; if (!!t) { out << "\n"; for(i=0;i"; out << "Data=" << *t; { depth++; out << "\n"; for(i=0;i"; out << "left=" << t.left(); out << "\n"; for(i=0;i"; out << "right=" < #ifndef CGAL_INDIRECT_EDGE_COMPARE_H #define CGAL_INDIRECT_EDGE_COMPARE_H namespace CGAL { // // given circulators to endpoints of two edges, sorts the edges that come // next (in the direction of circulator) from right to left. This ordering // makes finding the edge directly left of a given edge (needed for the // y-monotone decomposition algorithm) easy. // template class Indirect_edge_compare { public: typedef typename Traits::Compare_y_2 Compare_y_2; typedef typename Traits::Compare_x_2 Compare_x_2; typedef typename Traits::Construct_line_2 Construct_line_2; typedef typename Traits::Compare_x_at_y_2 Compare_x_at_y_2; typedef typename Traits::Is_horizontal_2 Is_horizontal_2; typedef typename Traits::Line_2 Line_2; typedef typename Traits::Point_2 Point_2; Indirect_edge_compare() : _compare_y_2(Traits().compare_y_2_object()), _compare_x_2(Traits().compare_x_2_object()), _construct_line_2(Traits().construct_line_2_object()), _compare_x_at_y_2(Traits().compare_x_at_y_2_object()), _is_horizontal_2(Traits().is_horizontal_2_object()) { } // determines if the edge (edge_vtx_1, edge_vtx_1++) has a larger // x value than vertex.x at y-value vertex.y bool larger_x_at_vertex_y(ForwardCirculator edge_vtx_1, ForwardCirculator vertex) const { ForwardCirculator edge_vtx_2 = edge_vtx_1; edge_vtx_2++; // check for horizontal edge if (_compare_y_2((*edge_vtx_1), (*edge_vtx_2)) == EQUAL) { // compare the smaller x and vertex x if (_compare_x_2(*edge_vtx_1, *edge_vtx_2) == SMALLER) return _compare_x_2(*edge_vtx_1, *vertex) == LARGER; else return _compare_x_2(*edge_vtx_2, *vertex) == LARGER; } else { // construct supporting line for edge Line_2 line = _construct_line_2(*edge_vtx_1, *edge_vtx_2); return _compare_x_at_y_2(*vertex, line) == SMALLER; } } bool operator()(ForwardCirculator p, ForwardCirculator q) const { ForwardCirculator after_p = p; after_p++; ForwardCirculator after_q = q; after_q++; if (p == q && after_p == after_q) return false; if (p == after_q) { return larger_x_at_vertex_y(p, q); } else if (after_p == q) { return !larger_x_at_vertex_y(q, p); } else if (p == q) { return larger_x_at_vertex_y(p, after_q); } else if (after_p == after_q) { return larger_x_at_vertex_y(p, q); } else // neither endpoint is shared { // construct supporting line Line_2 l_p = _construct_line_2(*p, *after_p); if (_is_horizontal_2(l_p)) { Line_2 l_q = _construct_line_2(*q, *after_q); if (_is_horizontal_2(l_q)) { Point_2 p_max; Point_2 q_max; if (_compare_x_2(*p, *after_p) == SMALLER) p_max = *after_p; else p_max = *p; if (_compare_x_2(*q, *after_q) == SMALLER) q_max = *after_q; else q_max = *q; return (_compare_x_2(p_max, q_max) == LARGER); } else // p and after_p must both be on same side of l_q { return (_compare_x_at_y_2(*p, l_q) == LARGER); } } else { bool q_larger_x = _compare_x_at_y_2(*q, l_p) == SMALLER; bool after_q_larger_x = _compare_x_at_y_2(*after_q, l_p) == SMALLER; if (q_larger_x == after_q_larger_x) return q_larger_x; else // one smaller and one larger { // construct the other line Line_2 l_q = _construct_line_2(*q, *after_q); if (_is_horizontal_2(l_q)) // p is not horizontal { return _compare_x_at_y_2((*q), l_p) == LARGER; } else { return _compare_x_at_y_2((*p), l_q) != SMALLER; } } } } } private: Compare_y_2 _compare_y_2; Compare_x_2 _compare_x_2; Construct_line_2 _construct_line_2; Compare_x_at_y_2 _compare_x_at_y_2; Is_horizontal_2 _is_horizontal_2; }; } #endif // CGAL_INDIRECT_EDGE_COMPARE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Plane_separator.h0000644000175000017500000000403011344301500030305 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Plane_separator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_PLANE_SEPARATOR_H #define CGAL_PLANE_SEPARATOR_H namespace CGAL { template < class FT> class Plane_separator { public: int cutting_dim; FT cutting_val; inline int cutting_dimension() const { return cutting_dim;} inline FT cutting_value() const { return cutting_val;} void set_cutting_dimension(int d) { cutting_dim=d; } void set_cutting_value(FT val) { cutting_val=val; } template inline bool has_on_negative_side(const Point& i) { return i[cutting_dimension()] < cutting_value(); } Plane_separator(const int d, const FT& v) : cutting_dim(d), cutting_val(v) {} Plane_separator(const Plane_separator& s) : cutting_dim(s.cutting_dimension()), cutting_val(s.cutting_value()) {} explicit Plane_separator() : cutting_dim(0), cutting_val(0) {} Plane_separator& operator= (const Plane_separator& s) { cutting_dim = s.cutting_dimension(); cutting_val = s.cutting_value(); return *this; } ~Plane_separator() {} }; template < class FT> std::ostream& operator<< (std::ostream& s, Plane_separator& x) { s << "\n Separator coordinate: " << x.cutting_dimension() << " value: " << x.cutting_value() << "\n"; return s; } } // namespace CGAL #endif // CGAL_PLANE_SEPARATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_assertions.h0000644000175000017500000002702011344301500030036 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : script by Geert-Jan Giezeman and Sven Schoenherr // macro definitions // ================= // assertions // ---------- #if defined(CGAL_CH_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_ch_assertion(EX) ((void)0) # define CGAL_ch_assertion_msg(EX,MSG) ((void)0) # define CGAL_ch_assertion_code(CODE) #else # define CGAL_ch_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_assertion_code(CODE) CODE #endif // CGAL_CH_NO_ASSERTIONS #if defined(CGAL_CH_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_ch_exactness_assertion(EX) ((void)0) # define CGAL_ch_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_ch_exactness_assertion_code(CODE) #else # define CGAL_ch_exactness_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_exactness_assertion_code(CODE) CODE #endif // CGAL_CH_NO_ASSERTIONS #if defined(CGAL_CH_NO_ASSERTIONS) \ || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_assertion(EX) ((void)0) # define CGAL_ch_expensive_assertion_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_assertion_code(CODE) #else # define CGAL_ch_expensive_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_expensive_assertion_code(CODE) CODE #endif // CGAL_CH_NO_ASSERTIONS #if defined(CGAL_CH_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_exactness_assertion(EX) ((void)0) # define CGAL_ch_expensive_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_exactness_assertion_code(CODE) #else # define CGAL_ch_expensive_exactness_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_expensive_exactness_assertion_code(CODE) CODE #endif // CGAL_CH_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_CH_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_ch_precondition(EX) ((void)0) # define CGAL_ch_precondition_msg(EX,MSG) ((void)0) # define CGAL_ch_precondition_code(CODE) #else # define CGAL_ch_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_precondition_code(CODE) CODE #endif // CGAL_CH_NO_PRECONDITIONS #if defined(CGAL_CH_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_ch_exactness_precondition(EX) ((void)0) # define CGAL_ch_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_ch_exactness_precondition_code(CODE) #else # define CGAL_ch_exactness_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_exactness_precondition_code(CODE) CODE #endif // CGAL_CH_NO_PRECONDITIONS #if defined(CGAL_CH_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_precondition(EX) ((void)0) # define CGAL_ch_expensive_precondition_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_precondition_code(CODE) #else # define CGAL_ch_expensive_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_expensive_precondition_code(CODE) CODE #endif // CGAL_CH_NO_PRECONDITIONS #if defined(CGAL_CH_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_exactness_precondition(EX) ((void)0) # define CGAL_ch_expensive_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_exactness_precondition_code(CODE) #else # define CGAL_ch_expensive_exactness_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_expensive_exactness_precondition_code(CODE) CODE #endif // CGAL_CH_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_ch_postcondition(EX) ((void)0) # define CGAL_ch_postcondition_msg(EX,MSG) ((void)0) # define CGAL_ch_postcondition_code(CODE) #else # define CGAL_ch_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__,MSG)) # define CGAL_ch_postcondition_code(CODE) CODE #endif // CGAL_CH_NO_POSTCONDITIONS #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_ch_exactness_postcondition(EX) ((void)0) # define CGAL_ch_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_ch_exactness_postcondition_code(CODE) #else # define CGAL_ch_exactness_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__,MSG)) # define CGAL_ch_exactness_postcondition_code(CODE) CODE #endif // CGAL_CH_NO_POSTCONDITIONS #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_postcondition(EX) ((void)0) # define CGAL_ch_expensive_postcondition_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_postcondition_code(CODE) #else # define CGAL_ch_expensive_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__,MSG)) # define CGAL_ch_expensive_postcondition_code(CODE) CODE #endif // CGAL_CH_NO_POSTCONDITIONS #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_exactness_postcondition(EX) ((void)0) # define CGAL_ch_expensive_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_exactness_postcondition_code(CODE) #else # define CGAL_ch_expensive_exactness_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__,MSG)) # define CGAL_ch_expensive_exactness_postcondition_code(CODE) CODE #endif // CGAL_CH_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_CH_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_ch_warning(EX) ((void)0) # define CGAL_ch_warning_msg(EX,MSG) ((void)0) # define CGAL_ch_warning_code(CODE) #else # define CGAL_ch_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_warning_code(CODE) CODE #endif // CGAL_CH_NO_WARNINGS #if defined(CGAL_CH_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_ch_exactness_warning(EX) ((void)0) # define CGAL_ch_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_ch_exactness_warning_code(CODE) #else # define CGAL_ch_exactness_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_exactness_warning_code(CODE) CODE #endif // CGAL_CH_NO_WARNINGS #if defined(CGAL_CH_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_warning(EX) ((void)0) # define CGAL_ch_expensive_warning_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_warning_code(CODE) #else # define CGAL_ch_expensive_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_expensive_warning_code(CODE) CODE #endif // CGAL_CH_NO_WARNINGS #if defined(CGAL_CH_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_CH_CHECK_EXACTNESS) && !defined(CHECK_EXACTNESS))\ || (!defined(CGAL_CH_CHECK_EXPENSIVE) && !defined(CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_ch_expensive_exactness_warning(EX) ((void)0) # define CGAL_ch_expensive_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_ch_expensive_exactness_warning_code(CODE) #else # define CGAL_ch_expensive_exactness_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_ch_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_ch_expensive_exactness_warning_code(CODE) CODE #endif // CGAL_CH_NO_WARNINGS ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_traits_wrapper_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_trait0000644000175000017500000000244311344301500031457 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_traits_wrapper_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_TRAITS_WRAPPER_2_H #define CGAL_APOLLONIUS_GRAPH_TRAITS_WRAPPER_2_H #include CGAL_BEGIN_NAMESPACE template class Apollonius_graph_traits_wrapper_2 : public Gt_base { public: // struct Segment_2 {}; struct Triangle_2 {}; Apollonius_graph_traits_wrapper_2() {} Apollonius_graph_traits_wrapper_2(const Gt_base& gtb) : Gt_base(gtb) {} }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_TRAITS_WRAPPER_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_cell_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_cell_bas0000644000175000017500000000613211344301501031412 0ustar debiandebian // Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_cell_base_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud // cell of a triangulation of any dimension <=3 #ifndef CGAL_TRIANGULATION_CELL_BASE_3_H #define CGAL_TRIANGULATION_CELL_BASE_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename GT, typename Cb = Triangulation_ds_cell_base_3<> > class Triangulation_cell_base_3 : public Cb { public: typedef typename Cb::Vertex_handle Vertex_handle; typedef typename Cb::Cell_handle Cell_handle; typedef GT Geom_traits; typedef typename Geom_traits::Point_3 Point; typedef Point* Point_container; typedef Point* Point_iterator; typedef const Point* Point_const_iterator; template < typename TDS2 > struct Rebind_TDS { typedef typename Cb::template Rebind_TDS::Other Cb2; typedef Triangulation_cell_base_3 Other; }; Triangulation_cell_base_3() : Cb() {} Triangulation_cell_base_3(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3) : Cb(v0, v1, v2, v3) {} Triangulation_cell_base_3(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Cell_handle& n0, const Cell_handle& n1, const Cell_handle& n2, const Cell_handle& n3) : Cb(v0, v1, v2, v3, n0, n1, n2, n3) {} Point_iterator hidden_points_begin() const { return hidden_points_end(); } Point_iterator hidden_points_end() const { return NULL; } void hide_point (const Point &p) const { } }; // The following should be useless. #if 0 template < class GT, class Cb > inline std::istream& operator>>(std::istream &is, Triangulation_cell_base_3 &c) // non combinatorial information. Default = nothing { return is >> static_cast(c); } template < class GT, class Cb > inline std::ostream& operator<<(std::ostream &os, const Triangulation_cell_base_3 &c) // non combinatorial information. Default = nothing { return os << static_cast(c); } #endif CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_CELL_BASE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Hyperbola_segment_2.h0000644000175000017500000001055111344301500031063 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Hyperbola_segment_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_HYPERBOLA_SEGMENT_2_H #define CGAL_HYPERBOLA_SEGMENT_2_H #include CGAL_BEGIN_NAMESPACE template < class Gt > class Hyperbola_segment_2 : public Hyperbola_2< Gt > { public: typedef CGAL::Hyperbola_2 Base; typedef typename Base::Site_2 Site_2; typedef typename Base::Point_2 Point_2; typedef typename Base::Segment_2 Segment_2; typedef typename Base::FT FT; #if 0 typedef CGAL::Hyperbola_2 Base; typedef typename Base::Weighted_point Weighted_point; #endif // typedef typename R::RT FT; // typedef double FT; // typedef CGAL::Point_2< Cartesian > Point_2; // typedef CGAL::Segment_2< Cartesian > Segment_2; protected: Point_2 p1, p2; template< class Stream > inline void draw_line(Stream &W) const { #if 0 FT s[2]; s[0] = t(p1); s[1] = t(p2); Point_2 p[2]; for (int i = 0; i < 2; i++) p[i] = f(s[i]); W << Segment_2(p[0], p[1]); #else W << Segment_2(p1, p2); #endif } inline Point_2 midpoint() const { return Hyperbola_2< Gt >::midpoint(p1, p2); } public: Hyperbola_segment_2() : Hyperbola_2< Gt >() {} Hyperbola_segment_2(const Site_2 &f1, const Site_2 &f2, const Point_2 &p1, const Point_2 &p2) : Hyperbola_2< Gt >(f1, f2) { this->p1 = p1; this->p2 = p2; } void generate_points(std::vector& p) const { if ( CGAL::is_zero(this->r) ) { p.push_back(p1); p.push_back(p2); return; } // FT STEP = W.width() / 100.0; FT s[2]; s[0] = t(p1); s[1] = t(p2); if (CGAL::compare(s[0], s[1]) == LARGER) { #if defined(__GNUC__) && (__GNUC__ < 3) FT tmp = s[0]; s[0] = s[1]; s[1] = tmp; #else std::swap< FT >(s[0], s[1]); #endif } p.clear(); if ( !(CGAL::is_positive(s[0])) && !(CGAL::is_negative(s[1])) ) { FT tt; int k; p.push_back( this->o ); k = 1; tt = FT(-this->STEP); while ( CGAL::compare(tt, s[0]) == LARGER ) { p.insert( p.begin(), f(tt) ); k--; tt = -FT(k * k) * this->STEP; } p.insert( p.begin(), f(s[0]) ); k = 1; tt = FT(this->STEP); while ( CGAL::compare(tt, s[1]) == SMALLER ) { p.push_back( f(tt) ); k++; tt = FT(k * k) * this->STEP; } p.push_back( f(s[1]) ); } else if ( !(CGAL::is_negative(s[0])) && !(CGAL::is_negative(s[1])) ) { FT tt; int k; p.push_back( f(s[0]) ); tt = s[0]; k = int(CGAL::to_double(CGAL::sqrt(tt / this->STEP))); while ( CGAL::compare(tt, s[1]) == SMALLER ) { if ( CGAL::compare(tt, s[0]) != SMALLER ) p.push_back( f(tt) ); k++; tt = FT(k * k) * this->STEP; } p.push_back( f(s[1]) ); } else { FT tt; int k; p.push_back( f(s[1]) ); tt = s[1]; k = int(CGAL::to_double(-CGAL::sqrt(-tt / this->STEP))); while ( CGAL::compare(tt, s[0]) == LARGER ) { if ( CGAL::compare(tt, s[1]) != LARGER ) p.push_back( f(tt) ); k--; tt = -FT(k * k) * this->STEP; } p.push_back( f(s[0]) ); } } template< class Stream > void draw(Stream &W) const { std::vector p; generate_points(p); for (unsigned int i = 0; i < p.size() - 1; i++) { W << Segment_2(p[i], p[i+1]); } } }; template< class Stream, class Gt > inline Stream& operator<<(Stream &s, const Hyperbola_segment_2& H) { H.draw(s); return s; } CGAL_END_NAMESPACE #endif // CGAL_HYPERBOLA_SEGMENT_2_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous_converter.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous_converter.0000644000175000017500000001657311344301500031414 0ustar debiandebian// Copyright (c) 2001-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous_converter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion // Menelaos Karavelas #ifndef CGAL_HOMOGENEOUS_CONVERTER_H #define CGAL_HOMOGENEOUS_CONVERTER_H // This file contains the definition of a kernel converter, based on // Homogeneous representation. It should work between *Homogeneous // and *Homogeneous, provided you give an RT converter from A to C, // and an FT converter from B to D. #include #include #include #include #include CGAL_BEGIN_NAMESPACE template , class FT_Converter = NT_converter > class Homogeneous_converter : public Enum_converter { private: typedef Enum_converter Base; public: typedef K1 Source_kernel; typedef K2 Target_kernel; typedef RT_Converter Ring_number_type_converter; typedef FT_Converter Field_number_type_converter; #ifdef CGAL_CFG_USING_BASE_MEMBER_BUG bool operator()(bool b) const { return Base::operator()(b); } Sign operator()(Sign s) const { return Base::operator()(s); } Oriented_side operator()(Oriented_side os) const { return Base::operator()(os); } Bounded_side operator()(Bounded_side bs) const { return Base::operator()(bs); } Comparison_result operator()(Comparison_result cr) const { return Base::operator()(cr); } Angle operator()(Angle a) const { return Base::operator()(a); } #else using Base::operator(); #endif Bbox_2 operator()(const Bbox_2& b) { return b; } Bbox_3 operator()(const Bbox_3& b) { return b; } typename K2::RT operator()(const typename K1::RT &a) const { return c(a); } typename K2::FT operator()(const typename K1::FT &a) const { return c(a); } typename K2::Point_2 operator()(const typename K1::Point_2 &a) const { return k.construct_point_2_object()(rc(a.hx()), rc(a.hy()), rc(a.hw())); } typename K2::Vector_2 operator()(const typename K1::Vector_2 &a) const { return k.construct_vector_2_object()(rc(a.hx()), rc(a.hy()), rc(a.hw())); } typename K2::Direction_2 operator()(const typename K1::Direction_2 &a) const { return k.construct_direction_2_object()(rc(a.dx()), rc(a.dy())); } typename K2::Segment_2 operator()(const typename K1::Segment_2 &a) const { return k.construct_segment_2_object()(operator()(a.source()), operator()(a.target())); } typename K2::Line_2 operator()(const typename K1::Line_2 &a) const { return k.construct_line_2_object()(rc(a.a()), rc(a.b()), rc(a.c())); } typename K2::Ray_2 operator()(const typename K1::Ray_2 &a) const { return k.construct_ray_2_object()(operator()(a.source()), operator()(a.second_point())); } typename K2::Circle_2 operator()(const typename K1::Circle_2 &a) const { return k.construct_circle_2_object()(operator()(a.center()), fc(a.squared_radius()), a.orientation()); } typename K2::Triangle_2 operator()(const typename K1::Triangle_2 &a) const { return k.construct_triangle_2_object()(operator()(a.vertex(0)), operator()(a.vertex(1)), operator()(a.vertex(2))); } typename K2::Iso_rectangle_2 operator()(const typename K1::Iso_rectangle_2 &a) const { return k.construct_iso_rectangle_2_object()(operator()(a.min()), operator()(a.max())); } typename K2::Point_3 operator()(const typename K1::Point_3 &a) const { return k.construct_point_3_object()(rc(a.hx()), rc(a.hy()), rc(a.hz()), rc(a.hw())); } typename K2::Vector_3 operator()(const typename K1::Vector_3 &a) const { return k.construct_vector_3_object()(rc(a.hx()), rc(a.hy()), rc(a.hz()), rc(a.hw())); } typename K2::Direction_3 operator()(const typename K1::Direction_3 &a) const { return k.construct_direction_3_object()(rc(a.dx()), rc(a.dy()), rc(a.dz())); } typename K2::Segment_3 operator()(const typename K1::Segment_3 &a) const { return k.construct_segment_3_object()(operator()(a.source()), operator()(a.target())); } typename K2::Line_3 operator()(const typename K1::Line_3 &a) const { return k.construct_line_3_object()(operator()(a.point()), operator()(a.direction())); } typename K2::Ray_3 operator()(const typename K1::Ray_3 &a) const { return k.construct_ray_3_object()(operator()(a.source()), operator()(a.second_point())); } typename K2::Sphere_3 operator()(const typename K1::Sphere_3 &a) const { return k.construct_sphere_3_object()(operator()(a.center()), fc(a.squared_radius()), a.orientation()); } typename K2::Triangle_3 operator()(const typename K1::Triangle_3 &a) const { return k.construct_triangle_3_object()(operator()(a.vertex(0)), operator()(a.vertex(1)), operator()(a.vertex(2))); } typename K2::Tetrahedron_3 operator()(const typename K1::Tetrahedron_3 &a) const { return k.construct_tetrahedron_3_object()(operator()(a.vertex(0)), operator()(a.vertex(1)), operator()(a.vertex(2)), operator()(a.vertex(3))); } typename K2::Plane_3 operator()(const typename K1::Plane_3 &a) const { return k.construct_plane_3_object()(rc(a.a()), rc(a.b()), rc(a.c()), rc(a.d())); } typename K2::Iso_cuboid_3 operator()(const typename K1::Iso_cuboid_3 &a) const { return k.construct_iso_cuboid_3_object()(operator()(a.min()), operator()(a.max())); } private: RT_Converter rc; FT_Converter fc; K2 k; }; CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_CONVERTER_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/monotone_matrix_search.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/monotone_matrix_search0000644000175000017500000001411411344301500031513 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/monotone_matrix_search.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_MONOTONE_MATRIX_SEARCH_H) #define CGAL_MONOTONE_MATRIX_SEARCH_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template < class Matrix, class RandomAccessIterator > inline void monotone_matrix_search( const Matrix& M, RandomAccessIterator t) { typedef typename Matrix::Value V; monotone_matrix_search( M, t, std::less< V >()); } // monotone_matrix_search( M, t) template < class Matrix, class RandomAccessIterator, class Compare_strictly > void monotone_matrix_search( const Matrix& M, RandomAccessIterator t, const Compare_strictly& compare_strictly) // Matrix has to define: // o operator()( int, int) [access] // o int number_of_columns(), int number_of_rows() // o replace_column( int o, int n) // o shrink_to_quadratic_size() // o Matrix* extract_all_even_rows() // // Precondition: M is totally monotone // M.number_of_rows() > 1 and // RandomAccessIterator has value type int // // writes to t the positions (columns) // of the row maxima of M { // divide // ------ // get even rows of M: Matrix* M_new = M.extract_all_even_rows(); CGAL_optimisation_assertion( M_new->number_of_columns() == M.number_of_columns()); CGAL_optimisation_assertion( M_new->number_of_rows() == 0 || M_new->number_of_rows() == ( M.number_of_rows() + 1) >> 1); // reduce M_new to a quadratic matrix: // table to store the reduction permutation: // (incl. sentinel) int* reduction_table = new int[ M_new->number_of_rows() + 1]; if ( M_new->number_of_rows() < M_new->number_of_columns()) { // set sentinel: reduction_table[M_new->number_of_rows()] = M.number_of_columns() - 1; _reduce_matrix( *M_new, reduction_table, compare_strictly); CGAL_optimisation_assertion( M_new->number_of_columns() == M_new->number_of_rows()); } // if ( M_new->number_of_rows() < M_new->number_of_columns()) else { // no reduction -> reduction_table is identity table: for ( int i1( 0); i1 < M_new->number_of_columns(); ++i1) reduction_table[i1] = i1; // set sentinel: reduction_table[M_new->number_of_columns()] = M_new->number_of_columns() - 1; } // recursion: CGAL_optimisation_assertion( M_new->number_of_rows() >= M_new->number_of_columns()); // table to store the rmax values of M_new: // (incl. sentinel) int* t_new = new int[M_new->number_of_rows() + 1]; t_new[M_new->number_of_rows()] = M_new->number_of_columns(); if ( M_new->number_of_rows() == 1) // recursion anchor: // we have just one element ==> no choice t_new[0] = 0; else monotone_matrix_search( *M_new, t_new); // and conquer // ----------- int j( 0); // actual index in t int j_new( 0); // actual index in t_new do { // even row ==> we know *(t+j) = reduction_table[t_new[j_new++]]; if ( ++j >= M.number_of_rows()) break; // odd row // search *(t+j) between *(t+j-1) and t_new[j_new]: *(t+j) = reduction_table[t_new[j_new]]; int j_tmp( *(t+j-1)); while ( j_tmp < reduction_table[t_new[j_new]]) { if ( compare_strictly( M( j, t[j]), M( j, j_tmp))) *(t+j) = j_tmp++; else ++j_tmp; } } while ( ++j < M.number_of_rows()); delete M_new; delete[] t_new; delete[] reduction_table; } // monotone_matrix_search( M, t) template < class Matrix, class RandomAccessIterator, class Compare_strictly > void _reduce_matrix( Matrix& M, RandomAccessIterator t, const Compare_strictly& compare_strictly) // Matrix has to define: // o operator()( int, int) [access] // o int number_of_columns(), int number_of_rows() // o replace_column( int o, int n) // o shrink_to_quadratic_size() // o Matrix* extract_all_even_rows() // // Precondition: M is totally monotone // reduces M, i.e. deletes some columns that // do not contain the maximum value of any row // such that M becomes quadratic // and returns for each column of the resulting // matrix its column index in the original matrix { CGAL_optimisation_precondition( M.number_of_columns() >= M.number_of_rows()); // active columns are 0, ..., j1, j2, ..., M.x_dim()-1 int j1( 0), j2( 1); *t = 0; while ( j2 - j1 < M.number_of_columns() - M.number_of_rows() + 1) { if ( compare_strictly( M( j1, j1), M( j1, j2))) { // delete column j1 if ( j1 > 0) --j1; else { M.replace_column( 0, j2); *t = j2++; } } else { if ( j1 < M.number_of_rows() - 1) { // proceed M.replace_column( ++j1, j2); *(t+j1) = j2; } // else delete column j2 ++j2; } } // while ( j2 - j1 < // M.number_of_columns() - M.number_of_rows() + 1) // M.number_of_columns() - M.number_of_rows() columns // have been deleted, now move columns // j2 .. M.number_of_columns()-1 to the first part while ( j1 < M.number_of_rows() - 1) { CGAL_optimisation_assertion( j2 < M.number_of_columns()); M.replace_column( ++j1, j2); *(t+j1) = j2++; } M.shrink_to_quadratic_size(); } // _reduce_matrix( M, t) CGAL_END_NAMESPACE #endif // ! (CGAL_MONOTONE_MATRIX_SEARCH_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Turn_reverser.h0000644000175000017500000000233511344301501030042 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Turn_reverser.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_TURN_REVERSER_H #define CGAL_TURN_REVERSER_H namespace CGAL { template class Turn_reverser { public: Turn_reverser() {} Turn_reverser( const TurnPredicate& t ): turn(t) {} bool operator() (const Point_2& p1, const Point_2& p2, const Point_2& p3) const { return turn(p2, p1, p3); } private: TurnPredicate turn; }; } #endif // CGAL_TURN_REVERSER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random.h0000644000175000017500000000631411344301500026415 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Random.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Sylvain Pion #ifndef CGAL_RANDOM_H #define CGAL_RANDOM_H #include CGAL_BEGIN_NAMESPACE class Random { public: // creation Random( ); Random( unsigned int seed); // operations bool get_bool ( ); int get_int ( int lower, int upper); double get_double( double lower = 0.0, double upper = 1.0); // Computes a random int value smaller than 2^b. // It's supposed to be fast, useful for randomized algorithms. // The distribution is not perfectly flat, but this is a sacrifice against // efficiency. template int get_bits() { CGAL_assertion(0>= 1; // Shifting by b would be slightly better, but is slower. return ret; } int operator () ( int upper); private: // data members const double rand_max_plus_1; unsigned int random_value; // Current 15 bits random value. unsigned int val; // random_value shifted by used bits. }; // Global variables // ================ extern Random default_random; CGAL_END_NAMESPACE // ============================================================================ // Class implementation (inline functions) // ======================================= // includes # include CGAL_BEGIN_NAMESPACE // operations inline bool Random:: get_bool( ) { return( static_cast< bool>( CGAL_CLIB_STD::rand() & 1)); } inline int Random:: get_int( int lower, int upper) { return( lower + static_cast< int>( ( static_cast< double>( upper) - lower) * CGAL_CLIB_STD::rand() / rand_max_plus_1)); } inline double Random:: get_double( double lower, double upper) { return( lower + ( ( upper-lower) * CGAL_CLIB_STD::rand() / rand_max_plus_1)); } inline int Random:: operator () ( int upper) { return( get_int( 0, upper)); } CGAL_END_NAMESPACE #endif // CGAL_RANDOM_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_2.h0000644000175000017500000000760211344301500027430 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_H #define CGAL_PARTITION_H #include #include #include #include namespace CGAL { template inline OutputIterator greene_approx_convex_partition_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { return partition_greene_approx_convex_2(first, beyond, result, traits); } template inline OutputIterator greene_approx_convex_partition_2(InputIterator first, InputIterator beyond, OutputIterator result) { return partition_greene_approx_convex_2(first, beyond, result); } template inline OutputIterator optimal_convex_partition_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { return partition_optimal_convex_2(first, beyond, result, traits); } template inline OutputIterator optimal_convex_partition_2(InputIterator first, InputIterator beyond, OutputIterator result) { return partition_optimal_convex_2(first, beyond, result); } template inline OutputIterator approx_convex_partition_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { return partition_approx_convex_2(first, beyond, result, traits); } template inline OutputIterator approx_convex_partition_2(InputIterator first, InputIterator beyond, OutputIterator result) { return partition_approx_convex_2(first, beyond, result); } template inline OutputIterator y_monotone_partition_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { return partition_y_monotone_2(first, beyond, result, traits); } template inline OutputIterator y_monotone_partition_2(InputIterator first, InputIterator beyond, OutputIterator result) { return partition_y_monotone_2(first, beyond, result); } } #endif // CGAL_PARTITION_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/regular_neighbor_coordinates_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/regular_neighbor_coord0000644000175000017500000003445711344301500031464 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/regular_neighbor_coordinates_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Julia Floetotto #ifndef CGAL_REGULAR_NEIGHBOR_COORDINATES_2_H #define CGAL_REGULAR_NEIGHBOR_COORDINATES_2_H #include #include //for definition of class Project_vertex_output_iterator #include CGAL_BEGIN_NAMESPACE // in this functions, the traits class is defined via the regular // triangulation // see natural_neighbor_coordinates_2 for a proposal for signatures // that allow to pass the traits class as argument //the following two functions suppose that // OutputIterator has value type // std::pair //!!!they are not documented!!! //init Face_handle start: // OutputIterator has value type // std::pair template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_vertex_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out) { return regular_neighbor_coordinates_vertex_2(rt, p, out, typename Rt::Face_handle()); } //Face_handle start is known: // OutputIterator has value type // std::pair template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_vertex_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, typename Rt::Face_handle start) { return regular_neighbor_coordinates_vertex_2(rt, p, out, Emptyset_iterator(), start); } //the Voronoi vertices of the power cell are known: // OutputIterator has value type // std::pair template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_vertex_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, OutputIteratorVorVertices vor_vertices, typename Rt::Face_handle start) { //out: the result of the coordinate computation //vor_vertices: the vertices of the power cell (to avoid // recomputation) typedef typename Rt::Geom_traits Traits; typedef typename Traits::FT Coord_type; typedef typename Rt::Weighted_point Weighted_point; typedef typename Rt::Vertex_handle Vertex_handle; typedef typename Rt::Face_handle Face_handle; typedef typename Rt::Edge Edge; typedef typename Rt::Locate_type Locate_type; Locate_type lt; int li; Face_handle fh = rt.locate(p, lt, li, start); //the point must lie inside the convex hull // sinon return false: if(lt == Rt::OUTSIDE_AFFINE_HULL || lt == Rt::OUTSIDE_CONVEX_HULL || (lt == Rt::EDGE && (rt.is_infinite(fh) || rt.is_infinite(fh->neighbor(li))))) return make_triple(out, Coord_type(1), false); if (lt == Rt::VERTEX) { //the point must be in conflict: CGAL_precondition(rt.power_test(fh->vertex(li)->point(), p) != ON_NEGATIVE_SIDE); if (rt.power_test(fh->vertex(li)->point(), p) ==ON_ORIENTED_BOUNDARY) { *out++= std::make_pair(fh->vertex(li),Coord_type(1)); return make_triple(out, Coord_type(1), true); } } std::list hole; std::list< Vertex_handle > hidden_vertices; rt.get_boundary_of_conflicts_and_hidden_vertices(p, std::back_inserter(hole), std::back_inserter (hidden_vertices), fh); return regular_neighbor_coordinates_vertex_2 (rt, p, out, vor_vertices, hole.begin(),hole.end(), hidden_vertices.begin(), hidden_vertices.end()); } // OutputIterator has value type // std::pair template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_vertex_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, EdgeIterator hole_begin, EdgeIterator hole_end, VertexIterator hidden_vertices_begin, VertexIterator hidden_vertices_end) { return regular_neighbor_coordinates_vertex_2(rt, p, out,Emptyset_iterator(), hole_begin, hole_end, hidden_vertices_begin, hidden_vertices_end); } // OutputIterator has value type // std::pair template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_vertex_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, OutputIteratorVorVertices vor_vertices, EdgeIterator hole_begin, EdgeIterator hole_end, VertexIterator hidden_vertices_begin, VertexIterator hidden_vertices_end) { //precondition: p must lie inside the non-empty hole // (=^ inside convex hull of neighbors) //out: the result of the coordinate computation //vor_vertices: the vertices of the power cell of p (to avoid recomputation) CGAL_precondition(rt.dimension()==2); typedef typename Rt::Geom_traits Traits; typedef typename Traits::FT Coord_type; typedef typename Traits::Bare_point Bare_point; typedef typename Rt::Weighted_point Weighted_point; typedef typename Rt::Vertex_handle Vertex_handle; typedef typename Rt::Face_circulator Face_circulator; //no hole because only (exactly!) one vertex is hidden: if(hole_begin==hole_end){ *out++= std::make_pair((*hidden_vertices_begin), Coord_type(1)); ++hidden_vertices_begin; CGAL_assertion(hidden_vertices_begin == hidden_vertices_end); return make_triple(out, Coord_type(1), true); } std::vector vor(3); Coord_type area_sum(0); //determine the last vertex of the hole: EdgeIterator hit = hole_end; --hit; //to start: prev is the "last" vertex of the hole // later: prev is the last vertex processed (previously) Vertex_handle prev = hit->first->vertex(rt.cw(hit->second)); hit = hole_begin; while(hit != hole_end) { Coord_type area(0); Vertex_handle current = hit->first->vertex(rt.cw(hit->second)); //a first Voronoi vertex of the cell of p: vor[0] = rt.geom_traits().construct_weighted_circumcenter_2_object() (current->point(), hit->first->vertex(rt.ccw(hit->second))->point(), p); *vor_vertices++= vor[0]; //triangulation of the Voronoi subcell: //a second vertex as base Face_circulator fc = rt.incident_faces(current, hit->first); ++fc; vor[1] = rt.dual(fc); // iteration over all other "old" Voronoi vertices while(!fc->has_vertex(prev)) { ++fc; vor[2] = rt.dual(fc); area += polygon_area_2(vor.begin(), vor.end(), rt.geom_traits()); vor[1] = vor[2]; } //the second Voronoi vertex of the cell of p: vor[2] = rt.geom_traits().construct_weighted_circumcenter_2_object() (prev->point(),current->point(),p); *vor_vertices++= vor[2]; area += polygon_area_2(vor.begin(), vor.end(), rt.geom_traits()); *out++= std::make_pair(current,area); area_sum += area; //update prev and hit: prev= current; ++hit; } //get coordinate for hidden vertices // <=> the area of their Voronoi cell. //decomposition of the cell into triangles // vor1: dual of first triangle // vor2, vor 3: duals of two consecutive triangles Face_circulator fc, fc_begin; for(; hidden_vertices_begin != hidden_vertices_end; ++hidden_vertices_begin){ Coord_type area(0); fc_begin = rt.incident_faces(*hidden_vertices_begin); vor[0] = rt.dual(fc_begin); fc = fc_begin; ++fc; vor[1] = rt.dual(fc); ++fc; while(fc != fc_begin){ vor[2] = rt.dual(fc); area += polygon_area_2(vor.begin(), vor.end(), rt.geom_traits()); vor[1] = vor[2]; ++fc; } *out++= std::make_pair((*hidden_vertices_begin),area); area_sum += area; } return make_triple(out, area_sum, true); } //////////////////////////////////////////////////////////// //the cast from vertex to point: // the following functions return an Output_iterator over // std::pair //=> OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> ///////////////////////////////////////////////////////////// //init Face_handle start: template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out) { return regular_neighbor_coordinates_2(rt, p, out, typename Rt::Face_handle()); } //OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> //Face_handle start is known: template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, typename Rt::Face_handle start) { return regular_neighbor_coordinates_2(rt, p, out, Emptyset_iterator(), start); } //OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> //the Voronoi vertices of the power cell are known: template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, OutputIteratorVorVertices vor_vertices, typename Rt::Face_handle start) { //out: the result of the coordinate computation //vor_vertices: the vertices of the power cell (to avoid // recomputation) Project_vertex_output_iterator op(out); Triple< Project_vertex_output_iterator, typename Rt::Geom_traits::FT, bool > result = regular_neighbor_coordinates_vertex_2 (rt, p, op , vor_vertices, start); return make_triple(result.first.base(), result.second, result.third); } //OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, EdgeIterator hole_begin, EdgeIterator hole_end, VertexIterator hidden_vertices_begin, VertexIterator hidden_vertices_end) { return regular_neighbor_coordinates_2(rt, p, out,Emptyset_iterator(), hole_begin, hole_end, hidden_vertices_begin, hidden_vertices_end); } //OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_2(const Rt& rt, const typename Rt::Weighted_point& p, OutputIterator out, OutputIteratorVorVertices vor_vertices, EdgeIterator hole_begin, EdgeIterator hole_end, VertexIterator hidden_vertices_begin, VertexIterator hidden_vertices_end) { //precondition: p must lie inside the non-empty hole // (=^ inside convex hull of neighbors) //out: the result of the coordinate computation //vor_vertices: the vertices of the power cell of p //(to avoid recomputation) Project_vertex_output_iterator op(out); Triple< Project_vertex_output_iterator, typename Rt::Geom_traits::FT, bool > result = regular_neighbor_coordinates_vertex_2 (rt, p, op , vor_vertices, hole_begin,hole_end, hidden_vertices_begin, hidden_vertices_end); return make_triple(result.first.base(), result.second, result.third); } /**********************************************************/ //compute the coordinates for a vertex of the triangulation // with respect to the other points in the triangulation //OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> template Triple< OutputIterator, typename Rt::Geom_traits::FT, bool > regular_neighbor_coordinates_2(const Rt& rt, typename Rt::Vertex_handle vh, OutputIterator out) { //this functions creates a small triangulation of the // incident vertices of this vertex and computes the // natural neighbor coordinates of vh->point() wrt. it. typedef typename Rt::Vertex_circulator Vertex_circulator; Rt t2; Vertex_circulator vc = rt.incident_vertices(vh), done(vc); do{ assert(!rt.is_infinite(vc)); t2.insert(vc->point()); } while(++vc!=done); return regular_neighbor_coordinates_2(t2, vh->point(), out); } //class providing a function object: //OutputIterator has value type // std::pair< Rt::Geom_traits::Point_2, Rt::Geom_traits::FT> template class regular_neighbor_coordinates_2_object { public: Triple< OutputIterator, typename Rt::Geom_traits::FT , bool > operator()(const Rt& rt, typename Rt::Vertex_handle vh, OutputIterator out) const { return regular_neighbor_coordinates_2(rt, vh, out); } }; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_NEIGHBOR_COORDINATES_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_bykat.C0000644000175000017500000002074311344301500026716 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_bykat.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_BYKAT_C #define CGAL_CH_BYKAT_C #ifndef CGAL_CH_BYKAT_H #include #endif // CGAL_CH_BYKAT_H #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template OutputIterator ch_bykat(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Less_signed_distance_to_line_2 Less_dist; typedef typename Traits::Equal_2 Equal_2; Left_turn_2 left_turn = ch_traits.left_turn_2_object(); Less_dist less_dist = ch_traits.less_signed_distance_to_line_2_object(); Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; std::vector< Point_2 > P; // Points in subsets std::vector< Point_2 > H; // right endpoints of subproblems P.reserve(16); H.reserve(16); typedef typename std::vector< Point_2 >::iterator PointIterator; std::vector< PointIterator > L; // start of subset range std::vector< PointIterator > R; // end of subset range L.reserve(16); R.reserve(16); PointIterator l; PointIterator r; Point_2 a,b,c; std::copy(first,last,std::back_inserter(P)); ch_we_point(P.begin(), P.end(), l, r, ch_traits); a = *l; b = *r; if (equal_points(a,b)) { *result = a; ++result; return result; } #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... H.push_back( a ); L.push_back( P.begin() ); R.push_back( l = std::partition( P.begin(), P.end(), bind_1(bind_1(left_turn,a),b) ) ); r = std::partition( l, P.end(), bind_1(bind_1(left_turn,b),a) ); for (;;) { if ( l != r) { c = *std::min_element( l, r, bind_1(bind_1(less_dist, a), b)); H.push_back( b ); L.push_back( l ); R.push_back( l = std::partition(l, r, bind_1(bind_1(left_turn,b),c))); r = std::partition(l, r, bind_1(bind_1(left_turn,c),a)); b = c; } else { *res = a; ++res; if ( L.empty() ) break; a = b; b = H.back(); H.pop_back(); l = L.back(); L.pop_back(); r = R.back(); R.pop_back(); } } CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( res.output_so_far_begin(), \ res.output_so_far_end(), \ ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( \ P.begin(), P.end(), \ res.output_so_far_begin(), res.output_so_far_end(), \ ch_traits)); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } #define CGAL_ch_THRESHOLD 10 template OutputIterator ch_bykat_with_threshold(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Less_signed_distance_to_line_2 Less_dist; typedef typename std::vector< Point_2 >::iterator PointIterator; typedef typename Traits::Equal_2 Equal_2; Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; std::vector< Point_2 > P; // points in subsets std::vector< Point_2 > H; // right endpoints of subproblems P.reserve(16); H.reserve(16); std::vector< PointIterator > L; // start of subset range std::vector< PointIterator > R; // end of subset range L.reserve(16); R.reserve(16); PointIterator l; PointIterator r; Point_2 a,b,c; PointIterator Pbegin, Pend; P.push_back(Point_2() ); std::copy(first,last,std::back_inserter(P)); P.push_back(Point_2() ); Pbegin = successor(P.begin()); Pend = predecessor(P.end()); ch_we_point(Pbegin, Pend, l, r, ch_traits); a = *l; b = *r; if (equal_points(a,b)) { *result = a; ++result; return result; } #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... H.push_back( a ); L.push_back( Pbegin ); Left_turn_2 left_turn = ch_traits.left_turn_2_object(); R.push_back( l = std::partition( Pbegin, Pend, bind_1(bind_1(left_turn, a), b) ) ); r = std::partition( l, Pend, bind_1(bind_1(left_turn,b),a) ); Less_dist less_dist = ch_traits.less_signed_distance_to_line_2_object(); for (;;) { if ( l != r) { if ( r-l > CGAL_ch_THRESHOLD ) { c = *std::min_element( l, r, bind_1(bind_1(less_dist, a), b)); H.push_back( b ); L.push_back( l ); R.push_back( l = std::partition(l, r, bind_1(bind_1(left_turn, b), c)) ); r = std::partition(l, r, bind_1(bind_1(left_turn, c), a)); b = c; } else { std::swap( a, *--l); std::swap( b, *++r); if ( ch_traits.less_xy_2_object()(*l,*r) ) { std::sort(successor(l), r, ch_traits.less_xy_2_object() ); } else { std::sort(successor(l), r, swap_1(ch_traits.less_xy_2_object()) ); } ch__ref_graham_andrew_scan(l, successor(r), res, ch_traits); std::swap( a, *l); std::swap( b, *r); if ( L.empty() ) break; a = b; b = H.back(); H.pop_back(); l = L.back(); L.pop_back(); r = R.back(); R.pop_back(); } } else { *res = a; ++res; if ( L.empty() ) break; a = b; b = H.back(); H.pop_back(); l = L.back(); L.pop_back(); r = R.back(); R.pop_back(); } } CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( res.output_so_far_begin(), \ res.output_so_far_end(), \ ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( \ Pbegin, Pend, \ res.output_so_far_begin(), res.output_so_far_end(), \ ch_traits)); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } CGAL_END_NAMESPACE #endif // CGAL_CH_BYKAT_C ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_polygon_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_polygon_traits_0000644000175000017500000000367611344301500031473 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Random_polygon_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_RANDOM_POLYGON_TRAITS_2_H #define CGAL_RANDOM_POLYGON_TRAITS_2_H CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // Random_polygon_traits_2 //-----------------------------------------------------------------------// template class Random_polygon_traits_2 { public: typedef R_ R; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Less_xy_2 Less_xy_2; typedef typename R::Orientation_2 Orientation_2; Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } }; CGAL_END_NAMESPACE #endif // CGAL_RANDOM_POLYGON_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Width_polyhedron_3.h0000644000175000017500000001640711344301501030746 0ustar debiandebian// Copyright (c) 1997-2000 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Width_polyhedron_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Thomas Herrmann, Lutz Kettner #ifndef CGAL_WIDTH_POLYHEDRON_3_H #define CGAL_WIDTH_POLYHEDRON_3_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Width_vertex_default_base : public CGAL::HalfedgeDS_vertex_base< Refs, Tag_true, typename Traits::Point_3> { private: typedef Traits WT; typedef typename WT::RT RT; WT tco; public: typedef typename Traits::Point_3 Point_3; typedef CGAL::HalfedgeDS_vertex_base< Refs, Tag_true, Point_3> Vertex_base; Width_vertex_default_base() {} Width_vertex_default_base( const Point_3& p) : Vertex_base(p) {} }; struct Width_polyhedron_items_3 { template < class Refs, class Traits> struct Vertex_wrapper { typedef Width_vertex_default_base< Refs, Traits> Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef CGAL::HalfedgeDS_halfedge_base< Refs> Halfedge; }; template < class Refs, class Traits> struct Face_wrapper { typedef typename Traits::Plane_3 Plane; typedef CGAL::HalfedgeDS_face_base< Refs, CGAL::Tag_true, Plane> Face; }; }; template class Data_access { public: typedef InputPolyhedron Polyhedron; typedef typename Polyhedron::Vertex Vertex; typedef typename Polyhedron::Facet Facet; typedef typename Polyhedron::Halfedge Halfedge; typedef typename Polyhedron::Facet_handle Facet_handle; typedef typename Polyhedron::Vertex_handle Vertex_handle; typedef typename Polyhedron::Halfedge_handle Halfedge_handle; typedef typename Polyhedron::Facet_const_handle Facet_const_handle; typedef typename Polyhedron::Vertex_const_handle Vertex_const_handle; typedef typename Polyhedron::Halfedge_const_handle Halfedge_const_handle; typedef typename Polyhedron::Point_3 PolyPoint; typedef typename Polyhedron::Plane_3 Plane; typedef typename Polyhedron::Vertex_iterator Vertex_iterator; typedef typename Polyhedron::Facet_iterator Facet_iterator; typedef typename Polyhedron::Halfedge_iterator Halfedge_iterator; typedef typename Width_Traits::RT RT; private: Width_Traits tco; public: Data_access() {} ~Data_access() {} private: //Precondition: Plane Equation already computed in a deterministic way struct Facet_compare { bool operator()(Facet_const_handle f, Facet_const_handle g) const { Width_Traits tco; Plane fpp=f->plane(); Plane gpp=g->plane(); RT fa,fb,fc,fd,ga,gb,gc,gd; tco.get_plane_coefficients(fpp,fa,fb,fc,fd); tco.get_plane_coefficients(gpp,ga,gb,gc,gd); return (faopposite()->vertex()->point(); PolyPoint ehead=e->vertex()->point(); PolyPoint htail=h->opposite()->vertex()->point(); PolyPoint hhead=h->vertex()->point(); RT etx,ety,etz,eth,ehx,ehy,ehz,ehh; tco.get_point_coordinates(etail,etx,ety,etz,eth); tco.get_point_coordinates(ehead,ehx,ehy,ehz,ehh); RT htx,hty,htz,hth,hhx,hhy,hhz,hhh; tco.get_point_coordinates(htail,htx,hty,htz,hth); tco.get_point_coordinates(hhead,hhx,hhy,hhz,hhh); return (etx*hth , Facet_compare> antipodal_vertices; std::map< Halfedge_const_handle, bool, Halfedge_compare> visited_halfedges; std::map< Halfedge_const_handle, bool, Halfedge_compare> impassable_halfedges; public: bool is_visited(Halfedge_handle& e) const { typename std::map < Halfedge_const_handle, bool, Halfedge_compare > ::const_iterator it; it=visited_halfedges.find(e); CGAL_assertion(it!=visited_halfedges.end()); DEBUGENDL(VISITED_CHECK,"Visited flag value of edge " <opposite()->vertex()->point() <<" --> ",e->vertex()->point()<<": "<second); return it->second; } void set_visited_flag(Halfedge_handle& e, bool val) { DEBUGENDL(VISITED_CHECK,"Set visited flag to: ",val); visited_halfedges[e]=val; } bool is_impassable(Halfedge_handle& e) const { typename std::map < Halfedge_const_handle, bool, Halfedge_compare > ::const_iterator it; it=impassable_halfedges.find(e); CGAL_assertion(it!=impassable_halfedges.end()); DEBUGENDL(IMPASSABLE_CHECK,"Impassable flag value of edge ", e->opposite()->vertex()->point() <<" --> "<vertex()->point()<<": "<second); return it->second; } void set_impassable_flag(Halfedge_handle& e, bool val) { DEBUGENDL(IMPASSABLE_CHECK,"Set impassable flag to: ",val); impassable_halfedges[e]=val; } void set_antipodal_vertices(Facet_handle& f, std::vector& V) { antipodal_vertices[f]=V; } void get_antipodal_vertices(Facet_handle& f, std::vector& res) const { typename std::map< Facet_const_handle, std::vector, Facet_compare>::const_iterator it; it=antipodal_vertices.find(f); CGAL_assertion(it!=antipodal_vertices.end()); res=it->second; } #if !(defined(CGAL_KERNEL_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG)) int size_of_impassable() { return(int(impassable_halfedges.size())); } int size_of_visited() { return(int(visited_halfedges.size())); } int size_of_antipodal_vertices() { return (int(antipodal_vertices.size())); } #endif }; CGAL_END_NAMESPACE #endif //WIDTH_POLYHEDRON_3_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_point_location_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_point_location_base0000644000175000017500000001255611344301500031423 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_point_location_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_PM_POINT_LOCATION_BASE_H #define CGAL_PM_POINT_LOCATION_BASE_H #ifndef CGAL_PM_BOUNDING_BOX_BASE_H #include #endif CGAL_BEGIN_NAMESPACE //////////////////////////////////////////////////////////////////// // ABSTRACT BASE CLASS OF STRATEGY ////////////////////////////////////////////////////////////////// template class Pm_point_location_base { public: typedef Planar_map_ Planar_map; typedef typename Planar_map::Traits Traits; typedef typename Planar_map::Traits_wrap Traits_wrap; typedef typename Planar_map::Locate_type Locate_type; typedef typename Planar_map::Ccb_halfedge_circulator Ccb_halfedge_circulator; typedef typename Planar_map::Ccb_halfedge_const_circulator Ccb_halfedge_const_circulator; typedef typename Planar_map::Vertex_handle Vertex_handle; typedef typename Planar_map::Vertex_const_handle Vertex_const_handle; typedef typename Planar_map::Halfedge_handle Halfedge_handle; typedef typename Planar_map::Halfedge_const_handle Halfedge_const_handle; typedef typename Planar_map::Halfedge_iterator Halfedge_iterator; typedef typename Planar_map::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Planar_map::Halfedge Halfedge; typedef std::vector Halfedge_handle_container; typedef typename Halfedge_handle_container::iterator Halfedge_handle_iterator; typedef typename Planar_map::Face_handle Face_handle; typedef typename Planar_map::Face_const_handle Face_const_handle; typedef typename Traits::Point_2 Point; typedef typename Traits::X_monotone_curve_2 X_curve; // typedef typename Traits::X_curve_iterator X_curve_iterator; typedef Pm_bounding_box_base Bounding_box; typedef typename Bounding_box::Token Token; Pm_point_location_base() {} virtual void init(Planar_map & pmp, const Traits & tr) = 0; virtual ~Pm_point_location_base() {} virtual void insert(Halfedge_handle h,const X_curve & cv) = 0; //h is the handle in which the curveis heald in the pm. /* Ignores the bounding box */ virtual Halfedge_const_handle locate(const Point& p, Locate_type& lt) const = 0; /* Applies the bounding box */ virtual Halfedge_handle locate(const Point& p, Locate_type& lt) { return locate(p,lt); } /* Ignores the bounding box */ virtual Halfedge_const_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) const = 0; /* Applies the bounding box */ virtual Halfedge_handle vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) { return vertical_ray_shoot(p,lt,up); } //the function is called after the combinatoric split //cv is the original curve , e1 e2 are the new halfedges returned virtual void split_edge(const X_curve &cv, Halfedge_handle e1, Halfedge_handle e2 //additions by iddo for arrangement ,const X_curve& cv1, const X_curve& cv2 //end additions ) = 0; //called after combinatoric merge //e is the new edge cv1,cv2 are the original curves virtual void merge_edge(const X_curve &cv1, const X_curve &cv2, Halfedge_handle e //additions by iddo for arrangement ,const X_curve& cv //end additions ) = 0; //called before combinatoric deletion virtual void remove_edge(Halfedge_handle e) = 0; // - undocumented functions - virtual void remove_edge(const Halfedge_handle_iterator&, const Halfedge_handle_iterator&) {}; virtual void clear() {}; virtual void update(const Halfedge_handle_iterator&, const Halfedge_handle_iterator&, const Token& token) { token.rebuild_bounding_box(this); }; // Should changed to = 0 in the near future. // -------------------------- virtual const Traits* get_traits() const = 0; #ifdef CGAL_PM_DEBUG virtual void debug() = 0; #endif protected: // Remove the Halfedge_const_handle protections static inline Halfedge_handle Halfedge_handle_unconst(const Halfedge_const_handle hc) { return Halfedge_handle((Halfedge*)&*&*hc); } }; CGAL_END_NAMESPACE #endif //CGAL_PM_POINT_LOCATION_BASE_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_with_intersections_misc.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_with_intersections_0000644000175000017500000000635211344301500031470 0ustar debiandebian// Copyright (c) 2000 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_with_intersections_misc.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Eyal flato #ifndef CGAL_PM_WITH_INTERSECTIONS_MISC_H #define CGAL_PM_WITH_INTERSECTIONS_MISC_H #include #include CGAL_BEGIN_NAMESPACE template class Planar_map_with_intersections_traits_wrap : public Pm_traits_wrap_2 { public: typedef Pm_traits_wrap_2 Base; typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; typedef typename Base::Point_2 Point_2; typedef typename I::Has_left_category Has_left_category; Planar_map_with_intersections_traits_wrap() : Base() {} Planar_map_with_intersections_traits_wrap(const Base & tw) : Base(tw) {} void directed_curve_split(const X_monotone_curve_2 & cv, const Point_2 & first_pnt, const Point_2 & split_pnt, X_monotone_curve_2 & split1, X_monotone_curve_2 & split2) { CGAL_assertion(point_equal(curve_source(cv), first_pnt) || point_equal(curve_target(cv), first_pnt)); CGAL_assertion(!point_equal(curve_source(cv), split_pnt)); CGAL_assertion(!point_equal(curve_target(cv), split_pnt)); curve_split(cv, split1, split2, split_pnt); } // maps the curves to their mirror images over the y coordinate // and calls nearest_intersect_to_right (see there). Object nearest_intersection_to_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & pt) const { return (nearest_intersection_to_left_imp(cv1, cv2, pt, Has_left_category())); } Object nearest_intersection_to_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & pt, Tag_true) const { return (Base::nearest_intersection_to_left(cv1, cv2, pt)); } Object nearest_intersection_to_left_imp(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & pt, Tag_false) const { Point_2 rpt = point_reflect_in_x_and_y( pt); X_monotone_curve_2 rcv1 = curve_reflect_in_x_and_y( cv1); X_monotone_curve_2 rcv2 = curve_reflect_in_x_and_y( cv2); return (nearest_intersection_to_right(rcv1, rcv2, rpt)); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Simple_cartesian.h0000644000175000017500000000462211344301501030460 0ustar debiandebian// Copyright (c) 2000-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Simple_cartesian.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann, Sylvain Pion #ifndef CGAL_SIMPLE_CARTESIAN_H #define CGAL_SIMPLE_CARTESIAN_H #include #include #include CGAL_BEGIN_NAMESPACE template < typename FT_, typename Kernel > struct Cartesian_base_no_ref_count : public Cartesian_base< Kernel, FT_ > { typedef FT_ RT; typedef FT_ FT; // The mecanism that allows to specify reference-counting or not. template < typename T > struct Handle { typedef T type; }; template < typename Kernel2 > struct Base { typedef Cartesian_base_no_ref_count Type; }; // TODO: cleanup (use Rational_traits<> instead) static FT make_FT(const RT & num, const RT& denom) { return num/denom;} static FT make_FT(const RT & num) { return num;} static RT FT_numerator(const FT &r) { return r;} static RT FT_denominator(const FT &) { return RT(1);} }; template < typename FT_ > struct Simple_cartesian : public Type_equality_wrapper< Cartesian_base_no_ref_count >, Simple_cartesian > {}; CGAL_END_NAMESPACE #endif // CGAL_SIMPLE_CARTESIAN_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_bases.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_bases.0000644000175000017500000000605211344301501031313 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_bases.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel #ifndef CGAL_TOPOLOGICAL_MAP_BASES_H #define CGAL_TOPOLOGICAL_MAP_BASES_H #include #include CGAL_BEGIN_NAMESPACE /*! Base vertex class */ class Tpm_vertex_base { protected: /*! An incident halfedge of the vertex */ void * hdg; public: Tpm_vertex_base() {} void * halfedge() { return hdg; } const void * halfedge() const { return hdg; } void set_halfedge(void * h) { hdg = h; } }; /*! Base halfedge class */ class Tpm_halfedge_base { public: Tpm_halfedge_base() {} void * opposite() { return opp; } const void * opposite() const { return opp; } /*! \brief obtains the next halfedge along the face. */ void * next() { return nxt;} const void * next() const { return nxt; } void set_opposite(void * h) { opp = h; } void set_next(void * h) { nxt = h; } //will probably be in a max base in the future // void* prev() { return prv;} // const void* prev() const { return prv;} void * vartex() { return v; } const void * vertex() const { return v; } /*! \brief obtains the face to the left. */ void * face() { return f; } const void * face() const { return f; } void set_vertex(void * _v) { v = _v; } void set_face(void * _f) { f = _f; } protected: void * opp; void * nxt; void * v; void * f; //face }; /*! Base face class */ class Tpm_face_base { public: typedef std::list Holes_container; typedef Holes_container::iterator Holes_iterator; typedef Holes_container::const_iterator Holes_const_iterator; Tpm_face_base() : holes() {}; void * halfedge() { return hdg; } const void * halfedge() const { return hdg; } void set_halfedge(void * h) { hdg = h; } //mine Holes_iterator holes_begin() { return holes.begin(); } Holes_iterator holes_end() { return holes.end(); } Holes_const_iterator holes_begin() const { return holes.begin(); } Holes_const_iterator holes_end() const { return holes.end(); } void add_hole(void * halfedge_ptr) { holes.push_back(halfedge_ptr); } void erase_hole(Holes_iterator hit) { holes.erase(hit); } void erase_holes(Holes_iterator first, Holes_iterator last) { holes.erase(first, last); } private: void * hdg; Holes_container holes; }; CGAL_END_NAMESPACE #else #error Header file .h included twice #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000003005211344301500031410 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_MINIBALL_C #define CGAL_MINIBALL_MINIBALL_C #include #include #ifdef CGAL_MINIBALL_DEBUG #include #endif #include #include #include namespace CGAL_MINIBALL_NAMESPACE { // Returns a random number uniformly in {0,...,k-1}. inline int random(int k) { return std::rand() % k; // todo. This is not good... } template inline bool compare(const FT& a,const FT& b, const FT& ap,const FT& bp) { const FT u = a-ap, uu = u*u; if (u >= FT(0)) { if (bp <= uu) return false; // here (1) holds const FT v = uu-b+bp; if (v <= 0) return false; // here (2) holds return 4 * uu * bp < sqr(v); } else { // here (1) holds const FT v = uu-b+bp; if (v >= FT(0)) return true; // here (3) holds return 4 * uu *bp > sqr(v); } } template void Min_sphere_of_spheres_d::update(LP_algorithm) { using namespace Min_sphere_of_spheres_d_impl; const int n = l.size(); int i, k = n; do { CGAL_MINIBALL_ASSERT(k>=e && e>=0); // permute: for (int j=k-1; j>=e; --j) // todo. theory: is this necessary? std::swap(l[j],l[e+random(j+1-e)]); for (i=e; i bool Min_sphere_of_spheres_d::find_farthest(int from,int to, int& i,const Tag_true use_sqrt,const Tag_false is_exact) { using namespace Min_sphere_of_spheres_d_impl; // we will compute the excesses w.r.t. to the ball B with // center ss.begin() and radius radius: const FT radius = ss.radius() * Tol; // find ball with largest excess: FT maximum = radius; for (int k=from; k(ss.begin(), t.center_cartesian_begin(*l[k]),0.0,std::plus(), Subtract_and_square()); // compute excess: using std::sqrt; const FT ex = sqrt(dist)+t.radius(*l[k]); // compare with current maximum: if (ex > maximum) { // (*) maximum = ex; i = k; } } // return whether B doesn't contain the ball l[i]: return maximum > radius; } template bool Min_sphere_of_spheres_d::find_farthest(int from,int to, int& i,const Tag_true use_sqrt,const Tag_true is_exact) { using namespace Min_sphere_of_spheres_d_impl; // we will compute the excesses w.r.t. to the ball B with // center center and radius radius: Pair_to_double cast(ss.disc()); const double radius = cast(ss.radius()); double center[D]; std::transform(ss.begin(),ss.begin()+D,center,cast); // find ball with largest excess: double maximum = radius; for (int k=from; k(center, t.center_cartesian_begin(*l[k]),0.0,std::plus(), Subtract_and_square_to_double()); // compute excess: using std::sqrt; const double ex = sqrt(dist) + CGAL_MINIBALL_NTS to_double(t.radius(*l[k])); // compare with current maximum: if (ex > maximum) { // (*) maximum = ex; i = k; } } // return whether B doesn't contain the ball l[i]: return maximum > radius && !ss.contains(t.center_cartesian_begin(*l[i]), t.radius(*l[i]),Tol,Is_exact()); } template bool Min_sphere_of_spheres_d::find_farthest(int from,int to, int& i,const Tag_false use_sqrt,const Tag_false is_exact) { using namespace Min_sphere_of_spheres_d_impl; // we will compute the excesses w.r.t. to the ball with // center ss.begin() and radius radius: const FT radius = ss.radius() * Tol; // find ball with largest excess: bool found = false; FT max = radius, maxp = 0; for (int k=from; k(ss.begin(), t.center_cartesian_begin(*l[k]),0.0,std::plus(), Subtract_and_square()); if (compare(max,maxp,t.radius(*l[k]),dist)) { max = t.radius(*l[k]); maxp = dist; i = k; found = true; } } // return whether B doesn't contain the ball l[i]: return found; } template bool Min_sphere_of_spheres_d::find_farthest(int from,int to, int& i,const Tag_false use_sqrt,const Tag_true is_exact) { using namespace Min_sphere_of_spheres_d_impl; // we will compute the excesses w.r.t. to the ball B with // center center and radius radius: Pair_to_double cast(ss.disc()); const double radius = cast(ss.radius()); double center[D]; std::transform(ss.begin(),ss.begin()+D,center,cast); // find ball with largest excess: bool found = false; double max = radius, maxp = 0; for (int k=from; k(center, t.center_cartesian_begin(*l[k]),0.0,std::plus(), Subtract_and_square_to_double()); const double r = CGAL_MINIBALL_NTS to_double(t.radius(*l[k])); if (compare(max,maxp,r,dist)) { max = r; maxp = dist; i = k; found = true; } } // return whether B doesn't contain the ball l[i]: return found && !ss.contains(t.center_cartesian_begin(*l[i]), t.radius(*l[i]),Tol,Is_exact()); } template void Min_sphere_of_spheres_d::update(Farthest_first_heuristic) { const int n = l.size(); int i = e; CGAL_MINIBALL_ASSERT(e <= n); bool enclosing = (e == 0)? n == 0 : !find_farthest(e,n,i,Use_sqrt(),Is_exact()); while (!enclosing && ss.pivot(l,e,i)) { enclosing = !find_farthest(e,n,i,Use_sqrt(),Is_exact()); } if (!is_approximate(Is_exact())) update(LP_algorithm()); } template bool Min_sphere_of_spheres_d:: is_valid(const Tag_false is_exact) { return true; } template bool Min_sphere_of_spheres_d:: is_valid(const Tag_true is_exact) { using namespace Min_sphere_of_spheres_d_impl; using std::cerr; using std::endl; // check size of support set: if (e > static_cast(l.size()) || e > (D+1)) { cerr << "Min_sphere_of_spheres_d: support set too large." << endl << "Please contact the author ." << endl; return false; } else if (l.size() > 0 && e<=0) { cerr << "Min_sphere_of_spheres_d: support set too small." << endl << "Please contact the author ." << endl; return false; } // check case of no balls: if (l.size() <= 0) { if (!is_empty()) { cerr << "Min_sphere_of_spheres_d: miniball of {} non-empty." << endl << "Please contact the author ." << endl; return false; } else return true; } // check that the miniball is enclosing: for (unsigned int i=0; i." << endl; return false; } // check that all support balls lie on the boundary: typedef Pair P; bool isSupporting = true; for (int i=0; i(ss.begin(), t.center_cartesian_begin(*l[i]),P(0,0),std::plus

    (), Subtract_and_square_pair(ss.disc())); // compute the square of rd: const P sqrRd(sqr(rd.first)+sqr(rd.second)*ss.disc(), FT(2)*rd.first*rd.second); // check containment: if (!is_zero(dist-sqrRd,ss.disc())) isSupporting = false; } if (!isSupporting) { cerr << "Min_sphere_of_spheres_d: support not on boundary." << endl << "Please contact the author ." << endl; return false; } // set up initial system's coefficient matrix: FT (*m)[D+1] = new FT[e][D+1]; for (int j=0; j(t.center_cartesian_begin(*l[j]),m[j]); for (int j=0; j rhs[D+1]; copy_n(ss.begin(),rhs); rhs[D] = FT(1); // perform Gaussian elimination: for (int j=0; j= D+1) { cerr << "Min_sphere_of_spheres_d: supp. centers aff. dep." << endl << "Please contact the author ." << endl; return false; } // exchange rows: for (int k=0; k." << endl; return false; } // compute coefficients by backsubstitution: Pair lambda[D+1]; for (int i=e-1; i>=0; --i) { lambda[i] = rhs[i]; for (int j=i+1; j." << endl; return false; } // tidy up: delete[] m; return true; } } // namespace CGAL_MINIBALL_NAMESPACE #endif // CGAL_MINIBALL_MINIBALL_CC ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d_to_polyhedron_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d_to_polyh0000644000175000017500000001011211344301500031444 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_d_to_polyhedron_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_CONVEX_HULL_D_TO_POLYHEDRON_3_H #define CGAL_CONVEX_HULL_D_TO_POLYHEDRON_3_H #include #include #include CGAL_BEGIN_NAMESPACE template class Build_polyhedron_from_chull : public Modifier_base< _HDS> { public: typedef _HDS HDS; typedef _ChullType ChullType; typedef typename HDS::Vertex HdsVertex; typedef typename HdsVertex::Point Point; typedef typename ChullType::Facet_const_handle Facet_handle; typedef typename ChullType::Vertex_const_handle Vertex_handle; typedef typename ChullType::R R; typedef typename ChullType::Point_d Point_d; Build_polyhedron_from_chull(const ChullType& CH) : ch(CH) {} Point convert(const Point_d& p) const { return Point(p.hx(),p.hy(),p.hz(),p.hw()); } void operator()(HDS& hds ) { CGAL_assertion( ch.current_dimension() == 3); Polyhedron_incremental_builder_3 B(hds, true); B.begin_surface( ch.number_of_vertices(), ch.number_of_facets() ); // would be nice to have statistical data on // Chull available other than print_statistics() Unique_hash_map index( -1); std::list L = ch.all_facets(); typename std::list::iterator fit; Facet_handle f; Vertex_handle v; int i = 0; for ( fit = L.begin(); fit != L.end(); ++fit) { f = *fit; for (int k=0; k < 3; ++k) { v = ch.vertex_of_facet(f,k); if ( index[v] == -1 ) { B.add_vertex( convert(ch.associated_point(v)) ); index[v] = i++; } } } Point_d center = ch.center(); for ( fit = L.begin(); fit != L.end(); ++fit) { f = *fit; B.begin_facet(); Vertex_handle v0 = ch.vertex_of_facet(f,0); Vertex_handle v1 = ch.vertex_of_facet(f,1); Vertex_handle v2 = ch.vertex_of_facet(f,2); typename R::Orientation_d orientation = ch.kernel().orientation_d_object(); std::vector V(4); V[0]= ch.associated_point(v0); V[1]= ch.associated_point(v1); V[2]= ch.associated_point(v2); V[3]= center; if ( orientation( V.begin(), V.end() ) == POSITIVE ) { B.add_vertex_to_facet( index[v0] ); B.add_vertex_to_facet( index[v1] ); B.add_vertex_to_facet( index[v2] ); } else { B.add_vertex_to_facet( index[v0] ); B.add_vertex_to_facet( index[v2] ); B.add_vertex_to_facet( index[v1] ); } B.end_facet(); } B.end_surface(); } private: const ChullType& ch; }; /*{\Mtext \headerline{Low Dimensional Conversion Routine} include || \setopdims{2cm}{3cm}}*/ template void convex_hull_d_to_polyhedron_3( const Convex_hull_d& C, Polyhedron_3& P) /*{\Mfunc converts the convex hull |C| to polyedral surface stored in |P|.\\ \precond |dim == 3| and |dcur == 3|. }*/ { typedef Convex_hull_d ChullType; typedef typename Polyhedron_3::HalfedgeDS HDS; CGAL_assertion_msg(C.dimension()==3&&C.current_dimension()==3, "convex_hull_d_to_polyhedron_3: only full manifold can be transformed."); Build_polyhedron_from_chull get_surface(C); P.delegate( get_surface ); } CGAL_END_NAMESPACE #endif //CGAL_CONVEX_HULL_D_TO_POLYHEDRON_3_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Point_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Point_2_inte0000644000175000017500000000223711344301500031203 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Point_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_traits_3.h0000644000175000017500000002001011344301500031260 0ustar debiandebian// Copyright (c) 2001 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Convex_hull_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_CONVEX_HULL_TRAITS_3_H #define CGAL_CONVEX_HULL_TRAITS_3_H #include #include #include #include namespace CGAL { template < class R_ > class Point_triple { protected: typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; Point_3 p_, q_, r_; public: typedef R_ R; Point_triple() {} Point_triple(const Point_3 &p, const Point_3 &q, const Point_3 &r) : p_(p), q_(q), r_(r) {} const Point_3& p() const { return p_; } const Point_3& q() const { return q_; } const Point_3& r() const { return r_; } }; template class Point_triple_has_on_positive_side_3 { public: typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; bool operator()( const Plane_3& pl, const Point_3& p) const { typename K::Orientation_3 o; return ( o(pl.p(), pl.q(), pl.r(), p) == CGAL::POSITIVE ); } }; template class Point_triple_construct_orthogonal_vector_3 { public: typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; Vector_3 operator()(const Plane_3& plane) const { typename OldK::Construct_orthogonal_vector_3 construct_orthogonal_vector_3; return construct_orthogonal_vector_3(plane.p(), plane.q(), plane.r()); } }; template class Point_triple_oriented_side_3 { public: typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef Oriented_side result_type; result_type operator()( const Plane_3& pl, const Point_3& p) const { typename K::Orientation_3 o; Orientation ori = o(pl.p(), pl.q(), pl.r(), p) ; if(ori > 0) return ON_POSITIVE_SIDE; if(ori < 0) return ON_NEGATIVE_SIDE; return ON_ORIENTED_BOUNDARY; } }; template class Point_triple_less_signed_distance_to_plane_3 { public: typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()( const Plane_3& h, const Point_3& p, const Point_3& q) const { const Point_3& hp = h.p(); const Point_3& hq = h.q(); const Point_3& hr = h.r(); typename OldK::Less_signed_distance_to_plane_3 less_signed_distance_to_plane_3; return less_signed_distance_to_plane_3(hp, hq, hr, p, q); } }; template class Max_coordinate_3 { public: int operator()(const T& v) { if (CGAL_NTS abs(v.x()) >= CGAL_NTS abs(v.y())) { if (CGAL_NTS abs(v.x()) >= CGAL_NTS abs(v.z())) return 0; return 2; } else { if (CGAL_NTS abs(v.y()) >= CGAL_NTS abs(v.z())) return 1; return 2; } } }; // without this we get an internal compiler error on bcc #if defined(__BORLANDC__) template > #else template #endif class Convex_hull_traits_3 { public: typedef R_ R; typedef Convex_hull_traits_3 Self; typedef typename R::Point_3 Point_3; typedef typename R::Segment_3 Segment_3; typedef typename R::Triangle_3 Triangle_3; typedef Point_triple Plane_3; typedef typename R::Vector_3 Vector_3; #if defined(__BORLANDC__) typedef Polyhedron_ Polyhedron_3; #else typedef CGAL::Polyhedron_3 Polyhedron_3; #endif typedef typename R::Construct_segment_3 Construct_segment_3; typedef typename R::Construct_ray_3 Construct_ray_3; class Construct_plane_3 { public: Plane_3 operator ()(const Point_3& p, const Point_3& q, const Point_3& r) { return Plane_3(p,q,r); } }; typedef typename R::Construct_vector_3 Construct_vector_3; typedef typename R::Construct_triangle_3 Construct_triangle_3; typedef typename R::Construct_centroid_3 Construct_centroid_3; typedef Point_triple_construct_orthogonal_vector_3 Construct_orthogonal_vector_3; typedef typename R::Equal_3 Equal_3; typedef typename R::Orientation_3 Orientation_3; typedef typename R::Collinear_3 Collinear_3; typedef typename R::Coplanar_3 Coplanar_3; typedef typename R::Less_distance_to_point_3 Less_distance_to_point_3; typedef Point_triple_has_on_positive_side_3 Has_on_positive_side_3; typedef Point_triple_less_signed_distance_to_plane_3 Less_signed_distance_to_plane_3; // required for degenerate case of all points coplanar typedef Convex_hull_projective_xy_traits_2 Traits_xy; typedef Convex_hull_projective_xz_traits_2 Traits_xz; typedef Convex_hull_projective_yz_traits_2 Traits_yz; typedef CGAL::Max_coordinate_3 Max_coordinate_3; // for postcondition checking typedef typename R::Ray_3 Ray_3; typedef typename R::Has_on_3 Has_on_3; typedef Point_triple_oriented_side_3 Oriented_side_3; typedef typename R::Intersect_3 Intersect_3; typedef typename R::Do_intersect_3 Do_intersect_3; Construct_segment_3 construct_segment_3_object() const { return Construct_segment_3(); } Construct_ray_3 construct_ray_3_object() const { return Construct_ray_3(); } Construct_plane_3 construct_plane_3_object() const { return Construct_plane_3(); } Construct_triangle_3 construct_triangle_3_object() const { return Construct_triangle_3(); } Construct_vector_3 construct_vector_3_object() const { return Construct_vector_3(); } Construct_centroid_3 construct_centroid_3_object() const { return Construct_centroid_3(); } Construct_orthogonal_vector_3 construct_orthogonal_vector_3_object() const { return Construct_orthogonal_vector_3(); } Collinear_3 collinear_3_object() const { return Collinear_3(); } Coplanar_3 coplanar_3_object() const { return Coplanar_3(); } Has_on_3 has_on_3_object() const { return Has_on_3(); } Less_distance_to_point_3 less_distance_to_point_3_object() const { return Less_distance_to_point_3(); } Has_on_positive_side_3 has_on_positive_side_3_object() const { return Has_on_positive_side_3(); } Oriented_side_3 oriented_side_3_object() const { return Oriented_side_3(); } Equal_3 equal_3_object() const { return Equal_3(); } Intersect_3 intersect_3_object() const { return Intersect_3(); } Do_intersect_3 do_intersect_3_object() const { return Do_intersect_3(); } Less_signed_distance_to_plane_3 less_signed_distance_to_plane_3_object() const { return Less_signed_distance_to_plane_3(); } Max_coordinate_3 max_coordinate_3_object() const { return Max_coordinate_3(); } }; } // namespace CGAL #endif // CGAL_CONVEX_HULL_TRAITS_3_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_walk_along_line_point_location.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_walk_along_line_poi0000644000175000017500000005022011344301500031372 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_walk_along_line_point_location.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan // Iddo Hanniel #ifndef CGAL_PM_WALK_ALONG_LINE_POINT_LOCATION_C #define CGAL_PM_WALK_ALONG_LINE_POINT_LOCATION_C #include //#define CGAL_PM_WALK_DEBUG //#define CGAL_PM_DEBUG CGAL_BEGIN_NAMESPACE //if unbounded face - returns NULL or some edge on unbounded face //if its a vertex returns a halfedge pointing _at_ it template typename Pm_walk_along_line_point_location::Halfedge_const_handle Pm_walk_along_line_point_location::locate(const Point & p, Locate_type & lt) const { Face_const_handle f = pm->unbounded_face(), last = pm->faces_end(); // invariant: p always lies in f's interior or holes Halfedge_const_handle e = pm->halfedges_end(); // closest halfedge so far lt = Planar_map::UNBOUNDED_FACE; while (f != last) { // stop at innermost level last = f; Holes_const_iterator it = f->holes_begin(), end = f->holes_end(); while (it != end && last == f) { // handle holes if (find_closest(p, *it, true, true, e, lt)) switch (lt) { case Planar_map::UNBOUNDED_FACE: break; case Planar_map::FACE: walk_along_line(p,true,true,e,lt); switch (lt) { case Planar_map::VERTEX: #ifdef CGAL_PM_DEBUG CGAL_assertion(traits->point_equal(e->target()->point(), p)); #endif case Planar_map::EDGE: return e; case Planar_map::FACE: f=e->face(); break; default: CGAL_assertion(lt == Planar_map::FACE || lt == Planar_map::EDGE || lt == Planar_map::VERTEX); break; } break; case Planar_map::VERTEX: #ifdef CGAL_PM_DEBUG CGAL_assertion(traits->point_equal(e->target()->point(), p)); #endif case Planar_map::EDGE: return e; default: CGAL_assertion(lt==Planar_map::UNBOUNDED_FACE|| lt==Planar_map::FACE|| lt==Planar_map::EDGE|| lt==Planar_map::VERTEX); } ++it; } } if (lt == Planar_map::UNBOUNDED_FACE && f != pm->unbounded_face()) lt = Planar_map::FACE; if (e == pm->halfedges_end() && pm->number_of_halfedges() > 0) return Halfedge_const_handle(*(pm->unbounded_face()->holes_begin())); return e; } template typename Pm_walk_along_line_point_location::Halfedge_handle Pm_walk_along_line_point_location::locate(const Point & p, Locate_type & lt) { ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); if (!((Bounding_box*)get_bounding_box())->locate(p,lt,h)) h=Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); return h; } template typename Pm_walk_along_line_point_location::Halfedge_const_handle Pm_walk_along_line_point_location:: vertical_ray_shoot(const Point & p, Locate_type & lt, bool up) const { Face_const_handle f = pm->unbounded_face(), last = pm->faces_end(); // p always lies in f's interior Halfedge_const_handle e = pm->halfedges_end(); // closest halfedge so far lt = Planar_map::UNBOUNDED_FACE; while(f != last) // stop at innermost level { last = f; Holes_const_iterator it = f->holes_begin(), end = f->holes_end(); // For each hole while(it != end && last == f) { if (find_closest(p,*it,up,false,e,lt)) { switch (lt) { case Planar_map::VERTEX: #ifdef CGAL_PM_DEBUG CGAL_assertion(traits->point_equal_x(e->target()->point(), p)); #endif case Planar_map::EDGE: #ifdef CGAL_PM_WALK_DEBUG std::cerr << "\ncalling walk_along_line(" << p << "," << up << ",false," << e->curve() << "," << lt << ")"; #endif walk_along_line(p,up,false,e,lt); switch(lt) { case Planar_map::VERTEX: f=e->twin()->face(); break; case Planar_map::EDGE: #ifdef CGAL_PM_DEBUG CGAL_assertion(up == traits->point_is_left_low(e->target()->point(), e->source()->point())); #endif f=e->face(); case Planar_map::UNBOUNDED_FACE: break; default: CGAL_assertion(lt==Planar_map::UNBOUNDED_FACE|| lt==Planar_map::EDGE|| lt==Planar_map::VERTEX); break; } break; default: CGAL_assertion(lt == Planar_map::EDGE || lt == Planar_map::VERTEX); break; } } ++it; } } if (e==pm->halfedges_end()) lt=Planar_map::UNBOUNDED_FACE; return e; } template typename Pm_walk_along_line_point_location::Halfedge_handle Pm_walk_along_line_point_location:: vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) { /* Make sure the source point is in the bounding box on the output */ ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->vertical_ray_shoot(p,lt,up)); /* Apply the bounding box on the output */ if (!((Bounding_box*)get_bounding_box())->vertical_ray_shoot(p,lt,up,h)) { h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); CGAL_assertion(lt!=Planar_map::UNBOUNDED_FACE); } return h; } ///IMPLEMENTATION //////////////////////////////////////// /* Point p - the source of the vertical ray shoot bool up - true if the ray shoot is upwards, otherwise false (downwards) bool including - true if the ray includes its source, false otherwise The intersection of the vertical ray shoot is represented using: Locate_type lt - the type of the intersection Halfedge_handle e - an halfedge representing the intersection depending on { lt == point, ( a vertex in the planar map ) find the first halfedge pointing at p, when going clockwise if highest==true - start from 12 oclock, else start from 6 oclock DEBUG: highest = up or !up ??? lt == curve, ( an halfedge in the planar map ) DEBUG: ? lt == face, ( a face in the planar map ) DEBUG: ? lt == unbounded face, ( an unbounded face in the planar map) DEBUG: ? } */ // This function takes a point p , p is in the face to the side of e. // We walk along a the vertical line enamating from p (in direction // up), one each iteration find_closest finds the closest halfedge to // p (in direction up), the loop stops when find_closest found the // closest face to p (the condition last_face != face) or we got to // the unbounded face so there is nothing left to do. template void Pm_walk_along_line_point_location:: walk_along_line(const Point & p, bool up, bool including, // bool type, Halfedge_const_handle& e, Locate_type& lt) const { bool type = including; Face_const_handle face = (type || lt!=Planar_map::VERTEX) ? e->face() : e->twin()->face(); // hold the current face find_closest found. Face_const_handle last_face; // hold the last face find_closest found. do { last_face = face; /* x / x p A situation where CGAL_assertion(f!=pm->unbounded_face()) doesn't hold. */ #ifdef CGAL_PM_WALK_DEBUG std::cerr << "\n pre find_closest(" << p << ", , " << up << "," << including << ",(" << e->source()->point() << "," << e->target()->point() << ")," << lt << ");"; #endif if (face != pm->unbounded_face()) { #ifdef CGAL_PM_DEBUG bool found = #endif find_closest(p, face->outer_ccb(), up, including, e, lt); #ifdef CGAL_PM_DEBUG CGAL_assertion(found); #endif } face = (type || lt != Planar_map::VERTEX) ? e->face() : e->twin()->face(); } while((type == (lt==Planar_map::UNBOUNDED_FACE)) && last_face != face); } /*! The function gets a face circulator, a point p, direction (up/down), and returns the edge that is closest to the point in the given direction. An edge is returned in all cases. The info about the location type is returned in the Locate_type lt (vertex/edge/face). */ template bool Pm_walk_along_line_point_location:: find_closest(const Point & p, const Ccb_halfedge_const_circulator & c, bool up, bool including, // bool type, Halfedge_const_handle & e, Locate_type & lt) const { // for possible future implementation (if the ray includes its source). //including - if the ray includes its source or not. //type == true : was called from locate, // should return the edge that points to the face p is in. //type == false: was called from vertical ray shoot // should return the edge right above, or if vertex above - // should return the first edge in ccb order bool type = including; // is this the first relevant edge found bool intersection = e != pm->halfedges_end(); // used to answer is it known that ray shoot intersects curves? // inside flips from false to true according to the number of edges found // above p. odd number - p is inside, even - p outside the face. // its like a counter to the number of edges above p. bool inside = false; // used to calculate if point is inside ccb //an iterator on all the halfedges Ccb_halfedge_const_circulator curr = c; //the main loop do { #ifdef CGAL_PM_WALK_DEBUG std::cout << curr->source()->point()<<" towards " << curr->target()->point()<curve(); const X_curve & ecv = intersection ? e->curve() : cv; // dummy ref to cv const Point & p1 = traits->curve_source(cv), & p2 = traits->curve_target(cv); bool in_x_range = true; if (type) {//we are in locate - lexicographic x range in_x_range = ((traits->point_is_left_low(p, p1) != traits->point_is_left_low(p, p2)) || (traits->point_equal(p, p1)) || (traits->point_equal(p, p2))); } else { //we are in vertical ray shoot in_x_range = traits->point_in_x_range(cv, p); } Comparison_result res = EQUAL; if (in_x_range) res = traits->curve_compare_y_at_x(p, cv); //continue only if we're in x range, //and the halfedge is above us (if up) / below (if down) if (res == (up ? SMALLER: LARGER)) { /* cv is a non vertical curve intersecting the vertical ray shoot x / x | ( for a vertical ray shoot upwards ) | p The vertical case is excluded for lexicographically the curve is not intersecting with the ray: x | x | | / x => |x | | p p */ if (traits->point_is_left_low(p, p1) != traits->point_is_left_low(p, p2)) { // p is lexicographically between p1 and p2. // count parity of curves intersecting ray in their interior inside = !inside; } //if this curve is better for us than all the others : //or its the first in the right x-range, or its the closest if (!intersection || // if we had an intersection in the previous iteration. traits->curves_compare_y_at_x(ecv, cv , p) == (up ? LARGER : SMALLER)) // we know that curr is above (or below, if up false) p. { // orient e leftlow if ( up == traits->point_is_left_low(curr->target()->point(), curr->source()->point())) e = curr ; else e = curr->twin(); #ifdef CGAL_PM_WALK_DEBUG std::cout<<"e is "<< e->source()->point()<<" towards " << e->target()->point()<curve_is_vertical(cv)) { if (traits->point_equal_x(e->source()->point(),p)) { // p is below (above if not up) e->source(). e = e->twin(); lt=Planar_map::VERTEX; } else if (traits->point_equal_x(e->target()->point(),p)) { lt = Planar_map::VERTEX; } else lt = Planar_map::EDGE; } else // for p is within e'th x range lt=Planar_map::VERTEX; // the vertical ray intersects a vertex or an edge. intersection = true; } //if there was intersection in the previous run, and the compare-y_at_x //returned equal, that is in one of the cases: else if (e != curr && e != curr->twin() && traits->curves_compare_y_at_x(ecv, cv , p) == EQUAL) { /* * The common edge point of cv and ecv is on the vertical ray * emanating from p. q is assigned with this common edge point. * first intersection point of ray and curve is an end point like * * x x * x--x---x |/ * | x * | | * p or p * */ //q will hold the intersection point of cv and ecv Point q = traits->curve_source(cv); if ((traits->compare_x(p, q) != EQUAL) || //the next 2 lines are written to deal with cases //that one of the curves is vertical (!traits->point_equal(q, traits->curve_source(ecv)) && !traits->point_equal(q, traits->curve_target(ecv)))) q = traits->curve_target(cv); //check which curve (cv or ecv) is closer in the meaning of clockwise if ((up ? traits->curves_compare_y_at_x_from_bottom(ecv, cv, q) : traits->curves_compare_y_at_x_from_top(ecv,cv,q)) == LARGER) { //if type == vertical ray shoot we want to return the edge that points // towards q //if type == locate - // ecv is closer to p than cv. if (type != (traits->point_equal(curr->target()->point(), q))) // means we're under cv (so we take the outer edge part). e = curr; else // means we're above cv (between cv and ecv) and so // we take the inner edge part. e = curr->twin(); //idit - was moved, and to change to suit down ray shoot //in this case q is upper point of a vertical edge. //in this case we have to take (in locate) the halfedge that q is its //source //in vertical ray shoot we we have to take the halfedge that q is its //target if (traits->curve_is_vertical(cv)) { if (traits->point_is_left_low (traits->curve_leftlow_most(cv), q)) { // special treatment for this special case: // vertical segment downward - here we should take // the opposite direction if (type != (traits->point_equal(curr->target()->point(), q))) e = curr->twin(); else e = curr; } } } if (!type) lt=Planar_map::VERTEX; // lt should be already Planar_map::VERTEX } #ifdef CGAL_PM_DEBUG else { CGAL_assertion(traits->curves_compare_y_at_x(ecv, cv , p) == (!up ? LARGER : SMALLER) || e==curr || e==curr->twin()); } #endif // CGAL_PM_DEBUG } else if (in_x_range && res == EQUAL) { if (!including) { /* The vertical ray shoot is not including p itself, thus we are interested only in vertical curves that extend upwards Remark: The Locate type is always EDGE */ if (traits->curve_is_vertical(cv) && traits->point_is_right_top(traits->curve_righttop_most(cv), p)) { /* x x | | p=x or p | x */ lt = Planar_map::EDGE; if (up==traits->point_is_left_low(curr->target()->point(), curr->source()->point())) e = curr; else e = curr->twin(); #ifdef CGAL_PM_WALK_DEBUG std::cerr << "\n find_closest(" << p << ", , " << up << "," << including << ",(" << "," << e->target()->point() << ")," << lt << ");"; #endif return true; } } else // including { // p is in interior of curr->curve(); if ( !traits->point_equal(p,traits->curve_source(cv)) && !traits->point_equal(p,traits->curve_target(cv))) { lt = Planar_map::EDGE; if (up==traits->point_is_left_low(curr->target()->point(), curr->source()->point())) e = curr; else e = curr->twin(); } else // end point { lt = Planar_map::VERTEX; #ifdef CGAL_PM_DEBUG CGAL_assertion(curr!=pm->halfedges_end()); #endif if (traits->point_equal(curr->target()->point(),p)) e = find_vertex_representation(curr,p,up); else e = find_vertex_representation(curr->twin(),p,up); #ifdef CGAL_PM_DEBUG CGAL_assertion(traits->point_equal(e->target()->point(),p)); #endif } #ifdef CGAL_PM_WALK_DEBUG std::cerr << "\n find_closest(" << p << ", , " << up << "," << including << ",(" << e->source()->point() << "," << e->target()->point() << ")," << lt << ");"; #endif return true; } } ++curr; } while (curr != c); if (!intersection) { lt = Planar_map::UNBOUNDED_FACE; return false; } if (type) lt = (inside ? Planar_map::FACE : Planar_map::UNBOUNDED_FACE); #ifdef CGAL_PM_WALK_DEBUG std::cerr << "\n find_closest(" << p << ", , " << up << "," << including << ",(" << e->source()->point() << "," << e->target()->point() << ")," << lt << ");"; if (lt == Planar_map::FACE && e == pm->halfedges_end()) std::cout << "Error - e is pm->halfedges_end() while lt is face" << std::endl; if (lt == Planar_map::FACE && e->face()->is_unbounded()){ std::cout << "Error - e->face is unbounded while lt is face" << std::endl; if ( !(e->twin()->face()->is_unbounded()) ) std::cout << "Probably confused with twin halfedge" << std::endl; } if (lt == Planar_map::UNBOUNDED_FACE && !(e->face()->is_unbounded()) ){ std::cout << "Error - lt is UNBOUNDED_FACE, but e is on a bounded face" << std::endl; if (e->twin()->face()->is_unbounded()) std::cout << "Probably confused with twin halfedge" << std::endl; } #endif return true; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_access_adaptor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Random_access_adaptor.0000644000175000017500000000250411344301500031275 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Random_access_adaptor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete; use instead. #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2.h0000644000175000017500000000521211344301500026301 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_LINE_2_H #define CGAL_LINE_2_H CGAL_BEGIN_NAMESPACE template class Line_2 : public R_::Kernel_base::Line_2 { typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Kernel_base::Line_2 RLine_2; public: typedef R_ R; Line_2() {} Line_2(const Point_2 &p, const Point_2 &q) : RLine_2(p,q) {} Line_2(const RT &a, const RT &b, const RT &c) : RLine_2(a,b,c) {} Line_2(const RLine_2& l) // conversion impl -> interface class : RLine_2(l) {} Line_2(const Segment_2& s) : RLine_2(s) {} Line_2(const Ray_2& r) : RLine_2(r) {} Line_2(const Point_2 &p, const Direction_2 &d) : RLine_2(p,d) {} Line_2(const Point_2 &p, const Vector_2 &v) : RLine_2(p,v) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_LINE_2 template < class R > std::ostream & operator<<(std::ostream &os, const Line_2 &l) { typedef typename R::Kernel_base::Line_2 RLine_2; return os << static_cast(l); } #endif // CGAL_NO_OSTREAM_INSERT_LINE_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_LINE_2 template < class R > std::istream & operator>>(std::istream &is, Line_2 &p) { typedef typename R::Kernel_base::Line_2 RLine_2; return is >> static_cast(p); } #endif // CGAL_NO_ISTREAM_EXTRACT_LINE_2 CGAL_END_NAMESPACE #endif // CGAL_LINE_2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_intersection.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_0000644000175000017500000002511611344301501031144 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Triangle_2_intersection.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template struct Pointlist_2_rec_ { Pointlist_2_rec_ *next; typename K::Point_2 point; Oriented_side side; }; template struct Pointlist_2_ { int size; Pointlist_2_rec_ *first; Pointlist_2_() ; ~Pointlist_2_() ; }; template class Triangle_2_Triangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT, TRIANGLE, POLYGON}; Triangle_2_Triangle_2_pair() ; Triangle_2_Triangle_2_pair( typename K::Triangle_2 const *trian1, typename K::Triangle_2 const *trian2) ; ~Triangle_2_Triangle_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; bool intersection(typename K::Triangle_2 &result) const; bool intersection(/*Polygon_2 &result*/) const; int vertex_count() const; typename K::Point_2 vertex(int i) const; protected: typename K::Triangle_2 const* _trian1; typename K::Triangle_2 const * _trian2; mutable bool _known; mutable Intersection_results _result; mutable Pointlist_2_ _pointlist; }; // template // inline bool do_intersect( // const Triangle_2 &p1, // const Triangle_2 &p2) // { // typedef Triangle_2_Triangle_2_pair pair_t; // pair_t pair(&p1, &p2); // return pair.intersection_type() != pair_t::NO; // } template Pointlist_2_::Pointlist_2_() { size = 0; first = 0; } template Pointlist_2_::~Pointlist_2_() { Pointlist_2_rec_ *cur; for (int i=0; inext; delete cur; } } template void _init_list(Pointlist_2_ &list, const typename K::Triangle_2 &trian) { // check on degeneracies of trian. if (!trian.is_degenerate()) { list.size = 3; list.first = 0; for (int i=0; i<3; i++) { Pointlist_2_rec_ *newrec = new Pointlist_2_rec_; newrec->next = list.first; list.first = newrec; newrec->point = trian[i]; } } else { // _not_implemented(); CGAL_kernel_assertion(false); } } template void _cut_off(Pointlist_2_ &list, const typename K::Line_2 &cutter) { int i; int add = 0; Pointlist_2_rec_ *cur, *last=0, *newrec; for (i=0, cur = list.first; inext) { cur->side = cutter.oriented_side(cur->point); last = cur; } for (cur = list.first, i=0; inext) { if ((cur->side == ON_POSITIVE_SIDE && last->side == ON_NEGATIVE_SIDE) || (cur->side == ON_NEGATIVE_SIDE && last->side == ON_POSITIVE_SIDE)) { // add a vertex after cur add++; typename K::Line_2 l(cur->point, last->point); newrec = new Pointlist_2_rec_; newrec->next = last->next; last->next = newrec; newrec->side = ON_ORIENTED_BOUNDARY; Line_2_Line_2_pair linepair(&cutter, &l); typename Line_2_Line_2_pair::Intersection_results isr; isr = linepair.intersection_type(); CGAL_kernel_assertion(isr == Line_2_Line_2_pair::POINT); linepair.intersection(newrec->point); } last = cur; } CGAL_kernel_assertion(add <= 2); Pointlist_2_rec_ **curpt; curpt = &list.first; while (*curpt != 0) { cur = *curpt; if (cur->side == ON_NEGATIVE_SIDE) { add--; *curpt = cur->next; delete cur; } else { curpt = &cur->next; } } if (list.size == 2 && add == 1) { add = 0; cur = list.first; if (cur->side == ON_ORIENTED_BOUNDARY) { list.first = cur->next; delete cur; } else { last = cur; cur = cur->next; last->next = cur->next; delete cur; } } list.size += add; } template Triangle_2_Triangle_2_pair:: Triangle_2_Triangle_2_pair() { _trian1 = 0; _trian2 = 0; _known = false; } template Triangle_2_Triangle_2_pair:: Triangle_2_Triangle_2_pair(typename K::Triangle_2 const *trian1, typename K::Triangle_2 const *trian2) { _trian1 = trian1; _trian2 = trian2; _known = false; } template typename Triangle_2_Triangle_2_pair::Intersection_results Triangle_2_Triangle_2_pair::intersection_type() const { typedef typename K::Line_2 Line_2; if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; if (!do_overlap(_trian1->bbox(), _trian2->bbox())) { _result = NO; return _result; } _init_list(_pointlist, *_trian1); if (_trian2->is_degenerate()) { // _not_implemented(); CGAL_kernel_assertion(false); } else { Line_2 l(_trian2->vertex(0), _trian2->vertex(1)); if (l.oriented_side(_trian2->vertex(2)) == ON_POSITIVE_SIDE) { // counterclockwise triangle _cut_off(_pointlist, l); l = Line_2(_trian2->vertex(1), _trian2->vertex(2)); _cut_off(_pointlist, l); l = Line_2(_trian2->vertex(2), _trian2->vertex(0)); _cut_off(_pointlist, l); } else { l = l.opposite(); _cut_off(_pointlist, l); l = Line_2(_trian2->vertex(0), _trian2->vertex(2)); _cut_off(_pointlist, l); l = Line_2(_trian2->vertex(2), _trian2->vertex(1)); _cut_off(_pointlist, l); } } switch (_pointlist.size) { case 0: _result = NO; break; case 1: _result = POINT; break; case 2: _result = SEGMENT; break; case 3: _result = TRIANGLE; break; default: _result = POLYGON; } return _result; } template bool Triangle_2_Triangle_2_pair::intersection( /* Polygon_2 &result */) const { if (!_known) intersection_type(); if (_result != TRIANGLE && _result != POLYGON) return false; Pointlist_2_rec_ *cur; int i; for (i=0, cur = _pointlist.first; i<_pointlist.size; i++, cur = cur->next) { std::cout << to_double(cur->point.x()) << ' '; std::cout << to_double(cur->point.y()) << ' '; } std::cout << std::endl; return true; } template int Triangle_2_Triangle_2_pair::vertex_count() const { CGAL_kernel_assertion(_known); return _pointlist.size; } template typename K::Point_2 Triangle_2_Triangle_2_pair::vertex(int n) const { CGAL_kernel_assertion(_known); CGAL_kernel_assertion(n >= 0 && n < _pointlist.size); Pointlist_2_rec_ *cur; int k; for (k=0, cur = _pointlist.first; k < n; k++, cur = cur->next) { } return cur->point; } template bool Triangle_2_Triangle_2_pair::intersection( typename K::Triangle_2 &result) const { typedef typename K::Triangle_2 Triangle_2; if (!_known) intersection_type(); if (_result != TRIANGLE) return false; result = Triangle_2(_pointlist.first->point, _pointlist.first->next->point, _pointlist.first->next->next->point); return true; } template bool Triangle_2_Triangle_2_pair::intersection( typename K::Segment_2 &seg) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; seg = Segment_2(_pointlist.first->point, _pointlist.first->next->point); return true; } template bool Triangle_2_Triangle_2_pair::intersection( typename K::Point_2 &pt) const { if (!_known) intersection_type(); if (_result != POINT) return false; pt = _pointlist.first->point; return true; } template Object intersection(const typename CGAL_WRAP(K)::Triangle_2 &tr1, const typename CGAL_WRAP(K)::Triangle_2 &tr2, const K& k) { typedef Triangle_2_Triangle_2_pair is_t; is_t ispair(&tr1, &tr2); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } case is_t::TRIANGLE: { typename K::Triangle_2 itr; ispair.intersection(itr); return make_object(itr); } case is_t::POLYGON: { typedef CGAL_STD::vector Container; Container points(ispair.vertex_count()); for (int i =0; i < ispair.vertex_count(); i++) { points[i] = ispair.vertex(i); } return make_object(points); } } } } // namespace CGALi CGAL_END_NAMESPACE ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Rectangular_p_center_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Rectangular_p_center_t0000644000175000017500000002765611344301500031434 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Rectangular_p_center_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_RECTANGULAR_P_CENTER_TRAITS_2_H) #define CGAL_RECTANGULAR_P_CENTER_TRAITS_2_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template < class A, class S > struct Select : public CGAL_STD::binary_function< A, A, A > { typedef Arity_tag< 2 > Arity; Select() {} Select(const S& s) : s_(s) {} A operator()(const A& a, const A& b) const { return s_(a, b) ? a : b; } A operator()(const A& a, const A& b) { return s_(a, b) ? a : b; } protected: S s_; }; template < class R > struct I_Signed_x_distance_2 : public CGAL_STD::binary_function< Point_2< R >, Point_2< R >, typename R::FT > { typedef Arity_tag< 2 > Arity; typename R::FT operator()(const Point_2< R >& q1, const Point_2< R >& q2) const { return q1.x() - q2.x(); } }; template < class R > struct I_Signed_y_distance_2 : public CGAL_STD::binary_function< Point_2< R >, Point_2< R >, typename R::FT > { typedef Arity_tag< 2 > Arity; typename R::FT operator()(const Point_2< R >& q1, const Point_2< R >& q2) const { return q1.y() - q2.y(); } }; template < class R > struct I_Infinity_distance_2 : public CGAL_STD::binary_function< Point_2< R >, Point_2< R >, typename R::FT > { typedef Arity_tag< 2 > Arity; typename R::FT operator()(const Point_2< R >& q1, const Point_2< R >& q2) const { return max(CGAL_NTS abs(q1.x() - q2.x()), CGAL_NTS abs(q1.y() - q2.y())); } }; template < class R > struct I_Signed_infinity_distance_2 : public CGAL_STD::binary_function< Point_2< R >, Point_2< R >, typename R::FT > { typedef Arity_tag< 2 > Arity; typename R::FT operator()(const Point_2< R >& q1, const Point_2< R >& q2) const { return max(q1.x() - q2.x(), q1.y() - q2.y()); } }; template < class R > struct I_Construct_point_2_above_right_implicit_point_2 { // (p, q, r) |--> (p.x() + r, q.y() + r) typedef typename R::FT FT; typedef Point_2< Cartesian< FT > > P; inline P operator()(const P& p, const P& q, FT r) const { return P(p.x() + r, q.y() + r); } }; template < class R > struct I_Construct_point_2_above_left_implicit_point_2 { // (p, q, r) |--> (p.x() - r, q.y() + r) typedef typename R::FT FT; typedef Point_2< Cartesian< FT > > P; inline P operator()(const P& p, const P& q, FT r) const { return P(p.x() - r, q.y() + r); } }; template < class R > struct I_Construct_point_2_below_left_implicit_point_2 { // (p, q, r) |--> (p.x() - r, q.y() - r) typedef typename R::FT FT; typedef Point_2< Cartesian< FT > > P; inline P operator()(const P& p, const P& q, FT r) const { return P(p.x() - r, q.y() - r); } }; template < class R > struct I_Construct_point_2_below_right_implicit_point_2 { // (p, q, r) |--> (p.x() + r, q.y() - r) typedef typename R::FT FT; typedef Point_2< Cartesian< FT > > P; inline P operator()(const P& p, const P& q, FT r) const { return P(p.x() + r, q.y() - r); } }; template < class R > struct Rectangular_p_center_default_traits_2 : public R { // ----------------------------------------------------------------- // types: // typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Iso_rectangle_2 Iso_rectangle_2; // ----------------------------------------------------------------- // predicates: // typedef typename R::Less_x_2 Less_x_2; typedef typename R::Less_y_2 Less_y_2; // ----------------------------------------------------------------- // constructions: // // from the kernel typedef typename R::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename R::Construct_vertex_2 Construct_vertex_2; // additions typedef I_Signed_x_distance_2< R > Signed_x_distance_2; typedef I_Signed_y_distance_2< R > Signed_y_distance_2; typedef I_Infinity_distance_2< R > Infinity_distance_2; typedef I_Signed_infinity_distance_2< R > Signed_infinity_distance_2; typedef I_Construct_point_2_above_right_implicit_point_2< R > Construct_point_2_above_right_implicit_point_2; typedef I_Construct_point_2_above_left_implicit_point_2< R > Construct_point_2_above_left_implicit_point_2; typedef I_Construct_point_2_below_right_implicit_point_2< R > Construct_point_2_below_right_implicit_point_2; typedef I_Construct_point_2_below_left_implicit_point_2< R > Construct_point_2_below_left_implicit_point_2; // get object methods: Signed_x_distance_2 signed_x_distance_2_object() const { return Signed_x_distance_2(); } Signed_y_distance_2 signed_y_distance_2_object() const { return Signed_y_distance_2(); } Infinity_distance_2 infinity_distance_2_object() const { return Infinity_distance_2(); } Signed_infinity_distance_2 signed_infinity_distance_2_object() const { return Signed_infinity_distance_2(); } Construct_point_2_above_right_implicit_point_2 construct_point_2_above_right_implicit_point_2_object() const { return Construct_point_2_above_right_implicit_point_2(); } Construct_point_2_above_left_implicit_point_2 construct_point_2_above_left_implicit_point_2_object() const { return Construct_point_2_above_left_implicit_point_2(); } Construct_point_2_below_left_implicit_point_2 construct_point_2_below_left_implicit_point_2_object() const { return Construct_point_2_below_left_implicit_point_2(); } Construct_point_2_below_right_implicit_point_2 construct_point_2_below_right_implicit_point_2_object() const { return Construct_point_2_below_right_implicit_point_2(); } }; // Rectangular_p_center_default_traits_2 template < class Traits_, class PiercingFunction_ > struct Rectangular_p_center_matrix_search_traits_2 { typedef Traits_ Traits; typedef typename Traits::FT FT; typedef typename Traits::Point_2 Point_2; typedef PiercingFunction_ PiercingFunction; typedef Staircases< Traits > LD; typedef typename LD::size_type size_type; template < class InputIC > Rectangular_p_center_matrix_search_traits_2( InputIC f, InputIC l, Traits t, const PiercingFunction& p) : ld(f, l, t), pf(p) #if (!defined(CGAL_OPTIMISATION_NO_ASSERTIONS) && \ !defined(CGAL_NO_ASSERTIONS) && !defined(NDEBUG)) , ld_size(ld.size()) #endif // optimisation_assertion_code {} size_type number_of_points() const { return ld.pts.size(); } bool operator()(FT v) { CGAL_optimisation_assertion(ld.size() == ld_size); ld.r = v / FT(2); bool ok; pf(ld, Wastebasket< Point_2 >(), ok); CGAL_optimisation_assertion(ld.size() == ld_size); return ok; } template < class OutputIterator > OutputIterator operator()(FT v, OutputIterator o, bool& ok) { CGAL_optimisation_assertion(ld.size() == ld_size); ld.r = v / FT(2); OutputIterator n = pf(ld, o, ok); CGAL_optimisation_assertion(ld.size() == ld_size); return n; //pf(ld, o, ok); } protected: // data members: LD ld; PiercingFunction pf; CGAL_optimisation_assertion_code(typename LD::size_type ld_size;) // copying this would be too inefficient Rectangular_p_center_matrix_search_traits_2( const Rectangular_p_center_matrix_search_traits_2&) {} }; // Rectangular_p_center_matrix_search_traits_2< ... > template < class ForwardIterator, class Traits > typename Traits::Iso_rectangle_2 bounding_box_2(ForwardIterator f, ForwardIterator l, const Traits& t) // PRE: f != l. { CGAL_precondition(f != l); typedef typename Traits::Less_x_2 Less_x_2; typedef typename Traits::Less_y_2 Less_y_2; typedef typename Traits::Construct_iso_rectangle_2 Rect; typedef typename Traits::Construct_vertex_2 CVertex; Less_x_2 lessx = t.less_x_2_object(); Less_y_2 lessy = t.less_y_2_object(); Rect rect = t.construct_iso_rectangle_2_object(); CVertex v = t.construct_vertex_2_object(); ForwardIterator xmin = f; ForwardIterator xmax = f; ForwardIterator ymin = f; ForwardIterator ymax = f; while (++f != l) { if (lessx(*f, *xmin)) xmin = f; if (lessx(*xmax, *f)) xmax = f; if (lessy(*f, *ymin)) ymin = f; if (lessy(*ymax, *f)) ymax = f; } return rect(v(rect(*xmin, *ymin), 0), v(rect(*xmax, *ymax), 2)); } // bounding_box_2(f, l, t) template < class ForwardIterator > inline typename std::iterator_traits< ForwardIterator >::value_type::R::Iso_rectangle_2 bounding_box_2(ForwardIterator f, ForwardIterator l) // PRE: f != l. { CGAL_precondition(f != l); // that is how it is supposed to be ... //typedef typename std::iterator_traits< ForwardIterator >::value_type::R // Traits; typedef typename std::iterator_traits< ForwardIterator >::value_type::R R; typedef Rectangular_p_center_default_traits_2< R > Traits; Traits t; return bounding_box_2(f, l, t); } // bounding_box_2(f, l) #ifdef CGAL_CFG_MATCHING_BUG_3 template < class ForwardIterator > inline typename std::iterator_traits< ForwardIterator* >::value_type::R::Iso_rectangle_2 bounding_box_2(ForwardIterator* f, ForwardIterator* l) // PRE: f != l. { CGAL_precondition(f != l); typedef typename std::iterator_traits< ForwardIterator* >::value_type::R R; typedef Rectangular_p_center_default_traits_2< R > Traits; Traits t; return bounding_box_2(f, l, t); } // bounding_box_2(f, l) #endif // CGAL_CFG_MATCHING_BUG_3 template < class Rectangle, class Traits > inline Rectangle construct_bounding_box_union_2(const Rectangle& r1, const Rectangle& r2, const Traits& t) { typedef typename Traits::Construct_iso_rectangle_2 Rect; typedef typename Traits::Construct_vertex_2 CVertex; typedef typename Traits::Less_x_2 Less_x_2; typedef typename Traits::Less_y_2 Less_y_2; Less_x_2 lessx = t.less_x_2_object(); Less_y_2 lessy = t.less_y_2_object(); Rect rect = t.construct_iso_rectangle_2_object(); CVertex v = t.construct_vertex_2_object(); #ifdef __BORLANDC__ typedef typename Traits::Point_2 Point_2; Point_2 bpt1 = lessx(v(r1, 0), v(r2, 0)) ? v(r1, 0) : v(r2, 0); Point_2 bpt2 = lessy(v(r1, 0), v(r2, 0)) ? v(r1, 0) : v(r2, 0); Point_2 bpt3 = lessx(v(r2, 2), v(r1, 2)) ? v(r1, 2) : v(r2, 2); Point_2 bpt4 = lessy(v(r2, 2), v(r1, 2)) ? v(r1, 2) : v(r2, 2); return rect(v(rect(bpt1, bpt2), 0), v(rect(bpt3, bpt4), 2)); #else return rect( v(rect(lessx(v(r1, 0), v(r2, 0)) ? v(r1, 0) : v(r2, 0), lessy(v(r1, 0), v(r2, 0)) ? v(r1, 0) : v(r2, 0)), 0), v(rect(lessx(v(r2, 2), v(r1, 2)) ? v(r1, 2) : v(r2, 2), lessy(v(r2, 2), v(r1, 2)) ? v(r1, 2) : v(r2, 2)), 2)); #endif } // construct_bounding_box_union_2(r1, r2, t) template < class Rectangle > inline Rectangle construct_bounding_box_union_2(const Rectangle& r1, const Rectangle& r2) { typename Rectangle::R t; return construct_bounding_box_union_2(r1, r2, t); } // construct_bounding_box_union_2(r1, r2) CGAL_END_NAMESPACE #endif // ! (CGAL_RECTANGULAR_P_CENTER_TRAITS_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_trapezoid_ric_point_location.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_trapezoid_ric_point0000644000175000017500000001071311344301500031450 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_trapezoid_ric_point_location.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_PM_TRAPEZOID_RIC_POINT_LOCATION_C #define CGAL_PM_TRAPEZOID_RIC_POINT_LOCATION_C #include CGAL_BEGIN_NAMESPACE //IMPLEMENTATION //if unbounded face - returns NULL or some edge on unbounded face //if its a vertex returns a halfedge pointing _at_ it /* postconditions: The output Halfedge_handle represents a planar map subdivision region that contains the input Point in its interior or equal to it. The input Locate_type is equal to the type of this region. */ template typename Pm_trapezoid_ric_point_location::Halfedge_const_handle Pm_trapezoid_ric_point_location::locate(const Point& p, Locate_type& lt) const { //there are different internal compiler errors if we // typedef the Locate_type typename TD::Locate_type td_lt; const X_curve_plus& cv = td.locate(p,td_lt).top(); // treat special case, where trapezoid is unbounded. // for then get_parent() is not defined if (td_lt==TD::UNBOUNDED_TRAPEZOID) { lt=PM::UNBOUNDED_FACE; return halfedge_representing_unbounded_face(); } Halfedge_const_handle h = cv.get_parent(); lt=convert(p,td_lt,h); return h; } template typename Pm_trapezoid_ric_point_location::Halfedge_handle Pm_trapezoid_ric_point_location::locate(const Point& p, Locate_type& lt){ ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); if (!((Bounding_box*)get_bounding_box())->locate(p,lt,h)) h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); return h; } /* postconditions: The output Halfedge_handle represents a planar map subdivision region that contains the first Point on the closed vertical ray eminating from the input Point in upward or downward direction depending on the input bool in its interior or equal to it. The input Locate_type is equal to the type of this region. */ template typename Pm_trapezoid_ric_point_location::Halfedge_const_handle Pm_trapezoid_ric_point_location:: vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) const { //trying to workaround internal compiler error typename TD::Locate_type td_lt; X_curve_plus cv = td.vertical_ray_shoot(p,td_lt,up); // treat special case, where trapezoid is unbounded. // for then get_parent() is not defined if (td_lt==TD::UNBOUNDED_TRAPEZOID) { lt=PM::UNBOUNDED_FACE; return halfedge_representing_unbounded_face(); } Halfedge_const_handle h=cv.get_parent(); lt=convert(p,td_lt,h,up); return h; } template typename Pm_trapezoid_ric_point_location::Halfedge_handle Pm_trapezoid_ric_point_location:: vertical_ray_shoot(const Point& p, Locate_type& lt, bool up) { /* Make sure the source point is in the bounding box on the output */ ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); /* Apply the bounding box on the output */ if (!((Bounding_box*)get_bounding_box())->vertical_ray_shoot(p,lt, up,h)) { h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); CGAL_assertion(lt!=Planar_map::UNBOUNDED_FACE); } return h; } CGAL_END_NAMESPACE #endif // CGAL_PM_DEFAULT_POINT_LOCATION_C ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_utils.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_utils0000644000175000017500000001663111344301501031511 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_utils.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SQUARED_DISTANCE_UTILS_H #define CGAL_SQUARED_DISTANCE_UTILS_H #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template bool is_null(const typename K::Vector_2 &v, const K&) { typedef typename K::RT RT; return v.hx()==RT(0) && v.hy()==RT(0); } template typename K::RT wdot(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K&) { return (u.hx()*v.hx() + u.hy()*v.hy()); } template typename K::RT wdot_tag(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K&, const Cartesian_tag&) { return (p.x() - q.x()) * (r.x() - q.x()) + (p.y() - q.y()) * (r.y() - q.y()); } template typename K::RT wdot_tag(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K&, const Homogeneous_tag&) { return (p.hx() * q.hw() - q.hx() * p.hw()) * (r.hx() * q.hw() - q.hx() * r.hw()) + (p.hy() * q.hw() - q.hy() * p.hw()) * (r.hy() * q.hw() - q.hy() * r.hw()); } template typename K::RT wdot(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return wdot_tag(p, q, r, k, tag); } template typename K::RT wcross(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K&) { return (typename K::RT)(u.hx()*v.hy() - u.hy()*v.hx()); } template inline typename K::RT wcross_tag(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K&, const Homogeneous_tag&) { return det3x3_by_formula( p.hx(), q.hx(), r.hx(), p.hy(), q.hy(), r.hy(), p.hw(), q.hw(), r.hw()); } template inline typename K::FT wcross_tag(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K&, const Cartesian_tag&) { return (q.x()-p.x())*(r.y()-q.y()) - (q.y()-p.y())*(r.x()-q.x()); } template typename K::RT wcross(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return wcross_tag(p, q, r, k, tag); } template inline bool is_acute_angle(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wdot(u, v, k)) > RT(0) ; } template inline bool is_straight_angle(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wdot(u, v, k)) == RT(0) ; } template inline bool is_obtuse_angle(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wdot(u, v, k)) < RT(0) ; } template inline bool is_acute_angle(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K& k) { typedef typename K::RT RT; return RT(wdot(p, q, r, k)) > RT(0) ; } template inline bool is_straight_angle(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K& k) { typedef typename K::RT RT; return RT(wdot(p, q, r, k)) == RT(0) ; } template inline bool is_obtuse_angle(const typename K::Point_2 &p, const typename K::Point_2 &q, const typename K::Point_2 &r, const K& k) { typedef typename K::RT RT; return RT(wdot(p, q, r, k)) < RT(0) ; } template Orientation orientation(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; RT wcr = wcross(u,v, k); return (wcr > RT(0)) ? COUNTERCLOCKWISE : (wcr < RT(0)) ? CLOCKWISE : COLLINEAR; } template inline bool counterclockwise(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wcross(u,v, k)) > RT(0); } template inline bool left_turn(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wcross(u,v, k)) > RT(0); } template inline bool clockwise(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wcross(u,v, k)) < RT(0); } template inline bool right_turn(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wcross(u,v, k)) < RT(0); } template inline bool collinear(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::RT RT; return RT(wcross(u,v, k)) == RT(0); } /* the ordertype, right_turn, left_turn and collinear routines for points are defined elsewhere. */ template inline bool same_direction_tag(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K&, const Cartesian_tag&) { typedef typename K::FT FT; const FT& ux = u.x(); const FT& uy = u.y(); if (CGAL_NTS abs(ux) > CGAL_NTS abs(uy)) { return CGAL_NTS sign(ux) == CGAL_NTS sign(v.x()); } else { return CGAL_NTS sign(uy) == CGAL_NTS sign(v.y()); } } template inline bool same_direction_tag(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K&, const Homogeneous_tag&) { typedef typename K::RT RT; const RT& uhx = u.hx(); const RT& uhy = u.hy(); if (CGAL_NTS abs(uhx) > CGAL_NTS abs(uhy)) { return CGAL_NTS sign(uhx) == CGAL_NTS sign(v.hx()); } else { return CGAL_NTS sign(uhy) == CGAL_NTS sign(v.hy()); } } template inline bool same_direction(const typename K::Vector_2 &u, const typename K::Vector_2 &v, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return same_direction_tag(u,v, k, tag); } } // namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_SQUARED_DISTANCE_UTILS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_insert_utils.h0000644000175000017500000001054711344301500030360 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_insert_utils.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tali Zvi #ifndef CGAL_PM_INSERT_UTILS_H #define CGAL_PM_INSERT_UTILS_H #include #include CGAL_BEGIN_NAMESPACE template class Pm_curve_node : public Handle_for< typename SweepLineTraits_2::X_curve > { typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve X_curve; typedef Handle_for Handle_for_curve; typedef Pm_curve_node Self; typedef Point_plus_ Point_plus; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Handle_for_curve::ptr; #endif public: Pm_curve_node(const X_curve& cv, const Point_plus& p, Traits* traits_) : Handle_for_curve(cv), m_point(p), m_traits(traits_) {} ~Pm_curve_node() {} bool operator==(const Pm_curve_node & cv_node) const { return *ptr() == *(cv_node.ptr()); } bool operator!=(const Pm_curve_node & cv_node) const { return !operator==(cv_node); } const X_curve & get_curve() const { return *ptr(); } Point_plus & get_point() { return m_point; } Self & operator=(const Self & cv_node) { Handle_for_curve::operator=(cv_node); return *this; } private: Point_plus m_point; Traits * m_traits; }; /*! A class describing an intersection point. It contains the point itself and a list of all curves going through that point, ordered by compare_at_x and compare_at_x_right of the traits. */ template class Pm_point_node { public: typedef Pm_point_node Self; typedef SweepLineTraits_2 Traits; typedef typename Traits::X_curve X_curve; typedef typename Traits::Point Point; typedef Point_plus_ Point_plus; typedef Pm_curve_node Curve_node_; typedef std::vector Curve_node_container; typedef typename Curve_node_container::iterator Curve_node_iterator; typedef typename Curve_node_container::const_iterator Curve_node_const_iterator; Pm_point_node(Traits *traits_) : m_traits(traits_) {} Pm_point_node(const Curve_node_& cv, Traits *traits_) : m_intersect_p(cv.get_point()), m_traits(traits_) { m_curves.push_back(cv); } Pm_point_node(const Curve_node_& cv, const Point_plus & ref_point, Traits * traits_) : m_intersect_p(ref_point), m_traits(traits_) { m_curves.push_back(cv); } void add_curve(Curve_node_ & cv) { m_curves.push_back(cv); } Point_plus & get_point() { return m_intersect_p; } const Point_plus & get_point() const { return m_intersect_p; } Curve_node_iterator curves_begin() { return m_curves.begin(); } Curve_node_iterator curves_end() { return m_curves.end(); } Curve_node_const_iterator curves_begin() const { return m_curves.begin(); } Curve_node_const_iterator curves_end() const { return m_curves.end(); } protected: Point_plus m_intersect_p; Curve_node_container m_curves; Traits *m_traits; }; template class Pm_less_point_xy { public: typedef SweepLineTraits_2 Traits; Pm_less_point_xy(Traits *traits_) : m_traits(traits_) {} inline bool operator()(const Point & p1, const Point & p2) const { return (m_traits->compare_xy(p1, p2) == SMALLER); } private: Traits * m_traits; }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_cell_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_cell_0000644000175000017500000001343311344301501031414 0ustar debiandebian// Copyright (c) 1999,2000,2001,2002,2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_cell_base_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud // cell of a triangulation data structure of any dimension <=3 #ifndef CGAL_TRIANGULATION_DS_CELL_BASE_3_H #define CGAL_TRIANGULATION_DS_CELL_BASE_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename TDS = void > class Triangulation_ds_cell_base_3 { public: typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Cell_handle Cell_handle; template struct Rebind_TDS { typedef Triangulation_ds_cell_base_3 Other; }; Triangulation_ds_cell_base_3() { set_vertices(); set_neighbors(); } Triangulation_ds_cell_base_3(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3) { set_vertices(v0, v1, v2, v3); set_neighbors(); } Triangulation_ds_cell_base_3(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Cell_handle& n0, const Cell_handle& n1, const Cell_handle& n2, const Cell_handle& n3) { set_vertices(v0, v1, v2, v3); set_neighbors(n0, n1, n2, n3); } // ACCESS FUNCTIONS const Vertex_handle& vertex(int i) const { CGAL_triangulation_precondition( i >= 0 && i <= 3 ); return V[i]; } bool has_vertex(const Vertex_handle& v) const { return (V[0] == v) || (V[1] == v) || (V[2]== v) || (V[3]== v); } bool has_vertex(const Vertex_handle& v, int & i) const { if (v == V[0]) { i = 0; return true; } if (v == V[1]) { i = 1; return true; } if (v == V[2]) { i = 2; return true; } if (v == V[3]) { i = 3; return true; } return false; } int index(const Vertex_handle& v) const { if (v == V[0]) { return 0; } if (v == V[1]) { return 1; } if (v == V[2]) { return 2; } CGAL_triangulation_assertion( v == V[3] ); return 3; } const Cell_handle& neighbor(int i) const { CGAL_triangulation_precondition( i >= 0 && i <= 3); return N[i]; } bool has_neighbor(const Cell_handle& n) const { return (N[0] == n) || (N[1] == n) || (N[2] == n) || (N[3] == n); } bool has_neighbor(const Cell_handle& n, int & i) const { if(n == N[0]){ i = 0; return true; } if(n == N[1]){ i = 1; return true; } if(n == N[2]){ i = 2; return true; } if(n == N[3]){ i = 3; return true; } return false; } int index(const Cell_handle& n) const { if (n == N[0]) return 0; if (n == N[1]) return 1; if (n == N[2]) return 2; CGAL_triangulation_assertion( n == N[3] ); return 3; } // SETTING void set_vertex(int i, const Vertex_handle& v) { CGAL_triangulation_precondition( i >= 0 && i <= 3); V[i] = v; } void set_neighbor(int i, const Cell_handle& n) { CGAL_triangulation_precondition( i >= 0 && i <= 3); N[i] = n; } void set_vertices() { V[0] = V[1] = V[2] = V[3] = Vertex_handle(); } void set_vertices(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3) { V[0] = v0; V[1] = v1; V[2] = v2; V[3] = v3; } void set_neighbors() { N[0] = N[1] = N[2] = N[3] = Cell_handle(); } void set_neighbors(const Cell_handle& n0, const Cell_handle& n1, const Cell_handle& n2, const Cell_handle& n3) { N[0] = n0; N[1] = n1; N[2] = n2; N[3] = n3; } // CHECKING // the following trivial is_valid allows // the user of derived cell base classes // to add their own purpose checking bool is_valid(bool, int ) const {return true;} // Obsolete : it's redundant with the default constructor. void init() const {} // For use by Compact_container. void * for_compact_container() const { return N[0].for_compact_container(); } void * & for_compact_container() { return N[0].for_compact_container(); } private: Cell_handle N[4]; Vertex_handle V[4]; }; template < class TDS > inline std::istream& operator>>(std::istream &is, Triangulation_ds_cell_base_3 &) // non combinatorial information. Default = nothing { return is; } template < class TDS > inline std::ostream& operator<<(std::ostream &os, const Triangulation_ds_cell_base_3 &) // non combinatorial information. Default = nothing { return os; } // Specialisation for void. template <> class Triangulation_ds_cell_base_3 { public: typedef Dummy_tds_3 Triangulation_data_structure; typedef Triangulation_data_structure::Vertex_handle Vertex_handle; typedef Triangulation_data_structure::Cell_handle Cell_handle; template struct Rebind_TDS { typedef Triangulation_ds_cell_base_3 Other; }; }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DS_CELL_BASE_3_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Iso_rectangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Iso_rectangl0000644000175000017500000002134711344301500031266 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_2_Iso_rectangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SEGMENT_2_ISO_RECTANGLE_2_INTERSECTION_H #define CGAL_SEGMENT_2_ISO_RECTANGLE_2_INTERSECTION_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Segment_2_Iso_rectangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Segment_2_Iso_rectangle_2_pair() ; Segment_2_Iso_rectangle_2_pair(typename K::Segment_2 const *seg, typename K::Iso_rectangle_2 const *rect) ; Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _ref_point; mutable typename K::Vector_2 _dir; mutable typename K::Point_2 _isomin; mutable typename K::Point_2 _isomax; mutable typename K::FT _min, _max; }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Segment_2 &p1, const typename CGAL_WRAP(K)::Iso_rectangle_2 &p2, const K&) { typedef Segment_2_Iso_rectangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template Object intersection( const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const K&) { typedef Segment_2_Iso_rectangle_2_pair is_t; is_t ispair(&seg, &iso); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 ipt; ispair.intersection(ipt); return make_object(ipt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } template inline Object intersection(const typename CGAL_WRAP(K)::Iso_rectangle_2 &iso, const typename CGAL_WRAP(K)::Segment_2 &seg, const K& k) { return CGALi::intersection(seg, iso, k); } template Segment_2_Iso_rectangle_2_pair::Segment_2_Iso_rectangle_2_pair() { _known = false; } template Segment_2_Iso_rectangle_2_pair:: Segment_2_Iso_rectangle_2_pair( typename K::Segment_2 const *seg, typename K::Iso_rectangle_2 const *iso) { _known = false; _isomin = iso->min(); _isomax = iso->max(); _ref_point = seg->source(); _dir = seg->direction().to_vector(); _min = (typename K::FT)(0); int main_dir = (CGAL_NTS abs(_dir.x()) > CGAL_NTS abs(_dir.y()) ) ? 0 : 1; typename K::Construct_cartesian_const_iterator_2 construct_cccit; typename K::Cartesian_const_iterator_2 seg_target_it = construct_cccit(seg->target()) + main_dir; typename K::Cartesian_const_iterator_2 ref_point_it = construct_cccit(_ref_point) + main_dir; _max = (*seg_target_it - *ref_point_it) / _dir.cartesian(main_dir); } template typename Segment_2_Iso_rectangle_2_pair::Intersection_results Segment_2_Iso_rectangle_2_pair::intersection_type() const { typedef typename K::RT RT; typedef typename K::FT FT; if (_known) return _result; _known = true; typename K::Construct_cartesian_const_iterator_2 construct_cccit; typename K::Cartesian_const_iterator_2 ref_point_it = construct_cccit(_ref_point); typename K::Cartesian_const_iterator_2 end = construct_cccit(_ref_point, 0); typename K::Cartesian_const_iterator_2 isomin_it = construct_cccit(_isomin); typename K::Cartesian_const_iterator_2 isomax_it = construct_cccit(_isomax); for (unsigned int i=0; ref_point_it != end; ++i, ++ref_point_it, ++isomin_it, ++isomax_it) { if (_dir.homogeneous(i) == RT(0)) { if ( *(ref_point_it) < *(isomin_it) ) { _result = NO; return _result; } if ( *(ref_point_it) > *(isomax_it)) { _result = NO; return _result; } } else { FT newmin, newmax; if (_dir.homogeneous(i) > RT(0)) { newmin = ( *(isomin_it) - (*ref_point_it)) / _dir.cartesian(i); newmax = ( *(isomax_it) - (*ref_point_it)) / _dir.cartesian(i); } else { newmin = ( (*isomax_it) - (*ref_point_it)) / _dir.cartesian(i); newmax = ( (*isomin_it) - *(ref_point_it)) / _dir.cartesian(i); } if (newmin > _min) _min = newmin; if (newmax < _max) _max = newmax; if (_max < _min) { _result = NO; return _result; } } } if (_max == _min) { _result = POINT; return _result; } _result = SEGMENT; return _result; } template bool Segment_2_Iso_rectangle_2_pair:: intersection(typename K::Segment_2 &seg) const { typedef typename K::Segment_2 Segment_2; typename K::Construct_translated_point_2 translated_point; typename K::Construct_scaled_vector_2 construct_scaled_vector; if (!_known) intersection_type(); if (_result != SEGMENT) return false; typename K::Point_2 p1(translated_point(_ref_point, construct_scaled_vector(_dir,_min))); typename K::Point_2 p2(translated_point(_ref_point, construct_scaled_vector(_dir,_max))); seg = Segment_2(p1, p2); return true; } template bool Segment_2_Iso_rectangle_2_pair:: intersection(typename K::Point_2 &pt) const { typedef typename K::Point_2 Point_2; typename K::Construct_translated_point_2 translated_point; typename K::Construct_scaled_vector_2 construct_scaled_vector; if (!_known) intersection_type(); if (_result != POINT) return false; pt = Point_2(translated_point(_ref_point, construct_scaled_vector(_dir,_min))); return true; } template class Iso_rectangle_2_Segment_2_pair: public Segment_2_Iso_rectangle_2_pair { public: Iso_rectangle_2_Segment_2_pair() {} Iso_rectangle_2_Segment_2_pair(typename K::Iso_rectangle_2 const *rect, typename K::Segment_2 const *seg) :Segment_2_Iso_rectangle_2_pair (seg, rect){} }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Iso_rectangle_2 &p1, const typename CGAL_WRAP(K)::Segment_2 &p2, const K&) { typedef Iso_rectangle_2_Segment_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } } // namespace CGALi template inline bool do_intersect(const Iso_rectangle_2 & iso, const Segment_2 &seg) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(seg, iso); } template inline bool do_intersect(const Segment_2 &seg, const Iso_rectangle_2 &iso) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(seg, iso); } template inline Object intersection( const Iso_rectangle_2 &iso, const Segment_2 &seg) { typedef typename K::Intersect_2 Intersect; return Intersect()(seg, iso); } template inline Object intersection(const Segment_2 &seg, const Iso_rectangle_2 &iso) { typedef typename K::Intersect_2 Intersect; return Intersect()(seg, iso); } CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_2_ISO_RECTANGLE_2_INTERSECTION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Distance_2.h0000644000175000017500000000463411344301500027153 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Distance_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec // Sylvain Pion #ifndef CGAL_DISTANCE_2_H #define CGAL_DISTANCE_2_H #include #include CGAL_BEGIN_NAMESPACE template struct Distance_2 { typedef typename I::Point Point; Distance_2(const I* = NULL) {} Distance_2(const Point& p0, const I* = NULL) { p[0]=p0; } Distance_2(const Point& p0, const Point& p1, const I* = NULL) { p[0]=p0; p[1]=p1; } Distance_2(const Point& p0, const Point& p1, const Point& p2, const I* = NULL) { p[0]=p0; p[1]=p1; p[2]=p2; } void set_point(int i, const Point& q) { CGAL_precondition( ((unsigned int) i) < 3 ); p[i] = q; } Point get_point(int i) const { CGAL_precondition( ((unsigned int) i) < 3 ); return p[i]; } Comparison_result compare() const { return cmp_dist_to_point(p[0], p[1], p[2]); } private: Point p[3]; }; template struct Distance_xy_3 : public Distance_2 { typedef typename Distance_2::Point Point; public: Distance_xy_3(const Point& p0, const Traits* traits = NULL) : Distance_2(p0, traits) { } Distance_xy_3(const Point& p0, const Point& p1, const Traits* traits = NULL) : Distance_2(p0,p1,traits) { } Distance_xy_3(const Point& p0, const Point& p1, const Point& p2, const Traits* traits = NULL) : Distance_2(p0,p1,p2,traits) { } Comparison_result compare() const { Point p0 = get_point(0); Point p1 = get_point(1); Point p2 = get_point(2); return cmp_dist_to_pointC2(x(p0),y(p0),x(p1),y(p1),x(p2),y(p2)); } }; CGAL_END_NAMESPACE #endif // CGAL_DISTANCE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Simple_homogeneous.h0000644000175000017500000000506511344301501031041 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Simple_homogeneous.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion #ifndef CGAL_SIMPLE_HOMOGENEOUS_H #define CGAL_SIMPLE_HOMOGENEOUS_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename RT_, typename FT_, typename Kernel > struct Homogeneous_base_no_ref_count : public Homogeneous_base< Kernel > { typedef RT_ RT; typedef FT_ FT; // The mecanism that allows to specify reference-counting or not. template < typename T > struct Handle { typedef T type; }; template < typename Kernel2 > struct Base { typedef Homogeneous_base_no_ref_count Type; }; // TODO: cleanup (use Rational_traits<> instead) static FT make_FT(const RT & num, const RT& denom) { return FT(num, denom); } static FT make_FT(const RT & num) { return FT(num); } static RT FT_numerator(const FT &r) { return r.numerator(); } static RT FT_denominator(const FT &r) { return r.denominator(); } }; template < typename RT_, typename FT_ = Quotient > struct Simple_homogeneous : public Type_equality_wrapper< Homogeneous_base_no_ref_count >, Simple_homogeneous > {}; CGAL_END_NAMESPACE #endif // CGAL_SIMPLE_HOMOGENEOUS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits.h0000644000175000017500000000241111344301500027762 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_KD_TREE_TRAITS_POINT_H #define CGAL_KD_TREE_TRAITS_POINT_H namespace CGAL { template class Search_traits { public: typedef CartesianCoordinateIterator Cartesian_const_iterator_d; typedef ConstructCartesianCoordinateIterator Construct_cartesian_const_iterator_d; typedef Point Point_d; typedef FT_ FT; }; } // namespace CGAL #endif // KD_TREE_TRAITS_POINT_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_function_objects_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_function_objects_2.0000644000175000017500000000362111344301500031254 0ustar debiandebian// Copyright (c) 2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_function_objects_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_CH_FUNCTION_OBJECTS_2_H #define CGAL_CH_FUNCTION_OBJECTS_2_H #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class r_Less_dist_to_line { public: typedef bool result_type; typedef Arity_tag< 4 > Arity; typedef typename R::Point_2 Point; typedef typename R::Line_2 Line; r_Less_dist_to_line() : line_constructed( false ) { } bool operator()(const Point& a, const Point& b, const Point& c, const Point& d) const { if (!line_constructed) { line_constructed = true; l_ab = Line(a,b); } Comparison_result res = compare_signed_distance_to_line(l_ab, c, d); if ( res == SMALLER ) { return true; } else if ( res == EQUAL ) { return lexicographically_xy_smaller( c, d ); } else { return false; } } private: mutable bool line_constructed; mutable Line l_ab; }; } // namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_CH_FUNCTION_OBJECTS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/0000755000175000017500000000000012146213724025765 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Visualizor.h0000644000175000017500000007442611344301501030310 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Visualizor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_VISUALIZOR_OPENGL_3_H #define CGAL_VISUALIZOR_OPENGL_3_H #include #include #include #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 157 #include #define CGAL_NEF3_MARKED_VERTEX_COLOR 183,232,92 #define CGAL_NEF3_MARKED_EDGE_COLOR 171,216,86 #define CGAL_NEF3_MARKED_FACET_COLOR 157,203,81 #define CGAL_NEF3_UNMARKED_VERTEX_COLOR 255,246,124 #define CGAL_NEF3_UNMARKED_EDGE_COLOR 255,236,94 #define CGAL_NEF3_UNMARKED_FACET_COLOR 249,215,44 CGAL_BEGIN_NAMESPACE namespace OGL { // ---------------------------------------------------------------------------- // Drawable double types: // ---------------------------------------------------------------------------- typedef CGAL::Simple_cartesian DKernel; typedef DKernel::Point_3 Double_point; typedef DKernel::Vector_3 Double_vector; typedef DKernel::Segment_3 Double_segment; typedef DKernel::Aff_transformation_3 Affine_3; // DPoint = a double point including a mark class DPoint : public Double_point { bool m_; public: DPoint() {} DPoint(const Double_point& p, bool m) : Double_point(p) { m_ = m; } DPoint(const DPoint& p) : Double_point(p) { m_ = p.m_; } DPoint& operator=(const DPoint& p) { Double_point::operator=(p); m_ = p.m_; return *this; } bool mark() const { return m_; } }; // DSegment = a double segment including a mark class DSegment : public Double_segment { bool m_; public: DSegment() {} DSegment(const Double_segment& s, bool m) : Double_segment(s) { m_ = m; } DSegment(const DSegment& s) : Double_segment(s) { m_ = s.m_; } DSegment& operator=(const DSegment& s) { Double_segment::operator=(s); m_ = s.m_; return *this; } bool mark() const { return m_; } }; // Double_triple = a class that stores a triple of double // coordinates; we need a pointer to the coordinates in a C array // for OpenGL class Double_triple { typedef double* double_ptr; typedef const double* const_double_ptr; double coords_[3]; public: Double_triple() { coords_[0]=coords_[1]=coords_[2]=0.0; } Double_triple(double x, double y, double z) { coords_[0]=x; coords_[1]=y; coords_[2]=z; } Double_triple(const Double_triple& t) { coords_[0]=t.coords_[0]; coords_[1]=t.coords_[1]; coords_[2]=t.coords_[2]; } Double_triple& operator=(const Double_triple& t) { coords_[0]=t.coords_[0]; coords_[1]=t.coords_[1]; coords_[2]=t.coords_[2]; return *this; } operator double_ptr() const { return const_cast(*this).coords_; } double operator[](unsigned i) { CGAL_assertion(i<3); return coords_[i]; } }; // Double_triple static std::ostream& operator << (std::ostream& os, const Double_triple& t) { os << "(" << t[0] << "," << t[1] << "," << t[2] << ")"; return os; } // DFacet stores the facet cycle vertices in a continuus C array // of three double components, this is necessary due to the OpenGL // tesselator input format ! class DFacet { typedef std::vector Coord_vector; typedef std::vector Cycle_vector; Coord_vector coords_; // stores all vertex coordinates Cycle_vector fc_ends_; // stores entry points of facet cycles Double_triple normal_; // stores normal and mark of facet bool mark_; public: typedef Coord_vector::iterator Coord_iterator; typedef Coord_vector::const_iterator Coord_const_iterator; DFacet() {} void push_back_vertex(double x, double y, double z) { coords_.push_back(Double_triple(x,y,z)); } DFacet(const DFacet& f) { coords_ = f.coords_; fc_ends_ = f.fc_ends_; normal_ = f.normal_; mark_ = f.mark_; } DFacet& operator=(const DFacet& f) { coords_ = f.coords_; fc_ends_ = f.fc_ends_; normal_ = f.normal_; mark_ = f.mark_; return *this; } ~DFacet() { coords_.clear(); fc_ends_.clear(); } void push_back_vertex(const Double_point& p) { push_back_vertex(p.x(),p.y(),p.z()); } void set_normal(double x, double y, double z, bool m) { double l = sqrt(x*x + y*y + z*z); normal_ = Double_triple(x/l,y/l,z/l); mark_ = m; } double dx() const { return normal_[0]; } double dy() const { return normal_[1]; } double dz() const { return normal_[2]; } bool mark() const { return mark_; } double* normal() const { return static_cast(normal_); } void new_facet_cycle() { fc_ends_.push_back(coords_.size()); } unsigned number_of_facet_cycles() const { return fc_ends_.size(); } Coord_iterator facet_cycle_begin(unsigned i) { CGAL_assertion(i(vertex)); GLdouble* pu(static_cast(user)); CGAL_NEF_TRACEN("vertexCallback coord "< vertices_; std::list edges_; std::list halffacets_; GLuint object_list_; bool init_, axes_, surface_; Bbox_3 bbox_; typedef std::list::const_iterator Vertex_iterator; typedef std::list::const_iterator Edge_iterator; typedef std::list::const_iterator Halffacet_iterator; public: Polyhedron() : bbox_(-1,-1,-1,1,1,1) { object_list_ = 0; init_ = axes_ = false; surface_ = true; } Polyhedron(const Polyhedron& p) { object_list_ = 0; init_ = axes_ = false; surface_ = true; } Polyhedron& operator=(const Polyhedron& p) { return *this; } ~Polyhedron() { if (object_list_) glDeleteLists(object_list_, 4); } void push_back(const Double_point& p, bool m) { vertices_.push_back(DPoint(p,m)); } void push_back(const Double_segment& s, bool m) { edges_.push_back(DSegment(s,m)); } void push_back(const DFacet& f) { halffacets_.push_back(f); } void toggle_axes() { axes_ = !axes_; } void skeleton_on() { surface_ = false; } void boundary_on() { surface_ = true; } bool is_initialized() const { return init_; } Bbox_3 bbox() const { return bbox_; } Bbox_3& bbox() { return bbox_; } void draw(Vertex_iterator v) const { CGAL_NEF_TRACEN("drawing vertex "<<*v); CGAL::Color cf(CGAL_NEF3_MARKED_VERTEX_COLOR), ct(CGAL_NEF3_UNMARKED_VERTEX_COLOR); // more blue-ish CGAL::Color c = v->mark() ? ct : cf; glPointSize(10); glColor3ub(c.red(), c.green(), c.blue()); glBegin(GL_POINTS); glVertex3d(v->x(),v->y(),v->z()); glEnd(); } void draw(Edge_iterator e) const { CGAL_NEF_TRACEN("drawing edge "<<*e); Double_point p = e->source(), q = e->target(); CGAL::Color cf(CGAL_NEF3_MARKED_EDGE_COLOR), ct(CGAL_NEF3_UNMARKED_EDGE_COLOR); // more blue-ish CGAL::Color c = e->mark() ? ct : cf; glLineWidth(5); glColor3ub(c.red(),c.green(),c.blue()); glBegin(GL_LINE_STRIP); glVertex3d(p.x(), p.y(), p.z()); glVertex3d(q.x(), q.y(), q.z()); glEnd(); } void draw(Halffacet_iterator f) const { CGAL_NEF_TRACEN("drawing facet "<<(f->debug(),"")); GLUtesselator* tess_ = gluNewTess(); gluTessCallback(tess_, GLenum(GLU_TESS_VERTEX_DATA), (GLvoid (*)()) &vertexCallback); gluTessCallback(tess_, GLenum(GLU_TESS_BEGIN), (GLvoid (*)()) &beginCallback); gluTessCallback(tess_, GLenum(GLU_TESS_END), (GLvoid (*)()) &endCallback); gluTessCallback(tess_, GLenum(GLU_TESS_ERROR), (GLvoid (*)()) &errorCallback); gluTessProperty(tess_, GLenum(GLU_TESS_WINDING_RULE), GLU_TESS_WINDING_POSITIVE); DFacet::Coord_const_iterator cit; CGAL::Color cf(CGAL_NEF3_MARKED_FACET_COLOR), ct(CGAL_NEF3_UNMARKED_FACET_COLOR); // more blue-ish CGAL::Color c = (f->mark() ? ct : cf); glColor3ub(c.red(),c.green(),c.blue()); gluTessBeginPolygon(tess_,f->normal()); CGAL_NEF_TRACEN(" "); CGAL_NEF_TRACEN("Begin Polygon"); gluTessNormal(tess_,f->dx(),f->dy(),f->dz()); // forall facet cycles of f: for(unsigned i = 0; i < f->number_of_facet_cycles(); ++i) { gluTessBeginContour(tess_); CGAL_NEF_TRACEN(" Begin Contour"); // put all vertices in facet cycle into contour: for(cit = f->facet_cycle_begin(i); cit != f->facet_cycle_end(i); ++cit) { gluTessVertex(tess_, *cit, *cit); CGAL_NEF_TRACEN(" add Vertex"); } gluTessEndContour(tess_); CGAL_NEF_TRACEN(" End Contour"); } gluTessEndPolygon(tess_); CGAL_NEF_TRACEN("End Polygon"); gluDeleteTess(tess_); } void construct_axes() const { glLineWidth(2.0); // red x-axis glColor3f(1.0,0.0,0.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(5.0,0.0,0.0); glEnd(); // green y-axis glColor3f(0.0,1.0,0.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(0.0,5.0,0.0); glEnd(); // blue z-axis and equator glColor3f(0.0,0.0,1.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(0.0,0.0,5.0); glEnd(); // six coordinate points in pink: glPointSize(10); glBegin(GL_POINTS); glColor3f(1.0,0.0,0.0); glVertex3d(5,0,0); glColor3f(0.0,1.0,0.0); glVertex3d(0,5,0); glColor3f(0.0,0.0,1.0); glVertex3d(0,0,5); glEnd(); } void fill_display_lists() { glNewList(object_list_, GL_COMPILE); Vertex_iterator v; CGAL_forall_iterators(v,vertices_) draw(v); glEndList(); glNewList(object_list_+1, GL_COMPILE); Edge_iterator e; CGAL_forall_iterators(e,edges_) draw(e); glEndList(); glNewList(object_list_+2, GL_COMPILE); Halffacet_iterator f; CGAL_forall_iterators(f,halffacets_) draw(f); glEndList(); glNewList(object_list_+3, GL_COMPILE); // axes: construct_axes(); glEndList(); } void initialize() { if (init_) return; init_ = true; axes_ = false; object_list_ = glGenLists(4); CGAL_assertion(object_list_); fill_display_lists(); } void draw( GLdouble z_vec[3]) const { if (!is_initialized()) const_cast(*this).initialize(); double l = std::max( std::max( bbox().xmax() - bbox().xmin(), bbox().ymax() - bbox().ymin()), bbox().zmax() - bbox().zmin()); if ( l < 1) // make sure that a single point doesn't screw up here l = 1; glScaled( 4.0/l, 4.0/l, 4.0/l); glTranslated( -(bbox().xmax() + bbox().xmin()) / 2.0, -(bbox().ymax() + bbox().ymin()) / 2.0, -(bbox().zmax() + bbox().zmin()) / 2.0); if ( surface_ ) { //glEnable(GL_LIGHTING); glCallList(object_list_+2); // facets //glDisable(GL_LIGHTING); } // move edges and vertices a bit towards the view-point, // i.e., 1/100th of the unit vector in camera space double f = l / 4.0 / 100.0; glTranslated( z_vec[0] * f, z_vec[1] * f, z_vec[2] * f); glCallList(object_list_+1); // edges glCallList(object_list_); // vertices if (axes_) glCallList(object_list_+3); // axis } void debug(std::ostream& os = std::cerr) const { os << "OGL::Polyhedron" << std::endl; os << "Vertices:" << std::endl; Vertex_iterator v; CGAL_forall_iterators(v,vertices_) os << " "<<*v<<", mark="<mark()<debug(); os << std::endl; os << std::endl; } }; // Polyhedron // ---------------------------------------------------------------------------- // Viewer configuration: // ---------------------------------------------------------------------------- enum MenuEntries { ROTATE, SCALE, TRANSLATE, TRANS_Z, RESET_CONTROL, AXES, BOUNDARY, SKELETON, PERSP, FULLSCREEN, QUIT }; const double znear = 4.0; const double zfar = 4.0; const double eye = 6.0; const double wsize = 2.0; int window_width = 600; // Breite und int window_height = 600; // Hoehe des Fensters int window_radius = 300; // min(width,height) / 2 bool perspective = true; int mouse_x, mouse_y; // Mauskoordinaten linker button int interaction; // type of interaction in motion fct. int motion_mode = ROTATE; // Bewegen der Maus bei Mouse1 gedrueckt int submenu1, submenu2; double dx = 0; // Translation double dy = 0; // Translation double dz = 0; // Translation in Z double s = 0.4; // Skalierung Affine_3 rotation( IDENTITY); // Rotation long double factor_s; // Umrechnungsfaktor fuer Skalierung // our draw object: static std::vector polyhedra_; static std::vector titles_; static Polyhedron& add_polyhedron() { polyhedra_.push_back(Polyhedron()); return polyhedra_.back(); } static void show (int mode) { std::vector::iterator it; switch(mode) { case ROTATE: case SCALE: case TRANSLATE: case TRANS_Z: motion_mode = mode; break; case RESET_CONTROL: dx = dy = dz = 0.0; s = 0.5; rotation = Affine_3( IDENTITY); motion_mode = ROTATE; CGAL_forall_iterators(it,polyhedra_) it->initialize(); glutPostRedisplay(); break; case AXES: CGAL_forall_iterators(it,polyhedra_) it->toggle_axes(); glutPostRedisplay(); break; case BOUNDARY: CGAL_forall_iterators(it,polyhedra_) it->boundary_on(); //CGAL_forall_iterators(it,polyhedra_) it->draw(); glutPostRedisplay(); break; case SKELETON: CGAL_forall_iterators(it,polyhedra_) it->skeleton_on(); //CGAL_forall_iterators(it,polyhedra_) it->draw(); glutPostRedisplay(); break; case PERSP: perspective = ! perspective; break; case FULLSCREEN: glutFullScreen(); break; case QUIT: exit(0); } } // Mausknopf gedrueckt static void mouse (int button, int state, int x, int y) { mouse_x = x; mouse_y = y; interaction = 0; if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) { if ( GLUT_ACTIVE_SHIFT & glutGetModifiers()) interaction = SCALE; else interaction = motion_mode; } if (button == GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) if ( GLUT_ACTIVE_SHIFT & glutGetModifiers()) interaction = TRANS_Z; else interaction = TRANSLATE; } static Affine_3 virtual_sphere_transformation( double old_x, double old_y, double new_x, double new_y) { if ( old_x == new_x && old_y == new_y)// zero rotation. return Affine_3( IDENTITY); // Determine the projected vectors on the `sphere'. double dd = old_x * old_x + old_y * old_y; Double_vector v_old( old_x, old_y, ((dd < 0.5) ? std::sqrt(1-dd) : 0.5 / std::sqrt(dd))); dd = new_x * new_x + new_y * new_y; Double_vector v_new( new_x, new_y, ((dd < 0.5) ? std::sqrt(1-dd) : 0.5 / std::sqrt(dd))); Double_vector axis = cross_product( v_old, v_new); double angle = 0.0; double norm = std::sqrt( (v_old*v_old)*(v_new*v_new)); if ( norm != 0) { double x = v_old*v_new/ norm; if ( x <= -1) angle = M_PI; if ( x < 1) angle = std::acos(x); } double len = std::sqrt( double(axis * axis)); double s = std::sin( angle / 2.0) / len; double q1 = axis.x() * s; // quaternion double q2 = axis.y() * s; double q3 = axis.z() * s; double q0 = std::cos( angle / 2.0); double a = q1 * q2; double b = q0 * q3; double c = q1 * q3; double d = q0 * q2; double e = q2 * q3; double f = q0 * q1; double qq0 = q0 * q0; double qq1 = q1 * q1; double qq2 = q2 * q2; double qq3 = q3 * q3; return Affine_3( qq0 + qq1 - qq2 - qq3, 2 * (a-b), 2 * (c+d), 2 * (a+b), qq0 - qq1 + qq2 - qq3, 2 * (e-f), 2 * (c-d), 2 * (e+f), qq0 - qq1 - qq2 + qq3); } // Objekt rotieren, zoomen oder verschieben static void motion (int x, int y) { switch ( interaction) { case SCALE: s *= exp( (x - mouse_x + mouse_y -y) * factor_s ); break; case ROTATE: { double old_x = 1.2 * (mouse_x - window_width/2) / window_radius; double old_y = - 1.2 * (mouse_y - window_height/2) / window_radius; double new_x = 1.2 * (x - window_width/2) / window_radius; double new_y = - 1.2 * (y - window_height/2) / window_radius; rotation = virtual_sphere_transformation( old_x, old_y, new_x, new_y) * rotation; } break; case TRANSLATE: dx += (x - mouse_x) * 2.0 / window_radius; dy -= (y - mouse_y) * 2.0 / window_radius; break; case TRANS_Z: dz += (x - mouse_x + mouse_y -y) * 2.0 / window_radius; break; default: break; } mouse_x = x; mouse_y = y; glutPostRedisplay(); } static void initialize_olg() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); /* GLfloat light_ambient[4] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; // white diffuse light GLfloat light_position[] = { 2.0, 3.0, -4.0, 0.0 }; // infinite location //GLfloat light_position[] = { 3.0, 5.0, 4.5, 1.0}; glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, light_ambient); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHT0); GLfloat mat_ambient[4] = { 0.1, 0.1, 0.1, 1.0 }; //GLfloat mat_back_ambient[4] = { 0.2, 0.0, 0.0, 1.0 }; GLfloat mat_diffuse[4] = { 0.7, 0.7, 0.7, 1.0 }; //GLfloat mat_specular[4] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat mat_specular[4] = { 0.3, 0.3, 0.3, 1.0 }; GLfloat mat_shininess[] = { 100.0 }; glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient ); //glMaterialfv(GL_BACK, GL_AMBIENT, mat_back_ambient ); glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse ); glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular ); glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess ); */ glDepthFunc( GL_LEQUAL); glShadeModel( GL_FLAT); glEnable(GL_AUTO_NORMAL); glEnable(GL_DEPTH_TEST); glEnable(GL_POINT_SMOOTH); glEnable(GL_NORMALIZE); //glColorMaterial(GL_FRONT_AND_BACK,GL_DIFFUSE); //glEnable(GL_COLOR_MATERIAL); } static void enter_leave(int state) { glutPostRedisplay(); } static void draw() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glPushMatrix(); if (window_width > window_height) { double w = double( window_width) / double( window_height); if ( perspective) { double s = (eye - znear) / eye; glFrustum( -wsize*w*s, wsize*w*s, -wsize*s, wsize*s, eye-znear, eye+zfar); glTranslated( 0.0, 0.0, -eye); } else { glOrtho( -wsize*w, wsize*w, -wsize, wsize, -znear, zfar ); } } else { double h = double( window_height) / double( window_width); if ( perspective) { double s = (eye - znear) / eye; glFrustum( -wsize*s, wsize*s, -wsize*h*s, wsize*h*s, eye-znear, eye+zfar); glTranslated( 0.0, 0.0, -eye); } else { glOrtho( -wsize, wsize, -wsize*h, wsize*h, -znear, zfar ); } } glTranslated(dx,dy,dz); glTranslated(0,0,1); GLdouble M[16] = { rotation.m(0,0), rotation.m(1,0), rotation.m(2,0), 0.0, rotation.m(0,1), rotation.m(1,1), rotation.m(2,1), 0.0, rotation.m(0,2), rotation.m(1,2), rotation.m(2,2), 0.0, rotation.m(0,3), rotation.m(1,3), rotation.m(2,3), 1.0}; glMultMatrixd( M); glScaled(s,s,s); GLdouble z_vec[3] = { rotation.m(2,0) / s, rotation.m(2,1) / s, rotation.m(2,2) / s}; int win = glutGetWindow(); polyhedra_[win-1].draw( z_vec); glPopMatrix(); glutSwapBuffers(); } static void reshape(int width, int height) { window_width = width; window_height = height; window_radius = std::min( width, height) / 2; factor_s = std::log(2.0) / (window_radius/2.0); // radius == scale factor 2 glViewport(0, 0, (GLint)width, (GLint)height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); } static void start_viewer() { glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); glutInitWindowSize(window_width, window_height); glutInitWindowPosition(0,0); int submenu1 = glutCreateMenu(show); glutAddMenuEntry("Reset",RESET_CONTROL); glutAddMenuEntry("Rotate",ROTATE); glutAddMenuEntry("Scale",SCALE); glutAddMenuEntry("Translate in XY",TRANSLATE); glutAddMenuEntry("Translate in Z",TRANS_Z); int submenu2 = glutCreateMenu(show); glutAddMenuEntry("Boundary",BOUNDARY); glutAddMenuEntry("Skeleton",SKELETON); glutAddMenuEntry("Toggle Axes",AXES); for (unsigned i = 0; i < polyhedra_.size(); ++i) { if (i > 0 ) glutInitWindowPosition(i*(window_width+12),0); if ( i < titles_.size() ) glutCreateWindow(titles_[i].c_str()); else glutCreateWindow(" Polyhedron "); glutEntryFunc(enter_leave); initialize_olg(); glutDisplayFunc(draw); glutReshapeFunc(reshape); glutMouseFunc(mouse); glutMotionFunc(motion); glutCreateMenu(show); glutAddSubMenu("Control",submenu1); glutAddSubMenu("Render",submenu2); glutAddMenuEntry("Persp/Ortho",PERSP); glutAddMenuEntry("Fullscreen",FULLSCREEN); glutAddMenuEntry("Quit",QUIT); glutAttachMenu(GLUT_RIGHT_BUTTON); } glutMainLoop(); } } // namespace OGL // ---------------------------------------------------------------------------- // SNC_visualizor_OGL // when you define a SNC_visualizor_OGL object then you create a // viewer window that shows the corresponding SNC_ object. All such viewers // follow the same visualization motion. Thus visualizing binary operations // is easy: just display the two input SNCs and the output SNC // // for similar viewer code see Nef_S2/demo/Nef_S2/Nef_polyhedron_S2-demo.C // ---------------------------------------------------------------------------- template class Visualizor_OpenGL_3 { typedef typename Nef_polyhedron::SNC_structure SNC_structure; typedef CGAL::SNC_decorator Base; typedef CGAL::SNC_FM_decorator FM_decorator; CGAL::OGL::Polyhedron* ppoly_; public: typedef typename SNC_structure::Vertex_const_iterator Vertex_const_iterator; typedef typename SNC_structure::Halfedge_const_iterator Halfedge_const_iterator; typedef typename SNC_structure::Halffacet_const_iterator Halffacet_const_iterator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Object_const_handle Object_const_handle; typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SNC_structure::Vertex_const_handle Vertex_const_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Mark Mark; typedef typename SNC_structure::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; Nef_polyhedron N; Visualizor_OpenGL_3(const Nef_polyhedron& Nef) : N(Nef) { ppoly_ = & CGAL::OGL::add_polyhedron(); } OGL::Double_point double_point(const Point_3& p) const { return OGL::Double_point(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(p.z())); } OGL::Double_segment double_segment(const Segment_3& s) const { return OGL::Double_segment(double_point(s.source()), double_point(s.target())); } void draw(Vertex_const_handle v) const { Point_3 bp = N.point(v); CGAL_NEF_TRACEN("vertex " << bp); ppoly_->push_back(double_point(bp), N.mark(v)); } void draw(Halfedge_const_handle e) const { Vertex_const_handle s = N.source(e); Vertex_const_handle t = N.source(N.twin(e)); Segment_3 seg(N.point(s),N.point(t)); CGAL_NEF_TRACEN("edge " << seg); ppoly_->push_back(double_segment(seg), N.mark(e)); } void draw(Halffacet_const_handle f) const { OGL::DFacet g; Halffacet_cycle_const_iterator fc; // all facet cycles: CGAL_forall_facet_cycles_of(fc,f) if ( fc.is_shalfedge() ) { // non-trivial facet cycle g.new_facet_cycle(); SHalfedge_const_handle h = fc; SHalfedge_around_facet_const_circulator hc(h), he(hc); CGAL_For_all(hc,he){ // all vertex coordinates in facet cycle Point_3 sp = N.point(N.source(hc)); CGAL_NEF_TRACEN(" ");CGAL_NEF_TRACEN("facet" << sp); g.push_back_vertex(double_point(sp)); } } Vector_3 v = N.plane(f).orthogonal_vector(); g.set_normal(CGAL::to_double(v.x()), CGAL::to_double(v.y()), CGAL::to_double(v.z()), N.mark(f)); ppoly_->push_back(g); } // Returns the bounding box of the finite vertices of the polyhedron. // Returns $[-1,+1]^3$ as bounding box if no finite vertex exists. Bbox_3 bounded_bbox() const { bool first_vertex = true; Bbox_3 bbox( -1.0, -1.0, -1.0, 1.0, 1.0, 1.0); Vertex_const_iterator vi; CGAL_forall_vertices(vi, N) { Point_3 p = vi->point(); double x = CGAL::to_double(p.hx()); double y = CGAL::to_double(p.hy()); double z = CGAL::to_double(p.hz()); double w = CGAL::to_double(p.hw()); if (N.is_standard(vi)) { if(first_vertex) { bbox = Bbox_3(x/w, y/w, z/w, x/w, y/w, z/w); first_vertex = false; } else { bbox = bbox + Bbox_3(x/w, y/w, z/w, x/w, y/w, z/w); first_vertex = false; } } } return bbox; } void set_R(const Bbox_3 bbox) const { if(N.is_standard_kernel()) return; double size = abs(bbox.xmin()); if(size < bbox.xmax()) size = bbox.xmax(); if(size < bbox.ymin()) size = bbox.ymin(); if(size < bbox.ymax()) size = bbox.ymax(); if(size < bbox.zmin()) size = bbox.zmin(); if(size < bbox.zmax()) size = bbox.zmax(); N.set_size_of_infimaximal_box(size*10); CGAL_NEF_TRACEN("set infi box size to " << size); } void draw() const { Bbox_3 bbox(bounded_bbox()); ppoly_->bbox() = bbox; set_R(bbox); Vertex_const_iterator v; CGAL_forall_vertices(v,*N.sncp()) draw(v); Halfedge_const_iterator e; CGAL_forall_edges(e,*N.sncp()) draw(e); Halffacet_const_iterator f; CGAL_forall_facets(f,*N.sncp()) draw(f); } }; // Visualizor_OpenGL_3 CGAL_END_NAMESPACE #endif //CGAL_VISUALIZOR_OPENGL_3_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Pluecker_line_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Pluecker_line_3.0000644000175000017500000002462211344301501030765 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Pluecker_line_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_PLUECKER_LINE_3_H #define CGAL_PLUECKER_LINE_3_H #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 61 #include CGAL_BEGIN_NAMESPACE /*{\Manpage{Pluecker_line_3}{R}{Straight lines in 3-space}{pl}}*/ /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a directed straight line in the three-dimensional plane. Its representation is based on Pluecker coordinates. (For a treatment see the book on projected oriented geometry of Stolfi.)}*/ template class Pluecker_line_3; template class Pluecker_line_3 { /*{\Mtypes 6}*/ typedef R_ R; /*{\Mtypemember the standard kernel type.}*/ typedef typename R::RT RT; /*{\Mtypemember the ring type.}*/ typedef typename R::Point_3 Point_3; /*{\Mtypemember the point type of the standard kernel.}*/ typedef typename R::Line_3 Line_3; /*{\Mtypemember the line type of the standard kernel.}*/ /*{\Mtypemember iterator over Pluecker coefficients.}*/ typedef Pluecker_line_3 Self; // typedef Infimaximal_box::value_type, R> Infi_box; // typedef typename Infi_box::NT NT; typedef const RT* const_iterator; RT c_[6]; public: /*{\Mcreation 3}*/ Pluecker_line_3() {} /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to some line.}*/ Pluecker_line_3(const Line_3& l) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to |l|.}*/ { Point_3 p(l.point(0)), q(l.point(1)); c_[0] = p.hx()*q.hy() - p.hy()*q.hx(); c_[1] = p.hx()*q.hz() - p.hz()*q.hx(); c_[2] = p.hy()*q.hz() - p.hz()*q.hy(); c_[3] = p.hx()*q.hw() - p.hw()*q.hx(); c_[4] = p.hy()*q.hw() - p.hw()*q.hy(); c_[5] = p.hz()*q.hw() - p.hw()*q.hz(); } Pluecker_line_3(const Point_3& p, const Point_3& q) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to the oriented line through |p| and |q|.}*/ { c_[0] = p.hx()*q.hy() - p.hy()*q.hx(); c_[1] = p.hx()*q.hz() - p.hz()*q.hx(); c_[2] = p.hy()*q.hz() - p.hz()*q.hy(); c_[3] = p.hx()*q.hw() - p.hw()*q.hx(); c_[4] = p.hy()*q.hw() - p.hw()*q.hy(); c_[5] = p.hz()*q.hw() - p.hw()*q.hz(); } template Pluecker_line_3(Forward_iterator s, Forward_iterator e) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to line with the parameters |tuple [s,e)|.}*/ { int i=0; while (s!=e && i<6) c_[i++] = *s; CGAL_assertion(i==6); } /*{\Moperations 4 2 }*/ const_iterator begin() const { return c_; } /*{\Mop returns an iterator pointing to the first Pluecker coefficient.}*/ const_iterator end() const { return c_+6; } /*{\Mop returns an iterator pointing beyond the last Pluecker coefficient.}*/ Pluecker_line_3(const Self& l) { std::copy(l.begin(),l.end(),c_); } Self& operator=(const Self& l) { if (&l!=this) std::copy(l.begin(),l.end(),c_); return *this; } const RT& operator[](unsigned i) const /*{\Marrop returns constant access to the $i$th Pluecker coefficient.}*/ { CGAL_assertion(i<6); return c_[i]; } int sign() const /*{\Mop returns the sign of the first nonzero Pluecker coefficient within the ordered tuple of coefficients.}*/ { for (unsigned i=0; i<6; ++i) if (c_[i]!=RT(0)) return CGAL_NTS sign(c_[i]); CGAL_assertion_msg(0,"Pluecker line 0 0 0 0 0 0 shouldn't appear!!!"); return CGAL_NTS sign(c_[5]); } void normalize() //{\Mop reduces the Pluecker coefficients to a minimal //representation. This is done by dividing all Pluecker //coefficients by their common gcd.} { CGAL_NEF_TRACEN("normalize"); int i=0; while(i<6 && c_[i]==0) i++; if(i>5) return; RT D = c_[i]; CGAL_assertion(D!=0); for(++i; i<6; ++i) D = (c_[i]==0 ? D : CGAL_NTS gcd(D, c_[i])); if (D==0) return; CGAL_NEF_TRACEN("gcd" << D); for(int i=0; i<6; ++i) c_[i]/=D; } void negate() /*{\Mop negates all Pluecker coefficients.}*/ { for(int i=0; i<6; ++i) c_[i] = -c_[i]; } Self opposite() const /*{\Mop returns the line opposite to |\Mvar|. }*/ { Self res; std::negate N; std::transform(begin(), end(), res.c_, N); return res; } static int cmp(const Self& l1, const Self& l2) /*{\Mstatic returns the lexicographic order on lines defined on their Pluecker coefficient tuples.}*/ { for (unsigned i=0; i<5; ++i) { typename R::RT diff = l1[i]-l2[i]; if ( diff != typename R::RT(0) ) return CGAL_NTS sign(diff); } return CGAL_NTS sign(l1[5]-l2[5]); } }; // Pluecker_line_3 template class Pluecker_line_3 { /*{\Mtypes 6}*/ typedef R_ R; /*{\Mtypemember the standard kernel type.}*/ typedef typename R::FT FT; /*{\Mtypemember the ring type.}*/ typedef typename R::Point_3 Point_3; /*{\Mtypemember the point type of the standard kernel.}*/ typedef typename R::Line_3 Line_3; /*{\Mtypemember the line type of the standard kernel.}*/ /*{\Mtypemember iterator over Pluecker coefficients.}*/ typedef Pluecker_line_3 Self; // typedef Infimaximal_box::value_type, R> Infi_box; // typedef typename Infi_box::NT NT; typedef const FT* const_iterator; FT c_[6]; public: /*{\Mcreation 3}*/ Pluecker_line_3() {} /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to some line.}*/ Pluecker_line_3(const Line_3& l) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to |l|.}*/ { Point_3 p(l.point(0)), q(l.point(1)); c_[0] = p.x()*q.y() - p.y()*q.x(); c_[1] = p.x()*q.z() - p.z()*q.x(); c_[2] = p.y()*q.z() - p.z()*q.y(); c_[3] = p.x() - q.x(); c_[4] = p.y() - q.y(); c_[5] = p.z() - q.z(); } Pluecker_line_3(const Point_3& p, const Point_3& q) //{\Mcreate creates an instance |\Mvar| of type |\Mname| and // initializes it to the oriented line through |p| and |q|.} { c_[0] = p.x()*q.y() - p.y()*q.x(); c_[1] = p.x()*q.z() - p.z()*q.x(); c_[2] = p.y()*q.z() - p.z()*q.y(); c_[3] = p.x() - q.x(); c_[4] = p.y() - q.y(); c_[5] = p.z() - q.z(); } template Pluecker_line_3(Forward_iterator s, Forward_iterator e) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to line with the parameters |tuple [s,e)|.}*/ { int i=0; while (s!=e && i<6) c_[i++] = *s; CGAL_assertion(i==6); } /*{\Moperations 4 2 }*/ const_iterator begin() const { return c_; } /*{\Mop returns an iterator pointing to the first Pluecker coefficient.}*/ const_iterator end() const { return c_+6; } /*{\Mop returns an iterator pointing beyond the last Pluecker coefficient.}*/ Pluecker_line_3(const Self& l) { std::copy(l.begin(),l.end(),c_); } Self& operator=(const Self& l) { if (&l!=this) std::copy(l.begin(),l.end(),c_); return *this; } const FT& operator[](unsigned i) const /*{\Marrop returns constant access to the $i$th Pluecker coefficient.}*/ { CGAL_assertion(i<6); return c_[i]; } int sign() const /*{\Mop returns the sign of the first nonzero Pluecker coefficient within the ordered tuple of coefficients.}*/ { for (unsigned i=0; i<6; ++i) if (c_[i]!=FT(0)) return CGAL_NTS sign(c_[i]); CGAL_assertion_msg(0,"Pluecker line 0 0 0 0 0 0 shouldn't appear!!!"); return CGAL_NTS sign(c_[5]); } void normalize() //{\Mop reduces the Pluecker coefficients to a minimal //representation. This is done by dividing all Pluecker //coefficients by their common gcd.} { CGAL_NEF_TRACEN("normalize"); int i=0; while(i<6 && c_[i]==FT(0)) i++; if(i>5) return; FT D = c_[i]; if(D N; std::transform(begin(), end(), res.c_, N); return res; } static int cmp(const Self& l1, const Self& l2) /*{\Mstatic returns the lexicographic order on lines defined on their Pluecker coefficient tuples.}*/ { for (unsigned i=0; i<5; ++i) { typename R::FT diff = l1[i]-l2[i]; if ( diff != typename R::FT(0) ) return CGAL_NTS sign(diff); } return CGAL_NTS sign(l1[5]-l2[5]); } }; // Pluecker_line_3 template std::ostream& operator<<(std::ostream& os, const Pluecker_line_3& l) { switch( os.iword(CGAL::IO::mode) ) { case CGAL::IO::ASCII : for (unsigned i=0; i<6; ++i) os << l[i] << " "; return os; case CGAL::IO::BINARY : for (unsigned i=0; i<6; ++i) CGAL::write(os, l[i]); return os; default: os << "Pluecker_line_3("; for (unsigned i=0; i<5; ++i) os << l[i] << ", "; os << l[5] << ")"; } return os; } template Pluecker_line_3 categorize(const Pluecker_line_3& l, int& inverted) { Pluecker_line_3 res(l); if ( res.sign()<0 ) { res.negate(); inverted=1; } else inverted=-1; res.normalize(); CGAL_assertion(res.sign()!=0); return res; } struct Pluecker_line_lt { template bool operator()(const CGAL::Pluecker_line_3& l1, const CGAL::Pluecker_line_3& l2) const { return CGAL::Pluecker_line_3::cmp(l1,l2)<0; } }; CGAL_END_NAMESPACE #endif //CGAL_PLUECKER_LINE_3_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_overlayer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_overlayer0000644000175000017500000001461611344301501031020 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_overlayer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_SNC_SM_OVERLAYER_H #define CGAL_SNC_SM_OVERLAYER_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 131 #include #ifndef CGAL_USE_LEDA #define LEDA_MEMORY(t) #endif CGAL_BEGIN_NAMESPACE /*{\Manpage {SNC_SM_overlayer}{Refs_}{Overlay in the sphere}{O}}*/ template class SNC_SM_overlayer : public SM_overlayer { public: typedef SM_decorator_ SM_decorator; typedef typename SM_decorator::Map Map; typedef SM_overlayer Base; typedef SNC_SM_overlayer Self; // typedef typename Base::Constructor_parameter Constructor_parameter; typedef typename Base::SVertex_handle SVertex_handle; typedef typename Base::SHalfedge_handle SHalfedge_handle; typedef typename Base::SHalfloop_handle SHalfloop_handle; typedef typename Base::SFace_handle SFace_handle; typedef typename Base::SVertex_iterator SVertex_iterator; typedef typename Base::SHalfedge_iterator SHalfedge_iterator; typedef typename Base::SFace_iterator SFace_iterator; typedef typename Base::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Base::Sphere_kernel Sphere_kernel; typedef typename Map::Infi_box Infi_box; public: void simplify(); SNC_SM_overlayer(Map* M, const Sphere_kernel& G = Sphere_kernel()) : Base(M,G) {} }; template void SNC_SM_overlayer::simplify() { CGAL_NEF_TRACEN("simplifying"); typedef typename CGAL::Union_find::handle Union_find_handle; CGAL::Unique_hash_map< SFace_handle, Union_find_handle> Pitem(NULL); CGAL::Unique_hash_map< SVertex_handle, Union_find_handle> Vitem(NULL); CGAL::Union_find< SFace_handle> UF; SFace_iterator f; CGAL_forall_sfaces(f,*this) { Pitem[f] = UF.make_set(f); clear_face_cycle_entries(f); } if ( this->has_shalfloop() ) { SHalfloop_handle l = this->shalfloop(); SFace_handle f = *(UF.find(Pitem[face(l)])); link_as_loop(l,f); f = *(UF.find(Pitem[face(twin(l))])); link_as_loop(twin(l),f); } SHalfedge_iterator e, en; for(e = this->shalfedges_begin(); e != this->shalfedges_end(); e = en) { en = e; ++en; if ( en==twin(e) ) ++en; CGAL_NEF_TRACEN("can simplify ? " << PH(e)); if(!Infi_box::is_sedge_on_infibox(e)) { CGAL_NEF_TRACEN(mark(e) << " " << mark(face(e)) << " " << mark(face(twin(e)))); if (( mark(e) == mark(face(e)) && mark(e) == mark(face(twin(e))))){ CGAL_NEF_TRACEN("deleting "< linked(false); for (e = this->shalfedges_begin(); e != this->shalfedges_end(); ++e) { if ( linked[e] ) continue; SHalfedge_around_sface_circulator hfc(e),hend(hfc); SFace_handle f = *(UF.find( Pitem[face(e)])); CGAL_For_all(hfc,hend) { set_face(hfc,f); linked[hfc]=true; } store_sm_boundary_object(e,f); } SVertex_iterator v,vn; for(v = this->svertices_begin(); v != this->svertices_end(); v=vn) { vn=v; ++vn; if ( is_isolated(v) ) { if(Vitem[v] != NULL) { set_face(v,*(UF.find(Vitem[v]))); CGAL_NEF_TRACEN("incident face of " << PH(v) << " set to " << &*(face(v))); } else { set_face(v, *(UF.find(Pitem[face(v)]))); CGAL_NEF_TRACEN("isolated svertex " << PH(v) << " already has incident face " << &*(face(v))); } if ( mark(v) == mark(face(v)) ) { CGAL_NEF_TRACEN("removing isolated vertex"<sfaces_begin(); f != this->sfaces_end(); f=fn) { ++fn; Union_find_handle pit = Pitem[f]; if ( UF.find(pit) != pit ) { CGAL_NEF_TRACEN("delete face " << &*f); delete_face_only(f); } } CGAL_NEF_TRACEN(" "); CGAL_NEF_TRACEN("resulting vertex "); CGAL_forall_svertices(vn, *this) CGAL_NEF_TRACEN("|" << vn->point() << "|" << vn->mark()); CGAL_NEF_TRACEN(" "); CGAL_forall_shalfedges(en,*this) CGAL_NEF_TRACEN("|" << en->circle() << "|" << en->mark() << " " << en->incident_sface()->mark()); CGAL_NEF_TRACEN("---------------------"); } CGAL_END_NAMESPACE #endif //CGAL_SNC_SM_OVERLAYER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SM_visualizor.h0000644000175000017500000002040011344301501030726 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SM_visualizor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SM_VISUALIZOR_H #define CGAL_SM_VISUALIZOR_H #include #include #include #include #include #define LGREY CGAL::Color(170,170,200) #define DGREY CGAL::Color(30,30,50) CGAL_BEGIN_NAMESPACE template class SNC_SM_BooleColor { typedef typename Refs_::SVertex_const_handle SVertex_const_handle; typedef typename Refs_::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Refs_::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Refs_::SFace_const_handle SFace_const_handle; typedef typename Refs_::Mark Mark; public: Color color(SVertex_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfedge_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfloop_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SFace_const_handle, Mark m) const { return ( m ? DGREY : LGREY ); } }; template class SM_visualizor { /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to draw the structure of a sphere map into the surface of a OpenGL sphere. It is generic with respect to the template concept.}*/ public: typedef typename SM_explorer::Sphere_map Sphere_map; typedef CGAL::SNC_SM_BooleColor Color_; typedef typename Sphere_map::Sphere_kernel Sphere_kernel; // typedef CGAL::Sphere_map Sphere_map; // typedef typename SM_explorer::Sphere_map Sphere_map; typedef SM_decorator SM_decorator; typedef SM_triangulator SM_triangulator; typedef typename Sphere_map::SVertex_const_handle SVertex_const_handle; typedef typename Sphere_map::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Sphere_map::SFace_const_handle SFace_const_handle; typedef typename Sphere_map::SVertex_const_iterator SVertex_const_iterator; typedef typename Sphere_map::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Sphere_map::SFace_const_iterator SFace_const_iterator; typedef typename Sphere_map::Mark Mark; /* Here collide two handle worlds: Nef_S2::handles and Nef_3::handles: We have to separate symbols. In this class scope we stick to the Nef_3 world. All Nef_S2 handles obtain a SM_ prefix. */ typedef typename Sphere_map::SVertex_const_iterator SM_Vertex_const_iterator; typedef typename Sphere_map::SHalfedge_const_iterator SM_Halfedge_const_iterator; typedef typename Sphere_map::SHalfloop_const_iterator SM_Halfloop_const_iterator; typedef typename Sphere_map::SFace_const_iterator SM_Face_const_iterator; typedef typename Sphere_kernel::Sphere_point Sphere_point; typedef typename Sphere_kernel::Sphere_segment Sphere_segment; typedef typename Sphere_kernel::Sphere_circle Sphere_circle; typedef typename Sphere_kernel::Sphere_triangle Sphere_triangle; typedef Color_ Color_objects; protected: Sphere_map MT_; const SM_explorer* E_; SM_triangulator T_; Color_objects CO_; CGAL::OGL::Unit_sphere& S_; public: /*{\Mcreation 4}*/ SM_visualizor(const SM_explorer* E, CGAL::OGL::Unit_sphere& S) : MT_(true), E_(E), T_(&MT_,E_), S_(S) { T_.triangulate(); } /*{\Moperations 2 1}*/ /* |draw_map| draws all object of the sphere map referenced by E_: 1) edges, loops, and vertices are taken from E_ 2) faces are drawn via the calculated triangulation in MT_ */ void draw_map() const /*{\Mop draw the whole plane map.}*/ { // draw sphere segments underlying edges of E_: SHalfedge_const_iterator e; bool top=false; bool bot=false; CGAL_forall_sedges(e,*E_) { top = top || E_->point(E_->source(e)).hz() > 0 || E_->point(E_->target(e)).hz() > 0; bot = bot || E_->point(E_->source(e)).hz() < 0 || E_->point(E_->target(e)).hz() < 0; } CGAL_assertion(top || bot); CGAL_forall_sedges(e,*E_) { if ( E_->source(e) == E_->target(e) ) { S_.push_back(E_->circle(e), CO_.color(e,E_->mark(e))); } else /* if(E_->point(E_->source(e)) == E_->point(E_->target(e)).antipode()) { CGAL_assertion(!top || !bot); if(!top) S_.push_back(Sphere_segment(E_->point(E_->source(e)), E_->point(E_->target(e)), c),CO_.color(e,E_->mark(e))); else c=Sphere_circle(E_->point(E_->source(e)),Sphere_point(0,0,1)); } else */ S_.push_back(Sphere_segment(E_->point(E_->source(e)), E_->point(E_->target(e)), E_->circle(e)),CO_.color(e,E_->mark(e))); } // draw sphere circles underlying loops of E_: if ( E_->has_shalfloop() ) S_.push_back( Sphere_circle(E_->circle(E_->shalfloop())), CO_.color(E_->shalfloop(),E_->mark(E_->shalfloop()))); // draw points underlying vertices of E_: SVertex_const_iterator v; CGAL_forall_svertices(v,*E_) S_.push_back(E_->point(v),CO_.color(v,E_->mark(v))); SM_Halfedge_const_iterator h; Unique_hash_map Done(false); CGAL_forall_shalfedges(h,T_) { if ( Done[h] ) continue; SM_Halfedge_const_iterator hn(T_.next(h)),hnn(T_.next(hn)); CGAL_NEF_TRACEV(T_.incident_triangle(h)); CGAL_assertion( T_.incident_mark(h) == T_.incident_mark(hn) && T_.incident_mark(hn) == T_.incident_mark(hnn)); Mark m = T_.incident_mark(h); Sphere_triangle t = T_.incident_triangle(h); S_.push_back(t, (m ? DGREY : LGREY) ); Done[h]=Done[hn]=Done[hnn]=true; } CGAL_forall_sedges(h,T_) // for all sphere edges S_.push_back_triangle_edge(Sphere_segment(T_.point(T_.source(h)), T_.point(T_.target(h)), T_.circle(h))); } /* |draw_triangulation| draws all object of the underlying triangulation: triangles, edges, loops, and vertices taken from MT_ */ void draw_triangulation() const { // draw sphere segments underlying edges of triangulation: SHalfedge_const_iterator ed; SVertex_const_iterator vd; SM_Halfedge_const_iterator e; CGAL_forall_sedges(e,T_) { S_.push_back(Sphere_segment(T_.point(T_.source(e)),T_.point(T_.target(e)), T_.circle(e)),CO_.color(ed,T_.mark(e))); } // draw points underlying vertices of triangulation: SM_Vertex_const_iterator v; CGAL_forall_svertices(v,T_) S_.push_back(T_.point(v),CO_.color(vd,T_.mark(v))); Unique_hash_map Done(false); CGAL_forall_shalfedges(e,T_) { if ( Done[e] ) continue; SM_Halfedge_const_iterator en(T_.next(e)),enn(T_.next(en)); CGAL_assertion(T_.incident_mark(e)==T_.incident_mark(en)&& T_.incident_mark(en)==T_.incident_mark(enn)); Mark m = T_.incident_mark(e); Sphere_triangle t = T_.incident_triangle(e); S_.push_back(t, (m ? DGREY : LGREY) ); Done[e]=Done[en]=Done[enn]=true; } } }; // end of SM_Visualizor template void show_sphere_map_of(typename Sphere_map::Vertex_const_handle v) { CGAL::OGL::add_sphere(); SM_visualizor V(v,CGAL::OGL::spheres_.back()); V.draw_map(); CGAL::OGL::start_viewer(); } CGAL_END_NAMESPACE #endif // CGAL_SM_VISUALIZOR_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/binop_intersection_tests.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/binop_intersecti0000644000175000017500000002102211344301501031233 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/binop_intersection_tests.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Meyer #ifndef CGAL_BINOP_INTERSECTION_TESTS_H #define CGAL_BINOP_INTERSECTION_TESTS_H #include #include #include #include CGAL_BEGIN_NAMESPACE template struct binop_intersection_test_segment_tree { typedef typename SNC_decorator::SNC_structure SNC_structure; typedef typename SNC_decorator::SNC_intersection SNC_intersection; typedef typename SNC_decorator::Object_handle Object_handle; typedef typename SNC_decorator::Vertex_const_iterator Vertex_const_iterator; typedef typename SNC_decorator::Vertex_const_handle Vertex_const_handle; typedef typename SNC_decorator::Halfedge_const_iterator Halfedge_const_iterator; typedef typename SNC_decorator::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_decorator::Halffacet_const_iterator Halffacet_const_iterator; typedef typename SNC_decorator::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_decorator::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_decorator::Infi_box Infi_box; typedef typename SNC_decorator::Point_3 Point_3; typedef typename SNC_decorator::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_decorator::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename SNC_decorator::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; typedef CGAL::SNC_const_decorator Const_decorator; class Nef_box : public Box_intersection_d::Box_d< double, 3 > { Halffacet_const_handle f; Halfedge_const_handle e; enum Type { FACET, EDGE }; Type type; void extend( const Point_3& p ) { double q[3]; q[0] = CGAL::to_double( p.x() ); q[1] = CGAL::to_double( p.y() ); q[2] = CGAL::to_double( p.z() ); Box_intersection_d::Box_d< double, 3 >::extend(q); } public: Nef_box( Halffacet_const_handle f ) : f(f), type(FACET) { if( !Const_decorator::is_standard( f ) ) { init( true ); } else { init( false ); Halffacet_cycle_const_iterator cycle_it = f->facet_cycles_begin(); if( cycle_it.is_shalfedge() ) { SHalfedge_const_iterator edge_it(cycle_it); SHalfedge_around_facet_const_circulator start( edge_it ), end( edge_it ); CGAL_For_all( start, end ) { const Point_3& p = start->prev()->source()->source()->point(); extend( p ); } } else CGAL_assertion_msg(0, "is facet first cycle a SHalfloop?"); } } Nef_box( Halfedge_const_handle e ) : e(e), type(EDGE) { if(!Const_decorator::is_standard(e->source() ) || !Const_decorator::is_standard(e->twin()->source() ) ) { init( true ); } else { init( false ); extend( e->source()->point()); extend( e->twin()->source()->point()); } } Halffacet_const_handle get_halffacet() { assert( type == FACET ); return f; } Halfedge_const_handle get_halfedge() { assert( type == EDGE ); return e; } }; template struct Bop_edge0_face1_callback { SNC_intersection &is; Callback &cb; struct Pair_hash_function { typedef std::size_t result_type; template std::size_t operator() (const H& h) const { return std::size_t(&*(h.first)) / sizeof (typename std::iterator_traits::value_type) + std::size_t(&*(h.second)) / sizeof (typename std::iterator_traits::value_type); } }; Bop_edge0_face1_callback(SNC_intersection &is, Callback &cb) : is(is), cb(cb) {} void operator()( Nef_box& box0, Nef_box& box1 ) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Halfedge_const_iterator e0 = box0.get_halfedge(); Halffacet_const_iterator f1 = box1.get_halffacet(); if( Infi_box::degree( f1->plane().d() ) > 0 ) return; Point_3 ip; if( is.does_intersect_internally( Const_decorator::segment(e0), f1, ip )) { cb(e0,f1,ip); } } }; template struct Bop_edge1_face0_callback { SNC_intersection &is; Callback &cb; Bop_edge1_face0_callback(SNC_intersection &is, Callback &cb) : is(is), cb(cb) {} void operator()( Nef_box& box0, Nef_box& box1 ) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Halfedge_const_iterator e1 = box0.get_halfedge(); Halffacet_const_iterator f0 = box1.get_halffacet(); if( Infi_box::degree( f0->plane().d() ) > 0 ) return; Point_3 ip; if( is.does_intersect_internally( Const_decorator::segment( e1 ), f0, ip ) ) cb(e1,f0,ip); } }; template struct Bop_edge0_edge1_callback { SNC_intersection &is; Callback &cb; Bop_edge0_edge1_callback(SNC_intersection &is, Callback &cb) : is(is), cb(cb) {} void operator()( Nef_box& box0, Nef_box& box1 ) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Halfedge_const_iterator e0 = box0.get_halfedge(); Halfedge_const_iterator e1 = box1.get_halfedge(); Point_3 ip; if( is.does_intersect_internally( Const_decorator::segment( e0 ), Const_decorator::segment( e1 ), ip )) cb(e0,e1,ip); } }; template void operator()(Callback& cb0, Callback& cb1, const SNC_structure& sncp, const SNC_structure& snc1i) { Halfedge_const_iterator e0, e1; Halffacet_const_iterator f0, f1; std::vector a, b; SNC_intersection is( sncp ); CGAL_NEF_TRACEN("start edge0 edge1"); Bop_edge0_edge1_callback callback_edge0_edge1( is, cb0 ); CGAL_forall_edges( e0, sncp) a.push_back( Nef_box( e0 ) ); CGAL_forall_edges( e1, snc1i) b.push_back( Nef_box( e1 ) ); #ifdef CGAL_NEF3_BOX_INTERSECTION_CUTOFF box_intersection_d( a.begin(), a.end(), b.begin(), b.end(), callback_edge0_edge1, CGAL_NEF3_BOX_INTERSECTION_CUTOFF); #else box_intersection_d( a.begin(), a.end(), b.begin(), b.end(), callback_edge0_edge1); #endif a.clear(); b.clear(); CGAL_NEF_TRACEN("start edge0 face1"); Bop_edge0_face1_callback callback_edge0_face1( is, cb0 ); CGAL_forall_edges( e0, sncp ) a.push_back( Nef_box( e0 ) ); CGAL_forall_facets( f1, snc1i) b.push_back( Nef_box( f1 ) ); #ifdef CGAL_NEF3_BOX_INTERSECTION_CUTOFF box_intersection_d( a.begin(), a.end(), b.begin(), b.end(), callback_edge0_face1, CGAL_NEF3_BOX_INTERSECTION_CUTOFF); #else box_intersection_d( a.begin(), a.end(), b.begin(), b.end(), callback_edge0_face1); #endif a.clear(); b.clear(); CGAL_NEF_TRACEN("start edge1 face0"); Bop_edge1_face0_callback callback_edge1_face0( is, cb1 ); CGAL_forall_edges( e1, snc1i) a.push_back( Nef_box( e1 ) ); CGAL_forall_facets( f0, sncp ) b.push_back( Nef_box( f0 ) ); #ifdef CGAL_NEF3_BOX_INTERSECTION_CUTOFF box_intersection_d( a.begin(), a.end(), b.begin(), b.end(), callback_edge1_face0, CGAL_NEF3_BOX_INTERSECTION_CUTOFF); #else box_intersection_d( a.begin(), a.end(), b.begin(), b.end(), callback_edge1_face0); #endif } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_structure.h0000644000175000017500000013142311344301501030673 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_structure.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SNC_STRUCTURE_H #define CGAL_SNC_STRUCTURE_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 41 #include #include CGAL_BEGIN_NAMESPACE template struct move_shalfedge_around_facet { void forward(HE& e) const { e = (e->next()); } void backward(HE& e) const { e = (e->prev()); } }; template void merge_sets( Object o1, Object o2, Hash_map& hash, Union_find& uf) { //CGAL_assertion( hash[o1] != 0 && hash[o2] != 0); CGAL_assertion( hash.is_defined(o1) && hash.is_defined(o2)); if( !uf.same_set( hash[o1], hash[o2])) uf.unify_sets( hash[o1], hash[o2]); } template class SNC_sphere_map; template class SM_decorator; template class SNC_decorator; /*{\Manpage {SNC_structure}{Items}{Selective Nef Complex}{C}}*/ template class SNC_structure { /*{\Mdefinition The extended Wuerzburg structure is the topological structure of Nef polyhedra. It is programmed around the local graphs of the vertices of a Nef polyhedron, which describe the point set completely. All other concepts are either derived from the local graph or added for the comfort of the user.}*/ public: /*{\Mtypes 7}*/ typedef Items_ Items; typedef Kernel_ Kernel; typedef Mark_ Mark; typedef SNC_structure Self; // typedef bool Mark; typedef SNC_decorator SNC_decorator; typedef typename Kernel::FT FT; typedef typename Kernel::RT RT; typedef CGAL::Sphere_geometry Sphere_kernel; typedef SNC_sphere_map Sphere_map; typedef SM_decorator SM_decorator; typedef typename Kernel::Point_3 Point_3; /*{\Mtypemember embedding vertices.}*/ typedef typename Kernel::Plane_3 Plane_3; /*{\Mtypemember supporting facets.}*/ typedef typename Kernel::Vector_3 Vector_3; /*{\Mtypemember normal vectors.}*/ typedef typename Kernel::Direction_3 Direction_3; /*{\Mtypemember normal directions.}*/ typedef typename Kernel::Segment_3 Segment_3; /*{\Mtypemember segments in space.}*/ typedef typename Kernel::Line_3 Line_3; /*{\Mtypemember lines in space.}*/ typedef typename Kernel::Ray_3 Ray_3; /*{\Mtypemember rays in space.}*/ typedef typename Kernel::Triangle_3 Triangle_3; /*{\Mtypemember triangles in space.}*/ typedef typename Kernel::Aff_transformation_3 Aff_transformation_3; typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember points on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember segments on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember segments on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_direction Sphere_direction; /*{\Mtypemember directions on the unit sphere.}*/ typedef size_t Size_type; /*{\Mtypemember size type.}*/ private: friend class CGAL::SM_decorator; friend class CGAL::SNC_decorator; /*{\Mtext For all objects |Vertex|, |Halfedge|, |Halffacet|, |Volume| there are handle and iterator types |xxx_handle|, |xxx_iterator|. Additionally all objects of the local graph of a vertex |SVertex|, |SHalfedge|, |SHalfloop|, |SFace| are accessed via handles and iterators. There's no type |SHalfloop_iterator|, as there is at most one |SLoop| pair per vertex.}*/ public: typedef Sphere_map Vertex_base; typedef SNC_in_place_list_sm Vertex; typedef CGAL::In_place_list Vertex_list; typedef CGAL_ALLOCATOR(Vertex) Vertex_alloc; typedef typename Vertex_list::iterator Vertex_handle; typedef typename Vertex_list::const_iterator Vertex_const_handle; typedef typename Vertex_list::iterator Vertex_iterator; typedef typename Vertex_list::const_iterator Vertex_const_iterator; typedef typename Items::template Halffacet Halffacet_base; typedef SNC_in_place_list_halffacet Halffacet; typedef CGAL::In_place_list Halffacet_list; typedef CGAL_ALLOCATOR(Halffacet) Halffacet_alloc; typedef typename Halffacet_list::iterator Halffacet_handle; typedef typename Halffacet_list::const_iterator Halffacet_const_handle; typedef typename Halffacet_list::iterator Halffacet_iterator; typedef typename Halffacet_list::const_iterator Halffacet_const_iterator; typedef typename Items::template Volume Volume_base; typedef SNC_in_place_list_volume Volume; typedef CGAL::In_place_list Volume_list; typedef CGAL_ALLOCATOR(Volume) Volume_alloc; typedef typename Volume_list::iterator Volume_handle; typedef typename Volume_list::const_iterator Volume_const_handle; typedef typename Volume_list::iterator Volume_iterator; typedef typename Volume_list::const_iterator Volume_const_iterator; typedef typename Items::template SVertex SVertex_base; typedef SNC_in_place_list_svertex SVertex; typedef CGAL::In_place_list SVertex_list; typedef CGAL_ALLOCATOR(SVertex) SVertex_alloc; typedef typename SVertex_list::iterator SVertex_handle; typedef typename SVertex_list::const_iterator SVertex_const_handle; typedef typename SVertex_list::iterator SVertex_iterator; typedef typename SVertex_list::const_iterator SVertex_const_iterator; typedef typename Items::template SVertex Halfedge_base; typedef SNC_in_place_list_svertex Halfedge; typedef CGAL::In_place_list Halfedge_list; typedef CGAL_ALLOCATOR(SVertex) Halfedge_alloc; typedef typename SVertex_list::iterator Halfedge_handle; typedef typename SVertex_list::const_iterator Halfedge_const_handle; typedef typename SVertex_list::iterator Halfedge_iterator; typedef typename SVertex_list::const_iterator Halfedge_const_iterator; typedef typename Items::template SHalfedge SHalfedge_base; typedef SNC_in_place_list_shalfedge SHalfedge; typedef CGAL::In_place_list SHalfedge_list; typedef CGAL_ALLOCATOR(SHalfedge) SHalfedge_alloc; typedef typename SHalfedge_list::iterator SHalfedge_handle; typedef typename SHalfedge_list::const_iterator SHalfedge_const_handle; typedef typename SHalfedge_list::iterator SHalfedge_iterator; typedef typename SHalfedge_list::const_iterator SHalfedge_const_iterator; typedef typename Items::template SHalfloop SHalfloop_base; typedef SNC_in_place_list_shalfloop SHalfloop; typedef CGAL::In_place_list SHalfloop_list; typedef CGAL_ALLOCATOR(SHalfloop) SHalfloop_alloc; typedef typename SHalfloop_list::iterator SHalfloop_handle; typedef typename SHalfloop_list::const_iterator SHalfloop_const_handle; typedef typename SHalfloop_list::iterator SHalfloop_iterator; typedef typename SHalfloop_list::const_iterator SHalfloop_const_iterator; typedef typename Items::template SFace SFace_base; typedef SNC_in_place_list_sface SFace; typedef CGAL::In_place_list SFace_list; typedef CGAL_ALLOCATOR(SFace) SFace_alloc; typedef typename SFace_list::iterator SFace_handle; typedef typename SFace_list::const_iterator SFace_const_handle; typedef typename SFace_list::iterator SFace_iterator; typedef typename SFace_list::const_iterator SFace_const_iterator; typedef CGAL::Object_handle Object_handle; typedef std::list Object_list; typedef Object_list::iterator Object_iterator; typedef Object_list::const_iterator Object_const_iterator; typedef Object_list::const_iterator Object_const_handle; typedef typename Sphere_map::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Sphere_map::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Sphere_map::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; typedef typename Sphere_map::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_const_circulator; typedef typename Sphere_map::Infi_box Infi_box; typedef typename Infi_box::Standard_kernel Standard_kernel; typedef Vertex_handle Constructor_parameter; typedef Vertex_const_handle Constructor_const_parameter; // Halffacet triangle class Halffacet_triangle_handle : public Halffacet_handle { typedef Halffacet_handle Base; Triangle_3 triangle; public: Halffacet_triangle_handle() : Base() {} Halffacet_triangle_handle( Halffacet_handle h, Triangle_3 t = Triangle_3()) : Base(h), triangle(t) {} Triangle_3 get_triangle() { return triangle; } }; class Halffacet_cycle_iterator : public Object_iterator /*{\Mtypemember a generic handle to an object in the boundary of a facet. Convertible to |Object_handle|.}*/ { typedef Object_iterator Ibase; public: Halffacet_cycle_iterator() : Ibase() {} Halffacet_cycle_iterator(const Ibase& b) : Ibase(b) {} Halffacet_cycle_iterator(const Halffacet_cycle_iterator& i) : Ibase(i) {} bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SHalfedge_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return e; } operator SHalfloop_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return l; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_assertion_msg(0,"not impl."); return Object_handle();} }; class Halffacet_cycle_const_iterator : public Object_const_iterator /*{\Mtypemember a generic handle to an object in the boundary of a facet. Convertible to |Object_handle|.}*/ { typedef Object_const_iterator Ibase; public: Halffacet_cycle_const_iterator() : Ibase() {} Halffacet_cycle_const_iterator(const Ibase& b) : Ibase(b) {} Halffacet_cycle_const_iterator(const Halffacet_cycle_const_iterator& i) : Ibase(i) {} bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SHalfedge_const_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return SHalfedge_const_handle(e); } operator SHalfloop_const_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return SHalfloop_const_handle(l); } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_assertion_msg(0,"not impl."); return Object_handle();} }; class SFace_cycle_iterator : public Object_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a sface. Convertible to |Object_handle|.}*/ { typedef Object_iterator Ibase; public: SFace_cycle_iterator() : Ibase() {} SFace_cycle_iterator(const Ibase& b) : Ibase(b) {} SFace_cycle_iterator(const SFace_cycle_iterator& i) : Ibase(i) {} bool is_svertex() const { SVertex_handle v; return CGAL::assign(v,Ibase::operator*()); } bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SVertex_handle() const { SVertex_handle v; CGAL::assign(v,Ibase::operator*()); return v; } operator SHalfedge_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return e; } operator SHalfloop_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return l; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { this->CGAL_nef_assertion_msg(0,"not impl."); return Object_handle(); } }; class SFace_cycle_const_iterator : public Object_const_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a facet. Convertible to |Object_handle|.}*/ { typedef Object_const_iterator Ibase; public: SFace_cycle_const_iterator() : Ibase() {} SFace_cycle_const_iterator(const Ibase& b) : Ibase(b) {} SFace_cycle_const_iterator(const SFace_cycle_const_iterator& i) : Ibase(i) {} bool is_svertex() const { SVertex_handle v; return CGAL::assign(v,Ibase::operator*()); } bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SVertex_const_handle() const { SVertex_handle v; CGAL::assign(v,Ibase::operator*()); return SVertex_const_handle(v); } operator SHalfedge_const_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return SHalfedge_const_handle(e); } operator SHalfloop_const_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return SHalfloop_const_handle(l); } operator Object_handle() const { return Ibase::operator*(); } const Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { this->CGAL_nef_assertion_msg(0,"not impl."); return Object_handle(); } }; class Shell_entry_iterator : public Object_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a shell. Convertible to |SFace_handle|.}*/ { typedef Object_iterator Ibase; public: Shell_entry_iterator() : Ibase() {} Shell_entry_iterator(const Ibase& b) : Ibase(b) {} Shell_entry_iterator(const Shell_entry_iterator& i) : Ibase(i) {} operator SFace_handle() const { SFace_handle f; CGAL_assertion( CGAL::assign(f,Ibase::operator*()) ); CGAL::assign(f,Ibase::operator*()); return f; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { this->CGAL_nef_assertion_msg(0,"not impl."); return Object_handle(); } }; class Shell_entry_const_iterator : public Object_const_iterator { typedef Object_const_iterator Ibase; public: Shell_entry_const_iterator() : Ibase() {} Shell_entry_const_iterator(const Ibase& b) : Ibase(b) {} Shell_entry_const_iterator(const Shell_entry_const_iterator& i) : Ibase(i) {} operator SFace_const_handle() const { SFace_handle f; CGAL_assertion( CGAL::assign(f,Ibase::operator*()) ); CGAL::assign(f,Ibase::operator*()); return SFace_const_handle(f); } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { this->CGAL_nef_assertion_msg(0,"not impl."); return Object_handle(); } }; typedef CircFromIt > SHalfedge_around_facet_const_circulator; // Mutable Circulators: typedef CircFromIt > SHalfedge_around_facet_circulator; /*{\Mcreation 3}*/ /*{\Mtext |\Mname| is default and copy constructible. Note that copy construction means cloning an isomorphic structure and is thus an expensive operation.}*/ SNC_structure() : boundary_item_(undef_), sm_boundary_item_(undef_), vertices_(), halfedges_(), halffacets_(), volumes_(), shalfedges_(), shalfloops_(), sfaces_() {} ~SNC_structure() { CGAL_NEF_TRACEN("~SNC_structure: clearing "< bool is_boundary_object(H h) { return boundary_item_[h]!=undef_; } template bool is_sm_boundary_object(H h) { return sm_boundary_item_[h]!=undef_; } template Object_iterator& boundary_item(H h) { return boundary_item_[h]; } template Object_iterator& sm_boundary_item(H h) { return sm_boundary_item_[h]; } template void store_boundary_item(H h, Object_iterator o) { boundary_item_[h] = o; } template void store_sm_boundary_item(H h, Object_iterator o) { sm_boundary_item_[h] = o; } template void undef_boundary_item(H h) { CGAL_assertion(boundary_item_[h]!=undef_); boundary_item_[h] = undef_; } template void undef_sm_boundary_item(H h) { CGAL_assertion(sm_boundary_item_[h]!=undef_); sm_boundary_item_[h] = undef_; } void reset_iterator_hash(Object_iterator it) { SVertex_handle sv; SHalfedge_handle se; SHalfloop_handle sl; if ( CGAL::assign(se,*it) ) { if( is_boundary_object(se)) undef_boundary_item(se); return; } if ( CGAL::assign(sl,*it) ) { if( is_boundary_object(sl)) undef_boundary_item(sl); return; } if ( CGAL::assign(sv,*it) ) { if( is_boundary_object(sv)) undef_boundary_item(sv); return; } } void reset_sm_object_list(Object_list& L) { Object_iterator oit; CGAL_forall_iterators(oit,L) reset_sm_iterator_hash(oit); L.clear(); } void reset_sm_iterator_hash(Object_iterator it) { SVertex_handle sv; SHalfedge_handle se; SHalfloop_handle sl; if ( CGAL::assign(se,*it) ) { if( is_sm_boundary_object(se)) undef_sm_boundary_item(se); return; } if ( CGAL::assign(sl,*it) ) { if( is_sm_boundary_object(sl)) undef_sm_boundary_item(sl); return; } if ( CGAL::assign(sv,*it) ) { if( is_sm_boundary_object(sv)) undef_sm_boundary_item(sv); return; } } void reset_object_list(Object_list& L) { Object_iterator oit; CGAL_forall_iterators(oit,L) reset_iterator_hash(oit); L.clear(); } /*{\Moperations 2.5 3}*/ // The constant iterators and circulators. Vertex_const_iterator vertices_begin() const { return vertices_.begin();} Vertex_const_iterator vertices_end() const { return vertices_.end();} Halfedge_const_iterator halfedges_begin() const { return halfedges_.begin();} Halfedge_const_iterator halfedges_end() const { return halfedges_.end();} Halffacet_const_iterator halffacets_begin() const { return halffacets_.begin();} Halffacet_const_iterator halffacets_end() const { return halffacets_.end();} Volume_const_iterator volumes_begin() const { return volumes_.begin();} Volume_const_iterator volumes_end() const { return volumes_.end();} SVertex_const_iterator svertices_begin() const { return halfedges_.begin();} SVertex_const_iterator svertices_end() const { return halfedges_.end();} SHalfedge_const_iterator shalfedges_begin() const { return shalfedges_.begin();} SHalfedge_const_iterator shalfedges_end() const { return shalfedges_.end();} SHalfloop_const_iterator shalfloops_begin() const { return shalfloops_.begin();} SHalfloop_const_iterator shalfloops_end() const { return shalfloops_.end();} SFace_const_iterator sfaces_begin() const { return sfaces_.begin();} SFace_const_iterator sfaces_end() const { return sfaces_.end();} Vertex_iterator vertices_begin() { return vertices_.begin();} Vertex_iterator vertices_end() { return vertices_.end();} Halfedge_iterator halfedges_begin() { return halfedges_.begin();} Halfedge_iterator halfedges_end() { return halfedges_.end();} Halffacet_iterator halffacets_begin() { return halffacets_.begin();} Halffacet_iterator halffacets_end() { return halffacets_.end();} Volume_iterator volumes_begin() { return volumes_.begin();} Volume_iterator volumes_end() { return volumes_.end();} SVertex_iterator svertices_begin() { return halfedges_.begin();} SVertex_iterator svertices_end() { return halfedges_.end();} SHalfedge_iterator shalfedges_begin() { return shalfedges_.begin();} SHalfedge_iterator shalfedges_end() { return shalfedges_.end();} SHalfloop_iterator shalfloops_begin() { return shalfloops_.begin();} SHalfloop_iterator shalfloops_end() { return shalfloops_.end();} SFace_iterator sfaces_begin() { return sfaces_.begin();} SFace_iterator sfaces_end() { return sfaces_.end();} /*{\Mtext The list of all objects can be accessed via iterator ranges. For comfortable iteration we also provide iterations macros. The iterator range access operations are of the following kind:\\ |Vertex_iterator vertices_begin()/vertices_end()|\\ |Halfedge_iterator halfedges_begin()/halfedges_end()|\\ |Halffacet_iterator halffacets_begin()/halffacets_end()|\\ |Volume_iterator volumes_begin()/volumes_end()| The macros are then |CGAL_forall_vertices(v,\Mvar)|, |CGAL_forall_halfedges(e,\Mvar)|, |CGAL_forall_edges(e,\Mvar)|, |CGAL_forall_halffacets(f,\Mvar)|, |CGAL_forall_facets(f,\Mvar)|, |CGAL_forall_volumes(w,\Mvar)|.}*/ Size_type number_of_vertices() const { return vertices_.size(); } /*{\Mop returns the number of vertices.}*/ Size_type number_of_halfedges() const { return halfedges_.size(); } /*{\Mop returns the number of (directed edges).}*/ Size_type number_of_edges() const { return halfedges_.size()/2; } /*{\Mop returns the number of (directed edges).}*/ Size_type number_of_halffacets() const { return halffacets_.size();} /*{\Mop returns the number of halffacets.}*/ Size_type number_of_facets() const { return halffacets_.size()/2;} /*{\Mop returns the number of facets.}*/ Size_type number_of_volumes() const { return volumes_.size();} /*{\Mop returns the number of volumes.}*/ Size_type number_of_svertices() const { return halfedges_.size();} /*{\Mop returns the number of svertices.}*/ Size_type number_of_shalfedges() const { return shalfedges_.size();} /*{\Mop returns the number of sedges.}*/ Size_type number_of_shalfloops() const { return shalfloops_.size();} /*{\Mop returns the number of sloops.}*/ Size_type number_of_sfaces() const { return sfaces_.size();} /*{\Mop returns the number of sfaces.}*/ void print_statistics(std::ostream& os = std::cout) const /*{\Mop print the statistics of |P|: the number of vertices, edges, faces, volumes and sobjects.}*/ { os << "Selective Nef Complex - Statistics\n"; os << "|V| = " << number_of_vertices() << std::endl; os << "|E| = " << number_of_halfedges() << std::endl; os << "|F| = " << number_of_halffacets() << std::endl; os << "|C| = " << number_of_volumes() << std::endl; os << "|VS| = " << number_of_svertices() << std::endl; os << "|ES| = " << number_of_shalfedges() << std::endl; os << "|LS| = " << number_of_shalfloops() << std::endl; os << "|FS| = " << number_of_sfaces() << std::endl; os << std::endl; } bool is_empty() const { /*{\Mop returns true if |\Mvar| is empty, false otherwise.}*/ return number_of_vertices() == 0 && number_of_halfedges() == 0 && number_of_halffacets() == 0 && number_of_volumes() == 0 && number_of_shalfedges() == 0 && number_of_shalfloops() == 0 && number_of_sfaces() == 0; } bool has_bbox_only() const { /*{\Mop returns true if |\Mvar| is only the infimaximal box, false otherwise.}*/ return (number_of_vertices() == 8 && number_of_edges() == 12 && number_of_facets() == 6 && number_of_volumes() == 2 && (++volumes_begin())->mark() == false); } Vertex_handle new_vertex(const Point_3& p = Point_3(), Mark m = Mark()) /*{\Mop returns a new vertex at point |p| marked by |m|.}*/ { Vertex_handle vh = new_vertex_only(); vh->point() = p; vh->mark() = m; vh->sncp() = this; vh->svertices_begin() = vh->svertices_last() = svertices_end(); vh->shalfedges_begin() = vh->shalfedges_last() = shalfedges_end(); vh->sfaces_begin() = vh->sfaces_last() = sfaces_end(); vh->shalfloop() = shalfloops_end(); return vh; } Halfedge_handle new_halfedge_pair(Vertex_handle v1, Vertex_handle v2, Mark m = Mark()) /*{\Mop creates a new halfedge pair between the vertices $v_1$ and $v_2$. The edge is marked by |m|.}*/ { SM_decorator D1(&*v1); SM_decorator D2(&*v2); SVertex_handle e1 = D1.new_vertex(); SVertex_handle e2 = D2.new_vertex(); make_twins(e1,e2); e1->mark() = m; return e1; } Halffacet_handle new_halffacet_pair(const Plane_3& h = Plane_3(), Mark m = Mark()) /*{\Mop creates a new facet supported by the plane |h| and marked with |m|.}*/ { Halffacet_handle f1 = new_halffacet_only(); Halffacet_handle f2 = new_halffacet_only(); f1->plane() = h; f2->plane() = h.opposite(); make_twins(f1,f2); f1->mark() = f2->mark() = m; return f1; } Volume_handle new_volume(Mark m = Mark()) /*{\Mop creates a new volume marked with |m|.}*/ { Volume_handle vh = new_volume_only(); vh->mark() = m; return vh; } template void make_twins(H h1, H h2) { h1->twin() = h2; h2->twin() = h1; } void delete_vertex(Vertex_handle v) /*{\Mop deletes the vertex including the objects in its local graph.}*/ { CGAL_NEF_TRACEN("~ deleting vertex "<<&*v<<" from "<<&*this); v->clear(true); delete_vertex_only(v); CGAL_NEF_TRACEN("~~ vertex deleted"<<&*v); } void delete_halfedge_pair(Halfedge_handle e) /*{\Mop deletes the halfedge pair of |e,twin(e)|. Does not care about incident objects in the local graph of |source(e)|.}*/ { CGAL_NEF_TRACEN("~ deleting halfedges pair "<<&*e<<", "<<&*(e->twin())<< " from "<<&*this); Halfedge_handle et = e->twin(); SM_decorator D1(&*e->center_vertex()), D2(&*et->center_vertex()); D1.delete_vertex(e); D2.delete_vertex(et); } void delete_halffacet_pair(Halffacet_handle f) /*{\Mop deletes the halffacet pair |f,twin(f)|. Does not care about boundary cycle objects.}*/ { CGAL_NEF_TRACEN("~ deleting halffacets pair "<<&*f<<", "<<&*(f->twin())<< " from "<<&*this); reset_object_list(f->boundary_entry_objects()); reset_object_list(f->twin()->boundary_entry_objects()); delete_halffacet_only(f->twin()); delete_halffacet_only(f); } void delete_volume(Volume_handle c) /*{\Mop deletes the volume |c|. Does not care about shell objects.}*/ { CGAL_NEF_TRACEN("~ deleting volume "<<&*c<<" from "<<&*this); reset_object_list(c->shell_entry_objects()); delete_volume_only(c); } Vertex_alloc vertex_allocator; Vertex* get_vertex_node( const Vertex& t) { Vertex* p = vertex_allocator.allocate(1); vertex_allocator.construct( p, Vertex()); return p; } void put_vertex_node( Vertex* p) { vertex_allocator.destroy(p); vertex_allocator.deallocate( p, 1); } Halfedge_alloc halfedge_allocator; Halfedge* get_halfedge_node( const Halfedge& t) { Halfedge* p = halfedge_allocator.allocate(1); halfedge_allocator.construct( p, Halfedge()); return p; } void put_halfedge_node( Halfedge* p) { halfedge_allocator.destroy(p); halfedge_allocator.deallocate( p, 1); } Halffacet_alloc halffacet_allocator; Halffacet* get_halffacet_node( const Halffacet& t) { Halffacet* p = halffacet_allocator.allocate(1); halffacet_allocator.construct( p, Halffacet()); return p; } void put_halffacet_node( Halffacet* p) { halffacet_allocator.destroy(p); halffacet_allocator.deallocate( p, 1); } Volume_alloc volume_allocator; Volume* get_volume_node( const Volume& t) { Volume* p = volume_allocator.allocate(1); volume_allocator.construct( p, Volume()); return p; } void put_volume_node( Volume* p) { volume_allocator.destroy(p); volume_allocator.deallocate( p, 1); } SHalfedge_alloc shalfedge_allocator; SHalfedge* get_shalfedge_node( const SHalfedge& t) { SHalfedge* p = shalfedge_allocator.allocate(1); shalfedge_allocator.construct( p, SHalfedge()); return p; } void put_shalfedge_node( SHalfedge* p) { shalfedge_allocator.destroy(p); shalfedge_allocator.deallocate( p, 1); } SHalfloop_alloc shalfloop_allocator; SHalfloop* get_shalfloop_node( const SHalfloop& t) { SHalfloop* p = shalfloop_allocator.allocate(1); shalfloop_allocator.construct( p, SHalfloop()); return p; } void put_shalfloop_node( SHalfloop* p) { shalfloop_allocator.destroy(p); shalfloop_allocator.deallocate( p, 1); } SFace_alloc sface_allocator; SFace* get_sface_node( const SFace& t) { SFace* p = sface_allocator.allocate(1); sface_allocator.construct( p, SFace()); return p; } void put_sface_node( SFace* p) { sface_allocator.destroy(p); sface_allocator.deallocate( p, 1); } Vertex_handle new_vertex_only() { vertices_.push_back(* get_vertex_node(Vertex())); CGAL_NEF_TRACEN(" new vertex only "<<&*(--vertices_end())); return --vertices_end(); } Halfedge_handle new_halfedge_only(Halfedge_handle e) { Halfedge_handle ne = halfedges_.insert(e, * get_halfedge_node(Halfedge())); CGAL_NEF_TRACEN(" after "<<&*e<<" new halfedge only "<<&*ne); return ne; } Halfedge_handle new_halfedge_only() { CGAL_NEF_TRACEN(" new halfedge only "<<&*(--halfedges_end())); halfedges_.push_back( * get_halfedge_node(Halfedge())); return --halfedges_end(); } Halffacet_handle new_halffacet_only() { halffacets_.push_back( * get_halffacet_node(Halffacet())); CGAL_NEF_TRACEN(" new halffacet only "<<&*(--halffacets_end())); return --halffacets_end(); } Volume_handle new_volume_only() { volumes_.push_back( * get_volume_node(Volume())); CGAL_NEF_TRACEN(" new volume only "<<&*(--volumes_end())); return --volumes_end(); } SHalfedge_handle new_shalfedge_only() { shalfedges_.push_back( * get_shalfedge_node(SHalfedge())); CGAL_NEF_TRACEN(" new shalfedge only "<<&*(--shalfedges_end())); return --shalfedges_end(); } SHalfloop_handle new_shalfloop_only() { shalfloops_.push_back( * get_shalfloop_node(SHalfloop())); CGAL_NEF_TRACEN(" new shalfloop only "<<&*(--shalfloops_end())); return --shalfloops_end(); } SFace_handle new_sface_only() { sfaces_.push_back( * get_sface_node(SFace())); CGAL_NEF_TRACEN(" new sface only "<<&*(--sfaces_end())); return --sfaces_end(); } void delete_vertex_only(Vertex_handle h) { CGAL_NEF_TRACEN("~ deleting vertex only "<<&*h<<" from "<<&*this); vertices_.erase(h); put_vertex_node(&*h); } void delete_halfedge_only(Halfedge_handle h) { CGAL_NEF_TRACEN("~ deleting halfedge only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_sm_boundary_object(h)); halfedges_.erase(h); put_halfedge_node(&*h); } void delete_halffacet_only(Halffacet_handle h) { CGAL_NEF_TRACEN("~ deleting halffacet only "<<&*h<<" from "<<&*this); halffacets_.erase(h); put_halffacet_node(&*h); } void delete_volume_only(Volume_handle h) { CGAL_NEF_TRACEN("~ deleting volume only "<<&*h<<" from "<<&*this); volumes_.erase(h); put_volume_node(&*h); } void delete_shalfedge_only(SHalfedge_handle h) { CGAL_NEF_TRACEN("~ deleting shalfedge only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_sm_boundary_object(h)); shalfedges_.erase(h); put_shalfedge_node(&*h); } void delete_shalfloop_only(SHalfloop_handle h) { CGAL_NEF_TRACEN("~ deleting shalfloop only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_sm_boundary_object(h)); shalfloops_.erase(h); put_shalfloop_node(&*h); } void delete_sface_only(SFace_handle h) { CGAL_NEF_TRACEN("~ deleting sface only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_boundary_object(h)); sfaces_.erase(h); put_sface_node(&*h); } std::size_t bytes() { // bytes used for the SNC_structure std::size_t result = sizeof(Self); result += number_of_vertices() * (sizeof(Vertex) - sizeof(Point_3)); result += number_of_halfedges() * (sizeof(Halfedge) - sizeof(Sphere_point)); result += number_of_halffacets() * (sizeof(Halffacet) - sizeof(Plane_3)); result += number_of_volumes() * sizeof(Volume); result += number_of_shalfedges() * (sizeof(SHalfedge) - sizeof(Sphere_circle)); result += number_of_shalfloops() * sizeof(SHalfloop); result += number_of_sfaces() * sizeof(SFace); Halffacet_iterator hf; CGAL_forall_halffacets(hf, *this) { Halffacet_cycle_iterator fc; CGAL_forall_facet_cycles_of(fc, hf) result += sizeof(*fc) + 2 * sizeof(void*); } Volume_iterator c; CGAL_forall_volumes(c, *this) { Shell_entry_iterator sei; CGAL_forall_shells_of(sei,c) result += sizeof(*sei) + 2 * sizeof(void*); } SFace_iterator sf; CGAL_forall_sfaces(sf, *this) { SFace_cycle_iterator sfc; CGAL_forall_sface_cycles_of(sfc,sf) result += sizeof(*sfc) + 2 * sizeof(void*); } return result; } std::size_t bytes_reduced() { // bytes used for the SNC_structure std::size_t result = sizeof(Self); result += number_of_vertices() * (sizeof(Vertex) - sizeof(Point_3) - sizeof(SHalfloop_iterator) - 2 * sizeof(Mark) - sizeof(void*)); result += number_of_halfedges() * (sizeof(Halfedge) - sizeof(SHalfedge_handle) - sizeof(SFace_handle) - sizeof(void*) - sizeof(Sphere_point)); result += number_of_halffacets() * (sizeof(Halffacet) - sizeof(Plane_3)); result += number_of_volumes() * sizeof(Volume); result += number_of_shalfedges() * (sizeof(SHalfedge) - sizeof(SVertex_handle) - 3 * sizeof(SHalfedge_handle) - sizeof(SFace_handle) - sizeof(void*) - sizeof(Mark) - sizeof(Sphere_circle)); result += number_of_sfaces() * (sizeof(SFace) - sizeof(void*) - sizeof(Mark) - sizeof(Object_list)); Halffacet_iterator hf; CGAL_forall_halffacets(hf, *this) { Halffacet_cycle_iterator fc; CGAL_forall_facet_cycles_of(fc, hf) result += sizeof(*fc) + 2 * sizeof(void*); } Volume_iterator c; CGAL_forall_volumes(c, *this) { Shell_entry_iterator sei; CGAL_forall_shells_of(sei,c) result += sizeof(*sei) + 2 * sizeof(void*); } return result; } std::size_t bytes_reduced2() { // bytes used for the SNC_structure std::size_t result = sizeof(Self); result += number_of_vertices() * (sizeof(Mark) + sizeof(SNC_structure*) + sizeof(Object_list) + 2 * sizeof(SFace_handle)); result += number_of_halfedges() * (sizeof(Vertex_handle) + sizeof(SVertex_handle) + sizeof(Mark) + 2 * sizeof(Object_handle)); result += number_of_halffacets() * (sizeof(Halffacet) - sizeof(Plane_3)); result += number_of_volumes() * sizeof(Volume); result += number_of_shalfedges() * (2 * sizeof(SHalfedge_handle) + sizeof(Halffacet_handle)); result += number_of_shalfloops() * sizeof(SHalfloop); result += number_of_sfaces() * (sizeof(Vertex_handle) + sizeof(Volume_handle)); Halffacet_iterator hf; CGAL_forall_halffacets(hf, *this) { Halffacet_cycle_iterator fc; CGAL_forall_facet_cycles_of(fc, hf) result += sizeof(*fc) + 2 * sizeof(void*); } Volume_iterator c; CGAL_forall_volumes(c, *this) { Shell_entry_iterator sei; CGAL_forall_shells_of(sei,c) result += sizeof(*sei) + 2 * sizeof(void*); } return result; } protected: void pointer_update(const Self& D); static Object_iterator undef_; Generic_handle_map boundary_item_; Generic_handle_map sm_boundary_item_; Vertex_list vertices_; Halfedge_list halfedges_; Halffacet_list halffacets_; Volume_list volumes_; SHalfedge_list shalfedges_; SHalfloop_list shalfloops_; SFace_list sfaces_; }; // SNC_structure template void SNC_structure:: pointer_update(const SNC_structure& D) { CGAL::Unique_hash_map VM; CGAL::Unique_hash_map EM; CGAL::Unique_hash_map FM; CGAL::Unique_hash_map CM; CGAL::Unique_hash_map SEM; CGAL::Unique_hash_map SLM; CGAL::Unique_hash_map SFM; Vertex_const_iterator vc = D.vertices_begin(); Vertex_iterator v = vertices_begin(); for ( ; vc != D.vertices_end(); ++vc,++v) VM[vc] = v; VM[D.vertices_end()] = vertices_end(); Halfedge_const_iterator ec = D.halfedges_begin(); Halfedge_iterator e = halfedges_begin(); for ( ; ec != D.halfedges_end(); ++ec,++e) EM[ec] = e; EM[D.halfedges_end()] = halfedges_end(); Halffacet_const_iterator fc = D.halffacets_begin(); Halffacet_iterator f = halffacets_begin(); for ( ; fc != D.halffacets_end(); ++fc,++f) FM[fc] = f; FM[D.halffacets_end()] = halffacets_end(); Volume_const_iterator cc = D.volumes_begin(); Volume_iterator c = volumes_begin(); for ( ; cc != D.volumes_end(); ++cc,++c) CM[cc] = c; CM[D.volumes_end()] = volumes_end(); SHalfedge_const_iterator sec = D.shalfedges_begin(); SHalfedge_iterator se = shalfedges_begin(); for ( ; sec != D.shalfedges_end(); ++sec,++se) SEM[sec] = se; SEM[D.shalfedges_end()] = shalfedges_end(); SHalfloop_const_iterator slc = D.shalfloops_begin(); SHalfloop_iterator sl = shalfloops_begin(); for ( ; slc != D.shalfloops_end(); ++slc,++sl) SLM[slc] = sl; SLM[D.shalfloops_end()] = shalfloops_end(); SFace_const_iterator sfc = D.sfaces_begin(); SFace_iterator sf = sfaces_begin(); for ( ; sfc != D.sfaces_end(); ++sfc,++sf) SFM[sfc] = sf; SFM[D.sfaces_end()] = sfaces_end(); CGAL_forall_vertices(v,*this) { // Local Graph update: (SVertices are postponed/updated as Edges) v->sncp() = this; v->svertices_begin() = EM[v->svertices_begin()]; v->svertices_last() = EM[v->svertices_last()]; v->shalfedges_begin() = SEM[v->shalfedges_begin()]; v->shalfedges_last() = SEM[v->shalfedges_last()]; v->sfaces_begin() = SFM[v->sfaces_begin()]; v->sfaces_last() = SFM[v->sfaces_last()]; v->shalfloop() = SLM[v->shalfloop()]; } // Halfedge update: CGAL_forall_halfedges(e,*this) { e->center_vertex() = VM[e->center_vertex()]; e->twin() = EM[e->twin()]; e->out_sedge() = SEM[e->out_sedge()]; e->incident_sface() = SFM[e->incident_sface()]; } // Halffacet update CGAL_forall_halffacets(f,*this) { f->twin() = FM[f->twin()]; f->incident_volume() = CM[f->incident_volume()]; Halffacet_cycle_iterator ftc; for(ftc = f->facet_cycles_begin(); ftc != f->facet_cycles_end(); ++ftc) { if (ftc.is_shalfedge() ) { se = SHalfedge_handle(ftc); *ftc = Object_handle(SEM[se]); store_boundary_item(se,ftc); } else if (ftc.is_shalfloop() ) { sl = SHalfloop_handle(ftc); *ftc = Object_handle(SLM[sl]); store_boundary_item(sl,ftc); } else CGAL_assertion_msg(0,"damn wrong boundary item in facet."); } } // Volume update CGAL_forall_volumes(c,*this) { Shell_entry_iterator sei; CGAL_forall_shells_of(sei,c) { sf = sei; // conversion from generic iterator to sface const handle *sei = Object_handle(SFM[sf]); store_boundary_item(sf,sei); } } CGAL_forall_shalfedges(se,*this) { se->source() = EM[se->source()]; se->sprev() = SEM[se->sprev()]; se->snext() = SEM[se->snext()]; se->incident_sface() = SFM[se->incident_sface()]; se->twin() = SEM[se->twin()]; se->prev() = SEM[se->prev()]; se->next() = SEM[se->next()]; se->facet() = FM[se->facet()]; } CGAL_forall_shalfloops(sl,*this) { sl->twin() = SLM[sl->twin()]; sl->incident_sface() = SFM[sl->incident_sface()]; sl->facet() = FM[sl->facet()]; } for ( slc = D.shalfloops_begin(), sl = shalfloops_begin(); slc != D.shalfloops_end(); ++slc, ++sl) { /* It is possible that the is_twin() property differs for equivalent sloops on both SNC structures. So, we need to store the correct selection mark in the correct (non-twin) facet of a shalfloop pair. */ CGAL_assertion_code( if( slc->is_twin() == sl->is_twin()) CGAL_assertion( slc->mark() == sl->mark())); if( !sl->is_twin() && slc->is_twin()) sl->mark() = sl->twin()->mark(); } CGAL_forall_sfaces(sf,*this) { sf->center_vertex() = VM[sf->center_vertex()]; sf->volume() = CM[sf->volume()]; SFace_cycle_iterator sfc; for(sfc = sf->sface_cycles_begin(); sfc != sf->sface_cycles_end(); ++sfc) { if (sfc.is_svertex()) { SVertex_handle sv(sfc); *sfc = Object_handle(EM[sv]); store_sm_boundary_item(sv,sfc); } else if (sfc.is_shalfedge()) { se = SHalfedge_handle(sfc); *sfc = Object_handle(SEM[se]); store_sm_boundary_item(se,sfc); } else if (sfc.is_shalfloop()) { sl = SHalfloop_handle(sfc); *sfc = Object_handle(SLM[sl]); store_sm_boundary_item(sl,sfc); } else CGAL_assertion_msg(0,"damn wrong boundary item in sface."); } } } template typename SNC_structure::Object_iterator SNC_structure::undef_; CGAL_END_NAMESPACE #endif // CGAL_SNC_STRUCTURE_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_intersection0000644000175000017500000003126311344301501031114 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_SNC_INTERSECTION_H #define CGAL_SNC_INTERSECTION_H #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 37 #include CGAL_BEGIN_NAMESPACE template < class Node, class Object> struct Project_halfedge_point { typedef Node argument_type; typedef Object result_type; Object& operator()( Node& x) const { return x.source()->source()->point(); /* a Point_3& reference must be returned by D.point() */ } const Object& operator()( const Node& x) const { return x.source()->source()->point(); /* a Point_3& reference must be returned by D.point() */ } }; template class SNC_intersection : public SNC_const_decorator { // TODO: granados: is it really necessary to inherit from the decorator? typedef SNC_structure_ SNC_structure; typedef SNC_intersection Self; typedef SNC_const_decorator Base; // typedef SNC_const_decorator SNC_const_decorator; typedef typename SNC_structure::SHalfedge SHalfedge; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SNC_structure::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Line_3 Line_3; typedef typename SNC_structure::Ray_3 Ray_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Triangle_3 Triangle_3; public: SNC_intersection() : Base() {} SNC_intersection(const SNC_structure& W) : Base(W) {} bool does_contain_internally(const Segment_3& s, const Point_3& p) const { if(!s.has_on(p)) return false; Comparison_result r1 = compare_xyz(s.source(),p); Comparison_result r2 = compare_xyz(s.target(),p); return (r1 == opposite(r2)); } bool does_contain_internally( Halffacet_const_handle f, const Point_3& p) const { if( !plane(f).has_on(p)) return false; return (locate_point_in_halffacet( p, f) == CGAL::ON_BOUNDED_SIDE); } bool does_contain_on_boundary( Halffacet_const_handle f, const Point_3& p) const { typedef Project_halfedge_point < SHalfedge, const Point_3> Project; typedef Circulator_project < SHalfedge_around_facet_const_circulator, Project, const Point_3&, const Point_3*> Circulator; Halffacet_cycle_const_iterator fc = f->facet_cycles_begin(); CGAL_assertion(fc.is_shalfedge()); if (fc.is_shalfedge() ) { SHalfedge_const_handle se(fc); SHalfedge_around_facet_const_circulator hfc(se); Circulator c(hfc), cp(c), cend(c); do { c++; CGAL_NEF_TRACEN("contained on edge "<facet_cycles_end(); ++fc; CGAL_For_all(fc, fe) { if (fc.is_shalfloop() ) { SHalfloop_const_handle l(fc); CGAL_NEF_TRACEN("isolated point on "<incident_sface()->center_vertex()->point()<<"? "); if( l->incident_sface()->center_vertex()->point() == p) return true; } else if (fc.is_shalfedge() ) { SHalfedge_const_handle se(fc); SHalfedge_around_facet_const_circulator hfc(se); Circulator c(hfc), cp(c), cend(c); do { c++; CGAL_NEF_TRACEN("contained on edge "< Intersection triangle - ray"); CGAL_NEF_TRACEN(" -> Ray: "< Triangle: "< intersection point: "< Intersection triangle - segment"); CGAL_NEF_TRACEN(" -> Segment: "< Triangle: "< intersection point: "< Intersection facet - ray"); Plane_3 h( f->plane()); CGAL_NEF_TRACEN("-> facet's plane: " << h); CGAL_NEF_TRACEN("-> a point on the plane: " << h.point()); CGAL_NEF_TRACEN("-> ray: " << ray); if( ray.is_degenerate()) /* no possible internal intersection */ return false; if( h.has_on( ray.source())) /* no possible internal intersection */ return false; Object o = intersection( h, ray); if( !CGAL::assign( p, o)) return false; CGAL_NEF_TRACEN( "-> intersection point: " << p ); CGAL_NEF_TRACEN( "-> point in facet interior? "< Intersection facet - segment"); Plane_3 h( plane(f)); CGAL_NEF_TRACEN("-> facet's plane: " << h); CGAL_NEF_TRACEN("-> a point on the plane: " << h.point()); CGAL_NEF_TRACEN("-> segment: " << seg); if( seg.is_degenerate()) /* no possible internal intersection */ return false; if( h.has_on( seg.source()) || h.has_on(seg.target())) /* no possible internal intersection */ return false; Object o = intersection( h, seg); if( !CGAL::assign( p, o)) return false; CGAL_NEF_TRACEN( "-> intersection point: " << p ); CGAL_NEF_TRACEN( "-> point in facet interior? "< Project; typedef Circulator_project < SHalfedge_around_facet_const_circulator, Project, const Point_3&, const Point_3*> Circulator; typedef Container_from_circulator Container; Plane_3 h(plane(f)); CGAL_assertion(h.has_on(p)); Halffacet_cycle_const_iterator fc = f->facet_cycles_begin(); Bounded_side outer_bound_pos(CGAL::ON_BOUNDARY); if (fc.is_shalfedge() ) { SHalfedge_const_handle se(fc); SHalfedge_around_facet_const_circulator hfc(se); Circulator c(hfc); Container ct(c); CGAL_assertion( !is_empty_range(ct.begin(), ct.end())); outer_bound_pos = bounded_side_3(ct.begin(), ct.end(), p, h); } else CGAL_assertion_msg(0, "is facet first cycle a SHalfloop?"); if( outer_bound_pos != CGAL::ON_BOUNDED_SIDE ) return outer_bound_pos; /* The point p is not in the relative interior of the outer face cycle so it is not necesary to know the possition of p with respect to the inner face cycles */ Halffacet_cycle_const_iterator fe = f->facet_cycles_end(); ++fc; if( fc == fe ) return outer_bound_pos; Bounded_side inner_bound_pos(CGAL::ON_BOUNDARY); CGAL_For_all(fc, fe) { if (fc.is_shalfloop() ) { SHalfloop_const_handle l(fc); if(l->incident_sface()->center_vertex()->point() == p ) inner_bound_pos = CGAL::ON_BOUNDARY; else inner_bound_pos = CGAL::ON_UNBOUNDED_SIDE; } else if (fc.is_shalfedge() ) { SHalfedge_const_handle se(fc); SHalfedge_around_facet_const_circulator hfc(se); Circulator c(hfc); Container ct(c); CGAL_assertion( !is_empty_range(ct.begin(), ct.end())); inner_bound_pos = bounded_side_3( ct.begin(), ct.end(), p, h.opposite()); } else CGAL_assertion_msg(0, "Damn wrong handle."); if( inner_bound_pos != CGAL::ON_UNBOUNDED_SIDE ) return opposite(inner_bound_pos); /* At this point the point p belongs to relative interior of the facet's outer cycle, and its possition is completely known when it belongs to the clousure of any inner cycle */ } return CGAL::ON_BOUNDED_SIDE; } }; // SNC_intersection CGAL_END_NAMESPACE #endif //CGAL_SNC_INTERSECTION_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Progress_indicator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Progress_indicat0000644000175000017500000000453011344301501031177 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Progress_indicator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Miguel Granados #ifndef PROGRESS_INDICATOR_H #define PROGRESS_INDICATOR_H #include #include class Progress_indicator { protected: long total, current; public: Progress_indicator( long n) : total(n), current(0) {} void operator++(int) { CGAL_assertion( total > 0); CGAL_assertion( current != total); ++current; } void operator++() { operator++(0); } float percentage() { CGAL_assertion( total > 0); return 100.0*current/total; } }; class Progress_indicator_ostream : public Progress_indicator { typedef Progress_indicator Base; protected: std::ostream& os; char separator; public: Progress_indicator_ostream( std::ostream& o, long n, char *msg, char s='\n') : Base(n), os(o), separator(s) { os< // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SNC_ITERATION_H #define CGAL_SNC_ITERATION_H #include #define CGAL_forall_vertices(x,SNC)\ for(x = (SNC).vertices_begin(); x != (SNC).vertices_end(); ++x) #define CGAL_forall_halfedges(x,SNC)\ for(x = (SNC).halfedges_begin(); x != (SNC).halfedges_end(); ++x) #define CGAL_forall_edges(x,SNC)\ for(x = (SNC).halfedges_begin(); x != (SNC).halfedges_end(); ++x) \ if ( x->is_twin() ) continue; else #define CGAL_forall_halffacets(x,SNC)\ for(x = (SNC).halffacets_begin(); x != (SNC).halffacets_end(); ++x) #define CGAL_forall_facets(x,SNC)\ for(x = (SNC).halffacets_begin(); x != (SNC).halffacets_end(); ++x) \ if ( x->is_twin() ) continue; else #define CGAL_forall_volumes(x,SNC)\ for(x = (SNC).volumes_begin(); x != (SNC).volumes_end(); ++x) #define CGAL_forall_facet_cycles_of(x,F)\ for(x = (F)->facet_cycles_begin(); x != (F)->facet_cycles_end(); ++x) #define CGAL_forall_shells_of(x,C)\ for(x = (C)->shells_begin(); x != (C)->shells_end(); ++x) #define CGAL_forall_svertices_of(x,V)\ for(x = (V)->svertices_begin(); x != (V)->svertices_end(); ++x) #define CGAL_forall_sedges_of(x,V)\ for(x = (V)->shalfedges_begin(); x != (V)->shalfedges_end(); ++(++x)) #define CGAL_forall_shalfedges_of(x,V)\ for(x = (V)->shalfedges_begin(); x != (V)->shalfedges_end(); ++x) #define CGAL_forall_sfaces_of(x,V)\ for(x = (V)->sfaces_begin(); x != (V)->sfaces_end(); ++x) #endif //CGAL_SNC_ITERATION_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_visualizor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_visualizo0000644000175000017500000001727211344301501031036 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_visualizor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SNC_SM_VISUALIZOR_H #define CGAL_SNC_SM_VISUALIZOR_H #include #include #include #include #include #define LGREY CGAL::Color(170,170,200) #define DGREY CGAL::Color(30,30,50) CGAL_BEGIN_NAMESPACE template class SNC_SM_BooleColor { typedef typename Map_::SVertex_const_handle SVertex_const_handle; typedef typename Map_::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Map_::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Map_::SFace_const_handle SFace_const_handle; typedef typename Map_::Mark Mark; public: Color color(SVertex_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfedge_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SHalfloop_const_handle, Mark m) const { return ( m ? CGAL::BLACK : CGAL::WHITE ); } Color color(SFace_const_handle, Mark m) const { return ( m ? DGREY : LGREY ); } }; /*{\Moptions outfile=SNC_SM_visualizor.man }*/ /*{\Manpage {SNC_SM_visualizor}{Map_}{Drawing sphere maps}{V}}*/ template > class SNC_SM_visualizor { /*{\Mdefinition An instance |\Mvar| of the data type |\Mname| is a decorator to draw the structure of a sphere map into the surface of a OpenGL sphere. It is generic with respect to the template concept.}*/ /*{\Mgeneralization SM_decorator}*/ /*{\Mtypes 3}*/ public: typedef SNC_SM_visualizor Self; typedef typename Map_::Sphere_kernel Sphere_kernel; typedef CGAL::Map Map; typedef SM_const_decorator SNC_SM_explorer; typedef SNC_SM_triangulator SNC_SM_triangulator; typedef typename Map_::Vertex_handle Vertex_handle; typedef typename Map_::SVertex_const_handle SVertex_const_handle; typedef typename Map_::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Map_::SFace_const_handle SFace_const_handle; typedef typename Map_::SVertex_const_iterator SVertex_const_iterator; typedef typename Map_::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Map_::SFace_const_iterator SFace_const_iterator; typedef typename Map_::Mark Mark; // types from the local sphere map type that stores triangulation: typedef typename Map::Vertex_const_iterator SM_Vertex_const_iterator; typedef typename Map::Halfedge_const_iterator SM_Halfedge_const_iterator; typedef typename Map::Halfloop_const_iterator SM_Halfloop_const_iterator; typedef typename Map::Face_const_iterator SM_Face_const_iterator; typedef typename Sphere_kernel::Sphere_point Sphere_point; typedef typename Sphere_kernel::Sphere_segment Sphere_segment; typedef typename Sphere_kernel::Sphere_circle Sphere_circle; typedef typename Sphere_kernel::Sphere_triangle Sphere_triangle; typedef Color_ Color_objects; protected: Map MT_; SNC_SM_triangulator T_; SNC_SM_explorer E_; const Color_objects& CO_; CGAL::OGL::Unit_sphere& S_; public: /*{\Mcreation 4}*/ SNC_SM_visualizor(Vertex_handle v, CGAL::OGL::Unit_sphere& S, const Color_objects& C = Color_objects()) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| to visualize the vertices, edges, and faces of |D| in an open GL window.}*/ : MT_(), T_(v,MT_), E_(v), CO_(C), S_(S) { T_.triangulate(); } /*{\Moperations 2 1}*/ /* |draw_map| draws all object of the sphere map referenced by E_: 1) edges, loops, and vertices are taken from E_ 2) faces are drawn via the calculated triangulation in MT_ */ void draw_map() const /*{\Mop draw the whole plane map.}*/ { // draw sphere segments underlying edges of E_: SHalfedge_const_iterator e; CGAL_nef3_forall_sedges(e,E_) { if ( E_.source(e) == E_.target(e) ) { S_.push_back(E_.circle(e), CO_.color(e,E_.mark(e))); } else { S_.push_back(Sphere_segment(E_.point(E_.source(e)), E_.point(E_.target(e)), E_.circle(e)),CO_.color(e,E_.mark(e))); } } // draw sphere circles underlying loops of E_: if ( E_.has_sloop() ) S_.push_back( Sphere_circle(E_.circle(E_.shalfloop())), CO_.color(E_.shalfloop(),E_.mark(E_.shalfloop()))); // draw points underlying vertices of E_: SVertex_const_iterator v; CGAL_nef3_forall_svertices(v,E_) S_.push_back(E_.point(v),CO_.color(v,E_.mark(v))); SM_Halfedge_const_iterator h; Unique_hash_map Done(false); CGAL_nef3_forall_halfedges(h,T_) { if ( Done[h] ) continue; SM_Halfedge_const_iterator hn(T_.next(h)),hnn(T_.next(hn)); CGAL_NEF_TRACEV(T_.incident_triangle(h)); CGAL_assertion( T_.incident_mark(h) == T_.incident_mark(hn) && T_.incident_mark(hn) == T_.incident_mark(hnn)); Mark m = T_.incident_mark(h); Sphere_triangle t = T_.incident_triangle(h); S_.push_back(t, (m ? DGREY : LGREY) ); Done[h]=Done[hn]=Done[hnn]=true; } CGAL_forall_edges(h,T_) // for all sphere edges S_.push_back_triangle_edge(Sphere_segment(T_.point(T_.source(h)), T_.point(T_.target(h)), T_.circle(h))); } /* |draw_triangulation| draws all object of the underlying triangulation: triangles, edges, loops, and vertices taken from MT_ */ void draw_triangulation() const { // draw sphere segments underlying edges of triangulation: SHalfedge_const_iterator ed; SVertex_const_iterator vd; SM_Halfedge_const_iterator e; CGAL_nef3_forall_edges(e,T_) { S_.push_back(Sphere_segment(T_.point(T_.source(e)),T_.point(T_.target(e)), T_.circle(e)),CO_.color(ed,T_.mark(e))); } // draw points underlying vertices of triangulation: SM_Vertex_const_iterator v; CGAL_nef3_forall_vertices(v,T_) S_.push_back(T_.point(v),CO_.color(vd,T_.mark(v))); Unique_hash_map Done(false); CGAL_nef3_forall_halfedges(e,T_) { if ( Done[e] ) continue; SM_Halfedge_const_iterator en(T_.next(e)),enn(T_.next(en)); CGAL_assertion(T_.incident_mark(e)==T_.incident_mark(en)&& T_.incident_mark(en)==T_.incident_mark(enn)); Mark m = T_.incident_mark(e); Sphere_triangle t = T_.incident_triangle(e); S_.push_back(t, (m ? DGREY : LGREY) ); Done[e]=Done[en]=Done[enn]=true; } } }; // end of SNC_SM_visualizor template void show_sphere_map_of(typename Map_::Vertex_handle v) { CGAL::OGL::add_sphere(); SNC_SM_visualizor V(v,CGAL::OGL::spheres_.back()); V.draw_map(); CGAL::OGL::start_viewer(); } CGAL_END_NAMESPACE //#undef LGREY //#undef DGREY #endif // CGAL_SNC_SM_VISUALIZOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/OGL_helper.h0000644000175000017500000005255111344301501030114 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/OGL_helper.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_NEF_OPENGL_HELPER_H #define CGAL_NEF_OPENGL_HELPER_H #include #include #include #include #define CGAL_NEF3_MARKED_VERTEX_COLOR 183,232,92 #define CGAL_NEF3_MARKED_EDGE_COLOR 171,216,86 #define CGAL_NEF3_MARKED_FACET_COLOR 157,203,81 #define CGAL_NEF3_UNMARKED_VERTEX_COLOR 255,246,124 #define CGAL_NEF3_UNMARKED_EDGE_COLOR 255,236,94 #define CGAL_NEF3_UNMARKED_FACET_COLOR 249,215,44 #ifdef _WIN32 #define CGAL_GLU_TESS_CALLBACK CALLBACK #else #define CGAL_GLU_TESS_CALLBACK #endif CGAL_BEGIN_NAMESPACE namespace OGL { // ---------------------------------------------------------------------------- // Drawable double types: // ---------------------------------------------------------------------------- typedef CGAL::Simple_cartesian DKernel; typedef DKernel::Point_3 Double_point; typedef DKernel::Vector_3 Double_vector; typedef DKernel::Segment_3 Double_segment; typedef DKernel::Aff_transformation_3 Affine_3; // DPoint = a double point including a mark class DPoint : public Double_point { bool m_; public: DPoint() {} DPoint(const Double_point& p, bool m) : Double_point(p) { m_ = m; } DPoint(const DPoint& p) : Double_point(p) { m_ = p.m_; } DPoint& operator=(const DPoint& p) { Double_point::operator=(p); m_ = p.m_; return *this; } bool mark() const { return m_; } }; // DSegment = a double segment including a mark class DSegment : public Double_segment { bool m_; public: DSegment() {} DSegment(const Double_segment& s, bool m) : Double_segment(s) { m_ = m; } DSegment(const DSegment& s) : Double_segment(s) { m_ = s.m_; } DSegment& operator=(const DSegment& s) { Double_segment::operator=(s); m_ = s.m_; return *this; } bool mark() const { return m_; } }; // Double_triple = a class that stores a triple of double // coordinates; we need a pointer to the coordinates in a C array // for OpenGL class Double_triple { typedef double* double_ptr; typedef const double* const_double_ptr; double coords_[3]; public: Double_triple() { coords_[0]=coords_[1]=coords_[2]=0.0; } Double_triple(double x, double y, double z) { coords_[0]=x; coords_[1]=y; coords_[2]=z; } Double_triple(const Double_triple& t) { coords_[0]=t.coords_[0]; coords_[1]=t.coords_[1]; coords_[2]=t.coords_[2]; } Double_triple& operator=(const Double_triple& t) { coords_[0]=t.coords_[0]; coords_[1]=t.coords_[1]; coords_[2]=t.coords_[2]; return *this; } operator double_ptr() const { return const_cast(*this).coords_; } double operator[](unsigned i) { CGAL_assertion(i<3); return coords_[i]; } }; // Double_triple static std::ostream& operator << (std::ostream& os, const Double_triple& t) { os << "(" << t[0] << "," << t[1] << "," << t[2] << ")"; return os; } // DFacet stores the facet cycle vertices in a continuus C array // of three double components, this is necessary due to the OpenGL // tesselator input format ! class DFacet { typedef std::vector Coord_vector; typedef std::vector Cycle_vector; Coord_vector coords_; // stores all vertex coordinates Cycle_vector fc_ends_; // stores entry points of facet cycles Double_triple normal_; // stores normal and mark of facet bool mark_; public: typedef Coord_vector::iterator Coord_iterator; typedef Coord_vector::const_iterator Coord_const_iterator; DFacet() {} void push_back_vertex(double x, double y, double z) { coords_.push_back(Double_triple(x,y,z)); } DFacet(const DFacet& f) { coords_ = f.coords_; fc_ends_ = f.fc_ends_; normal_ = f.normal_; mark_ = f.mark_; } DFacet& operator=(const DFacet& f) { coords_ = f.coords_; fc_ends_ = f.fc_ends_; normal_ = f.normal_; mark_ = f.mark_; return *this; } ~DFacet() { coords_.clear(); fc_ends_.clear(); } void push_back_vertex(const Double_point& p) { push_back_vertex(p.x(),p.y(),p.z()); } void set_normal(double x, double y, double z, bool m) { double l = sqrt(x*x + y*y + z*z); normal_ = Double_triple(x/l,y/l,z/l); mark_ = m; } double dx() const { return normal_[0]; } double dy() const { return normal_[1]; } double dz() const { return normal_[2]; } bool mark() const { return mark_; } double* normal() const { return static_cast(normal_); } void new_facet_cycle() { fc_ends_.push_back(coords_.size()); } unsigned number_of_facet_cycles() const { return fc_ends_.size(); } Coord_iterator facet_cycle_begin(unsigned i) { CGAL_assertion(i(vertex)); GLdouble* pu(static_cast(user)); // CGAL_NEF_TRACEN("vertexCallback coord "< vertices_; std::list edges_; std::list halffacets_; GLuint object_list_; bool init_; Bbox_3 bbox_; int style; std::vector switches; typedef std::list::const_iterator Vertex_iterator; typedef std::list::const_iterator Edge_iterator; typedef std::list::const_iterator Halffacet_iterator; public: Polyhedron() : bbox_(-1,-1,-1,1,1,1), switches(1) { object_list_ = 0; init_ = false; style = SNC_BOUNDARY; switches[SNC_AXES] = false; } /* Polyhedron(const Polyhedron& P) : object_list_(0), init_(false), bbox_(P.bbox_), style(P.style), switches(2) { switches[SNC_AXES] = P.switches[SNC_AXES]; Vertex_iterator v; for(v=P.vertices_.begin();v!=P.vertices_.end();++v) vertices_.push_back(*v); Edge_iterator e; for(e=P.edges_.begin();e!=P.edges_.end();++e) edges_.push_back(*e); Halffacet_iterator f; for(f=P.halffacets_.begin();f!=P.halffacets_.end();++f) halffacets_.push_back(*f); } Polyhedron& operator=(const Polyhedron& P) { if (object_list_) glDeleteLists(object_list_, 4); object_list_ = 0; init_ = false; style = P.style; switches[SNC_AXES] = P.switches[SNC_AXES]; Vertex_iterator v; vertices_.clear(); for(v=P.vertices_.begin();v!=P.vertices_.end();++v) vertices_.push_back(*v); Edge_iterator e; edges_.clear(); for(e=P.edges_.begin();e!=P.edges_.end();++e) edges_.push_back(*e); Halffacet_iterator f; halffacets_.clear(); for(f=P.halffacets_.begin();f!=P.halffacets_.end();++f) halffacets_.push_back(*f); init(); return *this; } */ ~Polyhedron() { if (object_list_) glDeleteLists(object_list_, 4); } void push_back(const Double_point& p, bool m) { vertices_.push_back(DPoint(p,m)); } void push_back(const Double_segment& s, bool m) { edges_.push_back(DSegment(s,m)); } void push_back(const DFacet& f) { halffacets_.push_back(f); } void toggle(int index) { switches[index] = !switches[index]; } void set_style(int index) { style = index; } bool is_initialized() const { return init_; } Bbox_3 bbox() const { return bbox_; } Bbox_3& bbox() { return bbox_; } void draw(Vertex_iterator v) const { // CGAL_NEF_TRACEN("drawing vertex "<<*v); CGAL::Color cf(CGAL_NEF3_MARKED_VERTEX_COLOR), ct(CGAL_NEF3_UNMARKED_VERTEX_COLOR); // more blue-ish CGAL::Color c = v->mark() ? ct : cf; glPointSize(10); glColor3ub(c.red(), c.green(), c.blue()); glBegin(GL_POINTS); glVertex3d(v->x(),v->y(),v->z()); glEnd(); } void draw(Edge_iterator e) const { // CGAL_NEF_TRACEN("drawing edge "<<*e); Double_point p = e->source(), q = e->target(); CGAL::Color cf(CGAL_NEF3_MARKED_EDGE_COLOR), ct(CGAL_NEF3_UNMARKED_EDGE_COLOR); // more blue-ish CGAL::Color c = e->mark() ? ct : cf; glLineWidth(5); glColor3ub(c.red(),c.green(),c.blue()); glBegin(GL_LINE_STRIP); glVertex3d(p.x(), p.y(), p.z()); glVertex3d(q.x(), q.y(), q.z()); glEnd(); } void draw(Halffacet_iterator f) const { // CGAL_NEF_TRACEN("drawing facet "<<(f->debug(),"")); GLUtesselator* tess_ = gluNewTess(); gluTessCallback(tess_, GLenum(GLU_TESS_VERTEX_DATA), (GLvoid (CGAL_GLU_TESS_CALLBACK *)()) &vertexCallback); gluTessCallback(tess_, GLenum(GLU_TESS_BEGIN), (GLvoid (CGAL_GLU_TESS_CALLBACK *)()) &beginCallback); gluTessCallback(tess_, GLenum(GLU_TESS_END), (GLvoid (CGAL_GLU_TESS_CALLBACK *)()) &endCallback); gluTessCallback(tess_, GLenum(GLU_TESS_ERROR), (GLvoid (CGAL_GLU_TESS_CALLBACK *)()) &errorCallback); gluTessProperty(tess_, GLenum(GLU_TESS_WINDING_RULE), GLU_TESS_WINDING_POSITIVE); DFacet::Coord_const_iterator cit; CGAL::Color cf(CGAL_NEF3_MARKED_FACET_COLOR), ct(CGAL_NEF3_UNMARKED_FACET_COLOR); // more blue-ish CGAL::Color c = (f->mark() ? ct : cf); glColor3ub(c.red(),c.green(),c.blue()); gluTessBeginPolygon(tess_,f->normal()); // CGAL_NEF_TRACEN(" "); // CGAL_NEF_TRACEN("Begin Polygon"); gluTessNormal(tess_,f->dx(),f->dy(),f->dz()); // forall facet cycles of f: for(unsigned i = 0; i < f->number_of_facet_cycles(); ++i) { gluTessBeginContour(tess_); // CGAL_NEF_TRACEN(" Begin Contour"); // put all vertices in facet cycle into contour: for(cit = f->facet_cycle_begin(i); cit != f->facet_cycle_end(i); ++cit) { gluTessVertex(tess_, *cit, *cit); // CGAL_NEF_TRACEN(" add Vertex"); } gluTessEndContour(tess_); // CGAL_NEF_TRACEN(" End Contour"); } gluTessEndPolygon(tess_); // CGAL_NEF_TRACEN("End Polygon"); gluDeleteTess(tess_); } void construct_axes() const { glLineWidth(2.0); // red x-axis glColor3f(1.0,0.0,0.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(5000.0,0.0,0.0); glEnd(); // green y-axis glColor3f(0.0,1.0,0.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(0.0,5000.0,0.0); glEnd(); // blue z-axis and equator glColor3f(0.0,0.0,1.0); glBegin(GL_LINES); glVertex3f(0.0,0.0,0.0); glVertex3f(0.0,0.0,5000.0); glEnd(); // six coordinate points in pink: glPointSize(10); glBegin(GL_POINTS); glColor3f(1.0,0.0,0.0); glVertex3d(5,0,0); glColor3f(0.0,1.0,0.0); glVertex3d(0,5,0); glColor3f(0.0,0.0,1.0); glVertex3d(0,0,5); glEnd(); } void fill_display_lists() { glNewList(object_list_, GL_COMPILE); Vertex_iterator v; for(v=vertices_.begin();v!=vertices_.end();++v) draw(v); glEndList(); glNewList(object_list_+1, GL_COMPILE); Edge_iterator e; for(e=edges_.begin();e!=edges_.end();++e) draw(e); glEndList(); glNewList(object_list_+2, GL_COMPILE); Halffacet_iterator f; for(f=halffacets_.begin();f!=halffacets_.end();++f) draw(f); glEndList(); glNewList(object_list_+3, GL_COMPILE); // axes: construct_axes(); glEndList(); } void init() { if (init_) return; init_ = true; switches[SNC_AXES] = false; style = SNC_BOUNDARY; object_list_ = glGenLists(4); CGAL_assertion(object_list_); fill_display_lists(); } void draw(GLdouble z_vec[3]) const { if (!is_initialized()) const_cast(*this).init(); double l = std::max( std::max( bbox().xmax() - bbox().xmin(), bbox().ymax() - bbox().ymin()), bbox().zmax() - bbox().zmin()); if ( l < 1) // make sure that a single point doesn't screw up here l = 1; glScaled( 4.0/l, 4.0/l, 4.0/l); glTranslated( -(bbox().xmax() + bbox().xmin()) / 2.0, -(bbox().ymax() + bbox().ymin()) / 2.0, -(bbox().zmax() + bbox().zmin()) / 2.0); if (style == SNC_BOUNDARY) { //glEnable(GL_LIGHTING); glCallList(object_list_+2); // facets //glDisable(GL_LIGHTING); } // move edges and vertices a bit towards the view-point, // i.e., 1/100th of the unit vector in camera space double f = l / 4.0 / 100.0; glTranslated( z_vec[0] * f, z_vec[1] * f, z_vec[2] * f); glCallList(object_list_+1); // edges glCallList(object_list_); // vertices if (switches[SNC_AXES]) glCallList(object_list_+3); // axis } void debug(std::ostream& os = std::cerr) const { os << "OGL::Polyhedron" << std::endl; os << "Vertices:" << std::endl; Vertex_iterator v; for(v=vertices_.begin();v!=vertices_.end();++v) os << " "<<*v<<", mark="<mark()<debug(); os << std::endl; os << std::endl; } }; // Polyhedron template class Nef3_Converter { typedef typename Nef_polyhedron::SNC_structure SNC_structure; typedef CGAL::SNC_decorator Base; typedef CGAL::SNC_FM_decorator FM_decorator; public: typedef typename SNC_structure::Vertex_const_iterator Vertex_const_iterator; typedef typename SNC_structure::Halfedge_const_iterator Halfedge_const_iterator; typedef typename SNC_structure::Halffacet_const_iterator Halffacet_const_iterator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Object_const_handle Object_const_handle; typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SNC_structure::Vertex_const_handle Vertex_const_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Mark Mark; typedef typename SNC_structure::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; private: static OGL::Double_point double_point(const Point_3& p) { return OGL::Double_point(CGAL::to_double(p.x()), CGAL::to_double(p.y()), CGAL::to_double(p.z())); } static OGL::Double_segment double_segment(const Segment_3& s) { return OGL::Double_segment(double_point(s.source()), double_point(s.target())); } static void draw(Vertex_const_handle v, const Nef_polyhedron& N, CGAL::OGL::Polyhedron& P) { Point_3 bp = N.point(v); // CGAL_NEF_TRACEN("vertex " << bp); P.push_back(double_point(bp), N.mark(v)); } static void draw(Halfedge_const_handle e, const Nef_polyhedron& N, CGAL::OGL::Polyhedron& P) { Vertex_const_handle s = e->source(); Vertex_const_handle t = e->twin()->source(); Segment_3 seg(N.point(s),N.point(t)); // CGAL_NEF_TRACEN("edge " << seg); P.push_back(double_segment(seg), N.mark(e)); } static void draw(Halffacet_const_handle f, const Nef_polyhedron& N, CGAL::OGL::Polyhedron& P) { OGL::DFacet g; Halffacet_cycle_const_iterator fc; // all facet cycles: CGAL_forall_facet_cycles_of(fc,f) if ( fc.is_shalfedge() ) { // non-trivial facet cycle g.new_facet_cycle(); SHalfedge_const_handle h = fc; SHalfedge_around_facet_const_circulator hc(h), he(hc); CGAL_For_all(hc,he){ // all vertex coordinates in facet cycle Point_3 sp = hc->source()->source()->point(); // CGAL_NEF_TRACEN(" ");CGAL_NEF_TRACEN("facet" << sp); g.push_back_vertex(double_point(sp)); } } Vector_3 v = N.plane(f).orthogonal_vector(); g.set_normal(CGAL::to_double(v.x()), CGAL::to_double(v.y()), CGAL::to_double(v.z()), N.mark(f)); P.push_back(g); } // Returns the bounding box of the finite vertices of the polyhedron. // Returns $[-1,+1]^3$ as bounding box if no finite vertex exists. static Bbox_3 bounded_bbox(const Nef_polyhedron& N) { bool first_vertex = true; Bbox_3 bbox( -1.0, -1.0, -1.0, 1.0, 1.0, 1.0); Vertex_const_iterator vi; CGAL_forall_vertices(vi, N) { Point_3 p = vi->point(); double x = CGAL::to_double(p.hx()); double y = CGAL::to_double(p.hy()); double z = CGAL::to_double(p.hz()); double w = CGAL::to_double(p.hw()); if (N.is_standard(vi)) { if(first_vertex) { bbox = Bbox_3(x/w, y/w, z/w, x/w, y/w, z/w); first_vertex = false; } else { bbox = bbox + Bbox_3(x/w, y/w, z/w, x/w, y/w, z/w); first_vertex = false; } } } return bbox; } static void set_R(Bbox_3& bbox, const Nef_polyhedron& N) { if(N.is_standard_kernel()) return; double size = abs(bbox.xmin()); if(size < bbox.xmax()) size = bbox.xmax(); if(size < bbox.ymin()) size = bbox.ymin(); if(size < bbox.ymax()) size = bbox.ymax(); if(size < bbox.zmin()) size = bbox.zmin(); if(size < bbox.zmax()) size = bbox.zmax(); N.set_size_of_infimaximal_box(size*50); // CGAL_NEF_TRACEN("set infi box size to " << size); Vertex_const_iterator vi; CGAL_forall_vertices(vi, N) if(N.is_standard(vi)) return; bbox = Bbox_3(bbox.xmin()*10,bbox.ymin()*10,bbox.zmin()*10, bbox.xmax()*10,bbox.ymax()*10,bbox.zmax()*10); } public: static void convert_to_OGLPolyhedron(const Nef_polyhedron& N, CGAL::OGL::Polyhedron* P) { Bbox_3 bbox(bounded_bbox(N)); set_R(bbox,N); P->bbox() = bbox; Vertex_const_iterator v; CGAL_forall_vertices(v,*N.sncp()) draw(v,N,*P); Halfedge_const_iterator e; CGAL_forall_edges(e,*N.sncp()) draw(e,N,*P); Halffacet_const_iterator f; CGAL_forall_facets(f,*N.sncp()) draw(f,N,*P); } }; // Nef3_Converter } // namespace OGL CGAL_END_NAMESPACE #endif // CGAL_NEF_OPENGL_HELPER_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_ray_shooter.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_ray_shooter.0000644000175000017500000002422211344301501031017 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_ray_shooter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SNC_RAY_SHOOTER_H #define CGAL_SNC_RAY_SHOOTER_H #include #include #include #include #include #include #include #include #include #include #ifdef SM_VISUALIZOR #include #endif // SM_VISUALIZOR #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 37 #include CGAL_BEGIN_NAMESPACE // ---------------------------------------------------------------------------- // SNC_ray_shooting // ---------------------------------------------------------------------------- /*{\Manpage{SNC_ray_shooting}{SNC}{ray shoot functionality}{O}}*/ template class SNC_ray_shooter : public SNC_decorator { typedef SNC_structure_ SNC_structure; protected: typedef SNC_ray_shooter Self; typedef SNC_decorator Base; public: typedef typename SNC_structure_::Kernel Kernel; typedef SNC_decorator SNC_decorator; typedef SM_decorator SM_decorator; typedef SM_point_locator SM_point_locator; typedef SM_const_decorator SM_const_decorator; typedef SNC_intersection SNC_intersection; typedef typename SNC_structure::Vertex Vertex; typedef typename SNC_structure::Halfedge Halfedge; typedef typename SNC_structure::Halffacet Halffacet; typedef typename SNC_structure::Volume Volume; typedef typename SNC_structure::Vertex_iterator Vertex_iterator; typedef typename SNC_structure::Halfedge_iterator Halfedge_iterator; typedef typename SNC_structure::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Volume_iterator Volume_iterator; typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::Vertex_const_handle Vertex_const_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Volume_const_handle Volume_const_handle; typedef typename SNC_structure::SVertex_iterator SVertex_iterator; typedef typename SNC_structure::SHalfedge_iterator SHalfedge_iterator; typedef typename SNC_structure::SFace_iterator SFace_iterator; typedef typename SNC_structure::SHalfloop_iterator SHalfloop_iterator; typedef typename SNC_structure::SVertex SVertex; typedef typename SNC_structure::SHalfedge SHalfedge; typedef typename SNC_structure::SFace SFace; typedef typename SNC_structure::SHalfloop SHalfloop; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::SVertex_const_handle SVertex_const_handle; typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SNC_structure::SFace_const_handle SFace_const_handle; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::SObject_handle SObject_handle; typedef typename SNC_structure::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; typedef typename SNC_structure::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename SNC_structure::SFace_cycle_iterator SFace_cycle_iterator; typedef typename SNC_structure::SFace_cycle_const_iterator SFace_cycle_const_iterator; typedef typename SNC_structure::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Shell_entry_iterator Shell_entry_iterator; typedef typename SNC_structure::Shell_entry_const_iterator Shell_entry_const_iterator; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Ray_3 Ray_3; typedef typename SNC_structure::Line_3 Line_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Sphere_point Sphere_point; typedef typename SNC_structure::Sphere_segment Sphere_segment; typedef typename SNC_structure::Sphere_circle Sphere_circle; typedef typename SNC_structure::Sphere_direction Sphere_direction; typedef typename SNC_structure::Mark Mark; typedef typename SNC_structure::Infi_box Infi_box; typedef typename SM_decorator::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; typedef typename SM_decorator::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef void* GenPtr; SNC_ray_shooter() {} void initialize(SNC_structure* W) { Base::initialize(W); } SNC_ray_shooter(SNC_structure& W) : Base(W) {} /*{\Mcreate makes |\Mvar| a ray shooter on |W|.}*/ private: Volume_handle determine_volume(const Ray_3& ray) const { CGAL_precondition( !ray.is_degenerate()); Object_handle o = shoot(ray); Vertex_handle v; Halfedge_handle e; Halffacet_handle f, f_below; if( CGAL::assign(v, o)) { CGAL_NEF_TRACEN("facet below from from vertex..."); f_below = get_visible_facet(v, ray); if(f_below != Halffacet_handle()) return volume(f_below); SM_decorator SD(v); CGAL_assertion( SD.number_of_sfaces() == 1); return volume(SD.sfaces_begin()); } else if( CGAL::assign(e, o)) { CGAL_NEF_TRACEN("facet below from from edge..."); f_below = get_visible_facet(e, ray); if(f_below != Halffacet_handle()) return volume(f_below); SM_decorator SD(source(e)); CGAL_assertion(SD.is_isolated(e)); return volume(sface(e)); } else if( CGAL::assign(f, o)) { CGAL_NEF_TRACEN("facet below from from facet..."); f_below = get_visible_facet(f, ray); CGAL_assertion( f_below != Halffacet_handle()); return volume(f_below); } return Base(*this).volumes_begin(); } public: Object_handle shoot(const Ray_3& ray) const /*{\Mop returns the nearest object hit by a ray |ray|. }*/ { CGAL_precondition( !ray.is_degenerate()); bool hit = false; Point_3 end_of_seg; SNC_intersection is(*this->sncp()); CGAL_NEF_TRACEN( "Shooting ray " << ray); Object_handle o; Vertex_handle v; CGAL_forall_vertices( v, *this->sncp()) { if ( ray.source() != point(v) && ray.has_on(point(v))) { if(hit && !Segment_3(ray.source(), end_of_seg).has_on(point(v))) continue; CGAL_NEF_TRACEN("ray hit vertex case "<sncp()) { Point_3 q; if( is.does_intersect_internally( ray, segment(e), q)) { if (!hit || has_smaller_distance_to_point(ray.source(),q, end_of_seg)) { CGAL_NEF_TRACEN("ray hit edge case " << segment(e) << " in " << q); end_of_seg = q; hit = true; o = Object_handle(e); } } } Halffacet_handle f; CGAL_forall_halffacets( f, *this->sncp()) { Point_3 q; if( is.does_intersect_internally( ray, f, q) ) { if(!hit || has_smaller_distance_to_point(ray.source(), q, end_of_seg)) { CGAL_NEF_TRACEN("ray hit facet "<sncp()); CGAL_NEF_TRACEN( "Point locator for " << p); Vertex_handle v; CGAL_forall_vertices( v, *this->sncp()) { CGAL_NEF_TRACEN("test vertex " << point(v)); if ( p == point(v)) { CGAL_NEF_TRACEN("on vertex."); return Object_handle(v); } } Halfedge_handle e; CGAL_forall_edges( e, *this->sncp()) { if ( is.does_contain_internally( segment(e), p) ) { CGAL_NEF_TRACEN("on edge."); return Object_handle(e); } } Halffacet_handle f; CGAL_forall_halffacets( f, *this->sncp()) { if ( is.does_contain_internally( f, p) ) { CGAL_NEF_TRACEN("on facet."); return Object_handle(f); } } Ray_3 r( p, Vector_3( -1, 0, 0)); return Object_handle(determine_volume(r)); } }; // SNC_ray_shooter CGAL_END_NAMESPACE #endif //CGAL_SNC_RAY_SHOOTER_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_k3_tree_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_k3_tree_trai0000644000175000017500000003147711344301501030770 0ustar debiandebian#line 934 "k3_tree.nw" // Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_k3_tree_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Miguel Granados #ifndef SNC_K3_TREE_TRAITS_H #define SNC_K3_TREE_TRAITS_H #include #include #define CGAL_for_each( i, C) for( i = C.begin(); i != C.end(); ++i) CGAL_BEGIN_NAMESPACE template class Side_of_plane { public: typedef typename SNC_decorator::SNC_structure SNC_structure; typedef typename SNC_decorator::Decorator_traits Decorator_traits; typedef typename Decorator_traits::Vertex_handle Vertex_handle; typedef typename Decorator_traits::Halfedge_handle Halfedge_handle; typedef typename Decorator_traits::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename SNC_structure::Object_handle Object_handle; typedef typename Decorator_traits::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename Decorator_traits::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename Decorator_traits::SHalfedge_handle SHalfedge_handle; typedef typename SNC_decorator::Kernel Kernel; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Segment_3 Segment_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Triangle_3 Triangle_3; typedef typename Kernel::Vector_3 Vector_3; typedef typename Kernel::RT RT; Oriented_side operator()( const Plane_3& pl, Object_handle o); Oriented_side operator()( const Plane_3& pl, Vertex_handle v); Oriented_side operator()( const Plane_3& pl, Halfedge_handle e); Oriented_side operator()( const Plane_3& pl, Halffacet_handle f); Oriented_side operator()( const Plane_3& pl, Halffacet_triangle_handle f); SNC_decorator D; Unique_hash_map OnSideMap; }; template class Objects_bbox { public: typedef typename SNC_decorator::SNC_structure SNC_structure; typedef typename SNC_decorator::Decorator_traits Decorator_traits; typedef typename Decorator_traits::Vertex_handle Vertex_handle; typedef typename Decorator_traits::Halfedge_handle Halfedge_handle; typedef typename Decorator_traits::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename SNC_structure::Object_handle Object_handle; typedef std::vector Object_list; typedef typename Decorator_traits::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename Decorator_traits::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename Decorator_traits::SHalfedge_handle SHalfedge_handle; typedef typename SNC_decorator::Kernel Kernel; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Segment_3 Segment_3; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Triangle_3 Triangle_3; typedef typename Kernel::RT RT; typedef typename Kernel::Kernel_tag Kernel_tag; typedef Bounding_box_3 Bounding_box_3; virtual Bounding_box_3 operator()(const Object_list& o) const; virtual Bounding_box_3 operator()(Object_handle o) const; virtual Bounding_box_3 operator()(Vertex_handle v) const; virtual Bounding_box_3 operator()(Halfedge_handle e) const; virtual Bounding_box_3 operator()(Halffacet_handle f) const; virtual Bounding_box_3 operator()(Halffacet_triangle_handle f) const; SNC_decorator D; }; template class SNC_k3_tree_traits { public: typedef Decorator SNC_decorator; typedef typename SNC_decorator::SNC_structure SNC_structure; typedef typename SNC_structure::Kernel Kernel; typedef typename SNC_structure::Infi_box Infimaximal_box; typedef typename SNC_decorator::Decorator_traits Decorator_traits; typedef typename Decorator_traits::Vertex_handle Vertex_handle; typedef typename Decorator_traits::Halfedge_handle Halfedge_handle; typedef typename Decorator_traits::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename SNC_structure::Object_handle Object_handle; typedef std::vector Object_list; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Segment_3 Segment_3; typedef typename Kernel::Ray_3 Ray_3; typedef typename Kernel::Vector_3 Vector_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Triangle_3 Triangle_3; typedef typename Kernel::Aff_transformation_3 Aff_transformation_3; typedef typename Kernel::RT RT; typedef typename Kernel::Kernel_tag Kernel_tag; typedef Bounding_box_3 Bounding_box_3; typedef typename Kernel::Intersect_3 Intersect; typedef Objects_bbox Objects_bbox; typedef Side_of_plane Side_of_plane; Intersect intersect_object() const { return Intersect(); } Side_of_plane side_of_plane_object() const { return Side_of_plane(); } Objects_bbox objects_bbox_object() const { return Objects_bbox(); } }; template Oriented_side Side_of_plane::operator() ( const Plane_3& pl, Object_handle o) { Vertex_handle v; Halfedge_handle e; Halffacet_handle f; if( CGAL::assign( v, o)) return (*this)( pl, v); else if( CGAL::assign( e, o)) return (*this)( pl, e); else if( CGAL::assign( f, o)) return (*this)( pl, f); else { Halffacet_triangle_handle t; if( CGAL::assign( t, o)) return (*this)( pl, t); else CGAL_assertion_msg( 0, "wrong handle"); } return Oriented_side(); // never reached } template Oriented_side Side_of_plane::operator() ( const Plane_3& pl, Vertex_handle v) { if(!OnSideMap.is_defined(v)) OnSideMap[v] = pl.oriented_side(D.point(v)); return OnSideMap[v]; } /* An edge is considered intersecting a plane if its endpoints lie on the plane or if they lie on diferent sides. Partial tangency is not considered as intersection, due the fact that a lower dimensional face (the vertex) should be already reported as an object intersecting the plane. */ template Oriented_side Side_of_plane::operator() ( const Plane_3& pl, Halfedge_handle e) { if(!OnSideMap.is_defined(D.source(e))) OnSideMap[D.source(e)] = pl.oriented_side(D.point(D.source(e))); if(!OnSideMap.is_defined(D.target(e))) OnSideMap[D.target(e)] = pl.oriented_side(D.point(D.target(e))); Oriented_side src_side = OnSideMap[D.source(e)]; Oriented_side tgt_side = OnSideMap[D.target(e)]; if( src_side == tgt_side) return src_side; if( src_side == ON_ORIENTED_BOUNDARY) return tgt_side; if( tgt_side == ON_ORIENTED_BOUNDARY) return src_side; return ON_ORIENTED_BOUNDARY; } template Oriented_side Side_of_plane::operator() ( const Plane_3& pl, Halffacet_triangle_handle t) { bool on_positive_side = false, on_negative_side = false; Triangle_3 tr(t.get_triangle()); for( int i = 0; i < 3; ++i) { Oriented_side side = pl.oriented_side(tr[i]); if( side == ON_POSITIVE_SIDE) on_positive_side = true; else if( side == ON_NEGATIVE_SIDE) on_negative_side = true; } if( on_positive_side && on_negative_side) return ON_ORIENTED_BOUNDARY; if( !on_positive_side && !on_negative_side) return ON_ORIENTED_BOUNDARY; if( on_positive_side) { CGAL_assertion( !on_negative_side); return ON_POSITIVE_SIDE; } CGAL_assertion( on_negative_side); return ON_NEGATIVE_SIDE; } /* As for the edges, if a facet is tanget to the plane it is not considered as a interesection since lower dimensional faces, like the edges and vertices where the tangency occurrs, should be reported as the objects intersecting the plane. So, an intersection is reported if all vertices of the facet lie on plane, for which it is only necessary to check three vertices, or if the facet has vertices on both sides of the plane, so the intersection is known as far as two vertices located on different sides of the plane. */ template Oriented_side Side_of_plane::operator() ( const Plane_3& pl, Halffacet_handle f) { CGAL_assertion( std::distance( f->facet_cycles_begin(), f->facet_cycles_end()) > 0); Halffacet_cycle_iterator fc(f->facet_cycles_begin()); SHalfedge_handle e; CGAL_assertion(fc.is_shalfedge()); e = SHalfedge_handle(fc); SHalfedge_around_facet_circulator sc(e), send(sc); //CGAL_assertion( iterator_distance( sc, send) >= 3); // TODO: facet with 2 vertices was found, is it possible? Oriented_side facet_side; do { if(!OnSideMap.is_defined(D.vertex(sc))) OnSideMap[D.vertex(sc)] = pl.oriented_side(D.point(D.vertex(sc))); facet_side = OnSideMap[D.vertex(sc)]; ++sc; } while( facet_side == ON_ORIENTED_BOUNDARY && sc != send); if( facet_side == ON_ORIENTED_BOUNDARY) return ON_ORIENTED_BOUNDARY; CGAL_assertion( facet_side != ON_ORIENTED_BOUNDARY); while( sc != send) { if(!OnSideMap.is_defined(D.vertex(sc))) OnSideMap[D.vertex(sc)] = pl.oriented_side(D.point(D.vertex(sc))); Oriented_side point_side = OnSideMap[D.vertex(sc)]; ++sc; if( point_side == ON_ORIENTED_BOUNDARY) continue; if( point_side != facet_side) return ON_ORIENTED_BOUNDARY; } return facet_side; } template Bounding_box_3 Objects_bbox::operator() ( const Object_list& O) const { CGAL_assertion( O.size() >= 0); Bounding_box_3 b(Point_3(0,0,0),Point_3(0,0,0)); typename Object_list::const_iterator o; for( o = O.begin(); o != O.end(); ++o) { Vertex_handle v; if( CGAL::assign( v, *o)) { b = b + (*this)(v); } } return b; } template Bounding_box_3 Objects_bbox::operator() (Object_handle o) const { Vertex_handle v; Halfedge_handle e; Halffacet_handle f; if( CGAL::assign( v, o)) return operator()(v); else if( CGAL::assign( e, o)) return operator()(e); else if( CGAL::assign( f, o)) return operator()(f); else { Halffacet_triangle_handle t; if( CGAL::assign( t, o)) return operator()(t); else CGAL_assertion_msg( 0, "wrong handle"); } return Bounding_box_3(); // never reached } template Bounding_box_3 Objects_bbox::operator() (Vertex_handle v) const { Point_3 p(D.point(v)); return Bounding_box_3(p, p); } template Bounding_box_3 Objects_bbox::operator() (Halfedge_handle e) const { return (operator()(D.vertex(e)) + operator()(D.vertex(D.twin(e)))); } template Bounding_box_3 Objects_bbox::operator() (Halffacet_triangle_handle t) const { Bounding_box_3 bbox(Point_3(0,0,0),Point_3(0,0,0)); Triangle_3 tr(t.get_triangle()); for( int i = 0; i < 3; ++i) { Point_3 p(tr[i]); bbox = bbox + Bounding_box_3(p,p); } return bbox; } template Bounding_box_3 Objects_bbox::operator() (Halffacet_handle f) const { // TODO CGAL_assertion( f->facet_cycles_begin() != Halffacet_cycle_iterator()); Halffacet_cycle_iterator fc(f->facet_cycles_begin()); SHalfedge_handle e; CGAL_assertion(fc.is_shalfedge()); e = SHalfedge_handle(fc); SHalfedge_around_facet_circulator sc(e), send(sc); CGAL_assertion( !is_empty_range( sc, send)); Bounding_box_3 b(operator()(D.vertex(sc))); sc++; while( sc != send) { b = b + operator()(D.vertex(sc)); sc++; } return b; } CGAL_END_NAMESPACE #endif // SNC_K3_TREE_TRAITS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_sphere_map.h0000644000175000017500000003731211344301501030760 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_sphere_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_SNC_SPHERE_MAP_H #define CGAL_SNC_SPHERE_MAP_H #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 109 #include CGAL_BEGIN_NAMESPACE template class SNC_structure; template struct move_shalfedge_around_svertex { void forward(HE& e) const { e = (e->sprev()->twin()); } void backward(HE& e) const { e = (e->twin()->snext()); } }; template struct move_shalfedge_around_sface { void forward(HE& e) const { e = (e->snext()); } void backward(HE& e) const { e = (e->sprev()); } }; template class SNC_sphere_map : public Items_::template Vertex > { public: /*{\Mtypes 7}*/ typedef SNC_sphere_map Self; typedef Items_ Items; typedef Kernel_ Kernel; typedef Mark_ Mark; typedef SNC_structure SNC_structure; typedef typename Items::template Vertex Base; // typedef bool Mark; typedef CGAL::Sphere_geometry Sphere_kernel; typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember points on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember segments on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember segments on the unit sphere.}*/ typedef typename Sphere_kernel::Sphere_direction Sphere_direction; /*{\Mtypemember directions on the unit sphere.}*/ typedef size_t Size_type; /*{\Mtypemember size type.}*/ typedef Infimaximal_box::value_type, Kernel> Infi_box; typedef typename Infi_box::Standard_kernel Standard_kernel; typedef Infimaximal_box::value_type, Standard_kernel> No_box; typedef Self Vertex_base; typedef SNC_in_place_list_sm Vertex; typedef CGAL::In_place_list Vertex_list; typedef CGAL_ALLOCATOR(Vertex) Vertex_alloc; typedef typename Vertex_list::iterator Vertex_handle; typedef typename Vertex_list::const_iterator Vertex_const_handle; typedef typename Vertex_list::iterator Vertex_iterator; typedef typename Vertex_list::const_iterator Vertex_const_iterator; typedef typename Items::template SVertex SVertex_base; typedef SNC_in_place_list_svertex SVertex; typedef CGAL::In_place_list SVertex_list; typedef CGAL_ALLOCATOR(SVertex) SVertex_alloc; typedef typename SVertex_list::iterator SVertex_handle; typedef typename SVertex_list::const_iterator SVertex_const_handle; typedef typename SVertex_list::iterator SVertex_iterator; typedef typename SVertex_list::const_iterator SVertex_const_iterator; typedef typename Items::template SHalfedge SHalfedge_base; typedef SNC_in_place_list_shalfedge SHalfedge; typedef CGAL::In_place_list SHalfedge_list; typedef CGAL_ALLOCATOR(SHalfedge) SHalfedge_alloc; typedef typename SHalfedge_list::iterator SHalfedge_handle; typedef typename SHalfedge_list::const_iterator SHalfedge_const_handle; typedef typename SHalfedge_list::iterator SHalfedge_iterator; typedef typename SHalfedge_list::const_iterator SHalfedge_const_iterator; typedef typename Items::template SHalfloop SHalfloop_base; typedef SNC_in_place_list_shalfloop SHalfloop; typedef CGAL::In_place_list SHalfloop_list; typedef CGAL_ALLOCATOR(SHalfloop) SHalfloop_alloc; typedef typename SHalfloop_list::iterator SHalfloop_handle; typedef typename SHalfloop_list::const_iterator SHalfloop_const_handle; typedef typename SHalfloop_list::iterator SHalfloop_iterator; typedef typename SHalfloop_list::const_iterator SHalfloop_const_iterator; typedef typename Items::template SFace SFace_base; typedef SNC_in_place_list_sface SFace; typedef CGAL::In_place_list SFace_list; typedef CGAL_ALLOCATOR(SFace) SFace_alloc; typedef typename SFace_list::iterator SFace_handle; typedef typename SFace_list::const_iterator SFace_const_handle; typedef typename SFace_list::iterator SFace_iterator; typedef typename SFace_list::const_iterator SFace_const_iterator; typedef CGAL::Object_handle Object_handle; typedef std::list Object_list; typedef Object_list::iterator Object_iterator; typedef Object_list::const_iterator Object_const_iterator; typedef Object_list::const_iterator Object_const_handle; typedef Vertex_handle Constructor_parameter; typedef Vertex_const_handle Constructor_const_parameter; public: SNC_sphere_map(bool construct=false) : Base(), destruct(construct) { if(!construct) return; this->sncp() = new SNC_structure; init_range(this->sncp()->svertices_end()); init_range(this->sncp()->shalfedges_end()); init_range(this->sncp()->sfaces_end()); this->shalfloop() = this->sncp()->shalfloops_end(); } ~SNC_sphere_map() { if(destruct) delete this->sncp(); } SNC_sphere_map(const Base& v) : Base(v), destruct(false) {} SNC_sphere_map(const Self& M) : Base((Base) M), destruct(M.destruct) {} Self& operator=(const Self& M) { destruct = M.destruct; Base* b(this); *b = M; return *this; } void clear(bool clear_base=false) { if(clear_base) Base::clear(); } template bool is_sm_boundary_object(H h) const { return this->sncp()->is_sm_boundary_object(h); } template Object_iterator& sm_boundary_item(H h) { return this->sncp()->sm_boundary_item(h); } template void store_sm_boundary_item(H h, Object_iterator o) { this->sncp()->store_sm_boundary_item(h,o); } template void undef_sm_boundary_item(H h) { this->sncp()->undef_sm_boundary_item(h); } void reset_sm_iterator_hash(Object_iterator it) { SVertex_handle sv; SHalfedge_handle se; SHalfloop_handle sl; if ( CGAL::assign(se,*it) ) { if( is_sm_boundary_object(se)) undef_sm_boundary_item(se); return; } if ( CGAL::assign(sl,*it) ) { if( is_sm_boundary_object(sl)) undef_sm_boundary_item(sl); return; } if ( CGAL::assign(sv,*it) ) { if( is_sm_boundary_object(sv)) undef_sm_boundary_item(sv); return; } } void reset_sm_object_list(Object_list& L) { Object_iterator oit; CGAL_forall_iterators(oit,L) reset_sm_iterator_hash(oit); L.clear(); } class SFace_cycle_iterator : public Object_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a sface. Convertible to |Object_handle|.}*/ { typedef Object_iterator Ibase; public: SFace_cycle_iterator() : Ibase() {} SFace_cycle_iterator(const Ibase& b) : Ibase(b) {} SFace_cycle_iterator(const SFace_cycle_iterator& i) : Ibase(i) {} bool is_svertex() const { SVertex_handle v; return CGAL::assign(v,Ibase::operator*()); } bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SVertex_handle() const { SVertex_handle v; CGAL::assign(v,Ibase::operator*()); return v; } operator SHalfedge_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return e; } operator SHalfloop_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return l; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { this->CGAL_nef_assertion_msg(0,"not impl."); return Object_handle(); } }; class SFace_cycle_const_iterator : public Object_const_iterator /*{\Mtypemember a generic iterator to an object in the boundary of a facet. Convertible to |Object_handle|.}*/ { typedef Object_const_iterator Ibase; public: SFace_cycle_const_iterator() : Ibase() {} SFace_cycle_const_iterator(const Ibase& b) : Ibase(b) {} SFace_cycle_const_iterator(const SFace_cycle_const_iterator& i) : Ibase(i) {} bool is_svertex() const { SVertex_handle v; return CGAL::assign(v,Ibase::operator*()); } bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SVertex_const_handle() const { SVertex_handle v; CGAL::assign(v,Ibase::operator*()); return SVertex_const_handle(v); } operator SHalfedge_const_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return SHalfedge_const_handle(e); } operator SHalfloop_const_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return SHalfloop_const_handle(l); } operator Object_handle() const { return Ibase::operator*(); } const Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { this->CGAL_nef_assertion_msg(0,"not impl."); return Object_handle(); } }; SFace_cycle_const_iterator sface_cycles_begin(SFace_const_handle f) const { return f->sface_cycles_begin(); } SFace_cycle_const_iterator sface_cycles_end(SFace_const_handle f) const { return f->sface_cycles_end(); } SFace_cycle_iterator sface_cycles_begin(SFace_handle f) const { return f->sface_cycles_begin(); } SFace_cycle_iterator sface_cycles_end(SFace_handle f) const { return f->sface_cycles_end(); } typedef CircFromIt< SHalfedge_const_iterator, move_shalfedge_around_svertex > SHalfedge_around_svertex_const_circulator; typedef CircFromIt< SHalfedge_const_iterator, move_shalfedge_around_sface > SHalfedge_around_sface_const_circulator; typedef CircFromIt< SHalfedge_iterator, move_shalfedge_around_svertex > SHalfedge_around_svertex_circulator; typedef CircFromIt< SHalfedge_iterator, move_shalfedge_around_sface > SHalfedge_around_sface_circulator; bool empty() const { return this->number_of_svertices() == 0 && this->number_of_shalfedges() == 0 && this->number_of_shalfloops() == 0 && this->number_of_sfaces() == 0; } /* bool has_shalfloop() const { return shalfloop_ != 0; } SHalfloop_handle shalfloop() const { return shalfloop_; } */ template void make_twins(H h1, H h2) { h1->twin() = h2; h2->twin() = h1; } SVertex_handle new_svertex(const Sphere_point& p, Mark m = Mark()) { SVertex_iterator sv; if (this->svertices_begin() == this->sncp()->svertices_end()) { sv = this->sncp()->new_halfedge_only(); init_range(sv); } else { SVertex_iterator svn = this->svertices_end(); sv = this->sncp()->new_halfedge_only(svn); this->svertices_last() = sv; } sv->point() = p; sv->mark() = m; sv->center_vertex() = Vertex_handle((SNC_in_place_list_sm*) this); CGAL_NEF_TRACEN("new_svertex "<<&*sv); return sv; } SFace_handle new_sface() { SFace_iterator sf = this->sncp()->new_sface_only(); if ( this->sfaces_begin() == this->sncp()->sfaces_end()) init_range(sf); else this->sfaces_last() = sf; sf->center_vertex() = Vertex_handle((SNC_in_place_list_sm*) this); return sf; } SHalfedge_handle new_shalfedge_pair() { SHalfedge_iterator se = this->sncp()->new_shalfedge_only(); SHalfedge_iterator set = this->sncp()->new_shalfedge_only(); if(this->shalfedges_begin() == this->sncp()->shalfedges_end()) init_range(se); this->shalfedges_last() = set; make_twins(se,set); return se; } SHalfloop_handle new_shalfloop_pair() { // CGAL_assertion( !cv->has_shalfloop() ); CGAL_assertion( !this->has_shalfloop() ); SHalfloop_iterator sl = this->sncp()->new_shalfloop_only(); SHalfloop_iterator slt = this->sncp()->new_shalfloop_only(); make_twins(sl,slt); // cv->shalfloop() = sl; this->shalfloop() = sl; return sl; } void delete_svertex(SVertex_handle v) { if (this->svertices_begin() == this->svertices_last() ) { CGAL_assertion(v == this->svertices_begin()); init_range(this->sncp()->svertices_end()); } else if (this->svertices_begin() == v ) ++(this->svertices_begin()); else if (this->svertices_last() == v ) --(this->svertices_last()); this->sncp()->delete_halfedge_only(v); } void delete_shalfedge(SHalfedge_handle e) { if ( this->shalfedges_begin() == this->shalfedges_last() ) { CGAL_assertion( e == this->shalfedges_begin() ); init_range(this->sncp()->shalfedges_end()); } else if (this->shalfedges_begin() == e ) ++(this->shalfedges_begin()); else if (this->shalfedges_last() == e ) --(this->shalfedges_last()); this->sncp()->delete_shalfedge_only(e); } void delete_shalfedge_pair(SHalfedge_handle e) { delete_shalfedge(e->twin()); delete_shalfedge(e); } void delete_sface(SFace_handle f) { if (this->sfaces_begin() == this->sfaces_last() ) { CGAL_assertion( f == this->sfaces_begin() ); init_range(this->sncp()->sfaces_end()); } else if (this->sfaces_begin() == f ) ++(this->sfaces_begin()); else if (this->sfaces_last() == f ) --(this->sfaces_last()); this->sncp()->delete_sface_only(f); } void delete_shalfloop_pair() { CGAL_assertion(this->has_shalfloop() ); this->sncp()->delete_shalfloop_only(this->shalfloop()->twin()); this->sncp()->delete_shalfloop_only(this->shalfloop()); this->shalfloop() = this->sncp()->shalfloops_end(); } protected: bool destruct; }; // SNC_sphere_map CGAL_END_NAMESPACE #endif // CGAL_SNC_SPHERE_MAP_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Infimaximal_box.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Infimaximal_box.0000644000175000017500000005061211344301501031066 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Infimaximal_box.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_INFIMAXIMAL_BOX_H #define CGAL_INFIMAXIMAL_BOX_H #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 191 #include #include #include #include CGAL_BEGIN_NAMESPACE template struct Is_extended_kernel { typedef Tag_false value_type; }; template struct Is_extended_kernel > { typedef Tag_true value_type; }; template struct Is_extended_kernel > { typedef Tag_true value_type; }; template class Infimaximal_box { public: typedef typename Kernel::RT NT; typedef typename Kernel::RT RT; typedef Kernel Standard_kernel; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Vector_3 Vector_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Ray_3 Ray_3; typedef typename Kernel::Aff_transformation_3 Aff_transformation_3; typedef Plane_3 Standard_plane; typedef Vector_3 Standard_vector; typedef Point_3 Standard_point; static bool standard_kernel() { return true; } static bool extended_kernel() { return false; } static bool is_standard(const Point_3& p) { return true; } static bool is_standard(const Plane_3& p) { return true; } static bool check_point_on_plane(Point_3 p, Plane_3 h) { return (p.hx()*h.a()+p.hy()*h.b()+p.hz()*h.c()+p.hw()*h.d() == 0); } static Point_3 simplify(Point_3& p) { return p; } static Standard_point standard_point(Point_3 p, NT d=1) { return p; } static Standard_plane standard_plane(Plane_3 p, NT d=1) { return p; } static Standard_vector standard_vector(Vector_3 p) { return p; } static void set_size_of_infimaximal_box(const NT& size) {} static int degree(const RT& n) { return 0; } static NT get_coeff(const RT& p, unsigned int i) { return p; } static NT eval_at(const RT& p) { return p; } static bool is_infibox_corner(const Point_3& p) { return false; } template static bool is_complex_facet_infibox_intersection(const Sphere_map& sm) { return false; } static int type_of_infibox_point(const Point_3& p) { return 0; } template static typename SNC_structure::Volume_handle getNirvana(SNC_structure& snc) { return snc.volumes_begin(); } template static bool is_beyond_Infibox(typename SNC_structure::SFace_handle sf, SNC_structure& snc) { return false; } static bool x_on_box(const Point_3& p) { return false; } static bool y_on_box(const Point_3& p) { return false; } static bool z_on_box(const Point_3& p) { return false; } template static NT compute_evaluation_constant_for_halfedge_pairup(const SNC_structure& snc) { return NT(1); } static void compute_min_max(const Plane_3& h, NT orth_coords[3], int& min, int& max) { } static Point_3 scale_infibox_vertex(const Point_3 pin) { return Point_3(); } static Point_3 normalize_transformed_vertex(const Point_3& p) { return Point_3(); } template static std::list create_vertices_on_infibox(SNC_constructor& C, const Plane_3& h, const std::list& points, const Mark& bnd, const Mark& inside, const Mark& outside) { return std::list(); } template static std::list find_points_of_box_with_plane(SNC_constructor& C, const Plane_3& h) { return std::list(); } static typename std::list::const_iterator segment_on_side(int side_of_point, const std::list& segs) { return segs.begin(); } static Point_3 create_extended_point(NT x, NT y, NT z) { std::cerr << "function should not be called" << std::endl; CGAL_assertion_msg(0,"function should not be called"); return Point_3(0,0,0); } static Plane_3 create_extended_plane(NT a, NT b, NT c, NT d) { std::cerr << "function should not be called" << std::endl; return Plane_3(1,0,0,0); } template static Ray_3 get_ray(SNC_decorator& D, Point& p) { // return D.point(D.vertex(D.shells_begin(D.volumes_begin()))); return Ray_3(p, Vector_3(-1,0,0)); } template static void create_vertices_of_box_with_plane(SNC_constructor_& C, const Plane_3& h, bool b) { std::cerr << "Constructor not available for this Kernel" << std::endl; } template static void initialize_infibox_vertices(SNC_constructor& C, bool space) { } template static bool is_sedge_on_infibox(SHalfedge_handle sh) { return false; } template static bool is_edge_on_infibox(Halfedge_handle e) { return false; } template static bool is_type4(Halfedge_handle e) {return false;} template static bool is_type3(Halfedge_handle e) {return false;} }; template class Infimaximal_box { public: typedef typename Kernel::RT RT; typedef typename Kernel::RT::NT NT; typedef typename Kernel::Standard_kernel Standard_kernel; typedef typename Standard_kernel::Point_3 Standard_point; typedef typename Standard_kernel::Plane_3 Standard_plane; typedef typename Standard_kernel::Vector_3 Standard_vector; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Vector_3 Vector_3; typedef typename Kernel::Segment_3 Segment_3; typedef typename Kernel::Direction_3 Direction_3; typedef typename Kernel::Aff_transformation_3 Aff_transformation_3; // typedef typename SNC_structure::Sphere_point Sphere_point; // typedef typename SNC_structure::Sphere_circle Sphere_circle; // typedef SM_decorator SM_decorator; enum Boundary { EXCLUDED=0, INCLUDED=1 }; static const int RADIUS = 10000000; static bool standard_kernel() { return false; } static bool extended_kernel() { return true; } static bool is_standard(const Point_3& p) { CGAL_assertion(p.hw().degree()==0); return (p.hx().degree()==0 && p.hy().degree()==0 && p.hz().degree()==0); } static bool is_standard(const Plane_3& p) { return (p.d().degree() == 0); } static int type_of_infibox_point(const Point_3& p) { int res = 0; RT W(NT(0),p.hw()[0]); if(CGAL_NTS abs(p.hx()) == W) ++res; if(CGAL_NTS abs(p.hy()) == W) ++res; if(CGAL_NTS abs(p.hz()) == W) ++res; return res; } static bool is_infibox_corner(const Point_3& p) { return type_of_infibox_point(p) == 3; } static Point_3 simplify(Point_3& p) { CGAL_assertion(p.hw().degree() == 0); int deg = p.hx().degree() > p.hy().degree() ? p.hx().degree() : p.hy().degree(); deg = p.hz().degree() > deg ? p.hz().degree() : deg; return Point_3(p.hx().degree() == deg ? p.hx()[deg] : 0, p.hy().degree() == deg ? p.hy()[deg] : 0, p.hz().degree() == deg ? p.hz()[deg] : 0, p.hw()[0]); } static int degree(const RT& p) { return p.degree(); } static NT get_coeff(const RT& p, unsigned int i) { return p[i]; } static NT eval_at(const RT& p, NT d=RADIUS) { return p.eval_at(d); } static Point_3 target_for_ray_shoot_on_minus_x_direction(Point_3 p) { CGAL_warning(is_standard(p)); return Point(RT(0,-1), RT(p.hy()[0]), RT(p.hz()[0]), RT(p.hw()[0])); } static bool check_point_on_plane(Point_3 p, Plane_3 h) { NT x(p.hx().eval_at(100)); NT y(p.hy().eval_at(100)); NT z(p.hz().eval_at(100)); NT w(p.hw().eval_at(100)); NT d(h.d().eval_at(100)); return (x*h.a()+y*h.b()+z*h.c()+w*d == 0); } static Standard_point standard_point(Point_3 p, NT d=1) { return Standard_point(p.hx().eval_at(d), p.hy().eval_at(d), p.hz().eval_at(d), p.hw().eval_at(1)); } static Standard_plane standard_plane(Plane_3 p, NT d=1) { return Standard_plane(p.a().eval_at(1), p.b().eval_at(1), p.c().eval_at(1), p.d().eval_at(d)); } static Standard_vector standard_vector(Vector_3 p) { return Standard_vector(p.hx().eval_at(1), p.hy().eval_at(1), p.hz().eval_at(1)); } static void set_size_of_infimaximal_box(NT size) { RT::infi_maximal_value() = size; } static bool x_on_box(const Point_3& p) { return CGAL_NTS abs(p.hx()) == RT(0,p.hw()[0]); } static bool y_on_box(const Point_3& p) { return CGAL_NTS abs(p.hy()) == RT(0,p.hw()[0]); } static bool z_on_box(const Point_3& p) { return CGAL_NTS abs(p.hz()) == RT(0,p.hw()[0]); } static Point_3 create_extended_point(NT x, NT y, NT z) { return Point_3(RT(0,x), RT(0,y), RT(0,z), RT(1)); } static Plane_3 create_extended_plane(NT a, NT b, NT c, NT d) { return Plane_3(a,b,c,RT(0,d)); } static Point_3 create_extended_point(NT a0,NT a1,NT b0,NT b1,NT c0,NT c1,NT d) { return Point_3(RT(a0,a1),RT(b0,b1),RT(c0,c1),RT(d)); } template static typename SNC_structure::Volume_handle getNirvana(SNC_structure& snc) { return ++(snc.volumes_begin()); } template static bool is_beyond_Infibox(typename SNC_structure::SFace_handle sf, SNC_structure& snc) { typename SNC_structure::SNC_decorator D(snc); return (D.volume(sf) == snc.volumes_begin()); } template static std::list create_vertices_on_infibox(SNC_constructor& C, const Plane_3& h, const std::list& points, const Mark& bnd, const Mark& inside, const Mark& outside) { return C.create_vertices_on_infibox(h,points,bnd,inside,outside); } template static void create_vertices_of_box_with_plane(SNC_constructor& C, const Plane_3& h, bool b) { C.create_vertices_of_box_with_plane(h, b); } static void compute_min_max(const Plane_3& h, NT orth_coords[3], int& min, int& max) { Vector_3 orth = h.orthogonal_vector(); orth_coords[0] = CGAL_NTS abs(orth.hx()[0]); orth_coords[1] = CGAL_NTS abs(orth.hy()[0]); orth_coords[2] = CGAL_NTS abs(orth.hz()[0]); max = 0; if(orth_coords[1] > orth_coords[0]) max = 1; if(orth_coords[2] > orth_coords[max]) max = 2; min = 0; if(orth_coords[1] < orth_coords[0]) min = 1; if(orth_coords[2] < orth_coords[min]) min = 2; } template static NT compute_evaluation_constant_for_halfedge_pairup(const SNC_structure& snc) { NT eval = 0; typename SNC_structure::Vertex_const_iterator v; CGAL_forall_vertices(v, snc) { Point_3 p(v->point()); if(p.hx()[0] > eval) eval = p.hx()[0]; if(p.hy()[0] > eval) eval = p.hy()[0]; if(p.hz()[0] > eval) eval = p.hz()[0]; } eval *= 4; if(eval == 0) return 1; return eval; } static Point_3 scale_infibox_vertex(const Point_3 pin, const Aff_transformation_3& aff) { RT lx(pin.hx()[0]); RT ly(pin.hy()[0]); RT lz(pin.hz()[0]); RT hx(pin.hx()-lx); RT hy(pin.hy()-ly); RT hz(pin.hz()-lz); RT hw(pin.hw()); Point_3 p(Point_3(lx,ly,lz,hw).transform(aff)); return Point_3(hx+p.hx(),hy+p.hy(),hz+p.hz(),hw); } static Point_3 normalize_transformed_vertex(const Point_3& p) { int i=0; if(CGAL_NTS abs(p.hx()) < CGAL_NTS abs(p.hy())) if(CGAL_NTS abs(p.hy()) < CGAL_NTS abs(p.hz())) i = 2; else i = 1; else if(CGAL_NTS abs(p.hx()) < CGAL_NTS abs(p.hz())) i = 2; switch(i) { case 0: CGAL_assertion(p.hx().degree() == 1); if(p.hx()[1] > 0) return Point_3(RT(0,p.hx()[1]*p.hw()[0]), RT(p.hy()[0]*p.hx()[1]-p.hx()[0]*p.hy()(1),p.hy()(1)*p.hw()[0]), RT(p.hz()[0]*p.hx()[1]-p.hx()[0]*p.hz()(1),p.hz()(1)*p.hw()[0]), RT(p.hw()[0]*p.hx()[1])); else return Point_3(RT(0,-p.hx()[1]*p.hw()[0]), RT(p.hy()[0]*p.hx()[1]-p.hx()[0]*p.hy()(1),-p.hy()(1)*p.hw()[0]), RT(p.hz()[0]*p.hx()[1]-p.hx()[0]*p.hz()(1),-p.hz()(1)*p.hw()[0]), RT(p.hw()[0]*p.hx()[1])); case 1: CGAL_assertion(p.hy().degree() == 1); if(p.hy()[1] > 0) return Point_3(RT(p.hx()[0]*p.hy()[1]-p.hy()[0]*p.hx()(1),p.hx()(1)*p.hw()[0]), RT(0,p.hy()[1]*p.hw()[0]), RT(p.hz()[0]*p.hy()[1]-p.hy()[0]*p.hz()(1),p.hz()(1)*p.hw()[0]), RT(p.hw()[0]*p.hy()[1])); else return Point_3(RT(p.hx()[0]*p.hy()[1]-p.hy()[0]*p.hx()(1),-p.hx()(1)*p.hw()[0]), RT(0,-p.hy()[1]*p.hw()[0]), RT(p.hz()[0]*p.hy()[1]-p.hy()[0]*p.hz()(1),-p.hz()(1)*p.hw()[0]), RT(p.hw()[0]*p.hy()[1])); case 2: CGAL_assertion(p.hz().degree() == 1); if(p.hz()[1] > 0) return Point_3(RT(p.hx()[0]*p.hz()[1]-p.hz()[0]*p.hx()(1),p.hx()(1)*p.hw()[0]), RT(p.hy()[0]*p.hz()[1]-p.hz()[0]*p.hy()(1),p.hy()(1)*p.hw()[0]), RT(0,p.hz()[1]*p.hw()[0]), RT(p.hw()[0]*p.hz()[1])); else return Point_3(RT(p.hx()[0]*p.hz()[1]-p.hz()[0]*p.hx()(1),-p.hx()(1)*p.hw()[0]), RT(p.hy()[0]*p.hz()[1]-p.hz()[0]*p.hy()(1),-p.hy()(1)*p.hw()[0]), RT(0,-p.hz()[1]*p.hw()[0]), RT(p.hw()[0]*p.hz()[1])); default: CGAL_assertion_msg(false, "wrong value"); } return Point_3(); } static typename std::list::const_iterator segment_on_side(int side_of_point, const std::list& segs) { typename std::list::const_iterator s1,t1; for(s1 = segs.begin(); s1 != segs.end(); ++s1) { t1 = s1; ++t1; if(t1 == segs.end()) t1 = segs.begin(); switch(side_of_point) { case 1: if( s1->hx()(1) != s1->hw()) continue; if( t1->hx()(1) != t1->hw()) continue; return s1; case -1: if(-s1->hx()(1) != s1->hw()) continue; if(-t1->hx()(1) != t1->hw()) continue; return s1; case 2: if( s1->hy()(1) != s1->hw()) continue; if( t1->hy()(1) != t1->hw()) continue; return s1; break; case -2: if(-s1->hy()(1) != s1->hw()) continue; if(-t1->hy()(1) != t1->hw()) continue; return s1; case 3: if( s1->hz()(1) != s1->hw()) continue; if( t1->hz()(1) != t1->hw()) continue; return s1; case -3: if(-s1->hz()(1) != s1->hw()) continue; if(-t1->hz()(1) != t1->hw()) continue; return s1; default: CGAL_assertion_msg(false, "wrong value"); } } CGAL_assertion_msg(false, "this line of shall not be reached"); return s1; } template static void initialize_infibox_vertices(SNC_constructor& C, bool space) { C.create_extended_box_corner( 1, 1, 1, space ); C.create_extended_box_corner(-1, 1, 1, space ); C.create_extended_box_corner( 1,-1, 1, space ); C.create_extended_box_corner(-1,-1, 1, space ); C.create_extended_box_corner( 1, 1,-1, space ); C.create_extended_box_corner(-1, 1,-1, space ); C.create_extended_box_corner( 1,-1,-1, space ); C.create_extended_box_corner(-1,-1,-1, space ); } /* template static bool is_edge_on_infibox(SHalfedge_handle e) { Point_3 p = e->center_vertex()->point(); if(is_standard(p)) return false; Vector_3 v(e->vector()); CGAL_assertion(p.hw().degree() == 0); FT Outer(RT(0,1)); if(CGAL_NTS abs(p.x()) == Outer && ((p.x() > 0 && v.x() > 0)||(p.x() < 0 && v.x() < 0))) return false; if(CGAL_NTS abs(p.y()) == Outer && ((p.y() > 0 && v.y() > 0)||(p.y() < 0 && v.y() < 0))) return false; if(CGAL_NTS abs(p.z()) == Outer && ((p.z() > 0 && v.z() > 0)||(p.z() < 0 && v.z() < 0))) return false; if(CGAL_NTS abs(p.x()) == Outer && v.x() == 0) return true; if(CGAL_NTS abs(p.y()) == Outer && v.y() == 0) return true; if(CGAL_NTS abs(p.z()) == Outer && v.z() == 0) return true; return false; } */ template static bool is_edge_on_infibox(SHalfedge_handle e) { Point_3 p = e->center_vertex()->point(); if(is_standard(p)) return false; Vector_3 v(e->vector()); CGAL_assertion(p.hw().degree() == 0); RT Outer(0,CGAL_NTS abs(p.hw()[0])); if(CGAL_NTS abs(p.hx()) == Outer && ((p.hx() > 0 && v.hx() > 0)||(p.hx() < 0 && v.hx() < 0))) return false; if(CGAL_NTS abs(p.hy()) == Outer && ((p.hy() > 0 && v.hy() > 0)||(p.hy() < 0 && v.hy() < 0))) return false; if(CGAL_NTS abs(p.hz()) == Outer && ((p.hz() > 0 && v.hz() > 0)||(p.hz() < 0 && v.hz() < 0))) return false; if(CGAL_NTS abs(p.hx()) == Outer && v.hx() == 0) return true; if(CGAL_NTS abs(p.hy()) == Outer && v.hy() == 0) return true; if(CGAL_NTS abs(p.hz()) == Outer && v.hz() == 0) return true; return false; } template static bool is_sedge_on_infibox(SHalfedge_handle sh) { Point_3 p = sh->source()->center_vertex()->point(); CGAL_NEF_TRACEN("Point " << p); if(is_standard(p)) return false; CGAL_NEF_TRACEN("Circle " << sh->circle() << " has signum " << sign_of(sh->circle())); CGAL_assertion(p.hw().degree() == 0); RT R(0,CGAL_NTS abs(p.hw()[0])); if((sh->circle().a() == 0 && sh->circle().b() == 0 && CGAL_NTS abs(p.hz())== R) || (sh->circle().a() == 0 && sh->circle().c() == 0 && CGAL_NTS abs(p.hy())== R) || (sh->circle().b() == 0 && sh->circle().c() == 0 && CGAL_NTS abs(p.hx())== R)) if(is_edge_on_infibox(sh->source()) && is_edge_on_infibox(sh->twin()->source())) return true; return false; } template static bool is_complex_facet_infibox_intersection(const Sphere_map& sm) { typename Sphere_map::SHalfedge_const_iterator sei; bool found = false; CGAL_forall_sedges(sei, sm) { if(!is_sedge_on_infibox(sei)) if(found) return true; else found = true; } return false; } template static std::list find_points_of_box_with_plane(SNC_constructor& C, const Plane_3& h) { return C.find_points_of_box_with_plane(h); } template static bool is_type4(Halfedge_handle e) { Point_3 p(e->center_vertex()->point()); Direction_3 d(e->vector()); if((CGAL_NTS abs(p.hx()) == CGAL_NTS abs(p.hw()) || d == Direction_3(1,0,0) || d == Direction_3(-1,0,0)) && (CGAL_NTS abs(p.hy()) == CGAL_NTS abs(p.hw()) || d == Direction_3(0,1,0) || d == Direction_3(0,-1,0)) && (CGAL_NTS abs(p.hz()) == CGAL_NTS abs(p.hw()) || d == Direction_3(0,0,1) || d == Direction_3(0,0,-1))) return true; return false; } template static bool is_type3(Halfedge_handle e) { Point_3 p(e->center_vertex()->point()); Direction_3 d(e->vector()); if(d == Direction_3(1,0,0) || d == Direction_3(-1,0,0)) { if(CGAL_NTS abs(p.hy()) == CGAL_NTS abs(p.hw())) return true; return false; } if(d == Direction_3(0,1,0) || d == Direction_3(0,-1,0)) { if(CGAL_NTS abs(p.hx()) == CGAL_NTS abs(p.hw())) return true; return false; } if(d == Direction_3(0,0,1) || d == Direction_3(0,0,-1)) { if(CGAL_NTS abs(p.hy()) == CGAL_NTS abs(p.hw())) return true; return false; } return false; } }; CGAL_END_NAMESPACE #endif // CGAL_INFIMAXIMAL_BOX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_list.h0000644000175000017500000007616711344301501027623 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_SNC_LIST_H #define CGAL_SNC_LIST_H #include #include CGAL_BEGIN_NAMESPACE template < class Sphere_map> class SNC_in_place_list_sm : public Sphere_map, public In_place_list_base > { public: typedef SNC_in_place_list_sm Self; // typedef typename Vertex::Vertex_handle Vertex_handle; // typedef typename Vertex::Vertex_const_handle Vertex_const_handle; SNC_in_place_list_sm() {} SNC_in_place_list_sm(const Sphere_map& sm) // down cast : Sphere_map(sm) {} Self& operator=( const Self& sm) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((Sphere_map*)this) = ((const Sphere_map&)sm); return *this; } }; template < class Halffacet> class SNC_in_place_list_halffacet : public Halffacet, public In_place_list_base > { public: typedef SNC_in_place_list_halffacet Self; // typedef typename Halffacet::Halffacet_handle Halffacet_handle; // typedef typename Halffacet::Halffacet_const_handle Halffacet_const_handle; SNC_in_place_list_halffacet() {} SNC_in_place_list_halffacet(const Halffacet& v) // down cast : Halffacet(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((Halffacet*)this) = ((const Halffacet&)v); return *this; } }; template < class Volume> class SNC_in_place_list_volume : public Volume, public In_place_list_base > { public: typedef SNC_in_place_list_volume Self; // typedef typename Volume::Volume_handle Volume_handle; // typedef typename Volume::Volume_const_handle Volume_const_handle; SNC_in_place_list_volume() {} SNC_in_place_list_volume(const Volume& v) // down cast : Volume(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((Volume*)this) = ((const Volume&)v); return *this; } }; template < class SHalfloop> class SNC_in_place_list_shalfloop : public SHalfloop, public In_place_list_base > { public: typedef SNC_in_place_list_shalfloop Self; // typedef typename SHalfloop::SHalfloop_handle SHalfloop_handle; // typedef typename SHalfloop::SHalfloop_const_handle SHalfloop_const_handle; SNC_in_place_list_shalfloop() {} SNC_in_place_list_shalfloop(const SHalfloop& v) // down cast : SHalfloop(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((SHalfloop*)this) = ((const SHalfloop&)v); return *this; } }; /* template class SNC_sphere_map; template class SM_decorator; template class SNC_list : public SM_list,Items_> { public: typedef Kernel_ Kernel; typedef Items_ Items; typedef CGAL::Sphere_geometry Sphere_kernel; typedef CGAL::SNC_list Self; typedef CGAL::SM_list Base; typedef CGAL::SNC_sphere_map Sphere_map; typedef CGAL::SM_decorator SM_decorator; typedef typename Base::Mark Mark; typedef typename Base::Size_type Size_type; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Vector_3 Vector_3; typedef typename Kernel::Direction_3 Direction_3; typedef typename Kernel::Segment_3 Segment_3; typedef typename Kernel::Line_3 Line_3; typedef typename Kernel::Ray_3 Ray_3; typedef typename Kernel::Triangle_3 Triangle_3; typedef typename Kernel::Aff_transformation_3 Aff_transformation_3; typedef typename Sphere_kernel::Sphere_point Sphere_point; typedef typename Sphere_kernel::Sphere_segment Sphere_segment; typedef typename Sphere_kernel::Sphere_circle Sphere_circle; typedef typename Sphere_kernel::Sphere_direction Sphere_direction; typedef Sphere_map Vertex_base; typedef SNC_in_place_list_sm Vertex; typedef CGAL::In_place_list Vertex_list; typedef CGAL_ALLOCATOR(Vertex) Vertex_alloc; typedef typename Vertex_list::iterator Vertex_handle; typedef typename Vertex_list::const_iterator Vertex_const_handle; typedef typename Vertex_list::iterator Vertex_iterator; typedef typename Vertex_list::const_iterator Vertex_const_iterator; typedef typename Items::template Halffacet Halffacet_base; typedef SNC_in_place_list_halffacet Halffacet; typedef CGAL::In_place_list Halffacet_list; typedef CGAL_ALLOCATOR(Halffacet) Halffacet_alloc; typedef typename Halffacet_list::iterator Halffacet_handle; typedef typename Halffacet_list::const_iterator Halffacet_const_handle; typedef typename Halffacet_list::iterator Halffacet_iterator; typedef typename Halffacet_list::const_iterator Halffacet_const_iterator; typedef typename Items::template Volume Volume_base; typedef SNC_in_place_list_volume Volume; typedef CGAL::In_place_list Volume_list; typedef CGAL_ALLOCATOR(Volume) Volume_alloc; typedef typename Volume_list::iterator Volume_handle; typedef typename Volume_list::const_iterator Volume_const_handle; typedef typename Volume_list::iterator Volume_iterator; typedef typename Volume_list::const_iterator Volume_const_iterator; typedef typename Items::template SVertex SVertex_base; typedef SNC_in_place_list_svertex SVertex; typedef CGAL::In_place_list SVertex_list; typedef CGAL_ALLOCATOR(SVertex) SVertex_alloc; typedef typename SVertex_list::iterator SVertex_handle; typedef typename SVertex_list::const_iterator SVertex_const_handle; typedef typename SVertex_list::iterator SVertex_iterator; typedef typename SVertex_list::const_iterator SVertex_const_iterator; typedef typename Items::template SVertex Halfedge_base; typedef SNC_in_place_list_svertex Halfedge; typedef CGAL::In_place_list Halfedge_list; typedef CGAL_ALLOCATOR(SVertex) Halfedge_alloc; typedef typename SVertex_list::iterator Halfedge_handle; typedef typename SVertex_list::const_iterator Halfedge_const_handle; typedef typename SVertex_list::iterator Halfedge_iterator; typedef typename SVertex_list::const_iterator Halfedge_const_iterator; typedef typename Items::template SHalfedge SHalfedge_base; typedef SNC_in_place_list_shalfedge SHalfedge; typedef CGAL::In_place_list SHalfedge_list; typedef CGAL_ALLOCATOR(SHalfedge) SHalfedge_alloc; typedef typename SHalfedge_list::iterator SHalfedge_handle; typedef typename SHalfedge_list::const_iterator SHalfedge_const_handle; typedef typename SHalfedge_list::iterator SHalfedge_iterator; typedef typename SHalfedge_list::const_iterator SHalfedge_const_iterator; typedef typename Items::template SHalfloop SHalfloop_base; typedef SNC_in_place_list_shalfloop SHalfloop; typedef CGAL::In_place_list SHalfloop_list; typedef CGAL_ALLOCATOR(SHalfloop) SHalfloop_alloc; typedef typename SHalfloop_list::iterator SHalfloop_handle; typedef typename SHalfloop_list::const_iterator SHalfloop_const_handle; typedef typename SHalfloop_list::iterator SHalfloop_iterator; typedef typename SHalfloop_list::const_iterator SHalfloop_const_iterator; typedef typename Items::template SFace SFace_base; typedef SNC_in_place_list_sface SFace; typedef CGAL::In_place_list SFace_list; typedef CGAL_ALLOCATOR(SFace) SFace_alloc; typedef typename SFace_list::iterator SFace_handle; typedef typename SFace_list::const_iterator SFace_const_handle; typedef typename SFace_list::iterator SFace_iterator; typedef typename SFace_list::const_iterator SFace_const_iterator; typedef typename Base::SVertex Halfedge; typedef typename Base::SVertex_handle Halfedge_handle; typedef typename Base::SVertex_iterator Halfedge_iterator; typedef typename Base::SVertex_const_handle Halfedge_const_handle; typedef typename Base::SVertex_const_iterator Halfedge_const_iterator; typedef typename Base::SVertex SVertex; typedef typename Base::SVertex_handle SVertex_handle; typedef typename Base::SVertex_iterator SVertex_iterator; typedef typename Base::SVertex_const_handle SVertex_const_handle; typedef typename Base::SVertex_const_iterator SVertex_const_iterator; typedef typename Base::SHalfedge SHalfedge; typedef typename Base::SHalfedge_handle SHalfedge_handle; typedef typename Base::SHalfedge_iterator SHalfedge_iterator; typedef typename Base::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Base::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Base::SFace SFace; typedef typename Base::SFace_handle SFace_handle; typedef typename Base::SFace_iterator SFace_iterator; typedef typename Base::SFace_const_handle SFace_const_handle; typedef typename Base::SFace_const_iterator SFace_const_iterator; typedef typename Base::SHalfloop SHalfloop; typedef typename Base::SHalfloop_handle SHalfloop_handle; typedef typename Base::SHalfloop_iterator SHalfloop_iterator; typedef typename Base::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Base::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename Base::Object_handle Object_handle; typedef typename Base::Object_list Object_list; typedef typename Base::Object_iterator Object_iterator; typedef typename Base::Object_const_iterator Object_const_iterator; typedef typename Base::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Base::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Base::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; typedef typename Base::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_const_circulator; typedef typename Base::SFace_cycle_iterator SFace_cycle_iterator; typedef typename Base::SFace_cycle_const_iterator SFace_cycle_const_iterator; typedef CircFromIt > SHalfedge_around_facet_const_circulator; typedef CircFromIt > SHalfedge_around_facet_circulator; class Halffacet_cycle_iterator : public Object_iterator { typedef Object_iterator Ibase; public: Halffacet_cycle_iterator() : Ibase() {} Halffacet_cycle_iterator(const Ibase& b) : Ibase(b) {} Halffacet_cycle_iterator(const Halffacet_cycle_iterator& i) : Ibase(i) {} bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SHalfedge_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return e; } operator SHalfloop_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return l; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_assertion_msg(0,"not impl."); } }; class Halffacet_cycle_const_iterator : public Object_const_iterator { typedef Object_const_iterator Ibase; public: Halffacet_cycle_const_iterator() : Ibase() {} Halffacet_cycle_const_iterator(const Ibase& b) : Ibase(b) {} Halffacet_cycle_const_iterator(const Halffacet_cycle_const_iterator& i) : Ibase(i) {} bool is_shalfedge() const { SHalfedge_handle e; return CGAL::assign(e,Ibase::operator*()); } bool is_shalfloop() const { SHalfloop_handle l; return CGAL::assign(l,Ibase::operator*()); } operator SHalfedge_const_handle() const { SHalfedge_handle e; CGAL::assign(e,Ibase::operator*()); return SHalfedge_const_handle(e); } operator SHalfloop_const_handle() const { SHalfloop_handle l; CGAL::assign(l,Ibase::operator*()); return SHalfloop_const_handle(l); } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_assertion_msg(0,"not impl."); } }; class Shell_entry_iterator : public Object_iterator { typedef Object_iterator Ibase; public: Shell_entry_iterator() : Ibase() {} Shell_entry_iterator(const Ibase& b) : Ibase(b) {} Shell_entry_iterator(const Shell_entry_iterator& i) : Ibase(i) {} operator SFace_handle() const { SFace_handle f; CGAL_assertion( CGAL::assign(f,Ibase::operator*()) ); CGAL::assign(f,Ibase::operator*()); return f; } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_nef_assertion_msg(0,"not impl."); } }; class Shell_entry_const_iterator : public Object_const_iterator { typedef Object_const_iterator Ibase; public: Shell_entry_const_iterator() : Ibase() {} Shell_entry_const_iterator(const Ibase& b) : Ibase(b) {} Shell_entry_const_iterator(const Shell_entry_const_iterator& i) : Ibase(i) {} operator SFace_const_handle() const { SFace_handle f; CGAL_assertion( CGAL::assign(f,Ibase::operator*()) ); CGAL::assign(f,Ibase::operator*()); return SFace_const_handle(f); } operator Object_handle() const { return Ibase::operator*(); } Object_handle& operator*() const { return Ibase::operator*(); } Object_handle operator->() const { CGAL_nef_assertion_msg(0,"not impl."); } }; private: Vertex_alloc vertex_allocator; Vertex* get_vertex_node( const Vertex& t) { Vertex* p = vertex_allocator.allocate(1); vertex_allocator.construct( p, Vertex()); return p; } void put_vertex_node( Vertex* p) { vertex_allocator.destroy(p); vertex_allocator.deallocate( p, 1); } Halffacet_alloc halffacet_allocator; Halffacet* get_halffacet_node( const Halffacet& t) { Halffacet* p = halffacet_allocator.allocate(1); halffacet_allocator.construct( p, Halffacet()); return p; } void put_halffacet_node( Halffacet* p) { halffacet_allocator.destroy(p); halffacet_allocator.deallocate( p, 1); } Volume_alloc volume_allocator; Volume* get_volume_node( const Volume& t) { Volume* p = volume_allocator.allocate(1); volume_allocator.construct( p, Volume()); return p; } void put_volume_node( Volume* p) { volume_allocator.destroy(p); volume_allocator.deallocate( p, 1); } public: SNC_list() : boundary_item_(undef_), vertices_(), halffacets_(), volumes_() {} ~SNC_list() { clear(); } SNC_list(const Self& D) : boundary_item_(undef_), vertices_(D.vertices_), halffacets_(D.halffacets_), volumes_(D.volumes_) { pointer_update(D); } Self& operator=(const Self& D) { if ( this == &D ) return *this; clear(); boundary_item_.clear(undef_); vertices_ = D.vertices_; halffacets_ = D.halffacets_; volumes_ = D.volumes_; pointer_update(D); return *this; } void clear() { Base::clear(); boundary_item_.clear(); vertices_.destroy(); halffacets_.destroy(); volumes_.destroy(); } Vertex_const_iterator vertices_begin() const {return vertices_.begin();} Vertex_const_iterator vertices_end() const {return vertices_.end();} Halfedge_const_iterator halfedges_begin() const {return svertices_.begin();} Halfedge_const_iterator halfedges_end() const {return svertices_.end();} Halffacet_const_iterator halffacets_begin() const {return halffacets_.begin();} Halffacet_const_iterator halffacets_end() const {return halffacets_.end();} Volume_const_iterator volumes_begin() const {return volumes_.begin();} Volume_const_iterator volumes_end() const {return volumes_.end();} Vertex_iterator vertices_begin() { return vertices_.begin();} Vertex_iterator vertices_end() { return vertices_.end();} Halfedge_iterator halfedges_begin() { return halfedges_.begin();} Halfedge_iterator halfedges_end() { return halfedges_.end();} Halffacet_iterator halffacets_begin() { return halffacets_.begin();} Halffacet_iterator halffacets_end() { return halffacets_.end();} Volume_iterator volumes_begin() { return volumes_.begin();} Volume_iterator volumes_end() { return volumes_.end();} Size_type number_of_vertices() const { return vertices_.size(); } Size_type number_of_halfedges() const { return svertices_.size(); } Size_type number_of_edges() const { return svertices_.size()/2; } Size_type number_of_halffacets() const { return halffacets_.size();} Size_type number_of_facets() const { return halffacets_.size()/2;} Size_type number_of_volumes() const { return volumes_.size();} template bool is_boundary_object(H h) { return boundary_item_[h]!=undef_; } template Object_iterator& boundary_item(H h) { return boundary_item_[h]; } template void store_boundary_item(H h, Object_iterator o) { boundary_item_[h] = o; } template void undef_boundary_item(H h) { CGAL_assertion(boundary_item_[h]!=undef_); boundary_item_[h] = undef_; } void reset_iterator_hash(Object_iterator it) { SVertex_handle sv; SHalfedge_handle se; SHalfloop_handle sl; if ( CGAL::assign(se,*it) ) { if( is_boundary_object(se)) undef_boundary_item(se); return; } if ( CGAL::assign(sl,*it) ) { if( is_boundary_object(sl)) undef_boundary_item(sl); return; } if ( CGAL::assign(sv,*it) ) { if( is_boundary_object(sv)) undef_boundary_item(sv); return; } } void reset_object_list(Object_list& L) { Object_iterator oit; CGAL_forall_iterators(oit,L) reset_iterator_hash(oit); L.clear(); } Vertex_handle new_vertex(const Point_3& p = Point_3(), Mark m = Mark()) { Vertex_handle vh = new_vertex_only(); vh->point() = p; vh->mark() = m; vh->sncp() = this; vh->svertices_begin() = vh->svertices_last() = svertices_end(); vh->shalfedges_begin() = vh->shalfedges_last() = shalfedges_end(); vh->sfaces_begin() = vh->sfaces_last() = sfaces_end(); vh->shalfloop() = shalfloops_end(); return vh; } Halfedge_handle new_halfedge_pair(Vertex_handle v1, Vertex_handle v2, Mark m = Mark()) { SM_decorator D1(&*v1); SM_decorator D2(&*v2); SVertex_handle e1 = D1.new_vertex(); SVertex_handle e2 = D2.new_vertex(); make_twins(e1,e2); e1->mark() = m; return e1; } Halffacet_handle new_halffacet_pair(const Plane_3& h = Plane_3(), Mark m = Mark()) { Halffacet_handle f1 = new_halffacet_only(); Halffacet_handle f2 = new_halffacet_only(); f1->supporting_plane_ = h; f2->supporting_plane_ = h.opposite(); make_twins(f1,f2); f1->mark() = f2->mark() = m; return f1; } Volume_handle new_volume(Mark m = Mark()) { Volume_handle vh = new_volume_only(); vh->mark() = m; return vh; } void delete_vertex(Vertex_handle v) CGAL_NEF_TRACEN("~ deleting vertex "<<&*v<<" from "<<&*this); v->clear(true); delete_vertex_only(v); CGAL_NEF_TRACEN("~~ vertex deleted"<<&*v); } void delete_halfedge_pair(Halfedge_handle e) CGAL_NEF_TRACEN("~ deleting halfedges pair "<<&*e<<", "<<&*(e->twin())<< " from "<<&*this); Halfedge_handle et = e->twin(); SM_decorator D1(&*e->center_vertex()), D2(&*et->center_vertex()); D1.delete_vertex(e); D2.delete_vertex(et); } void delete_halffacet_pair(Halffacet_handle f) CGAL_NEF_TRACEN("~ deleting halffacets pair "<<&*f<<", "<<&*(f->twin())<< " from "<<&*this); reset_object_list(f->boundary_entry_objects()); reset_object_list(f->twin()->boundary_entry_objects()); delete_halffacet_only(f->twin()); delete_halffacet_only(f); } void delete_volume(Volume_handle c) CGAL_NEF_TRACEN("~ deleting volume "<<&*c<<" from "<<&*this); reset_object_list(c->shell_entry_objects()); delete_volume_only(c); } Vertex_handle new_vertex_only() { vertices_.push_back(* get_vertex_node(Vertex())); CGAL_NEF_TRACEN(" new vertex only "<<&*(--vertices_end())); return --vertices_end(); } Halfedge_handle new_halfedge_only(Halfedge_handle e) { Halfedge_handle ne = halfedges_.insert(e, * get_halfedge_node(Halfedge())); CGAL_NEF_TRACEN(" after "<<&*e<<" new halfedge only "<<&*ne); return ne; } Halfedge_handle new_halfedge_only() { CGAL_NEF_TRACEN(" new halfedge only "<<&*(--halfedges_end())); halfedges_.push_back( * get_halfedge_node(Halfedge())); return --halfedges_end(); } Halffacet_handle new_halffacet_only() { halffacets_.push_back( * get_halffacet_node(Halffacet())); CGAL_NEF_TRACEN(" new halffacet only "<<&*(--halffacets_end())); return --halffacets_end(); } Volume_handle new_volume_only() { volumes_.push_back( * get_volume_node(Volume())); CGAL_NEF_TRACEN(" new volume only "<<&*(--volumes_end())); return --volumes_end(); } SHalfedge_handle new_shalfedge_only() { shalfedges_.push_back( * get_shalfedge_node(SHalfedge())); CGAL_NEF_TRACEN(" new shalfedge only "<<&*(--shalfedges_end())); return --shalfedges_end(); } SHalfloop_handle new_shalfloop_only() { shalfloops_.push_back( * get_shalfloop_node(SHalfloop())); CGAL_NEF_TRACEN(" new shalfloop only "<<&*(--shalfloops_end())); return --shalfloops_end(); } SFace_handle new_sface_only() { sfaces_.push_back( * get_sface_node(SFace())); CGAL_NEF_TRACEN(" new sface only "<<&*(--sfaces_end())); return --sfaces_end(); } void delete_vertex_only(Vertex_handle h) { CGAL_NEF_TRACEN("~ deleting vertex only "<<&*h<<" from "<<&*this); vertices_.erase(h); put_vertex_node(&*h); } void delete_halfedge_only(Halfedge_handle h) { CGAL_NEF_TRACEN("~ deleting halfedge only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_sm_boundary_object(h)); halfedges_.erase(h); put_halfedge_node(&*h); } void delete_halffacet_only(Halffacet_handle h) { CGAL_NEF_TRACEN("~ deleting halffacet only "<<&*h<<" from "<<&*this); halffacets_.erase(h); put_halffacet_node(&*h); } void delete_volume_only(Volume_handle h) { CGAL_NEF_TRACEN("~ deleting volume only "<<&*h<<" from "<<&*this); volumes_.erase(h); put_volume_node(&*h); } void delete_shalfedge_only(SHalfedge_handle h) { CGAL_NEF_TRACEN("~ deleting shalfedge only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_sm_boundary_object(h)); shalfedges_.erase(h); put_shalfedge_node(&*h); } void delete_shalfloop_only(SHalfloop_handle h) { CGAL_NEF_TRACEN("~ deleting shalfloop only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_sm_boundary_object(h)); shalfloops_.erase(h); put_shalfloop_node(&*h); } void delete_sface_only(SFace_handle h) { CGAL_NEF_TRACEN("~ deleting sface only "<<&*h<<" from "<<&*this); CGAL_assertion(!is_boundary_object(h)); sfaces_.erase(h); put_sface_node(&*h); } protected: Generic_handle_map boundary_item_; Vertex_list vertices_; Halffacet_list halffacets_; Volume_list volumes_; void pointer_update(const Self& D); }; template void SNC_list:: pointer_update(const SNC_list& D) { CGAL::Unique_hash_map VM; CGAL::Unique_hash_map EM; CGAL::Unique_hash_map FM; CGAL::Unique_hash_map CM; CGAL::Unique_hash_map SEM; CGAL::Unique_hash_map SLM; CGAL::Unique_hash_map SFM; Vertex_const_iterator vc = D.vertices_begin(); Vertex_iterator v = vertices_begin(); for ( ; vc != D.vertices_end(); ++vc,++v) VM[vc] = v; VM[D.vertices_end()] = vertices_end(); Halfedge_const_iterator ec = D.halfedges_begin(); Halfedge_iterator e = halfedges_begin(); for ( ; ec != D.halfedges_end(); ++ec,++e) EM[ec] = e; EM[D.halfedges_end()] = halfedges_end(); Halffacet_const_iterator fc = D.halffacets_begin(); Halffacet_iterator f = halffacets_begin(); for ( ; fc != D.halffacets_end(); ++fc,++f) FM[fc] = f; FM[D.halffacets_end()] = halffacets_end(); Volume_const_iterator cc = D.volumes_begin(); Volume_iterator c = volumes_begin(); for ( ; cc != D.volumes_end(); ++cc,++c) CM[cc] = c; CM[D.volumes_end()] = volumes_end(); SHalfedge_const_iterator sec = D.shalfedges_begin(); SHalfedge_iterator se = shalfedges_begin(); for ( ; sec != D.shalfedges_end(); ++sec,++se) SEM[sec] = se; SEM[D.shalfedges_end()] = shalfedges_end(); SHalfloop_const_iterator slc = D.shalfloops_begin(); SHalfloop_iterator sl = shalfloops_begin(); for ( ; slc != D.shalfloops_end(); ++slc,++sl) SLM[slc] = sl; SLM[D.shalfloops_end()] = shalfloops_end(); SFace_const_iterator sfc = D.sfaces_begin(); SFace_iterator sf = sfaces_begin(); for ( ; sfc != D.sfaces_end(); ++sfc,++sf) SFM[sfc] = sf; SFM[D.sfaces_end()] = sfaces_end(); CGAL_forall_vertices(v,*this) { // Local Graph update: (SVertices are postponed/updated as Edges) v->sncp() = this; v->svertices_begin() = EM[v->svertices_begin()]; v->svertices_last() = EM[v->svertices_last()]; v->shalfedges_begin() = SEM[v->shalfedges_begin()]; v->shalfedges_last() = SEM[v->shalfedges_last()]; v->sfaces_begin() = SFM[v->sfaces_begin()]; v->sfaces_last() = SFM[v->sfaces_last()]; v->shalfloop() = SLM[v->shalfloop()]; } // Halfedge update: CGAL_forall_halfedges(e,*this) { e->center_vertex() = VM[e->center_vertex()]; e->twin() = EM[e->twin()]; e->out_sedge() = SEM[e->out_sedge()]; e->incident_sface() = SFM[e->incident_sface()]; } // Halffacet update CGAL_forall_halffacets(f,*this) { f->twin() = FM[f->twin()]; f->volume_ = CM[f->volume_]; Halffacet_cycle_iterator ftc; for(ftc = f->boundary_entry_objects().begin(); ftc != f->boundary_entry_objects().end(); ++ftc) { if ( assign( se, ftc) ) { *ftc = Object_handle(SEM[se]); store_boundary_item(se,ftc); } else if ( assign( sl, ftc) ) { *ftc = Object_handle(SLM[sl]); store_boundary_item(sl,ftc); } else CGAL_assertion_msg(0,"damn wrong boundary item in facet."); } } // Volume update CGAL_forall_volumes(c,*this) { Shell_entry_iterator sei; CGAL_forall_shells_of(sei,c) { sf = sei; // conversion from generic iterator to sface const handle *sei = Object_handle(SFM[sf]); store_boundary_item(sf,sei); } } CGAL_forall_shalfedges(se,*this) { se->source() = EM[se->source()]; se->sprev() = SEM[se->sprev()]; se->snext() = SEM[se->snext()]; se->incident_sface() = SFM[se->incident_sface()]; se->twin() = SEM[se->twin()]; se->prev() = SEM[se->prev()]; se->next() = SEM[se->next()]; se->incident_facet() = FM[se->incident_facet()]; } CGAL_forall_shalfloops(sl,*this) { sl->twin() = SLM[sl->twin()]; sl->incident_sface() = SFM[sl->incident_sface()]; sl->incident_facet() = FM[sl->incident_facet()]; } for ( slc = D.shalfloops_begin(), sl = shalfloops_begin(); slc != D.shalfloops_end(); ++slc, ++sl) { CGAL_assertion_code( if( slc->is_twin() == sl->is_twin()) CGAL_assertion( slc->mark() == sl->mark())); if( !sl->is_twin() && slc->is_twin()) sl->mark() = sl->twin()->mark(); } CGAL_forall_sfaces(sf,*this) { sf->center_vertex() = VM[sf->center_vertex()]; sf->incident_volume() = CM[sf->incident_volume()]; SFace_cycle_iterator sfc; for(sfc = sf->sface_cycles_begin(); sfc != sf->sface_cycles_end(); ++sfc) { SVertex_handle sv; if ( assign(sv,sfc) ) { *sfc = Object_handle(EM[sv]); store_sm_boundary_item(sv,sfc); } else if ( assign(se,sfc) ) { *sfc = Object_handle(SEM[se]); store_sm_boundary_item(se,sfc); } else if ( assign(sl,sfc) ) { *sfc = Object_handle(SLM[sl]); store_sm_boundary_item(sl,sfc); } else CGAL_assertion_msg(0,"damn wrong boundary item in sface."); } } } */ CGAL_END_NAMESPACE #endif // CGAL_SNC_LIST_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/polyhedron_3_to_nef_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/polyhedron_3_to_0000644000175000017500000002042111344301501031143 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/polyhedron_3_to_nef_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef POLYHEDRON_3_TO_NEF_3_H #define POLYHEDRON_3_TO_NEF_3_H #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 29 #include CGAL_BEGIN_NAMESPACE template < class Node, class Object> struct Project_vertex_point { typedef Node argument_type; typedef Object result_type; Object& operator()( Node& x) const { return x.vertex()->point();} const Object& operator()( const Node& x) const { return x.vertex()->point();} }; struct Facet_plane_3 { template < class Facet_> typename Facet_::Plane_3 operator()( Facet_& f) { typedef Facet_ Facet; typedef typename Facet::Plane_3 Plane; typedef Kernel_traits< Plane> KernelTraits; typedef typename KernelTraits::Kernel Kernel; typedef typename Kernel::Vector_3 Vector; typedef typename Facet::Halfedge_around_facet_const_circulator Halfedge_circulator; typedef typename Facet::Halfedge Halfedge; typedef typename Halfedge::Vertex Vertex; typedef typename Vertex::Point_3 Point; typedef Project_vertex_point< Halfedge, const Point> Proj_vertex_point; typedef Circulator_project< Halfedge_circulator, Proj_vertex_point, const Point, const Point*> Circulator; /* TODO: to implement a better approach typedef Project_vertex< Halfedge> Project_vertex; typedef Project_point< Vertex> Project_point; typedef Compose< Project_vertex, Project_point> Projector; typedef Circulator_project< Halfedge_circulator, Projector> Circulator; */ Circulator point_cir( f.facet_begin()); Vector plane_orthogonal_vector; normal_vector_newell_3( point_cir, point_cir, plane_orthogonal_vector); CGAL_NEF_TRACEN( *point_cir); CGAL_NEF_TRACEN(Plane( *point_cir, Vector( plane_orthogonal_vector))); return( Plane( *point_cir, Vector( plane_orthogonal_vector))); } }; template void polyhedron_3_to_nef_3(Polyhedron_& P, SNC_structure& S) { typedef Polyhedron_ Polyhedron; typedef typename SNC_structure::SNC_decorator SNC_decorator; typedef typename SNC_structure::SM_decorator SM_decorator; typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Sphere_point Sphere_point; typedef typename SNC_structure::Sphere_segment Sphere_segment; typedef typename SNC_structure::Sphere_circle Sphere_circle; typedef typename Polyhedron::Halfedge_around_vertex_const_circulator Halfedge_around_vertex_const_circulator; CGAL_NEF_TRACEN(" calculating facet's planes..."); std::transform( P.facets_begin(), P.facets_end(), P.planes_begin(), Facet_plane_3()); SNC_decorator D(S); // Progress_indicator_clog progress // ( P.size_of_vertices(), // "polyhedron_3_to_nef_3: constructing local view of vertices..."); typename Polyhedron::Vertex_iterator pvi; for( pvi = P.vertices_begin(); pvi != P.vertices_end(); ++pvi ) { // progress++; typename Polyhedron::Vertex pv = *pvi; Vertex_handle nv = S.new_vertex(); D.point(nv) = pv.point(); D.mark(nv) = true; CGAL_NEF_TRACEN("v "<opposite()->vertex()->point()); Point_3 sp_point_0(CGAL::ORIGIN+(pe_target_0-pv.point())); Sphere_point sp_0(sp_point_0); SVertex_handle sv_0 = SM.new_svertex(sp_0); SM.mark(sv_0) = true; pe++; CGAL_assertion(pe != pv.vertex_begin()); SVertex_handle sv_prev = sv_0; do { CGAL_assertion(!pe->is_border()); CGAL_assertion(pe_prev->face() == pe->opposite()->face()); CGAL_assertion(pe_prev->vertex()->point()==pv.point()); CGAL_assertion(pe->vertex()->point()==pv.point()); Point_3 pe_target = pe->opposite()->vertex()->point(); Point_3 sp_point = CGAL::ORIGIN+(pe_target-pv.point()); Sphere_point sp(sp_point); SVertex_handle sv = SM.new_svertex(sp); SM.mark(sv) = true; CGAL_NEF_TRACEN(pe_prev->facet()->plane()); CGAL_NEF_TRACEN(pe_target); CGAL_NEF_TRACEN(pe_prev->opposite()->vertex()->point()); CGAL_assertion(!pe_prev->facet()->plane().is_degenerate()); CGAL_assertion(pe_prev->facet()->plane(). has_on(pe_prev->opposite()->vertex()->point())); CGAL_assertion(pe_prev->facet()->plane().has_on(pe_target)); CGAL_assertion(pe_prev->facet()->plane().has_on(pv.point())); typename Polyhedron::Facet::Plane_3 ss_plane (CGAL::ORIGIN, pe_prev->facet()->plane().opposite().orthogonal_vector()); Sphere_circle ss_circle(ss_plane); CGAL_assertion(ss_circle.has_on(sp)); CGAL_assertion(ss_circle.has_on(SM.point(sv_prev))); SHalfedge_handle e = SM.new_shalfedge_pair(sv_prev, sv); SM.circle(e) = ss_circle; SM.circle(SM.twin(e)) = ss_circle.opposite(); SM.mark(e) = SM.mark(SM.twin(e)) = true; sv_prev = sv; pe_prev = pe; pe++; } while( pe != pv.vertex_begin() ); CGAL_assertion(!pe_0->is_border()); CGAL_assertion(pe_prev->face() == pe_0->opposite()->face()); CGAL_assertion(pe_prev->vertex()->point()==pv.point()); CGAL_assertion(pe_0->vertex()->point()==pv.point()); CGAL_NEF_TRACEN(pe_prev->facet()->plane()); CGAL_NEF_TRACEN(pe_target_0); CGAL_NEF_TRACEN(pe_prev->opposite()->vertex()->point()); CGAL_assertion(!pe_prev->facet()->plane().is_degenerate()); CGAL_assertion(pe_prev->facet()->plane(). has_on(pe_prev->opposite()->vertex()->point())); CGAL_assertion(pe_prev->facet()->plane().has_on(pe_target_0)); CGAL_assertion(pe_prev->facet()->plane().has_on(pv.point())); typename Polyhedron::Facet::Plane_3 ss_plane (CGAL::ORIGIN, pe_prev->facet()->plane().opposite().orthogonal_vector()); Sphere_circle ss_circle(ss_plane); CGAL_assertion(ss_plane.has_on(SM.point(sv_prev))); CGAL_assertion(ss_circle.has_on(sp_0)); CGAL_assertion(ss_circle.has_on(SM.point(sv_prev))); SHalfedge_handle e = SM.new_shalfedge_pair(sv_prev, sv_0); SM.circle(e) = ss_circle; SM.circle(SM.twin(e)) = ss_circle.opposite(); SM.mark(e) = SM.mark(SM.twin(e)) = true; // create faces SFace_handle fint = SM.new_sface(); SFace_handle fext = SM.new_sface(); SM.link_as_face_cycle(e, fint); SM.link_as_face_cycle(SM.twin(e), fext); // mark faces properly... SM.mark(fint) = true; SM.mark(fext) = false; SM.check_integrity_and_topological_planarity(); // SM_point_locator L(nv); // L.init_marks_of_halfspheres(); } } CGAL_END_NAMESPACE #endif //POLYHEDRON_3_TO_NEF_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/K3_tree.h0000644000175000017500000005775411344301501027442 0ustar debiandebian#line 15 "k3_tree.nw" // Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/K3_tree.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Miguel Granados #ifndef K3_TREE_H #define K3_TREE_H #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 503 #include CGAL_BEGIN_NAMESPACE template void sort_triangle_by_lexicographically_smaller_vertex (const Triangle_3& t, int& a, int& b, int& c) { typedef typename Triangle_3::R Kernel; a = 0; for( int i = 1; i < 3; ++i) { if( compare_xyz( t[a], t[i]) == SMALLER) a = i; } b = (a + 1) % 3; c = (b + 1) % 3; if( compare_xyz( t[b], t[c]) == LARGER) std::swap( b, c); return; } template struct Compare_triangle_3 { typedef typename Triangle_3::R Kernel; bool operator()( const Triangle_3& t1, const Triangle_3& t2) const { int v1[3], v2[3]; sort_triangle_by_lexicographically_smaller_vertex ( t1, v1[0], v1[1], v1[2]); sort_triangle_by_lexicographically_smaller_vertex ( t2, v2[0], v2[1], v2[2]); for( int i = 0; i < 3; ++i) { Comparison_result c = compare_xyz( t1[v1[i]], t2[v2[i]]); if( c == SMALLER) return true; else if( c == LARGER) return false; } return false; // the two triangles are equivalent } }; template class K3_tree { public: friend class Objects_along_ray; friend class Objects_around_segment; public: #line 302 "k3_tree.nw" typedef typename Traits::SNC_decorator SNC_decorator; typedef typename Traits::Infimaximal_box Infimaximal_box; typedef typename Traits::Vertex_handle Vertex_handle; typedef typename Traits::Halfedge_handle Halfedge_handle; typedef typename Traits::Halffacet_handle Halffacet_handle; typedef typename Traits::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename Traits::Object_handle Object_handle; typedef std::vector Object_list; typedef typename Object_list::const_iterator Object_const_iterator; typedef typename Object_list::iterator Object_iterator; typedef typename Object_list::size_type size_type; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Segment_3 Segment_3; typedef typename Traits::Ray_3 Ray_3; typedef typename Traits::Vector_3 Vector_3; typedef typename Traits::Plane_3 Plane_3; typedef typename Traits::Triangle_3 Triangle_3; typedef typename Traits::Aff_transformation_3 Aff_transformation_3; typedef typename Traits::Bounding_box_3 Bounding_box_3; typedef typename Traits::Side_of_plane Side_of_plane; typedef typename Traits::Objects_bbox Objects_bbox; typedef typename Traits::Kernel Kernel; typedef typename Kernel::RT RT; #line 486 "k3_tree.nw" class Node { friend class K3_tree; public: Node( Node* p, Node* l, Node* r, Plane_3 pl, const Object_list& O) : parent_node(p), left_node(l), right_node(r), splitting_plane(pl), object_list(O) {} bool is_leaf() const { CGAL_assertion( (left_node != 0 && right_node != 0) || (left_node == 0 && right_node == 0)); return (left_node == 0 && right_node == 0); } const Node* parent() const { return parent_node; } const Node* left() const { return left_node; } const Node* right() const { return right_node; } const Plane_3& plane() const { return splitting_plane; } const Object_list& objects() const { return object_list; } void transform(const Aff_transformation_3& t) { if(left_node != 0) { CGAL_assertion(right_node != 0); left_node->transform(t); right_node->transform(t); splitting_plane = splitting_plane.transform(t); } } #line 812 "k3_tree.nw" friend std::ostream& operator<< (std::ostream& os, const Node* node) { CGAL_assertion( node != 0); if( node->is_leaf()) os << node->objects().size(); else { os << " ( "; if( !node->left()) os << '-'; else os << node->left(); os << " , "; if( !node->right()) os << '-'; else os << node->right(); os << " ) "; } return os; } #line 512 "k3_tree.nw" #line 587 "k3_tree.nw" ~Node() { CGAL_NEF_TRACEN("~Node: deleting node..."); if( !is_leaf()) { delete left_node; delete right_node; } } #line 513 "k3_tree.nw" private: Node* parent_node; Node* left_node; Node* right_node; Plane_3 splitting_plane; Object_list object_list; }; #line 97 "k3_tree.nw" public: class Objects_around_segment { public: class Iterator; protected: Traits traits; Node *root_node; Segment_3 segment; bool initialized; public: Objects_around_segment() : initialized(false) {} Objects_around_segment( const K3_tree& k, const Segment_3& s) : root_node(k.root), segment(s), initialized(true) { CGAL_NEF_TRACEN("Objects_around_segment: input segment: "< Candidate; protected: std::deque S; const Node* node; Traits traits; CGAL_assertion_code( Segment_3 prev_segment); CGAL_assertion_code( bool first_segment); public: Iterator() : node(0) {} Iterator( const Node* root, const Segment_3& s) { CGAL_assertion_code( first_segment = true); S.push_front( Candidate( root, s)); ++(*this); // place the interator in the first intersected cell } Iterator( const Self& i) : S(i.S), node(i.node) {} const Object_list& operator*() const { CGAL_assertion( node != 0); return node->objects(); } Self& operator++() { #line 882 "k3_tree.nw" if( S.empty()) node = 0; // end of the iterator else { while( !S.empty()) { const Node* n = S.front().first; Segment_3 s = S.front().second; S.pop_front(); if( n->is_leaf()) { #ifndef NDEBUG CGAL_assertion_code( if( first_segment) { first_segment = false; CGAL_NEF_TRACEN("operator++: prev_segment=(none), segment="<plane() << ", point: "<plane().point()); Oriented_side src_side = n->plane().oriented_side(s.source()); Oriented_side tgt_side = n->plane().oriented_side(s.target()); if( src_side == ON_ORIENTED_BOUNDARY && tgt_side == ON_ORIENTED_BOUNDARY) src_side = tgt_side = ON_NEGATIVE_SIDE; else if( src_side == ON_ORIENTED_BOUNDARY) src_side = tgt_side; else if( tgt_side == ON_ORIENTED_BOUNDARY) tgt_side = src_side; if( src_side == tgt_side) S.push_front( Candidate( get_child_by_side( n, src_side), s)); else { Segment_3 s1, s2; divide_segment_by_plane( s, n->plane(), s1, s2); S.push_front( Candidate( get_child_by_side( n, tgt_side), s2)); // cell on target pushed first S.push_front( Candidate( get_child_by_side( n, src_side), s1)); } } } } #line 152 "k3_tree.nw" return *this; } bool operator==(const Self& i) const { return (node == i.node); } bool operator!=(const Self& i) const { return !(*this == i); } private: const Node* get_node() const { CGAL_assertion( node != 0); return node; } #line 743 "k3_tree.nw" inline const Node* get_child_by_side( const Node* node, Oriented_side side) { CGAL_assertion( node != NULL); CGAL_assertion( side != ON_ORIENTED_BOUNDARY); if( side == ON_NEGATIVE_SIDE) { return node->left(); } CGAL_assertion( side == ON_POSITIVE_SIDE); return node->right(); } void divide_segment_by_plane( Segment_3 s, Plane_3 pl, Segment_3& s1, Segment_3& s2) { Object o = traits.intersect_object()( pl, s); Point_3 ip; CGAL_assertion( CGAL::assign( ip, o)); CGAL::assign( ip, o); ip = normalized(ip); s1 = Segment_3( s.source(), ip); s2 = Segment_3( ip, s.target()); CGAL_assertion( s1.target() == s2.source()); CGAL_assertion( s1.direction() == s.direction()); CGAL_assertion( s2.direction() == s.direction()); } #line 166 "k3_tree.nw" }; }; class Objects_along_ray : public Objects_around_segment { typedef Objects_around_segment Base; protected: Traits traits; public: Objects_along_ray( const K3_tree& k, const Ray_3& r) { CGAL_NEF_TRACEN("Objects_along_ray: input ray: "< // ( b.xmin(), b.ymin(), b.zmin()); Point_3 pt_on_minus_x_plane(b.get_min()); // We compute the intersection between a plane with normal vector in the minus x direction and located at the minimum point of the bounding box, and the input ray. When the ray does not intersect the bounding volume, there won't be any object hit, so it is safe to construct a segment that simply lay in the unbounded side of the bounding box. This approach is taken instead of somehow (efficiently) report that there was no hit object, in order to mantain a clear interface with the Iterator class. Plane_3 pl_on_minus_x( pt_on_minus_x_plane, Vector_3( -1, 0, 0)); Object o = traits.intersect_object()( pl_on_minus_x, r); if( !CGAL::assign( q, o) || pl_on_minus_x.has_on(p)) q = r.source() + Vector_3( -1, 0, 0); else q = normalized(q); Base::initialize( k, Segment_3( p, q)); } }; private: Traits traits; Node* root; int max_depth; Bounding_box_3 bounding_box; public: K3_tree(Object_list& objects, Object_iterator& v_end) { #line 285 "k3_tree.nw" typename Object_list::difference_type n_vertices = std::distance(objects.begin(),v_end); CGAL_NEF_TRACEN("K3_tree(): n_vertices = " << std::distance(objects.begin(),v_end)); frexp( (double) n_vertices, &max_depth); #line 204 "k3_tree.nw" #line 293 "k3_tree.nw" // TODO: in the presence of a infimaximal bounding box, the bounding box does not have to be computed Objects_bbox objects_bbox = traits.objects_bbox_object(); bounding_box = objects_bbox(objects); //CGAL_NEF_TRACEN("bounding box:"< v_mark(false); Unique_hash_map< Halfedge_handle, bool> e_mark(false); Unique_hash_map< Halffacet_handle, bool> f_mark(false); std::map< Triangle_3, bool, Compare_triangle_3 > t_mark; for( typename Objects_around_segment::Iterator oar = objects.begin(); oar != objects.end(); ++oar) { for( typename Object_list::const_iterator o = (*oar).begin(); o != (*oar).end(); ++o) { // TODO: implement operator->(...) Vertex_handle v; Halfedge_handle e; Halffacet_handle f; if( CGAL::assign( v, *o)) { if( !v_mark[v]) { O.push_back(*o); v_mark[v] = true; } } else if( CGAL::assign( e, *o)) { if( !e_mark [e]) { O.push_back(*o); e_mark[e] = true; } } else if( CGAL::assign( f, *o)) { if( !f_mark[f]) { O.push_back(*o); f_mark[f] = true; } } else { Halffacet_triangle_handle t; if( CGAL::assign( t, *o)) { Triangle_3 tr = t.get_triangle(); if( !t_mark[tr]) { O.push_back(*o); t_mark[tr] = true; } } else CGAL_assertion_msg( 0, "wrong handle"); } } } #line 216 "k3_tree.nw" return O; } bool is_point_on_cell( const Point_3& p, const typename Objects_around_segment::Iterator& target) const { return is_point_on_cell( p, target.get_node(), root); } template class BBox_updater { SNCd D; Bounding_box_3 b; public: BBox_updater(const SNCd& sncd) : D(sncd), b(Point_3(0,0,0),Point_3(0,0,0)) {} void pre_visit(const Node* n) {} void post_visit(const Node* n) { typename Object_list::const_iterator o; for( o = n->objects().begin(); o != n->objects().end(); ++o) { Vertex_handle v; if( CGAL::assign( v, *o)) { Point_3 p(D.point(v)); b = b + Bounding_box_3(p,p); } } } Bounding_box_3 box() const{ return b; } }; template void visit_k3tree(const Node* current, Visitor& V) const { V.pre_visit(current); if(current->left() != 0) { visit_k3tree(current->left(), V); visit_k3tree(current->right(), V); } V.post_visit(current); } void transform(const Aff_transformation_3& t) { // TODO: Bounding box must be updated/transformed, too if(root != 0) root->transform(t); SNC_decorator D; BBox_updater bbup(D); visit_k3tree(root, bbup); bounding_box = bbup.box(); } #line 769 "k3_tree.nw" #ifdef CODE_DOES_NOT_WORK_WITH_BOTH_KERNELS_AT_THE_SAME_TIME template friend std::ostream& operator<< (std::ostream& os, const K3_tree& k3_tree) { os << (const Node*)k3_tree.root; // no default conversion to const Node*? return os; } #endif std::string dump_object_list( const Object_list& O, int level = 0) { std::stringstream os; typename Object_list::size_type v_count = 0, e_count = 0, f_count = 0, t_count = 0; typename Object_list::const_iterator o; for( o = O.begin(); o != O.end(); ++o) { SNC_decorator D; Vertex_handle v; Halfedge_handle e; Halffacet_handle f; if( CGAL::assign( v, *o)) { if( level) os << D.point(v) << std::endl; v_count++; } else if( CGAL::assign( e, *o)) { if( level) os << D.segment(e) << std::endl; e_count++; } else if( CGAL::assign( f, *o)) { if( level) os << "facet" << std::endl; f_count++; } else { Halffacet_triangle_handle t; if( CGAL::assign( t, *o)) { if( level) os << "triangle" << std::endl; t_count++; } else CGAL_assertion_msg( 0, "wrong handle"); } } os << v_count << "v " << e_count << "e " << f_count << "f " << t_count << "t "; return os.str(); } #line 270 "k3_tree.nw" #line 525 "k3_tree.nw" bool update( Unique_hash_map& V, Unique_hash_map& E, Unique_hash_map& F) { return update( root, V, E, F); } bool update( Node* node, Unique_hash_map& V, Unique_hash_map& E, Unique_hash_map& F) { CGAL_assertion( node != 0); if( node->is_leaf()) { bool updated = false; Object_list* O = &node->object_list; typename Object_list::iterator onext, o = O->begin(); while( o != O->end()) { onext = o; onext++; Vertex_handle v; Halfedge_handle e; Halffacet_handle f; if( CGAL::assign( v, *o)) { if( !V[v]) { O->erase(o); updated = true; } } else if( CGAL::assign( e, *o)) { if( !E[e]) { O->erase(o); updated = true; } } else if( CGAL::assign( f, *o)) { if( !F[f]) { O->erase(o); updated = true; } } else CGAL_assertion_msg( 0, "wrong handle"); o = onext; } return updated; } // TODO: protect the code below from optimizations! bool left_updated = update( node->left_node, V, E, F); CGAL_NEF_TRACEN("k3_tree::update(): left node updated? "<right_node, V, E, F); CGAL_NEF_TRACEN("k3_tree::update(): right node updated? "< Node* build_kdtree(Object_list& O, Object_iterator v_end, Depth depth, Node* parent=0, int non_efective_splits=0) { CGAL_precondition( depth >= 0); CGAL_NEF_TRACEN( "build_kdtree: "<point()[depth%3] == vx->point()[depth%3]) O2.push_back(*oi); } O1.push_back(*median); O2.push_back(*median); for(Object_iterator oi=median+1;oi!=v_end;++oi) { O2.push_back(*oi); CGAL::assign(vx,*oi); if(vm->point()[depth%3] == vx->point()[depth%3]) O1.push_back(*oi); } typename Object_list::size_type v_end1 = O1.size(); typename Object_list::size_type v_end2 = O2.size(); bool splitted = classify_objects( v_end, O.end(), partition_plane, depth, std::back_inserter(O1), std::back_inserter(O2)); if( !splitted) { CGAL_NEF_TRACEN("build_kdtree: splitting plane not found"); return new Node( parent, 0, 0, Plane_3(), O); } CGAL_assertion( O1.size() <= O.size() && O2.size() <= O.size()); CGAL_assertion( O1.size() + O2.size() >= O.size()); bool non_efective_split = ((O1.size() == O.size()) || (O2.size() == O.size())); if( non_efective_split) non_efective_splits++; else non_efective_splits = 0; if( non_efective_splits > 2) { CGAL_NEF_TRACEN("build_kdtree: non efective splits reached maximum"); return new Node( parent, 0, 0, Plane_3(), O); } Node *node = new Node( parent, 0, 0, partition_plane, Object_list()); node->left_node = build_kdtree( O1, O1.begin()+v_end1, depth + 1, node, non_efective_splits); node->right_node = build_kdtree( O2, O2.begin()+v_end2, depth + 1, node, non_efective_splits); return node; } #line 399 "k3_tree.nw" template bool can_set_be_divided(Object_iterator start, Object_iterator end, Depth depth) { if( depth >= max_depth) return false; if(std::distance(start,end)<2) return false; return true; } #line 414 "k3_tree.nw" template bool classify_objects(Object_iterator start, Object_iterator end, Plane_3 partition_plane, int depth, OutputIterator o1, OutputIterator o2) { typename Object_list::difference_type on_oriented_boundary = 0; typename Object_list::const_iterator o; Side_of_plane sop; for( o = start; o != end; ++o) { Oriented_side side = sop( partition_plane, *o); if( side == ON_NEGATIVE_SIDE || side == ON_ORIENTED_BOUNDARY) { *o1 = *o; ++o1; } if( side == ON_POSITIVE_SIDE || side == ON_ORIENTED_BOUNDARY) { *o2 = *o; ++o2; } if( side == ON_ORIENTED_BOUNDARY) on_oriented_boundary++; } return (on_oriented_boundary != std::distance(start,end)); } #line 442 "k3_tree.nw" template class Vertex_smaller_than { public: Vertex_smaller_than(Coordinate c) : coord(c) { CGAL_assertion( c >= 0 && c <=2); } bool operator()( const Object& o1, const Object& o2) { Vertex v1,v2; CGAL::assign(v1,o1); CGAL::assign(v2,o2); return(v1->point()[coord] < v2->point()[coord]); } private: Coordinate coord; SNC_decorator D; }; template Plane_3 construct_splitting_plane(Object_iterator start, Object_iterator end, Object_iterator& median, Depth depth) { CGAL_precondition( depth >= 0); typename Object_list::difference_type n=std::distance(start,end); CGAL_assertion(n>1); std::nth_element(start, start+n/2, end, Vertex_smaller_than(depth%3)); median = start+n/2; Vertex_handle v; CGAL::assign(v,*median); switch( depth % 3) { case 0: return Plane_3( v->point(), Vector_3( 1, 0, 0)); break; case 1: return Plane_3( v->point(), Vector_3( 0, 1, 0)); break; case 2: return Plane_3( v->point(), Vector_3( 0, 0, 1)); break; } CGAL_assertion_msg( 0, "never reached"); return Plane_3(); } #line 274 "k3_tree.nw" #line 601 "k3_tree.nw" const Node *locate_cell_containing( const Point_3& p, const Node* node) const { CGAL_precondition( node != 0); if( node->is_leaf()) return node; else { Oriented_side side = node->plane().oriented_side(p); if( side == ON_NEGATIVE_SIDE || side == ON_ORIENTED_BOUNDARY) return locate_cell_containing( p, node->left()); else { // side == ON_POSITIVE_SIDE CGAL_assertion( side == ON_POSITIVE_SIDE); return locate_cell_containing( p, node->right()); } } } const Object_list& locate( const Point_3& p, const Node* node) const { CGAL_precondition( node != 0); return locate_cell_containing( p, node)->objects(); } bool is_point_on_cell( const Point_3& p, const Node* target, const Node* current) const { CGAL_precondition( target != 0 && current != 0); if( current->is_leaf()) return (current == target); Oriented_side side = current->plane().oriented_side(p); if( side == ON_NEGATIVE_SIDE) return is_point_on_cell( p, target, current->left()); else if( side == ON_POSITIVE_SIDE) return is_point_on_cell( p, target, current->right()); CGAL_assertion( side == ON_ORIENTED_BOUNDARY); return (is_point_on_cell( p, target, current->left()) || is_point_on_cell( p, target, current->right())); } #line 275 "k3_tree.nw" }; CGAL_END_NAMESPACE #endif // K3_TREE_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_constructor.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_constructor.0000644000175000017500000022667511344301501031066 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_constructor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner // Peter Hachenberger #ifndef CGAL_SNC_CONSTRUCTOR_H #define CGAL_SNC_CONSTRUCTOR_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef SM_VISUALIZOR #include #endif // SM_VISUALIZOR #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 43 #include #include CGAL_BEGIN_NAMESPACE template struct Frame_point_lt { Frame_point_lt() {} bool operator()(Vertex_handle v1, Vertex_handle v2) const { if(v1->point() != v2->point()) return CGAL::lexicographically_xyz_smaller(v1->point(),v2->point()); if(!Infi_box::is_complex_facet_infibox_intersection(*v1) && Infi_box::is_complex_facet_infibox_intersection(*v2)) return true; return false; } }; template struct circle_lt { int max; typedef typename T::Point_3 Point_3; typedef typename T::RT RT; circle_lt(int m) :max(m) {}; bool operator()(const Point_3& p1, const Point_3& p2) const { const Quotient zero(RT(0)); Quotient x[2]; Quotient y[2]; switch(max) { case 0: x[0] = p1.y(); y[0] = p1.z(); x[1] = p2.y(); y[1] = p2.z(); break; case 1: x[0] = p1.x(); y[0] = p1.z(); x[1] = p2.x(); y[1] = p2.z(); break; case 2: x[0] = p1.x(); y[0] = p1.y(); x[1] = p2.x(); y[1] = p2.y(); break; } if(y[0] >= zero) { if(y[1] < zero) return false; if(x[0] != x[1]) return (x[0]y[1]); } else { if(y[1] >= zero) return true; if(x[0]!=x[1]) return(x[0]>x[1]); if(x[0] > zero) return (y[0]y[1]); } CGAL_assertion_msg(false, "control should not reach this line"); return false; } }; template struct Halfedge_key { typedef Halfedge_key Self; Point p; int i; Edge e; Decorator& D; Halfedge_key(Point pi, int ii, Edge ei, Decorator& Di ) : p(pi), i(ii), e(ei), D(Di) {} Halfedge_key(const Self& k) : p(k.p), i(k.i), e(k.e), D(k.D) {} Self& operator=(const Self& k) { p=k.p; i=k.i; e=k.e; return *this; } bool operator==(const Self& k) const { return p==k.p && i==k.i; } bool operator!=(const Self& k) const { return !operator==(k); } }; template struct Halfedge_key_lt { typedef Halfedge_key Key; typedef typename Point::R R; typedef typename R::Vector_3 Vector; typedef typename R::Direction_3 Direction; bool operator()( const Key& k1, const Key& k2) const { if ( k1.p == k2.p ) return (k1.i < k2.i); /* previous code: else return CGAL::lexicographically_xyz_smaller(k1.p,k2.p); */ Direction l(k1.e->vector()); if( k1.i < 0) l = -l; return (Direction( k2.p - k1.p) == l); } }; template std::ostream& operator<<(std::ostream& os, const Halfedge_key& k ) { os << k.p << " " << k.i; return os; } template int sign_of(const CGAL::Plane_3& h) { if ( h.c() != 0 ) return CGAL_NTS sign(h.c()); if ( h.b() != 0 ) return CGAL_NTS sign(-h.b()); return CGAL_NTS sign(h.a()); } struct Plane_lt { template bool operator()(const CGAL::Plane_3& h1, const CGAL::Plane_3& h2) const { typedef typename R::RT RT; RT diff = h1.a()-h2.a(); if ( (diff) != 0 ) return CGAL_NTS sign(diff) < 0; diff = h1.b()-h2.b(); if ( (diff) != 0 ) return CGAL_NTS sign(diff) < 0; diff = h1.c()-h2.c(); if ( (diff) != 0 ) return CGAL_NTS sign(diff) < 0; diff = h1.d()-h2.d(); return CGAL_NTS sign(diff) < 0; } }; // ---------------------------------------------------------------------------- // SNC_constructor // ---------------------------------------------------------------------------- /*{\Manpage{SNC_constructor}{SNC}{overlay functionality}{O}}*/ template class SNC_constructor : public SNC_decorator { public: typedef SNC_structure_ SNC_structure; typedef typename SNC_structure::Infi_box Infi_box; typedef typename SNC_structure_::Sphere_kernel Sphere_kernel; typedef typename Infi_box::Standard_kernel Standard_kernel; typedef typename Standard_kernel::Point_3 Standard_point_3; typedef typename SNC_structure_::Kernel Kernel; typedef typename Kernel::RT RT; typedef typename Infi_box::NT NT; typedef CGAL::SNC_constructor Self; typedef CGAL::SNC_decorator Base; typedef CGAL::SNC_decorator SNC_decorator; typedef typename CGAL::SNC_const_decorator SNC_const_decorator; typedef CGAL::SNC_point_locator SNC_point_locator; typedef CGAL::SNC_FM_decorator FM_decorator; typedef CGAL::SNC_intersection SNC_intersection; typedef typename SNC_structure::Items Items; typedef typename SNC_structure::Sphere_map Sphere_map; typedef CGAL::SM_decorator SM_decorator; typedef CGAL::SNC_SM_overlayer SM_overlayer; typedef CGAL::SM_const_decorator SM_const_decorator; typedef CGAL::SM_point_locator SM_point_locator; typedef typename SNC_structure::Vertex Vertex; typedef typename SNC_structure::Halfedge Halfedge; typedef typename SNC_structure::Halffacet Halffacet; typedef typename SNC_structure::Volume Volume; typedef typename SNC_structure::Vertex_iterator Vertex_iterator; typedef typename SNC_structure::Halfedge_iterator Halfedge_iterator; typedef typename SNC_structure::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Volume_iterator Volume_iterator; typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::Vertex_const_handle Vertex_const_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Halffacet_const_iterator Halffacet_const_iterator; typedef typename SNC_structure::Volume_const_handle Volume_const_handle; typedef typename SNC_structure::SVertex_iterator SVertex_iterator; typedef typename SNC_structure::SHalfedge_iterator SHalfedge_iterator; typedef typename SNC_structure::SFace_iterator SFace_iterator; typedef typename SNC_structure::SHalfloop_iterator SHalfloop_iterator; typedef typename SNC_structure::SVertex SVertex; typedef typename SNC_structure::SHalfedge SHalfedge; typedef typename SNC_structure::SFace SFace; typedef typename SNC_structure::SHalfloop SHalfloop; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::SVertex_const_handle SVertex_const_handle; typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SNC_structure::SFace_const_handle SFace_const_handle; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename SNC_structure::SFace_cycle_iterator SFace_cycle_iterator; typedef typename SNC_structure::SFace_cycle_const_iterator SFace_cycle_const_iterator; typedef typename SNC_structure::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Shell_entry_iterator Shell_entry_iterator; typedef typename SNC_structure::Shell_entry_const_iterator Shell_entry_const_iterator; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Direction_3 Direction_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Line_3 Line_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Ray_3 Ray_3; typedef typename SNC_structure::Aff_transformation_3 Aff_transformation_3; typedef typename SNC_structure::Sphere_point Sphere_point; typedef typename SNC_structure::Sphere_segment Sphere_segment; typedef typename SNC_structure::Sphere_circle Sphere_circle; typedef typename SNC_structure::Sphere_direction Sphere_direction; typedef typename SNC_structure::Mark Mark; typedef typename SM_decorator::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename SM_const_decorator::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; enum{NORMAL, CORNER, DEGENERATE}; SNC_point_locator* pl; Vertex_handle minVertex; typedef void* GenPtr; typedef CGAL::Unique_hash_map Sface_shell_hash; typedef CGAL::Unique_hash_map Face_shell_hash; typedef CGAL::Unique_hash_map SFace_visited_hash; typedef CGAL::Unique_hash_map Shell_closed_hash; struct Shell_explorer { const SNC_decorator& D; Sface_shell_hash& ShellSf; Face_shell_hash& ShellF; // Shell_closed_hash& Closed; SFace_visited_hash& Done; SFace_handle sf_min; int n; Shell_explorer(const SNC_decorator& Di, Sface_shell_hash& SSf, Face_shell_hash& SF, SFace_visited_hash& Vi) : D(Di), ShellSf(SSf), ShellF(SF), Done(Vi), n(0) {} void visit(SFace_handle h) { CGAL_NEF_TRACEN("visit sf "<sfaces_begin(); // if( Closed[sf] ) { // if(SD.is_isolated(h)){ // if(!SD.has_shalfloop()) Closed[sf] = false; // } // else { // if(SD.first_out_edge(h) == SD.last_out_edge(h)) Closed[sf] = false; // } // } } void visit(Halffacet_handle h) { CGAL_NEF_TRACEN(h->plane()); ShellF[h]=n; } void visit(SHalfedge_handle se) {} void visit(SHalfloop_handle sl) {} SFace_handle& minimal_sface() { return sf_min; } void increment_shell_number() { CGAL_NEF_TRACEN("leaving shell "<sncp()->new_vertex(p , boundary); CGAL_NEF_TRACEN( point(v)); SM_decorator SD(&*v); Sphere_point sp[] = { Sphere_point(-x, 0, 0), Sphere_point(0, -y, 0), Sphere_point(0, 0, -z) }; /* create box vertices */ SVertex_handle sv[3]; for(int vi=0; vi<3; ++vi) { sv[vi] = SD.new_svertex(sp[vi]); mark(sv[vi]) = boundary; } /* create facet's edge uses */ // Sphere_segment ss[3]; SHalfedge_handle she[3]; for(int si=0; si<3; ++si) she[si] = SD.new_shalfedge_pair(sv[si], sv[(si+1)%3]); for(int i=0; i<3;++i) { SD.circle(she[i]) = Sphere_circle(Plane_3(sp[i],sp[(i+1)%3],Point_3(0,0,0))); SD.circle(SD.twin(she[i])) = SD.circle(she[i]).opposite(); SD.mark(she[i]) = SD.mark(SD.twin(she[i])) = boundary; } /* create facets */ SFace_handle fi = SD.new_sface(); SFace_handle fe = SD.new_sface(); SD.link_as_face_cycle(she[0], fi); SD.link_as_face_cycle(SD.twin(she[0]), fe); Sphere_point p1 = SD.point(SD.source(she[0])); Sphere_point p2 = SD.point(SD.target(she[0])); Sphere_point p3 = SD.point(SD.target(SD.next(she[0]))); if ( spherical_orientation(p1,p2,p3) > 0 ) { SD.mark(fi) = space; SD.mark(fe) = 0; } else { SD.mark(fi) = 0; SD.mark(fe) = space; } return v; } /*{\Mop produces the sphere map representing thp,e box corner in direction $(x,y,z)$.}*/ template void add_outer_sedge_cycle(Vertex_handle v, Forward_iterator start, Forward_iterator end, bool orient) { CGAL_assertion(start!=end); v->mark() = true; SM_decorator SD(&*v); Forward_iterator si; for(si=start; si!=end; ++si) SD.new_svertex(*si); SHalfedge_handle se,se_prev; std::list se_list; SVertex_iterator sv(SD.svertices_begin()), sv_next(sv); for(;sv!=SD.svertices_end();++sv) { ++sv_next; sv->mark()=true; if(sv_next==SD.svertices_end()) sv_next=SD.svertices_begin(); se=SD.new_shalfedge_pair(sv,sv_next); se_list.push_back(se); se->mark() = se->twin()->mark() = true; if(sv!=SD.svertices_begin()) { se->sprev() = se_prev; se_prev->snext() = se; se->twin()->snext() = se_prev->twin(); se_prev->twin()->sprev() = se->twin(); } se_prev = se; } se=*se_list.begin(); se->sprev() = se_prev; se_prev->snext() = se; se->twin()->snext() = se_prev->twin(); se_prev->twin()->sprev() = se->twin(); typename std::list::iterator seli; for(seli=se_list.begin();seli!=se_list.end();++seli) { se = *seli; se->circle() = Sphere_circle(se->source()->point(), se->snext()->source()->point()); if(orient && seli==se_list.begin()) se->circle() = Sphere_circle(se->snext()->source()->point(), se->source()->point()); se->circle() = normalized(se->circle()); se->twin()->circle() = se->circle().opposite(); } SFace_handle sfa = SD.new_sface(); SFace_handle sfi = SD.new_sface(); sfi->mark()=true; sfa->mark()=false; se=*se_list.begin(); SD.link_as_face_cycle(se,sfi); SD.link_as_face_cycle(se->twin(),sfa); } template void add_inner_sedge_cycle(Vertex_handle v, Forward_iterator start, Forward_iterator end, bool orient, bool camera) { CGAL_assertion(start!=end); v->mark() = true; SM_decorator SD(&*v); Forward_iterator si; std::list sv_list; for(si=start; si!=end; ++si) sv_list.push_back(SD.new_svertex(*si)); SHalfedge_handle se, se_prev; typename std::list::iterator sv(sv_list.begin()), sv_next(sv); std::list se_list; for(;sv!=sv_list.end();++sv) { ++sv_next; (*sv)->mark()=true; if(sv_next==sv_list.end()) sv_next=sv_list.begin(); se=SD.new_shalfedge_pair(*sv,*sv_next); se_list.push_back(se); se->mark() = se->twin()->mark() = true; if(sv!=sv_list.begin()) { se->prev() = se_prev; se_prev->next() = se; se->twin()->next() = se_prev->twin(); se_prev->twin()->prev() = se->twin(); } se_prev = se; } se=*se_list.begin(); se->prev() = se_prev; se_prev->next() = se; se->twin()->next() = se_prev->twin(); se_prev->twin()->prev() = se->twin(); typename std::list::iterator seli; for(seli=se_list.begin();seli!=se_list.end();++seli) { se = *seli; se->circle() = Sphere_circle(se->source()->point(), se->snext()->source()->point()); if(orient && seli==se_list.begin()) se->circle() = Sphere_circle(se->snext()->source()->point(), se->source()->point()); se->circle() = normalized(se->circle()); se->twin()->circle() = se->circle().opposite(); } SFace_handle sfa,sfi; if(camera) { sfa = ++SD.sfaces_begin(); sfi = SD.new_sface(); sfi->mark()=false; } else { sfa = SD.new_sface(); sfi = SD.new_sface(); sfa->mark()=true; sfi->mark()=false; } se=*se_list.begin(); SD.link_as_face_cycle(se,sfi); SD.link_as_face_cycle(se->twin(),sfa); } Vertex_handle create_for_infibox_overlay(Vertex_const_handle vin) const { Unique_hash_map mark_of_right_sface; Vertex_handle v = this->sncp()->new_vertex(vin->point(), vin->mark()); SM_decorator D(&*v); SM_const_decorator E(&*vin); SVertex_const_handle e; CGAL_forall_svertices(e, E) if(!Infi_box::is_edge_on_infibox(e)) break; Sphere_point ps = E.point(e); ps = normalized(ps); SVertex_handle v1 = D.new_svertex(ps); SVertex_handle v2 = D.new_svertex(ps.antipode()); CGAL_NEF_TRACEN("new svertex 1 " << ps); CGAL_NEF_TRACEN("new svertex 2 " << ps.antipode()); D.mark(v1) = D.mark(v2) = E.mark(e); CGAL_NEF_TRACEN("svertex 1 " << ps << " has mark " << D.mark(v1)); CGAL_NEF_TRACEN("svertex 2 " << ps.antipode() << " has mark " << D.mark(v2)); if(E.is_isolated(e)) { CGAL_NEF_TRACEN("edge is isolated"); SFace_handle f = D.new_sface(); D.mark(f) = E.mark(E.face(e)); D.link_as_isolated_vertex(v1, f); D.link_as_isolated_vertex(v2, f); } else { CGAL_NEF_TRACEN("edge is not isolated"); SHalfedge_handle se; SFace_handle sf; SHalfedge_around_svertex_const_circulator ec(E.out_edges(e)), ee(ec); CGAL_For_all(ec,ee) { Sphere_segment seg(E.point(E.source(ec)), E.point(E.source(ec)).antipode(), E.circle(ec)); se = D.new_shalfedge_pair(v1, v2); D.mark(se) = D.mark(D.twin(se)) = E.mark(ec); mark_of_right_sface[se] = E.mark(E.face(ec)); D.circle(se) = E.circle(ec); D.circle(D.twin(se)) = D.circle(se).opposite(); } SHalfedge_around_svertex_circulator ec2(D.out_edges(v1)), ee2(ec2); CGAL_For_all(ec2,ee2) { sf = D.new_sface(); D.mark(sf) = mark_of_right_sface[ec2]; D.link_as_face_cycle(SHalfedge_handle(ec2),sf); } } return v; } Vertex_handle create_from_plane(const Plane_3& pl, const Point_3& p, const Mark& bnd, const Mark& in, const Mark& out) const { typedef typename CGAL::SNC_const_decorator SNC_const_decorator; Vertex_handle v = this->sncp()->new_vertex( p, bnd); point(v) = p; Sphere_circle c(pl); // circle through origin parallel to h SM_decorator D(&*v); SHalfloop_handle l = D.new_shalfloop_pair(); SFace_handle f1 = D.new_sface(), f2 = D.new_sface(); D.link_as_loop(l,f1); D.link_as_loop(twin(l),f2); D.circle(l) = c; D.circle(twin(l)) = c.opposite(); D.mark(f1) = out; D.mark(f2) = in; D.mark(l) = D.mark(D.twin(l)) = bnd; return v; } Vertex_handle create_from_point_on_infibox_facet(const Point_3& p) const { CGAL_assertion(!Infi_box::is_standard(p)); if(Infi_box::x_on_box(p)) if(p.hx() > 0) return create_from_plane(Plane_3(1,0,0,1), p, 1, 1, 0); else return create_from_plane(Plane_3(-1,0,0,1), p, 1, 1, 0); if(Infi_box::y_on_box(p)) if(p.hy() > 0) return create_from_plane(Plane_3(0,1,0,1), p, 1, 1, 0); else return create_from_plane(Plane_3(0,-1,0,1), p, 1, 1, 0); if(Infi_box::z_on_box(p)) if(p.hz() > 0) return create_from_plane(Plane_3(0,0,1,1), p, 1, 1, 0); else return create_from_plane(Plane_3(0,0,-1,1), p, 1, 1, 0); CGAL_assertion_msg(0, "something is wrong"); return Vertex_handle(); } Vertex_handle create_from_point_on_infibox_edge(const Point_3& p) const { Sphere_point sp; Sphere_circle c1,c2; if(!Infi_box::x_on_box(p)) { sp = Sphere_point(1,0,0); c1 = (p.hy() < RT(0)) ? Sphere_circle(0,-1,0) : Sphere_circle(0,1,0); c2 = (p.hz() < RT(0)) ? Sphere_circle(0,0,-1) : Sphere_circle(0,0,1); } else if(!Infi_box::y_on_box(p)) { sp = Sphere_point(0,1,0); c1 = (p.hx() < RT(0)) ? Sphere_circle(-1,0,0) : Sphere_circle(1,0,0); c2 = (p.hz() < RT(0)) ? Sphere_circle(0,0,-1) : Sphere_circle(0,0,1); } else if(!Infi_box::z_on_box(p)) { sp = Sphere_point(0,0,1); c1 = (p.hx() < RT(0)) ? Sphere_circle(-1,0,0) : Sphere_circle(1,0,0); c2 = (p.hy() < RT(0)) ? Sphere_circle(0,-1,0) : Sphere_circle(0,1,0); } else CGAL_assertion_msg(false, "line of code shall not be reached"); Vertex_handle v = this->sncp()->new_vertex( p, true); SM_decorator D(&*v); SVertex_handle v1 = D.new_svertex(sp); SVertex_handle v2 = D.new_svertex(sp.antipode()); SHalfedge_handle e1 = D.new_shalfedge_pair(v1,v2); SHalfedge_handle e2 = D.new_shalfedge_pair(v1,v2); SFace_handle f1 = D.new_sface(); SFace_handle f2 = D.new_sface(); D.mark(v1) = D.mark(v2) = D.mark(e1) = D.mark(e1->twin()) = D.mark(e2) = D.mark(e2->twin()) = true; D.mark(f1) = false; D.mark(f2) = true; D.link_as_face_cycle(e1,f1); D.link_as_face_cycle(e2,f2); D.circle(e1) = c1; D.circle(e1->twin()) = c1.opposite(); D.circle(e1->snext()) = c2; D.circle(e1->snext()->twin()) = c2.opposite(); return v; } Vertex_handle create_from_point_on_infibox_vertex(const Point_3& p) const { typedef typename Infi_box::Standard_point Standard_point; Standard_point ps(Infi_box::standard_point(p,1)); return create_extended_box_corner(ps.hx(), ps.hy(), ps.hz(),true,true); } Vertex_handle create_from_facet(Halffacet_const_handle f, const Point_3& p) const { return create_from_plane(f->plane(), p, f->mark(), f->twin()->incident_volume()->mark(), f->incident_volume()->mark()); } /*{\Mop produces the sphere map at point $p$ representing the local view of $f$. \precond $p$ is part of $f$.}*/ Vertex_handle create_from_edge(Halfedge_const_handle e, const Point_3& p) const { typedef typename CGAL::SNC_const_decorator SNC_const_decorator; CGAL_assertion(SNC_const_decorator::segment(e).has_on(p)); Vertex_handle v = this->sncp()->new_vertex( p, e->mark()); SM_decorator D(&*v); SM_const_decorator E(&*e->source()); Sphere_point ps = e->point(); SVertex_handle v1 = D.new_svertex(ps); SVertex_handle v2 = D.new_svertex(ps.antipode()); v1->mark() = v2->mark() = e->mark(); bool first = true; // CGAL_NEF_SETDTHREAD(19*43*131); SHalfedge_const_handle ceee; CGAL_NEF_TRACEN("---------------------" << e->center_vertex()->point()); CGAL_forall_shalfedges(ceee,E) CGAL_NEF_TRACEN("|" << ceee->circle() << "|" << ceee->mark() << " " << ceee->incident_sface()->mark()); CGAL_NEF_TRACEN(" "); if(E.is_isolated(e)) { SFace_handle f = D.new_sface(); D.link_as_isolated_vertex(v1,f); D.link_as_isolated_vertex(v2,f); f->mark() = e->incident_sface()->mark(); } SHalfedge_around_svertex_const_circulator ec1(E.out_edges(e)), ee(ec1); SHalfedge_handle e1,e2; CGAL_For_all(ec1,ee) { if (first) e1 = D.new_shalfedge_pair(v1,v2); else e1 = D.new_shalfedge_pair(e1, e2, SM_decorator::AFTER, SM_decorator::BEFORE); e2 = D.twin(e1); first = false; } SHalfedge_handle eee; CGAL_forall_shalfedges(eee,D) CGAL_NEF_TRACEN("|" << eee->circle()); CGAL_NEF_TRACEN(" "); ec1 = E.out_edges(e); SHalfedge_around_svertex_circulator ec2(D.out_edges(v1)); CGAL_For_all(ec1,ee) { CGAL_NEF_TRACEN("|" << ec1->circle() << "|" << ec1->mark() << " " << ec1->incident_sface()->mark()); ec2->mark() = ec2->twin()->mark() = ec1->mark(); ec2->circle() = ec1->circle(); ec2->twin()->circle() = ec1->twin()->circle(); SFace_handle f = D.new_sface(); D.link_as_face_cycle(ec2,f); f->mark() = ec1->incident_sface()->mark(); ++ec2; } CGAL_NEF_TRACEN(" "); CGAL_NEF_TRACEN("new vertex "); CGAL_forall_svertices(v1, D) CGAL_NEF_TRACEN("|" << v1->point() << "|" << v1->mark()); CGAL_NEF_TRACEN(" "); CGAL_forall_shalfedges(eee,D) CGAL_NEF_TRACEN("|" << eee->circle() << "|" << eee->mark() << " " << eee->incident_sface()->mark()); CGAL_NEF_TRACEN("---------------------"); return v; } /*{\Mop produces the sphere map at point $p$ representing the local view of $e$. \precond $p$ is part of $e$.}*/ Vertex_handle clone_SM( Vertex_const_handle vin) { #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS ++number_of_clones; #endif CGAL::Unique_hash_map VM; CGAL::Unique_hash_map EM; CGAL::Unique_hash_map LM; CGAL::Unique_hash_map FM; SM_const_decorator E(&*vin); Vertex_handle vout = this->sncp()->new_vertex(vin->point(), vin->mark()); SM_decorator D(&*vout); SVertex_const_handle sv; CGAL_forall_svertices(sv, E) VM[sv] = D.new_svertex(E.point(sv)); SHalfedge_const_handle se; CGAL_forall_sedges(se, E) { EM[se] = D.new_shalfedge_pair(); EM[E.twin(se)] = D.twin(EM[se]); } SFace_const_handle sf; CGAL_forall_sfaces(sf, E) FM[sf] = D.new_sface(); SHalfloop_handle sl; if(E.has_shalfloop()) { sl = LM[E.shalfloop()] = D.new_shalfloop_pair(); LM[E.twin(E.shalfloop())] = D.twin(sl); D.set_face(sl, FM[E.face(E.shalfloop())]); D.set_face(D.twin(sl), FM[E.face(E.twin(E.shalfloop()))]); D.circle(sl) = E.circle(E.shalfloop()); D.circle(D.twin(sl)) = E.circle(E.twin(E.shalfloop())); } CGAL_forall_svertices(sv, E) { D.set_first_out_edge(VM[sv], EM[E.first_out_edge(sv)]); D.set_face(VM[sv], FM[E.face(sv)]); D.mark(VM[sv]) = E.mark(sv); } CGAL_forall_shalfedges(se, E) { D.mark(EM[se]) = D.mark(D.twin(EM[se])) = E.mark(se); D.set_source(EM[se], VM[E.source(se)]); D.set_prev(EM[se], EM[E.previous(se)]); D.set_next(EM[se], EM[E.next(se)]); D.set_face(EM[se], FM[E.face(se)]); D.circle(EM[se]) = E.circle(se); } CGAL_forall_sfaces(sf, E) { D.mark(FM[sf]) = E.mark(sf); SFace_cycle_const_iterator sfc; for(sfc = sf->sface_cycles_begin(); sfc != sf->sface_cycles_end(); ++sfc) { if(sfc.is_svertex()) D.store_sm_boundary_object(VM[SVertex_const_handle(sfc)], FM[sf]); else if(sfc.is_shalfedge()) D.store_sm_boundary_object(EM[SHalfedge_const_handle(sfc)], FM[sf]); else if(sfc.is_shalfloop()) D.store_sm_boundary_object(LM[SHalfloop_const_handle(sfc)], FM[sf]); else CGAL_assertion_msg(0,"damn wrong handle."); } } return vout; } template Sphere_map* create_edge_facet_overlay( Halfedge_const_handle e, Halffacet_const_handle f, const Point_3& p, const Selection& BOP, bool inv) { #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS ++number_of_edge_facet_overlays; #endif CGAL_NEF_TRACEN("edge facet overlay " << p); Unique_hash_map mark_of_right_sface; SM_decorator D(&*this->sncp()->new_vertex(p, BOP(e->mark(), f->mark()))); SM_const_decorator E(&*e->source()); Sphere_point ps = e->point(); ps = normalized(ps); SVertex_handle v1 = D.new_svertex(ps); SVertex_handle v2 = D.new_svertex(ps.antipode()); CGAL_NEF_TRACEN("new svertex 1 " << ps); CGAL_NEF_TRACEN("new svertex 2 " << ps.antipode()); Halffacet_const_handle faces_p(f); Vector_3 vec(ps-CGAL::ORIGIN); if(faces_p->plane().oriented_side(p+vec) == ON_NEGATIVE_SIDE) faces_p = faces_p->twin(); v1->mark() = BOP(e->mark(), faces_p->incident_volume()->mark(), inv); v2->mark() = BOP(e->mark(), faces_p->twin()->incident_volume()->mark(), inv); CGAL_NEF_TRACEN("svertex 1 " << ps << " has mark " << v1->mark()); CGAL_NEF_TRACEN("svertex 2 " << ps.antipode() << " has mark " << v2->mark()); if(E.is_isolated(e)) { CGAL_NEF_TRACEN("edge is isolated"); Mark mf1 = BOP(e->incident_sface()->mark(), faces_p->incident_volume()->mark(), inv); Mark mf2 = BOP(e->incident_sface()->mark(), faces_p->twin()->incident_volume()->mark(), inv); Mark ml = BOP(e->incident_sface()->mark(), faces_p->mark(), inv); SFace_handle f1 = D.new_sface(); D.link_as_isolated_vertex(v1, f1); f1->mark() = mf1; if(mf1 == mf2 && mf1 == ml) { D.link_as_isolated_vertex(v2, f1); } else { SHalfloop_handle l = D.new_shalfloop_pair(); SFace_handle f2 = D.new_sface(); D.link_as_isolated_vertex(v2, f2); D.link_as_loop(l,f1); D.link_as_loop(l->twin(),f2); l->circle() = Sphere_circle(faces_p->plane()); l->twin()->circle() = l->circle().opposite(); f2->mark() = mf2; l->mark() = l->twin()->mark() = ml; } } else { CGAL_NEF_TRACEN("edge is not isolated"); SVertex_handle sv; SHalfedge_handle se1; SHalfedge_handle se2; SFace_handle sf; Sphere_circle c(f->plane()); SHalfedge_handle next_edge; SHalfedge_around_svertex_const_circulator ec(E.out_edges(e)), ee(ec); CGAL_For_all(ec,ee) { Sphere_segment seg(E.point(E.source(ec)), E.point(E.source(ec)).antipode(), E.circle(ec)); Sphere_point sp(intersection(c, seg.sphere_circle())); CGAL_NEF_TRACEN(seg <<" has_on " << sp); if(!seg.has_on(sp)) sp = sp.antipode(); sv = D.new_svertex(sp); CGAL_NEF_TRACEN("new svertex 3 " << normalized(sp)); sv->mark() = BOP(ec->mark(), f->mark(), inv); se1 = D.new_shalfedge_pair(v1, sv); if(next_edge == SHalfedge_handle()) se2 = D.new_shalfedge_pair(sv, v2); else se2 = D.new_shalfedge_pair(sv, next_edge, -1); next_edge = twin(se2); se1->mark() = se1->twin()->mark() = BOP(E.mark(ec), faces_p->incident_volume()->mark(), inv); se2->mark() = se2->twin()->mark() = BOP(E.mark(ec), faces_p->twin()->incident_volume()->mark(), inv); mark_of_right_sface[se1] = E.mark(E.face(ec)); D.circle(se1) = D.circle(se2) = E.circle(ec); D.circle(D.twin(se1)) = D.circle(D.twin(se2)) = D.circle(se1).opposite(); } SHalfedge_around_svertex_circulator ec2(D.out_edges(v1)), ee2(ec2); CGAL_For_all(ec2,ee2) { SHalfedge_around_svertex_circulator en(ec2); ++en; se1 = D.new_shalfedge_pair(twin(ec2), twin(en), -1, 1); CGAL_NEF_TRACEN("new edge pair " << ssource(twin(ec2))->vector() << " -> " << ssource(twin(en))->vector()); D.circle(se1) = Sphere_circle(faces_p->plane()); D.circle(D.twin(se1)) = D.circle(se1).opposite(); D.mark(se1) = D.mark(D.twin(se1)) = BOP(mark_of_right_sface[ec2], faces_p->mark(), inv); sf = D.new_sface(); D.mark(sf) = BOP(mark_of_right_sface[ec2], faces_p->incident_volume()->mark(), inv); D.link_as_face_cycle(se1,sf); sf = D.new_sface(); D.mark(sf) = BOP(mark_of_right_sface[ec2], faces_p->twin()->incident_volume()->mark(), inv); D.link_as_face_cycle(D.twin(se1),sf); } } return D.sphere_map(); } private: void pair_up_halfedges() const { /*{\Mop pairs all halfedge stubs to create the edges in 3-space.}*/ // CGAL_NEF_SETDTHREAD(43*61); CGAL_NEF_TRACEN(">>>>>pair_up_halfedges"); typedef Halfedge_key< Point_3, Halfedge_handle, SNC_decorator> Halfedge_key; typedef Halfedge_key_lt< Point_3, Halfedge_handle, SNC_decorator> Halfedge_key_lt; typedef std::list Halfedge_list; typedef typename Standard_kernel::Kernel_tag Kernel_tag; typedef CGAL::Pluecker_line_3 Pluecker_line_3; typedef CGAL::Pluecker_line_lt Pluecker_line_lt; typedef std::map< Pluecker_line_3, Halfedge_list, Pluecker_line_lt> Pluecker_line_map; SNC_decorator D(*this); Pluecker_line_map M; Pluecker_line_map M2; Pluecker_line_map M3; Pluecker_line_map M4; // Progress_indicator_clog progress( 2*this->sncp()->number_of_halfedges(), // "SNC_constructor: pairing up edges..."); NT eval(Infi_box::compute_evaluation_constant_for_halfedge_pairup(*this->sncp()));; Halfedge_iterator e; CGAL_forall_halfedges(e,*this->sncp()) { // progress++; Point_3 p = point(vertex(e)); Point_3 q = p + e->vector(); CGAL_NEF_TRACE(" segment("<vector()<<")"); Standard_point_3 sp = Infi_box::standard_point(p,eval); Standard_point_3 sq = Infi_box::standard_point(q,eval); Pluecker_line_3 l( sp, sq); int inverted; l = categorize( l, inverted); if(Infi_box::is_edge_on_infibox(e)) if(Infi_box::is_type4(e)) M4[l].push_back(Halfedge_key(p,inverted,e, D)); else if(Infi_box::is_type3(e)) M3[l].push_back(Halfedge_key(p,inverted,e, D)); else M2[l].push_back(Halfedge_key(p,inverted,e, D)); else M[l].push_back(Halfedge_key(p,inverted,e,D)); // the following trace crashes when compiling with optimizations (-O{n}) //CGAL_NEF_TRACEN(Infi_box::standard_point(point(vertex(e)))+ // Vector_3(point(e))); CGAL_NEF_TRACEN(" line("<first); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; ++itl; CGAL_assertion(itl != it->second.end()); Halfedge_handle e2 = itl->e; CGAL_NEF_TRACEN(" " << point(vertex(e1)) << " -> " << point(vertex(e2))); CGAL_NEF_TRACEN(e1->vector()<<" -> "<<-e2->vector()); CGAL_assertion(normalized(e1->vector())==normalized(-e2->vector())); make_twins(e1,e2); CGAL_assertion(mark(e1)==mark(e2)); // discard temporary sphere_point ? } } CGAL_forall_iterators(it,M3) { // progress++; it->second.sort(Halfedge_key_lt()); CGAL_NEF_TRACEN("search opposite "<first); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; ++itl; CGAL_assertion(itl != it->second.end()); Halfedge_handle e2 = itl->e; CGAL_NEF_TRACEN(" " << point(vertex(e1)) << " -> " << point(vertex(e2))); CGAL_NEF_TRACEN(e1->vector()<<" -> "<<-e2->vector()); CGAL_assertion(normalized(e1->vector())==normalized(-e2->vector())); make_twins(e1,e2); CGAL_assertion(mark(e1)==mark(e2)); // discard temporary sphere_point ? } } CGAL_forall_iterators(it,M2) { // progress++; it->second.sort(Halfedge_key_lt()); CGAL_NEF_TRACEN("search opposite "<first); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; ++itl; CGAL_assertion(itl != it->second.end()); Halfedge_handle e2 = itl->e; CGAL_NEF_TRACEN(" " << point(vertex(e1)) << " -> " << point(vertex(e2))); CGAL_NEF_TRACEN(e1->vector()<<" -> "<<-e2->vector()); CGAL_assertion(normalized(e1->vector())==normalized(-e2->vector())); make_twins(e1,e2); CGAL_assertion(mark(e1)==mark(e2)); // discard temporary sphere_point ? } } CGAL_forall_iterators(it,M) { // progress++; it->second.sort(Halfedge_key_lt()); CGAL_NEF_TRACEN("search opposite "<first); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; ++itl; CGAL_assertion(itl != it->second.end()); Halfedge_handle e2 = itl->e; CGAL_NEF_TRACEN(" " << point(vertex(e1)) << " -> " << point(vertex(e2))); CGAL_NEF_TRACEN(e1->vector()<<" -> "<< -e2->vector()); // CGAL_assertion(normalized(e1->vector())==normalized(-e2->vector())); CGAL_assertion(point(vertex(e1)) != point(vertex(e2))); CGAL_assertion(mark(e1)==mark(e2)); make_twins(e1,e2); // discard temporary sphere_point ? } } } void link_shalfedges_to_facet_cycles() const { /*{\Mop creates all non-trivial facet cycles from sedges. \precond |pair_up_halfedges()| was called before.}*/ // CGAL_NEF_SETDTHREAD(43*31); CGAL_NEF_TRACEN(">>>>>link_shalfedges_to_facet_cycles"); // Progress_indicator_clog progress // (this->sncp()->number_of_halfedges(), // "SNC_constructor: building facet cycles..."); Halfedge_iterator e; CGAL_forall_edges(e,*this->sncp()) { // progress++; CGAL_NEF_TRACEN(""); CGAL_NEF_TRACEN(PH(e)); Halfedge_iterator et = twin(e); SM_decorator D(&*vertex(e)), Dt(&*vertex(et)); CGAL_NEF_TRACEN(point(vertex(e))); if ( D.is_isolated(e) ) continue; SHalfedge_around_svertex_circulator ce(D.first_out_edge(e)),cee(ce); SHalfedge_around_svertex_circulator cet(Dt.first_out_edge(et)),cete(cet); CGAL_For_all(cet,cete) if ( Dt.circle(cet) == D.circle(ce).opposite() && twin(Dt.source(cet)) == D.source(ce) ) break; /* DEBUG if( Dt.circle(cet) != D.circle(ce).opposite() ) CGAL_NEF_TRACEN("assertion failed!"); CGAL_NEF_TRACEN("vertices " << point(vertex(e)) << " " << point(vertex(et))); SHalfedge_around_svertex_circulator sc(D.first_out_edge(e)); SHalfedge_around_svertex_circulator sct(Dt.first_out_edge(et)); CGAL_For_all(sc,cee) CGAL_NEF_TRACEN("sseg@E addr="<<&*sc<< " src="<mark()==cet->mark()); link_as_prev_next_pair(Dt.twin(cet),ce); link_as_prev_next_pair(D.twin(ce),cet); --cet; // ce moves ccw, cet moves cw } } } void categorize_facet_cycles_and_create_facets() const { /*{\Mop collects all facet cycles incident to a facet and creates the facets. \precond |link_shalfedges_to_facet_cycles()| was called before.}*/ // CGAL_NEF_SETDTHREAD(43*31*23); CGAL_NEF_TRACEN(">>>>>categorize_facet_cycles_and_create_facets"); typedef std::list Object_list; typedef std::map Map_planes; // Progress_indicator_clog progress // (this->sncp()->number_of_shalfedges()+this->sncp()->number_of_shalfloops(), // "SNC_constructor: categorizing facet cycles..."); Map_planes M; SHalfedge_iterator e; CGAL_forall_shalfedges(e,*this->sncp()) { // progress++; Sphere_circle c(circle(e)); Plane_3 h = c.plane_through(point(vertex(e))); CGAL_NEF_TRACEN("\n" << point(target(e->source())) <<" - "<< point(vertex(e)) <<" - "<< point(target(e->twin()->source())) << " has plane " << h << " has circle " << circle(e) << " has signum " << sign_of(h)); if ( sign_of(h)<0 ) continue; M[normalized(h)].push_back(Object_handle(twin(e))); CGAL_NEF_TRACEN(" normalized as " << normalized(h)); } SHalfloop_iterator l; CGAL_forall_shalfloops(l,*this->sncp()) { Sphere_circle c(circle(l)); Plane_3 h = c.plane_through(point(vertex(l))); if ( sign_of(h)<0 ) continue; // CGAL_assertion( h == normalized(h)); M[normalized(h)].push_back(Object_handle(twin(l))); } // Progress_indicator_clog progress2 // ( M.size(), "SNC_constructor: creating facets..."); #ifdef CGAL_NEF3_TIMER_PLANE_SWEEPS number_of_plane_sweeps=0; timer_plane_sweeps.reset(); #endif typename Map_planes::iterator it; CGAL_forall_iterators(it,M) { // progress2++; CGAL_NEF_TRACEN(" plane "<first<<" "<<(it->first).point()); FM_decorator D(*this->sncp()); D.create_facet_objects(it->first,it->second.begin(),it->second.end()); } // CGAL_NEF_SETDTHREAD(1); } void create_volumes() { /*{\Mop collects all shells incident to a volume and creates the volumes. \precond |categorize_facet_cycles_and_creating_facets()| was called before.}*/ #ifdef CGAL_NEF3_TIMER_POINT_LOCATION timer_ray_shooting.reset(); #endif // CGAL_NEF_SETDTHREAD(37*43*19*47); CGAL_NEF_TRACEN(">>>>>create_volumes"); Sface_shell_hash ShellSf(-1); Face_shell_hash ShellF(-1); SFace_visited_hash Done(false); Shell_explorer V(*this,ShellSf,ShellF,Done); std::vector MinimalSFace; std::vector EntrySFace; std::vector Closed; // Progress_indicator_clog progress // (this->sncp()->number_of_sfaces(), "SNC_construction: building shells..."); SFace_iterator f; // First, we classify all the Shere Faces per Shell. For each Shell we // determine its minimum lexicographyly vertex and we check wheter the // Shell encloses a region (closed surface) or not. CGAL_forall_sfaces(f,*this->sncp()) { // progress++; CGAL_NEF_TRACEN("sface in " << ShellSf[f]); if ( Done[f] ) continue; V.minimal_sface() = f; visit_shell_objects(f,V); MinimalSFace.push_back(V.minimal_sface()); EntrySFace.push_back(f); V.increment_shell_number(); CGAL_NEF_TRACEN("sface out " << ShellSf[f]); } for(unsigned int i=0; iinitialize(this->sncp()); // construct the point locator #ifdef CGAL_NEF3_TIMER_INITIALIZE_KDTREE timer_initialize_kdtree.stop(); if(cgal_nef3_timer_on) std::cout << "Runtime_initialize_kdtree: " << timer_initialize_kdtree.time() << std::endl; #endif // Progress_indicator_clog progress2 // ( MinimalSFace.size(), "SNC_constructor: creating outer volumes..."); // then, we determine the Shells which correspond to Volumes via a ray // shootting in the direction (-1,0,0) over the Sphere_map of the minimal // vertex. The Shell corresponds to a Volume if the object hit belongs // to another Shell. this->sncp()->new_volume(); // outermost volume (nirvana) if(MinimalSFace.size() == 0) return; Vertex_handle v_min = vertex(MinimalSFace[0]); for( unsigned int i = 0; i < MinimalSFace.size(); ++i) { // progress2++; Vertex_handle v = vertex(MinimalSFace[i]); if(CGAL::lexicographically_xyz_smaller(point(v),point(v_min))) v_min=v; CGAL_NEF_TRACEN( "Shell #" << i << " minimal vertex: " << point(v)); SM_point_locator D((Sphere_map*) &*v); Object_handle o = D.locate(Sphere_point(-1,0,0)); SFace_const_handle sfc; if( !CGAL::assign(sfc, o) || ShellSf[sfc] != i) { CGAL_NEF_TRACEN("the shell encloses a volume"); CGAL_NEF_TRACEN("sface hit? "<sncp()->new_volume(); mark(c) = SD.mark(f); // TODO: test if line is redundant link_as_inner_shell(f, c ); CGAL_NEF_TRACE( "Shell #" << i <<" linked as inner shell"); CGAL_NEF_TRACEN( "(sface" << (CGAL::assign(sfc,o)?"":" not") << " hit case)"); } } } minVertex = v_min; // finaly, we go through all the Shells which do not correspond to a Volume // and we assign them to its enclosing Volume determined via a facet below // check. // Progress_indicator_clog progress3 // ( this->sncp()->number_of_sfaces(), // "SNC_constructor: finding nesting structure..."); CGAL_forall_sfaces(f,*this->sncp()) { // progress3++; if ( Base::volume(f) != Volume_handle() ) continue; CGAL_NEF_TRACEN( "Outer shell #" << ShellSf[f] << " volume?"); Volume_handle c = determine_volume( MinimalSFace[ShellSf[f]], MinimalSFace, ShellSf ); c->mark() = f->mark(); link_as_outer_shell( f, c ); } } Halffacet_handle get_facet_below( Vertex_handle vi, const std::vector< SFace_handle>& MinimalSFace, const Sface_shell_hash& Shell) const { // {\Mop determines the facet below a vertex |vi| via ray shooting. } Halffacet_handle f_below; Point_3 p = point(vi); if(!Infi_box::is_standard(p)) return Halffacet_handle(); Ray_3 ray = Ray_3(p, Direction_3(-1,0,0)); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION number_of_ray_shooting_queries++; timer_ray_shooting.start(); #endif Object_handle o = pl->shoot(ray); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION timer_ray_shooting.stop(); #endif // The ray here has an special property since it is shooted from the lowest // vertex in a shell, so it would be expected that the ray goes along the // interior of a volume before it hits a 2-skeleton element. // Unfortunatelly, it seems to be possible that several shells are incident // to this lowest vertex, and in consequence, the ray could also go along // an edge or a facet belonging to a different shell. // This fact invalidates the precondition of the get_visible_facet method, // (the ray must pierce the local view of the hit object in a sface). // This situation has not been analyzed and has to be verified. Granados. Vertex_handle v; Halfedge_handle e; Halffacet_handle f; CGAL_NEF_TRACEN("get_facet_below"); if( CGAL::assign(v, o)) { CGAL_NEF_TRACEN("facet below from from vertex..."); f_below = get_visible_facet(v, ray); if( f_below == Halffacet_handle()) { CGAL_assertion(v->sfaces_begin() == v->sfaces_last()); f_below = get_facet_below(vertex(MinimalSFace[Shell[v->sfaces_begin()]]), MinimalSFace,Shell); } } else if( CGAL::assign(e, o)) { CGAL_NEF_TRACEN("facet below from from edge..."); f_below = get_visible_facet(e, ray); if( f_below == Halffacet_handle()) { CGAL_assertion(vertex(e)->sfaces_begin() == vertex(e)->sfaces_last()); f_below = get_facet_below(vertex(MinimalSFace[Shell[vertex(e)->sfaces_begin()]]), MinimalSFace, Shell); } } else if( CGAL::assign(f, o)) { CGAL_NEF_TRACEN("facet below from from facet..."); f_below = get_visible_facet(f, ray); CGAL_assertion( f_below != Halffacet_handle()); } else { CGAL_NEF_TRACEN("no facet below found..."); } return f_below; } Volume_handle determine_volume( SFace_handle sf, const std::vector< SFace_handle>& MinimalSFace, const Sface_shell_hash& Shell ) const { //{\Mop determines the volume |C| that a shell |S| pointed by |sf| // belongs to. \precondition |S| separates the volume |C| from an enclosed // volume.} CGAL_NEF_TRACEN("determine volume"); Vertex_handle v_min = vertex(MinimalSFace[Shell[sf]]); Halffacet_handle f_below = get_facet_below(v_min, MinimalSFace, Shell); if ( f_below == Halffacet_handle()) return Base(*this).volumes_begin(); Volume_handle c = Base::volume(f_below); if( c != Volume_handle()) { CGAL_NEF_TRACE( "Volume " << &*c << " hit "); CGAL_NEF_TRACEN("(Shell #" << Shell[adjacent_sface(f_below)] << ")"); return c; } SFace_handle sf_below = adjacent_sface(f_below); CGAL_NEF_TRACE( "Shell not assigned to a volume hit "); CGAL_NEF_TRACEN( "(Inner shell #" << Shell[sf_below] << ")"); c = determine_volume( sf_below, MinimalSFace, Shell); link_as_inner_shell( sf_below, c); return c; } public: Point_3 get_transformed_coords_of_vertex(const Point_3& p, const std::list& segs1, const std::list& segs2) { CGAL_assertion(!segs1.empty() && !segs2.empty()); int side_of_point=1; RT max = p.hx(); if(CGAL_NTS abs(p.hy()) > CGAL_NTS abs(max)) { max = p.hy(); side_of_point=2; } if(CGAL_NTS abs(p.hz()) > CGAL_NTS abs(max)) { max = p.hz(); side_of_point=3; } if(max < RT(0)) side_of_point = -side_of_point; typename std::list::const_iterator s1,s2,t1,t2; s1 = Infi_box::segment_on_side(side_of_point, segs1); t1 = s1; ++t1; if(t1 == segs1.end()) t1=segs1.begin(); s2 = Infi_box::segment_on_side(side_of_point, segs2); t2 = s2; ++t2; if(t2 == segs2.end()) t2=segs2.begin(); SNC_intersection is; Point_3 ip; bool flag=is.does_intersect_internally(Segment_3(*s1,*t1),Segment_3(*s2,*t2),ip); if(!flag) if(*s1 == *s2) return normalized(*s1); else if(*s1 == *t2) return normalized(*s1); else if(*t1 == *s2) return normalized(*t1); else if(*t1 == *t2) return normalized(*t1); return normalized(ip); } Point_3 transform_point_on_infibox(const Point_3& p, const Aff_transformation_3& aff) { Point_3 res(p.transform(aff)); res = normalized(p); RT hw(CGAL_NTS abs(res.hx())); if(CGAL_NTS abs(res.hy()) > hw) hw = CGAL_NTS abs(res.hy()); if(CGAL_NTS abs(res.hz()) > hw) hw = CGAL_NTS abs(res.hz()); CGAL_assertion(hw.degree() == 1); CGAL_assertion(hw[0] == 0); return Point_3(res.hx(), res.hy(), res.hz(), hw(1)); } bool erase_redundant_vertices() { std::list redundant_points; Vertex_iterator v; CGAL_forall_vertices(v, *this->sncp()) if(!is_standard(v)) redundant_points.push_back(v); redundant_points.sort(Frame_point_lt()); typename std::list::iterator vi, vinext; for(vi = redundant_points.begin(); vi != redundant_points.end(); ++vi) { vinext = vi; ++vinext; if(vinext == redundant_points.end()) break; if(point(*vi) == point(*vinext)) { CGAL_assertion(!Infi_box::is_complex_facet_infibox_intersection(**vi)); this->sncp()->delete_vertex(*vi); } } NT eval(Infi_box::compute_evaluation_constant_for_halfedge_pairup(*this->sncp())); bool res; do { res = false; typedef Halfedge_key< Point_3, Halfedge_handle, SNC_decorator> Halfedge_key; typedef Halfedge_key_lt< Point_3, Halfedge_handle, SNC_decorator> Halfedge_key_lt; typedef std::list Halfedge_list; typedef typename Standard_kernel::Kernel_tag Kernel_tag; typedef CGAL::Pluecker_line_3 Pluecker_line_3; typedef CGAL::Pluecker_line_lt Pluecker_line_lt; typedef std::map< Pluecker_line_3, Halfedge_list, Pluecker_line_lt> Pluecker_line_map; Unique_hash_map erase_vertex(false); std::list recreate; SNC_decorator D(*this); Pluecker_line_map M2; Pluecker_line_map M3; Pluecker_line_map M4; Halfedge_iterator e; CGAL_forall_halfedges(e,*this->sncp()) { Point_3 p = point(vertex(e)); Point_3 q = p + e->vector(); Standard_point_3 sp = Infi_box::standard_point(p,eval); Standard_point_3 sq = Infi_box::standard_point(q,eval); Pluecker_line_3 l( sp, sq); int inverted; l = categorize( l, inverted); CGAL_NEF_TRACEN(" segment("<vector()<<")"<< " line("<first); it->second.sort(Halfedge_key_lt()); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; CGAL_NEF_TRACE(" " << point(vertex(e1)) << " -> "); ++itl; if(itl == it->second.end()) { erase_vertex[e1->source()] = true; break; } Halfedge_handle e2 = itl->e; CGAL_NEF_TRACE(point(vertex(e2))); if(normalized(e1->vector())!=normalized(-e2->vector())) { erase_vertex[e1->source()] = true; --itl; CGAL_NEF_TRACE(" failed "); } CGAL_NEF_TRACEN(""); } CGAL_NEF_TRACEN(""); CGAL_NEF_TRACEN(""); } CGAL_forall_iterators(it,M3) { CGAL_NEF_TRACEN("search opposite "<first); it->second.sort(Halfedge_key_lt()); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; CGAL_NEF_TRACE(" " << point(vertex(e1)) << " -> "); ++itl; if(itl == it->second.end()) { erase_vertex[e1->source()] = true; break; } Halfedge_handle e2 = itl->e; CGAL_NEF_TRACE(point(vertex(e2))); if(normalized(e1->vector())!=normalized(-e2->vector())) { erase_vertex[e1->source()] = true; --itl; CGAL_NEF_TRACE(" failed "); } CGAL_NEF_TRACEN(""); } CGAL_NEF_TRACEN(""); CGAL_NEF_TRACEN(""); } CGAL_forall_iterators(it,M2) { CGAL_NEF_TRACEN("search opposite "<first); it->second.sort(Halfedge_key_lt()); typename Halfedge_list::iterator itl; CGAL_forall_iterators(itl,it->second) { Halfedge_handle e1 = itl->e; CGAL_NEF_TRACE(" " << point(vertex(e1)) << " -> "); ++itl; if(itl == it->second.end()) { erase_vertex[e1->source()] = true; break; } Halfedge_handle e2 = itl->e; CGAL_NEF_TRACE(point(vertex(e2))); if(normalized(e1->vector())!=normalized(-e2->vector())) { erase_vertex[e1->source()] = true; --itl; CGAL_NEF_TRACE(" failed "); } CGAL_NEF_TRACEN(""); } CGAL_NEF_TRACEN(""); CGAL_NEF_TRACEN(""); } Vertex_iterator v; CGAL_forall_vertices(v, *this->sncp()) if(erase_vertex[v]) { CGAL_NEF_TRACEN("erase " << v->point()); if(Infi_box::is_infibox_corner(v->point())) recreate.push_back(v->point()); this->sncp()->delete_vertex(v); res = true; } typename std::list::const_iterator pi; for(pi = recreate.begin(); pi != recreate.end(); ++pi) create_from_point_on_infibox_vertex(*pi); } while(res); return res; } std::list find_points_of_box_with_plane(const Plane_3& h) { Vector_3 orth = h.orthogonal_vector(); NT orth_coords[3]; orth_coords[0] = orth.hx()[0]; orth_coords[1] = orth.hy()[0]; orth_coords[2] = orth.hz()[0]; int add_corners = 0; while(orth_coords[add_corners] == 0){ CGAL_assertion(add_corners < 2); ++add_corners; } std::list points; for(int dir=0; dir<3;++dir) { NT cnst[3]; for(int i=0; i<3;++i) cnst[i] = (i==dir? -h.d()[0] : 0); NT cross[4][4]; cross[0][dir] = -orth_coords[(dir+1)%3]-orth_coords[(dir+2)%3]; cross[1][dir] = orth_coords[(dir+1)%3]-orth_coords[(dir+2)%3]; cross[2][dir] = orth_coords[(dir+1)%3]+orth_coords[(dir+2)%3]; cross[3][dir] = -orth_coords[(dir+1)%3]+orth_coords[(dir+2)%3]; for(int i=0;i<4;++i) cross[i][3] = orth_coords[dir]; cross[0][(dir+1)%3] = cross[3][(dir+1)%3] = orth_coords[dir]; cross[1][(dir+1)%3] = cross[2][(dir+1)%3] = -orth_coords[dir]; cross[0][(dir+2)%3] = cross[1][(dir+2)%3] = orth_coords[dir]; cross[2][(dir+2)%3] = cross[3][(dir+2)%3] = -orth_coords[dir]; for(int i=0; i<4; ++i) if(CGAL_NTS abs(RT(cnst[dir],cross[i][dir])) < CGAL_NTS abs(RT(0,orth_coords[dir])) || (CGAL_NTS abs(RT(cnst[dir],cross[i][dir])) == CGAL_NTS abs(RT(0,orth_coords[dir])) && dir == add_corners)) points.push_back(Point_3(RT(cnst[0], cross[i][0]), RT(cnst[1], cross[i][1]), RT(cnst[2], cross[i][2]), RT(cross[i][3]))); } for(int i=0;i<3;++i) orth_coords[i] = CGAL_NTS abs(orth_coords[i]); int max = 0; if(orth_coords[1] > orth_coords[0]) max = 1; if(orth_coords[2] > orth_coords[max]) max = 2; int min = 0; if(orth_coords[1] < orth_coords[0]) min = 1; if(orth_coords[2] < orth_coords[min]) min = 2; points.sort(circle_lt(max)); typename std::list::const_iterator p; for(p=points.begin();p!=points.end();++p) CGAL_NEF_TRACEN(*p); return points; } std::list find_facet_infibox_intersections(Halffacet_handle fi, std::list points) { // points is a list of the required points, but with the inverse transformation applied std::list res; Halffacet_cycle_iterator fc = fi->facet_cycles_begin(); CGAL_assertion(fc.is_shalfedge()); SHalfedge_handle sh(fc); SHalfedge_around_facet_circulator fcc(sh), fend(fcc); CGAL_For_all(fcc,fend) { Point_3 src(fcc->source()->source()->point()); Point_3 trg(fcc->source()->twin()->source()->point()); typename std::list::iterator pi,pprev; pi = points.begin(); while(pi != points.end()) { *pi = normalized(*pi); // std::cerr << src << "->" << trg << " has on " << *pi << src.x() << " : " << std::endl; // std::cerr << (src.x()-pi->x() <= 0) << "|" << (src.y()-pi->y() <= 0) << "|" << (src.z()-pi->z() <= 0) << std::endl; // std::cerr << (pi->x()-trg.x() <= 0) << "|" << (pi->y()-trg.y() <= 0) << "|" << (pi->z()-trg.z() <= 0) << std::endl; if((src.x()-pi->x() <= 0 && pi->x()-trg.x() <= 0 || src.x()-pi->x() >= 0 && pi->x()-trg.x() >= 0) && (src.y()-pi->y() <= 0 && pi->y()-trg.y() <= 0 || src.y()-pi->y() >= 0 && pi->y()-trg.y() >= 0) && (src.z()-pi->z() <= 0 && pi->z()-trg.z() <= 0 || src.z()-pi->z() >= 0 && pi->z()-trg.z() >= 0)) { // std::cerr << "true" << std::endl; pprev = pi; ++pi; res.push_back(*pprev); points.erase(pprev); } else { // std::cerr << "false" << std::endl; ++pi; } } } return res; } std::list create_vertices_on_infibox(const Plane_3& h, const std::list points, const Mark& bnd, const Mark& inside, const Mark& outside) { std::list res; NT orth_coords[3]; int min,max; Infi_box::compute_min_max(h,orth_coords,min,max); typename std::list::const_iterator p,prev,next; for(p=points.begin();p!=points.end();++p){ if(p==points.begin()) prev = --points.end(); else { prev = p; prev--;} if(p==--points.end()) next=points.begin(); else {next = p; ++next;} CGAL_NEF_TRACEN("points " << *prev << " " << *p << " " << *next); Vector_3 v= *prev - *p; Sphere_point sp1(v); sp1 = normalized(sp1); CGAL_assertion(Infi_box::degree(sp1.hx()) == 0); CGAL_assertion(Infi_box::degree(sp1.hy()) == 0); CGAL_assertion(Infi_box::degree(sp1.hz()) == 0); CGAL_assertion(Infi_box::degree(sp1.hw()) == 0); v= *next - *p; Sphere_point sp2(v); sp2 = normalized(sp2); CGAL_assertion(Infi_box::degree(sp2.hx()) == 0); CGAL_assertion(Infi_box::degree(sp2.hy()) == 0); CGAL_assertion(Infi_box::degree(sp2.hz()) == 0); CGAL_assertion(Infi_box::degree(sp2.hw()) == 0); CGAL_NEF_TRACEN("sps " << sp1 << " " << sp2); CGAL_NEF_TRACEN(orth_coords[min] << "|" << orth_coords[(min+1)%3] << "|" << orth_coords[(min+2)%3]); if(orth_coords[min]==0 && orth_coords[(min+1)%3] == orth_coords[(min+2)%3] && h.d() == 0) res.push_back(create_degenerate_corner_frame_point(*p,sp1,sp2,min,max,h,bnd,inside,outside)); else if(CGAL_NTS abs(p->hx()) == CGAL_NTS abs(p->hy()) && CGAL_NTS abs(p->hz()) == CGAL_NTS abs(p->hy())) res.push_back(create_corner_frame_point(*p,sp1,sp2,max,h,bnd,inside,outside)); else res.push_back(create_frame_point(*p,sp1,sp2,h,bnd,inside,outside)); } return res; } void create_vertices_of_box_with_plane(const Plane_3& h, bool b) { // CGAL_NEF_SETDTHREAD(19*43*11); std::list points(find_points_of_box_with_plane(h)); create_vertices_on_infibox(h,points,b,true,false); RT sum= h.a()+h.b()+h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner( 1, 1, 1, (sum<0 || (sum == 0 && h.d()<0))); } sum=-h.a()+h.b()+h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner(-1, 1, 1, (sum<0 || (sum == 0 && h.d()<0))); } sum= h.a()-h.b()+h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner( 1,-1, 1, (sum<0 || (sum == 0 && h.d()<0))); } sum=-h.a()-h.b()+h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner(-1,-1, 1, (sum<0 || (sum == 0 && h.d()<0))); } sum= h.a()+h.b()-h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner( 1, 1,-1, (sum<0 || (sum == 0 && h.d()<0))); } sum=-h.a()+h.b()-h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner(-1, 1,-1, (sum<0 || (sum == 0 && h.d()<0))); } sum= h.a()-h.b()-h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner( 1,-1,-1, (sum<0 || (sum == 0 && h.d()<0))); } sum=-h.a()-h.b()-h.c(); if(h.d()!=0 || sum!= 0) { CGAL_NEF_TRACEN(sum); create_extended_box_corner(-1,-1,-1, (sum<0 || (sum == 0 && h.d()<0))); } } Vertex_handle create_frame_point(Point_3 p, Point_3 sp1, Point_3 sp2, Plane_3 h, const Mark& boundary, const Mark& inside, const Mark& outside) const { if(h.d() == 0) { CGAL_assertion(CGAL_NTS abs(p.hy()) != CGAL_NTS abs(p.hx()) || CGAL_NTS abs(p.hz()) != CGAL_NTS abs(p.hx())); } int max = 0; if(CGAL_NTS abs(p.hx()) > CGAL_NTS abs(p.hy())) max = 1; if(CGAL_NTS abs(p.hx()) > CGAL_NTS abs(p.hz())) max = 2; CGAL_NEF_TRACEN("create frame point "); CGAL_NEF_TRACEN("create spoints"); Sphere_point SP[4]; switch(max) { case 0: SP[2] = Sphere_point(1,0,0); break; case 1: SP[2] = Sphere_point(0,1,0); break; case 2: SP[2] = Sphere_point(0,0,1); break; default: CGAL_assertion_msg(0,"wrong value"); } SP[1]=sp1; SP[0]=sp2; if (spherical_orientation(SP[0],SP[1],SP[2]) < 0) { SP[3] = SP[2]; SP[2] = CGAL::ORIGIN-SP[3]; } else SP[3] = CGAL::ORIGIN-SP[2]; RT delta = h.a()*SP[2].hx()+h.b()*SP[2].hy()+h.c()*SP[2].hz(); CGAL_assertion(delta !=0); Mark swtch = (delta < 0); Mark fmark0 = (swtch && inside) || (!swtch && !inside); Mark fmark1 = (swtch && outside) || (!swtch && !outside); return create_SM_on_infibox(p, SP, 4, boundary, fmark0, fmark1); } Vertex_handle create_corner_frame_point(Point_3 p, Point_3 sp1, Point_3 sp2, int max, Plane_3 h, const Mark& boundary, const Mark& inside, const Mark& outside) const { CGAL_assertion(h.d() == 0); Vector_3 vec = h.orthogonal_vector(); CGAL_assertion(CGAL_NTS abs(vec.hx()) != CGAL_NTS abs(vec.hy()) && CGAL_NTS abs(vec.hy()) != CGAL_NTS abs(vec.hz()) && CGAL_NTS abs(vec.hx()) != CGAL_NTS abs(vec.hz())); CGAL_assertion(vec.hx() + vec.hy() == vec.hz() || vec.hx() + vec.hz() == vec.hy() || vec.hy() + vec.hz() == vec.hx()); CGAL_NEF_TRACEN("create corner frame point "); RT vp[3]; vp[0] = -p.hx()[1]; vp[1] = -p.hy()[1]; vp[2] = -p.hz()[1]; CGAL_NEF_TRACEN("create spoints"); Sphere_point SP[5]; switch(max) { case 0: SP[3] = Sphere_point(0,vp[1],0); SP[2]= Sphere_point(0,0,vp[2]); SP[4] = Sphere_point(vp[0],0,0); break; case 1: SP[3] = Sphere_point(vp[0],0,0); SP[2]= Sphere_point(0,0,vp[2]); SP[4] = Sphere_point(0,vp[1],0); break; case 2: SP[3] = Sphere_point(vp[0],0,0); SP[2]= Sphere_point(0,vp[1],0); SP[4] = Sphere_point(0,0,vp[2]); break; default: CGAL_assertion_msg(0,"wrong value"); } if (spherical_orientation(SP[3],Sphere_point(sp1),Sphere_point(sp2)) > 0) { SP[0] = sp1; SP[1] = sp2; } else { SP[0] = sp2; SP[1] = sp1; } if (spherical_orientation(SP[2],SP[3],SP[0]) < 0) { Sphere_point sx = SP[2]; SP[2] = SP[3]; SP[3] = sx; } RT delta = h.a()*SP[4].hx()+h.b()*SP[4].hy()+h.c()*SP[4].hz(); CGAL_assertion(delta !=0); Mark swtch = (delta > 0); Mark fmark0 = (swtch && inside) || (!swtch && !inside); Mark fmark1 = (swtch && outside) || (!swtch && !outside); return create_SM_on_infibox(p, SP, 5, boundary, fmark0, fmark1); } Vertex_handle create_degenerate_corner_frame_point(Point_3 p, Point_3 sp1,Point_3 sp2, int min,int max, Plane_3 h, const Mark& boundary, const Mark& inside, const Mark& outside)const { CGAL_assertion(h.d() == 0); Vector_3 vec = h.orthogonal_vector(); CGAL_assertion( (CGAL_NTS abs(vec.hx()) == CGAL_NTS abs(vec.hy()) && vec.hz() == 0) || (CGAL_NTS abs(vec.hy()) == CGAL_NTS abs(vec.hz()) && vec.hx() == 0) || (CGAL_NTS abs(vec.hx()) == CGAL_NTS abs(vec.hz()) && vec.hy() == 0)); RT vp[3]; vp[0] = -p.hx()[1]; vp[1] = -p.hy()[1]; vp[2] = -p.hz()[1]; CGAL_NEF_TRACEN("create degenerate corner frame point "); CGAL_NEF_TRACEN("create spoints"); Sphere_point SP[4]; switch(max) { case 0: SP[2] = Sphere_point(vp[0],0,0); break; // plane(x,x,0), plane(x,0,x) case 1: SP[2] = Sphere_point(0,vp[1],0); break; // plane(0,x,x) default: CGAL_assertion_msg(0,"wrong value \"max\""); } switch(min+max) { case 1: SP[3] = Sphere_point(0,0,vp[2]); break; // plane(0,x,x), plane(x,0,x) case 2: SP[3] = Sphere_point(0,vp[1],0); break; // plane(x,x,0) default: CGAL_assertion_msg(0,"wrong value \"min+max\""); } if (spherical_orientation(SP[2],Sphere_point(sp1),Sphere_point(sp2)) > 0) { SP[0] = sp1; SP[1] = sp2; } else { SP[0] = sp2; SP[1] = sp1; } RT delta = h.a()*SP[2].hx()+h.b()*SP[2].hy()+h.c()*SP[2].hz(); CGAL_assertion(delta !=0); Mark swtch = (delta < 0); Mark fmark0 = (swtch && inside) || (!swtch && !inside); Mark fmark1 = (swtch && outside) || (!swtch && !outside); return create_SM_on_infibox(p, SP, 4, boundary, fmark0, fmark1); } Vertex_handle create_SM_on_infibox(const Point_3& center, Sphere_point* SP, int size, const Mark& boundary, const Mark& fmark0, const Mark& fmark1) const { Vertex_handle v=this->sncp()->new_vertex(normalized(center), boundary); SM_decorator SD(&*v); CGAL_NEF_TRACEN("create_SM_on_infibox: center = " << center); CGAL_NEF_TRACEN("create svertices"); std::vector sv(size); CGAL_NEF_TRACEN("create_SM_on_infibox: size = " << size); for(int i=0; i she(size+1); for(int si=0; si O0(std::cout,*this->sncp()); // O0.print(); link_shalfedges_to_facet_cycles(); categorize_facet_cycles_and_create_facets(); create_volumes(); #ifdef CGAL_NEF3_TIMER_EXTERNAL_STRUCTURE timer_external_structure.stop(); if(cgal_nef3_timer_on) std::cout << "Runtime_external_structure: " << timer_external_structure.time() << std::endl; #endif } void clear_external_structure() { this->sncp()->clear_boundary(); while(this->sncp()->volumes_begin()!= this->sncp()->volumes_end()) this->sncp()->delete_volume(this->sncp()->volumes_begin()); while(this->sncp()->halffacets_begin()!= this->sncp()->halffacets_end()) this->sncp()->delete_halffacet_pair(this->sncp()->halffacets_begin()); } void correct_infibox_sface_marks() { Vertex_iterator v; CGAL_forall_vertices(v,*this->sncp()) { if(is_standard(v) || Infi_box::is_infibox_corner(point(v))) continue; SM_decorator SD(&*v); SFace_iterator sf; CGAL_forall_sfaces(sf, SD) sf->volume()->mark() = sf->mark(); } CGAL_forall_vertices(v,*this->sncp()) { if(is_standard(v) || !Infi_box::is_infibox_corner(point(v))) continue; SM_decorator SD(&*v); SFace_iterator sf; CGAL_forall_sfaces(sf, SD) sf->mark() = sf->volume()->mark(); } } void correct_infibox_sedge_marks() { SHalfedge_iterator se; Vertex_iterator v; CGAL_forall_vertices(v,*this->sncp()) { if(is_standard(v)) continue; SM_decorator SD(&*v); CGAL_forall_shalfedges(se,SD) if(Infi_box::is_sedge_on_infibox(se)) { se->mark() = true; se->source()->mark() = true; } } } }; // SNC_constructor CGAL_END_NAMESPACE #endif //CGAL_SNC_CONSTRUCTOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_items.h0000644000175000017500000010625311344301501027757 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_items.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner // Peter Hachenberger #ifndef CGAL_SNC_ITEMS_H #define CGAL_SNC_ITEMS_H #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 83 #include CGAL_BEGIN_NAMESPACE template class SNC_sphere_map; template class SM_decorator; class SNC_items { public: //----------------------------------------------------------------------------- template class Vertex { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Point_3 Point_3; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::SHalfloop_handle SHalfloop_handle; typedef typename Refs::Vertex_iterator Vertex_iterator; typedef typename Refs::SVertex_iterator SVertex_iterator; typedef typename Refs::SHalfedge_iterator SHalfedge_iterator; typedef typename Refs::SHalfloop_iterator SHalfloop_iterator; typedef typename Refs::SFace_iterator SFace_iterator; typedef typename Refs::Vertex_const_iterator Vertex_const_iterator; typedef typename Refs::SVertex_const_iterator SVertex_const_iterator; typedef typename Refs::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Refs::SFace_const_iterator SFace_const_iterator; typedef typename Refs::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Refs::Size_type Size_type; Point_3 point_at_center_; Mark mark_; // local view (surface graph): public: Refs* sncp_; SVertex_iterator svertices_begin_, svertices_last_; SHalfedge_iterator shalfedges_begin_, shalfedges_last_; SFace_iterator sfaces_begin_, sfaces_last_; SHalfloop_iterator shalfloop_; GenPtr info_; public: Vertex() : point_at_center_(), mark_(), sncp_(), svertices_begin_(), svertices_last_(), shalfedges_begin_(), shalfedges_last_(), sfaces_begin_(), sfaces_last_(), shalfloop_(), info_() // , sm_(Vertex_handle((SNC_in_place_list_vertex*) this)) {} Vertex(const Point_3& p, Mark m) : point_at_center_(p), mark_(m), sncp_(), svertices_begin_(), svertices_last_(), shalfedges_begin_(), shalfedges_last_(), sfaces_begin_(), sfaces_last_(), shalfloop_(), info_() // , sm_(Vertex_handle((SNC_in_place_list_vertex*) this)) {} Vertex(const Vertex& v) // : sm_(Vertex_handle((SNC_in_place_list_vertex*)this)) { point_at_center_ = v.point_at_center_; mark_ = v.mark_; sncp_ = v.sncp_; svertices_begin_ = v.svertices_begin_; svertices_last_ = v.svertices_last_; shalfedges_begin_ = v.shalfedges_begin_; shalfedges_last_ = v.shalfedges_last_; sfaces_begin_ = v.sfaces_begin_; sfaces_last_ = v.sfaces_last_; shalfloop_ = v.shalfloop_; info_ = 0; } Vertex& operator=(const Vertex& v) { if (this == &v) return *this; point_at_center_ = v.point_at_center_; mark_ = v.mark_; sncp_ = v.sncp_; svertices_begin_ = v.svertices_begin_; svertices_last_ = v.svertices_last_; shalfedges_begin_ = v.shalfedges_begin_; shalfedges_last_ = v.shalfedges_last_; sfaces_begin_ = v.sfaces_begin_; sfaces_last_ = v.sfaces_last_; shalfloop_ = v.shalfloop_; return *this; } Refs* sncp() const { return sncp_; } Refs*& sncp() { return sncp_; } /* all sobjects of the local graph are stored in a global list where each vertex has a continous range in each list for its sobjects. All objects of the range [sxxx_begin_,sxxx_last_] belong to a vertex. This range is empty iff sxxx_begin_ == sxxx_last_ == sncp()->sxxx_end() ( the latter being the standard end iterator of the corresponding list ) for the past the end iterator we have to increment sxxx_last_ once iff the range is non-empty. */ void init_range(SVertex_iterator it) { svertices_begin_ = svertices_last_ = it; } void init_range(SHalfedge_iterator it) { shalfedges_begin_ = shalfedges_last_ = it; } void init_range(SFace_iterator it) { sfaces_begin_ = sfaces_last_ = it; } SVertex_iterator& svertices_begin() { return svertices_begin_; } SVertex_iterator& svertices_last() { return svertices_last_; } SVertex_iterator svertices_end() { if ( svertices_last_ == sncp()->svertices_end() ) return svertices_last_; else return ++SVertex_iterator(svertices_last_); } SHalfedge_iterator& shalfedges_begin() { return shalfedges_begin_; } SHalfedge_iterator& shalfedges_last() { return shalfedges_last_; } SHalfedge_iterator shalfedges_end() { if ( shalfedges_last_ == sncp()->shalfedges_end() ) return shalfedges_last_; else return ++SHalfedge_iterator(shalfedges_last_); } SFace_iterator& sfaces_begin() { return sfaces_begin_; } SFace_iterator& sfaces_last() { return sfaces_last_; } SFace_iterator sfaces_end() { if ( sfaces_last_ == sncp()->sfaces_end() ) return sfaces_last_; else return ++SFace_iterator(sfaces_last_); } SVertex_const_iterator svertices_begin() const { return svertices_begin_; } SVertex_const_iterator svertices_last() const { return svertices_last_; } SVertex_const_iterator svertices_end() const { if ( svertices_last_ == sncp()->svertices_end() ) return svertices_last_; else return ++SVertex_const_iterator(svertices_last_); } SHalfedge_const_iterator shalfedges_begin() const { return shalfedges_begin_; } SHalfedge_const_iterator shalfedges_last() const { return shalfedges_last_; } SHalfedge_const_iterator shalfedges_end() const { if ( shalfedges_last_ == sncp()->shalfedges_end() ) return shalfedges_last_; else return ++SHalfedge_const_iterator(shalfedges_last_); } SFace_const_iterator sfaces_begin() const { return sfaces_begin_; } SFace_const_iterator sfaces_last() const { return sfaces_last_; } SFace_const_iterator sfaces_end() const { if ( sfaces_last_ == sncp()->sfaces_end() ) return sfaces_last_; else return ++SFace_const_iterator(sfaces_last_); } SHalfloop_handle& shalfloop() { return shalfloop_; } SHalfloop_handle shalfloop() const { return shalfloop_; } bool has_shalfloop() const { return shalfloop_ != sncp()->shalfloops_end(); } Size_type number_of_svertices() const /*{\Mop returns the number of vertices.}*/ { Size_type n(0); SVertex_const_iterator vit; CGAL_forall_svertices(vit, *this) ++n; return n; } Size_type number_of_shalfedges() const /*{\Mop returns the number of halfedges.}*/ { Size_type n(0); SHalfedge_const_iterator eit; CGAL_forall_shalfedges(eit, *this) ++n; return n;} Size_type number_of_sedges() const /*{\Mop returns the number of edges.}*/ { return number_of_shalfedges()/2; } Size_type number_of_shalfloops() const /*{\Mop returns the number of halfloops.}*/ { return ( has_shalfloop() ? 2 : 0); } Size_type number_of_sloops() const /*{\Mop returns the number of loops.}*/ { return number_of_shalfloops()/2; } Size_type number_of_sfaces() const /*{\Mop returns the number of faces.}*/ { Size_type n(0); SFace_const_iterator fit; CGAL_forall_sfaces(fit, *this) ++n; return n; } /*{\Xtext Vertices provide access to their local graphs via the iterator ranges: \begin{Mverb} SVertex_iterator svertices_begin()/svertices_end() SHalfedge_iterator shalfedges_begin()/shalfedges_end() SFace_iterator sfaces_begin()/sfaces_end() SHalfloop_handle shalfloop() \end{Mverb} }*/ void clear() /*{\Xop clears the local graph.}*/ { SFace_iterator fit = sfaces_begin(), fend = sfaces_end(); while (fit != fend) { SFace_iterator fdel = fit++; /* TO VERIFY: next statement needs access to a private attribute */ sncp()->reset_sm_object_list(fdel->boundary_entry_objects_); sncp()->delete_sface_only(fdel); } sfaces_begin_ = sfaces_last_ = sncp()->sfaces_end(); if ( shalfloop() != sncp()->shalfloops_end() ) { sncp()->delete_shalfloop_only(shalfloop_->twin()); sncp()->delete_shalfloop_only(shalfloop_); shalfloop_ = sncp()->shalfloops_end(); } SHalfedge_iterator eit = shalfedges_begin(), eend = shalfedges_end(); while (eit != eend) { SHalfedge_iterator edel = eit++; sncp()->delete_shalfedge_only(edel); } shalfedges_begin_ = shalfedges_last_ = sncp()->shalfedges_end(); SVertex_iterator vit = svertices_begin(), vend = svertices_end(); while (vit != vend) { SVertex_iterator vdel = vit++; sncp()->delete_halfedge_only(vdel); } svertices_begin_ = svertices_last_ = sncp()->halfedges_end(); } Point_3& point() { return point_at_center_; } const Point_3& point() const { return point_at_center_; } Mark& mark() { return mark_; } const Mark& mark() const { return mark_;} GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } ~Vertex() { CGAL_NEF_TRACEN(" destroying Vertex item "<<&*this); } public: std::string debug() const { std::stringstream os; set_pretty_mode(os); os<<"{ addr, point, mark, snc, svb, sve, seb, see, sfb, sfe, sl," <<" info }"<svertices_end()) CGAL_assertion(svertices_end() == sncp()->svertices_end()); if(shalfedges_begin_ == sncp()->shalfedges_end()) CGAL_assertion(shalfedges_end() == sncp()->shalfedges_end()); if(sfaces_begin_ == sncp()->sfaces_end()) CGAL_assertion(sfaces_end() == sncp()->sfaces_end()); */ return true; } bool is_valid( bool verb = false, int level = 0) const { Verbose_ostream verr(verb); verr << "begin CGAL::SNC_items<...>::Vertex::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = (sncp_ != NULL); valid = valid && (svertices_begin_ != NULL && svertices_begin_ != SVertex_iterator()); valid = valid && (svertices_last_ != NULL && svertices_last_ != SVertex_iterator()); valid = valid && (shalfedges_begin_ != NULL && shalfedges_begin_ != SHalfedge_iterator()); valid = valid && (shalfedges_last_ != NULL && shalfedges_last_ != SHalfedge_iterator()); valid = valid && (sfaces_begin_ != NULL && sfaces_begin_ != SFace_iterator()); valid = valid && (sfaces_last_ != NULL && sfaces_last_ != SFace_iterator()); valid = valid && (shalfloop_ != NULL && shalfloop_ != SHalfloop_iterator()); if(shalfedges_begin_ == sncp()->shalfedges_end()) { // point in volume or on plane, which is either isolated or has one outgoing edge if(shalfloop_ != sncp()->shalfloops_end()) valid = valid && (++SFace_const_iterator(sfaces_begin_) == sfaces_last_); else valid = valid && (sfaces_begin_ == sfaces_last_); } valid = valid && (sfaces_begin_ != sncp()->sfaces_end()); if(sfaces_begin_ == sfaces_last_) { valid = valid && (shalfloop_ == sncp()->shalfloops_end()); } else valid = valid && (sfaces_begin_->sface_cycles_begin() != sfaces_begin_->sface_cycles_end()); verr << "end of CGAL::SNC_items<...>::Vertex::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // Vertex //----------------------------------------------------------------------------- template class SVertex { // == Halfedge typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Vector_3 Vector_3; typedef typename Refs::Sphere_point Sphere_point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::SVertex_handle SVertex_handle; typedef typename Refs::SHalfedge_handle SHalfedge_handle; typedef typename Refs::SFace_handle SFace_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::SVertex_const_handle SVertex_const_handle; typedef typename Refs::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Refs::SFace_const_handle SFace_const_handle; Vertex_handle center_vertex_; Mark mark_; SVertex_handle twin_; SHalfedge_handle out_sedge_; SFace_handle incident_sface_; GenPtr info_; Sphere_point point_; public: SVertex() : center_vertex_(), mark_(), twin_(), out_sedge_(), incident_sface_(), info_(), point_() {} SVertex(Mark m) : center_vertex_(), mark_(m), twin_(), out_sedge_(), incident_sface_(), info_(), point_() {} ~SVertex() { CGAL_NEF_TRACEN(" destroying Halfedge item "<<&*this); } SVertex(const SVertex& e) { center_vertex_ = e.center_vertex_; point_ = e.point_; mark_ = e.mark_; twin_ = e.twin_; out_sedge_ = e.out_sedge_; incident_sface_ = e.incident_sface_; info_ = 0; } SVertex& operator=(const SVertex& e) { center_vertex_ = e.center_vertex_; point_ = e.point_; mark_ = e.mark_; twin_ = e.twin_; out_sedge_ = e.out_sedge_; incident_sface_ = e.incident_sface_; info_ = 0; return *this; } Vertex_handle& center_vertex() { return center_vertex_; } Vertex_const_handle center_vertex() const { return center_vertex_; } Vertex_handle& source() { return center_vertex_; } Vertex_const_handle source() const { return center_vertex_; } Vertex_handle& target() { return twin()->source(); } Vertex_const_handle target() const { return twin()->source(); } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } Vector_3 vector() const { return (point_ - CGAL::ORIGIN); } Sphere_point& point(){ return point_; } const Sphere_point& point() const { return point_; } SVertex_handle& twin() { return twin_; } SVertex_const_handle twin() const { return twin_; } SHalfedge_handle& out_sedge() { return out_sedge_; } SHalfedge_const_handle out_sedge() const { return out_sedge_; } SFace_handle& incident_sface() { return incident_sface_; } SFace_const_handle incident_sface() const { return incident_sface_; } bool is_isolated() const { return (out_sedge() == SHalfedge_handle()); } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } public: std::string debug() const { std::stringstream os; set_pretty_mode(os); os<<"sv [ "<::SVertex::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = (center_vertex_ != NULL && center_vertex_ != Vertex_handle()); valid = valid && (twin_ != NULL && twin_ != SVertex_handle() && twin_ != SVertex_handle()); // valid = valid && (out_sedge_ != NULL); // valid = valid && (incident_sface_ != SFace_handle()); valid = valid &&((out_sedge_ != NULL && incident_sface_ == NULL) || (out_sedge_ == NULL && incident_sface_ != NULL)); verr << "end of CGAL::SNC_items<...>::SVertex::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // SVertex //----------------------------------------------------------------------------- template class Halffacet { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Plane_3 Plane_3; typedef typename Refs::Halffacet_handle Halffacet_handle; typedef typename Refs::Halffacet_const_handle Halffacet_const_handle; typedef typename Refs::Volume_handle Volume_handle; typedef typename Refs::Volume_const_handle Volume_const_handle; typedef typename Refs::Object_list Object_list; typedef typename Refs::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename Refs::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; Plane_3 supporting_plane_; Mark mark_; Halffacet_handle twin_; Volume_handle volume_; Object_list boundary_entry_objects_; // SEdges, SLoops public: Halffacet() : supporting_plane_(), mark_() {} Halffacet(const Plane_3& h, Mark m) : supporting_plane_(h), mark_(m) {} ~Halffacet() { CGAL_NEF_TRACEN(" destroying Halffacet item "<<&*this); } Halffacet(const Halffacet& f) { supporting_plane_ = f.supporting_plane_; mark_ = f.mark_; twin_ = f.twin_; CGAL_NEF_TRACEN("VOLUME const"); volume_ = f.volume_; boundary_entry_objects_ = f.boundary_entry_objects_; } Halffacet& operator=(const Halffacet& f) { if (this == &f) return *this; supporting_plane_ = f.supporting_plane_; mark_ = f.mark_; twin_ = f.twin_; CGAL_NEF_TRACEN("VOLUME op="); volume_ = f.volume_; boundary_entry_objects_ = f.boundary_entry_objects_; return *this; } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } Halffacet_handle& twin() { return twin_; } Halffacet_const_handle twin() const { return twin_; } Plane_3& plane() { return supporting_plane_; } const Plane_3& plane() const { return supporting_plane_; } Volume_handle& incident_volume() { return volume_; } Volume_const_handle incident_volume() const { return volume_; } Object_list& boundary_entry_objects() { return boundary_entry_objects_; } const Object_list& boundary_entry_objects() const { return boundary_entry_objects_; } GenPtr& info() { return this->info_; } const GenPtr& info() const { return this->info_; } Halffacet_cycle_iterator facet_cycles_begin() { return boundary_entry_objects_.begin(); } Halffacet_cycle_iterator facet_cycles_end() { return boundary_entry_objects_.end(); } Halffacet_cycle_const_iterator facet_cycles_begin() const { return boundary_entry_objects_.begin(); } Halffacet_cycle_const_iterator facet_cycles_end() const { return boundary_entry_objects_.end(); } bool is_twin() const { return (&*twin_ < this); } bool is_valid( bool verb = false, int level = 0) const { Verbose_ostream verr(verb); verr << "begin CGAL::SNC_items<...>::Halffacet::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = (twin_ != NULL && twin_ != Halffacet_handle()); valid = valid && (volume_ != NULL && volume_ != Volume_handle()); valid = valid && (supporting_plane_.a() != 0 || supporting_plane_.b() != 0 || supporting_plane_.c() != 0); valid = valid && (!boundary_entry_objects_.empty()); verr << "end of CGAL::SNC_items<...>::Halffacet::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // Halffacet //----------------------------------------------------------------------------- template class Volume { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Volume_handle Volume_handle; typedef typename Refs::Volume_const_handle Volume_const_handle; typedef typename Refs::Object_list Object_list; typedef typename Refs::Shell_entry_iterator Shell_entry_iterator; typedef typename Refs::Shell_entry_const_iterator Shell_entry_const_iterator; Mark mark_; Object_list shell_entry_objects_; // SFaces public: Volume() {} Volume(Mark m) : mark_(m) {} ~Volume() { CGAL_NEF_TRACEN(" destroying Volume item "<<&*this); } Volume(const Volume& v) { mark_ = v.mark_; shell_entry_objects_ = v.shell_entry_objects_; } Volume& operator=(const Volume& v) { if (this == &v) return *this; mark_ = v.mark_; shell_entry_objects_ = v.shell_entry_objects_; return *this; } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } GenPtr& info() { return this->info_; } const GenPtr& info() const { return this->info_; } Object_list& shell_entry_objects() { return shell_entry_objects_; } const Object_list& shell_entry_objects() const { return shell_entry_objects_; } Shell_entry_iterator shells_begin() { return shell_entry_objects_.begin(); } Shell_entry_iterator shells_end() { return shell_entry_objects_.end(); } Shell_entry_const_iterator shells_begin() const { return shell_entry_objects_.begin(); } Shell_entry_const_iterator shells_end() const { return shell_entry_objects_.end(); } bool is_valid( bool verb = false, int level = 0) const { Verbose_ostream verr(verb); verr << "begin CGAL::SNC_items<...>::Volume::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = (!shell_entry_objects_.empty()); verr << "end of CGAL::SNC_items<...>::Volume::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // Volume //----------------------------------------------------------------------------- template class SHalfedge { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Sphere_circle Sphere_circle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::SVertex_handle SVertex_handle; typedef typename Refs::SVertex_const_handle SVertex_const_handle; typedef typename Refs::SHalfedge_handle SHalfedge_handle; typedef typename Refs::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Refs::SFace_handle SFace_handle; typedef typename Refs::SFace_const_handle SFace_const_handle; typedef typename Refs::Halffacet_handle Halffacet_handle; typedef typename Refs::Halffacet_const_handle Halffacet_const_handle; // Role within local graph: SVertex_handle source_; SHalfedge_handle sprev_, snext_; SFace_handle incident_sface_; SHalfedge_handle twin_; // Topology within global Nef structure: SHalfedge_handle prev_, next_; Halffacet_handle facet_; GenPtr info_; // temporary needed: Mark mark_; Sphere_circle circle_; public: SHalfedge() : source_(), sprev_(), snext_(), incident_sface_(), twin_(), prev_(), next_(), facet_(), info_(), mark_(), circle_() {} ~SHalfedge() { CGAL_NEF_TRACEN(" destroying SHalfedge item "<<&*this); } SHalfedge(const SHalfedge& e) { source_ = e.source_; sprev_ = e.sprev_; snext_ = e.snext_; incident_sface_ = e.incident_sface_; twin_ = e.twin_; prev_ = e.prev_; next_ = e.next_; facet_ = e.facet_; info_ = 0; mark_ = e.mark_; circle_ = e.circle_; } SHalfedge& operator=(const SHalfedge& e) { source_ = e.source_; sprev_ = e.sprev_; snext_ = e.snext_; incident_sface_ = e.incident_sface_; twin_ = e.twin_; prev_ = e.prev_; next_ = e.next_; facet_ = e.facet_; info_ = 0; mark_ = e.mark_; circle_ = e.circle_; return *this; } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } SHalfedge_handle& twin() { return twin_; } SHalfedge_const_handle twin() const { return twin_; } SVertex_handle& source() { return source_; } SVertex_const_handle source() const { return source_; } SVertex_handle& target() { return twin()->source(); } SVertex_const_handle target() const { return twin()->source(); } SHalfedge_handle& prev() { return prev_; } SHalfedge_const_handle prev() const { return prev_; } SHalfedge_handle& next() { return next_; } SHalfedge_const_handle next() const { return next_; } SHalfedge_handle& sprev() { return sprev_; } SHalfedge_const_handle sprev() const { return sprev_; } SHalfedge_handle& snext() { return snext_; } SHalfedge_const_handle snext() const { return snext_; } SHalfedge_handle& cyclic_adj_succ() { return sprev()->twin(); } SHalfedge_const_handle cyclic_adj_succ() const { return sprev()->twin(); } SHalfedge_handle& cyclic_adj_pred(SHalfedge_const_handle e) { return e->twin()->snext(); } SHalfedge_const_handle cyclic_adj_pred(SHalfedge_const_handle e) const { return e->twin()->snext(); } Sphere_circle& circle() { return circle_; } const Sphere_circle& circle() const { return circle_; } SFace_handle& incident_sface() { return incident_sface_; } SFace_const_handle incident_sface() const { return incident_sface_; } Halffacet_handle& facet() { return facet_; } Halffacet_const_handle facet() const { return facet_; } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } public: std::string debug() const { std::stringstream os; set_pretty_mode(os); os <<"e[ "<debug()<<", " <source_->debug()<<" "<::SHalfedge::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = (source_ != SVertex_handle() && source_ != NULL && source_ != Halfedge_handle()); valid = valid && (twin_ != SHalfedge_handle() && twin_ != NULL); valid = valid && (sprev_ != SHalfedge_handle() && sprev_ != NULL); valid = valid && (snext_ != SHalfedge_handle() && snext_ != NULL); valid = valid && (prev_ != SHalfedge_handle() && prev_ != NULL); valid = valid && (next_ != SHalfedge_handle() && next_ != NULL); valid = valid && (incident_sface_ != SFace_handle() && incident_sface_ != NULL); valid = valid && (facet_ != Halffacet_handle() && facet_ != NULL); valid = valid && (circle_.d() == 0); valid = valid && (circle_.a() != 0 || circle_.b() != 0 || circle_.c() !=0); verr << "end of CGAL::SNC_items<...>::SHalfedge::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // SHalfedge //----------------------------------------------------------------------------- template class SHalfloop { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Sphere_circle Sphere_circle; typedef typename Refs::SHalfloop_handle SHalfloop_handle; typedef typename Refs::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Refs::SFace_handle SFace_handle; typedef typename Refs::SFace_const_handle SFace_const_handle; typedef typename Refs::Halffacet_handle Halffacet_handle; typedef typename Refs::Halffacet_const_handle Halffacet_const_handle; SHalfloop_handle twin_; SFace_handle incident_sface_; Halffacet_handle facet_; GenPtr info_; // temporary needed: Mark mark_; Sphere_circle circle_; public: SHalfloop() : twin_(), incident_sface_(), facet_(), info_(), mark_(), circle_() {} ~SHalfloop() { CGAL_NEF_TRACEN(" destroying SHalfloop item "<<&*this); } SHalfloop(const SHalfloop& l) { twin_ = l.twin_; incident_sface_ = l.incident_sface_; facet_ = l.facet_; info_ = 0; mark_ = l.mark_; circle_ = l.circle_; } SHalfloop& operator=(const SHalfloop& l) { twin_ = l.twin_; incident_sface_ = l.incident_sface_; facet_ = l.facet_; info_ = 0; mark_ = l.mark_; circle_ = l.circle_; return *this; } Mark& mark() { return mark_;} const Mark& mark() const { return mark_; } SHalfloop_handle& twin() { return twin_; } SHalfloop_const_handle twin() const { return twin_; } Sphere_circle& circle() { return circle_; } const Sphere_circle& circle() const { return circle_; } SFace_handle& incident_sface() { return incident_sface_; } SFace_const_handle incident_sface() const { return incident_sface_; } Halffacet_handle& facet() { return facet_; } Halffacet_const_handle facet() const { return facet_; } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } public: std::string debug() const { std::stringstream os; set_pretty_mode(os); os<<"sl [ "<::SHalfloop::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid = (twin_ != SHalfloop_handle() && twin_ != NULL); valid = valid && (incident_sface_ != SFace_handle() && incident_sface_ != NULL); valid = valid && (facet_ != Halffacet_handle() && facet_ != NULL); valid = valid && (circle_.d() == 0); valid = valid && (circle_.a() != 0 || circle_.b() != 0 || circle_.c() !=0); verr << "end of CGAL::SNC_items<...>::SHalfloop::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // SHalfloop //----------------------------------------------------------------------------- template class SFace { typedef void* GenPtr; typedef typename Refs::Mark Mark; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::SFace_handle SFace_handle; typedef typename Refs::SFace_const_handle SFace_const_handle; typedef typename Refs::Volume_handle Volume_handle; typedef typename Refs::Volume_const_handle Volume_const_handle; typedef typename Refs::Object_list Object_list; typedef typename Refs::SFace_cycle_iterator SFace_cycle_iterator; typedef typename Refs::SFace_cycle_const_iterator SFace_cycle_const_iterator; Vertex_handle center_vertex_; Volume_handle volume_; // Object_list boundary_entry_objects_; // SEdges, SLoops, SVertices GenPtr info_; // temporary needed: Mark mark_; public: Object_list boundary_entry_objects_; // SEdges, SLoops, SVertices SFace() : center_vertex_(), volume_(), info_(), mark_() {} ~SFace() { CGAL_NEF_TRACEN(" destroying SFace item "<<&*this); } SFace(const SFace& f) { center_vertex_ = f.center_vertex_; volume_ = f.volume_; boundary_entry_objects_ = f.boundary_entry_objects_; info_ = 0; mark_ = f.mark_; } SFace& operator=(const SFace& f) { if (this == &f) return *this; center_vertex_ = f.center_vertex_; volume_ = f.volume_; boundary_entry_objects_ = f.boundary_entry_objects_; info_ = 0; mark_ = f.mark_; return *this; } SFace_cycle_iterator sface_cycles_begin() { return boundary_entry_objects_.begin(); } SFace_cycle_iterator sface_cycles_end() { return boundary_entry_objects_.end(); } SFace_cycle_const_iterator sface_cycles_begin() const { return boundary_entry_objects_.begin(); } SFace_cycle_const_iterator sface_cycles_end() const { return boundary_entry_objects_.end(); } Mark& mark() { return mark_; } const Mark& mark() const { return mark_; } Vertex_handle& center_vertex() { return center_vertex_; } Vertex_const_handle center_vertex() const { return center_vertex_; } Volume_handle& volume() { return volume_; } Volume_const_handle volume() const { return volume_; } Object_list& boundary_entry_objects() { return boundary_entry_objects_; } const Object_list& boundary_entry_objects() const { return boundary_entry_objects_; } GenPtr& info() { return info_; } const GenPtr& info() const { return info_; } bool is_valid( bool verb = false, int level = 0) const { Verbose_ostream verr(verb); verr << "begin CGAL::SNC_items<...>::SFace::is_valid( verb=true, " "level = " << level << "):" << std::endl; bool valid =(center_vertex_ != Vertex_handle() && center_vertex_ != NULL); valid = valid && (volume_ != Volume_handle() && volume_ != NULL); if(boundary_entry_objects_.empty()) { valid = valid && (center_vertex_->shalfedges_begin() == center_vertex_->shalfedges_end()); } verr << "end of CGAL::SNC_items<...>::SFace::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } }; // SFace }; // SNC_items CGAL_END_NAMESPACE #endif //CGAL_SNC_ITEMS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_decorator.h0000644000175000017500000017201011344301501030612 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESISGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SNC_DECORATOR_H #define CGAL_SNC_DECORATOR_H //#define CGAL_NEF3_SM_VISUALIZOR //#define CGAL_NEF3_DUMP_SPHERE_MAPS //#define CGAL_NEF3_DUMP_SNC_OPERATORS #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CGAL_NEF3_SM_VISUALIZOR #include #endif // CGAL_NEF3_SM_VISUALIZOR #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 19 #include CGAL_BEGIN_NAMESPACE #if defined (CGAL_NEF3_TIMER_OVERLAY) || defined(CGAL_NEF3_TIMER_INTERSECTION) CGAL::Timer timer_overlay; #endif #ifdef CGAL_NEF3_TIMER_POINT_LOCATION int number_of_point_location_queries; int number_of_ray_shooting_queries; CGAL::Timer timer_point_location; CGAL::Timer timer_ray_shooting; #endif #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS int number_of_edge_facet_overlays=0; int number_of_clones=0; int number_of_sphere_sweeps=0; CGAL::Timer timer_sphere_sweeps; #endif #ifdef CGAL_NEF3_TIMER_PLANE_SWEEPS int number_of_plane_sweeps=0; CGAL::Timer timer_plane_sweeps; #endif #ifdef CGAL_NEF3_DUMP_STATISTICS int number_of_intersections; int number_of_intersection_candidates; #endif template class SNC_decorator : public SNC_const_decorator { public: typedef Map SNC_structure; typedef typename Map::Sphere_map Sphere_map; typedef CGAL::SNC_decorator Self; typedef CGAL::SNC_const_decorator Base; typedef Base SNC_const_decorator; typedef CGAL::SNC_constructor SNC_constructor; typedef CGAL::SM_decorator SM_decorator; typedef CGAL::SM_const_decorator SM_const_decorator; typedef CGAL::SNC_SM_overlayer SM_overlayer; typedef CGAL::SM_point_locator SM_point_locator; typedef CGAL::SNC_intersection SNC_intersection; typedef CGAL::SNC_point_locator SNC_point_locator; typedef CGAL::SNC_simplify SNC_simplify; SNC_structure* sncp_; typedef SNC_decorator_traits Decorator_traits; typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::Vertex_iterator Vertex_iterator; typedef typename SNC_structure::Halfedge_iterator Halfedge_iterator; typedef typename SNC_structure::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Volume_iterator Volume_iterator; typedef typename SNC_structure::SVertex_iterator SVertex_iterator; typedef typename SNC_structure::SHalfedge_iterator SHalfedge_iterator; typedef typename SNC_structure::SHalfloop_iterator SHalfloop_iterator; typedef typename SNC_structure::SFace_iterator SFace_iterator; typedef typename SNC_structure::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename SNC_structure::SFace_cycle_iterator SFace_cycle_iterator; typedef typename SNC_structure::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename SNC_structure::Shell_entry_iterator Shell_entry_iterator; typedef typename SNC_structure::Vertex Vertex; typedef typename SNC_structure::Halfedge Halfedge; typedef typename SNC_structure::Halffacet Halffacet; typedef typename SNC_structure::Volume Volume; typedef typename SNC_structure::SVertex SVertex; typedef typename SNC_structure::SHalfedge SHalfedge; typedef typename SNC_structure::SHalfloop SHalfloop; typedef typename SNC_structure::SFace SFace; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::Object_iterator Object_iterator; typedef typename Base::Vertex_const_handle Vertex_const_handle; typedef typename Base::Halfedge_const_handle Halfedge_const_handle; typedef typename Base::Halffacet_const_handle Halffacet_const_handle; typedef typename Base::Volume_const_handle Volume_const_handle; typedef typename Base::SVertex_const_handle SVertex_const_handle; typedef typename Base::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Base::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Base::SFace_const_handle SFace_const_handle; typedef typename Base::Vertex_const_iterator Vertex_const_iterator; typedef typename Base::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Base::Halffacet_const_iterator Halffacet_const_iterator; typedef typename Base::Volume_const_iterator Volume_const_iterator; typedef typename Base::SVertex_const_iterator SVertex_const_iterator; typedef typename Base::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Base::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename Base::SFace_const_iterator SFace_const_iterator; typedef typename Base::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; typedef typename Base::SFace_cycle_const_iterator SFace_cycle_const_iterator; typedef typename Base::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename Base::Shell_entry_const_iterator Shell_entry_const_iterator; typedef typename Base::Kernel Kernel; typedef typename Base::FT FT; typedef typename Base::RT RT; typedef typename Base::Point_3 Point_3; typedef typename Base::Segment_3 Segment_3; typedef typename Base::Ray_3 Ray_3; typedef typename Base::Line_3 Line_3; typedef typename Base::Plane_3 Plane_3; typedef typename Base::Vector_3 Vector_3; typedef typename Base::Sphere_kernel Sphere_kernel; typedef typename Base::Sphere_point Sphere_point; typedef typename Base::Sphere_segment Sphere_segment; typedef typename Base::Sphere_circle Sphere_circle; typedef typename Base::Sphere_direction Sphere_direction; typedef typename Base::Size_type Size_type; typedef typename Base::Mark Mark; typedef typename Base::Infi_box Infi_box; typedef typename Base::Aff_transformation_3 Aff_transformation_3; typedef typename SM_decorator::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename SM_decorator::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; struct points_lt { bool operator()(Point_3& p1, Point_3& p2) const { return CGAL::lexicographically_xyz_smaller(p1,p2); } }; enum {NO_SNC, WITH_SNC}; public: typedef void* GenPtr; #define using(f) using Base::f // using(mark); // using(vertex); // using(twin); // using(source); // using(target); // using(sface); // using(vertex); // using(twin); // using(source); // using(target); // using(previous); // using(next); // using(facet); // using(sface); // using(ssource); // using(starget); // using(mark); // using(twin); // using(facet); // using(vertex); // using(sface); // using(vertex); // using(volume); // using(twin); // using(volume); // using(point); // using(point); // using(calc_point); // using(segment); // using(plane); // using(vector); // using(orthogonal_vector); // using(mark); #undef using SNC_decorator() : Base(), sncp_() {} SNC_decorator(SNC_structure& W) : Base(W), sncp_(&W) {} SNC_decorator(const Self& S) { sncp_ = S.sncp_; } SNC_structure* sncp() const { CGAL_assertion( sncp_ != NULL); return sncp_; } void set_snc(SNC_structure& W) { sncp_ = &W; } static Vertex_handle vertex( Halfedge_handle e) { return e->center_vertex(); } static Halfedge_handle twin( Halfedge_handle e) { return e->twin(); } static Vertex_handle source( Halfedge_handle e) { return e->center_vertex(); } static Vertex_handle target( Halfedge_handle e) { return e->twin()->source(); } static SFace_handle sface( Halfedge_handle e) { return e->incident_sface(); } /* SVertex queries*/ static Vertex_handle vertex(SHalfedge_handle e) { return vertex(e->source()); } static SHalfedge_handle twin(SHalfedge_handle e) { return e->twin(); } static Vertex_handle source(SHalfedge_handle e) { return e->source()->center_vertex(); } static Vertex_handle source(SHalfedge e) { return e.source()->center_vertex(); } static Vertex_handle target(SHalfedge_handle e) { return e->twin()->source()->twin()->center_vertex(); } static SHalfedge_handle previous(SHalfedge_handle e) { return e->prev(); } static SHalfedge_handle next(SHalfedge_handle e) { return e->next(); } static Halffacet_handle facet(SHalfedge_handle e) { return e->facet(); } static SFace_handle sface(SHalfedge_handle e) { return e->incident_sface(); } static Halfedge_handle ssource(SHalfedge_handle e) { return e->source(); } static Halfedge_handle starget(SHalfedge_handle e) { return e->twin()->source(); } /* SHalfedge queries */ static const Mark& mark(SHalfedge_handle e) /*{\Mop returns the mark associated to |e| as a sphere object. This is temporary information!!!}*/ { return e->mark(); } static const Sphere_circle& circle(SHalfedge_handle e) { return e->circle(); } static const Sphere_circle& circle(SHalfloop_handle l) { return l->circle(); } std::string debug(SHalfedge_handle e) const { std::stringstream os; set_pretty_mode(os); os << "sedge-use " << point(source(e)) << point(target(e))<<'\0'; return os.str(); } static SHalfloop_handle twin( SHalfloop_handle l) { return l->twin(); } static Halffacet_handle facet( SHalfloop_handle l) { return l->facet(); } static Vertex_handle vertex( SHalfloop_handle l) { return l->incident_sface()->center_vertex(); } static SFace_handle sface( SHalfloop_handle l) { return l->incident_sface(); } /* SHalfloop queries */ static Vertex_handle vertex(SFace_handle f) { return f->center_vertex(); } static Volume_handle volume(SFace_handle f) { return f->volume(); } /* SHalffacet queries */ static Halffacet_handle twin(Halffacet_handle f) { return f->twin(); } static Volume_handle volume(Halffacet_handle f) { return f->incident_volume(); } /* Halffacet queries */ SFace_handle adjacent_sface(Halffacet_handle f) const { Halffacet_cycle_iterator fc(f->facet_cycles_begin()); CGAL_assertion( fc != f->facet_cycles_end()); if ( fc.is_shalfedge() ) { SHalfedge_handle se(fc); CGAL_assertion( facet(se) == f); CGAL_assertion( sface(se) != SFace_handle()); CGAL_assertion( volume(sface(twin(se))) == volume(f)); return sface(twin(se)); } else CGAL_assertion_msg( 0, "Facet outer cycle entry point" "is not an SHalfedge? "); return SFace_handle(); // never reached } static Point_3& point(Vertex_handle v) { return v->point(); } static Vector_3 to_vector(Halfedge_handle e) { // rename to to_vector return Vector_3(e->vector()-CGAL::ORIGIN); } static Segment_3 segment(Halfedge_handle e) { return Segment_3(point(source(e)), point(target(e))); } static Plane_3& plane(Halffacet_handle f) { return f->plane(); } static Mark& mark(Vertex_handle v) { return v->mark(); } static Mark& mark(Halfedge_handle e) { return e->mark(); } static Mark& mark(Halffacet_handle f) { return f->mark(); } static Mark& mark(Volume_handle c) { return c->mark(); } GenPtr& info(Vertex_handle v) const { return v->info(); } template bool is_boundary_object(H h) const { return sncp()->is_boundary_object(h); } template void store_boundary_object(H h, Halffacet_handle f) const { f->boundary_entry_objects().push_back(Object_handle(h)); sncp()->store_boundary_item(h, --(f->facet_cycles_end())); } template void store_as_first_boundary_object(H h, Halffacet_handle f) const { f->boundary_entry_objects().push_front(Object_handle(h)); sncp()->store_boundary_item(h, --(f->facet_cycles_end())); } template void undo_boundary_object(H h, Halffacet_handle f) const { CGAL_assertion(sncp()->is_boundary_object(h)); Halffacet_cycle_iterator it = sncp()->boundary_item(h); sncp()->undef_boundary_item(h); f->boundary_entry_objects().erase(it); } void link_as_facet_cycle(SHalfedge_handle e, Halffacet_handle f) const { SHalfedge_around_facet_circulator hfc(e), hend(hfc); CGAL_For_all(hfc,hend) hfc->facet() = f; store_boundary_object(e,f); } void link_as_interior_loop(SHalfloop_handle l, Halffacet_handle f) const { l->facet() = f; store_boundary_object(l,f); } template void make_twins(H h1, H h2) const { h1->twin() = h2; h2->twin() = h1; } void link_as_prev_next_pair(SHalfedge_handle e1, SHalfedge_handle e2) const { e1->next() = e2; e2->prev() = e1; } template void undo_boundary_object(H h, Volume_handle c) const { CGAL_assertion(sncp()->is_boundary_object(h)); Shell_entry_iterator it = sncp()->boundary_item(h); sncp()->undef_boundary_item(h); c->shell_entry_objects().erase(it); } template void store_boundary_object(H h, Volume_handle c, bool at_front = false) const { if(at_front) { c->shell_entry_objects().push_front(Object_handle(h)); sncp()->store_boundary_item(h, c->shells_begin()); } else { c->shell_entry_objects().push_back(Object_handle(h)); sncp()->store_boundary_item(h, --(c->shells_end())); } } template struct Shell_volume_setter { const SNCD_ D; Volume_handle c; typedef Unique_hash_map< SFace_handle, bool> SFace_map; SFace_map linked; Shell_volume_setter(const SNCD_& Di) : D(Di), linked(false) {} void visit(SFace_handle h) { CGAL_NEF_TRACEN(D.point(D.vertex(h))); D.set_volume(h, c); linked[h] = true; } void visit(Vertex_handle h) { /* empty */ } void visit(Halfedge_handle h) { /* empty */ } void visit(Halffacet_handle h ) { D.set_volume(h, c); } void visit(SHalfedge_handle se) {} void visit(SHalfloop_handle sl) {} void set_volume(Volume_handle ci) { c = ci; } bool is_linked(SFace_handle h) {return linked[h];} }; void link_as_outer_shell( SFace_handle f, Volume_handle c ) const { // CGAL_assertion(c->shell_entry_objects().size() == 0); Shell_volume_setter Setter(*this); Setter.set_volume(c); visit_shell_objects( f, Setter ); CGAL_NEF_TRACEN("Volume "<<&*c<<", outer shell "<<&*f); store_boundary_object( f, c ); } void link_as_inner_shell( SFace_handle f, Volume_handle c ) const { // CGAL_assertion(c->shell_entry_objects().size() > 0); Shell_volume_setter Setter(*this); Setter.set_volume(c); visit_shell_objects( f, Setter ); CGAL_NEF_TRACEN("Volume "<<&*c<<", inner shell "<<&*f); store_boundary_object( f, c); } template void set_facet(H h, Halffacet_handle f) const { h->facet() = f; } void set_volume(Halffacet_handle h, Volume_handle c) const { h->incident_volume() = c; } void set_volume(SFace_handle h, Volume_handle c) const { h->volume() = c; } void add_sloop_to_facet(SHalfloop_handle l, Halffacet_handle f) const { SM_decorator SD(&*vertex(l)); Sphere_circle facet_plane(plane(f)); if( facet_plane == SD.circle(l)) { l->facet() = f; SD.twin(l)->facet() = twin(f); } else { CGAL_assertion( facet_plane.opposite() == SD.circle(l)); l->facet() = twin(f); SD.twin(l)->facet() = f; } } /* returns true when |v| has outdegree two.*/ bool has_outdeg_two(SVertex_handle v) const { SM_decorator SD; if( SD.is_isolated(v)) return false; SHalfedge_handle e1 = SD.first_out_edge(v); SHalfedge_handle e2 = SD.cyclic_adj_succ(e1); return( e1!=e2 && SD.cyclic_adj_succ(e2)==e1); } Halffacet_handle get_visible_facet( const Vertex_handle v, const Ray_3& ray) const /*{\Mop when one shoot a ray |ray| in order to find the facet below to an object, and vertex |v| is hit, we need to choose one of the facets in the adjacency list of |v| such that it could be 'seen' from the piercing point of the |ray| on the sphere map on |v|. We make it just locating the sphere facet |sf| pierced by |ray| and taking the adjacent facet to one of the sphere segments on the boundary of |sf|. \precondition |ray| target is on |v| and the intersection between |ray| and the 2-skeleton incident to v is empty. }*/ { Halffacet_handle f_visible; CGAL_assertion( ray.source() != point(v)); CGAL_assertion( ray.has_on(point(v))); Sphere_point sp(ray.source() - point(v)); CGAL_NEF_TRACEN( "Locating "<facet()->plane() << std::endl; SVertex_handle sv; if(CGAL::assign(sv,o)) std::cerr << "on svertex " << sv->point() << std::endl; CGAL_assertion_msg( 0, "it is not possible to decide which one is a visible facet (if any)"); return Halffacet_handle(); } /* SM_decorator SD; if(sncp()->halfedges_begin() == sncp()->halfedges_end() || SD.is_isolated(sncp()->halfedges_begin())) return Halffacet_handle(); */ SFace_cycle_iterator fc = sf->sface_cycles_begin(), fce = sf->sface_cycles_end(); if( is_empty_range( fc, fce)) { CGAL_NEF_TRACEN( "no adjacent facet found."); f_visible = Halffacet_handle(); } else { if ( fc.is_shalfedge()) { SHalfedge_handle se(fc); CGAL_NEF_TRACEN( "adjacent facet found (SEdges cycle)."); CGAL_NEF_TRACEN("se"<facet()->plane() <<"/"<< se->snext()->facet()->plane() <<"/"<< se->snext()->snext()->facet()->plane()); f_visible = se->twin()->facet(); CGAL_NEF_TRACEN("f_visible"<circle() << " with facet "<=FT(0)) continue; if(sk0>=FT(0) && sk1<=FT(0)) { res = facet(sh); vec0 = vec1; continue; } // We have to comapare the two skalar products sk0 and sk1. Therefore // we have to normalize the input vectors vec0 and vec1, which means // that we have to divide them by their lengths len0 and len1. // To cicumvent irrational numbers, we sqaure the whole inequality. FT len0 = vec0.x()*vec0.x()+vec0.y()*vec0.y()+vec0.z()*vec0.z(); FT len1 = vec1.x()*vec1.x()+vec1.y()*vec1.y()+vec1.z()*vec1.z(); FT diff = len0*sk1*sk1 - len1*sk0*sk0; // if sk0<0 (and therefore sk1<0) both vectors point in a good direction. // Therefore we take the one pointing more in the good direction. // if sk0>0 (and therefore sk1>0) both vectors point in a bad direction. // Therefore we take the one pointing less in the bad direction. if((sk0>FT(0) && diffFT(0))) { res = facet(sh); vec0 = vec1; } } // We have to check which of the two halffacet is visible from // the ray. if(rv*plane(res).orthogonal_vector() > FT(0)) res = twin(res); CGAL_NEF_TRACEN("return "<sface_cycles_begin(), fce = sf->sface_cycles_end(); if( is_empty_range( fc, fce)) { CGAL_NEF_TRACEN( "no adjacent facets were found."); f_visible = Halffacet_handle(); } else { if (fc.is_shalfege()) { SHalfedge_handle se(fc); CGAL_NEF_TRACEN( "adjacent facet found (SEdges cycle)."); CGAL_NEF_TRACEN("se"<0) continue; if(sk0>0 && sk1<0) { res = facet(sh); continue; } RT len0 = vec0.x()*vec0.x()+vec0.y()*vec0.y()+vec0.z()*vec0.z(); RT len1 = vec1.x()*vec1.x()+vec1.y()*vec1.y()+vec1.z()*vec1.z(); RT sq0 = sk0 * sk0; RT sq1 = sk1 * sk1; RT diff = len0*sq1 - len1*sq0; if((sk0 > 0 && diff<0) || (sk0 < 0 && diff>0)) res = facet(sh); } return Halffacet_handle(); // never reached } */ Halffacet_handle get_visible_facet( const Halffacet_handle f, const Segment_3& ray) const //{\Mop when one shoot a ray |ray| in order to find the facet below to // an object, and a facet |f| is hit, we need to choose the right facet // from the halffacet pair |f| that could be 'seen' from the // piercing point of the |ray| on the local (virtual) view of |f|. // \precondition |ray| target belongs to |f| and the intersection between // |ray| and is not coplanar with |f|. } { Halffacet_handle f_visible = f; CGAL_assertion( !plane(f_visible).has_on(ray.source())); if( plane(f_visible).has_on_negative_side(ray.source())) f_visible = twin(f); CGAL_assertion( plane(f_visible).has_on_positive_side(ray.source())); return f_visible; } template Vertex_handle binop_local_views( Vertex_const_handle v0, Vertex_const_handle v1, const Selection& BOP, SNC_structure& rsnc) /*{\opOverlays two spheres maps.}*/ { #ifdef CGAL_NEF3_DUMP_SPHERE_MAPS typedef SM_io_parser SM_io_parser; SM_io_parser IO0( std::cerr, v0); SM_io_parser IO1( std::cerr, v1); CGAL_NEF_TRACEN(" sphere maps before local binary operation"); CGAL_NEF_TRACEN(v0->debug()); CGAL_NEF_TRACEN(v1->debug()); IO0.debug(); IO1.debug(); IO0.print(); IO1.print(); #endif // CGAL_NEF3_DUMP_SPHERE_MAPS CGAL_assertion( v0->point() == v1->point()); Vertex_handle v01 = rsnc.new_vertex( v0->point(), BOP( v0->mark(),v1->mark())); // cerr<<"BOP Vertex "<mark()<<" "<mark()<sncp())); SM_overlayer O(&*v01); O.subdivide( &*v0, &*v1); O.select( BOP); O.simplify(); #ifdef CGAL_NEF3_DUMP_SPHERE_MAPS CGAL_NEF_TRACEN(" result sphere map:"); SM_io_parser IO01( std::cerr, v01); CGAL_NEF_TRACEN(v01->debug()); IO01.print(); CGAL_NEF_TRACEN(" sphere maps after local binary operation"); IO0.debug(); IO1.debug(); #endif //CGAL_NEF3_DUMP_SPHERE_MAPS #ifdef CGAL_NEF3_SM_VISUALIZOR typedef SNC_SM_visualizor SMV; CGAL::OGL::add_sphere(); SMV V0(v0, CGAL::OGL::spheres_.back()); V0.draw_map(); SMV V1(v1, CGAL::OGL::spheres_.back()); V1.draw_map(); SMV V01(v01, CGAL::OGL::spheres_.back()); V01.draw_map(); CGAL::OGL::start_viewer(); CGAL_NEF_TRACEN("any key to continue..."); char c; std::cin >> c; #endif // CGAL_NEF3_VISUALIZOR return v01; } Vertex_handle create_local_view_on( const Point_3& p, Halfedge_const_handle e) { SNC_constructor C(*sncp()); return C.create_from_edge( e, p); } Vertex_handle create_local_view_on( const Point_3& p, Halffacet_const_handle f) { SNC_constructor C(*sncp()); return C.create_from_facet( f, p); } Vertex_handle create_local_view_on( const Point_3& p, Volume_const_handle c) { Vertex_handle v = sncp()->new_vertex( p, c->mark()); SM_decorator SD(&*v); SFace_handle f = SD.new_sface(); f->mark() = c->mark(); CGAL_NEF_TRACEN("volume "<<&*c<<" marked as "<mark()); // SM_point_locator PL(v); // PL.init_marks_of_halfspheres(); // necessary to init default marks return v; } Vertex_handle qualify_with_respect( const Point_3 p, const SNC_point_locator* pl1, SNC_structure& result) { Vertex_handle v; Halfedge_handle e; Halffacet_handle f; Volume_handle c; Self D(result); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION number_of_point_location_queries++; timer_point_location.start(); #endif Object_handle o = pl1->locate(p); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION timer_point_location.stop(); #endif if( CGAL::assign( v, o)) { CGAL_NEF_TRACEN("<-> vertex local view on "< edge local view of "< facet local view of "< volume local view of "< class Intersection_call_back : public SNC_point_locator::Intersection_call_back { public: Intersection_call_back( const SNC_structure& s0, const SNC_structure& s1, const Selection& _bop, SNC_structure& r, bool invert_order = false) : snc0(s0), snc1(s1), bop(_bop), result(r), inverse_order(invert_order) {} void operator()( Halfedge_const_handle e0, Object_handle o1, const Point_3& ip) const { #ifdef CGAL_NEF3_DUMP_STATISTICS number_of_intersections++; #endif Halfedge_const_handle e; Halffacet_const_handle f; Point_3 p(normalized(ip)); CGAL_NEF_TRACEN("Intersection_call_back: intersection reported on " << p << " (normalized: " << normalized(p) << " )"); #ifdef CGAL_NEF_DEBUG CGAL_NEF_TRACEN("edge 0 has source " << e0->source()->point() << " and direction " << e0->vector()); if( CGAL::assign( e, o1)) { CGAL_NEF_TRACEN("edge 1 has source " << e->source()->point() << " and direction " << e->vector()); } else if( CGAL::assign( f, o1)) { CGAL_NEF_TRACEN("face 1 has plane equation " << f->plane()); } else CGAL_assertion_msg( 0, "wrong handle"); #endif #if defined (CGAL_NEF3_TIMER_OVERLAY) || (CGAL_NEF3_TIMER_INTERSECTION) timer_overlay.start(); #endif if( CGAL::assign( e, o1)) { Self D(result); Vertex_handle v0, v1; v0 = D.create_local_view_on( p, e0); v1 = D.create_local_view_on( p, e); if( inverse_order) std::swap( v0, v1); D.binop_local_views( v0, v1, bop, result); result.delete_vertex(v0); result.delete_vertex(v1); } else if( CGAL::assign( f, o1)) { #ifdef CGAL_NEF3_OVERLAY_BY_HAND_OFF Self D(result); Vertex_handle v0, v1; v0 = D.create_local_view_on( p, e0); v1 = D.create_local_view_on( p, f); if( inverse_order) std::swap( v0, v1); D.binop_local_views( v0, v1, bop, result); result.delete_vertex(v0); result.delete_vertex(v1); #else SNC_constructor C(result); Sphere_map* M0 = C.create_edge_facet_overlay(e0, f, p, bop, inverse_order); SM_overlayer O(M0); O.simplify(); #endif } else CGAL_assertion_msg( 0, "wrong handle"); #if defined (CGAL_NEF3_TIMER_OVERLAY) || (CGAL_NEF3_TIMER_INTERSECTION) timer_overlay.stop(); #endif } private: const SNC_structure& snc0; const SNC_structure& snc1; const Selection& bop; SNC_structure& result; bool inverse_order; }; template void binary_operation( SNC_point_locator* pl0, const SNC_structure& snc1, const SNC_point_locator* pl1, const SNC_structure& snc2, const SNC_point_locator* pl2, const Selection& BOP) /*{\opPerforms a binary operation defined on |BOP| between two SNC structures. The input structures are not modified and the result of the operation is stored in |result|. \precondition: the structure |result| is empty.}*/ { CGAL_assertion( sncp()->is_empty()); CGAL_assertion( pl1 != NULL && pl2 != NULL); // Progress_indicator_clog v_qualifying // (sncp()->number_of_vertices()+snc1i.number_of_vertices(), // "binary_operator: qualifying vertices..."); #ifdef CGAL_NEF3_TIMER_BINARY_OPERATION CGAL::Timer timer_binary_operation; timer_binary_operation.start(); #endif #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS timer_sphere_sweeps.reset(); #endif Unique_hash_map ignore(false); Vertex_const_iterator v0; // CGAL_NEF_SETDTHREAD(19*43*131*509); CGAL_NEF_TRACEN("=> binary operation"); #ifdef CGAL_NEF3_DUMP_SNC_OPERATORS CGAL_NEF_TRACEN("=> first operand:"); SNC_io_parser O0(std::cout, snc1); O0.print(); CGAL_NEF_TRACEN("=> second operand:"); SNC_io_parser O1(std::cout, snc2); O1.print(); #endif // CGAL_NEF3_DUMP_SNC_OPERATORS CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); CGAL_NEF_TRACEN("=> for all v0 in snc1, qualify v0 with respect snc2"); CGAL_forall_vertices( v0, snc1) { // v_qualifying++; CGAL_assertion(!ignore[v0]); Point_3 p0(v0->point()); Vertex_handle v; Halfedge_handle e; Halffacet_handle f; Volume_handle c; CGAL_NEF_TRACEN("Locating point " << p0); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION timer_point_location.reset(); number_of_point_location_queries++; timer_point_location.start(); #endif Object_handle o = pl2->locate(p0); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION timer_point_location.stop(); #endif #if defined(CGAL_NEF3_TIMER_OVERLAY) timer_overlay.reset(); timer_overlay.start(); #endif if( CGAL::assign( v, o)) { CGAL_NEF_TRACEN("p0 found on vertex"); binop_local_views( v0, v, BOP, *sncp()); ignore[v] = true; } else if( CGAL::assign( e, o)) { CGAL_NEF_TRACEN("p0 found on edge"); Vertex_handle v1 = create_local_view_on( p0, e); binop_local_views( v0, v1, BOP, *sncp()); sncp()->delete_vertex(v1); } else if( CGAL::assign( f, o)) { CGAL_NEF_TRACEN("p0 found on facet"); Vertex_handle v1 = create_local_view_on( p0, f); binop_local_views( v0, v1, BOP, *sncp()); sncp()->delete_vertex(v1); } else if( CGAL::assign( c, o)) { CGAL_NEF_TRACEN("p0 found on volume with mark " << mark(c)); #ifdef CGAL_NEF3_OVERLAY_IF_NEEDED_OFF if(true) { #else if( BOP( true, mark(c)) != BOP( false, mark(c))) { #endif #ifdef CGAL_NEF3_OVERLAY_BY_HAND_OFF Vertex_handle v1 = create_local_view_on( p0, c); binop_local_views( v0, v1, BOP, *sncp()); sncp()->delete_vertex(v1); #else SNC_constructor C(*sncp()); Vertex_handle v1 = C.clone_SM(v0); SM_decorator SM(&*v1); SM.change_marks(BOP, mark(c)); SM_overlayer O(&*v1); O.simplify(); #endif } else { CGAL_NEF_TRACEN("vertex in volume deleted " << std::endl << " vertex: " << v0->point() << std::endl << " mark of volume: " << mark(c)); } } else CGAL_assertion_msg( 0, "wrong handle"); #if defined(CGAL_NEF3_TIMER_OVERLAY) timer_overlay.stop(); #endif } CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); CGAL_NEF_TRACEN("=> for all v1 in snc1, qualify v1 with respect snc0"); CGAL_forall_vertices( v0, snc2) { // v_qualifying++; if(ignore[v0]) continue; Point_3 p1(v0->point()); Halfedge_handle e; Halffacet_handle f; Volume_handle c; CGAL_NEF_TRACEN("Locating point " << p1); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION number_of_point_location_queries++; timer_point_location.start(); #endif Object_handle o = pl1->locate(p1); #ifdef CGAL_NEF3_TIMER_POINT_LOCATION timer_point_location.stop(); #endif CGAL_assertion_code(Vertex_handle v); CGAL_assertion( !CGAL::assign( v, o)); #if defined(CGAL_NEF3_TIMER_OVERLAY) timer_overlay.start(); #endif if( CGAL::assign( e, o)) { CGAL_NEF_TRACEN("p1 found on edge"); Vertex_handle v1 = create_local_view_on( p1, e); binop_local_views( v1, v0, BOP, *sncp()); sncp()->delete_vertex(v1); } else if( CGAL::assign( f, o)) { CGAL_NEF_TRACEN("p1 found on facet"); Vertex_handle v1 = create_local_view_on( p1, f); binop_local_views( v1, v0, BOP, *sncp()); sncp()->delete_vertex(v1); } else if( CGAL::assign( c, o)) { CGAL_NEF_TRACEN("p1 found on volume with mark " << mark(c)); #ifdef CGAL_NEF3_OVERLAY_IF_NEEDED_OFF if(true) { #else if( BOP( mark(c), true) != BOP( mark(c), false)) { #endif #ifdef CGAL_NEF3_OVERLAY_BY_HAND_OFF Vertex_handle v1 = create_local_view_on( p1, c); binop_local_views( v1, v0, BOP, *sncp()); sncp()->delete_vertex(v1); #else SNC_constructor C(*sncp()); Vertex_handle v1 = C.clone_SM(v0); SM_decorator SM(&*v1); SM.change_marks(mark(c), BOP); SM_overlayer O(&*v1); O.simplify(); #endif } else { CGAL_NEF_TRACEN("vertex in volume deleted " << std::endl << " vertex: " << v0->point() << std::endl << " mark of volume: " << mark(c)); } } else CGAL_assertion_msg( 0, "wrong handle"); #if defined(CGAL_NEF3_TIMER_OVERLAY) timer_overlay.stop(); #endif } CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); // Each time the intersect method of the point locator for the // SNC structure finds an intersection between the segment defined // by an edge on the other SNC structure, the call back method is // called with the intersecting objects and the intersection point. // The responsability of the call back functor is to construct the // local view on the intersection point on both SNC structures, // overlay them and add the resulting sphere map to the result. // CGAL_NEF_SETDTHREAD(19*509*43*131); // Progress_indicator_clog ee_intersections // (sncp()->number_of_edges(), // "binary_operator: finding edge-edge intersections..."); Intersection_call_back call_back0 ( snc1, snc2, BOP, *sncp()); Intersection_call_back call_back1 ( snc2, snc2, BOP, *sncp(), true); #ifdef CGAL_NEF3_TIMER_INTERSECTION double split_intersection = timer_overlay.time(); CGAL::Timer timer_intersection; timer_intersection.start(); #endif // choose between intersection algorithms #ifdef CGAL_NEF3_INTERSECTION_BY_KDTREE Halfedge_const_iterator e0, e1; /* CGAL_NEF_TRACEN("=> finding edge-edge intersections..."); CGAL_forall_edges( e0, snc1) { // ee_intersections++; pl2->intersect_with_edges( e0, call_back0); } CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); // Progress_indicator_clog ef_intersections // (sncp()->number_of_edges()+snc1i.number_of_edges(), // "binary_operator: finding edge-facet intersections..."); CGAL_NEF_TRACEN("number of vertices (so far...) = "<< sncp()->number_of_vertices()); CGAL_NEF_TRACEN("=> finding edge0-facet1 intersections..."); CGAL_forall_edges( e0, snc1) { // ef_intersections++; pl2->intersect_with_facets( e0, call_back0); } CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); */ CGAL_forall_edges(e0,snc1) pl2->intersect_with_edges_and_facets(e0,call_back0); CGAL_NEF_TRACEN("=> finding edge1-facet0 intersections..."); CGAL_forall_edges( e1, snc2) { // ef_intersections++; pl1->intersect_with_facets( e1, call_back1); } CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); #else { binop_intersection_test_segment_tree binop_box_intersection; binop_box_intersection(call_back0, call_back1, snc1, snc2); } #endif #ifdef CGAL_NEF3_TIMER_INTERSECTION timer_intersection.stop(); if(cgal_nef3_timer_on) std::cout << "Runtime_intersection: " << timer_intersection.time()-timer_overlay.time()+split_intersection << std::endl; #endif CGAL_NEF_TRACEN("=> resultant vertices (before simplification): "); CGAL_assertion_code(CGAL_forall_vertices( v0, *sncp()) CGAL_NEF_TRACEN(&*v0<<" "<point())); #ifdef CGAL_NEF3_TIMER_SIMPLIFICATION CGAL::Timer timer_simplification; timer_simplification.start(); #endif SNC_simplify simp(*sncp()); simp.vertex_simplification(NO_SNC); #ifdef CGAL_NEF3_TIMER_SIMPLIFICATION timer_simplification.stop(); if(cgal_nef3_timer_on) std::cout << "Runtime_simplification: " << timer_simplification.time() << std::endl; #endif CGAL_NEF_TRACEN("\nnumber of vertices (so far...) = "<< sncp()->number_of_vertices()); CGAL_NEF_TRACEN("=> resultant vertices (after simplification): "); CGAL_assertion_code(CGAL_forall_vertices( v0, *sncp()) CGAL_NEF_TRACEN(&*v0<<" "<point())); #ifdef CGAL_NEF3_DUMP_SNC_OPERATORS CGAL_NEF_TRACEN("=> pre-construction result"); SNC_io_parser O(std::cerr, *sncp()); O.print(); #endif #ifndef CGAL_NEF3_NO_EXTERNAL // CGAL_assertion( !sncp()->is_empty()); SNC_constructor C(*sncp(), pl0); C.build_external_structure(); #endif #ifdef CGAL_NEF3_DUMP_SNC_OPERATORS CGAL_NEF_TRACEN("=> construction completed, result: "); SNC_io_parser Op(std::cout, *sncp()); Op.print(); #endif #ifdef CGAL_NEF3_TIMER_PLANE_SWEEPS if(cgal_nef3_timer_on) { std::cout << "Number_of_plane_sweeps: " << number_of_plane_sweeps << std::endl; std::cout << "Runtime_plane_sweeps: " << timer_plane_sweeps.time() << std::endl; } #endif CGAL_assertion(!simp.simplify()); CGAL_NEF_TRACEN("=> end binary operation. "); #ifdef CGAL_NEF3_DUMP_STATISTICS if(cgal_nef3_timer_on) { std::cout << "Vertices_in_object_A: " << snc1.number_of_vertices() << std::endl; std::cout << "Vertices_in_object_B: " << snc2.number_of_vertices() << std::endl; std::cout << "Number_of_intersections: " << number_of_intersections << std::endl; std::cout << "Number_of_intersection_candidates: " << number_of_intersection_candidates << std::endl; std::cout << "Vertices_in_Result: " << sncp()->number_of_vertices() << std::endl; } #endif #ifdef CGAL_NEF3_TIMER_SPHERE_SWEEPS if(cgal_nef3_timer_on) { std::cout << "Number_of_edge_facet_overlays: " << number_of_edge_facet_overlays << std::endl; std::cout << "Number_of_clones: " << number_of_clones << std::endl; std::cout << "Number_of_sphere_sweeps: " << number_of_sphere_sweeps << std::endl; std::cout << "Runtime_sphere_sweeps: " << timer_sphere_sweeps.time() << std::endl; } #endif #if defined (CGAL_NEF3_TIMER_SPHERE_SWEEPS) && defined (CGAL_NEF3_TIMER_PLANE_SWEEPS) if(cgal_nef3_timer_on) { std::cout << "Runtime_all_sweeps: " << timer_sphere_sweeps.time()+timer_plane_sweeps.time() << std::endl; } #endif #ifdef CGAL_NEF3_TIMER_OVERLAY if(cgal_nef3_timer_on) { std::cout << "Runtime_overlay: " << timer_overlay.time() << std::endl; } #endif #ifdef CGAL_NEF3_TIMER_POINT_LOCATION if(cgal_nef3_timer_on) { std::cout << "Number_of_ray_shooting_queries: " << number_of_ray_shooting_queries << std::endl; std::cout << "Runtime_ray_shooting: " << timer_ray_shooting.time() << std::endl; std::cout << "Number_of_point_location_queries: " << number_of_point_location_queries << std::endl; std::cout << "Runtime_point_location: " << timer_point_location.time() << std::endl; std::cout << "Number_of_kd_tree_queries: " << number_of_point_location_queries + number_of_ray_shooting_queries << std::endl; std::cout << "Runtime_kd_tree_queries: " << timer_point_location.time() + timer_ray_shooting.time() << std::endl; } #endif #ifdef CGAL_NEF3_TIMER_BINARY_OPERATION if(cgal_nef3_timer_on) { timer_binary_operation.stop(); std::cout << "Runtime_binary_operation: " << timer_binary_operation.time() << std::endl; } #endif } bool is_valid( bool verb = false, int level = 0) { Verbose_ostream verr(verb); verr << "begin CGAL::SNC_decorator<...>::is_valid( verb=true, " "level = " << level << "):" << std::endl; int max = number_of_vertices() + number_of_halfedges() + number_of_halffacets() + number_of_volumes() + 2 * sncp()->number_of_shalfedges() + sncp()->number_of_shalfloops() + sncp()->number_of_sfaces(); int count = 0; bool valid = true; Vertex_iterator vi; std::list Points(false); // durch hashmap ersetzen CGAL_forall_vertices(vi,*this) { if(!valid) break; valid = valid && (vi->sncp()==sncp()); valid = valid && vi->is_valid(verb, level); SM_decorator SD(&*vi); Unique_hash_map SVvisited(false); Unique_hash_map SEvisited(false); Unique_hash_map SFvisited(false); valid = valid && SD.is_valid(SVvisited,SEvisited,SFvisited, verb, level); Points.push_back(point(vi)); // Mark m1 = SD.mark_of_halfsphere(-1); // Mark m2 = SD.mark_of_halfsphere(+1); // SM_point_locator PL(vi); // PL.init_marks_of_halfspheres(); // valid = valid && (SD.mark_of_halfsphere(-1) == m1); // valid = valid && (SD.mark_of_halfsphere(+1) == m2); // CGAL_NEF_TRACEN(m1 << "," << m2 << " should have been " << // SD.mark_of_halfsphere(-1) << "," << SD.mark_of_halfsphere(+1)); valid = valid && (++count <= max); } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; Points.sort(points_lt()); typename std::list::const_iterator li1, li2; li2 = li1 = Points.begin(); if(!Points.empty()) { li2++; while(valid && li2 != Points.end()) { valid = valid && (*li1++ != *li2++); } } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; Halfedge_iterator he; CGAL_forall_halfedges(he,*this) { valid = valid && he->is_valid(verb, level); valid = valid && (twin(he)!=he); valid = valid && (twin(twin(he))==he); if(he->is_twin()) { SM_decorator S1(&*source(he)); SM_decorator S2(&*target(he)); SHalfedge_handle se1(S1.first_out_edge(he)); SHalfedge_handle se2(S2.first_out_edge(twin(he))); if(se1 != NULL && se2 != NULL) { SHalfedge_handle start1(se1); SHalfedge_handle start2(S2.next(twin(se2))); while(facet(se1) != twin(facet(se2)) && se2 != start2) se2 = twin(S2.previous(se2)); start2 = se2; do { se1 = S1.next(twin(se1)); se2 = twin(S2.previous(se2)); valid = valid && (facet(se1) == twin(facet(se2))); } while(se1 != start1); valid = valid && (se2 == start2); } // Line_3 supporting_line(point(source(he)), point(he)); // valid = valid && supporting_line.has_on(point(source(twin(he)))); } valid = valid && (++count <= max); } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; Unique_hash_map SEinUniqueFC(false); Halffacet_iterator hfi; CGAL_forall_halffacets(hfi,*this) { valid = valid && hfi->is_valid(verb, level); valid = valid && (twin(hfi)!=hfi); valid = valid && (twin(twin(hfi))==hfi); valid = valid && (plane(hfi).opposite() == plane(twin(hfi))); Halffacet_cycle_iterator hfci; CGAL_forall_facet_cycles_of(hfci,hfi) { if(hfci.is_shalfedge()) { SHalfedge_handle sheh(hfci); valid = valid && (sheh != SHalfedge_handle()); SHalfedge_around_facet_circulator shec1(sheh), shec2(shec1); CGAL_For_all(shec1, shec2) { SM_decorator SD(&*vertex(shec1)); CGAL_assertion(!SEinUniqueFC[shec1]); SEinUniqueFC[shec1] = true; Plane_3 p_ref(point(vertex(shec1)),SD.circle(shec1).opposite().orthogonal_vector()); valid = valid && Infi_box::check_point_on_plane(point(vertex(shec1)), plane(hfi)); valid = valid && (normalized(plane(hfi)) == normalized(p_ref)); valid = valid && (sheh->incident_sface()->volume() == hfi->twin()->incident_volume()); } } else if(hfci.is_shalfloop()) valid = valid && (SHalfloop_handle(hfci) != SHalfloop_handle()); else valid = false; valid = valid && (++count <= max); } valid = valid && (++count <= max); } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; Volume_iterator voli; CGAL_forall_volumes(voli,*this) { if(number_of_vertices() > 0) valid = valid && (voli->is_valid(verb, level)); Shell_entry_iterator si; CGAL_forall_shells_of(si,voli) { valid = valid && (si != Shell_entry_iterator() && SFace_handle(si) != SFace_handle() && SFace_handle(si) != NULL); valid = valid && (++count <= max); } valid = valid && (++count <= max); } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; SHalfedge_iterator she; CGAL_forall_shalfedges(she,*sncp()) { valid = valid && (next(she) != she); valid = valid && (previous(she) != she); valid = valid && (previous(next(she)) == she); valid = valid && (next(previous(she)) == she); valid = valid && (next(twin(next(she))) == twin(she)); valid = valid && (previous(twin(previous(she))) == twin(she)); valid = valid && (twin(facet(she)) == facet(twin(she))); valid = valid && (mark(facet(she)) == mark(she)); valid = valid && (she->twin()->facet()->incident_volume() == she->incident_sface()->volume()); valid = valid && (++count <= max); } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; SHalfloop_iterator shl; CGAL_forall_shalfloops(shl,*sncp()){ SM_decorator SD; valid = valid && (mark(facet(shl)) == SD.mark(shl)); // valid = valid && (plane(facet(twin(shl))) == SD.circle(shl)); // valid = valid && (volume(facet(twin(shl))) == volume(sface(shl))); } verr << "CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; SFace_iterator sf; CGAL_forall_sfaces(sf,*sncp()) { SM_decorator SD; valid = valid && (mark(volume(sf)) == SD.mark(sf)); SFace_cycle_iterator sfc; for(sfc=sf->sface_cycles_begin();sfc!=sf->sface_cycles_end();++sfc) if(sfc.is_shalfedge()) valid = valid && (sf==SHalfedge_handle(sfc)->incident_sface()); } verr << "end of CGAL::SNC_decorator<...>::is_valid(): structure is " << ( valid ? "valid." : "NOT VALID.") << std::endl; return valid; } template void visit_shell_objects(SFace_handle f, Visitor& V) const; Vertex_iterator vertices_begin() { return sncp()->vertices_begin(); } Vertex_iterator vertices_end() { return sncp()->vertices_end(); } Halfedge_iterator halfedges_begin() { return sncp()->halfedges_begin(); } Halfedge_iterator halfedges_end() { return sncp()->halfedges_end(); } Halffacet_iterator halffacets_begin(){ return sncp()->halffacets_begin(); } Halffacet_iterator halffacets_end() { return sncp()->halffacets_end(); } Volume_iterator volumes_begin() { return sncp()->volumes_begin(); } Volume_iterator volumes_end() { return sncp()->volumes_end(); } SVertex_iterator svertices_begin() { return sncp()->svertices_begin(); } SVertex_iterator svertices_end() { return sncp()->svertices_end(); } SHalfedge_iterator shalfedges_begin(){ return sncp()->shalfedges_begin(); } SHalfedge_iterator shalfedges_end() { return sncp()->shalfedges_end(); } SHalfloop_iterator shalfloops_begin(){ return sncp()->shalfloops_begin(); } SHalfloop_iterator shalfloops_end() { return sncp()->shalfloops_end(); } SFace_iterator sfaces_begin() { return sncp()->sfaces_begin(); } SFace_iterator sfaces_end() { return sncp()->sfaces_end(); } Shell_entry_iterator shells_begin(Volume_handle c) { return c->shells_begin(); } Shell_entry_iterator shells_end(Volume_handle c) { return c->shells_end(); } Size_type number_of_vertices() const { return sncp()->number_of_vertices(); } Size_type number_of_halfedges() const { return sncp()->number_of_halfedges(); } Size_type number_of_edges() const { return sncp()->number_of_edges(); } Size_type number_of_halffacets() const { return sncp()->number_of_halffacets();} Size_type number_of_facets() const { return sncp()->number_of_facets();} Size_type number_of_volumes() const { return sncp()->number_of_volumes();} }; /* visiting shell objects: Objects are marked as done, when placed in the output list. We have to maintain a stack of sface candidates (the spherical rubber sectors that provide connectivity at the local graphs of vertices) and facet candiates (the plane pieces in three space also providing connectivity). Note that we have to take care about the orientation of sobjects and facets. We have to take care that (1) the search along the shell extends along the whole shell structure (2) does not visit any object twice, and (3) all 3-space objects have to be reported and this also just once. The facets and sfaces are marked |done| when they are put into their corresponding queues thus each such object is visited exactly once when taken out of the queue. When an sface |sf| is taken out of the queue |SFaceCandiates| its boundary structure is examined and all 2-skeleton objects (vertices and edges of 3-space) that are incident to the volume represented by |sf| are reported. Facets are reported when they are taken out of |FacetCandiates|. */ template template void SNC_decorator:: visit_shell_objects(SFace_handle f, Visitor& V) const { typedef typename SM_decorator::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; std::list SFaceCandidates; std::list FacetCandidates; CGAL::Generic_handle_map Done(false); SFaceCandidates.push_back(f); Done[f] = true; while ( true ) { if ( SFaceCandidates.empty() && FacetCandidates.empty() ) break; if ( !FacetCandidates.empty() ) { Halffacet_handle f = *FacetCandidates.begin(); FacetCandidates.pop_front(); V.visit(f); // report facet Halffacet_cycle_iterator fc; CGAL_forall_facet_cycles_of(fc,f) { if (fc.is_shalfedge() ) { SHalfedge_handle e(fc); SHalfedge_around_facet_circulator ec(e),ee(e); CGAL_For_all(ec,ee) { e = twin(ec); if ( Done[sface(e)] ) continue; SFaceCandidates.push_back(sface(e)); Done[sface(e)] = true; } } else if (fc.is_shalfloop()) { SHalfloop_handle l(fc); l = twin(l); if ( Done[sface(l)] ) continue; SFaceCandidates.push_back(sface(l)); Done[sface(l)] = true; } else CGAL_assertion_msg(0,"Damn wrong handle."); } } if ( !SFaceCandidates.empty() ) { SFace_handle sf = *SFaceCandidates.begin(); SFaceCandidates.pop_front(); V.visit(sf); // report sface if ( !Done[vertex(sf)] ) V.visit(vertex(sf)); // report vertex Done[vertex(sf)] = true; // SVertex_handle sv; SM_decorator SD(&*vertex(sf)); /* CGAL_forall_svertices(sv,SD){ if(SD.is_isolated(sv) && !Done[sv]) V.visit(sv); } */ SFace_cycle_iterator fc; CGAL_forall_sface_cycles_of(fc,sf) { if ( fc.is_shalfedge() ) { SHalfedge_handle e(fc); SHalfedge_around_sface_circulator ec(e),ee(e); CGAL_For_all(ec,ee) { V.visit(SHalfedge_handle(ec)); SVertex_handle v = starget(ec); if ( !SD.is_isolated(v) && !Done[v] ) { V.visit(v); // report edge Done[v] = Done[twin(v)] = true; } Halffacet_handle f = facet(twin(ec)); if ( Done[f] ) continue; FacetCandidates.push_back(f); Done[f] = true; } } else if ( fc.is_svertex() ) { SVertex_handle v(fc); if ( Done[v] ) continue; V.visit(v); // report edge V.visit(twin(v)); Done[v] = Done[twin(v)] = true; CGAL_assertion(SD.is_isolated(v)); SFaceCandidates.push_back(sface(twin(v))); Done[sface(twin(v))]=true; // note that v is isolated, thus twin(v) is isolated too // SM_decorator SD; // SFace_handle fo; // fo = sface(twin(v)); /* if(SD.is_isolated(v)) fo = source(v)->sfaces_begin(); else fo = sface(twin(v)); */ // if ( Done[fo] ) continue; // SFaceCandidates.push_back(fo); Done[fo] = true; } else if (fc.is_shalfloop()) { SHalfloop_handle l(fc); V.visit(l); Halffacet_handle f = facet(twin(l)); if ( Done[f] ) continue; FacetCandidates.push_back(f); Done[f] = true; } else CGAL_assertion_msg(0,"Damn wrong handle."); } } } } CGAL_END_NAMESPACE #endif //CGAL_SNC_DECORATOR_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_const_decorator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_const_decora0000644000175000017500000006626211344301501031060 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_const_decorator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner // Peter Hachenberger #ifndef CGAL_SNC_CONST_DECORATOR_H #define CGAL_SNC_CONST_DECORATOR_H #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 191 #include CGAL_BEGIN_NAMESPACE template class SM_const_decorator; template class SNC_const_decorator { typedef SNC_structure_ Base; typedef SNC_structure_ SNC_structure; typedef SNC_const_decorator Self; typedef typename SNC_structure::Sphere_map Sphere_map; typedef CGAL::SM_const_decorator SM_const_decorator; const SNC_structure* sncp_; typedef typename SNC_structure::SHalfedge SHalfedge; public: typedef SNC_decorator_const_traits Decorator_traits; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::Object_const_iterator Object_const_iterator; typedef typename SNC_structure::Vertex_const_handle Vertex_const_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::Volume_const_handle Volume_const_handle; typedef typename SNC_structure::SVertex_const_handle SVertex_const_handle; typedef typename SNC_structure::SHalfedge_const_handle SHalfedge_const_handle; typedef typename SNC_structure::SHalfloop_const_handle SHalfloop_const_handle; typedef typename SNC_structure::SFace_const_handle SFace_const_handle; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::Vertex_const_iterator Vertex_const_iterator; typedef typename SNC_structure::Halfedge_const_iterator Halfedge_const_iterator; typedef typename SNC_structure::Halffacet_const_iterator Halffacet_const_iterator; typedef typename SNC_structure::Volume_const_iterator Volume_const_iterator; typedef typename SNC_structure::SVertex_const_iterator SVertex_const_iterator; typedef typename SNC_structure::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename SNC_structure::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename SNC_structure::SFace_const_iterator SFace_const_iterator; typedef typename SNC_structure::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; typedef typename SNC_structure::SFace_cycle_const_iterator SFace_cycle_const_iterator; typedef typename SNC_structure::Halffacet_cycle_const_iterator Halffacet_cycle_const_iterator; typedef typename SNC_structure::Shell_entry_const_iterator Shell_entry_const_iterator; typedef typename SNC_structure::Kernel Kernel; typedef typename SNC_structure::FT FT; typedef typename SNC_structure::RT RT; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Ray_3 Ray_3; typedef typename SNC_structure::Line_3 Line_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Aff_transformation_3 Aff_transformation_3; typedef typename SNC_structure::Sphere_kernel Sphere_kernel; typedef typename SNC_structure::Sphere_point Sphere_point; typedef typename SNC_structure::Sphere_segment Sphere_segment; typedef typename SNC_structure::Sphere_circle Sphere_circle; typedef typename SNC_structure::Sphere_direction Sphere_direction; typedef typename SNC_structure::Size_type Size_type; typedef typename SNC_structure::Mark Mark; typedef typename SNC_structure::Infi_box Infi_box; typedef typename SM_const_decorator::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_const_circulator; typedef typename SM_const_decorator::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_const_circulator; public: typedef void* GenPtr; SNC_const_decorator() : sncp_(0) {} SNC_const_decorator(const SNC_structure& W) : sncp_(&W) {} SNC_const_decorator(const SNC_const_decorator& S) { sncp_ = S.sncp_; } protected: void set_snc(const SNC_structure& W) { sncp_ = &W; } public: const SNC_structure* sncp() const { return sncp_; } /* static Vertex_const_handle vertex( Halfedge_const_handle e) { return e->center_vertex(); } static Halfedge_const_handle twin( Halfedge_const_handle e) { return e->twin(); } static Vertex_const_handle source( Halfedge_const_handle e) { return e->center_vertex(); } static Vertex_const_handle target( Halfedge_const_handle e) { return source(twin(e)); } static SFace_const_handle sface( Halfedge_const_handle e) { return e->incident_sface(); } // SVertex queries static Vertex_const_handle vertex(SHalfedge_const_handle e) { return vertex(e->source()); } static SHalfedge_const_handle twin(SHalfedge_const_handle e) { return e->twin(); } static Vertex_const_handle source(SHalfedge_const_handle e) { return e->source()->center_vertex(); } static Vertex_const_handle source(SHalfedge e) { return e.source()->center_vertex(); } static Vertex_const_handle target(SHalfedge_const_handle e) { return e->twin()->source()->twin()->center_vertex(); } static SHalfedge_const_handle previous(SHalfedge_const_handle e) { return e->prev(); } static SHalfedge_const_handle next(SHalfedge_const_handle e) { return e->next(); } static Halffacet_const_handle facet(SHalfedge_const_handle e) { return e->facet(); } static SFace_const_handle sface(SHalfedge_const_handle e) { return e->incident_sface(); } static Halfedge_const_handle ssource(SHalfedge_const_handle e) { return e->source(); } static Halfedge_const_handle starget(SHalfedge_const_handle e) { return e->twin()->source(); } // SHalfedge queries static SHalfloop_const_handle twin( SHalfloop_const_handle l) { return l->twin(); } static Halffacet_const_handle facet( SHalfloop_const_handle l) { return l->facet(); } static Vertex_const_handle vertex( SHalfloop_const_handle l) { return l->incident_sface()->center_vertex(); } static SFace_const_handle sface( SHalfloop_const_handle l) { return l->incident_sface(); } // SHalfloop queries static Vertex_const_handle vertex(SFace_const_handle f) { return f->center_vertex(); } static Volume_const_handle volume(SFace_const_handle f) { return f->volume(); } // SFace queries static Halffacet_const_handle twin(Halffacet_const_handle f) { return f->twin(); } static Volume_const_handle volume(Halffacet_const_handle f) { return f->incident_volume(); } // Halffacet queries */ SFace_const_handle adjacent_sface(Halffacet_const_handle f) const { Halffacet_cycle_const_iterator fc(f->facet_cycles_begin()); CGAL_assertion( fc != f->facet_cycles_end()); if ( fc.is_shalfedge() ) { SHalfedge_const_handle se(fc); CGAL_assertion( facet(se) == f); CGAL_assertion( sface(se) != SFace_const_handle()); CGAL_assertion( volume(sface(twin(se))) == volume(f)); return sface(twin(se)); } else CGAL_assertion_msg( 0, "Facet outer cycle entry point" "is not an SHalfedge? "); return SFace_const_handle(); // never reached } static const Point_3& point(Vertex_const_handle v) { return v->point(); } static Vector_3 vector(Halfedge_const_handle e) { return Vector_3(e->point()-CGAL::ORIGIN); } static Segment_3 segment(Halfedge_const_handle e) { return Segment_3(e->source()->point(), e->twin()->source()->point()); } static const Plane_3 plane(Halffacet_const_handle f) { return f->plane(); } static const Mark& mark(Vertex_const_handle v) { return v->mark(); } static const Mark& mark(Halfedge_const_handle e) { return e->mark(); } static const Mark& mark(Halffacet_const_handle f) { return f->mark(); } static const Mark& mark(Volume_const_handle c) { return c->mark(); } template void visit_shell_objects(SFace_const_handle f, Visitor& V) const; Vertex_const_iterator vertices_begin() const { return this->sncp()->vertices_begin(); } Vertex_const_iterator vertices_end() const { return this->sncp()->vertices_end(); } Halfedge_const_iterator halfedges_begin()const { return this->sncp()->halfedges_begin(); } Halfedge_const_iterator halfedges_end() const { return this->sncp()->halfedges_end(); } Halffacet_const_iterator halffacets_begin() const { return this->sncp()->halffacets_begin(); } Halffacet_const_iterator halffacets_end() const { return this->sncp()->halffacets_end(); } Volume_const_iterator volumes_begin() const { return this->sncp()->volumes_begin(); } Volume_const_iterator volumes_end() const { return this->sncp()->volumes_end(); } Shell_entry_const_iterator shells_begin(Volume_const_handle c) const { return c->shells_begin(); } Shell_entry_const_iterator shells_end(Volume_const_handle c) const { return c->shells_end(); } Size_type number_of_vertices() const { return this->sncp()->number_of_vertices(); } Size_type number_of_halfedges() const { return this->sncp()->number_of_halfedges(); } Size_type number_of_edges() const { return this->sncp()->number_of_edges(); } Size_type number_of_halffacets() const { return this->sncp()->number_of_halffacets();} Size_type number_of_facets() const { return this->sncp()->number_of_facets();} Size_type number_of_volumes() const { return this->sncp()->number_of_volumes();} bool is_bounded() const { if(is_standard_kernel()) return true; int i = 0; Halffacet_const_handle hf; CGAL_forall_facets(hf, *sncp()) { if(!Infi_box::is_standard(plane(hf))) ++i; } CGAL_assertion(i>=6); return (i == 6); } static bool is_bounded(Halffacet_const_handle f) { Halffacet_cycle_const_iterator fc = f->facet_cycles_begin(); CGAL_assertion(fc.is_shalfedge()); SHalfedge_const_handle sh(fc); SHalfedge_around_facet_const_circulator fcc(sh), fend(fcc); CGAL_For_all(fcc,fend) if(!is_standard(fcc->source()->source())) return false; return true; } static bool is_standard(Vertex_const_handle v) { return Infi_box::is_standard(v->point()); } static bool is_standard(Halffacet_const_handle f) { return Infi_box::is_standard(f->plane()); } static bool is_standard_kernel() { return Infi_box::standard_kernel(); } static bool is_extended_kernel() { return Infi_box::extended_kernel(); } static void set_size_of_infimaximal_box(const typename Infi_box::NT& size) { Infi_box::set_size_of_infimaximal_box(size); } typedef SM_point_locator SM_point_locator; Halffacet_const_handle get_visible_facet( const Vertex_const_handle v, const Ray_3& ray) const /*{\Mop when one shoot a ray |ray| in order to find the facet below to an object, and vertex |v| is hit, we need to choose one of the facets in the adjacency list of |v| such that it could be 'seen' from the piercing point of the |ray| on the sphere map on |v|. We make it just locating the sphere facet |sf| pierced by |ray| and taking the adjacent facet to one of the sphere segments on the boundary of |sf|. \precondition |ray| target is on |v| and the intersection between |ray| and the 2-skeleton incident to v is empty. }*/ { Halffacet_const_handle f_visible; CGAL_assertion( ray.source() != point(v)); CGAL_assertion( ray.has_on(point(v))); Sphere_point sp(ray.source() - point(v)); CGAL_NEF_TRACEN( "Locating "<sncp()->halfedges_begin() == this->sncp()->halfedges_end() || SD.is_isolated(this->sncp()->halfedges_begin())) return Halffacet_const_handle(); */ SFace_cycle_const_iterator fc = sf->sface_cycles_begin(), fce = sf->sface_cycles_end(); if( is_empty_range( fc, fce)) { CGAL_NEF_TRACEN( "no adjacent facet found."); f_visible = Halffacet_const_handle(); } else { SHalfedge_const_handle se; SHalfloop_const_handle sl; SVertex_const_handle sv; if (fc.is_shalfedge()) { se = SHalfedge_const_handle(fc); CGAL_NEF_TRACEN( "adjacent facet found (SEdges cycle)."); CGAL_NEF_TRACEN("se"<FT(0)) continue; if(sk0>FT(0) && sk1FT(0) && diffFT(0))) { res = facet(sh); vec0 = vec1; } } // We have to check which of the two halffacet is visible from // the ray. if(rv*plane(res).orthogonal_vector() > FT(0)) res = twin(res); CGAL_NEF_TRACEN("return "<sface_cycles_begin(), fce = sf->sface_cycles_end(); if( is_empty_range( fc, fce)) { CGAL_NEF_TRACEN( "no adjacent facets were found."); f_visible = Halffacet_const_handle(); } else { if (fc.is_shalfedge()) { SHalfedge_const_handle se(fc); CGAL_NEF_TRACEN( "adjacent facet found (SEdges cycle)."); CGAL_NEF_TRACEN("se"<0) continue; if(sk0>0 && sk1<0) { res = facet(sh); continue; } RT len0 = vec0.x()*vec0.x()+vec0.y()*vec0.y()+vec0.z()*vec0.z(); RT len1 = vec1.x()*vec1.x()+vec1.y()*vec1.y()+vec1.z()*vec1.z(); RT sq0 = sk0 * sk0; RT sq1 = sk1 * sk1; RT diff = len0*sq1 - len1*sq0; if((sk0 > 0 && diff<0) || (sk0 < 0 && diff>0)) res = facet(sh); } return Halffacet_const_handle(); // never reached } */ Halffacet_const_handle get_visible_facet( const Halffacet_const_handle f, const Segment_3& ray) const //{\Mop when one shoot a ray |ray| in order to find the facet below to // an object, and a facet |f| is hit, we need to choose the right facet // from the halffacet pair |f| that could be 'seen' from the // piercing point of the |ray| on the local (virtual) view of |f|. // \precondition |ray| target belongs to |f| and the intersection between // |ray| and is not coplanar with |f|. } { Halffacet_const_handle f_visible = f; CGAL_assertion( !plane(f_visible).has_on(ray.source())); if( plane(f_visible).has_on_negative_side(ray.source())) f_visible = twin(f); CGAL_assertion( plane(f_visible).has_on_positive_side(ray.source())); return f_visible; } }; template template void SNC_const_decorator:: visit_shell_objects(SFace_const_handle f, Visitor& V) const { std::list SFaceCandidates; std::list FacetCandidates; CGAL::Unique_hash_map DoneSF(false); CGAL::Unique_hash_map DoneV(false); CGAL::Unique_hash_map DoneSV(false); CGAL::Unique_hash_map DoneF(false); SFaceCandidates.push_back(f); DoneSF[f] = true; while ( true ) { if ( SFaceCandidates.empty() && FacetCandidates.empty() ) break; if ( !FacetCandidates.empty() ) { Halffacet_const_handle f = *FacetCandidates.begin(); FacetCandidates.pop_front(); V.visit(f); // report facet Halffacet_cycle_const_iterator fc; CGAL_forall_facet_cycles_of(fc,f) { if (fc.is_shalfedge() ) { SHalfedge_const_handle e(fc); SHalfedge_const_handle she; SHalfedge_around_facet_const_circulator ec(e),ee(e); CGAL_For_all(ec,ee) { she = ec->twin(); if ( DoneSF[she->incident_sface()] ) continue; SFaceCandidates.push_back(she->incident_sface()); DoneSF[she->incident_sface()] = true; } } else if (fc.is_shalfloop() ) { SHalfloop_const_handle l(fc); SHalfloop_const_handle ll = l->twin(); if ( DoneSF[ll->incident_sface()] ) continue; SFaceCandidates.push_back(ll->incident_sface()); DoneSF[ll->incident_sface()] = true; } else CGAL_assertion_msg(0,"Damn wrong handle."); } } if ( !SFaceCandidates.empty() ) { SFace_const_handle sf = *SFaceCandidates.begin(); SFaceCandidates.pop_front(); V.visit(sf); if ( !DoneV[sf->center_vertex()] ) V.visit(sf->center_vertex()); // report vertex DoneV[sf->center_vertex()] = true; // SVertex_const_handle sv; SM_const_decorator SD(&*sf->center_vertex()); /* CGAL_forall_svertices(sv,SD){ if(SD.is_isolated(sv) && !DoneSV[sv]) V.visit(sv); } */ SFace_cycle_const_iterator fc; CGAL_forall_sface_cycles_of(fc,sf) { if (fc.is_shalfedge() ) { SHalfedge_const_handle e(fc); SHalfedge_around_sface_const_circulator ec(e),ee(e); CGAL_For_all(ec,ee) { V.visit(SHalfedge_const_handle(ec)); SVertex_const_handle vv = ec->twin()->source(); if ( !SD.is_isolated(vv) && !DoneSV[vv] ) { V.visit(vv); // report edge DoneSV[vv] = DoneSV[vv->twin()] = true; } Halffacet_const_handle f = ec->twin()->facet(); if ( DoneF[f] ) continue; FacetCandidates.push_back(f); DoneF[f] = true; } } else if (fc.is_svertex() ) { SVertex_const_handle v(fc); if ( DoneSV[v] ) continue; V.visit(v); // report edge V.visit(v->twin()); DoneSV[v] = DoneSV[v->twin()] = true; CGAL_assertion(SD.is_isolated(v)); SFaceCandidates.push_back(v->twin()->incident_sface()); DoneSF[v->twin()->incident_sface()]=true; // note that v is isolated, thus twin(v) is isolated too // SM_const_decorator SD; // SFace_const_handle fo; // fo = v->twin()->incident_sface(); /* if(SD.is_isolated(v)) fo = v->source()->sfaces_begin(); else fo = v->twin()->incident_sface(); */ } else if (fc.is_shalfloop() ) { SHalfloop_const_handle l(fc); V.visit(l); Halffacet_const_handle f = l->twin()->facet(); if ( DoneF[f] ) continue; FacetCandidates.push_back(f); DoneF[f] = true; } else CGAL_assertion_msg(0,"Damn wrong handle."); } } } } CGAL_END_NAMESPACE #endif //CGAL_SNC_CONST_DECORATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_io_parser.h0000644000175000017500000016735411344301501030632 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_io_parser.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_SNC_IO_PARSER_H #define CGAL_SNC_IO_PARSER_H #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 293 #include CGAL_BEGIN_NAMESPACE template class moreLeft : public T { typedef typename T::SM_decorator SM_decorator; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::Vector_3 Vector_3; typedef typename T::FT FT; typedef typename T::RT RT; public: moreLeft(T D) : T(D) {} int operator()(SHalfedge_handle se1, SHalfedge_handle se2) { CGAL_assertion(se1 != SHalfedge_handle()); if(se2 == SHalfedge_handle()) return -1; SM_decorator SM(&*vertex(se1)); Vector_3 vec1 = SM.circle(se1).orthogonal_vector(); Vector_3 vec2 = SM.circle(se2).orthogonal_vector(); if(vec1 == vec2) return 0; if(vec1.x() == RT(0) && vec2.x() == RT(0)) { if(vec1.y() != vec2.y()) if(vec1.y() < vec2.y()) return -1; else return 1; if(vec1.z() < vec2.z()) return -1; else return 1; } Vector_3 minus(-1,0,0); FT sk1(minus*vec1), sk2(minus*vec2); if((sk1 >= FT(0) && sk2 <= FT(0)) || (sk1 <= FT(0) && sk2 >= FT(0))) if(sk1 > FT(0) || sk2 < FT(0)) return -1; else return 1; FT len1 = vec1.x()*vec1.x()+vec1.y()*vec1.y()+vec1.z()*vec1.z(); FT len2 = vec2.x()*vec2.x()+vec2.y()*vec2.y()+vec2.z()*vec2.z(); FT diff = len1*sk2*sk2 - len2*sk1*sk1; if(diff != FT(0)) if((sk1>FT(0) && diffFT(0))) return -1; else return 1; return 0; } }; template class sort_vertices : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::Vertex_handle Vertex_handle; typedef typename T::Point_3 Point_3; public: sort_vertices(T& D) : Base(D) {} bool operator() (Vertex_handle v1, Vertex_handle v2) const { return lexicographically_xyz_smaller(point(v1), point(v2)); } }; template class sort_edges : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::Halfedge_handle Halfedge_handle; public: sort_edges(T& D) : Base(D) {} bool operator() (Halfedge_handle e1, Halfedge_handle e2) const { sort_vertices SORT(*this->sncp()); if(source(e1) != source(e2)) return SORT(source(e1),source(e2)); return SORT(source(twin(e1)), source(twin(e2))); } }; template class sort_facets : public SNC_decorator { typedef T SNC_structure; typedef SNC_decorator Base; typedef typename T::Halffacet_handle Halffacet_handle; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::Vector_3 Vector_3; typedef typename T::Plane_3 Plane_3; public: sort_facets(T& D) : Base(D) {} bool operator() (Halffacet_handle f1, Halffacet_handle f2) const { Plane_3 p1(plane(f1)); Plane_3 p2(plane(f2)); if(p1.d() != p2.d()) return p1.d() < p2.d(); else if(p1.a() != p2.a()) return p1.a() < p2.a(); else if(p1.b() != p2.b()) return p1.b() < p2.b(); else if(p1.c() != p2.c()) return p1.c() < p2.c(); SHalfedge_handle se1 = SHalfedge_handle(f1->facet_cycles_begin()); SHalfedge_handle se2 = SHalfedge_handle(f2->facet_cycles_begin()); sort_vertices SORT(*this->sncp()); if(vertex(se1) != vertex(se2)) return SORT(vertex(se1), vertex(se2)); se1 = next(se1); se2 = next(se2); CGAL_assertion(vertex(se1) != vertex(se2)); return SORT(vertex(se1), vertex(se2)); } }; template class sort_sedges : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef CGAL::SM_decorator SM_decorator; typedef typename T::Vertex_handle Vertex_handle; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::Sphere_circle Sphere_circle; public: sort_sedges(T& D) : Base(D) {} bool operator() (SHalfedge_handle se1, SHalfedge_handle se2) const { CGAL_NEF_TRACEN("sort sedges"); if(se1 == se2) return false; sort_vertices SORT(*this->sncp()); CGAL_NEF_TRACEN(" center verices: " << source(se1)->point() << " , " << source(se2)->point()); if(source(se1) != source(se2)) return SORT(source(se1),source(se2)); SM_decorator SD; if(se1 == twin(se2)) if(ssource(se1) == ssource(se2)) { Sphere_circle vec1 = SD.circle(se1); Sphere_circle vec2 = SD.circle(se2); if(vec1.a() != vec2.a()) return vec1.a() < vec2.a(); else if(vec1.b() != vec2.b()) return vec1.b() < vec2.b(); return vec1.c() < vec2.c(); } else return SORT(vertex(twin(ssource(se1))), vertex(twin(ssource(se2)))); if(SORT(vertex(twin(ssource(twin(se1)))), vertex(twin(ssource(se1))))) se1 = twin(se1); if(SORT(vertex(twin(ssource(twin(se2)))), vertex(twin(ssource(se2))))) se2 = twin(se2); CGAL_NEF_TRACEN(" ssources " << vertex(twin(ssource(se1)))->point() << " , " << vertex(twin(ssource(se2)))->point()); if(ssource(se1) != ssource(se2)) return SORT(vertex(twin(ssource(se1))), vertex(twin(ssource(se2)))); CGAL_NEF_TRACEN(" starget " << target(se1)->point() << " , " << target(se2)->point()); if(target(se1) != target(se2)) return SORT(target(se1), target(se2)); CGAL_assertion(SD.circle(se1) != SD.circle(se2)); Sphere_circle vec1 = SD.circle(se1); Sphere_circle vec2 = SD.circle(se2); if(vec1.a() != vec2.a()) return vec1.a() < vec2.a(); else if(vec1.b() != vec2.b()) return vec1.b() < vec2.b(); return vec1.c() < vec2.c(); } }; template class sort_sloops : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::SHalfloop_handle SHalfloop_handle; public: sort_sloops(T& D) : Base(D) {} bool operator() (SHalfloop_handle sl1, SHalfloop_handle sl2) const { if(sl1 == sl2) return false; sort_vertices SORTV(*this->sncp()); sort_facets SORTF(*this->sncp()); if(vertex(sl1) != vertex(sl2)) return SORTV(vertex(sl1),vertex(sl2)); return SORTF(facet(sl1), facet(sl2)); } }; template class sort_sface_cycle_entries : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::SM_decorator SM_decorator; typedef typename T::Object_handle Object_handle; typedef typename T::SVertex_handle SVertex_handle; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::SHalfloop_handle SHalfloop_handle; typedef typename T::SFace_handle SFace_handle; typedef typename T::Point_3 Point_3; typedef typename T::Vector_3 Vector_3; public: sort_sface_cycle_entries(T D) : Base(D) {} bool operator() (Object_handle o1, Object_handle o2) const { CGAL_NEF_TRACEN("sort sface cycles "); SVertex_handle sv1, sv2; SHalfedge_handle se1, se2; SHalfloop_handle sl1, sl2; if(!CGAL::assign(se1,o1) && !CGAL::assign(sl1,o1) && !CGAL::assign(sv1,o1)) CGAL_assertion_msg(0,"wrong handle"); if(!CGAL::assign(se2,o2) && !CGAL::assign(sl2,o2) && !CGAL::assign(sv2,o2)) CGAL_assertion_msg(0,"wrong handle"); if(se1 != SHalfedge_handle() && se2 == SHalfedge_handle()) return true; if(se1 == SHalfedge_handle() && se2 != SHalfedge_handle()) return false; if(sl1 != SHalfloop_handle() && sv2 != SVertex_handle()) return true; if(sl2 != SHalfloop_handle() && sv1 != SVertex_handle()) return false; if(se1 != SHalfedge_handle() && se2 != SHalfedge_handle()) { CGAL_NEF_TRACEN(" sedges " << &*se1 << " , " << &*se2); sort_sedges SORT(*this->sncp()); return SORT(se1,se2); /* sort_vertices SORT(*this->sncp()); if(ssource(se1) != ssource(se2)) return SORT(vertex(twin(ssource(se1))), vertex(twin(ssource(se2)))); else return SORT(target(se1), target(se2)); */ } if(sl1 != SHalfloop_handle() && sl2 != SHalfloop_handle()) { SM_decorator SD(&*vertex(sl1)); Vector_3 vec1(SD.circle(sl1).orthogonal_vector()); Vector_3 vec2(SD.circle(sl2).orthogonal_vector()); // CGAL_assertion(vec1 == vec2.antipode()); if(vec1.x() != vec2.x()) return vec1.x() < vec2.x(); else if(vec1.y() != vec2.y()) return vec1.y() < vec2.y(); else if(vec1.z() != vec2.z()) return vec1.z() < vec2.z(); } CGAL_assertion(sv1 != SVertex_handle() && sv2 != SVertex_handle()); sort_vertices SORT(*this->sncp()); return SORT(target(sv1), target(sv2)); } }; template class sort_sfaces : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::SM_decorator SM_decorator; typedef typename T::Point_3 Point_3; typedef typename T::Vector_3 Vector_3; typedef typename T::SVertex_handle SVertex_handle; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::SHalfloop_handle SHalfloop_handle; typedef typename T::SFace_handle SFace_handle; typedef typename T::SFace_cycle_iterator SFace_cycle_iterator; typedef typename T::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; public: sort_sfaces(T& D) : Base(D) {} bool operator() (SFace_handle sf1, SFace_handle sf2) const { CGAL_NEF_TRACEN("sort sfaces"); if(&*sf1 == &*sf2) return false; sort_vertices SORT(*this->sncp()); CGAL_NEF_TRACEN(" vertices " << vertex(sf1)->point() << " , " << vertex(sf2)->point()); if(vertex(sf1) != vertex(sf2)) return SORT(vertex(sf1), vertex(sf2)); // sort_sface_cycle_entries sort_cycles((Base) *this); // return sort_cycles(*sf1->sface_cycles_begin(), *sf2->sface_cycles_begin()); SM_decorator SD(&*vertex(sf1)); moreLeft ml((Base) *this); Vector_3 plus(1,0,0); SFace_cycle_iterator fc; CGAL_NEF_TRACEN(" sface 1"); SHalfedge_handle se1; SHalfloop_handle sl1; CGAL_forall_sface_cycles_of(fc,sf1) { if(fc.is_shalfedge()) { SHalfedge_handle se(fc); SHalfedge_around_sface_circulator ec(se),ee(se); CGAL_For_all(ec,ee) { CGAL_NEF_TRACEN(" " << SD.point(ssource(ec)) << " | " << SD.circle(ec).orthogonal_vector()); if(ml(ec, se1) == -1) se1 = ec; } } else if(fc.is_shalfloop()) sl1 = SHalfloop_handle(fc); else CGAL_assertion(fc.is_svertex()); } CGAL_NEF_TRACEN(" sface 2"); SHalfedge_handle se2; SHalfloop_handle sl2; CGAL_forall_sface_cycles_of(fc,sf2) { if(fc.is_shalfedge()) { SHalfedge_handle se(fc); SHalfedge_around_sface_circulator ec(se),ee(se); CGAL_For_all(ec,ee) { CGAL_NEF_TRACEN(" " << SD.point(ssource(ec)) << " | " << SD.circle(ec).orthogonal_vector()); if(ml(ec, se2) == -1) se2 = ec; } } else if(fc.is_shalfloop()) sl2 = SHalfloop_handle(fc); else CGAL_assertion(fc.is_svertex()); } CGAL_NEF_TRACEN(" sedge cycles existing? " << (se1 != SHalfedge_handle()) << " , " << (se2 != SHalfedge_handle())); if(se1 != SHalfedge_handle() && se2 == SHalfedge_handle()) return true; if(se1 == SHalfedge_handle() && se2 != SHalfedge_handle()) return false; if(se1 == SHalfedge_handle() && se2 == SHalfedge_handle()) { Vector_3 vec1 = SD.circle(sl1).orthogonal_vector(); Vector_3 vec2 = SD.circle(sl2).orthogonal_vector(); CGAL_NEF_TRACEN(" sloops " << vec1 << " , " << vec2); if(vec1.x() != vec2.x()) return vec1.x() < vec2.x(); else if(vec1.y() != vec2.y()) return vec1.y() < vec2.y(); else if(vec1.z() != vec2.z()) return vec1.z() < vec2.z(); } CGAL_assertion(se1 != SHalfedge_handle() && se2 != SHalfedge_handle()); CGAL_NEF_TRACEN(" minimal sedge in sface 1:" << SD.point(ssource(se1)) << " , " << SD.circle(se1).orthogonal_vector()); CGAL_NEF_TRACEN(" minimal sedge in sface 2:" << SD.point(ssource(se2)) << " , " << SD.circle(se2).orthogonal_vector()); CGAL_NEF_TRACEN("result " << ml(se1,se2)); switch(ml(se1, se2)) { case -1: return true; case 1: return false; } sort_sface_cycle_entries SORTSFC(*this->sncp()); return SORTSFC(*sf1->sface_cycles_begin(), *sf2->sface_cycles_begin()); } }; template class sort_volumes : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::Volume_handle Volume_handle; typedef typename T::SFace_handle SFace_handle; public: sort_volumes(T& D) : Base(D) {} bool operator() (Volume_handle c1, Volume_handle c2) const { CGAL_NEF_TRACEN("sort volumes"); SFace_handle sf1 = SFace_handle(c1->shells_begin()); SFace_handle sf2 = SFace_handle(c2->shells_begin()); sort_sfaces SORT(*this->sncp()); return SORT(sf1, sf2); } }; template class sort_facet_cycle_entries : public T { typedef typename T::SNC_structure SNC_structure; typedef typename T::SM_decorator SM_decorator; typedef typename T::Object_handle Object_handle; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::SHalfloop_handle SHalfloop_handle; typedef typename T::SFace_handle SFace_handle; typedef typename T::Point_3 Point_3; typedef typename T::Vector_3 Vector_3; public: sort_facet_cycle_entries(T D) : T(D) {} bool operator() (Object_handle o1, Object_handle o2) const { SHalfedge_handle se1, se2; SHalfloop_handle sl1, sl2; if(!CGAL::assign(se1,o1) && !CGAL::assign(sl1,o1)) CGAL_assertion_msg(0,"wrong handle"); if(!CGAL::assign(se2,o2) && !CGAL::assign(sl2,o2)) CGAL_assertion_msg(0,"wrong handle"); if(se1 != SHalfedge_handle() && se2 != SHalfedge_handle()) { sort_vertices SORT(*this->sncp()); return SORT(source(se1), source(se2)); } if(se1 != SHalfedge_handle()) return true; if(se2 != SHalfedge_handle()) return false; CGAL_assertion(sl1 != SHalfloop_handle() && sl2 != SHalfloop_handle()); SM_decorator SD(&*vertex(sl1)); Vector_3 vec1(SD.circle(sl1).orthogonal_vector()); Vector_3 vec2(SD.circle(sl2).orthogonal_vector()); // CGAL_assertion(vec1 == vec2.antipode()); if(vec1.x() != vec2.x()) return vec1.x() < vec2.x(); else if(vec1.y() != vec2.y()) return vec1.y() < vec2.y(); else return vec1.z() < vec2.z(); } }; template class sort_shell_entries : public T { typedef typename T::Object_handle Object_handle; typedef typename T::Shell_entry_iterator Shell_entry_iterator; typedef typename T::SFace_handle SFace_handle; typedef typename T::Point_3 Point_3; public: sort_shell_entries(T D) : T(D) {} bool operator() (Object_handle o1, Object_handle o2) const { SFace_handle sf1, sf2; CGAL::assign(sf1, o1); CGAL::assign(sf2, o2); Point_3 p1(point(vertex(sf1))), p2(point(vertex(sf2))); if(p1.x() != p2.x()) return p1.x() < p2.x(); else if(p1.y() != p2.y()) return p1.y() < p2.y(); return p1.z() < p2.z(); } }; template struct find_minimal_sface_of_shell : public SNC_decorator { typedef T SNC_structure; typedef CGAL::SNC_decorator Base; typedef typename T::Vertex_handle Vertex_handle; typedef typename T::Halfedge_handle Halfedge_handle; typedef typename T::Halffacet_handle Halffacet_handle; typedef typename T::SFace_handle SFace_handle; typedef typename T::SHalfedge_handle SHalfedge_handle; typedef typename T::SHalfloop_handle SHalfloop_handle; typedef CGAL::Unique_hash_map SFace_visited_hash; SFace_visited_hash& Done; SFace_handle sf_min; sort_sfaces SORT; find_minimal_sface_of_shell(T& D, SFace_visited_hash& Vi) : Base(D), Done(Vi), SORT(D) {} void visit(SFace_handle h) { Done[h]=true; if(sf_min == SFace_handle()) sf_min = h; else { if(SORT(h,sf_min)) sf_min = h; } } void visit(Vertex_handle h) {} void visit(Halfedge_handle h) {} void visit(Halffacet_handle h) {} void visit(SHalfedge_handle h) {} void visit(SHalfloop_handle h) {} SFace_handle& minimal_sface() { return sf_min; } }; template class SNC_io_parser : public SNC_decorator { typedef SNC_structure_ SNC_structure; typedef CGAL::SNC_io_parser Self; typedef CGAL::SNC_decorator Base; typedef typename SNC_structure::Sphere_map Sphere_map; typedef CGAL::SM_decorator SM_decorator; typedef typename SNC_structure::Infi_box Infi_box; typedef typename Infi_box::Standard_kernel Standard_kernel; public: typedef typename SNC_structure::Vertex_iterator Vertex_iterator; typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::Halfedge_iterator Halfedge_iterator; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Volume_iterator Volume_iterator; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::SVertex_iterator SVertex_iterator; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_iterator SHalfedge_iterator; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SFace_iterator SFace_iterator; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::SHalfloop_iterator SHalfloop_iterator; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::Object_iterator Object_iterator; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::SFace_cycle_iterator SFace_cycle_iterator; typedef typename SNC_structure::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename SNC_structure::Shell_entry_iterator Shell_entry_iterator; typedef typename SNC_structure::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename SNC_structure::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Sphere_point Sphere_point; typedef typename SNC_structure::Sphere_segment Sphere_segment; typedef typename SNC_structure::Sphere_circle Sphere_circle; typedef typename SNC_structure::Mark Mark; typedef typename SNC_structure::Kernel Kernel; typedef typename Kernel::RT RT; typedef typename Infi_box::Standard_point Standard_point; typedef typename Infi_box::Standard_vector Standard_vector; typedef typename Infi_box::Standard_plane Standard_plane; typedef void* GenPtr; private: std::istream& in; std::ostream& out; bool verbose; bool reduce; bool sorted; bool addInfiBox; CGAL::Object_index VI; CGAL::Object_index EI; CGAL::Object_index FI; CGAL::Object_index CI; CGAL::Object_index SEI; CGAL::Object_index SLI; CGAL::Object_index SFI; std::list VL; std::list EL; std::list FL; std::list CL; std::list SEL; std::list SLL; std::list SFL; std::vector Vertex_of; std::vector Edge_of; std::vector Halffacet_of; std::vector Volume_of; std::vector SVertex_of; std::vector SEdge_of; std::vector SLoop_of; std::vector SFace_of; long i,vn,en,fn,cn,sen,sln,sfn; public: SNC_io_parser(std::istream& is, SNC_structure& W); SNC_io_parser(std::ostream& os, SNC_structure& W, bool sort=false); std::string index(Vertex_iterator v) const { return VI(v,verbose); } std::string index(Halfedge_iterator e) const { return EI(e,verbose); } std::string index(Halffacet_iterator f) const { return FI(f,verbose); } std::string index(Volume_iterator c) const { return CI(c,verbose); } std::string index(SHalfedge_iterator e) const { return SEI(e,verbose); } std::string index(SHalfloop_iterator l) const { return SLI(l,verbose); } std::string index(SFace_iterator f) const { return SFI(f,verbose); } std::string index(Object_iterator o) const { if( o == 0 ) return this->string("undef"); Vertex_iterator v; Halfedge_iterator e; Halffacet_iterator f; Volume_iterator c; SHalfedge_iterator se; SHalfloop_iterator sl; SFace_iterator sf; if( CGAL::assign( v, *o)) return index(v); else if( CGAL::assign( e, *o)) return index(e); else if( CGAL::assign( f, *o)) return index(f); else if( CGAL::assign( c, *o)) return index(c); else if( CGAL::assign( se, *o)) return index(se); else if( CGAL::assign( sl, *o)) return index(sl); else if( CGAL::assign( sf, *o)) return index(sf); return this->string("unknown object"); } bool check_sep(char* sep) const; bool test_string(std::string s) const; void print_vertex(Vertex_handle) const; void print_edge(Halfedge_handle) const; void print_facet(Halffacet_handle) const; void print_volume(Volume_handle) const; void print_sedge(SHalfedge_handle) const; void print_sloop(SHalfloop_handle) const; void print_sface(SFace_handle) const; void print() const; void print_local_graph(Vertex_handle) const; template bool read_vertex(Vertex_handle); template bool read_edge(Halfedge_handle); template bool read_facet(Halffacet_handle); bool read_volume(Volume_handle); template bool read_svertex(SVertex_handle); template bool read_sedge(SHalfedge_handle); template bool read_sloop(SHalfloop_handle); bool read_sface(SFace_handle); void add_infi_box(); void read(); static void dump(SNC_structure& W, std::ostream& os = std::cerr, bool sort = false) { Self O(os,W, sort); O.print(); } template void output_sorted_indexes(Iter begin, Iter end, Index i) const { int low = i[begin]; int high = low; for(Iter it=begin; it != end; it++) { if(i[it] < low) low = i[it]; if(i[it] > high) high = i[it]; } out << low << " " << high << ", "; } }; template SNC_io_parser::SNC_io_parser(std::istream& is, SNC_structure& W) : Base(W), in(is), out(std::cout) { W.clear(); CGAL_assertion(W.is_empty()); verbose = false; } template SNC_io_parser::SNC_io_parser(std::ostream& os, SNC_structure& W, bool sort) : Base(W), in(std::cin), out(os), FI(W.halffacets_begin(),W.halffacets_end(),'F'), CI(W.volumes_begin(),W.volumes_end(),'C'), SEI(W.shalfedges_begin(),W.shalfedges_end(),'e'), SLI(W.shalfloops_begin(),W.shalfloops_end(),'l'), SFI(W.sfaces_begin(),W.sfaces_end(),'f'), vn(W.number_of_vertices()), en(W.number_of_halfedges()), fn(W.number_of_halffacets()), cn(W.number_of_volumes()), sen(W.number_of_shalfedges()), sln(W.number_of_shalfloops()), sfn(W.number_of_sfaces()) { verbose = (out.iword(CGAL::IO::mode) != CGAL::IO::ASCII && out.iword(CGAL::IO::mode) != CGAL::IO::BINARY); sorted = sort; reduce = this->is_extended_kernel() && sorted && this->is_bounded(); Vertex_iterator vi; CGAL_forall_vertices(vi, *this->sncp()) { VL.push_back(vi); if(sorted) { point(vi) = normalized(point(vi)); if(vi->has_shalfloop() && sort_sloops(*this->sncp())(vi->shalfloop()->twin(), vi->shalfloop())) vi->shalfloop() = vi->shalfloop()->twin(); } } if(sorted) { VL.sort(sort_vertices(*this->sncp())); } if(reduce) for(int k=0; k<4; k++){ VL.pop_front(); VL.pop_back(); } int i = 0; typename std::list::iterator vl; for(vl = VL.begin(); vl != VL.end(); vl++) VI[*vl] = i++; SM_decorator SD; Halfedge_iterator ei; CGAL_forall_halfedges(ei, *this->sncp()) { EL.push_back(ei); if(sorted) { // std::cerr << point(ei) << " | " << normalized(point(ei)) << " |"; SD.point(ei) = normalized(SD.point(ei)); // std::cerr << point(ei) << std::endl; sort_sedges sortSE(*this->sncp()); SHalfedge_handle new_outedge = ei->out_sedge(); SHalfedge_around_svertex_circulator cb(new_outedge), ce(cb); CGAL_For_all(cb,ce) { if(cb != new_outedge && sortSE(cb,new_outedge)) new_outedge = cb; /* if(source(cb) == target(cb) && source(cb) == target(new_outedge)) { Plane_3 c(SD.circle(cb)); if(c.a() != 0) { if(c.a() < 0) new_outedge = cb; } else if(c.b() != 0) { if(c.b() < 0) new_outedge = cb; } else if(c.c() != 0) { if(c.c() < 0) new_outedge = cb; } } else if(lexicographically_xyz_smaller(point(target(cb)), point(target(new_outedge)))) new_outedge = cb; */ } ei->out_sedge() = new_outedge; } } if(sorted) EL.sort(sort_edges(*this->sncp())); if(reduce) for(int k=0; k<12; k++){ EL.pop_front(); EL.pop_back(); } i = 0; typename std::list::iterator el; for(el = EL.begin(); el != EL.end(); el++) EI[*el] = i++; Halffacet_iterator fi; CGAL_forall_halffacets(fi, *this->sncp()){ if(sorted) { plane(fi) = normalized(plane(fi)); fi->boundary_entry_objects().sort(sort_facet_cycle_entries((Base) *this)); } FL.push_back(fi); } if(sorted) FL.sort(sort_facets(*this->sncp())); if(reduce) { for(int k=0; k<6; k++){ FL.pop_front(); FL.pop_back(); } } i = 0; typename std::list::iterator fl; for(fl = FL.begin(); fl != FL.end(); fl++) FI[*fl] = i++; SHalfedge_iterator sei; CGAL_forall_shalfedges(sei, *this->sncp()) { SEL.push_back(sei); if(sorted) SD.circle(sei) = normalized(SD.circle(sei)); } if(sorted) SEL.sort(sort_sedges(*this->sncp())); if(reduce) for(int k=0; k<24; k++){ SEL.pop_front(); SEL.pop_back(); } i = 0; typename std::list::iterator sel; for(sel = SEL.begin(); sel != SEL.end(); sel++) SEI[*sel] = i++; SHalfloop_iterator sli; CGAL_forall_shalfloops(sli, *this->sncp()) { SLL.push_back(sli); if(sorted) SD.circle(sli) = normalized(SD.circle(sli)); } if(sorted) SLL.sort(sort_sloops(*this->sncp())); i = 0; typename std::list::iterator sll; for(sll = SLL.begin(); sll != SLL.end(); sll++) SLI[*sll] = i++; SFace_iterator sfi; CGAL_forall_sfaces(sfi, *this->sncp()) { if(sorted) { SFace_cycle_iterator fc; CGAL_forall_sface_cycles_of(fc, sfi) { if(fc.is_shalfedge()) { SHalfedge_handle se(fc); SHalfedge_around_sface_circulator cb(se), ce(cb); CGAL_For_all(cb,ce) { if(ssource(cb) != ssource(se)) { if(lexicographically_xyz_smaller(point(vertex(twin(ssource(cb)))), point(vertex(twin(ssource(se)))))) se = cb; } else if(lexicographically_xyz_smaller(point(target(cb)), point(target(se)))) se = cb; } *fc = se; } } sfi->boundary_entry_objects().sort(sort_sface_cycle_entries((Base) *this)); } SFL.push_back(sfi); } if(sorted) SFL.sort(sort_sfaces(*this->sncp())); if(reduce) for(int k=0; k<8; k++){ SFL.pop_front(); SFL.pop_back(); } i = 0; typename std::list::iterator sfl; for(sfl = SFL.begin(); sfl != SFL.end(); sfl++) SFI[*sfl] = i++; Volume_iterator ci; CGAL::Unique_hash_map Done(false); find_minimal_sface_of_shell findMinSF(*this->sncp(),Done); CGAL_forall_volumes(ci, *this->sncp()) { if(sorted) { Shell_entry_iterator it; CGAL_forall_shells_of(it,ci) { findMinSF.minimal_sface() = SFace_handle(it); visit_shell_objects(SFace_handle(it),findMinSF); *it = findMinSF.minimal_sface(); } ci->shell_entry_objects().sort(sort_shell_entries((Base)*this)); } CL.push_back(ci); } if(sorted) CL.sort(sort_volumes(*this->sncp())); if(reduce) CL.pop_front(); i = 0; typename std::list::iterator cl; for(cl = CL.begin(); cl != CL.end(); cl++) CI[*cl] = i++; VI[W.vertices_end()]=-2; EI[W.halfedges_end()]=-2; FI[W.halffacets_end()]=-2; CI[W.volumes_end()]=-2; SEI[W.shalfedges_end()]=-2; SLI[W.shalfloops_end()]=-2; SFI[W.sfaces_end()]=-2; } template bool SNC_io_parser::check_sep(char* sep) const { char c; do in.get(c); while (isspace(c)); while (*sep != '\0') { if (*sep != c) { in.putback(c); return false; } ++sep; in.get(c); } in.putback(c); return true; } template bool SNC_io_parser::test_string(std::string s) const { std::string s2; in >> s2; return (s==s2); } template void SNC_io_parser::print() const { out << "Selective Nef Complex" << std::endl; if(this->is_extended_kernel() && (!reduce || !this->is_bounded())) out << "extended" << std::endl; else out << "standard" << std::endl; out << "vertices " << VL.size() << std::endl; out << "halfedges " << EL.size() << std::endl; out << "facets " << FL.size() << std::endl; out << "volumes " << CL.size() << std::endl; out << "shalfedges " << SEL.size() << std::endl; out << "shalfloops " << SLL.size() << std::endl; out << "sfaces " << SFL.size() << std::endl; if (verbose) out << "/* Vertex: index { svs sve ses see sfs sfe sl," << " mark, point } */\n"; typename std::list::const_iterator v; for(v=VL.begin();v!=VL.end();v++) print_vertex(*v); if (verbose) out << "/* Edge: index { twin, source, isolated incident_object," << " mark } */\n"; typename std::list::const_iterator e; for(e=EL.begin();e!=EL.end();e++) print_edge(*e); if (verbose) out << "/* Facet: index { twin, fclist, ivlist, volume | plane } mark */\n"; typename std::list::const_iterator f; for(f=FL.begin();f!=FL.end();f++) print_facet(*f); if (verbose) out << "/* Volume: index { shlist } mark */\n"; typename std::list::const_iterator c; for(c=CL.begin();c!=CL.end();c++) print_volume(*c); if (verbose) out << "/* SEdge: index { twin, sprev, snext, source, sface," << " prev, next, facet } */\n"; typename std::list::const_iterator se; for(se=SEL.begin();se!=SEL.end();se++) print_sedge(*se); if (verbose) out << "/* SLoop: index { twin, sface, facet } */" << std::endl; typename std::list::const_iterator sl; for(sl=SLL.begin();sl!=SLL.end();sl++) print_sloop(*sl); if (verbose) out << "/* SFace: index { fclist, ivlist, sloop, volume } */" << std::endl; typename std::list::const_iterator sf; for(sf=SFL.begin();sf!=SFL.end();sf++) print_sface(*sf); out << "/* end Selective Nef complex */" << std::endl; } template void SNC_io_parser::read() { if ( !check_sep("Selective Nef Complex") ) CGAL_assertion_msg(0,"SNC_io_parser::read: no SNC header."); std::string kernel_type; in >> kernel_type; CGAL_assertion(kernel_type == "standard" || kernel_type == "extended"); if ( !(check_sep("vertices") && (in >> vn)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong vertex line."); if ( !(check_sep("halfedges") && (in >> en) && (en%2==0)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong edge line."); if ( !(check_sep("facets") && (in >> fn) && (fn%2==0)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong facet line."); if ( !(check_sep("volumes") && (in >> cn)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong volume line."); if ( !(check_sep("shalfedges") && (in >> sen)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong sedge line."); if ( !(check_sep("shalfloops") && (in >> sln)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong sloop line."); if ( !(check_sep("sfaces") && (in >> sfn)) ) CGAL_assertion_msg(0,"SNC_io_parser::read: wrong sface line."); /* char c; int spaces = 0; std::streampos pos(in.tellg()); in.get(c); while(in.get(c) && c != '\n') if(c == ' ') ++spaces; in.seekg(pos,std::ios::beg); CGAL_assertion_msg(c=='\n' && (spaces==15 || spaces==26 || vn == 0),"wrong file format"); CGAL_assertion_msg(!(Infi_box::standard_kernel() && spaces==26), "you cannot load an inifinite polyhedron without an extended kernel."); addInfiBox = ((spaces==15 || vn == 0) && Infi_box::extended_kernel()); */ addInfiBox = (kernel_type == "standard" && Infi_box::extended_kernel()); if(addInfiBox) { Vertex_of.reserve(vn+8); Edge_of.reserve(en+24); Halffacet_of.reserve(fn+12); Volume_of.reserve(cn+1); SEdge_of.reserve(sen+48); SLoop_of.reserve(sln); SFace_of.reserve(sfn+16); for(i=0; isncp()->new_vertex_only(); for(i=0; isncp()->new_halfedge_only(); for(i=0; isncp()->new_halffacet_only(); for(i=0; isncp()->new_volume_only(); for(i=0; isncp()->new_shalfedge_only(); for(i=0; isncp()->new_shalfloop_only(); for(i=0; isncp()->new_sface_only(); } else { Vertex_of.reserve(vn); Edge_of.reserve(en); Halffacet_of.reserve(fn); Volume_of.reserve(cn); SEdge_of.reserve(sen); SLoop_of.reserve(sln); SFace_of.reserve(sfn); for(i=0; isncp()->new_vertex_only(); for(i=0; isncp()->new_halfedge_only(); for(i=0; isncp()->new_halffacet_only(); for(i=0; isncp()->new_volume_only(); for(i=0; isncp()->new_shalfedge_only(); for(i=0; isncp()->new_shalfloop_only(); for(i=0; isncp()->new_sface_only(); } if(addInfiBox) { for(i=0; i(Vertex_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in node line"); } for(i=0; i(Edge_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in edge line"); } for(i=0; i(Halffacet_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in facet line"); } for(i=0; i(SEdge_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in sedge line"); } for(i=0; i(SLoop_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in sloop line"); } for(i=0; i(Vertex_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in node line"); } for(i=0; i(Edge_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in edge line"); } for(i=0; i(Halffacet_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in facet line"); } for(i=0; i(SEdge_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in sedge line"); } for(i=0; i(SLoop_of[i])) CGAL_assertion_msg(0,"SNC_io_parser::read: error in sloop line"); } for(i=0; i void SNC_io_parser::print_vertex(Vertex_handle v) const { // syntax: index { svs sve, ses see, sfs sfe, sl | point } mark SM_decorator SD(&*v); out << index(v) << " { "; if(sorted) { output_sorted_indexes(v->svertices_begin(), v->svertices_end(), EI); output_sorted_indexes(v->shalfedges_begin(), v->shalfedges_end(), SEI); output_sorted_indexes(v->sfaces_begin(), v->sfaces_end(), SFI); out << index(SD.shalfloop()) << " | "; } else { out << index(v->svertices_begin()) << " " << index(v->svertices_last()) << ", " << index(v->shalfedges_begin()) << " " << index(v->shalfedges_last()) << ", " << index(v->sfaces_begin()) << " " << index(v->sfaces_last()) << ", " << index(SD.shalfloop()) << " | "; } if(reduce) { Standard_point p(Infi_box::standard_point(point(v))); out << p.hx() << " " << p.hy() << " " << p.hz() << " " << p.hw(); } else { Point_3 p(point(v)); out << p.hx() << " " << p.hy() << " " << p.hz() << " " << p.hw(); } out << " } " << mark(v) << std::endl; } /* template bool SNC_io_parser:: read_vertex(Vertex_handle v) const { // syntax: index { svs sve ses see sfs sfe sl, mark, point } int n, svs, sve, ses, see, sfs, sfe, sl; Mark m; Point_3 p; if ( !(in >> n) || !check_sep("{") || !(in >> svs) || !(in >> sve) || !(in >> ses) || !(in >> see) || !(in >> sfs) || !(in >> sfe) || !(in >> sl) || !check_sep(",") || !(in >> m) || !check_sep(",") || !(in >> p) || !check_sep("}") ) return false; CGAL_assertion_msg( Vertex_of[n] == v && svs >= 0 && svs < en && sve >= 0 && sve < en && ses >= 0 && ses < sen && see >= 0 && see < sen && sfs >= 0 && sfs < sfn && sfe >= 0 && sfe < sfn && sl >= 0 && sl < sln , "wrong index in read_vertex"); v->svertices_begin_ = Edge_of[svs]; v->svertices_last_ = Edge_of[sve]; v->shalfedges_begin_ = SEdge_of[ses]; v->shalfedges_last_ = SEdge_of[see]; v->sfaces_begin_ = SFace_of[sfs]; v->sfaces_last_ = SFace_of[sfe]; v->shalfloop_ = SLoop_of[sl]; mark(v) = m; point(v) = p; return true; } */ template template bool SNC_io_parser:: read_vertex(Vertex_handle vh) { bool OK = true; int index; typename K::RT hx, hy, hz, hw; in >> index; OK = OK && test_string("{"); vh->sncp() = this->sncp(); in >> index; vh->svertices_begin() = (index >= 0 ? Edge_of[index] : this->svertices_end()); in >> index; vh->svertices_last() = index >= 0 ? Edge_of[index] : this->svertices_end(); OK = OK && test_string(","); in >> index; vh->shalfedges_begin() = index >= 0 ? SEdge_of[index] : this->shalfedges_end(); in >> index; vh->shalfedges_last() = index >= 0 ? SEdge_of[index] : this->shalfedges_end(); OK = OK && test_string(","); in >> index; vh->sfaces_begin() = index >= 0 ? SFace_of[index] : this->sfaces_end(); in >> index; vh->sfaces_last() = index >= 0 ? SFace_of[index] : this->sfaces_end(); OK = OK && test_string(","); in >> index; vh->shalfloop() = index >= 0 ? SLoop_of[index] : this->shalfloops_end(); OK = OK && test_string("|"); in >> hx >> hy >> hz >> hw; vh->point() = Point_3(hx,hy,hz,hw); OK = OK && test_string("}"); in >> vh->mark(); return OK; } template void SNC_io_parser::print_edge(Halfedge_handle e) const { // syntax: index { twin, source, isolated incident_object | spoint } mark SM_decorator D(&*vertex(e)); out << index(e) << " { " << index(twin(e)) << ", " << index(source(e)) << ", "; if ( D.is_isolated(e) ) out << "1 " << index(D.face(e)); else out << "0 " << index(D.first_out_edge(e)); out << " | "; if(reduce) { Standard_vector p(Infi_box::standard_vector(e->vector())); out << p.hx() << " " << p.hy() << " " << p.hz() << " " << p.hw(); } else { Vector_3 p(e->vector()); out << p.hx() << " " << p.hy() << " " << p.hz() << " " << p.hw(); } out << " } "<< mark(e) << std::endl; } /* template bool SNC_io_parser:: read_edge(Halfedge_handle e) const { // syntax: index { twin, source, isolated incident_object, mark } int n, et, vs, ef, efm; bool iso; Mark m; if ( !(in >> n) || !check_sep("{") || !(in >> et) || !check_sep(",") || !(in >> vs) || !check_sep(",") || !(in >> iso) || !(in >> ef) || !check_sep(",") || !(in >> m) || !check_sep("}") ) return false; if (iso) efm=sfn; else efm=sen; CGAL_assertion_msg ( Edge_of[n] == e && et >= 0 && et < en && vs >= 0 && vs < vn && ef >= 0 && et < efm , "wrong index in read_edge"); e->twin_ = Edge_of[et]; e->center_vertex() = Vertex_of[vs]; if ( iso ) e->incident_sface_ = SFace_of[ef]; else e->out_sedge() = SEdge_of[ef]; mark(e) = m; return true; } */ template template bool SNC_io_parser:: read_edge(Halfedge_handle eh) { bool OK = true; int index; typename K::RT hx,hy,hz,hw; in >> index; OK = OK && test_string("{"); in >> index; eh->twin() = Edge_of[index]; OK = OK && test_string(","); in >> index; eh->center_vertex() = Vertex_of[index]; OK = OK && test_string(","); in >> index; if(index == 0) { in >> index; eh->out_sedge() = SEdge_of[index]; } else { in >> index; eh->incident_sface() = SFace_of[index]; } OK = OK && test_string("|"); in >> hx >> hy >> hz >> hw; eh->point() = Sphere_point(hx,hy,hz); OK = OK && test_string("}"); in >> eh->mark(); return OK; } template void SNC_io_parser::print_facet(Halffacet_handle f) const { // syntax: index { twin, fclist, ivlist, volume | plane } mark out << index(f) << " { "; out << index(twin(f)) << ", "; Halffacet_cycle_iterator it; CGAL_forall_facet_cycles_of(it,f) if ( it.is_shalfedge() ) out << index(SHalfedge_handle(it)) << ' '; out << ", "; CGAL_forall_facet_cycles_of(it,f) if ( it.is_shalfloop() ) out << index(SHalfloop_handle(it)) << ' '; out << ", " << index(Base::volume(f)) << " | "; if(reduce) { Standard_plane p(Infi_box::standard_plane(plane(f))); out << p.a() << " " << p.b() << " " << p.c() << " " << p.d(); } else { Plane_3 p(plane(f)); out << p.a() << " " << p.b() << " " << p.c() << " " << p.d(); } out << " } " << mark(f) << std::endl; } /* template bool SNC_io_parser:: read_facet(Halffacet_handle f) const { // syntax: index { fclist, ivlist, loop, mark } int n, ei, li; Mark m; if ( !(in >> n) || !check_sep("{") ) return false; while (in >> ei) { CGAL_assertion_msg(ei >= 0 && ei < sen, "wrong index in facet cycle list."); store_boundary_object(SEdge_of[ei],f); } in.clear(); if (!check_sep(",")) { return false; } while (in >> li) { CGAL_assertion_msg(li >= 0 && li < sln, "wrong index in facet cycle list."); store_boundary_object(SLoop_of[li],f); } in.clear(); if (!check_sep(",") || !(in >> m) || !check_sep("}") ) return false; mark(f) = m; return true; } */ template template bool SNC_io_parser:: read_facet(Halffacet_handle fh) { bool OK = true; int index; char cc; typename K::RT a,b,c,d; in >> index; OK = OK && test_string("{"); in >> index; fh->twin() = Halffacet_of[index]; OK = OK && test_string(","); in >> cc; while(isdigit(cc)) { in.putback(cc); in >> index; fh->boundary_entry_objects().push_back(SEdge_of[index]); in >> cc; } in >> cc; while(isdigit(cc)) { in.putback(cc); in >> index; fh->boundary_entry_objects().push_back(SLoop_of[index]); in >> cc; } in >> index; fh->incident_volume() = Volume_of[index+addInfiBox]; OK = OK && test_string("|"); in >> a >> b >> c >> d; fh->plane() = Plane_3(a,b,c,d); OK = OK && test_string("}"); in >> fh->mark(); return OK; } template void SNC_io_parser::print_volume(Volume_handle c) const { // syntax: index { shlist } mark out << index(c) << " { "; Shell_entry_iterator it; CGAL_forall_shells_of(it,c) if(!reduce || Infi_box::is_standard(point(vertex(SFace_handle(it))))) out << index(SFace_handle(it)) << ' '; out << "} " << mark(c) << std::endl; } /* template bool SNC_io_parser:: read_volume(Volume_handle c) const { // syntax: index { shlist, mark } int n, fi; Mark m; if ( !(in >> n) || !check_sep("{") ) return false; while (in >> fi) { CGAL_assertion_msg(fi >= 0 && fi < sfn, "wrong index in shell list."); store_boundary_object(SFace_of[fi],c); } in.clear(); if (!check_sep(",") || !(in >> m) || !check_sep("}") ) return false; mark(c) = m; return true; } */ template bool SNC_io_parser:: read_volume(Volume_handle ch) { bool OK = true; int index; char cc; in >> index; OK = OK && test_string("{"); in >> cc; while(isdigit(cc)) { in.putback(cc); in >> index; ch->shell_entry_objects().push_back(SFace_of[index]); in >> cc; } in >> ch->mark(); return OK; } template void SNC_io_parser:: print_sedge(SHalfedge_handle e) const { //index { twin, sprev, snext, source, sface, prev, next, facet | circle } mark SM_decorator D(&*vertex(e)); out << index(e) << " { " << index(D.twin(e)) << ", " << index(D.previous(e)) << ", " << index(D.next(e)) << ", " << index(D.source(e)) << ", " << index(D.face(e)) << ", " << index(previous(e)) << ", " << index(next(e)) << ", " << index(facet(e)) << " | "; if(reduce) { Standard_plane p(Infi_box::standard_plane(circle(e))); out << p.a() << " " << p.b() << " " << p.c() << " " << p.d(); } else { Plane_3 p(circle(e)); out << p.a() << " " << p.b() << " " << p.c() << " " << p.d(); } out << " } " << D.mark(e) << "\n"; } /* template bool SNC_io_parser:: read_sedge(SHalfedge_handle e) const { // syntax: index { twin, sprev, snext, source, sface, prev, next, facet } int n, et, sp, sn, vs, sf, ep, en, ft; if ( !(in >> n) || !check_sep("{") || !(in >> et) || !check_sep(",") || !(in >> sp) || !check_sep(",") || !(in >> sn) || !check_sep(",") || !(in >> vs) || !check_sep(",") || !(in >> sf) || !check_sep(",") || !(in >> ep) || !check_sep(",") || !(in >> en) || !check_sep(",") || !(in >> ft) || !check_sep("}") ) return false; CGAL_assertion_msg (et >= 0 && et < sen && sp >= 0 && sp < sen && sn >= 0 && sn < sen && vs >= 0 && vs < en && sf >= 0 && sf < sfn && ep >= 0 && ep < sen && en >= 0 && en < sen && ft >= 0 && ft < fn , "wrong index in read_sedge"); // precond: features exist! CGAL_assertion(SEdge_of[n]==e); e->sprev() = SEdge_of[sp]; e->snext() = SEdge_of[sn]; e->source() = Edge_of[vs]; e->incident_sface() = SFace_of[sf]; e->prev() = SEdge_of[ep]; e->next() = SEdge_of[en]; e->facet() = Halffacet_of[ft]; return true; } */ template template bool SNC_io_parser:: read_sedge(SHalfedge_handle seh) { bool OK = true; int index; typename K::RT a,b,c,d; in >> index; OK = OK && test_string("{"); in >> index; seh->twin() = SEdge_of[index]; OK = OK && test_string(","); in >> index; seh->sprev() = SEdge_of[index]; OK = OK && test_string(","); in >> index; seh->snext() = SEdge_of[index]; OK = OK && test_string(","); in >> index; seh->source() = Edge_of[index]; OK = OK && test_string(","); in >> index; seh->incident_sface() = SFace_of[index]; OK = OK && test_string(","); in >> index; seh->prev() = SEdge_of[index]; OK = OK && test_string(","); in >> index; seh->next() = SEdge_of[index]; OK = OK && test_string(","); in >> index; seh->facet() = Halffacet_of[index]; OK = OK && test_string("|"); in >> a >> b >> c >> d; seh->circle() = Sphere_circle(Plane_3(a,b,c,d)); OK = OK && test_string("}"); in >> seh->mark(); return OK; } template void SNC_io_parser:: print_sloop(SHalfloop_handle l) const { // syntax: index { twin, sface, facet | circle } mark SM_decorator D(&*vertex(l)); out << index(l) << " { " << index(D.twin(l)) << ", " << index(D.face(l)) << ", " << index(facet(l)) << " | "; if(reduce) { Standard_plane p(Infi_box::standard_plane(circle(l))); out << p.a() << " " << p.b() << " " << p.c() << " " << p.d(); } else { Plane_3 p(circle(l)); out << p.a() << " " << p.b() << " " << p.c() << " " << p.d(); } out << " } " << D.mark(l) << "\n"; } /* template bool SNC_io_parser:: read_sloop(SHalfloop_handle l) const { // syntax: index { twin, sface, facet } int n, lt, sf, ft; if ( !(in >> n) || !check_sep("{") || !(in >> lt) || !check_sep(",") || !(in >> sf) || !check_sep(",") || !(in >> ft) || !check_sep("}") ) return false; CGAL_assertion_msg (lt >= 0 && lt < sen && sf >= 0 && sf < sfn && ft >= 0 && ft < fn , "wrong index in read_sedge"); CGAL_assertion(SLoop_of[n]==l); l->twin_ = SLoop_of[lt]; l->incident_sface_ = SFace_of[sf]; l->facet_ = Halffacet_of[ft]; return true; } */ template template bool SNC_io_parser:: read_sloop(SHalfloop_handle slh) { bool OK = true; int index; typename K::RT a,b,c,d; in >> index; OK = OK && test_string("{"); in >> index; slh->twin() = SLoop_of[index]; OK = OK && test_string(","); in >> index; slh->incident_sface() = SFace_of[index]; OK = OK && test_string(","); in >> index; slh->facet() = Halffacet_of[index]; OK = OK && test_string("|"); in >> a >> b >> c >> d; slh->circle() = Sphere_circle(Plane_3(a,b,c,d)); OK = OK && test_string("}"); in >> slh->mark(); return OK; } template void SNC_io_parser:: print_sface(SFace_handle f) const { // syntax: index { vertex, fclist, ivlist, sloop, volume } SM_decorator D(&*f->center_vertex()); out << index(f) << " { " << index(f->center_vertex()) << ", "; SFace_cycle_iterator it; CGAL_forall_sface_cycles_of(it,f) if ( it.is_shalfedge() ) out << index(SHalfedge_handle(it)) << ' '; out << ", "; CGAL_forall_sface_cycles_of(it,f) if ( it.is_svertex() ) out << index(SVertex_handle(it)) << ' '; out << ", "; CGAL_forall_sface_cycles_of(it,f) if ( it.is_shalfloop() ) out << index(SHalfloop_handle(it)); out << ", " << index(Base::volume(f)) << " } " << D.mark(f) <<"\n"; } /* template bool SNC_io_parser:: read_sface(SFace_handle f) const { // syntax: index { vertex, fclist, ivlist, sloop, volume } int n, vc, ei, vi, li, c; if ( !(in >> n) || !check_sep("{") || !(in >> vc) || !check_sep(",") ) return false; CGAL_assertion(vc >= 0 && vc < vn); f->center_vertex() = Vertex_of[vc]; SM_decorator D(&*Vertex_of[vc]); while (in >> ei) { CGAL_assertion_msg(ei >= 0 && ei < sen, "wrong index in sface cycle list."); D.store_boundary_object(SEdge_of[ei],f); } in.clear(); while (in >> vi) { CGAL_assertion_msg(vi >= 0 && vi < en, "wrong index in sface cycle list."); D.store_boundary_object(Edge_of[vi],f); } in.clear(); if (!check_sep(",")) { return false; } while (in >> li) { CGAL_assertion_msg(li >= 0 && li < sln, "wrong index in sface cycle list."); D.store_boundary_object(SLoop_of[li],f); } in.clear(); if (!check_sep(",") || !(in >> c) || !check_sep("}") ) return false; f->incident_volume_ = Volume_of[c]; return true; } */ template bool SNC_io_parser:: read_sface(SFace_handle sfh) { bool OK = true; int index; char cc; in >> index; OK = OK && test_string("{"); in >> index; sfh->center_vertex() = Vertex_of[index]; OK = OK && test_string(","); in >> cc; while(isdigit(cc)) { in.putback(cc); in >> index; sfh->boundary_entry_objects().push_back(SEdge_of[index]); in >> cc; } in >> cc; while(isdigit(cc)) { in.putback(cc); in >> index; sfh->boundary_entry_objects().push_back(Edge_of[index]); in >> cc; } in >> cc; while(isdigit(cc)) { in.putback(cc); in >> index; sfh->boundary_entry_objects().push_back(SLoop_of[index]); in >> cc; } in >> index; sfh->volume() = Volume_of[index+addInfiBox]; OK = OK && test_string("}"); in >> sfh->mark(); return OK; } template void SNC_io_parser::print_local_graph(Vertex_handle v) const { SM_decorator D(&*v); out << "Local Graph " << D.number_of_vertices() << " " << D.number_of_edges() << " " << D.number_of_loops() << " " << D.number_of_faces() << " " << std::endl; if (verbose) out << "/* index { twin, source, isolated incident_object, mark } */\n"; SVertex_iterator vit; CGAL_forall_svertices_of(vit,v) print_edge(vit); if (verbose) out << "/* index { twin, sprev, snext, source, sface," << " prev, next, facet } */\n"; SHalfedge_iterator eit; CGAL_forall_shalfedges_of(eit,v) print_sedge(eit); if (verbose) out << "/* index { twin, sface, facet } */" << std::endl; if ( D.has_sloop() ) { print_sloop(D.loop()); print_sloop(D.twin(D.loop())); } if (verbose) out << "/* index { fclist, ivlist, sloop, volume } */" << std::endl; SFace_iterator fit; CGAL_forall_sfaces_of(fit,v) print_sface(fit); out.flush(); } template void SNC_io_parser::add_infi_box() { typename Standard_kernel::RT hx,hy,hz,hw; for(int i=0; i<8; i++) { Vertex_handle vh = Vertex_of[vn+i]; vh->svertices_begin() = Edge_of[en+3*i]; vh->svertices_last() = Edge_of[en+3*i+2]; vh->shalfedges_begin() = SEdge_of[sen+6*i]; vh->shalfedges_last() = SEdge_of[sen+6*i+5]; vh->sfaces_begin() = SFace_of[sfn+2*i]; vh->sfaces_last() = SFace_of[sfn+2*i+1]; vh->shalfloop() = this->shalfloops_end(); hx = i % 2 ? -1 : 1; hy = i % 4 > 1 ? -1 : 1; hz = i > 3 ? -1 : 1; vh->point() = Infi_box::create_extended_point(hx, hy, hz); vh->mark() = 1; vh->sncp() = this->sncp(); } int seOff[3] = {0, 1, 3}; int twinIdx[24] = { 3, 7,14, 0,10,17, 9, 1,20, 6, 4,23, 15,19, 2, 12,22, 5, 21,13, 8, 18,16,11}; for(int i = 0; i < 24; i++) { Halfedge_handle eh = Edge_of[en+i]; eh->twin() = Edge_of[en+twinIdx[i]]; eh->center_vertex() = Vertex_of[vn+(i/3)]; eh->out_sedge() = SEdge_of[sen+(i/3*6)+seOff[i%3]]; switch(i%3) { case 0 : hx = i % 6 ? 1 : -1; hy = hz = 0; break; case 1: hy = i % 12 >= 6 ? 1 : -1; hx = hz = 0; break; case 2: hz = i >= 12 ? 1 : -1; hx = hy = 0; break; } eh->point() = Sphere_point(hx,hy,hz); eh->mark() = 1; } int bnd[12] = {19, 18, 43, 42, 35, 34, 47, 46, 39, 38, 45, 44}; for(int i = 0; i < 12; i++) { Halffacet_handle fh = Halffacet_of[fn+i]; fh->twin() = Halffacet_of[fn+(i/2*2)+((i+1)%2)]; fh->boundary_entry_objects().push_back(SEdge_of[sen+bnd[i]]); fh->incident_volume() = Volume_of[((i%4) == 1 || (i%4 == 2)) ? 1 : 0]; if(i<4) { hz = i % 2 ? -1 : 1; hx = hy = 0; } else if(i<8) { hy = i % 2 ? -1 : 1; hx = hz = 0; } else { hx = i % 2 ? -1 : 1; hz = hy = 0; } hw = ((i%4) == 1 || (i%4) == 2) ? 1 : -1; fh->plane() = Infi_box::create_extended_plane(hx,hy,hz,hw); fh->mark() = 1; } Volume_of[0]->shell_entry_objects().push_back(SFace_of[sfn]); Volume_of[0]->mark() = 0; Volume_of[1]->shell_entry_objects().push_front(SFace_of[sfn+1]); int sprevOff[6] = {4,3,0,5,2,1}; int snextOff[6] = {2,5,4,1,0,3}; int prevIdx[48] = {7,12,15,26,29,10, 1,18,21,32,35,4, 19,0,3,38,41,22, 13,6,9,44,47,16, 31,36,39,2,5,34, 25,42,45,8,11,28, 43,24,27,14,17,46, 37,30,33,20,23,40}; int nextIdx[48] = {13,6,27,14,11,28, 19,0,33,20,5,34, 1,18,39,2,23,40, 7,12,45,8,17,46, 37,30,3,38,35,4, 43,24,9,44,29,10, 25,42,15,26,47,16, 31,36,21,32,41,22}; int factIdx[48] = {1,0,9,8,5,4, 0,1,11,10,4,5, 0,1,8,9,7,6, 1,0,10,11,6,7, 3,2,8,9,4,5, 2,3,10,11,5,4, 2,3,9,8,6,7, 3,2,11,10,7,6}; int sgn[24] = {1,1,1,-1,1,-1, -1,-1,1,1,-1,-1, 1,-1,-1,-1,-1,1, -1,1,-1,1,1,1}; for(int i = 0; i < 48; i++) { SHalfedge_handle seh = SEdge_of[sen+i]; seh->twin() = SEdge_of[sen+(i/2*2)+((i+1)%2)]; seh->sprev() = SEdge_of[sen+sprevOff[i%6]+(i/6*6)]; seh->snext() = SEdge_of[sen+snextOff[i%6]+(i/6*6)]; seh->source() = Edge_of[en+((i+1)%6)/2+(i/6)*3]; seh->incident_sface() = SFace_of[sfn+(i%2)+(i/6)*2]; seh->prev() = SEdge_of[sen+prevIdx[i]]; seh->next() = SEdge_of[sen+nextIdx[i]]; seh->facet() = Halffacet_of[fn+factIdx[i]]; if(i%6 < 2) { hz = (i%2) ? sgn[i/2] * (-1) : sgn[i/2]; hx = hy = 0; } else if(i%6 < 4) { hx = (i%2) ? sgn[i/2] * (-1) : sgn[i/2]; hz = hy = 0; } else { hy = (i%2) ? sgn[i/2] * (-1) : sgn[i/2]; hx = hz = 0; } seh->circle() = Sphere_circle(Plane_3(RT(hx),RT(hy),RT(hz),RT(0))); seh->mark() = 1; } int volIdx[8] = {0,1,1,0,1,0,0,1}; for(int i = 0; i < 16; i++) { SFace_handle sfh = SFace_of[sfn+i]; sfh->center_vertex() = Vertex_of[vn+(i/2)]; sfh->boundary_entry_objects().push_back(SEdge_of[sen+(i/2*6)+(i%2)]); int cIdx = i%2 ? 1-volIdx[i/2] : volIdx[i/2]; sfh->volume() = Volume_of[cIdx]; sfh->mark() = cIdx ? Volume_of[1]->mark() : 0; } } CGAL_END_NAMESPACE #endif //CGAL_SNC_IO_PARSER_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_decorator_traits.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_decorator_tr0000644000175000017500000001072511344301501031075 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_decorator_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef SNC_DECORATOR_TRAITS_H #define SNC_DECORATOR_TRAITS_H #include #include template class SM_decorator; template class SM_const_decorator; template class SNC_decorator_traits : public SM_decorator_traits { typedef Refs_ Refs; typedef typename Refs::Sphere_map Sphere_map; public: typedef CGAL::SM_decorator SM_decorator; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halffacet_handle Halffacet_handle; typedef typename Refs::Volume_handle Volume_handle; typedef typename Refs::SVertex_handle SVertex_handle; typedef typename Refs::SHalfedge_handle SHalfedge_handle; typedef typename Refs::SHalfloop_handle SHalfloop_handle; typedef typename Refs::SFace_handle SFace_handle; typedef typename Refs::Vertex_iterator Vertex_iterator; typedef typename Refs::Halfedge_iterator Halfedge_iterator; typedef typename Refs::Halffacet_iterator Halffacet_iterator; typedef typename Refs::Volume_iterator Volume_iterator; typedef typename Refs::SVertex_iterator SVertex_iterator; typedef typename Refs::SHalfedge_iterator SHalfedge_iterator; typedef typename Refs::SHalfloop_iterator SHalfloop_iterator; typedef typename Refs::SFace_iterator SFace_iterator; typedef typename Refs::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename Refs::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename Refs::SFace_cycle_iterator SFace_cycle_iterator; typedef typename Refs::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename Refs::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename Refs::Shell_entry_iterator Shell_entry_iterator; }; template class SNC_decorator_const_traits { typedef Refs_ Refs; typedef typename Refs::Sphere_map Sphere_map; public: typedef CGAL::SM_const_decorator SM_decorator; typedef typename Refs::Vertex_const_handle Vertex_handle; typedef typename Refs::Halfedge_const_handle Halfedge_handle; typedef typename Refs::Halffacet_const_handle Halffacet_handle; typedef typename Refs::Volume_const_handle Volume_handle; typedef typename Refs::SVertex_const_handle SVertex_handle; typedef typename Refs::SHalfedge_const_handle SHalfedge_handle; typedef typename Refs::SHalfloop_const_handle SHalfloop_handle; typedef typename Refs::SFace_const_handle SFace_handle; typedef typename Refs::Vertex_const_iterator Vertex_iterator; typedef typename Refs::Halfedge_const_iterator Halfedge_iterator; typedef typename Refs::Halffacet_const_iterator Halffacet_iterator; typedef typename Refs::Volume_const_iterator Volume_iterator; typedef typename Refs::SVertex_const_iterator SVertex_iterator; typedef typename Refs::SHalfedge_const_iterator SHalfedge_iterator; typedef typename Refs::SHalfloop_const_iterator SHalfloop_iterator; typedef typename Refs::SFace_const_iterator SFace_iterator; typedef typename Refs::SHalfedge_around_svertex_const_circulator SHalfedge_around_svertex_circulator; typedef typename Refs::SHalfedge_around_sface_const_circulator SHalfedge_around_sface_circulator; typedef typename Refs::SFace_cycle_const_iterator SFace_cycle_iterator; typedef typename Refs::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_circulator; typedef typename Refs::Halffacet_cycle_const_iterator Halffacet_cycle_iterator; typedef typename Refs::Shell_entry_const_iterator Shell_entry_iterator; }; #endif // SNC_DECORATOR_TRAITS_H ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/quotient_coordinates_to_homogeneous_point.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/quotient_coordin0000644000175000017500000000341211344301501031263 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/quotient_coordinates_to_homogeneous_point.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Miguel Granados #ifndef QUOTIENT_COORDINATES_TO_HOMOGENEOUS_POINT_H #define QUOTIENT_COORDINATES_TO_HOMOGENEOUS_POINT_H CGAL_BEGIN_NAMESPACE template typename Homogeneous::Point_3 quotient_coordinates_to_homogeneous_point( typename Homogeneous::FT x, typename Homogeneous::FT y, typename Homogeneous::FT z) { typedef typename Homogeneous::Point_3 Point_3; if( (x.denominator() == y.denominator()) && (x.denominator() == z.denominator())) { Point_3 p( x.numerator(), y.numerator(), z.numerator(), x.denominator()); return normalized(p); } else { Point_3 p( x.numerator() * y.denominator() * z.denominator(), x.denominator() * y.numerator() * z.denominator(), x.denominator() * y.denominator() * z.numerator(), x.denominator() * y.denominator() * z.denominator()); return normalized(p); } } CGAL_END_NAMESPACE #endif // QUOTIENT_COORDINATES_TO_HOMOGENEOUS_POINT_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_explorer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_explorer.0000644000175000017500000000261311344301501030720 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_SM_explorer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger #ifndef CGAL_SNC_SM_EXPLORER_H #define CGAL_SNC_SM_EXPLORER_H #include #include CGAL_BEGIN_NAMESPACE template class SNC_SM_explorer : public SMCDEC { typedef SMCDEC Base; typedef SNC_SM_explorer Self; // typedef typename Base::Kernel Kernel; // typedef typename Kernel::Point_3 Point_3; public: SNC_SM_explorer(const Base& E) : Base(E) {} Self& operator=(const Self& E) { Base::operator=(E); return *this; } }; CGAL_END_NAMESPACE #endif // CGAL_SNC_SM_EXPLORER_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_point_locator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_point_locato0000644000175000017500000010101311344301501031067 0ustar debiandebian#line 7 "point_locator.nw" // Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_point_locator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Miguel Granados #ifndef SNC_POINT_LOCATOR_H #define SNC_POINT_LOCATOR_H #include #include #include #include #include #include #include // #include // #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 509 #include #undef _CGAL_NEF_TRACEN #define _CGAL_NEF_TRACEN(msg) CGAL_NEF_TRACEN( "SNC_point_locator: " << msg); // TODO: find out the proper CGAL replacement for this macro and remove it #define CGAL_for_each( i, C) for( i = C.begin(); i != C.end(); ++i) // #define TIMER(instruction) instruction #define TIMER(instruction) // #define CLOG(t) std::clog <<" "< class SNC_point_locator { public: class Intersection_call_back; typedef SNC_point_locator Self; typedef typename SNC_decorator::Decorator_traits Decorator_traits; typedef typename SNC_decorator::SNC_structure SNC_structure; protected: char version_[64]; // time for construction, point location, ray shooting and intersection test mutable Timer ct_t, pl_t, rs_t, it_t; public: typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Ray_3 Ray_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Triangle_3 Triangle_3; typedef typename SNC_structure::Aff_transformation_3 Aff_transformation_3; typedef typename Decorator_traits::Vertex_handle Vertex_handle; typedef typename Decorator_traits::Halfedge_handle Halfedge_handle; typedef typename Decorator_traits::Halffacet_handle Halffacet_handle; typedef typename Decorator_traits::Volume_handle Volume_handle; typedef typename Decorator_traits::Vertex_iterator Vertex_iterator; typedef typename Decorator_traits::Halfedge_iterator Halfedge_iterator; typedef typename Decorator_traits::Halffacet_iterator Halffacet_iterator; const char* version() { return version_; } virtual Object_handle locate(const Point_3& p) const = 0; virtual Object_handle shoot(const Ray_3& s) const = 0; virtual void intersect_with_edges( Halfedge_const_handle edge, const Intersection_call_back& call_back) const = 0; virtual void intersect_with_facets( Halfedge_const_handle edge, const Intersection_call_back& call_back) const = 0; virtual void intersect_with_edges_and_facets( Halfedge_const_handle edge, const Intersection_call_back& call_back) const = 0; class Intersection_call_back { public: virtual void operator()( Halfedge_const_handle edge, Object_handle object, const Point_3& intersection_point) const = 0; }; virtual void initialize(SNC_structure* W) = 0; virtual Self* clone() const = 0; virtual void transform(const Aff_transformation_3& t) = 0; //virtual bool update( Unique_hash_map& V, // Unique_hash_map& E, // Unique_hash_map& F) = 0; virtual ~SNC_point_locator() { CLOG(""); CLOG("construction_time: "< class SNC_point_locator_by_spatial_subdivision : public SNC_point_locator, public SNC_decorator { typedef SNC_decorator Base; typedef CGAL::SNC_point_locator SNC_point_locator; typedef CGAL::SNC_point_locator_by_spatial_subdivision Self; typedef typename SNC_decorator::SNC_structure SNC_structure; typedef typename SNC_decorator::Decorator_traits Decorator_traits; typedef typename Decorator_traits::SM_decorator SM_decorator; typedef CGAL::SNC_intersection SNC_intersection; typedef typename SNC_decorator::SM_point_locator SM_point_locator; typedef typename SNC_decorator::Kernel Kernel; public: typedef typename CGAL::SNC_k3_tree_traits K3_tree_traits; typedef typename CGAL::K3_tree K3_tree; typedef K3_tree SNC_candidate_provider; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_structure::Halffacet_const_handle Halffacet_const_handle; typedef typename SNC_structure::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Segment_3 Segment_3; typedef typename SNC_structure::Ray_3 Ray_3; typedef typename SNC_structure::Vector_3 Vector_3; typedef typename SNC_structure::Triangle_3 Triangle_3; typedef typename SNC_structure::Aff_transformation_3 Aff_transformation_3; typedef typename SNC_structure::Infi_box Infi_box; typedef typename Decorator_traits::Vertex_handle Vertex_handle; typedef typename Decorator_traits::Halfedge_handle Halfedge_handle; typedef typename Decorator_traits::Halffacet_handle Halffacet_handle; typedef typename Decorator_traits::SHalfedge_handle SHalfedge_handle; typedef typename Decorator_traits::SFace_handle SFace_handle; typedef typename Decorator_traits::Vertex_iterator Vertex_iterator; typedef typename Decorator_traits::Halfedge_iterator Halfedge_iterator; typedef typename Decorator_traits::Halffacet_iterator Halffacet_iterator; typedef typename Decorator_traits::Volume_handle Volume_handle; typedef typename SNC_candidate_provider::Object_list Object_list; typedef typename Object_list::iterator Object_list_iterator; typedef typename SNC_candidate_provider::Objects_along_ray Objects_along_ray; typedef typename Objects_along_ray::Iterator Objects_along_ray_iterator; public: SNC_point_locator_by_spatial_subdivision() : initialized(false), candidate_provider(0) {} virtual void initialize(SNC_structure* W) { TIMER(ct_t.start()); strcpy( this->version_, "Point Locator by Spatial Subdivision (tm)"); #ifdef CGAL_NEF3_TRIANGULATE_FACETS CLOG(version()<<" (with triangulated facets)"); #else CLOG(version()); #endif CGAL_assertion( W != NULL); // (Base) *this = SNC_decorator(*W); set_snc(*W); initialized = true; Object_list objects; Vertex_iterator v; Halfedge_iterator e; Halffacet_iterator f; CGAL_forall_vertices( v, *this->sncp()) objects.push_back(Object_handle(Vertex_handle(v))); typename Object_list::difference_type v_end = objects.size(); CGAL_forall_edges( e, *this->sncp()) objects.push_back(Object_handle(Halfedge_handle(e))); CGAL_forall_facets( f, *this->sncp()) { #ifdef CGAL_NEF3_TRIANGULATE_FACETS typedef typename std::list Triangles; typedef typename Triangles::const_iterator Triangles_iterator; typedef Polygon_triangulation_traits_2 Triangulation_traits; Triangles triangles; triangulate_facet ( f, std::back_inserter(triangles), Triangulation_traits()); for( Triangles_iterator ti = triangles.begin(); ti != triangles.end(); ++ti) { Halffacet_triangle_handle th( f, *ti); objects.push_back(Object_handle(th)); CGAL_assertion( CGAL::assign( th, *(--objects.end()))); CGAL_assertion( th.get_triangle() == *ti); } #else objects.push_back(Object_handle(Halffacet_handle(f))); #endif // CGAL_NEF3_TRIANGULATE_FACETS } Object_list_iterator oli=objects.begin()+v_end; candidate_provider = new SNC_candidate_provider(objects,oli); // CGAL_NEF_TRACEN(*candidate_provider); TIMER(ct_t.stop()); } virtual Self* clone() const { return new Self; } virtual void transform(const Aff_transformation_3& t) { candidate_provider->transform(t); } virtual bool update( Unique_hash_map& V, Unique_hash_map& E, Unique_hash_map& F) { TIMER(ct_t.start()); CGAL_assertion( initialized); bool updated = candidate_provider->update( V, E, F); TIMER(ct_t.stop()); return updated; } virtual ~SNC_point_locator_by_spatial_subdivision() { CGAL_warning( initialized); // required? delete candidate_provider; } virtual Object_handle shoot(const Ray_3& ray) const { TIMER(rs_t.start()); CGAL_assertion( initialized); _CGAL_NEF_TRACEN( "shooting: "<objects_along_ray(ray); Objects_along_ray_iterator objects_iterator = objects.begin(); while( !hit && objects_iterator != objects.end()) { Object_list candidates = *objects_iterator; Object_list_iterator o; CGAL_for_each( o, candidates) { if( CGAL::assign( v, *o)) { _CGAL_NEF_TRACEN("trying vertex on "<source()->point(),e->twin()->source()->point())); if( is.does_intersect_internally( ray, Segment_3(e->source()->point(), e->twin()->source()->point()), q)) { _CGAL_NEF_TRACEN("ray intersects edge on "<is_point_on_cell( q, objects_iterator)); if( !candidate_provider->is_point_on_cell( q, objects_iterator)) continue; eor = q; result = Object_handle(e); hit = true; _CGAL_NEF_TRACEN("the edge becomes the new hit object"); } } else if( CGAL::assign( f, *o)) { Point_3 q; _CGAL_NEF_TRACEN("trying facet with on plane "<is_point_on_cell( q, objects_iterator)); if( !candidate_provider->is_point_on_cell( q, objects_iterator)) continue; eor = q; result = Object_handle(f); hit = true; _CGAL_NEF_TRACEN("the facet becomes the new hit object"); } } else if( CGAL::assign( t, *o)) { Point_3 q; Triangle_3 tr = t.get_triangle(); _CGAL_NEF_TRACEN("trying triangle "<is_point_on_cell(q,objects_iterator)); if( !candidate_provider->is_point_on_cell( q, objects_iterator)) continue; eor = q; result = Object_handle(Halffacet_handle(t)); hit = true; _CGAL_NEF_TRACEN("the facet becomes the new hit object"); } } else CGAL_assertion_msg( 0, "wrong handle"); } if(!hit) ++objects_iterator; } TIMER(rs_t.stop()); return result; } virtual Object_handle locate( const Point_3& p) const { if(Infi_box::extended_kernel()) { TIMER(pl_t.start()); CGAL_assertion( initialized); _CGAL_NEF_TRACEN( "locate "<objects_around_point(p); Object_list_iterator o = candidates.begin(); bool found = false; while( !found && o != candidates.end()) { if( CGAL::assign( v, *o)) { if ( p == point(v)) { _CGAL_NEF_TRACEN("found on vertex "<source()->point(),e->twin()->source()->point()), p) ) { _CGAL_NEF_TRACEN("found on edge "<source()->point(),e->twin()->source()->point())); result = Object_handle(e); found = true; } } else if( CGAL::assign( f, *o)) { if ( is.does_contain_internally( f, p) ) { _CGAL_NEF_TRACEN("found on facet..."); result = Object_handle(f); found = true; } } else if( CGAL::assign( t, *o)) { Triangle_3 tr = t.get_triangle(); if( tr.has_on(p)) { _CGAL_NEF_TRACEN("found on triangle "<objects_around_point(p); Object_list_iterator o = candidates.begin(); if(candidates.empty()) return Base(*this).volumes_begin(); CGAL::assign(v,*o); CGAL_assertion(CGAL::assign(v,*o)); if(p==point(v)) return Object_handle(v); min_distance = CGAL::squared_distance(point(v),p); result = Object_handle(v); ++o; while(o!=candidates.end() && CGAL::assign(v,*o)) { if ( p == point(v)) { _CGAL_NEF_TRACEN("found on vertex "<point(),p); if(tmp_distance < min_distance) { result = Object_handle(v); min_distance = tmp_distance; } ++o; } CGAL::assign(v, result); Segment_3 s(p,point(v)); Point_3 ip; // Object_list_iterator ox(o); for(;o!=candidates.end();++o) { if( CGAL::assign( e, *o)) { Segment_3 ss(e->source()->point(),e->twin()->source()->point()); CGAL_NEF_TRACEN("test edge " << e->source()->point() << "->" << e->twin()->source()->point()); if(is.does_contain_internally(ss, p) ) { _CGAL_NEF_TRACEN("found on edge "<< ss); return Object_handle(e); } if(is.does_intersect_internally(s, ss, ip)) { s = Segment_3(p, normalized(ip)); result = Object_handle(e); } } else if( CGAL::assign( f, *o)) { CGAL_NEF_TRACEN("test facet " << f->plane()); if (is.does_contain_internally(f,p) ) { _CGAL_NEF_TRACEN("found on facet..."); return Object_handle(f); } if( is.does_intersect_internally(s,f,ip)) { s = Segment_3(p, normalized(ip)); result = Object_handle(f); } } else CGAL_assertion_msg(false, "wrong handle type"); } if( CGAL::assign( v, result)) { _CGAL_NEF_TRACEN("vertex hit, obtaining volume..."); SM_point_locator L(&*v); Object_handle so = L.locate(s.source()-s.target()); SFace_handle sf; if(CGAL::assign(sf,so)) return sf->volume(); CGAL_assertion_msg(false, "wrong handle type"); /* SHalfedge_handle se; CGAL_assertion(CGAL::assign(se,so)); CGAL_NEF_TRACEN("intersect segment " << s << " with edges"); for(;ox!=candidates.end();++ox) { if(!CGAL::assign(e,*ox)) continue; CGAL_NEF_TRACEN("test edge " << e->source()->point() << "->" << e->twin()->source()->point()); if(is.does_intersect_internally(s,Segment_3(e->source()->point(),e->twin()->source()->point()),ip)) { s = Segment_3(p, normalized(ip)); result = Object_handle(e); } } CGAL_assertion(CGAL::assign(e,result)); CGAL::assign(e,result); f = get_visible_facet(e, Ray_3(p, s.target())); if( f != Halffacet_handle()) return f->incident_volume(); SM_decorator SD(&*v); // now, the vertex has no incident facets CGAL_assertion( SD.number_of_sfaces() == 1); return SD.sfaces_begin()->volume(); */ } else if( CGAL::assign( f, result)) { _CGAL_NEF_TRACEN("facet hit, obtaining volume..."); if(f->plane().oriented_side(p) == ON_NEGATIVE_SIDE) f = f->twin(); return Object_handle(f->incident_volume()); } else if( CGAL::assign(e, result)) { SM_decorator SD(&*source(e)); if( SD.is_isolated(e)) return Object_handle(e->incident_sface()->volume()); return get_visible_facet(e,Ray_3(s.source(),s.to_vector()))->incident_volume(); } CGAL_assertion_msg(false, "wrong handle type"); return Object_handle(); } } virtual void intersect_with_edges_and_facets( Halfedge_const_handle e0, const typename SNC_point_locator::Intersection_call_back& call_back) const { TIMER(it_t.start()); CGAL_assertion( initialized); _CGAL_NEF_TRACEN( "intersecting edge: "<<&*e0<<' '<source()->point(), e0->twin()->source()->point())); #ifdef CGAL_NEF3_TRIANGULATE_FACETS Unique_hash_map< Halffacet_triangle_handle, bool> f_mark(false); #endif // CGAL_NEF3_TRIANGULATE_FACETS Segment_3 s(Segment_3(e0->source()->point(),e0->twin()->source()->point())); Vertex_handle v; Halfedge_handle e; Halffacet_handle f; Halffacet_triangle_handle t; Object_list_iterator o; Object_list objects = candidate_provider->objects_around_segment(s); CGAL_for_each( o, objects) { if( CGAL::assign( v, *o)) { /* do nothing */ } else if( CGAL::assign( e, *o)) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Point_3 q; if( is.does_intersect_internally( s, Segment_3(e->source()->point(), e->twin()->source()->point()), q)) { q = normalized(q); call_back( e0, Object_handle(Halfedge_const_handle(e)), q); _CGAL_NEF_TRACEN("edge intersects edge "<<' '<<&*e<< Segment_3(e->source()->point(), e->twin()->source()->point())<<" on "<source()->point(), e0->twin()->source()->point())); Segment_3 s(Segment_3(e0->source()->point(),e0->twin()->source()->point())); Vertex_handle v; Halfedge_handle e; Halffacet_handle f; Halffacet_triangle_handle t; Object_list_iterator o; Object_list objects = candidate_provider->objects_around_segment(s); CGAL_for_each( o, objects) { if( CGAL::assign( v, *o)) { /* do nothing */ } else if( CGAL::assign( e, *o)) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Point_3 q; if( is.does_intersect_internally( s, Segment_3(e->source()->point(), e->twin()->source()->point()), q)) { q = normalized(q); call_back( e0, Object_handle(Halfedge_const_handle(e)), q); _CGAL_NEF_TRACEN("edge intersects edge "<<' '<<&*e<< Segment_3(e->source()->point(), e->twin()->source()->point())<<" on "<source()->point(), e0->twin()->source()->point())); #ifdef CGAL_NEF3_TRIANGULATE_FACETS Unique_hash_map< Halffacet_triangle_handle, bool> f_mark(false); #endif // CGAL_NEF3_TRIANGULATE_FACETS Segment_3 s(Segment_3(e0->source()->point(),e0->twin()->source()->point())); Vertex_handle v; Halfedge_handle e; Halffacet_handle f; Halffacet_triangle_handle t; Object_list_iterator o; Object_list objects = candidate_provider->objects_around_segment(s); CGAL_for_each( o, objects) { if( CGAL::assign( v, *o)) { /* do nothing */ } else if( CGAL::assign( e, *o)) { /* do nothing */ } else if( CGAL::assign( f, *o)) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Point_3 q; if( is.does_intersect_internally( s, f, q) ) { q = normalized(q); call_back( e0, Object_handle(Halffacet_const_handle(f)), q); _CGAL_NEF_TRACEN("edge intersects facet on plane "<incident_volume(); SM_decorator SD(&*v); // now, the vertex has no incident facets CGAL_assertion( SD.number_of_sfaces() == 1); return SD.sfaces_begin()->volume(); } else if( CGAL::assign( e, o)) { _CGAL_NEF_TRACEN("edge hit, obtaining volume..."); f_below = get_visible_facet( e, ray); if( f_below != Halffacet_handle()) return f_below->incident_volume(); CGAL_assertion_code(SM_decorator SD(&*source(e))); // now, the edge has no incident facets CGAL_assertion(SD.is_isolated(e)); return sface(e)->volume(); } else if( CGAL::assign( f, o)) { _CGAL_NEF_TRACEN("facet hit, obtaining volume..."); f_below = get_visible_facet(f, ray); CGAL_assertion( f_below != Halffacet_handle()); return f_below->incident_volume(); } return Base(*this).volumes_begin(); // TODO: Comment this hack! } private: bool initialized; SNC_candidate_provider* candidate_provider; SNC_intersection is; std::list triangulation; }; /* template class SNC_point_locator_naive : public SNC_ray_shooter, public SNC_point_locator { typedef SNC_ray_shooter Base; typedef SNC_point_locator_naive Self; typedef SNC_point_locator SNC_point_locator; typedef SNC_intersection SNC_intersection; public: typedef typename SNC_decorator::Object_handle Object_handle; typedef typename SNC_decorator::Halfedge_const_handle Halfedge_const_handle; typedef typename SNC_decorator::Halffacet_triangle_handle Halffacet_triangle_handle; typedef typename SNC_decorator::Point_3 Point_3; typedef typename SNC_decorator::Segment_3 Segment_3; typedef typename SNC_decorator::Ray_3 Ray_3; typedef typename SNC_decorator::Triangle_3 Triangle_3; typedef typename Decorator_traits::Vertex_handle Vertex_handle; typedef typename Decorator_traits::Halfedge_handle Halfedge_handle; typedef typename Decorator_traits::Halffacet_handle Halffacet_handle; typedef typename Decorator_traits::Volume_handle Volume_handle; typedef typename Decorator_traits::Vertex_iterator Vertex_iterator; typedef typename Decorator_traits::Halfedge_iterator Halfedge_iterator; typedef typename Decorator_traits::Halffacet_iterator Halffacet_iterator; public: SNC_point_locator_naive() : initialized(false) {} virtual void initialize(SNC_structure* W) { TIMER(ct_t.start()); strcpy( version_, "Naive Point Locator (tm)"); CLOG(version()); CGAL_assertion( W != NULL); Base::initialize(W); initialized = true; TIMER(ct_t.stop()); } virtual Self* clone() const { return new Self; } virtual bool update( Unique_hash_map& V, Unique_hash_map& E, Unique_hash_map& F) { TIMER(ct_t.start()); CGAL_assertion( initialized); TIMER(ct_t.stop()); return false; } virtual ~SNC_point_locator_naive() {} virtual Object_handle locate(const Point_3& p) const { TIMER(pl_t.start()); CGAL_assertion( initialized); TIMER(pl_t.stop()); return Base::locate(p); } virtual Object_handle shoot(const Ray_3& r) const { TIMER(rs_t.start()); CGAL_assertion( initialized); TIMER(rs_t.stop()); return Base::shoot(r); } virtual void intersect_with_edges( Halfedge_const_handle e0, const typename SNC_point_locator::Intersection_call_back& call_back) const { TIMER(it_t.start()); CGAL_assertion( initialized); CGAL_NEF_TRACEN( "intersecting edge: "<< Segment_3(e0->source()->point(), e0->twin()->source()->point())); SNC_intersection is(*this->sncp()); Segment_3 s(Segment_3(e0->source()->point(),e0->twin()->source()->point())); Halfedge_iterator e; CGAL_forall_edges( e, *this->sncp()) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Point_3 q; if( is.does_intersect_internally( s, Segment_3(e->source()->point(), e->twin()->source()->point()), q)) { q = normalized(q); CGAL_NEF_TRACEN("edge intersects edge "<< Segment_3(e->source()->point(), e->twin()->source()->point()) <<" on "<source()->point(), e0->twin()->source()->point())); SNC_intersection is(*this->sncp()); Segment_3 s(Segment_3(e0->source()->point(), e0->twin()->source()->point())); Halffacet_iterator f; CGAL_forall_facets( f, *this->sncp()) { #ifdef CGAL_NEF3_DUMP_STATISTICS ++number_of_intersection_candidates; #endif Point_3 q; if( is.does_intersect_internally( s, f, q) ) { q = normalized(q); CGAL_NEF_TRACEN("edge intersects facet on plane "< #ifndef CGAL_SNC_FM_DECORATOR_H #define CGAL_SNC_FM_DECORATOR_H #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 31 #include CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------------- /* We introduce a template that is a point that refers to a vertex. We derive from the point type and add the vertex handle */ template class Vertex_point : public P { H v_; public: Vertex_point() {} Vertex_point(const P& p, H v) : P(p) { v_=v; } Vertex_point(const Vertex_point& vp) : P(vp) { v_=vp.v_; } Vertex_point& operator=(const Vertex_point& vp) { P::operator=(vp); v_=vp.v_; return *this; } H vertex() const { return v_; } }; template std::ostream& operator<<(std::ostream& os, const Vertex_point& p) { os << static_cast

    (p); return os; } template std::ostream& operator<<(std::ostream& os, const std::pair< Vertex_point, Vertex_point > & s) { os << s.first << s.second; return os; } template struct Sort_sedges { bool operator()(SE e1, SE e2) { P p1[2], p2[2]; p1[0] = e1->source()->center_vertex()->point(); p1[1] = e1->twin()->source()->twin()->center_vertex()->point(); p2[0] = e2->source()->center_vertex()->point(); p2[1] = e2->twin()->source()->twin()->center_vertex()->point(); int i1(0), i2(0); if(CGAL::lexicographically_xyz_smaller(p1[1],p1[0])) i1 = 1; if(CGAL::lexicographically_xyz_smaller(p2[1],p2[0])) i2 = 1; if(p1[i1] != p2[i2]) return CGAL::lexicographically_xyz_smaller(p1[i1],p2[i2]); if(p1[1-i1] != p2[1-i2]) return CGAL::lexicographically_xyz_smaller(p1[1-i1],p2[1-i2]); return i1 struct Halffacet_output { Halffacet_output(CGAL::Unique_hash_map& F, std::vector& S) : From(F), Support(S) { edge_number=0; Support[0]=E(); } typedef P Point; typedef V Vertex_handle; typedef unsigned Halfedge_handle; CGAL::Unique_hash_map& From; std::vector& Support; unsigned edge_number; Vertex_handle new_vertex(const Point& p) const { geninfo::create(p.vertex()->info()); return p.vertex(); } Halfedge_handle new_halfedge_pair_at_source(Vertex_handle v) { CGAL_NEF_TRACEN("new_edge "<<&*v<<" "<point() <<": " << e); geninfo::access(v->info()) = e; } // all empty, no update necessary void link_as_target_and_append(Vertex_handle v, Halfedge_handle e) { /* do nothing */ } void trivial_segment(Vertex_handle v, I it) const {} void starting_segment(Vertex_handle v, I it) const {} void passing_segment(Vertex_handle v, I it) const {} void ending_segment(Vertex_handle v, I it) const {} }; //-------------------------------------------------------------------------- // the following class is the geometry kernel of the generic sweep // module |Segment_overlay_traits|. //-------------------------------------------------------------------------- template class Halffacet_geometry { public: typedef Point Point_3; typedef Plane Plane_3; typedef Vertex_point Point_2; typedef std::pair Segment_2; private: // the underlying plane: Plane_3 h; Point_3 above(const Point_3& p) const { return p + h.orthogonal_vector(); } public: Halffacet_geometry(const Plane_3& hi) : h(hi) {} Point_2 source(const Segment_2& s) const { return s.first; } Point_2 target(const Segment_2& s) const { return s.second; } bool is_degenerate(const Segment_2& s) const { return source(s)==target(s); } Segment_2 construct_segment(const Point_2& p1, const Point_2& p2) const { return Segment_2(p1,p2); } int orientation(const Point_2& p1, const Point_2& p2, const Point_2& p3) const { return static_cast( CGAL::orientation(p1,p2,p3,above(p1))); } int orientation(const Segment_2& s, const Point_2& p) const { return orientation(source(s),target(s),p); } int compare_xy(const Point_2& p1, const Point_2& p2) const { return static_cast( CGAL::compare_xyz(p1,p2)); } Point_2 intersection(const Segment_2& s1, const Segment_2& s2) const { CGAL_assertion(target(s1)==target(s2)); return target(s1); } bool left_turn(const Point_3& p1, const Point_3& p2, const Point_3& p3) const { return CGAL::orientation(p1,p2,p3,above(p1)) == CGAL::POSITIVE; } }; // Halffacet_geometry //-------------------------------------------------------------------------- // SNC_FM_decorator // Note that we interpret sedges as edge uses between vertices. We // overwrite some operations from the base class for that semantics. //-------------------------------------------------------------------------- template class SNC_decorator; template class SNC_FM_decorator : public SNC_decorator { public: typedef SNC_structure_ SNC_structure; typedef SNC_decorator Base; typedef typename SNC_structure::Vertex_iterator Vertex_iterator; typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::Halfedge_iterator Halfedge_iterator; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Volume_iterator Volume_iterator; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::SVertex_iterator SVertex_iterator; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_iterator SHalfedge_iterator; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SHalfloop_iterator SHalfloop_iterator; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::SFace_iterator SFace_iterator; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::SFace_cycle_iterator SFace_cycle_iterator; typedef typename SNC_structure::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename SNC_structure::Shell_entry_iterator Shell_entry_iterator; typedef typename SNC_structure::Object_handle Object_handle; typedef typename SNC_structure::Point_3 Point_3; typedef typename SNC_structure::Plane_3 Plane_3; typedef typename SNC_structure::Mark Mark; typedef typename Base::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; #if 0 typedef typename Base::SHalfedge_around_facet_const_circulator SHalfedge_around_facet_const_circulator; #endif typedef typename std::list::iterator Object_list_iterator; typedef Vertex_point Vertex_point; typedef std::pair Vertex_segment; typedef std::list Segment_list; typedef typename Segment_list::iterator Segment_iterator; typedef CGAL::Halffacet_geometry Halffacet_geometry; protected: Halffacet_handle f_; public: SNC_FM_decorator(SNC_structure& W) : Base(W), f_() {} SNC_FM_decorator(SNC_structure& W, Halffacet_handle f) : Base(W),f_(f) {} Halffacet_cycle_iterator facet_cycles_begin() const { return f_->facet_cycles_begin(); } Halffacet_cycle_iterator facet_cycles_end() const { return f_->facet_cycles_end(); } void create_facet_objects(const Plane_3& h, Object_list_iterator start, Object_list_iterator end) const; protected: //-------------------------------------------------------------------------- /* We provide some information on determine_facet. To understand its functionality please refer to the Nef_2 implementation report where there is similar function determine_face with more documentation. When we call |determine_facet|$(e,\ldots)$ we know that the shalfedge |e| is not linked to a face object yet and thus no shalfedge in its face cycle is linked. Thus we jump to the minimal shalfedge and look down (along the previously used sweep line in the plane of the facet). If we see an shalfedge we ask for its face. If it does not have one we recurse. Note that the target vertex of the minimal halfedge actually has a view downwards as we examine a hole facet cycle. The method |link_as_facet_cycle| does the linkage between the facet object and all sedges of the facet cycle. Its cost is linear in the size of the facet cycle. Note also that we do the linking bottom up along the recursion stack for all visited hole (facet) cycles. Thus we visit each hole facet cycle only once as afterwards each edge of the facet cycle is incident to a facet. */ //-------------------------------------------------------------------------- Halffacet_handle determine_facet(SHalfedge_handle e, const std::vector& MinimalEdge, const CGAL::Unique_hash_map& FacetCycle, const std::vector& Edge_of) const { CGAL_NEF_TRACEN(" determine_facet "<::access(info(target(e_min)))]; CGAL_assertion( e_below != SHalfedge_handle() ); CGAL_NEF_TRACEN(" edge below " << debug(e_below)); Halffacet_handle f = facet(e_below); if ( f != Halffacet_handle() ) return f; // has already a facet // e_below also has no facet f = determine_facet(e_below, MinimalEdge, FacetCycle, Edge_of); CGAL_NEF_TRACEN(" edge below " << debug(e_below)); link_as_facet_cycle(e_below,f); link_as_facet_cycle(twin(e_below),twin(f)); return f; } //-------------------------------------------------------------------------- /* segment(...) an shalfedge |e| can be interpreted as an edge-use extending along the halfedge that leaves the local graph in |target(e)|. Only edge-uses allow us to code the non-unique character of an edge as a boundary object of several facets. An edge-use |e| represents the edge |target(e)| in the boundary structure of a facet. */ //-------------------------------------------------------------------------- Vertex_segment segment(SHalfedge_handle e) const { Vertex_handle vs = source(e), vt = target(e); Vertex_point ps(point(vs),vs), pt(point(vt),vt); return Vertex_segment(ps,pt); } Vertex_segment segment(SHalfloop_handle l) const { Vertex_handle v = vertex(l); Vertex_point p(point(v),v); return Vertex_segment(p,p); } }; // SNC_FM_decorator //-------------------------------------------------------------------------- /* create_facet_objects() In this method we use the visibility along a sweep line in the facet plane to create facet objects. |SEdge_below[v]| either provides the sedge that is hit first by a vertical ray downwards or an uninitialized edge if there is none. */ //-------------------------------------------------------------------------- template void SNC_FM_decorator:: create_facet_objects(const Plane_3& plane_supporting_facet, Object_list_iterator start, Object_list_iterator end) const { CGAL_NEF_TRACEN(">>>>>create_facet_objects"); CGAL::Unique_hash_map FacetCycle(-1); std::vector MinimalEdge; std::list SHalfedges; std::list SHalfloops; CGAL::Unique_hash_map SHalfedgeBelow; CGAL::Unique_hash_map From; Segment_list Segments; SHalfedge_handle e; SHalfloop_handle l; typename std::list::iterator eit,epred; typename std::list::iterator lit; // the output decorator for the facet plane sweep typedef CGAL::Halffacet_output Halffacet_output; // the sweep traits class instantiated with the input, output and // geometry models typedef CGAL::Segment_overlay_traits Halffacet_sweep_traits; typedef CGAL::generic_sweep Halffacet_sweep; Halffacet_geometry G(plane_supporting_facet); /* We first separate sedges and sloops, and fill a list of segments to trigger a sweep. */ for ( ; start != end; ++start ) { if ( CGAL::assign(e,*start) ) { SHalfedges.push_back(e); } else if ( CGAL::assign(l,*start) ) { SHalfloops.push_back(l); } else CGAL_assertion_msg(0,"Damn wrong handle."); } /* We iterate all shalfedges and assign a number for each facet cycle. After that iteration for an edge |e| the number of its facet cycle is |FacetCycle[e]| and for a facet cycle |c| we know |MinimalEdge[c]|. */ int i=0; CGAL_forall_iterators(eit,SHalfedges) { e = *eit; if ( FacetCycle[e] >= 0 ) continue; // already assigned SHalfedge_around_facet_circulator hfc(e),hend(hfc); SHalfedge_handle e_min = e; CGAL_NEF_TRACEN("\n facet cycle numbering "<sncp()->new_halffacet_pair(plane_supporting_facet); link_as_facet_cycle(e,f); link_as_facet_cycle(twin(e),twin(f)); mark(f) = mark(twin(f)) = mark(e); CGAL_NEF_TRACEN(" creating new facet object "<<&*f<<" bd "<<&*e); } } /* Now the only shalfedges not linked are those on hole facet cycles. We use a recursive scheme to find the bounding cycle providing the facet object and finally iterate over all isolated vertices to link them accordingly to their containing facet object. Note that in that final iteration all shalfedges already have facet links. Thus that ensures termination. The recursive operation $|determine_facet|(e,\ldots)$ returns the facet containing the hole cycle of |e|. As a postcondition of this code part we have all shalfedges and isolated shalfloops linked to facet objects, and all facet objects know their bounding facet cycles. */ bool do_sweep = false; if(SHalfloops.size() > 0) do_sweep = true; CGAL_forall_iterators(eit,SHalfedges) { if ( facet(*eit) == Halffacet_handle() ) { do_sweep = true; break; } } #ifndef CGAL_NEF3_PLANE_SWEEP_OPTIMIZATION_OFF if(!do_sweep) return; #endif #ifdef CGAL_NEF3_TIMER_PLANE_SWEEPS number_of_plane_sweeps++; timer_plane_sweeps.start(); #endif // Note that we only allow those edges that are // directed from lexicographically smaller to larger vertices. // Insertion of SHalfedges into Segments is shifted below in order // to guarantee that there are no gaps in the overlay. SHalfedges.sort(Sort_sedges()); for(eit = SHalfedges.begin();eit != SHalfedges.end();) { CGAL_NEF_TRACEN(" appending edge "<< debug(*eit)); Segments.push_front(segment(*eit)); From[Segments.begin()] = *eit; epred=eit; ++eit; if(eit != SHalfedges.end()) CGAL_NEF_TRACEN("test " << std::endl << " " << debug(*epred) << std::endl << " " << debug(*eit)); if(eit != SHalfedges.end() && point(source(*epred))== point(target(*eit)) && point(source(*eit)) == point(target(*epred))) ++eit; } CGAL_forall_iterators(lit,SHalfloops) { CGAL_NEF_TRACEN(" appending loop " << point(vertex(*lit))); Segments.push_back(segment(*lit)); } std::vector Edge_of(Segments.size()+1); Halffacet_output O(From,Edge_of); Halffacet_sweep FS(typename Halffacet_sweep::INPUT( Segments.begin(),Segments.end()), O, G); FS.sweep(); #ifdef CGAL_NEF3_TIMER_PLANE_SWEEPS timer_plane_sweeps.stop(); #endif CGAL_forall_iterators(eit,SHalfedges) { e=*eit; if ( facet(e) != Halffacet_handle() ) continue; CGAL_NEF_TRACEN(" linking hole "<::access(info(vertex(l)))]; CGAL_assertion( e_below != SHalfedge_handle() ); CGAL_NEF_TRACEN("link sloop at vertex "<< point(vertex(l))); CGAL_NEF_TRACEN("e_below " << debug(e_below)); CGAL_NEF_TRACEN("next " << debug(next(e_below))); CGAL_NEF_TRACEN("next " << debug(next(next(e_below)))); CGAL_NEF_TRACEN("next " << debug(next(next(next(e_below))))); CGAL_NEF_TRACEN("next " << debug(next(next(next(next(e_below)))))); link_as_interior_loop(l,facet(e_below)); link_as_interior_loop(twin(l),twin(facet(e_below))); } CGAL_NEF_TRACEN("exit FM"); } CGAL_END_NAMESPACE #endif //CGAL_SNC_FM_DECORATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Bounding_box_3.h0000644000175000017500000002305011344301501030763 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/Bounding_box_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Miguel Granados #ifndef CGAL_BOUNDING_BOX_3_H #define CGAL_BOUNDING_BOX_3_H #include #include CGAL_BEGIN_NAMESPACE template class Bounding_box_3; template class Bounding_box_rep_3 { typedef typename Traits::Point_3 Point_3; public: Bounding_box_rep_3() { min = Point_3(0,0,0); max = Point_3(0,0,0); } Bounding_box_rep_3(Point_3 init_min, Point_3 init_max) { min = init_min; max = init_max; } Point_3 min; Point_3 max; }; template class Bounding_box_3 : public Handle_for< Bounding_box_rep_3 > { typedef Handle_for< Bounding_box_rep_3 > BBox_handle_3; typedef typename BBox_handle_3::element_type BBox_ref_3; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Vector_3 Vector_3; public: Bounding_box_3() : BBox_handle_3(BBox_ref_3()) {} Bounding_box_3(Point_3 init_min, Point_3 init_max) : BBox_handle_3(BBox_ref_3(init_min, init_max)) {} const Point_3& get_min() const { return this->Ptr()->min; } const Point_3& get_max() const { return this->Ptr()->max; } Bounding_box_3 operator+(const Bounding_box_3& b) const { Point_3 res_min(b.get_min()), res_max(b.get_max()); if(res_min.x() > get_min().x()) res_min = Point_3(res_min.x(),get_min().y(),get_min().z()); if(res_min.y() > get_min().y()) res_min = Point_3(get_min().x(),res_min.y(),get_min().z()); if(res_min.z() > get_min().z()) res_min = Point_3(get_min().x(),get_min().y(),res_min.z()); if(res_max.x() < get_max().x()) res_max = Point_3(res_max.x(),get_max().y(),get_max().z()); if(res_max.y() < get_max().y()) res_max = Point_3(get_max().x(),res_max.y(),get_max().z()); if(res_max.z() < get_max().z()) res_max = Point_3(get_max().x(),get_max().y(),res_max.z()); return Bounding_box_3(normalized(res_min),normalized(res_max)); } }; template class Bounding_box_3 : public Handle_for< Bounding_box_rep_3 > { typedef Handle_for< Bounding_box_rep_3 > BBox_handle_3; typedef typename BBox_handle_3::element_type BBox_ref_3; typedef typename Traits::Point_3 Point_3; typedef typename Traits::Vector_3 Vector_3; public: Bounding_box_3() : BBox_handle_3(BBox_ref_3()) {} Bounding_box_3(Point_3 init_min, Point_3 init_max) : BBox_handle_3(BBox_ref_3(init_min, init_max)) {} const Point_3& get_min() const { return this->Ptr()->min; } const Point_3& get_max() const { return this->Ptr()->max; } Bounding_box_3 operator+(const Bounding_box_3& b) const { Point_3 res_min(b.get_min()), res_max(b.get_max()); if(res_min.x() > get_min().x()) { Point_3 src(res_min.hx(),0,0,res_min.hw()); Point_3 tgt(get_min().hx(),0,0,get_min().hw()); Vector_3 delta(tgt - src); res_min = res_min + delta; } if(res_min.y() > get_min().y()) { Point_3 src(0,res_min.hy(),0,res_min.hw()); Point_3 tgt(0,get_min().hy(),0,get_min().hw()); Vector_3 delta(tgt - src); res_min = res_min + delta; } if(res_min.z() > get_min().z()) { Point_3 src(0,0,res_min.hz(),res_min.hw()); Point_3 tgt(0,0,get_min().hz(),get_min().hw()); Vector_3 delta(tgt - src); res_min = res_min + delta; } if(res_max.x() < get_max().x()) { Point_3 src(res_max.hx(),0,0,res_max.hw()); Point_3 tgt(get_max().hx(),0,0,get_max().hw()); Vector_3 delta(tgt - src); res_max = res_max + delta; } if(res_max.y() < get_max().y()) { Point_3 src(0,res_max.hy(),0,res_max.hw()); Point_3 tgt(0,get_max().hy(),0,get_max().hw()); Vector_3 delta(tgt - src); res_max = res_max + delta; } if(res_max.z() < get_max().z()) { Point_3 src(0,0,res_max.hz(),res_max.hw()); Point_3 tgt(0,0,get_max().hz(),get_max().hw()); Vector_3 delta(tgt - src); res_max = res_max + delta; } return Bounding_box_3(normalized(res_min),normalized(res_max)); } }; /* template inline Bounding_box_3 Bounding_box_3:: operator+(const Bounding_box_3& b) const { Point_3 res_min(b.get_min()), res_max(b.get_max()); if(res_min.x() > get_min().x()) res_min = Point_3(res_min.x(),get_min().y(),get_min().z()); if(res_min.y() > get_min().y()) res_min = Point_3(get_min().x(),res_min.y(),get_min().z()); if(res_min.z() > get_min().z()) res_min = Point_3(get_min().x(),get_min().y(),res_min.z()); if(res_max.x() < get_max().x()) res_max = Point_3(res_max.x(),get_max().y(),get_max().z()); if(res_max.y() < get_max().y()) res_max = Point_3(get_max().x(),res_max.y(),get_max().z()); if(res_max.z() < get_max().z()) res_max = Point_3(get_max().x(),get_max().y(),res_max.z()); return Bounding_box_3(normalized(res_min),normalized(res_max)); } template inline Bounding_box_3 Bounding_box_3::operator+(const Bounding_box_3& b) const { Point_3 res_min(b.get_min()), res_max(b.get_max()); if(res_min.x() > get_min().x()) { Point_3 src(res_min.hx(),0,0,res_min.hw()); Point_3 tgt(get_min().hx(),0,0,get_min().hw()); Vector_3 delta(tgt - src); res_min = res_min + delta; } if(res_min.y() > get_min().y()) { Point_3 src(0,res_min.hy(),0,res_min.hw()); Point_3 tgt(0,get_min().hy(),0,get_min().hw()); Vector_3 delta(tgt - src); res_min = res_min + delta; } if(res_min.z() > get_min().z()) { Point_3 src(0,0,res_min.hz(),res_min.hw()); Point_3 tgt(0,0,get_min().hz(),get_min().hw()); Vector_3 delta(tgt - src); res_min = res_min + delta; } if(res_max.x() < get_max().x()) { Point_3 src(res_max.hx(),0,0,res_max.hw()); Point_3 tgt(get_max().hx(),0,0,get_max().hw()); Vector_3 delta(tgt - src); res_max = res_max + delta; } if(res_max.y() < get_max().y()) { Point_3 src(0,res_max.hy(),0,res_max.hw()); Point_3 tgt(0,get_max().hy(),0,get_max().hw()); Vector_3 delta(tgt - src); res_max = res_max + delta; } if(res_max.z() < get_max().z()) { Point_3 src(0,0,res_max.hz(),res_max.hw()); Point_3 tgt(0,0,get_max().hz(),get_max().hw()); Vector_3 delta(tgt - src); res_max = res_max + delta; } return Bounding_box_3(normalized(res_min),normalized(res_max)); } */ template inline bool do_overlap(const Bounding_box_3& bb1, const Bounding_box_3& bb2) { if (bb1.get_max().x() < bb2.get_min().x() || bb2.get_max().x() < bb1.get_min().x()) return false; if (bb1.get_max().y() < bb2.get_min().y() || bb2.get_max().y() < bb1.get_min().y()) return false; if (bb1.get_max().z() < bb2.get_min().z() || bb2.get_max().z() < bb1.get_min().z()) return false; return true; } #define CGAL_NO_ISTREAM_EXTRACT_BOUNDING_BOX_3 #ifndef CGAL_NO_OSTREAM_INSERT_BOUNDING_BOX_3 template inline std::ostream& operator<<(std::ostream &os, const Bounding_box_3& b) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << b.get_min().hx() << ' ' << b.get_min().hy() << ' ' << b.get_min().hz() << ' ' << b.get_min().hw() << std::endl << b.get_max().hx() << ' ' << b.get_max().hy() << ' ' << b.get_max().hz() << ' ' << b.get_max().hz(); case IO::BINARY : write(os, b.get_min().hx()); write(os, b.get_min().hy()); write(os, b.get_min().hz()); write(os, b.get_min().hw()); write(os, b.get_max().hx()); write(os, b.get_max().hy()); write(os, b.get_max().hz()); write(os, b.get_max().hw()); return os; default: os << "Bounding_box_3((" << b.get_min().hx() << ", " << b.get_min().hy() << ", " << b.get_min().hz() << ", " << b.get_min().hw() << "), ("; os << b.get_max().hx() << ", " << b.get_max().hy() << ", " << b.get_max().hz() << ", " << b.get_max().hw() << "))"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_BOUNDING_BOX_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_BOUNDING_BOX_3 template inline std::istream& operator>>(std::istream &is, Bounding_box_3& b) { NT xmin, ymin, zmin, xmax, ymax, zmax; switch(is.iword(IO::mode)) { case IO::ASCII : is >> xmin >> ymin >> xmax >> ymax; break; case IO::BINARY : read(is, xmin); read(is, ymin); read(is, zmin); read(is, xmax); read(is, ymax); read(is, zmax); break; } b = Bounding_box_3(xmin, ymin, zmin, xmax, ymax, zmax); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_BOUNDING_BOX_3 CGAL_END_NAMESPACE #endif // CGAL_BOUNDING_BOX_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_simplify.h0000644000175000017500000005625711344301501030502 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/SNC_simplify.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Peter Hachenberger // Michael Seel #ifndef CGAL_SNC_SIMPLIFY_H #define CGAL_SNC_SIMPLIFY_H #include #include #include #ifdef CGAL_NEF_DEBUG #include #endif #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 41 #include CGAL_BEGIN_NAMESPACE template class SNC_simplify : public SNC_decorator { typedef CGAL::SNC_simplify Self; typedef CGAL::SNC_decorator SNC_decorator; typedef SNC_decorator Base; typedef typename SNC_structure::Sphere_map Sphere_map; typedef CGAL::SM_decorator SM_decorator; #ifdef CGAL_NEF_DEBUG typedef CGAL::SNC_io_parser SNC_io_parser; #endif typedef typename SNC_structure::Vertex_handle Vertex_handle; typedef typename SNC_structure::Halfedge_handle Halfedge_handle; typedef typename SNC_structure::Halffacet_handle Halffacet_handle; typedef typename SNC_structure::Volume_handle Volume_handle; typedef typename SNC_structure::SVertex_handle SVertex_handle; typedef typename SNC_structure::SHalfedge_handle SHalfedge_handle; typedef typename SNC_structure::SHalfloop_handle SHalfloop_handle; typedef typename SNC_structure::SFace_handle SFace_handle; typedef typename SNC_structure::Vertex_iterator Vertex_iterator; typedef typename SNC_structure::Halfedge_iterator Halfedge_iterator; typedef typename SNC_structure::Halffacet_iterator Halffacet_iterator; typedef typename SNC_structure::Volume_iterator Volume_iterator; typedef typename SNC_structure::SVertex_iterator SVertex_iterator; typedef typename SNC_structure::SHalfedge_iterator SHalfedge_iterator; typedef typename SNC_structure::SHalfloop_iterator SHalfloop_iterator; typedef typename SNC_structure::SFace_iterator SFace_iterator; typedef typename SNC_structure::SHalfedge_around_facet_circulator SHalfedge_around_facet_circulator; typedef typename SNC_structure::SHalfedge_around_svertex_circulator SHalfedge_around_svertex_circulator; typedef typename SNC_structure::SHalfedge_around_sface_circulator SHalfedge_around_sface_circulator; typedef typename SNC_structure::Halffacet_cycle_iterator Halffacet_cycle_iterator; typedef typename SNC_structure::SFace_cycle_iterator SFace_cycle_iterator; typedef typename Base::Sphere_kernel Sphere_kernel; typedef typename Base::Sphere_point Sphere_point; typedef typename Base::Sphere_segment Sphere_segment; typedef typename Base::Sphere_circle Sphere_circle; typedef typename Base::Sphere_direction Sphere_direction; #ifdef CGAL_NEF_DEBUG SNC_io_parser *IO; #endif public: SNC_simplify(SNC_structure& sncs) : Base(sncs), IO(NULL) {} char PSE(SHalfedge_handle h) /* prints a sphere segment */ { SNC_decorator D; SM_decorator SD; CGAL_NEF_TRACE(IO->index(h)<<" @ "<index(D.vertex(h))<< " "<index(D.previous(h))<< ", next " <index(D.next(h))<< ", sprev "<index(SD.previous(h))<< ", snext "<index(SD.next(h))<< ", twin " <index(D.twin(h))); return ' '; } char PFC(SHalfedge_handle e) /* prints a facet cycle */ { CGAL_NEF_TRACEN("--> Facet cycle begin"); SHalfedge_around_facet_circulator c(e), cend(c); CGAL_For_all(c, cend) { CGAL_NEF_TRACEN(PSE(c)); } CGAL_NEF_TRACE("--> Facet cycle end"); return ' '; } char PFB(Halffacet_handle f) /* prints facet boundary entry points */ { Halffacet_cycle_iterator fc; CGAL_forall_facet_cycles_of(fc, f) { if(fc.is_shalfedge()) { SHalfedge_handle(e); CGAL_NEF_TRACE(' '<index(e)); } else if(fc.is_shalfloop()) { SHalfloop_handle l(fc); CGAL_NEF_TRACE(' '<index(l)<<"(sl)"); } } return '.'; } char PSFB(SFace_handle f) /* prints sphere face boundary entry points */ { SFace_cycle_iterator it; CGAL_forall_sface_cycles_of(it,f) if ( it.is_shalfedge() ) CGAL_NEF_TRACE(IO->index(SHalfedge_handle(it))<<' '); CGAL_NEF_TRACE(", "); CGAL_forall_sface_cycles_of(it,f) if ( it.is_svertex() ) CGAL_NEF_TRACE(IO->index(SVertex_handle(it))<<' '); CGAL_NEF_TRACE(", "); CGAL_forall_sface_cycles_of(it,f) if ( it.is_shalfloop() ) CGAL_NEF_TRACE(IO->index(SHalfloop_handle(it))); return '.'; } typedef typename Union_find< Volume_handle>::handle UFH_volume; typedef typename Union_find< Halffacet_handle>::handle UFH_facet; typedef typename Union_find< SFace_handle>::handle UFH_sface; void remove_f_including_all_edge_uses_in_its_boundary_cycles ( Halffacet_handle f, Unique_hash_map< SFace_handle, UFH_sface>& hash, Union_find< SFace_handle>& uf ) /* removes f and its boundary cycles, and merges up the sphere facets incident to them. */ { SNC_decorator D; Halffacet_cycle_iterator fc; CGAL_forall_facet_cycles_of(fc, f) { if(fc.is_shalfedge() ) { SHalfedge_handle e(fc); SHalfedge_around_facet_circulator u(e), eend(e); CGAL_For_all(u, eend) { SFace_handle fu = D.sface(u), ftu = D.sface(D.twin(u)); CGAL_NEF_TRACEN("sfUNION of "<index(fu)<<" & "<index(ftu)); merge_sets( fu, ftu, hash, uf); SM_decorator SD(&*D.vertex(u)); CGAL_NEF_TRACEN("removing "<index(u)<<" & "<index(SD.twin(u))); Halfedge_handle src(SD.source(u)), tgt(SD.target(u)); if ( SD.is_closed_at_source(u) ) SD.set_face( src, fu); if ( SD.is_closed_at_source( SD.twin(u)) ) SD.set_face( tgt, fu); /* TO VERIFY: does is_closed_at_source(u) imply is_isolated(src)? if it is true, the svertex face update is not necesary. */ SD.delete_edge_pair(u); if( SD.is_isolated(src)) // SD.delete_vertex_only(src); SD.set_face(src,fu); SM_decorator SD2(&*D.vertex(tgt)); if( SD2.is_isolated(tgt)) // SD.delete_vertex_only(tgt); SD2.set_face(tgt,fu); /* TO VERIFY: can both svertices be isolated at the same time? */ } } else if(fc.is_shalfloop()) { SHalfloop_handle l(fc); // this code is currenlty not used, but it is potentially need // in the future, e.g for complex marks or a relative interior // function SFace_handle fu = D.sface(l), ftu = D.sface(D.twin(l)); CGAL_NEF_TRACEN("UNION of "<index(fu)<<" & "<index(ftu)); merge_sets( fu, ftu, hash, uf); SM_decorator SD(&*D.vertex(l)); CGAL_NEF_TRACEN("removing "<index(l)<<" & "<index(SD.twin(l))); SD.delete_loop_only(); } } CGAL_NEF_TRACEN("removing "<index(f)<<" & "<index(D.twin(f))); this->sncp()->delete_halffacet_pair(f); return; } bool is_part_of_volume(Vertex_handle v) /* determines if a vertex v is part of a volume, cheking if its local graph is trivial (only one sface with no boundary). */ { SM_decorator SD(&*v); CGAL_assertion( !is_empty_range( SD.sfaces_begin(), SD.sfaces_end())); if( is_empty_range( SD.svertices_begin(), SD.svertices_end()) && is_empty_range( SD.shalfedges_begin(), SD.shalfedges_end()) && !SD.has_shalfloop()) return true; return false; } bool is_part_of_facet(Vertex_handle v) /* determines if a vertex v is part of a the relative interior of a facet, checking if its local graph consists just of a sloop and two incident sfaces. */ { SM_decorator SD(&*v); CGAL_assertion( !is_empty_range( SD.svertices_begin(), SD.svertices_end()) || is_empty_range( SD.shalfedges_begin(), SD.shalfedges_end())); return( SD.has_shalfloop() && is_empty_range( SD.svertices_begin(), SD.svertices_end())); } bool is_part_of_edge(Vertex_handle v) { /* determines if a vertex v is part of a edge, checking at its local graph for exactly two antipodal vertices */ SM_decorator SD(&*v); if(SD.has_shalfloop()) return false; if(SD.svertices_begin() == SD.svertices_end()) return false; if(++(SD.svertices_begin()) == SD.svertices_end()) return false; CGAL_NEF_TRACE(SNC_decorator(*this->sncp()).point(v)<<" is in edge interior? "); SVertex_iterator sv(SD.svertices_begin()); SVertex_handle p1(sv++), p2(sv++); if( sv != SD.svertices_end()) return false; CGAL_NEF_TRACE("has two svertices "); Sphere_point sp1(SD.point(p1)), sp2(SD.point(p2)); return (sp1 == sp2.antipode()); } bool vertex_simplification(bool snc_computed = true) { bool simplified = false; #ifdef CGAL_NEF_DEBUG delete IO; IO = new SNC_io_parser(std::cerr, *this->sncp()); #endif SNC_decorator D(*this->sncp()); Vertex_iterator v = (*this->sncp()).vertices_begin(); while( v != (*this->sncp()).vertices_end()) { SM_decorator SD(&*v); Vertex_iterator v_next(v); v_next++; if( is_part_of_volume(v)) { CGAL_NEF_TRACEN("mark("<index(v)<<")="<index(D.volume(SD.sfaces_begin()))<<")="<< SD.mark(SD.sfaces_begin())); if(D.mark(v) == SD.mark(SD.sfaces_begin())) { CGAL_NEF_TRACEN("removing isolated vertex "<index(v)); this->sncp()->delete_vertex(v); simplified = true; } } else if( is_part_of_facet(v)) { if( D.mark(v) == SD.mark(SD.shalfloop())) { CGAL_NEF_TRACEN("removing "<index(v)<< " on facet "); this->sncp()->delete_vertex(v); simplified = true; } } else if( is_part_of_edge(v)) { SVertex_iterator sv(SD.svertices_begin()); Halfedge_handle e1(sv++), e2(sv++); CGAL_assertion( sv == SD.svertices_end()); if( D.mark(e1) == D.mark(v) && D.mark(v) == D.mark(e2)) { CGAL_NEF_TRACEN("merging "<index(e1)<<" & "<index(e2)<< " in "<index(v)); if(snc_computed) merge_halfedge_pairs( e1, e2); else this->sncp()->delete_vertex(v); simplified = true; } } v = v_next; } return simplified; } bool simplify() { bool update_facets = false; bool update_sfaces = false; bool update_volumes = false; CGAL_NEF_TRACEN(">>> simplifying"); SNC_decorator D(*this->sncp()); #ifdef CGAL_NEF_DEBUG delete IO; IO = new SNC_io_parser(std::cerr, *this->sncp()); #endif Unique_hash_map< Volume_handle, UFH_volume> hash_volume; Unique_hash_map< Halffacet_handle, UFH_facet> hash_facet; Unique_hash_map< SFace_handle, UFH_sface> hash_sface; Union_find< Volume_handle> uf_volume; Union_find< Halffacet_handle> uf_facet; Union_find< SFace_handle> uf_sface; /* We discard the information about boundary entry points, first on volumes, facets on sfacets. Since during the volumes simplification is required the remotion of facet cycles, the information about those cycles is keep until the this simplification step is performed. */ this->sncp()->clear_boundary(); Volume_iterator c; CGAL_forall_volumes( c, *this->sncp()) { hash_volume[c] = uf_volume.make_set(c); this->sncp()->reset_object_list(c->shell_entry_objects()); } SFace_iterator sf; CGAL_forall_sfaces( sf, *this->sncp()) { hash_sface[sf] = uf_sface.make_set(sf); this->sncp()->reset_sm_object_list(sf->boundary_entry_objects()); } /* * Volumes simplification */ Halffacet_handle f(D.halffacets_begin()); while( f != D.halffacets_end() && f->is_twin()) f++; while( f != D.halffacets_end()) { CGAL_assertion( !f->is_twin()); Halffacet_iterator f_next(f); do f_next++; while( f_next != D.halffacets_end() && f_next->is_twin()); CGAL_assertion( f != D.twin(f)); Volume_handle c1 = D.volume(f), c2 = D.volume(D.twin(f)); CGAL_NEF_TRACEN(" mark("<index(c1)<<")="<index(f) <<")="<index(c2)<<")="<index(c1)<<" & "<index(c2)); } f = f_next; } CGAL_forall_halffacets( f, *this->sncp()) { hash_facet[f] = uf_facet.make_set(f); this->sncp()->reset_object_list(f->boundary_entry_objects()); } /* * Edges simplification */ Halfedge_iterator e(D.halfedges_begin()); while( e != D.halfedges_end() && e->is_twin()) e++; while( e != (*this->sncp()).halfedges_end()) { CGAL_assertion( !e->is_twin()); Halfedge_iterator e_next(e); do e_next++; while( e_next != D.halfedges_end() && e_next->is_twin()); SM_decorator SD(&*D.source(e)); if( SD.is_isolated(e)) { if(D.mark(e) == D.mark(D.volume(D.sface(e)))) { CGAL_NEF_TRACEN("removing pair "<index(e)<<' '<index(D.twin(e))); this->sncp()->delete_halfedge_pair(e); update_facets = true; } } else { if( D.has_outdeg_two(e)) { SHalfedge_handle e1(SD.first_out_edge(e)); SHalfedge_handle e2(SD.cyclic_adj_succ(e1)); if( SD.circle(e1)==SD.circle(SD.twin(e2)) && D.mark(e1)==D.mark(e) && D.mark(e)==D.mark(e2)) { Halffacet_handle f1(D.facet(e1)); Halffacet_handle f2(D.facet(e2)); CGAL_NEF_TRACEN("UNION of "<index(f1)<<" & "<index(D.twin(f2))<< " ("<index(D.twin(f1))<<" & "<index(f2)<<")"); merge_sets( f1, D.twin(f2), hash_facet, uf_facet); merge_sets( D.twin(f1), f2, hash_facet, uf_facet); CGAL_NEF_TRACEN("BEFORE "<index(e)); remove_edge_and_merge_facet_cycles(e); update_facets = true; // CGAL_NEF_TRACEN("AFTER "<>> simplifying done "); return update_sfaces || update_facets || update_volumes; } void remove_edge_and_merge_facet_cycles( Halfedge_handle e) { SNC_decorator D(*this->sncp()); CGAL_assertion( D.has_outdeg_two(e)); Halfedge_handle et = D.twin(e); CGAL_assertion( D.has_outdeg_two(et)); SM_decorator SD1(&*D.vertex(e)); SM_decorator SD2(&*D.vertex(et)); CGAL_NEF_TRACEN("source " << IO->index(D.vertex(e))); CGAL_NEF_TRACEN("target " << IO->index(D.vertex(et))); SHalfedge_handle e1 = SD1.first_out_edge(e); SHalfedge_handle e2 = SD2.next(D.previous(e1)); merge_sedges_at_target_and_remove_svertex( D.twin(e1), e); merge_sedges_at_target_and_remove_svertex( D.twin(e2), et); } void merge_sedges_at_target_and_remove_svertex( SHalfedge_handle s1, SVertex_handle v) { SNC_decorator D(*this->sncp()); SM_decorator SD(&*D.vertex(v)); CGAL_assertion( SD.target(s1) == v); SHalfedge_handle s2(SD.next(s1)); CGAL_assertion( SD.source(s2) == v); CGAL_NEF_TRACEN("s1 = " << IO->index(s1)); CGAL_NEF_TRACEN("s2 = " << IO->index(s2)); if( s1 == s2) { CGAL_NEF_TRACEN(IO->index(s1)<<'('<index(D.twin(s2))<<") to sloop"); SD.convert_edge_to_loop(s1); CGAL_assertion(SD.shalfloop() != SHalfloop_handle()); D.add_sloop_to_facet( SD.shalfloop(), D.facet(s1)); CGAL_NEF_TRACEN(IO->index(s2)<<" removed"); } else { CGAL_assertion( D.has_outdeg_two(v)); D.link_as_prev_next_pair( s1, D.next(s2)); CGAL_NEF_TRACEN(IO->index(s1)<<" "<index(D.next(s2))<<" linked."); D.link_as_prev_next_pair( D.twin(D.next(s2)), D.twin(s1)); CGAL_NEF_TRACEN(IO->index(D.twin(D.next(s2)))<<" "<< IO->index(D.twin(s1))<<" linked."); SD.merge_edge_pairs_at_target( s1); // s2 is removed CGAL_NEF_TRACEN(IO->index(s2)<<" removed"); } } void merge_halfedge_pairs( SVertex_handle p, SVertex_handle q) { SNC_decorator D(*this->sncp()); CGAL_assertion( D.vertex(p) == D.vertex(q)); Vertex_handle v(D.vertex(p)); CGAL_assertion( is_part_of_edge(v)); SM_decorator SD(&*v); SHalfedge_around_svertex_circulator s(SD.first_out_edge(p)), se(s); CGAL_For_all( s, se) { D.link_as_prev_next_pair( D.previous(s), D.next(s)); D.link_as_prev_next_pair( D.previous(SD.twin(s)), D.next(SD.twin(s))); } D.make_twins( D.twin(p), D.twin(q)); SD.delete_vertex(p); SD.delete_vertex(q); this->sncp()->delete_vertex(v); } void purge_no_find_objects( Unique_hash_map< Volume_handle, UFH_volume>& hash_volume, Unique_hash_map< Halffacet_handle, UFH_facet>& hash_facet, Unique_hash_map< SFace_handle, UFH_sface>& hash_sface, Union_find< Volume_handle>& uf_volume, Union_find< Halffacet_handle>& uf_facet, Union_find< SFace_handle>& uf_sface ) { SNC_decorator D(*this->sncp()); SFace_iterator sf; std::list sflist; CGAL_forall_sfaces( sf, *this->sncp()) { if( uf_sface.find(hash_sface[sf]) != hash_sface[sf]) { CGAL_NEF_TRACEN("no find object "<index(sf)); sflist.push_back(sf); } } typename std::list::const_iterator sfli; for(sfli = sflist.begin(); sfli != sflist.end(); sfli++){ SM_decorator SD(&*D.vertex(*sfli)); SD.delete_face_only(*sfli); } Halffacet_iterator f; std::list flist; CGAL_forall_facets( f, *this->sncp()) { CGAL_NEF_TRACEN("facet "<index(f)); if( uf_facet.find(hash_facet[f]) != hash_facet[f]) { CGAL_NEF_TRACEN("no find object "<index(f)); flist.push_back(f); } } typename std::list::const_iterator fli; for(fli = flist.begin(); fli != flist.end(); fli++) this->sncp()->delete_halffacet_pair(*fli); Volume_iterator c; std::list clist; CGAL_forall_volumes( c, *this->sncp()) { if( uf_volume.find(hash_volume[c]) != hash_volume[c]) { CGAL_NEF_TRACEN("no find object "<index(c)); clist.push_back(c); } } typename std::list::const_iterator cli; for(cli = clist.begin(); cli != clist.end(); cli++){ this->sncp()->delete_volume(*cli); } } void create_boundary_links_forall_sfaces( Unique_hash_map< SFace_handle, UFH_sface>& hash, Union_find< SFace_handle>& uf ) { Unique_hash_map< SHalfedge_handle, bool> linked(false); SNC_decorator D(*this->sncp()); SHalfedge_iterator e; CGAL_forall_shalfedges(e, *this->sncp()) { if( linked[e]) continue; SM_decorator SD(&*D.vertex(e)); SFace_handle sf = *(uf.find(hash[D.sface(e)])); CGAL_assertion( sf != SFace_handle()); SHalfedge_around_sface_circulator c(e), cend(c); CGAL_For_all( c, cend) { SD.set_face(c, sf); linked[c] = true; } SD.store_sm_boundary_object( e, sf); } SVertex_handle sv; CGAL_forall_svertices(sv, *this->sncp()) { SM_decorator SD(&*D.vertex(sv)); if( SD.is_isolated(sv)) { SFace_handle sf = *(uf.find(hash[SD.face(sv)])); CGAL_assertion( sf != SFace_handle()); SD.set_face( sv, sf); SD.store_sm_boundary_object( sv, sf); } } SHalfloop_handle sl; CGAL_forall_shalfloops(sl, *this->sncp()) { SM_decorator SD(&*D.vertex(sl)); SD.store_sm_boundary_object( sl, SD.face(sl)); } } void create_boundary_links_forall_facets( Unique_hash_map< Halffacet_handle, UFH_facet>& hash, Union_find< Halffacet_handle>& uf) { Unique_hash_map< SHalfedge_handle, bool> linked(false); SNC_decorator D(*this->sncp()); SHalfedge_iterator u; CGAL_forall_shalfedges(u, *this->sncp()) { if( linked[u]) continue; /* set find(f) as incident facet of every edge use on the cycle of u */ SHalfedge_handle u_min = u; Halffacet_handle f = *(uf.find(hash[D.facet(u)])); SHalfedge_around_facet_circulator c(u), cend(c); CGAL_For_all( c, cend) { D.set_facet( c, f); if( lexicographically_xyz_smaller(D.point(D.vertex(c)), D.point(D.vertex(u_min)))) u_min = c; linked[c] = true; } /* store the edge use at the lexicographicaly minimum facet vertex, as a cycle entry of f. The outermost cycle is stored at first on the facet's cycles list. */ if( is_empty_range( f->boundary_entry_objects().begin(), f->boundary_entry_objects().end())) { D.store_boundary_object( u_min, f); CGAL_NEF_TRACEN("new outer cycle min. vertex: "<boundary_entry_objects().front())); CGAL::assign( f_sedge, f->boundary_entry_objects().front()); if( lexicographically_xyz_smaller(D.point(D.vertex(u_min)), D.point(D.vertex(f_sedge)))) D.store_as_first_boundary_object( u_min, f); else D.store_boundary_object( u_min, f); } } SHalfloop_iterator l; CGAL_forall_shalfloops( l, *this->sncp()) { Halffacet_handle f = *(uf.find(hash[D.facet(l)])); D.set_facet( l, f); D.store_boundary_object( l, f); } } void create_boundary_links_forall_volumes( Unique_hash_map< Volume_handle, UFH_volume>& hash, Union_find< Volume_handle>& uf) { typedef typename SNC_decorator::template Shell_volume_setter Volume_setter; // typedef Unique_hash_map< SFace_handle, bool> SFace_map; // SFace_map linked(false); #ifdef CGAL_NEF_DEBUG delete IO; IO = new SNC_io_parser(std::cerr, *this->sncp()); #endif SNC_decorator D(*this->sncp()); Volume_setter setter(D); SFace_iterator sf; Volume_handle c; CGAL_forall_sfaces(sf, *this->sncp()) { CGAL_NEF_TRACEN("SFace " << IO->index(sf)); if( setter.is_linked(sf)) continue; c = *(uf.find(hash[D.volume(sf)])); CGAL_NEF_TRACEN("Volume " << IO->index(c)); setter.set_volume(c); D.visit_shell_objects( sf, setter ); D.store_boundary_object( sf, c); } } }; CGAL_END_NAMESPACE #endif // CGAL_SNC_STRUCTURE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/bounded_side_3.h0000644000175000017500000001470111344301501030775 0ustar debiandebian// Copyright (c) 1997-2002 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_3/bounded_side_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Miguel Granados // Susan Hert // Lutz Kettner #ifndef CGAL_BOUNDED_SIDE_3_H #define CGAL_BOUNDED_SIDE_3_H #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 17 #include CGAL_BEGIN_NAMESPACE template Point_2 point_3_get_x_y_point_2(Point_3 p) { return( Point_2(p.hx(), p.hy(), p.hw()) ); } template Point_2 point_3_get_y_z_point_2(Point_3 p) { return( Point_2(p.hy(), p.hz(), p.hw()) ); } template Point_2 point_3_get_z_x_point_2(Point_3 p) { return( Point_2(p.hz(), p.hx(), p.hw()) ); } template Bounded_side bounded_side_3(IteratorForward first, IteratorForward last, const Point_3& point, typename R::Plane_3 plane = typename R::Plane_3(0,0,0,0)) { typedef typename R::Point_2 Point_2; typedef typename R::Point_3 Point_3; typedef typename R::Vector_3 Vector_3; typedef typename R::Plane_3 Plane_3; if(plane == Plane_3(0,0,0,0)) { // TO TEST: code never tested IteratorForward p(first); Point_3 p0(*(p++)); CGAL_assertion(p != last); Point_3 p1(*(p++)); CGAL_assertion(p != last); Point_3 p2(*(p++)); plane = Plane_3(p0, p1, p2); /* since we just need to project the points to a non-perpendicular plane we don't need to care about the plane orientation */ } CGAL_assertion(!plane.is_degenerate()); Point_2 (*t)(Point_3); Vector_3 pv(plane.orthogonal_vector()), pxy(0,0,1), pyz(1,0,0), pzx(0,1,0); CGAL_NEF_TRACEN("pv*pxz: "<; else if( !CGAL_NTS is_zero(pv*pyz) ) /* the plane is not perpendicular to the YZ plane */ t = &point_3_get_y_z_point_2< Point_2, Point_3>; else { CGAL_assertion( !CGAL_NTS is_zero(pv*pxy) ); /* the plane is not perpendicular to the XY plane */ t = &point_3_get_x_y_point_2< Point_2, Point_3>; } std::vector< Point_2> points; CGAL_NEF_TRACEN("facet:"); for( ; first != last; ++first ) { CGAL_NEF_TRACEN(t(*first)<<" "<<*first); points.push_back( t(*first)); } Bounded_side side = bounded_side_2( points.begin(), points.end(), t(point)); points.clear(); return side; } CGAL_END_NAMESPACE #ifdef WRONG_IMPLEMENTATION /* The following code is wrong since Proyector_.. structures must not return references to temporal objects */ template < class Point_2, class Point_3> struct Project_XY { typedef Point_3 argument_type; typedef Point_2 result_type; Point_2 operator()( Point_3& p) const { return Point_2(p.hx(), p.hy(), p.hw()); } const Point_2 operator()( const Point_3& p) const { return Point_2(p.hx(), p.hy(), p.hw()); } }; template < class Point_2, class Point_3> struct Project_YZ { typedef Point_3 argument_type; typedef Point_2 result_type; Point_2 operator()( Point_3& p) const { return Point_2(p.hy(), p.hz(), p.hw()); } const Point_2 operator()( const Point_3& p) const { return Point_2(p.hy(), p.hz(), p.hw()); } }; template < class Point_2, class Point_3> struct Project_XZ { typedef Point_3 argument_type; typedef Point_2 result_type; Point_2 operator()( Point_3& p) const { return Point_2(p.hx(), p.hz(), p.hw()); } const Point_2 operator()( const Point_3& p) const { return Point_2(p.hx(), p.hz(), p.hw()); } }; template Bounded_side bounded_side_3(IC first, IC last, const Point_3& point, Plane_3 plane = Plane_3(0,0,0,0)) { typedef typename R::Point_2 Point_2; typedef typename R::Point_3 Point_3; typedef typename R::Vector_3 Vector_3; typedef typename R::Plane_3 Plane_3; CGAL_assertion( !CGAL::is_empty_range( first, last)); if(plane == Plane_3(0,0,0,0)) { Vector_3 hv; normal_vector_newell_3( first, last, hv); plane = Plane_3( *first, Vector_3(hv)); } CGAL_assertion(!plane.is_degenerate()); Vector_3 pd(plane.orthogonal_vector()), pyz(1,0,0), pxz(0,1,0); if(pd == pyz || pd == -pyz) { /* the plane is parallel to the YZ plane */ typedef Project_YZ< Point_2, Point_3> Project_YZ; typedef Iterator_project< IC, Project_YZ> Iterator_YZ; Project_YZ project; Point_2 p = project(point); Iterator_YZ pfirst(first), plast(last); return bounded_side_2(pfirst, plast, p); } else if(pd == pxz || pd ==- pxz) { /* the plane is parallel to the XZ plane */ typedef Project_XZ< Point_2, Point_3> Project_XZ; typedef Iterator_project< IC, Project_XZ> Iterator_XZ; Project_XZ project; Point_2 p = project(point); Iterator_XZ pfirst(first), plast(last); return bounded_side_2(pfirst, plast, p); } else { CGAL_assertion(cross_product(pd.vector(), Vector_3(0,0,1)) == NULL_VECTOR); /* the plane is not perpendicular to the XY plane */ typedef Project_XY< Point_2, Point_3> Project_XY; typedef Iterator_project< IC, Project_XY> Iterator_XY; Project_XY project; Point_2 p = project(point); Iterator_XY pfirst(first), plast(last); return bounded_side_2(pfirst, plast, p); } } #endif // WRONG_IMPLEMENTATION #endif // CGAL_BOUNDED_SIDE_3_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_construction.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_construction.0000644000175000017500000000571111344301500031375 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_construction.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_FILTERED_CONSTRUCTION_H #define CGAL_FILTERED_CONSTRUCTION_H #include #include CGAL_BEGIN_NAMESPACE template class Filtered_construction { private: EC Exact_construction; FC Filter_construction; C2E To_Exact; C2F To_Filtered; E2C From_Exact; F2C From_Filtered; typedef typename AC::result_type AC_result_type; typedef typename FC::result_type FC_result_type; typedef typename EC::result_type EC_result_type; public: typedef AC_result_type result_type; typedef typename AC::Arity Arity; public: Filtered_construction() {} template result_type operator()(const A1 &a1) const { try { Protect_FPU_rounding P; return From_Filtered( Filter_construction(To_Filtered(a1)) ); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return From_Exact( Exact_construction(To_Exact(a1)) ); } } template result_type operator()(const A1 &a1, const A2 &a2) const { try { Protect_FPU_rounding P; return From_Filtered( Filter_construction(To_Filtered(a1), To_Filtered(a2)) ); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return From_Exact( Exact_construction(To_Exact(a1), To_Exact(a2)) ); } } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3) const { try { Protect_FPU_rounding P; return From_Filtered( Filter_construction(To_Filtered(a1), To_Filtered(a2), To_Filtered(a3)) ); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return From_Exact( Exact_construction(To_Exact(a1), To_Exact(a3), To_Exact(a2)) ); } } }; CGAL_END_NAMESPACE #endif // CGAL_FILTERED_CONSTRUCTION_H ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions_on_weighted_points_homogeneous_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/constructions_on_weigh0000644000175000017500000000567611344301500031555 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/constructions_on_weighted_points_homogeneous_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Julia Flototto, Mariette Yvinec #ifndef CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_HOMOGENEOUS_2_H #define CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_HOMOGENEOUS_2_H CGAL_BEGIN_NAMESPACE template < class RT, class We> void weighted_circumcenterH2( const RT &phx, const RT &phy, const RT &phw, const We &pwt, const RT &qhx, const RT &qhy, const RT &qhw, const We &qwt, const RT &rhx, const RT &rhy, const RT &rhw, const We &rwt, RT &vvx, RT &vvy, RT &vvw ) { // RT qx_px = ( qhx*qhw*phw*phw - phx*phw*qhw*qhw ); // RT qy_py = ( qhy*qhw*phw*phw - phy*phw*qhw*qhw ); // RT rx_px = ( rhx*rhw*phw*phw - phx*phw*rhw*rhw ); // RT ry_py = ( rhy*rhw*phw*phw - phy*phw*rhw*rhw ); // //intersection of the two radical axis of (qp) and (rp) // RT px2_py2_rx2_ry_2 = // phx*phx*rhw*rhw + phy*phy*rhw*rhw - rhx*rhx*phw*phw - // rhy*rhy*phw*phw - RT(pwt*pwt) + RT(rwt*rwt); // RT px2_py2_qx2_qy_2 = // phx*phx*qhw*qhw + phy*phy*qhw*qhw - qhx*qhx*phw*phw - // qhy*qhy*phw*phw - RT(pwt*pwt) + RT(qwt*qwt); // vvx = qy_py * px2_py2_rx2_ry_2 - ry_py * px2_py2_qx2_qy_2; // vvy = rx_px * px2_py2_qx2_qy_2 - qx_px * px2_py2_rx2_ry_2; // vvw = RT(2) * ( qx_px * ry_py - rx_px * qy_py ); RT a1, b1, c1; RT a2, b2, c2; radical_axisH2(phx,phy,phw,pwt,qhx,qhy,qhw,qwt,a1,b1,c1); radical_axisH2(phx,phy,phw,pwt,rhx,rhy,rhw,rwt,a2,b2,c2); vvx = b1*c2 - c1*b2; vvy = c1*a2 - c2*a1; vvw = a1*b2 - a2*b1; } template < class RT , class We> void radical_axisH2(const RT &phx, const RT &phy, const RT &phw, const We &pwt, const RT &qhx, const RT &qhy, const RT &qhw, const We &qwt, RT &a, RT &b, RT &c ) { // a = RT(2) * ( qhx*qhw*phw*phw - phx*phw*qhw*qhw ); // b = RT(2) * ( qhy*qhw*phw*phw - phy*phw*qhw*qhw ); // c = phx*phx*qhw*qhw + phy*phy*qhw*qhw - qhx*qhx*phw*phw // - qhy*qhy*phw*phw- RT(pwt*pwt) + RT(qwt*qwt); a = RT(2) * ( phx*phw*qhw*qhw - qhx*qhw*phw*phw ); b = RT(2) * ( phy*phw*qhw*qhw - qhy*qhw*phw*phw ); c = - phx*phx*qhw*qhw - phy*phy*qhw*qhw + qhx*qhx*phw*phw + qhy*qhy*phw*phw + RT(pwt)*phw*phw*qhw*qhw - RT(qwt)*phw*phw*qhw*qhw; } CGAL_END_NAMESPACE #endif //CGAL_CONSTRUCTIONS_ON_WEIGHTED_POINTS_HOMOGENEOUS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_jarvis.C0000644000175000017500000001002211344301500027067 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_jarvis.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_JARVIS_C #define CGAL_CH_JARVIS_C #ifndef CGAL_CH_JARVIS_H #include #endif // CGAL_CH_JARVIS_H #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS #include #include #include #include #include CGAL_BEGIN_NAMESPACE template OutputIterator ch_jarvis_march(ForwardIterator first, ForwardIterator last, const Point& start_p, const Point& stop_p, OutputIterator result, const Traits& ch_traits) { if (first == last) return result; typedef typename Traits::Less_rotate_ccw_2 Less_rotate_ccw; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Equal_2 Equal_2; Equal_2 equal_points = ch_traits.equal_2_object(); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions ... CGAL_ch_assertion_code( \ int count_points = 0; ) CGAL_ch_assertion_code( \ for (ForwardIterator fit = first; fit!= last; ++fit) ++count_points; ) Less_rotate_ccw rotation_predicate = ch_traits.less_rotate_ccw_2_object( ); *res = start_p; ++res; CGAL_ch_assertion_code( \ int constructed_points = 1; ) CGAL_ch_exactness_assertion_code( \ Point previous_point = start_p; ) ForwardIterator it = std::min_element( first, last, bind_1(rotation_predicate, start_p) ); while (! equal_points(*it, stop_p) ) { CGAL_ch_exactness_assertion( \ *it != previous_point ); CGAL_ch_exactness_assertion_code( \ previous_point = *it; ) *res = *it; ++res; CGAL_ch_assertion_code( \ ++constructed_points;) CGAL_ch_assertion( \ constructed_points <= count_points + 1 ); it = std::min_element( first, last, bind_1(rotation_predicate, *it) ); } CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( res.output_so_far_begin(), \ res.output_so_far_end(), \ ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( first, last, \ res.output_so_far_begin(), res.output_so_far_end(), \ ch_traits)); #if defined(CGAL_CH_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions ... } template OutputIterator ch_jarvis(ForwardIterator first, ForwardIterator last, OutputIterator result, const Traits& ch_traits) { if (first == last) return result; ForwardIterator start; ch_w_point(first, last, start, ch_traits); return ch_jarvis_march( first, last, *start, *start, result, ch_traits); } CGAL_END_NAMESPACE #endif // CGAL_CH_JARVIS_C ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Point_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Point_2_int0000644000175000017500000000224111344301501031175 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_2_Point_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_melkman.C0000644000175000017500000000760511344301500027232 0ustar debiandebian // Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_melkman.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_MELKMAN_C #define CGAL_CH_MELKMAN_C #ifndef CGAL_CH_MELKMAN_H #include #endif #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS #include #include #include CGAL_BEGIN_NAMESPACE template OutputIterator ch_melkman( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Point_2 Point; typedef typename Traits::Segment_2 Segment; typedef typename Traits::Equal_2 Equal_2; typename Traits::Left_turn_2 left_turn = ch_traits.left_turn_2_object(); Equal_2 equal_points = ch_traits.equal_2_object(); CGAL_ch_assertion_code( \ typename Traits::Less_xy_2 less = ch_traits.less_xy_2_object(); ) std::deque< Point> Q; CGAL_ch_expensive_postcondition_code( std::deque< Point> IN; ) if (first == last) return result; // 0 elements Point p = *first; CGAL_ch_expensive_postcondition_code( IN.push_back(p); ) if (++first == last) { *result = p; ++result; return result; } // 1 element Point q = *first; CGAL_ch_expensive_postcondition_code( IN.push_back(q); ) if (++first == last) // 2 elements { *result = p; ++result; if (! equal_points(p,q)) { *result = q; ++result; } return result; } Q.push_back( p); Point r; while (first != last) { r = *first; CGAL_ch_expensive_postcondition_code( IN.push_back(r); ) // visited input sequence = p,..., q, r if ( left_turn(p,q,r)) { Q.push_back( q); break; } if ( left_turn(q,p,r)) { Q.push_front( q); break; } CGAL_ch_assertion( less( p, q) ? less (p, r) : less( r, p)); q = r; ++first; } Point current = q; if (first != last) // non-collinear point r exists { current = r; // current, Q.front(), ..., Q.back() // ccw convex hull of visited points Point s; while ( ++first != last) { r = *first; CGAL_ch_expensive_postcondition_code( IN.push_back(r); ) if (left_turn( current, r, Q.front()) || left_turn( Q.back(), r, current)) // r outside cone Q.front(), current, Q.back() <=> // right_turn( current, Q.front(), r) || // right_turn( Q.back(), current, r) { s = current; while ( !left_turn( r, s, Q.front())) // !left_turn( r, s, Q.front()) { s = Q.front(); Q.pop_front(); } Q.push_front(s); s = current; while ( !left_turn( s, r, Q.back())) // !right_turn( r, s, Q.back()) { s = Q.back(); Q.pop_back(); } Q.push_back(s); current = r; } } } Q.push_back( current); // add last point to Q CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( Q.begin(), Q.end(), ch_traits)); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( IN.begin(),IN.end(), Q.begin(),Q.end(), ch_traits)); std::copy( Q.begin(), Q.end(), result); return result; } CGAL_END_NAMESPACE #endif // CGAL_CH_MELKMAN_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/generators.h0000644000175000017500000000741111344301500027345 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/generators.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_GENERATORS_H #define CGAL_GENERATORS_H 1 #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class T > class Generator_base { protected: T d_item; double d_range; public: typedef std::input_iterator_tag iterator_category; typedef T value_type; typedef std::ptrdiff_t difference_type; typedef const T* pointer; typedef const T& reference; typedef Generator_base This; Generator_base() {} Generator_base( double range) : d_range( range) {} Generator_base( const T& item, double range) : d_item(item), d_range(range) {} bool operator==( const This& base) const { return ( d_item == base.d_item); } bool operator!=( const This& base) const { return ! operator==(base);} double range() const { return d_range; } reference operator*() const { return d_item; } pointer operator->() const { return & operator*(); } }; template < class T > class Random_generator_base : public Generator_base { protected: Random& _rnd; public: typedef Random_generator_base This; Random_generator_base() : _rnd( default_random) {} Random_generator_base( double range, Random& rnd) : Generator_base( range), _rnd( rnd) {} Random_generator_base( const T& item, double range, Random& rnd) : Generator_base( item, range), _rnd( rnd) {} bool operator==( const This& rb) const { return ( _rnd == rb._rnd && Generator_base::operator==(rb)); } bool operator!=( const This& rb) const { return ! operator==(rb); } }; class Random_double_in_interval : public Random_generator_base { public: typedef Random_double_in_interval This; Random_double_in_interval(double a = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed in the half-open square with side length a, // centered around the origin, i.e. \forall p = `*g': -\frac{a}{2} // <= p.x() < \frac{a}{2} and -\frac{a}{2} <= p.y() < \frac{a}{2} // . Two random numbers are needed from `rnd' for each point. : Random_generator_base( a, rnd) { this->d_item = this->d_range * (2 * this->_rnd.get_double() - 1.0); } This& operator++() { this->d_item = this->d_range * (2 * this->_rnd.get_double() - 1.0); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; CGAL_END_NAMESPACE #endif // CGAL_GENERATORS_H // // EOF // ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_structure_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_str0000644000175000017500000022427311344301501031457 0ustar debiandebian// Copyright (c) 1999,2000,2001,2002,2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_structure_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud // Sylvain Pion // // combinatorial triangulation of the boundary of a polytope // of dimension d in dimension d+1 // for -1 <= d <= 3 // // ============================================================================ #ifndef CGAL_TRIANGULATION_DATA_STRUCTURE_3_H #define CGAL_TRIANGULATION_DATA_STRUCTURE_3_H #include #include #include #include #include #include #if (!defined _MSC_VER || defined __INTEL_COMPILER) && !defined __sgi # define CGAL_T3_USE_ITERATOR_AS_HANDLE #endif #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // TODO : noms : Vb != Vertex_base : clarifier. template < class Vb = Triangulation_ds_vertex_base_3<>, class Cb = Triangulation_ds_cell_base_3<> > class Triangulation_data_structure_3 : public Triangulation_utils_3 { typedef Triangulation_data_structure_3 Tds; typedef typename Vb::template Rebind_TDS::Other Vertex_base; typedef typename Cb::template Rebind_TDS::Other Cell_base; friend class Triangulation_ds_facet_iterator_3; friend class Triangulation_ds_edge_iterator_3; friend class Triangulation_ds_cell_circulator_3; friend class Triangulation_ds_facet_circulator_3; public: typedef Triangulation_ds_vertex_3 Vertex; typedef Triangulation_ds_cell_3 Cell; private: typedef Compact_container Cell_container; typedef Compact_container Vertex_container; public: typedef typename Cell_container::size_type size_type; typedef typename Cell_container::difference_type difference_type; typedef typename Cell_container::iterator Cell_iterator; typedef typename Vertex_container::iterator Vertex_iterator; typedef Triangulation_ds_facet_iterator_3 Facet_iterator; typedef Triangulation_ds_edge_iterator_3 Edge_iterator; typedef Triangulation_ds_cell_circulator_3 Cell_circulator; typedef Triangulation_ds_facet_circulator_3 Facet_circulator; //private: // In 2D only : typedef Triangulation_ds_face_circulator_3 Face_circulator; #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE typedef Vertex_iterator Vertex_handle; typedef Cell_iterator Cell_handle; #else // Defining nested classes for the handles instead of typedefs // considerably shortens the symbol names (and compile times). // It makes error messages more readable as well. class Vertex_handle { Vertex_iterator _v; public: typedef Vertex value_type; typedef value_type * pointer; typedef value_type & reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef void iterator_category; Vertex_handle() : _v() {} Vertex_handle(Vertex_iterator v) : _v(v) {} #ifndef CGAL_NO_DEPRECATED_CODE // must be kept Vertex_handle(void * CGAL_triangulation_precondition_code(n)) : _v() { CGAL_triangulation_precondition(n == NULL); } #endif Vertex* operator->() const { return &*_v; } Vertex& operator*() const { return *_v; } bool operator==(Vertex_handle v) const { return _v == v._v; } bool operator!=(Vertex_handle v) const { return _v != v._v; } #ifndef CGAL_NO_DEPRECATED_CODE // must be kept // For std::set and co. bool operator<(Vertex_handle v) const { return &*_v < &*v._v; } #endif // Should be private to the TDS : const Vertex_iterator & base() const { return _v; } Vertex_iterator & base() { return _v; } void * for_compact_container() const { return _v.for_compact_container(); } void * & for_compact_container() { return _v.for_compact_container(); } }; class Cell_handle { Cell_iterator _c; public: typedef Cell value_type; typedef value_type * pointer; typedef value_type & reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef void iterator_category; Cell_handle() : _c() {} Cell_handle(Cell_iterator c) : _c(c) {} Cell_handle(const Cell_circulator &c) : _c(c.base()._c) {} Cell_handle(const Face_circulator &c) : _c(c.base()._c) {} #ifndef CGAL_NO_DEPRECATED_CODE // must be kept Cell_handle(void * CGAL_triangulation_precondition_code(n)) : _c() { CGAL_triangulation_precondition(n == NULL); } #endif Cell* operator->() const { return &*_c; } Cell& operator*() const { return *_c; } bool operator==(Cell_handle c) const { return _c == c._c; } bool operator!=(Cell_handle c) const { return _c != c._c; } #ifndef CGAL_NO_DEPRECATED_CODE // must be kept // For std::set and co. bool operator<(Cell_handle c) const { return &*_c < &*c._c; } #endif // These should be private to the TDS : const Cell_iterator & base() const { return _c; } Cell_iterator & base() { return _c; } void * for_compact_container() const { return _c.for_compact_container(); } void * & for_compact_container() { return _c.for_compact_container(); } }; #endif typedef std::pair Facet; typedef Triple Edge; public: Triangulation_data_structure_3() : _dimension(-2) {} Triangulation_data_structure_3(const Tds & tds) { copy_tds(tds); } Tds & operator= (const Tds & tds) { if (&tds != this) { Tds tmp(tds); swap(tmp); } return *this; } size_type number_of_vertices() const { return vertex_container().size(); } int dimension() const {return _dimension;} size_type number_of_cells() const { if ( dimension() < 3 ) return 0; return cell_container().size(); } size_type number_of_facets() const { if ( dimension() < 2 ) return 0; return std::distance(facets_begin(), facets_end()); } size_type number_of_edges() const { if ( dimension() < 1 ) return 0; return std::distance(edges_begin(), edges_end()); } // USEFUL CONSTANT TIME FUNCTIONS // SETTING void set_dimension(int n) { _dimension = n; } Vertex_handle create_vertex(const Vertex &v) { return vertex_container().insert(v); } Vertex_handle create_vertex() { return vertex_container().construct_insert(); } Vertex_handle create_vertex(const Vertex_handle& v) { return create_vertex(*v); } Cell_handle create_cell(const Cell &c) { Cell_handle r = cell_container().insert(c); r->init(); return r; } Cell_handle create_cell() { Cell_handle r = cell_container().construct_insert(); r->init(); return r; } Cell_handle create_cell(const Cell_handle& c) { return create_cell(*c); } Cell_handle create_cell(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3) { Cell_handle r =cell_container().construct_insert(v0, v1, v2, v3); r->init(); return r; } Cell_handle create_cell(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Cell_handle& n0, const Cell_handle& n1, const Cell_handle& n2, const Cell_handle& n3) { Cell_handle r =cell_container().construct_insert(v0, v1, v2, v3, n0, n1, n2, n3); r->init(); return r; } Cell_handle create_face() { CGAL_triangulation_precondition(dimension()<3); return create_cell(); } Cell_handle create_face(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2) { CGAL_triangulation_precondition(dimension()<3); Cell_handle r = cell_container().construct_insert(v0, v1, v2, Vertex_handle()); r->init(); return r; //return cell_container().insert(Cell(v0, v1, v2, Vertex_handle())); } // The following functions come from TDS_2. Cell_handle create_face(const Cell_handle& f0, int i0, const Cell_handle& f1, int i1, const Cell_handle& f2, int i2) { CGAL_triangulation_precondition(dimension() <= 2); Cell_handle newf = create_face(f0->vertex(cw(i0)), f1->vertex(cw(i1)), f2->vertex(cw(i2))); set_adjacency(newf, 2, f0, i0); set_adjacency(newf, 0, f1, i1); set_adjacency(newf, 1, f2, i2); return newf; } Cell_handle create_face(const Cell_handle& f0, int i0, const Cell_handle& f1, int i1) { CGAL_triangulation_precondition(dimension() <= 2); Cell_handle newf = create_face(f0->vertex(cw(i0)), f1->vertex(cw(i1)), f1->vertex(ccw(i1))); set_adjacency(newf, 2, f0, i0); set_adjacency(newf, 0, f1, i1); return newf; } Cell_handle create_face(const Cell_handle& f, int i, const Vertex_handle& v) { CGAL_triangulation_precondition(dimension() <= 2); Cell_handle newf = create_face(f->vertex(cw(i)), f->vertex(ccw(i)), v); set_adjacency(newf, 2, f, i); return newf; } // not documented void read_cells(std::istream& is, std::map< int, Vertex_handle > &V, int & m, std::map< int, Cell_handle > &C ); // not documented void print_cells(std::ostream& os, const std::map &V ) const; // ACCESS FUNCTIONS void delete_vertex( const Vertex_handle& v ) { CGAL_triangulation_expensive_precondition( is_vertex(v) ); #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE vertex_container().erase(v); #else vertex_container().erase(v.base()); #endif } void delete_cell( const Cell_handle& c ) { CGAL_triangulation_expensive_precondition( dimension() != 3 || is_cell(c) ); CGAL_triangulation_expensive_precondition( dimension() != 2 || is_facet(c,3) ); CGAL_triangulation_expensive_precondition( dimension() != 1 || is_edge(c,0,1) ); CGAL_triangulation_expensive_precondition( dimension() != 0 || is_vertex(c->vertex(0)) ); #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE cell_container().erase(c); #else cell_container().erase(c.base()); #endif } template void delete_vertices(InputIterator begin, InputIterator end) { for(; begin != end; ++begin) delete_vertex(*begin); } template void delete_cells(InputIterator begin, InputIterator end) { for(; begin != end; ++begin) delete_cell(*begin); } // QUERIES bool is_vertex(const Vertex_handle& v) const; bool is_edge(const Cell_handle& c, int i, int j) const; bool is_edge(const Vertex_handle& u, const Vertex_handle& v, Cell_handle & c, int & i, int & j) const; bool is_edge(const Vertex_handle& u, const Vertex_handle& v) const; bool is_facet(const Cell_handle& c, int i) const; bool is_facet(const Vertex_handle& u, const Vertex_handle& v, const Vertex_handle& w, Cell_handle & c, int & i, int & j, int & k) const; bool is_cell(const Cell_handle& c) const; bool is_cell(const Vertex_handle& u, const Vertex_handle& v, const Vertex_handle& w, const Vertex_handle& t, Cell_handle & c, int & i, int & j, int & k, int & l) const; bool is_cell(const Vertex_handle& u, const Vertex_handle& v, const Vertex_handle& w, const Vertex_handle& t) const; bool has_vertex(const Facet & f, const Vertex_handle& v, int & j) const; bool has_vertex(const Cell_handle& c, int i, const Vertex_handle& v, int & j) const; bool has_vertex(const Facet & f, const Vertex_handle& v) const; bool has_vertex(const Cell_handle& c, int i, const Vertex_handle& v) const; bool are_equal(const Cell_handle& c, int i, const Cell_handle& n, int j) const; bool are_equal(const Facet & f, const Facet & g) const; bool are_equal(const Facet & f, const Cell_handle& n, int j) const; // MODIFY bool flip(const Cell_handle& c, int i); bool flip(const Facet &f) { return flip( f.first, f.second); } void flip_flippable(const Cell_handle& c, int i); void flip_flippable(const Facet &f) { flip_flippable( f.first, f.second ); } bool flip(const Cell_handle& c, int i, int j); bool flip(const Edge &e) { return flip( e.first, e.second, e.third ); } void flip_flippable(const Cell_handle& c, int i, int j); void flip_flippable(const Edge &e) { flip_flippable( e.first, e.second, e.third ); } private: // common to flip and flip_flippable void flip_really(const Cell_handle& c, int i, const Cell_handle& n, int in); void flip_really(const Cell_handle& c, int i, int j, const Cell_handle& c1, const Vertex_handle& v1, int i1, int j1, int next1, const Cell_handle& c2, const Vertex_handle& v2, int i2, int j2, int next2, const Vertex_handle& v3); Cell_handle create_star_3(const Vertex_handle& v, const Cell_handle& c, int li, int prev_ind2 = -1); Cell_handle create_star_2(const Vertex_handle& v, const Cell_handle& c, int li); public: // Internal function : assumes the conflict cells are marked. template Vertex_handle _insert_in_hole(CellIt cell_begin, CellIt cell_end, const Cell_handle& begin, int i) { CGAL_triangulation_precondition(begin != Cell_handle()); // if begin == NULL (default arg), we could compute one by walking in // CellIt. At the moment, the functionality is not available, you have // to specify a starting facet. Vertex_handle newv = create_vertex(); Cell_handle cnew; if (dimension() == 3) cnew = create_star_3(newv, begin, i); else cnew = create_star_2(newv, begin, i); newv->set_cell(cnew); delete_cells(cell_begin, cell_end); return newv; } // Mark the cells in conflict, then calls the internal function. template Vertex_handle insert_in_hole(CellIt cell_begin, CellIt cell_end, const Cell_handle& begin, int i) { for (CellIt cit = cell_begin; cit != cell_end; ++cit) (*cit)->set_in_conflict_flag(1); return _insert_in_hole(cell_begin, cell_end, begin, i); } //INSERTION Vertex_handle insert_in_cell(const Cell_handle& c); Vertex_handle insert_in_facet(const Facet & f) { return insert_in_facet(f.first, f.second); } Vertex_handle insert_in_facet(const Cell_handle& c, int i); Vertex_handle insert_in_edge(const Edge & e) { return insert_in_edge(e.first, e.second, e.third); } Vertex_handle insert_in_edge(const Cell_handle& c, int i, int j); Vertex_handle insert_increase_dimension(Vertex_handle star =Vertex_handle()); // REMOVAL private: Cell_handle remove_degree_4(const Vertex_handle& v); Cell_handle remove_degree_3(const Vertex_handle& v); Cell_handle remove_degree_2(const Vertex_handle& v); public: Cell_handle remove_from_maximal_dimension_simplex(const Vertex_handle& v); void remove_decrease_dimension(const Vertex_handle& v); // Change orientation of the whole TDS. void reorient() { CGAL_triangulation_precondition(dimension() >= 1); for (Cell_iterator i = cell_container().begin(); i != cell_container().end(); ++i) change_orientation(i); } // ITERATOR METHODS Cell_iterator cells_begin() const { if ( dimension() < 3 ) return cells_end(); return cell_container().begin(); } Cell_iterator cells_end() const { return cell_container().end(); } Facet_iterator facets_begin() const { if ( dimension() < 2 ) return facets_end(); return Facet_iterator(this); } Facet_iterator facets_end() const { return Facet_iterator(this, 1); } Edge_iterator edges_begin() const { if ( dimension() < 1 ) return edges_end(); return Edge_iterator(this); } Edge_iterator edges_end() const { return Edge_iterator(this,1); } Vertex_iterator vertices_begin() const { return vertex_container().begin(); } Vertex_iterator vertices_end() const { return vertex_container().end(); } // CIRCULATOR METHODS // cells around an edge Cell_circulator incident_cells(const Edge & e) const { CGAL_triangulation_precondition( dimension() == 3 ); return Cell_circulator(e); } Cell_circulator incident_cells(const Cell_handle& ce, int i, int j) const { CGAL_triangulation_precondition( dimension() == 3 ); return Cell_circulator(ce, i, j); } Cell_circulator incident_cells(const Edge &e, const Cell_handle& start) const { CGAL_triangulation_precondition( dimension() == 3 ); return Cell_circulator(e, start); } Cell_circulator incident_cells(const Cell_handle& ce, int i, int j, const Cell_handle& start) const { CGAL_triangulation_precondition( dimension() == 3 ); return Cell_circulator(ce, i, j, start); } //facets around an edge Facet_circulator incident_facets(const Edge & e) const { CGAL_triangulation_precondition( dimension() == 3 ); return Facet_circulator(e); } Facet_circulator incident_facets(const Cell_handle& ce, int i, int j) const { CGAL_triangulation_precondition( dimension() == 3 ); return Facet_circulator(ce, i, j); } Facet_circulator incident_facets(const Edge & e, const Facet & start) const { CGAL_triangulation_precondition( dimension() == 3 ); return Facet_circulator(e, start); } Facet_circulator incident_facets(const Cell_handle& ce, int i, int j, const Facet & start) const { CGAL_triangulation_precondition( dimension() == 3 ); return Facet_circulator(ce, i, j, start); } Facet_circulator incident_facets(const Edge & e, const Cell_handle& start, int f) const { CGAL_triangulation_precondition( dimension() == 3 ); return Facet_circulator(e, start, f); } Facet_circulator incident_facets(const Cell_handle& ce, int i, int j, const Cell_handle& start, int f) const { CGAL_triangulation_precondition( dimension() == 3 ); return Facet_circulator(ce, i, j, start, f); } // 2D : circulates on the faces adjacent to a vertex. Face_circulator incident_faces(const Vertex_handle& v) const { CGAL_triangulation_precondition( dimension() == 2 ); return Face_circulator(v, v->cell()); } // around a vertex private: template void incident_cells_3(const Vertex_handle& v, const Cell_handle& c, OutputIterator cells) const { CGAL_triangulation_precondition(dimension() == 3); // Flag values : // 1 : incident cell already visited // 0 : unknown c->set_in_conflict_flag(1); *cells++ = c; for (int i=0; i<4; ++i) { if (c->vertex(i) == v) continue; Cell_handle next = c->neighbor(i); if (next->get_in_conflict_flag() != 0) continue; incident_cells_3(v, next, cells); } } template void incident_cells_2(const Vertex_handle& v, const Cell_handle& c, OutputIterator cells) const { CGAL_triangulation_precondition(dimension() == 2); // TODO : in 2D, there's no real need for conflict_flag, we could use // a smarter algorithm. We could use the 2D Face_circulator. // Should we just have this Face_circulator ? // Flag values : // 1 : incident cell already visited // 0 : unknown c->set_in_conflict_flag(1); *cells++ = c; for (int i=0; i<3; ++i) { if (c->vertex(i) == v) continue; Cell_handle next = c->neighbor(i); if (next->get_in_conflict_flag() != 0) continue; incident_cells_2(v, next, cells); } } public: template OutputIterator incident_cells(const Vertex_handle& v, OutputIterator cells) const { CGAL_triangulation_precondition( v != Vertex_handle() ); CGAL_triangulation_expensive_precondition( is_vertex(v) ); if ( dimension() < 2 ) return cells; std::vector tmp_cells; tmp_cells.reserve(64); if ( dimension() == 3 ) incident_cells_3(v, v->cell(), std::back_inserter(tmp_cells)); else incident_cells_2(v, v->cell(), std::back_inserter(tmp_cells)); for(typename std::vector::iterator cit = tmp_cells.begin(); cit != tmp_cells.end(); ++cit) { (*cit)->set_in_conflict_flag(0); *cells++ = *cit; } return cells; } template OutputIterator incident_vertices(const Vertex_handle& v, OutputIterator vertices) const { CGAL_triangulation_precondition( v != Vertex_handle() ); CGAL_triangulation_precondition( dimension() >= -1 ); CGAL_triangulation_expensive_precondition( is_vertex(v) ); CGAL_triangulation_expensive_precondition( is_valid() ); if (dimension() == -1) return vertices; if (dimension() == 0) { *vertices++ = v->cell()->neighbor(0)->vertex(0); return vertices; } if (dimension() == 1) { CGAL_triangulation_assertion( number_of_vertices() >= 3); Cell_handle n0 = v->cell(); Cell_handle n1 = n0->neighbor(1-n0->index(v)); *vertices++ = n0->vertex(1-n0->index(v)); *vertices++ = n1->vertex(1-n1->index(v)); return vertices; } // Get the incident cells. std::vector tmp_cells; tmp_cells.reserve(64); incident_cells(v, std::back_inserter(tmp_cells)); std::set tmp_vertices; for(typename std::vector::iterator cit = tmp_cells.begin(); cit != tmp_cells.end(); ++cit) { // Put all incident vertices in tmp_vertices. for (int j=0; j<=dimension(); ++j) if ((*cit)->vertex(j) != v) tmp_vertices.insert((*cit)->vertex(j)); } // Now output the vertices. return std::copy(tmp_vertices.begin(), tmp_vertices.end(), vertices); } size_type degree(const Vertex_handle& v) const; // CHECKING bool is_valid(bool verbose = false, int level = 0) const; // Helping functions Vertex_handle copy_tds(const Tds & tds, Vertex_handle vert = Vertex_handle() ); // returns the new vertex corresponding to vert in the new tds void swap(Tds & tds); void clear(); void set_adjacency(const Cell_handle& c0, int i0, const Cell_handle& c1, int i1) const { CGAL_triangulation_assertion(i0 >= 0 && i0 <= dimension()); CGAL_triangulation_assertion(i1 >= 0 && i1 <= dimension()); CGAL_triangulation_assertion(c0 != c1); c0->set_neighbor(i0,c1); c1->set_neighbor(i1,c0); } private: // Change the orientation of the cell by swapping indices 0 and 1. void change_orientation(const Cell_handle& c) const { Vertex_handle tmp_v = c->vertex(0); c->set_vertex(0, c->vertex(1)); c->set_vertex(1, tmp_v); Cell_handle tmp_c = c->neighbor(0); c->set_neighbor(0, c->neighbor(1)); c->set_neighbor(1, tmp_c); } // We need the const_cast<>s because TDS is not const-correct. Cell_container & cell_container() { return _cell_container; } Cell_container & cell_container() const { return const_cast(this)->_cell_container; } Vertex_container & vertex_container() {return _vertex_container;} Vertex_container & vertex_container() const { return const_cast(this)->_vertex_container; } // in dimension i, number of vertices >= i+2 // ( the boundary of a simplex in dimension i+1 has i+2 vertices ) int _dimension; Cell_container _cell_container; Vertex_container _vertex_container; // used by is-valid : bool count_vertices(size_type &i, bool verbose = false, int level = 0) const; // counts AND checks the validity bool count_facets(size_type &i, bool verbose = false, int level = 0) const; // counts but does not check bool count_edges(size_type &i, bool verbose = false, int level = 0) const; // counts but does not check bool count_cells(size_type &i, bool verbose = false, int level = 0) const; // counts AND checks the validity }; template typename Triangulation_data_structure_3::Cell_handle Triangulation_data_structure_3:: create_star_3(const Vertex_handle& v, const Cell_handle& c, int li, int prev_ind2) { CGAL_triangulation_precondition( dimension() == 3); CGAL_triangulation_precondition( c->get_in_conflict_flag() == 1); CGAL_triangulation_precondition( c->neighbor(li)->get_in_conflict_flag() != 1); Cell_handle cnew = create_cell(c->vertex(0), c->vertex(1), c->vertex(2), c->vertex(3)); cnew->set_vertex(li, v); const Cell_handle& c_li = c->neighbor(li); set_adjacency(cnew, li, c_li, c_li->index(c)); // Look for the other neighbors of cnew. for (int ii=0; ii<4; ++ii) { if (ii == prev_ind2 || cnew->neighbor(ii) != Cell_handle()) continue; cnew->vertex(ii)->set_cell(cnew); // Indices of the vertices of cnew such that ii,vj1,vj2,li positive. const Vertex_handle& vj1 = c->vertex(next_around_edge(ii, li)); const Vertex_handle& vj2 = c->vertex(next_around_edge(li, ii)); Cell_handle cur = c; int zz = ii; Cell_handle n = cur->neighbor(zz); // turn around the oriented edge vj1 vj2 while ( n->get_in_conflict_flag() == 1) { CGAL_triangulation_assertion( n != c ); cur = n; zz = next_around_edge(n->index(vj1), n->index(vj2)); n = cur->neighbor(zz); } // Now n is outside region, cur is inside. n->set_in_conflict_flag(0); // Reset the flag for boundary cells. int jj1 = n->index(vj1); int jj2 = n->index(vj2); const Vertex_handle& vvv = n->vertex(next_around_edge(jj1, jj2)); Cell_handle nnn = n->neighbor(next_around_edge(jj2, jj1)); int zzz = nnn->index(vvv); if (nnn == cur) { // Neighbor relation is reciprocal, ie // the cell we are looking for is not yet created. nnn = create_star_3(v, nnn, zz, zzz); } set_adjacency(nnn, zzz, cnew, ii); } return cnew; } template typename Triangulation_data_structure_3::Cell_handle Triangulation_data_structure_3:: create_star_2(const Vertex_handle& v, const Cell_handle& c, int li ) { CGAL_triangulation_assertion( dimension() == 2 ); Cell_handle cnew; // i1 i2 such that v,i1,i2 positive int i1=ccw(li); // traversal of the boundary of region in ccw order to create all // the new facets Cell_handle bound = c; Vertex_handle v1 = c->vertex(i1); int ind = c->neighbor(li)->index(c); // to be able to find the // first cell that will be created Cell_handle cur; Cell_handle pnew = Cell_handle(); do { cur = bound; // turn around v2 until we reach the boundary of region while ( cur->neighbor(cw(i1))->get_in_conflict_flag() == 1 ) { // neighbor in conflict cur = cur->neighbor(cw(i1)); i1 = cur->index( v1 ); } cur->neighbor(cw(i1))->set_in_conflict_flag(0); // here cur has an edge on the boundary of region cnew = create_face( v, v1, cur->vertex( ccw(i1) ) ); set_adjacency(cnew, 0, cur->neighbor(cw(i1)), cur->neighbor(cw(i1))->index(cur)); cnew->set_neighbor(1, Cell_handle()); cnew->set_neighbor(2, pnew); // pnew is null at the first iteration v1->set_cell(cnew); //pnew->set_neighbor( cw(pnew->index(v1)), cnew ); if (pnew != Cell_handle()) { pnew->set_neighbor( 1, cnew );} bound = cur; i1 = ccw(i1); v1 = bound->vertex(i1); pnew = cnew; //} while ( ( bound != c ) || ( li != cw(i1) ) ); } while ( v1 != c->vertex(ccw(li)) ); // missing neighbors between the first and the last created cells cur = c->neighbor(li)->neighbor(ind); // first created cell set_adjacency(cnew, 1, cur, 2); return cnew; } template < class Vb, class Cb> std::istream& operator>>(std::istream& is, Triangulation_data_structure_3& tds) // reads : // the dimension // the number of vertices // the number of cells // the cells by the indices of their vertices // the neighbors of each cell by their index in the preceding list of cells // when dimension < 3 : the same with faces of maximal dimension { typedef Triangulation_data_structure_3 Tds; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Cell_handle Cell_handle; tds.clear(); int n, d; is >> d >> n; tds.set_dimension(d); if(n == 0) return is; std::map< int, Vertex_handle > V; // creation of the vertices for (int i=0; i < n; i++) { // is >> p; // V[i] = tds.create_vertex(); // V[i]->set_point(p); V[i] = tds.create_vertex(); } std::map< int, Cell_handle > C; int m; tds.read_cells(is, V, m, C); CGAL_triangulation_assertion( tds.is_valid() ); return is; } template < class Vb, class Cb> std::ostream& operator<<(std::ostream& os, const Triangulation_data_structure_3 &tds) // writes : // the dimension // the number of vertices // the number of cells // the cells by the indices of their vertices // the neighbors of each cell by their index in the preceding list of cells // when dimension < 3 : the same with faces of maximal dimension { typedef Triangulation_data_structure_3 Tds; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Vertex_iterator Vertex_iterator; std::map V; // outputs dimension and number of vertices int n = tds.number_of_vertices(); if (is_ascii(os)) os << tds.dimension() << std::endl << n << std::endl; else os << tds.dimension() << n; if (n == 0) return os; // index the vertices int i = 0; for (Vertex_iterator it=tds.vertices_begin(); it != tds.vertices_end(); ++it) V[it] = i++; CGAL_triangulation_assertion( i == n ); tds.print_cells(os, V); return os; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_vertex(const Vertex_handle& v) const { Vertex_iterator vit = vertices_begin(); while (vit != vertices_end() && v != vit) ++vit; return v == vit; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_edge(const Vertex_handle& u, const Vertex_handle& v, Cell_handle &c, int &i, int &j) const // returns false when dimension <1 or when indices wrong { CGAL_triangulation_expensive_precondition( is_vertex(u) && is_vertex(v) ); if (u==v) return false; std::vector cells; cells.reserve(64); incident_cells(u, std::back_inserter(cells)); for (typename std::vector::iterator cit = cells.begin(); cit != cells.end(); ++cit) if ((*cit)->has_vertex(v, j)) { c = *cit; i = c->index(u); return true; } return false; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_edge(const Vertex_handle& u, const Vertex_handle& v) const { Cell_handle c; int i, j; return is_edge(u, v, c, i, j); } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_edge(const Cell_handle& c, int i, int j) const // returns false when dimension <1 { if ( i==j ) return false; if ( (i<0) || (j<0) ) return false; if ( (dimension() == 1) && ((i>1) || (j>1)) ) return false; if ( (dimension() == 2) && ((i>2) || (j>2)) ) return false; if ((i>3) || (j>3)) return false; for(Cell_iterator cit = cell_container().begin(); cit != cells_end(); ++cit) if (c == cit) return true; return false; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_facet(const Vertex_handle& u, const Vertex_handle& v, const Vertex_handle& w, Cell_handle & c, int & i, int & j, int & k) const // returns false when dimension <2 or when indices wrong { CGAL_triangulation_expensive_precondition( is_vertex(u) && is_vertex(v) && is_vertex(w) ); if ( u==v || u==w || v==w ) return false; if (dimension() < 2) return false; std::vector cells; cells.reserve(64); incident_cells(u, std::back_inserter(cells)); for (typename std::vector::iterator cit = cells.begin(); cit != cells.end(); ++cit) if ((*cit)->has_vertex(v, j) && (*cit)->has_vertex(w, k)) { c = *cit; i = c->index(u); return true; } return false; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_facet(const Cell_handle& c, int i) const // returns false when dimension <2 { CGAL_triangulation_precondition(i>=0 && i<4); if ( (dimension() == 2) && (i!=3) ) return false; Cell_iterator cit = cell_container().begin(); // needs to work in dim 2. while (cit != cells_end() && c != cit) ++cit; return c == cit; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_cell( const Cell_handle& c ) const // returns false when dimension <3 { if (dimension() < 3) return false; Cell_iterator cit = cells_begin(); while (cit != cells_end() && c != cit) ++cit; return c == cit; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_cell(const Vertex_handle& u, const Vertex_handle& v, const Vertex_handle& w, const Vertex_handle& t, Cell_handle & c, int & i, int & j, int & k, int & l) const // returns false when dimension <3 { CGAL_triangulation_expensive_precondition( is_vertex(u) && is_vertex(v) && is_vertex(w) && is_vertex(t) ); if ( u==v || u==w || u==t || v==w || v==t || w==t ) return false; std::vector cells; cells.reserve(64); incident_cells(u, std::back_inserter(cells)); for (typename std::vector::iterator cit = cells.begin(); cit != cells.end(); ++cit) if ((*cit)->has_vertex(v, j) && (*cit)->has_vertex(w, k) && (*cit)->has_vertex(t, l)) { c = *cit; i = c->index(u); return true; } return false; } template < class Vb, class Cb> bool Triangulation_data_structure_3:: is_cell(const Vertex_handle& u, const Vertex_handle& v, const Vertex_handle& w, const Vertex_handle& t) const // returns false when dimension <3 { Cell_handle c; int i, j, k, l; return is_cell(u, v, w, t, c, i, j, k, l); } template < class Vb, class Cb> inline bool Triangulation_data_structure_3:: has_vertex(const Cell_handle& c, int i, const Vertex_handle& v, int & j) const // computes the index j of the vertex in the cell c giving the query // facet (c,i) // j has no meaning if false is returned { CGAL_triangulation_precondition( dimension() == 3 ); return ( c->has_vertex(v,j) && (j != i) ); } template < class Vb, class Cb> inline bool Triangulation_data_structure_3:: has_vertex(const Cell_handle& c, int i, const Vertex_handle& v) const // checks whether the query facet (c,i) has vertex v { CGAL_triangulation_precondition( dimension() == 3 ); int j; return ( c->has_vertex(v,j) && (j != i) ); } template < class Vb, class Cb> inline bool Triangulation_data_structure_3:: has_vertex(const Facet & f, const Vertex_handle& v, int & j) const { return has_vertex(f.first, f.second, v, j); } template < class Vb, class Cb> inline bool Triangulation_data_structure_3:: has_vertex(const Facet & f, const Vertex_handle& v) const { return has_vertex(f.first, f.second, v); } template < class Vb, class Cb> bool Triangulation_data_structure_3:: are_equal(const Cell_handle& c, int i, const Cell_handle& n, int j) const // tests whether facets c,i and n,j, have the same 3 vertices // the triangulation is supposed to be valid, the orientation of the // facets is not checked here // the neighbor relations between c and n are not tested either, // which allows to use this method before setting these relations // (see remove in Delaunay_3) // if ( c->neighbor(i) != n ) return false; // if ( n->neighbor(j) != c ) return false; { CGAL_triangulation_precondition( dimension() == 3 ); if ( (c==n) && (i==j) ) return true; int j1,j2,j3; return( n->has_vertex( c->vertex((i+1)&3), j1 ) && n->has_vertex( c->vertex((i+2)&3), j2 ) && n->has_vertex( c->vertex((i+3)&3), j3 ) && ( j1+j2+j3+j == 6 ) ); } template < class Vb, class Cb> bool Triangulation_data_structure_3:: are_equal(const Facet & f, const Facet & g) const { return are_equal(f.first, f.second, g.first, g.second); } template < class Vb, class Cb> bool Triangulation_data_structure_3:: are_equal(const Facet & f, const Cell_handle& n, int j) const { return are_equal(f.first, f.second, n, j); } template < class Vb, class Cb> bool Triangulation_data_structure_3:: flip( const Cell_handle& c, int i ) // returns false if the facet is not flippable // true other wise and // flips facet i of cell c // c will be replaced by one of the new cells { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (number_of_vertices() > 6) ); CGAL_triangulation_expensive_precondition( is_cell(c) ); Cell_handle n = c->neighbor(i); int in = n->index(c); // checks that the facet is flippable, // ie the future edge does not already exist if (is_edge(c->vertex(i), n->vertex(in))) return false; flip_really(c,i,n,in); return true; } template < class Vb, class Cb> void Triangulation_data_structure_3:: flip_flippable(const Cell_handle& c, int i ) // flips facet i of cell c // c will be replaced by one of the new cells { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (number_of_vertices() > 6) ); CGAL_triangulation_expensive_precondition( is_cell(c) ); Cell_handle n = c->neighbor(i); int in = n->index(c); // checks that the facet is flippable, // ie the future edge does not already exist CGAL_triangulation_expensive_precondition( !is_edge(c->vertex(i), n->vertex(in))); flip_really(c,i,n,in); } template < class Vb, class Cb> inline void Triangulation_data_structure_3:: flip_really( const Cell_handle& c, int i, const Cell_handle& n, int in ) // private - used by flip and flip_flippable { int i1 = (i+1)&3; int i2 = (i+2)&3; int i3 = (i+3)&3; int in1 = n->index(c->vertex(i1)); int in2 = n->index(c->vertex(i2)); int in3 = n->index(c->vertex(i3)); set_adjacency(c, i, n->neighbor(in3), n->neighbor(in3)->index(n)); c->set_vertex( i3, n->vertex(in) ); set_adjacency(n, in, c->neighbor(i1), c->neighbor(i1)->index(c)); n->set_vertex( in1, c->vertex(i) ); Cell_handle cnew = create_cell(c->vertex(i), c->vertex(i1), n->vertex(in), n->vertex(in3)); set_adjacency(cnew, 0, n->neighbor(in2), n->neighbor(in2)->index(n)); set_adjacency(cnew, 1, n, in2); set_adjacency(cnew, 2, c->neighbor(i2), c->neighbor(i2)->index(c)); set_adjacency(cnew, 3, c, i2); set_adjacency(c, i1, n, in3); if ((i&1) != 0) change_orientation(cnew); c->vertex(i1)->set_cell(cnew); c->vertex(i2)->set_cell(c); n->vertex(in3)->set_cell(n); // to be implemented : 2d case // CGAL_triangulation_precondition( (0<=i) && (i<3) ); } template < class Vb, class Cb> bool Triangulation_data_structure_3:: flip( const Cell_handle& c, int i, int j ) // returns false if the edge is not flippable // true otherwise and // flips edge i,j of cell c // c will be deleted { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (0<=j) && (j<4) && ( i != j ) && (number_of_vertices() > 6) ); CGAL_triangulation_expensive_precondition( is_cell(c) ); // checks that the edge is flippable ie degree 3 int degree = 0; Cell_circulator ccir = incident_cells(c,i,j); Cell_circulator cdone = ccir; do { ++degree; ++ccir; } while ( ccir != cdone ); if ( degree != 3 ) return false; int next = next_around_edge(i,j); Cell_handle c1 = c->neighbor( next ); const Vertex_handle& v1 = c->vertex( next ); // will become vertex of c1 int i1 = c1->index( c->vertex(i) ); int j1 = c1->index( c->vertex(j) ); int next1 = next_around_edge(i1,j1); Cell_handle c2 = c1->neighbor( next1 ); const Vertex_handle& v2 = c1->vertex( next1 ); // will become vertex of c2 int i2 = c2->index( c->vertex(i) ); int j2 = c2->index( c->vertex(j) ); int next2 = next_around_edge(i2,j2); const Vertex_handle& v3 = c2->vertex( next2 ); // checks that the edge is flippable, // is the future cells do not already exist if ( is_cell(v1,v2,v3,c->vertex(i)) ) return false; if ( is_cell(v1,v2,v3,c->vertex(j)) ) return false; flip_really(c,i,j,c1,v1,i1,j1,next1,c2,v2,i2,j2,next2,v3); return true; } template < class Vb, class Cb> void Triangulation_data_structure_3:: flip_flippable( const Cell_handle& c, int i, int j ) // flips edge i,j of cell c // c will be deleted { CGAL_triangulation_precondition( (dimension() == 3) && (0<=i) && (i<4) && (0<=j) && (j<4) && ( i != j ) && (number_of_vertices() > 6) ); CGAL_triangulation_expensive_precondition( is_cell(c) ); // checks that the edge is flippable ie degree 3 CGAL_triangulation_precondition_code( int degree = 0; ); CGAL_triangulation_precondition_code ( Cell_circulator ccir = incident_cells(c,i,j); ); CGAL_triangulation_precondition_code( Cell_circulator cdone = ccir; ); CGAL_triangulation_precondition_code( do { ++degree; ++ccir; } while ( ccir != cdone ); ); CGAL_triangulation_precondition( degree == 3 ); int next = next_around_edge(i,j); Cell_handle c1 = c->neighbor( next ); const Vertex_handle& v1 = c->vertex( next ); // will become vertex of c1 int i1 = c1->index( c->vertex(i) ); int j1 = c1->index( c->vertex(j) ); int next1 = next_around_edge(i1,j1); Cell_handle c2 = c1->neighbor( next1 ); const Vertex_handle& v2 = c1->vertex( next1 ); // will become vertex of c2 int i2 = c2->index( c->vertex(i) ); int j2 = c2->index( c->vertex(j) ); int next2 = next_around_edge(i2,j2); const Vertex_handle& v3 = c2->vertex( next2 ); // checks that the edge is flippable, // is the future cells do not already exist CGAL_triangulation_expensive_precondition( !is_cell(v1,v2,v3,c->vertex(i)) ); CGAL_triangulation_expensive_precondition( !is_cell(v1,v2,v3,c->vertex(j)) ); flip_really(c,i,j,c1,v1,i1,j1,next1,c2,v2,i2,j2,next2,v3); } template < class Vb, class Cb> inline void Triangulation_data_structure_3:: flip_really( const Cell_handle& c, int i, int j, const Cell_handle& c1, const Vertex_handle& v1, int i1, int j1, int next1, const Cell_handle& c2, const Vertex_handle& v2, int i2, int j2, int next2, const Vertex_handle& v3 ) { c->vertex(i)->set_cell(c1); c->vertex(j)->set_cell(c2); c1->set_vertex( j1, v1 ); v1->set_cell(c1); c2->set_vertex( i2, v2 ); v2->set_cell(c2); set_adjacency(c1, next1,c2->neighbor(j2), c2->neighbor(j2)->index(c2)); set_adjacency(c2,c2->index(v1),c1->neighbor(i1),c1->neighbor(i1)->index(c1)); set_adjacency(c1, i1, c2, j2); set_adjacency(c1, 6-i1-j1-next1, c->neighbor(j), c->neighbor(j)->index(c)); set_adjacency(c2, next2, c->neighbor(i), c->neighbor(i)->index(c)); v3->set_cell( c2 ); delete_cell( c ); } template < class Vb, class Cb > void Triangulation_data_structure_3:: read_cells(std::istream& is, std::map< int, Vertex_handle > &V, int & m, std::map< int, Cell_handle > &C) { // creation of the cells and neighbors switch (dimension()) { case 3: case 2: case 1: { is >> m; for(int i = 0; i < m; i++) { Cell_handle c = create_cell(); for (int k=0; k<=dimension(); ++k) { int ik; is >> ik; c->set_vertex(k, V[ik]); V[ik]->set_cell(c); } C[i] = c; } for(int j = 0; j < m; j++) { Cell_handle c = C[j]; for (int k=0; k<=dimension(); ++k) { int ik; is >> ik; c->set_neighbor(k, C[ik]); } } break; } case 0: { m = 2; // CGAL_triangulation_assertion( n == 2 ); for (int i=0; i < 2; i++) { Cell_handle c = create_face(V[i], Vertex_handle(), Vertex_handle()); C[i] = c; V[i]->set_cell(c); } for (int j=0; j < 2; j++) { Cell_handle c = C[j]; c->set_neighbor(0, C[1-j]); } break; } case -1: { m = 1; // CGAL_triangulation_assertion( n == 1 ); Cell_handle c = create_face(V[0], Vertex_handle(), Vertex_handle()); C[0] = c; V[0]->set_cell(c); break; } } } template < class Vb, class Cb> void Triangulation_data_structure_3:: print_cells(std::ostream& os, const std::map &V ) const { std::map C; int i = 0; switch ( dimension() ) { case 3: { int m = number_of_cells(); os << m; if(is_ascii(os)) os << std::endl; // write the cells Cell_iterator it; for(it = cells_begin(); it != cells_end(); ++it) { C[it] = i++; for(int j = 0; j < 4; j++){ os << V.find(it->vertex(j))->second; if(is_ascii(os)) { if ( j==3 ) os << std::endl; else os << ' '; } } } CGAL_triangulation_assertion( i == m ); // write the neighbors for(it = cells_begin(); it != cells_end(); ++it) { for (int j = 0; j < 4; j++) { os << C[it->neighbor(j)]; if(is_ascii(os)){ if(j==3) os << std::endl; else os << ' '; } } } break; } case 2: { int m = number_of_facets(); os << m; if(is_ascii(os)) os << std::endl; // write the facets Facet_iterator it; for(it = facets_begin(); it != facets_end(); ++it) { C[(*it).first] = i++; for(int j = 0; j < 3; j++){ os << V.find((*it).first->vertex(j))->second; if(is_ascii(os)) { if ( j==2 ) os << std::endl; else os << ' '; } } } CGAL_triangulation_assertion( i == m ); // write the neighbors for(it = facets_begin(); it != facets_end(); ++it) { for (int j = 0; j < 3; j++) { os << C[(*it).first->neighbor(j)]; if(is_ascii(os)){ if(j==2) os << std::endl; else os << ' '; } } } break; } case 1: { int m = number_of_edges(); os << m; if(is_ascii(os)) os << std::endl; // write the edges Edge_iterator it; for(it = edges_begin(); it != edges_end(); ++it) { C[(*it).first] = i++; for(int j = 0; j < 2; j++){ os << V.find((*it).first->vertex(j))->second; if(is_ascii(os)) { if ( j==1 ) os << std::endl; else os << ' '; } } } CGAL_triangulation_assertion( i == m ); // write the neighbors for(it = edges_begin(); it != edges_end(); ++it) { for (int j = 0; j < 2; j++) { os << C[(*it).first->neighbor(j)]; if(is_ascii(os)){ if(j==1) os << std::endl; else os << ' '; } } } break; } } } template typename Triangulation_data_structure_3::Vertex_handle Triangulation_data_structure_3:: insert_in_cell(const Cell_handle& c) { CGAL_triangulation_precondition( dimension() == 3 ); CGAL_triangulation_precondition( c != Cell_handle() ); CGAL_triangulation_expensive_precondition( is_cell(c) ); Vertex_handle v = create_vertex(); Vertex_handle v0 = c->vertex(0); Vertex_handle v1 = c->vertex(1); Vertex_handle v2 = c->vertex(2); Vertex_handle v3 = c->vertex(3); Cell_handle n1 = c->neighbor(1); Cell_handle n2 = c->neighbor(2); Cell_handle n3 = c->neighbor(3); // c will be modified to have v,v1,v2,v3 as vertices Cell_handle c3 = create_cell(v0,v1,v2,v); Cell_handle c2 = create_cell(v0,v1,v,v3); Cell_handle c1 = create_cell(v0,v,v2,v3); set_adjacency(c3, 0, c, 3); set_adjacency(c2, 0, c, 2); set_adjacency(c1, 0, c, 1); set_adjacency(c2, 3, c3, 2); set_adjacency(c1, 3, c3, 1); set_adjacency(c1, 2, c2, 1); set_adjacency(n1, n1->index(c), c1, 1); set_adjacency(n2, n2->index(c), c2, 2); set_adjacency(n3, n3->index(c), c3, 3); c->set_vertex(0,v); v0->set_cell(c1); v->set_cell(c); return v; } template typename Triangulation_data_structure_3::Vertex_handle Triangulation_data_structure_3:: insert_in_facet(const Cell_handle& c, int i) { // inserts v in the facet opposite to vertex i of cell c CGAL_triangulation_precondition( c != Cell_handle() ); CGAL_triangulation_precondition( dimension() >= 2 ); Vertex_handle v = create_vertex(); switch ( dimension() ) { case 3: { CGAL_triangulation_expensive_precondition( is_cell(c) ); CGAL_triangulation_precondition( i == 0 || i == 1 || i == 2 || i == 3 ); // c will be modified to have v replacing vertex(i+3) int i1,i2,i3; if ( (i&1) == 0 ) { i1=(i+1)&3; i2=(i+2)&3; i3=6-i-i1-i2; } else { i1=(i+1)&3; i2=(i+3)&3; i3=6-i-i1-i2; } // i,i1,i2,i3 is well oriented // so v will "replace" the vertices in this order // when creating the new cells one after another from c Vertex_handle vi=c->vertex(i); Vertex_handle v1=c->vertex(i1); Vertex_handle v2=c->vertex(i2); Vertex_handle v3=c->vertex(i3); // new cell with v in place of i1 Cell_handle nc = c->neighbor(i1); Cell_handle cnew1 = create_cell(vi,v,v2,v3); set_adjacency(cnew1, 1, nc, nc->index(c)); set_adjacency(cnew1, 3, c, i1); v3->set_cell(cnew1); // new cell with v in place of i2 nc = c->neighbor(i2); Cell_handle cnew2 = create_cell(vi,v1,v,v3); set_adjacency(cnew2, 2, nc, nc->index(c)); set_adjacency(cnew2, 3, c, i2); set_adjacency(cnew1, 2, cnew2, 1); // v replaces i3 in c c->set_vertex(i3,v); // other side of facet containing v Cell_handle d = c->neighbor(i); int j = d->index(c); int j1=d->index(v1);// triangulation supposed to be valid int j2=d->index(v2); int j3=6-j-j1-j2; // then the orientation of j,j1,j2,j3 depends on the parity // of i-j // new cell with v in place of j1 Cell_handle nd = d->neighbor(j1); Cell_handle dnew1 = create_cell(d->vertex(j),v,v3,v2); set_adjacency(dnew1, 1, nd, nd->index(d)); set_adjacency(dnew1, 2, d, j1); set_adjacency(dnew1, 0, cnew1, 0); // new cell with v in place of j2 nd = d->neighbor(j2); Cell_handle dnew2 = create_cell(d->vertex(j),v1,v3,v); set_adjacency(dnew2, 3, nd, nd->index(d)); set_adjacency(dnew2, 2, d, j2); set_adjacency(dnew2, 0, cnew2, 0); set_adjacency(dnew1, 3, dnew2, 1); // v replaces i3 in d d->set_vertex(j3,v); v->set_cell(d); break; } case 2: { CGAL_triangulation_expensive_precondition( is_facet(c,i) ); Cell_handle n = c->neighbor(2); Cell_handle cnew = create_face(c->vertex(0),c->vertex(1),v); set_adjacency(cnew, 2, n, n->index(c)); set_adjacency(cnew, 0, c, 2); c->vertex(0)->set_cell(cnew); n = c->neighbor(1); Cell_handle dnew = create_face(c->vertex(0),v,c->vertex(2)); set_adjacency(dnew, 1, n, n->index(c)); set_adjacency(dnew, 0, c, 1); set_adjacency(dnew, 2, cnew, 1); c->set_vertex(0,v); v->set_cell(c); break; } } return v; } template typename Triangulation_data_structure_3::Vertex_handle Triangulation_data_structure_3:: insert_in_edge(const Cell_handle& c, int i, int j) // inserts a vertex in the edge of cell c with vertices i and j { CGAL_triangulation_precondition( c != Cell_handle() ); CGAL_triangulation_precondition( i != j ); CGAL_triangulation_precondition( dimension() >= 1 ); switch ( dimension() ) { case 3: { CGAL_triangulation_expensive_precondition( is_cell(c) ); CGAL_triangulation_precondition( i>=0 && i<=3 && j>=0 && j<=3 ); std::vector cells; cells.reserve(32); Cell_circulator ccir = incident_cells(c, i, j); do { Cell_handle cc = ccir; cells.push_back(cc); cc->set_in_conflict_flag(1); ++ccir; } while (c != ccir); return _insert_in_hole(cells.begin(), cells.end(), c, i); } case 2: { CGAL_triangulation_expensive_precondition( is_edge(c,i,j) ); Vertex_handle v = create_vertex(); int k=3-i-j; // index of the third vertex of the facet Cell_handle d = c->neighbor(k); int kd = d->index(c); int id = d->index(c->vertex(i)); int jd = d->index(c->vertex(j)); Cell_handle cnew = create_cell(); cnew->set_vertex(i,c->vertex(i)); c->vertex(i)->set_cell(cnew); cnew->set_vertex(j,v); cnew->set_vertex(k,c->vertex(k)); c->set_vertex(i,v); Cell_handle dnew = create_cell(); dnew->set_vertex(id,d->vertex(id)); // d->vertex(id)->cell() is cnew OK dnew->set_vertex(jd,v); dnew->set_vertex(kd,d->vertex(kd)); d->set_vertex(id,v); Cell_handle nj = c->neighbor(j); set_adjacency(cnew, i, c, j); set_adjacency(cnew, j, nj, nj->index(c)); nj = d->neighbor(jd); set_adjacency(dnew, id, d, jd); set_adjacency(dnew, jd, nj, nj->index(d)); set_adjacency(cnew, k, dnew, kd); v->set_cell(cnew); return v; } default: // case 1: { Vertex_handle v = create_vertex(); CGAL_triangulation_expensive_precondition( is_edge(c,i,j) ); Cell_handle cnew = create_face(v, c->vertex(1), Vertex_handle()); c->vertex(1)->set_cell(cnew); c->set_vertex(1,v); set_adjacency(cnew, 0, c->neighbor(0), 1); set_adjacency(cnew, 1, c, 0); v->set_cell(cnew); return v; } } } template typename Triangulation_data_structure_3::Vertex_handle Triangulation_data_structure_3:: insert_increase_dimension(Vertex_handle star) // star = vertex from which we triangulate the facet of the // incremented dimension // ( geometrically : star = infinite vertex ) // = NULL only used to insert the 1st vertex (dimension -2 to dimension -1) // changes the dimension { CGAL_triangulation_precondition( dimension() < 3); Vertex_handle v = create_vertex(); int dim = dimension(); if (dim != -2) { CGAL_triangulation_precondition( star != Vertex_handle() ); // In this case, this precondition is not relatively expensive. CGAL_triangulation_precondition( is_vertex(star) ); } // this is set now, so that it becomes allowed to reorient // new facets or cells by iterating on them (otherwise the // dimension is too small) set_dimension( dimension()+1 ); switch ( dim ) { case -2: // insertion of the first vertex // ( geometrically : infinite vertex ) { Cell_handle c = create_face(v, Vertex_handle(), Vertex_handle()); v->set_cell(c); break; } case -1: // insertion of the second vertex // ( geometrically : first finite vertex ) { Cell_handle d = create_face(v, Vertex_handle(), Vertex_handle()); v->set_cell(d); set_adjacency(d, 0, star->cell(), 0); break; } case 0: // insertion of the third vertex // ( geometrically : second finite vertex ) { Cell_handle c = star->cell(); Cell_handle d = c->neighbor(0); c->set_vertex(1,d->vertex(0)); d->set_vertex(1,v); d->set_neighbor(1,c); Cell_handle e = create_face( v, star, Vertex_handle() ); set_adjacency(e, 0, c, 1); set_adjacency(e, 1, d, 0); v->set_cell(d); break; } case 1: // general case : 4th vertex ( geometrically : 3rd finite vertex ) // degenerate cases geometrically : 1st non collinear vertex { Cell_handle c = star->cell(); int i = c->index(star); // i== 0 or 1 int j = (1-i); Cell_handle d = c->neighbor(j); c->set_vertex(2,v); Cell_handle e = c->neighbor(i); Cell_handle cnew = c; Cell_handle enew = Cell_handle(); while( e != d ){ enew = create_cell(); enew->set_vertex(i,e->vertex(j)); enew->set_vertex(j,e->vertex(i)); enew->set_vertex(2,star); set_adjacency(enew, i, cnew, j); // false at the first iteration of the loop where it should // be neighbor 2 // it is corrected after the loop set_adjacency(enew, 2, e, 2); // neighbor j will be set during next iteration of the loop e->set_vertex(2,v); e = e->neighbor(i); cnew = enew; } d->set_vertex(2,v); set_adjacency(enew, j, d, 2); // corrections for star->cell() : c = star->cell(); c->set_neighbor(2,c->neighbor(i)->neighbor(2)); c->set_neighbor(j,d); v->set_cell(d); break; } case 2: // general case : 5th vertex ( geometrically : 4th finite vertex ) // degenerate cases : geometrically 1st non coplanar vertex { // used to store the new cells, in order to be able to traverse only // them to find the missing neighbors. std::vector new_cells; new_cells.reserve(16); Cell_iterator it = cells_begin(); // allowed since the dimension has already been set to 3 v->set_cell(it); // ok since there is at least one ``cell'' for(; it != cells_end(); ++it) { // Here we must be careful since we create_cells in a loop controlled // by an iterator. So we first take care of the cells newly created // by the following test : if (it->neighbor(0) == Cell_handle()) continue; it->set_neighbor(3, Cell_handle()); it->set_vertex(3, v); if ( ! it->has_vertex(star) ) { Cell_handle cnew = create_cell( it->vertex(0), it->vertex(2), it->vertex(1), star); // The Intel compiler has a problem with passing "it" directly to // function "set_adjacency": the adjacency is not changed. Cell_handle ch_it = it; set_adjacency(cnew, 3, ch_it, 3); cnew->set_neighbor(0, Cell_handle()); new_cells.push_back(cnew); } } // traversal of the new cells only, to add missing neighbors for(typename std::vector::iterator ncit = new_cells.begin(); ncit != new_cells.end(); ++ncit) { Cell_handle n = (*ncit)->neighbor(3); // opposite to star for ( int i=0; i<3; i++ ) { int j; if ( i==0 ) j=0; else j=3-i; // vertex 1 and vertex 2 are always switched when // creating a new cell (see above) Cell_handle c = n->neighbor(i)->neighbor(3); if ( c != Cell_handle() ) { // i.e. star is not a vertex of n->neighbor(i) (*ncit)->set_neighbor(j, c); // opposite relation will be set when ncit arrives on c // this avoids to look for the correct index // and to test whether *ncit already has neighbor i } else { // star is a vertex of n->neighbor(i) set_adjacency(*ncit, j, n->neighbor(i), 3);//neighbor opposite to v } } } } }// end switch return v; } template void Triangulation_data_structure_3:: remove_decrease_dimension(const Vertex_handle& v) { CGAL_triangulation_expensive_precondition( is_valid() ); CGAL_triangulation_precondition( dimension() >= -1 ); CGAL_triangulation_precondition( dimension() != 1 || number_of_vertices() == 3); CGAL_triangulation_precondition( number_of_vertices() > (size_type) dimension() + 1 ); CGAL_triangulation_precondition( degree(v) == number_of_vertices()-1 ); if (dimension() <= 0) { delete_cell(v->cell()); } else { // the cells incident to v are down graded one dimension // the other cells are deleted std::vector to_delete, to_downgrade; for (Cell_iterator ib = cell_container().begin(); ib != cell_container().end(); ++ib) { if ( ib->has_vertex(v) ) to_downgrade.push_back(ib); else to_delete.push_back(ib); } typename std::vector::iterator lfit=to_downgrade.begin(); for( ; lfit != to_downgrade.end(); ++lfit) { Cell_handle f = *lfit; int j = f->index(v); if (j != dimension()) { f->set_vertex(j, f->vertex(dimension())); f->set_neighbor(j, f->neighbor(dimension())); if (dimension() >= 1) change_orientation(f); } f->set_vertex(dimension(), Vertex_handle()); f->set_neighbor(dimension(), Cell_handle()); // Update vertex->cell() pointers. for (int i = 0; i < dimension(); ++i) f->vertex(i)->set_cell(f); } delete_cells(to_delete.begin(), to_delete.end()); } delete_vertex(v); set_dimension(dimension()-1); CGAL_triangulation_postcondition(is_valid()); } template typename Triangulation_data_structure_3::Cell_handle Triangulation_data_structure_3:: remove_from_maximal_dimension_simplex(const Vertex_handle& v) { CGAL_triangulation_precondition(dimension() >= 1); CGAL_triangulation_precondition(degree(v) == (size_type) dimension() + 1); CGAL_triangulation_precondition(number_of_vertices() > (size_type) dimension() + 1); if (number_of_vertices() == (size_type) dimension() + 2) { remove_decrease_dimension(v); return Cell_handle(); } if (dimension() == 3) return remove_degree_4(v); if (dimension() == 2) return remove_degree_3(v); // dimension() == 1 return remove_degree_2(v); } template typename Triangulation_data_structure_3::Cell_handle Triangulation_data_structure_3:: remove_degree_2(const Vertex_handle& v) { CGAL_triangulation_precondition(dimension() == 1); CGAL_triangulation_precondition(degree(v) == 2); CGAL_triangulation_precondition(number_of_vertices() >= 4); // Cells to be killed. Cell_handle c0, c1; // Indices of v in these cells. int i0, i1; c0 = v->cell(); i0 = c0->index(v); c1 = c0->neighbor(1-i0); i1 = c1->index(v); // New cell : we copy the content of c0, so we keep the orientation. Cell_handle newc = create_face(c0->vertex(0), c0->vertex(1), Vertex_handle()); newc->set_vertex(i0, c1->vertex(c1->index(c0))); set_adjacency(newc, i0, c0->neighbor(i0), c0->mirror_index(i0)); set_adjacency(newc, 1-i0, c1->neighbor(i1), c1->mirror_index(i1)); newc->vertex(0)->set_cell(newc); newc->vertex(1)->set_cell(newc); delete_cell(c0); delete_cell(c1); delete_vertex(v); return newc; } template typename Triangulation_data_structure_3::Cell_handle Triangulation_data_structure_3:: remove_degree_3(const Vertex_handle& v) { CGAL_triangulation_precondition(dimension() == 2); CGAL_triangulation_precondition(degree(v) == 3); CGAL_triangulation_precondition(number_of_vertices() >= 5); // Cells to be killed. Cell_handle c0, c1, c2; // Indices of v in these cells. int i0, i1, i2; c0 = v->cell(); i0 = c0->index(v); c1 = c0->neighbor(cw(i0)); i1 = c1->index(v); c2 = c0->neighbor(ccw(i0)); i2 = c2->index(v); // New cell : we copy the content of c0, so we keep the orientation. Cell_handle newc = create_face(c0->vertex(0), c0->vertex(1), c0->vertex(2)); newc->set_vertex(i0, c1->vertex(c1->index(c0))); set_adjacency(newc, i0, c0->neighbor(i0), c0->mirror_index(i0)); set_adjacency(newc, cw(i0), c1->neighbor(i1), c1->mirror_index(i1)); set_adjacency(newc, ccw(i0), c2->neighbor(i2), c2->mirror_index(i2)); newc->vertex(0)->set_cell(newc); newc->vertex(1)->set_cell(newc); newc->vertex(2)->set_cell(newc); delete_cell(c0); delete_cell(c1); delete_cell(c2); delete_vertex(v); return newc; } template typename Triangulation_data_structure_3::Cell_handle Triangulation_data_structure_3:: remove_degree_4(const Vertex_handle& v) { CGAL_triangulation_precondition(dimension() == 3); CGAL_triangulation_precondition(degree(v) == 4); CGAL_triangulation_precondition(number_of_vertices() >= 6); // Cells to be killed. Cell_handle c0, c1, c2, c3; // Indices of v in these cells. int i0, i1, i2, i3; c0 = v->cell(); i0 = c0->index(v); c1 = c0->neighbor(i0^1); i1 = c1->index(v); c2 = c0->neighbor(i0^2); i2 = c2->index(v); c3 = c0->neighbor(i0^3); i3 = c3->index(v); // New cell : we copy the content of c0, so we keep the orientation. Cell_handle newc = create_cell(c0->vertex(0), c0->vertex(1), c0->vertex(2), c0->vertex(3)); newc->set_vertex(i0, c1->vertex(c1->index(c0))); set_adjacency(newc, i0, c0->neighbor(i0), c0->mirror_index(i0)); set_adjacency(newc, i0^1, c1->neighbor(i1), c1->mirror_index(i1)); set_adjacency(newc, i0^2, c2->neighbor(i2), c2->mirror_index(i2)); set_adjacency(newc, i0^3, c3->neighbor(i3), c3->mirror_index(i3)); newc->vertex(0)->set_cell(newc); newc->vertex(1)->set_cell(newc); newc->vertex(2)->set_cell(newc); newc->vertex(3)->set_cell(newc); delete_cell(c0); delete_cell(c1); delete_cell(c2); delete_cell(c3); delete_vertex(v); return newc; } template typename Triangulation_data_structure_3::size_type Triangulation_data_structure_3:: degree(const Vertex_handle& v) const { Counting_output_iterator cnt; return (int) incident_vertices(v, cnt).current_counter(); } template bool Triangulation_data_structure_3:: is_valid(bool verbose, int level ) const { switch ( dimension() ) { case 3: { size_type vertex_count; if ( ! count_vertices(vertex_count,verbose,level) ) return false; if ( number_of_vertices() != vertex_count ) { if (verbose) std::cerr << "wrong number of vertices" << std::endl; CGAL_triangulation_assertion(false); return false; } size_type cell_count; if ( ! count_cells(cell_count,verbose,level) ) return false; size_type edge_count; if ( ! count_edges(edge_count,verbose,level) ) return false; size_type facet_count; if ( ! count_facets(facet_count,verbose,level) ) return false; // Euler relation if ( cell_count - facet_count + edge_count - vertex_count != 0 ) { if (verbose) std::cerr << "Euler relation unsatisfied" << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 2: { size_type vertex_count; if ( ! count_vertices(vertex_count,verbose,level) ) return false; if ( number_of_vertices() != vertex_count ) { if (verbose) std::cerr << "false number of vertices" << std::endl; CGAL_triangulation_assertion(false); return false; } size_type edge_count; if ( ! count_edges(edge_count,verbose,level) ) return false; // Euler for edges if ( edge_count != 3 * vertex_count - 6 ) { if (verbose) std::cerr << "Euler relation unsatisfied - edges/vertices" << std::endl; CGAL_triangulation_assertion(false); return false; } size_type facet_count; if ( ! count_facets(facet_count,verbose,level) ) return false; // Euler for facets if ( facet_count != 2 * vertex_count - 4 ) { if (verbose) std::cerr << "Euler relation unsatisfied - facets/vertices" << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 1: { size_type vertex_count; if ( ! count_vertices(vertex_count,verbose,level) ) return false; if ( number_of_vertices() != vertex_count ) { if (verbose) std::cerr << "false number of vertices" << std::endl; CGAL_triangulation_assertion(false); return false; } size_type edge_count; if ( ! count_edges(edge_count,verbose,level) ) return false; // Euler for edges if ( edge_count != vertex_count ) { if (verbose) std::cerr << "false number of edges" << std::endl; CGAL_triangulation_assertion(false); return false; } break; } case 0: { if ( number_of_vertices() < 2 ) { if (verbose) std::cerr << "less than 2 vertices but dimension 0" << std::endl; CGAL_triangulation_assertion(false); return false; } // no break; continue } case -1: { if ( number_of_vertices() < 1 ) { if (verbose) std::cerr << "no vertex but dimension -1" << std::endl; CGAL_triangulation_assertion(false); return false; } // vertex count size_type vertex_count; if ( ! count_vertices(vertex_count,verbose,level) ) return false; if ( number_of_vertices() != vertex_count ) { if (verbose) std::cerr << "false number of vertices" << std::endl; CGAL_triangulation_assertion(false); return false; } } } // end switch if (verbose) std::cerr << "valid data structure" << std::endl; return true; } template typename Triangulation_data_structure_3::Vertex_handle Triangulation_data_structure_3:: copy_tds(const Tds & tds, Vertex_handle vert ) // returns the new vertex corresponding to vert in the new tds { CGAL_triangulation_expensive_precondition( vert == Vertex_handle() || tds.is_vertex(vert) ); clear(); int n = tds.number_of_vertices(); set_dimension(tds.dimension()); // Number of pointers to cell/vertex to copy per cell. int dim = std::max(1, dimension() + 1); if (n == 0) return vert; // Create the vertices. std::vector TV(n); int i = 0; for (Vertex_iterator vit = tds.vertices_begin(); vit != tds.vertices_end(); ++vit) TV[i++] = vit; CGAL_triangulation_assertion( i == n ); std::map< Vertex_handle, Vertex_handle > V; std::map< Cell_handle, Cell_handle > F; for (i=0; i <= n-1; ++i) V[ TV[i] ] = create_vertex(TV[i]); // Create the cells. for (Cell_iterator cit = tds.cell_container().begin(); cit != tds.cells_end(); ++cit) { F[cit] = create_cell(cit); for (int j = 0; j < dim; j++) F[cit]->set_vertex(j, V[cit->vertex(j)] ); } // Link the vertices to a cell. for (Vertex_iterator vit2 = tds.vertices_begin(); vit2 != tds.vertices_end(); ++vit2) V[vit2]->set_cell( F[vit2->cell()] ); // Hook neighbor pointers of the cells. for (Cell_iterator cit2 = tds.cell_container().begin(); cit2 != tds.cells_end(); ++cit2) { for (int j = 0; j < dim; j++) F[cit2]->set_neighbor(j, F[cit2->neighbor(j)] ); } CGAL_triangulation_postcondition( is_valid() ); return (vert != Vertex_handle()) ? V[vert] : vert; } template void Triangulation_data_structure_3:: swap(Tds & tds) { CGAL_triangulation_expensive_precondition(tds.is_valid() && is_valid()); std::swap(_dimension, tds._dimension); cell_container().swap(tds.cell_container()); vertex_container().swap(tds.vertex_container()); } template void Triangulation_data_structure_3:: clear() { cell_container().clear(); vertex_container().clear(); set_dimension(-2); } template bool Triangulation_data_structure_3:: count_vertices(size_type & i, bool verbose, int level) const // counts AND checks the validity { i = 0; for (Vertex_iterator it = vertices_begin(); it != vertices_end(); ++it) { if ( ! it->is_valid(verbose,level) ) { if (verbose) std::cerr << "invalid vertex" << std::endl; CGAL_triangulation_assertion(false); return false; } ++i; } return true; } template bool Triangulation_data_structure_3:: count_facets(size_type & i, bool verbose, int level) const // counts but does not check { i = 0; for (Facet_iterator it = facets_begin(); it != facets_end(); ++it) { if ( ! (*it).first->is_valid(dimension(),verbose, level) ) { if (verbose) std::cerr << "invalid facet" << std::endl; CGAL_triangulation_assertion(false); return false; } ++i; } return true; } template bool Triangulation_data_structure_3:: count_edges(size_type & i, bool verbose, int level) const // counts but does not check { i = 0; for (Edge_iterator it = edges_begin(); it != edges_end(); ++it) { if ( ! (*it).first->is_valid(dimension(),verbose, level) ) { if (verbose) std::cerr << "invalid edge" << std::endl; CGAL_triangulation_assertion(false); return false; } ++i; } return true; } template bool Triangulation_data_structure_3:: count_cells(size_type & i, bool verbose, int level) const // counts AND checks the validity { i = 0; for (Cell_iterator it = cells_begin(); it != cells_end(); ++it) { if ( ! it->is_valid(dimension(),verbose, level) ) { if (verbose) std::cerr << "invalid cell" << std::endl; CGAL_triangulation_assertion(false); return false; } ++i; } return true; } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DATA_STRUCTURE_3_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_iterator_adaptator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_iterator0000644000175000017500000000356111344301501031502 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_iterator_adaptator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec // Menelaos Karavelas #ifndef CGAL_TRIANGULATION_ITERATOR_ADAPTATOR_H #define CGAL_TRIANGULATION_ITERATOR_ADAPTATOR_H #include #include CGAL_BEGIN_NAMESPACE template struct Triangulation_iterator_handle_adaptor : public Base { typedef Triangulation_iterator_handle_adaptor Self; Triangulation_iterator_handle_adaptor() : Base() {} Triangulation_iterator_handle_adaptor(const Base & b) : Base(b) {} // MK: added this to satisfy the mips_CC-7.40 compiler Self& operator=(const Self& other) { static_cast(*this) = static_cast(other); return *this; } operator Handle() const {return Base::base();} Self& operator++() { Base::operator++(); return *this;} Self& operator--() { Base::operator--(); return *this;} Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } }; CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_ITERATOR_ADAPTATOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Twotuple.h0000644000175000017500000000254511344301501027023 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Twotuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL__TWOTUPLE_H #define CGAL__TWOTUPLE_H CGAL_BEGIN_NAMESPACE template < class T > class Twotuple { public: T e0; T e1; Twotuple() {} Twotuple(const T & a0, const T &a1) : e0(a0), e1(a1) {} }; CGAL_END_NAMESPACE #endif // CGAL__TWOTUPLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_point.h0000644000175000017500000000427411344301501030152 0ustar debiandebian// Copyright (c) 1999-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Weighted_point.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec // Sylvain Pion #ifndef CGAL_WEIGHTED_POINT_H #define CGAL_WEIGHTED_POINT_H CGAL_BEGIN_NAMESPACE template < class Pt, class We > class Weighted_point : public Pt { public: typedef We Weight; typedef Pt Point; Weighted_point () : Point(), _weight(0) {} //explicit Weighted_point (const Point &p) : Point(p), _weight(0) { //abort(); //std::cerr << "Warning : truncated weight !!!" << std::endl; } Weighted_point (const Point &p, const Weight &w) : Point(p), _weight(w) {} const Point & point() const { return *this; } const Weight & weight() const { return _weight; } // The following power() member functions are not used at the moment. // They belong to the traits class anyway. // // Weight power(const Point &p) // { // return squared_distance(*this, p) - weight(); // } // // Weight power(const Weighted_point &p) // { // return squared_distance(*this, p) - weight() - p.weight(); // } private: Weight _weight; }; template < class Point, class Weight > std::ostream & operator<<(std::ostream &os, const Weighted_point &p) { return os << p.point() << " " << p.weight(); } template < class Point, class Weight > std::istream & operator>>(std::istream &is, Weighted_point &wp) { Weight w; Point p; is >> p >> w; if (is) wp = Weighted_point(p,w); return is; } CGAL_END_NAMESPACE #endif // CGAL_WEIGHTED_POINT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/bbox_intersection_3.h0000644000175000017500000000300711344301500031133 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/bbox_intersection_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_BBOX_INTERSECTION_3_H #define CGAL_BBOX_INTERSECTION_3_H #include #include CGAL_BEGIN_NAMESPACE Object intersection_bl(const Bbox_3 &box, double lx1, double ly1, double lz1, double lx2, double ly2, double lz2, bool min_infinite, bool max_infinite); CGAL_END_NAMESPACE #endif // CGAL_BBOX_INTERSECTION_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Segment_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Segment_2_inters0000644000175000017500000002402611344301500031212 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Segment_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_RAY_2_SEGMENT_2_INTERSECTION_H #define CGAL_RAY_2_SEGMENT_2_INTERSECTION_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Ray_2_Segment_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Ray_2_Segment_2_pair() ; Ray_2_Segment_2_pair(typename K::Ray_2 const *ray, typename K::Segment_2 const *line); ~Ray_2_Segment_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: typename K::Ray_2 const * _ray; typename K::Segment_2 const * _seg; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point, _other_point; }; template inline bool do_intersect(const typename CGAL_WRAP(K)::Ray_2 &p1, const typename CGAL_WRAP(K)::Segment_2 &p2, const K& k) { typedef Ray_2_Segment_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Segment_2 &p2, const typename CGAL_WRAP(K)::Ray_2 &p1, const K& k) { return CGALi::do_intersect(p1, p2, k); } template Ray_2_Segment_2_pair::Ray_2_Segment_2_pair() { _ray = 0; _seg = 0; _known = false; } template Ray_2_Segment_2_pair::Ray_2_Segment_2_pair( typename K::Ray_2 const *ray, typename K::Segment_2 const *seg) { _ray = ray; _seg = seg; _known = false; } template typename Ray_2_Segment_2_pair::Intersection_results Ray_2_Segment_2_pair::intersection_type() const { if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; // if (!do_overlap(_ray->bbox(), _seg->bbox())) // return NO; const typename K::Line_2 &l1 = _ray->supporting_line(); const typename K::Line_2 &l2 = _seg->supporting_line(); Line_2_Line_2_pair linepair(&l1, &l2); switch ( linepair.intersection_type()) { case Line_2_Line_2_pair::NO: _result = NO; return _result; case Line_2_Line_2_pair::POINT: linepair.intersection(_intersection_point); _result = (_ray->collinear_has_on(_intersection_point) && _seg->collinear_has_on(_intersection_point) ) ? POINT : NO; return _result; case Line_2_Line_2_pair::LINE: { typedef typename K::RT RT; const typename K::Point_2 &start1 = _seg->source(); const typename K::Point_2 &end1 = _seg->target(); const typename K::Point_2 &start2 = _ray->source(); const typename K::Point_2 *minpt, *maxpt; typename K::Vector_2 diff1 = end1-start1; if (CGAL_NTS abs(diff1.x()) > CGAL_NTS abs(diff1.y())) { typedef typename K::FT FT; if (start1.x() < end1.x()) { minpt = &start1; maxpt = &end1; } else { minpt = &end1; maxpt = &start1; } if (_ray->direction().to_vector().x() > FT(0)) { if (maxpt->x() < start2.x()) { _result = NO; return _result; } if (maxpt->x() == start2.x()) { _intersection_point = *maxpt; _result = POINT; return _result; } if (minpt->x() < start2.x()) { _intersection_point = start2; _other_point = *maxpt; } else { _intersection_point = _seg->source(); _other_point = _seg->target(); } _result = SEGMENT; return _result; } else { if (minpt->x() > start2.x()) { _result = NO; return _result; } if (minpt->x() == start2.x()) { _intersection_point = *minpt; _result = POINT; return _result; } if (maxpt->x() > start2.x()) { _intersection_point = start2; _other_point = *maxpt; } else { _intersection_point = _seg->source(); _other_point = _seg->target(); } _result = SEGMENT; return _result; } } else { typedef typename K::FT FT; if (start1.y() < end1.y()) { minpt = &start1; maxpt = &end1; } else { minpt = &end1; maxpt = &start1; } if (_ray->direction().to_vector().y() > FT(0)) { if (maxpt->y() < start2.y()) { _result = NO; return _result; } if (maxpt->y() == start2.y()) { _intersection_point = *maxpt; _result = POINT; return _result; } if (minpt->y() < start2.y()) { _intersection_point = start2; _other_point = *maxpt; } else { _intersection_point = _seg->source(); _other_point = _seg->target(); } _result = SEGMENT; return _result; } else { if (minpt->y() > start2.y()) { _result = NO; return _result; } if (minpt->y() == start2.y()) { _intersection_point = *minpt; _result = POINT; return _result; } if (maxpt->y() > start2.y()) { _intersection_point = start2; _other_point = *maxpt; } else { _intersection_point = _seg->source(); _other_point = _seg->target(); } _result = SEGMENT; return _result; } } } default: CGAL_kernel_assertion(false); // should not be reached: return _result; } } template bool Ray_2_Segment_2_pair::intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Ray_2_Segment_2_pair::intersection(typename K::Segment_2 &result) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = Segment_2(_intersection_point, _other_point); return true; } template Object intersection(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Segment_2&seg, const K&) { typedef Ray_2_Segment_2_pair is_t; is_t ispair(&ray, &seg); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } template Object intersection(const typename CGAL_WRAP(K)::Segment_2 &seg, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { return CGALi::intersection(ray, seg, k); } template class Segment_2_Ray_2_pair: public Ray_2_Segment_2_pair { public: Segment_2_Ray_2_pair( typename K::Segment_2 const *seg, typename K::Ray_2 const *ray) : Ray_2_Segment_2_pair(ray, seg) {} }; } // namespace CGALi template inline bool do_intersect( const Segment_2 &p1, const Ray_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline bool do_intersect( const Ray_2 &p1, const Segment_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p2, p1); } template inline Object intersection(const Segment_2 &seg, const Ray_2 &ray) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, seg); } template inline Object intersection(const Ray_2 &ray, const Segment_2 &seg) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, seg); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/to_rational.h0000644000175000017500000000524211344301501027510 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/to_rational.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Susan Hert, Sylvain Pion #ifndef CGAL_TO_RATIONAL_H #define CGAL_TO_RATIONAL_H #include CGAL_BEGIN_NAMESPACE template Rational to_rational(double x) { typename Rational_traits::RT num = 0; typename Rational_traits::RT den = 1; if (x != 0.0) { bool neg = (x < 0); if (neg) x = -x; const unsigned shift = 15; // a safe shift per step const int shift_pow = 32768; // = 2^shift const double width = 32768; // = 2^shift const int maxiter = 20; // ought not be necessary, but just in // case, max 300 bits of precision int expt; double mantissa = frexp(x, &expt); long exponent = expt; double intpart; int k = 0; while (mantissa != 0.0 && k++ < maxiter) { mantissa *= width; // shift double mantissa mantissa = CGAL_CLIB_STD::modf(mantissa, &intpart); num *= shift_pow; num += (int)intpart; exponent -= shift; } int expsign = (exponent>0 ? +1 : (exponent<0 ? -1 : 0)); exponent *= expsign; typename Rational_traits::RT twopot(2); typename Rational_traits::RT exppot(1); while (exponent!=0) { if (exponent & 1) exppot *= twopot; exponent >>= 1; twopot *= twopot; } if (expsign > 0) num *= exppot; else if (expsign < 0) den *= exppot; if (neg) num = -num; } return Rational(num,den); } CGAL_END_NAMESPACE #endif // CGAL_TO_RATIONAL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/vector.h0000644000175000017500000005402611344301501026503 0ustar debiandebian// Copyright (c) 1997, 1998, 1999, 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/vector.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri // Lutz Kettner #ifndef CGAL_VECTOR_H #define CGAL_VECTOR_H 1 #if defined( _MSC_VER) && (_MSC_VER <= 1200) #error CGAL::vector not available on MSC VC6 #else #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { // We give the vector container class a class based iterator implementation. // It ensures that iterator_traits work on compilers not supporting // partial specializations and it guarantees that default initialization // initializes the internal pointer to 0. Allows explicit construction // from a pointer. template < class T, class Ref, class Ptr> class vector_iterator { private: Ptr ptr; public: typedef vector_iterator< T, Ref, Ptr> Self; typedef T value_type; typedef Ref reference; typedef Ptr pointer; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; // CREATION // -------- vector_iterator() : ptr(0) {} // explicitly set to 0 explicit vector_iterator( Ptr p) : ptr(p) {} // construction from pointer // Allows construction of const_iterator from iterator template < class A, class B, class C> vector_iterator( const vector_iterator& i) : ptr( &*i) {} // OPERATIONS Forward Category // --------------------------- bool operator==( const Self& i) const { return ( ptr == i.ptr); } bool operator!=( const Self& i) const { return !(*this == i); } reference operator*() const { return *ptr; } pointer operator->() const { return ptr; } Self& operator++() { ++ptr; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --ptr; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self& operator+=( difference_type n) { ptr += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return ptr - i.ptr; } reference operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } bool operator< ( const Self& i) const { return ( ptr < i.ptr); } bool operator> ( const Self& i) const { return i < *this; } bool operator<=( const Self& i) const { return !(i < *this); } bool operator>=( const Self& i) const { return !(*this < i); } }; template < class T, class Ref, class Ptr> inline vector_iterator operator+( std::ptrdiff_t n, vector_iterator i) { return i += n; } template < class T, class Alloc = CGAL_ALLOCATOR(T)> class vector { public: typedef Alloc Allocator; typedef Alloc allocator_type; // STL compliant // Note: the standard requires the following types to be equivalent // to T, T*, const T*, T&, const T&, size_t, and ptrdiff_t, respectively. // So we don't pass these types to the iterators explicitly. typedef typename Allocator::value_type value_type; typedef typename Allocator::pointer pointer; typedef typename Allocator::const_pointer const_pointer; typedef typename Allocator::reference reference; typedef typename Allocator::const_reference const_reference; typedef typename Allocator::size_type size_type; typedef typename Allocator::difference_type difference_type; typedef std::random_access_iterator_tag iterator_category; typedef vector_iterator< T, reference, pointer> iterator; typedef vector_iterator< T, const_reference, const_pointer> const_iterator; typedef vector< T, Alloc> Self; #if defined(__sun) && defined(__SUNPRO_CC) typedef std::reverse_iterator< iterator, typename iterator::iterator_category, typename iterator::value_type, typename iterator::reference, typename iterator::pointer, typename iterator::difference_type > reverse_iterator; typedef std::reverse_iterator< const_iterator, typename const_iterator::iterator_category, typename const_iterator::value_type, typename const_iterator::reference, typename const_iterator::pointer, typename const_iterator::difference_type > const_reverse_iterator; #else typedef std::reverse_iterator< iterator > reverse_iterator; typedef std::reverse_iterator< const_iterator > const_reverse_iterator; #endif // defined(__sun) && defined(__SUNPRO_CC) protected: #ifndef _MSC_VER // Somehow the static initialization does not work correctly for MSVC // ---> strange linker errors static #endif // _MSC_VER Allocator alloc; iterator start_; iterator finish; iterator end_of_storage; // ALLOCATION AND CONSTRUCTION HELPERS void construct( iterator i, const T& x) { alloc.construct( &*i, x);} void destroy( iterator i) { alloc.destroy( &*i); } void destroy( iterator first, iterator last) { // destroy in reverse order than construction while ( last != first) { --last; destroy( last); } } void deallocate() { if ( &*start_) alloc.deallocate( &*start_, end_of_storage - start_ ); } protected: // pointer versions of begin()/end() to call the various // standard algorithms with the (possibly) more efficient pointers. pointer pbegin() { return &*start_; } const_pointer pbegin() const { return &*start_; } pointer pend() { return &*finish; } const_pointer pend() const { return &*finish; } public: // ACCESS // ------ iterator begin() { return start_; } const_iterator begin() const { return start_; } iterator end() { return finish; } const_iterator end() const { return finish; } size_type size() const { return size_type(end() - begin()); } size_type max_size() const { return size_type(-1) / sizeof(T); } size_type capacity() const { return size_type(end_of_storage - start_); } bool empty() const { return begin() == end(); } reference front() { return *begin(); } const_reference front() const { return *begin(); } reference back() { return *(end() - 1); } const_reference back() const { return *(end() - 1); } reference operator[] ( size_type n) { return *(begin() + n); } const_reference operator[] ( size_type n) const { return *(begin() + n); } reference at( size_type n) { return *(begin() + n); } const_reference at( size_type n) const { return *(begin() + n); } Allocator get_allocator() const { return alloc; } reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } // COMPARISON // ---------- bool operator==( const Self& y) const { return size() == y.size() && std::equal( pbegin(), pend(), y.pbegin()); } bool operator!=( const Self& y) const { return !(*this == y); } bool operator< ( const Self& y) const { return std::lexicographical_compare( pbegin(), pend(), y.pbegin(), y.pend()); } bool operator> ( const Self& y) const { return y < *this; } bool operator<=( const Self& y) const { return !(y < *this); } bool operator>=( const Self& y) const { return !(*this < y); } // CREATION // -------- explicit vector() : start_(0), finish(0), end_of_storage(0) {} explicit vector( const Alloc& a) : start_(0), finish(0), end_of_storage(0) { alloc = a; } explicit vector( size_type n, const T& val) { fill_initialize(n, val); } explicit vector( size_type n) { fill_initialize(n, T()); } vector( const Self& x) { start_ = allocate_and_copy( x.end() - x.begin(), x.begin(), x.end()); finish = start_ + (x.end() - x.begin()); end_of_storage = finish; } template vector( InputIterator first, InputIterator last, const Alloc& a = Alloc()) : start_(0), finish(0), end_of_storage(0) { alloc = a; typedef std::iterator_traits Traits; typedef typename Traits::iterator_category iterator_category; range_initialize( first, last, iterator_category()); } ~vector() { destroy( start_, finish); deallocate(); } vector& operator=(const Self& x) { if (&x != this) { if ( x.size() > capacity()) { iterator tmp = allocate_and_copy( x.end() - x.begin(), x.begin(), x.end()); destroy( start_, finish); deallocate(); start_ = tmp; end_of_storage = start_ + (x.end() - x.begin()); } else if (size() >= x.size()) { iterator i = std::copy( x.begin(), x.end(), begin()); destroy( i, finish); } else { std::copy( x.begin(), x.begin() + size(), begin()); std::uninitialized_copy(x.pbegin() + size(), x.pend(), pend()); } finish = start_ + x.size(); } return *this; } void swap( Self& x) { std::swap( start_, x.start_); std::swap( finish, x.finish); std::swap( end_of_storage, x.end_of_storage); } void reserve( size_type n) { if ( capacity() < n) { const size_type old_size = size(); iterator tmp = allocate_and_copy( n, start_, finish); destroy(start_, finish); deallocate(); start_ = tmp; finish = tmp + old_size; end_of_storage = start_ + n; } } // INSERTION // --------- void push_back( const T& x) { if ( finish != end_of_storage) { construct( finish, x); ++finish; } else { insert_aux( end(), x); } } iterator insert( iterator position, const T& x) { size_type n = position - begin(); if (finish != end_of_storage && position == end()) { construct( finish, x); ++finish; } else { insert_aux( position, x); } return begin() + n; } iterator insert(iterator position) { return insert( position, T()); } template void insert( iterator position, InputIterator first, InputIterator last) { typedef std::iterator_traits Traits; typedef typename Traits::iterator_category iterator_category; range_insert( position, first, last, iterator_category()); } void insert( iterator pos, size_type n, const T& x); // REMOVAL // ------- void pop_back() { --finish; destroy( finish); } iterator erase( iterator position) { if (position + 1 != end()) std::copy( position + 1, finish, position); --finish; destroy(finish); return position; } iterator erase( iterator first, iterator last) { iterator i = std::copy( last, finish, first); destroy( i, finish); finish = finish - (last - first); return first; } void clear() { erase( begin(), end()); } // ASSIGNMENT // ---------- template void assign( InputIterator first, InputIterator last) { clear(); insert( begin(), first, last); } void assign( size_type n, const T& u) { clear(); insert( begin(), n, u); } void resize( size_type new_size, const T& x) { if (new_size < size()) erase( begin() + new_size, end()); else insert( end(), new_size - size(), x); } void resize( size_type new_size) { resize( new_size, T()); } protected: // INTERNAL // -------- void insert_aux( iterator position, const T& x); void fill_initialize( size_type n, const T& value) { start_ = allocate_and_fill(n, value); finish = start_ + n; end_of_storage = finish; } iterator allocate_and_fill( size_type n, const T& x) { iterator result = iterator( alloc.allocate(n)); try { std::uninitialized_fill_n( &*result, n, x); return result; } catch(...) { alloc.deallocate( &*result, n); throw; } } template iterator allocate_and_copy( size_type n, ForwardIterator first, ForwardIterator last) { iterator result = iterator( alloc.allocate(n)); try { std::uninitialized_copy( first, last, &*result); return result; } catch(...) { alloc.deallocate( &*result, n); throw; } } template void range_initialize(InputIterator first, InputIterator last, std::input_iterator_tag) { for ( ; first != last; ++first) push_back(*first); } // This function is only called by the constructor. We have to worry // about resource leaks, but not about maintaining invariants. template void range_initialize( ForwardIterator first, ForwardIterator last, std::forward_iterator_tag) { size_type n = std::distance( first, last); start_ = allocate_and_copy( n, first, last); finish = start_ + n; end_of_storage = finish; } template void range_insert( iterator pos, InputIterator first, InputIterator last, std::input_iterator_tag) { for ( ; first != last; ++first) { pos = insert( pos, *first); ++pos; } } template void range_insert( iterator position, ForwardIterator first, ForwardIterator last, std::forward_iterator_tag) { if (first != last) { size_type n = std::distance(first, last); if ( size_type(end_of_storage - finish) >= n) { const size_type elems_after = finish - position; iterator old_finish = finish; if (elems_after > n) { std::uninitialized_copy( pend() - n, pend(), pend()); finish += n; std::copy_backward( position, old_finish - n, old_finish); std::copy( first, last, position); } else { ForwardIterator mid = first; std::advance( mid, elems_after); std::uninitialized_copy( mid, last, pend()); finish += n - elems_after; std::uninitialized_copy( position, old_finish, pend()); finish += elems_after; std::copy( first, mid, position); } } else { const size_type old_size = size(); const size_type len = old_size + std::max( old_size, n); iterator new_start = iterator( alloc.allocate(len)); iterator new_finish = new_start; try { new_finish = iterator( std::uninitialized_copy(start_, position,&*new_start)); new_finish = iterator( std::uninitialized_copy( first, last, &*new_finish)); new_finish = iterator( std::uninitialized_copy(position,finish,&*new_finish)); } catch(...) { destroy( new_start, new_finish); alloc.deallocate( &*new_start, len); throw; } destroy( start_, finish); deallocate(); start_ = new_start; finish = new_finish; end_of_storage = new_start + len; } } } }; // class vector #ifndef _MSC_VER // init static member allocator object template Alloc vector< T, Alloc>::alloc = Alloc(); #endif // _MSC_VER template inline void swap( vector& x, vector& y) { x.swap(y); } template void vector::insert_aux( iterator position, const T& x) { if ( finish != end_of_storage) { construct( finish, *(finish - 1)); ++finish; T x_copy = x; std::copy_backward( position, finish - 2, finish - 1); *position = x_copy; } else { const size_type old_size = size(); const size_type len = old_size != 0 ? 2 * old_size : 1; iterator new_start = iterator( alloc.allocate(len)); iterator new_finish = new_start; try { new_finish = iterator( std::uninitialized_copy(start_, position, &*new_start)); construct( new_finish, x); ++new_finish; new_finish = iterator( std::uninitialized_copy(position,finish,&*new_finish)); } catch(...) { destroy( new_start, new_finish); alloc.deallocate( &*new_start, len); throw; } destroy( begin(), end()); deallocate(); start_ = new_start; finish = new_finish; end_of_storage = new_start + len; } } template void vector::insert( iterator position, size_type n, const T& x) { if (n != 0) { if ( size_type(end_of_storage - finish) >= n) { T x_copy = x; const size_type elems_after = finish - position; iterator old_finish = finish; if (elems_after > n) { std::uninitialized_copy( pend() - n, pend(), pend()); finish += n; std::copy_backward( position, old_finish - n, old_finish); std::fill( position, position + n, x_copy); } else { std::uninitialized_fill_n( pend(), n - elems_after, x_copy); finish += n - elems_after; std::uninitialized_copy( position, old_finish, pend()); finish += elems_after; std::fill(position, old_finish, x_copy); } } else { const size_type old_size = size(); const size_type len = old_size + std::max(old_size, n); iterator new_start = iterator( alloc.allocate(len)); iterator new_finish = new_start; try { new_finish = iterator( std::uninitialized_copy( start_, position, &*new_start)); std::uninitialized_fill_n( &*new_finish, n, x); new_finish += n; new_finish = iterator( std::uninitialized_copy( position, finish, &*new_finish)); } catch(...) { destroy( new_start, new_finish); alloc.deallocate( &*new_start, len); throw; } destroy( start_, finish); deallocate(); start_ = new_start; finish = new_finish; end_of_storage = new_start + len; } } } } // namespace CGALi CGAL_END_NAMESPACE #endif // defined( _MSC_VER) && (_MSC_VER <= 1200) #endif // CGAL_VECTOR_H // // EOF // ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_traits_with_normals_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_traits_with0000644000175000017500000000321211344301500031505 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_traits_with_normals_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_POLYHEDRON_TRAITS_WITH_NORMALS_3_H #define CGAL_POLYHEDRON_TRAITS_WITH_NORMALS_3_H 1 #include CGAL_BEGIN_NAMESPACE template < class Kernel_ > class Polyhedron_traits_with_normals_3 { public: typedef Kernel_ Kernel; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Vector_3 Plane_3; typedef typename Kernel::Construct_opposite_vector_3 Construct_opposite_plane_3; private: Kernel m_kernel; public: Polyhedron_traits_with_normals_3() {} Polyhedron_traits_with_normals_3( const Kernel& kernel) : m_kernel(kernel) {} Construct_opposite_plane_3 construct_opposite_plane_3_object() const { return m_kernel.construct_opposite_vector_3_object(); } }; CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_TRAITS_WITH_NORMALS_3_H // // EOF // ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_edge.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_edge0000644000175000017500000000711311344301500031444 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_edge.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_OPT_CVX_EDGE_H #define CGAL_PARTITION_OPT_CVX_EDGE_H #include #include namespace CGAL { enum Partition_opt_cvx_edge_validity {PARTITION_OPT_CVX_NOT_VALID, PARTITION_OPT_CVX_START_VALID, PARTITION_OPT_CVX_END_VALID, PARTITION_OPT_CVX_BOTH_VALID}; class Partition_opt_cvx_edge { public: Partition_opt_cvx_edge(): _is_done(false), _validity(PARTITION_OPT_CVX_NOT_VALID), _is_visible(false), _value(0) {} bool is_done( ) const { return _is_done; } bool is_valid( ) const { return _validity != PARTITION_OPT_CVX_NOT_VALID; } Partition_opt_cvx_edge_validity validity( ) const { return _validity; } bool is_visible( ) const { return _is_visible; } int value( ) const { return _value; } Partition_opt_cvx_diagonal_list solution( ) const { return _solution; } void set_done(bool val) { _is_done = val; } void set_valid(Partition_opt_cvx_edge_validity val) { _validity = val; } template void set_valid(const Point_2_& p1, const Point_2_& p2, const Point_2_& p3, const Point_2_& p4, const Point_2_& p5, const Point_2_& p6, const Traits& traits) { typedef typename Traits::Left_turn_2 Left_turn_2; Left_turn_2 left_turn = traits.left_turn_2_object(); _validity = PARTITION_OPT_CVX_NOT_VALID; Turn_reverser right_turn(left_turn); if (right_turn(p1, p2, p3)) _validity = PARTITION_OPT_CVX_START_VALID; if (right_turn(p4, p5, p6)) if (_validity == PARTITION_OPT_CVX_START_VALID) _validity = PARTITION_OPT_CVX_BOTH_VALID; else _validity = PARTITION_OPT_CVX_END_VALID; } void set_visible(bool vis) { _is_visible = vis; } void set_value(int val) { _value = val; } void set_solution(const Partition_opt_cvx_diagonal_list& diag_list) { _solution = diag_list; } private: bool _is_done; Partition_opt_cvx_edge_validity _validity; bool _is_visible; int _value; Partition_opt_cvx_diagonal_list _solution; }; inline std::ostream& operator<<(std::ostream& os, const Partition_opt_cvx_edge& g) { if (g.is_done()) os << "1"; else os << "0"; if (g.validity() == PARTITION_OPT_CVX_NOT_VALID) os << "0"; else if (g.validity() == PARTITION_OPT_CVX_START_VALID) os << "1"; else if (g.validity() == PARTITION_OPT_CVX_END_VALID) os << "2"; else os << "3"; if (g.is_visible()) os << "1"; else os << "0"; os << g.value(); return os; } } #endif // CGAL_PARTITION_OPT_CVX_EDGE_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_3_center_2_msvc.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_3_center_20000644000175000017500000010261711344301500031264 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_3_center_2_msvc.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_RECTANGULAR_3_CENTER_2_MSVC_H) #define CGAL_RECTANGULAR_3_CENTER_2_MSVC_H 1 template < class R > struct Rectangular_3_center_2_type2_operations0 { typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Iso_rectangle_2 Iso_rectangle_2; typedef typename R::Infinity_distance_2 Infinity_distance_2; typedef typename R::Less_x_2 Less_x_2; typedef typename R::Less_y_2 Less_y_2; typedef typename Swap< Less_x_2 >::Type Greater_x_2; typedef typename Swap< Less_y_2 >::Type Greater_y_2; typedef Min< Point_2, Less_x_2 > Min_x_2; typedef Max< Point_2, Less_x_2 > Max_x_2; typedef Min< Point_2, Less_y_2 > Min_y_2; typedef Max< Point_2, Less_y_2 > Max_y_2; typedef typename R::Construct_vertex_2 Construct_vertex_2; typedef typename R::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename R::Construct_point_2_above_right_implicit_point_2 Construct_point_2_above_right_implicit_point_2; typedef typename R::Construct_point_2_above_left_implicit_point_2 Construct_point_2_above_left_implicit_point_2; typedef typename R::Construct_point_2_below_right_implicit_point_2 Construct_point_2_below_right_implicit_point_2; typedef typename R::Construct_point_2_below_left_implicit_point_2 Construct_point_2_below_left_implicit_point_2; typedef typename Bind< Infinity_distance_2, Point_2, 1 >::Type Delta; Delta delta() const { return delta_; } Less_x_2 less_x_2_object() const { return r_.less_x_2_object(); } Less_y_2 less_y_2_object() const { return r_.less_y_2_object(); } Greater_x_2 greater_x_2_object() const { return swap_1(less_x_2_object()); } Greater_y_2 greater_y_2_object() const { return swap_1(less_y_2_object()); } Infinity_distance_2 distance() const { return r_.infinity_distance_2_object(); } Construct_vertex_2 construct_vertex_2_object() const { return r_.construct_vertex_2_object(); } Construct_iso_rectangle_2 construct_iso_rectangle_2_object() const { return r_.construct_iso_rectangle_2_object(); } Construct_point_2_below_left_implicit_point_2 pt_b_l() const { return r_.construct_point_2_below_left_implicit_point_2_object(); } Construct_point_2_above_left_implicit_point_2 pt_a_l() const { return r_.construct_point_2_above_left_implicit_point_2_object(); } Construct_point_2_below_right_implicit_point_2 pt_b_r() const { return r_.construct_point_2_below_right_implicit_point_2_object(); } Construct_point_2_above_right_implicit_point_2 pt_a_r() const { return r_.construct_point_2_above_right_implicit_point_2_object(); } Min_x_2 minx() const { return Min_x_2(less_x_2_object()); } Min_y_2 miny() const { return Min_y_2(less_y_2_object()); } Max_x_2 maxx() const { return Max_x_2(less_x_2_object()); } Max_y_2 maxy() const { return Max_y_2(less_y_2_object()); } private: R& r_; Delta delta_; public: typedef Point_2 Point; typedef Iso_rectangle_2 Rectangle; typedef Less_x_2 X_compare; typedef Greater_y_2 Y_compare; typedef Infinity_distance_2 Distance; Rectangular_3_center_2_type2_operations0(R& r, const Point& p) : r_(r), delta_(bind_1(r.infinity_distance_2_object(), p)) {} X_compare compare_x() const { return less_x_2_object(); } Y_compare compare_y() const { return greater_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)); return v(rect(bpt, v(bbox, 2)), 3); #else return v(rect(constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)), v(bbox, 2)), 3); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(bpt, v(bbox, 2)), 3); #else return v(rect(constraint_empty ? v(bbox, 2) : v(constraint, 0), v(bbox, 2)), 3); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(pt_b_l()(v(bbox, 2), v(bbox, 2), radius), so_far), so_far), 3); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0)); return v(rect(v(bbox, 2), bpt), 1); #else return v(rect(v(bbox, 2), constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0))), 1); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(v(bbox, 2), bpt), 1); #else return v(rect(v(bbox, 2), constraint_empty ? v(bbox, 2) : v(constraint, 0)), 1); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, miny()(pt_b_l()(v(bbox, 2), v(bbox, 2), radius), so_far)), 1); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(s, newp), s), 3); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, miny()(s, newp)), 1); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 1)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 3)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_a_r()(construct_vertex_2_object()(bbox, 0), construct_vertex_2_object()(bbox, 0), r); } Point construct_x_square(const Point& p, FT r) const { return pt_b_r()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_a_l()(p, p, r); } }; template < class R > struct Rectangular_3_center_2_type2_operations1 { typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Iso_rectangle_2 Iso_rectangle_2; typedef typename R::Infinity_distance_2 Infinity_distance_2; typedef typename R::Less_x_2 Less_x_2; typedef typename R::Less_y_2 Less_y_2; typedef typename Swap< Less_x_2 >::Type Greater_x_2; typedef typename Swap< Less_y_2 >::Type Greater_y_2; typedef Min< Point_2, Less_x_2 > Min_x_2; typedef Max< Point_2, Less_x_2 > Max_x_2; typedef Min< Point_2, Less_y_2 > Min_y_2; typedef Max< Point_2, Less_y_2 > Max_y_2; typedef typename R::Construct_vertex_2 Construct_vertex_2; typedef typename R::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename R::Construct_point_2_above_right_implicit_point_2 Construct_point_2_above_right_implicit_point_2; typedef typename R::Construct_point_2_above_left_implicit_point_2 Construct_point_2_above_left_implicit_point_2; typedef typename R::Construct_point_2_below_right_implicit_point_2 Construct_point_2_below_right_implicit_point_2; typedef typename R::Construct_point_2_below_left_implicit_point_2 Construct_point_2_below_left_implicit_point_2; typedef typename Bind< Infinity_distance_2, Point_2, 1 >::Type Delta; Delta delta() const { return delta_; } Less_x_2 less_x_2_object() const { return r_.less_x_2_object(); } Less_y_2 less_y_2_object() const { return r_.less_y_2_object(); } Greater_x_2 greater_x_2_object() const { return swap_1(less_x_2_object()); } Greater_y_2 greater_y_2_object() const { return swap_1(less_y_2_object()); } Infinity_distance_2 distance() const { return r_.infinity_distance_2_object(); } Construct_vertex_2 construct_vertex_2_object() const { return r_.construct_vertex_2_object(); } Construct_iso_rectangle_2 construct_iso_rectangle_2_object() const { return r_.construct_iso_rectangle_2_object(); } Construct_point_2_below_left_implicit_point_2 pt_b_l() const { return r_.construct_point_2_below_left_implicit_point_2_object(); } Construct_point_2_above_left_implicit_point_2 pt_a_l() const { return r_.construct_point_2_above_left_implicit_point_2_object(); } Construct_point_2_below_right_implicit_point_2 pt_b_r() const { return r_.construct_point_2_below_right_implicit_point_2_object(); } Construct_point_2_above_right_implicit_point_2 pt_a_r() const { return r_.construct_point_2_above_right_implicit_point_2_object(); } Min_x_2 minx() const { return Min_x_2(less_x_2_object()); } Min_y_2 miny() const { return Min_y_2(less_y_2_object()); } Max_x_2 maxx() const { return Max_x_2(less_x_2_object()); } Max_y_2 maxy() const { return Max_y_2(less_y_2_object()); } private: R& r_; Delta delta_; public: typedef Point_2 Point; typedef Iso_rectangle_2 Rectangle; typedef Greater_x_2 X_compare; typedef Greater_y_2 Y_compare; typedef Infinity_distance_2 Distance; Rectangular_3_center_2_type2_operations1(R& r, const Point& p) : r_(r), delta_(bind_1(r.infinity_distance_2_object(), p)) {} X_compare compare_x() const { return greater_x_2_object(); } Y_compare compare_y() const { return greater_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)); return v(rect(bpt, v(bbox, 3)), 2); #else return v(rect(constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)), v(bbox, 3)), 2); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(bpt, v(bbox, 3)), 2); #else return v(rect(constraint_empty ? v(bbox, 0) : v(constraint, 2), v(bbox, 3)), 2); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(so_far, pt_a_r()(v(bbox, 0), v(bbox, 0), radius)), so_far), 2); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0)); return v(rect(v(bbox, 3), bpt), 0); #else return v(rect(v(bbox, 3), constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0))), 0); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(v(bbox, 3), bpt), 0); #else return v(rect(v(bbox, 3), constraint_empty ? v(bbox, 2) : v(constraint, 0)), 0); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, miny()(so_far, pt_b_l()(v(bbox, 2), v(bbox, 2), radius))), 0); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(s, newp), s), 2); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, miny()(s, newp)), 0); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 0)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 2)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_a_l()(construct_vertex_2_object()(bbox, 2), construct_vertex_2_object()(bbox, 0), r); } Point construct_x_square(const Point& p, FT r) const { return pt_b_l()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_a_r()(p, p, r); } }; template < class R > struct Rectangular_3_center_2_type2_operations2 { typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Iso_rectangle_2 Iso_rectangle_2; typedef typename R::Infinity_distance_2 Infinity_distance_2; typedef typename R::Less_x_2 Less_x_2; typedef typename R::Less_y_2 Less_y_2; typedef typename Swap< Less_x_2 >::Type Greater_x_2; typedef typename Swap< Less_y_2 >::Type Greater_y_2; typedef Min< Point_2, Less_x_2 > Min_x_2; typedef Max< Point_2, Less_x_2 > Max_x_2; typedef Min< Point_2, Less_y_2 > Min_y_2; typedef Max< Point_2, Less_y_2 > Max_y_2; typedef typename R::Construct_vertex_2 Construct_vertex_2; typedef typename R::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename R::Construct_point_2_above_right_implicit_point_2 Construct_point_2_above_right_implicit_point_2; typedef typename R::Construct_point_2_above_left_implicit_point_2 Construct_point_2_above_left_implicit_point_2; typedef typename R::Construct_point_2_below_right_implicit_point_2 Construct_point_2_below_right_implicit_point_2; typedef typename R::Construct_point_2_below_left_implicit_point_2 Construct_point_2_below_left_implicit_point_2; typedef typename Bind< Infinity_distance_2, Point_2, 1 >::Type Delta; Delta delta() const { return delta_; } Less_x_2 less_x_2_object() const { return r_.less_x_2_object(); } Less_y_2 less_y_2_object() const { return r_.less_y_2_object(); } Greater_x_2 greater_x_2_object() const { return swap_1(less_x_2_object()); } Greater_y_2 greater_y_2_object() const { return swap_1(less_y_2_object()); } Infinity_distance_2 distance() const { return r_.infinity_distance_2_object(); } Construct_vertex_2 construct_vertex_2_object() const { return r_.construct_vertex_2_object(); } Construct_iso_rectangle_2 construct_iso_rectangle_2_object() const { return r_.construct_iso_rectangle_2_object(); } Construct_point_2_below_left_implicit_point_2 pt_b_l() const { return r_.construct_point_2_below_left_implicit_point_2_object(); } Construct_point_2_above_left_implicit_point_2 pt_a_l() const { return r_.construct_point_2_above_left_implicit_point_2_object(); } Construct_point_2_below_right_implicit_point_2 pt_b_r() const { return r_.construct_point_2_below_right_implicit_point_2_object(); } Construct_point_2_above_right_implicit_point_2 pt_a_r() const { return r_.construct_point_2_above_right_implicit_point_2_object(); } Min_x_2 minx() const { return Min_x_2(less_x_2_object()); } Min_y_2 miny() const { return Min_y_2(less_y_2_object()); } Max_x_2 maxx() const { return Max_x_2(less_x_2_object()); } Max_y_2 maxy() const { return Max_y_2(less_y_2_object()); } private: R& r_; Delta delta_; public: typedef Point_2 Point; typedef Iso_rectangle_2 Rectangle; typedef Greater_x_2 X_compare; typedef Less_y_2 Y_compare; typedef Infinity_distance_2 Distance; Rectangular_3_center_2_type2_operations2(R& r, const Point& p) : r_(r), delta_(bind_1(r.infinity_distance_2_object(), p)) {} X_compare compare_x() const { return greater_x_2_object(); } Y_compare compare_y() const { return less_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)); return v(rect(bpt, v(bbox, 0)), 1); #else return v(rect(constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)), v(bbox, 0)), 1); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(bpt, v(bbox, 0)), 1); #else return v(rect(constraint_empty ? v(bbox, 0) : v(constraint, 2), v(bbox, 0)), 1); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(so_far, pt_a_r()(v(bbox, 0), v(bbox, 0), radius)), so_far), 1); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2)); return v(rect(v(bbox, 0), bpt), 3); #else return v(rect(v(bbox, 0), constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2))), 3); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(v(bbox, 0), bpt), 3); #else return v(rect(v(bbox, 0), constraint_empty ? v(bbox, 0) : v(constraint, 2)), 3); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, maxy()(pt_a_r()(v(bbox, 0), v(bbox, 0), radius), so_far)), 3); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(s, newp), s), 1); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, maxy()(s, newp)), 3); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 3)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 1)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_b_l()(construct_vertex_2_object()(bbox, 2), construct_vertex_2_object()(bbox, 2), r); } Point construct_x_square(const Point& p, FT r) const { return pt_a_l()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_b_r()(p, p, r); } }; template < class R > struct Rectangular_3_center_2_type2_operations3 { typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Iso_rectangle_2 Iso_rectangle_2; typedef typename R::Infinity_distance_2 Infinity_distance_2; typedef typename R::Less_x_2 Less_x_2; typedef typename R::Less_y_2 Less_y_2; typedef typename Swap< Less_x_2 >::Type Greater_x_2; typedef typename Swap< Less_y_2 >::Type Greater_y_2; typedef Min< Point_2, Less_x_2 > Min_x_2; typedef Max< Point_2, Less_x_2 > Max_x_2; typedef Min< Point_2, Less_y_2 > Min_y_2; typedef Max< Point_2, Less_y_2 > Max_y_2; typedef typename R::Construct_vertex_2 Construct_vertex_2; typedef typename R::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename R::Construct_point_2_above_right_implicit_point_2 Construct_point_2_above_right_implicit_point_2; typedef typename R::Construct_point_2_above_left_implicit_point_2 Construct_point_2_above_left_implicit_point_2; typedef typename R::Construct_point_2_below_right_implicit_point_2 Construct_point_2_below_right_implicit_point_2; typedef typename R::Construct_point_2_below_left_implicit_point_2 Construct_point_2_below_left_implicit_point_2; typedef typename Bind< Infinity_distance_2, Point_2, 1 >::Type Delta; Delta delta() const { return delta_; } Less_x_2 less_x_2_object() const { return r_.less_x_2_object(); } Less_y_2 less_y_2_object() const { return r_.less_y_2_object(); } Greater_x_2 greater_x_2_object() const { return swap_1(less_x_2_object()); } Greater_y_2 greater_y_2_object() const { return swap_1(less_y_2_object()); } Infinity_distance_2 distance() const { return r_.infinity_distance_2_object(); } Construct_vertex_2 construct_vertex_2_object() const { return r_.construct_vertex_2_object(); } Construct_iso_rectangle_2 construct_iso_rectangle_2_object() const { return r_.construct_iso_rectangle_2_object(); } Construct_point_2_below_left_implicit_point_2 pt_b_l() const { return r_.construct_point_2_below_left_implicit_point_2_object(); } Construct_point_2_above_left_implicit_point_2 pt_a_l() const { return r_.construct_point_2_above_left_implicit_point_2_object(); } Construct_point_2_below_right_implicit_point_2 pt_b_r() const { return r_.construct_point_2_below_right_implicit_point_2_object(); } Construct_point_2_above_right_implicit_point_2 pt_a_r() const { return r_.construct_point_2_above_right_implicit_point_2_object(); } Min_x_2 minx() const { return Min_x_2(less_x_2_object()); } Min_y_2 miny() const { return Min_y_2(less_y_2_object()); } Max_x_2 maxx() const { return Max_x_2(less_x_2_object()); } Max_y_2 maxy() const { return Max_y_2(less_y_2_object()); } private: R& r_; Delta delta_; public: typedef Point_2 Point; typedef Iso_rectangle_2 Rectangle; typedef Less_x_2 X_compare; typedef Less_y_2 Y_compare; typedef Infinity_distance_2 Distance; Rectangular_3_center_2_type2_operations3(R& r, const Point& p) : r_(r), delta_(bind_1(r.infinity_distance_2_object(), p)) {} X_compare compare_x() const { return less_x_2_object(); } Y_compare compare_y() const { return less_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)); return v(rect(bpt, v(bbox, 1)), 0); #else return v(rect(constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)), v(bbox, 1)), 0); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(bpt, v(bbox, 1)), 0); #else return v(rect(constraint_empty ? v(bbox, 2) : v(constraint, 0), v(bbox, 1)), 0); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(pt_b_l()(v(bbox, 2), v(bbox, 2), radius), so_far), so_far), 0); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2)); return v(rect(v(bbox, 1), bpt), 2); #else return v(rect(v(bbox, 1), constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2))), 2); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(v(bbox, 1), bpt), 2); #else return v(rect(v(bbox, 1), constraint_empty ? v(bbox, 0) : v(constraint, 2)), 2); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, maxy()(pt_a_r()(v(bbox, 0), v(bbox, 0), radius), so_far)), 2); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(s, newp), s), 0); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, maxy()(s, newp)), 2); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 2)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 0)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_b_r()(construct_vertex_2_object()(bbox, 0), construct_vertex_2_object()(bbox, 2), r); } Point construct_x_square(const Point& p, FT r) const { return pt_a_r()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_b_l()(p, p, r); } }; #endif // ! (CGAL_RECTANGULAR_3_CENTER_2_MSVC_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Td_traits.h0000644000175000017500000001210511344301501027126 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Td_traits.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_TD_TRAITS_H #define CGAL_TD_TRAITS_H CGAL_BEGIN_NAMESPACE template class Td_traits : public Pm_traits_ { public: typedef Pm_traits_ Traits_base; typedef X_curve_ X_curve; typedef Td_traits Self; typedef typename Traits_base::Point Point; typedef X_curve* X_curve_ptr; typedef X_curve& X_curve_ref; typedef const X_curve& X_curve_const_ref; typedef Td_X_trapezoid X_trapezoid; typedef X_trapezoid* X_trapezoid_ptr; typedef X_trapezoid& X_trapezoid_ref; typedef const X_trapezoid& X_trapezoid_const_ref; Td_traits(const Traits_base& t) : Traits_base(t){} Td_traits() {} ~Td_traits(void) { if (POINT_AT_LEFT_TOP_INFINITY) { delete POINT_AT_LEFT_TOP_INFINITY; POINT_AT_LEFT_TOP_INFINITY = 0; } if (POINT_AT_RIGHT_BOTTOM_INFINITY) { delete POINT_AT_RIGHT_BOTTOM_INFINITY; POINT_AT_RIGHT_BOTTOM_INFINITY = 0; } if (CURVE_AT_INFINITY) { delete CURVE_AT_INFINITY; CURVE_AT_INFINITY = 0; } } protected: typedef X_trapezoid_const_ref const_ref; public: /* note: The traits assume that the trapezoid is active,non empty, and planar, that is no two curves intersect in non degenerate curve. */ inline bool curve_is_unbounded(const X_curve& cv) const { /* compare curve with static unbounded curve */ return cv.identical(CURVE_AT_INFINITY); } inline bool trapezoid_bottom_curve_equal(X_trapezoid_const_ref left, X_trapezoid_const_ref right) const /* returns true if bottom curves of input are the same */ { if (left.is_bottom_unbounded()) return right.is_bottom_unbounded(); if (right.is_bottom_unbounded()) return false; return curve_equal(left.bottom(),right.bottom()); } inline bool trapezoid_top_curve_equal(X_trapezoid_const_ref left, X_trapezoid_const_ref right) const /* returns true if top curves of input are the same */ { if (left.is_top_unbounded()) return right.is_top_unbounded(); if (right.is_top_unbounded()) return false; return curve_equal(left.top(),right.top()); } bool is_degenerate(const_ref tr) const { return is_degenerate_point(tr) || !tr.is_top_unbounded() && !tr.is_bottom_unbounded() && curve_equal(tr.bottom(),tr.top()); } bool is_degenerate_point(const_ref tr) const { return !tr.is_left_unbounded() && !tr.is_right_unbounded() && point_equal(tr.left(),tr.right()); } bool is_degenerate_curve(const_ref tr) const { return !tr.is_top_unbounded() && !tr.is_bottom_unbounded() && curve_equal(tr.bottom(), tr.top()) && !is_degenerate_point(tr); } bool is_vertical(const_ref tr) const { return !tr.is_left_unbounded() && !tr.is_right_unbounded() && point_equal_x(tr.left(),tr.right()); } /* Description: returns whether point is inside trapezoid using lexicographic order */ bool is_inside(const_ref tr,const Point& p) const { return (tr.is_left_unbounded()|| point_is_left_low(tr.left(),p))&& (tr.is_right_unbounded()|| point_is_right_top(tr.right(),p))&& (tr.is_bottom_unbounded()|| curve_compare_y_at_x(p, tr.bottom()) == LARGER)&& (tr.is_top_unbounded()|| curve_compare_y_at_x(p, tr.top()) == SMALLER); } bool is_in_closure(const_ref tr,const Point& p) const { // test left and right sides if ((tr.is_left_unbounded()|| !point_is_left_low(p,tr.left()))&& (tr.is_right_unbounded()|| !point_is_right_top(p,tr.right()))) { // test bottom side if (!tr.is_bottom_unbounded()) { if (curve_compare_y_at_x(p, tr.bottom()) == SMALLER) return false; } // test top side if (!tr.is_top_unbounded()) { if (curve_compare_y_at_x(p, tr.top()) == LARGER) return false; } return true; } return false; } public: static const Point& get_point_at_left_top_infinity(); static const Point& get_point_at_right_bottom_infinity(); static const X_curve& get_curve_at_infinity(); private: static Point * POINT_AT_LEFT_TOP_INFINITY; static Point * POINT_AT_RIGHT_BOTTOM_INFINITY; static X_curve * CURVE_AT_INFINITY; }; CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_iterators.h0000644000175000017500000003666711344301500030033 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_iterators.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel #ifndef CGAL_ARR_ITERATORS_H #define CGAL_ARR_ITERATORS_H //this part is taken from Lutz's polyhedron, with minor modifications for //the planar map name convention #ifndef CGAL_CIRCULATOR_H #include #endif CGAL_BEGIN_NAMESPACE //////////////////////////////////////////////////////////////////////// // ARR //////////////////////////////////////////////////////////////////////// template < class Node, class It, class Ctg> class _Arr_face_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _Arr_face_circ Self; typedef Ctg iterator_category; typedef Node value_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; typedef size_t size_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::nt; #endif // CREATION // -------- // _Arr_face_circ() : It(0) {} _Arr_face_circ() : It() {} //_Polyhedron_facet_circ( pointer p) : It(p) {} _Arr_face_circ( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { nt = (*nt).next_halfedge(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- /* When implemented change it Self& operator--() { nt = (*nt).previous_halfedge(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } */ }; template < class Node, class It, class Ctg> class _Arr_face_const_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _Arr_face_const_circ Self; typedef Ctg iterator_category; typedef Node value_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; typedef size_t size_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::nt; #endif // CREATION // -------- _Arr_face_const_circ() : It(0) {} _Arr_face_const_circ( const_pointer p) : It(p) {} _Arr_face_const_circ( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- const_pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { nt = (*nt).next_halfedge(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- /* Self& operator--() { nt = (*nt).previous_halfedge(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } */ }; template < class Node, class It, class Ctg> class _Arr_vertex_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _Arr_vertex_circ Self; typedef Ctg iterator_category; typedef Node value_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; typedef size_t size_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::nt; #endif // CREATION // -------- // _Arr_vertex_circ() : It(0) {} _Arr_vertex_circ() : It() {} //_Polyhedron_vertex_circ( pointer p) : It(p) {} _Arr_vertex_circ( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { nt = (*nt).next_halfedge()->twin(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- /* Self& operator--() { nt = (*nt).twin()->previous_halfedge(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } */ }; template < class Node, class It, class Ctg> class _Arr_vertex_const_circ : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef _Arr_vertex_const_circ Self; typedef Ctg iterator_category; typedef Node value_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; typedef size_t size_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::nt; #endif // CREATION // -------- _Arr_vertex_const_circ() : It(0) {} _Arr_vertex_const_circ( const_pointer p) : It(p) {} _Arr_vertex_const_circ( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- const_pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { nt = (*nt).next_halfedge()->twin(); return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- /* Self& operator--() { nt = (*nt).twin()->previous_halfedge(); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } */ }; /////////////////////////////////////////////////////////////////////// // ARR OVERLAP CIRCULATOR // bidirectional circulator over overlapping edges - like above template < class Node, class It, class Ctg> class Arr_overlap_circulator : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef Arr_overlap_circulator Self; typedef Ctg iterator_category; typedef Node value_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; typedef size_t size_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::nt; #endif // CREATION // -------- Arr_overlap_circulator() : It() {} //try this Arr_overlap_circulator( pointer p) : It(p) {} Arr_overlap_circulator( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { //for this Subcurve_node needs to make the circ a friend nt = (*nt).past_end_child; return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { nt = (*nt).begin_child; return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; template < class Node, class It, class Ctg> class Arr_overlap_const_circulator : public It { // Ptr nt; // The internal node ptr inherited from It. public: typedef It Base; typedef Arr_overlap_const_circulator Self; typedef Ctg iterator_category; typedef Node value_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; typedef size_t size_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const value_type* const_pointer; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::nt; #endif // CREATION // -------- Arr_overlap_const_circulator() : It(0) {} Arr_overlap_const_circulator( const_pointer p) : It(p) {} Arr_overlap_const_circulator( It i) : It(i) {} // OPERATIONS Forward Category // --------------------------- const_pointer ptr() const { return & It::operator*();} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return It::operator==( It(NULL)); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return It::operator==(i); } bool operator!=( const Self& i) const { return !(*this == i); } Self& operator++() { nt = (*nt).past_end_child; //needs to be friend return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { nt = It((*nt).begin_child); return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } }; #ifdef BOGI //old implementation #ifdef CGAL_CFG_NO_DEFAULT_PREVIOUS_TEMPLATE_ARGUMENTS template < class C, class Fct /*, class Ref, class Ptr*/> #else template < class C, class Fct> // class Ref = typename C::reference, // class Ptr = typename C::pointer> #endif class Arr_overlap_circulator { protected: C nt; // The internal circulator. public: typedef C Circulator; //typedef Circulator_project Self; typedef Arr_overlap_circulator Self; //typedef typename C::iterator_category iterator_category; typedef std::bidirectional_iterator_tag iterator_category; //typedef typename Fct::result_type value_type; typedef Fct value_type; //typedef typename C::difference_type difference_type; // Metrowerks expects std:: before ptrdiff_t typedef CGAL_CLIB_STD::ptrdiff_t difference_type; //typedef typename C::size_type size_type; typedef size_t size_type; //typedef Ref reference; //just for this special case (since Fct is an iterator) : typedef Fct reference; //typedef Ptr pointer; typedef C pointer; //just for this special case // CREATION // -------- Arr_overlap_circulator() {} Arr_overlap_circulator( Circulator j) : nt(j) {} // OPERATIONS Forward Category // --------------------------- Circulator current_circulator() const { return nt;} //Ptr ptr() const { pointer ptr() const { //Fct fct; return nt; //return &(fct(*nt)); } bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == NULL); return ( nt == NULL); } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return ( nt == i.nt); } bool operator!=( const Self& i) const { return !(*this == i); } //Ref operator*() const { return *ptr(); } //Ptr operator->() const { return ptr(); } reference operator*() const { return Fct(nt); } pointer operator->() const { return nt; } //this is a bit meaningless Self& operator++() { //++nt; nt=nt->past_end_child; //for this Edge_node needs to make the circ a friend return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { //--nt; nt=nt->begin_child; //for this Edge_node needs to make the circ a friend return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } /* // OPERATIONS Random Access Category // --------------------------------- Self min_circulator() const { return Self( nt.min_circulator()); } Self& operator+=( difference_type n) { nt += n; return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; } Ref operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } */ }; #endif //BOGI CGAL_END_NAMESPACE #endif // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2.h0000644000175000017500000004170711344301500027663 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_ELLIPSE_2_H #define CGAL_MIN_ELLIPSE_2_H // includes #ifndef CGAL_OPTIMISATION_BASIC_H # include #endif #ifndef CGAL_RANDOM_H # include #endif #ifndef CGAL_PROTECT_LIST # include # define CGAL_PROTECT_LIST #endif #ifndef CGAL_PROTECT_VECTOR # include # define CGAL_PROTECT_VECTOR #endif #ifndef CGAL_PROTECT_ALGORITHM # include # define CGAL_PROTECT_ALGORITHM #endif #ifndef CGAL_PROTECT_IOSTREAM # include # define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class Traits_ > class Min_ellipse_2; // Class interface // =============== template < class Traits_ > class Min_ellipse_2 { public: // types typedef Traits_ Traits; typedef typename Traits_::Point Point; typedef typename Traits_::Ellipse Ellipse; typedef typename std::list::const_iterator Point_iterator; typedef const Point * Support_point_iterator; /************************************************************************** WORKAROUND: Some compilers are unable to match member functions defined outside the class template. Therefore, all member functions are implemented in the class interface. // creation template < class InputIterator > Min_ellipse_2( InputIterator first, InputIterator last, bool randomize = false, Random& random = default_random, const Traits& traits = Traits()); Min_ellipse_2( const Traits& traits = Traits()); Min_ellipse_2( const Point& p, const Traits& traits = Traits()); Min_ellipse_2( Point p, Point q, const Traits& traits = Traits()); Min_ellipse_2( const Point& p1, const Point& p2, const Point& p3, const Traits& traits = Traits()); Min_ellipse_2( const Point& p1, const Point& p2, const Point& p3, const Point& p4, const Traits& traits = Traits()); Min_ellipse_2( const Point& p1, const Point& p2, const Point& p3, const Point& p4, const Point& p5, const Traits& traits = Traits()); ~Min_ellipse_2( ); // access functions int number_of_points ( ) const; int number_of_support_points( ) const; Point_iterator points_begin( ) const; Point_iterator points_end ( ) const; Support_point_iterator support_points_begin( ) const; Support_point_iterator support_points_end ( ) const; const Point& support_point( int i) const; const Ellipse& ellipse( ) const; // predicates CGAL::Bounded_side bounded_side( const Point& p) const; bool has_on_bounded_side ( const Point& p) const; bool has_on_boundary ( const Point& p) const; bool has_on_unbounded_side ( const Point& p) const; bool is_empty ( ) const; bool is_degenerate( ) const; // modifiers void insert( const Point& p); void insert( const Point* first, const Point* last ); void insert( std::list::const_iterator first, std::list::const_iterator last ); void insert( std::istream_iterator first, std::istream_iterator last ); void clear( ); // validity check bool is_valid( bool verbose = false, int level = 0) const; // miscellaneous const Traits& traits( ) const; **************************************************************************/ private: // private data members Traits tco; // traits class object std::list points; // doubly linked list of points int n_support_points; // number of support points Point* support_points; // array of support points // copying and assignment not allowed! Min_ellipse_2( const Min_ellipse_2&); Min_ellipse_2& operator = ( const Min_ellipse_2&); // ============================================================================ // Class implementation // ==================== public: // Access functions and predicates // ------------------------------- // #points and #support points inline int number_of_points( ) const { return( points.size()); } inline int number_of_support_points( ) const { return( n_support_points); } // is_... predicates inline bool is_empty( ) const { return( number_of_support_points() == 0); } inline bool is_degenerate( ) const { return( number_of_support_points() < 3); } // access to points and support points inline Point_iterator points_begin( ) const { return( points.begin()); } inline Point_iterator points_end( ) const { return( points.end()); } inline Support_point_iterator support_points_begin( ) const { return( support_points); } inline Support_point_iterator support_points_end( ) const { return( support_points+n_support_points); } // random access for support points inline const Point& support_point( int i) const { CGAL_optimisation_precondition( (i >= 0) && (i < number_of_support_points())); return( support_points[ i]); } // ellipse inline const Ellipse& ellipse( ) const { return( tco.ellipse); } // in-ellipse test predicates inline CGAL::Bounded_side bounded_side( const Point& p) const { return( tco.ellipse.bounded_side( p)); } inline bool has_on_bounded_side( const Point& p) const { return( tco.ellipse.has_on_bounded_side( p)); } inline bool has_on_boundary( const Point& p) const { return( tco.ellipse.has_on_boundary( p)); } inline bool has_on_unbounded_side( const Point& p) const { return( tco.ellipse.has_on_unbounded_side( p)); } private: // Private member functions // ------------------------ // compute_ellipse inline void compute_ellipse( ) { switch ( n_support_points) { case 5: tco.ellipse.set( support_points[ 0], support_points[ 1], support_points[ 2], support_points[ 3], support_points[ 4]); break; case 4: tco.ellipse.set( support_points[ 0], support_points[ 1], support_points[ 2], support_points[ 3]); break; case 3: tco.ellipse.set( support_points[ 0], support_points[ 1], support_points[ 2]); break; case 2: tco.ellipse.set( support_points[ 0], support_points[ 1]); break; case 1: tco.ellipse.set( support_points[ 0]); break; case 0: tco.ellipse.set( ); break; default: CGAL_optimisation_assertion( ( n_support_points >= 0) && ( n_support_points <= 5) ); } } void me( const Point_iterator& last, int n_sp) { // compute ellipse through support points n_support_points = n_sp; compute_ellipse(); if ( n_sp == 5) return; // test first n points typename std::list::iterator point_iter = points.begin(); for ( ; last != point_iter; ) { const Point& p = *point_iter; // p not in current ellipse? if ( has_on_unbounded_side( p)) { // recursive call with p as additional support point support_points[ n_sp] = p; me( point_iter, n_sp+1); // move current point to front points.splice( points.begin(), points, point_iter++); } else ++point_iter; } } public: // Constructors // ------------ // STL-like constructor (member template) template < class InputIterator > Min_ellipse_2( InputIterator first, InputIterator last, bool randomize #if !defined(__BORLANDC__) && (!defined(_MSC_VER) || _MSC_VER > 1300) = false #endif , Random& random = default_random, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 5]; // range of points not empty? if ( first != last) { // store points if ( randomize) { // shuffle points at random #ifndef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES std::vector v( first, last); #else std::vector v; std::copy( first, last, std::back_inserter( v)); #endif std::random_shuffle( v.begin(), v.end(), random); std::copy( v.begin(), v.end(), std::back_inserter( points)); } else std::copy( first, last, std::back_inserter( points)); } // compute me me( points.end(), 0); } // default constructor inline Min_ellipse_2( const Traits& traits = Traits()) : tco( traits), n_support_points( 0) { // allocate support points' array support_points = new Point[ 5]; // initialize ellipse tco.ellipse.set(); CGAL_optimisation_postcondition( is_empty()); } // constructor for one point inline Min_ellipse_2( const Point& p, const Traits& traits = Traits()) : tco( traits), points( 1, p), n_support_points( 1) { // allocate support points' array support_points = new Point[ 5]; // initialize ellipse support_points[ 0] = p; tco.ellipse.set( p); CGAL_optimisation_postcondition( is_degenerate()); } // constructor for two points // This was const Point& but then Intel 7.0/.net2003 messes it up // with the constructor taking an iterator range inline Min_ellipse_2( Point p1, Point p2, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 5]; // store points points.push_back( p1); points.push_back( p2); // compute me me( points.end(), 0); CGAL_optimisation_postcondition( is_degenerate()); } // constructor for three points inline Min_ellipse_2( const Point& p1, const Point& p2, const Point& p3, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 5]; // store points points.push_back( p1); points.push_back( p2); points.push_back( p3); // compute me me( points.end(), 0); } // constructor for four points inline Min_ellipse_2( const Point& p1, const Point& p2, const Point& p3, const Point& p4, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 5]; // store points points.push_back( p1); points.push_back( p2); points.push_back( p3); points.push_back( p4); // compute me me( points.end(), 0); } // constructor for five points inline Min_ellipse_2( const Point& p1, const Point& p2, const Point& p3, const Point& p4, const Point& p5, const Traits& traits = Traits()) : tco( traits) { // allocate support points' array support_points = new Point[ 5]; // store points points.push_back( p1); points.push_back( p2); points.push_back( p3); points.push_back( p4); points.push_back( p5); // compute me me( points.end(), 0); } // Destructor // ---------- inline ~Min_ellipse_2( ) { // free support points' array delete[] support_points; } // Modifiers // --------- void insert( const Point& p) { // p not in current ellipse? if ( has_on_unbounded_side( p)) { // p new support point support_points[ 0] = p; // recompute me me( points.end(), 1); // store p as the first point in list points.push_front( p); } else // append p to the end of the list points.push_back( p); } template < class InputIterator > void insert( InputIterator first, InputIterator last) { for ( ; first != last; ++first) insert( *first); } void clear( ) { points.erase( points.begin(), points.end()); n_support_points = 0; tco.ellipse.set(); } // Validity check // -------------- bool is_valid( bool verbose = false, int level = 0) const { CGAL_USING_NAMESPACE_STD CGAL::Verbose_ostream verr( verbose); verr << endl; verr << "CGAL::Min_ellipse_2::" << endl; verr << "is_valid( true, " << level << "):" << endl; verr << " |P| = " << number_of_points() << ", |S| = " << number_of_support_points() << endl; // containment check (a) verr << " a) containment check..." << flush; Point_iterator point_iter; for ( point_iter = points_begin(); point_iter != points_end(); ++point_iter) if ( has_on_unbounded_side( *point_iter)) return( CGAL::_optimisation_is_valid_fail( verr, "ellipse does not contain all points")); verr << "passed." << endl; // support set checks (b)+(c) (not yet implemented) // alternative support set check verr << " +) support set check..." << flush; Support_point_iterator support_point_iter; for ( support_point_iter = support_points_begin(); support_point_iter != support_points_end(); ++support_point_iter) if ( ! has_on_boundary( *support_point_iter)) return( CGAL::_optimisation_is_valid_fail( verr, "ellipse does not have all \ support points on the boundary")); verr << "passed." << endl; verr << " object is valid!" << endl; return( true); } // Miscellaneous // ------------- inline const Traits& traits( ) const { return( tco); } }; // Function declarations // ===================== // I/O // --- template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_ellipse_2& me); template < class Traits_ > std::istream& operator >> ( std::istream& is, Min_ellipse_2& me); CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_MIN_ELLIPSE_2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_verte0000644000175000017500000000715011344301501031462 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DS_VERTEX_2_H #define CGAL_TRIANGULATION_DS_VERTEX_2_H #include #include CGAL_BEGIN_NAMESPACE template class Triangulation_ds_vertex_2 : public Vb { typedef typename Vb::Triangulation_data_structure Tds; public: typedef typename Tds::size_type size_type; typedef typename Tds::difference_type difference_type; typedef typename Tds::Vertex Vertex; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Vertex_circulator Vertex_circulator; typedef typename Tds::Face_circulator Face_circulator; typedef typename Tds::Edge_circulator Edge_circulator; //CREATORS Triangulation_ds_vertex_2() : Vb() {} //ACCESS size_type degree(); //should be const //Deprecated access to circulators - for bacward compatibility // the following should be const // when Face_circulator, Vertex_circulator and Edge_circulator // are created from // Face_const_handle and Face_const_vertex Vertex_circulator incident_vertices() {return Vertex_circulator(handle());} Vertex_circulator incident_vertices( Face_handle f) {return Vertex_circulator(handle(),f);} Face_circulator incident_faces() { return Face_circulator(handle()) ;} Face_circulator incident_faces( Face_handle f) { return Face_circulator(handle(), f);} Edge_circulator incident_edges() { return Edge_circulator(handle());} Edge_circulator incident_edges( Face_handle f) { return Edge_circulator(handle(), f);} bool is_valid(bool verbose = false, int level = 0); private: // used to implement deprected access to circulators Vertex_handle handle(); }; template typename Triangulation_ds_vertex_2 ::size_type Triangulation_ds_vertex_2 :: degree() //const { int count = 0; Vertex_circulator vc = incident_vertices(), done(vc); if ( ! vc.is_empty()) { do { count += 1; } while (++vc != done); } return count; } template typename Triangulation_ds_vertex_2::Vertex_handle Triangulation_ds_vertex_2 :: handle() { Face_handle fh = this->face(); for(int i = 0 ; i < 3 ; ++i){ if ( &*fh->vertex(i) == this) return fh->vertex(i); } return Vertex_handle(); } template bool Triangulation_ds_vertex_2 :: is_valid(bool verbose, int level) { bool result = Vb::is_valid(verbose, level); CGAL_triangulation_assertion(result); if (this->face() != Face_handle()) { // face==NULL if dim <0 result = result && ( &*this->face()->vertex(0) == this || &*this->face()->vertex(1) == this || &*this->face()->vertex(2) == this ); } CGAL_triangulation_assertion(result); return result; } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_DS_VERTEX_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_eddy.C0000644000175000017500000001025611344301500026527 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_eddy.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_EDDY_C #define CGAL_CH_EDDY_C #ifndef CGAL_CH_EDDY_H #include #endif // CGAL_CH_EDDY_H #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template void ch__recursive_eddy(List& L, ListIterator a_it, ListIterator b_it, const Traits& ch_traits) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Less_signed_distance_to_line_2 Less_dist; Left_turn_2 left_turn = ch_traits.left_turn_2_object(); CGAL_ch_precondition( \ std::find_if(a_it, b_it, \ bind_1(bind_1(left_turn, *b_it), *a_it)) \ != b_it ); ListIterator f_it = successor(a_it); Less_dist less_dist = ch_traits.less_signed_distance_to_line_2_object(); ListIterator c_it = std::min_element( f_it, b_it, // max before bind_1(bind_1(less_dist, *a_it), *b_it)); Point_2 c = *c_it; c_it = std::partition(f_it, b_it, bind_1(bind_1(left_turn, c), *a_it)); f_it = std::partition(c_it, b_it, bind_1(bind_1(left_turn, *b_it), c)); c_it = L.insert(c_it, c); L.erase( f_it, b_it ); if ( successor(a_it) != c_it ) { ch__recursive_eddy( L, a_it, c_it, ch_traits); } if ( successor(c_it) != b_it ) { ch__recursive_eddy( L, c_it, b_it, ch_traits); } } template OutputIterator ch_eddy(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits) { typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Equal_2 Equal_2; Left_turn_2 left_turn = ch_traits.left_turn_2_object(); Equal_2 equal_points = ch_traits.equal_2_object(); if (first == last) return result; std::list< Point_2 > L; std::copy( first, last, std::back_inserter(L) ); typedef typename std::list< Point_2 >::iterator list_iterator; list_iterator w, e; ch_we_point(L.begin(), L.end(), w, e, ch_traits); Point_2 wp = *w; Point_2 ep = *e; if (equal_points(wp,ep) ) { *result = wp; ++result; return result; } L.erase(w); L.erase(e); e = std::partition(L.begin(), L.end(), bind_1(bind_1(left_turn, ep), wp) ); L.push_front(wp); e = L.insert(e, ep); if ( successor(L.begin()) != e ) { ch__recursive_eddy( L, L.begin(), e, ch_traits); } w = std::find_if( e, L.end(), bind_1(bind_1(left_turn, wp), ep) ); if ( w == L.end() ) { L.erase( ++e, L.end() ); return std::copy( L.begin(), L.end(), result ); } w = L.insert(L.end(), wp); ch__recursive_eddy( L, e, w, ch_traits); CGAL_ch_postcondition( \ is_ccw_strongly_convex_2( L.begin(), w, ch_traits) ); CGAL_ch_expensive_postcondition( \ ch_brute_force_check_2( first, last, \ L.begin(), w, ch_traits ) ); return std::copy( L.begin(), w, result ); } CGAL_END_NAMESPACE #endif // CGAL_CH_EDDY_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2.C0000644000175000017500000001212311344301500026773 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink #include //-----------------------------------------------------------------------// // operator== //-----------------------------------------------------------------------// CGAL_BEGIN_NAMESPACE namespace i_polygon { template class Equal_pred { Equal_2 m_equal_2; Point_2 m_pt; public: Equal_pred(Equal_2 equal_2, Point_2 const &pt) : m_equal_2(equal_2), m_pt(pt) {} bool operator()(Point_2 const &pt) const { return m_equal_2(m_pt, pt); } }; } template bool operator==( const Polygon_2 &x, const Polygon_2 &y ) { if (&x == &y) return true; typedef typename Traits_P::Equal_2 Equal_2; typedef typename Traits_P::Point_2 Point_2; // CGAL_polygon_precondition( (x.size() != 0) || (y.size() != 0)); if ((x.size() == 0) && (y.size() == 0)) return true; if (x.size() != y.size()) return false; Equal_2 equal_2 = x.traits_member().equal_2_object(); typename Polygon_2::Vertex_const_iterator x_iter = x.vertices_begin(); typename Polygon_2::Vertex_const_iterator y_iter = std::find_if(y.vertices_begin(), y.vertices_end(), i_polygon::Equal_pred(equal_2, *x.vertices_begin())); // if y doesn't contain the first point of x ... if (y_iter == y.vertices_end()) return false; ++x_iter; ++y_iter; while (y_iter != y.vertices_end()) { if (!equal_2(*x_iter, *y_iter)) return false; ++x_iter; ++y_iter; } y_iter = y.vertices_begin(); while (x_iter != x.vertices_end()) { if (!equal_2(*x_iter, *y_iter)) return false; ++x_iter; ++y_iter; } return true; } //-----------------------------------------------------------------------// // operator>> //-----------------------------------------------------------------------// template std::istream &operator>>(std::istream &is, Polygon_2& p) { int n; // number of vertices is >> n; typename Traits_P::Point_2 point; if (is) { p.erase(p.vertices_begin(),p.vertices_end()); for (int i=0; i> point; p.push_back(point); } } return is; } //-----------------------------------------------------------------------// // operator<< //-----------------------------------------------------------------------// template std::ostream &operator<<(std::ostream &os, const Polygon_2& p) { typename Polygon_2::Vertex_const_iterator i; switch(os.iword(IO::mode)) { case IO::ASCII : os << p.size() << ' '; for (i = p.vertices_begin(); i != p.vertices_end(); ++i) { os << *i << ' '; } return os; case IO::BINARY : os << p.size(); for (i = p.vertices_begin(); i != p.vertices_end(); ++i) { os << *i; } return os; default: os << "Polygon_2(" << std::endl; for (i = p.vertices_begin(); i != p.vertices_end(); ++i) { os << " " << *i << std::endl; } os << ")" << std::endl; return os; } } CGAL_END_NAMESPACE //-----------------------------------------------------------------------// // transform //-----------------------------------------------------------------------// #ifdef CGAL_REP_CLASS_DEFINED CGAL_BEGIN_NAMESPACE template Polygon_2 transform(const Transformation& t, const Polygon_2& p) { typedef typename Polygon_2::Vertex_const_iterator VI; Polygon_2 result; for (VI i = p.vertices_begin(); i != p.vertices_end(); ++i) result.push_back(t(*i)); return result; } CGAL_END_NAMESPACE #endif // CGAL_REP_CLASS_DEFINED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Rotation_tree_2.h0000644000175000017500000001307211344301500030233 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Rotation_tree_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert /* A rotation tree for computing the vertex visibility graph of a set of non-intersecting segments in the plane (e.g. edges of a polygon). Let $V$ be the set of segment endpoints and let $p_{\infinity}$ ($p_{-\infinity}$) be a point with $y$ coordinate $\infinity$ ($-\infinity$) and $x$ coordinate larger than all points in $V$. The tree $G$ is a tree with node set $V \cup \{p_{\infinity}, p_{-\infinity}\}$. Every node (except the one corresponding to $p_{\infinity}$) has exactly one outgoing edge to the point $q$ with the following property: $q$ is the first point encountered when looking from $p$ in direction $d$ and rotating counterclockwise. */ #ifndef CGAL_ROTATION_TREE_H #define CGAL_ROTATION_TREE_H // MSVC6 doesn't work with the CGALi::vector but it does with the std::vector // (from stlport?) #if (defined( _MSC_VER) && (_MSC_VER <= 1200)) || defined(__BORLANDC__) #include #else #include #endif // MSVC6 #include #include namespace CGAL { template #if (defined( _MSC_VER) && (_MSC_VER <= 1200)) || defined(__BORLANDC__) class Rotation_tree_2 : public std::vector< Rotation_tree_node_2 > #else class Rotation_tree_2 : public CGALi::vector< Rotation_tree_node_2 > #endif // MSVC 6 { public: typedef Traits_ Traits; typedef Rotation_tree_node_2 Node; #if (defined( _MSC_VER) && (_MSC_VER <= 1200)) || defined(__BORLANDC__) typedef typename std::vector::iterator Self_iterator; #else typedef typename CGALi::vector::iterator Self_iterator; #endif // MSVC6 typedef typename Traits::Point_2 Point_2; // constructor template Rotation_tree_2(ForwardIterator first, ForwardIterator beyond) { for (ForwardIterator it = first; it != beyond; it++) push_back(*it); std::sort(this->begin(), this->end(), swap_1(Traits().less_xy_2_object())); std::unique(this->begin(), this->end()); // front() is the point with the largest x coordinate // push the point p_minus_infinity; the coordinates should never be used push_back(Point_2( 1, -1)); // push the point p_infinity; the coordinates should never be used push_back(Point_2(1, 1)); _p_inf = this->end(); // record the iterators to these extreme points _p_inf--; _p_minus_inf = _p_inf; _p_minus_inf--; Self_iterator child; // make p_minus_inf a child of p_inf set_rightmost_child(_p_minus_inf, _p_inf); child = this->begin(); // now points to p_0 while (child != _p_minus_inf) // make all points children of p_minus_inf { set_rightmost_child(child, _p_minus_inf); child++; } } // the point that comes first in the right-to-left ordering is first // in the ordering, after the auxilliary points p_minus_inf and p_inf Self_iterator rightmost_point_ref() { return this->begin(); } Self_iterator right_sibling(Self_iterator p) { if (!(*p).has_right_sibling()) return this->end(); return (*p).right_sibling(); } Self_iterator left_sibling(Self_iterator p) { if (!(*p).has_left_sibling()) return this->end(); return (*p).left_sibling(); } Self_iterator rightmost_child(Self_iterator p) { if (!(*p).has_children()) return this->end(); return (*p).rightmost_child(); } Self_iterator parent(Self_iterator p) { if (!(*p).has_parent()) return this->end(); return (*p).parent(); } bool parent_is_p_infinity(Self_iterator p) { return parent(p) == _p_inf; } bool parent_is_p_minus_infinity(Self_iterator p) { return parent(p) == _p_minus_inf; } // makes *p the parent of *q void set_parent (Self_iterator p, Self_iterator q) { CGAL_assertion(q != this->end()); if (p == this->end()) (*q).clear_parent(); else (*q).set_parent(p); } // makes *p the rightmost child of *q void set_rightmost_child(Self_iterator p, Self_iterator q); // makes *p the left sibling of *q void set_left_sibling(Self_iterator p, Self_iterator q); // makes *p the right sibling of *q void set_right_sibling(Self_iterator p, Self_iterator q); // NOTE: this function does not actually remove the node p from the // list; it only reorganizes the pointers so this node is not // in the tree structure anymore void erase(Self_iterator p); private: Self_iterator _p_inf; Self_iterator _p_minus_inf; }; } #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_ROTATION_TREE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters.h0000644000175000017500000001120111344301501030144 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Static_filters.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_STATIC_FILTERS_H #define CGAL_STATIC_FILTERS_H // This kernel wrapper gathers optimized predicates written by hand, using // a few steps of filtering. It should work if the initial traits has // cartesian coordinates which fit exactly in doubles. // // Purely static filters code has been removed, since it requires additional // logic and is not plug'n play (requires users providing bounds). // If it should be provided again, it should probably be separate. #include #include #include #include #include #include #include #include // #include // #include // TODO : // - aim at obsoleting Filtered_exact, so that // Exact_predicates_inexact_constructions_kernel becomes Filtered_kernel. // - Is Fixed_precision_nt now obsolete ? If yes, deprecate it. // - add more predicates : // - lexicographical comparisons // - left_turn (via generic adapter to orientation) // - power_tests // - others ? // - benchmark on more algorithms. // - improve fit_in_double() for other NTs (MP_Float, Lazy). cf tools.h. // - try to automatize : have a struct a la Static_filter_error, with one part // which is runtime, and the other which can be constant-propagated by the // compiler. g++ 4.0 should be able to cprop the second part... CGAL_BEGIN_NAMESPACE // The K_base argument is supposed to provide exact primitives. template < typename K_base > class Static_filters : public K_base { typedef Static_filters Self; public: typedef CommonKernelFunctors::Left_turn_2 Left_turn_2; typedef CartesianKernelFunctors::Less_xy_2 Less_xy_2; typedef CartesianKernelFunctors::Less_yx_2 Less_yx_2; typedef SF_Orientation_2 Orientation_2; typedef SF_Orientation_3 Orientation_3; typedef SF_Side_of_oriented_circle_2 Side_of_oriented_circle_2; typedef SF_Side_of_oriented_sphere_3 Side_of_oriented_sphere_3; Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Orientation_3 orientation_3_object() const { return Orientation_3(); } Side_of_oriented_circle_2 side_of_oriented_circle_2_object() const { return Side_of_oriented_circle_2(); } Side_of_oriented_sphere_3 side_of_oriented_sphere_3_object() const { return Side_of_oriented_sphere_3(); } // The two following are for degenerate cases, so I'll update them later. // // typedef SF_Coplanar_orientation_3 // Coplanar_orientation_3; // typedef SF_Side_of_bounded_circle_3 // Coplanar_side_of_bounded_circle_3; // Coplanar_orientation_3 // coplanar_orientation_3_object() const // { return Coplanar_orientation_3(); } // Coplanar_side_of_bounded_circle_3 // coplanar_side_of_bounded_circle_3_object() const // { return Coplanar_side_of_bounded_circle_3(); } }; CGAL_END_NAMESPACE #endif // CGAL_STATIC_FILTERS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2_1.h0000644000175000017500000000325511344301500030345 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2_1.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTION_2_1_H #define CGAL_INTERSECTION_2_1_H #include #include #include #include #include #include #include #include #include #include #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_nearest_neighbor.h0000644000175000017500000001526211344301500031151 0ustar debiandebian// Copyright (c) 2004 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_nearest_neighbor.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Idit Haran #ifndef CGAL_PM_NEAREST_NEIGHBOR_H #define CGAL_PM_NEAREST_NEIGHBOR_H //#define CGAL_PM_WALK_DEBUG //#define CGAL_LM_DEBUG //---------------------------------------------------------- //Pm includes //---------------------------------------------------------- #include //#include //#include //#include //#include //#include //#include #include #include #include #include #include //#define CGAL_LM_DEBUG CGAL_BEGIN_NAMESPACE /*! This is a model for the concept: nearest neigbor for landmarks point location. It is the nearest neighbor algorithm, that should be changed easily */ template class Pm_nearest_neighbor { public: typedef typename Planar_map::Vertex_handle Vertex_handle; class NN_Point_2 { public: NN_Point_2() { vec[0]= vec[1] = 0; } NN_Point_2 (double x, double y) { vec[0]=x; vec[1]=y; } NN_Point_2 (double x, double y, Vertex_handle vh) { vec[0]=x; vec[1]=y; vert = vh; } double x() const { return vec[ 0 ]; } double y() const { return vec[ 1 ]; } Vertex_handle vertex() const { return vert; } double& x() { return vec[ 0 ]; } double& y() { return vec[ 1 ]; } Vertex_handle vertex() {return vert; } bool operator==(const NN_Point_2& p) const { return (x() == p.x()) && (y() == p.y() && vertex() == p.vertex()) ; } bool operator!=(const NN_Point_2& p) const { return ! (*this == p); } double vec[2]; Vertex_handle vert; }; //end of class class Construct_coord_iterator { public: const double* operator()(const NN_Point_2& p) const { return static_cast(p.vec); } const double* operator()(const NN_Point_2& p, int) const { return static_cast(p.vec+2); } }; //---------------------------------------------------------- // Types //---------------------------------------------------------- typedef CGAL::Search_traits Traits; typedef CGAL::Orthogonal_k_neighbor_search Neighbor_search; typedef typename Neighbor_search::iterator Neighbor_iterator; typedef typename Neighbor_search::Tree Tree; typedef std::list Point_list; typedef typename Point_list::const_iterator Input_iterator; typedef Pm_nearest_neighbor Self; //---------------------------------------------------------- public: /*! Constructor */ Pm_nearest_neighbor() : tree(0), b_valid_tree(false) { #ifdef CGAL_LM_DEBUG std::cout << "constructor of nearest neighbor " << std::endl; #endif } /*! Distructor - must be because we allocated a tree */ ~Pm_nearest_neighbor() { if (b_valid_tree && tree){ #ifdef CGAL_LM_DEBUG std::cout << "~: deleting the tree. tree = " << tree ; std::cout << "size = " << tree->size() << std::endl; //tree->statistics(std::cout); #endif delete tree; } b_valid_tree = false; tree = 0; } /*! init should allocate the tree and initialize it with all points. it will be better if we could create a blank tree, and afterwards add points to it */ void init(Input_iterator begin, Input_iterator beyond) { if (b_valid_tree || tree) { std::cerr << "ERROR: init - tree exists" << std::endl; return; } if (begin == beyond) { #ifdef CGAL_LM_DEBUG std::cout << "empty list" << std::endl; #endif } else { #ifdef CGAL_LM_DEBUG std::cout << "allocating a new tree" << std::endl; #endif tree = new Tree(begin, beyond); b_valid_tree = true; } } /*! clean - deletes the tree in order to create a new one later */ void clean() { if (b_valid_tree && tree){ #ifdef CGAL_LM_DEBUG std::cout << "~: deleting the tree. tree = " << tree ; std::cout << "size = " << tree->size() << std::endl; //tree->statistics(std::cout); #endif delete tree; #ifdef CGAL_LM_DEBUG std::cout << "after deleting the tree" << std::endl; #endif } else { #ifdef CGAL_LM_DEBUG std::cout << "no tree to clean" << std::endl; #endif } b_valid_tree = false; tree = 0; } //Point_2 & find_nearest_neighbor(/*Point_2 & query*/) NN_Point_2 find_nearest_neighbor(const NN_Point_2 & query) const { #ifdef CGAL_LM_DEBUG std::cout << "finding nearest neighbor of "<< query.x() <<' ' <first).x()<<' '<<(it->first).y()<< std::endl; #endif } return (search.begin()->first); } /*! ixx: should be implemented */ //void insert_point(Point_2 & p) { } /*! ixx: should be implemented */ //void insert_points(Point_list & p_list) { } protected: Tree * tree; bool b_valid_tree; public: /*! Copy Constructor. */ Pm_nearest_neighbor(const Self & nn) : tree(0), b_valid_tree(false) { std::cout << "nn copy contructor" << std::endl; *this = nn; } /*! Assignment Operator */ Self & operator=(const Self & nn) { std::cout << "nn operator =" << std::endl; if (this == &nn) return (*this); if (tree != 0) delete tree; tree = 0; b_valid_tree = false; if (nn.b_valid_tree) { tree = new Tree (*(nn.tree)); b_valid_tree = true; } return (*this); } }; CGAL_END_NAMESPACE #endif //CGAL_PM_NEAREST_NEIGHBOR_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Tree_assertions.h0000644000175000017500000002726611344301501030360 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Tree_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef CGAL_TREE_ASSERTIONS_H #define CGAL_TREE_ASSERTIONS_H #ifndef CGAL_ASSERTIONS_H # include #endif // macro definitions // ================= // assertions // ---------- #if defined(CGAL_TREE_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_Tree_assertion(EX) ((void)0) # define CGAL_Tree_assertion_msg(EX,MSG) ((void)0) # define CGAL_Tree_assertion_code(CODE) #else # define CGAL_Tree_assertion(EX) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_assertion_msg(EX,MSG) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_assertion_code(CODE) CODE #endif // CGAL_TREE_NO_ASSERTIONS #if defined(CGAL_TREE_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_Tree_exactness_assertion(EX) ((void)0) # define CGAL_Tree_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_Tree_exactness_assertion_code(CODE) #else # define CGAL_Tree_exactness_assertion(EX) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_exactness_assertion_code(CODE) CODE #endif // CGAL_TREE_NO_ASSERTIONS #if defined(CGAL_TREE_NO_ASSERTIONS) \ || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_assertion(EX) ((void)0) # define CGAL_Tree_expensive_assertion_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_assertion_code(CODE) #else # define CGAL_Tree_expensive_assertion(EX) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_assertion_msg(EX,MSG) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_assertion_code(CODE) CODE #endif // CGAL_TREE_NO_ASSERTIONS #if defined(CGAL_TREE_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_exactness_assertion(EX) ((void)0) # define CGAL_Tree_expensive_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_exactness_assertion_code(CODE) #else # define CGAL_Tree_expensive_exactness_assertion(EX) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0):assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_exactness_assertion_code(CODE) CODE #endif // CGAL_TREE_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_TREE_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_Tree_precondition(EX) ((void)0) # define CGAL_Tree_precondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_precondition_code(CODE) #else # define CGAL_Tree_precondition(EX) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_precondition_msg(EX,MSG) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_precondition_code(CODE) CODE #endif // CGAL_TREE_NO_PRECONDITIONS #if defined(CGAL_TREE_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_Tree_exactness_precondition(EX) ((void)0) # define CGAL_Tree_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_exactness_precondition_code(CODE) #else # define CGAL_Tree_exactness_precondition(EX) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_exactness_precondition_code(CODE) CODE #endif // CGAL_TREE_NO_PRECONDITIONS #if defined(CGAL_TREE_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_precondition(EX) ((void)0) # define CGAL_Tree_expensive_precondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_precondition_code(CODE) #else # define CGAL_Tree_expensive_precondition(EX) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_precondition_msg(EX,MSG) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_precondition_code(CODE) CODE #endif // CGAL_TREE_NO_PRECONDITIONS #if defined(CGAL_TREE_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_exactness_precondition(EX) ((void)0) # define CGAL_Tree_expensive_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_exactness_precondition_code(CODE) #else # define CGAL_Tree_expensive_exactness_precondition(EX) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0):precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_exactness_precondition_code(CODE) CODE #endif // CGAL_TREE_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_TREE_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_Tree_postcondition(EX) ((void)0) # define CGAL_Tree_postcondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_postcondition_code(CODE) #else # define CGAL_Tree_postcondition(EX) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_postcondition_msg(EX,MSG) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_postcondition_code(CODE) CODE #endif // CGAL_TREE_NO_POSTCONDITIONS #if defined(CGAL_TREE_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_Tree_exactness_postcondition(EX) ((void)0) # define CGAL_Tree_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_exactness_postcondition_code(CODE) #else # define CGAL_Tree_exactness_postcondition(EX) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_exactness_postcondition_code(CODE) CODE #endif // CGAL_TREE_NO_POSTCONDITIONS #if defined(CGAL_TREE_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_postcondition(EX) ((void)0) # define CGAL_Tree_expensive_postcondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_postcondition_code(CODE) #else # define CGAL_Tree_expensive_postcondition(EX) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_postcondition_msg(EX,MSG) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_postcondition_code(CODE) CODE #endif // CGAL_TREE_NO_POSTCONDITIONS #if defined(CGAL_TREE_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_exactness_postcondition(EX) ((void)0) # define CGAL_Tree_expensive_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_exactness_postcondition_code(CODE) #else # define CGAL_Tree_expensive_exactness_postcondition(EX) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0):postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_exactness_postcondition_code(CODE) CODE #endif // CGAL_TREE_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_TREE_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_Tree_warning(EX) ((void)0) # define CGAL_Tree_warning_msg(EX,MSG) ((void)0) # define CGAL_Tree_warning_code(CODE) #else # define CGAL_Tree_warning(EX) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_warning_msg(EX,MSG) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_warning_code(CODE) CODE #endif // CGAL_TREE_NO_WARNINGS #if defined(CGAL_TREE_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_Tree_exactness_warning(EX) ((void)0) # define CGAL_Tree_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_Tree_exactness_warning_code(CODE) #else # define CGAL_Tree_exactness_warning(EX) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_exactness_warning_code(CODE) CODE #endif // CGAL_TREE_NO_WARNINGS #if defined(CGAL_TREE_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_warning(EX) ((void)0) # define CGAL_Tree_expensive_warning_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_warning_code(CODE) #else # define CGAL_Tree_expensive_warning(EX) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_warning_msg(EX,MSG) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_warning_code(CODE) CODE #endif // CGAL_TREE_NO_WARNINGS #if defined(CGAL_TREE_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_TREE_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_TREE_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_Tree_expensive_exactness_warning(EX) ((void)0) # define CGAL_Tree_expensive_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_Tree_expensive_exactness_warning_code(CODE) #else # define CGAL_Tree_expensive_exactness_warning(EX) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_Tree_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0):warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_Tree_expensive_exactness_warning_code(CODE) CODE #endif // CGAL_TREE_NO_WARNINGS #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_0000644000175000017500000000634311344301500031460 0ustar debiandebian// Copyright (c) 1997-2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_d_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_OPTIMISATION_D_TRAITS_2_H #define CGAL_OPTIMISATION_D_TRAITS_2_H // includes #ifndef CGAL_OPTIMISATION_ACCESS_DIMENSION_2_H # include #endif #ifndef CGAL_OPTIMISATION_ACCESS_COORDINATES_BEGIN_2_H # include #endif #ifndef CGAL_OPTIMISATION_CONSTRUCT_POINT_2_H # include #endif CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class K_, class ET_ = typename K_::RT, class NT_ = typename K_::RT > class Optimisation_d_traits_2; // Class interface // =============== template < class K_, class ET_, class NT_> class Optimisation_d_traits_2 { public: // self typedef K_ K; typedef ET_ ET; typedef NT_ NT; typedef Optimisation_d_traits_2 Self; // types typedef typename K::Point_2 Point_d; typedef typename K::Rep_tag Rep_tag; typedef typename K::RT RT; typedef typename K::FT FT; typedef CGAL::Access_dimension_2 Access_dimension_d; typedef CGAL::Access_coordinates_begin_2 Access_coordinates_begin_d; // this does not (yet) work: // typedef typename K::Construct_point_2 Construct_point_d; typedef _Construct_point_2 Construct_point_d; // creation Optimisation_d_traits_2( ) { } Optimisation_d_traits_2( const Optimisation_d_traits_2&) {} // operations Access_dimension_d access_dimension_d_object( ) const { return Access_dimension_d(); } Access_coordinates_begin_d access_coordinates_begin_d_object( ) const { return Access_coordinates_begin_d(); } Construct_point_d construct_point_d_object( ) const { return Construct_point_d(); } }; CGAL_END_NAMESPACE #endif // CGAL_OPTIMISATION_D_TRAITS_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_assertions.h0000644000175000017500000003113211344301500031454 0ustar debiandebian// Copyright (c) 1997 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_assertions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : script by Geert-Jan Giezeman and Sven Schoenherr // macro definitions // ================= // assertions // ---------- #if defined(CGAL_PARTITION_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || defined(NDEBUG) # define CGAL_partition_assertion(EX) ((void)0) # define CGAL_partition_assertion_msg(EX,MSG) ((void)0) # define CGAL_partition_assertion_code(CODE) #else # define CGAL_partition_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_assertion_code(CODE) CODE #endif // CGAL_PARTITION_NO_ASSERTIONS #if defined(CGAL_PARTITION_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_partition_exactness_assertion(EX) ((void)0) # define CGAL_partition_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_partition_exactness_assertion_code(CODE) #else # define CGAL_partition_exactness_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_exactness_assertion_code(CODE) CODE #endif // CGAL_PARTITION_NO_ASSERTIONS #if defined(CGAL_PARTITION_NO_ASSERTIONS) \ || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_assertion(EX) ((void)0) # define CGAL_partition_expensive_assertion_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_assertion_code(CODE) #else # define CGAL_partition_expensive_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_assertion_code(CODE) CODE #endif // CGAL_PARTITION_NO_ASSERTIONS #if defined(CGAL_PARTITION_NO_ASSERTIONS) || defined(CGAL_NO_ASSERTIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_exactness_assertion(EX) ((void)0) # define CGAL_partition_expensive_exactness_assertion_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_exactness_assertion_code(CODE) #else # define CGAL_partition_expensive_exactness_assertion(EX) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_exactness_assertion_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::assertion_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_exactness_assertion_code(CODE) CODE #endif // CGAL_PARTITION_NO_ASSERTIONS // preconditions // ------------- #if defined(CGAL_PARTITION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || defined(NDEBUG) # define CGAL_partition_precondition(EX) ((void)0) # define CGAL_partition_precondition_msg(EX,MSG) ((void)0) # define CGAL_partition_precondition_code(CODE) #else # define CGAL_partition_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_precondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_PRECONDITIONS #if defined(CGAL_PARTITION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_partition_exactness_precondition(EX) ((void)0) # define CGAL_partition_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_partition_exactness_precondition_code(CODE) #else # define CGAL_partition_exactness_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_exactness_precondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_PRECONDITIONS #if defined(CGAL_PARTITION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_precondition(EX) ((void)0) # define CGAL_partition_expensive_precondition_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_precondition_code(CODE) #else # define CGAL_partition_expensive_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_precondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_PRECONDITIONS #if defined(CGAL_PARTITION_NO_PRECONDITIONS) || defined(CGAL_NO_PRECONDITIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_exactness_precondition(EX) ((void)0) # define CGAL_partition_expensive_exactness_precondition_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_exactness_precondition_code(CODE) #else # define CGAL_partition_expensive_exactness_precondition(EX) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_exactness_precondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::precondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_exactness_precondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_PRECONDITIONS // postconditions // -------------- #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || defined(NDEBUG) # define CGAL_partition_postcondition(EX) ((void)0) # define CGAL_partition_postcondition_msg(EX,MSG) ((void)0) # define CGAL_partition_postcondition_code(CODE) #else # define CGAL_partition_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_postcondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_POSTCONDITIONS #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_partition_exactness_postcondition(EX) ((void)0) # define CGAL_partition_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_partition_exactness_postcondition_code(CODE) #else # define CGAL_partition_exactness_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_exactness_postcondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_POSTCONDITIONS #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_postcondition(EX) ((void)0) # define CGAL_partition_expensive_postcondition_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_postcondition_code(CODE) #else # define CGAL_partition_expensive_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_postcondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_POSTCONDITIONS #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || defined(CGAL_NO_POSTCONDITIONS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_exactness_postcondition(EX) ((void)0) # define CGAL_partition_expensive_exactness_postcondition_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_exactness_postcondition_code(CODE) #else # define CGAL_partition_expensive_exactness_postcondition(EX) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_exactness_postcondition_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::postcondition_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_exactness_postcondition_code(CODE) CODE #endif // CGAL_PARTITION_NO_POSTCONDITIONS // warnings // -------- #if defined(CGAL_PARTITION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || defined(NDEBUG) # define CGAL_partition_warning(EX) ((void)0) # define CGAL_partition_warning_msg(EX,MSG) ((void)0) # define CGAL_partition_warning_code(CODE) #else # define CGAL_partition_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_warning_code(CODE) CODE #endif // CGAL_PARTITION_NO_WARNINGS #if defined(CGAL_PARTITION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || defined(NDEBUG) # define CGAL_partition_exactness_warning(EX) ((void)0) # define CGAL_partition_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_partition_exactness_warning_code(CODE) #else # define CGAL_partition_exactness_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_exactness_warning_code(CODE) CODE #endif // CGAL_PARTITION_NO_WARNINGS #if defined(CGAL_PARTITION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_warning(EX) ((void)0) # define CGAL_partition_expensive_warning_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_warning_code(CODE) #else # define CGAL_partition_expensive_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_warning_code(CODE) CODE #endif // CGAL_PARTITION_NO_WARNINGS #if defined(CGAL_PARTITION_NO_WARNINGS) || defined(CGAL_NO_WARNINGS) \ || (!defined(CGAL_PARTITION_CHECK_EXACTNESS) && !defined(CGAL_CHECK_EXACTNESS))\ || (!defined(CGAL_PARTITION_CHECK_EXPENSIVE) && !defined(CGAL_CHECK_EXPENSIVE)) \ || defined(NDEBUG) # define CGAL_partition_expensive_exactness_warning(EX) ((void)0) # define CGAL_partition_expensive_exactness_warning_msg(EX,MSG) ((void)0) # define CGAL_partition_expensive_exactness_warning_code(CODE) #else # define CGAL_partition_expensive_exactness_warning(EX) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, 0)) # define CGAL_partition_expensive_exactness_warning_msg(EX,MSG) \ ((EX)?((void)0): ::CGAL::warning_fail( # EX , __FILE__, __LINE__, MSG)) # define CGAL_partition_expensive_exactness_warning_code(CODE) CODE #endif // CGAL_PARTITION_NO_WARNINGS mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Join_input_iterator.h0000644000175000017500000000250211344301500031217 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Join_input_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete; use instead. #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Sun_fixes.h0000644000175000017500000000770211344301501027143 0ustar debiandebian// Copyright (c) 1997-2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Sun_fixes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Hoffmann (hoffmann@inf.ethz.ch) #ifndef CGAL_SUN_FIXES_H #define CGAL_SUN_FIXES_H 1 //----------------------------------------------------------------------// // if member templates for stdlib are not enabled // //----------------------------------------------------------------------// /* For reasons of binary backward compatibility, Sun CC does not enable member templates of the STL classes. An #undef creates runtime errors for some packages, so it is not a viable solution. Instead, we have to offer workarounds in CGAL code, whereever we use this feature. */ #include #if defined(RWSTD_NO_MEMBER_TEMPLATES) || defined(_RWSTD_NO_MEMBER_TEMPLATES) #define CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES #endif //----------------------------------------------------------------------// // fake iterator_traits // //----------------------------------------------------------------------// #include namespace std { template struct iterator_traits { typedef typename Iterator::value_type value_type; typedef typename Iterator::difference_type difference_type; typedef typename Iterator::pointer pointer; typedef typename Iterator::reference reference; typedef typename Iterator::iterator_category iterator_category; }; template struct iterator_traits { typedef T value_type; typedef ptrdiff_t difference_type; typedef T* pointer; typedef T& reference; typedef random_access_iterator_tag iterator_category; }; template struct iterator_traits { typedef T value_type; typedef ptrdiff_t difference_type; typedef const T* pointer; typedef const T& reference; typedef random_access_iterator_tag iterator_category; }; template inline ptrdiff_t distance (ForwardIterator first, ForwardIterator last) { ptrdiff_t n = 0; __distance(first, last, n, iterator_traits::iterator_category()); return n; } } // namespace std namespace CGAL { template < class T > inline typename T::value_type* __value_type (const T&) { return (typename T::value_type*)(0); } template < class T > inline typename T::difference_type* __distance_type(const T&) { return (typename T::difference_type*)(0); } template < class T > inline typename T::iterator_category __iterator_category (const T&) { typename T::iterator_category tmp; return tmp; } template < class T > inline T* __value_type(T*) { return (T*)(0); } template inline std::ptrdiff_t* __distance_type (T*) { return (std::ptrdiff_t*)(0); } template inline std::random_access_iterator_tag __iterator_category (T*) { return std::random_access_iterator_tag(); } } // namespace CGAL #endif // CGAL_SUN_FIXES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Fixed_precision_nt.h0000644000175000017500000010002511344301500031002 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Fixed_precision_nt.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Olivier Devillers #ifndef CGAL_FIXED_PRECISION_NT_H #define CGAL_FIXED_PRECISION_NT_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Fixed_precision_nt implement 24 bits integers using float // The user has to initiate a multiplicator factor to be applied to // original data. // ====================================================================== //--------- static variables declaration and initialization // ====================================================================== // static marks to decide if perturbation are used static bool Fixed_incircle_perturb= false; static bool Fixed_insphere_perturb= false; ////// degree 0 constant static double Fixed_Or2 = 3.0/9007199254740992.0; // 3/2^53 semi-static orientation filter static double Fixed_Ic2 = 3.0/9007199254740992.0; // 3/2^54 semi-static incircle filter static double Fixed_Is2 = 6.0 / 18014398509481984.0; // 6/2^54 semi-static insphere filter ////// degree 1 constant static double Fixed_B0=0.0; // precision on coordinates // assumed to be 1.0 to fix value below static double Fixed_B24 = 16777216.0; // 2^24 bound on coordinates static double Fixed_SNAP = 6755399441055744.0; // 3 * 2^51 for rounding of coordinates ////// degree 2 constant static double Fixed_S_2_25= 453347182355485940514816.0; // 3 * 2^77 split to bit B0^2 * 2^25 ////// degree 3 constant static double Fixed_S_3_25= Fixed_S_2_25; // 3 * 2^77 split to bit B0^3 * 2^25 static double Fixed_S_3_51= 30423614405477505635920876929024.0; // 3 * 2^103 split to bit B0^3 * 2^51 static double Fixed_Or1 = 37748736.0; // 9*2^22 static error for orientation filter static double Fixed_Bx3 = 0.5; // 2^(-1) half degree 3 unit for semi-static filter ////// degree 4 constant static double Fixed_Ic1 = 2533274790395904.0; // 9*2^48; static error for incircle filter static double Fixed_Bx4 = 0.5; // 2^(-1) half degree 4 unit for semi-static filter ////// degree 5 constant static double Fixed_Is1 = 1416709944860893564108800.0; // 75*2^74; static error for insphere filter static double Fixed_Bx5 = 0.5; // 2^(-1) half degree 5 unit for semi-static filter class Fixed_precision_nt { private: float _value; // value of the number // I put this function here so that GCC doesn't complain with -Winline. void round() {_value = ( _value+ Fixed_SNAP ) - Fixed_SNAP ;} public: typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_false Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; // constructors Fixed_precision_nt() {_value=0;} Fixed_precision_nt(const Fixed_precision_nt&f) {_value=f._value;} Fixed_precision_nt(double f) {_value=f; round(); } Fixed_precision_nt(int f) {_value=f; round(); } //access functions double to_double() const {return (double)_value;} float to_float() const {return _value;} // NT requirements Fixed_precision_nt operator= (const Fixed_precision_nt&f) {_value= f._value; return *this;} Fixed_precision_nt operator+=(const Fixed_precision_nt&f) {_value+=f._value; return *this;} Fixed_precision_nt operator-=(const Fixed_precision_nt&f) {_value-=f._value; return *this;} Fixed_precision_nt operator*=(const Fixed_precision_nt&f) {_value*=f._value; return *this;} Fixed_precision_nt operator/=(const Fixed_precision_nt&f) {_value/=f._value; return *this;} // access and parametrization of static members inline static bool init(float f); static float unit_value() {return Fixed_B0;} static float upper_bound(){return Fixed_B24;} static void perturb_incircle(){Fixed_incircle_perturb=true;} static void unperturb_incircle(){Fixed_incircle_perturb=false;} static bool is_perturbed_incircle(){return Fixed_incircle_perturb;} static void perturb_insphere(){Fixed_insphere_perturb=true;} static void unperturb_insphere(){Fixed_insphere_perturb=false;} static bool is_perturbed_insphere(){return Fixed_insphere_perturb;} }; inline double to_double(Fixed_precision_nt a){ return a.to_double(); } inline bool is_finite(Fixed_precision_nt) { return true; } inline bool is_valid(Fixed_precision_nt) { return true; } inline std::pair to_interval (Fixed_precision_nt a) { double d = a.to_double(); return std::make_pair(d,d); } inline Fixed_precision_nt operator- (Fixed_precision_nt a) { return Fixed_precision_nt( - (a.to_double()) );} inline Fixed_precision_nt operator+(Fixed_precision_nt a, Fixed_precision_nt b) { return Fixed_precision_nt(a.to_double() + b.to_double() );} inline Fixed_precision_nt operator-(Fixed_precision_nt a, Fixed_precision_nt b) { return Fixed_precision_nt(a.to_double() - b.to_double() );} inline Fixed_precision_nt operator*(Fixed_precision_nt a, Fixed_precision_nt b) { return Fixed_precision_nt(a.to_double() * b.to_double() );} inline Fixed_precision_nt operator/(Fixed_precision_nt a, Fixed_precision_nt b) { return Fixed_precision_nt(a.to_double() / b.to_double() );} inline bool operator< (Fixed_precision_nt a, Fixed_precision_nt b) { return (a.to_double() < b.to_double() );} inline bool operator<= (Fixed_precision_nt a, Fixed_precision_nt b) { return (a.to_double() <= b.to_double() );} inline bool operator> (Fixed_precision_nt a, Fixed_precision_nt b) { return (a.to_double() > b.to_double() );} inline bool operator>= (Fixed_precision_nt a, Fixed_precision_nt b) { return (a.to_double() >= b.to_double() );} inline bool operator== (Fixed_precision_nt a, Fixed_precision_nt b) { return (a.to_double() == b.to_double() );} inline bool operator!= (Fixed_precision_nt a, Fixed_precision_nt b) { return (a.to_double() != b.to_double() );} inline std::ostream &operator<<(std::ostream &os, const Fixed_precision_nt& a) { return os << a.to_double(); } inline std::istream &operator>>(std::istream &is, Fixed_precision_nt& a) { float f; is >>f; a=Fixed_precision_nt(f); return is; } // ====================================================================== //--------- non official mysterious NT requirement // ====================================================================== inline io_Operator io_tag(Fixed_precision_nt) { return io_Operator(); } // ====================================================================== //--------- initialize the upper bound on fixed // ====================================================================== inline bool Fixed_precision_nt::init(float b) // return true if init succeed false otherwise // Precondition : b positive // Precondition : non yet initialized // parameter b is the upper bound on absolute value on all entries { bool result = true; if (b<=0) b=-b; if (Fixed_B0!=0) result = false; float D = ((double) b) * 4503599627370497.0; //2^52 + 1 D = (((double) b)+D )-D ; // get the power of two closer to b if (D0) return LEFT_TURN; if (det) return RIGHT_TURN; /* the points are collinear */ return COLLINEAR; } inline Oriented_side side_of_oriented_circleC2 ( const Fixed_precision_nt& x0, const Fixed_precision_nt& y0, const Fixed_precision_nt& x1, const Fixed_precision_nt& y1, const Fixed_precision_nt& x2, const Fixed_precision_nt& y2, const Fixed_precision_nt& x3, const Fixed_precision_nt& y3) // relative position of p3 with respect to circle p0p1p2 // if p0p1p2 is positively oriented, // positive side is the interior of the circle { double X1=x1.to_double()-x0.to_double(); double Y1=y1.to_double()-y0.to_double(); double X2=x2.to_double()-x0.to_double(); double Y2=y2.to_double()-y0.to_double(); double X3=x3.to_double()-x0.to_double(); double Y3=y3.to_double()-y0.to_double(); double R1=X1*X1+Y1*Y1; double R2=X2*X2+Y2*Y2; double R3=X3*X3+Y3*Y3; double M1=X2*Y3-X3*Y2; double M2=X1*Y3-X3*Y1; double M3=X1*Y2-X2*Y1; double det= R1*M1 -R2*M2 +R3*M3; if (det > Fixed_Ic1) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Ic1) return ON_POSITIVE_SIDE; // static filter failed, error is small { double error= CGAL_NTS abs(R1*M1) + CGAL_NTS abs(R2*M2) + CGAL_NTS abs(R3*M3) ; error *= Fixed_Ic2 ; if ( error < Fixed_Bx4 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; double m1,m2,m3,r1,r2,r3; if (error!=0) { // dynamic filter failed, error is very small Fixed_split(M1,M1,m1,Fixed_S_2_25); Fixed_split(M2,M2,m2,Fixed_S_2_25); Fixed_split(M3,M3,m3,Fixed_S_2_25); // Minor i is Mi+mi Fixed_split(R1,R1,r1,Fixed_S_2_25); Fixed_split(R2,R2,r2,Fixed_S_2_25); Fixed_split(R3,R3,r3,Fixed_S_2_25); // xi^2+yi^2 is Ri+ri det = R1*M1 -R2*M2 +R3*M3 ; // most significant // exact because necessary less than 2^80 and multiple 2^52 det += (R1*m1 + r1*M1) - (R2*m2 + r2*M2) + (R3*m3 + r3*M3) ; // exact because necessary less than 2^53 and multiple 2^25 det += r1*m1 -r2*m2 +r3*m3 ; // less significant if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } //cocircular case if (! Fixed_incircle_perturb) return ON_ORIENTED_BOUNDARY; // apply perturbation method // first order coefficient is obtained replacing x^2+y^2 by xy R1 = X1*Y1; R2 = X2*Y2; R3 = X3*Y3; det= R1*M1 -R2*M2 +R3*M3; if (det > Fixed_Ic1) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Ic1) return ON_POSITIVE_SIDE; // static filter failed, error is small error= (CGAL_NTS abs(R1*M1)+CGAL_NTS abs(R2*M2)+CGAL_NTS abs(R3*M3)) * Fixed_Ic2 ; if ( error < Fixed_Bx4 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0) { // dynamic filter failed, error is very small Fixed_split(R1,R1,r1,Fixed_S_2_25); Fixed_split(R2,R2,r2,Fixed_S_2_25); Fixed_split(R3,R3,r3,Fixed_S_2_25); det = R1*M1 -R2*M2 +R3*M3 ; det += (R1*m1 + r1*M1) - (R2*m2 + r2*M2) + (R3*m3 + r3*M3) ; det += r1*m1 -r2*m2 +r3*m3 ; if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // first order coefficient is null, // compute second order coefficient in the pertrubation method // replace x^2+y^2 by y^2 R1 = Y1*Y1; R2 = Y2*Y2; R3 = Y3*Y3; det= R1*M1 -R2*M2 +R3*M3; if (det > Fixed_Ic1) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Ic1) return ON_POSITIVE_SIDE; // static filter failed, error is small error= (CGAL_NTS abs(R1*M1)+CGAL_NTS abs(R2*M2)+CGAL_NTS abs(R3*M3)) * Fixed_Ic2 ; if ( error < Fixed_Bx4 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0) { // dynamic filter failed, error is very small Fixed_split(R1,R1,r1,Fixed_S_2_25); Fixed_split(R2,R2,r2,Fixed_S_2_25); Fixed_split(R3,R3,r3,Fixed_S_2_25); det = R1*M1 -R2*M2 +R3*M3 ; det += (R1*m1 + r1*M1) - (R2*m2 + r2*M2) + (R3*m3 + r3*M3) ; det += r1*m1 -r2*m2 +r3*m3 ; if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // points are colinear return ON_ORIENTED_BOUNDARY; } } inline Comparison_result cmp_dist_to_pointC3( const Fixed_precision_nt& x0, const Fixed_precision_nt& y0, const Fixed_precision_nt& z0, const Fixed_precision_nt& x1, const Fixed_precision_nt& y1, const Fixed_precision_nt& z1, const Fixed_precision_nt& x2, const Fixed_precision_nt& y2, const Fixed_precision_nt& z2) { return CGAL_NTS compare( CGAL_NTS square(x0.to_double()-x1.to_double()) + CGAL_NTS square(y0.to_double()-y1.to_double()) + CGAL_NTS square(z0.to_double()-z1.to_double()), CGAL_NTS square(x0.to_double()-x2.to_double()) + CGAL_NTS square(y0.to_double()-y2.to_double()) + CGAL_NTS square(z0.to_double()-z2.to_double())); } inline Orientation orientationC3 ( const Fixed_precision_nt& x0, const Fixed_precision_nt& y0, const Fixed_precision_nt& z0, const Fixed_precision_nt& x1, const Fixed_precision_nt& y1, const Fixed_precision_nt& z1, const Fixed_precision_nt& x2, const Fixed_precision_nt& y2, const Fixed_precision_nt& z2, const Fixed_precision_nt& x3, const Fixed_precision_nt& y3, const Fixed_precision_nt& z3) { double X1=x1.to_double() -x0.to_double(); double Y1=y1.to_double() -y0.to_double(); double Z1=z1.to_double() -z0.to_double(); double X2=x2.to_double() -x0.to_double(); double Y2=y2.to_double() -y0.to_double(); double Z2=z2.to_double() -z0.to_double(); double X3=x3.to_double() -x0.to_double(); double Y3=y3.to_double() -y0.to_double(); double Z3=z3.to_double() -z0.to_double(); double M1=Y2*Z3-Y3*Z2; double M2=Y1*Z3-Y3*Z1; double M3=Y1*Z2-Y2*Z1; double det= X1*M1 - X2*M2 + X3*M3 ; if (det > Fixed_Or1 ) return POSITIVE; if (det < -Fixed_Or1 ) return NEGATIVE; /* det is small */ double error= CGAL_NTS abs(X1*M1) + CGAL_NTS abs(X2*M2) + CGAL_NTS abs(X3*M3); error *= Fixed_Or2; if ( error < Fixed_Bx3) error = 0.0; if (det > error) return POSITIVE; if (det < -error) return NEGATIVE; /* det is very small, exact computation must be done */ if (error!=0.0) { // otherwise, exact value 0 already certified Fixed_split(M1,M1,Z1,Fixed_S_2_25); Fixed_split(M2,M2,Z2,Fixed_S_2_25); Fixed_split(M3,M3,Z3,Fixed_S_2_25); det = X1*M1 - X2*M2 + X3*M3 ; det += X1*Z1 - X2*Z2 + X3*Z3 ; /* less significant */ if (det>0) return POSITIVE; if (det<0) return NEGATIVE; } /* points are coplanar */ return COPLANAR; } inline Oriented_side side_of_oriented_sphereC3 ( const Fixed_precision_nt& x0, const Fixed_precision_nt& y0, const Fixed_precision_nt& z0, const Fixed_precision_nt& x1, const Fixed_precision_nt& y1, const Fixed_precision_nt& z1, const Fixed_precision_nt& x2, const Fixed_precision_nt& y2, const Fixed_precision_nt& z2, const Fixed_precision_nt& x3, const Fixed_precision_nt& y3, const Fixed_precision_nt& z3, const Fixed_precision_nt& x4, const Fixed_precision_nt& y4, const Fixed_precision_nt& z4) // relative position of p4 with respect to sphere p0p1p2p3 // if p0p1p2p3 is positively oriented, // positive side is the interior of the sphere { double det,error; // transform in 4x4 determinant // point p4 is inside sphere through oriented tetra p0p1p2p3 // if the determinant is negative double X1=x1.to_double() -x0.to_double() ; double Y1=y1.to_double() -y0.to_double() ; double Z1=z1.to_double() -z0.to_double() ; double X2=x2.to_double() -x0.to_double() ; // | X1 X2 X3 X4 | double Y2=y2.to_double() -y0.to_double() ; // | Y1 Y2 Y3 Y4 | double Z2=z2.to_double() -z0.to_double() ; // | Z1 Z2 Z3 Z4 | double X3=x3.to_double() -x0.to_double() ; // | R1 R2 R3 R4 | double Y3=y3.to_double() -y0.to_double() ; double Z3=z3.to_double() -z0.to_double() ; double X4=x4.to_double() -x0.to_double() ; double Y4=y4.to_double() -y0.to_double() ; double Z4=z4.to_double() -z0.to_double() ; double R1= X1*X1+Y1*Y1+Z1*Z1; double R2= X2*X2+Y2*Y2+Z2*Z2; double R3= X3*X3+Y3*Y3+Z3*Z3; double R4= X4*X4+Y4*Y4+Z4*Z4; // compute 2x2 minors on the two first lines double M12 = X1 * Y2 - X2 * Y1; double M23 = X2 * Y3 - X3 * Y2; double M34 = X3 * Y4 - X4 * Y3; double M13 = X1 * Y3 - X3 * Y1; double M14 = X1 * Y4 - X4 * Y1; double M24 = X2 * Y4 - X4 * Y2; // compute 3x3 minors on the three first lines double MM1 = Z2 * M34 - Z3 * M24 + Z4 * M23 ; double MM2 = Z1 * M34 - Z3 * M14 + Z4 * M13 ; double MM3 = Z1 * M24 - Z2 * M14 + Z4 * M12 ; double MM4 = Z1 * M23 - Z2 * M13 + Z3 * M12 ; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small { double mm1 =CGAL_NTS abs(Z2*M34) + CGAL_NTS abs(Z3*M24) + CGAL_NTS abs(Z4*M23) ; double mm2 =CGAL_NTS abs(Z1*M34) + CGAL_NTS abs(Z3*M14) + CGAL_NTS abs(Z4*M13) ; double mm3 =CGAL_NTS abs(Z1*M24) + CGAL_NTS abs(Z2*M14) + CGAL_NTS abs(Z4*M12) ; double mm4 =CGAL_NTS abs(Z1*M23) + CGAL_NTS abs(Z2*M13) + CGAL_NTS abs(Z3*M12) ; error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0) { // dynamic filter failed, error is very small double a1,a2,a3,a4; double b1,b2,b3,b4; double c1,c2,c3,c4; double d1,d2,d3,d4; if (error!=0.0){ // start exact computation Fixed_split(M12,a2,M12,Fixed_S_2_25); Fixed_split(M13,a3,M13,Fixed_S_2_25); Fixed_split(M14,a4,M14,Fixed_S_2_25); Fixed_split(M23,b3,M23,Fixed_S_2_25); Fixed_split(M24,b4,M24,Fixed_S_2_25); Fixed_split(M34,c4,M34,Fixed_S_2_25); // compute 3x3 minors ci+di is minor i c1 = Z2 * c4 - Z3 * b4 + Z4 * b3 ; // most significant c2 = Z1 * c4 - Z3 * a4 + Z4 * a3 ; c3 = Z1 * b4 - Z2 * a4 + Z4 * a2 ; c4 = Z1 * b3 - Z2 * a3 + Z3 * a2 ; d1 = Z2 * M34 - Z3 * M24 + Z4 * M23 ; // less significant d2 = Z1 * M34 - Z3 * M14 + Z4 * M13 ; d3 = Z1 * M24 - Z2 * M14 + Z4 * M12 ; d4 = Z1 * M23 - Z2 * M13 + Z3 * M12 ; Fixed_split(d1,a1,d1,Fixed_S_3_25); Fixed_split(d2,a2,d2,Fixed_S_3_25); Fixed_split(d3,a3,d3,Fixed_S_3_25); Fixed_split(d4,a4,d4,Fixed_S_3_25); // now ci+ai+di is minor i a1 += c1; a2 += c2; a3 += c3; a4 += c4; // now ai+di is minor i Fixed_split(a1,c1,a1,Fixed_S_3_51); Fixed_split(a2,c2,a2,Fixed_S_3_51); Fixed_split(a3,c3,a3,Fixed_S_3_51); Fixed_split(a4,c4,a4,Fixed_S_3_51); // now ci+ai+di is minor i, non overlapping 25 bits for each Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // points are cospherical if (! Fixed_insphere_perturb)return ON_ORIENTED_BOUNDARY; // apply perturbation method // first order coefficient is obtained replacing x^2+y^2+z^2 by xy R1 = X1*Y1; R2 = X2*Y2; R3 = X3*Y3; R4 = X4*Y4; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0.0){ // dynamic filter failed, error is very small // start exact computation Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // first order coefficient is null, // compute second order coefficient in the pertrubation method // replace x^2+y^2+z^2 by y^2 R1 = Y1*Y1; R2 = Y2*Y2; R3 = Y3*Y3; R4 = Y4*Y4; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0.0){ // dynamic filter failed, error is very small // start exact computation Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // 2nd order coefficient is null, // compute 3rd order coefficient in the pertrubation method // replace x^2+y^2+z^2 by yz R1 = Y1*Z1; R2 = Y2*Z2; R3 = Y3*Z3; R4 = Y4*Z4; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0.0){ // dynamic filter failed, error is very small // start exact computation Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // 3rd order coefficient is null, // compute 4th order coefficient in the pertrubation method // replace x^2+y^2+z^2 by xz R1 = X1*Z1; R2 = X2*Z2; R3 = X3*Z3; R4 = X4*Z4; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0.0){ // dynamic filter failed, error is very small // start exact computation Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // 4th order coefficient is null, // compute 5th order coefficient in the pertrubation method // replace x^2+y^2+z^2 by z^2 R1 = Z1*Z1; R2 = Z2*Z2; R3 = Z3*Z3; R4 = Z4*Z4; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0.0){ // dynamic filter failed, error is very small // start exact computation Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // 5th order coefficient is null, // compute 6th order coefficient in the pertrubation method // replace x^2+y^2+z^2 by x^2 R1 = X1*X1; R2 = X2*X2; R3 = X3*X3; R4 = X4*X4; // compute determinant det= (R2 * MM2 - R1 * MM1) + (R4 * MM4 - R3 * MM3) ; if (det >= Fixed_Is1 ) return ON_NEGATIVE_SIDE; if (det <= -Fixed_Is1 ) return ON_POSITIVE_SIDE; // static filter failed, error is small error= CGAL_NTS abs(R1)*mm1 + CGAL_NTS abs(R2)*mm2 + CGAL_NTS abs(R3)*mm3 + CGAL_NTS abs(R4)*mm4; error *= Fixed_Is2; if ( error < Fixed_Bx5 ) error = 0.0; if (det > error) return ON_NEGATIVE_SIDE; if (det < -error) return ON_POSITIVE_SIDE; if (error!=0.0){ // dynamic filter failed, error is very small // start exact computation Fixed_split(R1,b1,R1,Fixed_S_2_25); Fixed_split(R2,b2,R2,Fixed_S_2_25); Fixed_split(R3,b3,R3,Fixed_S_2_25); Fixed_split(R4,b4,R4,Fixed_S_2_25); // now bi+Ri is last line, non overlapping 25 bits for each det = (b2 * c2 - b1 * c1) ; // 1 det += (b4 * c4 - b3 * c3) ; // 1b det += (b2 * a2 - b1 * a1) + (b4 * a4 - b3 * a3) ; // 2 det += (R2 * c2 - R1 * c1) + (R4 * c4 - R3 * c3) ; // 3 det += (b2 * d2 - b1 * d1) + (b4 * d4 - b3 * d3) ; // 4 det += (R2 * a2 - R1 * a1) + (R4 * a4 - R3 * a3) ; // 5 det += (R2 * d2 - R1 * d1) + (R4 * d4 - R3 * d3) ; // 6 if (det>0) return ON_NEGATIVE_SIDE; if (det<0) return ON_POSITIVE_SIDE; } // 6th order coefficient is null, // points are coplanar return ON_ORIENTED_BOUNDARY; } } return ON_ORIENTED_BOUNDARY; // code never goes here, it is just to avoid compilation warning } CGAL_END_NAMESPACE #endif //CGAL_FIXED_PRECISION_NT_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_circulators_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_circu0000644000175000017500000003103411344301501031440 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_circulators_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud #ifndef CGAL_TRIANGULATION_DS_CIRCULATORS_3_H #define CGAL_TRIANGULATION_DS_CIRCULATORS_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Tds_ > class Triangulation_ds_cell_circulator_3 : public Bidirectional_circulator_base { // circulates on cells around a given edge typedef Tds_ Tds; typedef typename Tds::Cell Cell; typedef typename Tds::Edge Edge; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Cell_handle Cell_handle; typedef Triangulation_ds_cell_circulator_3 Cell_circulator; public: #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE bool operator==(Cell_handle ch) const { return ch == pos; } bool operator!=(Cell_handle ch) const { return ch != pos; } bool operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return pos == Cell_handle(); } bool operator!=(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return pos != Cell_handle(); } #endif Triangulation_ds_cell_circulator_3() : _s(), _t(), pos() {} Triangulation_ds_cell_circulator_3(Cell_handle c, int s, int t) : _s(c->vertex(s)), _t(c->vertex(t)), pos(c) { CGAL_triangulation_precondition( c != Cell_handle() && s >= 0 && s < 4 && t >= 0 && t < 4 ); } Triangulation_ds_cell_circulator_3(const Edge & e) : _s(e.first->vertex(e.second)), _t(e.first->vertex(e.third)), pos(e.first) { CGAL_triangulation_precondition( e.first != Cell_handle() && e.second >=0 && e.second < 4 && e.third >=0 && e.third < 4); } Triangulation_ds_cell_circulator_3(Cell_handle c, int s, int t, Cell_handle start) : _s(c->vertex(s)), _t(c->vertex(t)), pos(start) { CGAL_triangulation_precondition( c != Cell_handle() && s >= 0 && s < 4 && t >= 0 && t < 4 && start->has_vertex( _s ) && start->has_vertex( _t ) ); } Triangulation_ds_cell_circulator_3(const Edge & e, Cell_handle start) : _s(e.first->vertex(e.second)), _t(e.first->vertex(e.third)), pos(start) { CGAL_triangulation_precondition( e.first != Cell_handle() && e.second >=0 && e.second < 4 && e.third >=0 && e.third < 4 && start->has_vertex( _s ) && start->has_vertex( _t ) ); } Cell_circulator & operator++() { CGAL_triangulation_precondition( pos != Cell_handle() ); //then dimension() cannot be < 3 pos = pos->neighbor(next_around_edge(pos->index(_s), pos->index(_t))); return *this; } Cell_circulator operator++(int) { Cell_circulator tmp(*this); ++(*this); return tmp; } Cell_circulator & operator--() { CGAL_triangulation_precondition( pos != Cell_handle() ); pos = pos->neighbor(next_around_edge(pos->index(_t), pos->index(_s))); return *this; } Cell_circulator operator--(int) { Cell_circulator tmp(*this); --(*this); return tmp; } Cell& operator*() const { return *pos; } Cell* operator->() const { return &*pos; } bool operator==(const Cell_circulator & ccir) const { return pos == ccir.pos && _s == ccir._s && _t == ccir._t; } bool operator!=(const Cell_circulator & ccir) const { return ! (*this == ccir); } // For TDS's private use only. Cell_handle base() const { return pos; } #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE operator Cell_handle() const { return pos; } #endif private: Vertex_handle _s; // source vertex of the edge Vertex_handle _t; // target vertex of the edge Cell_handle pos; // current cell static int next_around_edge(const int i, const int j) { return Triangulation_utils_3::next_around_edge(i,j); } }; #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE template < class Tds_ > bool operator==(typename Tds_::Cell_handle ch, Triangulation_ds_cell_circulator_3 cc) { return (cc==ch); } template < class Tds_ > bool operator!=(typename Tds_::Cell_handle ch, Triangulation_ds_cell_circulator_3 cc) { return !(cc==ch); } #endif template < class Tds_ > class Triangulation_ds_facet_circulator_3 : public Bidirectional_circulator_base { // circulates on facets around a given edge typedef Tds_ Tds; typedef typename Tds::Cell Cell; typedef typename Tds::Cell_handle Cell_handle; typedef typename Tds::Facet Facet; typedef typename Tds::Edge Edge; typedef typename Tds::Vertex_handle Vertex_handle; typedef Triangulation_ds_facet_circulator_3 Facet_circulator; public: Triangulation_ds_facet_circulator_3() : _s(), _t(), pos() {} Triangulation_ds_facet_circulator_3(Cell_handle c, int s, int t) : _s(c->vertex(s)), _t(c->vertex(t)), pos(c) { CGAL_triangulation_precondition( c != Cell_handle() && s >= 0 && s < 4 && t >= 0 && t < 4 ); } Triangulation_ds_facet_circulator_3(const Edge & e) : _s(e.first->vertex(e.second)), _t(e.first->vertex(e.third)), pos(e.first) { CGAL_triangulation_precondition( e.first != Cell_handle() && e.second >= 0 && e.second < 4 && e.third >= 0 && e.third < 4); } Triangulation_ds_facet_circulator_3(Cell_handle c, int s, int t, Cell_handle start, int f) : _s(c->vertex(s)), _t(c->vertex(t)) { CGAL_triangulation_precondition( c != Cell_handle() && s >= 0 && s < 4 && t >= 0 && t < 4 && f >= 0 && f < 4 && start->has_vertex( _s ) && start->has_vertex( _t ) ); int i = start->index( _s ); int j = start->index( _t ); CGAL_triangulation_precondition( f!=i && f!=j ); if ( f == next_around_edge(i,j) ) pos = start; else pos = start->neighbor(f); // other cell with same facet } Triangulation_ds_facet_circulator_3(Cell_handle c, int s, int t, const Facet & start) : _s(c->vertex(s)), _t(c->vertex(t)) { CGAL_triangulation_precondition( c != Cell_handle() && s >= 0 && s < 4 && t >= 0 && t < 4 && start.first->has_vertex( _s ) && start.first->has_vertex( _t ) ); int i = start.first->index( _s ); int j = start.first->index( _t ); CGAL_triangulation_precondition( start.second !=i && start.second !=j ); if ( start.second == next_around_edge(i,j) ) pos = start.first; else pos = start.first->neighbor(start.second); // other cell with same facet } Triangulation_ds_facet_circulator_3(const Edge & e, Cell_handle start, int f) : _s(e.first->vertex(e.second)), _t(e.first->vertex(e.third)) { CGAL_triangulation_precondition( e.first != Cell_handle() && e.second >= 0 && e.second < 4 && e.third >= 0 && e.third < 4 && f >= 0 && f < 4 && start->has_vertex( _s ) && start->has_vertex( _t ) ); int i = start->index( _s ); int j = start->index( _t ); CGAL_triangulation_precondition( f!=i && f!=j ); if ( f == next_around_edge(i,j) ) pos = start; else pos = start->neighbor(f); // other cell with same facet } Triangulation_ds_facet_circulator_3(const Edge & e, const Facet & start) : _s(e.first->vertex(e.second)), _t(e.first->vertex(e.third)) { CGAL_triangulation_precondition( e.first != Cell_handle() && e.second >= 0 && e.second < 4 && e.third >= 0 && e.third < 4 && start.first->has_vertex( _s ) && start.first->has_vertex( _t ) ); int i = start.first->index( _s ); int j = start.first->index( _t ); if ( start.second == next_around_edge(i,j) ) pos = start.first; else pos = start.first->neighbor(start.second); } Facet_circulator & operator++() { CGAL_triangulation_precondition( pos != Cell_handle() ); //then dimension() cannot be < 3 pos = pos->neighbor( next_around_edge( pos->index(_s), pos->index(_t) ) ); return *this; } Facet_circulator operator++(int) { Facet_circulator tmp(*this); ++(*this); return tmp; } Facet_circulator & operator--() { CGAL_triangulation_precondition( pos != Cell_handle() ); pos = pos->neighbor( next_around_edge( pos->index(_t), pos->index(_s) ) ); return *this; } Facet_circulator operator--(int) { Facet_circulator tmp(*this); --(*this); return tmp; } Facet operator*() const { return Facet(pos, next_around_edge( pos->index(_s), pos->index(_t) ) ); } bool operator==(const Facet_circulator & ccir) const { return pos == ccir.pos && _s == ccir._s && _t == ccir._t; } bool operator!=(const Facet_circulator & ccir) const { return ! (*this == ccir); } private: Vertex_handle _s; // source vertex of the edge Vertex_handle _t; // target vertex of the edge Cell_handle pos; // current cell // the current facet is the facet of pos numbered // next_around_edge( pos->index(_c->vertex(_s)), // pos->index(_c->vertex(_t)) ) static int next_around_edge(const int i, const int j) { return Triangulation_utils_3::next_around_edge(i,j); } }; template < class Tds_ > class Triangulation_ds_face_circulator_3 : public Bidirectional_circulator_base { // circulates on faces (Cell) around a given vertex, // valid in dimension 2 only. typedef Tds_ Tds; typedef typename Tds::Cell Cell; typedef typename Tds::Vertex Vertex; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Cell_handle Cell_handle; typedef Triangulation_ds_face_circulator_3 Face_circulator; public: Triangulation_ds_face_circulator_3() : _s(), pos() {} Triangulation_ds_face_circulator_3(Vertex_handle v, Cell_handle c) : _s(v), pos(c) {} Face_circulator & operator++() { CGAL_triangulation_precondition( pos != Cell_handle() ); //then dimension() cannot be < 3 pos = pos->neighbor(ccw(pos->index(_s))); return *this; } Face_circulator operator++(int) { Face_circulator tmp(*this); ++(*this); return tmp; } Face_circulator & operator--() { CGAL_triangulation_precondition( pos != Cell_handle() ); pos = pos->neighbor(cw(pos->index(_s))); return *this; } Face_circulator operator--(int) { Face_circulator tmp(*this); --(*this); return tmp; } Cell& operator*() const { return *pos; } Cell* operator->() const { return &*pos; } bool operator==(const Face_circulator & ccir) const { return pos == ccir.pos && _s == ccir._s; } bool operator!=(const Face_circulator & ccir) const { return ! (*this == ccir); } // For TDS's private use only. Cell_handle base() const { return pos; } #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE operator Cell_handle()const { return pos; } #endif private: Vertex_handle _s; // source vertex Cell_handle pos; // current cell static int cw(int i) { return Triangulation_utils_3::cw(i); } static int ccw(int i) { return Triangulation_utils_3::ccw(i); } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DS_CIRCULATORS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_2_default_dcel.h0000644000175000017500000000265711344301500030643 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_2_default_dcel.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel #ifndef CGAL_ARR_2_DEFAULT_DCEL_H #define CGAL_ARR_2_DEFAULT_DCEL_H #ifndef CGAL_PM_DEFAULT_DCEL_H #include #endif #ifndef ARR_2_BASES_H #include #endif CGAL_BEGIN_NAMESPACE /////////////////////////////////////////////////////////////// // DEFAULT DCEL /////////////////////////////////////////////////////////////// template class Arr_2_default_dcel : public Pm_dcel< Arr_2_vertex_base, Arr_2_halfedge_base >, Arr_2_face_base > { public: // CREATION Arr_2_default_dcel() {} }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_conic_traits_2_core.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_conic_traits_2_cor0000644000175000017500000011241011344301500031313 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_conic_traits_2_core.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Ron Wein #ifndef CGAL_ARR_CONIC_TRAITS_2_CORE_H #define CGAL_ARR_CONIC_TRAITS_2_CORE_H #include #include #include #include CGAL_BEGIN_NAMESPACE /*! * Arrangement traits for conic arcs. */ template class Arr_conic_traits_2 { public: typedef CfNT_ CfNT; typedef Kernel_ Kernel; typedef typename Kernel::FT CoNT; typedef Tag_true Has_left_category; typedef Tag_false Has_reflect_category; // The difference between Curve_2 and X_monotone_curve_2 is semantical only, // NOT syntactical. typedef Conic_arc_2 Curve_2; typedef Curve_2 X_monotone_curve_2; typedef typename Curve_2::Kernel R; typedef typename Curve_2::Point_2 Point_2; typedef typename Curve_2::Circle_2 Circle_2; typedef typename Curve_2::Segment_2 Segment_2; // For backward compatibility: typedef Curve_2 Curve; typedef X_monotone_curve_2 X_curve; typedef Point_2 Point; typedef Circle_2 Circle; typedef Segment_2 Segment; #ifdef CGAL_CONIC_ARC_USE_CACHING private: typedef typename Curve_2::Intersections Intersections; mutable std::list inter_list; // For caching intersections. #endif public: /*! * Default constructor. */ Arr_conic_traits_2() {} /*! * Destructor. */ ~Arr_conic_traits_2() { #ifdef CGAL_CONIC_ARC_USE_CACHING inter_list.clear(); #endif } ////////// Planar Map methods: ////////// /*! * Compare the x-coordinates of two given points. * \param p1 The first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL. */ Comparison_result compare_x(const Point_2& p1, const Point_2& p2) const { return (p1.compare_x (p2)); } /*! * Compares lexigoraphically the two points: by x, then by y. * \param p1 Te first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL. */ Comparison_result compare_xy(const Point_2& p1, const Point_2& p2) const { return (p1.compare_lex_xy (p2)); } /*! * Check whether the given curve is a vertical segment. * \param curve The curve. * \return (true) if the curve is vertical. */ bool curve_is_vertical(const X_monotone_curve_2& curve) const { return (curve.is_vertical_segment()); } /*! * Check whether the given point is in the x-range of the given curve. * In out case, the curve is a segment [s, t], check whether x(s)<=x(q)<=x(t) * or whether x(t)<=x(q)<=x(s). * \param curve The curve. * \param q The point. * \return (true) if q is in the x-range of cv. */ bool point_in_x_range(const X_monotone_curve_2& curve, const Point_2& p) const { CGAL_precondition(is_x_monotone(curve)); if (curve.is_vertical_segment()) { // Check if the vertical segment's x coordinate is the same as p's. return (compare_x (curve.source(), p) == EQUAL); } else { // Since the curve is x-monotone, if the point x coordinate is to the // left (or to the right of both curve's source and target points), then // the point is obviously not in the curve's x range. Comparison_result res1 = compare_x(p, curve.source()); Comparison_result res2 = compare_x(p, curve.target()); return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); } } /*! * Get the relative status of two curves at the x-coordinate of a given * point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p The point. * \pre The point p is in the x-range of the two curves. * \return LARGER if cv1(x(p)) > cv2(x(p)); SMALLER if cv1(x(p)) < cv2(x(p)); * or else EQUAL. */ Comparison_result curves_compare_y_at_x (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); CGAL_precondition(point_in_x_range(curve1, p)); CGAL_precondition(point_in_x_range(curve2, p)); // If both curves contain p, they are obviously equal at x(p). if (curve1.contains_point(p) && curve2.contains_point(p)) return (EQUAL); // Get the points on curve1 with the same x coordinate as p. int n1; Point_2 ps1[2]; if (curve1.is_vertical_segment()) { // In case curve1 is a vertical segment, both the source and target // of the curve has the same x coordinate as p. // Make sure that ps1[0] has a smaller y value than ps1[1]. n1 = 2; if (curve1.source().compare_y (curve1.target()) == SMALLER) { ps1[0] = curve1.source(); ps1[1] = curve1.target(); } else { ps1[0] = curve1.target(); ps1[1] = curve1.source(); } } else if (compare_x(p, curve1.source()) == EQUAL) { ps1[0] = curve1.source(); n1 = 1; } else if (compare_x(p, curve1.target()) == EQUAL) { ps1[0] = curve1.target(); n1 = 1; } else { // Find all points on curve1 with the same x coordinate as p. n1 = curve1.get_points_at_x (p, ps1); CGAL_assertion(n1 == 1); } // Get the points on curve2 with the same x coordinate as p. int n2; Point_2 ps2[2]; if (curve2.is_vertical_segment()) { // In case curve2 is a vertical segment, both the source and target // of the curve has the same x coordinate as p. // Make sure that ps2[0] has a smaller y value than ps2[1]. n2 = 2; if (curve2.source().compare_y (curve2.target()) == SMALLER) { ps2[0] = curve2.source(); ps2[1] = curve2.target(); } else { ps2[0] = curve2.target(); ps2[1] = curve2.source(); } } else if (compare_x(p, curve2.source()) == EQUAL) { ps2[0] = curve2.source(); n2 = 1; } else if (compare_x(p, curve2.target()) == EQUAL) { ps2[0] = curve2.target(); n2 = 1; } else { // Find all points on curve2 with the same x coordinate as p. n2 = curve2.get_points_at_x (p, ps2); CGAL_assertion(n2 == 1); } // Deal with vertical segments: if (n1 == 2) { // Check if the vertical segment curve1 contains ps2[0] or ps2[1]. if (ps1[0].compare_y (ps2[0]) != LARGER && ps1[1].compare_y (ps2[0]) != SMALLER) { return (EQUAL); } if (n2 == 2) { if (ps1[0].compare_y (ps2[1]) != LARGER && ps1[1].compare_y (ps2[1]) != SMALLER) { return (EQUAL); } } } else if (n2 == 2) { // Check if the vertical segment curve2 contains ps1[0]. if (ps2[0].compare_y (ps1[0]) != LARGER && ps2[1].compare_y (ps1[0]) != SMALLER) { return (EQUAL); } } // None of the curves is a vertical segments and both have exactly // one point with the given x coordinate: // Compare the y coordinates of these two points. return (ps1[0].compare_y (ps2[0])); } /*! * Compare the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p The point. * \pre The point p is in the x range of the two curves, and both of them * must be also be defined to its left. Furthermore, cv1(x(p) == cv2(x(p)). * \return The relative position of cv1 with respect to cv2 to the left of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_left (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // The two curve must not be vertical segments. CGAL_precondition(! curve1.is_vertical_segment()); CGAL_precondition(! curve2.is_vertical_segment()); // Check that both curves are defined to the left of p. CGAL_precondition((compare_x(curve1.source(), p) == SMALLER) || (compare_x(curve1.target(), p) == SMALLER)); CGAL_precondition((compare_x(curve2.source(), p) == SMALLER) || (compare_x(curve2.target(), p) == SMALLER)); // Get the points on curve1 with the same x coordinate as p. int n1; Point_2 ps1[2]; if (curve1.contains_point(p)) { ps1[0] = p; n1 = 1; } else { n1 = curve1.get_points_at_x (p, ps1); } // Make sure that there is exactly one point. CGAL_assertion(n1 == 1); // Get the points on curve2 with the same x coordinate as p. int n2; Point_2 ps2[2]; if (curve2.contains_point(p)) { ps2[0] = p; n2 = 1; } else { n2 = curve2.get_points_at_x (p, ps2); } // Make sure that there is exactly one point. CGAL_assertion(n2 == 1); // The two curves must intersect at x(p). CGAL_precondition (ps1[0].compare_y (ps2[0]) == EQUAL); // If the two curves are equal: if (curve1.equals (curve2)) return (EQUAL); // The two curves intersect at ps1[0] = ps2[0] - proceed from here. return (_curve_compare_at_intersection_left (curve1, curve2, ps1[0])); } /*! * Compare the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p The point. * \pre The point p is in the x range of the two curves, and both of them * must be also be defined to its right. Furthermore, cv1(x(p) == cv2(x(p)). * \return The relative position of cv1 with respect to cv2 to the right of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_right (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // The two curve must not be vertical segments. CGAL_precondition(! curve1.is_vertical_segment()); CGAL_precondition(! curve2.is_vertical_segment()); // Check that both curves are defined to the right of p. CGAL_precondition((compare_x(curve1.source(), p) == LARGER) || (compare_x(curve1.target(), p) == LARGER)); CGAL_precondition((compare_x(curve2.source(), p) == LARGER) || (compare_x(curve2.target(), p) == LARGER)); // Get the points on curve1 with the same x coordinate as p. int n1; Point_2 ps1[2]; if (curve1.contains_point(p)) { ps1[0] = p; n1 = 1; } else { n1 = curve1.get_points_at_x (p, ps1); } // Make sure we have a single point. CGAL_assertion(n1 == 1); // Get the points on curve2 with the same x coordinate as p. int n2; Point_2 ps2[2]; if (curve2.contains_point(p)) { ps2[0] = p; n2 = 1; } else { n2 = curve2.get_points_at_x (p, ps2); } // Make sure we have a single point. CGAL_assertion(n2 == 1); // The two curves must intersect at p(x). CGAL_precondition (ps1[0].compare_y (ps2[0]) == EQUAL); // If the two curves are equal: if (curve1.equals (curve2)) return (EQUAL); // The two curves intersect at ps1[0] = ps2[0] - proceed from here: return (_curve_compare_at_intersection_right (curve1, curve2, ps1[0])); } /*! * Return the location of the given point with respect to the input curve. * \param p The point. * \param curve The curve (cv). * \pre p is in the x-range of the curve. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x(const Point_2& p, const X_monotone_curve_2& curve) const { CGAL_precondition(is_x_monotone(curve)); CGAL_precondition(point_in_x_range(curve,p)); // A special treatment for vertical segments: if (curve.is_vertical_segment()) { // In case p has the same x c-ordinate of the vertical segment, compare // it to the segment endpoints to determine its position. Comparison_result res1 = p.compare_y (curve.source()); Comparison_result res2 = p.compare_y (curve.target()); if (res1 == res2) return (res1); else return (EQUAL); } // Check whether the point is exactly on the curve. if (curve.contains_point(p)) return (EQUAL); // Get the points on the arc with the same x coordinate as p. int n; Point_2 ps[2]; if (compare_x(p, curve.source()) == EQUAL) { ps[0] = curve.source(); n = 1; } else if (compare_x(p, curve.target()) == EQUAL) { ps[0] = curve.target(); n = 1; } else { n = curve.get_points_at_x (p, ps); } // Make sure there is exactly one point. CGAL_assertion(n == 1); // Compare p with the a point of the curve with the same x coordinate. return (p.compare_y(ps[0])); } /*! * Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal (const Point_2& p1, const Point_2& p2) const { return (p1.equals(p2)); } /*! * Check if the two curves are the same (have the same graph). * \param curve1 The first curve. * \param curve2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); return (curve1.equals (curve2)); } /*! * Get the curve source. * \param curve The curve. * \return The source point. */ const Point_2& curve_source (const X_monotone_curve_2& curve) const { return (curve.source()); } /*! * Get the curve target. * \param curve The curve. * \return The target point. */ const Point_2& curve_target (const X_monotone_curve_2& curve) const { return (curve.target()); } /*! * Flip a given curve (swap the source and target and flip the orientation). * \param curve The input curve. * \return The flipped curve. */ X_monotone_curve_2 curve_opposite (const X_monotone_curve_2& curve) const { // Flip the arc. return (curve.flip()); } /*! * Check whether the curve is x-monotone. * \param curve The curve. * \return (true) if the curve is x-monotone. */ bool is_x_monotone (const Curve_2& curve) const { return (curve.is_x_monotone()); } /*! Cut the given curve into x-monotone subcurves and inserts them to the * given output iterator. * \param curve the input curve * \param o the output iterator * \return The past-the-end iterator */ template OutputIterator curve_make_x_monotone (const Curve_2& curve, OutputIterator o) const { // Find the points of vertical tangency and act accordingly. int n; Point_2 ps[2]; n = curve.vertical_tangency_points (ps); if (n == 0) { // In case the given curve is already x-monotone: *o++ = curve; return (o); } // Split the conic arc into x-monotone sub-curves. if (curve.is_full_conic()) { // Make sure we have two vertical tangency points. CGAL_assertion(n == 2); // In case the curve is a full conic, split it to two x-monotone curves, // one going from ps[0] to ps[1], and the other from ps[1] to ps[0]. *o++ = X_monotone_curve_2 (curve, ps[0], ps[1]); *o++ = X_monotone_curve_2 (curve, ps[1], ps[0]); } else { X_monotone_curve_2 sub_curve1; X_monotone_curve_2 sub_curve2; X_monotone_curve_2 sub_curve3; if (n == 1) { // Split the arc into two x-monotone sub-curves: one going from the // arc source to ps[0], and the other from ps[0] to the target. _curve_split (curve, sub_curve1, sub_curve2, ps[0]); *o++ = sub_curve1; *o++ = sub_curve2; } else if (n == 2) { // Split the arc into three x-monotone sub-curves: one going from the // arc source to ps[0], one from ps[0] to ps[1], and the last one // from ps[1] to the target. // Notice that ps[0] and ps[1] might switch places. X_monotone_curve_2 temp; _curve_split (curve, sub_curve1, sub_curve2, ps[0]); if (sub_curve2.contains_point(ps[1])) { temp = sub_curve2; _curve_split (temp, sub_curve2, sub_curve3, ps[1]); } else if (sub_curve1.contains_point(ps[1])) { // Actually we switch between ps[0] and ps[1]. temp = sub_curve1; sub_curve3 = sub_curve2; _curve_split (temp, sub_curve1, sub_curve2, ps[1]); } else { // We should never reach here: CGAL_assertion(false); } *o++ = sub_curve1; *o++ = sub_curve2; *o++ = sub_curve3; } else { // We should never reach here: CGAL_assertion(false); } } return (o); } /*! * Split a given curve at a given split point into two sub-curves. * \param curve The curve to split. * \param sub_curve1 The output first part of the split curve. * Its source is the source of the original curve. * \param sub_curve2 The output second part of the split curve. * Its target is the target of the original curve. * \param p the split point. * \pre p lies on the curve but is not one of its end-points. */ void curve_split (const X_monotone_curve_2& curve, X_monotone_curve_2& sub_curve1, X_monotone_curve_2& sub_curve2, const Point_2& p) const { CGAL_precondition(is_x_monotone(curve)); // Make sure the point is on the curve and is not an end-point. CGAL_precondition(curve.contains_point(p)); CGAL_precondition(! p.equals(curve.source())); CGAL_precondition(! p.equals(curve.target())); // Split the curve. _curve_split (curve, sub_curve1, sub_curve2, p); return; } /*! * Find the nearest intersection point (or points) of two given curves to * the right lexicographically of a given point not including the point * itself: * - If the intersection of the two curves is a point to the right of the * given point, it is returned through both point references p1 and p2. * - If the intersection of the two curves is an X_monotone_curve_2, * that is, they overlap at infinitely many points, then the endpoints * of the overlapping sub-arc are returned. * \param curve1 The first curve. * \param curve2 The second curve. * \param p The refernece point. * \param p1 The first output point. * \param p2 The second output point. * \return (true) if curve1 and curve2 do intersect to the right of p, * or (false) if no such intersection exists. */ bool nearest_intersection_to_right (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p, Point_2& p1, Point_2& p2) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // Deal with overlapping curves: X_monotone_curve_2 ovlp_arcs[2]; const int n_ovlps = curve1.overlaps (curve2, ovlp_arcs); CGAL_assertion (n_ovlps < 2); if (n_ovlps == 1) { // An overlapping sub-arc was found. Trim it so it would be entirely // to the right of p. Point_2 ovlp_source = ovlp_arcs[0].source(); Point_2 ovlp_target = ovlp_arcs[0].target(); if (ovlp_source.compare_lex_xy(p) == LARGER && ovlp_target.compare_lex_xy(p) == LARGER) { // The entire overlapping arc is to the right of p: p1 = ovlp_source; p2 = ovlp_target; return (true); } else if (ovlp_source.compare_lex_xy(p) != LARGER && ovlp_target.compare_lex_xy(p) == LARGER) { // The source is to the left of p, and the traget is to its right. p1 = p; p2 = ovlp_target; return (true); } else if (ovlp_source.compare_lex_xy(p) == LARGER && ovlp_target.compare_lex_xy(p) != LARGER) { // The source is to the right of p, and the traget is to its left. p1 = ovlp_source; p2 = p; return (true); } else { // The entire overlapping arc is to the left of p: return (false); } } // In case there are no overlaps and the base conics are the same, // there cannot be any intersection points, unless the two x-monotone // curves share an end point. if (curve1.has_same_base_conic(curve2)) { const Point_2 *nearest_end_P = NULL; if ((curve1.source().equals(curve2.source()) || curve1.source().equals(curve2.target())) && curve1.source().compare_lex_xy(p) == LARGER) { nearest_end_P = &(curve1.source()); } if ((curve1.target().equals(curve2.source()) || curve1.target().equals(curve2.target())) && curve1.target().compare_lex_xy(p) == LARGER) { if (nearest_end_P == NULL || nearest_end_P->compare_lex_xy (curve1.target()) == LARGER) { nearest_end_P = &(curve1.target()); } } if (nearest_end_P != NULL) { // A common end point was found: p1 = p2 = *nearest_end_P; return (true); } else { // No intersection: return (false); } } // Find the intersection points and choose the one nearest to p. int n; Point_2 ps[4]; const Point_2 *nearest_inter_P = NULL; int i; #ifdef CGAL_CONIC_ARC_USE_CACHING n = curve1.intersections_with (curve2, ps, &inter_list); #else n = curve1.intersections_with (curve2, ps); #endif for (i = 0; i < n; i++) { // Check if the current point is to the right of p. if (ps[i].compare_lex_xy(p) == LARGER) { // Compare with the nearest point so far. if (nearest_inter_P == NULL || nearest_inter_P->compare_lex_xy (ps[i]) == LARGER) { nearest_inter_P = &(ps[i]); } } } if (nearest_inter_P != NULL) { // Return the nearest intersection point. p1 = p2 = *nearest_inter_P; return (true); } // No intersection found to the right of p: return (false); } /*! * Find the nearest intersection point (or points) of two given curves to * the left lexicographically of a given point not including the point * itself: * - If the intersection of the two curves is a point to the left of the * given point, it is returned through both point references p1 and p2. * - If the intersection of the two curves is an X_monotone_curve_2, * that is, they overlap at infinitely many points, then the endpoints * of the overlapping sub-arc are returned. * \param curve1 The first curve. * \param curve2 The second curve. * \param p The refernece point. * \param p1 The first output point. * \param p2 The second output point. * \return (true) if curve1 and curve2 do intersect to the left of p, * or (false) if no such intersection exists. */ bool nearest_intersection_to_left (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p, Point_2& p1, Point_2& p2) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); // Deal with overlapping curves: X_monotone_curve_2 ovlp_arcs[2]; const int n_ovlps = curve1.overlaps (curve2, ovlp_arcs); CGAL_assertion (n_ovlps < 2); if (n_ovlps == 1) { // An overlapping sub-arc was found. Trim it so it would be entirely // to the left of p. Point_2 ovlp_source = ovlp_arcs[0].source(); Point_2 ovlp_target = ovlp_arcs[0].target(); if (ovlp_source.compare_lex_xy(p) == SMALLER && ovlp_target.compare_lex_xy(p) == SMALLER) { // The entire overlapping arc is to the left of p: p1 = ovlp_source; p2 = ovlp_target; return (true); } else if (ovlp_source.compare_lex_xy(p) != SMALLER && ovlp_target.compare_lex_xy(p) == SMALLER) { // The source is to the right of p, and the traget is to its left. p1 = p; p2 = ovlp_target; return (true); } else if (ovlp_source.compare_lex_xy(p) == SMALLER && ovlp_target.compare_lex_xy(p) != SMALLER) { // The source is to the left of p, and the traget is to its right. p1 = ovlp_source; p2 = p; return (true); } else { // The entire overlapping arc is to the right of p: return (false); } } // In case there are no overlaps and the base conics are the same, // there cannot be any intersection points, unless the two x-monotone // curves share an end point. if (curve1.has_same_base_conic(curve2)) { const Point_2 *nearest_end_P = NULL; if ((curve1.source().equals(curve2.source()) || curve1.source().equals(curve2.target())) && curve1.source().compare_lex_xy(p) == SMALLER) { nearest_end_P = &(curve1.source()); } if ((curve1.target().equals(curve2.source()) || curve1.target().equals(curve2.target())) && curve1.target().compare_lex_xy(p) == SMALLER) { if (nearest_end_P == NULL || nearest_end_P->compare_lex_xy (curve1.target()) == SMALLER) { nearest_end_P = &(curve1.target()); } } if (nearest_end_P != NULL) { // A common end point was found: p1 = p2 = *nearest_end_P; return (true); } else { // No intersection: return (false); } } // Find the intersection points and choose the one nearest to p. int n; Point_2 ps[4]; const Point_2 *nearest_inter_P = NULL; int i; #ifdef CGAL_CONIC_ARC_USE_CACHING n = curve1.intersections_with (curve2, ps, &inter_list); #else n = curve1.intersections_with (curve2, ps); #endif for (i = 0; i < n; i++) { // Check if the current point is to the left of p. if (ps[i].compare_lex_xy(p) == SMALLER) { // Compare with the nearest point so far. if (nearest_inter_P == NULL || nearest_inter_P->compare_lex_xy (ps[i]) == SMALLER) { nearest_inter_P = &(ps[i]); } } } if (nearest_inter_P != NULL) { // Return the nearest intersection point. p1 = p2 = *nearest_inter_P; return (true); } // No intersection found to the left of p: return (false); } /*! * Check whether the two given curves overlap. * \patam curve1 The first curve. * \patam curve2 The second curve. * \return (true) if the two curves overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, if they have a finite * number of intersection points, or none at all, return (false). */ bool curves_overlap (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2) const { CGAL_precondition(is_x_monotone(curve1)); CGAL_precondition(is_x_monotone(curve2)); X_monotone_curve_2 ovlp_arcs[2]; return (curve1.overlaps (curve2, ovlp_arcs) > 0); } private: ////////// Private auxiliary methods: ////////// /*! * Split the given curve into two sub-curves at the given point which lies * on the curve's interior. * \param curve The curve to split. * \param sub_curve1 The output first part of the split curve. * Its source is the source of the original curve. * \param sub_curve2 The output second part of the split curve. * Its target is the target of the original curve. * \param p the split point. */ void _curve_split (const X_monotone_curve_2& curve, X_monotone_curve_2& sub_curve1, X_monotone_curve_2& sub_curve2, const Point_2& p) const { // Split the curve to source->p and p->target. sub_curve1 = X_monotone_curve_2 (curve, curve.source(), p); sub_curve2 = X_monotone_curve_2 (curve, p, curve.target()); CGAL_assertion(sub_curve1.is_x_monotone()); CGAL_assertion(sub_curve2.is_x_monotone()); return; } /*! * Compare the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p_int Their intersection point. * \return The relative position of cv1 with respect to cv2 to the left of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result _curve_compare_at_intersection_left (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p_int) const { // In case one arc is facing upwards and another facing downwards, it is // very clear that the one facing upward is above the one facing downwards. if (curve1.has_same_base_conic(curve2)) { Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); } // Otherwise, since the two curves do intersect at p_int, make a decision // based on their partial derivatives. const CoNT _zero = 0; CoNT slope1_numer, slope1_denom; CoNT slope2_numer, slope2_denom; curve1.derive_by_x_at (p_int, 1, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 1, slope2_numer, slope2_denom); const bool is_vertical_slope1 = (slope1_denom == _zero); const bool is_vertical_slope2 = (slope2_denom == _zero); if (!is_vertical_slope1 && !is_vertical_slope2) { // The two curves have derivatives at p_int: use it to determine which // one is above the other (the one with a smaller slope in above). Comparison_result slope_res = CGAL::compare(slope2_numer*slope1_denom, slope1_numer*slope2_denom); if (slope_res != EQUAL) return (slope_res); // Use the second order derivative. curve1.derive_by_x_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 2, slope2_numer, slope2_denom); slope_res = CGAL::compare (slope2_numer*slope1_denom, slope1_numer*slope2_denom); CGAL_assertion(slope_res != EQUAL); return ((slope_res == LARGER) ? SMALLER : LARGER); } else if (!is_vertical_slope2) { // The first curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac1 = curve1.facing(); CGAL_assertion(fac1 != EQUAL); return (fac1); } else if (!is_vertical_slope1) { // The second curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac2 = curve2.facing(); CGAL_assertion(fac2 != EQUAL); return ((fac2 == LARGER) ? SMALLER : LARGER); } else { // The two curves have vertical slopes at p_int: // First check whether one is facing up and one down. In this case the // comparison result is trivial. Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); // Compute the second order derivative by y and act according to it. curve1.derive_by_y_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_y_at (p_int, 2, slope2_numer, slope2_denom); Comparison_result slope_res = CGAL::compare(slope2_numer*slope1_denom, slope1_numer*slope2_denom); CGAL_assertion(slope_res != EQUAL); if (fac1 == LARGER && fac2 == LARGER) { // Both are facing up. return ((slope_res == LARGER) ? SMALLER : LARGER); } else { // Both are facing down. return (slope_res); } } // We should never reach here: CGAL_assertion(false); return (EQUAL); } /*! * Compare the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param curve1 The first curve (cv1). * \param curve2 The second curve (cv2). * \param p_int Their intersection point. * \return The relative position of cv1 with respect to cv2 to the left of * x(p): LARGER, SMALLER or EQUAL. */ Comparison_result _curve_compare_at_intersection_right (const X_monotone_curve_2& curve1, const X_monotone_curve_2& curve2, const Point_2& p_int) const { // In case one arc is facing upwards and another facing downwards, it is // very clear that the one facing upward is above the one facing downwards. if (curve1.has_same_base_conic(curve2)) { Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); } // Otherwise, the two curves do intersect at p_int, make a decision based // on their partial derivatives. const CoNT _zero = 0; CoNT slope1_numer, slope1_denom; CoNT slope2_numer, slope2_denom; curve1.derive_by_x_at (p_int, 1, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 1, slope2_numer, slope2_denom); const bool is_vertical_slope1 = (slope1_denom == _zero); const bool is_vertical_slope2 = (slope2_denom == _zero); if (!is_vertical_slope1 && !is_vertical_slope2) { // The two curves have derivatives at p_int: use it to determine which // one is above the other (the one with a larger slope is below). Comparison_result slope_res = CGAL::compare (slope1_numer*slope2_denom, slope2_numer*slope1_denom); if (slope_res != EQUAL) return (slope_res); // Use the second order derivative. curve1.derive_by_x_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_x_at (p_int, 2, slope2_numer, slope2_denom); slope_res = CGAL::compare (slope1_numer*slope2_denom, slope2_numer*slope1_denom); CGAL_assertion(slope_res != EQUAL); return (slope_res); } else if (!is_vertical_slope2) { // The first curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac1 = curve1.facing(); CGAL_assertion(fac1 != EQUAL); return (fac1); } else if (!is_vertical_slope1) { // The second curve has a vertical slope at p_int: check whether it is // facing upwards or downwards and decide accordingly. Comparison_result fac2 = curve2.facing(); CGAL_assertion(fac2 != EQUAL); return ((fac2 == LARGER) ? SMALLER : LARGER); } else { // The two curves have vertical slopes at p_int: // First check whether one is facing up and one down. In this case the // comparison result is trivial. Comparison_result fac1 = curve1.facing(); Comparison_result fac2 = curve2.facing(); if (fac1 == LARGER && fac2 == SMALLER) return (LARGER); else if (fac1 == SMALLER && fac2 == LARGER) return (SMALLER); // Compute the second order derivative by y and act according to it. curve1.derive_by_y_at (p_int, 2, slope1_numer, slope1_denom); curve2.derive_by_y_at (p_int, 2, slope2_numer, slope2_denom); Comparison_result slope_res = CGAL::compare (slope1_numer*slope2_denom, slope2_numer*slope1_denom); CGAL_assertion(slope_res != EQUAL); if (fac1 == LARGER && fac2 == LARGER) { // Both are facing up. return ((slope_res == LARGER) ? SMALLER : LARGER); } else { // Both are facing down. return (slope_res); } } // We should never reach here: CGAL_assertion(false); return (EQUAL); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/function_objects.h0000644000175000017500000003640011344301500030532 0ustar debiandebian// Copyright (c) 2003,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/function_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_FUNCTION_OBJECTS_H #define CGAL_FUNCTION_OBJECTS_H 1 #include #include CGAL_BEGIN_NAMESPACE template < class Value> struct Identity { typedef Value argument_type; typedef Value result_type; typedef Arity_tag<1> Arity; Value& operator()( Value& x) const { return x; } const Value& operator()( const Value& x) const { return x; } }; template < class Value> struct Dereference { typedef Value* argument_type; typedef Value result_type; typedef Arity_tag<1> Arity; Value& operator()( Value* x) const { return *x;} const Value& operator()( const Value* x) const { return *x;} }; template < class Value> struct Get_address { typedef Value argument_type; typedef Value* result_type; typedef Arity_tag<1> Arity; Value* operator()( Value& x) const { return &x;} const Value* operator()( const Value& x) const { return &x;} }; template < class Arg, class Result> struct Cast_function_object { typedef Arg argument_type; typedef Result result_type; typedef Arity_tag<1> Arity; Result& operator()( Arg& x) const { return (Result&)(x); } const Result& operator()( const Arg& x) const { return (const Result&)(x); } }; template < class Node> struct Project_vertex { typedef Node argument_type; typedef typename Node::Vertex Vertex; typedef Vertex result_type; typedef Arity_tag<1> Arity; Vertex& operator()( Node& x) const { return x.vertex(); } const Vertex& operator()( const Node& x) const { return x.vertex(); } }; template < class Node> struct Project_facet { typedef Node argument_type; typedef typename Node::Facet Facet; typedef Facet result_type; typedef Arity_tag<1> Arity; Facet& operator()( Node& x) const { return x.facet(); } const Facet& operator()( const Node& x) const { return x.facet(); } }; template < class Node> struct Project_point { typedef Node argument_type; typedef typename Node::Point Point; typedef Point result_type; typedef Arity_tag<1> Arity; Point& operator()( Node& x) const { return x.point(); } const Point& operator()( const Node& x) const { return x.point(); } }; template < class Node> struct Project_normal { typedef Node argument_type; typedef typename Node::Normal Normal; typedef Normal result_type; typedef Arity_tag<1> Arity; Normal& operator()( Node& x) const { return x.normal(); } const Normal& operator()( const Node& x) const { return x.normal(); } }; template < class Node> struct Project_plane { typedef Node argument_type; typedef typename Node::Plane Plane; typedef Plane result_type; typedef Arity_tag<1> Arity; Plane& operator()( Node& x) const { return x.plane(); } const Plane& operator()( const Node& x) const { return x.plane(); } }; // The following four adaptors are used to create the circulators // for polyhedral surfaces. template < class Node> struct Project_next { typedef Node* argument_type; typedef Node* result_type; typedef Arity_tag<1> Arity; Node* operator()( Node* x) const { return x->next(); } const Node* operator()( const Node* x) const { return x->next(); } }; template < class Node> struct Project_prev { typedef Node* argument_type; typedef Node* result_type; typedef Arity_tag<1> Arity; Node* operator()( Node* x) const { return x->prev(); } const Node* operator()( const Node* x) const { return x->prev(); } }; template < class Node> struct Project_next_opposite { typedef Node* argument_type; typedef Node* result_type; typedef Arity_tag<1> Arity; Node* operator()( Node* x) const { return x->next()->opposite(); } const Node* operator()( const Node* x) const { return x->next()->opposite(); } }; template < class Node> struct Project_opposite_prev { typedef Node* argument_type; typedef Node* result_type; typedef Arity_tag<1> Arity; Node* operator()( Node* x) const { return x->opposite()->prev(); } const Node* operator()( const Node* x) const { return x->opposite()->prev(); } }; template < class Arg, class Result > class Creator_1 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Result result_type; typedef Arity_tag<1> Arity; Result operator()(Arg a) const { return Result(a);} }; template < class Arg1, class Arg2, class Result > class Creator_2 { public: typedef Arg1 argument1_type; typedef Arg2 argument2_type; typedef Result result_type; typedef Arity_tag<2> Arity; Result operator()(Arg1 a1, Arg2 a2) const { return Result(a1,a2);} }; template < class Arg1, class Arg2, class Arg3, class Result > class Creator_3 { public: typedef Arg1 argument1_type; typedef Arg2 argument2_type; typedef Arg3 argument3_type; typedef Result result_type; typedef Arity_tag<3> Arity; Result operator()(Arg1 a1, Arg2 a2, Arg3 a3) const { return Result(a1,a2,a3); } }; template < class Arg1, class Arg2, class Arg3, class Arg4, class Result > class Creator_4 { public: typedef Arg1 argument1_type; typedef Arg2 argument2_type; typedef Arg3 argument3_type; typedef Arg4 argument4_type; typedef Result result_type; typedef Arity_tag<4> Arity; Result operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) const { return Result(a1,a2,a3,a4); } }; template < class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Result > class Creator_5 { public: typedef Arg1 argument1_type; typedef Arg2 argument2_type; typedef Arg3 argument3_type; typedef Arg4 argument4_type; typedef Arg5 argument5_type; typedef Result result_type; typedef Arity_tag<5> Arity; Result operator()(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) const { return Result(a1,a2,a3,a4,a5); } }; template < class Arg, class Result > class Creator_uniform_2 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Result result_type; typedef Arity_tag<2> Arity; Result operator()(Arg a1, Arg a2) const { return Result(a1,a2);} }; template < class Arg, class Result > class Creator_uniform_3 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Result result_type; typedef Arity_tag<3> Arity; Result operator()(Arg a1, Arg a2, Arg a3) const { return Result(a1,a2,a3); } }; template < class Arg, class Result > class Creator_uniform_4 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Arg argument4_type; typedef Result result_type; typedef Arity_tag<4> Arity; Result operator()(Arg a1, Arg a2, Arg a3, Arg a4) const { return Result(a1,a2,a3,a4); } }; template < class Arg, class Result > class Creator_uniform_5 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Arg argument4_type; typedef Arg argument5_type; typedef Result result_type; typedef Arity_tag<5> Arity; Result operator()(Arg a1, Arg a2, Arg a3, Arg a4, Arg a5) const { return Result(a1,a2,a3,a4,a5); } }; template < class Arg, class Result > class Creator_uniform_6 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Arg argument4_type; typedef Arg argument5_type; typedef Arg argument6_type; typedef Result result_type; Result operator()(Arg a1, Arg a2, Arg a3, Arg a4, Arg a5, Arg a6 ) const { return Result(a1,a2,a3,a4,a5,a6); } }; template < class Arg, class Result > class Creator_uniform_7 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Arg argument4_type; typedef Arg argument5_type; typedef Arg argument6_type; typedef Arg argument7_type; typedef Result result_type; Result operator()(Arg a1, Arg a2, Arg a3, Arg a4, Arg a5, Arg a6, Arg a7) const { return Result(a1,a2,a3,a4,a5,a6,a7); } }; template < class Arg, class Result > class Creator_uniform_8 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Arg argument4_type; typedef Arg argument5_type; typedef Arg argument6_type; typedef Arg argument7_type; typedef Arg argument8_type; typedef Result result_type; Result operator()(Arg a1, Arg a2, Arg a3, Arg a4, Arg a5, Arg a6, Arg a7, Arg a8) const { return Result(a1,a2,a3,a4,a5,a6,a7,a8); } }; template < class Arg, class Result > class Creator_uniform_9 { public: typedef Arg argument_type; typedef Arg argument1_type; typedef Arg argument2_type; typedef Arg argument3_type; typedef Arg argument4_type; typedef Arg argument5_type; typedef Arg argument6_type; typedef Arg argument7_type; typedef Arg argument8_type; typedef Arg argument9_type; typedef Result result_type; Result operator()(Arg a1, Arg a2, Arg a3, Arg a4, Arg a5, Arg a6, Arg a7, Arg a8, Arg a9) const { return Result(a1,a2,a3,a4,a5,a6,a7,a8,a9); } }; template < class Arg, class Result > class Creator_uniform_d { int d; private: Creator_uniform_d(){} public: typedef Arg argument1_type; typedef Result result_type; typedef Arity_tag<2> Arity; Creator_uniform_d(int dim) : d(dim) {} Result operator()(Arg a1, Arg a2) const { return Result(d, a1,a2);} }; template < class Op1, class Op2 > class Unary_compose_1 : public CGAL_STD::unary_function< typename Op2::argument_type, typename Op1::result_type > { protected: Op1 op1; Op2 op2; public: typedef typename Op2::argument_type argument_type; typedef typename Op1::result_type result_type; Unary_compose_1(const Op1& x, const Op2& y) : op1(x), op2(y) {} result_type operator()(const argument_type& x) const { return op1(op2(x)); } }; template < class Op1, class Op2 > inline Unary_compose_1< Op1, Op2 > compose1_1(const Op1& op1, const Op2& op2) { return Unary_compose_1< Op1, Op2 >(op1, op2); } template < class Op1, class Op2, class Op3 > class Binary_compose_1 : public CGAL_STD::unary_function< typename Op2::argument_type, typename Op1::result_type > { protected: Op1 op1; Op2 op2; Op3 op3; public: typedef typename Op2::argument_type argument_type; typedef typename Op1::result_type result_type; Binary_compose_1(const Op1& x, const Op2& y, const Op3& z) : op1(x), op2(y), op3(z) {} result_type operator()(const argument_type& x) const { return op1(op2(x), op3(x)); } }; template < class Op1, class Op2, class Op3 > inline Binary_compose_1< Op1, Op2, Op3 > compose2_1(const Op1& op1, const Op2& op2, const Op3& op3) { return Binary_compose_1< Op1, Op2, Op3 >(op1, op2, op3); } template < class Op1, class Op2 > class Unary_compose_2 : public CGAL_STD::binary_function< typename Op2::first_argument_type, typename Op2::second_argument_type, typename Op1::result_type > { protected: Op1 op1; Op2 op2; public: typedef typename Op2::first_argument_type first_argument_type; typedef typename Op2::second_argument_type second_argument_type; typedef typename Op1::result_type result_type; Unary_compose_2(const Op1& x, const Op2& y) : op1(x), op2(y) {} result_type operator()(const first_argument_type& x, const second_argument_type& y) const { return op1(op2(x, y)); } }; template < class Op1, class Op2 > inline Unary_compose_2< Op1, Op2 > compose1_2(const Op1& op1, const Op2& op2) { return Unary_compose_2< Op1, Op2 >(op1, op2); } template < class Op1, class Op2, class Op3 > class Binary_compose_2 : public CGAL_STD::binary_function< typename Op2::argument_type, typename Op3::argument_type, typename Op1::result_type > { protected: Op1 op1; Op2 op2; Op3 op3; public: typedef typename Op2::argument_type first_argument_type; typedef typename Op3::argument_type second_argument_type; typedef typename Op1::result_type result_type; Binary_compose_2(const Op1& x, const Op2& y, const Op3& z) : op1(x), op2(y), op3(z) {} result_type operator()(const first_argument_type& x, const second_argument_type& y) const { return op1(op2(x), op3(y)); } }; template < class Op1, class Op2, class Op3 > inline Binary_compose_2< Op1, Op2, Op3 > compose2_2(const Op1& op1, const Op2& op2, const Op3& op3) { return Binary_compose_2< Op1, Op2, Op3 >(op1, op2, op3); } template < class Op > class Compare_to_less : public Op { public: typedef Op Type; typedef bool result_type; Compare_to_less(const Op& op) : Op(op) {} template < typename A1 > bool operator()(const A1 &a1) const { return Op::operator()(a1) == SMALLER; } template < typename A1, typename A2 > bool operator()(const A1 &a1, const A2 &a2) const { return Op::operator()(a1, a2) == SMALLER; } template < typename A1, typename A2, typename A3 > bool operator()(const A1 &a1, const A2 &a2, const A3 &a3) const { return Op::operator()(a1, a2, a3) == SMALLER; } template < typename A1, typename A2, typename A3, typename A4 > bool operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const { return Op::operator()(a1, a2, a3, a4) == SMALLER; } // More can be added. }; template < class Op > inline Compare_to_less compare_to_less(const Op& op) { return Compare_to_less(op); } CGAL_END_NAMESPACE #endif // CGAL_FUNCTION_OBJECTS_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/all_furthest_neighbors_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/all_furthest_neighbors0000644000175000017500000001414111344301500031500 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/all_furthest_neighbors_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_ALL_FURTHEST_NEIGHBORS_2_H) #define CGAL_ALL_FURTHEST_NEIGHBORS_2_H 1 #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Operation, class RandomAccessIC > class All_furthest_neighbor_matrix : public Cartesian_matrix< Operation, RandomAccessIC, RandomAccessIC > // represents the matrix used for computing // all furthest neighbors of a convex polygon { public: typedef Cartesian_matrix< Operation, RandomAccessIC, RandomAccessIC > Base; typedef typename Base::Value Value; using Base::number_of_rows; All_furthest_neighbor_matrix(RandomAccessIC f, RandomAccessIC l) : Base(f, l, f, l) {} All_furthest_neighbor_matrix(RandomAccessIC f, RandomAccessIC l, const Operation& o) : Base(f, l, f, l, o) {} int number_of_columns() const { return 2 * number_of_rows() - 1; } Value operator()( int r, int c) const { CGAL_optimisation_precondition(r >= 0 && r < number_of_rows()); CGAL_optimisation_precondition(c >= 0 && c < number_of_columns()); if (c <= r) return Value(c - r); else if (c >= r + number_of_rows()) return Value(0); else if (c >= number_of_rows()) return Base::operator()(r, c - number_of_rows()); else return Base::operator()(r, c); } }; CGAL_END_NAMESPACE #include CGAL_BEGIN_NAMESPACE template < class RandomAccessIC, class OutputIterator, class Traits, class IteratorCategory > OutputIterator all_furthest_neighbors_2( RandomAccessIC points_begin, RandomAccessIC points_end, OutputIterator o, const Traits& t, IteratorCategory) { using std::vector; using std::transform; using std::modulus; typedef All_furthest_neighbor_matrix< typename Traits::Compute_squared_distance_2, RandomAccessIC > Afn_matrix; // check preconditions: int number_of_points( iterator_distance( points_begin, points_end)); CGAL_optimisation_precondition( number_of_points > 0); CGAL_optimisation_expensive_precondition( is_convex_2( points_begin, points_end, t)); // prepare random access container: vector< int > v; v.reserve( number_of_points); for (int i = 0; i < number_of_points; ++i) v.push_back( 0); // compute maxima: monotone_matrix_search( dynamic_matrix( Afn_matrix(points_begin, points_end, t.compute_squared_distance_2_object())), v.begin()); // output result: return transform( v.begin(), v.end(), o, bind_2( modulus< int >(), number_of_points)); } // all_furthest_neighbors_2( ... ) template < class RandomAccessIC, class OutputIterator, class Traits > OutputIterator all_furthest_neighbors_2( RandomAccessIC points_begin, RandomAccessIC points_end, OutputIterator o, const Traits& CGAL_optimisation_expensive_precondition_code(t), std::random_access_iterator_tag) { typedef All_furthest_neighbor_matrix< typename Traits::Compute_squared_distance_2, RandomAccessIC > Afn_matrix; // check preconditions: int number_of_points( iterator_distance( points_begin, points_end)); CGAL_optimisation_precondition( number_of_points > 0); CGAL_optimisation_expensive_precondition( is_convex_2( points_begin, points_end, t)); // compute maxima: monotone_matrix_search( dynamic_matrix( Afn_matrix( points_begin, points_end)), o); return o + number_of_points; } // all_furthest_neighbors_2( ... ) template < class RandomAccessIC, class OutputIterator, class Traits > inline OutputIterator all_furthest_neighbors_2( RandomAccessIC points_begin, RandomAccessIC points_end, OutputIterator o, const Traits& t) { typedef typename std::iterator_traits< OutputIterator >::iterator_category iterator_category; return all_furthest_neighbors_2( points_begin, points_end, o, t, iterator_category()); } // all_furthest_neighbors_2( ... ) template < class RandomAccessIC, class OutputIterator > inline OutputIterator all_furthest_neighbors_2( RandomAccessIC points_begin, RandomAccessIC points_end, OutputIterator o) { typedef typename std::iterator_traits< RandomAccessIC >::value_type::R R; return all_furthest_neighbors_2( points_begin, points_end, o, R()); } // all_furthest_neighbors_2( ... ) // backwards compatibility template < class RandomAccessIC, class OutputIterator > inline OutputIterator all_furthest_neighbors( RandomAccessIC points_begin, RandomAccessIC points_end, OutputIterator o) { return all_furthest_neighbors_2( points_begin, points_end, o); } CGAL_END_NAMESPACE #endif // ! (CGAL_ALL_FURTHEST_NEIGHBORS_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_inexact_constructions_kernel.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_inexa0000644000175000017500000000304011344301500031373 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_inexact_constructions_kernel.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas, Sylvain Pion #ifndef CGAL_EXACT_PREDICATES_INEXACT_CONSTRUCTIONS_KERNEL_H #define CGAL_EXACT_PREDICATES_INEXACT_CONSTRUCTIONS_KERNEL_H #include #include CGAL_BEGIN_NAMESPACE typedef Filtered_kernel< Simple_cartesian > Exact_predicates_inexact_constructions_kernel; CGAL_END_NAMESPACE #endif // CGAL_EXACT_PREDICATES_INEXACT_CONSTRUCTIONS_KERNEL_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_approx_convex_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_approx_conve0000644000175000017500000002432011344301500031540 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_approx_convex_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_APPROX_CONVEX_H #define CGAL_PARTITION_APPROX_CONVEX_H #include #include #include #include #include #include #include #include #include #include namespace CGAL { template< class Point_2, class Traits > bool partition_appx_cvx_is_edge_through_interior(const Point_2& before_s, const Point_2& source, const Point_2& after_s, const Point_2& target, const Traits& traits ) { // determine if the edge goes through the interior of the polygon or not typedef typename Traits::Left_turn_2 Left_turn_2; Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (right_turn(before_s, source, after_s)) // concave angle { if (right_turn(before_s, source, target) && right_turn(target, source, after_s)) return false; } else // left turn or straight if (right_turn(before_s, source, target) || right_turn(target, source, after_s)) return false; return true; } // e_circ is a circulator for the edges incident to the point referred to by // v_ref, which is a circualtor around the vertices of the original polygon template bool partition_appx_cvx_cuts_nonconvex_angle( Edge_circulator e_circ, Circulator v_ref, const Triangulation& triangles, const Traits& traits) { typedef typename Triangulation::Segment Segment_2; #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG Segment_2 edge = triangles.segment((*e_circ).first, (*e_circ).second); std::cout << "edge: " << *edge.source() << " " << *edge.target() << std::endl; #endif typename Triangulation::Point next_ccw_pt_ref, prev_ccw_pt_ref; // the next and previous edges in the ccw ordering of edges around v_ref Edge_circulator next_e = e_circ; next_e++; Edge_circulator prev_e = e_circ; prev_e--; // find the first edge before this one that has been included in the // partition polygon (and is thus marked as constrained in triangulation) while (prev_e != e_circ && (triangles.is_infinite(*prev_e) || !(*prev_e).first->is_constrained((*prev_e).second))) prev_e--; Segment_2 next_edge = triangles.segment((*next_e).first,(*next_e).second); Segment_2 prev_edge = triangles.segment((*prev_e).first,(*prev_e).second); #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG std::cout << "next_edge: " << *next_edge.source() << " " << *next_edge.target() < right_turn(left_turn); return right_turn(*next_ccw_pt_ref, *v_ref, *prev_ccw_pt_ref); } template OutputIterator partition_approx_convex_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { if (first == beyond) return result; typedef Partitioned_polygon_2< Traits > P_Polygon_2; typedef typename P_Polygon_2::iterator I; typedef Circulator_from_iterator Circulator; typedef Triangulation_indirect_traits_2 Gt; typedef Constrained_triangulation_2 Constrained_tri_2; typedef typename Constrained_tri_2::Edge_iterator Edge_iterator; typedef typename Constrained_tri_2::Edge_circulator Edge_circulator; typedef typename Constrained_tri_2::Vertex_iterator Tri_vertex_iterator; typedef typename Constrained_tri_2::Vertex_handle Vertex_handle; typedef typename Gt::Segment_2 Segment_2; P_Polygon_2 polygon(first, beyond); CGAL_partition_precondition( orientation_2(polygon.begin(), polygon.end(), traits) == COUNTERCLOCKWISE); Circulator first_c(polygon.begin(), polygon.end(), polygon.begin()); Circulator c(polygon.begin(), polygon.end()); Circulator next(polygon.begin(), polygon.end()); Constrained_tri_2 triangles; do { next = c; next++; triangles.insert(c, next); } while (++c != first_c); Segment_2 edge; Circulator source, target, before_s, after_s; #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG std::cout << "Inserting diagonals: " << std::endl; #endif Edge_circulator e_circ, first_e; Tri_vertex_iterator v_it; for (v_it = triangles.vertices_begin(); v_it != triangles.vertices_end(); v_it++) { first_e = triangles.incident_edges(Vertex_handle(v_it)); // find the constrained edge attached to this vertex that is first // when going CW from the first edge returned above. while (triangles.is_infinite(*first_e) || !(*first_e).first->is_constrained((*first_e).second)) { first_e--; } e_circ = first_e; do { if ((*e_circ).first->is_constrained((*e_circ).second)) { edge = triangles.segment((*e_circ).first, (*e_circ).second); #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG std::cout << "edge " << *edge.source() << " " << *edge.target() << " is constrained " << std::endl; #endif } else { if (!triangles.is_infinite(*e_circ)) { edge = triangles.segment((*e_circ).first, (*e_circ).second); source = edge.source(); target = edge.target(); before_s = source; before_s--; after_s = source; after_s++; #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG std::cout << "considering " << *source << " " << *target << "..."; #endif if (partition_appx_cvx_is_edge_through_interior(*before_s, *source, *after_s, *target, traits)) { if (partition_appx_cvx_cuts_nonconvex_angle(e_circ, (*v_it).point(), triangles, traits)) { #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG std::cout << "inserting" << std::endl; #endif polygon.insert_diagonal(source, target); triangles.insert(source, target); } #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG else std::cout << "doesn't cut reflex angle" << std::endl; #endif } #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG else std::cout << "not an edge through the interior" << std::endl; #endif } #ifdef CGAL_PARTITION_APPROX_CONVEX_DEBUG std::cout << "edge is infinite " << std::endl; #endif } } while (++e_circ != first_e); } #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) OutputIterator res(result); #else typedef typename Traits::Polygon_2 Polygon_2; Tee_for_output_iterator res(result); #endif // no postconditions polygon.partition(res, 0); CGAL_partition_postcondition( convex_partition_is_valid_2(polygon.begin(), polygon.end(), res.output_so_far_begin(), res.output_so_far_end(), traits)); #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions } template inline OutputIterator partition_approx_convex_2(InputIterator first, InputIterator beyond, OutputIterator result) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return partition_approx_convex_2(first, beyond, result, Partition_traits_2()); } } #endif // CGAL_PARTITION_APPROX_CONVEX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/int.h0000644000175000017500000000622311344301500025766 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/int.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_INT_H #define CGAL_INT_H #include CGAL_BEGIN_NAMESPACE // int template <> struct Number_type_traits { typedef Tag_true Has_gcd; typedef Tag_false Has_division; typedef Tag_false Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; inline int div(int i1, int i2) { return i1 / i2; } inline double to_double(int i) { return static_cast(i); } inline std::pair to_interval(int i) { return std::pair(i, i); } inline bool is_finite(int) { return true; } inline bool is_valid(int) { return true; } inline io_Operator io_tag(int) { return io_Operator(); } // long template <> struct Number_type_traits { typedef Tag_true Has_gcd; typedef Tag_false Has_division; typedef Tag_false Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; inline long int div(long int i1, long int i2) { return i1 / i2; } inline double to_double(long int i) { return static_cast(i); } inline bool is_finite(long int) { return true; } inline bool is_valid(long int) { return true; } inline io_Operator io_tag(long int) { return io_Operator(); } // short template <> struct Number_type_traits { typedef Tag_true Has_gcd; typedef Tag_false Has_division; typedef Tag_false Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; inline short int div(short int i1, short int i2) { return i1 / i2; } inline double to_double(short int i) { return static_cast(i); } inline std::pair to_interval(short int i) { return std::pair(i, i); } inline bool is_finite(short int) { return true; } inline bool is_valid(short int) { return true; } inline io_Operator io_tag(short int) { return io_Operator(); } // Note : "long long" support is in CGAL_END_NAMESPACE #endif // CGAL_INT_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_quadrilateral_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_quadrilateral_trai0000644000175000017500000003350711344301500031427 0ustar debiandebian// Copyright (c) 1999-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_quadrilateral_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann and // Emo Welzl #if ! (CGAL_MIN_QUADRILATERAL_TRAITS_2_H) #define CGAL_MIN_QUADRILATERAL_TRAITS_2_H 1 #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace Optimisation { template < class Kernel_ > struct Min_rectangle_2 { typedef Kernel_ Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Direction_2 Direction_2; Min_rectangle_2(const Point_2& q1, const Direction_2& e, const Point_2& q2, const Point_2& q3, const Point_2& q4) : p1(q1), p2(q2), p3(q3), p4(q4), d(e) {} Point_2 p1, p2, p3, p4; Direction_2 d; }; template < class Kernel_ > struct Min_parallelogram_2 { typedef Kernel_ Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Direction_2 Direction_2; Min_parallelogram_2(const Point_2& q1, const Direction_2& e1, const Point_2& q2, const Direction_2& e2, const Point_2& q3, const Point_2& q4) : p1(q1), p2(q2), p3(q3), p4(q4), d1(e1), d2(e2) {} Point_2 p1, p2, p3, p4; Direction_2 d1, d2; }; template < class Kernel > std::ostream& operator<<(std::ostream& o, const Min_parallelogram_2& p) { if (p.d1 == p.d2) o << "Dirs equal!\n"; return o << "Para(\t" << p.p1 << ",\n" << p.d1 << ",\n" << p.p2 << ",\n" << p.d2 << ",\n" << p.p3 << ",\n" << p.p4 << ")"; } } // namespace Optimisation template < class K_ > struct Min_quadrilateral_default_traits_2 { // types inherited from Kernel typedef K_ Kernel; typedef typename Kernel::RT RT; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Vector_2 Vector_2; typedef typename Kernel::Direction_2 Direction_2; typedef typename Kernel::Line_2 Line_2; // predicates and constructions inherited from Kernel typedef typename Kernel::Equal_2 Equal_2; typedef typename Kernel::Less_xy_2 Less_xy_2; typedef typename Kernel::Less_yx_2 Less_yx_2; typedef typename Kernel::Has_on_negative_side_2 Has_on_negative_side_2; typedef typename Kernel::Compare_angle_with_x_axis_2 Compare_angle_with_x_axis_2; typedef typename Kernel::Construct_vector_2 Construct_vector_2; typedef typename Kernel::Construct_direction_2 Construct_direction_2; typedef typename Kernel::Construct_line_2 Construct_line_2; typedef typename Kernel::Construct_perpendicular_vector_2 Construct_perpendicular_vector_2; typedef typename Kernel::Construct_opposite_direction_2 Construct_opposite_direction_2; // used for expensive precondition checks only: typedef typename Kernel::Orientation_2 Orientation_2; protected: // used internally Construct_line_2 line; typename Kernel::Intersect_2 isec; public: // new types typedef Optimisation::Min_rectangle_2 Rectangle_2; typedef Optimisation::Min_parallelogram_2 Parallelogram_2; typedef Triple Strip_2; // new predicates struct Area_less_rectangle_2 : public CGAL_STD::binary_function< Rectangle_2, Rectangle_2, bool > { RT area_numerator(const Rectangle_2& r, Cartesian_tag) const { return (r.d.dx() * (r.p3.y() - r.p1.y()) + r.d.dy() * (r.p1.x() - r.p3.x())) * (-r.d.dy() * (r.p4.y() - r.p2.y()) + r.d.dx() * (r.p2.x() - r.p4.x())); } RT area_denominator(const Rectangle_2& r, Cartesian_tag) const { return CGAL_NTS square(r.d.dx()) + CGAL_NTS square(r.d.dy()); } RT area_numerator(const Rectangle_2& r, Homogeneous_tag) const { return (r.d.dx() * (r.p3.hy() * r.p1.hw() - r.p1.hy() * r.p3.hw()) + r.d.dy() * (r.p1.hx() * r.p3.hw() - r.p3.hx() * r.p1.hw())) * (-r.d.dy() * (r.p4.hy() * r.p2.hw() - r.p2.hy() * r.p4.hw()) + r.d.dx() * (r.p2.hx() * r.p4.hw() - r.p4.hx() * r.p2.hw())); } RT area_denominator(const Rectangle_2& r, Homogeneous_tag) const { return r.p1.hw() * r.p2.hw() * r.p3.hw() * r.p4.hw() * (CGAL_NTS square(r.d.dx()) + CGAL_NTS square(r.d.dy())); } bool operator()(const Rectangle_2& p, const Rectangle_2& q) const { typename Kernel::Rep_tag tag; #if defined(__sun) && defined(__SUNPRO_CC) // to avoid a warning "tag has not yet been assigned a value" typedef typename Kernel::Rep_tag Rep_tag; tag = Rep_tag(); #endif // SUNPRO return area_numerator(p, tag) * area_denominator(q, tag) < area_denominator(p, tag) * area_numerator(q, tag); } }; struct Area_less_parallelogram_2 : public CGAL_STD::binary_function< Parallelogram_2, Parallelogram_2, bool > { RT area_numerator(const Parallelogram_2& r, Cartesian_tag) const { return (r.d1.dx() * (r.p3.y() - r.p1.y()) - r.d1.dy() * (r.p3.x() - r.p1.x())) * (r.d2.dx() * (r.p4.y() - r.p2.y()) - r.d2.dy() * (r.p4.x() - r.p2.x())); } RT area_denominator(const Parallelogram_2& r, Cartesian_tag) const { return r.d1.dx() * r.d2.dy() - r.d1.dy() * r.d2.dx(); } RT area_numerator(const Parallelogram_2& r, Homogeneous_tag) const { return (r.d1.dx() * (r.p3.hy() * r.p1.hw() - r.p1.hy() * r.p3.hw()) - r.d1.dy() * (r.p3.hx() * r.p1.hw() - r.p1.hx() * r.p3.hw())) * (r.d2.dx() * (r.p4.hy() * r.p2.hw() - r.p2.hy() * r.p4.hw()) - r.d2.dy() * (r.p4.hx() * r.p2.hw() - r.p2.hx() * r.p4.hw())); } RT area_denominator(const Parallelogram_2& r, Homogeneous_tag) const { return r.p1.hw() * r.p2.hw() * r.p3.hw() * r.p4.hw() * (r.d1.dx() * r.d2.dy() - r.d1.dy() * r.d2.dx()); } bool operator()(const Parallelogram_2& p, const Parallelogram_2& q) const { typename Kernel::Rep_tag tag; #if defined(__sun) && defined(__SUNPRO_CC) // to avoid a warning "tag has not yet been assigned a value" typedef typename Kernel::Rep_tag Rep_tag; tag = Rep_tag(); #endif // SUNPRO return area_numerator(p, tag) * area_denominator(q, tag) < area_denominator(p, tag) * area_numerator(q, tag); } }; struct Width_less_strip_2 : public CGAL_STD::binary_function< Strip_2, Strip_2, bool > { RT width_numerator(const Strip_2& r, Cartesian_tag) const { return r.second.dx() * (r.third.y() - r.first.y()) + r.second.dy() * (r.first.x() - r.third.x()); } RT width_denominator(const Strip_2& r, Cartesian_tag) const { return CGAL_NTS square(r.second.dx()) + CGAL_NTS square(r.second.dy()); } RT width_numerator(const Strip_2& r, Homogeneous_tag) const { return r.second.dx() * (r.third.hy() * r.first.hw() - r.first.hy() * r.third.hw()) + r.second.dy() * (r.first.hx() * r.third.hw() - r.third.hx() * r.first.hw()); } RT width_denominator(const Strip_2& r, Homogeneous_tag) const { return r.first.hw() * r.third.hw() * (CGAL_NTS square(r.second.dx()) + CGAL_NTS square(r.second.dy())); } bool operator()(const Strip_2& p, const Strip_2& q) const { typename Kernel::Rep_tag tag; #if defined(__sun) && defined(__SUNPRO_CC) // to avoid a warning "tag has not yet been assigned a value" typedef typename Kernel::Rep_tag Rep_tag; tag = Rep_tag(); #endif // SUNPRO return width_numerator(p, tag) * width_denominator(q, tag) < width_denominator(p, tag) * width_numerator(q, tag); } }; // new constructions struct Construct_vector_from_direction_2 : public CGAL_STD::unary_function { Vector_2 operator()(const Direction_2& d) const { return d.vector(); } }; struct Construct_rectangle_2 { Rectangle_2 operator()(const Point_2& p1, const Direction_2& d1, const Point_2& p2, const Point_2& p3, const Point_2& p4) const { return Rectangle_2(p1, d1, p2, p3, p4); } }; template < class OutputIterator > OutputIterator copy_rectangle_vertices_2(const Rectangle_2& r, OutputIterator o) const { return copy_parallelogram_vertices_2( construct_parallelogram_2_object()( r.p1, r.d, r.p2, construct_direction_2_object()( construct_perpendicular_vector_2_object()( construct_vector_from_direction_2_object()(r.d), CLOCKWISE)), r.p3, r.p4), o); } struct Construct_parallelogram_2 { Parallelogram_2 operator()(const Point_2& p1, const Direction_2& d1, const Point_2& p2, const Direction_2& d2, const Point_2& p3, const Point_2& p4) const { return Parallelogram_2(p1, d1, p2, d2, p3, p4); } }; template < class OutputIterator > OutputIterator copy_parallelogram_vertices_2( const Parallelogram_2& r, OutputIterator o) const { Point_2 tmp; Line_2 tmpl; Object tmpo; tmpo = isec(line(r.p1, r.d1), line(r.p2, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { CGAL_optimisation_assertion_code(bool test1 =) assign(tmpl, tmpo); CGAL_optimisation_assertion(test1); *o++ = r.p1; } tmpo = isec(line(r.p3, r.d1), line(r.p2, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { CGAL_optimisation_assertion_code(bool test1 =) assign(tmpl, tmpo); CGAL_optimisation_assertion(test1); *o++ = r.p2; } tmpo = isec(line(r.p3, r.d1), line(r.p4, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { CGAL_optimisation_assertion_code(bool test1 =) assign(tmpl, tmpo); CGAL_optimisation_assertion(test1); *o++ = r.p3; } tmpo = isec(line(r.p1, r.d1), line(r.p4, r.d2)); if (assign(tmp, tmpo)) { *o++ = tmp; } else { CGAL_optimisation_assertion_code(bool test1 =) assign(tmpl, tmpo); CGAL_optimisation_assertion(test1); *o++ = r.p3; } return o; } struct Construct_strip_2 { Strip_2 operator()(const Point_2& p1, const Direction_2& d1, const Point_2& p2) const { return Strip_2(p1, d1, p2); } }; template < class OutputIterator > OutputIterator copy_strip_lines_2(const Strip_2& r, OutputIterator o) const { *o++ = line(r.first, r.second); *o++ = line(r.third, r.second); return o; } Equal_2 equal_2_object() const { return Equal_2(); } Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Has_on_negative_side_2 has_on_negative_side_2_object() const { return Has_on_negative_side_2(); } Compare_angle_with_x_axis_2 compare_angle_with_x_axis_2_object() const { return Compare_angle_with_x_axis_2(); } Area_less_rectangle_2 area_less_rectangle_2_object() const { return Area_less_rectangle_2(); } Area_less_parallelogram_2 area_less_parallelogram_2_object() const { return Area_less_parallelogram_2(); } Width_less_strip_2 width_less_strip_2_object() const { return Width_less_strip_2(); } Construct_vector_2 construct_vector_2_object() const { return Construct_vector_2(); } Construct_vector_from_direction_2 construct_vector_from_direction_2_object() const { return Construct_vector_from_direction_2(); } Construct_perpendicular_vector_2 construct_perpendicular_vector_2_object() const { return Construct_perpendicular_vector_2(); } Construct_direction_2 construct_direction_2_object() const { return Construct_direction_2(); } Construct_opposite_direction_2 construct_opposite_direction_2_object() const { return Construct_opposite_direction_2(); } Construct_line_2 construct_line_2_object() const { return Construct_line_2(); } Construct_rectangle_2 construct_rectangle_2_object() const { return Construct_rectangle_2(); } Construct_parallelogram_2 construct_parallelogram_2_object() const { return Construct_parallelogram_2(); } Construct_strip_2 construct_strip_2_object() const { return Construct_strip_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } }; CGAL_END_NAMESPACE #endif // ! (CGAL_MIN_QUADRILATERAL_TRAITS_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/determinant.h0000644000175000017500000002041311344301500027503 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/determinant.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion // Stefan Schirra #ifndef CGAL_DETERMINANT_H #define CGAL_DETERMINANT_H CGAL_BEGIN_NAMESPACE template inline FT det2x2_by_formula( const FT& a00, const FT& a01, const FT& a10, const FT& a11) { // First compute the det2x2 const FT m01 = a00*a11 - a10*a01; return m01; } template CGAL_KERNEL_MEDIUM_INLINE FT det3x3_by_formula( const FT& a00, const FT& a01, const FT& a02, const FT& a10, const FT& a11, const FT& a12, const FT& a20, const FT& a21, const FT& a22) { // First compute the det2x2 const FT m01 = a00*a11 - a10*a01; const FT m02 = a00*a21 - a20*a01; const FT m12 = a10*a21 - a20*a11; // Now compute the minors of rank 3 const FT m012 = m01*a22 - m02*a12 + m12*a02; return m012; } template CGAL_KERNEL_LARGE_INLINE FT det4x4_by_formula( const FT& a00, const FT& a01, const FT& a02, const FT& a03, const FT& a10, const FT& a11, const FT& a12, const FT& a13, const FT& a20, const FT& a21, const FT& a22, const FT& a23, const FT& a30, const FT& a31, const FT& a32, const FT& a33) { // First compute the det2x2 const FT m01 = a10*a01 - a00*a11; const FT m02 = a20*a01 - a00*a21; const FT m03 = a30*a01 - a00*a31; const FT m12 = a20*a11 - a10*a21; const FT m13 = a30*a11 - a10*a31; const FT m23 = a30*a21 - a20*a31; // Now compute the minors of rank 3 const FT m012 = m12*a02 - m02*a12 + m01*a22; const FT m013 = m13*a02 - m03*a12 + m01*a32; const FT m023 = m23*a02 - m03*a22 + m02*a32; const FT m123 = m23*a12 - m13*a22 + m12*a32; // Now compute the minors of rank 4 const FT m0123 = m123*a03 - m023*a13 + m013*a23 - m012*a33; return m0123; } template CGAL_KERNEL_LARGE_INLINE FT det5x5_by_formula( const FT& a00, const FT& a01, const FT& a02, const FT& a03, const FT& a04, const FT& a10, const FT& a11, const FT& a12, const FT& a13, const FT& a14, const FT& a20, const FT& a21, const FT& a22, const FT& a23, const FT& a24, const FT& a30, const FT& a31, const FT& a32, const FT& a33, const FT& a34, const FT& a40, const FT& a41, const FT& a42, const FT& a43, const FT& a44) { // First compute the det2x2 const FT m01 = a10*a01 - a00*a11; const FT m02 = a20*a01 - a00*a21; const FT m03 = a30*a01 - a00*a31; const FT m04 = a40*a01 - a00*a41; const FT m12 = a20*a11 - a10*a21; const FT m13 = a30*a11 - a10*a31; const FT m14 = a40*a11 - a10*a41; const FT m23 = a30*a21 - a20*a31; const FT m24 = a40*a21 - a20*a41; const FT m34 = a40*a31 - a30*a41; // Now compute the minors of rank 3 const FT m012 = m12*a02 - m02*a12 + m01*a22; const FT m013 = m13*a02 - m03*a12 + m01*a32; const FT m014 = m14*a02 - m04*a12 + m01*a42; const FT m023 = m23*a02 - m03*a22 + m02*a32; const FT m024 = m24*a02 - m04*a22 + m02*a42; const FT m034 = m34*a02 - m04*a32 + m03*a42; const FT m123 = m23*a12 - m13*a22 + m12*a32; const FT m124 = m24*a12 - m14*a22 + m12*a42; const FT m134 = m34*a12 - m14*a32 + m13*a42; const FT m234 = m34*a22 - m24*a32 + m23*a42; // Now compute the minors of rank 4 const FT m0123 = m123*a03 - m023*a13 + m013*a23 - m012*a33; const FT m0124 = m124*a03 - m024*a13 + m014*a23 - m012*a43; const FT m0134 = m134*a03 - m034*a13 + m014*a33 - m013*a43; const FT m0234 = m234*a03 - m034*a23 + m024*a33 - m023*a43; const FT m1234 = m234*a13 - m134*a23 + m124*a33 - m123*a43; // Now compute the minors of rank 5 const FT m01234 = m1234*a04 - m0234*a14 + m0134*a24 - m0124*a34 + m0123*a44; return m01234; } template FT det6x6_by_formula( const FT& a00, const FT& a01, const FT& a02, const FT& a03, const FT& a04, const FT& a05, const FT& a10, const FT& a11, const FT& a12, const FT& a13, const FT& a14, const FT& a15, const FT& a20, const FT& a21, const FT& a22, const FT& a23, const FT& a24, const FT& a25, const FT& a30, const FT& a31, const FT& a32, const FT& a33, const FT& a34, const FT& a35, const FT& a40, const FT& a41, const FT& a42, const FT& a43, const FT& a44, const FT& a45, const FT& a50, const FT& a51, const FT& a52, const FT& a53, const FT& a54, const FT& a55) { // First compute the det2x2 const FT m01 = a00*a11 - a10*a01; const FT m02 = a00*a21 - a20*a01; const FT m03 = a00*a31 - a30*a01; const FT m04 = a00*a41 - a40*a01; const FT m05 = a00*a51 - a50*a01; const FT m12 = a10*a21 - a20*a11; const FT m13 = a10*a31 - a30*a11; const FT m14 = a10*a41 - a40*a11; const FT m15 = a10*a51 - a50*a11; const FT m23 = a20*a31 - a30*a21; const FT m24 = a20*a41 - a40*a21; const FT m25 = a20*a51 - a50*a21; const FT m34 = a30*a41 - a40*a31; const FT m35 = a30*a51 - a50*a31; const FT m45 = a40*a51 - a50*a41; // Now compute the minors of rank 3 const FT m012 = m01*a22 - m02*a12 + m12*a02; const FT m013 = m01*a32 - m03*a12 + m13*a02; const FT m014 = m01*a42 - m04*a12 + m14*a02; const FT m015 = m01*a52 - m05*a12 + m15*a02; const FT m023 = m02*a32 - m03*a22 + m23*a02; const FT m024 = m02*a42 - m04*a22 + m24*a02; const FT m025 = m02*a52 - m05*a22 + m25*a02; const FT m034 = m03*a42 - m04*a32 + m34*a02; const FT m035 = m03*a52 - m05*a32 + m35*a02; const FT m045 = m04*a52 - m05*a42 + m45*a02; const FT m123 = m12*a32 - m13*a22 + m23*a12; const FT m124 = m12*a42 - m14*a22 + m24*a12; const FT m125 = m12*a52 - m15*a22 + m25*a12; const FT m134 = m13*a42 - m14*a32 + m34*a12; const FT m135 = m13*a52 - m15*a32 + m35*a12; const FT m145 = m14*a52 - m15*a42 + m45*a12; const FT m234 = m23*a42 - m24*a32 + m34*a22; const FT m235 = m23*a52 - m25*a32 + m35*a22; const FT m245 = m24*a52 - m25*a42 + m45*a22; const FT m345 = m34*a52 - m35*a42 + m45*a32; // Now compute the minors of rank 4 const FT m0123 = m012*a33 - m013*a23 + m023*a13 - m123*a03; const FT m0124 = m012*a43 - m014*a23 + m024*a13 - m124*a03; const FT m0125 = m012*a53 - m015*a23 + m025*a13 - m125*a03; const FT m0134 = m013*a43 - m014*a33 + m034*a13 - m134*a03; const FT m0135 = m013*a53 - m015*a33 + m035*a13 - m135*a03; const FT m0145 = m014*a53 - m015*a43 + m045*a13 - m145*a03; const FT m0234 = m023*a43 - m024*a33 + m034*a23 - m234*a03; const FT m0235 = m023*a53 - m025*a33 + m035*a23 - m235*a03; const FT m0245 = m024*a53 - m025*a43 + m045*a23 - m245*a03; const FT m0345 = m034*a53 - m035*a43 + m045*a33 - m345*a03; const FT m1234 = m123*a43 - m124*a33 + m134*a23 - m234*a13; const FT m1235 = m123*a53 - m125*a33 + m135*a23 - m235*a13; const FT m1245 = m124*a53 - m125*a43 + m145*a23 - m245*a13; const FT m1345 = m134*a53 - m135*a43 + m145*a33 - m345*a13; const FT m2345 = m234*a53 - m235*a43 + m245*a33 - m345*a23; // Now compute the minors of rank 5 const FT m01234 = m0123*a44 - m0124*a34 + m0134*a24 - m0234*a14 + m1234*a04; const FT m01235 = m0123*a54 - m0125*a34 + m0135*a24 - m0235*a14 + m1235*a04; const FT m01245 = m0124*a54 - m0125*a44 + m0145*a24 - m0245*a14 + m1245*a04; const FT m01345 = m0134*a54 - m0135*a44 + m0145*a34 - m0345*a14 + m1345*a04; const FT m02345 = m0234*a54 - m0235*a44 + m0245*a34 - m0345*a24 + m2345*a04; const FT m12345 = m1234*a54 - m1235*a44 + m1245*a34 - m1345*a24 + m2345*a14; // Now compute the minors of rank 6 const FT m012345 = m01234*a55 - m01235*a45 + m01245*a35 - m01345*a25 + m02345*a15 - m12345*a05; return m012345; } CGAL_END_NAMESPACE #endif // CGAL_DETERMINANT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convexity_check_2.C0000644000175000017500000001337011344301500030536 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convexity_check_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CONVEXITY_CHECK_2_C #define CGAL_CONVEXITY_CHECK_2_C #include #include #include #include CGAL_BEGIN_NAMESPACE template bool is_ccw_strongly_convex_2( ForwardIterator first, ForwardIterator last, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Left_turn_2 Left_turn; // added typedef typename Traits::Equal_2 Equal_2; Less_xy smaller_xy = ch_traits.less_xy_2_object(); Left_turn left_turn = ch_traits.left_turn_2_object(); Equal_2 equal_points = ch_traits.equal_2_object(); ForwardIterator iter1; ForwardIterator iter2; ForwardIterator iter3; if ( first == last) return true; iter2 = first; iter3 = ++iter2; if (iter3 == last ) return true; ++iter3; if (iter3 == last ) return (! equal_points(*first,*iter2) ); iter1 = first; short int f = 0; while (iter3 != last) { if ( !left_turn( *iter1, *iter2, *iter3 ) ) return false; if ( smaller_xy( *iter2, *iter1 ) && smaller_xy( *iter2, *iter3 )) ++f; ++iter1; ++iter2; ++iter3; } iter3 = first; if ( !left_turn( *iter1, *iter2, *iter3 ) ) return false; if ( smaller_xy( *iter2, *iter1 ) && smaller_xy( *iter2, *iter3 )) ++f; iter1 = iter2; iter2 = first; ++iter3; if ( !left_turn( *iter1, *iter2, *iter3 ) ) return false; if ( smaller_xy( *iter2, *iter1 ) && smaller_xy( *iter2, *iter3 )) ++f; return ( f > 1 ) ? false : true; } template bool is_cw_strongly_convex_2( ForwardIterator first, ForwardIterator last, const Traits& ch_traits) { typedef typename Traits::Less_xy_2 Less_xy; typedef typename Traits::Left_turn_2 Left_turn; typedef typename Traits::Equal_2 Equal_2; Less_xy smaller_xy = ch_traits.less_xy_2_object(); Equal_2 equal_points = ch_traits.equal_2_object(); ForwardIterator iter1; ForwardIterator iter2; ForwardIterator iter3; if ( first == last) return true; iter2 = first; iter3 = ++iter2; if (iter3 == last ) return true; ++iter3; if (iter3 == last ) return (! equal_points(*first,*iter2) ); iter1 = first; short int f = 0; while (iter3 != last) { if ( !left_turn( *iter2, *iter1, *iter3 ) ) return false; if ( smaller_xy( *iter2, *iter1 ) && smaller_xy( *iter2, *iter3 )) ++f; ++iter1; ++iter2; ++iter3; } iter3 = first; if ( !left_turn( *iter2, *iter1, *iter3 ) ) return false; if ( smaller_xy( *iter2, *iter1 ) && smaller_xy( *iter2, *iter3 )) ++f; iter1 = iter2; iter2 = first; ++iter3; if ( !left_turn( *iter2, *iter1, *iter3 ) ) return false; if ( smaller_xy( *iter2, *iter1 ) && smaller_xy( *iter2, *iter3 )) ++f; return ( f > 1 ) ? false : true; } template bool ch_brute_force_check_2(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, const Traits& ch_traits) { typedef typename Traits::Left_turn_2 Left_of_line; ForwardIterator1 iter11; ForwardIterator2 iter21; ForwardIterator2 iter22; if ( first1 == last1) return true; if ( first2 == last2) return false; if ( successor(first2) == last2 ) { while (first1 != last1) { if ( *first1++ != *first2 ) return false; } return true; } Left_of_line left_turn = ch_traits.left_turn_2_object(); iter22 = first2; iter21 = iter22++; while (iter22 != last2) { iter11 = std::find_if( first1, last1, bind_1(bind_1(left_turn,*iter22++), *iter21++) ); if (iter11 != last1 ) return false; } iter11 = std::find_if( first1, last1, bind_1(bind_1(left_turn, *first2), *iter21) ); if (iter11 != last1 ) return false; return true; } template bool ch_brute_force_chain_check_2(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, const Traits& ch_traits ) { typedef typename Traits::Left_turn_2 Left_turn_2; ForwardIterator1 iter11; ForwardIterator2 iter21; ForwardIterator2 iter22; if ( first1 == last1) return true; if ( first2 == last2) return false; if ( successor(first2) == last2 ) return true; Left_turn_2 left_turn = ch_traits.left_turn_2_object(); iter22 = first2; iter21 = iter22++; while (iter22 != last2) { iter11 = std::find_if( first1, last1, bind_1(bind_1(left_turn, *iter22++), *iter21++) ); if (iter11 != last1 ) return false; } return true; } CGAL_END_NAMESPACE #endif // CGAL_CONVEXITY_CHECK_2_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Handle_hash_function.h0000644000175000017500000000316711344301500031303 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Handle_hash_function.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel // Lutz Kettner #ifndef CGAL_HANDLE_HASH_FUNCTION_H #define CGAL_HANDLE_HASH_FUNCTION_H #include #include CGAL_BEGIN_NAMESPACE struct Handle_hash_function { typedef std::size_t result_type; template std::size_t operator() (const H& h) const { return std::size_t(&*h) / sizeof( typename std::iterator_traits::value_type); } }; CGAL_END_NAMESPACE #endif // CGAL_HANDLE_HASH_FUNCTION_H // EOF mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_traits_2.h0000644000175000017500000000257011344301500030433 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink #ifndef CGAL_POLYGON_TRAITS_2_H #define CGAL_POLYGON_TRAITS_2_H // For backward compatibility only. #include CGAL_BEGIN_NAMESPACE template class Polygon_traits_2 : public R_ {}; CGAL_END_NAMESPACE #endif // CGAL_POLYGON_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/misc.h0000644000175000017500000000300511344301500026122 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/misc.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_MISC_H #define CGAL_MISC_H CGAL_BEGIN_NAMESPACE // A helper class: template struct converter { static inline Target do_it(const Source& s) { return static_cast(s); } }; template inline Target convert_to (const Source& s) { return converter::do_it(s); } CGAL_END_NAMESPACE #endif // CGAL_MISC_H ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_traits_leda_kernel_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_traits_leda0000644000175000017500000002546211344301500031425 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_traits_leda_kernel_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Shai Hirsch // Efi Fogel #ifndef CGAL_PM_SEGMENT_TRAITS_LEDA_KERNEL #define CGAL_PM_SEGMENT_TRAITS_LEDA_KERNEL #include #include #include // if we use a LEDA version without namespaces we have to define a few macros #if !defined(LEDA_NAMESPACE) #define LEDA_BEGIN_NAMESPACE #define LEDA_END_NAMESPACE #define LEDA_NAMESPACE_NAME #endif CGAL_BEGIN_NAMESPACE /*! */ class my_rat_direction : public leda_rat_point { public: public: typedef leda_rational RT; typedef leda_rational FT; my_rat_direction(const leda_rat_point & p) : leda_rat_point(p) {} my_rat_direction(const FT x, const FT y) : leda_rat_point(x,y) {} /*! */ Sign sign_of_determinant2x2(const FT & a00, const FT & a01, const FT & a10, const FT & a11) const { return static_cast(static_cast(CGAL_NTS compare( a00*a11, a10*a01))); } /*! */ Comparison_result compare_angle_with_x_axis_2(const FT & dx1, const FT & dy1, const FT & dx2, const FT & dy2) const { // angles are in [-pi,pi], and the angle between Ox and d1 is compared // with the angle between Ox and d2 int quadrant_1 = (dx1 >= FT(0)) ? ((dy1 >= FT(0))?1:4) : ((dy1 >= FT(0))?2:3); int quadrant_2 = (dx2 >= FT(0)) ? ((dy2 >= FT(0))?1:4) : ((dy2 >= FT(0))?2:3); // We can't use CGAL_NTS compare(quadrant_1,quadrant_2) because in case // of tie, we need additional computation if (quadrant_1 > quadrant_2) return LARGER; else if (quadrant_1 < quadrant_2) return SMALLER; return Comparison_result(-sign_of_determinant2x2(dx1,dy1,dx2,dy2)); } /*! */ Comparison_result compare_angle_with_x_axis(const my_rat_direction & d1, const my_rat_direction & d2) const { return compare_angle_with_x_axis_2(d1.xcoord(), d1.ycoord(), d2.xcoord(), d2.ycoord()); } /*! */ bool operator<(const my_rat_direction & d) const { return compare_angle_with_x_axis(*this, d) == SMALLER; } /*! */ bool operator<=(const my_rat_direction & d) const { return compare_angle_with_x_axis(*this, d) != LARGER; } /*! */ bool counterclockwise_in_between(const my_rat_direction & d1, const my_rat_direction & d2) const { if (d1 <*this) return (*this < d2 || d2 <= d1); return (*this < d2 && d2 <= d1); } }; class Pm_segment_traits_leda_kernel_2 { private: typedef Pm_segment_traits_leda_kernel_2 Self; public: typedef leda_rational RT; typedef leda_rational FT; typedef leda_rat_point Point_2; typedef leda_rat_segment Segment_2; typedef my_rat_direction Direction_2; /*! Functor */ class Is_vertical_2 { public: /*! \todo Can cv be a point, or should it be prohobited by a precondition. */ bool operator()(const Segment_2 & cv) const { if (cv.is_trivial()) return true; return cv.is_vertical(); } }; /*! Functor */ class Equal_2 { public: bool operator()(const Point_2 & p1, const Point_2 & p2) const { return (p1 == p2); } bool operator()(const Segment_2 & c1, const Segment_2 & c2) const { return (c1 == c2); } }; /*! Functor */ class Compare_x_2 { public: Comparison_result operator()(const Point_2 & p1, const Point_2 & p2) const { int res = Self::Point_2::cmp_x(p1, p2); return ((res < 0) ? SMALLER : ((res > 0) ? LARGER : EQUAL)); } }; /*! Functor */ class Compare_xy_2 { public: Comparison_result operator()(const Point_2 & p1, const Point_2 & p2) const { int res = Self::Point_2::cmp_x(p1, p2); if (res != 0) return ((res < 0) ? SMALLER : LARGER); res = Self::Point_2::cmp_y(p1, p2); return ((res < 0) ? SMALLER : ((res > 0) ? LARGER : EQUAL)); } }; /*! Functor */ class Less_x_2 { public: bool operator()(const Point_2 & p1, const Point_2 & p2) const { return (Self::Point_2::cmp_x(p1, p2) < 0); } }; /*! Functor */ class Less_y_2 { public: bool operator()(const Point_2 & p1, const Point_2 & p2) const { return (Self::Point_2::cmp_y(p1, p2) < 0); } }; /*! Functor */ class Construct_vertex_2 { public: Point_2 operator()(const Segment_2 & cv, int id) const { return ((id == 0) ? cv.source() : cv.target()); } }; /*! Functor */ class Compare_y_at_x_2 { private: int cmp_x(const Point_2 & p1, const Point_2 & p2) const { return Self::Point_2::cmp_x(p1, p2); } int cmp_y(const Point_2 & p1, const Point_2 & p2) const { return Self::Point_2::cmp_y(p1, p2); } bool point_in_x_range(const Segment_2 & cv, const Point_2 & p) const { return !(((cmp_x(p, cv.source()) < 0) && (cmp_x(p, cv.target()) < 0)) || ((cmp_x(p, cv.source()) > 0) && (cmp_x(p, cv.target()) > 0))); } bool curve_is_in_y_range(const Segment_2 & cv, const Point_2 & p) const { return !(((cmp_y(p, cv.source()) < 0) && (cmp_y(p, cv.target()) < 0)) || ((cmp_y(p, cv.source()) > 0) && (cmp_y(p, cv.target()) > 0))); } Orientation orientation(const Point_2 & p, const Point_2 & q, const Point_2 & r) const { return CGAL::orientation(p, q, r); } public: Comparison_result operator()(const Point_2 & q, const Segment_2 & cv1, const Segment_2 & cv2) const { if ((!point_in_x_range(cv1, q)) || (!point_in_x_range(cv2, q))) return EQUAL; // bug ??? in LEDA - // cmp_segments_at_xcoord returns wrong answer if // cv1 (or cv2) are from right to left // cv1_ and cv2_ are the same as cv1 and cv2 - // oriented from left to right Segment_2 cv1_ = cv1; Segment_2 cv2_ = cv2; if (lexicographically_xy_larger(cv1.source(), cv1.target())) cv1_ = cv1.reversal(); if (lexicographically_xy_larger(cv2.source(), cv2.target())) cv2_ = cv2.reversal(); // checking verical curves. if (cv1_.is_vertical()) { if (cv2_.is_vertical()) { // both cv1 and cv2 are vertical int res = cmp_y(cv1_.target(), cv2_.source()); return ((res < 0) ? SMALLER : ((res > 0) ? LARGER : EQUAL)); } // only cv1 is vertical. if (orientation(cv2_.source(), cv2_.target(), cv1_.source()) > 0) return LARGER; if (orientation(cv2_.source(), cv2_.target(), cv1_.target()) < 0) return SMALLER; return EQUAL; } if (cv2_.is_vertical()) { // only cv2 is vertical: if (orientation(cv1_.source(), cv1_.target(), cv2_.source()) > 0 ) return SMALLER; if (orientation(cv1_.source(), cv1_.target(), cv2_.target()) < 0) return LARGER; return EQUAL; } // Non of the curves are vertical: int res = LEDA_NAMESPACE_NAME::cmp_segments_at_xcoord(cv1_, cv2_, q); return ((res < 0) ? SMALLER : ((res > 0) ? LARGER : EQUAL)); } Comparison_result operator()(const Point_2 & p, const Segment_2 & cv) { if (!point_in_x_range(cv, p)) return EQUAL; if (cv.is_vertical()) { if ((cmp_y(p, cv.source()) < 0) && (cmp_y(p, cv.target()) < 0)) return SMALLER; if ((cmp_y(p, cv.source()) > 0) && (cmp_y(p, cv.target()) > 0)) return LARGER; return EQUAL; } Orientation o = (cmp_x(cv.source(), cv.target()) < 0) ? orientation(cv.source(), cv.target(), p) : orientation(cv.target(), cv.source(), p); return ((o < 0) ? SMALLER : ((o > 0) ? LARGER : EQUAL)); } }; /*! */ class Compare_slope_2 { public: Comparison_result operator()(const Segment_2 & cv1, const Segment_2 & cv2) const { int res = LEDA_NAMESPACE_NAME::cmp_slopes(cv1, cv2); return ((res < 0) ? SMALLER : ((res > 0) ? LARGER : EQUAL)); } }; /*! */ class Counterclockwise_in_between_2 { public: bool operator()(const Direction_2 & d, const Direction_2 & d1, const Direction_2 & d2) const { return d.counterclockwise_in_between(d1, d2); } }; /*! */ class Construct_direction_2 { public: Direction_2 operator()(const Segment_2 & cv) const { return Direction_2(cv.target() - cv.source()); } }; /*! */ class Construct_opposite_direction_2 { public: Direction_2 operator()(const Direction_2 & d) const { return Direction_2(-d.xcoord(), -d.ycoord()); } }; /*! */ class Construct_opposite_segment_2 { public: Segment_2 operator()(const Segment_2 & seg) const { return Segment_2(seg.target(), seg.source()); } }; // creators: Is_vertical_2 is_vertical_2_object() const { return Is_vertical_2(); } Equal_2 equal_2_object() const { return Equal_2(); } Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_xy_2 compare_xy_2_object() const { return Compare_xy_2(); } Construct_vertex_2 construct_vertex_2_object() const { return Construct_vertex_2(); } Compare_y_at_x_2 compare_y_at_x_2_object() const { return Compare_y_at_x_2(); } Less_x_2 less_x_2_object() const { return Less_x_2(); } Compare_slope_2 compare_slope_2_object() const { return Compare_slope_2(); } Counterclockwise_in_between_2 counterclockwise_in_between_2_object() const { return Counterclockwise_in_between_2(); } Construct_direction_2 construct_direction_2_object() const { return Construct_direction_2(); } Construct_opposite_direction_2 construct_opposite_direction_2_object() const { return Construct_opposite_direction_2(); } Construct_opposite_segment_2 construct_opposite_segment_2_object() const { return Construct_opposite_segment_2(); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_euclidean_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000002662411344301500031455 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_euclidean_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec // Sylvain Pion #ifndef CGAL_REGULAR_TRIANGULATION_EUCLIDEAN_TRAITS_2_H #define CGAL_REGULAR_TRIANGULATION_EUCLIDEAN_TRAITS_2_H #include #include #include #include #ifndef CGAL_REP_CLASS_DEFINED #error no representation class defined #endif // CGAL_REP_CLASS_DEFINED #if defined CGAL_CARTESIAN_H || defined CGAL_SIMPLE_CARTESIAN_H #include #include #endif #if defined CGAL_HOMOGENEOUS_H || defined CGAL_SIMPLE_HOMOGENEOUS_H #include #include #endif CGAL_BEGIN_NAMESPACE // constructions for DUALITY: weighted_circumcenter and radical // axis template < class Bare_point, class We > inline Bare_point weighted_circumcenter(const Weighted_point< Bare_point,We >& p, const Weighted_point< Bare_point,We >& q, const Weighted_point< Bare_point,We >& r, Cartesian_tag ) { typename Bare_point::R::RT x,y; weighted_circumcenterC2(p.x(),p.y(),p.weight(), q.x(),q.y(),q.weight(), r.x(),r.y(),r.weight(),x,y); return Bare_point(x,y); } template < class Bare_point, class We > inline Bare_point weighted_circumcenter(const Weighted_point< Bare_point,We >& p, const Weighted_point< Bare_point,We >& q, const Weighted_point< Bare_point,We >& r, Homogeneous_tag ) { typename Bare_point::R::RT x,y,w; weighted_circumcenterH2(p.hx(),p.hy(),p.hw(),p.weight(), q.hx(),q.hy(),q.hw(),q.weight(), r.hx(),r.hy(),r.hw(),r.weight(), x,y,w); return Bare_point(x,y,w); } template < class Bare_point, class We > inline Bare_point weighted_circumcenter(const Weighted_point< Bare_point,We >& p, const Weighted_point< Bare_point,We >& q, const Weighted_point< Bare_point,We >& r) { typedef typename Bare_point::R::Rep_tag Tag; return weighted_circumcenter(p, q, r, Tag()); } template < typename K > class Construct_weighted_circumcenter_2 { public: typedef typename K::Weighted_point_2 Weighted_point_2; typedef typename K::Bare_point Bare_point; typedef Arity_tag< 3 > Arity; typedef Bare_point result_type; Bare_point operator() ( const Weighted_point_2 & p, const Weighted_point_2 & q, const Weighted_point_2 & r) const { CGAL_triangulation_precondition( ! collinear(p, q, r) ); return CGAL::weighted_circumcenter(p,q,r); } }; template < class Bare_point, class We > inline Line_2 radical_axis(const Weighted_point< Bare_point,We >& p, const Weighted_point< Bare_point,We >& q, Cartesian_tag ) { typedef typename Bare_point::R::RT RT; typedef typename Bare_point::R Rep; RT a,b,c; radical_axisC2(p.x(),p.y(),p.weight(),q.x(),q.y(),q.weight(),a,b,c); return Line_2(a,b,c); } template < class Bare_point, class We > inline Line_2 radical_axis(const Weighted_point< Bare_point,We >& p, const Weighted_point< Bare_point,We >& q, Homogeneous_tag) { typedef typename Bare_point::R::RT RT; typedef typename Bare_point::R Rep; RT a,b,c; radical_axisH2(p.hx(),p.hy(), p.hw(), p.weight(), q.hx(),q.hy(), q.hw(), q.weight(),a,b,c); return Line_2(a,b,c); } template < class Bare_point, class We > inline Line_2 radical_axis(const Weighted_point< Bare_point,We >& p, const Weighted_point< Bare_point,We >& q) { typedef typename Bare_point::R::Rep_tag Tag; return radical_axis(p, q, Tag()); } template < typename K > class Construct_radical_axis_2 { public: typedef typename K::Weighted_point_2 Weighted_point_2; typedef typename K::Line_2 Line_2; typedef Arity_tag< 2 > Arity; typedef Line_2 result_type; Line_2 operator() ( const Weighted_point_2 & p, const Weighted_point_2 & q) const { return CGAL::radical_axis(p,q); } }; ///----------------------------------------------------------- template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &t, Cartesian_tag ) { typedef typename Bare_point::R::FT FT; return power_testC2(p.x(), p.y(), FT(p.weight()), q.x(), q.y(), FT(q.weight()), r.x(), r.y(), FT(r.weight()), t.x(), t.y(), FT(t.weight())); } template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &t, Homogeneous_tag ) { typedef typename Bare_point::R::RT RT; return power_testH2(p.hx(), p.hy(), p.hw(), RT(p.weight()), q.hx(), q.hy(), q.hw(), RT(q.weight()), r.hx(), r.hy(), r.hw(), RT(r.weight()), t.hx(), t.hy(), t.hw(), RT(t.weight())); } template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &r, const Weighted_point &t) { typedef typename Bare_point::R::Rep_tag Tag; return power_test(p, q, r, t, Tag()); } template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &t, Cartesian_tag ) { typedef typename Bare_point::R::FT FT; return power_testC2(p.x(), p.y(), FT(p.weight()), q.x(), q.y(), FT(q.weight()), t.x(), t.y(), FT(t.weight())); } template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &t, Homogeneous_tag ) { typedef typename Bare_point::R::RT RT; return power_testH2(p.hx(), p.hy(), p.hw(), RT(p.weight()), q.hx(), q.hy(), q.hw(), RT(q.weight()), t.hx(), t.hy(), t.hw(), RT(t.weight())); } template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &q, const Weighted_point &t) { typedef typename Bare_point::R::Rep_tag Tag; return power_test(p, q, t, Tag()); } template < class Bare_point, class Weight > inline Oriented_side power_test(const Weighted_point &p, const Weighted_point &t) { typedef typename Bare_point::R::RT RT; Comparison_result r = Compare()(p.weight(), t.weight()); if(r == LARGER) return ON_NEGATIVE_SIDE; else if (r == SMALLER) return ON_POSITIVE_SIDE; return ON_ORIENTED_BOUNDARY; } template < typename K > class Power_test_2 { public: typedef typename K::Weighted_point_2 Weighted_point_2; typedef Arity_tag< 4 > Arity; typedef Oriented_side result_type; Oriented_side operator() ( const Weighted_point_2 & p, const Weighted_point_2 & q, const Weighted_point_2 & r, const Weighted_point_2 & s) const { //CGAL_triangulation_precondition( ! collinear(p, q, r) ); return CGAL::power_test(p,q,r,s); } Oriented_side operator() ( const Weighted_point_2 & p, const Weighted_point_2 & q, const Weighted_point_2 & r) const { //CGAL_triangulation_precondition( collinear(p, q, r) ); //CGAL_triangulation_precondition( p.point() != q.point() ); return CGAL::power_test(p,q,r); } Oriented_side operator() ( const Weighted_point_2 & p, const Weighted_point_2 & r) const { //CGAL_triangulation_precondition( p.point() == r.point() ); return CGAL::power_test(p,r); } }; template < class R, class W = typename R::RT> class Regular_triangulation_euclidean_traits_base_2 : public R { public: typedef R Rep; typedef W Weight; typedef R Traits; typedef typename Traits::Point_2 Bare_point; typedef typename Traits::Point_2 Point_2; typedef CGAL::Weighted_point Weighted_point_2; // This is required for the point() function of vertex base class // to be correctly return a weighted_point; // patch 27/11/00 // 18/03/03 I put now the same typedef in Regulat_triangulation_2 // for the need of hierarchy // don't know if this is definitive //typedef Weighted_point Point_2; typedef Regular_triangulation_euclidean_traits_base_2 Self; typedef CGAL::Power_test_2 Power_test_2; // construction objects typedef CGAL::Construct_weighted_circumcenter_2 Construct_weighted_circumcenter_2; typedef CGAL::Construct_radical_axis_2 Construct_radical_axis_2; Power_test_2 power_test_2_object() const { return Power_test_2();} //constructions for dual: Construct_weighted_circumcenter_2 construct_weighted_circumcenter_2_object() const {return Construct_weighted_circumcenter_2();} Construct_radical_axis_2 construct_radical_axis_2_object() const {return Construct_radical_axis_2();} }; // We use a base class here to have the specialization below to work. // Otherwise there is a cycle in the derivation. template < class R, class W = typename R::RT> class Regular_triangulation_euclidean_traits_2 : public Regular_triangulation_euclidean_traits_base_2 {}; CGAL_END_NAMESPACE // Now specialize for Exact_predicates_ienxact_constructions_kernel, to get // the filtered traits automatically. #include #include CGAL_BEGIN_NAMESPACE template <> class Regular_triangulation_euclidean_traits_2 : public Regular_triangulation_filtered_traits_2 {}; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_EUCLIDEAN_TRAITS_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_curve_origin_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_curve_origin_trait0000644000175000017500000001416511344301500031454 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_curve_origin_traits_2.h,v $ // $Revision: 1.1.1.1 $ // $Name: $ // // Author(s) : Ron Wein // Efi Fogel #ifndef CGAL_CURVE_ORIGIN_TRAITS_2_H #define CGAL_CURVE_ORIGIN_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE /*! A generic traits class for maintaining an arrangement of X-monotone curves, * such that each point to their respective origin curve. This traits class * is templated with an base ordinary traits class and derived from it. * The X_monotone_curve_2 type is extracted from the base traits class, and * redefines it to have a pointer to a Curve_2 type as an extra field. * * The pointer is updated when the curves are converted from Curve_2 to * X_monotone_curve_2, and when the X_monotone_curve_2 curves are split. All * other methods are inherited from the base ordinary traits class. */ template class Arr_curve_origin_traits_2 : public Traits_ { public: typedef Traits_ Traits; typedef typename Traits::Curve_2 Curve_2; typedef typename Traits::Point_2 Point_2; typedef typename Traits::X_monotone_curve_2 Org_x_monotone_curve_2; class X_monotone_curve_2 : public Org_x_monotone_curve_2 { private: enum {CURVE_2, X_MONOTONE_CURVE_2} m_type; union { Curve_2 * m_curve; X_monotone_curve_2 * m_x_monotone_curve; } m_origin; public: /*! Parameterless constructor */ X_monotone_curve_2() {} /*! Constructor */ X_monotone_curve_2(const Org_x_monotone_curve_2 & cv, Curve_2 * origin) : Org_x_monotone_curve_2(cv) { m_type = CURVE_2; m_origin.m_curve = origin; } /*! Constructor */ X_monotone_curve_2(const Org_x_monotone_curve_2 & cv, X_monotone_curve_2 * origin) : Org_x_monotone_curve_2(cv) { m_type = X_MONOTONE_CURVE_2; m_origin.m_x_monotone_curve = origin; } /*! Constructor */ X_monotone_curve_2(const X_monotone_curve_2 * cv) { m_type = cv->m_type; if (m_type == CURVE_2) m_origin.m_curve = cv->m_origin.m_curve; else m_origin.m_x_monotone_curve = cv->m_origin.m_x_monotone_curve; } /*! obtains the curve type */ bool is_origin_x_monotone() const { return (m_type == X_MONOTONE_CURVE_2); } /*! obtains the curve origin */ Curve_2 * get_origin_curve() const { return m_origin.m_curve; } /*! obtains the curve x-monotone origin */ X_monotone_curve_2 * get_origin_x_monotone_curve() const { return m_origin.m_x_monotone_curve; } }; typedef typename std::list List_curve_2; typedef typename std::list List_x_monotone_curve_2; // For backward compatibility: typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; private: Traits m_traits; mutable List_curve_2 m_curves; mutable List_x_monotone_curve_2 m_x_monotone_curves; public: Arr_curve_origin_traits_2() : m_traits() {} ~Arr_curve_origin_traits_2() { typename List_curve_2::const_iterator cit; for (cit = m_curves.begin(); cit != m_curves.end(); ++cit) delete *cit; m_curves.clear(); typename List_x_monotone_curve_2::const_iterator xcit; for (xcit = m_x_monotone_curves.begin(); xcit != m_x_monotone_curves.end(); ++xcit) delete *xcit; m_x_monotone_curves.clear(); } /*! Cut the given curve into x-monotone subcurves and insert them to the * given output iterator. While segments are x_monotone, still need to pass * them out. * \param cv the curve. * \param o the output iterator * \return the past-the-end iterator * * \todo This function does not compile when made 'const', why? */ template OutputIterator curve_make_x_monotone(const Curve_2 & cv, OutputIterator o) // const { std::list org_x_curves; m_traits.curve_make_x_monotone(cv, std::back_inserter(org_x_curves)); typename std::list::const_iterator it; Curve_2 * stored_cv = new Curve_2(cv); m_curves.push_back(stored_cv); for (it = org_x_curves.begin(); it != org_x_curves.end(); it++) *o++ = X_monotone_curve_2(*it, stored_cv); return o; } /*! Split a given curve at a given split point into two sub-curves. * \param cv the curve to split * \param c1 the output first part of the split curve. Its source is the * source of the original curve. * \param c2 the output second part of the split curve. Its target is the * target of the original curve. * \param p the split point. * \pre p lies on cv but is not one of its end-points. */ void curve_split(const X_monotone_curve_2 & cv, X_monotone_curve_2 & c1, X_monotone_curve_2 & c2, const Point_2 & p) const { Org_x_monotone_curve_2 org_c1, org_c2; m_traits.curve_split(cv, org_c1, org_c2, p); X_monotone_curve_2 * stored_cv; if (cv.is_origin_x_monotone()) stored_cv = cv.get_origin_x_monotone_curve(); else { stored_cv = new X_monotone_curve_2(cv); m_x_monotone_curves.push_back(stored_cv); } c1 = X_monotone_curve_2(org_c1, stored_cv); c2 = X_monotone_curve_2(org_c2, stored_cv); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Rotation_tree_node_2.h0000644000175000017500000001113611344301500031237 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Rotation_tree_node_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert /* Node of a rotation tree, used for computing the visibility graph of a set of non-intersecting segments in a graph Associated with each node in the rotation tree is the following information - the coordinates of the associated segment endpoint - a pointer to the parent - a pointer to the left sibling - a pointer to the right sibling - a pointer to the rightmost child. */ #ifndef CGAL_ROTATION_TREE_NODE_H #define CGAL_ROTATION_TREE_NODE_H #include // MSVC6 doesn't work with the CGALi::vector but it does with the std::vector // (from stlport?) #if (defined( _MSC_VER) && (_MSC_VER <= 1200)) || defined(__BORLANDC__) #include #else #include #endif // MSVC6 namespace CGAL { template class Rotation_tree_2; template class Rotation_tree_node_2 : public Traits::Point_2 { public: typedef typename Traits::Point_2 Base_point; typedef Rotation_tree_node_2 Self; #if (defined( _MSC_VER) && (_MSC_VER <= 1200)) || defined(__BORLANDC__) typedef std::vector< Self > Tree; #else typedef CGALi::vector< Self > Tree; #endif typedef typename Tree::iterator Tree_iterator; typedef std::pair Node_ref; Rotation_tree_node_2(Base_point p) : Base_point(p) { _parent.second = false; _left_sibling.second = false; _right_sibling.second = false; _rightmost_child.second = false; } bool has_left_sibling() const { return _left_sibling.second; } Tree_iterator left_sibling() const { return _left_sibling.first; } bool has_right_sibling() const { return _right_sibling.second; } Tree_iterator right_sibling() const { return _right_sibling.first; } bool has_parent() const { return _parent.second; } Tree_iterator parent() const { return _parent.first; } bool has_children() const { return _rightmost_child.second; } Tree_iterator rightmost_child() const { return _rightmost_child.first; } void set_left_sibling(Tree_iterator ls) { _left_sibling.first = ls; _left_sibling.second = true; } void clear_left_sibling() { _left_sibling.second = false; } void set_right_sibling(Tree_iterator rs) { _right_sibling.first = rs; _right_sibling.second = true; } void clear_right_sibling() { _right_sibling.second = false; } void set_parent(Tree_iterator p) { _parent.first = p; _parent.second = true; } void clear_parent() { _parent.second = false; } void set_rightmost_child(Tree_iterator c) { _rightmost_child.first = c; _rightmost_child.second = true; } void clear_rightmost_child() { _rightmost_child.second = false; } bool is_a_leaf() { return !_rightmost_child.second; } private: Node_ref _parent; Node_ref _left_sibling; Node_ref _right_sibling; Node_ref _rightmost_child; }; #ifdef CGAL_PARTITION_DEBUG template std::ostream& operator<<(std::ostream& os, const Rotation_tree_node_2& node) { os << node.x() << " " << node.y() << " "; if (node.has_parent()) os << " parent " << (*node.parent()).x() << " " << (*node.parent()).y() << " "; if (node.has_left_sibling()) os << " left sibling " << (*node.left_sibling()).x() << " " << (*node.left_sibling()).y() << " "; if (node.has_right_sibling()) os << " right sibling " << (*node.right_sibling()).x() << " " << (*node.right_sibling()).y() << " "; if (node.has_children()) os << " rightmost child " << (*node.rightmost_child()).x() << " " << (*node.rightmost_child()).y(); return os; } #endif // CGAL_PARTITION_DEBUG } #endif // CGAL_ROTATION_NODE_TREE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_face_base.h0000644000175000017500000001665111344301500031100 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_face_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_FACE_BASE_H #define CGAL_HALFEDGEDS_FACE_BASE_H 1 #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE // We use Tag_false to indicate that no plane type is provided. template < class Refs, class T = Tag_true, class Pln = Tag_false> class HalfedgeDS_face_base; template < class Refs > class HalfedgeDS_face_base< Refs, Tag_false, Tag_false> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_face_base< Refs, Tag_false, Tag_false> Base; typedef Tag_false Supports_face_halfedge; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Halfedge Halfedge; // Additional tags required by Polyhedron. typedef Tag_false Supports_face_plane; struct Plane_not_supported {}; typedef Plane_not_supported Plane; // No longer required. // typedef Tag_false Supports_face_normal; }; template < class Refs > class HalfedgeDS_face_base< Refs, Tag_true, Tag_false> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_face_base< Refs, Tag_true, Tag_false> Base; typedef Tag_true Supports_face_halfedge; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Halfedge Halfedge; // Additional tags required by Polyhedron. typedef Tag_false Supports_face_plane; struct Plane_not_supported {}; typedef Plane_not_supported Plane; // No longer required. //typedef Tag_false Supports_face_normal; private: Halfedge_handle hdg; public: Halfedge_handle halfedge() { return hdg; } Halfedge_const_handle halfedge() const { return hdg; } void set_halfedge( Halfedge_handle h) { hdg = h; } }; template < class Refs, class Pln > class HalfedgeDS_face_base< Refs, Tag_false, Pln> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_face_base< Refs, Tag_false, Pln> Base; typedef Tag_false Supports_face_halfedge; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Halfedge Halfedge; // Additional tags and types required by Polyhedron. typedef Tag_true Supports_face_plane; typedef Pln Plane; // No longer required. //typedef Tag_true Supports_face_normal; //typedef Trts Traits; //typedef typename Traits::Normal Normal; //typedef typename Traits::Plane Plane; private: Plane pln; public: HalfedgeDS_face_base() {} HalfedgeDS_face_base( const Plane& g) : pln(g) {} Plane& plane() { return pln; } const Plane& plane() const { return pln; } // No longer required. // Normal normal() const { return pln.orthogonal_vector();} }; template < class Refs, class Pln > class HalfedgeDS_face_base< Refs, Tag_true, Pln> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_face_base< Refs, Tag_true, Pln> Base; typedef Tag_true Supports_face_halfedge; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Vertex Vertex; typedef typename Refs::Halfedge Halfedge; // Additional tags and types required by Polyhedron. typedef Tag_true Supports_face_plane; typedef Pln Plane; // No longer required. //typedef Tag_true Supports_face_normal; //typedef Trts Traits; //typedef typename Traits::Normal Normal; //typedef typename Traits::Plane Plane; private: Halfedge_handle hdg; Plane pln; public: HalfedgeDS_face_base() {} HalfedgeDS_face_base( const Plane& g) : pln(g) {} Halfedge_handle halfedge() { return hdg; } Halfedge_const_handle halfedge() const { return hdg; } void set_halfedge( Halfedge_handle h) { hdg = h; } Plane& plane() { return pln; } const Plane& plane() const { return pln; } // No longer required. //Normal normal() const { return pln.orthogonal_vector();} }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_FACE_BASE_H // // EOF // ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_p_center_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_p_center_20000644000175000017500000002544411344301500031363 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_p_center_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_RECTANGULAR_P_CENTER_2_H) #define CGAL_RECTANGULAR_P_CENTER_2_H 1 #include #include #include #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif // CGAL_REP_CLASS_DEFINED CGAL_BEGIN_NAMESPACE CGAL_END_NAMESPACE #include CGAL_BEGIN_NAMESPACE template < class Operation, class RandomAccessIC_row, class RandomAccessIC_column > class Cartesian_matrix_horizontally_flipped : public Cartesian_matrix< Operation, RandomAccessIC_row, RandomAccessIC_column > { public: typedef Cartesian_matrix< Operation, RandomAccessIC_row, RandomAccessIC_column > Base; typedef typename Base::Value Value; using Base::number_of_rows; using Base::number_of_columns; /* Cartesian_matrix_horizontally_flipped( Operation o = Operation()) : Base( o) {} */ Cartesian_matrix_horizontally_flipped( RandomAccessIC_row r_f, RandomAccessIC_row r_l, RandomAccessIC_column c_f, RandomAccessIC_column c_l) : Base( r_f, r_l, c_f, c_l) {} Cartesian_matrix_horizontally_flipped( RandomAccessIC_row r_f, RandomAccessIC_row r_l, RandomAccessIC_column c_f, RandomAccessIC_column c_l, const Operation& o) : Base( r_f, r_l, c_f, c_l, o) {} Value operator()( int r, int c) const { CGAL_optimisation_precondition( r >= 0 && r < number_of_rows()); CGAL_optimisation_precondition( c >= 0 && c < number_of_columns()); return Base::operator()( r, number_of_columns() - 1 - c); } }; template < class Operation, class RandomAccessIC_row, class RandomAccessIC_column > inline Cartesian_matrix_horizontally_flipped< Operation, RandomAccessIC_row, RandomAccessIC_column > cartesian_matrix_horizontally_flipped( RandomAccessIC_row r_f, RandomAccessIC_row r_l, RandomAccessIC_column c_f, RandomAccessIC_column c_l, const Operation& o) { return Cartesian_matrix_horizontally_flipped< Operation, RandomAccessIC_row, RandomAccessIC_column > ( r_f, r_l, c_f, c_l, o); } /* template < class ForwardIterator, class OutputIterator, class FT, class PiercingFunction > inline OutputIterator rectangular_p_center_2_binary_search( ForwardIterator f, ForwardIterator l, OutputIterator o, FT& r, const PiercingFunction& pf) { return rectangular_p_center_2_binary_search( f, l, o, r, pf, CGAL_reinterpret_cast( Rectangular_p_center_matrix_search_traits_2< PiercingFunction >, 0)); } // rectangular_p_center_2_binary_search( ... ) template < class ForwardIterator, class OutputIterator, class Traits > OutputIterator rectangular_p_center_2_binary_search( ForwardIterator f, ForwardIterator l, OutputIterator o, typename Traits::FT& r, const typename Traits::PiercingFunction& pf, Traits*) // // preconditions: // -------------- // * Traits fulfills the requirements for PCenter traits classes // * value type of ForwardIterator is Traits::Point_2 // * OutputIterator accepts Traits::Point_2 as value type // * the range [f,l) is not empty // // functionality: // -------------- // { CGAL_optimisation_precondition( f != l); // typedefs: typedef typename Traits::FT FT; typedef typename Traits::X X; typedef typename Traits::Y Y; // create Traits object: Traits pierce_it( f, l, pf); // check, if input data is trivial bool ok; OutputIterator oi = pierce_it(FT(0), o, ok); if (ok) { r = 0; return oi; } // create vector with absolute coordinate differences: std::vector< FT > c_diffs; c_diffs.reserve( pierce_it.number_of_points() * (pierce_it.number_of_points() - 1)); for ( ForwardIterator i( f); i != l; ++i) for ( ForwardIterator j( i + 1); j != l; ++j) { c_diffs.push_back( CGAL_NTS abs( i->x() - j->x())); c_diffs.push_back( CGAL_NTS abs( i->y() - j->y())); } CGAL_optimisation_assertion( c_diffs.size() == pierce_it.number_of_points() * (pierce_it.number_of_points() - 1)); // sort it: sort( c_diffs.begin(), c_diffs.end()); // search it: int b( 0); int e( c_diffs.size()); // invariant of the following loop: // forall 0 <= a < b: c_diffs[a] is infeasible AND // forall e <= a < c_diffs.size(): c_diffs[a] is feasible while ( e > b) { int c = ( e + b) >> 1; if ( pierce_it( c_diffs[c])) { // c_diffs[c] is feasible e = c; } else { // c_diffs[c] is infeasible b = c + 1; } } // while ( e > b) CGAL_optimisation_assertion( e == b); // return the result: r = c_diffs[e]; OutputIterator o_return( pierce_it( r, o, ok)); CGAL_optimisation_assertion( ok); return o_return; } // rectangular_p_center_2_binary_search( ... ) */ template < class RandomAccessIC, class OutputIterator, class PiercingFunction, class Traits, class MatrixOperator > OutputIterator rectangular_p_center_2_matrix_search( RandomAccessIC f, RandomAccessIC l, OutputIterator o, typename Traits::FT& r, PiercingFunction pf, const Traits& t, const MatrixOperator& mop) { int number_of_points( iterator_distance( f, l)); CGAL_optimisation_precondition( number_of_points > 0); using std::minus; using std::sort; // typedefs: typedef typename Traits::FT FT; typedef std::vector< FT > FT_cont; typedef typename FT_cont::iterator FT_iterator; typedef Cartesian_matrix_horizontally_flipped< MatrixOperator, FT_iterator, FT_iterator > Matrix; typedef std::vector< Matrix > MatrixContainer; typedef Rectangular_p_center_matrix_search_traits_2< Traits, PiercingFunction > MSTraits; typedef Sorted_matrix_search_traits_adaptor< MSTraits&, Matrix > Matrix_search_traits; // create Traits object: MSTraits pierce_it(f, l, t, pf); // check, if input data is trivial bool ok; OutputIterator oi = pierce_it(FT(0), o, ok); if (ok) { r = 0; return oi; } // create matrix search traits: Matrix_search_traits search_it(pierce_it); // copy x and y coordinates from [f,l): std::vector< FT > x_coords; std::vector< FT > y_coords; x_coords.reserve( number_of_points); y_coords.reserve( number_of_points); for ( RandomAccessIC p( f); p != l; ++p) { x_coords.push_back(p->x()); y_coords.push_back(p->y()); } // sort coordinates: sort( x_coords.begin(), x_coords.end()); sort( y_coords.begin(), y_coords.end()); // create matrices: MatrixContainer matrices; // create matrix of x-differences: matrices.push_back( Matrix( x_coords.begin(), x_coords.end(), x_coords.begin(), x_coords.end(), mop)); // create matrix of y-differences: matrices.push_back( Matrix( y_coords.begin(), y_coords.end(), y_coords.begin(), y_coords.end(), mop)); // do the actual search: r = sorted_matrix_search(matrices.begin(), matrices.end(), search_it); // return result: OutputIterator o_return(pierce_it(r, o, ok)); CGAL_optimisation_assertion(ok); return o_return; } // P_center_matrix_search template < class RandomAccessIC, class OutputIterator, class PiercingFunction, class Traits > inline OutputIterator rectangular_p_center_2_matrix_search( RandomAccessIC f, RandomAccessIC l, OutputIterator o, typename Traits::FT& r, const PiercingFunction& pf, const Traits& t) { typedef typename Traits::FT FT; using std::minus; return rectangular_p_center_2_matrix_search( f, l, o, r, pf, t, compose(bind_1(Max< FT >(), 0), minus< FT >())); } // Pcenter_matrix_search( ... ) template < class ForwardIterator, class OutputIterator, class FT > inline OutputIterator rectangular_p_center_matrix_search_2( ForwardIterator f, ForwardIterator l, OutputIterator o, FT& r, int p) { CGAL_optimisation_precondition(p >= 2 && p < 5); typename std::iterator_traits::value_type::R t; if (p == 2) return rectangular_p_center_2_matrix_search( f, l, o, r, Two_covering_algorithm(), t); else if (p == 3) return rectangular_p_center_2_matrix_search( f, l, o, r, Three_covering_algorithm(), t); return rectangular_p_center_2_matrix_search( f, l, o, r, Four_covering_algorithm(), t); } // rectangular_p_center_matrix_search_2(f, l, o, r, p) template < class ForwardIterator, class OutputIterator, class Traits > inline OutputIterator rectangular_p_center_2(ForwardIterator f, ForwardIterator l, OutputIterator o, typename Traits::FT& r, int p, Traits& t) { CGAL_optimisation_precondition(p >= 2 && p < 5); if (p == 2) return rectangular_2_center_2(f, l, o, r, t); else if (p == 3) return rectangular_3_center_2(f, l, o, r, t); return rectangular_p_center_2_matrix_search( f, l, o, r, Four_covering_algorithm(), t); } // rectangular_p_center_2( ... ) template < class ForwardIterator, class OutputIterator, class FT > inline OutputIterator rectangular_p_center_2(ForwardIterator f, ForwardIterator l, OutputIterator o, FT& r, int p) { CGAL_optimisation_precondition(p >= 2 && p < 5); typedef typename std::iterator_traits< ForwardIterator >::value_type::R R; Rectangular_p_center_default_traits_2< R > t; return rectangular_p_center_2(f, l, o, r, p, t); } // rectangular_p_center_2( ... ) CGAL_END_NAMESPACE #endif // ! (CGAL_RECTANGULAR_P_CENTER_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_gcc2-95-2_fix.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000011617211344301500031420 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_gcc2-95-2_fix.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_GCC2_92_2_FIX #define CGAL_MINIBALL_GCC2_92_2_FIX // This is file bitset: /* * Copyright (c) 1998 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. */ #ifndef __SGI_STL_BITSET #define __SGI_STL_BITSET // This implementation of bitset<> has a second template parameter, // _WordT, which defaults to unsigned long. *YOU SHOULD NOT USE // THIS FEATURE*. It is experimental, and it may be removed in // future releases. // A bitset of size N, using words of type _WordT, will have // N % (sizeof(_WordT) * CHAR_BIT) unused bits. (They are the high- // order bits in the highest word.) It is a class invariant // of class bitset<> that those unused bits are always zero. // Most of the actual code isn't contained in bitset<> itself, but in the // base class _Base_bitset. The base class works with whole words, not with // individual bits. This allows us to specialize _Base_bitset for the // important special case where the bitset is only a single word. // The C++ standard does not define the precise semantics of operator[]. // In this implementation the const version of operator[] is equivalent // to test(), except that it does no range checking. The non-const version // returns a reference to a bit, again without doing any range checking. #include // for size_t #include // for CHAR_BIT #include #include // for invalid_argument, out_of_range, overflow_error #include // for istream, ostream #define __BITS_PER_WORDT(__wt) (CHAR_BIT*sizeof(__wt)) #define __BITSET_WORDS(__n,__wt) \ ((__n) < 1 ? 1 : ((__n) + __BITS_PER_WORDT(__wt) - 1)/__BITS_PER_WORDT(__wt)) __STL_BEGIN_NAMESPACE #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) #pragma set woff 1209 #endif // structure to aid in counting bits template struct _Bit_count { static unsigned char _S_bit_count[256]; }; // Mapping from 8 bit unsigned integers to the index of the first one // bit: template struct _First_one { static unsigned char _S_first_one[256]; }; // // Base class: general case. // template struct _Base_bitset { _WordT _M_w[_Nw]; // 0 is the least significant word. _Base_bitset( void ) { _M_do_reset(); } _Base_bitset(unsigned long __val); static size_t _S_whichword( size_t __pos ) { return __pos / __BITS_PER_WORDT(_WordT); } static size_t _S_whichbyte( size_t __pos ) { return (__pos % __BITS_PER_WORDT(_WordT)) / CHAR_BIT; } static size_t _S_whichbit( size_t __pos ) { return __pos % __BITS_PER_WORDT(_WordT); } static _WordT _S_maskbit( size_t __pos ) { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t __pos) { return _M_w[_S_whichword(__pos)]; } _WordT _M_getword(size_t __pos) const { return _M_w[_S_whichword(__pos)]; } _WordT& _M_hiword() { return _M_w[_Nw - 1]; } _WordT _M_hiword() const { return _M_w[_Nw - 1]; } void _M_do_and(const _Base_bitset<_Nw,_WordT>& __x) { for ( size_t __i = 0; __i < _Nw; __i++ ) { _M_w[__i] &= __x._M_w[__i]; } } void _M_do_or(const _Base_bitset<_Nw,_WordT>& __x) { for ( size_t __i = 0; __i < _Nw; __i++ ) { _M_w[__i] |= __x._M_w[__i]; } } void _M_do_xor(const _Base_bitset<_Nw,_WordT>& __x) { for ( size_t __i = 0; __i < _Nw; __i++ ) { _M_w[__i] ^= __x._M_w[__i]; } } void _M_do_left_shift(size_t __shift); void _M_do_right_shift(size_t __shift); void _M_do_flip() { for ( size_t __i = 0; __i < _Nw; __i++ ) { _M_w[__i] = ~_M_w[__i]; } } void _M_do_set() { for ( size_t __i = 0; __i < _Nw; __i++ ) { _M_w[__i] = ~static_cast<_WordT>(0); } } void _M_do_reset() { for ( size_t __i = 0; __i < _Nw; __i++ ) { _M_w[__i] = 0; } } bool _M_is_equal(const _Base_bitset<_Nw,_WordT>& __x) const { for (size_t __i = 0; __i < _Nw; ++__i) { if (_M_w[__i] != __x._M_w[__i]) return false; } return true; } bool _M_is_any() const { for ( size_t __i = 0; __i < __BITSET_WORDS(_Nw,_WordT); __i++ ) { if ( _M_w[__i] != static_cast<_WordT>(0) ) return true; } return false; } size_t _M_do_count() const { size_t __result = 0; const unsigned char* __byte_ptr = (const unsigned char*)_M_w; const unsigned char* __end_ptr = (const unsigned char*)(_M_w+_Nw); while ( __byte_ptr < __end_ptr ) { __result += _Bit_count::_S_bit_count[*__byte_ptr]; __byte_ptr++; } return __result; } unsigned long _M_do_to_ulong() const; // find first "on" bit size_t _M_do_find_first(size_t __not_found) const; // find the next "on" bit that follows "prev" size_t _M_do_find_next(size_t __prev, size_t __not_found) const; }; // // Definitions of non-inline functions from _Base_bitset. // template _Base_bitset<_Nw, _WordT>::_Base_bitset(unsigned long __val) { _M_do_reset(); const size_t __n = min(sizeof(unsigned long)*CHAR_BIT, __BITS_PER_WORDT(_WordT)*_Nw); for(size_t __i = 0; __i < __n; ++__i, __val >>= 1) if ( __val & 0x1 ) _M_getword(__i) |= _S_maskbit(__i); } template void _Base_bitset<_Nw, _WordT>::_M_do_left_shift(size_t __shift) { if (__shift != 0) { const size_t __wshift = __shift / __BITS_PER_WORDT(_WordT); const size_t __offset = __shift % __BITS_PER_WORDT(_WordT); const size_t __sub_offset = __BITS_PER_WORDT(_WordT) - __offset; size_t __n = _Nw - 1; for ( ; __n > __wshift; --__n) _M_w[__n] = (_M_w[__n - __wshift] << __offset) | (_M_w[__n - __wshift - 1] >> __sub_offset); if (__n == __wshift) _M_w[__n] = _M_w[0] << __offset; for (size_t __n1 = 0; __n1 < __n; ++__n1) _M_w[__n1] = static_cast<_WordT>(0); } } template void _Base_bitset<_Nw, _WordT>::_M_do_right_shift(size_t __shift) { if (__shift != 0) { const size_t __wshift = __shift / __BITS_PER_WORDT(_WordT); const size_t __offset = __shift % __BITS_PER_WORDT(_WordT); const size_t __sub_offset = __BITS_PER_WORDT(_WordT) - __offset; const size_t __limit = _Nw - __wshift - 1; size_t __n = 0; for ( ; __n < __limit; ++__n) _M_w[__n] = (_M_w[__n + __wshift] >> __offset) | (_M_w[__n + __wshift + 1] << __sub_offset); _M_w[__limit] = _M_w[_Nw-1] >> __offset; for (size_t __n1 = __limit + 1; __n1 < _Nw; ++__n1) _M_w[__n1] = static_cast<_WordT>(0); } } template unsigned long _Base_bitset<_Nw, _WordT>::_M_do_to_ulong() const { const overflow_error __overflow("bitset"); if (sizeof(_WordT) >= sizeof(unsigned long)) { for (size_t __i = 1; __i < _Nw; ++__i) if (_M_w[__i]) __STL_THROW(__overflow); const _WordT __mask = static_cast<_WordT>(static_cast(-1)); if (_M_w[0] & ~__mask) __STL_THROW(__overflow); return static_cast(_M_w[0] & __mask); } else { // sizeof(_WordT) < sizeof(unsigned long). const size_t __nwords = (sizeof(unsigned long) + sizeof(_WordT) - 1) / sizeof(_WordT); size_t __min_nwords = __nwords; if (_Nw > __nwords) { for (size_t __i = __nwords; __i < _Nw; ++__i) if (_M_w[__i]) __STL_THROW(__overflow); } else __min_nwords = _Nw; // If unsigned long is 8 bytes and _WordT is 6 bytes, then an unsigned // long consists of all of one word plus 2 bytes from another word. const size_t __part = sizeof(unsigned long) % sizeof(_WordT); if (__part != 0 && __nwords <= _Nw && (_M_w[__min_nwords - 1] >> ((sizeof(_WordT) - __part) * CHAR_BIT)) != 0) __STL_THROW(__overflow); unsigned long __result = 0; for (size_t __i = 0; __i < __min_nwords; ++__i) { __result |= static_cast( _M_w[__i]) << (__i * sizeof(_WordT) * CHAR_BIT); } return __result; } } // End _M_do_to_ulong template size_t _Base_bitset<_Nw, _WordT>::_M_do_find_first(size_t __not_found) const { for ( size_t __i = 0; __i < _Nw; __i++ ) { _WordT __thisword = _M_w[__i]; if ( __thisword != static_cast<_WordT>(0) ) { // find byte within word for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) { unsigned char __this_byte = static_cast(__thisword & (~(unsigned char)0)); if ( __this_byte ) return __i*__BITS_PER_WORDT(_WordT) + __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; __thisword >>= CHAR_BIT; } } } // not found, so return an indication of failure. return __not_found; } template size_t _Base_bitset<_Nw, _WordT>::_M_do_find_next(size_t __prev, size_t __not_found) const { // make bound inclusive ++__prev; // check out of bounds if ( __prev >= _Nw * __BITS_PER_WORDT(_WordT) ) return __not_found; // search first word size_t __i = _S_whichword(__prev); _WordT __thisword = _M_w[__i]; // mask off bits below bound __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); if ( __thisword != static_cast<_WordT>(0) ) { // find byte within word // get first byte into place __thisword >>= _S_whichbyte(__prev) * CHAR_BIT; for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) { unsigned char __this_byte = static_cast(__thisword & (~(unsigned char)0)); if ( __this_byte ) return __i*__BITS_PER_WORDT(_WordT) + __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; __thisword >>= CHAR_BIT; } } // check subsequent words __i++; for ( ; __i < _Nw; __i++ ) { _WordT __thisword = _M_w[__i]; if ( __thisword != static_cast<_WordT>(0) ) { // find byte within word for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) { unsigned char __this_byte = static_cast(__thisword & (~(unsigned char)0)); if ( __this_byte ) return __i*__BITS_PER_WORDT(_WordT) + __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; __thisword >>= CHAR_BIT; } } } // not found, so return an indication of failure. return __not_found; } // end _M_do_find_next // ------------------------------------------------------------ // // Base class: specialization for a single word. // template struct _Base_bitset<1, _WordT> { _WordT _M_w; _Base_bitset( void ) { _M_do_reset(); } _Base_bitset(unsigned long __val); static size_t _S_whichword( size_t __pos ) { return __pos / __BITS_PER_WORDT(_WordT); } static size_t _S_whichbyte( size_t __pos ) { return (__pos % __BITS_PER_WORDT(_WordT)) / CHAR_BIT; } static size_t _S_whichbit( size_t __pos ) { return __pos % __BITS_PER_WORDT(_WordT); } static _WordT _S_maskbit( size_t __pos ) { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); } _WordT& _M_getword(size_t) { return _M_w; } _WordT _M_getword(size_t) const { return _M_w; } _WordT& _M_hiword() { return _M_w; } _WordT _M_hiword() const { return _M_w; } void _M_do_and(const _Base_bitset<1,_WordT>& __x) { _M_w &= __x._M_w; } void _M_do_or(const _Base_bitset<1,_WordT>& __x) { _M_w |= __x._M_w; } void _M_do_xor(const _Base_bitset<1,_WordT>& __x) { _M_w ^= __x._M_w; } void _M_do_left_shift(size_t __shift) { _M_w <<= __shift; } void _M_do_right_shift(size_t __shift) { _M_w >>= __shift; } void _M_do_flip() { _M_w = ~_M_w; } void _M_do_set() { _M_w = ~static_cast<_WordT>(0); } void _M_do_reset() { _M_w = 0; } bool _M_is_equal(const _Base_bitset<1,_WordT>& __x) const { return _M_w == __x._M_w; } bool _M_is_any() const { return _M_w != 0; } size_t _M_do_count() const { size_t __result = 0; const unsigned char* __byte_ptr = (const unsigned char*)&_M_w; const unsigned char* __end_ptr = ((const unsigned char*)&_M_w)+ sizeof(_M_w); while ( __byte_ptr < __end_ptr ) { __result += _Bit_count::_S_bit_count[*__byte_ptr]; __byte_ptr++; } return __result; } unsigned long _M_do_to_ulong() const { if (sizeof(_WordT) <= sizeof(unsigned long)) return static_cast(_M_w); else { const _WordT __mask = static_cast<_WordT>( static_cast(-1)); if (_M_w & ~__mask) __STL_THROW(overflow_error("bitset")); return static_cast(_M_w); } } size_t _M_do_find_first(size_t __not_found) const; // find the next "on" bit that follows "prev" size_t _M_do_find_next(size_t __prev, size_t __not_found) const; }; // // Definitions of non-inline functions from the single-word version of // _Base_bitset. // template _Base_bitset<1, _WordT>::_Base_bitset(unsigned long __val) { _M_do_reset(); const size_t __n = min(sizeof(unsigned long)*CHAR_BIT, __BITS_PER_WORDT(_WordT)*_Nw); for(size_t __i = 0; __i < __n; ++__i, __val >>= 1) if ( __val & 0x1 ) _M_w |= _S_maskbit(__i); } template size_t _Base_bitset<1, _WordT>::_M_do_find_first(size_t __not_found) const { _WordT __thisword = _M_w; if ( __thisword != static_cast<_WordT>(0) ) { // find byte within word for ( size_t __j = 0; __j < sizeof(_WordT); __j++ ) { unsigned char __this_byte = static_cast(__thisword & (~(unsigned char)0)); if ( __this_byte ) return __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; __thisword >>= CHAR_BIT; } } // not found, so return a value that indicates failure. return __not_found; } template size_t _Base_bitset<1, _WordT>::_M_do_find_next(size_t __prev, size_t __not_found ) const { // make bound inclusive ++__prev; // check out of bounds if ( __prev >= __BITS_PER_WORDT(_WordT) ) return __not_found; // search first (and only) word _WordT __thisword = _M_w; // mask off bits below bound __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev); if ( __thisword != static_cast<_WordT>(0) ) { // find byte within word // get first byte into place __thisword >>= _S_whichbyte(__prev) * CHAR_BIT; for ( size_t __j = _S_whichbyte(__prev); __j < sizeof(_WordT); __j++ ) { unsigned char __this_byte = static_cast(__thisword & (~(unsigned char)0)); if ( __this_byte ) return __j*CHAR_BIT + _First_one::_S_first_one[__this_byte]; __thisword >>= CHAR_BIT; } } // not found, so return a value that indicates failure. return __not_found; } // end _M_do_find_next // // One last specialization: _M_do_to_ulong() and the constructor from // unsigned long are very simple if the bitset consists of a single // word of type unsigned long. // template<> inline unsigned long _Base_bitset<1, unsigned long>::_M_do_to_ulong() const { return _M_w; } template<> inline _Base_bitset<1, unsigned long>::_Base_bitset(unsigned long __val) { _M_w = __val; } // ------------------------------------------------------------ // Helper class to zero out the unused high-order bits in the highest word. template struct _Sanitize { static void _M_do_sanitize(_WordT& __val) { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); } }; template struct _Sanitize<_WordT, 0> { static void _M_do_sanitize(_WordT) {} }; // ------------------------------------------------------------ // Class bitset. // _Nb may be any nonzero number of type size_t. // Type _WordT may be any unsigned integral type. template class bitset : private _Base_bitset<__BITSET_WORDS(_Nb,_WordT), _WordT> { private: typedef _Base_bitset<__BITSET_WORDS(_Nb,_WordT), _WordT> _Base; // Import base's protected interface. Necessary because of new template // name resolution rules. using _Base::_S_whichword; using _Base::_S_whichbyte; using _Base::_S_whichbit; using _Base::_S_maskbit; using _Base::_M_getword; using _Base::_M_hiword; using _Base::_M_do_and; using _Base::_M_do_or; using _Base::_M_do_xor; using _Base::_M_do_left_shift; using _Base::_M_do_right_shift; using _Base::_M_do_flip; using _Base::_M_do_set; using _Base::_M_do_reset; using _Base::_M_is_equal; using _Base::_M_is_any; using _Base::_M_do_count; using _Base::_M_do_to_ulong; using _Base::_M_do_find_first; using _Base::_M_do_find_next; private: void _M_do_sanitize() { _Sanitize<_WordT,_Nb%__BITS_PER_WORDT(_WordT) > ::_M_do_sanitize(_M_hiword()); } public: // bit reference: class reference; friend class reference; class reference { friend class bitset; _WordT *_M_wp; size_t _M_bpos; // left undefined reference(); reference( bitset& __b, size_t __pos ) { _M_wp = &__b._M_getword(__pos); _M_bpos = _S_whichbit(__pos); } public: ~reference() {} // for b[i] = __x; reference& operator=(bool __x) { if ( __x ) *_M_wp |= _S_maskbit(_M_bpos); else *_M_wp &= ~_S_maskbit(_M_bpos); return *this; } // for b[i] = b[__j]; reference& operator=(const reference& __j) { if ( (*(__j._M_wp) & _S_maskbit(__j._M_bpos)) ) *_M_wp |= _S_maskbit(_M_bpos); else *_M_wp &= ~_S_maskbit(_M_bpos); return *this; } // flips the bit bool operator~() const { return (*(_M_wp) & _S_maskbit(_M_bpos)) == 0; } // for __x = b[i]; operator bool() const { return (*(_M_wp) & _S_maskbit(_M_bpos)) != 0; } // for b[i].flip(); reference& flip() { *_M_wp ^= _S_maskbit(_M_bpos); return *this; } }; // 23.3.5.1 constructors: bitset() {} bitset(unsigned long __val) : _Base_bitset<__BITSET_WORDS(_Nb,_WordT), _WordT>(__val) {} template explicit bitset(const basic_string<_CharT,_Traits,_Alloc>& __s, size_t __pos = 0, size_t __n = size_t(basic_string<_CharT,_Traits,_Alloc>:: npos)) : _Base() { if (__pos > __s.size()) __STL_THROW(out_of_range("bitset")); _M_copy_from_string(__s, __pos, __n); } // 23.3.5.2 bitset operations: bitset<_Nb,_WordT>& operator&=(const bitset<_Nb,_WordT>& __rhs) { _M_do_and(__rhs); return *this; } bitset<_Nb,_WordT>& operator|=(const bitset<_Nb,_WordT>& __rhs) { _M_do_or(__rhs); return *this; } bitset<_Nb,_WordT>& operator^=(const bitset<_Nb,_WordT>& __rhs) { _M_do_xor(__rhs); return *this; } bitset<_Nb,_WordT>& operator<<=(size_t __pos) { _M_do_left_shift(__pos); _M_do_sanitize(); return *this; } bitset<_Nb,_WordT>& operator>>=(size_t __pos) { _M_do_right_shift(__pos); _M_do_sanitize(); return *this; } // // Extension: // Versions of single-bit set, reset, flip, test with no range checking. // bitset<_Nb,_WordT>& _Unchecked_set(size_t __pos) { _M_getword(__pos) |= _S_maskbit(__pos); return *this; } bitset<_Nb,_WordT>& _Unchecked_set(size_t __pos, int __val) { if (__val) _M_getword(__pos) |= _S_maskbit(__pos); else _M_getword(__pos) &= ~_S_maskbit(__pos); return *this; } bitset<_Nb,_WordT>& _Unchecked_reset(size_t __pos) { _M_getword(__pos) &= ~_S_maskbit(__pos); return *this; } bitset<_Nb,_WordT>& _Unchecked_flip(size_t __pos) { _M_getword(__pos) ^= _S_maskbit(__pos); return *this; } bool _Unchecked_test(size_t __pos) const { return (_M_getword(__pos) & _S_maskbit(__pos)) != static_cast<_WordT>(0); } // Set, reset, and flip. bitset<_Nb,_WordT>& set() { _M_do_set(); _M_do_sanitize(); return *this; } bitset<_Nb,_WordT>& set(size_t __pos) { if (__pos >= _Nb) __STL_THROW(out_of_range("bitset")); return _Unchecked_set(__pos); } bitset<_Nb,_WordT>& set(size_t __pos, int __val) { if (__pos >= _Nb) __STL_THROW(out_of_range("bitset")); return _Unchecked_set(__pos, __val); } bitset<_Nb,_WordT>& reset() { _M_do_reset(); return *this; } bitset<_Nb,_WordT>& reset(size_t __pos) { if (__pos >= _Nb) __STL_THROW(out_of_range("bitset")); return _Unchecked_reset(__pos); } bitset<_Nb,_WordT>& flip() { _M_do_flip(); _M_do_sanitize(); return *this; } bitset<_Nb,_WordT>& flip(size_t __pos) { if (__pos >= _Nb) __STL_THROW(out_of_range("bitset")); return _Unchecked_flip(__pos); } bitset<_Nb,_WordT> operator~() const { return bitset<_Nb,_WordT>(*this).flip(); } // element access: //for b[i]; reference operator[](size_t __pos) { return reference(*this,__pos); } bool operator[](size_t __pos) const { return _Unchecked_test(__pos); } unsigned long to_ulong() const { return _M_do_to_ulong(); } #ifdef __STL_EXPLICIT_FUNCTION_TMPL_ARGS template basic_string<_CharT, _Traits, _Alloc> to_string() const { basic_string<_CharT, _Traits, _Alloc> __result; _M_copy_to_string(__result); return __result; } #endif /* __STL_EXPLICIT_FUNCTION_TMPL_ARGS */ // Helper functions for string operations. template void _M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s, size_t, size_t); // Helper functions for string operations. template void _M_copy_to_string(basic_string<_CharT,_Traits,_Alloc>&) const; size_t count() const { return _M_do_count(); } size_t size() const { return _Nb; } bool operator==(const bitset<_Nb,_WordT>& __rhs) const { return _M_is_equal(__rhs); } bool operator!=(const bitset<_Nb,_WordT>& __rhs) const { return !_M_is_equal(__rhs); } bool test(size_t __pos) const { if (__pos > _Nb) __STL_THROW(out_of_range("bitset")); return _Unchecked_test(__pos); } bool any() const { return _M_is_any(); } bool none() const { return !_M_is_any(); } bitset<_Nb,_WordT> operator<<(size_t __pos) const { return bitset<_Nb,_WordT>(*this) <<= __pos; } bitset<_Nb,_WordT> operator>>(size_t __pos) const { return bitset<_Nb,_WordT>(*this) >>= __pos; } // // EXTENSIONS: bit-find operations. These operations are // experimental, and are subject to change or removal in future // versions. // // find the index of the first "on" bit size_t _Find_first() const { return _M_do_find_first(_Nb); } // find the index of the next "on" bit after prev size_t _Find_next( size_t __prev ) const { return _M_do_find_next(__prev, _Nb); } }; // // Definitions of non-inline member functions. // template template void bitset<_Nb, _WordT> ::_M_copy_from_string(const basic_string<_CharT,_Traits,_Alloc>& __s, size_t __pos, size_t __n) { reset(); const size_t __nbits = min(_Nb, min(__n, __s.size() - __pos)); for (size_t __i = 0; __i < __nbits; ++__i) { switch(__s[__pos + __nbits - __i - 1]) { case '0': break; case '1': set(__i); break; default: __STL_THROW(invalid_argument("bitset")); } } } template template void bitset<_Nb, _WordT> ::_M_copy_to_string(basic_string<_CharT, _Traits, _Alloc>& __s) const { __s.assign(_Nb, '0'); for (size_t __i = 0; __i < _Nb; ++__i) if (_Unchecked_test(__i)) __s[_Nb - 1 - __i] = '1'; } // ------------------------------------------------------------ // // 23.3.5.3 bitset operations: // template inline bitset<_Nb,_WordT> operator&(const bitset<_Nb,_WordT>& __x, const bitset<_Nb,_WordT>& __y) { bitset<_Nb,_WordT> __result(__x); __result &= __y; return __result; } template inline bitset<_Nb,_WordT> operator|(const bitset<_Nb,_WordT>& __x, const bitset<_Nb,_WordT>& __y) { bitset<_Nb,_WordT> __result(__x); __result |= __y; return __result; } template inline bitset<_Nb,_WordT> operator^(const bitset<_Nb,_WordT>& __x, const bitset<_Nb,_WordT>& __y) { bitset<_Nb,_WordT> __result(__x); __result ^= __y; return __result; } // NOTE: these must be rewritten once we have templatized iostreams. template istream& operator>>(istream& __is, bitset<_Nb,_WordT>& __x) { string __tmp; __tmp.reserve(_Nb); // In new templatized iostreams, use istream::sentry if (__is.flags() & ios::skipws) { char __c; do __is.get(__c); while (__is && isspace(__c)); if (__is) __is.putback(__c); } for (size_t __i = 0; __i < _Nb; ++__i) { char __c; __is.get(__c); if (!__is) break; else if (__c != '0' && __c != '1') { __is.putback(__c); break; } else __tmp.push_back(__c); } if (__tmp.empty()) __is.clear(__is.rdstate() | ios::failbit); else __x._M_copy_from_string(__tmp, static_cast(0), _Nb); return __is; } template ostream& operator<<(ostream& __os, const bitset<_Nb,_WordT>& __x) { string __tmp; __x._M_copy_to_string(__tmp); return __os << __tmp; } // ------------------------------------------------------------ // Lookup tables for find and count operations. template unsigned char _Bit_count<__dummy>::_S_bit_count[] = { 0, /* 0 */ 1, /* 1 */ 1, /* 2 */ 2, /* 3 */ 1, /* 4 */ 2, /* 5 */ 2, /* 6 */ 3, /* 7 */ 1, /* 8 */ 2, /* 9 */ 2, /* 10 */ 3, /* 11 */ 2, /* 12 */ 3, /* 13 */ 3, /* 14 */ 4, /* 15 */ 1, /* 16 */ 2, /* 17 */ 2, /* 18 */ 3, /* 19 */ 2, /* 20 */ 3, /* 21 */ 3, /* 22 */ 4, /* 23 */ 2, /* 24 */ 3, /* 25 */ 3, /* 26 */ 4, /* 27 */ 3, /* 28 */ 4, /* 29 */ 4, /* 30 */ 5, /* 31 */ 1, /* 32 */ 2, /* 33 */ 2, /* 34 */ 3, /* 35 */ 2, /* 36 */ 3, /* 37 */ 3, /* 38 */ 4, /* 39 */ 2, /* 40 */ 3, /* 41 */ 3, /* 42 */ 4, /* 43 */ 3, /* 44 */ 4, /* 45 */ 4, /* 46 */ 5, /* 47 */ 2, /* 48 */ 3, /* 49 */ 3, /* 50 */ 4, /* 51 */ 3, /* 52 */ 4, /* 53 */ 4, /* 54 */ 5, /* 55 */ 3, /* 56 */ 4, /* 57 */ 4, /* 58 */ 5, /* 59 */ 4, /* 60 */ 5, /* 61 */ 5, /* 62 */ 6, /* 63 */ 1, /* 64 */ 2, /* 65 */ 2, /* 66 */ 3, /* 67 */ 2, /* 68 */ 3, /* 69 */ 3, /* 70 */ 4, /* 71 */ 2, /* 72 */ 3, /* 73 */ 3, /* 74 */ 4, /* 75 */ 3, /* 76 */ 4, /* 77 */ 4, /* 78 */ 5, /* 79 */ 2, /* 80 */ 3, /* 81 */ 3, /* 82 */ 4, /* 83 */ 3, /* 84 */ 4, /* 85 */ 4, /* 86 */ 5, /* 87 */ 3, /* 88 */ 4, /* 89 */ 4, /* 90 */ 5, /* 91 */ 4, /* 92 */ 5, /* 93 */ 5, /* 94 */ 6, /* 95 */ 2, /* 96 */ 3, /* 97 */ 3, /* 98 */ 4, /* 99 */ 3, /* 100 */ 4, /* 101 */ 4, /* 102 */ 5, /* 103 */ 3, /* 104 */ 4, /* 105 */ 4, /* 106 */ 5, /* 107 */ 4, /* 108 */ 5, /* 109 */ 5, /* 110 */ 6, /* 111 */ 3, /* 112 */ 4, /* 113 */ 4, /* 114 */ 5, /* 115 */ 4, /* 116 */ 5, /* 117 */ 5, /* 118 */ 6, /* 119 */ 4, /* 120 */ 5, /* 121 */ 5, /* 122 */ 6, /* 123 */ 5, /* 124 */ 6, /* 125 */ 6, /* 126 */ 7, /* 127 */ 1, /* 128 */ 2, /* 129 */ 2, /* 130 */ 3, /* 131 */ 2, /* 132 */ 3, /* 133 */ 3, /* 134 */ 4, /* 135 */ 2, /* 136 */ 3, /* 137 */ 3, /* 138 */ 4, /* 139 */ 3, /* 140 */ 4, /* 141 */ 4, /* 142 */ 5, /* 143 */ 2, /* 144 */ 3, /* 145 */ 3, /* 146 */ 4, /* 147 */ 3, /* 148 */ 4, /* 149 */ 4, /* 150 */ 5, /* 151 */ 3, /* 152 */ 4, /* 153 */ 4, /* 154 */ 5, /* 155 */ 4, /* 156 */ 5, /* 157 */ 5, /* 158 */ 6, /* 159 */ 2, /* 160 */ 3, /* 161 */ 3, /* 162 */ 4, /* 163 */ 3, /* 164 */ 4, /* 165 */ 4, /* 166 */ 5, /* 167 */ 3, /* 168 */ 4, /* 169 */ 4, /* 170 */ 5, /* 171 */ 4, /* 172 */ 5, /* 173 */ 5, /* 174 */ 6, /* 175 */ 3, /* 176 */ 4, /* 177 */ 4, /* 178 */ 5, /* 179 */ 4, /* 180 */ 5, /* 181 */ 5, /* 182 */ 6, /* 183 */ 4, /* 184 */ 5, /* 185 */ 5, /* 186 */ 6, /* 187 */ 5, /* 188 */ 6, /* 189 */ 6, /* 190 */ 7, /* 191 */ 2, /* 192 */ 3, /* 193 */ 3, /* 194 */ 4, /* 195 */ 3, /* 196 */ 4, /* 197 */ 4, /* 198 */ 5, /* 199 */ 3, /* 200 */ 4, /* 201 */ 4, /* 202 */ 5, /* 203 */ 4, /* 204 */ 5, /* 205 */ 5, /* 206 */ 6, /* 207 */ 3, /* 208 */ 4, /* 209 */ 4, /* 210 */ 5, /* 211 */ 4, /* 212 */ 5, /* 213 */ 5, /* 214 */ 6, /* 215 */ 4, /* 216 */ 5, /* 217 */ 5, /* 218 */ 6, /* 219 */ 5, /* 220 */ 6, /* 221 */ 6, /* 222 */ 7, /* 223 */ 3, /* 224 */ 4, /* 225 */ 4, /* 226 */ 5, /* 227 */ 4, /* 228 */ 5, /* 229 */ 5, /* 230 */ 6, /* 231 */ 4, /* 232 */ 5, /* 233 */ 5, /* 234 */ 6, /* 235 */ 5, /* 236 */ 6, /* 237 */ 6, /* 238 */ 7, /* 239 */ 4, /* 240 */ 5, /* 241 */ 5, /* 242 */ 6, /* 243 */ 5, /* 244 */ 6, /* 245 */ 6, /* 246 */ 7, /* 247 */ 5, /* 248 */ 6, /* 249 */ 6, /* 250 */ 7, /* 251 */ 6, /* 252 */ 7, /* 253 */ 7, /* 254 */ 8 /* 255 */ }; // end _Bit_count template unsigned char _First_one<__dummy>::_S_first_one[] = { 0, /* 0 */ 0, /* 1 */ 1, /* 2 */ 0, /* 3 */ 2, /* 4 */ 0, /* 5 */ 1, /* 6 */ 0, /* 7 */ 3, /* 8 */ 0, /* 9 */ 1, /* 10 */ 0, /* 11 */ 2, /* 12 */ 0, /* 13 */ 1, /* 14 */ 0, /* 15 */ 4, /* 16 */ 0, /* 17 */ 1, /* 18 */ 0, /* 19 */ 2, /* 20 */ 0, /* 21 */ 1, /* 22 */ 0, /* 23 */ 3, /* 24 */ 0, /* 25 */ 1, /* 26 */ 0, /* 27 */ 2, /* 28 */ 0, /* 29 */ 1, /* 30 */ 0, /* 31 */ 5, /* 32 */ 0, /* 33 */ 1, /* 34 */ 0, /* 35 */ 2, /* 36 */ 0, /* 37 */ 1, /* 38 */ 0, /* 39 */ 3, /* 40 */ 0, /* 41 */ 1, /* 42 */ 0, /* 43 */ 2, /* 44 */ 0, /* 45 */ 1, /* 46 */ 0, /* 47 */ 4, /* 48 */ 0, /* 49 */ 1, /* 50 */ 0, /* 51 */ 2, /* 52 */ 0, /* 53 */ 1, /* 54 */ 0, /* 55 */ 3, /* 56 */ 0, /* 57 */ 1, /* 58 */ 0, /* 59 */ 2, /* 60 */ 0, /* 61 */ 1, /* 62 */ 0, /* 63 */ 6, /* 64 */ 0, /* 65 */ 1, /* 66 */ 0, /* 67 */ 2, /* 68 */ 0, /* 69 */ 1, /* 70 */ 0, /* 71 */ 3, /* 72 */ 0, /* 73 */ 1, /* 74 */ 0, /* 75 */ 2, /* 76 */ 0, /* 77 */ 1, /* 78 */ 0, /* 79 */ 4, /* 80 */ 0, /* 81 */ 1, /* 82 */ 0, /* 83 */ 2, /* 84 */ 0, /* 85 */ 1, /* 86 */ 0, /* 87 */ 3, /* 88 */ 0, /* 89 */ 1, /* 90 */ 0, /* 91 */ 2, /* 92 */ 0, /* 93 */ 1, /* 94 */ 0, /* 95 */ 5, /* 96 */ 0, /* 97 */ 1, /* 98 */ 0, /* 99 */ 2, /* 100 */ 0, /* 101 */ 1, /* 102 */ 0, /* 103 */ 3, /* 104 */ 0, /* 105 */ 1, /* 106 */ 0, /* 107 */ 2, /* 108 */ 0, /* 109 */ 1, /* 110 */ 0, /* 111 */ 4, /* 112 */ 0, /* 113 */ 1, /* 114 */ 0, /* 115 */ 2, /* 116 */ 0, /* 117 */ 1, /* 118 */ 0, /* 119 */ 3, /* 120 */ 0, /* 121 */ 1, /* 122 */ 0, /* 123 */ 2, /* 124 */ 0, /* 125 */ 1, /* 126 */ 0, /* 127 */ 7, /* 128 */ 0, /* 129 */ 1, /* 130 */ 0, /* 131 */ 2, /* 132 */ 0, /* 133 */ 1, /* 134 */ 0, /* 135 */ 3, /* 136 */ 0, /* 137 */ 1, /* 138 */ 0, /* 139 */ 2, /* 140 */ 0, /* 141 */ 1, /* 142 */ 0, /* 143 */ 4, /* 144 */ 0, /* 145 */ 1, /* 146 */ 0, /* 147 */ 2, /* 148 */ 0, /* 149 */ 1, /* 150 */ 0, /* 151 */ 3, /* 152 */ 0, /* 153 */ 1, /* 154 */ 0, /* 155 */ 2, /* 156 */ 0, /* 157 */ 1, /* 158 */ 0, /* 159 */ 5, /* 160 */ 0, /* 161 */ 1, /* 162 */ 0, /* 163 */ 2, /* 164 */ 0, /* 165 */ 1, /* 166 */ 0, /* 167 */ 3, /* 168 */ 0, /* 169 */ 1, /* 170 */ 0, /* 171 */ 2, /* 172 */ 0, /* 173 */ 1, /* 174 */ 0, /* 175 */ 4, /* 176 */ 0, /* 177 */ 1, /* 178 */ 0, /* 179 */ 2, /* 180 */ 0, /* 181 */ 1, /* 182 */ 0, /* 183 */ 3, /* 184 */ 0, /* 185 */ 1, /* 186 */ 0, /* 187 */ 2, /* 188 */ 0, /* 189 */ 1, /* 190 */ 0, /* 191 */ 6, /* 192 */ 0, /* 193 */ 1, /* 194 */ 0, /* 195 */ 2, /* 196 */ 0, /* 197 */ 1, /* 198 */ 0, /* 199 */ 3, /* 200 */ 0, /* 201 */ 1, /* 202 */ 0, /* 203 */ 2, /* 204 */ 0, /* 205 */ 1, /* 206 */ 0, /* 207 */ 4, /* 208 */ 0, /* 209 */ 1, /* 210 */ 0, /* 211 */ 2, /* 212 */ 0, /* 213 */ 1, /* 214 */ 0, /* 215 */ 3, /* 216 */ 0, /* 217 */ 1, /* 218 */ 0, /* 219 */ 2, /* 220 */ 0, /* 221 */ 1, /* 222 */ 0, /* 223 */ 5, /* 224 */ 0, /* 225 */ 1, /* 226 */ 0, /* 227 */ 2, /* 228 */ 0, /* 229 */ 1, /* 230 */ 0, /* 231 */ 3, /* 232 */ 0, /* 233 */ 1, /* 234 */ 0, /* 235 */ 2, /* 236 */ 0, /* 237 */ 1, /* 238 */ 0, /* 239 */ 4, /* 240 */ 0, /* 241 */ 1, /* 242 */ 0, /* 243 */ 2, /* 244 */ 0, /* 245 */ 1, /* 246 */ 0, /* 247 */ 3, /* 248 */ 0, /* 249 */ 1, /* 250 */ 0, /* 251 */ 2, /* 252 */ 0, /* 253 */ 1, /* 254 */ 0, /* 255 */ }; // end _First_one #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) #pragma reset woff 1209 #endif __STL_END_NAMESPACE #undef __BITS_PER_WORDT #undef __BITSET_WORDS #endif /* __SGI_STL_BITSET */ // Local Variables: // mode:C++ // End: // This is file sstream: /* This is part of libio/iostream, providing -*- C++ -*- input/output. Copyright (C) 2000 Free Software Foundation This file is part of the GNU IO Library. This library 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 library 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 library; see the file COPYING. If not, write to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. As a special exception, if you link this library with files compiled with a GNU compiler to produce an executable, this does not cause the resulting executable to be covered by the GNU General Public License. This exception does not however invalidate any other reasons why the executable file might be covered by the GNU General Public License. */ /* Written by Magnus Fromreide (magfr@lysator.liu.se). */ #ifndef __SSTREAM__ #define __SSTREAM__ #include #include #include namespace std { class stringbuf : public streambuf { public: typedef char char_type; typedef int int_type; typedef streampos pos_type; typedef streamoff off_type; explicit stringbuf(int which=ios::in|ios::out) : streambuf(which), buf(), mode(static_cast(which)), rpos(0), bufsize(1) { } explicit stringbuf(const std::string &s, int which=ios::in|ios::out) : streambuf(which), buf(s), mode(static_cast(which)), bufsize(1) { if(mode & ios::in) { setg(&defbuf, &defbuf + bufsize, &defbuf + bufsize); } if(mode & ios::out) { setp(&defbuf, &defbuf + bufsize); } rpos = (mode & ios::ate ? s.size() : 0); } std::string str() const { const_cast(this)->sync(); // Sigh, really ugly hack return buf; }; void str(const std::string& s) { buf = s; if(mode & ios::in) { gbump(egptr() - gptr()); } if(mode & ios::out) { pbump(pbase() - pptr()); } rpos = (mode & ios::ate ? s.size() : 0); } protected: inline virtual int sync(); inline virtual int overflow(int = EOF); inline virtual int underflow(); private: std::string buf; ios::open_mode mode; std::string::size_type rpos; streamsize bufsize; char defbuf; }; class stringstreambase : virtual public ios { protected: stringbuf __my_sb; public: std::string str() const { return dynamic_cast(_strbuf)->str(); } void str(const std::string& s) { clear(); dynamic_cast(_strbuf)->str(s); } stringbuf* rdbuf() { return &__my_sb; } protected: stringstreambase(int which) : __my_sb(which) { init (&__my_sb); } stringstreambase(const std::string& s, int which) : __my_sb(s, which) { init (&__my_sb); } }; class istringstream : public stringstreambase, public istream { public: istringstream(int which=ios::in) : stringstreambase(which) { } istringstream(const std::string& s, int which=ios::in) : stringstreambase(s, which) { } }; class ostringstream : public stringstreambase, public ostream { public: ostringstream(int which=ios::out) : stringstreambase(which) { } ostringstream(const std::string& s, int which=ios::out) : stringstreambase(s, which) { } }; class stringstream : public stringstreambase, public iostream { public: stringstream(int which=ios::in|ios::out) : stringstreambase(which) { } stringstream(const std::string &s, int which=ios::in|ios::out) : stringstreambase(s, which) { } }; } inline int std::stringbuf::sync() { if(static_cast(mode & ios::out) == 0) return EOF; streamsize n = pptr() - pbase(); if(n) { buf.replace(rpos, std::string::npos, pbase(), n); if(static_cast(buf.size() - rpos) != n) return EOF; rpos += n; pbump(-n); gbump(egptr() - gptr()); } return 0; } inline int std::stringbuf::overflow(int ch) { if((mode & ios::out) == 0) return EOF; streamsize n = pptr() - pbase(); if(n && sync()) return EOF; if(ch != EOF) { std::string::size_type oldSize = buf.size(); buf.replace(rpos, std::string::npos, ch); if(buf.size() - oldSize != 1) return EOF; ++rpos; } return 0; } inline int std::stringbuf::underflow() { sync(); if((mode & ios::in) == 0) { return EOF; } if(rpos >= buf.size()) { return EOF; } std::string::size_type n = egptr() - eback(); std::string::size_type s; s = buf.copy(eback(), n, rpos); pbump(pbase() - pptr()); gbump(eback() - gptr()); int res = (0377 & buf[rpos]); rpos += s; return res; } #endif /* not __STRSTREAM__ */ #endif // CGAL_MINIBALL_GCC2_92_2_FIX ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/distance_predicates_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/distance_predicates_3.0000644000175000017500000000237411344301500031246 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/distance_predicates_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_DISTANCE_PREDICATES_3_H #define CGAL_DISTANCE_PREDICATES_3_H // Kept for backward compatibility only. #endif // CGAL_DISTANCE_PREDICATES_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Dummy_tds_3.h0000644000175000017500000000255411344301500027366 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Dummy_tds_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_TRIANGULATION_DUMMY_TDS_3_H #define CGAL_TRIANGULATION_DUMMY_TDS_3_H #include #include CGAL_BEGIN_NAMESPACE // Dummy TDS which provides all types that a vertex_base or cell_base can use. struct Dummy_tds_3 { struct Vertex {}; struct Cell {}; struct Facet {}; struct Edge {}; struct Vertex_handle {}; struct Cell_handle {}; struct Vertex_iterator {}; struct Cell_iterator {}; struct Facet_iterator {}; struct Edge_iterator {}; struct Cell_circulator {}; struct Facet_circulator {}; }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DUMMY_TDS_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_selected_extreme_points_2.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_selected_extreme_po0000644000175000017500000001121711344301500031436 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_selected_extreme_points_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_SELECTED_EXTREME_POINTS_2_C #define CGAL_CH_SELECTED_EXTREME_POINTS_2_C #ifndef CGAL_CH_SELECTED_EXTREME_POINTS_2_H #include #endif // CGAL_CH_SELECTED_EXTREME_POINTS_2_H #ifndef CGAL_CH_NO_POSTCONDITIONS #include #endif // CGAL_CH_NO_POSTCONDITIONS CGAL_BEGIN_NAMESPACE template void ch_nswe_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, ForwardIterator& s, ForwardIterator& w, ForwardIterator& e, const Traits& ch_traits ) { typename Traits::Less_xy_2 lexicographically_xy_smaller = ch_traits.less_xy_2_object(); typename Traits::Less_yx_2 lexicographically_yx_smaller = ch_traits.less_yx_2_object(); n = s = w = e = first; while ( first != last ) { if ( lexicographically_xy_smaller( *first, *w )) w = first; if ( lexicographically_xy_smaller( *e, *first )) e = first; if ( lexicographically_yx_smaller( *n, *first )) n = first; if ( lexicographically_yx_smaller( *first, *s )) s = first; ++first; } } template void ch_we_point( ForwardIterator first, ForwardIterator last, ForwardIterator& w, ForwardIterator& e, const Traits& ch_traits) { typename Traits::Less_xy_2 lexicographically_xy_smaller = ch_traits.less_xy_2_object(); w = e = first; while ( first != last ) { if ( lexicographically_xy_smaller( *first, *w )) w = first; if ( lexicographically_xy_smaller( *e, *first )) e = first; ++first; } } template void ch_ns_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, ForwardIterator& s, const Traits& ch_traits) { typename Traits::Less_yx_2 lexicographically_yx_smaller = ch_traits.less_yx_2_object(); n = s = first; while ( first != last ) { if ( lexicographically_yx_smaller( *first, *s )) s = first; if ( lexicographically_yx_smaller( *n, *first )) n = first; ++first; } } template void ch_n_point( ForwardIterator first, ForwardIterator last, ForwardIterator& n, const Traits& ch_traits) { typename Traits::Less_yx_2 lexicographically_yx_smaller = ch_traits.less_yx_2_object(); n = first; while ( first != last ) { if ( lexicographically_yx_smaller ( *n, *first )) n = first; ++first; } } template void ch_s_point( ForwardIterator first, ForwardIterator last, ForwardIterator& s, const Traits& ch_traits) { typename Traits::Less_yx_2 lexicographically_yx_smaller = ch_traits.less_yx_2_object(); s = first; while ( first != last ) { if ( lexicographically_yx_smaller( *first, *s )) s = first; ++first; } } template void ch_e_point( ForwardIterator first, ForwardIterator last, ForwardIterator& e, const Traits& ch_traits) { typename Traits::Less_xy_2 lexicographically_xy_smaller = ch_traits.less_xy_2_object(); e = first; while ( first != last ) { if ( lexicographically_xy_smaller( *e, *first )) e = first; ++first; } } template void ch_w_point( ForwardIterator first, ForwardIterator last, ForwardIterator& w, const Traits& ch_traits) { typename Traits::Less_xy_2 lexicographically_xy_smaller = ch_traits.less_xy_2_object(); w = first; while ( first != last ) { if ( lexicographically_xy_smaller( *first, *w )) w = first; ++first; } } CGAL_END_NAMESPACE #endif // CGAL_CH_SELECTED_EXTREME_POINTS_2_C ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_default_data_structure_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_default_0000644000175000017500000000174511344301501031436 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_default_data_structure_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DEFAULT_DATA_STRUCTURE_2_H #define CGAL_TRIANGULATION_DEFAULT_DATA_STRUCTURE_2_H // no longer needed // for backwards compatibility only #endif //CGAL_TRIANGULATION_DEFAULT_DATA_STRUCTURE_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Triangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Triangle_2_inte0000644000175000017500000001610211344301500031140 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Line_2_Triangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_LINE_2_TRIANGLE_2_INTERSECTION_H #define CGAL_LINE_2_TRIANGLE_2_INTERSECTION_H #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Line_2_Triangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Line_2_Triangle_2_pair() ; Line_2_Triangle_2_pair(typename K::Line_2 const *line, typename K::Triangle_2 const *trian); ~Line_2_Triangle_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: typename K::Line_2 const*_line; typename K::Triangle_2 const * _trian; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; mutable typename K::Point_2 _other_point; }; template inline bool do_intersect(const typename CGAL_WRAP(K)::Line_2 &p1, const typename CGAL_WRAP(K)::Triangle_2 &p2, const K&) { typedef Line_2_Triangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template inline bool do_intersect(const typename CGAL_WRAP(K)::Triangle_2 &p2, const typename CGAL_WRAP(K)::Line_2 &p1, const K& k) { return CGALi::do_intersect(p1, p2, k); } template Line_2_Triangle_2_pair:: Line_2_Triangle_2_pair() { _known = false; _line = 0; _trian = 0; } template Line_2_Triangle_2_pair:: Line_2_Triangle_2_pair(typename K::Line_2 const *line, typename K::Triangle_2 const *trian) { _known = false; _line = line; _trian = trian; } template typename Line_2_Triangle_2_pair::Intersection_results Line_2_Triangle_2_pair::intersection_type() const { typedef typename K::Line_2 Line_2; if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; Straight_2_ straight(*_line); Line_2 l(_trian->vertex(0), _trian->vertex(1)); if (l.oriented_side(_trian->vertex(2)) == ON_POSITIVE_SIDE) { // if (_trian->is_counterclockwise()) { straight.cut_right_off( Line_2(_trian->vertex(0), _trian->vertex(1))); straight.cut_right_off( Line_2(_trian->vertex(1), _trian->vertex(2))); straight.cut_right_off( Line_2(_trian->vertex(2), _trian->vertex(0))); } else { straight.cut_right_off( Line_2(_trian->vertex(2), _trian->vertex(1))); straight.cut_right_off( Line_2(_trian->vertex(1), _trian->vertex(0))); straight.cut_right_off( Line_2(_trian->vertex(0), _trian->vertex(2))); } switch (straight.current_state()) { case Straight_2_::EMPTY: _result = NO; return _result; case Straight_2_::POINT: { straight.current(_intersection_point); _result = POINT; return _result; } case Straight_2_::SEGMENT: { typename K::Segment_2 seg; straight.current(seg); _intersection_point = seg.source(); _other_point = seg.target(); _result = SEGMENT; return _result; } default: // should not happen. CGAL_kernel_assertion_msg(false, "Internal CGAL error."); _result = NO; return _result; } } template bool Line_2_Triangle_2_pair:: intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Line_2_Triangle_2_pair:: intersection(typename K::Segment_2 &result) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = Segment_2(_intersection_point, _other_point); return true; } template Object intersection(const typename CGAL_WRAP(K)::Line_2 &line, const typename CGAL_WRAP(K)::Triangle_2 &tr, const K&) { typedef Line_2_Triangle_2_pair is_t; is_t ispair(&line, &tr); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } template inline Object intersection(const typename CGAL_WRAP(K)::Triangle_2 &tr, const typename CGAL_WRAP(K)::Line_2 &line, const K& k) { return intersection(line, tr, k); } template class Triangle_2_Line_2_pair : public Line_2_Triangle_2_pair { public: Triangle_2_Line_2_pair( typename K::Triangle_2 const *trian, typename K::Line_2 const *line) : Line_2_Triangle_2_pair(line, trian) {} }; } // namespace CGALi template inline bool do_intersect(const Line_2 &p1, const Triangle_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p1, p2); } template inline bool do_intersect( const Triangle_2 &p1, const Line_2 &p2) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(p2, p1); } template inline Object intersection(const Line_2 &line, const Triangle_2 &tr) { typedef typename K::Intersect_2 Intersect; return Intersect()(line, tr); } template inline Object intersection(const Triangle_2 &tr, const Line_2 &line) { typedef typename K::Intersect_2 Intersect; return Intersect()(line, tr); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/segment_intersection_points_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/segment_intersection_p0000644000175000017500000000717711344301500031526 0ustar debiandebian// Copyright (c) 1998 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/segment_intersection_points_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_SEGMENT_INTERSECTION_POINTS_2_H #define CGAL_SEGMENT_INTERSECTION_POINTS_2_H #include #include #include namespace CGAL { /* #include template OutputIterator si_brute_force(ForwardIterator first, ForwardIterator last, OutputIterator result, const R& ) { typedef Point_2 Point; ForwardIterator inner, outer; Object i_obj; Point p; for ( outer = first; outer != last; ++outer) for ( inner = successor(outer); inner != last; ++inner) { i_obj = intersection( *outer, *inner); if ( assign( p, i_obj) ) result++ = p; } return result; } */ template OutputIterator si_brute_force_II(ForwardIterator first, ForwardIterator last, OutputIterator result, const Traits& traits) { typedef typename Traits::Point_2 Point; typedef typename Traits::Line_2 Line; typedef typename Traits::Orientation_2 Orientation; Orientation orientation = traits.orientation_2_object(); for ( ForwardIterator outer = first; outer != last; ++outer) for ( ForwardIterator inner = successor(outer); inner != last; ++inner) { Point s1 = (*outer).source(); Point e1 = (*outer).target(); Point s2 = (*inner).source(); Point e2 = (*inner).target(); if ( (orientation( s1, e1, s2) != orientation( s1, e1, e2)) &&(orientation( s2, e2, s1) != orientation( s2, e2, e1))) { Line l1( s1, e1); Line l2( s2, e2); result++ = Point( l1.b()*l2.c() - l2.b()*l1.c(), l2.a()*l1.c() - l1.a()*l2.c(), l1.a()*l2.b() - l2.a()*l1.b()); } } return result; } template OutputIterator segment_intersection_points_2(ForwardIterator first, ForwardIterator last, OutputIterator result, const Traits& traits) { return si_brute_force_II( first, last, result, traits); } template OutputIterator segment_intersection_points_2(ForwardIterator first, ForwardIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return segment_intersection_points_2( first, last, result, Kernel()); } } // namespace CGAL #endif // CGAL_SEGMENT_INTERSECTION_POINTS_2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_verte0000644000175000017500000000547011344301501031465 0ustar debiandebian// Copyright (c) 1999,2000,2001,2002,2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_vertex_base_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud #ifndef CGAL_TRIANGULATION_DS_VERTEX_BASE_3_H #define CGAL_TRIANGULATION_DS_VERTEX_BASE_3_H #include #include #include CGAL_BEGIN_NAMESPACE template < typename TDS = void > class Triangulation_ds_vertex_base_3 { public: typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Cell_handle Cell_handle; template struct Rebind_TDS { typedef Triangulation_ds_vertex_base_3 Other; }; Triangulation_ds_vertex_base_3() : _c() {} Triangulation_ds_vertex_base_3(const Cell_handle& c) : _c(c) {} const Cell_handle& cell() const { return _c; } void set_cell(const Cell_handle& c) { _c = c; } // the following trivial is_valid allows // the user of derived cell base classes // to add their own purpose checking bool is_valid(bool, int ) const { return cell() != Cell_handle(); } // For use by the Compact_container. void * for_compact_container() const { return _c.for_compact_container(); } void * & for_compact_container() { return _c.for_compact_container(); } private: Cell_handle _c; }; template < class TDS > inline std::istream& operator>>(std::istream &is, Triangulation_ds_vertex_base_3 &) // no combinatorial information. { return is; } template < class TDS > inline std::ostream& operator<<(std::ostream &os, const Triangulation_ds_vertex_base_3 &) // no combinatorial information. { return os; } // Specialization for void. template <> class Triangulation_ds_vertex_base_3 { public: typedef Dummy_tds_3 Triangulation_data_structure; typedef Triangulation_data_structure::Vertex_handle Vertex_handle; typedef Triangulation_data_structure::Cell_handle Cell_handle; template struct Rebind_TDS { typedef Triangulation_ds_vertex_base_3 Other; }; }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DS_VERTEX_BASE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Point_pair_less_xy_2.h0000644000175000017500000000344411344301500031271 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Point_pair_less_xy_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_POINT_PAIR_LESS_XY_2_H #define CGAL_POINT_PAIR_LESS_XY_2_H #include namespace CGAL { // // Given two pairs of points determine their lexicographical order by first // comparing the first points lexicographically and then the second points if // the first are equal // template class Point_pair_less_xy_2 { typedef typename Traits::Point_2 Point_2; typedef std::pair Point_pair; typedef typename Traits::Less_xy_2 Less_xy_2; public: Point_pair_less_xy_2() : _less_xy_2(Traits().less_xy_2_object()) { } bool operator()(const Point_pair& p, const Point_pair& q) const { if (_less_xy_2(p.first, q.first)) return true; else if (_less_xy_2(q.first, p.first)) return false; else if (_less_xy_2(p.second, q.second)) return true; else return false; } private: Less_xy_2 _less_xy_2; }; } #endif // CGAL_POINT_PAIR_LESS_XY_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Orthogonal_incremental_neighbor_search.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Orthogonal_incremental0000644000175000017500000003326611344301500031452 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Orthogonal_incremental_neighbor_search.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef ORTHOGONAL_INCREMENTAL_NEIGHBOR_SEARCH #define ORTHOGONAL_INCREMENTAL_NEIGHBOR_SEARCH #include #include #include #include #include #include namespace CGAL { template , class Splitter_ = Sliding_midpoint, class Tree_= Kd_tree > class Orthogonal_incremental_neighbor_search { public: typedef Splitter_ Splitter; typedef Tree_ Tree; typedef Distance_ Distance; typedef typename SearchTraits::Point_d Point_d; typedef typename Distance::Query_item Query_item; typedef typename SearchTraits::FT FT; typedef typename Tree::Point_d_iterator Point_d_iterator; typedef typename Tree::Node_handle Node_handle; typedef std::pair Point_with_transformed_distance; typedef std::pair Node_with_distance; typedef std::vector Node_with_distance_vector; typedef std::vector Point_with_transformed_distance_vector; class Iterator_implementation { public: int number_of_neighbours_computed; int number_of_internal_nodes_visited; int number_of_leaf_nodes_visited; int number_of_items_visited; private: Distance Orthogonal_distance_instance; FT multiplication_factor; Query_item query_point; int total_item_number; FT distance_to_root; bool search_nearest_neighbour; FT rd; class Priority_higher { public: bool search_nearest; Priority_higher(bool search_the_nearest_neighbour) : search_nearest(search_the_nearest_neighbour) {} //highest priority is smallest distance bool operator() (Node_with_distance* n1, Node_with_distance* n2) const { return (search_nearest) ? (n1->second > n2->second) : (n2->second > n1->second); } }; class Distance_smaller { public: bool search_nearest; Distance_smaller(bool search_the_nearest_neighbour) : search_nearest(search_the_nearest_neighbour) {} //highest priority is smallest distance bool operator() (Point_with_transformed_distance* p1, Point_with_transformed_distance* p2) const { return (search_nearest) ? (p1->second > p2->second) : (p2->second > p1->second); } }; std::priority_queue PriorityQueue; public: std::priority_queue Item_PriorityQueue; public: int reference_count; // constructor Iterator_implementation(Tree& tree, Query_item& q, const Distance& tr, FT Eps=FT(0.0), bool search_nearest=true) : number_of_neighbours_computed(0), number_of_internal_nodes_visited(0), number_of_leaf_nodes_visited(0), number_of_items_visited(0), Orthogonal_distance_instance(tr), multiplication_factor(Orthogonal_distance_instance.transformed_distance(FT(1.0)+Eps)), query_point(q), total_item_number(tree.size()), search_nearest_neighbour(search_nearest), PriorityQueue(Priority_higher(search_nearest)), Item_PriorityQueue(Distance_smaller(search_nearest)), reference_count(1) { // if (search_nearest) distance_to_root= Orthogonal_distance_instance.min_distance_to_rectangle(q, tree.bounding_box()); // else distance_to_root= // Orthogonal_Distance_instance->max_distance_to_rectangle(q, // tree.bounding_box()); Node_with_distance *The_Root = new Node_with_distance(tree.root(), distance_to_root); PriorityQueue.push(The_Root); // rd is the distance of the top of the priority queue to q rd=The_Root->second; Compute_the_next_nearest_neighbour(); } // * operator Point_with_transformed_distance& operator* () const { return *(Item_PriorityQueue.top()); } // prefix operator Iterator_implementation& operator++() { Delete_the_current_item_top(); Compute_the_next_nearest_neighbour(); return *this; } // postfix operator Point_with_transformed_distance operator++(int) { Point_with_transformed_distance result = *(Item_PriorityQueue.top()); ++*this; return result; } // Print statistics of the general priority search process. std::ostream& statistics (std::ostream& s) const { s << "Orthogonal priority search statistics:" << std::endl; s << "Number of internal nodes visited:" << number_of_internal_nodes_visited << std::endl; s << "Number of leaf nodes visited:" << number_of_leaf_nodes_visited << std::endl; s << "Number of items visited:" << number_of_items_visited << std::endl; s << "Number of neighbours computed:" << number_of_neighbours_computed << std::endl; return s; } //destructor ~Iterator_implementation() { while (PriorityQueue.size()>0) { Node_with_distance* The_top=PriorityQueue.top(); PriorityQueue.pop(); delete The_top; } while (Item_PriorityQueue.size()>0) { Point_with_transformed_distance* The_top=Item_PriorityQueue.top(); Item_PriorityQueue.pop(); delete The_top; } } private: void Delete_the_current_item_top() { Point_with_transformed_distance* The_item_top=Item_PriorityQueue.top(); Item_PriorityQueue.pop(); delete The_item_top; } void Compute_the_next_nearest_neighbour() { // compute the next item bool next_neighbour_found=false; if (!(Item_PriorityQueue.empty())) { if (search_nearest_neighbour) next_neighbour_found= (multiplication_factor*rd > Item_PriorityQueue.top()->second); else next_neighbour_found= (rd < multiplication_factor*Item_PriorityQueue.top()->second); } typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d query_point_it = construct_it(query_point); // otherwise browse the tree further while ((!next_neighbour_found) && (!PriorityQueue.empty())) { Node_with_distance* The_node_top=PriorityQueue.top(); Node_handle N= The_node_top->first; PriorityQueue.pop(); delete The_node_top; FT copy_rd=rd; while (!(N->is_leaf())) { // compute new distance number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); FT old_off, new_rd; FT new_off = *(query_point_it + new_cut_dim) - N->cutting_value(); if (new_off < FT(0.0)) { old_off= *(query_point_it + new_cut_dim)-N->low_value(); if (old_off>FT(0.0)) old_off=FT(0.0); new_rd= Orthogonal_distance_instance.new_distance(copy_rd,old_off,new_off,new_cut_dim); CGAL_assertion(new_rd >= copy_rd); if (search_nearest_neighbour) { Node_with_distance *Upper_Child = new Node_with_distance(N->upper(), new_rd); PriorityQueue.push(Upper_Child); N=N->lower(); } else { Node_with_distance *Lower_Child = new Node_with_distance(N->lower(), copy_rd); PriorityQueue.push(Lower_Child); N=N->upper(); copy_rd=new_rd; } } else { // compute new distance old_off= N->high_value() - *(query_point_it+new_cut_dim); if (old_off>FT(0.0)) old_off=FT(0.0); new_rd=Orthogonal_distance_instance.new_distance(copy_rd,old_off,new_off,new_cut_dim); CGAL_assertion(new_rd >= copy_rd); if (search_nearest_neighbour) { Node_with_distance *Lower_Child = new Node_with_distance(N->lower(), new_rd); PriorityQueue.push(Lower_Child); N=N->upper(); } else { Node_with_distance *Upper_Child = new Node_with_distance(N->upper(), copy_rd); PriorityQueue.push(Upper_Child); N=N->lower(); copy_rd=new_rd; } } } // n is a leaf number_of_leaf_nodes_visited++; if (N->size() > 0) { for (Point_d_iterator it=N->begin(); it != N->end(); it++) { number_of_items_visited++; FT distance_to_query_point= Orthogonal_distance_instance.transformed_distance(query_point,**it); Point_with_transformed_distance *NN_Candidate= new Point_with_transformed_distance(**it,distance_to_query_point); Item_PriorityQueue.push(NN_Candidate); } // old top of PriorityQueue has been processed, // hence update rd if (!(PriorityQueue.empty())) { rd = PriorityQueue.top()->second; if (search_nearest_neighbour) next_neighbour_found = (multiplication_factor*rd > Item_PriorityQueue.top()->second); else next_neighbour_found = (multiplication_factor*rd < Item_PriorityQueue.top()->second); } else // priority queue empty => last neighbour found { next_neighbour_found=true; } number_of_neighbours_computed++; } } // next_neighbour_found or priority queue is empty // in the latter case also the item priority quee is empty } }; // class Iterator_implementaion class iterator; typedef std::vector Distance_vector; public: // constructor Orthogonal_incremental_neighbor_search(Tree& tree, Query_item& q, FT Eps = FT(0.0), bool search_nearest=true, const Distance& tr=Distance()) : start(tree,q,tr,Eps,search_nearest), past_the_end() {} iterator begin() { return start; } iterator end() { return past_the_end; } std::ostream& statistics(std::ostream& s) { start.statistics(s); return s; } class iterator { public: typedef std::forward_iterator_tag iterator_category; typedef Point_with_transformed_distance value_type; typedef Point_with_transformed_distance* pointer; typedef const Point_with_transformed_distance& reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef int distance_type; //class Iterator_implementation; Iterator_implementation *Ptr_implementation; public: // default constructor iterator() : Ptr_implementation(0) {} int the_number_of_items_visited() { return Ptr_implementation->number_of_items_visited; } // constructor iterator(Tree& tree, Query_item& q, const Distance& tr=Distance(), FT eps=FT(0.0), bool search_nearest=true) : Ptr_implementation(new Iterator_implementation(tree, q, tr, eps, search_nearest)) {} // copy constructor iterator(const iterator& Iter) { Ptr_implementation = Iter.Ptr_implementation; if (Ptr_implementation != 0) Ptr_implementation->reference_count++; } const Point_with_transformed_distance& operator* () const { return *(*Ptr_implementation); } // prefix operator iterator& operator++() { ++(*Ptr_implementation); return *this; } // postfix operator iterator operator++(int) { iterator tmp(*this); ++(*this); return tmp; } bool operator==(const iterator& It) const { if ( ((Ptr_implementation == 0) || Ptr_implementation->Item_PriorityQueue.empty()) && ((It.Ptr_implementation == 0) || It.Ptr_implementation->Item_PriorityQueue.empty()) ) return true; // else return (Ptr_implementation == It.Ptr_implementation); } bool operator!=(const iterator& It) const { return !(*this == It); } std::ostream& statistics (std::ostream& s) { Ptr_implementation->statistics(s); return s; } ~iterator() { if (Ptr_implementation != 0) { Ptr_implementation->reference_count--; if (Ptr_implementation->reference_count==0) { delete Ptr_implementation; Ptr_implementation = 0; } } } }; // class iterator iterator start; iterator past_the_end; }; // class template void swap (typename Orthogonal_incremental_neighbor_search::iterator& x, typename Orthogonal_incremental_neighbor_search::iterator& y) { typename Orthogonal_incremental_neighbor_search::iterator::Iterator_implementation *tmp = x.Ptr_implementation; x.Ptr_implementation = y.Ptr_implementation; y.Ptr_implementation = tmp; } } // namespace CGAL #endif // ORTHOGONAL_INCREMENTAL_NEIGHBOR_SEARCH_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2.C0000644000175000017500000000622611344301500027613 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_ellipse_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #include CGAL_BEGIN_NAMESPACE // Class implementation (continued) // ================================ // I/O // --- template < class Traits_ > std::ostream& operator << ( std::ostream& os, const Min_ellipse_2& min_ellipse) { CGAL_USING_NAMESPACE_STD typedef typename Min_ellipse_2::Point Point; typedef ostream_iterator Os_it; switch ( CGAL::get_mode( os)) { case CGAL::IO::PRETTY: os << endl; os << "CGAL::Min_ellipse_2( |P| = "< std::istream& operator >> ( std::istream& is, CGAL::Min_ellipse_2& min_ellipse) { CGAL_USING_NAMESPACE_STD switch ( CGAL::get_mode( is)) { case CGAL::IO::PRETTY: cerr << endl; cerr << "Stream must be in ascii or binary mode" << endl; break; case CGAL::IO::ASCII: case CGAL::IO::BINARY: typedef typename Min_ellipse_2::Point Point; typedef istream_iterator Is_it; min_ellipse.clear(); min_ellipse.insert( Is_it( is), Is_it()); break; default: CGAL_optimisation_assertion_msg( false, "CGAL::IO::mode invalid!"); break; } return( is); } CGAL_END_NAMESPACE // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_items_3.h0000644000175000017500000000412711344301500030743 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_items_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_POLYHEDRON_ITEMS_3_H #define CGAL_POLYHEDRON_ITEMS_3_H 1 #ifndef CGAL_HALFEDGEDS_VERTEX_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_HALFEDGE_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_FACE_BASE_H #include #endif CGAL_BEGIN_NAMESPACE class Polyhedron_items_3 { public: template < class Refs, class Traits> struct Vertex_wrapper { typedef typename Traits::Point_3 Point; typedef HalfedgeDS_vertex_base< Refs, Tag_true, Point> Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef HalfedgeDS_halfedge_base< Refs> Halfedge; }; template < class Refs, class Traits> struct Face_wrapper { typedef typename Traits::Plane_3 Plane; typedef HalfedgeDS_face_base< Refs, Tag_true, Plane> Face; }; }; CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_ITEMS_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_kernel.h0000644000175000017500000000773311344301500030301 0ustar debiandebian// Copyright (c) 2001,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filtered_kernel.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_FILTERED_KERNEL_H #define CGAL_FILTERED_KERNEL_H #include #include #include #include #include #include #include #include #ifndef CGAL_NO_STATIC_FILTERS # include #endif // This file contains the definition of a generic kernel filter. // // TODO: // - at the moment, only the predicates are filtered. // Constructions will come later. // - the kernel provides the traits interface, as well as type equality. // Having the global functions working is another story... // - The converters are more a property of the types rather than anything else, // so maybe they should not be passed as template parameter, but use a // traits-like mecanism ? CGAL_BEGIN_NAMESPACE // CK = eventually rebound construction kernel (gets Point_2 from). // EK = exact kernel called when needed by the filter. // FK = filtering kernel template < typename CK > struct Filtered_kernel_base : public CK { typedef typename Exact_type_selecter::Type Exact_nt; typedef Simple_cartesian EK; typedef Simple_cartesian FK; typedef Cartesian_converter C2E; typedef Cartesian_converter > C2F; template < typename Kernel2 > struct Base { typedef typename CK::template Base CK2; typedef Filtered_kernel_base Type; }; // We change the predicates. #define CGAL_Kernel_pred(P, Pf) \ typedef Filtered_predicate P; \ P Pf() const { return P(); } // We don't touch the constructions. #define CGAL_Kernel_cons(Y,Z) #include }; #ifndef CGAL_NO_STATIC_FILTERS template < typename CK > class Static_filters_base : public Static_filters< Filtered_kernel_base > { template < typename Kernel2 > struct Base { typedef typename CK::template Base::Type CK2; typedef Static_filters_base Type; }; }; #endif template < typename CK > struct Filtered_kernel_adaptor #ifndef CGAL_NO_STATIC_FILTERS : public Static_filters_base #else : public Filtered_kernel_base #endif {}; template struct Filtered_kernel : public Filtered_kernel_adaptor< Type_equality_wrapper< typename CK::template Base< Filtered_kernel >::Type, Filtered_kernel > > {}; // The following is only kept for backward compatibility. #ifndef CGAL_NO_DEPRECATED_CODE template < typename CK > struct Filtered_kernel_without_type_equality : public Filtered_kernel_adaptor {}; #endif CGAL_END_NAMESPACE #endif // CGAL_FILTERED_KERNEL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/box_intersection_d.h0000644000175000017500000004044411344301500031060 0ustar debiandebian// Copyright (c) 2004 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/box_intersection_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner // Andreas Meyer #ifndef CGAL_BOX_INTERSECTION_D_H #define CGAL_BOX_INTERSECTION_D_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Generic call with custom predicate traits parameter. template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class BoxPredicateTraits > void box_intersection_custom_predicates_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, BoxPredicateTraits traits, std::ptrdiff_t cutoff = 10, Box_intersection_d::Setting setting = Box_intersection_d::BIPARTITE) { typedef BoxPredicateTraits Traits; typedef typename Traits::NT NT; CGAL_assertion( Traits::dimension() > 0 ); const int dim = Traits::dimension() - 1; const NT inf = Box_intersection_d::box_limits::inf(); const NT sup = Box_intersection_d::box_limits::sup(); Box_intersection_d::segment_tree(begin1, end1, begin2, end2, inf, sup, callback, traits, cutoff, dim, true); if(setting == Box_intersection_d::BIPARTITE) Box_intersection_d::segment_tree(begin2, end2, begin1, end1, inf, sup, callback, traits, cutoff, dim, false); } // Generic call with box traits parameter. // - make all default parameters explicit overloads (workaround) template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class BoxTraits > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, BoxTraits box_traits, std::ptrdiff_t cutoff, Box_intersection_d::Topology topology, Box_intersection_d::Setting setting) { if (topology == Box_intersection_d::CLOSED) { typedef Box_intersection_d::Predicate_traits_d Traits; box_intersection_custom_predicates_d(begin1, end1, begin2, end2, callback, Traits(), cutoff, setting); } else { typedef Box_intersection_d::Predicate_traits_d Traits; box_intersection_custom_predicates_d(begin1, end1, begin2, end2, callback, Traits(), cutoff, setting); } } template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class BoxTraits > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, BoxTraits box_traits, std::ptrdiff_t cutoff, Box_intersection_d::Topology topology) { box_intersection_d( begin1, end1, begin2, end2, callback, box_traits, cutoff, topology, Box_intersection_d::BIPARTITE); } template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class BoxTraits > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, BoxTraits box_traits, std::ptrdiff_t cutoff) { box_intersection_d( begin1, end1, begin2, end2, callback, box_traits, cutoff, Box_intersection_d::CLOSED, Box_intersection_d::BIPARTITE); } template< class RandomAccessIter1, class RandomAccessIter2, class Callback, class BoxTraits > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, BoxTraits box_traits) { box_intersection_d( begin1, end1, begin2, end2, callback, box_traits, 10, Box_intersection_d::CLOSED, Box_intersection_d::BIPARTITE); } // Specialized call with default box traits. // - make all default parameters explicit overloads (workaround) template< class RandomAccessIter1, class RandomAccessIter2, class Callback > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, std::ptrdiff_t cutoff, Box_intersection_d::Topology topology, Box_intersection_d::Setting setting) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_d( begin1, end1, begin2, end2, callback, Box_traits(), cutoff, topology, setting); } template< class RandomAccessIter1, class RandomAccessIter2, class Callback > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, std::ptrdiff_t cutoff, Box_intersection_d::Topology topology) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_d( begin1, end1, begin2, end2, callback, Box_traits(), cutoff, topology, Box_intersection_d::BIPARTITE); } template< class RandomAccessIter1, class RandomAccessIter2, class Callback > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback, std::ptrdiff_t cutoff) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_d( begin1, end1, begin2, end2, callback, Box_traits(), cutoff, Box_intersection_d::CLOSED, Box_intersection_d::BIPARTITE); } template< class RandomAccessIter1, class RandomAccessIter2, class Callback > void box_intersection_d( RandomAccessIter1 begin1, RandomAccessIter1 end1, RandomAccessIter2 begin2, RandomAccessIter2 end2, Callback callback) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_d( begin1, end1, begin2, end2, callback, Box_traits(), 10, Box_intersection_d::CLOSED, Box_intersection_d::BIPARTITE); } // Generic call with box traits parameter, specialized for self-intersection. // - make all default parameters explicit overloads (workaround) template< class RandomAccessIter, class Callback, class BoxTraits > void box_self_intersection_d( RandomAccessIter begin, RandomAccessIter end, Callback callback, BoxTraits box_traits) { typedef typename std::iterator_traits::value_type val_t; std::vector< val_t> i( begin, end); box_intersection_d( begin, end, i.begin(), i.end(), callback, box_traits, 10, Box_intersection_d::CLOSED, Box_intersection_d::COMPLETE); } template< class RandomAccessIter, class Callback, class BoxTraits > void box_self_intersection_d( RandomAccessIter begin, RandomAccessIter end, Callback callback, BoxTraits box_traits, std::ptrdiff_t cutoff) { typedef typename std::iterator_traits::value_type val_t; std::vector< val_t> i( begin, end); box_intersection_d( begin, end, i.begin(), i.end(), callback, box_traits, cutoff, Box_intersection_d::CLOSED, Box_intersection_d::COMPLETE); } template< class RandomAccessIter, class Callback, class BoxTraits > void box_self_intersection_d( RandomAccessIter begin, RandomAccessIter end, Callback callback, BoxTraits box_traits, std::ptrdiff_t cutoff, Box_intersection_d::Topology topology) { typedef typename std::iterator_traits::value_type val_t; std::vector< val_t> i( begin, end); box_intersection_d( begin, end, i.begin(), i.end(), callback, box_traits, cutoff, topology, Box_intersection_d::COMPLETE); } // Specialized call with default box traits, specialized for self-intersection. // - make all default parameters explicit overloads (workaround) template< class RandomAccessIter, class Callback > void box_self_intersection_d( RandomAccessIter begin, RandomAccessIter end, Callback callback) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_self_intersection_d(begin, end, callback, Box_traits(), 10, Box_intersection_d::CLOSED); } template< class RandomAccessIter, class Callback > void box_self_intersection_d( RandomAccessIter begin, RandomAccessIter end, Callback callback, std::ptrdiff_t cutoff) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_self_intersection_d(begin, end, callback, Box_traits(), 10, Box_intersection_d::CLOSED); } template< class RandomAccessIter, class Callback > void box_self_intersection_d( RandomAccessIter begin, RandomAccessIter end, Callback callback, std::ptrdiff_t cutoff, Box_intersection_d::Topology topology) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_self_intersection_d(begin, end, callback, Box_traits(), cutoff, topology ); } // Generic call for trivial all-pairs algorithm with box traits parameter. // - make all default parameters explicit overloads (workaround) template< class ForwardIter1, class ForwardIter2, class Callback, class BoxTraits > void box_intersection_all_pairs_d( ForwardIter1 begin1, ForwardIter1 end1, ForwardIter2 begin2, ForwardIter2 end2, Callback callback, BoxTraits traits) { typedef Box_intersection_d::Predicate_traits_d Traits; Box_intersection_d::all_pairs( begin1, end1, begin2, end2, callback, Traits()); } template< class ForwardIter1, class ForwardIter2, class Callback, class BoxTraits > void box_intersection_all_pairs_d( ForwardIter1 begin1, ForwardIter1 end1, ForwardIter2 begin2, ForwardIter2 end2, Callback callback, BoxTraits traits, Box_intersection_d::Topology topology, Box_intersection_d::Setting setting) { bool complete_case = (setting != Box_intersection_d::BIPARTITE); if (topology == Box_intersection_d::CLOSED) { typedef Box_intersection_d::Predicate_traits_d Traits; Box_intersection_d::all_pairs( begin1, end1, begin2, end2, callback, Traits(), complete_case); } else { typedef Box_intersection_d::Predicate_traits_d Traits; Box_intersection_d::all_pairs( begin1, end1, begin2, end2, callback, Traits(), complete_case); } } template< class ForwardIter1, class ForwardIter2, class Callback, class BoxTraits > void box_intersection_all_pairs_d( ForwardIter1 begin1, ForwardIter1 end1, ForwardIter2 begin2, ForwardIter2 end2, Callback callback, BoxTraits traits, Box_intersection_d::Topology topology) { box_intersection_all_pairs_d( begin1, end1, begin2, end2, callback, traits, topology, Box_intersection_d::BIPARTITE); } // Specialized call for trivial all-pairs algorithm with default box traits. // - make all default parameters explicit overloads (workaround) template< class ForwardIter1, class ForwardIter2, class Callback > void box_intersection_all_pairs_d( ForwardIter1 begin1, ForwardIter1 end1, ForwardIter2 begin2, ForwardIter2 end2, Callback callback) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_all_pairs_d( begin1, end1, begin2, end2, callback, Box_traits(), Box_intersection_d::CLOSED ); } template< class ForwardIter1, class ForwardIter2, class Callback > void box_intersection_all_pairs_d( ForwardIter1 begin1, ForwardIter1 end1, ForwardIter2 begin2, ForwardIter2 end2, Callback callback, Box_intersection_d::Topology topology) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_all_pairs_d( begin1, end1, begin2, end2, callback, Box_traits(), topology); } template< class ForwardIter1, class ForwardIter2, class Callback > void box_intersection_all_pairs_d( ForwardIter1 begin1, ForwardIter1 end1, ForwardIter2 begin2, ForwardIter2 end2, Callback callback, Box_intersection_d::Topology topology, Box_intersection_d::Setting setting) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_intersection_all_pairs_d( begin1, end1, begin2, end2, callback, Box_traits(), topology, setting); } // Generic call for trivial all-pairs algorithm with box traits parameter // specialized for self-intersection test. // - make all default parameters explicit overloads (workaround) template< class ForwardIter, class Callback, class BoxTraits > void box_self_intersection_all_pairs_d( ForwardIter begin1, ForwardIter end1, Callback callback, BoxTraits traits) { typedef Box_intersection_d::Predicate_traits_d Traits; Box_intersection_d::all_pairs( begin1, end1, callback, Traits()); } template< class ForwardIter, class Callback, class BoxTraits > void box_self_intersection_all_pairs_d( ForwardIter begin1, ForwardIter end1, Callback callback, BoxTraits traits, Box_intersection_d::Topology topology) { if (topology == Box_intersection_d::CLOSED) { typedef Box_intersection_d::Predicate_traits_d Traits; Box_intersection_d::all_pairs( begin1, end1, callback, Traits()); } else { typedef Box_intersection_d::Predicate_traits_d Traits; Box_intersection_d::all_pairs( begin1, end1, callback, Traits()); } } // Specialized call for trivial all-pairs algorithm with default box traits. // specialized for self-intersection test. // - make all default parameters explicit overloads (workaround) template< class ForwardIter, class Callback > void box_self_intersection_all_pairs_d( ForwardIter begin1, ForwardIter end1, Callback callback) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_self_intersection_all_pairs_d( begin1, end1, callback, Box_traits(), Box_intersection_d::CLOSED ); } template< class ForwardIter, class Callback > void box_self_intersection_all_pairs_d( ForwardIter begin1, ForwardIter end1, Callback callback, Box_intersection_d::Topology topology) { typedef typename std::iterator_traits::value_type val_t; typedef Box_intersection_d::Box_traits_d< val_t> Box_traits; box_self_intersection_all_pairs_d( begin1, end1, callback, Box_traits(), topology); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_constructive_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_constructi0000644000175000017500000000467711344301500031564 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/convex_hull_constructive_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra // This file's name must begin with a lower-case letter for backward // compatability. Unfortunately, you can't have a file that differs only // in capitalization on the Windows platforms. #ifndef CGAL_CONVEX_HULL_CONSTRUCTIVE_TRAITS_2_H #define CGAL_CONVEX_HULL_CONSTRUCTIVE_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE template class Convex_hull_constructive_traits_2 : public K_ { public: typedef K_ K; typedef typename K::Point_2 Point_2; typedef typename K::Less_xy_2 Less_xy_2; typedef typename K::Less_yx_2 Less_yx_2; typedef CGALi::r_Less_dist_to_line Less_signed_distance_to_line_2; typedef typename K::Less_rotate_ccw_2 Less_rotate_ccw_2; typedef typename K::Left_turn_2 Left_turn_2; typedef typename K::Equal_2 Equal_2; typedef typename K::Segment_2 Segment_2; Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Less_signed_distance_to_line_2 less_signed_distance_to_line_2_object() const { return Less_signed_distance_to_line_2(); } Less_rotate_ccw_2 less_rotate_ccw_2_object() const { return Less_rotate_ccw_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Equal_2 equal_2_object() const { return Equal_2(); } }; // for backward compatability template class convex_hull_constructive_traits_2 : public Convex_hull_constructive_traits_2 { }; CGAL_END_NAMESPACE #endif // CGAL_CONVEX_HULL_CONSTRUCTIVE_TRAITS_2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_incremental_builder_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_incremental0000644000175000017500000010304411344301500031451 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polyhedron_incremental_builder_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner ) #ifndef CGAL_POLYHEDRON_INCREMENTAL_BUILDER_3_H #define CGAL_POLYHEDRON_INCREMENTAL_BUILDER_3_H 1 #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class HalfedgeDS_> class Polyhedron_incremental_builder_3 { public: typedef HalfedgeDS_ HDS; // internal typedef HalfedgeDS_ HalfedgeDS; typedef typename HDS::Vertex Vertex; typedef typename HDS::Halfedge Halfedge; typedef typename HDS::Face Face; typedef typename HDS::Vertex_handle Vertex_handle; typedef typename HDS::Halfedge_handle Halfedge_handle; typedef typename HDS::Face_handle Face_handle; typedef typename HDS::Face_handle Facet_handle; typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Vertex::Point Point_3; typedef typename HDS::size_type size_type; protected: typedef typename HDS::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename HDS::Supports_removal Supports_removal; typedef typename HDS::Vertex_iterator Vertex_iterator; typedef typename HDS::Halfedge_iterator Halfedge_iterator; typedef Random_access_adaptor Random_access_index; bool m_error; bool m_verbose; HDS& hds; size_type rollback_v; size_type rollback_f; size_type rollback_h; size_type new_vertices; size_type new_faces; size_type new_halfedges; Face_handle current_face; Random_access_index index_to_vertex_map; std::vector< Halfedge_handle> vertex_to_edge_map; Halfedge_handle g1; // first halfedge, 0 denotes none. Halfedge_handle gprime; Halfedge_handle h1; // current halfedge size_type w1; // first vertex. size_type w2; // second vertex. size_type v1; // current vertex bool first_vertex; bool last_vertex; CGAL_assertion_code( int check_protocoll;) // use to check protocoll. // states for checking: 0 = created, 1 = constructing, 2 = make face. // Implement the vertex_to_edge_map either with an array or // the halfedge pointer in the vertices (if supported). // ---------------------------------------------------- void initialize_vertex_to_edge_map( size_type n, bool mode, Tag_true) { vertex_to_edge_map = std::vector< Halfedge_handle>(); vertex_to_edge_map.reserve(n); if ( mode) { // go through all halfedges and keep a halfedge for each // vertex found in a hashmap. size_type i = 0; for ( Vertex_iterator vi = hds.vertices_begin(); vi != hds.vertices_end(); ++vi) { set_vertex_to_edge_map( i, vi->halfedge()); ++i; } } } void initialize_vertex_to_edge_map( size_type n, bool mode, Tag_false){ vertex_to_edge_map = std::vector< Halfedge_handle>(); vertex_to_edge_map.reserve(n); if ( mode) { // go through all halfedges and keep a halfedge for each // vertex found in a hashmap. typedef Unique_hash_map< Vertex_iterator, Halfedge_handle> V_map; Halfedge_handle hh; V_map v_map( hh, hds.size_of_vertices()); for ( Halfedge_iterator hi = hds.halfedges_begin(); hi != hds.halfedges_end(); ++hi) { v_map[ hi->vertex()] = hi; } size_type i = 0; for ( Vertex_iterator vi = hds.vertices_begin(); vi != hds.vertices_end(); ++vi) { //set_vertex_to_edge_map( i, v_map[ index_to_vertex_map[i]]); set_vertex_to_edge_map( i, v_map[ vi]); ++i; } } } void initialize_vertex_to_edge_map( size_type n, bool mode) { initialize_vertex_to_edge_map(n, mode, Supports_vertex_halfedge()); } void push_back_vertex_to_edge_map( Halfedge_handle h, Tag_true) { push_back_vertex_to_edge_map( h, Tag_false()); } void push_back_vertex_to_edge_map( Halfedge_handle h, Tag_false) { vertex_to_edge_map.push_back(h); } void push_back_vertex_to_edge_map( Halfedge_handle h) { push_back_vertex_to_edge_map( h, Supports_vertex_halfedge()); } Halfedge_handle get_vertex_to_edge_map( int i, Tag_true) { // Use the halfedge pointer within the vertex. //CGAL_assertion( index_to_vertex_map[i]->halfedge() == get_vertex_to_edge_map(i, Tag_false())); return index_to_vertex_map[i]->halfedge(); } Halfedge_handle get_vertex_to_edge_map( int i, Tag_false) { // Use the self-managed array vertex_to_edge_map. return vertex_to_edge_map[i]; } Halfedge_handle get_vertex_to_edge_map( int i) { return get_vertex_to_edge_map( i, Supports_vertex_halfedge()); } void set_vertex_to_edge_map( int i, Halfedge_handle h, Tag_true) { set_vertex_to_edge_map( i, h, Tag_false()); // Use the halfedge pointer within the vertex. index_to_vertex_map[i]->VBase::set_halfedge(h); } void set_vertex_to_edge_map( int i, Halfedge_handle h, Tag_false) { // Use the self-managed array vertex_to_edge_map. vertex_to_edge_map[i] = h; } void set_vertex_to_edge_map( int i, Halfedge_handle h) { set_vertex_to_edge_map( i, h, Supports_vertex_halfedge()); } // An Incremental Builder for Polyhedral Surfaces // ---------------------------------------------- // DEFINITION // // Polyhedron_incremental_builder_3 is an auxiliary class that // supports the incremental construction of polyhedral surfaces. This is // for example convinient when constructing polyhedral surfaces from // files. The incremental construction starts with a list of all point // coordinates and concludes with a list of all facet polygons. Edges are // not explicitly specified. They are derived from the incidence // information provided from the facet polygons. These are given as a // sequence of vertex indices. The correct protocol of method calls to // build a polyhedral surface can be stated as regular expression: // // `begin_surface (add_vertex | (begin_facet add_vertex_to_facet* // end_facet))* end_surface ' // // PARAMETERS // // `HDS' is the halfedge data structure used to represent the // polyhedral surface that is to be constructed. // // CREATION public: bool error() const { return m_error; } Polyhedron_incremental_builder_3( HDS& h, bool verbose = false) // stores a reference to the halfedge data structure `h' in the // internal state. The previous polyhedral surface in `h' // remains unchanged. The incremental builder adds the new // polyhedral surface to the old one. : m_error( false), m_verbose( verbose), hds(h) { CGAL_assertion_code(check_protocoll = 0;) } ~Polyhedron_incremental_builder_3() { CGAL_assertion( check_protocoll == 0); } // OPERATIONS enum { RELATIVE_INDEXING = 0, ABSOLUTE_INDEXING = 1}; void begin_surface( std::size_t v, std::size_t f, std::size_t h = 0, int mode = RELATIVE_INDEXING); // starts the construction. v is the number of new // vertices to expect, f the number of new facets, and h the number of // new halfedges. If h is unspecified (`== 0') it is estimated using // Euler equations (plus 5% for the so far unkown holes and genus // of the object). These values are used to reserve space in the // polyhedron representation `HDS'. If the representation // supports insertion these values do not restrict the class of // readable polyhedrons. If the representation does not support // insertion the object must fit in the reserved sizes. // If `mode' is set to ABSOLUTE_INDEXING the incremental builder // uses absolute indexing and the vertices of the old polyhedral // surface can be used in new facets. Otherwise relative indexing is // used starting with new indices for the new construction. Vertex_handle add_vertex( const Point_3& p) { // adds p to the vertex list. CGAL_assertion( check_protocoll == 1); if ( hds.size_of_vertices() >= hds.capacity_of_vertices()) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3::" << std::endl; verr << "add_vertex(): capacity error: more than " << new_vertices << " vertices added." << std::endl; m_error = true; return Vertex_handle(); } HalfedgeDS_decorator decorator(hds); Vertex_handle v = decorator.vertices_push_back( Vertex(p)); index_to_vertex_map.push_back( v); decorator.set_vertex_halfedge( v, Halfedge_handle()); push_back_vertex_to_edge_map( Halfedge_handle()); ++new_vertices; return v; } // returns handle for the vertex of index i Vertex_handle vertex( std::size_t i) { if ( i < new_vertices) return index_to_vertex_map[i]; return Vertex_handle(); } Facet_handle begin_facet() { // starts a facet. if ( m_error) return Facet_handle(); CGAL_assertion( check_protocoll == 1); CGAL_assertion_code( check_protocoll = 2;) if ( hds.size_of_faces() >= hds.capacity_of_faces()) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3::" << std::endl; verr << "begin_facet(): capacity error: more than " << new_vertices << " facets added." << std::endl; m_error = true; return Facet_handle(); } // initialize all status variables. first_vertex = true; // denotes 'no vertex yet' g1 = Halfedge_handle(); // denotes 'no halfedge yet' last_vertex = false; HalfedgeDS_decorator decorator(hds); current_face = decorator.faces_push_back( Face()); return current_face; } void add_vertex_to_facet( std::size_t i); // adds a vertex with index i to the current facet. The first // point added with `add_vertex()' has the index 0. Halfedge_handle end_facet() { // ends a facet. if ( m_error) return Halfedge_handle(); CGAL_assertion( check_protocoll == 2); CGAL_assertion( ! first_vertex); // cleanup all static status variables add_vertex_to_facet( w1); if ( m_error) return Halfedge_handle(); last_vertex = true; add_vertex_to_facet( w2); if ( m_error) return Halfedge_handle(); CGAL_assertion( check_protocoll == 2); CGAL_assertion_code( check_protocoll = 1;) HalfedgeDS_items_decorator decorator; Halfedge_handle h = get_vertex_to_edge_map(w1); decorator.set_face_halfedge( current_face, h); ++new_faces; return h; } template Halfedge_handle add_facet( InputIterator first, InputIterator beyond) { // synonym for begin_facet(), a call to add_facet() for each iterator // value type, and end_facet(). begin_facet(); for ( ; ! m_error && first != beyond; ++first) add_vertex_to_facet( *first); if ( m_error) return Halfedge_handle(); return end_facet(); } template bool test_facet( InputIterator first, InputIterator beyond) { // tests if the facet described by the vertex indices in the // range [first,beyond) can be inserted without creating a // a non-manifold (and therefore invalid) situation. // First, create a copy of the indices and close it cyclically std::vector< std::size_t> indices( first, beyond); if ( indices.size() < 3) return false; indices.push_back( indices[0]); return test_facet_indices( indices); } bool test_facet_indices( std::vector< std::size_t> indices); void end_surface(); // ends the construction. bool check_unconnected_vertices(); // returns `true' if unconnected vertices are detected. If `verb' // is set to `true' debug information about the unconnected // vertices is printed. bool remove_unconnected_vertices( Tag_true); bool remove_unconnected_vertices( Tag_false) { return ! check_unconnected_vertices(); } bool remove_unconnected_vertices() { // returns `true' if all unconnected vertices could be removed // succesfully. return remove_unconnected_vertices( Supports_removal()); } void rollback(); protected: Halfedge_handle lookup_hole( std::size_t w) { CGAL_assertion( w < new_vertices); return lookup_hole( get_vertex_to_edge_map( w)); } size_type find_vertex( Vertex_handle v) { // Returns 0 if v == NULL. if ( v == Vertex_handle() ) return 0; size_type n = 0; typename HDS::Vertex_iterator it = hds.vertices_begin(); while ( it != v) { CGAL_assertion( it != hds.vertices_end()); ++n; ++it; } n = n - rollback_v; return n; } size_type find_facet( Face_handle f) { // Returns 0 if f == NULL. if ( f == Face_handle()) return 0; size_type n = 0; typename HDS::Face_iterator it = hds.faces_begin(); while ( it != f) { CGAL_assertion( it != hds.faces_end()); ++n; ++it; } n = n - rollback_f; return n; } Halfedge_handle lookup_halfedge( size_type w, size_type v) { // Pre: 0 <= w,v < new_vertices // Case a: It exists an halfedge g from w to v: // g must be a border halfedge and the facet of g->opposite() // must be set and different from the current facet. // Set the facet of g to the current facet. Return the // halfedge pointing to g. // Case b: It exists no halfedge from w to v: // Create a new pair of halfedges g and g->opposite(). // Set the facet of g to the current facet and g->opposite() // to a border halfedge. Assign the vertex references. // Set g->opposite()->next() to g. Return g->opposite(). typedef typename HDS::Supports_halfedge_vertex Supports_halfedge_vertex; Assert_compile_time_tag( Supports_halfedge_vertex(), Tag_true()); CGAL_assertion( w < new_vertices); CGAL_assertion( v < new_vertices); CGAL_assertion( ! last_vertex); HalfedgeDS_items_decorator decorator; Halfedge_handle e = get_vertex_to_edge_map( w); if ( e != Halfedge_handle()) { CGAL_assertion( e->vertex() == index_to_vertex_map[w]); // check that the facet has no self intersections if ( current_face != Face_handle() && current_face == decorator.get_face(e)) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3::" << std::endl; verr << "lookup_halfedge(): input error: facet " << new_faces << " has a self intersection at vertex " << w << "." << std::endl; m_error = true; return Halfedge_handle(); } Halfedge_handle start_edge( e); do { if ( e->next()->vertex() == index_to_vertex_map[v]) { if ( ! e->next()->is_border()) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3" "::" << std::endl; verr << "lookup_halfedge(): input error: facet " << new_faces << " shares a halfedge from " "vertex " << w << " to vertex " << v << " with"; if ( m_verbose && current_face != Face_handle()) verr << " facet " << find_facet( decorator.get_face(e->next())) << '.' << std::endl; else verr << " another facet." << std::endl; m_error = true; return Halfedge_handle(); } CGAL_assertion( ! e->next()->opposite()->is_border()); if ( current_face != Face_handle() && current_face == decorator.get_face( e->next()->opposite())) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3" "::" << std::endl; verr << "lookup_halfedge(): input error: facet " << new_faces << " has a self intersection " "at the halfedge from vertex " << w << " to vertex " << v << "." << std::endl; m_error = true; return Halfedge_handle(); } decorator.set_face( e->next(), current_face); return e; } e = e->next()->opposite(); } while ( e != start_edge); } // create a new halfedge if ( hds.size_of_halfedges() >= hds.capacity_of_halfedges()) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3::" << std::endl; verr << "lookup_halfedge(): capacity error: more than " << new_halfedges << " halfedges added while creating facet" << new_faces << '.' << std::endl; m_error = true; return Halfedge_handle(); } e = hds.edges_push_back( Halfedge(), Halfedge()); new_halfedges++; new_halfedges++; decorator.set_face( e, current_face); e->HBase::set_vertex( index_to_vertex_map[v]); e->HBase::set_next( Halfedge_handle()); decorator.set_prev( e, e->opposite()); e = e->opposite(); e->HBase::set_vertex( index_to_vertex_map[w]); e->HBase::set_next( e->opposite()); return e; } Halfedge_handle lookup_hole( Halfedge_handle e) { // Halfedge e points to a vertex w. Walk around w to find a hole // in the facet structure. Report an error if none exist. Return // the halfedge at this hole that points to the vertex w. CGAL_assertion( e != Halfedge_handle()); HalfedgeDS_items_decorator decorator; Halfedge_handle start_edge( e); do { if ( e->next()->is_border()) { return e; } e = e->next()->opposite(); } while ( e != start_edge); Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3::" << std::endl; verr << "lookup_hole(): input error: at vertex " << find_vertex( e->vertex()) << " a closed surface already exists and facet " << new_faces << " is nonetheless adjacent." << std::endl; if ( m_verbose && current_face != Face_handle()) { verr << " The closed cycle of facets is:"; do { if ( ! e->is_border()) verr << " " << find_facet( decorator.get_face(e)); e = e->next()->opposite(); } while ( e != start_edge); verr << '.' << std::endl; } m_error = true; return Halfedge_handle(); } }; template < class HDS> void Polyhedron_incremental_builder_3:: rollback() { CGAL_assertion( rollback_v <= hds.size_of_vertices()); CGAL_assertion( rollback_h <= hds.size_of_halfedges()); CGAL_assertion( rollback_f <= hds.size_of_faces()); if ( rollback_v == 0 && rollback_h == 0 && rollback_f == 0) { hds.clear(); } else { while ( rollback_v != hds.size_of_vertices()) hds.vertices_pop_back(); CGAL_assertion((( hds.size_of_halfedges() - rollback_h) & 1) == 0); while ( rollback_h != hds.size_of_halfedges()) hds.edges_pop_back(); while ( rollback_f != hds.size_of_faces()) hds.faces_pop_back(); } m_error = false; CGAL_assertion_code( check_protocoll = 0;) } template < class HDS> CGAL_MEDIUM_INLINE void Polyhedron_incremental_builder_3:: begin_surface( std::size_t v, std::size_t f, std::size_t h, int mode) { CGAL_assertion( check_protocoll == 0); CGAL_assertion_code( check_protocoll = 1;) CGAL_assertion( ! m_error); if ( mode == RELATIVE_INDEXING) { new_vertices = 0; new_faces = 0; new_halfedges = 0; rollback_v = hds.size_of_vertices(); rollback_f = hds.size_of_faces(); rollback_h = hds.size_of_halfedges(); } else { new_vertices = hds.size_of_vertices(); new_faces = hds.size_of_faces(); new_halfedges = hds.size_of_halfedges(); rollback_v = 0; rollback_f = 0; rollback_h = 0; } if ( h == 0) { // Use the Eulerian equation for connected planar graphs. We do // not know the number of facets that are holes and we do not // know the genus of the surface. So we add 12 and a factor of // 5 percent. h = int((v + f - 2 + 12) * 2.1); } hds.reserve( hds.size_of_vertices() + v, hds.size_of_halfedges() + h, hds.size_of_faces() + f); if ( mode == RELATIVE_INDEXING) { index_to_vertex_map = Random_access_index( hds.vertices_end()); index_to_vertex_map.reserve(v); initialize_vertex_to_edge_map( v, false); } else { index_to_vertex_map = Random_access_index( hds.vertices_begin(), hds.vertices_end()); index_to_vertex_map.reserve( hds.size_of_vertices() + v); initialize_vertex_to_edge_map( hds.size_of_vertices() + v, true); } } template < class HDS> void Polyhedron_incremental_builder_3:: add_vertex_to_facet( std::size_t v2) { if ( m_error) return; CGAL_assertion( check_protocoll == 2); if ( v2 >= new_vertices) { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3::" << std::endl; verr << "add_vertex_to_facet(): vertex index " << v2 << " is out-of-range [0," << new_vertices-1 << "]." << std::endl; m_error = true; return; } HalfedgeDS_items_decorator decorator; if ( first_vertex) { CGAL_assertion( ! last_vertex); w1 = v2; first_vertex = false; return; } if ( g1 == Halfedge_handle()) { CGAL_assertion( ! last_vertex); gprime = lookup_halfedge( w1, v2); if ( m_error) return; h1 = g1 = gprime->next(); v1 = w2 = v2; return; } // g1, h1, v1, w1, w2 are set. Insert halfedge. // Lookup v1-->v2 Halfedge_handle hprime; if ( last_vertex) hprime = gprime; else { hprime = lookup_halfedge( v1, v2); if ( m_error) return; } Halfedge_handle h2 = hprime->next(); CGAL_assertion( ! last_vertex || h2 == g1); Halfedge_handle prev = h1->next(); h1->HBase::set_next( h2); decorator.set_prev( h2, h1); if ( get_vertex_to_edge_map( v1) == Halfedge_handle()) { // case 1: h2->opposite()->HBase::set_next( h1->opposite()); decorator.set_prev( h1->opposite(), h2->opposite()); } else { // case 2: bool b1 = h1->opposite()->is_border(); bool b2 = h2->opposite()->is_border(); if ( b1 && b2) { Halfedge_handle hole = lookup_hole( v1); if ( m_error) return; CGAL_assertion( hole != Halfedge_handle()); h2->opposite()->HBase::set_next( hole->next()); decorator.set_prev( hole->next(), h2->opposite()); hole->HBase::set_next( h1->opposite()); decorator.set_prev( h1->opposite(), hole); } else if ( b2) { // case 2.b: CGAL_assertion( prev->is_border()); h2->opposite()->HBase::set_next( prev); decorator.set_prev( prev, h2->opposite()); } else if ( b1) { // case 2.c: CGAL_assertion( hprime->is_border()); hprime->HBase::set_next( h1->opposite()); decorator.set_prev( h1->opposite(), hprime); } else if ( h2->opposite()->next() == h1->opposite()) {// case 2.d: // f1 == f2 CGAL_assertion( decorator.get_face( h1->opposite()) == decorator.get_face( h2->opposite())); } else { // case 2.e: if ( prev == h2) { // case _i: // nothing to be done, hole is closed. } else { // case _ii: CGAL_assertion( prev->is_border()); CGAL_assertion( hprime->is_border()); hprime->HBase::set_next( prev); decorator.set_prev( prev, hprime); // Check whether the halfedges around v1 are connected. // It is sufficient to check it for h1 to prev. // Assert loop termination: CGAL_assertion_code( std::size_t k = 0;) // Look for a hole in the facet complex starting at h1. Halfedge_handle hole; Halfedge_handle e = h1; do { if ( e->is_border()) hole = e; e = e->next()->opposite(); CGAL_assertion( k++ < hds.size_of_halfedges()); } while ( e->next() != prev && e != h1); if ( e == h1) { // disconnected facet complexes if ( hole != Halfedge_handle()) { // The complex can be connected with // the hole at hprime. hprime->HBase::set_next( hole->next()); decorator.set_prev( hole->next(), hprime); hole->HBase::set_next( prev); decorator.set_prev( prev, hole); } else { Verbose_ostream verr( m_verbose); verr << " " << std::endl; verr << "CGAL::Polyhedron_incremental_builder_3<" "HDS>::" << std::endl; verr << "add_vertex_to_facet(): input error: " "disconnected facet complexes at vertex " << v1 << ":" << std::endl; if ( m_verbose && current_face != Face_handle()) { verr << " involved facets are:"; do { if ( ! e->is_border()) verr << " " << find_facet( decorator.get_face(e)); e = e->next()->opposite(); } while ( e != h1); verr << " (closed cycle) and"; e = hprime; do { if ( ! e->is_border()) verr << " " << find_facet( decorator.get_face(e)); } while ( e != hprime); verr << "." << std::endl; } m_error = true; return; } } } } } if ( h1->vertex() == index_to_vertex_map[v1]) set_vertex_to_edge_map( v1, h1); CGAL_assertion( h1->vertex() == index_to_vertex_map[v1]); h1 = h2; v1 = v2; } template < class HDS> bool Polyhedron_incremental_builder_3:: test_facet_indices( std::vector< std::size_t> indices) { typedef typename HDS::Supports_halfedge_vertex Supports_halfedge_vertex; Assert_compile_time_tag( Supports_halfedge_vertex(), Tag_true()); // tests if the facet described by the vertex indices can be inserted // without creating a a non-manifold (and therefore invalid) situation. // indices are cyclically closed once. std::size_t n = indices.size() - 1; // Test if a vertex is not twice in the indices for ( std::size_t i = 0; i < n; ++i) { CGAL_precondition( indices[i] < new_vertices); // check if vertex indices[i] is already in the sequence [0..i-1] for ( std::size_t k = 0; k+1 < i; ++k) { if ( indices[k] == indices[i]) return false; } } // Test non-manifold edges for ( std::size_t i = 0; i < n; ++i) { // edge goes from vertex indices[i] to indices[i+1] // we know already that the edge is only once in the sequence // (otherwise the end-vertices would be twice in the sequence too) // check if edge is already in the HDS and is not border edge Halfedge_handle v = get_vertex_to_edge_map(indices[i]); Vertex_handle w = index_to_vertex_map[indices[i+1]]; if ( v != Halfedge_handle() && get_vertex_to_edge_map(indices[i+1]) != Halfedge_handle()) { // cycle through halfedge-loop and find edge to indices[i+1] Halfedge_handle vstart = v; do { v = v->next()->opposite(); } while ( v->next()->vertex() != w && v != vstart); if ( v->next()->vertex() == w && ! v->next()->is_border()) return false; } } // test non-manifold vertices for ( std::size_t i = 0; i < n; ++i) { // since we don't allow duplicates in indices[..] and we // tested for non-manifold edges already, we just need to check // if the vertex indices[i] is not a closed manifold yet. Halfedge_handle v = get_vertex_to_edge_map(indices[i]); if ( v != Halfedge_handle()) { Halfedge_handle vstart = v; do { v = v->next()->opposite(); } while ( ! v->is_border() && v != vstart); if ( ! v->is_border()) return false; } } return true; } template < class HDS> CGAL_MEDIUM_INLINE void Polyhedron_incremental_builder_3:: end_surface() { if ( m_error) return; CGAL_assertion( check_protocoll == 1); CGAL_assertion_code( check_protocoll = 0;) } template < class HDS> bool Polyhedron_incremental_builder_3:: check_unconnected_vertices() { if ( m_error) return false; bool unconnected = false; Verbose_ostream verr( m_verbose); for ( std::size_t i = 0; i < new_vertices; i++) { if ( get_vertex_to_edge_map( i) == Halfedge_handle()) { verr << "CGAL::Polyhedron_incremental_builder_3::\n" << "check_unconnected_vertices( verb = true): " << "vertex " << i << " is unconnected." << std::endl; unconnected = true; } } return unconnected; } template < class HDS> bool Polyhedron_incremental_builder_3:: remove_unconnected_vertices( Tag_true) { if ( m_error) return true; for( std::size_t i = 0; i < new_vertices; i++) { if( get_vertex_to_edge_map( i) == Halfedge_handle()) { hds.vertices_erase( index_to_vertex_map[i]); } } return true; } CGAL_END_NAMESPACE #endif // CGAL_POLYHEDRON_INCREMENTAL_BUILDER_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous_d.h0000644000175000017500000003335211344301500027772 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef HOMOGENEOUS_D_H #define HOMOGENEOUS_D_H #ifndef NOCGALINCL #include #include #include #include #include #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template > class Homogeneous_d { public: typedef Homogeneous_d Self; typedef pRT RT; typedef Quotient FT; typedef pLA LA; typedef Homogeneous_tag Rep_tag; typedef PointHd2 Point_d_base; typedef VectorHd Vector_d_base; typedef DirectionHd Direction_d_base; typedef HyperplaneHd Hyperplane_d_base; typedef Aff_transformationHd Aff_transformation_d_base; typedef CGAL::Point_d Point_d; typedef CGAL::Vector_d Vector_d; typedef CGAL::Direction_d Direction_d; typedef CGAL::Hyperplane_d Hyperplane_d; typedef CGAL::Aff_transformation_d Aff_transformation_d; typedef typename Point_d_base::Cartesian_const_iterator Cartesian_const_iterator_d; template class Construct_cartesian_const_iterator { typedef typename K::Point_d Point_d; typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator_d; public: typedef Cartesian_const_iterator_d result_type; typedef Arity_tag< 1> Arity; Cartesian_const_iterator_d operator()(const Point_d& p) const { return p.cartesian_begin(); } Cartesian_const_iterator_d operator()( const Point_d& p, int) const { return p.cartesian_end(); } }; // TODO: Make it work for the other values template class Construct_vertex { typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator_d; public: typedef Point_d result_type; typedef Arity_tag< 2> Arity; Point_d operator()(const Iso_box_d& b, int i) { if(i == 0){ return b.min(); } return b.max(); } }; typedef Construct_vertex Construct_vertex_d; template class Construct_min_vertex { typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; public: typedef Point_d result_type; typedef Arity_tag< 1 > Arity; Point_d operator()(const Iso_box_d& b) { return b.min(); } }; typedef Construct_min_vertex Construct_min_vertex_d; Construct_min_vertex_d construct_min_vertex_d_object() const { return Construct_min_vertex_d(); } template class Construct_max_vertex { typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; public: typedef Point_d result_type; typedef Arity_tag< 1 > Arity; Point_d operator()(const Iso_box_d& b) { return b.max(); } }; typedef Construct_max_vertex Construct_max_vertex_d; Construct_max_vertex_d construct_max_vertex_d_object() const { return Construct_max_vertex_d(); } typedef Construct_cartesian_const_iterator Construct_cartesian_const_iterator_d; Construct_cartesian_const_iterator_d construct_cartesian_const_iterator_d_object() const { return Construct_cartesian_const_iterator_d(); } // meta types (fit both kernels): typedef CGAL::Sphere_d Sphere_d; typedef CGAL::Iso_box_d Iso_box_d; typedef CGAL::Segment_d Segment_d; typedef CGAL::Ray_d Ray_d; typedef CGAL::Line_d Line_d; // construction objects: typedef CGALi::Construct Construct_point_d; Construct_point_d construct_point_d_object() const { return Construct_point_d(); } typedef CGALi::Construct Construct_vector_d; Construct_vector_d construct_vector_d_object() const { return Construct_vector_d(); } typedef CGALi::Construct Construct_direction_d; Construct_direction_d construct_direction_d_object() const { return Construct_direction_d(); } typedef CGALi::Construct Construct_segment_d; Construct_segment_d construct_segment_d_object() const { return Construct_segment_d(); } typedef CGALi::Construct Construct_ray_d; Construct_ray_d construct_ray_d_object() const { return Construct_ray_d(); } typedef CGALi::Construct Construct_line_d; Construct_line_d construct_line_d_object() const { return Construct_line_d(); } typedef CGALi::Construct Construct_iso_box_d; Construct_iso_box_d construct_iso_box_d_object() const { return Construct_iso_box_d(); } typedef CGALi::Construct Construct_hyperplane_d; Construct_hyperplane_d construct_hyperplane_d_object() const { return Construct_hyperplane_d(); } typedef CGALi::Construct Construct_sphere_d; Construct_sphere_d construct_sphere_d_object() const { return Construct_sphere_d(); } typedef CGALi::Construct Construct_aff_transformation_d; Construct_aff_transformation_d construct_aff_transformation_d_object() const { return Construct_aff_transformation_d(); } // function objects: typedef Lift_to_paraboloidHd Lift_to_paraboloid_d; typedef Project_along_d_axisHd Project_along_d_axis_d; typedef MidpointHd Midpoint_d; typedef Squared_distanceHd Squared_distance_d; typedef Position_on_lineHd Position_on_line_d; typedef Barycentric_coordinatesHd Barycentric_coordinates_d; typedef OrientationHd Orientation_d; typedef Side_of_oriented_sphereHd Side_of_oriented_sphere_d; typedef Side_of_bounded_sphereHd Side_of_bounded_sphere_d; typedef Contained_in_simplexHd Contained_in_simplex_d; typedef Contained_in_affine_hullHd Contained_in_affine_hull_d; typedef Affine_rankHd Affine_rank_d; typedef Affinely_independentHd Affinely_independent_d; typedef Compare_lexicographicallyHd Compare_lexicographically_d; typedef Lt_from_compare Less_lexicographically_d; typedef Le_from_compare Less_or_equal_lexicographically_d; typedef Eq_from_method Equal_d; typedef Center_of_sphereHd Center_of_sphere_d; typedef Contained_in_linear_hullHd Contained_in_linear_hull_d; typedef Linear_rankHd Linear_rank_d; typedef Linearly_independentHd Linearly_independent_d; typedef Linear_baseHd Linear_base_d; Lift_to_paraboloid_d lift_to_paraboloid_d_object() const { return Lift_to_paraboloid_d(); } Project_along_d_axis_d project_along_d_axis_d_object() const { return Project_along_d_axis_d(); } Midpoint_d midpoint_d_object() const { return Midpoint_d(); } Squared_distance_d squared_distance_d_object() const { return Squared_distance_d(); } Position_on_line_d position_on_line_d_object() const { return Position_on_line_d(); } Barycentric_coordinates_d barycentric_coordinates_d_object() const { return Barycentric_coordinates_d(); } Orientation_d orientation_d_object() const { return Orientation_d(); } Side_of_oriented_sphere_d side_of_oriented_sphere_d_object() const { return Side_of_oriented_sphere_d(); } Side_of_bounded_sphere_d side_of_bounded_sphere_d_object() const { return Side_of_bounded_sphere_d(); } Contained_in_simplex_d contained_in_simplex_d_object() const { return Contained_in_simplex_d(); } Contained_in_affine_hull_d contained_in_affine_hull_d_object() const { return Contained_in_affine_hull_d(); } Affine_rank_d affine_rank_d_object() const { return Affine_rank_d(); } Affinely_independent_d affinely_independent_d_object() const { return Affinely_independent_d(); } Equal_d equal_d_object() const { return Equal_d(); } Compare_lexicographically_d compare_lexicographically_d_object() const { return Compare_lexicographically_d(); } Less_lexicographically_d less_lexicographically_d_object() const { return Less_lexicographically_d(); } Less_or_equal_lexicographically_d less_or_equal_lexicographically_d_object() const { return Less_or_equal_lexicographically_d(); } Center_of_sphere_d center_of_sphere_d_object() const { return Center_of_sphere_d(); } Contained_in_linear_hull_d contained_in_linear_hull_d_object() const { return Contained_in_linear_hull_d(); } Linear_rank_d linear_rank_d_object() const { return Linear_rank_d(); } Linearly_independent_d linearly_independent_d_object() const { return Linearly_independent_d(); } Linear_base_d linear_base_d_object() const { return Linear_base_d(); } // Intersection objects: typedef CGAL::Line_line_intersectionHd Line_line_intersection_d; typedef CGAL::Line_hyperplane_intersectionHd Line_hyperplane_intersection_d; typedef CGAL::Line_d_Line_d_pair Line_d_Line_d_pair; typedef CGAL::Ray_d_Ray_d_pair Ray_d_Ray_d_pair; typedef CGAL::Segment_d_Segment_d_pair Segment_d_Segment_d_pair; typedef CGAL::Line_d_Ray_d_pair Line_d_Ray_d_pair; typedef CGAL::Line_d_Segment_d_pair Line_d_Segment_d_pair; typedef CGAL::Ray_d_Segment_d_pair Ray_d_Segment_d_pair; typedef CGAL::Line_d_Hyperplane_d_pair Line_d_Hyperplane_d_pair; typedef CGAL::Ray_d_Hyperplane_d_pair Ray_d_Hyperplane_d_pair; typedef CGAL::Segment_d_Hyperplane_d_pair Segment_d_Hyperplane_d_pair; typedef CGALi::Intersect Intersect_d; Intersect_d intersect_d_object() const { return Intersect_d(); } // FT - RT conversion and access : static FT make_FT(const RT & num, const RT& denom) { return FT(num, denom); } static FT make_FT(const RT & num) { return FT(num); } static RT FT_numerator(const FT &r) { return r.numerator(); } static RT FT_denominator(const FT &r) { return r.denominator(); } // special stuff for traits class character : struct Component_accessor_d { template int dimension(const C& c) const { return c.dimension(); } template RT homogeneous(const C& c, int i) { return c.homogeneous(i); } template FT cartesian(const C& c, int i) { return c.cartesian(i); } }; Component_accessor_d component_accessor_d_object() const { return Component_accessor_d(); } typedef CGALi::Call_has_on_positive_side Has_on_positive_side_d; Has_on_positive_side_d has_on_positive_side_d_object() const { return Has_on_positive_side_d(); } typedef CGALi::Call_oriented_side Oriented_side_d; Oriented_side_d oriented_side_d_object() const { return Oriented_side_d(); } struct Value_at_d { RT operator()(const Hyperplane_d& h, const Point_d& p) const { return h.value_at(p); } }; Value_at_d value_at_d_object() const { return Value_at_d(); } struct Point_to_vector_d { Vector_d operator()(const Point_d& p) const { return p-CGAL::ORIGIN; } }; Point_to_vector_d point_to_vector_d_object() const { return Point_to_vector_d(); } struct Vector_to_point_d { Point_d operator()(const Vector_d& v) const { return CGAL::ORIGIN+v; } }; Vector_to_point_d vector_to_point_d_object() const { return Vector_to_point_d(); } struct Orthogonal_vector_d { Vector_d operator()(const Hyperplane_d& h) const { return h.orthogonal_vector(); } }; Orthogonal_vector_d orthogonal_vector_d_object() const { return Orthogonal_vector_d(); } struct Point_of_sphere_d { Point_d operator()(const Sphere_d& S, int i) { return S.point(i); } }; Point_of_sphere_d point_of_sphere_d_object() const { return Point_of_sphere_d(); } }; // Homogeneous_d CGAL_END_NAMESPACE #include #include #include #include #include #include #include #include #include #include #include #include #endif // HOMOGENEOUS_D_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/known_bit_size_integers.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/known_bit_size_integer0000644000175000017500000000640711344301500031513 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/known_bit_size_integers.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_KNOWN_BIT_SIZE_INTEGERS_H #define CGAL_KNOWN_BIT_SIZE_INTEGERS_H CGAL_BEGIN_NAMESPACE #if (defined(__sparc__) || defined(__sparc) || defined(sparc)) || \ (defined(__sgi__) || defined(__sgi) || defined(sgi)) || \ (defined(__i386__) || defined(__i386) || defined(i386)) || \ (defined(__x86_64__) || defined(__x86_64) || defined(x86_64)) || \ (defined(__ia64__) || defined(__ia64) || defined(ia64)) || \ (defined(__alpha__) || defined(__alpha) || defined(alpha)) || \ (defined(__ppc__) || defined(__ppc) || defined(ppc)) || \ (defined(__powerpc__) || defined(__powerpc) || defined(powerpc)) typedef signed char Integer8; typedef short Integer16; typedef int Integer32; typedef unsigned char UInteger8; typedef unsigned short UInteger16; typedef unsigned int UInteger32; // See long_long.h for Integer64. # if (defined __ia64__ || defined __x86_64__) typedef long Integer64; typedef unsigned long UInteger64; # define CGAL_HAS_INTEGER64 # endif #else # if defined(__BORLANDC__) typedef __int8 Integer8; typedef __int16 Integer16; typedef __int32 Integer32; typedef __int64 Integer64; typedef unsigned __int8 UInteger8; typedef unsigned __int16 UInteger16; typedef unsigned __int32 UInteger32; typedef unsigned __int64 UInteger64; #define CGAL_HAS_INTEGER64 # else # if defined(_MSC_VER) typedef signed char Integer8; typedef short Integer16; typedef int Integer32; typedef __int64 Integer64; typedef unsigned char UInteger8; typedef unsigned short UInteger16; typedef unsigned int UInteger32; typedef unsigned __int64 UInteger64; #define CGAL_HAS_INTEGER64 # else # error "patch this" # endif # endif #endif CGAL_END_NAMESPACE #endif // CGAL_KNOWN_BIT_SIZE_INTEGERS_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_traits_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000003322611344301501031376 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_traits_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_BASE_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_BASE_2_H #include #ifndef CGAL_REP_CLASS_DEFINED #error no representation class defined #endif // CGAL_REP_CLASS_DEFINED #if defined CGAL_CARTESIAN_H || defined CGAL_SIMPLE_CARTESIAN_H #include #include #include #endif #include #include CGAL_BEGIN_NAMESPACE //*********************************************************************** //*********************************************************************** // PREDICATES //*********************************************************************** //*********************************************************************** //----------------------------------------------------------------------- // orientation //----------------------------------------------------------------------- template< class K > class Svd_orientation_2 { public: typedef typename K::Site_2 Site_2; typedef typename K::Point_2 Point_2; typedef Orientation result_type; typedef Arity_tag<3> Arity; private: typedef typename K::Orientation_2 orientation_2; public: result_type operator()(const Site_2& p, const Site_2& q, const Site_2& r) const { CGAL_precondition( p.is_point() && q.is_point() && r.is_point() ); return svd_orientation_C2( p, q, r ); } }; //----------------------------------------------------------------------- // are same points //----------------------------------------------------------------------- template< class K > class Are_same_points_2 { public: typedef typename K::Site_2 Site_2; typedef typename K::Point_2 Point_2; typedef bool result_type; typedef Arity_tag<2> Arity; public: result_type operator()(const Site_2& p, const Site_2& q) const { CGAL_precondition( p.is_point() && q.is_point() ); return svd_are_same_points_C2(p, q); } }; //----------------------------------------------------------------------- // are parallel //----------------------------------------------------------------------- template< class K > class Are_parallel_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<2> Arity; public: result_type operator()(const Site_2& p, const Site_2& q) const { return svd_are_parallel_C2(p, q); } }; //----------------------------------------------------------------------- // oriented side of bisector //----------------------------------------------------------------------- template class Svd_oriented_side_of_bisector_2 { public: typedef typename K::Site_2 Site_2; typedef Oriented_side result_type; typedef Arity_tag<3> Arity; public: result_type operator()(const Site_2& t1, const Site_2& t2, const Site_2& q) const { return svd_oriented_side_of_bisector_ftC2 (t1, t2, q, Method_tag()); } }; //----------------------------------------------------------------------- // vertex conflict //----------------------------------------------------------------------- template< class K, class Method_tag > class Svd_vertex_conflict_2 { public: typedef typename K::Site_2 Site_2; typedef Sign result_type; struct Arity {}; public: result_type operator()(const Site_2& p, const Site_2& q, const Site_2& t) const { return svd_vertex_conflict_ftC2(p, q, t, Method_tag()); } result_type operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& t) const { return svd_vertex_conflict_ftC2(p, q, r, t, Method_tag()); } }; //----------------------------------------------------------------------- // finite edge interior conflict //----------------------------------------------------------------------- template< class K, class Method_tag > class Svd_finite_edge_interior_conflict_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; struct Arity {}; public: result_type operator()(const Site_2& p, const Site_2& q, const Site_2& t, Sign sgn) const { return svd_finite_edge_conflict_ftC2(p, q, t, sgn, Method_tag()); } result_type operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& t, Sign sgn) const { return svd_finite_edge_conflict_ftC2(p, q, r, t, sgn, Method_tag()); } result_type operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Sign sgn) const { return svd_finite_edge_conflict_ftC2(p, q, r, s, t, sgn, Method_tag()); } }; //----------------------------------------------------------------------- // infinite edge interior conflict //----------------------------------------------------------------------- template< class K, class Method_tag > class Svd_infinite_edge_interior_conflict_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<5> Arity; public: result_type operator()(const Site_2& q, const Site_2& r, const Site_2& s, const Site_2& t, Sign sgn) const { return svd_infinite_edge_conflict_ftC2(q, r, s, t, sgn, Method_tag()); } }; //----------------------------------------------------------------------- // is degenerate edge //----------------------------------------------------------------------- template< class K, class Method_tag > class Svd_is_degenerate_edge_2 { public: typedef typename K::Site_2 Site_2; typedef bool result_type; typedef Arity_tag<4> Arity; public: result_type operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s) const { return svd_is_degenerate_edge_ftC2(p, q, r, s, Method_tag()); } }; //----------------------------------------------------------------------- // do intersect //----------------------------------------------------------------------- template< class K, class Method_tag > class Svd_arrangement_type_2 : public CGALi::Svd_arrangement_enum { public: typedef typename K::Site_2 Site_2; typedef Arrangement_type result_type; typedef Arity_tag<2> Arity; public: result_type operator()(const Site_2& p, const Site_2& q) const { return svd_arrangement_type_C2(p, q, Method_tag()); } }; //----------------------------------------------------------------------- // oriented side //----------------------------------------------------------------------- template< class K, class Method_tag > class Svd_oriented_side_2 { public: typedef typename K::Site_2 Site_2; typedef Oriented_side result_type; struct Arity {}; public: result_type operator()(const Site_2& q, const Site_2& s, const Site_2& p) const { return svd_oriented_side_ftC2(q, s, p, Method_tag()); } result_type operator()(const Site_2& s1, const Site_2& s2, const Site_2& s3, const Site_2& s, const Site_2& p) const { return svd_oriented_side_ftC2(s1, s2, s3, s, p, Method_tag()); } }; //----------------------------------------------------------------------- // the Traits class //----------------------------------------------------------------------- template class Segment_Voronoi_diagram_traits_base_2 { public: //----------------------------------------------------------------------- // TYPE DEFINITIONS //----------------------------------------------------------------------- // BASIC TYPES //------------ typedef Segment_Voronoi_diagram_kernel_wrapper_2 Kernel; typedef Kernel K; typedef R Rep; typedef MTag Method_tag; // the following tag controls how support intersections in the // traits. If it is Tag_true then we fully support intersections. // If it is Tag_true it is assumed that no intersections appear in // the data and so there is limited support for intersections. typedef ITag Intersections_tag; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Line_2 Line_2; typedef typename Kernel::Segment_2 Segment_2; typedef typename Kernel::Ray_2 Ray_2; // typedef typename Kernel::Circle_2 Circle_2; typedef typename Kernel::Site_2 Site_2; typedef typename Kernel::Object_2 Object_2; typedef typename Kernel::FT FT; typedef typename Kernel::RT RT; typedef CGALi::Svd_arrangement_enum::Arrangement_type Arrangement_type; public: // OBJECT CONSTRUCTION & ASSIGNMENT //------------------------------- typedef typename Kernel::Construct_object_2 Construct_object_2; typedef typename Kernel::Assign_2 Assign_2; // CONSTRUCTIONS //-------------- // vertex and Voronoi circle typedef CGAL::Construct_svd_vertex_2 Construct_svd_vertex_2; // typedef CGAL::Construct_svd_circle_2 Construct_svd_circle_2; // PREDICATES //----------- typedef CGAL::Svd_compare_x_2 Compare_x_2; typedef CGAL::Svd_compare_y_2 Compare_y_2; typedef CGAL::Svd_orientation_2 Orientation_2; typedef CGAL::Are_same_points_2 Equal_2; typedef CGAL::Are_parallel_2 Are_parallel_2; typedef CGAL::Svd_oriented_side_of_bisector_2 /* */ Oriented_side_of_bisector_2; typedef CGAL::Svd_vertex_conflict_2 Vertex_conflict_2; typedef CGAL::Svd_finite_edge_interior_conflict_2 /* */ Finite_edge_interior_conflict_2; typedef CGAL::Svd_infinite_edge_interior_conflict_2 /* */ Infinite_edge_interior_conflict_2; typedef CGAL::Svd_is_degenerate_edge_2 Is_degenerate_edge_2; typedef CGAL::Svd_arrangement_type_2 Arrangement_type_2; typedef CGAL::Svd_oriented_side_2 Oriented_side_2; public: //----------------------------------------------------------------------- // ACCESS TO OBJECTS //----------------------------------------------------------------------- // OBJECT CONSTRUCTION & ASSIGNMENT //--------------------------------- Assign_2 assign_2_object() const { return Assign_2(); } Construct_object_2 construct_object_2_object() const { return Construct_object_2(); } // CONSTRUCTIONS //-------------- Construct_svd_vertex_2 construct_svd_vertex_2_object() const { return Construct_svd_vertex_2(); } /* Construct_svd_circle_2 construct_svd_circle_2_object() const { return Construct_svd_circle_2(); } */ // PREDICATES //----------- Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Equal_2 equal_2_object() const { return Equal_2(); } Are_parallel_2 are_parallel_2_object() const { return Are_parallel_2(); } Oriented_side_of_bisector_2 oriented_side_of_bisector_2_object() const { return Oriented_side_of_bisector_2(); } Vertex_conflict_2 vertex_conflict_2_object() const { return Vertex_conflict_2(); } Finite_edge_interior_conflict_2 finite_edge_interior_conflict_2_object() const { return Finite_edge_interior_conflict_2(); } Infinite_edge_interior_conflict_2 infinite_edge_interior_conflict_2_object() const { return Infinite_edge_interior_conflict_2(); } Is_degenerate_edge_2 is_degenerate_edge_2_object() const { return Is_degenerate_edge_2(); } Arrangement_type_2 arrangement_type_2_object() const { return Arrangement_type_2(); } Oriented_side_2 oriented_side_2_object() const { return Oriented_side_2(); } }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_TRAITS_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/in_place_edge_list.h0000644000175000017500000001100411344301500030756 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/in_place_edge_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_IN_PLACE_EDGE_LIST_H #define CGAL_IN_PLACE_EDGE_LIST_H CGAL_BEGIN_NAMESPACE template class In_place_edge_list { private: typedef typename Edge::first_type Face_handle; typedef typename Face_handle::value_type Face; private: Edge _front; unsigned int _size; private: inline void increase_size() { _size++; } inline void decrease_size() { _size--; } public: bool is_valid() const { return true; } inline unsigned int size() const { return _size; } inline void push_first(const Edge& e) { _front = e; set_next(e, e); set_previous(e, e); increase_size(); } inline Edge next(const Edge& e) const { CGAL_precondition( is_in_list(e) ); return e.first->next(e.second); } inline Edge previous(const Edge& e) const { CGAL_precondition( is_in_list(e) ); return e.first->previous(e.second); } inline void set_next(const Edge& e, const Edge& next) { Edge _next(next.first, next.second); e.first->set_next(e.second, _next); } inline void set_previous(const Edge& e, const Edge& prev) { Edge _prev(prev.first, prev.second); e.first->set_previous(e.second, _prev); } inline bool is_first(const Edge& e) const { return ( (e.first == _front.first && e.second == _front.second) ); } public: inline bool is_singleton() const { CGAL_precondition( !is_empty() ); return (size() == 1); } public: In_place_edge_list(const Edge& e = Edge(Face_handle(),-1) ) : _size(0) { _front = e; } inline Edge front() const { CGAL_precondition( !is_empty() ); return _front; } inline Edge back() const { CGAL_precondition( !is_empty() ); return previous(_front); } inline bool is_empty() const { return ( _front.first == Face_handle() ); } inline void pop() { CGAL_precondition( !is_empty() ); remove(front()); // it is important here that I do not pass the // variable _front but rather a copy of it... } inline void push_front(const Edge& e) { CGAL_precondition( !is_in_list(e) ); push(e); _front = e; } inline void push_back(const Edge& e) { push(e); } void push(const Edge& e) { CGAL_precondition( !is_in_list(e) ); if ( is_empty() ) { push_first(e); return; } Edge last_edge = back(); set_next(last_edge, e); set_next(e, _front); set_previous(e, last_edge); set_previous(_front, e); increase_size(); } inline void insert_after(const Edge& e, const Edge& new_e) { CGAL_precondition( is_in_list(e) ); Edge old_front = _front; _front = next(e); push_front(new_e); _front = old_front; } inline void insert_before(const Edge& e, const Edge& new_e) { CGAL_precondition( is_in_list(e) ); Edge old_front = _front; _front = e; push(new_e); _front = old_front; } inline void replace(const Edge& e, const Edge& new_e) { insert_before(e, new_e); remove(e); } void remove(const Edge& e) { CGAL_precondition( is_in_list(e) ); static Edge SENTINEL_QUEUE_EDGE = Edge(Face_handle(), -1); if ( is_singleton() ) { _front = SENTINEL_QUEUE_EDGE; set_next(e, SENTINEL_QUEUE_EDGE); set_previous(e, SENTINEL_QUEUE_EDGE); decrease_size(); return; } Edge _next = next(e); Edge _prev = previous(e); if ( is_first(e) ) { _front = _next; } set_next(e, SENTINEL_QUEUE_EDGE); set_previous(e, SENTINEL_QUEUE_EDGE); set_next(_prev, _next); set_previous(_next, _prev); decrease_size(); } bool is_in_list(const Edge& e) const { return e.first->is_in_list(e.second); } void clear() { while ( !is_empty() ) { pop(); } } }; CGAL_END_NAMESPACE #endif // CGAL_IN_EDGE_PLACE_LIST_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarch0000644000175000017500000003405711344301501031442 0ustar debiandebian// Copyright (c) 1998 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Olivier Devillers // Mariette Yvinec #ifndef CGAL_TRIANGULATION_HIERARCHY_2_H #define CGAL_TRIANGULATION_HIERARCHY_2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE // parameterization of the hierarchy //const float Triangulation_hierarchy_2__ratio = 30.0; const int Triangulation_hierarchy_2__ratio = 30; const int Triangulation_hierarchy_2__minsize = 20; const int Triangulation_hierarchy_2__maxlevel = 5; // maximal number of points is 30^5 = 24 millions ! template < class Tr> class Triangulation_hierarchy_2 : public Tr { public: typedef Tr Tr_Base; typedef typename Tr_Base::Geom_traits Geom_traits; typedef typename Tr_Base::Point Point; typedef typename Tr_Base::size_type size_type; typedef typename Tr_Base::Vertex_handle Vertex_handle; typedef typename Tr_Base::Face_handle Face_handle; typedef typename Tr_Base::Vertex Vertex; typedef typename Tr_Base::Locate_type Locate_type; typedef typename Tr_Base::Finite_vertices_iterator Finite_vertices_iterator; //typedef typename Tr_Base::Finite_faces_iterator Finite_faces_iterator; private: // here is the stack of triangulations which form the hierarchy Tr_Base* hierarchy[Triangulation_hierarchy_2__maxlevel]; Random random; // random generator public: Triangulation_hierarchy_2(const Geom_traits& traits = Geom_traits()); Triangulation_hierarchy_2(const Triangulation_hierarchy_2& tr); Triangulation_hierarchy_2 &operator=(const Triangulation_hierarchy_2& tr); ~Triangulation_hierarchy_2(); //Helping void copy_triangulation(const Triangulation_hierarchy_2 &tr); void swap(Triangulation_hierarchy_2 &tr); void clear(); // CHECKING bool is_valid(bool verbose = false, int level = 0) const; // INSERT REMOVE Vertex_handle insert(const Point &p, Face_handle start = Face_handle() ); Vertex_handle insert(const Point& p, Locate_type lt, Face_handle loc, int li ); Vertex_handle push_back(const Point &p); template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = this->number_of_vertices(); while(first != last){ insert(*first); ++first; } return this->number_of_vertices() - n; } void remove_degree_3(Vertex_handle v); void remove_first(Vertex_handle v); void remove_second(Vertex_handle v); void remove(Vertex_handle v); //LOCATE Face_handle locate(const Point& p, Locate_type& lt, int& li, Face_handle start = Face_handle()) const; Face_handle locate(const Point &p, Face_handle start = Face_handle()) const; private: void locate_in_all(const Point& p, Locate_type& lt, int& li, Face_handle pos[Triangulation_hierarchy_2__maxlevel]) const; int random_level(); // helping function to copy_triangulation // the version to be used with Tag_true is templated to avoid // systematique instanciation template void add_hidden_vertices_into_map(Tag, std::map& V) { for (typename Tr_Base::Hidden_vertices_iterator it=hierarchy[0]->hidden_vertices_begin(); it != hierarchy[0]->hidden_vertices_end(); ++it) { if (it->up() != Vertex_handle()) V[ it->up()->down() ] = it; } } void add_hidden_vertices_into_map(Tag_false , std::map& V) {return;} }; template Triangulation_hierarchy_2:: Triangulation_hierarchy_2(const Geom_traits& traits) : Tr_Base(traits), random((long)0) { hierarchy[0] = this; for(int i=1;i Triangulation_hierarchy_2:: Triangulation_hierarchy_2(const Triangulation_hierarchy_2 &tr) : Tr_Base(), random((long)0) { // create an empty triangulation to be able to delete it ! hierarchy[0] = this; for(int i=1;i Triangulation_hierarchy_2 & Triangulation_hierarchy_2:: operator=(const Triangulation_hierarchy_2 &tr) { copy_triangulation(tr); return *this; } template void Triangulation_hierarchy_2:: copy_triangulation(const Triangulation_hierarchy_2 &tr) { { for(int i=0;icopy_triangulation(*tr.hierarchy[i]); } //up and down have been copied in straightforward way // compute a map at lower level std::map V; { for( Finite_vertices_iterator it=hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) { if (it->up() != Vertex_handle()) V[ it->up()->down() ] = it; } } typename Tr_Base::Weighted_tag tag; add_hidden_vertices_into_map(tag,V); { for(int i=1;ifinite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) { // down pointer goes in original instead in copied triangulation it->set_down(V[it->down()]); // make reverse link it->down()->set_up(it); // I think the next line is unnecessary (my) // make map for next level if (it->up()!= Vertex_handle() ) V[ it->up()->down() ] = it; } } } } /* template */ /* void */ /* Triangulation_hierarchy_2:: */ /* add_hidden_vertices_into_map(Tag_false, */ /* std::map& V) { */ /* return; */ /* } */ /* template */ /* void */ /* Triangulation_hierarchy_2:: */ /* add_hidden_vertices_into_map(Tag_true, */ /* std::map& V) */ /* { */ /* for (typename Tr_Base::Hidden_vertices_iterator */ /* it=hierarchy[0]->hidden_vertices_begin(); */ /* it != hierarchy[0]->hidden_vertices_end(); ++it) { */ /* if (it->up() != Vertex_handle()) V[ it->up()->down() ] = it; */ /* } */ /* } */ template void Triangulation_hierarchy_2:: swap(Triangulation_hierarchy_2 &tr) { Tr_Base* temp; Tr_Base::swap(tr); for(int i= 1; i Triangulation_hierarchy_2:: ~Triangulation_hierarchy_2() { clear(); for(int i= 1; i void Triangulation_hierarchy_2:: clear() { for(int i=0;iclear(); } template bool Triangulation_hierarchy_2:: is_valid(bool verbose, int level) const { bool result = true; int i; Finite_vertices_iterator it; //verify correctness of triangulation at all levels for(i=0;inumber_of_vertices() << std::endl; result = result && hierarchy[i]->is_valid(verbose,level); } //verify that lower level has no down pointers for( it = hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) result = result && ( it->down() == Vertex_handle()); //verify that other levels have down pointer and reciprocal link is fine for(i=1;ifinite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) result = result && ( &*(it->down()->up()) == &*(it) ); //verify that levels have up pointer and reciprocal link is fine for(i=0;ifinite_vertices_begin(); it != hierarchy[i]->finite_vertices_end(); ++it) result = result && ( it->up() == Vertex_handle() || &*it == &*(it->up())->down() ); return result; } template typename Triangulation_hierarchy_2::Vertex_handle Triangulation_hierarchy_2:: insert(const Point &p, Face_handle) { int vertex_level = random_level(); Locate_type lt; int i; // locate using hierarchy Face_handle positions[Triangulation_hierarchy_2__maxlevel]; locate_in_all(p,lt,i,positions); //insert at level 0 Vertex_handle vertex=hierarchy[0]->Tr_Base::insert(p,lt,positions[0],i); Vertex_handle previous=vertex; Vertex_handle first = vertex; int level = 1; while (level <= vertex_level ){ vertex=hierarchy[level]->Tr_Base::insert(p,positions[level]); vertex->set_down(previous);// link with level above previous->set_up(vertex); previous=vertex; level++; } return first; } template typename Triangulation_hierarchy_2::Vertex_handle Triangulation_hierarchy_2:: insert(const Point& p, Locate_type lt, Face_handle loc, int li ) { int vertex_level = random_level(); //insert at level 0 Vertex_handle vertex=hierarchy[0]->Tr_Base::insert(p,lt,loc,li); Vertex_handle previous=vertex; Vertex_handle first = vertex; if (vertex_level > 0) { // locate using hierarchy Locate_type ltt; int lii; Face_handle positions[Triangulation_hierarchy_2__maxlevel]; locate_in_all(p,ltt,lii,positions); //insert in higher levels int level = 1; while (level <= vertex_level ){ vertex=hierarchy[level]->Tr_Base::insert(p,positions[level]); vertex->set_down(previous);// link with level above previous->set_up(vertex); previous=vertex; level++; } } return first; } template inline typename Triangulation_hierarchy_2::Vertex_handle Triangulation_hierarchy_2:: push_back(const Point &p) { return insert(p); } template void Triangulation_hierarchy_2:: remove(Vertex_handle v ) { Vertex_handle u=v->up(); int l = 0 ; while(1){ hierarchy[l++]->remove(v); if (u == Vertex_handle()) break; if(l>Triangulation_hierarchy_2__maxlevel) break; v=u; u=v->up(); } } template inline void Triangulation_hierarchy_2:: remove_degree_3(Vertex_handle v ) { remove(v); } template inline void Triangulation_hierarchy_2:: remove_first(Vertex_handle v ) { remove(v); } template inline void Triangulation_hierarchy_2:: remove_second(Vertex_handle v ) { remove(v); } template typename Triangulation_hierarchy_2::Face_handle Triangulation_hierarchy_2:: locate(const Point& p, Locate_type& lt, int& li, Face_handle) const { Face_handle positions[Triangulation_hierarchy_2__maxlevel]; locate_in_all(p,lt,li,positions); return positions[0]; } template typename Triangulation_hierarchy_2::Face_handle Triangulation_hierarchy_2:: locate(const Point& p, Face_handle ) const { Locate_type lt; int li; return locate(p, lt, li); } template void Triangulation_hierarchy_2:: locate_in_all(const Point& p, Locate_type& lt, int& li, Face_handle pos[Triangulation_hierarchy_2__maxlevel]) const { Face_handle position; Vertex_handle nearest; int level = Triangulation_hierarchy_2__maxlevel; typename Geom_traits::Compare_distance_2 closer = this->geom_traits().compare_distance_2_object(); // find the highest level with enough vertices while (hierarchy[--level]->number_of_vertices() < static_cast (Triangulation_hierarchy_2__minsize )){ if ( ! level) break; // do not go below 0 } for (int i=level+1; i 0) { pos[level]=position=hierarchy[level]->locate(p,position); // locate at that level from "position" // result is stored in "position" for the next level // find the nearest between vertices 0 and 1 if (hierarchy[level]->is_infinite(position->vertex(0))) nearest = position->vertex(1); else if (hierarchy[level]->is_infinite(position->vertex(1))) nearest = position->vertex(0); else if ( closer(p, position->vertex(0)->point(), position->vertex(1)->point()) == SMALLER) nearest = position->vertex(0); else nearest = position->vertex(1); // compare to vertex 2, but only if the triangulation is 2D, because otherwise vertex(2) is NULL if ( (hierarchy[level]->dimension()==2) && (! hierarchy[level]->is_infinite(position->vertex(2)))) if ( closer( p, position->vertex(2)->point(), nearest->point()) == SMALLER ) nearest = position->vertex(2); // go at the same vertex on level below nearest = nearest->down(); position = nearest->face(); // incident face --level; } pos[0]=hierarchy[level]->locate(p,lt,li,position); // at level 0 } template int Triangulation_hierarchy_2:: random_level() { int l = 0; while (1) { if ( random(Triangulation_hierarchy_2__ratio) ) break; ++l; } if (l >= Triangulation_hierarchy_2__maxlevel) l = Triangulation_hierarchy_2__maxlevel -1; return l; } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_HIERARCHY_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_bykat.h0000644000175000017500000000513511344301500026761 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_bykat.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_CH_BYKAT_H #define CGAL_CH_BYKAT_H #include #include CGAL_BEGIN_NAMESPACE // same as |convex_hull_2(first,last,result)|. {\sc traits}: // uses |Traits::Point_2|, |Traits::Less_signed_distance_to_line_2|, // |Traits::Left_turn_2|,, |Traits::Equal_2| and |Traits::Less_xy_2|. template OutputIterator ch_bykat(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits); template inline OutputIterator ch_bykat(InputIterator first, InputIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_bykat( first, last, result, Kernel()); } template OutputIterator ch_bykat_with_threshold(InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits); template inline OutputIterator ch_bykat_with_threshold(InputIterator first, InputIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_bykat_with_threshold( first, last, result, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_BYKAT_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_base_with_info_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_b0000644000175000017500000000371511344301501031470 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_base_with_info_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec, Sylvain Pion #ifndef CGAL_TRIANGULATION_VERTEX_BASE_WITH_INFO_2_H #define CGAL_TRIANGULATION_VERTEX_BASE_WITH_INFO_2_H #include CGAL_BEGIN_NAMESPACE template < typename Info_, typename GT, typename Vb = Triangulation_vertex_base_2 > class Triangulation_vertex_base_with_info_2 : public Vb { Info_ _info; public: typedef typename Vb::Face_handle Face_handle; typedef typename Vb::Point Point; typedef Info_ Info; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Triangulation_vertex_base_with_info_2 Other; }; Triangulation_vertex_base_with_info_2() : Vb() {} Triangulation_vertex_base_with_info_2(const Point & p) : Vb(p) {} Triangulation_vertex_base_with_info_2(const Point & p, Face_handle c) : Vb(p, c) {} Triangulation_vertex_base_with_info_2(Face_handle c) : Vb(c) {} const Info& info() const { return _info; } Info& info() { return _info; } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_VERTEX_BASE_WITH_INFO_2_H ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_optimal_convex_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_optimal_conv0000644000175000017500000005544311344301500031541 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_optimal_convex_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert // =========================================================================== // There is a known bug in this algorithm that causes more than the optimal // number of convex pieces to be reported in cases where there are many // collinear vertices (as in a Hilbert polygon, for example). More precisely, // the problem is known to crop up in this situation: // // 5-----------4 // | | // | 2-----3 // | | // | 1-----0 // | | // | 13-----14 // | | // 6 12--11 // | | // | 9--10 // | | // 7-----8 // // The problem arises because when decomposing the polygon from vertex 1 to 13 // point 2 is (quite correctly) indicated as not visible to point 13. Thus // it is believed an edge is necessary to divide the polygon (1 2 5 6 12 13). // // A hack that partially fixes this problem is implemented as follows: // a vertex r is marked as visible from a point q for the purposes of // the decompose function if p is the other endpoint of the edge containing r // and p is visible from q. // // This causes the problem that decomposition from 8 to 12 indicates that // valid vertices are 8 9 and 12. Diagonal (9 12) is valid, but (8 12) is // also considered to be valid and necessary since 9 is a reflex vertex. // The result is a polygon split with diagonals (2 5) (12 5) (9 12) and // (13 1), which is obviously not optimal. // // To get around this problem, I currently postprocess during the cutting // up of the polygon to remove unneeded diagonals and then // achieve the optimal, but a better solution is surely desired.... // // =========================================================================== #ifndef CGAL_PARTITION_OPTIMAL_CONVEX_H #define CGAL_PARTITION_OPTIMAL_CONVEX_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace CGAL { #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG int partition_opt_cvx_debug_list_count = 0; #endif template int partition_opt_cvx_best_so_far(Partition_opt_cvx_vertex& pivot_vertex, unsigned int extension, Polygon& polygon, const Traits& traits, Partition_opt_cvx_diagonal_list& diag_list) { #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "best(" << pivot_vertex.vertex_num() << "." << partition_opt_cvx_debug_list_count << ", " << extension << ")" << std::endl; #endif Partition_opt_cvx_stack_record best_so_far = pivot_vertex.best_so_far(); while (!pivot_vertex.stack_empty()) { Partition_opt_cvx_stack_record old = pivot_vertex.stack_top(); #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "best(" << pivot_vertex.vertex_num() << "." << partition_opt_cvx_debug_list_count << ", " << extension << ")" << " old = " << old.vertex_num() << ", " << old.value() << std::endl; #endif typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Point_2 Point_2; Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (right_turn(polygon[old.vertex_num()], polygon[pivot_vertex.vertex_num()], polygon[extension])) { #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "best(" << pivot_vertex.vertex_num() << "." << partition_opt_cvx_debug_list_count << ", " << extension << ")" << " returning(a) " << best_so_far.value() << std::endl; #endif diag_list = best_so_far.solution(); return best_so_far.value(); } else if (old.value() < best_so_far.value()) best_so_far = old; #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "best(" << pivot_vertex.vertex_num() << "." << partition_opt_cvx_debug_list_count << ", " << extension << ") " << "popping off " << old.vertex_num() << ", " << old.value() << std::endl; #endif pivot_vertex.stack_pop(); } #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "best(" << pivot_vertex.vertex_num() << "." << partition_opt_cvx_debug_list_count << ", " << extension << ") returning(b) " << best_so_far.value() << std::endl; #endif diag_list = best_so_far.solution(); #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << " diagonal list " << diag_list << std::endl; #endif return best_so_far.value(); } template void partition_opt_cvx_load(int current, ::std::vector< Partition_opt_cvx_vertex >& v_list, Polygon& polygon, Matrix& edges, const Traits& traits) { int previous; int num_polygons; Partition_opt_cvx_diagonal_list diag_list1, diag_list2; #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "load(" << v_list[current].vertex_num() << ")" << std::endl; #endif for (previous = current-1; previous >= 0; previous--) { #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "load: previous = " << v_list[previous].vertex_num() << std::endl; #endif // must look at all valid edges and at all edges that are visible and // have something on the stack. The latter check is necessary to make // sure solutions accumulate properly. if (edges[v_list[previous].vertex_num()] [v_list[current].vertex_num()].is_valid() || (edges[v_list[previous].vertex_num()] [v_list[current].vertex_num()].is_visible() && !v_list[previous].stack_empty())) { num_polygons = partition_opt_cvx_decompose( v_list[previous].vertex_num(), v_list[current].vertex_num(), polygon, edges, traits, diag_list1) + partition_opt_cvx_best_so_far(v_list[previous], v_list[current].vertex_num(), polygon, traits, diag_list2); diag_list1.splice(diag_list1.end(), diag_list2); #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "load: pushing previous = " << v_list[previous].vertex_num() << " num_polygons = " << num_polygons << " on stack " << v_list[current].vertex_num() << "." << partition_opt_cvx_debug_list_count << std::endl; std::cout << " diagonal list = " << diag_list1 << std::endl; #endif v_list[current].stack_push(v_list[previous].vertex_num(), num_polygons, diag_list1); } } } // pre: edge_num1 <= e_num <= edge_num2 but edge_num1 != edge_num2 template bool collinearly_visible(unsigned int edge_num1, unsigned int e_num, unsigned int edge_num2, const Matrix& edges, const Polygon& polygon, const Traits& traits) { typedef typename Polygon::size_type size_type; typedef typename Traits::Orientation_2 Orientation_2; Orientation_2 orientation = traits.orientation_2_object(); if ((e_num == edge_num1+1 || e_num+1 == edge_num2) && edges[edge_num1][edge_num2].is_visible() && orientation(polygon[edge_num1], polygon[e_num], polygon[edge_num2]) == COLLINEAR) return true; else return false; } template int partition_opt_cvx_decompose(unsigned int edge_num1, unsigned int edge_num2, Polygon& polygon, Matrix& edges, const Traits& traits, Partition_opt_cvx_diagonal_list& diag_list) { #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "decompose(" << edge_num1 << ", " << edge_num2 << ")"; #endif if (edges[edge_num1][edge_num2].is_done()) { #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << " returning " << edges[edge_num1][edge_num2].value() << std::endl; #endif diag_list = edges[edge_num1][edge_num2].solution(); return edges[edge_num1][edge_num2].value(); } #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << std::endl; #endif // temporarily invalidate this edge so we don't try to decompose on this // edge again Partition_opt_cvx_edge_validity old_validity; old_validity = edges[edge_num1][edge_num2].validity(); edges[edge_num1][edge_num2].set_valid(PARTITION_OPT_CVX_NOT_VALID); std::vector< Partition_opt_cvx_vertex > v_list; #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG partition_opt_cvx_debug_list_count++; #endif typedef typename Polygon::size_type size_type; for (size_type e_num = edge_num1; e_num <= edge_num2; e_num++) { if (edges[edge_num1][e_num].is_visible() && edges[e_num][edge_num2].is_visible() || collinearly_visible(edge_num1, e_num, edge_num2, edges, polygon, traits) ) { v_list.push_back(Partition_opt_cvx_vertex(e_num)); } } std::vector< int >::size_type v; #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "v_list(" << edge_num1 << ", " << edge_num2 << ")"; for(v = 0; v < v_list.size(); v++) { std::cout << " " << v_list[v].vertex_num(); } std::cout << std::endl; #endif for(v = 0; v < v_list.size(); v++) { partition_opt_cvx_load(int(v), v_list, polygon, edges, traits); } int num_pieces = partition_opt_cvx_best_so_far(v_list[v_list.size()-1], edge_num1, polygon, traits, diag_list) + 1; #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "decompose: num_pieces = " << num_pieces << std::endl; #endif edges[edge_num1][edge_num2].set_value(num_pieces); diag_list.push_back(Partition_opt_cvx_diagonal(edge_num1, edge_num2)); edges[edge_num1][edge_num2].set_value(num_pieces); edges[edge_num1][edge_num2].set_solution(diag_list); edges[edge_num1][edge_num2].set_done(true); edges[edge_num1][edge_num2].set_valid(old_validity); // revalidate the edge; next time it will pick up the computed value // stored with this edge #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "decompose(" << edge_num1 << ", " << edge_num2 << "): " << " edge[" << edge_num1 << "][" << edge_num2 << "] set to " << edges[edge_num1][edge_num2] << std::endl; std::cout << " with diagonal list " << edges[edge_num1][edge_num2].solution() << std::endl; std::cout << "decompose(" << edge_num1 << ", " << edge_num2 << "): returning " << num_pieces << std::endl; partition_opt_cvx_debug_list_count--; #endif return num_pieces; } // // implementation of the naive n^3 visibility algorithm // template bool partition_opt_cvx_is_visible_n3(const Polygon& polygon, unsigned int i, unsigned int j, const Traits& traits) { typedef typename Traits::Segment_2 Segment_2; typedef typename Polygon::size_type size_type; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Construct_segment_2 Construct_segment_2; static Construct_segment_2 construct_segment_2 = traits.construct_segment_2_object(); Segment_2 segment = construct_segment_2(polygon[i], polygon[j]); size_type prev_i = (i == 0)? polygon.size()-1: i - 1; size_type next_i = (i + 1)% polygon.size(); size_type prev_j = (j == 0)? polygon.size()-1: j - 1; // determine if the edge goes through the interior of the polygon or not Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (right_turn(polygon[prev_i], polygon[i], polygon[next_i])) // concave angle { if (right_turn(polygon[prev_i], polygon[i], polygon[j]) && right_turn(polygon[j], polygon[i], polygon[next_i])) return false; } else // left turn or straight if (right_turn(polygon[prev_i], polygon[i], polygon[j]) || right_turn(polygon[j], polygon[i], polygon[next_i])) return false; size_type next_e; for (size_type e = 0; e < polygon.size(); e++) { if (e != i && e != prev_i && e != j && e != prev_j) { next_e = (e == polygon.size()-1)? 0 : e+1; Segment_2 edge = construct_segment_2(polygon[e], polygon[next_e]); if (do_intersect(segment, edge)) return false; } } return true; } // when consecutive sequence of vertices are collinear, they must all be // visible to each other as if there were no vertices in between. template void make_collinear_vertices_visible(Polygon& polygon, Matrix& edges, const Traits& traits) { typedef typename Polygon::size_type size_type; typedef typename Traits::Orientation_2 Orientation_2; Orientation_2 orientation = traits.orientation_2_object(); size_type i; size_type prev_j, j; size_type k, next_k; // start at the beginning, move backwards as long as the points are // collinear; move forward as long as the points are collinear; // when you find the extremes make the larger one visible to the smaller // one loop until you reach the larger one each time starting again at the // larger i = polygon.size() - 1; prev_j = 0; j = 1; int start_i = 0; while (i > 0 && orientation(polygon[i], polygon[prev_j], polygon[j]) == COLLINEAR) { prev_j = i; start_i = i; i--; } i = 0; prev_j = 1; j = 2; while (j < polygon.size() && orientation(polygon[i], polygon[prev_j], polygon[j]) == COLLINEAR) { i++; prev_j++; j++; } // all points between start_i and prev_j are collinear so they must all // be visible to each other for (k = start_i; k != prev_j; ) { next_k = k; do { next_k = (next_k == polygon.size() - 1) ? 0 : next_k+1; // the matrix should be upper triangular. if (k < next_k) edges[k][next_k].set_visible(true); else edges[next_k][k].set_visible(true); } while ( next_k != prev_j ); k = (k == polygon.size() - 1) ? 0 : k+1; } i = prev_j; while (i < polygon.size()) { prev_j = i+1; j = i+2; while (j < polygon.size() && orientation(polygon[i], polygon[prev_j], polygon[j]) == COLLINEAR) { j++; prev_j++; } // the edge from the first collinear vertex to the last has // the same validity as the edge ending at the last collinear vertex if (prev_j < polygon.size()) for (k = i; k != prev_j; k++) { next_k = k; do { next_k++; edges[k][next_k].set_visible(true); } while ( next_k != prev_j ); } i = prev_j; } } template void partition_opt_cvx_preprocessing(Polygon& polygon, Matrix& edges, const Traits& traits) { typedef typename Polygon::size_type size_type; typedef typename Polygon::iterator Vertex_iterator; typedef Vertex_visibility_graph_2 Vis_graph; typedef typename Traits::Point_2 Point_2; typedef std::pair Point_pair; Vis_graph graph(polygon.begin(), polygon.end()); size_type prev_i, i, next_i, next_next_i; size_type prev_j, j, next_j; for (i = 0; i < polygon.size(); i++) { prev_i = (i == 0)?polygon.size()-1:i-1; next_i = (i + 1)% polygon.size(); next_next_i = (next_i + 1)% polygon.size(); edges[i][i].set_visible(true); if (next_i != 0) { // endpoints of edges are visible edges[i][next_i].set_visible(true);// and done (value == 0) edges[i][next_i].set_done(true); // except for the last edge used } edges[i][next_i].set_valid(polygon[prev_i], polygon[i], polygon[next_i], polygon[i], polygon[next_i], polygon[next_next_i], traits); for (j = i + 2 ; j < polygon.size(); j++) { prev_j = j-1; if (graph.is_an_edge(Point_pair(polygon[i], polygon[j]))) { next_j = (j + 1)% polygon.size(); edges[i][j].set_visible(true); edges[i][j].set_valid(polygon[prev_i],polygon[i],polygon[next_i], polygon[prev_j],polygon[j],polygon[next_j], traits); if (j == i+2) { edges[i][j].set_value(1); Partition_opt_cvx_diagonal_list d; d.push_back(Partition_opt_cvx_diagonal(i,j)); edges[i][j].set_solution(d); edges[i][j].set_done(true); } // triangles are a base case. } } } make_collinear_vertices_visible(polygon, edges, traits); } template OutputIterator partition_optimal_convex_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { if (first == beyond) return result; typedef Partitioned_polygon_2< Traits > P_Polygon_2; typedef typename P_Polygon_2::iterator I; typedef typename P_Polygon_2::value_type V; typedef typename P_Polygon_2::size_type S; typedef typename P_Polygon_2::difference_type D; typedef Bidirectional_circulator_from_iterator Circulator; #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) OutputIterator res(result); #else typedef typename Traits::Polygon_2 Polygon_2; Tee_for_output_iterator res(result); #endif // no postconditions P_Polygon_2 polygon(first, beyond); CGAL_partition_precondition( orientation_2(polygon.begin(), polygon.end(), traits) == COUNTERCLOCKWISE); #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "The polygon: " << std::endl; for (S i = 0; i < polygon.size(); i++) std::cout << polygon[i] << " "; std::cout << std::endl; #endif Matrix edges(polygon.size(), polygon.size()); partition_opt_cvx_preprocessing(polygon, edges, traits); #ifdef CGAL_PARTITION_OPTIMAL_CONVEX_DEBUG std::cout << "after preprocessing edges are (done, valid, visible, value): " << std::endl; std::cout << edges << std::endl; #endif Partition_opt_cvx_diagonal_list diag_list; if (polygon.size() > 0) { partition_opt_cvx_decompose(0, polygon.size()-1, polygon, edges, traits, diag_list); diag_list.pop_back(); // the last diagonal added is the edge from last // to first vertex (i.e., it is not a diagonal) Partition_opt_cvx_diagonal_list::const_iterator it; for (it = diag_list.begin(); it != diag_list.end(); it++) { Circulator source(polygon.begin(), polygon.end(), polygon.begin() + (*it).first); Circulator target(polygon.begin(), polygon.end(), polygon.begin() + (*it).second); polygon.insert_diagonal(source, target); } // the 1 is needed here to indicate that unnecessary edges should // be pruned away. These crop up when there are collinear vertices. // See explanation at top of file. polygon.partition(res, 1); CGAL_partition_postcondition( convex_partition_is_valid_2(polygon.begin(), polygon.end(), res.output_so_far_begin(), res.output_so_far_end(), traits) ); } #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions } template inline OutputIterator partition_optimal_convex_2(InputIterator first, InputIterator beyond, OutputIterator result) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return partition_optimal_convex_2(first, beyond, result, Partition_traits_2()); } } #endif // CGAL_PARTITION_OPTIMAL_CONVEX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/number_utils.h0000644000175000017500000000450211344301500027702 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/number_utils.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_NUMBER_UTILS_H #define CGAL_NUMBER_UTILS_H #include #include #include CGAL_BEGIN_NAMESPACE template inline bool is_zero(const NT& x) { return x == 0; } template inline bool is_one(const NT& x) { return x == 1; } template inline bool is_negative(const NT& x) { return x < 0; } template inline bool is_positive(const NT& x) { return 0 < x; } template inline Sign sign(const NT& x) { return (x < 0) ? NEGATIVE : (0 < x) ? POSITIVE : ZERO; } template inline NT abs(const NT& x) { if (x < 0) return -x; return x; } template inline Comparison_result compare(const NT1& n1, const NT2& n2) { return (n1 < n2) ? SMALLER : (n2 < n1) ? LARGER : EQUAL; } template inline NT square( const NT& n) { return n*n; } template inline NT gcd( const NT& n1, const NT& n2) { CGAL_precondition(!CGAL_NTS is_zero(n2)); NT x = CGAL_NTS abs(n1); NT y = CGAL_NTS abs(n2); do { x %= y; if (CGAL_NTS is_zero(x)) return y; y %= x; } while (CGAL_NTS is_positive(y)); return x; } // for min and max see CGAL_END_NAMESPACE #endif // CGAL_NUMBER_UTILS_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_leda_segment_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_leda_segment_trait0000644000175000017500000002615711344301500031414 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_leda_segment_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Eyal Flato // Efi Fogel #ifndef CGAL_ARR_LEDA_SEGMENT_EXACT_TRAITS #define CGAL_ARR_LEDA_SEGMENT_EXACT_TRAITS #include #include #include #include #include // if we use a LEDA version without namespaces we have to define a few macros #if !defined(LEDA_NAMESPACE) #define LEDA_BEGIN_NAMESPACE #define LEDA_END_NAMESPACE #define LEDA_NAMESPACE_NAME #endif CGAL_BEGIN_NAMESPACE #define CGAL_XT_SINGLE_POINT 1 #define CGAL_XT_ORIGINAL_POINT 2 template class Arr_leda_segment_traits_2 : public Pm_segment_traits_2 { public: Arr_leda_segment_traits_2() {} public: typedef Tag_false Has_left_category; typedef Kernel_ Kernel; typedef Pm_segment_traits_2 Base; typedef typename Base::Point_2 Point_2; typedef typename Base::X_monotone_curve_2 X_monotone_curve_2; typedef X_monotone_curve_2 Curve_2; // Obsolete, for backward compatibility typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; public: //! segments are x_monotone bool is_x_monotone(const Curve_2 & cv) {return true;} /*! curve_make_x_monotone() cuts the given curve into x-monotone subcurves * and inserts them to the given output iterator. The order in which they * are inserted defines their order in the hierarchy tree. * While segments are x_monotone, still need to pass them out. * \param cv the input curve * \param o the output iterator * \return the past-the-end iterator */ template OutputIterator curve_make_x_monotone(const Curve_2 & cv, OutputIterator o) const { *o++ = cv; return o; } X_monotone_curve_2 curve_opposite(const X_monotone_curve_2 & cv) const { return cv.reversal(); } void curve_split(const X_monotone_curve_2 & cv, X_monotone_curve_2 & c1, X_monotone_curve_2 & c2, const Point_2 & split_pt) const { //split curve at split point (x coordinate) into c1 and c2 CGAL_precondition(curve_compare_y_at_x(split_pt, cv) == EQUAL); CGAL_precondition(curve_source(cv) != split_pt); CGAL_precondition(curve_target(cv) != split_pt); c1 = X_monotone_curve_2(cv.source(), split_pt); c2 = X_monotone_curve_2(split_pt, cv.target()); } public: bool nearest_intersection_to_right(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt, Point_2 & p1, Point_2 & p2) const { bool res = intersection_base(c1, c2, pt, true, true, p1, p2, dummy_int); if ((res) && (dummy_int & CGAL_XT_SINGLE_POINT)) p2 = p1; return res; // Following implementation was commented out during to the // introduction of intersection_base by Eyal to speed up the traits class. /* X_monotone_curve_2 xcv; bool res = c1.intersection(c2, xcv); if (!res) return false; if (lexicographically_xy_larger(xcv.source(),xcv.target())) xcv=curve_opposite(xcv); if (lexicographically_xy_larger(xcv.target(),pt)) { p2=point_normalize(xcv.target()); if (lexicographically_xy_larger(xcv.source(),pt)) p1=point_normalize(xcv.source()); else p1=pt; return true; } return false; */ } #ifndef CGAL_PMWX_TRAITS_HAVE_INTERSECT_TO_LEFT X_monotone_curve_2 curve_reflect_in_x_and_y(const X_monotone_curve_2 & cv) const { X_monotone_curve_2 reflected_cv(point_reflect_in_x_and_y(cv.source()), point_reflect_in_x_and_y(cv.target())); return reflected_cv; } Point_2 point_reflect_in_x_and_y (const Point_2 & pt) const { Point_2 reflected_pt(-pt.xcoord(), -pt.ycoord()); return reflected_pt; } #else /*! */ bool nearest_intersection_to_left(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt, Point_2 & p1, Point_2 & p2) const { bool res = intersection_base(c1, c2, pt, false, true, p1, p2, dummy_int); if ((res) && (dummy_int & CGAL_XT_SINGLE_POINT)) p2 = p1; return res; /*X_monotone_curve_2 xcv; bool res = c1.intersection(c2, xcv); if (!res) return false; if (compare_xy(xcv.source(),xcv.target()) == SMALLER) xcv=curve_opposite(xcv); if (compare_xy(xcv.target(),pt) == SMALLER) { p2=point_normalize(xcv.target()); if (compare_xy(xcv.source(),pt) == SMALLER) p1=point_normalize(xcv.source()); else p1=pt; return true; } return false;*/ } #endif bool curves_overlap(const X_monotone_curve_2 & ca, const X_monotone_curve_2 & cb) const { X_monotone_curve_2 xcv; // bool res = ca.intersection(cb, xcv); return !(xcv.is_trivial()); } // returns values in p1 and p2 only if return_intersection is true // if (xsect_type | CGAL_XT_SINGLE_POINT) then only p1 is returned bool intersection_base(const X_monotone_curve_2 & c1, const X_monotone_curve_2 & c2, const Point_2 & pt, bool right, bool return_intersection, Point_2 & p1, Point_2 & p2, int & xsect_type) const { const Point_2 & c1_src = c1.source(); const Point_2 & c1_trg = c1.target(); const Point_2 & c2_src = c2.source(); const Point_2 & c2_trg = c2.target(); xsect_type = 0; if (c1.is_trivial()) { if (!c2.contains(c1_src)) return false; if (right) { if (compare_xy(c1_src, pt) == LARGER) { // intersection is c1_src xsect_type = CGAL_XT_SINGLE_POINT | CGAL_XT_ORIGINAL_POINT; if (return_intersection) { p1 = c1_src; //p2 = p1; } return true; } } else { if (compare_xy(c1_src,pt) == SMALLER) { // intersection is c1_src xsect_type = CGAL_XT_SINGLE_POINT | CGAL_XT_ORIGINAL_POINT; if (return_intersection) { p1 = c1_src; //p2 = p1; } return true; } } } if (c2.is_trivial()) { if (!c1.contains(c2_src)) return false; if (right) { if (compare_xy(c2_src, pt) == LARGER) { // intersection is c2_src xsect_type = CGAL_XT_SINGLE_POINT | CGAL_XT_ORIGINAL_POINT; if (return_intersection) { p1 = c2_src; //p2 = p1; } return true; } } else { if (compare_xy(c2_src, pt) == SMALLER) { // intersection is c2_src xsect_type = CGAL_XT_SINGLE_POINT | CGAL_XT_ORIGINAL_POINT; if (return_intersection) { p1 = c2_src; //p2 = p1; } return true; } } } int o1 = CGAL_LEDA_SCOPE::orientation(c1, c2.start()); int o2 = CGAL_LEDA_SCOPE::orientation(c1, c2.end()); if (o1 == 0 && o2 == 0) { int cmp_c1 = (CGAL_LEDA_SCOPE::compare (c1_src, c1_trg) > 0); const Point_2 & sa = (cmp_c1) ? c1_trg : c1_src; const Point_2 & sb = (cmp_c1) ? c1_src : c1_trg; int cmp_c2 = (CGAL_LEDA_SCOPE::compare (c2_src, c2_trg) > 0); const Point_2 & ta = (cmp_c2) ? c2_trg : c2_src; const Point_2 & tb = (cmp_c2) ? c2_src : c2_trg; const Point_2 & a = (CGAL_LEDA_SCOPE::compare(sa, ta) < 0) ? ta : sa; const Point_2 & b = (CGAL_LEDA_SCOPE::compare(sb, tb) < 0) ? sb : tb; if (CGAL_LEDA_SCOPE::compare(a,b) <= 0) { // a is left-low to b if (right) { //intersection (not to the right) is rat_segment(a, b); if (compare_xy(b, pt) == LARGER) { xsect_type = 0; if (return_intersection) { //if (b_right) p2 = point_normalize(b); if (compare_xy(a, pt) == LARGER) p1 = point_normalize(a); else p1 = pt; } return true; } } else { //intersection (not to the right) is rat_segment(a, b); if (compare_xy(a, pt) == SMALLER) { xsect_type = 0; if (return_intersection) { p2 = point_normalize(a); if (compare_xy(b, pt) == SMALLER) p1 = point_normalize(b); else p1 = pt; } return true; } } } return false; } int o3 = CGAL_LEDA_SCOPE::orientation(c2, c1.start()); int o4 = CGAL_LEDA_SCOPE::orientation(c2, c1.end()); if (o1 != o2 && o3 != o4) { leda_integer w = c1.dy() * c2.dx() - c2.dy() * c1.dx(); leda_integer m1 = c1.X2() * c1.Y1() - c1.X1() * c1.Y2(); leda_integer m2 = c2.X2() * c2.Y1() - c2.X1() * c2.Y2(); Point_2 p(m2*c1.dx() - m1*c2.dx(), m2*c1.dy() - m1*c2.dy(), w); if (right) { if (compare_xy(p, pt) == LARGER) { //intersection is rat_segment(p, p); if (return_intersection) { xsect_type = CGAL_XT_SINGLE_POINT; p1 = point_normalize(p); //p2 = p1; } return true; } } else { if (compare_xy(p, pt) == SMALLER) { //intersection is rat_segment(p, p); if (return_intersection) { xsect_type = CGAL_XT_SINGLE_POINT; p1 = point_normalize(p); //p2 = p1; } return true; } } } return false; } private: Point_2 point_normalize(const Point_2 & pt) const { leda_integer g, x, y, w; x = pt.X(); y = pt.Y(); w = pt.W(); if (x.iszero() && y.iszero()) { //g = w; return Point_2(x,y,leda_integer(1)); } else { g = LEDA_NAMESPACE_NAME::gcd(x, y); g = LEDA_NAMESPACE_NAME::gcd(g, w); return Point_2(x/g,y/g,w/g); } } // Dummies mutable Point_2 dummy_pnt1, dummy_pnt2; mutable int dummy_int; }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rational_rotation.h0000644000175000017500000001613411344301500030726 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/rational_rotation.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_RATIONAL_ROTATION_H #define CGAL_RATIONAL_ROTATION_H #include CGAL_BEGIN_NAMESPACE template < class NT > void rational_rotation_approximation( const NT & dirx, // dir.x() const NT & diry, // dir.y() NT & sin_num, // return NT & cos_num, // return NT & denom, // return const NT & eps_num, // quality_bound const NT & eps_den ) { const NT& n = eps_num; const NT& d = eps_den; const NT NT0 = NT(0) ; const NT NT1 = NT(1) ; CGAL_kernel_precondition( n > NT0 ); CGAL_kernel_precondition( d > NT0 ); NT & sin = sin_num; NT & cos = cos_num; NT & den = denom; NT dx = CGAL_NTS abs(dirx); NT dy = CGAL_NTS abs(diry); NT sq_hypotenuse = dx*dx + dy*dy; NT common_part; NT diff_part; NT rhs; bool lower_ok; bool upper_ok; if (dy > dx) { std::swap (dx,dy); } // approximate sin = dy / sqrt(sq_hypotenuse) // if ( dy / sqrt(sq_hypotenuse) < n/d ) if (dy * dy * d * d < sq_hypotenuse * n * n) { cos = NT1; sin = NT0; den = NT1; } else { NT p; NT q; NT p0 = NT0; NT q0 = NT1; NT p1 = NT1; NT q1 = NT1; for(;;) { p = p0 + p1; q = q0 + q1; sin = NT(2)*p*q; den = p*p + q*q; // sanity check for approximation // sin/den < dy/sqrt(hypotenuse) + n/d // && sin/den > dy/sqrt(hypotenuse) - n/d // === sin/den - n/d < dy/sqrt(sq_hypotenuse) // && sin/den + n/d > dy/sqrt(sq_hypotenuse) // === (sin^2 d^2 + n^2 den^2)sq_hypotenuse - 2... < dy^2 d^2 den^2 // && (sin^2 d^2 + n^2 den^2)sq_hypotenuse + 2... > dy^2 d^2 den^2 common_part = (sin*sin*d*d + n*n*den*den)*sq_hypotenuse; diff_part = NT(2)*n*sin*d*den*sq_hypotenuse; rhs = dy*dy*d*d*den*den; upper_ok = (common_part - diff_part < rhs); lower_ok = (common_part + diff_part > rhs); if ( lower_ok && upper_ok ) { // if ( (p*p)%2 + (q*q)%2 > NT1) // { // sin = p*q; // cos = (q*q - p*p)/2; // exact division // den = (p*p + q*q)/2; // exact division // } // else // { cos = q*q - p*p; // } break; } else { // if ( dy/sqrt(sq_hypotenuse) < sin/den ) if ( dy*dy*den*den < sin*sin*sq_hypotenuse ) { p1 = p; q1 = q; } else { p0 = p; q0 = q; } } } // for(;;) } dx = dirx; dy = diry; if (dy > dx ) { std::swap (sin,cos); } if (dx < NT0) { cos = - cos; } if (dy < NT0) { sin = - sin; } sin_num = sin; cos_num = cos; denom = den; } template < class NT > void rational_rotation_approximation( const double& angle, NT & sin_num, // return NT & cos_num, // return NT & denom, // return const NT & eps_num, // quality_bound const NT & eps_den ) { const NT& n = eps_num; const NT& d = eps_den; const NT NT0 = NT(0) ; const NT NT1 = NT(1) ; CGAL_kernel_precondition( n > NT0 ); CGAL_kernel_precondition( d > NT0 ); NT& isin = sin_num; NT& icos = cos_num; NT& iden = denom; double dsin = sin(angle); double dcos = cos(angle); double dn = CGAL::to_double(n); double dd = CGAL::to_double(d); double eps = dn / dd; dsin = CGAL_NTS abs( dsin); dcos = CGAL_NTS abs( dcos); NT common_part; NT diff_part; NT os; bool lower_ok; bool upper_ok; bool swapped = false; if (dsin > dcos) { swapped = true; std::swap (dsin,dcos); } if ( dsin < eps ) { icos = NT1; isin = NT0; iden = NT1; } else { NT p; NT q; NT p0 = NT0; NT q0 = NT1; NT p1 = NT1; NT q1 = NT1; for(;;) { p = p0 + p1; q = q0 + q1; isin = NT(2)*p*q; iden = p*p + q*q; // XXX sanity check for approximation // sin/den < dsin + n/d // && sin/den > dsin - n/d // sin < dsin * den + n/d * den // && sin > dsin * den - n/d * den os = CGAL::to_double(isin); diff_part = eps * CGAL::to_double(iden); common_part = dsin * CGAL::to_double(iden); upper_ok = (common_part - diff_part < os); lower_ok = (os < common_part + diff_part); if ( lower_ok && upper_ok ) { // if ( (p*p)%2 + (q*q)%2 > NT1) // { // isin = p*q; // icos = (q*q - p*p)/2; // exact division // iden = (p*p + q*q)/2; // exact division // } // else // { icos = q*q - p*p; // } break; } else { // XXX if ( dsin < sin/den ) if ( dsin * CGAL::to_double(iden) < CGAL::to_double(isin) ) { p1 = p; q1 = q; } else { p0 = p; q0 = q; } } } // for(;;) } if ( swapped ) { std::swap (isin,icos); } dsin = sin( angle); dcos = cos( angle); if (dcos < 0.0) { icos = - icos; } if (dsin < 0.0) { isin = - isin; } sin_num = isin; cos_num = icos; denom = iden; } CGAL_END_NAMESPACE #endif // CGAL_RATIONAL_ROTATION_H ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_simple_site_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000001564611344301501031404 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_simple_site_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef SEGMENT_VORONOI_DIAGRAM_SIMPLE_SITE_H #define SEGMENT_VORONOI_DIAGRAM_SIMPLE_SITE_H #include #include #include #include CGAL_BEGIN_NAMESPACE /** A Site is either a point or a segment or a point defined as the intersection of two non-parallel segments (if defined) */ template class Segment_Voronoi_diagram_simple_site_2 { public: typedef R_ R; typedef R Rep; typedef typename R::Point_2 Point_2; typedef typename R::Segment_2 Segment_2; protected: typedef typename R::FT FT; typedef typename R::RT RT; typedef Segment_Voronoi_diagram_simple_site_2 Self; // friend class Construct_svd_site_2; // friend std::ostream& operator<<(std::ostream&, const Self&); // friend std::istream& operator>>(std::istream&, Self&); public: static Self construct_site_2(const Point_2& p) { Self t; t.initialize_site(p); return t; // return Self(p); } static Self construct_site_2(const Point_2& p0, const Point_2& p1) { Self t; t.initialize_site(p0, p1); return t; // return Self(p0, p1); } private: static bool no_warning(bool b) { CGAL_assertion( b ); return b; } static void no_constructor_support() { bool THIS_CLASS_DOES_NOT_SUPPORT_THIS_CONSTRUCTOR = false; no_warning( THIS_CLASS_DOES_NOT_SUPPORT_THIS_CONSTRUCTOR ); } public: // these "constructors" are defined in order to conform with the // specs; they will produce a run-time error if used static Self construct_site_2(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2) { no_constructor_support(); return Self(); } static Self construct_site_2(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2, bool b) { no_constructor_support(); return Self(); } static Self construct_site_2(const Point_2& p1, const Point_2& p2, const Point_2& q1, const Point_2& q2, const Point_2& r1, const Point_2& r2) { no_constructor_support(); return Self(); } public: Segment_Voronoi_diagram_simple_site_2() : type_(0) {} public: bool is_defined() const { return type_; } bool is_point() const { return type_ == 1; } bool is_segment() const { return type_ == 2; } bool is_input() const { return true; } bool is_input(unsigned int i) const { return true; } const Point_2& point() const { CGAL_precondition ( is_point() ); return p_[0]; } const Point_2& source_of_supporting_site() const { CGAL_precondition( is_segment() ); return p_[0]; } const Point_2& target_of_supporting_site() const { CGAL_precondition( is_segment() ); return p_[1]; } // the following four methods do not really make any sense but have // been added in order for this class to be a model of the // SegmentVoronoiDiagramSite_2 concept. const Point_2& source_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return p_[0]; } const Point_2& target_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return p_[0]; } const Point_2& source_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return p_[0]; } const Point_2& target_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return p_[0]; } Segment_2 segment() const { CGAL_precondition ( is_segment() ); return Segment_2( p_[0], p_[1] ); } const Point_2& source() const { CGAL_precondition ( is_segment() ); return p_[0]; } const Point_2& target() const { CGAL_precondition ( is_segment() ); return p_[1]; } Self source_site() const { CGAL_precondition( is_segment() ); return Self::construct_site_2(p_[0]); } Self target_site() const { CGAL_precondition( is_segment() ); return Self::construct_site_2(p_[1]); } const Self& supporting_site() const { CGAL_precondition( is_segment() ); return *this; } // the following two methods make no sense, but have been added in // order for this class to be a model of the // SegmentVoronoiDiagramSite_2 concept. Self supporting_site(unsigned int i) const { CGAL_precondition( is_point() && i < 2 ); CGAL_precondition( !is_input() ); return Self::construct_site_2(p_[0], p_[0]); } Self crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && i < 2 ); CGAL_precondition( !is_input(i) ); return *this; } protected: void initialize_site(const Point_2& p) { type_ = 1; p_[0] = p; } void initialize_site(const Point_2& p1, const Point_2& p2) { type_ = 2; p_[0] = p1; p_[1] = p2; } protected: Point_2 p_[2]; char type_; }; //------------------------------------------------------------------------- template std::ostream& operator<<(std::ostream& os, const Segment_Voronoi_diagram_simple_site_2& s) { if (!s.is_defined()) return os << "u"; if (s.is_point()) return os << "p " << s.point (); return os << "s " << s.segment (); } template std::istream & operator>>(std::istream &is, Segment_Voronoi_diagram_simple_site_2& t) { typedef Segment_Voronoi_diagram_simple_site_2 Site_2; typedef typename Site_2::Point_2 Point_2; char type; if (is >> type) { if (type == 'p') { Point_2 p; is >> p; t = Site_2::construct_site_2(p); } else if (type == 's') { Point_2 p1, p2; is >> p1 >> p2; t = Site_2::construct_site_2(p1, p2); } } return is; } template < class R, class Stream > Stream& operator<<(Stream& str, Segment_Voronoi_diagram_simple_site_2& t) { if ( t.is_defined() ) { if ( t.is_point() ) { str << "p " << t.point(); } else { str << "s " << t.segment().source() << " " << t.segment().target(); } } return str; } CGAL_END_NAMESPACE #endif // SEGMENT_VORONOI_DIAGRAM_SIMPLE_SITE_H ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_exact_constructions_kernel.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_exact0000644000175000017500000000353711344301500031406 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Exact_predicates_exact_constructions_kernel.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas, Sylvain Pion #ifndef CGAL_EXACT_PREDICATES_EXACT_CONSTRUCTIONS_KERNEL_H #define CGAL_EXACT_PREDICATES_EXACT_CONSTRUCTIONS_KERNEL_H #include #include #include #ifdef CGAL_USE_GMP # include #else # include # include #endif CGAL_BEGIN_NAMESPACE #ifdef CGAL_USE_GMP typedef Filtered_kernel > > Exact_predicates_exact_constructions_kernel; #else typedef Filtered_kernel > > > Exact_predicates_exact_constructions_kernel; #endif CGAL_END_NAMESPACE #endif // CGAL_EXACT_PREDICATES_EXACT_CONSTRUCTIONS_KERNEL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Straight_2_stream.h0000644000175000017500000001032611344301501030555 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Straight_2_stream.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Oren Nechushtan #ifndef CGAL_STRAIGHT_2_STREAM_H #define CGAL_STRAIGHT_2_STREAM_H CGAL_BEGIN_NAMESPACE #ifndef CGAL_NO_OSTREAM_INSERT_STRAIGHT_2 template std::ostream& operator<<(std::ostream& os,const Straight_2_& cv) { typedef Pm_straight_exact_traits Traits; typedef Straight_2_ Curve; switch(cv.current_state()) { case Curve::SEGMENT: { Segment_2 seg; cv.current(seg); return os << seg; } case Curve::RAY: { Ray_2 ray; cv.current(ray); return os << ray; } case Curve::LINE: { Line_2 line; cv.current(line); return os << line; } case Curve::POINT: { Point_2 p; cv.current(p); return os << p; } case Curve::EMPTY: break; } CGAL_assertion_msg( cv.current_state()==Curve::SEGMENT|| cv.current_state()==Curve::RAY|| cv.current_state()==Curve::LINE|| cv.current_state()==Curve::POINT|| cv.current_state()==Curve::EMPTY, "\nUnknown type in std:: ostream& operator<<( \ std:: ostream& os,const Straight_2&)"); return os; } #endif //CGAL_NO_OSTREAM_INSERT_STRAIGHT_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_STRAIGHT_2 template std:: istream& operator>>(std:: istream& is,Straight_2_& cv) { typedef Pm_straight_exact_traits Traits; typedef Straight_2_ Curve; switch(cv.current_state()) { case Curve::SEGMENT: { Segment_2 seg; cv.current(seg); return os >> seg; } case Curve::RAY: { Ray_2 ray; cv.current(ray); return os >> ray; } case Curve::LINE: { Line_2 line; cv.current(line); return os >> line; } case Curve::POINT: { Point_2 p; cv.current(p); return os >> p; } case Curve::EMPTY: break; } CGAL_assertion_msg( cv.current_state()==Curve::SEGMENT|| cv.current_state()==Curve::RAY|| cv.current_state()==Curve::LINE|| cv.current_state()==Curve::POINT|| cv.current_state()==Curve::EMPTY, "\nUnknown type in std:: ostream& operator>>( \ std:: ostream& os,Straight_2&)"); return os; } #endif //CGAL_NO_ISTREAM_EXTRACT_STRAIGHT_2 CGAL_END_NAMESPACE #endif // CGAL_STRAIGHT_2_STREAM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Interval_arithmetic.h0000644000175000017500000004767011344301500031204 0ustar debiandebian// Copyright (c) 1998-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Interval_arithmetic.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_INTERVAL_ARITHMETIC_H #define CGAL_INTERVAL_ARITHMETIC_H // This file contains the description of the following classes: // - Interval_nt It's a number type that needs the FPU rounding mode // to be set to +inf. It is also typedef'd to // Interval_nt_advanced for backward compatibility. // - Interval_nt Same but it does the rounding mode itself so you // don't have to worry about it. But it's slower. // // Note: When rounding is towards +infinity, to make an operation rounded // towards -infinity, it's enough to take the opposite of some of the operand, // and the opposite of the result (see operator+, operator*,...). #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { struct Unsafe_comparison {}; // Exception class. } template class Interval_nt { typedef Interval_nt IA; typedef std::pair Pair; public: typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; // ??? MK: We may have to look back at these... typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; typedef CGALi::Unsafe_comparison unsafe_comparison; static unsigned number_of_failures; // Number of filter failures. Interval_nt() {} Interval_nt(int i) : _inf(i), _sup(i) {} Interval_nt(double d) : _inf(d), _sup(d) {} Interval_nt(double i, double s) : _inf(i), _sup(s) { // VC++ should use instead : (i<=s) || !is_valid(i) || !is_valid(s) // Or should I use is_valid() ? or is_valid_or_nan() ? CGAL_assertion_msg(!(i>s), " Variable used before being initialized (or CGAL bug)"); } // This copy ctor, normally equivalent to the one created by the compiler, // appears to fix a code generation problem with GCC 3.0.4... // (see test/IA/gcc_3.0.bug.C). Interval_nt(const Interval_nt & i) : _inf(i._inf), _sup(i._sup) {} Interval_nt(const Pair & p) : _inf(p.first), _sup(p.second) {} IA operator-() const { return IA (-sup(), -inf()); } IA & operator+= (const IA &d) { return *this = *this + d; } IA & operator-= (const IA &d) { return *this = *this - d; } IA & operator*= (const IA &d) { return *this = *this * d; } IA & operator/= (const IA &d) { return *this = *this / d; } static void overlap_action() // throw (unsafe_comparison) { number_of_failures++; throw unsafe_comparison(); } // TODO : Maybe I should suppress these : they are useless and risky. // The (join, union, ||) operator. IA operator|| (const IA & d) const { return IA(std::min(inf(), d.inf()), std::max(sup(), d.sup())); } // The (meet, intersection, &&) operator. Valid if intervals overlap. IA operator&& (const IA & d) const { return IA(std::max(inf(), d.inf()), std::min(sup(), d.sup())); } bool is_point() const { return sup() == inf(); } bool is_same (const IA & d) const { return inf() == d.inf() && sup() == d.sup(); } bool do_overlap (const IA & d) const { return !(d.inf() > sup() || d.sup() < inf()); } const double & inf() const { return _inf; } const double & sup() const { return _sup; } std::pair pair() const { return std::pair(_inf, _sup); } static IA largest() { return IA(-CGALi::infinity, CGALi::infinity); } static IA smallest() { return IA(-CGAL_IA_MIN_DOUBLE, CGAL_IA_MIN_DOUBLE); } private: // Pair inf_sup; double _inf, _sup; }; template unsigned Interval_nt::number_of_failures; template inline bool operator<(const Interval_nt &a, const Interval_nt &b) { if (a.sup() < b.inf()) return true; if (a.inf() >= b.sup()) return false; a.overlap_action(); return false; } template inline bool operator>(const Interval_nt &a, const Interval_nt &b) { return b < a; } template inline bool operator<=(const Interval_nt &a, const Interval_nt &b) { if (a.sup() <= b.inf()) return true; if (a.inf() > b.sup()) return false; a.overlap_action(); return false; } template inline bool operator>=(const Interval_nt &a, const Interval_nt &b) { return b <= a; } template inline bool operator==(const Interval_nt &a, const Interval_nt &b) { if (b.inf() > a.sup() || b.sup() < a.inf()) return false; if (b.inf() == a.sup() && b.sup() == a.inf()) return true; a.overlap_action(); return false; } template inline bool operator!=(const Interval_nt &a, const Interval_nt &b) { return ! (a == b); } // Mixed operators. template inline bool operator<(int a, const Interval_nt &b) { if (a < b.inf()) return true; if (a >= b.sup()) return false; b.overlap_action(); return false; } template inline bool operator>(int a, const Interval_nt &b) { return b < a; } template inline bool operator<=(int a, const Interval_nt &b) { if (a <= b.inf()) return true; if (a > b.sup()) return false; b.overlap_action(); return false; } template inline bool operator>=(int a, const Interval_nt &b) { return b <= a; } template inline bool operator==(int a, const Interval_nt &b) { if (b.inf() > a || b.sup() < a) return false; if (b.inf() == a && b.sup() == a) return true; b.overlap_action(); return false; } template inline bool operator!=(int a, const Interval_nt &b) { return ! (a == b); } template inline bool operator<(const Interval_nt &a, int b) { if (a.sup() < b) return true; if (a.inf() >= b) return false; a.overlap_action(); return false; } template inline bool operator>(const Interval_nt &a, int b) { return b < a; } template inline bool operator<=(const Interval_nt &a, int b) { if (a.sup() <= b) return true; if (a.inf() > b) return false; a.overlap_action(); return false; } template inline bool operator>=(const Interval_nt &a, int b) { return b <= a; } template inline bool operator==(const Interval_nt &a, int b) { if (b > a.sup() || b < a.inf()) return false; if (b == a.sup() && b == a.inf()) return true; a.overlap_action(); return false; } template inline bool operator!=(const Interval_nt &a, int b) { return ! (a == b); } template inline double to_double (const Interval_nt & d) { return (d.sup() + d.inf()) * 0.5; // This may overflow... } template inline std::pair to_interval (const Interval_nt & d) { return d.pair(); } template inline bool is_valid (const Interval_nt & d) { return CGAL::is_valid(d.inf()) && CGAL::is_valid(d.sup()) && d.inf() <= d.sup(); } template inline bool is_finite (const Interval_nt & d) { return CGAL::is_finite(d.inf()) && CGAL::is_finite(d.sup()); } template inline io_Operator io_tag (const Interval_nt &) { return io_Operator(); } template std::ostream & operator<< (std::ostream &os, const Interval_nt & I ) { return os << "[" << I.inf() << ";" << I.sup() << "]"; } template std::istream & operator>> (std::istream &is, Interval_nt & I) { double d; is >> d; I = d; return is; } typedef Interval_nt Interval_nt_advanced; // for back-compatibility template inline Interval_nt operator+ (const Interval_nt &a, const Interval_nt & b) { Protect_FPU_rounding P; return Interval_nt (-CGAL_IA_SUB(-a.inf(), b.inf()), CGAL_IA_ADD(a.sup(), b.sup())); } template inline Interval_nt operator+ (double a, const Interval_nt & b) { return Interval_nt(a)+b; } template inline Interval_nt operator+ (const Interval_nt & a, double b) { return a+Interval_nt(b); } template inline Interval_nt operator+ (int a, const Interval_nt & b) { return Interval_nt(a)+b; } template inline Interval_nt operator+ (const Interval_nt & a, int b) { return a+Interval_nt(b); } template inline Interval_nt operator- (const Interval_nt &a, const Interval_nt & b) { Protect_FPU_rounding P; return Interval_nt(-CGAL_IA_SUB(b.sup(), a.inf()), CGAL_IA_SUB(a.sup(), b.inf())); } template inline Interval_nt operator- (double a, const Interval_nt & b) { return Interval_nt(a)-b; } template inline Interval_nt operator- (const Interval_nt & a, double b) { return a-Interval_nt(b); } template inline Interval_nt operator- (int a, const Interval_nt & b) { return Interval_nt(a)-b; } template inline Interval_nt operator- (const Interval_nt & a, int b) { return a-Interval_nt(b); } template inline Interval_nt operator* (const Interval_nt &a, const Interval_nt & b) { typedef Interval_nt IA; Protect_FPU_rounding P; if (a.inf() >= 0.0) // e>=0 { // b>=0 [a.inf()*b.inf(); a.sup()*b.sup()] // b<=0 [a.sup()*b.inf(); a.inf()*b.sup()] // b~=0 [a.sup()*b.inf(); a.sup()*b.sup()] double aa = a.inf(), bb = a.sup(); if (b.inf() < 0.0) { aa = bb; if (b.sup() < 0.0) bb = a.inf(); } return IA(-CGAL_IA_MUL(aa, -b.inf()), CGAL_IA_MUL(bb, b.sup())); } else if (a.sup()<=0.0) // e<=0 { // b>=0 [a.inf()*b.sup(); a.sup()*b.inf()] // b<=0 [a.sup()*b.sup(); a.inf()*b.inf()] // b~=0 [a.inf()*b.sup(); a.inf()*b.inf()] double aa = a.sup(), bb = a.inf(); if (b.inf() < 0.0) { aa=bb; if (b.sup() < 0.0) bb=a.sup(); } return IA(-CGAL_IA_MUL(bb, -b.sup()), CGAL_IA_MUL(aa, b.inf())); } else // 0 \in [inf();sup()] { if (b.inf()>=0.0) // d>=0 return IA(-CGAL_IA_MUL(-a.inf(), b.sup()), CGAL_IA_MUL(a.sup(), b.sup())); if (b.sup()<=0.0) // d<=0 return IA(-CGAL_IA_MUL(a.sup(), -b.inf()), CGAL_IA_MUL(a.inf(), b.inf())); // 0 \in d double tmp1 = CGAL_IA_MUL(-a.inf(), b.sup()); double tmp2 = CGAL_IA_MUL( a.sup(), -b.inf()); double tmp3 = CGAL_IA_MUL( a.inf(), b.inf()); double tmp4 = CGAL_IA_MUL( a.sup(), b.sup()); return IA(-std::max(tmp1,tmp2), std::max(tmp3,tmp4)); } } template inline Interval_nt operator* (double a, const Interval_nt & b) { return Interval_nt(a)*b; } template inline Interval_nt operator* (const Interval_nt & a, double b) { return a*Interval_nt(b); } template inline Interval_nt operator* (int a, const Interval_nt & b) { return Interval_nt(a)*b; } template inline Interval_nt operator* (const Interval_nt & a, int b) { return a*Interval_nt(b); } template inline Interval_nt operator/ (const Interval_nt &a, const Interval_nt & b) { typedef Interval_nt IA; Protect_FPU_rounding P; if (b.inf() > 0.0) // b>0 { // e>=0 [a.inf()/b.sup(); a.sup()/b.inf()] // e<=0 [a.inf()/b.inf(); a.sup()/b.sup()] // e~=0 [a.inf()/b.inf(); a.sup()/b.inf()] double aa = b.sup(), bb = b.inf(); if (a.inf() < 0.0) { aa = bb; if (a.sup() < 0.0) bb = b.sup(); }; return IA(-CGAL_IA_DIV(-a.inf(), aa), CGAL_IA_DIV(a.sup(), bb)); } else if (b.sup()<0.0) // b<0 { // e>=0 [a.sup()/b.sup(); a.inf()/b.inf()] // e<=0 [a.sup()/b.inf(); a.inf()/b.sup()] // e~=0 [a.sup()/b.sup(); a.inf()/b.sup()] double aa = b.sup(), bb = b.inf(); if (a.inf() < 0.0) { bb = aa; if (a.sup() < 0.0) aa = b.inf(); }; return IA(-CGAL_IA_DIV(-a.sup(), aa), CGAL_IA_DIV(a.inf(), bb)); } else // b~0 return IA::largest(); // We could do slightly better -> [0;infinity] when b.sup()==0, // but is this worth ? } template inline Interval_nt operator/ (double a, const Interval_nt & b) { return Interval_nt(a)/b; } template inline Interval_nt operator/ (const Interval_nt & a, double b) { return a/Interval_nt(b); } template inline Interval_nt operator/ (int a, const Interval_nt & b) { return Interval_nt(a)/b; } template inline Interval_nt operator/ (const Interval_nt & a, int b) { return a/Interval_nt(b); } template inline Interval_nt sqrt (const Interval_nt & d) { Protect_FPU_rounding P; // not optimal here. // sqrt([+a,+b]) => [sqrt(+a);sqrt(+b)] // sqrt([-a,+b]) => [0;sqrt(+b)] => assumes roundoff error. // sqrt([-a,-b]) => [0;sqrt(-b)] => assumes user bug (unspecified result). FPU_set_cw(CGAL_FE_DOWNWARD); double i = (d.inf() > 0.0) ? CGAL_IA_SQRT(d.inf()) : 0.0; FPU_set_cw(CGAL_FE_UPWARD); return Interval_nt(i, CGAL_IA_SQRT(d.sup())); } template inline Interval_nt min (const Interval_nt & d, const Interval_nt & e) { return Interval_nt(std::min(d.inf(), e.inf()), std::min(d.sup(), e.sup())); } template inline Interval_nt max (const Interval_nt & d, const Interval_nt & e) { return Interval_nt(std::max(d.inf(), e.inf()), std::max(d.sup(), e.sup())); } template inline Interval_nt square (const Interval_nt & d) { Protect_FPU_rounding P; if (d.inf()>=0.0) return Interval_nt(-CGAL_IA_MUL(d.inf(), -d.inf()), CGAL_IA_MUL(d.sup(), d.sup())); if (d.sup()<=0.0) return Interval_nt(-CGAL_IA_MUL(d.sup(), -d.sup()), CGAL_IA_MUL(d.inf(), d.inf())); return Interval_nt(0.0, CGAL_IA_SQUARE(std::max(-d.inf(), d.sup()))); } template inline Interval_nt abs (const Interval_nt & d) { if (d.inf() >= 0.0) return d; if (d.sup() <= 0.0) return -d; return Interval_nt(0.0, std::max(-d.inf(), d.sup())); } template inline Sign sign (const Interval_nt & d) { if (d.inf() > 0.0) return POSITIVE; if (d.sup() < 0.0) return NEGATIVE; if (d.inf() == d.sup()) return ZERO; Interval_nt::overlap_action(); return ZERO; } template inline Comparison_result compare (const Interval_nt & d, const Interval_nt & e) { if (d.inf() > e.sup()) return LARGER; if (e.inf() > d.sup()) return SMALLER; if (e.inf() == d.sup() && d.inf() == e.sup()) return EQUAL; Interval_nt::overlap_action(); return EQUAL; } inline std::pair to_interval (const long & l) { #ifndef __BORLANDC__ // The stupid Borland compiler generates warnings... if (sizeof(double) > sizeof(long)) { // On 64bit platforms, a long doesn't fit exactly in a double. // Well, a perfect fix would be to use std::numeric_limits<>, but... Protect_FPU_rounding P(CGAL_FE_TONEAREST); Interval_nt approx ((double) l); FPU_set_cw(CGAL_FE_UPWARD); approx += Interval_nt::smallest(); return approx.pair(); } else #endif return std::pair(l,l); } namespace Certified { // The following functions are similar to their CGAL:: counterparts, except // that they notify the non-guaranteed case by the return value, instead of // by throwing an exception which can be costly. // They return a pair, where the second member is true if the // comparison is guaranteed, and false otherwise. template inline std::pair operator<(const Interval_nt &a, const Interval_nt &b) { if (a.sup() < b.inf()) return std::make_pair(true, true); if (a.inf() >= b.sup()) return std::make_pair(false, true); return std::make_pair(false, false); } template inline std::pair operator<(int a, const Interval_nt &b) { if (a < b.inf()) return std::make_pair(true, true); if (a >= b.sup()) return std::make_pair(false, true); return std::make_pair(false, false); } template inline std::pair operator<(const Interval_nt &a, int b) { if (a.sup() < b) return std::make_pair(true, true); if (a.inf() >= b) return std::make_pair(false, true); return std::make_pair(false, false); } template inline std::pair operator==(const Interval_nt &a, const Interval_nt &b) { if (b.inf() > a.sup() || b.sup() < a.inf()) return std::make_pair(false, true); if (b.inf() == a.sup() && b.sup() == a.inf()) return std::make_pair(true, true); return std::make_pair(false, false); } template inline std::pair operator==(int a, const Interval_nt &b) { if (b.inf() > a || b.sup() < a) return std::make_pair(false, true); if (b.inf() == a && b.sup() == a) return std::make_pair(true, true); return std::make_pair(false, false); } template inline std::pair sign (const Interval_nt & d) { if (d.inf() > 0.0) return std::make_pair(POSITIVE, true); if (d.sup() < 0.0) return std::make_pair(NEGATIVE, true); if (d.inf() == d.sup()) return std::make_pair(ZERO, true); return std::make_pair(ZERO, false); } template inline std::pair compare (const Interval_nt & d, const Interval_nt & e) { if (d.inf() > e.sup()) return std::make_pair(LARGER, true); if (e.inf() > d.sup()) return std::make_pair(SMALLER, true); if (e.inf() == d.sup() && d.inf() == e.sup()) return std::make_pair(EQUAL, true); return std::make_pair(EQUAL, false); } } // namespace Certified CGAL_END_NAMESPACE #endif // CGAL_INTERVAL_ARITHMETIC_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_algorithms.C0000644000175000017500000003400411344301500031226 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Polygon_2_algorithms.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Wieger Wesselink #include "CGAL/Polygon_2_algorithms.h" #include "CGAL/Polygon_2_simplicity.h" #include #include #include #include #include CGAL_BEGIN_NAMESPACE //-----------------------------------------------------------------------// // is_simple_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_xy_2 // PolygonTraits::less_xy_2 // PolygonTraits::Orientation_2 // PolygonTraits::orientation_2 // PolygonTraits::Point_2 template bool is_simple_2(ForwardIterator first, ForwardIterator last, const PolygonTraits& traits) { return is_simple_polygon(first, last, traits); } //-----------------------------------------------------------------------// // left_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_xy_2 and less_xy_2_object() template ForwardIterator left_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits&traits) { CGAL_polygon_precondition(first != last); return std::min_element(first, last, traits.less_xy_2_object()); } //-----------------------------------------------------------------------// // right_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_xy_2 and less_xy_2_object() template ForwardIterator right_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits &traits) { CGAL_polygon_precondition(first != last); return std::max_element(first, last, traits.less_xy_2_object()); } //-----------------------------------------------------------------------// // top_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_yx_2 and less_yx_2_object() template ForwardIterator top_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits&traits) { CGAL_polygon_precondition(first != last); return std::max_element(first, last, traits.less_yx_2_object()); } //-----------------------------------------------------------------------// // bottom_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_yx_2 and less_yx_2_object() template ForwardIterator bottom_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits&traits) { CGAL_polygon_precondition(first != last); return std::min_element(first, last, traits.less_yx_2_object()); } //-----------------------------------------------------------------------// // bbox_2 //-----------------------------------------------------------------------// template Bbox_2 bbox_2(InputIterator first, InputIterator last, const PolygonTraits& traits) { typename PolygonTraits::Construct_bbox_2 construct_bbox = traits.construct_bbox_2_object(); CGAL_polygon_precondition(first != last); Bbox_2 result = construct_bbox(*first); while (++first != last) result = result + construct_bbox(*first); return result; } //-----------------------------------------------------------------------// // area_2 //-----------------------------------------------------------------------// // uses Traits:: // implemented in header file //-----------------------------------------------------------------------// // is_convex_2 //-----------------------------------------------------------------------// // uses Traits::Less_xy_2 and less_xy_2_object() // Traits::Orientation_2 and orientation_2_object() template bool is_convex_2(ForwardIterator first, ForwardIterator last, const Traits& traits) { ForwardIterator previous = first; if (previous == last) return true; ForwardIterator current = previous; ++current; if (current == last) return true; ForwardIterator next = current; ++next; if (next == last) return true; typename Traits::Less_xy_2 less_xy_2 = traits.less_xy_2_object(); typename Traits::Orientation_2 orientation = traits.orientation_2_object(); // initialization bool HasClockwiseTriples = false; bool HasCounterClockwiseTriples = false; bool Order = less_xy_2(*previous, *current); int NumOrderChanges = 0; do { switch (orientation(*previous, *current, *next)) { case CLOCKWISE: HasClockwiseTriples = true; break; case COUNTERCLOCKWISE: HasCounterClockwiseTriples = true; break; default: ; } bool NewOrder = less_xy_2(*current, *next); if (Order != NewOrder) NumOrderChanges++; if (NumOrderChanges > 2) { #ifdef CGAL_POLYGON_DEBUG std::cout << "too many order changes: not convex!" << std::endl; #endif return false; } if (HasClockwiseTriples && HasCounterClockwiseTriples) { #ifdef CGAL_POLYGON_DEBUG std::cout << "polygon not locally convex!" << std::endl; #endif return false; } previous = current; current = next; ++next; if (next == last) next = first; Order = NewOrder; } while (previous != first); return true; } //-----------------------------------------------------------------------// // oriented_side_2 //-----------------------------------------------------------------------// // uses Traits::Less_xy_2 // Traits::Compare_x_2 compare_x_2_object() // Traits::Compare_y_2 compare_y_2_object() // Traits::Orientation_2 and orientation_2_object() template Oriented_side oriented_side_2(ForwardIterator first, ForwardIterator last, const Point& point, const Traits& traits) { Orientation o = orientation_2(first, last, traits); CGAL_polygon_assertion(o != COLLINEAR); Bounded_side b = bounded_side_2(first, last, point, traits); switch (b) { case ON_BOUNDARY: return ON_ORIENTED_BOUNDARY; case ON_BOUNDED_SIDE: return (o == CLOCKWISE) ? ON_NEGATIVE_SIDE : ON_POSITIVE_SIDE; default: //case ON_UNBOUNDED_SIDE: return (o == CLOCKWISE) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } } //-----------------------------------------------------------------------// // bounded_side_2 //-----------------------------------------------------------------------// // uses Traits::Compare_x_2 compare_x_2_object() // Traits::Compare_y_2 compare_y_2_object() // Traits::Orientation_2 and orientation_2_object() // // returns ON_BOUNDED_SIDE, ON_BOUNDARY or ON_UNBOUNDED_SIDE /* Implementation: we shoot a horizontal ray from the point to the right and count the number of intersections with polygon segments. If the number of intersections is odd, the point is inside. We don't count intersections with horizontal segments. With non-horizontal segments, the top vertex is considered to be part of the segment, but the bottom vertex is not. (Segments are half-closed). */ namespace i_polygon { template int which_side_in_slab(Point const &point, Point const &low, Point const &high, Orientation_2 &orientation_2, CompareX_2 &compare_x_2) // returns -1 if point is left of segment , 0 if its on the segment // and 1 if it is to the right // precondition: low.y < point.y < high.y { // first we try to decide on x coordinate values alone // This is an optimisation (whether this is really faster for // a homogeneous kernel is not clear, as comparisons can be expensive. Comparison_result low_x_comp_res = compare_x_2(point, low); Comparison_result high_x_comp_res = compare_x_2(point, high); if (low_x_comp_res == SMALLER) { if (high_x_comp_res == SMALLER) return -1; } else { switch (high_x_comp_res) { case LARGER: return 1; case SMALLER: break; case EQUAL: return (low_x_comp_res == EQUAL) ? 0 : 1; } } switch (orientation_2(low, point, high)) { case LEFT_TURN: return 1; case RIGHT_TURN: return -1; default: return 0; } } } // end namespace i_polygon template Bounded_side bounded_side_2(ForwardIterator first, ForwardIterator last, const Point& point, const Traits& traits) { ForwardIterator current = first; if (current == last) return ON_UNBOUNDED_SIDE; ForwardIterator next = current; ++next; if (next == last) return ON_UNBOUNDED_SIDE; typename Traits::Compare_x_2 compare_x_2 = traits.compare_x_2_object(); typename Traits::Compare_y_2 compare_y_2 = traits.compare_y_2_object(); typename Traits::Orientation_2 orientation_2 = traits.orientation_2_object(); bool IsInside = false; Comparison_result cur_y_comp_res = compare_y_2(*current, point); do // check if the segment (current,next) intersects // the ray { (t,point.y()) | t >= point.x() } { Comparison_result next_y_comp_res = compare_y_2(*next, point); switch (cur_y_comp_res) { case SMALLER: switch (next_y_comp_res) { case SMALLER: break; case EQUAL: switch (compare_x_2(point, *next)) { case SMALLER: IsInside = !IsInside; break; case EQUAL: return ON_BOUNDARY; case LARGER: break; } break; case LARGER: switch (i_polygon::which_side_in_slab(point, *current, *next, orientation_2, compare_x_2)) { case -1: IsInside = !IsInside; break; case 0: return ON_BOUNDARY; } break; } break; case EQUAL: switch (next_y_comp_res) { case SMALLER: switch (compare_x_2(point, *current)) { case SMALLER: IsInside = !IsInside; break; case EQUAL: return ON_BOUNDARY; case LARGER: break; } break; case EQUAL: switch (compare_x_2(point, *current)) { case SMALLER: if (compare_x_2(point, *next) != SMALLER) return ON_BOUNDARY; break; case EQUAL: return ON_BOUNDARY; case LARGER: if (compare_x_2(point, *next) != LARGER) return ON_BOUNDARY; break; } break; case LARGER: if (compare_x_2(point, *current) == EQUAL) { return ON_BOUNDARY; } break; } break; case LARGER: switch (next_y_comp_res) { case SMALLER: switch (i_polygon::which_side_in_slab(point, *next, *current, orientation_2, compare_x_2)) { case -1: IsInside = !IsInside; break; case 0: return ON_BOUNDARY; } break; case EQUAL: if (compare_x_2(point, *next) == EQUAL) { return ON_BOUNDARY; } break; case LARGER: break; } break; } current = next; cur_y_comp_res = next_y_comp_res; ++next; if (next == last) next = first; } while (current != first); return IsInside ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } //-----------------------------------------------------------------------// // orientation_2 //-----------------------------------------------------------------------// // uses Traits::Less_xy_2 (used by left_vertex_2) // Traits::orientation_2_object() template Orientation orientation_2(ForwardIterator first, ForwardIterator last, const Traits& traits) { CGAL_polygon_precondition(is_simple_2(first, last, traits)); ForwardIterator i = left_vertex_2(first, last, traits); ForwardIterator prev = (i == first) ? last : i; --prev; ForwardIterator next = i; ++next; if (next == last) next = first; // if the range [first,last) contains less than three points, then some // of the points (prev,i,next) will coincide // return the orientation of the triple (prev,i,next) return traits.orientation_2_object()(*prev, *i, *next); } CGAL_END_NAMESPACE mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/enum.h0000644000175000017500000000411511344301500026136 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/enum.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_ENUM_H #define CGAL_ENUM_H // If you add/change one type here, please update Is_a_predicate.h as well. CGAL_BEGIN_NAMESPACE enum Sign { NEGATIVE = -1, ZERO, POSITIVE }; typedef Sign Orientation; const Orientation LEFT_TURN = POSITIVE; const Orientation RIGHT_TURN = NEGATIVE; const Orientation CLOCKWISE = NEGATIVE; const Orientation COUNTERCLOCKWISE = POSITIVE; const Orientation COLLINEAR = ZERO; const Orientation COPLANAR = ZERO; const Orientation DEGENERATE = ZERO; enum Oriented_side { ON_NEGATIVE_SIDE = -1, ON_ORIENTED_BOUNDARY, ON_POSITIVE_SIDE }; enum Bounded_side { ON_UNBOUNDED_SIDE = -1, ON_BOUNDARY, ON_BOUNDED_SIDE }; enum Comparison_result { SMALLER = -1, EQUAL, LARGER }; enum Angle { OBTUSE = -1, RIGHT, ACUTE }; CGAL_END_NAMESPACE #include #endif // CGAL_ENUM_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2.h0000644000175000017500000000244611344301500030126 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTION_2_H #define CGAL_INTERSECTION_2_H #include #include #include #endif // CGAL_INTERSECTION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map.h0000644000175000017500000011512211344301501030305 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan #ifndef CGAL_TOPOLOGICAL_MAP_H #define CGAL_TOPOLOGICAL_MAP_H #include #include CGAL_BEGIN_NAMESPACE template class Topological_map { protected: typedef typename Dcel::Vertex dvertex; typedef typename Dcel::Halfedge dedge; typedef typename Dcel::Face dface; public: typedef typename Dcel::Size Size; typedef typename Dcel::size_type size_type; typedef typename Dcel::difference_type difference_type; typedef typename Dcel::difference_type Difference; typedef typename Dcel::iterator_category iterator_category; // These extra (internal) typedefs are necessary to make // SunPro CC 4.2 happy. (And they are used.) typedef typename Dcel::Vertex_iterator TR_VI; typedef typename Dcel::Vertex_const_iterator TR_C_VI; typedef typename Dcel::Halfedge_iterator TR_HI; typedef typename Dcel::Halfedge_const_iterator TR_C_HI; typedef typename Dcel::Edge_iterator TR_EI; typedef typename Dcel::Edge_const_iterator TR_C_EI; typedef typename Dcel::Face_iterator TR_FI; typedef typename Dcel::Face_const_iterator TR_C_FI; typedef typename Dcel::Face::Holes_iterator TR_HOI; typedef typename Dcel::Face::Holes_const_iterator TR_C_HOI; public: class Vertex; class Halfedge; class Face; //in VC class's private members aren't available in nested classes #if _MSC_VER>=1100 friend Face; #endif typedef I_HalfedgeDS_iterator Vertex_iterator; typedef I_HalfedgeDS_const_iterator Vertex_const_iterator; typedef I_HalfedgeDS_iterator Halfedge_iterator; typedef I_HalfedgeDS_const_iterator Halfedge_const_iterator; typedef I_HalfedgeDS_iterator Edge_iterator; typedef I_HalfedgeDS_const_iterator Edge_const_iterator; typedef I_HalfedgeDS_iterator Face_iterator; typedef I_HalfedgeDS_const_iterator Face_const_iterator; typedef _HalfedgeDS_facet_circ Ccb_halfedge_circulator; typedef _HalfedgeDS_vertex_circ Halfedge_around_vertex_circulator; typedef _HalfedgeDS_facet_const_circ Ccb_halfedge_const_circulator; typedef _HalfedgeDS_vertex_const_circ Halfedge_around_vertex_const_circulator; typedef I_HalfedgeDS_iterator Holes_iterator; typedef I_HalfedgeDS_const_iterator Holes_const_iterator; typedef Vertex_iterator Vertex_handle; typedef Halfedge_iterator Halfedge_handle; typedef Face_iterator Face_handle; typedef Vertex_const_iterator Vertex_const_handle; typedef Halfedge_const_iterator Halfedge_const_handle; typedef Face_const_iterator Face_const_handle; /**************************************************************/ /********************* V e r t e x ****************************/ /**************************************************************/ /**************************************************************/ class Vertex : public Dcel::Vertex { public: typedef typename Dcel::Vertex Base; Vertex() {} Vertex(Base *v) : Base(*v) {} Vertex(Base& v) : Base(v) {} bool is_incident_edge(Halfedge_const_handle e) const { return (&(*(e->source())) == this) || (&(*(e->target())) == this); } bool is_incident_face(Face_const_handle f) const { // const typename Dcel::Halfedge* e_ptr=(dvertex::halfedge()); const typename Dcel::Halfedge* e_ptr=(Base::halfedge()); do { if ( e_ptr->face() == &(*f) ) return true; e_ptr = e_ptr->opposite()->next(); // } while (e_ptr != dvertex::halfedge()); } while (e_ptr != Base::halfedge()); return false; } unsigned int degree() const { // const typename Dcel::Halfedge* e=dvertex::halfedge(); const typename Dcel::Halfedge * e = Base::halfedge(); const typename Dcel::Halfedge * e1 = e; int n = 0; if (e1 != NULL) { do { n++; e1 = e1->next()->opposite(); } while (e1 != e); } return n; } Halfedge_around_vertex_circulator incident_halfedges() { //return Halfedge_around_vertex_circulator(TR_HI(dvertex::halfedge())); return Halfedge_around_vertex_circulator(TR_HI(Base::halfedge())); } Halfedge_around_vertex_const_circulator incident_halfedges() const { //return //Halfedge_around_vertex_const_circulator(TR_C_HI(dvertex::halfedge())); return Halfedge_around_vertex_const_circulator(TR_C_HI(Base::halfedge())); } private: // void set_halfedge(Halfedge* h) {dvertex::set_halfedge(h);} void set_halfedge(Halfedge* h) {Base::set_halfedge(h);} }; /**************************************************************/ /**************************************************************/ /********************* Halfedge *******************************/ /**************************************************************/ /**************************************************************/ class Halfedge : public Dcel::Halfedge { public: typedef typename Dcel::Halfedge Base; Halfedge() {} Halfedge(Base *e) : Base(*e) {} Halfedge(Base& e) : Base(e) {} Vertex_handle source() { return TR_VI(Base::opposite()->vertex()); } Vertex_const_handle source() const { return TR_C_VI(Base::opposite()->vertex()); } Vertex_handle target() { return TR_VI(Base::vertex()); } Vertex_const_handle target() const { return TR_C_VI(Base::vertex()); } Face_handle face() { return TR_FI(Base::face()); } Face_const_handle face() const { return TR_C_FI(Base::face()); } Halfedge_handle twin() { return TR_HI(Base::opposite()); } Halfedge_const_handle twin() const { return TR_C_HI(Base::opposite()); } Halfedge_handle next_halfedge() { return TR_HI(Base::next()); } Halfedge_const_handle next_halfedge() const { return TR_C_HI(Base::next()); } Ccb_halfedge_circulator ccb() { return Ccb_halfedge_circulator(TR_HI(this)); } Ccb_halfedge_const_circulator ccb() const { return Ccb_halfedge_const_circulator(TR_C_HI(this)); } private: //hide from users the underlying structure void set_next( Halfedge* h) { Base::set_next(h);} void set_vertex( Vertex* ve) { Base::set_vertex(ve);} void set_face( Face* face) { Base::set_face(face);} }; /**************************************************************/ /**************************************************************/ /********************* F a c e ********************************/ /**************************************************************/ /**************************************************************/ class Face : public Dcel::Face { public: typedef typename Dcel::Face Base; #ifndef _MSC_VER // the following two typedefs are needed for compilation on irix64 (CC7.30) typedef typename Topological_map::Holes_iterator Holes_iterator; typedef typename Topological_map::Holes_const_iterator Holes_const_iterator; #endif Face() {} Face(Base *f) : Base(*f) {} Face(Base& f) : Base(f) {} bool is_unbounded() const { // face is not bounded iff it has no outer boundary return (Base::halfedge() == NULL); } // must explicitly say Topological_map::Holes_iterator. Otherwise // the CC compiler thinks we mean Base::Holes_iterator. Holes_iterator holes_begin() { return TR_HOI(Base::holes_begin()); } Holes_const_iterator holes_begin() const { return TR_C_HOI(Base::holes_begin()); } Holes_iterator holes_end() { return TR_HOI(Base::holes_end()); } Holes_const_iterator holes_end() const { return TR_C_HOI(Base::holes_end()); } bool is_halfedge_on_inner_ccb(Halfedge_const_handle e) #if !(_MSC_VER>=1100) const #endif { dedge* dummy; return (/*Topological_map::*/ is_halfedge_on_inner_ccb(&(*e), (typename Dcel::Face*)this, dummy)); // oren corrections (dummy parameter - for bug in MSC) } bool is_halfedge_on_outer_ccb(Halfedge_const_handle e) #if !(_MSC_VER>=1100) const #endif { dedge* dummy; return /*Topological_map::*/ is_halfedge_on_outer_ccb(&(*e),this,dummy); // oren corrections (dummy parameter - bug in MSC) } bool does_outer_ccb_exist() const { return Base::halfedge() != NULL; } Halfedge_handle halfedge_on_outer_ccb() { CGAL_precondition(does_outer_ccb_exist()); return TR_HI(Base::halfedge()); } Halfedge_const_handle halfedge_on_outer_ccb() const { CGAL_precondition(does_outer_ccb_exist()); return TR_C_HI(Base::halfedge()); } Ccb_halfedge_circulator outer_ccb() { CGAL_precondition(does_outer_ccb_exist()); return (halfedge_on_outer_ccb())->ccb(); } Ccb_halfedge_const_circulator outer_ccb() const { CGAL_precondition(does_outer_ccb_exist()); return (halfedge_on_outer_ccb())->ccb(); } private: void set_halfedge( Halfedge* h) { Base::set_halfedge(h);} void add_hole(Halfedge* h) {Base::add_hole(h);} }; /*! Constructor */ Topological_map() : d() { u_face = d.new_face(); u_face->set_halfedge(NULL); } /* * INSERTIONS * * insertion from vertices may invalidate the holes containers (since a new * face can be created which contains some of the holes of the old face. * to validate the containers the function move_hole should be called. * * if a new face is created, returns the halfedge on the new face. * the new face will ALWAYS (by definition) be the one from v1->v2 (==e1) * this sets a requirement on the user!!! (since a topological pm can't * know if v1->v2 is on the new face or v2->v1) * * since there can be a number of edges from the vertices, and we can't * now topologically which will be in the new face and which will be * outside, this should be provided by the user - defining prev1 and * prev2 (previous to v1,v2 resp.) the planar map will define this * geometrically using the one previous to the curve clock wise. */ Halfedge_handle insert_at_vertices( Halfedge_handle previous1, Halfedge_handle previous2) ; //moves ONE hole from f1 to f2 void move_hole(Holes_iterator e, Face_handle f1, Face_handle f2); Halfedge_handle insert_from_vertex(Halfedge_handle previous) ; Halfedge_handle insert_in_face_interior(Face_handle f) ; Halfedge_handle split_edge (Halfedge_handle e ) ; Halfedge_handle merge_edge (Halfedge_handle e1, Halfedge_handle e2) ; //returns the merged face after the deletion Face_handle remove_edge(Halfedge_handle e) ; Face_handle unbounded_face() { return TR_FI(u_face); } Face_const_handle unbounded_face() const { return TR_C_FI(u_face); } Face_iterator faces_begin() { return TR_FI(d.faces_begin()); } Face_const_iterator faces_begin() const { return TR_C_FI(d.faces_begin()); } Face_iterator faces_end() { return TR_FI(d.faces_end()); } Face_const_iterator faces_end() const { return TR_C_FI(d.faces_end()); } Halfedge_iterator halfedges_begin() { return TR_HI(d.halfedges_begin()); } Halfedge_const_iterator halfedges_begin() const { return TR_C_HI(d.halfedges_begin()); } Halfedge_iterator halfedges_end() { return TR_HI(d.halfedges_end()); } Halfedge_const_iterator halfedges_end() const { return TR_C_HI(d.halfedges_end()); } Edge_iterator edges_begin() { return TR_EI(d.edges_begin()); } Edge_const_iterator edges_begin() const { return TR_C_EI(d.edges_begin()); } Edge_iterator edges_end() { return TR_EI(d.edges_end()); } Edge_const_iterator edges_end() const { return TR_C_EI(d.edges_end()); } Vertex_iterator vertices_begin() { return TR_VI(d.vertices_begin()); } Vertex_const_iterator vertices_begin() const { return TR_C_VI(d.vertices_begin()); } Vertex_iterator vertices_end() { return TR_VI(d.vertices_end()); } Vertex_const_iterator vertices_end() const { return TR_C_VI(d.vertices_end()); } void clear() { d.delete_all(); u_face = NULL; u_face = d.new_face(); u_face->set_halfedge(NULL); } void assign(const Topological_map &tpm) { d.delete_all(); u_face = NULL; u_face = (Face*)d.assign(tpm.d, tpm.u_face); } /**************************************************************/ /**************************************************************/ /*********** Topological_map_2 - validity checks ********/ /**************************************************************/ /**************************************************************/ bool is_valid(Vertex_const_handle v #if _MSC_VER>=1100 // VC template bug ,Vertex* dummy=NULL #endif ) const { bool valid = true; // check if every edge from v has v as its target Halfedge_around_vertex_const_circulator ec = v->incident_halfedges(); Halfedge_around_vertex_const_circulator start = ec; do { if ((*ec).target() != v) { valid = false; } ++ec; } while (ec != start); return valid; } bool is_valid(Halfedge_const_handle e #if _MSC_VER>=1100 // VC template bug ,Halfedge* dummy=NULL #endif ) const { //check relations with next if (e->target() != e->next_halfedge()->source()) return false; return true; } bool is_valid(const Ccb_halfedge_const_circulator& start, Face_const_handle f) const { bool valid = true; Ccb_halfedge_const_circulator circ = start; do { if ((*circ).face() != f) valid = false; ++circ; } while (circ != start); return valid; } bool is_valid(Face_const_handle f #if _MSC_VER>=1100 // VC template bug ,Face* dummy=NULL #endif ) const { bool valid = true; // check if all edges of f (on all ccb's) refer to f (as their face) Holes_const_iterator iccbit; Ccb_halfedge_const_circulator ccb_circ; if (f->does_outer_ccb_exist()) { ccb_circ = f->outer_ccb(); if (!is_valid(ccb_circ, f)) valid = false; } for (iccbit = f->holes_begin(); iccbit != f->holes_end(); ++iccbit) { ccb_circ = *iccbit; if (!is_valid(ccb_circ, f)) valid = false; } return valid; } /*! Chcecks whether the planar map is valid. In particular is_valid() * checks the validity of each vertex, halfedge, and face */ bool is_valid() const { Vertex_const_iterator vi; for (vi = vertices_begin(); vi != vertices_end(); ++vi) { if (!is_valid(vi)) { CGAL_warning("Invalid vertex!"); return false; } } Halfedge_const_iterator ei; for (ei = halfedges_begin(); ei != halfedges_end(); ++ei) { if (!is_valid(ei)) { CGAL_warning("Invalid halfedge!"); return false; } } Face_const_iterator fi; for (fi = faces_begin(); fi != faces_end(); ++fi) { if (!is_valid(fi)) { CGAL_warning("Invalid face!"); return false; } } return true; } /******************************************************************/ /********************* counting functions ***********************/ /******************************************************************/ Size number_of_faces() const { return d.size_of_faces(); } //counts every halfedge (i.e always even) Size number_of_halfedges() const { return d.size_of_halfedges(); } Size number_of_vertices() const { return d.size_of_vertices(); } //--------------------------------------------------------------- //PRIVATE IMPLEMENTATIONS //--------------------------------------------------------------- private: //find previous halfedge of given halfedge typename Dcel::Halfedge* get_prev( typename Dcel::Halfedge* de) { //find previous halfedge of de typename Dcel::Halfedge* prev=de; do { if (prev->next()==de) break; prev=prev->next(); }while (prev!=de); //assumes a loop to itself is unacceptable CGAL_assertion(prev!=de); return prev; } bool find_and_erase_hole(typename Dcel::Halfedge* e, typename Dcel::Face* f) { typename Dcel::Face::Holes_iterator it=f->holes_begin(); bool ret=false; for (; it!=f->holes_end(); ++it) { if ( (*it)==e ) { f->erase_hole(it); ret=true; break; } } return ret; } protected: // forbid copy constructor and assignment /*! Copy Constructor */ Topological_map(const Topological_map & tm) { // d = tm.d; // u_face = tm.u_face; } /*! Assignment operator */ Topological_map & operator=(const Topological_map &) { // d = tm.d; // u_face = tm.u_face; return *this; } protected: Dcel d; dface* u_face; }; ///////////////////////////////////////////////////////////////// // implementation ///////////////////////////////////////////////////////////////// template bool is_halfedge_on_inner_ccb(const typename Dcel::Halfedge* e, typename Dcel::Face* f, typename Dcel::Halfedge* &iccb) { typedef typename Dcel::Vertex dvertex; typedef typename Dcel::Halfedge dedge; typedef typename Dcel::Face dface; //move over all holes in face and check for (typename dface::Holes_iterator dhi=f->holes_begin(); dhi!=f->holes_end(); ++dhi) { iccb=(*dhi); const typename Dcel::Halfedge* aux=iccb; do { if (aux==e) return true; aux=aux->next() ; } while (aux!=(*dhi)); } iccb=NULL; return false; } //returns the representative halfedge of outer ccb in occb, or false template bool is_halfedge_on_outer_ccb(const typename Dcel::Halfedge* e, typename Dcel::Face* f, typename Dcel::Halfedge* &occb) { typedef typename Dcel::Vertex dvertex; typedef typename Dcel::Halfedge dedge; typedef typename Dcel::Face dface; occb=f->halfedge(); if ( occb ) { //if f isn't the unbounded face const typename Dcel::Halfedge* aux=occb; do { if (aux==e) return true; aux=aux->next(); }while (aux!=f->halfedge()); } occb=NULL; return false; } //insertion from vertices may invalidate the holes containers (since a new //face can be created which contains some of the holes of the old face. //to validate the containers the function move_hole should be called. //if a new face is created, returns the halfedge on the new face. the //new face will ALWAYS (by definition) be the one from v1->v2 //(==previous1->e1->..) this sets a requirement on the user!!! (since //a topological pm can't know if v1->v2 is on the new face or v2->v1) //since there can be a number of edges from the vertices, and we can't //know topologically which will be in the new face and which will be //outside, this should be provided by the user - defining prev1 and //prev2 (previous to v1,v2 resp.) the planar map will define this //geometrically using the one previous to the curve clock wise. //prev1->target() is v1 template typename Topological_map::Halfedge_handle Topological_map:: insert_at_vertices(Halfedge_handle previous1, Halfedge_handle previous2) { // vertices should be distinct CGAL_precondition(previous1->target()!=previous2->target()); typename Dcel::Halfedge *prev1=&(*previous1), *prev2=&(*previous2); typename Dcel::Vertex* dv1=prev1->vertex(); typename Dcel::Vertex* dv2=prev2->vertex(); CGAL_precondition(prev1->face()==prev2->face()); typename Dcel::Face* df=prev1->face(); //will hold represantative halfedge of prev1/2 typename Dcel::Halfedge *ccb1,*ccb2; if (!(is_halfedge_on_outer_ccb(prev1,df,ccb1)) ) is_halfedge_on_inner_ccb(prev1,df,ccb1); if (!(is_halfedge_on_outer_ccb(prev2,df,ccb2)) ) is_halfedge_on_inner_ccb(prev2,df,ccb2); bool ccb1_is_inner = !(ccb1==df->halfedge()); bool ccbs_equal = (ccb1 == ccb2); typename Dcel::Halfedge* e1=d.new_edge(); typename Dcel::Halfedge* e2=e1->opposite(); e1->set_vertex(dv1); e2->set_vertex(dv2); e1->set_next(prev1->next()); e2->set_next(prev2->next()); prev1->set_next(e2); prev2->set_next(e1); //Cases: //a. ccb1!=ccb2 (at least one is inner ccb) - no face added if (!ccbs_equal) { e1->set_face(df); e2->set_face(df); //remove ONE inner ccb from df if (ccb1_is_inner) { //ccb1 becomes part of ccb2 find_and_erase_hole(ccb1,df); } else { //ccb2 becomes part of ccb1 find_and_erase_hole(ccb2,df); } return TR_HI(e2); } //b. ccb1==ccb2 //new face is created //the new face will ALWAYS (by definition) be the one from v1->v2 (==e2) //this sets a requirement on the user!!! //the planar map will define this geometrically //(by finding the leftmost halfedge //(or left-down) when going from v1 to v2 (visiting v1 only once!!) and //checking if it is up or down, if it is up then send v1->v2 else //send v2->v1) typename Dcel::Face* nf = d.new_face(); //b.1 the vertices are on outer ccb if (! ccb1_is_inner) { e2->set_face(nf); e1->set_face(df); nf->set_halfedge(e2); //set the represantative edge to be e2 df->set_halfedge(e1); //set the face pointer for all halfedges of e2 to nf ccb2=e2->next(); while (ccb2!=e2) { ccb2->set_face(nf); ccb2=ccb2->next(); } } //b.2 the vertices are on an inner ccb else { e1->set_face(df); e2->set_face(nf); nf->set_halfedge(e2); ccb2=e2->next(); while (ccb2!=e2) { ccb2->set_face(nf); ccb2=ccb2->next(); } //remove ccb1 from holes_container (maybe it is now inside the new face) find_and_erase_hole(ccb1,df); df->add_hole(e1); } return TR_HI(e2); } template void Topological_map:: move_hole(Holes_iterator e, Face_handle f1, Face_handle f2) { //move hole from df1 to df2 and set face pointer of each edge on hole to df1 typename Dcel::Face* df1=&(*f1); typename Dcel::Face* df2=&(*f2); //set face pointers to df1 typename Dcel::Halfedge* last=&(*(*(e))); typename Dcel::Halfedge* first=last; do { first->set_face(df2); first=first->next(); } while (first!=last) ; //copy to df2 df2->add_hole(first); df1->erase_hole(e.current_iterator()); } //returns halfedge which is previous->next template typename Topological_map::Halfedge_handle Topological_map:: insert_from_vertex(Halfedge_handle previous) { typename Dcel::Halfedge* prev=&(*previous); typename Dcel::Face* df=prev->face(); typename Dcel::Vertex* dv1=prev->vertex(); typename Dcel::Vertex* dv2=d.new_vertex(); //the new vertex typename Dcel::Halfedge* h1=d.new_edge(); typename Dcel::Halfedge* h2=h1->opposite(); h1->set_vertex(dv1); h2->set_vertex(dv2); h1->set_face(df); h2->set_face(df); dv2->set_halfedge(h2); h2->set_next(h1); h1->set_next(prev->next()); prev->set_next(h2); return TR_HI(h2); } template typename Topological_map::Halfedge_handle Topological_map:: insert_in_face_interior(Face_handle f) { typename Dcel::Vertex* v1=d.new_vertex(); typename Dcel::Vertex* v2=d.new_vertex(); typename Dcel::Halfedge* h1 = d.new_edge(); typename Dcel::Halfedge* h2 = h1->opposite(); typename Dcel::Face* fp =&(*f); h1->set_next(h2); h1->set_vertex(v1); h1->set_face(fp); h2->set_next(h1); h2->set_vertex(v2); h2->set_face(fp); v1->set_halfedge(h1); v2->set_halfedge(h2); fp->add_hole(h1); return TR_HI(h1); } template typename Topological_map::Halfedge_handle Topological_map::split_edge (Halfedge_handle e) { typename Dcel::Halfedge* e1=&(*e); typename Dcel::Halfedge* e2=e1->opposite(); //find previous halfedge of e2 typename Dcel::Halfedge* prev2=get_prev(e2); typename Dcel::Vertex* v=d.new_vertex(); typename Dcel::Halfedge* e3=d.new_edge(); typename Dcel::Halfedge* e4=e3->opposite(); v->set_halfedge(e4); if (e1->next()!=e2) e3->set_next(e1->next()); else e3->set_next(e4); e4->set_vertex(v); e3->set_face(e1->face()); e4->set_next(e2); e3->set_vertex(e1->vertex()); e4->set_face(e2->face()); e1->vertex()->set_halfedge(e3); //makes the incident halfedge e3 //(so if e1 was the incident halfedge it comes instead ) - changed if (prev2!=e1) prev2->set_next(e4); //otherwise e3->set_next(e4) - taken care above e1->set_next(e3); e1->set_vertex(v); return TR_HI(e1); } /*! Merge 2 given halfedges into one * \param e1 the first input halfedge * \param e2 second input halfedge * \return the merged halfedge */ template typename Topological_map::Halfedge_handle Topological_map::merge_edge(Halfedge_handle e1, Halfedge_handle e2) { //check e1->e2 and that degree(e1.target)==2 (i.e no other edge connected) //CGAL_assertion(e1->target()==e2->source()); CGAL_assertion((e1->target()==e2->source() && e1->target()->degree()==2 ) || (e2->target()==e1->source() && e2->target()->degree()==2 ) || (e1->target()==e2->target() && e1->target()->degree()==2 ) || (e2->source()==e1->source() && e1->source()->degree()==2 )); //CGAL_assertion(e1->target()->degree()==2); typename Dcel::Halfedge * de1 = 0; typename Dcel::Halfedge * de1t = 0; typename Dcel::Halfedge * de2 = 0; typename Dcel::Halfedge * de2t = 0; if (e1->target() == e2->source()) { de1 = &(*e1); de1t = de1->opposite(); de2 = &(*e2); de2t = de2->opposite(); } if (e1->source() == e2->source()) { de1t = &(*e1); de1 = de1t->opposite(); de2 = &(*e2); de2t = de2->opposite(); } if (e1->target() == e2->target()) { de1 = &(*e1); de1t = de1->opposite(); de2t = &(*e2); de2 = de2t->opposite(); } if (e1->source() == e2->target()) { de1t = &(*e1); de1 = de1t->opposite(); de2t = &(*e2); de2 = de2t->opposite(); } typename Dcel::Vertex * v = de1->vertex(); typename Dcel::Face * f = de2->face(); typename Dcel::Face * ft = de1t->face(); //typename Dcel::Face* ft=de2t->face(); //at the end de1 and de1t will remain and de2t,de2 will be deleted //check if they are a "represantative" of a hole or outer ccb of face if (f->halfedge()==de2) f->set_halfedge(de1); else { if (find_and_erase_hole(de2,f)) f->add_hole(de1); } if (ft->halfedge()==de2t) ft->set_halfedge(de1t); else { if (find_and_erase_hole(de2t,f)) f->add_hole(de1t); } //in case de2 is representative halfedge of the target vertex de2->vertex()->set_halfedge(de1); if (de2->next() != de2t) { //de2 is not a tip of antenna //find previous halfedge of de2t typename Dcel::Halfedge* prev2=get_prev(de2t); de1->set_next(de2->next()); prev2->set_next(de1t); } else { de1->set_next(de1t); } de1->set_vertex(de2->vertex()); d.delete_edge(de2); d.delete_vertex(v); return TR_HI(de1); } template typename Topological_map::Face_handle Topological_map::remove_edge(Halfedge_handle e) { typename Dcel::Halfedge* de1=&(*e); typename Dcel::Halfedge* de2=de1->opposite(); typename Dcel::Face* df1=de1->face(); typename Dcel::Face* df2=de2->face(); typename Dcel::Halfedge* prev1; typename Dcel::Halfedge* prev2; //CASES: if (df1==df2) { //case a. antenna - no face deleted if (de1->next()==de2 && de2->next()==de1) { //a.1 only one edge as a hole if (!find_and_erase_hole(de1,df1)) find_and_erase_hole(de2,df1); d.delete_vertex(de2->vertex()); d.delete_vertex(de1->vertex()); d.delete_edge(de1); return TR_FI(df1); } if (de1->next()==de2 || de2->next()==de1) { //a.2 a tip of the antenna if (de1->next()==de2) { //de1 points at the tip prev1=get_prev(de1); prev1->set_next(de2->next()); //check if they are a represantative halfedge if so exchange if (df1->halfedge()==de2) df1->set_halfedge(prev1); else { if (find_and_erase_hole(de2,df1)) df1->add_hole(prev1); } if (df1->halfedge()==de1) df1->set_halfedge(prev1); else { if (find_and_erase_hole(de1,df1)) df1->add_hole(prev1); } //check if de2 is incident halfedge of de2->vertex and if so - //change to prev1 (iddo 16/6) if (de2->vertex()->halfedge() == de2) de2->vertex()->set_halfedge(prev1); d.delete_vertex(de1->vertex()); //changed to conform with HDS } else { //de2 points at the tip - find previous halfedge of de2 prev2=get_prev(de2); prev2->set_next(de1->next()); //check if they are represantative halfedge if so exchange if (df1->halfedge()==de2) df1->set_halfedge(prev2); else { if (find_and_erase_hole(de2,df1)) df1->add_hole(prev2); } if (df1->halfedge()==de1) df1->set_halfedge(prev2); else { if (find_and_erase_hole(de1,df1)) df1->add_hole(prev2); } //check if de1 is incident halfedge of de1->vertex and if so - //change to prev2 if (de1->vertex()->halfedge() == de1) de1->vertex()->set_halfedge(prev2) ; d.delete_vertex(de2->vertex()); } d.delete_edge(de1); return TR_FI(df1); } //a.3 a middle of an antenna - a new hole is created prev1=get_prev(de1); prev2=get_prev(de2); //find the ccb of de1/de2 typename Dcel::Halfedge *ccb1; if (is_halfedge_on_outer_ccb(prev1,df1,ccb1)) { //antenna is connected to outer ccb, split a hole from it. //we assume in this case that de1->next is the hole //(to be determined genoetrically by the user) df1->add_hole(de1->next()); df1->set_halfedge(prev1); } else { //antenna is a hole - split it into two holes is_halfedge_on_inner_ccb(prev1,df1,ccb1); #if defined(CGAL_NO_ASSERTIONS) || defined(NDEBUG) find_and_erase_hole(ccb1,df1); #else bool hole_found = find_and_erase_hole(ccb1,df1); CGAL_assertion(hole_found); //ccb1 must be a hole in df1 #endif df1->add_hole(prev1); df1->add_hole(prev2); } prev1->set_next(de2->next()); prev2->set_next(de1->next()); //check if de1 is incident halfedge of de1->vertex() and if so change to //prev2 same for de2 if (de1->vertex()->halfedge() == de1) de1->vertex()->set_halfedge(prev2); if (de2->vertex()->halfedge() == de2) de2->vertex()->set_halfedge(prev1); d.delete_edge(de1); return TR_FI(df1); } else { //case b. edge between faces - merge faces typename Dcel::Halfedge* ccb; bool de1_is_on_hole=!(is_halfedge_on_outer_ccb(de1,df1,ccb)); bool de2_is_on_hole=!(is_halfedge_on_outer_ccb(de2,df2,ccb)); if ( !de1_is_on_hole && !de2_is_on_hole ) { //b.1 both halfedges are on outer boundary prev1=get_prev(de1); prev2=get_prev(de2); //arbitrarily df2 will be removed - change all edges so point to df1 //set the face pointer for all halfedges of df2 to df1 typename Dcel::Halfedge* aux=de2->next(); while (aux!=de2) { aux->set_face(df1); aux=aux->next(); } //move holes from df2 to df1 and set face pointer of each edge on //hole to df1 typename Dcel::Face::Holes_iterator hi = df2->holes_begin(); for ( ; hi!=df2->holes_end(); ++hi) { //set face pointers to df1 typename Dcel::Halfedge* aux1=(*hi); do { aux1->set_face(df1); aux1=aux1->next(); } while (aux1!=(*hi)) ; } //copy the holes to the holes list of df1 for (hi = df2->holes_begin(); hi!=df2->holes_end(); ++hi) { df1->add_hole(*hi); } df2->erase_holes(df2->holes_begin(),df2->holes_end()); //check if represantative edge if (de1==df1->halfedge()) df1->set_halfedge(prev1); //check if de1 is incident halfedge of de1->vertex() and if so change to //prev2 same for de2 if (de1->vertex()->halfedge() == de1) de1->vertex()->set_halfedge(prev2); if (de2->vertex()->halfedge() == de2) de2->vertex()->set_halfedge(prev1); prev1->set_next(de2->next()); prev2->set_next(de1->next()); d.delete_face(df2); d.delete_edge(de1); return TR_FI(df1); } else { //edge is on a hole prev1=get_prev(de1); prev2=get_prev(de2); if (de1_is_on_hole) { //df1 is the outer face df2 was the hole //df2 will be removed - change all edges so point to df1 //set the face pointer for all halfedges of df2 to df1 typename Dcel::Halfedge* aux=de2->next(); while (aux!=de2) { aux->set_face(df1); aux=aux->next(); } //move holes from df2 to df1 and set face pointer of each edge on //hole to df1 typename Dcel::Face::Holes_iterator hi = df2->holes_begin(); for ( ; hi!=df2->holes_end(); ++hi) { //set face pointers to df1 typename Dcel::Halfedge* aux1=(*hi); do { aux1->set_face(df1); aux1=aux1->next(); } while (aux1!=(*hi)) ; } //copy to the holes list of df1 for (hi = df2->holes_begin(); hi!=df2->holes_end(); ++hi) { df1->add_hole(*hi); } df2->erase_holes(df2->holes_begin(),df2->holes_end()); //check if de1 is a represantative hole of df1 (it is not on the outer) if (find_and_erase_hole(de1,df1)) df1->add_hole(prev1); //check if de1 is incident halfedge of de1->vertex() and if so change to //prev2 same for de2 if (de1->vertex()->halfedge() == de1) de1->vertex()->set_halfedge(prev2); if (de2->vertex()->halfedge() == de2) de2->vertex()->set_halfedge(prev1); prev1->set_next(de2->next()); prev2->set_next(de1->next()); d.delete_face(df2); d.delete_edge(de1); return TR_FI(df1); } else { //df2 is the outer face //erase df1 //df1 will be removed - change all edges so point to df2 typename Dcel::Halfedge* aux=de1->next(); while (aux!=de1) { aux->set_face(df2); aux=aux->next(); } //move holes from df1 to df2 and set face pointer of each edge on //hole to df1 typename Dcel::Face::Holes_iterator hi = df1->holes_begin(); for ( ; hi!=df1->holes_end(); ++hi) { //set face pointers to df2 typename Dcel::Halfedge* aux1=(*hi); do { aux1->set_face(df2); aux1=aux1->next(); } while (aux1!=(*hi)) ; } //copy to the holes list of df2 for (hi = df1->holes_begin(); hi!=df1->holes_end(); ++hi) { df2->add_hole(*hi); } df1->erase_holes(df1->holes_begin(),df1->holes_end()); //check if de2 is a represantative hole of df2 if (find_and_erase_hole(de2,df2)) df2->add_hole(prev2); //check if de1 is incident halfedge of de1->vertex() and if so change to //to prev2 same for de2 if (de1->vertex()->halfedge() == de1) de1->vertex()->set_halfedge(prev2); if (de2->vertex()->halfedge() == de2) de2->vertex()->set_halfedge(prev1); prev1->set_next(de2->next()); prev2->set_next(de1->next()); d.delete_face(df1); d.delete_edge(de1); return TR_FI(df2); } //df2 is outer.. } //edge is on a hole.. } //case b. (face deleted) } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Largest_empty_iso_rectangle_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Largest_empty_iso_rect0000644000175000017500000011100111344301500031443 0ustar debiandebian// Copyright (c) 1999 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Largest_empty_iso_rectangle_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Eli Packer (algorithm), Andreas Fabri (cgal conformance) #ifndef CGAL_LARGEST_EMPTY_ISO_RECTANGLE_2_H #define CGAL_LARGEST_EMPTY_ISO_RECTANGLE_2_H /*! \file * The implementation of the Largest_empty_iso_rectangle_2 class. */ #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE /*! Largest_empty_iso_rectangle_2 is a class that implements the largest empty rectangle algorithm based on the algorithm described in M. Orlowski. A new algorithm for the largest empty rectangle problem. Algorithmica, 5:65-73, 1990. The problem is the following. Given a set of points and a bounding box that include the points, find the largest axis parallel rectangle that contains no points inside it. The algorithm is extended to support the degenerate case in which two points have the same x or y coordinates. The algorithm checks all the empty rectangles that are bounded by either points or edges of the bounding box (other empty rectangles can be enlarged and remain empty). There are O(n^2) such rectangles. It is done in three phases. In the first one empty rectangles that are bounded by two opposite edges of the bounding box are checked. In the second one, other empty rectangles that are bounded by one or two edges of the bounding box are checked. In the third phase, all other empty rectangles, namely the ones that are bounded by four points, are checked. */ template class Largest_empty_iso_rectangle_2 { public: struct Internal_point; typedef typename T::FT NT; typedef typename T::Point_2 Point_2; typedef Internal_point Point; typedef typename T::Iso_rectangle_2 Iso_rectangle_2; typedef T Traits; class Point_data; class Less_yx { private: class Less_xy_internal_point; class Less_yx_internal_point; Traits _gt; const Traits & traits() const {return _gt;}; Less_yx(){} public: Less_yx(const Traits& t) : _gt(t) {} bool operator()(const Point_data *a, const Point_data *b) const { Comparison_result c = traits().compare_y_2_object() (b->p.y_part, a->p.y_part); if(c == LARGER) { return true; } else if (c == EQUAL) { return traits().less_x_2_object()(a->p.x_part, b->p.x_part); } return false; } }; class Less_xy { private: Traits _gt; const Traits & traits() const {return _gt;}; public: Less_xy(const Traits& t) : _gt(t) {} bool operator()(const Point_data *a, const Point_data *b) const { Comparison_result c = traits().compare_x_2_object() (b->p.x_part, a->p.x_part); if(c == LARGER) { return true; } else if (c == EQUAL) { return traits().less_y_2_object()(a->p.y_part, b->p.y_part); } return false; } }; template < class Node> struct Proj_point { typedef Node argument_type; typedef Point_2 result_type; Point_2& operator()( Node& x) const { return x->p.original; } const Point_2& operator()( const Node& x) const { return x->p.original; } }; typedef std::set Point_data_set_of_x; typedef std::set Point_data_set_of_y; // The following is an iterator adapter that allows us to enumerate // the points in a set where they are stored typedef Iterator_project, const Point_2&, const Point_2*> const_iterator; enum Point_type{REG, BOT_RIGHT, BOT_LEFT, TOP_LEFT, TOP_RIGHT}; const Traits & traits() const {return _gt;}; // These friends are required by SUNPRO CC. //! Internal data held under each point that the algorithm requires friend class Point_data; //! A functor used to sort points lexicographically by their x and y //! coordinates friend class Less_xy; //! A functor used to sort points lexicographically by their y and x //! coordinates friend class Less_yx; //! A constructor given two points parameters. The parameters are two //! opposite corners of the bounding box. Largest_empty_iso_rectangle_2(const Point_2& bl, const Point_2& tr); //! Constructor given an Iso Rectangle parameter. The parameter is //! the bounding box. Largest_empty_iso_rectangle_2(const Iso_rectangle_2 &b); //! A parameter-less constructor Largest_empty_iso_rectangle_2(); //! Add a point to the data. bool insert(const Point_2& p); //! The STL standard member function for insertion. void push_back(const Point& _p) { insert(_p); } //! Insertion of an iterator range. template < class InputIterator > int insert(InputIterator first, InputIterator last) { int n = 0; while(first != last){ if(insert(*first)){ n++; } ++first; } return n; } //! Remove a point from data. bool remove(const Point& p); //! Get the bounding box of the instance. Iso_rectangle_2 get_bounding_box(); //! Retrieve largest empty iso rectangle. /*! get_largest_empty_iso_rectangle() retrieves the largest empty iso * rectangle which lies inside the bounding box of the instance. An * empty rectangle is defined as a rectangle that contains no points * inside its interior. * \return the largest empty iso rectangle. */ Iso_rectangle_2 get_largest_empty_iso_rectangle(); //! Retrieve four points from the input that define the largest //! empty iso rectangle. Quadruple get_left_bottom_right_top() { if(x_sorted.size() == 4) { return(make_quadruple(bl_p.original, bl_p.original, tr_p.original, tr_p.original)); } update(); return(make_quadruple(left_p.original, bottom_p.original, right_p.original, top_p.original)); } //! Clear the data(remove the points). void clear(); //! Get a begin iterator to points const_iterator begin() const; //! Get a after-the-end iterator to points const_iterator end() const; //! A destructor ~Largest_empty_iso_rectangle_2(); //! An operator= Largest_empty_iso_rectangle_2& operator =(const Largest_empty_iso_rectangle_2& ler); //! A copy constructor Largest_empty_iso_rectangle_2( const Largest_empty_iso_rectangle_2& ler); struct Internal_point { Point_2 x_part;// the x coordinate of the point Point_2 y_part;// the y coordinate of the point Point_2 original; Internal_point & operator=(const Internal_point &other) { x_part = other.x_part; y_part = other.y_part; original = other.original; return(*this); } Internal_point() // no real value - just to allow construction of LER : x_part(Point_2(0,0)), y_part(Point_2(0,0)), original(Point_2(0,0)) {} Internal_point(int x,int y) : x_part(Point_2(x,y)), y_part(Point_2(x,y)), original(Point_2(x,y)) {} Internal_point(const Point_2 &p) : x_part(p), y_part(p), original(p) {} }; class Point_data { public: Point p; /*! the next two members save set of points that are needed for the third phase. */ std::set *right_tent; std::set *left_tent; /* detemine whether the point is a bounding box corner (thus not implicitely inserted as a point, or not. */ Point_type type; Point_data(const Point& _p) : p(_p),type(REG) { right_tent = 0; left_tent = 0; } Point_data(const Point& _p, std::set *r_tent, std::set *l_tent) : p(_p),right_tent(r_tent),left_tent(l_tent),type(REG) {} Point_data(const Point& _p, std::set *r_tent, std::set *l_tent, Point_type i_type) : p(_p),right_tent(r_tent),left_tent(l_tent),type(i_type) {} Point_data (const Point_data &other) : p(other.p), right_tent(other.right_tent), left_tent(other.left_tent) {} ~Point_data() { delete right_tent; delete left_tent; } }; private: /* this struct is the point representation. It is composed of two points * such that one holds the x coordinate and the other holds the y coordinate */ /*! false if no points were inserted or removed, thus the previous results hold. Otherwise there is a need to find the new largest empty rectangle.. */ class Less_xy_internal_point { private: Traits _gt; const Traits & traits() const {return _gt;}; public: Less_xy_internal_point(const Traits& t) : _gt(t) {} bool operator()(const Point &a, const Point &b) const { Comparison_result c = traits().compare_x_2_object() (b.x_part, a.x_part); if(c == LARGER) { return true; } else if (c == EQUAL) { return traits().less_y_2_object()(a.y_part, b.y_part); } return false; } }; class Less_yx_internal_point { private: Traits _gt; const Traits & traits() const {return _gt;}; Less_yx_internal_point(){} public: Less_yx_internal_point(const Traits& t) : _gt(t) {} bool operator()(const Point &a, const Point &b) const { Comparison_result c = traits().compare_y_2_object() (b.y_part, a.y_part); if(c == LARGER) { return true; } else if (c == EQUAL) { return traits().less_x_2_object()(a.x_part, b.x_part); } return false; } }; bool cache_valid; Traits _gt; /*! this class holds points' data as needed in the LER process. */ bool less_xy(const Point_data *a, const Point_data *b) const { return(!larger_xy(a,b)); } bool less_yx(const Point_data *a, const Point_data *b) const { return(!larger_yx(a,b)); } bool larger_xy(const Point_data *a, const Point_data *b) const { Comparison_result c = traits().compare_x_2_object() (a->p.x_part, b->p.x_part); if(c == LARGER) { return true; } else if (c == EQUAL) { return traits().less_y_2_object()(b->p.y_part, a->p.y_part); } return false; } bool larger_yx(const Point_data *a, const Point_data *b) const { Comparison_result c = traits().compare_y_2_object() (a->p.y_part, b->p.y_part); if(c == LARGER) { return true; } else if (c == EQUAL) { return traits().less_x_2_object()(b->p.x_part, a->p.x_part); } return false; } // the next sets store the points sorted Point_data_set_of_x x_sorted; Point_data_set_of_y y_sorted; Less_xy_internal_point less_xy_point; Less_yx_internal_point less_yx_point; // bottom left and top right points of the bounding box Point bl_p, tr_p; // the bounding box of the points Iso_rectangle_2 bbox_p; // the points that define the largest empty iso-rectangle Point left_p, bottom_p, right_p ,top_p; // save the largest empty rectangle size found by now NT largest_rect_size; // insert points bool insert(const Point& _p,Point_type i_type); bool insert(const Point_2& _p,Point_type i_type); /* the phases of the algorithm as described in the paper */ void phase_1(); // the first phase is divided to work on the x-axis and work on the y-axis void phase_1_on_x(); void phase_1_on_y(); // the second phase is divided to four parts, // one for each edge of the bounding box void phase_2_on_bot(); void phase_2_on_top(); void phase_2_on_left(); void phase_2_on_right(); void phase_2(); void phase_3(); // the next functions are used by the functions of the three phases void check_for_larger(const Point& px0, const Point& py0, const Point& px1, const Point& py1); void tent(Point_data *first, Point_data *second); void tent(Point_data *first, Point_data *second, Point_data *third); void get_next_for_top(typename std::list::iterator &iter, typename std::list::iterator &beyond) { while(iter != beyond && ((*iter)->type == BOT_RIGHT || (*iter)->type == BOT_LEFT)) ++iter; } void get_prev_for_top(typename std::list::iterator &iter) { while((*iter)->type == BOT_RIGHT || (*iter)->type == BOT_LEFT) --iter; } void get_next_for_bot(typename std::list::iterator &iter, typename std::list::iterator &beyond) { while(iter != beyond && ((*iter)->type == TOP_LEFT || (*iter)->type == TOP_RIGHT)) ++iter; } void get_prev_for_bot(typename std::list::iterator &iter) { while((*iter)->type == TOP_LEFT || (*iter)->type == TOP_RIGHT) --iter; } void get_next_for_bot(typename Point_data_set_of_y::iterator &iter) { while((*iter)->type == TOP_LEFT || (*iter)->type == TOP_RIGHT) ++iter; } void get_next_for_bot(typename Point_data_set_of_y::iterator &iter, typename Point_data_set_of_y::iterator &last) { while(iter != last && ((*iter)->type == TOP_LEFT || (*iter)->type == TOP_RIGHT)) ++iter; } void get_prev_for_bot(typename Point_data_set_of_y::iterator &iter) { while((*iter)->type == TOP_LEFT || (*iter)->type == TOP_RIGHT) --iter; } void get_next_for_left(typename std::list::iterator &iter, typename std::list::iterator &beyond) { while(iter != beyond && ((*iter)->type == BOT_RIGHT || (*iter)->type == TOP_RIGHT)) ++iter; } void get_prev_for_left(typename std::list::iterator &iter) { while((*iter)->type == BOT_RIGHT || (*iter)->type == TOP_RIGHT) --iter; } void get_next_for_right(typename std::list::iterator &iter, typename std::list::iterator &beyond) { while(iter != beyond && ((*iter)->type == BOT_LEFT || (*iter)->type == TOP_LEFT)) ++iter; } void get_prev_for_right(typename std::list::iterator &iter) { while((*iter)->type == BOT_LEFT || (*iter)->type == TOP_LEFT) --iter; } void determine_first_two_iters(typename Point_data_set_of_y::iterator &iter1, typename Point_data_set_of_y::iterator &iter2, typename Point_data_set_of_y::iterator &iter3, bool &first_iter_is_right, bool &second_iter_is_right, bool &third_iter_is_right) { if(first_iter_is_right) { if(second_iter_is_right) { iter1 = iter2; iter2 = iter3; first_iter_is_right = second_iter_is_right; second_iter_is_right = third_iter_is_right; } else { if(third_iter_is_right) { iter1 = iter2; iter2 = iter3; first_iter_is_right = second_iter_is_right; second_iter_is_right = third_iter_is_right; } else { iter2 = iter3; second_iter_is_right = third_iter_is_right; } } } else { if(second_iter_is_right) { if(third_iter_is_right) { iter2 = iter3; second_iter_is_right = third_iter_is_right; } else { iter1 = iter2; iter2 = iter3; first_iter_is_right = second_iter_is_right; second_iter_is_right = third_iter_is_right; } } else { iter1 = iter2; iter2 = iter3; first_iter_is_right = second_iter_is_right; second_iter_is_right = third_iter_is_right; } } } void determine_next_iter( typename Point_data_set_of_y::iterator &iter, typename Point_data_set_of_y::iterator &right_iter, typename Point_data_set_of_y::iterator &left_iter, typename Point_data_set_of_y::const_iterator right_iter_end, typename Point_data_set_of_y::const_iterator left_iter_end, bool &iter_is_right, bool &exist) { if((typename Point_data_set_of_y::const_iterator)right_iter != right_iter_end) { if((typename Point_data_set_of_y::const_iterator)left_iter != left_iter_end) { if(less_yx(*right_iter, *left_iter)) { iter = right_iter; iter_is_right = true; ++right_iter; } else { iter = left_iter; iter_is_right = false; ++left_iter; } } else { iter = right_iter; iter_is_right = true; ++right_iter; } } else { if((typename Point_data_set_of_y::const_iterator)left_iter != left_iter_end) { iter = left_iter; iter_is_right = false; ++left_iter; } else exist = false; } } void calls_for_tents(typename Point_data_set_of_y::iterator iter1, typename Point_data_set_of_y::iterator iter2) { if(less_xy(*iter1, *iter2)) tent(*iter1,*iter2); else tent(*iter2,*iter1); } void calls_for_tents(typename Point_data_set_of_y::iterator iter1, typename Point_data_set_of_y::iterator iter2, typename Point_data_set_of_y::iterator iter3) { bool first_is_right_to_second = less_xy(*iter1, *iter2); bool second_is_right_to_third = less_xy(*iter2, *iter3); if(first_is_right_to_second) { if(second_is_right_to_third) { tent(*iter1,*iter2); tent(*iter2,*iter3); } else { tent(*iter1,*iter3,*iter2); } } else { if(second_is_right_to_third) { tent(*iter2,*iter3,*iter1); } else { tent(*iter2,*iter1); tent(*iter3,*iter2); } } } void phase_2_update_y_sorted_list(); void phase_3_check_for_larger(typename Point_data_set_of_y::iterator iter, typename Point_data_set_of_y::iterator iter1, typename Point_data_set_of_y::iterator iter2, typename Point_data_set_of_y::iterator iter3, bool first_iter_is_right, bool second_iter_is_right) { if(first_iter_is_right) { if(!second_iter_is_right) check_for_larger((*iter2)->p, (*iter)->p, (*iter1)->p, (*iter3)->p); } else if(second_iter_is_right) check_for_larger((*iter1)->p,(*iter)->p,(*iter2)->p,(*iter3)->p); } void empty_tents(); // call the computation of the largest empty rectangle . void update(); // init class. void init(const Point_2& bl, const Point_2& tr); void copy_memory(const Largest_empty_iso_rectangle_2& ler); void free_memory(); // add a point to data bool insert(const Point& p); // Auxiliary iterators for convenience }; template struct Delete { void operator()(Ptr ptr)const { delete(ptr); } }; template void Largest_empty_iso_rectangle_2::free_memory() { std::for_each(x_sorted.begin(), x_sorted.end(), Delete()); x_sorted.clear(); y_sorted.clear(); } template Largest_empty_iso_rectangle_2::~Largest_empty_iso_rectangle_2() { free_memory(); } template void Largest_empty_iso_rectangle_2:: copy_memory(const Largest_empty_iso_rectangle_2& ler) { // copy bounding box bl_p = ler.bl_p; tr_p = ler.tr_p; bbox_p = ler.bbox_p; // copy points for(typename Point_data_set_of_x::const_iterator iter = ler.x_sorted.begin(); iter != ler.x_sorted.end(); ++iter) { if((*iter)->type == REG) insert((*iter)->p); else insert((*iter)->p,(*iter)->type); } } template Largest_empty_iso_rectangle_2& Largest_empty_iso_rectangle_2::operator =( const Largest_empty_iso_rectangle_2& ler) { if(this != &ler) { free_memory(); copy_memory(ler); } return *this; } template Largest_empty_iso_rectangle_2:: Largest_empty_iso_rectangle_2( const Largest_empty_iso_rectangle_2& ler) : cache_valid(false), _gt(), x_sorted(Less_xy(traits())), y_sorted(Less_yx(traits())), less_xy_point(traits()), less_yx_point(traits()) { copy_memory(ler); } template bool Largest_empty_iso_rectangle_2::insert(const Point_2& _p) { // check that the point is inside the bounding box if(bbox_p.has_on_unbounded_side(_p)) { return(false); } return(insert(Point(_p))); } template bool Largest_empty_iso_rectangle_2::insert(const Point& _p) { // check that the point is not already inserted Point_data po(_p); typename Point_data_set_of_x::iterator iter = x_sorted.find(&po); if(iter != x_sorted.end()) return(false); cache_valid = false; Point_data_set_of_y *right_tent = new Point_data_set_of_y(Less_yx(traits())); Point_data_set_of_y *left_tent = new Point_data_set_of_y(Less_yx(traits())); Point_data * ppo = new Point_data(_p,right_tent,left_tent,REG); x_sorted.insert(ppo); y_sorted.insert(ppo); return(true); } template bool Largest_empty_iso_rectangle_2::remove(const Point& _p) { cache_valid = false; Point_data po(_p); typename Point_data_set_of_x::iterator iter1 = x_sorted.find(&po); typename Point_data_set_of_y::iterator iter2 = y_sorted.find(&po); // point does not exist or a corner point if(iter1 == x_sorted.end() || (*iter1)->type != REG) return(false); delete((*iter1)->right_tent); delete((*iter2)->left_tent); x_sorted.erase(iter1); y_sorted.erase(iter2); return(true); } template bool Largest_empty_iso_rectangle_2::insert(const Point_2& _p, Point_type i_type) { // check that the point is inside the bounding box if((i_type == REG) && bbox_p.has_on_unbounded_side(_p)) { return false; } return(insert(Point(_p),i_type)); } template bool Largest_empty_iso_rectangle_2::insert(const Point& _p, Point_type i_type) { // check that the point is not already inserted Point_data po(_p); typename Point_data_set_of_x::iterator iter = x_sorted.find(&po); if(iter != x_sorted.end()) return(false); cache_valid = false; Point_data_set_of_y *right_tent = new Point_data_set_of_y(Less_yx(traits())); Point_data_set_of_y *left_tent = new Point_data_set_of_y(Less_yx(traits())); Point_data *ppo = new Point_data(_p,right_tent,left_tent,i_type); x_sorted.insert(ppo); y_sorted.insert(ppo); return(true); } template void Largest_empty_iso_rectangle_2::check_for_larger(const Point& px0, const Point& py0, const Point& px1, const Point& py1) { bool do_check = true; // check if the rectangle represented by the parameters is larger //than the current one Iso_rectangle_2 rec(less_xy_point(px0,px1) ? px0.x_part : px1.x_part, less_xy_point(px0,px1) ? px1.x_part : px0.x_part, less_yx_point(py0,py1) ? py0.y_part : py1.y_part, less_yx_point(py0,py1) ? py1.y_part : py0.y_part); NT rect_size = rec.area(); if(do_check && rect_size > largest_rect_size) { largest_rect_size = rect_size; left_p = px0; bottom_p = py0; right_p = px1; top_p = py1; } } template void Largest_empty_iso_rectangle_2::phase_1_on_x() { typename Point_data_set_of_x::const_iterator iter = x_sorted.begin(), last_iter = x_sorted.end(), prev_iter = iter; ++iter; // filter false points while((*iter)->type == TOP_RIGHT || (*iter)->type == TOP_LEFT) { ++iter; ++prev_iter; } // traverse over all possibilities for finding a larger empty rectangle // rectangles here touch the top and the buttom of the bounding box while(iter != last_iter) { // filter false points if((*iter)->type != TOP_RIGHT && (*iter)->type != TOP_LEFT) { check_for_larger((*prev_iter)->p, bl_p, (*iter)->p, tr_p); prev_iter = iter; } ++iter; } } template void Largest_empty_iso_rectangle_2::phase_1_on_y() { typename Point_data_set_of_y::const_iterator iter = y_sorted.begin(), last_iter = y_sorted.end(), prev_iter = iter; ++iter; // filter false points while((*iter)->type == BOT_RIGHT || (*iter)->type == TOP_RIGHT) { ++iter; ++prev_iter; } // traverse over all possibilities for finding a larger empty rectangle // rectangles here touch the left and the right of the bounding box while(iter != last_iter) { // filter false points if((*iter)->type != BOT_RIGHT && (*iter)->type != TOP_RIGHT) { check_for_larger(bl_p, (*prev_iter)->p, tr_p, (*iter)->p); prev_iter = iter; } ++iter; } } template void Largest_empty_iso_rectangle_2::phase_1() { phase_1_on_x(); phase_1_on_y(); } template void Largest_empty_iso_rectangle_2::tent(Point_data *first, Point_data *second) { if(less_yx(first, second)) first->right_tent->insert(second); else second->left_tent->insert(first); } template void Largest_empty_iso_rectangle_2::tent(Point_data *first, Point_data *second, Point_data *third) { first->right_tent->insert(second); third->left_tent->insert(second); if(less_yx(first, third)) first->right_tent->insert(third); else third->left_tent->insert(first); } template void Largest_empty_iso_rectangle_2::phase_2_on_bot() { std::list Point_data_list; std::copy(x_sorted.begin(), x_sorted.end(), std::back_inserter(Point_data_list)); typename std::list::iterator iter1 = Point_data_list.begin(), iter2,iter3,first_iter, beyond = Point_data_list.end(); int points_removed = 0, size = Point_data_list.size(); get_next_for_bot(iter1,beyond); first_iter = iter1; iter2 = iter1; ++iter2; get_next_for_bot(iter2,beyond); iter3 = iter2; ++iter3; get_next_for_bot(iter3,beyond); while(size - 4 > points_removed && iter3 != Point_data_list.end()) { if(less_yx(*iter1, *iter2) && larger_yx(*iter2, *iter3)) { check_for_larger((*iter1)->p, bl_p, (*iter3)->p, (*iter2)->p); tent(*iter1,*iter2,*iter3); ++points_removed; Point_data_list.erase(iter2); if(iter1 != first_iter) { iter2 = iter1; --iter1; get_prev_for_bot(iter1); } else { iter2 = iter3; ++iter3; get_next_for_bot(iter3,beyond); } } else {// iter3 can't be last iter1 = iter2; iter2 = iter3; ++iter3; get_next_for_bot(iter3,beyond); } } } template void Largest_empty_iso_rectangle_2::phase_2_on_top() { std::list Point_data_list; std::copy(x_sorted.begin(), x_sorted.end(), std::back_inserter(Point_data_list)); typename std::list::iterator iter1 = Point_data_list.begin(), iter2, iter3, first_iter, beyond = Point_data_list.end(); int points_removed = 0, size = Point_data_list.size(); get_next_for_top(iter1,beyond); iter2 = iter1; first_iter = iter1; ++iter2; get_next_for_top(iter2,beyond); iter3 = iter2; ++iter3; get_next_for_top(iter3,beyond); while(size - 4 > points_removed && iter3 != Point_data_list.end()) { if(larger_yx(*iter1, *iter2) && less_yx(*iter2, *iter3)) { check_for_larger((*iter1)->p,tr_p, (*iter3)->p,(*iter2)->p); ++points_removed; Point_data_list.erase(iter2); if(iter1 != first_iter) { iter2 = iter1; --iter1; get_prev_for_top(iter1); } else { iter2 = iter3; ++iter3; get_next_for_top(iter3,beyond); } } else {// iter3 can't be last iter1 = iter2; iter2 = iter3; ++iter3; get_next_for_top(iter3,beyond); } } } template void Largest_empty_iso_rectangle_2::phase_2_on_left() { std::list Point_data_list; std::copy(y_sorted.begin(), y_sorted.end(), std::back_inserter(Point_data_list)); typename std::list::iterator iter1 = Point_data_list.begin(), iter2, iter3, first_iter, beyond = Point_data_list.end(); int points_removed = 0, size = Point_data_list.size(); get_next_for_left(iter1,beyond); first_iter = iter1; iter2 = iter1; ++iter2; get_next_for_left(iter2,beyond); iter3 = iter2; ++iter3; get_next_for_left(iter3,beyond); while(size - 4 > points_removed && iter3 != Point_data_list.end()) { if(less_xy(*iter1, *iter2) && larger_xy(*iter2, *iter3)) { check_for_larger(bl_p, (*iter1)->p, (*iter2)->p, (*iter3)->p); ++points_removed; Point_data_list.erase(iter2); if(iter1 != first_iter) { iter2 = iter1; --iter1; get_prev_for_left(iter1); } else { iter2 = iter3; ++iter3; get_next_for_left(iter3,beyond); } } else {// iter3 can't be last iter1 = iter2; iter2 = iter3; ++iter3; get_next_for_left(iter3,beyond); } } } template void Largest_empty_iso_rectangle_2::phase_2_on_right() { std::list Point_data_list; std::copy(y_sorted.begin(), y_sorted.end(), std::back_inserter(Point_data_list)); typename std::list::iterator iter1 = Point_data_list.begin(), iter2, iter3, first_iter, beyond = Point_data_list.end(); int points_removed = 0,size = Point_data_list.size(); get_next_for_right(iter1,beyond); first_iter = iter1; iter2 = iter1; ++iter2; get_next_for_right(iter2,beyond); iter3 = iter2; ++iter3; get_next_for_right(iter3,beyond); while(size - 4 > points_removed && iter3 != Point_data_list.end()) { if(larger_xy(*iter1, *iter2) && less_xy(*iter2, *iter3)) { check_for_larger((*iter2)->p, (*iter1)->p, tr_p, (*iter3)->p); ++points_removed; Point_data_list.erase(iter2); if(iter1 != first_iter) { // move back iter2 = iter1; --iter1; get_prev_for_right(iter1); } else { iter2 = iter3; ++iter3; get_next_for_right(iter3,beyond); } } else {// iter3 can't be last iter1 = iter2; iter2 = iter3; ++iter3; get_next_for_right(iter3,beyond); } } } template void Largest_empty_iso_rectangle_2::phase_2() { phase_2_on_top(); phase_2_on_left(); phase_2_on_right(); // Done only for building tents for phase 3 phase_2_on_bot(); } template void Largest_empty_iso_rectangle_2::phase_3() { bool first_iter_is_right, second_iter_is_right, third_iter_is_right, first_exist,second_exist,third_exist; typename Point_data_set_of_y::iterator iter, last_iter = y_sorted.end(); typename Point_data_set_of_y::iterator iter1, iter2, iter3, right_iter, left_iter, last = last_iter; --last_iter; --last_iter; for(iter = y_sorted.begin();iter != last_iter;++iter) { get_next_for_bot(iter,last); if(iter == last) return; first_exist = true; second_exist = true; third_exist = true; right_iter = (*iter)->right_tent->begin(); left_iter = (*iter)->left_tent->begin(); determine_next_iter(iter1, right_iter, left_iter, (*iter)->right_tent->end(), (*iter)->left_tent->end(), first_iter_is_right, first_exist); determine_next_iter(iter2,right_iter,left_iter, (*iter)->right_tent->end(), (*iter)->left_tent->end(), second_iter_is_right, second_exist); determine_next_iter(iter3, right_iter, left_iter, (*iter)->right_tent->end(), (*iter)->left_tent->end(), third_iter_is_right, third_exist); bool had_three = false; while(third_exist) { had_three = true; phase_3_check_for_larger(iter, iter1, iter2, iter3, first_iter_is_right, second_iter_is_right); calls_for_tents(iter1, iter2, iter3); determine_first_two_iters(iter1, iter2, iter3, first_iter_is_right, second_iter_is_right, third_iter_is_right); determine_next_iter(iter3, right_iter,left_iter, (*iter)->right_tent->end(), (*iter)->left_tent->end(), third_iter_is_right, third_exist); } if(!had_three && second_exist) calls_for_tents(iter1, iter2); } } template void Largest_empty_iso_rectangle_2::empty_tents() { for(typename Point_data_set_of_x::const_iterator iter = x_sorted.begin(); iter != x_sorted.end(); ++iter) { (*iter)->right_tent->clear(); (*iter)->left_tent->clear(); } } template typename Largest_empty_iso_rectangle_2::Iso_rectangle_2 Largest_empty_iso_rectangle_2::get_bounding_box() { return bbox_p; } /* Performs the computation if the cache is invalid. * */ template void Largest_empty_iso_rectangle_2::update() { if(! cache_valid){ largest_rect_size = 0; phase_1(); phase_2(); phase_3(); empty_tents(); cache_valid = true; } } template typename Largest_empty_iso_rectangle_2::Iso_rectangle_2 Largest_empty_iso_rectangle_2::get_largest_empty_iso_rectangle() { if(x_sorted.size() == 4) { return(get_bounding_box()); } update(); return(Iso_rectangle_2( less_xy_point(left_p.x_part,right_p.x_part) ? left_p.x_part : right_p.x_part, less_xy_point(left_p.x_part,right_p.x_part) ? right_p.x_part : left_p.x_part, less_yx_point(bottom_p.x_part,top_p.x_part) ? bottom_p.y_part : top_p.y_part, less_yx_point(bottom_p.x_part,top_p.x_part) ? top_p.y_part : bottom_p.y_part)); } template void Largest_empty_iso_rectangle_2::init(const Point_2& bl, const Point_2& tr) { // determine extreme values of bounding box bbox_p = Iso_rectangle_2(bl,tr); // add extreme points insert(bbox_p.vertex(0), BOT_LEFT); insert(bbox_p.vertex(1), BOT_RIGHT); insert(bbox_p.vertex(3), TOP_LEFT); insert(bbox_p.vertex(2), TOP_RIGHT); } // ctor template Largest_empty_iso_rectangle_2::Largest_empty_iso_rectangle_2( const Point_2& bl, const Point_2& tr) : cache_valid(false), _gt(), x_sorted(Less_xy(traits())), y_sorted(Less_yx(traits())), less_xy_point(traits()), less_yx_point(traits()), bl_p(bl), tr_p(tr) { // precondition: bl and tr init(bl, tr); } // ctor template Largest_empty_iso_rectangle_2::Largest_empty_iso_rectangle_2( const Iso_rectangle_2 &b) : cache_valid(false), _gt(), x_sorted(Less_xy(traits())), y_sorted(Less_yx(traits())), less_xy_point(traits()), less_yx_point(traits()), bl_p(b.min()), tr_p(b.max()) { init(b.min(), b.max()); } // ctor template Largest_empty_iso_rectangle_2::Largest_empty_iso_rectangle_2() : cache_valid(false), _gt(), x_sorted(Less_xy(traits())), y_sorted(Less_yx(traits())), less_xy_point(traits()), less_yx_point(traits()) { Point bl(0,0); Point tr(1,1); init(bl.x_part,tr.x_part); } template typename Largest_empty_iso_rectangle_2::const_iterator Largest_empty_iso_rectangle_2::begin() const { typename Point_data_set_of_x::const_iterator i = x_sorted.begin(); while(i != x_sorted.end() && (*i)->type != REG) ++i; return const_iterator(i); } template typename Largest_empty_iso_rectangle_2::const_iterator Largest_empty_iso_rectangle_2::end() const { typename Point_data_set_of_x::const_iterator i = x_sorted.end(); while(--i != x_sorted.begin() && (*i)->type != REG); if((*i)->type != REG) // The points list is actually empty. Point to end() to make // begin() == end() i = x_sorted.end(); else // increment i to make it point to a corner point ++i; return const_iterator(i); } template void Largest_empty_iso_rectangle_2::clear() { cache_valid = false; for(typename Point_data_set_of_x::iterator iter = x_sorted.begin(); iter != x_sorted.end(); ++iter) delete(*iter); x_sorted.clear(); y_sorted.clear(); // add extreme points insert(bbox_p.vertex(0), BOT_LEFT); insert(bbox_p.vertex(1), BOT_RIGHT); insert(bbox_p.vertex(3), TOP_LEFT); insert(bbox_p.vertex(2), TOP_RIGHT); } CGAL_END_NAMESPACE #endif // CGAL_LARGEST_EMPTY_ISO_RECTANGLE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Filter_construction.h0000644000175000017500000001761511344301500031242 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Filter_construction.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_FILTER_CONSTRUCTION_H #define CGAL_FILTER_CONSTRUCTION_H #include #include CGAL_BEGIN_NAMESPACE template class Lazy_construct; // Abstract base representation class template struct Lazy_construct_rep : public Rep { AT app; // could be const, except for rafinement ? or mutable ? ET *et; Lazy_construct_rep () : app(), et(NULL) {} const AT& approx() const { return app; } const ET& exact() { if (et==NULL) update_exact(); return *et; } // virtual void update_approx() = 0; // Not used anymore... at the moment :) virtual void update_exact() = 0; virtual ~Lazy_construct_rep () {}; }; // Ref class for a geometric class, corresponding to a given construction. template struct Lazy_construct : public Lazy_construct_rep { Lazy_construct () {} // ? // So : we want the interval computation to be try/Protect/catch. // We want the exact computation to be lazy, triggered by the above initial // construction, or later triggered externally by a predicate (called via // update_exact(). BUT, update_exact() needs to know which exact // construction to call, that is, which operator() to call. For a given // type, there can be several with different number of arguments, or types // of arguments. We must have a construct for the original exact data, // which recursively provides the exact original exact data. // This is not trivial, as we need to store pointers to the arguments, which // number and types are variable, and do not depend only on the type of the // construction object exact/approx which is called. // Is it doable dynamically ? Or maybe we need something else which is // triggered when operator() is called at top-level, which selects the // actual return type, templated by the argument passed... // A bit more complexity... template operator()(const A1 &a1) const { try { } catch (IA::unsafe_comparison) { update_exact(); rafine(); } } void update_approx() { in = min(op1.approx(), op2.approx()); } void update_exact() { et = new ET(min(op1.exact(), op2.exact())); } }; // This template class is a wrapper that implements the filtering for all // constructions (dynamic filters with IA). template class Filtered_construction { EC Exact_construction; AC Approx_construction; ECv To_Exact; ACv To_Approx; public: // Here's another subtle part (virtual class hierarchy) : typedef Handle___construct<...> result_type; // FIXME Filtered_construction() {} result_type operator()() const // FIXME : makes sense ? { try { Protect_FPU_rounding P; return Approx_construction(); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(); } } template result_type operator()(const A1 &a1) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1)); } } template result_type operator()(const A1 &a1, const A2 &a2) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1), To_Approx(a2)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1), To_Exact(a2)); } } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1), To_Approx(a2), To_Approx(a3)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3)); } } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4)); } } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5)); } } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5), To_Approx(a6)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5), To_Exact(a6)); } } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7) const { try { Protect_FPU_rounding P; return Approx_construction(To_Approx(a1), To_Approx(a2), To_Approx(a3), To_Approx(a4), To_Approx(a5), To_Approx(a6), To_Approx(a7)); } catch (Interval_nt_advanced::unsafe_comparison) { Protect_FPU_rounding P(CGAL_FE_TONEAREST); return Exact_construction(To_Exact(a1), To_Exact(a2), To_Exact(a3), To_Exact(a4), To_Exact(a5), To_Exact(a6), To_Exact(a7)); } } // Idem for more than 7 arguments. Do it on demand. }; CGAL_END_NAMESPACE #endif // CGAL_FILTER_CONSTRUCTION_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/generic_sweep.h0000644000175000017500000001420111344301500030006 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/generic_sweep.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_GENERIC_SWEEP_H #define CGAL_GENERIC_SWEEP_H /*{\Moptions print_title=yes}*/ /*{\Moptions section=subsection}*/ #include namespace CGAL { /*{\Manpage {generic_sweep}{T}{A Generic Plane Sweep Framework}{PS}}*/ template class generic_sweep { typedef generic_sweep Self; /*{\Mdefinition The data type |\Mname| provides a general framework for algorithms following the plane sweep paradigm. The plane sweep paradigm can be described as follows. A vertical line sweeps the plane from left to right and constructs the desired output incrementally left behind the sweep line. The sweep line maintains knowledge of the scenery of geometric objects and stops at points where changes of this knowledge relevant for the output occur. These points are called events. A general plane sweep framework structures the execution of the sweep into phases and provides a storage place for all data structures necessary to execute the sweep. An object |\Mvar| of type |\Mname| maintains an object of type |T| which generally can be used to store necessary structures. The content is totally dependent of the sweep specification and thereby varies within the application domain of the framework. The traits class |T| has to provide a set of types which define the input/output interface of the sweep: the input type |INPUT|, the output type |OUTPUT|, and a geometry kernel type |GEOMETRY|. The natural phases which determine a sweep are \begin{Mverb} // INITIALIZATION initialize_structures(); check_invariants(); // SWEEP LOOP while ( event_exists() ) { process_event(); check_invariants(); procede_to_next_event(); } // COMPLETION complete_structures(); check_final(); \end{Mverb} \begin{description} \item[ Initialization ] -- initializing the data structures, ensuring preconditions, checking invariants \item[ Sweep Loop ] -- iterating over all events, while handling the event stops, ensuring invariants and the soundness of all data structures and maybe triggering some animation tasks. \item[ Completion ] -- cleaning up some data structures and completing the output. \end{description} The above subtasks are members of the class |T| which a model of our traits concept has to provide: \begin{Mverb} void T::initialize_structures(); bool T::event_exists(); void T::process_event(); void T::procede_to_next_event(); void T::complete_structures(); void T::check_invariants(); void T::check_final(); \end{Mverb} See specification of the traits class for |\Mname|. }*/ T traits; /*{\Mtypes 5}*/ public : typedef T TRAITS; /*{\Mtypemember the traits class}*/ typedef typename TRAITS::INPUT INPUT; /*{\Mtypemember the input interface.}*/ typedef typename TRAITS::OUTPUT OUTPUT; /*{\Mtypemember the output container.}*/ typedef typename TRAITS::GEOMETRY GEOMETRY; /*{\Mtypemember the geometry kernel.}*/ /*{\Mevents 6.5}*/ /*{\Mtext To enable animation of the sweep there are event hooks inserted which allow an observer to attach certain visualization actions to them. There are four such hooks: }*/ Event_hook post_init_hook; /*{\Mevent triggered just after initialization.}*/ Event_hook pre_event_hook; /*{\Mevent triggered just before the sweep event.}*/ Event_hook post_event_hook; /*{\Mevent triggered just after the sweep event.}*/ Event_hook post_completion_hook; /*{\Mevent triggered just after the completion phase.}*/ /*{\Mtext All of these are triggered during the sweep with the instance of the |TRAITS| class that is stored inside the plane sweep object. Thus any animation operation attached to a hook can work on that class object which maintains the sweep status.}*/ /*{\Mcreation PS}*/ generic_sweep(const INPUT& input, OUTPUT& output, const GEOMETRY& geometry = GEOMETRY()) : traits(input,output,geometry) {} /*{\Mcreate creates a plane sweep object for a sweep on objects determined by |input| and delivers the result of the sweep in |output|. The traits class |T| specifies the models of all types and the implementations of all methods used by |\Mname|. At this point, it suffices to say that |INPUT| represents the input data type and |OUTPUT| represents the result data type. The |geometry| is an object providing object bound, geometry traits access.}*/ generic_sweep(OUTPUT& output, const GEOMETRY& geometry = GEOMETRY()) : traits(output,geometry) {} /*{\Mcreate a simpler call of the above where |output| carries also the input.}*/ /*{\Moperations}*/ void sweep() /*{\Mop execute the plane sweep.}*/ { traits.initialize_structures(); traits.check_invariants(); post_init_hook(traits); while ( traits.event_exists() ) { pre_event_hook(traits); traits.process_event(); post_event_hook(traits); traits.check_invariants(); traits.procede_to_next_event(); } traits.complete_structures(); traits.check_final(); post_completion_hook(traits); } /*{\Mexample A typical sweep based on |\Mname| looks like the following little program: \begin{Mverb} typedef std::list::const_iterator iterator; typedef std::pair iterator_pair; std::list P; // fill input GRAPH G; // the output generic_sweep triangulation(iterator_pair(P.begin(),P.end()),G); triangulation.sweep(); \end{Mverb}}*/ }; // generic_sweep } // namespace CGAL #endif // CGAL_GENERIC_SWEEP_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_d.h0000644000175000017500000003147311344301500027575 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr // Bernd Gaertner #ifndef CGAL_MIN_SPHERE_D_H #define CGAL_MIN_SPHERE_D_H // Class declarations // ================== // Class interface and implementation // ================================== // includes # include # include # include # include #ifndef CGAL_PROTECT_LIST # include # define CGAL_PROTECT_LIST #endif #ifndef CGAL_PROTECT_IOSTREAM # include # define CGAL_PROTECT_IOSTREAM #endif CGAL_BEGIN_NAMESPACE template class Min_sphere_d { public: typedef typename Traits::Rep_tag Rep_tag; typedef typename Traits::RT RT; typedef typename Traits::FT FT; typedef typename Traits::Point_d Point; // Point type typedef typename Traits::Access_dimension_d Access_dimension_d; typedef typename Traits::Access_coordinates_begin_d Access_coordinates_begin_d; typedef typename Traits::Construct_point_d Construct_point_d; typedef typename std::list::const_iterator Point_iterator; typedef typename std::list::const_iterator Support_point_iterator; private: typedef typename std::list::iterator It; private: int d; // ambient dim std::list points; // keeps P = Q_n Traits tco; // traits object Optimisation_sphere_d ms_basis; // keeps miniball It support_end; // delimites S public: Min_sphere_d () : d(-1), tco( Traits()), ms_basis (tco), support_end(points.begin()) {} Min_sphere_d (const Traits& traits) : d(-1), tco( traits), ms_basis (tco), support_end(points.begin()) {} // STL-like constructor (member template) template Min_sphere_d( InputIterator first, InputIterator last) : d(-1), #if ( _MSC_VER != 1300) points( first, last), #endif tco( Traits()), ms_basis (tco) #if ( _MSC_VER != 1300) ,support_end(points.begin()) #endif { #if ( _MSC_VER == 1300) std::copy(first,last,std::back_inserter(points)); support_end = points.begin(); #endif if (points.size()>0) { d = tco.access_dimension_d_object() (points.front()); CGAL_optimisation_precondition ((d>=0) && all_points_have_dim(d)); ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } } template Min_sphere_d( InputIterator first, InputIterator last, const Traits& traits) : d(-1), #if ( _MSC_VER != 1300) points( first, last), #endif tco( traits), ms_basis (tco) #if ( _MSC_VER != 1300) ,support_end(points.begin()) #endif { #if ( _MSC_VER == 1300) std::copy(first,last,std::back_inserter(points)); support_end = points.begin(); #endif if (points.size()>0) { d = tco.access_dimension_d_object() (points.front()); CGAL_optimisation_precondition ((d>=0) && all_points_have_dim(d)); ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } } Min_sphere_d (const Min_sphere_d& msph) : d(msph.ambient_dimension()), points (msph.points_begin(), msph.points_end()), tco (msph.tco), ms_basis (tco), support_end (points.begin()) { if (d != -1) { ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } } Min_sphere_d& operator=(const Min_sphere_d& msph) { if (this != &msph) { points.erase (points.begin(), points.end()); d = msph.ambient_dimension(); points.insert (points.begin(), msph.points_begin(), msph.points_end()); ms_basis.get_sphere(Rep_tag()).set_tco(msph.tco); support_end = points.begin(); tco = msph.tco; if (d != -1) { ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } } return *this; } int number_of_points() const { return points.size(); } int number_of_support_points() const { return ms_basis.get_sphere(Rep_tag()).number_of_support_points(); } Point_iterator points_begin () const { return points.begin(); } Point_iterator points_end () const { return points.end(); } Support_point_iterator support_points_begin () const { return points.begin(); } Support_point_iterator support_points_end () const { return support_end; } int ambient_dimension () const { return d; } Point center () const { CGAL_optimisation_precondition (!is_empty()); return ms_basis.get_sphere(Rep_tag()).center(); } FT squared_radius () const { CGAL_optimisation_precondition (!is_empty()); return ms_basis.get_sphere(Rep_tag()).squared_radius(); } Bounded_side bounded_side (const Point& p) const { if (d == -1) return ON_UNBOUNDED_SIDE; else { CGAL_optimisation_precondition (d == tco.access_dimension_d_object()(p)); return (Bounded_side (-CGAL::sign (ms_basis.get_sphere(Rep_tag()).excess (p)))); } } bool has_on_bounded_side (const Point& p) const { if (d == -1) return false; else { CGAL_optimisation_precondition (d == tco.access_dimension_d_object()(p)); return (CGAL_NTS is_negative (ms_basis.get_sphere(Rep_tag()).excess (p))); } } bool has_on_unbounded_side (const Point& p) const { if (d == -1) return true; else { CGAL_optimisation_precondition (d == tco.access_dimension_d_object()(p)); return (CGAL_NTS is_positive (ms_basis.get_sphere(Rep_tag()).excess (p))); } } bool has_on_boundary (const Point& p) const { if (d == -1) return false; else { CGAL_optimisation_precondition (d == tco.access_dimension_d_object()(p)); return (CGAL_NTS is_zero (ms_basis.get_sphere(Rep_tag()).excess (p))); } } bool is_empty () const { return (d == -1); } bool is_degenerate () const { return (ms_basis.get_sphere(Rep_tag()).number_of_support_points() < 2); } void clear () { d = -1; points.erase (points.begin(), points.end()); ms_basis.get_sphere(Rep_tag()).set_size (-1); support_end = points.begin(); } // STL-like set(member template) template void set ( InputIterator first, InputIterator last) { points.erase (points.begin(), points.end()); points.insert (points.begin(), first, last); support_end = points.begin(); if (points.size()>0) { d = tco.access_dimension_d_object() (points.front()); CGAL_optimisation_precondition ((d>=0) && all_points_have_dim (d)); ms_basis.get_sphere(Rep_tag()).set_size (d); pivot_ms(); } else { d = -1; ms_basis.get_sphere(Rep_tag()).set_size (-1); } } void insert (const Point& p) { if (has_on_unbounded_side (p)) { if (is_empty()) { d = tco.access_dimension_d_object() (p); CGAL_optimisation_precondition (d>=0); ms_basis.get_sphere(Rep_tag()).set_size (d); } // ensure precondition of pivot_ms ms_basis.get_sphere(Rep_tag()).push (p); pivot_ms (); ms_basis.get_sphere(Rep_tag()).pop (); points.push_front (p); // ensure postcondition of insert } else points.push_back (p); // just append p if (support_end == points.end()) --support_end; } template void insert (InputIterator first, InputIterator last) { for (InputIterator i=first; i!=last; ++i) insert (*i); } bool is_valid (bool verbose = false, int level = 0) const { Verbose_ostream verr (verbose); // sphere verification verr << " (a) sphere verification..." << std::flush; if (ms_basis.get_sphere(Rep_tag()).is_valid (verbose)) verr << "passed." << std::endl; else return false; // containment check verr << " (b) containment check..." << std::flush; // non-support-points Point_iterator i; for (i=support_end; i!=points.end(); ++i) if (has_on_unbounded_side (*i)) return (_optimisation_is_valid_fail (verr, "sphere does not contain all points")); // support points for (i=points.begin(); i!=support_end; ++i) if (!has_on_boundary (*i)) return (_optimisation_is_valid_fail (verr, "sphere does not have all support points on boundary")); verr << "passed." << std::endl; verr << "object is valid!" << std::endl; return true; } const Traits& traits() const { return tco; } private: void mtf_ms (It k) { support_end = points.begin(); if (ms_basis.get_sphere(Rep_tag()).size_of_basis()==d+1) return; for (It i = points.begin(); i!=k;) { It j = i++; if (CGAL_NTS is_positive (ms_basis.get_sphere(Rep_tag()).excess(*j))) { ms_basis.get_sphere(Rep_tag()).push (*j); mtf_ms (j); ms_basis.get_sphere(Rep_tag()).pop(); move_to_front (j); } } } void pivot_ms () { It t = points.begin(); std::advance (t, std::min (d+1, (int)points.size())); mtf_ms (t); RT excess, e; do { excess = RT(0); It pivot; for (It i=t; i!=points.end(); ++i) { e = ms_basis.get_sphere(Rep_tag()).excess(*i); if (e > excess) { excess = e; pivot = i; } } if (CGAL_NTS is_positive (excess)) { t = support_end; if (t==pivot) ++t; // inserted from the esa code ms_basis.get_sphere(Rep_tag()).push (*pivot); mtf_ms (support_end); ms_basis.get_sphere(Rep_tag()).pop(); move_to_front (pivot); } } while (CGAL_NTS is_positive (excess)); } void move_to_front (It j) { if (support_end == j) ++support_end; points.splice (points.begin(), points, j); } bool all_points_have_dim (int dim) const { for (Point_iterator i=points.begin(); i!=points.end(); ++i) if (tco.access_dimension_d_object()(*i) != dim) return false; return true; } }; // Function declarations // ===================== // I/O // --- template < class Traits > std::ostream& operator << ( std::ostream& os, const Min_sphere_d& ms); template < class Traits > std::istream& operator >> ( std::istream& is, Min_sphere_d & ms); CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_MIN_SPHERE_D_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_traits_2.h0000644000175000017500000003133311344301500031101 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_segment_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Eyal Flato // Oren Nechushtan // Eti Ezra // Shai Hirsch // Eugene Lipovetsky // Efi Fogel // Ron Wein #ifndef CGAL_PM_SEGMENT_TRAITS_2_H #define CGAL_PM_SEGMENT_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE template class Pm_segment_traits_2 : public Kernel_ { public: typedef Kernel_ Kernel; // Categories: //#define HAS_LEFT_NOT #if !defined(HAS_LEFT_NOT) typedef Tag_true Has_left_category; #else typedef Tag_false Has_left_category; #endif //#define HAS_REFLECT #if !defined(HAS_REFLECT) typedef Tag_false Has_reflect_category; #else typedef Tag_true Has_reflect_category; #endif // Traits objects typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 X_monotone_curve_2; // Backward compatability typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; protected: // Functors: typedef typename Kernel::Compare_x_2 Compare_x_2; typedef typename Kernel::Compare_xy_2 Compare_xy_2; typedef typename Kernel::Is_vertical_2 Is_vertical_2; typedef typename Kernel::Construct_vertex_2 Construct_vertex_2; typedef typename Kernel::Less_x_2 Less_x_2; typedef typename Kernel::Equal_2 Equal_2; public: #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Kernel::compare_x_2_object; using Kernel::is_vertical_2_object; using Kernel::construct_vertex_2_object; using Kernel::compare_y_at_x_2_object; using Kernel::compare_xy_2_object; using Kernel::has_on_2_object; using Kernel::compare_slope_2_object; using Kernel::construct_point_2_object; using Kernel::construct_vector_2_object; using Kernel::equal_2_object; using Kernel::construct_opposite_segment_2_object; #endif // Creation Pm_segment_traits_2() {} // Operations // ---------- /*! compare_x() compares the x-coordinates of two given points * \param p1 the first point * \param p2 the second point * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL */ Comparison_result compare_x(const Point_2 & p1, const Point_2 & p2) const { return compare_x_2_object()(p1, p2); } /*! compare_xy() compares lexigoraphically the two points by x, then by y. * \param p1 the first point * \param p2 the second point * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL */ Comparison_result compare_xy(const Point_2 & p1, const Point_2 & p2) const { return compare_xy_2_object()(p1, p2); } /*! curve_is_vertical() * \param cv the curve * \return true iff the curve is vertical */ bool curve_is_vertical(const X_monotone_curve_2 & cv) const { return is_vertical_2_object()(cv); } /*! point_in_x_range() * \param cv the curve * \param q the point * \return true if q is in the x range of cv */ bool point_in_x_range(const X_monotone_curve_2 & cv, const Point_2 & q) const { #if 1 Compare_x_2 compare_x = compare_x_2_object(); Construct_vertex_2 construct_vertex = construct_vertex_2_object(); Comparison_result res1 = compare_x(construct_vertex(cv, 0), q); Comparison_result res2 = compare_x(construct_vertex(cv, 1), q); // We check if x(p) equals the x value of one of the end-points. // If not, we check whether one end-point is to p's left and the other is // to its right. return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); #else // \todo use this code instead, after the calls it uses are supported // in the LEDA kernel. Compare_x_2 compare_x = compare_x_2_object(); Comparison_result res1 = compare_x(cv, 0, q); Comparison_result res2 = compare_x(cv, 1, q); // We check if x(p) equals the x value of one of the end-points. // If not, we check whether one end-point is to p's left and the other is // to its right. return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); #endif } /*! curves_compare_y_at_x() compares the y-coordinate of two given curves at * the x-coordinate of a given point. * \param cv1 the first curve * \param cv2 the second curve * \param q the point * \return LARGER if cv1(x(q)) > cv2(x(q)); SMALLER if cv1(x(q)) < cv2(x(q)); * or else EQUAL. * \pre The point q is in the x range of the two curves. */ Comparison_result curves_compare_y_at_x(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { CGAL_precondition(point_in_x_range(cv1, q)); CGAL_precondition(point_in_x_range(cv2, q)); return compare_y_at_x_2_object()(q, cv1, cv2); } #if !defined(HAS_LEFT_NOT) /*! curves_compare_y_at_x_left() compares the y value of two curves in an * epsilon environment to the left of the x value of the input point * Preconditions: The point q is in the x range of the two curves, and both * of them must be also be defined to its left. The two curves must also * intersect at x(q). */ Comparison_result curves_compare_y_at_x_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curve must be defined at q and also to its left. CGAL_precondition_code( Construct_vertex_2 construct_vertex = construct_vertex_2_object(); Compare_xy_2 cmp_xy = compare_xy_2_object(); const Point_2 & source1 = construct_vertex(cv1, 0); const Point_2 & target1 = construct_vertex(cv1, 1); const Point_2 & source2 = construct_vertex(cv2, 0); const Point_2 & target2 = construct_vertex(cv2, 1); const Is_vertical_2 is_vertical = is_vertical_2_object(); ); CGAL_precondition((cmp_xy(source1, q) == SMALLER) || (cmp_xy(target1, q) == SMALLER)); CGAL_precondition((cmp_xy(source1, q) != SMALLER) || (cmp_xy(target1, q) != SMALLER)); CGAL_precondition((cmp_xy(source2, q) == SMALLER) || (cmp_xy(target2, q) == SMALLER)); CGAL_precondition((cmp_xy(source2, q) != SMALLER) || (cmp_xy(target2, q) != SMALLER)); // Since the curves are continuous, if they are not equal at q, the same // result also applies to q's left. CGAL_precondition((is_vertical(cv1) && has_on_2_object()(cv1, q)) || (is_vertical(cv2) && has_on_2_object()(cv2, q)) || (compare_y_at_x_2_object()(q, cv1, cv2) == EQUAL)); // and meet at a point with the same x-coordinate as q // compare their derivatives. return compare_slope_2_object()(cv2, cv1); } #else /*! point_reflect_in_x_and_y() reflects the given point about the origin */ Point_2 point_reflect_in_x_and_y(const Point_2 & pt) const { Point_2 org = construct_point_2_object()(ORIGIN); typename Kernel::Vector_2 v = construct_vector_2_object()(pt, org); Point_2 reflected_pt = org + v; return reflected_pt; } /*! curve_reflect_in_x_and_y reflects the given curve about the origin */ X_monotone_curve_2 curve_reflect_in_x_and_y(const X_monotone_curve_2 & cv) const { X_monotone_curve_2 reflected_cv(point_reflect_in_x_and_y(cv.source()), point_reflect_in_x_and_y(cv.target())); return reflected_cv; } #endif /*! curves_compare_y_at_x_right() compares the y value of two curves in an * epsilon environment to the right of the x value of the input point * Preconditions: The point q is in the x range of the two curves, and both * of them must be also be defined to its right. The two curves must also * intersect at x(q). */ Comparison_result curves_compare_y_at_x_right(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curve must be defined at q and also to its right. CGAL_precondition_code( Construct_vertex_2 construct_vertex = construct_vertex_2_object(); Compare_xy_2 cmp_xy = compare_xy_2_object(); const Point_2 & source1 = construct_vertex(cv1, 0); const Point_2 & target1 = construct_vertex(cv1, 1); const Point_2 & source2 = construct_vertex(cv2, 0); const Point_2 & target2 = construct_vertex(cv2, 1); ); CGAL_precondition((cmp_xy(q, source1) == SMALLER)|| (cmp_xy(q, target1) == SMALLER)); CGAL_precondition((cmp_xy(q, source1) != SMALLER) | (cmp_xy(q, target1) != SMALLER)); CGAL_precondition((cmp_xy(q, source2) == SMALLER) || (cmp_xy(q, target2) == SMALLER)); CGAL_precondition((cmp_xy(q, source2) != SMALLER) || (cmp_xy(q, target2) != SMALLER)); // Since the curves are continuous, if they are not equal at q, the same // result also applies to q's left. CGAL_precondition((is_vertical_2_object()(cv1) && has_on_2_object()(cv1, q)) || (is_vertical_2_object()(cv2) && has_on_2_object()(cv2, q)) || (compare_y_at_x_2_object()(q, cv1, cv2) == EQUAL)); // and meet at a point with the same x-coordinate as q // compare their derivatives return compare_slope_2_object()(cv1, cv2); } /*! Return the location of the given point with respect to the input curve. * \param cv The curve. * \param p The point. * \pre p is in the x-range of cv. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x (const Point_2 & p, const X_monotone_curve_2 & cv) const { CGAL_precondition(point_in_x_range(cv, p)); return compare_y_at_x_2_object()(p, cv); } /*! Check if the two curves are the same (have the same graph). * \param cv1 The first curve. * \param cv2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { Equal_2 equal = equal_2_object(); const X_monotone_curve_2 & ocv1 = construct_opposite_segment_2_object()(cv1); return equal(cv1, cv2) || equal(ocv1, cv2); } /*! Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal(const Point_2 & p1, const Point_2 & p2) const { return equal_2_object()(p1, p2); } /*! Obtain the curve source. * We return the point by value (and by reference), because the implementation * of the Construct_vertex_2 function object in undelying kernel may return * a temporary variable. * \param cv The curve. * \return The source point. */ const Point_2 curve_source(const X_monotone_curve_2 & cv) const { return construct_vertex_2_object()(cv, 0); } /*! Obtain the curve target. * We return the point by value (and by reference), because the implementation * of the Construct_vertex_2 function object in undelying kernel may return * a temporary variable. * \param cv The curve. * \return The target point. */ const Point_2 curve_target(const X_monotone_curve_2 & cv) const { return construct_vertex_2_object()(cv, 1); } }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersection_3.h0000644000175000017500000000304111344301500030117 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersection_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTION_3_H #define CGAL_INTERSECTION_3_H #include #include #include #include #include #include #include #endif // CGAL_INTERSECTION_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersections.h0000644000175000017500000000237311344301500030067 0ustar debiandebian// Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersections.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_INTERSECTIONS_H #define CGAL_INTERSECTIONS_H #include #include #endif // CGAL_INTERSECTIONS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Handle_for_virtual.h0000644000175000017500000000646611344301500031014 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Handle_for_virtual.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HANDLE_FOR_VIRTUAL_H #define CGAL_HANDLE_FOR_VIRTUAL_H #include CGAL_BEGIN_NAMESPACE class Ref_counted_virtual { public: Ref_counted_virtual() : count(1) {} Ref_counted_virtual(const Ref_counted_virtual&) : count(1) {} void add_reference() { ++count; } void remove_reference() { --count; } bool is_referenced() { return (count != 0); } bool is_shared() { return (count > 1); } virtual ~Ref_counted_virtual() {} protected: unsigned int count; }; template // RefCounted must provide // add_reference() // remove_reference() // bool is_referenced() // bool is_shared() // and initialize count to 1 in default and copy constructor class Handle_for_virtual { public: Handle_for_virtual(const RefCounted& rc) { ptr = new RefCounted(rc); } Handle_for_virtual() { ptr = NULL; } Handle_for_virtual( const Handle_for_virtual& h) { ptr = h.ptr; ptr->add_reference(); } ~Handle_for_virtual() { ptr->remove_reference(); if ( !ptr->is_referenced() ) delete ptr; } Handle_for_virtual& operator=( const Handle_for_virtual& h) { h.ptr->add_reference(); ptr->remove_reference(); if ( !ptr->is_referenced() ) delete ptr; ptr = h.ptr; return *this; } // protected: typedef RefCounted element_type; template void initialize_with( const T& rc) { ptr = new T(rc); } bool identical( const Handle_for_virtual& h) const { return ptr == h.ptr; } long int id() const { return reinterpret_cast(&*ptr); } const RefCounted * Ptr() const { return ptr; } /* T * Ptr() { copy_on_write(); return ptr; } */ /* // private: void copy_on_write() { if ( ptr->is_shared() ) { RefCounted* tmp_ptr = allocator.allocate(1); allocator.construct( tmp_ptr, *ptr); ptr->remove_reference(); ptr = tmp_ptr; } } */ protected: /* RefCounted * ptr() const { return ptr; } */ private: RefCounted * ptr; }; CGAL_END_NAMESPACE #endif // CGAL_HANDLE_FOR_VIRTUAL_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constraint_hierarchy_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constraint_hierarchy_20000644000175000017500000005074311344301500031357 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constraint_hierarchy_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Olivier Billet, Mariette Yvinec #ifndef CGAL_CONSTRAINT_HIERARCHY_2_H #define CGAL_CONSTRAINT_HIERARCHY_2_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // T is expected to be Vertex_handle // Data is intended to store info on a Vertex template class Constraint_hierarchy_2 { public: typedef std::pair H_edge; typedef T H_vertex; typedef Constraint_hierarchy_2 Hierarchy; typedef std::pair H_constraint; typedef std::list H_vertex_list; typedef std::list H_constraint_list; typedef typename std::list::iterator H_vertex_it; typedef typename std::list::iterator H_constraint_it; class H_context { friend class Constraint_hierarchy_2; private: H_vertex_list* enclosing; H_vertex_it pos; public: H_vertex_it vertices_begin() { return enclosing->begin();} H_vertex_it current() {return pos;} H_vertex_it vertices_end() {return enclosing->end();} int number_of_vertices() {return enclosing->size();} }; typedef std::list H_context_list; typedef typename std::list::iterator H_context_iterator; typedef std::map H_vertex_map; typedef std::map H_c_to_sc_map; typedef std::map H_sc_to_c_map; typedef typename H_c_to_sc_map::const_iterator H_c_iterator; typedef typename H_sc_to_c_map::const_iterator H_sc_iterator; typedef typename H_vertex_map::const_iterator H_v_iterator; typedef std::pair H_c_value; typedef std::pair H_sc_value; private: // data for the 1d hierarchy H_c_to_sc_map c_to_sc_map; H_sc_to_c_map sc_to_c_map; // data for the 0d hierarchy H_vertex_map vertex_map; public: Constraint_hierarchy_2() { } Constraint_hierarchy_2(const Constraint_hierarchy_2& ch); ~Constraint_hierarchy_2(){ clear();} void clear(); Constraint_hierarchy_2& operator=(const Constraint_hierarchy_2& ch); // Query bool is_subconstrained_edge(T va, T vb) const; bool is_constrained_edge(T va, T vb) const; bool is_constrained_vertex(T v) const; bool vertices_in_constraint(H_constraint hc, H_vertex_it& v_first, H_vertex_it& v_past) const; H_vertex_it vertices_in_constraint_begin(T va, T vb); H_vertex_it vertices_in_constraint_end(T va, T vb); bool enclosing_constraint(H_edge he, H_constraint& hc) const; bool enclosing_constraint(T vaa, T vbb, T& va, T& vb) const; bool enclosing_constraints(T vaa, T vbb, H_constraint_list& hcl) const; bool next_along_sc(T va, T vb, T& w) const; void oriented_end(T va, T vb, T& vc) const; H_context context(T va, T vb); int number_of_enclosing_constraints(T va, T vb); H_context_iterator contexts_begin(T va, T vb); H_context_iterator contexts_end(T va, T vb); int number_of_constraints() { return c_to_sc_map.size();} int number_of_subconstraints() {return sc_to_c_map.size();} // insert/remove void add_Steiner(T va, T vb, T vx); bool insert_constraint(T va, T vb); void remove_constraint(T va, T vb); void split_constraint(T va, T vb, T vc); void constrain_vertex(T v, Data data=Data()); void unconstrain_vertex(T v); void set_data(T v, Data data); Data get_data(T v); void remove_Steiner(T v, T va, T vb); // iterators H_sc_iterator sc_begin() const{ return sc_to_c_map.begin(); } H_sc_iterator sc_end() const{ return sc_to_c_map.end(); } H_c_iterator c_begin() const{ return c_to_sc_map.begin(); } H_c_iterator c_end() const{ return c_to_sc_map.end(); } H_v_iterator v_begin() const{ return vertex_map.begin(); } H_v_iterator v_end() const{ return vertex_map.end(); } //Helping functions void copy(const Constraint_hierarchy_2& ch); void copy(const Constraint_hierarchy_2& ch, std::map& vmap); void swap(Constraint_hierarchy_2& ch); private: H_edge make_edge(T va, T vb) const; H_vertex_it get_pos(T va, T vb) const; bool get_contexts(T va, T vb, H_context_iterator& ctxt, H_context_iterator& past) const; bool get_contexts(T va, T vb, H_context_list*&) const; //to_debug public: void print() const; }; template Constraint_hierarchy_2:: Constraint_hierarchy_2(const Constraint_hierarchy_2& ch) { copy(ch); } template Constraint_hierarchy_2& Constraint_hierarchy_2:: operator=(const Constraint_hierarchy_2& ch){ copy(ch); return *this; } template void Constraint_hierarchy_2:: copy(const Constraint_hierarchy_2& ch1) { // create a identity transfer vertex map std::map vmap; H_c_iterator cit1 = ch1.c_begin(); for( ; cit1 != ch1.c_end(); ++cit1) { H_vertex_it vit = cit1->second->begin(); for( ; vit != cit1->second->end(); ++vit) { vmap[*vit] = *vit; } } copy(ch1, vmap); } template void Constraint_hierarchy_2:: copy(const Constraint_hierarchy_2& ch1, std::map& vmap) // copy with a tranfer vertex map { clear(); // copy c_to_sc_map H_c_iterator cit1 = ch1.c_begin(); for( ; cit1 != ch1.c_end(); ++cit1) { H_vertex u2 = vmap[cit1->first.first]; H_vertex v2 = vmap[cit1->first.second]; H_vertex_list* hvl1 = cit1->second; H_vertex_list* hvl2 = new H_vertex_list; H_vertex_it vit = hvl1->begin(); for( ; vit != hvl1->end(); ++vit) hvl2->push_back(vmap[*vit]); c_to_sc_map[make_edge(u2,v2)] = hvl2; } // copy sc_to_c_map H_sc_iterator scit1 = ch1.sc_begin(); for( ; scit1 != ch1.sc_end(); ++scit1) { //vertices of the subconstraints H_vertex uu2 = vmap[scit1->first.first]; H_vertex vv2 = vmap[scit1->first.second]; H_context_list* hcl1 = scit1->second; H_context_list* hcl2 = new H_context_list; H_context_iterator cit1 = hcl1->begin(); for( ; cit1 != hcl1->end(); ++cit1){ // vertices of the enclosing constraints H_vertex u2 = vmap[cit1->enclosing->front()]; H_vertex v2 = vmap[cit1->enclosing->back()]; H_context ctxt2; ctxt2.enclosing = c_to_sc_map[make_edge(u2,v2)]; ctxt2.pos = ctxt2.enclosing->begin(); H_vertex_it aux = cit1->enclosing->begin(); while( aux != cit1->pos) { ++aux; ++ctxt2.pos; } hcl2->push_back(ctxt2); } sc_to_c_map[make_edge(uu2,vv2)] = hcl2; } // copy of vertex_map H_v_iterator hvit1 = ch1.vertex_map.begin(); for ( ; hvit1 != ch1.vertex_map.end(); ++hvit1){ vertex_map[vmap[hvit1->first]] = hvit1->second; } return; } template void Constraint_hierarchy_2:: swap(Constraint_hierarchy_2& ch) { c_to_sc_map.swap(ch.c_to_sc_map); sc_to_c_map.swap(ch.sc_to_c_map); vertex_map.swap(ch.vertex_map); } template bool Constraint_hierarchy_2:: is_constrained_vertex(T v) const { return( vertex_map.find(v) != vertex_map.end() ); } template bool Constraint_hierarchy_2:: is_constrained_edge(T va, T vb) const { return( c_to_sc_map.find(make_edge(va, vb)) != c_to_sc_map.end() ); } template bool Constraint_hierarchy_2:: is_subconstrained_edge(T va, T vb) const { return( sc_to_c_map.find(make_edge(va, vb)) != sc_to_c_map.end() ); } template bool Constraint_hierarchy_2:: vertices_in_constraint(H_constraint hc, H_vertex_it& v_first, H_vertex_it& v_past ) const { H_sc_iterator sc_iter = sc_to_c_map.find(hc); if( sc_iter == sc_to_c_map.end() ) return false; v_first = (*sc_iter).second; return true; } template bool Constraint_hierarchy_2:: enclosing_constraint(H_edge he, H_constraint& hc) const { H_context_iterator hcit, past; if ( !get_contexts(he.first,he.second, hcit ,past)) return false; hc = make_edge(hcit->enclosing->front(), hcit->enclosing->back()); return true; } template bool Constraint_hierarchy_2:: enclosing_constraint(T vaa, T vbb, T& va, T& vb) const { H_context_iterator hcit, past; if ( !get_contexts(vaa,vbb, hcit ,past)) return false; va = hcit->enclosing->front(); vb = hcit->enclosing->back(); return true; } template bool Constraint_hierarchy_2:: enclosing_constraints(T vaa, T vbb , H_constraint_list& hcl) const { H_context_iterator hcit, past; if ( !get_contexts(vaa,vbb, hcit ,past)) return false; for (; hcit!=past; hcit++) { hcl.push_back(make_edge(hcit->enclosing->front(), hcit->enclosing->back())); } return true; } template typename Constraint_hierarchy_2::H_context Constraint_hierarchy_2:: context(T va, T vb) { H_context_iterator hcit, past; if(!get_contexts(va,vb, hcit ,past)) CGAL_triangulation_assertion(false); return *hcit; } template int Constraint_hierarchy_2:: number_of_enclosing_constraints(T va, T vb) { H_context_list* hcl; if (! get_contexts(va,vb,hcl)) CGAL_triangulation_assertion(false); return hcl->size(); } template typename Constraint_hierarchy_2::H_context_iterator Constraint_hierarchy_2:: contexts_begin(T va, T vb) { H_context_iterator first, last; if( !get_contexts(va,vb,first,last)) CGAL_triangulation_assertion(false); return first; } template typename Constraint_hierarchy_2::H_context_iterator Constraint_hierarchy_2:: contexts_end(T va, T vb) { H_context_iterator first, last; if( !get_contexts(va,vb,first,last)) CGAL_triangulation_assertion(false); return last; } template typename Constraint_hierarchy_2::H_vertex_it Constraint_hierarchy_2:: vertices_in_constraint_begin(T va, T vb) { H_c_iterator cit = c_to_sc_map.find(make_edge(va,vb)); CGAL_triangulation_assertion( cit != c_to_sc_map.end()); return cit->second->begin(); } template typename Constraint_hierarchy_2::H_vertex_it Constraint_hierarchy_2:: vertices_in_constraint_end(T va, T vb) { H_c_iterator cit = c_to_sc_map.find(make_edge(va,vb)); CGAL_triangulation_assertion( cit != c_to_sc_map.end()); return cit->second->end(); } /* when a constraint is inserted, it is, at first, both a constraint and a subconstraint */ template bool Constraint_hierarchy_2:: insert_constraint(T va, T vb){ H_edge he = make_edge(va, vb); H_vertex_list* children = new H_vertex_list; H_context_list* fathers = new H_context_list; children->push_front(he.first); children->push_back(he.second); bool insert_ok = (c_to_sc_map.insert(std::make_pair(he,children))).second; if (insert_ok) { H_context ctxt; ctxt.enclosing = children; ctxt.pos = children->begin(); fathers->push_front(ctxt); sc_to_c_map.insert(std::make_pair(he,fathers)); return true; } delete children; delete fathers; return false; //duplicate constraint - no insertion } template void Constraint_hierarchy_2:: remove_constraint(T va, T vb){ H_edge he = make_edge(va, vb); typename H_c_to_sc_map::iterator c_to_sc_it = c_to_sc_map.find(he); CGAL_triangulation_assertion(c_to_sc_it != c_to_sc_map.end()); H_vertex_list *hvl = c_to_sc_it->second; // We have to look at all subconstraints for(H_vertex_it it = hvl->begin(), succ = it; ++succ != hvl->end(); ++it){ typename H_sc_to_c_map::iterator scit = sc_to_c_map.find(make_edge(*it,*succ)); CGAL_triangulation_assertion(scit != sc_to_c_map.end()); H_context_list* hcl = scit->second; // and remove the contraint from the context list of the subcontraint for(H_context_iterator ctit=hcl->begin(); ctit != hcl->end(); ctit++) { if(ctit->enclosing == hvl){ hcl->erase(ctit); break; } } // If this was the only context in the list, delete the context list if(hcl->empty()){ sc_to_c_map.erase(scit); delete hcl; } } c_to_sc_map.erase(c_to_sc_it); delete hvl; } template void Constraint_hierarchy_2:: constrain_vertex(T v, Data data){ vertex_map.insert(std::make_pair(v,data)); } template void Constraint_hierarchy_2:: unconstrain_vertex(T v){ vertex_map.erase(v); } template Data Constraint_hierarchy_2:: get_data(T v){ CGAL_precondition( is_constrained_vertex(v) ); return (*vertex_map.find(v)).second; } template void Constraint_hierarchy_2:: set_data(T v, Data data){ vertex_map.erase(v); vertex_map.insert(std::make_pair(v,data)); } template void Constraint_hierarchy_2:: clear() { H_c_iterator cit; H_sc_iterator scit; // clean and delete vertices lists for(cit=c_to_sc_map.begin(); cit != c_to_sc_map.end(); cit++){ (*cit).second->clear(); delete (*cit).second; } // clean and delete context lists for(scit=sc_to_c_map.begin(); scit != sc_to_c_map.end(); scit++){ (*scit).second->clear(); delete (*scit).second; } sc_to_c_map.clear(); c_to_sc_map.clear(); vertex_map.clear(); } template bool Constraint_hierarchy_2:: next_along_sc(T va, T vb, T& w) const { // find the next vertex after vb along any enclosing constrained // return false if there is no .... H_context_iterator ctxtit, past; if(!get_contexts(va, vb, ctxtit, past)) CGAL_triangulation_assertion(false); H_vertex_it pos; for( ; ctxtit != past; ctxtit++){ pos = ctxtit->pos; if((*pos)==va) { ++pos; ++pos; if (pos != ctxtit->enclosing->end()) { w=(*pos); return true;} } else { if (pos != ctxtit->enclosing->begin()) {--pos; w=(*pos); return true;} } } return false; } /* Attention, le point v DOIT etre un point de Steiner, et les segments va,v et v,vb sont des sous contraintes. */ template void Constraint_hierarchy_2:: remove_Steiner(T v, T va, T vb) { // remove a Steiner point CGAL_precondition(!is_constrained_vertex(v)); H_context_list* hcl1; H_context_list* hcl2; if(!get_contexts(va,v,hcl1)) CGAL_triangulation_assertion(false); if(!get_contexts(v,vb,hcl2)) CGAL_triangulation_assertion(false); H_vertex_it pos; for(H_context_iterator ctit=hcl1->begin(); ctit != hcl1->end(); ctit++){ pos = ctit->pos; if((*pos)==va) pos++; pos = ctit->enclosing->erase(pos); ctit->pos = --pos; } sc_to_c_map.erase(make_edge(va,v)); sc_to_c_map.erase(make_edge(v,vb)); delete hcl2; sc_to_c_map.insert(std::make_pair(make_edge(va,vb),hcl1)); } /* same as add_Steiner precondition : va,vb est une souscontrainte. */ template void Constraint_hierarchy_2:: split_constraint(T va, T vb, T vc){ add_Steiner(va, vb, vc); } template void Constraint_hierarchy_2:: add_Steiner(T va, T vb, T vc){ H_context_list* hcl; if(!get_contexts(va,vb,hcl)) CGAL_triangulation_assertion(false); H_context_list* hcl2 = new H_context_list; H_vertex_it pos; H_context ctxt; for(H_context_iterator ctit=hcl->begin(); ctit != hcl->end(); ctit++) { // insert vc in enclosing constraint pos = ctit->pos; ++pos; pos = ctit->enclosing->insert(pos, vc); --pos; // set ctxt to the context of (vc,vb) // change *ctit in hcl to the context of (va,vc) // add ctxt to hcl2 list ctxt.enclosing = ctit->enclosing; if((*pos)==va) { ctit->pos = pos; ctxt.pos = ++pos; } else { //(*pos)==vb ctxt.pos = pos; ctit->pos = ++pos; } hcl2->push_back(ctxt); } H_context_list* hcl3; if (get_contexts(va,vc,hcl3)) { // (va,vc) is already a subconstraint #ifdef __SUNPRO_CC std::copy(hcl->begin(), hcl->end(), std::back_inserter(*hcl3)); #else hcl3->splice(hcl3->end(), *hcl); #endif delete hcl; } else sc_to_c_map.insert(std::make_pair(make_edge(va,vc), hcl)); if (get_contexts(vc,vb,hcl3)) {// (vc,vb) is already a subconstraint #ifdef __SUNPRO_CC std::copy(hcl2->begin(), hcl2->end(), std::back_inserter(*hcl3)); #else hcl3->splice(hcl3->end(),*hcl2); #endif delete hcl2; } else sc_to_c_map.insert(std::make_pair(make_edge(vc,vb), hcl2)); sc_to_c_map.erase(make_edge(va,vb)); return; } template inline typename Constraint_hierarchy_2::H_edge Constraint_hierarchy_2:: make_edge(T va, T vb) const { return (va inline bool Constraint_hierarchy_2:: get_contexts(T va, T vb, H_context_list* & hcl) const { H_sc_iterator sc_iter = sc_to_c_map.find(make_edge(va,vb)); if( sc_iter == sc_to_c_map.end() ) return(false); hcl = (*sc_iter).second; return true; } template inline bool Constraint_hierarchy_2:: get_contexts(T va, T vb, H_context_iterator& ctxt, H_context_iterator& past) const { H_context_list* hcl; if (!get_contexts(va,vb,hcl)) return false; ctxt = hcl->begin(); past = hcl->end(); return true; } template inline typename Constraint_hierarchy_2::H_vertex_it Constraint_hierarchy_2:: get_pos(T va, T vb) const //return pos in the first context { return (*sc_to_c_map.find(make_edge(va,vb))).second->begin().pos; } template void Constraint_hierarchy_2:: oriented_end(T va, T vb, T& vc) const { H_context_iterator ctxt, past; if(!get_contexts(va,vb, ctxt, past) ) CGAL_triangulation_assertion(false); if(*(ctxt->pos) == va) vc = ctxt->enclosing->back(); else vc = ctxt->enclosing->front(); } template void Constraint_hierarchy_2:: print() const { H_c_iterator hcit; std::map vertex_num; int num = 0; for(hcit = c_begin(); hcit != c_end(); hcit++) { H_vertex_it vit = (*hcit).second->begin(); for (; vit != (*hcit).second->end(); vit++){ num ++; vertex_num.insert(std::make_pair((*vit), num)); } } // typename std::map::iterator vnit = vertex_num.begin(); // for(; vnit != vertex_num.end(); vnit++) { // vnit->second = ++num; // std::cerr << "vertex num " << num << " " << vnit->first->point() // << std::endl; // } H_c_iterator cit=c_begin(); H_sc_iterator scit=sc_begin(); for(; cit != c_end(); cit++){ std::cout << std::endl ; std::cout << "constraint " ; std::cout << vertex_num[cit->first.first] << " " << vertex_num[cit->first.second]; std::cout << " subconstraints " ; H_vertex_it vit = cit->second->begin(); for(; vit != cit->second->end(); vit++){ std::cout << vertex_num[*vit] <<" "; } } std::cout << std::endl ; for(;scit != sc_end(); scit++){ std::cout << "subconstraint " ; std::cout << vertex_num[scit->first.first] << " " << vertex_num[scit->first.second]; H_constraint_list hcl; enclosing_constraints( scit->first.first, scit->first.second, hcl); H_constraint_it hcit=hcl.begin(); std::cout << " enclosing " ; for(; hcit != hcl.end(); hcit++) { std::cout << vertex_num[hcit->first] <<" " << vertex_num[hcit->second] ; std::cout << " " ; } std::cout << std::endl ; } return; } CGAL_END_NAMESPACE #endif // CGAL_CONSTRAINT_HIERARCHY_2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000000353011344301500031411 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_3_H #define CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_3_H namespace CGAL { template // algorithm to use class Min_sphere_of_spheres_d_traits_3 { public: // types: typedef FT_ FT; typedef FT_ Radius; typedef typename K_::Point_3 Point; typedef std::pair Sphere; typedef typename K_::Cartesian_const_iterator_3 Cartesian_const_iterator; typedef UseSqrt_ Use_square_roots; typedef Algorithm_ Algorithm; public: // constants: static const int D = 3; // dimension public: // accessors: static inline const FT& radius(const Sphere& s) { return s.second; } static inline Cartesian_const_iterator center_cartesian_begin(const Sphere& s) { return s.first.cartesian_begin(); } }; } // namespace CGAL #endif // CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_iterators_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_itera0000644000175000017500000001254611344301501031446 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_iterators_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DS_ITERATORS_2_H #define CGAL_TRIANGULATION_DS_ITERATORS_2_H #include #include #include //#include CGAL_BEGIN_NAMESPACE template class Triangulation_ds_edge_iterator_2 { public: typedef typename Tds::Edge Edge; typedef typename Tds::Face_iterator Face_iterator; typedef typename Tds::Face_handle Face_handle; typedef Edge value_type; typedef Edge* pointer; typedef Edge& reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; typedef Triangulation_ds_edge_iterator_2 Edge_iterator; private: const Tds* _tds; Face_iterator pos; mutable Edge edge; public: Triangulation_ds_edge_iterator_2() {} Triangulation_ds_edge_iterator_2(const Tds * tds); Triangulation_ds_edge_iterator_2(const Tds* tds, int ); bool operator==(const Edge_iterator& fi) const ; bool operator!=(const Edge_iterator& fi) const {return !(*this== fi);} Edge_iterator& operator++(); Edge_iterator& operator--(); Edge_iterator operator++(int); Edge_iterator operator--(int); Edge* operator->() const; Edge& operator*() const ; private: void increment(); void decrement(); bool associated_edge(); }; // Edge iterator implementation template Triangulation_ds_edge_iterator_2 :: Triangulation_ds_edge_iterator_2(const Tds * tds) : _tds(tds) { edge.second = 0; if (_tds->dimension()<= 0) { pos = _tds->face_container().end(); // there is no edge return; } pos = _tds->face_container().begin(); if (_tds->dimension() == 1) edge.second = 2; while ( pos != _tds->face_container().end() && !associated_edge() ) increment(); } template Triangulation_ds_edge_iterator_2 :: Triangulation_ds_edge_iterator_2(const Tds * tds, int ) : _tds(tds) { pos = tds->face_container().end(); edge.second = 0; if (_tds->dimension() == 1) {edge.second = 2;} } template inline bool Triangulation_ds_edge_iterator_2 :: operator==(const Edge_iterator& fi) const { return _tds == fi._tds && pos == fi.pos && edge.second == fi.edge.second; } template inline void Triangulation_ds_edge_iterator_2 :: increment() { CGAL_triangulation_precondition(_tds->dimension() >= 1); if (_tds->dimension() == 1) ++pos; else if (edge.second == 2) {edge.second = 0; ++pos;} else edge.second += 1; return; } template inline void Triangulation_ds_edge_iterator_2 :: decrement() { CGAL_triangulation_precondition(_tds->dimension() >= 1); if (_tds->dimension() == 1) --pos; else if (edge.second == 0) { edge.second = 2; --pos;} else edge.second -= 1; return; } template inline bool Triangulation_ds_edge_iterator_2 :: associated_edge() { if (_tds->dimension() == 1) {return true;} return Face_handle(pos) < pos->neighbor(edge.second); } template inline Triangulation_ds_edge_iterator_2& Triangulation_ds_edge_iterator_2 :: operator++() { //CGAL_triangulation_precondition(pos != Iterator_base() && // pos != _tds->face_container().end()); do increment(); while( pos != _tds->face_container().end() && !associated_edge()); return *this; } template inline Triangulation_ds_edge_iterator_2& Triangulation_ds_edge_iterator_2 :: operator--() { // CGAL_triangulation_precondition(pos != Iterator_base() // && *this != Edge_iterator(_tds)); do decrement(); while ( !associated_edge() && *this != Edge_iterator(_tds) ); return *this; } template inline Triangulation_ds_edge_iterator_2 Triangulation_ds_edge_iterator_2 :: operator++(int) { Edge_iterator tmp(*this); ++(*this); return tmp; } template inline Triangulation_ds_edge_iterator_2 Triangulation_ds_edge_iterator_2 :: operator--(int) { Edge_iterator tmp(*this); --(*this); return tmp; } template inline typename Triangulation_ds_edge_iterator_2::Edge* Triangulation_ds_edge_iterator_2 :: operator->() const { edge.first = pos; return &edge; } template inline typename Triangulation_ds_edge_iterator_2::Edge& Triangulation_ds_edge_iterator_2 :: operator*() const { edge.first = pos; return edge; } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_DS_ITERATORS_2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_greene_approx_convex_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_greene_appro0000644000175000017500000010015011344301500031477 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_greene_approx_convex_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_GREENE_APPROX_H #define CGAL_GREENE_APPROX_H #include #include #include #include #include #include #include #include #include #include #include #include // These things should be constant: // front is where you add things to a chain // top chain shares its back with front (top) of stack // bottom chain shares its back with the back (bottom) of the stack // bottom of the stack has lower y value than top. // ==> chain direction is cw, make ccw polygon from front to back // and chain direction is ccw, make ccw polygon from back to front namespace CGAL { template bool is_adjacent_to(BidirectionalCirculator new_point_ref, BidirectionalCirculator old_point_ref) { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "is_adjacent_to: new_point " << *new_point_ref << " old_point " << *old_point_ref << std::endl; #endif // find the old point in original list of points if (*new_point_ref == *(++old_point_ref)) return true; // check ccw #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "is_adjacent_to: next point is " << *old_point_ref << std::endl; #endif old_point_ref--; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "is_adjacent_to: old_point is " << *old_point_ref << std::endl; #endif if (*new_point_ref == *(--old_point_ref)) return true; // check cw #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "is_adjacent_to: previous points is " << *old_point_ref << std::endl; #endif return false; } // erases vertices in the range [first, last) (counterclockwise) template void erase_vertices(BidirectionalCirculator first, BidirectionalCirculator last, Polygon& polygon, bool& update_required) { typedef typename Polygon::iterator Vertex_iterator; Vertex_iterator it = polygon.begin(); Vertex_iterator temp_it; update_required = false; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "before erasing polygon is "; for (Vertex_iterator v = polygon.begin(); v != polygon.end(); v++) { std::cout << " " << *v; } std::cout << std::endl; std::cout << "erasing from " << *first << " to " << *last << std::endl; #endif it = first.current_iterator(); CGAL_partition_assertion (it != polygon.end()); while ( (it != polygon.end()) && (*it != *last) ) { while ( (it != polygon.end()) && (*it != *last) ) { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "erase_vertices: erasing " << *it << std::endl; #endif temp_it = it; // when the beginning vertex of the polygon is deleted, all the // circulators for that polygon become invalid and must be updated. if (it == polygon.begin()) update_required = true; it++; #ifdef CGAL_GREENE_APPROX_DEBUG if (it != polygon.end()) std::cout << "erase_vertices: next vertex is " << *it << std::endl; #endif polygon.erase(temp_it); } if (it == polygon.end()) it = polygon.begin(); } // Yes, both loops here are necessary in case the range of vertices // includes the last and first points. } template void visible(Polygon& polygon, const BidirectionalCirculator& new_point_ref, Circ_pair< BidirectionalCirculator >& stack, Circ_pair< BidirectionalCirculator >& bottom_chain, Circ_pair< BidirectionalCirculator >& top_chain, OutputIterator& result, const Traits& traits) { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "visible: stack.back " << *stack.back() << " stack.before_back " << *stack.before_back() << " new_point_ref " << *new_point_ref << std::endl; #endif typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (((bottom_chain.direction() == CLOCKWISE) && right_turn(*stack.back(), *stack.before_back(), *new_point_ref)) || ((bottom_chain.direction() == COUNTERCLOCKWISE) && left_turn(*stack.back(), *stack.before_back(), *new_point_ref))) { typedef typename Traits::Polygon_2 new_Polygon_2; new_Polygon_2 new_polygon; bool done = false; bool big_angle_at_stack = false; bool is_visible = false; bool update_required; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "visible: bottom_chain.front " << *bottom_chain.front() << std::endl; #endif do { new_Polygon_2 new_polygon; stack.pop_back(); #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "visible: stack.back " << *stack.back() << std::endl; #endif if (bottom_chain.direction() == CLOCKWISE) { std::copy(bottom_chain.front(), stack.before_back(), std::back_inserter(new_polygon)); erase_vertices(bottom_chain.before_front(), stack.back(), polygon, update_required); } else { std::copy(stack.back(), bottom_chain.after_front(), std::back_inserter(new_polygon)); erase_vertices(bottom_chain.back(), bottom_chain.front(), polygon, update_required); } if (!is_degenerate_polygon_2(new_polygon.vertices_begin(), new_polygon.vertices_end(), traits)) { *result = new_polygon; result++; } bottom_chain.push_back(stack.back()); if (stack.back() == stack.front()) // form new stack with previous { // point and old stack top // (still on stack) done = true; typename Traits::Less_yx_2 less_yx = traits.less_yx_2_object(); if (less_yx(*(stack.front()),*bottom_chain.front())) { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "visible: reversing stack and swapping chains " << std::endl; #endif stack.push_front(bottom_chain.front()); // reverse stack direction stack.change_dir(); bottom_chain = top_chain; // swap chains top_chain.initialize(stack.front()); top_chain.change_dir(); #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "visible: stack is now " << *stack.back() << " " << *stack.front() << " dir " << int(stack.direction()) << std::endl; std::cout << "visible: bottom_chain is now " << *bottom_chain.back() << " " << *bottom_chain.front() << " dir " << int(bottom_chain.direction()) << std::endl; std::cout << "visible: top_chain is now " << *top_chain.back() << " " << *top_chain.front() << " dir " << int(top_chain.direction()) << std::endl; #endif } else { stack.push_back(bottom_chain.front()); bottom_chain.push_back(bottom_chain.front()); } } else // stack size must be >= 2 here { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "visible: stack.before_back " << *stack.before_back() << std::endl; #endif // angle at stack > 180 if (bottom_chain.direction() == CLOCKWISE) big_angle_at_stack = right_turn(*bottom_chain.front(), *stack.back(), *stack.before_back()); else big_angle_at_stack = left_turn(*bottom_chain.front(), *stack.back(), *stack.before_back()); if (bottom_chain.direction() == CLOCKWISE) is_visible = !right_turn(*stack.back(), *stack.before_back(), *new_point_ref); else is_visible = !left_turn(*stack.back(), *stack.before_back(), *new_point_ref); // point can see stack bottom } } while (!done && !big_angle_at_stack && !is_visible); if (big_angle_at_stack) // previous point is placed on bottom of stack { stack.push_back(bottom_chain.front()); bottom_chain.push_back(bottom_chain.front()); } } } template void stack_extend(Polygon& polygon, BidirectionalCirculator& point_ref, Circ_pair< BidirectionalCirculator >& stack, Circ_pair< BidirectionalCirculator >& top_chain, OutputIterator& result, const Traits& traits) { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "stack_extend" << std::endl; std::cout << "stack_extend: stack.before_front() " << *stack.before_front() << " stack.front " << *stack.front() << " point_ref " << *point_ref << std::endl; #endif typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (((stack.direction() == COUNTERCLOCKWISE) && right_turn(*stack.before_front(), *stack.front(), *point_ref)) || ((stack.direction() == CLOCKWISE) && left_turn(*stack.before_front(), *stack.front(), *point_ref))) { // new stack top becomes new first (and only) element of top chain stack.push_front(point_ref); top_chain.initialize(point_ref); #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "stack_extend: top_chain.front " << *top_chain.front() << std::endl; #endif } else change_top_chain(polygon, point_ref, stack, top_chain, result, traits); } template void change_top_chain(Polygon& polygon, BidirectionalCirculator new_point_ref, Circ_pair< BidirectionalCirculator >& stack, Circ_pair< BidirectionalCirculator >& top_chain, OutputIterator& result, const Traits& traits) { BidirectionalCirculator next_point_ref = new_point_ref; if (top_chain.direction() == COUNTERCLOCKWISE) next_point_ref++; else next_point_ref--; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_top_chain: top_chain.front " << *top_chain.front() << " new_point_ref " << *new_point_ref << " next_point_ref " << *next_point_ref << std::endl; #endif typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (((top_chain.direction() == COUNTERCLOCKWISE) && !right_turn(*top_chain.front(), *new_point_ref, *next_point_ref)) || ((top_chain.direction() == CLOCKWISE) && !left_turn(*top_chain.front(), *new_point_ref, *next_point_ref))) { top_chain.push_front(new_point_ref); } else { typedef typename Traits::Polygon_2 new_Polygon_2; BidirectionalCirculator old_top_ref; bool done = false; bool big_angle_at_stack = false; bool small_angle_at_point = false; bool update_required; // pop off element already on top chain old_top_ref = stack.front(); stack.pop_front(); do { new_Polygon_2 new_polygon; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_top_chain: stack.front " << *stack.front() << std::endl; #endif if (top_chain.direction() == COUNTERCLOCKWISE) { std::copy(stack.front(), next_point_ref, std::back_inserter(new_polygon)); erase_vertices(old_top_ref, new_point_ref, polygon, update_required); } else { std::copy(new_point_ref, stack.before_front(), std::back_inserter(new_polygon)); typedef typename Polygon::iterator iterator; erase_vertices(top_chain.front(), stack.front(), polygon, update_required); top_chain.push_front(stack.front()); } if (!is_degenerate_polygon_2(new_polygon.vertices_begin(), new_polygon.vertices_end(), traits)) { *result = new_polygon; result++; } if (stack.front() == stack.back()) // the "stack empty" case { done = true; stack.push_front(new_point_ref); #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_top_chain: stack is empty. New stack top is " << *stack.front() << std::endl; std::cout << "stack.back is " << *stack.back() << std::endl; std::cout << "stack.before_back is " << *stack.before_back() << std::endl; #endif top_chain.initialize(new_point_ref); // top chain should share top of stack } else // stack size must be >= 2 here { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_top_chain: stack.front " << *stack.front() << std::endl; #endif if (top_chain.direction() == COUNTERCLOCKWISE) big_angle_at_stack = !left_turn(*stack.before_front(), *stack.front(), *new_point_ref); else big_angle_at_stack = !right_turn(*stack.before_front(), *stack.front(), *new_point_ref); if (top_chain.direction() == COUNTERCLOCKWISE) small_angle_at_point = left_turn(*stack.front(), *new_point_ref, *next_point_ref); else small_angle_at_point = right_turn(*stack.front(), *new_point_ref, *next_point_ref); if (!big_angle_at_stack && !small_angle_at_point) { old_top_ref = stack.front(); stack.pop_front(); } } } while (!done && !big_angle_at_stack && !small_angle_at_point); if (big_angle_at_stack) // promote point to stack { stack.push_front(new_point_ref); top_chain.initialize(new_point_ref); // top chain shares top of stack } else if (small_angle_at_point) { top_chain.push_back(stack.front()); top_chain.push_front(new_point_ref); } } } template void change_bottom_chain(Polygon& polygon, BidirectionalCirculator new_point_ref, Circ_pair< BidirectionalCirculator >& stack, Circ_pair< BidirectionalCirculator >& bottom_chain, Circ_pair< BidirectionalCirculator >& top_chain, OutputIterator& result, const Traits& traits) { BidirectionalCirculator next_point_ref = new_point_ref; if (bottom_chain.direction() == COUNTERCLOCKWISE) next_point_ref++; else next_point_ref--; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_bottom_chain: bottom_chain.front " << *bottom_chain.front() << " new_point_ref " << *new_point_ref << " next_point_ref " << *next_point_ref << std::endl; #endif typedef typename Traits::Point_2 Point_2; typedef typename Traits::Left_turn_2 Left_turn_2; Left_turn_2 left_turn = traits.left_turn_2_object(); Turn_reverser right_turn(left_turn); if (((bottom_chain.direction() == CLOCKWISE) && !left_turn(*bottom_chain.front(), *new_point_ref, *next_point_ref)) || ((bottom_chain.direction() == COUNTERCLOCKWISE) && !right_turn(*bottom_chain.front(), *new_point_ref, *next_point_ref))) { bottom_chain.push_front(new_point_ref); } else { typedef typename Traits::Polygon_2 new_Polygon_2; bool done = false; bool small_angle_at_point = false; bool update_required; do { new_Polygon_2 new_polygon; stack.pop_back(); // remove old bottom of stack #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_bottom_chain: stack.front " << *stack.front() << " stack.back " << *stack.back() << std::endl; #endif if (bottom_chain.direction() == CLOCKWISE) { std::copy(new_point_ref, stack.before_back(), std::back_inserter(new_polygon)); erase_vertices(bottom_chain.front(), stack.back(), polygon, update_required); } else { std::copy(stack.back(), next_point_ref, std::back_inserter(new_polygon)); erase_vertices(bottom_chain.back(), new_point_ref, polygon, update_required); } if (!is_degenerate_polygon_2(new_polygon.vertices_begin(), new_polygon.vertices_end(), traits)) { *result = new_polygon; result++; } bottom_chain.initialize(stack.back()); if (stack.back() == stack.front()) // form new stack with new point { // and old stack top (still on stack) done = true; typename Traits::Less_yx_2 less_yx = traits.less_yx_2_object(); if (less_yx(*(stack.front()),*new_point_ref)) { #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_bottom_chain: reversing stack and " << "swapping chains" << std::endl; #endif stack.push_front(new_point_ref); // reverse stack direction stack.change_dir(); bottom_chain = top_chain; // swap the chains top_chain.initialize(stack.front()); top_chain.change_dir(); #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "change_bottom_chain: stack is now " << *stack.back() << " " << *stack.front() << " dir " << int(stack.direction()) << std::endl; std::cout << "change_bottom_chain: bottom_chain is now " << *bottom_chain.back() << " " << *bottom_chain.front() << " dir " << int(bottom_chain.direction()) << std::endl; std::cout << "change_bottom_chain: top_chain is now " << *top_chain.back() << " " << *top_chain.front() << " dir " << int(top_chain.direction()) << std::endl; #endif } else stack.push_back(new_point_ref); } else // stack size must be >= 2 here { // angle at new point is < 180 if (bottom_chain.direction() == CLOCKWISE) small_angle_at_point = right_turn(*stack.back(), *new_point_ref, *next_point_ref); else small_angle_at_point = left_turn(*stack.back(), *new_point_ref, *next_point_ref); } } while (!done && !small_angle_at_point); if (small_angle_at_point) { bottom_chain.push_back(stack.back()); bottom_chain.push_front(new_point_ref); } } } template void make_polygons_from_stack(Polygon& polygon, const BidirectionalCirculator& high_point_ref, Circ_pair< BidirectionalCirculator >& stack, Circ_pair< BidirectionalCirculator >& bottom_chain, OutputIterator& result, const Traits& traits) { bool update_required; // make polygons by connecting the high point to every point on the stack // except the first and the last. #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "make_polygons_from_stack: high_point_ref " << *high_point_ref << " stack.back " << *stack.back() << " stack.before_back " << *stack.before_back() << std::endl; #endif typedef typename Traits::Polygon_2 new_Polygon_2; new_Polygon_2 new_polygon; BidirectionalCirculator next_point_ref = high_point_ref; if (bottom_chain.direction() == COUNTERCLOCKWISE) next_point_ref++; stack.pop_back(); while (stack.front() != stack.back()) { new_Polygon_2 new_polygon; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "make_polygons_from_stack: stack.back " << *stack.back() << std::endl; #endif if (bottom_chain.direction() == CLOCKWISE) { std::copy(high_point_ref, stack.before_back(), std::back_inserter(new_polygon)); erase_vertices(bottom_chain.front(), stack.back(), polygon, update_required); bottom_chain.initialize(stack.back()); } else { std::copy(stack.back(), next_point_ref, std::back_inserter(new_polygon)); erase_vertices(bottom_chain.back(), high_point_ref, polygon, update_required); bottom_chain.push_back(stack.back()); } if (!is_degenerate_polygon_2(new_polygon.vertices_begin(), new_polygon.vertices_end(), traits)) { *result = new_polygon; result++; } stack.pop_back(); } // add remaining points from the top chain if there is more than one std::copy(polygon.begin(), polygon.end(), std::back_inserter(new_polygon)); if (!is_degenerate_polygon_2(new_polygon.vertices_begin(), new_polygon.vertices_end(), traits)) { *result = new_polygon; result++; } } template void find_smallest_yx(BidirectionalCirculator& first, const Traits& traits) { BidirectionalCirculator current = first; current++; // find out which direction to go typename Traits::Less_yx_2 less_yx = traits.less_yx_2_object(); if (less_yx(*current, *first)) // go foward { do { first++; current++; } while (less_yx(*current, *first)); } else { current = first; current--; if (less_yx(*current, *first)) // go backward { do { first--; current--; } while (less_yx(*current, *first)); } } // otherwise both previous and next are larger, so no need to move } template bool second_point_is_next(BidirectionalCirculator first, const Traits& traits) { BidirectionalCirculator next = first; next++; BidirectionalCirculator previous = first; previous--; typename Traits::Less_yx_2 less_yx = traits.less_yx_2_object(); return less_yx(*next, *previous); } template BidirectionalCirculator next_vertex(BidirectionalCirculator& ccw_current, BidirectionalCirculator& cw_current, const Traits& traits) { BidirectionalCirculator ccw_next = ccw_current; ccw_next++; BidirectionalCirculator cw_next = cw_current; cw_next--; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "next_vertex: ccw_next " << *ccw_next << " cw_next " << *cw_next << std::endl; #endif if (ccw_next == cw_next) { cw_current = cw_next; ccw_current = ccw_next; return cw_next; } else { typename Traits::Less_yx_2 less_yx = traits.less_yx_2_object(); if (less_yx(*ccw_next,*cw_next)) { ccw_current = ccw_next; return ccw_next; } else { cw_current = cw_next; return cw_next; } } } template void ga_convex_decomposition(ForwardIterator first, ForwardIterator beyond, OutputIterator& result, const Traits& traits) { if (first == beyond) return; typedef typename Traits::Point_2 Point_2; typedef std::list Vertex_list; typedef Circulator_from_container Vertex_circulator; Vertex_list polygon(first, beyond); CGAL_partition_precondition( orientation_2(polygon.begin(), polygon.end(), traits) == COUNTERCLOCKWISE); CGAL_partition_precondition( is_y_monotone_2(polygon.begin(), polygon.end(), traits)); Vertex_circulator point_ref(&polygon); Vertex_circulator circ = point_ref; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "before find_smallest_yx " << std::endl; do { std::cout << *circ << std::endl; } while (++circ != point_ref); #endif find_smallest_yx(point_ref, traits); circ = point_ref; #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "after find_smallest_yx " << std::endl; do { std::cout << *circ << std::endl; } while (++circ != point_ref); #endif Vertex_circulator ccw_chain_ref = point_ref; Vertex_circulator cw_chain_ref = point_ref; Circ_pair< Vertex_circulator > stack(point_ref, COUNTERCLOCKWISE); Circ_pair< Vertex_circulator > bottom_chain(point_ref, CLOCKWISE); Circ_pair< Vertex_circulator > top_chain(point_ref, COUNTERCLOCKWISE); // discover which is the direction to the next point if (second_point_is_next(point_ref, traits)) { ccw_chain_ref++; stack.push_front(ccw_chain_ref); stack.set_direction(COUNTERCLOCKWISE); top_chain.initialize(ccw_chain_ref); top_chain.set_direction(COUNTERCLOCKWISE); bottom_chain.set_direction(CLOCKWISE); } else { cw_chain_ref--; stack.push_front(cw_chain_ref); stack.set_direction(CLOCKWISE); top_chain.initialize(cw_chain_ref); top_chain.set_direction(CLOCKWISE); bottom_chain.set_direction(COUNTERCLOCKWISE); } #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "after inserting first two points: ccw_chain_ref " << *ccw_chain_ref << " cw_chain_ref " << *cw_chain_ref << std::endl; #endif while (ccw_chain_ref != cw_chain_ref) { point_ref = next_vertex(ccw_chain_ref, cw_chain_ref, traits); #ifdef CGAL_GREENE_APPROX_DEBUG std::cout << "after next_vertex: ccw_chain_ref " << *ccw_chain_ref << " cw_chain_ref " << *cw_chain_ref << std::endl; std::cout << "current point: " << *point_ref << std::endl; #endif if (is_adjacent_to(point_ref, bottom_chain.front())) visible(polygon, point_ref, stack, bottom_chain, top_chain, result, traits); if (ccw_chain_ref == cw_chain_ref) { make_polygons_from_stack(polygon, point_ref, stack, bottom_chain, result, traits); return; } if (is_adjacent_to(point_ref, stack.front())) stack_extend(polygon, point_ref, stack, top_chain, result, traits); else if (is_adjacent_to(point_ref, top_chain.front())) change_top_chain(polygon, point_ref, stack, top_chain, result, traits); else change_bottom_chain(polygon, point_ref, stack, bottom_chain, top_chain, result, traits); } } // should change this so it is like the others in that it adds diagonals // to a partition polygon and then calls partition // have to be able to go over the vertices again in order to check the // result, so they have to be stored somewhere else. template OutputIterator partition_greene_approx_convex_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { if (first == beyond) return result; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Polygon_2 Polygon_2; #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) OutputIterator res(result); #else Tee_for_output_iterator res(result); #endif // no postconditions Polygon_2 polygon(first, beyond); CGAL_partition_precondition( orientation_2(polygon.vertices_begin(), polygon.vertices_end(), traits) == COUNTERCLOCKWISE); std::list MP_list; typename std::list::iterator MP_it; y_monotone_partition_2(polygon.vertices_begin(), polygon.vertices_end(), std::back_inserter(MP_list), traits); for(MP_it = MP_list.begin(); MP_it != MP_list.end(); MP_it++) { ga_convex_decomposition((*MP_it).vertices_begin(), (*MP_it).vertices_end(), res, traits); } CGAL_partition_postcondition( convex_partition_is_valid_2(polygon.vertices_begin(), polygon.vertices_end(), res.output_so_far_begin(), res.output_so_far_end(), traits)); #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions } template inline OutputIterator partition_greene_approx_convex_2(InputIterator first, InputIterator beyond, OutputIterator result) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return partition_greene_approx_convex_2(first, beyond, result, Partition_traits_2()); } } #endif // CGAL_GREENE_APPROX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/number_utils_classes.h0000644000175000017500000001117511344301500031423 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/number_utils_classes.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // to be included by number_utils.h #ifndef CGAL_NUMBER_UTILS_CLASSES_H #define CGAL_NUMBER_UTILS_CLASSES_H 1 #include #include #include #include CGAL_BEGIN_NAMESPACE template < class NT > struct Is_zero :public CGAL_STD::unary_function< NT, bool > { typedef Arity_tag< 1 > Arity; bool operator()( const NT& x) const { return CGAL_NTS is_zero( x); } }; template < class NT > struct Is_one :public CGAL_STD::unary_function< NT, bool > { typedef Arity_tag< 1 > Arity; bool operator()( const NT& x) const { return CGAL_NTS is_one( x); } }; template < class NT > struct Is_negative :public CGAL_STD::unary_function< NT, bool > { typedef Arity_tag< 1 > Arity; bool operator()( const NT& x) const { return CGAL_NTS is_negative( x); } }; template < class NT > struct Is_positive :public CGAL_STD::unary_function< NT, bool > { typedef Arity_tag< 1 > Arity; bool operator()( const NT& x) const { return CGAL_NTS is_positive( x); } }; // Sign would result in a name clash with enum.h template < class NT > struct Sgn :public CGAL_STD::unary_function< NT, int > { typedef Arity_tag< 1 > Arity; Sign operator()( const NT& x) const { return CGAL_NTS sign( x); } }; template < class NT > struct Abs :public CGAL_STD::unary_function< NT, NT > { typedef Arity_tag< 1 > Arity; NT operator()( const NT& x) const { return CGAL_NTS abs( x); } }; template < class NT, class Compare = std::less< NT > > struct Min :public CGAL_STD::binary_function< NT, NT, NT > { typedef Arity_tag< 2 > Arity; Min() {} Min(const Compare& c_) : c(c_) {} NT operator()( const NT& x, const NT& y) const { return min( x, y, c); } protected: Compare c; }; template < class NT, class Compare = std::less< NT > > struct Max :public CGAL_STD::binary_function< NT, NT, NT > { typedef Arity_tag< 2 > Arity; Max() {} Max(const Compare& c_) : c(c_) {} NT operator()( const NT& x, const NT& y) const { return max( x, y, c); } protected: Compare c; }; template < class NT > struct Compare :public CGAL_STD::binary_function< NT, NT, Comparison_result > { typedef Arity_tag< 2 > Arity; Comparison_result operator()( const NT& x, const NT& y) const { return CGAL_NTS compare( x, y); } }; template < class NT > struct Square : public CGAL_STD::unary_function< NT, NT > { typedef Arity_tag< 1 > Arity; NT operator()( const NT& x) const { return CGAL_NTS square( x ); } }; template < class NT > struct Sqrt : public CGAL_STD::unary_function< NT, NT > { typedef Arity_tag< 1 > Arity; NT operator()( const NT& x) const { return CGAL_NTS sqrt( x ); } }; template < class NT > struct Div : public CGAL_STD::binary_function< NT, NT, NT > { typedef Arity_tag< 2 > Arity; NT operator()( const NT& x, const NT& y) const { return CGAL_NTS div( x, y ); } }; template < class NT > struct Gcd : public CGAL_STD::binary_function< NT, NT, NT > { typedef Arity_tag< 2 > Arity; NT operator()( const NT& x, const NT& y) const { return CGAL_NTS gcd( x, y ); } }; template < class NT > struct To_double : public CGAL_STD::unary_function< NT, double > { typedef Arity_tag< 1 > Arity; double operator()( const NT& x) const { return CGAL_NTS to_double( x ); } }; template < class NT > struct To_interval : public CGAL_STD::unary_function< NT, std::pair > { typedef Arity_tag< 1 > Arity; std::pair operator()( const NT& x) const { return CGAL_NTS to_interval( x ); } }; CGAL_END_NAMESPACE #endif // CGAL_NUMBER_UTILS_CLASSES_H ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Triangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Triangle_2_inter0000644000175000017500000001621011344301500031166 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2_Triangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_RAY_2_TRIANGLE_2_INTERSECTION_H #define CGAL_RAY_2_TRIANGLE_2_INTERSECTION_H #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template class Ray_2_Triangle_2_pair { public: enum Intersection_results {NO, POINT, SEGMENT}; Ray_2_Triangle_2_pair() ; Ray_2_Triangle_2_pair(typename K::Ray_2 const *ray, typename K::Triangle_2 const *trian); ~Ray_2_Triangle_2_pair() {} Intersection_results intersection_type() const; bool intersection(typename K::Point_2 &result) const; bool intersection(typename K::Segment_2 &result) const; protected: typename K::Ray_2 const* _ray; typename K::Triangle_2 const * _trian; mutable bool _known; mutable Intersection_results _result; mutable typename K::Point_2 _intersection_point; mutable typename K::Point_2 _other_point; }; template Ray_2_Triangle_2_pair:: Ray_2_Triangle_2_pair() { _known = false; _ray = 0; _trian = 0; } template Ray_2_Triangle_2_pair:: Ray_2_Triangle_2_pair(typename K::Ray_2 const *ray, typename K::Triangle_2 const *trian) { _known = false; _ray = ray; _trian = trian; } template typename Ray_2_Triangle_2_pair::Intersection_results Ray_2_Triangle_2_pair::intersection_type() const { typedef typename K::Line_2 Line_2; if (_known) return _result; // The non const this pointer is used to cast away const. _known = true; Straight_2_ straight(*_ray); Line_2 l(_trian->vertex(0), _trian->vertex(1)); if (l.oriented_side(_trian->vertex(2)) == ON_POSITIVE_SIDE) { // if (_trian->is_counterclockwise()) { straight.cut_right_off( Line_2(_trian->vertex(0), _trian->vertex(1))); straight.cut_right_off( Line_2(_trian->vertex(1), _trian->vertex(2))); straight.cut_right_off( Line_2(_trian->vertex(2), _trian->vertex(0))); } else { straight.cut_right_off( Line_2(_trian->vertex(2), _trian->vertex(1))); straight.cut_right_off( Line_2(_trian->vertex(1), _trian->vertex(0))); straight.cut_right_off( Line_2(_trian->vertex(0), _trian->vertex(2))); } switch (straight.current_state()) { case Straight_2_::EMPTY: _result = NO; return _result; case Straight_2_::POINT: { straight.current(_intersection_point); _result = POINT; return _result; } case Straight_2_::SEGMENT: { typename K::Segment_2 seg; straight.current(seg); _intersection_point = seg.source(); _other_point = seg.target(); _result = SEGMENT; return _result; } default: // should not happen. CGAL_kernel_assertion_msg(false, "Internal CGAL error."); _result = NO; return _result; } } template bool Ray_2_Triangle_2_pair:: intersection(typename K::Point_2 &result) const { if (!_known) intersection_type(); if (_result != POINT) return false; result = _intersection_point; return true; } template bool Ray_2_Triangle_2_pair:: intersection(typename K::Segment_2 &result) const { typedef typename K::Segment_2 Segment_2; if (!_known) intersection_type(); if (_result != SEGMENT) return false; result = Segment_2(_intersection_point, _other_point); return true; } template Object intersection(const typename CGAL_WRAP(K)::Ray_2 &ray, const typename CGAL_WRAP(K)::Triangle_2&tr, const K&) { typedef Ray_2_Triangle_2_pair is_t; is_t ispair(&ray, &tr); switch (ispair.intersection_type()) { case is_t::NO: default: return Object(); case is_t::POINT: { typename K::Point_2 pt; ispair.intersection(pt); return make_object(pt); } case is_t::SEGMENT: { typename K::Segment_2 iseg; ispair.intersection(iseg); return make_object(iseg); } } } template Object intersection(const typename CGAL_WRAP(K)::Triangle_2&tr, const typename CGAL_WRAP(K)::Ray_2 &ray, const K& k) { return CGALi::intersection(ray, tr, k); } template class Triangle_2_Ray_2_pair : public Ray_2_Triangle_2_pair { public: Triangle_2_Ray_2_pair( typename K::Triangle_2 const *trian, typename K::Ray_2 const *ray) : Ray_2_Triangle_2_pair(ray, trian) {} }; template inline bool do_intersect( const typename CGAL_WRAP(K)::Ray_2 &p1, const typename CGAL_WRAP(K)::Triangle_2 &p2, const K&) { typedef Ray_2_Triangle_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } template inline bool do_intersect( const typename CGAL_WRAP(K)::Triangle_2 &p1, const typename CGAL_WRAP(K)::Ray_2 &p2, const K&) { typedef Triangle_2_Ray_2_pair pair_t; pair_t pair(&p1, &p2); return pair.intersection_type() != pair_t::NO; } } // namespace CGALi template inline bool do_intersect(const Triangle_2 &tr, const Ray_2 &ray) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(ray, tr); } template inline bool do_intersect(const Ray_2 &ray, const Triangle_2 &tr) { typedef typename K::Do_intersect_2 Do_intersect; return Do_intersect()(ray, tr); } template inline Object intersection(const Ray_2 &ray, const Triangle_2 &tr) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, tr); } template inline Object intersection(const Triangle_2 &tr, const Ray_2 &ray) { typedef typename K::Intersect_2 Intersect; return Intersect()(ray, tr); } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vertex_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vertex_base0000644000175000017500000001415711344301500031270 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_vertex_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_VERTEX_BASE_H #define CGAL_HALFEDGEDS_VERTEX_BASE_H 1 #ifndef CGAL_BASIC_H #include #endif CGAL_BEGIN_NAMESPACE // We use Tag_false to indicate that no point type is provided. template < class Refs, class T = Tag_true, class P = Tag_false> class HalfedgeDS_vertex_base; template < class Refs > class HalfedgeDS_vertex_base< Refs, Tag_false, Tag_false> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_vertex_base< Refs, Tag_false, Tag_false> Base; typedef Tag_false Supports_vertex_halfedge; typedef Tag_false Supports_vertex_point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Halfedge Halfedge; typedef typename Refs::Face Face; }; template < class Refs> class HalfedgeDS_vertex_base< Refs, Tag_true, Tag_false> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_vertex_base< Refs, Tag_true, Tag_false> Base; typedef Tag_true Supports_vertex_halfedge; typedef Tag_false Supports_vertex_point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Halfedge Halfedge; typedef typename Refs::Face Face; private: Halfedge_handle hdg; public: Halfedge_handle halfedge() { return hdg; } Halfedge_const_handle halfedge() const { return hdg; } void set_halfedge( Halfedge_handle h) { hdg = h; } }; template < class Refs, class P> class HalfedgeDS_vertex_base< Refs, Tag_false, P> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_vertex_base< Refs, Tag_false, P> Base; typedef Tag_false Supports_vertex_halfedge; typedef Tag_true Supports_vertex_point; typedef P Point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Halfedge Halfedge; typedef typename Refs::Face Face; private: Point p; public: HalfedgeDS_vertex_base() {} HalfedgeDS_vertex_base( const Point& pp) : p(pp) {} Point& point() { return p; } const Point& point() const { return p; } }; template < class Refs, class P> class HalfedgeDS_vertex_base< Refs, Tag_true, P> { public: typedef Refs HalfedgeDS; typedef HalfedgeDS_vertex_base< Refs, Tag_true, P> Base; typedef Tag_true Supports_vertex_halfedge; typedef Tag_true Supports_vertex_point; typedef P Point; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Vertex_const_handle Vertex_const_handle; typedef typename Refs::Halfedge_handle Halfedge_handle; typedef typename Refs::Halfedge_const_handle Halfedge_const_handle; typedef typename Refs::Face_handle Face_handle; typedef typename Refs::Face_const_handle Face_const_handle; typedef typename Refs::Halfedge Halfedge; typedef typename Refs::Face Face; private: Halfedge_handle hdg; Point p; public: HalfedgeDS_vertex_base() {} HalfedgeDS_vertex_base( const Point& pp) : p(pp) {} Halfedge_handle halfedge() { return hdg; } Halfedge_const_handle halfedge() const { return hdg; } void set_halfedge( Halfedge_handle h) { hdg = h; } Point& point() { return p; } const Point& point() const { return p; } }; CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_VERTEX_BASE_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_kd_2.h0000644000175000017500000004036211344301501030704 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Snap_rounding_kd_2.h,v $ // $Revision: 1.1.1.1 $ // $Name: $ // // author(s) : Eli Packer #ifndef CGAL_SNAP_ROUNDING_KD_2_H #define CGAL_SNAP_ROUNDING_KD_2_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class My_point : public Traits::Point_2 { private: typedef typename Traits::Point_2 Point_2; typedef typename Traits::FT NT; public: Point_2 orig; SAVED_OBJECT object; My_point(Point_2 p, Point_2 inp_orig, SAVED_OBJECT obj) : Point_2(p), orig(inp_orig), object(obj) {} My_point(Point_2 p) : Point_2(p), orig(Point_2(0, 0)) {} My_point() : Point_2(),orig() {} My_point(NT x, NT y) : Point_2(x, y), orig(Point_2(0, 0)) {} }; template class Multiple_kd_tree { private: typedef Traits_ Traits; typedef typename Traits::FT NT; typedef typename Traits::Segment_2 Segment_2; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Vector_2 Vector_2; typedef typename Traits::Iso_rectangle_2 Iso_rectangle_2; typedef typename Traits::Direction_2 Direction_2; typedef typename Traits::Line_2 Line_2; typedef typename Traits::Aff_transformation_2 Transformation_2; typedef My_point My_point_saved; typedef CGAL::Kdtree_interface_2d Kd_interface; typedef CGAL::Kdtree_d Kd_tree; typedef typename Kd_tree::Box Box; typedef std::list Points_List; typedef std::pair Direction_nt_pair; typedef std::pair Kd_triple; typedef std::pair Kd_direction_nt_pair; typedef std::list Kd_triple_list; typedef std::pair Point_saved_pair; typedef std::list Point_saved_pair_list; typedef typename Point_saved_pair_list::iterator Point_saved_pair_iter; typedef typename std::list My_point_saved_list; typedef typename My_point_saved_list::iterator My_point_saved_iter; typedef std::list Point_list; typedef typename Point_list::iterator Point_iter; typedef std::list Segment_list; typedef typename Segment_list::const_iterator Segment_const_iter; typedef std::list Direction_list; typedef typename Direction_list::const_iterator Direction_const_iter; private: Traits m_gt; const double pi, half_pi; int number_of_trees; Kd_triple_list kd_trees_list; Point_saved_pair_list input_points_list; std::map angle_to_sines_appr; // was const int /*! */ void rotate(Point_2& p, NT angle) { static const double rad_to_deg = 57.297; typename Traits::To_double to_dbl; int tranc_angle = int(to_dbl(angle) * rad_to_deg); NT cosine_val = angle_to_sines_appr[90 - tranc_angle], sine_val = angle_to_sines_appr[tranc_angle]; Transformation_2 rotate(ROTATION, sine_val, cosine_val); p = rotate(p); } /*! */ Kd_triple create_kd_tree(NT angle) { Points_List l; Kd_tree *tree = new Kd_tree(2); for (Point_saved_pair_iter iter = input_points_list.begin(); iter != input_points_list.end(); ++iter) { Point_2 p(iter->first); rotate(p,angle); My_point_saved rotated_point(p,iter->first,iter->second); l.push_back(rotated_point); } tree->build(l); //checking validity if (!tree->is_valid()) tree->dump(); assert(tree->is_valid()); typename Traits::To_double to_dbl; double buffer_angle(to_dbl(angle) - half_pi / (2 * number_of_trees)); if (buffer_angle < 0) buffer_angle = 0; Line_2 li(tan(buffer_angle), -1, 0); Direction_2 d(li); // rotate_by 180 degrees Transformation_2 t(ROTATION, 0, -1); d = d.transform(t); Direction_nt_pair kp(d, angle); Kd_triple kt(tree,kp); return(kt); } inline NT square(NT x) {return(x * x);} inline NT min(NT x, NT y) {return((x < y) ? x : y);} inline NT max(NT x, NT y) {return((x < y) ? y : x);} inline NT min(NT x1, NT x2, NT x3, NT x4, NT x5, NT x6) {return(min(min(min(x1, x2), min(x3, x4)),min(x5, x6)));} inline NT max(NT x1, NT x2, NT x3, NT x4, NT x5, NT x6) {return(max(max(max(x1, x2), max(x3, x4)),max(x5, x6)));} /*! */ Direction_2 get_direction(Segment_2 seg) { typedef typename Traits_::Construct_vertex_2 Construct_vertex_2; Construct_vertex_2 construct_vertex = m_gt.construct_vertex_2_object(); // force the segment slope to [0-180) Point_2 s = construct_vertex(seg, 0); Point_2 t = construct_vertex(seg, 1); Comparison_result cx = m_gt.compare_x_2_object()(s, t); Comparison_result cy = m_gt.compare_y_2_object()(s, t); if (cy == LARGER || cy == EQUAL && cx == LARGER) { typedef typename Traits::Construct_segment_2 Construct_segment_2; Construct_segment_2 construct_seg = m_gt.construct_segment_2_object(); seg = construct_seg(t, s); } // force the vector to [0-90) Vector_2 v(construct_vertex(seg, 0), construct_vertex(seg, 1)); if (cx == EQUAL || cx == LARGER && cy == SMALLER || cx == SMALLER && cy == LARGER) v = v.perpendicular(RIGHT_TURN); Direction_2 d(v.direction()); return(d); } /*! */ int get_kd_num(Segment_2 seg, int n, Direction_list & directions) { Direction_2 d = get_direction(seg); int i = 0; bool found = false; Direction_const_iter iter = directions.begin(); while (i < n && !found) { if (*iter > d) found = true; ++i; ++iter; } if (found) --i; else i = 0; return(i); } /*! */ void check_kd(int *kd_counter,int number_of_trees, const Segment_list & seg_list, Direction_list & directions) { for (int i = 0;i < number_of_trees;++i) kd_counter[i] = 0; int kd_num; for (Segment_const_iter iter = seg_list.begin(); iter != seg_list.end(); ++iter) { kd_num = get_kd_num(*iter, number_of_trees, directions); kd_counter[kd_num]++; } } /*! */ void init_angle_to_sines_table() { angle_to_sines_appr[0] = NT(0); angle_to_sines_appr[1] = NT(115) / NT(6613); angle_to_sines_appr[2] = NT(57) / NT(1625); angle_to_sines_appr[3] = NT(39) / NT(761); angle_to_sines_appr[4] = NT(29) / NT(421); angle_to_sines_appr[5] = NT(23) / NT(265); angle_to_sines_appr[6] = NT(19) / NT(181); angle_to_sines_appr[7] = NT(32) / NT(257); angle_to_sines_appr[8] = NT(129) / NT(929); angle_to_sines_appr[9] = NT(100) / NT(629); angle_to_sines_appr[10] = NT(92) / NT(533); angle_to_sines_appr[11] = NT(93) / NT(485); angle_to_sines_appr[12] = NT(76) / NT(365); angle_to_sines_appr[13] = NT(156) / NT(685); angle_to_sines_appr[14] = NT(205) / NT(853); angle_to_sines_appr[15] = NT(69) / NT(269); angle_to_sines_appr[16] = NT(7) / NT(25); angle_to_sines_appr[17] = NT(120) / NT(409); angle_to_sines_appr[18] = NT(57) / NT(185); angle_to_sines_appr[19] = NT(12) / NT(37); angle_to_sines_appr[20] = NT(51) / NT(149); angle_to_sines_appr[21] = NT(135) / NT(377); angle_to_sines_appr[22] = NT(372) / NT(997); angle_to_sines_appr[23] = NT(348) / NT(877); angle_to_sines_appr[24] = NT(231) / NT(569); angle_to_sines_appr[25] = NT(36) / NT(85); angle_to_sines_appr[26] = NT(39) / NT(89); angle_to_sines_appr[27] = NT(300) / NT(661); angle_to_sines_appr[28] = NT(8) / NT(17); angle_to_sines_appr[29] = NT(189) / NT(389); angle_to_sines_appr[30] = NT(451) / NT(901); angle_to_sines_appr[31] = NT(180) / NT(349); angle_to_sines_appr[32] = NT(28) / NT(53); angle_to_sines_appr[33] = NT(432) / NT(793); angle_to_sines_appr[34] = NT(161) / NT(289); angle_to_sines_appr[35] = NT(228) / NT(397); angle_to_sines_appr[36] = NT(504) / NT(865); angle_to_sines_appr[37] = NT(3) / NT(5); angle_to_sines_appr[38] = NT(580) / NT(941); angle_to_sines_appr[39] = NT(341) / NT(541); angle_to_sines_appr[40] = NT(88) / NT(137); angle_to_sines_appr[41] = NT(48) / NT(73); angle_to_sines_appr[42] = NT(65) / NT(97); angle_to_sines_appr[43] = NT(429) / NT(629); angle_to_sines_appr[44] = NT(555) / NT(797); angle_to_sines_appr[45] = NT(697) / NT(985); angle_to_sines_appr[46] = NT(572) / NT(797); angle_to_sines_appr[47] = NT(460) / NT(629); angle_to_sines_appr[48] = NT(72) / NT(97); angle_to_sines_appr[49] = NT(55) / NT(73); angle_to_sines_appr[50] = NT(105) / NT(137); angle_to_sines_appr[51] = NT(420) / NT(541); angle_to_sines_appr[52] = NT(741) / NT(941); angle_to_sines_appr[53] = NT(4) / NT(5); angle_to_sines_appr[54] = NT(703) / NT(865); angle_to_sines_appr[55] = NT(325) / NT(397); angle_to_sines_appr[56] = NT(240) / NT(289); angle_to_sines_appr[57] = NT(665) / NT(793); angle_to_sines_appr[58] = NT(45) / NT(53); angle_to_sines_appr[59] = NT(299) / NT(349); angle_to_sines_appr[60] = NT(780) / NT(901); angle_to_sines_appr[61] = NT(340) / NT(389); angle_to_sines_appr[62] = NT(15) / NT(17); angle_to_sines_appr[63] = NT(589) / NT(661); angle_to_sines_appr[64] = NT(80) / NT(89); angle_to_sines_appr[65] = NT(77) / NT(85); angle_to_sines_appr[66] = NT(520) / NT(569); angle_to_sines_appr[67] = NT(805) / NT(877); angle_to_sines_appr[68] = NT(925) / NT(997); angle_to_sines_appr[69] = NT(352) / NT(377); angle_to_sines_appr[70] = NT(140) / NT(149); angle_to_sines_appr[71] = NT(35) / NT(37); angle_to_sines_appr[72] = NT(176) / NT(185); angle_to_sines_appr[73] = NT(391) / NT(409); angle_to_sines_appr[74] = NT(24) / NT(25); angle_to_sines_appr[75] = NT(260) / NT(269); angle_to_sines_appr[76] = NT(828) / NT(853); angle_to_sines_appr[77] = NT(667) / NT(685); angle_to_sines_appr[78] = NT(357) / NT(365); angle_to_sines_appr[79] = NT(476) / NT(485); angle_to_sines_appr[80] = NT(525) / NT(533); angle_to_sines_appr[81] = NT(621) / NT(629); angle_to_sines_appr[82] = NT(920) / NT(929); angle_to_sines_appr[83] = NT(255) / NT(257); angle_to_sines_appr[84] = NT(180) / NT(181); angle_to_sines_appr[85] = NT(264) / NT(265); angle_to_sines_appr[86] = NT(420) / NT(421); angle_to_sines_appr[87] = NT(760) / NT(761); angle_to_sines_appr[88] = NT(1624) / NT(1625); angle_to_sines_appr[89] = NT(6612) / NT(6613); angle_to_sines_appr[90] = NT(1); } public: /*! */ Multiple_kd_tree(const Point_saved_pair_list & inp_points_list, int inp_number_of_trees, const Segment_list & seg_list) : pi(3.1415), half_pi(1.57075), number_of_trees(inp_number_of_trees), input_points_list(inp_points_list) { Kd_triple kd; // check that there are at least two trees if (number_of_trees < 1) { std::cerr << "There must be at least one kd-tree\n"; exit(1); } init_angle_to_sines_table(); // find the kd trees that have enough candidates (segments with a close // slope) int * kd_counter = new int[number_of_trees]; int number_of_segments = seg_list.size(); // auxilary directions Direction_list directions; double buffer_angle; Line_2 li; Direction_2 d; int i = 0; for (double angle = 0; i < number_of_trees; angle += half_pi / number_of_trees,++i) { buffer_angle = angle - half_pi / (2 * number_of_trees); if (buffer_angle < 0) buffer_angle = 0; li = Line_2(tan(buffer_angle), -1, 0); d = Direction_2(li); // rotate_by 180 degrees Transformation_2 t(ROTATION, 0, -1); d = d.transform(t); directions.push_back(d); } check_kd(kd_counter, number_of_trees, seg_list,directions); int ind = 0; #ifdef CGAL_SR_DEBUG int number_of_actual_kd_trees = 0; #endif i = 0; for (NT angle = 0; i < number_of_trees; angle += NT(half_pi / number_of_trees),++i) { if (kd_counter[ind] >= (double)number_of_segments / (double)number_of_trees / 2.0) { kd = create_kd_tree(angle); kd_trees_list.push_back(kd); #ifdef CGAL_SR_DEBUG ++number_of_actual_kd_trees; #endif } ++ind; } #ifdef CGAL_SR_DEBUG std::cout << "Actual number of kd-trees created : " << number_of_actual_kd_trees << std::endl; #endif } /*! */ Point_2 small_x_point(const Point_2 & p1, const Point_2 & p2) { Comparison_result c = m_gt.compare_x_2_object()(p1, p2); return (c == SMALLER) ? p1 : p2; } /*! */ Point_2 big_x_point(const Point_2 & p1, const Point_2 & p2) { Comparison_result c = m_gt.compare_x_2_object()(p1, p2); return (c == SMALLER) ? p2 : p1; } /*! */ Point_2 small_y_point(const Point_2 & p1, const Point_2 & p2) { Comparison_result c = m_gt.compare_y_2_object()(p1, p2); return (c == SMALLER) ? p1 : p2; } /*! */ Point_2 big_y_point(const Point_2 & p1, const Point_2 & p2) { Comparison_result c = m_gt.compare_y_2_object()(p1, p2); return (c == SMALLER) ? p2 : p1; } /*! */ void get_intersecting_points(std::list & result_list, Segment_2 s, NT unit_square) { // determine right kd-tree to work on, depending on the segment's slope Direction_2 d = get_direction(s); int i = 0; int n = kd_trees_list.size(); bool found = false; typename Kd_triple_list::const_iterator iter = kd_trees_list.begin(); while(i < n && !found) { if (iter->second.first > d) found = true; ++i; ++iter; } if (!found) iter = kd_trees_list.begin(); else --iter; Point_list points_list; m_gt.minkowski_sum_with_pixel_2_object()(points_list, s, unit_square); Point_iter points_iter; for (points_iter = points_list.begin(); points_iter != points_list.end(); ++points_iter) rotate(*points_iter, iter->second.second); // query points_iter = points_list.begin(); Point_2 point_left,point_right,point_bot,point_top; point_left = point_right = point_bot = point_top = *points_iter; for (++points_iter; points_iter != points_list.end(); ++points_iter) { point_left = small_x_point(point_left,*points_iter); point_right = big_x_point(point_right,*points_iter); point_bot = small_y_point(point_bot,*points_iter); point_top = big_y_point(point_top,*points_iter); } typedef typename Traits::Construct_iso_rectangle_2 Construct_iso_rectangle_2; Construct_iso_rectangle_2 construct_rec = m_gt.construct_iso_rectangle_2_object(); Iso_rectangle_2 rec = construct_rec(point_left, point_right, point_bot, point_top); Point_2 p1 = rec.vertex(0); Point_2 p2 = rec.vertex(2); My_point_saved point1(p1); My_point_saved point2(p2); Box b(point1, point2, 2); // the kd-tree query My_point_saved_list res; iter->first->search(std::back_inserter(res), b); // create result result_list.empty(); for (My_point_saved_iter my_point_iter = res.begin(); my_point_iter != res.end(); ++my_point_iter) result_list.push_back(my_point_iter->object); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_verte0000644000175000017500000000751411344301500031465 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_VERTEX_BASE_2_H #define CGAL_APOLLONIUS_GRAPH_VERTEX_BASE_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template struct Apollonius_graph_vertex_base_nested_iterator_traits { typedef AGVB2_Iterator Base_iterator; typedef typename Base_iterator::value_type::Hidden_sites_iterator Iterator; Iterator begin(Base_iterator it) const { return it->hidden_sites_begin(); } Iterator end(Base_iterator it) const { return it->hidden_sites_end(); } }; template > class Apollonius_graph_vertex_base_2 : public Vb { private: typedef typename Vb::Triangulation_data_structure AGDS; public: // TYPES //------ typedef Gt Geom_traits; typedef Vb Base; typedef typename Gt::Site_2 Site_2; typedef AGDS Apollonius_graph_data_structure_2; typedef typename AGDS::Face_handle Face_handle; typedef typename AGDS::Vertex_handle Vertex_handle; enum {Store_hidden = StoreHidden}; template < typename AGDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Apollonius_graph_vertex_base_2 Other; }; private: // local types typedef std::list Container; public: // TYPES (continued) //------------------ // typedef Container Hidden_sites_container; typedef typename Container::iterator Hidden_sites_iterator; public: // CREATION //--------- Apollonius_graph_vertex_base_2() : Vb() {} Apollonius_graph_vertex_base_2(const Site_2& p) : Vb(), _p(p) {} Apollonius_graph_vertex_base_2(const Site_2& p, Face_handle f) : Vb(f), _p(p) {} ~Apollonius_graph_vertex_base_2() { clear_hidden_sites_container(); } // ACCESS METHODS //--------------- const Site_2& site() const { return _p; } Site_2& site() { return _p; } Face_handle face() const { return Vb::face(); } unsigned int number_of_hidden_sites() const { return hidden_site_list.size(); } Hidden_sites_iterator hidden_sites_begin() { return hidden_site_list.begin(); } Hidden_sites_iterator hidden_sites_end() { return hidden_site_list.end(); } public: // SETTING AND UNSETTING //---------------------- void set_site(const Site_2& p) { _p = p; } void add_hidden_site(const Site_2& p) { if ( StoreHidden ) { hidden_site_list.push_back(p); } } void clear_hidden_sites_container() { hidden_site_list.clear(); } public: // VALIDITY CHECK bool is_valid(bool verbose = false, int level = 0) const { return Vb::is_valid(verbose, level); } private: // class variables Container hidden_site_list; Site_2 _p; }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_vertex.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_vert0000644000175000017500000000545011344301500031522 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Partition_opt_cvx_vertex.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert #ifndef CGAL_PARTITION_OPT_CVX_VERTEX_H #define CGAL_PARTITION_OPT_CVX_VERTEX_H #include #include namespace CGAL { class Partition_opt_cvx_stack_record { public: Partition_opt_cvx_stack_record() {} Partition_opt_cvx_stack_record(unsigned int old, int value) : _old(old), _value(value), _solution(Partition_opt_cvx_diagonal_list()) {} Partition_opt_cvx_stack_record(unsigned int old, int value, const Partition_opt_cvx_diagonal_list& solution) : _old(old), _value(value), _solution(solution) {} unsigned int vertex_num() { return _old; } int value() {return _value; } Partition_opt_cvx_diagonal_list solution() { return _solution; } private: unsigned int _old; int _value; Partition_opt_cvx_diagonal_list _solution; }; class Partition_opt_cvx_vertex { public: Partition_opt_cvx_vertex() {} Partition_opt_cvx_vertex(unsigned int v_num): _v_num(v_num), _stack(std::list()), _best_so_far(Partition_opt_cvx_stack_record(0, 0)) {} unsigned int vertex_num( ) { return _v_num; } Partition_opt_cvx_stack_record best_so_far( ) { return _best_so_far; } bool stack_empty() { return _stack.empty(); } // Pre: stack is not empty Partition_opt_cvx_stack_record stack_top() { return _stack.back(); } void stack_push(unsigned int vertex, int value, const Partition_opt_cvx_diagonal_list& diag_list) { _best_so_far = Partition_opt_cvx_stack_record(vertex, value, diag_list); _stack.push_back(_best_so_far); } // Pre: stack is not empty void stack_pop() { _best_so_far = _stack.back(); _stack.pop_back(); } private: unsigned int _v_num; std::list _stack; Partition_opt_cvx_stack_record _best_so_far; }; } #endif // CGAL_PARTITION_OPT_CVX_VERTEX_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree_node.h0000644000175000017500000001400611344301500027554 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree_node.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Authors : Hans Tangelder () #ifndef CGAL_KD_TREE_NODE_H #define CGAL_KD_TREE_NODE_H #include #include namespace CGAL { template class Kd_tree; template < class TreeTraits, class Splitter, class UseExtendedNode > class Kd_tree_node { friend class Kd_tree; typedef typename Kd_tree::Node_handle Node_handle; enum Node_type {LEAF, INTERNAL, EXTENDED_INTERNAL}; typedef typename TreeTraits::Point_d Point_d; typedef typename TreeTraits::FT FT; typedef typename Kd_tree::Separator Separator; typedef typename Kd_tree::Point_d_iterator Point_d_iterator; private: // node type identifier Node_type the_node_type; // private variables for leaf nodes unsigned int n; // denotes number of items in a leaf node Point_d_iterator data; // iterator to data in leaf node // private variables for internal nodes Node_handle lower_ch, upper_ch; Separator sep; // private variables for extended internal nodes FT low_val; FT high_val; public: void * for_compact_container() const { return lower_ch.for_compact_container(); } void * & for_compact_container() { return lower_ch.for_compact_container(); } // default constructor Kd_tree_node() {} Kd_tree_node(Node_type t ) : the_node_type(t) {} Kd_tree_node(int n_, Node_type t ) : the_node_type(t), n(n_) {} // members for all nodes inline bool is_leaf() const { return (the_node_type==LEAF); } // members for leaf nodes only inline unsigned int size() const { return n; } inline Point_d_iterator begin() const { return data; } inline Point_d_iterator end() const { return data + n; } // members for internal node and extended internal node inline Node_handle lower() const { return lower_ch; } inline Node_handle upper() const { return upper_ch; } // inline Separator& separator() {return sep; } // use instead inline FT cutting_value() const { return sep.cutting_value(); } inline int cutting_dimension() const { return sep.cutting_dimension(); } // members for extended internal node only inline FT low_value() const { return low_val; } inline FT high_value() const { return high_val; } Separator& separator() { return sep; } unsigned int num_items() { if (is_leaf()) return size(); else return lower()->num_items() + upper()->num_items(); } unsigned int num_nodes() { if (is_leaf()) return 1; else return lower()->num_nodes() + upper()->num_nodes(); } int depth(const int current_max_depth) const { if (is_leaf()){ return current_max_depth; } else return std::max( lower()->depth(current_max_depth + 1), upper()->depth(current_max_depth + 1)); } int depth() const { return depth(1); } template OutputIterator tree_items(OutputIterator it) { if (is_leaf()) { if (n>0) for (Point_d_iterator i=begin(); i != end(); i++) {*it=**i; ++it;} } else { it=lower_ch->tree_items(it); it=upper_ch->tree_items(it); }; return it; } void indent(int d) const { for(int i = 0; i < d; i++){ std::cout << " "; } } void print(int d = 0) const { if (is_leaf()) { indent(d); std::cout << "leaf" << std::endl; if (n>0) for (Point_d_iterator i=begin(); i != end(); i++) {indent(d);std::cout << **i << std::endl;} } else { indent(d); std::cout << "lower tree" << std::endl; lower_ch->print(d+1); indent(d); std::cout << "separator: dim = " << sep.cutting_dimension() << " val = " << sep.cutting_value() << std::endl; indent(d); std::cout << "upper tree" << std::endl; upper_ch->print(d+1); } } template OutputIterator search(OutputIterator it, const FuzzyQueryItem& q, Kd_tree_rectangle& b) { if (is_leaf()) { if (n>0) for (Point_d_iterator i=begin(); i != end(); i++) if (q.contains(**i)) {*it=**i; ++it;} } else { // after splitting b denotes the lower part of b Kd_tree_rectangle b_upper(b); b.split(b_upper, sep.cutting_dimension(), sep.cutting_value()); if (q.outer_range_contains(b)) it=lower_ch->tree_items(it); else if (q.inner_range_intersects(b)) it=lower_ch->search(it,q,b); if (q.outer_range_contains(b_upper)) it=upper_ch->tree_items(it); else if (q.inner_range_intersects(b_upper)) it=upper_ch->search(it,q,b_upper); }; return it; } }; } // namespace CGAL #endif // CGAL_KDTREE_NODE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_site_2.h0000644000175000017500000000434011344301500030564 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_site_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_SITE_2_H #define CGAL_APOLLONIUS_SITE_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < class K > class Apollonius_site_2 { public: typedef K Kernel; typedef typename K::Point_2 Point_2; typedef Apollonius_site_2 Self; typedef typename K::FT Weight; typedef typename K::RT RT; typedef Weight FT; public: Apollonius_site_2(const Point_2& p = Point_2(), const Weight& w = Weight(0)) : _p(p), _w(w) {} Apollonius_site_2(const Apollonius_site_2& other) : _p(other._p), _w(other._w) {} const Point_2& point() const { return _p; } const Weight& weight() const { return _w; } RT x() const { return _p.x(); } RT y() const { return _p.y(); } bool operator==(const Apollonius_site_2& other) const { return ( _p == other._p && _w == other._w ); } private: Point_2 _p; Weight _w; }; template std::ostream& operator<<(std::ostream &os, const Apollonius_site_2& wp) { return os << wp.point() << " " << wp.weight(); } template std::istream& operator>>(std::istream& is, Apollonius_site_2& wp) { typename Apollonius_site_2::Weight weight; typename Apollonius_site_2::Point_2 p; is >> p >> weight; wp = Apollonius_site_2(p, weight); return is; } CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_SITE_2_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_sweep_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulat0000644000175000017500000005433411344301500031457 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_sweep_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_CONSTRAINED_TRIANGULATION_SWEEP_2_H #define CGAL_CONSTRAINED_TRIANGULATION_SWEEP_2_H #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Gt, class Tds> class Triangulation_2; template < class Gt, class Tds> class Constrained_triangulation_2; template < class Gt, class Tds> class Constrained_triangulation_sweep_2 { public: typedef Gt Geom_traits; typedef typename Gt::Point Point; typedef typename Gt::Segment Segment; typedef Triangulation_2 Triangulation; typedef Constrained_triangulation_2 Ctriangulation; typedef typename Ctriangulation::Face_handle Face_handle; typedef typename Ctriangulation::Vertex_handle Vertex_handle; typedef typename Ctriangulation::Edge Edge; typedef typename Ctriangulation::Vertex Vertex; typedef typename Ctriangulation::Face Face; typedef typename Ctriangulation::Constraint Constraint; typedef std::pair Neighbor; class Neighbor_list; class Chain; class Event_less; class Status_comp; class Event_less : public CGAL_STD::binary_function { private: Geom_traits t; public: Event_less() : t() {}; Event_less(const Geom_traits& traits) : t(traits) {}; bool operator() (const Point& p, const Point& q) { return(t.compare_x(p,q)== SMALLER || ( t.compare_x(p,q)== EQUAL && t.compare_y(p,q) == SMALLER ) ); } }; class Status_comp : public CGAL_STD::binary_function { private: Geom_traits t; public: Status_comp() : t() {}; Status_comp(const Geom_traits& traits) : t(traits){} bool operator() (const Constraint& s1, const Constraint& s2) { Point p1= s1.first; Point p2= s2.first; Point q1= s1.second; Point q2= s2.second; // one of the constraint is degenerate if ( t.compare_x(p1,q1) == EQUAL && t.compare_y(p1,q1) == EQUAL) { // p1==q1, then p2 has to be != q2 // if p1==p2 or p1==q2 return true if ( t.compare_x(p1,p2) == EQUAL && t.compare_y(p1,p2) == EQUAL) {return true;} if ( t.compare_x(p1,q2) == EQUAL && t.compare_y(p1,q2) == EQUAL ) {return true;} // for vertical constraint (p2,q2) if (t.compare_x(p2,q2) == EQUAL) { return (t.compare_y(p1,p2) == SMALLER);} // default case return( t.orientation(p2,q2,p1) == RIGHT_TURN); } else if ( t.compare_x(p2,q2) == EQUAL && t.compare_y(p2,q2) == EQUAL) { // p2==q2 && p1!=q1 // if p2==p1 or p2==q1 return false if ( t.compare_x(p2,p1) == EQUAL && t.compare_y(p2,p1) == EQUAL) {return false;} if ( t.compare_x(p2,q1) == EQUAL && t.compare_y(p2,q1) == EQUAL) {return false;} //for vertical (p1,q1) constraints if (t.compare_x(p1,q1) == EQUAL) { return ( t.compare_y(p1,p2) == SMALLER);} // default case return (t.orientation(p1,q1,q2) == LEFT_TURN); } // comparison of two non degenerate constraints else { //neither of the constraints are points switch( t.compare_x(p1,p2)) { case SMALLER: if ( t.compare_x(q1,p2) == EQUAL && t.compare_y(q1,p2) == EQUAL) {return true;} else return ( t.orientation(p1,q1,p2) == LEFT_TURN); case LARGER : if ( t.compare_x(p1,q2) == EQUAL && t.compare_y(p1,q2) == EQUAL) {return false;} else return ( t.orientation(p2,q2,p1) == RIGHT_TURN); case EQUAL : return ( t.compare_y(p1,p2) == SMALLER || (t.compare_y(p1,p2) == EQUAL && t.orientation(p1,q1,q2) == LEFT_TURN)); } } // shouldn't get there // CGAL_triangulation_assertion( false ); return false; } }; class Neighbor_list : public CGAL_STD::list { private: Ctriangulation* _tr; public: Neighbor_list (Ctriangulation *tr) : _tr(tr) {} bool is_removable(Face_handle fh) { return ( (*fh).vertex(1) == (*fh).vertex(2) && (*fh).neighbor(1) != Face_handle() && (*fh).neighbor(2) != Face_handle() ); } void remove_flat(Face_handle fh) { CGAL_triangulation_precondition((*fh).vertex(1) == (*fh).vertex(2)); Face_handle f2= (*fh).neighbor(2); Face_handle f1= (*fh).neighbor(1); if ( f2 != Face_handle() ) { (*f2).set_neighbor( (*f2).index(fh), f1);} if ( f1 != Face_handle() ) { (*f1).set_neighbor( (*f1).index(fh), f2);} ( (*fh). vertex(0))->set_face( f2!= Face_handle() ? f2 : f1 ); _tr->delete_face(fh); return; } Face_handle up_visit_without_test(Vertex_handle v, Face_handle last) { Face_handle newf; Face_handle fn; int in; while( !empty()){ fn= front().first; in= front().second; pop_front(); newf = _tr->create_face(v, fn->vertex(fn->cw(in)), fn->vertex(fn->ccw(in))); last->set_neighbor(2,newf); newf->set_neighbor(1,last); fn->set_neighbor(in, newf); newf->set_neighbor(0,fn); newf->set_constraint(1, last->is_constrained(2)); newf->set_constraint(0, fn->is_constrained(in)); // delete fn if flat and removable if (is_removable(fn)) { remove_flat(fn);} last=newf; } return last; } Face_handle up_visit( Vertex_handle v, Face_handle last) { Geom_traits t=Geom_traits(); Face_handle newf; Face_handle fn; int in; Vertex_handle cwin; Vertex_handle ccwin; while (!empty()) { fn= front().first; in= front().second; cwin = fn->vertex(fn->cw(in)); ccwin = fn->vertex(fn->ccw(in)); if ( t.orientation(ccwin->point(),cwin->point(),v->point()) == RIGHT_TURN) { pop_front(); newf = _tr->create_face(v,cwin,ccwin); last->set_neighbor(2,newf); newf->set_neighbor(1,last); fn->set_neighbor(in, newf); newf->set_neighbor(0,fn); newf->set_constraint(1, last->is_constrained(2)); newf->set_constraint(0, fn->is_constrained(in)); // delete fn if flat and removable if (is_removable(fn)) { remove_flat(fn);} last=newf; } else{break;} } return last; } Face_handle down_visit(Vertex_handle v, Face_handle first) { Geom_traits t=Geom_traits(); Face_handle newf; Face_handle fn; int in; Vertex_handle cwin; Vertex_handle ccwin; while (!empty()) { fn= back().first; in= back().second; cwin = fn->vertex(fn->cw(in)); ccwin = fn->vertex(fn->ccw(in)); if ( t.orientation(ccwin->point(),cwin->point(),v->point()) == RIGHT_TURN) { pop_back(); newf = _tr->create_face(v,cwin,ccwin); first->set_neighbor(1,newf); newf->set_neighbor(2,first); fn->set_neighbor(in, newf); newf->set_neighbor(0,fn); newf->set_constraint(2, first->is_constrained(1)); newf->set_constraint(0, fn->is_constrained(in)); // delete fn if flat and removable if (is_removable(fn)) { remove_flat(fn);} first=newf; } else{break;} } return first; } }; class Chain { private: Vertex_handle rm; Neighbor_list up; Neighbor_list down; public: Chain(Ctriangulation* tr) : rm(), up(tr), down(tr) {} Vertex_handle right_most() { return rm;} Neighbor_list* up_list(){return &up;} Neighbor_list* down_list(){return &down;} void set_right_most(Vertex_handle v) { rm=v;} }; typedef std::list Out_edges; typedef std::map Event_queue; typedef std::map Sweep_status; // should be //typedef std::map Sweep_status; // added to please MIPS Pro typedef typename Event_queue::iterator Event_queue_iterator; typedef typename Sweep_status::iterator Sweep_status_iterator; protected: Ctriangulation* _tr; std::list* _lc; Event_less event_less; Event_queue queue; Status_comp status_comp; Sweep_status status; Chain upper_chain; public: Constrained_triangulation_sweep_2() : _tr(NULL), _lc(), upper_chain() { } Constrained_triangulation_sweep_2( Ctriangulation* ct, std::list& lc) : _tr(ct), _lc(&lc), event_less(ct->geom_traits()), queue(event_less), status_comp(ct->geom_traits()), status(status_comp), upper_chain(ct) { make_event_queue(); build_triangulation(); } Geom_traits geom_traits() { return _tr->geom_traits(); } Event_less xy_less() { return event_less;} friend class Neighbor_list; public: void make_event_queue(); void build_triangulation(); Vertex_handle treat_in_edges(const Event_queue_iterator & event, Sweep_status_iterator & loc); void treat_out_edges(const Event_queue_iterator & event, Sweep_status_iterator & loc); //Vertex_handle set_infinite_faces(); void set_infinite_faces(); bool do_intersect(const Constraint& c1, const Constraint& c2 ); }; template void Constrained_triangulation_sweep_2:: make_event_queue() { if ( ! queue.empty()) {return;} // queue already done typename std::list::iterator sit=_lc->begin(); typename std::list::iterator sdone=_lc->end(); Constraint s; Point p,q; Event_queue_iterator look_up; while (sit != sdone) { s=*sit++; if (event_less(s.first,s.second)) { p=s.first; q = s.second;} else { p=s.second; q = s.first;} // p is xy_less or equal to q look_up = queue.lower_bound(p); if (look_up == queue.end() || event_less(p,(*look_up).first) ) { // the event p does not yet exists Out_edges* out= new Out_edges(); typename Event_queue::value_type event(p,out); look_up=queue.insert(look_up,event); } if(event_less(p,q)) { ((*look_up).second)->push_front(q); //insert q in out_edges(p); // Degenerate constraints (p==q) are not inserted in Out_egdes list. // A duplicate constraint // will be inserted twice in the Out_egdes list of its first // point. The second copy will be discarded when // insertion in status takes place look_up = queue.lower_bound(q); if (look_up == queue.end() || event_less(q,(*look_up).first)){ // the event q does not yet exists Out_edges* out= new Out_edges(); typename Event_queue::value_type event(q,out); look_up=queue.insert(look_up,event); } } } return; } template void Constrained_triangulation_sweep_2:: build_triangulation() { Point p; Vertex_handle v; Out_edges* out; Event_queue_iterator event; while (! queue.empty()) { event = queue.begin(); // locate (p,p) dans status p = (*event).first; out = (*event).second; Sweep_status_iterator loc=status.lower_bound(Constraint(p,p)); // deal with the contraints finishing at p v = treat_in_edges(event,loc); _tr->set_number_of_vertices( _tr->number_of_vertices() +1); // insert constraint beginning at p treat_out_edges(event,loc); // delete event from event_queue out= (*event).second; CGAL_triangulation_assertion( (*out).empty()); delete out; //delete la liste out queue.erase(event); } // make inifinite vertex, infinite faces // at this stage status is empty // and the lists of upper_chain correspond to the convex hull CGAL_triangulation_assertion( status.empty()); //the_vertex = set_infinite_faces(); set_infinite_faces(); return; } template typename Constrained_triangulation_sweep_2::Vertex_handle Constrained_triangulation_sweep_2:: treat_in_edges(const Event_queue_iterator & event, Sweep_status_iterator & loc) { // loc is assumed to point to the first constraint in status // not less than [p,p]; Vertex_handle v = (new Vertex((*event).first))->handle(); Chain* pch; Sweep_status_iterator loc_start=loc; if (loc == status.end()) { pch = &upper_chain;} else { pch = (Chain*)((*loc).second);} Vertex_handle w = pch->right_most(); if (w == Vertex_handle() ) { // first event is treated pch->set_right_most(v); return v; } Face_handle newf= _tr->create_face(v,w,w); // test if the edge vw is a constraint // this is not possible if loc == status.end() if ( loc != status.end() && w->point() == ((*loc).first).first && v->point() == ((*loc).first).second ) { // vw is a constraint newf->set_constraints(true,true,true); } Neighbor_list* nl = pch->down_list(); Face_handle first; first= nl->down_visit(v,newf); Face_handle last = newf; while( loc!= status.end() && ((*event).first == ((*loc).first).second ) ) { nl= pch->up_list(); last = nl->up_visit_without_test(v,last); last->set_constraint(2,true); loc++; if (loc == status.end()) { pch = &upper_chain;} else { pch = (Chain *)((*loc).second);} nl= pch->down_list(); last = nl->up_visit_without_test(v,last); } nl=pch->up_list(); last= nl->up_visit(v,last); //delete flat newf if possible // i. e. if at least one of its neighbor is not Face_handle() if ( newf->neighbor(2) != Face_handle() || newf->neighbor(1)!= Face_handle() ) { if (first == newf ) { // means newf->neighbor(1) == Face_handle() first = newf->neighbor(2);} if (last == newf) { // means newf->neighbor(2) == Face_handle() last = newf->neighbor(1);} nl->remove_flat(newf); } // set face pointer of vertex v. // if no face is created except the flat one // the pointer is set to this face. // Thus the face pointer of f->vertex(0) has to be reset // when the flat face f is removed through f->remove_flat() v->set_face(last); // update the chain of loc and status; //update the up list of *loc nl->push_front(Neighbor(last,2)); pch->set_right_most(v); // update the down list of *loc // splicing in the remaining downlist of *loc_start // then adding Neighbor(first,1) nl = pch->down_list(); if (loc_start != loc) { pch = (Chain *)((*loc_start).second); nl->splice(nl->end(), *(pch->down_list())); } nl->push_back(Neighbor(first,1)); //update status while (loc_start != loc) { pch = (Chain *)((*loc_start).second); delete pch; status.erase(loc_start++); } // test for intersection the newly adjacent constraints if(loc_start != status.end() && loc_start != status.begin()){ CGAL_triangulation_assertion( ! do_intersect( (*loc_start).first, (*(--loc_start)).first ) ); } return v; } template void Constrained_triangulation_sweep_2:: treat_out_edges(const Event_queue_iterator & event, Sweep_status_iterator & loc) { Point p = (*event).first; Out_edges* out = (*event).second; typename Out_edges::iterator outit= (*out).begin(); Chain* newpc; Chain* pc_up; Constraint c; const Constraint* c_plus=NULL; const Constraint* c_minus=NULL; if(loc != status.end()) { c_plus= &((*loc).first);} if(loc != status.begin()) {c_minus = &((*(--loc)).first); ++loc;} // c_plus points to the constraint in status following // the last constraint through p if there is one. // c_minus points to the constraint in status preceeding // the first constraint through p if there is one. // These two constraints are to be tested for intersection // when inserting the constraint through p; if (loc == status.end()) {pc_up = & upper_chain;} else { pc_up = (Chain*)((*loc).second);} Vertex_handle v = pc_up->right_most(); //assert (v->point() == p); //c= Constraint(p,p); //Sweep_status_iterator loc_bis = status.lower_bound(Constraint(p,p)); //assert( loc == loc_bis); while( outit != (*out).end()){ c = Constraint(p,*outit); // test for intersection if (c_plus != NULL){ CGAL_triangulation_assertion( ! do_intersect( (*c_plus), c)); } if (c_minus != NULL){ CGAL_triangulation_assertion( ! do_intersect( (*c_minus), c)); } //insert // if the constraint of *out are sorted (with out_comp()) // loc should be always equal to status.lower_bound(c) // and status-insert should be constant time newpc = new Chain(_tr); newpc->set_right_most(v); loc = status.insert(loc, std::pair(c, (void*)newpc )); loc++; if (loc == status.end()) {pc_up = & upper_chain;} else { pc_up = (Chain*)((*loc).second);} (newpc->down_list())->splice((newpc->down_list())->end(), *(pc_up->down_list()) ); (*out).erase(outit++); } return; } template void //Constrained_triangulation_sweep_2::Vertex_handle Constrained_triangulation_sweep_2:: set_infinite_faces() { //Vertex_handle infinite= (new Vertex)->handle(); Vertex_handle infinite= _tr->infinite_vertex(); // Triangulation may be empty; if (upper_chain.right_most() == Vertex_handle() ) {return;} Neighbor_list* upper_list= upper_chain.up_list(); Neighbor_list* lower_list= upper_chain.down_list(); //Triangulation may have only one vertex if (upper_list->empty() || lower_list->empty()) // {return upper_chain.right_most();} { _tr->set_number_of_vertices(0); _tr->insert_first(upper_chain.right_most()->point()); delete &(*upper_chain.right_most()); return; } //Triangulation has now at least two vertices Face_handle first, last; Face_handle newf, fn; int in; // Solve the One dimensional case first = (lower_list->front()).first; last = (upper_list->back()).first; if (first->vertex(1) == first->vertex(2) && last->vertex(1) == last ->vertex(2) ) { //dimension 1 //both test are necessary because it may remain some flat faces //in the upper chain. _tr->set_dimension(1); newf = _tr->create_face(infinite, first->vertex(1), Face_handle()); first = last = newf; infinite->set_face(first); typename Neighbor_list::iterator it = lower_list->begin(); for( ; it != lower_list->end(); it++) { fn = (*it).first; //turn the vertex [vww] into [wvNULL] fn->set_vertex(1, fn->vertex(0)); fn->set_vertex(0, fn->vertex(2)); fn->set_vertex(2, Vertex_handle()); fn->vertex(0)->set_face(fn); fn->set_neighbor(1,last); last->set_neighbor(0,fn); last = fn; } fn = _tr->create_face(last->vertex(1), infinite, Vertex_handle()); fn->vertex(0)->set_face(fn); fn->set_neighbor(1,last); last->set_neighbor(0,fn); fn->set_neighbor(0,first); first->set_neighbor(1,fn); return; } // good 2d triangulation _tr->set_dimension(2); lower_list->splice(lower_list->end(), *upper_list); // * lower_list now describes the convex-hull ccw fn = (*(lower_list->begin())).first; in = (*(lower_list->begin())).second; lower_list->pop_front(); newf = _tr->create_face( infinite, fn->vertex(fn->cw(in)), fn->vertex(fn->ccw(in))); fn->set_neighbor(in,newf); newf->set_neighbor(0,fn); newf->set_constraint(0, fn->is_constrained(in)); if (lower_list->is_removable(fn)) { lower_list->remove_flat(fn); } first = last = newf; while ( ! lower_list->empty()){ fn =(* (lower_list->begin())).first; in =(* (lower_list->begin())).second; lower_list->pop_front(); newf= _tr->create_face( infinite, fn->vertex(fn->cw(in)), fn->vertex(fn->ccw(in))); fn->set_neighbor(in,newf); newf->set_neighbor(0,fn); last->set_neighbor(2,newf); newf->set_neighbor(1,last); newf->set_constraint(0, fn->is_constrained(in)); if (lower_list->is_removable(fn)) { lower_list->remove_flat(fn); } (newf->vertex(2))->set_face(newf->neighbor(0)); last=newf; } last->set_neighbor(2,first);first->set_neighbor(1,last); (first->vertex(2))->set_face(first->neighbor(0)); //cannot be done before infinite->set_face(last); return; } template bool Constrained_triangulation_sweep_2:: do_intersect(const Constraint& c1, const Constraint& c2 ) { // The constraints are known to be non degenerate // ordered (c.first Lexicographic less than c.second) // and to span some common y-value. // They do not have the same first point but they can share the same // endpoint. if ( (!event_less(c1.second, c2.second)) && (!event_less(c2.second, c1.second)) ) {return false;} else{ Orientation t1 = geom_traits().orientation(c1.first,c1.second,c2.first); Orientation t2 = geom_traits().orientation(c1.first,c1.second,c2.second); if (t1 == COLLINEAR && t2 == COLLINEAR) {return true;} return ( t1 != t2 && (geom_traits().orientation(c2.first,c2.second,c1.first) != geom_traits().orientation(c2.first,c2.second,c1.second))); } // return false; } CGAL_END_NAMESPACE #endif //CGAL_CONSTRAINED_TRIANGULATION_SWEEP_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Tree_base.h0000644000175000017500000002023411344301501027064 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Tree_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Gabriele Neyer #ifndef __CGAL_Tree_base_d__ #define __CGAL_Tree_base_d__ #include #include #include #include #include #include #include #ifndef USE_ARGUMENT #define USE_ARGUMENT( X ) (void)(X); #endif #ifndef USE_VARIABLE #define USE_VARIABLE( X ) (void)(&(X)); #endif #ifndef TREE_BASE_NULL #define TREE_BASE_NULL 0 #endif #ifndef CGAL__static_cast #define CGAL__static_cast(TYPE,EXPR) (TYPE)(EXPR) #endif #ifndef CGAL__const_cast #define CGAL__const_cast(TYPE,EXPR) (TYPE)(EXPR) #endif #ifndef CGAL__reinterpret_cast #define CGAL__reinterpret_cast(TYPE,EXPR) (TYPE)(EXPR) #endif #define stlvector CGAL_BEGIN_NAMESPACE //link type definition of an ordinary vertex of the tree struct Tree_node_base { void *parent_link; void *left_link; void *right_link; Tree_node_base() :parent_link(0), left_link(0), right_link(0) {} Tree_node_base(void* ll, void* rl) :parent_link(0), left_link(ll), right_link(rl) {} }; // ------------------------------------------------------------------- // pure virtual abstract base class. // Designed according to the Prototype Design Pattern // A tree class has to be derived from this class. template class Tree_base { protected: Tree_base(Tree_base const &); // prevent access void operator= (Tree_base const &); // prevent access public: typedef double vit; typedef int lit; typedef int lbit; typedef double vbit; typedef char oit; // typedef std::vector::iterator vit; //typedef std::list::iterator lit; //typedef std::back_insert_iterator lbit; //typedef std::back_insert_iterator vbit; typedef Tree_base Tree_base_type; Tree_base() {} virtual ~Tree_base() {} // 'clone()' returns an object which can be used as argument to 'delete' virtual Tree_base *clone() const = 0; //virtual Tree_base_type *clone() const = 0; // 'make_tree()' returns an object which can be used as argument to 'delete' virtual bool make_tree(const typename std::list::iterator& beg, const typename std::list::iterator& end, lit *dummy=0) =0; #ifdef stlvector virtual bool make_tree(const typename std::vector::iterator& beg, const typename std::vector::iterator& end, vit *dummy=0) =0; #endif #ifdef carray virtual bool make_tree(const C_Data *beg, const C_Data *end) =0; #endif virtual std::back_insert_iterator< std::list > window_query(C_Window const &win, std::back_insert_iterator< std::list > out,lbit *dummy=0 ) = 0; virtual std::back_insert_iterator< std::vector > window_query(C_Window const &win, std::back_insert_iterator< std::vector > out,vbit *dummy=0) = 0; #ifdef carray virtual C_Data * window_query( C_Window const &win, C_Data * out) = 0; #endif #ifdef ostreamiterator typedef std::ostream_iterator< C_Data> oit; virtual std::ostream_iterator< C_Data> window_query( C_Window const &win, std::ostream_iterator< C_Data> out, oit *dummy=0 ) = 0; #endif virtual std::back_insert_iterator< std::list< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, lbit *dummy=0 ) = 0; virtual std::back_insert_iterator< std::vector< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out,vbit *dummy=0 ) = 0; #ifdef carray virtual C_Data * enclosing_query( C_Window const &win, C_Data *out) = 0; #endif #ifdef ostreamiterator virtual std::ostream_iterator< C_Data> enclosing_query( C_Window const &win, std::ostream_iterator< C_Data> out, oit *dummy=0) = 0; #endif virtual bool is_inside( C_Window const &win, C_Data const& object) const =0; virtual bool is_anchor()const =0; virtual bool is_valid()const =0; }; // ------------------------------------------------------------------- // Tree Anchor: this class is used as a recursion anchor. // The derived tree classes can be nested. Use this class as the // most inner class. This class is doing nothin exept stopping the recursion template class Tree_anchor: public Tree_base< C_Data, C_Window> { public: // Construct a factory with the given factory as sublayer Tree_anchor() {} virtual ~Tree_anchor(){} Tree_base *clone() const { return new Tree_anchor(); } typedef Tree_base tbt; // Tree_base_type *clone() const { return new Tree_anchor(); } bool make_tree(const typename std::list< C_Data>::iterator& beg, const typename std::list< C_Data>::iterator& end, typename tbt::lit * =0) { USE_ARGUMENT(beg); USE_ARGUMENT(end); return true; } #ifdef stlvector bool make_tree(const typename std::vector< C_Data>::iterator& beg, const typename std::vector< C_Data>::iterator& end, typename tbt::vit * =0) { USE_ARGUMENT(beg); USE_ARGUMENT(end); return true; } #endif #ifdef carray bool make_tree(const C_Data *beg, const C_Data *end) { USE_ARGUMENT(beg); USE_ARGUMENT(end); return true; } #endif std::back_insert_iterator< std::list< C_Data> > window_query( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, typename tbt::lbit * =0){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } std::back_insert_iterator< std::vector< C_Data> > window_query( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out, typename tbt::vbit * =0){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } #ifdef carray C_Data * window_query( C_Window const &win, C_Data * out){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } #endif #ifdef ostreamiterator std::ostream_iterator< C_Data> window_query( C_Window const &win, std::ostream_iterator< C_Data> out, typename tbt::oit *dummy=0){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } #endif std::back_insert_iterator< std::list< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::list< C_Data> > out, typename tbt::lbit * =0){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } std::back_insert_iterator< std::vector< C_Data> > enclosing_query( C_Window const &win, std::back_insert_iterator< std::vector< C_Data> > out, typename tbt::vbit * =0){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } #ifdef carray C_Data * enclosing_query( C_Window const &win, C_Data * out){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } #endif #ifdef ostreamiterator std::ostream_iterator< C_Data> enclosing_query( C_Window const &win, std::ostream_iterator< C_Data> out, typename tbt::oit *dummy=0){ USE_ARGUMENT(win); USE_ARGUMENT(out); return out; } #endif bool is_valid()const{ return true;} protected: bool is_inside( C_Window const &win, C_Data const& object) const { USE_ARGUMENT(win); USE_ARGUMENT(object); return true; } bool is_anchor()const {return true;} }; CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Linear_algebraHd.h0000644000175000017500000002140011344301500030331 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Linear_algebraHd.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel //--------------------------------------------------------------------- // file generated by notangle from Linear_algebra.lw // please debug or modify noweb file // based on LEDA architecture by S. Naeher, C. Uhrig // coding: K. Mehlhorn, M. Seel // debugging and templatization: M. Seel //--------------------------------------------------------------------- #ifndef CGAL_LINEAR_ALGEBRAHD_H #define CGAL_LINEAR_ALGEBRAHD_H #include #include // #define CGAL_LA_SELFTEST CGAL_BEGIN_NAMESPACE /*{\Moptions outfile=Linear_algebra.man}*/ /*{\Manpage {Linear_algebraHd}{RT}{Linear Algebra on RT}{LA}}*/ template class Linear_algebraHd { /*{\Mdefinition The data type |\Mname| encapsulates two classes |Matrix|, |Vector| and many functions of basic linear algebra. It is parametrized by a number type |RT|. An instance of data type |Matrix| is a matrix of variables of type |RT|, the so called ring type. Accordingly, |Vector| implements vectors of variables of type |RT|. The arithmetic type |RT| is required to behave like integers in the mathematical sense. The manual pages of |Vector| and |Matrix| follow below. All functions compute the exact result, i.e., there is no rounding error. Most functions of linear algebra are \emph{checkable}, i.e., the programs can be asked for a proof that their output is correct. For example, if the linear system solver declares a linear system $A x = b$ unsolvable it also returns a vector $c$ such that $c^T A = 0$ and $c^T b \neq 0$. All internal correctness checks can be switched on by the flag [[CGAL_LA_SELFTEST]].}*/ public: /*{\Mtypes 5.5}*/ typedef RT_ RT; /*{\Mtypemember the ring type of the components.}*/ typedef CGALLA::Vector_ Vector; /*{\Mtypemember the vector type.}*/ typedef CGALLA::Matrix_ Matrix; /*{\Mtypemember the matrix type.}*/ typedef AL_ allocator_type; /*{\Mtypemember the allocator used for memory management. |\Mname| is an abbreviation for |Linear_algebraHd >|. Thus |allocator_type| defaults to the standard allocator offered by the STL.}*/ /*{\Moperations 2 1}*/ static Matrix transpose(const Matrix& M); /*{\Mstatic returns $M^T$ ($m\times n$ - matrix). }*/ static bool inverse(const Matrix& M, Matrix& I, RT& D, Vector& c); /*{\Mstatic determines whether |M| has an inverse. It also computes either the inverse as $(1/D) \cdot |I|$ or when no inverse exists, a vector $c$ such that $c^T \cdot M = 0 $. }*/ static Matrix inverse(const Matrix& M, RT& D) /*{\Mstatic returns the inverse matrix of |M|. More precisely, $1/D$ times the matrix returned is the inverse of |M|.\\ \precond |determinant(M) != 0|. }*/ { Matrix result; Vector c; if (!inverse(M,result,D,c)) CGAL_assertion_msg(0,"inverse(): matrix is singular."); return result; } static RT determinant (const Matrix& M, Matrix& L, Matrix& U, std::vector& q, Vector& c); /*{\Mstatic returns the determinant $D$ of |M| and sufficient information to verify that the value of the determinant is correct. If the determinant is zero then $c$ is a vector such that $c^T \cdot M = 0$. If the determinant is non-zero then $L$ and $U$ are lower and upper diagonal matrices respectively and $q$ encodes a permutation matrix $Q$ with $Q(i,j) = 1$ iff $i = q(j)$ such that $L \cdot M \cdot Q = U$, $L(0,0) = 1$, $L(i,i) = U(i - 1,i - 1)$ for all $i$, $1 \le i < n$, and $D = s \cdot U(n - 1,n - 1)$ where $s$ is the determinant of $Q$. \precond |M| is square. }*/ static bool verify_determinant (const Matrix& M, RT D, Matrix& L, Matrix& U, const std::vector& q, Vector& c); /*{\Mstatic verifies the conditions stated above. }*/ static RT determinant (const Matrix& M); /*{\Mstatic returns the determinant of |M|. \precond |M| is square. }*/ static int sign_of_determinant (const Matrix& M); /*{\Mstatic returns the sign of the determinant of |M|. \precond |M| is square. }*/ static bool linear_solver(const Matrix& M, const Vector& b, Vector& x, RT& D, Matrix& spanning_vectors, Vector& c); /*{\Mstatic determines the complete solution space of the linear system $M\cdot x = b$. If the system is unsolvable then $c^T \cdot M = 0$ and $c^T \cdot b \not= 0$. If the system is solvable then $(1/D) x$ is a solution, and the columns of |spanning_vectors| are a maximal set of linearly independent solutions to the corresponding homogeneous system. \precond |M.row_dimension() = b.dimension()|. }*/ static bool linear_solver(const Matrix& M, const Vector& b, Vector& x, RT& D, Vector& c) /*{\Mstatic determines whether the linear system $M\cdot x = b$ is solvable. If yes, then $(1/D) x$ is a solution, if not then $c^T \cdot M = 0$ and $c^T \cdot b \not= 0$. \precond |M.row_dimension() = b.dimension()|. }*/ { Matrix spanning_vectors; return linear_solver(M,b,x,D,spanning_vectors,c); } static bool linear_solver(const Matrix& M, const Vector& b, Vector& x, RT& D) /*{\Mstatic as above, but without the witness $c$ \precond |M.row_dimension() = b.dimension()|. }*/ { Matrix spanning_vectors; Vector c; return linear_solver(M,b,x,D,spanning_vectors,c); } static bool is_solvable(const Matrix& M, const Vector& b) /*{\Mstatic determines whether the system $M \cdot x = b$ is solvable \\ \precond |M.row_dimension() = b.dimension()|. }*/ { Vector x; RT D; Matrix spanning_vectors; Vector c; return linear_solver(M,b,x,D,spanning_vectors,c); } static bool homogeneous_linear_solver (const Matrix& M, Vector& x); /*{\Mstatic determines whether the homogeneous linear system $M\cdot x = 0$ has a non - trivial solution. If yes, then $x$ is such a solution. }*/ static int homogeneous_linear_solver (const Matrix& M, Matrix& spanning_vecs); /*{\Mstatic determines the solution space of the homogeneous linear system $M\cdot x = 0$. It returns the dimension of the solution space. Moreover the columns of |spanning_vecs| span the solution space. }*/ static int independent_columns (const Matrix& M, std::vector& columns); /*{\Mstatic returns the indices of a maximal subset of independent columns of |M|.}*/ static int rank (const Matrix & M); /*{\Mstatic returns the rank of matrix |M| }*/ /*{\Mimplementation The datatype |\Mname| is a wrapper class for the linear algebra functionality on matrices and vectors. Operations |determinant|, |inverse|, |linear_solver|, and |rank| take time $O(n^3)$, and all other operations take time $O(nm)$. These time bounds ignore the cost for multiprecision arithmetic operations. All functions on integer matrices compute the exact result, i.e., there is no rounding error. The implemenation follows a proposal of J. Edmonds (J. Edmonds, Systems of distinct representatives and linear algebra, Journal of Research of the Bureau of National Standards, (B), 71, 241 - 245). Most functions of linear algebra are { \em checkable }, i.e., the programs can be asked for a proof that their output is correct. For example, if the linear system solver declares a linear system $A x = b$ unsolvable it also returns a vector $c$ such that $c^T A = 0$ and $c^T b \not= 0$.}*/ }; // Linear_algebraHd CGAL_END_NAMESPACE #include #endif // CGAL_LINALG_ALGEBRAHD_H ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_utils_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_utils_3.0000644000175000017500000000517611344301501031315 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_utils_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud #ifndef CGAL_TRIANGULATION_UTILS_3_H #define CGAL_TRIANGULATION_UTILS_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE // We use the following template class in order to avoid having a static data // member of a non-template class which would require src/Triangulation_3.C . template < class T = void > struct Triangulation_utils_base_3 { static const char tab_next_around_edge[4][4]; static const int tab_vertex_triple_index[4][3]; }; template < class T > const char Triangulation_utils_base_3::tab_next_around_edge[4][4] = { {5, 2, 3, 1}, {3, 5, 0, 2}, {1, 3, 5, 0}, {2, 0, 1, 5} }; template < class T > const int Triangulation_utils_base_3::tab_vertex_triple_index[4][3] = { {1, 3, 2}, {0, 2, 3}, {0, 3, 1}, {0, 1, 2} }; // We derive from Triangulation_cw_ccw_2 because we still use cw() and ccw() // in the 2D part of the code. Ideally, this should go away when we re-use // T2D entirely. struct Triangulation_utils_3 : public Triangulation_cw_ccw_2, public Triangulation_utils_base_3<> { static int next_around_edge(const int i, const int j) { // index of the next cell when turning around the // oriented edge vertex(i) vertex(j) in 3d CGAL_triangulation_precondition( ( i >= 0 && i < 4 ) && ( j >= 0 && j < 4 ) && ( i != j ) ); return tab_next_around_edge[i][j]; } static int vertex_triple_index(const int i, const int j) { // indexes of the jth vertex of the facet of a cell // opposite to vertx i CGAL_triangulation_precondition( ( i >= 0 && i < 4 ) && ( j >= 0 && j < 3 ) ); return tab_vertex_triple_index[i][j]; } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_UTILS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_polyhedron_S2.h0000644000175000017500000006161211344301500030516 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_polyhedron_S2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel // Peter Hachenberger #ifndef CGAL_NEF_POLYHEDRON_S2_H #define CGAL_NEF_POLYHEDRON_S2_H #include #include #include #include #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 121 #include CGAL_BEGIN_NAMESPACE template class Nef_polyhedron_S2; template class Nef_polyhedron_S2_rep; template class Nef_polyhedron_3; class SNC_items; template std::ostream& operator<<(std::ostream&, const Nef_polyhedron_S2&); template std::istream& operator>>(std::istream&, Nef_polyhedron_S2&); template class Nef_polyhedron_S2_rep { typedef Nef_polyhedron_S2_rep Self; friend class Nef_polyhedron_S2; public: typedef CGAL::Sphere_geometry Sphere_kernel; typedef Mk Mark; typedef M Sphere_map; typedef CGAL::SM_const_decorator Const_decorator; typedef CGAL::SM_decorator Decorator; typedef CGAL::SM_overlayer Overlayer; typedef CGAL::SM_point_locator Locator; private: Sphere_map sm_; public: Nef_polyhedron_S2_rep() : sm_() {} Nef_polyhedron_S2_rep(const Self& R) : sm_() {} ~Nef_polyhedron_S2_rep() { sm_.clear(); } }; /*{\Moptions print_title=yes }*/ /*{\Manpage {Nef_polyhedron_S2}{K} {Nef Polyhedra in the sphere surface}{N}}*/ /*{\Mdefinition An instance of data type |\Mname| is a subset of $S_2$ that is the result of forming complements and intersections starting from a finite set |H| of half-spaces. |\Mtype| is closed under all binary set operations |intersection|, |union|, |difference|, |complement| and under the topological operations |boundary|, |closure|, and |interior|. The template parameter |Kernel| is specified via a kernel concept. |Kernel| must be a model of the concept |NefSphereKernelTraits_2|. }*/ template ,Items_, Mark_> > class Nef_polyhedron_S2 : public Handle_for< Nef_polyhedron_S2_rep >, public Nef_polyhedron_S2_rep::Const_decorator { public: /*{\Mtypes 7}*/ typedef Items_ Items; typedef Kernel_ Kernel; typedef Map_ Sphere_map; typedef Mark_ Mark; typedef Nef_polyhedron_S2 Self; typedef Nef_polyhedron_S2_rep Rep; typedef Handle_for< Nef_polyhedron_S2_rep > Base; typedef typename Rep::Sphere_kernel Sphere_kernel; // typedef typename Rep::Sphere_map Sphere_map; typedef typename Sphere_kernel::Sphere_point Sphere_point; /*{\Mtypemember points in the sphere surface.}*/ typedef typename Sphere_kernel::Sphere_segment Sphere_segment; /*{\Mtypemember segments in the sphere surface.}*/ typedef typename Sphere_kernel::Sphere_circle Sphere_circle; /*{\Mtypemember oriented great circles modeling spherical half-spaces}*/ typedef typename Sphere_kernel::Sphere_direction Sphere_direction; // typedef typename Rep::Mark Mark; /*{\Xtypemember marking set membership or exclusion.}*/ enum Boundary { EXCLUDED=0, INCLUDED=1 }; /*{\Menum construction selection.}*/ enum Content { EMPTY=0, COMPLETE=1 }; /*{\Menum construction selection}*/ const Sphere_map& sphere_map() const { return this->ptr()->sm_; } protected: Sphere_map& sphere_map() { return this->ptr()->sm_; } struct AND { bool operator()(const Mark& b1, const Mark& b2) const { return b1&&b2; } }; struct OR { bool operator()(const Mark& b1, const Mark& b2) const { return b1||b2; } }; struct DIFF { bool operator()(const Mark& b1, const Mark& b2) const { return b1&&!b2; } }; struct XOR { bool operator()(const Mark& b1, const Mark& b2) const { return (b1&&!b2)||(!b1&&b2); } }; typedef Nef_polyhedron_S2_rep Nef_rep; typedef typename Nef_rep::Decorator Decorator; typedef typename Nef_rep::Const_decorator Const_decorator; typedef typename Nef_rep::Overlayer Overlayer; typedef typename Nef_rep::Locator Locator; friend std::ostream& operator<< <> (std::ostream& os, const Self& NP); friend std::istream& operator>> <> (std::istream& is, Self& NP); public: typedef typename Decorator::SVertex_handle SVertex_handle; typedef typename Decorator::SHalfedge_handle SHalfedge_handle; typedef typename Decorator::SHalfloop_handle SHalfloop_handle; typedef typename Decorator::SFace_handle SFace_handle; typedef typename Sphere_map::SVertex_base SVertex; typedef typename Sphere_map::SHalfedge_base SHalfedge; typedef typename Sphere_map::SHalfloop SHalfloop; typedef typename Sphere_map::SFace_base SFace; typedef typename Decorator::SVertex_const_handle SVertex_const_handle; typedef typename Decorator::SHalfedge_const_handle SHalfedge_const_handle; typedef typename Decorator::SHalfloop_const_handle SHalfloop_const_handle; typedef typename Decorator::SFace_const_handle SFace_const_handle; typedef typename Decorator::SVertex_iterator SVertex_iterator; typedef typename Decorator::SHalfedge_iterator SHalfedge_iterator; typedef typename Decorator::SHalfloop_iterator SHalfloop_iterator; typedef typename Decorator::SFace_iterator SFace_iterator; typedef typename Const_decorator::SVertex_const_iterator SVertex_const_iterator; typedef typename Const_decorator::SHalfedge_const_iterator SHalfedge_const_iterator; typedef typename Const_decorator::SHalfloop_const_iterator SHalfloop_const_iterator; typedef typename Const_decorator::SFace_const_iterator SFace_const_iterator; typedef typename Const_decorator::Size_type Size_type; typedef Size_type size_type; typedef std::list SS_list; typedef typename SS_list::const_iterator SS_iterator; friend class Nef_polyhedron_3; public: /*{\Mcreation 3}*/ Nef_polyhedron_S2(Content sphere = EMPTY) : Base(Nef_rep()) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to the empty set if |sphere == EMPTY| and to the whole sphere if |sphere == COMPLETE|.}*/ { set_sm(&sphere_map()); Decorator D(&sphere_map()); SFace_handle sf=D.new_sface(); D.mark(sf) = bool(sphere); } Nef_polyhedron_S2(const Sphere_circle& c, Boundary circle = INCLUDED) : Base(Nef_rep()) { /*{\Mcreate creates a Nef polyhedron |\Mvar| containing the half-sphere left of |c| including |c| if |circle==INCLUDED|, excluding |c| if |circle==EXCLUDED|.}*/ set_sm(&sphere_map()); CGAL_NEF_TRACEN("Nef_polyhedron_S2(): construction from circle "< Nef_polyhedron_S2(Forward_iterator first, Forward_iterator beyond, Boundary b = INCLUDED) : Base(Nef_rep()) /*{\Mcreate creates a Nef polyhedron |\Mvar| from the set of sphere segments in the iterator range |[first,beyond)|. If the set of sphere segments is a simple polygon that separates the sphere surface into two regions, then the polygonal region that is left of the segment |*first| is selected. The polygonal region includes its boundary if |b = INCLUDED| and excludes the boundary otherwise. |Forward_iterator| has to be an iterator with value type |Sphere_segment|.}*/ { CGAL_NEF_TRACEN("Nef_polyhedron_S2(): creation from segment range"); CGAL_assertion(first!=beyond); set_sm(&sphere_map()); Overlayer D(&sphere_map()); Sphere_segment s = *first; D.create_from_segments(first,beyond); SHalfedge_iterator e; CGAL_forall_shalfedges(e,D) { Sphere_circle c(D.circle(e)); if ( c == s.sphere_circle() ) break; } if ( e != SHalfedge_iterator() ) { if ( D.circle(e) != s.sphere_circle() ) e = D.twin(e); CGAL_assertion( D.circle(e) == s.sphere_circle() ); D.set_marks_in_face_cycle(e,bool(b)); if ( D.number_of_sfaces() > 2 ) D.mark(D.face(e)) = true; else D.mark(D.face(e)) = !bool(b); return; } D.simplify(); } Nef_polyhedron_S2(const Self& N1) : Base(N1) { set_sm(&sphere_map()); } Nef_polyhedron_S2& operator=(const Self& N1) { Base::operator=(N1); set_sm(&sphere_map()); return (*this); } ~Nef_polyhedron_S2() {} template Nef_polyhedron_S2(Forward_iterator first, Forward_iterator beyond, double p) : Base(Nef_rep()) /*{\Xcreate creates a random Nef polyhedron from the arrangement of the set of circles |S = set[first,beyond)|. The cells of the arrangement are selected uniformly at random with probability $p$. \precond $0 < p < 1$.}*/ { CGAL_assertion(0<=p && p<=1); CGAL_assertion(first!=beyond); set_sm(&sphere_map()); Overlayer D(&sphere_map()); D.create_from_circles(first, beyond); D.simplify(); SVertex_iterator v; SHalfedge_iterator e; SFace_iterator f; CGAL_forall_svertices(v,D) D.mark(v) = ( default_random.get_double() < p ? true : false ); CGAL_forall_shalfedges(e,D) D.mark(e) = ( default_random.get_double() < p ? true : false ); CGAL_forall_sfaces(f,D) D.mark(f) = ( default_random.get_double() < p ? true : false ); D.simplify(); } protected: Nef_polyhedron_S2(const Sphere_map& H, bool clone=true) : Base(Nef_rep()) /*{\Xcreate makes |\Mvar| a new object. If |clone==true| then the underlying structure of |H| is copied into |\Mvar|.}*/ { if(clone) this->ptr()->sm_ = H; set_sm(&sphere_map()); } void clone_rep() { *this = Self(sphere_map()); } /*{\Moperations 4 3 }*/ public: void clear(Content plane = EMPTY) { *this = Nef_polyhedron_S2(plane); } /*{\Mop makes |\Mvar| the empty set if |plane == EMPTY| and the full plane if |plane == COMPLETE|.}*/ bool is_empty() const /*{\Mop returns true if |\Mvar| is empty, false otherwise.}*/ { Const_decorator D(&sphere_map()); CGAL_NEF_TRACEN("is_empty()"<<*this); SFace_const_iterator f = D.sfaces_begin(); return (D.number_of_svertices()==0 && D.number_of_sedges()==0 && D.number_of_sloops()==0 && D.number_of_sfaces()==1 && D.mark(f) == false); } bool is_plane() const /*{\Mop returns true if |\Mvar| is the whole plane, false otherwise.}*/ { Const_decorator D(&sphere_map()); SFace_const_iterator f = D.sfaces_begin(); return (D.number_of_svertices()==0 && D.number_of_sedges()==0 && D.number_of_sloops()==0 && D.number_of_sfaces()==1 && D.mark(f) == true); } void extract_complement() { CGAL_NEF_TRACEN("extract complement"); if ( this->is_shared() ) clone_rep(); Overlayer D(&sphere_map()); SVertex_iterator v; SHalfedge_iterator e; SFace_iterator f; CGAL_forall_svertices(v,D) D.mark(v) = !D.mark(v); CGAL_forall_sedges(e,D) D.mark(e) = !D.mark(e); CGAL_forall_sfaces(f,D) D.mark(f) = !D.mark(f); if ( D.has_shalfloop() ) D.mark(D.shalfloop()) = !D.mark(D.shalfloop()); } void extract_interior() { CGAL_NEF_TRACEN("extract interior"); if ( this->is_shared() ) clone_rep(); Overlayer D(&sphere_map()); SVertex_iterator v; SHalfedge_iterator e; CGAL_forall_svertices(v,D) D.mark(v) = false; CGAL_forall_sedges(e,D) D.mark(e) = false; if ( D.has_sloop() ) D.mark(D.shalfloop()) = false; D.simplify(); } void extract_boundary() { CGAL_NEF_TRACEN("extract boundary"); if ( this->is_shared() ) clone_rep(); Overlayer D(&sphere_map()); SVertex_iterator v; SHalfedge_iterator e; SFace_iterator f; CGAL_forall_svertices(v,D) D.mark(v) = true; CGAL_forall_sedges(e,D) D.mark(e) = true; CGAL_forall_sfaces(f,D) D.mark(f) = false; if ( D.has_sloop() ) D.mark(D.shalfloop()) = true; D.simplify(); } void extract_closure() /*{\Xop converts |\Mvar| to its closure. }*/ { CGAL_NEF_TRACEN("extract closure"); extract_complement(); extract_interior(); extract_complement(); } void extract_regularization() /*{\Xop converts |\Mvar| to its regularization. }*/ { CGAL_NEF_TRACEN("extract regularization"); extract_interior(); extract_closure(); } /*{\Mtext \headerline{Constructive Operations}}*/ Self complement() const /*{\Mop returns the complement of |\Mvar| in the plane.}*/ { Self res = *this; res.extract_complement(); return res; } Self interior() const /*{\Mop returns the interior of |\Mvar|.}*/ { Self res = *this; res.extract_interior(); return res; } Self closure() const /*{\Mop returns the closure of |\Mvar|.}*/ { Self res = *this; res.extract_closure(); return res; } Self boundary() const /*{\Mop returns the boundary of |\Mvar|.}*/ { Self res = *this; res.extract_boundary(); return res; } Self regularization() const /*{\Mop returns the regularized polyhedron (closure of interior).}*/ { Self res = *this; res.extract_regularization(); return res; } Self intersection(const Self& N1) const /*{\Mop returns |\Mvar| $\cap$ |N1|. }*/ { Self res(sphere_map(),false); // empty Overlayer D(&res.sphere_map()); D.subdivide(&sphere_map(),&N1.sphere_map()); AND _and; D.select(_and); D.simplify(); return res; } Self join(const Self& N1) const /*{\Mop returns |\Mvar| $\cup$ |N1|. }*/ { Self res(sphere_map(),false); // empty Overlayer D(&res.sphere_map()); D.subdivide(&sphere_map(),&N1.sphere_map()); OR _or; D.select(_or); D.simplify(); return res; } Self difference(const Self& N1) const /*{\Mop returns |\Mvar| $-$ |N1|. }*/ { Self res(sphere_map(),false); // empty Overlayer D(&res.sphere_map()); D.subdivide(&sphere_map(),&N1.sphere_map()); DIFF _diff; D.select(_diff); D.simplify(); return res; } Self symmetric_difference( const Self& N1) const /*{\Mop returns the symmectric difference |\Mvar - T| $\cup$ |T - \Mvar|. }*/ { Self res(sphere_map(),false); // empty Overlayer D(&res.sphere_map()); D.subdivide(&sphere_map(),&N1.sphere_map()); XOR _xor; D.select(_xor); D.simplify(); return res; } /*{\Mtext Additionally there are operators |*,+,-,^,!| which implement the binary operations \emph{intersection}, \emph{union}, \emph{difference}, \emph{symmetric difference}, and the unary operation \emph{complement} respectively. There are also the corresponding modification operations |*=,+=,-=,^=|.}*/ Self operator*(const Self& N1) const { return intersection(N1); } Self operator+(const Self& N1) const { return join(N1); } Self operator-(const Self& N1) const { return difference(N1); } Self operator^(const Self& N1) const { return symmetric_difference(N1); } Self operator!() const { return complement(); } Self& operator*=(const Self& N1) { *this = intersection(N1); return *this; } Self& operator+=(const Self& N1) { *this = join(N1); return *this; } Self& operator-=(const Self& N1) { *this = difference(N1); return *this; } Self& operator^=(const Self& N1) { *this = symmetric_difference(N1); return *this; } /*{\Mtext There are also comparison operations like |<,<=,>,>=,==,!=| which implement the relations subset, subset or equal, superset, superset or equal, equality, inequality, respectively.}*/ bool operator==(const Self& N1) const { return symmetric_difference(N1).is_empty(); } bool operator!=(const Self& N1) const { return !operator==(N1); } bool operator<=(const Self& N1) const { return difference(N1).is_empty(); } bool operator<(const Self& N1) const { return difference(N1).is_empty() && !N1.difference(*this).is_empty(); } bool operator>=(const Self& N1) const { return N1.difference(*this).is_empty(); } bool operator>(const Self& N1) const { return N1.difference(*this).is_empty() && !difference(N1).is_empty(); } /*{\Mtext \headerline{Exploration - Point location - Ray shooting} As Nef polyhedra are the result of forming complements and intersections starting from a set |H| of half-spaces that are defined by oriented lines in the plane, they can be represented by an attributed plane map $M = (V,E,F)$. For topological queries within |M| the following types and operations allow exploration access to this structure.}*/ /*{\Mtypes 3}*/ typedef Const_decorator Topological_explorer; typedef Const_decorator Explorer; /*{\Mtypemember a decorator to examine the underlying plane map. See the manual page of |Explorer|.}*/ typedef typename Locator::Object_handle Object_handle; /*{\Mtypemember a generic handle to an object of the underlying plane map. The kind of object |(vertex, halfedge, face)| can be determined and the object can be assigned to a corresponding handle by the three functions:\\ |bool assign(SVertex_const_handle& h, Object_handle)|\\ |bool assign(SHalfedge_const_handle& h, Object_handle)|\\ |bool assign(SFace_const_handle& h, Object_handle)|\\ where each function returns |true| iff the assignment to |h| was done.}*/ /*{\Moperations 3 1 }*/ bool contains(Object_handle h) const /*{\Mop returns true iff the object |h| is contained in the set represented by |\Mvar|.}*/ { Locator PL(&sphere_map()); return PL.mark(h); } bool contained_in_boundary(Object_handle h) const /*{\Mop returns true iff the object |h| is contained in the $1$-skeleton of |\Mvar|.}*/ { SVertex_const_handle v; SHalfedge_const_handle e; return ( CGAL::assign(v,h) || CGAL::assign(e,h) ); } Object_handle locate(const Sphere_point& p) const /*{\Mop returns a generic handle |h| to an object (face, halfedge, vertex) of the underlying plane map that contains the point |p| in its relative interior. The point |p| is contained in the set represented by |\Mvar| if |\Mvar.contains(h)| is true. The location mode flag |m| allows one to choose between different point location strategies.}*/ { Locator PL(&sphere_map()); return PL.locate(p); } struct INSET { const Const_decorator& D; INSET(const Const_decorator& Di) : D(Di) {} bool operator()(SVertex_const_handle v) const { return D.mark(v); } bool operator()(SHalfedge_const_handle e) const { return D.mark(e); } bool operator()(SHalfloop_const_handle l) const { return D.mark(l); } bool operator()(SFace_const_handle f) const { return D.mark(f); } }; Object_handle ray_shoot(const Sphere_point& p, const Sphere_direction& d) const /*{\Mop returns a handle |h| with |\Mvar.contains(h)| that can be converted to a |SVertex_/SHalfedge_/SFace_const_handle| as described above. The object returned is intersected by the ray starting in |p| with direction |d| and has minimal distance to |p|. The operation returns the null handle |NULL| if the ray shoot along |d| does not hit any object |h| of |\Mvar| with |\Mvar.contains(h)|.}*/ { Locator PL(&sphere_map()); return PL.ray_shoot(p,d,INSET(PL)); } struct INSKEL { bool operator()(SVertex_const_handle) const { return true; } bool operator()(SHalfedge_const_handle) const { return true; } bool operator()(SHalfloop_const_handle) const { return true; } bool operator()(SFace_const_handle) const { return false; } }; Object_handle ray_shoot_to_boundary(const Sphere_point& p, const Sphere_direction& d) const /*{\Mop returns a handle |h| that can be converted to a |SVertex_/SHalfedge_const_handle| as described above. The object returned is part of the $1$-skeleton of |\Mvar|, intersected by the ray starting in |p| with direction |d| and has minimal distance to |p|. The operation returns the null handle |NULL| if the ray shoot along |d| does not hit any $1$-skeleton object |h| of |\Mvar|. The location mode flag |m| allows one to choose between different point location strategies.}*/ { Locator PL(&sphere_map()); return PL.ray_shoot(p,d,INSKEL()); } // Explorer explorer() const /*{\Mop returns a decorator object which allows read-only access of the underlying plane map. See the manual page |Explorer| for its usage.}*/ // { return Explorer(const_cast(&sphere_map())); } /*{\Mtext\headerline{Input and Output} A Nef polyhedron |\Mvar| can be visualized in an open GL window. The output operator is defined in the file |CGAL/IO/Nef_\-poly\-hedron_2_\-Win\-dow_\-stream.h|. }*/ /*{\Mimplementation Nef polyhedra are implemented on top of a halfedge data structure and use linear space in the number of vertices, edges and facets. Operations like |empty| take constant time. The operations |clear|, |complement|, |interior|, |closure|, |boundary|, |regularization|, input and output take linear time. All binary set operations and comparison operations take time $O(n \log n)$ where $n$ is the size of the output plus the size of the input. The point location and ray shooting operations are implemented in the naive way. The operations run in linear query time without any preprocessing.}*/ /*{\Mexample Nef polyhedra are parameterized by a standard CGAL kernel. \begin{Mverb} #include #include #include #include using namespace CGAL; typedef Homogeneous Kernel; typedef SM_items SM_items; typedef Nef_polyhedron_S2 Nef_polyhedron; typedef Nef_polyhedron::Sphere_circle Sphere_circle; int main() { Nef_polyhedron N1(Sphere_circle(1,0,0)); Nef_polyhedron N2(Sphere_circle(0,1,0), Nef_polyhedron::EXCLUDED); Nef_polyhedron N3 = N1 * N2; // line (*) return 0; } \end{Mverb} After line (*) |N3| is the intersection of |N1| and |N2|.}*/ }; // end of Nef_polyhedron_S2 template std::ostream& operator<< (std::ostream& os, const Nef_polyhedron_S2& NP) { os << "Nef_polyhedron_S2\n"; typedef typename Nef_polyhedron_S2::Explorer Decorator; CGAL::SM_io_parser O(os, Decorator(&NP.sphere_map())); O.print(); return os; } template std::istream& operator>> (std::istream& is, Nef_polyhedron_S2& NP) { typedef typename Nef_polyhedron_S2::Decorator Decorator; CGAL::SM_io_parser I(is, Decorator(NP.sphere_map())); if ( I.check_sep("Nef_polyhedron_S2") ) I.read(); else { std::cerr << "Nef_polyhedron_S2 input corrupted." << std::endl; NP = Nef_polyhedron_S2(); } typename Nef_polyhedron_S2::Topological_explorer D(NP.explorer()); D.check_integrity_and_topological_planarity(); return is; } CGAL_END_NAMESPACE #endif //CGAL_NEF_POLYHEDRON_S2_H ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_Delaunay_triangulation_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_Delaunay_t0000644000175000017500000005126711344301500031374 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_Delaunay_triangulation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec, Jean Daniel Boissonnat #ifndef CGAL_CONSTRAINED_DELAUNAY_TRIANGULATION_2_H #define CGAL_CONSTRAINED_DELAUNAY_TRIANGULATION_2_H #include #include #include CGAL_BEGIN_NAMESPACE template , Constrained_triangulation_face_base_2 >, class Itag = No_intersection_tag > class Constrained_Delaunay_triangulation_2 : public Constrained_triangulation_2 { public: typedef Constrained_triangulation_2 Ctr; typedef Constrained_Delaunay_triangulation_2 CDt; typedef typename Ctr::Geom_traits Geom_traits; typedef typename Ctr::Intersection_tag Intersection_tag; typedef typename Ctr::Constraint Constraint; typedef typename Ctr::Vertex_handle Vertex_handle; typedef typename Ctr::Face_handle Face_handle; typedef typename Ctr::Edge Edge; typedef typename Ctr::Finite_faces_iterator Finite_faces_iterator; typedef typename Ctr::Face_circulator Face_circulator; typedef typename Ctr::Locate_type Locate_type; typedef typename Ctr::List_edges List_edges; typedef typename Ctr::List_faces List_faces; typedef typename Ctr::List_vertices List_vertices; typedef typename Ctr::List_constraints List_constraints; typedef typename Ctr::Less_edge less_edge; typedef typename Ctr::Edge_set Edge_set; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_2 using Ctr::number_of_vertices; using Ctr::finite_faces_begin; using Ctr::finite_faces_end; using Ctr::dimension; using Ctr::cw; using Ctr::ccw; using Ctr::infinite_vertex; #endif typedef typename Geom_traits::Point_2 Point; Constrained_Delaunay_triangulation_2(const Geom_traits& gt=Geom_traits()) : Ctr(gt) { } Constrained_Delaunay_triangulation_2(const CDt& cdt) : Ctr(cdt) {} Constrained_Delaunay_triangulation_2(List_constraints& lc, const Geom_traits& gt=Geom_traits()) : Ctr(gt) { typename List_constraints::iterator itc = lc.begin(); for( ; itc != lc.end(); ++itc) { insert((*itc).first, (*itc).second); } CGAL_triangulation_postcondition( is_valid() ); } template Constrained_Delaunay_triangulation_2(InputIterator it, InputIterator last, const Geom_traits& gt=Geom_traits() ) : Ctr(gt) { for ( ; it != last; it++) { insert((*it).first, (*it).second); } CGAL_triangulation_postcondition( is_valid() ); } virtual ~Constrained_Delaunay_triangulation_2() {} // FLIPS bool is_flipable(Face_handle f, int i) const; void flip(Face_handle& f, int i); void flip_around(Vertex_handle va); void flip_around(List_vertices & new_vertices); void propagating_flip(Face_handle& f,int i); void propagating_flip(List_edges & edges); // CONFLICTS bool test_conflict(Face_handle fh, const Point& p) const; //deprecated bool test_conflict(const Point& p, Face_handle fh) const; void find_conflicts(const Point& p, std::list& le, //deprecated Face_handle hint= Face_handle()) const; // //template member functions, declared and defined at the end // template // std::pair // get_conflicts_and_boundary(const Point &p, // OutputItFaces fit, // OutputItBoundaryEdges eit, // Face_handle start) const; // template // OutputItFaces // get_conflicts (const Point &p, // OutputItFaces fit, // Face_handle start ) const; // template // OutputItBoundaryEdges // get_boundary_of_conflicts(const Point &p, // OutputItBoundaryEdges eit, // Face_handle start ) const; // INSERTION-REMOVAL Vertex_handle insert(const Point & a, Face_handle start = Face_handle()); Vertex_handle insert(const Point& p, Locate_type lt, Face_handle loc, int li ); Vertex_handle push_back(const Point& a); // template < class InputIterator > // int insert(InputIterator first, InputIterator last); void remove(Vertex_handle v); void remove_incident_constraints(Vertex_handle v); void remove_constrained_edge(Face_handle f, int i); // template // OutputItFaces // remove_constrained_edge(Face_handle f, int i, OutputItFaces out) //for backward compatibility void insert(Point a, Point b) { insert_constraint(a, b);} void insert(Vertex_handle va, Vertex_handle vb) {insert_constraint(va,vb);} void remove_constraint(Face_handle f, int i){remove_constrained_edge(f,i);} // CHECK bool is_valid(bool verbose = false, int level = 0) const; protected: virtual Vertex_handle virtual_insert(const Point & a, Face_handle start = Face_handle()); virtual Vertex_handle virtual_insert(const Point& a, Locate_type lt, Face_handle loc, int li ); //Vertex_handle special_insert_in_edge(const Point & a, Face_handle f, int i); void remove_2D(Vertex_handle v ); virtual void triangulate_hole(List_faces& intersected_faces, List_edges& conflict_boundary_ab, List_edges& conflict_boundary_ba); public: // MESHING // suppressed meshing functions from here //template member functions public: template < class InputIterator > #if defined(_MSC_VER) || defined(__SUNPRO_CC) int insert(InputIterator first, InputIterator last, int i = 0) #else int insert(InputIterator first, InputIterator last) #endif { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } template std::pair get_conflicts_and_boundary(const Point &p, OutputItFaces fit, OutputItBoundaryEdges eit, Face_handle start = Face_handle()) const { CGAL_triangulation_precondition( dimension() == 2); int li; Locate_type lt; Face_handle fh = locate(p,lt,li, start); switch(lt) { case Ctr::OUTSIDE_AFFINE_HULL: case Ctr::VERTEX: return std::make_pair(fit,eit); case Ctr::FACE: case Ctr::EDGE: case Ctr::OUTSIDE_CONVEX_HULL: *fit++ = fh; //put fh in OutputItFaces std::pair pit = std::make_pair(fit,eit); pit = propagate_conflicts(p,fh,0,pit); pit = propagate_conflicts(p,fh,1,pit); pit = propagate_conflicts(p,fh,2,pit); return pit; } CGAL_triangulation_assertion(false); return std::make_pair(fit,eit); } template OutputItFaces get_conflicts (const Point &p, OutputItFaces fit, Face_handle start= Face_handle()) const { std::pair pp = get_conflicts_and_boundary(p,fit,Emptyset_iterator(),start); return pp.first; } template OutputItBoundaryEdges get_boundary_of_conflicts(const Point &p, OutputItBoundaryEdges eit, Face_handle start= Face_handle()) const { std::pair pp = get_conflicts_and_boundary(p,Emptyset_iterator(),eit,start); return pp.second; } public: // made public for the need of Mesh_2 // but not documented template std::pair propagate_conflicts (const Point &p, Face_handle fh, int i, std::pair pit) const { Face_handle fn = fh->neighbor(i); OutputItFaces fit = pit.first; OutputItBoundaryEdges eit = pit.second; if ( fh->is_constrained(i) || ! test_conflict(p,fn)) { *eit++ = Edge(fn, fn->index(fh)); return std::make_pair(fit,eit); } *fit++ = fn; int j = fn->index(fh); pit = propagate_conflicts(p,fn,ccw(j),pit); pit = propagate_conflicts(p,fn,cw(j), pit); return pit; } public: template OutputItFaces propagating_flip(List_edges & edges, OutputItFaces out = Emptyset_iterator()) { // makes the triangulation Delaunay by flipping // List edges contains an initial list of edges to be flipped // Precondition : the output triangulation is Delaunay if the list // edges contains all edges of the input triangulation that need to be // flipped (plus possibly others) int i, ii, indf, indn; Face_handle ni, f,ff; Edge ei,eni; typename Ctr::Edge_set edge_set; typename Ctr::Less_edge less_edge; Edge e[4]; typename List_edges::iterator itedge=edges.begin(); // initialization of the set of edges to be flip while (itedge != edges.end()) { f=(*itedge).first; i=(*itedge).second; if (is_flipable(f,i)) { eni=Edge(f->neighbor(i),f->mirror_index(i)); if (less_edge(*itedge,eni)) edge_set.insert(*itedge); else edge_set.insert(eni); } ++itedge; } // flip edges and updates the set of edges to be flipped while (!(edge_set.empty())) { f=(*(edge_set.begin())).first; indf=(*(edge_set.begin())).second; // erase from edge_set the 4 edges of the wing of the edge to be // flipped (edge_set.begin) , i.e. the edges of the faces f and // f->neighbor(indf) that are distinct from the edge to be flipped ni = f->neighbor(indf); indn=f->mirror_index(indf); ei= Edge(f,indf); edge_set.erase(ei); e[0]= Edge(f,cw(indf)); e[1]= Edge(f,ccw(indf)); e[2]= Edge(ni,cw(indn)); e[3]= Edge(ni,ccw(indn)); for(i=0;i<4;i++) { ff=e[i].first; ii=e[i].second; eni=Edge(ff->neighbor(ii),ff->mirror_index(ii)); if (less_edge(e[i],eni)) {edge_set.erase(e[i]);} else { edge_set.erase(eni);} } // here is the flip *out++ = f; *out++ = f->neighbor(indf); flip(f, indf); //insert in edge_set the 4 edges of the wing of the edge that //have been flipped e[0]= Edge(f,indf); e[1]= Edge(f,cw(indf)); e[2]= Edge(ni,indn); e[3]= Edge(ni,cw(indn)); for(i=0;i<4;i++) { ff=e[i].first; ii=e[i].second; if (is_flipable(ff,ii)) { eni=Edge(ff->neighbor(ii),ff->mirror_index(ii)); if (less_edge(e[i],eni)) { edge_set.insert(e[i]);} else { edge_set.insert(eni);} } } } return out; } template OutputItFaces remove_constrained_edge(Face_handle f, int i, OutputItFaces out) { Ctr::remove_constrained_edge(f,i); if(dimension() == 2) { List_edges le; le.push_back(Edge(f,i)); propagating_flip(le,out); } return out; } }; template < class Gt, class Tds, class Itag > bool Constrained_Delaunay_triangulation_2:: is_flipable(Face_handle f, int i) const // determines if edge (f,i) can be flipped { Face_handle ni = f->neighbor(i); if (is_infinite(f) || is_infinite(ni)) return false; if (f->is_constrained(i)) return false; return (side_of_oriented_circle(ni, f->vertex(i)->point()) == ON_POSITIVE_SIDE); } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: flip (Face_handle& f, int i) { Face_handle g = f->neighbor(i); int j = f->mirror_index(i); // save wings neighbors to be able to restore contraint status Face_handle f1 = f->neighbor(cw(i)); int i1 = f->mirror_index(cw(i)); Face_handle f2 = f->neighbor(ccw(i)); int i2 = f->mirror_index(ccw(i)); Face_handle f3 = g->neighbor(cw(j)); int i3 = g->mirror_index(cw(j)); Face_handle f4 = g->neighbor(ccw(j)); int i4 = g->mirror_index(ccw(j)); // The following precondition prevents the test suit // of triangulation to work on constrained Delaunay triangulation //CGAL_triangulation_precondition(is_flipable(f,i)); this->_tds.flip(f, i); // restore constraint status f->set_constraint(f->index(g), false); g->set_constraint(g->index(f), false); f1->neighbor(i1)->set_constraint(f1->mirror_index(i1), f1->is_constrained(i1)); f2->neighbor(i2)->set_constraint(f2->mirror_index(i2), f2->is_constrained(i2)); f3->neighbor(i3)->set_constraint(f3->mirror_index(i3), f3->is_constrained(i3)); f4->neighbor(i4)->set_constraint(f4->mirror_index(i4), f4->is_constrained(i4)); return; } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: flip_around(Vertex_handle va) // makes the triangles incident to vertex va Delaunay using flips { if (dimension() <= 1) return; Face_handle f=va->face(); Face_handle next; Face_handle start(f); int i; do { i = f->index(va); // FRAGILE : DIM 1 next = f->neighbor(ccw(i)); // turns ccw around a propagating_flip(f,i); f=next; } while(next != start); } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: flip_around(List_vertices& new_vertices) { typename List_vertices::iterator itv=new_vertices.begin(); for( ; itv != new_vertices.end(); itv++) { flip_around(*itv); } return; } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: propagating_flip(Face_handle& f,int i) // similar to the corresponding function in Delaunay_triangulation_2.h { if (!is_flipable(f,i)) return; Face_handle ni = f->neighbor(i); flip(f, i); // flip for constrained triangulations propagating_flip(f,i); i = ni->index(f->vertex(i)); propagating_flip(ni,i); } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: propagating_flip(List_edges & edges) { propagating_flip(edges,Emptyset_iterator()); } template < class Gt, class Tds, class Itag > inline bool Constrained_Delaunay_triangulation_2:: test_conflict(const Point& p, Face_handle fh) const // true if point P lies inside the circle circumscribing face fh { // return true if P is inside the circumcircle of fh // if fh is infinite, return true when p is in the positive // halfspace or on the boundary and in the finite edge of fh Oriented_side os = side_of_oriented_circle(fh,p); if (os == ON_POSITIVE_SIDE) return true; if (os == ON_ORIENTED_BOUNDARY && is_infinite(fh)) { int i = fh->index(infinite_vertex()); return collinear_between(fh->vertex(cw(i))->point(), p, fh->vertex(ccw(i))->point() ); } return false; } template < class Gt, class Tds, class Itag > inline bool Constrained_Delaunay_triangulation_2:: test_conflict(Face_handle fh, const Point& p) const // true if point P lies inside the circle circumscribing face fh { return test_conflict(p,fh); } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: find_conflicts(const Point& p, std::list& le, Face_handle hint) const { // sets in le the counterclocwise list of the edges of the boundary of the // union of the faces in conflict with p // an edge is represented by the incident face that is not in conflict with p get_boundary_of_conflicts(p, std::back_inserter(le), hint); } template < class Gt, class Tds, class Itag > inline typename Constrained_Delaunay_triangulation_2::Vertex_handle Constrained_Delaunay_triangulation_2:: virtual_insert(const Point & a, Face_handle start) // virtual version of the insertion { return insert(a,start); } template < class Gt, class Tds, class Itag > inline typename Constrained_Delaunay_triangulation_2::Vertex_handle Constrained_Delaunay_triangulation_2:: virtual_insert(const Point& a, Locate_type lt, Face_handle loc, int li ) // virtual version of insert { return insert(a,lt,loc,li); } template < class Gt, class Tds, class Itag > inline typename Constrained_Delaunay_triangulation_2::Vertex_handle Constrained_Delaunay_triangulation_2:: insert(const Point & a, Face_handle start) // inserts a in the triangulation // constrained edges are updated // Delaunay property is restored { Vertex_handle va= Ctr::insert(a, start); flip_around(va); return va; } template < class Gt, class Tds, class Itag > typename Constrained_Delaunay_triangulation_2::Vertex_handle Constrained_Delaunay_triangulation_2:: insert(const Point& a, Locate_type lt, Face_handle loc, int li) // insert a point p, whose localisation is known (lt, f, i) // constrained edges are updated // Delaunay property is restored { Vertex_handle va= Ctr::insert(a,lt,loc,li); flip_around(va); return va; } template < class Gt, class Tds, class Itag > inline typename Constrained_Delaunay_triangulation_2::Vertex_handle Constrained_Delaunay_triangulation_2:: push_back(const Point &p) { return insert(p); } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: triangulate_hole(List_faces& intersected_faces, List_edges& conflict_boundary_ab, List_edges& conflict_boundary_ba) { List_edges new_edges; Ctr::triangulate_hole(intersected_faces, conflict_boundary_ab, conflict_boundary_ba, new_edges); propagating_flip(new_edges); return; } template < class Gt, class Tds, class Itag > inline void Constrained_Delaunay_triangulation_2:: remove(Vertex_handle v) // remove a vertex and updates the constrained edges of the new faces // precondition : there is no incident constraints { CGAL_triangulation_precondition( v != Vertex_handle() ); CGAL_triangulation_precondition( ! is_infinite(v)); CGAL_triangulation_precondition( ! are_there_incident_constraints(v)); if (dimension() <= 1) Ctr::remove(v); else remove_2D(v); return; } // template < class Gt, class Tds, class Itag > // typename // Constrained_Delaunay_triangulation_2::Vertex_handle // Constrained_Delaunay_triangulation_2:: // special_insert_in_edge(const Point & a, Face_handle f, int i) // // insert point p in edge(f,i) // // bypass the precondition for point a to be in edge(f,i) // // update constrained status // // this member fonction is not robust with exact predicates // // and approximate construction. Should be removed // { // Vertex_handle vh=Ctr::special_insert_in_edge(a,f,i); // flip_around(vh); // return vh; // } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: remove_2D(Vertex_handle v) { if (test_dim_down(v)) { this->_tds.remove_dim_down(v); } else { std::list hole; make_hole(v, hole); std::list shell=hole; //because hole will be emptied by fill_hole fill_hole_delaunay(hole); update_constraints(shell); delete_vertex(v); } return; } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: remove_incident_constraints(Vertex_handle v) { List_edges iconstraints; if (are_there_incident_constraints(v, std::back_inserter(iconstraints))) { Ctr::remove_incident_constraints(v); if (dimension()==2) propagating_flip(iconstraints); } return; } template < class Gt, class Tds, class Itag > void Constrained_Delaunay_triangulation_2:: remove_constrained_edge(Face_handle f, int i) { remove_constrained_edge(f,i,Emptyset_iterator()); return; } template < class Gt, class Tds, class Itag > bool Constrained_Delaunay_triangulation_2:: is_valid(bool verbose, int level) const { bool result = Ctr::is_valid(verbose, level); CGAL_triangulation_assertion( result ); Finite_faces_iterator fit= finite_faces_begin(); for (; fit != finite_faces_end(); fit++) { for(int i=0;i<3;i++) { result = result && !is_flipable(fit,i); CGAL_triangulation_assertion( result ); } } return result; } CGAL_END_NAMESPACE #endif // CGAL_CONSTRAINED_DELAUNAY_TRIANGULATION_2_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_constructions_ftC2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_const0000644000175000017500000001103311344301500031455 0ustar debiandebian// Copyright (c) 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_constructions_ftC2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_FTC2_H #define CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_FTC2_H #include CGAL_BEGIN_NAMESPACE template < class FT > inline void invert_C2(const FT &x, const FT &y, const FT &wt, FT &new_x, FT &new_y, FT &new_wt) { FT p = CGAL::square(x) + CGAL::square(y) - CGAL::square(wt); CGAL_assertion( CGAL::is_positive(p) ); new_x = x / p; new_y = -y / p; new_wt = wt / p; } template < class FT > void w_plane_tangent_line_2(const FT &x1, const FT &y1, const FT &w1, const FT &x2, const FT &y2, const FT &w2, const FT &x3, const FT &y3, const FT &w3, FT & a, FT & b, FT & c) { // we assume that the weight w1 is the smallest among w1, w2, w3. FT u2, v2; FT u3, v3; FT r2, r3; invert_C2(x2-x1, y2-y1, w2-w1, u2, v2, r2); invert_C2(x3-x1, y3-y1, w3-w1, u3, v3, r3); FT Du = u2 - u3; FT Dv = v2 - v3; FT Dr = r2 - r3; FT Duv = det2x2_by_formula(u2, v2, u3, v3); FT Dur = det2x2_by_formula(u2, r2, u3, r3); FT Dvr = det2x2_by_formula(v2, r2, v3, r3); FT D1 = CGAL::square(Du) + CGAL::square(Dv); FT D1inv = FT(1) / D1; FT sqrtD = CGAL::sqrt(D1 - CGAL::square(Dr)); a = (Du * Dr - Dv * sqrtD) * D1inv; b = (Dv * Dr + Du * sqrtD) * D1inv; c = (Du * Dur + Dv * Dvr - Duv * sqrtD) * D1inv; } template < class FT > inline void z_plane_circumcircle_2(const FT &x1, const FT &y1, const FT &w1, const FT &x2, const FT &y2, const FT &w2, const FT &x3, const FT &y3, const FT &w3, FT &cx, FT &cy, FT &cwt) { // we assume that the weight w1 is the smallest among w1, w2, w3. FT a, b, c; w_plane_tangent_line_2(x1, y1, w1, x2, y2, w2, x3, y3, w3, a, b, c); cx = -a / (FT(2) * c) + x1; cy = b / (FT(2) * c) + y1; // this the only part that is computed at vain when only the center // is needed. #if 0 FT cwt2 = (CGAL::square(a) + CGAL::square(b)) / (FT(4) * CGAL::square(c)); #endif // cwt = CGAL::sqrt(cwt2) - FT(w1); cwt = FT(1) / (FT(2) * c) - FT(w1); } template < class FT > inline void ad_circumcenterC2(const FT &x1, const FT &y1, const FT &w1, const FT &x2, const FT &y2, const FT &w2, const FT &x3, const FT &y3, const FT &w3, FT &cx, FT &cy) { FT cwt; ad_circumcircleC2(x1, y1, w1, x2, y2, w2, x3, y3, w3, cx, cy, cwt); } template < class FT > void ad_circumcircleC2(const FT &x1, const FT &y1, const FT &w1, const FT &x2, const FT &y2, const FT &w2, const FT &x3, const FT &y3, const FT &w3, FT &cx, FT &cy, FT &cwt) { if (CGAL::compare(w2, w1) != LARGER && CGAL::compare(w2, w3) != LARGER) { z_plane_circumcircle_2(x2, y2, w2, x3, y3, w3, x1, y1, w1, cx, cy, cwt); return; } else if (CGAL::compare(w3, w1) != LARGER && CGAL::compare(w3, w2) != LARGER) { z_plane_circumcircle_2(x3, y3, w3, x1, y1, w1, x2, y2, w2, cx, cy, cwt); return; } z_plane_circumcircle_2(x1, y1, w1, x2, y2, w2, x3, y3, w3, cx, cy, cwt); } template < class FT > void ad_left_bitangent_lineC2(const FT &x1, const FT &y1, const FT &w1, const FT &x2, const FT &y2, const FT &w2, FT & a, FT & b, FT & c) { FT dx = x1 - x2; FT dy = y1 - y2; FT dw = w1 - w2; FT dxw = det2x2_by_formula(x1, w1, x2, w2); FT dyw = det2x2_by_formula(y1, w1, y2, w2); FT dxy = det2x2_by_formula(x1, y1, x2, y2); FT D1 = CGAL::square(dx) + CGAL::square(dy); FT invD1 = FT(1) / D1; FT D = D1 - CGAL::square(dw); FT sqrtD = CGAL::sqrt(D); a = -(dx * dw - dy * sqrtD) * invD1; b = -(dy * dw + dx * sqrtD) * invD1; c = -(dx * dxw + dy * dyw - dxy * sqrtD) * invD1; } CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_CONSTRUCTIONS_FTC2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_criteria_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_criteria0000644000175000017500000000562111344301500031407 0ustar debiandebian// Copyright (c) 2003-2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Delaunay_mesh_criteria_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Laurent RINEAU #ifndef CGAL_DELAUNAY_MESH_CRITERIA_2_H #define CGAL_DELAUNAY_MESH_CRITERIA_2_H #include namespace CGAL { template class Delaunay_mesh_criteria_2 { double B; public: typedef typename Tr::Face_handle Face_handle; Delaunay_mesh_criteria_2(const double bound = 0.125) : B(bound) {}; typedef double Quality; inline double bound() const { return B; }; inline void set_bound(const double bound) { B = bound; }; class Is_bad { protected: const double B; public: typedef typename Tr::Point Point_2; Is_bad(const double bound) : B(bound) {}; Mesh_2::Face_badness operator()(const Quality q) const { if( q < B ) return Mesh_2::BAD; else return Mesh_2::NOT_BAD; } Mesh_2::Face_badness operator()(const Face_handle& fh, Quality& q) const { typedef typename Tr::Geom_traits Geom_traits; typedef typename Geom_traits::Compute_area_2 Compute_area_2; typedef typename Geom_traits::Compute_squared_distance_2 Compute_squared_distance_2; typedef typename Geom_traits::Construct_triangle_2 Construct_triangle_2; typedef typename Geom_traits::FT FT; Geom_traits traits; Compute_area_2 area_2 = traits.compute_area_2_object(); Compute_squared_distance_2 squared_distance = traits.compute_squared_distance_2_object(); Construct_triangle_2 triangle = traits.construct_triangle_2_object(); const Point_2& pa = fh->vertex(0)->point(); const Point_2& pb = fh->vertex(1)->point(); const Point_2& pc = fh->vertex(2)->point(); double area = 2*CGAL::to_double(area_2(pa, pb, pc)); area=area*area; // area = 4 * area(triangle) double a = CGAL::to_double(squared_distance(pb, pc)); double b = CGAL::to_double(squared_distance(pc, pa)); double c = CGAL::to_double(squared_distance(pa, pb)); if(a #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_KERNEL_WRAPPER_2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_KERNEL_WRAPPER_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template struct SVD_Which_site; // If the ITag is Tag_true we fully support intersections and // therefore we need the full-fletched site. template struct SVD_Which_site { typedef K Kernel; typedef Tag_true Intersections_tag; typedef CGAL::Segment_Voronoi_diagram_site_2 Site_2; typedef Construct_svd_site_2 Construct_site_2; }; // If the ITag is Tag_false we are happy with the simple site. template struct SVD_Which_site { typedef K Kernel; typedef Tag_false Intersections_tag; typedef CGAL::Segment_Voronoi_diagram_simple_site_2 Site_2; typedef Construct_svd_site_2 Construct_site_2; }; } // namespace CGALi template class Segment_Voronoi_diagram_kernel_wrapper_2 : public Kernel_base_2 { public: typedef Kernel_base_2 Kernel_base; typedef ITag Intersections_tag; typedef typename CGALi::SVD_Which_site::Site_2 Site_2; typedef typename CGALi::SVD_Which_site::Construct_site_2 Construct_site_2; }; template class Svd_cartesian_converter : public Converter { private: typedef typename K1::Site_2 K1_Site_2; typedef typename K1::Point_2 K1_Point_2; typedef typename K2::Site_2 K2_Site_2; typedef typename K2::Point_2 K2_Point_2; typedef Converter Base; typedef typename K1::Intersections_tag Intersections_tag; private: static const Intersections_tag& intersections_tag() { static Intersections_tag itag; return itag; } private: // with intersections K2_Site_2 convert_site(const K1_Site_2& t, const Tag_true&) const { if ( t.is_point() ) { if ( t.is_input() ) { return K2_Site_2::construct_site_2( Base::operator()(t.point()) ); } else { return K2_Site_2::construct_site_2 ( Base::operator()(t.source_of_supporting_site(0)), Base::operator()(t.target_of_supporting_site(0)), Base::operator()(t.source_of_supporting_site(1)), Base::operator()(t.target_of_supporting_site(1)) ); } } if ( t.is_input() ) { return K2_Site_2::construct_site_2 ( Base::operator()(t.source_of_supporting_site()), Base::operator()(t.target_of_supporting_site()) ); } else { if ( t.is_input(0) ) { return K2_Site_2::construct_site_2 ( Base::operator()(t.source_of_supporting_site()), Base::operator()(t.target_of_supporting_site()), Base::operator()(t.source_of_crossing_site(1)), Base::operator()(t.target_of_crossing_site(1)), true ); } else if ( t.is_input(1) ) { return K2_Site_2::construct_site_2 ( Base::operator()(t.source_of_supporting_site()), Base::operator()(t.target_of_supporting_site()), Base::operator()(t.source_of_crossing_site(0)), Base::operator()(t.target_of_crossing_site(0)), false ); } else { return K2_Site_2::construct_site_2 ( Base::operator()(t.source_of_supporting_site()), Base::operator()(t.target_of_supporting_site()), Base::operator()(t.source_of_crossing_site(0)), Base::operator()(t.target_of_crossing_site(0)), Base::operator()(t.source_of_crossing_site(1)), Base::operator()(t.target_of_crossing_site(1)) ); } } } // without intersections K2_Site_2 convert_site(const K1_Site_2& t, const Tag_false&) const { if ( t.is_point() ) { return K2_Site_2::construct_site_2( Base::operator()(t.point()) ); } // t is a segment return K2_Site_2::construct_site_2 ( Base::operator()(t.source_of_supporting_site()), Base::operator()(t.target_of_supporting_site()) ); } public: K2_Site_2 operator()(const K1_Site_2& t) const { return convert_site(t, intersections_tag()); } #if defined(CGAL_CFG_USING_BASE_MEMBER_BUG) || defined(_MSC_VER) \ || defined(__sgi) K2_Point_2 operator()(const K1_Point_2& p) const { return Base::operator()(p); } Sign operator()(const Sign& s) const { return s; } #else using Base::operator(); #endif }; CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_KERNEL_WRAPPER_2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Manhattan_distance_iso_box_point.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Manhattan_distance_iso0000644000175000017500000001024011344301500031377 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Manhattan_distance_iso_box_point.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_MANHATTAN_DISTANCE_ISO_BOX_POINT_H #define CGAL_MANHATTAN_DISTANCE_ISO_BOX_POINT_H #include namespace CGAL { template class Manhattan_distance_iso_box_point { public: typedef typename SearchTraits::Point_d Point_d; typedef typename SearchTraits::Iso_box_d Iso_box_d; typedef typename SearchTraits::FT FT; typedef Iso_box_d Query_item; Manhattan_distance_iso_box_point() {} // obsolete as we no longer store dimension Manhattan_distance_iso_box_point(const int d) : the_dimension(d) {} //copy constructor Manhattan_distance_iso_box_point(const Manhattan_distance_iso_box_point& d) {} ~Manhattan_distance_iso_box_point() {} inline FT transformed_distance(const Query_item& q, const Point_d& p) { FT distance = FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Construct_min_vertex_d construct_min_vertex; typename SearchTraits::Construct_max_vertex_d construct_max_vertex; typename SearchTraits::Cartesian_const_iterator_d qmaxit = construct_it(construct_max_vertex(q)), qe = construct_it(construct_max_vertex(q),1), qminit = construct_it(construct_min_vertex(q)), pit = construct_it(p); for (; qmaxit != qe; ++pit,++qmaxit,++qminit) { if ((*pit)>(*qmaxit)) distance += (*pit)-(*qmaxit); else if ((*pit)<(*qminit)) distance += (*qminit)-(*pit); } return distance; } inline FT min_distance_to_rectangle(const Query_item& q, const Kd_tree_rectangle& r) { FT distance = FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Construct_min_vertex_d construct_min_vertex; typename SearchTraits::Construct_max_vertex_d construct_max_vertex; typename SearchTraits::Cartesian_const_iterator_d qmaxit = construct_it(construct_max_vertex(q)), qe = construct_it(construct_max_vertex(q),1), qminit = construct_it(construct_min_vertex(q)); for (unsigned int i = 0; qmaxit != qe; ++ qmaxit, ++qminit, ++i) { if (r.min_coord(i)>(*qmaxit)) distance +=(r.min_coord(i)-(*qmaxit)); if (r.max_coord(i)<(*qminit)) distance += ((*qminit)-r.max_coord(i)); } return distance; } inline FT max_distance_to_rectangle(const Query_item& q, const Kd_tree_rectangle& r) { FT distance=FT(0); typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Construct_min_vertex_d construct_min_vertex; typename SearchTraits::Construct_max_vertex_d construct_max_vertex; typename SearchTraits::Cartesian_const_iterator_d qmaxit = construct_it(construct_max_vertex(q)), qe = construct_it(construct_max_vertex(q),1), qminit = construct_it(construct_min_vertex(q)); for (unsigned int i = 0; qmaxit != qe; ++ qmaxit, ++qminit, ++i) { if ( r.max_coord(i)-(*qminit) >(*qmaxit)-r.min_coord(i) ) distance += (r.max_coord(i)-(*qminit)); else distance += ((*qmaxit)-r.min_coord(i)); } return distance; } inline FT transformed_distance(FT d) { return d; } inline FT inverse_of_transformed_distance(FT d) { return d; } }; // class Manhattan_distance_iso_box_point } // namespace CGAL #endif // MANHATTAN_DISTANCE_ISO_BOX_POINT_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Counting_iterator.h0000644000175000017500000000250011344301500030665 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Counting_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion // This file is obsolete; use instead. #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/0000755000175000017500000000000012146213711026247 5ustar debiandebian././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_internal_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_function0000644000175000017500000004475211344301501031345 0ustar debiandebian// Copyright (c) 2003-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_internal_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_GLOBAL_FUNCTIONS_INTERNAL_3_H #define CGAL_KERNEL_GLOBAL_FUNCTIONS_INTERNAL_3_H // Generic functions calling the kernel functor. // See comments in CGAL/Kernel/global_functions_internal_3.h. CGAL_BEGIN_NAMESPACE namespace CGALi { template inline Angle angle(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.angle_3_object()(p, q, r); } template < class K > inline bool are_ordered_along_line(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.are_ordered_along_line_3_object()(p, q, r); } template < class K > inline bool are_strictly_ordered_along_line(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.are_strictly_ordered_along_line_3_object()(p, q, r); } template inline typename K::Plane_3 bisector(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.construct_bisector_3_object()(p, q); } template inline typename K::Plane_3 bisector(const typename CGAL_WRAP(K)::Plane_3 &h1, const typename CGAL_WRAP(K)::Plane_3 &h2, const K &k) { return k.construct_bisector_3_object()(h1, h2); } template < class K > inline typename K::Point_3 centroid(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return k.construct_centroid_3_object()(p, q, r, s); } template < class K > inline typename K::Point_3 centroid(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.construct_centroid_3_object()(p, q, r); } template < class K > inline typename K::Point_3 circumcenter(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return k.construct_circumcenter_3_object()(p, q, r, s); } template < class K > inline typename K::Point_3 circumcenter(const typename CGAL_WRAP(K)::Tetrahedron_3 &t, const K& k) { return k.construct_circumcenter_3_object()(t); } template < class K > inline typename K::Point_3 circumcenter(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.construct_circumcenter_3_object()(p, q, r); } template < class K > inline typename K::Point_3 circumcenter(const typename CGAL_WRAP(K)::Triangle_3 &t, const K& k) { return k.construct_circumcenter_3_object()(t); } template < class K > inline bool collinear(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.collinear_3_object()(p, q, r); } template < class K > inline bool collinear_are_ordered_along_line( const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.collinear_are_ordered_along_line_3_object()(p, q, r); } template < class K > inline bool collinear_are_strictly_ordered_along_line( const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.collinear_are_strictly_ordered_along_line_3_object()(p, q, r); } template < class K > inline Comparison_result compare_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.compare_distance_3_object()(p, q, r); } template < class K > inline Comparison_result compare_lexicographically_xyz(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K& k) { return k.compare_xyz_3_object()(p, q); } template < class K > inline Comparison_result compare_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h, const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { if (k.less_signed_distance_to_plane_3_object()(h, p, q)) return SMALLER; if (k.less_signed_distance_to_plane_3_object()(h, q, p)) return LARGER; return EQUAL; } template < class K > inline Comparison_result compare_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp, const typename CGAL_WRAP(K)::Point_3 &hq, const typename CGAL_WRAP(K)::Point_3 &hr, const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { if (k.less_signed_distance_to_plane_3_object()(hp, hq, hr, p, q)) return SMALLER; if (k.less_signed_distance_to_plane_3_object()(hp, hq, hr, q, p)) return LARGER; return EQUAL; } template < class K > inline Comparison_result compare_x(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.compare_x_3_object()(p, q); } template < class K > inline Comparison_result compare_y(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.compare_y_3_object()(p, q); } template < class K > inline Comparison_result compare_z(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.compare_z_3_object()(p, q); } template < class K > inline Comparison_result compare_xyz(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.compare_xyz_3_object()(p, q); } template < class K > inline bool coplanar(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K& k) { return k.coplanar_3_object()(p, q, r, s); } template < class K > inline Orientation coplanar_orientation(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K& k) { return k.coplanar_orientation_3_object()(p, q, r, s); } template < class K > inline Orientation coplanar_orientation(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { return k.coplanar_orientation_3_object()(p, q, r); } template < class K > inline Bounded_side coplanar_side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &t, const K& k) { return k.coplanar_side_of_bounded_circle_3_object()(p, q, r, t); } template < class K > inline typename K::Vector_3 cross_product(const typename CGAL_WRAP(K)::Vector_3 &v, const typename CGAL_WRAP(K)::Vector_3 &w, const K& k) { return k.construct_cross_product_vector_3_object()(v, w); } template < class K > inline bool has_smaller_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.less_distance_to_point_3_object()(p, q, r); } template < class K > inline bool has_larger_distance_to_point(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.compare_distance_3_object()(p, q, r) == LARGER; } template < class K > inline bool has_larger_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h, const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_signed_distance_to_plane_3_object()(h, q, p); } template < class K > inline bool has_larger_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp, const typename CGAL_WRAP(K)::Point_3 &hq, const typename CGAL_WRAP(K)::Point_3 &hr, const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_signed_distance_to_plane_3_object()(hp, hq, hr, q, p); } template < class K > inline bool has_smaller_signed_distance_to_plane(const typename CGAL_WRAP(K)::Plane_3 &h, const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_signed_distance_to_plane_3_object()(h, p, q); } template < class K > inline bool has_smaller_signed_distance_to_plane(const typename CGAL_WRAP(K)::Point_3 &hp, const typename CGAL_WRAP(K)::Point_3 &hq, const typename CGAL_WRAP(K)::Point_3 &hr, const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_signed_distance_to_plane_3_object()(hp, hq, hr, p, q); } template < class K > inline bool less_x(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_x_3_object()(p, q); } template < class K > inline bool less_y(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_y_3_object()(p, q); } template < class K > inline bool less_z(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_z_3_object()(p, q); } template < class K > inline bool lexicographically_xyz_smaller(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.less_xyz_3_object()(p, q); } template < class K > inline typename K::Point_3 midpoint(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.construct_midpoint_3_object()(p, q); } template < class K > inline typename K::Point_3 max_vertex(const typename CGAL_WRAP(K)::Iso_cuboid_3 &ic, const K &k) { return k.construct_max_vertex_3_object()(ic); } template < class K > inline typename K::Point_3 min_vertex(const typename CGAL_WRAP(K)::Iso_cuboid_3 &ic, const K &k) { return k.construct_min_vertex_3_object()(ic); } template inline Orientation orientation(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return k.orientation_3_object()(p, q, r, s); } template < class K > inline typename K::Vector_3 orthogonal_vector(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.construct_orthogonal_vector_3_object()(p, q, r); } template < class K > inline typename K::Vector_3 orthogonal_vector(const typename CGAL_WRAP(K)::Plane_3 &p, const K &k) { return k.construct_orthogonal_vector_3_object()(p); } template inline bool parallel(const typename CGAL_WRAP(K)::Line_3 &l1, const typename CGAL_WRAP(K)::Line_3 &l2, const K &k) { return k.are_parallel_3_object()(l1, l2); } template inline bool parallel(const typename CGAL_WRAP(K)::Plane_3 &h1, const typename CGAL_WRAP(K)::Plane_3 &h2, const K &k) { return k.are_parallel_3_object()(h1, h2); } template inline bool parallel(const typename CGAL_WRAP(K)::Ray_3 &r1, const typename CGAL_WRAP(K)::Ray_3 &r2, const K &k) { return k.are_parallel_3_object()(r1, r2); } template inline bool parallel(const typename CGAL_WRAP(K)::Segment_3 &s1, const typename CGAL_WRAP(K)::Segment_3 &s2, const K &k) { return k.are_parallel_3_object()(s1, s2); } template inline Bounded_side side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &test, const K &k) { return k.side_of_bounded_sphere_3_object()(p, q, test); } template inline Bounded_side side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &test, const K &k) { return k.side_of_bounded_sphere_3_object()(p, q, r, test); } template inline Bounded_side side_of_bounded_sphere(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const typename CGAL_WRAP(K)::Point_3 &test, const K &k) { return k.side_of_bounded_sphere_3_object()(p, q, r, s, test); } template inline Oriented_side side_of_oriented_sphere(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const typename CGAL_WRAP(K)::Point_3 &test, const K &k) { return k.side_of_oriented_sphere_3_object()(p, q, r, s, test); } template inline typename K::FT squared_area(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.compute_squared_area_3_object()(p, q, r); } template < class K > inline typename K::FT squared_radius(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return k.compute_squared_radius_3_object()(p, q, r, s); } template < class K > inline typename K::FT squared_radius(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K &k) { return k.compute_squared_radius_3_object()(p, q, r); } template < class K > inline typename K::FT squared_radius(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.compute_squared_radius_3_object()(p, q); } template < class K > inline typename K::FT volume(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return k.compute_volume_3_object()(p, q, r, s); } template < class K > inline bool x_equal(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.equal_x_3_object()(p, q); } template < class K > inline bool y_equal(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.equal_y_3_object()(p, q); } template < class K > inline bool z_equal(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K &k) { return k.equal_z_3_object()(p, q); } // The following functions only call some of the previous ones. template inline bool are_negative_oriented(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return CGALi::orientation(p, q, r, s, k) == NEGATIVE; } template inline bool are_positive_oriented(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const typename CGAL_WRAP(K)::Point_3 &s, const K &k) { return CGALi::orientation(p, q, r, s, k) == POSITIVE; } template < class K > inline bool lexicographically_xyz_smaller_or_equal(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const K&k) { return CGALi::compare_lexicographically_xyz(p, q, k) != LARGER; } } // namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_KERNEL_GLOBAL_FUNCTIONS_INTERNAL_3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_function0000644000175000017500000000312011344301501031325 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_GLOBAL_FUNCTIONS_H #define CGAL_KERNEL_GLOBAL_FUNCTIONS_H // Generic functions calling the kernel functor. // Independent of the dimension. #include #include CGAL_BEGIN_NAMESPACE template inline bool parallel(const O &o1, const O &o2) { typedef typename Kernel_traits::Kernel K; return CGALi::parallel(o1, o2, K()); } CGAL_END_NAMESPACE #endif // CGAL_KERNEL_GLOBAL_FUNCTIONS_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/concept_archetype_functors.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/concept_archety0000644000175000017500000023611711344301501031350 0ustar debiandebian// Copyright (c) 1999,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/concept_archetype_functors.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_CONCEPT_ARCHETYPE_FUNCTION_OBJECTS_H #define CGAL_CONCEPT_ARCHETYPE_FUNCTION_OBJECTS_H #include #include #include #include #include #include // see kernel functors for original version // all deprecated stuff was removed ... // all functors were put into namespace CGALca // (to avoid ambiguities with the original functors) CGAL_BEGIN_NAMESPACE namespace CGALca { template class Angle_2 { typedef typename K::Point_2 Point_2; public: typedef Angle result_type; typedef Arity_tag< 3 > Arity; Angle operator()(const Point_2&, const Point_2&, const Point_2&) const { CGAL::Angle a = CGAL::RIGHT; return a; } }; template class Angle_3 { typedef typename K::Point_3 Point_3; public: typedef Angle result_type; typedef Arity_tag< 3 > Arity; Angle operator()(const Point_3&, const Point_3&, const Point_3&) const { CGAL::Angle a = CGAL::RIGHT; return a; } }; template class Are_ordered_along_line_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Are_ordered_along_line_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Are_parallel_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()(const Line_2&, const Line_2&) const { return true; } bool operator()(const Segment_2&, const Segment_2&) const { return true; } bool operator()(const Ray_2&, const Ray_2&) const { return true; } }; template class Are_parallel_3 { typedef typename K::Line_3 Line_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Plane_3 Plane_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()(const Line_3&, const Line_3&) const { return true; } bool operator()(const Plane_3&, const Plane_3&) const { return true; } bool operator()(const Segment_3&, const Segment_3&) const { return true; } bool operator()(const Ray_3&, const Ray_3&) const { return true; } }; template class Are_strictly_ordered_along_line_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Are_strictly_ordered_along_line_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Assign_2 { typedef typename K::Object_2 Object_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; template bool operator()(T&, const Object_2&) const { return true; } }; template class Assign_3 { typedef typename K::Object_3 Object_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; template bool operator()(T&, const Object_3&) const { return true; } }; template class Bounded_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Bounded_side result_type; typedef Arity_tag< 2 > Arity; Bounded_side operator()( const Circle_2&, const Point_2&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Triangle_2&, const Point_2&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Iso_rectangle_2&, const Point_2&) const { return CGAL::ON_BOUNDARY; } }; template class Bounded_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Bounded_side result_type; typedef Arity_tag< 2 > Arity; Bounded_side operator()( const Sphere_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Tetrahedron_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Iso_cuboid_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } }; template class Collinear_are_ordered_along_line_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Collinear_are_ordered_along_line_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Collinear_are_strictly_ordered_along_line_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Collinear_are_strictly_ordered_along_line_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Collinear_has_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Ray_2&, const Point_2&) const { return true; } bool operator()( const Segment_2&, const Point_2&) const { return true; } }; template class Collinear_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Collinear_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Compare_angle_with_x_axis_2 { typedef typename K::Direction_2 Direction_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()(const Direction_2&, const Direction_2&) const { return CGAL::LARGER; } }; template class Compare_distance_2 { typedef typename K::Point_2 Point_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()(const Point_2&, const Point_2&, const Point_2&) const { return CGAL::LARGER; } }; template class Compare_distance_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()(const Point_3&, const Point_3&, const Point_3&) const { return CGAL::LARGER; } }; template class Compare_slope_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()(const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()(const Segment_2&, const Segment_2&) const { return CGAL::LARGER; } }; template class Compare_x_at_y_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()( const Point_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Point_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } }; template class Compare_xyz_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3&, const Point_3&) const { return CGAL::LARGER; } }; template class Compare_xy_2 { typedef typename K::Point_2 Point_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2&, const Point_2&) const { return CGAL::LARGER; } }; template class Compare_xy_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3&, const Point_3&) const { return CGAL::LARGER; } }; template class Compare_x_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2&, const Point_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Point_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } }; template class Compare_x_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3&, const Point_3&) const { return CGAL::LARGER; } }; template class Compare_y_at_x_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()( const Point_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Point_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Point_2&, const Segment_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Point_2&, const Segment_2&, const Segment_2&) const { return CGAL::LARGER; } }; template class Compare_y_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2&, const Point_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Point_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } Comparison_result operator()( const Line_2&, const Line_2&, const Line_2&, const Line_2&) const { return CGAL::LARGER; } }; template class Compare_y_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3&, const Point_3&) const { return CGAL::LARGER; } }; template class Compare_z_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3&, const Point_3&) const { return CGAL::LARGER; } }; template class Compute_area_2 { typedef typename K::FT FT; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Point_2 Point_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Point_2&, const Point_2&, const Point_2&) const { FT val = 0; return val; } FT operator()( const Iso_rectangle_2&) const { FT val = 0; return val; } FT operator()( const Triangle_2&) const { FT val = 0; return val; } }; template class Compute_area_3 { typedef typename K::FT FT; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Point_3 Point_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Triangle_3&) const { FT val = 0; return val; } FT operator()( const Point_3&, const Point_3&, const Point_3&) const { FT val = 0; return val; } }; template class Compute_scalar_product_2 { typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()(const Vector_2& v, const Vector_2& w) const { FT val = 0; return val; } }; template class Compute_scalar_product_3 { typedef typename K::FT FT; typedef typename K::Vector_3 Vector_3; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()(const Vector_3& v, const Vector_3& w) const { FT val = 0; return val; } }; template class Compute_squared_area_3 { typedef typename K::FT FT; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Point_3 Point_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Triangle_3&) const { FT val = 0; return val; } FT operator()( const Point_3&, const Point_3&, const Point_3&) const { FT val = 0; return val; } }; template class Compute_squared_distance_2 { typedef typename K::FT FT; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; // There are 25 combinaisons, we use a template. template FT operator()( const T1&, const T2&) const { FT val = 0; return val; } }; template class Compute_squared_distance_3 { typedef typename K::FT FT; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; // There are 25 combinaisons, we use a template. template FT operator()( const T1&, const T2&) const { FT val = 0; return val; } }; template class Compute_squared_length_2 { typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; typedef typename K::Segment_2 Segment_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Vector_2&) const { FT val = 0; return val; } FT operator()( const Segment_2&) const { FT val = 0; return val; } }; template class Compute_squared_length_3 { typedef typename K::FT FT; typedef typename K::Vector_3 Vector_3; typedef typename K::Segment_3 Segment_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Vector_3&) const { FT val = 0; return val; } FT operator()( const Segment_3&) const { FT val = 0; return val; } }; template class Compute_squared_radius_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Circle_2&) const { FT val = 0; return val; } FT operator()( const Point_2&, const Point_2&, const Point_2&) const { FT val = 0; return val; } FT operator()( const Point_2&, const Point_2&) const { FT val = 0; return val; } }; template class Compute_squared_radius_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Sphere_3&) const { FT val = 0; return val; } FT operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { FT val = 0; return val; } FT operator()( const Point_3&, const Point_3&, const Point_3&) const { FT val = 0; return val; } FT operator()( const Point_3&, const Point_3&) const { FT val = 0; return val; } }; template class Compute_volume_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Tetrahedron_3&) const { FT val = 0; return val; } FT operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { FT val = 0; return val; } FT operator()( const Iso_cuboid_3&) const { FT val = 0; return val; } }; template class Construct_base_vector_3 { typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()( const Plane_3&, int) const { Vector_3 v; return v; } }; template class Construct_bisector_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Line_2 operator()(const Point_2&, const Point_2&) const { Line_2 obj; return obj; } }; template class Construct_bisector_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()(const Point_3&, const Point_3&) const { Plane_3 obj; return obj; } }; template class Construct_center_2 { typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()(const Circle_2&) const { Point_2 obj; return obj; } }; template class Construct_center_3 { typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()(const Sphere_3&) const { Point_3 obj; return obj; } }; template class Construct_centroid_2 { typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 3 > Arity; Point_2 operator()(const Point_2&, const Point_2&, const Point_2&) const { Point_2 obj; return obj; } Point_2 operator()(const Point_2&, const Point_2&, const Point_2&, const Point_2&) const { Point_2 obj; return obj; } }; template class Construct_centroid_3 { typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 3 > Arity; Point_3 operator()(const Point_3&, const Point_3&, const Point_3&) const { Point_3 obj; return obj; } Point_3 operator()(const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { Point_3 obj; return obj; } }; template class Construct_circle_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef Circle_2 result_type; typedef Arity_tag< 3 > Arity; Circle_2 operator()() const { return Circle_2(); } Circle_2 operator()( const Point_2&, const FT&, Orientation = COUNTERCLOCKWISE) const { return Circle_2(); } Circle_2 operator()( const Point_2&, const Point_2&, const Point_2&) const { return Circle_2(); } Circle_2 operator()( const Point_2&, const Point_2&, Orientation = COUNTERCLOCKWISE) const { return Circle_2(); } Circle_2 operator()( const Point_2&, Orientation = COUNTERCLOCKWISE) const { return Circle_2(); } }; template class Construct_circumcenter_2 { typedef typename K::Point_2 Point_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 3 > Arity; Point_2 operator()(const Point_2&, const Point_2&, const Point_2&) const { return Point_2(); } Point_2 operator()(const Triangle_2&) const { return Point_2(); } }; template class Construct_circumcenter_3 { typedef typename K::Point_3 Point_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef Point_3 result_type; typedef Arity_tag< 4 > Arity; Point_3 operator()(const Point_3&, const Point_3&, const Point_3&) const { return Point_3(); } Point_3 operator()(const Triangle_3&) const { return Point_3(); } Point_3 operator()(const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return Point_3(); } Point_3 operator()(const Tetrahedron_3&) const { return Point_3(); } }; template class Construct_cross_product_vector_3 { typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()(const Vector_3&, const Vector_3&) const { return Vector_3(); } }; template class Construct_direction_2 { typedef typename K::Direction_2 Direction_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; typedef typename K::RT RT; public: typedef Direction_2 result_type; typedef Arity_tag< 1 > Arity; Direction_2 operator()() const { return Direction_2(); } Direction_2 operator()(const Vector_2&) const { return Direction_2(); } Direction_2 operator()(const Line_2&) const { return Direction_2(); } Direction_2 operator()(const Ray_2&) const { return Direction_2(); } Direction_2 operator()(const Segment_2&) const { return Direction_2(); } }; template class Construct_direction_3 { typedef typename K::Direction_3 Direction_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::RT RT; public: typedef Direction_3 result_type; typedef Arity_tag< 1 > Arity; Direction_3 operator()() const { return Direction_3(); } Direction_3 operator()(const Vector_3&) const { return Direction_3(); } Direction_3 operator()(const Line_3&) const { return Direction_3(); } Direction_3 operator()(const Ray_3&) const { return Direction_3(); } Direction_3 operator()(const Segment_3&) const { return Direction_3(); } }; template class Construct_iso_cuboid_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Iso_cuboid_3 result_type; typedef Arity_tag< 2 > Arity; Iso_cuboid_3 operator()() const { return Iso_cuboid_3(); } Iso_cuboid_3 operator()(const Point_3&, const Point_3&) const { return Iso_cuboid_3(); } Iso_cuboid_3 operator()(const Point_3 &, const Point_3 &, const Point_3 &, const Point_3 &, const Point_3 &, const Point_3 &) const { return Iso_cuboid_3(); } }; template class Construct_iso_rectangle_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Iso_rectangle_2 result_type; typedef Arity_tag< 2 > Arity; Iso_rectangle_2 operator()() const { return Iso_rectangle_2(); } Iso_rectangle_2 operator()(const Point_2&, const Point_2&) const { return Iso_rectangle_2(); } Iso_rectangle_2 operator()(const Point_2 &, const Point_2 &, const Point_2 &, const Point_2 &) const { return Iso_rectangle_2(); } }; template class Construct_lifted_point_3 { typedef typename K::Point_2 Point_2; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()(const Plane_3&, const Point_2&) const { return Point_3(); } }; template class Construct_line_2 { typedef typename K::RT RT; typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Direction_2 Direction_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Line_2 Line_2; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Line_2 operator()() const { return Line_2(); } Line_2 operator()(const Point_2&, const Point_2&) const { return Line_2(); } Line_2 operator()(const Point_2&, const Direction_2&) const { return Line_2(); } Line_2 operator()(const Point_2&, const Vector_2&) const { return Line_2(); } Line_2 operator()(const Segment_2&) const { return Line_2(); } Line_2 operator()(const Ray_2&) const { return Line_2(); } }; template class Construct_line_3 { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Line_3 Line_3; public: typedef Line_3 result_type; typedef Arity_tag< 2 > Arity; Line_3 operator()() const { return Line_3(); } Line_3 operator()(const Point_3&, const Point_3&) const { return Line_3(); } Line_3 operator()(const Point_3&, const Direction_3&) const { return Line_3(); } Line_3 operator()(const Point_3&, const Vector_3&) const { return Line_3(); } Line_3 operator()(const Segment_3&) const { return Line_3(); } Line_3 operator()(const Ray_3&) const { return Line_3(); } }; template class Construct_max_vertex_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()(const Iso_rectangle_2& r) const { return Point_2(); } }; template class Construct_min_vertex_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()(const Iso_rectangle_2& r) const { return Point_2(); } }; template class Construct_max_vertex_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()(const Iso_cuboid_3& r) const { return Point_3(); } }; template class Construct_min_vertex_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()(const Iso_cuboid_3& r) const { return Point_3(); } }; template class Construct_midpoint_2 { typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()(const Point_2&, const Point_2&) const { return Point_2(); } }; template class Construct_midpoint_3 { typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()(const Point_3&, const Point_3&) const { return Point_3(); } }; template class Construct_object_2 { typedef typename K::Object_2 Object_2; public: typedef Object_2 result_type; typedef Arity_tag< 1 > Arity; template Object_2 operator()( const Cls&) const { Object_2 obj; return obj; } }; template class Construct_object_3 { typedef typename K::Object_3 Object_3; public: typedef Object_3 result_type; typedef Arity_tag< 1 > Arity; template Object_3 operator()( const Cls&) const { Object_3 obj; return obj; } }; template class Construct_opposite_circle_2 { typedef typename K::Circle_2 Circle_2; public: typedef Circle_2 result_type; typedef Arity_tag< 1 > Arity; Circle_2 operator()( const Circle_2&) const { return Circle_2(); } }; template class Construct_opposite_direction_2 { typedef typename K::Direction_2 Direction_2; public: typedef Direction_2 result_type; typedef Arity_tag< 1 > Arity; Direction_2 operator()( const Direction_2&) const { return Direction_2(); } }; template class Construct_opposite_direction_3 { typedef typename K::Direction_3 Direction_3; public: typedef Direction_3 result_type; typedef Arity_tag< 1 > Arity; Direction_3 operator()( const Direction_3&) const { return Direction_3(); } }; template class Construct_opposite_line_2 { typedef typename K::Line_2 Line_2; public: typedef Line_2 result_type; typedef Arity_tag< 1 > Arity; Line_2 operator()( const Line_2&) const { return Line_2(); } }; template class Construct_opposite_line_3 { typedef typename K::Line_3 Line_3; public: typedef Line_3 result_type; typedef Arity_tag< 1 > Arity; Line_3 operator()( const Line_3&) const { return Line_3(); } }; template class Construct_opposite_plane_3 { typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 1 > Arity; Plane_3 operator()( const Plane_3&) const { return Plane_3(); } }; template class Construct_opposite_ray_2 { typedef typename K::Ray_2 Ray_2; public: typedef Ray_2 result_type; typedef Arity_tag< 1 > Arity; Ray_2 operator()( const Ray_2&) const { return Ray_2(); } }; template class Construct_opposite_ray_3 { typedef typename K::Ray_3 Ray_3; public: typedef Ray_3 result_type; typedef Arity_tag< 1 > Arity; Ray_3 operator()( const Ray_3&) const { return Ray_3(); } }; template class Construct_opposite_segment_2 { typedef typename K::Segment_2 Segment_2; public: typedef Segment_2 result_type; typedef Arity_tag< 1 > Arity; Segment_2 operator()( const Segment_2&) const { return Segment_2(); } }; template class Construct_opposite_segment_3 { typedef typename K::Segment_3 Segment_3; public: typedef Segment_3 result_type; typedef Arity_tag< 1 > Arity; Segment_3 operator()( const Segment_3&) const { return Segment_3(); } }; template class Construct_opposite_sphere_3 { typedef typename K::Sphere_3 Sphere_3; public: typedef Sphere_3 result_type; typedef Arity_tag< 1 > Arity; Sphere_3 operator()( const Sphere_3&) const { return Sphere_3(); } }; template class Construct_opposite_triangle_2 { typedef typename K::Triangle_2 Triangle_2; public: typedef Triangle_2 result_type; typedef Arity_tag< 1 > Arity; Triangle_2 operator()( const Triangle_2&) const { return Triangle_2(); } }; template class Construct_opposite_vector_2 { typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 1 > Arity; Vector_2 operator()( const Vector_2&) const { return Vector_2(); } }; template class Construct_opposite_vector_3 { typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 1 > Arity; Vector_3 operator()( const Vector_3&) const { return Vector_3(); } }; template class Construct_orthogonal_vector_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; public: typedef Vector_3 result_type; typedef Arity_tag< 1 > Arity; Vector_3 operator()( const Plane_3&) const { return Vector_3(); } Vector_3 operator()( const Point_3&, const Point_3&, const Point_3&) const { return Vector_3(); } }; template class Construct_perpendicular_direction_2 { typedef typename K::Direction_2 Direction_2; public: typedef Direction_2 result_type; typedef Arity_tag< 2 > Arity; Direction_2 operator()( const Direction_2&, Orientation) const { return Direction_2(); } }; template class Construct_perpendicular_line_2 { typedef typename K::Line_2 Line_2; typedef typename K::Point_2 Point_2; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Line_2 operator()( const Line_2&, const Point_2&) const { return Line_2(); } }; template class Construct_perpendicular_line_3 { typedef typename K::Line_3 Line_3; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Line_3 result_type; typedef Arity_tag< 2 > Arity; Line_3 operator()( const Plane_3&, const Point_3&) const { return Line_3(); } }; template class Construct_perpendicular_plane_3 { typedef typename K::Line_3 Line_3; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()( const Line_3&, const Point_3&) const { return Plane_3(); } }; template class Construct_perpendicular_vector_2 { typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()( const Vector_2&, Orientation) const { return Vector_2(); } }; template class Construct_plane_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()() const { return Plane_3(); } Plane_3 operator()(const RT&, const RT&, const RT&, const RT&) const { return Plane_3(); } Plane_3 operator()(const Point_3&, const Point_3&, const Point_3&) const { return Plane_3(); } Plane_3 operator()(const Point_3&, const Direction_3&) const { return Plane_3(); } Plane_3 operator()(const Line_3&, const Point_3&) const { return Plane_3(); } Plane_3 operator()(const Ray_3&, const Point_3&) const { return Plane_3(); } Plane_3 operator()(const Segment_3&, const Point_3&) const { return Plane_3(); } }; template class Construct_point_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Line_2&, int) const { return Point_2(); } Point_2 operator()( const Segment_2&, int) const { return Point_2(); } Point_2 operator()( const Ray_2&, int) const { return Point_2(); } }; template class Construct_point_on_3 { typedef typename K::Point_3 Point_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Line_3&, int) const { return Point_3(); } Point_3 operator()( const Segment_3&, int) const { return Point_3(); } Point_3 operator()( const Ray_3&, int) const { return Point_3(); } Point_3 operator()( const Plane_3&) const { return Point_3(); } }; template class Construct_point_2 { typedef typename K::RT RT; typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()() const { return Point_2(); } Point_2 operator()(Origin) const { return Point_2(); } }; template class Construct_point_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()() const { return Point_3(); } Point_3 operator()(Origin) const { return Point_3(); } }; template class Construct_projected_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Line_2&, const Point_2&) const { return Point_2(); } }; template class Construct_projected_point_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Line_3 Line_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Line_3&, const Point_3&) const { return Point_3(); } Point_3 operator()( const Plane_3&, const Point_3&) const { return Point_3(); } }; template class Construct_projected_xy_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Plane_3&, const Point_3&) const { return Point_2(); } }; template class Construct_ray_2 { typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Direction_2 Direction_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; public: typedef Ray_2 result_type; typedef Arity_tag< 2 > Arity; Ray_2 operator()() const { return Ray_2(); } Ray_2 operator()(const Point_2&, const Point_2&) const { return Ray_2(); } Ray_2 operator()(const Point_2&, const Vector_2&) const { return Ray_2(); } Ray_2 operator()(const Point_2&, const Direction_2&) const { return Ray_2(); } Ray_2 operator()(const Point_2&, const Line_2&) const { return Ray_2(); } }; template class Construct_ray_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; public: typedef Ray_3 result_type; typedef Arity_tag< 2 > Arity; Ray_3 operator()() const { return Ray_3(); } Ray_3 operator()(const Point_3&, const Point_3&) const { return Ray_3(); } Ray_3 operator()(const Point_3&, const Vector_3&) const { return Ray_3(); } Ray_3 operator()(const Point_3&, const Direction_3&) const { return Ray_3(); } Ray_3 operator()(const Point_3&, const Line_3&) const { return Ray_3(); } }; template class Construct_scaled_vector_2 { typedef typename K::RT RT; typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()( const Vector_2&, const RT&) const { return Vector_2(); } Vector_2 operator()( const Vector_2&, const Quotient&) const { return Vector_2(); } }; template class Construct_scaled_vector_3 { typedef typename K::RT RT; typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()( const Vector_3&, const RT&) const { return Vector_3(); } Vector_3 operator()( const Vector_3&, const Quotient&) const { return Vector_3(); } }; template class Construct_segment_2 { typedef typename K::Segment_2 Segment_2; typedef typename K::Point_2 Point_2; public: typedef Segment_2 result_type; typedef Arity_tag< 2 > Arity; Segment_2 operator()() const { return Segment_2(); } Segment_2 operator()( const Point_2&, const Point_2&) const { return Segment_2(); } }; template class Construct_segment_3 { typedef typename K::Segment_3 Segment_3; typedef typename K::Point_3 Point_3; public: typedef Segment_3 result_type; typedef Arity_tag< 2 > Arity; Segment_3 operator()() const { return Segment_3(); } Segment_3 operator()( const Point_3&, const Point_3&) const { return Segment_3(); } }; template class Construct_sphere_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Sphere_3 result_type; typedef Arity_tag< 4 > Arity; Sphere_3 operator()() const { return Sphere_3(); } Sphere_3 operator()( const Point_3&, const FT&, Orientation = COUNTERCLOCKWISE) const { return Sphere_3(); } Sphere_3 operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return Sphere_3(); } Sphere_3 operator()( const Point_3&, const Point_3&, const Point_3&, Orientation = COUNTERCLOCKWISE) const { return Sphere_3(); } Sphere_3 operator()( const Point_3&, const Point_3&, Orientation = COUNTERCLOCKWISE) const { return Sphere_3(); } Sphere_3 operator()( const Point_3&, Orientation = COUNTERCLOCKWISE) const { return Sphere_3(); } }; #ifndef CGAL_NO_DEPRECATED_CODE template class Construct_supporting_line_2 { typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; public: typedef Line_2 result_type; typedef Arity_tag< 1 > Arity; Line_2 operator()( const Ray_2&) const { return Line_2(); } Line_2 operator()( const Segment_2&) const { return Line_2(); } }; template class Construct_supporting_line_3 { typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; public: typedef Line_3 result_type; typedef Arity_tag< 1 > Arity; Line_3 operator()( const Ray_3&) const { return Line_3(); } Line_3 operator()( const Segment_3&) const { return Line_3(); } }; #endif // CGAL_NO_DEPRECATED_CODE template class Construct_supporting_plane_3 { typedef typename K::Triangle_3 Triangle_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 1 > Arity; Plane_3 operator()( const Triangle_3&) const { return Plane_3(); } }; template class Construct_tetrahedron_3 { typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Point_3 Point_3; public: typedef Tetrahedron_3 result_type; typedef Arity_tag< 4 > Arity; Tetrahedron_3 operator()() const { return Tetrahedron_3(); } Tetrahedron_3 operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return Tetrahedron_3(); } }; template class Construct_translated_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Point_2&, const Vector_2&) const { return Point_2(); } Point_2 operator()( const Origin&, const Vector_2&) const { return Point_2(); } }; template class Construct_translated_point_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Point_3&, const Vector_3&) const { return Point_3(); } Point_3 operator()( const Origin&, const Vector_3&) const { return Point_3(); } }; template class Construct_triangle_2 { typedef typename K::Triangle_2 Triangle_2; typedef typename K::Point_2 Point_2; public: typedef Triangle_2 result_type; typedef Arity_tag< 3 > Arity; Triangle_2 operator()() const { return Triangle_2(); } Triangle_2 operator()( const Point_2&, const Point_2&, const Point_2&) const { return Triangle_2(); } }; template class Construct_triangle_3 { typedef typename K::Triangle_3 Triangle_3; typedef typename K::Point_3 Point_3; public: typedef Triangle_3 result_type; typedef Arity_tag< 3 > Arity; Triangle_3 operator()() const { return Triangle_3(); } Triangle_3 operator()( const Point_3&, const Point_3&, const Point_3&) const { return Triangle_3(); } }; template class Construct_vector_2 { typedef typename K::RT RT; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Line_2 Line_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Point_2 Point_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()() const { return Vector_2(); } Vector_2 operator()( const Point_2&, const Point_2&) const { return Vector_2(); } Vector_2 operator()( const Origin&, const Point_2&) const { return Vector_2(); } Vector_2 operator()( const Point_2&, const Origin&) const { return Vector_2(); } Vector_2 operator()( const Segment_2&) const { return Vector_2(); } Vector_2 operator()( const Ray_2&) const { return Vector_2(); } Vector_2 operator()( const Line_2&) const { return Vector_2(); } Vector_2 operator()( Null_vector) const { return Vector_2(); } }; template class Construct_vector_3 { typedef typename K::RT RT; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Line_3 Line_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()() const { return Vector_3(); } Vector_3 operator()( const Point_3&, const Point_3&) const { return Vector_3(); } Vector_3 operator()( const Origin&, const Point_3&) const { return Vector_3(); } Vector_3 operator()( const Point_3&, const Origin&) const { return Vector_3(); } Vector_3 operator()( const Segment_3&) const { return Vector_3(); } Vector_3 operator()( const Ray_3&) const { return Vector_3(); } Vector_3 operator()( const Line_3&) const { return Vector_3(); } Vector_3 operator()( Null_vector) const { return Vector_3(); } }; template class Construct_vertex_2 { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Segment_2&, int) const { return Point_2(); } Point_2 operator()( const Triangle_2&, int) const { return Point_2(); } Point_2 operator()( const Iso_rectangle_2&, int) const { return Point_2(); } }; template class Construct_vertex_3 { typedef typename K::Point_3 Point_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Segment_3&, int) const { return Point_3(); } Point_3 operator()( const Triangle_3&, int) const { return Point_3(); } Point_3 operator()( const Iso_cuboid_3&, int) const { return Point_3(); } Point_3 operator()( const Tetrahedron_3&, int) const { return Point_3(); } }; template class Construct_bbox_2 { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Circle_2 Circle_2; public: typedef Bbox_2 result_type; typedef Arity_tag< 1 > Arity; Bbox_2 operator()( const Point_2& p) const { Bbox_2 b; return b; } Bbox_2 operator()( const Segment_2& s) const { Bbox_2 b; return b; } Bbox_2 operator()( const Triangle_2& t) const { Bbox_2 b; return b; } Bbox_2 operator()( const Iso_rectangle_2& r) const { Bbox_2 b; return b; } Bbox_2 operator()( const Circle_2& c) const { Bbox_2 b; return b; } }; template class Construct_bbox_3 { typedef typename K::Point_3 Point_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Bbox_3 result_type; typedef Arity_tag< 1 > Arity; Bbox_3 operator()( const Point_3& p) const { Bbox_3 b; return b; } Bbox_3 operator()( const Segment_3& s) const { Bbox_3 b; return b; } Bbox_3 operator()( const Triangle_3& t) const { Bbox_3 b; return b; } Bbox_3 operator()( const Iso_cuboid_3& r) const { Bbox_3 b; return b; } Bbox_3 operator()( const Tetrahedron_3& t) const { Bbox_3 b; return b; } Bbox_3 operator()( const Sphere_3& s) const { Bbox_3 b; return b; } }; template class Construct_cartesian_const_iterator_2 { typedef typename K::Point_2 Point_2; typedef typename K::Cartesian_const_iterator_2 Cartesian_const_iterator_2; public: typedef Cartesian_const_iterator_2 result_type; typedef Arity_tag< 1 > Arity; Cartesian_const_iterator_2 operator()( const Point_2& p) const { return Cartesian_const_iterator_2(); } Cartesian_const_iterator_2 operator()( const Point_2& p, int) const { return Cartesian_const_iterator_2(); } }; template class Construct_cartesian_const_iterator_3 { typedef typename K::Point_3 Point_3; typedef typename K::Cartesian_const_iterator_3 Cartesian_const_iterator_3; public: typedef Cartesian_const_iterator_3 result_type; typedef Arity_tag< 1 > Arity; Cartesian_const_iterator_3 operator()( const Point_3& p) const { return Cartesian_const_iterator_3(); } Cartesian_const_iterator_3 operator()( const Point_3& p, int) const { return Cartesian_const_iterator_3(); } }; template class Coplanar_orientation_3 { typedef typename K::Point_3 Point_3; public: typedef Orientation result_type; typedef Arity_tag< 4 > Arity; Orientation operator()(const Point_3&, const Point_3&, const Point_3&) const { return CGAL::COLLINEAR; } Orientation operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return CGAL::COLLINEAR; } }; template class Coplanar_side_of_bounded_circle_3 { typedef typename K::Point_3 Point_3; public: typedef Bounded_side result_type; typedef Arity_tag< 4 > Arity; Bounded_side operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } }; template class Coplanar_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 4 > Arity; bool operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Counterclockwise_in_between_2 { typedef typename K::Direction_2 Direction_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()( const Direction_2&, const Direction_2&, const Direction_2&) const { return true; } }; template class Do_intersect_2 { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // There are 36 combinaisons, so I use a template. template bool operator()(const T1&, const T2&) const { return true; } }; template class Do_intersect_3 { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // There are x combinaisons, so I use a template. template bool operator()(const T1&, const T2&) const { return true; } }; template class Equal_xy_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Equal_x_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2&, const Point_2&) const { return true; } }; template class Equal_x_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Equal_y_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2&, const Point_2&) const { return true; } }; template class Equal_y_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Equal_z_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Equal_2 { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // template to replace n different versions template bool operator()(const T&, const T&) const { return true; } }; template class Equal_3 { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // template to replace n different versions template bool operator()(const T&, const T&) const { return true; } }; template class Has_on_boundary_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2&, const Point_2&) const { return true; } bool operator()( const Triangle_2&, const Point_2&) const { return true; } bool operator()( const Iso_rectangle_2&, const Point_2&) const { return true; } }; template class Has_on_boundary_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Plane_3 Plane_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3&, const Point_3&) const { return true; } bool operator()( const Tetrahedron_3&, const Point_3&) const { return true; } bool operator()( const Iso_cuboid_3&, const Point_3&) const { return true; } }; template class Has_on_bounded_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2&, const Point_2&) const { return true; } bool operator()( const Triangle_2&, const Point_2&) const { return true; } bool operator()( const Iso_rectangle_2&, const Point_2&) const { return true; } }; template class Has_on_bounded_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3&, const Point_3&) const { return true; } bool operator()( const Tetrahedron_3&, const Point_3&) const { return true; } bool operator()( const Iso_cuboid_3&, const Point_3&) const { return true; } }; template class Has_on_negative_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2&, const Point_2&) const { return true; } bool operator()( const Triangle_2&, const Point_2&) const { return true; } bool operator()( const Line_2&, const Point_2&) const { return true; } }; template class Has_on_negative_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3&, const Point_3&) const { return true; } bool operator()( const Tetrahedron_3&, const Point_3&) const { return true; } bool operator()( const Plane_3&, const Point_3&) const { return true; } }; template class Has_on_positive_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2&, const Point_2&) const { return true; } bool operator()( const Triangle_2&, const Point_2&) const { return true; } bool operator()( const Line_2&, const Point_2&) const { return true; } }; template class Has_on_positive_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3&, const Point_3&) const { return true; } bool operator()( const Tetrahedron_3&, const Point_3&) const { return true; } bool operator()( const Plane_3&, const Point_3&) const { return true; } }; template class Has_on_unbounded_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2&, const Point_2&) const { return true; } bool operator()( const Triangle_2&, const Point_2&) const { return true; } bool operator()( const Iso_rectangle_2&, const Point_2&) const { return true; } }; template class Has_on_unbounded_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3&, const Point_3&) const { return true; } bool operator()( const Tetrahedron_3&, const Point_3&) const { return true; } bool operator()( const Iso_cuboid_3&, const Point_3&) const { return true; } }; template class Has_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Line_2&, const Point_2&) const { return true; } bool operator()( const Ray_2&, const Point_2&) const { return true; } bool operator()( const Segment_2&, const Point_2&) const { return true; } }; template class Has_on_3 { typedef typename K::Point_3 Point_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Triangle_3 Triangle_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Line_3&, const Point_3&) const { return true; } bool operator()( const Ray_3&, const Point_3&) const { return true; } bool operator()( const Segment_3&, const Point_3&) const { return true; } bool operator()( const Plane_3&, const Point_3&) const { return true; } bool operator()( const Triangle_3&, const Point_3&) const { return true; } }; template class Intersect_2 { typedef typename K::Object_2 Object_2; public: typedef Object_2 result_type; typedef Arity_tag< 2 > Arity; // 25 possibilities, so I keep the template. template Object_2 operator()(const T1&, const T2&) const { return Object_2(); } }; template class Intersect_3 { typedef typename K::Object_3 Object_3; public: typedef Object_3 result_type; typedef Arity_tag< 2 > Arity; // n possibilities, so I keep the template. template Object_3 operator()(const T1&, const T2&) const { return Object_3(); } }; template class Is_degenerate_2 { typedef typename K::Circle_2 Circle_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Circle_2&) const { return true; } bool operator()( const Iso_rectangle_2&) const { return true; } bool operator()( const Line_2&) const { return true; } bool operator()( const Ray_2&) const { return true; } bool operator()( const Segment_2&) const { return true; } bool operator()( const Triangle_2&) const { return true; } }; template class Is_degenerate_3 { typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Line_3 Line_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Iso_cuboid_3&) const { return true; } bool operator()( const Line_3&) const { return true; } bool operator()( const Plane_3&) const { return true; } bool operator()( const Ray_3&) const { return true; } bool operator()( const Segment_3&) const { return true; } bool operator()( const Sphere_3&) const { return true; } bool operator()( const Triangle_3&) const { return true; } bool operator()( const Tetrahedron_3&) const { return true; } }; template class Is_horizontal_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Line_2&) const { return true; } bool operator()( const Segment_2&) const { return true; } bool operator()( const Ray_2&) const { return true; } }; template class Is_vertical_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Line_2&) const { return true; } bool operator()( const Segment_2&) const { return true; } bool operator()( const Ray_2&) const { return true; } }; template class Left_turn_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Less_distance_to_point_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Less_distance_to_point_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Less_rotate_ccw_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&) const { return true; } }; template class Less_signed_distance_to_line_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef bool result_type; typedef Arity_tag< 4 > Arity; bool operator()(const Point_2&, const Point_2&, const Point_2&, const Point_2&) const { return true; } bool operator()(const Line_2&, const Point_2&, const Point_2&) const { return true; } }; template class Less_signed_distance_to_plane_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()( const Plane_3&, const Point_3&, const Point_3&) const { return true; } bool operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return true; } }; template class Less_xyz_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Less_xy_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2&, const Point_2&) const { return true; } }; template class Less_xy_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Less_x_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2&, const Point_2&) const { return true; } }; template class Less_x_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Less_yx_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2&, const Point_2&) const { return true; } }; template class Less_y_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2&, const Point_2&) const { return true; } }; template class Less_y_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Less_z_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3&, const Point_3&) const { return true; } }; template class Orientation_2 { typedef typename K::Point_2 Point_2; public: typedef Orientation result_type; typedef Arity_tag< 3 > Arity; Orientation operator()(const Point_2&, const Point_2&, const Point_2&) const { return CGAL::COLLINEAR; } }; template class Orientation_3 { typedef typename K::Point_3 Point_3; public: typedef Orientation result_type; typedef Arity_tag< 4 > Arity; Orientation operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return CGAL::COLLINEAR; } }; template class Oriented_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Line_2 Line_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Oriented_side result_type; typedef Arity_tag< 2 > Arity; Oriented_side operator()( const Circle_2&, const Point_2&) const { return CGAL::ON_POSITIVE_SIDE; } Oriented_side operator()( const Line_2&, const Point_2&) const { return CGAL::ON_POSITIVE_SIDE; } Oriented_side operator()( const Triangle_2&, const Point_2&) const { return CGAL::ON_POSITIVE_SIDE; } }; template class Oriented_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Oriented_side result_type; typedef Arity_tag< 2 > Arity; Oriented_side operator()( const Sphere_3&, const Point_3&) const { return CGAL::ON_POSITIVE_SIDE; } Oriented_side operator()( const Plane_3&, const Point_3&) const { return CGAL::ON_POSITIVE_SIDE; } Oriented_side operator()( const Tetrahedron_3&, const Point_3&) const { return CGAL::ON_POSITIVE_SIDE; } }; template class Side_of_bounded_circle_2 { typedef typename K::Point_2 Point_2; public: typedef Bounded_side result_type; typedef Arity_tag< 4 > Arity; Bounded_side operator()( const Point_2&, const Point_2&, const Point_2&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Point_2&, const Point_2&, const Point_2&, const Point_2&) const { return CGAL::ON_BOUNDARY; } }; template class Side_of_bounded_sphere_3 { typedef typename K::Point_3 Point_3; public: typedef Bounded_side result_type; typedef Arity_tag< 5 > Arity; Bounded_side operator()( const Point_3&, const Point_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } Bounded_side operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return CGAL::ON_BOUNDARY; } }; template class Side_of_oriented_circle_2 { typedef typename K::Point_2 Point_2; public: typedef Oriented_side result_type; typedef Arity_tag< 4 > Arity; Oriented_side operator()( const Point_2&, const Point_2&, const Point_2&, const Point_2&) const { return CGAL::ON_POSITIVE_SIDE; } }; template class Side_of_oriented_sphere_3 { typedef typename K::Point_3 Point_3; public: typedef Oriented_side result_type; typedef Arity_tag< 5 > Arity; Oriented_side operator()( const Point_3&, const Point_3&, const Point_3&, const Point_3&, const Point_3&) const { return CGAL::ON_POSITIVE_SIDE; } }; } // namespace CGALca CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Cartesian_coordinate_iterator_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Cartesian_coord0000644000175000017500000000621711344301501031271 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Cartesian_coordinate_iterator_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_COORDINATE_ITERATOR_2_H #define CGAL_CARTESIAN_COORDINATE_ITERATOR_2_H #include #include CGAL_BEGIN_NAMESPACE template class Cartesian_coordinate_iterator_2 { protected: typedef typename K::Point_2 P; const P* point; int index; typedef Cartesian_coordinate_iterator_2 Self; public: typedef typename K::FT FT; typedef P Point; typedef std::random_access_iterator_tag iterator_category; typedef FT value_type; typedef std::ptrdiff_t difference_type; typedef const value_type& reference; typedef const value_type* pointer; Cartesian_coordinate_iterator_2(const Point *const p = NULL, int _index = 0) : point(p), index(_index) {} const FT operator*() const { return point->cartesian(index); } Self& operator++() { index++; return *this; } Self& operator--() { index--; return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } Self& operator+=(difference_type i) { index+=i; return *this; } Self& operator-=(difference_type i) { index -= i; return *this; } Self operator+(difference_type i) const { Self tmp=*this; return tmp += i; } Self operator-(difference_type i) const { Self tmp=*this; return tmp -= i; } difference_type operator-(const Self& x) const { CGAL_kernel_assertion(point == x.point); return index - x.index; } reference operator[](difference_type i) const { return *(*this + i); } bool operator==(const Self& x) const { return (point == x.point)&& (index == x.index) ; } bool operator!=(const Self& x) const { return ! (*this==x); } bool operator<(const Self& x) const { return (x - *this) > 0; } }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_COORDINATE_ITERATOR_2_H ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/concept_archetype_interface_macros.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/concept_archety0000644000175000017500000007402711344301501031350 0ustar debiandebian// Copyright (c) 1999,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/concept_archetype_interface_macros.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Matthias Baesken // for the original version see Kernel/interface_macros.h // This file is intentionally not protected against re-inclusion. // It's aimed at being included from within a kernel traits class, this // way we share more code. // It is the responsability of the including file to correctly set the 2 // macros CGAL_Kernel_pred and CGAL_Kernel_cons. // And they are #undefed at the end of this file. #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ANGLE_2) CGAL_Kernel_pred(Angle_2, angle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ANGLE_3) CGAL_Kernel_pred(Angle_3, angle_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_ARE_ORDERED_ALONG_LINE_2) CGAL_Kernel_pred(Are_ordered_along_line_2, are_ordered_along_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_ARE_ORDERED_ALONG_LINE_3) CGAL_Kernel_pred(Are_ordered_along_line_3, are_ordered_along_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_ARE_PARALLEL_2) CGAL_Kernel_pred(Are_parallel_2, are_parallel_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_ARE_PARALLEL_3) CGAL_Kernel_pred(Are_parallel_3, are_parallel_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_ARE_STRICTLY_ORDERED_ALONG_LINE_2) CGAL_Kernel_pred(Are_strictly_ordered_along_line_2, are_strictly_ordered_along_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_ARE_STRICTLY_ORDERED_ALONG_LINE_3) CGAL_Kernel_pred(Are_strictly_ordered_along_line_3, are_strictly_ordered_along_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ASSIGN_2) CGAL_Kernel_cons(Assign_2, assign_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ASSIGN_3) CGAL_Kernel_cons(Assign_3, assign_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_BOUNDED_SIDE_2) CGAL_Kernel_pred(Bounded_side_2, bounded_side_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_BOUNDED_SIDE_3) CGAL_Kernel_pred(Bounded_side_3, bounded_side_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COLLINEAR_ARE_ORDERED_ALONG_LINE_2) CGAL_Kernel_pred(Collinear_are_ordered_along_line_2, collinear_are_ordered_along_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COLLINEAR_ARE_ORDERED_ALONG_LINE_3) CGAL_Kernel_pred(Collinear_are_ordered_along_line_3, collinear_are_ordered_along_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COLLINEAR_ARE_STRICTLY_ORDERED_ALONG_LINE_2) CGAL_Kernel_pred(Collinear_are_strictly_ordered_along_line_2, collinear_are_strictly_ordered_along_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COLLINEAR_ARE_STRICTLY_ORDERED_ALONG_LINE_3) CGAL_Kernel_pred(Collinear_are_strictly_ordered_along_line_3, collinear_are_strictly_ordered_along_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COLLINEAR_HAS_ON_2) CGAL_Kernel_pred(Collinear_has_on_2, collinear_has_on_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COLLINEAR_2) CGAL_Kernel_pred(Collinear_2, collinear_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COLLINEAR_3) CGAL_Kernel_pred(Collinear_3, collinear_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPARE_ANGLE_WITH_X_AXIS_2) CGAL_Kernel_pred(Compare_angle_with_x_axis_2, compare_angle_with_x_axis_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPARE_DISTANCE_2) CGAL_Kernel_pred(Compare_distance_2, compare_distance_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPARE_DISTANCE_3) CGAL_Kernel_pred(Compare_distance_3, compare_distance_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPARE_SLOPE_2) CGAL_Kernel_pred(Compare_slope_2, compare_slope_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPARE_X_AT_Y_2) CGAL_Kernel_pred(Compare_x_at_y_2, compare_x_at_y_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_XYZ_3) CGAL_Kernel_pred(Compare_xyz_3, compare_xyz_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_XY_2) CGAL_Kernel_pred(Compare_xy_2, compare_xy_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_XY_3) CGAL_Kernel_pred(Compare_xy_3, compare_xy_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_X_2) CGAL_Kernel_pred(Compare_x_2, compare_x_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_X_3) CGAL_Kernel_pred(Compare_x_3, compare_x_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_Y_AT_X_2) CGAL_Kernel_pred(Compare_y_at_x_2, compare_y_at_x_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_Y_2) CGAL_Kernel_pred(Compare_y_2, compare_y_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_Y_3) CGAL_Kernel_pred(Compare_y_3, compare_y_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPARE_Z_3) CGAL_Kernel_pred(Compare_z_3, compare_z_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPUTE_AREA_2) CGAL_Kernel_cons(Compute_area_2, compute_area_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPUTE_AREA_2) CGAL_Kernel_cons(Compute_area_3, compute_area_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SCALAR_PRODUCT_2) CGAL_Kernel_cons(Compute_scalar_product_2, compute_scalar_product_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SCALAR_PRODUCT_3) CGAL_Kernel_cons(Compute_scalar_product_3, compute_scalar_product_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COMPUTE_AREA_3) CGAL_Kernel_cons(Compute_squared_area_3, compute_squared_area_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SQUARED_DISTANCE_2) CGAL_Kernel_cons(Compute_squared_distance_2, compute_squared_distance_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SQUARED_DISTANCE_3) CGAL_Kernel_cons(Compute_squared_distance_3, compute_squared_distance_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SQUARED_LENGTH_2) CGAL_Kernel_cons(Compute_squared_length_2, compute_squared_length_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SQUARED_LENGTH_3) CGAL_Kernel_cons(Compute_squared_length_3, compute_squared_length_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SQUARED_RADIUS_2) CGAL_Kernel_cons(Compute_squared_radius_2, compute_squared_radius_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_SQUARED_RADIUS_3) CGAL_Kernel_cons(Compute_squared_radius_3, compute_squared_radius_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COMPUTE_VOLUME_3) CGAL_Kernel_cons(Compute_volume_3, compute_volume_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_BASE_VECTOR_3) CGAL_Kernel_cons(Construct_base_vector_3, construct_base_vector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_BISECTOR_2) CGAL_Kernel_cons(Construct_bisector_2, construct_bisector_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_BISECTOR_3) CGAL_Kernel_cons(Construct_bisector_3, construct_bisector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CENTER_2) CGAL_Kernel_cons(Construct_center_2, construct_center_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CENTER_3) CGAL_Kernel_cons(Construct_center_3, construct_center_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CENTROID_2) CGAL_Kernel_cons(Construct_centroid_2, construct_centroid_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CENTROID_3) CGAL_Kernel_cons(Construct_centroid_3, construct_centroid_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CIRCLE_2) CGAL_Kernel_cons(Construct_circle_2, construct_circle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CIRCUMCENTER_2) CGAL_Kernel_cons(Construct_circumcenter_2, construct_circumcenter_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CIRCUMCENTER_3) CGAL_Kernel_cons(Construct_circumcenter_3, construct_circumcenter_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CROSS_PRODUCT_VECTOR_3) CGAL_Kernel_cons(Construct_cross_product_vector_3, construct_cross_product_vector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_DIRECTION_2) CGAL_Kernel_cons(Construct_direction_2, construct_direction_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_DIRECTION_3) CGAL_Kernel_cons(Construct_direction_3, construct_direction_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_ISO_CUBOID_3) CGAL_Kernel_cons(Construct_iso_cuboid_3, construct_iso_cuboid_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_ISO_RECTANGLE_2) CGAL_Kernel_cons(Construct_iso_rectangle_2, construct_iso_rectangle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_LIFTED_POINT_3) CGAL_Kernel_cons(Construct_lifted_point_3, construct_lifted_point_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_LINE_2) CGAL_Kernel_cons(Construct_line_2, construct_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_LINE_3) CGAL_Kernel_cons(Construct_line_3, construct_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_MAX_VERTEX_2) CGAL_Kernel_cons(Construct_max_vertex_2, construct_max_vertex_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_MAX_VERTEX_3) CGAL_Kernel_cons(Construct_max_vertex_3, construct_max_vertex_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_MIDPOINT_2) CGAL_Kernel_cons(Construct_midpoint_2, construct_midpoint_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_MIDPOINT_3) CGAL_Kernel_cons(Construct_midpoint_3, construct_midpoint_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_MIN_VERTEX_2) CGAL_Kernel_cons(Construct_min_vertex_2, construct_min_vertex_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_MIN_VERTEX_3) CGAL_Kernel_cons(Construct_min_vertex_3, construct_min_vertex_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OBJECT_2) CGAL_Kernel_cons(Construct_object_2, construct_object_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_OBJECT_3) CGAL_Kernel_cons(Construct_object_3, construct_object_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_CIRCLE_2) CGAL_Kernel_cons(Construct_opposite_circle_2, construct_opposite_circle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_DIRECTION_2) CGAL_Kernel_cons(Construct_opposite_direction_2, construct_opposite_direction_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_DIRECION_3) CGAL_Kernel_cons(Construct_opposite_direction_3, construct_opposite_direction_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_LINE_2) CGAL_Kernel_cons(Construct_opposite_line_2, construct_opposite_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_LINE_3) CGAL_Kernel_cons(Construct_opposite_line_3, construct_opposite_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_PLANE_3) CGAL_Kernel_cons(Construct_opposite_plane_3, construct_opposite_plane_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_RAY_2) CGAL_Kernel_cons(Construct_opposite_ray_2, construct_opposite_ray_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_RAY_3) CGAL_Kernel_cons(Construct_opposite_ray_3, construct_opposite_ray_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_SEGMENT_2) CGAL_Kernel_cons(Construct_opposite_segment_2, construct_opposite_segment_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_SEGMENT_3) CGAL_Kernel_cons(Construct_opposite_segment_3, construct_opposite_segment_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_SPHERE_3) CGAL_Kernel_cons(Construct_opposite_sphere_3, construct_opposite_sphere_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_TRIANGLE_2) CGAL_Kernel_cons(Construct_opposite_triangle_2, construct_opposite_triangle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_VECTOR_2) CGAL_Kernel_cons(Construct_opposite_vector_2, construct_opposite_vector_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_OPPOSITE_VECTOR_3) CGAL_Kernel_cons(Construct_opposite_vector_3, construct_opposite_vector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_ORTHOGONAL_VECTOR_3) CGAL_Kernel_cons(Construct_orthogonal_vector_3, construct_orthogonal_vector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PERPENDICULAR_DIRECTION_2) CGAL_Kernel_cons(Construct_perpendicular_direction_2, construct_perpendicular_direction_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PERPENDICULAR_LINE_2) CGAL_Kernel_cons(Construct_perpendicular_line_2, construct_perpendicular_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PERPENDICULAR_LINE_3) CGAL_Kernel_cons(Construct_perpendicular_line_3, construct_perpendicular_line_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PERPENDICULAR_PLANE_3) CGAL_Kernel_cons(Construct_perpendicular_plane_3, construct_perpendicular_plane_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PERPENDICULAR_VECTOR_2) CGAL_Kernel_cons(Construct_perpendicular_vector_2, construct_perpendicular_vector_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PLANE_3) CGAL_Kernel_cons(Construct_plane_3, construct_plane_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_POINT_ON_2) CGAL_Kernel_cons(Construct_point_on_2, construct_point_on_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_POINT_ON_3) CGAL_Kernel_cons(Construct_point_on_3, construct_point_on_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_POINT_2) CGAL_Kernel_cons(Construct_point_2, construct_point_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_POINT_3) CGAL_Kernel_cons(Construct_point_3, construct_point_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PROJECTED_POINT_2) CGAL_Kernel_cons(Construct_projected_point_2, construct_projected_point_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PROJECTED_POINT_3) CGAL_Kernel_cons(Construct_projected_point_3, construct_projected_point_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_PROJECTED_XY_POINT_2) CGAL_Kernel_cons(Construct_projected_xy_point_2, construct_projected_xy_point_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_RAY_2) CGAL_Kernel_cons(Construct_ray_2, construct_ray_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_RAY_3) CGAL_Kernel_cons(Construct_ray_3, construct_ray_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SCALED_VECTOR_2) CGAL_Kernel_cons(Construct_scaled_vector_2, construct_scaled_vector_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SCALED_VECTOR_3) CGAL_Kernel_cons(Construct_scaled_vector_3, construct_scaled_vector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SEGMENT_2) CGAL_Kernel_cons(Construct_segment_2, construct_segment_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SEGMENT_3) CGAL_Kernel_cons(Construct_segment_3, construct_segment_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SPHERE_3) CGAL_Kernel_cons(Construct_sphere_3, construct_sphere_3_object) #endif #ifndef CGAL_NO_DEPRECATED_CODE #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SUPPORTING_LINE_2) CGAL_Kernel_cons(Construct_supporting_line_2, construct_supporting_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SUPPORTING_LINE_3) CGAL_Kernel_cons(Construct_supporting_line_3, construct_supporting_line_3_object) #endif #endif // CGAL_NO_DEPRECATED_CODE #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_SUPPORTING_PLANE_3) CGAL_Kernel_cons(Construct_supporting_plane_3, construct_supporting_plane_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_TETRAHEDRON_3) CGAL_Kernel_cons(Construct_tetrahedron_3, construct_tetrahedron_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_TRANSLATED_POINT_2) CGAL_Kernel_cons(Construct_translated_point_2, construct_translated_point_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_TRANSLATED_POINT_3) CGAL_Kernel_cons(Construct_translated_point_3, construct_translated_point_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_TRIANGLE_2) CGAL_Kernel_cons(Construct_triangle_2, construct_triangle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_TRIANGLE_3) CGAL_Kernel_cons(Construct_triangle_3, construct_triangle_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_VECTOR_2) CGAL_Kernel_cons(Construct_vector_2, construct_vector_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_VECTOR_3) CGAL_Kernel_cons(Construct_vector_3, construct_vector_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_VERTEX_2) CGAL_Kernel_cons(Construct_vertex_2, construct_vertex_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_VERTEX_3) CGAL_Kernel_cons(Construct_vertex_3, construct_vertex_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_BBOX_2) CGAL_Kernel_cons(Construct_bbox_2, construct_bbox_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CONSTRUCT_BBOX_3) CGAL_Kernel_cons(Construct_bbox_3, construct_bbox_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CARTESIAN_COORDINATE_ITERATOR_2) CGAL_Kernel_cons(Construct_cartesian_const_iterator_2, construct_cartesian_const_iterator_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CONSTRUCT_CARTESIAN_COORDINATE_ITERATOR_3) CGAL_Kernel_cons(Construct_cartesian_const_iterator_3, construct_cartesian_const_iterator_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COPLANAR_ORIENTATION_3) CGAL_Kernel_pred(Coplanar_orientation_3, coplanar_orientation_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COPLANAR_SIDE_OF_BOUNDED_CIRCLE_3) CGAL_Kernel_pred(Coplanar_side_of_bounded_circle_3, coplanar_side_of_bounded_circle_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_COPLANAR_3) CGAL_Kernel_pred(Coplanar_3, coplanar_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_COUNTERCLOCKWISE_IN_BETWEEN_2) CGAL_Kernel_pred(Counterclockwise_in_between_2, counterclockwise_in_between_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_DO_INTERSECT_2) CGAL_Kernel_pred(Do_intersect_2, do_intersect_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_DO_INTERSECT_3) CGAL_Kernel_cons(Do_intersect_3, do_intersect_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_XY_3) CGAL_Kernel_pred(Equal_xy_3, equal_xy_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_X_2) CGAL_Kernel_pred(Equal_x_2, equal_x_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_X_3) CGAL_Kernel_pred(Equal_x_3, equal_x_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_Y_2) CGAL_Kernel_pred(Equal_y_2, equal_y_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_Y_3) CGAL_Kernel_pred(Equal_y_3, equal_y_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_Z_3) CGAL_Kernel_pred(Equal_z_3, equal_z_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_2) CGAL_Kernel_pred(Equal_2, equal_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_EQUAL_3) CGAL_Kernel_pred(Equal_3, equal_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_HAS_ON_BOUNDARY_2) CGAL_Kernel_pred(Has_on_boundary_2, has_on_boundary_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_HAS_ON_BOUNDARY_3) CGAL_Kernel_pred(Has_on_boundary_3, has_on_boundary_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_BOUNDED_SIDE_2) CGAL_Kernel_pred(Has_on_bounded_side_2, has_on_bounded_side_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_BOUNDED_SIDE_3) CGAL_Kernel_pred(Has_on_bounded_side_3, has_on_bounded_side_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_NEGATIVE_SIDE_2) CGAL_Kernel_pred(Has_on_negative_side_2, has_on_negative_side_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_NEGATIVE_SIDE_3) CGAL_Kernel_pred(Has_on_negative_side_3, has_on_negative_side_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_POSITIVE_SIDE_2) CGAL_Kernel_pred(Has_on_positive_side_2, has_on_positive_side_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_POSITIVE_SIDE_3) CGAL_Kernel_pred(Has_on_positive_side_3, has_on_positive_side_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_UNBOUNDED_SIDE_2) CGAL_Kernel_pred(Has_on_unbounded_side_2, has_on_unbounded_side_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_HAS_ON_UNBOUNDED_SIDE_3) CGAL_Kernel_pred(Has_on_unbounded_side_3, has_on_unbounded_side_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_HAS_ON_2) CGAL_Kernel_pred(Has_on_2, has_on_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_HAS_ON_3) CGAL_Kernel_pred(Has_on_3, has_on_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_INTERSECT_2) CGAL_Kernel_cons(Intersect_2, intersect_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_INTERSECT_3) CGAL_Kernel_cons(Intersect_3, intersect_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_IS_DEGENERATE_2) CGAL_Kernel_pred(Is_degenerate_2, is_degenerate_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_IS_DEGENERATE_3) CGAL_Kernel_pred(Is_degenerate_3, is_degenerate_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_IS_HORIZONTAL_2) CGAL_Kernel_pred(Is_horizontal_2, is_horizontal_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_IS_VERTICAL_2) CGAL_Kernel_pred(Is_vertical_2, is_vertical_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LEFT_TURN_2) CGAL_Kernel_pred(Left_turn_2, left_turn_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_LESS_DISTANCE_TO_POINT_2) CGAL_Kernel_pred(Less_distance_to_point_2, less_distance_to_point_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_LESS_DISTANCE_TO_POINT_3) CGAL_Kernel_pred(Less_distance_to_point_3, less_distance_to_point_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_LESS_ROTATE_CCW_2) CGAL_Kernel_pred(Less_rotate_ccw_2, less_rotate_ccw_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_LESS_SIGNED_DISTANCE_TO_LINE_2) CGAL_Kernel_pred(Less_signed_distance_to_line_2, less_signed_distance_to_line_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_LESS_SIGNED_DISTANCE_TO_PLANE_3) CGAL_Kernel_pred(Less_signed_distance_to_plane_3, less_signed_distance_to_plane_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_XYZ_3) CGAL_Kernel_pred(Less_xyz_3, less_xyz_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_XY_2) CGAL_Kernel_pred(Less_xy_2, less_xy_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_XY_3) CGAL_Kernel_pred(Less_xy_3, less_xy_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_X_2) CGAL_Kernel_pred(Less_x_2, less_x_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_X_3) CGAL_Kernel_pred(Less_x_3, less_x_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_YX_2) CGAL_Kernel_pred(Less_yx_2, less_yx_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_Y_2) CGAL_Kernel_pred(Less_y_2, less_y_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_Y_3) CGAL_Kernel_pred(Less_y_3, less_y_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LESS_Z_3) CGAL_Kernel_pred(Less_z_3, less_z_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ORIENTATION_2) CGAL_Kernel_pred(Orientation_2, orientation_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ORIENTATION_3) CGAL_Kernel_pred(Orientation_3, orientation_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ORIENTED_SIDE_2) CGAL_Kernel_pred(Oriented_side_2, oriented_side_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ORIENTED_SIDE_3) CGAL_Kernel_pred(Oriented_side_3, oriented_side_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_SIDE_OF_BOUNDED_CIRCLE_2) CGAL_Kernel_pred(Side_of_bounded_circle_2, side_of_bounded_circle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_SIDE_OF_BOUNDED_SPHERE_3) CGAL_Kernel_pred(Side_of_bounded_sphere_3, side_of_bounded_sphere_3_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_SIDE_OF_ORIENTED_CIRCLE_2) CGAL_Kernel_pred(Side_of_oriented_circle_2, side_of_oriented_circle_2_object) #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_SIDE_OF_ORIENTED_SPHERE_3) CGAL_Kernel_pred(Side_of_oriented_sphere_3, side_of_oriented_sphere_3_object) #endif // deprecated functors were removed ... #undef CGAL_Kernel_pred #undef CGAL_Kernel_cons mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Wutils.h0000644000175000017500000001467411344301501027715 0ustar debiandebian// Copyright (c) 1998,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Wutils.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman, Sylvain Pion #ifndef CGAL_KERNEL_WUTILS_H #define CGAL_KERNEL_WUTILS_H #include #include #include #include // Functions wmult() and wcross(). CGAL_BEGIN_NAMESPACE namespace CGALi { template < typename Rep_Tag > struct wmult_tag; template <> struct wmult_tag { template < typename RT > const RT & operator()(const RT &a, const RT &) const { return a; } template < typename RT > const RT & operator()(const RT &a, const RT &, const RT &) const { return a; } template < typename RT > const RT & operator()(const RT &a, const RT &, const RT &, const RT &) const { return a; } template < typename RT > const RT & operator()(const RT &a, const RT &, const RT &, const RT &, const RT &) const { return a; } }; template <> struct wmult_tag { template < typename RT > RT operator()(const RT &a, const RT &w) const { return a*w; } template < typename RT > RT operator()(const RT &a, const RT &w1, const RT &w2) const { return a*w1*w2; } template < typename RT > RT operator()(const RT &a, const RT &w1, const RT &w2, const RT &w3) const { return a*w1*w2*w3; } template < typename RT > RT operator()(const RT &a, const RT &w1, const RT &w2, const RT &w3, const RT &w4) const { return a*w1*w2*w3*w4; } }; template < typename K > struct wmult_functor : public wmult_tag {}; template < typename Rep_Tag > struct wcross_tag_2; template <> struct wcross_tag_2 { template < typename Point_2 > typename Point_2::R::RT operator()(const Point_2 &p, const Point_2 &q, const Point_2 &r) const { return (q.x()-p.x())*(r.y()-q.y()) - (q.y()-p.y())*(r.x()-q.x()); } }; template <> struct wcross_tag_2 { template < typename Point_2 > typename Point_2::R::RT operator()(const Point_2 &p, const Point_2 &q, const Point_2 &r) const { return det3x3_by_formula(p.hx(), q.hx(), r.hx(), p.hy(), q.hy(), r.hy(), p.hw(), q.hw(), r.hw()); } }; template < typename K > struct wcross_functor_2 : public wcross_tag_2 {}; template < typename Rep_Tag > struct wcross_tag_3; template <> struct wcross_tag_3 { template < typename Point_3 > typename Point_3::R::Vector_3 operator()(const Point_3 &p, const Point_3 &q, const Point_3 &r) const { typedef typename Point_3::R::FT FT; typedef typename Point_3::R::Vector_3 Vector_3; FT x = (q.y()-p.y())*(r.z()-q.z()) - (q.z()-p.z())*(r.y()-q.y()); FT y = (q.z()-p.z())*(r.x()-q.x()) - (q.x()-p.x())*(r.z()-q.z()); FT z = (q.x()-p.x())*(r.y()-q.y()) - (q.y()-p.y())*(r.x()-q.x()); return Vector_3(x, y, z); } }; template <> struct wcross_tag_3 { template < typename Point_3 > typename Point_3::R::Vector_3 operator()(const Point_3 &p, const Point_3 &q, const Point_3 &r) const { typedef typename Point_3::R::RT RT; typedef typename Point_3::R::Vector_3 Vector_3; RT x = p.hy() * (q.hz()*r.hw() - q.hw()*r.hz() ) + p.hz() * (q.hw()*r.hy() - q.hy()*r.hw() ) + p.hw() * (q.hy()*r.hz() - q.hz()*r.hy() ); RT y = p.hz() * (q.hx()*r.hw() - q.hw()*r.hx() ) + p.hx() * (q.hw()*r.hz() - q.hz()*r.hw() ) + p.hw() * (q.hz()*r.hx() - q.hx()*r.hz() ); RT z = p.hx() * (q.hy()*r.hw() - q.hw()*r.hy() ) + p.hy() * (q.hw()*r.hx() - q.hx()*r.hw() ) + p.hw() * (q.hx()*r.hy() - q.hy()*r.hx() ); return Vector_3(x, y, z); } }; template < typename K > struct wcross_functor_3 : public wcross_tag_3 {}; } // end namespace CGALi template < typename K > inline typename K::RT wmult(K*, const typename K::RT &a, const typename K::RT &w) { return CGALi::wmult_functor()(a, w); } template < typename K > inline typename K::RT wmult(K*, const typename K::RT &a, const typename K::RT &w1, const typename K::RT &w2) { return CGALi::wmult_functor()(a, w1, w2); } template < typename K > inline typename K::RT wmult(K*, const typename K::RT &a, const typename K::RT &w1, const typename K::RT &w2, const typename K::RT &w3) { return CGALi::wmult_functor()(a, w1, w2, w3); } template < typename K > inline typename K::RT wmult(K*, const typename K::RT &a, const typename K::RT &w1, const typename K::RT &w2, const typename K::RT &w3, const typename K::RT &w4) { return CGALi::wmult_functor()(a, w1, w2, w3, w4); } template < typename K > inline typename K::RT wcross(K*, const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::wcross_functor_2()(p, q, r); } template < typename K > inline typename K::Vector_3 wcross(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::wcross_functor_3()(p, q, r); } CGAL_END_NAMESPACE #endif // CGAL_KERNEL_WUTILS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/mpl.h0000644000175000017500000000277111344301501027211 0ustar debiandebian// Copyright (c) 2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/mpl.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_MPL_H #define CGAL_KERNEL_MPL_H #include // Some tools for basic template metaprogramming. // These bits should move to CGAL/mpl.h in STL_Extension, or taken from Boost. CGAL_BEGIN_NAMESPACE template < typename A, typename B > struct First_if_different { typedef A Type; }; template < typename A > struct First_if_different { struct Type{}; }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_function0000644000175000017500000004014411344301501031334 0ustar debiandebian// Copyright (c) 2003-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_GLOBAL_FUNCTIONS_3_H #define CGAL_KERNEL_GLOBAL_FUNCTIONS_3_H #include #include #include // Generic functions calling the kernel functor. // See comments in CGAL/Kernel/global_functions_2.h. CGAL_BEGIN_NAMESPACE template inline Angle angle(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::angle(p, q, r, K()); } template < typename K > inline bool are_negative_oriented(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) { return CGALi::are_negative_oriented(p, q, r, s, K()); } template < class K > inline bool are_ordered_along_line(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::are_ordered_along_line(p, q, r, K()); } template < typename K > inline bool are_positive_oriented(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) { return CGALi::are_positive_oriented(p, q, r, s, K()); } template < class K > inline bool are_strictly_ordered_along_line(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::are_strictly_ordered_along_line(p, q, r, K()); } template inline typename K::Plane_3 bisector(const Point_3 &p, const Point_3 &q) { return CGALi::bisector(p, q, K()); } template inline typename K::Plane_3 bisector(const Plane_3 &h1, const Plane_3 &h2) { return CGALi::bisector(h1, h2, K()); } template < class K > inline Point_3 centroid(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::centroid(p, q, r, s, K()); } template < class K > inline Point_3 centroid(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::centroid(p, q, r, K()); } template < class K > inline typename K::Point_3 circumcenter(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::circumcenter(p, q, r, s, K()); } template < class K > inline typename K::Point_3 circumcenter(const Tetrahedron_3 &t) { return CGALi::circumcenter(t, K()); } template < class K > inline typename K::Point_3 circumcenter(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::circumcenter(p, q, r, K()); } template < class K > inline typename K::Point_3 circumcenter(const Triangle_3 &t) { return CGALi::circumcenter(t, K()); } template < class K > inline bool collinear(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::collinear(p, q, r, K()); } template < class K > inline bool collinear_are_ordered_along_line(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::collinear_are_ordered_along_line(p, q, r, K()); } template < class K > inline bool collinear_are_strictly_ordered_along_line(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::collinear_are_strictly_ordered_along_line(p, q, r, K()); } template < class K > inline Comparison_result compare_distance_to_point(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::compare_distance_to_point(p, q, r, K()); } template < class K > inline Comparison_result compare_lexicographically_xyz(const Point_3 &p, const Point_3 &q) { return CGALi::compare_lexicographically_xyz(p, q, K()); } template < class K > inline Comparison_result compare_signed_distance_to_plane(const Plane_3 &h, const Point_3 &p, const Point_3 &q) { return CGALi::compare_signed_distance_to_plane(h, p, q, K()); } template < class K > inline Comparison_result compare_signed_distance_to_plane(const Point_3 &hp, const Point_3 &hq, const Point_3 &hr, const Point_3 &p, const Point_3 &q) { return CGALi::compare_signed_distance_to_plane(hp, hq, hr, p, q, K()); } template < class K > inline Comparison_result compare_x(const Point_3 &p, const Point_3 &q) { return CGALi::compare_x(p, q, K()); } template < class K > inline Comparison_result compare_y(const Point_3 &p, const Point_3 &q) { return CGALi::compare_y(p, q, K()); } template < class K > inline Comparison_result compare_z(const Point_3 &p, const Point_3 &q) { return CGALi::compare_z(p, q, K()); } template < class K > inline Comparison_result compare_xyz(const Point_3 &p, const Point_3 &q) { return CGALi::compare_xyz(p, q, K()); } template < class K > inline bool coplanar(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::coplanar(p, q, r, s, K()); } template < class K > inline Orientation coplanar_orientation(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::coplanar_orientation(p, q, r, s, K()); } template < class K > inline Orientation coplanar_orientation(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::coplanar_orientation(p, q, r, K()); } template < class K > inline Bounded_side coplanar_side_of_bounded_circle(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &t) { return CGALi::coplanar_side_of_bounded_circle(p, q, r, t, K()); } template < class K > inline typename K::Vector_3 cross_product(const Vector_3 &v, const Vector_3 &w) { return CGALi::cross_product(v, w, K()); } template < class K > inline bool has_larger_distance_to_point(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::has_larger_distance_to_point(p, q, r, K()); } template < class K > inline bool has_larger_signed_distance_to_plane(const Point_3 &hp, const Point_3 &hq, const Point_3 &hr, const Point_3 &p, const Point_3 &q) { return CGALi::has_larger_signed_distance_to_plane(hp, hq, hr, p, q, K()); } template < class K > inline bool has_larger_signed_distance_to_plane(const Plane_3 &h, const Point_3 &p, const Point_3 &q) { return CGALi::has_larger_signed_distance_to_plane(h, p, q, K()); } template < class K > inline bool has_smaller_distance_to_point(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::has_smaller_distance_to_point(p, q, r, K()); } template < class K > inline bool has_smaller_signed_distance_to_plane(const Point_3 &hp, const Point_3 &hq, const Point_3 &hr, const Point_3 &p, const Point_3 &q) { return CGALi::has_smaller_signed_distance_to_plane(hp, hq, hr, p, q, K()); } template < class K > inline bool has_smaller_signed_distance_to_plane(const Plane_3 &h, const Point_3 &p, const Point_3 &q) { return CGALi::has_smaller_signed_distance_to_plane(h, p, q, K()); } template < class K > inline bool less_x(const Point_3 &p, const Point_3 &q) { return CGALi::less_x(p, q, K()); } template < class K > inline bool less_y(const Point_3 &p, const Point_3 &q) { return CGALi::less_y(p, q, K()); } template < class K > inline bool less_z(const Point_3 &p, const Point_3 &q) { return CGALi::less_z(p, q, K()); } template < class K > inline bool lexicographically_xyz_smaller(const Point_3 &p, const Point_3 &q) { return CGALi::lexicographically_xyz_smaller(p, q, K()); } template < class K > inline bool lexicographically_xyz_smaller_or_equal(const Point_3 &p, const Point_3 &q) { return CGALi::lexicographically_xyz_smaller_or_equal(p, q, K()); } template < class K > inline typename K::Point_3 midpoint(const Point_3 &p, const Point_3 &q) { return CGALi::midpoint(p, q, K()); } template < class K > inline typename K::Point_3 max_vertex(const Iso_cuboid_3 &ic) { return CGALi::max_vertex(ic, K()); } template < class K > inline typename K::Point_3 min_vertex(const Iso_cuboid_3 &ic) { return CGALi::min_vertex(ic, K()); } // FIXME TODO : what to do with the operators ? template < class K > inline bool operator==(const Point_3& p, const Point_3& q) { return K().equal_3_object()(p, q); } template < class K > inline bool operator!=(const Point_3& p, const Point_3& q) { return ! (p == q); } template < class K > inline bool operator==(const Point_3& p, const Origin& o) { return K().equal_3_object()(p, Point_3(o)); } template < class K > inline bool operator!=(const Point_3& p, const Origin& o) { return ! (p == o); } template < class K > inline bool operator<(const Point_3& p, const Point_3& q) { return K().less_xyz_3_object()(p, q); } template < class K > inline bool operator>(const Point_3& p, const Point_3& q) { return K().less_xyz_3_object()(q, p); } template < class K > inline bool operator<=(const Point_3& p, const Point_3& q) { return ! K().less_xyz_3_object()(q, p); } template < class K > inline bool operator>=(const Point_3& p, const Point_3& q) { return ! K().less_xyz_3_object()(p, q); } template < class K > inline typename K::Vector_3 operator*(const typename CGAL_WRAP(K)::FT &c, const Vector_3 &w) { return K().construct_scaled_vector_3_object()(w, c); } template < class K > inline typename K::Vector_3 operator*(const Vector_3 &w, const typename CGAL_WRAP(K)::FT &c) { return K().construct_scaled_vector_3_object()(w, c); } template < class K > inline typename K::Vector_3 operator*(const typename First_if_different::Type &c, const Vector_3 &w) { return K().construct_scaled_vector_3_object()(w, c); } template < class K > inline typename K::Vector_3 operator*(const Vector_3 &w, const typename First_if_different::Type &c) { return K().construct_scaled_vector_3_object()(w, c); } template < class K > inline typename K::FT operator*(const Vector_3 &v, const Vector_3 &w) { return K().compute_scalar_product_3_object()(v, w); } template < class K > inline typename K::Point_3 operator+(const Point_3 &p, const Vector_3 &v) { return K().construct_translated_point_3_object()(p, v); } template < class K > inline typename K::Point_3 operator+(const Origin &o, const Vector_3 &v) { return K().construct_translated_point_3_object()(o, v); } template < class K > inline typename K::Point_3 operator-(const Point_3 &p, const Vector_3 &v) { return K().construct_translated_point_3_object() (p, K().construct_opposite_vector_3_object()(v)); } template < class K > inline typename K::Point_3 operator-(const Origin &o, const Vector_3 &v) { return K().construct_translated_point_3_object() (o, K().construct_opposite_vector_3_object()(v)); } template < class K > inline typename K::Vector_3 operator-(const Point_3 &p, const Point_3 &q) { return K().construct_vector_3_object()(q, p); } template < class K > inline typename K::Vector_3 operator-(const Point_3 &p, const Origin &o) { return K().construct_vector_3_object()(o, p); } template < class K > inline typename K::Vector_3 operator-(const Origin &o, const Point_3 &q) { return K().construct_vector_3_object()(q, o); } template inline Orientation orientation(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::orientation(p, q, r, s, K()); } template inline typename K::Vector_3 orthogonal_vector(const Point_3& p, const Point_3& q, const Point_3& r) { return CGALi::orthogonal_vector(p, q, r, K()); } template inline typename K::Vector_3 orthogonal_vector(const Plane_3& p) { return CGALi::orthogonal_vector(p, K()); } // parallel() functions are in Kernel/global_functions.h template inline Bounded_side side_of_bounded_sphere(const Point_3 &p, const Point_3 &q, const Point_3 &test) { return CGALi::side_of_bounded_sphere(p, q, test, K()); } template inline Bounded_side side_of_bounded_sphere(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &test) { return CGALi::side_of_bounded_sphere(p, q, r, test, K()); } template inline Bounded_side side_of_bounded_sphere(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s, const Point_3 &test) { return CGALi::side_of_bounded_sphere(p, q, r, s, test, K()); } template inline Oriented_side side_of_oriented_sphere(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s, const Point_3 &test) { return CGALi::side_of_oriented_sphere(p, q, r, s, test, K()); } template inline typename K::FT squared_area(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::squared_area(p, q, r, K()); } template < class K > inline typename K::FT squared_radius(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::squared_radius(p, q, r, s, K()); } template < class K > inline typename K::FT squared_radius(const Point_3 &p, const Point_3 &q, const Point_3 &r) { return CGALi::squared_radius(p, q, r, K()); } template < class K > inline typename K::FT squared_radius(const Point_3 &p, const Point_3 &q) { return CGALi::squared_radius(p, q, K()); } template < class K > inline typename K::FT volume(const Point_3 &p, const Point_3 &q, const Point_3 &r, const Point_3 &s) { return CGALi::volume(p, q, r, s, K()); } template < class K > inline bool x_equal(const Point_3 &p, const Point_3 &q) { return CGALi::x_equal(p, q, K()); } template < class K > inline bool y_equal(const Point_3 &p, const Point_3 &q) { return CGALi::y_equal(p, q, K()); } template < class K > inline bool z_equal(const Point_3 &p, const Point_3 &q) { return CGALi::z_equal(p, q, K()); } CGAL_END_NAMESPACE #endif // CGAL_KERNEL_GLOBAL_FUNCTIONS_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Type_equality_wrapper.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Type_equality_w0000644000175000017500000000615311344301501031355 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Type_equality_wrapper.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_TYPE_EQUALITY_WRAPPER_H #define CGAL_KERNEL_TYPE_EQUALITY_WRAPPER_H #include CGAL_BEGIN_NAMESPACE // This is a kernel wrapper which provides the type equality between // Kernel::Point_2 and CGAL::Point_2, by deriving from // K_base::Point_2 (and similar for the other types). template < typename K_base, typename Kernel > struct Type_equality_wrapper : public K_base { typedef K_base Kernel_base; typedef CGAL::Point_2 Point_2; typedef CGAL::Vector_2 Vector_2; typedef CGAL::Direction_2 Direction_2; typedef CGAL::Line_2 Line_2; typedef CGAL::Ray_2 Ray_2; typedef CGAL::Segment_2 Segment_2; typedef CGAL::Triangle_2 Triangle_2; typedef CGAL::Circle_2 Circle_2; typedef CGAL::Iso_rectangle_2 Iso_rectangle_2; typedef CGAL::Aff_transformation_2 Aff_transformation_2; // Undocumented stuff. typedef CGAL::Conic_2 Conic_2; typedef CGAL::Point_3 Point_3; typedef CGAL::Vector_3 Vector_3; typedef CGAL::Direction_3 Direction_3; typedef CGAL::Line_3 Line_3; typedef CGAL::Plane_3 Plane_3; typedef CGAL::Ray_3 Ray_3; typedef CGAL::Segment_3 Segment_3; typedef CGAL::Triangle_3 Triangle_3; typedef CGAL::Tetrahedron_3 Tetrahedron_3; typedef CGAL::Sphere_3 Sphere_3; typedef CGAL::Iso_cuboid_3 Iso_cuboid_3; typedef CGAL::Aff_transformation_3 Aff_transformation_3; }; CGAL_END_NAMESPACE #endif // CGAL_KERNEL_TYPE_EQUALITY_WRAPPER_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_function0000644000175000017500000004437311344301501031344 0ustar debiandebian// Copyright (c) 2003-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_GLOBAL_FUNCTIONS_2_H #define CGAL_KERNEL_GLOBAL_FUNCTIONS_2_H // Generic functions taking "user classes" as parameters, calling the // internal functions (in *_internal*.h, namespace CGALi) taking a kernel as // additional parameter, which themselves call the corresponding kernel // functors. #include #include #include CGAL_BEGIN_NAMESPACE template < class K > inline Angle angle(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::angle(p, q, r, K()); } template < class K > inline bool are_ordered_along_line(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::are_ordered_along_line(p, q, r, K()); } template < class K > inline bool are_strictly_ordered_along_line(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::are_strictly_ordered_along_line(p, q, r, K()); } template < class K > inline typename K::FT area(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::area(p, q, r, K()); } template inline typename K::Line_2 bisector(const Point_2 &p, const Point_2 &q) { return CGALi::bisector(p, q, K()); } template inline typename K::Line_2 bisector(const Line_2 &l1, const Line_2 &l2) { return CGALi::bisector(l1, l2, K()); } template < class K > inline typename K::Point_2 centroid(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::centroid(p, q, r, K()); } template < class K > inline typename K::Point_2 centroid(const Point_2 &p, const Point_2 &q, const Point_2 &r, const Point_2 &s) { return CGALi::centroid(p, q, r, s, K()); } template < class K > inline typename K::Point_2 circumcenter(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::circumcenter(p, q, r, K()); } template < class K > inline typename K::Point_2 circumcenter(const Triangle_2 &t) { return CGALi::circumcenter(t, K()); } template < class K > inline bool collinear(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::collinear(p, q, r, K()); } template < class K > inline bool collinear_are_ordered_along_line(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::collinear_are_ordered_along_line(p, q, r, K()); } template < class K > inline bool collinear_are_strictly_ordered_along_line(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::collinear_are_strictly_ordered_along_line(p, q, r, K()); } template < typename K > inline Comparison_result compare_angle_with_x_axis(const Direction_2& d1, const Direction_2& d2) { return CGALi::compare_angle_with_x_axis(d1, d2, K()); } template inline Comparison_result compare_distance_to_point(const Point_2& p, const Point_2& q, const Point_2& r) { return CGALi::compare_distance_to_point(p, q, r, K()); } template inline Comparison_result compare_signed_distance_to_line(const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& s) { return CGALi::compare_signed_distance_to_line(p, q, r, s, K()); } template inline Comparison_result compare_signed_distance_to_line(const Line_2& l, const Point_2& p, const Point_2& q) { return CGALi::compare_signed_distance_to_line(l, p, q, K()); } /* FIXME : Undocumented, obsolete... template < class K > inline Comparison_result compare_lexicographically_xy(const Point_2 &p, const Point_2 &q) { return K().compare_xy_2_object()(p, q); } */ template < class K > inline Comparison_result compare_slopes(const Line_2 &l1, const Line_2 &l2) { return CGALi::compare_slopes(l1, l2, K()); } template < class K > inline Comparison_result compare_slopes(const Segment_2 &s1, const Segment_2 &s2) { return CGALi::compare_slopes(s1, s2, K()); } template < class K > inline Comparison_result compare_x(const Point_2 &p, const Point_2 &q) { return CGALi::compare_x(p, q, K()); } template < class K > inline Comparison_result compare_x(const Point_2& p, const Line_2& l1, const Line_2& l2) { return CGALi::compare_x(p, l1, l2, K()); } template < class K > inline Comparison_result compare_x(const Line_2 &l, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_x(l, h1, h2, K()); } template < class K > inline Comparison_result compare_x(const Line_2 &l1, const Line_2 &h1, const Line_2 &l2, const Line_2 &h2) { return CGALi::compare_x(l1, h1, l2, h2, K()); } template < class K > inline Comparison_result compare_x_at_y(const Point_2& p, const Line_2& h) { return CGALi::compare_x_at_y(p, h, K()); } /* Undocumented template < class K > inline Comparison_result compare_x_at_y(const Point_2& p, const Segment_2& s) { return CGALi::compare_x_at_y(p, s, K()); } */ template < class K > inline Comparison_result compare_x_at_y(const Point_2 &p, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_x_at_y(p, h1, h2, K()); } template < class K > inline Comparison_result compare_x_at_y(const Line_2 &l1, const Line_2 &l2, const Line_2 &h) { return CGALi::compare_x_at_y(l1, l2, h, K()); } template < class K > inline Comparison_result compare_x_at_y(const Line_2 &l1, const Line_2 &l2, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_x_at_y(l1, l2, h1, h2, K()); } template < class K > inline Comparison_result compare_xy(const Point_2 &p, const Point_2 &q) { return CGALi::compare_xy(p, q, K()); } template < class K > inline Comparison_result compare_y(const Point_2 &p, const Point_2 &q) { return CGALi::compare_y(p, q, K()); } template < class K > inline Comparison_result compare_y(const Point_2 &p, const Line_2 &l1, const Line_2 &l2) { return CGALi::compare_y(p, l1, l2, K()); } template < class K > inline Comparison_result compare_y(const Line_2 &l1, const Line_2 &l2, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_y(l1, l2, h1, h2, K()); } template < class K > inline Comparison_result compare_y(const Line_2 &l, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_y(l, h1, h2, K()); } template < class K > inline Comparison_result compare_y_at_x(const Point_2 &p, const Segment_2 &s) { return CGALi::compare_y_at_x(p, s, K()); } template < class K > inline Comparison_result compare_y_at_x(const Point_2 &p, const Segment_2 &s1, const Segment_2 &s2) { return CGALi::compare_y_at_x(p, s1, s2, K()); } template < class K > inline Comparison_result compare_y_at_x(const Point_2 &p, const Line_2 &h) { return CGALi::compare_y_at_x(p, h, K()); } template < class K > inline Comparison_result compare_y_at_x(const Point_2 &p, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_y_at_x(p, h1, h2, K()); } template < class K > inline Comparison_result compare_y_at_x(const Line_2 &l1, const Line_2 &l2, const Line_2 &h) { return CGALi::compare_y_at_x(l1, l2, h, K()); } template < class K > inline Comparison_result compare_y_at_x(const Line_2 &l1, const Line_2 &l2, const Line_2 &h1, const Line_2 &h2) { return CGALi::compare_y_at_x(l1, l2, h1, h2, K()); } template inline bool has_larger_distance_to_point(const Point_2& p, const Point_2& q, const Point_2& r) { return CGALi::has_larger_distance_to_point(p, q, r, K()); } template inline bool has_smaller_distance_to_point(const Point_2& p, const Point_2& q, const Point_2& r) { return CGALi::has_smaller_distance_to_point(p, q, r, K()); } template inline bool has_smaller_signed_distance_to_line(const Line_2& l, const Point_2& p, const Point_2& q) { return CGALi::has_smaller_signed_distance_to_line(l, p, q, K()); } template inline bool has_larger_signed_distance_to_line(const Line_2& l, const Point_2& p, const Point_2& q) { return CGALi::has_larger_signed_distance_to_line(l, p, q, K()); } template inline bool has_larger_signed_distance_to_line(const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& s) { return CGALi::has_larger_signed_distance_to_line(p, q, r, s, K()); } template inline bool has_smaller_signed_distance_to_line(const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& s) { return CGALi::has_smaller_signed_distance_to_line(p, q, r, s, K()); } template < class K > inline bool left_turn(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::left_turn(p, q, r, K()); } template < class K > inline bool less_x(const Point_2 &p, const Point_2 &q) { return CGALi::less_x(p, q, K()); } template < class K > inline bool less_y(const Point_2 &p, const Point_2 &q) { return CGALi::less_y(p, q, K()); } template < class K > inline bool lexicographically_xy_larger(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_xy_larger(p, q, K()); } template < class K > inline bool lexicographically_xy_larger_or_equal(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_xy_larger_or_equal(p, q, K()); } template < class K > inline bool lexicographically_xy_smaller(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_xy_smaller(p, q, K()); } template < class K > inline bool lexicographically_xy_smaller_or_equal(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_xy_smaller_or_equal(p, q, K()); } template < class K > inline bool lexicographically_yx_smaller(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_yx_smaller(p, q, K()); } template < class K > inline bool lexicographically_yx_smaller_or_equal(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_yx_smaller_or_equal(p, q, K()); } // FIXME : Undocumented template < class K > inline bool lexicographically_yx_larger(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_yx_larger(p, q, K()); } // FIXME : Undocumented template < class K > inline bool lexicographically_yx_larger_or_equal(const Point_2 &p, const Point_2 &q) { return CGALi::lexicographically_yx_larger_or_equal(p, q, K()); } template < class K > inline typename K::Point_2 midpoint(const Point_2 &p, const Point_2 &q) { return CGALi::midpoint(p, q, K()); } template < class K > inline typename K::Point_2 max_vertex(const Iso_rectangle_2 &ir) { return CGALi::max_vertex(ir, K()); } template < class K > inline typename K::Point_2 min_vertex(const Iso_rectangle_2 &ir) { return CGALi::min_vertex(ir, K()); } // FIXME TODO : What do we do with the operators ? // They have no counter part with the kernel argument... template < class K > inline bool operator<(const Direction_2& d1, const Direction_2& d2) { return compare_angle_with_x_axis(d1, d2) == SMALLER; } template < class K > inline bool operator>(const Direction_2& d1, const Direction_2& d2) { return compare_angle_with_x_axis(d1, d2) == LARGER; } template < class K > inline bool operator>=(const Direction_2& d1, const Direction_2& d2) { return compare_angle_with_x_axis(d1, d2) != SMALLER; } template < class K > inline bool operator<=(const Direction_2& d1, const Direction_2& d2) { return compare_angle_with_x_axis(d1, d2) != LARGER; } template < class K > inline bool operator==(const Point_2& p, const Point_2& q) { return K().equal_2_object()(p, q); } template < class K > inline bool operator!=(const Point_2& p, const Point_2& q) { return ! (p == q); } template < class K > inline bool operator<(const Point_2& p, const Point_2& q) { return K().less_xy_2_object()(p, q); } template < class K > inline bool operator>(const Point_2& p, const Point_2& q) { return K().less_xy_2_object()(q, p); } template < class K > inline bool operator<=(const Point_2& p, const Point_2& q) { return ! K().less_xy_2_object()(q, p); } template < class K > inline bool operator>=(const Point_2& p, const Point_2& q) { return ! K().less_xy_2_object()(p, q); } template < class K > inline typename K::Vector_2 operator*(const typename CGAL_WRAP(K)::FT &c, const Vector_2 &w) { return K().construct_scaled_vector_2_object()(w, c); } template < class K > inline typename K::Vector_2 operator*(const Vector_2 &w, const typename CGAL_WRAP(K)::FT &c) { return K().construct_scaled_vector_2_object()(w, c); } template < class K > inline typename K::Vector_2 operator*(const typename First_if_different::Type &c, const Vector_2 &w) { return K().construct_scaled_vector_2_object()(w, c); } template < class K > inline typename K::Vector_2 operator*(const Vector_2 &w, const typename First_if_different::Type &c) { return K().construct_scaled_vector_2_object()(w, c); } template < class K > inline typename K::FT operator*(const Vector_2 &v, const Vector_2 &w) { return K().compute_scalar_product_2_object()(v, w); } template < class K > inline typename K::Point_2 operator+(const Point_2 &p, const Vector_2 &v) { return K().construct_translated_point_2_object()(p, v); } template < class K > inline typename K::Point_2 operator+(const Origin &o, const Vector_2 &v) { return K().construct_translated_point_2_object()(o, v); } template < class K > inline typename K::Point_2 operator-(const Point_2 &p, const Vector_2 &v) { return K().construct_translated_point_2_object() (p, K().construct_opposite_vector_2_object()(v)); } template < class K > inline typename K::Point_2 operator-(const Origin &o, const Vector_2 &v) { return K().construct_translated_point_2_object() (o, K().construct_opposite_vector_2_object()(v)); } template < class K > inline typename K::Vector_2 operator-(const Point_2 &p, const Point_2 &q) { return K().construct_vector_2_object()(q, p); } template < class K > inline typename K::Vector_2 operator-(const Point_2 &p, const Origin &o) { return K().construct_vector_2_object()(o, p); } template < class K > inline typename K::Vector_2 operator-(const Origin &o, const Point_2 &q) { return K().construct_vector_2_object()(q, o); } template inline Orientation orientation(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::orientation(p, q, r, K()); } // parallel() functions are in global_functions.h template inline bool right_turn(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::right_turn(p, q, r, K()); } template inline Bounded_side side_of_bounded_circle(const Point_2 &p, const Point_2 &q, const Point_2 &r, const Point_2 &t) { return CGALi::side_of_bounded_circle(p, q, r, t, K()); } template inline Bounded_side side_of_bounded_circle(const Point_2 &p, const Point_2 &q, const Point_2 &r) { return CGALi::side_of_bounded_circle(p, q, r, K()); } template inline Oriented_side side_of_oriented_circle(const Point_2 &p, const Point_2 &q, const Point_2 &r, const Point_2 &t) { return CGALi::side_of_oriented_circle(p, q, r, t, K()); } template < class K > inline typename K::FT squared_radius(const Point_2 &p, const Point_2 &q) { return CGALi::squared_radius(p, q, K()); } template < class K > CGAL_KERNEL_INLINE typename K::FT squared_radius(const Point_2& p, const Point_2& q, const Point_2& r) { return CGALi::squared_radius(p, q, r, K()); } template < class K > inline bool x_equal(const Point_2 &p, const Point_2 &q) { return CGALi::x_equal(p, q, K()); } template < class K > inline bool y_equal(const Point_2 &p, const Point_2 &q) { return CGALi::y_equal(p, q, K()); } CGAL_END_NAMESPACE #endif // CGAL_KERNEL_GLOBAL_FUNCTIONS_2_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Cartesian_coordinate_iterator_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Cartesian_coord0000644000175000017500000000620311344301501031264 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/Cartesian_coordinate_iterator_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_CARTESIAN_COORDINATE_ITERATOR_3_H #define CGAL_CARTESIAN_COORDINATE_ITERATOR_3_H #include #include CGAL_BEGIN_NAMESPACE template class Cartesian_coordinate_iterator_3 { typedef typename K::Point_3 P; const P* point; int index; typedef Cartesian_coordinate_iterator_3 Self; public: typedef typename K::FT FT; typedef P Point; typedef std::random_access_iterator_tag iterator_category; typedef FT value_type; typedef std::ptrdiff_t difference_type; typedef const value_type& reference; typedef const value_type* pointer; Cartesian_coordinate_iterator_3(const Point *const p = NULL, int _index = 0) : point(p), index(_index) {} const FT operator*() const { return point->cartesian(index); } Self& operator++() { index++; return *this; } Self& operator--() { index--; return *this; } Self operator++(int) { Self tmp(*this); ++(*this); return tmp; } Self operator--(int) { Self tmp(*this); --(*this); return tmp; } Self& operator+=(difference_type i) { index+=i; return *this; } Self& operator-=(difference_type i) { index -= i; return *this; } Self operator+(difference_type i) const { Self tmp=*this; return tmp += i; } Self operator-(difference_type i) const { Self tmp=*this; return tmp -= i; } difference_type operator-(const Self& x) const { CGAL_kernel_assertion(point == x.point); return index - x.index; } reference operator[](difference_type i) const { return *(*this + i); } bool operator==(const Self& x) const { return (point == x.point)&& (index == x.index) ; } bool operator!=(const Self& x) const { return ! (*this==x); } bool operator<(const Self& x) const { return (x - *this) > 0; } }; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_COORDINATE_ITERATOR_3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/function_objects.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/function_object0000644000175000017500000015045311344301501031347 0ustar debiandebian// Copyright (c) 1999,2002 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/function_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion #ifndef CGAL_KERNEL_FUNCTION_OBJECTS_H #define CGAL_KERNEL_FUNCTION_OBJECTS_H #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CommonKernelFunctors { template class Are_ordered_along_line_2 { typedef typename K::Point_2 Point_2; typedef typename K::Collinear_2 Collinear_2; typedef typename K::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; Collinear_2 c; Collinear_are_ordered_along_line_2 cao; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Are_ordered_along_line_2() {} Are_ordered_along_line_2(const Collinear_2& c_, const Collinear_are_ordered_along_line_2& cao_) : c(c_), cao(cao_) {} bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return c(p, q, r) && cao(p, q, r); } }; template class Are_ordered_along_line_3 { typedef typename K::Point_3 Point_3; typedef typename K::Collinear_3 Collinear_3; typedef typename K::Collinear_are_ordered_along_line_3 Collinear_are_ordered_along_line_3; Collinear_3 c; Collinear_are_ordered_along_line_3 cao; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Are_ordered_along_line_3() {} Are_ordered_along_line_3(const Collinear_3& c_, const Collinear_are_ordered_along_line_3& cao_) : c(c_), cao(cao_) {} bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return c(p, q, r) && cao(p, q, r); } }; template class Are_strictly_ordered_along_line_2 { typedef typename K::Point_2 Point_2; typedef typename K::Collinear_2 Collinear_2; typedef typename K::Collinear_are_strictly_ordered_along_line_2 Collinear_are_strictly_ordered_along_line_2; Collinear_2 c; Collinear_are_strictly_ordered_along_line_2 cao; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Are_strictly_ordered_along_line_2() {} Are_strictly_ordered_along_line_2( const Collinear_2& c_, const Collinear_are_strictly_ordered_along_line_2& cao_) : c(c_), cao(cao_) {} bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return c(p, q, r) && cao(p, q, r); } }; template class Are_strictly_ordered_along_line_3 { typedef typename K::Point_3 Point_3; typedef typename K::Collinear_3 Collinear_3; typedef typename K::Collinear_are_strictly_ordered_along_line_3 Collinear_are_strictly_ordered_along_line_3; Collinear_3 c; Collinear_are_strictly_ordered_along_line_3 cao; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Are_strictly_ordered_along_line_3() {} Are_strictly_ordered_along_line_3( const Collinear_3& c_, const Collinear_are_strictly_ordered_along_line_3& cao_) : c(c_), cao(cao_) {} bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return c(p, q, r) && cao(p, q, r); } }; template class Assign_2 { typedef typename K::Object_2 Object_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; template bool operator()(T& t, const Object_2& o) const { return assign(t, o); } }; template class Assign_3 { typedef typename K::Object_3 Object_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; template bool operator()(T& t, const Object_3& o) const { return assign(t, o); } }; template class Bounded_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Bounded_side result_type; typedef Arity_tag< 2 > Arity; Bounded_side operator()( const Circle_2& c, const Point_2& p) const { return c.bounded_side(p); } Bounded_side operator()( const Triangle_2& t, const Point_2& p) const { return t.bounded_side(p); } Bounded_side operator()( const Iso_rectangle_2& r, const Point_2& p) const { return r.bounded_side(p); } }; template class Compute_area_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Triangle_3 Triangle_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Triangle_3& t ) const { return CGAL_NTS sqrt(K().compute_squared_area_3_object()(t)); } FT operator()( const Point_3& p, const Point_3& q, const Point_3& r ) const { return CGAL_NTS sqrt(K().compute_squared_area_3_object()(p, q, r)); } }; template class Compute_squared_distance_2 { typedef typename K::FT FT; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; // There are 25 combinaisons, we use a template. template FT operator()( const T1& t1, const T2& t2) const { return CGALi::squared_distance(t1, t2, K()); } }; template class Compute_squared_distance_3 { typedef typename K::FT FT; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; // There are 25 combinaisons, we use a template. template FT operator()( const T1& t1, const T2& t2) const { return CGALi::squared_distance(t1, t2, K()); } }; template class Compute_squared_length_2 { typedef typename K::FT FT; typedef typename K::Segment_2 Segment_2; typedef typename K::Vector_2 Vector_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Vector_2& v) const { return v.squared_length(); } FT operator()( const Segment_2& s) const { return s.squared_length(); } }; template class Compute_squared_length_3 { typedef typename K::FT FT; typedef typename K::Segment_3 Segment_3; typedef typename K::Vector_3 Vector_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Vector_3& v) const { return v.squared_length(); } FT operator()( const Segment_3& s) const { return s.squared_length(); } }; template class Construct_center_2 { typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()(const Circle_2& c) const { return c.center(); } }; template class Construct_center_3 { typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()(const Sphere_3& s) const { return s.center(); } }; template class Construct_circle_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef Circle_2 result_type; typedef Arity_tag< 3 > Arity; Circle_2 operator()() const { return Circle_2(); } Circle_2 operator()( const Point_2& center, const FT& squared_radius, Orientation orientation = COUNTERCLOCKWISE) const { return Circle_2(center, squared_radius, orientation); } Circle_2 operator()( const Point_2& p, const Point_2& q, const Point_2& r) const { return Circle_2(p, q, r); } Circle_2 operator()( const Point_2& p, const Point_2& q, Orientation orientation = COUNTERCLOCKWISE) const { return Circle_2(p, q, orientation); } Circle_2 operator()( const Point_2& center, Orientation orientation = COUNTERCLOCKWISE) const { return Circle_2(center, orientation); } }; template class Construct_direction_2 { typedef typename K::Direction_2 Direction_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; typedef typename K::RT RT; public: typedef Direction_2 result_type; typedef Arity_tag< 1 > Arity; Direction_2 operator()() const { return Direction_2(); } #ifndef CGAL_NO_DEPRECATED_CODE Direction_2 operator()(const RT& x, const RT& y) const { return Direction_2(x, y); } #endif // CGAL_NO_DEPRECATED_CODE Direction_2 operator()(const Vector_2& v) const { return Direction_2(v); } Direction_2 operator()(const Line_2& l) const { return Direction_2(l); } Direction_2 operator()(const Ray_2& r) const { return Direction_2(r); } Direction_2 operator()(const Segment_2& s) const { return Direction_2(s); } }; template class Construct_direction_3 { typedef typename K::Direction_3 Direction_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::RT RT; public: typedef Direction_3 result_type; typedef Arity_tag< 1 > Arity; Direction_3 operator()() const { return Direction_3(); } #ifndef CGAL_NO_DEPRECATED_CODE Direction_3 operator()(const RT& x, const RT& y, const RT& z) const { return Direction_3(x, y, z); } #endif // CGAL_NO_DEPRECATED_CODE Direction_3 operator()(const Vector_3& v) const { return Direction_3(v); } Direction_3 operator()(const Line_3& l) const { return Direction_3(l); } Direction_3 operator()(const Ray_3& r) const { return Direction_3(r); } Direction_3 operator()(const Segment_3& s) const { return Direction_3(s); } }; template class Construct_iso_cuboid_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Iso_cuboid_3 result_type; typedef Arity_tag< 2 > Arity; Iso_cuboid_3 operator()() const { return Iso_cuboid_3(); } Iso_cuboid_3 operator()(const Point_3& p, const Point_3& q) const { return Iso_cuboid_3(p, q); } Iso_cuboid_3 operator()(const Point_3 &left, const Point_3 &right, const Point_3 &bottom, const Point_3 &top, const Point_3 &far_, const Point_3 &close) const { return Iso_cuboid_3(left, right, bottom, top, far_, close); } }; template class Construct_iso_rectangle_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Iso_rectangle_2 result_type; typedef Arity_tag< 2 > Arity; Iso_rectangle_2 operator()() const { return Iso_rectangle_2(); } Iso_rectangle_2 operator()(const Point_2& p, const Point_2& q) const { return Iso_rectangle_2(p, q); } Iso_rectangle_2 operator()(const Point_2 &left, const Point_2 &right, const Point_2 &bottom, const Point_2 &top) const { return Iso_rectangle_2(left, right, bottom, top); } }; template class Construct_max_vertex_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()(const Iso_rectangle_2& r) const { return r.max(); } }; template class Construct_min_vertex_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()(const Iso_rectangle_2& r) const { return r.min(); } }; template class Construct_max_vertex_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()(const Iso_cuboid_3& r) const { return r.max(); } }; template class Construct_min_vertex_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()(const Iso_cuboid_3& r) const { return r.min(); } }; template class Construct_object_2 { typedef typename K::Object_2 Object_2; public: typedef Object_2 result_type; typedef Arity_tag< 1 > Arity; template Object_2 operator()( const Cls& c) const { return make_object(c); } }; template class Construct_object_3 { typedef typename K::Object_3 Object_3; public: typedef Object_3 result_type; typedef Arity_tag< 1 > Arity; template Object_3 operator()( const Cls& c) const { return make_object(c); } }; template class Construct_opposite_circle_2 { typedef typename K::Circle_2 Circle_2; public: typedef Circle_2 result_type; typedef Arity_tag< 1 > Arity; Circle_2 operator()( const Circle_2& c) const { return c.opposite(); } }; template class Construct_opposite_direction_2 { typedef typename K::Direction_2 Direction_2; public: typedef Direction_2 result_type; typedef Arity_tag< 1 > Arity; Direction_2 operator()( const Direction_2& d) const { return -d; } }; template class Construct_opposite_direction_3 { typedef typename K::Direction_3 Direction_3; public: typedef Direction_3 result_type; typedef Arity_tag< 1 > Arity; Direction_3 operator()( const Direction_3& d) const { return -d; } }; template class Construct_opposite_line_2 { typedef typename K::Line_2 Line_2; public: typedef Line_2 result_type; typedef Arity_tag< 1 > Arity; Line_2 operator()( const Line_2& l) const { return l.opposite(); } }; template class Construct_opposite_line_3 { typedef typename K::Line_3 Line_3; public: typedef Line_3 result_type; typedef Arity_tag< 1 > Arity; Line_3 operator()( const Line_3& l) const { return l.opposite(); } }; template class Construct_opposite_plane_3 { typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 1 > Arity; Plane_3 operator()( const Plane_3& p) const { return p.opposite(); } }; template class Construct_opposite_ray_2 { typedef typename K::Ray_2 Ray_2; public: typedef Ray_2 result_type; typedef Arity_tag< 1 > Arity; Ray_2 operator()( const Ray_2& r) const { return r.opposite(); } }; template class Construct_opposite_ray_3 { typedef typename K::Ray_3 Ray_3; public: typedef Ray_3 result_type; typedef Arity_tag< 1 > Arity; Ray_3 operator()( const Ray_3& r) const { return r.opposite(); } }; template class Construct_opposite_segment_2 { typedef typename K::Segment_2 Segment_2; public: typedef Segment_2 result_type; typedef Arity_tag< 1 > Arity; Segment_2 operator()( const Segment_2& s) const { return s.opposite(); } }; template class Construct_opposite_segment_3 { typedef typename K::Segment_3 Segment_3; public: typedef Segment_3 result_type; typedef Arity_tag< 1 > Arity; Segment_3 operator()( const Segment_3& s) const { return s.opposite(); } }; template class Construct_opposite_sphere_3 { typedef typename K::Sphere_3 Sphere_3; public: typedef Sphere_3 result_type; typedef Arity_tag< 1 > Arity; Sphere_3 operator()( const Sphere_3& s) const { return s.opposite(); } }; template class Construct_opposite_triangle_2 { typedef typename K::Triangle_2 Triangle_2; public: typedef Triangle_2 result_type; typedef Arity_tag< 1 > Arity; Triangle_2 operator()( const Triangle_2& t) const { return t.opposite(); } }; template class Construct_perpendicular_direction_2 { typedef typename K::Direction_2 Direction_2; public: typedef Direction_2 result_type; typedef Arity_tag< 2 > Arity; Direction_2 operator()( const Direction_2& d, Orientation o) const { return d.perpendicular(o); } }; template class Construct_perpendicular_line_2 { typedef typename K::Line_2 Line_2; typedef typename K::Point_2 Point_2; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Line_2 operator()( const Line_2& l, const Point_2& p) const { return l.perpendicular(p); } }; template class Construct_perpendicular_line_3 { typedef typename K::Line_3 Line_3; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Line_3 result_type; typedef Arity_tag< 2 > Arity; Line_3 operator()( const Plane_3& pl, const Point_3& p) const { return pl.perpendicular_line(p); } }; template class Construct_perpendicular_plane_3 { typedef typename K::Line_3 Line_3; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()( const Line_3& l, const Point_3& p) const { return l.perpendicular_plane(p); } }; template class Construct_perpendicular_vector_2 { typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()( const Vector_2& v, Orientation o) const { return v.perpendicular(o); } }; template class Construct_plane_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()() const { return Plane_3(); } Plane_3 operator()(const RT& a, const RT& b, const RT& c, const RT& d) const { return Plane_3(a, b, c, d); } Plane_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return Plane_3(p, q, r); } Plane_3 operator()(const Point_3& p, const Direction_3& d) const { return Plane_3(p, d); } Plane_3 operator()(const Point_3& p, const Vector_3& v) const { return Plane_3(p, v); } Plane_3 operator()(const Line_3& l, const Point_3& p) const { return Plane_3(l, p); } Plane_3 operator()(const Ray_3& r, const Point_3& p) const { return Plane_3(r, p); } Plane_3 operator()(const Segment_3& s, const Point_3& p) const { return Plane_3(s, p); } }; template class Construct_point_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Line_2& l, int i) const { return l.point(i); } Point_2 operator()( const Segment_2& s, int i) const { return s.point(i); } Point_2 operator()( const Ray_2& r, int i) const { return r.point(i); } }; template class Construct_point_on_3 { typedef typename K::Point_3 Point_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Line_3& l, int i) const { return l.point(i); } Point_3 operator()( const Segment_3& s, int i) const { return s.point(i); } Point_3 operator()( const Ray_3& r, int i) const { return r.point(i); } Point_3 operator()( const Plane_3& p) const { return p.point(); } }; template class Construct_point_2 { typedef typename K::RT RT; typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 1 > Arity; Point_2 operator()() const { return Point_2(); } Point_2 operator()(Origin o) const { return Point_2(o); } // Reactivated, as some functors in Cartesian/function_objects.h // need it for constructions //#ifndef CGAL_NO_DEPRECATED_CODE Point_2 operator()(const RT& x, const RT& y) const { return Point_2(x, y); } Point_2 operator()(const RT& x, const RT& y, const RT& w) const { return Point_2(x, y, w); } //#endif // CGAL_NO_DEPRECATED_CODE }; template class Construct_point_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 1 > Arity; Point_3 operator()() const { return Point_3(); } Point_3 operator()(Origin o) const { return Point_3(o); } // Reactivated, as some functors in Cartesian/function_objects.h // need it for constructions //#ifndef CGAL_NO_DEPRECATED_CODE Point_3 operator()(const RT& x, const RT& y, const RT& z) const { return Point_3(x, y, z); } Point_3 operator()(const RT& x, const RT& y, const RT& z, const RT& w) const { return Point_3(x, y, z, w); } //#endif // CGAL_NO_DEPRECATED_CODE }; template class Construct_projected_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Line_2& l, const Point_2& p ) const { return l.projection(p); } }; template class Construct_projected_xy_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Plane_3& h, const Point_3& p) const { return h.to_2d(p); } }; template class Construct_ray_2 { typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Direction_2 Direction_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; public: typedef Ray_2 result_type; typedef Arity_tag< 2 > Arity; Ray_2 operator()() const { return Ray_2(); } Ray_2 operator()(const Point_2& p, const Point_2& q) const { return Ray_2(p, q); } Ray_2 operator()(const Point_2& p, const Vector_2& v) const { return Ray_2(p, v); } Ray_2 operator()(const Point_2& p, const Direction_2& d) const { return Ray_2(p, d); } Ray_2 operator()(const Point_2& p, const Line_2& l) const { return Ray_2(p, l); } }; template class Construct_ray_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Direction_3 Direction_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; public: typedef Ray_3 result_type; typedef Arity_tag< 2 > Arity; Ray_3 operator()() const { return Ray_3(); } Ray_3 operator()(const Point_3& p, const Point_3& q) const { return Ray_3(p, q); } Ray_3 operator()(const Point_3& p, const Vector_3& v) const { return Ray_3(p, v); } Ray_3 operator()(const Point_3& p, const Direction_3& d) const { return Ray_3(p, d); } Ray_3 operator()(const Point_3& p, const Line_3& l) const { return Ray_3(p, l); } }; template class Construct_segment_2 { typedef typename K::Segment_2 Segment_2; typedef typename K::Point_2 Point_2; public: typedef Segment_2 result_type; typedef Arity_tag< 2 > Arity; Segment_2 operator()() const { return Segment_2(); } Segment_2 operator()( const Point_2& p, const Point_2& q) const { return Segment_2(p, q); } }; template class Construct_segment_3 { typedef typename K::Segment_3 Segment_3; typedef typename K::Point_3 Point_3; public: typedef Segment_3 result_type; typedef Arity_tag< 2 > Arity; Segment_3 operator()() const { return Segment_3(); } Segment_3 operator()( const Point_3& p, const Point_3& q) const { return Segment_3(p, q); } }; template class Construct_sphere_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Sphere_3 result_type; typedef Arity_tag< 4 > Arity; Sphere_3 operator()() const { return Sphere_3(); } Sphere_3 operator()( const Point_3& center, const FT& squared_radius, Orientation orientation = COUNTERCLOCKWISE) const { return Sphere_3(center, squared_radius, orientation); } Sphere_3 operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { return Sphere_3(p, q, r, s); } Sphere_3 operator()( const Point_3& p, const Point_3& q, const Point_3& r, Orientation orientation = COUNTERCLOCKWISE) const { return Sphere_3(p, q, r, orientation); } Sphere_3 operator()( const Point_3& p, const Point_3& q, Orientation orientation = COUNTERCLOCKWISE) const { return Sphere_3(p, q, orientation); } Sphere_3 operator()( const Point_3& center, Orientation orientation = COUNTERCLOCKWISE) const { return Sphere_3(center, orientation); } }; #ifndef CGAL_NO_DEPRECATED_CODE template class Construct_supporting_line_2 { typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; public: typedef Line_2 result_type; typedef Arity_tag< 1 > Arity; Line_2 operator()( const Ray_2& r) const { return r.supporting_line(); } Line_2 operator()( const Segment_2& s) const { return s.supporting_line(); } }; template class Construct_supporting_line_3 { typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; public: typedef Line_3 result_type; typedef Arity_tag< 1 > Arity; Line_3 operator()( const Ray_3& r) const { return r.supporting_line(); } Line_3 operator()( const Segment_3& s) const { return s.supporting_line(); } }; #endif // CGAL_NO_DEPRECATED_CODE template class Construct_supporting_plane_3 { typedef typename K::Triangle_3 Triangle_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 1 > Arity; Plane_3 operator()( const Triangle_3& t) const { return t.supporting_plane(); } }; template class Construct_tetrahedron_3 { typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Point_3 Point_3; public: typedef Tetrahedron_3 result_type; typedef Arity_tag< 4 > Arity; Tetrahedron_3 operator()() const { return Tetrahedron_3(); } Tetrahedron_3 operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { return Tetrahedron_3(p, q, r, s); } }; template class Construct_triangle_2 { typedef typename K::Triangle_2 Triangle_2; typedef typename K::Point_2 Point_2; public: typedef Triangle_2 result_type; typedef Arity_tag< 3 > Arity; Triangle_2 operator()() const { return Triangle_2(); } Triangle_2 operator()( const Point_2& p, const Point_2& q, const Point_2& r) const { return Triangle_2(p, q, r); } }; template class Construct_triangle_3 { typedef typename K::Triangle_3 Triangle_3; typedef typename K::Point_3 Point_3; public: typedef Triangle_3 result_type; typedef Arity_tag< 3 > Arity; Triangle_3 operator()() const { return Triangle_3(); } Triangle_3 operator()( const Point_3& p, const Point_3& q, const Point_3& r) const { return Triangle_3(p, q, r); } }; template class Construct_vertex_2 { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; const Point_2 & operator()( const Segment_2& s, int i) const { return s.vertex(i); } const Point_2 & operator()( const Triangle_2& t, int i) const { return t.vertex(i); } const Point_2 operator()( const Iso_rectangle_2& r, int i) const { return r.vertex(i); } }; template class Construct_vertex_3 { typedef typename K::Point_3 Point_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; const Point_3 & operator()( const Segment_3& s, int i) const { return s.vertex(i); } const Point_3 & operator()( const Triangle_3& t, int i) const { return t.vertex(i); } const Point_3 operator()( const Iso_cuboid_3& r, int i) const { return r.vertex(i); } const Point_3 & operator()( const Tetrahedron_3& t, int i) const { return t.vertex(i); } }; template class Construct_bbox_2 { typedef typename K::Point_2 Point_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Circle_2 Circle_2; public: typedef Bbox_2 result_type; typedef Arity_tag< 1 > Arity; Bbox_2 operator()( const Point_2& p) const { return p.bbox(); } Bbox_2 operator()( const Segment_2& s) const { return s.bbox(); } Bbox_2 operator()( const Triangle_2& t) const { return t.bbox(); } Bbox_2 operator()( const Iso_rectangle_2& r) const { return r.bbox(); } Bbox_2 operator()( const Circle_2& c) const { return c.bbox(); } }; template class Construct_bbox_3 { typedef typename K::Point_3 Point_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Bbox_3 result_type; typedef Arity_tag< 1 > Arity; Bbox_3 operator()( const Point_3& p) const { return p.bbox(); } Bbox_3 operator()( const Segment_3& s) const { return s.bbox(); } Bbox_3 operator()( const Triangle_3& t) const { return t.bbox(); } Bbox_3 operator()( const Iso_cuboid_3& r) const { return r.bbox(); } Bbox_3 operator()( const Tetrahedron_3& t) const { return t.bbox(); } Bbox_3 operator()( const Sphere_3& s) const { return s.bbox(); } }; template class Construct_cartesian_const_iterator_2 { typedef typename K::Point_2 Point_2; typedef typename K::Cartesian_const_iterator_2 Cartesian_const_iterator_2; public: typedef Cartesian_const_iterator_2 result_type; typedef Arity_tag< 1 > Arity; Cartesian_const_iterator_2 operator()( const Point_2& p) const { return p.cartesian_begin(); } Cartesian_const_iterator_2 operator()( const Point_2& p, int) const { return p.cartesian_end(); } }; template class Construct_cartesian_const_iterator_3 { typedef typename K::Point_3 Point_3; typedef typename K::Cartesian_const_iterator_3 Cartesian_const_iterator_3; public: typedef Cartesian_const_iterator_3 result_type; typedef Arity_tag< 1 > Arity; Cartesian_const_iterator_3 operator()( const Point_3& p) const { return p.cartesian_begin(); } Cartesian_const_iterator_3 operator()( const Point_3& p, int) const { return p.cartesian_end(); } }; template class Coplanar_3 { typedef typename K::Point_3 Point_3; typedef typename K::Orientation_3 Orientation_3; Orientation_3 o; public: typedef bool result_type; typedef Arity_tag< 4 > Arity; Coplanar_3() {} Coplanar_3(const Orientation_3& o_) : o(o_) {} bool operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { return o(p, q, r, s) == COPLANAR; } }; template class Counterclockwise_in_between_2 { typedef typename K::Direction_2 Direction_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()( const Direction_2& p, const Direction_2& q, const Direction_2& r) const { if ( q < p) return ( p < r )||( r <= q ); else return ( p < r )&&( r <= q ); } }; template class Do_intersect_2 { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // There are 36 combinaisons, so I use a template. template bool operator()(const T1& t1, const T2& t2) const { return CGALi::do_intersect(t1, t2, K()); } }; template class Do_intersect_3 { public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // There are x combinaisons, so I use a template. template bool operator()(const T1& t1, const T2& t2) const { return CGALi::do_intersect(t1, t2, K()); } }; template class Equal_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // template to replace n different versions template bool operator()(const T& p, const T& q) const { return p == q; } // Point_2 is special case since the global operator== would recurse. bool operator()(const Point_2 &p, const Point_2 &q) const { return p.x() == q.x() && p.y() == q.y(); } }; template class Equal_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; // template to replace n different versions template bool operator()(const T& p, const T& q) const { return p == q; } // Point_3 is special case since the global operator== would recurse. bool operator()(const Point_3 &p, const Point_3 &q) const { return p.x() == q.x() && p.y() == q.y() && p.z() == q.z(); } }; template class Has_on_boundary_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2& c, const Point_2& p) const { return c.has_on_boundary(p); } bool operator()( const Triangle_2& t, const Point_2& p) const { return t.has_on_boundary(p); } bool operator()( const Iso_rectangle_2& r, const Point_2& p) const { return r.has_on_boundary(p); } }; template class Has_on_boundary_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Plane_3 Plane_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3& s, const Point_3& p) const { return s.has_on_boundary(p); } bool operator()( const Tetrahedron_3& t, const Point_3& p) const { return t.has_on_boundary(p); } bool operator()( const Iso_cuboid_3& c, const Point_3& p) const { return c.has_on_boundary(p); } }; template class Has_on_bounded_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2& c, const Point_2& p) const { return c.has_on_bounded_side(p); } bool operator()( const Triangle_2& t, const Point_2& p) const { return t.has_on_bounded_side(p); } bool operator()( const Iso_rectangle_2& r, const Point_2& p) const { return r.has_on_bounded_side(p); } }; template class Has_on_bounded_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3& s, const Point_3& p) const { return s.has_on_bounded_side(p); } bool operator()( const Tetrahedron_3& t, const Point_3& p) const { return t.has_on_bounded_side(p); } bool operator()( const Iso_cuboid_3& c, const Point_3& p) const { return c.has_on_bounded_side(p); } }; template class Has_on_negative_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2& c, const Point_2& p) const { return c.has_on_negative_side(p); } bool operator()( const Triangle_2& t, const Point_2& p) const { return t.has_on_negative_side(p); } bool operator()( const Line_2& l, const Point_2& p) const { return l.has_on_negative_side(p); } }; template class Has_on_negative_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3& s, const Point_3& p) const { return s.has_on_negative_side(p); } bool operator()( const Tetrahedron_3& t, const Point_3& p) const { return t.has_on_negative_side(p); } bool operator()( const Plane_3& pl, const Point_3& p) const { return pl.has_on_negative_side(p); } }; template class Has_on_positive_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2& c, const Point_2& p) const { return c.has_on_positive_side(p); } bool operator()( const Triangle_2& t, const Point_2& p) const { return t.has_on_positive_side(p); } bool operator()( const Line_2& l, const Point_2& p) const { return l.has_on_positive_side(p); } }; template class Has_on_positive_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3& s, const Point_3& p) const { return s.has_on_positive_side(p); } bool operator()( const Tetrahedron_3& t, const Point_3& p) const { return t.has_on_positive_side(p); } bool operator()( const Plane_3& pl, const Point_3& p) const { return pl.has_on_positive_side(p); } }; template class Has_on_unbounded_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Circle_2& c, const Point_2& p) const { return c.has_on_unbounded_side(p); } bool operator()( const Triangle_2& t, const Point_2& p) const { return t.has_on_unbounded_side(p); } bool operator()( const Iso_rectangle_2& r, const Point_2& p) const { return r.has_on_unbounded_side(p); } }; template class Has_on_unbounded_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Sphere_3& s, const Point_3& p) const { return s.has_on_unbounded_side(p); } bool operator()( const Tetrahedron_3& t, const Point_3& p) const { return t.has_on_unbounded_side(p); } bool operator()( const Iso_cuboid_3& c, const Point_3& p) const { return c.has_on_unbounded_side(p); } }; template class Has_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Line_2& l, const Point_2& p) const { return l.has_on(p); } bool operator()( const Ray_2& r, const Point_2& p) const { return r.has_on(p); } bool operator()( const Segment_2& s, const Point_2& p) const { return s.has_on(p); } }; template class Intersect_2 { typedef typename K::Object_2 Object_2; public: typedef Object_2 result_type; typedef Arity_tag< 2 > Arity; // 25 possibilities, so I keep the template. template Object_2 operator()(const T1& t1, const T2& t2) const { return CGALi::intersection(t1, t2, K()); } }; template class Intersect_3 { typedef typename K::Object_3 Object_3; typedef typename K::Plane_3 Plane_3; public: typedef Object_3 result_type; typedef Arity_tag< 2 > Arity; // n possibilities, so I keep the template. template Object_3 operator()(const T1& t1, const T2& t2) const { return CGALi::intersection(t1, t2, K() ); } Object_3 operator()(const Plane_3& pl1, const Plane_3& pl2, const Plane_3& pl3)const { return CGALi::intersection(pl1, pl2, pl3, K() ); } }; template class Is_degenerate_2 { typedef typename K::Circle_2 Circle_2; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Line_2 Line_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Triangle_2 Triangle_2; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Circle_2& c) const { return c.is_degenerate(); } bool operator()( const Iso_rectangle_2& r) const { return r.is_degenerate(); } bool operator()( const Line_2& l) const { return l.is_degenerate(); } bool operator()( const Ray_2& r) const { return r.is_degenerate(); } bool operator()( const Segment_2& s) const { return s.is_degenerate(); } bool operator()( const Triangle_2& t) const { return t.is_degenerate(); } }; template class Is_degenerate_3 { typedef typename K::Iso_cuboid_3 Iso_cuboid_3; typedef typename K::Line_3 Line_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Iso_cuboid_3& c) const { return c.is_degenerate(); } bool operator()( const Line_3& l) const { return l.is_degenerate(); } bool operator()( const Plane_3& pl) const { return pl.is_degenerate(); } bool operator()( const Ray_3& r) const { return r.is_degenerate(); } bool operator()( const Segment_3& s) const { return s.is_degenerate(); } bool operator()( const Sphere_3& s) const { return s.is_degenerate(); } bool operator()( const Triangle_3& t) const { return t.is_degenerate(); } bool operator()( const Tetrahedron_3& t) const { return t.is_degenerate(); } }; template class Is_horizontal_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Line_2& l) const { return l.is_horizontal(); } bool operator()( const Segment_2& s) const { return s.is_horizontal(); } bool operator()( const Ray_2& r) const { return r.is_horizontal(); } }; template class Is_vertical_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; public: typedef bool result_type; typedef Arity_tag< 1 > Arity; bool operator()( const Line_2& l) const { return l.is_vertical(); } bool operator()( const Segment_2& s) const { return s.is_vertical(); } bool operator()( const Ray_2& r) const { return r.is_vertical(); } }; template class Left_turn_2 { typedef typename K::Point_2 Point_2; typedef typename K::Orientation_2 Orientation_2; Orientation_2 o; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Left_turn_2() {} Left_turn_2(const Orientation_2& o_) : o(o_) {} bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return o(p, q, r) == LEFT_TURN; } }; template class Less_rotate_ccw_2 { typedef typename K::Point_2 Point_2; typedef typename K::Orientation_2 Orientation_2; typedef typename K::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; Orientation_2 o; Collinear_are_ordered_along_line_2 co; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Less_rotate_ccw_2() {} Less_rotate_ccw_2(const Orientation_2& o_, const Collinear_are_ordered_along_line_2& co_) : o(o_), co(co_) {} bool operator()(const Point_2& r, const Point_2& p, const Point_2& q) const { Orientation ori = o(r, p, q); if ( ori == LEFT_TURN ) return true; else if ( ori == RIGHT_TURN ) return false; else { if (p == r) return false; if (q == r) return true; if (p == q) return false; return co( r, q, p); } } }; template class Oriented_side_2 { typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; typedef typename K::Line_2 Line_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Oriented_side result_type; typedef Arity_tag< 2 > Arity; Oriented_side operator()( const Circle_2& c, const Point_2& p) const { return c.oriented_side(p); } Oriented_side operator()( const Line_2& l, const Point_2& p) const { return l.oriented_side(p); } Oriented_side operator()( const Triangle_2& t, const Point_2& p) const { return t.oriented_side(p); } }; template class Oriented_side_3 { typedef typename K::Point_3 Point_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Sphere_3 Sphere_3; public: typedef Oriented_side result_type; typedef Arity_tag< 2 > Arity; Oriented_side operator()( const Sphere_3& s, const Point_3& p) const { return s.oriented_side(p); } Oriented_side operator()( const Plane_3& pl, const Point_3& p) const { return pl.oriented_side(p); } Oriented_side operator()( const Tetrahedron_3& t, const Point_3& p) const { return t.oriented_side(p); } }; } // namespace CommonKernelFunctors CGAL_END_NAMESPACE #endif // CGAL_KERNEL_FUNCTION_OBJECTS_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/interface_macros.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/interface_macro0000644000175000017500000003370611344301501031316 0ustar debiandebian// Copyright (c) 2000-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/interface_macros.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Herve Bronnimann, Sylvain Pion, Susan Hert // This file is intentionally not protected against re-inclusion. // It's aimed at being included from within a kernel traits class, this // way we share more code. // It is the responsability of the including file to correctly set the 2 // macros CGAL_Kernel_pred and CGAL_Kernel_cons. // And they are #undefed at the end of this file. CGAL_Kernel_pred(Angle_2, angle_2_object) CGAL_Kernel_pred(Angle_3, angle_3_object) CGAL_Kernel_pred(Are_ordered_along_line_2, are_ordered_along_line_2_object) CGAL_Kernel_pred(Are_ordered_along_line_3, are_ordered_along_line_3_object) CGAL_Kernel_pred(Are_parallel_2, are_parallel_2_object) CGAL_Kernel_pred(Are_parallel_3, are_parallel_3_object) CGAL_Kernel_pred(Are_strictly_ordered_along_line_2, are_strictly_ordered_along_line_2_object) CGAL_Kernel_pred(Are_strictly_ordered_along_line_3, are_strictly_ordered_along_line_3_object) CGAL_Kernel_cons(Assign_2, assign_2_object) CGAL_Kernel_cons(Assign_3, assign_3_object) CGAL_Kernel_pred(Bounded_side_2, bounded_side_2_object) CGAL_Kernel_pred(Bounded_side_3, bounded_side_3_object) CGAL_Kernel_pred(Collinear_are_ordered_along_line_2, collinear_are_ordered_along_line_2_object) CGAL_Kernel_pred(Collinear_are_ordered_along_line_3, collinear_are_ordered_along_line_3_object) CGAL_Kernel_pred(Collinear_are_strictly_ordered_along_line_2, collinear_are_strictly_ordered_along_line_2_object) CGAL_Kernel_pred(Collinear_are_strictly_ordered_along_line_3, collinear_are_strictly_ordered_along_line_3_object) CGAL_Kernel_pred(Collinear_has_on_2, collinear_has_on_2_object) CGAL_Kernel_pred(Collinear_2, collinear_2_object) CGAL_Kernel_pred(Collinear_3, collinear_3_object) CGAL_Kernel_pred(Compare_angle_with_x_axis_2, compare_angle_with_x_axis_2_object) CGAL_Kernel_pred(Compare_distance_2, compare_distance_2_object) CGAL_Kernel_pred(Compare_distance_3, compare_distance_3_object) CGAL_Kernel_pred(Compare_slope_2, compare_slope_2_object) CGAL_Kernel_pred(Compare_x_at_y_2, compare_x_at_y_2_object) CGAL_Kernel_pred(Compare_xyz_3, compare_xyz_3_object) CGAL_Kernel_pred(Compare_xy_2, compare_xy_2_object) CGAL_Kernel_pred(Compare_xy_3, compare_xy_3_object) CGAL_Kernel_pred(Compare_x_2, compare_x_2_object) CGAL_Kernel_pred(Compare_x_3, compare_x_3_object) CGAL_Kernel_pred(Compare_y_at_x_2, compare_y_at_x_2_object) CGAL_Kernel_pred(Compare_y_2, compare_y_2_object) CGAL_Kernel_pred(Compare_y_3, compare_y_3_object) CGAL_Kernel_pred(Compare_z_3, compare_z_3_object) CGAL_Kernel_cons(Compute_area_2, compute_area_2_object) CGAL_Kernel_cons(Compute_area_3, compute_area_3_object) CGAL_Kernel_cons(Compute_scalar_product_2, compute_scalar_product_2_object) CGAL_Kernel_cons(Compute_scalar_product_3, compute_scalar_product_3_object) CGAL_Kernel_cons(Compute_squared_area_3, compute_squared_area_3_object) CGAL_Kernel_cons(Compute_squared_distance_2, compute_squared_distance_2_object) CGAL_Kernel_cons(Compute_squared_distance_3, compute_squared_distance_3_object) CGAL_Kernel_cons(Compute_squared_length_2, compute_squared_length_2_object) CGAL_Kernel_cons(Compute_squared_length_3, compute_squared_length_3_object) CGAL_Kernel_cons(Compute_squared_radius_2, compute_squared_radius_2_object) CGAL_Kernel_cons(Compute_squared_radius_3, compute_squared_radius_3_object) CGAL_Kernel_cons(Compute_volume_3, compute_volume_3_object) CGAL_Kernel_cons(Construct_base_vector_3, construct_base_vector_3_object) CGAL_Kernel_cons(Construct_bisector_2, construct_bisector_2_object) CGAL_Kernel_cons(Construct_bisector_3, construct_bisector_3_object) CGAL_Kernel_cons(Construct_center_2, construct_center_2_object) CGAL_Kernel_cons(Construct_center_3, construct_center_3_object) CGAL_Kernel_cons(Construct_centroid_2, construct_centroid_2_object) CGAL_Kernel_cons(Construct_centroid_3, construct_centroid_3_object) CGAL_Kernel_cons(Construct_circle_2, construct_circle_2_object) CGAL_Kernel_cons(Construct_circumcenter_2, construct_circumcenter_2_object) CGAL_Kernel_cons(Construct_circumcenter_3, construct_circumcenter_3_object) CGAL_Kernel_cons(Construct_cross_product_vector_3, construct_cross_product_vector_3_object) CGAL_Kernel_cons(Construct_direction_2, construct_direction_2_object) CGAL_Kernel_cons(Construct_direction_3, construct_direction_3_object) CGAL_Kernel_cons(Construct_iso_cuboid_3, construct_iso_cuboid_3_object) CGAL_Kernel_cons(Construct_iso_rectangle_2, construct_iso_rectangle_2_object) CGAL_Kernel_cons(Construct_lifted_point_3, construct_lifted_point_3_object) CGAL_Kernel_cons(Construct_line_2, construct_line_2_object) CGAL_Kernel_cons(Construct_line_3, construct_line_3_object) CGAL_Kernel_cons(Construct_midpoint_2, construct_midpoint_2_object) CGAL_Kernel_cons(Construct_midpoint_3, construct_midpoint_3_object) CGAL_Kernel_cons(Construct_min_vertex_2, construct_min_vertex_2_object) CGAL_Kernel_cons(Construct_max_vertex_2, construct_max_vertex_2_object) CGAL_Kernel_cons(Construct_min_vertex_3, construct_min_vertex_3_object) CGAL_Kernel_cons(Construct_max_vertex_3, construct_max_vertex_3_object) CGAL_Kernel_cons(Construct_object_2, construct_object_2_object) CGAL_Kernel_cons(Construct_object_3, construct_object_3_object) CGAL_Kernel_cons(Construct_opposite_circle_2, construct_opposite_circle_2_object) CGAL_Kernel_cons(Construct_opposite_direction_2, construct_opposite_direction_2_object) CGAL_Kernel_cons(Construct_opposite_direction_3, construct_opposite_direction_3_object) CGAL_Kernel_cons(Construct_opposite_line_2, construct_opposite_line_2_object) CGAL_Kernel_cons(Construct_opposite_line_3, construct_opposite_line_3_object) CGAL_Kernel_cons(Construct_opposite_plane_3, construct_opposite_plane_3_object) CGAL_Kernel_cons(Construct_opposite_ray_2, construct_opposite_ray_2_object) CGAL_Kernel_cons(Construct_opposite_ray_3, construct_opposite_ray_3_object) CGAL_Kernel_cons(Construct_opposite_segment_2, construct_opposite_segment_2_object) CGAL_Kernel_cons(Construct_opposite_segment_3, construct_opposite_segment_3_object) CGAL_Kernel_cons(Construct_opposite_sphere_3, construct_opposite_sphere_3_object) CGAL_Kernel_cons(Construct_opposite_triangle_2, construct_opposite_triangle_2_object) CGAL_Kernel_cons(Construct_opposite_vector_2, construct_opposite_vector_2_object) CGAL_Kernel_cons(Construct_opposite_vector_3, construct_opposite_vector_3_object) CGAL_Kernel_cons(Construct_orthogonal_vector_3, construct_orthogonal_vector_3_object) CGAL_Kernel_cons(Construct_perpendicular_direction_2, construct_perpendicular_direction_2_object) CGAL_Kernel_cons(Construct_perpendicular_line_2, construct_perpendicular_line_2_object) CGAL_Kernel_cons(Construct_perpendicular_line_3, construct_perpendicular_line_3_object) CGAL_Kernel_cons(Construct_perpendicular_plane_3, construct_perpendicular_plane_3_object) CGAL_Kernel_cons(Construct_perpendicular_vector_2, construct_perpendicular_vector_2_object) CGAL_Kernel_cons(Construct_plane_3, construct_plane_3_object) CGAL_Kernel_cons(Construct_point_on_2, construct_point_on_2_object) CGAL_Kernel_cons(Construct_point_on_3, construct_point_on_3_object) CGAL_Kernel_cons(Construct_point_2, construct_point_2_object) CGAL_Kernel_cons(Construct_point_3, construct_point_3_object) CGAL_Kernel_cons(Construct_projected_point_2, construct_projected_point_2_object) CGAL_Kernel_cons(Construct_projected_point_3, construct_projected_point_3_object) CGAL_Kernel_cons(Construct_projected_xy_point_2, construct_projected_xy_point_2_object) CGAL_Kernel_cons(Construct_ray_2, construct_ray_2_object) CGAL_Kernel_cons(Construct_ray_3, construct_ray_3_object) CGAL_Kernel_cons(Construct_scaled_vector_2, construct_scaled_vector_2_object) CGAL_Kernel_cons(Construct_scaled_vector_3, construct_scaled_vector_3_object) CGAL_Kernel_cons(Construct_segment_2, construct_segment_2_object) CGAL_Kernel_cons(Construct_segment_3, construct_segment_3_object) CGAL_Kernel_cons(Construct_sphere_3, construct_sphere_3_object) #ifndef CGAL_NO_DEPRECATED_CODE CGAL_Kernel_cons(Construct_supporting_line_2, construct_supporting_line_2_object) CGAL_Kernel_cons(Construct_supporting_line_3, construct_supporting_line_3_object) #endif // CGAL_NO_DEPRECATED_CODE CGAL_Kernel_cons(Construct_supporting_plane_3, construct_supporting_plane_3_object) CGAL_Kernel_cons(Construct_tetrahedron_3, construct_tetrahedron_3_object) CGAL_Kernel_cons(Construct_translated_point_2, construct_translated_point_2_object) CGAL_Kernel_cons(Construct_translated_point_3, construct_translated_point_3_object) CGAL_Kernel_cons(Construct_triangle_2, construct_triangle_2_object) CGAL_Kernel_cons(Construct_triangle_3, construct_triangle_3_object) CGAL_Kernel_cons(Construct_vector_2, construct_vector_2_object) CGAL_Kernel_cons(Construct_vector_3, construct_vector_3_object) CGAL_Kernel_cons(Construct_vertex_2, construct_vertex_2_object) CGAL_Kernel_cons(Construct_vertex_3, construct_vertex_3_object) CGAL_Kernel_cons(Construct_bbox_2, construct_bbox_2_object) CGAL_Kernel_cons(Construct_bbox_3, construct_bbox_3_object) CGAL_Kernel_cons(Construct_cartesian_const_iterator_2, construct_cartesian_const_iterator_2_object) CGAL_Kernel_cons(Construct_cartesian_const_iterator_3, construct_cartesian_const_iterator_3_object) CGAL_Kernel_pred(Coplanar_orientation_3, coplanar_orientation_3_object) CGAL_Kernel_pred(Coplanar_side_of_bounded_circle_3, coplanar_side_of_bounded_circle_3_object) CGAL_Kernel_pred(Coplanar_3, coplanar_3_object) CGAL_Kernel_pred(Counterclockwise_in_between_2, counterclockwise_in_between_2_object) CGAL_Kernel_pred(Do_intersect_2, do_intersect_2_object) CGAL_Kernel_cons(Do_intersect_3, do_intersect_3_object) CGAL_Kernel_pred(Equal_xy_3, equal_xy_3_object) CGAL_Kernel_pred(Equal_x_2, equal_x_2_object) CGAL_Kernel_pred(Equal_x_3, equal_x_3_object) CGAL_Kernel_pred(Equal_y_2, equal_y_2_object) CGAL_Kernel_pred(Equal_y_3, equal_y_3_object) CGAL_Kernel_pred(Equal_z_3, equal_z_3_object) CGAL_Kernel_pred(Equal_2, equal_2_object) CGAL_Kernel_pred(Equal_3, equal_3_object) CGAL_Kernel_pred(Has_on_boundary_2, has_on_boundary_2_object) CGAL_Kernel_pred(Has_on_boundary_3, has_on_boundary_3_object) CGAL_Kernel_pred(Has_on_bounded_side_2, has_on_bounded_side_2_object) CGAL_Kernel_pred(Has_on_bounded_side_3, has_on_bounded_side_3_object) CGAL_Kernel_pred(Has_on_negative_side_2, has_on_negative_side_2_object) CGAL_Kernel_pred(Has_on_negative_side_3, has_on_negative_side_3_object) CGAL_Kernel_pred(Has_on_positive_side_2, has_on_positive_side_2_object) CGAL_Kernel_pred(Has_on_positive_side_3, has_on_positive_side_3_object) CGAL_Kernel_pred(Has_on_unbounded_side_2, has_on_unbounded_side_2_object) CGAL_Kernel_pred(Has_on_unbounded_side_3, has_on_unbounded_side_3_object) CGAL_Kernel_pred(Has_on_2, has_on_2_object) CGAL_Kernel_pred(Has_on_3, has_on_3_object) CGAL_Kernel_cons(Intersect_2, intersect_2_object) CGAL_Kernel_cons(Intersect_3, intersect_3_object) CGAL_Kernel_pred(Is_degenerate_2, is_degenerate_2_object) CGAL_Kernel_pred(Is_degenerate_3, is_degenerate_3_object) CGAL_Kernel_pred(Is_horizontal_2, is_horizontal_2_object) CGAL_Kernel_pred(Is_vertical_2, is_vertical_2_object) CGAL_Kernel_pred(Left_turn_2, left_turn_2_object) CGAL_Kernel_pred(Less_distance_to_point_2, less_distance_to_point_2_object) CGAL_Kernel_pred(Less_distance_to_point_3, less_distance_to_point_3_object) CGAL_Kernel_pred(Less_rotate_ccw_2, less_rotate_ccw_2_object) CGAL_Kernel_pred(Less_signed_distance_to_line_2, less_signed_distance_to_line_2_object) CGAL_Kernel_pred(Less_signed_distance_to_plane_3, less_signed_distance_to_plane_3_object) CGAL_Kernel_pred(Less_xyz_3, less_xyz_3_object) CGAL_Kernel_pred(Less_xy_2, less_xy_2_object) CGAL_Kernel_pred(Less_xy_3, less_xy_3_object) CGAL_Kernel_pred(Less_x_2, less_x_2_object) CGAL_Kernel_pred(Less_x_3, less_x_3_object) CGAL_Kernel_pred(Less_yx_2, less_yx_2_object) CGAL_Kernel_pred(Less_y_2, less_y_2_object) CGAL_Kernel_pred(Less_y_3, less_y_3_object) CGAL_Kernel_pred(Less_z_3, less_z_3_object) CGAL_Kernel_pred(Orientation_2, orientation_2_object) CGAL_Kernel_pred(Orientation_3, orientation_3_object) CGAL_Kernel_pred(Oriented_side_2, oriented_side_2_object) CGAL_Kernel_pred(Oriented_side_3, oriented_side_3_object) CGAL_Kernel_pred(Side_of_bounded_circle_2, side_of_bounded_circle_2_object) CGAL_Kernel_pred(Side_of_bounded_sphere_3, side_of_bounded_sphere_3_object) CGAL_Kernel_pred(Side_of_oriented_circle_2, side_of_oriented_circle_2_object) CGAL_Kernel_pred(Side_of_oriented_sphere_3, side_of_oriented_sphere_3_object) #undef CGAL_Kernel_pred #undef CGAL_Kernel_cons ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_internal_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_function0000644000175000017500000005031511344301501031335 0ustar debiandebian// Copyright (c) 2003-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel/global_functions_internal_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_GLOBAL_FUNCTIONS_INTERNAL_2_H #define CGAL_KERNEL_GLOBAL_FUNCTIONS_INTERNAL_2_H // Generic functions calling the kernel functor, taking the kernel as // parameter. // These functions are not documented for now, but could be as some point. #include CGAL_BEGIN_NAMESPACE namespace CGALi { template < class K > inline Angle angle(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.angle_2_object()(p, q, r); } template < class K > inline bool are_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.are_ordered_along_line_2_object()(p, q, r); } template < class K > inline bool are_strictly_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.are_strictly_ordered_along_line_2_object()(p, q, r); } template < class K > inline typename K::FT area(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.compute_area_2_object()(p, q, r); } template inline typename K::Line_2 bisector(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K &k) { return k.construct_bisector_2_object()(p, q); } template inline typename K::Line_2 bisector(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const K &k) { return k.construct_bisector_2_object()(l1, l2); } template < class K > inline typename K::Point_2 centroid(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.construct_centroid_2_object()(p, q, r); } template < class K > inline typename K::Point_2 centroid(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const typename CGAL_WRAP(K)::Point_2 &s, const K& k) { return k.construct_centroid_2_object()(p, q, r, s); } template < class K > inline typename K::Point_2 circumcenter(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.construct_circumcenter_2_object()(p, q, r); } template < class K > inline typename K::Point_2 circumcenter(const typename CGAL_WRAP(K)::Triangle_2 &t, const K& k) { return k.construct_circumcenter_2_object()(t); } template < class K > inline bool collinear(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.collinear_2_object()(p, q, r); } template < class K > inline bool collinear_are_ordered_along_line(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.collinear_are_ordered_along_line_2_object()(p, q, r); } template < class K > inline bool collinear_are_strictly_ordered_along_line( const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.collinear_are_strictly_ordered_along_line_2_object()(p, q, r); } template < typename K > inline Comparison_result compare_angle_with_x_axis(const typename CGAL_WRAP(K)::Direction_2& d1, const typename CGAL_WRAP(K)::Direction_2& d2, const K& k) { return k.compare_angle_with_x_axis_2_object()(d1, d2); } template inline Comparison_result compare_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.compare_distance_2_object()(p, q, r); } template inline Comparison_result compare_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Point_2& q, const typename CGAL_WRAP(K)::Point_2& r, const typename CGAL_WRAP(K)::Point_2& s, const K& k) { if (k.less_signed_distance_to_line_2_object()(p, q, r, s)) return SMALLER; if (k.less_signed_distance_to_line_2_object()(p, q, s, r)) return LARGER; return EQUAL; } template inline Comparison_result compare_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l, const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Point_2& q, const K& k) { if (k.less_signed_distance_to_line_2_object()(l, p, q)) return SMALLER; if (k.less_signed_distance_to_line_2_object()(l, q, p)) return LARGER; return EQUAL; } template < class K > inline Comparison_result compare_slopes(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const K& k) { return k.compare_slope_2_object()(l1, l2); } template < class K > inline Comparison_result compare_slopes(const typename CGAL_WRAP(K)::Segment_2 &s1, const typename CGAL_WRAP(K)::Segment_2 &s2, const K& k) { return k.compare_slope_2_object()(s1, s2); } template < class K > inline Comparison_result compare_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.compare_x_2_object()(p, q); } template < class K > inline Comparison_result compare_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const K& k) { return k.compare_x_2_object()(p, l1, l2); } template < class K > inline Comparison_result compare_x(const typename CGAL_WRAP(K)::Line_2 &l, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_x_2_object()(l, h1, h2); } template < class K > inline Comparison_result compare_x(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &l2, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_x_2_object()(l1, h1, l2, h2); } template < class K > inline Comparison_result compare_x_at_y(const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Line_2& h, const K& k) { return k.compare_x_at_y_2_object()(p, h); } /* Undocumented template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Segment_2 &s, const K& k) { return k.compare_y_at_x_2_object()(p, s); } */ template < class K > inline Comparison_result compare_x_at_y(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_x_at_y_2_object()(p, h1, h2); } template < class K > inline Comparison_result compare_x_at_y(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const typename CGAL_WRAP(K)::Line_2 &h, const K& k) { return k.compare_x_at_y_2_object()(l1, l2, h); } template < class K > inline Comparison_result compare_x_at_y(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_x_at_y_2_object()(l1, l2, h1, h2); } template < class K > inline Comparison_result compare_xy(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.compare_xy_2_object()(p, q); } template < class K > inline Comparison_result compare_y(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.compare_y_2_object()(p, q); } template < class K > inline Comparison_result compare_y(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const K& k) { return k.compare_y_2_object()(p, l1, l2); } template < class K > inline Comparison_result compare_y(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_y_2_object()(l1, l2, h1, h2); } template < class K > inline Comparison_result compare_y(const typename CGAL_WRAP(K)::Line_2 &l, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_y_2_object()(l, h1, h2); } template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Segment_2 &s, const K& k) { return k.compare_y_at_x_2_object()(p, s); } template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Segment_2 &s1, const typename CGAL_WRAP(K)::Segment_2 &s2, const K& k) { return k.compare_y_at_x_2_object()(p, s1, s2); } template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Line_2 &l, const K& k) { return k.compare_y_at_x_2_object()(p, l); } template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_y_at_x_2_object()(p, h1, h2); } template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const typename CGAL_WRAP(K)::Line_2 &h, const K& k) { return k.compare_y_at_x_2_object()(l1, l2, h); } template < class K > inline Comparison_result compare_y_at_x(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const typename CGAL_WRAP(K)::Line_2 &h1, const typename CGAL_WRAP(K)::Line_2 &h2, const K& k) { return k.compare_y_at_x_2_object()(l1, l2, h1, h2); } template inline bool has_larger_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.less_distance_to_point_2_object()(p, r, q); } template inline bool has_smaller_distance_to_point(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.less_distance_to_point_2_object()(p, q, r); } template inline bool has_smaller_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l, const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Point_2& q, const K& k) { return k.less_signed_distance_to_line_2_object()(l, p, q); } template inline bool has_larger_signed_distance_to_line(const typename CGAL_WRAP(K)::Line_2& l, const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Point_2& q, const K& k) { return k.less_signed_distance_to_line_2_object()(l, q, p); } template inline bool has_larger_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Point_2& q, const typename CGAL_WRAP(K)::Point_2& r, const typename CGAL_WRAP(K)::Point_2& s, const K& k) { return k.less_signed_distance_to_line_2_object()(p, q, s, r); } template inline bool has_smaller_signed_distance_to_line(const typename CGAL_WRAP(K)::Point_2& p, const typename CGAL_WRAP(K)::Point_2& q, const typename CGAL_WRAP(K)::Point_2& r, const typename CGAL_WRAP(K)::Point_2& s, const K& k) { return k.less_signed_distance_to_line_2_object()(p, q, r, s); } template < class K > inline bool left_turn(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K& k) { return k.left_turn_2_object()(p, q, r); } template < class K > inline bool less_x(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.less_x_2_object()(p, q); } template < class K > inline bool less_y(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.less_y_2_object()(p, q); } template < class K > inline bool lexicographically_xy_larger(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.compare_xy_2_object()(p, q) == LARGER; } template < class K > inline bool lexicographically_xy_larger_or_equal(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.compare_xy_2_object()(p, q) != SMALLER; } template < class K > inline bool lexicographically_xy_smaller(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.less_xy_2_object()(p, q); } template < class K > inline bool lexicographically_xy_smaller_or_equal(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.compare_xy_2_object()(p, q) != LARGER; } template < class K > inline bool lexicographically_yx_smaller(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.less_yx_2_object()(p, q); } template < class K > inline bool lexicographically_yx_smaller_or_equal(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return !k.less_yx_2_object()(q, p); } // FIXME : Undocumented template < class K > inline bool lexicographically_yx_larger(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return k.less_yx_2_object()(q, p); } // FIXME : Undocumented template < class K > inline bool lexicographically_yx_larger_or_equal(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K& k) { return !k.less_yx_2_object()(p, q); } template < class K > inline typename K::Point_2 midpoint(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K &k) { return k.construct_midpoint_2_object()(p, q); } template < class K > inline typename K::Point_2 max_vertex(const typename CGAL_WRAP(K)::Iso_rectangle_2 &ir, const K &k) { return k.construct_max_vertex_2_object()(ir); } template < class K > inline typename K::Point_2 min_vertex(const typename CGAL_WRAP(K)::Iso_rectangle_2 &ir, const K &k) { return k.construct_min_vertex_2_object()(ir); } template inline Orientation orientation(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K &k) { return k.orientation_2_object()(p, q, r); } template inline bool parallel(const typename CGAL_WRAP(K)::Line_2 &l1, const typename CGAL_WRAP(K)::Line_2 &l2, const K &k) { return k.are_parallel_2_object()(l1, l2); } template inline bool parallel(const typename CGAL_WRAP(K)::Ray_2 &r1, const typename CGAL_WRAP(K)::Ray_2 &r2, const K &k) { return k.are_parallel_2_object()(r1, r2); } template inline bool parallel(const typename CGAL_WRAP(K)::Segment_2 &s1, const typename CGAL_WRAP(K)::Segment_2 &s2, const K &k) { return k.are_parallel_2_object()(s1, s2); } template inline bool right_turn(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K &k) { return CGALi::orientation(p, q, r, k) == RIGHT_TURN; } template inline Bounded_side side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const typename CGAL_WRAP(K)::Point_2 &t, const K &k) { return k.side_of_bounded_circle_2_object()(p, q, r, t); } template inline Bounded_side side_of_bounded_circle(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K &k) { return k.side_of_bounded_circle_2_object()(p, q, r); } template inline Oriented_side side_of_oriented_circle(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const typename CGAL_WRAP(K)::Point_2 &t, const K &k) { return k.side_of_oriented_circle_2_object()(p, q, r, t); } template < class K > inline typename K::FT squared_radius(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K &k) { return k.compute_squared_radius_2_object()(p, q); } template < class K > CGAL_KERNEL_INLINE typename K::FT squared_radius(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const typename CGAL_WRAP(K)::Point_2 &r, const K &k) { return k.compute_squared_radius_2_object()(p, q, r); } template < class K > inline bool x_equal(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K &k) { return k.equal_x_2_object()(p, q); } template < class K > inline bool y_equal(const typename CGAL_WRAP(K)::Point_2 &p, const typename CGAL_WRAP(K)::Point_2 &q, const K &k) { return k.equal_y_2_object()(p, q); } } // namespace CGALi CGAL_END_NAMESPACE #endif // CGAL_KERNEL_GLOBAL_FUNCTIONS_INTERNAL_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_2.C0000644000175000017500000014016211344301500030657 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_2.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_2_C #define CGAL_APOLLONIUS_GRAPH_2_C // class implementation continued //================================= CGAL_BEGIN_NAMESPACE //-------------------------------------------------------------------- // test method //-------------------------------------------------------------------- template bool Apollonius_graph_2:: is_valid(bool verbose, int level) const { if (level < 0) { return true; } if (number_of_vertices() <= 1) { return true; } // level 0 test: check the TDS bool result = this->_tds.is_valid(verbose, level); // bool result(true); // CGAL_assertion( result ); if ( result && verbose ) { std::cerr << "AGDS is ok... " << std::flush; } if (level == 0) { return result; } // level 1 test: do the incircle tests if (number_of_vertices() < 3) return true; // CGAL_triangulation_assertion(result); for (All_edges_iterator eit = all_edges_begin(); eit != all_edges_end(); ++eit) { Edge e = *eit; Face_handle f = e.first; Vertex_handle v = f->mirror_vertex(e.second); if ( f->vertex(e.second) == v ) { continue; } if ( !is_infinite(v) ) { result = result && ( incircle(f, v->site()) != NEGATIVE ); // CGAL_triangulation_assertion(result); } Edge sym_e = sym_edge(e); f = sym_e.first; v = f->mirror_vertex(sym_e.second); if ( !is_infinite(v) ) { result = result && ( incircle(f, v->site()) != NEGATIVE ); // CGAL_triangulation_assertion(result); } } if ( result && verbose ) { std::cerr << "Apollonius diagram is ok..." << std::flush; } if ( !result && verbose ) { std::cerr << "Apollonius diagram is NOT valid..." << std::flush; } // CGAL_triangulation_assertion(result); return result; } //-------------------------------------------------------------------- // embedding and visualization methods and constructions for primal // and dual //-------------------------------------------------------------------- // circumcenter template typename Apollonius_graph_2::Point_2 Apollonius_graph_2:: circumcenter(const Face_handle& f) const { CGAL_triangulation_precondition (dimension()==2 || !is_infinite(f)); return circumcenter(f->vertex(0)->site(), f->vertex(1)->site(), f->vertex(2)->site()); } template typename Apollonius_graph_2::Point_2 Apollonius_graph_2:: circumcenter(const Site_2& p0, const Site_2& p1, const Site_2& p2) const { return geom_traits().construct_Apollonius_vertex_2_object()(p0, p1, p2); } // circumcircle template typename Apollonius_graph_2::Site_2 Apollonius_graph_2:: circumcircle(const Face_handle& f) const { CGAL_triangulation_precondition (dimension()==2 || !is_infinite(f)); return circumcircle(f->vertex(0)->site(), f->vertex(1)->site(), f->vertex(2)->site()); } template typename Apollonius_graph_2::Site_2 Apollonius_graph_2:: circumcircle(const Site_2& p0, const Site_2& p1, const Site_2& p2) const { return geom_traits().construct_Apollonius_site_2_object()(p0, p1, p2); } template typename Gt::Line_2 Apollonius_graph_2:: circumcircle(const Site_2& p0, const Site_2& p1) const { return geom_traits().construct_Apollonius_site_2_object()(p0, p1); } // dual template typename Gt::Object_2 Apollonius_graph_2:: dual(const Face_handle& f) const { if ( !is_infinite(f) ) { Site_2 cc = circumcircle(f); return geom_traits().construct_object_2_object()(cc); } int i_inf(-1); for (int i = 0; i < 3; i++) { if ( is_infinite( f->vertex(0) ) ) { i_inf = i; break; } } typename Gt::Line_2 ll = circumcircle(f->vertex((i_inf+1)%3)->site(), f->vertex((i_inf+2)%3)->site()); return geom_traits().construct_object_2_object()(ll); } template typename Gt::Object_2 Apollonius_graph_2:: dual(const Edge e) const { CGAL_triangulation_precondition( !is_infinite(e) ); if ( dimension() == 1 ) { Site_2 p = (e.first)->vertex(cw(e.second))->site(); Site_2 q = (e.first)->vertex(ccw(e.second))->site(); return construct_Apollonius_bisector_2_object()(p,q); } // dimension == 2 // none of the two adjacent faces is infinite if( (!is_infinite(e.first)) && (!is_infinite(e.first->neighbor(e.second))) ) { Site_2 p = (e.first)->vertex( ccw(e.second) )->site(); Site_2 q = (e.first)->vertex( cw(e.second) )->site(); Site_2 r = (e.first)->vertex( e.second )->site(); Site_2 s = (e.first)->mirror_vertex(e.second)->site(); return construct_Apollonius_bisector_segment_2_object()(p,q,r,s); } // both of the adjacent faces are infinite if ( is_infinite(e.first) && is_infinite(e.first->neighbor(e.second)) ) { Site_2 p = (e.first)->vertex(cw(e.second))->site(); Site_2 q = (e.first)->vertex(ccw(e.second))->site(); return construct_Apollonius_bisector_2_object()(p,q); } // only one of the adjacent faces is infinite CGAL_triangulation_assertion( is_infinite( e.first ) || is_infinite( e.first->neighbor(e.second) ) ); CGAL_triangulation_assertion( !(is_infinite( e.first ) && is_infinite( e.first->neighbor(e.second) ) ) ); CGAL_triangulation_assertion ( is_infinite( e.first->vertex(e.second) ) || is_infinite( e.first->mirror_vertex(e.second) ) ); Edge ee = e; if ( is_infinite( e.first->vertex(e.second) ) ) { ee = sym_edge(e); } Site_2 p = ee.first->vertex( ccw(ee.second) )->site(); Site_2 q = ee.first->vertex( cw(ee.second) )->site(); Site_2 r = ee.first->vertex( ee.second )->site(); return construct_Apollonius_bisector_ray_2_object()(p,q,r); } // primal template typename Gt::Object_2 Apollonius_graph_2:: primal(const Edge e) const { typedef typename Geom_traits::Segment_2 Segment; typedef typename Geom_traits::Ray_2 Ray; typedef CGAL::Hyperbola_segment_2 Hyperbola_segment; typedef CGAL::Parabola_segment_2 Parabola_segment; // typedef typename Geom_traits::Hyperbola_segment_2 Hyperbola_segment; // typedef typename Geom_traits::Parabola_segment_2 Parabola_segment; // CGAL_triangulation_precondition( !is_infinite(e) ); if ( number_of_vertices() != 2 ) { if ( is_infinite(e) ) { Ray ray; if ( is_infinite( e.first->vertex(cw(e.second)) ) ) { Site_2 p = e.first->vertex( ccw(e.second) )->site(); Site_2 r = e.first->vertex( e.second )->site(); Site_2 s = e.first->mirror_vertex( e.second )->site(); ray = construct_Apollonius_primal_ray_2_object()(p,r,s); } else { CGAL_triangulation_assertion ( is_infinite( e.first->vertex(ccw(e.second)) ) ); Site_2 q = e.first->vertex( cw(e.second) )->site(); Site_2 r = e.first->vertex( e.second )->site(); Site_2 s = e.first->mirror_vertex( e.second )->site(); ray = construct_Apollonius_primal_ray_2_object()(q,s,r); } return make_object(ray); } } if ( dimension() == 1 ) { Site_2 p = (e.first)->vertex(cw(e.second))->site(); Site_2 q = (e.first)->vertex(ccw(e.second))->site(); Segment seg = construct_Apollonius_primal_segment_2_object()(p, q); return make_object(seg); } // dimension == 2 if( (!is_infinite(e.first)) && (!is_infinite(e.first->neighbor(e.second))) ) { Site_2 p = (e.first)->vertex( ccw(e.second) )->site(); Site_2 q = (e.first)->vertex( cw(e.second) )->site(); Site_2 r = (e.first)->vertex( e.second )->site(); Site_2 s = (e.first)->mirror_vertex(e.second)->site(); return construct_Apollonius_primal_segment_2_object()(p,q,r,s); } // both of the adjacent faces are infinite if ( is_infinite(e.first) && is_infinite(e.first->neighbor(e.second)) ) { Site_2 p = (e.first)->vertex(cw(e.second))->site(); Site_2 q = (e.first)->vertex(ccw(e.second))->site(); Segment seg = construct_Apollonius_primal_segment_2_object()(p,q); return make_object(seg); } // only one of the adjacent faces is infinite Edge ee = e; if ( is_infinite(e.first) ) { ee = sym_edge(e); } Site_2 p = (ee.first)->vertex( ccw(ee.second) )->site(); Site_2 q = (ee.first)->vertex( cw(ee.second) )->site(); Site_2 r = (ee.first)->vertex( ee.second )->site(); Parabola_segment ps = construct_Apollonius_primal_segment_2_object()(p,q,r); return make_object(ps); } //-------------------------------------------------------------------- // combinatorial operations //-------------------------------------------------------------------- template typename Apollonius_graph_2::Edge Apollonius_graph_2:: flip(Face_handle& f, int i) { CGAL_triangulation_precondition ( f != Face_handle() ); CGAL_triangulation_precondition (i == 0 || i == 1 || i == 2); CGAL_triangulation_precondition( dimension()==2 ); CGAL_triangulation_precondition( f->vertex(i) != f->mirror_vertex(i) ); this->_tds.flip(f, i); return Edge(f, ccw(i)); } template typename Apollonius_graph_2::Edge Apollonius_graph_2:: flip(Edge e) { return flip(e.first, e.second); } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert_in_face(Face_handle& f, const Site_2& p) { Vertex_handle v = this->_tds.insert_in_face( f ); v->set_site(p); return v; } template bool Apollonius_graph_2:: is_degree_2(const Vertex_handle& v) const { Face_circulator fc = v->incident_faces(); Face_circulator fc1 = fc; ++(++fc1); return ( fc == fc1 ); } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert_degree_2(Edge e) { return this->_tds.insert_degree_2(e.first, e.second); } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert_degree_2(Edge e, const Site_2& p) { Vertex_handle v = insert_degree_2(e); v->set_site(p); return v; } template void Apollonius_graph_2:: remove_degree_2(Vertex_handle v) { CGAL_triangulation_precondition( is_degree_2(v) ); this->_tds.remove_degree_2( v ); } template void Apollonius_graph_2:: remove_degree_3(Vertex_handle v) { #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE remove_degree_3(v, Face_handle()); #else remove_degree_3(v, NULL); #endif } template void Apollonius_graph_2:: #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE remove_degree_3(Vertex_handle v, Face_handle f) // af:was Face* #else remove_degree_3(Vertex_handle v, Face* f) #endif { CGAL_triangulation_precondition( v->degree() == 3 ); this->_tds.remove_degree_3(v, f); } //-------------------------------------------------------------------- // insertion of weighted point //-------------------------------------------------------------------- template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert_first(const Site_2& p) { CGAL_triangulation_precondition(number_of_vertices() == 0); Vertex_handle v = this->_tds.insert_second(); v->set_site(p); return v; // return Delaunay_graph::insert_first(p); } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert_second(const Site_2& p) { CGAL_triangulation_precondition( number_of_vertices() == 1 ); Vertex_handle vnew; Vertex_handle v(finite_vertices_begin()); if ( is_hidden(v->site(), p) ) { v->add_hidden_site(p); vnew = Vertex_handle(); } else if ( is_hidden(p, v->site()) ) { v->add_hidden_site(v->site()); v->set_site(p); vnew = v; } else { CGAL_triangulation_precondition(number_of_vertices() == 1); vnew = this->_tds.insert_dim_up(infinite_vertex(), true); vnew->set_site(p); // vnew = Delaunay_graph::insert_second(p); } return vnew; } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert_third(const Site_2& p) { CGAL_triangulation_precondition( number_of_vertices() == 2 ); Vertex_handle v1(finite_vertices_begin()); Vertex_handle v2(++finite_vertices_begin()); if ( is_hidden(v1->site(), p) ) { v1->add_hidden_site(p); return Vertex_handle(); } if ( is_hidden(v2->site(), p) ) { v2->add_hidden_site(p); return Vertex_handle(); } bool t1 = is_hidden(p, v1->site()); bool t2 = is_hidden(p, v2->site()); if ( t1 && !t2 ) { v1->add_hidden_site(v1->site()); v1->set_site(p); return v1; } else if ( !t1 && t2 ) { v2->add_hidden_site(v2->site()); v2->set_site(p); return v2; } else if ( t1 && t2 ) { v1->add_hidden_site(v1->site()); v1->add_hidden_site(v2->site()); v1->set_site(p); remove_second(v2); return v1; } Vertex_handle v = this->_tds.insert_dim_up(infinite_vertex()); v->set_site(p); Face_handle f(finite_faces_begin()); Point_2 p1 = f->vertex(0)->site().point(); Point_2 p2 = f->vertex(1)->site().point(); Point_2 p3 = f->vertex(2)->site().point(); Orientation o = geom_traits().orientation_2_object()(p1, p2, p3); if ( o != LEFT_TURN ) { f->reorient(); for (int i = 0; i < 3; i++) { f->neighbor(i)->reorient(); } } Conflict_type ct = finite_edge_conflict_type_degenerated(v1->site(), v2->site(), p); if ( ct == NO_CONFLICT ) { Oriented_side os = side_of_bisector(v1->site(), v2->site(), p.point()); CGAL_assertion( os != ON_ORIENTED_BOUNDARY ); Vertex_handle vv = ( os == ON_NEGATIVE_SIDE ) ? v1 : v2; Face_circulator fc = incident_faces(v); while ( true ) { Face_handle f(fc); int k = f->index(v); Vertex_handle vh = f->vertex(ccw(k)); if ( vh == vv ) { flip(f, cw(k)); break; } ++fc; } } else if ( ct == INTERIOR ) { Edge_circulator ec = incident_edges(v); while ( true ) { if ( is_infinite(ec) ) { flip(*ec); break; } ec++; } } else if ( ct == ENTIRE_EDGE ) { Face_circulator fc = incident_faces(v); while ( true ) { Face_handle f(fc); if ( !is_infinite(f) ) { flip(f, f->index(v)); break; } ++fc; } } else if ( ct == BOTH_VERTICES ) { Conflict_type ct1 = finite_edge_conflict_type_degenerated(v1->site(), p, v2->site()); Edge_circulator ec; ec = ( ct1 == INTERIOR ) ? incident_edges(v2) : incident_edges(v1); while ( true ) { if ( is_infinite(ec) ) { flip(*ec); break; } ec++; } } else { CGAL_assertion( ct == RIGHT_VERTEX || ct == LEFT_VERTEX ); // do nothing here } // CGAL_triangulation_assertion( is_valid() ); return v; } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: insert(const Site_2& p, Vertex_handle vnear) { if ( number_of_vertices() == 0 ) { return insert_first(p); } if ( number_of_vertices() == 1 ) { return insert_second(p); } if ( number_of_vertices() == 2 ) { return insert_third(p); } // first find the nearest neighbor Vertex_handle vnearest = nearest_neighbor(p.point(), vnear); CGAL_assertion( vnearest != Vertex_handle() ); // check if it is hidden Site_2 wp_nearest = vnearest->site(); if ( is_hidden(wp_nearest, p) ) { vnearest->add_hidden_site(p); return Vertex_handle(); } // find the first conflict // first look for conflict with vertex Face_circulator fc_start = vnearest->incident_faces(); Face_circulator fc = fc_start; Face_handle start_f; Sign s; do { Face_handle f(fc); s = incircle(f, p); if ( s == NEGATIVE ) { start_f = f; break; } ++fc; } while ( fc != fc_start ); // we are not in conflict with an Apollonius vertex, so we have to // be in conflict with the interior of an Apollonius edge if ( s != NEGATIVE ) { Edge_circulator ec_start = vnearest->incident_edges(); Edge_circulator ec = ec_start; bool interior_in_conflict(false); Edge e; do { e = *ec; interior_in_conflict = edge_interior(e, p, false); if ( interior_in_conflict ) { break; } ++ec; } while ( ec != ec_start ); CGAL_assertion( interior_in_conflict ); return insert_degree_2(e, p); } // we are in conflict with an Apollonius vertex; start from that and // find the entire conflict region and then repair the diagram List l; Face_map fm; Vertex_map vm; // MK:: NEED TO WRITE A FUNCTION CALLED find_conflict_region WHICH // IS GIVEN A STARTING FACE, A LIST, A FACE MAP, A VERTEX MAP AND A // LIST OF FLIPPED EDGES AND WHAT IS DOES IS INITIALIZE THE CONFLICT // REGION AND EXPANDS THE CONFLICT REGION. initialize_conflict_region(start_f, l); expand_conflict_region(start_f, p, l, fm, vm, NULL); // retriangulate_conflict_region(v, l, fm, vm); Vertex_handle v = retriangulate_conflict_region(p, l, fm, vm); fm.clear(); vm.clear(); return v; } //-------------------------------------------------------------------- // find conflict region //-------------------------------------------------------------------- template void Apollonius_graph_2:: find_conflict_region_remove(const Vertex_handle& v, const Vertex_handle& vnearest, List& l, Face_map& fm, Vertex_map& vm, std::vector* fe) { Site_2 p = v->site(); // check if it is hidden Site_2 wp_nearest = vnearest->site(); if ( is_hidden(wp_nearest, p) ) { vnearest->add_hidden_site(p); return; } CGAL_precondition( vnearest != Vertex_handle() ); // find the first conflict // first look for conflict with vertex Face_circulator fc_start = vnearest->incident_faces(); Face_circulator fc = fc_start; Face_handle start_f; Sign s; do { Face_handle f(fc); // int id = f->mirror_indexf->index(vnearest) s = incircle(f, p); if ( s == NEGATIVE ) { start_f = f; break; } ++fc; } while ( fc != fc_start ); CGAL_assertion( s == NEGATIVE ); // we are not in conflict with an Apollonius vertex, so we have to // be in conflict with the interior of an Apollonius edge if ( s != NEGATIVE ) { Edge_circulator ec_start = vnearest->incident_edges(); Edge_circulator ec = ec_start; bool interior_in_conflict(false); Edge e; do { e = *ec; interior_in_conflict = edge_interior(e, p, false); if ( interior_in_conflict ) { break; } ++ec; } while ( ec != ec_start ); CGAL_assertion( interior_in_conflict ); l.push_back(e); l.push_back(sym_edge(e)); return; } initialize_conflict_region(start_f, l); expand_conflict_region(start_f, v->site(), l, fm, vm, fe); } template void Apollonius_graph_2:: initialize_conflict_region(const Face_handle& f, List& l) { l.clear(); for (int i = 0; i < 3; i++) { l.push_back(sym_edge(f, i)); } } template bool Apollonius_graph_2:: check_edge_for_hidden_sites(const Face_handle& f, int i, const Site_2& p, Vertex_map& vm) { bool found(false); Vertex_handle v1 = f->vertex(ccw(i)); if ( vm.find(v1) == vm.end() ) { if ( !is_infinite(v1) && is_hidden(p, v1->site()) ) { vm[v1] = true; found = true; } } else { found = true; } Vertex_handle v2 = f->vertex(cw(i)); if ( vm.find(v2) == vm.end() ) { if ( !is_infinite(v2) && is_hidden(p, v2->site()) ) { vm[v2] = true; found = true; } } else { found = true; } return found; } template void Apollonius_graph_2:: expand_conflict_region(const Face_handle& f, const Site_2& p, List& l, Face_map& fm, Vertex_map& vm, std::vector* fe) { // setting fm[f] to true means that the face has been reached and // that the face is available for recycling. If we do not want the // face to be available for recycling we must set this flag to // false. fm[f] = true; // CGAL_assertion( fm.find(f) != fm.end() ); for (int i = 0; i < 3; i++) { bool hidden_found = check_edge_for_hidden_sites(f, i, p, vm); Face_handle n = f->neighbor(i); if ( !hidden_found ) { Sign s = incircle(n, p); if ( s != NEGATIVE ) { continue; } bool interior_in_conflict = edge_interior(f, i, p, true); if ( !interior_in_conflict ) { continue; } } if ( fm.find(n) != fm.end() ) { Edge e = sym_edge(f, i); if ( l.is_in_list(e) || l.is_in_list(sym_edge(e)) ) { l.remove(e); l.remove(sym_edge(e)); } continue; } Edge e = sym_edge(f, i); CGAL_assertion( l.is_in_list(e) ); int j = f->mirror_index(i); Edge e_before = sym_edge(n, ccw(j)); Edge e_after = sym_edge(n, cw(j)); if ( !l.is_in_list(e_before) ) { l.insert_before(e, e_before); } if ( !l.is_in_list(e_after) ) { l.insert_after(e, e_after); } l.remove(e); if ( fe != NULL ) { Vh_triple* vhq = new Vh_triple[1]; (*vhq)[0] = Vertex_handle(); (*vhq)[1] = n->vertex( j ); (*vhq)[2] = n->vertex( ccw(j) ); fe->push_back(vhq); } expand_conflict_region(n, p, l, fm, vm, fe); } // for-loop } //-------------------------------------------------------------------- // retriangulate conflict region //-------------------------------------------------------------------- template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: add_bogus_vertex(Edge e, List& l) { Edge esym = sym_edge(e); Face_handle g1 = e.first; Face_handle g2 = esym.first; Vertex_handle v = insert_degree_2(e); Face_circulator fc(v); Face_handle f1(fc); Face_handle f2(++fc); int i1 = f1->index(v); int i2 = f2->index(v); CGAL_assertion( ((f1->neighbor(i1) == g1) && (f2->neighbor(i2) == g2)) || ((f1->neighbor(i1) == g2) && (f2->neighbor(i2) == g1)) ); Edge ee, eesym; if ( f1->neighbor(i1) == g1 ) { ee = Edge(f2, i2); eesym = Edge(f1, i1); } else { ee = Edge(f1, i1); eesym = Edge(f2, i2); } l.replace(e, ee); l.replace(esym, eesym); return v; } template typename Apollonius_graph_2::Vertex_list Apollonius_graph_2:: add_bogus_vertices(List& l) { Vertex_list vertex_list; Edge_list edge_list; Edge e_start = l.front(); Edge e = e_start; do { Edge esym = sym_edge(e); if ( l.is_in_list(esym) && edge_list.find(esym) == edge_list.end() ) { edge_list.insert(e); } e = l.next(e); } while ( e != e_start ); typename Edge_list::iterator it; for (it = edge_list.begin(); it != edge_list.end(); ++it) { e = *it; Vertex_handle v = add_bogus_vertex(e, l); vertex_list.push_back(v); } return vertex_list; } template void Apollonius_graph_2:: remove_bogus_vertices(Vertex_list& vl) { while ( vl.size() > 0 ) { Vertex_handle v = vl.front(); vl.pop_front(); remove_degree_2(v); } } template void Apollonius_graph_2:: move_hidden_sites(Vertex_handle& vold, Vertex_handle& vnew) { typename Vertex::Hidden_sites_iterator wpit; for (wpit = vold->hidden_sites_begin(); wpit != vold->hidden_sites_end(); ++wpit) { vnew->add_hidden_site(*wpit); } vold->clear_hidden_sites_container(); } template std::vector::Face*> Apollonius_graph_2:: get_faces_for_recycling(Face_map& fm, unsigned int n_wanted) { std::vector vf; typename Face_map::iterator fmit; for (fmit = fm.begin(); fmit != fm.end(); ++fmit) { Face_handle f = (*fmit).first; if ( fm[f] == true ) { vf.push_back( f ); } } while ( vf.size() < n_wanted ) { Face* fp = static_cast(this->_tds.create_face()); vf.push_back(fp); } while ( vf.size() > n_wanted ) { Face* fp = vf.back(); vf.pop_back(); this->_tds.delete_face(fp); } return vf; } template void Apollonius_graph_2:: remove_hidden_vertices(Vertex_map& vm) { typename Vertex_map::iterator it; for (it = vm.begin(); it != vm.end(); ++it) { Vertex_handle vhidden = (*it).first; this->_tds.delete_vertex( vhidden ); } vm.clear(); } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: retriangulate_conflict_region(const Site_2& p, List& l, Face_map& fm, Vertex_map& vm) { size_type vmsize = vm.size(); size_type num_vert = number_of_vertices(); if ( num_vert - vmsize == 0 ) { // 1. copy all hidden sites to a temporary list Site_list wp_list; typename Vertex_map::iterator vmit; for (vmit = vm.begin(); vmit != vm.end(); ++vmit) { Vertex_handle vhidden = (*vmit).first; wp_list.push_back(vhidden->site()); typename Vertex::Hidden_sites_iterator it; for (it = vhidden->hidden_sites_begin(); it != vhidden->hidden_sites_end(); ++it) { wp_list.push_back(*it); } vhidden->clear_hidden_sites_container(); } // 2. clear the current Apollonius diagram clear(); // 3. add a new vertex Vertex_handle v = insert_first(p); // 4. add all old sites to the hidden site list of the // new site Site_list_iterator wpit; for (wpit = wp_list.begin(); wpit != wp_list.end(); ++wpit) { v->add_hidden_site(*wpit); } return v; } else if ( num_vert - vmsize == 1 ) { // 1. copy all hidden sites to a temporary list Site_list wp_list; typename Vertex_map::iterator vmit; for (vmit = vm.begin(); vmit != vm.end(); ++vmit) { Vertex_handle vhidden = (*vmit).first; wp_list.push_back(vhidden->site()); typename Vertex::Hidden_sites_iterator it; for (it = vhidden->hidden_sites_begin(); it != vhidden->hidden_sites_end(); ++it) { wp_list.push_back(*it); } vhidden->clear_hidden_sites_container(); } // 2. find which vertex remains non-hidden and copy its hidden // sites to a local container Vertex_handle non_hidden; Finite_vertices_iterator vit = finite_vertices_begin(); do { non_hidden = Vertex_handle(vit); ++vit; } while ( vm.find(non_hidden) != vm.end() ); Site_2 p1 = non_hidden->site(); Site_list wp_list1; typename Vertex::Hidden_sites_iterator it; for (it = non_hidden->hidden_sites_begin(); it != non_hidden->hidden_sites_end(); ++it) { wp_list1.push_back(*it); } non_hidden->clear_hidden_sites_container(); // 3. clear the current Apollonius graph clear(); // 4. insert the two non-hidden sites and copy the corresponding // hidden sites Vertex_handle v1 = insert_first(p1); for (Site_list_iterator it = wp_list1.begin(); it != wp_list1.end(); ++it) { v1->add_hidden_site(*it); } Vertex_handle v = insert_second(p); for (Site_list_iterator it = wp_list.begin(); it != wp_list.end(); ++it) { v->add_hidden_site(*it); } return v; } Vertex_handle v = this->_tds.create_vertex(); v->set_site(p); // 1. move all the hidden sites to the new one typename Vertex_map::iterator vmit; for (vmit = vm.begin(); vmit != vm.end(); ++vmit) { Vertex_handle vhidden = (*vmit).first; move_hidden_sites(vhidden, v); v->add_hidden_site(vhidden->site()); } CGAL_precondition( number_of_vertices() - vm.size() >= 2 ); // 2. add the bogus vetrices Vertex_list dummy_vertices = add_bogus_vertices(l); // 3. repair the face pointers... Edge e_start = l.front(); Edge eit = e_start; do { Edge esym = sym_edge(eit); Face_handle f = eit.first; int k = eit.second; CGAL_assertion( !l.is_in_list(esym) ); CGAL_assertion( fm.find(f) == fm.end() ); f->vertex(ccw(k))->set_face(f); f->vertex( cw(k))->set_face(f); eit = l.next(eit); } while ( eit != e_start ); // std::vector vf = get_faces_for_recycling(fm, l.size()); std::list vf; // 4. copy the edge list to a vector of edges and clear the in place // list typedef typename Agds::Edge Agds_edge; std::vector ve; Edge efront = l.front(); Edge e = efront; do { ve.push_back(Agds_edge(e.first, e.second)); e = l.next(e); } while ( e != efront ); l.clear(); // 5. remove the hidden vertices remove_hidden_vertices(vm); // 6. retriangulate the hole // _tds.star_hole( v, ve.begin(), ve.end(), vf.begin(), vf.end()); this->_tds.star_hole(v, ve.begin(), ve.end()); // 7. remove the bogus vertices remove_bogus_vertices(dummy_vertices); // 8. remove the unused faces typename Face_map::iterator it; for (it = fm.begin(); it != fm.end(); ++it) { Face_handle fh = (*it).first; this->_tds.delete_face( fh ); } CGAL_assertion( number_of_vertices() + vmsize == num_vert + 1 ); // 9. DONE!!!! return v; } //-------------------------------------------------------------------- // point location //-------------------------------------------------------------------- template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: nearest_neighbor(const Point_2& p) const { return nearest_neighbor(p, Vertex_handle()); } template typename Apollonius_graph_2::Vertex_handle Apollonius_graph_2:: nearest_neighbor(const Point_2& p, Vertex_handle start_vertex) const { if ( number_of_vertices() == 0 ) { return Vertex_handle(); } if ( start_vertex == Vertex_handle() ) { start_vertex = finite_vertex(); } // if ( start_vertex == Vertex_handle() ) { return start_vertex; } Vertex_handle vclosest; Vertex_handle v = start_vertex; if ( number_of_vertices() < 3 ) { vclosest = v; Finite_vertices_iterator vit = finite_vertices_begin(); for (; vit != finite_vertices_end(); ++vit) { Vertex_handle v1(vit); if ( v1 != vclosest /*&& !is_infinite(v1)*/ ) { Site_2 p1 = vclosest->site(); Site_2 p2 = v1->site(); if ( side_of_bisector(p1, p2, p) == ON_NEGATIVE_SIDE ) { vclosest = v1; } } } return vclosest; } do { vclosest = v; Site_2 p1 = v->site(); Vertex_circulator vc_start = incident_vertices(v); Vertex_circulator vc = vc_start; do { if ( !is_infinite(vc) ) { Vertex_handle v1(vc); Site_2 p2 = v1->site(); if ( side_of_bisector(p1, p2, p) == ON_NEGATIVE_SIDE ) { v = v1; break; } } ++vc; } while ( vc != vc_start ); } while ( vclosest != v ); return vclosest; } //---------------------------------------------------------------------- // methods for the predicates //---------------------------------------------------------------------- template bool Apollonius_graph_2:: is_hidden(const Site_2 &p, const Site_2 &q) const { return geom_traits().is_hidden_2_object()(p, q); } template Oriented_side Apollonius_graph_2:: side_of_bisector(const Site_2 &p1, const Site_2 &p2, const Point_2 &p) const { return geom_traits().oriented_side_of_bisector_2_object()(p1, p2, p); } template Sign Apollonius_graph_2:: incircle(const Site_2 &p1, const Site_2 &p2, const Site_2 &p3, const Site_2 &q) const { return geom_traits().vertex_conflict_2_object()(p1, p2, p3, q); } template Sign Apollonius_graph_2:: incircle(const Site_2 &p1, const Site_2 &p2, const Site_2 &q) const { return geom_traits().vertex_conflict_2_object()(p1, p2, q); } template Sign Apollonius_graph_2:: incircle(const Face_handle& f, const Site_2& q) const { if ( !is_infinite(f) ) { return incircle(f->vertex(0)->site(), f->vertex(1)->site(), f->vertex(2)->site(), q); } int inf_i(-1); // to avoid compiler warning for (int i = 0; i < 3; i++) { if ( is_infinite(f->vertex(i)) ) { inf_i = i; break; } } return incircle( f->vertex( ccw(inf_i) )->site(), f->vertex( cw(inf_i) )->site(), q ); } template Sign Apollonius_graph_2:: incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v) const { CGAL_precondition( !is_infinite(v0) && !is_infinite(v1) && !is_infinite(v) ); return incircle( v0->site(), v1->site(), v->site()); } template Sign Apollonius_graph_2:: incircle(const Vertex_handle& v0, const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v) const { CGAL_precondition( !is_infinite(v) ); if ( !is_infinite(v0) && !is_infinite(v1) && !is_infinite(v2) ) { return incircle(v0->site(), v1->site(), v2->site(), v->site()); } if ( is_infinite(v0) ) { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) ); return incircle( v1->site(), v2->site(), v->site()); } if ( is_infinite(v1) ) { CGAL_precondition( !is_infinite(v0) && !is_infinite(v2) ); return incircle( v2->site(), v0->site(), v->site()); } CGAL_assertion( is_infinite(v2) ); CGAL_precondition( !is_infinite(v0) && !is_infinite(v1) ); return incircle( v0->site(), v1->site(), v->site()); } template bool Apollonius_graph_2:: finite_edge_interior(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b) const { if ( is_hidden(q, p1) ) { return true; } if ( is_hidden(q, p2) ) { return true; } return geom_traits().finite_edge_interior_conflict_2_object()(p1,p2,p3,p4,q,b); } template bool Apollonius_graph_2:: finite_edge_interior(const Face_handle& f, int i, const Site_2& p, bool b) const { CGAL_precondition( !is_infinite(f) && !is_infinite(f->neighbor(i)) ); return finite_edge_interior( f->vertex( ccw(i) )->site(), f->vertex( cw(i) )->site(), f->vertex( i )->site(), f->mirror_vertex(i)->site(), p, b); } template bool Apollonius_graph_2:: finite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool b) const { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) && !is_infinite(v3) && !is_infinite(v4) && !is_infinite(v) ); return finite_edge_interior( v1->site(), v2->site(), v3->site(), v4->site(), v->site(), b); } template bool Apollonius_graph_2:: finite_edge_interior_degenerated(const Site_2& p1, const Site_2& p2, const Site_2& p3, const Site_2& q, bool b) const { if ( is_hidden(q, p1) ) { return true; } if ( is_hidden(q, p2) ) { return true; } return geom_traits().finite_edge_interior_conflict_2_object()(p1,p2,p3,q,b); } template bool Apollonius_graph_2:: finite_edge_interior_degenerated(const Site_2& p1, const Site_2& p2, const Site_2& q, bool b) const { if ( is_hidden(q, p1) ) { return true; } if ( is_hidden(q, p2) ) { return true; } return geom_traits().finite_edge_interior_conflict_2_object()(p1, p2, q, b); } template bool Apollonius_graph_2:: finite_edge_interior_degenerated(const Face_handle& f, int i, const Site_2& p, bool b) const { if ( !is_infinite( f->mirror_vertex(i) ) ) { CGAL_precondition( is_infinite(f->vertex(i)) ); Face_handle g = f->neighbor(i); int j = f->mirror_index(i); return finite_edge_interior_degenerated(g, j, p, b); } CGAL_precondition( is_infinite( f->mirror_vertex(i) ) ); Site_2 p1 = f->vertex( ccw(i) )->site(); Site_2 p2 = f->vertex( cw(i) )->site(); if ( is_infinite(f->vertex(i)) ) { return finite_edge_interior_degenerated(p1, p2, p, b); } Site_2 p3 = f->vertex(i)->site(); return finite_edge_interior_degenerated(p1, p2, p3, p, b); } template bool Apollonius_graph_2:: finite_edge_interior_degenerated(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool b) const { CGAL_precondition( !is_infinite(v1) && !is_infinite(v2) && !is_infinite(v) ); if ( !is_infinite( v4 ) ) { CGAL_precondition( is_infinite(v3) ); return finite_edge_interior_degenerated(v2, v1, v4, v3, v, b); } CGAL_precondition( is_infinite( v4 ) ); Site_2 p1 = v1->site(); Site_2 p2 = v2->site(); Site_2 p = v->site(); if ( is_infinite(v3) ) { return finite_edge_interior_degenerated(p1, p2, p, b); } Site_2 p3 = v3->site(); return finite_edge_interior_degenerated(p1, p2, p3, p, b); } template bool Apollonius_graph_2:: infinite_edge_interior(const Site_2& p2, const Site_2& p3, const Site_2& p4, const Site_2& q, bool b) const { if ( is_hidden(q, p2) ) { return true; } return geom_traits().infinite_edge_interior_conflict_2_object()(p2,p3,p4,q,b); } template bool Apollonius_graph_2:: infinite_edge_interior(const Face_handle& f, int i, const Site_2& p, bool b) const { if ( !is_infinite( f->vertex(ccw(i)) ) ) { CGAL_precondition( is_infinite( f->vertex(cw(i)) ) ); Face_handle g = f->neighbor(i); int j = f->mirror_index(i); return infinite_edge_interior(g, j, p, b); } CGAL_precondition( is_infinite( f->vertex(ccw(i)) ) ); Site_2 p2 = f->vertex( cw(i) )->site(); Site_2 p3 = f->vertex( i )->site(); Site_2 p4 = f->mirror_vertex(i)->site(); return infinite_edge_interior(p2, p3, p4, p, b); } template bool Apollonius_graph_2:: infinite_edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool b) const { CGAL_precondition( !is_infinite(v3) && !is_infinite(v4) && !is_infinite(v) ); if ( !is_infinite( v1 ) ) { CGAL_precondition( is_infinite( v2 ) ); return infinite_edge_interior(v2, v1, v4, v3, v, b); } CGAL_precondition( is_infinite( v1 ) ); Site_2 p2 = v2->site(); Site_2 p3 = v3->site(); Site_2 p4 = v4->site(); Site_2 p = v->site(); return infinite_edge_interior(p2, p3, p4, p, b); } template bool Apollonius_graph_2:: edge_interior(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, const Vertex_handle& v4, const Vertex_handle& v, bool b) const { CGAL_precondition( !is_infinite(v) ); bool is_inf_v1 = is_infinite(v1); bool is_inf_v2 = is_infinite(v2); bool is_inf_v3 = is_infinite(v3); bool is_inf_v4 = is_infinite(v4); bool result; if ( !is_inf_v1 && !is_inf_v2 && !is_inf_v3 && !is_inf_v4 ) { result = finite_edge_interior(v1, v2, v3, v4, v, b); } else if ( is_inf_v3 || is_inf_v4 ) { result = finite_edge_interior_degenerated(v1, v2, v3, v4, v, b); } else { result = infinite_edge_interior(v1, v2, v3, v4, v, b); } return result; } template bool Apollonius_graph_2:: edge_interior(const Face_handle& f, int i, const Site_2& p, bool b) const { Face_handle g = f->neighbor(i); bool is_inf_f = is_infinite(f); bool is_inf_g = is_infinite(g); bool result; if ( !is_inf_f && !is_inf_g ) { result = finite_edge_interior(f, i, p, b); } else if ( !is_inf_f || !is_inf_g ) { result = finite_edge_interior_degenerated(f, i, p, b); } else { // Edge e(f, i); if ( !is_infinite(f, i) ) { result = finite_edge_interior_degenerated(f, i, p, b); } else { result = infinite_edge_interior(f, i, p, b); } } return result; } template typename Apollonius_graph_2::Conflict_type Apollonius_graph_2:: finite_edge_conflict_type_degenerated(const Site_2& p1, const Site_2& p2, const Site_2& q) const { Sign i1 = incircle(p1, p2, q); Sign i2 = incircle(p2, p1, q); if ( i1 == NEGATIVE && i2 == POSITIVE ) { return LEFT_VERTEX; } else if ( i1 == POSITIVE && i2 == NEGATIVE ) { return RIGHT_VERTEX; } else if ( i1 == POSITIVE && i2 == POSITIVE ) { bool b = finite_edge_interior_degenerated(p1, p2, q, false); return (b ? INTERIOR : NO_CONFLICT); } else if ( i1 == NEGATIVE && i2 == NEGATIVE ) { bool b = finite_edge_interior_degenerated(p1, p2, q, true); return (b ? ENTIRE_EDGE : BOTH_VERTICES); } else { // this should never be reached; the degenerated incircle never // returns ZERO CGAL_assertion( false ); } // to satisfy compiler return NO_CONFLICT; } //---------------------------------------------------------------------- // methods for disk removal //---------------------------------------------------------------------- template void Apollonius_graph_2:: remove_first(Vertex_handle v) { Delaunay_graph::remove_first(v); } template void Apollonius_graph_2:: remove_second(Vertex_handle v) { Delaunay_graph::remove_second(v); } template void Apollonius_graph_2:: remove_third(Vertex_handle v) { if ( is_degree_2(v) ) { Face_handle fh(v->incident_faces()); int i = fh->index(v); flip(fh, i); } else if ( v->degree() == 4 ) { Edge_circulator ec = v->incident_edges(); for (int i = 0; i < 4; i++) { Edge e = *ec; Edge sym = sym_edge(e); if ( e.first->vertex(e.second) != sym.first->vertex(sym.second) ) { flip(e); break; } ++ec; } } this->_tds.remove_dim_down( v ); } template void Apollonius_graph_2:: remove(Vertex_handle v) { CGAL_triangulation_precondition( v != Vertex_handle() ); CGAL_triangulation_precondition( !is_infinite(v) ); // find a neighbor of v to use for point location of hidden sites to // be re-inserted Vertex_handle vnear; if ( /*StoreHidden*/ true ) { if ( number_of_vertices() > 10 ) { Vertex_circulator vc_start = v->incident_vertices(); Vertex_circulator vc = vc_start; do { if ( !is_infinite(vc) ) { vnear = Vertex_handle(vc); break; } ++vc; } while ( vc != vc_start ); } } Site_list wp_list; typename Vertex::Hidden_sites_iterator wpit; for (wpit = v->hidden_sites_begin(); wpit != v->hidden_sites_end(); ++wpit) { wp_list.push_back(*wpit); } int n = number_of_vertices(); if ( n == 1 ) { remove_first(v); } else if ( n == 2 ) { remove_second(v); } else if ( n == 3 ) { remove_third(v); } else { int degree = v->degree(); if ( degree == 2 ) { remove_degree_2(v); } else if ( degree == 3 ) { remove_degree_3(v); } else { remove_degree_d_vertex(v); } } Site_less_than_comparator less_than(geom_traits()); std::sort(wp_list.begin(), wp_list.end(), less_than); for (unsigned int i = 0; i < wp_list.size(); i++) { vnear = insert(wp_list[i], vnear); } } template void Apollonius_graph_2:: remove_degree_d_vertex(Vertex_handle v) { minimize_degree(v); int deg = v->degree(); if ( deg == 3 ) { remove_degree_3(v); return; } if ( deg == 2 ) { remove_degree_2(v); return; } Apollonius_graph_2 ag_small; std::map vmap; Vertex_circulator vc_start = v->incident_vertices(); Vertex_circulator vc = v->incident_vertices(); Vertex_handle vh_large, vh_small; do { vh_large = Vertex_handle(vc); if ( is_infinite(vh_large) ) { vh_small = ag_small.infinite_vertex(); vmap[vh_small] = vh_large; } else { vh_small = ag_small.insert(vc->site()); if ( vh_small != Vertex_handle() ) { vmap[vh_small] = vh_large; } } ++vc; } while ( vc != vc_start ); if ( ag_small.number_of_vertices() == 2 ) { CGAL_assertion( deg == 4 ); Edge_circulator ec = v->incident_edges(); for (int i = 0; i < 4; i++) { Edge e = *ec; Edge sym = sym_edge(e); if ( e.first->vertex(e.second) != sym.first->vertex(sym.second) ) { flip(e); break; } ++ec; } remove_degree_3(v); return; } Vertex_handle vn = ag_small.nearest_neighbor(v->site().point()); assert( vn != Vertex_handle() ); List l; Face_map fm; Vertex_map vm; std::vector flipped_edges; ag_small.find_conflict_region_remove(v, vn, l, fm, vm, &flipped_edges); l.clear(); fm.clear(); vm.clear(); Edge_circulator ec; unsigned int num_fe = flipped_edges.size(); for (unsigned int i = 0; i < num_fe; i++) { Vh_triple *vhq = flipped_edges[num_fe - i - 1]; bool found(false); ec = v->incident_edges(); Edge_circulator ec_start = ec; do { Edge e = *ec; if ( (e.first->vertex( cw(e.second) ) == vmap[(*vhq)[1]] && e.first->vertex( e.second ) == vmap[(*vhq)[2]]) || (e.first->vertex( ccw(e.second) ) == vmap[(*vhq)[1]] && e.first->mirror_vertex(e.second) == vmap[(*vhq)[2]]) ) { flip(e); found = true; break; } ++ec; } while ( ec != ec_start ); CGAL_assertion( found ); } CGAL_triangulation_precondition( v->degree() == 3 ); #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE this->_tds.remove_degree_3( v, Face_handle() ); #else this->_tds.remove_degree_3( v, NULL ); #endif for (unsigned int i = 0; i < num_fe; i++) { delete flipped_edges[i]; } } template void Apollonius_graph_2:: minimize_degree(Vertex_handle v) { CGAL_precondition ( v->degree() > 3 ); Face_circulator fc_start = v->incident_faces(); Face_circulator fc = v->incident_faces(); bool found(false); do { Face_handle f = Face_handle(fc); int i = ccw( f->index(v) ); CGAL_assertion( f->vertex( cw(i) ) == v ); Vertex_handle v0 = f->vertex( i ); Vertex_handle v1 = f->mirror_vertex( i ); bool is_admissible = (v0 != v1) && !is_infinite(f) && !is_infinite( f->neighbor(i) ); if ( is_admissible && is_degenerate_edge(f, i) ) { Edge e = flip(f, i); f = e.first; if ( !f->has_vertex(v) ) { f = e.first->neighbor(e.second); CGAL_assertion( f->has_vertex(v) ); } fc = --( v->incident_faces(f) ); fc_start = fc; found = true; } else { ++fc; found = false; } } while ( found || fc != fc_start ); } CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_2_C mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3_0.h0000644000175000017500000002000711344301501031150 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_3_0.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman, Andreas Fabri #ifndef CGAL_DISTANCE_3_0_H #define CGAL_DISTANCE_3_0_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template bool is_null(const typename CGAL_WRAP(K)::Vector_3 &v, const K&) { typedef typename K::RT RT; return v.hx()==RT(0) && v.hy()==RT(0) && v.hz()==RT(0); } template typename K::RT wdot(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K&) { return (u.hx()*v.hx() + u.hy()*v.hy() + u.hz()*v.hz()); } template typename K::RT wdot_tag(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K&, const Cartesian_tag&) { return ( (p.x() - q.x()) * (r.x()- q.x()) + (p.y()- q.y())* (r.y()- q.y()) + (p.z()- q.z()) * (r.z() - q.z()) ); } template typename K::RT wdot_tag(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K&, const Homogeneous_tag&) { return ( (p.hx() * q.hw() - q.hx() * p.hw()) * (r.hx() * q.hw() - q.hx() * r.hw()) + (p.hy() * q.hw() - q.hy() * p.hw()) * (r.hy() * q.hw() - q.hy() * r.hw()) + (p.hz() * q.hw() - q.hz() * p.hw()) * (r.hz() * q.hw() - q.hz() * r.hw())); } template inline typename K::RT wdot(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return wdot_tag(p, q, r, k, tag); } template typename K::Vector_3 wcross(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K&) { typedef typename K::Vector_3 Vector_3; return Vector_3( u.hy()*v.hz() - u.hz()*v.hy(), u.hz()*v.hx() - u.hx()*v.hz(), u.hx()*v.hy() - u.hy()*v.hx()); } template inline bool is_acute_angle(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K& k) { typedef typename K::RT RT; return RT(wdot(u, v, k)) > RT(0) ; } template inline bool is_straight_angle(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K& k) { typedef typename K::RT RT; return RT(wdot(u, v, k)) == RT(0) ; } template inline bool is_obtuse_angle(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K& k) { typedef typename K::RT RT; return RT(wdot(u, v, k)) < RT(0) ; } template inline bool is_acute_angle(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { typedef typename K::RT RT; return RT(wdot(p, q, r, k)) > RT(0) ; } template inline bool is_straight_angle(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { typedef typename K::RT RT; return RT(wdot(p, q, r, k)) == RT(0) ; } template inline bool is_obtuse_angle(const typename CGAL_WRAP(K)::Point_3 &p, const typename CGAL_WRAP(K)::Point_3 &q, const typename CGAL_WRAP(K)::Point_3 &r, const K& k) { typedef typename K::RT RT; return RT(wdot(p, q, r, k)) < RT(0) ; } template inline typename K::FT squared_distance(const typename CGAL_WRAP(K)::Point_3 & pt1, const typename CGAL_WRAP(K)::Point_3 & pt2, const K&) { typename K::Construct_vector_3 construct_vector; typedef typename K::Vector_3 Vector_3; Vector_3 vec = construct_vector(pt2, pt1); return vec*vec; } template typename K::FT squared_distance_to_plane(const typename CGAL_WRAP(K)::Vector_3 & normal, const typename CGAL_WRAP(K)::Vector_3 & diff, const K& k) { typedef typename K::RT RT; typedef typename K::FT FT; RT dot, squared_length; dot = wdot(normal, diff, k); squared_length = wdot(normal, normal, k); return FT(dot*dot) / FT(wmult((K*)0, squared_length, diff.hw(), diff.hw())); } template typename K::FT squared_distance_to_line(const typename CGAL_WRAP(K)::Vector_3 & dir, const typename CGAL_WRAP(K)::Vector_3 & diff, const K& k) { typedef typename K::Vector_3 Vector_3; typedef typename K::RT RT; typedef typename K::FT FT; Vector_3 wcr = wcross(dir, diff, k); return FT(wcr*wcr)/FT(wmult( (K*)0, RT(wdot(dir, dir, k)), diff.hw(), diff.hw())); } template inline bool same_direction_tag(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K& k, const Cartesian_tag&) { typedef typename K::FT FT; const FT& ux = u.x(); const FT& uy = u.y(); const FT& uz = u.z(); if (CGAL_NTS abs(ux) > CGAL_NTS abs(uy)) { if (CGAL_NTS abs(ux) > CGAL_NTS abs(uz)) { return CGAL_NTS sign(ux) == CGAL_NTS sign(v.x()); } else { return CGAL_NTS sign(uz) == CGAL_NTS sign(v.z()); } } else { if (CGAL_NTS abs(uy) > CGAL_NTS abs(uz)) { return CGAL_NTS sign(uy) == CGAL_NTS sign(v.y()); } else { return CGAL_NTS sign(uz) == CGAL_NTS sign(v.z()); } } } template inline bool same_direction_tag(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K& k, const Homogeneous_tag&) { typedef typename K::RT RT; const RT& uhx = u.hx(); const RT& uhy = u.hy(); const RT& uhz = u.hz(); if (CGAL_NTS abs(uhx) > CGAL_NTS abs(uhy)) { if (CGAL_NTS abs(uhx) > CGAL_NTS abs(uhz)) { return CGAL_NTS sign(uhx) == CGAL_NTS sign(v.hx()); } else { return CGAL_NTS sign(uhz) == CGAL_NTS sign(v.hz()); } } else { if (CGAL_NTS abs(uhy) > CGAL_NTS abs(uhz)) { return CGAL_NTS sign(uhy) == CGAL_NTS sign(v.hy()); } else { return CGAL_NTS sign(uhz) == CGAL_NTS sign(v.hz()); } } } template inline bool same_direction(const typename CGAL_WRAP(K)::Vector_3 &u, const typename CGAL_WRAP(K)::Vector_3 &v, const K& k) { typedef typename K::Kernel_tag Tag; Tag tag; return same_direction_tag(u, v, k, tag); } } // namespace CGALi template inline typename K::FT squared_distance(const Point_3 & pt1, const Point_3 & pt2) { return CGALi::squared_distance(pt1,pt2, K()); } template inline typename K::FT squared_distance_to_plane(const Vector_3 & normal, const Vector_3 & diff) { return CGALi::squared_distance_to_plane(normal, diff, K()); } template inline typename K::FT squared_distance_to_line(const Vector_3 & dir, const Vector_3 & diff) { return CGALi::squared_distance_to_line(dir, diff, K()); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_archetype.h0000644000175000017500000001233711344301500030463 0ustar debiandebian// Copyright (c) 1999,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_archetype.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Matthias Baesken #ifndef CGAL_KERNEL_ARCHETYPE #define CGAL_KERNEL_ARCHETYPE #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE class Kernel_archetype { public: // 2d #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_FT) typedef double FT; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_RT) typedef double RT; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_POINT_2) typedef Point_2_archetype Point_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_VECTOR_2) typedef Vector_2_archetype Vector_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_DIRECTION_2) typedef Direction_2_archetype Direction_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LINE_2) typedef Line_2_archetype Line_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_RAY_2) typedef Ray_2_archetype Ray_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_SEGMENT_2) typedef Segment_2_archetype Segment_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_TRIANGLE_2) typedef Triangle_2_archetype Triangle_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ISO_RECTANGLE_2) typedef Iso_rectangle_2_archetype Iso_rectangle_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_CIRCLE_2) typedef Circle_2_archetype Circle_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_OBJECT_2) typedef CGAL::Object Object_2; #endif // 3d #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_POINT_3) typedef Point_3_archetype Point_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_VECTOR_3) typedef Vector_3_archetype Vector_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_DIRECTION_3) typedef Direction_3_archetype Direction_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_ISO_CUBOID_3) typedef Iso_cuboid_3_archetype Iso_cuboid_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_LINE_3) typedef Line_3_archetype Line_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_RAY_3) typedef Ray_3_archetype Ray_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_SEGMENT_3) typedef Segment_3_archetype Segment_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_SPHERE_3) typedef Sphere_3_archetype Sphere_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_PLANE_3) typedef Plane_3_archetype Plane_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_TRIANGLE_3) typedef Triangle_3_archetype Triangle_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_TETRAHEDRON_3) typedef Tetrahedron_3_archetype Tetrahedron_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || defined(CGAL_CA_OBJECT_3) typedef CGAL::Object Object_3; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CARTESIAN_COORDINATE_CONST_ITERATOR_2) typedef Cartesian_coordinate_const_iterator_2_archetype Cartesian_const_iterator_2; #endif #if !defined(CGAL_CA_LIMITED_INTERFACE) || \ defined(CGAL_CA_CARTESIAN_COORDINATE_CONST_ITERATOR_3) typedef Cartesian_coordinate_const_iterator_3_archetype Cartesian_const_iterator_3; #endif // functors and access functions ... // predicate ... #define CGAL_Kernel_pred(Y,Z) typedef CGALca::Y Y; \ Y Z() const {return Y();} // accessor function ... #define CGAL_Kernel_cons(Y,Z) CGAL_Kernel_pred(Y,Z) #include }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_naive_point_location.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Pm_naive_point_locatio0000644000175000017500000002510311344301500031425 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Pm_naive_point_location.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Iddo Hanniel // Oren Nechushtan // Efi Fogel #ifndef CGAL_PM_NAIVE_POINT_LOCATION_C #define CGAL_PM_NAIVE_POINT_LOCATION_C #include CGAL_BEGIN_NAMESPACE //IMPLEMENTATION //if unbounded face - returns NULL or some edge on unbounded face //if its a vertex returns a halfedge pointing _at_ it template typename Pm_naive_point_location::Halfedge_const_handle Pm_naive_point_location::locate(const Point & p, Locate_type & lt) const { typename Planar_map::Vertex_const_iterator vit=pm->vertices_begin(); for (; vit != pm->vertices_end(); ++vit) { if (traits->point_equal(p,vit->point()) ) { lt = Planar_map::VERTEX; Halfedge_const_handle h(vit->incident_halfedges()); return h; } } typename Planar_map::Halfedge_const_iterator hit=pm->halfedges_begin(); for (; hit != pm->halfedges_end(); ++hit) { if (traits->point_in_x_range(hit->curve(),p) && traits->curve_compare_y_at_x(p, hit->curve()) == EQUAL) { lt = Planar_map::EDGE; return hit; } } lt = Planar_map::UNBOUNDED_FACE; Locate_type temp; Halfedge_const_handle h = vertical_ray_shoot(p,temp,true); if (temp != Planar_map::UNBOUNDED_FACE) { if (temp == Planar_map::VERTEX) { //since h points at the vertex and is the first //halfedge after the ray clockwise! then the face //is to its _right_ (maybe the specs will change in the future) h = h->twin(); } if (!(h->face()->is_unbounded())) lt = Planar_map::FACE; return h; } //==the vertical ray shoot returned the halfedges_end() iterator. if (pm->unbounded_face()->holes_begin() == pm->unbounded_face()->holes_end() ) //an empty map return h; //return halfedges_end() //- returns a halfedge on an inner ccb of the unbounded face typename Planar_map::Holes_iterator hot = pm->unbounded_face()->holes_begin(); return (*hot); } template typename Pm_naive_point_location::Halfedge_handle Pm_naive_point_location::locate(const Point & p, Locate_type & lt) { ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); if (!((Bounding_box*)get_bounding_box())->locate(p,lt,h)) h = Halfedge_handle_unconst(((const_Self_ptr)this)->locate(p,lt)); return h; } template typename Pm_naive_point_location::Halfedge_const_handle Pm_naive_point_location:: vertical_ray_shoot(const Point & p, Locate_type & lt, bool up) const { Comparison_result point_above_under, res; Comparison_result curve_above_under; bool in_x_range; lt = Planar_map::EDGE; // set the flags for comparison acording to the ray // direction (up/down) if (up) { point_above_under = SMALLER; curve_above_under = LARGER; } else { point_above_under = LARGER; curve_above_under = SMALLER; } typename Planar_map::Halfedge_const_iterator it = pm->halfedges_begin(), eit = pm->halfedges_end(), closest_edge = eit; bool first = false; // For each halfedge while (it != eit) { // Find if p is in the x-range of the curve and above or below it // according to the direction of the shoot. in_x_range = traits->point_in_x_range(it->curve(), p); if (in_x_range) res = traits->curve_compare_y_at_x(p, it->curve()); if (in_x_range && res == point_above_under) { // If the first curve in the x-range was not found yet if (!first) { closest_edge = it; first = true; } else { // We found another curve in the x-range and we want to remember // the closest if (traits->curves_compare_y_at_x(closest_edge->curve(), it->curve(), p) == curve_above_under) { closest_edge = it; } } } if (in_x_range && res == EQUAL && traits->curve_is_vertical(it->curve())) { // The vertical ray shoot is not including p itself, // thus we are interested only in vertical curves that // extend upwards (downwards, resp.) // In this case the Locate type is always EDGE // Remark: This treatment was originally written in the walk PL. // if (up && traits->point_is_right_top (traits->curve_righttop_most(it->curve()), p) || ! up && traits->point_is_left_low (traits->curve_leftlow_most(it->curve()), p)) /* x x | | p=x or p | x */ { lt = Planar_map::EDGE; if (up == traits->point_is_left_low(it->target()->point(), it->source()->point())) return it; else return it->twin(); } } ++it; ++it; } // if we didn't find any edge above p then it is the empty face if ( ! first) { lt = Planar_map::UNBOUNDED_FACE; Halfedge_const_handle h = pm->halfedges_end(); return h; //==NULL } // if the closest point is a vertex then find the first clockwise // edge from the vertical segment typename Planar_map::Vertex_const_handle v = pm->vertices_end(); bool maybe_vertical = false; // BUG fix (Oren) if (traits->point_equal_x(closest_edge->target()->point(), p)) { v = closest_edge->target(); maybe_vertical=true; // BUG fix (Oren) } if ( traits->point_equal_x( closest_edge->source()->point(), p) ) { if (!maybe_vertical || traits->point_is_right_top(closest_edge->target()->point(), closest_edge->source()->point())==up) // BUG fix (Oren) v = closest_edge->source(); /* special care for the vertical cases: x p | x and x | p x */ } //if (closest_is_vertex) if (v != pm->vertices_end()) { lt = Planar_map::VERTEX; closest_edge = (up) ? find_lowest(v, false) : find_lowest(v, true); } if (lt == Planar_map::VERTEX) return closest_edge; if (up) { // return the edge that is going from right to left // such that p is to the left of this edge return (traits->point_is_right(closest_edge->source()->point(), closest_edge->target()->point())) ? closest_edge : closest_edge->twin(); } return (traits->point_is_left(closest_edge->source()->point(), closest_edge->target()->point())) ? closest_edge : closest_edge->twin(); } template typename Pm_naive_point_location::Halfedge_handle Pm_naive_point_location::vertical_ray_shoot(const Point & p, Locate_type & lt, bool up) { /* Make sure the source point is in the bounding box on the output */ ((Bounding_box*)get_bounding_box())->insert(p); Halfedge_handle h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); /* Apply the bounding box on the output */ if (!((Bounding_box*)get_bounding_box())->vertical_ray_shoot(p,lt,up,h)) { h = Halfedge_handle_unconst(((const_Self_ptr)this)-> vertical_ray_shoot(p,lt,up)); CGAL_assertion(lt!=Planar_map::UNBOUNDED_FACE); } return h; } //find the first halfedge pointing at v, when going clockwise //if highest==true - start from 12 oclock, else start from 6 oclock template typename Pm_naive_point_location::Halfedge_const_handle Pm_naive_point_location:: find_lowest(typename Pm_naive_point_location::Vertex_const_handle v, bool highest) const { Halfedge_const_handle lowest_left = pm->halfedges_end(); Halfedge_const_handle lowest_right = pm->halfedges_end(); Halfedge_const_handle vertical_up = pm->halfedges_end(); Halfedge_const_handle vertical_down = pm->halfedges_end(); typename Planar_map::Halfedge_around_vertex_const_circulator first = v->incident_halfedges(); typename Planar_map::Halfedge_around_vertex_const_circulator curr = first; do { if (traits->point_is_left(curr->source()->point(), v->point())) { if (lowest_left == pm->halfedges_end()) lowest_left = curr; else if (traits->curves_compare_y_at_x_left(curr->curve(), lowest_left->curve(), v->point()) == SMALLER) lowest_left = curr; } if (traits->point_is_right(curr->source()->point(), v->point())) { if (lowest_right == pm->halfedges_end()) lowest_right = curr; else if (traits->curves_compare_y_at_x_right(curr->curve(), lowest_right->curve(), v->point()) == LARGER) lowest_right = curr; } if (traits->curve_is_vertical(curr->curve())) { if (traits->compare_xy(v->point(), curr->source()->point()) == LARGER) vertical_up=curr; if (traits->compare_xy(v->point(), curr->source()->point()) == SMALLER) vertical_down=curr; } } while (++curr != first); /* vertical_down | v <- lowest_right 'v' lowest_left-> ^ | vertical_up */ if (!highest) { if (lowest_left != pm->halfedges_end()) return lowest_left; if (vertical_down != pm->halfedges_end()) return vertical_down; return lowest_right; } if (lowest_right != pm->halfedges_end()) return lowest_right; if (vertical_up != pm->halfedges_end()) return vertical_up; return lowest_left; } CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_traits_2.0000644000175000017500000000440211344301500031115 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_circle_2_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_MIN_CIRCLE_2_TRAITS_2_H #define CGAL_MIN_CIRCLE_2_TRAITS_2_H // includes #ifndef CGAL_OPTIMISATION_CIRCLE_2_H # include #endif #ifndef CGAL_PREDICATES_ON_POINTS_2_H # include #endif CGAL_BEGIN_NAMESPACE // Class declarations // ================== template < class Traits_ > class Min_circle_2; template < class K_ > class Min_circle_2_traits_2; // Class interface and implementation // ================================== template < class K_ > class Min_circle_2_traits_2 { public: // types typedef K_ K; typedef typename K::Point_2 Point; typedef CGAL::Optimisation_circle_2 Circle; typedef typename K::Orientation_2 Orientation_2; private: // data members Circle circle; // current circle // friends friend class CGAL::Min_circle_2< CGAL::Min_circle_2_traits_2 >; public: // creation (use default implementations) // CGAL::Min_circle_2_traits_2( ); // CGAL::Min_circle_2_traits_2( CGAL::Min_circle_2_traits_2 const&); // operations inline CGAL::Orientation orientation( const Point& p, const Point& q, const Point& r) const { Orientation_2 orientation; return(orientation( p, q, r)); } }; CGAL_END_NAMESPACE #endif // CGAL_MIN_CIRCLE_2_TRAITS_2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian_matrix.h0000644000175000017500000000610611344301500030471 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian_matrix.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_CARTESIAN_MATRIX_H) #define CGAL_CARTESIAN_MATRIX_H 1 #include #include CGAL_BEGIN_NAMESPACE template < class Operation, class RandomAccessIC_row, class RandomAccessIC_column > class Cartesian_matrix { public: typedef typename Operation::result_type Value; Cartesian_matrix(RandomAccessIC_row r_f, RandomAccessIC_row r_l, RandomAccessIC_column c_f, RandomAccessIC_column c_l) : row_vec(r_f), column_vec(c_f), n_rows(r_l - r_f), n_columns(c_l - c_f) {} Cartesian_matrix(RandomAccessIC_row r_f, RandomAccessIC_row r_l, RandomAccessIC_column c_f, RandomAccessIC_column c_l, const Operation& o) : row_vec(r_f), column_vec(c_f), n_rows(r_l - r_f), n_columns(c_l - c_f), op(o) {} int number_of_rows() const { return n_rows; } int number_of_columns() const { return n_columns; } Value operator()(int r, int c) const { CGAL_optimisation_precondition(r >= 0 && r < number_of_rows()); CGAL_optimisation_precondition(c >= 0 && c < number_of_columns()); return op(row_vec[r], column_vec[c]); } protected: RandomAccessIC_row row_vec; RandomAccessIC_column column_vec; int n_rows; int n_columns; Operation op; }; // class Cartesian_matrix< ... > template < class Operation, class RandomAccessIC_row, class RandomAccessIC_column > inline Cartesian_matrix< Operation, RandomAccessIC_row, RandomAccessIC_column > cartesian_matrix( RandomAccessIC_row r_f, RandomAccessIC_row r_l, RandomAccessIC_column c_f, RandomAccessIC_column c_l, const Operation& o) { return Cartesian_matrix< Operation, RandomAccessIC_row, RandomAccessIC_column > ( r_f, r_l, c_f, c_l, o); } CGAL_END_NAMESPACE #endif // ! (CGAL_CARTESIAN_MATRIX_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_short_names_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_short0000644000175000017500000000274311344301500031476 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_short_names_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_SHORT_NAMES_2_H #define CGAL_APOLLONIUS_GRAPH_SHORT_NAMES_2_H #define Apollonius_site_2 As2 #define Apollonius_graph_2 Ag2 #define Apollonius_graph_hierarchy_2 Agh2 #define Apollonius_graph_data_structure_2 Agds2 #define Apollonius_graph_vertex_base_2 Agvb2 #define Apollonius_graph_hierarchy_vertex_base_2 Aghvb2 #define Apollonius_graph_traits_2 Agt2 #define Apollonius_graph_filtered_traits_2 Agft2 #define Apollonius_graph_traits_wrapper_2 Agtw2 #define Apollonius_graph_kernel_wrapper_2 Agkw2 #endif //CGAL_APOLLONIUS_GRAPH_SHORT_NAMES_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree_rectangle.h0000644000175000017500000001511111344301500030571 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kd_tree_rectangle.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_KD_TREE_RECTANGLE_H #define CGAL_KD_TREE_RECTANGLE_H #include #include #include #include namespace CGAL { template struct set_bounds_from_pointer : public std::unary_function { int dim; T *lower; T *upper; set_bounds_from_pointer(int d, T *l, T *u) : dim(d), lower(l), upper(u) {} void operator()(P p) { T h; typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d pit = construct_it(*p); for (int i = 0; i < dim; ++i, ++pit) { h=(*pit); if (h < lower[i]) lower[i] = h; if (h > upper[i]) upper[i] = h; } } }; template class Kd_tree_rectangle { public: typedef typename SearchTraits::FT FT; typedef FT T; private: int dim; T *lower_; T *upper_; int max_span_coord_; public: inline void set_upper_bound(int i, const FT& x) { CGAL_assertion(i >= 0 && i < dim); CGAL_assertion(x >= lower_[i]); upper_[i] = x; set_max_span(); } inline void set_lower_bound(int i, const FT& x) { CGAL_assertion(i >= 0 && i < dim); CGAL_assertion(x <= upper_[i]); lower_[i] = x; set_max_span(); } inline void set_max_span() { FT span = upper_[0]-lower_[0]; max_span_coord_ = 0; for (int i = 1; i < dim; ++i) { FT tmp = upper_[i] - lower_[i]; if (span < tmp) { span = tmp; max_span_coord_ = i; } } } Kd_tree_rectangle(int d) : dim(d), lower_(new FT[d]), upper_(new FT[d]), max_span_coord_(0) { std::fill(lower_, lower_ + dim, 0); std::fill(upper_, upper_ + dim, 0); } Kd_tree_rectangle() : dim(0), lower_(0), upper_(0) {} explicit Kd_tree_rectangle(const Kd_tree_rectangle& r) : dim(r.dim), lower_(new FT[dim]), upper_(new FT[dim]), max_span_coord_(r.max_span_coord_) { std::copy(r.lower_, r.lower_+dim, lower_); std::copy(r.upper_, r.upper_+dim, upper_); } template // was PointIter Kd_tree_rectangle(int d, PointPointerIter begin, PointPointerIter end) : dim(d), lower_(new FT[d]), upper_(new FT[d]) { // initialize with values of first point typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d bit = construct_it(**begin); for (int i=0; i < dim; ++bit, ++i){ lower_[i]=(*bit); upper_[i]=lower_[i]; } begin++; typedef typename std::iterator_traits::value_type P; std::for_each(begin, end, set_bounds_from_pointer(dim, lower_, upper_)); set_max_span(); } template void update_from_point_pointers(PointPointerIter begin, PointPointerIter end) { if (begin ==end) { // no points for (int i=0; i < dim; ++i) { lower_[i]= FT(1); upper_[i]= FT(-1); } } else { // initialize with values of first point typename SearchTraits::Construct_cartesian_const_iterator_d construct_it; typename SearchTraits::Cartesian_const_iterator_d bit = construct_it(**begin); for (int i=0; i < dim; ++i, ++bit) { lower_[i]= *bit; upper_[i]=lower_[i]; } begin++; typedef typename std::iterator_traits::value_type P; std::for_each(begin, end, set_bounds_from_pointer(dim, lower_, upper_)); } set_max_span(); } inline int max_span_coord() const { return max_span_coord_; } inline FT max_span() const { return upper_[max_span_coord_] - lower_[max_span_coord_]; } inline FT min_coord(int i) const { CGAL_assertion(lower_ != NULL); return lower_[i]; } inline FT max_coord(int i) const { return upper_[i]; } std::ostream& print(std::ostream& s) const { s << "Rectangle dimension = " << dim; s << "\n lower: "; for (int i=0; i < dim; ++i) s << lower_[i] << " "; // std::copy(lower_, lower_ + dim, // std::ostream_iterator(s," ")); s << "\n upper: "; for (int j=0; j < dim; ++j) s << upper_[j] << " "; // std::copy(upper_, upper_ + dim, // std::ostream_iterator(s," ")); s << "\n maximum span " << max_span() << " at coordinate " << max_span_coord() << std::endl; return s; } // Splits rectangle by modifying itself to lower half // and returns upper half // Kd_tree_rectangle* void split(Kd_tree_rectangle& r, int d, FT value) { CGAL_assertion(d >= 0 && d < dim); CGAL_assertion(lower_[d] <= value && value <= upper_[d]); //Kd_tree_rectangle* r = new Kd_tree_rectangle(*this); upper_[d]=value; r.lower_[d]=value; //return r; } ~Kd_tree_rectangle() { if (dim) { if (lower_) delete [] lower_; if (upper_) delete [] upper_; } } int dimension() const { return dim; } Kd_tree_rectangle& operator=(const Kd_tree_rectangle& r) { CGAL_assertion(dimension() == r.dimension()); if (this != &r) { std::copy(r.lower_, r.lower_+dim, lower_); std::copy(r.upper_, r.upper_+dim, upper_); set_max_span(); } return *this; } }; // of class Kd_tree_rectangle template std::ostream& operator<<(std::ostream& s, const Kd_tree_rectangle& r) { return r.print(s); } } // namespace CGAL #endif // CGAL_KD_TREE_RECTANGLE_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_3_center_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_3_center_20000644000175000017500000016226211344301500031266 0ustar debiandebian// Copyright (c) 1998-2003 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/rectangular_3_center_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_RECTANGULAR_3_CENTER_2_H) #define CGAL_RECTANGULAR_3_CENTER_2_H 1 #include #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif // CGAL_REP_CLASS_DEFINED #include #include CGAL_BEGIN_NAMESPACE template < class ForwardIterator, class OutputIterator, class FT, class Traits > OutputIterator rectangular_2_center_2( ForwardIterator f, ForwardIterator l, OutputIterator o, FT& r, Traits& t) { using std::pair; using std::greater; using std::less; typedef typename Traits::Iso_rectangle_2 Rectangle; typedef typename Traits::Point_2 Point; typedef typename Traits::Infinity_distance_2 Dist; typedef typename Traits::Construct_vertex_2 CVertex; typedef typename Traits::Construct_point_2_above_right_implicit_point_2 P_above_right; typedef typename Traits::Construct_point_2_above_left_implicit_point_2 P_above_left; typedef typename Traits::Construct_point_2_below_right_implicit_point_2 P_below_right; typedef typename Traits::Construct_point_2_below_left_implicit_point_2 P_below_left; typedef typename Bind< Dist, Point, 1 >::Type BDist; typedef typename Compose_shared< Min< FT >, BDist, BDist >::Type Gamma; // fetch function objects from traits class CVertex v = t.construct_vertex_2_object(); Dist dist = t.infinity_distance_2_object(); P_above_left pt_a_l = t.construct_point_2_above_left_implicit_point_2_object(); P_above_right pt_a_r = t.construct_point_2_above_right_implicit_point_2_object(); P_below_left pt_b_l = t.construct_point_2_below_left_implicit_point_2_object(); P_below_right pt_b_r = t.construct_point_2_below_right_implicit_point_2_object(); // compute bounding box Rectangle bb = bounding_box_2(f, l, t); // two cases: top-left & bottom-right or top-right & bottom-left Min< FT > minft; Gamma gamma1 = compose_shared(minft, bind_1(dist, v(bb, 0)), bind_1(dist, v(bb, 2))); Gamma gamma2 = compose_shared(minft, bind_1(dist, v(bb, 1)), bind_1(dist, v(bb, 3))); pair< ForwardIterator, ForwardIterator > cand = min_max_element(f, l, compose(greater< FT >(), gamma1, gamma1), compose(less< FT >(), gamma2, gamma2)); // return the result if (gamma1(*cand.first) < gamma2(*cand.second)) { r = gamma1(*cand.first); *o++ = pt_a_r(v(bb, 0), v(bb, 0), r / FT(2)); *o++ = pt_b_l(v(bb, 2), v(bb, 2), r / FT(2)); } else { r = gamma2(*cand.second); *o++ = pt_a_l(v(bb, 2), v(bb, 0), r / FT(2)); *o++ = pt_b_r(v(bb, 0), v(bb, 2), r / FT(2)); } return o; } template < class RandomAccessIterator, class OutputIterator, class Traits > OutputIterator rectangular_3_center_2_type1( RandomAccessIterator f, RandomAccessIterator l, const typename Traits::Iso_rectangle_2& r, OutputIterator o, typename Traits::FT& rad, Traits& t) { using std::max; using std::less; using std::nth_element; typedef typename Traits::FT FT; typedef typename Traits::Iso_rectangle_2 Rectangle; typedef typename Traits::Point_2 Point; typedef typename Traits::Infinity_distance_2 Dist; typedef typename Traits::Signed_infinity_distance_2 Sdist; typedef typename Traits::Construct_iso_rectangle_2 Rect; typedef typename Traits::Construct_vertex_2 CVertex; typedef typename Traits::Construct_point_2_above_right_implicit_point_2 P_above_right; typedef typename Traits::Construct_point_2_above_left_implicit_point_2 P_above_left; typedef typename Traits::Construct_point_2_below_right_implicit_point_2 P_below_right; typedef typename Traits::Construct_point_2_below_left_implicit_point_2 P_below_left; typedef typename Bind< Dist, Point, 1 >::Type BDist; typedef typename Compose_shared< Min< FT >, BDist, BDist >::Type Gamma; // fetch function objects from traits class Rect rect = t.construct_iso_rectangle_2_object(); CVertex v = t.construct_vertex_2_object(); Dist dist = t.infinity_distance_2_object(); Sdist sdist = t.signed_infinity_distance_2_object(); P_above_left pt_a_l = t.construct_point_2_above_left_implicit_point_2_object(); P_above_right pt_a_r = t.construct_point_2_above_right_implicit_point_2_object(); P_below_left pt_b_l = t.construct_point_2_below_left_implicit_point_2_object(); P_below_right pt_b_r = t.construct_point_2_below_right_implicit_point_2_object(); // initialize best radius so far rad = sdist(v(r, 2), v(r, 0)); // init to prevent default constructor requirement Point bestpoint = *f; // (initialisation avoids warning) unsigned int bestrun = 0; // two cases: top-left & bottom-right or top-right & bottom-left // init to prevent default constructor requirement Rectangle b = rect(*f, *f); for (unsigned int i = 0; i < 2; ++i) { // the range [s, e) defines the point set Pt RandomAccessIterator s = f; RandomAccessIterator e = l; bool b_empty = true; Min< FT > minft; Gamma gamma = compose_shared(minft, bind_1(dist, v(r, i)), bind_1(dist, v(r, 2 + i))); while (e - s > 1) { // step (a) RandomAccessIterator m = s + (e - s - 1) / 2; nth_element(s, m, e, compose(less< FT >(), gamma, gamma)); // step (b) Rectangle b_prime = bounding_box_2(m + 1, e, t); if (!b_empty) b_prime = construct_bounding_box_union_2(b, b_prime, t); // step (c) / (d) if (sdist(v(b_prime, 2), v(b_prime, 0)) > gamma(*m)) s = m + 1; else { e = m + 1; b_empty = false; b = b_prime; } } // check whether s or (s-1) is the solution Rectangle b_prime = b_empty ? rect(*s, *s) : construct_bounding_box_union_2(b, rect(*s, *s), t); FT b_prime_size = sdist(v(b_prime, 2), v(b_prime, 0)); if (b_prime_size < gamma(*s)) { if (b_prime_size < rad) { rad = b_prime_size; bestpoint = midpoint(v(b_prime, 0), v(b_prime, 2)); bestrun = i; } } else if (gamma(*s) < rad) { rad = gamma(*s); bestpoint = midpoint(v(b, 0), v(b, 2)); bestrun = i; } } // return the result *o++ = bestpoint; if (bestrun == 1) { *o++ = pt_a_l(v(r, 2), v(r, 0), rad / FT(2)); *o++ = pt_b_r(v(r, 0), v(r, 2), rad / FT(2)); } else { *o++ = pt_a_r(v(r, 0), v(r, 0), rad / FT(2)); *o++ = pt_b_l(v(r, 2), v(r, 2), rad / FT(2)); } return o; } #ifndef _MSC_VER template < class R > struct Rectangular_3_center_2_type2_operations_base { typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Iso_rectangle_2 Iso_rectangle_2; typedef typename R::Infinity_distance_2 Infinity_distance_2; typedef typename R::Less_x_2 Less_x_2; typedef typename R::Less_y_2 Less_y_2; typedef typename Swap< Less_x_2 >::Type Greater_x_2; typedef typename Swap< Less_y_2 >::Type Greater_y_2; typedef Min< Point_2, Less_x_2 > Min_x_2; typedef Max< Point_2, Less_x_2 > Max_x_2; typedef Min< Point_2, Less_y_2 > Min_y_2; typedef Max< Point_2, Less_y_2 > Max_y_2; typedef typename R::Construct_vertex_2 Construct_vertex_2; typedef typename R::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename R::Construct_point_2_above_right_implicit_point_2 Construct_point_2_above_right_implicit_point_2; typedef typename R::Construct_point_2_above_left_implicit_point_2 Construct_point_2_above_left_implicit_point_2; typedef typename R::Construct_point_2_below_right_implicit_point_2 Construct_point_2_below_right_implicit_point_2; typedef typename R::Construct_point_2_below_left_implicit_point_2 Construct_point_2_below_left_implicit_point_2; typedef typename Bind< Infinity_distance_2, Point_2, 1 >::Type Delta; Delta delta() const { return delta_; } Less_x_2 less_x_2_object() const { return r_.less_x_2_object(); } Less_y_2 less_y_2_object() const { return r_.less_y_2_object(); } Greater_x_2 greater_x_2_object() const { return swap_1(less_x_2_object()); } Greater_y_2 greater_y_2_object() const { return swap_1(less_y_2_object()); } Infinity_distance_2 distance() const { return r_.infinity_distance_2_object(); } Construct_vertex_2 construct_vertex_2_object() const { return r_.construct_vertex_2_object(); } Construct_iso_rectangle_2 construct_iso_rectangle_2_object() const { return r_.construct_iso_rectangle_2_object(); } Construct_point_2_below_left_implicit_point_2 pt_b_l() const { return r_.construct_point_2_below_left_implicit_point_2_object(); } Construct_point_2_above_left_implicit_point_2 pt_a_l() const { return r_.construct_point_2_above_left_implicit_point_2_object(); } Construct_point_2_below_right_implicit_point_2 pt_b_r() const { return r_.construct_point_2_below_right_implicit_point_2_object(); } Construct_point_2_above_right_implicit_point_2 pt_a_r() const { return r_.construct_point_2_above_right_implicit_point_2_object(); } Min_x_2 minx() const { return Min_x_2(less_x_2_object()); } Min_y_2 miny() const { return Min_y_2(less_y_2_object()); } Max_x_2 maxx() const { return Max_x_2(less_x_2_object()); } Max_y_2 maxy() const { return Max_y_2(less_y_2_object()); } private: R& r_; Delta delta_; public: Rectangular_3_center_2_type2_operations_base(R& r, const Point_2& p) : r_(r), delta_(bind_1(r.infinity_distance_2_object(), p)) {} }; template < class R > struct Rectangular_3_center_2_type2_operations0 : public Rectangular_3_center_2_type2_operations_base< R > { typedef Rectangular_3_center_2_type2_operations0< R > This; typedef Rectangular_3_center_2_type2_operations_base< R > Base; typedef typename Base::FT FT; typedef typename Base::Point_2 Point; typedef typename Base::Iso_rectangle_2 Rectangle; typedef typename Base::Less_x_2 X_compare; typedef typename Base::Greater_y_2 Y_compare; typedef typename Base::Infinity_distance_2 Distance; typedef typename Base::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename Base::Construct_vertex_2 Construct_vertex_2; using Base::less_x_2_object; using Base::greater_y_2_object; using Base::construct_iso_rectangle_2_object; using Base::construct_vertex_2_object; using Base::minx; using Base::miny; using Base::distance; using Base::pt_b_l; using Base::pt_b_r; using Base::pt_a_l; using Base::pt_a_r; Rectangular_3_center_2_type2_operations0(R& r, const Point& p) : Rectangular_3_center_2_type2_operations_base< R >(r, p) {} X_compare compare_x() const { return less_x_2_object(); } Y_compare compare_y() const { return greater_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)); return v(rect(bpt, v(bbox, 2)), 3); #else return v(rect(constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)), v(bbox, 2)), 3); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(bpt, v(bbox, 2)), 3); #else return v(rect(constraint_empty ? v(bbox, 2) : v(constraint, 0), v(bbox, 2)), 3); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(pt_b_l()(v(bbox, 2), v(bbox, 2), radius), so_far), so_far), 3); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0)); return v(rect(v(bbox, 2), bpt), 1); #else return v(rect(v(bbox, 2), constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0))), 1); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(v(bbox, 2), bpt), 1); #else return v(rect(v(bbox, 2), constraint_empty ? v(bbox, 2) : v(constraint, 0)), 1); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, miny()(pt_b_l()(v(bbox, 2), v(bbox, 2), radius), so_far)), 1); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(s, newp), s), 3); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, miny()(s, newp)), 1); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 1)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 3)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_a_r()(construct_vertex_2_object()(bbox, 0), construct_vertex_2_object()(bbox, 0), r); } Point construct_x_square(const Point& p, FT r) const { return pt_b_r()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_a_l()(p, p, r); } }; template < class R > struct Rectangular_3_center_2_type2_operations1 : public Rectangular_3_center_2_type2_operations_base< R > { typedef Rectangular_3_center_2_type2_operations_base< R > Base; typedef typename Base::FT FT; typedef typename Base::Point_2 Point; typedef typename Base::Iso_rectangle_2 Rectangle; typedef typename Base::Infinity_distance_2 Distance; typedef typename Base::Greater_x_2 X_compare; typedef typename Base::Greater_y_2 Y_compare; typedef typename Base::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename Base::Construct_vertex_2 Construct_vertex_2; using Base::greater_x_2_object; using Base::greater_y_2_object; using Base::construct_iso_rectangle_2_object; using Base::construct_vertex_2_object; using Base::maxx; using Base::miny; using Base::pt_a_r; using Base::pt_b_l; using Base::pt_a_l; using Base::distance; Rectangular_3_center_2_type2_operations1(R& r, const Point& p) : Rectangular_3_center_2_type2_operations_base< R >(r, p) {} X_compare compare_x() const { return greater_x_2_object(); } Y_compare compare_y() const { return greater_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)); return v(rect(bpt, v(bbox, 3)), 2); #else return v(rect(constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)), v(bbox, 3)), 2); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(bpt, v(bbox, 3)), 2); #else return v(rect(constraint_empty ? v(bbox, 0) : v(constraint, 2), v(bbox, 3)), 2); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(so_far, pt_a_r()(v(bbox, 0), v(bbox, 0), radius)), so_far), 2); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0)); return v(rect(v(bbox, 3), bpt), 0); #else return v(rect(v(bbox, 3), constraint_empty ? first_uncovered : miny()(first_uncovered, v(constraint, 0))), 0); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(v(bbox, 3), bpt), 0); #else return v(rect(v(bbox, 3), constraint_empty ? v(bbox, 2) : v(constraint, 0)), 0); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, miny()(so_far, pt_b_l()(v(bbox, 2), v(bbox, 2), radius))), 0); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(s, newp), s), 2); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, miny()(s, newp)), 0); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 0)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 2)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_a_l()(construct_vertex_2_object()(bbox, 2), construct_vertex_2_object()(bbox, 0), r); } Point construct_x_square(const Point& p, FT r) const { return pt_b_l()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_a_r()(p, p, r); } }; template < class R > struct Rectangular_3_center_2_type2_operations2 : public Rectangular_3_center_2_type2_operations_base< R > { typedef Rectangular_3_center_2_type2_operations_base< R > Base; typedef typename Base::FT FT; typedef typename Base::Point_2 Point; typedef typename Base::Iso_rectangle_2 Rectangle; typedef typename Base::Infinity_distance_2 Distance; typedef typename Base::Greater_x_2 X_compare; typedef typename Base::Less_y_2 Y_compare; typedef typename Base::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename Base::Construct_vertex_2 Construct_vertex_2; using Base::greater_x_2_object; using Base::less_y_2_object; using Base::construct_iso_rectangle_2_object; using Base::construct_vertex_2_object; using Base::distance; using Base::maxx; using Base::maxy; using Base::pt_a_r; using Base::pt_a_l; using Base::pt_b_r; using Base::pt_b_l; Rectangular_3_center_2_type2_operations2(R& r, const Point& p) : Rectangular_3_center_2_type2_operations_base< R >(r, p) {} X_compare compare_x() const { return greater_x_2_object(); } Y_compare compare_y() const { return less_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)); return v(rect(bpt, v(bbox, 0)), 1); #else return v(rect(constraint_empty ? first_uncovered : maxx()(first_uncovered, v(constraint, 2)), v(bbox, 0)), 1); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(bpt, v(bbox, 0)), 1); #else return v(rect(constraint_empty ? v(bbox, 0) : v(constraint, 2), v(bbox, 0)), 1); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(so_far, pt_a_r()(v(bbox, 0), v(bbox, 0), radius)), so_far), 1); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2)); return v(rect(v(bbox, 0), bpt), 3); #else return v(rect(v(bbox, 0), constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2))), 3); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(v(bbox, 0), bpt), 3); #else return v(rect(v(bbox, 0), constraint_empty ? v(bbox, 0) : v(constraint, 2)), 3); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, maxy()(pt_a_r()(v(bbox, 0), v(bbox, 0), radius), so_far)), 3); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(maxx()(s, newp), s), 1); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, maxy()(s, newp)), 3); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 3)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 1)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_b_l()(construct_vertex_2_object()(bbox, 2), construct_vertex_2_object()(bbox, 2), r); } Point construct_x_square(const Point& p, FT r) const { return pt_a_l()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_b_r()(p, p, r); } }; template < class R > struct Rectangular_3_center_2_type2_operations3 : public Rectangular_3_center_2_type2_operations_base< R > { typedef Rectangular_3_center_2_type2_operations_base< R > Base; typedef typename Base::FT FT; typedef typename Base::Point_2 Point; typedef typename Base::Iso_rectangle_2 Rectangle; typedef typename Base::Infinity_distance_2 Distance; typedef typename Base::Less_x_2 X_compare; typedef typename Base::Less_y_2 Y_compare; typedef typename Base::Construct_iso_rectangle_2 Construct_iso_rectangle_2; typedef typename Base::Construct_vertex_2 Construct_vertex_2; using Base::less_x_2_object; using Base::less_y_2_object; using Base::construct_iso_rectangle_2_object; using Base::construct_vertex_2_object; using Base::distance; using Base::minx; using Base::maxy; using Base::pt_b_l; using Base::pt_b_r; using Base::pt_a_r; Rectangular_3_center_2_type2_operations3(R& r, const Point& p) : Rectangular_3_center_2_type2_operations_base< R >(r, p) {} X_compare compare_x() const { return less_x_2_object(); } Y_compare compare_y() const { return less_y_2_object(); } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)); return v(rect(bpt, v(bbox, 1)), 0); #else return v(rect(constraint_empty ? first_uncovered : minx()(first_uncovered, v(constraint, 0)), v(bbox, 1)), 0); #endif } Point place_x_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 2) : v(constraint, 0); return v(rect(bpt, v(bbox, 1)), 0); #else return v(rect(constraint_empty ? v(bbox, 2) : v(constraint, 0), v(bbox, 1)), 0); #endif } Point place_x_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(pt_b_l()(v(bbox, 2), v(bbox, 2), radius), so_far), so_far), 0); } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Point& first_uncovered, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2)); return v(rect(v(bbox, 1), bpt), 2); #else return v(rect(v(bbox, 1), constraint_empty ? first_uncovered : maxy()(first_uncovered, v(constraint, 2))), 2); #endif } Point place_y_square(bool constraint_empty, const Rectangle& constraint, const Rectangle& bbox) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); #if defined(__BORLANDC__) || defined(__SUNPRO_CC) Point bpt = constraint_empty ? v(bbox, 0) : v(constraint, 2); return v(rect(v(bbox, 1), bpt), 2); #else return v(rect(v(bbox, 1), constraint_empty ? v(bbox, 0) : v(constraint, 2)), 2); #endif } Point place_y_square(const Point& so_far, const Rectangle& bbox, FT radius) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(so_far, maxy()(pt_a_r()(v(bbox, 0), v(bbox, 0), radius), so_far)), 2); } Point update_x_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(minx()(s, newp), s), 0); } Point update_y_square(const Point& s, const Point& newp) const { Construct_iso_rectangle_2 rect = construct_iso_rectangle_2_object(); Construct_vertex_2 v = construct_vertex_2_object(); return v(rect(s, maxy()(s, newp)), 2); } FT compute_x_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 2)); } FT compute_y_distance(const Point& extreme, const Rectangle& constraint) const { return distance()(extreme, construct_vertex_2_object()(constraint, 0)); } Point construct_corner_square(const Rectangle& bbox, FT r) const { return pt_b_r()(construct_vertex_2_object()(bbox, 0), construct_vertex_2_object()(bbox, 2), r); } Point construct_x_square(const Point& p, FT r) const { return pt_a_r()(p, p, r); } Point construct_y_square(const Point& p, FT r) const { return pt_b_l()(p, p, r); } }; #else #include #endif // _MSC_VER template < class RandomAccessIterator, class Rectangle, class OutputIterator, class FT, class Operations > OutputIterator rectangular_3_center_2_type2( RandomAccessIterator f, RandomAccessIterator l, const Rectangle& r, OutputIterator o, FT& rad, Operations op) { using std::max; using std::less; using std::greater; using std::greater_equal; using std::not_equal_to; using std::logical_and; using std::max_element; using std::nth_element; using std::find_if; using std::sort; using std::partition; using std::pair; typedef typename Operations::Point Point; typedef typename Operations::Distance Distance; typedef pair< RandomAccessIterator, RandomAccessIterator > IP; typename Operations::Construct_iso_rectangle_2 rect = op.construct_iso_rectangle_2_object(); typename Operations::Construct_vertex_2 v = op.construct_vertex_2_object(); typename Operations::Less_x_2 less_x_2 = op.less_x_2_object(); typename Operations::Less_y_2 less_y_2 = op.less_y_2_object(); // constant fraction to be excluded on every iteration (1/.) const unsigned int fraction = 7; // the range [s, e) defines the point set P RandomAccessIterator s = f; RandomAccessIterator e = l; // a flag to indicate whether we need to search the radius // in the final brute-force step or not bool radius_is_known = false; // the bounding boxes of assigned points Rectangle Q_t, Q_r; bool Q_t_empty = true, Q_r_empty = true; // lower bound for the diameter (2 * radius) // also store the corresponding positions of q_t and q_r FT rho_max = 0, rho_min = -1, q_t_q_r_cover_at_rho_min = 0; Point q_t_at_rho_max, q_r_at_rho_max, q_t_at_rho_min, q_r_at_rho_min; RandomAccessIterator s_at_rho_min = s, e_at_rho_min = s; #ifndef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST { // First try whether the best radius so far can be reached at all RandomAccessIterator m = partition(f, l, compose(bind_1(greater< FT >(), rad), op.delta())); IP pos = min_max_element(m, l, op.compare_x(), op.compare_y()); // extreme points of the two other squares Point q_t = op.place_x_square(op.place_x_square(Q_t_empty, Q_t, *pos.first, r), r, rad); Point q_r = op.place_y_square(op.place_y_square(Q_r_empty, Q_r, *pos.second, r), r, rad); typename Bind< greater_equal< FT >, FT, 1 >::Type le_rad = bind_1(greater_equal< FT >(), rad); RandomAccessIterator b1 = partition(m, l, compose(le_rad, bind_1(op.distance(), q_t))); RandomAccessIterator b2 = partition(b1, l, compose(le_rad, bind_1(op.distance(), q_r))); if (b2 != l) return o; } #endif // ! CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST #ifndef CGAL_3COVER_NO_PREFILTER // Prefiltering heuristic while (e - s > 6) { int cutoff = (e - s) / 2; RandomAccessIterator m = s + cutoff - 1; nth_element(s, m, e, compose(less< FT >(), op.delta(), op.delta())); // step (b) IP pos = min_max_element(m + 1, e, op.compare_x(), op.compare_y()); // extreme points of the two other squares // (consider Q_i and pos [move as far as possible]) Point q_t_afap = op.place_x_square(Q_t_empty, Q_t, *pos.first, r); Point q_r_afap = op.place_y_square(Q_r_empty, Q_r, *pos.second, r); // now consider also that we must not leave the bbox r Point q_t = op.place_x_square(q_t_afap, r, op.delta()(*m)); Point q_r = op.place_y_square(q_r_afap, r, op.delta()(*m)); // check for covering typename Bind< greater_equal< FT >, FT, 1 >::Type le_delta_m(bind_1(greater_equal< FT >(), op.delta()(*m))); RandomAccessIterator b1 = partition(m + 1, e, compose(le_delta_m, bind_1(op.distance(), q_t))); RandomAccessIterator b2 = partition(b1, e, compose(le_delta_m, bind_1(op.distance(), q_r))); if (b2 != e) s = m; else break; } #endif // ! CGAL_3COVER_NO_PREFILTER while (e - s > 6) { /* cerr << e - s << " points (" << e - s - (e - s) / fraction << ")" << endl; */ // step (a) int cutoff = (e - s) / fraction; RandomAccessIterator m = s + cutoff - 1; nth_element(s, m, e, compose(less< FT >(), op.delta(), op.delta())); // step (b) IP pos = min_max_element(m + 1, e, op.compare_x(), op.compare_y()); // extreme points of the two other squares // (consider Q_i and pos [move as far as possible]) Point q_t_afap = op.place_x_square(Q_t_empty, Q_t, *pos.first, r); Point q_r_afap = op.place_y_square(Q_r_empty, Q_r, *pos.second, r); // now consider also that we must not leave the bbox r Point q_t = op.place_x_square(q_t_afap, r, op.delta()(*m)); Point q_r = op.place_y_square(q_r_afap, r, op.delta()(*m)); #ifdef CGAL_3COVER_CHECK // check whether the points in [e,l) which have been assigned // to Q_t and Q_r are covered by q_t and q_r if ((Q_t_empty || op.compute_x_distance(q_t, Q_t) <= op.delta()(*m)) && (Q_r_empty || op.compute_y_distance(q_r, Q_r) <= op.delta()(*m))) { typename Bind< less< FT >, FT, 1 >::Type greater_delta_m(bind_1(less< FT >(), op.delta()(*m))); CGAL_optimisation_assertion_code(RandomAccessIterator iii =) find_if(e, l, compose_shared(logical_and< bool >(), compose(greater_delta_m, bind_1(op.distance(), q_t)), compose(greater_delta_m, bind_1(op.distance(), q_r)))); CGAL_optimisation_assertion(iii == l); } // check whether the points in [f,s) are covered { typename Bind< greater_equal< FT >, FT, 1 >::Type le_delta_m(bind_1(greater_equal< FT >(), op.delta()(*m))); RandomAccessIterator iii = partition(f, s, compose(le_delta_m, op.delta())); iii = partition(iii, s, compose(le_delta_m, bind_1(op.distance(), q_t))); iii = partition(iii, s, compose(le_delta_m, bind_1(op.distance(), q_r))); CGAL_optimisation_assertion(iii == s); } #endif // CGAL_3COVER_CHECK // partition the range [m+1, e) into ranges // [m+1, b1), [b1, b2), [b2, b3) and [b3, e) // R G cap q_t G cap q_r none typename Bind< greater_equal< FT >, FT, 1 >::Type le_delta_m(bind_1(greater_equal< FT >(), op.delta()(*m))); RandomAccessIterator b2 = partition(m + 1, e, compose(le_delta_m, bind_1(op.distance(), q_t))); RandomAccessIterator b1 = partition(m + 1, b2, compose(le_delta_m, bind_1(op.distance(), q_r))); RandomAccessIterator b3 = partition(b2, e, compose(le_delta_m, bind_1(op.distance(), q_r))); // step (c) if (b3 != e || !Q_t_empty && op.compute_x_distance(q_t, Q_t) > op.delta()(*m) || !Q_r_empty && op.compute_y_distance(q_r, Q_r) > op.delta()(*m)) { // not covered s = b1; rho_min = op.delta()(*m); q_t_q_r_cover_at_rho_min = 0; if (!Q_t_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_x_distance(q_t, Q_t)); if (!Q_r_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_y_distance(q_r, Q_r)); q_t_at_rho_min = q_t, q_r_at_rho_min = q_r; s_at_rho_min = s, e_at_rho_min = e; continue; } // step (d) [covered] if (b3 - b1 >= cutoff) { // enough points in G e = b1; // adjust Q_t if (b1 != b2) if (Q_t_empty) { Q_t = bounding_box_2(b1, b2, op); Q_t_empty = false; } else Q_t = construct_bounding_box_union_2( Q_t, bounding_box_2(b1, b2, op), op); // adjust Q_r if (b2 != b3) if (Q_r_empty) { Q_r = bounding_box_2(b2, b3, op); Q_r_empty = false; } else Q_r = construct_bounding_box_union_2( Q_r, bounding_box_2(b2, b3, op), op); continue; } // step (e) [not enough points in G] CGAL_optimisation_assertion(b1 - (m + 1) >= 5 * cutoff); // compute the four cutting lines for R nth_element(m + 1, m + 1 + cutoff, b1, less_x_2); Point x_min_cutoff = *(m + 1 + cutoff); nth_element(m + 1, m + 1 + cutoff, b1, op.greater_x_2_object()); Point x_max_cutoff = *(m + 1 + cutoff); nth_element(m + 1, m + 1 + cutoff, b1, less_y_2); Point y_min_cutoff = *(m + 1 + cutoff); nth_element(m + 1, m + 1 + cutoff, b1, op.greater_y_2_object()); Point y_max_cutoff = *(m + 1 + cutoff); Point Pmin = v(rect(x_min_cutoff, y_min_cutoff), less_x_2(x_min_cutoff, y_min_cutoff) ? less_y_2(x_min_cutoff, y_min_cutoff) ? 3 : 0 : less_y_2(x_min_cutoff, y_min_cutoff) ? 2 : 1); Point Pmax = v(rect(x_max_cutoff, y_max_cutoff), less_x_2(x_max_cutoff, y_max_cutoff) ? less_y_2(x_max_cutoff, y_max_cutoff) ? 1 : 2 : less_y_2(x_max_cutoff, y_max_cutoff) ? 0 : 3); Rectangle B = rect(Pmin, Pmax); // Algorithm search_E: // the range [s_b, s_e) defines the point set S RandomAccessIterator s_b = s; RandomAccessIterator s_e = m + 1; while (s_e - s_b > 1) { // step 1 RandomAccessIterator s_m = s_b + (s_e - s_b - 1) / 2; nth_element(s_b, s_m, s_e, compose(less< FT >(), op.delta(), op.delta())); // step 2 (as above) Point q_t_m = q_t_afap; Point q_r_m = q_r_afap; if (s_m + 1 != s_e) { pos = min_max_element(s_m + 1, s_e, op.compare_x(), op.compare_y()); q_t_m = op.update_x_square(q_t_m, *pos.first); q_r_m = op.update_y_square(q_r_m, *pos.second); } // step 3/4 if (op.compute_x_distance( op.place_x_square(q_t_m, r, op.delta()(*s_m)), B) <= op.delta()(*s_m) && op.compute_y_distance( op.place_y_square(q_r_m, r, op.delta()(*s_m)), B) <= op.delta()(*s_m)) { s_e = s_m + 1; q_t_afap = q_t_m; q_r_afap = q_r_m; } else s_b = s_m + 1; } // now s_b corresponds to the first moment in [s, m+1) // where q_t and q_r cover B // place q_t and q_r q_t = op.place_x_square(q_t_afap, r, op.delta()(*s_b)); q_r = op.place_y_square(q_r_afap, r, op.delta()(*s_b)); // partition the range [s_b+1, e) into ranges // [s_b+1, b1), [b1, b2), [b2, b3) and [b3, e) // R G cap q_t G cap q_r none typename Bind< greater_equal< FT >, FT, 1 >::Type le_delta_sb = bind_1(greater_equal< FT >(), op.delta()(*s_b)); b2 = partition(s_b + 1, e, compose(le_delta_sb, bind_1(op.distance(), q_t))); b1 = partition(s_b + 1, b2, compose(le_delta_sb, bind_1(op.distance(), q_r))); b3 = partition(b2, e, compose(le_delta_sb, bind_1(op.distance(), q_r))); if (b3 != e || !Q_t_empty && op.compute_x_distance(q_t, Q_t) > op.delta()(*s_b) || !Q_r_empty && op.compute_y_distance(q_r, Q_r) > op.delta()(*s_b)) { // no covering CGAL_optimisation_assertion(b1 - s >= cutoff); s = b1; rho_min = op.delta()(*s_b); q_t_at_rho_min = q_t, q_r_at_rho_min = q_r; q_t_q_r_cover_at_rho_min = 0; if (!Q_t_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_x_distance(q_t, Q_t)); if (!Q_r_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_y_distance(q_r, Q_r)); s_at_rho_min = s, e_at_rho_min = e; continue; } // we still have a covering if (s_b == s) { CGAL_optimisation_expensive_assertion_code( std::vector< Point > tmppts(f, l); RandomAccessIterator ii = partition(tmppts.begin(), tmppts.end(), compose(le_delta_sb, op.delta())); IP tmppos = min_max_element(ii, tmppts.end(), op.compare_x(), op.compare_y()); ) CGAL_optimisation_expensive_assertion( !op.compare_x()(*tmppos.first, q_t)); CGAL_optimisation_expensive_assertion( !op.compare_y()(q_r, *tmppos.second)); // we are done rho_max = op.delta()(*s); q_t_at_rho_max = q_t, q_r_at_rho_max = q_r; radius_is_known = true; break; } // if there are enough points in G ... if (b3 - b1 >= cutoff) { e = b1; // adjust Q_t if (b1 != b2) if (Q_t_empty) { Q_t = bounding_box_2(b1, b2, op); Q_t_empty = false; } else Q_t = construct_bounding_box_union_2( Q_t, bounding_box_2(b1, b2, op), op); // adjust Q_r if (b2 != b3) if (Q_r_empty) { Q_r = bounding_box_2(b2, b3, op); Q_r_empty = false; } else Q_r = construct_bounding_box_union_2( Q_r, bounding_box_2(b2, b3, op), op); continue; } // we have to take the next smaller radius RandomAccessIterator next = max_element_if(s, s_b, compose(less< FT >(), op.delta(), op.delta()), compose(bind_1(not_equal_to< FT >(), op.delta()(*s_b)), op.delta())); rho_max = op.delta()(*s_b); q_t_at_rho_max = q_t, q_r_at_rho_max = q_r; CGAL_optimisation_assertion(op.delta()(*next) < op.delta()(*s_b)); q_t_afap = op.update_x_square(q_t_afap, *s_b); q_r_afap = op.update_y_square(q_r_afap, *s_b); q_t = op.place_x_square(q_t_afap, r, op.delta()(*next)); q_r = op.place_y_square(q_r_afap, r, op.delta()(*next)); // again check for covering typename Bind< greater_equal< FT >, FT, 1 >::Type le_delta_next = bind_1(greater_equal< FT >(), op.delta()(*next)); b2 = partition(s_b, e, compose(le_delta_next, bind_1(op.distance(), q_t))); b1 = partition(s_b, b2, compose(le_delta_next, bind_1(op.distance(), q_r))); b3 = partition(b2, e, compose(le_delta_next, bind_1(op.distance(), q_r))); if (b3 != e || !Q_t_empty && op.compute_x_distance(q_t, Q_t) > op.delta()(*next) || !Q_r_empty && op.compute_y_distance(q_r, Q_r) > op.delta()(*next)) { // no covering rho_min = op.delta()(*next); q_t_q_r_cover_at_rho_min = 0; if (!Q_t_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_x_distance(q_t, Q_t)); if (!Q_r_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_y_distance(q_r, Q_r)); q_t_at_rho_min = q_t, q_r_at_rho_min = q_r; s_at_rho_min = b3, e_at_rho_min = e; radius_is_known = true; break; } CGAL_optimisation_assertion(b3 - b1 >= cutoff); e = b1; // adjust Q_t if (b1 != b2) if (Q_t_empty) { Q_t = bounding_box_2(b1, b2, op); Q_t_empty = false; } else Q_t = construct_bounding_box_union_2( Q_t, bounding_box_2(b1, b2, op), op); // adjust Q_r if (b2 != b3) if (Q_r_empty) { Q_r = bounding_box_2(b2, b3, op); Q_r_empty = false; } else Q_r = construct_bounding_box_union_2( Q_r, bounding_box_2(b2, b3, op), op); } // while (e - s > 6) // compute the solution brute-force if (!radius_is_known) { RandomAccessIterator t = e; Point q_t_afap = op.place_x_square(Q_t_empty, Q_t, r); Point q_r_afap = op.place_y_square(Q_r_empty, Q_r, r); if (s != e) { sort(s, e, compose(less< FT >(), op.delta(), op.delta())); rho_max = op.delta()(*--t); } else rho_max = rho_min; Point q_t = op.place_x_square(q_t_afap, r, rho_max); Point q_r = op.place_y_square(q_r_afap, r, rho_max); if (!Q_t_empty && op.compute_x_distance(q_t, Q_t) > rho_max || !Q_r_empty && op.compute_y_distance(q_r, Q_r) > rho_max) { rho_max = max(op.compute_x_distance(q_t, Q_t), op.compute_y_distance(q_r, Q_r)); #ifndef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST CGAL_optimisation_assertion(rho_max <= rad); #endif // ! CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rad = rho_max; *o++ = op.construct_corner_square(r, rad / FT(2)); *o++ = op.construct_x_square(q_t, rad / FT(2)); *o++ = op.construct_y_square(q_r, rad / FT(2)); return o; } CGAL_optimisation_assertion(s != e); // find the first diameter where covering is possible for (;;) { q_t_at_rho_max = q_t, q_r_at_rho_max = q_r; if (t == s) break; // these get uncovered now do { q_t_afap = op.update_x_square(q_t_afap, *t); q_r_afap = op.update_y_square(q_r_afap, *t); } while (t != s && op.delta()(*--t) == rho_max); // try the next possible diameter value FT try_rho = op.delta()(*t); CGAL_optimisation_assertion(t == s || try_rho < rho_max); q_t = op.place_x_square(q_t_afap, r, try_rho); q_r = op.place_y_square(q_r_afap, r, try_rho); // check for covering typename Bind< less< FT >, FT, 1 >::Type greater_rho_max(bind_1(less< FT >(), try_rho)); if (!Q_t_empty && op.compute_x_distance(q_t, Q_t) > try_rho || !Q_r_empty && op.compute_y_distance(q_r, Q_r) > try_rho || e != find_if( t + 1, e, compose_shared(logical_and< bool >(), compose(greater_rho_max, bind_1(op.distance(), q_t)), compose(greater_rho_max, bind_1(op.distance(), q_r))))) { rho_min = try_rho; q_t_q_r_cover_at_rho_min = 0; if (!Q_t_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_x_distance(q_t, Q_t)); if (!Q_r_empty) q_t_q_r_cover_at_rho_min = max(q_t_q_r_cover_at_rho_min, op.compute_y_distance(q_r, Q_r)); q_t_at_rho_min = q_t, q_r_at_rho_min = q_r; s_at_rho_min = t + 1, e_at_rho_min = e; break; } rho_max = try_rho; } // for (;;) } // if (!radius_is_known) // now we have the following: // rho_min corresponds to a non-covering with // - q_t_at_rho_min is the corr. position of q_t, // - q_r_at_rho_min is the corr. position of q_r and // - q_t_q_r_cover_at_rho_min is the radius needed to // cover Q_t and Q_r // - the range [s_at_rho_min, e_at_rho_min) contains the points // still to be covered // rho_max corresponds to a covering with // - q_t_at_rho_max is the corr. position of q_t and // - q_r_at_rho_max is the corr. position of q_r. // try rho_min CGAL_optimisation_assertion(rho_min <= rho_max); CGAL_optimisation_assertion(rho_min >= 0); FT rad2 = q_t_q_r_cover_at_rho_min; typedef typename Bind< Distance, Point, 1 >::Type Dist_bind; if (s_at_rho_min != e_at_rho_min) { typename Compose_shared< Min< FT >, Dist_bind, Dist_bind >::Type mydist(compose_shared(Min< FT >(), bind_1(op.distance(), q_t_at_rho_min), bind_1(op.distance(), q_r_at_rho_min))); rad2 = max( rad2, mydist(*max_element(s_at_rho_min, e_at_rho_min, compose(less< FT >(), mydist, mydist)))); } CGAL_optimisation_assertion(rad2 == 0 || rad2 > rho_min); // if a covering with rho == 0 is possible, // it will be catched in the type1 functions Point q_t, q_r; if (rad2 > rho_max || rho_min == -1) { // it is rho_max ... q_t = q_t_at_rho_max, q_r = q_r_at_rho_max; rad2 = rho_max; } else q_t = q_t_at_rho_min, q_r = q_r_at_rho_min; #ifndef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST CGAL_optimisation_assertion(rad2 <= rad); #endif // ! CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rad = rad2; *o++ = op.construct_corner_square(r, rad / FT(2)); *o++ = op.construct_x_square(q_t, rad / FT(2)); *o++ = op.construct_y_square(q_r, rad / FT(2)); return o; } // rectangular_3_center_2_type2( ... ) template < class ForwardIterator, class OutputIterator, class Traits > OutputIterator rectangular_3_center_2( ForwardIterator f, ForwardIterator l, OutputIterator o, typename Traits::FT& r, Traits& t) { CGAL_optimisation_precondition(f != l); typedef typename Traits::FT FT; typedef typename Traits::Point_2 Point; typedef typename Traits::Iso_rectangle_2 Rectangle; typedef Rectangular_3_center_2_type2_operations0< Traits > Op0; typedef Rectangular_3_center_2_type2_operations1< Traits > Op1; typedef Rectangular_3_center_2_type2_operations2< Traits > Op2; typedef Rectangular_3_center_2_type2_operations3< Traits > Op3; std::vector< Point > points(f, l); Rectangle bb = bounding_box_2(points.begin(), points.end(), t); // try to place two squares at opposite corners of bb Point ptst[3]; rectangular_3_center_2_type1( points.begin(), points.end(), bb, ptst, r, t); // try to place one square at a corner and the others // at the two remaining sides of bb Point pts0[3]; Point pts1[3]; Point pts2[3]; Point pts3[3]; Point* pts = ptst; FT rmin = r; rectangular_3_center_2_type2( points.begin(), points.end(), bb, pts0, r, Op0(t, bb[0])); if (r < rmin) pts = pts0, rmin = r; #ifdef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST else r = rmin; #endif // CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rectangular_3_center_2_type2( points.begin(), points.end(), bb, pts1, r, Op1(t, bb[1])); if (r < rmin) pts = pts1, rmin = r; #ifdef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST else r = rmin; #endif // CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rectangular_3_center_2_type2( points.begin(), points.end(), bb, pts2, r, Op2(t, bb[2])); if (r < rmin) pts = pts2, rmin = r; #ifdef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST else r = rmin; #endif // CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST rectangular_3_center_2_type2( points.begin(), points.end(), bb, pts3, r, Op3(t, bb[3])); if (r < rmin) pts = pts3; #ifdef CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST else r = rmin; #endif // CGAL_3COVER_NO_CHECK_OPTIMUM_FIRST *o++ = pts[0]; *o++ = pts[1]; *o++ = pts[2]; return o; } // rectangular_3_center_2( ... ) CGAL_END_NAMESPACE #endif // ! (CGAL_RECTANGULAR_3_CENTER_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_list.h0000644000175000017500000007126711344301500030167 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/HalfedgeDS_list.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_HALFEDGEDS_LIST_H #define CGAL_HALFEDGEDS_LIST_H 1 #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < class VertexBase> class HalfedgeDS_in_place_list_vertex : public VertexBase, public In_place_list_base< HalfedgeDS_in_place_list_vertex< VertexBase> > { public: typedef HalfedgeDS_in_place_list_vertex< VertexBase> Self; typedef typename VertexBase::Vertex_handle Vertex_handle; typedef typename VertexBase::Vertex_const_handle Vertex_const_handle; HalfedgeDS_in_place_list_vertex() {} HalfedgeDS_in_place_list_vertex( const VertexBase& v) // down cast : VertexBase(v) {} Self& operator=( const Self& v) { // This self written assignment avoids that assigning vertices will // overwrite the list linking of the target vertex. *((VertexBase*)this) = ((const VertexBase&)v); return *this; } }; template < class HalfedgeBase> class HalfedgeDS_in_place_list_halfedge : public HalfedgeBase, public In_place_list_base< HalfedgeDS_in_place_list_halfedge< HalfedgeBase> > { public: typedef HalfedgeDS_in_place_list_halfedge< HalfedgeBase> Self; typedef typename HalfedgeBase::Halfedge_handle Halfedge_handle; typedef typename HalfedgeBase::Halfedge_const_handle Halfedge_const_handle; HalfedgeDS_in_place_list_halfedge() {} // down cast HalfedgeDS_in_place_list_halfedge( const HalfedgeBase& h) : HalfedgeBase(h) {} Self& operator=( const Self& h) { // This self written assignment avoids that assigning halfedges will // overwrite the list linking of the target halfedge. *((HalfedgeBase*)this) = ((const HalfedgeBase&)h); return *this; } }; template < class FaceBase> class HalfedgeDS_in_place_list_face : public FaceBase, public In_place_list_base< HalfedgeDS_in_place_list_face< FaceBase> > { public: typedef HalfedgeDS_in_place_list_face< FaceBase> Self; typedef typename FaceBase::Face_handle Face_handle; typedef typename FaceBase::Face_const_handle Face_const_handle; HalfedgeDS_in_place_list_face() {} // down cast HalfedgeDS_in_place_list_face( const FaceBase& f) : FaceBase(f) {} Self& operator=( const Self& f) { // This self written assignment avoids that assigning faces will // overwrite the list linking of the target face. *((FaceBase*)this) = ((const FaceBase&)f); // this->FaceBase::operator=(f); // does not compile on SGI return *this; } }; template < class Traits_, class HalfedgeDSItems, class Alloc> class HalfedgeDS_list_types { public: typedef HalfedgeDS_list_types Self; typedef Traits_ Traits; typedef HalfedgeDSItems Items; typedef Alloc Allocator; typedef Alloc allocator_type; typedef typename Items::template Vertex_wrapper Vertex_wrapper; typedef typename Items::template Halfedge_wrapper Halfedge_wrapper; typedef typename Items::template Face_wrapper Face_wrapper; typedef typename Vertex_wrapper::Vertex Vertex_base; typedef HalfedgeDS_in_place_list_vertex< Vertex_base> Vertex; typedef typename Halfedge_wrapper::Halfedge Halfedge_base; typedef HalfedgeDS_in_place_list_halfedge< Halfedge_base> Halfedge; typedef typename Face_wrapper::Face Face_base; typedef HalfedgeDS_in_place_list_face< Face_base> Face; typedef typename Allocator::template rebind< Vertex> Vertex_alloc_rebind; typedef typename Vertex_alloc_rebind::other Vertex_allocator; typedef typename Allocator::template rebind< Halfedge> Halfedge_alloc_rebind; typedef typename Halfedge_alloc_rebind::other Halfedge_allocator; typedef typename Allocator::template rebind< Face> Face_alloc_rebind; typedef typename Face_alloc_rebind::other Face_allocator; typedef In_place_list Vertex_list; typedef typename Vertex_list::iterator Vertex_handle; typedef typename Vertex_list::const_iterator Vertex_const_handle; typedef typename Vertex_list::iterator Vertex_iterator; typedef typename Vertex_list::const_iterator Vertex_const_iterator; typedef In_place_list Halfedge_list; typedef typename Halfedge_list::iterator Halfedge_handle; typedef typename Halfedge_list::const_iterator Halfedge_const_handle; typedef typename Halfedge_list::iterator Halfedge_iterator; typedef typename Halfedge_list::const_iterator Halfedge_const_iterator; typedef In_place_list Face_list; typedef typename Face_list::iterator Face_handle; typedef typename Face_list::const_iterator Face_const_handle; typedef typename Face_list::iterator Face_iterator; typedef typename Face_list::const_iterator Face_const_iterator; typedef typename Halfedge_list::size_type size_type; typedef typename Halfedge_list::difference_type difference_type; typedef std::bidirectional_iterator_tag iterator_category; static inline Vertex_handle vertex_handle( Vertex_base* v) { Vertex* vv = 0; vv = (Vertex*)((char*) v - (std::ptrdiff_t)((Vertex_base*)vv)); return vv; } static inline Vertex_const_handle vertex_handle( const Vertex_base* v) { const Vertex* vv = 0; vv = (const Vertex*)((const char*) v - (std::ptrdiff_t)((const Vertex_base*)vv)); return vv; } static inline Halfedge_handle halfedge_handle( Halfedge_base* h) { Halfedge* hh = 0; hh = (Halfedge*)((char*) h - (std::ptrdiff_t)((Halfedge_base*)hh)); return hh; } static inline Halfedge_const_handle halfedge_handle( const Halfedge_base* h) { const Halfedge* hh = 0; hh = (const Halfedge*)((const char*) h - (std::ptrdiff_t)((const Halfedge_base*)hh)); return hh; } static inline Face_handle face_handle( Face_base* f) { Face* ff = 0; ff = (Face*)((char*) f - (std::ptrdiff_t)((Face_base*)ff)); return ff; } static inline Face_const_handle face_handle( const Face_base* f) { const Face* ff = 0; ff = (const Face*)((const char*)f - (std::ptrdiff_t)((const Face_base*)ff)); return ff; } }; #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM template < class Traits_, class HalfedgeDSItems, class Alloc = CGAL_ALLOCATOR(int)> class HalfedgeDS_list : public HalfedgeDS_list_types { public: typedef HalfedgeDS_list Self; #else struct HalfedgeDS_list { template < class Traits_, class HalfedgeDSItems, class Alloc = CGAL_ALLOCATOR(int)> class HDS : public HalfedgeDS_list_types { public: typedef HDS Self; #endif public: typedef HalfedgeDS_list_types Types; typedef typename Types::Traits Traits; typedef typename Types::Items Items; typedef typename Types::Allocator Allocator; typedef typename Types::allocator_type allocator_type; typedef typename Types::Vertex Vertex; typedef typename Types::Halfedge Halfedge; typedef typename Types::Face Face; typedef typename Types::Vertex_allocator Vertex_allocator; typedef typename Types::Vertex_list Vertex_list; typedef typename Types::Vertex_handle Vertex_handle; typedef typename Types::Vertex_const_handle Vertex_const_handle; typedef typename Types::Vertex_iterator Vertex_iterator; typedef typename Types::Vertex_const_iterator Vertex_const_iterator; typedef typename Types::Halfedge_allocator Halfedge_allocator; typedef typename Types::Halfedge_list Halfedge_list; typedef typename Types::Halfedge_handle Halfedge_handle; typedef typename Types::Halfedge_const_handle Halfedge_const_handle; typedef typename Types::Halfedge_iterator Halfedge_iterator; typedef typename Types::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Types::Face_allocator Face_allocator; typedef typename Types::Face_list Face_list; typedef typename Types::Face_handle Face_handle; typedef typename Types::Face_const_handle Face_const_handle; typedef typename Types::Face_iterator Face_iterator; typedef typename Types::Face_const_iterator Face_const_iterator; typedef typename Types::size_type size_type; typedef typename Types::difference_type difference_type; typedef typename Types::iterator_category iterator_category; typedef Tag_true Supports_removal; typedef typename Vertex::Supports_vertex_halfedge Supports_vertex_halfedge; typedef typename Halfedge::Supports_halfedge_prev Supports_halfedge_prev; typedef typename Halfedge::Supports_halfedge_vertex Supports_halfedge_vertex; typedef typename Halfedge::Supports_halfedge_face Supports_halfedge_face; typedef typename Face::Supports_face_halfedge Supports_face_halfedge; // Halfedges are allocated in pairs. Here is the type for that. typedef std::pair Halfedge_pair; typedef typename Allocator::template rebind< Halfedge_pair> Edge_alloc_rebind; typedef typename Edge_alloc_rebind::other Edge_allocator; protected: // Changed from static to local variable Vertex_allocator vertex_allocator; Edge_allocator edge_allocator; // allocates pairs of halfedges Face_allocator face_allocator; Vertex* get_vertex_node( const Vertex& t) { Vertex* p = vertex_allocator.allocate(1); vertex_allocator.construct(p, t); return p; } void put_vertex_node( Vertex* p) { vertex_allocator.destroy( p); vertex_allocator.deallocate( p, 1); } Halfedge* get_edge_node( const Halfedge& h, const Halfedge& g) { // creates a new pair of opposite border halfedges. Halfedge_pair* hpair = edge_allocator.allocate(1); edge_allocator.construct(hpair, Halfedge_pair( h, g)); Halfedge* h2 = &(hpair->first); Halfedge* g2 = &(hpair->second); CGAL_assertion( h2 == (Halfedge*)hpair); CGAL_assertion( g2 == h2 + 1); h2->HBase_base::set_opposite(g2); g2->HBase_base::set_opposite(h2); return h2; } void put_edge_node( Halfedge* h) { // deletes the pair of opposite halfedges h and h->opposite(). Halfedge_handle g = h->opposite(); Halfedge_pair* hpair = (Halfedge_pair*)(&*h); if ( &*h > &*g) hpair = (Halfedge_pair*)(&*g); CGAL_assertion( &(hpair->first) == (Halfedge*)hpair); edge_allocator.destroy( hpair); edge_allocator.deallocate( hpair, 1); } Face* get_face_node( const Face& t) { Face* p = face_allocator.allocate(1); face_allocator.construct(p, t); return p; } void put_face_node( Face* p) { face_allocator.destroy( p); face_allocator.deallocate( p, 1); } typedef typename Vertex::Base VBase; typedef typename Halfedge::Base HBase; typedef typename Halfedge::Base_base HBase_base; typedef typename Face::Base FBase; Vertex_list vertices; Halfedge_list halfedges; Face_list faces; size_type nb_border_halfedges; size_type nb_border_edges; Halfedge_iterator border_halfedges; // CREATION private: void pointer_update( const Self& hds) { // Update own pointers assuming that they lived previously // in a halfedge data structure `hds' with lists. // Update own pointers assuming that they lived previously // in a halfedge data structure `hds' with lists. typedef Unique_hash_map< Vertex_const_iterator, Vertex_iterator> V_map; typedef Unique_hash_map< Halfedge_const_iterator, Halfedge_iterator> H_map; typedef Unique_hash_map< Face_const_iterator, Face_iterator> F_map; // initialize maps. H_map h_map( hds.halfedges_begin(), hds.halfedges_end(), halfedges_begin(), Halfedge_iterator(), 3 * hds.size_of_halfedges() / 2); Vertex_iterator vii; V_map v_map( vii, 3 * hds.size_of_vertices() / 2); Face_iterator fii; F_map f_map( fii, 3 * hds.size_of_faces() / 2); // some special values h_map[Halfedge_const_iterator()] = Halfedge_iterator(); h_map[hds.halfedges_end()] = halfedges_end(); v_map[Vertex_const_iterator()] = Vertex_iterator(); v_map[hds.vertices_end()] = vertices_end(); f_map[Face_const_iterator()] = Face_iterator(); f_map[hds.faces_end()] = faces_end(); // vertices and faces are optional if ( check_tag( Supports_halfedge_vertex())) { v_map.insert( hds.vertices_begin(), hds.vertices_end(), vertices_begin()); } if ( check_tag( Supports_halfedge_face())) { f_map.insert( hds.faces_begin(), hds.faces_end(), faces_begin()); } HalfedgeDS_items_decorator D; for (Halfedge_iterator h = halfedges_begin(); h!=halfedges_end(); ++h){ h->HBase::set_next( h_map[ h->next()]); // Superfluous and false: opposite pointer get set upon creation // h->HBase_base::set_opposite( h_map[ h->opposite()]); if ( check_tag( Supports_halfedge_prev())) D.set_prev( h, h_map[ D.get_prev(h)]); if ( check_tag( Supports_halfedge_vertex())) D.set_vertex( h, v_map[ D.get_vertex(h)]); if ( check_tag( Supports_halfedge_face())) D.set_face( h, f_map[ D.get_face(h)]); } border_halfedges = h_map[ border_halfedges]; if (check_tag( Supports_vertex_halfedge())) { for (Vertex_iterator v = vertices_begin(); v != vertices_end();++v) D.set_vertex_halfedge(v, h_map[ D.get_vertex_halfedge(v)]); } if (check_tag( Supports_face_halfedge())) { for ( Face_iterator f = faces_begin(); f != faces_end(); ++f) D.set_face_halfedge(f, h_map[ D.get_face_halfedge(f)]); } //h_map.statistics(); //v_map.statistics(); //f_map.statistics(); } public: #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM HalfedgeDS_list() : nb_border_halfedges(0), nb_border_edges(0) {} // the empty polyhedron `P'. HalfedgeDS_list( size_type, size_type, size_type) : nb_border_halfedges(0), nb_border_edges(0) {} // Parameter order is v,h,f. // a polyhedron `P' with storage reserved for v vertices, h // halfedges, and f faces. The reservation sizes are a hint for // optimizing storage allocation. They are not used here. ~HalfedgeDS_list() { clear(); } HalfedgeDS_list( const Self& hds) #else HDS() : nb_border_halfedges(0), nb_border_edges(0) {} HDS( size_type, size_type, size_type) : nb_border_halfedges(0), nb_border_edges(0) {} ~HDS() { clear(); } HDS( const Self& hds) #endif // CGAL_CFG_NO_TMPL_IN_TMPL_PARAM // : vertices( hds.vertices), //halfedges( hds.halfedges), faces( hds.faces), nb_border_halfedges( hds.nb_border_halfedges), nb_border_edges( hds.nb_border_edges), border_halfedges( hds.border_halfedges) { // goal is halfedges = hds.halfedges, but we have pairs here Halfedge_const_iterator i = hds.halfedges_begin(); for ( ; i != hds.halfedges_end(); ++ ++ i) { edges_push_back( *i); } pointer_update( hds); } Self& operator=( const Self& hds) { if ( this != &hds) { clear(); vertices = hds.vertices; // goal is halfedges = hds.halfedges, but we have pairs here halfedges = Halfedge_list(); Halfedge_const_iterator i = hds.halfedges_begin(); for ( ; i != hds.halfedges_end(); ++ ++ i) { edges_push_back( *i); } faces = hds.faces; nb_border_halfedges = hds.nb_border_halfedges; nb_border_edges = hds.nb_border_edges; border_halfedges = hds.border_halfedges; pointer_update( hds); } return *this; } void reserve( size_type, size_type, size_type) {} // Parameter order is v,h,f. // reserve storage for v vertices, h halfedges, and f faces. The // reservation sizes are a hint for optimizing storage allocation. // If the `capacity' is already greater than the requested size // nothing happens. If the `capacity' changes all iterators and // circulators invalidates. The function is void here. // Access Member Functions allocator_type get_allocator() const { return allocator_type(); } size_type size_of_vertices() const { return vertices.size();} size_type size_of_halfedges() const { return halfedges.size();} // number of all halfedges (including border halfedges). size_type size_of_faces() const { return faces.size();} size_type capacity_of_vertices() const { return vertices.max_size();} size_type capacity_of_halfedges() const { return halfedges.max_size();} size_type capacity_of_faces() const { return faces.max_size();} std::size_t bytes() const { return sizeof(Self) + vertices.size() * sizeof( Vertex) + halfedges.size() * sizeof( Halfedge) + faces.size() * sizeof( Face); } std::size_t bytes_reserved() const { return bytes();} Vertex_iterator vertices_begin() { return vertices.begin();} Vertex_iterator vertices_end() { return vertices.end();} Halfedge_iterator halfedges_begin() { return halfedges.begin();} Halfedge_iterator halfedges_end() { return halfedges.end();} Face_iterator faces_begin() { return faces.begin();} Face_iterator faces_end() { return faces.end();} // The constant iterators and circulators. Vertex_const_iterator vertices_begin() const{ return vertices.begin();} Vertex_const_iterator vertices_end() const{ return vertices.end();} Halfedge_const_iterator halfedges_begin() const{ return halfedges.begin();} Halfedge_const_iterator halfedges_end() const{ return halfedges.end();} Face_const_iterator faces_begin() const{ return faces.begin();} Face_const_iterator faces_end() const{ return faces.end();} // Insertion // // The following operations simply allocate a new element of that type. // Halfedges are always allocated in pairs of opposite halfedges. The // opposite pointers are automatically set. Vertex_handle vertices_push_back( const Vertex& v) { vertices.push_back( * get_vertex_node(v)); Vertex_handle vh = vertices.end(); return --vh; } Halfedge_handle edges_push_back( const Halfedge& h, const Halfedge& g) { // creates a new pair of opposite border halfedges. Halfedge* ptr = get_edge_node( h, g); halfedges.push_back( *ptr); Halfedge_handle hh = halfedges.end(); --hh; halfedges.push_back( *(ptr->opposite())); return hh; } Halfedge_handle edges_push_back( const Halfedge& h) { CGAL_precondition( h.opposite() != Halfedge_const_handle()); return edges_push_back( h, *(h.opposite())); } Face_handle faces_push_back( const Face& f) { faces.push_back( * get_face_node(f)); Face_handle fh = faces.end(); return --fh; } // Removal // // The following operations erase an element referenced by a handle. // Halfedges are always deallocated in pairs of opposite halfedges. Erase // of single elements is optional. The deletion of all is mandatory. void vertices_pop_front() { Vertex* v = &(vertices.front()); vertices.pop_front(); put_vertex_node( v); } void vertices_pop_back() { Vertex* v = &(vertices.back()); vertices.pop_back(); put_vertex_node( v); } void vertices_erase( Vertex_handle v) { Vertex* ptr = &*v; vertices.erase(v); put_vertex_node( ptr); } void vertices_erase( Vertex_iterator first, Vertex_iterator last) { while (first != last) vertices_erase(first++); } void edges_erase( Halfedge_handle h) { // deletes the pair of opposite halfedges h and h->opposite(). Halfedge_handle g = h->opposite(); halfedges.erase(h); halfedges.erase(g); put_edge_node(&*h); } void edges_pop_front() { edges_erase( halfedges.begin()); } void edges_pop_back() { Halfedge_iterator h = halfedges.end(); edges_erase( --h); } void edges_erase( Halfedge_iterator first, Halfedge_iterator last) { while (first != last) { Halfedge_iterator nxt = first; ++nxt; CGAL_assertion( nxt != last); ++nxt; edges_erase(first); first = nxt; } } void faces_pop_front() { Face* f = &(faces.front()); faces.pop_front(); put_face_node( f); } void faces_pop_back() { Face* f = &(faces.back()); faces.pop_back(); put_face_node( f); } void faces_erase( Face_handle f) { Face* ptr = &*f; faces.erase(f); put_face_node( ptr); } void faces_erase( Face_iterator first, Face_iterator last) { while (first != last) faces_erase(first++); } void vertices_clear() { vertices.destroy(); } void edges_clear() { edges_erase( halfedges.begin(), halfedges.end()); nb_border_halfedges = 0; nb_border_edges = 0; border_halfedges = Halfedge_handle(); } void faces_clear() { faces.destroy(); } void clear() { vertices_clear(); edges_clear(); faces_clear(); } // Operations with Border Halfedges size_type size_of_border_halfedges() const { return nb_border_halfedges;} // number of border halfedges. An edge with no incident face // counts as two border halfedges. Precondition: `normalize_border()' // has been called and no halfedge insertion or removal and no // change in border status of the halfedges have occured since // then. size_type size_of_border_edges() const { return nb_border_edges;} // number of border edges. If `size_of_border_edges() == // size_of_border_halfedges()' all border edges are incident to a // face on one side and to a hole on the other side. // Precondition: `normalize_border()' has been called and no // halfedge insertion or removal and no change in border status of // the halfedges have occured since then. Halfedge_iterator border_halfedges_begin() { // halfedge iterator starting with the border edges. The range [ // `halfedges_begin(), border_halfedges_begin()') denotes all // non-border edges. The range [`border_halfedges_begin(), // halfedges_end()') denotes all border edges. Precondition: // `normalize_border()' has been called and no halfedge insertion // or removal and no change in border status of the halfedges have // occured since then. return border_halfedges; } Halfedge_const_iterator border_halfedges_begin() const { return border_halfedges; } void normalize_border() { // sorts halfedges such that the non-border edges precedes the // border edges. For each border edge that is incident to a face // the halfedge iterator will reference the halfedge incident to // the face right before the halfedge incident to the hole. CGAL_assertion_code( size_type count = halfedges.size();) nb_border_halfedges = 0; nb_border_edges = 0; Halfedge_list border; Halfedge_iterator i = halfedges_begin(); while ( i != halfedges_end()) { Halfedge_iterator j = i; ++i; ++i; Halfedge_iterator k = j; ++k; if ( j->is_border()) { nb_border_halfedges++; nb_border_edges++; if (k->is_border()) nb_border_halfedges++; border.splice( border.end(), halfedges, k); border.splice( border.end(), halfedges, j); } else if ( k->is_border()) { nb_border_halfedges++; nb_border_edges++; border.splice( border.end(), halfedges, j); border.splice( border.end(), halfedges, k); } else { CGAL_assertion_code( count -= 2;) } } CGAL_assertion( count == 2 * nb_border_edges ); CGAL_assertion( count == border.size()); if ( i == halfedges_begin()) { halfedges.splice( halfedges.end(), border); i = halfedges_begin(); } else { --i; --i; CGAL_assertion( ! i->is_border() && ! i->opposite()->is_border()); halfedges.splice( halfedges.end(), border); ++i; ++i; } CGAL_assertion( i == halfedges_end() || i->opposite()->is_border()); border_halfedges = i; } }; #ifdef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM }; #endif // #ifndef CGAL_CFG_NO_TMPL_IN_TMPL_PARAM // #define CGAL__HDS_IP_List HalfedgeDS_list // #else // #define CGAL__HDS_IP_List HalfedgeDS_list::HDS // #endif // init static member allocator objects (no longer static) //template < class Traits_, class HalfedgeDSItems, class Alloc> //typename CGAL__HDS_IP_List::Vertex_allocator //CGAL__HDS_IP_List::vertex_allocator; // //template < class Traits_, class HalfedgeDSItems, class Alloc> //typename CGAL__HDS_IP_List::Edge_allocator //CGAL__HDS_IP_List::edge_allocator; // //template < class Traits_, class HalfedgeDSItems, class Alloc> //typename CGAL__HDS_IP_List::Face_allocator //CGAL__HDS_IP_List::face_allocator; // #undef CGAL__HDS_IP_List CGAL_END_NAMESPACE #endif // CGAL_HALFEDGEDS_LIST_H // // EOF // ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_items.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_items.0000644000175000017500000000333011344301501031333 0ustar debiandebian// Copyright (c) 2001 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Topological_map_items.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Shai Hirsch #ifndef CGAL_TOPOLOGICAL_MAP_ITEMS_H #define CGAL_TOPOLOGICAL_MAP_ITEMS_H 1 #ifndef CGAL_HALFEDGEDS_VERTEX_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_HALFEDGE_BASE_H #include #endif #ifndef CGAL_HALFEDGEDS_FACE_BASE_H #include #endif CGAL_BEGIN_NAMESPACE class Topological_map_items { public: template < class Refs, class Traits > struct Vertex_wrapper { typedef typename Traits::Point_2 Point; typedef HalfedgeDS_vertex_base< Refs, Tag_true, Point > Vertex; }; template < class Refs, class Traits> struct Halfedge_wrapper { typedef typename Traits::X_curve X_curve; typedef HalfedgeDS_halfedge_base< Refs > Halfedge; }; template < class Refs, class Triats> struct Face_wrapper { typedef Topological_map_face_list_base< Refs > Face; }; }; CGAL_END_NAMESPACE #endif // CGAL_TOPOLOGICAL_MAP_ITEMS_H // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/point_generators_3.h0000644000175000017500000001467211344301500031007 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/point_generators_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_POINT_GENERATORS_3_H #define CGAL_POINT_GENERATORS_3_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template < class P, class Creator = Creator_uniform_3::Kernel::RT,P> > class Random_points_in_sphere_3 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_in_sphere_3 This; Random_points_in_sphere_3( double r = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed in the open sphere with radius r, i.e. |`*g'| < r . // Three random numbers are needed from `rnd' for each point. : Random_generator_base

    ( r, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_in_sphere_3:: generate_point() { typedef typename Creator::argument_type T; do { Creator creator; this->d_item = creator( T(this->d_range * ( 2 * this->_rnd.get_double() - 1.0)), T(this->d_range * ( 2 * this->_rnd.get_double() - 1.0)), T(this->d_range * ( 2 * this->_rnd.get_double() - 1.0))); } while (CGAL::to_double(this->d_item.x() * this->d_item.x() + this->d_item.y() * this->d_item.y() + this->d_item.z() * this->d_item.z()) >= this->d_range * this->d_range); } template < class P, class Creator = Creator_uniform_3::Kernel::RT,P> > class Random_points_on_sphere_3 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_on_sphere_3 This; Random_points_on_sphere_3( double r = 1, Random& rnd = default_random) // g is an input iterator creating points of type `P' uniformly // distributed on the circle with radius r, i.e. |`*g'| == r . A // single random number is needed from `rnd' for each point. : Random_generator_base

    ( r, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_on_sphere_3:: generate_point() { typedef typename Creator::argument_type T; double alpha = this->_rnd.get_double() * 2.0 * CGAL_PI; double z = 2 * this->_rnd.get_double() - 1.0; double r = std::sqrt( 1 - z * z); Creator creator; this->d_item = creator( T(this->d_range * r * CGAL_CLIB_STD::cos(alpha)), T(this->d_range * r * CGAL_CLIB_STD::sin(alpha)), T(this->d_range * z)); } template < class P, class Creator = Creator_uniform_3::Kernel::RT,P> > class Random_points_in_cube_3 : public Random_generator_base

    { void generate_point(); public: typedef Random_points_in_cube_3 This; Random_points_in_cube_3( double a = 1, Random& rnd = default_random) : Random_generator_base

    ( a, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P, class Creator > void Random_points_in_cube_3:: generate_point() { typedef typename Creator::argument_type T; Creator creator; this->d_item = creator( T(this->d_range * ( 2 * this->_rnd.get_double() - 1.0)), T(this->d_range * ( 2 * this->_rnd.get_double() - 1.0)), T(this->d_range * ( 2 * this->_rnd.get_double() - 1.0))); } template OutputIterator points_on_cube_grid_3( double a, std::size_t n, OutputIterator o, Creator creator) { if (n == 0) return o; int m = int(CGAL_CLIB_STD::ceil( std::sqrt(std::sqrt(static_cast(n))))); while (m*m*m < int(n)) m++; double base = -a; // Left and bottom boundary. double step = 2*a/(m-1); int j = 0; int k = 0; double px = base; double py = base; double pz = base; *o++ = creator( px, py, pz); for (std::size_t i = 1; i < n; i++) { j++; if ( j == m) { k++; if ( k == m) { py = base; px = base; pz = pz + step; k = 0; } else { px = base; py = py + step; } j = 0; } else { px = px + step; } *o++ = creator( px, py, pz); } return o; } template OutputIterator points_on_cube_grid_3( double a, std::size_t n, OutputIterator o) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type P; return points_on_square_grid_3(a, n, o, Creator_uniform_3::Kernel::RT,P>()); } CGAL_END_NAMESPACE #endif // CGAL_POINT_GENERATORS_3_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Enum_converter.h0000644000175000017500000000331611344301500030167 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Enum_converter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_ENUM_CONVERTER_H #define CGAL_ENUM_CONVERTER_H #include #include CGAL_BEGIN_NAMESPACE struct Enum_converter { bool operator()(bool b) const { return b; } Sign operator()(Sign s) const { return s; } Oriented_side operator()(Oriented_side os) const { return os; } Bounded_side operator()(Bounded_side bs) const { return bs; } Comparison_result operator()(Comparison_result cr) const { return cr; } Angle operator()(Angle a) const { return a; } }; CGAL_END_NAMESPACE #endif // CGAL_ENUM_CONVERTER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3.h0000644000175000017500000000436711344301501027173 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangle_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Andreas Fabri, Stefan Schirra #ifndef CGAL_TRIANGLE_3_H #define CGAL_TRIANGLE_3_H CGAL_BEGIN_NAMESPACE template class Triangle_3 : public R_::Kernel_base::Triangle_3 { typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Kernel_base::Triangle_3 RTriangle_3; public: typedef R_ R; Triangle_3() {} Triangle_3(const RTriangle_3& t) : RTriangle_3(t) {} Triangle_3(const Point_3& p, const Point_3& q, const Point_3& r) : RTriangle_3(p,q,r) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_TRIANGLE_3 template < class R > std::ostream& operator<<(std::ostream& os, const Triangle_3& t) { typedef typename R::Kernel_base::Triangle_3 RTriangle_3; return os << static_cast(t); } #endif // CGAL_NO_OSTREAM_INSERT_TRIANGLE_3 #ifndef CGAL_NO_ISTREAM_EXTRACT_TRIANGLE_3 template < class R > std::istream& operator>>(std::istream& is, Triangle_3& t) { typedef typename R::Kernel_base::Triangle_3 RTriangle_3; return is >> static_cast(t); } #endif // CGAL_NO_ISTREAM_EXTRACT_TRIANGLE_3 CGAL_END_NAMESPACE #endif // CGAL_TRIANGLE_3_H ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Iso_rectangle_2_intersection.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Iso_re0000644000175000017500000000720311344301500031244 0ustar debiandebian // Copyright (c) 2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Iso_rectangle_2_Iso_rectangle_2_intersection.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_ISO_RECTANGLE_2_ISO_RECTANGLE_2_INTERSECTION_H #define CGAL_ISO_RECTANGLE_2_ISO_RECTANGLE_2_INTERSECTION_H #include #include CGAL_BEGIN_NAMESPACE namespace CGALi { template Object intersection( const typename CGAL_WRAP(K)::Iso_rectangle_2 &irect1, const typename CGAL_WRAP(K)::Iso_rectangle_2 &irect2, const K&) { typename K::Construct_point_2 construct_point_2; typename K::Construct_object_2 construct_object; typename K::Construct_iso_rectangle_2 construct_iso_rectangle_2; const typename K::Point_2 &min1 = irect1.min(); const typename K::Point_2 &min2 = irect2.min(); const typename K::Point_2 &max1 = irect1.max(); const typename K::Point_2 &max2 = irect2.max(); typename K::FT minx, miny, maxx, maxy; typename K::Point_2 newmin; typename K::Point_2 newmax; minx = (min1.x() >= min2.x()) ? min1.x() : min2.x(); maxx = (max1.x() <= max2.x()) ? max1.x() : max2.x(); if (maxx < minx) return Object(); miny = (min1.y() >= min2.y()) ? min1.y() : min2.y(); maxy = (max1.y() <= max2.y()) ? max1.y() : max2.y(); if (maxy < miny) return Object(); if (K::FT_denominator(minx) == K::FT_denominator(miny)) { newmin = construct_point_2(K::FT_numerator(minx), K::FT_numerator(miny), K::FT_denominator(minx)); } else { newmin = construct_point_2(K::FT_numerator(minx)*K::FT_denominator(miny), K::FT_numerator(miny)*K::FT_denominator(minx), K::FT_denominator(minx) * K::FT_denominator(miny)); } if (K::FT_denominator(maxx) == K::FT_denominator(maxy)) { newmax = construct_point_2(K::FT_numerator(maxx), K::FT_numerator(maxy), K::FT_denominator(maxx)); } else { newmax = construct_point_2(K::FT_numerator(maxx)*K::FT_denominator(maxy), K::FT_numerator(maxy)*K::FT_denominator(maxx), K::FT_denominator(maxx) * K::FT_denominator(maxy)); } return construct_object(construct_iso_rectangle_2(newmin, newmax)); } } // namespace CGALi template inline Object intersection( const Iso_rectangle_2 &irect1, const Iso_rectangle_2 &irect2) { typedef typename K::Intersect_2 Intersect; return Intersect()(irect1, irect2); } template inline bool do_intersect( const Iso_rectangle_2 &irect1, const Iso_rectangle_2 &irect2) { Object obj(intersection(irect1, irect2)); typename K::Iso_rectangle_2 irect; return (assign(irect, obj)); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ch_melkman.h0000644000175000017500000000324211344301500027270 0ustar debiandebian// Copyright (c) 1999 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ch_melkman.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Lutz Kettner #ifndef CGAL_CH_MELKMAN_H #define CGAL_CH_MELKMAN_H #include #include CGAL_BEGIN_NAMESPACE template OutputIterator ch_melkman( InputIterator first, InputIterator last, OutputIterator result, const Traits& ch_traits); template OutputIterator ch_melkman( InputIterator first, InputIterator last, OutputIterator result) { typedef std::iterator_traits ITraits; typedef typename ITraits::value_type value_type; typedef CGAL::Kernel_traits KTraits; typedef typename KTraits::Kernel Kernel; return ch_melkman( first, last, result, Kernel()); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_CH_MELKMAN_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_debug_traits_2.h0000644000175000017500000003127311344301500030700 0ustar debiandebian// ====================================================================== // // Copyright (c) 1997 The CGAL Consortium // // This software and related documentation is part of an INTERNAL release // of the Computational Geometry Algorithms Library (CGAL). It is not // intended for general use. // // ---------------------------------------------------------------------- // // release : $$ // release_date : $$ // // file : include/CGAL/Arr_debug_traits_2.h // package : Arrangement (5.87) // maintainer : Efi Fogel // source : // revision : // revision_date : // author(s) : Ron Wein // // coordinator : Tel-Aviv University (Dan Halperin ) // // Chapter : // ====================================================================== #ifndef CGAL_ARR_DEBUG_TRAITS_2_H #define CGAL_ARR_DEBUG_TRAITS_2_H #include CGAL_BEGIN_NAMESPACE /*! * A traits class for debugging a generic traits class. */ template class Arr_debug_traits_2 { private: Base_traits_ base; mutable std::ostream& os; public: typedef Base_traits_ Base_traits; typedef typename Base_traits::Has_left_category Has_left_category; typedef CGAL::Tag_false Has_reflect_category; typedef typename Base_traits::Point_2 Point_2; typedef typename Base_traits::X_monotone_curve_2 X_monotone_curve_2; typedef typename Base_traits::Curve_2 Curve_2; // For backward compatability: typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef X_monotone_curve_2 Curve; /*! * Default constructor. */ Arr_debug_traits_2() : base(), os(std::cout) {} /*! * Constructor with an output file. */ Arr_debug_traits_2 (std::ostream& _os) : base(), os(_os) {} /*! * Compare the x-coordinates of two given points. * \param p1 The first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL. */ Comparison_result compare_x (const Point_2& p1, const Point_2& p2) const { Comparison_result res = base.compare_x (p1, p2); os << "compare_x (" << p1 << " ," << '\t' << p2 << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Compares lexigoraphically the two points: by x, then by y. * \param p1 Te first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL. */ Comparison_result compare_xy (const Point_2& p1, const Point_2& p2) const { Comparison_result res = base.compare_xy (p1, p2); os << "compare_xy (" << p1 << " ," << '\t' << p2 << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Check whether the given curve is a vertical segment. * \param cv The curve. * \return (true) if the curve is vertical. */ bool curve_is_vertical(const X_monotone_curve_2& cv) const { bool res = base.curve_is_vertical (cv); os << "curve_is_vertical (" << cv << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Check whether the given point is in the x-range of the given curve. * \param cv The curve. * \param q The point. * \return (true) if q is in the x-range of cv. */ bool point_in_x_range (const X_monotone_curve_2& cv, const Point_2& q) const { bool res = base.point_in_x_range (cv, q); os << "point_in_x_range (" << cv << " ," << '\t' << q << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Get the relative status of two curves at the x-coordinate of a given * point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x-range of the two curves. * \return LARGER if cv1(x(q)) > cv2(x(q)); SMALLER if cv1(x(q)) < cv2(x(q)); * or else EQUAL. */ Comparison_result curves_compare_y_at_x (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& q) const { Comparison_result res = base.curves_compare_y_at_x (cv1, cv2, q); os << "curves_compare_y_at_x (" << cv1 << " ," << '\t' << cv2 << " ," << '\t' << q << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Compares the y value of two curves immediately to the left of the * x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its left. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the left of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_left (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& q) const { Comparison_result res = base.curves_compare_y_at_x_left (cv1, cv2, q); os << "curves_compare_y_at_x_left (" << cv1 << " ," << '\t' << cv2 << " ," << '\t' << q << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Compares the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its right. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the right of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_right (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& q) const { Comparison_result res = base.curves_compare_y_at_x_right (cv1, cv2, q); os << "curves_compare_y_at_x_right (" << cv1 << " ," << '\t' << cv2 << " ," << '\t' << q << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Return the location of the given point with respect to the input curve. * \param cv The curve. * \param p The point. * \pre p is in the x-range of cv. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x (const Point_2& p, const X_monotone_curve_2& cv) const { Comparison_result res = base.curve_compare_y_at_x (p, cv); os << "curve_compare_y_at_x (" << p << " ," << '\t' << cv << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Check if the two curves are the same (have the same graph). * \param cv1 The first curve. * \param cv2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2) const { bool res = base.curve_equal (cv1, cv2); os << "curve_equal (" << cv1 << " ," << '\t' << cv2 << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal (const Point_2& p1, const Point_2& p2) const { bool res = base.point_equal (p1, p2); os << "point_equal (" << p1 << " ," << '\t' << p2 << ")" << std::endl; os << "-> " << res << std::endl; return (res); } /*! * Get the curve source. * \param cv The curve. * \return The source point. */ Point_2 curve_source (const X_monotone_curve_2& cv) const { Point_2 p = base.curve_source (cv); os << "curve_source (" << cv << ")" << std::endl; os << "-> " << p << std::endl; return (p); } /*! * Get the curve target. * \param cv The curve. * \return The target point. */ Point_2 curve_target(const X_monotone_curve_2& cv) const { Point_2 p = base.curve_target (cv); os << "curve_target (" << cv << ")" << std::endl; os << "-> " << p << std::endl; return (p); } /*! * Cut the given curve into x-monotone subcurves and insert them to the * given output iterator. * \param cv The curve. * \param o The output iterator * \return The past-the-end iterator */ template OutputIterator curve_make_x_monotone (const Curve_2& cv, OutputIterator oi) const { std::list xcvs; typename std::list::const_iterator it; base.curve_make_x_monotone (cv, std::back_inserter(xcvs)); os << "curve_make_x_monotone (" << cv << ")" << std::endl; for (it = xcvs.begin(); it != xcvs.end(); ++it) { os << (it == xcvs.begin() ? "-> " : " ") << *it << std::endl; *oi++ = *it; } return (oi); } /*! * Split a given curve at a given split point into two sub-curves. * \param cv The curve to split * \param c1 The output first part of the split curve. * Its source will be the source of the original curve. * \param c2 The output second part of the split curve. * Its target will be the target of the original curve. * \param p The split point. * \pre p lies on cv but is not one of its endpoints. */ void curve_split (const X_monotone_curve_2& cv, X_monotone_curve_2& c1, X_monotone_curve_2& c2, const Point_2& p) const { base.curve_split (cv, c1, c2, p); os << "curve_split (" << cv << " ," << '\t' << p << ")" << std::endl; os << "-> " << c1 << std::endl << " " << c2 << std::endl; return; } /*! * Find the nearest intersection point (or points) of two given curves to * the right lexicographically of a given reference point. */ CGAL::Object nearest_intersection_to_right (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& p) const { CGAL::Object res = base.nearest_intersection_to_right (cv1, cv2, p); Point_2 ip; X_monotone_curve_2 icv; os << "nearest_intersection_to_right (" << cv1 << " ," << '\t' << cv2 << " ," << '\t' << p << ")" << std::endl; if (res.is_empty()) { os << "-> NONE!" << std::endl; } else if (CGAL::assign (ip, res)) { os << "-> " << ip << std::endl; } else if (CGAL::assign (icv, res)) { os << "-> " << icv << std::endl; } else { os << "-> ERROR!" << std::endl; } return (res); } /*! * Find the nearest intersection point (or points) of two given curves to * the left lexicographically of a given reference point. */ CGAL::Object nearest_intersection_to_left (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& p) const { CGAL::Object res = base.nearest_intersection_to_left (cv1, cv2, p); Point_2 ip; X_monotone_curve_2 icv; os << "nearest_intersection_to_left (" << cv1 << " ," << '\t' << cv2 << " ," << '\t' << p << ")" << std::endl; if (res.is_empty()) { os << "-> NONE!" << std::endl; } else if (CGAL::assign (ip, res)) { os << "-> " << ip << std::endl; } else if (CGAL::assign (icv, res)) { os << "-> " << icv << std::endl; } else { os << "-> ERROR!" << std::endl; } return (res); } /*! * Check whether the two given curves overlap. * \patam cv1 The first curve. * \patam cv2 The second curve. * \return (true) if the two curves overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, if they have a finite * number of intersection points, or none at all, return (false). */ bool curves_overlap (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2) const { bool res = base.curves_overlap (cv1, cv2); os << "curves_overlap (" << cv1 << " ," << '\t' << cv2 << std::endl; os << "-> " << res << std::endl; return (res); } }; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_plus_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulat0000644000175000017500000004441711344301500031460 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Constrained_triangulation_plus_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_CONSTRAINED_TRIANGULATION_PLUS_2_H #define CGAL_CONSTRAINED_TRIANGULATION_PLUS_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE // Tr the base triangulation class // Tr has to be Constrained or Constrained_Delaunay template < class Tr > class Constrained_triangulation_plus_2 : public Tr { public: typedef Tr Triangulation; typedef typename Tr::Intersection_tag Intersection_tag; typedef Constrained_triangulation_plus_2 Self; typedef typename Triangulation::Edge Edge; typedef typename Triangulation::Vertex Vertex; typedef typename Triangulation::Vertex_handle Vertex_handle; typedef typename Triangulation::Face_handle Face_handle; typedef typename Triangulation::Vertex_iterator Vertex_iterator; typedef typename Triangulation::Locate_type Locate_type; typedef typename Triangulation::Line_face_circulator Line_face_circulator; typedef typename Triangulation::Geom_traits Geom_traits; typedef typename Geom_traits::Point_2 Point; typedef typename Geom_traits::Segment_2 Segment; typedef typename Triangulation::Constraint Constraint; typedef typename Triangulation::size_type size_type; typedef typename Triangulation::List_edges List_edges; typedef typename Triangulation::List_faces List_faces; typedef typename Triangulation::List_vertices List_vertices; typedef typename Triangulation::List_constraints List_constraints; typedef Constraint_hierarchy_2 Constraint_hierarchy; typedef Tag_true Constraint_hierarchy_tag; // for user interface with the constraint hierarchy typedef typename Constraint_hierarchy::H_vertex_it Vertices_in_constraint_iterator; typedef typename Constraint_hierarchy::H_context Context; typedef typename Constraint_hierarchy::H_context_iterator Context_iterator; typedef typename Constraint_hierarchy::H_c_iterator Constraint_iterator; typedef typename Constraint_hierarchy::H_sc_iterator Subconstraint_iterator; //for backward compatibility typedef Vertices_in_constraint_iterator Vertices_in_constraint; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Triangulation::geom_traits; using Triangulation::cw; using Triangulation::ccw; using Triangulation::number_of_vertices; using Triangulation::vertices_begin; #endif protected: Constraint_hierarchy hierarchy; public: Constrained_triangulation_plus_2(const Geom_traits& gt=Geom_traits()) : Triangulation(gt) { } Constrained_triangulation_plus_2(const Self& ctp) : Triangulation() { copy(ctp);} virtual ~Constrained_triangulation_plus_2() {} Constrained_triangulation_plus_2 & operator=(const Self& ctp); Constrained_triangulation_plus_2(List_constraints& lc, const Geom_traits& gt=Geom_traits()) : Triangulation(gt) { typename List_constraints::iterator lcit=lc.begin(); for( ;lcit != lc.end(); lcit++) { insert_constraint( (*lcit).first, (*lcit).second); } CGAL_triangulation_postcondition( this->is_valid() ); } template Constrained_triangulation_plus_2(InputIterator first, InputIterator last, const Geom_traits& gt=Geom_traits() ) : Triangulation(gt) { while( first != last){ insert_constraint((*first).first, (*first).second); ++first; } CGAL_triangulation_postcondition( this->is_valid() ); } //Helping void clear() { Tr::clear(); hierarchy.clear();} void copy(const Constrained_triangulation_plus_2 &ctp); void swap(Constrained_triangulation_plus_2 &ctp); // INSERTION Vertex_handle insert(const Point& a, Face_handle start = Face_handle() ); Vertex_handle insert(const Point& p, Locate_type lt, Face_handle loc, int li ); void insert_constraint(const Point& a, const Point& b); void insert_constraint(Vertex_handle va, Vertex_handle vb); // template < class InputIterator > // int insert(InputIterator first, InputIterator last); Vertex_handle push_back(const Point& a); void push_back(const Constraint& c); //for backward compatibility // not const Point&, because otherwise VC6/7 messes it up with // the insert that takes an iterator range void insert(Point a, Point b) { insert_constraint(a, b);} void insert(Vertex_handle va, Vertex_handle vb) {insert_constraint(va,vb);} virtual Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb); Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, No_intersection_tag); Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_intersections_tag); Vertex_handle intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_predicates_tag); // REMOVAL void remove_constraint(Vertex_handle va, Vertex_handle vb); // Query of the constraint hierarchy Constraint_iterator constraints_begin() const; Constraint_iterator constraints_end() const; Subconstraint_iterator subconstraints_begin() const; Subconstraint_iterator subconstraints_end() const; Context context(Vertex_handle va, Vertex_handle vb); size_type number_of_enclosing_constraints(Vertex_handle va, Vertex_handle vb); Context_iterator contexts_begin(Vertex_handle va, Vertex_handle vb); Context_iterator contexts_end(Vertex_handle va, Vertex_handle vb); Vertices_in_constraint_iterator vertices_in_constraint_begin(Vertex_handle va, Vertex_handle vb); Vertices_in_constraint_iterator vertices_in_constraint_end(Vertex_handle va, Vertex_handle vb); size_type number_of_constraints() { return static_cast (hierarchy.number_of_constraints());} size_type number_of_subconstraints(){ return static_cast (hierarchy.number_of_subconstraints());} protected: void insert_subconstraint(Vertex_handle va,Vertex_handle vb); //to debug public: void print_hierarchy() { hierarchy.print(); } //template member functions public: template < class InputIterator > #if defined(_MSC_VER) || defined(__SUNPRO_CC) int insert(InputIterator first, InputIterator last, int i = 0) #else int insert(InputIterator first, InputIterator last) #endif { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } template OutputItFaces remove_constraint(Vertex_handle va, Vertex_handle vb, OutputItFaces out) { CGAL_triangulation_precondition(hierarchy.is_constrained_edge(va,vb)); for(Vertices_in_constraint_iterator it = hierarchy.vertices_in_constraint_begin(va,vb), succ = it; ++succ != hierarchy.vertices_in_constraint_end(va,vb); ++it){ Face_handle fh; int i; CGAL_triangulation_assertion_code( bool b = ) Triangulation::is_edge(*it, *succ, fh, i); CGAL_triangulation_assertion(b); // this does also flipping if necessary. Triangulation::remove_constrained_edge(fh,i,out); } hierarchy.remove_constraint(va,vb); return out; } }; template void Constrained_triangulation_plus_2:: copy(const Constrained_triangulation_plus_2 &ctp) { copy_triangulation(ctp); //the following assume that the triangulation and its copy // iterates on their vertices on the same order std::map vmap; Vertex_iterator vit = ctp.vertices_begin(); Vertex_iterator vvit = vertices_begin(); for( ; vit != ctp.vertices_end(); ++vit, ++vvit) { assert (vit->point() == vvit->point()); vmap[vit] = vvit; } hierarchy.copy(ctp.hierarchy, vmap); } template void Constrained_triangulation_plus_2:: swap(Constrained_triangulation_plus_2 &ctp) { Tr::swap(ctp); hierarchy.swap(ctp.hierarchy); } template Constrained_triangulation_plus_2& Constrained_triangulation_plus_2:: operator=(const Constrained_triangulation_plus_2 &ctp) { copy(ctp); return *this; } template inline typename Constrained_triangulation_plus_2::Vertex_handle Constrained_triangulation_plus_2:: push_back(const Point &p) { return insert(p); } template inline void Constrained_triangulation_plus_2:: push_back(const Constraint &c) { insert_constraint(c.first, c.second); } template < class Tr > inline typename Constrained_triangulation_plus_2::Vertex_handle Constrained_triangulation_plus_2:: insert(const Point& a, Face_handle start) { Locate_type lt; int li; Face_handle loc = locate(a, lt, li, start); return insert(a,lt,loc,li); } template < class Tr> typename Constrained_triangulation_plus_2::Vertex_handle Constrained_triangulation_plus_2:: insert(const Point& a, Locate_type lt, Face_handle loc, int li) { Vertex_handle v1, v2; bool insert_in_constrained_edge = false; if ( lt == Triangulation::EDGE && loc->is_constrained(li) ){ insert_in_constrained_edge = true; v1=loc->vertex(ccw(li)); //endpoint of the constraint v2=loc->vertex(cw(li)); // endpoint of the constraint } Vertex_handle va = Triangulation::insert(a,lt,loc,li); // update the hierarchy if (insert_in_constrained_edge) { hierarchy.split_constraint(v1,v2,va); } return va; } template inline void Constrained_triangulation_plus_2:: insert_constraint(const Point& a, const Point& b) // insert endpoints first { Vertex_handle va= insert(a); // If the segment is "short" it is a good idea to start the next insertion // close to point a // Otherwise, to start here is as good as elsewhere Vertex_handle vb = insert(b, va->face()); insert_constraint(va, vb); } template inline void Constrained_triangulation_plus_2:: insert_constraint(Vertex_handle va, Vertex_handle vb) { // protects against inserting twice the same constraint bool no_twice = hierarchy.insert_constraint(va, vb); if (va != vb && no_twice ) insert_subconstraint(va,vb); return; } template inline void Constrained_triangulation_plus_2:: insert_subconstraint(Vertex_handle vaa, Vertex_handle vbb) // insert the subconstraint [vaa vbb] // it will eventually be splitted into several subconstraints { CGAL_triangulation_precondition( vaa != vbb); Vertex_handle vi; Face_handle fr; int i; if(includes_edge(vaa,vbb,vi,fr,i)) { mark_constraint(fr,i); if (vi != vbb) { hierarchy.split_constraint(vaa,vbb,vi); insert_subconstraint(vi,vbb); } return; } List_faces intersected_faces; List_edges conflict_boundary_ab, conflict_boundary_ba; bool intersection = find_intersected_faces( vaa, vbb, intersected_faces, conflict_boundary_ab, conflict_boundary_ba, vi); if ( intersection) { if (vi != vaa && vi != vbb) { hierarchy.split_constraint(vaa,vbb,vi); insert_subconstraint(vaa,vi); insert_subconstraint(vi,vbb); } else insert_subconstraint(vaa,vbb); return; } //no intersection triangulate_hole(intersected_faces, conflict_boundary_ab, conflict_boundary_ba); if (vi != vbb) { hierarchy.split_constraint(vaa,vbb,vi); insert_subconstraint(vi,vbb); } return; } template typename Constrained_triangulation_plus_2:: Vertex_handle Constrained_triangulation_plus_2:: intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb) { return intersect(f, i, vaa, vbb, Intersection_tag()); } template typename Constrained_triangulation_plus_2:: Vertex_handle Constrained_triangulation_plus_2:: intersect(Face_handle , int , Vertex_handle , Vertex_handle , No_intersection_tag) { std::cerr << " sorry, this triangulation does not deal with" << std::endl << " intersecting constraints" << std::endl; CGAL_triangulation_assertion(false); return Vertex_handle(); } template typename Constrained_triangulation_plus_2:: Vertex_handle Constrained_triangulation_plus_2:: intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_intersections_tag) // compute the intersection of the constraint edge (f,i) // with the subconstraint (vaa,vbb) being inserted // insert the intersection point // (the constraint edge (f,i) will be splitted in hierarchy by insert) // and return the Vertex_handle of the new Vertex { Vertex_handle vc, vd, va, vb; Vertex_handle vcc, vdd; vcc = f->vertex(cw(i)); vdd = f->vertex(ccw(i)); CGAL_triangulation_assertion_code( bool b1 = ) hierarchy.enclosing_constraint(vcc,vdd,vc,vd); CGAL_triangulation_assertion_code( bool b2 = ) hierarchy.enclosing_constraint(vaa,vbb,va,vb); CGAL_triangulation_assertion(b1); CGAL_triangulation_assertion(b2); const Point& pa = va->point(); const Point& pb = vb->point(); const Point& pc = vc->point(); const Point& pd = vd->point(); Point pi; Intersection_tag itag = Intersection_tag(); CGAL_triangulation_assertion_code( bool ok = ) intersection(geom_traits(), pa, pb, pc, pd, pi, itag ); CGAL_triangulation_assertion(ok); Vertex_handle vi = insert(pi, Triangulation::EDGE, f, i); return vi; } template typename Constrained_triangulation_plus_2::Vertex_handle Constrained_triangulation_plus_2:: intersect(Face_handle f, int i, Vertex_handle vaa, Vertex_handle vbb, Exact_predicates_tag) { Vertex_handle vcc, vdd; vcc = f->vertex(cw(i)); vdd = f->vertex(ccw(i)); const Point& pa = vaa->point(); const Point& pb = vbb->point(); const Point& pc = vcc->point(); const Point& pd = vdd->point(); Point pi; //creator for point is required here Intersection_tag itag = Intersection_tag(); bool ok = intersection(geom_traits(), pa, pb, pc, pd, pi, itag ); Vertex_handle vi; if ( !ok) { //intersection detected but not computed int i = limit_intersection(geom_traits(), pa, pb, pc, pd, itag); switch(i){ case 0 : vi = vaa; break; case 1 : vi = vbb; break; case 2 : vi = vcc; break; case 3 : vi = vdd; break; } } else{ //computed Triangulation::remove_constrained_edge(f, i); vi = insert(pi, f); } // vi == vc or vi == vd may happen even if intersection==true // due to approximate construction of the intersection if (vi != vcc && vi != vdd) { hierarchy.split_constraint(vcc,vdd,vi); insert_subconstraint(vcc,vi); insert_subconstraint(vi, vdd); } else { insert_subconstraint(vcc,vdd); } return vi; } // This remove_constraint leaves all vertices in the triangulation template void Constrained_triangulation_plus_2:: remove_constraint(Vertex_handle va, Vertex_handle vb) { remove_constraint(va, vb, Emptyset_iterator()); } template std::ostream & operator<<(std::ostream& os, const Constrained_triangulation_plus_2 &ct) { ct.file_output(os); return os ; } // Constraint Hierarchy Queries template inline typename Constrained_triangulation_plus_2::Constraint_iterator Constrained_triangulation_plus_2:: constraints_begin() const { return hierarchy.c_begin(); } template inline typename Constrained_triangulation_plus_2::Constraint_iterator Constrained_triangulation_plus_2:: constraints_end() const { return hierarchy.c_end(); } template inline typename Constrained_triangulation_plus_2::Subconstraint_iterator Constrained_triangulation_plus_2:: subconstraints_begin() const { return hierarchy.sc_begin(); } template inline typename Constrained_triangulation_plus_2::Subconstraint_iterator Constrained_triangulation_plus_2:: subconstraints_end() const { return hierarchy.sc_end(); } template inline typename Constrained_triangulation_plus_2::Context Constrained_triangulation_plus_2:: context(Vertex_handle va, Vertex_handle vb) { return hierarchy.context(va,vb); } template inline typename Constrained_triangulation_plus_2::size_type Constrained_triangulation_plus_2:: number_of_enclosing_constraints(Vertex_handle va, Vertex_handle vb) { return static_cast (hierarchy.number_of_enclosing_constraints(va,vb)); } template inline typename Constrained_triangulation_plus_2::Context_iterator Constrained_triangulation_plus_2:: contexts_begin(Vertex_handle va, Vertex_handle vb) { return hierarchy.contexts_begin(va,vb); } template inline typename Constrained_triangulation_plus_2::Context_iterator Constrained_triangulation_plus_2:: contexts_end(Vertex_handle va, Vertex_handle vb) { return hierarchy.contexts_end(va,vb); } template inline typename Constrained_triangulation_plus_2::Vertices_in_constraint_iterator Constrained_triangulation_plus_2:: vertices_in_constraint_begin(Vertex_handle va, Vertex_handle vb) { return hierarchy.vertices_in_constraint_begin(va,vb); } template inline typename Constrained_triangulation_plus_2::Vertices_in_constraint_iterator Constrained_triangulation_plus_2:: vertices_in_constraint_end(Vertex_handle va, Vertex_handle vb) { return hierarchy.vertices_in_constraint_end(va,vb); } CGAL_END_NAMESPACE #endif //CGAL_CONSTRAINED_TRIANGULATION_PLUS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/ConicHPA2.h0000644000175000017500000005343311344301500026647 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/ConicHPA2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Bernd Gaertner, Sven Schoenherr #ifndef CGAL_CONICHPA2_H #define CGAL_CONICHPA2_H // includes #include #include CGAL_BEGIN_NAMESPACE template < class PT, class DA> class ConicHPA2; template < class PT, class DA> class _Min_ellipse_2_adapterH2__Ellipse; template < class _PT, class _DA> class ConicHPA2 { public: // types typedef _PT PT; typedef _DA DA; typedef typename _DA::RT RT; //private: //friend class Conic_2< CGAL::Homogeneous >; friend class _Min_ellipse_2_adapterH2__Ellipse; DA dao; RT _r, _s, _t, _u, _v, _w; Conic_type type; CGAL::Orientation o; bool empty, trivial, degenerate; void set_linear_combination (const RT& a1, const ConicHPA2& c1, const RT& a2, const ConicHPA2& c2) { _r = a1 * c1.r() + a2 * c2.r(); _s = a1 * c1.s() + a2 * c2.s(); _t = a1 * c1.t() + a2 * c2.t(); _u = a1 * c1.u() + a2 * c2.u(); _v = a1 * c1.v() + a2 * c2.v(); _w = a1 * c1.w() + a2 * c2.w(); } static void set_two_linepairs (const PT& p1, const PT& p2, const PT& p3, const PT& p4, ConicHPA2& pair1, ConicHPA2& pair2) { RT x1, y1, h1, x2, y2, h2, x3, y3, h3, x4, y4, h4; const DA& da = pair1.da(); da.get (p1, x1, y1, h1); da.get (p2, x2, y2, h2); da.get (p3, x3, y3, h3); da.get (p4, x4, y4, h4); CGAL::Orientation side1_24 = (CGAL::Orientation)(CGAL_NTS sign (-h2*x1*y4+h1*x2*y4 +h2*x4*y1-h4*x2*y1 +h4*x1*y2-h1*x4*y2)), side3_24 = (CGAL::Orientation)(CGAL_NTS sign (-h2*x3*y4+h3*x2*y4 +h2*x4*y3-h4*x2*y3 +h4*x3*y2-h3*x4*y2)); if (side1_24 != side3_24) { // (counter)clockwise order pair1.set_linepair (p1, p2, p3, p4); pair2.set_linepair (p2, p3, p4, p1); } else { CGAL::Orientation side1_32 = (CGAL::Orientation)(CGAL_NTS sign (-h3*x1*y2+h1*x3*y2 +h3*x2*y1-h2*x3*y1 +h2*x1*y3-h1*x2*y3)); if (side1_32 != side3_24) { // p1, p2 need to be swapped pair1.set_linepair (p2, p1, p3, p4); pair2.set_linepair (p1, p3, p4, p2); } else { // p2, p3 need to be swapped pair1.set_linepair (p1, p3, p2, p4); pair2.set_linepair (p3, p2, p4, p1); } } } void set_ellipse (const ConicHPA2& pair1, const ConicHPA2& pair2) { RT b = RT(2) * (pair1.r() * pair2.s() + pair1.s() * pair2.r()) - pair1.t() * pair2.t(); set_linear_combination (pair2.det()-b, pair1, pair1.det()-b, pair2); } void set (const ConicHPA2& c1, const ConicHPA2& c2, const PT& p) { set_linear_combination (c2.evaluate(p), c1, -c1.evaluate(p), c2); } CGAL::Sign vol_derivative (RT dr, RT ds, RT dt, RT du, RT dv, RT dw) const { RT a1 = RT(4)*r()*ds+RT(4)*dr*s()-RT(2)*t()*dt, a0 = RT(4)*r()*s()-t()*t(), b1 = (RT(4)*r()*s()-t()*t())*dw+(RT(4)*r()*ds+RT(4)*dr*s()- RT(2)*t()*dt)*w()-u()*u()*ds - RT(2)*u()*du*s()-v()*v()*dr-RT(2)*v()*dv*r()+u()*v()*dt+ (u()*dv+du*v())*t(), b0 = (RT(4)*r()*s()-t()*t())*w() -u()*u()*s()-v()*v()*r()+u()*v()*t(), c0 = -RT(2)*a0*b1 + RT(3)*a1*b0; return CGAL_NTS sign (-CGAL_NTS sign (c0)*o); } double vol_minimum (RT dr, RT ds, RT dt, RT du, RT dv, RT dw) const { RT a2 = RT(4)*dr*ds-dt*dt, a1 = RT(4)*r()*ds+RT(4)*dr*s()-RT(2)*t()*dt, a0 = RT(4)*r()*s()-t()*t(), b3 = (RT(4)*dr*ds-dt*dt)*dw-du*du*ds-dv*dv*dr+du*dv*dt, b2 = (RT(4)*r()*ds+RT(4)*dr*s()-RT(2)*t()*dt)*dw+ (RT(4)*dr*ds-dt*dt)*w()-RT(2)*u()*du*ds-du*du*s()- RT(2)*v()*dv*dr-dv*dv*r()+(u()*dv+du*v())*dt+du*dv*t(), b1 = (RT(4)*r()*s()-t()*t())*dw+(RT(4)*r()*ds+RT(4)*dr*s()- RT(2)*t()*dt)*w()-u()*u()*ds - RT(2)*u()*du*s()-v()*v()*dr-RT(2)*v()*dv*r()+u()*v()*dt+ (u()*dv+du*v())*t(), b0 = (RT(4)*r()*s()-t()*t())*w() -u()*u()*s()-v()*v()*r()+u()*v()*t(), c3 = -RT(3)*a1*b3 + RT(2)*a2*b2, c2 = -RT(6)*a0*b3 - a1*b2 + RT(4)*a2*b1, c1 = -RT(4)*a0*b2 + a1*b1 + RT(6)*a2*b0, c0 = -RT(2)*a0*b1 + RT(3)*a1*b0; double roots[3]; int nr_roots = solve_cubic (CGAL::to_double(c3), CGAL::to_double(c2), CGAL::to_double(c1), CGAL::to_double(c0), roots[0], roots[1], roots[2]); CGAL_kernel_precondition (nr_roots > 0); // minimum exists return best_value (roots, nr_roots, CGAL::to_double(a2), CGAL::to_double(a1), CGAL::to_double(a0), CGAL::to_double(b3), CGAL::to_double(b2), CGAL::to_double(b1), CGAL::to_double(b0)); } protected: RT det () const { return RT(4)*s()*r() - t()*t(); } void analyse( ) { RT d = det(); type = (Conic_type)(CGAL_NTS sign(d)); switch (type) { case HYPERBOLA: { trivial = empty = false; RT z_prime = d*w() - u()*u()*s() - v()*v()*r() + u()*v()*t(); o = (CGAL::Orientation)(CGAL_NTS sign (z_prime)); degenerate = (o == CGAL::ZERO); } break; case PARABOLA: { if (!CGAL_NTS is_zero (r())) { trivial = false; degenerate = (t()*u() == RT(2)*r()*v()); if (degenerate) { CGAL::Sign discr = (CGAL::Sign) CGAL_NTS sign(u()*u()-RT(4)*r()*w()); switch (discr) { case CGAL::NEGATIVE: empty = true; o = (CGAL::Orientation)(CGAL_NTS sign (w())); break; case CGAL::ZERO: empty = false; o = (CGAL::Orientation)(CGAL_NTS sign (r())); break; case CGAL::POSITIVE: empty = false; o = CGAL::ZERO; break; } } else { empty = false; o = (CGAL::Orientation)(-CGAL_NTS sign (r())); } } else if (!CGAL_NTS is_zero (s())) { trivial = false; degenerate = (t()*v() == RT(2)*s()*u()); if (degenerate) { CGAL::Sign discr = (CGAL::Sign) CGAL_NTS sign(v()*v()-RT(4)*s()*w()); switch (discr) { case CGAL::NEGATIVE: empty = true; o = (CGAL::Orientation)(CGAL_NTS sign (w())); break; case CGAL::ZERO: empty = false; o = (CGAL::Orientation)(CGAL_NTS sign (s())); break; case CGAL::POSITIVE: empty = false; o = CGAL::ZERO; break; } } else { empty = false; o = (CGAL::Orientation)(-CGAL_NTS sign (s())); } } else { // r=0, s=0 degenerate = true; bool uv_zero = CGAL_NTS is_zero (u()) && CGAL_NTS is_zero (v()); trivial = uv_zero && CGAL_NTS is_zero (w()); empty = uv_zero && !trivial; if (empty) o = (CGAL::Orientation)(CGAL_NTS sign (w())); else if (trivial) o = CGAL::POSITIVE; else o = CGAL::ZERO; } } break; case ELLIPSE: { trivial = false; RT z_prime = d*w() - u()*u()*s() - v()*v()*r() + u()*v()*t(); if (CGAL_NTS is_positive (r())) { empty = CGAL_NTS is_positive(CGAL_NTS sign (z_prime)); empty ? o = CGAL::POSITIVE : o = CGAL::NEGATIVE; } else { empty = CGAL_NTS is_negative(CGAL_NTS sign (z_prime)); empty ? o = CGAL::NEGATIVE : o = CGAL::POSITIVE; } degenerate = empty || CGAL_NTS is_zero (z_prime); } break; } } RT evaluate (const PT& p) const { RT x, y, h; dao.get (p, x, y, h); return r()*x*x + s()*y*y + t()*x*y + u()*x*h + v()*y*h + w()*h*h; } public: ConicHPA2 ( const DA& da = DA()) : dao( da) { } ConicHPA2 (RT r, RT s, RT t, RT u, RT v, RT w, const DA& da = DA()) : dao( da), _r(r), _s(s), _t(t), _u(u), _v(v), _w(w) { analyse(); } const DA& da() const { return dao; } RT r() const { return _r;} RT s() const { return _s;} RT t() const { return _t;} RT u() const { return _u;} RT v() const { return _v;} RT w() const { return _w;} PT center () const { CGAL_kernel_precondition (type != PARABOLA); // PT p; // replaced previous line by following hack (no idea // why original version doesn't work) typename DA::Point_2 p; RT two = RT(2); dao.set( p, two*s()*u() - t()*v(), two*r()*v() - t()*u(), -det()); return p; } Conic_type conic_type () const { return type; } bool is_hyperbola () const { return (type == HYPERBOLA); } bool is_parabola () const { return (type == PARABOLA); } bool is_ellipse () const { return (type == ELLIPSE); } bool is_circle () const { return (type == ELLIPSE && (r()==s()) && CGAL_NTS is_zero (t())); } bool is_empty () const { return empty; } bool is_trivial () const { return trivial; } bool is_degenerate () const { return degenerate; } CGAL::Orientation orientation () const { return o; } CGAL::Oriented_side oriented_side (const PT& p) const { return (CGAL::Oriented_side)(CGAL_NTS sign (evaluate (p))); } bool has_on_positive_side (const PT& p) const { return (CGAL_NTS is_positive (evaluate(p))); } bool has_on_negative_side (const PT& p) const { return (CGAL_NTS is_negative (evaluate(p))); } bool has_on_boundary (const PT& p) const { return (CGAL_NTS is_zero (evaluate(p))); } bool has_on (const PT& p) const { return (CGAL_NTS is_zero (evaluate(p))); } Convex_side convex_side (const PT& p) const { switch (o) { case CGAL::POSITIVE: return (Convex_side)( CGAL_NTS sign (evaluate (p))); case CGAL::NEGATIVE: return (Convex_side)(-CGAL_NTS sign (evaluate (p))); case CGAL::ZERO: return (Convex_side)( CGAL_NTS sign (CGAL_NTS abs (evaluate(p)))); } // keeps g++ happy return( Convex_side( 0)); } bool has_on_convex_side (const PT& p) const { return (convex_side (p) == ON_CONVEX_SIDE); } bool has_on_nonconvex_side (const PT& p) const { return (convex_side (p) == ON_NONCONVEX_SIDE); } bool operator == ( const ConicHPA2<_PT,_DA>& c) const { // find coefficient != 0 RT factor1(0); if ( ! CGAL_NTS is_zero( r())) factor1 = r(); else if ( ! CGAL_NTS is_zero( s())) factor1 = s(); else if ( ! CGAL_NTS is_zero( t())) factor1 = t(); else if ( ! CGAL_NTS is_zero( u())) factor1 = u(); else if ( ! CGAL_NTS is_zero( v())) factor1 = v(); else if ( ! CGAL_NTS is_zero( w())) factor1 = w(); else CGAL_kernel_assertion_msg( false, "all coefficients zero"); // find coefficient != 0 RT factor2(0); if ( ! CGAL_NTS is_zero( c.r())) factor2 = c.r(); else if ( ! CGAL_NTS is_zero( c.s())) factor2 = c.s(); else if ( ! CGAL_NTS is_zero( c.t())) factor2 = c.t(); else if ( ! CGAL_NTS is_zero( c.u())) factor2 = c.u(); else if ( ! CGAL_NTS is_zero( c.v())) factor2 = c.v(); else if ( ! CGAL_NTS is_zero( c.w())) factor2 = c.w(); else CGAL_kernel_assertion_msg( false, "all coefficients zero"); return( ( r()*factor2 == c.r()*factor1) && ( s()*factor2 == c.s()*factor1) && ( t()*factor2 == c.t()*factor1) && ( u()*factor2 == c.u()*factor1) && ( v()*factor2 == c.v()*factor1) && ( w()*factor2 == c.w()*factor1)); } void set (RT r_, RT s_, RT t_, RT u_, RT v_, RT w_) { _r = r_; _s = s_; _t = t_; _u = u_; _v = v_; _w = w_; analyse(); } void set_opposite () { _r = -r(); _s = -s(); _t = -t(); _u = -u(); _v = -v(); _w = -w(); o = CGAL::opposite(orientation()); } void set_circle (const PT& p1, const PT& p2, const PT& p3) { // the circle will have r = s = det*h1*h2*h3, t=0 RT x1, y1, h1, x2, y2, h2, x3, y3, h3; dao.get (p1, x1, y1, h1); dao.get (p2, x2, y2, h2); dao.get (p3, x3, y3, h3); // precondition: p1, p2, p3 not collinear RT det = -h1*x3*y2+h3*x1*y2+h1*x2*y3-h2*x1*y3+h2*x3*y1-h3*x2*y1; CGAL_kernel_precondition (!CGAL_NTS is_zero (det)); // Cramer's rule RT sqr1 = (-x1*x1 - y1*y1)*h2*h3; RT sqr2 = (-x2*x2 - y2*y2)*h1*h3; RT sqr3 = (-x3*x3 - y3*y3)*h1*h2; _u = -h1*sqr3*y2+h3*sqr1*y2+h1*sqr2*y3-h2*sqr1*y3+h2*sqr3*y1-h3*sqr2*y1; _v = -h1*x3*sqr2+h3*x1*sqr2+h1*x2*sqr3-h2*x1*sqr3+h2*x3*sqr1-h3*x2*sqr1; _w = -sqr1*x3*y2+sqr3*x1*y2+sqr1*x2*y3-sqr2*x1*y3+sqr2*x3*y1-sqr3*x2*y1; _r = det*h1*h2*h3; _s = _r; _t = RT(0); analyse(); CGAL_kernel_postcondition(is_circle()); CGAL_kernel_postcondition(has_on_boundary(p1)); CGAL_kernel_postcondition(has_on_boundary(p2)); CGAL_kernel_postcondition(has_on_boundary(p3)); } void set_linepair (const PT& p1, const PT& p2, const PT& p3, const PT& p4, const DA& da = DA()) { RT x1, y1, h1, x2, y2, h2, x3, y3, h3, x4, y4, h4; da.get (p1, x1, y1, h1); da.get (p2, x2, y2, h2); da.get (p3, x3, y3, h3); da.get (p4, x4, y4, h4); // precondition: p1 != p2, p3 != p4 CGAL_kernel_precondition ( ((x1*h2 != x2*h1) || (y1*h2 != y2*h1)) && ((x3*h4 != x4*h3) || (y3*h4 != y4*h3)) ); RT h1x2_x1h2 = h1*x2-x1*h2; RT h3x4_x3h4 = h3*x4-x3*h4; RT y1h2_h1y2 = y1*h2-h1*y2; RT y3h4_h3y4 = y3*h4-h3*y4; RT x1y2_y1x2 = x1*y2-y1*x2; RT x3y4_y3x4 = x3*y4-y3*x4; _r = y1h2_h1y2 * y3h4_h3y4; _s = h1x2_x1h2 * h3x4_x3h4; _t = h1x2_x1h2 * y3h4_h3y4 + y1h2_h1y2 * h3x4_x3h4; _u = x1y2_y1x2 * y3h4_h3y4 + y1h2_h1y2 * x3y4_y3x4; _v = x1y2_y1x2 * h3x4_x3h4 + h1x2_x1h2 * x3y4_y3x4; _w = x1y2_y1x2 * x3y4_y3x4; analyse(); } void set_ellipse (const PT& p1, const PT& p2, const PT& p3) { RT x1, y1, h1, x2, y2, h2, x3, y3, h3; dao.get (p1, x1, y1, h1); dao.get (p2, x2, y2, h2); dao.get (p3, x3, y3, h3); // precondition: p1, p2, p3 not collinear RT det = -h1*x3*y2+h3*x1*y2+h1*x2*y3-h2*x1*y3+h2*x3*y1-h3*x2*y1; CGAL_kernel_precondition (!CGAL_NTS is_zero (det)); RT x1x1 = x1*x1, y1y1 = y1*y1, x2x2 = x2*x2, y2y2 = y2*y2, x3x3 = x3*x3, y3y3 = y3*y3, // x_i^2, y_i^2 x1h1 = x1*h1, y1h1 = y1*h1, x2h2 = x2*h2, y2h2 = y2*h2, x3h3 = x3*h3, y3h3 = y3*h3, // x_i h_i, y_i h_i h1h1 = h1*h1, h2h2 = h2*h2, h3h3 = h3*h3, // h_i^2 two = RT(2); // 2 _r = y1y1*h2h2*h3h3 - y1h1*y2h2*h3h3 - y1h1*h2h2*y3h3 + h1h1*y2y2*h3h3 - h1h1*y2h2*y3h3 + h1h1*h2h2*y3y3; _s = x1x1*h2h2*h3h3 - x1h1*x2h2*h3h3 - x1h1*h2h2*x3h3 + h1h1*x2x2*h3h3 - h1h1*x2h2*x3h3 + h1h1*h2h2*x3x3; _t = -two*x1*y1*h2h2*h3h3 + x1h1*y2h2*h3h3 + x1h1*h2h2*y3h3 + y1h1*x2h2*h3h3 -two*h1h1*x2*y2*h3h3 + h1h1*x2h2*y3h3 + y1h1*h2h2*x3h3 + h1h1*y2h2*x3h3 -two*h1h1*h2h2*x3*y3; _u = -(h1h1*y2y2*x3h3 - h1h1*x2*y2*y3h3 - h1h1*y2h2*x3*y3 + x1h1*h2h2*y3y3 + h1h1*x2h2*y3y3 +y1y1*x2h2*h3h3 + y1y1*h2h2*x3h3 - x1*y1*y2h2*h3h3 - y1h1*x2*y2*h3h3 - x1*y1*h2h2*y3h3 - y1h1*h2h2*x3*y3 + x1h1*y2y2*h3h3); _v = -(h1h1*x2x2*y3h3 - h1h1*x2*y2*x3h3 - h1h1*x2h2*x3*y3 + y1h1*h2h2*x3x3 + h1h1*y2h2*x3x3 +x1x1*y2h2*h3h3 + x1x1*h2h2*y3h3 - x1*y1*x2h2*h3h3 - x1h1*x2*y2*h3h3 - x1*y1*h2h2*x3h3 - x1h1*h2h2*x3*y3 + y1h1*x2x2*h3h3); _w = y1y1*x2h2*x3h3 - x1*y1*y2h2*x3h3 - y1h1*x2*y2*x3h3 + y1h1*y2h2*x3x3 - x1*y1*x2h2*y3h3 + y1h1*x2x2*y3h3 - y1h1*x2h2*x3*y3 + x1h1*y2y2*x3h3 + x1x1*y2h2*y3h3 - x1h1*x2*y2*y3h3 - x1h1*y2h2*x3*y3 + x1h1*x2h2*y3y3; type = ELLIPSE; degenerate = trivial = empty = false; o = CGAL::NEGATIVE; if (CGAL_NTS is_positive (det)) set_opposite (); } void set_ellipse (const PT& p1, const PT& p2, const PT& p3, const PT& p4, CGAL::Orientation _o = POSITIVE) { ConicHPA2 pair1, pair2; set_two_linepairs (p1, p2, p3, p4, pair1, pair2); set_ellipse (pair1, pair2); analyse(); if (o != _o) set_opposite(); } void set (const PT& p1, const PT& p2, const PT& p3, const PT& p4, const PT& p5, CGAL::Orientation _o = POSITIVE) { ConicHPA2 c1; c1.set_linepair (p1, p2, p3, p4); ConicHPA2 c2; c2.set_linepair (p1, p4, p2, p3); set_linear_combination (c2.evaluate (p5), c1, -c1.evaluate (p5), c2); analyse(); // precondition: all points distinct <=> conic nontrivial CGAL_kernel_precondition (!is_trivial()); if (o != _o) set_opposite(); } }; #ifndef CGAL_NO_OSTREAM_INSERT_CONICHPA2 template< class _PT, class _DA> std::ostream& operator << ( std::ostream& os, const ConicHPA2<_PT,_DA>& c) { return( os << c.r() << ' ' << c.s() << ' ' << c.t() << ' ' << c.u() << ' ' << c.v() << ' ' << c.w()); } template< class _PT, class _DA> std::istream& operator >> ( std::istream& is, ConicHPA2<_PT,_DA>& c) { typedef ConicHPA2<_PT,_DA> Conic; typedef typename _DA::RT RT; RT r, s, t, u, v, w; is >> r >> s >> t >> u >> v >> w; c.set( r, s, t, u, v, w); return( is); } #endif // CGAL_NO_OSTREAM_INSERT_CONICHPA2 CGAL_END_NAMESPACE #endif // CGAL_CONICHPA2_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_complex_d.h0000644000175000017500000006356111344301500030637 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_complex_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel //--------------------------------------------------------------------- // file generated by notangle from regl_complex.lw // please debug or modify LEDA web file // mails and bugs: Michael.Seel@mpi-sb.mpg.de // based on LEDA architecture by S. Naeher, C. Uhrig // coding: K. Mehlhorn, M. Seel // debugging and templatization: M. Seel //--------------------------------------------------------------------- #ifndef CGAL_REGULAR_COMPLEX_D_H #define CGAL_REGULAR_COMPLEX_D_H #include #include #include #include #include #include #undef _DEBUG #define _DEBUG 93 #include #ifdef CGAL_USE_LEDA #include #endif CGAL_BEGIN_NAMESPACE template class RC_simplex_d; template class RC_vertex_d; template class Regular_complex_d; template class Convex_hull_d; #define forall_rc_vertices(x,RC)\ for(x = (RC).vertices_begin(); x != (RC).vertices_end(); ++x) #define forall_rc_simplices(x,RC)\ for(x = (RC).simplices_begin(); x != (RC).simplices_end(); ++x) template class RC_vertex_d { typedef RC_vertex_d Self; typedef typename Refs::Point_d Point_d; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Simplex_handle Simplex_handle; typedef typename Refs::R R; friend class Regular_complex_d; friend class Convex_hull_d; friend class RC_simplex_d; Simplex_handle s_; int index_; Point_d point_; void set_simplex(Simplex_handle s) { s_=s; } void set_index(int i) { index_=i; } void set_point(const Point_d& p) { point_=p; } public: RC_vertex_d(Simplex_handle s, int i, const Point_d& p) : s_(s), index_(i), point_(p) {} RC_vertex_d(const Point_d& p) : point_(p), pp(NULL) {} RC_vertex_d() : s_(), index_(-42), pp(NULL) {} // beware that ass_point was initialized here by nil_point ~RC_vertex_d() {} Simplex_handle simplex() const { return s_; } int index() const { return index_; } const Point_d& point() const { return point_; } void* pp; void* for_compact_container() const { return pp; } void* & for_compact_container() { return pp; } #ifdef CGAL_USE_LEDA LEDA_MEMORY(RC_vertex_d) #endif }; template class RC_simplex_d { typedef RC_simplex_d Self; typedef typename Refs::Point_d Point_d; typedef typename Refs::Vertex_handle Vertex_handle; typedef typename Refs::Simplex_handle Simplex_handle; typedef typename Refs::R R; friend class Regular_complex_d; friend class Convex_hull_d; protected: std::vector vertices; // array of vertices std::vector neighbors; // opposite simplices std::vector opposite_vertices; // indices of opposite vertices //------ only for convex hulls ------------------ typedef typename R::Hyperplane_d Hyperplane_d; Hyperplane_d h_base; // hyperplane supporting base facet bool visited_; // visited mark when traversing //------ only for convex hulls ------------------ Vertex_handle vertex(int i) const { return vertices[i]; } Simplex_handle neighbor(int i) const { return neighbors[i]; } int opposite_vertex_index(int i) const { return opposite_vertices[i]; } void set_vertex(int i, Vertex_handle v) { vertices[i] = v; } void set_neighbor(int i, Simplex_handle s) { neighbors[i]=s; } void set_opposite_vertex_index(int i, int index) { opposite_vertices[i]=index; } //------ only for convex hulls ------------------ Hyperplane_d hyperplane_of_base_facet() const { return h_base; } void set_hyperplane_of_base_facet(const Hyperplane_d& h) { h_base = h; } bool& visited() { return visited_; } //------ only for convex hulls ------------------ public: typedef typename std::vector::const_iterator VIV_iterator; struct Point_from_VIV_iterator { typedef Vertex_handle argument_type; typedef Point_d result_type; result_type& operator()(argument_type& x) const { return x->point(); } const result_type& operator()(const argument_type& x) const { return x->point(); } }; typedef CGAL::Iterator_project Point_const_iterator; Point_const_iterator points_begin() const { return Point_const_iterator(vertices.begin()); } Point_const_iterator points_end() const { return Point_const_iterator(vertices.end()); } void* pp; void* for_compact_container() const { return pp; } void* & for_compact_container() { return pp; } #if 0 struct Point_const_iterator { typedef Point_const_iterator self; typedef std::random_access_iterator_tag iterator_category; typedef const Point_d& value_type; typedef std::ptrdiff_t difference_type; typedef const Point_d* pointer; typedef const Point_d& reference; typedef typename std::vector::const_iterator ra_vertex_iterator; Point_const_iterator() : _it() {} Point_const_iterator(ra_vertex_iterator it) : _it(it) {} value_type operator*() const { return (*_it)->point(); } pointer operator->() const { return &(operator*()); } self& operator++() { ++_it; return *this; } self operator++(int) { self tmp = *this; ++_it; return tmp; } self& operator--() { --_it; return *this; } self operator--(int) { self tmp = *this; --_it; return tmp; } self& operator+=(difference_type i) { _it+=i; return *this; } self& operator-=(difference_type i) { _it-=i; return *this; } self operator+(difference_type i) const { self tmp=*this; tmp+=i; return tmp; } self operator-(difference_type i) const { self tmp=*this; tmp-=i; return tmp; } difference_type operator-(self x) const { return _it-x._it; } reference operator[](difference_type i) { return *(*this + i); } bool operator==(const self& x) const { return _it==x._it; } bool operator!=(const self& x) const { return ! (*this==x); } bool operator<(self x) const { (x - *this) > 0; } private: ra_vertex_iterator _it; }; // Point_const_iterator Point_const_iterator points_begin() const { return Point_const_iterator(vertices.begin()); } Point_const_iterator points_end() const { return Point_const_iterator(vertices.end()); } #endif RC_simplex_d() : pp(NULL) {} RC_simplex_d(int dmax) : vertices(dmax+1), neighbors(dmax+1), opposite_vertices(dmax+1), pp(NULL) { for (int i = 0; i <= dmax; i++) { neighbors[i] = Simplex_handle(); vertices[i] = Vertex_handle(); opposite_vertices[i] = -1; } visited_ = false; } ~RC_simplex_d() {} void print(std::ostream& O=std::cout) const { O << "RC_simplex_d {" ; for(int i=0;i < int(vertices.size());++i) { Vertex_handle v = vertices[i]; if ( v != Vertex_handle() ) O << v->point(); else O << "(nil)"; } O << "}"; } #ifdef CGAL_USE_LEDA LEDA_MEMORY(RC_simplex_d) #endif }; template std::ostream& operator<<(std::ostream& O, const RC_simplex_d& s) { s.print(O); return O; } /*{\Manpage {Regular_complex_d}{R}{Regular Simplicial Complex}{C}}*/ /*{\Mdefinition An instance |\Mvar| of type |\Mname| is a regular abstract or concrete simplicial complex. An abstract simplicial complex is a family |\Mvar| of subsets of some set $V$, called the vertex set of the complex, which is closed under the subset relation, i.e., if a set $s$ belongs to the family then all its subsets do. A set $s$ of cardinality $k + 1$ is called a $k$-simplex and $k$ is called its dimension. If $s$ is a subset of $t$ then $s$ is called a subsimplex or face of $t$. A vertex $v$ is called incident to a simplex $s$ if $v$ is an element of $s$. A simplex is called \emph{maximal} if it is not a face of any simplex in |\Mvar|. Two simplices of dimension $k$ are called neighbors if they share $k-1$ vertices. A complex is connected if its set of maximal simplices forms a connected set under the neighboring relation. A simplicial complex is called \emph{regular} if all maximal simplices in the complex have the same dimension and if the complex is connected. A concrete simplicial complex is an abstract simplicial complex in which a point in some ambient space is associated with each vertex. We use |dim| to denote the dimension of ambient space. Simplices are now interpreted geometrically as sets of points in ambient space, namely as the convex hulls of (the points associated with) their vertices. A $0$-simplex is a point, a $1$-simplex is a line segment, a $2$-simplex is a triangle, a $3$-simplex is a tetrahedron, etc.. \emph{The simplices is a concrete simplicial complex must satisfy the additional conditions that the points associated with the vertices of any simplex are affinely independet and that the intersection of any two simplices is a face of both.} We will write simplicial complex instead of concrete simplicial complex in the sequel. All maximal simplices in a regular simplicial complex have the same dimension, which we denote |dcur|. For each maximal simplex\footnote{we drop the adjective maximal in the sequel} in |\Mvar| there is an item of type |RC_simplex_d| and for each vertex there is an item of type |rc_vertex|. Each maximal simplex has |1+dcur| vertices indexed from $0$ to |dcur|. For any simplex $s$ and any index $i$, |C.vertex_of(s,i)| returns the $i$-th vertex of $s$. There may or may not be a simplex $t$ opposite to (the vertex with index) $i$, i.e., a maximal simplex $t$ having \{|C.vertex_of(s,0)|,|C.vertex_of(s,1)|,\ldots, |C.vertex_of(s,dcur)|\} - \{|C.vertex_of(s,i)|\} in its vertex set. The function |C.opposite(s,i)| returns $t$ if it exists and returns |nil| otherwise. If $t$ exists then $s$ and $t$ share |dcur| vertices, namely all but vertex $i$ of $s$ and vertex |C.opposite_vertex(s,i)| of $t$. Assume that $t = |C.opposite(s,i)|$ exists and let |j = C.opposite_vertex(s,i)|. Then |s = C.opposite(t,j)| and |i = C.opposite_vertex(t,j)| and \begin{eqnarray*} \lefteqn{\{|C.vertex_of(s,0)|,|C.vertex_of(s,1)|,\ldots, |C.vertex_of(s,dcur)|\} - \{|C.vertex_of(s,i)|\} =} \\ & & \{|C.vertex_of(t,0)|,|C.vertex_of(t,1)|,\ldots,|C.vertex_of(t,dcur)|\} - \{|C.vertex_of(t,j)|\}. \end{eqnarray*} In general, a vertex belongs to many simplices. For an |rc_vertex| $v$, the functions |C.simplex(v)| and |C.index(v)| return a pair $(s,i)$ such that |v = C.vertex_of(s,i)|. The class |regl_complex| has a static member |nil_point| of type |Point_d|. This point is different (= not indentical) from any user defined point and is the point associated with every vertex of an abstract simplicial complex. It simulates the use of |nil| to denote an undefined object. Regular complexes are designed as the base class for triangulations of convex hulls and Delaunay triangulations in higher dimensional space. We have not used them yet for any other purpose. Regular complexes are built by constructing vertices and simplices, by assigning positions to vertices and vertices to simplices, and by establishing neighbor relations. The update operations do not check whether the data structure built actually encodes a simplicial complex. The class provides a function |is_valid()| that performs a partial check whether the data structure encodes a simplicial complex. It is not checked whether two simplices intersect without sharing a face. }*/ template class Regular_complex_d { typedef Regular_complex_d Self; public: /*{\Mtypes 4}*/ typedef R_ R; typedef RC_vertex_d Vertex; typedef CGAL::Compact_container Vertex_list; typedef typename Vertex_list::iterator Vertex_handle; /*{\Mtypemember the handle type for vertices of the complex.}*/ typedef typename Vertex_list::const_iterator Vertex_const_handle; typedef typename Vertex_list::iterator Vertex_iterator; /*{\Mtypemember the iterator type for vertices of the complex.}*/ typedef typename Vertex_list::const_iterator Vertex_const_iterator; typedef RC_simplex_d Simplex; typedef CGAL::Compact_container Simplex_list; typedef typename Simplex_list::iterator Simplex_handle; /*{\Mtypemember the handle type for simplices of the complex.}*/ typedef typename Simplex_list::const_iterator Simplex_const_handle; typedef typename Simplex_list::iterator Simplex_iterator; /*{\Mtypemember the iterator type for simplices of the complex.}*/ typedef typename Simplex_list::const_iterator Simplex_const_iterator; typedef typename R::Point_d Point_d; protected: const R& Kernel_; int dcur; // dimension of the current complex int dmax; // dimension of ambient space Vertex_list vertices_; // list of all vertices Simplex_list simplices_; // list of all simplices /* the default copy constructor and assignment operator for class regl_complex work incorrectly; it is therefore good practice to either implement them correctly or to make them inaccessible. We do the latter. */ private: Regular_complex_d(const Regular_complex_d& ); Regular_complex_d& operator=(const Regular_complex_d& ); void clean_dynamic_memory() { vertices_.clear(); simplices_.clear(); } public: /*{\Mcreation}*/ Regular_complex_d(int d = 2, const R& Kernel = R()) /*{\Mcreate creates an instance |\Mvar| of type |\Mtype|. The dimension of the underlying space is $d$ and |\Mvar| is initialized to the empty regular complex. Thus |dcur| equals $-1$. The traits class |R| specifies the models of all types and the implementations of all geometric primitives used by the regular complex class. The |Kernel| parameter allows you to carry fixed geometric information into the data type. For the default kernel traits |Homogeneous_d| the default construction of |Kernel| is enough. In the following we use further template parameters like the point type |Point_d=R::Point_d|. At this point, it suffices to say that |Point_d| represents points in $d$-space. The complete specification of the traits class is to be found at the end of this manual page.}*/ : Kernel_(Kernel) { dmax = d; dcur = -1; } ~Regular_complex_d() { clean_dynamic_memory(); } /* In the destructor for |Regular_complex_d|, we have to release the storage which was allocated for the simplices and the vertices. */ /*{\Mtext The data type |\Mtype| offers neither copy constructor nor assignment operator.}*/ /*{\Moperations 3 3}*/ /*{\Mtext \headerline{Access Operations}}*/ int dimension() const { return dmax; } /*{\Mop returns the dimension of ambient space}*/ int current_dimension() const { return dcur; } /*{\Mop returns the current dimension of the simplices in the complex.}*/ Vertex_handle vertex(Simplex_handle s, int i) const /*{\Mop returns the $i$-th vertex of $s$.\\ \precond $0 \leq i \leq |current_dimension|$. }*/ { CGAL_assertion(0<=i&&i<=dcur); return s->vertex(i); } Vertex_const_handle vertex(Simplex_const_handle s, int i) const { CGAL_assertion(0<=i&&i<=dcur); return s->vertex(i); } Point_d associated_point(Vertex_handle v) const /*{\Mop returns the point associated with vertex |v|.}*/ { return v->point(); } Point_d associated_point(Vertex_const_handle v) const { return v->point(); } int index(Vertex_handle v) const /*{\Mop returns the index of $v$ in |C.simplex(v)|.}*/ { return v->index(); } int index(Vertex_const_handle v) const { return v->index(); } Simplex_handle simplex(Vertex_handle v) const /*{\Mop returns a simplex of which $v$ is a vertex. Note that this simplex is not unique. }*/ { return v->simplex(); } Simplex_const_handle simplex(Vertex_const_handle v) const { return v->simplex(); } Point_d associated_point(Simplex_handle s, int i) const /*{\Mop same as |C.associated_point(C.vertex(s,i))|.}*/ { return associated_point(vertex(s,i)); } Point_d associated_point(Simplex_const_handle s, int i) const { return associated_point(vertex(s,i)); } Simplex_handle opposite_simplex(Simplex_handle s,int i) const /*{\Mop returns the simplex opposite to the $i$-th vertex of $s$ (|Simplex_handle()| is there is no such simplex).\\ \precond $0 \leq i \leq |dcur|$. }*/ { CGAL_assertion(0<=i&&i<=dcur); return s->neighbor(i); } Simplex_const_handle opposite_simplex(Simplex_const_handle s,int i) const { CGAL_assertion(0<=i&&i<=dcur); return s->neighbor(i); } int index_of_opposite_vertex(Simplex_handle s, int i) const { CGAL_assertion(0<=i&&i<=dcur); return s->opposite_vertex_index(i); } /*{\Mop returns the index of the vertex opposite to the $i$-th vertex of $s$. \precond $0 \leq i \leq |dcur|$ and there is a simplex opposite to the $i$-th vertex of $s$.}*/ int index_of_opposite_vertex(Simplex_const_handle s, int i) const { CGAL_assertion(0<=i&&i<=dcur); return s->opposite_vertex_index(i); } /*{\Mtext \headerline{Update Operations} We give operations that allow to update a regular complex. They have to be used with care as they may invalidate the data structure.}*/ void clear(int d = 0) /*{\Mop reinitializes |\Mvar| to the empty complex in dimension |dim|.}*/ { clean_dynamic_memory(); dmax = d; dcur = -1; } void set_current_dimension(int d) { dcur = d; } /*{\Mop sets |dcur| to |d|. }*/ Simplex_handle new_simplex() /*{\Mop adds a new simplex to |\Mvar| and returns it. The new simplex has no vertices yet.}*/ { Simplex s(dmax); Simplex_handle h = simplices_.insert(s); return h; } Vertex_handle new_vertex() /*{\Mop adds a new vertex to |\Mvar| and returns it. The new vertex has no associated simplex nor index yet. The associated point is the point |Regular_complex_d::nil_point| which is a static member of class |Regular_complex_d.|}*/ { Vertex v(nil_point); Vertex_handle h = vertices_.insert(v); return h; } Vertex_handle new_vertex(const Point_d& p) /*{\Mop adds a new vertex to |\Mvar| and returns it. The new vertex has |p| as the associated point, but is has no associated simplex nor index yet.}*/ { Vertex v(p); Vertex_handle h = vertices_.insert(v); return h; } void associate_vertex_with_simplex(Simplex_handle s, int i, Vertex_handle v) /*{\Mop sets the $i$-th vertex of |s| to |v| and records this fact in $v$. The latter occurs only if $v$ is non-nil.}*/ { s -> set_vertex(i,v); if ( v != Vertex_handle() ) { v -> set_simplex(s); v -> set_index(i); } } void associate_point_with_vertex(Vertex_handle v, const Point_d& p) /*{\Mop sets the point associated with $v$ to $p$.}*/ { v -> set_point(p); } void set_neighbor(Simplex_handle s, int i, Simplex_handle s1, int j) /*{\Mop sets the neihbor opposite to vertex $i$ of |s| to |s1| and records vertex $j$ of |s1| as the vertex opposite to $i$.}*/ { s -> set_neighbor(i,s1); s1 -> set_neighbor(j,s); s -> set_opposite_vertex_index(i,j); s1 -> set_opposite_vertex_index(j,i); } void check_topology() const; /*{\Mop Partially checks whether |\Mvar| is an abstract simplicial complex. This function terminates without error if each vertex is a vertex of the simplex of which it claims to be a vertex, if the vertices of all simplices are pairwise distinct, if the neighbor relationship is symmetric, and if neighboring simplices share exactly |dcur| vertices. It returns an error message if one of these conditions is violated. Note that it is not checked whether simplices that share |dcur| vertices are neighbors in the data structure.}*/ void check_topology_and_geometry() const; /*{\Mop In addition to the above, this function checks whether all vertices have an associated point different from |Regular_complex_d::nil_point| and whether the points associated with the vertices of any simplex are affinely independent. It returns an error message otherwise. Note that it is not checked whether the intersection of any two simplices is a facet of both.}*/ typedef size_t Size_type; Size_type number_of_vertices() const { return this->_vertices.size();} Size_type number_of_simplices() const { return this->_simplices.size();} void print_statistics(std::ostream& os = std::cout) const { os << "Regular_complex_d - statistic" << std::endl; os << "number of vertices = " << number_of_vertices() << std::endl; os << "number of simplices = " << number_of_simplices() << std::endl; } /*{\Mtext \headerline{Lists and Iterators} \setopdims{4.5cm}{3.5cm}}*/ /*{\Mtext The following operation pairs return iterator ranges in the style of STL.}*/ Vertex_iterator vertices_begin() { return vertices_.begin(); } /*{\Mop the first vertex of |\Mvar|.}*/ Vertex_iterator vertices_end() { return vertices_.end(); } /*{\Mop the beyond vertex of |\Mvar|.}*/ Simplex_iterator simplices_begin() { return simplices_.begin(); } /*{\Mop the first simplex of |\Mvar|.}*/ Simplex_iterator simplices_end() { return simplices_.end(); } /*{\Mop the beyond simplex of |\Mvar|.}*/ Vertex_const_iterator vertices_begin() const { return vertices_.begin(); } Vertex_const_iterator vertices_end() const { return vertices_.end(); } Simplex_const_iterator simplices_begin() const { return simplices_.begin(); } Simplex_const_iterator simplices_end() const { return simplices_.end(); } std::list all_simplices() /*{\Mop returns the set of all maximal simplices in |\Mvar|.}*/ { std::list res; Simplex_iterator it; forall_rc_simplices(it,*this) res.push_back(it); return res; } std::list all_simplices() const { std::list res; Simplex_const_iterator it; forall_rc_simplices(it,*this) res.push_back(it); return res; } std::list all_vertices() /*{\Mop returns the set of all vertices in |\Mvar|.}*/ { std::list res; Vertex_iterator it; forall_rc_vertices(it,*this) res.push_back(it); return res; } std::list all_vertices() const { std::list res; Vertex_const_iterator it; forall_rc_vertices(it,*this) res.push_back(it); return res; } const R& kernel() const { return Kernel_; } static Point_d nil_point; }; // Regular_complex_d // init static member: template typename Regular_complex_d::Point_d Regular_complex_d::nil_point; template void Regular_complex_d::check_topology() const { Simplex_const_handle s,t; Vertex_const_handle v; int i,j,k; if (dcur == -1) { if (!vertices_.empty() || !simplices_.empty() ) CGAL_assertion_msg(0, "check_topology: dcur is -1 but there are vertices or simplices"); } forall_rc_vertices(v,*this) { if ( v != vertex(simplex(v),index(v)) ) CGAL_assertion_msg(0, "check_topology: vertex-simplex relationship corrupted"); } forall_rc_simplices(s,*this) { for(i = 0; i <= dcur; i++) { for (j = i + 1; j <= dcur; j++) { if (vertex(s,i) == vertex(s,j)) CGAL_assertion_msg(0, "check_topology: a simplex with two equal vertices"); } } } forall_rc_simplices(s,*this) { for(i = 0; i <= dcur; i++) { if ((t = opposite_simplex(s,i)) != Simplex_const_handle()) { int l = index_of_opposite_vertex(s,i); if (s != opposite_simplex(t,l) || i != index_of_opposite_vertex(t,l)) CGAL_assertion_msg(0, "check_topology: neighbor relation is not symmetric"); for (j = 0; j <= dcur; j++) { if (j != i) { // j must also occur as a vertex of t for (k = 0; k <= dcur && ( vertex(s,j) != vertex(t,k) || k == l); k++); // forloop has no body if (k > dcur) CGAL_assertion_msg(0, "check_topology: too few shared vertices."); } } } } } } template void Regular_complex_d::check_topology_and_geometry() const { check_topology(); Vertex_const_handle v; forall_rc_vertices(v,*this) { if ( v == Vertex_const_handle() || associated_point(v).identical(Regular_complex_d::nil_point) ) CGAL_assertion_msg(0,"check_topology_and_geometry: \ vertex with nil_point or no associated point."); } typename R::Affinely_independent_d affinely_independent = kernel().affinely_independent_d_object(); Simplex_const_handle s; forall_rc_simplices(s,*this) { std::vector A(dcur + 1); for (int i = 0; i <= dcur; i++) A[i] = associated_point(s,i); if ( !affinely_independent(A.begin(),A.end()) ) CGAL_assertion_msg(0,"check_topology_and_geometry: \ corners of some simplex are not affinely independent"); } } /*{\Mtext \headerline{Iteration Statements} {\bf forall\_rc\_simplices}($s,C$) $\{$ ``the simplices of $C$ are successively assigned to $s$'' $\}$ {\bf forall\_rc\_vertices}($v,C$) $\{$ ``the vertices of $C$ are successively assigned to $v$'' $\}$ }*/ /*{\Mimplementation Each simplex stores its vertices, the adjacent simplices, and the opposite vertices in arrays. The space requirement for a simplex is $3 * |dim| * 4$ Bytes for the contents of the arrays plus the actual space for the points plus the constant space overhead for the arrays (see the manual pages for arrays). The class |Regular_complex_d| needs constant space plus space for a list of simplices (which is about 12 bytes per simplex). The total space requirement is therefore about $12(|dim| + 2)$ bytes times the number of simplices. }*/ CGAL_END_NAMESPACE #endif // CGAL_REGULAR_COMPLEX_D_H ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_structure_using_list_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_str0000644000175000017500000000177011344301501031452 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_data_structure_using_list_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DATA_STRUCTURE_USING_LIST_2_H #define CGAL_TRIANGULATION_DATA_STRUCTURE_USING_LIST_2_H // no longer needed // maintained for backwards compatibility #endif //CGAL_TRIANGULATION_DATA_STRUCTURE_USING_LIST_2_H ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_constructions_C2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000002272511344301501031400 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_constructions_C2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SEGMENT_VORONOI_DIAGRAM_CONSTRUCTIONS_C2_H #define CGAL_SEGMENT_VORONOI_DIAGRAM_CONSTRUCTIONS_C2_H #include #include #include #include #include CGAL_BEGIN_NAMESPACE //*********************************************************************** //*********************************************************************** // CONSTRUCTIONS //*********************************************************************** //*********************************************************************** //----------------------------------------------------------------------- // Segment Voronoi diagram site //----------------------------------------------------------------------- template class Construct_svd_site_2; template class Construct_svd_site_2 { public: typedef Site Site_2; typedef typename Site_2::Point_2 Point_2; typedef Site_2 result_type; struct Arity_tag {}; public: result_type operator()(const Point_2& p) const { return Site_2(p); } result_type operator()(const Point_2& p0, const Point_2& p1) const { return Site_2(p0, p1); } result_type operator()(const Point_2& p0, const Point_2& p1, const Point_2& q0, const Point_2& q1) const { return Site_2(p0, p1, q0, q1); } result_type operator()(const Point_2& p0, const Point_2& p1, const Point_2& q0, const Point_2& q1, bool b) const { return Site_2(p0, p1, q0, q1, b); } result_type operator()(const Point_2& p0, const Point_2& p1, const Point_2& q0, const Point_2& q1, const Point_2& r0, const Point_2& r1) const { return Site_2(p0, p1, q0, q1, r0, r1); } }; template class Construct_svd_site_2 { public: typedef Site Site_2; typedef typename Site_2::Point_2 Point_2; typedef Site_2 result_type; struct Arity_tag {}; public: result_type operator()(const Point_2& p) const { return Site_2(p); } result_type operator()(const Point_2& p0, const Point_2& p1) const { return Site_2(p0, p1); } }; //----------------------------------------------------------------------- // Segment Voronoi diagram vertex //----------------------------------------------------------------------- template class Construct_svd_vertex_2 { public: typedef typename K::Site_2 Site_2; typedef CGAL::Svd_voronoi_vertex_2 Voronoi_vertex_2; typedef typename K::Point_2 Point_2; typedef Point_2 result_type; typedef Arity_tag<3> Arity; public: Point_2 operator()(const Site_2& s1, const Site_2& s2, const Site_2& s3) const { Voronoi_vertex_2 v(s1, s2, s3); return v.point(); } }; //----------------------------------------------------------------------- // Segment Voronoi diagram circle //----------------------------------------------------------------------- template class Construct_svd_circle_2 { public: typedef typename Gt::Site_2 Site_2; typedef Svd_voronoi_vertex_2 Voronoi_vertex_2; typedef typename Gt::Circle_2 Circle_2; typedef Circle_2 result_type; typedef Arity_tag<3> Arity; public: Circle_2 operator() (const Site_2& s1, const Site_2& s2, const Site_2& s3) const { Voronoi_vertex_2 v(s1, s2, s3); return v.circle(); } }; //----------------------------------------------------------------------- // Segment Voronoi diagram bisector //----------------------------------------------------------------------- template class Construct_svd_bisector_2 { public: typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef Line_2 result_type; typedef Arity_tag<2> Arity; public: Line_2 operator()(const Site_2& p, const Site_2& q) const { CGAL_assertion( !(p.is_segment() && q.is_segment()) ); if ( p.is_point() && q.is_point() ) { Point_2 mid = midpoint(p.point(), q.point()); Line_2 l(p.point(), q.point()); return l.perpendicular(mid); } if ( p.is_segment() && q.is_point() ) { // in this case q has to be one of the two endpoints of the // segment p... Line_2 l = p.segment().supporting_line(); return l.perpendicular(q.point()); } // in this case p has to be one of the two endpoints of the // segment q... Line_2 l = q.segment().supporting_line(); return l.perpendicular(p.point()); } }; //----------------------------------------------------------------------- // Segment Voronoi diagram bisector ray //----------------------------------------------------------------------- template class Construct_svd_bisector_ray_2 { public: typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::Ray_2 Ray_2; typedef typename Gt::Construct_svd_vertex_2 Construct_svd_vertex_2; typedef typename Gt::Equal_2 Equal_2; typedef Ray_2 result_type; typedef Arity_tag<3> Arity; Ray_2 operator()(const Site_2& p, const Site_2& q, const Site_2& r) const { CGAL_assertion( !(p.is_segment() && q.is_segment()) ); Equal_2 are_same_points; Point_2 v = Construct_svd_vertex_2()(p, q, r); Point_2 p1, p2; if ( p.is_point() && q.is_point() ) { p1 = q.point(); p2 = p.point(); } else if ( p.is_point() && q.is_segment() ) { CGAL_assertion( are_same_points(p, q.source_site()) || are_same_points(p, q.target_site()) ); p1 = are_same_points(p, q.source_site()) ? q.target() : q.source(); p2 = p.point(); } else { // p is a segment and q a point p1 = q.point(); p2 = are_same_points(q, p.source_site()) ? p.target() : p.source(); } Line_2 l(p1, p2); Line_2 lperp = l.perpendicular( v ); return Ray_2(v, lperp.direction()); } }; //----------------------------------------------------------------------- // Segment Voronoi diagram bisector segment //----------------------------------------------------------------------- template class Construct_svd_bisector_segment_2 { public: typedef typename Gt::Site_2 Site_2; typedef typename Gt::Point_2 Point_2; typedef typename Gt::Line_2 Line_2; typedef typename Gt::Ray_2 Ray_2; typedef typename Gt::Segment_2 Segment_2; typedef CGAL::Parabola_segment_2 Parabola_segment_2; typedef typename Gt::Construct_svd_vertex_2 Construct_svd_vertex_2; typedef typename Gt::Equal_2 Equal_2; typedef CGAL::Object Object_2; typedef Object_2 result_type; typedef Arity_tag<4> Arity; result_type operator()(const Site_2& p, const Site_2& q, const Site_2& r, const Site_2& s) const { Construct_svd_vertex_2 circumcenter; Point_2 vpqr = circumcenter(p, q, r); Point_2 vqps = circumcenter(q, p, s); Equal_2 same_points; if ( (p.is_point() && q.is_point()) || (p.is_segment() && q.is_segment()) ) { Segment_2 vorseg(vpqr, vqps); return CGAL::make_object(vorseg); } if ( p.is_point() ) { // check is p is an endpoint of q if ( same_points( p, q.source_site() ) || same_points( p, q.target_site() ) ) { Segment_2 vorseg(vpqr, vqps); return CGAL::make_object(vorseg); } Line_2 l = q.segment().supporting_line(); Parabola_segment_2 vorseg(p.point(), l, vpqr, vqps); return CGAL::make_object(vorseg); } // check is q is an endpoint of p if ( same_points(q, p.source_site()) || same_points(q, p.target_site()) ) { Segment_2 vorseg(vpqr, vqps); return CGAL::make_object(vorseg); } Line_2 l = p.segment().supporting_line(); Parabola_segment_2 vorseg(q.point(), l, vpqr, vqps); return CGAL::make_object(vorseg); } }; //----------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // CGAL_SEGMENT_VORONOI_DIAGRAM_CONSTRUCTIONS_C2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/representation_tags.h0000644000175000017500000000245011344301500031252 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/representation_tags.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_REPRESENTATION_TAGS_H #define CGAL_REPRESENTATION_TAGS_H CGAL_BEGIN_NAMESPACE class Cartesian_tag {}; class Homogeneous_tag {}; CGAL_END_NAMESPACE #endif // CGAL_REPRESENTATION_TAGS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2.h0000644000175000017500000000470011344301500026146 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Ray_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_RAY_2_H #define CGAL_RAY_2_H CGAL_BEGIN_NAMESPACE template class Ray_2 : public R_::Kernel_base::Ray_2 { typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Kernel_base::Ray_2 RRay_2; public: typedef R_ R; Ray_2() {} Ray_2(const RRay_2& r) : RRay_2(r) {} Ray_2(const Point_2 &sp, const Point_2 &secondp) : RRay_2(sp, secondp) {} Ray_2(const Point_2 &sp, const Direction_2 &d) : RRay_2(sp, d) {} Ray_2(const Point_2 &sp, const Vector_2 &v) : RRay_2(sp, v) {} Ray_2(const Point_2 &sp, const Line_2 &l) : RRay_2(sp, l) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_RAY_2 template < class R > std::ostream & operator<<(std::ostream &os, const Ray_2 &r) { typedef typename R::Kernel_base::Ray_2 RRay_2; return os << static_cast(r); } #endif // CGAL_NO_OSTREAM_INSERT_RAY_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_RAY_2 template < class R > std::istream & operator>>(std::istream &is, Ray_2 &r) { typedef typename R::Kernel_base::Ray_2 RRay_2; return is >> static_cast(r); } #endif // CGAL_NO_ISTREAM_EXTRACT_RAY_2 CGAL_END_NAMESPACE #endif // CGAL_RAY_2_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_storage_site_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagra0000644000175000017500000002160711344301501031376 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Segment_Voronoi_diagram_storage_site_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef SEGMENT_VORONOI_DIAGRAM_STORAGE_SITE_H #define SEGMENT_VORONOI_DIAGRAM_STORAGE_SITE_H #include #include #include CGAL_BEGIN_NAMESPACE /** A Site is either a point or a segment or a point defined as the intersection of two non-parallel segments (if defined) */ template class Segment_Voronoi_diagram_storage_site_2 { public: typedef Gt Geom_traits; typedef typename Geom_traits::Site_2 Site_2; typedef typename std::set::iterator Point_handle; // typedef typename std::list::iterator // Point_handle; protected: typedef Point_handle Handle; typedef Segment_Voronoi_diagram_storage_site_2 Self; public: // constructs point site using input point static Self construct_storage_site_2(const Handle& hp) { Self t; t.initialize_site(hp); return t; } // constructs segment site corresponding to the segment (*hp1,*hp2) static Self construct_storage_site_2(const Handle& hp1, const Handle& hp2) { Self t; t.initialize_site(hp1, hp2); return t; } // constructs point site using the point of intersection of the // segments (*hp1,*hp2) and (*hq1,*hq2) static Self construct_storage_site_2(const Handle& hp1, const Handle& hp2, const Handle& hq1, const Handle& hq2) { Self t; t.initialize_site(hp1, hp2, hq1, hq2); return t; } // constructs segment site whose endpoints are the points of // intersection of the pairs of segments (*hp1,*hp2), (*hq1,*hq2) // and (*hp1,*hp2), (*hr1,*hr2) static Self construct_storage_site_2(const Handle& hp1, const Handle& hp2, const Handle& hq1, const Handle& hq2, const Handle& hr1, const Handle& hr2) { Self t; t.initialize_site(hp1, hp2, hq1, hq2, hr1, hr2); return t; } // constructs segment site using either the source or the target of // (*hp1,*hp2) (that depends on the boolean is_first_exact) and the // intersection of (*hp1,*hp2) with (*hq1,*hq2) as the other endpoint static Self construct_storage_site_2(const Handle& hp1, const Handle& hp2, const Handle& hq1, const Handle& hq2, bool is_first_exact) { Self t; t.initialize_site(hp1, hp2, hq1, hq2, is_first_exact); return t; } public: // DEFAULT CONSTRUCTOR //-------------------- Segment_Voronoi_diagram_storage_site_2() : type_(0) {} // COPY CONSTRUCTOR //----------------- Segment_Voronoi_diagram_storage_site_2(const Self& other) { copy_from(other); } // ASSIGNMENT OPERATOR //-------------------- Self& operator=(const Self& other) { copy_from(other); return *this; } public: // PREDICATES //----------- bool is_defined() const { return type_; } bool is_point() const { return (type_ & 3) == 1; } bool is_segment() const { return (type_ & 3) == 2; } bool is_input() const { return !(type_ & 12); } bool is_input(unsigned int i) const { CGAL_precondition( is_segment() && i < 2 ); if ( i == 0 ) { return !(type_ & 4); } return !(type_ & 8); } // ACCESS METHODS //--------------- const Handle& point() const { CGAL_precondition( is_point() && is_input() ); return h_[0]; } const Handle& source_of_supporting_site() const { CGAL_precondition( is_segment() ); return h_[0]; } const Handle& target_of_supporting_site() const { CGAL_precondition( is_segment() ); return h_[1]; } const Handle& source_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return (i == 0) ? h_[2] : h_[4]; } const Handle& target_of_supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() ); return (i == 0) ? h_[3] : h_[5]; } const Handle& source_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return (i == 0) ? h_[2] : h_[4]; } const Handle& target_of_crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input(i) ); return (i == 0) ? h_[3] : h_[5]; } Self source_site() const { CGAL_precondition( is_segment() ); if ( is_input() || is_input(0) ) { return construct_storage_site_2(h_[0]); } else { return construct_storage_site_2(h_[0], h_[1], h_[2], h_[3]); } } Self target_site() const { CGAL_precondition( is_segment() ); if ( is_input() || is_input(1) ) { return construct_storage_site_2(h_[1]); } else { return construct_storage_site_2(h_[0], h_[1], h_[4], h_[5]); } } Self supporting_site() const { CGAL_precondition( is_segment() ); return construct_storage_site_2(h_[0], h_[1]); } Self supporting_site(unsigned int i) const { CGAL_precondition( is_point() && !is_input() && i < 2 ); if ( i == 0 ) { return construct_storage_site_2(h_[2], h_[3]); } else { return construct_storage_site_2(h_[4], h_[5]); } } Self crossing_site(unsigned int i) const { CGAL_precondition( is_segment() && !is_input() ); CGAL_precondition( i < 2 && !is_input(i) ); if ( i == 0 ) { return construct_storage_site_2(h_[2], h_[3]); } else { return construct_storage_site_2(h_[4], h_[5]); } } Site_2 site() const { if ( is_point() ) { if ( is_input() ) { return Site_2::construct_site_2(*h_[0]); } else { return Site_2::construct_site_2(*h_[2], *h_[3], *h_[4], *h_[5]); } } else { if ( is_input() ) { return Site_2::construct_site_2(*h_[0], *h_[1]); } else if ( is_input(0) ) { return Site_2::construct_site_2(*h_[0], *h_[1], *h_[4], *h_[5], true); } else if ( is_input(1) ) { return Site_2::construct_site_2(*h_[0], *h_[1], *h_[2], *h_[3], false); } else { return Site_2::construct_site_2(*h_[0], *h_[1], *h_[2], *h_[3], *h_[4], *h_[5]); } } } protected: // INITIALIZATION //--------------- void initialize_site(const Handle& hp) { type_ = 1; h_[0] = hp; } void initialize_site(const Handle& hp1, const Handle& hp2) { type_ = 2; h_[0] = hp1; h_[1] = hp2; } void initialize_site(const Handle& hp1, const Handle& hp2, const Handle& hq1, const Handle& hq2) { // MK: Sort the segments s1 and s2 in lexicographical order so // that the computation of the intersection point is always // done in the same manner (?) type_ = 5; h_[2] = hp1; h_[3] = hp2; h_[4] = hq1; h_[5] = hq2; } void initialize_site(const Handle& hp1, const Handle& hp2, const Handle& hq1, const Handle& hq2, const Handle& hr1, const Handle& hr2) { type_ = 14; h_[0] = hp1; h_[1] = hp2; h_[2] = hq1; h_[3] = hq2; h_[4] = hr1; h_[5] = hr2; } void initialize_site(const Handle& hp1, const Handle& hp2, const Handle& hq1, const Handle& hq2, bool is_first_exact) { type_ = (is_first_exact ? 10 : 6); h_[0] = hp1; h_[1] = hp2; if ( is_first_exact ) { h_[4] = hq1; h_[5] = hq2; } else { h_[2] = hq1; h_[3] = hq2; } } void copy_from(const Self& other) { type_ = other.type_; if ( !other.is_defined() ) { return; } if ( other.is_point() ) { if ( other.is_input() ) { h_[0] = other.h_[0]; } else { h_[2] = other.h_[2]; h_[3] = other.h_[3]; h_[4] = other.h_[4]; h_[5] = other.h_[5]; } } else { h_[0] = other.h_[0]; h_[1] = other.h_[1]; if ( !other.is_input() ) { if ( other.is_input(0) ) { h_[4] = other.h_[4]; h_[5] = other.h_[5]; } else if ( other.is_input(1) ) { h_[2] = other.h_[2]; h_[3] = other.h_[3]; } else { h_[2] = other.h_[2]; h_[3] = other.h_[3]; h_[4] = other.h_[4]; h_[5] = other.h_[5]; } } } } protected: Handle h_[6]; char type_; }; //------------------------------------------------------------------------- CGAL_END_NAMESPACE #endif // SEGMENT_VORONOI_DIAGRAM_STORAGE_SITE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits_d.h0000644000175000017500000000271311344301500030272 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_SEARCH_TRAITS_D_H #define CGAL_SEARCH_TRAITS_D_H namespace CGAL { template class Search_traits_d { public: typedef typename K::Cartesian_const_iterator_d Cartesian_const_iterator_d; typedef typename K::Construct_cartesian_const_iterator_d Construct_cartesian_const_iterator_d; typedef typename K::Construct_iso_box_d Construct_iso_box_d; typedef typename K::Construct_min_vertex_d Construct_min_vertex_d; typedef typename K::Construct_max_vertex_d Construct_max_vertex_d; typedef typename K::Point_d Point_d; typedef typename K::Iso_box_d Iso_box_d; typedef typename K::FT FT; }; } // namespace CGAL #endif // CGAL_SEARCH_TRAITS_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_profiler.h0000644000175000017500000001014711344301500030316 0ustar debiandebian// Copyright (c) 2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Kernel_profiler.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_KERNEL_PROFILER_H #define CGAL_KERNEL_PROFILER_H // This file contains the definition of a kernel traits profiler. #include #include CGAL_BEGIN_NAMESPACE // Primitive wrapper which handles the profiling. template < typename P > struct Primitive_profiler : public P { typedef typename P::result_type result_type; typedef typename P::Arity Arity; // #define CGAL_KERNEL_PROFILER CGAL_PROFILER(__PRETTY_FUNCTION__); #define CGAL_KERNEL_PROFILER \ CGAL_PROFILER(typeid(static_cast(*this)).name()) Primitive_profiler(const P& p = P()) : P(p) {} template result_type operator()(const A1 &a1) const { CGAL_KERNEL_PROFILER; return P::operator()(a1); } template result_type operator()(const A1 &a1, const A2 &a2) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2); } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2, a3); } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2, a3, a4); } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2, a3, a4, a5); } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2, a3, a4, a5, a6); } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2, a3, a4, a5, a6, a7); } template result_type operator()(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5, const A6 &a6, const A7 &a7, const A8 &a8) const { CGAL_KERNEL_PROFILER; return P::operator()(a1, a2, a3, a4, a5, a6, a7, a8); } // ... }; // We inherit all geometric objects from K, and just replace the primitives. template < typename K > struct Kernel_profiler : public K { #define CGAL_prof_prim(X, Y) \ typedef Primitive_profiler X; \ X Y() const { return X(static_cast(*this).Y()); } #define CGAL_Kernel_pred(X, Y) CGAL_prof_prim(X, Y) #define CGAL_Kernel_cons(X, Y) CGAL_prof_prim(X, Y) #include }; CGAL_END_NAMESPACE #endif // CGAL_KERNEL_PROFILER_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_traits_d.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000000362211344301500031413 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_traits_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_D_H #define CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_D_H namespace CGAL { template // algorithm to use class Min_sphere_of_spheres_d_traits_d { public: // types: typedef FT_ FT; typedef FT_ Radius; typedef typename K_::Point_d Point; typedef std::pair Sphere; typedef typename K_::Cartesian_const_iterator_d Cartesian_const_iterator; typedef UseSqrt_ Use_square_roots; typedef Algorithm_ Algorithm; public: // constants: static const int D = Dim_; // dimension public: // accessors: static inline const FT& radius(const Sphere& s) { return s.second; } static inline Cartesian_const_iterator center_cartesian_begin(const Sphere& s) { return s.first.cartesian_begin(); } }; } // namespace CGAL #endif // CGAL_MIN_SPHERE_OF_SPHERES_D_TRAITS_D_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits_3.h0000644000175000017500000000320611344301500030207 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_SEARCH_TRAITS_3_H #define CGAL_SEARCH_TRAITS_3_H namespace CGAL { template class Search_traits_3 { public: typedef typename K::Cartesian_const_iterator_3 Cartesian_const_iterator_d; typedef typename K::Construct_cartesian_const_iterator_3 Construct_cartesian_const_iterator_d; typedef typename K::Point_3 Point_d; typedef typename K::Iso_cuboid_3 Iso_box_d; typedef typename K::Sphere_3 Sphere_d; typedef typename K::Construct_iso_cuboid_3 Construct_iso_box_d; typedef typename K::Construct_min_vertex_3 Construct_min_vertex_d; typedef typename K::Construct_max_vertex_3 Construct_max_vertex_d; typedef typename K::Construct_center_3 Construct_center_d; typedef typename K::Compute_squared_radius_3 Compute_squared_radius_d; typedef typename K::FT FT; }; } // namespace CGAL #endif // SEARCH_TRAITS_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_iterators_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_itera0000644000175000017500000002530111344301501031437 0ustar debiandebian// Copyright (c) 1999 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_iterators_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Monique Teillaud #ifndef CGAL_TRIANGULATION_DS_ITERATORS_3_H #define CGAL_TRIANGULATION_DS_ITERATORS_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Tds > class Triangulation_ds_facet_iterator_3 { // traverses the list of cells and reports all facets. public: typedef typename Tds::Facet value_type; typedef const typename Tds::Facet * pointer; typedef const typename Tds::Facet & reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; typedef typename Tds::Facet Facet; typedef Triangulation_ds_facet_iterator_3 Facet_iterator; typedef typename Tds::Cell_iterator Cell_iterator; Triangulation_ds_facet_iterator_3() {} Triangulation_ds_facet_iterator_3(const Tds * tds) : _tds(tds) { facet.second = 0; switch ( _tds->dimension() ) { case 2: pos = _tds->cell_container().begin(); facet.second = 3; return; case 3: pos = _tds->cell_container().begin(); while (// there must be at least one facet pos->neighbor(facet.second) < pos ) { increment(); } return; default: pos = _tds->cell_container().end(); return; } } // used to initialize the past-the end iterator Triangulation_ds_facet_iterator_3(const Tds* tds, int) : _tds(tds) { facet.second = 0; pos = _tds->cell_container().end(); if (_tds->dimension() == 2) facet.second = 3; } Facet_iterator& operator++() { if (_tds->dimension() < 2) return *this; if (_tds->dimension() == 3) { do { increment(); } while ( pos != _tds->cell_container().end() && pos->neighbor(facet.second) < pos ); // reports a facet when the current cell has a pointer inferior // to the pointer of the neighbor cell return *this; } ++pos; // dimension 2 return *this; } Facet_iterator& operator--() { if (_tds->dimension() < 2) return *this; if ( _tds->dimension() == 2 ) { --pos; // index remains 3 return *this; } // dimension 3 do{ if (facet.second == 0) { // all the facets of the current cell have been examined facet.second = 3; --pos; } else --facet.second; } while ( pos != _tds->cell_container().end() && pos->neighbor(facet.second) < pos ); // reports a facet when the current cell has a pointer inferior // to the pointer of the neighbor cell return *this; } Facet_iterator operator++(int) { Facet_iterator tmp(*this); ++(*this); return tmp; } Facet_iterator operator--(int) { Facet_iterator tmp(*this); --(*this); return tmp; } bool operator==(const Facet_iterator& fi) const { return _tds == fi._tds && pos == fi.pos && facet.second == fi.facet.second; } bool operator!=(const Facet_iterator& fi) const { return !(*this == fi); } reference operator*() const { facet.first = pos; return facet; } pointer operator->() const { facet.first = pos; return &facet; } private: const Tds* _tds; Cell_iterator pos; // current "cell". mutable Facet facet; // current facet. void increment() { if (facet.second == 3) { // all the faces of the current cell have been examined facet.second = 0; ++pos; } // be careful : facet.second should always be 0 when pos = cells_end else ++facet.second; } }; template < class Tds > class Triangulation_ds_edge_iterator_3 { // traverses the list of cells and reports each edge. public: typedef typename Tds::Edge value_type; typedef const typename Tds::Edge * pointer; typedef const typename Tds::Edge & reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::bidirectional_iterator_tag iterator_category; typedef typename Tds::Edge Edge; typedef Triangulation_ds_edge_iterator_3 Edge_iterator; typedef typename Tds::Cell_iterator Cell_iterator; typedef typename Tds::Cell_handle Cell_handle; typedef Triangulation_ds_cell_circulator_3 Cell_circulator; Triangulation_ds_edge_iterator_3() : _tds(NULL) { edge.second = 0; edge.third = 1; } Triangulation_ds_edge_iterator_3(const Tds * tds) : _tds(tds) { edge.second = 0; edge.third = 1; switch ( _tds->dimension() ) { case 1: { pos = _tds->cell_container().begin(); return; } case 2: { pos = _tds->cell_container().begin(); while ( // there must be at least one edge pos->neighbor(3-edge.second-edge.third) < pos ) { increment2(); } return; } case 3: { pos = _tds->cell_container().begin(); bool notfound = true; while ( // there must be at least one edge notfound ) { edge.first = pos; Cell_circulator ccir = _tds->incident_cells(edge); do { ++ccir; #ifdef CGAL_T3_USE_ITERATOR_AS_HANDLE } while ( pos < ccir ); #else } while ( Cell_handle(pos) < Cell_handle(ccir) ); #endif // loop terminates since it stops at least when ccir = pos if ( Cell_handle(ccir) == Cell_handle(pos) ) // pos is the cell with minimal pointer notfound = false; else increment3(); } return; } default: { pos = _tds->cell_container().end(); return; } } } // used to initialize the past-the end iterator Triangulation_ds_edge_iterator_3(const Tds* tds, int) : _tds(tds) { edge.second = 0; edge.third = 1; pos = _tds->cell_container().end(); } Edge_iterator& operator++() { switch ( _tds->dimension() ) { case 1: { ++pos; break; } case 2: { do { increment2(); } while ( pos != _tds->cell_container().end() && pos->neighbor(3-edge.second-edge.third) < pos ); break; } case 3: { bool notfound = true; do { increment3(); if (pos != _tds->cell_container().end()) { edge.first = pos; Cell_circulator ccir = _tds->incident_cells(edge); do { ++ccir; } while ( Cell_handle(pos) < Cell_handle(ccir) ); if ( Cell_handle(ccir) == Cell_handle(pos) ) // pos is the cell with minimal pointer notfound = false; } else { edge.second=0; edge.third=1; } } while ( pos != _tds->cell_container().end() && notfound ); break; } default: { return *this; } } return *this; } Edge_iterator& operator--() { switch ( _tds->dimension() ) { case 1: { --pos; // edge.second, edge.third remain 0, 1 break; } case 2: { do { if (edge.second == 0) { edge.second = 2; edge.third = 0; --pos; } else { --edge.second; edge.third = edge.second+1; // case edge.second==2, edge.third==0 forbids to write edge.third-- } } while ( pos != _tds->cell_container().end() && pos->neighbor(3-edge.second-edge.third) < pos ); break; } case 3: { bool notfound = true; do { if (edge.second == 0) { if (edge.third == 1) { // all the edges of the current cell have been examined edge.second = 2; edge.third = 3; --pos; } else --edge.third; } else { if (edge.third == edge.second+1) { --edge.second; edge.third = 3; } else --edge.third; } if (pos != _tds->cell_container().end()) { edge.first = pos; Cell_circulator ccir = _tds->incident_cells(edge); do { ++ccir; } while ( Cell_handle(pos) < Cell_handle(ccir) ); if ( Cell_handle(pos) == Cell_handle(ccir) ) // pos is the cell with minimum pointer notfound = false; } else { edge.second=0; edge.third=1; } } while ( pos != _tds->cell_container().end() && notfound ); break; } default : return *this; } // reports an edge when the current cell has a pointer inferior // to the pointer of the neighbor cell return *this; } Edge_iterator operator++(int) { Edge_iterator tmp(*this); ++(*this); return tmp; } Edge_iterator operator--(int) { Edge_iterator tmp(*this); --(*this); return tmp; } bool operator==(const Edge_iterator& ei) const { return _tds == ei._tds && pos == ei.pos && edge.second == ei.edge.second && edge.third == ei.edge.third; } bool operator!=(const Edge_iterator& ei) const { return !(*this == ei); } reference operator*() const { edge.first = pos; return edge; } pointer operator->() const { edge.first = pos; return &edge; } private: const Tds* _tds; Cell_iterator pos; // current "cell". Even if the dimension is <3 when // there is no true cell yet. mutable Edge edge; // keeps the indices of the current edge. void increment2() { if (edge.second == 2) { // edge.third == 0 // all the edges of the current cell have been examined edge.second = 0; edge.third = 1; ++pos; } // be careful : index should always be 0 when pos = cells_end else { ++edge.second; if ( edge.second == 2 ) edge.third = 0; else // edge.second==1 edge.third = 2; } } void increment3() { if (edge.second == 2) { // then edge.third == 3 // all the edges of the current cell have been examined edge.second = 0; edge.third = 1; ++pos; } else { if (edge.third == 3) { edge.second++; edge.third = edge.second+1; } else ++edge.third; } } }; CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_DS_ITERATORS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_2.h0000644000175000017500000000237511344301501030740 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/squared_distance_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Geert-Jan Giezeman #ifndef CGAL_SQUARED_DISTANCE_2_H #define CGAL_SQUARED_DISTANCE_2_H #include #include #endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_euclidean_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_euclidean_0000644000175000017500000000206611344301500031324 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_euclidean_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA // Andreas Fabri #ifndef CGAL_ALPHA_SHAPE_EUCLIDEAN_TRAITS_H #define CGAL_ALPHA_SHAPE_EUCLIDEAN_TRAITS_H CGAL_BEGIN_NAMESPACE template < class R > class Alpha_shape_euclidean_traits_2 : public R {}; CGAL_END_NAMESPACE #endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_graph_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_grap0000644000175000017500000003736511344301501031517 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_graph_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Susan Hert /* Provides an implementation of the algorithm of Overmars and Welzl for computing the visibility graph of a set of non-intersecting line segments in the plane. @inproceedings{ow-nmcvg-88 , author = "M. H. Overmars and Emo Welzl" , title = "New methods for computing visibility graphs" , booktitle = "Proc. 4th Annu. ACM Sympos. Comput. Geom." , year = 1988 , pages = "164--171" } The running time is $O(n^2)$ with linear space requirements. The algorithm implemented uses a sweep-line technique to construct the visibility graph. The sweep data structure is a rotation tree, implemented in the class CGAL::Rotation_tree_2. A direction vector $d$ is swept from $-\pi/2$ to $\pi/2$, and the sweep data structure, and whenever the direction of this vector coincides with the slope of an edge in the rotation tree, the tree $G$ is updated and edges of the visibility graph are reported. To accomplish the updates, it is necessary to keep track of all the leaves that are leftmost children of their parents. In particular, one needs to know the rightmost of these leftmost children. Two data structures are needed for the implementation of the algorithm: the sweep data structure $G$, and a stack $S$ that contains all the leaves in $G$ that are the leftmost children of their parents. TODO: --is_valid function is not complete --??? would a list of list of sorted vertices be a better representation? */ #ifndef CGAL_VERTEX_VISIBILITY_GRAPH_2_H #define CGAL_VERTEX_VISIBILITY_GRAPH_2_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace CGAL { template class Vertex_visibility_graph_2 { private: typedef Vertex_visibility_graph_2 Self; typedef typename Traits::Point_2 Point_2; typedef typename Traits::Segment_2 Segment_2; typedef typename Traits::Ray_2 Ray_2; typedef typename Traits::Object_2 Object_2; typedef typename Traits::Left_turn_2 Left_turn_2; typedef typename Traits::Less_xy_2 Less_xy_2; typedef typename Traits::Orientation_2 Orientation_2; typedef typename Traits::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; typedef typename Traits::Are_strictly_ordered_along_line_2 Are_strictly_ordered_along_line_2; typedef typename Traits::Construct_segment_2 Construct_segment_2; typedef typename Traits::Construct_ray_2 Construct_ray_2; typedef typename Traits::Intersect_2 Intersect_2; typedef typename Traits::Assign_2 Assign_2; typedef Segment_less_yx_2 Segment_less_yx_2; typedef Rotation_tree_2 Tree; typedef typename Tree::iterator Tree_iterator; typedef std::list< Point_2 > Polygon; typedef typename Polygon::const_iterator Polygon_const_iterator; typedef typename Polygon::iterator Polygon_iterator; // the edge set is simply a set of point pairs. typedef std::pair Point_pair; typedef Point_pair_less_xy_2 Point_pair_compare; typedef std::set< Point_pair, Point_pair_compare > Edge_set; // this map associates with each point (vertex), the iterator in the // original list that it originated from and its current visibility // point iterator. typedef std::pair Iterator_pair; typedef std::map Vertex_map; typedef typename Vertex_map::iterator Vertex_map_iterator; public: typedef typename Edge_set::iterator iterator; typedef typename Edge_set::const_iterator const_iterator; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES static Indirect_less_xy_2 indirect_less_xy_2; static bool compare(const Polygon_const_iterator& pit1, const Polygon_const_iterator& pit2) { return indirect_less_xy_2(pit1, pit2); } #endif Vertex_visibility_graph_2() {} // // first and beyond should be iterators over vertices of a polygon // template Vertex_visibility_graph_2(ForwardIterator first, ForwardIterator beyond): left_turn_2(Traits().left_turn_2_object()), orientation_2(Traits().orientation_2_object()), collinear_ordered_2(Traits().collinear_are_ordered_along_line_2_object()), are_strictly_ordered_along_line_2( Traits().are_strictly_ordered_along_line_2_object()), less_xy_2(Traits().less_xy_2_object()), construct_segment_2(Traits().construct_segment_2_object()), construct_ray_2(Traits().construct_ray_2_object()), intersect_2(Traits().intersect_2_object()), assign_2(Traits().assign_2_object()) { build(first, beyond); } // Pre: ccw order of points; no repeated points template void build(ForwardIterator first, ForwardIterator beyond) { #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES Polygon polygon; for(ForwardIterator fit = first; fit != beyond; fit++){ polygon.push_back(*fit); } #else Polygon polygon(first,beyond); #endif Tree tree(polygon.begin(), polygon.end()); Vertex_map vertex_map; initialize_vertex_map(polygon, vertex_map); // NOTE: use the std::list as the basis here because otherwise the basis // is a deque, which is buggy under MSVC++ std::stack > stack; // push on p_0, the rightmost point stack.push(tree.rightmost_point_ref()); Tree_iterator p, p_r, q; Tree_iterator z; while (!stack.empty()) { p = stack.top(); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG if (p != tree.end()) std::cout << "p = " << *p << std::endl; else std::cout << "p == NULL" << std::endl; #endif stack.pop(); p_r = tree.right_sibling(p); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG if (p_r != tree.end()) std::cout << "p_r = " << *p_r << std::endl; else std::cout << "p_r == NULL" << std::endl; #endif q = tree.parent(p); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG if (q != tree.end()) std::cout << "q = " << *q << std::endl; else std::cout << "q == NULL" << std::endl; #endif if (!tree.parent_is_p_minus_infinity(p)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "q is not p_minus_infinity" << std::endl; #endif handle(p,q,polygon,vertex_map); } z = tree.left_sibling(q); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG if (z != tree.end()) std::cout << "z = " << *z << std::endl; else std::cout << "z == NULL" << std::endl; std::cout << "erasing " << *p << " from tree " << std::endl; #endif tree.erase(p); if ((z == tree.end()) || !left_turn_to_parent(p,z,tree)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "making " << *p << " the left sibling of " << *q << std::endl; #endif tree.set_left_sibling(p,q); } else { // NOTE: no need to check here if z is p_infinity since you are // moving DOWN the tree instead of up and p_infinity is at the root Turn_reverser right_turn(left_turn_2); while ((tree.rightmost_child(z) != tree.end()) && !right_turn(*p,*tree.rightmost_child(z),*z)) { z = tree.rightmost_child(z); #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << " z = " << *z << std::endl; #endif } tree.set_rightmost_child(p,z); if (!stack.empty() && z == stack.top()) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "popping " << *z << " from top of stack " << std::endl; #endif z = stack.top(); stack.pop(); } } #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << " p is now " << *p << std::endl; #endif if (tree.left_sibling(p) == tree.end() && !tree.parent_is_p_infinity(p)) { #ifdef CGAL_VISIBILITY_GRAPH_DEBUG std::cout << "pushing " << *p << std::endl; #endif stack.push(p); } if (p_r != tree.end()) stack.push(p_r); } // print_edge_set(edges); } void clear() { edges.clear(); } iterator begin() { return edges.begin(); } const_iterator begin() const { return edges.begin(); } const_iterator end() const { return edges.end(); } iterator end() { return edges.end(); } void insert_edge(const Point_pair& edge) { if (less_xy_2(edge.first,edge.second)) edges.insert(edge); else edges.insert(Point_pair(edge.second, edge.first)); } bool is_an_edge(const Point_pair& edge) { if (less_xy_2(edge.first,edge.second)) return edges.find(edge) != edges.end(); else return edges.find(Point_pair(edge.second, edge.first)) != edges.end(); } #if 0 // ??? need to finish this ??? template bool is_valid(ForwardIterator first, ForwardIterator beyond) { std::vector vertices(first, beyond); bool edge_there[vertices.size()]; // for each edge in the graph determine if it is either an edge of the // polygon or, if not, if it intersects the polygon in the interior of // the edge. for (iterator e_it = edges.begin(); e_it != edges.end(); e_it++) { Segment_2 s = construct_segment_2((*e_it).first, (*e_it).second); if (is_an_edge(*e_it)) edge_there[edge_num] = true; else if (do_intersect_in_interior(s, first, beyond)) return false; } // check if all the edges of the polygon are present // // ??? how do you check if there are missing edges ??? } #endif private: void print_vertex_map(const Vertex_map& vertex_map, const Polygon& polygon) { typedef typename Vertex_map::const_iterator const_iterator; for (const_iterator it = vertex_map.begin(); it != vertex_map.end();it++) { if ((*it).second.second != polygon.end()) std::cout << (*it).first << " sees " << *((*it).second.second) << std::endl; } } template void print_edge_set(const E& edges) { typedef typename E::iterator iterator; for (iterator it = edges.begin(); it != edges.end(); it++) { std::cout << (*it).first << " " << (*it).second << std::endl; } } // want to determine, for each vertex p of the polygon, the line segment // immediately below it. For vertical edges, the segment below is not the // one that begins at the other endpoint of the edge. void initialize_vertex_map(const Polygon& polygon, Vertex_map& vertex_map); // determines if one makes a left turn going from p to q to q's parent. // if q's parent is p_infinity, then a left turn is made when p's x value // is less than q's x value or the x values are the same and p's y value is // less than q's. // if p, q, and q's parent are collinear, then one makes a "left turn" // if q is between p and q's parent (since this means that p can't see // q's parent and thus should not become a child of that node) bool left_turn_to_parent(Tree_iterator p, Tree_iterator q, Tree& tree); // returns true if q is the vertex after p bool is_next_to(const Polygon& polygon, Polygon_const_iterator p, Polygon_const_iterator q) const { Polygon_const_iterator next = p; next++; if (next == polygon.end()) next = polygon.begin(); return (q == next); } // returns true if q is the vertex before or after p bool are_adjacent(const Polygon& polygon, Polygon_const_iterator p, Polygon_const_iterator q) const { Polygon_const_iterator next = p; next++; if (next == polygon.end()) next = polygon.begin(); if (q == next) return true; next = q; next++; if (next == polygon.end()) next = polygon.begin(); if (p == next) return true; return false; } // returns true if the diagonal from p to q cuts the interior angle at p bool diagonal_in_interior(const Polygon& polygon, Polygon_const_iterator p, Polygon_const_iterator q); // returns true if the looker can see the point_to_see bool point_is_visible(const Polygon& polygon, Polygon_const_iterator point_to_see, Vertex_map_iterator looker); void update_visibility(Vertex_map_iterator p_it, Vertex_map_iterator q_it, const Polygon& polygon, int are_adjacent); void update_collinear_visibility(Vertex_map_iterator p_it, Vertex_map_iterator q_it, const Polygon& polygon); // The segment between points p and q is a potential visibility edge // This function determines if the edge should be added or not (based // on p's current visibility point) and updates p's visibility point // where appropriate void handle(Tree_iterator p, Tree_iterator q, const Polygon& polygon, Vertex_map& vertex_map); private: Left_turn_2 left_turn_2; Orientation_2 orientation_2; Collinear_are_ordered_along_line_2 collinear_ordered_2; Are_strictly_ordered_along_line_2 are_strictly_ordered_along_line_2; Less_xy_2 less_xy_2; Construct_segment_2 construct_segment_2; Construct_ray_2 construct_ray_2; Intersect_2 intersect_2; Assign_2 assign_2; Edge_set edges; }; #ifdef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES template Indirect_less_xy_2 Vertex_visibility_graph_2::indirect_less_xy_2; #endif } #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #include #endif // CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION #endif // CGAL_VERTEX_VISIBILITY_GRAPH_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits_2.h0000644000175000017500000000321511344301500030206 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Search_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_SEARCH_TRAITS_2_H #define CGAL_SEARCH_TRAITS_2_H namespace CGAL { template class Search_traits_2 { public: typedef typename K::Point_2 Point_d; typedef typename K::Iso_rectangle_2 Iso_box_d; typedef typename K::Circle_2 Sphere_d; typedef typename K::Cartesian_const_iterator_2 Cartesian_const_iterator_d; typedef typename K::Construct_cartesian_const_iterator_2 Construct_cartesian_const_iterator_d; typedef typename K::Construct_min_vertex_2 Construct_min_vertex_d; typedef typename K::Construct_max_vertex_2 Construct_max_vertex_d; typedef typename K::Construct_center_2 Construct_center_d; typedef typename K::Compute_squared_radius_2 Compute_squared_radius_d; typedef typename K::Construct_iso_rectangle_2 Construct_iso_box_d; typedef typename K::FT FT; }; } // namespace CGAL #endif // CGAL_SEARCH_TRAITS_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Profile_counter.h0000644000175000017500000000353411344301500030335 0ustar debiandebian// Copyright (c) 2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Profile_counter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_PROFILE_COUNTER_H #define CGAL_PROFILE_COUNTER_H // This file contains the class Profile_counter which is able to keep track // of a number, and prints a message in the destructor. // Typically, it can be used as a profile counter in a static variable. #include CGAL_BEGIN_NAMESPACE struct Profile_counter { Profile_counter(const char *ss) : i(0), s(ss) {} void operator++() { ++i; } ~Profile_counter() { std::cerr << "Profile counter : " << s << " = " << i << std::endl; } private: unsigned int i; const char *s; }; #ifdef CGAL_PROFILE # define CGAL_PROFILER(Y) { static CGAL::Profile_counter tmp(Y); ++tmp; } #else # define CGAL_PROFILER(Y) #endif CGAL_END_NAMESPACE #endif // CGAL_PROFILE_COUNTER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Restricted_double.h0000644000175000017500000000574611344301500030647 0ustar debiandebian// Copyright (c) 1999,2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Restricted_double.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_RESTRICTED_DOUBLE_H #define CGAL_RESTRICTED_DOUBLE_H // This file contains the description of the class Restricted_double. // The goal of this class is to be run by some overloaded predicates, // This is just a wrapper for a double, but with limited functionality, // to detect non-intented use. // It's the type over which is run the epsilon variant, and which throws // the exceptions. // TODO: I need to add some missing operators and functions, min/max... #include // #include CGAL_BEGIN_NAMESPACE #ifdef CGAL_IA_CHECK_RESTRICT struct Restricted_double { typedef Restricted_double Self; struct unsafe_comparison {}; // Exception class. Restricted_double () {} Restricted_double (const double &d) : _d(d) {} Restricted_double (const int &i) : _d(double(i)) {} // Add operator= for efficiency. Self operator+ (const Self &f) const { return _d+f._d; } Self operator- (const Self &f) const { return _d-f._d; } Self operator* (const Self &f) const { return _d*f._d; } Self operator/ (const Self &f) const { return _d/f._d; } Self operator- () const { return -_d; } Self& operator+=(const Self &f) { return *this = _d + f._d; } Self& operator-=(const Self &f) { return *this = _d - f._d; } Self& operator*=(const Self &f) { return *this = _d * f._d; } Self& operator/=(const Self &f) { return *this = _d / f._d; } #if 0 bool operator< (const Self &f) const { return _d < f._d; } #endif double dbl () const { return _d; } private: double _d; }; inline Restricted_double sqrt(const Restricted_double &f) { return CGAL_CLIB_STD::sqrt(f.dbl()); } inline Restricted_double abs(const Restricted_double &f) { return CGAL_CLIB_STD::fabs(f.dbl()); } inline double to_double(const Restricted_double &f) { return f.dbl(); } #else typedef double Restricted_double; #endif CGAL_END_NAMESPACE #endif // CGAL_RESTRICTED_DOUBLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Exact_type_selecter.h0000644000175000017500000000563511344301500031175 0ustar debiandebian// Copyright (c) 2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Exact_type_selecter.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_EXACT_TYPE_SELECTER_H #define CGAL_EXACT_TYPE_SELECTER_H // This is an undocumented private helper for Filtered_kernel. #include #include #include #include #ifdef CGAL_USE_GMP # include # include #endif #ifdef CGAL_USE_GMPXX # include #endif #ifdef CGAL_USE_LEDA # include # include # include #endif #ifdef CGAL_USE_CORE # include #endif CGAL_BEGIN_NAMESPACE // A class which tells the prefered exact number type corresponding to a type. // The default template chooses Quotient. // It should support the built-in types, MP_Float, Quotient. template < typename > struct Exact_type_selecter { typedef Quotient Type; }; // And we specialize for the following types : #ifdef CGAL_USE_GMP template <> struct Exact_type_selecter { typedef Gmpq Type; }; template <> struct Exact_type_selecter { typedef Gmpq Type; }; #endif #ifdef CGAL_USE_GMPXX template <> struct Exact_type_selecter< ::mpz_class> { typedef ::mpq_class Type; }; template <> struct Exact_type_selecter< ::mpq_class> { typedef ::mpq_class Type; }; #endif #ifdef CGAL_USE_LEDA template <> struct Exact_type_selecter { typedef leda_rational Type; }; template <> struct Exact_type_selecter { typedef leda_rational Type; }; template <> struct Exact_type_selecter { typedef leda_real Type; }; #endif #ifdef CGAL_USE_CORE template <> struct Exact_type_selecter { typedef CORE::Expr Type; }; #endif template < typename ET > struct Exact_type_selecter > { typedef Lazy_exact_nt Type; }; CGAL_END_NAMESPACE #endif // CGAL_EXACT_TYPE_SELECTER_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/0000755000175000017500000000000012146213732027103 5ustar debiandebian././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Pricing_strategy_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Pricing_str0000644000175000017500000001015711344301501031304 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Pricing_strategy_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_PRICING_STRATEGY_BASE_H #define CGAL_PRICING_STRATEGY_BASE_H // includes #include #include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class _Rep > class Pricing_strategy_base; template < class _Rep > class QP_solver; // Class interface // =============== template < class _Rep > class Pricing_strategy_base { public: // self typedef _Rep Rep; typedef Pricing_strategy_base Self; // the ambient QP solver typedef CGAL::QP_solver Solver; // types from the ambient QP solver typedef typename Solver::NT NT; typedef typename Solver::ET ET; typedef typename Solver::A_iterator A_iterator; typedef typename Solver::B_iterator B_iterator; typedef typename Solver::C_iterator C_iterator; typedef typename Solver::D_iterator D_iterator; typedef typename Solver::A_artificial_iterator A_artificial_iterator; typedef typename Solver::C_auxiliary_iterator C_auxiliary_iterator; typedef typename Solver::Basic_variable_index_iterator Basic_variable_index_iterator; typedef typename Solver::Basic_variable_value_iterator Basic_variable_value_iterator; typedef typename Solver::Basic_variable_numerator_iterator Basic_variable_numerator_iterator; typedef typename Solver::Lambda_value_iterator Lambda_value_iterator; typedef typename Solver::Lambda_numerator_iterator Lambda_numerator_iterator; // types from the representation class typedef typename Rep::Is_lp Is_lp; protected: // protected types typedef CGAL::Tag_true Tag_true; typedef CGAL::Tag_false Tag_false; public: // creation Pricing_strategy_base( ) { } // destruction virtual ~Pricing_strategy_base( ) { } // initialization void set( const Solver& solver, CGAL::Verbose_ostream& verbose_out) { solverP = &solver; voutP = &verbose_out; set(); } virtual void set( ) { } virtual void init( ) { } // access const Solver& solver( ) const { return *solverP; } CGAL::Verbose_ostream& vout ( ) const { return *voutP; } // operations virtual int pricing( ) = 0; virtual void leaving_basis( int) { } virtual void transition( ) { } private: // data members const Solver* solverP; // the ambient QP solver CGAL::Verbose_ostream* voutP; // used for verbose output }; CGAL_END_NAMESPACE #endif // CGAL_PRICING_STRATEGY_BASE_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Access_by_index.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Access_by_i0000644000175000017500000000347011344301501031224 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Access_by_index.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_ACCESS_BY_INDEX_H #define CGAL_ACCESS_BY_INDEX_H #include #include #include CGAL_BEGIN_NAMESPACE template < class RndAccIt, bool check_lower = false, bool check_upper = false> class Access_by_index { public: typedef int argument_type; typedef typename std::iterator_traits::value_type result_type; Access_by_index( RndAccIt it = RndAccIt(), const result_type& default_result = result_type(), int lower = 0, int upper = 0) : a( it), r( default_result) { if ( check_lower) l = lower; if ( check_upper) u = upper; } result_type operator () ( int i) const { if ( check_lower && i < l) return r; if ( check_upper && i >= u) return r; return a[ i]; } private: RndAccIt a; int l; int u; result_type r; }; CGAL_END_NAMESPACE #endif // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/identity.h0000644000175000017500000000221111344301501031070 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/identity.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_IDENTITY_H #define CGAL_IDENTITY_H #include #include CGAL_BEGIN_NAMESPACE template < class T > class identity : public CGAL_STD::unary_function { public: T operator () ( T t) const { return t; } }; CGAL_END_NAMESPACE #endif // CGAL_IDENTITY_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Full_exact_pricing.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Full_exact_0000644000175000017500000001320611344301501031244 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Full_exact_pricing.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_FULL_EXACT_PRICING_H #define CGAL_FULL_EXACT_PRICING_H // includes #include #include #include #include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class Rep > class Full_exact_pricing; // Class interface // =============== template < class _Rep > class Full_exact_pricing : public CGAL::Pricing_strategy_base<_Rep> { public: // self typedef _Rep Rep; typedef Full_exact_pricing Self; typedef Pricing_strategy_base Base; // types from the base class typedef typename Base::NT NT; typedef typename Base::ET ET; typedef typename Base::A_iterator A_iterator; typedef typename Base::B_iterator B_iterator; typedef typename Base::C_iterator C_iterator; typedef typename Base::D_iterator D_iterator; typedef typename Base::A_artificial_iterator A_artificial_iterator; typedef typename Base::C_auxiliary_iterator C_auxiliary_iterator; typedef typename Base::Basic_variable_index_iterator Basic_variable_index_iterator; typedef typename Base::Is_lp Is_lp; typedef typename Base::Solver Solver; typedef typename Base::Tag_true Tag_true; typedef typename Base::Tag_false Tag_false; using Base::vout; using Base::solver; private: // some constants ET et_0, et_2; public: // creation Full_exact_pricing( ) : et_0( 0), et_2( 2) { } // initialization void set( ) { CGAL_optimisation_debug { vout() << "full exact pricing" << std::endl; } } // operations int pricing( ) { typedef CGAL::Access_by_index< typename std::iterator_traits::value_type, false,false> Access_D_Bj; typedef CGAL::Join_random_access_iterator_1< Basic_variable_index_iterator, Access_D_Bj > D_Bj_iterator; const Solver& s = solver(); int n = s.number_of_variables(); int m = s.number_of_constraints(); ET d = s.variables_common_denominator(); int j, min_j = -1; ET mu, min_mu = 0; bool is_phase_I = ( s.phase() == 1); // loop over all non-basic variables for ( j = 0; j < ( is_phase_I ? n+m : n); ++j) { // variable non-basic? if ( ! s.is_basic( j)) { // compute mu_j if ( is_phase_I) { // phase I if ( j < n) { // original variable mu = std::inner_product( s.lambda_numerator_begin(), s.lambda_numerator_end(), s.a_begin()[ j], d * s.c_auxiliary_begin()[ j]); } else { // artificial variable mu = std::inner_product( s.lambda_numerator_begin(), s.lambda_numerator_end(), s.a_artificial_begin()[ j-n], d * s.c_auxiliary_begin()[ j]); } } else { // phase II mu = std::inner_product( s.lambda_numerator_begin(), s.lambda_numerator_end(), s.a_begin()[ j], d * s.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { mu += et_2 * std::inner_product( s.basic_variables_numerator_begin(), s.basic_variables_numerator_end(), D_Bj_iterator( s.basic_variables_index_begin(), Access_D_Bj( s.d_begin()[ j])), et_0); } } CGAL_optimisation_debug { vout() << "mu_" << j << ": " << mu << std::endl; } // new minimum? if ( mu < min_mu) { min_j = j; min_mu = mu; } } } vout() << std::endl; // return index of entering variable return min_j; } }; CGAL_END_NAMESPACE #endif // CGAL_FULL_EXACT_PRICING_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Sparse_vector_iterator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Sparse_vect0000644000175000017500000000710611344301501031277 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Sparse_vector_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_SPARSE_VECTOR_ITERATOR_H #define CGAL_SPARSE_VECTOR_ITERATOR_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class NT > class Sparse_vector_iterator { public: typedef NT value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; typedef Sparse_vector_iterator Self; typedef value_type Val; typedef difference_type Dist; typedef std::pair Entry; typedef std::vector Entries; typedef typename Entries::const_iterator EntryIterator; // forward operations Sparse_vector_iterator( ) : curr( 0), zero( 0) { } bool operator == ( const Self& it) const { return ( curr == it.curr); } bool operator != ( const Self& it) const { return ( curr != it.curr); } Val operator * ( ) const { EntryIterator it; for ( it = entries.begin(); it != entries.end(); ++it) if ( curr == it->first) return it->second; return zero; } Self& operator ++ ( ) { ++curr; return *this; } Self operator ++ ( int) { Self tmp = *this; ++curr; return tmp; } // bidirectional operations Self& operator -- ( ) { --curr; return *this; } Self operator -- ( int) { Self tmp = *this; --curr; return tmp; } // random access operations Self& operator += ( Dist n) { curr += n; return *this; } Self& operator -= ( Dist n) { curr -= n; return *this; } Self operator + ( Dist n) const { Self tmp=*this; return tmp+=n; } Self operator - ( Dist n) const { Self tmp=*this; return tmp-=n; } Dist operator - ( const Self& it) const { return curr - it.curr; } Val operator [] ( Dist i) const { Dist index = curr+i; EntryIterator it; for ( it = entries.begin(); it != entries.end(); ++it) if ( index == it->first) return it->second; return zero; } bool operator < ( const Self& it) const { return ( curr < it.curr); } bool operator > ( const Self& it) const { return ( curr > it.curr); } bool operator <= ( const Self& it) const { return ( curr <= it.curr); } bool operator >= ( const Self& it) const { return ( curr >= it.curr); } // additional operations void push_back( const Entry& entry) { entries.push_back( entry); } private: Dist curr; NT zero; std::vector entries; }; CGAL_END_NAMESPACE #endif // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Basis_inverse.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Basis_inver0000644000175000017500000006002211344301501031261 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Basis_inverse.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_BASIS_INVERSE_H #define CGAL_BASIS_INVERSE_H // includes #include #include #include #include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class ET_, class Is_lp_ > class Basis_inverse; template < class ET, class Is_lp > class Basis_inverse__entry_iterator; // Class interface // =============== template < class ET_, class Is_lp_ > class Basis_inverse { public: // self typedef ET_ ET; typedef Is_lp_ Is_lp; typedef Basis_inverse Self; private: // private types typedef std::vector Row; typedef std::vector Matrix; typedef CGAL::Tag_true Tag_true; typedef CGAL::Tag_false Tag_false; // friends friend class Basis_inverse__entry_iterator; public: // types typedef Basis_inverse__entry_iterator Entry_iterator; // creation Basis_inverse( CGAL::Verbose_ostream& verbose_out) : et_0( 0), et_1( 1), vout( verbose_out) { } // initialization template < class InputIterator1, class InputIterator2 > void init( unsigned int qp_m, unsigned int l, InputIterator1 u_it, InputIterator2 w_it, unsigned int max_size = 0) { CGAL_optimisation_precondition( qp_m > 0); m = qp_m; d = et_1; init( l, u_it, w_it, max_size, Is_lp()); CGAL_optimisation_debug { if ( vout.verbose()) { for ( unsigned int row = 0; row < k; ++row) { std::copy( M[ row].begin(), M[ row].end(), std::ostream_iterator( vout.out()," ")); vout.out() << std::endl; } vout.out() << "denominator = " << d << std::endl; } } } // access const ET& denominator( ) const { return d; } Entry_iterator column_begin( unsigned int j) const { return Entry_iterator( M, 0, j); } Entry_iterator column_end ( unsigned int j) const { return Entry_iterator( M, k, j); } // multiplication functions template < class ForwardIterator, class OutputIterator > void multiply( ForwardIterator z_l, ForwardIterator z_x, OutputIterator y_l, OutputIterator y_x) const { multiply( z_l, z_x, y_l, y_x, Is_lp()); } // special multiplication functions for LPs template < class ForwardIterator, class OutputIterator > void multiply_l( ForwardIterator z_x, OutputIterator y_l) const { multiply_l( z_x, y_l, Is_lp()); } template < class ForwardIterator, class OutputIterator > void multiply_x( ForwardIterator z_l, OutputIterator y_x) const { multiply_x( z_l, y_x, Is_lp()); } // update functions /* template < class ForwardIterator > inline void append( ForwardIterator q_l, ForwardIterator q_x, const ET& nu); inline void remove( unsigned int i); template < class RandomAccessIterator > inline void replace( unsigned int i, RandomAccessIterator q_x); */ // swap function /* inline void swap( unsigned int, unsigned int); */ private: // some constants const ET et_0, et_1; // data members unsigned int m; // number of constraints unsigned int k; // size of matrix Matrix M; // basis inverse, stored row-wise ET d; // denominator CGAL::Verbose_ostream& vout; // used for verbose output // initialization /* template < class InputIterator1, class InputIterator2 > inline void init( unsigned int l, InputIterator1 u_it, InputIterator2 w_it, unsigned int max_size, Tag_false); template < class InputIterator1, class InputIterator2 > inline void init( unsigned int l, InputIterator1 u_it, InputIterator2 w_it, unsigned int max_size, Tag_true ); */ // multiplication functions /* template < class ForIt, class OutIt > inline // QP void multiply( ForIt z_l, ForIt z_x, OutIt y_l, OutIt y_x, Tag_false) const; template < class ForIt, class OutIt > inline // LP void multiply( ForIt z_l, ForIt z_x, OutIt y_l, OutIt y_x, Tag_true ) const; */ // special multiplication functions for LPs /* template < class ForIt, class OutIt > inline // QP void multiply_l( ForIt z_x, OutIt y_l, Tag_false) const; template < class ForIt, class OutIt > inline // LP void multiply_l( ForIt z_x, OutIt y_l, Tag_true ) const; template < class ForIt, class OutIt > inline // QP void multiply_x( ForIt z_l, OutIt y_x, Tag_false) const; template < class ForIt, class OutIt > inline // LP void multiply_x( ForIt z_l, OutIt y_x, Tag_true ) const; */ // ============================================================================ // Class Implementation // ==================== // initialization // -------------- // initialization (QP) template < class InputIterator1, class InputIterator2 > inline void init( unsigned int l, InputIterator1 u_it, InputIterator2 w_it, unsigned int max_size, Tag_false) { k = 2*m; M.erase( M.begin(), M.end()); M.reserve( max_size > m ? m+max_size : k+1); unsigned int i; for ( i = 0; i < k; ) M.push_back( Row( ++i, et_0)); for ( i = 0; i < m; ++i, ++u_it, ++w_it) { M[ m+i][ l] = *w_it; M[ m+i][ i] = *u_it; } } // initialization (LP) template < class InputIterator1, class InputIterator2 > inline void init( unsigned int l, InputIterator1 u_it, InputIterator2 w_it, unsigned int, Tag_true) { k = m; M = Matrix( m, Row( m, et_0)); for ( unsigned int i = 0; i < m; ++i, ++u_it, ++w_it) { M[ i][ l] = *w_it; M[ i][ i] = *u_it; } } // multiplication functions // ------------------------ // multiply (QP) template < class ForIt, class OutIt > inline void multiply( ForIt z_l, ForIt z_x, OutIt y_l, OutIt y_x, Tag_false) const { typename Matrix::const_iterator matrix_it = M.begin(); typename Row ::const_iterator row_it; // left of diagonal typename Matrix::const_iterator column_it; // right of diagonal ForIt z_it; unsigned int row, count; ET sum; // compute P z_l + Q^T z_x for ( row = 0; row < m; ++row, ++y_l) { sum = et_0; // P: left of diagonal (inclusive) for ( row_it = matrix_it->begin(), z_it = z_l; row_it != matrix_it->end(); ++row_it, ++z_it ) { sum += *row_it * *z_it; } // P: right of diagonal (exclusive) for ( count = row+1, column_it = ++matrix_it; count < m; ++count, ++column_it, ++z_it ) { sum += (*column_it)[ row] * *z_it; } // Q^T: for ( z_it = z_x; count < k; ++count, ++column_it, ++z_it ) { sum += (*column_it)[ row] * *z_it; } // store result *y_l = sum; } // compute Q z_l + R z_x for ( ; row < k; ++row, ++y_x) { sum = et_0; // Q: for ( count = 0, row_it = matrix_it->begin(), z_it = z_l; count < m; ++count, ++row_it, ++z_it ) { sum += *row_it * *z_it; } // R: left of diagonal (inclusive) for ( z_it = z_x; row_it != matrix_it->end(); ++row_it, ++z_it ) { sum += *row_it * *z_it; } // R: right of diagonal (exclusive) for ( count = row+1, column_it = ++matrix_it; count < k; ++count, ++column_it, ++z_it ) { sum += (*column_it)[ row] * *z_it; } // store result *y_x = sum; } } // multiply (LP) template < class ForIt, class OutIt > inline void multiply( ForIt z_l, ForIt z_x, OutIt y_l, OutIt y_x, Tag_true) const { multiply_l( z_x, y_l); multiply_x( z_l, y_x); } // multiply_l (QP) template < class ForIt, class OutIt > inline void multiply_l( ForIt z_x, OutIt y_l, Tag_false) const { typename Matrix::const_iterator matrix_it = M.begin()+m; typename Matrix::const_iterator column_it; ForIt z_it; unsigned int row, count; ET sum; // compute Q^T z_x for ( row = 0; row < m; ++row, ++y_l) { sum = et_0; for ( count = 0, column_it = matrix_it, z_it = z_x; count < m; ++count, ++column_it, ++z_it ) { sum += (*column_it)[ row] * *z_it; } *y_l = sum; } } // multiply_x (QP) template < class ForIt, class OutIt > inline void multiply_x( ForIt z_l, OutIt y_x, Tag_false) const { typename Matrix::const_iterator matrix_it = M.begin()+m; typename Row ::const_iterator row_it; ForIt z_it; unsigned int row, count; ET sum; // compute Q z_l for ( row = 0; row < m; ++row, ++matrix_it, ++y_x) { sum = et_0; for ( count = 0, row_it = matrix_it->begin(), z_it = z_l; count < m; ++count, ++row_it, ++z_it ) { sum += *row_it * *z_it; } *y_x = sum; } } // multiply_l (LP) template < class ForIt, class OutIt > inline void multiply_l( ForIt z_x, OutIt y_l, Tag_true) const { typename Matrix::const_iterator matrix_it; ForIt z_it; unsigned int row; ET sum; // compute Q^T z_x for ( row = 0; row < m; ++row, ++y_l) { sum = et_0; for ( matrix_it = M.begin(), z_it = z_x; matrix_it != M.end(); ++matrix_it, ++z_it ) { sum += (*matrix_it)[ row] * *z_it; } *y_l = sum; } } // multiply_x (LP) template < class ForIt, class OutIt > inline void multiply_x( ForIt z_l, OutIt y_x, Tag_true) const { typename Matrix::const_iterator matrix_it = M.begin(); typename Row ::const_iterator row_it; ForIt z_it; ET sum; // compute Q z_l for ( ; matrix_it != M.end(); ++matrix_it, ++y_x) { sum = et_0; for ( row_it = matrix_it->begin(), z_it = z_l; row_it != matrix_it->end(); ++row_it, ++z_it ) { sum += *row_it * *z_it; } *y_x = sum; } } // update functions // ---------------- public: // append template < class ForIt > inline void append( ForIt q_l, ForIt q_x, const ET& nu) { // check for QP Assert_compile_time_tag( Tag_false(), Is_lp()); // handle sign of `nu' bool nu_negative = ( nu < et_0); if ( nu_negative) d = -d; // now `d' is `sgn(nu) * d' // update matrix in place // ---------------------- typename Matrix::iterator matrix_it = M.begin(); typename Row ::iterator row_it; ForIt q_it1, q_it2; unsigned int row, column; // rows: 0..m-1 for ( row = 0, q_it1 = q_l; row < m; ++row, ++q_it1, ++matrix_it) { // columns: 0..row for ( row_it = matrix_it->begin(), q_it2 = q_l; row_it != matrix_it->end(); ++row_it, ++q_it2 ){ *row_it *= nu; *row_it -= *q_it1 * *q_it2; *row_it /= d; // without remainder! } } // rows: m..k-1 for ( q_it1 = q_x; row < k; ++row, ++q_it1, ++matrix_it) { // columns: 0..m-1 for ( column = 0, row_it = matrix_it->begin(), q_it2 = q_l; column < m; ++column, ++row_it, ++q_it2 ){ *row_it *= nu; *row_it -= *q_it1 * *q_it2; *row_it /= d; // without remainder! } // columns: m..k-1 for ( q_it2 = q_x; row_it != matrix_it->end(); ++row_it, ++q_it2 ){ *row_it *= nu; *row_it -= *q_it1 * *q_it2; *row_it /= d; // without remainder! } } // store new row // ------------- // allocate new row, if necessary // otherwise `matrix_it' already points to first unused row ++k; if ( k > M.size()) { matrix_it = M.insert( M.end(), Row( k, et_0)); } // store entries in new row for ( column = 0, row_it = matrix_it->begin(); column < m; ++column, ++row_it , ++q_l) { *row_it = ( nu_negative ? -( *q_l) : *q_l); } for ( ; column < k-1; ++column, ++row_it , ++q_x) { *row_it = ( nu_negative ? -( *q_x) : *q_x); } *row_it = -d; // store new denominator // --------------------- d = ( nu_negative ? -nu : nu); CGAL_optimisation_postcondition( d > et_0); CGAL_optimisation_debug { if ( vout.verbose()) { for ( unsigned int row = 0; row < k; ++row) { std::copy( M[ row].begin(), M[ row].end(), std::ostream_iterator( vout.out(), " ")); vout.out() << std::endl; } vout.out() << "denominator = " << d << std::endl; } } } // remove void remove( unsigned int i) { // check for QP Assert_compile_time_tag( Tag_false(), Is_lp()); // check for last row/column CGAL_optimisation_precondition( m+i == k-1); // get `q^T = ( q_l^T | q_x^T)^T' and `d' from last row // ---------------------------------------------------- --k; typename Row::const_iterator q = M[ k].begin(); ET new_d = M[ k][ k]; // handle sign of `nu' if ( new_d > et_0) { d = -d; new_d = -new_d; } // update matrix in place // ---------------------- typename Matrix::iterator matrix_it = M.begin(); typename Row ::iterator row_it; typename Row ::const_iterator q_it1, q_it2; unsigned int row; // rows: 0..k-1 for ( row = 0, q_it1 = q; row < k; ++row, ++q_it1, ++matrix_it) { // columns: 0..row for ( row_it = matrix_it->begin(), q_it2 = q; row_it != matrix_it->end(); ++row_it, ++q_it2 ) { *row_it *= new_d; *row_it += *q_it1 * *q_it2; *row_it /= d; // without remainder! } } // store new denominator // --------------------- d = -new_d; CGAL_optimisation_postcondition( d > et_0); CGAL_optimisation_debug { if ( vout.verbose()) { for ( unsigned int row = 0; row < k; ++row) { std::copy( M[ row].begin(), M[ row].end(), std::ostream_iterator( vout.out(), " ")); vout.out() << std::endl; } vout.out() << "denominator = " << d << std::endl; } } } // replace template < class RanIt > inline void replace( unsigned int i, RanIt q_x) { // check for LP Assert_compile_time_tag( Tag_true(), Is_lp()); // check index CGAL_optimisation_precondition( i < m); // update matrix in place // ---------------------- typename Matrix:: iterator matrix_it = M.begin(); typename Row ::const_iterator row_i_it; typename Row :: iterator row_it; ET new_d = q_x[ i]; unsigned int row; // handle sign of `new_d' bool new_d_negative = ( new_d < et_0); if ( new_d_negative) { d = -d; new_d = -new_d; } // rows: 0..i-1 for ( row = 0; row < i; ++row, ++matrix_it, ++q_x) { // columns: 0..m-1 for ( row_it = matrix_it->begin(), row_i_it = M[ i].begin(); row_it != matrix_it->end(); ++row_it , ++row_i_it ) { *row_it *= new_d; *row_it -= *q_x * *row_i_it; *row_it /= d; // without remainder! } } // rows: i (flip signs, in necessary) if ( new_d_negative) { for ( row_it = matrix_it->begin(); row_it != matrix_it->end(); ++row_it ) { *row_it = -( *row_it); } } // rows: i+1..m-1 for ( ++row, ++matrix_it, ++q_x; row < m; ++row, ++matrix_it, ++q_x) { // columns: 0..m-1 for ( row_it = matrix_it->begin(), row_i_it = M[ i].begin(); row_it != matrix_it->end(); ++row_it , ++row_i_it ) { *row_it *= new_d; *row_it -= *q_x * *row_i_it; *row_it /= d; // without remainder! } } // store new denominator // --------------------- d = new_d; CGAL_optimisation_postcondition( d > et_0); CGAL_optimisation_debug { if ( vout.verbose()) { for ( unsigned int row = 0; row < k; ++row) { std::copy( M[ row].begin(), M[ row].end(), std::ostream_iterator( vout.out(), " ")); vout.out() << std::endl; } vout.out() << "denominator = " << d << std::endl; } } } // swap function // ------------- void swap( unsigned int i, unsigned int j) { // check for QP Assert_compile_time_tag( Tag_false(), Is_lp()); // check indices CGAL_optimisation_precondition( m+i < k); CGAL_optimisation_precondition( m+j < k); if ( i == j) return; // guarantee `i < j' if ( i > j) std::swap( i, j); // swap rows and columns // --------------------- i += m; j += m; typename Row::iterator row_i_it = M[ i].begin(); typename Row::iterator row_j_it = M[ j].begin(); typename Matrix::iterator matrix_it = M.begin()+(i+1); unsigned int count; // swap entries 0..i-1 (row <-> row) for ( count = 0; count < i; ++count, ++row_i_it, ++row_j_it) { std::iter_swap( row_i_it, row_j_it); } // swap entries i+1..j-1 (column <-> row) for ( ++count, ++row_j_it; count < j; ++count, ++matrix_it, ++row_j_it) { std::swap( ( *matrix_it)[ i], *row_j_it); } // swap entries j+1..k (column <-> column) for ( ++count, ++matrix_it; count < j; ++count, ++matrix_it) { std::swap( ( *matrix_it)[ i], ( *matrix_it)[ j]); } // swap entries i,i with j,j (entry <-> entry) std::iter_swap( row_i_it, row_j_it); } }; template < class ET, class Is_lp > class Basis_inverse__entry_iterator { public: typedef ET value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; typedef Basis_inverse__entry_iterator Self; typedef value_type Val; typedef difference_type Dist; typedef typename Basis_inverse::Matrix Matrix; // creation Basis_inverse__entry_iterator( const Matrix& M, Dist i, Dist j) : matrix( M), row( i), col( j) { } // compare operations bool operator == ( const Self& it) const { return ( row == it.row); } bool operator != ( const Self& it) const { return ( row != it.row); } // access Val operator * ( ) const { if ( ( ! CGAL::check_tag( Is_lp())) && ( col > row)) return matrix[ col][ row]; return matrix[ row][ col]; } // forward operations Self& operator ++ ( ) { ++row; return *this; } Self operator ++ ( int) { Self tmp = *this; ++row; return tmp; } // bidirectional operations Self& operator -- ( ) { --row; return *this; } Self operator -- ( int) { Self tmp = *this; --row; return tmp; } // random access operations Self& operator += ( Dist n) { row += n; return *this; } Self& operator -= ( Dist n) { row -= n; return *this; } Self operator + ( Dist n) const { Self tmp=*this; return tmp+=n; } Self operator - ( Dist n) const { Self tmp=*this; return tmp-=n; } Dist operator - ( const Self& it) const { return row - it.row; } Val operator [] ( Dist i) const { if ( ( ! CGAL::check_tag( Is_lp())) && ( col > row+i)) return matrix[ col][ row+i]; return matrix[ row+i][ col]; } bool operator < ( const Self& it) const { return ( row < it.row); } bool operator > ( const Self& it) const { return ( row > it.row); } bool operator <= ( const Self& it) const { return ( row <= it.row); } bool operator >= ( const Self& it) const { return ( row >= it.row); } private: const Matrix& matrix; Dist row; Dist col; }; CGAL_END_NAMESPACE #endif // CGAL_BASIS_INVERSE_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Const_value_iterator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Const_value0000644000175000017500000000630711344301501031305 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Const_value_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_CONST_VALUE_ITERATOR_H #define CGAL_CONST_VALUE_ITERATOR_H #include #include CGAL_BEGIN_NAMESPACE template < class T > class Const_value_iterator #ifdef __BORLANDC__ : public CGAL_STD:: iterator #endif { public: typedef T value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; typedef Const_value_iterator Self; typedef value_type Val; typedef difference_type Dist; typedef reference Ref; typedef pointer Ptr; // forward operations Const_value_iterator( const T& t = T(), Dist i = 0) : index( i), value( t) { } bool operator == ( const Self& it) const { return index == it.index;} bool operator != ( const Self& it) const { return index != it.index;} Val operator * ( ) const { return value; } Ptr operator -> ( ) const { return &value; } Self& operator ++ ( ) { ++index; return *this; } Self operator ++ ( int) { Self tmp = *this; ++index; return tmp; } // bidirectional operations Self& operator -- ( ) { --index; return *this; } Self operator -- ( int) { Self tmp = *this; --index; return tmp; } // random access operations Self& operator += ( Dist i) { index += i; return *this; } Self& operator -= ( Dist i) { index -= i; return *this; } Self operator + ( Dist i) const { Self tmp = *this; tmp += i; return tmp; } Self operator - ( Dist i) const { Self tmp = *this; tmp -= i; return tmp; } Dist operator - ( const Self& it) const { return index - it.index; } Val operator [] ( int) const { return value; } bool operator < ( const Self& it) const { return index < it.index; } bool operator > ( const Self& it) const { return index > it.index; } bool operator <= ( const Self& it) const { return index <= it.index; } bool operator >= ( const Self& it) const { return index >= it.index; } private: Dist index; T value; }; CGAL_END_NAMESPACE #endif // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/gmp_integer.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/gmp_integer0000644000175000017500000002037011344301501031317 0ustar debiandebian// Copyright (c) 1999,2003,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/gmp_integer.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef GMP_INTEGER_H #define GMP_INTEGER_H // includes #include #include namespace GMP { // Class declaration // ================= class Integer; // Function declaration // ==================== std::ostream& operator << ( std::ostream&, const Integer&); // Class interface // =============== class Integer { public: // construction Integer( ); Integer( const Integer&); Integer( int); Integer( signed long); Integer( unsigned long); Integer( double); // destruction ~Integer( ); // assignment Integer& operator = ( const Integer&); // comparisons bool operator == ( const Integer&) const; bool operator != ( const Integer&) const; bool operator < ( const Integer&) const; bool operator > ( const Integer&) const; bool operator <= ( const Integer&) const; bool operator >= ( const Integer&) const; // arithmetic operations Integer operator - ( ) const; Integer operator + ( const Integer&) const; Integer operator - ( const Integer&) const; Integer operator * ( const Integer&) const; Integer operator / ( const Integer&) const; // arithmetic assignment operations Integer& operator += ( const Integer&); Integer& operator -= ( const Integer&); Integer& operator *= ( const Integer&); Integer& operator /= ( const Integer&); // shift operations Integer operator << ( unsigned long) const; Integer operator >> ( unsigned long) const; // shift assignment operations Integer& operator <<= ( unsigned long); Integer& operator >>= ( unsigned long); // sign function int sign( ) const; // conversion functions long to_long ( ) const; double to_double( ) const; // access functions to the internal representation size_t length( ) const; unsigned long zeros ( ) const; private: // data members mpz_t value; // friends friend std::ostream& operator << ( std::ostream&, const Integer&); }; // ============================================================================ // Class implementation // ==================== // construction // ------------ // default constructor inline Integer:: Integer( ) { mpz_init( value); } // copy constructor inline Integer:: Integer( const Integer& integer) { mpz_init_set( value, integer.value); } // constructor (int) inline Integer:: Integer( int i) { mpz_init_set_si( value, i); } // constructor (signed long) inline Integer:: Integer( signed long sl) { mpz_init_set_si( value, sl); } // constructor (unsigned long) inline Integer:: Integer( unsigned long ul) { mpz_init_set_ui( value, ul); } // constructor (double) inline Integer:: Integer( double d) { mpz_init_set_d ( value, d); } // destruction // ----------- // destructor inline Integer:: ~Integer( ) { mpz_clear( value); } // assignment // ---------- inline Integer& Integer:: operator = ( const Integer& integer) { mpz_set( value, integer.value); return *this; } // comparisons // ----------- // equal inline bool Integer:: operator == ( const Integer& integer) const { return ( mpz_cmp( value, integer.value) == 0); } // not equal inline bool Integer:: operator != ( const Integer& integer) const { return ( mpz_cmp( value, integer.value) != 0); } // less inline bool Integer:: operator < ( const Integer& integer) const { return ( mpz_cmp( value, integer.value) < 0); } // greater inline bool Integer:: operator > ( const Integer& integer) const { return ( mpz_cmp( value, integer.value) > 0); } // less equal inline bool Integer:: operator <= ( const Integer& integer) const { return ( mpz_cmp( value, integer.value) <= 0); } // greater equal inline bool Integer:: operator >= ( const Integer& integer) const { return ( mpz_cmp( value, integer.value) >= 0); } // arithmetic operations // --------------------- // unary minus inline Integer Integer:: operator - ( ) const { Integer result; mpz_neg( result.value, value); return result; } // addition inline Integer Integer:: operator + ( const Integer& integer) const { Integer result; mpz_add( result.value, value, integer.value); return result; } // subtraction inline Integer Integer:: operator - ( const Integer& integer) const { Integer result; mpz_sub( result.value, value, integer.value); return result; } // multiplication inline Integer Integer:: operator * ( const Integer& integer) const { Integer result; mpz_mul( result.value, value, integer.value); return result; } // division (truncated) inline Integer Integer:: operator / ( const Integer& integer) const { Integer result; mpz_tdiv_q( result.value, value, integer.value); return result; } // arithmetic assignment operations // -------------------------------- // addition assignment inline Integer& Integer:: operator += ( const Integer& integer) { mpz_add( value, value, integer.value); return *this; } // subtraction assignment inline Integer& Integer:: operator -= ( const Integer& integer) { mpz_sub( value, value, integer.value); return *this; } // multiplication assignment inline Integer& Integer:: operator *= ( const Integer& integer) { mpz_mul( value, value, integer.value); return *this; } // division assignment inline Integer& Integer:: operator /= ( const Integer& integer) { mpz_tdiv_q( value, value, integer.value); return *this; } // shift operations // ---------------- // left shift inline Integer Integer:: operator << ( unsigned long i) const { Integer result; mpz_mul_2exp( result.value, value, i); return result; } // right shift inline Integer Integer:: operator >> ( unsigned long i) const { Integer result; mpz_tdiv_q_2exp( result.value, value, i); return result; } // shift assignment operations // --------------------------- // left shift assignment inline Integer& Integer:: operator <<= ( unsigned long i) { mpz_mul_2exp( value, value, i); return *this; } // right shift assignment inline Integer& Integer:: operator >>= ( unsigned long i) { mpz_tdiv_q_2exp( value, value, i); return *this; } // sign function // ------------- inline int Integer:: sign( ) const { return mpz_sgn( value); } // conversion functions // -------------------- // conversion to long inline long Integer:: to_long( ) const { return mpz_get_si( value); } // conversion to double inline double Integer:: to_double( ) const { return mpz_get_d( value); } // access functions to the internal representation // ----------------------------------------------- // number of bits inline size_t Integer:: length( ) const { return mpz_sizeinbase( value, 2); } // number of trailing zeros inline unsigned long Integer:: zeros ( ) const { if ( mpz_sgn( value) == 0) return 0; else return mpz_scan1( value, 0); } // I/O // --- // output operator inline std::ostream& operator << ( std::ostream& out, const Integer& integer) { out << mpz_get_str( (char*)0, 10, integer.value); return out; } } // namespace GMP #endif // GMP_INTEGER_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/QP_solver.C0000644000175000017500000003530411344301501031115 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/QP_solver.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr CGAL_BEGIN_NAMESPACE // Class Implementation (continued) // ================================ // initialization // -------------- // set-up of QP template < class Rep_ > void QP_solver:: set( int n, int m, int max_b, typename QP_solver::A_iterator A_it, typename QP_solver::B_iterator b_it, typename QP_solver::C_iterator c_it, typename QP_solver::D_iterator D_it) { CGAL_optimisation_debug { vout2 << std::endl << "------" << std::endl << "Set-Up" << std::endl << "------" << std::endl; vout << "[ " << ( CGAL::check_tag( Is_lp()) ? "L" : "Q") << "P, " << n << " variables, " << m << " constraints ]" << std::endl; } // store QP CGAL_optimisation_precondition( m > 0); CGAL_optimisation_precondition( n >= m); qp_n = n; qp_m = m; qp_A = A_it; qp_b = b_it; qp_c = c_it; qp_D = D_it; max_basis = max_b; // set up pricing strategy strategyP->set( *this, vout2); } // set-up of auxiliary problem template < class Rep_ > void QP_solver:: set_up_auxiliary_problem( ) { int ii; // delete artifical part of `A' and auxiliary `c', if necessary art_A.clear(); aux_c.clear(); // initialize artificial part of `A' and auxiliary `c' art_A.reserve( qp_m); aux_c.reserve( qp_n+qp_m); aux_c.insert( aux_c.end(), qp_n, nt_0); for ( ii = 0; ii < qp_m; ++ii) { Artificial_column art_col; art_col.push_back( std::make_pair( ii, qp_b[ ii] >= nt_0 ? nt_1 : nt_minus_1)); art_A.push_back( art_col); aux_c.push_back( nt_1); } // handling of zero `b_i's, if any if ( std::find( qp_b, qp_b+qp_m, nt_0) != qp_b+qp_m) { int k = 0; while ( ( k < qp_m) && ( qp_b[ k] == nt_0)) { ++k; } CGAL_optimisation_precondition( k < qp_m); for ( ii = 0; ii < qp_m; ++ii) { if ( qp_b[ ii] == nt_0) { art_A[ k].push_back( std::make_pair( ii, nt_minus_1)); } } } } // set-up of basis and basis inverse template < class Rep_ > void QP_solver:: set_up_basis( ) { int ii; // initialize basis (with artificial variables) if ( B.size() > 0) B.clear(); B.insert( B.end(), std::vector::size_type(qp_m), 0); for ( ii = 0; ii < qp_m; ++ii) B[ ii] = qp_n+ii; art_basic = qp_m; CGAL_optimisation_debug { vout1 << " "; vout2 << "initial "; vout << "basis: "; if ( vout.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator( vout.out(), " ")); vout.out() << std::endl; } vout3 << "initial basis-inverse:" << std::endl; } // initialize positions in basis if ( in_B.size() > 0) in_B.clear(); in_B.reserve( qp_n+qp_m); in_B.insert( in_B.end(), std::vector::size_type(qp_n), -1); for ( ii = 0; ii < qp_m; ++ii) in_B.push_back( ii); // initialize basis inverse int k = 0; while ( qp_b[ k] == nt_0) { ++k; } std::vector u, w; u.reserve( qp_m); w.reserve( qp_m); NT u_k = ( qp_b[ k] > nt_0 ? nt_1 : nt_minus_1); /***** NT u_k = nt_0; *****/ for ( ii = 0; ii < qp_m; ++ii) { if ( qp_b[ ii] < nt_0) { u.push_back( nt_minus_1); w.push_back( nt_0); } else { u.push_back( nt_1); w.push_back( qp_b[ ii] > nt_0 ? nt_0 : u_k); } } inv_M_B.init( qp_m, k, u.begin(), w.begin()); } // set-up of initial solution template < class Rep_ > void QP_solver:: set_up_initial_solution( ) { // initialize exact version of `qp_b' (implicit conversion to ET) #ifndef CGAL_CFG_RWSTD_NO_MEMBER_TEMPLATES b = Values( qp_b, qp_b+qp_m); #else b = Values ( qp_m ); std::copy(qp_b, qp_b+qp_m, b.begin()); #endif // initialize exact version of `-aux_c' (implicit conversion to ET) minus_c_B.clear(); minus_c_B.reserve( qp_m); std::transform( aux_c.begin()+qp_n, aux_c.end(), std::back_inserter( minus_c_B), std::negate()); // allocate storage lambda = Values( qp_m); x_B = Values( qp_m); // compute initial solution inv_M_B.multiply( b.begin(), minus_c_B.begin(), lambda.begin(), x_B.begin()); } // set-up of additional variables template < class Rep_ > void QP_solver:: set_up_additional_variables( ) { A_j = Values( qp_m); two_D_Bj = Values( qp_m); q_lambda = Values( qp_m); q_x = Values( qp_m); strategyP->init(); } // initialization of phase I template < class Rep_ > void QP_solver:: init( ) { CGAL_optimisation_debug { vout2 << std::endl << "--------------" << std::endl << "Initialization" << std::endl << "--------------" << std::endl; } // set up auxiliary problem set_up_auxiliary_problem(); // set up basis and basis inverse set_up_basis(); // set up initial solution set_up_initial_solution(); // set up additional variables set_up_additional_variables(); // set up status m_phase = 1; m_status = UPDATE; m_iterations = 0; is_phase_I = true; CGAL_optimisation_debug { vout2 << std::endl; vout2 << " b: "; if ( vout2.verbose()) { std::copy( b.begin(), b.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << " -c_B: "; if ( vout2.verbose()) { std::copy( minus_c_B.begin(), minus_c_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << "lambda: "; if ( vout2.verbose()) { std::copy( lambda.begin(), lambda.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << " x_B: "; if ( vout2.verbose()) { std::copy( x_B.begin(), x_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout1 << " "; vout2 << std::endl << "initial "; vout << "solution: "; CGAL::Quotient s = solution(); vout << s << " ~= " << CGAL::to_double( s) << std::endl; } } // transition to phase II template < class Rep_ > void QP_solver:: transition( ) { CGAL_optimisation_debug { vout1 << " t"; vout2 << std::endl << "T"; vout << "ransition to phase II" << std::endl; vout2 << "----------------------" << std::endl; } // remove artificial variables in_B.erase( in_B.begin()+qp_n, in_B.end()); // initialize exact version of `-qp_c' (implicit conversion to ET) Access_c_B access_c_B( qp_c); std::transform( c_B_iterator( B.begin(), access_c_B), c_B_iterator( B.end (), access_c_B), minus_c_B.begin(), std::negate()); // compute initial solution of phase II inv_M_B.multiply( b.begin(), minus_c_B.begin(), lambda.begin(), x_B.begin()); // update status m_phase = 2; is_phase_I = false; // notify pricing strategy strategyP->transition(); CGAL_optimisation_debug { vout2 << " b: "; if ( vout2.verbose()) { std::copy( b.begin(), b.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << " -c_B: "; if ( vout2.verbose()) { std::copy( minus_c_B.begin(), minus_c_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << "lambda: "; if ( vout2.verbose()) { std::copy( lambda.begin(), lambda.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << " x_B: "; if ( vout2.verbose()) { std::copy( x_B.begin(), x_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout1 << " "; vout2 << std::endl; vout << "solution: "; CGAL::Quotient s = solution(); vout << s << " ~= " << CGAL::to_double( s) << std::endl; } CGAL_optimisation_assertion( check_basis( Is_lp())); } // access functions // ---------------- // numerator of current solution template < class Rep_ > typename QP_solver::ET QP_solver:: solution_numerator( ) const { Basic_variable_index_iterator i_it, j_it; Basic_variable_numerator_iterator x_i_it, x_j_it; ET s = et_0, sum; int ii; bool is_phase_II = (phase() == 1); // compute c^T x + x^T D x (D is symmetric) // ------------------------------------------ // i: 0..|B|-1 i_it = basic_variables_index_begin(); x_i_it = basic_variables_numerator_begin(); for ( ; i_it != basic_variables_index_end(); ++i_it, ++x_i_it) { sum = et_0; ii = *i_it; if ( ! ( CGAL::check_tag( Is_lp()) || is_phase_II)) { // j: 0..i-1 j_it = basic_variables_index_begin(); x_j_it = basic_variables_numerator_begin(); for ( ; j_it != i_it; ++j_it, ++x_j_it) { // D_{ii,j} x_j sum += ET( qp_D[ ii][ *j_it]) * *x_j_it; } sum *= et_2; // D_{ii,ii} x_i sum += ET( qp_D[ ii][ ii]) * *x_i_it; } // d c_i sum += d * ( is_phase_II ? aux_c[ ii] : qp_c[ ii]); s += sum * *x_i_it; } return s; } // variables of dual LP template < class Rep_ > typename QP_solver::ET QP_solver:: dual_variable( int ii) const { Assert_compile_time_tag( Tag_true(), Is_lp()); Values unity( qp_m), col; unity[ ii] = et_1; col.reserve( qp_m); inv_M_B.multiply_x( unity.begin(), std::back_inserter( col)); return std::inner_product( col.begin(), col.end(), minus_c_B.begin(), et_0); } // pivot function // -------------- template < class Rep_ > void QP_solver:: pivot_step( ) { ++m_iterations; CGAL_optimisation_debug { vout2 << std::endl << "----------" << std::endl << "Pivot Step" << std::endl << "----------" << std::endl; vout << "[ phase " << ( is_phase_I ? "I" : "II") << ", iteration " << m_iterations << " ]" << std::endl; } // pricing // ------- pricing(); // check for optimality if ( j < 0 ) { // which phase? if ( is_phase_I) { // phase I // check for infeasibility if ( art_basic > 0 ) { m_phase = 3; m_status = INFEASIBLE; CGAL_optimisation_debug { vout1 << " "; vout << "problem is INFEASIBLE" << std::endl; } } else { // QP feasible, transition to phase II transition(); } } else { // phase II m_phase = 3; m_status = OPTIMAL; CGAL_optimisation_debug { vout1 << " "; vout << "solution is OPTIMAL" << std::endl; } } return; } /* // loop until new basis is found init_ratio_test_update_loop(); do { // ratio test // ---------- ratio_test(); // check for unboundedness if ( q_i == et_0 ) { m_phase = 3; m_status = UNBOUNDED; CGAL_optimisation_debug { vout1 << " "; vout << "problem is UNBOUNDED" << std::endl; } return; } // update // ------ update(); } while ( j >= 0 ); */ // ratio test // ---------- ratio_test(); // check for unboundedness if ( q_i == et_0 ) { m_phase = 3; m_status = UNBOUNDED; CGAL_optimisation_debug { vout1 << " "; vout << "problem is UNBOUNDED" << std::endl; } return; } // update // ------ update(); // loop until new basis is found // ----------------------------- iterated_ratio_test_update(); CGAL_optimisation_debug { vout1 << std::endl << " "; vout1 << "basis: "; if ( vout1.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator( vout1.out(), " ")); vout1.out() << std::endl; } vout1 << " "; vout2 << std::endl << "new "; vout << "solution: "; CGAL::Quotient s = solution(); vout << s << " ~= " << CGAL::to_double( s) << std::endl; } } CGAL_END_NAMESPACE // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Compute_quotient.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Compute_quo0000644000175000017500000000252411344301501031320 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Compute_quotient.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_COMPUTE_QUOTIENT_H #define CGAL_COMPUTE_QUOTIENT_H #include #include CGAL_BEGIN_NAMESPACE template < class NT > struct Compute_quotient { typedef NT argument1_type; typedef NT argument2_type; typedef CGAL::Quotient result_type; result_type operator () ( const NT& numer, const NT& denom) const { return result_type( numer, denom); } }; CGAL_END_NAMESPACE #endif // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/QP_solver.h0000644000175000017500000015147411344301501031171 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/QP_solver.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_QP_SOLVER_H #define CGAL_QP_SOLVER_H // includes #include #include //#include //#include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class Rep_ > class QP_solver; template < class Rep_ > class Pricing_strategy_base; template < class Rep_ > class Full_exact_pricing; // Class interface // =============== template < class Rep_ > class QP_solver { public: // self typedef Rep_ Rep; typedef QP_solver Self; // types from the representation class typedef typename Rep::NT NT; typedef typename Rep::ET ET; typedef typename Rep::A_iterator A_iterator; typedef typename Rep::B_iterator B_iterator; typedef typename Rep::C_iterator C_iterator; typedef typename Rep::D_iterator D_iterator; typedef typename Rep::Is_lp Is_lp; private: // private types typedef CGAL::Tag_true Tag_true; typedef CGAL::Tag_false Tag_false; typedef std::vector Indices; typedef Indices::const_iterator Index_iterator; typedef std::vector Values; typedef typename Values::const_iterator Value_iterator; typedef CGAL::Compute_quotient Compute_quotient; typedef std::binder2nd< Compute_quotient > Make_quotient; typedef CGAL::Access_by_index Access_value_checked; typedef CGAL::Sparse_vector_iterator Artificial_column; typedef std::vector A_artificial; typedef std::vector C_auxiliary; typedef CGAL::Access_by_index< C_iterator, false, false > Access_c_B; typedef CGAL::Join_random_access_iterator_1< Index_iterator, Access_c_B > c_B_iterator; typedef CGAL::Access_by_index< typename std::iterator_traits::value_type, false, true > Access_D_Bj; typedef CGAL::Join_random_access_iterator_1< Index_iterator, Access_D_Bj > D_Bj_iterator; public: // public types enum Status { UPDATE, INFEASIBLE, UNBOUNDED, OPTIMAL }; typedef Index_iterator Basic_variable_index_iterator; typedef Value_iterator Basic_variable_numerator_iterator; typedef CGAL::Join_random_access_iterator_1< Basic_variable_numerator_iterator, Make_quotient > Basic_variable_value_iterator; typedef CGAL::Join_random_access_iterator_1< Index_iterator, Access_value_checked > Variable_numerator_iterator; typedef CGAL::Join_random_access_iterator_1< Variable_numerator_iterator, Make_quotient > Variable_value_iterator; typedef Value_iterator Lambda_numerator_iterator; typedef CGAL::Join_random_access_iterator_1< Lambda_numerator_iterator, Make_quotient > Lambda_value_iterator; typedef CGAL::Pricing_strategy_base Pricing_strategy; typedef CGAL::Full_exact_pricing Pricing_strategy_default; typedef typename A_artificial::const_iterator A_artificial_iterator; typedef typename C_auxiliary::const_iterator C_auxiliary_iterator; // creation QP_solver( int verbose = 0, std::ostream& stream = std::cout); /* : nt_0( 0), nt_1( 1), nt_minus_1( -nt_1), et_0( 0), et_1( 1), et_2( 2), vout1( verbose == 1, stream), vout2( verbose >= 2, stream), vout3( verbose == 3, stream), vout ( verbose > 0, stream), qp_n( 0), qp_m( 0), inv_M_B( vout3), m_phase( 0), d( inv_M_B.denominator()), strategyP( &strategy_default) { CGAL_optimisation_debug { vout2 << "======================================" << std::endl << "The CGAL Solver for Quadratic Programs" << std::endl << "======================================" << std::endl; } } */ // set-up of QP void set( int n, int m, int max_b, A_iterator A, B_iterator b, C_iterator c, D_iterator D); // initialization (of phase I) void init( ); // access to QP int number_of_variables ( ) const { return qp_n; } int number_of_constraints( ) const { return qp_m; } A_iterator a_begin( ) const { return qp_A; } A_iterator a_end ( ) const { return qp_A+qp_n; } B_iterator b_begin( ) const { return qp_b; } B_iterator b_end ( ) const { return qp_b+qp_m; } C_iterator c_begin( ) const { return qp_c; } C_iterator c_end ( ) const { return qp_c+qp_n; } D_iterator d_begin( ) const { return qp_D; } D_iterator d_end ( ) const { return qp_D+qp_n; } // access to current status int phase ( ) const { return m_phase; } Status status ( ) const { return m_status; } int iterations( ) const { return m_iterations; } bool is_optimal( ) const { return status() == OPTIMAL; } // access to common denominator const ET& variables_common_denominator( ) const { return d; } // access to basic variables int number_of_basic_variables( ) const { return B.size(); } Basic_variable_index_iterator basic_variables_index_begin( ) const { return B.begin(); } Basic_variable_index_iterator basic_variables_index_end ( ) const { return B.end(); } Basic_variable_numerator_iterator basic_variables_numerator_begin( ) const { return x_B.begin(); } Basic_variable_numerator_iterator basic_variables_numerator_end ( ) const { return x_B.end(); } Basic_variable_value_iterator basic_variables_value_begin( ) const { return Basic_variable_value_iterator( basic_variables_numerator_begin(), Make_quotient( Compute_quotient(), d)); } Basic_variable_value_iterator basic_variables_value_end ( ) const { return Basic_variable_value_iterator( basic_variables_numerator_end (), Make_quotient( Compute_quotient(), d)); } bool is_basic( int ii) const { CGAL_optimisation_precondition( ii >= 0); CGAL_optimisation_precondition( ii < ( phase() == 1 ? number_of_variables()+number_of_constraints() : number_of_variables())); return ( in_B[ ii] >= 0); } // access to variables Variable_numerator_iterator variables_numerator_begin( ) const { return Variable_numerator_iterator( in_B.begin(), Access_value_checked( x_B.begin(), et_0)); } Variable_numerator_iterator variables_numerator_end ( ) const { return Variable_numerator_iterator( in_B.end (), Access_value_checked( x_B.begin(), et_0)); } Variable_value_iterator variables_value_begin( ) const { return Variable_value_iterator( variables_numerator_begin(), Make_quotient( Compute_quotient(), d)); } Variable_value_iterator variables_value_end ( ) const { return Variable_value_iterator( variables_numerator_end (), Make_quotient( Compute_quotient(), d)); } // access to current solution ET solution_numerator ( ) const; ET solution_denominator( ) const { return d*d; } Quotient solution( ) const { return Quotient( solution_numerator(), d*d); } // access to lambda Lambda_numerator_iterator lambda_numerator_begin( ) const { return lambda.begin(); } Lambda_numerator_iterator lambda_numerator_end ( ) const { return lambda.end(); } Lambda_value_iterator lambda_value_begin( ) const { return Lambda_value_iterator( lambda_numerator_begin(), Make_quotient( Compute_quotient(), d)); } Lambda_value_iterator lambda_value_end ( ) const { return Lambda_value_iterator( lambda_numerator_end (), Make_quotient( Compute_quotient(), d)); } // access to auxiliary problem A_artificial_iterator a_artificial_begin( ) const { return art_A.begin();} A_artificial_iterator a_artificial_end ( ) const { return art_A.end ();} C_auxiliary_iterator c_auxiliary_begin ( ) const { return aux_c.begin();} C_auxiliary_iterator c_auxiliary_end ( ) const { return aux_c.end ();} // access to variables of dual LP ET dual_variable( int i) const; // operations Status pivot( ) { CGAL_optimisation_precondition( phase() > 0); CGAL_optimisation_precondition( phase() < 3); pivot_step(); return status(); } Status solve( ) { CGAL_optimisation_precondition( phase() > 0); while ( phase() < 3) { pivot_step(); } return status(); } // altering the pricing strategy const Pricing_strategy& pricing_strategy() const; /* { return *strategyP; } */ void set_pricing_strategy( Pricing_strategy& pricing_strategy); /* { CGAL_optimisation_debug { vout2 << std::endl << "-----------------------" << std::endl << "Pricing Strategy Change" << std::endl << "-----------------------" << std::endl; } strategyP = &pricing_strategy; strategyP->set( *this, vout2); } */ // transition (to phase II) void transition( ); private: // some constants const NT nt_0, nt_1, nt_minus_1; const ET et_0, et_1, et_2; // verbose output streams CGAL::Verbose_ostream vout1; // used for some verbose output CGAL::Verbose_ostream vout2; // used for more verbose output CGAL::Verbose_ostream vout3; // used for very verbose output CGAL::Verbose_ostream vout; // used for any verbose output // given QP int qp_n; // number of variables int qp_m; // number of constraints A_iterator qp_A; // constraint matrix B_iterator qp_b; // right-hand-side vector C_iterator qp_c; // objective vector D_iterator qp_D; // objective matrix // HACK unsigned int max_basis; // current status Indices B; // basis Basis_inverse inv_M_B; // inverse of basis matrix Values lambda; Values x_B; // solution restricted to basis int m_phase; // phase of the Simplex method Status m_status; // status of last pivot step int m_iterations;// number of pivot steps const ET& d; // reference to `inv_M_B.denominator()' Indices in_B; // position in basis, -1 if non-basic // pricing strategy //Pricing_strategy_default strategy_default; Pricing_strategy* strategyP; int art_basic; // number of basic artificial variables // auxiliary problem A_artificial art_A; // artificial part of constraint matrix C_auxiliary aux_c; // auxiliary objective vector // additional variables Values b; // exact version of `qp_b' Values minus_c_B; // exact version of `-qp_c' // restricted to basis bool is_phase_I;// flag indicating phase I int j; // index of entering variable `x_j' Values A_j; // exact version of j-th column of A Values two_D_Bj; // exact version of twice the j-th // column of D restricted to basis B Values q_lambda; // used in the ratio test Values q_x; // --------- " ---------- int i; // index of leaving variable `x_i' ET x_i; // numerator of leaving variable `x_i' ET q_i; // corresponding `q_i' ET mu_j; // numerator of `t_j' ET nu; // denominator of `t_j' // ------------------------------------------------------------------------ // pivot step void pivot_step( ); // set-up functions void set_up_auxiliary_problem( ); void set_up_basis( ); void set_up_initial_solution( ); void set_up_additional_variables( ); // pricing // ------- void pricing( ) { CGAL_optimisation_debug { vout2 << std::endl << "Pricing" << std::endl << "-------" << std::endl; } if ( is_phase_I && ( art_basic == 0)) { j = -1; // all artificial variables non-basic CGAL_optimisation_debug { vout2 << "artificial variables are non-basic" << std::endl; } } else { // call pricing strategy j = strategyP->pricing(); CGAL_optimisation_debug { if ( j < 0) { vout2 << "entering variable: none" << std::endl; } else { vout1 << " "; vout << "entering"; vout2 << " variable"; vout << ": "; vout << j; vout2 << std::endl; } } } } /* // ratio test // ---------- void ratio_test( ) { CGAL_optimisation_debug { vout2 << std::endl << "Ratio Test" << std::endl << "----------" << std::endl; } // compute `q_lambda' and `q_x' CGAL_optimisation_debug { vout2 << " A_j: "; if ( vout2.verbose()) { std::copy( A_j.begin(), A_j.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } compute_q( Is_lp()); CGAL_optimisation_debug { vout2 << " q_x: "; if ( vout2.verbose()) { std::copy( q_x.begin(), q_x.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } // check `t_i's x_i = et_1; // trick: initialize q_i = et_0; // minimum with +oo Value_iterator x_it = x_B.begin(); Value_iterator q_it = q_x.begin(); for ( unsigned int k = 0; k < B.size(); ++k, ++x_it, ++q_it) { if ( ( *q_it > et_0) && ( ( *x_it * q_i) < ( x_i * *q_it))) { i = k; x_i = *x_it; q_i = *q_it; } } // check `t_j' check_t_j( Is_lp()); CGAL_optimisation_debug { vout2 << std::endl; for ( unsigned int k = 0; k < B.size(); ++k) { vout2 << "t_" << k << ": " << x_B[ k] << '/' << q_x[ k] << ( ( q_i > et_0) && ( i == (int)k) ? " *" : "") << std::endl; } if ( ! ( CGAL::check_tag( Is_lp()) || is_phase_I)) { vout2 << "t_j: " << mu_j << '/' << nu << ( ( q_i > et_0) && ( i < 0) ? " *" : "") << std::endl; } vout2 << std::endl; if ( q_i > et_0) { if ( i < 0) { vout2 << "leaving variable: none" << std::endl; } else { vout1 << ", "; vout << "leaving"; vout2 << " variable"; vout << ": "; vout << B[ i]; vout2 << " (= B[ " << i << "])" << std::endl; } } } } // initialization of ratio-test/update loop void init_ratio_test_update_loop( ) { // store exact version of `A_j' (implicit conversion to ET) if ( j < qp_n) { // original variable std::copy( qp_A[ j ], qp_A[ j ]+qp_m, A_j.begin()); } else { // artificial variable std::copy( art_A[ j-qp_n], art_A[ j-qp_n]+qp_m, A_j.begin()); } // store exact version of `2 D_{B,j}' store_2_D_Bj( Is_lp()); } // storing of exact version of `2 D_{B,j}' void store_2_D_Bj( Tag_false) // QP { if ( j < qp_n) { // original variable Access_D_Bj access_D_Bj( qp_D[ j], nt_0, 0, qp_n); std::transform( D_Bj_iterator( B.begin(), access_D_Bj), D_Bj_iterator( B.end (), access_D_Bj), two_D_Bj.begin(), std::bind1st( std::multiplies(), et_2)); } else { // artificial variable std::fill_n( two_D_Bj.begin(), B.size(), et_0); } } void store_2_D_Bj( Tag_true) // LP { // nop } // computation of `q_lambda' and `q_x' void compute_q( Tag_false) // QP { CGAL_optimisation_debug { vout2 << " 2 D_Bj: "; if ( vout2.verbose()) { std::copy( two_D_Bj.begin(), two_D_Bj.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } inv_M_B.multiply( A_j.begin(), two_D_Bj.begin(), q_lambda.begin(), q_x.begin()); CGAL_optimisation_debug { vout2 << std::endl; vout2 << "q_lambda: "; if ( vout2.verbose()) { std::copy( q_lambda.begin(), q_lambda.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } } void compute_q( Tag_true) // LP { inv_M_B.multiply_x( A_j.begin(), q_x.begin()); } // computation and checking of `t_j' void check_t_j( Tag_false) // QP { // compute `nu' nu = std::inner_product( q_x.begin(), q_x.end(), two_D_Bj.begin(), std::inner_product( q_lambda.begin(), q_lambda.end(), A_j.begin(), ( j < qp_n) ? -et_2*d*ET( qp_D[ j][ j]) : et_0)); if ( ! is_phase_I) { // compute `mu_j' mu_j = std::inner_product( x_B.begin(), x_B.end(), two_D_Bj.begin(), std::inner_product( lambda.begin(), lambda.end(), A_j.begin(), d * ( is_phase_I ? ET( aux_c[ j]) : ET( qp_c[ j])))); // check `t_j' if ( ( nu < et_0) && ( ( mu_j * q_i) > ( x_i * nu))) { i = -1; q_i = et_1; } } } void check_t_j( Tag_true) // LP { // nop } // update // ------ void update( ) { CGAL_optimisation_debug { vout2 << std::endl << "Update" << std::endl << "------"; } // update basis and basis inverse update_basis( Is_lp()); // compute current solution if ( is_phase_I) { inv_M_B.multiply_l( minus_c_B.begin(), lambda.begin()); inv_M_B.multiply_x( b.begin(), x_B.begin()); } else { inv_M_B.multiply( b.begin(), minus_c_B.begin(), lambda.begin(), x_B.begin()); } CGAL_optimisation_debug { vout2 << std::endl; vout2 << " -c_B: "; if ( vout2.verbose()) { std::copy( minus_c_B.begin(), minus_c_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << "lambda: "; if ( vout2.verbose()) { std::copy( lambda.begin(), lambda.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << " x_B: "; if ( vout2.verbose()) { std::copy( x_B.begin(), x_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } } // update of basis and basis inverse void update_basis( Tag_false) // QP { // append variable to basis if ( ( i < 0) || ( B.size() == (unsigned int)qp_m)) { CGAL_optimisation_debug { vout2 << std::endl << "--> non-basic variable " << j << " enters basis" << std::endl; } // update basis unsigned int k = B.size(); B.push_back( j); // `j' enters basis in_B[ j] = k; if ( is_phase_I && ( j >= qp_n)) ++art_basic; CGAL_optimisation_debug { vout2 << "new "; vout2 << "basis: "; if ( vout2.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout3 << "new basis-inverse:" << std::endl; } // update basis inverse inv_M_B.append( q_lambda.begin(), q_x.begin(), nu); // update status x_B.push_back( et_0); q_x.push_back( et_0); if ( k >= two_D_Bj.size()) { two_D_Bj.push_back( et_0); minus_c_B.push_back( -( is_phase_I ? ET( aux_c[ j]) : ET( qp_c[ j]))); } else { minus_c_B[ k] = is_phase_I ? -ET( aux_c[ j]) : -ET( qp_c[ j]); } // mark variable as entered j = -1; } // remove variable from basis if ( i >= 0) { CGAL_optimisation_debug { vout2 << std::endl << "<-- basic variable " << B[ i] << " leaves basis" << std::endl; } // make `i' the last index in `B' int k = B.size()-1; int l = B[ i]; if ( i < k) { inv_M_B.swap( i, k); std::swap( in_B[ B[ i]], in_B[ B[ k]]); B[ i] = B[ k]; minus_c_B[ i] = minus_c_B[ k]; two_D_Bj[ i] = two_D_Bj[ k]; } // update basis B.pop_back(); // `i' leaves basis in_B[ l] = -1; if ( is_phase_I && ( l >= qp_n)) --art_basic; CGAL_optimisation_debug { vout2 << "new "; vout2 << "basis: "; if ( vout2.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout3 << "new basis-inverse:" << std::endl; } // update basis inverse inv_M_B.remove( k); // update status x_B.pop_back(); q_x.pop_back(); // notify pricing strategy strategyP->leaving_basis( l); } } void update_basis( Tag_true) // LP { CGAL_optimisation_debug { vout2 << std::endl << "<--> non-basic variable " << j << " replaces basic variable " << B[ i] << std::endl; } // update basis int l = B[ i]; in_B[ B[ i] ] = -1; // `i' leaves basis in_B[ j ] = i; // `j' enters basis B[ i] = j; // `j' replaces `i' in basis if ( is_phase_I && ( j >= qp_n)) ++art_basic; if ( is_phase_I && ( l >= qp_n)) --art_basic; CGAL_optimisation_debug { vout2 << "new "; vout2 << "basis: "; if ( vout2.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout3 << "new basis-inverse:" << std::endl; } // update basis inverse inv_M_B.replace( i, q_x.begin()); // update status minus_c_B[ i] = -ET( is_phase_I ? aux_c[ j] : qp_c[ j]); // mark variable as entered j = -1; // notify pricing strategy strategyP->leaving_basis( l); } */ // ratio test // ---------- void ratio_test( ) { CGAL_optimisation_debug { vout2 << std::endl << "Ratio Test" << std::endl << "----------" << std::endl; } // initialize init_ratio_test(); // compute `q_lambda' and `q_x' compute_q( Is_lp()); CGAL_optimisation_debug { vout2 << " q_x: "; if ( vout2.verbose()) { std::copy( q_x.begin(), q_x.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } // check `t_i's x_i = et_1; // trick: initialize q_i = et_0; // minimum with +oo Value_iterator x_it = x_B.begin(); Value_iterator q_it = q_x.begin(); for ( unsigned int k = 0; k < B.size(); ++k, ++x_it, ++q_it) { if ( ( *q_it > et_0) && ( ( *x_it * q_i) < ( x_i * *q_it))) { i = k; x_i = *x_it; q_i = *q_it; } } // check `t_j' check_t_j( Is_lp()); CGAL_optimisation_debug { vout2 << std::endl; for ( unsigned int k = 0; k < B.size(); ++k) { vout2 << "t_" << k << ": " << x_B[ k] << '/' << q_x[ k] << ( ( q_i > et_0) && ( i == (int)k) ? " *" : "") << std::endl; } if ( ! ( CGAL::check_tag( Is_lp()) || is_phase_I)) { vout2 << "t_j: " << mu_j << '/' << nu << ( ( q_i > et_0) && ( i < 0) ? " *" : "") << std::endl; } vout2 << std::endl; if ( q_i > et_0) { if ( i < 0) { vout2 << "leaving variable: none" << std::endl; } else { vout1 << ", "; vout << "leaving"; vout2 << " variable"; vout << ": "; vout << B[ i]; vout2 << " (= B[ " << i << "])" << std::endl; } } } } // initialization of ratio-test void init_ratio_test( ) { // store exact version of `A_j' (implicit conversion to ET) if ( j < qp_n) { // original variable std::copy( qp_A[ j ], qp_A[ j ]+qp_m, A_j.begin()); } else { // artificial variable std::copy( art_A[ j-qp_n], art_A[ j-qp_n]+qp_m, A_j.begin()); } CGAL_optimisation_debug { vout2 << " A_j: "; if ( vout2.verbose()) { std::copy( A_j.begin(), A_j.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } // store exact version of `2 D_{B,j}' store_2_D_Bj( Is_lp()); } // storing of exact version of `2 D_{B,j}' void store_2_D_Bj( Tag_false) // QP { if ( j < qp_n) { // original variable Access_D_Bj access_D_Bj( qp_D[ j], nt_0, 0, qp_n); std::transform( D_Bj_iterator( B.begin(), access_D_Bj), D_Bj_iterator( B.end (), access_D_Bj), two_D_Bj.begin(), std::bind1st( std::multiplies(), et_2)); } else { // artificial variable std::fill_n( two_D_Bj.begin(), B.size(), et_0); } CGAL_optimisation_debug { vout2 << " 2 D_Bj: "; if ( vout2.verbose()) { std::copy( two_D_Bj.begin(), two_D_Bj.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } } void store_2_D_Bj( Tag_true) // LP { // nop } // computation of `q_lambda' and `q_x' void compute_q( Tag_false) // QP { inv_M_B.multiply( A_j.begin(), two_D_Bj.begin(), q_lambda.begin(), q_x.begin()); CGAL_optimisation_debug { vout2 << std::endl; vout2 << "q_lambda: "; if ( vout2.verbose()) { std::copy( q_lambda.begin(), q_lambda.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } } void compute_q( Tag_true) // LP { inv_M_B.multiply_x( A_j.begin(), q_x.begin()); } // computation and checking of `t_j' void check_t_j( Tag_false) // QP { // compute `nu' nu = std::inner_product( q_x.begin(), q_x.end(), two_D_Bj.begin(), std::inner_product( q_lambda.begin(), q_lambda.end(), A_j.begin(), ( j < qp_n) ? -et_2*d*ET( qp_D[ j][ j]) : et_0)); if ( ! is_phase_I) { // compute `mu_j' mu_j = std::inner_product( x_B.begin(), x_B.end(), two_D_Bj.begin(), std::inner_product( lambda.begin(), lambda.end(), A_j.begin(), d * ( is_phase_I ? ET( aux_c[ j]) : ET( qp_c[ j])))); // check `t_j' if ( ( nu < et_0) && ( ( mu_j * q_i) > ( x_i * nu))) { i = -1; q_i = et_1; } } } void check_t_j( Tag_true) // LP { // nop } // update // ------ void update( ) { CGAL_optimisation_debug { vout2 << std::endl << "Update" << std::endl << "------"; } // update basis and basis inverse update_basis( Is_lp()); // compute current solution compute_current_solution(); } // append variable to basis void append_variable( ) { CGAL_optimisation_debug { vout2 << std::endl << "--> non-basic variable " << j << " enters basis" << std::endl; } // update basis unsigned int k = B.size(); B.push_back( j); // `j' enters basis in_B[ j] = k; if ( is_phase_I && ( j >= qp_n)) ++art_basic; CGAL_optimisation_debug { vout2 << "new "; vout2 << "basis: "; if ( vout2.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator(vout2.out()," ")); vout2.out() << std::endl; } vout3 << "new basis-inverse:" << std::endl; } // update basis inverse inv_M_B.append( q_lambda.begin(), q_x.begin(), nu); // update status x_B.push_back( et_0); q_x.push_back( et_0); if ( k >= two_D_Bj.size()) { two_D_Bj.push_back( et_0); minus_c_B.push_back( -( is_phase_I ? ET( aux_c[ j]) : ET( qp_c[ j]))); } else { minus_c_B[ k] = is_phase_I ? -ET( aux_c[ j]) : -ET( qp_c[ j]); } CGAL_optimisation_assertion( check_basis( Is_lp())); } // remove variable from basis void remove_variable( ) { CGAL_optimisation_debug { vout2 << std::endl << "<-- basic variable " << B[ i] << " leaves basis" << std::endl; } // make `i' the last index in `B' int k = B.size()-1; int l = B[ i]; if ( i < k) { inv_M_B.swap( i, k); std::swap( in_B[ B[ i]], in_B[ B[ k]]); B[ i] = B[ k]; minus_c_B[ i] = minus_c_B[ k]; two_D_Bj[ i] = two_D_Bj[ k]; } // update basis B.pop_back(); // `i' leaves basis in_B[ l] = -1; if ( is_phase_I && ( l >= qp_n)) --art_basic; CGAL_optimisation_debug { vout2 << "new "; vout2 << "basis: "; if ( vout2.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator(vout2.out()," ")); vout2.out() << std::endl; } vout3 << "new basis-inverse:" << std::endl; } // update basis inverse inv_M_B.remove( k); // update status x_B.pop_back(); q_x.pop_back(); // notify pricing strategy strategyP->leaving_basis( l); // new basis found? if ( B.size() == (unsigned int)qp_m) { i = -1; } CGAL_optimisation_assertion( check_basis( Is_lp())); } // update of basis and basis inverse void update_basis( Tag_false) // QP { if ( B.size() < max_basis) { // append variable to basis append_variable(); // remove variable from basis (if any) if ( i >= 0) remove_variable(); } else { remove_variable(); inv_M_B.multiply( A_j.begin(), two_D_Bj.begin(), q_lambda.begin(), q_x.begin()); nu = std::inner_product( q_x.begin(), q_x.end(), two_D_Bj.begin(), std::inner_product( q_lambda.begin(), q_lambda.end(), A_j.begin(), ( j < qp_n) ? -et_2*d*ET( qp_D[ j][ j]) : et_0)); append_variable(); } } void update_basis( Tag_true) // LP { CGAL_optimisation_debug { vout2 << std::endl << "<--> non-basic variable " << j << " replaces basic variable " << B[ i] << std::endl; } // update basis int l = B[ i]; in_B[ l ] = -1; // `i' leaves basis in_B[ j ] = i; // `j' enters basis B[ i] = j; // `j' replaces `i' in basis if ( is_phase_I) { if ( j >= qp_n) ++art_basic; if ( l >= qp_n) --art_basic; } CGAL_optimisation_debug { vout2 << "new "; vout2 << "basis: "; if ( vout2.verbose()) { std::copy( B.begin(), B.end(), std::ostream_iterator(vout2.out()," ")); vout2.out() << std::endl; } vout3 << "new basis-inverse:" << std::endl; } // update basis inverse inv_M_B.replace( i, q_x.begin()); // update status minus_c_B[ i] = -ET( is_phase_I ? aux_c[ j] : qp_c[ j]); // notify pricing strategy strategyP->leaving_basis( l); // new basis found i = -1; } // computation of current solution void compute_current_solution( ) { if ( is_phase_I) { inv_M_B.multiply_l( minus_c_B.begin(), lambda.begin()); inv_M_B.multiply_x( b.begin(), x_B.begin()); } else { inv_M_B.multiply( b.begin(), minus_c_B.begin(), lambda.begin(), x_B.begin()); } CGAL_optimisation_debug { vout2 << std::endl; vout2 << " -c_B: "; if ( vout2.verbose()) { std::copy( minus_c_B.begin(), minus_c_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << "lambda: "; if ( vout2.verbose()) { std::copy( lambda.begin(), lambda.begin()+qp_m, std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } vout2 << " x_B: "; if ( vout2.verbose()) { std::copy( x_B.begin(), x_B.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } } // iterated ratio test and update // ------------------------------ void iterated_ratio_test_update( ) { loop_until_basis_found( Is_lp()); } // loop until new basis is found void loop_until_basis_found( Tag_false) // QP { while ( i >= 0 ) { // ratio test (iterated) ratio_test_iterated(); // check for unboundedness if ( q_i == et_0 ) { m_phase = 3; m_status = UNBOUNDED; CGAL_optimisation_debug { vout1 << " "; vout << "problem is UNBOUNDED" << std::endl; } return; } // update (iterated) update_iterated(); } } void loop_until_basis_found( Tag_true) // LP { // nop } // ratio test (iterated) void ratio_test_iterated( ) { CGAL_optimisation_debug { vout2 << std::endl << "Ratio Test (iterated)" << std::endl << "---------------------" << std::endl; } // get `q_x' unsigned int l = in_B[ j]; std::copy( inv_M_B.column_begin( qp_m+l)+qp_m, inv_M_B.column_end ( qp_m+l) , q_x.begin()); CGAL_optimisation_debug { vout2 << "q_x[ " << l << "]: "; if ( vout2.verbose()) { std::copy( q_x.begin(), q_x.begin()+B.size(), std::ostream_iterator( vout2.out(), " ")); vout2.out() << std::endl; } } // store frequently used values ET x_j = x_B[ l]; ET q_j = q_x[ l]; int sign_q_i_q_j = CGAL_NTS sign( q_j); // initialize minimum x_i = ( sign_q_i_q_j < 0) ? et_1 : -et_1; // trick: initialize q_i = et_0; // minimum with +oo // check `t_i's Value_iterator x_it = x_B.begin(); Value_iterator q_it = q_x.begin(); for ( unsigned int k = 0; k < B.size(); ++k, ++x_it, ++q_it) { if ( ( k != l) // t_i > 0 ? && (/* (( *q_it > et_0) && ( *x_it * q_j < x_j * *q_it)) ||*/ (( *q_it < et_0) && ( *x_it * q_j > x_j * *q_it))) // t_i < t_min ? && ( ( ( CGAL_NTS sign( *q_it) * sign_q_i_q_j > 0) && ( *x_it * q_i > x_i * *q_it)) || ( ( CGAL_NTS sign( *q_it) * sign_q_i_q_j < 0) && ( *x_it * q_i < x_i * *q_it)))) { // store new minimum i = k; x_i = *x_it; q_i = *q_it; sign_q_i_q_j = CGAL_NTS sign( q_j) * CGAL_NTS sign( q_i); } } // check `t_j' if ( ( x_j > et_0) && ( CGAL_NTS sign( x_i) * sign_q_i_q_j <= 0)) { i = -1; q_i = et_1; } CGAL_optimisation_debug { vout2 << std::endl; for ( unsigned int k = 0; k < B.size(); ++k) { if ( k != l) { vout2 << "t_" << k << ": " << x_j * q_x[k] - x_B[k] * q_j << '/' << q_x[k] << ( ( q_i != et_0) && (i == (int)k) ? " *" : "") << std::endl; } } vout2 << "t_j: " << x_j << '/' << et_1 << ( ( q_i > et_0) && ( i < 0) ? " *" : "") << std::endl << std::endl; if ( q_i != et_0) { if ( i < 0) { vout2 << "leaving variable: none" << std::endl; } else { vout1 << ", "; vout << "leaving"; vout2 << " variable"; vout << ": "; vout << B[ i]; vout2 << " (= B[ " << i << "])" << std::endl; } } } } // update (iterated) void update_iterated( ) { if ( i >= 0) { CGAL_optimisation_debug { vout2 << std::endl << "Update (iterated)" << std::endl << "-----------------"; } // update basis and basis inverse remove_variable(); CGAL_optimisation_assertion( check_basis( Is_lp())); // compute current solution compute_current_solution(); } } bool check_basis( Tag_true) // LP { return true; } bool check_basis( Tag_false) { if ( is_phase_I) return true; Values result( qp_m+B.size()); Values col_l( qp_m, et_0), col_x( B.size()); unsigned int i, j; // first part for ( i = 0; i < (unsigned int)qp_m; ++i) { // get source column for ( j = 0; j < B.size(); ++j) col_x[ j] = qp_A[ B[ j]][ i]; // compute target column inv_M_B.multiply( col_l.begin(), col_x.begin(), result.begin(), result.begin()+qp_m); // check result /* std::copy( result.begin(), result.end(), std::ostream_iterator( std::cerr, " ")); std::cerr << endl; */ for ( j = 0; j < qp_m+B.size(); ++j) { if ( ( ( j == i) && result[ j] != d) || ( ( j != i) && result[ j] != et_0)) return false; } } // second part for ( i = 0; i < B.size(); ++i) { j = B[ i]; // get source column std::copy( qp_A[ j], qp_A[ j]+qp_m, col_l.begin()); Access_D_Bj access_D_Bj( qp_D[ j], nt_0, 0, qp_n); std::transform( D_Bj_iterator( B.begin(), access_D_Bj), D_Bj_iterator( B.end (), access_D_Bj), col_x.begin(), std::bind1st( std::multiplies(), et_2)); // compute target column inv_M_B.multiply( col_l.begin(), col_x.begin(), result.begin(), result.begin()+qp_m); // check result /* std::copy( result.begin(), result.end(), std::ostream_iterator( std::cerr, " ")); std::cerr << endl; */ for ( j = 0; j < qp_m+B.size(); ++j) { if ( ( ( j == i+qp_m) && result[ j] != d) || ( ( j != i+qp_m) && result[ j] != et_0)) return false; } } return true; } }; CGAL_END_NAMESPACE #include #include CGAL_BEGIN_NAMESPACE template < class Rep_ > QP_solver:: QP_solver( int verbose, std::ostream& stream) : nt_0( 0), nt_1( 1), nt_minus_1( -nt_1), et_0( 0), et_1( 1), et_2( 2), vout1( verbose == 1, stream), vout2( verbose >= 2, stream), vout3( verbose == 3, stream), vout ( verbose > 0, stream), qp_n( 0), qp_m( 0), inv_M_B( vout3), m_phase( 0), d( inv_M_B.denominator()), strategyP( new Pricing_strategy_default) { CGAL_optimisation_debug { vout2 << "======================================" << std::endl << "The CGAL Solver for Quadratic Programs" << std::endl << "======================================" << std::endl; } } template < class Rep_ > const typename QP_solver::Pricing_strategy& QP_solver:: pricing_strategy() const { return *strategyP; } template < class Rep_ > void QP_solver:: set_pricing_strategy( typename QP_solver::Pricing_strategy& pricing_strategy) { CGAL_optimisation_debug { vout2 << std::endl << "-----------------------" << std::endl << "Pricing Strategy Change" << std::endl << "-----------------------" << std::endl; } strategyP = &pricing_strategy; strategyP->set( *this, vout2); } CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_QP_SOLVER_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Join_random_access_iterator.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Join_random0000644000175000017500000000641311344301501031260 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Join_random_access_iterator.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H #define CGAL_JOIN_RANDOM_ACCESS_ITERATOR_H #include #include CGAL_BEGIN_NAMESPACE template < class RndAccIt, class Operation > class Join_random_access_iterator_1 { public: typedef typename Operation::result_type value_type; typedef ptrdiff_t difference_type; typedef value_type* pointer; typedef value_type& reference; typedef std::random_access_iterator_tag iterator_category; typedef Join_random_access_iterator_1 Self; typedef value_type Val; typedef difference_type Dist; typedef reference Ref; // forward operations Join_random_access_iterator_1( ) { } Join_random_access_iterator_1( const RndAccIt& it_1) : it1( it_1) { } Join_random_access_iterator_1( const RndAccIt& it_1, const Operation& operation) : it1( it_1), op( operation) { } bool operator == ( const Self& it) const { return ( it1 == it.it1); } bool operator != ( const Self& it) const { return ( it1 != it.it1); } Val operator * ( ) const { return op( *it1); } Self& operator ++ ( ) { ++it1; return *this; } Self operator ++ ( int) { Self tmp = *this; ++it1; return tmp; } // bidirectional operations Self& operator -- ( ) { --it1; return *this; } Self operator -- ( int) { Self tmp = *this; --it1; return tmp; } // random access operations Self& operator += ( Dist n) { it1 += n; return *this; } Self& operator -= ( Dist n) { it1 -= n; return *this; } Self operator + ( Dist n) const { Self tmp = *this; return tmp += n; } Self operator - ( Dist n) const { Self tmp = *this; return tmp -= n; } Dist operator - ( const Self& it) const { return it1 - it.it1; } Val operator [] ( int i) const { return op( it1[ i]); } bool operator < ( const Self& it) const { return ( it1 < it.it1); } bool operator > ( const Self& it) const { return ( it1 > it.it1); } bool operator <= ( const Self& it) const { return ( it1 <= it.it1); } bool operator >= ( const Self& it) const { return ( it1 >= it.it1); } private: RndAccIt it1; Operation op; }; CGAL_END_NAMESPACE #endif // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/gmp_double.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/gmp_double.0000644000175000017500000002205011344301501031207 0ustar debiandebian// Copyright (c) 1999,2003,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/gmp_double.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef GMP_DOUBLE_H #define GMP_DOUBLE_H // includes #include #include #include namespace GMP { // Class declaration // ================= class Double; // Function declaration // ==================== inline std::ostream& operator << ( std::ostream&, const Double&); // Class interface // =============== class Double { public: // types typedef GMP::Integer Mantissa; typedef long Exponent; // construction Double( ); Double( const Double&); Double( int); Double( double); Double( const Mantissa&, const Exponent&); // comparisons bool operator == ( const Double&) const; bool operator != ( const Double&) const; bool operator < ( const Double&) const; bool operator > ( const Double&) const; bool operator <= ( const Double&) const; bool operator >= ( const Double&) const; // arithmetic operations Double operator - ( ) const; Double operator + ( const Double&) const; Double operator - ( const Double&) const; Double operator * ( const Double&) const; Double operator / ( const Double&) const; // arithmetic assignment operations Double& operator += ( const Double&); Double& operator -= ( const Double&); Double& operator *= ( const Double&); Double& operator /= ( const Double&); // shift operations Double operator << ( unsigned long) const; Double operator >> ( unsigned long) const; // shift assignment operations Double& operator <<= ( unsigned long); Double& operator >>= ( unsigned long); // sign function int sign( ) const; // conversion function double to_double( ) const; // access functions to the internal representation const Mantissa& mantissa( ) const; const Exponent& exponent( ) const; // normalization bool is_normal( ) const; void normalize( ); private: // data members Mantissa m; Exponent e; }; // ============================================================================ // Class implementation // ==================== // normalization // ------------- // is normalized? inline bool Double:: is_normal( ) const { return ( m.zeros() == 0); } // normalize inline void Double:: normalize( ) { if ( m == 0) e = 0; else { int zeros = m.zeros(); m >>= zeros; e += zeros; } } // construction // ------------ // default constructor inline Double:: Double( ) : e( 0) { } // copy constructor inline Double:: Double( const Double& d) : m( d.m), e( d.e) { } // constructor (int) inline Double:: Double( int i) : m( i), e( 0) { } // constructor (double) inline Double:: Double( double d) { if ( d == 0.0) e = 0; else { int exp; double x = frexp( d, &exp); m = Mantissa( ldexp( x, 53)); e = exp-53; normalize(); } } // constructor (mantissa, exponent) inline Double:: Double( const Mantissa& mantissa, const Exponent& exponent) : m( mantissa), e( exponent) { normalize(); } // comparisons // ----------- // equal inline bool Double:: operator == ( const Double& d) const { if ( e < d.e) return ( m == ( d.m << ( d.e - e))); if ( e > d.e) return ( ( m << ( e - d.e)) == d.m ); return ( m == d.m); } // not equal inline bool Double:: operator != ( const Double& d) const { return !( *this == d); } // less inline bool Double:: operator < ( const Double& d) const { if ( e < d.e) return ( m < ( d.m << ( d.e - e))); if ( e > d.e) return ( ( m << ( e - d.e)) < d.m ); return ( m < d.m); } inline bool operator < (int i, const Double& d) { Double ld(i); return ld < d; } inline bool operator < (const Double& d, int i) { Double rd(i); return d < rd; } // greater inline bool Double:: operator > ( const Double& d) const { return ( d < *this); } inline bool operator > (int i, const Double& d) { Double ld(i); return ld > d; } inline bool operator > (const Double& d, int i) { Double rd(i); return d > rd; } // less equal inline bool Double:: operator <= ( const Double& d) const { return !( d < *this); } // greater equal inline bool Double:: operator >= ( const Double& d) const { return !( *this < d); } // arithmetic operations // --------------------- // unary minus inline Double Double:: operator - ( ) const { return Double( -m, e); } // addition inline Double Double:: operator + ( const Double& d) const { if ( e < d.e) return Double( m + ( d.m << ( d.e - e)), e); if ( e > d.e) return Double( ( m << ( e - d.e)) + d.m, d.e); return Double( m + d.m, e); } // subtraction inline Double Double:: operator - ( const Double& d) const { if ( e < d.e) return Double( m - ( d.m << ( d.e - e)), e); if ( e > d.e) return Double( ( m << ( e - d.e)) - d.m, d.e); return Double( m - d.m, e); } // multiplication inline Double Double:: operator * ( const Double& d) const { return Double( m * d.m, e + d.e); } // division (without remainder) inline Double Double:: operator / ( const Double& d) const { // only correct if division result is representable // as a Double and both operands are normalized if ( ! d.is_normal()) const_cast( d).normalize(); if ( ! is_normal()) const_cast( this)->normalize(); return Double( m / d.m, e - d.e); } // arithmetic assignment operations // -------------------------------- // addition assignment inline Double& Double:: operator += ( const Double& d) { if ( e < d.e) { m += ( d.m << ( d.e - e)); return *this; } if ( e > d.e) { m = ( m << ( e - d.e)) + d.m; e = d.e; return *this; } // e == d.e m += d.m; return *this; } // subtraction assignment inline Double& Double:: operator -= ( const Double& d) { if ( e < d.e) { m -= ( d.m << ( d.e - e)); return *this; } if ( e > d.e) { m = ( m << ( e - d.e)) - d.m; e = d.e; return *this; } // e == d.e m -= d.m; return *this; } // multiplication assignment inline Double& Double:: operator *= ( const Double& d) { m *= d.m; e += d.e; return *this; } // division assignment inline Double& Double:: operator /= ( const Double& d) { // only correct if division result is representable // as a Double and both operands are normalized if ( ! d.is_normal()) const_cast( d).normalize(); if ( ! is_normal()) normalize(); m /= d.m; e -= d.e; return *this; } // shift operations // ---------------- // left shift inline Double Double:: operator << ( unsigned long i) const { return Double( m, e+i); } // right shift inline Double Double:: operator >> ( unsigned long i) const { return Double( m, e-i); } // shift assignment operations // --------------------------- // left shift assignment inline Double& Double:: operator <<= ( unsigned long i) { e += i; return *this; } // right shift assignment inline Double& Double:: operator >>= ( unsigned long i) { e -= i; return *this; } // sign function // ------------- inline int Double:: sign( ) const { return m.sign(); } // conversion functions // -------------------- // conversion to double inline double Double:: to_double( ) const { return ldexp( m.to_double(), e); } // Also add global function in this namespace for Koenig lookup. inline double to_double(const Double &d) { return d.to_double(); } // access functions to the internal representation // ----------------------------------------------- // mantissa inline const Double::Mantissa& Double:: mantissa( ) const { return m; } // exponent inline const Double::Exponent& Double:: exponent( ) const { return e; } // I/O // --- // output operator inline std::ostream& operator << ( std::ostream& out, const Double& d) { out << "( " << d.mantissa() << ", " << d.exponent() << ')'; return out; } } // namespace GMP #endif // GMP_DOUBLE_H // ===== EOF ================================================================== mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Double.h0000644000175000017500000000354211344301501030461 0ustar debiandebian// Copyright (c) 1999,2003,2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Double.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_GMP_DOUBLE_H #define CGAL_GMP_DOUBLE_H #include #include CGAL_BEGIN_NAMESPACE template<> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_false Has_sqrt; typedef Tag_false Has_exact_ring_operations; typedef Tag_false Has_exact_division; typedef Tag_false Has_exact_sqrt; }; using GMP::to_double; inline bool is_finite( GMP::Double) { return true; } inline bool is_valid( GMP::Double) { return true; } inline io_Operator io_tag(GMP::Double) { return io_Operator(); } CGAL_END_NAMESPACE #endif // CGAL_GMP_DOUBLE_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Partial_filtered_pricing.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Partial_fil0000644000175000017500000005244011344301501031250 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Partial_filtered_pricing.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_PARTIAL_FILTERED_PRICING_H #define CGAL_PARTIAL_FILTERED_PRICING_H // includes #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class Rep > class Partial_filtered_pricing; // Class interface // =============== template < class _Rep > class Partial_filtered_pricing : public CGAL::Pricing_strategy_base<_Rep> { public: // self typedef _Rep Rep; typedef Partial_filtered_pricing Self; typedef Pricing_strategy_base Base; // types from the base class typedef typename Base::NT NT; typedef typename Base::ET ET; typedef typename Base::A_iterator A_iterator; typedef typename Base::B_iterator B_iterator; typedef typename Base::C_iterator C_iterator; typedef typename Base::D_iterator D_iterator; typedef typename Base::A_artificial_iterator A_artificial_iterator; typedef typename Base::C_auxiliary_iterator C_auxiliary_iterator; typedef typename Base::Basic_variable_index_iterator Basic_variable_index_iterator; typedef typename Base::Is_lp Is_lp; typedef typename Base::Solver Solver; typedef typename Base::Tag_true Tag_true; typedef typename Base::Tag_false Tag_false; using Base::vout; using Base::solver; private: // some constants NT nt_0, nt_1, nt_2; ET et_0, et_2; // data members std::vector N; // non-basis int s; // size of active set std::vector row_max_A; std::vector row_max_D; std::vector row_valid; NT row_max_c; std::vector col_max; public: // creation Partial_filtered_pricing( ) : nt_0( 0), nt_1( 1), nt_2( 2), et_0( 0), et_2( 2) { } // initialization void set( ) { CGAL_optimisation_debug { vout() << "partial filtered pricing" << std::endl; } } void init( ) { int i, j; const Solver& solve = solver(); int n = solve.number_of_variables(); int m = solve.number_of_constraints(); s = min( 2*m, n); N.erase( N.begin(), N.end()); N.reserve( n); for ( i = 0; i < n; ++i) N.push_back( i); // compute maxima row_max_A = std::vector( m, nt_1); col_max = std::vector( n+m, nt_0); A_iterator Aj = solve.a_begin(); NT z; for ( j = 0; j < n; ++j, ++Aj) { for ( i = 0; i < m; ++i) { z = CGAL_NTS abs( (*Aj)[ i]); if ( z > row_max_A[ i]) row_max_A[ i] = z; if ( z > col_max [ j]) col_max [ j] = z; } } for ( j = n; j < n+m; ++j) { col_max[ j] = nt_1; } row_max_c = nt_1; } void transition( ) { const Solver& solve = solver(); int n = solve.number_of_variables(); int m = solve.number_of_constraints(); // remove artificial variables from N int j, i = 0; for ( j = n-m; j < n; ++j) { if ( N[ j] < n) { while ( N[ i] < n) { ++i; } N[ i] = N[ j]; } } N.erase( N.end()-m, N.end()); s = min( static_cast(m * CGAL_CLIB_STD::sqrt(static_cast(n))), n-m); // update row/column maxima of `A' C_iterator c_i = solve.c_begin(); NT z; for ( i = 0; i < n; ++i, ++c_i) { z = CGAL_NTS abs( *c_i); if ( z > col_max[ i]) col_max[ i] = z; if ( z > row_max_c ) row_max_c = z; } // compute row/column maxima of `D' if ( ! CGAL::check_tag( Is_lp())) { row_max_D = std::vector< NT >( n, nt_0); row_valid = std::vector( n, false); } } // operations int pricing( ) { typedef CGAL::Access_by_index< typename std::iterator_traits::value_type, false,false> Access_D_Bj; typedef CGAL::Join_random_access_iterator_1< Basic_variable_index_iterator, Access_D_Bj > D_Bj_iterator; const Solver& solve = solver(); int n = solve.number_of_variables(); int m = solve.number_of_constraints(); int b = solve.number_of_basic_variables(); ET d = solve.variables_common_denominator(); NT nt_d = CGAL_NTS to_double( d); int i, j, k, min_k = -1, min_j = -1; NT nt_mu, nt_min_mu = 0; ET mu, min_mu = 0; bool is_phase_I = ( solve.phase() == 1); // get inexact versions of `lambda' and `x_B' std::vector lambda, x_B; lambda.reserve( m); std::transform( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), std::back_inserter( lambda), To_double()); if ( ! ( CGAL::check_tag( Is_lp()) || is_phase_I)) { x_B.reserve( b); std::transform( solve.basic_variables_numerator_begin(), solve.basic_variables_numerator_end(), std::back_inserter( x_B), To_double()); } // loop over all active non-basic variables for ( k = 0; k < s; ++k) { j = N[ k]; // compute mu_j if ( is_phase_I) { // phase I if ( j < n) { // original variable nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_begin()[ j], nt_d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_artificial_begin()[ j-n], nt_d * solve.c_auxiliary_begin()[ j]); } } else { // phase II nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_begin()[ j], nt_d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { nt_mu += nt_2 * std::inner_product( x_B.begin(), x_B.end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), nt_0); } } CGAL_optimisation_debug { vout() << "nt_mu_" << j << ": " << nt_mu << std::endl; } // new minimum? if ( ( nt_mu < nt_min_mu) || ( ( min_j >= n) && ( j < n) && ( nt_mu == nt_min_mu))) { min_k = k; min_j = j; nt_min_mu = nt_mu; } } // exact check of entering variable if ( min_k >= 0) { j = N[ min_k]; if ( is_phase_I) { // phase I if ( j < n) { // original variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_artificial_begin()[ j-n], d * solve.c_auxiliary_begin()[ j]); } } else { // phase II mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { mu += et_2 * std::inner_product( solve.basic_variables_numerator_begin(), solve.basic_variables_numerator_end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), et_0); } } if ( mu >= et_0) { vout() << "entering variable defeated by exact check\n"; min_k = -1; min_j = -1; nt_min_mu = nt_0; } } if ( min_k < 0) { // -------------------------------------------------------------------- vout() << "no entering variable found so far, test remaining variables" // -------------------------------------------------------------------- << std::endl; // loop over all remaining non-basic variables for ( k = s; k < (int)N.size(); ++k) { j = N[ k]; // compute mu_j if ( is_phase_I) { // phase I if ( j < n) { // original variable nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_begin()[ j], nt_d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_artificial_begin()[ j-n], nt_d * solve.c_auxiliary_begin()[ j]); } } else { // phase II nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_begin()[ j], nt_d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { nt_mu += nt_2 * std::inner_product( x_B.begin(), x_B.end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), nt_0); } } CGAL_optimisation_debug { vout() << "nt_mu_" << j << ": " << nt_mu << std::endl; } // improving variable? if ( nt_mu < nt_0) { std::swap( N[ k], N[ s]); // new minimum? if ( ( nt_mu < nt_min_mu) || ( ( min_j >= n) && ( j < n) && ( nt_mu == nt_min_mu))) { min_k = s; min_j = j; nt_min_mu = nt_mu; } ++s; } } // exact check of entering variable if ( min_k >= 0) { j = N[ min_k]; if ( is_phase_I) { // phase I if ( j < n) { // original variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_artificial_begin()[ j-n], d * solve.c_auxiliary_begin()[ j]); } } else { // phase II mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { mu += et_2 * std::inner_product( solve.basic_variables_numerator_begin(), solve.basic_variables_numerator_end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), et_0); } } if ( mu >= et_0) { vout() << "entering variable defeated by exact check\n"; min_k = -1; nt_min_mu = nt_0; } } } if ( min_k < 0) { // ---------------------------------------------------------------- vout() << "no entering variable found so far, revert to exact arithmetic" // ---------------------------------------------------------------- << std::endl; // compute first error bound k = m+b+1; NT q = ldexp( 1.015625*k*(k+1), -53); NT max_1 = nt_d * row_max_c; NT max_2 = nt_d; NT z; for ( i = 0; i < m; ++i) { z = CGAL_NTS abs( lambda[ i]) * row_max_A[ i]; if ( z > max_1) max_1 = z; z = CGAL_NTS abs( lambda[ i]); if ( z > max_2) max_2 = z; } if ( ! CGAL::check_tag( Is_lp())) { typename std::iterator_traits::value_type row_D; for ( i = 0; i < b; ++i) { k = solve.basic_variables_index_begin()[ i]; row_D = solve.d_begin()[ k]; if ( ! row_valid[ k]) { NT max = nt_0; for ( j = 0; j < n; ++j) { z = CGAL_NTS abs( row_D[ j]); if ( z > max ) max = z; if ( z > col_max[ j]) col_max[ j] = z; } row_max_D[ k] = max; } z = CGAL_NTS abs( x_B[ i]) * row_max_D[ k]; if ( z > max_1) max_1 = z; z = CGAL_NTS abs( x_B[ i]); if ( z > max_2) max_2 = z; } } NT bound_1 = max_1 * q, max_u_q = max_2 * q, bound_2; CGAL_optimisation_debug { vout() << "[ first bound: " << bound_1 << " ]" << std::endl; } // loop again over all non-basic variables to verify optimality k = 0; while ( k < (int)N.size() && min_k < 0) { j = N[ k]; // compute mu_j (inexact) if ( is_phase_I) { // phase I if ( j < n) { // original variable nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_begin()[ j], nt_d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_artificial_begin()[ j-n], nt_d * solve.c_auxiliary_begin()[ j]); } } else { // phase II nt_mu = std::inner_product( lambda.begin(), lambda.end(), solve.a_begin()[ j], nt_d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { nt_mu += nt_2 * std::inner_product( x_B.begin(), x_B.end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), nt_0); } } CGAL_optimisation_debug { vout() << "nt_mu_" << j << ": " << nt_mu; } // check against first bound if ( nt_mu >= bound_1) { CGAL_optimisation_debug { vout() << " [ certified by first bound ]" << std::endl; } } else { // compute second bound bound_2 = col_max[ j] * max_u_q; if ( nt_mu >= bound_2) { CGAL_optimisation_debug { vout() << " [ certified by second bound: " << bound_2 << " ]" << std::endl; } } else { // compute mu_j (exact) if ( is_phase_I) { // phase I if ( j < n) { // original variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_artificial_begin()[ j-n], d * solve.c_auxiliary_begin()[ j]); } } else { // phase II mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { mu += et_2 * std::inner_product( solve.basic_variables_numerator_begin(), solve.basic_variables_numerator_end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), et_0); } } CGAL_optimisation_debug { vout() << " [ exact computation needed: " << mu << " ]" << std::endl; } if ( mu < et_0) min_k = k; } } ++k; } } vout() << std::endl; // return index of entering variable if ( min_k >= 0) { j = N[ min_k]; --s; N[ min_k] = N[ s]; N[ s] = N.back(); N.pop_back(); return j; } return -1; } void leaving_basis( int i) { if ( s == (int)N.size()) { N.push_back( i); } else { N.push_back( N[ s]); N[ s] = i; } ++s; } }; CGAL_END_NAMESPACE #endif // CGAL_PARTIAL_FILTERED_PRICING_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Partial_exact_pricing.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Partial_exa0000644000175000017500000002321611344301501031252 0ustar debiandebian// Copyright (c) 1997-2001 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/_QP_solver/Partial_exact_pricing.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr #ifndef CGAL_PARTIAL_EXACT_PRICING_H #define CGAL_PARTIAL_EXACT_PRICING_H // includes #include #include #include #include #include CGAL_BEGIN_NAMESPACE // Class declaration // ================= template < class Rep > class Partial_exact_pricing; // Class interface // =============== template < class _Rep > class Partial_exact_pricing : public CGAL::Pricing_strategy_base<_Rep> { public: // self typedef _Rep Rep; typedef Partial_exact_pricing Self; typedef Pricing_strategy_base Base; // types from the base class typedef typename Base::NT NT; typedef typename Base::ET ET; typedef typename Base::A_iterator A_iterator; typedef typename Base::B_iterator B_iterator; typedef typename Base::C_iterator C_iterator; typedef typename Base::D_iterator D_iterator; typedef typename Base::A_artificial_iterator A_artificial_iterator; typedef typename Base::C_auxiliary_iterator C_auxiliary_iterator; typedef typename Base::Basic_variable_index_iterator Basic_variable_index_iterator; typedef typename Base::Is_lp Is_lp; typedef typename Base::Solver Solver; typedef typename Base::Tag_true Tag_true; typedef typename Base::Tag_false Tag_false; using Base::vout; using Base::solver; private: // some constants ET et_0, et_2; // data members std::vector N; // non-basis int s; // size of active set public: // creation Partial_exact_pricing( ) : et_0( 0), et_2( 2) { } // initialization void set( ) { CGAL_optimisation_debug { vout() << "partial exact pricing" << std::endl; } } void init( ) { const Solver& solve = solver(); int n = solve.number_of_variables(); int m = solve.number_of_constraints(); s = min( 2*m, n); N.erase( N.begin(), N.end()); N.reserve( n); for ( int i = 0; i < n; ++i) N.push_back( i); } // operations int pricing( ) { typedef CGAL::Access_by_index< typename std::iterator_traits::value_type, false,false> Access_D_Bj; typedef CGAL::Join_random_access_iterator_1< Basic_variable_index_iterator, Access_D_Bj > D_Bj_iterator; const Solver& solve = solver(); int n = solve.number_of_variables(); ET d = solve.variables_common_denominator(); int j, min_k = -1, min_j = -1; ET mu, min_mu = 0; bool is_phase_I = ( solve.phase() == 1); // loop over all active non-basic variables for ( int k = 0; k < s; ++k) { j = N[ k]; // compute mu_j if ( is_phase_I) { // phase I if ( j < n) { // original variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_artificial_begin()[ j-n], d * solve.c_auxiliary_begin()[ j]); } } else { // phase II mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { mu += et_2 * std::inner_product( solve.basic_variables_numerator_begin(), solve.basic_variables_numerator_end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), et_0); } } CGAL_optimisation_debug { vout() << "mu_" << j << ": " << mu << std::endl; } // new minimum? if ( ( mu < min_mu) || ( ( min_j >= n) && ( j < n) && ( mu == min_mu))) { min_k = k; min_j = j; min_mu = mu; } } if ( min_k < 0) { // -------------------------------------------------------------------- vout() << "no entering variable found so far, test remaining variables" // -------------------------------------------------------------------- << std::endl; // loop over all remaining non-basic variables for ( int k = s; k < (int)N.size(); ++k) { j = N[ k]; // compute mu_j if ( is_phase_I) { // phase I if ( j < n) { // original variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_auxiliary_begin()[ j]); } else { // artificial variable mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_artificial_begin()[ j-n], d * solve.c_auxiliary_begin()[ j]); } } else { // phase II mu = std::inner_product( solve.lambda_numerator_begin(), solve.lambda_numerator_end(), solve.a_begin()[ j], d * solve.c_begin()[ j]); // is QP? if ( ! CGAL::check_tag( Is_lp())) { mu += et_2 * std::inner_product( solve.basic_variables_numerator_begin(), solve.basic_variables_numerator_end(), D_Bj_iterator( solve.basic_variables_index_begin(), Access_D_Bj( solve.d_begin()[ j])), et_0); } } CGAL_optimisation_debug { vout() << "mu_" << j << ": " << mu << std::endl; } // improving variable? if ( mu < et_0) { std::swap( N[ k], N[ s]); // new minimum? if ( ( mu < min_mu) || ( ( min_j >= n) && ( j < n) && ( mu == min_mu))) { min_k = s; min_j = j; min_mu = mu; } ++s; } } } vout() << std::endl; // return index of entering variable if ( min_k >= 0) { j = N[ min_k]; --s; N[ min_k] = N[ s]; N[ s] = N.back(); N.pop_back(); return j; } return -1; } void leaving_basis( int i) { if ( s == (int)N.size()) { N.push_back( i); } else { N.push_back( N[ s]); N[ s] = i; } ++s; } void transition( ) { const Solver& solve = solver(); int n = solve.number_of_variables(); int m = solve.number_of_constraints(); // remove artificial variables from N int i = 0; for ( int j = n-m; j < n; ++j) { if ( N[ j] < n) { while ( N[ i] < n) { ++i; } N[ i] = N[ j]; } } N.erase( N.end()-m, N.end()); s = min( static_cast(m * CGAL_CLIB_STD::sqrt(static_cast(n))), n-m); } }; CGAL_END_NAMESPACE #endif // CGAL_PARTIAL_EXACT_PRICING_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_support_set.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000002433711344301500031421 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_support_set.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_SUPPORTSET #define CGAL_MINIBALL_SUPPORTSET #include #include #include #include namespace CGAL_MINIBALL_NAMESPACE { namespace Min_sphere_of_spheres_d_impl { // The package provides specializations of (some of) the // algorithms for float and double, while the generic version // works with exact number types (which have no rounding // errors). So depending on the number type FT of the input (i.e., // of the input point coordinates and radii) we choose a different // algorithm. In fact, not only the algorithm depends on FT but // also the type of the result (i.e., of the radius and the center // coordinates of the miniball): if FT is an exact number type, // the result is a Pair (because the radius and the center // coordinates may be degree-2 numbers which we encode as pairs); // if on the other hand FT is float or double, the result type // coincides with FT. // // The following struct Selector contains the appropriate // result type, and a flag telling whether the exact or floating- // point specialization of the chosen algorithm is to be run. template struct Selector { typedef Pair Result; typedef Tag_true Is_exact; }; template<> struct Selector { typedef float Result; typedef Tag_false Is_exact; }; template<> struct Selector { typedef double Result; typedef Tag_false Is_exact; }; template struct Subtract_and_square { inline FT operator()(const FT x,const FT y) const { return sqr(x-y); } }; template class Subtract_and_square_pair { private: const FT& d; public: Subtract_and_square_pair(const FT& d) : d(d) {} inline Pair operator()(const Pair& x, const FT& y) const { const FT t = x.first - y; return Pair(sqr(t)+sqr(x.second)*d,FT(2)*t*x.second); } }; template struct Pair_to_double { const double root; Pair_to_double(const FT& disc) : root(std::sqrt(CGAL_MINIBALL_NTS to_double(disc))) {} inline double operator()(const Pair& p) const { return CGAL_MINIBALL_NTS to_double(p.first) + CGAL_MINIBALL_NTS to_double(p.second) * root; } }; template struct Subtract_and_square_to_double { inline double operator()(const double x,const FT& y) const { return sqr(x - CGAL_MINIBALL_NTS to_double(y)); } }; template class Support_set { private: // some short hands: typedef typename Traits::FT FT; typedef typename Min_sphere_of_spheres_d_impl:: Selector::Result Result; typedef typename Min_sphere_of_spheres_d_impl:: Selector::Is_exact Is_exact; typedef typename Traits::Use_square_roots Use_sqrt; typedef typename Traits::Sphere Sphere; static const int D = Traits::D; typedef typename Traits::Cartesian_const_iterator CIt; public: // constructor: inline Support_set(Traits& traits); public: // access: inline const Result& radius() const; inline const Result *begin() const; inline const FT& disc() const; public: // containment test: template bool contains(InputIterator c,const FT& r, const FT tol, const Tag_false is_exact) const { // scale ball: const FT r1 = sol[m]*tol; // check radii: if (r > r1) return false; // compute the (squared) distance from center to c: const FT dist = inner_product_n(center,c, FT(0),std::plus(),Subtract_and_square()); // check containment: return dist <= sqr(r1-r); } template bool contains(InputIterator c,const FT& r, const double,const Tag_true is_exact) const { typedef Pair P; // check radii: const P rd = sol[m]-r; if (is_neg(rd,discrim[m])) return false; // compute the (squared) distance from center to c: const P dist = inner_product_n(center,c, P(0,0),std::plus

    (),Subtract_and_square_pair(discrim[m])); // compute the square of rd: const P sqrRd(sqr(rd.first)+sqr(rd.second)*discrim[m], FT(2)*rd.first*rd.second); // check containment: return is_neg_or_zero(dist-sqrRd,discrim[m]); } public: // modification: void reset(); bool pivot(std::vector& l, int& e,const int d); private: // modification: bool push(const Sphere& ball); inline void pop(); bool is_spanning(); private: // utility: inline bool find_radius(const Tag_false is_exact); inline bool find_radius(const Tag_true is_exact); private: // traits class: Traits& t; private: // for internal consisteny checks: #ifdef CGAL_MINIBALL_DEBUG // The following variable is true if and only if no ball has been // pushed so far, or is_spanning() has been called at least once and // neither pop() nor push() have been called since last is_spanning(). bool is_spanning_was_called; #endif private: // member fields: int m; // number of pushed balls const Sphere *b[D+1]; // pointers to pushed balls Result center[D+1]; // contains, when is_spanning() returns true, // the center of the miniball // variables of the device: FT u[D+1][D]; FT d[D+1][D]; FT e[D+1][D]; FT f[D+1][D]; FT alpha[D+1]; FT delta[D+1]; FT eps[D+1]; FT phi[D+1]; FT sigma[D+1]; FT chi[D+1]; FT psi[D+1]; FT omega[D+1]; FT tau[D][D+1]; Result sol[D+2]; FT discrim[D+2]; FT maxradius[D+1]; }; template Support_set::Support_set(Traits& traits) : t(traits) { reset(); } template void Support_set::reset() { m = 0; sol[0] = FT(-1); discrim[0] = FT(0); CGAL_MINIBALL_DO_DEBUG(is_spanning_was_called = true); } template const typename Support_set::Result& Support_set::radius() const { CGAL_MINIBALL_ASSERT(is_spanning_was_called); return sol[m]; } template const typename Support_set::Result *Support_set::begin() const { CGAL_MINIBALL_ASSERT(is_spanning_was_called); return center; } template const typename Support_set::FT& Support_set::disc() const { CGAL_MINIBALL_ASSERT(is_spanning_was_called); return discrim[m]; } template void Support_set::pop() { CGAL_MINIBALL_ASSERT(m>0); CGAL_MINIBALL_DO_DEBUG(is_spanning_was_called = false); --m; } template bool Support_set::find_radius(const Tag_false is_exact) { using namespace Min_sphere_of_spheres_d_impl; // find discriminant: discrim[m+1] = sqr(psi[m]) - 4*chi[m]*omega[m]; if (discrim[m+1] < Min_float) return false; // handle degenerate quadratic: if (std::abs(chi[m]) < Min_float) { if (std::abs(psi[m]) < Min_float) return false; sol[m+1] = -omega[m]/psi[m]; return sol[m+1]*Tol >= maxradius[m]; } // calculate the two solutions: FT sd = std::sqrt(discrim[m+1]); if (psi[m] > 0) sd = -sd; Result sols[2] = { (sd-psi[m]) / (FT(2)*chi[m]), FT(2)*omega[m] / (sd-psi[m]) }; // order the solutions (*): if (sols[1] < sols[0]) std::swap(sols[0],sols[1]); // eliminate negative solutions: if (sols[0]*Tol >= maxradius[m]) { sol[m+1] = sols[0]; return true; } sol[m+1] = sols[1]; return sol[m+1]*Tol >= maxradius[m]; } template bool Support_set::find_radius(const Tag_true is_exact) { // find discriminant: discrim[m+1] = sqr(psi[m]) - FT(4)*chi[m]*omega[m]; if (discrim[m+1] < FT(0)) return false; // handle degenerate quadratic: if (chi[m] == FT(0)) { if (psi[m] == FT(0)) return false; sol[m+1] = Pair(-omega[m]/psi[m],FT(0)); return sol[m+1].first >= maxradius[m]; } // calculate the two solutions: const FT tmp = FT(-1)/(FT(2)*chi[m]); Result sols[2] = { Pair(psi[m]*tmp, tmp), Pair(psi[m]*tmp,-tmp) }; // order the solutions (*): if (chi[m] < FT(0)) std::swap(sols[0],sols[1]); CGAL_MINIBALL_ASSERT(is_neg_or_zero(sols[0]-sols[1],discrim[m+1])); // eliminate negative solutions: if (!is_neg(sols[0]-maxradius[m],discrim[m+1])) { sol[m+1] = sols[0]; return true; } sol[m+1] = sols[1]; return !is_neg(sols[1]-maxradius[m],discrim[m+1]); } } // namespace Min_sphere_of_spheres_d_impl } // namespace CGAL_MINIBALL_NAMESPACE #ifdef CGAL_MINIBALL_NO_TEMPLATE_EXPORT #include #endif #endif // CGAL_MINIBALL_SUPPORTSET ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Simple_container_wrapper.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Simple_container_wrapp0000644000175000017500000000406711344301501031457 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France) and // Notre Dame University (U.S.A.). All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Simple_container_wrapper.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_SIMPLE_CONTAINER_WRAPPER_H #define CGAL_SIMPLE_CONTAINER_WRAPPER_H #include #include CGAL_BEGIN_NAMESPACE template class Simple_container_wrapper { public: typedef C Container; typedef typename Container::value_type value_type; typedef typename Container::iterator iterator; typedef typename Container::const_iterator const_iterator; typedef typename Container::size_type size_type; private: typedef Simple_container_wrapper Self; public: Simple_container_wrapper(const Container& c = Container()) : c(c) {} iterator begin() { return c.begin(); } iterator end() { return c.end(); } std::pair insert(const value_type& t) { // std::pair it_b = c.insert(t); // return it_b.first; #if 1 return c.insert(t); #else c.push_back(t); return std::pair(--c.end(), true); #endif } void remove(iterator it) { c.erase(it); } void swap(Self& other) { c.swap(other.c); } void clear() { c.clear(); } size_type size() const { return c.size(); } private: Container c; }; CGAL_END_NAMESPACE #endif // CGAL_SIMPLE_CONTAINER_WRAPPER_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_y_monotone_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/partition_y_monotone_20000644000175000017500000004454111344301500031453 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/partition_y_monotone_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Susan Hert // // Implementaion of the algorithm from pp 49--55 of "Computational Geometry // Algorithms and Applications" by de Berg, van Kreveld, Overmars, and // Schwarzkopf for producing a partitioning of a polygon into y-monotone // pieces. // // NOTE: e_i = (v_i, v_{i+1}) // // TREE: // "Therefore we store the edges of P intersecting the sweep line in the // leaves of a dynamic binary search tree T. The left-to-right order of // the leaves of T corresponds to the left-to-right order of the edges. // Because we are only interested in edges to the left of split and merge // vertices we only need to store edges in T that have the interior of P // to their right. With each edge in T we store its helper." // // #ifndef CGAL_PARTITION_Y_MONOTONE_H #define CGAL_PARTITION_Y_MONOTONE_H #include #include #include #include #include #include #include #include #include #include #include namespace CGAL { enum Partition_y_mono_vertex_type {PARTITION_Y_MONO_START_VERTEX, PARTITION_Y_MONO_SPLIT_VERTEX, PARTITION_Y_MONO_REGULAR_VERTEX, PARTITION_Y_MONO_COLLINEAR_VERTEX, PARTITION_Y_MONO_MERGE_VERTEX, PARTITION_Y_MONO_END_VERTEX}; // // assumes CCW orientation of vertices // template Partition_y_mono_vertex_type partition_y_mono_vertex_type( BidirectionalCirculator c, const Traits& traits) { BidirectionalCirculator previous = c; previous--; BidirectionalCirculator next = c; next++; #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono__vertex_type: previous " << *previous << " c " << *c << " next " << *next << std::endl; #endif typename Traits::Compare_y_2 compare_y_2 = traits.compare_y_2_object(); if (compare_y_2(*previous, *c) == EQUAL && compare_y_2(*next, *c) == EQUAL) return PARTITION_Y_MONO_COLLINEAR_VERTEX; typename Traits::Less_yx_2 less_yx = traits.less_yx_2_object(); typename Traits::Left_turn_2 left_turn = traits.left_turn_2_object(); if (less_yx(*previous, *c)) { if (less_yx(*next, *c)) // previous and next both less_yx if (left_turn(*previous, *c, *next)) // interior angle less than pi return PARTITION_Y_MONO_START_VERTEX; else // interior angle greater than pi return PARTITION_Y_MONO_SPLIT_VERTEX; else // previous less_yx and next not return PARTITION_Y_MONO_REGULAR_VERTEX; } else { if (less_yx(*c, *next)) // previous and next both not less_yx if (left_turn(*previous, *c, *next)) // interior angle less than pi return PARTITION_Y_MONO_END_VERTEX; else // interior angle greater than pi return PARTITION_Y_MONO_MERGE_VERTEX; else // next less_yx and previous not return PARTITION_Y_MONO_REGULAR_VERTEX; } } template void partition_y_mono_print_tree(Tree tree) { typedef typename Tree::iterator iterator; iterator it = tree.begin(); for (; it != tree.end(); it++) { std::cout << "edge node " << *(*it).first << " helper " << *(*it).second << std::endl; } std::cout << std::endl; } template void partition_y_mono_handle_start_vertex(BidirectionalCirculator c, Tree& tree) { typedef typename Tree::value_type ValuePair; #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *c << " is a start vertex " << std::endl; #endif tree.insert(ValuePair(c, c)); #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_handle_start_vertex: after insert tree is " << std::endl; partition_y_mono_print_tree(tree); #endif // insert e_i (edge from *c to *++c) into "tree" with helper(e_i) = v_i } template void partition_y_mono_handle_end_vertex(BidirectionalCirculator c, Tree& tree, Partition_Poly& partition_poly, const Traits& traits ) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *c << " is an end vertex " << std::endl; #endif typedef typename Tree::iterator tree_iterator; tree_iterator it; BidirectionalCirculator previous = c; previous--; #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_end_vertex: previous " << *previous << std::endl; #endif it = tree.find(previous); CGAL_assertion (it != tree.end()); if (partition_y_mono_vertex_type((*it).second, traits) == PARTITION_Y_MONO_MERGE_VERTEX) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_end_vertex: diagonal " << *(*it).second << " to " << *c << std::endl; #endif partition_poly.insert_diagonal(c, (*it).second); } tree.erase(it); #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_end_vertex: after erase tree is " << std::endl; partition_y_mono_print_tree(tree); #endif // if helper(e_{i-1}) is a merge vertex // insert diagonal connecting v_i to helper(e_{i-1}) // delete e_{i-1} from tree } template inline void partition_y_mono_edge_directly_left(BidirectionalCirculator c, Tree& tree, Iterator& it) { it = tree.lower_bound(c); // edge directly to the left of v_i since the // items in the tree are sorted from right to // left #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG if (it != tree.end()) std::cout << "partition_y_mono_edge_directly_left: lower_bound edge node: " << *((*it).first) << " helper " << *((*it).second) << std::endl; #endif } template void partition_y_mono_handle_split_vertex(BidirectionalCirculator c, Tree& tree, Partition_Poly& partition_poly) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *c << " is a split vertex " << std::endl; #endif typedef typename Tree::iterator tree_iterator; typedef typename Tree::value_type ValuePair; tree_iterator it; partition_y_mono_edge_directly_left(c, tree, it); if (it != tree.end()) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_split_vertex: diagonal " << *(*it).second << " to " << *c << std::endl; #endif partition_poly.insert_diagonal(c, (*it).second); BidirectionalCirculator ej = (*it).first; tree.erase(it); tree.insert(ValuePair(ej, c)); } tree.insert(ValuePair(c, c)); #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_split_vertex: " << "after erase and inserts tree is" << std::endl; partition_y_mono_print_tree(tree); #endif // 1. find the edge e_j in tree directly to the left of v_i // 2. insert the diagonal connecting v_i to helper(e_j) // 3. helper(e_j) = v_i // 4. Insert e_i in tree and set helper(e_i) to v_i } template void partition_y_mono_handle_merge_vertex(BidirectionalCirculator c, Tree& tree, Partition_Poly& partition_poly, const Traits& traits) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *c << " is a merge vertex " << std::endl; #endif typedef typename Tree::iterator tree_iterator; typedef typename Tree::value_type ValuePair; BidirectionalCirculator prev = c; prev--; tree_iterator it = tree.find(prev); CGAL_assertion (it != tree.end()); if (partition_y_mono_vertex_type((*it).second,traits) == PARTITION_Y_MONO_MERGE_VERTEX) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_merge_vertex 1: diagonal " << *(*it).second << " to " << *c << std::endl; #endif partition_poly.insert_diagonal(c, (*it).second); } tree.erase(it); partition_y_mono_edge_directly_left(c, tree, it); if (it != tree.end()) { if (partition_y_mono_vertex_type((*it).second,traits) == PARTITION_Y_MONO_MERGE_VERTEX) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_merge_vertex 2: diagonal " << *(*it).second << " to " << *c << std::endl; #endif partition_poly.insert_diagonal(c, (*it).second); } BidirectionalCirculator ej = (*it).first; tree.erase(it); tree.insert(ValuePair(ej,c)); } #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_merge_vertex: after erase(s) tree is " << std::endl; partition_y_mono_print_tree(tree); #endif // 1. if helper(e_{i-1}) is a merge vertex // insert the diagonal connecting v_i to helper(e_{i-1}) // 2. delete e_{i-1} from tree // 3. find the edge e_j in tree directly to the left of v_i // 4. if helper(e_j) is a merge vertex // insert diagonal connecting v_i to helper(e_j) in polygon // 5. helper(e_j) = v_i } template bool partition_y_mono_interior_to_right(BidirectionalCirculator c, const Traits& traits) { typename Traits::Compare_y_2 compare_y_2 = traits.compare_y_2_object(); BidirectionalCirculator previous = c; previous--; Comparison_result cmp_y = compare_y_2(*previous, *c); if (cmp_y == LARGER) return true; BidirectionalCirculator next = c; next++; if (cmp_y == EQUAL && compare_y_2(*next, *c) == SMALLER) return true; return false; } template void partition_y_mono_handle_regular_vertex(BidirectionalCirculator c, Tree& tree, Partition_Poly& partition_poly, const Traits& traits ) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *c << " is a regular vertex " << std::endl; #endif typedef typename Tree::iterator tree_iterator; typedef typename Tree::value_type ValuePair; tree_iterator it; BidirectionalCirculator previous = c; previous--; if (partition_y_mono_interior_to_right(c, traits)) { it = tree.find(previous); CGAL_assertion( it != tree.end() ); if (partition_y_mono_vertex_type((*it).second, traits) == PARTITION_Y_MONO_MERGE_VERTEX) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_regular_vertex 1: diagonal " << *(*it).second << " to " << *c << std::endl; #endif partition_poly.insert_diagonal(c, (*it).second); } tree.erase(it); tree.insert(ValuePair(c,c)); } else { partition_y_mono_edge_directly_left(c, tree, it); CGAL_assertion (it != tree.end()); if (partition_y_mono_vertex_type((*it).second, traits) == PARTITION_Y_MONO_MERGE_VERTEX) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_regular_vertex 2: diagonal " << *c << " to " << *(*it).second << std::endl; #endif partition_poly.insert_diagonal(c, (*it).second); } BidirectionalCirculator ej = (*it).first; tree.erase(it); tree.insert(ValuePair(ej,c)); } #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_regular_vertex: " << "after erase and insert tree is" << std::endl; partition_y_mono_print_tree(tree); #endif // if interior of polygon lies to the right of v_i // if helper(e_{i-1}) is a merge vertex // insert diagonal connecting v_i to helper(e_{i-1}) in polygon // delete e_{i-1} from tree // insert e_i in tree and set helper(e_i) to v_i // else // find the edge e_j in tree directly left of v_i // if helper(e_j) is a merge vertex // insert diagonal connecting v_i to helper(e_j) in D // helper(e_j) = v_i } template void partition_y_mono_handle_collinear_vertex(BidirectionalCirculator c, Tree& tree) { typedef typename Tree::iterator tree_iterator; typedef typename Tree::value_type ValuePair; #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *c << " is a collinear vertex " << std::endl; #endif tree_iterator it; BidirectionalCirculator previous = c; previous--; #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << *previous << " is the previous vertex " << std::endl; #endif it = tree.find(previous); if ( it != tree.end() ) { #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "partition_y_mono_handle_collinear_vertex : removing " << *(*it).first << std::endl; #endif tree.erase(it); } tree.insert(ValuePair(c,c)); } template OutputIterator partition_y_monotone_2(InputIterator first, InputIterator beyond, OutputIterator result, const Traits& traits) { if (first == beyond) return result; typedef Partitioned_polygon_2< Traits > P_Polygon_2; typedef typename P_Polygon_2::iterator I; typedef Circulator_from_iterator Circulator; #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) OutputIterator res(result); #else typedef typename Traits::Polygon_2 Polygon_2; Tee_for_output_iterator res(result); #endif // no postcondition P_Polygon_2 polygon(first, beyond); CGAL_partition_precondition( orientation_2(polygon.begin(), polygon.end(), traits) == COUNTERCLOCKWISE); Circulator circ(polygon.begin(), polygon.end()), done = circ; std::vector circulators; CGAL_For_all(circ, done){ circulators.push_back(circ); } std::sort(circulators.begin(), circulators.end(), Indirect_not_less_yx_2(traits)); #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG std::cout << "Initial vertex list: "<< circulators << std::endl; for(std::vector::const_iterator it = circulators.begin(); it != circulators.end(); it++){ std::cout << **it << " " ; } std::cout << std::endl; #endif typedef std::map > Tree; Tree tree; typename std::vector::iterator it = circulators.begin(); for (; it != circulators.end(); it++) { switch (partition_y_mono_vertex_type(*it, traits)) { case PARTITION_Y_MONO_START_VERTEX: partition_y_mono_handle_start_vertex(*it, tree); break; case PARTITION_Y_MONO_SPLIT_VERTEX: partition_y_mono_handle_split_vertex(*it, tree, polygon); break; case PARTITION_Y_MONO_END_VERTEX: partition_y_mono_handle_end_vertex(*it, tree, polygon, traits); break; case PARTITION_Y_MONO_MERGE_VERTEX: partition_y_mono_handle_merge_vertex(*it, tree, polygon, traits); break; case PARTITION_Y_MONO_REGULAR_VERTEX: partition_y_mono_handle_regular_vertex(*it, tree, polygon, traits); break; case PARTITION_Y_MONO_COLLINEAR_VERTEX: partition_y_mono_handle_collinear_vertex(*it, tree); break; } } #ifdef CGAL_PARTITION_Y_MONOTONE_DEBUG I v_it; for (v_it = polygon.begin(); v_it != polygon.end(); v_it++) { (*v_it).print_diagonals(); } #endif polygon.partition(res, 0); CGAL_partition_postcondition( y_monotone_partition_is_valid_2(polygon.begin(), polygon.end(), res.output_so_far_begin(), res.output_so_far_end(), traits)); #if defined(CGAL_PARTITION_NO_POSTCONDITIONS) || \ defined(CGAL_NO_POSTCONDITIONS) || defined(NDEBUG) return res; #else return res.to_output_iterator(); #endif // no postconditions } template inline OutputIterator partition_y_monotone_2(InputIterator first, InputIterator beyond, OutputIterator result) { typedef typename std::iterator_traits::value_type Point_2; typedef typename Kernel_traits::Kernel K; return partition_y_monotone_2(first, beyond, result, Partition_traits_2()); } } #endif // CGAL_PARTITION_Y_MONOTONE_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_face_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_face_0000644000175000017500000000731511344301501031375 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_ds_face_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_DS_FACE_2_H #define CGAL_TRIANGULATION_DS_FACE_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < class Fb > class Triangulation_ds_face_2 : public Fb { public: typedef typename Fb::Triangulation_data_structure Tds; typedef typename Tds::Vertex Vertex; typedef typename Tds::Face Face; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Face_handle Face_handle; public : // creators Triangulation_ds_face_2() : Fb() {} Triangulation_ds_face_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Fb(v0,v1,v2) {} Triangulation_ds_face_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Fb(v0,v1,v2,n0,n1,n2) {} Triangulation_ds_face_2( const Face& f) : Fb(f) {} static int ccw(int i) {return Triangulation_cw_ccw_2::ccw(i);} static int cw(int i) {return Triangulation_cw_ccw_2::cw(i);} Vertex_handle mirror_vertex(int i) const; int mirror_index(int i) const; bool is_valid(bool verbose = false, int level = 0) const; }; template < class Fb > inline typename Triangulation_ds_face_2::Vertex_handle Triangulation_ds_face_2:: mirror_vertex(int i) const { CGAL_triangulation_precondition ( this->neighbor(i) != Face_handle() && this->dimension() >= 1); //return neighbor(i)->vertex(neighbor(i)->index(this->handle())); return this->neighbor(i)->vertex(mirror_index(i)); } template < class Fb > inline int Triangulation_ds_face_2:: mirror_index(int i) const { // return the index of opposite vertex in neighbor(i); CGAL_triangulation_precondition (this->neighbor(i) != Face_handle() && this->dimension() >= 1); if (this->dimension() == 1) { return 1 - (this->neighbor(i)->index(this->vertex(1-i))); } return this->ccw( this->neighbor(i)->index(this->vertex(this->ccw(i)))); } template < class Fb > bool Triangulation_ds_face_2:: is_valid(bool verbose, int level) const { bool result = Fb::is_valid(verbose, level); for(int i = 0; i <= this->dimension(); i++) { Face_handle n = this->neighbor(i); // the strange formulation in case dimension()==2 // is used to handle the cases of TDS allowing // two faces with two common edges int in; if (this->dimension() == 0) in = 0; else in = mirror_index(i); result = result && ( this == &*(n->neighbor(in)) ); switch(this->dimension()) { case 0 : break; case 1 : result = result && in == 1-i; result = result && ( this->vertex(1-i) == n->vertex(1-in)); break; case 2 : result = result && ( this->vertex(cw(i)) == n->vertex(ccw(in))) && ( this->vertex(ccw(i)) == n->vertex(cw(in))); break; } } return result; } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_DS_FACE_2_H ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarch0000644000175000017500000003017111344301501031433 0ustar debiandebian// Copyright (c) 1998, 2001, 2003 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_hierarchy_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Olivier Devillers // Sylvain Pion #ifndef CGAL_TRIANGULATION_HIERARCHY_3_H #define CGAL_TRIANGULATION_HIERARCHY_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class Tr > class Triangulation_hierarchy_3 : public Tr { // parameterization of the hierarchy // maximal number of points is 30^5 = 24 millions ! enum { ratio = 30 }; enum { minsize = 20}; enum { maxlevel = 5}; public: typedef Tr Tr_Base; typedef typename Tr_Base::Geom_traits Geom_traits; typedef typename Tr_Base::Point Point; typedef typename Tr_Base::size_type size_type; typedef typename Tr_Base::Vertex_handle Vertex_handle; typedef typename Tr_Base::Cell_handle Cell_handle; typedef typename Tr_Base::Vertex_iterator Vertex_iterator; typedef typename Tr_Base::Vertex Vertex; typedef typename Tr_Base::Locate_type Locate_type; typedef typename Tr_Base::Finite_vertices_iterator Finite_vertices_iterator; typedef typename Tr_Base::Finite_cells_iterator Finite_cells_iterator; typedef typename Tr_Base::Finite_facets_iterator Finite_facets_iterator; typedef typename Tr_Base::Finite_edges_iterator Finite_edges_iterator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Tr_Base::number_of_vertices; #endif private: // here is the stack of triangulations which form the hierarchy Tr_Base* hierarchy[maxlevel]; Random random; // random generator public: Triangulation_hierarchy_3(const Geom_traits& traits = Geom_traits()); Triangulation_hierarchy_3(const Triangulation_hierarchy_3& tr); template < typename InputIterator > Triangulation_hierarchy_3(InputIterator first, InputIterator last, const Geom_traits& traits = Geom_traits()) : Tr_Base(traits), random((long)0) { hierarchy[0] = this; for(int i=1; i int insert(InputIterator first, InputIterator last) { int n = number_of_vertices(); while(first != last){ insert(*first); ++first; } return number_of_vertices() - n; } // bool only for backward compatibility, we document void. bool remove(Vertex_handle v); template < typename InputIterator > int remove(InputIterator first, InputIterator beyond) { int n = number_of_vertices(); while (first != beyond) { remove(*first); ++first; } return n - number_of_vertices(); } Vertex_handle move_point(Vertex_handle v, const Point & p); //LOCATE Cell_handle locate(const Point& p, Locate_type& lt, int& li, int& lj) const; Cell_handle locate(const Point& p) const; Vertex_handle nearest_vertex(const Point& p, Cell_handle start = Cell_handle()) const; private: struct locs { Cell_handle pos; int li, lj; Locate_type lt; }; void locate(const Point& p, Locate_type& lt, int& li, int& lj, locs pos[maxlevel]) const; int random_level(); // added to make the test program of usual triangulations work // undocumented public: Vertex_handle insert(const Point& p, Locate_type lt, Cell_handle loc, int li, int lj) { return Tr_Base::insert(p, lt, loc, li, lj); } Vertex_handle insert(const Point &p, Cell_handle start) { return Tr_Base::insert(p, start); } Cell_handle locate(const Point& p, Locate_type& lt, int& li, int& lj, Cell_handle start) const { return Tr_Base::locate(p, lt, li, lj, start); } }; template Triangulation_hierarchy_3:: Triangulation_hierarchy_3(const Geom_traits& traits) : Tr_Base(traits), random((long)0) { hierarchy[0] = this; for(int i=1;i Triangulation_hierarchy_3:: Triangulation_hierarchy_3(const Triangulation_hierarchy_3 &tr) : Tr_Base(tr), random((long)0) { hierarchy[0] = this; for(int i=1; i V; for( Finite_vertices_iterator it=hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) if (it->up() != Vertex_handle()) V[ it->up()->down() ] = it; for(int j=1; jfinite_vertices_begin(); it != hierarchy[j]->finite_vertices_end(); ++it) { // down pointer goes in original instead in copied triangulation it->set_down(V[it->down()]); // make reverse link it->down()->set_up( it ); // make map for next level if (it->up() != Vertex_handle()) V[ it->up()->down() ] = it; } } } template void Triangulation_hierarchy_3:: swap(Triangulation_hierarchy_3 &tr) { Tr_Base::swap(tr); for(int i=1; i Triangulation_hierarchy_3:: ~Triangulation_hierarchy_3() { clear(); for(int i=1; i void Triangulation_hierarchy_3:: clear() { for(int i=0;iclear(); } template bool Triangulation_hierarchy_3:: is_valid(bool verbose, int level) const { bool result = true; // verify correctness of triangulation at all levels for(int i=0; iis_valid(verbose, level); // verify that lower level has no down pointers for( Finite_vertices_iterator it = hierarchy[0]->finite_vertices_begin(); it != hierarchy[0]->finite_vertices_end(); ++it) result = result && (it->down() == Vertex_handle()); // verify that other levels has down pointer and reciprocal link is fine for(int j=1; jfinite_vertices_begin(); it != hierarchy[j]->finite_vertices_end(); ++it) result = result && &*(it) == &*(it->down()->up()); // verify that other levels has down pointer and reciprocal link is fine for(int k=0; kfinite_vertices_begin(); it != hierarchy[k]->finite_vertices_end(); ++it) result = result && ( it->up() == Vertex_handle() || &*it == &*(it->up())->down() ); return result; } template typename Triangulation_hierarchy_3::Vertex_handle Triangulation_hierarchy_3:: insert(const Point &p) { int vertex_level = random_level(); Locate_type lt; int i, j; // locate using hierarchy locs positions[maxlevel]; locate(p, lt, i, j, positions); // insert at level 0 Vertex_handle vertex = hierarchy[0]->insert(p, positions[0].lt, positions[0].pos, positions[0].li, positions[0].lj); Vertex_handle previous = vertex; Vertex_handle first = vertex; int level = 1; while (level <= vertex_level ){ if (positions[level].pos == Cell_handle()) vertex = hierarchy[level]->insert(p); else vertex = hierarchy[level]->insert(p, positions[level].lt, positions[level].pos, positions[level].li, positions[level].lj); vertex->set_down(previous);// link with level above previous->set_up(vertex); previous=vertex; level++; } return first; } template bool Triangulation_hierarchy_3:: remove(Vertex_handle v) { CGAL_triangulation_precondition(v != Vertex_handle()); Vertex_handle u = v->up(); int l = 0; while (1) { hierarchy[l++]->remove(v); if (u == Vertex_handle() || l > maxlevel) break; v = u; u = v->up(); } return true; } template < class Tr > typename Triangulation_hierarchy_3::Vertex_handle Triangulation_hierarchy_3:: move_point(Vertex_handle v, const Point & p) { CGAL_triangulation_precondition(v != Vertex_handle()); Vertex_handle u = v->up(); Vertex_handle old, ret; int l = 0; while (1) { Vertex_handle w = hierarchy[l++]->move_point(v, p); if (l == 1) ret = w; if (l > 1) { old->set_up(w); w->set_down(old); } old = w; if (u == Vertex_handle() || l > maxlevel) break; v = u; u = v->up(); } return ret; } template inline typename Triangulation_hierarchy_3::Cell_handle Triangulation_hierarchy_3:: locate(const Point& p, Locate_type& lt, int& li, int& lj) const { locs positions[maxlevel]; locate(p, lt, li, lj, positions); return positions[0].pos; } template inline typename Triangulation_hierarchy_3::Cell_handle Triangulation_hierarchy_3:: locate(const Point& p) const { Locate_type lt; int li, lj; return locate(p, lt, li, lj); } template void Triangulation_hierarchy_3:: locate(const Point& p, Locate_type& lt, int& li, int& lj, locs pos[maxlevel]) const { int level = maxlevel; // find the highest level with enough vertices while (hierarchy[--level]->number_of_vertices() < (size_type) minsize) { if ( ! level) break; // do not go below 0 } for (int i=level+1; i 0) { // locate at that level from "position" // result is stored in "position" for the next level pos[level].pos = position = hierarchy[level]->locate(p, pos[level].lt, pos[level].li, pos[level].lj, position); // find the nearest vertex. Vertex_handle nearest = hierarchy[level]->nearest_vertex_in_cell(p, position); // go at the same vertex on level below nearest = nearest->down(); position = nearest->cell(); // incident cell --level; } pos[0].pos = hierarchy[level]->locate(p, lt, li, lj, position); // at level 0 pos[0].lt = lt; pos[0].li = li; pos[0].lj = lj; } template typename Triangulation_hierarchy_3::Vertex_handle Triangulation_hierarchy_3:: nearest_vertex(const Point& p, Cell_handle start) const { return Tr_Base::nearest_vertex(p, start != Cell_handle() ? start : locate(p)); } template int Triangulation_hierarchy_3:: random_level() { int l = 0; while ( ! random(ratio) ) ++l; if (l >= maxlevel) l = maxlevel - 1; return l; } CGAL_END_NAMESPACE #endif // CGAL_TRIANGULATION_HIERARCHY_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/0000755000175000017500000000000012146213704027321 5ustar debiandebian././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Aff_transformationH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Aff_transf0000644000175000017500000006447011344301501031320 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Aff_transformationH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_AFF_TRANSFORMATIONH3_H #define CGAL_AFF_TRANSFORMATIONH3_H #include #include CGAL_BEGIN_NAMESPACE // forward declaration template < class R > class Aff_transformationH3; template < class R > class Aff_transformation_repH3; template < class R > std::ostream & operator<< ( std::ostream & out, const Aff_transformationH3& t); template < class R > Aff_transformationH3 _general_transformation_composition ( Aff_transformation_repH3 l, Aff_transformation_repH3 r); template class Aff_transformation_rep_baseH3 : public Ref_counted_virtual // abstract base class of aff transformation representations { public: typedef R_ R; typedef typename R::FT FT; typedef typename R::RT RT; typedef typename R::Point_3 Point_3; typedef typename R::Vector_3 Vector_3; typedef typename R::Direction_3 Direction_3; typedef typename R::Plane_3 Plane_3; typedef typename R::Aff_transformation_3 Aff_transformation_3; virtual ~Aff_transformation_rep_baseH3(){} virtual Point_3 transform(const Point_3&) const = 0; virtual Vector_3 transform(const Vector_3&) const = 0; virtual Direction_3 transform(const Direction_3&) const = 0; virtual Plane_3 transform(const Plane_3&) const = 0; virtual Aff_transformation_3 inverse() const = 0; virtual Aff_transformation_3 transpose() const = 0; virtual Aff_transformation_repH3 general_form() const = 0; virtual bool is_even() const = 0; virtual RT homogeneous(int i, int j) const = 0; virtual FT cartesian(int i, int j) const = 0; }; template < class R_ > class Aff_transformation_repH3 : public Aff_transformation_rep_baseH3 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; public: typedef R_ R; Aff_transformation_repH3() {} Aff_transformation_repH3( const RT& m00, const RT& m01, const RT& m02, const RT& m03, const RT& m10, const RT& m11, const RT& m12, const RT& m13, const RT& m20, const RT& m21, const RT& m22, const RT& m23, const RT& m33); virtual ~Aff_transformation_repH3() {} virtual Point_3 transform(const Point_3& p) const; virtual Vector_3 transform(const Vector_3& v) const; virtual Direction_3 transform(const Direction_3& dir) const; virtual Plane_3 transform(const Plane_3& pl) const; virtual Aff_transformation_3 inverse() const; virtual Aff_transformation_repH3 general_form() const; virtual Aff_transformation_3 transpose() const; virtual bool is_even() const; virtual RT homogeneous(int i, int j) const ; virtual FT cartesian(int i, int j) const ; friend class Aff_transformationH3; friend Aff_transformationH3 _general_transformation_composition <> ( Aff_transformation_repH3 l, Aff_transformation_repH3 r); friend std::ostream & operator<< <> (std::ostream & out, const Aff_transformationH3& t); private: RT t00, t01, t02, t03; RT t10, t11, t12, t13; RT t20, t21, t22, t23; RT t33; }; template < class R_ > class Identity_repH3 : public Aff_transformation_rep_baseH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; public: typedef R_ R; Identity_repH3() {} virtual ~Identity_repH3() {} virtual Point_3 transform(const Point_3& p) const { return p; } virtual Vector_3 transform(const Vector_3& v) const { return v; } virtual Direction_3 transform(const Direction_3& dir) const { return dir; } virtual Plane_3 transform(const Plane_3& pl) const { return pl; } virtual Aff_transformation_3 inverse() const { return Aff_transformation_3( IDENTITY); } virtual Aff_transformation_repH3 general_form() const; virtual Aff_transformation_3 transpose() const { return Aff_transformation_3( IDENTITY); } virtual bool is_even() const { return true; } virtual RT homogeneous(int i, int j) const { return (i==j) ? RT(1) : RT(0); } virtual FT cartesian(int i, int j) const { return (i==j) ? FT(1) : FT(0); } }; template < class R_ > class Translation_repH3 : public Aff_transformation_rep_baseH3 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; public: typedef R_ R; Translation_repH3( const Vector_3& v); virtual ~Translation_repH3() {} virtual Point_3 transform(const Point_3& p) const; virtual Vector_3 transform(const Vector_3& v) const; virtual Direction_3 transform(const Direction_3& dir) const; virtual Plane_3 transform(const Plane_3& pl) const; virtual Aff_transformation_3 inverse() const; virtual Aff_transformation_repH3 general_form() const; virtual Aff_transformation_3 transpose() const; virtual bool is_even() const; virtual RT homogeneous(int i, int j) const ; virtual FT cartesian(int i, int j) const ; friend class Aff_transformationH3; private: Vector_3 tv; }; template < class R_ > class Aff_transformationH3 : public Handle_for_virtual< Aff_transformation_rep_baseH3 > { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; public: typedef R_ R; Aff_transformationH3(); // Identity Aff_transformationH3(const Identity_transformation&); // Translation Aff_transformationH3(const Translation& , const Vector_3& v); // Scaling Aff_transformationH3(const Scaling&, const RT& num, const RT& den); // General form Aff_transformationH3( const RT& m00, const RT& m01, const RT& m02, const RT& m03, const RT& m10, const RT& m11, const RT& m12, const RT& m13, const RT& m20, const RT& m21, const RT& m22, const RT& m23, const RT& m33); Aff_transformationH3( const RT& m00, const RT& m01, const RT& m02, const RT& m10, const RT& m11, const RT& m12, const RT& m20, const RT& m21, const RT& m22, const RT& m33); Point_3 transform(const Point_3& p) const; Vector_3 transform(const Vector_3& v) const; Direction_3 transform(const Direction_3& d) const; Plane_3 transform(const Plane_3& pl) const; Aff_transformation_3 inverse() const; Aff_transformationH3 transpose() const; bool is_even() const; bool is_odd() const; FT cartesian(int i, int j) const { return this->Ptr()->cartesian(i,j); } RT homogeneous(int i, int j) const { return this->Ptr()->homogeneous(i,j); } FT m(int i, int j) const { return this->Ptr()->cartesian(i,j); } RT hm(int i, int j) const { return this->Ptr()->homogeneous(i,j); } }; template < class R > CGAL_KERNEL_INLINE Aff_transformation_repH3::Aff_transformation_repH3( const RT& m00, const RT& m01, const RT& m02, const RT& m03, const RT& m10, const RT& m11, const RT& m12, const RT& m13, const RT& m20, const RT& m21, const RT& m22, const RT& m23, const RT& m33) : t00(m00), t01(m01), t02(m02), t03(m03), t10(m10), t11(m11), t12(m12), t13(m13), t20(m20), t21(m21), t22(m22), t23(m23), t33(m33) {} template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repH3::Point_3 Aff_transformation_repH3:: transform(const typename Aff_transformation_repH3::Point_3& p) const { return Point_3(t00 * p.hx() + t01 * p.hy() + t02 * p.hz() + t03 * p.hw(), t10 * p.hx() + t11 * p.hy() + t12 * p.hz() + t13 * p.hw(), t20 * p.hx() + t21 * p.hy() + t22 * p.hz() + t23 * p.hw(), t33 * p.hw()); } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repH3::Vector_3 Aff_transformation_repH3:: transform(const typename Aff_transformation_repH3::Vector_3& v) const { return Vector_3(t00 * v.hx() + t01 * v.hy() + t02 * v.hz(), t10 * v.hx() + t11 * v.hy() + t12 * v.hz(), t20 * v.hx() + t21 * v.hy() + t22 * v.hz(), t33 * v.hw() ); } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repH3::Direction_3 Aff_transformation_repH3:: transform(const typename Aff_transformation_repH3::Direction_3& d) const { if (t33 > RT(0)) return Direction_3(t00 * d.hx() + t01 * d.hy() + t02 * d.hz(), t10 * d.hx() + t11 * d.hy() + t12 * d.hz(), t20 * d.hx() + t21 * d.hy() + t22 * d.hz()); else return - Direction_3(t00 * d.hx() + t01 * d.hy() + t02 * d.hz(), t10 * d.hx() + t11 * d.hy() + t12 * d.hz(), t20 * d.hx() + t21 * d.hy() + t22 * d.hz()); } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repH3::Plane_3 Aff_transformation_repH3:: transform(const typename Aff_transformation_repH3::Plane_3& pl) const { if ( is_even() ) { return Plane_3( transform(pl.point() ), transpose().inverse().transform(pl.orthogonal_direction() )); } else { return Plane_3( transform(pl.point() ), -(transpose().inverse().transform(pl.orthogonal_direction() ))); } } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repH3::Aff_transformation_3 Aff_transformation_repH3::inverse() const { typedef typename R::RT RT; const RT RT0(0); return Aff_transformation_3( det3x3_by_formula( t11, t12, t13, t21, t22, t23, // i 00 RT0, RT0, t33 ), - det3x3_by_formula( t01, t02, t03, t21, t22, t23, // i 01 RT0, RT0, t33 ), det3x3_by_formula( t01, t02, t03, t11, t12, t13, // i 02 RT0, RT0, t33 ), - det3x3_by_formula( t01, t02, t03, t11, t12, t13, // i 03 t21, t22, t23 ), - det3x3_by_formula( t10, t12, t13, t20, t22, t23, // i 10 RT0, RT0, t33 ), det3x3_by_formula( t00, t02, t03, t20, t22, t23, // i 11 RT0, RT0, t33 ), - det3x3_by_formula( t00, t02, t03, t10, t12, t13, // i 12 RT0, RT0, t33 ), det3x3_by_formula( t00, t02, t03, t10, t12, t13, // i 13 t20, t22, t23 ), det3x3_by_formula( t10, t11, t13, t20, t21, t23, // i 20 RT0, RT0, t33 ), - det3x3_by_formula( t00, t01, t03, t20, t21, t23, // i 21 RT0, RT0, t33 ), det3x3_by_formula( t00, t01, t03, t10, t11, t13, // i 22 RT0, RT0, t33 ), - det3x3_by_formula( t00, t01, t03, t10, t11, t13, // i 23 t20, t21, t23 ), det3x3_by_formula( t00, t01, t02, t10, t11, t12, // i 33 t20, t21, t22 ) ) ; } template < class R > inline Aff_transformation_repH3 Aff_transformation_repH3::general_form() const { return *this; } template < class R > CGAL_KERNEL_INLINE typename Aff_transformation_repH3::Aff_transformation_3 Aff_transformation_repH3::transpose() const { typedef typename R::RT RT; const RT RT0(0); return Aff_transformation_3( t00, t10, t20, RT0, t01, t11, t21, RT0, t02, t12, t22, RT0, t33); } template < class R > CGAL_KERNEL_INLINE bool Aff_transformation_repH3::is_even() const { return (CGAL_NTS sign( t33 * det3x3_by_formula(t00, t01, t02, t10, t11, t12, t20, t21, t22 ) ) == POSITIVE ); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Aff_transformation_repH3::RT Aff_transformation_repH3:: homogeneous(int i, int j) const { typedef typename R::RT RT; CGAL_kernel_precondition( (i >= 0) && (i <= 3) && (j >= 0) && (j <= 3) ); const RT RT0(0); switch (i) { case 0: switch (j) { case 0: return t00; case 1: return t01; case 2: return t02; case 3: return t03; } case 1: switch (j) { case 0: return t10; case 1: return t11; case 2: return t12; case 3: return t13; } case 2: switch (j) { case 0: return t20; case 1: return t21; case 2: return t22; case 3: return t23; } case 3: switch (j) { case 0: return RT0; case 1: return RT0; case 2: return RT0; case 3: return t33; } } return RT0; } template < class R > inline typename Aff_transformation_repH3::FT Aff_transformation_repH3:: cartesian(int i, int j) const { typedef typename R::FT FT; return FT(homogeneous(i,j)) / FT(t33); } template Aff_transformation_repH3 Identity_repH3::general_form() const { typedef typename R::RT RT; const RT RT0(0); const RT RT1(1); return Aff_transformation_repH3(RT1, RT0, RT0, RT0, RT0, RT1, RT0, RT0, RT0, RT0, RT1, RT0, RT1 ); } template < class R > inline Translation_repH3:: Translation_repH3( const typename Translation_repH3::Vector_3& v) : tv(v) {} template < class R > CGAL_KERNEL_INLINE typename Translation_repH3::Point_3 Translation_repH3:: transform(const typename Translation_repH3::Point_3& p) const { return Point_3( tv.hw() * p.hx() + tv.hx() * p.hw(), tv.hw() * p.hy() + tv.hy() * p.hw(), tv.hw() * p.hz() + tv.hz() * p.hw(), tv.hw() * p.hw() ); } template < class R > inline typename Translation_repH3::Vector_3 Translation_repH3:: transform(const typename Translation_repH3::Vector_3& v) const { return v; } template < class R > inline typename Translation_repH3::Direction_3 Translation_repH3:: transform(const typename Translation_repH3::Direction_3& dir) const { return dir; } template < class R > inline typename Translation_repH3::Plane_3 Translation_repH3:: transform(const typename Translation_repH3::Plane_3& pl) const { return Plane_3( transform( pl.point() ), pl.orthogonal_vector() ); } template < class R > inline typename Translation_repH3::Aff_transformation_3 Translation_repH3::inverse() const { return Aff_transformation_3(TRANSLATION, - tv ); } template < class R > CGAL_KERNEL_INLINE Aff_transformation_repH3 Translation_repH3::general_form() const { const RT RT0(0); return Aff_transformation_repH3(tv.hw(), RT0, RT0, tv.hx(), RT0, tv.hw(), RT0, tv.hy(), RT0, RT0, tv.hw(), tv.hz(), tv.hw() ); } template < class R > CGAL_KERNEL_INLINE typename Translation_repH3::Aff_transformation_3 Translation_repH3::transpose() const { typedef typename R::RT RT; const RT RT0(0); const RT RT1(1); return Aff_transformation_3( RT1, RT0, RT0, RT0, RT0, RT1, RT0, RT0, RT0, RT0, RT1, RT0, RT1 ); } template < class R > inline bool Translation_repH3::is_even() const { return true; } template < class R > CGAL_KERNEL_LARGE_INLINE typename Translation_repH3::RT Translation_repH3::homogeneous(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 3) && (j >= 0) && (j <= 3) ); const RT RT0(0); switch (i) { case 0: switch (j) { case 0: return tv.hw(); case 1: return RT0; case 2: return RT0; case 3: return tv.hx(); } case 1: switch (j) { case 0: return RT0; case 1: return tv.hw(); case 2: return RT0; case 3: return tv.hy(); } case 2: switch (j) { case 0: return RT0; case 1: return RT0; case 2: return tv.hw(); case 3: return tv.hz(); } case 3: switch (j) { case 0: return RT0; case 1: return RT0; case 2: return RT0; case 3: return tv.hw(); } } return RT0; } template < class R > inline typename Translation_repH3::FT Translation_repH3:: cartesian(int i, int j) const { return FT(homogeneous(i,j)) / FT(tv.hw()); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3 _general_transformation_composition( Aff_transformation_repH3 l, Aff_transformation_repH3 r ) { return Aff_transformationH3( l.t00*r.t00 + l.t01*r.t10 + l.t02*r.t20, l.t00*r.t01 + l.t01*r.t11 + l.t02*r.t21, l.t00*r.t02 + l.t01*r.t12 + l.t02*r.t22, l.t00*r.t03 + l.t01*r.t13 + l.t02*r.t23 + l.t03*r.t33, l.t10*r.t00 + l.t11*r.t10 + l.t12*r.t20, l.t10*r.t01 + l.t11*r.t11 + l.t12*r.t21, l.t10*r.t02 + l.t11*r.t12 + l.t12*r.t22, l.t10*r.t03 + l.t11*r.t13 + l.t12*r.t23 + l.t13*r.t33, l.t20*r.t00 + l.t21*r.t10 + l.t22*r.t20, l.t20*r.t01 + l.t21*r.t11 + l.t22*r.t21, l.t20*r.t02 + l.t21*r.t12 + l.t22*r.t22, l.t20*r.t03 + l.t21*r.t13 + l.t22*r.t23 + l.t23*r.t33, l.t33*r.t33 ); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3::Aff_transformationH3() { initialize_with(Aff_transformation_repH3()); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3:: Aff_transformationH3(const Identity_transformation&) { initialize_with(Identity_repH3()); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3:: Aff_transformationH3(const Translation&, const typename Aff_transformationH3::Vector_3& v) { initialize_with(Translation_repH3( v )); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3:: Aff_transformationH3(const Scaling&, const RT& num, const RT& den) { const RT RT0(0); initialize_with(Aff_transformation_repH3(num, RT0, RT0, RT0, RT0, num, RT0, RT0, RT0, RT0, num, RT0, den )); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3:: Aff_transformationH3( const RT& m00, const RT& m01, const RT& m02, const RT& m03, const RT& m10, const RT& m11, const RT& m12, const RT& m13, const RT& m20, const RT& m21, const RT& m22, const RT& m23, const RT& m33) { initialize_with(Aff_transformation_repH3(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m33 )); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3:: Aff_transformationH3( const RT& m00, const RT& m01, const RT& m02, const RT& m10, const RT& m11, const RT& m12, const RT& m20, const RT& m21, const RT& m22, const RT& m33) { const RT RT0 = RT(0); initialize_with(Aff_transformation_repH3(m00, m01, m02, RT0, m10, m11, m12, RT0, m20, m21, m22, RT0, m33 )); } template < class R > inline typename Aff_transformationH3::Point_3 Aff_transformationH3:: transform(const typename Aff_transformationH3::Point_3& p) const { return this->Ptr()->transform(p); } template < class R > inline typename Aff_transformationH3::Vector_3 Aff_transformationH3:: transform(const typename Aff_transformationH3::Vector_3& v) const { return this->Ptr()->transform(v); } template < class R > inline typename Aff_transformationH3::Direction_3 Aff_transformationH3:: transform(const typename Aff_transformationH3::Direction_3& d) const { return this->Ptr()->transform(d); } template < class R > inline typename Aff_transformationH3::Plane_3 Aff_transformationH3:: transform(const typename Aff_transformationH3::Plane_3& pl) const { return this->Ptr()->transform(pl); } template < class R > inline typename Aff_transformationH3::Aff_transformation_3 Aff_transformationH3::inverse() const { return this->Ptr()->inverse(); } template < class R > inline Aff_transformationH3 Aff_transformationH3::transpose() const { return this->Ptr()->transpose(); } template < class R > inline bool Aff_transformationH3::is_even() const { return this->Ptr()->is_even(); } template < class R > inline bool Aff_transformationH3::is_odd() const { return ( ! (this->Ptr()->is_even() )); } template < class R > CGAL_KERNEL_INLINE Aff_transformationH3 operator*(const Aff_transformationH3& left_argument, const Aff_transformationH3& right_argument ) { return _general_transformation_composition( left_argument.Ptr() ->general_form(), right_argument.Ptr()->general_form() ); } template < class R > std::ostream & operator<< ( std::ostream & out, const Aff_transformationH3& t) { typename R::RT RT0(0); Aff_transformation_repH3 r = t.Ptr()->general_form(); return out << "| "<< r.t00 <<' '<< r.t01 <<' '<< r.t02 <<' '<< r.t03 << " |\n" << "| "<< r.t10 <<' '<< r.t11 <<' '<< r.t12 <<' '<< r.t13 << " |\n" << "| "<< r.t20 <<' '<< r.t21 <<' '<< r.t22 <<' '<< r.t23 << " |\n" << "| "<< RT0 <<' '<< RT0 <<' '<< RT0 <<' '<< r.t33 << " |\n"; } CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATIONH3_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/basic_constructionsH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/basic_cons0000644000175000017500000000571611344301501031350 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/basic_constructionsH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_BASIC_CONSTRUCTIONSH3_H #define CGAL_BASIC_CONSTRUCTIONSH3_H CGAL_BEGIN_NAMESPACE template typename R::Point_3 _projection(const typename R::Point_3& p, const PlaneH3& pl) { typedef typename R::RT RT; if ( pl.has_on(p) ) return p; RT A = pl.a(); RT B = pl.b(); RT C = pl.c(); RT D = pl.d(); RT phx = p.hx(); RT phy = p.hy(); RT phz = p.hz(); RT phw = p.hw(); RT num = A * phx + B * phy + C * phz + D * phw; RT den = A * A + B * B + C * C; return typename R::Point_3( num * A - den * phx, num * B - den * phy, num * C - den * phz, -den ); } template typename R::Point_3 gp_linear_intersection(const PlaneH3 &f, const PlaneH3 &g, const PlaneH3 &h) { typedef typename R::RT RT; return typename R::Point_3( det3x3_by_formula(-f.d(), f.b(), f.c(), -g.d(), g.b(), g.c(), -h.d(), h.b(), h.c()), det3x3_by_formula( f.a(),-f.d(), f.c(), g.a(),-g.d(), g.c(), h.a(),-h.d(), h.c()), det3x3_by_formula( f.a(), f.b(),-f.d(), g.a(), g.b(),-g.d(), h.a(), h.b(),-h.d()), det3x3_by_formula( f.a(), f.b(), f.c(), g.a(), g.b(), g.c(), h.a(), h.b(), h.c())); } template CGAL_KERNEL_INLINE typename R::FT squared_distance( PointH3 const& p, PointH3 const& q) { return (p-q)*(p-q); } CGAL_END_NAMESPACE #endif // CGAL_BASIC_CONSTRUCTIONSH3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/PlaneH3.h0000644000175000017500000004157611344301501030731 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/PlaneH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_PLANEH3_H #define CGAL_PLANEH3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class PlaneH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_2 Point_2; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Plane_3 Plane_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Fourtuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; PlaneH3() {} PlaneH3(const Point_3&, const Point_3&, const Point_3& ); PlaneH3(const RT& a, const RT& b, const RT& c, const RT& d ); PlaneH3(const Point_3&, const Ray_3& ); PlaneH3(const Point_3&, const Line_3& ); PlaneH3(const Point_3&, const Segment_3& ); PlaneH3(const Line_3&, const Point_3& ); PlaneH3(const Segment_3&, const Point_3& ); PlaneH3(const Ray_3&, const Point_3& ); PlaneH3(const Point_3&, const Direction_3& ); PlaneH3(const Point_3&, const Vector_3& ); PlaneH3(const Point_3&, const Direction_3&, const Direction_3& ); const RT & a() const; const RT & b() const; const RT & c() const; const RT & d() const; bool operator==( const PlaneH3& ) const; bool operator!=( const PlaneH3& ) const; Line_3 perpendicular_line(const Point_3& ) const; Plane_3 opposite() const; // plane with opposite orientation Point_3 projection(const Point_3& ) const; Point_3 point() const; // same point on the plane Direction_3 orthogonal_direction() const; Vector_3 orthogonal_vector() const; Oriented_side oriented_side(const Point_3 &p) const; bool has_on(const Point_3 &p) const; bool has_on(const Line_3 &p) const; bool has_on_positive_side(const Point_3&l) const; bool has_on_negative_side(const Point_3&l) const; bool is_degenerate() const; Plane_3 transform(const Aff_transformation_3& ) const; Aff_transformation_3 transform_to_2d() const; Point_2 to_2d(const Point_3& ) const; Point_3 to_3d(const Point_2& ) const; Vector_3 base1() const; Vector_3 base2() const; protected: Point_3 point1() const; // same point different from point() Point_3 point2() const; // same point different from point() // and point1() void new_rep(const Point_3 &p, const Point_3 &q, const Point_3 &r); void new_rep(const RT &a, const RT &b, const RT &c, const RT &d); }; // // a() * X + b() * Y + c() * Z() + d() * W() == 0 // // | X Y Z W | // | p.hx() p.hy() p.hz() p.hw() | // | q.hx() q.hy() q.hz() q.hw() | // | r.hx() r.hy() r.hz() r.hw() | // // Fourtuple ( a(), b(), c(), d() ) template < class R > inline void PlaneH3::new_rep(const typename PlaneH3::Point_3 &p, const typename PlaneH3::Point_3 &q, const typename PlaneH3::Point_3 &r) { RT phx = p.hx(); RT phy = p.hy(); RT phz = p.hz(); RT phw = p.hw(); RT qhx = q.hx(); RT qhy = q.hy(); RT qhz = q.hz(); RT qhw = q.hw(); RT rhx = r.hx(); RT rhy = r.hy(); RT rhz = r.hz(); RT rhw = r.hw(); base = Rep ( phy*( qhz*rhw - qhw*rhz ) - qhy*( phz*rhw - phw*rhz ) // * X + rhy*( phz*qhw - phw*qhz ), - phx*( qhz*rhw - qhw*rhz ) + qhx*( phz*rhw - phw*rhz ) // * Y - rhx*( phz*qhw - phw*qhz ), phx*( qhy*rhw - qhw*rhy ) - qhx*( phy*rhw - phw*rhy ) // * Z + rhx*( phy*qhw - phw*qhy ), - phx*( qhy*rhz - qhz*rhy ) + qhx*( phy*rhz - phz*rhy ) // * W - rhx*( phy*qhz - phz*qhy ) ); } template < class R > inline void PlaneH3::new_rep(const RT &a, const RT &b, const RT &c, const RT &d) { base = Rep(a, b, c, d); } template < class R > inline bool PlaneH3::operator!=(const PlaneH3& l) const { return !(*this == l); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p, const typename PlaneH3::Point_3& q, const typename PlaneH3::Point_3& r) { new_rep(p,q,r); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const RT& a, const RT& b, const RT& c, const RT& d) { new_rep(a,b,c,d); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p , const typename PlaneH3::Line_3& l) { new_rep(p, l.point(0), l.point(1) ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p, const typename PlaneH3::Segment_3& s) { new_rep(p, s.source(), s.target() ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p , const typename PlaneH3::Ray_3& r) { new_rep(p, r.start(), r.start() + r.direction().to_vector() ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Line_3& l , const typename PlaneH3::Point_3& p) { new_rep(l.point(0), p, l.point(1) ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Segment_3& s, const typename PlaneH3::Point_3& p) { new_rep(s.source(), p, s.target() ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Ray_3& r, const typename PlaneH3::Point_3& p) { new_rep(r.start(), p, r.start() + r.direction().to_vector() ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p, const typename PlaneH3::Direction_3& d) { Vector_3 ov = d.to_vector(); new_rep( ov.hx()*p.hw(), ov.hy()*p.hw(), ov.hz()*p.hw(), -(ov.hx()*p.hx() + ov.hy()*p.hy() + ov.hz()*p.hz() ) ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p, const typename PlaneH3::Vector_3& ov) { new_rep( ov.hx()*p.hw(), ov.hy()*p.hw(), ov.hz()*p.hw(), -(ov.hx()*p.hx() + ov.hy()*p.hy() + ov.hz()*p.hz() ) ); } template < class R > CGAL_KERNEL_INLINE PlaneH3::PlaneH3(const typename PlaneH3::Point_3& p, const typename PlaneH3::Direction_3& d1, const typename PlaneH3::Direction_3& d2) { new_rep( p, p + d1.to_vector(), p + d2.to_vector() ); } template < class R > inline const typename PlaneH3::RT & PlaneH3::a() const { return get(base).e0; } template < class R > inline const typename PlaneH3::RT & PlaneH3::b() const { return get(base).e1; } template < class R > inline const typename PlaneH3::RT & PlaneH3::c() const { return get(base).e2; } template < class R > inline const typename PlaneH3::RT & PlaneH3::d() const { return get(base).e3; } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Line_3 PlaneH3::perpendicular_line(const typename PlaneH3::Point_3& p) const { return Line_3( p, orthogonal_direction() ); } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Plane_3 PlaneH3::opposite() const { return PlaneH3(-a(), -b(), -c(), -d() ); } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Point_3 PlaneH3::projection(const typename PlaneH3::Point_3& p) const { return _projection( p, *this ); } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Point_3 PlaneH3::point() const { const RT RT0(0); if ( a() != RT0 ) { return Point_3( -d(), RT0, RT0, a() ); } if ( b() != RT0 ) { return Point_3( RT0, -d(), RT0, b() ); } CGAL_kernel_assertion ( c() != RT0); return Point_3( RT0, RT0, -d(), c() ); } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Vector_3 PlaneH3::base1() const { // point(): // a() != RT0 : Point_3( -d(), RT0, RT0, a() ); // b() != RT0 : Point_3( RT0, -d(), RT0, b() ); // : Point_3( RT0, RT0, -d(), c() ); // point1(): // a() != RT0 : Point_3( -b()-d(), a(), RT0, a() ); // b() != RT0 : Point_3( RT0, -c()-d(), b(), b() ); // : Point_3( c(), RT0, -a()-d(), c() ); const RT RT0(0); if ( a() != RT0 ) { return Vector_3( -b(), a(), RT0, a() ); } if ( b() != RT0 ) { return Vector_3( RT0, -c(), b(), b() ); } CGAL_kernel_assertion ( c() != RT(0) ); return Vector_3( c(), RT0, -a(), c() ); } template < class R > inline typename PlaneH3::Vector_3 PlaneH3::base2() const { Vector_3 a = orthogonal_vector(); Vector_3 b = base1(); return Vector_3(a.hy()*b.hz() - a.hz()*b.hy(), a.hz()*b.hx() - a.hx()*b.hz(), a.hx()*b.hy() - a.hy()*b.hx(), a.hw()*b.hw() ); } // Actually, the following should work, but bcc doesn't like it: // { return cross_product( orthogonal_vector(), base1() ); } template < class R > inline typename PlaneH3::Point_3 PlaneH3::point1() const { return point() + base1(); } template < class R > inline typename PlaneH3::Point_3 PlaneH3::point2() const { return point() + base2(); } template < class R > inline typename PlaneH3::Direction_3 PlaneH3::orthogonal_direction() const { return Direction_3(a(), b(), c() ); } template < class R > inline typename PlaneH3::Vector_3 PlaneH3::orthogonal_vector() const { return Vector_3(a(), b(), c() ); } template < class R > typename PlaneH3::Plane_3 PlaneH3::transform(const typename PlaneH3::Aff_transformation_3& t) const { return t.transform(*this); } #ifndef CGAL_NO_OSTREAM_INSERT_PLANE3 template < class R > std::ostream &operator<<(std::ostream &os, const PlaneH3 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.a() << ' ' << p.b() << ' ' << p.c() << ' ' << p.d(); case IO::BINARY : write(os, p.a()); write(os, p.b()); write(os, p.c()); write(os, p.d()); return os; default: os << "PlaneC3(" << p.a() << ", " << p.b() << ", "; os << p.c() << ", " << p.d() <<")"; return os; } } #endif // CGAL_NO_OSTREAM_INSERT_PLANE3 #ifndef CGAL_NO_ISTREAM_EXTRACT_PLANE3 template < class R > std::istream &operator>>(std::istream &is, PlaneH3 &p) { typename R::RT a, b, c, d; switch(is.iword(IO::mode)) { case IO::ASCII : is >> a >> b >> c >> d; break; case IO::BINARY : read(is, a); read(is, b); read(is, c); read(is, d); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = PlaneH3(a, b, c, d); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_PLANE3 template < class R > bool PlaneH3::is_degenerate() const { const RT RT0(0); return ( (a() == RT0 ) && (b() == RT0 ) && (c() == RT0 ) ); } template < class R > bool PlaneH3::has_on_positive_side( const typename PlaneH3::Point_3& p) const { return (a()*p.hx() + b()*p.hy() + c()*p.hz() + d()*p.hw() > RT(0) ); } template < class R > bool PlaneH3::has_on_negative_side( const typename PlaneH3::Point_3& p) const { return (a()*p.hx() + b()*p.hy() + c()*p.hz() + d()*p.hw() < RT(0) ); } template < class R > bool PlaneH3::has_on( const typename PlaneH3::Point_3& p) const { return (a()*p.hx() + b()*p.hy() + c()*p.hz() + d()*p.hw() == RT(0) ); } template < class R > bool PlaneH3::has_on( const typename PlaneH3::Line_3& l) const { Point_3 p = l.point(); Vector_3 ld = l.direction().to_vector(); Vector_3 ov = orthogonal_vector(); return ( ( a()*p.hx() + b()*p.hy() + c()*p.hz() + d()*p.hw() == RT(0) ) &&( ld.hx()*ov.hx() + ld.hy()*ov.hy() + ld.hz()*ov.hz() == RT(0) ) ); } template < class R > Oriented_side PlaneH3::oriented_side( const typename PlaneH3::Point_3& p) const { RT value = a()*p.hx() + b()*p.hy() + c()*p.hz() + d()*p.hw() ; if (value > RT(0) ) { return ON_POSITIVE_SIDE; } else { return (value < RT(0) ) ? ON_NEGATIVE_SIDE : ON_ORIENTED_BOUNDARY; } } template < class R > bool PlaneH3::operator==(const PlaneH3& l) const { if ( (a() * l.d() != l.a() * d() ) ||(b() * l.d() != l.b() * d() ) ||(c() * l.d() != l.c() * d() ) ) { return false; } int sd = static_cast(CGAL_NTS sign(d())); int sld = static_cast(CGAL_NTS sign(l.d())); if ( sd == sld ) { if (sd == 0) { return ( (a()*l.b() == b()*l.a() ) &&(a()*l.c() == c()*l.a() ) &&(b()*l.c() == c()*l.b() ) &&(CGAL_NTS sign(a() )== CGAL_NTS sign( l.a() )) &&(CGAL_NTS sign(b() )== CGAL_NTS sign( l.b() )) &&(CGAL_NTS sign(c() )== CGAL_NTS sign( l.c() )) ); } else { return true; } } else { return false; } } template < class R > typename PlaneH3::Aff_transformation_3 PlaneH3::transform_to_2d() const { const RT RT0(0); const RT RT1(1); Vector_3 nov = orthogonal_vector(); Vector_3 e1v = point1()-point() ; Vector_3 e2v = point2()-point() ; RT orthohx = nov.hx(); RT orthohy = nov.hy(); RT orthohz = nov.hz(); RT e1phx = e1v.hx(); RT e1phy = e1v.hy(); RT e1phz = e1v.hz(); RT e2phx = e2v.hx(); RT e2phy = e2v.hy(); RT e2phz = e2v.hz(); RT t11 = -( orthohy*e2phz - orthohz*e2phy ); RT t12 = ( orthohx*e2phz - orthohz*e2phx ); RT t13 = -( orthohx*e2phy - orthohy*e2phx ); RT t21 = ( orthohy*e1phz - orthohz*e1phy ); RT t22 = -( orthohx*e1phz - orthohz*e1phx ); RT t23 = ( orthohx*e1phy - orthohy*e1phx ); RT t31 = ( e1phy*e2phz - e1phz*e2phy ); RT t32 = -( e1phx*e2phz - e1phz*e2phx ); RT t33 = ( e1phx*e2phy - e1phy*e2phx ); RT scale = det3x3_by_formula( orthohx, orthohy, orthohz, e1phx, e1phy, e1phz, e2phx, e2phy, e2phz ); Aff_transformation_3 point_to_origin(TRANSLATION, - ( point() - ORIGIN ) ); Aff_transformation_3 rotate_and_more( t11, t12, t13, RT0, t21, t22, t23, RT0, t31, t32, t33, RT0, scale); Point_3 ortho( orthohx, orthohy, orthohz ); Point_3 e1p( e1phx, e1phy, e1phz ); Point_3 e2p( e2phx, e2phy, e2phz ); CGAL_kernel_assertion(( ortho.transform(rotate_and_more) == Point_3( RT(0), RT(0), RT(1)) )); CGAL_kernel_assertion(( e1p.transform(rotate_and_more) == Point_3( RT(1), RT(0), RT(0)) )); CGAL_kernel_assertion(( e2p.transform(rotate_and_more) == Point_3( RT(0), RT(1), RT(0)) )); return rotate_and_more * point_to_origin; } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Point_2 PlaneH3::to_2d(const typename PlaneH3::Point_3& p) const { Point_3 tp = p.transform( transform_to_2d() ); return Point_2( tp.hx(), tp.hy(), tp.hw()); } template < class R > CGAL_KERNEL_INLINE typename PlaneH3::Point_3 PlaneH3::to_3d(const typename PlaneH3::Point_2& p) const { Point_3 hp( p.hx(), p.hy(), RT(0.0), p.hw()); return hp.transform( transform_to_2d().inverse() ); } CGAL_END_NAMESPACE #endif // CGAL_PLANEH3_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_pointsH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates0000644000175000017500000000576011344301501031367 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_pointsH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_PREDICATES_ON_POINTSH2_H #define CGAL_PREDICATES_ON_POINTSH2_H #include CGAL_BEGIN_NAMESPACE template < class R> CGAL_KERNEL_INLINE bool equal_xy(const PointH2& p, const PointH2& q) { typedef typename R::RT RT; // Using these references allows to spare calls to [pq].hw(). const RT& phw = p.hw(); const RT& qhw = q.hw(); return (p.hx()*qhw == q.hx()*phw) && (p.hy()*qhw == q.hy()*phw); } template < class R> CGAL_KERNEL_INLINE Comparison_result compare_yx(const PointH2& p, const PointH2& q) { typedef typename R::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); RT pV = phy*qhw; RT qV = qhy*phw; if ( pV == qV ) { pV = phx*qhw; qV = qhx*phw; } if ( pV < qV ) return SMALLER; else return ( qV < pV ) ? LARGER : EQUAL; } template CGAL_KERNEL_MEDIUM_INLINE Oriented_side _where_wrt_L_wedge( const PointH2& p, const PointH2& q ) { Sign xs = CGAL_NTS sign( q.hx()*p.hw() - p.hx()*q.hw() ); // sign( qx - px ) Sign ys = CGAL_NTS sign( q.hy()*p.hw() - p.hy()*q.hw() ); // sign( qy - py ) if (( xs == NEGATIVE ) || ( ys == NEGATIVE )) return ON_NEGATIVE_SIDE; if (( xs == POSITIVE ) && ( ys == POSITIVE )) return ON_POSITIVE_SIDE; return ON_ORIENTED_BOUNDARY; } template < class R > CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_deltax_deltay(const PointH2& p, const PointH2& q, const PointH2& r, const PointH2& s) { return CGAL_NTS compare( CGAL_NTS abs(p.hx()*q.hw() - q.hx()*p.hw()) * r.hw()*s.hw(), CGAL_NTS abs(r.hy()*s.hw() - s.hy()*r.hw()) * p.hw()*q.hw()); } CGAL_END_NAMESPACE #endif // CGAL_PREDICATES_ON_POINTSH2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/SphereH3.h0000644000175000017500000002155111344301501031107 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/SphereH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_SPHEREH3_H #define CGAL_SPHEREH3_H #include #include #include CGAL_BEGIN_NAMESPACE template class SphereH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Triple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; SphereH3() {} SphereH3(const Point_3& p, const FT& sq_rad, const Orientation& o = COUNTERCLOCKWISE); SphereH3(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& u); SphereH3(const Point_3& p, const Point_3& q, const Point_3& r, const Orientation& o = COUNTERCLOCKWISE); SphereH3(const Point_3& p, const Point_3& q, const Orientation& o = COUNTERCLOCKWISE); SphereH3(const Point_3& p, const Orientation& o = COUNTERCLOCKWISE); bool operator==(const SphereH3&) const; bool operator!=(const SphereH3& s) const { return !(*this == s); } const Point_3 & center() const; const FT & squared_radius() const; Orientation orientation() const; SphereH3 orthogonal_transform(const Aff_transformation_3& t) const; bool is_degenerate() const; SphereH3 opposite() const; Bbox_3 bbox() const; Oriented_side oriented_side(const Point_3& p) const; bool has_on_boundary(const Point_3& p) const { return oriented_side(p)==ON_ORIENTED_BOUNDARY; } bool has_on_positive_side(const Point_3& p) const { return oriented_side(p)==ON_POSITIVE_SIDE; } bool has_on_negative_side(const Point_3& p) const { return oriented_side(p)==ON_NEGATIVE_SIDE; } Bounded_side bounded_side(const Point_3& p) const; bool has_on_bounded_side(const Point_3& p) const { return bounded_side(p)==ON_BOUNDED_SIDE; } bool has_on_unbounded_side(const Point_3& p) const { return bounded_side(p)==ON_UNBOUNDED_SIDE; } }; template < class R > CGAL_KERNEL_INLINE SphereH3::SphereH3(const typename SphereH3::Point_3& center, const FT& squared_radius, const Orientation& o) { CGAL_kernel_precondition( !( squared_radius < FT(0)) &&( o != COLLINEAR) ); base = Rep(center, squared_radius, o); } template CGAL_KERNEL_INLINE SphereH3::SphereH3(const typename SphereH3::Point_3& center, const Orientation& o) { CGAL_kernel_precondition( ( o != COLLINEAR) ); base = Rep(center, FT(0), o); } template CGAL_KERNEL_MEDIUM_INLINE SphereH3::SphereH3(const typename SphereH3::Point_3& p, const typename SphereH3::Point_3& q, const Orientation& o) { CGAL_kernel_precondition( o != COLLINEAR); Point_3 center = midpoint(p,q); FT squared_radius = squared_distance(p,center); base = Rep(center, squared_radius, o); } template CGAL_KERNEL_MEDIUM_INLINE SphereH3::SphereH3(const typename SphereH3::Point_3& p, const typename SphereH3::Point_3& q, const typename SphereH3::Point_3& r, const Orientation& o) { CGAL_kernel_precondition( o != COLLINEAR); Point_3 center = circumcenter(p,q,r); FT squared_radius = squared_distance(p,center); base = Rep(center, squared_radius, o); } template CGAL_KERNEL_MEDIUM_INLINE SphereH3::SphereH3(const typename SphereH3::Point_3& p, const typename SphereH3::Point_3& q, const typename SphereH3::Point_3& r, const typename SphereH3::Point_3& s) { Orientation o = CGAL::orientation(p,q,r,s); CGAL_kernel_precondition( o != COLLINEAR); Point_3 center = circumcenter(p,q,r,s); FT squared_radius = squared_distance(p,center); base = Rep(center, squared_radius, o); } template CGAL_KERNEL_INLINE bool SphereH3::operator==(const SphereH3& s) const { return ( orientation() == s.orientation()) && ( center() == s.center()) && ( squared_radius() == s.squared_radius()); } template inline const typename SphereH3::Point_3 & SphereH3::center() const { return get(base).first; } template inline const typename SphereH3::FT & SphereH3::squared_radius() const { return get(base).second; } template inline Orientation SphereH3::orientation() const { return get(base).third; } template inline bool SphereH3::is_degenerate() const { return squared_radius() <= FT(0) ; } template CGAL_KERNEL_MEDIUM_INLINE Oriented_side SphereH3::oriented_side(const typename SphereH3::Point_3& p) const { return Oriented_side(bounded_side(p) * orientation()); } template CGAL_KERNEL_INLINE Bounded_side SphereH3::bounded_side(const typename SphereH3::Point_3& p) const { return Bounded_side(CGAL_NTS compare(squared_radius(), squared_distance(center(),p))); } template inline SphereH3 SphereH3::opposite() const { return SphereH3(center(), squared_radius(), CGAL::opposite(orientation()) ); } template CGAL_KERNEL_INLINE Bbox_3 SphereH3::bbox() const { Bbox_3 b = center().bbox(); Interval_nt<> x (b.xmin(), b.xmax()); Interval_nt<> y (b.ymin(), b.ymax()); Interval_nt<> z (b.zmin(), b.zmax()); Interval_nt<> sqr = CGAL_NTS to_interval(squared_radius()); Interval_nt<> r = CGAL::sqrt(sqr); Interval_nt<> minx = x-r; Interval_nt<> maxx = x+r; Interval_nt<> miny = y-r; Interval_nt<> maxy = y+r; Interval_nt<> minz = z-r; Interval_nt<> maxz = z+r; return Bbox_3(minx.inf(), miny.inf(), minz.inf(), maxx.sup(), maxy.sup(), maxz.sup()); } #ifndef CGAL_NO_OSTREAM_INSERT_SPHEREH3 template < class R > CGAL_KERNEL_INLINE std::ostream & operator<<(std::ostream &os, const SphereH3 &c) { switch(os.iword(IO::mode)) { case IO::ASCII : os << c.center() << ' ' << c.squared_radius() << ' ' << static_cast(c.orientation()); break; case IO::BINARY : os << c.center(); write(os, c.squared_radius()); write(os, static_cast(c.orientation())); break; default: os << "SphereH3(" << c.center() << ", " << c.squared_radius(); switch (c.orientation()) { case CLOCKWISE: os << ", clockwise)"; break; case COUNTERCLOCKWISE: os << ", counterclockwise)"; break; default: os << ", collinear)"; break; } break; } return os; } #endif // CGAL_NO_OSTREAM_INSERT_SPHEREH3 #ifndef CGAL_NO_ISTREAM_EXTRACT_SPHEREH3 template < class R > CGAL_KERNEL_INLINE std::istream & operator>>(std::istream &is, SphereH3 &c) { typename R::Point_3 center; typename R::FT squared_radius; int o; switch(is.iword(IO::mode)) { case IO::ASCII : is >> center >> squared_radius >> o; break; case IO::BINARY : is >> center; read(is, squared_radius); is >> o; break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } if (is) c = SphereH3(center, squared_radius, static_cast(o)); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_SPHEREH3 CGAL_END_NAMESPACE #endif // CGAL_SPHEREH3_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/DirectionH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/DirectionH0000644000175000017500000001400211344301501031261 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/DirectionH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_DIRECTION_3_H #define CGAL_HOMOGENEOUS_DIRECTION_3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class DirectionH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Fourtuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; DirectionH3() {} //DirectionH3(const Point_3 & p ) //: base(p) {} DirectionH3(const Vector_3 & v ) { *this = v.direction(); } DirectionH3(const Line_3 & l ) { *this = l.direction(); } DirectionH3(const Ray_3 & r ) { *this = r.direction(); } DirectionH3(const Segment_3 & s ) { *this = s.direction(); } // the fourth argument is not documented. Should go away ? DirectionH3(const RT& x, const RT& y, const RT& z, const RT& w = RT(1) ) { if ( w >= RT(0) ) base = Rep(x,y,z,w); else base = Rep(-x,-y,-z,-w); } DirectionH3 transform(const Aff_transformation_3 &) const ; DirectionH3 operator-() const; bool is_degenerate() const; bool operator==( const DirectionH3& d) const; bool operator!=( const DirectionH3& d) const; Vector_3 to_vector() const; Vector_3 vector() const { return to_vector(); } const RT & dx() const { return get(base).e0; } const RT & dy() const { return get(base).e1; } const RT & dz() const { return get(base).e2; } const RT & x() const { return get(base).e0; } const RT & y() const { return get(base).e1; } const RT & z() const { return get(base).e2; } const RT & hx() const { return get(base).e0; } const RT & hy() const { return get(base).e1; } const RT & hz() const { return get(base).e2; } const RT & delta(int i) const; }; template CGAL_KERNEL_INLINE const typename DirectionH3::RT & DirectionH3::delta(int i) const { switch (i) { case 0: return x(); case 1: return y(); case 2: return z(); default: return delta( i%3 ); } } template CGAL_KERNEL_INLINE bool DirectionH3::operator==( const DirectionH3& d) const { return ( ( hx()*d.hy() == hy()*d.hx() ) &&( hx()*d.hz() == hz()*d.hx() ) &&( hy()*d.hz() == hz()*d.hy() ) &&( CGAL_NTS sign( hx() ) == CGAL_NTS sign( d.hx() ) ) &&( CGAL_NTS sign( hy() ) == CGAL_NTS sign( d.hy() ) ) &&( CGAL_NTS sign( hz() ) == CGAL_NTS sign( d.hz() ) ) ); } template inline bool DirectionH3::operator!=( const DirectionH3& d) const { return !operator==(d); } template CGAL_KERNEL_INLINE bool DirectionH3::is_degenerate() const { return ((hx() == RT(0)) && (hy() == RT(0)) && (hz() == RT(0))); } template inline DirectionH3 DirectionH3::operator-() const { return DirectionH3(- hx(),- hy(),- hz() ); } template inline typename DirectionH3::Vector_3 DirectionH3::to_vector() const { return Vector_3(dx(), dy(), dz(), RT(1)); } template CGAL_KERNEL_INLINE DirectionH3 cross_product( const DirectionH3& d1, const DirectionH3& d2) { return cross_product(d1.to_vector(),d2.to_vector()).direction(); } template inline DirectionH3 DirectionH3:: transform(const typename DirectionH3::Aff_transformation_3& t) const { return t.transform(*this); } #ifndef CGAL_NO_OSTREAM_INSERT_DIRECTIONH3 template < class R > std::ostream &operator<<(std::ostream &os, const DirectionH3 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.dx() << ' ' << p.dy() << ' ' << p.dz(); case IO::BINARY : write(os, p.dx()); write(os, p.dy()); write(os, p.dz()); return os; default: return os << "DirectionH3(" << p.dx() << ", " << p.dy() << ", " << p.dz() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_DIRECTIONH3 #ifndef CGAL_NO_ISTREAM_EXTRACT_DIRECTIONH3 template < class R > std::istream &operator>>(std::istream &is, DirectionH3 &p) { typename R::RT x, y, z; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y >> z; break; case IO::BINARY : read(is, x); read(is, y); read(is, z); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = DirectionH3(x, y, z); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_DIRECTIONH3 CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_DIRECTION_3_H ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_directionsH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates0000644000175000017500000000267111344301501031365 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_directionsH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_PREDICATES_ON_DIRECTIONSH2_H #define CGAL_PREDICATES_ON_DIRECTIONSH2_H #include #include #include #include // kind of obsolete... #endif // CGAL_PREDICATES_ON_DIRECTIONSH2_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/DirectionH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/DirectionH0000644000175000017500000001375111344301501031273 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/DirectionH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_DIRECTION_2_H #define CGAL_HOMOGENEOUS_DIRECTION_2_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class DirectionH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; DirectionH2() {} DirectionH2(const Vector_2 & v ) { *this = v.direction(); } DirectionH2(const Line_2 & l ) { *this = l.direction(); } DirectionH2(const Ray_2 & r ) { *this = r.direction(); } DirectionH2(const Segment_2 & s ) { *this = s.direction(); } DirectionH2(const RT& x, const RT& y) : base (x, y, RT(1)) {} // TODO Not documented : should not exist , not used. // we should also change Threetuple -> Twotuple DirectionH2(const RT& x, const RT& y, const RT& w ) { if (w > RT(0) ) base = Rep(x, y, w); else base = Rep(-x, -y, -w); } bool operator==( const DirectionH2& d) const; bool operator!=( const DirectionH2& d) const; bool counterclockwise_in_between( const DirectionH2& d1, const DirectionH2& d2 ) const; DirectionH2 operator-() const; Vector_2 to_vector() const; Vector_2 vector() const { return to_vector(); } const RT & x() const { return get(base).e0; }; const RT & y() const { return get(base).e1; }; const RT & delta(int i) const; const RT & dx() const { return get(base).e0; }; const RT & dy() const { return get(base).e1; }; DirectionH2 perpendicular(const Orientation &o) const; DirectionH2 transform(const Aff_transformation_2 &) const; }; template CGAL_KERNEL_INLINE bool DirectionH2::operator==( const DirectionH2& d) const { return ( ( x() * d.y() == y() * d.x() ) &&( CGAL_NTS sign( x() ) == CGAL_NTS sign( d.x() ) ) &&( CGAL_NTS sign( y() ) == CGAL_NTS sign( d.y() ) ) ); } template inline bool DirectionH2::operator!=( const DirectionH2& d) const { return !(*this == d); } template inline DirectionH2 DirectionH2::operator-() const { return DirectionH2( - x(), - y() ); } template CGAL_KERNEL_INLINE const typename DirectionH2::RT & DirectionH2::delta(int i) const { CGAL_kernel_precondition( ( i == 0 ) || ( i == 1 ) ); if (i == 0) return dx(); return dy(); } CGAL_END_NAMESPACE #include CGAL_BEGIN_NAMESPACE template CGAL_KERNEL_INLINE bool DirectionH2:: counterclockwise_in_between( const DirectionH2& d1, const DirectionH2& d2) const { return R().counterclockwise_in_between_2_object()(*this, d1, d2); } template CGAL_KERNEL_INLINE DirectionH2 DirectionH2::perpendicular(const Orientation& o) const { CGAL_kernel_precondition(o != COLLINEAR); if (o == COUNTERCLOCKWISE) { return DirectionH2(-dy(), dx()); } else { return DirectionH2(dy(), -dx()); } } template inline DirectionH2 DirectionH2:: transform(const typename DirectionH2::Aff_transformation_2& t) const { return t.transform(*this); } template CGAL_KERNEL_INLINE typename DirectionH2::Vector_2 DirectionH2::to_vector() const { return Vector_2(dx(), dy()); } #ifndef CGAL_NO_OSTREAM_INSERT_DIRECTIONH2 template < class R > std::ostream & operator<<(std::ostream &os, const DirectionH2 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.dx() << ' ' << p.dy(); case IO::BINARY : write(os, p.dx()); write(os, p.dy()); return os; default: return os << "DirectionH2(" << p.dx() << ", " << p.dy() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_DIRECTIONH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_DIRECTIONH2 template < class R > std::istream & operator>>(std::istream &is, DirectionH2 &p) { typename R::RT x, y; switch(is.iword(IO::mode)) { case IO::ASCII : is >> x >> y; break; case IO::BINARY : read(is, x); read(is, y); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = DirectionH2(x, y); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_DIRECTIONH2 CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_DIRECTION_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/CircleH2.h0000644000175000017500000002314511344301501031062 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/CircleH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr // Stefan Schirra #ifndef CGAL_CIRCLEH2_H #define CGAL_CIRCLEH2_H #include #include CGAL_BEGIN_NAMESPACE template class CircleH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Triple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; CircleH2() {} CircleH2(const Point_2& p, const Point_2& q, const Point_2& r) { Orientation o = CGAL::orientation( p, q, r); CGAL_kernel_precondition( o != COLLINEAR); Point_2 cp = circumcenter( p, q, r); FT sq_r = squared_distance( p, cp); base = Rep(cp, sq_r, o); } CircleH2(const Point_2& p, const Point_2& q, const Orientation& o) { CGAL_kernel_precondition( o != COLLINEAR); if ( p != q) { Point_2 cp = midpoint( p, q); FT sq_r = squared_distance( cp, p); base = Rep(cp, sq_r, o); } else base = Rep(p, FT( 0), o); } CircleH2(const Point_2& cp, const FT& squared_radius, const Orientation& o) { CGAL_precondition( ( ! CGAL_NTS is_negative( squared_radius)) && ( o != COLLINEAR ) ); base = Rep(cp, squared_radius, o); } Bbox_2 bbox() const; CircleH2 orthogonal_transform(const Aff_transformation_2&) const; const Point_2 & center() const; Orientation orientation() const; const FT & squared_radius() const; CircleH2 opposite() const; Oriented_side oriented_side(const Point_2& ) const; Bounded_side bounded_side(const Point_2& ) const; bool operator==( const CircleH2& ) const; bool operator!=( const CircleH2& ) const; bool has_on_positive_side(const Point_2& ) const; bool has_on_negative_side(const Point_2& ) const; bool has_on_boundary( const Point_2& ) const; bool has_on_bounded_side( const Point_2& ) const; bool has_on_unbounded_side(const Point_2&) const; bool is_degenerate() const; // bool oriented_equal( const CircleH2& ) const; // bool unoriented_equal( const CircleH2& ) const; }; template inline const typename CircleH2::Point_2 & CircleH2::center() const { return get(base).first; } template inline const typename CircleH2::FT & CircleH2::squared_radius() const { return get(base).second; } template CGAL_KERNEL_INLINE CircleH2 CircleH2::opposite() const { return CircleH2( center(), squared_radius(), CGAL::opposite( orientation() ) ); } template inline Orientation CircleH2::orientation() const { return get(base).third; } template CGAL_KERNEL_INLINE Oriented_side CircleH2::oriented_side( const typename CircleH2::Point_2& p) const { FT sq_dist = squared_distance( p, center() ); FT sq_rad = squared_radius(); Comparison_result vgl = CGAL_NTS compare( sq_dist, sq_rad ); Oriented_side rel_pos = (vgl == LARGER ) ? ON_NEGATIVE_SIDE : ( (vgl == SMALLER ) ? ON_POSITIVE_SIDE : ON_ORIENTED_BOUNDARY); if (orientation() == POSITIVE) { return rel_pos; } else // NEGATIVE { return CGAL::opposite( rel_pos ); } } template CGAL_KERNEL_INLINE bool CircleH2::has_on_positive_side(const typename CircleH2::Point_2& p) const { if ( orientation() == POSITIVE ) { return (has_on_bounded_side(p) ); } else { return (has_on_unbounded_side(p) ); } } template CGAL_KERNEL_INLINE bool CircleH2::has_on_boundary(const typename CircleH2::Point_2& p) const { FT sq_dist = squared_distance( p, center() ); FT sq_rad = squared_radius(); return ( sq_dist == sq_rad ); } template CGAL_KERNEL_INLINE bool CircleH2::has_on_negative_side( const typename CircleH2::Point_2&p) const { if ( orientation() == NEGATIVE ) { return (has_on_bounded_side(p) ); } else { return (has_on_unbounded_side(p) ); } } template CGAL_KERNEL_INLINE Bounded_side CircleH2::bounded_side(const typename CircleH2::Point_2& p) const { FT sq_dist = squared_distance( p, center() ); FT sq_rad = squared_radius(); Comparison_result vgl = CGAL_NTS compare( sq_dist, sq_rad ); return (vgl == LARGER ) ? ON_UNBOUNDED_SIDE : ( (vgl == SMALLER ) ? ON_BOUNDED_SIDE : ON_BOUNDARY); } template CGAL_KERNEL_INLINE bool CircleH2::has_on_bounded_side(const typename CircleH2::Point_2& p) const { FT sq_dist = squared_distance( p, center() ); FT sq_rad = squared_radius(); return ( sq_dist < sq_rad ); } template CGAL_KERNEL_INLINE bool CircleH2::has_on_unbounded_side(const typename CircleH2::Point_2&p) const { FT sq_dist = squared_distance( p, center() ); FT sq_rad = squared_radius(); return ( sq_rad < sq_dist ); } template inline bool CircleH2::is_degenerate() const { return ( squared_radius() == FT(0) ); } template CGAL_KERNEL_MEDIUM_INLINE Bbox_2 CircleH2::bbox() const { Bbox_2 b = center().bbox(); Interval_nt<> x (b.xmin(), b.xmax()); Interval_nt<> y (b.ymin(), b.ymax()); Interval_nt<> sqr = CGAL_NTS to_interval(squared_radius()); Interval_nt<> r = CGAL::sqrt(sqr); Interval_nt<> minx = x-r; Interval_nt<> maxx = x+r; Interval_nt<> miny = y-r; Interval_nt<> maxy = y+r; return Bbox_2(minx.inf(), miny.inf(), maxx.sup(), maxy.sup()); } template CGAL_KERNEL_INLINE CircleH2 CircleH2:: orthogonal_transform(const typename CircleH2::Aff_transformation_2& t) const { typename R::Vector_2 vec( RT(1), RT(0) ); // unit vector vec = vec.transform(t); // transformed FT sq_scale = FT( vec*vec ); // squared scaling factor if ( t.is_even() ) { return CircleH2(t.transform(center() ), sq_scale * squared_radius(), orientation() ); } else { return CircleH2(t.transform(center() ), sq_scale * squared_radius(), CGAL::opposite( orientation()) ); } } template CGAL_KERNEL_INLINE bool CircleH2::operator==(const CircleH2& c) const { return ( center() == c.center() ) &&( squared_radius() == c.squared_radius() ) &&( orientation() == c.orientation() ); } template inline bool CircleH2::operator!=(const CircleH2& c) const { return !(*this == c); } #ifndef CGAL_NO_OSTREAM_INSERT_CIRCLEH2 template < class R > std::ostream &operator<<(std::ostream &os, const CircleH2 &c) { switch(os.iword(IO::mode)) { case IO::ASCII : os << c.center() << ' ' << c.squared_radius() << ' ' << static_cast(c.orientation()); break; case IO::BINARY : os << c.center(); write(os, c.squared_radius()); write(os, static_cast(c.orientation())); break; default: os << "CircleH2(" << c.center() << ", " << c.squared_radius() ; if (c.orientation() == CLOCKWISE) { os << ", clockwise)"; } else if (c.orientation() == COUNTERCLOCKWISE) { os << ", counterclockwise)"; } else { os << ", collinear)"; } break; } return os; } #endif // CGAL_NO_OSTREAM_INSERT_CIRCLEH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_CIRCLEH2 template < class R > std::istream& operator>>(std::istream &is, CircleH2 &c) { typename R::Point_2 center; typename R::FT squared_radius; int o; switch(is.iword(IO::mode)) { case IO::ASCII : is >> center >> squared_radius >> o; break; case IO::BINARY : is >> center; read(is, squared_radius); is >> o; break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } c = CircleH2(center, squared_radius, static_cast(o)); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_CIRCLEH2 CGAL_END_NAMESPACE #endif // CGAL_CIRCLEH2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/RayH3.h0000644000175000017500000001270711344301501030417 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/RayH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_RAYH3_H #define CGAL_RAYH3_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class RayH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef std::pair Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; RayH3() {} RayH3( const Point_3& sp, const Point_3& secondp) : base(sp, secondp-sp) {} RayH3( const Point_3& sp, const Vector_3& v) : base(sp, v) {} RayH3( const Point_3& sp, const Direction_3& d) : base(sp, d.to_vector()) {} RayH3( const Point_3& sp, const Line_3& l) : base(sp, l.to_vector()) {} const Point_3 & start() const; const Point_3 & source() const; Point_3 second_point() const; Point_3 point(int i) const; Direction_3 direction() const; const Vector_3 & to_vector() const; Line_3 supporting_line() const; RayH3 opposite() const; RayH3 transform( const Aff_transformation_3 & t) const; bool has_on(const Point_3& p) const; bool collinear_has_on(const Point_3 &p) const; bool is_degenerate() const; bool operator==(const RayH3& r) const; bool operator!=(const RayH3& r) const; }; template < class R > inline const typename RayH3::Point_3 & RayH3::source() const { return get(base).first; } template < class R > inline const typename RayH3::Point_3 & RayH3::start() const { return get(base).first; } template < class R > inline const typename RayH3::Vector_3 & RayH3::to_vector() const { return get(base).second; } template < class R > inline typename RayH3::Direction_3 RayH3::direction() const { return to_vector().direction(); } template < class R > CGAL_KERNEL_INLINE typename RayH3::Point_3 RayH3::second_point() const { return start() + to_vector(); } template < class R > CGAL_KERNEL_INLINE typename RayH3::Point_3 RayH3::point(int i) const { CGAL_kernel_precondition( i >= 0 ); return start() + RT(i)*to_vector(); } template < class R > CGAL_KERNEL_INLINE typename RayH3::Line_3 RayH3::supporting_line() const { CGAL_kernel_precondition( !is_degenerate() ); return Line_3(start(), second_point() ); } template < class R > CGAL_KERNEL_INLINE RayH3 RayH3::opposite() const { return RayH3( start(), - direction() ); } template < class R > CGAL_KERNEL_INLINE RayH3 RayH3::transform( const Aff_transformation_3 & t) const { return RayH3(t.transform(start()), t.transform(direction()) ); } #ifndef CGAL_NO_OSTREAM_INSERT_RAYH3 template < class R > std::ostream &operator<<(std::ostream &os, const RayH3 &r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r.start() << ' ' << r.direction(); case IO::BINARY : return os<< r.start() << r.direction(); default: return os << "RayH3(" << r.start() << ", " << r.direction() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_RAYH3 #ifndef CGAL_NO_ISTREAM_EXTRACT_RAYH3 template < class R > std::istream &operator>>(std::istream &is, RayH3 &r) { typename R::Point_3 p; typename R::Direction_3 d; is >> p >> d; r = RayH3(p, d); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_RAYH3 template < class R > CGAL_KERNEL_INLINE bool RayH3::has_on(const typename RayH3::Point_3 &p) const { return ( ( p == start() ) ||( Direction_3(p - start()) == direction() ) ); } template < class R > inline /* XXX */ bool RayH3::collinear_has_on(const typename RayH3::Point_3 &p) const { return has_on(p); } template < class R > inline bool RayH3::is_degenerate() const { return to_vector() == NULL_VECTOR; } template < class R > CGAL_KERNEL_INLINE bool RayH3::operator==(const RayH3& r) const { return ( (start() == r.start() )&&( direction() == r.direction() ) ); } template < class R > CGAL_KERNEL_INLINE bool RayH3::operator!=( const RayH3& r) const { return !operator==(r); } CGAL_END_NAMESPACE #endif // CGAL_RAYH3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/PointH2.h0000644000175000017500000001377211344301501030757 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/PointH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_POINT_2_H #define CGAL_HOMOGENEOUS_POINT_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class PointH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Point_2 Point_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef Cartesian_coordinate_iterator_2 Cartesian_const_iterator; typedef R_ R; PointH2() {} PointH2(const Origin &) : base (RT(0), RT(0), RT(1)) {} PointH2(const RT& hx, const RT& hy ) : base (hx, hy, RT(1)) {} PointH2(const RT& hx, const RT& hy, const RT& hw) { if ( hw >= RT(0) ) base = Rep( hx, hy, hw); else base = Rep(-hx,-hy,-hw); } bool operator==( const PointH2& p) const; bool operator!=( const PointH2& p) const; const RT & hx() const { return get(base).e0; }; const RT & hy() const { return get(base).e1; }; const RT & hw() const { return get(base).e2; }; FT x() const { return FT(hx()) / FT(hw()); }; FT y() const { return FT(hy()) / FT(hw()); }; FT cartesian(int i) const; FT operator[](int i) const; const RT & homogeneous(int i) const; Cartesian_const_iterator cartesian_begin() const { return Cartesian_const_iterator(static_cast(this), 0); } Cartesian_const_iterator cartesian_end() const { return Cartesian_const_iterator(static_cast(this), 2); } int dimension() const; Bbox_2 bbox() const; Point_2 transform( const Aff_transformation_2 & t) const; Direction_2 direction() const; }; template < class R > CGAL_KERNEL_INLINE bool PointH2::operator==( const PointH2& p) const { // FIXME : Predicate return ( (hx() * p.hw() == p.hx() * hw() ) &&(hy() * p.hw() == p.hy() * hw() ) ); } template < class R > inline bool PointH2::operator!=( const PointH2& p) const { return !(*this == p); } template < class R > CGAL_KERNEL_INLINE typename PointH2::FT PointH2::cartesian(int i) const { CGAL_kernel_precondition( (i==0 || i==1) ); if (i==0) return x(); return y(); } template < class R > CGAL_KERNEL_INLINE const typename PointH2::RT & PointH2::homogeneous(int i) const { CGAL_kernel_precondition( (i>=0) && (i<=2) ); if (i==0) return hx(); if (i==1) return hy(); return hw(); } template < class R > inline typename PointH2::FT PointH2::operator[](int i) const { return cartesian(i); } template < class R > inline int PointH2::dimension() const { return 2; } template < class R > CGAL_KERNEL_INLINE typename PointH2::Direction_2 PointH2::direction() const { return typename PointH2::Direction_2(*this); } template < class R > CGAL_KERNEL_MEDIUM_INLINE Bbox_2 PointH2::bbox() const { Interval_nt<> ihx = CGAL_NTS to_interval(hx()); Interval_nt<> ihy = CGAL_NTS to_interval(hy()); Interval_nt<> ihw = CGAL_NTS to_interval(hw()); Interval_nt<> ix = ihx/ihw; Interval_nt<> iy = ihy/ihw; return Bbox_2(ix.inf(), iy.inf(), ix.sup(), iy.sup()); } template < class R > inline typename R::Point_2 PointH2::transform(const typename PointH2::Aff_transformation_2& t) const { return t.transform(static_cast(*this)); } #ifndef CGAL_NO_OSTREAM_INSERT_POINTH2 template < class R > std::ostream & operator<<(std::ostream &os, const PointH2 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.hx() << ' ' << p.hy() << ' ' << p.hw(); case IO::BINARY : write(os, p.hx()); write(os, p.hy()); write(os, p.hw()); return os; default: return os << "PointH2(" << p.hx() << ", " << p.hy() << ", " << p.hw() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_POINTH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_POINTH2 template < class R > std::istream & operator>>(std::istream &is, PointH2 &p) { typename R::RT hx, hy, hw; switch(is.iword(IO::mode)) { case IO::ASCII : is >> hx >> hy >> hw; break; case IO::BINARY : read(is, hx); read(is, hy); read(is, hw); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = PointH2(hx, hy, hw); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_POINTH2 CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_POINT_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/VectorH2.h0000644000175000017500000002017711344301501031125 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/VectorH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_VECTOR_2_h #define CGAL_HOMOGENEOUS_VECTOR_2_h #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class VectorH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; VectorH2() {} VectorH2(const Point_2& a, const Point_2& b) { *this = R().construct_vector_2_object()(a, b); } VectorH2(const Segment_2& s) { *this = R().construct_vector_2_object()(s); } VectorH2(const Ray_2& r) { *this = R().construct_vector_2_object()(r); } VectorH2(const Line_2& l) { *this = R().construct_vector_2_object()(l); } VectorH2(const Null_vector &) : base (RT(0), RT(0), RT(1)) {} VectorH2(const RT& x, const RT& y) : base (x, y, RT(1)) {} VectorH2(const RT& x, const RT& y, const RT& w ) { if ( w >= RT(0) ) base = Rep( x, y, w); else base = Rep(-x, -y, -w); } bool operator==( const VectorH2& v) const; bool operator!=( const VectorH2& v) const; bool operator==( const Null_vector&) const; bool operator!=( const Null_vector& v) const; const RT & hx() const { return get(base).e0; }; const RT & hy() const { return get(base).e1; }; const RT & hw() const { return get(base).e2; }; FT x() const { return FT(hx()) / FT(hw()); }; FT y() const { return FT(hy()) / FT(hw()); }; FT cartesian(int i) const; const RT & homogeneous(int i) const; FT operator[](int i) const; int dimension() const; Direction_2 direction() const; Vector_2 transform(const Aff_transformation_2& t ) const; Vector_2 perpendicular(const Orientation& o ) const; Vector_2 operator+(const VectorH2 &v) const; Vector_2 operator-(const VectorH2 &v) const; Vector_2 operator-() const; Vector_2 opposite() const; FT squared_length() const; Vector_2 operator/(const RT &f) const; Vector_2 operator/(const FT &f) const; // undocumented: VectorH2(const Direction_2 & dir) : base ( dir) {} VectorH2(const Point_2 & p) : base ( p) {} }; template < class R > inline bool VectorH2::operator==( const Null_vector&) const { return (hx() == RT(0)) && (hy() == RT(0)); } template < class R > inline bool VectorH2::operator!=( const Null_vector& v) const { return !(*this == v); } template < class R > CGAL_KERNEL_INLINE bool VectorH2::operator==( const VectorH2& v) const { return ( (hx() * v.hw() == v.hx() * hw() ) &&(hy() * v.hw() == v.hy() * hw() ) ); } template < class R > inline bool VectorH2::operator!=( const VectorH2& v) const { return !(*this == v); } /* XXX */ template < class R > CGAL_KERNEL_INLINE typename VectorH2::FT VectorH2::cartesian(int i) const { CGAL_kernel_precondition( (i==0 || i==1) ); if (i==0) return x(); return y(); } template < class R > CGAL_KERNEL_INLINE const typename VectorH2::RT & VectorH2::homogeneous(int i) const { CGAL_kernel_precondition( (i>=0) && (i<=2) ); if (i==0) return hx(); if (i==1) return hy(); return hw(); } template < class R > inline typename VectorH2::FT VectorH2::operator[](int i) const { return cartesian(i); } template < class R > inline int VectorH2::dimension() const { return 2; } template < class R > CGAL_KERNEL_INLINE typename VectorH2::Direction_2 VectorH2::direction() const { return Direction_2(hx(), hy()); } template < class R > inline typename VectorH2::Vector_2 VectorH2::operator-() const { return VectorH2(- hx(), - hy(), hw() ); } template < class R > inline typename VectorH2::Vector_2 VectorH2::opposite() const { return VectorH2(- hx(), - hy(), hw() ); } template CGAL_KERNEL_INLINE typename VectorH2::Vector_2 VectorH2::operator+(const VectorH2& v) const { return VectorH2( hx()*v.hw() + v.hx()*hw(), hy()*v.hw() + v.hy()*hw(), hw()*v.hw() ); } template CGAL_KERNEL_INLINE typename VectorH2::Vector_2 VectorH2::operator-(const VectorH2& v) const { return VectorH2( hx()*v.hw() - v.hx()*hw(), hy()*v.hw() - v.hy()*hw(), hw()*v.hw() ); } template CGAL_KERNEL_INLINE typename VectorH2::FT VectorH2::squared_length() const { typedef typename R::FT FT; return FT( CGAL_NTS square(hx()) + CGAL_NTS square(hy()) ) / FT( CGAL_NTS square(hw()) ); } template CGAL_KERNEL_INLINE typename VectorH2::Vector_2 VectorH2::operator/(const typename VectorH2::RT& f) const { return VectorH2( hx(), hy(), hw()*f ); } template CGAL_KERNEL_INLINE typename VectorH2::Vector_2 VectorH2::operator/(const typename VectorH2::FT& f) const { return VectorH2( hx()*f.denominator(), hy()*f.denominator(), hw()*f.numerator() ); } template < class R > CGAL_KERNEL_INLINE typename R::Vector_2 VectorH2::perpendicular(const Orientation& o) const { CGAL_kernel_precondition(o != COLLINEAR); if (o == COUNTERCLOCKWISE) return typename R::Vector_2(-hy(), hx(), hw()); else return typename R::Vector_2(hy(), -hx(), hw()); } template < class R > inline typename R::Vector_2 VectorH2:: transform(const typename VectorH2::Aff_transformation_2& t) const { return t.transform(*this); } #ifndef CGAL_NO_OSTREAM_INSERT_VECTORH2 template < class R > std::ostream & operator<<(std::ostream &os, const VectorH2 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.hx() << ' ' << p.hy() << ' ' << p.hw(); case IO::BINARY : write(os, p.hx()); write(os, p.hy()); write(os, p.hw()); return os; default: return os << "VectorH2(" << p.hx() << ", " << p.hy() << ", " << p.hw() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_VECTORH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_VECTORH2 template < class R > std::istream & operator>>(std::istream &is, VectorH2 &p) { typename R::RT hx, hy, hw; switch(is.iword(IO::mode)) { case IO::ASCII : is >> hx >> hy >> hw; break; case IO::BINARY : read(is, hx); read(is, hy); read(is, hw); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = VectorH2(hx, hy, hw); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_VECTORH2 CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_VECTOR_2_h mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/VectorH3.h0000644000175000017500000001732211344301501031124 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/VectorH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_VECTOR_3_H #define CGAL_HOMOGENEOUS_VECTOR_3_H #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class VectorH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Segment_3 Segment_3; typedef typename R_::Ray_3 Ray_3; typedef typename R_::Line_3 Line_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Fourtuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; VectorH3() {} VectorH3(const Point_3& a, const Point_3& b) { *this = R().construct_vector_3_object()(a, b); } VectorH3(const Segment_3& s) { *this = R().construct_vector_3_object()(s); } VectorH3(const Ray_3& r) { *this = R().construct_vector_3_object()(r); } VectorH3(const Line_3& l) { *this = R().construct_vector_3_object()(l); } VectorH3(const Null_vector&) : base(RT(0), RT(0), RT(0), RT(1)) {} VectorH3(const RT& x, const RT& y, const RT& z) : base(x, y, z, RT(1)) {} VectorH3(const RT& w, const RT& x, const RT& y, const RT& z); const RT & hx() const { return get(base).e0 ; } const RT & hy() const { return get(base).e1 ; } const RT & hz() const { return get(base).e2 ; } const RT & hw() const { return get(base).e3 ; } FT x() const { return FT(hx())/FT(hw()) ; } FT y() const { return FT(hy())/FT(hw()) ; } FT z() const { return FT(hz())/FT(hw()) ; } const RT & homogeneous(int i) const; FT cartesian(int i) const; FT operator[](int i) const; int dimension() const { return 3; }; Direction_3 direction() const; Vector_3 transform(const Aff_transformation_3& t ) const; Vector_3 operator-() const; bool operator==( const VectorH3& v) const; bool operator!=( const VectorH3& v) const; Vector_3 operator+( const VectorH3 &v) const; Vector_3 operator-( const VectorH3 &v) const; FT squared_length() const; Vector_3 operator/( const RT &f) const; Vector_3 operator/( const FT &f) const; }; template < class R > CGAL_KERNEL_INLINE VectorH3::VectorH3(const RT& x, const RT& y, const RT& z, const RT& w) { if ( w >= RT(0) ) base = Rep(x, y, z, w); else base = Rep(-x,-y,-z,-w); } template < class R > CGAL_KERNEL_INLINE typename VectorH3::FT VectorH3::cartesian(int i) const { CGAL_kernel_precondition(i == 0 || i == 1 || i == 2); switch (i) { case 0: return x(); case 1: return y(); } return z(); } template < class R > CGAL_KERNEL_INLINE const typename VectorH3::RT & VectorH3::homogeneous(int i) const { CGAL_kernel_precondition(i == 0 || i == 1 || i == 2 || i == 3); switch (i) { case 0: return hx(); case 1: return hy(); case 2: return hz(); } return hw() ; } template < class R > inline typename VectorH3::Direction_3 VectorH3::direction() const { return Direction_3(hx(), hy(), hz()); } template < class R > CGAL_KERNEL_INLINE bool VectorH3::operator==( const VectorH3& v) const { return ( (hx() * v.hw() == v.hx() * hw() ) &&(hy() * v.hw() == v.hy() * hw() ) &&(hz() * v.hw() == v.hz() * hw() ) ); } template < class R > inline bool VectorH3::operator!=( const VectorH3& v) const { return !(*this == v); } template < class R > inline typename VectorH3::FT VectorH3::operator[](int i) const { return cartesian(i); } template < class R > CGAL_KERNEL_INLINE typename VectorH3::Vector_3 VectorH3::operator-() const { return Vector_3( - hx(), - hy(), -hz(), hw() ); } template CGAL_KERNEL_INLINE typename R::Vector_3 VectorH3::operator+(const VectorH3& v) const { return typename R::Vector_3(hx()*v.hw() + v.hx()*hw(), hy()*v.hw() + v.hy()*hw(), hz()*v.hw() + v.hz()*hw(), hw()*v.hw() ); } template CGAL_KERNEL_INLINE typename R::Vector_3 VectorH3::operator-(const VectorH3& v) const { return typename R::Vector_3(hx()*v.hw() - v.hx()*hw(), hy()*v.hw() - v.hy()*hw(), hz()*v.hw() - v.hz()*hw(), hw()*v.hw() ); } template CGAL_KERNEL_INLINE typename VectorH3::FT VectorH3::squared_length() const { typedef typename R::FT FT; return FT( CGAL_NTS square(hx()) + CGAL_NTS square(hy()) + CGAL_NTS square(hz()) ) / FT( CGAL_NTS square(hw()) ); } template CGAL_KERNEL_INLINE typename R::Vector_3 VectorH3::operator/(const typename VectorH3::RT& f) const { return typename R::Vector_3( hx(), hy(), hz(), hw()*f ); } template CGAL_KERNEL_INLINE typename R::Vector_3 VectorH3::operator/(const typename VectorH3::FT& f) const { return typename R::Vector_3(hx()*f.denominator(), hy()*f.denominator(), hz()*f.denominator(), hw()*f.numerator() ); } template < class R > inline typename R::Vector_3 VectorH3:: transform(const typename VectorH3::Aff_transformation_3&t ) const { return t.transform(*this); } #ifndef CGAL_NO_OSTREAM_INSERT_VECTORH3 template < class R > std::ostream& operator<<(std::ostream& os, const VectorH3& v) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << v.hx() << ' ' << v.hy() << ' ' << v.hz() << ' ' << v.hw(); case IO::BINARY : write(os, v.hx()); write(os, v.hy()); write(os, v.hz()); write(os, v.hw()); return os; default: return os << "VectorH3(" << v.hx() << ", " << v.hy() << ", " << v.hz() << ", " << v.hw() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_VECTORH3 #ifndef CGAL_NO_ISTREAM_EXTRACT_VECTORH3 template < class R > std::istream& operator>>(std::istream& is, VectorH3& v) { typename R::RT hx, hy, hz, hw; switch(is.iword(IO::mode)) { case IO::ASCII : is >> hx >> hy >> hz >> hw; break; case IO::BINARY : read(is, hx); read(is, hy); read(is, hz); read(is, hw); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } v = VectorH3(hx, hy, hz, hw); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_VECTORH3 CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_VECTOR_3_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Data_accessorH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Data_acces0000644000175000017500000000356211344301501031251 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Data_accessorH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_DATA_ACCESSORH2_H #define CGAL_DATA_ACCESSORH2_H CGAL_BEGIN_NAMESPACE template < class R > class Data_accessorH2 { public: typedef typename R::FT FT; typedef typename R::RT RT; typedef typename R::Point_2 Point_2; RT get_hx( const Point_2 & p) const { return( p.hx()); } RT get_hy( const Point_2 & p) const { return( p.hy()); } RT get_hw( const Point_2 & p) const { return( p.hw()); } void get( const Point_2 & p, RT& hx, RT& hy, RT& hw) const { hx = get_hx( p); hy = get_hy( p); hw = get_hw( p); } void set( Point_2& p, const RT & hx, const RT & hy, const RT & hw) const { p = Point_2( hx, hy, hw); } }; CGAL_END_NAMESPACE #endif // CGAL_DATA_ACCESSORH2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/LineH2.h0000644000175000017500000002511611344301501030550 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/LineH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_LINEH2_H #define CGAL_LINEH2_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class LineH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Segment_2 Segment_2; typedef typename R_::Ray_2 Ray_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Threetuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; LineH2() {} LineH2(const Point_2& p, const Point_2& q); LineH2(const RT& a, const RT& b, const RT& c); LineH2(const Segment_2& s); LineH2(const Ray_2& r); LineH2(const Point_2& p, const Direction_2& d); LineH2(const Point_2& p, const Vector_2& v); bool operator==(const LineH2& l) const ; bool operator!=(const LineH2& l) const ; const RT & a() const { return get(base).e0; } const RT & b() const { return get(base).e1; } const RT & c() const { return get(base).e2; } FT x_at_y(FT y) const; FT y_at_x(FT x) const; Line_2 perpendicular(const Point_2& p ) const; Line_2 opposite() const; Point_2 point() const; Point_2 point(int i) const; Point_2 projection(const Point_2& p) const; Direction_2 direction() const; Vector_2 to_vector() const; Oriented_side oriented_side( const Point_2& p ) const; bool has_on( const Point_2& p ) const; bool has_on_boundary( const Point_2& p ) const; bool has_on_positive_side( const Point_2& p ) const; bool has_on_negative_side( const Point_2& p ) const; bool is_horizontal() const; bool is_vertical() const; bool is_degenerate() const; Line_2 transform(const Aff_transformation_2&) const; }; template < class R > CGAL_KERNEL_MEDIUM_INLINE LineH2::LineH2(const typename LineH2::Point_2& p, const typename LineH2::Point_2& q) : base( // a() * X + b() * Y + c() * W() == 0 // | X Y W | // | p.hx() p.hy() p.hw() | // | q.hx() q.hy() q.hw() | p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx()) {} template < class R > CGAL_KERNEL_INLINE LineH2::LineH2(const RT& a, const RT& b, const RT& c) : base(a, b, c) {} template < class R > CGAL_KERNEL_INLINE LineH2::LineH2(const typename LineH2::Segment_2& s) { Point_2 p = s.start(); Point_2 q = s.end(); base = Rep ( p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx()); } template < class R > CGAL_KERNEL_INLINE LineH2::LineH2(const typename LineH2::Ray_2& r) { Point_2 p = r.start(); Point_2 q = r.second_point(); base = Rep ( p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx() ); } template < class R > CGAL_KERNEL_INLINE LineH2::LineH2(const typename LineH2::Point_2& p, const typename LineH2::Vector_2& v) { Point_2 q = p + v; base = Rep ( p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx() ); } template < class R > CGAL_KERNEL_INLINE LineH2::LineH2(const typename LineH2::Point_2& p, const typename LineH2::Direction_2& d) { Point_2 q = p + d.to_vector(); base = Rep ( p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx() ); } template < class R > CGAL_KERNEL_INLINE typename LineH2::FT LineH2::x_at_y(FT y) const { CGAL_kernel_precondition( !is_degenerate() ); return (FT(-b())*y - FT(c()) )/FT(a()); } template < class R > CGAL_KERNEL_INLINE typename LineH2::FT LineH2::y_at_x(FT x) const { CGAL_kernel_precondition( !is_degenerate() ); return (FT(-a())*x - FT(c()) )/FT(b()); } template < class R > CGAL_KERNEL_INLINE typename R::Line_2 LineH2::perpendicular(const typename LineH2::Point_2& p ) const { CGAL_kernel_precondition( !is_degenerate() ); return typename R::Line_2( -b()*p.hw(), a()*p.hw(), b()*p.hx() - a()*p.hy()); } template < class R > inline typename R::Line_2 LineH2::opposite() const { return typename R::Line_2( -a(), -b(), -c() ); } template < class R > CGAL_KERNEL_INLINE typename LineH2::Point_2 LineH2::point() const { CGAL_kernel_precondition( !is_degenerate() ); if (is_vertical() ) { return Point_2(-c(), RT(0) , a() ); } else { return Point_2(RT(0) , -c(), b() ); } } template < class R > CGAL_KERNEL_INLINE typename LineH2::Point_2 LineH2::point(int i) const { return point() + RT(i) * to_vector(); } template < class R > CGAL_KERNEL_INLINE typename LineH2::Point_2 LineH2::projection(const typename LineH2::Point_2& p) const { CGAL_kernel_precondition( !is_degenerate() ); LineH2 l( p, Direction_2( a(), b() )); return Point_2( b()*l.c() - l.b()*c(), l.a()*c() - a()*l.c(), a()*l.b() - l.a()*b() ); } template < class R > CGAL_KERNEL_INLINE typename LineH2::Vector_2 LineH2::to_vector() const { CGAL_kernel_precondition( !is_degenerate() ); return Vector_2( b(), -a() ); } template < class R > CGAL_KERNEL_INLINE typename LineH2::Direction_2 LineH2::direction() const { CGAL_kernel_precondition( !is_degenerate() ); return Direction_2( b(), -a() ); } template < class R > CGAL_KERNEL_INLINE typename R::Line_2 LineH2::transform(const typename LineH2::Aff_transformation_2& t) const { CGAL_kernel_precondition( !is_degenerate() ); Point_2 p = point() + to_vector(); return typename R::Line_2( t.transform(point() ), t.transform(p) ); } #ifndef CGAL_NO_OSTREAM_INSERT_LINEH2 template < class R > std::ostream & operator<<(std::ostream &os, const LineH2 &l) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << l.a() << ' ' << l.b() << ' ' << l.c(); case IO::BINARY : write(os, l.a()); write(os, l.b()); write(os, l.c()); return os; default: return os << "LineH2(" << l.a() << ", " << l.b() << ", " << l.c() <<')'; } } #endif // CGAL_NO_OSTREAM_INSERT_LINEH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_LINEH2 template < class R > std::istream & operator>>(std::istream &is, LineH2 &p) { typename R::RT a, b, c; switch(is.iword(IO::mode)) { case IO::ASCII : is >> a >> b >> c; break; case IO::BINARY : read(is, a); read(is, b); read(is, c); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = LineH2(a, b, c); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_LINEH2 template < class R > CGAL_KERNEL_INLINE bool LineH2::has_on( const typename LineH2::Point_2& p ) const { CGAL_kernel_precondition( !is_degenerate() ); return ( ( a()*p.hx() + b()*p.hy() + c()*p.hw() ) == RT(0) ); } template < class R > CGAL_KERNEL_INLINE bool LineH2::has_on_boundary( const typename LineH2::Point_2& p ) const { CGAL_kernel_precondition( !is_degenerate() ); return ( ( a()*p.hx() + b()*p.hy() + c()*p.hw() ) == RT(0) ); } template < class R > CGAL_KERNEL_INLINE bool LineH2::has_on_positive_side( const typename LineH2::Point_2& p ) const { CGAL_kernel_precondition( !is_degenerate() ); return ( ( a()*p.hx() + b()*p.hy() + c()*p.hw() ) > RT(0) ); } template < class R > CGAL_KERNEL_INLINE bool LineH2::has_on_negative_side( const typename LineH2::Point_2& p ) const { CGAL_kernel_precondition( !is_degenerate() ); return ( ( a()*p.hx() + b()*p.hy() + c()*p.hw() ) < RT(0) ); } template < class R > CGAL_KERNEL_INLINE Oriented_side LineH2::oriented_side( const typename LineH2::Point_2& p ) const { CGAL_kernel_precondition( !is_degenerate() ); RT v = a()*p.hx() + b()*p.hy() + c()*p.hw(); if (v > RT(0) ) { return ON_POSITIVE_SIDE; } else { return (v < RT(0) ) ? ON_NEGATIVE_SIDE : ON_ORIENTED_BOUNDARY; } } template < class R > inline bool LineH2::is_horizontal() const { return ( a() == RT(0) ); } template < class R > inline bool LineH2::is_vertical() const { return ( b() == RT(0) ); } template < class R > inline bool LineH2::is_degenerate() const { return (a() == RT(0) )&&(b() == RT(0) ) ; } template < class R > CGAL_KERNEL_MEDIUM_INLINE bool LineH2::operator==(const LineH2& l) const { if ( (a() * l.c() != l.a() * c() ) ||(b() * l.c() != l.b() * c() ) ) { return false; } int sc = static_cast(CGAL_NTS sign(c())); int slc = static_cast(CGAL_NTS sign(l.c())); if ( sc == slc ) { if (sc == 0) return ( (a()*l.b() == b()*l.a() ) &&(CGAL_NTS sign(a() )== CGAL_NTS sign( l.a() )) &&(CGAL_NTS sign(b() )== CGAL_NTS sign( l.b() )) ); else return true; } else return false; } template < class R > inline bool LineH2::operator!=(const LineH2& l) const { return !(*this == l); } CGAL_END_NAMESPACE #endif // CGAL_LINEH2_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/distance_predicatesH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/distance_p0000644000175000017500000002277011344301501031355 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/distance_predicatesH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_DISTANCE_PREDICATESH3_H #define CGAL_DISTANCE_PREDICATESH3_H CGAL_BEGIN_NAMESPACE template Comparison_result compare_distance_to_point(const PointH3& , const PointH3& , const PointH3& ); template bool has_larger_distance_to_point(const PointH3& , const PointH3& , const PointH3& ); template bool has_smaller_distance_to_point(const PointH3& , const PointH3& , const PointH3& ); template Comparison_result compare_signed_distance_to_plane(const PlaneH3& , const PointH3& , const PointH3& ); template bool has_larger_signed_distance_to_plane(const PlaneH3& , const PointH3& , const PointH3& ); template bool has_smaller_signed_distance_to_plane(const PlaneH3&, const PointH3& , const PointH3& ); template Comparison_result compare_signed_distance_to_plane(const PointH3& , const PointH3& , const PointH3& , const PointH3& , const PointH3& ); template bool has_larger_signed_distance_to_plane(const PointH3& , const PointH3& , const PointH3& , const PointH3& , const PointH3& ); template bool has_smaller_signed_distance_to_plane(const PointH3& , const PointH3& , const PointH3& , const PointH3& , const PointH3& ); template CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_distance_to_point(const PointH3& p, const PointH3& q, const PointH3& r) { typedef typename R::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhz = r.hz(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy + qhz*qhz ) - RT2 * qhw * ( phx*qhx + phy*qhy + phz*qhz ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy + rhz*rhz ) - RT2 * rhw * ( phx*rhx + phy*rhy + phz*rhz ) ); if ( RT0 < dosd ) { return LARGER; } else { return (dosd < RT0) ? SMALLER : EQUAL; } } template < class R> CGAL_KERNEL_MEDIUM_INLINE bool has_larger_distance_to_point(const PointH3& p, const PointH3& q, const PointH3& r) { typedef typename R::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhz = r.hz(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy + qhz*qhz ) - RT2 * qhw * ( phx*qhx + phy*qhy + phz*qhz ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy + rhz*rhz ) - RT2 * rhw * ( phx*rhx + phy*rhy + phz*rhz ) ); return ( RT0 < dosd ); } template < class R> CGAL_KERNEL_MEDIUM_INLINE bool has_smaller_distance_to_point(const PointH3& p, const PointH3& q, const PointH3& r) { typedef typename R::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhz = r.hz(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy + qhz*qhz ) - RT2 * qhw * ( phx*qhx + phy*qhy + phz*qhz ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy + rhz*rhz ) - RT2 * rhw * ( phx*rhx + phy*rhy + phz*rhz ) ); return ( dosd < RT0 ); } template < class R> CGAL_KERNEL_INLINE Comparison_result compare_signed_distance_to_plane(const PlaneH3& pl, const PointH3& p, const PointH3& q) { typedef typename R::RT RT; const RT pla = pl.a(); const RT plb = pl.b(); const RT plc = pl.c(); const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = pla*( phx*qhw - qhx*phw ) + plb*( phy*qhw - qhy*phw ) + plc*( phz*qhw - qhz*phw ); if ( scaled_dist_p_minus_scaled_dist_q < RT0 ) { return SMALLER; } else { return (RT0 < scaled_dist_p_minus_scaled_dist_q ) ? LARGER : EQUAL;} } template bool has_larger_signed_distance_to_plane(const PlaneH3& pl, const PointH3& p, const PointH3& q ) { typedef typename R::RT RT; const RT pla = pl.a(); const RT plb = pl.b(); const RT plc = pl.c(); const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = pla*( phx*qhw - qhx*phw ) + plb*( phy*qhw - qhy*phw ) + plc*( phz*qhw - qhz*phw ); return ( RT0 < scaled_dist_p_minus_scaled_dist_q ); } template bool has_smaller_signed_distance_to_plane(const PlaneH3& pl, const PointH3& p, const PointH3& q ) { typedef typename R::RT RT; const RT pla = pl.a(); const RT plb = pl.b(); const RT plc = pl.c(); const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = pla*( phx*qhw - qhx*phw ) + plb*( phy*qhw - qhy*phw ) + plc*( phz*qhw - qhz*phw ); return ( scaled_dist_p_minus_scaled_dist_q < RT0 ); } template inline Comparison_result compare_signed_distance_to_plane(const PointH3& p, const PointH3& q, const PointH3& r, const PointH3& s, const PointH3& t) { CGAL_kernel_precondition( !collinear(p,q,r) ); PlaneH3 P(p,q,r); return cmp_signed_dist_to_plane( P, s, t); } template inline bool has_larger_signed_distance_to_plane(const PointH3& p, const PointH3& q, const PointH3& r, const PointH3& s, const PointH3& t) { return cmp_signed_dist_to_plane(p,q,r,s,t) == LARGER; } template inline bool has_smaller_signed_distance_to_plane(const PointH3& p, const PointH3& q, const PointH3& r, const PointH3& s, const PointH3& t) { return cmp_signed_dist_to_plane(p,q,r,s,t) == SMALLER; } CGAL_END_NAMESPACE #endif //CGAL_DISTANCE_PREDICATESH3_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Iso_rectangleH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Iso_rectan0000644000175000017500000002364711344301501031336 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Iso_rectangleH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_ISO_RECTANGLEH2_H #define CGAL_ISO_RECTANGLEH2_H #include CGAL_BEGIN_NAMESPACE template class Iso_rectangleH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; Iso_rectangleH2() {} Iso_rectangleH2(const Point_2& p, const Point_2& q); Iso_rectangleH2(const Point_2& left, const Point_2& right, const Point_2& bottom, const Point_2& top); Iso_rectangleH2(const RT& min_hx, const RT& min_hy, const RT& max_hx, const RT& max_hy); Iso_rectangleH2(const RT& min_hx, const RT& min_hy, const RT& max_hx, const RT& max_hy, const RT& hw); bool operator==(const Iso_rectangleH2& s) const; bool operator!=(const Iso_rectangleH2& s) const; const Point_2 & min() const; const Point_2 & max() const; Point_2 vertex(int i) const; Point_2 operator[](int i) const; Iso_rectangleH2 transform(const Aff_transformation_2& t) const; Bounded_side bounded_side(const Point_2& p) const; bool has_on(const Point_2& p) const; bool has_on_boundary(const Point_2& p) const; bool has_on_bounded_side(const Point_2& p) const; bool has_on_unbounded_side(const Point_2& p) const; bool is_degenerate() const; Bbox_2 bbox() const; FT xmin() const; FT ymin() const; FT xmax() const; FT ymax() const; FT min_coord(int i) const; FT max_coord(int i) const; FT area() const; }; template < class R > CGAL_KERNEL_MEDIUM_INLINE Iso_rectangleH2:: Iso_rectangleH2(const typename Iso_rectangleH2::Point_2& p, const typename Iso_rectangleH2::Point_2& q) { bool px_g_qx = ( p.hx()*q.hw() > q.hx()*p.hw() ); bool py_g_qy = ( p.hy()*q.hw() > q.hy()*p.hw() ); if ( px_g_qx || py_g_qy) { if ( px_g_qx && py_g_qy ) { base = Rep(q, p); } else { if ( px_g_qx ) { base = Rep( Point_2(q.hx()*p.hw(), p.hy()*q.hw(), q.hw()*p.hw() ), Point_2(p.hx()*q.hw(), q.hy()*p.hw(), q.hw()*p.hw() )); } if ( py_g_qy ) { base = Rep( Point_2(p.hx()*q.hw(), q.hy()*p.hw(), q.hw()*p.hw() ), Point_2(q.hx()*p.hw(), p.hy()*q.hw(), q.hw()*p.hw() )); } } } else { base = Rep(p, q); } } template < class R > CGAL_KERNEL_MEDIUM_INLINE Iso_rectangleH2:: Iso_rectangleH2(const typename Iso_rectangleH2::Point_2& left, const typename Iso_rectangleH2::Point_2& right, const typename Iso_rectangleH2::Point_2& bottom, const typename Iso_rectangleH2::Point_2& top) : base(Point_2(left.hx() * bottom.hw(), bottom.hy() * left.hw(), left.hw() * bottom.hw()), Point_2(right.hx() * top.hw(), top.hy() * right.hw(), right.hw() * top.hw())) { CGAL_kernel_precondition(!less_x(right, left)); CGAL_kernel_precondition(!less_y(top, bottom)); } template < class R > inline Iso_rectangleH2::Iso_rectangleH2(const RT& min_hx, const RT& min_hy, const RT& max_hx, const RT& max_hy) : base(Point_2(min_hx, min_hy), Point_2(max_hx, max_hy)) {} template < class R > inline Iso_rectangleH2::Iso_rectangleH2(const RT& min_hx, const RT& min_hy, const RT& max_hx, const RT& max_hy, const RT& hw) : base(Point_2(min_hx, min_hy, hw), Point_2(max_hx, max_hy, hw)) {} template < class R > inline bool Iso_rectangleH2::operator==(const Iso_rectangleH2& r) const { return vertex(0) == r.vertex(0) && vertex(2) == r.vertex(2); } template < class R > inline bool Iso_rectangleH2::operator!=(const Iso_rectangleH2& r) const { return !(*this == r); } template < class R > inline const typename Iso_rectangleH2::Point_2 & Iso_rectangleH2::min() const { return get(base).e0; } template < class R > inline const typename Iso_rectangleH2::Point_2 & Iso_rectangleH2::max() const { return get(base).e1; } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::xmin() const { return FT( min().hx() ) / FT( min().hw() ); } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::ymin() const { return FT( min().hy() ) / FT( min().hw() ); } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::xmax() const { return FT( max().hx() ) / FT( max().hw() ); } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::ymax() const { return FT( max().hy() ) / FT( max().hw() ); } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::min_coord(int i) const { CGAL_kernel_precondition ( i == 0 || i == 1 ); if (i == 0) return xmin(); else return ymin(); } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::max_coord(int i) const { CGAL_kernel_precondition ( i == 0 || i == 1 ); if (i == 0) return xmax(); else return ymax(); } template < class R > inline typename Iso_rectangleH2::FT Iso_rectangleH2::area() const { return (xmax() - xmin()) * (ymax() - ymin()); } template < class R > CGAL_KERNEL_INLINE typename Iso_rectangleH2::Point_2 Iso_rectangleH2::vertex(int i) const { switch (i%4) { case 0: return min(); case 1: return Point_2( max().hx()*min().hw(), min().hy()*max().hw(), min().hw()*max().hw() ); case 2: return max(); default: // case 3: return Point_2( min().hx()*max().hw(), max().hy()*min().hw(), min().hw()*max().hw() ); } } template < class R > inline typename Iso_rectangleH2::Point_2 Iso_rectangleH2::operator[](int i) const { return vertex(i); } template < class R > CGAL_KERNEL_INLINE Bounded_side Iso_rectangleH2:: bounded_side(const typename Iso_rectangleH2::Point_2& p) const { Oriented_side wrt_min = _where_wrt_L_wedge(min(),p); Oriented_side wrt_max = _where_wrt_L_wedge(p,max()); if (( wrt_min == ON_NEGATIVE_SIDE )||( wrt_max == ON_NEGATIVE_SIDE)) { return ON_UNBOUNDED_SIDE; } if ( ( wrt_min == ON_ORIENTED_BOUNDARY ) ||( wrt_max == ON_ORIENTED_BOUNDARY ) ) { return ON_BOUNDARY; } return ON_BOUNDED_SIDE; } template < class R > inline bool Iso_rectangleH2:: has_on_boundary(const typename Iso_rectangleH2::Point_2& p) const { return ( bounded_side(p) == ON_BOUNDARY ); } template < class R > inline bool Iso_rectangleH2::has_on(const typename Iso_rectangleH2::Point_2& p) const { return ( bounded_side(p) == ON_BOUNDARY ); } template < class R > inline bool Iso_rectangleH2:: has_on_bounded_side(const typename Iso_rectangleH2::Point_2& p) const { return ( bounded_side(p) == ON_BOUNDED_SIDE ); } template < class R > CGAL_KERNEL_INLINE bool Iso_rectangleH2:: has_on_unbounded_side(const typename Iso_rectangleH2::Point_2& p) const { return ( (_where_wrt_L_wedge(min(),p) == ON_NEGATIVE_SIDE) ||(_where_wrt_L_wedge(p,max()) == ON_NEGATIVE_SIDE) ); } template < class R > CGAL_KERNEL_INLINE bool Iso_rectangleH2::is_degenerate() const { return ( ( min().hx()*max().hw() == max().hx()*min().hw() ) || ( min().hy()*max().hw() == max().hy()*min().hw() ) ); } template < class R > inline Bbox_2 Iso_rectangleH2::bbox() const { return min().bbox() + max().bbox(); } template < class R > CGAL_KERNEL_INLINE Iso_rectangleH2 Iso_rectangleH2:: transform(const typename Iso_rectangleH2::Aff_transformation_2&t) const { return Iso_rectangleH2(t.transform(min() ), t.transform(max() ) ); } #ifndef CGAL_NO_OSTREAM_INSERT_ISO_RECTANGLEH2 template < class R > std::ostream& operator<<(std::ostream& os, const Iso_rectangleH2& r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r[0] << ' ' << r[2]; case IO::BINARY : return os << r[0] << r[2]; default: return os << "Iso_rectangleH2(" << r[0] << ", " << r[2] << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_ISO_RECTANGLEH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_ISO_RECTANGLEH2 template < class R > std::istream& operator>>(std::istream& is, Iso_rectangleH2& r) { typename R::Point_2 p, q; is >> p >> q; r = Iso_rectangleH2(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_ISO_RECTANGLEH2 CGAL_END_NAMESPACE #endif // CGAL_ISO_RECTANGLEH2_H ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_pointsH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates0000644000175000017500000000620211344301501031357 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_pointsH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_PREDICATES_ON_POINTSH3_H #define CGAL_PREDICATES_ON_POINTSH3_H #include CGAL_BEGIN_NAMESPACE template < class R > CGAL_KERNEL_MEDIUM_INLINE bool lexicographically_xy_smaller(const PointH3 &p, const PointH3 &q) { typedef typename R::RT RT; RT pV = p.hx()*q.hw(); RT qV = q.hx()*p.hw(); if ( pV < qV ) { return true; } if ( qV < pV ) { return false; } // same x pV = p.hy()*q.hw(); qV = q.hy()*p.hw(); if ( pV < qV ) { return true; } return false; } template < class R> CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_xy(const PointH3& p, const PointH3& q) { typedef typename R::RT RT; RT pV = p.hx()*q.hw(); RT qV = q.hx()*p.hw(); if ( pV < qV ) { return SMALLER; } if ( qV < pV ) // ( pV > qV ) { return LARGER; } // same x pV = p.hy()*q.hw(); qV = q.hy()*p.hw(); if ( pV < qV ) { return SMALLER; } if ( qV < pV ) // ( pV > qV ) { return LARGER; } // same x and y return EQUAL; } template < class R > CGAL_KERNEL_INLINE bool equal_xy(const PointH3 &p, const PointH3 &q) { return (p.hx() * q.hw() == q.hx() * p.hw() ) && (p.hy() * q.hw() == q.hy() * p.hw() ); } template < class R > // ??? -> == CGAL_KERNEL_INLINE bool equal_xyz(const PointH3 &p, const PointH3 &q) { return (p.hx() * q.hw() == q.hx() * p.hw() ) && (p.hy() * q.hw() == q.hy() * p.hw() ) && (p.hz() * q.hw() == q.hz() * p.hw() ); } template < class R > CGAL_KERNEL_INLINE bool less_x(const PointH3 &p, const PointH3 &q) { return (p.hx() * q.hw() < q.hx() * p.hw() ); } template < class R > CGAL_KERNEL_INLINE bool less_y(const PointH3 &p, const PointH3 &q) { return (p.hy() * q.hw() < q.hy() * p.hw() ); } template < class R > CGAL_KERNEL_INLINE bool less_z(const PointH3 &p, const PointH3 &q) { return (p.hz() * q.hw() < q.hz() * p.hw() ); } CGAL_END_NAMESPACE #endif // CGAL_PREDICATES_ON_POINTSH3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/PointH3.h0000644000175000017500000001567211344301501030761 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/PointH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_HOMOGENEOUS_POINT_3_H #define CGAL_HOMOGENEOUS_POINT_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class R_ > class PointH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Vector_3 Vector_3; typedef typename R_::Point_3 Point_3; typedef typename R_::Direction_3 Direction_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Fourtuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef Cartesian_coordinate_iterator_3 Cartesian_const_iterator; typedef R_ R; PointH3() {} PointH3(const Origin &) : base (RT(0), RT(0), RT(0), RT(1)) { } PointH3(const RT& x, const RT& y, const RT& z) : base(x, y, z, RT(1)) {} PointH3(const RT& x, const RT& y, const RT& z, const RT& w) { if ( w < RT(0) ) base = Rep(-x,-y,-z,-w); else base = Rep(x,y,z,w); } FT x() const; FT y() const; FT z() const; const RT & hx() const; const RT & hy() const; const RT & hz() const; const RT & hw() const; const RT & homogeneous(int i) const; FT cartesian(int i) const; FT operator[](int i) const; Cartesian_const_iterator cartesian_begin() const { return Cartesian_const_iterator(static_cast(this), 0); } Cartesian_const_iterator cartesian_end() const { return Cartesian_const_iterator(static_cast(this), 3); } int dimension() const; Direction_3 direction() const; Point_3 transform( const Aff_transformation_3 & t) const; Bbox_3 bbox() const; bool operator==( const PointH3& p) const; bool operator!=( const PointH3& p) const; }; template < class R > inline const typename PointH3::RT & PointH3::hx() const { return get(base).e0 ; } template < class R > inline const typename PointH3::RT & PointH3::hy() const { return get(base).e1 ; } template < class R > inline const typename PointH3::RT & PointH3::hz() const { return get(base).e2 ; } template < class R > inline const typename PointH3::RT & PointH3::hw() const { return get(base).e3 ; } template < class R > CGAL_KERNEL_INLINE typename PointH3::FT PointH3::x() const { return ( FT(hx()) / FT(hw())); } template < class R > CGAL_KERNEL_INLINE typename PointH3::FT PointH3::y() const { return ( FT(hy()) / FT(hw())); } template < class R > CGAL_KERNEL_INLINE typename PointH3::FT PointH3::z() const { return ( FT(hz()) / FT(hw())); } template < class R > inline int PointH3::dimension() const { return 3; } template < class R > CGAL_KERNEL_INLINE typename PointH3::FT PointH3::cartesian(int i) const { CGAL_kernel_precondition(i == 0 || i == 1 || i == 2); switch (i) { case 0: return x(); case 1: return y(); } return z(); } template < class R > CGAL_KERNEL_INLINE const typename PointH3::RT & PointH3::homogeneous(int i) const { CGAL_kernel_precondition(i == 0 || i == 1 || i == 2 || i == 3); switch (i) { case 0: return hx(); case 1: return hy(); case 2: return hz(); } return hw(); } template < class R > inline typename PointH3::FT PointH3::operator[](int i) const { return cartesian(i); } template < class R > inline typename PointH3::Direction_3 PointH3::direction() const { return Direction_3(*this); } template < class R > CGAL_KERNEL_INLINE bool PointH3::operator==( const PointH3 & p) const { return ( (hx() * p.hw() == p.hx() * hw() ) &&(hy() * p.hw() == p.hy() * hw() ) &&(hz() * p.hw() == p.hz() * hw() ) ); } template < class R > inline bool PointH3::operator!=( const PointH3 & p) const { return !(*this == p); } #ifndef CGAL_NO_OSTREAM_INSERT_POINTH3 template < class R > std::ostream &operator<<(std::ostream &os, const PointH3 &p) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << p.hx() << ' ' << p.hy() << ' ' << p.hz() << ' ' << p.hw(); case IO::BINARY : write(os, p.hx()); write(os, p.hy()); write(os, p.hz()); write(os, p.hw()); return os; default: return os << "PointH3(" << p.hx() << ", " << p.hy() << ", " << p.hz() << ", " << p.hw() << ')'; } } #endif // CGAL_NO_OSTREAM_INSERT_POINTH3 #ifndef CGAL_NO_ISTREAM_EXTRACT_POINTH3 template < class R > std::istream &operator>>(std::istream &is, PointH3 &p) { typename R::RT hx, hy, hz, hw; switch(is.iword(IO::mode)) { case IO::ASCII : is >> hx >> hy >> hz >> hw; break; case IO::BINARY : read(is, hx); read(is, hy); read(is, hz); read(is, hw); break; default: std::cerr << "" << std::endl; std::cerr << "Stream must be in ascii or binary mode" << std::endl; break; } p = PointH3(hx, hy, hz, hw); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_POINTH3 template < class R > inline typename R::Point_3 PointH3::transform(const typename PointH3::Aff_transformation_3& t) const { return t.transform(static_cast(*this)); } template < class R > CGAL_KERNEL_LARGE_INLINE Bbox_3 PointH3::bbox() const { Interval_nt<> ihx = CGAL_NTS to_interval(hx()); Interval_nt<> ihy = CGAL_NTS to_interval(hy()); Interval_nt<> ihz = CGAL_NTS to_interval(hz()); Interval_nt<> ihw = CGAL_NTS to_interval(hw()); Interval_nt<> ix = ihx/ihw; Interval_nt<> iy = ihy/ihw; Interval_nt<> iz = ihz/ihw; return Bbox_3(ix.inf(), iy.inf(), iz.inf(), ix.sup(), iy.sup(), iz.sup()); } CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_POINT_3_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/function_objects.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/function_o0000644000175000017500000025653711344301501031421 0ustar debiandebian// Copyright (c) 1999-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/function_objects.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion, Michael Hoffmann #ifndef CGAL_HOMOGENEOUS_FUNCTION_OBJECTS_H #define CGAL_HOMOGENEOUS_FUNCTION_OBJECTS_H #include #include CGAL_BEGIN_NAMESPACE namespace HomogeneousKernelFunctors { using namespace CommonKernelFunctors; // For lazyness... using CartesianKernelFunctors::Are_parallel_2; using CartesianKernelFunctors::Are_parallel_3; using CartesianKernelFunctors::Compute_squared_area_3; using CartesianKernelFunctors::Collinear_3; using CartesianKernelFunctors::Construct_line_3; template class Angle_2 { typedef typename K::Point_2 Point_2; typedef typename K::Construct_vector_2 Construct_vector_2; Construct_vector_2 c; public: typedef Angle result_type; typedef Arity_tag< 3 > Arity; Angle_2() {} Angle_2(const Construct_vector_2& c_) : c(c_) {} Angle operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { return (Angle) CGAL_NTS sign(c(q,p) * c(q,r)); } // FIXME: scalar product }; template class Angle_3 { typedef typename K::Point_3 Point_3; typedef typename K::Construct_vector_3 Construct_vector_3; Construct_vector_3 c; public: typedef Angle result_type; typedef Arity_tag< 3 > Arity; Angle_3() {} Angle_3(const Construct_vector_3& c_) : c(c_) {} Angle operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return (Angle) CGAL_NTS sign(c(q,p) * c(q,r)); } // FIXME: scalar product }; template class Bounded_side_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Sphere_3 Sphere_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef Bounded_side result_type; typedef Arity_tag< 2 > Arity; Bounded_side operator()( const Sphere_3& s, const Point_3& p) const { return s.bounded_side(p); } Bounded_side operator()( const Tetrahedron_3& t, const Point_3& p) const { RT alpha; RT beta ; RT gamma; Vector_3 v1 = t.vertex(1)-t.vertex(0); Vector_3 v2 = t.vertex(2)-t.vertex(0); Vector_3 v3 = t.vertex(3)-t.vertex(0); Vector_3 vp = p - t.vertex(0); // want to solve alpha*v1 + beta*v2 + gamma*v3 == vp // let vi' == vi*vi.hw() // we solve alpha'*v1' + beta'*v2' + gamma'*v3' == vp' / vp.hw() // muliplied by vp.hw() // then we have alpha = alpha'*v1.hw() / vp.hw() // and beta = beta' *v2.hw() / vp.hw() // and gamma = gamma'*v3.hw() / vp.hw() RT v1x = v1.hx(); RT v1y = v1.hy(); RT v1z = v1.hz(); RT v2x = v2.hx(); RT v2y = v2.hy(); RT v2z = v2.hz(); RT v3x = v3.hx(); RT v3y = v3.hy(); RT v3z = v3.hz(); RT vpx = vp.hx(); RT vpy = vp.hy(); RT vpz = vp.hz(); alpha = det3x3_by_formula( vpx, v2x, v3x, vpy, v2y, v3y, vpz, v2z, v3z ); beta = det3x3_by_formula( v1x, vpx, v3x, v1y, vpy, v3y, v1z, vpz, v3z ); gamma = det3x3_by_formula( v1x, v2x, vpx, v1y, v2y, vpy, v1z, v2z, vpz ); RT det= det3x3_by_formula( v1x, v2x, v3x, v1y, v2y, v3y, v1z, v2z, v3z ); CGAL_kernel_assertion( det != 0 ); if (det < 0 ) { alpha = - alpha; beta = - beta ; gamma = - gamma; det = - det ; } bool t1 = ( alpha < 0 ); bool t2 = ( beta < 0 ); bool t3 = ( gamma < 0 ); // t1 || t2 || t3 == not contained in cone RT lhs = alpha*v1.hw() + beta*v2.hw() + gamma*v3.hw(); RT rhs = det * vp.hw(); bool t4 = ( lhs > rhs ); // alpha + beta + gamma > 1 ? bool t5 = ( lhs < rhs ); // alpha + beta + gamma < 1 ? bool t6 = ( (alpha > 0) && (beta > 0) && (gamma > 0) ); if ( t1 || t2 || t3 || t4 ) { return ON_UNBOUNDED_SIDE; } return (t5 && t6) ? ON_BOUNDED_SIDE : ON_BOUNDARY; } Bounded_side operator()( const Iso_cuboid_3& c, const Point_3& p) const { return c.bounded_side(p); } }; template class Collinear_are_ordered_along_line_2 { typedef typename K::RT RT; typedef typename K::Point_2 Point_2; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_2 Collinear_2; Collinear_2 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_ordered_along_line_2() {} Collinear_are_ordered_along_line_2(const Collinear_2& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& rhx = r.hx(); const RT& rhy = r.hy(); const RT& rhw = r.hw(); if ( !(phx * rhw == rhx * phw ) ) // non-vertical ? { return !( ( ( phx * qhw < qhx * phw) &&( rhx * qhw < qhx * rhw)) ||( ( qhx * phw < phx * qhw) &&( qhx * rhw < rhx * qhw)) ); } else if ( !(phy * rhw == rhy * phw ) ) { return !( ( ( phy * qhw < qhy * phw) &&( rhy * qhw < qhy * rhw)) ||( ( qhy * phw < phy * qhw) &&( qhy * rhw < rhy * qhw)) ); } else return (( phx*qhw == qhx*phw) && ( phy*qhw == qhy*phw)); } }; template class Collinear_are_ordered_along_line_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_3 Collinear_3; Collinear_3 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_ordered_along_line_3() {} Collinear_are_ordered_along_line_3(const Collinear_3& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); typedef typename K::RT RT; const RT phx = p.hx(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhw = r.hw(); const RT pqx = phx*qhw; const RT qpx = qhx*phw; const RT prx = phx*rhw; const RT qrx = qhx*rhw; const RT rqx = rhx*qhw; const RT rpx = rhx*phw; if ( prx != rpx ) // px != rx { // (px <= qx)&&(qx <= rx) || (px >= qx)&&(qx >= rx) // !(((qx < px)||(rx < qx))&&((px < qx)||(qx < rx))) return ! ( ((qpx < pqx) || (rqx < qrx)) && ((pqx < qpx) || (qrx < rqx)) ); } const RT phy = p.hy(); const RT qhy = q.hy(); const RT rhy = r.hy(); const RT pqy = phy*qhw; const RT qpy = qhy*phw; const RT pry = phy*rhw; const RT qry = qhy*rhw; const RT rqy = rhy*qhw; const RT rpy = rhy*phw; if ( pry != rpy ) { return ! ( ((qpy < pqy) || (rqy < qry)) && ((pqy < qpy) || (qry < rqy)) ); } const RT phz = p.hz(); const RT qhz = q.hz(); const RT rhz = r.hz(); const RT pqz = phz*qhw; const RT qpz = qhz*phw; const RT prz = phz*rhw; const RT qrz = qhz*rhw; const RT rqz = rhz*qhw; const RT rpz = rhz*phw; if ( prz != rpz ) { return ! ( ((qpz < pqz) || (rqz < qrz)) && ((pqz < qpz) || (qrz < rqz)) ); } // p == r return ((rqx == qrx) && (rqy == qry) && (rqz == qrz)); } }; template class Collinear_are_strictly_ordered_along_line_2 { typedef typename K::Point_2 Point_2; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_2 Collinear_2; Collinear_2 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_strictly_ordered_along_line_2() {} Collinear_are_strictly_ordered_along_line_2(const Collinear_2& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& rhx = r.hx(); const RT& rhy = r.hy(); const RT& rhw = r.hw(); if ( !(phx * rhw == rhx * phw ) ) { return ( ( phx * qhw < qhx * phw) &&( qhx * rhw < rhx * qhw)) ||( ( qhx * phw < phx * qhw) // ( phx * qhw > qhx * phw) &&( rhx * qhw < qhx * rhw)); // ( qhx * rhw > rhx * qhw) } else { return ( ( phy * qhw < qhy * phw) &&( qhy * rhw < rhy * qhw)) ||( ( qhy * phw < phy * qhw) // ( phy * qhw > qhy * phw) &&( rhy * qhw < qhy * rhw)); // ( qhy * rhw > rhy * qhw) } } }; template class Collinear_are_strictly_ordered_along_line_3 { typedef typename K::Point_3 Point_3; typedef typename K::Direction_3 Direction_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Collinear_3 Collinear_3; Collinear_3 c; #endif // CGAL_kernel_exactness_preconditions public: typedef bool result_type; typedef Arity_tag< 3 > Arity; #ifdef CGAL_kernel_exactness_preconditions Collinear_are_strictly_ordered_along_line_3() {} Collinear_are_strictly_ordered_along_line_3(const Collinear_3& c_) : c(c_) {} #endif // CGAL_kernel_exactness_preconditions bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { CGAL_kernel_exactness_precondition( c(p, q, r) ); if ( p == r) return false; Direction_3 dir_pq = (p - q).direction(); Direction_3 dir_rq = (r - q).direction(); return (dir_pq == -dir_rq); } // FIXME }; template class Collinear_has_on_2 { typedef typename K::Point_2 Point_2; typedef typename K::Direction_2 Direction_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Construct_point_on_2 Construct_point_on_2; typedef typename K::Compare_xy_2 Compare_xy_2; typedef typename K::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; Collinear_are_ordered_along_line_2 co; Construct_point_on_2 cp; Compare_xy_2 cxy; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Collinear_has_on_2() {} Collinear_has_on_2(const Construct_point_on_2& cp_, const Compare_xy_2& cxy_) : cp(cp_), cxy(cxy_) {} bool operator()( const Ray_2& r, const Point_2& p) const { const Point_2 & source = cp(r,0); return p == source || Direction_2(p - source) == r.direction(); } // FIXME bool operator()( const Segment_2& s, const Point_2& p) const { return co(cp(s,0), p, cp(s,1)); } }; template class Collinear_2 { typedef typename K::Point_2 Point_2; typedef typename K::Orientation_2 Orientation_2; Orientation_2 o; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; Collinear_2() {} Collinear_2(const Orientation_2 o_) : o(o_) {} bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& rhx = r.hx(); const RT& rhy = r.hy(); const RT& rhw = r.hw(); const RT RT0 = RT(0); // | A B | // | C D | RT A = phx*rhw - phw*rhx; RT B = phy*rhw - phw*rhy; RT C = qhx*rhw - qhw*rhx; RT D = qhy*rhw - qhw*rhy; RT det = A*D - B*C; /* RT det_old = p.hx() * (q.hy()*r.hw() - q.hw()*r.hy() ) + p.hy() * (q.hw()*r.hx() - q.hx()*r.hw() ) + p.hw() * (q.hx()*r.hy() - q.hy()*r.hx() ); if ( !(CGAL_NTS sign(det) == CGAL_NTS sign(det_old)) ) { std::cerr << "det: " << det << " det_old: " << det_old << flush; } */ return ( det == RT0 ); } }; template class Compare_angle_with_x_axis_2 { typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Direction_2 Direction_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()(const Direction_2& d1, const Direction_2& d2) const { typedef typename K::RT RT; CGAL_kernel_precondition( static_cast(COUNTERCLOCKWISE) == static_cast(LARGER) && static_cast(COLLINEAR) == static_cast(EQUAL) && static_cast(CLOCKWISE) == static_cast(SMALLER) ); const RT RT0(0); Vector_2 dirvec1(d1.x(), d1.y()); // Added Point_2 p1 = CGAL::ORIGIN + dirvec1; // Added Vector_2 dirvec2(d2.x(), d2.y()); // Added Point_2 p2 = ORIGIN + dirvec2; // Added // Point_2 p1 = ORIGIN + d1.vector(); // Commented out // Point_2 p2 = ORIGIN + d2.vector(); // Commented out CGAL_kernel_precondition( RT0 < p1.hw() ); CGAL_kernel_precondition( RT0 < p2.hw() ); int x_sign1 = static_cast(CGAL_NTS sign( p1.hx() )); int x_sign2 = static_cast(CGAL_NTS sign( p2.hx() )); int y_sign1 = static_cast(CGAL_NTS sign( p1.hy() )); int y_sign2 = static_cast(CGAL_NTS sign( p2.hy() )); if ( y_sign1 * y_sign2 < 0) { return (0 < y_sign1 ) ? SMALLER : LARGER; } Point_2 origin( RT0 , RT0 ); if ( 0 < y_sign1 * y_sign2 ) { return static_cast(static_cast( orientation(origin, p2, p1))); // Precondition on the enums: // COUNTERCLOCKWISE == LARGER ( == 1 ) // COLLINEAR == EQUAL ( == 0 ) // CLOCKWISE == SMALLER ( == -1 ) } // ( y_sign1 * y_sign2 == 0 ) bool b1 = (y_sign1 == 0) && (x_sign1 >= 0); bool b2 = (y_sign2 == 0) && (x_sign2 >= 0); if ( b1 ) { return b2 ? EQUAL : SMALLER; } if ( b2 ) { return b1 ? EQUAL : LARGER; } if ( y_sign1 == y_sign2 ) // == 0 { return EQUAL; } else { return (orientation(origin, p1, p2) == COUNTERCLOCKWISE) ? static_cast(SMALLER) : static_cast(LARGER); } } }; template class Compare_distance_2 { typedef typename K::Point_2 Point_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typedef typename K::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances // phx * phx * qhw * qhw * rhw * rhw // -RT(2) * phx * qhx * phw * qhw * rhw * rhw // + qhx * qhx * phw * phw * rhw * rhw // // + phy * phy * qhw * qhw * rhw * rhw // -RT(2) * phy * qhy * phw * qhw * rhw * rhw // + qhy * qhy * phw * phw * rhw * rhw // // - ( phx * phx * qhw * qhw * rhw * rhw // -RT(2) * phx * rhx * phw * qhw * qhw * rhw // + rhx * rhx * phw * phw * qhw * qhw // // + phy * phy * qhw * qhw * rhw * rhw // -RT(2) * phy * rhy * phw * qhw * qhw * rhw // + rhy * rhy * phw * phw * qhw * qhw rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy ) - RT2 * qhw * ( phx*qhx + phy*qhy ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy ) - RT2 * rhw * ( phx*rhx + phy*rhy ) ); if ( RT0 < dosd ) { return LARGER; } else { return (dosd < RT0) ? SMALLER : EQUAL; } } }; template class Compare_distance_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { typedef typename K::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhz = r.hz(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy + qhz*qhz ) - RT2 * qhw * ( phx*qhx + phy*qhy + phz*qhz ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy + rhz*rhz ) - RT2 * rhw * ( phx*rhx + phy*rhy + phz*rhz ) ); if ( RT0 < dosd ) { return LARGER; } else { return (dosd < RT0) ? SMALLER : EQUAL; } } }; template class Compare_slope_2 { typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()(const Line_2& l1, const Line_2& l2) const { typedef typename K::RT RT; if (l1.is_horizontal()) return l2.is_vertical() ? SMALLER : Comparison_result(CGAL_NTS sign(l2.a() * l2.b())); if (l2.is_horizontal()) return l1.is_vertical() ? LARGER : Comparison_result(- CGAL_NTS sign(l1.a() * l1.b())); if (l1.is_vertical()) return l2.is_vertical() ? EQUAL : LARGER; if (l2.is_vertical()) return SMALLER; int l1_sign = CGAL_NTS sign(-l1.a() * l1.b()); int l2_sign = CGAL_NTS sign(-l2.a() * l2.b()); if (l1_sign < l2_sign) return SMALLER; if (l1_sign > l2_sign) return LARGER; if (l1_sign > 0) return CGAL_NTS compare( CGAL_NTS abs(l1.a() * l2.b()), CGAL_NTS abs(l2.a() * l1.b()) ); return CGAL_NTS compare( CGAL_NTS abs(l2.a() * l1.b()), CGAL_NTS abs(l1.a() * l2.b()) ); } // FIXME Comparison_result operator()(const Segment_2& s1, const Segment_2& s2) const { typedef typename K::FT FT; Comparison_result cmp_y1 = compare_y(s1.source(), s1.target()); if (cmp_y1 == EQUAL) // horizontal { Comparison_result cmp_x2 = compare_x(s2.source(), s2.target()); if (cmp_x2 == EQUAL) return SMALLER; FT s_hw = s2.source().hw(); FT t_hw = s2.target().hw(); return Comparison_result ( - CGAL_NTS sign((s2.source().hy()*t_hw - s2.target().hy()*s_hw) * (s2.source().hx()*t_hw - s2.target().hx()*s_hw)) ); } Comparison_result cmp_y2 = compare_y(s2.source(), s2.target()); if (cmp_y2 == EQUAL) { Comparison_result cmp_x1 = compare_x(s1.source(), s1.target()); if (cmp_x1 == EQUAL) return LARGER; FT s_hw = s1.source().hw(); FT t_hw = s1.target().hw(); return Comparison_result ( CGAL_NTS sign((s1.source().hy()*t_hw - s1.target().hy()*s_hw) * (s1.source().hx()*t_hw - s1.target().hx()*s_hw)) ); } Comparison_result cmp_x1 = compare_x(s1.source(), s1.target()); Comparison_result cmp_x2 = compare_x(s2.source(), s2.target()); if (cmp_x1 == EQUAL) return cmp_x2 == EQUAL ? EQUAL : LARGER; if (cmp_x2 == EQUAL) return SMALLER; FT s1_s_hw = s1.source().hw(); FT s1_t_hw = s1.target().hw(); FT s2_s_hw = s2.source().hw(); FT s2_t_hw = s2.target().hw(); FT s1_xdiff = s1.source().hx()*s1_t_hw - s1.target().hx()*s1_s_hw; FT s1_ydiff = s1.source().hy()*s1_t_hw - s1.target().hy()*s1_s_hw; FT s2_xdiff = s2.source().hx()*s2_t_hw - s2.target().hx()*s2_s_hw; FT s2_ydiff = s2.source().hy()*s2_t_hw - s2.target().hy()*s2_s_hw; Sign s1_sign = CGAL_NTS sign(s1_ydiff * s1_xdiff); Sign s2_sign = CGAL_NTS sign(s2_ydiff * s2_xdiff); if (s1_sign < s2_sign) return SMALLER; if (s1_sign > s2_sign) return LARGER; if (s1_sign > 0) return Comparison_result( CGAL_NTS sign ( CGAL_NTS abs(s1_ydiff * s2_xdiff) - CGAL_NTS abs(s2_ydiff * s1_xdiff)) ); return Comparison_result( CGAL_NTS sign ( CGAL_NTS abs(s2_ydiff * s1_xdiff) - CGAL_NTS abs(s1_ydiff * s2_xdiff)) ); } }; template class Compare_x_at_y_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()( const Point_2& p, const Line_2& h) const { typedef typename K::RT RT; CGAL_kernel_precondition( ! h.is_horizontal() ); Oriented_side ors = h.oriented_side( p ); if ( h.a() < RT(0) ) ors = opposite( ors ); if ( ors == ON_POSITIVE_SIDE ) return LARGER; return ( ors == ON_NEGATIVE_SIDE ) ? SMALLER : EQUAL; } // FIXME Comparison_result operator()( const Point_2& p, const Line_2& h1, const Line_2& h2) const { return CGAL_NTS compare(h1.x_at_y( p.y() ), h2.x_at_y( p.y() )); } // FIXME Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h) const { return compare_x_at_y( gp_linear_intersection( l1, l2 ), h); } // FIXME Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { return compare_x_at_y( gp_linear_intersection( l1, l2 ), h1, h2 ); } // FIXME }; template class Compare_xyz_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { typedef typename K::RT RT; RT pV = p.hx()*q.hw(); RT qV = q.hx()*p.hw(); if ( pV < qV ) { return SMALLER; } if ( qV < pV ) // ( pV > qV ) { return LARGER; } // same x pV = p.hy()*q.hw(); qV = q.hy()*p.hw(); if ( pV < qV ) { return SMALLER; } if ( qV < pV ) // ( pV > qV ) { return LARGER; } // same x and y pV = p.hz()*q.hw(); qV = q.hz()*p.hw(); if ( pV < qV ) { return SMALLER; } else { return (qV < pV) ? LARGER : EQUAL; } } }; template class Compare_xy_2 { typedef typename K::Point_2 Point_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2& p, const Point_2& q) const { typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); RT pV = phx*qhw; RT qV = qhx*phw; if ( pV == qV ) { pV = phy*qhw; qV = qhy*phw; } if ( pV < qV ) { return SMALLER; } else { return (qV < pV) ? LARGER : EQUAL; } } }; template class Compare_xy_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { typedef typename K::RT RT; RT pV = p.hx()*q.hw(); RT qV = q.hx()*p.hw(); if ( pV < qV ) { return SMALLER; } if ( qV < pV ) // ( pV > qV ) { return LARGER; } // same x pV = p.hy()*q.hw(); qV = q.hy()*p.hw(); if ( pV < qV ) { return SMALLER; } if ( qV < pV ) // ( pV > qV ) { return LARGER; } // same x and y return EQUAL; } }; template class Compare_x_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2& p, const Point_2& q) const { return CGAL_NTS compare(p.hx()*q.hw(), q.hx()*p.hw()); } Comparison_result operator()( const Point_2& p, const Line_2& l1, const Line_2& l2) const { Point_2 ip = gp_linear_intersection( l1, l2 ); return this->operator()(p, ip); } // FIXME Comparison_result operator()( const Line_2& l, const Line_2& h1, const Line_2& h2) const { return this->operator()(l, h1, l, h2); } // FIXME Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { Point_2 lip = gp_linear_intersection( l1, l2 ); Point_2 hip = gp_linear_intersection( h1, h2 ); return this->operator()(lip, hip); } // FIXME }; template class Compare_x_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return CGAL_NTS compare(p.hx() * q.hw(), q.hx() * p.hw() ); } }; template class Compare_y_at_x_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; typedef typename K::Segment_2 Segment_2; public: typedef Comparison_result result_type; typedef Arity_tag< 3 > Arity; Comparison_result operator()( const Point_2& p, const Line_2& h) const { typedef typename K::RT RT; CGAL_kernel_precondition( ! h.is_vertical() ); Oriented_side ors = h.oriented_side( p ); if ( h.b() < RT(0) ) { ors = opposite( ors ); } if ( ors == ON_POSITIVE_SIDE ) { return LARGER; } return ( ors == ON_NEGATIVE_SIDE ) ? SMALLER : EQUAL; } // FIXME Comparison_result operator()( const Point_2& p, const Line_2& h1, const Line_2& h2) const { return CGAL_NTS compare(h1.y_at_x( p.x() ), h2.y_at_x( p.x() )); } // FIXME Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h) const { return compare_y_at_x( gp_linear_intersection( l1, l2 ), h); } // FIXME Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { return compare_y_at_x( gp_linear_intersection( l1, l2 ), h1, h2 ); } // FIXME Comparison_result operator()( const Point_2& p, const Segment_2& s) const { // compares the y-coordinates of p and the vertical projection of p on s. // Precondition : p is in the x-range of s. if (compare_x(s.source(), s.target()) == SMALLER) { CGAL_kernel_precondition(compare_x(s.source(), p) != LARGER && compare_x(p, s.target()) != LARGER); return (Comparison_result) orientation(p, s.source(), s.target()); } else if (compare_x(s.source(), s.target()) == LARGER) { CGAL_kernel_precondition(compare_x(s.target(), p) != LARGER && compare_x(p, s.source()) != LARGER); return (Comparison_result) orientation(p, s.target(), s.source()); } else { CGAL_kernel_precondition(compare_x(s.target(), p) == EQUAL); if (compare_y(p, s.source()) == SMALLER && compare_y(p, s.target()) == SMALLER) return SMALLER; if (compare_y(p, s.source()) == LARGER && compare_y(p, s.target()) == LARGER) return LARGER; return EQUAL; } } // FIXME Comparison_result operator()( const Point_2& p, const Segment_2& s1, const Segment_2& s2) const { // compares the y-coordinates of the vertical projections // of p on s1 and s2 // Precondition : p is in the x-range of s1 and s2. // - if one or two segments are vertical : // - if the segments intersect, return EQUAL // - if not, return the obvious SMALLER/LARGER. typedef typename K::FT FT; FT px = p.x(); FT s1sx = s1.source().x(); FT s1sy = s1.source().y(); FT s1tx = s1.target().x(); FT s1ty = s1.target().y(); FT s2sx = s2.source().x(); FT s2sy = s2.source().y(); FT s2tx = s2.target().x(); FT s2ty = s2.target().y(); CGAL_kernel_precondition(px >= CGAL_NTS min(s1sx, s1tx) && px <= CGAL_NTS max(s1sx, s1tx)); CGAL_kernel_precondition(px >= CGAL_NTS min(s2sx, s2tx) && px <= CGAL_NTS max(s2sx, s2tx)); if (s1sx != s1tx && s2sx != s2tx) { FT s1stx = s1sx-s1tx; FT s2stx = s2sx-s2tx; return Comparison_result( CGAL_NTS compare(s1sx, s1tx) * CGAL_NTS compare(s2sx, s2tx) * CGAL_NTS compare(-(s1sx-px)*(s1sy-s1ty)*s2stx, (s2sy-s1sy)*s2stx*s1stx -(s2sx-px)*(s2sy-s2ty)*s1stx )); } else { if (s1sx == s1tx) { // s1 is vertical Comparison_result c1, c2; c1 = compare_y_at_x(s1.source(), s2); c2 = compare_y_at_x(s1.target(), s2); if (c1 == c2) return c1; return EQUAL; } // s2 is vertical Comparison_result c3, c4; c3 = compare_y_at_x(s2.source(), s1); c4 = compare_y_at_x(s2.target(), s1); if (c3 == c4) return opposite(c3); return EQUAL; } } // FIXME }; template class Compare_y_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_2& p, const Point_2& q) const { typedef typename K::RT RT; const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT RT0 = RT(0); RT com = phy * qhw - qhy * phw; if ( com < RT0 ) return SMALLER; else if ( RT0 < com ) return LARGER; return EQUAL; } Comparison_result operator()( const Point_2& p, const Line_2& l1, const Line_2& l2) const { Point_2 ip = gp_linear_intersection( l1, l2 ); return compare_y( p, ip ); } // FIXME Comparison_result operator()( const Line_2& l, const Line_2& h1, const Line_2& h2) const { return this->operator()(l, h1, l, h2); } Comparison_result operator()( const Line_2& l1, const Line_2& l2, const Line_2& h1, const Line_2& h2) const { Point_2 lip = gp_linear_intersection( l1, l2 ); Point_2 hip = gp_linear_intersection( h1, h2 ); return this->operator()( lip, hip ); } // FIXME }; template class Compare_y_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return CGAL_NTS compare(p.hy() * q.hw(), q.hy() * p.hw() ); } }; template class Compare_z_3 { typedef typename K::Point_3 Point_3; public: typedef Comparison_result result_type; typedef Arity_tag< 2 > Arity; Comparison_result operator()( const Point_3& p, const Point_3& q) const { return CGAL_NTS compare(p.hz() * q.hw(), q.hz() * p.hw() ); } }; template class Compute_area_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Iso_rectangle_2 Iso_rectangle_2; typedef typename K::Triangle_2 Triangle_2; typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Construct_vector_2 Construct_vector_2; Construct_vector_2 co; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Point_2& p, const Point_2& q, const Point_2& r ) const { Vector_2 v1 = co(p, q); Vector_2 v2 = co(p, r); RT num = v1.hx()*v2.hy() - v2.hx()*v1.hy(); RT den = RT(2) * v1.hw() * v2.hw(); return FT(num)/FT(den); } FT operator()( const Iso_rectangle_2& r ) const { return r.area(); } FT operator()( const Triangle_2& t ) const { return t.area(); } }; template class Compute_scalar_product_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()(const Vector_2& v, const Vector_2& w) const { return FT( RT(v.hx()*w.hx() + v.hy()*w.hy()) ) / FT( RT(v.hw()*w.hw() ) ); } }; template class Compute_scalar_product_3 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Vector_3 Vector_3; public: typedef FT result_type; typedef Arity_tag< 2 > Arity; FT operator()(const Vector_3& v, const Vector_3& w) const { return FT( RT(v.hx()*w.hx() + v.hy()*w.hy()) + v.hz()*w.hz() ) / FT( RT(v.hw()*w.hw() ) ); } }; // TODO ... template class Compute_squared_radius_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Circle_2 Circle_2; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Circle_2& c) const { return c.squared_radius(); } FT operator()( const Point_2& p, const Point_2& q) const { typedef typename K::FT FT; return squared_distance(p, q)/FT(4); } // FIXME FT operator()( const Point_2& p, const Point_2& q, const Point_2& r) const { return squared_distance(p, circumcenter(p, q, r)); } // FIXME }; template class Compute_squared_radius_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Sphere_3 Sphere_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()( const Sphere_3& s) const { return s.squared_radius(); } FT operator()( const Point_3& p, const Point_3& q) const { typedef typename K::FT FT; return squared_distance(p, q) / FT(4); } // FIXME FT operator()( const Point_3& p, const Point_3& q, const Point_3& r) const { return squared_distance(p, circumcenter(p, q, r)); } // FIXME FT operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { return squared_distance(p, circumcenter(p, q, r, s)); } // FIXME }; template class Compute_volume_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Iso_cuboid_3 Iso_cuboid_3; public: typedef FT result_type; typedef Arity_tag< 1 > Arity; FT operator()(const Point_3& p0, const Point_3& p1, const Point_3& p2, const Point_3& p3) const { Vector_3 vec1 = p1 - p0; Vector_3 vec2 = p2 - p0; Vector_3 vec3 = p3 - p0; // first compute (vec1.hw * vec2.hw * vec3.hw * det(vec1, vec2, vec3)) // then divide by (6 * vec1.hw * vec2.hw * vec3.hw) const FT w123 = vec1.hw() * vec2.hw() * vec3.hw(); const FT& hx1 = vec1.hx(); const FT& hy1 = vec1.hy(); const FT& hz1 = vec1.hz(); const FT& hx2 = vec2.hx(); const FT& hy2 = vec2.hy(); const FT& hz2 = vec2.hz(); const FT& hx3 = vec3.hx(); const FT& hy3 = vec3.hy(); const FT& hz3 = vec3.hz(); return ( (hx1 * (hy2 * hz3 - hy3 * hz2)) - (hy1 * (hx2 * hz3 - hx3 * hz2)) + (hz1 * (hx2 * hy3 - hx3 * hy2)))/ (6 * w123); } FT operator()( const Tetrahedron_3& t ) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2), t.vertex(3)); } FT operator()( const Iso_cuboid_3& c ) const { return c.volume(); } }; template class Construct_base_vector_3 { typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; typedef typename K::RT RT; typedef typename K::Construct_orthogonal_vector_3 Construct_orthogonal_vector_3; Construct_orthogonal_vector_3 co; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Construct_base_vector_3() {} Construct_base_vector_3(const Construct_orthogonal_vector_3& co_) : co(co_) {} Vector_3 operator()( const Plane_3& h, int index ) const { if (index == 1) { // point(): // a() != RT0 : Point_3( -d(), RT0, RT0, a() ); // b() != RT0 : Point_3( RT0, -d(), RT0, b() ); // : Point_3( RT0, RT0, -d(), c() ); // point1(): // a() != RT0 : Point_3( -b()-d(), a(), RT0, a() ); // b() != RT0 : Point_3( RT0, -c()-d(), b(), b() ); // : Point_3( c(), RT0, -a()-d(), c() ); const RT RT0(0); if ( h.a() != RT0 ) { return Vector_3( -h.b(), h.a(), RT0, h.a() ); } if ( h.b() != RT0 ) { return Vector_3( RT0, -h.c(), h.b(), h.b() ); } CGAL_kernel_assertion ( h.c() != RT(0) ); return Vector_3( h.c(), RT0, -h.a(), h.c() ); } else { Vector_3 a = co(h); Vector_3 b = this->operator()(h, 1); return Vector_3(a.hy()*b.hz() - a.hz()*b.hy(), a.hz()*b.hx() - a.hx()*b.hz(), a.hx()*b.hy() - a.hy()*b.hx(), a.hw()*b.hw() ); } } }; template class Construct_bisector_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Line_2 operator()(const Point_2& p, const Point_2& q) const { // Bisector equation is based on equation // ( X - p.x())^2 + (Y - p.y())^2 == ( X - q.x())^2 + (Y - q.y()) // and x() = hx()/hw() ... const RT &phx = p.hx(); const RT &phy = p.hy(); const RT &phw = p.hw(); const RT &qhx = q.hx(); const RT &qhy = q.hy(); const RT &qhw = q.hw(); RT a = RT(2) * ( phx*phw*qhw*qhw - qhx*qhw*phw*phw ); RT b = RT(2) * ( phy*phw*qhw*qhw - qhy*qhw*phw*phw ); RT c = qhx*qhx*phw*phw + qhy*qhy*phw*phw - phx*phx*qhw*qhw - phy*phy*qhw*qhw; return Line_2( a, b, c ); } Line_2 operator()(const Line_2& p, const Line_2& q) const { RT a, b, c; bisector_of_linesC2(p.a(), p.b(), p.c(), q.a(), q.b(), q.c(), a, b, c); return Line_2(a, b, c); } }; template class Construct_bisector_3 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Plane_3 result_type; typedef Arity_tag< 2 > Arity; Plane_3 operator()(const Point_3& p, const Point_3& q) const { // Bisector equation is based on equation // ( X - p.x())^2 + (Y - p.y())^2 == ( X - q.x())^2 + (Y - q.y()) // and x() = hx()/hw() ... const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phz = p.hz(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhz = q.hz(); const RT& qhw = q.hw(); RT a = RT(2) * ( phx*phw*qhw*qhw - qhx*qhw*phw*phw ); RT b = RT(2) * ( phy*phw*qhw*qhw - qhy*qhw*phw*phw ); RT c = RT(2) * ( phz*phw*qhw*qhw - qhz*qhw*phw*phw ); RT d = qhx*qhx*phw*phw + qhy*qhy*phw*phw + qhz*qhz*phw*phw - phx*phx*qhw*qhw - phy*phy*qhw*qhw - phz*phz*qhw*qhw; return Plane_3( a, b, c, d ); } Plane_3 operator()(const Plane_3& p, const Plane_3& q) const { RT a, b, c, d; bisector_of_planesC3(p.a(), p.b(), p.c(), p.d(), q.a(), q.b(), q.c(), q.d(), a, b, c, d); return Plane_3(a, b, c, d); } }; template class Construct_centroid_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 3 > Arity; Point_2 operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typedef typename K::RT RT; const RT phw(p.hw()); const RT qhw(q.hw()); const RT rhw(r.hw()); RT hx(p.hx()*qhw*rhw + q.hx()*phw*rhw + r.hx()*phw*qhw); RT hy(p.hy()*qhw*rhw + q.hy()*phw*rhw + r.hy()*phw*qhw); RT hw( phw*qhw*rhw * 3); return Point_2(hx, hy, hw); } Point_2 operator()(const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& s) const { typedef typename K::RT RT; const RT phw(p.hw()); const RT qhw(q.hw()); const RT rhw(r.hw()); const RT shw(s.hw()); RT hx(p.hx()*qhw*rhw*shw + q.hx()*phw*rhw*shw + r.hx()*phw*qhw*shw + s.hx()*phw*qhw*rhw); RT hy(p.hy()*qhw*rhw*shw + q.hy()*phw*rhw*shw + r.hy()*phw*qhw*shw + s.hy()*phw*qhw*rhw); RT hw( phw*qhw*rhw*shw * 4); return Point_2(hx, hy, hw); } }; template class Construct_centroid_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 3 > Arity; Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { const RT& phw = p.hw(); const RT& qhw = q.hw(); const RT& rhw = r.hw(); RT hx(p.hx()*qhw*rhw + q.hx()*phw*rhw + r.hx()*phw*qhw); RT hy(p.hy()*qhw*rhw + q.hy()*phw*rhw + r.hy()*phw*qhw); RT hz(p.hz()*qhw*rhw + q.hz()*phw*rhw + r.hz()*phw*qhw); RT hw( phw*qhw*rhw * RT(3)); return Point_3(hx, hy, hz, hw); } Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { const RT& phw = p.hw(); const RT& qhw = q.hw(); const RT& rhw = r.hw(); const RT& shw = s.hw(); RT hx(p.hx()*qhw*rhw*shw + q.hx()*phw*rhw*shw + r.hx()*phw*qhw*shw + s.hx()*phw*qhw*rhw); RT hy(p.hy()*qhw*rhw*shw + q.hy()*phw*rhw*shw + r.hy()*phw*qhw*shw + s.hy()*phw*qhw*rhw); RT hz(p.hz()*qhw*rhw*shw + q.hz()*phw*rhw*shw + r.hz()*phw*qhw*shw + s.hz()*phw*qhw*rhw); RT hw( phw*qhw*rhw*shw * RT(4)); return Point_3(hx, hy, hz, hw); } }; template class Construct_circumcenter_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Triangle_2 Triangle_2; public: typedef Point_2 result_type; typedef Arity_tag< 3 > Arity; Point_2 operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typedef typename K::RT RT; RT phx = p.hx(); RT phy = p.hy(); RT phw = p.hw(); RT qhx = q.hx(); RT qhy = q.hy(); RT qhw = q.hw(); RT rhx = r.hx(); RT rhy = r.hy(); RT rhw = r.hw(); #ifdef CGAL_EXPANDED_CIRCUMCENTER_COMPUTATION RT vvx = ( qhy*qhw*phw*phw - phy*phw*qhw*qhw ) *( phx*phx*rhw*rhw + phy*phy*rhw*rhw - rhx*rhx*phw*phw - rhy*rhy*phw*phw ) - ( rhy*rhw*phw*phw - phy*phw*rhw*rhw ) *( phx*phx*qhw*qhw + phy*phy*qhw*qhw - qhx*qhx*phw*phw - qhy*qhy*phw*phw ); RT vvy = - ( qhx*qhw*phw*phw - phx*phw*qhw*qhw ) *( phx*phx*rhw*rhw + phy*phy*rhw*rhw - rhx*rhx*phw*phw - rhy*rhy*phw*phw ) + ( rhx*rhw*phw*phw - phx*phw*rhw*rhw ) *( phx*phx*qhw*qhw + phy*phy*qhw*qhw - qhx*qhx*phw*phw - qhy*qhy*phw*phw ); RT vvw = RT(2) * ( ( qhx*qhw*phw*phw - phx*phw*qhw*qhw ) *( rhy*rhw*phw*phw - phy*phw*rhw*rhw ) - ( rhx*rhw*phw*phw - phx*phw*rhw*rhw ) *( qhy*qhw*phw*phw - phy*phw*qhw*qhw ) ); #endif // CGAL_EXPANDED_CIRCUMCENTER_COMPUTATION RT qy_py = ( qhy*qhw*phw*phw - phy*phw*qhw*qhw ); RT qx_px = ( qhx*qhw*phw*phw - phx*phw*qhw*qhw ); RT rx_px = ( rhx*rhw*phw*phw - phx*phw*rhw*rhw ); RT ry_py = ( rhy*rhw*phw*phw - phy*phw*rhw*rhw ); RT px2_py2_rx2_ry_2 = phx*phx*rhw*rhw + phy*phy*rhw*rhw - rhx*rhx*phw*phw - rhy*rhy*phw*phw ; RT px2_py2_qx2_qy_2 = phx*phx*qhw*qhw + phy*phy*qhw*qhw - qhx*qhx*phw*phw - qhy*qhy*phw*phw ; RT vvx = qy_py * px2_py2_rx2_ry_2 - ry_py * px2_py2_qx2_qy_2; RT vvy = rx_px * px2_py2_qx2_qy_2 - qx_px * px2_py2_rx2_ry_2; RT vvw = RT(2) * ( qx_px * ry_py - rx_px * qy_py ); return Point_2( vvx, vvy, vvw ); } Point_2 operator()(const Triangle_2& t) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2)); } }; template class Construct_circumcenter_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_3 result_type; typedef Arity_tag< 4 > Arity; Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { return gp_linear_intersection( Plane_3(p,q,r), bisector(p,q), bisector(p,r)); } // FIXME Point_3 operator()(const Triangle_3& t) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2)); } Point_3 operator()(const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { typedef typename K::RT RT; RT phw( p.hw() ); RT qhw( q.hw() ); RT rhw( r.hw() ); RT shw( s.hw() ); RT phx( p.hx() ); RT phy( p.hy() ); RT phz( p.hz() ); RT qhx( q.hx() ); RT qhy( q.hy() ); RT qhz( q.hz() ); RT rhx( r.hx() ); RT rhy( r.hy() ); RT rhz( r.hz() ); RT shx( s.hx() ); RT shy( s.hy() ); RT shz( s.hz() ); RT pssq( phx*phx + phy*phy + phz*phz ); RT qssq( qhx*qhx + qhy*qhy + qhz*qhz ); RT rssq( rhx*rhx + rhy*rhy + rhz*rhz ); RT sssq( shx*shx + shy*shy + shz*shz ); phx *= phw; phy *= phw; phz *= phw; phw *= phw; qhx *= qhw; qhy *= qhw; qhz *= qhw; qhw *= qhw; rhx *= rhw; rhy *= rhw; rhz *= rhw; rhw *= rhw; shx *= shw; shy *= shw; shz *= shw; shw *= shw; RT chx = det4x4_by_formula(phy, phz, pssq, phw, qhy, qhz, qssq, qhw, rhy, rhz, rssq, rhw, shy, shz, sssq, shw ); RT chy = det4x4_by_formula(phx, phz, pssq, phw, qhx, qhz, qssq, qhw, rhx, rhz, rssq, rhw, shx, shz, sssq, shw ); RT chz = det4x4_by_formula(phx, phy, pssq, phw, qhx, qhy, qssq, qhw, rhx, rhy, rssq, rhw, shx, shy, sssq, shw ); RT chw = det4x4_by_formula(phx, phy, phz, phw, qhx, qhy, qhz, qhw, rhx, rhy, rhz, rhw, shx, shy, shz, shw ); return Point_3( chx, -chy, chz, RT(2)*chw); } Point_3 operator()(const Tetrahedron_3& t) const { return this->operator()(t.vertex(0), t.vertex(1), t.vertex(2), t.vertex(3)); } }; template class Construct_cross_product_vector_3 { typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()(const Vector_3& a, const Vector_3& b) const { return Vector_3(a.hy()*b.hz() - a.hz()*b.hy(), a.hz()*b.hx() - a.hx()*b.hz(), a.hx()*b.hy() - a.hy()*b.hx(), a.hw()*b.hw() ); } }; template class Construct_lifted_point_3 { typedef typename K::RT RT; typedef typename K::Point_2 Point_2; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()(const Plane_3& h, const Point_2& p) const { Point_3 hp( p.hx(), p.hy(), RT(0.0), p.hw()); return hp.transform( h.transform_to_2d().inverse() ); } }; template class Construct_line_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Direction_2 Direction_2; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Line_2 Line_2; typedef typename K::Construct_point_on_2 Construct_point_on_2; Construct_point_on_2 cp; public: typedef Line_2 result_type; typedef Arity_tag< 2 > Arity; Construct_line_2() {} Construct_line_2(const Construct_point_on_2& cp_) : cp(cp_) {} Line_2 operator()() const { return Line_2(); } // #ifndef CGAL_NO_DEPRECATED_CODE Line_2 operator()(const RT& a, const RT& b, const RT& c) const { return Line_2(a, b, c); } // #endif // CGAL_NO_DEPRECATED_CODE Line_2 operator()(const Point_2& p, const Point_2& q) const { return Line_2( // a() * X + b() * Y + c() * W() == 0 // | X Y W | // | p.hx() p.hy() p.hw() | // | q.hx() q.hy() q.hw() | p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx() ); } Line_2 operator()(const Point_2& p, const Vector_2& v) const { Point_2 q = p + v; return Line_2( p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx() ); } Line_2 operator()(const Point_2& p, const Direction_2& d) const { Point_2 q = p + d.to_vector(); return Line_2( p.hy()*q.hw() - p.hw()*q.hy(), p.hw()*q.hx() - p.hx()*q.hw(), p.hx()*q.hy() - p.hy()*q.hx() ); } Line_2 operator()(const Segment_2& s) const { return this->operator()(cp(s, 0), cp(s, 1)); } Line_2 operator()(const Ray_2& r) const { return this->operator()(cp(r, 0), cp(r, 1)); } }; template class Construct_midpoint_2 { typedef typename K::FT FT; typedef typename K::Point_2 Point_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()(const Point_2& p, const Point_2& q) const { typedef typename K::RT RT; const RT& phw = p.hw(); const RT& qhw = q.hw(); return Point_2( p.hx()*qhw + q.hx()*phw, p.hy()*qhw + q.hy()*phw, phw * qhw * RT( 2)); } }; template class Construct_midpoint_3 { typedef typename K::FT FT; typedef typename K::Point_3 Point_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()(const Point_3& p, const Point_3& q) const { typedef typename K::RT RT; RT phw = p.hw(); RT qhw = q.hw(); return Point_3( p.hx()*qhw + q.hx()*phw, p.hy()*qhw + q.hy()*phw, p.hz()*qhw + q.hz()*phw, RT(2) * phw * qhw ); } }; // TODO ... template class Construct_opposite_vector_2 { typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 1 > Arity; Vector_2 operator()( const Vector_2& v) const { return Vector_2(-v.hx(), -v.hy(), v.hw()); } }; template class Construct_opposite_vector_3 { typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 1 > Arity; Vector_3 operator()( const Vector_3& v) const { return Vector_3(-v.hx(), -v.hy(), -v.hz(), v.hw()); } }; template class Construct_orthogonal_vector_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Plane_3 Plane_3; public: typedef Vector_3 result_type; typedef Arity_tag< 1 > Arity; Vector_3 operator()( const Plane_3& p ) const { return p.orthogonal_vector(); } Vector_3 operator()( const Point_3& p, const Point_3& q, const Point_3& r ) const { return operator()(Plane_3(p, q, r)); } }; template class Construct_projected_point_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Line_3 Line_3; typedef typename K::Vector_3 Vector_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Line_3& l, const Point_3& p ) const { if ( l.has_on(p) ) return p; Vector_3 v = p - l.point(); const RT& vx = v.hx(); const RT& vy = v.hy(); const RT& vz = v.hz(); const RT& vw = v.hw(); Vector_3 dir = l.to_vector(); const RT& dx = dir.hx(); const RT& dy = dir.hy(); const RT& dz = dir.hz(); const RT& dw = dir.hw(); RT lambda_num = (vx*dx + vy*dy + vz*dz)*dw; // *dw RT lambda_den = (dx*dx + dy*dy + dz*dz)*vw; // *dw return l.point() + ( (lambda_num * dir)/lambda_den ); } Point_3 operator()( const Plane_3& h, const Point_3& p ) const { return h.projection(p); } }; template class Construct_scaled_vector_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Vector_2 Vector_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()( const Vector_2& v, const RT& c) const { return Vector_2(c * v.hx(), c * v.hy(), v.hw()); } Vector_2 operator()( const Vector_2& v, const FT& c) const { return Vector_2( v.hx()*c.numerator(), v.hy()*c.numerator(), v.hw()*c.denominator() ); } }; template class Construct_scaled_vector_3 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Vector_3 Vector_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()( const Vector_3& v, const RT& c) const { return Vector_3(c * v.hx(), c * v.hy(), c * v.hz(), v.hw()); } Vector_3 operator()( const Vector_3& v, const FT& c) const { return Vector_3( v.hx()*c.numerator(), v.hy()*c.numerator(), v.hz()*c.numerator(), v.hw()*c.denominator() ); } }; template class Construct_translated_point_2 { typedef typename K::Point_2 Point_2; typedef typename K::Vector_2 Vector_2; public: typedef Point_2 result_type; typedef Arity_tag< 2 > Arity; Point_2 operator()( const Point_2& p, const Vector_2& v) const { return Point_2( p.hx()*v.hw() + v.hx()*p.hw(), p.hy()*v.hw() + v.hy()*p.hw(), p.hw()*v.hw() ); } Point_2 operator()( const Origin&, const Vector_2& v) const { return Point_2( v.hx(), v.hy(), v.hw() ); } }; template class Construct_translated_point_3 { typedef typename K::Point_3 Point_3; typedef typename K::Vector_3 Vector_3; public: typedef Point_3 result_type; typedef Arity_tag< 2 > Arity; Point_3 operator()( const Point_3& p, const Vector_3& v) const { return Point_3(p.hx()*v.hw() + v.hx()*p.hw(), p.hy()*v.hw() + v.hy()*p.hw(), p.hz()*v.hw() + v.hz()*p.hw(), p.hw()*v.hw() ); } Point_3 operator()( const Origin&, const Vector_3& v) const { return Point_3( v.hx(), v.hy(), v.hz(), v.hw() ); } }; template class Construct_vector_2 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Segment_2 Segment_2; typedef typename K::Ray_2 Ray_2; typedef typename K::Line_2 Line_2; typedef typename K::Vector_2 Vector_2; typedef typename K::Point_2 Point_2; public: typedef Vector_2 result_type; typedef Arity_tag< 2 > Arity; Vector_2 operator()() const { return Vector_2(); } Vector_2 operator()( const Point_2& p, const Point_2& q) const { return Vector_2( q.hx()*p.hw() - p.hx()*q.hw(), q.hy()*p.hw() - p.hy()*q.hw(), p.hw()*q.hw() ); } Vector_2 operator()( const Origin& , const Point_2& q) const { return Vector_2( q.hx() , q.hy() , q.hw() ); } Vector_2 operator()( const Point_2& p, const Origin& q) const { return Vector_2( - p.hx(), - p.hy(), p.hw() ); } Vector_2 operator()( const Segment_2& s) const { return s.to_vector(); } Vector_2 operator()( const Ray_2& r) const { return r.to_vector(); } Vector_2 operator()( const Line_2& l) const { return l.to_vector(); } Vector_2 operator()( Null_vector) const { return Vector_2(RT(0), RT(0), RT(1)); } // #ifndef CGAL_NO_DEPRECATED_CODE Vector_2 operator()( const RT& x, const RT& y) const { return Vector_2(x, y); } Vector_2 operator()( const RT& x, const RT& y, const RT& w) const { return Vector_2(x, y, w); } // #endif // CGAL_NO_DEPRECATED_CODE }; template class Construct_vector_3 { typedef typename K::RT RT; typedef typename K::FT FT; typedef typename K::Segment_3 Segment_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Line_3 Line_3; typedef typename K::Vector_3 Vector_3; typedef typename K::Point_3 Point_3; public: typedef Vector_3 result_type; typedef Arity_tag< 2 > Arity; Vector_3 operator()() const { return Vector_3(); } Vector_3 operator()( const Point_3& p, const Point_3& q) const { return Vector_3(q.hx()*p.hw() - p.hx()*q.hw(), q.hy()*p.hw() - p.hy()*q.hw(), q.hz()*p.hw() - p.hz()*q.hw(), q.hw()*p.hw() ); } Vector_3 operator()( const Origin& , const Point_3& q) const { return Vector_3( q.hx() , q.hy() , q.hz() , q.hw() ); } Vector_3 operator()( const Point_3& p, const Origin& q) const { return Vector_3( - p.hx(), - p.hy(), - p.hz(), p.hw() ); } Vector_3 operator()( const Segment_3& s) const { return this->operator()(s.start(), s.end()); } Vector_3 operator()( const Ray_3& r) const { return r.to_vector(); } Vector_3 operator()( const Line_3& l) const { return l.to_vector(); } Vector_3 operator()( const Null_vector&) const { return Vector_3(RT(0), RT(0), RT(0), RT(1)); } // #ifndef CGAL_NO_DEPRECATED_CODE Vector_3 operator()( const RT& x, const RT& y, const RT& z) const { return Vector_3(x, y, z); } Vector_3 operator()( const RT& x, const RT& y, const RT& z, const RT& w) const { return Vector_3(x, y, z, w); } // #endif // CGAL_NO_DEPRECATED_CODE }; template class Coplanar_orientation_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Coplanar_3 Coplanar_3; typedef typename K::Collinear_3 Collinear_3; Coplanar_3 cp; Collinear_3 cl; #endif // CGAL_kernel_exactness_preconditions public: typedef Orientation result_type; typedef Arity_tag< 4 > Arity; #ifdef CGAL_kernel_exactness_preconditions Coplanar_orientation_3() {} Coplanar_orientation_3(const Coplanar_3& cp_, const Collinear_3& cl_) : cp(cp_), cl(cl_) {} #endif // CGAL_kernel_exactness_preconditions Orientation operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { Orientation oxy_pqr = orientationH2(p.hx(), p.hy(), p.hw(), q.hx(), q.hy(), q.hw(), r.hx(), r.hy(), r.hw()); if (oxy_pqr != COLLINEAR) return oxy_pqr; Orientation oyz_pqr = orientationH2(p.hy(), p.hz(), p.hw(), q.hy(), q.hz(), q.hw(), r.hy(), r.hz(), r.hw()); if (oyz_pqr != COLLINEAR) return oyz_pqr; return orientationH2(p.hx(), p.hz(), p.hw(), q.hx(), q.hz(), q.hw(), r.hx(), r.hz(), r.hw()); } Orientation operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { // p,q,r,s supposed to be coplanar // p,q,r supposed to be non collinear // tests whether s is on the same side of p,q as r // returns : // COLLINEAR if pqr collinear // POSITIVE if qrp and qrs have the same orientation // NEGATIVE if qrp and qrs have opposite orientations CGAL_kernel_exactness_precondition( ! cl(p, q, r) ); CGAL_kernel_exactness_precondition( cp(p, q, r, s) ); // compute orientation of p,q,s in this plane P: Orientation save; if ( (save = orientationH2( p.hy(), p.hz(), p.hw(), q.hy(), q.hz(), q.hw(), r.hy(), r.hz(), r.hw())) != COLLINEAR) { return static_cast( static_cast( save) * static_cast( orientationH2( p.hy(), p.hz(), p.hw(), q.hy(), q.hz(), q.hw(), s.hy(), s.hz(), s.hw())) ); } if ( (save = orientationH2( p.hx(), p.hz(), p.hw(), q.hx(), q.hz(), q.hw(), r.hx(), r.hz(), r.hw())) != COLLINEAR) { return static_cast( static_cast( save) * static_cast( orientationH2( p.hx(), p.hz(), p.hw(), q.hx(), q.hz(), q.hw(), s.hx(), s.hz(), s.hw())) ); } if ( (save = orientationH2( p.hx(), p.hy(), p.hw(), q.hx(), q.hy(), q.hw(), r.hx(), r.hy(), r.hw())) != COLLINEAR) { return static_cast( static_cast( save) * static_cast( orientationH2( p.hx(), p.hy(), p.hw(), q.hx(), q.hy(), q.hw(), s.hx(), s.hy(), s.hw())) ); } CGAL_kernel_assertion( false); return COLLINEAR; } }; template class Coplanar_side_of_bounded_circle_3 { typedef typename K::Point_3 Point_3; #ifdef CGAL_kernel_exactness_preconditions typedef typename K::Coplanar_3 Coplanar_3; typedef typename K::Collinear_3 Collinear_3; Coplanar_3 cp; Collinear_3 cl; #endif // CGAL_kernel_exactness_preconditions public: typedef Bounded_side result_type; typedef Arity_tag< 4 > Arity; #ifdef CGAL_kernel_exactness_preconditions Coplanar_side_of_bounded_circle_3() {} Coplanar_side_of_bounded_circle_3(const Coplanar_3& cp_, const Collinear_3& cl_) : cp(cp_), cl(cl_) {} #endif // CGAL_kernel_exactness_preconditions Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& t) const { // p,q,r,t are supposed to be coplanar. // p,q,r determine an orientation of this plane (not collinear). // returns the equivalent of side_of_bounded_circle(p,q,r,t) // in this plane CGAL_kernel_exactness_precondition( cp(p,q,r,t) ); CGAL_kernel_exactness_precondition( !cl(p,q,r) ); return (Bounded_side) side_of_oriented_sphere(p, q, r, t+cross_product(q-p, r-p), t); } // FIXME }; template class Equal_xy_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return (p.hx() * q.hw() == q.hx() * p.hw() ) && (p.hy() * q.hw() == q.hy() * p.hw() ); } }; template class Equal_x_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return p.hx()*q.hw() == q.hx()*p.hw(); } }; template class Equal_x_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.hx()*q.hw() == q.hx()*p.hw(); } }; template class Equal_y_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return p.hy()*q.hw() == q.hy()*p.hw(); } }; template class Equal_y_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.hy()*q.hw() == q.hy()*p.hw(); } }; template class Equal_z_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return p.hz()*q.hw() == q.hz()*p.hw(); } }; template class Has_on_3 { typedef typename K::Point_3 Point_3; typedef typename K::Line_3 Line_3; typedef typename K::Ray_3 Ray_3; typedef typename K::Segment_3 Segment_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Triangle_3 Triangle_3; typedef typename K::Tetrahedron_3 Tetrahedron_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Line_3& l, const Point_3& p) const { return l.has_on(p); } bool operator()( const Ray_3& r, const Point_3& p) const { return r.has_on(p); } bool operator()( const Segment_3& s, const Point_3& p) const { return s.has_on(p); } bool operator()( const Plane_3& pl, const Point_3& p) const { return pl.has_on(p); } bool operator()( const Triangle_3& t, const Point_3& p) const { if (!t.is_degenerate() ) { Plane_3 sup_pl = t.supporting_plane(); if ( !sup_pl.has_on(p) ) { return false; } Tetrahedron_3 tetrapak( t.vertex(0), t.vertex(1), t.vertex(2), t.vertex(0) + sup_pl.orthogonal_vector()); return tetrapak.has_on_boundary(p); } Point_3 minp( t.vertex(0) ); Point_3 maxp( t.vertex(1) ); if (lexicographically_xyz_smaller(t.vertex(1),t.vertex(0)) ) { minp = t.vertex(1); maxp = t.vertex(0); } if (lexicographically_xyz_smaller(t.vertex(2),minp ) ) { minp = t.vertex(2); } if (lexicographically_xyz_smaller(maxp, t.vertex(2)) ) { maxp = t.vertex(2); } if (minp == maxp) { return (p == maxp); } Segment_3 s(minp,maxp); return s.has_on(p); } }; template class Less_distance_to_point_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typedef typename K::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances // phx * phx * qhw * qhw * rhw * rhw // -RT(2) * phx * qhx * phw * qhw * rhw * rhw // + qhx * qhx * phw * phw * rhw * rhw // // + phy * phy * qhw * qhw * rhw * rhw // -RT(2) * phy * qhy * phw * qhw * rhw * rhw // + qhy * qhy * phw * phw * rhw * rhw // // - ( phx * phx * qhw * qhw * rhw * rhw // -RT(2) * phx * rhx * phw * qhw * qhw * rhw // + rhx * rhx * phw * phw * qhw * qhw // // + phy * phy * qhw * qhw * rhw * rhw // -RT(2) * phy * rhy * phw * qhw * qhw * rhw // + rhy * rhy * phw * phw * qhw * qhw rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy ) - RT2 * qhw * ( phx*qhx + phy*qhy ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy ) - RT2 * rhw * ( phx*rhx + phy*rhy ) ); return ( dosd < RT0 ); } }; template class Less_distance_to_point_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()(const Point_3& p, const Point_3& q, const Point_3& r) const { typedef typename K::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhz = r.hz(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy + qhz*qhz ) - RT2 * qhw * ( phx*qhx + phy*qhy + phz*qhz ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy + rhz*rhz ) - RT2 * rhw * ( phx*rhx + phy*rhy + phz*rhz ) ); return ( dosd < RT0 ); } }; template class Less_signed_distance_to_line_2 { typedef typename K::Point_2 Point_2; typedef typename K::Line_2 Line_2; public: typedef bool result_type; typedef Arity_tag< 4 > Arity; bool operator()(const Point_2& p, const Point_2& q, const Point_2& r, const Point_2& s) const { typedef typename K::RT RT; const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT rhx= r.hx(); const RT rhy= r.hy(); const RT rhw= r.hw(); const RT shx= s.hx(); const RT shy= s.hy(); const RT shw= s.hw(); const RT RT0 = RT(0); RT scaled_dist_r_minus_scaled_dist_s = ( rhx*shw - shx*rhw ) * (phy*qhw - qhy*phw) - ( rhy*shw - shy*rhw ) * (phx*qhw - qhx*phw); return ( scaled_dist_r_minus_scaled_dist_s < RT0 ); } bool operator()(const Line_2& l, const Point_2& p, const Point_2& q) const { typedef typename K::RT RT; const RT la = l.a(); const RT lb = l.b(); const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = la*( phx*qhw - qhx*phw ) + lb*( phy*qhw - qhy*phw ); return ( scaled_dist_p_minus_scaled_dist_q < RT0 ); } }; template class Less_signed_distance_to_plane_3 { typedef typename K::RT RT; typedef typename K::Point_3 Point_3; typedef typename K::Plane_3 Plane_3; typedef typename K::Construct_plane_3 Construct_plane_3; public: typedef bool result_type; typedef Arity_tag< 3 > Arity; bool operator()( const Plane_3& pl, const Point_3& p, const Point_3& q) const { const RT pla = pl.a(); const RT plb = pl.b(); const RT plc = pl.c(); const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = pla*( phx*qhw - qhx*phw ) + plb*( phy*qhw - qhy*phw ) + plc*( phz*qhw - qhz*phw ); return ( scaled_dist_p_minus_scaled_dist_q < RT0 ); } bool operator()(const Point_3& plp, const Point_3& plq,const Point_3& plr, const Point_3& p, const Point_3& q) const { Construct_plane_3 construct_plane_3; return operator()(construct_plane_3(plp, plq, plr), p, q); } }; template class Less_xyz_3 { typedef typename K::Point_3 Point_3; typedef typename K::Compare_xyz_3 Compare_xyz_3; Compare_xyz_3 c; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Less_xyz_3() {} Less_xyz_3(const Compare_xyz_3& c_) : c(c_) {} bool operator()( const Point_3& p, const Point_3& q) const { return c(p, q) == SMALLER; } }; template class Less_xy_2 { typedef typename K::Point_2 Point_2; typedef typename K::Compare_xy_2 Compare_xy_2; Compare_xy_2 c; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Less_xy_2() {} Less_xy_2(const Compare_xy_2& c_) : c(c_) {} bool operator()( const Point_2& p, const Point_2& q) const { return c(p, q) == SMALLER; } }; template class Less_xy_3 { typedef typename K::Point_3 Point_3; typedef typename K::Compare_xy_3 Compare_xy_3; Compare_xy_3 c; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; Less_xy_3() {} Less_xy_3(const Compare_xy_3& c_) : c(c_) {} bool operator()( const Point_3& p, const Point_3& q) const { return c(p, q) == SMALLER; } }; template class Less_x_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return ( p.hx()*q.hw() < q.hx()*p.hw() ); } }; template class Less_x_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return ( p.hx()*q.hw() < q.hx()*p.hw() ); } }; template class Less_yx_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); RT pV = phy * qhw; RT qV = qhy * phw; if ( qV < pV ) { return false; } else if ( pV < qV ) { return true; } pV = phx * qhw; qV = qhx * phw; return ( pV < qV ); } }; template class Less_y_2 { typedef typename K::Point_2 Point_2; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_2& p, const Point_2& q) const { return ( p.hy()*q.hw() < q.hy()*p.hw() ); } }; template class Less_y_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return ( p.hy()*q.hw() < q.hy()*p.hw() ); } }; template class Less_z_3 { typedef typename K::Point_3 Point_3; public: typedef bool result_type; typedef Arity_tag< 2 > Arity; bool operator()( const Point_3& p, const Point_3& q) const { return (p.hz() * q.hw() < q.hz() * p.hw() ); } }; template class Orientation_2 { typedef typename K::Point_2 Point_2; public: typedef Orientation result_type; typedef Arity_tag< 3 > Arity; Orientation operator()(const Point_2& p, const Point_2& q, const Point_2& r) const { typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& rhx = r.hx(); const RT& rhy = r.hy(); const RT& rhw = r.hw(); // | A B | // | C D | RT A = phx*rhw - phw*rhx; RT B = phy*rhw - phw*rhy; RT C = qhx*rhw - qhw*rhx; RT D = qhy*rhw - qhw*rhy; return static_cast((int) CGAL_NTS compare(A*D, B*C)); } }; template class Orientation_3 { typedef typename K::Point_3 Point_3; public: typedef Orientation result_type; typedef Arity_tag< 4 > Arity; Orientation operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s) const { // Two rows are switched, because of the homogeneous column. return (Orientation) sign_of_determinant4x4( p.hx(), p.hy(), p.hz(), p.hw(), r.hx(), r.hy(), r.hz(), r.hw(), q.hx(), q.hy(), q.hz(), q.hw(), s.hx(), s.hy(), s.hz(), s.hw()); } }; template class Side_of_bounded_circle_2 { typedef typename K::Point_2 Point_2; public: typedef Bounded_side result_type; typedef Arity_tag< 4 > Arity; Bounded_side operator()( const Point_2& p, const Point_2& q, const Point_2& t) const { typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& thx = t.hx(); const RT& thy = t.hy(); const RT& thw = t.hw(); return Bounded_side( CGAL_NTS compare((thx*phw-phx*thw)*(qhx*thw-thx*qhw), (thy*phw-phy*thw)*(thy*qhw-qhy*thw)) ); } Bounded_side operator()( const Point_2& q, const Point_2& r, const Point_2& s, const Point_2& t) const { typedef typename K::RT RT; const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& rhx = r.hx(); const RT& rhy = r.hy(); const RT& rhw = r.hw(); const RT& shx = s.hx(); const RT& shy = s.hy(); const RT& shw = s.hw(); const RT& thx = t.hx(); const RT& thy = t.hy(); const RT& thw = t.hw(); const RT RT0 = RT(0); CGAL_kernel_precondition( ! collinear(q,r,s) ); // compute sign of |qx qy qx^2+qy^2 1 | | a b c d | // | -- r -- | = | e f g h | // determinant | -- s -- | = | i j k l | // | -- t -- | | m n o p | // where RT a = qhx*qhw; RT b = qhy*qhw; RT c = qhx*qhx + qhy*qhy; RT d = qhw*qhw; RT e = rhx*rhw; RT f = rhy*rhw; RT g = rhx*rhx + rhy*rhy; RT h = rhw*rhw; RT i = shx*shw; RT j = shy*shw; RT k = shx*shx + shy*shy; RT l = shw*shw; RT m = thx*thw; RT n = thy*thw; RT o = thx*thx + thy*thy; RT p = thw*thw; RT det = a * ( f*(k*p - l*o) + j*(h*o - g*p) + n*(g*l - h*k) ) - e * ( b*(k*p - l*o) + j*(d*o - c*p) + n*(c*l - d*k) ) + i * ( b*(g*p - h*o) + f*(d*o - c*p) + n*(c*h - d*g) ) - m * ( b*(g*l - h*k) + f*(d*k - c*l) + j*(c*h - d*g) ); if ( det == RT0 ) return ON_BOUNDARY; else { if (orientation(q,r,s) == CLOCKWISE) det = -det; return (RT0 < det ) ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } } }; template class Side_of_bounded_sphere_3 { typedef typename K::Point_3 Point_3; public: typedef Bounded_side result_type; typedef Arity_tag< 5 > Arity; Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& t) const { typedef typename K::RT RT; const RT& phx = p.hx(); const RT& phy = p.hy(); const RT& phz = p.hz(); const RT& phw = p.hw(); const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhz = q.hz(); const RT& qhw = q.hw(); const RT& thx = t.hx(); const RT& thy = t.hy(); const RT& thz = t.hz(); const RT& thw = t.hw(); return Bounded_side( CGAL_NTS sign((thx*phw-phx*thw)*(qhx*thw-thx*qhw) + (thy*phw-phy*thw)*(qhy*thw-thy*qhw) + (thz*phw-phz*thw)*(qhz*thw-thz*qhw))); } Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& t) const { Point_3 center = circumcenter(p, q, r); return Bounded_side( compare_distance_to_point(center, p, t) ); } // FIXME Bounded_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s, const Point_3& test) const { Oriented_side oside = side_of_oriented_sphere(p,q,r,s,test); if ( are_positive_oriented( p,q,r,s) ) { switch (oside) { case ON_POSITIVE_SIDE : return ON_BOUNDED_SIDE; case ON_ORIENTED_BOUNDARY: return ON_BOUNDARY; case ON_NEGATIVE_SIDE : return ON_UNBOUNDED_SIDE; } } else { switch (oside) { case ON_POSITIVE_SIDE : return ON_UNBOUNDED_SIDE; case ON_ORIENTED_BOUNDARY: return ON_BOUNDARY; case ON_NEGATIVE_SIDE : return ON_BOUNDED_SIDE; } } return ON_BOUNDARY; // Pls, no warnings anylonger } // FIXME }; template class Side_of_oriented_circle_2 { typedef typename K::Point_2 Point_2; public: typedef Oriented_side result_type; typedef Arity_tag< 4 > Arity; Oriented_side operator()( const Point_2& q, const Point_2& r, const Point_2& s, const Point_2& t) const { typedef typename K::RT RT; const RT& qhx = q.hx(); const RT& qhy = q.hy(); const RT& qhw = q.hw(); const RT& rhx = r.hx(); const RT& rhy = r.hy(); const RT& rhw = r.hw(); const RT& shx = s.hx(); const RT& shy = s.hy(); const RT& shw = s.hw(); const RT& thx = t.hx(); const RT& thy = t.hy(); const RT& thw = t.hw(); CGAL_kernel_precondition( ! collinear(q,r,s) ); // compute sign of |qx qy qx^2+qy^2 1 | | a b c d | // | -- r -- | = | e f g h | // determinant | -- s -- | = | i j k l | // | -- t -- | | m n o p | // where RT a = qhx*qhw; RT b = qhy*qhw; RT c = qhx*qhx + qhy*qhy; RT d = qhw*qhw; RT e = rhx*rhw; RT f = rhy*rhw; RT g = rhx*rhx + rhy*rhy; RT h = rhw*rhw; RT i = shx*shw; RT j = shy*shw; RT k = shx*shx + shy*shy; RT l = shw*shw; RT m = thx*thw; RT n = thy*thw; RT o = thx*thx + thy*thy; RT p = thw*thw; RT det = a * ( f*(k*p - l*o) + j*(h*o - g*p) + n*(g*l - h*k) ) - e * ( b*(k*p - l*o) + j*(d*o - c*p) + n*(c*l - d*k) ) + i * ( b*(g*p - h*o) + f*(d*o - c*p) + n*(c*h - d*g) ) - m * ( b*(g*l - h*k) + f*(d*k - c*l) + j*(c*h - d*g) ); return static_cast((int) CGAL_NTS sign(det)); } }; template class Side_of_oriented_sphere_3 { typedef typename K::Point_3 Point_3; public: typedef Oriented_side result_type; typedef Arity_tag< 5 > Arity; Oriented_side operator()( const Point_3& p, const Point_3& q, const Point_3& r, const Point_3& s, const Point_3& t) const { typedef typename K::RT RT; CGAL_kernel_precondition( !coplanar(p,q,r,s) ); const RT phx = p.hx(); const RT phy = p.hy(); const RT phz = p.hz(); const RT phw = p.hw(); const RT phw2 = phw*phw; const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhz = q.hz(); const RT qhw = q.hw(); const RT qhw2 = qhw*qhw; const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhz = r.hz(); const RT rhw = r.hw(); const RT rhw2 = rhw*rhw; const RT shx = s.hx(); const RT shy = s.hy(); const RT shz = s.hz(); const RT shw = s.hw(); const RT shw2 = shw*shw; const RT thx = t.hx(); const RT thy = t.hy(); const RT thz = t.hz(); const RT thw = t.hw(); const RT thw2 = thw*thw; const RT det = det5x5_by_formula( phx*phw, phy*phw, phz*phw, phx*phx + phy*phy + phz*phz, phw2, qhx*qhw, qhy*qhw, qhz*qhw, qhx*qhx + qhy*qhy + qhz*qhz, qhw2, rhx*rhw, rhy*rhw, rhz*rhw, rhx*rhx + rhy*rhy + rhz*rhz, rhw2, shx*shw, shy*shw, shz*shw, shx*shx + shy*shy + shz*shz, shw2, thx*thw, thy*thw, thz*thw, thx*thx + thy*thy + thz*thz, thw2); if (det < RT(0)) { return ON_POSITIVE_SIDE; } else { return (RT(0) < det) ? ON_NEGATIVE_SIDE : ON_ORIENTED_BOUNDARY; } } }; } // namespace HomogeneousKernelFunctors CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_FUNCTION_OBJECTS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/RayH2.h0000644000175000017500000001377211344301501030421 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/RayH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_RAYH2_H #define CGAL_RAYH2_H #include CGAL_BEGIN_NAMESPACE template < class R_ > class RayH2 { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Line_2 Line_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Aff_transformation_2 Aff_transformation_2; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; RayH2() {} RayH2( const Point_2& sp, const Point_2& secondp) : base(sp, secondp) {} RayH2( const Point_2& sp, const Direction_2& d) : base(sp, sp + d.to_vector()) {} RayH2( const Point_2& sp, const Vector_2& v) : base(sp, sp + v) {} RayH2( const Point_2& sp, const Line_2& l) : base(sp, sp + l.to_vector()) {} bool operator==(const RayH2& r) const; bool operator!=(const RayH2& r) const; const Point_2 & start() const; const Point_2 & source() const; const Point_2 & second_point() const; Point_2 point(int i) const; Direction_2 direction() const; Vector_2 to_vector() const; Line_2 supporting_line() const; RayH2 opposite() const; bool is_horizontal() const; bool is_vertical() const; bool has_on(const Point_2& p) const; bool collinear_has_on(const Point_2& p) const; bool is_degenerate() const; RayH2 transform( const Aff_transformation_2 & t) const; }; template < class R > inline const typename RayH2::Point_2 & RayH2::source() const { return get(base).e0; } template < class R > inline const typename RayH2::Point_2 & RayH2::start() const { return source(); } template < class R > CGAL_KERNEL_INLINE typename RayH2::Vector_2 RayH2::to_vector() const { CGAL_kernel_precondition( !is_degenerate() ); return second_point() - start(); } template < class R > CGAL_KERNEL_INLINE typename RayH2::Direction_2 RayH2::direction() const { CGAL_kernel_precondition( !is_degenerate() ); return Direction_2( second_point() - start() ); } template < class R > inline const typename RayH2::Point_2 & RayH2::second_point() const { CGAL_kernel_precondition( !is_degenerate() ); return get(base).e1; } template < class R > CGAL_KERNEL_INLINE typename RayH2::Point_2 RayH2::point(int i) const { CGAL_kernel_precondition( !is_degenerate() ); CGAL_kernel_precondition( i>= 0 ); Vector_2 v = direction().to_vector(); return start() + RT(i) * v; } template < class R > inline typename RayH2::Line_2 RayH2::supporting_line() const { CGAL_kernel_precondition( !is_degenerate() ); return Line_2(*this); } template < class R > inline RayH2 RayH2::opposite() const { return RayH2( start(), - direction() ); } template < class R > CGAL_KERNEL_INLINE RayH2 RayH2:: transform(const typename RayH2::Aff_transformation_2 & t) const { return RayH2(t.transform(start()), t.transform(second_point()) ); } #ifndef CGAL_NO_OSTREAM_INSERT_RAYH2 template < class R > std::ostream & operator<<(std::ostream &os, const RayH2 &r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r.source() << ' ' << r.second_point(); case IO::BINARY : return os << r.source() << r.second_point(); default: return os << "RayC2(" << r.source() << ", " << r.second_point() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_RAYH2 #ifndef CGAL_NO_ISTREAM_EXTRACT_RAYH2 template < class R > std::istream & operator>>(std::istream &is, RayH2 &r) { typename R::Point_2 p, q; is >> p >> q; r = RayH2(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_RAYH2 template < class R > CGAL_KERNEL_INLINE bool RayH2::is_horizontal() const { return start().hy()*second_point().hw() == second_point().hy()*start().hw(); } template < class R > CGAL_KERNEL_INLINE bool RayH2::is_vertical() const { return start().hx()*second_point().hw() == second_point().hx()*start().hw(); } template < class R > CGAL_KERNEL_INLINE bool RayH2::has_on(const typename RayH2::Point_2& p) const { return p == start() || Direction_2(p - start()) == direction(); } template < class R > CGAL_KERNEL_INLINE bool RayH2::is_degenerate() const { return start() == get(base).e1; } template < class R > inline bool RayH2::collinear_has_on(const typename RayH2::Point_2& p) const { return has_on(p); } template < class R > CGAL_KERNEL_INLINE bool RayH2::operator==(const RayH2& r) const { return ( (start() == r.start() )&&( direction() == r.direction() ) ); } template < class R > inline bool RayH2::operator!=( const RayH2& r) const { return !(*this == r); } CGAL_END_NAMESPACE #endif // CGAL_RAYH2_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/distance_predicatesH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/distance_p0000644000175000017500000001642511344301501031355 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/distance_predicatesH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_DISTANCE_PREDICATESH2_H #define CGAL_DISTANCE_PREDICATESH2_H #include CGAL_BEGIN_NAMESPACE template < class R> CGAL_KERNEL_MEDIUM_INLINE bool has_larger_distance_to_point(const PointH2& p, const PointH2& q, const PointH2& r) { typedef typename R::RT RT; const RT phx = p.hx(); const RT phy = p.hy(); const RT phw = p.hw(); const RT qhx = q.hx(); const RT qhy = q.hy(); const RT qhw = q.hw(); const RT rhx = r.hx(); const RT rhy = r.hy(); const RT rhw = r.hw(); const RT RT0 = RT(0); const RT RT2 = RT(2); RT dosd = // difference of squared distances // phx * phx * qhw * qhw * rhw * rhw // -RT(2) * phx * qhx * phw * qhw * rhw * rhw // + qhx * qhx * phw * phw * rhw * rhw // // + phy * phy * qhw * qhw * rhw * rhw // -RT(2) * phy * qhy * phw * qhw * rhw * rhw // + qhy * qhy * phw * phw * rhw * rhw // // - ( phx * phx * qhw * qhw * rhw * rhw // -RT(2) * phx * rhx * phw * qhw * qhw * rhw // + rhx * rhx * phw * phw * qhw * qhw // // + phy * phy * qhw * qhw * rhw * rhw // -RT(2) * phy * rhy * phw * qhw * qhw * rhw // + rhy * rhy * phw * phw * qhw * qhw rhw*rhw * ( phw * ( qhx*qhx + qhy*qhy ) - RT2 * qhw * ( phx*qhx + phy*qhy ) ) - qhw*qhw * ( phw * ( rhx*rhx + rhy*rhy ) - RT2 * rhw * ( phx*rhx + phy*rhy ) ); return ( dosd > RT0 ); } template < class R> CGAL_KERNEL_INLINE Comparison_result compare_signed_distance_to_line(const LineH2& l, const PointH2& p, const PointH2& q) { typedef typename R::RT RT; const RT la = l.a(); const RT lb = l.b(); const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = la*( phx*qhw - qhx*phw ) + lb*( phy*qhw - qhy*phw ); if ( scaled_dist_p_minus_scaled_dist_q < RT0 ) { return SMALLER; } else { return ( RT0 < scaled_dist_p_minus_scaled_dist_q ) ? LARGER : EQUAL; } } template < class R> CGAL_KERNEL_INLINE bool has_larger_signed_distance_to_line(const LineH2& l, const PointH2& p, const PointH2& q) { typedef typename R::RT RT; const RT la = l.a(); const RT lb = l.b(); const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = la*( phx*qhw - qhx*phw ) + lb*( phy*qhw - qhy*phw ); return ( scaled_dist_p_minus_scaled_dist_q > RT0 ); } template < class R> CGAL_KERNEL_INLINE bool has_smaller_signed_distance_to_line(const LineH2& l, const PointH2& p, const PointH2& q) { typedef typename R::RT RT; const RT la = l.a(); const RT lb = l.b(); const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT RT0 = RT(0); RT scaled_dist_p_minus_scaled_dist_q = la*( phx*qhw - qhx*phw ) + lb*( phy*qhw - qhy*phw ); return ( scaled_dist_p_minus_scaled_dist_q < RT0 ); } template < class R> CGAL_KERNEL_MEDIUM_INLINE Comparison_result compare_signed_distance_to_line(const PointH2& p, const PointH2& q, const PointH2& r, const PointH2& s) { typedef typename R::RT RT; const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT rhx= r.hx(); const RT rhy= r.hy(); const RT rhw= r.hw(); const RT shx= s.hx(); const RT shy= s.hy(); const RT shw= s.hw(); const RT RT0 = RT(0); RT scaled_dist_r_minus_scaled_dist_s = ( rhx*shw - shx*rhw ) * (phy*qhw - qhy*phw) - ( rhy*shw - shy*rhw ) * (phx*qhw - qhx*phw); if ( scaled_dist_r_minus_scaled_dist_s < RT0 ) { return SMALLER; } else { return (scaled_dist_r_minus_scaled_dist_s > RT0 ) ? LARGER : EQUAL; } } template < class R> CGAL_KERNEL_MEDIUM_INLINE bool has_smaller_signed_distance_to_line(const PointH2& p, const PointH2& q, const PointH2& r, const PointH2& s) { typedef typename R::RT RT; const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT rhx= r.hx(); const RT rhy= r.hy(); const RT rhw= r.hw(); const RT shx= s.hx(); const RT shy= s.hy(); const RT shw= s.hw(); const RT RT0 = RT(0); RT scaled_dist_r_minus_scaled_dist_s = ( rhx*shw - shx*rhw ) * (phy*qhw - qhy*phw) - ( rhy*shw - shy*rhw ) * (phx*qhw - qhx*phw); return ( scaled_dist_r_minus_scaled_dist_s < RT0 ); } template < class R> CGAL_KERNEL_MEDIUM_INLINE bool has_larger_signed_distance_to_line(const PointH2& p, const PointH2& q, const PointH2& r, const PointH2& s) { typedef typename R::RT RT; const RT phx= p.hx(); const RT phy= p.hy(); const RT phw= p.hw(); const RT qhx= q.hx(); const RT qhy= q.hy(); const RT qhw= q.hw(); const RT rhx= r.hx(); const RT rhy= r.hy(); const RT rhw= r.hw(); const RT shx= s.hx(); const RT shy= s.hy(); const RT shw= s.hw(); const RT RT0 = RT(0); RT scaled_dist_r_minus_scaled_dist_s = ( rhx*shw - shx*rhw ) * (phy*qhw - qhy*phw) - ( rhy*shw - shy*rhw ) * (phx*qhw - qhx*phw); return ( scaled_dist_r_minus_scaled_dist_s > RT0 ); } CGAL_END_NAMESPACE #endif //CGAL_DISTANCE_PREDICATESH2_H ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_rtH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates0000644000175000017500000000346411344301501031366 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/predicates_on_rtH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_PREDICATES_ON_RTH2_H #define CGAL_PREDICATES_ON_RTH2_H CGAL_BEGIN_NAMESPACE template CGAL_KERNEL_INLINE Orientation orientationH2( const RT& phx, const RT& phy, const RT& phw, const RT& qhx, const RT& qhy, const RT& qhw, const RT& rhx, const RT& rhy, const RT& rhw ) { const RT RT0 = RT(0); // | A B | // | C D | RT A = phx*rhw - phw*rhx; RT B = phy*rhw - phw*rhy; RT C = qhx*rhw - qhw*rhx; RT D = qhy*rhw - qhw*rhy; RT det = A*D - B*C; if (det < RT0 ) { return CLOCKWISE; } else { return (RT0 < det) ? COUNTERCLOCKWISE : COLLINEAR; } } CGAL_END_NAMESPACE #endif // CGAL_PREDICATES_ON_RTH2_H ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Homogeneous_base.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Homogeneou0000644000175000017500000001232511344301501031344 0ustar debiandebian// Copyright (c) 1999-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Homogeneous_base.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra, Sylvain Pion #ifndef CGAL_HOMOGENEOUS_BASE_H #define CGAL_HOMOGENEOUS_BASE_H #define CGAL_REP_CLASS_DEFINED #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template < typename K_ > struct Homogeneous_base { typedef K_ Kernel; typedef Homogeneous_tag Rep_tag; typedef Homogeneous_tag Kernel_tag; typedef CGAL::Object Object_2; typedef CGAL::Object Object_3; typedef PointH2 Point_2; typedef VectorH2 Vector_2; typedef DirectionH2 Direction_2; typedef SegmentC2 Segment_2; typedef LineH2 Line_2; typedef RayH2 Ray_2; typedef CircleH2 Circle_2; typedef TriangleC2 Triangle_2; typedef Iso_rectangleH2 Iso_rectangle_2; typedef Aff_transformationH2 Aff_transformation_2; typedef PointH3 Point_3; typedef VectorH3 Vector_3; typedef DirectionH3 Direction_3; typedef SegmentC3 Segment_3; typedef PlaneH3 Plane_3; typedef LineC3 Line_3; typedef RayH3 Ray_3; typedef TriangleC3 Triangle_3; typedef TetrahedronC3 Tetrahedron_3; typedef Iso_cuboidH3 Iso_cuboid_3; typedef SphereH3 Sphere_3; typedef Aff_transformationH3 Aff_transformation_3; typedef Cartesian_coordinate_iterator_2 Cartesian_const_iterator_2; typedef Cartesian_coordinate_iterator_3 Cartesian_const_iterator_3; // Undocumented stuff. typedef Data_accessorH2 Data_accessor_2; typedef ConicHPA2 Conic_2; // Functors types and access functions. #define CGAL_Kernel_pred(Y,Z) typedef HomogeneousKernelFunctors::Y Y; \ Y Z() const { return Y(); } #define CGAL_Kernel_cons(Y,Z) CGAL_Kernel_pred(Y,Z) #include }; CGAL_END_NAMESPACE #endif // CGAL_HOMOGENEOUS_BASE_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/basic_constructionsH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/basic_cons0000644000175000017500000000455411344301501031347 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/basic_constructionsH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Sven Schoenherr // Stefan Schirra #ifndef CGAL_BASIC_CONSTRUCTIONSH2_H #define CGAL_BASIC_CONSTRUCTIONSH2_H #include #include CGAL_BEGIN_NAMESPACE template CGAL_KERNEL_MEDIUM_INLINE typename R::Point_2 gp_linear_intersection(const LineH2& l1, const LineH2& l2) { return typename R::Point_2( l1.b()*l2.c() - l2.b()*l1.c(), l2.a()*l1.c() - l1.a()*l2.c(), l1.a()*l2.b() - l2.a()*l1.b() ); } template CGAL_KERNEL_MEDIUM_INLINE typename R::FT squared_distance( const PointH2& p, const PointH2& q ) { typedef typename R::RT RT; typedef typename R::FT FT; const RT & phx = p.hx(); const RT & phy = p.hy(); const RT & phw = p.hw(); const RT & qhx = q.hx(); const RT & qhy = q.hy(); const RT & qhw = q.hw(); RT sq_dist_numerator = phx * phx * qhw * qhw - RT(2) * phx * qhx * phw * qhw + qhx * qhx * phw * phw + phy * phy * qhw * qhw - RT(2) * phy * qhy * phw * qhw + qhy * qhy * phw * phw ; RT sq_dist_denominator = qhw * qhw * phw * phw ; return FT( sq_dist_numerator ) / FT( sq_dist_denominator ); } CGAL_END_NAMESPACE #endif // CGAL_BASIC_CONSTRUCTIONSH2_H ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Aff_transformationH2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Aff_transf0000644000175000017500000007527711344301501031327 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Aff_transformationH2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_AFF_TRANSFORMATIONH2_H #define CGAL_AFF_TRANSFORMATIONH2_H #include #include CGAL_BEGIN_NAMESPACE template class Aff_transformationH2; template class Aff_transformation_repH2; template Aff_transformationH2 _general_transformation_composition( Aff_transformation_repH2 l, Aff_transformation_repH2 r); template class Aff_transformation_rep_baseH2 : public Ref_counted_virtual { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; virtual ~Aff_transformation_rep_baseH2(){} virtual Point_2 transform(const Point_2& p) const = 0; virtual Vector_2 transform(const Vector_2& v) const = 0; virtual Direction_2 transform(const Direction_2& d) const = 0; virtual Aff_transformationH2 inverse() const = 0; virtual Aff_transformation_repH2 general_form() const = 0; virtual bool is_even() const = 0; virtual RT homogeneous(int i, int j) const = 0; virtual FT cartesian(int i, int j) const = 0; }; template < class R > class Aff_transformation_repH2 : public Aff_transformation_rep_baseH2 { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; Aff_transformation_repH2() {} Aff_transformation_repH2(const RT& m00, const RT& m01, const RT& m02, const RT& m10, const RT& m11, const RT& m12, const RT& m22) : a(m00), b(m01), c(m02), d(m10), e(m11), f(m12), g(m22) {} virtual ~Aff_transformation_repH2() {} virtual Point_2 transform(const Point_2& p) const { return Point_2( a * p.hx() + b * p.hy() + c * p.hw(), d * p.hx() + e * p.hy() + f * p.hw(), g * p.hw() ); } virtual Vector_2 transform(const Vector_2& v) const { return Vector_2( a * v.hx() + b * v.hy(), d * v.hx() + e * v.hy(), g * v.hw() ); } virtual Direction_2 transform(const Direction_2& dir) const { if ( g > RT(0) ) return Direction_2( a * dir.x() + b * dir.y(), d * dir.x() + e * dir.y() ); else return - Direction_2(a * dir.x() + b * dir.y(), d * dir.x() + e * dir.y() ); } virtual Aff_transformationH2 inverse() const { RT ai = e*g; RT bi = - b*g; RT ci = b*f - e*c; RT di = - d*g; RT ei = a*g; RT fi = d*c - a*f; RT gi = a*e - b*d; return Aff_transformationH2( ai, bi, ci, di, ei, fi, gi) ; } virtual Aff_transformation_repH2 general_form() const { return *this; } virtual bool is_even() const { return CGAL_NTS sign( (a*e - b*d)*g ) == POSITIVE; } virtual RT homogeneous(int i, int j) const; virtual FT cartesian(int i, int j) const; RT a; // | a b c | | x | | xn | RT b; // | d e f | * | y | = | yn | RT c; // | 0 0 g | | w | | wn | RT d; RT e; RT f; RT g; friend Aff_transformationH2 _general_transformation_composition <> ( Aff_transformation_repH2 l, Aff_transformation_repH2 r); }; template < class R > class Identity_repH2 : public Aff_transformation_rep_baseH2 { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; Identity_repH2() {} virtual ~Identity_repH2() {} virtual Point_2 transform(const Point_2 & p) const { return p; } virtual Vector_2 transform(const Vector_2 & v) const { return v; } virtual Direction_2 transform(const Direction_2 & d) const { return d; } virtual Aff_transformationH2 inverse() const { return Aff_transformationH2(IDENTITY); } virtual bool is_even() const { return true; } virtual Aff_transformation_repH2 general_form() const { const RT RT0(0); const RT RT1(1); return Aff_transformation_repH2( RT1, RT0, RT0, RT0, RT1, RT0, RT1 ); } virtual RT homogeneous(int i, int j) const { return (i==j) ? RT(1) : RT(0); } virtual FT cartesian(int i, int j) const { return (i==j) ? FT(1) : FT(0); } }; template < class R > class Translation_repH2 : public Aff_transformation_rep_baseH2 { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; Translation_repH2() {} Translation_repH2(const Vector_2 & tv) : _tv(tv) {} virtual ~Translation_repH2() {} virtual Point_2 transform(const Point_2 & p) const { return (p + _tv); } virtual Vector_2 transform(const Vector_2 & v) const { return (v); } virtual Direction_2 transform(const Direction_2 & d) const { return (d); } virtual Aff_transformationH2 inverse() const { return Aff_transformationH2(TRANSLATION, - _tv); } virtual bool is_even() const { return true; } virtual Aff_transformation_repH2 general_form() const { return Aff_transformation_repH2( _tv.hw(), RT(0) , _tv.hx(), RT(0), _tv.hw(), _tv.hy(), _tv.hw() ); } virtual RT homogeneous(int i, int j) const; virtual FT cartesian(int i, int j) const; private: Vector_2 _tv; }; template < class R > class Rotation_repH2 : public Aff_transformation_rep_baseH2 { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; Rotation_repH2() { } Rotation_repH2(const RT& sin, const RT& cos, const RT& den) : _sin(sin), _cos(cos), _den(den) { if ( den < RT(0) ) { _sin = - _sin; _cos = - _cos; _den = - _den; }; } ~Rotation_repH2() { } virtual Point_2 transform(const Point_2 & p) const { return Point_2( p.hx()*_cos - p.hy()*_sin, p.hx()*_sin + p.hy()*_cos, p.hw()*_den ); } virtual Vector_2 transform(const Vector_2 & v) const { return Vector_2( v.hx()*_cos - v.hy()*_sin, v.hx()*_sin + v.hy()*_cos, v.hw()*_den ); } virtual Direction_2 transform(const Direction_2 & d) const { return Direction_2( d.x()*_cos - d.y()*_sin, d.x()*_sin + d.y()*_cos); } virtual Aff_transformationH2 inverse() const { return Aff_transformationH2(ROTATION, - _sin, _cos, _den); } virtual bool is_even() const { return true; } virtual Aff_transformation_repH2 general_form() const { return Aff_transformation_repH2( _cos, - _sin, RT(0) , _sin, _cos, RT(0) , _den ); } virtual RT homogeneous(int i, int j) const; virtual FT cartesian(int i, int j) const; private: RT _sin; RT _cos; RT _den; }; template < class R > class Scaling_repH2 : public Aff_transformation_rep_baseH2 { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; Scaling_repH2() {} Scaling_repH2(const RT& scaling_numerator, const RT& scaling_denominator) : _sf_num(scaling_numerator), _sf_den(scaling_denominator) { if ( scaling_denominator < RT(0) ) { _sf_num = - _sf_num; _sf_den = - _sf_den; }; } virtual ~Scaling_repH2() {} virtual Point_2 transform(const Point_2 & p) const { return Point_2( p.hx() * _sf_num, p.hy() * _sf_num, p.hw() * _sf_den ); } virtual Vector_2 transform(const Vector_2 & v) const { return Vector_2( v.hx() * _sf_num, v.hy() * _sf_num, v.hw() * _sf_den ); } virtual Direction_2 transform(const Direction_2 & d) const { return (d); } virtual Aff_transformationH2 inverse() const { return Aff_transformationH2(SCALING, _sf_den, _sf_num); } virtual bool is_even() const { return true; } virtual Aff_transformation_repH2 general_form() const { return Aff_transformation_repH2(_sf_num, RT(0) , RT(0) , RT(0) , _sf_num, RT(0) , _sf_den ); } virtual RT homogeneous(int i, int j) const; virtual FT cartesian(int i, int j) const; private: RT _sf_num; RT _sf_den; }; template < class R > class Reflection_repH2 : public Aff_transformation_rep_baseH2 { public: typedef typename R::RT RT; typedef typename R::FT FT; typedef typename R::Point_2 Point_2; typedef typename R::Vector_2 Vector_2; typedef typename R::Direction_2 Direction_2; typedef typename R::Line_2 Line_2; Reflection_repH2(const Line_2& l_) : l(l_) {} virtual ~Reflection_repH2() {} virtual Point_2 transform(const Point_2 & p) const { Point_2 pp = l.projection(p); return p + (pp - p)*RT(2); } virtual Vector_2 transform(const Vector_2 & v) const { Line_2 l0( l.a(), l.b(), RT(0)); Point_2 p = ORIGIN + v; Point_2 pp = l0.projection(p); return (p + (pp - p)*RT(2)) - ORIGIN; } virtual Direction_2 transform(const Direction_2 & d) const { return transform( Vector_2(d) ).direction(); } virtual Aff_transformationH2 inverse() const { return Aff_transformationH2( static_cast< Aff_transformation_rep_baseH2* > ( const_cast< Reflection_repH2*> (this) ) ); } virtual bool is_even() const { return false; } virtual Aff_transformation_repH2 general_form() const { const RT mRT2 = - RT(2); const RT& a = l.a(); const RT& b = l.b(); const RT& c = l.c(); RT de = a*a + b*b; RT aa = b*b - a*a; RT bb = a*a - b*b; RT ab = a*b* mRT2; RT ac = a*c* mRT2; RT bc = b*c* mRT2; return Aff_transformation_repH2( aa, ab, ac, ab, bb, bc, de ); } virtual RT homogeneous(int i, int j) const; virtual FT cartesian(int i, int j) const; private: Line_2 l; }; template < class R_ > class Aff_transformationH2 : public Handle_for_virtual< Aff_transformation_rep_baseH2 > { typedef typename R_::FT FT; typedef typename R_::RT RT; typedef typename R_::Point_2 Point_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Line_2 Line_2; public: typedef R_ R; Aff_transformationH2(); // Identity: Aff_transformationH2(const Identity_transformation); // Translation: Aff_transformationH2(const Translation, const Vector_2& v); // Scaling: Aff_transformationH2(const Scaling, const RT& a, const RT& b = RT(1)); Aff_transformationH2(const Scaling, const RT& xa, const RT& xb, const RT& ya, const RT& yb); // Reflection: Aff_transformationH2(const Reflection, const Line_2& l); // Rational Rotation: Aff_transformationH2(const Rotation, const RT& sine, const RT& cosine, const RT& denominator); Aff_transformationH2(const Rotation, const Direction_2& dir, const RT& n, const RT& d = RT(1)); // Orthogonal Transformation: Aff_transformationH2(const Vector_2& v, const RT& sine, const RT& cosine, const RT& denominator, const RT& scaling_numerator = RT(1), const RT& scaling_denominator = RT(1)) { Aff_transformationH2 scaling(SCALING,scaling_numerator,scaling_denominator); Aff_transformationH2 combination = Aff_transformationH2(TRANSLATION, scaling.inverse().transform(-v)) * scaling * Aff_transformationH2(ROTATION, sine, cosine, denominator) * Aff_transformationH2(TRANSLATION, v ) ; *this = combination; } // General affine transformation // | a b c | |x| // | d e f | * |y| // | 0 0 g | |w| Aff_transformationH2(const RT& a, const RT& b, const RT& c, const RT& d, const RT& e, const RT& f, const RT& g = RT(1)); Aff_transformationH2(const RT& a, const RT& b, const RT& d, const RT& e, const RT& g = RT(1)); Point_2 transform(const Point_2& p) const; Vector_2 transform(const Vector_2& v) const; Direction_2 transform(const Direction_2& d) const; Line_2 transform(const Line_2& l) const; Aff_transformationH2 inverse() const; bool is_even() const; bool is_odd() const; // Access functions for matrix form FT cartesian(int i, int j) const; RT homogeneous(int i, int j) const; FT m(int i, int j) const { return cartesian(i,j); } RT hm(int i, int j) const { return homogeneous(i,j); } Aff_transformation_repH2 general_form() const; // friend Aff_transformationH2 // operator* <> // (const Aff_transformationH2& left_argument, // const Aff_transformationH2& right_argument ); Aff_transformationH2 operator*(const Aff_transformationH2& right_argument ) const; }; template < class R > Aff_transformationH2::Aff_transformationH2() { initialize_with(Aff_transformation_repH2()); } template < class R > Aff_transformationH2:: Aff_transformationH2(const Identity_transformation) { initialize_with(Identity_repH2()); } template < class R > Aff_transformationH2:: Aff_transformationH2(const Translation, const typename Aff_transformationH2::Vector_2& v) { initialize_with(Translation_repH2( v )); } template < class R > Aff_transformationH2:: Aff_transformationH2(const Scaling, const RT& a, const RT& b) { initialize_with(Scaling_repH2( a, b)); } template < class R > Aff_transformationH2:: Aff_transformationH2( const Scaling, const RT& xa, const RT& xb, const RT& ya, const RT& yb) { initialize_with(Aff_transformation_repH2(xa*yb, RT(0), RT(0), RT(0), ya*xb, RT(0), xb*yb )); } template < class R > Aff_transformationH2:: Aff_transformationH2(const Reflection, const typename Aff_transformationH2::Line_2& l) { initialize_with(Reflection_repH2( l)); } template < class R > Aff_transformationH2:: Aff_transformationH2(const Rotation, const RT& sine, const RT& cosine, const RT& denominator) { initialize_with(Rotation_repH2(sine, cosine, denominator)); } template < class R > Aff_transformationH2:: Aff_transformationH2(const Rotation, const typename Aff_transformationH2::Direction_2& dir, const RT& n, const RT& d) { const RT RTzero = RT(0) ; CGAL_kernel_precondition( n > RTzero ); CGAL_kernel_precondition( d > RTzero ); RT sin; RT cos; RT den; rational_rotation_approximation(dir.x(), dir.y(), sin, cos, den, n, d); initialize_with(Rotation_repH2( sin, cos, den )); } template < class R > Aff_transformationH2:: Aff_transformationH2( const RT& a, const RT& b, const RT& c, const RT& d, const RT& e, const RT& f, const RT& g) { initialize_with(Aff_transformation_repH2( a, b, c, d, e, f, g )); } template < class R > Aff_transformationH2:: Aff_transformationH2( const RT& a, const RT& b, const RT& d, const RT& e, const RT& g) { initialize_with(Aff_transformation_repH2( a, b, RT(0), d, e, RT(0), g )); } template < class R > typename Aff_transformationH2::Point_2 Aff_transformationH2:: transform(const typename Aff_transformationH2::Point_2& p) const { return this->Ptr()->transform(p); } template < class R > typename Aff_transformationH2::Vector_2 Aff_transformationH2:: transform( const typename Aff_transformationH2::Vector_2& v) const { return this->Ptr()->transform(v); } template < class R > typename Aff_transformationH2::Direction_2 Aff_transformationH2:: transform( const typename Aff_transformationH2::Direction_2& d) const { return this->Ptr()->transform(d); } template < class R > typename Aff_transformationH2::Line_2 Aff_transformationH2:: transform( const typename Aff_transformationH2::Line_2& l) const { return Line_2( transform( l.point(0)), transform( l.point(1)) ); } template < class R > Aff_transformationH2 Aff_transformationH2:: inverse() const { return this->Ptr()->inverse(); } template < class R > bool Aff_transformationH2:: is_even() const { return this->Ptr()->is_even(); } template < class R > bool Aff_transformationH2:: is_odd() const { return ! is_even(); } template < class R > inline typename Aff_transformationH2::FT Aff_transformationH2:: cartesian(int i, int j) const { return this->Ptr()->cartesian(i,j); } template < class R > inline typename Aff_transformationH2::RT Aff_transformationH2:: homogeneous(int i, int j) const { return this->Ptr()->homogeneous(i,j); } template < class R > Aff_transformation_repH2 Aff_transformationH2:: general_form() const { return this->Ptr()->general_form(); } template Aff_transformationH2 //operator*(const Aff_transformationH2& left_argument, // const Aff_transformationH2& right_argument ) Aff_transformationH2:: operator*(const Aff_transformationH2& right_argument) const { return _general_transformation_composition( this->Ptr()->general_form(), right_argument.Ptr()->general_form() ); } template Aff_transformationH2 _general_transformation_composition( Aff_transformation_repH2 l, Aff_transformation_repH2 r ) { return Aff_transformationH2( l.a*r.a + l.b*r.d, l.a*r.b + l.b*r.e, l.a*r.c + l.b*r.f + l.c*r.g, l.d*r.a + l.e*r.d, l.d*r.b + l.e*r.e, l.d*r.c + l.e*r.f + l.f*r.g, l.g*r.g ); } template < class R > typename Aff_transformation_repH2::RT Aff_transformation_repH2::homogeneous(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return a; case 1: return b; case 2: return c; } case 1: switch (j) { case 0: return d; case 1: return e; case 2: return f; } case 2: switch (j) { case 0: return RT(0); case 1: return RT(0); case 2: return g; } } return RT(0); } template < class R > typename Aff_transformation_repH2::FT Aff_transformation_repH2::cartesian(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); if ( (i == 2) && (j == 2) ) return FT(1); return FT(homogeneous(i,j)) / FT(g); } template < class R > typename Translation_repH2::RT Translation_repH2::homogeneous(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return _tv.hw(); case 1: return RT(0); case 2: return _tv.hx(); } case 1: switch (j) { case 0: return RT(0); case 1: return _tv.hw(); case 2: return _tv.hy(); } case 2: switch (j) { case 0: return RT(0); case 1: return RT(0); case 2: return _tv.hw(); } } return RT(0); } template < class R > typename Translation_repH2::FT Translation_repH2::cartesian(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return FT(1); case 1: return FT(0); case 2: return _tv.x(); } case 1: switch (j) { case 0: return FT(0); case 1: return FT(1); case 2: return _tv.y(); } case 2: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(1); } } return FT(0); } template < class R > typename Rotation_repH2::RT Rotation_repH2:: homogeneous(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return _cos; case 1: return - _sin; case 2: return RT(0); } case 1: switch (j) { case 0: return _sin; case 1: return _cos; case 2: return RT(0); } case 2: switch (j) { case 0: return RT(0); case 1: return RT(0); case 2: return _den; } } return RT(0); } template < class R > typename Rotation_repH2::FT Rotation_repH2:: cartesian(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return FT(_cos) / FT(_den); case 1: return - FT(_sin) / FT(_den); case 2: return RT(0); } case 1: switch (j) { case 0: return FT(_sin) / FT(_den); case 1: return FT(_cos) / FT(_den); case 2: return FT(0); } case 2: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(1); } } return FT(0); } template < class R > typename Scaling_repH2::RT Scaling_repH2:: homogeneous(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return _sf_num; case 1: return RT(0); case 2: return RT(0); } case 1: switch (j) { case 0: return RT(0); case 1: return _sf_num; case 2: return RT(0); } case 2: switch (j) { case 0: return RT(0); case 1: return RT(0); case 2: return _sf_den; } } return RT(0); } template typename Scaling_repH2::FT Scaling_repH2:: cartesian(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); switch (i) { case 0: switch (j) { case 0: return FT(_sf_num) / FT(_sf_den); case 1: return FT(0); case 2: return FT(0); } case 1: switch (j) { case 0: return FT(0); case 1: return FT(_sf_num) / FT(_sf_den); case 2: return FT(0); } case 2: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(1); } } return FT(0); } template < class R > typename Reflection_repH2::RT Reflection_repH2:: homogeneous(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); RT mRT2 = -RT(2); switch (i) { case 0: switch (j) { case 0: return l.b()*l.b() - l.a()*l.a(); case 1: return l.a()*l.b()*mRT2; case 2: return l.a()*l.c()*mRT2; } case 1: switch (j) { case 0: return l.a()*l.b()*mRT2; case 1: return l.a()*l.a() - l.b()*l.b(); case 2: return l.b()*l.c()*mRT2; } case 2: switch (j) { case 0: return RT(0); case 1: return RT(0); case 2: return l.a()*l.a() + l.b()*l.b(); } } return RT(0); } template typename Reflection_repH2::FT Reflection_repH2:: cartesian(int i, int j) const { CGAL_kernel_precondition( (i >= 0) && (i <= 2) && (j >= 0) && (j <= 2) ); FT de = FT( l.a()*l.a() + l.b()*l.b() ); switch (i) { case 0: switch (j) { case 0: return FT( l.b()-l.a() ) / FT( l.a()+l.b()); case 1: return FT( homogeneous(0,1)) / de; case 2: return FT( homogeneous(0,2)) / de; } case 1: switch (j) { case 0: return FT( homogeneous(1,0)) / de; case 1: return FT( l.a()-l.b() ) / FT( l.a()+l.b()); case 2: return FT( homogeneous(1,2)) / de; } case 2: switch (j) { case 0: return FT(0); case 1: return FT(0); case 2: return FT(1); } } return FT(0); } CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATIONH2_H ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Iso_cuboidH3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Iso_cuboid0000644000175000017500000002667611344301501031334 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Homogeneous/Iso_cuboidH3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_ISO_CUBOIDH3_H #define CGAL_ISO_CUBOIDH3_H #include CGAL_BEGIN_NAMESPACE template class Iso_cuboidH3 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Point_3 Point_3; typedef typename R_::Aff_transformation_3 Aff_transformation_3; typedef Twotuple Rep; typedef typename R_::template Handle::type Base; Base base; public: typedef R_ R; Iso_cuboidH3() {} Iso_cuboidH3(const Point_3& p, const Point_3& q); Iso_cuboidH3(const Point_3& left, const Point_3& right, const Point_3& bottom, const Point_3& top, const Point_3& far_, const Point_3& close); Iso_cuboidH3(const RT& min_hx, const RT& min_hy, const RT& min_hz, const RT& max_hx, const RT& max_hy, const RT& max_hz, const RT& hw); Iso_cuboidH3(const RT& min_hx, const RT& min_hy, const RT& min_hz, const RT& max_hx, const RT& max_hy, const RT& max_hz); bool operator==(const Iso_cuboidH3& s) const; bool operator!=(const Iso_cuboidH3& s) const; const Point_3 & min() const; const Point_3 & max() const; Point_3 vertex(int i) const; Point_3 operator[](int i) const; Iso_cuboidH3 transform(const Aff_transformation_3& t) const; Bounded_side bounded_side(const Point_3& p) const; bool has_on(const Point_3& p) const; bool has_on_boundary(const Point_3& p) const; bool has_on_bounded_side(const Point_3& p) const; bool has_on_unbounded_side(const Point_3& p) const; bool is_degenerate() const; Bbox_3 bbox() const; FT xmin() const; FT ymin() const; FT zmin() const; FT xmax() const; FT ymax() const; FT zmax() const; FT min_coord(int i) const; FT max_coord(int i) const; FT volume() const; }; template < class R > CGAL_KERNEL_LARGE_INLINE Iso_cuboidH3:: Iso_cuboidH3(const typename Iso_cuboidH3::Point_3& p, const typename Iso_cuboidH3::Point_3& q) { bool px_k_qx = ( p.hx()*q.hw() < q.hx()*p.hw() ); bool py_k_qy = ( p.hy()*q.hw() < q.hy()*p.hw() ); bool pz_k_qz = ( p.hz()*q.hw() < q.hz()*p.hw() ); RT minx; RT miny; RT minz; RT maxx; RT maxy; RT maxz; RT minw = p.hw()*q.hw(); RT maxw = p.hw()*q.hw(); if ( px_k_qx ) { minx = p.hx()*q.hw(); maxx = q.hx()*p.hw(); } else { minx = q.hx()*p.hw(); maxx = p.hx()*q.hw(); } if ( py_k_qy ) { miny = p.hy()*q.hw(); maxy = q.hy()*p.hw(); } else { miny = q.hy()*p.hw(); maxy = p.hy()*q.hw(); } if ( pz_k_qz ) { minz = p.hz()*q.hw(); maxz = q.hz()*p.hw(); } else { minz = q.hz()*p.hw(); maxz = p.hz()*q.hw(); } base = Rep(Point_3(minx, miny, minz, minw), Point_3(maxx, maxy, maxz, maxw)); } template < class R > CGAL_KERNEL_LARGE_INLINE Iso_cuboidH3:: Iso_cuboidH3(const typename Iso_cuboidH3::Point_3& left, const typename Iso_cuboidH3::Point_3& right, const typename Iso_cuboidH3::Point_3& bottom, const typename Iso_cuboidH3::Point_3& top, const typename Iso_cuboidH3::Point_3& far_, const typename Iso_cuboidH3::Point_3& close) : base(Point_3(left.hx() * bottom.hw() * far_.hw(), bottom.hy() * left.hw() * far_.hw(), far_.hz() * left.hw() * bottom.hw(), left.hw() * bottom.hw() * far_.hw()), Point_3(right.hx() * top.hw() * close.hw(), top.hy() * right.hw() * close.hw(), close.hz() * right.hw() * top.hw(), right.hw() * top.hw() * close.hw())) { CGAL_kernel_precondition(!less_x(right, left)); CGAL_kernel_precondition(!less_y(top, bottom)); CGAL_kernel_precondition(!less_z(close, far_)); } template < class R > CGAL_KERNEL_LARGE_INLINE Iso_cuboidH3:: Iso_cuboidH3(const RT& min_hx, const RT& min_hy, const RT& min_hz, const RT& max_hx, const RT& max_hy, const RT& max_hz) : base(Point_3(min_hx, min_hy, min_hz, RT(1)), Point_3(max_hx, max_hy, max_hz, RT(1))) {} template < class R > CGAL_KERNEL_LARGE_INLINE Iso_cuboidH3:: Iso_cuboidH3(const RT& min_hx, const RT& min_hy, const RT& min_hz, const RT& max_hx, const RT& max_hy, const RT& max_hz, const RT& hw) : base(Point_3(min_hx, min_hy, min_hz, hw), Point_3(max_hx, max_hy, max_hz, hw)) {} template < class R > CGAL_KERNEL_INLINE bool Iso_cuboidH3:: operator==(const Iso_cuboidH3& r) const { return (min() == r.min()) && (max() == r.max()); } template < class R > inline bool Iso_cuboidH3:: operator!=(const Iso_cuboidH3& r) const { return !(*this == r); } template < class R > inline const typename Iso_cuboidH3::Point_3 & Iso_cuboidH3::min() const { return get(base).e0; } template < class R > inline const typename Iso_cuboidH3::Point_3 & Iso_cuboidH3::max() const { return get(base).e1; } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::xmin() const { return FT( min().hx() ) / FT( min().hw() ); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::ymin() const { return FT( min().hy() ) / FT( min().hw() ); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::zmin() const { return FT( min().hz() ) / FT( min().hw() ); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::xmax() const { return FT( max().hx() ) / FT( max().hw() ); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::ymax() const { return FT( max().hy() ) / FT( max().hw() ); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::zmax() const { return FT( max().hz() ) / FT( max().hw() ); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::min_coord(int i) const { CGAL_kernel_precondition(i == 0 || i == 1 || i == 2); if ( i == 0 ) return xmin(); else if (i == 1) return ymin(); return zmin(); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::max_coord(int i) const { CGAL_kernel_precondition(i == 0 || i == 1 || i == 2); if ( i == 0 ) return xmax(); else if ( i == 1 ) return ymax(); return zmax(); } template < class R > inline typename Iso_cuboidH3::FT Iso_cuboidH3::volume() const { return (xmax() - xmin()) * (ymax() - ymin()) * (zmax() - zmin()); } template < class R > CGAL_KERNEL_LARGE_INLINE typename Iso_cuboidH3::Point_3 Iso_cuboidH3::vertex(int i) const { switch (i%8) { case 0: return min(); case 1: return Point_3( max().hx(), min().hy(), min().hz(), min().hw() ); case 2: return Point_3( max().hx(), max().hy(), min().hz(), min().hw() ); case 3: return Point_3( min().hx(), max().hy(), min().hz(), min().hw() ); case 4: return Point_3( min().hx(), max().hy(), max().hz(), min().hw() ); case 5: return Point_3( min().hx(), min().hy(), max().hz(), min().hw() ); case 6: return Point_3( max().hx(), min().hy(), max().hz(), min().hw() ); default: /*case 7:*/ return max(); } } template < class R > inline typename Iso_cuboidH3::Point_3 Iso_cuboidH3::operator[](int i) const { return vertex(i); } template < class R > CGAL_KERNEL_MEDIUM_INLINE Bounded_side Iso_cuboidH3:: bounded_side(const typename Iso_cuboidH3::Point_3& p) const { if ( (p.hx()*min().hw() < min().hx()*p.hw() ) ||(p.hy()*min().hw() < min().hy()*p.hw() ) ||(p.hz()*min().hw() < min().hz()*p.hw() ) ||(p.hx()*max().hw() > max().hx()*p.hw() ) ||(p.hy()*max().hw() > max().hy()*p.hw() ) ||(p.hz()*max().hw() > max().hz()*p.hw() ) ) { return ON_UNBOUNDED_SIDE; } if ( (p.hx()*min().hw() == min().hx()*p.hw() ) ||(p.hy()*min().hw() == min().hy()*p.hw() ) ||(p.hz()*min().hw() == min().hz()*p.hw() ) ||(p.hx()*max().hw() == max().hx()*p.hw() ) ||(p.hy()*max().hw() == max().hy()*p.hw() ) ||(p.hz()*max().hw() == max().hz()*p.hw() ) ) { return ON_BOUNDARY; } else { return ON_BOUNDED_SIDE; } } template < class R > inline bool Iso_cuboidH3:: has_on_boundary(const typename Iso_cuboidH3::Point_3& p) const { return ( bounded_side(p) == ON_BOUNDARY ); } template < class R > inline bool Iso_cuboidH3::has_on(const typename Iso_cuboidH3::Point_3& p) const { return ( bounded_side(p) == ON_BOUNDARY ); } template < class R > inline bool Iso_cuboidH3:: has_on_bounded_side(const typename Iso_cuboidH3::Point_3& p) const { return ( bounded_side(p) == ON_BOUNDED_SIDE ); } template < class R > CGAL_KERNEL_INLINE bool Iso_cuboidH3:: has_on_unbounded_side(const typename Iso_cuboidH3::Point_3& p) const { return ( ( lexicographically_xyz_smaller(p,min() )) ||( lexicographically_xyz_smaller(max(),p )) ); } template < class R > CGAL_KERNEL_INLINE bool Iso_cuboidH3::is_degenerate() const { return ( ( min().hx() == max().hx() ) || ( min().hy() == max().hy() ) || ( min().hz() == max().hz() ) ); } template < class R > inline Bbox_3 Iso_cuboidH3::bbox() const { return min().bbox() + max().bbox(); } template < class R > CGAL_KERNEL_INLINE Iso_cuboidH3 Iso_cuboidH3:: transform(const typename Iso_cuboidH3::Aff_transformation_3&t) const { return Iso_cuboidH3(t.transform(min() ), t.transform(max() ) ); } #ifndef CGAL_NO_OSTREAM_INSERT_ISO_CUBOIDH3 template < class R > std::ostream& operator<<(std::ostream& os, const Iso_cuboidH3& r) { switch(os.iword(IO::mode)) { case IO::ASCII : return os << r.min() << ' ' << r.max(); case IO::BINARY : return os << r.min() << r.max(); default: return os << "Iso_cuboidH3(" << r.min() << ", " << r.max() << ")"; } } #endif // CGAL_NO_OSTREAM_INSERT_ISO_CUBOIDH3 #ifndef CGAL_NO_ISTREAM_EXTRACT_ISO_CUBOIDH3 template < class R > std::istream& operator>>(std::istream& is, Iso_cuboidH3& r) { typename R::Point_3 p, q; is >> p >> q; r = Iso_cuboidH3(p, q); return is; } #endif // CGAL_NO_ISTREAM_EXTRACT_ISO_CUBOIDH3 CGAL_END_NAMESPACE #endif // CGAL_ISO_CUBOIDH3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/CORE_Expr.h0000644000175000017500000000477611344301500026735 0ustar debiandebian// Copyright (c) 2002-2004 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/CORE_Expr.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sylvain Pion #ifndef CGAL_CORE_EXPR_H #define CGAL_CORE_EXPR_H #include #include #include #include #ifdef CGAL_USE_GMPXX #include #endif #define CORE_LEVEL 4 #include CGAL_BEGIN_NAMESPACE template <> struct Number_type_traits { typedef Tag_false Has_gcd; typedef Tag_true Has_division; typedef Tag_true Has_sqrt; typedef Tag_true Has_exact_ring_operations; typedef Tag_true Has_exact_division; typedef Tag_true Has_exact_sqrt; }; inline double to_double(const CORE::Expr & e) { return e.doubleValue(); } inline CORE::Expr sqrt(const CORE::Expr & e) { return CORE::sqrt(e); } inline bool is_finite(const CORE::Expr &) { return true; } inline bool is_valid(const CORE::Expr &) { return true; } inline io_Operator io_tag(const CORE::Expr &) { return io_Operator(); } inline Sign sign(const CORE::Expr& e) { return (Sign) e.sign(); } inline Comparison_result compare(const CORE::Expr& e1, const CORE::Expr& e2) { return Comparison_result(e1.cmp(e2)); } // Should not be inline, but, well... inline std::pair to_interval (const CORE::Expr & e) { std::pair result; e.doubleInterval(result.first, result.second); CGAL_expensive_assertion(result.first <= e); CGAL_expensive_assertion(result.second >= e); return result; } CGAL_END_NAMESPACE #endif // CGAL_CORE_EXPR_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_cached_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_cached_tra0000644000175000017500000010142411344301500031350 0ustar debiandebian// Copyright (c) 1997 Tel-Aviv University (Israel). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Arr_segment_cached_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Ron Wein // Efi Fogel #ifndef CGAL_ARR_SEGMENT_CACHED_TRAITS_2_H #define CGAL_ARR_SEGMENT_CACHED_TRAITS_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Segment_cached_2; /*! * A traits class for maintaining an arrangement of segments, aoviding * cascading of computations as much as possible. */ template class Arr_segment_cached_traits_2 : public Kernel_ { public: typedef Kernel_ Kernel; typedef Tag_true Has_left_category; typedef Tag_false Has_reflect_category; /*! * Representation of a segement with cached data. */ class My_segment_cached_2 { typedef typename Kernel_::Line_2 Line_2; typedef typename Kernel_::Segment_2 Segment_2; typedef typename Kernel_::Point_2 Point_2; protected: Line_2 line; // The line that supports the segment. Point_2 ps, pt; // The source a target points. bool is_vert; // Is this a vertical segment. /*! * Default constructor. */ My_segment_cached_2 () : is_vert(false) {} /*! * Constructor from a segment. * \param seg The segment. */ My_segment_cached_2 (const Segment_2 & seg) { Kernel_ kernel; line = kernel.construct_line_2_object()(seg); is_vert = kernel.is_vertical_2_object()(seg); typename Kernel_::Construct_vertex_2 construct_vertex = kernel.construct_vertex_2_object(); ps = construct_vertex(seg, 0); pt = construct_vertex(seg, 1); } /*! * Construct a segment from two end-points. * \param source The source point. * \param target The target point. */ My_segment_cached_2 (const Point_2 & source, const Point_2 & target) : ps (source), pt (target) { Kernel_ kernel; line = kernel.construct_line_2_object()(source, target); is_vert = kernel.is_vertical_2_object()(line); } /*! * Construct a segment from two end-points on a supporting line. * \param l The supporting line. * \param source The source point. * \param target The target point. */ My_segment_cached_2 (const Line_2& l, const Point_2 & source, const Point_2 & target) : line (l), ps (source), pt (target) { Kernel_ kernel; CGAL_precondition (kernel.has_on_2_object() (line, source) && kernel.has_on_2_object() (line, target)); is_vert = kernel.is_vertical_2_object()(line); } /*! * Assignment operator. * \param seg the source segment to copy from */ const My_segment_cached_2& operator= (const Segment_2 & seg) { Kernel_ kernel; line = kernel.construct_line_2_object()(seg); is_vert = kernel.is_vertical_2_object()(seg); typename Kernel_::Construct_vertex_2 construct_vertex = kernel.construct_vertex_2_object(); ps = construct_vertex(seg, 0); pt = construct_vertex(seg, 1); return *this; } friend class Arr_segment_cached_traits_2; }; // Traits objects typedef typename Kernel::Point_2 Point_2; typedef Segment_cached_2 X_monotone_curve_2; typedef Segment_cached_2 Curve_2; // Backward compatability typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef X_monotone_curve_2 Curve; protected: // Functors: typedef typename Kernel::Less_x_2 Less_x_2; typedef typename Kernel::Equal_2 Equal_2; typedef typename Kernel::Compare_x_2 Compare_x_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Compare_xy_2 Compare_xy_2; typedef typename Kernel::Compare_slope_2 Compare_slope_2; typedef typename Kernel::Has_on_2 Has_on_2; public: #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Kernel::compare_xy_2_object; using Kernel::compare_x_2_object; using Kernel::compare_y_2_object; using Kernel::compare_y_at_x_2_object; using Kernel::is_vertical_2_object; using Kernel::has_on_2_object; using Kernel::compare_slope_2_object; using Kernel::equal_2_object; using Kernel::intersect_2_object; using Kernel::construct_line_2_object; #endif /*! * Default constructor. */ Arr_segment_cached_traits_2() {} // Operations // ---------- /*! * Compare the x-coordinates of two given points. * \param p1 The first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL. */ Comparison_result compare_x(const Point_2 & p1, const Point_2 & p2) const { return (compare_x_2_object()(p1, p2)); } /*! * Compares lexigoraphically the two points: by x, then by y. * \param p1 Te first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL. */ Comparison_result compare_xy(const Point_2 & p1, const Point_2 & p2) const { return (compare_xy_2_object()(p1, p2)); } /*! * Check whether the given curve is a vertical segment. * \param cv The curve. * \return (true) if the curve is vertical. */ bool curve_is_vertical(const X_monotone_curve_2 & cv) const { return (cv.is_vert); } /*! * Check whether the given point is in the x-range of the given curve. * In out case, the curve is a segment [s, t], check whether x(s)<=x(q)<=x(t) * or whether x(t)<=x(q)<=x(s). * \param cv The curve. * \param q The point. * \return (true) if q is in the x-range of cv. */ bool point_in_x_range(const X_monotone_curve_2 & cv, const Point_2 & q) const { Compare_x_2 compare_x = compare_x_2_object(); Comparison_result res1 = compare_x (q, cv.ps); if (cv.is_vert) // Special check for vertical segments. return (res1 == EQUAL); Comparison_result res2 = compare_x (q, cv.pt); // We check if x(p) equals the x value of one of the end-points. // If not, we check whether one end-point is to p's left and the other is // to its right. return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); } /*! * Get the relative status of two curves at the x-coordinate of a given * point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x-range of the two curves. * \return LARGER if cv1(x(q)) > cv2(x(q)); SMALLER if cv1(x(q)) < cv2(x(q)); * or else EQUAL. */ Comparison_result curves_compare_y_at_x(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { CGAL_precondition(point_in_x_range(cv1, q)); CGAL_precondition(point_in_x_range(cv2, q)); // Special treatment for vertical segments: // In case one curve is a vertical segment, return EQUAL if it intersects // with the other segment, otherwise return LARGER or SMALLER. if (cv1.is_vert) { if (cv2.is_vert) { // Compare two vertical segments. Compare_y_2 compare_y = compare_y_2_object(); Comparison_result res1 = compare_y (cv1.ps, cv1.pt); const Point_2 & lower1 = (res1 == SMALLER) ? cv1.ps : cv1.pt; const Point_2 & upper1 = (res1 == SMALLER) ? cv1.pt : cv1.ps; Comparison_result res2 = compare_y (cv2.ps, cv2.pt); const Point_2 & lower2 = (res2 == SMALLER) ? cv2.ps : cv2.pt; const Point_2 & upper2 = (res2 == SMALLER) ? cv2.pt : cv2.ps; if (compare_y(upper1, lower2) == SMALLER) // cv1 is entirely below cv2: return (SMALLER); else if (compare_y(lower1, upper2) == LARGER) // cv1 is entirely above cv2: return (LARGER); else // cv1 intersects cv2: return (EQUAL); } // Only cv1 is vertical: Comparison_result res1 = compare_y_at_x_2_object()(cv1.ps,cv2.line); Comparison_result res2 = compare_y_at_x_2_object()(cv1.pt,cv2.line); if (res1 == res2) { CGAL_assertion(res1 != EQUAL); return (res1); } else return (EQUAL); } else if (cv2.is_vert) { // Only cv2 is vertical: Comparison_result res1 = compare_y_at_x_2_object()(cv2.ps,cv1.line); Comparison_result res2 = compare_y_at_x_2_object()(cv2.pt,cv1.line); if (res1 == res2) { CGAL_assertion(res1 != EQUAL); return ((res1 == LARGER) ? SMALLER : LARGER); } else return (EQUAL); } // Compare using the supporting lines. return (compare_y_at_x_2_object()(q, cv1.line, cv2.line)); } /*! * Compares the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its left. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the left of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_left(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curve must be defined at q and also to its left. CGAL_precondition_code(Compare_xy_2 cmp_xy = compare_xy_2_object();); CGAL_precondition((cmp_xy(cv1.ps, q) == SMALLER) || (cmp_xy(cv1.pt, q) == SMALLER)); CGAL_precondition((cmp_xy(cv1.ps, q) != SMALLER) || (cmp_xy(cv1.pt, q) != SMALLER)); CGAL_precondition((cmp_xy(cv2.ps, q) == SMALLER) || (cmp_xy(cv2.pt, q) == SMALLER)); CGAL_precondition((cmp_xy(cv2.ps, q) != SMALLER) || (cmp_xy(cv2.pt, q) != SMALLER)); // Notice q is a placeholder for the x coordinate of the two segments. // That is, if we compare them at x(q) the result should be EQUAL. CGAL_precondition((is_vertical_2_object()(cv1.line) && has_on_2_object()(cv1.line, q)) || (is_vertical_2_object()(cv2.line) && has_on_2_object()(cv2.line, q)) || (compare_y_at_x_2_object()(q, cv1.line, cv2.line) == EQUAL)); // Compare the slopes of the two segments to determine thir relative // position immediately to the left of q. // Notice we use the supporting lines in order to compare the slopes. return (compare_slope_2_object()(cv2.line, cv1.line)); } /*! * Compares the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its right. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the right of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_right(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // The two curve must be defined at q and also to its right. CGAL_precondition_code(Compare_xy_2 cmp_xy = compare_xy_2_object();); CGAL_precondition((cmp_xy(q, cv1.ps) == SMALLER) || (cmp_xy(q, cv1.pt) == SMALLER)); CGAL_precondition((cmp_xy(q, cv1.ps) != SMALLER) || (cmp_xy(q, cv1.pt) != SMALLER)); CGAL_precondition((cmp_xy(q, cv2.ps) == SMALLER) || (cmp_xy(q, cv2.pt) == SMALLER)); CGAL_precondition((cmp_xy(q, cv2.ps) != SMALLER) || (cmp_xy(q, cv2.pt) != SMALLER)); // Notice q is a placeholder for the x coordinate of the two segments. // That is, if we compare them at x(q) the result should be EQUAL. CGAL_precondition((is_vertical_2_object()(cv1.line) && has_on_2_object()(cv1.line, q)) || (is_vertical_2_object()(cv2.line) && has_on_2_object()(cv2.line, q)) || (compare_y_at_x_2_object()(q, cv1.line, cv2.line) == EQUAL)); // Compare the slopes of the two segments to determine thir relative // position immediately to the right of q. // Notice we use the supporting lines in order to compare the slopes. return (compare_slope_2_object()(cv1.line, cv2.line)); } /*! * Return the location of the given point with respect to the input curve. * \param cv The curve. * \param p The point. * \pre p is in the x-range of cv. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x(const Point_2 & p, const X_monotone_curve_2 & cv) const { CGAL_precondition(point_in_x_range(cv, p)); if (! cv.is_vert) { // Compare with the supporting line. return compare_y_at_x_2_object()(p, cv.line); } else { // Compare with the vertical segment's end-points. Compare_y_2 compare_y = compare_y_2_object(); Comparison_result res1 = compare_y (p, cv.ps); Comparison_result res2 = compare_y (p, cv.pt); if (res1 == res2) return (res1); else return (EQUAL); } } /*! * Check if the two curves are the same (have the same graph). * \param cv1 The first curve. * \param cv2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { Equal_2 equal = equal_2_object(); return ((equal(cv1.ps, cv2.ps) && equal(cv1.pt, cv2.pt)) || (equal(cv1.ps, cv2.pt) && equal(cv1.pt, cv2.ps))); } /*! * Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal(const Point_2 & p1, const Point_2 & p2) const { return (equal_2_object()(p1, p2)); } /*! * Get the curve source. * \param cv The curve. * \return The source point. */ const Point_2 & curve_source(const X_monotone_curve_2 & cv) const { return (cv.ps); } /*! * Get the curve target. * \param cv The curve. * \return The target point. */ const Point_2 & curve_target(const X_monotone_curve_2 & cv) const { return (cv.pt); } /*! * Check whether the curve is x-monotone. * \param cv The curves. * \return (true) if the curve is x-monotone. In case of segments, the * function always returns (true), since all segments are x-monotone. * Vertical segments are also considered as 'weakly' x-monotone. */ bool is_x_monotone(const Curve_2 &) const { // Return true, since a sgement is always x-monotone. return (true); } /*! * Cut the given curve into x-monotone subcurves and insert them to the * given output iterator. While segments are x_monotone, still need to pass * them out. * \param cv The curve. * \param o The output iterator * \return The past-the-end iterator */ template OutputIterator curve_make_x_monotone(const Curve_2 & cv, OutputIterator o) const { *o++ = cv; return o; } /*! * Flip a given curve. * \param cv The input curve. * \return The flipped curve. In case of segments, if the input is [s,t], * then the flipped curve is simply [t,s]. */ X_monotone_curve_2 curve_opposite(const X_monotone_curve_2 & cv) const { X_monotone_curve_2 flip_cv(cv); flip_cv.ps = cv.pt; flip_cv.pt = cv.ps; return (flip_cv); } /*! * Split a given curve at a given split point into two sub-curves. * \param cv the curve to split * \param c1 the output first part of the split curve. Its source is the * source of the original curve. * \param c2 the output second part of the split curve. Its target is the * target of the original curve. * \param p the split point. * \pre p lies on cv but is not one of its end-points. */ void curve_split(const X_monotone_curve_2 & cv, X_monotone_curve_2 & c1, X_monotone_curve_2 & c2, const Point_2 & p) const { // Check preconditions. CGAL_precondition(curve_compare_y_at_x(p, cv) == EQUAL); CGAL_precondition_code(Equal_2 is_equal = equal_2_object()); CGAL_precondition(!is_equal(cv.ps, p)); CGAL_precondition(!is_equal(cv.pt, p)); // Do the split. c1.line = cv.line; c1.ps = cv.ps; c1.pt = p; c1.is_vert = cv.is_vert; c2.line = cv.line; c2.ps = p; c2.pt = cv.pt; c2.is_vert = cv.is_vert; return; } /*! * Find the nearest intersection of the two given curves to the right of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the right of the reference point (that is, whose * left endpoint is the projection of the reference point onto the * overlapping subcurve). * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the right of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_right (const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & p) const { Point_2 p1, p2; bool is_overlap; // Return an empty object if there is no intersection. if (! _find_intersection (cv1, cv2, is_overlap, p1, p2)) return Object(); // Check if there is a single intersection point. if (! is_overlap) { // Return the point if it is lexicographically to the right of p. if (compare_xy_2_object()(p1, p) == LARGER) return (CGAL::make_object (p1)); return Object(); } // In case the intersection is an overlapping segment [p1, p2] // (notice that p1 < p2): if (compare_xy_2_object()(p1, p) == LARGER) { // The entire segment p1 -> p2 is to the right of p: return (CGAL::make_object (X_monotone_curve_2 (cv1.line, p1, p2))); } else if (compare_xy_2_object()(p2, p) == LARGER) { if (has_on_2_object() (cv1.line, p)) { // p is one the overlapping segment, return it as the first point. p1 = p; } else { // Perform vertical ray-shooting from p to the overlapping segment // and make p1 the resulting point. _vertical_ray_shoot (p, cv1, p1); } // If after the trimming we have p1 == p2, return just a single point. if (equal_2_object() (p1, p2)) return (CGAL::make_object (p1)); // Return the segment p1 -> p2. return (CGAL::make_object (X_monotone_curve_2 (cv1.line, p1, p2))); } // The overlap is entirely to the left of p: return Object(); } /*! * Find the nearest intersection of the two given curves to the left of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the left of the reference point (that is, whose * right endpoint is the projection of the reference point onto the * overlapping subcurve). * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the left of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_left (const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & p) const { Point_2 p1, p2; bool is_overlap; // Return an empty object if there is no intersection. if (! _find_intersection (cv1, cv2, is_overlap, p1, p2)) return Object(); // Check if there is a single intersection point. if (! is_overlap) { // Return the point if it is lexicographically to the left of p. if (compare_xy_2_object()(p1, p) == SMALLER) return (CGAL::make_object (p1)); return Object(); } // In case the intersection is an overlapping segment [p1, p2] // (notice that p1 < p2): if (compare_xy_2_object()(p2, p) == SMALLER) { // The entire segment p1 -> p2 is to the left of p: return (CGAL::make_object (X_monotone_curve_2 (cv1.line, p1, p2))); } else if (compare_xy_2_object()(p1, p) == SMALLER) { if (has_on_2_object() (cv1.line, p)) { // p is one the overlapping segment, return it as the first point. p2 = p; } else { // Perform vertical ray-shooting from p to the overlapping segment // and make p2 the resulting point. _vertical_ray_shoot (p, cv1, p2); } // If after the trimming we have p1 == p2, return just a single point. if (equal_2_object() (p1, p2)) return (CGAL::make_object (p1)); // Return the segment p1 -> p2. return (CGAL::make_object (X_monotone_curve_2 (cv1.line, p1, p2))); } // The overlap is entirely to the right of p: return Object(); } /*! * Check whether the two given curves overlap. * \patam cv1 The first curve. * \patam cv2 The second curve. * \return (true) if the two curves overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, if they have a finite * number of intersection points, or none at all, return (false). */ bool curves_overlap(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2) const { // Comparing lines // if (!equal_2_object()(cv1.line, cv2.line)) return false; // doesn't work, as coincident lines with opposite direction are // considered different! Has_on_2 has_on = has_on_2_object(); if (!has_on(cv1.line, cv2.ps) || !has_on(cv1.line, cv2.pt)) return false; if (cv1.is_vert) { if (cv2.is_vert) { Compare_y_2 compare_y = compare_y_2_object(); Comparison_result res_ss = compare_y (cv1.ps, cv2.ps); Comparison_result res_st = compare_y (cv1.ps, cv2.pt); if (res_ss == SMALLER) { if (res_st == LARGER) return true; if (compare_y (cv1.pt, cv2.ps) == LARGER) return true; return (compare_y (cv1.pt, cv2.pt) == LARGER); } if (res_ss == LARGER) { if (res_st == SMALLER) return true; if (compare_y (cv1.pt, cv2.ps) == SMALLER) return true; return (compare_y (cv1.pt, cv2.pt) == SMALLER); } // res_ss == EQUAL if (res_st == SMALLER) return (compare_y (cv1.pt, cv2.ps) == LARGER); return (compare_y (cv1.pt, cv2.ps) == SMALLER); } return false; } if (cv2.is_vert) return false; Compare_x_2 compare_x = compare_x_2_object(); Comparison_result res_ss = compare_x (cv1.ps, cv2.ps); Comparison_result res_st = compare_x (cv1.ps, cv2.pt); if (res_ss == SMALLER) { if (res_st == LARGER) return true; if (compare_x (cv1.pt, cv2.ps) == LARGER) return true; return (compare_x (cv1.pt, cv2.pt) == LARGER); } if (res_ss == LARGER) { if (res_st == SMALLER) return true; if (compare_x (cv1.pt, cv2.ps) == SMALLER) return true; return (compare_x (cv1.pt, cv2.pt) == SMALLER); } // res_ss == EQUAL if (res_st == SMALLER) return (compare_x (cv1.pt, cv2.ps) == LARGER); return (compare_x (cv1.pt, cv2.ps) == SMALLER); } private: /*! * Find the intersection between teo segements. * \param cv1 The first segment. * \param cv2 The second segment. * \param is_ovelap Are the two segment overlapping. * \param p1 The intersection point (if there is no overlap), * otherwise the leftmost end-point of the intersection segment. * \param p2 If there is an overlap, the rightmost end-point of the * intersection segment. * \return (true) if an intersection has been found. */ bool _find_intersection (const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, bool & is_overlap, Point_2 & p1, Point_2 & p2) const { // Computing the orientation ahead and checking whether the end points of // one curve are in opposite orientations with respect to the other seems // slow down the process! // Intersect the two supporting lines. Object res = intersect_2_object()(cv1.line, cv2.line); // Parallel lines do not intersect if (res.is_empty()) return (false); Point_2 ip; if (assign(ip, res)) { is_overlap = false; // Simple case of intersection at a single point. if (_is_on_segment(cv1, ip) && _is_on_segment(cv2, ip)) { p1 = ip; return (true); } return (false); } else // The two supporting lines overlap. { // Assign the end-points such that p1 < p2. Compare_xy_2 comp_xy = compare_xy_2_object(); if (comp_xy(cv1.ps, cv1.pt) == SMALLER) { p1 = cv1.ps; p2 = cv1.pt; } else { p1 = cv1.pt; p2 = cv1.ps; } // Clip the first segment with respect to cv2. Comparison_result res = comp_xy(cv2.ps, cv2.pt); const Point_2 & left2 = (res == SMALLER) ? cv2.ps : cv2.pt; const Point_2 & right2 = (res == LARGER) ? cv2.ps : cv2.pt; if (comp_xy(p2, left2) == SMALLER) return (false); else if (comp_xy(p1, left2) == SMALLER) p1 = left2; if (comp_xy(p1, right2) == LARGER) return (false); else if (comp_xy(p2, right2) == LARGER) p2 = right2; // Check if the intersection segment has not become a point. is_overlap = (comp_xy(p1,p2) != EQUAL); CGAL_assertion(comp_xy(p1,p2) != LARGER); return (true); } } /*! * Check whether the given point lies on the given segment. * \param cv The curve. * \param q The point. * \pre The function assumes q lies on the supporting line of the segment. * \return (true) if q lies of cv. */ bool _is_on_segment (const X_monotone_curve_2 & cv, const Point_2 & q) const { if (! cv.is_vert) { Compare_x_2 comp_x = compare_x_2_object(); Comparison_result res1 = comp_x (q, cv.ps); Comparison_result res2 = comp_x (q, cv.pt); // We check if x(q) equals the x value of one of the end-points. // If not, we check whether one end-point is to q's left and the other is // to its right. return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); } else { Compare_y_2 comp_y = compare_y_2_object(); Comparison_result res1 = comp_y (q, cv.ps); Comparison_result res2 = comp_y (q, cv.pt); // We check if x(q) equals the y value of one of the end-points. // If not, we check whether one end-point is above q and the other is // below it. return ((res1 == EQUAL) || (res2 == EQUAL) || (res1 != res2)); } } /*! * Perform vertical ray-shooting from a given point towards a given curve. * \param q The source point of the ray. * \param cv The target curve. * \param p The resulting point. * \return Whether we have successfully computed a point p. */ bool _vertical_ray_shoot (const Point_2& q, const X_monotone_curve_2& cv, Point_2& p) const { // Construct a vertical line passing through q. typename Kernel::Direction_2 dir (0, 1); typename Kernel::Line_2 vl = construct_line_2_object() (q, dir); // Compute the intersetion between the vertical line and the line // supporting the curve cv. Object res = intersect_2_object()(cv.line, vl); bool ray_shoot_successful = assign(p, res); CGAL_assertion (ray_shoot_successful); return (ray_shoot_successful); } }; /*! * A representation of a segment, as used by the Arr_segment_cached_traits_2 * traits class. */ template class Segment_cached_2 : public Arr_segment_cached_traits_2::My_segment_cached_2 { typedef typename Arr_segment_cached_traits_2::My_segment_cached_2 Base; typedef typename Kernel_::Segment_2 Segment_2; typedef typename Kernel_::Point_2 Point_2; typedef typename Kernel_::Line_2 Line_2; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 public: using Base::ps; using Base::pt; #endif public: /*! * Default constructor. */ Segment_cached_2 () : Base() {} /*! * Constructor from a segment. * \param seg The segment. */ Segment_cached_2 (const Segment_2 & seg) : Base(seg) {} /*! * Construct a segment from two end-points. * \param source The source point. * \param target The target point. */ Segment_cached_2 (const Point_2 & source, const Point_2 & target) : Base(source,target) {} /*! * Construct a segment from a line and two end-points. * \param line The supporting line. * \param source The source point. * \param target The target point. * \pre Both source and target must be on the supporting line. */ Segment_cached_2 (const Line_2 & line, const Point_2 & source, const Point_2 & target) : Base(line,source,target) {} /*! * Cast to a segment. */ operator Segment_2 () const { return (Segment_2(ps, pt)); } /*! * Create a bounding box for the segment. */ Bbox_2 bbox() const { Segment_2 seg(ps, pt); return (seg.bbox()); } /*! * Get the segment source. */ const Point_2 & source() const { return ps; } /*! * Get the segment target. */ const Point_2 & target() const { return pt; } }; /*! * Exporter for a cached segment. */ template Stream_ & operator<<(Stream_ & os, const Segment_cached_2 & seg) { os << static_cast(seg); return (os); } /*! * Importer for a cached segment. */ template Stream_ & operator>>(Stream_ & is, Segment_cached_2 & seg) { typename Kernel_::Segment_2 kernel_seg; is >> kernel_seg; seg = kernel_seg; return is; } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/point_generators_d.h0000644000175000017500000000441311344301500031060 0ustar debiandebian// Copyright (c) 1997 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/point_generators_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL_POINT_GENERATORS_D_H #define CGAL_POINT_GENERATORS_D_H 1 #include #include #include CGAL_BEGIN_NAMESPACE template < class P> class Random_points_in_iso_box_d : public Generator_base

    { void generate_point(); typedef Counting_iterator N_Random_double_iterator; typedef Creator_uniform_d Creator; int d; Random_double_in_interval rdii; typedef Random_points_in_iso_box_d

    This; public: Random_points_in_iso_box_d() {} Random_points_in_iso_box_d(int dim, double a = 1, Random& rnd = default_random) : Generator_base

    (a), d(dim), rdii(a, rnd) { generate_point(); } This& operator++() { generate_point(); return *this; } This operator++(int) { This tmp = *this; ++(*this); return tmp; } }; template < class P> void Random_points_in_iso_box_d

    :: generate_point() { Creator creator(d); rdii++; this->d_item = creator( N_Random_double_iterator(rdii), N_Random_double_iterator(d)); } CGAL_END_NAMESPACE #endif // CGAL_POINT_GENERATORS_D_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/IEEE_754_unions.h0000644000175000017500000000440311344301500027673 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/IEEE_754_unions.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Stefan Schirra #ifndef CGAL_IEEE_754_UNIONS_H #define CGAL_IEEE_754_UNIONS_H #include union IEEE_754_double { double a; #ifdef CGAL_BIG_ENDIAN struct { unsigned sign : 1; unsigned exp :11; unsigned high :20; unsigned low :32; } b; struct { unsigned H :32; unsigned L :32; } c; #else struct { unsigned low :32; unsigned sign : 1; unsigned exp :11; unsigned high :20; } b; struct { unsigned L :32; unsigned H :32; } c; #endif }; union IEEE_754_float { float a; struct { unsigned sign : 1; unsigned exp : 8; unsigned high :23; } b; unsigned c; }; inline void show( IEEE_754_double* p) { std::cout << std::endl; std::cout << std::hex << std::setw(8) << std::setfill('0') << p->c.H; std::cout << ' '; std::cout << std::hex << std::setw(8) << std::setfill('0') << p->c.L; std::cout << std::endl; } inline void show( IEEE_754_float* p) { std::cout << std::endl; std::cout << std::hex << std::setw(8) << std::setfill('0') << p->c; std::cout << std::endl; } #endif // CGAL_IEEE_754_UNIONS_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_identity.h0000644000175000017500000001041311344301500031210 0ustar debiandebian// Copyright (c) 2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Circulator_identity.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann // Lutz Kettner // Sylvain Pion #ifndef CGAL_CIRCULATOR_IDENTITY_H #define CGAL_CIRCULATOR_IDENTITY_H 1 #include CGAL_BEGIN_NAMESPACE template < class C, class Ref = typename C::reference, class Ptr = typename C::pointer> class Circulator_identity { protected: C nt; // The internal circulator. public: typedef C Circulator; typedef Circulator_identity Self; typedef typename C::iterator_category iterator_category; typedef typename C::value_type value_type; typedef typename C::difference_type difference_type; typedef typename C::size_type size_type; typedef typename C::reference reference; typedef typename C::pointer pointer; // CREATION // -------- Circulator_identity() {} Circulator_identity( Circulator j) : nt(j) {} // OPERATIONS Forward Category // --------------------------- Circulator current_circulator() const { return nt;} bool operator==( CGAL_NULL_TYPE p) const { CGAL_assertion( p == 0); return ( nt == 0); //###// } bool operator!=( CGAL_NULL_TYPE p) const { return !(*this == p); } bool operator==( const Self& i) const { return ( nt == i.nt); //###// } bool operator!=( const Self& i) const { return !(*this == i); } Ref operator*() const { return *nt; //###// } Ptr operator->() const { return nt.operator->(); //###// } Self& operator++() { ++nt; //###// return *this; } Self operator++(int) { Self tmp = *this; ++*this; return tmp; } // OPERATIONS Bidirectional Category // --------------------------------- Self& operator--() { --nt; //###// return *this; } Self operator--(int) { Self tmp = *this; --*this; return tmp; } // OPERATIONS Random Access Category // --------------------------------- Self min_circulator() const { return Self( nt.min_circulator()); //###// } Self& operator+=( difference_type n) { nt += n; //###// return *this; } Self operator+( difference_type n) const { Self tmp = *this; return tmp += n; } Self& operator-=( difference_type n) { return operator+=( -n); } Self operator-( difference_type n) const { Self tmp = *this; return tmp += -n; } difference_type operator-( const Self& i) const { return nt - i.nt; //###// } Ref operator[]( difference_type n) const { Self tmp = *this; tmp += n; return tmp.operator*(); } }; template < class Dist, class C, class Ref, class Ptr> inline Circulator_identity operator+( Dist n, Circulator_identity i) { return i += n; } CGAL_END_NAMESPACE #endif // CGAL_CIRCULATOR_IDENTITY_H // // EOF // mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/intersections_d.h0000644000175000017500000002275011344301500030373 0ustar debiandebian// Copyright (c) 2000,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/intersections_d.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_INTERSECTIONS_D_H #define CGAL_INTERSECTIONS_D_H #include CGAL_BEGIN_NAMESPACE // Actually, we should better list the compilers which are inferior, i.e. // the others, which need the additional useless code. #if !defined(__KCC) && !defined(__BORLANDC__) && !defined(__PGI) # define CGAL_REMOVE_FLOW_WARNING #endif template Object intersection(const Line_d& l1, const Line_d& l2) { typedef typename R::Line_d_Line_d_pair ll_pair; ll_pair LL(l1, l2); switch (LL.intersection_type()) { case ll_pair::NO: default: return Object(); case ll_pair::POINT: { Point_d pt; LL.intersection(pt); return make_object(pt); } case ll_pair::LINE: return make_object(l1); } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Ray_d& l1, const Ray_d& l2) { typedef typename R::Ray_d_Ray_d_pair ll_pair; ll_pair LL(l1,l2); switch (LL.intersection_type()) { case ll_pair::NO: default: return Object(); case ll_pair::POINT: { Point_d p; LL.intersection(p); return make_object(p); } case ll_pair::RAY: { Ray_d r; LL.intersection(r); return make_object(r); } case ll_pair::SEGMENT: { Segment_d s; LL.intersection(s); return make_object(s); } } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Segment_d& l1, const Segment_d& l2) { typedef typename R::Segment_d_Segment_d_pair ll_pair; ll_pair LL(l1,l2); switch (LL.intersection_type()) { case ll_pair::NO: default: return Object(); case ll_pair::POINT: { Point_d p; LL.intersection(p); return make_object(p); } case ll_pair::SEGMENT: { Segment_d s; LL.intersection(s); return make_object(s); } } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Line_d& l, const Ray_d& r) { typedef typename R::Line_d_Ray_d_pair lr_pair; lr_pair LR(l,r); switch (LR.intersection_type()) { case lr_pair::NO: default: return Object(); case lr_pair::POINT: { Point_d pt; LR.intersection(pt); return make_object(pt); } case lr_pair::RAY: { return make_object(r); } } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Ray_d& r, const Line_d& l) { return intersection(l,r); } template Object intersection(const Ray_d& r, const Segment_d& s) { typedef typename R::Ray_d_Segment_d_pair rs_pair; rs_pair RS(r,s); switch (RS.intersection_type()) { case rs_pair::NO: default: return Object(); case rs_pair::POINT: { Point_d pt; RS.intersection(pt); return make_object(pt); } case rs_pair::SEGMENT: { Segment_d st; RS.intersection(st); return make_object(st); } } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Segment_d& s, const Ray_d& r) { return intersection(r,s); } template Object intersection(const Line_d& l, const Segment_d& s) { typedef typename R::Line_d_Segment_d_pair rs_pair; rs_pair RS(l,s); switch (RS.intersection_type()) { case rs_pair::NO: default: return Object(); case rs_pair::POINT: { Point_d pt; RS.intersection(pt); return make_object(pt); } case rs_pair::SEGMENT: { Segment_d st; RS.intersection(st); return make_object(st); } } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Segment_d& s, const Line_d& l) { return intersection(l,s); } template Object intersection(const Line_d& l, const Hyperplane_d& h) { typedef typename R::Line_d_Hyperplane_d_pair lh_pair; lh_pair LH(l,h); switch (LH.intersection_type()) { case lh_pair::NO: default: return Object(); case lh_pair::POINT: { Point_d pt; LH.intersection(pt); return make_object(pt); } case lh_pair::LINE: return make_object(l); } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Hyperplane_d& h, const Line_d& l) { return intersection(l,h); } template Object intersection(const Ray_d& r, const Hyperplane_d& h) { typedef typename R::Ray_d_Hyperplane_d_pair rh_pair; rh_pair RH(r,h); switch (RH.intersection_type()) { case rh_pair::NO: default: return Object(); case rh_pair::POINT: { Point_d pt; RH.intersection(pt); return make_object(pt); } case rh_pair::RAY: return make_object(r); } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Hyperplane_d& h, const Ray_d& r) { return intersection(r,h); } template Object intersection(const Segment_d& s, const Hyperplane_d& h) { typedef typename R::Segment_d_Hyperplane_d_pair sh_pair; sh_pair SH(s,h); switch (SH.intersection_type()) { case sh_pair::NO: default: return Object(); case sh_pair::POINT: { Point_d pt; SH.intersection(pt); return make_object(pt); } case sh_pair::SEGMENT: return make_object(s); } #ifdef CGAL_REMOVE_FLOW_WARNING return Object(); // never reached #endif } template Object intersection(const Hyperplane_d& h, const Segment_d& s) { return intersection(s,h); } template inline bool do_intersect(const Line_d &l1, const Line_d &l2) { typedef typename R::Line_d_Line_d_pair ll_pair; ll_pair LL(l1,l2); return LL.intersection_type() != ll_pair::NO; } template inline bool do_intersect(const Ray_d &l1, const Ray_d &l2) { typedef typename R::Ray_d_Ray_d_pair ll_pair; ll_pair LL(l1,l2); return LL.intersection_type() != ll_pair::NO; } template inline bool do_intersect(const Segment_d &l1, const Segment_d &l2) { typedef typename R::Segment_d_Segment_d_pair ll_pair; ll_pair LL(l1,l2); return LL.intersection_type() != ll_pair::NO; } template inline bool do_intersect(const Line_d& l, const Ray_d& r) { typedef typename R::Line_d_Ray_d_pair lr_pair; lr_pair LR(l,r); return LR.intersection_type() != lr_pair::NO; } template inline bool do_intersect(const Ray_d& r, const Line_d& l) { return do_intersect(l,r); } template inline bool do_intersect(const Line_d& l, const Segment_d& s) { typedef typename R::Line_d_Segment_d_pair ls_pair; ls_pair LS(l,s); return LS.intersection_type() != ls_pair::NO; } template inline bool do_intersect(const Segment_d& s, const Line_d& l) { return do_intersect(l,s); } template inline bool do_intersect(const Ray_d& r, const Segment_d& s) { typedef typename R::Ray_d_Segment_d_pair rs_pair; rs_pair RS(r,s); return RS.intersection_type() != rs_pair::NO; } template inline bool do_intersect(const Segment_d& s, const Ray_d& r) { return do_intersect(r,s); } template inline bool do_intersect(const Line_d& l, const Hyperplane_d& h) { typedef typename R::Line_d_Hyperplane_d_pair lh_pair; lh_pair LH(l,h); return LH.intersection_type() != lh_pair::NO; } template inline bool do_intersect(const Hyperplane_d& h, const Line_d& l) { return do_intersect(l,h); } template inline bool do_intersect(const Ray_d& r, const Hyperplane_d& h) { typedef typename R::Ray_d_Hyperplane_d_pair rh_pair; rh_pair RH(r,h); return RH.intersection_type() != rh_pair::NO; } template inline bool do_intersect(const Hyperplane_d& h, const Ray_d& r) { return do_intersect(r,h); } template inline bool do_intersect(const Segment_d& s, const Hyperplane_d& h) { typedef typename R::Segment_d_Hyperplane_d_pair sh_pair; sh_pair SH(s,h); return SH.intersection_type() != sh_pair::NO; } template inline bool do_intersect(const Hyperplane_d& h, const Segment_d& s) { return do_intersect(s,h); } CGAL_END_NAMESPACE #endif //CGAL_INTERSECTIONS_D_H ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_cell_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_cell_base_0000644000175000017500000000674711344301500031316 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_cell_base_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_ALPHA_SHAPE_CELL_BASE_3_H #define CGAL_ALPHA_SHAPE_CELL_BASE_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template < class NT> class Alpha_status : public Compact_container_base { private: bool _is_Gabriel; bool _is_on_chull; NT _alpha_min; NT _alpha_mid; NT _alpha_max; public: Alpha_status() : _is_Gabriel(false), _is_on_chull(false) {} void set_alpha_min(NT alpha) {_alpha_min = alpha;} void set_alpha_mid(NT alpha) {_alpha_mid = alpha;} void set_alpha_max(NT alpha) {_alpha_max = alpha;} void set_is_Gabriel(bool yesorno) { _is_Gabriel = yesorno;} void set_is_on_chull(bool yesorno) {_is_on_chull = yesorno;} NT alpha_min() const { return _alpha_min;} NT alpha_mid() const { return _alpha_mid;} NT alpha_max() const { return _alpha_max;} bool is_Gabriel() const {return _is_Gabriel;} bool is_on_chull() const {return _is_on_chull;} }; template < class Gt, class Cb = Triangulation_cell_base_3 > class Alpha_shape_cell_base_3 : public Cb { public: typedef typename Cb::Vertex_handle Vertex_handle; typedef typename Cb::Cell_handle Cell_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Cb::template Rebind_TDS::Other Cb2; typedef Alpha_shape_cell_base_3 Other; }; typedef typename Gt::FT NT; typedef CGAL::Alpha_status Alpha_status; typedef Compact_container Alpha_status_container; typedef typename Alpha_status_container::const_iterator Alpha_status_const_iterator; typedef typename Alpha_status_container::iterator Alpha_status_iterator; private: Alpha_status_iterator facet_status[4]; NT A; public: Alpha_shape_cell_base_3() : Cb() {} Alpha_shape_cell_base_3(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3) : Cb(v0, v1, v2, v3) {} Alpha_shape_cell_base_3(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Vertex_handle v3, Cell_handle n0, Cell_handle n1, Cell_handle n2, Cell_handle n3) : Cb(v0, v1, v2, v3, n0, n1, n2, n3) {} NT get_alpha() const { return A; } void set_alpha(const NT & AA) { A = AA;} Alpha_status_iterator get_facet_status(int i) const {return facet_status[i];} //Alpha_status_const_iterator get_facet_status(int i) const { // return facet_status[i];} void set_facet_status(int i, Alpha_status_iterator as) { facet_status[i]= as; } }; CGAL_END_NAMESPACE #endif // CGAL_ALPHA_SHAPE_CELL_BASE_3_H ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_support_set.Cmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_0000644000175000017500000001304511344301500031413 0ustar debiandebian// Copyright (c) 1997 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Min_sphere_of_spheres_d_support_set.C,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Kaspar Fischer #ifndef CGAL_MINIBALL_SUPPORTSET_C #define CGAL_MINIBALL_SUPPORTSET_C #include namespace CGAL_MINIBALL_NAMESPACE { namespace Min_sphere_of_spheres_d_impl { template inline bool reject(const FT& alpha,const FT& prev, const Tag_false is_exact) { using namespace Min_sphere_of_spheres_d_impl; return alpha < SqrOfEps*sqr(prev); } template inline bool reject(const FT& alpha,const Pair&, const Tag_true is_exact) { return alpha == FT(0); } template bool Support_set::push(const Sphere& ball) { CGAL_MINIBALL_DO_DEBUG(is_spanning_was_called = false); if (m > D) return false; b[m] = &ball; if (m == 0) { for (int j=0; j1 because $\q{C}_1=0$.) for (int i=1; i bool Support_set::is_spanning() { CGAL_MINIBALL_DO_DEBUG(is_spanning_was_called = true); Result beta[D+1]; // make sure at least one ball got pushed: CGAL_MINIBALL_ASSERT(m > 0); copy_n(t.center_cartesian_begin(*b[0]),center); if (m > 1) { // compute the coeffients beta[i] and the center: for(int i=1; i0; --i) { gamma[i] = beta[i]; for (int j=i+1; j #ifndef CGAL_ARR_POLYLINE_TRAITS_H #define CGAL_ARR_POLYLINE_TRAITS_H #include #include #include #include #include #include CGAL_BEGIN_NAMESPACE template class Polyline_2; template class Arr_polyline_traits_2 { public: typedef Tag_true Has_left_category; typedef Tag_false Has_reflect_category; typedef Segment_traits_ Segment_traits_2; typedef typename Segment_traits_2::Kernel Kernel; typedef Arr_polyline_traits_2 Self; typedef typename Segment_traits_2::Point_2 Point_2; typedef typename Segment_traits_2::Curve_2 Segment_2; typedef Polyline_2 Curve_2; typedef Polyline_2 X_monotone_curve_2; // Obsolete, for backward compatibility typedef Point_2 Point; typedef X_monotone_curve_2 X_curve; typedef Curve_2 Curve; protected: Segment_traits_2 seg_traits; // A traits class for segments. public: /*! * Default constructor. */ Arr_polyline_traits_2 () : seg_traits() {} /*! * Compare the x-coordinates of two given points. * \param p1 The first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2); SMALLER if x(p1) < x(p2); or else EQUAL. */ Comparison_result compare_x (const Point_2& p1, const Point_2& p2) const { return (seg_traits.compare_x (p1, p2)); } /*! * Compares lexigoraphically the two points: by x, then by y. * \param p1 Te first point. * \param p2 The second point. * \return LARGER if x(p1) > x(p2), or if x(p1) = x(p2) and y(p1) > y(p2); * SMALLER if x(p1) < x(p2), or if x(p1) = x(p2) and y(p1) < y(p2); * or else EQUAL. */ Comparison_result compare_xy(const Point_2& p1, const Point_2& p2) const { return (seg_traits.compare_xy (p1, p2)); } /*! * Check whether the given curve is a vertical segment. * \param cv The curve. * \return (true) if the curve is vertical. */ bool curve_is_vertical(const X_monotone_curve_2& cv) const { // An x-monotone polyline can represent a vertical segment only if it // is comprised of a single segment. return (cv._size() == 1 && seg_traits.curve_is_vertical(cv[0])); } /*! * Check whether the given point is in the x-range of the given curve. * In out case, the curve is a segment [s, t], check whether x(s)<=x(q)<=x(t) * or whether x(t)<=x(q)<=x(s). * \param cv The curve. * \param q The point. * \return (true) if q is in the x-range of cv. */ bool point_in_x_range(const X_monotone_curve_2& cv, const Point_2& q) const { return (_locate_point (cv, q) >= 0); } /*! * Get the relative status of two curves at the x-coordinate of a given * point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x-range of the two curves. * \return LARGER if cv1(x(q)) > cv2(x(q)); SMALLER if cv1(x(q)) < cv2(x(q)); * or else EQUAL. */ Comparison_result curves_compare_y_at_x(const X_monotone_curve_2 & cv1, const X_monotone_curve_2 & cv2, const Point_2 & q) const { // Get the indices of the segments in cv1 and cv2 containing q. int i1 = _locate_point (cv1, q); int i2 = _locate_point (cv2, q); CGAL_precondition(i1 >= 0); CGAL_precondition(i2 >= 0); return (seg_traits.curves_compare_y_at_x (cv1[i1], cv2[i2], q)); } /*! * Compares the y value of two curves in an epsilon environment to the left * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its left. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the left of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_left(const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& q) const { // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1)); CGAL_precondition(! curve_is_vertical(cv2)); // Get the indices of the segments in cv1 and cv2 containing q and // defined to its left. int i1 = _locate_point_side (cv1, q, false); int i2 = _locate_point_side (cv2, q, false); CGAL_precondition(i1 >= 0); CGAL_precondition(i2 >= 0); // Compare cv1[i1] and cv2[i2] at q's left. return (seg_traits.curves_compare_y_at_x_left (cv1[i1], cv2[i2], q)); } /*! * Compares the y value of two curves in an epsilon environment to the right * of the x-value of their intersection point. * \param cv1 The first curve. * \param cv2 The second curve. * \param q The point. * \pre The point q is in the x range of the two curves, and both of them * must be also be defined to its right. Furthermore, cv1(x(q) == cv2(x(q)). * \return The relative position of cv1 with respect to cv2 to the right of * x(q): LARGER, SMALLER or EQUAL. */ Comparison_result curves_compare_y_at_x_right(const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& q) const { // The two curves must not be vertical. CGAL_precondition(! curve_is_vertical(cv1)); CGAL_precondition(! curve_is_vertical(cv2)); // Get the indices of the segments in cv1 and cv2 containing q and // defined to its right. int i1 = _locate_point_side (cv1, q, true); int i2 = _locate_point_side (cv2, q, true); CGAL_precondition(i1 >= 0); CGAL_precondition(i2 >= 0); // Compare cv1[i1] and cv2[i2] at q's right. return (seg_traits.curves_compare_y_at_x_right (cv1[i1], cv2[i2], q)); } /*! * Return the location of the given point with respect to the input curve. * \param cv The curve. * \param p The point. * \pre p is in the x-range of cv. * \return SMALLER if y(p) < cv(x(p)), that is the point is below the curve; * LARGER if y(p) > cv(x(p)), that is the point is above the curve; * or else (if p is on the curve) EQUAL. */ Comparison_result curve_compare_y_at_x (const Point_2& p, const X_monotone_curve_2 &cv) const { // Get the indices of the segments in cv containing p. int i = _locate_point (cv, p); CGAL_precondition(i >= 0); // Compare the segment cv[i] and p. return (seg_traits.curve_compare_y_at_x (p, cv[i])); } /*! * Check if the two points are the same. * \param p1 The first point. * \param p2 The second point. * \return (true) if p1 == p2. */ bool point_equal (const Point_2& p1, const Point_2& p2) const { return (seg_traits.point_equal(p1, p2)); } /*! * Check if the two curves are the same (have the same graph). * \param cv1 The first curve. * \param cv2 The second curve. * \return (true) if the two curves are the same. */ bool curve_equal(const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2) const { // The two curves must contain the same number of segments. int n1 = cv1._size(); int n2 = cv2._size(); if (n1 != n2) return (false); // Check the pairwise equality of the contained segments. bool equal = true; int i; for (i = 0; i < n1; i++) { if (! seg_traits.curve_equal (cv1[i], cv2[i])) { equal = false; break; } } if (equal) return (true); // Check the reverse order. for (i = 0; i < n1; i++) { if (! seg_traits.curve_equal (cv1[i], cv2[n1 - i - 1])) return (false); } return (true); } /*! * Get the curve source (the source of the first segment in the polyline). * \param cv The curve. * \return The source point. */ Point_2 curve_source (const X_monotone_curve_2& cv) const { CGAL_assertion(cv._size() > 0); return (seg_traits.curve_source(cv[0])); } /*! * Get the curve target (the target of the last segment in the polyline). * \param cv The curve. * \return The target point. */ Point_2 curve_target (const X_monotone_curve_2 & cv) const { CGAL_assertion(cv._size() > 0); return (seg_traits.curve_target(cv[cv._size() - 1])); } /*! * Flip a given curve. * \param cv The input curve. * \return The flipped curve. */ X_monotone_curve_2 curve_opposite (const X_monotone_curve_2& cv) const { // Copy the segments in revered order while flipping each one individually. int n = cv._size(); int i; X_monotone_curve_2 flip_cv; for (i = 0; i < n; i++) { flip_cv._push_back (seg_traits.curve_opposite(cv[n - i - 1])); } return (flip_cv); } /*! * Check whether the curve is x-monotone. * \param curve The curve. * \return (true) if the curve is x-monotone. */ bool is_x_monotone(const Curve_2& curve) const { // Go over all curve segments. int n = curve._size(); Comparison_result curr_res; Comparison_result prev_res = EQUAL; int i; for (i = 0; i < n; i++) { curr_res = seg_traits.compare_x (seg_traits.curve_source(curve[i]), seg_traits.curve_target(curve[i])); // In case of a vertical segment, it must be the only segment in the // polyline to be considered x-monotone. if (curr_res == EQUAL) return (curve._size() == 1); if (curr_res != prev_res && prev_res != EQUAL) return (false); prev_res = curr_res; } return (true); } /*! * Cut the given curve into x-monotone subcurves and insert them to the * given output iterator. * \param cv The curve. * \param o The output iterator * \return The past-the-end iterator */ template OutputIterator curve_make_x_monotone (const Curve_2& curve, OutputIterator o) const { // Go over all curve segments. int n = curve._size(); Comparison_result curr_res; Comparison_result prev_res = EQUAL; X_monotone_curve_2 x_cv; int i; for (i = 0; i < n; i++) { curr_res = seg_traits.compare_x (seg_traits.curve_source(curve[i]), seg_traits.curve_target(curve[i])); // In case of a vertical segment, it must be the only segment in the // polyline to be considered x-monotone. if (curr_res == EQUAL) { // Current segment is vertical: if (x_cv._size() != 0) { // Cut the previous chain. *o++ = x_cv; x_cv._clear(); } // Insert the vertical segment as a singleton polyline. x_cv._push_back (curve[i]); *o++ = x_cv; x_cv._clear(); } else if (curr_res != prev_res && prev_res != EQUAL) { // We should cut the chain at this point and start a new one. if (x_cv._size() != 0) { // Cut the previous chain. *o++ = x_cv; x_cv._clear(); } x_cv._push_back (curve[i]); } else { // Just append [ps, pt] to the current chain. x_cv._push_back (curve[i]); } prev_res = curr_res; } // Append the last x-monotone chain. if (x_cv._size() != 0) { // Cut the previous chain. *o++ = x_cv; x_cv._clear(); } return (o); } /*! * Split a given curve at a given split point into two sub-curves. * \param cv the curve to split * \param c1 the output first part of the split curve. Its source is the * source of the original curve. * \param c2 the output second part of the split curve. Its target is the * target of the original curve. * \param p the split point. * \pre p lies on cv but is not one of its end-points. */ void curve_split (const X_monotone_curve_2& cv, X_monotone_curve_2& c1, X_monotone_curve_2& c2, const Point_2& p) const { // Locate the segment on the polyline cv that contains p. int i = _locate_point (cv, p); // Check preconditions. CGAL_precondition(i >= 0); CGAL_precondition(! seg_traits.point_equal(curve_source(cv), p)); CGAL_precondition(! seg_traits.point_equal(curve_target(cv), p)); // Clear the output curves. c1._clear(); c2._clear(); // Push all segments labeled (0, 1, ... , i-1) into c1. int j; for (j = 0; j < i; j++) c1._push_back (cv[j]); // Check whether the split point is cv[i]'s source of target. if (seg_traits.point_equal (seg_traits.curve_source(cv[i]), p)) { // cv[i] should be the first segment in c2. c2._push_back (cv[i]); } else if (seg_traits.point_equal (seg_traits.curve_target(cv[i]), p)) { // cv[i] should be the last segment in c1. c1._push_back (cv[i]); } else { // cv[i] should be split. Segment_2 cvi_1, cvi_2; seg_traits.curve_split (cv[i], cvi_1, cvi_2, p); // The first part should go into c1 and the second into c2. c1._push_back (cvi_1); c2._push_back (cvi_2); } // Push all segments labeled (i+1, i+2, ... , n-1) into cv1. int n = cv._size(); for (j = i+1; j < n; j++) c2._push_back (cv[j]); return; } /*! * Find the nearest intersection of the two given curves to the right of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the right of the reference point (that is, whose * left endpoint is the projection of the reference point onto the * overlapping subcurve). * NOTE: When there is an overlap we will always return a SEGMENT (i.e., * a polyline with 2 points) even if the overlap is actually a longer * polyline, as this is still sufficient for the arrangement. * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the right of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_right (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& p) const { Point_2 ps [2]; int res; res = _nearest_intersection_to_side (cv1, cv2, p, true, // To the right of p. ps[0], ps[1]); // Check if there is no intersection. if (res == 0) return Object(); // Check if the intersection is a single point. if (res == 1) return CGAL::make_object(ps[0]); // Return a polyline (which is actaully a single segment). return CGAL::make_object(X_monotone_curve_2(ps + 0, ps + 2)); } /*! * Find the nearest intersection of the two given curves to the left of * a given reference point. * Nearest is defined as the lexicographically nearest point, not including * the point reference point itself. * If the intersection of the two curves is an X_monotone_curve_2, that is, * there is an overlapping subcurve, that contains the reference point in * its x-range, the function should return an X_monotone_curve_2 whose * interior is strictly to the left of the reference point (that is, whose * right endpoint is the projection of the reference point onto the * overlapping subcurve). * NOTE: When there is an overlap we will always return a SEGMENT (i.e., * a polyline with 2 points) even if the overlap is actually a longer * polyline, as this is still sufficient for the arrangement. * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \return An empty object if there is no intersection to the left of p. * An object wrapping a Point_2 in case of a simple intersection. * An object wrapping an X_monotone_curve_2 in case of an overlap. */ Object nearest_intersection_to_left (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& p) const { Point_2 ps [2]; int res; res = _nearest_intersection_to_side (cv1, cv2, p, false, // To the left of p. ps[0], ps[1]); // Check if there is no intersection. if (res == 0) return Object(); // Check if the intersection is a single point. if (res == 1) return CGAL::make_object(ps[0]); // Return a polyline (which is actaully a single segment). return CGAL::make_object(X_monotone_curve_2(ps + 0, ps + 2)); } /*! * Check whether the two given curves overlap. * \patam cv1 The first curve. * \patam cv2 The second curve. * \return (true) if the two curves overlap in a one-dimensional subcurve * (i.e., not in a finite number of points). Otherwise, if they have a finite * number of intersection points, or none at all, return (false). */ bool curves_overlap(const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2) const { // Get the leftmost point of cv1 and of cv2. const Point_2& left1 = _is_curve_to_right(cv1) ? curve_source(cv1) : curve_target(cv1); const Point_2& left2 = _is_curve_to_right(cv2) ? curve_source(cv2) : curve_target(cv2); // Pick the righmost point of the two to start with. Point_2 p = (seg_traits.compare_x(left1, left2) == LARGER) ? left1 : left2; // Try to find an intersection to the right of p. Point_2 p1, p2; int res; while ((res = _nearest_intersection_to_side (cv1, cv2, p, true, // To the right of p. p1, p2)) != 0) { // Check if an overlap has been detected: if (res == 2) return (true); // Otherwise, p1==p2 is the next intersection point to the right. // Continue checking the intersections to its right. p = p1; } // If we reached here, no overlap has been detected. return (false); } private: /*! * Return the index of the segment in the polyline cv that contains the * point q in its x-range. The function performs a binary search, so if the * point q is in the x-range of the polyline with n segments, the segment * containing it can be located in O(log n) operations. * \param cv The polyline curve. * \param q The point. * \return An index i such that q is in the x-range of cv[i]. * If q is not in the x-range of cv, returns (-1). */ int _locate_point (const X_monotone_curve_2& cv, const Point_2& q) const { // First check whether the polyline curve really contains q in its x-range. int from = 0; Comparison_result res_from; int to = cv._size() - 1; Comparison_result res_to; res_from = seg_traits.compare_x (seg_traits.curve_source(cv[from]), q); if (res_from == EQUAL) return (from); res_to = seg_traits.compare_x (seg_traits.curve_target(cv[to]), q); if (res_to == EQUAL) return (to); if (res_from == res_to) return (-1); // Perform a binary search and locate the segment that contains q in its // x-range. int mid; Comparison_result res_mid_s, res_mid_t; while (to > from) { mid = (from + to) / 2; if (mid > from) { res_mid_s = seg_traits.compare_x (seg_traits.curve_source(cv[mid]), q); if (res_mid_s == EQUAL) return (mid); if (res_mid_s == res_from) from = mid; else to = mid - 1; } else { CGAL_assertion (mid < to); res_mid_t = seg_traits.compare_x (seg_traits.curve_target(cv[mid]), q); if (res_mid_t == EQUAL) return (mid); if (res_mid_t == res_to) to = mid; else from = mid + 1; } } // In case (from == to), and we know that the polyline contains the q: CGAL_assertion (from == to); return (from); } /*! * Find the index of the segment in the polyline that is defined to the * left (or to the right) of a the point q. * \param cv The polyline curve. * \param q The point. * \param to_right (true) if we wish to locate a segment to the right of q, * (false) if we wish to locate a segment to its right. * \return An index i such that cv[i] is defined to the left (or to the * right) of q, or (-1) if no such segment exists. */ int _locate_point_side (const X_monotone_curve_2& cv, const Point_2& q, const bool& to_right) const { // First locate a segment cv[i] that contains q in its x-range. int i = _locate_point (cv, q); if (i < 0) return (-1); // If we seek an end-point to the right of q, q must be smaller than it. // If we seek an end-point to its left, q must be larger. const Comparison_result cres = (to_right) ? SMALLER : LARGER; // Check whether x(q) is the x coordinate of an end-point of cv. if (seg_traits.compare_x (q, seg_traits.curve_source(cv[i])) == EQUAL) { // If x(q) is at cv[i]'s source and its target is to the right (or left) // of q, then cv[i] is defined to the right (or left) of q. if (seg_traits.compare_x (q, seg_traits.curve_target(cv[i])) == cres) { return (i); } // Otherwise, since cv[i]'s source is cv[i-1]'s target, we should check // if the source of the previous curve is to the right (or left) of q. if (i > 0 && seg_traits.compare_x (q, seg_traits.curve_source(cv[i-1])) == cres) { return (i-1); } else { return (-1); } } else if (seg_traits.compare_x (q, seg_traits.curve_target(cv[i])) == EQUAL) { // If x(q) is at cv[i]'s target and its source is to the right (or left) // of q, then cv[i] is defined to the right (or left) of q. if (seg_traits.compare_x (q, seg_traits.curve_source(cv[i])) == cres) { return (i); } // Otherwise, since cv[i]'s target is cv[i+1]'s source, we should check // if the target of the next curve is to the right (or left) of q. if (i < (cv._size() - 1) && seg_traits.compare_x (q, seg_traits.curve_target(cv[i+1])) == cres) { return (i+1); } else { return (-1); } } // In case q is in cv[i]'s interior: return (i); } /*! * Check whether the cuve is defined from the left to the right. * \param cv The polyline curve. * \return (true) if the curve target is lexicographically larger than its * source; (false) otherwise. */ bool _is_curve_to_right (const X_monotone_curve_2& cv) const { const Point_2& ps = seg_traits.curve_source(cv[0]); const Point_2& pt = seg_traits.curve_target(cv[0]); Comparison_result res; res = seg_traits.compare_x (ps, pt); if (res == EQUAL) res = seg_traits.compare_xy (ps, pt); return (res == SMALLER); } /*! * Find the nearest intersection point (or points) of two given curves to * the right (or to the left) lexicographically of a given point not * including the point itself. * This function is used by both nearest_intersection_to_right() and * nearest_intersection_to_left() to avoid code duplication. * \param cv1 The first curve. * \param cv2 The second curve. * \param p The refernece point. * \param to_right Should we search for an intersection to the right or to * the left of p. * \param p1 The first output point. * \param p2 The second output point. * \return 0 if cv1 and cv2 does not intersect to the right (or to the left, * if to_right == false) of p; * 1 if they have a single intersection point, returned as p1; * 2 if they overlap, where p1, p2 are the endpoints of the overlap. */ int _nearest_intersection_to_side (const X_monotone_curve_2& cv1, const X_monotone_curve_2& cv2, const Point_2& p, const bool& to_right, Point_2& p1, Point_2& p2) const { // Get the indices of the segments in cv1 and cv2 containing p. int i1 = _locate_point (cv1, p); int i2 = _locate_point (cv2, p); // Check if cv1 and cv2 are defined from left to right, and also // determine the desired comparison result (and its inverse). Comparison_result d_res; Comparison_result i_res; int n1 = cv1._size(); int n2 = cv2._size(); int inc1; int inc2; if (to_right) { d_res = SMALLER; i_res = LARGER; inc1 = _is_curve_to_right(cv1) ? 1 : -1; inc2 = _is_curve_to_right(cv2) ? 1 : -1; } else { d_res = LARGER; i_res = SMALLER; inc1 = _is_curve_to_right(cv1) ? -1 : 1; inc2 = _is_curve_to_right(cv2) ? -1 : 1; } // Check if the entire curve cv1 is defined to the right (left) of p. if (i1 < 0) { if (inc1 == 1) { // The source is the leftmost (rightmost) point in cv1, so p must be // to its left (right). // Otherwise, p is to the right (left) of the x-range of cv1. if (seg_traits.compare_x(p, seg_traits.curve_source(cv1[0])) == d_res) i1 = 0; else return (0); } else // if (inc1 == -1) { // The target is the leftmost (rightmost) point in cv1, so p must be // to its left (right). // Otherwise, p is to the right (left) of the x-range of cv1. if (seg_traits.compare_x(p, seg_traits.curve_target(cv1[n1-1])) == d_res) i1 = n1-1; else return (0); } } // Check if the entire curve cv2 is defined to the right (left) of p. if (i2 < 0) { if (inc2 == 1) { // The source is the leftmost (rightmost) point in cv2, so p must be // to its left (right). // Otherwise, p is to the right (left) of the x-range of cv2. if (seg_traits.compare_x(p, seg_traits.curve_source(cv2[0])) == d_res) i2 = 0; else return (0); } else // if (inc2 == -1) { // The target is the leftmost (rightmost) point in cv2, so p must be // to its left (right). // Otherwise, p is to the right (left) of the x-range of cv2. if (seg_traits.compare_x(p, seg_traits.curve_target(cv2[n2-1])) == d_res) i2 = n2-1; else return (0); } } // Try to locate the intersection point. Object obj; Segment_2 seg; Comparison_result res; while (i1 >= 0 && i1 < n1 && i2 >= 0 && i2 < n2) { // Check if the two current segment intersect to the right (left) of p. if (to_right) obj = seg_traits.nearest_intersection_to_right (cv1[i1], cv2[i2], p); else obj = seg_traits.nearest_intersection_to_left (cv1[i1], cv2[i2], p); if (! obj.is_empty()) { // In case an overlap was detected, stop here: if (CGAL::assign (seg, obj)) { p1 = seg_traits.curve_source (seg); p2 = seg_traits.curve_target (seg); return (2); } // The intersection is a single point: CGAL::assign (p1, obj); // In case we found a single intersection point, check whether it // is the next end-point of cv1[i1] or of cv2[i2]. bool eq1, eq2; eq1 = seg_traits.point_equal (p1, (inc1 == 1) ? seg_traits.curve_target(cv1[i1]) : seg_traits.curve_source(cv1[i1])); eq2 = seg_traits.point_equal (p1, (inc2 == 1) ? seg_traits.curve_target(cv2[i2]) : seg_traits.curve_source(cv2[i2])); if (!eq1 && !eq2) { return (1); } // In case p1 equals one of the endpoints, simply assign this // endpoint to be p1. if (eq1) { p1 = (inc1 == 1) ? seg_traits.curve_target(cv1[i1]) : seg_traits.curve_source(cv1[i1]); } else // if (eq2) { p1 = (inc2 == 1) ? seg_traits.curve_target(cv2[i2]) : seg_traits.curve_source(cv2[i2]); } // Proceed to the next curves. if (eq1) i1 += inc1; if (eq2) i2 += inc2; if (i1 < 0 || i1 >= n1 || i2 < 0 || i2 >= n2) return (1); // Check if the next curves overlap, and the nearest overlap endpoint // equals p1. Object _obj; if (to_right) _obj = seg_traits.nearest_intersection_to_right (cv1[i1], cv2[i2], p); else _obj = seg_traits.nearest_intersection_to_left (cv1[i1], cv2[i2], p); if (CGAL::assign (seg, _obj)) { Point_2 q1 = seg_traits.curve_source (seg); Point_2 q2 = seg_traits.curve_target (seg); if (seg_traits.point_equal (p1, q1)) { // Now p1 (== q1) --> q2 is an overlapping segment. p2 = q2; return (2); } else if (seg_traits.point_equal (p1, q2)) { // Now p1 (== q2) --> q1 is an overlapping segment. p2 = q1; return (2); } } // In this case we have a single intersection point. return (1); } // Find the segment whose end-point is the leftmost (rightmost) and move // forward (or backward) on its polyline. res = seg_traits.compare_x ((inc1 == 1) ? seg_traits.curve_target(cv1[i1]) : seg_traits.curve_source(cv1[i1]), (inc2 == 1) ? seg_traits.curve_target(cv2[i2]) : seg_traits.curve_source(cv2[i2])); if (res == d_res) { i1 += inc1; } else if (res == i_res) { i2 += inc2; } else { i1 += inc1; i2 += inc2; } } // No intersection found: return (0); } }; /*! * A representation of a polyline, as used by the Arr_polyline_traits_2 * traits class. */ template class Polyline_2 { friend class Arr_polyline_traits_2; public: typedef Segment_traits_ Segment_traits_2; typedef typename Segment_traits_2::Point_2 Point_2; typedef typename Segment_traits_2::Curve_2 Segment_2; typedef ::std::vector Base; private: // The segments that comprise the poyline: ::std::vector segments; public: /*! * Default constructor. */ Polyline_2 () : segments() {} /*! * Constructor from a range of points, defining the endpoints of the * polyline segments. * \param pts_begin An iterator pointing to the first point in the range. * \param pts_end An iterator pointing after the last point in the range. * \pre The are at least 2 points in the range. * In other cases, an empty polyline will be created. */ template Polyline_2 (const InputIterator& pts_begin, const InputIterator& pts_end) : segments() { // Check if there are no points in the range: InputIterator ps = pts_begin; if (ps == pts_end) return; // Construct a segment from each to adjacent points. InputIterator pt = ps; pt++; while (pt != pts_end) { segments.push_back (Segment_2 (*ps, *pt)); ps++; pt++; } } /* *Append a point to the polyline */ void push_back (const Point_2 & p) { Point_2 pt = p; Point_2 ps = (--segments.end()).source(); segments.push_back (Segment_2 (ps, pt)); } /*! * Create a bounding-box for the polyline. * \return The bounding-box. */ Bbox_2 bbox() const { // Compute the union of the bounding boxes of all segments. Bbox_2 bbox; int n = _size(); int i; for (i = 0; i < n; i++) { if (i == 0) bbox = (*this)[i].bbox(); else bbox = bbox + (*this)[i].bbox(); } return (bbox); } class const_iterator; friend class const_iterator; /*! * An iterator for the polyline points. */ class const_iterator { private: const Polyline_2 *cvP; // The polyline curve. int n_pts; // Its number of points. Segment_traits_ seg_traits; // Auxiliary variable. int i; // The current point. bool is_forward; // Forward or reverse iterator. /*! * Private constructor. * \param cv The scanned curve. * \param index The index of the segment. */ const_iterator (const Polyline_2* _cvP, const int& index, const bool& _forward) : cvP(_cvP), i(index), is_forward(_forward) { if (cvP == NULL) n_pts = 0; else n_pts = (cvP->_size() == 0) ? 0 : (cvP->_size() + 1); } /*! * Increment the index. */ void _increment () { if (cvP != NULL && i < n_pts) i++; } /*! * Decrement the index. */ void _decrement () { if (cvP != NULL && i >= 0) i--; } public: /*! * Default constructor. */ const_iterator () : cvP(NULL), n_pts(0), i(-1), is_forward(true) {} /*! * Dereference operator. * \return The current point. */ Point_2 operator* () const { CGAL_assertion(cvP != NULL); CGAL_assertion(i >= 0 && i < n_pts); if (i == 0) // First point is the source of the first segment. return (seg_traits.curve_source ((*cvP)[0])); else // Return the target of the (i-1)'st segment return (seg_traits.curve_target ((*cvP)[i-1])); } /*! * Increment operators. */ void operator++ () { if (is_forward) _increment(); else _decrement(); } void operator++ (int) { if (is_forward) _increment(); else _decrement(); } /*! * Decrement operators. */ void operator-- () { if (is_forward) _decrement(); else _increment(); } void operator-- (int) { if (is_forward) _decrement(); else _increment(); } /*! * Equality operators. */ bool operator== (const const_iterator& it) const { return (cvP == it.cvP && i == it.i); } bool operator!= (const const_iterator& it) const { return (cvP != it.cvP || i != it.i); } friend class Polyline_2; }; /*! * Get an iterator for the polyline points. * \return An iterator that points on the first point. */ const_iterator begin () const { if (_size() == 0) return (const_iterator (NULL, -1, true)); else return (const_iterator (this, 0, true)); } /*! * Get a past-the-end iterator for the polyline points. * \return A past-the-end iterator. */ const_iterator end () const { if (_size() == 0) return (const_iterator (NULL, -1, true)); else return (const_iterator (this, _size() + 1, true)); } /*! * Get an reverse iterator for the polyline points. * \return An iterator that points on the last point. */ const_iterator rbegin () const { if (_size() == 0) return (const_iterator (NULL, -1, false)); else return (const_iterator (this, _size(), false)); } /*! * Get a reverse past-the-end iterator for the polyline points. * \return A reverse past-the-end iterator. */ const_iterator rend () const { if (_size() == 0) return (const_iterator (NULL, -1, false)); else return (const_iterator (this, -1, false)); } /*! * Get the number of points contained in the polyline. * \return The number of points. */ unsigned int points () const { if (_size() == 0) return (0); else return (_size() + 1); } private: /*! * Append a segment to the polyline. * \param seg The new segment to be appended to the polyline. * \pre If the polyline is not empty, the segment source must be the * same as the target point of the last segment in the polyline. */ inline void _push_back (const Segment_2& seg) { segments.push_back(seg); return; } /*! * Get the number of segments that comprise the poyline. * \return The number of segments. */ inline int _size () const { return (static_cast(segments.size())); } /*! * Get the i'th segment of the polyline. * \param i The segment index (from 0 to size()-1). * \return A const reference to the segment. */ inline const Segment_2& operator[] (const int& i) const { return (segments[i]); } /*! * Clear the polyline. */ inline void _clear () { segments.clear(); return; } }; /*! * Output operator for a polyline. */ template inline Stream_ & operator<<(Stream_ & os, const Polyline_2 & cv) { typename Polyline_2::const_iterator ps = cv.begin(); typename Polyline_2::const_iterator pt = ps; pt++; while (pt != cv.end()) { typename Segment_traits_::Curve_2 seg(*ps, *pt); os << seg; ps++; pt++; } return (os); } /*! Specialized exporter for output stream. * In this case we export the number of points followed by the points */ template inline std::ostream & operator<<(std::ostream & os, const Polyline_2 & pl) { typedef Polyline_2 Curve_2; typename Curve_2::const_iterator it; // Print out the number of points in the polyline. os << pl.points(); // Print out the polyline points. for (it = pl.begin(); it != pl.end(); it++) os << " " << (*it); return (os); } /*! * Input operator for a polyline. */ template inline Stream_ & operator>>(Stream_ & is, Polyline_2 & pl) { typedef Polyline_2 Curve_2; typedef typename Curve_2::Point_2 Point_2; // Read the number of input points. int n_pts; is >> n_pts; // Read n_pts points to a list. Point_2 p; ::std::list pts; int i; for (i = 0; i < n_pts; i++) { is >> p; pts.push_back(p); } // Create the polyline curve. pl = Curve_2 (pts.begin(), pts.end()); return (is); } CGAL_END_NAMESPACE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/random_convex_set_2.h0000644000175000017500000001021611344301500031127 0ustar debiandebian// Copyright (c) 1998 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/random_convex_set_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Hoffmann #if ! (CGAL_RANDOM_CONVEX_SET_2_H) #define CGAL_RANDOM_CONVEX_SET_2_H 1 #include #include #include #include #include #ifdef CGAL_REP_CLASS_DEFINED #include #endif CGAL_BEGIN_NAMESPACE template < class OutputIterator, class Point_generator, class Traits > OutputIterator random_convex_set_2( int n, OutputIterator o, const Point_generator& pg, Traits t) { CGAL_precondition( n >= 3); #ifndef CGAL_CFG_NO_NAMESPACE using std::vector; using std::back_inserter; using std::accumulate; using std::transform; using std::bind2nd; using std::sort; using std::partial_sum; using std::less; using std::max_element; using CGAL::copy_n; #endif typedef typename Traits::Point_2 Point_2; typedef typename Traits::FT FT; typedef vector< Point_2 > Container; typedef typename Traits::Sum Sum; typedef typename Traits::Scale Scale; typedef typename Traits::Angle_less Angle_less; typedef typename Traits::Max_coordinate Max_coordinate; // GCC 2.8 and egcs-1.0.1 require these: // (does not accept s.l. Scale()( p, 1)) Scale scale; Max_coordinate max_coordinate; Sum sum; // build random point set: Container points; points.reserve( n); CGAL::copy_n( pg, n, back_inserter( points)); // compute centroid of points: Point_2 centroid( scale( accumulate( points.begin(), points.end(), t.origin(), Sum()), FT( 1) / FT( n))); // translate s.t. centroid == origin: transform( points.begin(), points.end(), points.begin(), bind2nd( Sum(), scale( centroid, FT( -1)))); // sort them according to their direction's angle // w.r.t. the positive x-axis: sort( points.begin(), points.end(), Angle_less()); // construct polygon: partial_sum( points.begin(), points.end(), points.begin(), Sum()); // and compute its centroid: Point_2 new_centroid( scale( accumulate( points.begin(), points.end(), t.origin(), Sum()), FT( 1) / FT( n))); // translate s.t. centroids match: transform( points.begin(), points.end(), points.begin(), bind2nd( Sum(), sum( centroid, scale( new_centroid, FT( -1))))); // compute maximal coordinate: FT maxcoord( max_coordinate( *max_element( points.begin(), points.end(), compose2_2( less< FT >(), Max_coordinate(), Max_coordinate())))); // and finally scale to fit into original grid: return transform( points.begin(), points.end(), o, bind2nd( Scale(), FT( pg.range()) / maxcoord)); } // random_convex_set_2( n, o, pg, t) CGAL_END_NAMESPACE #endif // ! (CGAL_RANDOM_CONVEX_SET_2_H) // ---------------------------------------------------------------------------- // ** EOF // ---------------------------------------------------------------------------- ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_line_face_circulator_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_line_fac0000644000175000017500000004460211344301501031412 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_line_face_circulator_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_LINE_FACE_CIRCULATOR_2_H #define CGAL_TRIANGULATION_LINE_FACE_CIRCULATOR_2_H // #include // #include // #include // #include // #include // #include CGAL_BEGIN_NAMESPACE template < class Gt, class Tds > class Triangulation_2; template < class Gt, class Tds > class Triangulation_line_face_circulator_2 : public Bidirectional_circulator_base< typename Tds::Face, CGAL_CLIB_STD::ptrdiff_t, CGAL_CLIB_STD::size_t>, public Triangulation_cw_ccw_2 { public: typedef Triangulation_line_face_circulator_2 Line_face_circulator; typedef Triangulation_2 Triangulation; typedef typename Tds::Vertex Vertex; typedef typename Tds::Face Face; typedef typename Tds::Edge Edge; typedef typename Tds::Vertex_handle Vertex_handle; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Face_circulator Face_circulator; typedef typename Gt::Point_2 Point; typedef typename Triangulation::Locate_type Locate_type; enum State {undefined = -1, vertex_vertex, vertex_edge, edge_vertex, edge_edge}; private: Face_handle pos; const Triangulation_2* _tr; State s; int i; Point p, q; public: Triangulation_line_face_circulator_2() : pos(), _tr(NULL), s(undefined), i(-1) {} Triangulation_line_face_circulator_2(Vertex_handle v, const Triangulation_2* tr, const Point& dir); Triangulation_line_face_circulator_2(const Point& pp, const Point& qq, const Triangulation_2 * t); Triangulation_line_face_circulator_2(const Point& pp, const Point& qq, const Face_handle& ff, const Triangulation_2* t); Line_face_circulator& operator++() ; Line_face_circulator& operator--() ; Line_face_circulator operator++(int); Line_face_circulator operator--(int); Face* operator->() {return &*pos;} Face& operator*() { return *pos;} Face_handle handle() {return pos;} operator const Face_handle() const {return pos;} bool operator==(const Line_face_circulator& lfc) const; bool operator!=(const Line_face_circulator& lfc) const; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE bool operator==(const Face_handle& fh) const { return fh == pos; } bool operator!=(const Face_handle& fh) const { return fh != pos; } #endif bool operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const; bool operator!=(CGAL_NULL_TYPE n) const; bool is_empty() const; bool collinear_outside() const; bool locate(const Point& t, Locate_type <, int &li); //private: Triangulation_line_face_circulator_2(const Face_handle& face, int index, State state, const Triangulation_2 * t, const Point& pp, const Point& qq); private: void increment(); void decrement(); }; #ifdef CGAL_T2_USE_ITERATOR_AS_HANDLE template < class Gt, class Tds > inline bool operator==(typename Tds::Face_handle fh, Triangulation_line_face_circulator_2 fc) { return (fc==fh); } template < class Gt, class Tds > inline bool operator!=(typename Tds::Face_handle fh, Triangulation_line_face_circulator_2 fc) { return (fc!=fh); } #endif template < class Gt, class Tds > Triangulation_line_face_circulator_2:: Triangulation_line_face_circulator_2(const Face_handle& face, int index, State state, const Triangulation_2 * t, const Point& pp, const Point& qq) : pos(face), _tr(t), s(state), i(index), p(pp), q(qq) { CGAL_triangulation_precondition(! t->xy_equal(p, q)); } template < class Gt, class Tds > Triangulation_line_face_circulator_2:: Triangulation_line_face_circulator_2(Vertex_handle v, const Triangulation_2* tr, const Point& dir) :pos(), _tr(tr), s(undefined) // begin at the face incident to v, traversed by the ray from v to // dir // or null iterator { CGAL_triangulation_precondition((!_tr->is_infinite(v)) && (_tr->dimension() == 2) && (! _tr->xy_equal(v->point(),dir))); p=v->point(); q=dir; // find a finite vertex to the left of pq // if there is no, the line_face_circulator is null Face_circulator fc = v->incident_faces(); Face_circulator done(fc); int ic = fc->index(v); Vertex_handle vt= fc->vertex(cw(ic)); while( _tr->is_infinite(vt) || _tr->orientation(p, q, vt->point()) != LEFT_TURN) { ++fc; ic = fc->index(v); vt= fc->vertex(cw(ic)); if (fc == done) { *this = Line_face_circulator(); return;} } // now vt is finite and to the left of pq Vertex_handle vr = fc-> vertex(ccw(ic)); Orientation pqr = RIGHT_TURN; // warning "pqr might be used uninitialized" while ( (!_tr->is_infinite(vr)) && (pqr = _tr->orientation(p, q, vr->point()))== LEFT_TURN ) { --fc; ic = fc->index(v); vr = fc-> vertex(ccw(ic)); } // vr can be infinite or finite. // If finite [pqr] is COLLINEAR or RIGHT_TURN // reset vt and conclude. vt is still finite and [pqt] still LEFT_TURN ic = fc->index(v); vt= fc->vertex(cw(ic)); CGAL_triangulation_assertion (_tr->orientation(p,q, vt->point())== LEFT_TURN ); if (_tr->is_infinite(vr)) { --fc; ic = fc->index(v); vr = fc->vertex(ccw(ic)); pqr = _tr->orientation(p, q, vr->point()); switch(pqr){ case RIGHT_TURN: case COLLINEAR: ++fc; ic = fc->index(_tr->infinite_vertex()); pos = fc; s = vertex_vertex; i = ic; break; case LEFT_TURN: *this = Line_face_circulator(); break; } } else if (pqr == COLLINEAR) { pos = fc; s = vertex_vertex; i = ccw(ic); } else { // pqr==RIGHT_TURN pos = fc; s = vertex_edge; i = ic ; } return; } template < class Gt, class Tds > Triangulation_line_face_circulator_2:: Triangulation_line_face_circulator_2(const Point& pp, const Point& qq, const Triangulation_2 * t) : pos(), _tr(t), s(undefined), p(pp), q(qq) //begins at the first finite face traversed be the oriented line pq { Vertex_handle inf = _tr->infinite_vertex(); Face_circulator fc = inf->incident_faces(), done(fc); i = fc->index(inf); Point l = fc->vertex(cw(i))->point(); Point r = fc->vertex(ccw(i))->point(); Orientation pql = _tr->orientation(p, q, l); Orientation pqr = _tr->orientation(p, q, r); do{ if( (pql == LEFT_TURN) && (pqr == RIGHT_TURN) ){ *this = ++Line_face_circulator( fc, i, vertex_edge, t, p, q); return; } else if ( (pql == LEFT_TURN) && (pqr == COLLINEAR) ){ --fc; i = fc->index(inf); Point ss = fc->vertex(ccw(i))->point(); Orientation pqs = _tr->orientation(p, q, ss); Face_handle fn; int in; switch(pqs) { case LEFT_TURN: *this = Line_face_circulator(); return; case COLLINEAR: fn = fc->neighbor(i); in = fn->index(fc); *this = Line_face_circulator( fn, cw(in),vertex_vertex,t,p,q); return; case RIGHT_TURN: fn = fc->neighbor(i); Vertex_handle vr = fc->vertex(cw(i)); // vertex corresponding to r in = fn->index(vr); ss = fn->vertex(cw(in))->point(); pqs = _tr->orientation(p, q, ss); Orientation pqss = RIGHT_TURN; while ( pqs != LEFT_TURN) { pqss = pqs; fn = fn->neighbor(ccw(in)); in = fn->index(vr); ss = fn->vertex(cw(in))->point(); pqs = _tr->orientation(p, q, ss); } if (pqss == RIGHT_TURN) *this = Line_face_circulator( fn, in ,vertex_edge,t,p,q); else // pqss = COLLINEAR *this = Line_face_circulator(fn,ccw(in),vertex_vertex,t,p,q); return; } } // going CCW around convex hull is CW around infinite vertex --fc; l = r; pql = pqr; i = fc->index(inf); r = fc->vertex(ccw(i))->point(); pqr = _tr->orientation(p, q, r); }while(fc != done); // if line (p,q) does not intersect the convex hull in an edge // the circulator has a singular value *this=Line_face_circulator(); return; } template < class Gt, class Tds > Triangulation_line_face_circulator_2:: Triangulation_line_face_circulator_2(const Point& pp, const Point& qq, const Face_handle& ff, const Triangulation_2* t) : pos(ff), _tr(t), s(undefined), p(pp), q(qq) // precondition : face ff contain p // the walk begins at face ff if ff is a finite face traversed by the // circulator // if ff is finite but not traversed by the circulator // (this happens when p is a vertex of ff or on an edge) : // the circulator may be empty, or the walk begins at a finite face // incident to p // if ff is infinite, the walk begin at the first finite face traversed { CGAL_triangulation_precondition(_tr->is_infinite(ff) || _tr->oriented_side(ff,p) != ON_NEGATIVE_SIDE); int j; if(_tr->is_infinite(pos)){ *this = Line_face_circulator(p, q, t); return; } // Test whether p lies on a vertex for(j = 0; j < 3; j++){ if(pos->vertex(j)->point() == p){ *this = Line_face_circulator( pos->vertex(j), t, q); if( (!is_empty()) && _tr->is_infinite(pos )) --(*this); return; } } // Test whether p lies on an edge for(j = 0; j < 3; j++) { if(_tr->orientation(pos->vertex(ccw(j))->point(), pos->vertex(cw(j))->point(), p) == COLLINEAR){ Orientation pqj = _tr->orientation(p, q, pos->vertex(j)->point()); Orientation pqcwj = _tr->orientation(p, q, pos->vertex(cw(j))->point()); switch(pqcwj) { case COLLINEAR : if(pqj == LEFT_TURN){ s = vertex_vertex; i = cw(j); return; } else if(! _tr->is_infinite(pos->neighbor(j))){ Face_handle n = pos->neighbor(j); i = cw(n->index(pos)); pos = n; s = vertex_vertex; return; } else { // singular value *this = Line_face_circulator(); return; } case LEFT_TURN : i = j; s = (pqj == COLLINEAR) ? vertex_edge : edge_edge; break; case RIGHT_TURN : switch(pqj){ case COLLINEAR: s = edge_vertex; i = j; return; case LEFT_TURN: s = edge_edge; i = cw(j); return; case RIGHT_TURN: s = edge_edge; i = ccw(j); return; } } } } // p lies in the interior of the face Orientation orient[3]; for(j=0; j<3; j++) { orient[j] = _tr->orientation(p,q,pos->vertex(j)->point()); } for(j=0; j<3; j++) { if(orient[j] == COLLINEAR) { i = j; s = (orient[ccw(j)] == LEFT_TURN) ? edge_vertex : vertex_edge; return; } } s = edge_edge; for(j=0; j<3; j++){ if(orient[j] == RIGHT_TURN){ i = (orient[ccw(j)] == RIGHT_TURN) ? j : cw(j); return; } } } template < class Gt, class Tds > inline void Triangulation_line_face_circulator_2:: increment() { CGAL_triangulation_precondition(pos != Face_handle()); if(s == vertex_vertex || s == edge_vertex) { Orientation o; do{ Face_handle n = pos->neighbor(cw(i)); i = n->index(pos); pos = n; if (pos->vertex(i) == _tr->infinite_vertex()){ o = COLLINEAR; i = cw(i); break; } o = _tr->orientation(p, q, pos->vertex(i)->point()); i = cw(i); }while(o == LEFT_TURN); if(o == COLLINEAR) { s = vertex_vertex; i = ccw(i); } else { s = vertex_edge; } } else { Face_handle n = pos->neighbor(i); int ni = n->index(pos); pos = n ; Orientation o = _tr->is_infinite(pos->vertex(ni)) ? COLLINEAR : _tr->orientation(p,q,pos->vertex(ni)->point()); switch(o){ case LEFT_TURN: s = edge_edge; i = ccw(ni); break; case RIGHT_TURN: s = edge_edge; i = cw(ni); break; default: s = edge_vertex; i = ni; } } } template < class Gt, class Tds > void Triangulation_line_face_circulator_2:: decrement() { CGAL_triangulation_precondition(pos != Face_handle()); if(s == vertex_vertex || s == vertex_edge) { if(s == vertex_vertex){ i = cw(i); } Orientation o; do{ Face_handle n = pos->neighbor(ccw(i)); i = n->index(pos); pos = n; if (pos->vertex(i) == _tr->infinite_vertex()){ o = COLLINEAR; i = ccw(i); break; } o = _tr->orientation(p, q, pos->vertex(i)->point()); i = ccw(i); }while(o == LEFT_TURN); s = (o == COLLINEAR) ? vertex_vertex : edge_vertex; } else { // s == edge_edge || s == edge_vertex // the following is not nice. A better solution is to say // that index i is at the vertex that is alone on one side of l(p,q) if(s == edge_edge){ i = (_tr->orientation (p, q, pos->vertex(i)->point()) == LEFT_TURN) ? cw(i) : ccw(i); } Face_handle n = pos->neighbor(i); i = n->index(pos); pos = n; Orientation o = _tr->is_infinite(pos->vertex(i)) ? COLLINEAR : _tr->orientation(p, q, pos->vertex(i)->point()); s = (o == COLLINEAR) ? vertex_edge : edge_edge; } } template < class Gt, class Tds > bool Triangulation_line_face_circulator_2:: locate(const Point& t, Locate_type <, int &li) { switch(s){ case edge_edge: case vertex_edge: { Orientation o = _tr->orientation(pos->vertex(ccw(i))->point(), pos->vertex(cw(i))->point(), t); if(o == RIGHT_TURN) return false; if(o == COLLINEAR){ lt = Triangulation::EDGE; li = i; return true; } lt = Triangulation::FACE; li = 4;//li unused in this case return true; } case vertex_vertex: { if(_tr->is_infinite(pos->vertex(i))){ CGAL_triangulation_assertion( _tr->orientation( pos->vertex(cw(i))->point(), pos->vertex(ccw(i))->point(), t) != LEFT_TURN); lt = Triangulation::OUTSIDE_CONVEX_HULL; li = i; return true; } const Point &u = pos->vertex(cw(i))->point(); const Point &v = pos->vertex(i)->point(); // u == t was detected earlier if(_tr->compare_x(v,t)==EQUAL && _tr->compare_y(v,t)==EQUAL){ lt = Triangulation::VERTEX; li = i; return true; } if(_tr->collinear_between(u, t, v)) { lt = Triangulation::EDGE; li = ccw(i); return true; } return false; } default: // edge_vertex { if(_tr->is_infinite(pos->vertex(i))){ lt = Triangulation::OUTSIDE_CONVEX_HULL; li = i; return true; } if(_tr->xy_equal(t,pos->vertex(i) ->point()) ){ li = i; lt = Triangulation::VERTEX; return true; } if(_tr->collinear_between(p, t, pos->vertex(i)->point())) { lt = Triangulation::FACE; return true; } return false; } } } template < class Gt, class Tds > inline Triangulation_line_face_circulator_2& Triangulation_line_face_circulator_2:: operator++() { CGAL_triangulation_precondition( pos != Face_handle()) ; increment(); return *this; } template < class Gt, class Tds > inline Triangulation_line_face_circulator_2& Triangulation_line_face_circulator_2:: operator--() { CGAL_triangulation_precondition(pos != Face_handle()) ; decrement(); return *this; } template < class Gt, class Tds > inline Triangulation_line_face_circulator_2 Triangulation_line_face_circulator_2:: operator++(int) { Line_face_circulator tmp(*this); ++(*this); return tmp; } template < class Gt, class Tds > inline Triangulation_line_face_circulator_2 Triangulation_line_face_circulator_2:: operator--(int) { Line_face_circulator tmp(*this); --(*this); return tmp; } template < class Gt, class Tds > inline bool Triangulation_line_face_circulator_2:: operator==(const Line_face_circulator& lfc) const { CGAL_triangulation_precondition( pos != Face_handle() && lfc.pos != Face_handle()); return ( pos == lfc.pos && _tr == lfc._tr && s== lfc.s && p==lfc.p && q==lfc.q); } template < class Gt, class Tds > inline bool Triangulation_line_face_circulator_2:: operator!=(const Line_face_circulator& lfc) const { return !(*this == lfc); } template < class Gt, class Tds > inline bool Triangulation_line_face_circulator_2:: is_empty() const { return pos == Face_handle(); } template < class Gt, class Tds > inline bool Triangulation_line_face_circulator_2:: operator==(CGAL_NULL_TYPE CGAL_triangulation_assertion_code(n)) const { CGAL_triangulation_assertion( n == NULL); return pos == Face_handle(); } template < class Gt, class Tds > inline bool Triangulation_line_face_circulator_2:: operator!=(CGAL_NULL_TYPE n) const { CGAL_triangulation_assertion( n == NULL); return !(*this == n); } template < class Gt, class Tds > inline bool Triangulation_line_face_circulator_2:: collinear_outside() const { // return (_tr->is_infinite(*this)) // && (s == vertex_vertex) // && (! _tr->is_infinite((*this)->vertex(i))); // return true if the circulator is non null // the line is collinear with a convex hull edge // and the convex hull is on the left of the line Face_handle fh = pos; return ( s == vertex_vertex && (! _tr->is_infinite(fh)) && _tr->is_infinite(fh->neighbor(ccw(i)))); } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_LINE_FACE_CIRCULATOR_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Nef_polyhedron_2.h0000644000175000017500000007612411344301500030377 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Nef_polyhedron_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_NEF_POLYHEDRON_2_H #define CGAL_NEF_POLYHEDRON_2_H #include #include #include #include #include #include #include #include #include //#include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 11 #include CGAL_BEGIN_NAMESPACE template class Nef_polyhedron_2; template class Nef_polyhedron_2_rep; template std::ostream& operator<<(std::ostream&, const Nef_polyhedron_2&); template std::istream& operator>>(std::istream&, Nef_polyhedron_2&); template class Nef_polyhedron_2_rep { typedef Nef_polyhedron_2_rep Self; friend class Nef_polyhedron_2; struct HDS_traits { typedef typename T::Point_2 Point; typedef bool Mark; }; public: // gcc-3.3 otherwise claims that Decorator in Polyhedron_2 is private typedef CGAL_HALFEDGEDS_DEFAULT Plane_map; typedef CGAL::PM_const_decorator Const_decorator; typedef CGAL::PM_decorator Decorator; typedef CGAL::PM_naive_point_locator Slocator; typedef CGAL::PM_point_locator Locator; typedef CGAL::PM_overlayer Overlayer; private: Plane_map pm_; Locator* pl_; void init_locator() { if ( !pl_ ) pl_ = new Locator(pm_); } void clear_locator() { if ( pl_ ) { delete pl_; pl_=0; } } public: Nef_polyhedron_2_rep() : pm_(), pl_(0) {} Nef_polyhedron_2_rep(const Self& R) : pm_(), pl_(0) {} ~Nef_polyhedron_2_rep() { pm_.clear(); clear_locator(); } }; /*{\Moptions print_title=yes }*/ /*{\Manpage {Nef_polyhedron_2}{T}{Nef Polyhedra in the Plane}{N}}*/ /*{\Mdefinition An instance of data type |\Mname| is a subset of the plane that is the result of forming complements and intersections starting from a finite set |H| of half-spaces. |\Mtype| is closed under all binary set operations |intersection|, |union|, |difference|, |complement| and under the topological operations |boundary|, |closure|, and |interior|. The template parameter |T| is specified via an extended kernel concept. |T| must be a model of the concept |ExtendedKernelTraits_2|. }*/ template class Nef_polyhedron_2 : public Handle_for< Nef_polyhedron_2_rep > { public: typedef T Extended_kernel; static T EK; // static extended kernel /*{\Mtypes 7}*/ typedef Nef_polyhedron_2 Self; typedef Handle_for< Nef_polyhedron_2_rep > Base; typedef typename T::Point_2 Extended_point; typedef typename T::Segment_2 Extended_segment; typedef typename T::Standard_line_2 Line; /*{\Mtypemember the oriented lines modeling half-planes}*/ typedef typename T::Standard_point_2 Point; /*{\Mtypemember the affine points of the plane.}*/ typedef typename T::Standard_direction_2 Direction; /*{\Mtypemember directions in our plane.}*/ typedef typename T::Standard_aff_transformation_2 Aff_transformation; /*{\Mtypemember affine transformations of the plane.}*/ typedef bool Mark; /*{\Xtypemember marking set membership or exclusion.}*/ enum Boundary { EXCLUDED=0, INCLUDED=1 }; /*{\Menum construction selection.}*/ enum Content { EMPTY=0, COMPLETE=1 }; /*{\Menum construction selection}*/ protected: struct AND { bool operator()(bool b1, bool b2) const { return b1&&b2; } }; struct OR { bool operator()(bool b1, bool b2) const { return b1||b2; } }; struct DIFF { bool operator()(bool b1, bool b2) const { return b1&&!b2; } }; struct XOR { bool operator()(bool b1, bool b2) const { return (b1&&!b2)||(!b1&&b2); } }; typedef Nef_polyhedron_2_rep Nef_rep; typedef typename Nef_rep::Plane_map Plane_map; typedef typename Nef_rep::Decorator Decorator; typedef typename Nef_rep::Const_decorator Const_decorator; typedef typename Nef_rep::Overlayer Overlayer; //typedef typename Nef_rep::T Transformer; typedef typename Nef_rep::Slocator Slocator; typedef typename Nef_rep::Locator Locator; #ifndef CGAL_CFG_USING_BASE_MEMBER_BUG_3 using Base::ptr; using Base::is_shared; #endif Plane_map& pm() { return ptr()->pm_; } const Plane_map& pm() const { return ptr()->pm_; } friend std::ostream& operator<< <> (std::ostream& os, const Nef_polyhedron_2& NP); friend std::istream& operator>> <> (std::istream& is, Nef_polyhedron_2& NP); typedef typename Decorator::Vertex_handle Vertex_handle; typedef typename Decorator::Halfedge_handle Halfedge_handle; typedef typename Decorator::Face_handle Face_handle; typedef typename Decorator::Vertex_const_handle Vertex_const_handle; typedef typename Decorator::Halfedge_const_handle Halfedge_const_handle; typedef typename Decorator::Face_const_handle Face_const_handle; typedef typename Decorator::Vertex_iterator Vertex_iterator; typedef typename Decorator::Halfedge_iterator Halfedge_iterator; typedef typename Decorator::Face_iterator Face_iterator; typedef typename Const_decorator::Vertex_const_iterator Vertex_const_iterator; typedef typename Const_decorator::Halfedge_const_iterator Halfedge_const_iterator; typedef typename Const_decorator::Face_const_iterator Face_const_iterator; struct Except_frame_box_edges { Decorator D_; Face_handle f_; Except_frame_box_edges(Plane_map& P) : D_(P), f_(D_.faces_begin()) {} bool operator()(Halfedge_handle e) const { return D_.face(e)==f_ || D_.face(D_.twin(e))==f_; } }; friend struct Except_frame_box_edges; typedef std::list ES_list; typedef typename ES_list::const_iterator ES_iterator; void fill_with_frame_segs(ES_list& L) const /*{\Xop fills the list with the four segments which span our frame, the convex hull of SW,SE,NW,NE.}*/ { L.push_back(Extended_segment(EK.SW(),EK.NW())); L.push_back(Extended_segment(EK.SW(),EK.SE())); L.push_back(Extended_segment(EK.NW(),EK.NE())); L.push_back(Extended_segment(EK.SE(),EK.NE())); } struct Link_to_iterator { const Decorator& D; Halfedge_handle _e; Vertex_handle _v; ES_iterator _it; Mark _m; Link_to_iterator(const Decorator& d, ES_iterator it, Mark m) : D(d), _e(), _v(), _it(it), _m(m) {} void supporting_segment(Halfedge_handle e, ES_iterator it) { if ( it == _it ) _e = e; D.mark(e) = _m; } void trivial_segment(Vertex_handle v, ES_iterator it) { if ( it == _it ) _v = v; D.mark(v) = _m; } void starting_segment(Vertex_handle v, ES_iterator) { D.mark(v) = _m; } void passing_segment(Vertex_handle v, ES_iterator) { D.mark(v) = _m; } void ending_segment(Vertex_handle v, ES_iterator) { D.mark(v) = _m; } }; friend struct Link_to_iterator; void clear_outer_face_cycle_marks() { // unset all frame marks Decorator D(pm()); Face_iterator f = D.faces_begin(); D.mark(f) = false; Halfedge_handle e = D.holes_begin(f); D.set_marks_in_face_cycle(e, false); } public: /*{\Mcreation 3}*/ Nef_polyhedron_2(Content plane = EMPTY) : Base(Nef_rep()) /*{\Mcreate creates an instance |\Mvar| of type |\Mname| and initializes it to the empty set if |plane == EMPTY| and to the whole plane if |plane == COMPLETE|.}*/ { ES_list L; fill_with_frame_segs(L); Overlayer D(pm()); Link_to_iterator I(D, --L.end(), false); D.create(L.begin(),L.end(),I); D.mark(++D.faces_begin()) = bool(plane); } Nef_polyhedron_2(const Line& l, Boundary line = INCLUDED) : Base(Nef_rep()) /*{\Mcreate creates a Nef polyhedron |\Mvar| containing the half-plane left of |l| including |l| if |line==INCLUDED|, excluding |l| if |line==EXCLUDED|.}*/ { CGAL_NEF_TRACEN("Nconstruction from line "< Nef_polyhedron_2(Forward_iterator it, Forward_iterator end, Boundary b = INCLUDED) : Base(Nef_rep()) /*{\Mcreate creates a Nef polyhedron |\Mvar| from the simple polygon |P| spanned by the list of points in the iterator range |[it,end)| and including its boundary if |b = INCLUDED| and excluding the boundary otherwise. |Forward_iterator| has to be an iterator with value type |Point|. This construction expects that |P| is simple. The degenerate cases where |P| contains no point, one point or spans just one segment (two points) are correctly handled. In all degenerate cases there's only one unbounded face adjacent to the degenerate polygon. If |b == INCLUDED| then |\Mvar| is just the boundary. If |b == EXCLUDED| then |\Mvar| is the whole plane without the boundary.}*/ { ES_list L; fill_with_frame_segs(L); bool empty = false; if (it != end) { Extended_point ef, ep = ef = EK.construct_point(*it); Forward_iterator itl=it; ++itl; if (itl == end) // case only one point L.push_back(EK.construct_segment(ep,ep)); else { // at least one segment while( itl != end ) { Extended_point en = EK.construct_point(*itl); L.push_back(EK.construct_segment(ep,en)); ep = en; ++itl; } L.push_back(EK.construct_segment(ep,ef)); } } else empty = true; Overlayer D(pm()); Link_to_iterator I(D, --L.end(), true); D.create(L.begin(),L.end(),I); if ( empty ) { D.mark(++D.faces_begin()) = !bool(b); return; } CGAL_assertion( I._e != Halfedge_handle() || I._v != Vertex_handle() ); if ( EK.is_degenerate(L.back()) ) { CGAL_assertion(I._v != Vertex_handle()); D.mark(D.face(I._v)) = !bool(b); D.mark(I._v) = b; } else { Halfedge_handle el = I._e; if ( D.point(D.target(el)) != EK.target(L.back()) ) el = D.twin(el); D.set_marks_in_face_cycle(el,bool(b)); if ( D.number_of_faces() > 2 ) D.mark(D.face(el)) = true; else D.mark(D.face(el)) = !bool(b); } clear_outer_face_cycle_marks(); } Nef_polyhedron_2(const Nef_polyhedron_2& N1) : Base(N1) {} Nef_polyhedron_2& operator=(const Nef_polyhedron_2& N1) { Base::operator=(N1); return (*this); } ~Nef_polyhedron_2() {} template Nef_polyhedron_2(Forward_iterator first, Forward_iterator beyond, double p) : Base(Nef_rep()) /*{\Xcreate creates a random Nef polyhedron from the arrangement of the set of lines |S = set[first,beyond)|. The cells of the arrangement are selected uniformly at random with probability $p$. \precond $0 < p < 1$.}*/ { CGAL_assertion(0

    (pm()); } /*{\Moperations 4 3 }*/ public: void clear(Content plane = EMPTY) { *this = Nef_polyhedron_2(plane); } /*{\Mop makes |\Mvar| the empty set if |plane == EMPTY| and the full plane if |plane == COMPLETE|.}*/ bool is_empty() const /*{\Mop returns true if |\Mvar| is empty, false otherwise.}*/ { Const_decorator D(pm()); Face_const_iterator f = D.faces_begin(); return (D.number_of_vertices()==4 && D.number_of_edges()==4 && D.number_of_faces()==2 && D.mark(++f) == false); } bool is_plane() const /*{\Mop returns true if |\Mvar| is the whole plane, false otherwise.}*/ { Const_decorator D(pm()); Face_const_iterator f = D.faces_begin(); return (D.number_of_vertices()==4 && D.number_of_edges()==4 && D.number_of_faces()==2 && D.mark(++f) == true); } void extract_complement() { CGAL_NEF_TRACEN("extract complement"); if ( this->is_shared() ) { clone_rep(); } Overlayer D(pm()); Vertex_iterator v, vend = D.vertices_end(); for(v = D.vertices_begin(); v != vend; ++v) D.mark(v) = !D.mark(v); Halfedge_iterator e, eend = D.halfedges_end(); for(e = D.halfedges_begin(); e != eend; ++(++e)) D.mark(e) = !D.mark(e); Face_iterator f, fend = D.faces_end(); for(f = D.faces_begin(); f != fend; ++f) D.mark(f) = !D.mark(f); clear_outer_face_cycle_marks(); } void extract_interior() { CGAL_NEF_TRACEN("extract interior"); if ( this->is_shared() ) clone_rep(); Overlayer D(pm()); Vertex_iterator v, vend = D.vertices_end(); for(v = D.vertices_begin(); v != vend; ++v) D.mark(v) = false; Halfedge_iterator e, eend = D.halfedges_end(); for(e = D.halfedges_begin(); e != eend; ++(++e)) D.mark(e) = false; D.simplify(Except_frame_box_edges(pm())); } void extract_boundary() { CGAL_NEF_TRACEN("extract boundary"); if ( this->is_shared() ) clone_rep(); Overlayer D(pm()); Vertex_iterator v, vend = D.vertices_end(); for(v = D.vertices_begin(); v != vend; ++v) D.mark(v) = true; Halfedge_iterator e, eend = D.halfedges_end(); for(e = D.halfedges_begin(); e != eend; ++(++e)) D.mark(e) = true; Face_iterator f, fend = D.faces_end(); for(f = D.faces_begin(); f != fend; ++f) D.mark(f) = false; clear_outer_face_cycle_marks(); D.simplify(Except_frame_box_edges(pm())); } void extract_closure() /*{\Xop converts |\Mvar| to its closure. }*/ { CGAL_NEF_TRACEN("extract closure"); extract_complement(); extract_interior(); extract_complement(); } void extract_regularization() /*{\Xop converts |\Mvar| to its regularization. }*/ { CGAL_NEF_TRACEN("extract regularization"); extract_interior(); extract_closure(); } /*{\Mtext \headerline{Constructive Operations}}*/ Nef_polyhedron_2 complement() const /*{\Mop returns the complement of |\Mvar| in the plane.}*/ { Nef_polyhedron_2 res = *this; res.extract_complement(); return res; } Nef_polyhedron_2 interior() const /*{\Mop returns the interior of |\Mvar|.}*/ { Nef_polyhedron_2 res = *this; res.extract_interior(); return res; } Nef_polyhedron_2 closure() const /*{\Mop returns the closure of |\Mvar|.}*/ { Nef_polyhedron_2 res = *this; res.extract_closure(); return res; } Nef_polyhedron_2 boundary() const /*{\Mop returns the boundary of |\Mvar|.}*/ { Nef_polyhedron_2 res = *this; res.extract_boundary(); return res; } Nef_polyhedron_2 regularization() const /*{\Mop returns the regularized polyhedron (closure of interior).}*/ { Nef_polyhedron_2 res = *this; res.extract_regularization(); return res; } Nef_polyhedron_2 intersection(const Nef_polyhedron_2& N1) const /*{\Mop returns |\Mvar| $\cap$ |N1|. }*/ { Nef_polyhedron_2 res(pm(),false); // empty, no frame Overlayer D(res.pm()); D.subdivide(pm(),N1.pm()); AND _and; D.select(_and); res.clear_outer_face_cycle_marks(); D.simplify(Except_frame_box_edges(res.pm())); return res; } Nef_polyhedron_2 join(const Nef_polyhedron_2& N1) const /*{\Mop returns |\Mvar| $\cup$ |N1|. }*/ { Nef_polyhedron_2 res(pm(),false); // empty, no frame Overlayer D(res.pm()); D.subdivide(pm(),N1.pm()); OR _or; D.select(_or); res.clear_outer_face_cycle_marks(); D.simplify(Except_frame_box_edges(res.pm())); return res; } Nef_polyhedron_2 difference(const Nef_polyhedron_2& N1) const /*{\Mop returns |\Mvar| $-$ |N1|. }*/ { Nef_polyhedron_2 res(pm(),false); // empty, no frame Overlayer D(res.pm()); D.subdivide(pm(),N1.pm()); DIFF _diff; D.select(_diff); res.clear_outer_face_cycle_marks(); D.simplify(Except_frame_box_edges(res.pm())); return res; } Nef_polyhedron_2 symmetric_difference( const Nef_polyhedron_2& N1) const /*{\Mop returns the symmectric difference |\Mvar - T| $\cup$ |T - \Mvar|. }*/ { Nef_polyhedron_2 res(pm(),false); // empty, no frame Overlayer D(res.pm()); D.subdivide(pm(),N1.pm()); XOR _xor; D.select(_xor); res.clear_outer_face_cycle_marks(); D.simplify(Except_frame_box_edges(res.pm())); return res; } #if 0 Nef_polyhedron_2 transform(const Aff_transformation& t) const /*{\Mop returns $t(|\Mvar|)$.}*/ { Nef_polyhedron_2 res(pm()); // cloned Transformer PMT(res.pm()); PMT.transform(t); return res; } #endif /*{\Mtext Additionally there are operators |*,+,-,^,!| which implement the binary operations \emph{intersection}, \emph{union}, \emph{difference}, \emph{symmetric difference}, and the unary operation \emph{complement} respectively. There are also the corresponding modification operations |*=,+=,-=,^=|.}*/ Nef_polyhedron_2 operator*(const Nef_polyhedron_2& N1) const { return intersection(N1); } Nef_polyhedron_2 operator+(const Nef_polyhedron_2& N1) const { return join(N1); } Nef_polyhedron_2 operator-(const Nef_polyhedron_2& N1) const { return difference(N1); } Nef_polyhedron_2 operator^(const Nef_polyhedron_2& N1) const { return symmetric_difference(N1); } Nef_polyhedron_2 operator!() const { return complement(); } Nef_polyhedron_2& operator*=(const Nef_polyhedron_2& N1) { *this = intersection(N1); return *this; } Nef_polyhedron_2& operator+=(const Nef_polyhedron_2& N1) { *this = join(N1); return *this; } Nef_polyhedron_2& operator-=(const Nef_polyhedron_2& N1) { *this = difference(N1); return *this; } Nef_polyhedron_2& operator^=(const Nef_polyhedron_2& N1) { *this = symmetric_difference(N1); return *this; } /*{\Mtext There are also comparison operations like |<,<=,>,>=,==,!=| which implement the relations subset, subset or equal, superset, superset or equal, equality, inequality, respectively.}*/ bool operator==(const Nef_polyhedron_2& N1) const { return symmetric_difference(N1).is_empty(); } bool operator!=(const Nef_polyhedron_2& N1) const { return !operator==(N1); } bool operator<=(const Nef_polyhedron_2& N1) const { return difference(N1).is_empty(); } bool operator<(const Nef_polyhedron_2& N1) const { return difference(N1).is_empty() && !N1.difference(*this).is_empty(); } bool operator>=(const Nef_polyhedron_2& N1) const { return N1.difference(*this).is_empty(); } bool operator>(const Nef_polyhedron_2& N1) const { return N1.difference(*this).is_empty() && !difference(N1).is_empty(); } /*{\Mtext \headerline{Exploration - Point location - Ray shooting} As Nef polyhedra are the result of forming complements and intersections starting from a set |H| of half-spaces that are defined by oriented lines in the plane, they can be represented by an attributed plane map $M = (V,E,F)$. For topological queries within |M| the following types and operations allow exploration access to this structure.}*/ /*{\Mtypes 3}*/ typedef Const_decorator Topological_explorer; typedef CGAL::PM_explorer Explorer; /*{\Mtypemember a decorator to examine the underlying plane map. See the manual page of |Explorer|.}*/ typedef typename Locator::Object_handle Object_handle; /*{\Mtypemember a generic handle to an object of the underlying plane map. The kind of object |(vertex, halfedge, face)| can be determined and the object can be assigned to a corresponding handle by the three functions:\\ |bool assign(Vertex_const_handle& h, Object_handle)|\\ |bool assign(Halfedge_const_handle& h, Object_handle)|\\ |bool assign(Face_const_handle& h, Object_handle)|\\ where each function returns |true| iff the assignment to |h| was done.}*/ enum Location_mode { DEFAULT, NAIVE, LMWT }; /*{\Menum selection flag for the point location mode.}*/ /*{\Moperations 3 1 }*/ void init_locator() const { const_cast(this)->ptr()->init_locator(); } const Locator& locator() const { assert(ptr()->pl_); return *(ptr()->pl_); } bool contains(Object_handle h) const /*{\Mop returns true iff the object |h| is contained in the set represented by |\Mvar|.}*/ { Slocator PL(pm()); return PL.mark(h); } bool contained_in_boundary(Object_handle h) const /*{\Mop returns true iff the object |h| is contained in the $1$-skeleton of |\Mvar|.}*/ { Vertex_const_handle v; Halfedge_const_handle e; return ( CGAL::assign(v,h) || CGAL::assign(e,h) ); } Object_handle locate(const Point& p, Location_mode m = DEFAULT) const /*{\Mop returns a generic handle |h| to an object (face, halfedge, vertex) of the underlying plane map that contains the point |p| in its relative interior. The point |p| is contained in the set represented by |\Mvar| if |\Mvar.contains(h)| is true. The location mode flag |m| allows one to choose between different point location strategies.}*/ { if (m == DEFAULT || m == LMWT) { init_locator(); Extended_point ep = EK.construct_point(p); return locator().locate(ep); } else if (m == NAIVE) { Slocator PL(pm(),EK); Extended_segment s(EK.construct_point(p), PL.point(PL.vertices_begin())); return PL.locate(s); } CGAL_assertion_msg(0,"location mode not implemented."); return Object_handle(); } struct INSET { const Const_decorator& D; INSET(const Const_decorator& Di) : D(Di) {} bool operator()(Vertex_const_handle v) const { return D.mark(v); } bool operator()(Halfedge_const_handle e) const { return D.mark(e); } bool operator()(Face_const_handle f) const { return D.mark(f); } }; friend struct INSET; Object_handle ray_shoot(const Point& p, const Direction& d, Location_mode m = DEFAULT) const /*{\Mop returns a handle |h| with |\Mvar.contains(h)| that can be converted to a |Vertex_/Halfedge_/Face_const_handle| as described above. The object returned is intersected by the ray starting in |p| with direction |d| and has minimal distance to |p|. The operation returns the null handle |NULL| if the ray shoot along |d| does not hit any object |h| of |\Mvar| with |\Mvar.contains(h)|. The location mode flag |m| allows one to choose between different point location strategies.}*/ { if (m == DEFAULT || m == LMWT) { init_locator(); Extended_point ep = EK.construct_point(p), eq = EK.construct_point(p,d); return locator().ray_shoot(EK.construct_segment(ep,eq), INSET(locator())); } else if (m == NAIVE) { Slocator PL(pm(),EK); Extended_point ep = EK.construct_point(p), eq = EK.construct_point(p,d); return PL.ray_shoot(EK.construct_segment(ep,eq),INSET(PL)); } CGAL_assertion_msg(0,"location mode not implemented."); return Object_handle(); } struct INSKEL { bool operator()(Vertex_const_handle) const { return true; } bool operator()(Halfedge_const_handle) const { return true; } bool operator()(Face_const_handle) const { return false; } }; Object_handle ray_shoot_to_boundary(const Point& p, const Direction& d, Location_mode m = DEFAULT) const /*{\Mop returns a handle |h| that can be converted to a |Vertex_/Halfedge_const_handle| as described above. The object returned is part of the $1$-skeleton of |\Mvar|, intersected by the ray starting in |p| with direction |d| and has minimal distance to |p|. The operation returns the null handle |NULL| if the ray shoot along |d| does not hit any $1$-skeleton object |h| of |\Mvar|. The location mode flag |m| allows one to choose between different point location strategies.}*/ { if (m == DEFAULT || m == LMWT) { init_locator(); Extended_point ep = EK.construct_point(p), eq = EK.construct_point(p,d); return locator().ray_shoot(EK.construct_segment(ep,eq),INSKEL()); } else if (m == NAIVE) { Slocator PL(pm(),EK); Extended_point ep = EK.construct_point(p), eq = EK.construct_point(p,d); return PL.ray_shoot(EK.construct_segment(ep,eq),INSKEL()); } CGAL_assertion_msg(0,"location mode not implemented."); return Object_handle(); } Explorer explorer() const { return Explorer(pm(),EK); } /*{\Mop returns a decorator object which allows read-only access of the underlying plane map. See the manual page |Explorer| for its usage.}*/ /*{\Mtext\headerline{Input and Output} A Nef polyhedron |\Mvar| can be visualized in a |Window_stream W|. The output operator is defined in the file |CGAL/IO/Nef_\-poly\-hedron_2_\-Win\-dow_\-stream.h|. }*/ /*{\Mimplementation Nef polyhedra are implemented on top of a halfedge data structure and use linear space in the number of vertices, edges and facets. Operations like |empty| take constant time. The operations |clear|, |complement|, |interior|, |closure|, |boundary|, |regularization|, input and output take linear time. All binary set operations and comparison operations take time $O(n \log n)$ where $n$ is the size of the output plus the size of the input. The point location and ray shooting operations are implemented in two flavors. The |NAIVE| operations run in linear query time without any preprocessing, the |DEFAULT| operations (equals |LMWT|) run in sub-linear query time, but preprocessing is triggered with the first operation. Preprocessing takes time $O(N^2)$, the sub-linear point location time is either logarithmic when LEDA's persistent dictionaries are present or if not then the point location time is worst-case linear, but experiments show often sublinear runtimes. Ray shooting equals point location plus a walk in the constrained triangulation overlayed on the plane map representation. The cost of the walk is proportional to the number of triangles passed in direction |d| until an obstacle is met. In a minimum weight triangulation of the obstacles (the plane map representing the polyhedron) the theory provides a $O(\sqrt{n})$ bound for the number of steps. Our locally minimum weight triangulation approximates the minimum weight triangulation only heuristically (the calculation of the minimum weight triangulation is conjectured to be NP hard). Thus we have no runtime guarantee but a strong experimental motivation for its approximation.}*/ /*{\Mexample Nef polyhedra are parameterized by a so-called extended geometric kernel. There are three kernels, one based on a homogeneous representation of extended points called |Extended_homogeneous| where |RT| is a ring type providing additionally a |gcd| operation and one based on a cartesian representation of extended points called |Extended_cartesian| where |NT| is a field type, and finally |Filtered_extended_homogeneous| (an optimized version of the first). The member types of |Nef_polyhedron_2< Extended_homogeneous >| map to corresponding types of the CGAL geometry kernel (e.g. |Nef_polyhedron::Line| equals |CGAL::Homogeneous::Line_2| in the example below). \begin{Mverb} #include #include #include #include using namespace CGAL; typedef Extended_homogeneous Extended_kernel; typedef Nef_polyhedron_2 Nef_polyhedron; typedef Nef_polyhedron::Line Line; int main() { Nef_polyhedron N1(Line(1,0,0)); Nef_polyhedron N2(Line(0,1,0), Nef_polyhedron::EXCLUDED); Nef_polyhedron N3 = N1 * N2; // line (*) return 0; } \end{Mverb} After line (*) |N3| is the intersection of |N1| and |N2|.}*/ }; // end of Nef_polyhedron_2 template T Nef_polyhedron_2::EK; template std::ostream& operator<< (std::ostream& os, const Nef_polyhedron_2& NP) { os << "Nef_polyhedron_2<" << NP.EK.output_identifier() << ">\n"; typedef typename Nef_polyhedron_2::Decorator Decorator; CGAL::PM_io_parser O(os, NP.pm()); O.print(); return os; } template std::istream& operator>> (std::istream& is, Nef_polyhedron_2& NP) { typedef typename Nef_polyhedron_2::Decorator Decorator; CGAL::PM_io_parser I(is, NP.pm()); if (I.check_sep("Nef_polyhedron_2<") && I.check_sep(NP.EK.output_identifier()) && I.check_sep(">")) I.read(); else { std::cerr << "Nef_polyhedron_2 input corrupted." << std::endl; NP = Nef_polyhedron_2(); } typename Nef_polyhedron_2::Topological_explorer D(NP.explorer()); D.check_integrity_and_topological_planarity(); return is; } CGAL_END_NAMESPACE #endif //CGAL_NEF_POLYHEDRON_2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_ellipse_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_ellipse_20000644000175000017500000003263711344301500031373 0ustar debiandebian// Copyright (c) 1997-2001 Freie Universitaet Berlin (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Optimisation_ellipse_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Sven Schoenherr , Bernd Gaertner #ifndef CGAL_OPTIMISATION_ELLIPSE_2_H #define CGAL_OPTIMISATION_ELLIPSE_2_H #include #include #ifndef CGAL_IO_FORWARD_DECL_WINDOW_STREAM_H # include #endif CGAL_BEGIN_NAMESPACE // Class interface // =============== template < class K_ > class Optimisation_ellipse_2 { /* friend std::ostream& operator << <> ( std::ostream&, const Optimisation_ellipse_2&); friend std::istream& operator >> <> ( std::istream&, Optimisation_ellipse_2 &); friend CGAL::Window_stream& operator << <> ( CGAL::Window_stream&, const Optimisation_ellipse_2&); */ public: // types typedef K_ K; typedef typename K_::RT RT; typedef typename K_::FT FT; typedef typename K::Point_2 Point; typedef typename K::Conic_2 Conic; /************************************************************************** WORKAROUND: Some compilers are unable to match member functions defined outside the class template. Therefore, all member functions are implemented in the class interface. // creation Optimisation_ellipse_2( ); void set( ); void set( const Point& p); void set( const Point& p, const Point& q); void set( const Point& p1, const Point& p2, const Point& p3); void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4); void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4, const Point& p5); // access functions int number_of_boundary_points() // equality tests bool operator == ( const Optimisation_ellipse_2& e) const; bool operator != ( const Optimisation_ellipse_2& e) const; // predicates CGAL::Bounded_side bounded_side( const Point& p) const; bool has_on_bounded_side ( const Point& p) const; bool has_on_boundary ( const Point& p) const; bool has_on_unbounded_side ( const Point& p) const; bool is_empty ( ) const; bool is_degenerate( ) const; **************************************************************************/ /* private: */ // private data members int n_boundary_points; // number of boundary points Point boundary_point1, boundary_point2, boundary_point3, boundary_point4, boundary_point5; // <= 5 support point Conic conic1, conic2; // two conics // this gradient vector has dr=0 and is used in testing the // position of a point relative to an ellipse through 4 points mutable RT dr, ds, dt, du, dv, dw; mutable bool d_values_set; // this gradient vector is just conic2 - conic1 and is used in // obtaining an explicit conic representing an ellipse through 4 poinnts mutable RT er, es, et, eu, ev, ew; mutable bool e_values_set; // needed in bounded-side predicate over ellipse with 4 support points mutable Conic helper_ellipse; // needed in bounded-side predicate over mutable bool helper_ellipse_set; mutable Conic helper_conic; // also needed in bounded-side test // ============================================================================ // Class implementation // ==================== public: // Constructor // ----------- inline Optimisation_ellipse_2( ) : er(0), es(0), et(0), eu(0), ev(0), ew(0) { } // Set functions // ------------- inline void set( ) { n_boundary_points = 0; } inline void set( const Point& p) { n_boundary_points = 1; boundary_point1 = p; } inline void set( const Point& p, const Point& q) { n_boundary_points = 2; CGAL_optimisation_precondition(boundary_point1 == p); boundary_point2 = q; } inline void set( const Point& p1, const Point& p2, const Point& p3) { n_boundary_points = 3; CGAL_optimisation_precondition(boundary_point1 == p1); CGAL_optimisation_precondition(boundary_point2 == p2); boundary_point3 = p3; conic1.set_ellipse( p1, p2, p3); } inline void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4) { n_boundary_points = 4; CGAL_optimisation_precondition(boundary_point1 == p1); CGAL_optimisation_precondition(boundary_point2 == p2); CGAL_optimisation_precondition(boundary_point3 == p3); boundary_point4 = p4; Conic::set_two_linepairs( p1, p2, p3, p4, conic1, conic2); d_values_set = false; e_values_set = false; helper_ellipse_set = false; } void set_d_values() const { if (!d_values_set) { dr = RT( 0); ds = conic1.r() * conic2.s() - conic2.r() * conic1.s(), dt = conic1.r() * conic2.t() - conic2.r() * conic1.t(), du = conic1.r() * conic2.u() - conic2.r() * conic1.u(), dv = conic1.r() * conic2.v() - conic2.r() * conic1.v(), dw = conic1.r() * conic2.w() - conic2.r() * conic1.w(); d_values_set = true; } } void set_e_values() const { if (!e_values_set) { er = conic2.r() - conic1.r(); es = conic2.s() - conic1.s(); et = conic2.t() - conic1.t(); eu = conic2.u() - conic1.u(); ev = conic2.v() - conic1.v(); ew = conic2.w() - conic1.w(); e_values_set = true; } } void set_helper_ellipse () const { if (!helper_ellipse_set) { helper_ellipse.set_ellipse( conic1, conic2); helper_ellipse.analyse(); CGAL_optimisation_assertion (helper_ellipse.is_ellipse()); helper_ellipse_set= true; } } void set( const Point& p1, const Point& p2, const Point& p3, const Point& p4, const Point& p5) { // uses the fact that the conic to be constructed has already // been computed in preceding bounded-side test over a 4-point // ellipse conic1 = helper_conic; n_boundary_points = 5; CGAL_optimisation_precondition(boundary_point1 == p1); CGAL_optimisation_precondition(boundary_point2 == p2); CGAL_optimisation_precondition(boundary_point3 == p3); CGAL_optimisation_precondition(boundary_point4 == p4); boundary_point5 = p5; } // Access functions // ---------------- inline int number_of_boundary_points( ) const { return( n_boundary_points); } template void double_conic(DoubleConic_2& e) const { double r,s,t,u,v,w; double_coefficients(r,s,t,u,v,w); e.set(r,s,t,u,v,w); // actually, we would have to call e.analyse() now to get // a clean conic, but since this is only internal stuff // right now, the call is omitted to save time } void double_coefficients (double &r, double &s,double &t, double &u, double &v, double &w) const { // just like double_conic, but we only get the coefficients CGAL_optimisation_precondition( ! is_degenerate()); double tau = 0.0; if ( n_boundary_points == 4) { set_e_values(); tau = conic1.vol_minimum( er, es, et, eu, ev, ew); } r = CGAL::to_double( conic1.r()) + tau*CGAL::to_double( er); s = CGAL::to_double( conic1.s()) + tau*CGAL::to_double( es); t = CGAL::to_double( conic1.t()) + tau*CGAL::to_double( et); u = CGAL::to_double( conic1.u()) + tau*CGAL::to_double( eu); v = CGAL::to_double( conic1.v()) + tau*CGAL::to_double( ev); w = CGAL::to_double( conic1.w()) + tau*CGAL::to_double( ew); } // Equality tests // -------------- bool operator == ( const Optimisation_ellipse_2& e) const { if ( n_boundary_points != e.n_boundary_points) return( false); switch ( n_boundary_points) { case 0: return( true); case 1: return( boundary_point1 == e.boundary_point1); case 2: return( ( ( boundary_point1 == e.boundary_point1) && ( boundary_point2 == e.boundary_point2)) || ( ( boundary_point1 == e.boundary_point2) && ( boundary_point2 == e.boundary_point1))); case 3: case 5: return( conic1 == e.conic1); case 4: return( ( ( conic1 == e.conic1) && ( conic2 == e.conic2)) || ( ( conic1 == e.conic2) && ( conic2 == e.conic1))); default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5)); } // keeps g++ happy return( false); } inline bool operator != ( const Optimisation_ellipse_2& e) const { return( ! operator == ( e)); } // Predicates // ---------- inline CGAL::Bounded_side bounded_side( const Point& p) const { switch ( n_boundary_points) { case 0: return( CGAL::ON_UNBOUNDED_SIDE); case 1: return( ( p == boundary_point1) ? CGAL::ON_BOUNDARY : CGAL::ON_UNBOUNDED_SIDE); case 2: return( ( p == boundary_point1) || ( p == boundary_point2) || ( CGAL::are_ordered_along_line( boundary_point1, p, boundary_point2)) ? CGAL::ON_BOUNDARY : CGAL::ON_UNBOUNDED_SIDE); case 3: case 5: return( conic1.convex_side( p)); case 4: { helper_conic.set( conic1, conic2, p); helper_conic.analyse(); if ( !helper_conic.is_ellipse()) { set_helper_ellipse(); return( helper_ellipse.convex_side( p)); } else { set_d_values(); int tau_star = helper_conic.vol_derivative( dr, ds, dt, du, dv, dw); return( CGAL::Bounded_side( CGAL_NTS sign( tau_star))); } } default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); } // keeps g++ happy return( CGAL::Bounded_side( 0)); } inline bool has_on_bounded_side( const Point& p) const { return( bounded_side( p) == CGAL::ON_BOUNDED_SIDE); } inline bool has_on_boundary( const Point& p) const { return( bounded_side( p) == CGAL::ON_BOUNDARY); } inline bool has_on_unbounded_side( const Point& p) const { return( bounded_side( p) == CGAL::ON_UNBOUNDED_SIDE); } inline bool is_empty( ) const { return( n_boundary_points == 0); } inline bool is_degenerate( ) const { return( n_boundary_points < 3); } bool is_circle( ) const { switch ( n_boundary_points) { case 0: return false; // the empty set is not a circle case 1: return true; case 2: return false; // a segment is not a circle case 3: case 5: return conic1.is_circle(); case 4: // the smallest ellipse through four points is // a circle only if the four points are cocircular; // if so, compute this circle (as a conic) and check // its volume derivative if (CGAL::ON_BOUNDARY != CGAL::side_of_bounded_circle (boundary_point1, boundary_point2, boundary_point3, boundary_point4)) { return false; } else { // ok, they are cocircular, now get the circle and check it Conic c; c.set_circle(boundary_point1, boundary_point2, boundary_point3); set_d_values(); return (CGAL_NTS is_zero (c.vol_derivative (dr, ds, dt, du, dv, dw))); } default: CGAL_optimisation_assertion( ( n_boundary_points >= 0) && ( n_boundary_points <= 5) ); return false; } } }; // Function declarations // ===================== // I/O // --- template < class K_ > std::ostream& operator << ( std::ostream&, const CGAL::Optimisation_ellipse_2&); template < class K_ > std::istream& operator >> ( std::istream&, CGAL::Optimisation_ellipse_2&); CGAL_END_NAMESPACE #ifdef CGAL_CFG_NO_AUTOMATIC_TEMPLATE_INCLUSION # include #endif #endif // CGAL_OPTIMISATION_ELLIPSE_2_H // ===== EOF ================================================================== ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_traits_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_trai0000644000175000017500000000565111344301501031516 0ustar debiandebian// Copyright (c) 2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Vertex_visibility_traits_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Susan Hert #ifndef VERTEX_VISIBILITY_TRAITS_2_H #define VERTEX_VISIBILITY_TRAITS_2_H namespace CGAL { template class Vertex_visibility_traits_2 { public: typedef Kernel_ Kernel; typedef typename Kernel::Point_2 Point_2; typedef typename Kernel::Segment_2 Segment_2; typedef typename Kernel::Ray_2 Ray_2; typedef typename Kernel::Construct_segment_2 Construct_segment_2; typedef typename Kernel::Construct_ray_2 Construct_ray_2; typedef typename Kernel::Less_yx_2 Less_yx_2; typedef typename Kernel::Less_xy_2 Less_xy_2; typedef typename Kernel::Compare_x_2 Compare_x_2; typedef typename Kernel::Compare_y_2 Compare_y_2; typedef typename Kernel::Left_turn_2 Left_turn_2; typedef typename Kernel::Orientation_2 Orientation_2; typedef typename Kernel::Collinear_are_ordered_along_line_2 Collinear_are_ordered_along_line_2; typedef typename Kernel::Are_strictly_ordered_along_line_2 Are_strictly_ordered_along_line_2; Compare_x_2 compare_x_2_object() const { return Compare_x_2(); } Compare_y_2 compare_y_2_object() const { return Compare_y_2(); } Less_yx_2 less_yx_2_object() const { return Less_yx_2(); } Less_xy_2 less_xy_2_object() const { return Less_xy_2(); } Left_turn_2 left_turn_2_object() const { return Left_turn_2(); } Orientation_2 orientation_2_object() const { return Orientation_2(); } Collinear_are_ordered_along_line_2 collinear_are_ordered_along_line_2_object() const { return Collinear_are_ordered_along_line_2(); } Are_strictly_ordered_along_line_2 are_strictly_ordered_along_line_2_object() const { return Are_strictly_ordered_along_line_2(); } Construct_segment_2 construct_segment_2_object() const { return Construct_segment_2(); } Construct_ray_2 construct_ray_2_object() const { return Construct_ray_2(); } }; } #endif // VERTEX_VISIBILITY_TRAITS_2_H ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_b0000644000175000017500000000565711344301501031477 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Triangulation_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Mariette Yvinec #ifndef CGAL_TRIANGULATION_VERTEX_BASE_2_H #define CGAL_TRIANGULATION_VERTEX_BASE_2_H #include #include #include CGAL_BEGIN_NAMESPACE template < typename GT, typename Vb = Triangulation_ds_vertex_base_2<> > class Triangulation_vertex_base_2 : public Vb { typedef typename Vb::Triangulation_data_structure Tds; public: typedef GT Geom_traits; typedef typename GT::Point_2 Point; typedef Tds Triangulation_data_structure; typedef typename Tds::Face_handle Face_handle; typedef typename Tds::Vertex_handle Vertex_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Triangulation_vertex_base_2 Other; }; private: Point _p; public: Triangulation_vertex_base_2 () : Vb() {} Triangulation_vertex_base_2(const Point & p) : Vb(), _p(p) {} Triangulation_vertex_base_2(const Point & p, Face_handle f) : Vb(f), _p(p) {} Triangulation_vertex_base_2(Face_handle f) : Vb(f) {} void set_point(const Point & p) { _p = p; } const Point& point() const { return _p; } // the non const version of point() is undocument // but needed to make the point iterator works // using Lutz projection scheme Point& point() { return _p; } //the following trivial is_valid to allow // the user of derived face base classes // to add their own purpose checking bool is_valid(bool /* verbose */ = false, int /* level */ = 0) const {return true;} }; template < class GT, class Vb > std::istream& operator>>(std::istream &is, Triangulation_vertex_base_2 &v) // non combinatorial information. Default = point { return is >> static_cast(v) >> v.point(); } template < class GT, class Vb > std::ostream& operator<<(std::ostream &os, const Triangulation_vertex_base_2 &v) // non combinatorial information. Default = point { return os << static_cast(v) << v.point(); } CGAL_END_NAMESPACE #endif //CGAL_TRIANGULATION_VERTEX_BASE_2_H ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_hierarchy_vertex_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_hiera0000644000175000017500000000447411344301500031432 0ustar debiandebian// Copyright (c) 2003,2004 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Apollonius_graph_hierarchy_vertex_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Menelaos Karavelas #ifndef CGAL_APOLLONIUS_GRAPH_HIERARCHY_VERTEX_BASE_2_H #define CGAL_APOLLONIUS_GRAPH_HIERARCHY_VERTEX_BASE_2_H #include #include CGAL_BEGIN_NAMESPACE template < class Vbb > class Apollonius_graph_hierarchy_vertex_base_2 : public Vbb { typedef Vbb Base; typedef typename Base::Apollonius_graph_data_structure_2 Agds; public: typedef typename Base::Site_2 Site_2; typedef Agds Apollonius_graph_data_structure_2; typedef typename Agds::Vertex_handle Vertex_handle; typedef typename Agds::Face_handle Face_handle; template < typename AGDS2 > struct Rebind_TDS { typedef typename Vbb::template Rebind_TDS::Other Vb2; typedef Apollonius_graph_hierarchy_vertex_base_2 Other; }; Apollonius_graph_hierarchy_vertex_base_2() : Base(), _up(), _down() {} Apollonius_graph_hierarchy_vertex_base_2(const Site_2& p, Face_handle f) : Base(p,f), _up(), _down() {} Apollonius_graph_hierarchy_vertex_base_2(const Site_2& p) : Base(p), _up(), _down() {} Vertex_handle up() {return _up;} Vertex_handle down() {return _down;} void set_up(Vertex_handle u) {_up=u;} void set_down(Vertex_handle d) {if (this) _down=d;} private: Vertex_handle _up; // same vertex one level above Vertex_handle _down; // same vertex one level below }; CGAL_END_NAMESPACE #endif // CGAL_APOLLONIUS_GRAPH_HIERARCHY_VERTEX_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Unique_hash_map.h0000644000175000017500000001247411344301501030310 0ustar debiandebian// Copyright (c) 1997-2000 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Unique_hash_map.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Michael Seel // Lutz Kettner #ifndef CGAL_UNIQUE_HASH_MAP_H #define CGAL_UNIQUE_HASH_MAP_H #include #include #include #include CGAL_BEGIN_NAMESPACE template class Unique_hash_map { public: typedef Key_ Key; typedef Data_ Data; typedef UniqueHashFunction Hash_function; // STL compliance typedef Key_ key_type; typedef Data_ data_type; typedef UniqueHashFunction hasher; typedef Unique_hash_map Self; private: typedef CGALi::chained_map Map; typedef typename Map::item Item; private: Hash_function m_hash_function; Map m_map; public: Unique_hash_map() { m_map.xdef() = Data(); } Unique_hash_map( const Data& deflt, std::size_t table_size = 1) : m_map( table_size) { m_map.xdef() = deflt; } Unique_hash_map( const Data& deflt, std::size_t table_size, const Hash_function& fct) : m_hash_function(fct), m_map( table_size) { m_map.xdef() = deflt; } Unique_hash_map( Key first1, Key beyond1, Data first2) { m_map.xdef() = Data(); insert( first1, beyond1, first2); } Unique_hash_map( Key first1, Key beyond1, Data first2, const Data& deflt, std::size_t table_size = 1, const Hash_function& fct = Hash_function()) : m_hash_function(fct), m_map( table_size) { m_map.xdef() = deflt; insert( first1, beyond1, first2); } Data default_value() const { return m_map.cxdef(); } Hash_function hash_function() const { return m_hash_function; } void clear() { m_map.clear(); } void clear( const Data& deflt) { m_map.clear(); m_map.xdef() = deflt; } bool is_defined( const Key& key) const { return m_map.lookup( m_hash_function(key)) != 0; } const Data& operator[]( const Key& key) const { Item p = m_map.lookup( m_hash_function(key)); if ( p != 0 ) return m_map.inf(p); return m_map.cxdef(); } Data& operator[]( const Key& key) { return m_map.access( m_hash_function(key)); } Data insert( Key first1, Key beyond1, Data first2) { for ( ; first1 != beyond1; (++first1, ++first2)) { operator[]( first1) = first2; } return first2; } void statistics() const { m_map.statistics(); } }; CGAL_END_NAMESPACE namespace boost { template class associative_property_map; struct lvalue_property_map_tag; template class associative_property_map > { typedef CGAL::Unique_hash_map C; public: typedef KeyType key_type; typedef ValueType value_type; typedef value_type& reference; typedef lvalue_property_map_tag category; associative_property_map() : m_c(0) { } associative_property_map(C& c) : m_c(&c) { } reference operator[](const key_type& k) const { return (*m_c)[k]; } private: C* m_c; }; template associative_property_map > make_assoc_property_map(CGAL::Unique_hash_map & c) { return associative_property_map >(c); } template ValueType& get(const associative_property_map >& uhm, const KeyType& key) { return uhm[key]; } template void put(associative_property_map >& uhm, const KeyType& key, const ValueType& val) { uhm[key] = val; } } #endif // CGAL_UNIQUE_HASH_MAP_H // EOF ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_vertex_base_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_vertex_bas0000644000175000017500000000427311344301500031400 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Alpha_shape_vertex_base_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Tran Kai Frank DA #ifndef CGAL_ALPHA_SHAPE_VERTEX_BASE_3_H #define CGAL_ALPHA_SHAPE_VERTEX_BASE_3_H #include #include #include #include CGAL_BEGIN_NAMESPACE template > class Alpha_shape_vertex_base_3 : public Vb { public: typedef typename Vb::Cell_handle Cell_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Vb::template Rebind_TDS::Other Vb2; typedef Alpha_shape_vertex_base_3 Other; }; typedef typename Gt::Point_3 Point; typedef typename Gt::FT NT; typedef CGAL::Alpha_status Alpha_status; typedef Compact_container Alpha_status_container; typedef typename Alpha_status_container::const_iterator Alpha_status_const_iterator; typedef typename Alpha_status_container::iterator Alpha_status_iterator; private: Alpha_status _as; public: Alpha_shape_vertex_base_3() : Vb() {} Alpha_shape_vertex_base_3(const Point& p) : Vb(p) {} Alpha_shape_vertex_base_3(const Point& p, Cell_handle c) : Vb(p, c) {} Alpha_status* get_alpha_status() { return &_as;} void set_alpha_status(Alpha_status_iterator as) {_as= as;} }; CGAL_END_NAMESPACE #endif // CGAL_ALPHA_SHAPE_VERTEX_BASE_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Aff_transformation_2.h0000644000175000017500000001027311344301500031237 0ustar debiandebian// Copyright (c) 1999 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Aff_transformation_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri // Stefan Schirra #ifndef CGAL_AFF_TRANSFORMATION_2_H #define CGAL_AFF_TRANSFORMATION_2_H CGAL_BEGIN_NAMESPACE template class Aff_transformation_2 : public R_::Kernel_base::Aff_transformation_2 { typedef typename R_::RT RT; typedef typename R_::FT FT; typedef typename R_::Line_2 Line_2; typedef typename R_::Direction_2 Direction_2; typedef typename R_::Vector_2 Vector_2; typedef typename R_::Kernel_base::Aff_transformation_2 RAff_transformation_2; public: typedef R_ R; Aff_transformation_2() {} Aff_transformation_2(const RAff_transformation_2& t) : RAff_transformation_2(t) {} Aff_transformation_2(const Identity_transformation tag) : RAff_transformation_2(tag) {} Aff_transformation_2(const Translation tag, const Vector_2 &v) : RAff_transformation_2(tag, v) {} // Rational Rotation: Aff_transformation_2(const Rotation tag, const Direction_2 &d, const RT &num, const RT &den = RT(1)) : RAff_transformation_2(tag, d, num, den) {} Aff_transformation_2(const Rotation tag, const RT &sin, const RT &cos, const RT &den = RT(1)) : RAff_transformation_2(tag, sin, cos, den) {} Aff_transformation_2(const Reflection tag, const Line_2& l ) : RAff_transformation_2(tag, l) {} Aff_transformation_2(const Scaling tag, const RT &s, const RT &w= RT(1)) : RAff_transformation_2(tag, s, w) {} // The general case: Aff_transformation_2(const RT & m11, const RT & m12, const RT & m13, const RT & m21, const RT & m22, const RT & m23, const RT &w= RT(1)) : RAff_transformation_2(m11, m12, m13, m21, m22, m23, w) {} Aff_transformation_2(const RT & m11, const RT & m12, const RT & m21, const RT & m22, const RT &w = RT(1)) : RAff_transformation_2(m11, m12, m21, m22, w) {} }; #ifndef CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATION_2 template < class R > std::ostream & operator<<(std::ostream &os, const CGAL::Aff_transformation_2 &t) { typedef typename R::Kernel_base::Aff_transformation_2 RAff_transformation_2; return os << static_cast(t); } #endif // CGAL_NO_OSTREAM_INSERT_AFF_TRANSFORMATION_2 #ifndef CGAL_NO_ISTREAM_EXTRACT_AFF_TRANSFORMATION_2 template < class R > std::istream & operator>>(std::istream &is, CGAL::Aff_transformation_2 &t) { typedef typename R::Kernel_base::Aff_transformation_2 RAff_transformation_2; return is >> static_cast(t); } #endif // CGAL_NO_ISTREAM_EXTRACT_AFF_TRANSFORMATION_2 CGAL_END_NAMESPACE #endif // CGAL_AFF_TRANSFORMATION_2_H ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Width_default_traits_3.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Width_default_traits_30000644000175000017500000000551011344301501031340 0ustar debiandebian// Copyright (c) 1997-2000 ETH Zurich (Switzerland). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Width_default_traits_3.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:41 $ // $Name: $ // // Author(s) : Thomas Herrmann, Lutz Kettner #ifndef CGAL_WIDTH_DEFAULT_TRAITS_3_H #define CGAL_WIDTH_DEFAULT_TRAITS_3_H #include CGAL_BEGIN_NAMESPACE // without this we get an internal compiler error on bcc #if defined(__BORLANDC__) template > #else template #endif class Width_default_traits_3 { public: typedef Kernel_ Kernel; typedef typename Kernel::RT RT; typedef typename Kernel::Point_3 Point_3; typedef typename Kernel::Plane_3 Plane_3; typedef typename Kernel::Vector_3 Vector_3; #if defined(__BORLANDC__) typedef CHT ChullTraits; #else typedef Convex_hull_traits_3 ChullTraits; #endif RT get_hx( const Point_3& p) const { return p.hx(); } RT get_hy( const Point_3& p) const { return p.hy(); } RT get_hz( const Point_3& p) const { return p.hz(); } RT get_hw( const Point_3& p) const { return p.hw(); } void get_point_coordinates( const Point_3& p, RT& px, RT& py, RT& pz, RT& ph) const { px = get_hx(p); py = get_hy(p); pz = get_hz(p); ph = get_hw(p); } RT get_a( const Plane_3& f) const { return f.a(); } RT get_b( const Plane_3& f) const { return f.b(); } RT get_c( const Plane_3& f) const { return f.c(); } RT get_d( const Plane_3& f) const { return f.d(); } void get_plane_coefficients( const Plane_3& f, RT& a, RT& b, RT& c, RT& d) const { a = get_a(f); b = get_b(f); c = get_c(f); d = get_d(f); } Point_3 make_point( const RT& hx, const RT& hy, const RT& hz, const RT& hw) const { return Point_3(hx,hy,hz,hw); } Plane_3 make_plane( const RT& a, const RT& b, const RT& c, const RT& d) const { return Plane_3(a,b,c,d); } Vector_3 make_vector( const RT& a, const RT& b, const RT& c) const { return Vector_3(a,b,c); } }; CGAL_END_NAMESPACE #endif //CGAL_WIDTH_DEFAULT_TRAITS_3_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Fourtuple.h0000644000175000017500000000265511344301500027166 0ustar debiandebian// Copyright (c) 1999,2001 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Fourtuple.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Andreas Fabri #ifndef CGAL__FOURTUPLE_H #define CGAL__FOURTUPLE_H CGAL_BEGIN_NAMESPACE template < class T > class Fourtuple { public: T e0; T e1; T e2; T e3; Fourtuple() {} Fourtuple(const T & a0, const T & a1, const T & a2, const T & a3) : e0(a0), e1(a1), e2(a2), e3(a3) {} }; CGAL_END_NAMESPACE #endif // CGAL__FOURTUPLE_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian.h0000644000175000017500000000455711344301500027115 0ustar debiandebian// Copyright (c) 2000,2001,2002,2003 Utrecht University (The Netherlands), // ETH Zurich (Switzerland), Freie Universitaet Berlin (Germany), // INRIA Sophia-Antipolis (France), Martin-Luther-University Halle-Wittenberg // (Germany), Max-Planck-Institute Saarbruecken (Germany), RISC Linz (Austria), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org); 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 CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Cartesian.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Herve Bronnimann, Sylvain Pion #ifndef CGAL_CARTESIAN_H #define CGAL_CARTESIAN_H #include #include #include CGAL_BEGIN_NAMESPACE template < typename FT_, typename Kernel > struct Cartesian_base_ref_count : public Cartesian_base< Kernel, FT_ > { typedef FT_ RT; typedef FT_ FT; // The mecanism that allows to specify reference-counting or not. template < typename T > struct Handle { typedef Handle_for type; }; template < typename Kernel2 > struct Base { typedef Cartesian_base_ref_count Type; }; // TODO: cleanup (use Rational_traits<> instead) static FT make_FT(const RT & num, const RT& denom) { return num/denom;} static FT make_FT(const RT & num) { return num;} static RT FT_numerator(const FT &r) { return r;} static RT FT_denominator(const FT &) { return RT(1);} }; template < typename FT_ > struct Cartesian : public Type_equality_wrapper< Cartesian_base_ref_count >, Cartesian > {}; CGAL_END_NAMESPACE #endif // CGAL_CARTESIAN_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Extended_homogeneous.h0000644000175000017500000004550311344301500031350 0ustar debiandebian// Copyright (c) 1997-2000 Max-Planck-Institute Saarbruecken (Germany). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Extended_homogeneous.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Michael Seel #ifndef CGAL_EXTENDED_HOMOGENEOUS_H #define CGAL_EXTENDED_HOMOGENEOUS_H #include #include #include #include #include #include #include #undef CGAL_NEF_DEBUG #define CGAL_NEF_DEBUG 5 #include #include CGAL_BEGIN_NAMESPACE template class Extended_homogeneous; /*{\Moptions outfile=ExtendedKernelTraits_2.man}*/ /*{\Moptions print_title=yes }*/ /*{\Msubst Extended_homogeneous ExtendedKernelTraits_2}*/ /*{\Manpage {ExtendedKernelTraits_2}{}{Extended Kernel Traits}{K}}*/ template class Extended_homogeneous : public CGAL::Homogeneous< CGAL::Nef_polynomial > { public: /*{\Mdefinition |\Mname| is a kernel concept providing extended geometry\footnote{It is called extended geometry for simplicity, though it is not a real geometry in the classical sense.}. Let |\Mvar| be an instance of the data type |\Mname|. The central notion of extended geomtry are extended points. An extended point represents either a standard affine point of the Cartesian plane or a non-standard point representing the equivalence class of rays where two rays are equivalent if one is contained in the other. Let $R$ be an infinimaximal number\footnote{A finite but very large number.}, $F$ be the square box with corners $NW(-R,R)$, $NE(R,R)$, $SE(R,-R)$, and $SW(-R,-R)$. Let $p$ be a non-standard point and let $r$ be a ray defining it. If the frame $F$ contains the source point of $r$ then let $p(R)$ be the intersection of $r$ with the frame $F$, if $F$ does not contain the source of $r$ then $p(R)$ is undefined. For a standard point let $p(R)$ be equal to $p$ if $p$ is contained in the frame $F$ and let $p(R)$ be undefined otherwise. Clearly, for any standard or non-standard point $p$, $p(R)$ is defined for any sufficiently large $R$. Let $f$ be any function on standard points, say with $k$ arguments. We call $f$ {\em extensible} if for any $k$ points $p_1$, \ldots, $p_k$ the function value $f(p_1(R),\ldots,p_k(R))$ is constant for all sufficiently large $R$. We define this value as $f(p_1,\ldots,p_k)$. Predicates like lexicographic order of points, orientation, and incircle tests are extensible. An extended segment is defined by two extended points such that it is either an affine segment, an affine ray, an affine line, or a segment that is part of the square box. Extended directions extend the affine notion of direction to extended objects. This extended geometry concept serves two purposes. It offers functionality for changing between standard affine and extended geometry. At the same time it provides extensible geometric primitives on the extended geometric objects.}*/ typedef CGAL::Homogeneous< CGAL::Nef_polynomial > Base; typedef Extended_homogeneous Self; /*{\Mtypes 8.5}*/ /*{\Mtext \headerline{Affine kernel types}}*/ typedef CGAL::Homogeneous Standard_kernel; /*{\Mtypemember the standard affine kernel.}*/ typedef RT_ Standard_RT; /*{\Mtypemember the standard ring type.}*/ typedef typename Standard_kernel::FT Standard_FT; /*{\Xtypemember the field type.}*/ typedef typename Standard_kernel::Point_2 Standard_point_2; /*{\Mtypemember standard points.}*/ typedef typename Standard_kernel::Segment_2 Standard_segment_2; /*{\Mtypemember standard segments.}*/ typedef typename Standard_kernel::Line_2 Standard_line_2; /*{\Mtypemember standard oriented lines.}*/ typedef typename Standard_kernel::Direction_2 Standard_direction_2; /*{\Mtypemember standard directions.}*/ typedef typename Standard_kernel::Ray_2 Standard_ray_2; /*{\Mtypemember standard rays.}*/ typedef typename Standard_kernel::Aff_transformation_2 Standard_aff_transformation_2; /*{\Mtypemember standard affine transformations.}*/ /*{\Mtext \headerline{Extended kernel types}}*/ typedef typename Base::RT RT; /*{\Mtypemember the ring type of our extended kernel.}*/ typedef typename Base::Point_2 Point_2; /*{\Mtypemember extended points.}*/ typedef typename Base::Segment_2 Segment_2; /*{\Mtypemember extended segments.}*/ typedef typename Base::Direction_2 Direction_2; /*{\Mtypemember extended directions.}*/ typedef typename Base::Line_2 Line_2; // used only internally enum Point_type { SWCORNER=1, LEFTFRAME, NWCORNER, BOTTOMFRAME, STANDARD, TOPFRAME, SECORNER, RIGHTFRAME, NECORNER }; /*{\Menum a type descriptor for extended points.}*/ public: Point_2 epoint(const Standard_RT& m1, const Standard_RT& n1, const Standard_RT& m2, const Standard_RT& n2, const Standard_RT& n3) const { return Point_2(RT(n1,m1),RT(n2,m2),RT(n3)); } Point_2 construct_point(const Standard_line_2& l, Point_type& t) const { t = (Point_type)Line_to_epoint::determine_type(l); Point_2 res; switch (t) { case SWCORNER: res = epoint(-1, 0, -1, 0, 1); break; case NWCORNER: res = epoint(-1, 0, 1, 0, 1); break; case SECORNER: res = epoint( 1, 0, -1, 0, 1); break; case NECORNER: res = epoint( 1, 0, 1, 0, 1); break; case LEFTFRAME: res = epoint(-l.b(), 0, l.a(), -l.c(), l.b()); break; case RIGHTFRAME: res = epoint( l.b(), 0, -l.a(), -l.c(), l.b()); break; case BOTTOMFRAME: res = epoint( l.b(), -l.c(), -l.a(), 0, l.a()); break; case TOPFRAME: res = epoint(-l.b(), -l.c(), l.a(), 0, l.a()); break; default: CGAL_assertion_msg(0,"EPoint type not correct!"); } return res; } template void determine_frame_radius(Forward_iterator start, Forward_iterator end, Standard_RT& R0) const { Standard_RT R, mx, nx, my, ny; while ( start != end ) { Point_2 p = *start++; if ( is_standard(p) ) { R = CGAL_NTS max(CGAL_NTS abs(p.hx()[0])/p.hw()[0], CGAL_NTS abs(p.hy()[0])/p.hw()[0]); } else { RT rx = CGAL_NTS abs(p.hx()), ry = CGAL_NTS abs(p.hy()); mx = ( rx.degree()>0 ? rx[1] : Standard_RT(0) ); nx = rx[0]; my = ( ry.degree()>0 ? ry[1] : Standard_RT(0) ); ny = ry[0]; if ( mx > my ) R = CGAL_NTS abs((ny-nx)/(mx-my)); else if ( mx < my ) R = CGAL_NTS abs((nx-ny)/(my-mx)); else /* mx == my */ R = CGAL_NTS abs(nx-ny)/(2*p.hw()[0]); } R0 = CGAL_NTS max(R+1,R0); } } /*{\Moperations 2}*/ /*{\Mtext \headerline{Interfacing the affine kernel types}}*/ Point_2 construct_point(const Standard_point_2& p) const /*{\Mop creates an extended point and initializes it to the standard point |p|.}*/ { return Point_2(p.hx(), p.hy(), p.hw()); } Point_2 construct_point(const Standard_point_2& p1, const Standard_point_2& p2, Point_type& t) const /*{\Xop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line |l(p1,p2)|. |t| returns the type of the new extended point.}*/ { return construct_point(Standard_line_2(p1,p2),t); } Point_2 construct_point(const Standard_line_2& l) const /*{\Mop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line |l|. }*/ { Point_type dummy; return construct_point(l,dummy); } Point_2 construct_point(const Standard_point_2& p1, const Standard_point_2& p2) const /*{\Mop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line |l(p1,p2)|.}*/ { return construct_point(Standard_line_2(p1,p2)); } Point_2 construct_point(const Standard_point_2& p, const Standard_direction_2& d) const /*{\Mop creates an extended point and initializes it to the equivalence class of all the rays underlying the ray starting in |p| in direction |d|.}*/ { return construct_point(Standard_line_2(p,d)); } Point_2 construct_opposite_point(const Standard_line_2& l) const /*{\Mop creates an extended point and initializes it to the equivalence class of all the rays underlying the oriented line opposite to |l|. }*/ { Point_type dummy; return construct_point(l.opposite(),dummy); } Point_type type(const Point_2& p) const /*{\Mop determines the type of |p| and returns it.}*/ { CGAL_assertion(p.hx().degree()>=0 && p.hy().degree()>=0 ); CGAL_assertion(p.hw().degree()==0); if (p.hx().degree() == 0 && p.hy().degree() == 0) return STANDARD; // now we are on the square frame RT rx = p.hx(); RT ry = p.hy(); int sx = CGAL_NTS sign(rx); int sy = CGAL_NTS sign(ry); if (sx < 0) rx = -rx; if (sy < 0) ry = -ry; if (rx>ry) { if (sx > 0) return RIGHTFRAME; else return LEFTFRAME; } if (rx 0) return TOPFRAME; else return BOTTOMFRAME; } // now (rx == ry) if (sx==sy) { if (sx < 0) return SWCORNER; else return NECORNER; } else { CGAL_assertion(sx==-sy); if (sx < 0) return NWCORNER; else return SECORNER; } } bool is_standard(const Point_2& p) const /*{\Mop returns |true| iff |p| is a standard point.}*/ { return (type(p)==STANDARD); } Standard_point_2 standard_point(const Point_2& p) const /*{\Mop returns the standard point represented by |p|. \precond |\Mvar.is_standard(p)|.}*/ { CGAL_assertion(type(p)==STANDARD); CGAL_assertion(p.hw() > RT(0)); return Standard_point_2(p.hx()[0],p.hy()[0],p.hw()[0]); } Standard_line_2 standard_line(const Point_2& p) const /*{\Mop returns the oriented line representing the bundle of rays defining |p|. \precond |!\Mvar.is_standard(p)|.}*/ { CGAL_assertion(type(p)!=STANDARD); RT hx = p.hx(), hy = p.hy(), hw = p.hw(); Standard_RT dx,dy; if (hx.degree()>0) dx=hx[1]; else dx=0; if (hy.degree()>0) dy=hy[1]; else dy=0; Standard_point_2 p0(hx[0],hy[0],hw[0]); Standard_point_2 p1(hx[0]+dx,hy[0]+dy,hw[0]); return Standard_line_2(p0,p1); } Standard_ray_2 standard_ray(const Point_2& p) const /*{\Mop a ray defining |p|. \precond |!\Mvar.is_standard(p)|.}*/ { CGAL_assertion(type(p)!=STANDARD); Standard_line_2 l = standard_line(p); Standard_direction_2 d = l.direction(); Standard_point_2 q = l.point(0); return Standard_ray_2(q,d); } Point_2 NE() const { return construct_point(Standard_line_2(-1, 1,0)); } /*{\Mop returns the point on the northeast frame corner.}*/ Point_2 SE() const { return construct_point(Standard_line_2( 1, 1,0)); } /*{\Mop returns the point on the southeast frame corner.}*/ Point_2 NW() const { return construct_point(Standard_line_2(-1,-1,0)); } /*{\Mop returns the point on the northwest frame corner.}*/ Point_2 SW() const { return construct_point(Standard_line_2( 1,-1,0)); } /*{\Mop returns the point on the southwest frame corner.}*/ Line_2 upper() const { return construct_line(NW(),NE()); } /*{\Xop returns the line underlying the upper frame segment.}*/ Line_2 lower() const { return construct_line(SW(),SE()); } /*{\Xop returns the line underlying the lower frame segment.}*/ Line_2 left() const { return construct_line(SW(),NW()); } /*{\Xop returns the line underlying the left frame segment.}*/ Line_2 right() const { return construct_line(SE(),NE()); } /*{\Xop returns the line underlying the right frame segment.}*/ /*{\Mtext \headerline{Geometric kernel calls}}*/ Point_2 source(const Segment_2& s) const /*{\Mop returns the source point of |s|.}*/ { typename Base::Construct_vertex_2 _source = this->construct_vertex_2_object(); return _source(s,0); } Point_2 target(const Segment_2& s) const /*{\Mop returns the target point of |s|.}*/ { typename Base::Construct_vertex_2 _target = this->construct_vertex_2_object(); return _target(s,1); } Segment_2 construct_segment(const Point_2& p, const Point_2& q) const /*{\Mop constructs a segment |pq|.}*/ { typename Base::Construct_segment_2 _segment = this->construct_segment_2_object(); return _segment(p,q); } void simplify(Point_2& p) const /*{\Xop only used internally.}*/ { CGAL_NEF_TRACEN("simplify("<construct_direction_2_object(); return _direction(construct_line(p1,p2)); } bool strictly_ordered_ccw(const Direction_2& d1, const Direction_2& d2, const Direction_2& d3) const /*{\Mop returns |true| iff |d2| is in the interior of the counterclockwise angular sector between |d1| and |d3|.}*/ { if ( d1 < d2 ) return ( d2 < d3 )||( d3 <= d1 ); if ( d1 > d2 ) return ( d2 < d3 )&&( d3 <= d1 ); return false; } bool strictly_ordered_along_line( const Point_2& p1, const Point_2& p2, const Point_2& p3) const /*{\Mop returns |true| iff |p2| is in the relative interior of the segment |p1p3|.}*/ { typename Base::Are_strictly_ordered_along_line_2 _ordered = this->are_strictly_ordered_along_line_2_object(); return _ordered(p1,p2,p3); } bool contains(const Segment_2& s, const Point_2& p) const /*{\Mop returns true iff |s| contains |p|.}*/ { typename Base::Has_on_2 _contains = this->has_on_2_object(); return _contains(s,p); } bool first_pair_closer_than_second( const Point_2& p1, const Point_2& p2, const Point_2& p3, const Point_2& p4) const /*{\Mop returns true iff $\Labs{p1-p2} < \Labs{p3-p4}$.}*/ { return ( squared_distance(p1,p2) < squared_distance(p3,p4) ); } void scale_first_by_second(RT& r1, RT& r2, RT& w) const { CGAL_assertion(w.degree()==0&&w!=RT(0)&& r2[1]!=Standard_RT(0)); Standard_RT w_res = w[0]*r2[1]; int sm2 = CGAL_NTS sign(r2[1]); RT r2_res = RT(Standard_RT(0),sm2 * w_res); RT r1_res = RT(r2[1]*r1[0]-r1[1]*r2[0], w[0]*r1[1]*sm2); r1 = r1_res; r2 = r2_res; w = w_res; } Point_2 transform(const Point_2& p, const Standard_aff_transformation_2& t) const { RT tpx = t.homogeneous(0,0)*p.hx() + t.homogeneous(0,1)*p.hy() + t.homogeneous(0,2)*p.hw(); RT tpy = t.homogeneous(1,0)*p.hx() + t.homogeneous(1,1)*p.hy() + t.homogeneous(1,2)*p.hw(); RT tpw = t.homogeneous(2,2)*p.hw(); if ( is_standard(p) ) { Point_2 res(tpx,tpy,tpw); simplify(res); return res; } RT tpxa = CGAL_NTS abs(tpx); RT tpya = CGAL_NTS abs(tpy); if ( tpxa > tpya ) { scale_first_by_second(tpy,tpx,tpw); } else { // tpxa <= tpya scale_first_by_second(tpx,tpy,tpw); } Point_2 res(tpx,tpy,tpw); simplify(res); return res; } const char* output_identifier() const { return "Extended_homogeneous"; } /*{\Mop returns a unique identifier for kernel object input/output.}*/ }; CGAL_END_NAMESPACE #endif // CGAL_EXTENDED_HOMOGENEOUS_H ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_face_base_2.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_0000644000175000017500000000472411344301500031452 0ustar debiandebian// Copyright (c) 1997 INRIA Sophia-Antipolis (France). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/Regular_triangulation_face_base_2.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Frederic Fichel, Mariette Yvinec #ifndef CGAL_REGULAR_TRIANGULATION_FACE_BASE_2_H #define CGAL_REGULAR_TRIANGULATION_FACE_BASE_2_H #include #include #include #include CGAL_BEGIN_NAMESPACE template > class Regular_triangulation_face_base_2 : public Fb { typedef Fb Fbase; typedef typename Fbase::Triangulation_data_structure TDS; public: typedef Gt Geom_traits; typedef TDS Triangulation_data_structure; typedef typename TDS::Vertex_handle Vertex_handle; typedef typename TDS::Face_handle Face_handle; template < typename TDS2 > struct Rebind_TDS { typedef typename Fb::template Rebind_TDS::Other Fb2; typedef Regular_triangulation_face_base_2 Other; }; typedef std::list Vertex_list; protected: Vertex_list vlist; public: Regular_triangulation_face_base_2() : Fbase(), vlist() {} Regular_triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2) : Fbase(v0,v1,v2), vlist() { } Regular_triangulation_face_base_2(Vertex_handle v0, Vertex_handle v1, Vertex_handle v2, Face_handle n0, Face_handle n1, Face_handle n2) : Fbase(v0,v1,v2,n0,n1,n2), vlist() { } ~Regular_triangulation_face_base_2() { vlist.clear(); } Vertex_list& vertex_list() { return vlist; } }; CGAL_END_NAMESPACE #endif // CGAL_REGULAR_TRIANGULATION_FACE_BASE_2_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/CGAL/K_neighbor_search.h0000644000175000017500000001434511344301500030574 0ustar debiandebian// Copyright (c) 2002 Utrecht University (The Netherlands). // All rights reserved. // // This file is part of CGAL (www.cgal.org); you may redistribute it under // the terms of the Q Public License version 1.0. // See the file LICENSE.QPL distributed with CGAL. // // Licensees holding a valid commercial license may use this file in // accordance with the commercial license agreement provided with the software. // // This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE // WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. // // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/CGAL/K_neighbor_search.h,v $ // $Revision: 1.1.1.1 $ $Date: 2010/03/05 22:18:40 $ // $Name: $ // // Author(s) : Hans Tangelder () #ifndef CGAL_K_NEIGHBOR_SEARCH_H #define CGAL_K_NEIGHBOR_SEARCH_H #include #include #include #include #include #include #include #include namespace CGAL { template , class Splitter_=Sliding_midpoint , class Tree_=Kd_tree > class K_neighbor_search { public: typedef Splitter_ Splitter; typedef Distance_ Distance; typedef Tree_ Tree; typedef typename SearchTraits::Point_d Point_d; typedef typename SearchTraits::FT FT; typedef std::pair Point_with_transformed_distance; typedef typename Tree::Node_handle Node_handle; typedef typename Tree::Point_d_iterator Point_d_iterator; typedef Kd_tree_rectangle Rectangle; typedef typename Distance::Query_item Query_item; private: int number_of_internal_nodes_visited; int number_of_leaf_nodes_visited; int number_of_items_visited; bool search_nearest; Distance distance_instance; FT multiplication_factor; Query_item query_object; int total_item_number; FT distance_to_root; typedef std::list NN_list; public: typedef typename NN_list::const_iterator iterator; private: NN_list l; int max_k; int actual_k; bool branch(FT distance) { if (actual_ksecond); else return ( distance > l.begin()->second * multiplication_factor); } void insert(Point_d* I, FT dist) { bool insert; if (actual_ksecond ); else insert=(dist > l.begin()->second); if (insert) { actual_k++; typename NN_list::iterator it=l.begin(); for (; (it != l.end()); ++it) { if (dist < it->second) break;} Point_with_transformed_distance NN_Candidate(*I,dist); l.insert(it,NN_Candidate); if (actual_k > max_k) { actual_k--; if (search_nearest) l.pop_back(); else l.pop_front(); } } } public: iterator begin() const { return l.begin(); } iterator end() const { return l.end(); } // constructor K_neighbor_search(Tree& tree, const Query_item& q, int k=1, FT Eps=FT(0.0), bool Search_nearest=true, const Distance& d=Distance()) : number_of_internal_nodes_visited(0), number_of_leaf_nodes_visited(0), number_of_items_visited(0), search_nearest(Search_nearest), distance_instance(d), multiplication_factor(distance_instance.transformed_distance(FT(1.0)+Eps)), query_object(q), total_item_number(tree.size()), max_k(k), actual_k(0) { compute_neighbors_general(tree.root(), tree.bounding_box()); } // Print statistics of the general standard search process. std::ostream& statistics (std::ostream& s) { s << "General search statistics:" << std::endl; s << "Number of internal nodes visited:" << number_of_internal_nodes_visited << std::endl; s << "Number of leaf nodes visited:" << number_of_leaf_nodes_visited << std::endl; s << "Number of items visited:" << number_of_items_visited << std::endl; return s; } private: void compute_neighbors_general(Node_handle N, const Kd_tree_rectangle& r) { if (!(N->is_leaf())) { number_of_internal_nodes_visited++; int new_cut_dim=N->cutting_dimension(); FT new_cut_val=N->cutting_value(); Kd_tree_rectangle r_lower(r); // modifies also r_lower to lower half Kd_tree_rectangle r_upper(r_lower); r_lower.split(r_upper, new_cut_dim, new_cut_val); FT distance_to_lower_half; FT distance_to_upper_half; if (search_nearest) { distance_to_lower_half = distance_instance. min_distance_to_rectangle(query_object, r_lower); distance_to_upper_half = distance_instance.min_distance_to_rectangle(query_object, r_upper); } else { distance_to_lower_half = distance_instance.max_distance_to_rectangle(query_object, r_lower); distance_to_upper_half = distance_instance.max_distance_to_rectangle(query_object, r_upper); } if ( (( search_nearest) && (distance_to_lower_half < distance_to_upper_half)) || ((!search_nearest) && (distance_to_lower_half >= distance_to_upper_half)) ) { compute_neighbors_general(N->lower(), r_lower); if (branch(distance_to_upper_half)) compute_neighbors_general (N->upper(), r_upper); } else { compute_neighbors_general(N->upper(), r_upper); if (branch(distance_to_lower_half)) compute_neighbors_general (N->lower(), r_lower); } } else { // n is a leaf number_of_leaf_nodes_visited++; if (N->size() > 0) for (Point_d_iterator it = N->begin(); it != N->end(); it++) { number_of_items_visited++; FT distance_to_query_object = distance_instance.transformed_distance(query_object,**it); insert(*it,distance_to_query_object); } } } }; // class } // namespace CGAL #endif // CGAL_K_NEIGHBOR_SEARCH_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/0000755000175000017500000000000012146213576021260 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/setup.cfg0000644000175000017500000000003210150464520023062 0ustar debiandebian[build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/0000755000175000017500000000000012146213606022041 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/contour3d.h0000755000175000017500000000106610150464521024135 0ustar debiandebian#ifndef __CONTOUR3D_H__ #define __CONTOUR3D_H__ class Contour3d { int nvert, ntri, nquad; int vsize,tsize; float (*vert)[3]; unsigned int (*tri)[3]; unsigned int (*quad)[4]; public : Contour3d(); ~Contour3d(); void Clear(); int getNTri(void) { return ntri; } int getNQuad(void) { return nquad; } int getNVert(void) { return nvert; } int AddTri(unsigned int v1,unsigned int v2,unsigned int v3); int AddVert(float v_pos[3], float norm[3]); int center_vtx(int v1,int v2,int v3); void display(); }; #endif __CONTOUR3D_H__ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/e_face.h0000755000175000017500000000024410150464521023414 0ustar debiandebian#ifndef __E_FACE_H__ #define __E_FACE_H__ typedef struct _edge_face { int faceidx; int orientation[4]; int facebit; } edge_face; #endif __E_FACE_H__ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/geoframe.cpp0000755000175000017500000001353210150464521024336 0ustar debiandebian#include "geoframe.h" #include #include geoframe::geoframe() { normals = 0; curvatures = 0; numverts = 0; numtris = 0; num_tris = 0; numquads = 0; numhexas = 0; vsize=100000; tsize=100000; qsize=100000; verts = (float (*)[3])malloc(sizeof(float[3]) * vsize); funcs = (float (*)[1])malloc(sizeof(float[1]) * vsize); normals = (float (*)[3])malloc(sizeof(float[3]) * tsize); curvatures = (float (*)[2])malloc(sizeof(float[2]) * tsize); triangles = (unsigned int (*)[3])malloc(sizeof(unsigned int[3]) * tsize); quads = (unsigned int (*)[4])malloc(sizeof(unsigned int[4]) * qsize); bound_sign = (unsigned int (*))malloc(sizeof(unsigned int) * vsize); bound_tri = (unsigned int (*))malloc(sizeof(unsigned int) * tsize); vtxnew_sign = (unsigned int (*))malloc(sizeof(unsigned int) * vsize); bound_edge = (unsigned int (*)[18])malloc(sizeof(unsigned int[18]) * vsize); vtx_idx_arr_extend = (int*)malloc(sizeof(int)*1000000); int k; for (k = 0; k < 1000000; k++) vtx_idx_arr_extend[k] = -1; } geoframe::~geoframe() { free(triangles); free(quads); free(verts); free(funcs); free(normals); free(curvatures); free(bound_sign); free(bound_tri); free(vtx_idx_arr_extend); free(vtxnew_sign); free(bound_edge); } /* void geoframe::loadgeoframe(const char * name, int num) { char buffer[256]; sprintf(buffer, "%s%05d.raw", name, num ); //sprintf(buffer, "%s", name); QFile file(buffer); file.open(IO_ReadOnly); QTextStream stream(&file); stream >> numverts >> numtris; verts = new double[numverts*3]; triangles = new int[numtris*3]; int c; //int min = 1<<30; for (c=0; c> verts[c*3+0]; stream >> verts[c*3+1]; stream >> verts[c*3+2]; } for (c=0; c> triangles[c*3+0]; //min = obj.faceArray[c*3+0]> triangles[c*3+1]; //min = obj.faceArray[c*3+0]> triangles[c*3+2]; //min = obj.faceArray[c*3+0]max_x?value:max_x); min_x = (valuemax_y?value:max_y); min_y = (valuemax_z?value:max_z); min_z = (valuemax_x-min_x?max_y-min_y:max_x-min_x); biggestDim = (max_z-min_z>biggestDim?max_z-min_z:biggestDim); centerx = (max_x+min_x)/2.0; centery = (max_y+min_y)/2.0; centerz = (max_z+min_z)/2.0; } /*void geoframe::display() { int vert; glBegin(GL_TRIANGLES); for (int c=0; c #include Contour3d::Contour3d() { nvert=0; ntri=0; vsize=500; tsize=1000; vert = (float (*)[3])malloc(sizeof(float[3]) * vsize); tri = (unsigned int (*)[3])malloc(sizeof(unsigned int[3]) * tsize); } Contour3d::~Contour3d() { free(vert); free(tri); } int Contour3d::AddVert(float v_pos[3], float norm[3]) { int i; if (nvert+1 > vsize) { vsize<<=1; vert = (float (*)[3])realloc(vert,sizeof(float[3])*vsize); } for (i=0;i<3;i++) vert[nvert][i]=v_pos[i]; return nvert++; } int Contour3d::AddTri(unsigned int v1, unsigned int v2, unsigned int v3) { if (ntri+1 > tsize) { tsize<<=1; tri = (unsigned int (*)[3])realloc(tri, sizeof(unsigned int[3]) * tsize); } tri[ntri][0] = v1; tri[ntri][1] = v2; tri[ntri][2] = v3; return ntri++; } void Contour3d::Clear() { nvert=0; ntri=0; } void Contour3d::display() { int i; /* char buffer[256]; sprintf(buffer, "%s%05d.raw", name, num ); //sprintf(buffer, "%s", name); QFile file(buffer); file.open(IO_ReadOnly); QTextStream stream(&file); stream >> numverts >> numtris; verts = new double[numverts*3]; triangles = new int[numtris*3]; int c; //int min = 1<<30; for (c=0; c> verts[c*3+0]; stream >> verts[c*3+1]; stream >> verts[c*3+2]; } for (c=0; c> triangles[c*3+0]; //min = obj.faceArray[c*3+0]> triangles[c*3+1]; //min = obj.faceArray[c*3+0]> triangles[c*3+2]; //min = obj.faceArray[c*3+0] #include"contour3d.h" #include"e_face.h" #include"geoframe.h" typedef struct _octcell { char refine_flag; } octcell; typedef struct _MinMax { float min; float max; } MinMax; #define NUM_PARENT_CELL 6 #define FLOAT_MINIMUM -10000000 #define FLOAT_MAXIMUM 10000000 typedef struct { int dir; int di,dj,dk; int d1,d2; } EdgeInfo; static int po[8][6][3] = { {{0,-1,-1},{-1,0,-1},{0,0,-1},{-1,-1,0},{0,-1,0},{-1,0,0}}, {{0,-1,-1},{0,0,-1},{1,0,-1},{0,-1,0},{1,-1,0},{1,0,0}}, {{0,1,-1},{-1,0,-1},{0,0,-1},{-1,1,0},{0,1,0},{-1,0,0}}, {{0,1,-1},{0,0,-1},{1,0,-1},{0,1,0},{1,1,0},{1,0,0}}, {{0,-1,1},{-1,0,1},{0,0,1},{-1,-1,0},{0,-1,0},{-1,0,0}}, {{0,-1,1},{0,0,1},{1,0,1},{0,-1,0},{1,-1,0},{1,0,0}}, {{0,1,1},{-1,0,1},{0,0,1},{-1,1,0},{0,1,0},{-1,0,0}}, {{0,1,1},{0,0,1},{1,0,1},{0,1,0},{1,1,0},{1,0,0}} }; static EdgeInfo edgeinfo[12] = { { 0, 0, 0, 0, 0, 1 }, { 2, 1, 0, 0, 1, 2 }, { 0, 0, 0, 1, 3, 2 }, { 2, 0, 0, 0, 0, 3 }, { 0, 0, 1, 0, 4, 5 }, { 2, 1, 1, 0, 5, 6 }, { 0, 0, 1, 1, 7, 6 }, { 2, 0, 1, 0, 4, 7 }, { 1, 0, 0, 0, 0, 4 }, { 1, 1, 0, 0, 1, 5 }, { 1, 0, 0, 1, 3, 7 }, { 1, 1, 0, 1, 2, 6 } }; static EdgeInfo edge_dir[6][4]={ { {1,1,0,0,0,4},{0,1,1,0,4,1},{1,1,1,0,4,2},{0,0,1,0,3,4}}, { {2,1,0,0,0,4},{0,1,0,1,4,1},{2,1,0,1,4,2},{0,0,0,1,3,4}}, { {1,2,0,1,0,4},{2,2,1,0,1,4},{1,2,1,1,4,2},{2,2,1,1,4,3}}, { {2,1,2,0,0,4},{0,1,2,1,4,1},{2,1,2,1,4,2},{0,0,2,1,3,4}}, { {1,0,0,1,0,4},{2,0,1,0,1,4},{1,0,1,1,4,2},{2,0,1,1,4,3}}, { {1,1,0,2,0,4},{0,1,1,2,4,1},{1,1,1,2,4,2},{0,0,1,2,3,4}} }; static int level_id[] = { 0, 1, 1+8, 1+8+64, 1+8+64+512, 1+8+64+512+4096, 1+8+64+512+4096+32768, 1+8+64+512+4096+32768+262144, 1+8+64+512+4096+32768+262144+2097152, 1+8+64+512+4096+32768+262144+2097152+16777216 }; static int interp_2vtx[18][5]={ {2,0,1}, {2,0,2}, {4,0,1,2,3}, {2,1,3}, {2,2,3}, {2,0,4}, {4,0,1,4,5}, {2,1,5}, {4,0,2,4,6}, {4,1,3,5,7}, {2,2,6}, {4,2,3,6,7}, {2,3,7}, {2,4,5}, {2,4,6}, {4,4,5,6,7}, {2,5,7}, {2,6,7} }; static int cube_eid[12][2] = { {0,1}, {1,2}, {2,3}, {0,3}, {4,5}, {5,6}, {6,7}, {4,7}, {0,4}, {1,5}, {3,7} , {2,6} }; class Octree { private : // Contour3d curcon; FILE* vol_fp; float iso_val, iso_val_in; int leaf_num; octcell* oct_array; int octcell_num; int cell_num; int oct_depth; int level_res[10]; int* cut_array; int flag_type; int flag_normal; int in_out; int flag_extend; edge_face e_face[12][12]; double** qef_array; double** qef_array_in; int* vtx_idx_arr; int* vtx_idx_arr_in; int* grid_idx_arr; int* vtx_idx_arr_refine; float* orig_vol; char * ebit; char * vbit; // float* BSplineCoeff; //commented out : A.O. MinMax* minmax; //char data_type; // 0 : uchar , 1 : ushort , 2 : uint , 3 : float float minext[3], maxext[3]; int nverts, ncells; int dim[3]; float orig[3]; float span[3]; void read_header(); void read_data(); int get_neighbor_bit(int id,int level); int is_refined(int x, int y, int z, int level); int is_refined2(int x, int y, int z, int level); int get_depth(int res); int get_octcell_num(int depth); int get_level(int oc_id); void idx2vtx(int oc_id, int level, int* vtx, int* interpol_vtx); void idx2vtx(int oc_id, int level, int* vtx); void interpRect3Dpts_x(int i1, int j1, int k1, float f1, float f2, float val, float *pt,float norm[3],int level); void interpRect3Dpts_y(int i1, int j1, int k1, float f1, float d2, float val, float *pt,float norm[3],int level); void interpRect3Dpts_z(int i1, int j1, int k1, float f1, float d2, float val, float *pt,float norm[3],int level); void e_face_initialization(); float compute_error(int oc_idx,int level,float& min, float& max); void construct_octree(char*); int child(int oc_id, int level, int i); void octcell2xyz(int oc_id,int& x,int& y,int& z,int level); int xyz2octcell(int x,int y,int z,int level); int xyz2vtx(int x, int y, int z); void getCellValues(int oc_id,int level,float* val); int is_intersect(int in_idx ,float isovalue , float* in_value, int& iv_idx , int i, int j, int k , int level , int faceidx,geoframe& geofrm); int is_intersect(float* val, int e_id); int is_intersect_interval(float* val, int e_id); void getVertGrad(int i, int j, int k, float g[3]); float getValue(int i, int j, int k); void add_tetra_face(int oc_id, int level, geoframe& geofrm); void march_one_face(int face_id, int oc_id, int level, unsigned int* my_vtx, unsigned int center, geoframe& geofrm); void march_each_face(int oc_id, int level, int face_id, unsigned int center, geoframe& geofrm); void march_each_edge(int oc_id, int level, int edge_id, int* my_edge, geoframe& geofrm); void add_tetra_face_interval(int oc_id, int level, geoframe& geofrm); void add_tetra_cube(int oc_id, int level, geoframe& geofrm); void add_tetra_cube_adaptive(int oc_id, int level, geoframe& geofrm); void add_hexa(geoframe& geofrm, unsigned int* vtx); void add_one_vertex(int x, int y, int z, int cell_size, unsigned int& my_vertex, geoframe& geofrm); void add_middle_vertex(int x, int y, int z, float dx, float dy, float dz, int cell_size, unsigned int& my_vertex, geoframe& geofrm); void march_edge(int x, int y, int z, int cell_size, int e_id, int num, int* temp, int* index, int& m_id, unsigned int* my_array, geoframe& geofrm); void get_index_array(int level, int& num, int* index); void face_0(int x, int y, int z, int cell_size, int face_id, int v0, int v1, int v2, int v3, int v4, geoframe& geofrm); void face_1(int v0, int v1, int v2, int v3, int v4, unsigned int* array, int leng, geoframe& geofrm); void face_2_0(int x, int y, int z, int face_id, int v0, int v1, int v2, int v3, int v4, unsigned int* array0, unsigned int* array1, int m_id0, int m_id1, geoframe& geofrm); void face_2_1(int v0, int v1, int v2, int v3, int v4, unsigned int* array0, unsigned int* array1, int m_id0, int m_id1, geoframe& geofrm); void face_3(int x, int y, int z, int face_id, int cell_size, int v0, int v1, int v2, int v3, int v4, unsigned int* array0, unsigned int* array1, unsigned int* array2, int m_id0, int m_id1, int m_id2, geoframe& geofrm); void face_4(int x, int y, int z, int face_id, int v0, int v1, int v2, int v3, int v4, unsigned int face_center, unsigned int* array0, unsigned int* array1, unsigned int* array2, unsigned int* array3, int m_id0, int m_id1, int m_id2, int m_id3, geoframe& geofrm); void permute_1(int& i0, int& i1, int& i2, int& i3, int s0, int s1, int s2, int s3); void permute_2(int& i0, int& i1, int& i2, int& i3, int& s0, int& s1, int& s2, int& s3); void permute_3(int& i0, int& i1, int& i2, int& i3, int s0, int s1, int s2, int s3); void get_middle_array_1(int face_id, int* my_edge0, int* my_edge1, int* my_edge2, int* my_edge3, unsigned int* my_array, int& m_id, int x, int y, int z, int level, geoframe& geofrm); void get_middle_array_2(int face_id, int* my_edge0, int* my_edge1, int* my_edge2, int* my_edge3, unsigned int* my_array0, unsigned int* my_array1, int& m_id0, int& m_id1, int x, int y, int z, int level, geoframe& geofrm); void get_middle_array_3(int face_id, int* my_edge0, int* my_edge1, int* my_edge2, int* my_edge3, unsigned int* my_array0, unsigned int* my_array1, unsigned int* my_array2, int& m_id0, int& m_id1, int& m_id2, int x, int y, int z, int level, geoframe& geofrm); void get_middle_array_4(int face_id, int* my_edge0, int* my_edge1, int* my_edge2, int* my_edge3, unsigned int* my_array0, unsigned int* my_array1, unsigned int* my_array2, unsigned int* my_array3, int& m_id0, int& m_id1, int& m_id2, int& m_id3, unsigned int& face_center, int x, int y, int z, int level, geoframe& geofrm); int is_skipcell(int oc_id); int is_skipcell_in(int oc_id); int is_skipcell_interval(int oc_id); void get_solution(int oc_id, float* pos); void get_vtx(int x, int y, int z, int level, float* pos); void get_VtxNorm(float* vtx, float* norm); void get_min_vertex(int e_id, int intersect_id, int x, int y, int z, int& tx, int& ty, int& tz); void get_vertex_index(int v_id, int x, int y, int z, int& tx, int& ty, int& tz); int cell_comp(int oc_id, int level, float pt[12][3], float norm[12][3]); int cell_comp_in(int oc_id, int level, float pt[12][3], float norm[12][3]); void put_qef(int oc_id, double* sigma_ni_2, double* sigma_ni_2_pi,double* sigma_ni_2_pi_2,double* solution,double qef); void put_qef_in(int oc_id, double* sigma_ni_2, double* sigma_ni_2_pi,double* sigma_ni_2_pi_2,double* solution,double qef); void get_qef(int child_idx,double* temp_sigma_ni_2,double* temp_sigma_ni_2_pi,double* temp_sigma_ni_2_pi_2); void get_qef_in(int child_idx,double* temp_sigma_ni_2,double* temp_sigma_ni_2_pi,double* temp_sigma_ni_2_pi_2); float get_err(int oc_id); float get_err_grad(int oc_id); float get_err_grad_test(int oc_id); void eflag_clear(); int is_eflag_on(int x, int y, int z, int level, int e); void eflag_on(int x, int y, int z, int level, int e); void vflag_clear(); int is_vflag_on(int x, int y, int z, int level, int v); void vflag_on(int x, int y, int z, int level, int v); int is_min_edge(int oc_id, int e_id, unsigned int* vtx, int& vtx_num,int intersect_id,geoframe& geofrm); int is_min_edge_2(int oc_id, int e_id, int* vtx, int& vtx_num, int* con_id, int intersect_id,geoframe& geofrm); int is_min_vertex(int oc_id, int v_id, unsigned int* vtx, geoframe& geofrm); int min_vtx(int x, int y, int z, int level,geoframe& geofrm); int min_vtx_tetra(int x, int y, int z, int e_id_0, int e_id, int level, int& con_ind, int& con_id_1, geoframe& geofrm); int min_vtx_hexa(int x, int y, int z, int level, geoframe& geofrm); void clear (double* a, double* b, double* c); void clear (double* a); public : Octree(); // construction of octree from the given volume ~Octree(); float vol_min, vol_max; // isosurface simplification operations void Octree_init(const char* rawiv_fname); void set_isovalue(float val) {iso_val = val;} void set_isovalue_in(float val) {iso_val_in = val;} void setMeshType(int n) {flag_type = n;} void setNormalType(int n) {flag_normal = n;} bool Octree_init_from_data(const unsigned char* data, int dims[3], unsigned int numVerts, unsigned int numCells, float origin[3] = NULL, float spans[3] = NULL); // dual contouring operations void collapse(); void collapse_interval(); void compute_qef(); void compute_qef_interval(); void traverse_qef(float err_tol); void traverse_qef_interval(float err_tol, float err_tol_in); void mesh_extract(geoframe& geofrm, float err_tol); void polygonize(geoframe& geofrm); void polygonize_interval(geoframe& geofrm); void polygonize_quad(geoframe& geofrm, float err_tol); void tetrahedralize(geoframe& geofrm); void hexahedralize(geoframe& geofrm, float err_tol); void hexa_adaptive_1(geoframe& geofrm, int* oc_id, int* edge_id, float err_tol, unsigned int* vtx); void hexa_adaptive_1_top(geoframe& geofrm, unsigned int* vtx, unsigned int* vtx_new); void hexa_adaptive_2(geoframe& geofrm, int* oc_id, int* edge_id, float err_tol, unsigned int* vtx); void add_hexa_adaptive_2(geoframe& geofrm, unsigned int* vtx_new); void add_hexa_adaptive_2_1(geoframe& geofrm, unsigned int* vtx, unsigned int* vtx_temp); void add_hexa_adaptive_2_2(geoframe& geofrm, unsigned int* vtx_new); void add_hexa_adaptive_2_4(geoframe& geofrm, unsigned int* vtx_new); void tetra_to_4_hexa(geoframe& geofrm); void tetrahedralize_interval(geoframe& geofrm); void quality_improve(geoframe& geofrm); void func_val(geoframe& geofrm); void find_oc_id(int x, int y, int z, int level, int j, int intersect_id, int* oc_id); void find_oc_id_hexa(int x, int y, int z, int level, int j, int* oc_id); void find_edge_id_hexa(int x, int y, int z, int cell_size, int j, int* edge_id); void find_vtx_new(geoframe& geofrm, int x, int y, int z, int level, int j, int intersect_id, unsigned int* vtx_new); void quad_adaptive(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx, int flag_method); void quad_adaptive_method1(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx); void quad_adaptive_method2(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx); void quad_adaptive_method3(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx, int flag_method); void quad_adaptive_method4(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx); void quad_adaptive_method5(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx); void get_vtx_new(geoframe& geofrm, int oc_id, unsigned int vtx); void assign_refine_sign_quad(geoframe& geofrm, float err_tol); void assign_refine_sign_hexa(geoframe& geofrm, float err_tol); }; #endif // __OCTREE_H__ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/tetra.cpp0000755000175000017500000022315310150672414023674 0ustar debiandebian#include #include #include"cellQueue.h" #include"octree.h" #include"e_face.h" #include"cubes.h" #include"vtkMarchingCubesCases.h" #include"pcio.h" #include"geoframe.h" #include void Octree::tetrahedralize(geoframe& geofrm) { int x, y, z, tx, ty, tz, valid_leaf, cell_size, level, i, j, k; int vtx_num, intersect_id, my_vtx[4], con_id[4]; unsigned int vtx[4], my_vertex, my_vertex_1; float val[8]; for (k = 0; k < octcell_num; k++) {vtx_idx_arr[k] = -1; vtx_idx_arr_in[k] = -1;} for (k = 0; k < dim[0]*dim[1]*dim[2]; k++) grid_idx_arr[k] = -1; for (i = 0; i < leaf_num; i++ ) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; cell_size = (dim[0]-1)/(1<= iso_val && minmax[valid_leaf].min <= iso_val) { //add_tetra_face(valid_leaf, level, geofrm); } // interior cell if(minmax[valid_leaf].max < iso_val) { //add_tetra_cube_adaptive(valid_leaf, level, geofrm); } } } void Octree::tetrahedralize_interval(geoframe& geofrm) { int x, y, z, tx, ty, tz, valid_leaf, cell_size, level, i, j, k; int vtx_num, intersect_id, my_vtx[4], con_id[4]; unsigned int vtx[4], my_vertex, my_vertex_1; float val[8]; for (k = 0; k < octcell_num; k++) {vtx_idx_arr[k] = -1; vtx_idx_arr_in[k] = -1;} for (k = 0; k< dim[0]*dim[1]*dim[2]; k++) grid_idx_arr[k] = -1; for (i = 0; i < leaf_num; i++ ) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; cell_size = (dim[0]-1)/(1<= iso_val && minmax[valid_leaf].min <= iso_val) || (minmax[valid_leaf].max >= iso_val_in && minmax[valid_leaf].min <= iso_val_in)) { //add_tetra_face_interval(valid_leaf, level, geofrm); } // interior cell if(minmax[valid_leaf].max < iso_val && minmax[valid_leaf].min > iso_val_in) { //add_tetra_cube_adaptive(valid_leaf, level, geofrm); } } } int Octree::is_min_edge_2(int oc_id, int e_id, int* vtx, int& vtx_num, int* con_id, int intersect_id, geoframe& geofrm) { int x, y, z, level, i; int temp_vtx[4], temp_id[8]; level = get_level(oc_id); octcell2xyz(oc_id, x, y, z, level); vtx_num = 4; //if(!(minmax[oc_id].max >= iso_val && minmax[oc_id].min <= iso_val)) { // temp_vtx[0] = -1; temp_vtx[1] = -1; temp_vtx[2] = -1; temp_vtx[3] = -1; // return 0; //} vtx[0] = -1; vtx[1] = -1; vtx[2] = -1; vtx[3] = -1; temp_vtx[0] = -1; temp_vtx[1] = -1; temp_vtx[2] = -1; temp_vtx[3] = -1; temp_id[0] = 1; temp_id[1] = 1; temp_id[2] = 1; temp_id[3] = 1; assert(! is_refined(x, y, z, level)); temp_vtx[0] = min_vtx_tetra(x, y, z, e_id, e_id, level, temp_id[0], temp_id[4], geofrm); switch (e_id) { case 0 : if (is_refined(x,y,z-1,level) || is_refined(x,y-1,z-1,level) || is_refined(x,y-1,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y, z-1, 0, 2, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x, y-1, z-1, 0, 6, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y-1, z, 0, 4, level, temp_id[3], temp_id[7], geofrm); break; case 1 : if (is_refined(x,y-1,z,level) || is_refined(x+1,y-1,z,level) || is_refined(x+1,y,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x+1, y, z, 1, 3, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x+1, y-1, z, 1, 7, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y-1, z, 1, 5, level, temp_id[3], temp_id[7], geofrm); break; case 2 : if (is_refined(x,y,z+1,level) || is_refined(x,y-1,z+1,level) || is_refined(x,y-1,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y, z+1, 2, 0, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x, y-1, z+1, 2, 4, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y-1, z, 2, 6, level, temp_id[3], temp_id[7], geofrm); break; case 3 : if (is_refined(x,y-1,z,level) || is_refined(x-1,y-1,z,level) || is_refined(x-1,y,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y-1, z, 3, 7, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x-1, y-1, z, 3, 5, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x-1, y, z, 3, 1, level, temp_id[3], temp_id[7], geofrm); break; case 4 : if (is_refined(x,y,z-1,level) || is_refined(x,y+1,z-1,level) || is_refined(x,y+1,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y+1, z, 4, 0, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x, y+1, z-1, 4, 2, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y, z-1, 4, 6, level, temp_id[3], temp_id[7], geofrm); break; case 5 : if (is_refined(x,y+1,z,level) || is_refined(x+1,y,z,level) || is_refined(x+1,y+1,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y+1, z, 5, 1, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x+1, y+1, z, 5, 3, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x+1, y, z, 5, 7, level, temp_id[3], temp_id[7], geofrm); break; case 6 : if (is_refined(x,y+1,z,level) || is_refined(x,y+1,z+1,level) || is_refined(x,y,z+1,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y+1, z, 6, 2, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x, y+1, z+1, 6, 0, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y, z+1, 6, 4, level, temp_id[3], temp_id[7], geofrm); break; case 7 : if (is_refined(x-1,y,z,level) || is_refined(x-1,y+1,z,level) || is_refined(x,y+1,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x-1, y, z, 7, 5, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x-1, y+1, z, 7, 1, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y+1, z, 7, 3, level, temp_id[3], temp_id[7], geofrm); break; case 8 : if (is_refined(x,y,z-1,level) || is_refined(x-1,y,z-1,level) || is_refined(x-1,y,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x-1, y, z, 8, 9, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x-1, y, z-1, 8, 11, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y, z-1, 8, 10, level, temp_id[3], temp_id[7], geofrm); break; case 9 : if (is_refined(x,y,z-1,level) || is_refined(x+1,y,z-1,level) || is_refined(x+1,y,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y, z-1, 9, 11, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x+1, y, z-1, 9, 10, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x+1, y, z, 9, 8, level, temp_id[3], temp_id[7], geofrm); break; case 10 : if (is_refined(x,y,z+1,level) || is_refined(x-1,y,z+1,level) || is_refined(x-1,y,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x, y, z+1, 10, 8, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x-1, y, z+1, 10, 9, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x-1, y, z, 10, 11, level, temp_id[3], temp_id[7], geofrm); break; case 11 : if (is_refined(x,y,z+1,level) || is_refined(x+1,y,z+1,level) || is_refined(x+1,y,z,level)) return 0; temp_vtx[1] = min_vtx_tetra(x+1, y, z, 11, 10, level, temp_id[1], temp_id[5], geofrm); temp_vtx[2] = min_vtx_tetra(x+1, y, z+1, 11, 8, level, temp_id[2], temp_id[6], geofrm); temp_vtx[3] = min_vtx_tetra(x, y, z+1, 11, 9, level, temp_id[3], temp_id[7], geofrm); break; } assert(intersect_id == 2 || intersect_id == -2); temp_id[0] = temp_id[0] && temp_id[5]; temp_id[1] = temp_id[1] && temp_id[6]; temp_id[2] = temp_id[2] && temp_id[7]; temp_id[3] = temp_id[3] && temp_id[4]; if (intersect_id == 2) for (i=0;i<4;i++) { vtx[i] = temp_vtx[i]; con_id[i] = temp_id[i]; } else if (intersect_id == -2) { for (i=0;i<4;i++) { vtx[i] = temp_vtx[3-i]; //con_id[i] = temp_id[3-i]; } con_id[0] = temp_id[2]; con_id[1] = temp_id[1]; con_id[2] = temp_id[0]; con_id[3] = temp_id[3]; } return 1; } void Octree::get_min_vertex(int e_id, int intersect_id, int x, int y, int z, int& tx, int& ty, int& tz) { if(intersect_id == 1) { if(e_id == 0) { tx = x; ty = y; tz = z; } else if(e_id == 1) { tx = x+1; ty = y; tz = z; } else if(e_id == 2) { tx = x+1; ty = y; tz = z+1; } else if(e_id == 3) { tx = x; ty = y; tz = z; } else if(e_id == 4) { tx = x; ty = y+1; tz = z; } else if(e_id == 5) { tx = x+1; ty = y+1; tz = z; } else if(e_id == 6) { tx = x+1; ty = y+1; tz = z+1; } else if(e_id == 7) { tx = x; ty = y+1; tz = z; } else if(e_id == 8) { tx = x; ty = y; tz = z; } else if(e_id == 9) { tx = x+1; ty = y; tz = z; } else if(e_id == 10) { tx = x; ty = y; tz = z+1; } else { // if(e_id == 11) tx = x+1; ty = y; tz = z+1; } } else { // intersect_id == -1 if(e_id == 0) { tx = x+1; ty = y; tz = z; } else if(e_id == 1) { tx = x+1; ty = y; tz = z+1; } else if(e_id == 2) { tx = x; ty = y; tz = z+1; } else if(e_id == 3) { tx = x; ty = y; tz = z+1; } else if(e_id == 4) { tx = x+1; ty = y+1; tz = z; } else if(e_id == 5) { tx = x+1; ty = y+1; tz = z+1; } else if(e_id == 6) { tx = x; ty = y+1; tz = z+1; } else if(e_id == 7) { tx = x; ty = y+1; tz = z+1; } else if(e_id == 8) { tx = x; ty = y+1; tz = z; } else if(e_id == 9) { tx = x+1; ty = y+1; tz = z; } else if(e_id == 10) { tx = x; ty = y+1; tz = z+1; } else { // if(e_id == 11) tx = x+1; ty = y+1; tz = z+1; } } } int Octree::min_vtx_tetra(int x, int y, int z, int e_id_0, int e_id, int level, int& con_ind, int& con_ind_1, geoframe& geofrm) { int tx, ty, tz, vert, oc_id, cell_size; float vtx[3], norm[3], val[8]; unsigned int center; tx = x; ty = y; tz = z; assert( tx>=0 && ty>=0 && tz>=0 ); assert( !is_refined(tx,ty,tz,level) ); while ( level==0 || !is_refined(tx/2 , ty/2 , tz/2 , level-1 )) { tx/=2; ty/=2; tz/=2; level--; } oc_id = xyz2octcell(tx, ty, tz, level); cell_size = (dim[0]-1)/(1<= iso_val_in && flag_type >= 4) ) { if ((center = vtx_idx_arr_in[oc_id]) == -1) { add_middle_vertex(tx, ty, tz, 0.5, 0.5, 0.5, cell_size, center, geofrm); vtx_idx_arr_in[oc_id] = center; return center; } else return center; } else { get_vtx(tx, ty, tz, level, vtx); getVertGrad(tx*cell_size, ty*cell_size, tz*cell_size, norm); //get_VtxNorm(vtx, norm); if(in_out == 0) { if ((vert = vtx_idx_arr[oc_id]) == -1) { vert = geofrm.AddVert(vtx, norm); vtx_idx_arr[oc_id] = vert; return vert; } else return vert; } else { //return -1; if ((vert = vtx_idx_arr_in[oc_id]) == -1) { vert = geofrm.AddVert(vtx, norm); vtx_idx_arr_in[oc_id] = vert; return vert; } else return vert; } } /* int bool_0 = (val[0] <= iso_val && val[3] <= iso_val && val[4] <= iso_val && val[7] <= iso_val); int bool_1 = (val[1] <= iso_val && val[2] <= iso_val && val[5] <= iso_val && val[6] <= iso_val); int bool_2 = (val[0] <= iso_val && val[1] <= iso_val && val[2] <= iso_val && val[3] <= iso_val); int bool_3 = (val[4] <= iso_val && val[5] <= iso_val && val[6] <= iso_val && val[7] <= iso_val); int bool_4 = (val[0] <= iso_val && val[1] <= iso_val && val[4] <= iso_val && val[5] <= iso_val); int bool_5 = (val[2] <= iso_val && val[3] <= iso_val && val[6] <= iso_val && val[7] <= iso_val); if(flag_type > 3) { int bool_00 = (val[0] >= iso_val_in && val[3] >= iso_val_in && val[4] >= iso_val_in && val[7] >= iso_val_in); int bool_01 = (val[1] >= iso_val_in && val[2] >= iso_val_in && val[5] >= iso_val_in && val[6] >= iso_val_in); int bool_02 = (val[0] >= iso_val_in && val[1] >= iso_val_in && val[2] >= iso_val_in && val[3] >= iso_val_in); int bool_03 = (val[4] >= iso_val_in && val[5] >= iso_val_in && val[6] >= iso_val_in && val[7] >= iso_val_in); int bool_04 = (val[0] >= iso_val_in && val[1] >= iso_val_in && val[4] >= iso_val_in && val[5] >= iso_val_in); int bool_05 = (val[2] >= iso_val_in && val[3] >= iso_val_in && val[6] >= iso_val_in && val[7] >= iso_val_in); bool_0 = bool_0 && bool_00; bool_1 = bool_1 && bool_01; bool_2 = bool_2 && bool_02; bool_3 = bool_3 && bool_03; bool_4 = bool_4 && bool_04; bool_5 = bool_5 && bool_05; } con_ind = 1; con_ind_1 = 1; switch (e_id) { case 0: if(bool_2 && bool_4) return -1; else { //if((e_id_0 == 0 || e_id_0 == 4) && bool_4) con_ind = 0; //if((e_id_0 == 2 || e_id_0 == 6) && bool_2) con_ind = 0; if(e_id_0 == 0 || e_id_0 == 4) { if(bool_4) con_ind = 0; if(bool_2) con_ind_1 = 0; } if(e_id_0 == 2 || e_id_0 == 6) { if(bool_2) con_ind = 0; if(bool_4) con_ind_1 = 0; } } break; case 1: if(bool_1 && bool_2) return -1; else { if(bool_1) con_ind = 0; if(bool_2) con_ind_1 = 0; } break; case 2: if(bool_2 && bool_5) return -1; else { //if((e_id_0 == 0 || e_id_0 == 4) && bool_2) con_ind = 0; //if((e_id_0 == 2 || e_id_0 == 6) && bool_5) con_ind = 0; if(e_id_0 == 0 || e_id_0 == 4) { if(bool_2) con_ind = 0; if(bool_5) con_ind_1 = 0; } if(e_id_0 == 2 || e_id_0 == 6) { if(bool_5) con_ind = 0; if(bool_2) con_ind_1 = 0; } } break; case 3: if(bool_0 && bool_2) return -1; else { if(bool_2) con_ind = 0; if(bool_0) con_ind_1 = 0; } break; case 4: if(bool_3 && bool_4) return -1; else { //if((e_id_0 == 0 || e_id_0 == 4) && bool_3) con_ind = 0; //if((e_id_0 == 2 || e_id_0 == 6) && bool_4) con_ind = 0; if(e_id_0 == 0 || e_id_0 == 4) { if(bool_3) con_ind = 0; if(bool_4) con_ind_1 = 0; } if(e_id_0 == 2 || e_id_0 == 6) { if(bool_4) con_ind = 0; if(bool_3) con_ind_1 = 0; } } break; case 5: if(bool_1 && bool_3) return -1; else { //if(bool_1 || bool_3) con_ind = 0; if(bool_3) con_ind = 0; if(bool_1) con_ind_1 = 0; } break; case 6: if(bool_3 && bool_5) return -1; else { //if(bool_5 || bool_3) con_ind = 0; //if((e_id_0 == 0 || e_id_0 == 4) && bool_5) con_ind = 0; //if((e_id_0 == 2 || e_id_0 == 6) && bool_3) con_ind = 0; if(e_id_0 == 0 || e_id_0 == 4) { if(bool_5) con_ind = 0; if(bool_3) con_ind_1 = 0; } if(e_id_0 == 2 || e_id_0 == 6) { if(bool_3) con_ind = 0; if(bool_5) con_ind_1 = 0; } } break; case 7: if(bool_0 && bool_3) return -1; else { if(bool_0) con_ind = 0; if(bool_3) con_ind_1 = 0; } break; case 8: if(bool_0 && bool_4) return -1; else { if(bool_0) con_ind = 0; if(bool_4) con_ind_1 = 0; } break; case 9: if(bool_1 && bool_4) return -1; else { if(bool_4) con_ind = 0; if(bool_1) con_ind_1 = 0; } break; case 10: if(bool_0 && bool_5) return -1; else { if(bool_5) con_ind = 0; if(bool_0) con_ind_1 = 0; } break; case 11: if(bool_1 && bool_5) return -1; else { if(bool_1) con_ind = 0; if(bool_5) con_ind_1 = 0; } break; } */ } void Octree::add_tetra_face(int oc_id, int level, geoframe& geofrm) { int x, y, z, cell_size; unsigned int my_vtx[8]; float val[8]; cell_size = (dim[0]-1)/(1<= iso_val_in && val[3] >= iso_val_in && val[4] >= iso_val_in && val[7] >= iso_val_in ) { march_one_face(0, oc_id, level, my_vtx, my_vertex, geofrm); } if( val[1] <= iso_val && val[2] <= iso_val && val[5] <= iso_val && val[6] <= iso_val && val[1] >= iso_val_in && val[2] >= iso_val_in && val[5] >= iso_val_in && val[6] >= iso_val_in) { march_one_face(1, oc_id, level, my_vtx, my_vertex, geofrm); } if( val[0] <= iso_val && val[1] <= iso_val && val[2] <= iso_val && val[3] <= iso_val && val[0] >= iso_val_in && val[1] >= iso_val_in && val[2] >= iso_val_in && val[3] >= iso_val_in) { march_one_face(2, oc_id, level, my_vtx, my_vertex, geofrm); } if( val[4] <= iso_val && val[5] <= iso_val && val[6] <= iso_val && val[7] <= iso_val && val[4] >= iso_val_in && val[5] >= iso_val_in && val[6] >= iso_val_in && val[7] >= iso_val_in) { march_one_face(3, oc_id, level, my_vtx, my_vertex, geofrm); } if( val[0] <= iso_val && val[1] <= iso_val && val[4] <= iso_val && val[5] <= iso_val && val[0] >= iso_val_in && val[1] >= iso_val_in && val[4] >= iso_val_in && val[5] >= iso_val_in) { march_one_face(4, oc_id, level, my_vtx, my_vertex, geofrm); } if( val[2] <= iso_val && val[3] <= iso_val && val[6] <= iso_val && val[7] <= iso_val && val[2] >= iso_val_in && val[3] >= iso_val_in && val[6] >= iso_val_in && val[7] >= iso_val_in) { march_one_face(5, oc_id, level, my_vtx, my_vertex, geofrm); } } void Octree::add_one_vertex(int x, int y, int z, int cell_size, unsigned int& my_vertex, geoframe& geofrm) { float pv[3], g[3]; int tx, ty, tz; tx = x*cell_size; ty = y*cell_size; tz = z*cell_size; pv[0] = tx; pv[1] = ty; pv[2] = tz; getVertGrad(tx, ty, tz, g); my_vertex = geofrm.AddVert(pv, g); } void Octree::add_middle_vertex(int x, int y, int z, float dx, float dy, float dz, int cell_size, unsigned int& my_vertex, geoframe& geofrm) { float pv[3], g[3], g1[3], g2[3]; int tx, ty, tz; pv[0] = (x + dx) * cell_size; pv[1] = (y + dy) * cell_size; pv[2] = (z + dz) * cell_size; tx = x*cell_size; ty = y*cell_size; tz = z*cell_size; getVertGrad(tx, ty, tz, g1); tx = (x+1)*cell_size; ty = (y+1)*cell_size; tz = (z+1)*cell_size; getVertGrad(tx, ty, tz, g2); g[0] = g1[0] + dx*(g2[0] - g1[0]); g[1] = g1[1] + dy*(g2[1] - g1[1]); g[2] = g1[2] + dz*(g2[2] - g1[2]); my_vertex = geofrm.AddVert(pv, g); } /* void Octree::add_middle_vertex(int x, int y, int z, float dx, float dy, float dz, int cell_size, unsigned int& my_vertex, geoframe& geofrm) { float pv[3], g[3]; int tx, ty, tz; tx = x*cell_size + dx * cell_size; ty = y*cell_size + dy * cell_size; tz = z*cell_size + dz * cell_size; pv[0] = tx; pv[1] = ty; pv[2] = tz; getVertGrad(tx, ty, tz, g); my_vertex = geofrm.AddVert(pv, g); } */ void Octree::add_tetra_cube(int oc_id, int level, geoframe& geofrm) { int x, y, z; unsigned int my_vtx[8]; int cell_size = (dim[0]-1)/(1<=0; index0--) { if(is_refined2(tx+index0, ty-1, tz-1, index) || is_refined2(tx+index0, ty, tz-1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty-1, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } tx *= 2; ty *= 2; tz *= 2; num_edge *= 2; } break; case 1: for(index = level; index <= oct_depth; index++) { if(edge_id == 1) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx, ty-1, tz+index0, index) || is_refined2(tx+1, ty-1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx+1, ty, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx, ty-1, tz+index0, index) || is_refined2(tx+1, ty-1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx+1, ty, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx = 2 * tx + 1; ty *= 2; tz *= 2; num_edge *= 2; } break; case 2: for(index = level; index <= oct_depth; index++) { if(edge_id == 2) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx+index0, ty-1, tz, index) || is_refined2(tx+index0, ty-1, tz+1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx+index0, ty-1, tz, index) || is_refined2(tx+index0, ty-1, tz+1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty *= 2; tz = 2 * tz + 1; num_edge *= 2; } break; case 3: for(index = level; index <= oct_depth; index++) { if(edge_id == 3) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx-1, ty-1, tz+index0, index) || is_refined2(tx, ty-1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx-1, ty, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx-1, ty-1, tz+index0, index) || is_refined2(tx, ty-1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx-1, ty, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty *= 2; tz *= 2; num_edge *= 2; } break; case 4: for(index = level; index <= oct_depth; index++) { if(edge_id == 4) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx+index0, ty, tz-1, index) || is_refined2(tx+index0, ty+1, tz-1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty+1, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx+index0, ty, tz-1, index) || is_refined2(tx+index0, ty+1, tz-1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty+1, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty = 2 * ty + 1; tz *= 2; num_edge *= 2; } break; case 5: for(index = level; index <= oct_depth; index++) { if(edge_id == 5) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx+1, ty, tz+index0, index) || is_refined2(tx, ty+1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx+1, ty+1, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx+1, ty, tz+index0, index) || is_refined2(tx, ty+1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx+1, ty+1, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx = 2 * tx + 1; ty = 2 * ty + 1; tz *= 2; num_edge *= 2; } break; case 6: for(index = level; index <= oct_depth; index++) { if(edge_id == 6) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx+index0, ty+1, tz, index) || is_refined2(tx+index0, ty, tz+1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty+1, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx+index0, ty+1, tz, index) || is_refined2(tx+index0, ty, tz+1, index) || is_refined2(tx+index0, ty, tz, index) || is_refined2(tx+index0, ty+1, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty = 2 * ty + 1; tz = 2 * tz + 1; num_edge *= 2; } break; case 7: for(index = level; index <= oct_depth; index++) { if(edge_id == 7) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx-1, ty, tz+index0, index) || is_refined2(tx-1, ty+1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx, ty+1, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx-1, ty, tz+index0, index) || is_refined2(tx-1, ty+1, tz+index0, index) || is_refined2(tx, ty, tz+index0, index) || is_refined2(tx, ty+1, tz+index0, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty = 2 * ty + 1; tz *= 2; num_edge *= 2; } break; case 8: for(index = level; index <= oct_depth; index++) { if(edge_id == 8) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx-1, ty+index0, tz-1, index) || is_refined2(tx, ty+index0, tz-1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx-1, ty+index0, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx-1, ty+index0, tz-1, index) || is_refined2(tx, ty+index0, tz-1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx-1, ty+index0, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty *= 2; tz *= 2; num_edge *= 2; } break; case 9: for(index = level; index <= oct_depth; index++) { if(edge_id == 9) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx, ty+index0, tz-1, index) || is_refined2(tx+1, ty+index0, tz-1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx+1, ty+index0, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx, ty+index0, tz-1, index) || is_refined2(tx+1, ty+index0, tz-1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx+1, ty+index0, tz, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx = 2 * tx + 1; ty *= 2; tz *= 2; num_edge *= 2; } break; case 10: for(index = level; index <= oct_depth; index++) { if(edge_id == 10) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx-1, ty+index0, tz, index) || is_refined2(tx-1, ty+index0, tz+1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx, ty+index0, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx-1, ty+index0, tz, index) || is_refined2(tx-1, ty+index0, tz+1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx, ty+index0, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx *= 2; ty *= 2; tz = 2 * tz + 1; num_edge *= 2; } break; case 11: for(index = level; index <= oct_depth; index++) { if(edge_id == 11) { for(index0 = 0; index0 < num_edge; index0++) { if(is_refined2(tx+1, ty+index0, tz, index) || is_refined2(tx, ty+index0, tz+1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx+1, ty+index0, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } else { for(index0 = num_edge - 1; index0 >=0; index0--) { if(is_refined2(tx+1, ty+index0, tz, index) || is_refined2(tx, ty+index0, tz+1, index) || is_refined2(tx, ty+index0, tz, index) || is_refined2(tx+1, ty+index0, tz+1, index)) my_edge[t] = 1; else my_edge[t] = 0; t++; } } tx = 2 * tx + 1; ty *= 2; tz = 2 * tz + 1; num_edge *= 2; } break; } } void Octree::face_0(int x, int y, int z, int cell_size, int face_id, int v0, int v1, int v2, int v3, int v4, geoframe& geofrm) { int my_bool_0 = ((x + y + z) % 2 == 0) && (face_id == 0 || face_id == 2 || face_id == 4 || face_id == 5); int my_bool_1 = ((x + y + z) % 2 == 1) && (face_id == 1 || face_id == 3); if(my_bool_0 || my_bool_1) { //if((x + y + z) % (2*cell_size) == 0) { geofrm.AddTetra(v0, v1, v3, v4); geofrm.AddTetra(v1, v2, v3, v4); } else { geofrm.AddTetra(v0, v1, v2, v4); geofrm.AddTetra(v0, v2, v3, v4); } } void Octree::face_1(int v0, int v1, int v2, int v3, int v4, unsigned int* array, int m_id, geoframe& geofrm) { int t; geofrm.AddTetra(v3, array[m_id], v2, v4); geofrm.AddTetra(v0, array[0], v3, v4); for(t = 0; t < m_id; t++) geofrm.AddTetra(array[t], array[t+1], v3, v4); t = m_id; while(array[t+1] != 999999) { geofrm.AddTetra(array[t], array[t+1], v2, v4); t++; } geofrm.AddTetra(array[t], v1, v2, v4); } void Octree::face_2_0(int x, int y, int z, int face_id, int v0, int v1, int v2, int v3, int v4, unsigned int* array0, unsigned int* array1, int m_id0, int m_id1, geoframe& geofrm) { int t; int my_bool_0 = ((x + y + z) % 2 == 0) && (face_id == 0 || face_id == 2 || face_id == 4 || face_id == 5); int my_bool_1 = ((x + y + z) % 2 == 1) && (face_id == 1 || face_id == 3); if((x + y + z) % 2 == 0) { // if(my_bool_0 || my_bool_1) { geofrm.AddTetra(v0, array0[0], v3, v4); for(t = 0; t < m_id0; t++) geofrm.AddTetra(array0[t], array0[t+1], v3, v4); t = m_id0; while(array0[t+1] != 999999) { geofrm.AddTetra(array0[t], array0[t+1], array1[m_id1], v4); t++; } geofrm.AddTetra(array0[t], v1, array1[m_id1], v4); geofrm.AddTetra(v2, array1[0], v1, v4); for(t = 0; t < m_id1; t++) geofrm.AddTetra(array1[t], array1[t+1], v1, v4); t = m_id1; while(array1[t+1] != 999999) { geofrm.AddTetra(array1[t], array1[t+1], array0[m_id0], v4); t++; } geofrm.AddTetra(array1[t], v3, array0[m_id0], v4); } else { geofrm.AddTetra(v0, array0[0], array1[m_id1], v4); for(t = 0; t < m_id0; t++) geofrm.AddTetra(array0[t], array0[t+1], array1[m_id1], v4); t = m_id0; while(array0[t+1] != 999999) { geofrm.AddTetra(array0[t], array0[t+1], v2, v4); t++; } geofrm.AddTetra(array0[t], v1, v2, v4); geofrm.AddTetra(v2, array1[0], array0[m_id0], v4); for(t = 0; t < m_id1; t++) geofrm.AddTetra(array1[t], array1[t+1], array0[m_id0], v4); t = m_id1; while(array1[t+1] != 999999) { geofrm.AddTetra(array1[t], array1[t+1], v0, v4); t++; } geofrm.AddTetra(array1[t], v3, v0, v4); } } void Octree::face_2_1(int v0, int v1, int v2, int v3, int v4, unsigned int* array0, unsigned int* array1, int m_id0, int m_id1, geoframe& geofrm) { int t, tt; geofrm.AddTetra(v3, array0[m_id0], array1[m_id1], v4); geofrm.AddTetra(v0, array0[0], v3, v4); for(t = 0; t < m_id0; t++) geofrm.AddTetra(array0[t], array0[t+1], v3, v4); t = m_id1; while(array1[t+1] != 999999) { geofrm.AddTetra(array1[t], array1[t+1], v3, v4); t++; } geofrm.AddTetra(array1[t], v2, v3, v4); t = m_id0; while(array0[t+1] != 999999) { geofrm.AddTetra(array0[t], array0[t+1], array1[m_id1], v4); t++; } tt = t; geofrm.AddTetra(v1, array1[0], array0[tt], v4); for(t = 0; t < m_id1; t++) geofrm.AddTetra(array1[t], array1[t+1], array0[tt], v4); } void Octree::face_3(int x, int y, int z, int face_id, int cell_size, int v0, int v1, int v2, int v3, int v4, unsigned int* array0, unsigned int* array1, unsigned int* array2, int m_id0, int m_id1, int m_id2, geoframe& geofrm) { int t, tt; geofrm.AddTetra(array0[m_id0], array1[m_id1], array2[m_id2], v4); t = m_id0; while(array0[t+1] != 999999) { geofrm.AddTetra(array0[t], array0[t+1], array1[m_id1], v4); t++; } tt = t; geofrm.AddTetra(v1, array1[0], array0[tt], v4); for(t = 0; t < m_id1; t++) geofrm.AddTetra(array1[t], array1[t+1], array0[tt], v4); for(t = 0; t < m_id2; t++) geofrm.AddTetra(array2[t], array2[t+1], array1[m_id1], v4); t = m_id1; while(array1[t+1] != 999999) { geofrm.AddTetra(array1[t], array1[t+1], array2[0], v4); t++; } geofrm.AddTetra(array1[t], v2, array2[0], v4); int my_bool_0 = ((x + y + z) % 2 == 0) && (face_id == 0 || face_id == 2 || face_id == 4 || face_id == 5); int my_bool_1 = ((x + y + z) % 2 == 1) && (face_id == 1 || face_id == 3); if((x + y + z) % 2 == 0) { //if(my_bool_0 || my_bool_1) { geofrm.AddTetra(v0, array0[0], v3, v4); for(t = 0; t < m_id0; t++) geofrm.AddTetra(array0[t], array0[t+1], v3, v4); t = m_id2; while(array2[t+1] != 999999) { geofrm.AddTetra(array2[t], array2[t+1], array0[m_id0], v4); t++; } geofrm.AddTetra(array2[t], v3, array0[m_id0], v4); } else { geofrm.AddTetra(v0, array0[0], array2[m_id2], v4); for(t = 0; t < m_id0; t++) geofrm.AddTetra(array0[t], array0[t+1], array2[m_id2], v4); t = m_id2; while(array2[t+1] != 999999) { geofrm.AddTetra(array2[t], array2[t+1], v0, v4); t++; } geofrm.AddTetra(array2[t], v3, v0, v4); } } void Octree::face_4(int x, int y, int z, int face_id, int v0, int v1, int v2, int v3, int v4, unsigned int face_center, unsigned int* array0, unsigned int* array1, unsigned int* array2, unsigned int* array3, int m_id0, int m_id1, int m_id2, int m_id3, geoframe& geofrm) { int t, tt; geofrm.AddTetra(array0[m_id0], array1[m_id1], face_center, v4); geofrm.AddTetra(array1[m_id1], array2[m_id2], face_center, v4); geofrm.AddTetra(array2[m_id2], array3[m_id3], face_center, v4); geofrm.AddTetra(array0[m_id0], face_center, array3[m_id3], v4); int my_bool_0 = ((x + y + z) % 2 == 0) && (face_id == 0 || face_id == 2 || face_id == 4 || face_id == 5); int my_bool_1 = ((x + y + z) % 2 == 1) && (face_id == 1 || face_id == 3); // if((x + y + z) % 2 == 1) { //if(my_bool_0 || my_bool_1) { t = m_id0; while(array0[t+1] != 999999) { geofrm.AddTetra(array0[t], array0[t+1], array1[0], v4); t++; } geofrm.AddTetra(array0[t], v1, array1[0], v4); for(t = 0; t < m_id1; t++) geofrm.AddTetra(array1[t], array1[t+1], array0[m_id0], v4); t = m_id1; while(array1[t+1] != 999999) { geofrm.AddTetra(array1[t], array1[t+1], array2[m_id2], v4); t++; } tt = t; geofrm.AddTetra(v2, array2[0], array1[tt], v4); for(t = 0; t < m_id2; t++) geofrm.AddTetra(array2[t], array2[t+1], array1[tt], v4); t = m_id2; while(array2[t+1] != 999999) { geofrm.AddTetra(array2[t], array2[t+1], array3[0], v4); t++; } tt = t; geofrm.AddTetra(v3, array3[0], array2[tt], v4); for(t = 0; t < m_id3; t++) geofrm.AddTetra(array3[t], array3[t+1], array2[m_id2], v4); t = m_id3; while(array3[t+1] != 999999) { geofrm.AddTetra(array3[t], array3[t+1], array0[m_id0], v4); t++; } tt = t; geofrm.AddTetra(v0, array0[0], array3[tt], v4); for(t = 0; t < m_id0; t++) geofrm.AddTetra(array0[t], array0[t+1], array3[tt], v4); // } // else { // } } void Octree::march_edge(int x, int y, int z, int cell_size, int e_id, int num, int* temp, int* index, int& m_id, unsigned int* my_array, geoframe& geofrm){ int id, t; switch (abs(e_id)) { case 0: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; add_middle_vertex(x, y, z, (t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); } } break; case 100: // edge -0 id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; add_middle_vertex(x+1, y, z, -(t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); } } break; case 1: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 1) add_middle_vertex(x+1, y, z, 0.0, 0.0, (t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y, z+1, 0.0, 0.0, -(t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); } } break; case 2: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 2) add_middle_vertex(x, y, z+1, (t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y, z+1, -(t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); } } break; case 3: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 3) add_middle_vertex(x, y, z, 0.0, 0.0, (t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); else add_middle_vertex(x, y, z+1, 0.0, 0.0, -(t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); } } break; case 4: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 4) add_middle_vertex(x, y+1, z, (t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y+1, z, -(t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); } } break; case 5: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 5) add_middle_vertex(x+1, y+1, z, 0.0, 0.0, (t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y+1, z+1, 0.0, 0.0, -(t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); } } break; case 6: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 6) add_middle_vertex(x, y+1, z+1, (t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y+1, z+1, -(t+1.0)/(num+1.0), 0.0, 0.0, cell_size, my_array[id], geofrm); } } break; case 7: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 7) add_middle_vertex(x, y+1, z, 0.0, 0.0, (t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); else add_middle_vertex(x, y+1, z+1, 0.0, 0.0, -(t+1.0)/(num+1.0), cell_size, my_array[id], geofrm); } } break; case 8: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 8) add_middle_vertex(x, y, z, 0.0, (t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x, y+1, z, 0.0, -(t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); } } break; case 9: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 9) add_middle_vertex(x+1, y, z, 0.0, (t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y+1, z, 0.0, -(t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); } } break; case 10: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 10) add_middle_vertex(x, y, z+1, 0.0, (t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x, y+1, z+1, 0.0, -(t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); } } break; case 11: id = -1; for(t = 0; t < num; t++) { if(temp[index[t]] == 1) { id++; if(index[t] == 0) m_id = id; if(e_id == 11) add_middle_vertex(x+1, y, z+1, 0.0, (t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); else add_middle_vertex(x+1, y+1, z+1, 0.0, -(t+1.0)/(num+1.0), 0.0, cell_size, my_array[id], geofrm); } } break; } } void Octree::get_index_array(int level, int& num, int* index) { int t; int index1[1] = {0}; int index2[3] = {1, 0, 2}; int index3[7] = {3, 1, 4, 0, 5, 2, 6}; int index4[15] = {7, 3, 8, 1, 9, 4, 10, 0, 11, 5, 12, 2, 13, 6, 14}; int index5[31] = {15, 7, 16, 3, 17, 8, 18, 1, 19, 9, 20, 4, 21, 10, 22, 0, 23, 11, 24, 5, 25, 12, 26, 2, 27, 13, 28, 6, 29, 14, 30}; int index6[63] = {31, 15, 32, 7, 33, 16, 34, 3, 35, 17, 36, 8, 37, 18, 38, 1, 39, 19, 40, 9, 41, 20, 42, 4, 43, 21, 44, 10, 45, 22, 46, 0, 47, 23, 48, 11, 49, 24, 50, 5, 51, 25, 52, 12, 53, 26, 54, 2, 55, 27, 56, 13, 57, 28, 58, 6, 59, 29, 60, 14, 61, 30, 62}; if(oct_depth - level == 1) {num = 1; for(t = 0; t < num; t++) index[t] = index1[t];} if(oct_depth - level == 2) {num = 3; for(t = 0; t < num; t++) index[t] = index2[t];} if(oct_depth - level == 3) {num = 7; for(t = 0; t < num; t++) index[t] = index3[t];} if(oct_depth - level == 4) {num = 15; for(t = 0; t < num; t++) index[t] = index4[t];} if(oct_depth - level == 5) {num = 31; for(t = 0; t < num; t++) index[t] = index5[t];} if(oct_depth - level == 6) {num = 63; for(t = 0; t < num; t++) index[t] = index6[t];} } void Octree::get_middle_array_1(int face_id, int* my_edge0, int* my_edge1, int* my_edge2, int* my_edge3, unsigned int* my_array, int& m_id, int x, int y, int z, int level, geoframe& geofrm) { int temp[128], t, e_id, num, index[128]; int cell_size = (dim[0]-1)/(1<= 0 && sum_edge <= 4); int my_bool = ( val[v_id[0]] <= iso_val && val[v_id[1]] <= iso_val && val[v_id[2]] <= iso_val && val[v_id[3]] <= iso_val ); if(sum_edge == 0 && my_bool) { face_0(x, y, z, cell_size, face_id, i0, i1, i2, i3, center, geofrm); } else if(sum_edge == 1 && my_bool) { permute_1(i0, i1, i2, i3, s0, s1, s2, s3); get_middle_array_1(face_id, my_edge0, my_edge1, my_edge2, my_edge3, my_array0, m_id0, x, y, z, level, geofrm); face_1(i0, i1, i2, i3, center, my_array0, m_id0, geofrm); } else if(sum_edge == 2 && my_bool) { permute_2(i0, i1, i2, i3, s0, s1, s2, s3); get_middle_array_2(face_id, my_edge0, my_edge1, my_edge2, my_edge3, my_array0, my_array1, m_id0, m_id1, x, y, z, level, geofrm); if(s1 == 0) face_2_0(x, y, z, face_id, i0, i1, i2, i3, center, my_array0, my_array1, m_id0, m_id1, geofrm); else face_2_1(i0, i1, i2, i3, center, my_array0, my_array1, m_id0, m_id1, geofrm); } else if(sum_edge == 3 && my_bool) { permute_3(i0, i1, i2, i3, s0, s1, s2, s3); get_middle_array_3(face_id, my_edge0, my_edge1, my_edge2, my_edge3, my_array0, my_array1, my_array2, m_id0, m_id1, m_id2, x, y, z, level, geofrm); face_3(x, y, z, face_id, cell_size, i0, i1, i2, i3, center, my_array0, my_array1, my_array2, m_id0, m_id1, m_id2, geofrm); } else if(sum_edge == 4) { // sum_edge == 4 //get_middle_array_4(face_id, my_edge0, my_edge1, my_edge2, my_edge3, my_array0, my_array1, // my_array2, my_array3, m_id0, m_id1, m_id2, m_id3, face_center, x, y, z, level, geofrm); //face_4(x, y, z, face_id, i0, i1, i2, i3, center, face_center, my_array0, my_array1, my_array2, my_array3, m_id0, m_id1, m_id2, m_id3, geofrm); for(index = 0; index < 4; index++) { int new_level = level; if(new_level < oct_depth) { if(face_id == 0 || face_id == 1) { if(index == 0) my_oc_id = xyz2octcell(2*tx, 2*ty, 2*tz, ++new_level); else if(index == 1) my_oc_id = xyz2octcell(2*tx, 2*ty+1, 2*tz, ++new_level); else if(index == 2) my_oc_id = xyz2octcell(2*tx, 2*ty, 2*tz+1, ++new_level); else my_oc_id = xyz2octcell(2*tx, 2*ty+1, 2*tz+1, ++new_level); } if(face_id == 2 || face_id == 3) { if(index == 0) my_oc_id = xyz2octcell(2*tx, 2*ty, 2*tz, ++new_level); else if(index == 1) my_oc_id = xyz2octcell(2*tx+1, 2*ty, 2*tz, ++new_level); else if(index == 2) my_oc_id = xyz2octcell(2*tx, 2*ty, 2*tz+1, ++new_level); else my_oc_id = xyz2octcell(2*tx+1, 2*ty, 2*tz+1, ++new_level); } if(face_id == 4 || face_id == 5) { if(index == 0) my_oc_id = xyz2octcell(2*tx, 2*ty, 2*tz, ++new_level); else if(index == 1) my_oc_id = xyz2octcell(2*tx+1, 2*ty, 2*tz, ++new_level); else if(index == 2) my_oc_id = xyz2octcell(2*tx, 2*ty+1, 2*tz, ++new_level); else my_oc_id = xyz2octcell(2*tx+1, 2*ty+1, 2*tz, ++new_level); } march_each_face(my_oc_id, new_level, neighbor, center, geofrm); } } } } void Octree::march_each_face(int oc_id, int level, int face_id, unsigned int center, geoframe& geofrm) { int x, y, z; unsigned int my_vtx[8]; int cell_size = (dim[0]-1)/(1< #include #include #include #include #include "cellQueue.h" mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/octree.cpp0000644000175000017500000033133410161650156024035 0ustar debiandebian#include #include #include"cellQueue.h" #include"octree.h" #include"e_face.h" #include"cubes.h" #include"vtkMarchingCubesCases.h" #include"pcio.h" #include"geoframe.h" #include"normalspline.h" int* interpol_bit; Octree::Octree() { //vol_min=0; vol_max=1; vol_min=1; vol_max=0; } Octree::~Octree() { free(oct_array); free(cut_array); free(orig_vol); free(vtx_idx_arr); free(vtx_idx_arr_in); free(grid_idx_arr); free(minmax); // free(BSplineCoeff); //commented out A.O. free(vtx_idx_arr_refine); } // given the path of a volume, // load the volume data and construct octree from that // allocate associate arrays void Octree::Octree_init(const char* rawiv_fname) { vol_fp=fopen(rawiv_fname,"rb"); if (vol_fp==NULL) { printf("wrong name : %s\n",rawiv_fname); return; } leaf_num=0; read_header(); // read dimension, span, orig and so on //printf ("header info: \n"); //printf("dim[3]: %d, %d, %d \n", dim[0], dim[1], dim[2]); //printf ("minext[3]: %f, %f, %f \n", minext[0], minext[1], minext[2]); //printf ("maxext[3]: %f, %f, %f \n", maxext[0], maxext[1], maxext[2]); //printf ("nverts = %d, ncells = %d \n", nverts, ncells); //printf ("orig[3]: %f, %f, %f \n", orig[0], orig[1], orig[2]); //printf ("span[3]: %f, %f, %f \n", span[0], span[1], span[2]); // octree information oct_depth = get_depth(dim[0]); octcell_num = get_octcell_num(oct_depth); cell_num = (dim[0]-1)*(dim[1]-1)*(dim[2]-1); oct_array = (octcell*)malloc(sizeof(octcell)*octcell_num); memset(oct_array,0,sizeof(octcell)*octcell_num); minmax = (MinMax*)malloc(sizeof(MinMax)*octcell_num); memset(minmax,0,sizeof(MinMax)*octcell_num); cut_array = (int*)malloc(sizeof(int)*2*cell_num); orig_vol = (float*)malloc(sizeof(float)*dim[0]*dim[1]*dim[2]); ebit = (char*)malloc(sizeof(char)*octcell_num*4/8); vbit = (char*)malloc(sizeof(char)*octcell_num*4/8); vtx_idx_arr = (int*)malloc(sizeof(int)*octcell_num); grid_idx_arr = (int*)malloc(sizeof(int)*dim[0]*dim[1]*dim[2]); vtx_idx_arr_in = (int*)malloc(sizeof(int)*octcell_num); vtx_idx_arr_refine = (int*)malloc(sizeof(int)*octcell_num); int k; for (k=0;k= 0) { level=get_level(oc_id); //octcell2xyz(oc_id,x,y,z,level); // if (is_skipcell(oc_id) || level==oct_depth) { if (is_skipcell(oc_id) || level==oct_depth || minmax[oc_id].max < iso_val) { //cut_array[leaf_num++]=oc_id; oct_array[oc_id].refine_flag=0; } else { oct_array[oc_id].refine_flag=1; cur_queue.Add(oc_id); } } while (cur_queue.Get(oc_id)>=0) { level=get_level(oc_id); for (i=0; i<8; i++) prev_queue.Add(child(oc_id,level,i)); } } //return leaf_idx; } void Octree::collapse_interval() { CellQueue prev_queue, cur_queue; int i, oc_id, level; oc_id=0; prev_queue.Add(oc_id); while (!prev_queue.Empty()) { //int leaf_idx=leaf_num; while (prev_queue.Get(oc_id) >= 0) { level=get_level(oc_id); //octcell2xyz(oc_id,x,y,z,level); // if (is_skipcell(oc_id) || level==oct_depth) { if (is_skipcell_interval(oc_id) || level==oct_depth) { //cut_array[leaf_num++]=oc_id; oct_array[oc_id].refine_flag=0; } else { oct_array[oc_id].refine_flag=1; cur_queue.Add(oc_id); } } while (cur_queue.Get(oc_id)>=0) { level=get_level(oc_id); for (i=0; i<8; i++) prev_queue.Add(child(oc_id,level,i)); } } //return leaf_idx; } int Octree::cell_comp(int oc_id, int level, float pt[12][3], float norm[12][3]) { float val[8], f1, f2; int code, e, i, j, k, edge; getCellValues(oc_id,level,val); code = 0; if (val[0] < iso_val) code |= 0x01; if (val[1] < iso_val) code |= 0x02; if (val[2] < iso_val) code |= 0x04; if (val[3] < iso_val) code |= 0x08; if (val[4] < iso_val) code |= 0x10; if (val[5] < iso_val) code |= 0x20; if (val[6] < iso_val) code |= 0x40; if (val[7] < iso_val) code |= 0x80; /* if (val[0] > iso_val) code |= 0x01; if (val[1] > iso_val) code |= 0x02; if (val[2] > iso_val) code |= 0x04; if (val[3] > iso_val) code |= 0x08; if (val[4] > iso_val) code |= 0x10; if (val[5] > iso_val) code |= 0x20; if (val[6] > iso_val) code |= 0x40; if (val[7] > iso_val) code |= 0x80; */ assert(code!=0 && code!=255); octcell2xyz(oc_id,i,j,k,level); for (e=0 ; e < cubeedges[code][0] ; e++) { edge = cubeedges[code][1+e]; EdgeInfo *ei = &edgeinfo[edge]; f1=val[ei->d1]; f2=val[ei->d2]; switch (ei->dir) { case 0: interpRect3Dpts_x(i+ei->di, j+ei->dj, k+ei->dk, f1, f2, iso_val, pt[e], norm[e], level); break; case 1: interpRect3Dpts_y(i+ei->di, j+ei->dj, k+ei->dk, f1, f2, iso_val, pt[e], norm[e], level); break; case 2: interpRect3Dpts_z(i+ei->di, j+ei->dj, k+ei->dk, f1, f2, iso_val, pt[e], norm[e], level); break; } } return cubeedges[code][0]; } int Octree::cell_comp_in(int oc_id, int level, float pt[12][3], float norm[12][3]) { float val[8], f1, f2; int code, e, i, j, k, edge; getCellValues(oc_id,level,val); code = 0; if (val[0] > iso_val_in) code |= 0x01; if (val[1] > iso_val_in) code |= 0x02; if (val[2] > iso_val_in) code |= 0x04; if (val[3] > iso_val_in) code |= 0x08; if (val[4] > iso_val_in) code |= 0x10; if (val[5] > iso_val_in) code |= 0x20; if (val[6] > iso_val_in) code |= 0x40; if (val[7] > iso_val_in) code |= 0x80; assert(code!=0 && code!=255); octcell2xyz(oc_id,i,j,k,level); for (e=0 ; e < cubeedges[code][0] ; e++) { edge = cubeedges[code][1+e]; EdgeInfo *ei = &edgeinfo[edge]; f1=val[ei->d1]; f2=val[ei->d2]; switch (ei->dir) { case 0: interpRect3Dpts_x(i+ei->di, j+ei->dj, k+ei->dk, f1, f2, iso_val_in, pt[e], norm[e], level); break; case 1: interpRect3Dpts_y(i+ei->di, j+ei->dj, k+ei->dk, f1, f2, iso_val_in, pt[e], norm[e], level); break; case 2: interpRect3Dpts_z(i+ei->di, j+ei->dj, k+ei->dk, f1, f2, iso_val_in, pt[e], norm[e], level); break; } } return cubeedges[code][0]; } void Octree::clear (double* a, double* b, double* c) { int i; for (i=0;i<3;i++) { a[i]=0; b[i]=0; c[i]=0; } } void Octree::clear (double* a) { int i; for (i=0;i<3;i++) { a[i]=0; } } void Octree::get_qef(int child_idx,double* temp_sigma_ni_2,double* temp_sigma_ni_2_pi,double* temp_sigma_ni_2_pi_2) { if (qef_array[child_idx]) { temp_sigma_ni_2[0]=qef_array[child_idx][0]; temp_sigma_ni_2[1]=qef_array[child_idx][1]; temp_sigma_ni_2[2]=qef_array[child_idx][2]; temp_sigma_ni_2_pi[0]=qef_array[child_idx][3]; temp_sigma_ni_2_pi[1]=qef_array[child_idx][4]; temp_sigma_ni_2_pi[2]=qef_array[child_idx][5]; temp_sigma_ni_2_pi_2[0]=qef_array[child_idx][6]; temp_sigma_ni_2_pi_2[1]=qef_array[child_idx][7]; temp_sigma_ni_2_pi_2[2]=qef_array[child_idx][8]; } else { //assert(qef_array[child_idx]!=NULL); temp_sigma_ni_2[0]=0; temp_sigma_ni_2[1]=0; temp_sigma_ni_2[2]=0; temp_sigma_ni_2_pi[0]=0; temp_sigma_ni_2_pi[1]=0; temp_sigma_ni_2_pi[2]=0; temp_sigma_ni_2_pi_2[0]=0; temp_sigma_ni_2_pi_2[1]=0; temp_sigma_ni_2_pi_2[2]=0; } } void Octree::get_qef_in(int child_idx,double* temp_sigma_ni_2,double* temp_sigma_ni_2_pi,double* temp_sigma_ni_2_pi_2) { if (qef_array_in[child_idx]) { temp_sigma_ni_2[0]=qef_array_in[child_idx][0]; temp_sigma_ni_2[1]=qef_array_in[child_idx][1]; temp_sigma_ni_2[2]=qef_array_in[child_idx][2]; temp_sigma_ni_2_pi[0]=qef_array_in[child_idx][3]; temp_sigma_ni_2_pi[1]=qef_array_in[child_idx][4]; temp_sigma_ni_2_pi[2]=qef_array_in[child_idx][5]; temp_sigma_ni_2_pi_2[0]=qef_array_in[child_idx][6]; temp_sigma_ni_2_pi_2[1]=qef_array_in[child_idx][7]; temp_sigma_ni_2_pi_2[2]=qef_array_in[child_idx][8]; } else { //assert(qef_array_in[child_idx]!=NULL); temp_sigma_ni_2[0]=0; temp_sigma_ni_2[1]=0; temp_sigma_ni_2[2]=0; temp_sigma_ni_2_pi[0]=0; temp_sigma_ni_2_pi[1]=0; temp_sigma_ni_2_pi[2]=0; temp_sigma_ni_2_pi_2[0]=0; temp_sigma_ni_2_pi_2[1]=0; temp_sigma_ni_2_pi_2[2]=0; } } void Octree::compute_qef() { float norm[12][3], p[12][3]; double sigma_ni_2[3], sigma_ni_2_pi[3], sigma_ni_2_pi_2[3], qef; double temp_sigma_ni_2[3], temp_sigma_ni_2_pi[3], temp_sigma_ni_2_pi_2[3],solution[3]; int child_idx, intersect_num; int oc_id, level, i, x,y,z; for (oc_id=level_id[oct_depth];oc_id x*cell_size && solution[0] < (x+1)*cell_size) || !(solution[1] > y*cell_size && solution[1] < (y+1)*cell_size) || !(solution[2] > z*cell_size && solution[2] < (z+1)*cell_size)) { solution[0] = 0.0; solution[1] = 0.0; solution[2] = 0.0; for (i = 0; i < intersect_num; i++) { solution[0] += p[i][0] / intersect_num; solution[1] += p[i][1] / intersect_num; solution[2] += p[i][2] / intersect_num; } } // Jessica end */ qef=0; for (i=0;i<3;i++) qef = sigma_ni_2_pi_2[i] - (sigma_ni_2_pi[i]*sigma_ni_2_pi[i]) / sigma_ni_2[i] ; put_qef(oc_id, sigma_ni_2, sigma_ni_2_pi, sigma_ni_2_pi_2, solution, qef); } int l; for (l=oct_depth-1;l>=0;l--) { for (oc_id=level_id[l];oc_id=0;l--) { for (oc_id = level_id[l]; oc_id < level_id[l+1]; oc_id++) { level=l; if (oct_array[oc_id].refine_flag == 0) continue; clear (temp_sigma_ni_2,temp_sigma_ni_2_pi,temp_sigma_ni_2_pi_2); clear (sigma_ni_2,sigma_ni_2_pi,sigma_ni_2_pi_2); clear (solution); //child(oc_id,level,cid); for (k=0;k<8;k++) { child_idx = child(oc_id,level,k); //if (oct_array[child_idx].refine_flag==0) continue; if (is_skipcell(child_idx)) continue; get_qef(child_idx,temp_sigma_ni_2,temp_sigma_ni_2_pi,temp_sigma_ni_2_pi_2); for (i=0;i<3;i++) { sigma_ni_2[i]+=temp_sigma_ni_2[i]; sigma_ni_2_pi[i]+=temp_sigma_ni_2_pi[i]; sigma_ni_2_pi_2[i]+=temp_sigma_ni_2_pi_2[i]; } } for (i=0;i<3;i++) solution[i] = sigma_ni_2_pi[i] / sigma_ni_2[i]; qef=0; for (i=0;i<3;i++) qef = sigma_ni_2_pi_2[i] - (sigma_ni_2_pi[i]*sigma_ni_2_pi[i]) / sigma_ni_2[i]; put_qef(oc_id,sigma_ni_2, sigma_ni_2_pi, sigma_ni_2_pi_2, solution, qef); clear (temp_sigma_ni_2,temp_sigma_ni_2_pi,temp_sigma_ni_2_pi_2); clear (sigma_ni_2,sigma_ni_2_pi,sigma_ni_2_pi_2); clear (solution); //child(oc_id,level,cid); for (k = 0; k < 8; k++) { child_idx = child(oc_id,level,k); //if (oct_array[child_idx].refine_flag==0) continue; if (is_skipcell_in(child_idx)) continue; get_qef_in(child_idx,temp_sigma_ni_2,temp_sigma_ni_2_pi,temp_sigma_ni_2_pi_2); for (i=0;i<3;i++) { sigma_ni_2[i]+=temp_sigma_ni_2[i]; sigma_ni_2_pi[i]+=temp_sigma_ni_2_pi[i]; sigma_ni_2_pi_2[i]+=temp_sigma_ni_2_pi_2[i]; } } for (i=0;i<3;i++) solution[i] = sigma_ni_2_pi[i] / sigma_ni_2[i]; qef=0; for (i=0;i<3;i++) qef = sigma_ni_2_pi_2[i] - (sigma_ni_2_pi[i]*sigma_ni_2_pi[i]) / sigma_ni_2[i]; put_qef_in(oc_id,sigma_ni_2, sigma_ni_2_pi, sigma_ni_2_pi_2, solution, qef); } } } /* void Octree::compute_qef_interval() { float norm[12][3], p[12][3]; double sigma_ni_2[3], sigma_ni_2_pi[3], sigma_ni_2_pi_2[3], qef; double temp_sigma_ni_2[3], temp_sigma_ni_2_pi[3], temp_sigma_ni_2_pi_2[3],solution[3]; int child_idx, intersect_num, oc_id; int level, i, x, y, z, cell_size; for (oc_id=level_id[oct_depth];oc_id=0;l--) { for (oc_id=level_id[l];oc_id iso_val && val[1] > iso_val && val[2] > iso_val && val[3] > iso_val && val[4] > iso_val && val[5] > iso_val && val[6] > iso_val && val[7] > iso_val); if(flag_type > 3) { bool my_bool_in = minmax[oc_id].min > iso_val || minmax[oc_id].max < iso_val_in || (minmax[oc_id].min > iso_val_in && minmax[oc_id].max < iso_val); my_bool = my_bool_in; } val_new[0] = getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size); val_new[1] = getValue(xx*cell_size+cell_size, yy*cell_size, zz*cell_size+cell_size/2); val_new[2] = getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size+cell_size); val_new[3] = getValue(xx*cell_size, yy*cell_size, zz*cell_size+cell_size/2); val_new[4] = getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size); val_new[5] = getValue(xx*cell_size+cell_size, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[6] = getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size+cell_size); val_new[7] = getValue(xx*cell_size, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[8] = getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size); val_new[9] = getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size); val_new[10]= getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size); val_new[11]= getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size); val_new[12]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); sum = 0.0; sum_grad = 0.0; for(ii = 0; ii < 13; ii++) { if(ii == 3 || ii == 7 || ii == 8 || ii == 10) x = 0.0; else if(ii == 1 || ii == 5 || ii == 9 || ii == 11) x = 1.0; else x = 0.5; if(ii < 4) y = 0.0; else if(ii < 8) y = 1.0; else y = 0.5; if(ii == 0 || ii == 4 || ii == 8 || ii == 9) z = 0.0; else if(ii == 2 || ii == 6 || ii == 10 || ii == 11) z = 1.0; else z = 0.5; func_0 = (1-x)*(1-y)*(1-z)*val[0] + (1-x)*(1-y)*z*val[3] + (1-x)*y*(1-z)*val[4] + x*(1-y)*(1-z)*val[1] + (1-x)*y*z*val[7] + x*(1-y)*z*val[2] + x*y*(1-z)*val[5] + x*y*z*val[6]; func_1 = val_new[ii]; if(func_1 > func_0) temp = func_1 - func_0; else temp = func_0 - func_1; sum += temp; f_x = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); f_y = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); f_z = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); sum_grad += sqrt(f_x*f_x + f_y*f_y + f_z*f_z); } for(ii = 0; ii < 2; ii++) { for(jj = 0; jj < 2; jj++) { for(kk = 0; kk < 2; kk ++) { x = ii; y = jj; z = kk; f_x = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); f_y = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) +x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); f_z = (1-x)*(1-y)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) +x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); sum_grad += sqrt(f_x*f_x + f_y*f_y + f_z*f_z); } } } if(!my_bool) { return (sum/sum_grad); } else return (-1.0); } */ float Octree::get_err_grad_test(int oc_id) { int level, cell_size, xx, yy, zz; float val[8], val_new[19], x, y, z; float func_0, func_1, f_x, f_y, f_z, sum_grad, temp; level = get_level(oc_id) ; cell_size = (dim[0]-1)/(1< iso_val && val[1] > iso_val && val[2] > iso_val && val[3] > iso_val && val[4] > iso_val && val[5] > iso_val && val[6] > iso_val && val[7] > iso_val); if(flag_type > 3) { bool my_bool_in = minmax[oc_id].min > iso_val || minmax[oc_id].max < iso_val_in || (minmax[oc_id].min > iso_val_in && minmax[oc_id].max < iso_val); my_bool = my_bool_in; } if(is_skipcell(oc_id) == 0) { if(qef_array[oc_id] != NULL) { x = qef_array[oc_id][9] / cell_size - xx; y = qef_array[oc_id][10] / cell_size - yy; z = qef_array[oc_id][11] / cell_size - zz; } } val_new[0] = getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size); val_new[1] = getValue(xx*cell_size+cell_size, yy*cell_size, zz*cell_size+cell_size/2); val_new[2] = getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size+cell_size); val_new[3] = getValue(xx*cell_size, yy*cell_size, zz*cell_size+cell_size/2); val_new[4] = getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size); val_new[5] = getValue(xx*cell_size+cell_size, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[6] = getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size+cell_size); val_new[7] = getValue(xx*cell_size, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[8] = getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size); val_new[9] = getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size); val_new[10]= getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size); val_new[11]= getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size); val_new[12]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); val_new[13]= getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); val_new[14]= getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); val_new[15]= getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size+cell_size/2); val_new[16]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[17]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size); val_new[18]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size+cell_size); sum_grad = 0.0; func_0 = (1-x)*(1-y)*(1-z)*val[0] + (1-x)*(1-y)*z*val[3] + (1-x)*y*(1-z)*val[4] + x*(1-y)*(1-z)*val[1] + (1-x)*y*z*val[7] + x*(1-y)*z*val[2] + x*y*(1-z)*val[5] + x*y*z*val[6]; //func_1 = val_new[ii]; int new_oc_id; if(x < 0.5 && y < 0.5 && z < 0.5) { new_oc_id = xyz2octcell(xx*2, yy*2, zz*2, level+1); getCellValues(new_oc_id, level+1, val); x = x*2; y = y*2; z = z*2; } else if(x > 0.5 && y < 0.5 && z < 0.5) { new_oc_id = xyz2octcell(xx*2+1, yy*2, zz*2, level+1); getCellValues(new_oc_id, level+1, val); x = x*2-1; y = y*2; z = z*2; } else if(x < 0.5 && y > 0.5 && z < 0.5) { new_oc_id = xyz2octcell(xx*2, yy*2+1, zz*2, level+1); getCellValues(new_oc_id, level+1, val); x = x*2; y = y*2-1; z = z*2; } else if(x > 0.5 && y > 0.5 && z < 0.5) { new_oc_id = xyz2octcell(xx*2+1, yy*2+1, zz*2, level+1); getCellValues(new_oc_id, level+1, val); x = x*2-1; y = y*2-1; z = z*2; } else if(x < 0.5 && y < 0.5 && z > 0.5) { new_oc_id = xyz2octcell(xx*2, yy*2, zz*2+1, level+1); getCellValues(new_oc_id, level+1, val); x = x*2; y = y*2; z = z*2-1; } else if(x > 0.5 && y < 0.5 && z > 0.5) { new_oc_id = xyz2octcell(xx*2+1, yy*2, zz*2+1, level+1); getCellValues(new_oc_id, level+1, val); x = x*2-1; y = y*2; z = z*2-1; } else if(x < 0.5 && y > 0.5 && z > 0.5) { new_oc_id = xyz2octcell(xx*2, yy*2+1, zz*2+1, level+1); getCellValues(new_oc_id, level+1, val); x = x*2; y = y*2-1; z = z*2-1; } else { //if(x > 0.5 && y > 0.5 && z > 0.5) new_oc_id = xyz2octcell(xx*2+1, yy*2+1, zz*2+1, level+1); getCellValues(new_oc_id, level+1, val); x = x*2-1; y = y*2-1; z = z*2-1; } func_1 = (1-x)*(1-y)*(1-z)*val[0] + (1-x)*(1-y)*z*val[3] + (1-x)*y*(1-z)*val[4] + x*(1-y)*(1-z)*val[1] + (1-x)*y*z*val[7] + x*(1-y)*z*val[2] + x*y*(1-z)*val[5] + x*y*z*val[6]; //temp = fabs(func_0); if(func_1 > func_0) temp = func_1 - func_0; else temp = func_0 - func_1; f_x = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); f_y = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); f_z = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); sum_grad = temp / sqrt(f_x*f_x + f_y*f_y + f_z*f_z); if(!my_bool) { return (sum_grad); } else return (-1.0); } // the error between two neighboring level float Octree::get_err_grad(int oc_id) { int level, cell_size, xx, yy, zz, ii; float val[8], val_new[19], x, y, z; float func_0, func_1, f_x, f_y, f_z, sum_grad, temp; level = get_level(oc_id) ; cell_size = (dim[0]-1)/(1< iso_val && val[1] > iso_val && val[2] > iso_val && val[3] > iso_val && val[4] > iso_val && val[5] > iso_val && val[6] > iso_val && val[7] > iso_val); if(flag_type > 3) { bool my_bool_in = minmax[oc_id].min > iso_val || minmax[oc_id].max < iso_val_in || (minmax[oc_id].min > iso_val_in && minmax[oc_id].max < iso_val); my_bool = my_bool_in; } val_new[0] = getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size); val_new[1] = getValue(xx*cell_size+cell_size, yy*cell_size, zz*cell_size+cell_size/2); val_new[2] = getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size+cell_size); val_new[3] = getValue(xx*cell_size, yy*cell_size, zz*cell_size+cell_size/2); val_new[4] = getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size); val_new[5] = getValue(xx*cell_size+cell_size, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[6] = getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size+cell_size); val_new[7] = getValue(xx*cell_size, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[8] = getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size); val_new[9] = getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size); val_new[10]= getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size); val_new[11]= getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size); val_new[12]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); val_new[13]= getValue(xx*cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); val_new[14]= getValue(xx*cell_size+cell_size, yy*cell_size+cell_size/2, zz*cell_size+cell_size/2); val_new[15]= getValue(xx*cell_size+cell_size/2, yy*cell_size, zz*cell_size+cell_size/2); val_new[16]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size, zz*cell_size+cell_size/2); val_new[17]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size); val_new[18]= getValue(xx*cell_size+cell_size/2, yy*cell_size+cell_size/2, zz*cell_size+cell_size); sum_grad = 0.0; for(ii = 0; ii < 19; ii++) { if(ii == 3 || ii == 7 || ii == 8 || ii == 10 || ii == 13) x = 0.0; else if(ii == 1 || ii == 5 || ii == 9 || ii == 11 || ii == 14) x = 1.0; else x = 0.5; if(ii < 4 || ii == 15) y = 0.0; else if(ii < 8 || ii == 16) y = 1.0; else y = 0.5; if(ii == 0 || ii == 4 || ii == 8 || ii == 9 || ii == 17) z = 0.0; else if(ii == 2 || ii == 6 || ii == 10 || ii == 11 || ii == 18) z = 1.0; else z = 0.5; func_0 = (1-x)*(1-y)*(1-z)*val[0] + (1-x)*(1-y)*z*val[3] + (1-x)*y*(1-z)*val[4] + x*(1-y)*(1-z)*val[1] + (1-x)*y*z*val[7] + x*(1-y)*z*val[2] + x*y*(1-z)*val[5] + x*y*z*val[6]; func_1 = val_new[ii]; if(func_1 > func_0) temp = func_1 - func_0; else temp = func_0 - func_1; f_x = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); f_y = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); f_z = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); sum_grad += temp / sqrt(f_x*f_x + f_y*f_y + f_z*f_z); } if(!my_bool) { return (sum_grad); } else return (-1.0); /* // head65 if(!my_bool && zz*cell_size > 16.0f) { return (sum_grad); } else return (-1.0); // mache_65 location //if( xx*cell_size >= 21 && xx*cell_size <= 43 && yy*cell_size >= 37 && // yy*cell_size <= 61 && zz*cell_size >= 23 && zz*cell_size <= 30 && my_bool == 0) return sum_grad; // mache_129 location //if( xx*cell_size >= 42 && xx*cell_size <= 86 && yy*cell_size >= 74 && // yy*cell_size <= 122 && zz*cell_size >= 46 && zz*cell_size <= 60 && my_bool == 0) return sum_grad; // mache_65129 if( xx*cell_size >= 53 && xx*cell_size <= 75 && yy*cell_size >= 69 && yy*cell_size <= 91 && zz*cell_size >= 52 && zz*cell_size <= 67 && my_bool == 0) return sum_grad; else return (-1.0f); */ } /* // the error between the current level and the finest level float Octree::get_err_grad(int oc_id) { int level, cell_size, xx, yy, zz, i, j, k; float val[8], x, y, z; float func_0, func_1, f_x, f_y, f_z, sum_grad, temp; level = get_level(oc_id) ; cell_size = (dim[0]-1)/(1< iso_val || minmax[oc_id].max < iso_val); if(flag_type > 3) { bool my_bool_in = minmax[oc_id].min > iso_val || minmax[oc_id].max < iso_val_in || (minmax[oc_id].min > iso_val_in && minmax[oc_id].max < iso_val); my_bool = my_bool_in; } sum_grad = 0.0; for(i = 0; i < cell_size+1; i++) { for(j = 0; j < cell_size+1; j++) { for(k = 0; k < cell_size+1; k++) { x = (float)i/cell_size; y = (float)j/cell_size; z = (float)k/cell_size; func_0 = (1-x)*(1-y)*(1-z)*val[0] + (1-x)*(1-y)*z*val[3] + (1-x)*y*(1-z)*val[4] + x*(1-y)*(1-z)*val[1] + (1-x)*y*z*val[7] + x*(1-y)*z*val[2] + x*y*(1-z)*val[5] + x*y*z*val[6]; func_1 = getValue(((float)xx+x)*cell_size, ((float)yy+y)*cell_size, ((float)zz+z)*cell_size); if(func_1 > func_0) temp = func_1 - func_0; else temp = func_0 - func_1; f_x = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); f_y = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); f_z = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); sum_grad += temp / sqrt(f_x*f_x + f_y*f_y + f_z*f_z); } } } if(!my_bool) { return (sum_grad/10.0f); } else return (-1.0); } */ void Octree::traverse_qef(float err_tol) { CellQueue prev_queue,cur_queue; int i,oc_id,level, start_level, end_level; int x, y, z, tx, ty, tz, cell_size; float r, r_min, temp, center; oc_id=0; leaf_num=0; center = (dim[0]-1.0f)/2.0f; start_level = oct_depth - 3; // - 3 end_level = oct_depth; if(flag_type == 2) { start_level = oct_depth - 3;//3 end_level = start_level + 1; } if(flag_type == 3) { start_level = oct_depth - 3;//3 end_level = start_level + 1; } memset(oct_array,0,sizeof(octcell)*octcell_num); prev_queue.Add(oc_id); while (!prev_queue.Empty()) { //leaf_idx=leaf_num; while (prev_queue.Get(oc_id) >= 0) { level=get_level(oc_id); octcell2xyz(oc_id,x,y,z,level); cell_size = (dim[0]-1)/(1< r) r = temp; if(temp < r_min) r_min = temp; tx = x*cell_size; ty = (y+1)*cell_size; tz = z*cell_size; temp = (float) sqrt((tx-center)*(tx-center) + (ty-center)*(ty-center) + (tz-center)*(tz-center)); if(temp > r) r = temp; if(temp < r_min) r_min = temp; tx = (x+1)*cell_size; ty = (y+1)*cell_size; tz = z*cell_size; temp = (float) sqrt((tx-center)*(tx-center) + (ty-center)*(ty-center) + (tz-center)*(tz-center)); if(temp > r) r = temp; if(temp < r_min) r_min = temp; tx = x*cell_size; ty = y*cell_size; tz = (z+1)*cell_size; temp = (float) sqrt((tx-center)*(tx-center) + (ty-center)*(ty-center) + (tz-center)*(tz-center)); if(temp > r) r = temp; if(temp < r_min) r_min = temp; tx = (x+1)*cell_size; ty = y*cell_size; tz = (z+1)*cell_size; temp = (float) sqrt((tx-center)*(tx-center) + (ty-center)*(ty-center) + (tz-center)*(tz-center)); if(temp > r) r = temp; if(temp < r_min) r_min = temp; tx = x*cell_size; ty = (y+1)*cell_size; tz = (z+1)*cell_size; temp = (float) sqrt((tx-center)*(tx-center) + (ty-center)*(ty-center) + (tz-center)*(tz-center)); if(temp > r) r = temp; if(temp < r_min) r_min = temp; tx = (x+1)*cell_size; ty = (y+1)*cell_size; tz = (z+1)*cell_size; temp = (float) sqrt((tx-center)*(tx-center) + (ty-center)*(ty-center) + (tz-center)*(tz-center)); if(temp > r) r = temp; if(temp < r_min) r_min = temp; //if (is_skipcell(oc_id)) { if(minmax[oc_id].min > iso_val) { continue; //} else if (level <= 4 ||(get_err_grad(oc_id) > err_tol && level != oct_depth)) { // heart_0 } else if (level <= start_level || (get_err_grad(oc_id) > err_tol && level < end_level)) { // head //} else if (level <= 3) { //4 //} else if (level <= oct_depth-4 || (level <= oct_depth-3 && is_skipcell(oc_id) == 0) // ||(get_err_grad(oc_id) > err_tol && level != oct_depth)) { //} else if (level < oct_depth) { //} else if ((level <= 1 && r > (dim[0]-1)/4.0*1.733) || (level <= 2 && r < (dim[0]-1)/4.0*1.733) // || (level <= oct_depth-2 && is_skipcell(oc_id) == 0 && r < (dim[0]-1)/4.0*1.515) // ||(get_err_grad(oc_id) > err_tol && level < oct_depth && r < 16*1.8)) { // 14.3 cur_queue.Add(oc_id); oct_array[oc_id].refine_flag=1; } else { cut_array[leaf_num++]=oc_id; } } while (cur_queue.Get(oc_id) >= 0) { level=get_level(oc_id); for (i=0; i<8; i++) prev_queue.Add(child(oc_id,level,i)); } } } void Octree::traverse_qef_interval(float err_tol, float err_tol_in) { CellQueue prev_queue,cur_queue; int i,oc_id,level; oc_id=0; leaf_num=0; memset(oct_array,0,sizeof(octcell)*octcell_num); prev_queue.Add(oc_id); while (!prev_queue.Empty()) { //leaf_idx=leaf_num; while (prev_queue.Get(oc_id) >= 0) { level=get_level(oc_id); //octcell2xyz(oc_id,x,y,z,level); //if (is_skipcell(oc_id)) { if(minmax[oc_id].min > iso_val || minmax[oc_id].max < iso_val_in) { continue; //} else if (level <= 3 ||(get_err_grad(oc_id) > err_tol && level != oct_depth)) { } else if (level <= 3 ||(is_skipcell(oc_id) == 0 && get_err_grad(oc_id) > err_tol && level != oct_depth) ||(minmax[oc_id].max > iso_val_in && minmax[oc_id].min < iso_val_in && get_err_grad(oc_id) > err_tol_in && level != oct_depth)) { /* } else if (level <= oct_depth-4 ||(is_skipcell_interval(oc_id) == 0 && get_err_grad(oc_id) > err_tol && level != oct_depth) || (level <= oct_depth-3 && is_skipcell_interval(oc_id) == 0) || (minmax[oc_id].max > iso_val_in && minmax[oc_id].min < iso_val_in && get_err_grad(oc_id) > err_tol_in && level != oct_depth)) { */ //} else if (level <= oct_depth-2) { cur_queue.Add(oc_id); oct_array[oc_id].refine_flag=1; } else { cut_array[leaf_num++]=oc_id; } } while (cur_queue.Get(oc_id) >= 0) { level=get_level(oc_id); for (i=0; i<8; i++) prev_queue.Add(child(oc_id,level,i)); } } } int Octree::is_min_edge(int oc_id, int e_id, unsigned int* vtx, int& vtx_num, int intersect_id, geoframe& geofrm) { int x,y,z,level,i; unsigned int temp_vtx[4]; level=get_level(oc_id); octcell2xyz(oc_id,x,y,z,level); vtx_num=4; switch (e_id) { case 0 : if (is_refined(x,y,z-1,level) || is_refined(x,y-1,z-1,level) || is_refined(x,y-1,z,level)) return 0; temp_vtx[1]=min_vtx(x,y,z-1,level,geofrm); temp_vtx[2]=min_vtx(x,y-1,z-1,level,geofrm); temp_vtx[3]=min_vtx(x,y-1,z,level,geofrm); break; case 1 : if (is_refined(x,y-1,z,level) || is_refined(x+1,y-1,z,level) || is_refined(x+1,y,z,level)) return 0; temp_vtx[1]=min_vtx(x+1,y,z,level,geofrm); temp_vtx[2]=min_vtx(x+1,y-1,z,level,geofrm); temp_vtx[3]=min_vtx(x,y-1,z,level,geofrm); break; case 2 : if (is_refined(x,y,z+1,level) || is_refined(x,y-1,z+1,level) || is_refined(x,y-1,z,level)) return 0; temp_vtx[1]=min_vtx(x,y,z+1,level,geofrm); temp_vtx[2]=min_vtx(x,y-1,z+1,level,geofrm); temp_vtx[3]=min_vtx(x,y-1,z,level,geofrm); break; case 3 : if (is_refined(x,y-1,z,level) || is_refined(x-1,y-1,z,level) || is_refined(x-1,y,z,level)) return 0; temp_vtx[1]=min_vtx(x,y-1,z,level,geofrm); temp_vtx[2]=min_vtx(x-1,y-1,z,level,geofrm); temp_vtx[3]=min_vtx(x-1,y,z,level,geofrm); break; case 4 : if (is_refined(x,y,z-1,level) || is_refined(x,y+1,z-1,level) || is_refined(x,y+1,z,level)) return 0; temp_vtx[1]=min_vtx(x,y+1,z,level,geofrm); temp_vtx[2]=min_vtx(x,y+1,z-1,level,geofrm); temp_vtx[3]=min_vtx(x,y,z-1,level,geofrm); break; case 5 : if (is_refined(x,y+1,z,level) || is_refined(x+1,y,z,level) || is_refined(x+1,y+1,z,level)) return 0; temp_vtx[1]=min_vtx(x,y+1,z,level,geofrm); temp_vtx[2]=min_vtx(x+1,y+1,z,level,geofrm); temp_vtx[3]=min_vtx(x+1,y,z,level,geofrm); break; case 6 : if (is_refined(x,y+1,z,level) || is_refined(x,y+1,z+1,level) || is_refined(x,y,z+1,level)) return 0; temp_vtx[1]=min_vtx(x,y+1,z,level,geofrm); temp_vtx[2]=min_vtx(x,y+1,z+1,level,geofrm); temp_vtx[3]=min_vtx(x,y,z+1,level,geofrm); break; case 7 : if (is_refined(x-1,y,z,level) || is_refined(x-1,y+1,z,level) || is_refined(x,y+1,z,level)) return 0; temp_vtx[1]=min_vtx(x-1,y,z,level,geofrm); temp_vtx[2]=min_vtx(x-1,y+1,z,level,geofrm); temp_vtx[3]=min_vtx(x,y+1,z,level,geofrm); break; case 8 : if (is_refined(x,y,z-1,level) || is_refined(x-1,y,z-1,level) || is_refined(x-1,y,z,level)) return 0; temp_vtx[1]=min_vtx(x-1,y,z,level,geofrm); temp_vtx[2]=min_vtx(x-1,y,z-1,level,geofrm); temp_vtx[3]=min_vtx(x,y,z-1,level,geofrm); break; case 9 : if (is_refined(x,y,z-1,level) || is_refined(x+1,y,z-1,level) || is_refined(x+1,y,z,level)) return 0; temp_vtx[1]=min_vtx(x,y,z-1,level,geofrm); temp_vtx[2]=min_vtx(x+1,y,z-1,level,geofrm); temp_vtx[3]=min_vtx(x+1,y,z,level,geofrm); break; case 10 : if (is_refined(x,y,z+1,level) || is_refined(x-1,y,z+1,level) || is_refined(x-1,y,z,level)) return 0; temp_vtx[1]=min_vtx(x,y,z+1,level,geofrm); temp_vtx[2]=min_vtx(x-1,y,z+1,level,geofrm); temp_vtx[3]=min_vtx(x-1,y,z,level,geofrm); break; case 11 : if (is_refined(x,y,z+1,level) || is_refined(x+1,y,z+1,level) || is_refined(x+1,y,z,level)) return 0; temp_vtx[1]=min_vtx(x+1,y,z,level,geofrm); temp_vtx[2]=min_vtx(x+1,y,z+1,level,geofrm); temp_vtx[3]=min_vtx(x,y,z+1,level,geofrm); break; } temp_vtx[0] = min_vtx(x,y,z,level,geofrm); assert(intersect_id==1 || intersect_id==-1 || intersect_id==3 || intersect_id==-3); if (intersect_id==1 || intersect_id==3) for (i=0;i<4;i++) vtx[i]=temp_vtx[i]; else if (intersect_id==-1 || intersect_id==-3) for (i=0;i<4;i++) vtx[i]=temp_vtx[3-i]; return 1; } void Octree::get_solution(int oc_id, float* pos) { int x,y,z; float val[8]; int level = get_level(oc_id); int cell_size = (dim[0]-1)/(1<= iso_val); assert(minmax[oc_id].max >= iso_val || minmax[oc_id].min <= iso_val_in); //if(in_out == 0) { if(is_skipcell(oc_id) == 0) { pos[0]=qef_array[oc_id][9]; pos[1]=qef_array[oc_id][10]; pos[2]=qef_array[oc_id][11]; } else { pos[0]=qef_array_in[oc_id][9]; pos[1]=qef_array_in[oc_id][10]; pos[2]=qef_array_in[oc_id][11]; } // to be corrected if (!(pos[0] > x*cell_size && pos[0] < (x+1)*cell_size)) { pos[0] = x*cell_size + cell_size/2.; } if (!(pos[1] > y*cell_size && pos[1] < (y+1)*cell_size)) { pos[1] = y*cell_size + cell_size/2.; } if (!(pos[2] > z*cell_size && pos[2] < (z+1)*cell_size)) { pos[2] = z*cell_size + cell_size/2.; } } void Octree::get_vtx(int x, int y, int z, int level, float* pos) { int oc_id; oc_id = xyz2octcell(x,y,z,level); get_solution(oc_id,pos); } void Octree::get_VtxNorm(float* vtx, float* norm) { // finest resolution int oc_id, x, y, z; float val[8], tx, ty, tz; x = (int) vtx[0]; tx = vtx[0] - (float) x; y = (int) vtx[1]; ty = vtx[1] - (float) y; z = (int) vtx[2]; tz = vtx[2] - (float) z; oc_id = xyz2octcell(x, y, z, oct_depth); getCellValues(oc_id, oct_depth, val); norm[0] = (1-ty)*(1-tz)*(val[1] - val[0]) + (1-ty)*tz*(val[2] - val[3]) + ty*(1-tz)*(val[5] - val[4]) + ty*tz*(val[6] - val[7]); norm[1] = (1-tx)*(1-tz)*(val[4] - val[0]) + (1-tx)*tz*(val[7] - val[3]) + tx*(1-tz)*(val[5] - val[1]) + tx*tz*(val[6] - val[2]); norm[2] = (1-tx)*(1-tz)*(val[3] - val[0]) + (1-tx)*ty*(val[7] - val[4]) + tx*(1-ty)*(val[2] - val[1]) + tx*ty*(val[6] - val[5]); } int Octree::min_vtx(int x, int y, int z, int level, geoframe& geofrm) { int tx, ty, tz, vert; float vtx[3], norm[3]; tx = x; ty = y; tz = z; assert( tx>=0 && ty>=0 && tz>=0 ); assert( !is_refined(tx,ty,tz,level) ); while ( level==0 || !is_refined(tx/2 , ty/2 , tz/2 , level-1 )) { tx/=2; ty/=2; tz/=2; level--; } int oc_id = xyz2octcell(tx, ty, tz, level); int cell_size = (dim[0]-1)/(1<= iso_val_in) return -1; else { get_vtx(tx, ty, tz, level, vtx); //getVertGrad(tx*cell_size, ty*cell_size, tz*cell_size, norm); get_VtxNorm(vtx, norm); if(in_out == 0) { if ((vert = vtx_idx_arr[xyz2octcell(tx, ty, tz, level)]) == -1) { vert = geofrm.AddVert(vtx, norm); geofrm.AddBound(vert, 1); vtx_idx_arr[xyz2octcell(tx, ty, tz, level)] = vert; return vert; } else return vert; } else { if ((vert = vtx_idx_arr_in[xyz2octcell(tx, ty, tz, level)]) == -1) { vert = geofrm.AddVert(vtx, norm); geofrm.AddBound(vert, -1); vtx_idx_arr_in[xyz2octcell(tx, ty, tz, level)] = vert; return vert; } else return vert; } } } void Octree::eflag_clear() { memset(ebit,0,octcell_num*4/8); } int Octree::is_eflag_on(int x, int y, int z, int level, int e) { int idx; switch (e) { case 0 : idx = 3*xyz2octcell(x,y,z,level) + 0; break; case 1 : idx = 3*xyz2octcell(x+1,y,z,level) + 2; break; case 2 : idx = 3*xyz2octcell(x,y,z+1,level) + 0; break; case 3 : idx = 3*xyz2octcell(x,y,z,level) + 2; break; case 4 : idx = 3*xyz2octcell(x,y+1,z,level) + 0; break; case 5 : idx = 3*xyz2octcell(x+1,y+1,z,level) + 2; break; case 6 : idx = 3*xyz2octcell(x,y+1,z+1,level) + 0; break; case 7 : idx = 3*xyz2octcell(x,y+1,z,level) + 2; break; case 8 : idx = 3*xyz2octcell(x,y,z,level) + 1; break; case 9 : idx = 3*xyz2octcell(x+1,y,z,level) + 1; break; case 10 : idx = 3*xyz2octcell(x,y,z+1,level) + 1; break; case 11 : idx = 3*xyz2octcell(x+1,y,z+1,level) + 1; break; } if (ebit[idx/8]&(1<<(idx%8))) return 1; else return 0; } void Octree::eflag_on(int x, int y, int z, int level, int e) { int idx; switch (e) { case 0 : idx = 3*xyz2octcell(x,y,z,level) + 0; break; case 1 : idx = 3*xyz2octcell(x+1,y,z,level) + 2; break; case 2 : idx = 3*xyz2octcell(x,y,z+1,level) + 0; break; case 3 : idx = 3*xyz2octcell(x,y,z,level) + 2; break; case 4 : idx = 3*xyz2octcell(x,y+1,z,level) + 0; break; case 5 : idx = 3*xyz2octcell(x+1,y+1,z,level) + 2; break; case 6 : idx = 3*xyz2octcell(x,y+1,z+1,level) + 0; break; case 7 : idx = 3*xyz2octcell(x,y+1,z,level) + 2; break; case 8 : idx = 3*xyz2octcell(x,y,z,level) + 1; break; case 9 : idx = 3*xyz2octcell(x+1,y,z,level) + 1; break; case 10 : idx = 3*xyz2octcell(x,y,z+1,level) + 1; break; case 11 : idx = 3*xyz2octcell(x+1,y,z+1,level) + 1; break; } ebit[idx/8]|=(1<<(idx%8)); } void Octree::find_oc_id(int x, int y, int z, int level, int j, int intersect_id, int* oc_id) { int i, temp_id[4]; oc_id[0] = xyz2octcell(x, y, z, level); switch (j) { case 0 : oc_id[1] = xyz2octcell(x, y, z-1, level); oc_id[2] = xyz2octcell(x, y-1, z-1, level); oc_id[3] = xyz2octcell(x, y-1, z, level); break; case 1 : oc_id[1] = xyz2octcell(x+1, y, z, level); oc_id[2] = xyz2octcell(x+1, y-1, z, level); oc_id[3] = xyz2octcell(x, y-1, z, level); break; case 2 : oc_id[1] = xyz2octcell(x, y, z+1, level); oc_id[2] = xyz2octcell(x, y-1, z+1, level); oc_id[3] = xyz2octcell(x, y-1, z, level); break; case 3 : oc_id[1] = xyz2octcell(x, y-1, z, level); oc_id[2] = xyz2octcell(x-1, y-1, z, level); oc_id[3] = xyz2octcell(x-1, y, z, level); break; case 4 : oc_id[1] = xyz2octcell(x, y+1, z, level); oc_id[2] = xyz2octcell(x, y+1, z-1, level); oc_id[3] = xyz2octcell(x, y, z-1, level); break; case 5 : oc_id[1] = xyz2octcell(x, y+1, z, level); oc_id[2] = xyz2octcell(x+1, y+1, z, level); oc_id[3] = xyz2octcell(x+1, y, z, level); break; case 6 : oc_id[1] = xyz2octcell(x, y+1, z, level); oc_id[2] = xyz2octcell(x, y+1, z+1, level); oc_id[3] = xyz2octcell(x, y, z+1, level); break; case 7 : oc_id[1] = xyz2octcell(x-1, y, z, level); oc_id[2] = xyz2octcell(x-1, y+1, z, level); oc_id[3] = xyz2octcell(x, y+1, z, level); break; case 8 : oc_id[1] = xyz2octcell(x-1, y, z, level); oc_id[2] = xyz2octcell(x-1, y, z-1, level); oc_id[3] = xyz2octcell(x, y, z-1, level); break; case 9 : oc_id[1] = xyz2octcell(x, y, z-1, level); oc_id[2] = xyz2octcell(x+1, y, z-1, level); oc_id[3] = xyz2octcell(x+1, y, z, level); break; case 10 : oc_id[1] = xyz2octcell(x, y, z+1, level); oc_id[2] = xyz2octcell(x-1, y, z+1, level); oc_id[3] = xyz2octcell(x-1, y, z, level); break; case 11 : oc_id[1] = xyz2octcell(x+1, y, z, level); oc_id[2] = xyz2octcell(x+1, y, z+1, level); oc_id[3] = xyz2octcell(x, y, z+1, level); break; } for(i = 0; i < 4; i++) temp_id[i] = oc_id[i]; if (intersect_id == -1) for (i = 0; i < 4; i++) oc_id[i] = temp_id[3-i]; } void Octree::find_vtx_new(geoframe& geofrm, int x, int y, int z, int level, int j, int intersect_id, unsigned int* vtx_new) { int i, oc_id_new[4], cell_size, vert, tx, ty, tz; float vtx[3], norm[3], val[8]; switch (j) { case 0 : oc_id_new[0] = xyz2octcell(2*x, 2*y, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y, 2*z, level+1, j, intersect_id, oc_id_new); break; case 1 : oc_id_new[0] = xyz2octcell(2*x+1, 2*y, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x+1, 2*y, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 2 : oc_id_new[0] = xyz2octcell(2*x, 2*y, 2*z+1, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y, 2*z+1, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 3 : oc_id_new[0] = xyz2octcell(2*x, 2*y, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x, 2*y, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 4 : oc_id_new[0] = xyz2octcell(2*x, 2*y+1, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y+1, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y+1, 2*z, level+1, j, intersect_id, oc_id_new); break; case 5 : oc_id_new[0] = xyz2octcell(2*x+1, 2*y+1, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x+1, 2*y+1, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y+1, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 6 : oc_id_new[0] = xyz2octcell(2*x, 2*y+1, 2*z+1, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y+1, 2*z+1, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y+1, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 7 : oc_id_new[0] = xyz2octcell(2*x, 2*y+1, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y+1, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x, 2*y+1, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 8 : oc_id_new[0] = xyz2octcell(2*x, 2*y, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x, 2*y+1, 2*z, level+1, j, intersect_id, oc_id_new); break; case 9 : oc_id_new[0] = xyz2octcell(2*x+1, 2*y, 2*z, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x+1, 2*y, 2*z, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y+1, 2*z, level+1, j, intersect_id, oc_id_new); break; case 10 : oc_id_new[0] = xyz2octcell(2*x, 2*y, 2*z+1, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x, 2*y, 2*z+1, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x, 2*y+1, 2*z+1, level+1, j, intersect_id, oc_id_new); break; case 11 : oc_id_new[0] = xyz2octcell(2*x+1, 2*y, 2*z+1, level+1); getCellValues(oc_id_new[0], level+1, val); if(is_intersect(val, j) == 1 || is_intersect(val, j) == -1) find_oc_id(2*x+1, 2*y, 2*z+1, level+1, j, intersect_id, oc_id_new); else find_oc_id(2*x+1, 2*y+1, 2*z+1, level+1, j, intersect_id, oc_id_new); break; } for(i = 0; i < 4; i++) { octcell2xyz(oc_id_new[i], tx, ty, tz, level+1); cell_size = (dim[0]-1)/(1<<(level+1)); //get_vtx(tx, ty, tz, level+1, vtx); get_solution(oc_id_new[i], vtx); getVertGrad(tx*cell_size, ty*cell_size, tz*cell_size, norm); //get_VtxNorm(vtx, norm); if(in_out == 0) { if ((vert = vtx_idx_arr[xyz2octcell(tx, ty, tz, level+1)]) == -1) { vert = geofrm.AddVert(vtx, norm); geofrm.AddBound(vert, 1); vtx_idx_arr[xyz2octcell(tx, ty, tz, level+1)] = vert; } } else { if ((vert = vtx_idx_arr_in[xyz2octcell(tx, ty, tz, level+1)]) == -1) { vert = geofrm.AddVert(vtx, norm); geofrm.AddBound(vert, -1); vtx_idx_arr_in[xyz2octcell(tx, ty, tz, level+1)] = vert; } } vtx_new[i] = (unsigned int) vert; } } void Octree::get_vtx_new(geoframe& geofrm, int oc_id, unsigned int vtx) { /* // average all the minimizer points inside this cell int xx, yy, zz, tx, ty, tz, level, i, j, my_id, num; float pos[3], pos_average[3]; level = get_level(oc_id) ; octcell2xyz(oc_id, xx, yy, zz, level); if(i == 0 || i == 3 || i == 4 || i == 7) tx = 2*xx; else tx = 2*xx + 1; if(i < 4) ty = 2*yy; else ty = 2*yy + 1; if(i == 0 || i == 1 || i == 4 || i == 5) tz = 2*zz; else tz = 2*zz + 1; num = 0; for(i = 0; i < 3; i++) pos_average[i] = 0.0f; for(i = 0; i < 8; i++) { my_id = xyz2octcell(tx, ty, tz, level+1); if(is_skipcell(my_id) == 0) { num++; get_solution(my_id, pos); for(j = 0; j < 3; j++) pos_average[j] += pos[j]; } } if(num > 1) { for(j = 0; j < 3; j++) { geofrm.verts[vtx][j] = (geofrm.verts[vtx][j] + pos_average[j]/num)/2.0f; } } // find the intersection point with the trilinear function (the current resolution) int level, cell_size, xx, yy, zz, i, my_bool; float val[8], x, y, z, step, func, func0; level = get_level(oc_id) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f); if(func*func0 <= 0.0f || my_bool == 0) break; func0 = func; } geofrm.verts[vtx][0] = ((float)xx + x)*(float)cell_size; geofrm.verts[vtx][1] = ((float)yy + y)*(float)cell_size; geofrm.verts[vtx][2] = ((float)zz + z)*(float)cell_size; geofrm.normals[vtx][0] = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); geofrm.normals[vtx][1] = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); geofrm.normals[vtx][2] = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); */ // find the intersection point with the trilinear function (the finest resolution) int level, cell_size, xx, yy, zz, tx, ty, tz, i, my_bool, my_id; float val[8], x, y, z, mx, my, mz, step, func, func0, n[3], temp; level = get_level(oc_id) ; cell_size = (dim[0]-1)/(1< 0.001f) for(i = 0; i < 3; i++) n[i] /= temp; if(fabs(func0) >= 0.001733f) { //0.2 for(i = 1; i < 1000*cell_size; i++) { if(fabs(func0) < 0.001733f) break; step = -0.001f; if(func0 < 0.0f) step = 0.001f; /* n[0] = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); n[1] = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); n[2] = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); temp = (float) sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]); if(temp > 0.001f) for(int j = 0; j < 3; j++) n[j] /= temp; */ x = x + n[0]*step; y = y + n[1]*step; z = z + n[2]*step; func = (1-x)*(1-y)*(1-z)*val[0] + (1-x)*(1-y)*z*val[3] + (1-x)*y*(1-z)*val[4] + x*(1-y)*(1-z)*val[1] + (1-x)*y*z*val[7] + x*(1-y)*z*val[2] + x*y*(1-z)*val[5] + x*y*z*val[6] - iso_val; my_bool = (x >= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f); if(func*func0 <= 0.0f && my_bool) break; func0 = func; if(my_bool == 0) { if(x < 0.0f) {tx--; x = x + 1.0f;} else {tx++; x = x - 1.0f;} if(y < 0.0f) {ty--; y = y + 1.0f;} else {ty++; y = y - 1.0f;} if(z < 0.0f) {tz--; z = z + 1.0f;} else {tz++; z = z - 1.0f;} my_id = xyz2octcell(tx, ty, tz, oct_depth); getCellValues(my_id, oct_depth, val); } } //if(my_bool == 0 && i < 1000*cell_size) { geofrm.verts[vtx][0] = (float)tx + x; geofrm.verts[vtx][1] = (float)ty + y; geofrm.verts[vtx][2] = (float)tz + z; //} /* // calculate normal using the trilinear function geofrm.normals[vtx][0] = (1-y)*(1-z)*(val[1] - val[0]) + (1-y)*z*(val[2] - val[3]) + y*(1-z)*(val[5] - val[4]) + y*z*(val[6] - val[7]); geofrm.normals[vtx][1] = (1-x)*(1-z)*(val[4] - val[0]) + (1-x)*z*(val[7] - val[3]) + x*(1-z)*(val[5] - val[1]) + x*z*(val[6] - val[2]); geofrm.normals[vtx][2] = (1-x)*(1-z)*(val[3] - val[0]) + (1-x)*y*(val[7] - val[4]) + x*(1-y)*(val[2] - val[1]) + x*y*(val[6] - val[5]); temp = sqrt(geofrm.normals[vtx][0]*geofrm.normals[vtx][0] + geofrm.normals[vtx][1]*geofrm.normals[vtx][1] + geofrm.normals[vtx][2]*geofrm.normals[vtx][2]); for(i = 0; i < 3; i++) geofrm.normals[vtx][i] /= temp; // calculate curvature using the trilinear function float df2_dxdy = -(1-z)*(val[1] - val[0]) + -z*(val[2] - val[3]) + (1-z)*(val[5] - val[4]) + z*(val[6] - val[7]); float df2_dxdz = -(1-y)*(val[1] - val[0]) + (1-y)*(val[2] - val[3]) - y*(val[5] - val[4]) + y*(val[6] - val[7]); float df2_dydz = -(1-x)*(val[4] - val[0]) + (1-x)*(val[7] - val[3]) - x*(val[5] - val[1]) + x*(val[6] - val[2]); float coef = sqrt((df2_dxdy*df2_dxdy + df2_dxdz*df2_dxdz + df2_dydz*df2_dydz)/3.0f); float theta = acos(df2_dxdy*df2_dxdz*df2_dydz/(coef*coef*coef)); if(fabs(df2_dxdy*df2_dxdz*df2_dydz/(coef*coef*coef)) > 1.0) theta = 0.0f; float eigenvalue_0 = coef*2.0f*cos(theta/3.0f); float eigenvalue_1 = coef*2.0f*cos((theta + 2.0f*3.1415926f)/3.0f); float eigenvalue_2 = coef*2.0f*cos((theta - 2.0f*3.1415926f)/3.0f); float kapa_1 = eigenvalue_0; float kapa_2 = eigenvalue_0; if(kapa_1 < eigenvalue_1) kapa_1 = eigenvalue_1; if(kapa_1 < eigenvalue_2) kapa_1 = eigenvalue_2; if(kapa_2 > eigenvalue_1) kapa_2 = eigenvalue_1; if(kapa_2 > eigenvalue_2) kapa_2 = eigenvalue_2; geofrm.curvatures[vtx][0] = kapa_1; geofrm.curvatures[vtx][1] = kapa_2; */ } } void Octree::quad_adaptive(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx, int flag_method) { switch (flag_method) { case 1: quad_adaptive_method1(geofrm, oc_id, err_tol, vtx); break; case 2: quad_adaptive_method2(geofrm, oc_id, err_tol, vtx); break; case 3: quad_adaptive_method3(geofrm, oc_id, err_tol, vtx, flag_method); break; case 4: quad_adaptive_method3(geofrm, oc_id, err_tol, vtx, flag_method); break; case 5: quad_adaptive_method5(geofrm, oc_id, err_tol, vtx); break; } } void Octree::quad_adaptive_method1(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx) { int i, j, vtx_num, xx, yy, zz, level, cell_size, vtx_new_num; unsigned int vtx_new[12]; float x, y, z; vtx_num = 4; if (get_err_grad(oc_id[0]) > err_tol || get_err_grad(oc_id[1]) > err_tol || get_err_grad(oc_id[2]) > err_tol || get_err_grad(oc_id[3]) > err_tol) { vtx_new_num = 4; geofrm.AddVert_adaptive(vtx, vtx_new); for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } for(i = 0; i < 4; i++) get_vtx_new(geofrm, oc_id[i], vtx[i]); geofrm.AddQuad_adaptive(vtx, vtx_new, vtx_num); } else geofrm.AddQuad(vtx, vtx_num); } void Octree::quad_adaptive_method2(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx) { int num_id, i, j, vtx_num, xx, yy, zz, level, cell_size, vtx_new_num; unsigned int temp_vtx[4], vtx_new[12]; float x, y, z; vtx_num = 4; num_id = 0; if(get_err_grad(oc_id[0]) > err_tol) num_id++; if(get_err_grad(oc_id[1]) > err_tol) num_id++; if(get_err_grad(oc_id[2]) > err_tol) num_id++; if(get_err_grad(oc_id[3]) > err_tol) num_id++; for(i = 0; i < 4; i++) { //if(get_err_grad(oc_id[i]) > err_tol) get_vtx_new(geofrm, oc_id[i], vtx[i]); get_vtx_new(geofrm, oc_id[i], vtx[i]); //if(geofrm.vtxnew_sign[vtx[i]] == 0) { // get_vtx_new(geofrm, oc_id[i], vtx[i]); // geofrm.AddVtxNew(vtx[i], 1); //} } for(i = 0; i < 4; i++) temp_vtx[i] = vtx[i]; if(num_id == 0) geofrm.AddQuad(vtx, vtx_num); else if(num_id == 1) { if(get_err_grad(oc_id[1]) > err_tol) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(get_err_grad(oc_id[2]) > err_tol) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(get_err_grad(oc_id[3]) > err_tol) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_2_1(vtx, vtx_new); vtx_new_num = 6; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); //if(geofrm.vtxnew_sign[vtx_new[i]] == 0) { // get_vtx_new(geofrm, oc_id[j], vtx_new[i]); // geofrm.AddVtxNew(vtx_new[i], 1); //} } geofrm.AddQuad_adaptive_2_1(vtx, vtx_new, vtx_num); } else if(num_id == 2) { if( (get_err_grad(oc_id[0]) > err_tol && get_err_grad(oc_id[2]) > err_tol) || (get_err_grad(oc_id[1]) > err_tol && get_err_grad(oc_id[3]) > err_tol) ) { geofrm.AddVert_adaptive_4(vtx, vtx_new); vtx_new_num = 12; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); //if(geofrm.vtxnew_sign[vtx_new[i]] == 0) { // get_vtx_new(geofrm, oc_id[j], vtx_new[i]); // geofrm.AddVtxNew(vtx_new[i], 1); //} } geofrm.AddQuad_adaptive_4(vtx, vtx_new, vtx_num); } else { if(get_err_grad(oc_id[1]) > err_tol && get_err_grad(oc_id[2]) > err_tol) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(get_err_grad(oc_id[2]) > err_tol && get_err_grad(oc_id[3]) > err_tol) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(get_err_grad(oc_id[3]) > err_tol && get_err_grad(oc_id[0]) > err_tol) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_2_3(vtx, vtx_new); vtx_new_num = 8; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); //if(geofrm.vtxnew_sign[vtx_new[i]] == 0) { // get_vtx_new(geofrm, oc_id[j], vtx_new[i]); // geofrm.AddVtxNew(vtx_new[i], 1); //} } geofrm.AddQuad_adaptive_2_3(vtx, vtx_new, vtx_num); } } else { geofrm.AddVert_adaptive_4(vtx, vtx_new); vtx_new_num = 12; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); //if(geofrm.vtxnew_sign[vtx_new[i]] == 0) { // get_vtx_new(geofrm, oc_id[j], vtx_new[i]); // geofrm.AddVtxNew(vtx_new[i], 1); //} } geofrm.AddQuad_adaptive_4(vtx, vtx_new, vtx_num); } } void Octree::quad_adaptive_method3(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx, int flag_method) { int num_id, i, j, vtx_num, xx, yy, zz, level, cell_size, vtx_new_num; unsigned int temp_vtx[4], vtx_new[12]; float x, y, z; vtx_num = 4; num_id = 0; if(get_err_grad(oc_id[0]) > err_tol) num_id++; if(get_err_grad(oc_id[1]) > err_tol) num_id++; if(get_err_grad(oc_id[2]) > err_tol) num_id++; if(get_err_grad(oc_id[3]) > err_tol) num_id++; for(i = 0; i < 4; i++) { //if(get_err_grad(oc_id[i]) > err_tol) get_vtx_new(geofrm, oc_id[i], vtx[i]); get_vtx_new(geofrm, oc_id[i], vtx[i]); } for(i = 0; i < 4; i++) temp_vtx[i] = vtx[i]; if(num_id == 0) geofrm.AddQuad(vtx, vtx_num); else if(num_id == 1) { if(get_err_grad(oc_id[1]) > err_tol) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(get_err_grad(oc_id[2]) > err_tol) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(get_err_grad(oc_id[3]) > err_tol) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_3_1(vtx, vtx_new); vtx_new_num = 3; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_3_1(vtx, vtx_new, vtx_num); } else if(num_id == 2) { if( (get_err_grad(oc_id[0]) > err_tol && get_err_grad(oc_id[2]) > err_tol) || (get_err_grad(oc_id[1]) > err_tol && get_err_grad(oc_id[3]) > err_tol) ) { if(get_err_grad(oc_id[1]) > err_tol && get_err_grad(oc_id[3]) > err_tol) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } if(flag_method == 3) { geofrm.AddVert_adaptive_3_2b(vtx, vtx_new); vtx_new_num = 5; } else { geofrm.AddVert_adaptive_4_2b(vtx, vtx_new); vtx_new_num = 8; } for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } if(flag_method == 3) geofrm.AddQuad_adaptive_3_2b(vtx, vtx_new, vtx_num); else geofrm.AddQuad_adaptive_4_2b(vtx, vtx_new, vtx_num); } else { if(get_err_grad(oc_id[1]) > err_tol && get_err_grad(oc_id[2]) > err_tol) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(get_err_grad(oc_id[2]) > err_tol && get_err_grad(oc_id[3]) > err_tol) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(get_err_grad(oc_id[3]) > err_tol && get_err_grad(oc_id[0]) > err_tol) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_3_2a(vtx, vtx_new); vtx_new_num = 8; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_3_2a(vtx, vtx_new, vtx_num); } } else if(num_id == 3) { if(get_err_grad(oc_id[0]) <= err_tol) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(get_err_grad(oc_id[1]) <= err_tol) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(get_err_grad(oc_id[2]) <= err_tol) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_3_3(vtx, vtx_new); vtx_new_num = 10; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_3_3(vtx, vtx_new, vtx_num); } else { geofrm.AddVert_adaptive_4(vtx, vtx_new); vtx_new_num = 12; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_4(vtx, vtx_new, vtx_num); } } void Octree::quad_adaptive_method5(geoframe& geofrm, int* oc_id, float err_tol, unsigned int* vtx) { int num_id, i, j, vtx_num, xx, yy, zz, level, cell_size, vtx_new_num; unsigned int temp_vtx[4], vtx_new[12]; float x, y, z; vtx_num = 4; num_id = 0; if(vtx_idx_arr_refine[oc_id[0]] == 1) num_id++; if(vtx_idx_arr_refine[oc_id[1]] == 1) num_id++; if(vtx_idx_arr_refine[oc_id[2]] == 1) num_id++; if(vtx_idx_arr_refine[oc_id[3]] == 1) num_id++; for(i = 0; i < 4; i++) { //if(get_err_grad(oc_id[i]) > err_tol) get_vtx_new(geofrm, oc_id[i], vtx[i]); get_vtx_new(geofrm, oc_id[i], vtx[i]); } for(i = 0; i < 4; i++) temp_vtx[i] = vtx[i]; if(num_id == 0) geofrm.AddQuad(vtx, vtx_num); else if(num_id == 1) { if(vtx_idx_arr_refine[oc_id[1]] == 1) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(vtx_idx_arr_refine[oc_id[2]] == 1) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(vtx_idx_arr_refine[oc_id[3]] == 1) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_3_1(vtx, vtx_new); vtx_new_num = 3; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_3_1(vtx, vtx_new, vtx_num); } else if(num_id == 2) { if(vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1) { vtx[0] = temp_vtx[1]; vtx[1] = temp_vtx[2]; vtx[2] = temp_vtx[3]; vtx[3] = temp_vtx[0]; } else if(vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1) { vtx[0] = temp_vtx[2]; vtx[1] = temp_vtx[3]; vtx[2] = temp_vtx[0]; vtx[3] = temp_vtx[1]; } else if(vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[0]] == 1) { vtx[0] = temp_vtx[3]; vtx[1] = temp_vtx[0]; vtx[2] = temp_vtx[1]; vtx[3] = temp_vtx[2]; } geofrm.AddVert_adaptive_3_2a(vtx, vtx_new); vtx_new_num = 8; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_3_2a(vtx, vtx_new, vtx_num); } else if(num_id == 4) { geofrm.AddVert_adaptive_4(vtx, vtx_new); vtx_new_num = 12; for(i = 0; i < vtx_new_num; i++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } geofrm.AddQuad_adaptive_4(vtx, vtx_new, vtx_num); } } void Octree::assign_refine_sign_quad(geoframe& geofrm, float err_tol) { int x, y, z, valid_leaf, level, num_id, refine_sign; int intersect_id, i, j, k, oc_id[4]; float val[8]; for (k = 0; k < octcell_num; k++) vtx_idx_arr_refine[k] = -1; for (i = 0; i < leaf_num; i++ ) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; octcell2xyz(valid_leaf, x, y, z, level); getCellValues(valid_leaf, level, val); for (j = 0 ; j < 12 ; j++ ) { if (is_eflag_on(x,y,z,level,j)) continue; intersect_id = is_intersect(val, j); if (intersect_id == 1 || intersect_id == -1) { eflag_on(x, y, z, level, j); find_oc_id(x, y, z, level, j, intersect_id, oc_id); num_id = 0; if(get_err_grad(oc_id[0]) > err_tol) num_id++; if(get_err_grad(oc_id[1]) > err_tol) num_id++; if(get_err_grad(oc_id[2]) > err_tol) num_id++; if(get_err_grad(oc_id[3]) > err_tol) num_id++; //if( num_id > 2 || // (num_id == 2 && get_err_grad(oc_id[0]) > err_tol && get_err_grad(oc_id[2]) > err_tol) || // (num_id == 2 && get_err_grad(oc_id[1]) > err_tol && get_err_grad(oc_id[3]) > err_tol) ) { if(num_id == 4) { vtx_idx_arr_refine[oc_id[0]] = 1; vtx_idx_arr_refine[oc_id[1]] = 1; vtx_idx_arr_refine[oc_id[2]] = 1; vtx_idx_arr_refine[oc_id[3]] = 1; } } } // end j } // end i eflag_clear(); refine_sign = 1; while(refine_sign == 1) { refine_sign = 0; for (i = 0; i < leaf_num; i++ ) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; octcell2xyz(valid_leaf, x, y, z, level); getCellValues(valid_leaf, level, val); for (j = 0 ; j < 12 ; j++ ) { if (is_eflag_on(x,y,z,level,j)) continue; intersect_id = is_intersect(val, j); if (intersect_id == 1 || intersect_id == -1) { eflag_on(x, y, z, level, j); find_oc_id(x, y, z, level, j, intersect_id, oc_id); num_id = 0; if(vtx_idx_arr_refine[oc_id[0]] == 1) num_id++; if(vtx_idx_arr_refine[oc_id[1]] == 1) num_id++; if(vtx_idx_arr_refine[oc_id[2]] == 1) num_id++; if(vtx_idx_arr_refine[oc_id[3]] == 1) num_id++; if( num_id > 2 || (num_id == 2 && vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1) || (num_id == 2 && vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1) ) { if(vtx_idx_arr_refine[oc_id[0]] != 1) {vtx_idx_arr_refine[oc_id[0]] = 1; refine_sign = 1;} if(vtx_idx_arr_refine[oc_id[1]] != 1) {vtx_idx_arr_refine[oc_id[1]] = 1; refine_sign = 1;} if(vtx_idx_arr_refine[oc_id[2]] != 1) {vtx_idx_arr_refine[oc_id[2]] = 1; refine_sign = 1;} if(vtx_idx_arr_refine[oc_id[3]] != 1) {vtx_idx_arr_refine[oc_id[3]] = 1; refine_sign = 1;} } } } // end j } // end i eflag_clear(); } // end while } void Octree::tetra_to_4_hexa(geoframe& geofrm) { // get a list of leaf cells satisfying the error tolerance. // for each cell, get the centroid vertex int x, y, z, valid_leaf, cell_size, level; int vtx_num, intersect_id, i, j; unsigned int vtx[4]; float val[8]; int k; for (k=0;k func_max) func_max = geofrm.funcs[i][0]; } //for(i = 0; i < geofrm.numverts; i++) { // geofrm.funcs[i][0] = (geofrm.funcs[i][0] - func_min) / (func_max - func_min)*2.0f - 1.0f; //} free(func_vol); } void Octree::mesh_extract(geoframe& geofrm, float err_tol) { geofrm.Clear(); eflag_clear(); vflag_clear(); //flag_type = 1; in_out = 0; flag_extend = 1; int func = 0; //Commented out: A.O. //BSplineCoeff = (float*)malloc(sizeof(float)*dim[0]*dim[1]*dim[2]); //TransImg2Spline(orig_vol, BSplineCoeff, dim[0], dim[1], dim[2]); switch (flag_type) { case 0: // isosurface polygonize(geofrm); if(func == 1) func_val(geofrm); break; case 1: // tetra mesh tetrahedralize(geofrm); break; case 2: // hexa mesh hexahedralize(geofrm, err_tol); break; case 3: //tetra_to_4_hexa(geofrm); polygonize_quad(geofrm, err_tol); break; case 4: // interval polygonize_interval(geofrm); break; case 5: // interval volume tetrahedralize_interval(geofrm); break; } } void Octree::quality_improve(geoframe& geofrm) { /* int i; unsigned int v[4]; // edge contraction -- surface for (i = 0; i < geofrm.numtris; i++) { v[0] = geofrm.triangles[i][0]; v[1] = geofrm.triangles[i][1]; v[2] = geofrm.triangles[i][2]; if(geofrm.bound_sign[v[0]] == 1 && geofrm.bound_sign[v[1]] == 1 && geofrm.bound_sign[v[2]] == 1) geofrm.edge_contraction(v, 3); } if(flag_type == 1) { // edge contraction -- tetrahedra for (i = 0; i < (geofrm.numtris / 4); i++) { v[0] = geofrm.triangles[i][0]; v[1] = geofrm.triangles[i][1]; v[2] = geofrm.triangles[i][2]; v[3] = geofrm.triangles[i][3]; if(geofrm.bound_sign[v[0]] == 1 && geofrm.bound_sign[v[1]] == 1 && geofrm.bound_sign[v[2]] == 1) geofrm.edge_contraction(v, 4); //if(geofrm.bound_sign[v[0]] == 1 && geofrm.bound_sign[v[1]] == 1 // && geofrm.bound_sign[v[2]] == 0 && geofrm.bound_sign[v[3]] == 0) // geofrm.edge_contraction(v, 5); } } */ } int Octree::is_intersect(float* val, int e_id) { float f1,f2; f1 = val[cube_eid[e_id][0]]; f2 = val[cube_eid[e_id][1]]; if (iso_val <= f1 && iso_val >= f2) return -1; else if (iso_val <= f2 && iso_val >= f1) return 1; else if (iso_val >= f1 && f1 >= f2) return -2; else if (iso_val >= f2 && f2 >= f1) return 2; else return 0; } int Octree::is_intersect_interval(float* val, int e_id) { float f1,f2; f1 = val[cube_eid[e_id][0]]; f2 = val[cube_eid[e_id][1]]; if ((iso_val <= f1 && iso_val >= f2 && f2 >= iso_val_in) || (iso_val_in <= f1 && iso_val_in >= f2 && f1 <= iso_val)) return -1; else if ((iso_val <= f2 && iso_val >= f1 && f1 >= iso_val_in) || (iso_val_in <= f2 && iso_val_in >= f1 && f2 <= iso_val)) return 1; else if (iso_val >= f1 && f1 >= f2 && f2 >= iso_val_in) return -2; else if (iso_val >= f2 && f2 >= f1 && f1 >= iso_val_in) return 2; else if (f1 >= iso_val && iso_val_in >= f2) return -3; else if (f2 >= iso_val && iso_val_in >= f1) return 3; else return 0; } void Octree::read_header() { getFloat(minext,3,vol_fp); getFloat(maxext,3,vol_fp); getInt(&nverts,1,vol_fp); getInt(&ncells,1,vol_fp); getInt(dim,3,vol_fp); getFloat(orig,3,vol_fp); getFloat(span,3,vol_fp); } void Octree::read_data() { int i; //int j, k, index; //float r, r0, r1; float center; center = (dim[0] - 1.0f)/2.0f; //float *temp; //temp = (float*)malloc(sizeof(float)*dim[0]*dim[1]*dim[2]); // currently support only float data printf ("in read_data: dims: %d, %d, %d\n",dim[0], dim[1], dim[2]); getFloat(orig_vol, dim[0]*dim[1]*dim[2], vol_fp); //getFloat(temp, dim[0]*dim[1]*dim[2], vol_fp); // remove the outer sphere for(i = 0; i < dim[0]*dim[1]*dim[2]; i++) { orig_vol[i] = - orig_vol[i]; } /* for(k = 0; k < dim[2]; k++) for(j = 0; j < dim[1]; j++) for(i = 0; i < dim[0]; i++) { index = k*dim[0]*dim[1] + j*dim[0] + i; if( i == 0 || i > 66 || j == 0 || j == dim[1]-1 || k == 0 || k == dim[2]-1 || (i < 60 && j < 60 && k < 60)) orig_vol[index] = 10.0f; } for(k = 0; k < dim[2]; k++) for(j = 0; j < dim[1]; j++) for(i = 0; i < dim[0]; i++) { index = k*dim[0]*dim[1] + j*dim[0] + i; r = (float) sqrt((i-center)*(i-center) + (j-center)*(j-center) + (k-center)*(k-center)); if(r > 28.0f && orig_vol[index] <= 0.0f) orig_vol[index] = 1.0-orig_vol[index]; } int index_0; for(k = 0; k < dim[2]; k++) for(j = 0; j < dim[1]; j++) for(i = 0; i < dim[0]; i++) { index_0 = k*dim[0]*dim[1] + j*dim[0] + i; index = (k-8)*dim[0]*dim[1] + (j-8)*dim[0] + (i-8); if(k > 8 && j > 8 & i > 8) orig_vol[index_0] = temp[index]; else orig_vol[index_0] = 1.0; } //r0 = center - 0.1f; r0 = 45.0f; for(k = 0; k < dim[2]; k++) for(j = 0; j < dim[1]; j++) for(i = 0; i < dim[0]; i++) { index = k*dim[0]*dim[1] + j*dim[0] + i; //orig_vol[index] = 0.5f - orig_vol[index]; orig_vol[index] = orig_vol[index] - 1.0f; r = (float) sqrt((i-center)*(i-center) + (j-center)*(j-center) + (k-center)*(k-center)); if(orig_vol[index] < 0.0) { if((r>r0) || ((r0-r) < -orig_vol[index])) orig_vol[index] = r - r0; } } //free(temp); r0 = 10.0f; r1 = 30.0f; for(k = 0; k < dim[2]; k++) for(j = 0; j < dim[1]; j++) for(i = 0; i < dim[0]; i++) { index = k*dim[0]*dim[1] + j*dim[0] + i; r = sqrt((i-32)*(i-32) + (j-32)*(j-32) + (k-32)*(k-32)); if(r < r0) orig_vol[index] = r0 - r; else if(r > r1) orig_vol[index] = r - r1; else { if(r < (r0+r1)/2.0) orig_vol[index] = r0 - r; else orig_vol[index] = r - r1; } } r1 = 15.0f; for(k = 0; k < dim[2]; k++) for(j = 0; j < dim[1]; j++) for(i = 0; i < dim[0]; i++) { index = k*dim[0]*dim[1] + j*dim[0] + i; r = sqrt((i-32)*(i-32) + (j-32)*(j-32) + (k-32)*(k-32)); orig_vol[index] = r - r1; } */ } int Octree::get_neighbor_bit(int id,int level) { int x,y,z; int reg_bitmask=0; octcell2xyz(id,x,y,z,level); reg_bitmask|=(is_refined(x , y-1, z-1, level)<<0); reg_bitmask|=(is_refined(x-1, y , z-1, level)<<1); reg_bitmask|=(is_refined(x , y , z-1, level)<<2); reg_bitmask|=(is_refined(x+1, y , z-1, level)<<3); reg_bitmask|=(is_refined(x , y+1, z-1, level)<<4); reg_bitmask|=(is_refined(x-1, y-1, z, level)<<5); reg_bitmask|=(is_refined(x , y-1, z, level)<<6); reg_bitmask|=(is_refined(x+1, y-1, z, level)<<7); reg_bitmask|=(is_refined(x-1, y , z, level)<<8); reg_bitmask|=(is_refined(x+1, y , z, level)<<9); reg_bitmask|=(is_refined(x-1, y+1, z, level)<<10); reg_bitmask|=(is_refined(x , y+1, z, level)<<11); reg_bitmask|=(is_refined(x+1, y+1, z, level)<<12); reg_bitmask|=(is_refined(x , y-1, z+1, level)<<13); reg_bitmask|=(is_refined(x-1, y , z+1, level)<<14); reg_bitmask|=(is_refined(x , y , z+1, level)<<15); reg_bitmask|=(is_refined(x+1, y , z+1, level)<<16); reg_bitmask|=(is_refined(x , y+1, z+1, level)<<17); return reg_bitmask; } int Octree::is_refined2(int x, int y, int z, int level) { int idx=0; int res; res = (1<=res || y>=res || z>=res) return 0; idx = level_id[level] + x + y*res + z*res*res; if (oct_array[idx].refine_flag==1) return 1; else return 0; //return oct_array[idx].refine_flag; } int Octree::is_refined(int x, int y, int z, int level) { int idx=0; int res; res = (1<=res || y>=res || z>=res) return 1; idx = level_id[level] + x + y*res + z*res*res; if (oct_array[idx].refine_flag==0) return 0; else return 1; //return oct_array[idx].refine_flag; } int Octree::get_depth(int res) { int i=0; while (1) { if (res<=(1<oc_id) break; i++; } return i; } void Octree::octcell2xyz(int oc_id,int& x,int& y,int& z,int level) { int idx; int lres; idx=oc_id-level_id[level]; lres=level_res[level]; x=idx%lres; y=(idx/lres)%lres; z=idx/(lres*lres); } int Octree::xyz2octcell(int x,int y,int z,int level) { int lres; lres=level_res[level]; if (x<0 || y<0 || z<0 || x>=lres || y>=lres || z>=lres) return -1; return level_id[level]+x+y*lres+z*lres*lres; } int Octree::child(int oc_id, int level, int i) { int x,y,z; int ret_idx; octcell2xyz(oc_id,x,y,z,level); switch (i) { case 0 : ret_idx= xyz2octcell(x*2,y*2,z*2,level+1); break; case 1 : ret_idx= xyz2octcell(x*2+1,y*2,z*2,level+1); break; case 2 : ret_idx= xyz2octcell(x*2,y*2+1,z*2,level+1); break; case 3 : ret_idx= xyz2octcell(x*2+1,y*2+1,z*2,level+1); break; case 4 : ret_idx= xyz2octcell(x*2,y*2,z*2+1,level+1); break; case 5 : ret_idx= xyz2octcell(x*2+1,y*2,z*2+1,level+1); break; case 6 : ret_idx= xyz2octcell(x*2,y*2+1,z*2+1,level+1); break; case 7 : ret_idx= xyz2octcell(x*2+1,y*2+1,z*2+1,level+1); break; } return ret_idx; } int Octree::xyz2vtx(int x, int y, int z) { return x+y*dim[0]+z*dim[0]*dim[1]; } void Octree::idx2vtx(int oc_id, int level, int* vtx) { int x,y,z; int x0,x2,y0,y2,z0,z2; int cell_size; cell_size = (dim[0]-1)/(1<d1]; f2=in_value[ei->d2]; if (!((f1<=isovalue && f2>=isovalue)||(f1>=isovalue && f2<=isovalue))) { return 0; // false : not intersect } if (f1==f2) return 0; switch (ei->dir) { case 0: interpRect3Dpts_x(2*i+ei->di,2*j+ei->dj,2*k+ei->dk, f1, f2,isovalue,pt, norm, level+1); break; case 1: interpRect3Dpts_y(2*i+ei->di,2*j+ei->dj,2*k+ei->dk, f1, f2, isovalue,pt, norm, level+1); break; case 2: interpRect3Dpts_z(2*i+ei->di,2*j+ei->dj,2*k+ei->dk, f1, f2, isovalue,pt, norm, level+1); break; } assert(ei->dir==0 || ei->dir==1 || ei->dir==2); iv_idx = geofrm.AddVert(pt, norm); return 1; } void Octree::interpRect3Dpts_x(int i1, int j1, int k1, float d1, float d2, float val, float *pt,float *norm,int level) { double ival, gval; int cell_size; float g1[3], g2[3]; cell_size = (dim[0]-1)/(1<orig_val) min=orig_val; if (maxinterp_val) ? orig_val-interp_val : interp_val-orig_val; sum+=diff*diff; //sum+=diff; } } } if (level==oct_depth) return 0; //if (sum<=0.01) return 0.01; //return oct_depth-get_level(oc_idx); //printf("sum : %f\n",sum); return sum; } void Octree::getCellValues(int oc_id,int level,float* val) { int vtx[8]; idx2vtx(oc_id,level,vtx); int i; for (i=0;i<8;i++) { //val[i]=orig_vol[vtx[i]]; val[i] = orig_vol[vtx[i]]; } } float Octree::getValue(int i, int j, int k) { /* int cell_size=(dim[0]-1)/(1<=lres-1) { g[0] = getValue(i, j, k) - getValue(i-1, j, k); } else { g[0] = (getValue(i+1, j, k) - getValue(i-1, j, k)) * 0.5; } if (j==0) { g[1] = getValue(i, j+1, k) - getValue(i, j, k); } else if (j>=lres-1) { g[1] = getValue(i, j, k) - getValue(i, j-1, k); } else { g[1] = (getValue(i, j+1, k) - getValue(i, j-1, k)) * 0.5; } if (k==0) { g[2] = getValue(i, j, k+1) - getValue(i, j, k); } else if (k>=lres-1) { g[2] = getValue(i, j, k) - getValue(i, j, k-1); } else { g[2] = (getValue(i, j, k+1) - getValue(i, j, k-1)) * 0.5; } } // A.O //else if(flag_normal == 0) { // Bspline Convolution else{ // Bspline Convolution flag_normal == 0 float v[27]; int ix[3], iy[3], iz[3]; int l, m, n, t = 0; ix[0] = (i-1 >= 0)? i-1:0; ix[1] = i; ix[2] = (i+1 < dim[0])? i+1:i; iy[0] = (j-1 >= 0)? j-1:0; iy[1] = j; iy[2] = (j+1 < dim[1])? j+1:j; iz[0] = (k-1 >= 0)? k-1:0; iz[1] = k; iz[2] = (k+1 < dim[2])? k+1:k; for (n = 0; n < 3; n++) { for (m = 0; m < 3; m++) { for (l = 0; l < 3; l++) { v[t] = getValue(ix[l], iy[m], iz[n]); t++; } } } g[0] = g[1] = g[2] = 0; for (l = 0; l < 27; l++) { g[0] += x_grad_mask[l]*v[l]; g[1] += y_grad_mask[l]*v[l]; g[2] += z_grad_mask[l]*v[l]; } g[0] /= span[0]; g[1] /= span[1]; g[2] /= span[2]; } // A.O /**** else { // Bspline Interpolation GradientAtPoint(BSplineCoeff, (float)i, (float)j, (float)k, dim[0], dim[1], dim[2], g); g[0]=g[0]/span[0]; g[1]=g[1]/span[1]; g[2]=g[2]/span[2]; } ***/ } int Octree::is_skipcell(int oc_id) { if ((minmax[oc_id].max > iso_val) && (minmax[oc_id].min < iso_val)) return 0; else return 1; } int Octree::is_skipcell_in(int oc_id) { if ((minmax[oc_id].max > iso_val_in) && (minmax[oc_id].min < iso_val_in)) return 0; else return 1; } int Octree::is_skipcell_interval(int oc_id) { if ((minmax[oc_id].max > iso_val && minmax[oc_id].min < iso_val) || (minmax[oc_id].max > iso_val_in && minmax[oc_id].min < iso_val_in)) return 0; else return 1; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/cellQueue.h0000755000175000017500000000745710162122564024154 0ustar debiandebian//----------------------------------------------------------------------- // // cellQueue.h - queue of cell identifiers. The circular queue dyanmically // resizes itself when full. Elements in the queue are of // type and size specified by the user. Not even template'd // yet, just using a void *. // // Copyright (c) 1997 Dan Schikore //------------------------------------------------------------------------ #ifndef CELL_QUEUE_H #define CELL_QUEUE_H #include #include #include #include #include #include #include class CellQueue { public: // constructor/destructor inline CellQueue(int size=100); ~CellQueue(); // add item to the queue inline void Add(unsigned int cell); // remove and return the first item in queue inline int Get(int &cell); // return the first item in queue inline int Peek(int &cell); // remove the first item in queue inline void Pop(); // reset to empty void Reset(void) { nel = 0; } // check if queue is empty int Empty(void) { return(nel == 0); } protected: private: int nel; int cellsize; /* # of elements in cell array */ int start; unsigned int *cells; }; //------------------------------------------------------------------------ // // CellQueue() - create a new cell queue with elements of specified size // //------------------------------------------------------------------------ inline CellQueue::CellQueue(int size) { nel = 0; start = 0; cellsize = size; cells = (unsigned int *)malloc(sizeof(unsigned int) * cellsize); } //------------------------------------------------------------------------ // // ~CellQueue() - free storage // //------------------------------------------------------------------------ inline CellQueue::~CellQueue() { if (cells != NULL) free(cells); } //------------------------------------------------------------------------ // // Add() - add an item to the queue // //------------------------------------------------------------------------ inline void CellQueue::Add(unsigned int c) { int n; int oldsize; int atend; n = nel++; // resize the queue if needed if (nel > cellsize) { oldsize = cellsize; cellsize *= 2; cells = (unsigned int *)realloc(cells, sizeof(int) * cellsize); // move everything from 'start' to the end if (start != 0) { atend = oldsize - start; memmove(&cells[cellsize-atend], &cells[start], sizeof(unsigned int)*atend); start = cellsize-atend; } } n += start; if (n >= cellsize) n-=cellsize; cells[n] = c; } //------------------------------------------------------------------------ // // Get() - return the top item from the queue // //------------------------------------------------------------------------ inline int CellQueue::Get(int &c) { if (Peek(c) == -1) return(-1); Pop(); return(1); } //------------------------------------------------------------------------ // // Peek() - return the top item, but don't remove it // //------------------------------------------------------------------------ inline int CellQueue::Peek(int &c) { if (nel == 0) return(-1); c = cells[start]; return(1); } //------------------------------------------------------------------------ // // Pop() - delete the top item in the queue // //------------------------------------------------------------------------ inline void CellQueue::Pop(void) { start++; if (start == cellsize) start=0; nel--; } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/mydrawer.h0000644000175000017500000000474410204724336024055 0ustar debiandebian#ifndef MYDRAWER_H #define MYDRAWER_H #include "geoframe.h" #include #include using namespace std; struct plane { plane(): a(1.0), b(0.0), c(0.0), d(0.0) {} plane(double newa, double newb, double newc, double newd) : a(newa), b(newb), c(newc), d(newd) {} double a, b, c, d; }; typedef vector > FloatArray; typedef vector > IntArray; class MyDrawer { public: MyDrawer(); geoframe *g_frame; void display(IntArray *, FloatArray *); void display_tri(int, int, int, int, int, IntArray *); void display_hexa(int, int, int, IntArray *); void display_tri0(int, int, int, int, int, int, IntArray *); void display_tri00(int, int, int, int, int, int, int, IntArray *); void display_tetra(int, int, int, IntArray *, FloatArray *); void display_tetra_in(int, int, int, IntArray *, FloatArray *); void display_tri_vv(float*, float*, float*, int, int, int, FloatArray *); void display_permute_1(float*, float*, float*, float*); void display_permute_2(float*, float*, float*, float*); void display_permute_3(float*, float*, float*, float*); void display_permute_1_z(float*, float*, float*, float*); void display_permute_2_z(float*, float*, float*, float*); void display_permute_3_z(float*, float*, float*, float*); void display_1(int*, int, float*, float*, float*, float*, int, int, FloatArray *); void display_2(int*, int, float*, float*, float*, float*, int, int, FloatArray *); void display_3(int*, int, float*, float*, float*, float*, int, int, FloatArray *); void display_1_z(int*, int, float*, float*, float*, float*, int, int, FloatArray *); void display_2_z(int*, int, float*, float*, float*, float*, int, int, FloatArray *); void display_3_z(int*, int, float*, float*, float*, float*, int, int, FloatArray * ); void setGeo(geoframe* g); void setCutting(int flag) { cut_flag = flag; }; void setExtents(double biggest, double cx, double cy, double cz); void setPlaneX(float planex) {plane_x = planex;}; void setPlaneZ(float planez) {plane_z = planez;}; protected: private: void clearGeo() { g_frame->Clear(); } int cut_flag; int flat_flag; int wireframe_flag; char fn[100]; int r_oldmx, r_oldmy; int t_oldmx, t_oldmy, t_oldmz; int zoom_z; float plane_x, plane_z; plane frustum[6]; float dist; double biggestDim; double center[3], centerx, centery, centerz; double t_x,t_y,t_z; int vcount; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/normalspline.cpp0000755000175000017500000001415710336160773025270 0ustar debiandebian#include #include #include #include //#include #include #include "normalspline.h" #define DBL_EPSILON 1.0e-10 /*--------------------------------------------------------------------------*/ void ConvertToInterpolationCoefficients ( float *c, /* input samples --> output coefficients */ int DataLength, /* number of samples or coefficients */ float *z, /* poles */ int NbPoles, /* number of poles */ float Tolerance /* admissible relative error */ ) { /* begin ConvertToInterpolationCoefficients */ float Lambda = 1.0; int n, k; /* special case required by mirror boundaries */ if (DataLength == 1) { return; } /* compute the overall gain */ for (k = 0; k < NbPoles; k++) { Lambda = Lambda * (1.0f - z[k]) * (1.0f - 1.0f / z[k]); } /* apply the gain */ for (n = 0; n < DataLength; n++) { c[n] *= Lambda; } /* loop over all poles */ for (k = 0; k < NbPoles; k++) { /* causal initialization */ c[0] = InitialCausalCoefficient(c, DataLength, z[k], Tolerance); /* causal recursion */ for (n = 1; n < DataLength; n++) { c[n] += z[k] * c[n - 1]; } /* anticausal initialization */ c[DataLength - 1] = InitialAntiCausalCoefficient(c, DataLength, z[k]); /* anticausal recursion */ for (n = DataLength - 2; 0 <= n; n--) { c[n] = z[k] * (c[n + 1] - c[n]); } } } /* end ConvertToInterpolationCoefficients */ double BS_Fun(double x) { double result; if(x<0) x=-x; if(x<=1.0){ result=2.0/3.0-x*x+x*x*x/2.0; return result;} else {if(x<=2.0) result=(2.0-x)*(2.0-x)*(2.0-x)/6.0; return result;} return 0.0; } double BS_GraFun(double x) { double result,y; y=x; if(y<0.0) y=-y; if(y<=1.0){ result=-2.0*y+3.0*y*y/2.0; } else {if(y<=2.0) result=-(2.0-y)*(2.0-y)/2.0; } if(y>=2.0) result=0.0; if(x<0.0) result=-result; return result; } float InitialAntiCausalCoefficient ( float *c, /* coefficients */ int DataLength, /* number of samples or coefficients */ float z /* actual pole */ ) { /* begin InitialAntiCausalCoefficient */ /* this initialization corresponds to mirror boundaries */ return((z / (z * z - 1.0f)) * (z * c[DataLength - 2] + c[DataLength - 1])); } /* end InitialAntiCausalCoefficient */ float InitialCausalCoefficient ( float *c, /* coefficients */ int DataLength, /* number of coefficients */ float z, /* actual pole */ float Tolerance /* admissible relative error */ ) { /* begin InitialCausalCoefficient */ float Sum, zn, z2n, iz; int n, Horizon; /* this initialization corresponds to mirror boundaries */ Horizon = DataLength; if (Tolerance > 0.0) { Horizon = (int)ceil(log(Tolerance) / log(fabs(z))); } if (Horizon < DataLength) { /* accelerated loop */ zn = z; Sum = c[0]; for (n = 1; n < Horizon; n++) { Sum += zn * c[n]; zn *= z; } return(Sum); } else { /* full loop */ zn = z; iz = 1.0f / z; z2n = (float)pow(z, (DataLength - 1)); Sum = c[0] + z2n * c[DataLength - 1]; z2n *= z2n * iz; for (n = 1; n <= DataLength - 2; n++) { Sum += (zn + z2n) * c[n]; zn *= z; z2n *= iz; } return(Sum / (1.0f - zn * zn)); } } /* end InitialCausalCoefficient */ void TransImg2Spline (float* InImage, float* OutImg, int Width, int Height, int SliceNum) { float *Line1, *Line2, *Line3; float Pole[2]; int NbPoles; int x, y; int i,j,k,index; int SplineDegree; SplineDegree=3; NbPoles = 1; Pole[0] = (float) sqrt(3.0) - 2.0f; /* convert the image samples into interpolation coefficients */ /* in-place separable process, along x */ Line1 = (float *)calloc(Width,sizeof(float)); if (Line1 == NULL) { // std::cout<<"error in allocating memory"<=sizeX) indexi=2*sizeX-2-i; if(j<0) indexj=-j; if(j>=sizeY) indexj=2*sizeY-2-j; if(k<0) indexk=-k; if(k>=sizeZ) indexk=2*sizeZ-2-k; index=indexk*sizeX*sizeY+indexj*sizeX+indexi; tempdoublex+=SplineCoeff[index]*BS_GraFun(x-i)*BS_Fun(j-y)*BS_Fun(k-z); tempdoubley+=SplineCoeff[index]*BS_Fun(i-x)*BS_GraFun(y-j)*BS_Fun(k-z); tempdoublez+=SplineCoeff[index]*BS_Fun(i-x)*BS_Fun(j-y)*BS_GraFun(z-k); } grad[0]=(float)tempdoublex; grad[1]=(float)tempdoubley; grad[2]=(float)tempdoublez; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/interp_bit.h0000755000175000017500001267513310150464521024373 0ustar debiandebianint interpol_bit[262144] = { 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 226495, 226495, 226495, 226495, 226491, 226490, 226489, 226488, 226495, 226495, 226495, 226495, 226483, 226482, 226481, 226480, 226495, 226495, 226495, 226495, 226475, 226474, 226473, 226472, 226495, 226495, 226495, 226495, 226467, 226466, 226465, 226464, 226463, 226463, 226463, 226463, 226459, 226458, 226457, 226456, 226463, 226463, 226463, 226463, 226451, 226450, 226449, 226448, 226463, 226463, 226463, 226463, 226443, 226442, 226441, 226440, 226463, 226463, 226463, 226463, 226435, 226434, 226433, 226432, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 226367, 226367, 226367, 226367, 226363, 226362, 226361, 226360, 226367, 226367, 226367, 226367, 226355, 226354, 226353, 226352, 226367, 226367, 226367, 226367, 226347, 226346, 226345, 226344, 226367, 226367, 226367, 226367, 226339, 226338, 226337, 226336, 226335, 226335, 226335, 226335, 226331, 226330, 226329, 226328, 226335, 226335, 226335, 226335, 226323, 226322, 226321, 226320, 226335, 226335, 226335, 226335, 226315, 226314, 226313, 226312, 226335, 226335, 226335, 226335, 226307, 226306, 226305, 226304, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 225471, 225471, 225471, 225471, 225467, 225466, 225465, 225464, 225471, 225471, 225471, 225471, 225459, 225458, 225457, 225456, 225471, 225471, 225471, 225471, 225451, 225450, 225449, 225448, 225471, 225471, 225471, 225471, 225443, 225442, 225441, 225440, 225439, 225439, 225439, 225439, 225435, 225434, 225433, 225432, 225439, 225439, 225439, 225439, 225427, 225426, 225425, 225424, 225439, 225439, 225439, 225439, 225419, 225418, 225417, 225416, 225439, 225439, 225439, 225439, 225411, 225410, 225409, 225408, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 225343, 225343, 225343, 225343, 225339, 225338, 225337, 225336, 225343, 225343, 225343, 225343, 225331, 225330, 225329, 225328, 225343, 225343, 225343, 225343, 225323, 225322, 225321, 225320, 225343, 225343, 225343, 225343, 225315, 225314, 225313, 225312, 225311, 225311, 225311, 225311, 225307, 225306, 225305, 225304, 225311, 225311, 225311, 225311, 225299, 225298, 225297, 225296, 225311, 225311, 225311, 225311, 225291, 225290, 225289, 225288, 225311, 225311, 225311, 225311, 225283, 225282, 225281, 225280, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 222399, 222399, 222399, 222399, 222395, 222394, 222393, 222392, 222399, 222399, 222399, 222399, 222387, 222386, 222385, 222384, 222399, 222399, 222399, 222399, 222379, 222378, 222377, 222376, 222399, 222399, 222399, 222399, 222371, 222370, 222369, 222368, 222367, 222367, 222367, 222367, 222363, 222362, 222361, 222360, 222367, 222367, 222367, 222367, 222355, 222354, 222353, 222352, 222367, 222367, 222367, 222367, 222347, 222346, 222345, 222344, 222367, 222367, 222367, 222367, 222339, 222338, 222337, 222336, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 222271, 222271, 222271, 222271, 222267, 222266, 222265, 222264, 222271, 222271, 222271, 222271, 222259, 222258, 222257, 222256, 222271, 222271, 222271, 222271, 222251, 222250, 222249, 222248, 222271, 222271, 222271, 222271, 222243, 222242, 222241, 222240, 222239, 222239, 222239, 222239, 222235, 222234, 222233, 222232, 222239, 222239, 222239, 222239, 222227, 222226, 222225, 222224, 222239, 222239, 222239, 222239, 222219, 222218, 222217, 222216, 222239, 222239, 222239, 222239, 222211, 222210, 222209, 222208, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 221375, 221375, 221375, 221375, 221371, 221370, 221369, 221368, 221375, 221375, 221375, 221375, 221363, 221362, 221361, 221360, 221375, 221375, 221375, 221375, 221355, 221354, 221353, 221352, 221375, 221375, 221375, 221375, 221347, 221346, 221345, 221344, 221343, 221343, 221343, 221343, 221339, 221338, 221337, 221336, 221343, 221343, 221343, 221343, 221331, 221330, 221329, 221328, 221343, 221343, 221343, 221343, 221323, 221322, 221321, 221320, 221343, 221343, 221343, 221343, 221315, 221314, 221313, 221312, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 221247, 221247, 221247, 221247, 221243, 221242, 221241, 221240, 221247, 221247, 221247, 221247, 221235, 221234, 221233, 221232, 221247, 221247, 221247, 221247, 221227, 221226, 221225, 221224, 221247, 221247, 221247, 221247, 221219, 221218, 221217, 221216, 221215, 221215, 221215, 221215, 221211, 221210, 221209, 221208, 221215, 221215, 221215, 221215, 221203, 221202, 221201, 221200, 221215, 221215, 221215, 221215, 221195, 221194, 221193, 221192, 221215, 221215, 221215, 221215, 221187, 221186, 221185, 221184, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 218303, 218303, 218303, 218303, 218299, 218298, 218297, 218296, 218303, 218303, 218303, 218303, 218291, 218290, 218289, 218288, 218303, 218303, 218303, 218303, 218283, 218282, 218281, 218280, 218303, 218303, 218303, 218303, 218275, 218274, 218273, 218272, 218271, 218271, 218271, 218271, 218267, 218266, 218265, 218264, 218271, 218271, 218271, 218271, 218259, 218258, 218257, 218256, 218271, 218271, 218271, 218271, 218251, 218250, 218249, 218248, 218271, 218271, 218271, 218271, 218243, 218242, 218241, 218240, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 226559, 226559, 226559, 226559, 226555, 226555, 226553, 226553, 226559, 226559, 226559, 226559, 226547, 226547, 226545, 226545, 226559, 226559, 226559, 226559, 226539, 226539, 226537, 226537, 226559, 226559, 226559, 226559, 226531, 226531, 226529, 226529, 218175, 218175, 218175, 218175, 218171, 218170, 218169, 218168, 218175, 218175, 218175, 218175, 218163, 218162, 218161, 218160, 218175, 218175, 218175, 218175, 218155, 218154, 218153, 218152, 218175, 218175, 218175, 218175, 218147, 218146, 218145, 218144, 218143, 218143, 218143, 218143, 218139, 218138, 218137, 218136, 218143, 218143, 218143, 218143, 218131, 218130, 218129, 218128, 218143, 218143, 218143, 218143, 218123, 218122, 218121, 218120, 218143, 218143, 218143, 218143, 218115, 218114, 218113, 218112, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 217279, 217279, 217279, 217279, 217275, 217274, 217273, 217272, 217279, 217279, 217279, 217279, 217267, 217266, 217265, 217264, 217279, 217279, 217279, 217279, 217259, 217258, 217257, 217256, 217279, 217279, 217279, 217279, 217251, 217250, 217249, 217248, 217247, 217247, 217247, 217247, 217243, 217242, 217241, 217240, 217247, 217247, 217247, 217247, 217235, 217234, 217233, 217232, 217247, 217247, 217247, 217247, 217227, 217226, 217225, 217224, 217247, 217247, 217247, 217247, 217219, 217218, 217217, 217216, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 225535, 225535, 225535, 225535, 225531, 225531, 225529, 225529, 225535, 225535, 225535, 225535, 225523, 225523, 225521, 225521, 225535, 225535, 225535, 225535, 225515, 225515, 225513, 225513, 225535, 225535, 225535, 225535, 225507, 225507, 225505, 225505, 217151, 217151, 217151, 217151, 217147, 217146, 217145, 217144, 217151, 217151, 217151, 217151, 217139, 217138, 217137, 217136, 217151, 217151, 217151, 217151, 217131, 217130, 217129, 217128, 217151, 217151, 217151, 217151, 217123, 217122, 217121, 217120, 217119, 217119, 217119, 217119, 217115, 217114, 217113, 217112, 217119, 217119, 217119, 217119, 217107, 217106, 217105, 217104, 217119, 217119, 217119, 217119, 217099, 217098, 217097, 217096, 217119, 217119, 217119, 217119, 217091, 217090, 217089, 217088, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 214207, 214207, 214207, 214207, 214203, 214202, 214201, 214200, 214207, 214207, 214207, 214207, 214195, 214194, 214193, 214192, 214207, 214207, 214207, 214207, 214187, 214186, 214185, 214184, 214207, 214207, 214207, 214207, 214179, 214178, 214177, 214176, 214175, 214175, 214175, 214175, 214171, 214170, 214169, 214168, 214175, 214175, 214175, 214175, 214163, 214162, 214161, 214160, 214175, 214175, 214175, 214175, 214155, 214154, 214153, 214152, 214175, 214175, 214175, 214175, 214147, 214146, 214145, 214144, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 222463, 222463, 222463, 222463, 222459, 222459, 222457, 222457, 222463, 222463, 222463, 222463, 222451, 222451, 222449, 222449, 222463, 222463, 222463, 222463, 222443, 222443, 222441, 222441, 222463, 222463, 222463, 222463, 222435, 222435, 222433, 222433, 214079, 214079, 214079, 214079, 214075, 214074, 214073, 214072, 214079, 214079, 214079, 214079, 214067, 214066, 214065, 214064, 214079, 214079, 214079, 214079, 214059, 214058, 214057, 214056, 214079, 214079, 214079, 214079, 214051, 214050, 214049, 214048, 214047, 214047, 214047, 214047, 214043, 214042, 214041, 214040, 214047, 214047, 214047, 214047, 214035, 214034, 214033, 214032, 214047, 214047, 214047, 214047, 214027, 214026, 214025, 214024, 214047, 214047, 214047, 214047, 214019, 214018, 214017, 214016, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 213183, 213183, 213183, 213183, 213179, 213178, 213177, 213176, 213183, 213183, 213183, 213183, 213171, 213170, 213169, 213168, 213183, 213183, 213183, 213183, 213163, 213162, 213161, 213160, 213183, 213183, 213183, 213183, 213155, 213154, 213153, 213152, 213151, 213151, 213151, 213151, 213147, 213146, 213145, 213144, 213151, 213151, 213151, 213151, 213139, 213138, 213137, 213136, 213151, 213151, 213151, 213151, 213131, 213130, 213129, 213128, 213151, 213151, 213151, 213151, 213123, 213122, 213121, 213120, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 221439, 221439, 221439, 221439, 221435, 221435, 221433, 221433, 221439, 221439, 221439, 221439, 221427, 221427, 221425, 221425, 221439, 221439, 221439, 221439, 221419, 221419, 221417, 221417, 221439, 221439, 221439, 221439, 221411, 221411, 221409, 221409, 213055, 213055, 213055, 213055, 213051, 213050, 213049, 213048, 213055, 213055, 213055, 213055, 213043, 213042, 213041, 213040, 213055, 213055, 213055, 213055, 213035, 213034, 213033, 213032, 213055, 213055, 213055, 213055, 213027, 213026, 213025, 213024, 213023, 213023, 213023, 213023, 213019, 213018, 213017, 213016, 213023, 213023, 213023, 213023, 213011, 213010, 213009, 213008, 213023, 213023, 213023, 213023, 213003, 213002, 213001, 213000, 213023, 213023, 213023, 213023, 212995, 212994, 212993, 212992, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 210111, 210111, 210111, 210111, 210107, 210106, 210105, 210104, 210111, 210111, 210111, 210111, 210099, 210098, 210097, 210096, 210111, 210111, 210111, 210111, 210091, 210090, 210089, 210088, 210111, 210111, 210111, 210111, 210083, 210082, 210081, 210080, 210079, 210079, 210079, 210079, 210075, 210074, 210073, 210072, 210079, 210079, 210079, 210079, 210067, 210066, 210065, 210064, 210079, 210079, 210079, 210079, 210059, 210058, 210057, 210056, 210079, 210079, 210079, 210079, 210051, 210050, 210049, 210048, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 209983, 209983, 209983, 209983, 209979, 209978, 209977, 209976, 209983, 209983, 209983, 209983, 209971, 209970, 209969, 209968, 209983, 209983, 209983, 209983, 209963, 209962, 209961, 209960, 209983, 209983, 209983, 209983, 209955, 209954, 209953, 209952, 209951, 209951, 209951, 209951, 209947, 209946, 209945, 209944, 209951, 209951, 209951, 209951, 209939, 209938, 209937, 209936, 209951, 209951, 209951, 209951, 209931, 209930, 209929, 209928, 209951, 209951, 209951, 209951, 209923, 209922, 209921, 209920, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226751, 226751, 226751, 226751, 226747, 226746, 226747, 226746, 226751, 226751, 226751, 226751, 226739, 226738, 226739, 226738, 226751, 226751, 226751, 226751, 226731, 226730, 226731, 226730, 226751, 226751, 226751, 226751, 226723, 226722, 226723, 226722, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 226623, 226623, 226623, 226623, 226619, 226618, 226619, 226618, 226623, 226623, 226623, 226623, 226611, 226610, 226611, 226610, 226623, 226623, 226623, 226623, 226603, 226602, 226603, 226602, 226623, 226623, 226623, 226623, 226595, 226594, 226595, 226594, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 209087, 209087, 209087, 209087, 209083, 209082, 209081, 209080, 209087, 209087, 209087, 209087, 209075, 209074, 209073, 209072, 209087, 209087, 209087, 209087, 209067, 209066, 209065, 209064, 209087, 209087, 209087, 209087, 209059, 209058, 209057, 209056, 209055, 209055, 209055, 209055, 209051, 209050, 209049, 209048, 209055, 209055, 209055, 209055, 209043, 209042, 209041, 209040, 209055, 209055, 209055, 209055, 209035, 209034, 209033, 209032, 209055, 209055, 209055, 209055, 209027, 209026, 209025, 209024, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 208959, 208959, 208959, 208959, 208955, 208954, 208953, 208952, 208959, 208959, 208959, 208959, 208947, 208946, 208945, 208944, 208959, 208959, 208959, 208959, 208939, 208938, 208937, 208936, 208959, 208959, 208959, 208959, 208931, 208930, 208929, 208928, 208927, 208927, 208927, 208927, 208923, 208922, 208921, 208920, 208927, 208927, 208927, 208927, 208915, 208914, 208913, 208912, 208927, 208927, 208927, 208927, 208907, 208906, 208905, 208904, 208927, 208927, 208927, 208927, 208899, 208898, 208897, 208896, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 206015, 206015, 206015, 206015, 206011, 206010, 206009, 206008, 206015, 206015, 206015, 206015, 206003, 206002, 206001, 206000, 206015, 206015, 206015, 206015, 205995, 205994, 205993, 205992, 206015, 206015, 206015, 206015, 205987, 205986, 205985, 205984, 205983, 205983, 205983, 205983, 205979, 205978, 205977, 205976, 205983, 205983, 205983, 205983, 205971, 205970, 205969, 205968, 205983, 205983, 205983, 205983, 205963, 205962, 205961, 205960, 205983, 205983, 205983, 205983, 205955, 205954, 205953, 205952, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 205887, 205887, 205887, 205887, 205883, 205882, 205881, 205880, 205887, 205887, 205887, 205887, 205875, 205874, 205873, 205872, 205887, 205887, 205887, 205887, 205867, 205866, 205865, 205864, 205887, 205887, 205887, 205887, 205859, 205858, 205857, 205856, 205855, 205855, 205855, 205855, 205851, 205850, 205849, 205848, 205855, 205855, 205855, 205855, 205843, 205842, 205841, 205840, 205855, 205855, 205855, 205855, 205835, 205834, 205833, 205832, 205855, 205855, 205855, 205855, 205827, 205826, 205825, 205824, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222655, 222655, 222655, 222655, 222651, 222650, 222651, 222650, 222655, 222655, 222655, 222655, 222643, 222642, 222643, 222642, 222655, 222655, 222655, 222655, 222635, 222634, 222635, 222634, 222655, 222655, 222655, 222655, 222627, 222626, 222627, 222626, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 222527, 222527, 222527, 222527, 222523, 222522, 222523, 222522, 222527, 222527, 222527, 222527, 222515, 222514, 222515, 222514, 222527, 222527, 222527, 222527, 222507, 222506, 222507, 222506, 222527, 222527, 222527, 222527, 222499, 222498, 222499, 222498, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 204991, 204991, 204991, 204991, 204987, 204986, 204985, 204984, 204991, 204991, 204991, 204991, 204979, 204978, 204977, 204976, 204991, 204991, 204991, 204991, 204971, 204970, 204969, 204968, 204991, 204991, 204991, 204991, 204963, 204962, 204961, 204960, 204959, 204959, 204959, 204959, 204955, 204954, 204953, 204952, 204959, 204959, 204959, 204959, 204947, 204946, 204945, 204944, 204959, 204959, 204959, 204959, 204939, 204938, 204937, 204936, 204959, 204959, 204959, 204959, 204931, 204930, 204929, 204928, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 204863, 204863, 204863, 204863, 204859, 204858, 204857, 204856, 204863, 204863, 204863, 204863, 204851, 204850, 204849, 204848, 204863, 204863, 204863, 204863, 204843, 204842, 204841, 204840, 204863, 204863, 204863, 204863, 204835, 204834, 204833, 204832, 204831, 204831, 204831, 204831, 204827, 204826, 204825, 204824, 204831, 204831, 204831, 204831, 204819, 204818, 204817, 204816, 204831, 204831, 204831, 204831, 204811, 204810, 204809, 204808, 204831, 204831, 204831, 204831, 204803, 204802, 204801, 204800, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 201919, 201919, 201919, 201919, 201915, 201914, 201913, 201912, 201919, 201919, 201919, 201919, 201907, 201906, 201905, 201904, 201919, 201919, 201919, 201919, 201899, 201898, 201897, 201896, 201919, 201919, 201919, 201919, 201891, 201890, 201889, 201888, 201887, 201887, 201887, 201887, 201883, 201882, 201881, 201880, 201887, 201887, 201887, 201887, 201875, 201874, 201873, 201872, 201887, 201887, 201887, 201887, 201867, 201866, 201865, 201864, 201887, 201887, 201887, 201887, 201859, 201858, 201857, 201856, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 210175, 210175, 210175, 210175, 210171, 210171, 210169, 210169, 210175, 210175, 210175, 210175, 210163, 210163, 210161, 210161, 210175, 210175, 210175, 210175, 210155, 210155, 210153, 210153, 210175, 210175, 210175, 210175, 210147, 210147, 210145, 210145, 201791, 201791, 201791, 201791, 201787, 201786, 201785, 201784, 201791, 201791, 201791, 201791, 201779, 201778, 201777, 201776, 201791, 201791, 201791, 201791, 201771, 201770, 201769, 201768, 201791, 201791, 201791, 201791, 201763, 201762, 201761, 201760, 201759, 201759, 201759, 201759, 201755, 201754, 201753, 201752, 201759, 201759, 201759, 201759, 201747, 201746, 201745, 201744, 201759, 201759, 201759, 201759, 201739, 201738, 201737, 201736, 201759, 201759, 201759, 201759, 201731, 201730, 201729, 201728, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 218559, 218559, 218559, 218559, 218555, 218554, 218555, 218554, 218559, 218559, 218559, 218559, 218547, 218546, 218547, 218546, 218559, 218559, 218559, 218559, 218539, 218538, 218539, 218538, 218559, 218559, 218559, 218559, 218531, 218530, 218531, 218530, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 226815, 226815, 226815, 226815, 226811, 226811, 226811, 226811, 226815, 226815, 226815, 226815, 226803, 226803, 226803, 226803, 226815, 226815, 226815, 226815, 226795, 226795, 226795, 226795, 226815, 226815, 226815, 226815, 226787, 226787, 226787, 226787, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 218431, 218431, 218431, 218431, 218427, 218426, 218427, 218426, 218431, 218431, 218431, 218431, 218419, 218418, 218419, 218418, 218431, 218431, 218431, 218431, 218411, 218410, 218411, 218410, 218431, 218431, 218431, 218431, 218403, 218402, 218403, 218402, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 200895, 200895, 200895, 200895, 200891, 200890, 200889, 200888, 200895, 200895, 200895, 200895, 200883, 200882, 200881, 200880, 200895, 200895, 200895, 200895, 200875, 200874, 200873, 200872, 200895, 200895, 200895, 200895, 200867, 200866, 200865, 200864, 200863, 200863, 200863, 200863, 200859, 200858, 200857, 200856, 200863, 200863, 200863, 200863, 200851, 200850, 200849, 200848, 200863, 200863, 200863, 200863, 200843, 200842, 200841, 200840, 200863, 200863, 200863, 200863, 200835, 200834, 200833, 200832, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 209151, 209151, 209151, 209151, 209147, 209147, 209145, 209145, 209151, 209151, 209151, 209151, 209139, 209139, 209137, 209137, 209151, 209151, 209151, 209151, 209131, 209131, 209129, 209129, 209151, 209151, 209151, 209151, 209123, 209123, 209121, 209121, 200767, 200767, 200767, 200767, 200763, 200762, 200761, 200760, 200767, 200767, 200767, 200767, 200755, 200754, 200753, 200752, 200767, 200767, 200767, 200767, 200747, 200746, 200745, 200744, 200767, 200767, 200767, 200767, 200739, 200738, 200737, 200736, 200735, 200735, 200735, 200735, 200731, 200730, 200729, 200728, 200735, 200735, 200735, 200735, 200723, 200722, 200721, 200720, 200735, 200735, 200735, 200735, 200715, 200714, 200713, 200712, 200735, 200735, 200735, 200735, 200707, 200706, 200705, 200704, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 197823, 197823, 197823, 197823, 197819, 197818, 197817, 197816, 197823, 197823, 197823, 197823, 197811, 197810, 197809, 197808, 197823, 197823, 197823, 197823, 197803, 197802, 197801, 197800, 197823, 197823, 197823, 197823, 197795, 197794, 197793, 197792, 197791, 197791, 197791, 197791, 197787, 197786, 197785, 197784, 197791, 197791, 197791, 197791, 197779, 197778, 197777, 197776, 197791, 197791, 197791, 197791, 197771, 197770, 197769, 197768, 197791, 197791, 197791, 197791, 197763, 197762, 197761, 197760, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 206079, 206079, 206079, 206079, 206075, 206075, 206073, 206073, 206079, 206079, 206079, 206079, 206067, 206067, 206065, 206065, 206079, 206079, 206079, 206079, 206059, 206059, 206057, 206057, 206079, 206079, 206079, 206079, 206051, 206051, 206049, 206049, 197695, 197695, 197695, 197695, 197691, 197690, 197689, 197688, 197695, 197695, 197695, 197695, 197683, 197682, 197681, 197680, 197695, 197695, 197695, 197695, 197675, 197674, 197673, 197672, 197695, 197695, 197695, 197695, 197667, 197666, 197665, 197664, 197663, 197663, 197663, 197663, 197659, 197658, 197657, 197656, 197663, 197663, 197663, 197663, 197651, 197650, 197649, 197648, 197663, 197663, 197663, 197663, 197643, 197642, 197641, 197640, 197663, 197663, 197663, 197663, 197635, 197634, 197633, 197632, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 214463, 214463, 214463, 214463, 214459, 214458, 214459, 214458, 214463, 214463, 214463, 214463, 214451, 214450, 214451, 214450, 214463, 214463, 214463, 214463, 214443, 214442, 214443, 214442, 214463, 214463, 214463, 214463, 214435, 214434, 214435, 214434, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 222719, 222719, 222719, 222719, 222715, 222715, 222715, 222715, 222719, 222719, 222719, 222719, 222707, 222707, 222707, 222707, 222719, 222719, 222719, 222719, 222699, 222699, 222699, 222699, 222719, 222719, 222719, 222719, 222691, 222691, 222691, 222691, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 214335, 214335, 214335, 214335, 214331, 214330, 214331, 214330, 214335, 214335, 214335, 214335, 214323, 214322, 214323, 214322, 214335, 214335, 214335, 214335, 214315, 214314, 214315, 214314, 214335, 214335, 214335, 214335, 214307, 214306, 214307, 214306, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 196799, 196799, 196799, 196799, 196795, 196794, 196793, 196792, 196799, 196799, 196799, 196799, 196787, 196786, 196785, 196784, 196799, 196799, 196799, 196799, 196779, 196778, 196777, 196776, 196799, 196799, 196799, 196799, 196771, 196770, 196769, 196768, 196767, 196767, 196767, 196767, 196763, 196762, 196761, 196760, 196767, 196767, 196767, 196767, 196755, 196754, 196753, 196752, 196767, 196767, 196767, 196767, 196747, 196746, 196745, 196744, 196767, 196767, 196767, 196767, 196739, 196738, 196737, 196736, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 205055, 205055, 205055, 205055, 205051, 205051, 205049, 205049, 205055, 205055, 205055, 205055, 205043, 205043, 205041, 205041, 205055, 205055, 205055, 205055, 205035, 205035, 205033, 205033, 205055, 205055, 205055, 205055, 205027, 205027, 205025, 205025, 196671, 196671, 196671, 196671, 196667, 196666, 196665, 196664, 196671, 196671, 196671, 196671, 196659, 196658, 196657, 196656, 196671, 196671, 196671, 196671, 196651, 196650, 196649, 196648, 196671, 196671, 196671, 196671, 196643, 196642, 196641, 196640, 196639, 196639, 196639, 196639, 196635, 196634, 196633, 196632, 196639, 196639, 196639, 196639, 196627, 196626, 196625, 196624, 196639, 196639, 196639, 196639, 196619, 196618, 196617, 196616, 196639, 196639, 196639, 196639, 196611, 196610, 196609, 196608, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 160959, 160959, 160959, 160959, 160955, 160954, 160953, 160952, 160959, 160959, 160959, 160959, 160947, 160946, 160945, 160944, 160959, 160959, 160959, 160959, 160939, 160938, 160937, 160936, 160959, 160959, 160959, 160959, 160931, 160930, 160929, 160928, 160927, 160927, 160927, 160927, 160923, 160922, 160921, 160920, 160927, 160927, 160927, 160927, 160915, 160914, 160913, 160912, 160927, 160927, 160927, 160927, 160907, 160906, 160905, 160904, 160927, 160927, 160927, 160927, 160899, 160898, 160897, 160896, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 160831, 160831, 160831, 160831, 160827, 160826, 160825, 160824, 160831, 160831, 160831, 160831, 160819, 160818, 160817, 160816, 160831, 160831, 160831, 160831, 160811, 160810, 160809, 160808, 160831, 160831, 160831, 160831, 160803, 160802, 160801, 160800, 160799, 160799, 160799, 160799, 160795, 160794, 160793, 160792, 160799, 160799, 160799, 160799, 160787, 160786, 160785, 160784, 160799, 160799, 160799, 160799, 160779, 160778, 160777, 160776, 160799, 160799, 160799, 160799, 160771, 160770, 160769, 160768, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 159935, 159935, 159935, 159935, 159931, 159930, 159929, 159928, 159935, 159935, 159935, 159935, 159923, 159922, 159921, 159920, 159935, 159935, 159935, 159935, 159915, 159914, 159913, 159912, 159935, 159935, 159935, 159935, 159907, 159906, 159905, 159904, 159903, 159903, 159903, 159903, 159899, 159898, 159897, 159896, 159903, 159903, 159903, 159903, 159891, 159890, 159889, 159888, 159903, 159903, 159903, 159903, 159883, 159882, 159881, 159880, 159903, 159903, 159903, 159903, 159875, 159874, 159873, 159872, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 159807, 159807, 159807, 159807, 159803, 159802, 159801, 159800, 159807, 159807, 159807, 159807, 159795, 159794, 159793, 159792, 159807, 159807, 159807, 159807, 159787, 159786, 159785, 159784, 159807, 159807, 159807, 159807, 159779, 159778, 159777, 159776, 159775, 159775, 159775, 159775, 159771, 159770, 159769, 159768, 159775, 159775, 159775, 159775, 159763, 159762, 159761, 159760, 159775, 159775, 159775, 159775, 159755, 159754, 159753, 159752, 159775, 159775, 159775, 159775, 159747, 159746, 159745, 159744, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 227003, 227002, 227001, 227000, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 227007, 227007, 227007, 227007, 226987, 226986, 226985, 226984, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226971, 226970, 226969, 226968, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 226975, 226975, 226975, 226975, 226955, 226954, 226953, 226952, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 156863, 156863, 156863, 156863, 156859, 156858, 156857, 156856, 156863, 156863, 156863, 156863, 156851, 156850, 156849, 156848, 156863, 156863, 156863, 156863, 156843, 156842, 156841, 156840, 156863, 156863, 156863, 156863, 156835, 156834, 156833, 156832, 156831, 156831, 156831, 156831, 156827, 156826, 156825, 156824, 156831, 156831, 156831, 156831, 156819, 156818, 156817, 156816, 156831, 156831, 156831, 156831, 156811, 156810, 156809, 156808, 156831, 156831, 156831, 156831, 156803, 156802, 156801, 156800, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 156735, 156735, 156735, 156735, 156731, 156730, 156729, 156728, 156735, 156735, 156735, 156735, 156723, 156722, 156721, 156720, 156735, 156735, 156735, 156735, 156715, 156714, 156713, 156712, 156735, 156735, 156735, 156735, 156707, 156706, 156705, 156704, 156703, 156703, 156703, 156703, 156699, 156698, 156697, 156696, 156703, 156703, 156703, 156703, 156691, 156690, 156689, 156688, 156703, 156703, 156703, 156703, 156683, 156682, 156681, 156680, 156703, 156703, 156703, 156703, 156675, 156674, 156673, 156672, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225979, 225978, 225977, 225976, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225983, 225983, 225983, 225983, 225963, 225962, 225961, 225960, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225947, 225946, 225945, 225944, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 225951, 225951, 225951, 225951, 225931, 225930, 225929, 225928, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 155839, 155839, 155839, 155839, 155835, 155834, 155833, 155832, 155839, 155839, 155839, 155839, 155827, 155826, 155825, 155824, 155839, 155839, 155839, 155839, 155819, 155818, 155817, 155816, 155839, 155839, 155839, 155839, 155811, 155810, 155809, 155808, 155807, 155807, 155807, 155807, 155803, 155802, 155801, 155800, 155807, 155807, 155807, 155807, 155795, 155794, 155793, 155792, 155807, 155807, 155807, 155807, 155787, 155786, 155785, 155784, 155807, 155807, 155807, 155807, 155779, 155778, 155777, 155776, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 155711, 155711, 155711, 155711, 155707, 155706, 155705, 155704, 155711, 155711, 155711, 155711, 155699, 155698, 155697, 155696, 155711, 155711, 155711, 155711, 155691, 155690, 155689, 155688, 155711, 155711, 155711, 155711, 155683, 155682, 155681, 155680, 155679, 155679, 155679, 155679, 155675, 155674, 155673, 155672, 155679, 155679, 155679, 155679, 155667, 155666, 155665, 155664, 155679, 155679, 155679, 155679, 155659, 155658, 155657, 155656, 155679, 155679, 155679, 155679, 155651, 155650, 155649, 155648, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 152767, 152767, 152767, 152767, 152763, 152762, 152761, 152760, 152767, 152767, 152767, 152767, 152755, 152754, 152753, 152752, 152767, 152767, 152767, 152767, 152747, 152746, 152745, 152744, 152767, 152767, 152767, 152767, 152739, 152738, 152737, 152736, 152735, 152735, 152735, 152735, 152731, 152730, 152729, 152728, 152735, 152735, 152735, 152735, 152723, 152722, 152721, 152720, 152735, 152735, 152735, 152735, 152715, 152714, 152713, 152712, 152735, 152735, 152735, 152735, 152707, 152706, 152705, 152704, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 161023, 161023, 161023, 161023, 161019, 161019, 161017, 161017, 161023, 161023, 161023, 161023, 161011, 161011, 161009, 161009, 161023, 161023, 161023, 161023, 161003, 161003, 161001, 161001, 161023, 161023, 161023, 161023, 160995, 160995, 160993, 160993, 152639, 152639, 152639, 152639, 152635, 152634, 152633, 152632, 152639, 152639, 152639, 152639, 152627, 152626, 152625, 152624, 152639, 152639, 152639, 152639, 152619, 152618, 152617, 152616, 152639, 152639, 152639, 152639, 152611, 152610, 152609, 152608, 152607, 152607, 152607, 152607, 152603, 152602, 152601, 152600, 152607, 152607, 152607, 152607, 152595, 152594, 152593, 152592, 152607, 152607, 152607, 152607, 152587, 152586, 152585, 152584, 152607, 152607, 152607, 152607, 152579, 152578, 152577, 152576, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 151743, 151743, 151743, 151743, 151739, 151738, 151737, 151736, 151743, 151743, 151743, 151743, 151731, 151730, 151729, 151728, 151743, 151743, 151743, 151743, 151723, 151722, 151721, 151720, 151743, 151743, 151743, 151743, 151715, 151714, 151713, 151712, 151711, 151711, 151711, 151711, 151707, 151706, 151705, 151704, 151711, 151711, 151711, 151711, 151699, 151698, 151697, 151696, 151711, 151711, 151711, 151711, 151691, 151690, 151689, 151688, 151711, 151711, 151711, 151711, 151683, 151682, 151681, 151680, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 159999, 159999, 159999, 159999, 159995, 159995, 159993, 159993, 159999, 159999, 159999, 159999, 159987, 159987, 159985, 159985, 159999, 159999, 159999, 159999, 159979, 159979, 159977, 159977, 159999, 159999, 159999, 159999, 159971, 159971, 159969, 159969, 151615, 151615, 151615, 151615, 151611, 151610, 151609, 151608, 151615, 151615, 151615, 151615, 151603, 151602, 151601, 151600, 151615, 151615, 151615, 151615, 151595, 151594, 151593, 151592, 151615, 151615, 151615, 151615, 151587, 151586, 151585, 151584, 151583, 151583, 151583, 151583, 151579, 151578, 151577, 151576, 151583, 151583, 151583, 151583, 151571, 151570, 151569, 151568, 151583, 151583, 151583, 151583, 151563, 151562, 151561, 151560, 151583, 151583, 151583, 151583, 151555, 151554, 151553, 151552, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227067, 227067, 227065, 227065, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 227071, 227071, 227071, 227071, 227051, 227051, 227049, 227049, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218811, 218810, 218809, 218808, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218815, 218815, 218815, 218815, 218795, 218794, 218793, 218792, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218779, 218778, 218777, 218776, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 218783, 218783, 218783, 218783, 218763, 218762, 218761, 218760, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 148671, 148671, 148671, 148671, 148667, 148666, 148665, 148664, 148671, 148671, 148671, 148671, 148659, 148658, 148657, 148656, 148671, 148671, 148671, 148671, 148651, 148650, 148649, 148648, 148671, 148671, 148671, 148671, 148643, 148642, 148641, 148640, 148639, 148639, 148639, 148639, 148635, 148634, 148633, 148632, 148639, 148639, 148639, 148639, 148627, 148626, 148625, 148624, 148639, 148639, 148639, 148639, 148619, 148618, 148617, 148616, 148639, 148639, 148639, 148639, 148611, 148610, 148609, 148608, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 156927, 156927, 156927, 156927, 156923, 156923, 156921, 156921, 156927, 156927, 156927, 156927, 156915, 156915, 156913, 156913, 156927, 156927, 156927, 156927, 156907, 156907, 156905, 156905, 156927, 156927, 156927, 156927, 156899, 156899, 156897, 156897, 148543, 148543, 148543, 148543, 148539, 148538, 148537, 148536, 148543, 148543, 148543, 148543, 148531, 148530, 148529, 148528, 148543, 148543, 148543, 148543, 148523, 148522, 148521, 148520, 148543, 148543, 148543, 148543, 148515, 148514, 148513, 148512, 148511, 148511, 148511, 148511, 148507, 148506, 148505, 148504, 148511, 148511, 148511, 148511, 148499, 148498, 148497, 148496, 148511, 148511, 148511, 148511, 148491, 148490, 148489, 148488, 148511, 148511, 148511, 148511, 148483, 148482, 148481, 148480, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226043, 226043, 226041, 226041, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 226047, 226047, 226047, 226047, 226027, 226027, 226025, 226025, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217787, 217786, 217785, 217784, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217791, 217791, 217791, 217791, 217771, 217770, 217769, 217768, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217755, 217754, 217753, 217752, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 217759, 217759, 217759, 217759, 217739, 217738, 217737, 217736, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 147647, 147647, 147647, 147647, 147643, 147642, 147641, 147640, 147647, 147647, 147647, 147647, 147635, 147634, 147633, 147632, 147647, 147647, 147647, 147647, 147627, 147626, 147625, 147624, 147647, 147647, 147647, 147647, 147619, 147618, 147617, 147616, 147615, 147615, 147615, 147615, 147611, 147610, 147609, 147608, 147615, 147615, 147615, 147615, 147603, 147602, 147601, 147600, 147615, 147615, 147615, 147615, 147595, 147594, 147593, 147592, 147615, 147615, 147615, 147615, 147587, 147586, 147585, 147584, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 155903, 155903, 155903, 155903, 155899, 155899, 155897, 155897, 155903, 155903, 155903, 155903, 155891, 155891, 155889, 155889, 155903, 155903, 155903, 155903, 155883, 155883, 155881, 155881, 155903, 155903, 155903, 155903, 155875, 155875, 155873, 155873, 147519, 147519, 147519, 147519, 147515, 147514, 147513, 147512, 147519, 147519, 147519, 147519, 147507, 147506, 147505, 147504, 147519, 147519, 147519, 147519, 147499, 147498, 147497, 147496, 147519, 147519, 147519, 147519, 147491, 147490, 147489, 147488, 147487, 147487, 147487, 147487, 147483, 147482, 147481, 147480, 147487, 147487, 147487, 147487, 147475, 147474, 147473, 147472, 147487, 147487, 147487, 147487, 147467, 147466, 147465, 147464, 147487, 147487, 147487, 147487, 147459, 147458, 147457, 147456, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 144575, 144575, 144575, 144575, 144571, 144570, 144569, 144568, 144575, 144575, 144575, 144575, 144563, 144562, 144561, 144560, 144575, 144575, 144575, 144575, 144555, 144554, 144553, 144552, 144575, 144575, 144575, 144575, 144547, 144546, 144545, 144544, 144543, 144543, 144543, 144543, 144539, 144538, 144537, 144536, 144543, 144543, 144543, 144543, 144531, 144530, 144529, 144528, 144543, 144543, 144543, 144543, 144523, 144522, 144521, 144520, 144543, 144543, 144543, 144543, 144515, 144514, 144513, 144512, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 144447, 144447, 144447, 144447, 144443, 144442, 144441, 144440, 144447, 144447, 144447, 144447, 144435, 144434, 144433, 144432, 144447, 144447, 144447, 144447, 144427, 144426, 144425, 144424, 144447, 144447, 144447, 144447, 144419, 144418, 144417, 144416, 144415, 144415, 144415, 144415, 144411, 144410, 144409, 144408, 144415, 144415, 144415, 144415, 144403, 144402, 144401, 144400, 144415, 144415, 144415, 144415, 144395, 144394, 144393, 144392, 144415, 144415, 144415, 144415, 144387, 144386, 144385, 144384, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161215, 161215, 161215, 161215, 161211, 161210, 161211, 161210, 161215, 161215, 161215, 161215, 161203, 161202, 161203, 161202, 161215, 161215, 161215, 161215, 161195, 161194, 161195, 161194, 161215, 161215, 161215, 161215, 161187, 161186, 161187, 161186, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 161087, 161087, 161087, 161087, 161083, 161082, 161083, 161082, 161087, 161087, 161087, 161087, 161075, 161074, 161075, 161074, 161087, 161087, 161087, 161087, 161067, 161066, 161067, 161066, 161087, 161087, 161087, 161087, 161059, 161058, 161059, 161058, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 143551, 143551, 143551, 143551, 143547, 143546, 143545, 143544, 143551, 143551, 143551, 143551, 143539, 143538, 143537, 143536, 143551, 143551, 143551, 143551, 143531, 143530, 143529, 143528, 143551, 143551, 143551, 143551, 143523, 143522, 143521, 143520, 143519, 143519, 143519, 143519, 143515, 143514, 143513, 143512, 143519, 143519, 143519, 143519, 143507, 143506, 143505, 143504, 143519, 143519, 143519, 143519, 143499, 143498, 143497, 143496, 143519, 143519, 143519, 143519, 143491, 143490, 143489, 143488, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 143423, 143423, 143423, 143423, 143419, 143418, 143417, 143416, 143423, 143423, 143423, 143423, 143411, 143410, 143409, 143408, 143423, 143423, 143423, 143423, 143403, 143402, 143401, 143400, 143423, 143423, 143423, 143423, 143395, 143394, 143393, 143392, 143391, 143391, 143391, 143391, 143387, 143386, 143385, 143384, 143391, 143391, 143391, 143391, 143379, 143378, 143377, 143376, 143391, 143391, 143391, 143391, 143371, 143370, 143369, 143368, 143391, 143391, 143391, 143391, 143363, 143362, 143361, 143360, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210619, 210618, 210617, 210616, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210623, 210623, 210623, 210623, 210603, 210602, 210601, 210600, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210587, 210586, 210585, 210584, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 210591, 210591, 210591, 210591, 210571, 210570, 210569, 210568, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 140479, 140479, 140479, 140479, 140475, 140474, 140473, 140472, 140479, 140479, 140479, 140479, 140467, 140466, 140465, 140464, 140479, 140479, 140479, 140479, 140459, 140458, 140457, 140456, 140479, 140479, 140479, 140479, 140451, 140450, 140449, 140448, 140447, 140447, 140447, 140447, 140443, 140442, 140441, 140440, 140447, 140447, 140447, 140447, 140435, 140434, 140433, 140432, 140447, 140447, 140447, 140447, 140427, 140426, 140425, 140424, 140447, 140447, 140447, 140447, 140419, 140418, 140417, 140416, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 140351, 140351, 140351, 140351, 140347, 140346, 140345, 140344, 140351, 140351, 140351, 140351, 140339, 140338, 140337, 140336, 140351, 140351, 140351, 140351, 140331, 140330, 140329, 140328, 140351, 140351, 140351, 140351, 140323, 140322, 140321, 140320, 140319, 140319, 140319, 140319, 140315, 140314, 140313, 140312, 140319, 140319, 140319, 140319, 140307, 140306, 140305, 140304, 140319, 140319, 140319, 140319, 140299, 140298, 140297, 140296, 140319, 140319, 140319, 140319, 140291, 140290, 140289, 140288, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227259, 227258, 227259, 227258, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 227263, 227263, 227263, 227263, 227243, 227242, 227243, 227242, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209595, 209594, 209593, 209592, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209599, 209599, 209599, 209599, 209579, 209578, 209577, 209576, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209563, 209562, 209561, 209560, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 209567, 209567, 209567, 209567, 209547, 209546, 209545, 209544, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157119, 157119, 157119, 157119, 157115, 157114, 157115, 157114, 157119, 157119, 157119, 157119, 157107, 157106, 157107, 157106, 157119, 157119, 157119, 157119, 157099, 157098, 157099, 157098, 157119, 157119, 157119, 157119, 157091, 157090, 157091, 157090, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 156991, 156991, 156991, 156991, 156987, 156986, 156987, 156986, 156991, 156991, 156991, 156991, 156979, 156978, 156979, 156978, 156991, 156991, 156991, 156991, 156971, 156970, 156971, 156970, 156991, 156991, 156991, 156991, 156963, 156962, 156963, 156962, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 139455, 139455, 139455, 139455, 139451, 139450, 139449, 139448, 139455, 139455, 139455, 139455, 139443, 139442, 139441, 139440, 139455, 139455, 139455, 139455, 139435, 139434, 139433, 139432, 139455, 139455, 139455, 139455, 139427, 139426, 139425, 139424, 139423, 139423, 139423, 139423, 139419, 139418, 139417, 139416, 139423, 139423, 139423, 139423, 139411, 139410, 139409, 139408, 139423, 139423, 139423, 139423, 139403, 139402, 139401, 139400, 139423, 139423, 139423, 139423, 139395, 139394, 139393, 139392, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 139327, 139327, 139327, 139327, 139323, 139322, 139321, 139320, 139327, 139327, 139327, 139327, 139315, 139314, 139313, 139312, 139327, 139327, 139327, 139327, 139307, 139306, 139305, 139304, 139327, 139327, 139327, 139327, 139299, 139298, 139297, 139296, 139295, 139295, 139295, 139295, 139291, 139290, 139289, 139288, 139295, 139295, 139295, 139295, 139283, 139282, 139281, 139280, 139295, 139295, 139295, 139295, 139275, 139274, 139273, 139272, 139295, 139295, 139295, 139295, 139267, 139266, 139265, 139264, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 136383, 136383, 136383, 136383, 136379, 136378, 136377, 136376, 136383, 136383, 136383, 136383, 136371, 136370, 136369, 136368, 136383, 136383, 136383, 136383, 136363, 136362, 136361, 136360, 136383, 136383, 136383, 136383, 136355, 136354, 136353, 136352, 136351, 136351, 136351, 136351, 136347, 136346, 136345, 136344, 136351, 136351, 136351, 136351, 136339, 136338, 136337, 136336, 136351, 136351, 136351, 136351, 136331, 136330, 136329, 136328, 136351, 136351, 136351, 136351, 136323, 136322, 136321, 136320, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 144639, 144639, 144639, 144639, 144635, 144635, 144633, 144633, 144639, 144639, 144639, 144639, 144627, 144627, 144625, 144625, 144639, 144639, 144639, 144639, 144619, 144619, 144617, 144617, 144639, 144639, 144639, 144639, 144611, 144611, 144609, 144609, 136255, 136255, 136255, 136255, 136251, 136250, 136249, 136248, 136255, 136255, 136255, 136255, 136243, 136242, 136241, 136240, 136255, 136255, 136255, 136255, 136235, 136234, 136233, 136232, 136255, 136255, 136255, 136255, 136227, 136226, 136225, 136224, 136223, 136223, 136223, 136223, 136219, 136218, 136217, 136216, 136223, 136223, 136223, 136223, 136211, 136210, 136209, 136208, 136223, 136223, 136223, 136223, 136203, 136202, 136201, 136200, 136223, 136223, 136223, 136223, 136195, 136194, 136193, 136192, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 153023, 153023, 153023, 153023, 153019, 153018, 153019, 153018, 153023, 153023, 153023, 153023, 153011, 153010, 153011, 153010, 153023, 153023, 153023, 153023, 153003, 153002, 153003, 153002, 153023, 153023, 153023, 153023, 152995, 152994, 152995, 152994, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 161279, 161279, 161279, 161279, 161275, 161275, 161275, 161275, 161279, 161279, 161279, 161279, 161267, 161267, 161267, 161267, 161279, 161279, 161279, 161279, 161259, 161259, 161259, 161259, 161279, 161279, 161279, 161279, 161251, 161251, 161251, 161251, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 152895, 152895, 152895, 152895, 152891, 152890, 152891, 152890, 152895, 152895, 152895, 152895, 152883, 152882, 152883, 152882, 152895, 152895, 152895, 152895, 152875, 152874, 152875, 152874, 152895, 152895, 152895, 152895, 152867, 152866, 152867, 152866, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 135359, 135359, 135359, 135359, 135355, 135354, 135353, 135352, 135359, 135359, 135359, 135359, 135347, 135346, 135345, 135344, 135359, 135359, 135359, 135359, 135339, 135338, 135337, 135336, 135359, 135359, 135359, 135359, 135331, 135330, 135329, 135328, 135327, 135327, 135327, 135327, 135323, 135322, 135321, 135320, 135327, 135327, 135327, 135327, 135315, 135314, 135313, 135312, 135327, 135327, 135327, 135327, 135307, 135306, 135305, 135304, 135327, 135327, 135327, 135327, 135299, 135298, 135297, 135296, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 143615, 143615, 143615, 143615, 143611, 143611, 143609, 143609, 143615, 143615, 143615, 143615, 143603, 143603, 143601, 143601, 143615, 143615, 143615, 143615, 143595, 143595, 143593, 143593, 143615, 143615, 143615, 143615, 143587, 143587, 143585, 143585, 135231, 135231, 135231, 135231, 135227, 135226, 135225, 135224, 135231, 135231, 135231, 135231, 135219, 135218, 135217, 135216, 135231, 135231, 135231, 135231, 135211, 135210, 135209, 135208, 135231, 135231, 135231, 135231, 135203, 135202, 135201, 135200, 135199, 135199, 135199, 135199, 135195, 135194, 135193, 135192, 135199, 135199, 135199, 135199, 135187, 135186, 135185, 135184, 135199, 135199, 135199, 135199, 135179, 135178, 135177, 135176, 135199, 135199, 135199, 135199, 135171, 135170, 135169, 135168, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210683, 210683, 210681, 210681, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 210687, 210687, 210687, 210687, 210667, 210667, 210665, 210665, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202427, 202426, 202425, 202424, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202431, 202431, 202431, 202431, 202411, 202410, 202409, 202408, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202395, 202394, 202393, 202392, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 202399, 202399, 202399, 202399, 202379, 202378, 202377, 202376, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 132287, 132287, 132287, 132287, 132283, 132282, 132281, 132280, 132287, 132287, 132287, 132287, 132275, 132274, 132273, 132272, 132287, 132287, 132287, 132287, 132267, 132266, 132265, 132264, 132287, 132287, 132287, 132287, 132259, 132258, 132257, 132256, 132255, 132255, 132255, 132255, 132251, 132250, 132249, 132248, 132255, 132255, 132255, 132255, 132243, 132242, 132241, 132240, 132255, 132255, 132255, 132255, 132235, 132234, 132233, 132232, 132255, 132255, 132255, 132255, 132227, 132226, 132225, 132224, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 140543, 140543, 140543, 140543, 140539, 140539, 140537, 140537, 140543, 140543, 140543, 140543, 140531, 140531, 140529, 140529, 140543, 140543, 140543, 140543, 140523, 140523, 140521, 140521, 140543, 140543, 140543, 140543, 140515, 140515, 140513, 140513, 132159, 132159, 132159, 132159, 132155, 132154, 132153, 132152, 132159, 132159, 132159, 132159, 132147, 132146, 132145, 132144, 132159, 132159, 132159, 132159, 132139, 132138, 132137, 132136, 132159, 132159, 132159, 132159, 132131, 132130, 132129, 132128, 132127, 132127, 132127, 132127, 132123, 132122, 132121, 132120, 132127, 132127, 132127, 132127, 132115, 132114, 132113, 132112, 132127, 132127, 132127, 132127, 132107, 132106, 132105, 132104, 132127, 132127, 132127, 132127, 132099, 132098, 132097, 132096, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227323, 227323, 227323, 227323, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 227327, 227327, 227327, 227327, 227307, 227307, 227307, 227307, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219067, 219066, 219067, 219066, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 219071, 219071, 219071, 219071, 219051, 219050, 219051, 219050, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209659, 209659, 209657, 209657, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 209663, 209663, 209663, 209663, 209643, 209643, 209641, 209641, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201403, 201402, 201401, 201400, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201407, 201407, 201407, 201407, 201387, 201386, 201385, 201384, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201371, 201370, 201369, 201368, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 201375, 201375, 201375, 201375, 201355, 201354, 201353, 201352, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 148927, 148927, 148927, 148927, 148923, 148922, 148923, 148922, 148927, 148927, 148927, 148927, 148915, 148914, 148915, 148914, 148927, 148927, 148927, 148927, 148907, 148906, 148907, 148906, 148927, 148927, 148927, 148927, 148899, 148898, 148899, 148898, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 157183, 157183, 157183, 157183, 157179, 157179, 157179, 157179, 157183, 157183, 157183, 157183, 157171, 157171, 157171, 157171, 157183, 157183, 157183, 157183, 157163, 157163, 157163, 157163, 157183, 157183, 157183, 157183, 157155, 157155, 157155, 157155, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 148799, 148799, 148799, 148799, 148795, 148794, 148795, 148794, 148799, 148799, 148799, 148799, 148787, 148786, 148787, 148786, 148799, 148799, 148799, 148799, 148779, 148778, 148779, 148778, 148799, 148799, 148799, 148799, 148771, 148770, 148771, 148770, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 131263, 131263, 131263, 131263, 131259, 131258, 131257, 131256, 131263, 131263, 131263, 131263, 131251, 131250, 131249, 131248, 131263, 131263, 131263, 131263, 131243, 131242, 131241, 131240, 131263, 131263, 131263, 131263, 131235, 131234, 131233, 131232, 131231, 131231, 131231, 131231, 131227, 131226, 131225, 131224, 131231, 131231, 131231, 131231, 131219, 131218, 131217, 131216, 131231, 131231, 131231, 131231, 131211, 131210, 131209, 131208, 131231, 131231, 131231, 131231, 131203, 131202, 131201, 131200, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 139519, 139519, 139519, 139519, 139515, 139515, 139513, 139513, 139519, 139519, 139519, 139519, 139507, 139507, 139505, 139505, 139519, 139519, 139519, 139519, 139499, 139499, 139497, 139497, 139519, 139519, 139519, 139519, 139491, 139491, 139489, 139489, 131135, 131135, 131135, 131135, 131131, 131130, 131129, 131128, 131135, 131135, 131135, 131135, 131123, 131122, 131121, 131120, 131135, 131135, 131135, 131135, 131115, 131114, 131113, 131112, 131135, 131135, 131135, 131135, 131107, 131106, 131105, 131104, 131103, 131103, 131103, 131103, 131099, 131098, 131097, 131096, 131103, 131103, 131103, 131103, 131091, 131090, 131089, 131088, 131103, 131103, 131103, 131103, 131083, 131082, 131081, 131080, 131103, 131103, 131103, 131103, 131075, 131074, 131073, 131072, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 95423, 95423, 95423, 95423, 95419, 95418, 95417, 95416, 95423, 95423, 95423, 95423, 95411, 95410, 95409, 95408, 95423, 95423, 95423, 95423, 95403, 95402, 95401, 95400, 95423, 95423, 95423, 95423, 95395, 95394, 95393, 95392, 95391, 95391, 95391, 95391, 95387, 95386, 95385, 95384, 95391, 95391, 95391, 95391, 95379, 95378, 95377, 95376, 95391, 95391, 95391, 95391, 95371, 95370, 95369, 95368, 95391, 95391, 95391, 95391, 95363, 95362, 95361, 95360, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 95295, 95295, 95295, 95295, 95291, 95290, 95289, 95288, 95295, 95295, 95295, 95295, 95283, 95282, 95281, 95280, 95295, 95295, 95295, 95295, 95275, 95274, 95273, 95272, 95295, 95295, 95295, 95295, 95267, 95266, 95265, 95264, 95263, 95263, 95263, 95263, 95259, 95258, 95257, 95256, 95263, 95263, 95263, 95263, 95251, 95250, 95249, 95248, 95263, 95263, 95263, 95263, 95243, 95242, 95241, 95240, 95263, 95263, 95263, 95263, 95235, 95234, 95233, 95232, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 94399, 94399, 94399, 94399, 94395, 94394, 94393, 94392, 94399, 94399, 94399, 94399, 94387, 94386, 94385, 94384, 94399, 94399, 94399, 94399, 94379, 94378, 94377, 94376, 94399, 94399, 94399, 94399, 94371, 94370, 94369, 94368, 94367, 94367, 94367, 94367, 94363, 94362, 94361, 94360, 94367, 94367, 94367, 94367, 94355, 94354, 94353, 94352, 94367, 94367, 94367, 94367, 94347, 94346, 94345, 94344, 94367, 94367, 94367, 94367, 94339, 94338, 94337, 94336, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 94271, 94271, 94271, 94271, 94267, 94266, 94265, 94264, 94271, 94271, 94271, 94271, 94259, 94258, 94257, 94256, 94271, 94271, 94271, 94271, 94251, 94250, 94249, 94248, 94271, 94271, 94271, 94271, 94243, 94242, 94241, 94240, 94239, 94239, 94239, 94239, 94235, 94234, 94233, 94232, 94239, 94239, 94239, 94239, 94227, 94226, 94225, 94224, 94239, 94239, 94239, 94239, 94219, 94218, 94217, 94216, 94239, 94239, 94239, 94239, 94211, 94210, 94209, 94208, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228543, 228543, 228543, 228543, 228539, 228538, 228537, 228536, 228543, 228543, 228543, 228543, 228531, 228530, 228529, 228528, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228511, 228511, 228511, 228511, 228507, 228506, 228505, 228504, 228511, 228511, 228511, 228511, 228499, 228498, 228497, 228496, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228415, 228415, 228415, 228415, 228411, 228410, 228409, 228408, 228415, 228415, 228415, 228415, 228403, 228402, 228401, 228400, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 228383, 228383, 228383, 228383, 228379, 228378, 228377, 228376, 228383, 228383, 228383, 228383, 228371, 228370, 228369, 228368, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 91327, 91327, 91327, 91327, 91323, 91322, 91321, 91320, 91327, 91327, 91327, 91327, 91315, 91314, 91313, 91312, 91327, 91327, 91327, 91327, 91307, 91306, 91305, 91304, 91327, 91327, 91327, 91327, 91299, 91298, 91297, 91296, 91295, 91295, 91295, 91295, 91291, 91290, 91289, 91288, 91295, 91295, 91295, 91295, 91283, 91282, 91281, 91280, 91295, 91295, 91295, 91295, 91275, 91274, 91273, 91272, 91295, 91295, 91295, 91295, 91267, 91266, 91265, 91264, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 91199, 91199, 91199, 91199, 91195, 91194, 91193, 91192, 91199, 91199, 91199, 91199, 91187, 91186, 91185, 91184, 91199, 91199, 91199, 91199, 91179, 91178, 91177, 91176, 91199, 91199, 91199, 91199, 91171, 91170, 91169, 91168, 91167, 91167, 91167, 91167, 91163, 91162, 91161, 91160, 91167, 91167, 91167, 91167, 91155, 91154, 91153, 91152, 91167, 91167, 91167, 91167, 91147, 91146, 91145, 91144, 91167, 91167, 91167, 91167, 91139, 91138, 91137, 91136, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 90303, 90303, 90303, 90303, 90299, 90298, 90297, 90296, 90303, 90303, 90303, 90303, 90291, 90290, 90289, 90288, 90303, 90303, 90303, 90303, 90283, 90282, 90281, 90280, 90303, 90303, 90303, 90303, 90275, 90274, 90273, 90272, 90271, 90271, 90271, 90271, 90267, 90266, 90265, 90264, 90271, 90271, 90271, 90271, 90259, 90258, 90257, 90256, 90271, 90271, 90271, 90271, 90251, 90250, 90249, 90248, 90271, 90271, 90271, 90271, 90243, 90242, 90241, 90240, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 90175, 90175, 90175, 90175, 90171, 90170, 90169, 90168, 90175, 90175, 90175, 90175, 90163, 90162, 90161, 90160, 90175, 90175, 90175, 90175, 90155, 90154, 90153, 90152, 90175, 90175, 90175, 90175, 90147, 90146, 90145, 90144, 90143, 90143, 90143, 90143, 90139, 90138, 90137, 90136, 90143, 90143, 90143, 90143, 90131, 90130, 90129, 90128, 90143, 90143, 90143, 90143, 90123, 90122, 90121, 90120, 90143, 90143, 90143, 90143, 90115, 90114, 90113, 90112, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 87231, 87231, 87231, 87231, 87227, 87226, 87225, 87224, 87231, 87231, 87231, 87231, 87219, 87218, 87217, 87216, 87231, 87231, 87231, 87231, 87211, 87210, 87209, 87208, 87231, 87231, 87231, 87231, 87203, 87202, 87201, 87200, 87199, 87199, 87199, 87199, 87195, 87194, 87193, 87192, 87199, 87199, 87199, 87199, 87187, 87186, 87185, 87184, 87199, 87199, 87199, 87199, 87179, 87178, 87177, 87176, 87199, 87199, 87199, 87199, 87171, 87170, 87169, 87168, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 95487, 95487, 95487, 95487, 95483, 95483, 95481, 95481, 95487, 95487, 95487, 95487, 95475, 95475, 95473, 95473, 95487, 95487, 95487, 95487, 95467, 95467, 95465, 95465, 95487, 95487, 95487, 95487, 95459, 95459, 95457, 95457, 87103, 87103, 87103, 87103, 87099, 87098, 87097, 87096, 87103, 87103, 87103, 87103, 87091, 87090, 87089, 87088, 87103, 87103, 87103, 87103, 87083, 87082, 87081, 87080, 87103, 87103, 87103, 87103, 87075, 87074, 87073, 87072, 87071, 87071, 87071, 87071, 87067, 87066, 87065, 87064, 87071, 87071, 87071, 87071, 87059, 87058, 87057, 87056, 87071, 87071, 87071, 87071, 87051, 87050, 87049, 87048, 87071, 87071, 87071, 87071, 87043, 87042, 87041, 87040, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 86207, 86207, 86207, 86207, 86203, 86202, 86201, 86200, 86207, 86207, 86207, 86207, 86195, 86194, 86193, 86192, 86207, 86207, 86207, 86207, 86187, 86186, 86185, 86184, 86207, 86207, 86207, 86207, 86179, 86178, 86177, 86176, 86175, 86175, 86175, 86175, 86171, 86170, 86169, 86168, 86175, 86175, 86175, 86175, 86163, 86162, 86161, 86160, 86175, 86175, 86175, 86175, 86155, 86154, 86153, 86152, 86175, 86175, 86175, 86175, 86147, 86146, 86145, 86144, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 94463, 94463, 94463, 94463, 94459, 94459, 94457, 94457, 94463, 94463, 94463, 94463, 94451, 94451, 94449, 94449, 94463, 94463, 94463, 94463, 94443, 94443, 94441, 94441, 94463, 94463, 94463, 94463, 94435, 94435, 94433, 94433, 86079, 86079, 86079, 86079, 86075, 86074, 86073, 86072, 86079, 86079, 86079, 86079, 86067, 86066, 86065, 86064, 86079, 86079, 86079, 86079, 86059, 86058, 86057, 86056, 86079, 86079, 86079, 86079, 86051, 86050, 86049, 86048, 86047, 86047, 86047, 86047, 86043, 86042, 86041, 86040, 86047, 86047, 86047, 86047, 86035, 86034, 86033, 86032, 86047, 86047, 86047, 86047, 86027, 86026, 86025, 86024, 86047, 86047, 86047, 86047, 86019, 86018, 86017, 86016, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220351, 220351, 220351, 220351, 220347, 220346, 220345, 220344, 220351, 220351, 220351, 220351, 220339, 220338, 220337, 220336, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 220319, 220319, 220319, 220319, 220315, 220314, 220313, 220312, 220319, 220319, 220319, 220319, 220307, 220306, 220305, 220304, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 228607, 228607, 228607, 228607, 228603, 228603, 228601, 228601, 228607, 228607, 228607, 228607, 228595, 228595, 228593, 228593, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220223, 220223, 220223, 220223, 220219, 220218, 220217, 220216, 220223, 220223, 220223, 220223, 220211, 220210, 220209, 220208, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 220191, 220191, 220191, 220191, 220187, 220186, 220185, 220184, 220191, 220191, 220191, 220191, 220179, 220178, 220177, 220176, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 83135, 83135, 83135, 83135, 83131, 83130, 83129, 83128, 83135, 83135, 83135, 83135, 83123, 83122, 83121, 83120, 83135, 83135, 83135, 83135, 83115, 83114, 83113, 83112, 83135, 83135, 83135, 83135, 83107, 83106, 83105, 83104, 83103, 83103, 83103, 83103, 83099, 83098, 83097, 83096, 83103, 83103, 83103, 83103, 83091, 83090, 83089, 83088, 83103, 83103, 83103, 83103, 83083, 83082, 83081, 83080, 83103, 83103, 83103, 83103, 83075, 83074, 83073, 83072, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 91391, 91391, 91391, 91391, 91387, 91387, 91385, 91385, 91391, 91391, 91391, 91391, 91379, 91379, 91377, 91377, 91391, 91391, 91391, 91391, 91371, 91371, 91369, 91369, 91391, 91391, 91391, 91391, 91363, 91363, 91361, 91361, 83007, 83007, 83007, 83007, 83003, 83002, 83001, 83000, 83007, 83007, 83007, 83007, 82995, 82994, 82993, 82992, 83007, 83007, 83007, 83007, 82987, 82986, 82985, 82984, 83007, 83007, 83007, 83007, 82979, 82978, 82977, 82976, 82975, 82975, 82975, 82975, 82971, 82970, 82969, 82968, 82975, 82975, 82975, 82975, 82963, 82962, 82961, 82960, 82975, 82975, 82975, 82975, 82955, 82954, 82953, 82952, 82975, 82975, 82975, 82975, 82947, 82946, 82945, 82944, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 82111, 82111, 82111, 82111, 82107, 82106, 82105, 82104, 82111, 82111, 82111, 82111, 82099, 82098, 82097, 82096, 82111, 82111, 82111, 82111, 82091, 82090, 82089, 82088, 82111, 82111, 82111, 82111, 82083, 82082, 82081, 82080, 82079, 82079, 82079, 82079, 82075, 82074, 82073, 82072, 82079, 82079, 82079, 82079, 82067, 82066, 82065, 82064, 82079, 82079, 82079, 82079, 82059, 82058, 82057, 82056, 82079, 82079, 82079, 82079, 82051, 82050, 82049, 82048, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 90367, 90367, 90367, 90367, 90363, 90363, 90361, 90361, 90367, 90367, 90367, 90367, 90355, 90355, 90353, 90353, 90367, 90367, 90367, 90367, 90347, 90347, 90345, 90345, 90367, 90367, 90367, 90367, 90339, 90339, 90337, 90337, 81983, 81983, 81983, 81983, 81979, 81978, 81977, 81976, 81983, 81983, 81983, 81983, 81971, 81970, 81969, 81968, 81983, 81983, 81983, 81983, 81963, 81962, 81961, 81960, 81983, 81983, 81983, 81983, 81955, 81954, 81953, 81952, 81951, 81951, 81951, 81951, 81947, 81946, 81945, 81944, 81951, 81951, 81951, 81951, 81939, 81938, 81937, 81936, 81951, 81951, 81951, 81951, 81931, 81930, 81929, 81928, 81951, 81951, 81951, 81951, 81923, 81922, 81921, 81920, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 79039, 79039, 79039, 79039, 79035, 79034, 79033, 79032, 79039, 79039, 79039, 79039, 79027, 79026, 79025, 79024, 79039, 79039, 79039, 79039, 79019, 79018, 79017, 79016, 79039, 79039, 79039, 79039, 79011, 79010, 79009, 79008, 79007, 79007, 79007, 79007, 79003, 79002, 79001, 79000, 79007, 79007, 79007, 79007, 78995, 78994, 78993, 78992, 79007, 79007, 79007, 79007, 78987, 78986, 78985, 78984, 79007, 79007, 79007, 79007, 78979, 78978, 78977, 78976, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 78911, 78911, 78911, 78911, 78907, 78906, 78905, 78904, 78911, 78911, 78911, 78911, 78899, 78898, 78897, 78896, 78911, 78911, 78911, 78911, 78891, 78890, 78889, 78888, 78911, 78911, 78911, 78911, 78883, 78882, 78881, 78880, 78879, 78879, 78879, 78879, 78875, 78874, 78873, 78872, 78879, 78879, 78879, 78879, 78867, 78866, 78865, 78864, 78879, 78879, 78879, 78879, 78859, 78858, 78857, 78856, 78879, 78879, 78879, 78879, 78851, 78850, 78849, 78848, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95679, 95679, 95679, 95679, 95675, 95674, 95675, 95674, 95679, 95679, 95679, 95679, 95667, 95666, 95667, 95666, 95679, 95679, 95679, 95679, 95659, 95658, 95659, 95658, 95679, 95679, 95679, 95679, 95651, 95650, 95651, 95650, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 95551, 95551, 95551, 95551, 95547, 95546, 95547, 95546, 95551, 95551, 95551, 95551, 95539, 95538, 95539, 95538, 95551, 95551, 95551, 95551, 95531, 95530, 95531, 95530, 95551, 95551, 95551, 95551, 95523, 95522, 95523, 95522, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 78015, 78015, 78015, 78015, 78011, 78010, 78009, 78008, 78015, 78015, 78015, 78015, 78003, 78002, 78001, 78000, 78015, 78015, 78015, 78015, 77995, 77994, 77993, 77992, 78015, 78015, 78015, 78015, 77987, 77986, 77985, 77984, 77983, 77983, 77983, 77983, 77979, 77978, 77977, 77976, 77983, 77983, 77983, 77983, 77971, 77970, 77969, 77968, 77983, 77983, 77983, 77983, 77963, 77962, 77961, 77960, 77983, 77983, 77983, 77983, 77955, 77954, 77953, 77952, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 77887, 77887, 77887, 77887, 77883, 77882, 77881, 77880, 77887, 77887, 77887, 77887, 77875, 77874, 77873, 77872, 77887, 77887, 77887, 77887, 77867, 77866, 77865, 77864, 77887, 77887, 77887, 77887, 77859, 77858, 77857, 77856, 77855, 77855, 77855, 77855, 77851, 77850, 77849, 77848, 77855, 77855, 77855, 77855, 77843, 77842, 77841, 77840, 77855, 77855, 77855, 77855, 77835, 77834, 77833, 77832, 77855, 77855, 77855, 77855, 77827, 77826, 77825, 77824, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228799, 228799, 228799, 228799, 228795, 228794, 228795, 228794, 228799, 228799, 228799, 228799, 228787, 228786, 228787, 228786, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 228671, 228671, 228671, 228671, 228667, 228666, 228667, 228666, 228671, 228671, 228671, 228671, 228659, 228658, 228659, 228658, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212159, 212159, 212159, 212159, 212155, 212154, 212153, 212152, 212159, 212159, 212159, 212159, 212147, 212146, 212145, 212144, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212127, 212127, 212127, 212127, 212123, 212122, 212121, 212120, 212127, 212127, 212127, 212127, 212115, 212114, 212113, 212112, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 212031, 212031, 212031, 212031, 212027, 212026, 212025, 212024, 212031, 212031, 212031, 212031, 212019, 212018, 212017, 212016, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 211999, 211999, 211999, 211999, 211995, 211994, 211993, 211992, 211999, 211999, 211999, 211999, 211987, 211986, 211985, 211984, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 74943, 74943, 74943, 74943, 74939, 74938, 74937, 74936, 74943, 74943, 74943, 74943, 74931, 74930, 74929, 74928, 74943, 74943, 74943, 74943, 74923, 74922, 74921, 74920, 74943, 74943, 74943, 74943, 74915, 74914, 74913, 74912, 74911, 74911, 74911, 74911, 74907, 74906, 74905, 74904, 74911, 74911, 74911, 74911, 74899, 74898, 74897, 74896, 74911, 74911, 74911, 74911, 74891, 74890, 74889, 74888, 74911, 74911, 74911, 74911, 74883, 74882, 74881, 74880, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 74815, 74815, 74815, 74815, 74811, 74810, 74809, 74808, 74815, 74815, 74815, 74815, 74803, 74802, 74801, 74800, 74815, 74815, 74815, 74815, 74795, 74794, 74793, 74792, 74815, 74815, 74815, 74815, 74787, 74786, 74785, 74784, 74783, 74783, 74783, 74783, 74779, 74778, 74777, 74776, 74783, 74783, 74783, 74783, 74771, 74770, 74769, 74768, 74783, 74783, 74783, 74783, 74763, 74762, 74761, 74760, 74783, 74783, 74783, 74783, 74755, 74754, 74753, 74752, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91583, 91583, 91583, 91583, 91579, 91578, 91579, 91578, 91583, 91583, 91583, 91583, 91571, 91570, 91571, 91570, 91583, 91583, 91583, 91583, 91563, 91562, 91563, 91562, 91583, 91583, 91583, 91583, 91555, 91554, 91555, 91554, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 91455, 91455, 91455, 91455, 91451, 91450, 91451, 91450, 91455, 91455, 91455, 91455, 91443, 91442, 91443, 91442, 91455, 91455, 91455, 91455, 91435, 91434, 91435, 91434, 91455, 91455, 91455, 91455, 91427, 91426, 91427, 91426, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 73919, 73919, 73919, 73919, 73915, 73914, 73913, 73912, 73919, 73919, 73919, 73919, 73907, 73906, 73905, 73904, 73919, 73919, 73919, 73919, 73899, 73898, 73897, 73896, 73919, 73919, 73919, 73919, 73891, 73890, 73889, 73888, 73887, 73887, 73887, 73887, 73883, 73882, 73881, 73880, 73887, 73887, 73887, 73887, 73875, 73874, 73873, 73872, 73887, 73887, 73887, 73887, 73867, 73866, 73865, 73864, 73887, 73887, 73887, 73887, 73859, 73858, 73857, 73856, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 73791, 73791, 73791, 73791, 73787, 73786, 73785, 73784, 73791, 73791, 73791, 73791, 73779, 73778, 73777, 73776, 73791, 73791, 73791, 73791, 73771, 73770, 73769, 73768, 73791, 73791, 73791, 73791, 73763, 73762, 73761, 73760, 73759, 73759, 73759, 73759, 73755, 73754, 73753, 73752, 73759, 73759, 73759, 73759, 73747, 73746, 73745, 73744, 73759, 73759, 73759, 73759, 73739, 73738, 73737, 73736, 73759, 73759, 73759, 73759, 73731, 73730, 73729, 73728, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 70847, 70847, 70847, 70847, 70843, 70842, 70841, 70840, 70847, 70847, 70847, 70847, 70835, 70834, 70833, 70832, 70847, 70847, 70847, 70847, 70827, 70826, 70825, 70824, 70847, 70847, 70847, 70847, 70819, 70818, 70817, 70816, 70815, 70815, 70815, 70815, 70811, 70810, 70809, 70808, 70815, 70815, 70815, 70815, 70803, 70802, 70801, 70800, 70815, 70815, 70815, 70815, 70795, 70794, 70793, 70792, 70815, 70815, 70815, 70815, 70787, 70786, 70785, 70784, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 79103, 79103, 79103, 79103, 79099, 79099, 79097, 79097, 79103, 79103, 79103, 79103, 79091, 79091, 79089, 79089, 79103, 79103, 79103, 79103, 79083, 79083, 79081, 79081, 79103, 79103, 79103, 79103, 79075, 79075, 79073, 79073, 70719, 70719, 70719, 70719, 70715, 70714, 70713, 70712, 70719, 70719, 70719, 70719, 70707, 70706, 70705, 70704, 70719, 70719, 70719, 70719, 70699, 70698, 70697, 70696, 70719, 70719, 70719, 70719, 70691, 70690, 70689, 70688, 70687, 70687, 70687, 70687, 70683, 70682, 70681, 70680, 70687, 70687, 70687, 70687, 70675, 70674, 70673, 70672, 70687, 70687, 70687, 70687, 70667, 70666, 70665, 70664, 70687, 70687, 70687, 70687, 70659, 70658, 70657, 70656, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 87487, 87487, 87487, 87487, 87483, 87482, 87483, 87482, 87487, 87487, 87487, 87487, 87475, 87474, 87475, 87474, 87487, 87487, 87487, 87487, 87467, 87466, 87467, 87466, 87487, 87487, 87487, 87487, 87459, 87458, 87459, 87458, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 95743, 95743, 95743, 95743, 95739, 95739, 95739, 95739, 95743, 95743, 95743, 95743, 95731, 95731, 95731, 95731, 95743, 95743, 95743, 95743, 95723, 95723, 95723, 95723, 95743, 95743, 95743, 95743, 95715, 95715, 95715, 95715, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 87359, 87359, 87359, 87359, 87355, 87354, 87355, 87354, 87359, 87359, 87359, 87359, 87347, 87346, 87347, 87346, 87359, 87359, 87359, 87359, 87339, 87338, 87339, 87338, 87359, 87359, 87359, 87359, 87331, 87330, 87331, 87330, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 69823, 69823, 69823, 69823, 69819, 69818, 69817, 69816, 69823, 69823, 69823, 69823, 69811, 69810, 69809, 69808, 69823, 69823, 69823, 69823, 69803, 69802, 69801, 69800, 69823, 69823, 69823, 69823, 69795, 69794, 69793, 69792, 69791, 69791, 69791, 69791, 69787, 69786, 69785, 69784, 69791, 69791, 69791, 69791, 69779, 69778, 69777, 69776, 69791, 69791, 69791, 69791, 69771, 69770, 69769, 69768, 69791, 69791, 69791, 69791, 69763, 69762, 69761, 69760, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 78079, 78079, 78079, 78079, 78075, 78075, 78073, 78073, 78079, 78079, 78079, 78079, 78067, 78067, 78065, 78065, 78079, 78079, 78079, 78079, 78059, 78059, 78057, 78057, 78079, 78079, 78079, 78079, 78051, 78051, 78049, 78049, 69695, 69695, 69695, 69695, 69691, 69690, 69689, 69688, 69695, 69695, 69695, 69695, 69683, 69682, 69681, 69680, 69695, 69695, 69695, 69695, 69675, 69674, 69673, 69672, 69695, 69695, 69695, 69695, 69667, 69666, 69665, 69664, 69663, 69663, 69663, 69663, 69659, 69658, 69657, 69656, 69663, 69663, 69663, 69663, 69651, 69650, 69649, 69648, 69663, 69663, 69663, 69663, 69643, 69642, 69641, 69640, 69663, 69663, 69663, 69663, 69635, 69634, 69633, 69632, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 220607, 220607, 220607, 220607, 220603, 220602, 220603, 220602, 220607, 220607, 220607, 220607, 220595, 220594, 220595, 220594, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 228863, 228863, 228863, 228863, 228859, 228859, 228859, 228859, 228863, 228863, 228863, 228863, 228851, 228851, 228851, 228851, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 220479, 220479, 220479, 220479, 220475, 220474, 220475, 220474, 220479, 220479, 220479, 220479, 220467, 220466, 220467, 220466, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203967, 203967, 203967, 203967, 203963, 203962, 203961, 203960, 203967, 203967, 203967, 203967, 203955, 203954, 203953, 203952, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 203935, 203935, 203935, 203935, 203931, 203930, 203929, 203928, 203935, 203935, 203935, 203935, 203923, 203922, 203921, 203920, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 212223, 212223, 212223, 212223, 212219, 212219, 212217, 212217, 212223, 212223, 212223, 212223, 212211, 212211, 212209, 212209, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203839, 203839, 203839, 203839, 203835, 203834, 203833, 203832, 203839, 203839, 203839, 203839, 203827, 203826, 203825, 203824, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 203807, 203807, 203807, 203807, 203803, 203802, 203801, 203800, 203807, 203807, 203807, 203807, 203795, 203794, 203793, 203792, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 66751, 66751, 66751, 66751, 66747, 66746, 66745, 66744, 66751, 66751, 66751, 66751, 66739, 66738, 66737, 66736, 66751, 66751, 66751, 66751, 66731, 66730, 66729, 66728, 66751, 66751, 66751, 66751, 66723, 66722, 66721, 66720, 66719, 66719, 66719, 66719, 66715, 66714, 66713, 66712, 66719, 66719, 66719, 66719, 66707, 66706, 66705, 66704, 66719, 66719, 66719, 66719, 66699, 66698, 66697, 66696, 66719, 66719, 66719, 66719, 66691, 66690, 66689, 66688, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 75007, 75007, 75007, 75007, 75003, 75003, 75001, 75001, 75007, 75007, 75007, 75007, 74995, 74995, 74993, 74993, 75007, 75007, 75007, 75007, 74987, 74987, 74985, 74985, 75007, 75007, 75007, 75007, 74979, 74979, 74977, 74977, 66623, 66623, 66623, 66623, 66619, 66618, 66617, 66616, 66623, 66623, 66623, 66623, 66611, 66610, 66609, 66608, 66623, 66623, 66623, 66623, 66603, 66602, 66601, 66600, 66623, 66623, 66623, 66623, 66595, 66594, 66593, 66592, 66591, 66591, 66591, 66591, 66587, 66586, 66585, 66584, 66591, 66591, 66591, 66591, 66579, 66578, 66577, 66576, 66591, 66591, 66591, 66591, 66571, 66570, 66569, 66568, 66591, 66591, 66591, 66591, 66563, 66562, 66561, 66560, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 83391, 83391, 83391, 83391, 83387, 83386, 83387, 83386, 83391, 83391, 83391, 83391, 83379, 83378, 83379, 83378, 83391, 83391, 83391, 83391, 83371, 83370, 83371, 83370, 83391, 83391, 83391, 83391, 83363, 83362, 83363, 83362, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 91647, 91647, 91647, 91647, 91643, 91643, 91643, 91643, 91647, 91647, 91647, 91647, 91635, 91635, 91635, 91635, 91647, 91647, 91647, 91647, 91627, 91627, 91627, 91627, 91647, 91647, 91647, 91647, 91619, 91619, 91619, 91619, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 83263, 83263, 83263, 83263, 83259, 83258, 83259, 83258, 83263, 83263, 83263, 83263, 83251, 83250, 83251, 83250, 83263, 83263, 83263, 83263, 83243, 83242, 83243, 83242, 83263, 83263, 83263, 83263, 83235, 83234, 83235, 83234, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 65727, 65727, 65727, 65727, 65723, 65722, 65721, 65720, 65727, 65727, 65727, 65727, 65715, 65714, 65713, 65712, 65727, 65727, 65727, 65727, 65707, 65706, 65705, 65704, 65727, 65727, 65727, 65727, 65699, 65698, 65697, 65696, 65695, 65695, 65695, 65695, 65691, 65690, 65689, 65688, 65695, 65695, 65695, 65695, 65683, 65682, 65681, 65680, 65695, 65695, 65695, 65695, 65675, 65674, 65673, 65672, 65695, 65695, 65695, 65695, 65667, 65666, 65665, 65664, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 73983, 73983, 73983, 73983, 73979, 73979, 73977, 73977, 73983, 73983, 73983, 73983, 73971, 73971, 73969, 73969, 73983, 73983, 73983, 73983, 73963, 73963, 73961, 73961, 73983, 73983, 73983, 73983, 73955, 73955, 73953, 73953, 65599, 65599, 65599, 65599, 65595, 65594, 65593, 65592, 65599, 65599, 65599, 65599, 65587, 65586, 65585, 65584, 65599, 65599, 65599, 65599, 65579, 65578, 65577, 65576, 65599, 65599, 65599, 65599, 65571, 65570, 65569, 65568, 65567, 65567, 65567, 65567, 65563, 65562, 65561, 65560, 65567, 65567, 65567, 65567, 65555, 65554, 65553, 65552, 65567, 65567, 65567, 65567, 65547, 65546, 65545, 65544, 65567, 65567, 65567, 65567, 65539, 65538, 65537, 65536, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259263, 259263, 259263, 259263, 259259, 259258, 259257, 259256, 259263, 259263, 259263, 259263, 259251, 259250, 259249, 259248, 259263, 259263, 259263, 259263, 259243, 259242, 259241, 259240, 259263, 259263, 259263, 259263, 259235, 259234, 259233, 259232, 259231, 259231, 259231, 259231, 259227, 259226, 259225, 259224, 259231, 259231, 259231, 259231, 259219, 259218, 259217, 259216, 259231, 259231, 259231, 259231, 259211, 259210, 259209, 259208, 259231, 259231, 259231, 259231, 259203, 259202, 259201, 259200, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259327, 259327, 259327, 259327, 259323, 259323, 259321, 259321, 259327, 259327, 259327, 259327, 259315, 259315, 259313, 259313, 259327, 259327, 259327, 259327, 259307, 259307, 259305, 259305, 259327, 259327, 259327, 259327, 259299, 259299, 259297, 259297, 259135, 259135, 259135, 259135, 259131, 259130, 259129, 259128, 259135, 259135, 259135, 259135, 259123, 259122, 259121, 259120, 259135, 259135, 259135, 259135, 259115, 259114, 259113, 259112, 259135, 259135, 259135, 259135, 259107, 259106, 259105, 259104, 259103, 259103, 259103, 259103, 259099, 259098, 259097, 259096, 259103, 259103, 259103, 259103, 259091, 259090, 259089, 259088, 259103, 259103, 259103, 259103, 259083, 259082, 259081, 259080, 259103, 259103, 259103, 259103, 259075, 259074, 259073, 259072, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259519, 259519, 259519, 259519, 259515, 259514, 259515, 259514, 259519, 259519, 259519, 259519, 259507, 259506, 259507, 259506, 259519, 259519, 259519, 259519, 259499, 259498, 259499, 259498, 259519, 259519, 259519, 259519, 259491, 259490, 259491, 259490, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259583, 259583, 259583, 259583, 259579, 259579, 259579, 259579, 259583, 259583, 259583, 259583, 259571, 259571, 259571, 259571, 259583, 259583, 259583, 259583, 259563, 259563, 259563, 259563, 259583, 259583, 259583, 259583, 259555, 259555, 259555, 259555, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 259391, 259391, 259391, 259391, 259387, 259386, 259387, 259386, 259391, 259391, 259391, 259391, 259379, 259378, 259379, 259378, 259391, 259391, 259391, 259391, 259371, 259370, 259371, 259370, 259391, 259391, 259391, 259391, 259363, 259362, 259363, 259362, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258239, 258239, 258239, 258239, 258235, 258234, 258233, 258232, 258239, 258239, 258239, 258239, 258227, 258226, 258225, 258224, 258239, 258239, 258239, 258239, 258219, 258218, 258217, 258216, 258239, 258239, 258239, 258239, 258211, 258210, 258209, 258208, 258207, 258207, 258207, 258207, 258203, 258202, 258201, 258200, 258207, 258207, 258207, 258207, 258195, 258194, 258193, 258192, 258207, 258207, 258207, 258207, 258187, 258186, 258185, 258184, 258207, 258207, 258207, 258207, 258179, 258178, 258177, 258176, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258303, 258303, 258303, 258303, 258299, 258299, 258297, 258297, 258303, 258303, 258303, 258303, 258291, 258291, 258289, 258289, 258303, 258303, 258303, 258303, 258283, 258283, 258281, 258281, 258303, 258303, 258303, 258303, 258275, 258275, 258273, 258273, 258111, 258111, 258111, 258111, 258107, 258106, 258105, 258104, 258111, 258111, 258111, 258111, 258099, 258098, 258097, 258096, 258111, 258111, 258111, 258111, 258091, 258090, 258089, 258088, 258111, 258111, 258111, 258111, 258083, 258082, 258081, 258080, 258079, 258079, 258079, 258079, 258075, 258074, 258073, 258072, 258079, 258079, 258079, 258079, 258067, 258066, 258065, 258064, 258079, 258079, 258079, 258079, 258059, 258058, 258057, 258056, 258079, 258079, 258079, 258079, 258051, 258050, 258049, 258048, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262143, 262143, 262143, 262143, 262139, 262139, 262139, 262139, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 262079, 262079, 262079, 262079, 262075, 262074, 262075, 262074, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261887, 261887, 261887, 261887, 261883, 261883, 261881, 261881, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261823, 261823, 261823, 261823, 261819, 261818, 261817, 261816, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261791, 261791, 261791, 261791, 261787, 261786, 261785, 261784, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261567, 261567, 261567, 261567, 261563, 261562, 261563, 261562, 261567, 261567, 261567, 261567, 261555, 261554, 261555, 261554, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261631, 261631, 261631, 261631, 261627, 261627, 261627, 261627, 261631, 261631, 261631, 261631, 261619, 261619, 261619, 261619, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261439, 261439, 261439, 261439, 261435, 261434, 261435, 261434, 261439, 261439, 261439, 261439, 261427, 261426, 261427, 261426, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261311, 261311, 261311, 261311, 261307, 261306, 261305, 261304, 261311, 261311, 261311, 261311, 261299, 261298, 261297, 261296, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261279, 261279, 261279, 261279, 261275, 261274, 261273, 261272, 261279, 261279, 261279, 261279, 261267, 261266, 261265, 261264, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261375, 261375, 261375, 261375, 261371, 261371, 261369, 261369, 261375, 261375, 261375, 261375, 261363, 261363, 261361, 261361, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261183, 261183, 261183, 261183, 261179, 261178, 261177, 261176, 261183, 261183, 261183, 261183, 261171, 261170, 261169, 261168, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 261151, 261151, 261151, 261151, 261147, 261146, 261145, 261144, 261151, 261151, 261151, 261151, 261139, 261138, 261137, 261136, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259835, 259835, 259833, 259833, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259839, 259839, 259839, 259839, 259819, 259819, 259817, 259817, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259771, 259770, 259769, 259768, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259775, 259775, 259775, 259775, 259755, 259754, 259753, 259752, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259739, 259738, 259737, 259736, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 259743, 259743, 259743, 259743, 259723, 259722, 259721, 259720, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255167, 255167, 255167, 255167, 255163, 255162, 255161, 255160, 255167, 255167, 255167, 255167, 255155, 255154, 255153, 255152, 255167, 255167, 255167, 255167, 255147, 255146, 255145, 255144, 255167, 255167, 255167, 255167, 255139, 255138, 255137, 255136, 255135, 255135, 255135, 255135, 255131, 255130, 255129, 255128, 255135, 255135, 255135, 255135, 255123, 255122, 255121, 255120, 255135, 255135, 255135, 255135, 255115, 255114, 255113, 255112, 255135, 255135, 255135, 255135, 255107, 255106, 255105, 255104, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255231, 255231, 255231, 255231, 255227, 255227, 255225, 255225, 255231, 255231, 255231, 255231, 255219, 255219, 255217, 255217, 255231, 255231, 255231, 255231, 255211, 255211, 255209, 255209, 255231, 255231, 255231, 255231, 255203, 255203, 255201, 255201, 255039, 255039, 255039, 255039, 255035, 255034, 255033, 255032, 255039, 255039, 255039, 255039, 255027, 255026, 255025, 255024, 255039, 255039, 255039, 255039, 255019, 255018, 255017, 255016, 255039, 255039, 255039, 255039, 255011, 255010, 255009, 255008, 255007, 255007, 255007, 255007, 255003, 255002, 255001, 255000, 255007, 255007, 255007, 255007, 254995, 254994, 254993, 254992, 255007, 255007, 255007, 255007, 254987, 254986, 254985, 254984, 255007, 255007, 255007, 255007, 254979, 254978, 254977, 254976, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260091, 260091, 260091, 260091, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260095, 260095, 260095, 260095, 260075, 260075, 260075, 260075, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260027, 260026, 260027, 260026, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 260031, 260031, 260031, 260031, 260011, 260010, 260011, 260010, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258811, 258811, 258809, 258809, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258815, 258815, 258815, 258815, 258795, 258795, 258793, 258793, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258747, 258746, 258745, 258744, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258751, 258751, 258751, 258751, 258731, 258730, 258729, 258728, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258715, 258714, 258713, 258712, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 258719, 258719, 258719, 258719, 258699, 258698, 258697, 258696, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255423, 255423, 255423, 255423, 255419, 255418, 255419, 255418, 255423, 255423, 255423, 255423, 255411, 255410, 255411, 255410, 255423, 255423, 255423, 255423, 255403, 255402, 255403, 255402, 255423, 255423, 255423, 255423, 255395, 255394, 255395, 255394, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255487, 255487, 255487, 255487, 255483, 255483, 255483, 255483, 255487, 255487, 255487, 255487, 255475, 255475, 255475, 255475, 255487, 255487, 255487, 255487, 255467, 255467, 255467, 255467, 255487, 255487, 255487, 255487, 255459, 255459, 255459, 255459, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 255295, 255295, 255295, 255295, 255291, 255290, 255291, 255290, 255295, 255295, 255295, 255295, 255283, 255282, 255283, 255282, 255295, 255295, 255295, 255295, 255275, 255274, 255275, 255274, 255295, 255295, 255295, 255295, 255267, 255266, 255267, 255266, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254143, 254143, 254143, 254143, 254139, 254138, 254137, 254136, 254143, 254143, 254143, 254143, 254131, 254130, 254129, 254128, 254143, 254143, 254143, 254143, 254123, 254122, 254121, 254120, 254143, 254143, 254143, 254143, 254115, 254114, 254113, 254112, 254111, 254111, 254111, 254111, 254107, 254106, 254105, 254104, 254111, 254111, 254111, 254111, 254099, 254098, 254097, 254096, 254111, 254111, 254111, 254111, 254091, 254090, 254089, 254088, 254111, 254111, 254111, 254111, 254083, 254082, 254081, 254080, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254207, 254207, 254207, 254207, 254203, 254203, 254201, 254201, 254207, 254207, 254207, 254207, 254195, 254195, 254193, 254193, 254207, 254207, 254207, 254207, 254187, 254187, 254185, 254185, 254207, 254207, 254207, 254207, 254179, 254179, 254177, 254177, 254015, 254015, 254015, 254015, 254011, 254010, 254009, 254008, 254015, 254015, 254015, 254015, 254003, 254002, 254001, 254000, 254015, 254015, 254015, 254015, 253995, 253994, 253993, 253992, 254015, 254015, 254015, 254015, 253987, 253986, 253985, 253984, 253983, 253983, 253983, 253983, 253979, 253978, 253977, 253976, 253983, 253983, 253983, 253983, 253971, 253970, 253969, 253968, 253983, 253983, 253983, 253983, 253963, 253962, 253961, 253960, 253983, 253983, 253983, 253983, 253955, 253954, 253953, 253952, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 29887, 29887, 29887, 29887, 29883, 29882, 29881, 29880, 29887, 29887, 29887, 29887, 29875, 29874, 29873, 29872, 29887, 29887, 29887, 29887, 29867, 29866, 29865, 29864, 29887, 29887, 29887, 29887, 29859, 29858, 29857, 29856, 29855, 29855, 29855, 29855, 29851, 29850, 29849, 29848, 29855, 29855, 29855, 29855, 29843, 29842, 29841, 29840, 29855, 29855, 29855, 29855, 29835, 29834, 29833, 29832, 29855, 29855, 29855, 29855, 29827, 29826, 29825, 29824, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 29759, 29759, 29759, 29759, 29755, 29754, 29753, 29752, 29759, 29759, 29759, 29759, 29747, 29746, 29745, 29744, 29759, 29759, 29759, 29759, 29739, 29738, 29737, 29736, 29759, 29759, 29759, 29759, 29731, 29730, 29729, 29728, 29727, 29727, 29727, 29727, 29723, 29722, 29721, 29720, 29727, 29727, 29727, 29727, 29715, 29714, 29713, 29712, 29727, 29727, 29727, 29727, 29707, 29706, 29705, 29704, 29727, 29727, 29727, 29727, 29699, 29698, 29697, 29696, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 28863, 28863, 28863, 28863, 28859, 28858, 28857, 28856, 28863, 28863, 28863, 28863, 28851, 28850, 28849, 28848, 28863, 28863, 28863, 28863, 28843, 28842, 28841, 28840, 28863, 28863, 28863, 28863, 28835, 28834, 28833, 28832, 28831, 28831, 28831, 28831, 28827, 28826, 28825, 28824, 28831, 28831, 28831, 28831, 28819, 28818, 28817, 28816, 28831, 28831, 28831, 28831, 28811, 28810, 28809, 28808, 28831, 28831, 28831, 28831, 28803, 28802, 28801, 28800, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 28735, 28735, 28735, 28735, 28731, 28730, 28729, 28728, 28735, 28735, 28735, 28735, 28723, 28722, 28721, 28720, 28735, 28735, 28735, 28735, 28715, 28714, 28713, 28712, 28735, 28735, 28735, 28735, 28707, 28706, 28705, 28704, 28703, 28703, 28703, 28703, 28699, 28698, 28697, 28696, 28703, 28703, 28703, 28703, 28691, 28690, 28689, 28688, 28703, 28703, 28703, 28703, 28683, 28682, 28681, 28680, 28703, 28703, 28703, 28703, 28675, 28674, 28673, 28672, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229055, 229055, 229055, 229055, 229051, 229050, 229049, 229048, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 229023, 229023, 229023, 229023, 229019, 229018, 229017, 229016, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 163007, 163007, 163007, 163007, 163003, 163002, 163001, 163000, 163007, 163007, 163007, 163007, 162995, 162994, 162993, 162992, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 162975, 162975, 162975, 162975, 162971, 162970, 162969, 162968, 162975, 162975, 162975, 162975, 162963, 162962, 162961, 162960, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162879, 162879, 162879, 162879, 162875, 162874, 162873, 162872, 162879, 162879, 162879, 162879, 162867, 162866, 162865, 162864, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 162847, 162847, 162847, 162847, 162843, 162842, 162841, 162840, 162847, 162847, 162847, 162847, 162835, 162834, 162833, 162832, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95931, 95930, 95929, 95928, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95935, 95935, 95935, 95935, 95915, 95914, 95913, 95912, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95899, 95898, 95897, 95896, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 95903, 95903, 95903, 95903, 95883, 95882, 95881, 95880, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 25791, 25791, 25791, 25791, 25787, 25786, 25785, 25784, 25791, 25791, 25791, 25791, 25779, 25778, 25777, 25776, 25791, 25791, 25791, 25791, 25771, 25770, 25769, 25768, 25791, 25791, 25791, 25791, 25763, 25762, 25761, 25760, 25759, 25759, 25759, 25759, 25755, 25754, 25753, 25752, 25759, 25759, 25759, 25759, 25747, 25746, 25745, 25744, 25759, 25759, 25759, 25759, 25739, 25738, 25737, 25736, 25759, 25759, 25759, 25759, 25731, 25730, 25729, 25728, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 25663, 25663, 25663, 25663, 25659, 25658, 25657, 25656, 25663, 25663, 25663, 25663, 25651, 25650, 25649, 25648, 25663, 25663, 25663, 25663, 25643, 25642, 25641, 25640, 25663, 25663, 25663, 25663, 25635, 25634, 25633, 25632, 25631, 25631, 25631, 25631, 25627, 25626, 25625, 25624, 25631, 25631, 25631, 25631, 25619, 25618, 25617, 25616, 25631, 25631, 25631, 25631, 25611, 25610, 25609, 25608, 25631, 25631, 25631, 25631, 25603, 25602, 25601, 25600, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94907, 94906, 94905, 94904, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94911, 94911, 94911, 94911, 94891, 94890, 94889, 94888, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94875, 94874, 94873, 94872, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 94879, 94879, 94879, 94879, 94859, 94858, 94857, 94856, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 24767, 24767, 24767, 24767, 24763, 24762, 24761, 24760, 24767, 24767, 24767, 24767, 24755, 24754, 24753, 24752, 24767, 24767, 24767, 24767, 24747, 24746, 24745, 24744, 24767, 24767, 24767, 24767, 24739, 24738, 24737, 24736, 24735, 24735, 24735, 24735, 24731, 24730, 24729, 24728, 24735, 24735, 24735, 24735, 24723, 24722, 24721, 24720, 24735, 24735, 24735, 24735, 24715, 24714, 24713, 24712, 24735, 24735, 24735, 24735, 24707, 24706, 24705, 24704, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 24639, 24639, 24639, 24639, 24635, 24634, 24633, 24632, 24639, 24639, 24639, 24639, 24627, 24626, 24625, 24624, 24639, 24639, 24639, 24639, 24619, 24618, 24617, 24616, 24639, 24639, 24639, 24639, 24611, 24610, 24609, 24608, 24607, 24607, 24607, 24607, 24603, 24602, 24601, 24600, 24607, 24607, 24607, 24607, 24595, 24594, 24593, 24592, 24607, 24607, 24607, 24607, 24587, 24586, 24585, 24584, 24607, 24607, 24607, 24607, 24579, 24578, 24577, 24576, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 21695, 21695, 21695, 21695, 21691, 21690, 21689, 21688, 21695, 21695, 21695, 21695, 21683, 21682, 21681, 21680, 21695, 21695, 21695, 21695, 21675, 21674, 21673, 21672, 21695, 21695, 21695, 21695, 21667, 21666, 21665, 21664, 21663, 21663, 21663, 21663, 21659, 21658, 21657, 21656, 21663, 21663, 21663, 21663, 21651, 21650, 21649, 21648, 21663, 21663, 21663, 21663, 21643, 21642, 21641, 21640, 21663, 21663, 21663, 21663, 21635, 21634, 21633, 21632, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 29951, 29951, 29951, 29951, 29947, 29947, 29945, 29945, 29951, 29951, 29951, 29951, 29939, 29939, 29937, 29937, 29951, 29951, 29951, 29951, 29931, 29931, 29929, 29929, 29951, 29951, 29951, 29951, 29923, 29923, 29921, 29921, 21567, 21567, 21567, 21567, 21563, 21562, 21561, 21560, 21567, 21567, 21567, 21567, 21555, 21554, 21553, 21552, 21567, 21567, 21567, 21567, 21547, 21546, 21545, 21544, 21567, 21567, 21567, 21567, 21539, 21538, 21537, 21536, 21535, 21535, 21535, 21535, 21531, 21530, 21529, 21528, 21535, 21535, 21535, 21535, 21523, 21522, 21521, 21520, 21535, 21535, 21535, 21535, 21515, 21514, 21513, 21512, 21535, 21535, 21535, 21535, 21507, 21506, 21505, 21504, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 20671, 20671, 20671, 20671, 20667, 20666, 20665, 20664, 20671, 20671, 20671, 20671, 20659, 20658, 20657, 20656, 20671, 20671, 20671, 20671, 20651, 20650, 20649, 20648, 20671, 20671, 20671, 20671, 20643, 20642, 20641, 20640, 20639, 20639, 20639, 20639, 20635, 20634, 20633, 20632, 20639, 20639, 20639, 20639, 20627, 20626, 20625, 20624, 20639, 20639, 20639, 20639, 20619, 20618, 20617, 20616, 20639, 20639, 20639, 20639, 20611, 20610, 20609, 20608, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 28927, 28927, 28927, 28927, 28923, 28923, 28921, 28921, 28927, 28927, 28927, 28927, 28915, 28915, 28913, 28913, 28927, 28927, 28927, 28927, 28907, 28907, 28905, 28905, 28927, 28927, 28927, 28927, 28899, 28899, 28897, 28897, 20543, 20543, 20543, 20543, 20539, 20538, 20537, 20536, 20543, 20543, 20543, 20543, 20531, 20530, 20529, 20528, 20543, 20543, 20543, 20543, 20523, 20522, 20521, 20520, 20543, 20543, 20543, 20543, 20515, 20514, 20513, 20512, 20511, 20511, 20511, 20511, 20507, 20506, 20505, 20504, 20511, 20511, 20511, 20511, 20499, 20498, 20497, 20496, 20511, 20511, 20511, 20511, 20491, 20490, 20489, 20488, 20511, 20511, 20511, 20511, 20483, 20482, 20481, 20480, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 229119, 229119, 229119, 229119, 229115, 229115, 229113, 229113, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220863, 220863, 220863, 220863, 220859, 220858, 220857, 220856, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 220831, 220831, 220831, 220831, 220827, 220826, 220825, 220824, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154815, 154815, 154815, 154815, 154811, 154810, 154809, 154808, 154815, 154815, 154815, 154815, 154803, 154802, 154801, 154800, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 154783, 154783, 154783, 154783, 154779, 154778, 154777, 154776, 154783, 154783, 154783, 154783, 154771, 154770, 154769, 154768, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 163071, 163071, 163071, 163071, 163067, 163067, 163065, 163065, 163071, 163071, 163071, 163071, 163059, 163059, 163057, 163057, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154687, 154687, 154687, 154687, 154683, 154682, 154681, 154680, 154687, 154687, 154687, 154687, 154675, 154674, 154673, 154672, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 154655, 154655, 154655, 154655, 154651, 154650, 154649, 154648, 154655, 154655, 154655, 154655, 154643, 154642, 154641, 154640, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95995, 95995, 95993, 95993, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 95999, 95999, 95999, 95999, 95979, 95979, 95977, 95977, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87739, 87738, 87737, 87736, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87743, 87743, 87743, 87743, 87723, 87722, 87721, 87720, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87707, 87706, 87705, 87704, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 87711, 87711, 87711, 87711, 87691, 87690, 87689, 87688, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 17599, 17599, 17599, 17599, 17595, 17594, 17593, 17592, 17599, 17599, 17599, 17599, 17587, 17586, 17585, 17584, 17599, 17599, 17599, 17599, 17579, 17578, 17577, 17576, 17599, 17599, 17599, 17599, 17571, 17570, 17569, 17568, 17567, 17567, 17567, 17567, 17563, 17562, 17561, 17560, 17567, 17567, 17567, 17567, 17555, 17554, 17553, 17552, 17567, 17567, 17567, 17567, 17547, 17546, 17545, 17544, 17567, 17567, 17567, 17567, 17539, 17538, 17537, 17536, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 25855, 25855, 25855, 25855, 25851, 25851, 25849, 25849, 25855, 25855, 25855, 25855, 25843, 25843, 25841, 25841, 25855, 25855, 25855, 25855, 25835, 25835, 25833, 25833, 25855, 25855, 25855, 25855, 25827, 25827, 25825, 25825, 17471, 17471, 17471, 17471, 17467, 17466, 17465, 17464, 17471, 17471, 17471, 17471, 17459, 17458, 17457, 17456, 17471, 17471, 17471, 17471, 17451, 17450, 17449, 17448, 17471, 17471, 17471, 17471, 17443, 17442, 17441, 17440, 17439, 17439, 17439, 17439, 17435, 17434, 17433, 17432, 17439, 17439, 17439, 17439, 17427, 17426, 17425, 17424, 17439, 17439, 17439, 17439, 17419, 17418, 17417, 17416, 17439, 17439, 17439, 17439, 17411, 17410, 17409, 17408, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94971, 94971, 94969, 94969, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 94975, 94975, 94975, 94975, 94955, 94955, 94953, 94953, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86715, 86714, 86713, 86712, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86719, 86719, 86719, 86719, 86699, 86698, 86697, 86696, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86683, 86682, 86681, 86680, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 86687, 86687, 86687, 86687, 86667, 86666, 86665, 86664, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 16575, 16575, 16575, 16575, 16571, 16570, 16569, 16568, 16575, 16575, 16575, 16575, 16563, 16562, 16561, 16560, 16575, 16575, 16575, 16575, 16555, 16554, 16553, 16552, 16575, 16575, 16575, 16575, 16547, 16546, 16545, 16544, 16543, 16543, 16543, 16543, 16539, 16538, 16537, 16536, 16543, 16543, 16543, 16543, 16531, 16530, 16529, 16528, 16543, 16543, 16543, 16543, 16523, 16522, 16521, 16520, 16543, 16543, 16543, 16543, 16515, 16514, 16513, 16512, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 24831, 24831, 24831, 24831, 24827, 24827, 24825, 24825, 24831, 24831, 24831, 24831, 24819, 24819, 24817, 24817, 24831, 24831, 24831, 24831, 24811, 24811, 24809, 24809, 24831, 24831, 24831, 24831, 24803, 24803, 24801, 24801, 16447, 16447, 16447, 16447, 16443, 16442, 16441, 16440, 16447, 16447, 16447, 16447, 16435, 16434, 16433, 16432, 16447, 16447, 16447, 16447, 16427, 16426, 16425, 16424, 16447, 16447, 16447, 16447, 16419, 16418, 16417, 16416, 16415, 16415, 16415, 16415, 16411, 16410, 16409, 16408, 16415, 16415, 16415, 16415, 16403, 16402, 16401, 16400, 16415, 16415, 16415, 16415, 16395, 16394, 16393, 16392, 16415, 16415, 16415, 16415, 16387, 16386, 16385, 16384, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 13503, 13503, 13503, 13503, 13499, 13498, 13497, 13496, 13503, 13503, 13503, 13503, 13491, 13490, 13489, 13488, 13503, 13503, 13503, 13503, 13483, 13482, 13481, 13480, 13503, 13503, 13503, 13503, 13475, 13474, 13473, 13472, 13471, 13471, 13471, 13471, 13467, 13466, 13465, 13464, 13471, 13471, 13471, 13471, 13459, 13458, 13457, 13456, 13471, 13471, 13471, 13471, 13451, 13450, 13449, 13448, 13471, 13471, 13471, 13471, 13443, 13442, 13441, 13440, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 13375, 13375, 13375, 13375, 13371, 13370, 13369, 13368, 13375, 13375, 13375, 13375, 13363, 13362, 13361, 13360, 13375, 13375, 13375, 13375, 13355, 13354, 13353, 13352, 13375, 13375, 13375, 13375, 13347, 13346, 13345, 13344, 13343, 13343, 13343, 13343, 13339, 13338, 13337, 13336, 13343, 13343, 13343, 13343, 13331, 13330, 13329, 13328, 13343, 13343, 13343, 13343, 13323, 13322, 13321, 13320, 13343, 13343, 13343, 13343, 13315, 13314, 13313, 13312, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30143, 30143, 30143, 30143, 30139, 30138, 30139, 30138, 30143, 30143, 30143, 30143, 30131, 30130, 30131, 30130, 30143, 30143, 30143, 30143, 30123, 30122, 30123, 30122, 30143, 30143, 30143, 30143, 30115, 30114, 30115, 30114, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 30015, 30015, 30015, 30015, 30011, 30010, 30011, 30010, 30015, 30015, 30015, 30015, 30003, 30002, 30003, 30002, 30015, 30015, 30015, 30015, 29995, 29994, 29995, 29994, 30015, 30015, 30015, 30015, 29987, 29986, 29987, 29986, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 12479, 12479, 12479, 12479, 12475, 12474, 12473, 12472, 12479, 12479, 12479, 12479, 12467, 12466, 12465, 12464, 12479, 12479, 12479, 12479, 12459, 12458, 12457, 12456, 12479, 12479, 12479, 12479, 12451, 12450, 12449, 12448, 12447, 12447, 12447, 12447, 12443, 12442, 12441, 12440, 12447, 12447, 12447, 12447, 12435, 12434, 12433, 12432, 12447, 12447, 12447, 12447, 12427, 12426, 12425, 12424, 12447, 12447, 12447, 12447, 12419, 12418, 12417, 12416, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 12351, 12351, 12351, 12351, 12347, 12346, 12345, 12344, 12351, 12351, 12351, 12351, 12339, 12338, 12337, 12336, 12351, 12351, 12351, 12351, 12331, 12330, 12329, 12328, 12351, 12351, 12351, 12351, 12323, 12322, 12321, 12320, 12319, 12319, 12319, 12319, 12315, 12314, 12313, 12312, 12319, 12319, 12319, 12319, 12307, 12306, 12305, 12304, 12319, 12319, 12319, 12319, 12299, 12298, 12297, 12296, 12319, 12319, 12319, 12319, 12291, 12290, 12289, 12288, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 229311, 229311, 229311, 229311, 229307, 229306, 229307, 229306, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212671, 212671, 212671, 212671, 212667, 212666, 212665, 212664, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 212639, 212639, 212639, 212639, 212635, 212634, 212633, 212632, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163263, 163263, 163263, 163263, 163259, 163258, 163259, 163258, 163263, 163263, 163263, 163263, 163251, 163250, 163251, 163250, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 163135, 163135, 163135, 163135, 163131, 163130, 163131, 163130, 163135, 163135, 163135, 163135, 163123, 163122, 163123, 163122, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146623, 146623, 146623, 146623, 146619, 146618, 146617, 146616, 146623, 146623, 146623, 146623, 146611, 146610, 146609, 146608, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146591, 146591, 146591, 146591, 146587, 146586, 146585, 146584, 146591, 146591, 146591, 146591, 146579, 146578, 146577, 146576, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146495, 146495, 146495, 146495, 146491, 146490, 146489, 146488, 146495, 146495, 146495, 146495, 146483, 146482, 146481, 146480, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 146463, 146463, 146463, 146463, 146459, 146458, 146457, 146456, 146463, 146463, 146463, 146463, 146451, 146450, 146449, 146448, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79547, 79546, 79545, 79544, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79551, 79551, 79551, 79551, 79531, 79530, 79529, 79528, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79515, 79514, 79513, 79512, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 79519, 79519, 79519, 79519, 79499, 79498, 79497, 79496, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 9407, 9407, 9407, 9407, 9403, 9402, 9401, 9400, 9407, 9407, 9407, 9407, 9395, 9394, 9393, 9392, 9407, 9407, 9407, 9407, 9387, 9386, 9385, 9384, 9407, 9407, 9407, 9407, 9379, 9378, 9377, 9376, 9375, 9375, 9375, 9375, 9371, 9370, 9369, 9368, 9375, 9375, 9375, 9375, 9363, 9362, 9361, 9360, 9375, 9375, 9375, 9375, 9355, 9354, 9353, 9352, 9375, 9375, 9375, 9375, 9347, 9346, 9345, 9344, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 9279, 9279, 9279, 9279, 9275, 9274, 9273, 9272, 9279, 9279, 9279, 9279, 9267, 9266, 9265, 9264, 9279, 9279, 9279, 9279, 9259, 9258, 9257, 9256, 9279, 9279, 9279, 9279, 9251, 9250, 9249, 9248, 9247, 9247, 9247, 9247, 9243, 9242, 9241, 9240, 9247, 9247, 9247, 9247, 9235, 9234, 9233, 9232, 9247, 9247, 9247, 9247, 9227, 9226, 9225, 9224, 9247, 9247, 9247, 9247, 9219, 9218, 9217, 9216, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96187, 96186, 96187, 96186, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 96191, 96191, 96191, 96191, 96171, 96170, 96171, 96170, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78523, 78522, 78521, 78520, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78527, 78527, 78527, 78527, 78507, 78506, 78505, 78504, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78491, 78490, 78489, 78488, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 78495, 78495, 78495, 78495, 78475, 78474, 78473, 78472, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26047, 26047, 26047, 26047, 26043, 26042, 26043, 26042, 26047, 26047, 26047, 26047, 26035, 26034, 26035, 26034, 26047, 26047, 26047, 26047, 26027, 26026, 26027, 26026, 26047, 26047, 26047, 26047, 26019, 26018, 26019, 26018, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 25919, 25919, 25919, 25919, 25915, 25914, 25915, 25914, 25919, 25919, 25919, 25919, 25907, 25906, 25907, 25906, 25919, 25919, 25919, 25919, 25899, 25898, 25899, 25898, 25919, 25919, 25919, 25919, 25891, 25890, 25891, 25890, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 8383, 8383, 8383, 8383, 8379, 8378, 8377, 8376, 8383, 8383, 8383, 8383, 8371, 8370, 8369, 8368, 8383, 8383, 8383, 8383, 8363, 8362, 8361, 8360, 8383, 8383, 8383, 8383, 8355, 8354, 8353, 8352, 8351, 8351, 8351, 8351, 8347, 8346, 8345, 8344, 8351, 8351, 8351, 8351, 8339, 8338, 8337, 8336, 8351, 8351, 8351, 8351, 8331, 8330, 8329, 8328, 8351, 8351, 8351, 8351, 8323, 8322, 8321, 8320, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 8255, 8255, 8255, 8255, 8251, 8250, 8249, 8248, 8255, 8255, 8255, 8255, 8243, 8242, 8241, 8240, 8255, 8255, 8255, 8255, 8235, 8234, 8233, 8232, 8255, 8255, 8255, 8255, 8227, 8226, 8225, 8224, 8223, 8223, 8223, 8223, 8219, 8218, 8217, 8216, 8223, 8223, 8223, 8223, 8211, 8210, 8209, 8208, 8223, 8223, 8223, 8223, 8203, 8202, 8201, 8200, 8223, 8223, 8223, 8223, 8195, 8194, 8193, 8192, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 5311, 5311, 5311, 5311, 5307, 5306, 5305, 5304, 5311, 5311, 5311, 5311, 5299, 5298, 5297, 5296, 5311, 5311, 5311, 5311, 5291, 5290, 5289, 5288, 5311, 5311, 5311, 5311, 5283, 5282, 5281, 5280, 5279, 5279, 5279, 5279, 5275, 5274, 5273, 5272, 5279, 5279, 5279, 5279, 5267, 5266, 5265, 5264, 5279, 5279, 5279, 5279, 5259, 5258, 5257, 5256, 5279, 5279, 5279, 5279, 5251, 5250, 5249, 5248, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 13567, 13567, 13567, 13567, 13563, 13563, 13561, 13561, 13567, 13567, 13567, 13567, 13555, 13555, 13553, 13553, 13567, 13567, 13567, 13567, 13547, 13547, 13545, 13545, 13567, 13567, 13567, 13567, 13539, 13539, 13537, 13537, 5183, 5183, 5183, 5183, 5179, 5178, 5177, 5176, 5183, 5183, 5183, 5183, 5171, 5170, 5169, 5168, 5183, 5183, 5183, 5183, 5163, 5162, 5161, 5160, 5183, 5183, 5183, 5183, 5155, 5154, 5153, 5152, 5151, 5151, 5151, 5151, 5147, 5146, 5145, 5144, 5151, 5151, 5151, 5151, 5139, 5138, 5137, 5136, 5151, 5151, 5151, 5151, 5131, 5130, 5129, 5128, 5151, 5151, 5151, 5151, 5123, 5122, 5121, 5120, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 21951, 21951, 21951, 21951, 21947, 21946, 21947, 21946, 21951, 21951, 21951, 21951, 21939, 21938, 21939, 21938, 21951, 21951, 21951, 21951, 21931, 21930, 21931, 21930, 21951, 21951, 21951, 21951, 21923, 21922, 21923, 21922, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 30207, 30207, 30207, 30207, 30203, 30203, 30203, 30203, 30207, 30207, 30207, 30207, 30195, 30195, 30195, 30195, 30207, 30207, 30207, 30207, 30187, 30187, 30187, 30187, 30207, 30207, 30207, 30207, 30179, 30179, 30179, 30179, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 21823, 21823, 21823, 21823, 21819, 21818, 21819, 21818, 21823, 21823, 21823, 21823, 21811, 21810, 21811, 21810, 21823, 21823, 21823, 21823, 21803, 21802, 21803, 21802, 21823, 21823, 21823, 21823, 21795, 21794, 21795, 21794, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 4287, 4287, 4287, 4287, 4283, 4282, 4281, 4280, 4287, 4287, 4287, 4287, 4275, 4274, 4273, 4272, 4287, 4287, 4287, 4287, 4267, 4266, 4265, 4264, 4287, 4287, 4287, 4287, 4259, 4258, 4257, 4256, 4255, 4255, 4255, 4255, 4251, 4250, 4249, 4248, 4255, 4255, 4255, 4255, 4243, 4242, 4241, 4240, 4255, 4255, 4255, 4255, 4235, 4234, 4233, 4232, 4255, 4255, 4255, 4255, 4227, 4226, 4225, 4224, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 12543, 12543, 12543, 12543, 12539, 12539, 12537, 12537, 12543, 12543, 12543, 12543, 12531, 12531, 12529, 12529, 12543, 12543, 12543, 12543, 12523, 12523, 12521, 12521, 12543, 12543, 12543, 12543, 12515, 12515, 12513, 12513, 4159, 4159, 4159, 4159, 4155, 4154, 4153, 4152, 4159, 4159, 4159, 4159, 4147, 4146, 4145, 4144, 4159, 4159, 4159, 4159, 4139, 4138, 4137, 4136, 4159, 4159, 4159, 4159, 4131, 4130, 4129, 4128, 4127, 4127, 4127, 4127, 4123, 4122, 4121, 4120, 4127, 4127, 4127, 4127, 4115, 4114, 4113, 4112, 4127, 4127, 4127, 4127, 4107, 4106, 4105, 4104, 4127, 4127, 4127, 4127, 4099, 4098, 4097, 4096, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 229375, 229375, 229375, 229375, 229371, 229371, 229371, 229371, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 221119, 221119, 221119, 221119, 221115, 221114, 221115, 221114, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 212735, 212735, 212735, 212735, 212731, 212731, 212729, 212729, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204479, 204479, 204479, 204479, 204475, 204474, 204473, 204472, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 204447, 204447, 204447, 204447, 204443, 204442, 204441, 204440, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 155071, 155071, 155071, 155071, 155067, 155066, 155067, 155066, 155071, 155071, 155071, 155071, 155059, 155058, 155059, 155058, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 163327, 163327, 163327, 163327, 163323, 163323, 163323, 163323, 163327, 163327, 163327, 163327, 163315, 163315, 163315, 163315, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 154943, 154943, 154943, 154943, 154939, 154938, 154939, 154938, 154943, 154943, 154943, 154943, 154931, 154930, 154931, 154930, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138431, 138431, 138431, 138431, 138427, 138426, 138425, 138424, 138431, 138431, 138431, 138431, 138419, 138418, 138417, 138416, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 138399, 138399, 138399, 138399, 138395, 138394, 138393, 138392, 138399, 138399, 138399, 138399, 138387, 138386, 138385, 138384, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 146687, 146687, 146687, 146687, 146683, 146683, 146681, 146681, 146687, 146687, 146687, 146687, 146675, 146675, 146673, 146673, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138303, 138303, 138303, 138303, 138299, 138298, 138297, 138296, 138303, 138303, 138303, 138303, 138291, 138290, 138289, 138288, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 138271, 138271, 138271, 138271, 138267, 138266, 138265, 138264, 138271, 138271, 138271, 138271, 138259, 138258, 138257, 138256, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79611, 79611, 79609, 79609, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 79615, 79615, 79615, 79615, 79595, 79595, 79593, 79593, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71355, 71354, 71353, 71352, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71359, 71359, 71359, 71359, 71339, 71338, 71337, 71336, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71323, 71322, 71321, 71320, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 71327, 71327, 71327, 71327, 71307, 71306, 71305, 71304, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 1215, 1215, 1215, 1215, 1211, 1210, 1209, 1208, 1215, 1215, 1215, 1215, 1203, 1202, 1201, 1200, 1215, 1215, 1215, 1215, 1195, 1194, 1193, 1192, 1215, 1215, 1215, 1215, 1187, 1186, 1185, 1184, 1183, 1183, 1183, 1183, 1179, 1178, 1177, 1176, 1183, 1183, 1183, 1183, 1171, 1170, 1169, 1168, 1183, 1183, 1183, 1183, 1163, 1162, 1161, 1160, 1183, 1183, 1183, 1183, 1155, 1154, 1153, 1152, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 9471, 9471, 9471, 9471, 9467, 9467, 9465, 9465, 9471, 9471, 9471, 9471, 9459, 9459, 9457, 9457, 9471, 9471, 9471, 9471, 9451, 9451, 9449, 9449, 9471, 9471, 9471, 9471, 9443, 9443, 9441, 9441, 1087, 1087, 1087, 1087, 1083, 1082, 1081, 1080, 1087, 1087, 1087, 1087, 1075, 1074, 1073, 1072, 1087, 1087, 1087, 1087, 1067, 1066, 1065, 1064, 1087, 1087, 1087, 1087, 1059, 1058, 1057, 1056, 1055, 1055, 1055, 1055, 1051, 1050, 1049, 1048, 1055, 1055, 1055, 1055, 1043, 1042, 1041, 1040, 1055, 1055, 1055, 1055, 1035, 1034, 1033, 1032, 1055, 1055, 1055, 1055, 1027, 1026, 1025, 1024, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96251, 96251, 96251, 96251, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 96255, 96255, 96255, 96255, 96235, 96235, 96235, 96235, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87995, 87994, 87995, 87994, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 87999, 87999, 87999, 87999, 87979, 87978, 87979, 87978, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78587, 78587, 78585, 78585, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 78591, 78591, 78591, 78591, 78571, 78571, 78569, 78569, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70331, 70330, 70329, 70328, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70335, 70335, 70335, 70335, 70315, 70314, 70313, 70312, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70299, 70298, 70297, 70296, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 70303, 70303, 70303, 70303, 70283, 70282, 70281, 70280, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 17855, 17855, 17855, 17855, 17851, 17850, 17851, 17850, 17855, 17855, 17855, 17855, 17843, 17842, 17843, 17842, 17855, 17855, 17855, 17855, 17835, 17834, 17835, 17834, 17855, 17855, 17855, 17855, 17827, 17826, 17827, 17826, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 26111, 26111, 26111, 26111, 26107, 26107, 26107, 26107, 26111, 26111, 26111, 26111, 26099, 26099, 26099, 26099, 26111, 26111, 26111, 26111, 26091, 26091, 26091, 26091, 26111, 26111, 26111, 26111, 26083, 26083, 26083, 26083, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 17727, 17727, 17727, 17727, 17723, 17722, 17723, 17722, 17727, 17727, 17727, 17727, 17715, 17714, 17715, 17714, 17727, 17727, 17727, 17727, 17707, 17706, 17707, 17706, 17727, 17727, 17727, 17727, 17699, 17698, 17699, 17698, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 191, 191, 191, 191, 187, 186, 185, 184, 191, 191, 191, 191, 179, 178, 177, 176, 191, 191, 191, 191, 171, 170, 169, 168, 191, 191, 191, 191, 163, 162, 161, 160, 159, 159, 159, 159, 155, 154, 153, 152, 159, 159, 159, 159, 147, 146, 145, 144, 159, 159, 159, 159, 139, 138, 137, 136, 159, 159, 159, 159, 131, 130, 129, 128, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 8447, 8447, 8447, 8447, 8443, 8443, 8441, 8441, 8447, 8447, 8447, 8447, 8435, 8435, 8433, 8433, 8447, 8447, 8447, 8447, 8427, 8427, 8425, 8425, 8447, 8447, 8447, 8447, 8419, 8419, 8417, 8417, 63, 63, 63, 63, 59, 58, 57, 56, 63, 63, 63, 63, 51, 50, 49, 48, 63, 63, 63, 63, 43, 42, 41, 40, 63, 63, 63, 63, 35, 34, 33, 32, 31, 31, 31, 31, 27, 26, 25, 24, 31, 31, 31, 31, 19, 18, 17, 16, 31, 31, 31, 31, 11, 10, 9, 8, 31, 31, 31, 31, 3, 2, 1, 0 }; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/vtkMarchingCubesCases.h0000755000175000017500000004537210150464521026443 0ustar debiandebian// // marching cubes case table for generating isosurfaces // typedef int EDGE_LIST; typedef struct { EDGE_LIST edges[16]; } TRIANGLE_CASES; // // Edges to intersect. Three at a time form a triangle. Comments at end of line // indicate case number (0->255) and base case number (0->15). // static TRIANGLE_CASES triCases[] = { {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 0 0 */ {{ 0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 1 1 */ {{ 0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 2 1 */ {{ 1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 3 2 */ {{ 1, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 4 1 */ {{ 0, 3, 8, 1, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 5 3 */ {{ 9, 11, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 6 2 */ {{ 2, 3, 8, 2, 8, 11, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 7 5 */ {{ 3, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 8 1 */ {{ 0, 2, 10, 8, 0, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 9 2 */ {{ 1, 0, 9, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 10 3 */ {{ 1, 2, 10, 1, 10, 9, 9, 10, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 11 5 */ {{ 3, 1, 11, 10, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 12 2 */ {{ 0, 1, 11, 0, 11, 8, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 13 5 */ {{ 3, 0, 9, 3, 9, 10, 10, 9, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 14 5 */ {{ 9, 11, 8, 11, 10, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 15 8 */ {{ 4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 16 1 */ {{ 4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 17 2 */ {{ 0, 9, 1, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 18 3 */ {{ 4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 19 5 */ {{ 1, 11, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 20 4 */ {{ 3, 7, 4, 3, 4, 0, 1, 11, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 21 7 */ {{ 9, 11, 2, 9, 2, 0, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 22 7 */ {{ 2, 9, 11, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1}}, /* 23 14 */ {{ 8, 7, 4, 3, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 24 3 */ {{10, 7, 4, 10, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 25 5 */ {{ 9, 1, 0, 8, 7, 4, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 26 6 */ {{ 4, 10, 7, 9, 10, 4, 9, 2, 10, 9, 1, 2, -1, -1, -1, -1}}, /* 27 9 */ {{ 3, 1, 11, 3, 11, 10, 7, 4, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 28 7 */ {{ 1, 11, 10, 1, 10, 4, 1, 4, 0, 7, 4, 10, -1, -1, -1, -1}}, /* 29 11 */ {{ 4, 8, 7, 9, 10, 0, 9, 11, 10, 10, 3, 0, -1, -1, -1, -1}}, /* 30 12 */ {{ 4, 10, 7, 4, 9, 10, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 31 5 */ {{ 9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 32 1 */ {{ 9, 4, 5, 0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 33 3 */ {{ 0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 34 2 */ {{ 8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 35 5 */ {{ 1, 11, 2, 9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 36 3 */ {{ 3, 8, 0, 1, 11, 2, 4, 5, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 37 6 */ {{ 5, 11, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 38 5 */ {{ 2, 5, 11, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1}}, /* 39 9 */ {{ 9, 4, 5, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 40 4 */ {{ 0, 2, 10, 0, 10, 8, 4, 5, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 41 7 */ {{ 0, 4, 5, 0, 5, 1, 2, 10, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 42 7 */ {{ 2, 5, 1, 2, 8, 5, 2, 10, 8, 4, 5, 8, -1, -1, -1, -1}}, /* 43 11 */ {{11, 10, 3, 11, 3, 1, 9, 4, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 44 7 */ {{ 4, 5, 9, 0, 1, 8, 8, 1, 11, 8, 11, 10, -1, -1, -1, -1}}, /* 45 12 */ {{ 5, 0, 4, 5, 10, 0, 5, 11, 10, 10, 3, 0, -1, -1, -1, -1}}, /* 46 14 */ {{ 5, 8, 4, 5, 11, 8, 11, 10, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 47 5 */ {{ 9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 48 2 */ {{ 9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 49 5 */ {{ 0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 50 5 */ {{ 1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 51 8 */ {{ 9, 8, 7, 9, 7, 5, 11, 2, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 52 7 */ {{11, 2, 1, 9, 0, 5, 5, 0, 3, 5, 3, 7, -1, -1, -1, -1}}, /* 53 12 */ {{ 8, 2, 0, 8, 5, 2, 8, 7, 5, 11, 2, 5, -1, -1, -1, -1}}, /* 54 11 */ {{ 2, 5, 11, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 55 5 */ {{ 7, 5, 9, 7, 9, 8, 3, 2, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 56 7 */ {{ 9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 10, 7, -1, -1, -1, -1}}, /* 57 14 */ {{ 2, 10, 3, 0, 8, 1, 1, 8, 7, 1, 7, 5, -1, -1, -1, -1}}, /* 58 12 */ {{10, 1, 2, 10, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 59 5 */ {{ 9, 8, 5, 8, 7, 5, 11, 3, 1, 11, 10, 3, -1, -1, -1, -1}}, /* 60 10 */ {{ 5, 0, 7, 5, 9, 0, 7, 0, 10, 1, 11, 0, 10, 0, 11, -1}}, /* 61 7 */ {{10, 0, 11, 10, 3, 0, 11, 0, 5, 8, 7, 0, 5, 0, 7, -1}}, /* 62 7 */ {{10, 5, 11, 7, 5, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 63 2 */ {{11, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 64 1 */ {{ 0, 3, 8, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 65 4 */ {{ 9, 1, 0, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 66 3 */ {{ 1, 3, 8, 1, 8, 9, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 67 7 */ {{ 1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 68 2 */ {{ 1, 5, 6, 1, 6, 2, 3, 8, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 69 7 */ {{ 9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 70 5 */ {{ 5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1}}, /* 71 11 */ {{ 2, 10, 3, 11, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 72 3 */ {{10, 8, 0, 10, 0, 2, 11, 5, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 73 7 */ {{ 0, 9, 1, 2, 10, 3, 5, 6, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 74 6 */ {{ 5, 6, 11, 1, 2, 9, 9, 2, 10, 9, 10, 8, -1, -1, -1, -1}}, /* 75 12 */ {{ 6, 10, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 76 5 */ {{ 0, 10, 8, 0, 5, 10, 0, 1, 5, 5, 6, 10, -1, -1, -1, -1}}, /* 77 14 */ {{ 3, 6, 10, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1}}, /* 78 9 */ {{ 6, 9, 5, 6, 10, 9, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 79 5 */ {{ 5, 6, 11, 4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 80 3 */ {{ 4, 0, 3, 4, 3, 7, 6, 11, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 81 7 */ {{ 1, 0, 9, 5, 6, 11, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 82 6 */ {{11, 5, 6, 1, 7, 9, 1, 3, 7, 7, 4, 9, -1, -1, -1, -1}}, /* 83 12 */ {{ 6, 2, 1, 6, 1, 5, 4, 8, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 84 7 */ {{ 1, 5, 2, 5, 6, 2, 3, 4, 0, 3, 7, 4, -1, -1, -1, -1}}, /* 85 10 */ {{ 8, 7, 4, 9, 5, 0, 0, 5, 6, 0, 6, 2, -1, -1, -1, -1}}, /* 86 12 */ {{ 7, 9, 3, 7, 4, 9, 3, 9, 2, 5, 6, 9, 2, 9, 6, -1}}, /* 87 7 */ {{ 3, 2, 10, 7, 4, 8, 11, 5, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 88 6 */ {{ 5, 6, 11, 4, 2, 7, 4, 0, 2, 2, 10, 7, -1, -1, -1, -1}}, /* 89 12 */ {{ 0, 9, 1, 4, 8, 7, 2, 10, 3, 5, 6, 11, -1, -1, -1, -1}}, /* 90 13 */ {{ 9, 1, 2, 9, 2, 10, 9, 10, 4, 7, 4, 10, 5, 6, 11, -1}}, /* 91 6 */ {{ 8, 7, 4, 3, 5, 10, 3, 1, 5, 5, 6, 10, -1, -1, -1, -1}}, /* 92 12 */ {{ 5, 10, 1, 5, 6, 10, 1, 10, 0, 7, 4, 10, 0, 10, 4, -1}}, /* 93 7 */ {{ 0, 9, 5, 0, 5, 6, 0, 6, 3, 10, 3, 6, 8, 7, 4, -1}}, /* 94 6 */ {{ 6, 9, 5, 6, 10, 9, 4, 9, 7, 7, 9, 10, -1, -1, -1, -1}}, /* 95 3 */ {{11, 9, 4, 6, 11, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 96 2 */ {{ 4, 6, 11, 4, 11, 9, 0, 3, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 97 7 */ {{11, 1, 0, 11, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 98 5 */ {{ 8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 11, 1, -1, -1, -1, -1}}, /* 99 14 */ {{ 1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 100 5 */ {{ 3, 8, 0, 1, 9, 2, 2, 9, 4, 2, 4, 6, -1, -1, -1, -1}}, /* 101 12 */ {{ 0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 102 8 */ {{ 8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 103 5 */ {{11, 9, 4, 11, 4, 6, 10, 3, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 104 7 */ {{ 0, 2, 8, 2, 10, 8, 4, 11, 9, 4, 6, 11, -1, -1, -1, -1}}, /* 105 10 */ {{ 3, 2, 10, 0, 6, 1, 0, 4, 6, 6, 11, 1, -1, -1, -1, -1}}, /* 106 12 */ {{ 6, 1, 4, 6, 11, 1, 4, 1, 8, 2, 10, 1, 8, 1, 10, -1}}, /* 107 7 */ {{ 9, 4, 6, 9, 6, 3, 9, 3, 1, 10, 3, 6, -1, -1, -1, -1}}, /* 108 11 */ {{ 8, 1, 10, 8, 0, 1, 10, 1, 6, 9, 4, 1, 6, 1, 4, -1}}, /* 109 7 */ {{ 3, 6, 10, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 110 5 */ {{ 6, 8, 4, 10, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 111 2 */ {{ 7, 6, 11, 7, 11, 8, 8, 11, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 112 5 */ {{ 0, 3, 7, 0, 7, 11, 0, 11, 9, 6, 11, 7, -1, -1, -1, -1}}, /* 113 11 */ {{11, 7, 6, 1, 7, 11, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1}}, /* 114 9 */ {{11, 7, 6, 11, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 115 5 */ {{ 1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1}}, /* 116 14 */ {{ 2, 9, 6, 2, 1, 9, 6, 9, 7, 0, 3, 9, 7, 9, 3, -1}}, /* 117 7 */ {{ 7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 118 5 */ {{ 7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 119 2 */ {{ 2, 10, 3, 11, 8, 6, 11, 9, 8, 8, 7, 6, -1, -1, -1, -1}}, /* 120 12 */ {{ 2, 7, 0, 2, 10, 7, 0, 7, 9, 6, 11, 7, 9, 7, 11, -1}}, /* 121 7 */ {{ 1, 0, 8, 1, 8, 7, 1, 7, 11, 6, 11, 7, 2, 10, 3, -1}}, /* 122 6 */ {{10, 1, 2, 10, 7, 1, 11, 1, 6, 6, 1, 7, -1, -1, -1, -1}}, /* 123 3 */ {{ 8, 6, 9, 8, 7, 6, 9, 6, 1, 10, 3, 6, 1, 6, 3, -1}}, /* 124 7 */ {{ 0, 1, 9, 10, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 125 4 */ {{ 7, 0, 8, 7, 6, 0, 3, 0, 10, 10, 0, 6, -1, -1, -1, -1}}, /* 126 3 */ {{ 7, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 127 1 */ {{ 7, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 128 1 */ {{ 3, 8, 0, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 129 3 */ {{ 0, 9, 1, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 130 4 */ {{ 8, 9, 1, 8, 1, 3, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 131 7 */ {{11, 2, 1, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 132 3 */ {{ 1, 11, 2, 3, 8, 0, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 133 6 */ {{ 2, 0, 9, 2, 9, 11, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 134 7 */ {{ 6, 7, 10, 2, 3, 11, 11, 3, 8, 11, 8, 9, -1, -1, -1, -1}}, /* 135 12 */ {{ 7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 136 2 */ {{ 7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 137 5 */ {{ 2, 6, 7, 2, 7, 3, 0, 9, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 138 7 */ {{ 1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1}}, /* 139 14 */ {{11, 6, 7, 11, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 140 5 */ {{11, 6, 7, 1, 11, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1}}, /* 141 9 */ {{ 0, 7, 3, 0, 11, 7, 0, 9, 11, 6, 7, 11, -1, -1, -1, -1}}, /* 142 11 */ {{ 7, 11, 6, 7, 8, 11, 8, 9, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 143 5 */ {{ 6, 4, 8, 10, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 144 2 */ {{ 3, 10, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 145 5 */ {{ 8, 10, 6, 8, 6, 4, 9, 1, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 146 7 */ {{ 9, 6, 4, 9, 3, 6, 9, 1, 3, 10, 6, 3, -1, -1, -1, -1}}, /* 147 11 */ {{ 6, 4, 8, 6, 8, 10, 2, 1, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 148 7 */ {{ 1, 11, 2, 3, 10, 0, 0, 10, 6, 0, 6, 4, -1, -1, -1, -1}}, /* 149 12 */ {{ 4, 8, 10, 4, 10, 6, 0, 9, 2, 2, 9, 11, -1, -1, -1, -1}}, /* 150 10 */ {{11, 3, 9, 11, 2, 3, 9, 3, 4, 10, 6, 3, 4, 3, 6, -1}}, /* 151 7 */ {{ 8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 152 5 */ {{ 0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 153 8 */ {{ 1, 0, 9, 2, 4, 3, 2, 6, 4, 4, 8, 3, -1, -1, -1, -1}}, /* 154 12 */ {{ 1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 155 5 */ {{ 8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 11, -1, -1, -1, -1}}, /* 156 14 */ {{11, 0, 1, 11, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1}}, /* 157 5 */ {{ 4, 3, 6, 4, 8, 3, 6, 3, 11, 0, 9, 3, 11, 3, 9, -1}}, /* 158 7 */ {{11, 4, 9, 6, 4, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 159 2 */ {{ 4, 5, 9, 7, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 160 3 */ {{ 0, 3, 8, 4, 5, 9, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 161 6 */ {{ 5, 1, 0, 5, 0, 4, 7, 10, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 162 7 */ {{10, 6, 7, 8, 4, 3, 3, 4, 5, 3, 5, 1, -1, -1, -1, -1}}, /* 163 12 */ {{ 9, 4, 5, 11, 2, 1, 7, 10, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 164 6 */ {{ 6, 7, 10, 1, 11, 2, 0, 3, 8, 4, 5, 9, -1, -1, -1, -1}}, /* 165 13 */ {{ 7, 10, 6, 5, 11, 4, 4, 11, 2, 4, 2, 0, -1, -1, -1, -1}}, /* 166 12 */ {{ 3, 8, 4, 3, 4, 5, 3, 5, 2, 11, 2, 5, 10, 6, 7, -1}}, /* 167 6 */ {{ 7, 3, 2, 7, 2, 6, 5, 9, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 168 7 */ {{ 9, 4, 5, 0, 6, 8, 0, 2, 6, 6, 7, 8, -1, -1, -1, -1}}, /* 169 12 */ {{ 3, 2, 6, 3, 6, 7, 1, 0, 5, 5, 0, 4, -1, -1, -1, -1}}, /* 170 10 */ {{ 6, 8, 2, 6, 7, 8, 2, 8, 1, 4, 5, 8, 1, 8, 5, -1}}, /* 171 7 */ {{ 9, 4, 5, 11, 6, 1, 1, 6, 7, 1, 7, 3, -1, -1, -1, -1}}, /* 172 12 */ {{ 1, 11, 6, 1, 6, 7, 1, 7, 0, 8, 0, 7, 9, 4, 5, -1}}, /* 173 6 */ {{ 4, 11, 0, 4, 5, 11, 0, 11, 3, 6, 7, 11, 3, 11, 7, -1}}, /* 174 7 */ {{ 7, 11, 6, 7, 8, 11, 5, 11, 4, 4, 11, 8, -1, -1, -1, -1}}, /* 175 3 */ {{ 6, 5, 9, 6, 9, 10, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 176 5 */ {{ 3, 10, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1}}, /* 177 9 */ {{ 0, 8, 10, 0, 10, 5, 0, 5, 1, 5, 10, 6, -1, -1, -1, -1}}, /* 178 14 */ {{ 6, 3, 10, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 179 5 */ {{ 1, 11, 2, 9, 10, 5, 9, 8, 10, 10, 6, 5, -1, -1, -1, -1}}, /* 180 12 */ {{ 0, 3, 10, 0, 10, 6, 0, 6, 9, 5, 9, 6, 1, 11, 2, -1}}, /* 181 6 */ {{10, 5, 8, 10, 6, 5, 8, 5, 0, 11, 2, 5, 0, 5, 2, -1}}, /* 182 7 */ {{ 6, 3, 10, 6, 5, 3, 2, 3, 11, 11, 3, 5, -1, -1, -1, -1}}, /* 183 3 */ {{ 5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1}}, /* 184 11 */ {{ 9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1}}, /* 185 5 */ {{ 1, 8, 5, 1, 0, 8, 5, 8, 6, 3, 2, 8, 6, 8, 2, -1}}, /* 186 7 */ {{ 1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 187 2 */ {{ 1, 6, 3, 1, 11, 6, 3, 6, 8, 5, 9, 6, 8, 6, 9, -1}}, /* 188 7 */ {{11, 0, 1, 11, 6, 0, 9, 0, 5, 5, 0, 6, -1, -1, -1, -1}}, /* 189 3 */ {{ 0, 8, 3, 5, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 190 4 */ {{11, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 191 1 */ {{10, 11, 5, 7, 10, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 192 2 */ {{10, 11, 5, 10, 5, 7, 8, 0, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 193 7 */ {{ 5, 7, 10, 5, 10, 11, 1, 0, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 194 7 */ {{11, 5, 7, 11, 7, 10, 9, 1, 8, 8, 1, 3, -1, -1, -1, -1}}, /* 195 10 */ {{10, 2, 1, 10, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 196 5 */ {{ 0, 3, 8, 1, 7, 2, 1, 5, 7, 7, 10, 2, -1, -1, -1, -1}}, /* 197 12 */ {{ 9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 10, -1, -1, -1, -1}}, /* 198 14 */ {{ 7, 2, 5, 7, 10, 2, 5, 2, 9, 3, 8, 2, 9, 2, 8, -1}}, /* 199 7 */ {{ 2, 11, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 200 5 */ {{ 8, 0, 2, 8, 2, 5, 8, 5, 7, 11, 5, 2, -1, -1, -1, -1}}, /* 201 11 */ {{ 9, 1, 0, 5, 3, 11, 5, 7, 3, 3, 2, 11, -1, -1, -1, -1}}, /* 202 12 */ {{ 9, 2, 8, 9, 1, 2, 8, 2, 7, 11, 5, 2, 7, 2, 5, -1}}, /* 203 7 */ {{ 1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 204 8 */ {{ 0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1}}, /* 205 5 */ {{ 9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1}}, /* 206 5 */ {{ 9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 207 2 */ {{ 5, 4, 8, 5, 8, 11, 11, 8, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 208 5 */ {{ 5, 4, 0, 5, 0, 10, 5, 10, 11, 10, 0, 3, -1, -1, -1, -1}}, /* 209 14 */ {{ 0, 9, 1, 8, 11, 4, 8, 10, 11, 11, 5, 4, -1, -1, -1, -1}}, /* 210 12 */ {{11, 4, 10, 11, 5, 4, 10, 4, 3, 9, 1, 4, 3, 4, 1, -1}}, /* 211 7 */ {{ 2, 1, 5, 2, 5, 8, 2, 8, 10, 4, 8, 5, -1, -1, -1, -1}}, /* 212 11 */ {{ 0, 10, 4, 0, 3, 10, 4, 10, 5, 2, 1, 10, 5, 10, 1, -1}}, /* 213 7 */ {{ 0, 5, 2, 0, 9, 5, 2, 5, 10, 4, 8, 5, 10, 5, 8, -1}}, /* 214 7 */ {{ 9, 5, 4, 2, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 215 4 */ {{ 2, 11, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1}}, /* 216 9 */ {{ 5, 2, 11, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1}}, /* 217 5 */ {{ 3, 2, 11, 3, 11, 5, 3, 5, 8, 4, 8, 5, 0, 9, 1, -1}}, /* 218 6 */ {{ 5, 2, 11, 5, 4, 2, 1, 2, 9, 9, 2, 4, -1, -1, -1, -1}}, /* 219 3 */ {{ 8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1}}, /* 220 5 */ {{ 0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 221 2 */ {{ 8, 5, 4, 8, 3, 5, 9, 5, 0, 0, 5, 3, -1, -1, -1, -1}}, /* 222 3 */ {{ 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 223 1 */ {{ 4, 7, 10, 4, 10, 9, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 224 5 */ {{ 0, 3, 8, 4, 7, 9, 9, 7, 10, 9, 10, 11, -1, -1, -1, -1}}, /* 225 12 */ {{ 1, 10, 11, 1, 4, 10, 1, 0, 4, 7, 10, 4, -1, -1, -1, -1}}, /* 226 11 */ {{ 3, 4, 1, 3, 8, 4, 1, 4, 11, 7, 10, 4, 11, 4, 10, -1}}, /* 227 7 */ {{ 4, 7, 10, 9, 4, 10, 9, 10, 2, 9, 2, 1, -1, -1, -1, -1}}, /* 228 9 */ {{ 9, 4, 7, 9, 7, 10, 9, 10, 1, 2, 1, 10, 0, 3, 8, -1}}, /* 229 6 */ {{10, 4, 7, 10, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1}}, /* 230 5 */ {{10, 4, 7, 10, 2, 4, 8, 4, 3, 3, 4, 2, -1, -1, -1, -1}}, /* 231 3 */ {{ 2, 11, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1}}, /* 232 14 */ {{ 9, 7, 11, 9, 4, 7, 11, 7, 2, 8, 0, 7, 2, 7, 0, -1}}, /* 233 7 */ {{ 3, 11, 7, 3, 2, 11, 7, 11, 4, 1, 0, 11, 4, 11, 0, -1}}, /* 234 7 */ {{ 1, 2, 11, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 235 4 */ {{ 4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1}}, /* 236 5 */ {{ 4, 1, 9, 4, 7, 1, 0, 1, 8, 8, 1, 7, -1, -1, -1, -1}}, /* 237 3 */ {{ 4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 238 2 */ {{ 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 239 1 */ {{ 9, 8, 11, 11, 8, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 240 8 */ {{ 3, 9, 0, 3, 10, 9, 10, 11, 9, -1, -1, -1, -1, -1, -1, -1}}, /* 241 5 */ {{ 0, 11, 1, 0, 8, 11, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1}}, /* 242 5 */ {{ 3, 11, 1, 10, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 243 2 */ {{ 1, 10, 2, 1, 9, 10, 9, 8, 10, -1, -1, -1, -1, -1, -1, -1}}, /* 244 5 */ {{ 3, 9, 0, 3, 10, 9, 1, 9, 2, 2, 9, 10, -1, -1, -1, -1}}, /* 245 3 */ {{ 0, 10, 2, 8, 10, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 246 2 */ {{ 3, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 247 1 */ {{ 2, 8, 3, 2, 11, 8, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1}}, /* 248 5 */ {{ 9, 2, 11, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 249 2 */ {{ 2, 8, 3, 2, 11, 8, 0, 8, 1, 1, 8, 11, -1, -1, -1, -1}}, /* 250 3 */ {{ 1, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 251 1 */ {{ 1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 252 2 */ {{ 0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 253 1 */ {{ 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, /* 254 1 */ {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}}; /* 255 0 */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/hexa.cpp0000755000175000017500000014423310150464521023501 0ustar debiandebian#include"cellQueue.h" #include"octree.h" #include"e_face.h" #include"cubes.h" #include #include"vtkMarchingCubesCases.h" #include"pcio.h" #include"geoframe.h" #include void Octree::hexahedralize(geoframe& geofrm, float err_tol) { int x, y, z, valid_leaf, cell_size, level; int oc_id[8], edge_id[6], i, j, k, flag_method; unsigned int vtx[8]; float val[8]; for(i = 0; i < octcell_num; i++) vtx_idx_arr[i] = -1; flag_method = 2; // 0 - uniform; 1 - Method 1; 2 - Method 2. if(flag_method == 2) assign_refine_sign_hexa(geofrm, err_tol); for(i = 0; i < leaf_num; i++ ) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; cell_size = (dim[0]-1)/(1< err_tol) num_id++; if(is_skipcell(oc_id[i]) == 0) get_vtx_new(geofrm, oc_id[i], vtx[i]); } num_quad = 0; for(i = 0; i < 6; i++) { if(edge_id[i] == 1) num_quad++; } if(num_id == 0 || num_quad == 0) { add_hexa(geofrm, vtx); } else { geofrm.AddVert_hexa_adaptive_1_center(vtx, vtx_new); add_hexa(geofrm, vtx_new); for(i = 0; i < 6; i++) { if(i == 0) {v[0] = 0; v[1] = 1; v[2] = 2; v[3] = 3;} // up if(i == 1) {v[0] = 4; v[1] = 7; v[2] = 6; v[3] = 5;} // down if(i == 2) {v[0] = 0; v[1] = 3; v[2] = 7; v[3] = 4;} // left if(i == 3) {v[0] = 1; v[1] = 5; v[2] = 6; v[3] = 2;} // right if(i == 4) {v[0] = 1; v[1] = 0; v[2] = 4; v[3] = 5;} // front if(i == 5) {v[0] = 3; v[1] = 2; v[2] = 6; v[3] = 7;} // back for(j = 0; j < 4; j++) { vtx_temp[j] = vtx[v[j]]; vtx_temp[j+4] = vtx_new[v[j]]; } if((get_err_grad(oc_id[v[0]]) > err_tol || get_err_grad(oc_id[v[1]]) > err_tol || get_err_grad(oc_id[v[2]]) > err_tol || get_err_grad(oc_id[v[3]]) > err_tol) && edge_id[i] == 1) { geofrm.AddVert_hexa_adaptive_1_top(vtx_temp, vtx_t); for(k = 0; k < 4; k++) { for(j = 0; j < 4; j++) { level = get_level(oc_id[v[j]]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 4) get_vtx_new(geofrm, oc_id[v[j]], vtx_t[k]); } hexa_adaptive_1_top(geofrm, vtx_temp, vtx_t); } else add_hexa(geofrm, vtx_temp); } } } // adaptive hexa mesh generation -- method 2 void Octree::hexa_adaptive_2(geoframe& geofrm, int* oc_id, int* edge_id, float err_tol, unsigned int* vtx) { int num_id, i, j, my_bool_2, my_bool_4, edge_id_new[6]; int level, cell_size, xx, yy, zz, vv[4]; unsigned int vtx_new[64], vtx_temp[8]; float x, y, z; for(i = 0; i < 6; i++) { if(i == 0) {vv[0] = 0; vv[1] = 1; vv[2] = 2; vv[3] = 3;} // up if(i == 1) {vv[0] = 4; vv[1] = 7; vv[2] = 6; vv[3] = 5;} // down if(i == 2) {vv[0] = 0; vv[1] = 3; vv[2] = 7; vv[3] = 4;} // left if(i == 3) {vv[0] = 1; vv[1] = 5; vv[2] = 6; vv[3] = 2;} // right if(i == 4) {vv[0] = 1; vv[1] = 0; vv[2] = 4; vv[3] = 5;} // front if(i == 5) {vv[0] = 3; vv[1] = 2; vv[2] = 6; vv[3] = 7;} // back if(edge_id[i] == 1) { geofrm.AddBound_edge(vtx[vv[0]], vtx[vv[1]]); geofrm.AddBound_edge(vtx[vv[1]], vtx[vv[2]]); geofrm.AddBound_edge(vtx[vv[2]], vtx[vv[3]]); geofrm.AddBound_edge(vtx[vv[3]], vtx[vv[0]]); } } num_id = 0; for(i = 0; i < 8; i++) { if(vtx_idx_arr_refine[oc_id[i]] == 1) num_id++; if(is_skipcell(oc_id[i]) == 0) get_vtx_new(geofrm, oc_id[i], vtx[i]); } // detect one edge my_bool_2 = (vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[1]] == 1) || (vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1) || (vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1) || (vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[0]] == 1) || (vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1) || (vtx_idx_arr_refine[oc_id[5]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1) || (vtx_idx_arr_refine[oc_id[6]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) || (vtx_idx_arr_refine[oc_id[7]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1) || (vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1) || (vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1) || (vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1) || (vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1); // detect one face my_bool_4 = (vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1) || (vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) || (vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) || (vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1) || (vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1) || (vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1); if(num_id == 0) { add_hexa(geofrm, vtx); } else if(num_id == 1) { // one point if(vtx_idx_arr_refine[oc_id[0]] == 1) { for(i = 0; i < 8; i++) vtx_temp[i] = vtx[i]; for(i = 0; i < 6; i++) edge_id_new[i] = edge_id[i]; } else if(vtx_idx_arr_refine[oc_id[1]] == 1) { vtx_temp[0] = vtx[1]; vtx_temp[1] = vtx[2]; vtx_temp[2] = vtx[3]; vtx_temp[3] = vtx[0]; vtx_temp[4] = vtx[5]; vtx_temp[5] = vtx[6]; vtx_temp[6] = vtx[7]; vtx_temp[7] = vtx[4]; edge_id_new[0] = edge_id[0]; edge_id_new[1] = edge_id[1]; edge_id_new[2] = edge_id[4]; edge_id_new[3] = edge_id[5]; edge_id_new[4] = edge_id[3]; edge_id_new[5] = edge_id[2]; } else if(vtx_idx_arr_refine[oc_id[2]] == 1) { vtx_temp[0] = vtx[2]; vtx_temp[1] = vtx[3]; vtx_temp[2] = vtx[0]; vtx_temp[3] = vtx[1]; vtx_temp[4] = vtx[6]; vtx_temp[5] = vtx[7]; vtx_temp[6] = vtx[4]; vtx_temp[7] = vtx[5]; edge_id_new[0] = edge_id[0]; edge_id_new[1] = edge_id[1]; edge_id_new[2] = edge_id[3]; edge_id_new[3] = edge_id[2]; edge_id_new[4] = edge_id[5]; edge_id_new[5] = edge_id[4]; } else if(vtx_idx_arr_refine[oc_id[3]] == 1) { vtx_temp[0] = vtx[3]; vtx_temp[1] = vtx[0]; vtx_temp[2] = vtx[1]; vtx_temp[3] = vtx[2]; vtx_temp[4] = vtx[7]; vtx_temp[5] = vtx[4]; vtx_temp[6] = vtx[5]; vtx_temp[7] = vtx[6]; edge_id_new[0] = edge_id[0]; edge_id_new[1] = edge_id[1]; edge_id_new[2] = edge_id[5]; edge_id_new[3] = edge_id[4]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else if(vtx_idx_arr_refine[oc_id[4]] == 1) { vtx_temp[0] = vtx[4]; vtx_temp[1] = vtx[7]; vtx_temp[2] = vtx[6]; vtx_temp[3] = vtx[5]; vtx_temp[4] = vtx[0]; vtx_temp[5] = vtx[3]; vtx_temp[6] = vtx[2]; vtx_temp[7] = vtx[1]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[4]; edge_id_new[3] = edge_id[5]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else if(vtx_idx_arr_refine[oc_id[5]] == 1) { vtx_temp[0] = vtx[5]; vtx_temp[1] = vtx[4]; vtx_temp[2] = vtx[7]; vtx_temp[3] = vtx[6]; vtx_temp[4] = vtx[1]; vtx_temp[5] = vtx[0]; vtx_temp[6] = vtx[3]; vtx_temp[7] = vtx[2]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[3]; edge_id_new[3] = edge_id[2]; edge_id_new[4] = edge_id[4]; edge_id_new[5] = edge_id[5]; } else if(vtx_idx_arr_refine[oc_id[6]] == 1) { vtx_temp[0] = vtx[6]; vtx_temp[1] = vtx[5]; vtx_temp[2] = vtx[4]; vtx_temp[3] = vtx[7]; vtx_temp[4] = vtx[2]; vtx_temp[5] = vtx[1]; vtx_temp[6] = vtx[0]; vtx_temp[7] = vtx[3]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[5]; edge_id_new[3] = edge_id[4]; edge_id_new[4] = edge_id[3]; edge_id_new[5] = edge_id[2]; } else { //if(vtx_idx_arr_refine[oc_id[7]] == 1) vtx_temp[0] = vtx[7]; vtx_temp[1] = vtx[6]; vtx_temp[2] = vtx[5]; vtx_temp[3] = vtx[4]; vtx_temp[4] = vtx[3]; vtx_temp[5] = vtx[2]; vtx_temp[6] = vtx[1]; vtx_temp[7] = vtx[0]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[2]; edge_id_new[3] = edge_id[3]; edge_id_new[4] = edge_id[5]; edge_id_new[5] = edge_id[4]; } //add_hexa(geofrm, vtx); geofrm.AddVert_hexa_adaptive_2_1(vtx_temp, edge_id_new, vtx_new); for(i = 0; i < 7; i++) { if(geofrm.bound_sign[vtx_new[i]] != 1) continue; for(j = 0; j < 8; j++) { if(is_skipcell(oc_id[j])) continue; level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 8) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } add_hexa_adaptive_2_1(geofrm, vtx_temp, vtx_new); } else if(num_id == 2 && my_bool_2) { // one edge if(vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[1]] == 1) { for(i = 0; i < 8; i++) vtx_temp[i] = vtx[i]; for(i = 0; i < 6; i++) edge_id_new[i] = edge_id[i]; } else if(vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1) { vtx_temp[0] = vtx[1]; vtx_temp[1] = vtx[2]; vtx_temp[2] = vtx[3]; vtx_temp[3] = vtx[0]; vtx_temp[4] = vtx[5]; vtx_temp[5] = vtx[6]; vtx_temp[6] = vtx[7]; vtx_temp[7] = vtx[4]; edge_id_new[0] = edge_id[0]; edge_id_new[1] = edge_id[1]; edge_id_new[2] = edge_id[4]; edge_id_new[3] = edge_id[5]; edge_id_new[4] = edge_id[3]; edge_id_new[5] = edge_id[2]; } else if(vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1) { vtx_temp[0] = vtx[2]; vtx_temp[1] = vtx[3]; vtx_temp[2] = vtx[0]; vtx_temp[3] = vtx[1]; vtx_temp[4] = vtx[6]; vtx_temp[5] = vtx[7]; vtx_temp[6] = vtx[4]; vtx_temp[7] = vtx[5]; edge_id_new[0] = edge_id[0]; edge_id_new[1] = edge_id[1]; edge_id_new[2] = edge_id[3]; edge_id_new[3] = edge_id[2]; edge_id_new[4] = edge_id[5]; edge_id_new[5] = edge_id[4]; } else if(vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[0]] == 1) { vtx_temp[0] = vtx[3]; vtx_temp[1] = vtx[0]; vtx_temp[2] = vtx[1]; vtx_temp[3] = vtx[2]; vtx_temp[4] = vtx[7]; vtx_temp[5] = vtx[4]; vtx_temp[6] = vtx[5]; vtx_temp[7] = vtx[6]; edge_id_new[0] = edge_id[0]; edge_id_new[1] = edge_id[1]; edge_id_new[2] = edge_id[5]; edge_id_new[3] = edge_id[4]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else if(vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) { vtx_temp[0] = vtx[4]; vtx_temp[1] = vtx[7]; vtx_temp[2] = vtx[6]; vtx_temp[3] = vtx[5]; vtx_temp[4] = vtx[0]; vtx_temp[5] = vtx[3]; vtx_temp[6] = vtx[2]; vtx_temp[7] = vtx[1]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[4]; edge_id_new[3] = edge_id[5]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else if(vtx_idx_arr_refine[oc_id[5]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1) { vtx_temp[0] = vtx[5]; vtx_temp[1] = vtx[4]; vtx_temp[2] = vtx[7]; vtx_temp[3] = vtx[6]; vtx_temp[4] = vtx[1]; vtx_temp[5] = vtx[0]; vtx_temp[6] = vtx[3]; vtx_temp[7] = vtx[2]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[3]; edge_id_new[3] = edge_id[2]; edge_id_new[4] = edge_id[4]; edge_id_new[5] = edge_id[5]; } else if(vtx_idx_arr_refine[oc_id[6]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1) { vtx_temp[0] = vtx[6]; vtx_temp[1] = vtx[5]; vtx_temp[2] = vtx[4]; vtx_temp[3] = vtx[7]; vtx_temp[4] = vtx[2]; vtx_temp[5] = vtx[1]; vtx_temp[6] = vtx[0]; vtx_temp[7] = vtx[3]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[5]; edge_id_new[3] = edge_id[4]; edge_id_new[4] = edge_id[3]; edge_id_new[5] = edge_id[2]; } else if(vtx_idx_arr_refine[oc_id[7]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1) { vtx_temp[0] = vtx[7]; vtx_temp[1] = vtx[6]; vtx_temp[2] = vtx[5]; vtx_temp[3] = vtx[4]; vtx_temp[4] = vtx[3]; vtx_temp[5] = vtx[2]; vtx_temp[6] = vtx[1]; vtx_temp[7] = vtx[0]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[2]; edge_id_new[3] = edge_id[3]; edge_id_new[4] = edge_id[5]; edge_id_new[5] = edge_id[4]; } else if(vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1) { vtx_temp[0] = vtx[0]; vtx_temp[1] = vtx[4]; vtx_temp[2] = vtx[5]; vtx_temp[3] = vtx[1]; vtx_temp[4] = vtx[3]; vtx_temp[5] = vtx[7]; vtx_temp[6] = vtx[6]; vtx_temp[7] = vtx[2]; edge_id_new[0] = edge_id[4]; edge_id_new[1] = edge_id[5]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else if(vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1) { vtx_temp[0] = vtx[1]; vtx_temp[1] = vtx[5]; vtx_temp[2] = vtx[6]; vtx_temp[3] = vtx[2]; vtx_temp[4] = vtx[0]; vtx_temp[5] = vtx[4]; vtx_temp[6] = vtx[7]; vtx_temp[7] = vtx[3]; edge_id_new[0] = edge_id[3]; edge_id_new[1] = edge_id[2]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[4]; edge_id_new[5] = edge_id[5]; } else if(vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1) { vtx_temp[0] = vtx[2]; vtx_temp[1] = vtx[6]; vtx_temp[2] = vtx[7]; vtx_temp[3] = vtx[3]; vtx_temp[4] = vtx[1]; vtx_temp[5] = vtx[5]; vtx_temp[6] = vtx[4]; vtx_temp[7] = vtx[0]; edge_id_new[0] = edge_id[5]; edge_id_new[1] = edge_id[4]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[3]; edge_id_new[5] = edge_id[2]; } else { //if(vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) vtx_temp[0] = vtx[3]; vtx_temp[1] = vtx[7]; vtx_temp[2] = vtx[4]; vtx_temp[3] = vtx[0]; vtx_temp[4] = vtx[2]; vtx_temp[5] = vtx[6]; vtx_temp[6] = vtx[5]; vtx_temp[7] = vtx[1]; edge_id_new[0] = edge_id[2]; edge_id_new[1] = edge_id[3]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[5]; edge_id_new[5] = edge_id[4]; } //add_hexa(geofrm, vtx); geofrm.AddVert_hexa_adaptive_2_2(vtx_temp, edge_id_new, vtx_new); for(i = 0; i < 24; i++) { if(geofrm.bound_sign[vtx_new[i]] != 1 || i == 0 || i == 3 || i == 10 || i == 11) continue; for(j = 0; j < 8; j++) { if(is_skipcell(oc_id[j])) continue; level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 8) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } add_hexa_adaptive_2_2(geofrm, vtx_new); } else if(num_id == 4 && my_bool_4) { // one face if( vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1) { for(i = 0; i < 8; i++) vtx_temp[i] = vtx[i]; for(i = 0; i < 6; i++) edge_id_new[i] = edge_id[i]; } else if(vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) { vtx_temp[0] = vtx[4]; vtx_temp[1] = vtx[7]; vtx_temp[2] = vtx[6]; vtx_temp[3] = vtx[5]; vtx_temp[4] = vtx[0]; vtx_temp[5] = vtx[3]; vtx_temp[6] = vtx[2]; vtx_temp[7] = vtx[1]; edge_id_new[0] = edge_id[1]; edge_id_new[1] = edge_id[0]; edge_id_new[2] = edge_id[4]; edge_id_new[3] = edge_id[5]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else if(vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1) { vtx_temp[0] = vtx[3]; vtx_temp[1] = vtx[7]; vtx_temp[2] = vtx[4]; vtx_temp[3] = vtx[0]; vtx_temp[4] = vtx[2]; vtx_temp[5] = vtx[6]; vtx_temp[6] = vtx[5]; vtx_temp[7] = vtx[1]; edge_id_new[0] = edge_id[2]; edge_id_new[1] = edge_id[3]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[5]; edge_id_new[5] = edge_id[4]; } else if(vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1 && vtx_idx_arr_refine[oc_id[6]] == 1) { vtx_temp[0] = vtx[1]; vtx_temp[1] = vtx[5]; vtx_temp[2] = vtx[6]; vtx_temp[3] = vtx[2]; vtx_temp[4] = vtx[0]; vtx_temp[5] = vtx[4]; vtx_temp[6] = vtx[7]; vtx_temp[7] = vtx[3]; edge_id_new[0] = edge_id[3]; edge_id_new[1] = edge_id[2]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[4]; edge_id_new[5] = edge_id[5]; } else if(vtx_idx_arr_refine[oc_id[0]] == 1 && vtx_idx_arr_refine[oc_id[1]] == 1 && vtx_idx_arr_refine[oc_id[4]] == 1 && vtx_idx_arr_refine[oc_id[5]] == 1) { vtx_temp[0] = vtx[0]; vtx_temp[1] = vtx[4]; vtx_temp[2] = vtx[5]; vtx_temp[3] = vtx[1]; vtx_temp[4] = vtx[3]; vtx_temp[5] = vtx[7]; vtx_temp[6] = vtx[6]; vtx_temp[7] = vtx[2]; edge_id_new[0] = edge_id[4]; edge_id_new[1] = edge_id[5]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[2]; edge_id_new[5] = edge_id[3]; } else { //if(vtx_idx_arr_refine[oc_id[2]] == 1 && vtx_idx_arr_refine[oc_id[3]] == 1 && // vtx_idx_arr_refine[oc_id[6]] == 1 && vtx_idx_arr_refine[oc_id[7]] == 1); vtx_temp[0] = vtx[2]; vtx_temp[1] = vtx[6]; vtx_temp[2] = vtx[7]; vtx_temp[3] = vtx[3]; vtx_temp[4] = vtx[1]; vtx_temp[5] = vtx[5]; vtx_temp[6] = vtx[4]; vtx_temp[7] = vtx[0]; edge_id_new[0] = edge_id[5]; edge_id_new[1] = edge_id[4]; edge_id_new[2] = edge_id[0]; edge_id_new[3] = edge_id[1]; edge_id_new[4] = edge_id[3]; edge_id_new[5] = edge_id[2]; } //add_hexa(geofrm, vtx); geofrm.AddVert_hexa_adaptive_2_4(vtx_temp, edge_id_new, vtx_new); for(i = 0; i < 44; i++) { if(geofrm.bound_sign[vtx_new[i]] != 1 || i == 0 || i == 3 || i == 12 || i == 15) continue; for(j = 0; j < 8; j++) { if(is_skipcell(oc_id[j])) continue; level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 8) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } add_hexa_adaptive_2_4(geofrm, vtx_new); } else { assert(num_id == 8); //add_hexa(geofrm, vtx); geofrm.AddVert_hexa_adaptive_2(vtx, edge_id, vtx_new); for(i = 0; i < 64; i++) { if(geofrm.bound_sign[vtx_new[i]] != 1 || i%48 == 0 || i%48 == 3 || i%48 == 12 || i%48 == 15) continue; for(j = 0; j < 8; j++) { if(is_skipcell(oc_id[j])) continue; level = get_level(oc_id[j]) ; cell_size = (dim[0]-1)/(1<= 0.0f && x <= 1.0f && y >= 0.0f && y <= 1.0f && z >= 0.0f && z <= 1.0f) break; } if(j < 8) get_vtx_new(geofrm, oc_id[j], vtx_new[i]); } add_hexa_adaptive_2(geofrm, vtx_new); } } void Octree::hexa_adaptive_1_top(geoframe& geofrm, unsigned int* vtx, unsigned int* vtx_new) { unsigned int temp[8]; add_hexa(geofrm, vtx_new); temp[0] = vtx[0]; temp[1] = vtx[1]; temp[2] = vtx_new[1]; temp[3] = vtx_new[0]; temp[4] = vtx[4]; temp[5] = vtx[5]; temp[6] = vtx_new[5]; temp[7] = vtx_new[4]; add_hexa(geofrm, temp); temp[0] = vtx[1]; temp[1] = vtx[2]; temp[2] = vtx_new[2]; temp[3] = vtx_new[1]; temp[4] = vtx[5]; temp[5] = vtx[6]; temp[6] = vtx_new[6]; temp[7] = vtx_new[5]; add_hexa(geofrm, temp); temp[0] = vtx[2]; temp[1] = vtx[3]; temp[2] = vtx_new[3]; temp[3] = vtx_new[2]; temp[4] = vtx[6]; temp[5] = vtx[7]; temp[6] = vtx_new[7]; temp[7] = vtx_new[6]; add_hexa(geofrm, temp); temp[0] = vtx[3]; temp[1] = vtx[0]; temp[2] = vtx_new[0]; temp[3] = vtx_new[3]; temp[4] = vtx[7]; temp[5] = vtx[4]; temp[6] = vtx_new[4]; temp[7] = vtx_new[7]; add_hexa(geofrm, temp); temp[0] = vtx_new[4]; temp[1] = vtx_new[5]; temp[2] = vtx_new[6]; temp[3] = vtx_new[7]; temp[4] = vtx[4]; temp[5] = vtx[5]; temp[6] = vtx[6]; temp[7] = vtx[7]; add_hexa(geofrm, temp); } void Octree::add_hexa_adaptive_2(geoframe& geofrm, unsigned int* vtx_new) { int i, j, k; unsigned int temp[8]; for(k = 0; k < 3; k++) { for(j = 0; j < 3; j++) { for(i = 0; i < 3; i++) { temp[0] = vtx_new[i+4*j+16*k]; temp[1] = vtx_new[i+4*j+16*k+1]; temp[2] = vtx_new[i+4*j+16*k+5]; temp[3] = vtx_new[i+4*j+16*k+4]; temp[4] = vtx_new[i+4*j+16*k+16]; temp[5] = vtx_new[i+4*j+16*k+17]; temp[6] = vtx_new[i+4*j+16*k+21]; temp[7] = vtx_new[i+4*j+16*k+20]; add_hexa(geofrm, temp); } } } } // one vertex needs to be refined void Octree::add_hexa_adaptive_2_1(geoframe& geofrm, unsigned int* vtx, unsigned int* vtx_temp) { int i; unsigned int temp[8]; temp[0] = vtx[0]; for(i = 0; i < 7; i++) temp[i+1] = vtx_temp[i]; add_hexa(geofrm, temp); for(i = 0; i < 4; i++) temp[i] = vtx_temp[i+3]; for(i = 4; i < 8; i++) temp[i] = vtx[i]; add_hexa(geofrm, temp); for(i = 0; i < 8; i++) temp[i] = vtx[i]; temp[0] = vtx_temp[0]; temp[3] = vtx_temp[1]; temp[4] = vtx_temp[4]; temp[7] = vtx_temp[5]; add_hexa(geofrm, temp); for(i = 0; i < 8; i++) temp[i] = vtx[i]; temp[0] = vtx_temp[2]; temp[1] = vtx_temp[1]; temp[4] = vtx_temp[6]; temp[5] = vtx_temp[5]; add_hexa(geofrm, temp); } // one edge needs to be refined void Octree::add_hexa_adaptive_2_2(geoframe& geofrm, unsigned int* vtx_new) { int i; unsigned int temp[8]; for(i = 0; i < 3; i++) { temp[0] = vtx_new[i+0]; temp[1] = vtx_new[i+1]; temp[2] = vtx_new[i+5]; temp[3] = vtx_new[i+4]; temp[4] = vtx_new[i+12]; temp[5] = vtx_new[i+13]; temp[6] = vtx_new[i+17]; temp[7] = vtx_new[i+16]; add_hexa(geofrm, temp); } temp[0] = vtx_new[13]; temp[1] = vtx_new[14]; temp[2] = vtx_new[18]; temp[3] = vtx_new[17]; temp[4] = vtx_new[20]; temp[5] = vtx_new[21]; temp[6] = vtx_new[23]; temp[7] = vtx_new[22]; add_hexa(geofrm, temp); temp[0] = vtx_new[12]; temp[1] = vtx_new[13]; temp[2] = vtx_new[17]; temp[3] = vtx_new[16]; temp[4] = vtx_new[24]; temp[5] = vtx_new[20]; temp[6] = vtx_new[22]; temp[7] = vtx_new[26]; add_hexa(geofrm, temp); temp[0] = vtx_new[14]; temp[1] = vtx_new[15]; temp[2] = vtx_new[19]; temp[3] = vtx_new[18]; temp[4] = vtx_new[21]; temp[5] = vtx_new[25]; temp[6] = vtx_new[27]; temp[7] = vtx_new[23]; add_hexa(geofrm, temp); temp[0] = vtx_new[20]; temp[1] = vtx_new[21]; temp[2] = vtx_new[23]; temp[3] = vtx_new[22]; temp[4] = vtx_new[24]; temp[5] = vtx_new[25]; temp[6] = vtx_new[27]; temp[7] = vtx_new[26]; add_hexa(geofrm, temp); temp[0] = vtx_new[5]; temp[1] = vtx_new[6]; temp[2] = vtx_new[9]; temp[3] = vtx_new[8]; temp[4] = vtx_new[17]; temp[5] = vtx_new[18]; temp[6] = vtx_new[23]; temp[7] = vtx_new[22]; add_hexa(geofrm, temp); temp[0] = vtx_new[4]; temp[1] = vtx_new[5]; temp[2] = vtx_new[8]; temp[3] = vtx_new[10]; temp[4] = vtx_new[16]; temp[5] = vtx_new[17]; temp[6] = vtx_new[22]; temp[7] = vtx_new[26]; add_hexa(geofrm, temp); temp[0] = vtx_new[6]; temp[1] = vtx_new[7]; temp[2] = vtx_new[11]; temp[3] = vtx_new[9]; temp[4] = vtx_new[18]; temp[5] = vtx_new[19]; temp[6] = vtx_new[27]; temp[7] = vtx_new[23]; add_hexa(geofrm, temp); temp[0] = vtx_new[8]; temp[1] = vtx_new[9]; temp[2] = vtx_new[11]; temp[3] = vtx_new[10]; temp[4] = vtx_new[22]; temp[5] = vtx_new[23]; temp[6] = vtx_new[27]; temp[7] = vtx_new[26]; add_hexa(geofrm, temp); } // one face needs to be refined void Octree::add_hexa_adaptive_2_4(geoframe& geofrm, unsigned int* vtx_new) { int i, j; unsigned int temp[8]; for(j = 0; j < 3; j++) { for(i = 0; i < 3; i++) { temp[0] = vtx_new[i+4*j+0]; temp[1] = vtx_new[i+4*j+1]; temp[2] = vtx_new[i+4*j+5]; temp[3] = vtx_new[i+4*j+4]; temp[4] = vtx_new[i+4*j+16]; temp[5] = vtx_new[i+4*j+17]; temp[6] = vtx_new[i+4*j+21]; temp[7] = vtx_new[i+4*j+20]; add_hexa(geofrm, temp); } } // middle - 4 temp[0] = vtx_new[21]; temp[1] = vtx_new[22]; temp[2] = vtx_new[26]; temp[3] = vtx_new[25]; temp[4] = vtx_new[32]; temp[5] = vtx_new[33]; temp[6] = vtx_new[35]; temp[7] = vtx_new[34]; add_hexa(geofrm, temp); temp[0] = vtx_new[32]; temp[1] = vtx_new[33]; temp[2] = vtx_new[35]; temp[3] = vtx_new[34]; temp[4] = vtx_new[36]; temp[5] = vtx_new[37]; temp[6] = vtx_new[43]; temp[7] = vtx_new[42]; add_hexa(geofrm, temp); temp[0] = vtx_new[17]; temp[1] = vtx_new[18]; temp[2] = vtx_new[22]; temp[3] = vtx_new[21]; temp[4] = vtx_new[36]; temp[5] = vtx_new[37]; temp[6] = vtx_new[33]; temp[7] = vtx_new[32]; add_hexa(geofrm, temp); temp[0] = vtx_new[25]; temp[1] = vtx_new[26]; temp[2] = vtx_new[30]; temp[3] = vtx_new[29]; temp[4] = vtx_new[34]; temp[5] = vtx_new[35]; temp[6] = vtx_new[43]; temp[7] = vtx_new[42]; add_hexa(geofrm, temp); // bottom - 1 temp[0] = vtx_new[36]; temp[1] = vtx_new[37]; temp[2] = vtx_new[43]; temp[3] = vtx_new[42]; temp[4] = vtx_new[44]; temp[5] = vtx_new[45]; temp[6] = vtx_new[47]; temp[7] = vtx_new[46]; add_hexa(geofrm, temp); // left - 4 temp[0] = vtx_new[16]; temp[1] = vtx_new[17]; temp[2] = vtx_new[21]; temp[3] = vtx_new[20]; temp[4] = vtx_new[44]; temp[5] = vtx_new[36]; temp[6] = vtx_new[32]; temp[7] = vtx_new[38]; add_hexa(geofrm, temp); temp[0] = vtx_new[20]; temp[1] = vtx_new[21]; temp[2] = vtx_new[25]; temp[3] = vtx_new[24]; temp[4] = vtx_new[38]; temp[5] = vtx_new[32]; temp[6] = vtx_new[34]; temp[7] = vtx_new[40]; add_hexa(geofrm, temp); temp[0] = vtx_new[24]; temp[1] = vtx_new[25]; temp[2] = vtx_new[29]; temp[3] = vtx_new[28]; temp[4] = vtx_new[40]; temp[5] = vtx_new[34]; temp[6] = vtx_new[42]; temp[7] = vtx_new[46]; add_hexa(geofrm, temp); temp[0] = vtx_new[38]; temp[1] = vtx_new[32]; temp[2] = vtx_new[34]; temp[3] = vtx_new[40]; temp[4] = vtx_new[44]; temp[5] = vtx_new[36]; temp[6] = vtx_new[42]; temp[7] = vtx_new[46]; add_hexa(geofrm, temp); // right - 4 temp[0] = vtx_new[18]; temp[1] = vtx_new[19]; temp[2] = vtx_new[23]; temp[3] = vtx_new[22]; temp[4] = vtx_new[37]; temp[5] = vtx_new[45]; temp[6] = vtx_new[39]; temp[7] = vtx_new[33]; add_hexa(geofrm, temp); temp[0] = vtx_new[22]; temp[1] = vtx_new[23]; temp[2] = vtx_new[27]; temp[3] = vtx_new[26]; temp[4] = vtx_new[33]; temp[5] = vtx_new[39]; temp[6] = vtx_new[41]; temp[7] = vtx_new[35]; add_hexa(geofrm, temp); temp[0] = vtx_new[26]; temp[1] = vtx_new[27]; temp[2] = vtx_new[31]; temp[3] = vtx_new[30]; temp[4] = vtx_new[35]; temp[5] = vtx_new[41]; temp[6] = vtx_new[47]; temp[7] = vtx_new[43]; add_hexa(geofrm, temp); temp[0] = vtx_new[33]; temp[1] = vtx_new[39]; temp[2] = vtx_new[41]; temp[3] = vtx_new[35]; temp[4] = vtx_new[37]; temp[5] = vtx_new[45]; temp[6] = vtx_new[47]; temp[7] = vtx_new[43]; add_hexa(geofrm, temp); } void Octree::vflag_clear() { memset(vbit, 0, octcell_num*4/8); } int Octree::is_vflag_on(int x, int y, int z, int level, int v) { int idx; switch (v) { case 0 : idx = xyz2octcell(x,y,z,level); break; case 1 : idx = xyz2octcell(x+1,y,z,level); break; case 2 : idx = xyz2octcell(x+1,y,z+1,level); break; case 3 : idx = xyz2octcell(x,y,z+1,level); break; case 4 : idx = xyz2octcell(x,y+1,z,level); break; case 5 : idx = xyz2octcell(x+1,y+1,z,level); break; case 6 : idx = xyz2octcell(x+1,y+1,z+1,level); break; case 7 : idx = xyz2octcell(x,y+1,z+1,level); break; } if (vbit[idx/8] & (1 << (idx%8))) return 1; else return 0; } void Octree::vflag_on(int x, int y, int z, int level, int v) { int idx; switch (v) { case 0 : idx = xyz2octcell(x,y,z,level); break; case 1 : idx = xyz2octcell(x+1,y,z,level); break; case 2 : idx = xyz2octcell(x+1,y,z+1,level); break; case 3 : idx = xyz2octcell(x,y,z+1,level); break; case 4 : idx = xyz2octcell(x,y+1,z,level); break; case 5 : idx = xyz2octcell(x+1,y+1,z,level); break; case 6 : idx = xyz2octcell(x+1,y+1,z+1,level); break; case 7 : idx = xyz2octcell(x,y+1,z+1,level); break; } vbit[idx/8] |= (1 << (idx%8)); } int Octree::is_min_vertex(int oc_id, int v_id, unsigned int* vtx, geoframe& geofrm) { int x, y, z, level, i; //assert(! is_skipcell(oc_id)); level = get_level(oc_id); octcell2xyz(oc_id, x, y, z, level); for(i = 0; i < 8; i++) vtx[i] = -1; switch (v_id) { case 0 : if (is_refined(x-1,y-1,z-1,level) || is_refined(x, y-1,z-1,level) || is_refined(x, y, z-1,level) || is_refined(x-1,y, z-1,level) || is_refined(x-1,y-1,z, level) || is_refined(x, y-1,z, level) || is_refined(x, y, z, level) || is_refined(x-1,y, z, level)) return 0; vtx[0] = min_vtx_hexa(x-1, y-1, z-1, level, geofrm); vtx[1] = min_vtx_hexa(x, y-1, z-1, level, geofrm); vtx[2] = min_vtx_hexa(x, y, z-1, level, geofrm); vtx[3] = min_vtx_hexa(x-1, y, z-1, level, geofrm); vtx[4] = min_vtx_hexa(x-1, y-1, z, level, geofrm); vtx[5] = min_vtx_hexa(x, y-1, z, level, geofrm); vtx[6] = min_vtx_hexa(x, y, z, level, geofrm); vtx[7] = min_vtx_hexa(x-1, y, z, level, geofrm); break; case 1 : if (is_refined(x, y-1,z-1,level) || is_refined(x+1,y-1,z-1,level) || is_refined(x+1,y, z-1,level) || is_refined(x, y, z-1,level) || is_refined(x, y-1,z, level) || is_refined(x+1,y-1,z, level) || is_refined(x+1,y, z, level) || is_refined(x, y, z, level)) return 0; vtx[0] = min_vtx_hexa(x, y-1, z-1, level, geofrm); vtx[1] = min_vtx_hexa(x+1, y-1, z-1, level, geofrm); vtx[2] = min_vtx_hexa(x+1, y, z-1, level, geofrm); vtx[3] = min_vtx_hexa(x, y, z-1, level, geofrm); vtx[4] = min_vtx_hexa(x, y-1, z, level, geofrm); vtx[5] = min_vtx_hexa(x+1, y-1, z, level, geofrm); vtx[6] = min_vtx_hexa(x+1, y, z, level, geofrm); vtx[7] = min_vtx_hexa(x, y, z, level, geofrm); break; case 2 : if (is_refined(x, y-1,z, level) || is_refined(x+1,y-1,z, level) || is_refined(x+1,y, z, level) || is_refined(x, y, z, level) || is_refined(x, y-1,z+1,level) || is_refined(x+1,y-1,z+1,level) || is_refined(x+1,y, z+1,level) || is_refined(x, y, z+1,level)) return 0; vtx[0] = min_vtx_hexa(x, y-1, z, level, geofrm); vtx[1] = min_vtx_hexa(x+1, y-1, z, level, geofrm); vtx[2] = min_vtx_hexa(x+1, y, z, level, geofrm); vtx[3] = min_vtx_hexa(x, y, z, level, geofrm); vtx[4] = min_vtx_hexa(x, y-1, z+1, level, geofrm); vtx[5] = min_vtx_hexa(x+1, y-1, z+1, level, geofrm); vtx[6] = min_vtx_hexa(x+1, y, z+1, level, geofrm); vtx[7] = min_vtx_hexa(x, y, z+1, level, geofrm); break; case 3 : if (is_refined(x-1,y-1,z, level) || is_refined(x, y-1,z, level) || is_refined(x, y, z, level) || is_refined(x-1,y, z, level) || is_refined(x-1,y-1,z+1,level) || is_refined(x, y-1,z+1,level) || is_refined(x, y, z+1,level) || is_refined(x-1,y, z+1,level)) return 0; vtx[0] = min_vtx_hexa(x-1, y-1, z, level, geofrm); vtx[1] = min_vtx_hexa(x, y-1, z, level, geofrm); vtx[2] = min_vtx_hexa(x, y, z, level, geofrm); vtx[3] = min_vtx_hexa(x-1, y, z, level, geofrm); vtx[4] = min_vtx_hexa(x-1, y-1, z+1, level, geofrm); vtx[5] = min_vtx_hexa(x, y-1, z+1, level, geofrm); vtx[6] = min_vtx_hexa(x, y, z+1, level, geofrm); vtx[7] = min_vtx_hexa(x-1, y, z+1, level, geofrm); break; case 4 : if (is_refined(x-1,y, z-1,level) || is_refined(x, y, z-1,level) || is_refined(x, y+1,z-1,level) || is_refined(x-1,y+1,z-1,level) || is_refined(x-1,y, z, level) || is_refined(x, y, z, level) || is_refined(x, y+1,z, level) || is_refined(x-1,y+1,z, level)) return 0; vtx[0] = min_vtx_hexa(x-1, y, z-1, level, geofrm); vtx[1] = min_vtx_hexa(x, y, z-1, level, geofrm); vtx[2] = min_vtx_hexa(x, y+1, z-1, level, geofrm); vtx[3] = min_vtx_hexa(x-1, y+1, z-1, level, geofrm); vtx[4] = min_vtx_hexa(x-1, y, z, level, geofrm); vtx[5] = min_vtx_hexa(x, y, z, level, geofrm); vtx[6] = min_vtx_hexa(x, y+1, z, level, geofrm); vtx[7] = min_vtx_hexa(x-1, y+1, z, level, geofrm); break; case 5 : if (is_refined(x, y, z-1,level) || is_refined(x+1,y, z-1,level) || is_refined(x+1,y+1,z-1,level) || is_refined(x, y+1,z-1,level) || is_refined(x, y, z, level) || is_refined(x+1,y, z, level) || is_refined(x+1,y+1,z, level) || is_refined(x, y+1,z, level)) return 0; vtx[0] = min_vtx_hexa(x, y, z-1, level, geofrm); vtx[1] = min_vtx_hexa(x+1, y, z-1, level, geofrm); vtx[2] = min_vtx_hexa(x+1, y+1, z-1, level, geofrm); vtx[3] = min_vtx_hexa(x, y+1, z-1, level, geofrm); vtx[4] = min_vtx_hexa(x, y, z, level, geofrm); vtx[5] = min_vtx_hexa(x+1, y, z, level, geofrm); vtx[6] = min_vtx_hexa(x+1, y+1, z, level, geofrm); vtx[7] = min_vtx_hexa(x, y+1, z, level, geofrm); break; case 6 : if (is_refined(x, y, z, level) || is_refined(x+1,y, z, level) || is_refined(x+1,y+1,z, level) || is_refined(x, y+1,z, level) || is_refined(x, y, z+1,level) || is_refined(x+1,y, z+1,level) || is_refined(x+1,y+1,z+1,level) || is_refined(x, y+1,z+1,level)) return 0; vtx[0] = min_vtx_hexa(x, y, z, level, geofrm); vtx[1] = min_vtx_hexa(x+1, y, z, level, geofrm); vtx[2] = min_vtx_hexa(x+1, y+1, z, level, geofrm); vtx[3] = min_vtx_hexa(x, y+1, z, level, geofrm); vtx[4] = min_vtx_hexa(x, y, z+1, level, geofrm); vtx[5] = min_vtx_hexa(x+1, y, z+1, level, geofrm); vtx[6] = min_vtx_hexa(x+1, y+1, z+1, level, geofrm); vtx[7] = min_vtx_hexa(x, y+1, z+1, level, geofrm); break; case 7 : if (is_refined(x-1,y, z, level) || is_refined(x, y, z, level) || is_refined(x, y+1,z, level) || is_refined(x-1,y+1,z, level) || is_refined(x-1,y, z+1,level) || is_refined(x, y, z+1,level) || is_refined(x, y+1,z+1,level) || is_refined(x-1,y+1,z+1,level)) return 0; vtx[0] = min_vtx_hexa(x-1, y, z, level, geofrm); vtx[1] = min_vtx_hexa(x, y, z, level, geofrm); vtx[2] = min_vtx_hexa(x, y+1, z, level, geofrm); vtx[3] = min_vtx_hexa(x-1, y+1, z, level, geofrm); vtx[4] = min_vtx_hexa(x-1, y, z+1, level, geofrm); vtx[5] = min_vtx_hexa(x, y, z+1, level, geofrm); vtx[6] = min_vtx_hexa(x, y+1, z+1, level, geofrm); vtx[7] = min_vtx_hexa(x-1, y+1, z+1, level, geofrm); break; } if( vtx[0] >= 0 && vtx[1] >= 0 && vtx[2] >= 0 && vtx[3] >= 0 && vtx[4] >= 0 && vtx[5] >= 0 && vtx[6] >= 0 && vtx[7] >= 0 ) return 1; else return 0; } int Octree::min_vtx_hexa(int x, int y, int z, int level, geoframe& geofrm) { int oc_id, cell_size, tx, ty, tz, vert; unsigned int center; float vtx[3], norm[3]; tx = x; ty = y; tz = z; assert( tx >= 0 && ty >= 0 && tz >= 0 ); //assert( !is_refined(tx,ty,tz,level) ); while ( level == 0 || !is_refined(tx/2 , ty/2 , tz/2 , level-1 )) { tx /= 2; ty /= 2; tz /= 2; level--; } x = tx; y = ty; z = tz; oc_id = xyz2octcell(x, y, z, level); cell_size = (dim[0]-1)/(1< dim[0]-1 || y > dim[1]-1 || z > dim[2]-1) return -1; else if(minmax[oc_id].max <= iso_val) { if ((center = vtx_idx_arr[oc_id]) == -1) { add_middle_vertex(x, y, z, 0.5, 0.5, 0.5, cell_size, center, geofrm); vtx_idx_arr[oc_id] = center; return center; } else return center; } else { get_vtx(x, y, z, level, vtx); //getVertGrad(x*cell_size, y*cell_size, z*cell_size, norm); get_VtxNorm(vtx, norm); if ((vert = vtx_idx_arr[oc_id]) == -1) { vert = geofrm.AddVert(vtx, norm); geofrm.AddBound(vert, 1); vtx_idx_arr[oc_id] = vert; return vert; } else return vert; } } void Octree::add_hexa(geoframe& geofrm, unsigned int* vtx) { unsigned int my_vtx[4]; my_vtx[0] = vtx[0]; my_vtx[1] = vtx[3]; my_vtx[2] = vtx[7]; my_vtx[3] = vtx[4]; geofrm.AddQuad(my_vtx, 4); my_vtx[0] = vtx[2]; my_vtx[1] = vtx[1]; my_vtx[2] = vtx[5]; my_vtx[3] = vtx[6]; geofrm.AddQuad(my_vtx, 4); my_vtx[0] = vtx[0]; my_vtx[1] = vtx[4]; my_vtx[2] = vtx[5]; my_vtx[3] = vtx[1]; geofrm.AddQuad(my_vtx, 4); my_vtx[0] = vtx[3]; my_vtx[1] = vtx[2]; my_vtx[2] = vtx[6]; my_vtx[3] = vtx[7]; geofrm.AddQuad(my_vtx, 4); my_vtx[0] = vtx[0]; my_vtx[1] = vtx[1]; my_vtx[2] = vtx[2]; my_vtx[3] = vtx[3]; geofrm.AddQuad(my_vtx, 4); my_vtx[0] = vtx[4]; my_vtx[1] = vtx[7]; my_vtx[2] = vtx[6]; my_vtx[3] = vtx[5]; geofrm.AddQuad(my_vtx, 4); geofrm.numhexas++; } void Octree::find_oc_id_hexa(int x, int y, int z, int level, int j, int* oc_id) { oc_id[0] = xyz2octcell(x, y, z, level); switch (j) { case 0 : oc_id[0] = xyz2octcell(x-1, y-1, z-1, level); oc_id[1] = xyz2octcell(x, y-1, z-1, level); oc_id[2] = xyz2octcell(x, y, z-1, level); oc_id[3] = xyz2octcell(x-1, y, z-1, level); oc_id[4] = xyz2octcell(x-1, y-1, z, level); oc_id[5] = xyz2octcell(x, y-1, z, level); oc_id[6] = xyz2octcell(x, y, z, level); oc_id[7] = xyz2octcell(x-1, y, z, level); break; case 1 : oc_id[0] = xyz2octcell(x, y-1, z-1, level); oc_id[1] = xyz2octcell(x+1, y-1, z-1, level); oc_id[2] = xyz2octcell(x+1, y, z-1, level); oc_id[3] = xyz2octcell(x, y, z-1, level); oc_id[4] = xyz2octcell(x, y-1, z, level); oc_id[5] = xyz2octcell(x+1, y-1, z, level); oc_id[6] = xyz2octcell(x+1, y, z, level); oc_id[7] = xyz2octcell(x, y, z, level); break; case 2 : oc_id[0] = xyz2octcell(x, y-1, z, level); oc_id[1] = xyz2octcell(x+1, y-1, z, level); oc_id[2] = xyz2octcell(x+1, y, z, level); oc_id[3] = xyz2octcell(x, y, z, level); oc_id[4] = xyz2octcell(x, y-1, z+1, level); oc_id[5] = xyz2octcell(x+1, y-1, z+1, level); oc_id[6] = xyz2octcell(x+1, y, z+1, level); oc_id[7] = xyz2octcell(x, y, z+1, level); break; case 3 : oc_id[0] = xyz2octcell(x-1, y-1, z, level); oc_id[1] = xyz2octcell(x, y-1, z, level); oc_id[2] = xyz2octcell(x, y, z, level); oc_id[3] = xyz2octcell(x-1, y, z, level); oc_id[4] = xyz2octcell(x-1, y-1, z+1, level); oc_id[5] = xyz2octcell(x, y-1, z+1, level); oc_id[6] = xyz2octcell(x, y, z+1, level); oc_id[7] = xyz2octcell(x-1, y, z+1, level); break; case 4 : oc_id[0] = xyz2octcell(x-1, y, z-1, level); oc_id[1] = xyz2octcell(x, y, z-1, level); oc_id[2] = xyz2octcell(x, y+1, z-1, level); oc_id[3] = xyz2octcell(x-1, y+1, z-1, level); oc_id[4] = xyz2octcell(x-1, y, z, level); oc_id[5] = xyz2octcell(x, y, z, level); oc_id[6] = xyz2octcell(x, y+1, z, level); oc_id[7] = xyz2octcell(x-1, y+1, z, level); break; case 5 : oc_id[0] = xyz2octcell(x, y, z-1, level); oc_id[1] = xyz2octcell(x+1, y, z-1, level); oc_id[2] = xyz2octcell(x+1, y+1, z-1, level); oc_id[3] = xyz2octcell(x, y+1, z-1, level); oc_id[4] = xyz2octcell(x, y, z, level); oc_id[5] = xyz2octcell(x+1, y, z, level); oc_id[6] = xyz2octcell(x+1, y+1, z, level); oc_id[7] = xyz2octcell(x, y+1, z, level); break; case 6 : oc_id[0] = xyz2octcell(x, y, z, level); oc_id[1] = xyz2octcell(x+1, y, z, level); oc_id[2] = xyz2octcell(x+1, y+1, z, level); oc_id[3] = xyz2octcell(x, y+1, z, level); oc_id[4] = xyz2octcell(x, y, z+1, level); oc_id[5] = xyz2octcell(x+1, y, z+1, level); oc_id[6] = xyz2octcell(x+1, y+1, z+1, level); oc_id[7] = xyz2octcell(x, y+1, z+1, level); break; case 7 : oc_id[0] = xyz2octcell(x-1, y, z, level); oc_id[1] = xyz2octcell(x, y, z, level); oc_id[2] = xyz2octcell(x, y+1, z, level); oc_id[3] = xyz2octcell(x-1, y+1, z, level); oc_id[4] = xyz2octcell(x-1, y, z+1, level); oc_id[5] = xyz2octcell(x, y, z+1, level); oc_id[6] = xyz2octcell(x, y+1, z+1, level); oc_id[7] = xyz2octcell(x-1, y+1, z+1, level); break; } } // for each interior vertex, check if which one of its 6 edges is sign change edge // decide which quad is on the boundary surface void Octree::find_edge_id_hexa(int x, int y, int z, int cell_size, int j, int* edge_id) { int tx, ty, tz, i; float val[6]; switch (j) { case 0 : tx = x; ty = y; tz = z; break; case 1 : tx = x+1; ty = y; tz = z; break; case 2 : tx = x+1; ty = y; tz = z+1; break; case 3 : tx = x; ty = y; tz = z+1; break; case 4 : tx = x; ty = y+1; tz = z; break; case 5 : tx = x+1; ty = y+1; tz = z; break; case 6 : tx = x+1; ty = y+1; tz = z+1; break; case 7 : tx = x; ty = y+1; tz = z+1; break; } val[0] = getValue(tx*cell_size, ty*cell_size, (tz-1)*cell_size); // up val[1] = getValue(tx*cell_size, ty*cell_size, (tz+1)*cell_size); // down val[2] = getValue((tx-1)*cell_size, ty*cell_size, tz*cell_size); // left val[3] = getValue((tx+1)*cell_size, ty*cell_size, tz*cell_size); // right val[4] = getValue(tx*cell_size, (ty-1)*cell_size, tz*cell_size); // front val[5] = getValue(tx*cell_size, (ty+1)*cell_size, tz*cell_size); // back for(i = 0; i < 6; i++) { if(val[i] > iso_val) edge_id[i] = 1; } } void Octree::assign_refine_sign_hexa(geoframe& geofrm, float err_tol) { int x, y, z, valid_leaf, cell_size, level, my_bool_2, my_bool_4, num_id_face; int oc_id[8], edge_id[6], i, j, k, m, num_id, refine_sign, vv[4]; unsigned int vtx[8]; float val[8]; for(i = 0; i < octcell_num; i++) vtx_idx_arr_refine[i] = -1; for(i = 0; i < leaf_num; i++) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; cell_size = (dim[0]-1)/(1< err_tol) { num_id++; //vtx_idx_arr_refine[oc_id[k]] = 1; } } if(num_id > 0) {// > 3 //for(k = 0; k < 8; k++) vtx_idx_arr_refine[oc_id[k]] = 1; for(k = 0; k < 8; k++) { if(get_err_grad(oc_id[k]) > err_tol) vtx_idx_arr_refine[oc_id[k]] = 1; } } } } } // end j } // end i vflag_clear(); refine_sign = 1; while(refine_sign == 1) { refine_sign = 0; for (i = 0; i < leaf_num; i++ ) { valid_leaf = cut_array[i] ; level = get_level(valid_leaf) ; cell_size = (dim[0]-1)/(1< #include #include #include "octree.h" #include "geoframe.h" #include "mydrawer.h" #define DEFAULT_ERR 0.0001f //99.99f //0.0001f #define DEFAULT_ERR_IN 0.0001f #define DEFAULT_IVAL -0.0001f //-0.5000f //-0.0001f //-1.0331 0.0001 #define DEFAULT_IVAL_IN -9.5001f //10.000f #define SINGLE 0 #define HEXA 1 #define DOUBLE 2 #define TETRA 3 #define T_4_H 4 #define TETRA2 5 using namespace std; //typedef vector > FloatArray; //typedef vector > IntArray; class LBIE_Mesher{ public : LBIE_Mesher(const char*); LBIE_Mesher(); LBIE_Mesher(const char*, const char* , float , float, float, float , int ); ~LBIE_Mesher(); Octree oc; MyDrawer drawer; void inputData(const unsigned char *data, int dims[3], unsigned int numVerts, unsigned int numCells, float origin[3] = NULL, float spans[3] = NULL); void fileOpen( const char* ); void fileSave( const char* ); void setMesh( int ); void errorChange( float ); void errorChange_in( float ); void isovalueChange( float ); void isovalueChange_in( float ); void outTriangle( float outverts[][3], int outfaces[][3]); void outTetra(float outverts[][3], int outfaces[][4]); void outHexa(float outverts[][3], int outfaces[][8]); void outQuad( float outverts[][3], int outfaces[][4]); int getNumFaces(); int getNumVerts(); float getVolMin(); float getVolMax(); void getOuterSurface(IntArray *newfaces); void setXCutPlane(float plane_x); void setZCutPlane(float plane_z); void getSurface(IntArray *newfaces, FloatArray * vertset, int crossection = 0); private : void saveTriangle( const char* ); void saveTetra( const char* ); void saveHexa( const char* ); void saveQuad( const char* ); float l_err; float l_err_in; float dist_level; int fopen_flag; char fname_buf[100]; float isovalue; float isovalue_in; int dual_flag; int numFrames; double biggestDim; double centerx, centery, centerz; int meshtype; float iso_inner,iso_outer,inner_err_tol,outer_err_tol; geoframe* g_frames; }; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/LBIE_Mesher.cpp0000755000175000017500000004560411112570406024573 0ustar debiandebian#include #include #include #include #include "LBIE_Mesher.h" #include "octree.h" #include "geoframe.h" #include "mydrawer.h" using namespace std; //constructor 1 : initializes a mesher for volumetric data (input - .rawiv file) // sets iso values and error tolerance values, computes the mesh and // writes vertices and faces into an output file (output - .raw) LBIE_Mesher::LBIE_Mesher( const char* input, const char* output, float in_iso_outer, float in_iso_inner, float in_error_outer, float in_error_inner, int in_meshtype ){ cout<< "input file is "<g_frames[c].biggestDim? biggestDim : g_frames[c].biggestDim); centerx += g_frames[c].centerx; centery += g_frames[c].centery; centerz += g_frames[c].centerz; } centerx /= numFrames; centery /= numFrames; centerz /= numFrames; ***/ } // output mesh (vertices and faces) into a file void LBIE_Mesher::fileSave( const char* filename ){ if ( meshtype == SINGLE || meshtype == DOUBLE ) { saveTriangle( filename ); } else if ( meshtype == TETRA || meshtype == TETRA2 ){ saveTetra( filename ); } else if ( meshtype == HEXA ){ saveHexa( filename ); } else if ( meshtype == T_4_H ){ saveQuad( filename ); } } // write triangle mesh into a file void LBIE_Mesher::saveTriangle( const char* filename ){ FILE* fp; fp=fopen(filename,"w"); int v0, v1, v2, nv, ntri, i; float r, a, b, c, p, sum_area, center; sum_area = 0.0; center = 64.0f/2.0f; nv=g_frames->getNVert(); ntri=g_frames->getNTri(); fprintf(fp,"%d %d\n", nv, ntri); for (i=0;iverts[i][0]-center)*(g_frames->verts[i][0]-center) + (g_frames->verts[i][1]-center)*(g_frames->verts[i][1]-center) + (g_frames->verts[i][2]-center)*(g_frames->verts[i][2]-center); fprintf(fp,"%f %f %f\n",g_frames->verts[i][0],g_frames->verts[i][1],g_frames->verts[i][2]); //fprintf(fp,"%f %f %f\n", sqrt(r)*0.3125, sqrt(r)*0.46875-10.0, fabs(sqrt(r)*0.46875-10.0)/10.0); } for (i=0;igetNTri();i++) { v0 = g_frames->triangles[i][0]; v1 = g_frames->triangles[i][1]; v2 = g_frames->triangles[i][2]; r = (g_frames->verts[v0][0]-center)*(g_frames->verts[v0][0]-center) + (g_frames->verts[v0][1]-center)*(g_frames->verts[v0][1]-center) + (g_frames->verts[v0][2]-center)*(g_frames->verts[v0][2]-center); if(sqrt(r) < 17.0) { a = sqrt((g_frames->verts[v1][0]-g_frames->verts[v0][0])*(g_frames->verts[v1][0]-g_frames->verts[v0][0]) + (g_frames->verts[v1][1]-g_frames->verts[v0][1])*(g_frames->verts[v1][1]-g_frames->verts[v0][1]) + (g_frames->verts[v1][2]-g_frames->verts[v0][2])*(g_frames->verts[v1][2]-g_frames->verts[v0][2])); b = sqrt((g_frames->verts[v2][0]-g_frames->verts[v1][0])*(g_frames->verts[v2][0]-g_frames->verts[v1][0]) + (g_frames->verts[v2][1]-g_frames->verts[v1][1])*(g_frames->verts[v2][1]-g_frames->verts[v1][1]) + (g_frames->verts[v2][2]-g_frames->verts[v1][2])*(g_frames->verts[v2][2]-g_frames->verts[v1][2])); c = sqrt((g_frames->verts[v0][0]-g_frames->verts[v2][0])*(g_frames->verts[v0][0]-g_frames->verts[v2][0]) + (g_frames->verts[v0][1]-g_frames->verts[v2][1])*(g_frames->verts[v0][1]-g_frames->verts[v2][1]) + (g_frames->verts[v0][2]-g_frames->verts[v2][2])*(g_frames->verts[v0][2]-g_frames->verts[v2][2])); p = (a + b + c)/2.0; sum_area += sqrt(p*(p - a)*(p - b)*(p - c)); } fprintf(fp,"%d %d %d\n",g_frames->triangles[i][0],g_frames->triangles[i][1],g_frames->triangles[i][2]); } //fprintf(fp, "area_14.5 = %f %f\n", sum_area, 4.0*3.1415926*10*10); fclose(fp); } //write tetrahedral mesh into a file void LBIE_Mesher::saveTetra( const char* filename ){ FILE* fp; fp=fopen(filename,"w"); int nv, ntri, i; float center = (129.0f-1.0f)/2.0f; nv=g_frames->getNVert(); ntri=g_frames->getNTri(); fprintf(fp,"%d %d\n",nv,ntri/4); for (i=0;iverts[i][0],g_frame->verts[i][1],g_frame->verts[i][2]); //float r = (g_frame->verts[i][0]-center)*(g_frame->verts[i][0]-center)*0.6798984*0.6798984 + // (g_frame->verts[i][1]-center)*(g_frame->verts[i][1]-center)*0.6798984*0.6798984 + // (g_frame->verts[i][2]-center)*(g_frame->verts[i][2]-center)*0.6779922*0.6779922; //fprintf(fp,"%f %f %f\n",(g_frame->verts[i][0]-center)*0.6798984*2,(g_frame->verts[i][1]-center)*0.6798984*2, // (g_frame->verts[i][2]-center)*0.6779922*2); fprintf(fp,"%f %f %f\n",(g_frames->verts[i][0]-center),(g_frames->verts[i][1]-center), (g_frames->verts[i][2]-center)); } for (i=0;itriangles[4*i][0],g_frames->triangles[4*i][1], g_frames->triangles[4*i][2], g_frames->triangles[4*i+1][2]); } fclose(fp); } //write hexahedral mesh into a file void LBIE_Mesher::saveHexa( const char* filename ){ FILE* fp; fp = fopen(filename,"w"); int nv, nquad, i; nv = g_frames->getNVert(); nquad = g_frames->getNQuad(); fprintf(fp,"%d %d\n", nv, nquad/6); for (i = 0; i < nv; i++) { //fprintf(fp,"%f %f %f %f %f %f %d\n", g_frames->verts[i][0], g_frames->verts[i][1], g_frames->verts[i][2], // g_frames->normals[i][0], g_frames->normals[i][1], g_frames->normals[i][2], g_frames->bound_sign[i]); fprintf(fp,"%f %f %f %d\n", g_frames->verts[i][0], g_frames->verts[i][1], g_frames->verts[i][2], g_frames->bound_sign[i]); } for (i = 0;i < nquad/6; i++) { fprintf(fp,"%d %d %d %d %d %d %d %d\n", g_frames->quads[6*i][0], g_frames->quads[6*i][1], g_frames->quads[6*i][2], g_frames->quads[6*i][3], g_frames->quads[6*i+1][1], g_frames->quads[6*i+1][0], g_frames->quads[6*i+1][3], g_frames->quads[6*i+1][2]); } fclose(fp); } // write quads into a file void LBIE_Mesher::saveQuad( const char* filename ){ FILE* fp; fp = fopen(filename,"w"); int nv, nquad, i; nv=g_frames->getNVert(); nquad=g_frames->getNQuad(); // Output 4-node quad element fprintf(fp,"%d %d\n", nv, nquad); for (i = 0; i < nv; i++) { fprintf(fp,"%f %f %f\n", g_frames->verts[i][0], g_frames->verts[i][1], g_frames->verts[i][2]); } for (i = 0; i < g_frames->getNQuad(); i++) { fprintf(fp,"%d %d %d %d\n", g_frames->quads[i][0], g_frames->quads[i][1], g_frames->quads[i][2], g_frames->quads[i][3]); } fclose(fp); } //output vertices an faces of mesh triangles void LBIE_Mesher::outTriangle( float outverts[][3], int outfaces[][3] ) { int nv, ntri, i; nv=g_frames->getNVert(); ntri=g_frames->getNTri(); for (i=0; iverts[i][0]; outverts[i][1] = g_frames->verts[i][1]; outverts[i][2] = g_frames->verts[i][2]; } for (i=0; itriangles[i][0]; outfaces[i][0] = g_frames->triangles[i][2]; outfaces[i][1] = g_frames->triangles[i][1]; //outfaces[i][2] = g_frames->triangles[i][2]; outfaces[i][2] = g_frames->triangles[i][0]; } } // output tetrahedral mesh void LBIE_Mesher::outTetra(float outverts[][3], int outfaces[][4]) { int nv, ntri, i; float center = (129.0f-1.0f)/2.0f; nv=g_frames->getNVert(); ntri=g_frames->getNTri(); for (i=0;iverts[i][0]-center; outverts[i][1] = g_frames->verts[i][1]-center; outverts[i][2] = g_frames->verts[i][2]-center; } for (i=0;itriangles[4*i][0]; outfaces[i][1] = g_frames->triangles[4*i][1]; outfaces[i][2] = g_frames->triangles[4*i][2]; outfaces[i][3] = g_frames->triangles[4*i+1][2]; } } //output hexahedral mesh void LBIE_Mesher::outHexa(float outverts[][3], int outfaces[][8]) { int nv, nquad, i; nv = g_frames->getNVert(); nquad = g_frames->getNQuad(); for (i = 0; i < nv; i++) { outverts[i][0] = g_frames->verts[i][0]; outverts[i][1] = g_frames->verts[i][1]; outverts[i][2] = g_frames->verts[i][2]; } for (i = 0;i < nquad/6; i++) { outfaces[i][0]= g_frames->quads[6*i][0]; outfaces[i][1]= g_frames->quads[6*i][1]; outfaces[i][2]= g_frames->quads[6*i][2]; outfaces[i][3]= g_frames->quads[6*i][3]; outfaces[i][4]= g_frames->quads[6*i+1][1]; outfaces[i][5]= g_frames->quads[6*i+1][0]; outfaces[i][6]= g_frames->quads[6*i+1][3]; outfaces[i][7]= g_frames->quads[6*i+1][2]; } } //output vertices and faces of quadrilateral mesh void LBIE_Mesher::outQuad( float outverts[][3], int outfaces[][4]) { int nv, nquad, i; nv=g_frames->getNVert(); nquad=g_frames->getNQuad(); // Output 4-node quad element for (i = 0; i < nv; i++) { outverts[i][0] = g_frames->verts[i][0]; outverts[i][1] = g_frames->verts[i][1]; outverts[i][2] = g_frames->verts[i][2]; } for (i = 0; i < nquad; i++) { /** outfaces[i][0] = g_frames->quads[i][0]; outfaces[i][1] = g_frames->quads[i][1]; outfaces[i][2] = g_frames->quads[i][2]; outfaces[i][3] = g_frames->quads[i][3]; **/ outfaces[i][0] = g_frames->quads[i][3]; outfaces[i][1] = g_frames->quads[i][2]; outfaces[i][2] = g_frames->quads[i][1]; outfaces[i][3] = g_frames->quads[i][0]; } } int LBIE_Mesher::getNumFaces() { if ( meshtype == SINGLE || meshtype == DOUBLE ) return g_frames->getNTri(); else if ( meshtype == TETRA || meshtype == TETRA2 ) return g_frames->getNTri()/4; else if ( meshtype == HEXA ) return g_frames->getNQuad()/6; else if ( meshtype == T_4_H ) return g_frames->getNQuad(); } int LBIE_Mesher::getNumVerts() { return g_frames->getNVert(); } //return maximum value of the volumetric data float LBIE_Mesher::getVolMax() { return oc.vol_max; } //return minimum value of the volumetric data float LBIE_Mesher::getVolMin() { return oc.vol_min; } //return outer faces of tetrahedral or hexahedral meshes void LBIE_Mesher:: getOuterSurface(IntArray *newfaces) { float norm[3]; int face[3], vert, my_bool, my_bool_0, c, num_tri; num_tri = 0; //vector v; vector f; if (g_frames->numtris ) { for (c = 0; c < g_frames->numtris; c++) { my_bool = (g_frames->bound_sign[g_frames->triangles[c][0]] == 1) && (g_frames->bound_sign[g_frames->triangles[c][1]] == 1) && (g_frames->bound_sign[g_frames->triangles[c][2]] == 1); my_bool_0 = (g_frames->bound_sign[g_frames->triangles[c][0]] == -1) && (g_frames->bound_sign[g_frames->triangles[c][1]] == -1) && (g_frames->bound_sign[g_frames->triangles[c][2]] == -1); if(my_bool || my_bool_0) { num_tri = num_tri +1; for(int i = 0; i < 3; i++) { vert = g_frames->triangles[c][i]; face[i] = vert; norm[0] = g_frames->normals[vert][0]; norm[1] = g_frames->normals[vert][1]; norm[2] = g_frames->normals[vert][2]; //v.push_back(g_frames->verts[vert][0]); //v.push_back(g_frames->verts[vert][1]); //v.push_back(g_frames->verts[vert][2]); //f.push_back(vert); } f.push_back(face[2]); f.push_back(face[1]); f.push_back(face[0]); newfaces->push_back(f); f.clear(); //v.clear(); } } } //if (g_frames->numtris ) else { for (c=0; cnumquads; c++) { my_bool = abs((int)g_frames->bound_sign[g_frames->quads[c][0]]) == 1 && abs((int)g_frames->bound_sign[g_frames->quads[c][1]]) == 1 && abs((int)g_frames->bound_sign[g_frames->quads[c][2]]) == 1 && abs((int)g_frames->bound_sign[g_frames->quads[c][3]]) == 1; if(my_bool) { f.push_back(g_frames->quads[c][3]); f.push_back(g_frames->quads[c][2]); f.push_back(g_frames->quads[c][1]); f.push_back(g_frames->quads[c][0]); newfaces->push_back(f); f.clear(); } } } //else } void LBIE_Mesher::setXCutPlane(float planex) { drawer.setPlaneX(planex); } void LBIE_Mesher::setZCutPlane(float planez) { drawer.setPlaneZ(planez); } void LBIE_Mesher:: getSurface(IntArray *newfaces, FloatArray * vertset, int crossection ) { drawer.setCutting(crossection); drawer.setGeo(g_frames); drawer.display(newfaces, vertset); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/geoframe.h0000755000175000017500000021115310162372464024011 0ustar debiandebian#ifndef __GEOFRAME_H__ #define __GEOFRAME_H__ #include #include #include #include #define GRAD class geoframe { public: geoframe(); ~geoframe(); void Clear() { numtris=0; numverts=0; numquads=0; numhexas = 0;} int getNTri(void) { return numtris; } int getNQuad(void) { return numquads; } int getNHexa(void) { return numhexas; } int getNVert(void) { return numverts; } int TestNum(unsigned int* v) { int i; float dis_0, dis_1, dis_2, dis_3; dis_0 = 0.0; dis_1 = 0.0; dis_2 = 0.0; dis_3 = 0.0; for(i = 0; i < 3; i++) { dis_0 += (verts[v[1]][i] - verts[v[0]][i])*(verts[v[1]][i] - verts[v[0]][i]); dis_1 += (verts[v[2]][i] - verts[v[1]][i])*(verts[v[2]][i] - verts[v[1]][i]); dis_2 += (verts[v[3]][i] - verts[v[2]][i])*(verts[v[3]][i] - verts[v[2]][i]); dis_3 += (verts[v[0]][i] - verts[v[3]][i])*(verts[v[0]][i] - verts[v[3]][i]); } dis_0 = (float)sqrt(dis_0); dis_1 = (float)sqrt(dis_1); dis_2 = (float)sqrt(dis_2); dis_3 = (float)sqrt(dis_3); if(dis_0 == 0.0 || dis_1 == 0.0) { //v[1] = v[2]; v[2] = v[3]; num_tris++; return 3; } else if(dis_2 == 0.0 || dis_3 == 0.0) { //v[3] = v[1]; v[1] = v[2]; v[2] = v[3]; num_tris++; return 3; } else return 4; } int AddQuad(unsigned int* v , int num) { assert (num==3 || num==4); num = TestNum(v); num = 4; if (numquads >= qsize) { qsize<<=1; quads = (unsigned int (*)[4])realloc(quads, sizeof(unsigned int[4]) * qsize); } if (num == 4) { quads[numquads][0] = v[0]; quads[numquads][1] = v[1]; quads[numquads][2] = v[2]; quads[numquads][3] = v[3]; return numquads++; } else { // (num==3) triangles[numtris][0] = v[0]; triangles[numtris][1] = v[1]; triangles[numtris][2] = v[2]; return numtris++; } } void AddQuad_indirect(unsigned int* v) { float pv[3], pv0[3], pv1[3], pv2[3], pv3[3]; float nv[3], nv0[3], nv1[3], nv2[3], nv3[3]; int i; unsigned int v_new[5], v_quad[4]; for(i = 0; i < 3; i++) { pv0[i] = (verts[v[0]][i] + verts[v[1]][i]) / 2.0f; pv1[i] = (verts[v[1]][i] + verts[v[2]][i]) / 2.0f; pv2[i] = (verts[v[2]][i] + verts[v[3]][i]) / 2.0f; pv3[i] = (verts[v[3]][i] + verts[v[0]][i]) / 2.0f; nv0[i] = (normals[v[0]][i] + normals[v[1]][i]) / 2.0f; nv1[i] = (normals[v[1]][i] + normals[v[2]][i]) / 2.0f; nv2[i] = (normals[v[2]][i] + normals[v[3]][i]) / 2.0f; nv3[i] = (normals[v[3]][i] + normals[v[0]][i]) / 2.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); if(v[0] == v[1]) { for(i = 0; i < 3; i++) { pv[i] = (verts[v[0]][i] + 2.0f*verts[v_new[2]][i]) / 3.0f; nv[i] = (normals[v[0]][i] + 2.0f*normals[v_new[2]][i]) / 3.0f; } v_new[4] = AddVert(pv, nv); AddBound(v_new[4], 1); v_quad[0] = v[0]; v_quad[1] = v_new[1]; v_quad[2] = v_new[4]; v_quad[3] = v_new[3]; AddQuad(v_quad, 4); v_quad[0] = v[2]; v_quad[1] = v_new[2]; v_quad[2] = v_new[4]; v_quad[3] = v_new[1]; AddQuad(v_quad, 4); v_quad[0] = v[3]; v_quad[1] = v_new[3]; v_quad[2] = v_new[4]; v_quad[3] = v_new[2]; AddQuad(v_quad, 4); } else if(v[1] == v[2]) { for(i = 0; i < 3; i++) { pv[i] = (verts[v[1]][i] + 2.0f*verts[v_new[3]][i]) / 3.0f; nv[i] = (normals[v[1]][i] + 2.0f*normals[v_new[3]][i]) / 3.0f; } v_new[4] = AddVert(pv, nv); AddBound(v_new[4], 1); v_quad[0] = v[0]; v_quad[1] = v_new[0]; v_quad[2] = v_new[4]; v_quad[3] = v_new[3]; AddQuad(v_quad, 4); v_quad[0] = v[1]; v_quad[1] = v_new[2]; v_quad[2] = v_new[4]; v_quad[3] = v_new[0]; AddQuad(v_quad, 4); v_quad[0] = v[3]; v_quad[1] = v_new[3]; v_quad[2] = v_new[4]; v_quad[3] = v_new[2]; AddQuad(v_quad, 4); } else if(v[2] == v[3]) { for(i = 0; i < 3; i++) { pv[i] = (verts[v[2]][i] + 2.0f*verts[v_new[0]][i]) / 3.0f; nv[i] = (normals[v[2]][i] + 2.0f*normals[v_new[0]][i]) / 3.0f; } v_new[4] = AddVert(pv, nv); AddBound(v_new[4], 1); v_quad[0] = v[0]; v_quad[1] = v_new[0]; v_quad[2] = v_new[4]; v_quad[3] = v_new[3]; AddQuad(v_quad, 4); v_quad[0] = v[1]; v_quad[1] = v_new[1]; v_quad[2] = v_new[4]; v_quad[3] = v_new[0]; AddQuad(v_quad, 4); v_quad[0] = v[2]; v_quad[1] = v_new[3]; v_quad[2] = v_new[4]; v_quad[3] = v_new[1]; AddQuad(v_quad, 4); } else if(v[3] == v[0]) { for(i = 0; i < 3; i++) { pv[i] = (verts[v[0]][i] + 2.0f*verts[v_new[1]][i]) / 3.0f; nv[i] = (normals[v[0]][i] + 2.0f*normals[v_new[1]][i]) / 3.0f; } v_new[4] = AddVert(pv, nv); AddBound(v_new[4], 1); v_quad[0] = v[0]; v_quad[1] = v_new[0]; v_quad[2] = v_new[4]; v_quad[3] = v_new[2]; AddQuad(v_quad, 4); v_quad[0] = v[1]; v_quad[1] = v_new[1]; v_quad[2] = v_new[4]; v_quad[3] = v_new[0]; AddQuad(v_quad, 4); v_quad[0] = v[2]; v_quad[1] = v_new[2]; v_quad[2] = v_new[4]; v_quad[3] = v_new[1]; AddQuad(v_quad, 4); } else { for(i = 0; i < 3; i++) { pv[i] = (verts[v[0]][i] + verts[v[1]][i] + verts[v[2]][i] + verts[v[3]][i]) / 4.0f; nv[i] = (normals[v[0]][i] + normals[v[1]][i] + normals[v[2]][i] + normals[v[3]][i]) / 4.0f; } v_new[4] = AddVert(pv, nv); AddBound(v_new[4], 1); v_quad[0] = v[0]; v_quad[1] = v_new[0]; v_quad[2] = v_new[4]; v_quad[3] = v_new[3]; AddQuad(v_quad, 4); v_quad[0] = v[1]; v_quad[1] = v_new[1]; v_quad[2] = v_new[4]; v_quad[3] = v_new[0]; AddQuad(v_quad, 4); v_quad[0] = v[2]; v_quad[1] = v_new[2]; v_quad[2] = v_new[4]; v_quad[3] = v_new[1]; AddQuad(v_quad, 4); v_quad[0] = v[3]; v_quad[1] = v_new[3]; v_quad[2] = v_new[4]; v_quad[3] = v_new[2]; AddQuad(v_quad, 4); } } void AddVert_adaptive(unsigned int* v , unsigned int* v_new) { float pv[3], pv0[3], pv1[3], pv2[3], pv3[3]; float nv[3], nv0[3], nv1[3], nv2[3], nv3[3]; int i; for(i = 0; i < 3; i++) { pv[i] = (verts[v[0]][i] + verts[v[1]][i] + verts[v[2]][i] + verts[v[3]][i]) / 4.0f; pv0[i] = (verts[v[0]][i] + 2.0f*pv[i]) / 3.0f; pv1[i] = (verts[v[1]][i] + 2.0f*pv[i]) / 3.0f; pv2[i] = (verts[v[2]][i] + 2.0f*pv[i]) / 3.0f; pv3[i] = (verts[v[3]][i] + 2.0f*pv[i]) / 3.0f; nv[i] = (normals[v[0]][i] + normals[v[1]][i] + normals[v[2]][i] + normals[v[3]][i]) / 4.0f; nv0[i] = (normals[v[0]][i] + 2.0f*nv[i]) / 3.0f; nv1[i] = (normals[v[1]][i] + 2.0f*nv[i]) / 3.0f; nv2[i] = (normals[v[2]][i] + 2.0f*nv[i]) / 3.0f; nv3[i] = (normals[v[3]][i] + 2.0f*nv[i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); } void AddQuad_adaptive(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[4], v_quad[4]; int i; for(i = 0; i < 4; i++) vv[i] = v_new[i]; v_quad[0] = v[0]; v_quad[1] = v[1]; v_quad[2] = vv[1]; v_quad[3] = vv[0]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = v[2]; v_quad[2] = vv[2]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = v[3]; v_quad[2] = vv[3]; v_quad[3] = vv[2]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = v[0]; v_quad[2] = vv[0]; v_quad[3] = vv[3]; AddQuad(v_quad, num); v_quad[0] = vv[0]; v_quad[1] = vv[1]; v_quad[2] = vv[2]; v_quad[3] = vv[3]; AddQuad(v_quad, num); } void AddVert_adaptive_2_1(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3], nv5[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[1]][i] + verts[v[0]][i]) / 3.0f; pv2[i] = (pv1[i] + 2.0f*(2.0f*verts[v[2]][i] + verts[v[3]][i])/3.0f) / 3.0f; pv3[i] = (2.0f*pv0[i] + (2.0f*verts[v[3]][i] + verts[v[2]][i])/3.0f) / 3.0f; pv4[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv5[i] = (2.0f*verts[v[3]][i] + verts[v[0]][i]) / 3.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[1]][i] + normals[v[0]][i]) / 3.0f; nv2[i] = (nv1[i] + 2.0f*(2.0f*normals[v[2]][i] + normals[v[3]][i])/3.0f) / 3.0f; nv3[i] = (2.0f*nv0[i] + (2.0f*normals[v[3]][i] + normals[v[2]][i])/3.0f) / 3.0f; nv4[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv5[i] = (2.0f*normals[v[3]][i] + normals[v[0]][i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); v_new[4] = AddVert(pv4, nv4); v_new[5] = AddVert(pv5, nv5); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); AddBound(v_new[5], 1); } void AddQuad_adaptive_2_1(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[6], v_quad[4]; int i; for(i = 0; i < 6; i++) vv[i] = v_new[i]; v_quad[0] = vv[0]; v_quad[1] = vv[1]; v_quad[2] = vv[2]; v_quad[3] = vv[3]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = v[2]; v_quad[2] = vv[2]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = v[3]; v_quad[2] = vv[5]; v_quad[3] = vv[2]; AddQuad(v_quad, num); v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[3]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = vv[2]; v_quad[1] = vv[5]; v_quad[2] = vv[4]; v_quad[3] = vv[3]; AddQuad(v_quad, num); } void AddVert_adaptive_2_3(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3], pv6[3], pv7[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3], nv5[3], nv6[3], nv7[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[1]][i] + verts[v[0]][i]) / 3.0f; pv2[i] = (2.0f*verts[v[1]][i] + verts[v[2]][i]) / 3.0f; pv3[i] = (2.0f*verts[v[2]][i] + verts[v[1]][i]) / 3.0f; pv4[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv5[i] = (2.0f*verts[v[3]][i] + verts[v[0]][i]) / 3.0f; pv6[i] = (5.0f*pv1[i] + (2.0f*verts[v[2]][i] + verts[v[3]][i])/3.0f) / 6.0f; pv7[i] = (5.0f*pv0[i] + (2.0f*verts[v[3]][i] + verts[v[2]][i])/3.0f) / 6.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[1]][i] + normals[v[0]][i]) / 3.0f; nv2[i] = (2.0f*normals[v[1]][i] + normals[v[2]][i]) / 3.0f; nv3[i] = (2.0f*normals[v[2]][i] + normals[v[1]][i]) / 3.0f; nv4[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv5[i] = (2.0f*normals[v[3]][i] + normals[v[0]][i]) / 3.0f; nv6[i] = (5.0f*nv1[i] + (2.0f*normals[v[2]][i] + normals[v[3]][i])/3.0f) / 6.0f; nv7[i] = (5.0f*nv0[i] + (2.0f*normals[v[3]][i] + normals[v[2]][i])/3.0f) / 6.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); v_new[4] = AddVert(pv4, nv4); v_new[5] = AddVert(pv5, nv5); v_new[6] = AddVert(pv6, nv6); v_new[7] = AddVert(pv7, nv7); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); AddBound(v_new[5], 1); AddBound(v_new[6], 1); AddBound(v_new[7], 1); } void AddQuad_adaptive_2_3(unsigned int* v, unsigned int* v_new, int num) { unsigned int vv[8], v_quad[4]; int i; for(i = 0; i < 8; i++) vv[i] = v_new[i]; v_quad[0] = vv[0]; v_quad[1] = vv[1]; v_quad[2] = vv[6]; v_quad[3] = vv[7]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[2]; v_quad[2] = vv[6]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[7]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = vv[6]; v_quad[1] = vv[2]; v_quad[2] = vv[4]; v_quad[3] = vv[7]; AddQuad(v_quad, num); v_quad[0] = vv[2]; v_quad[1] = vv[3]; v_quad[2] = vv[5]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = v[3]; v_quad[2] = vv[5]; v_quad[3] = vv[3]; AddQuad(v_quad, num); } void AddVert_adaptive_4(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3], pv6[3], pv7[3], pv8[3], pv9[3], pv10[3], pv11[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3], nv5[3], nv6[3], nv7[3], nv8[3], nv9[3], nv10[3], nv11[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[1]][i] + verts[v[0]][i]) / 3.0f; pv2[i] = (2.0f*verts[v[1]][i] + verts[v[2]][i]) / 3.0f; pv3[i] = (2.0f*verts[v[2]][i] + verts[v[1]][i]) / 3.0f; pv4[i] = (2.0f*verts[v[2]][i] + verts[v[3]][i]) / 3.0f; pv5[i] = (2.0f*verts[v[3]][i] + verts[v[2]][i]) / 3.0f; pv6[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv7[i] = (2.0f*verts[v[3]][i] + verts[v[0]][i]) / 3.0f; pv8[i] = (2.0f*pv0[i] + pv5[i]) / 3.0f; pv9[i] = (2.0f*pv5[i] + pv0[i]) / 3.0f; pv10[i] = (2.0f*pv1[i] + pv4[i]) / 3.0f; pv11[i] = (2.0f*pv4[i] + pv1[i]) / 3.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[1]][i] + normals[v[0]][i]) / 3.0f; nv2[i] = (2.0f*normals[v[1]][i] + normals[v[2]][i]) / 3.0f; nv3[i] = (2.0f*normals[v[2]][i] + normals[v[1]][i]) / 3.0f; nv4[i] = (2.0f*normals[v[2]][i] + normals[v[3]][i]) / 3.0f; nv5[i] = (2.0f*normals[v[3]][i] + normals[v[2]][i]) / 3.0f; nv6[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv7[i] = (2.0f*normals[v[3]][i] + normals[v[0]][i]) / 3.0f; nv8[i] = (2.0f*nv0[i] + nv5[i]) / 3.0f; nv9[i] = (2.0f*nv5[i] + nv0[i]) / 3.0f; nv10[i] = (2.0f*nv1[i] + nv4[i]) / 3.0f; nv11[i] = (2.0f*nv4[i] + nv1[i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); v_new[4] = AddVert(pv4, nv4); v_new[5] = AddVert(pv5, nv5); v_new[6] = AddVert(pv6, nv6); v_new[7] = AddVert(pv7, nv7); v_new[8] = AddVert(pv8, nv8); v_new[9] = AddVert(pv9, nv9); v_new[10] = AddVert(pv10, nv10); v_new[11] = AddVert(pv11, nv11); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); AddBound(v_new[5], 1); AddBound(v_new[6], 1); AddBound(v_new[7], 1); AddBound(v_new[8], 1); AddBound(v_new[9], 1); AddBound(v_new[10], 1); AddBound(v_new[11], 1); } void AddQuad_adaptive_4(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[12], v_quad[4]; int i; for(i = 0; i < 12; i++) vv[i] = v_new[i]; v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[8]; v_quad[3] = vv[6]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[2]; v_quad[2] = vv[10]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[4]; v_quad[2] = vv[11]; v_quad[3] = vv[3]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[7]; v_quad[2] = vv[9]; v_quad[3] = vv[5]; AddQuad(v_quad, num); v_quad[0] = vv[0]; v_quad[1] = vv[1]; v_quad[2] = vv[10]; v_quad[3] = vv[8]; AddQuad(v_quad, num); v_quad[0] = vv[2]; v_quad[1] = vv[3]; v_quad[2] = vv[11]; v_quad[3] = vv[10]; AddQuad(v_quad, num); v_quad[0] = vv[4]; v_quad[1] = vv[5]; v_quad[2] = vv[9]; v_quad[3] = vv[11]; AddQuad(v_quad, num); v_quad[0] = vv[6]; v_quad[1] = vv[8]; v_quad[2] = vv[9]; v_quad[3] = vv[7]; AddQuad(v_quad, num); v_quad[0] = vv[8]; v_quad[1] = vv[10]; v_quad[2] = vv[11]; v_quad[3] = vv[9]; AddQuad(v_quad, num); } void AddVert_adaptive_3_1(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], nv0[3], nv1[3], nv2[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*pv0[i] + (2.0f*verts[v[3]][i] + verts[v[2]][i])/3.0f) / 3.0f; pv2[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*nv0[i] + (2.0f*normals[v[3]][i] + normals[v[2]][i])/3.0f) / 3.0f; nv2[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); } void AddQuad_adaptive_3_1(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[3], v_quad[4]; int i; for(i = 0; i < 3; i++) vv[i] = v_new[i]; v_quad[0] = v[1]; v_quad[1] = v[2]; v_quad[2] = vv[1]; v_quad[3] = vv[0]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = v[3]; v_quad[2] = vv[2]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[1]; v_quad[3] = vv[2]; AddQuad(v_quad, num); } void AddVert_adaptive_3_2a(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3], pv6[3], pv7[3], pv8[3], pv9[3], pv10[3], pv11[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3], nv5[3], nv6[3], nv7[3], nv8[3], nv9[3], nv10[3], nv11[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[1]][i] + verts[v[0]][i]) / 3.0f; pv2[i] = (2.0f*verts[v[1]][i] + verts[v[2]][i]) / 3.0f; pv3[i] = (2.0f*verts[v[2]][i] + verts[v[1]][i]) / 3.0f; pv4[i] = (2.0f*verts[v[2]][i] + verts[v[3]][i]) / 3.0f; pv5[i] = (2.0f*verts[v[3]][i] + verts[v[2]][i]) / 3.0f; pv6[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv7[i] = (2.0f*verts[v[3]][i] + verts[v[0]][i]) / 3.0f; pv8[i] = (2.0f*pv0[i] + pv5[i]) / 3.0f; pv9[i] = (2.0f*pv5[i] + pv0[i]) / 3.0f; pv10[i] = (2.0f*pv1[i] + pv4[i]) / 3.0f; pv11[i] = (2.0f*pv4[i] + pv1[i]) / 3.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[1]][i] + normals[v[0]][i]) / 3.0f; nv2[i] = (2.0f*normals[v[1]][i] + normals[v[2]][i]) / 3.0f; nv3[i] = (2.0f*normals[v[2]][i] + normals[v[1]][i]) / 3.0f; nv4[i] = (2.0f*normals[v[2]][i] + normals[v[3]][i]) / 3.0f; nv5[i] = (2.0f*normals[v[3]][i] + normals[v[2]][i]) / 3.0f; nv6[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv7[i] = (2.0f*normals[v[3]][i] + normals[v[0]][i]) / 3.0f; nv8[i] = (2.0f*nv0[i] + nv5[i]) / 3.0f; nv9[i] = (2.0f*nv5[i] + nv0[i]) / 3.0f; nv10[i] = (2.0f*nv1[i] + nv4[i]) / 3.0f; nv11[i] = (2.0f*nv4[i] + nv1[i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv10, nv10); v_new[4] = AddVert(pv8, nv8); v_new[5] = AddVert(pv6, nv6); v_new[6] = AddVert(pv11, nv11); v_new[7] = AddVert(pv9, nv9); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); AddBound(v_new[5], 1); AddBound(v_new[6], 1); AddBound(v_new[7], 1); } void AddQuad_adaptive_3_2a(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[8], v_quad[4]; int i; for(i = 0; i < 8; i++) vv[i] = v_new[i]; v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[4]; v_quad[3] = vv[5]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[2]; v_quad[2] = vv[3]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[6]; v_quad[2] = vv[3]; v_quad[3] = vv[2]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[5]; v_quad[2] = vv[4]; v_quad[3] = vv[7]; AddQuad(v_quad, num); v_quad[0] = vv[0]; v_quad[1] = vv[1]; v_quad[2] = vv[3]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = vv[3]; v_quad[1] = vv[6]; v_quad[2] = vv[7]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = vv[7]; v_quad[1] = vv[6]; v_quad[2] = v[2]; v_quad[3] = v[3]; AddQuad(v_quad, num); } void AddVert_adaptive_3_2b(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[2]][i] + verts[v[1]][i]) / 3.0f; pv2[i] = (2.0f*verts[v[2]][i] + verts[v[3]][i]) / 3.0f; pv3[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv4[i] = (verts[v[0]][i] + verts[v[1]][i] + verts[v[2]][i] + verts[v[3]][i]) / 4.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[2]][i] + normals[v[1]][i]) / 3.0f; nv2[i] = (2.0f*normals[v[2]][i] + normals[v[3]][i]) / 3.0f; nv3[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv4[i] = (normals[v[0]][i] + normals[v[1]][i] + normals[v[2]][i] + normals[v[3]][i]) / 43.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); v_new[4] = AddVert(pv4, nv4); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); } void AddQuad_adaptive_3_2b(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[5], v_quad[4]; int i; for(i = 0; i < 5; i++) vv[i] = v_new[i]; v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[4]; v_quad[3] = vv[3]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[1]; v_quad[2] = vv[4]; v_quad[3] = vv[0]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[2]; v_quad[2] = vv[4]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[3]; v_quad[2] = vv[4]; v_quad[3] = vv[2]; AddQuad(v_quad, num); } void AddVert_adaptive_3_3(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3], pv6[3], pv7[3], pv8[3], pv9[3], pv10[3], pv11[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3], nv5[3], nv6[3], nv7[3], nv8[3], nv9[3], nv10[3], nv11[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[1]][i] + verts[v[0]][i]) / 3.0f; pv2[i] = (2.0f*verts[v[1]][i] + verts[v[2]][i]) / 3.0f; pv3[i] = (2.0f*verts[v[2]][i] + verts[v[1]][i]) / 3.0f; pv4[i] = (2.0f*verts[v[2]][i] + verts[v[3]][i]) / 3.0f; pv5[i] = (2.0f*verts[v[3]][i] + verts[v[2]][i]) / 3.0f; pv6[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv7[i] = (2.0f*verts[v[3]][i] + verts[v[0]][i]) / 3.0f; pv8[i] = (2.0f*pv0[i] + pv5[i]) / 3.0f; pv9[i] = (2.0f*pv5[i] + pv0[i]) / 3.0f; pv10[i] = (2.0f*pv1[i] + pv4[i]) / 3.0f; pv11[i] = (2.0f*pv4[i] + pv1[i]) / 3.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[1]][i] + normals[v[0]][i]) / 3.0f; nv2[i] = (2.0f*normals[v[1]][i] + normals[v[2]][i]) / 3.0f; nv3[i] = (2.0f*normals[v[2]][i] + normals[v[1]][i]) / 3.0f; nv4[i] = (2.0f*normals[v[2]][i] + normals[v[3]][i]) / 3.0f; nv5[i] = (2.0f*normals[v[3]][i] + normals[v[2]][i]) / 3.0f; nv6[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv7[i] = (2.0f*normals[v[3]][i] + normals[v[0]][i]) / 3.0f; nv8[i] = (2.0f*nv0[i] + nv5[i]) / 3.0f; nv9[i] = (2.0f*nv5[i] + nv0[i]) / 3.0f; nv10[i] = (2.0f*nv1[i] + nv4[i]) / 3.0f; nv11[i] = (2.0f*nv4[i] + nv1[i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv1, nv1); v_new[2] = AddVert(pv2, nv2); v_new[3] = AddVert(pv3, nv3); v_new[4] = AddVert(pv4, nv4); v_new[5] = AddVert(pv11, nv11); v_new[6] = AddVert(pv6, nv6); v_new[7] = AddVert(pv10, nv10); v_new[8] = AddVert(pv8, nv8); v_new[9] = AddVert(pv9, nv9); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); AddBound(v_new[5], 1); AddBound(v_new[6], 1); AddBound(v_new[7], 1); AddBound(v_new[8], 1); AddBound(v_new[9], 1); } void AddQuad_adaptive_3_3(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[10], v_quad[4]; int i; for(i = 0; i < 10; i++) vv[i] = v_new[i]; v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[8]; v_quad[3] = vv[6]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[2]; v_quad[2] = vv[7]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[4]; v_quad[2] = vv[5]; v_quad[3] = vv[3]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[6]; v_quad[2] = vv[8]; v_quad[3] = vv[9]; AddQuad(v_quad, num); v_quad[0] = vv[0]; v_quad[1] = vv[1]; v_quad[2] = vv[7]; v_quad[3] = vv[8]; AddQuad(v_quad, num); v_quad[0] = vv[2]; v_quad[1] = vv[3]; v_quad[2] = vv[5]; v_quad[3] = vv[7]; AddQuad(v_quad, num); v_quad[0] = vv[4]; v_quad[1] = v[3]; v_quad[2] = vv[9]; v_quad[3] = vv[5]; AddQuad(v_quad, num); v_quad[0] = vv[9]; v_quad[1] = vv[8]; v_quad[2] = vv[7]; v_quad[3] = vv[5]; AddQuad(v_quad, num); } void AddVert_adaptive_4_2b(unsigned int* v , unsigned int* v_new) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3], pv6[3], pv7[3], pv8[3], pv9[3], pv10[3], pv11[3]; float nv0[3], nv1[3], nv2[3], nv3[3], nv4[3], nv5[3], nv6[3], nv7[3], nv8[3], nv9[3], nv10[3], nv11[3]; int i; for(i = 0; i < 3; i++) { pv0[i] = (2.0f*verts[v[0]][i] + verts[v[1]][i]) / 3.0f; pv1[i] = (2.0f*verts[v[1]][i] + verts[v[0]][i]) / 3.0f; pv2[i] = (2.0f*verts[v[1]][i] + verts[v[2]][i]) / 3.0f; pv3[i] = (2.0f*verts[v[2]][i] + verts[v[1]][i]) / 3.0f; pv4[i] = (2.0f*verts[v[2]][i] + verts[v[3]][i]) / 3.0f; pv5[i] = (2.0f*verts[v[3]][i] + verts[v[2]][i]) / 3.0f; pv6[i] = (2.0f*verts[v[0]][i] + verts[v[3]][i]) / 3.0f; pv7[i] = (2.0f*verts[v[3]][i] + verts[v[0]][i]) / 3.0f; pv8[i] = (2.0f*pv0[i] + pv5[i]) / 3.0f; pv9[i] = (2.0f*pv5[i] + pv0[i]) / 3.0f; pv10[i] = (2.0f*pv1[i] + pv4[i]) / 3.0f; pv11[i] = (2.0f*pv4[i] + pv1[i]) / 3.0f; nv0[i] = (2.0f*normals[v[0]][i] + normals[v[1]][i]) / 3.0f; nv1[i] = (2.0f*normals[v[1]][i] + normals[v[0]][i]) / 3.0f; nv2[i] = (2.0f*normals[v[1]][i] + normals[v[2]][i]) / 3.0f; nv3[i] = (2.0f*normals[v[2]][i] + normals[v[1]][i]) / 3.0f; nv4[i] = (2.0f*normals[v[2]][i] + normals[v[3]][i]) / 3.0f; nv5[i] = (2.0f*normals[v[3]][i] + normals[v[2]][i]) / 3.0f; nv6[i] = (2.0f*normals[v[0]][i] + normals[v[3]][i]) / 3.0f; nv7[i] = (2.0f*normals[v[3]][i] + normals[v[0]][i]) / 3.0f; nv8[i] = (2.0f*nv0[i] + nv5[i]) / 3.0f; nv9[i] = (2.0f*nv5[i] + nv0[i]) / 3.0f; nv10[i] = (2.0f*nv1[i] + nv4[i]) / 3.0f; nv11[i] = (2.0f*nv4[i] + nv1[i]) / 3.0f; } v_new[0] = AddVert(pv0, nv0); v_new[1] = AddVert(pv3, nv3); v_new[2] = AddVert(pv4, nv4); v_new[3] = AddVert(pv6, nv6); v_new[4] = AddVert(pv8, nv8); v_new[5] = AddVert(pv10, nv10); v_new[6] = AddVert(pv11, nv11); v_new[7] = AddVert(pv9, nv9); AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1); AddBound(v_new[5], 1); AddBound(v_new[6], 1); AddBound(v_new[7], 1); } void AddQuad_adaptive_4_2b(unsigned int* v , unsigned int* v_new, int num) { unsigned int vv[8], v_quad[4]; int i; for(i = 0; i < 8; i++) vv[i] = v_new[i]; v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[4]; v_quad[3] = vv[3]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[5]; v_quad[2] = vv[4]; v_quad[3] = vv[0]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[1]; v_quad[2] = vv[6]; v_quad[3] = vv[5]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[2]; v_quad[2] = vv[6]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[7]; v_quad[2] = vv[6]; v_quad[3] = vv[2]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[3]; v_quad[2] = vv[4]; v_quad[3] = vv[7]; AddQuad(v_quad, num); v_quad[0] = vv[4]; v_quad[1] = vv[5]; v_quad[2] = vv[6]; v_quad[3] = vv[7]; AddQuad(v_quad, num); } void AddQuad_hexa(unsigned int* v , int num) { float pv0[3], pv1[3], pv2[3], pv3[3], pv4[3], pv5[3], pv6[3], norm[3]; unsigned int vv[7], v_quad[4]; int i; for(i = 0; i < 3; i++) { pv0[i] = (verts[v[0]][i] + verts[v[1]][i]) / 2.0f; pv1[i] = (verts[v[1]][i] + verts[v[2]][i]) / 2.0f; pv2[i] = (verts[v[2]][i] + verts[v[3]][i]) / 2.0f; pv3[i] = (verts[v[3]][i] + verts[v[0]][i]) / 2.0f; pv4[i] = (verts[v[0]][i] + verts[v[2]][i]) / 2.0f; pv5[i] = (verts[v[0]][i] + verts[v[1]][i] + verts[v[2]][i]) / 3.0f; pv6[i] = (verts[v[0]][i] + verts[v[2]][i] + verts[v[3]][i]) / 3.0f; } vv[0] = AddVert(pv0, norm); vv[1] = AddVert(pv1, norm); vv[2] = AddVert(pv2, norm); vv[3] = AddVert(pv3, norm); vv[4] = AddVert(pv4, norm); vv[5] = AddVert(pv5, norm); vv[6] = AddVert(pv6, norm); AddBound(vv[0], 1); AddBound(vv[1], 1); AddBound(vv[2], 1); AddBound(vv[3], 1); AddBound(vv[4], 1); AddBound(vv[5], 1); AddBound(vv[6], 1); v_quad[0] = v[0]; v_quad[1] = vv[0]; v_quad[2] = vv[5]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = v[1]; v_quad[1] = vv[1]; v_quad[2] = vv[5]; v_quad[3] = vv[0]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[4]; v_quad[2] = vv[5]; v_quad[3] = vv[1]; AddQuad(v_quad, num); v_quad[0] = v[2]; v_quad[1] = vv[2]; v_quad[2] = vv[6]; v_quad[3] = vv[4]; AddQuad(v_quad, num); v_quad[0] = v[3]; v_quad[1] = vv[3]; v_quad[2] = vv[6]; v_quad[3] = vv[2]; AddQuad(v_quad, num); v_quad[0] = v[0]; v_quad[1] = vv[4]; v_quad[2] = vv[6]; v_quad[3] = vv[3]; AddQuad(v_quad, num); } void AddVert_hexa_adaptive_1_center(unsigned int* v, unsigned int* v_new) { float pv[8][3], nv[8][3], po[3], no[3]; int i, j; for(i = 0; i < 3; i++) { po[i] = 0.0f; no[i] = 0.0f; for(j = 0; j < 8; j++) { po[i] += verts[v[j]][i]; no[i] += normals[v[j]][i]; } po[i] /= 8.0f; no[i] /= 8.0f; for(j = 0; j < 8; j++) { pv[j][i] = (2.0f*po[i] + verts[v[j]][i])/3.0f; nv[j][i] = (2.0f*no[i] + normals[v[j]][i])/3.0f; //pv[j][i] = (po[i] + verts[v[j]][i])/2.0f; //nv[j][i] = (no[i] + normals[v[j]][i])/2.0f; } } for(i = 0; i < 8; i++) { for(j = 0; j < 3; j++) { po[j] = pv[i][j]; no[j] = nv[i][j]; } v_new[i] = AddVert(po, no); //AddBound(v_new[i], 1); } } void AddVert_hexa_adaptive_1_top(unsigned int* v, unsigned int* v_new) { float pv[8][3], nv[8][3], po[3], no[3]; int i, j; for(i = 0; i < 3; i++) { po[i] = 0.0f; no[i] = 0.0f; for(j = 0; j < 4; j++) { po[i] += verts[v[j]][i]; no[i] += normals[v[j]][i]; } po[i] /= 4.0f; no[i] /= 4.0f; for(j = 0; j < 4; j++) { pv[j][i] = (2.0f*po[i] + verts[v[j]][i])/3.0f; nv[j][i] = (2.0f*no[i] + normals[v[j]][i])/3.0f; } for(j = 4; j < 8; j++) { pv[j][i] = (po[i] + verts[v[j]][i])/2.0f; nv[j][i] = (no[i] + normals[v[j]][i])/2.0f; } } for(i = 0; i < 8; i++) { for(j = 0; j < 3; j++) { po[j] = pv[i][j]; no[j] = nv[i][j]; } v_new[i] = AddVert(po, no); if(i < 4) AddBound(v_new[i], 1); } } void AddVert_hexa_adaptive_2(unsigned int* v, int* edge_id, unsigned int* v_new) { float pv[64][3], nv[64][3], po[3], no[3]; int i, j; for(i = 0; i < 3; i++) { pv[0][i] = verts[v[0]][i]; pv[3][i] = verts[v[1]][i]; pv[51][i] = verts[v[5]][i]; pv[48][i] = verts[v[4]][i]; pv[12][i] = verts[v[3]][i]; pv[15][i] = verts[v[2]][i]; pv[63][i] = verts[v[6]][i]; pv[60][i] = verts[v[7]][i]; nv[0][i] = normals[v[0]][i]; nv[3][i] = normals[v[1]][i]; nv[51][i] = normals[v[5]][i]; nv[48][i] = normals[v[4]][i]; nv[12][i] = normals[v[3]][i]; nv[15][i] = normals[v[2]][i]; nv[63][i] = normals[v[6]][i]; nv[60][i] = normals[v[7]][i]; pv[16][i] = (2.0f*pv[0][i] + pv[48][i])/3.0f; pv[32][i] = (2.0f*pv[48][i] + pv[0][i])/3.0f; pv[19][i] = (2.0f*pv[3][i] + pv[51][i])/3.0f; pv[35][i] = (2.0f*pv[51][i] + pv[3][i])/3.0f; pv[28][i] = (2.0f*pv[12][i] + pv[60][i])/3.0f; pv[44][i] = (2.0f*pv[60][i] + pv[12][i])/3.0f; pv[31][i] = (2.0f*pv[15][i] + pv[63][i])/3.0f; pv[47][i] = (2.0f*pv[63][i] + pv[15][i])/3.0f; nv[16][i] = (2.0f*nv[0][i] + nv[48][i])/3.0f; nv[32][i] = (2.0f*nv[48][i] + nv[0][i])/3.0f; nv[19][i] = (2.0f*nv[3][i] + nv[51][i])/3.0f; nv[35][i] = (2.0f*nv[51][i] + nv[3][i])/3.0f; nv[28][i] = (2.0f*nv[12][i] + nv[60][i])/3.0f; nv[44][i] = (2.0f*nv[60][i] + nv[12][i])/3.0f; nv[31][i] = (2.0f*nv[15][i] + nv[63][i])/3.0f; nv[47][i] = (2.0f*nv[63][i] + nv[15][i])/3.0f; for(j = 0; j < 4; j++) { pv[4+16*j][i] = (2.0f*pv[0+16*j][i] + pv[12+16*j][i])/3.0f; pv[8+16*j][i] = (2.0f*pv[12+16*j][i] + pv[0+16*j][i])/3.0f; pv[7+16*j][i] = (2.0f*pv[3+16*j][i] + pv[15+16*j][i])/3.0f; pv[11+16*j][i] = (2.0f*pv[15+16*j][i] + pv[3+16*j][i])/3.0f; pv[1+16*j][i] = (2.0f*pv[0+16*j][i] + pv[3+16*j][i])/3.0f; pv[2+16*j][i] = (2.0f*pv[3+16*j][i] + pv[0+16*j][i])/3.0f; pv[13+16*j][i] = (2.0f*pv[12+16*j][i] + pv[15+16*j][i])/3.0f; pv[14+16*j][i] = (2.0f*pv[15+16*j][i] + pv[12+16*j][i])/3.0f; pv[5+16*j][i] = (2.0f*pv[4+16*j][i] + pv[7+16*j][i])/3.0f; pv[6+16*j][i] = (2.0f*pv[7+16*j][i] + pv[4+16*j][i])/3.0f; pv[9+16*j][i] = (2.0f*pv[8+16*j][i] + pv[11+16*j][i])/3.0f; pv[10+16*j][i] = (2.0f*pv[11+16*j][i] + pv[8+16*j][i])/3.0f; nv[4+16*j][i] = (2.0f*nv[0+16*j][i] + nv[12+16*j][i])/3.0f; nv[8+16*j][i] = (2.0f*nv[12+16*j][i] + nv[0+16*j][i])/3.0f; nv[7+16*j][i] = (2.0f*nv[3+16*j][i] + nv[15+16*j][i])/3.0f; nv[11+16*j][i] = (2.0f*nv[15+16*j][i] + nv[3+16*j][i])/3.0f; nv[1+16*j][i] = (2.0f*nv[0+16*j][i] + nv[3+16*j][i])/3.0f; nv[2+16*j][i] = (2.0f*nv[3+16*j][i] + nv[0+16*j][i])/3.0f; nv[13+16*j][i] = (2.0f*nv[12+16*j][i] + nv[15+16*j][i])/3.0f; nv[14+16*j][i] = (2.0f*nv[15+16*j][i] + nv[12+16*j][i])/3.0f; nv[5+16*j][i] = (2.0f*nv[4+16*j][i] + nv[7+16*j][i])/3.0f; nv[6+16*j][i] = (2.0f*nv[7+16*j][i] + nv[4+16*j][i])/3.0f; nv[9+16*j][i] = (2.0f*nv[8+16*j][i] + nv[11+16*j][i])/3.0f; nv[10+16*j][i] = (2.0f*nv[11+16*j][i] + nv[8+16*j][i])/3.0f; } } for(i = 0; i < 64; i++) { if(i == 0) v_new[i] = v[0]; else if(i == 3) v_new[i] = v[1]; else if(i == 51) v_new[i] = v[5]; else if(i == 48) v_new[i] = v[4]; else if(i == 12) v_new[i] = v[3]; else if(i == 15) v_new[i] = v[2]; else if(i == 63) v_new[i] = v[6]; else if(i == 60) v_new[i] = v[7]; else { for(j = 0; j < 3; j++) { po[j] = pv[i][j]; no[j] = nv[i][j]; } v_new[i] = AddVert(po, no); } if((edge_id[0] > 0) && (i < 16)) AddBound(v_new[i], 1); if((edge_id[1] > 0) && (i > 47)) AddBound(v_new[i], 1); if((edge_id[2] > 0) && ((i%4) == 0)) AddBound(v_new[i], 1); if((edge_id[3] > 0) && ((i%4) == 3)) AddBound(v_new[i], 1); if((edge_id[4] > 0) && ((i%16) < 4)) AddBound(v_new[i], 1); if((edge_id[5] > 0) && ((i%16) > 11)) AddBound(v_new[i], 1); } // define bound_edge ... for(i = 0; i < 64; i++) { if(CheckBound_edge(v_new[0], v_new[3]) == 1) {AddBound(v_new[1], 1); AddBound(v_new[2], 1);} if(CheckBound_edge(v_new[3], v_new[15]) == 1) {AddBound(v_new[7], 1); AddBound(v_new[11], 1);} if(CheckBound_edge(v_new[15],v_new[12]) == 1) {AddBound(v_new[13], 1); AddBound(v_new[14], 1);} if(CheckBound_edge(v_new[0], v_new[12]) == 1) {AddBound(v_new[4], 1); AddBound(v_new[8], 1);} if(CheckBound_edge(v_new[48], v_new[51]) == 1) {AddBound(v_new[49], 1); AddBound(v_new[50], 1);} if(CheckBound_edge(v_new[51], v_new[63]) == 1) {AddBound(v_new[55], 1); AddBound(v_new[59], 1);} if(CheckBound_edge(v_new[63], v_new[60]) == 1) {AddBound(v_new[61], 1); AddBound(v_new[62], 1);} if(CheckBound_edge(v_new[48], v_new[60]) == 1) {AddBound(v_new[52], 1); AddBound(v_new[56], 1);} if(CheckBound_edge(v_new[0], v_new[48]) == 1) {AddBound(v_new[16], 1); AddBound(v_new[32], 1);} if(CheckBound_edge(v_new[3], v_new[51]) == 1) {AddBound(v_new[19], 1); AddBound(v_new[35], 1);} if(CheckBound_edge(v_new[12],v_new[60]) == 1) {AddBound(v_new[28], 1); AddBound(v_new[44], 1);} if(CheckBound_edge(v_new[15],v_new[63]) == 1) {AddBound(v_new[31], 1); AddBound(v_new[47], 1);} } } void AddVert_hexa_adaptive_2_1(unsigned int* v, int* edge_id, unsigned int* v_new) { float pv[7][3], nv[7][3], po[3], t0[3], t1[3]; int i, j; for(i = 0; i < 3; i++) { pv[0][i] = (2.0f*verts[v[0]][i] + verts[v[1]][i])/3.0f; po[i] = (2.0f*verts[v[3]][i] + verts[v[2]][i])/3.0f; pv[1][i] = (2.0f*pv[0][i] + po[i])/3.0f; pv[2][i] = (2.0f*verts[v[0]][i] + verts[v[3]][i])/3.0f; pv[3][i] = (2.0f*verts[v[0]][i] + verts[v[4]][i])/3.0f; po[i] = (2.0f*verts[v[1]][i] + verts[v[5]][i])/3.0f; pv[4][i] = (2.0f*pv[3][i] + po[i])/3.0f; t0[i] = (2.0f*verts[v[4]][i] + verts[v[5]][i])/3.0f; t1[i] = (2.0f*verts[v[7]][i] + verts[v[6]][i])/3.0f; po[i] = (2.0f*t0[i] + t1[i])/3.0f; pv[5][i] = (2.0f*pv[1][i] + po[i])/3.0f; po[i] = (2.0f*verts[v[3]][i] + verts[v[7]][i])/3.0f; pv[6][i] = (2.0f*pv[3][i] + po[i])/3.0f; // normal nv[0][i] = (2.0f*normals[v[0]][i] + normals[v[1]][i])/3.0f; po[i] = (2.0f*normals[v[3]][i] + normals[v[2]][i])/3.0f; nv[1][i] = (2.0f*nv[0][i] + po[i])/3.0f; nv[2][i] = (2.0f*normals[v[0]][i] + normals[v[3]][i])/3.0f; nv[3][i] = (2.0f*normals[v[0]][i] + normals[v[4]][i])/3.0f; po[i] = (2.0f*normals[v[1]][i] + normals[v[5]][i])/3.0f; nv[4][i] = (2.0f*nv[3][i] + po[i])/3.0f; t0[i] = (2.0f*normals[v[4]][i] + normals[v[5]][i])/3.0f; t1[i] = (2.0f*normals[v[7]][i] + normals[v[6]][i])/3.0f; po[i] = (2.0f*t0[i] + t1[i])/3.0f; nv[5][i] = (2.0f*nv[1][i] + po[i])/3.0f; po[i] = (2.0f*normals[v[3]][i] + normals[v[7]][i])/3.0f; nv[6][i] = (2.0f*nv[3][i] + po[i])/3.0f; } for(i = 0; i < 7; i++) { for(j = 0; j < 3; j++) { po[j] = pv[i][j]; t0[j] = nv[i][j]; } v_new[i] = AddVert(po, t0); //AddBound(v_new[i], 0); } if(edge_id[0] > 0) {AddBound(v_new[0], 1); AddBound(v_new[1], 1); AddBound(v_new[2], 1);} if(edge_id[2] > 0) {AddBound(v_new[2], 1); AddBound(v_new[3], 1); AddBound(v_new[6], 1);} if(edge_id[4] > 0) {AddBound(v_new[0], 1); AddBound(v_new[3], 1); AddBound(v_new[4], 1);} if(CheckBound_edge(v_new[0], v_new[1]) == 1) AddBound(v_new[0], 1); if(CheckBound_edge(v_new[0], v_new[3]) == 1) AddBound(v_new[2], 1); if(CheckBound_edge(v_new[0], v_new[4]) == 1) AddBound(v_new[3], 1); } void AddVert_hexa_adaptive_2_2(unsigned int* v, int* edge_id, unsigned int* v_new) { float pv[64][3], nv[64][3], po[3], no[3]; int i, j, vv; for(i = 0; i < 3; i++) { pv[0][i] = verts[v[0]][i]; pv[3][i] = verts[v[1]][i]; pv[51][i] = verts[v[5]][i]; pv[48][i] = verts[v[4]][i]; pv[12][i] = verts[v[3]][i]; pv[15][i] = verts[v[2]][i]; pv[63][i] = verts[v[6]][i]; pv[60][i] = verts[v[7]][i]; nv[0][i] = normals[v[0]][i]; nv[3][i] = normals[v[1]][i]; nv[51][i] = normals[v[5]][i]; nv[48][i] = normals[v[4]][i]; nv[12][i] = normals[v[3]][i]; nv[15][i] = normals[v[2]][i]; nv[63][i] = normals[v[6]][i]; nv[60][i] = normals[v[7]][i]; pv[16][i] = (2.0f*pv[0][i] + pv[48][i])/3.0f; pv[32][i] = (2.0f*pv[48][i] + pv[0][i])/3.0f; pv[19][i] = (2.0f*pv[3][i] + pv[51][i])/3.0f; pv[35][i] = (2.0f*pv[51][i] + pv[3][i])/3.0f; pv[28][i] = (2.0f*pv[12][i] + pv[60][i])/3.0f; pv[44][i] = (2.0f*pv[60][i] + pv[12][i])/3.0f; pv[31][i] = (2.0f*pv[15][i] + pv[63][i])/3.0f; pv[47][i] = (2.0f*pv[63][i] + pv[15][i])/3.0f; nv[16][i] = (2.0f*nv[0][i] + nv[48][i])/3.0f; nv[32][i] = (2.0f*nv[48][i] + nv[0][i])/3.0f; nv[19][i] = (2.0f*nv[3][i] + nv[51][i])/3.0f; nv[35][i] = (2.0f*nv[51][i] + nv[3][i])/3.0f; nv[28][i] = (2.0f*nv[12][i] + nv[60][i])/3.0f; nv[44][i] = (2.0f*nv[60][i] + nv[12][i])/3.0f; nv[31][i] = (2.0f*nv[15][i] + nv[63][i])/3.0f; nv[47][i] = (2.0f*nv[63][i] + nv[15][i])/3.0f; for(j = 0; j < 4; j++) { pv[4+16*j][i] = (2.0f*pv[0+16*j][i] + pv[12+16*j][i])/3.0f; pv[8+16*j][i] = (2.0f*pv[12+16*j][i] + pv[0+16*j][i])/3.0f; pv[7+16*j][i] = (2.0f*pv[3+16*j][i] + pv[15+16*j][i])/3.0f; pv[11+16*j][i] = (2.0f*pv[15+16*j][i] + pv[3+16*j][i])/3.0f; pv[1+16*j][i] = (2.0f*pv[0+16*j][i] + pv[3+16*j][i])/3.0f; pv[2+16*j][i] = (2.0f*pv[3+16*j][i] + pv[0+16*j][i])/3.0f; pv[13+16*j][i] = (2.0f*pv[12+16*j][i] + pv[15+16*j][i])/3.0f; pv[14+16*j][i] = (2.0f*pv[15+16*j][i] + pv[12+16*j][i])/3.0f; pv[5+16*j][i] = (2.0f*pv[4+16*j][i] + pv[7+16*j][i])/3.0f; pv[6+16*j][i] = (2.0f*pv[7+16*j][i] + pv[4+16*j][i])/3.0f; pv[9+16*j][i] = (2.0f*pv[8+16*j][i] + pv[11+16*j][i])/3.0f; pv[10+16*j][i] = (2.0f*pv[11+16*j][i] + pv[8+16*j][i])/3.0f; nv[4+16*j][i] = (2.0f*nv[0+16*j][i] + nv[12+16*j][i])/3.0f; nv[8+16*j][i] = (2.0f*nv[12+16*j][i] + nv[0+16*j][i])/3.0f; nv[7+16*j][i] = (2.0f*nv[3+16*j][i] + nv[15+16*j][i])/3.0f; nv[11+16*j][i] = (2.0f*nv[15+16*j][i] + nv[3+16*j][i])/3.0f; nv[1+16*j][i] = (2.0f*nv[0+16*j][i] + nv[3+16*j][i])/3.0f; nv[2+16*j][i] = (2.0f*nv[3+16*j][i] + nv[0+16*j][i])/3.0f; nv[13+16*j][i] = (2.0f*nv[12+16*j][i] + nv[15+16*j][i])/3.0f; nv[14+16*j][i] = (2.0f*nv[15+16*j][i] + nv[12+16*j][i])/3.0f; nv[5+16*j][i] = (2.0f*nv[4+16*j][i] + nv[7+16*j][i])/3.0f; nv[6+16*j][i] = (2.0f*nv[7+16*j][i] + nv[4+16*j][i])/3.0f; nv[9+16*j][i] = (2.0f*nv[8+16*j][i] + nv[11+16*j][i])/3.0f; nv[10+16*j][i] = (2.0f*nv[11+16*j][i] + nv[8+16*j][i])/3.0f; } } for(i = 0; i < 28; i++) { if(i == 0) v_new[i] = v[0]; else if(i == 3) v_new[i] = v[1]; else if(i == 11) v_new[i] = v[2]; else if(i == 10) v_new[i] = v[3]; else if(i == 24) v_new[i] = v[4]; else if(i == 25) v_new[i] = v[5]; else if(i == 27) v_new[i] = v[6]; else if(i == 26) v_new[i] = v[7]; else { if(i < 8) vv = i; else if(i < 10) vv = i+1; else if(i == 10) vv = 12; else if(i == 11) vv = 15; else if(i < 20) vv = i+4; else if(i < 22) vv = i+13; else vv = i+19; //if(i < 24) for(j = 0; j < 3; j++) {po[j] = pv[vv][j]; no[j] = nv[vv][j];} v_new[i] = AddVert(po, no); //AddBound(v_new[i], 0); } if((edge_id[0] > 0) && (i < 12)) AddBound(v_new[i], 1); if((edge_id[2] > 0) && (i == 4 || i == 12 || i == 16)) AddBound(v_new[i], 1); if((edge_id[3] > 0) && (i == 7 || i == 15 || i == 19)) AddBound(v_new[i], 1); if((edge_id[4] > 0) && ((i%12 < 4 && i < 16) || i == 20 || i == 21)) AddBound(v_new[i], 1); } for(i = 0; i < 28; i++) { if(CheckBound_edge(v_new[0], v_new[3]) == 1) {AddBound(v_new[1], 1); AddBound(v_new[2], 1);} if(CheckBound_edge(v_new[3], v_new[11]) == 1) AddBound(v_new[7], 1); if(CheckBound_edge(v_new[0], v_new[10]) == 1) AddBound(v_new[4], 1); if(CheckBound_edge(v_new[0], v_new[24]) == 1) AddBound(v_new[12], 1); if(CheckBound_edge(v_new[3], v_new[25]) == 1) AddBound(v_new[15], 1); } } void AddVert_hexa_adaptive_2_4(unsigned int* v, int* edge_id, unsigned int* v_new) { float pv[68][3], nv[68][3], po[3], no[3]; int i, j, vv; for(i = 0; i < 3; i++) { pv[0][i] = verts[v[0]][i]; pv[3][i] = verts[v[1]][i]; pv[51][i] = verts[v[5]][i]; pv[48][i] = verts[v[4]][i]; pv[12][i] = verts[v[3]][i]; pv[15][i] = verts[v[2]][i]; pv[63][i] = verts[v[6]][i]; pv[60][i] = verts[v[7]][i]; nv[0][i] = normals[v[0]][i]; nv[3][i] = normals[v[1]][i]; nv[51][i] = normals[v[5]][i]; nv[48][i] = normals[v[4]][i]; nv[12][i] = normals[v[3]][i]; nv[15][i] = normals[v[2]][i]; nv[63][i] = normals[v[6]][i]; nv[60][i] = normals[v[7]][i]; pv[16][i] = (2.0f*pv[0][i] + pv[48][i])/3.0f; pv[32][i] = (2.0f*pv[48][i] + pv[0][i])/3.0f; pv[19][i] = (2.0f*pv[3][i] + pv[51][i])/3.0f; pv[35][i] = (2.0f*pv[51][i] + pv[3][i])/3.0f; pv[28][i] = (2.0f*pv[12][i] + pv[60][i])/3.0f; pv[44][i] = (2.0f*pv[60][i] + pv[12][i])/3.0f; pv[31][i] = (2.0f*pv[15][i] + pv[63][i])/3.0f; pv[47][i] = (2.0f*pv[63][i] + pv[15][i])/3.0f; nv[16][i] = (2.0f*nv[0][i] + nv[48][i])/3.0f; nv[32][i] = (2.0f*nv[48][i] + nv[0][i])/3.0f; nv[19][i] = (2.0f*nv[3][i] + nv[51][i])/3.0f; nv[35][i] = (2.0f*nv[51][i] + nv[3][i])/3.0f; nv[28][i] = (2.0f*nv[12][i] + nv[60][i])/3.0f; nv[44][i] = (2.0f*nv[60][i] + nv[12][i])/3.0f; nv[31][i] = (2.0f*nv[15][i] + nv[63][i])/3.0f; nv[47][i] = (2.0f*nv[63][i] + nv[15][i])/3.0f; for(j = 0; j < 4; j++) { pv[4+16*j][i] = (2.0f*pv[0+16*j][i] + pv[12+16*j][i])/3.0f; pv[8+16*j][i] = (2.0f*pv[12+16*j][i] + pv[0+16*j][i])/3.0f; pv[7+16*j][i] = (2.0f*pv[3+16*j][i] + pv[15+16*j][i])/3.0f; pv[11+16*j][i] = (2.0f*pv[15+16*j][i] + pv[3+16*j][i])/3.0f; pv[1+16*j][i] = (2.0f*pv[0+16*j][i] + pv[3+16*j][i])/3.0f; pv[2+16*j][i] = (2.0f*pv[3+16*j][i] + pv[0+16*j][i])/3.0f; pv[13+16*j][i] = (2.0f*pv[12+16*j][i] + pv[15+16*j][i])/3.0f; pv[14+16*j][i] = (2.0f*pv[15+16*j][i] + pv[12+16*j][i])/3.0f; pv[5+16*j][i] = (2.0f*pv[4+16*j][i] + pv[7+16*j][i])/3.0f; pv[6+16*j][i] = (2.0f*pv[7+16*j][i] + pv[4+16*j][i])/3.0f; pv[9+16*j][i] = (2.0f*pv[8+16*j][i] + pv[11+16*j][i])/3.0f; pv[10+16*j][i] = (2.0f*pv[11+16*j][i] + pv[8+16*j][i])/3.0f; nv[4+16*j][i] = (2.0f*nv[0+16*j][i] + nv[12+16*j][i])/3.0f; nv[8+16*j][i] = (2.0f*nv[12+16*j][i] + nv[0+16*j][i])/3.0f; nv[7+16*j][i] = (2.0f*nv[3+16*j][i] + nv[15+16*j][i])/3.0f; nv[11+16*j][i] = (2.0f*nv[15+16*j][i] + nv[3+16*j][i])/3.0f; nv[1+16*j][i] = (2.0f*nv[0+16*j][i] + nv[3+16*j][i])/3.0f; nv[2+16*j][i] = (2.0f*nv[3+16*j][i] + nv[0+16*j][i])/3.0f; nv[13+16*j][i] = (2.0f*nv[12+16*j][i] + nv[15+16*j][i])/3.0f; nv[14+16*j][i] = (2.0f*nv[15+16*j][i] + nv[12+16*j][i])/3.0f; nv[5+16*j][i] = (2.0f*nv[4+16*j][i] + nv[7+16*j][i])/3.0f; nv[6+16*j][i] = (2.0f*nv[7+16*j][i] + nv[4+16*j][i])/3.0f; nv[9+16*j][i] = (2.0f*nv[8+16*j][i] + nv[11+16*j][i])/3.0f; nv[10+16*j][i] = (2.0f*nv[11+16*j][i] + nv[8+16*j][i])/3.0f; } pv[64][i] = (pv[21][i] + pv[37][i])/2.0f; pv[65][i] = (pv[22][i] + pv[38][i])/2.0f; pv[66][i] = (pv[25][i] + pv[41][i])/2.0f; pv[67][i] = (pv[26][i] + pv[41][i])/2.0f; nv[64][i] = (nv[21][i] + nv[37][i])/2.0f; nv[65][i] = (nv[22][i] + nv[38][i])/2.0f; nv[66][i] = (nv[25][i] + nv[41][i])/2.0f; nv[67][i] = (nv[26][i] + nv[41][i])/2.0f; } for(i = 0; i < 48; i++) { if(i == 0) v_new[i] = v[0]; else if(i == 3) v_new[i] = v[1]; else if(i == 15) v_new[i] = v[2]; else if(i == 12) v_new[i] = v[3]; else if(i == 44) v_new[i] = v[4]; else if(i == 45) v_new[i] = v[5]; else if(i == 47) v_new[i] = v[6]; else if(i == 46) v_new[i] = v[7]; else { if(i < 32) vv = i; else if(i < 36) vv = i+32; else if(i < 38) vv = i-3; else if(i == 38) vv = 36; else if(i < 41) vv = i; else if(i == 41) vv = 43; else vv = i+3; // if(i < 44) for(j = 0; j < 3; j++) {po[j] = pv[vv][j]; no[j] = nv[vv][j];} v_new[i] = AddVert(po, no); //if(i!=21 && i!=22 && i!=25 && i!=26 && i!=32 && i!=33 && i!=34 && i!=35) AddBound(v_new[i], 1); } if((edge_id[0] > 0) && (i < 16)) AddBound(v_new[i], 1); if((edge_id[2] > 0) && ((i%4 == 0 && i < 29) || i == 38 || i == 40)) AddBound(v_new[i], 1); if((edge_id[3] > 0) && ((i%4 == 3 && i < 32) || i == 39 || i == 41)) AddBound(v_new[i], 1); if((edge_id[4] > 0) && ((i%16 < 4 && i < 20) || i == 36 || i == 37)) AddBound(v_new[i], 1); if((edge_id[5] > 0) && ((i%16 > 11&& i < 32) || i == 42 || i == 43)) AddBound(v_new[i], 1); } for(i = 0; i < 48; i++) { if(CheckBound_edge(v_new[0], v_new[3]) == 1) {AddBound(v_new[1], 1); AddBound(v_new[2], 1);} if(CheckBound_edge(v_new[3], v_new[15]) == 1) {AddBound(v_new[7], 1); AddBound(v_new[11], 1);} if(CheckBound_edge(v_new[15], v_new[12]) == 1) {AddBound(v_new[13], 1); AddBound(v_new[14], 1);} if(CheckBound_edge(v_new[0], v_new[12]) == 1) {AddBound(v_new[4], 1); AddBound(v_new[8], 1);} if(CheckBound_edge(v_new[0], v_new[44]) == 1) AddBound(v_new[16], 1); if(CheckBound_edge(v_new[3], v_new[45]) == 1) AddBound(v_new[19], 1); if(CheckBound_edge(v_new[12], v_new[46]) == 1) AddBound(v_new[28], 1); if(CheckBound_edge(v_new[15], v_new[47]) == 1) AddBound(v_new[31], 1); } } int AddTri(unsigned int v1, unsigned int v2, unsigned int v3) { if (numtris+1 >= tsize) { tsize<<=1; triangles = (unsigned int (*)[3])realloc(triangles, sizeof(unsigned int[3]) * tsize); bound_tri = (unsigned int (*))realloc(bound_tri, sizeof(unsigned int) * tsize); } bound_tri[numtris] = 0; triangles[numtris][0] = v1; triangles[numtris][1] = v2; triangles[numtris][2] = v3; return numtris++; } float get_aspect_ratio(unsigned int v0, unsigned int v1, unsigned int v2) { float a, b, c, p, s, r_in, r_out; int i; a = 0.0; b = 0.0; c = 0.0; for(i = 0; i < 3; i++) { a += (verts[v1][i] - verts[v0][i])*(verts[v1][i] - verts[v0][i]); b += (verts[v2][i] - verts[v1][i])*(verts[v2][i] - verts[v1][i]); c += (verts[v0][i] - verts[v2][i])*(verts[v0][i] - verts[v2][i]); } a = (float)sqrt(a); b = (float)sqrt(b); c = (float)sqrt(c); p = (a + b + c) / 2.0f; s = (float)sqrt(p * (p - a) * (p - b) * (p - c)); r_in = s / p; r_out = a * b * c / (4.0f * s); return (r_in / r_out); } void Add_2_Tetra(unsigned int* v, unsigned int my_vertex) { float aspect_ratio_0, aspect_ratio_1, temp; // dectect duplicate vertices if(v[0] == v[1]) { AddTetra(v[1], v[3], v[2], my_vertex); } else if(v[1] == v[2]) { AddTetra(v[0], v[3], v[1], my_vertex); } else if(v[2] == v[3] || v[3] == v[0]) { AddTetra(v[0], v[2], v[1], my_vertex); } else { aspect_ratio_0 = get_aspect_ratio(v[0], v[2], v[1]); temp = get_aspect_ratio(v[0], v[3], v[2]); if(temp < aspect_ratio_0) aspect_ratio_0 = temp; aspect_ratio_1 = get_aspect_ratio(v[0], v[3], v[1]); temp = get_aspect_ratio(v[1], v[3], v[2]); if(temp < aspect_ratio_1) aspect_ratio_1 = temp; if(aspect_ratio_0 > aspect_ratio_1) { AddTetra(v[0], v[2], v[1], my_vertex); AddTetra(v[0], v[3], v[2], my_vertex); } else { AddTetra(v[0], v[3], v[1], my_vertex); AddTetra(v[1], v[3], v[2], my_vertex); } } } void Extend_Tri(unsigned int v0, unsigned int v1, unsigned int v2) { unsigned int vv0, vv1, vv2, t0, t1, t2, t, i, nstep; float v_pos[3], norm[3], r, step, radius_o, center; vv0 = v0; vv1 = v1; vv2 = v2; if(vv1 < vv0 && vv1 < vv2) {v0 = vv1; v1 = vv2; v2 = vv0;} if(vv2 < vv0 && vv2 < vv1) {v0 = vv2; v1 = vv0; v2 = vv1;} t0 = v0; t1 = v1; t2 = v2; center = (129.0-1.0f)/2.0f; radius_o = (129.0-1.0f)/2.0f; step = (30.0f*20.0f-radius_o)/10.0f; //40 times -- 10 //step = 268.0/21.0; // 20 times -- 6 //step = 270.0f/55.0f; // 20 times -- 10 nstep = 5; if (vtx_idx_arr_extend[v0] == -1) { for(i = 1; i < nstep; i++) { r = (float)sqrt((verts[v0][0]-center)*(verts[v0][0]-center) + (verts[v0][1]-center)*(verts[v0][1]-center) + (verts[v0][2]-center)*(verts[v0][2]-center)); for(t = 0; t < 3; t++) { v_pos[t] = (verts[v0][t]-center) * (radius_o + step*i*(i+1)/2.0f)/r + center; norm[t] = normals[v0][t]; } vv0 = AddVert(v_pos, norm); AddBound(vv0, 1); if(i == 1) vtx_idx_arr_extend[v0] = vv0; } } if (vtx_idx_arr_extend[v1] == -1) { for(i = 1; i < nstep; i++) { r = (float)sqrt((verts[v1][0]-center)*(verts[v1][0]-center) + (verts[v1][1]-center)*(verts[v1][1]-center) + (verts[v1][2]-center)*(verts[v1][2]-center)); for(t = 0; t < 3; t++) { v_pos[t] = (verts[v1][t]-center) * (radius_o + step*i*(i+1)/2.0f)/r + center; norm[t] = normals[v1][t]; } vv1 = AddVert(v_pos, norm); AddBound(vv1, 1); if(i == 1) vtx_idx_arr_extend[v1] = vv1; } } if (vtx_idx_arr_extend[v2] == -1) { for(i = 1; i < nstep; i++) { r = (float)sqrt((verts[v2][0]-center)*(verts[v2][0]-center) + (verts[v2][1]-center)*(verts[v2][1]-center) + (verts[v2][2]-center)*(verts[v2][2]-center)); for(t = 0; t < 3; t++) { v_pos[t] = (verts[v2][t]-center) * (radius_o + step*i*(i+1)/2.0f)/r + center; norm[t] = normals[v2][t]; } vv2 = AddVert(v_pos, norm); AddBound(vv2, 1); if(i == 1) vtx_idx_arr_extend[v2] = vv2; } } for(i = 1; i < nstep; i++) { vv0 = vtx_idx_arr_extend[v0] + (i - 1); vv1 = vtx_idx_arr_extend[v1] + (i - 1); vv2 = vtx_idx_arr_extend[v2] + (i - 1); if(v0 < v1 && v1 < v2) { AddTetra(vv0, vv1, vv2, t0); AddTetra(vv2, vv1, t1, t0); AddTetra(vv2, t1, t2, t0); } else { //if(v0 < v2 && v2 < v1) AddTetra(vv0, vv1, vv2, t0); AddTetra(vv2, vv1, t2, t0); AddTetra(vv1, t1, t2, t0); } t0 = vv0; t1 = vv1; t2 = vv2; } } void Extend_Tetra(unsigned int* v) { float aspect_ratio_0, aspect_ratio_1, temp, radius, center; center = 64.0f; radius = (float)sqrt((verts[v[0]][0]-center)*(verts[v[0]][0]-center) + (verts[v[0]][1]-center)*(verts[v[0]][1]-center) + (verts[v[0]][2]-center)*(verts[v[0]][2]-center)); if(radius > 40.0) { // dectect duplicate vertices if(v[0] == v[1]) { Extend_Tri(v[1], v[3], v[2]); } else if(v[1] == v[2]) { Extend_Tri(v[0], v[3], v[1]); } else if(v[2] == v[3] || v[3] == v[0]) { Extend_Tri(v[0], v[2], v[1]); } else { aspect_ratio_0 = get_aspect_ratio(v[0], v[2], v[1]); temp = get_aspect_ratio(v[0], v[3], v[2]); if(temp < aspect_ratio_0) aspect_ratio_0 = temp; aspect_ratio_1 = get_aspect_ratio(v[0], v[3], v[1]); temp = get_aspect_ratio(v[1], v[3], v[2]); if(temp < aspect_ratio_1) aspect_ratio_1 = temp; if(aspect_ratio_0 > aspect_ratio_1) { Extend_Tri(v[0], v[2], v[1]); Extend_Tri(v[0], v[3], v[2]); } else { Extend_Tri(v[0], v[3], v[1]); Extend_Tri(v[1], v[3], v[2]); } } } } void Add_2_Tri(unsigned int* v) { float aspect_ratio_0, aspect_ratio_1, temp; // dectect duplicate vertices if(v[0] == v[1]) { AddTri(v[1], v[2], v[3]); //AddTri(-1, -1, -1); } else if(v[1] == v[2]) { AddTri(v[0], v[1], v[3]); //AddTri(-1, -1, -1); } else if(v[2] == v[3] || v[3] == v[0]) { AddTri(v[0], v[1], v[2]); //AddTri(-1, -1, -1); } else { aspect_ratio_0 = get_aspect_ratio(v[0], v[2], v[1]); temp = get_aspect_ratio(v[0], v[3], v[2]); if(temp < aspect_ratio_0) aspect_ratio_0 = temp; aspect_ratio_1 = get_aspect_ratio(v[0], v[3], v[1]); temp = get_aspect_ratio(v[1], v[3], v[2]); if(temp < aspect_ratio_1) aspect_ratio_1 = temp; if(aspect_ratio_0 > aspect_ratio_1) { AddTri(v[0], v[1], v[2]); AddTri(v[2], v[3], v[0]); } else { AddTri(v[0], v[1], v[3]); AddTri(v[1], v[2], v[3]); } } } float getRadius(float a[3][3], float b[3], float v0[3]) { float temp0, x, y, z; int i; if(fabs(a[0][0]) < fabs(a[1][0]) && fabs(a[2][0]) <= fabs(a[1][0])) { for(i = 0; i < 3; i++) { temp0 = a[0][i]; a[0][i] = a[1][i]; a[1][i] = temp0; } temp0 = b[0]; b[0] = b[1]; b[1] = temp0; } else { if(fabs(a[0][0]) < fabs(a[2][0]) && fabs(a[1][0]) <= fabs(a[2][0])) { for(i = 0; i < 3; i++) { temp0 = a[0][i]; a[0][i] = a[2][i]; a[2][i] = temp0; } temp0 = b[0]; b[0] = b[2]; b[2] = temp0; } } for(i = 1; i < 3; i++) { if(fabs(a[i][0]) > pow(10., -12)) { a[i][1] = a[0][0] * a[i][1] / a[i][0] - a[0][1]; a[i][2] = a[0][0] * a[i][2] / a[i][0] - a[0][2]; b[i] = a[0][0] * b[i] / a[i][0] - b[0]; a[i][0] = 0.0; } } if(fabs(a[1][1]) < fabs(a[2][1])) { for(i = 0; i < 3; i++) { temp0 = a[1][i]; a[1][i] = a[2][i]; a[2][i] = temp0; } temp0 = b[1]; b[1] = b[2]; b[2] = temp0; } if(fabs(a[2][1]) > pow(10., -12)) { a[2][2] = a[1][1] * a[2][2] / a[2][1] - a[1][2]; b[2] = a[1][1] * b[2] / a[2][1] - b[1]; a[2][1] = 0.0; } if(fabs(a[0][0]) > pow(10., -12) && fabs(a[1][1]) > pow(10., -12) && fabs(a[2][2]) > pow(10., -12)) { z = b[2] / a[2][2]; y = (b[1] - a[1][2] * z) / a[1][1]; x = (b[0] - a[0][1] * y - a[0][2] * z) / a[0][0]; } else printf("--- singular ---\n"); float delt_x = x - v0[0]; float delt_y = y - v0[1]; float delt_z = z - v0[2]; float radius = (float)sqrt(delt_x*delt_x + delt_y*delt_y + delt_z*delt_z); return radius; } // return 1 -- bad quality; return 0 -- good quality int testTetrahedron(float v0[3], float v1[3], float v2[3], float v3[3]) { // min/max angles float v01[3], v02[3], n[3], v[3], t, min, max, temp; float v03[3], v13[3], v23[3], v0p[3], v1p[3], v2p[3]; int i; for(i = 0; i < 3; i++) { v01[i] = v1[i] - v0[i]; v02[i] = v2[i] - v0[i]; } n[0] = v01[1]*v02[2] - v01[2]*v02[1]; n[1] = v01[2]*v02[0] - v01[0]*v02[2]; n[2] = v01[0]*v02[1] - v01[1]*v02[0]; temp = (float)sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]); n[0] = - n[0] / temp; n[1] = - n[1] / temp; n[2] = - n[2] / temp; t = (v2[0] - v3[0])*n[0] + (v2[1] - v3[1])*n[1] + (v2[2] - v3[2])*n[2]; if(t < 0.0) return 1; // RHS for(i = 0; i < 3; i++) { v[i] = v3[i] + n[i] * t; v03[i] = v3[i] - v0[i]; v0p[i] = v[i] - v0[i]; v13[i] = v3[i] - v1[i]; v1p[i] = v[i] - v1[i]; v23[i] = v3[i] - v2[i]; v2p[i] = v[i] - v2[i]; } float a_dot_b = v03[0]*v0p[0] + v03[1]*v0p[1] + v03[2]*v0p[2]; float module_a = (float)sqrt(v03[0]*v03[0] + v03[1]*v03[1] + v03[2]*v03[2]); float module_b = (float)sqrt(v0p[0]*v0p[0] + v0p[1]*v0p[1] + v0p[2]*v0p[2]); float angle0; if(module_b < pow(10., -12)) angle0 = 90.0f; else angle0 = (float)acos(a_dot_b / (module_a * module_b)) * 180.0f / 3.1415926f; a_dot_b = v13[0]*v1p[0] + v13[1]*v1p[1] + v13[2]*v1p[2]; module_a = (float)sqrt(v13[0]*v13[0] + v13[1]*v13[1] + v13[2]*v13[2]); module_b = (float)sqrt(v1p[0]*v1p[0] + v1p[1]*v1p[1] + v1p[2]*v1p[2]); float angle1; if(module_b < pow(10., -12)) angle1 = 90.0f; else angle1 = (float)acos(a_dot_b / (module_a * module_b)) * 180.0f / 3.1415926f; a_dot_b = v23[0]*v2p[0] + v23[1]*v2p[1] + v23[2]*v2p[2]; module_a = (float)sqrt(v23[0]*v23[0] + v23[1]*v23[1] + v23[2]*v23[2]); module_b = (float)sqrt(v2p[0]*v2p[0] + v2p[1]*v2p[1] + v2p[2]*v2p[2]); float angle2; if(module_b < pow(10., -12)) angle2 = 90.0f; else angle2 = (float)acos(a_dot_b / (module_a * module_b)) * 180.0f / 3.1415926f; min = angle0; max = angle0; if(angle1 < min) min = angle1; else max = angle1; if(angle2 < min) min = angle2; if(angle2 > max) max = angle2; if((min < 10.0) || (max > 160.0)) return 1; // tetrahedral quality measure = volume of tetrahedron / volume of equilateral tetrahedron // with same circumsphere radius float h = (float)sqrt((v[0] - v3[0])*(v[0] - v3[0]) + (v[1] - v3[1])*(v[1] - v3[1]) + (v[2] - v3[2])*(v[2] - v3[2])); float side_a = (float)sqrt((v1[0] - v0[0])*(v1[0] - v0[0]) + (v1[1] - v0[1])*(v1[1] - v0[1]) + (v1[2] - v0[2])*(v1[2] - v0[2])); float side_b = (float)sqrt((v2[0] - v1[0])*(v2[0] - v1[0]) + (v2[1] - v1[1])*(v2[1] - v1[1]) + (v2[2] - v1[2])*(v2[2] - v1[2])); float side_c = (float)sqrt((v2[0] - v0[0])*(v2[0] - v0[0]) + (v2[1] - v0[1])*(v2[1] - v0[1]) + (v2[2] - v0[2])*(v2[2] - v0[2])); float periphery = side_a + side_b + side_c; float area = 0.25f*(float)sqrt(periphery*(periphery - 2*side_a)*(periphery - 2*side_b)*(periphery - 2*side_c)); float volume_1 = area * h / 3.0f; float matrix_lhs[3][3], vector_rhs[3], radius; for(i = 0; i < 3; i++) { matrix_lhs[0][i] = v1[i] - v0[i]; matrix_lhs[1][i] = v2[i] - v0[i]; matrix_lhs[2][i] = v3[i] - v0[i]; } vector_rhs[0] = (v1[0]*v1[0] - v0[0]*v0[0] + v1[1]*v1[1] - v0[1]*v0[1] + v1[2]*v1[2] - v0[2]*v0[2]) / 2.0f; vector_rhs[1] = (v2[0]*v2[0] - v0[0]*v0[0] + v2[1]*v2[1] - v0[1]*v0[1] + v2[2]*v2[2] - v0[2]*v0[2]) / 2.0f; vector_rhs[2] = (v3[0]*v3[0] - v0[0]*v0[0] + v3[1]*v3[1] - v0[1]*v0[1] + v3[2]*v3[2] - v0[2]*v0[2]) / 2.0f; if(volume_1 > pow(10., -12)) radius = getRadius(matrix_lhs, vector_rhs, v0); else return 1; float volume_2 = 0.25f*(float)sqrt(6.0f)*radius*radius*radius; if(volume_1/volume_2 < 0.02) return 1; else return 0; } void edge_contraction_tri(unsigned int* v) { float aspect_ratio, a, b, c; int i; aspect_ratio = get_aspect_ratio(v[0], v[1], v[2]); if(aspect_ratio < 0.1) { a = 0.0; b = 0.0; c = 0.0; for(i = 0; i < 3; i++) { a += (verts[v[1]][i] - verts[v[0]][i])*(verts[v[1]][i] - verts[v[0]][i]); b += (verts[v[2]][i] - verts[v[1]][i])*(verts[v[2]][i] - verts[v[1]][i]); c += (verts[v[0]][i] - verts[v[2]][i])*(verts[v[0]][i] - verts[v[2]][i]); } if(a <= b && a <= c) { for(i = 0; i < 3; i++) verts[v[1]][i] = verts[v[0]][i]; } else if(b <= a && b <= c) { for(i = 0; i < 3; i++) verts[v[2]][i] = verts[v[1]][i]; } else { for(i = 0; i < 3; i++) verts[v[0]][i] = verts[v[2]][i]; } } } void edge_contraction_tetra(unsigned int* v, int num) { float min, max, e[6]; float v0[3], v1[3], v2[3], v3[3]; int i, id_min, sign; for(i = 0; i < 6; i++) e[i] = 0.0; for(i = 0; i < 3; i++) { e[0] += (verts[v[1]][i] - verts[v[0]][i])*(verts[v[1]][i] - verts[v[0]][i]); //e_01 e[1] += (verts[v[2]][i] - verts[v[1]][i])*(verts[v[2]][i] - verts[v[1]][i]); //e_12 e[2] += (verts[v[0]][i] - verts[v[2]][i])*(verts[v[0]][i] - verts[v[2]][i]); //e_20 e[3] += (verts[v[3]][i] - verts[v[0]][i])*(verts[v[3]][i] - verts[v[0]][i]); //e_03 e[4] += (verts[v[3]][i] - verts[v[1]][i])*(verts[v[3]][i] - verts[v[1]][i]); //e_13 e[5] += (verts[v[3]][i] - verts[v[2]][i])*(verts[v[3]][i] - verts[v[2]][i]); //e_23 v0[i] = verts[v[0]][i]; v1[i] = verts[v[1]][i]; v2[i] = verts[v[2]][i]; v3[i] = verts[v[3]][i]; } min = e[0]; max = e[0]; id_min = 0; for(i = 1; i < 6; i++) { if(e[i] < min) {min = e[i]; id_min = i;} if(e[i] > max) max = e[i]; } //float aspect_ratio = min / max; //sign = testRHS(v0, v1, v2, v3); sign = testTetrahedron(v0, v1, v2, v3); //if(aspect_ratio < 0.1) { //0.2 if(sign == 1) { if(id_min == 0) { for(i = 0; i < 3; i++) verts[v[1]][i] = verts[v[0]][i]; } else if(id_min == 1) { for(i = 0; i < 3; i++) verts[v[2]][i] = verts[v[1]][i]; } else if(id_min == 2) { for(i = 0; i < 3; i++) verts[v[2]][i] = verts[v[0]][i]; } else if(id_min == 3) { for(i = 0; i < 3; i++) verts[v[3]][i] = verts[v[0]][i]; } else if(id_min == 4) { for(i = 0; i < 3; i++) verts[v[3]][i] = verts[v[1]][i]; } else { // id_min = 5 for(i = 0; i < 3; i++) verts[v[3]][i] = verts[v[2]][i]; } } } void edge_contraction(unsigned int* v, int num) { if(num == 3) { edge_contraction_tri(v); } else { // num == 4 or 5 edge_contraction_tetra(v, num); } } void AddPyramid(unsigned int* v , unsigned int my_vertex, int num) { float vv0[3], vv1[3], vv2[3], vv3[3]; int t, sign; AddQuad(v, num); for(t = 0; t < 3; t++) { vv0[t] = verts[v[0]][t]; vv1[t] = verts[v[1]][t]; vv2[t] = verts[v[2]][t]; vv3[t] = verts[my_vertex][t]; } sign = testRHS(vv0, vv1, vv2, vv3); if(sign == 0) { AddTri(v[0], my_vertex, v[1]); AddTri(v[1], my_vertex, v[2]); } else { AddTri(v[1], my_vertex, v[0]); AddTri(v[2], my_vertex, v[1]); } for(t = 0; t < 3; t++) { vv0[t] = verts[v[0]][t]; vv1[t] = verts[v[2]][t]; vv2[t] = verts[v[3]][t]; vv3[t] = verts[my_vertex][t]; } sign = testRHS(vv0, vv1, vv2, vv3); if(sign == 0) { AddTri(v[2], my_vertex, v[3]); AddTri(v[3], my_vertex, v[0]); } else { AddTri(v[3], my_vertex, v[2]); AddTri(v[0], my_vertex, v[3]); } } // RHS -- 0; LHS -- 1; int testRHS(float v0[3], float v1[3], float v2[3], float v3[3]) { float v01[3], v02[3], v03[3], n[3], sign; for(int i = 0; i < 3; i++) { v01[i] = v1[i] - v0[i]; v02[i] = v2[i] - v0[i]; v03[i] = v3[i] - v0[i]; } //float len = sqrt(v03[0]*v03[0] + v03[1]*v03[1] + v03[2]*v03[2]); //for(i = 0; i < 3; i++) v03[i] /= len; n[0] = v01[1]*v02[2] - v01[2]*v02[1]; n[1] = v01[2]*v02[0] - v01[0]*v02[2]; n[2] = v01[0]*v02[1] - v01[1]*v02[0]; //len = sqrt(n[0]*n[0] + n[1]*n[1] + n[2]*n[2]); //for(i = 0; i < 3; i++) n[i] /= len; sign = v03[0]*n[0] + v03[1]*n[1] + v03[2]*n[2]; if(sign < 0.0) return 1; else if(sign == 0.0) return -1; else return 0; } void AddTetra(unsigned int v1, unsigned int v2, unsigned int v3, unsigned int v4) { float vv0[3], vv1[3], vv2[3], vv3[3]; int t, sign; for(t = 0; t < 3; t++) { vv0[t] = verts[v1][t]; vv1[t] = verts[v2][t]; vv2[t] = verts[v3][t]; vv3[t] = verts[v4][t]; } sign = testRHS(vv0, vv1, vv2, vv3); if(sign == 1) { AddTri(v1, v3, v2); AddTri(v2, v3, v4); AddTri(v1, v4, v3); AddTri(v1, v2, v4); } if(sign == 0) { AddTri(v1, v2, v3); bound_tri[numtris-1] = 1; AddTri(v3, v2, v4); AddTri(v1, v3, v4); AddTri(v1, v4, v2); } } int AddVert(float v_pos[3], float norm[3]) { int i; /* // Jessica begin float v0[3], dist; int num = 0; if(numverts - 500 > 0) num = numverts - 500; for(i = num; i < numverts; i++) { v0[0] = verts[i][0]; v0[1] = verts[i][1]; v0[2] = verts[i][2]; dist = (v_pos[0] - v0[0])*(v_pos[0] - v0[0]) + (v_pos[1] - v0[1])*(v_pos[1] - v0[1]) + (v_pos[2] - v0[2])*(v_pos[2] - v0[2]); if(sqrt(dist) < 0.0001) { return i; break; } } // Jessica end */ if (numverts+1 > vsize) { vsize<<=1; verts = (float (*)[3])realloc(verts,sizeof(float[3])*vsize); funcs = (float (*)[1])realloc(funcs,sizeof(float[1])*vsize); //#ifdef GRAD // grad addtion normals = (float(*)[3])realloc(normals,sizeof(float[3])*vsize); curvatures = (float(*)[2])realloc(normals,sizeof(float[2])*vsize); //#endif GRAD bound_sign = (unsigned int (*))realloc(bound_sign,sizeof(unsigned int)*vsize); vtxnew_sign = (unsigned int (*))realloc(vtxnew_sign,sizeof(unsigned int)*vsize); bound_edge = (unsigned int (*)[18])realloc(bound_edge,sizeof(unsigned int[18])*vsize); } bound_sign[numverts] = 0; vtxnew_sign[numverts] = 0; for (i = 0; i < 18; i++) bound_edge[numverts][i] = 0; for (i = 0; i < 3; i++) verts[numverts][i] = v_pos[i]; //#ifdef GRAD for (i=0;i<3;i++) normals[numverts][i] = norm[i]; for (i=0;i<2;i++) curvatures[numverts][i] = 0.0f; //#endif return numverts++; } // sign = 1 -- outer // sign = -1 -- inside // sign = 0 -- not on boundary void AddBound(int index, int sign) { bound_sign[index] = sign; } void AddBound_edge(unsigned int index_1, unsigned int index_2) { int i, temp; if(index_2 < index_1) { temp = index_1; index_1 = index_2; index_2 = temp; } for(i = 0; i < 18; i++) { if(bound_edge[index_1][i] == index_2) break; if(bound_edge[index_1][i] == 0) bound_edge[index_1][i] = index_2; } } int CheckBound_edge(unsigned int index_1, unsigned int index_2) { int i, temp; if(index_2 < index_1) { temp = index_1; index_1 = index_2; index_2 = temp; } for(i = 0; i < 18; i++) { if(bound_edge[index_1][i] == index_2) return 1; } return 0; } void AddVtxNew(int index, int sign) { vtxnew_sign[index] = sign; } int center_vtx(int v1,int v2,int v3) { float center_vtx[3],norm[3]; int i; for (i=0; i<3; i++) { center_vtx[i]=(verts[v1][i] + verts[v2][i] + verts[v3][i])/3.0f; // grad addtion norm[i]=(normals[v1][i]+normals[v2][i]+normals[v3][i])/3.0f; } return AddVert(center_vtx,norm); } //void loadgeoframe(const char * name, int num); void calculatenormals(); void calculateTriangleNormal(float* norm, unsigned int c); void calculateExtents(); void read_raw(const char * rawiv_fname); //void display(); int numverts; int numtris; int num_tris; int numquads; int numhexas; int tsize, vsize, qsize; float (*verts)[3]; float (*normals)[3]; float (*curvatures)[2]; float (*funcs)[1]; unsigned int (*triangles)[3]; unsigned int (*quads)[4]; unsigned int *bound_sign; unsigned int *bound_tri; int* vtx_idx_arr_extend; unsigned int *vtxnew_sign; unsigned int (*bound_edge)[18]; double biggestDim; double centerx, centery, centerz; }; #endif //__GEOFRAME_H__ mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/mydrawer.cpp0000644000175000017500000013276711112570406024413 0ustar debiandebian#include #include #include #include #include "mydrawer.h" #include "geoframe.h" #include "octree.h" float l_err, l_err_in; float dist_level; extern void cross(float* dest, const float* v1, const float* v2); MyDrawer::MyDrawer() { g_frame = 0; cut_flag = 0; //flat_flag=2; flat_flag=1; //wireframe_flag=0; wireframe_flag=1; strcpy(fn,"aaa"); biggestDim = 1.0; centerx = 0.0; centery = 0.0; centerz = 0.0; center[0] = 0.0; center[1] = 0.0; center[2] = 0.0; zoom_z=1; plane_x = 32.0f;//(float) ((int)biggestDim/2.0); //32.0; plane_z = 48.0f; //cout << "in MyDrawer(): plane_x " << plane_x << "plane_z " << plane_z << "\n"; } // void MyDrawer::display_tri(int i, int j, int k, int c, int normalflag, IntArray *newfaces) { //std::cout<< "Inside MyDrawer. display_tri\n"; float v1[3], v2[3], norm[3], v0[3]; int vert, ii, index, my_bool, f0, f2; vector f; my_bool = ((g_frame->bound_sign[g_frame->quads[c][0]] == 1) && (g_frame->bound_sign[g_frame->quads[c][1]] == 1) && (g_frame->bound_sign[g_frame->quads[c][2]] == 1) && (g_frame->bound_sign[g_frame->quads[c][3]] == 1)) || normalflag == -1; if(my_bool) { if(normalflag == -1) { vert = g_frame->quads[c][i]; v0[0] = g_frame->verts[vert][0]; vert = g_frame->quads[c][j]; v1[0] = g_frame->verts[vert][0]; vert = g_frame->quads[c][k]; v2[0] = g_frame->verts[vert][0]; if(v0[0] >= plane_x && v1[0] >= plane_x && v2[0] >= plane_x) { //if(v0[0] <= plane_x && v1[0] <= plane_x && v2[0] <= plane_x && // v0[2] <= plane_x && v1[2] <= plane_x && v2[2] <= plane_x) { normalflag = -2; } } else { vert = g_frame->quads[c][i]; v1[0] = v2[0] = -g_frame->verts[vert][0]; v1[1] = v2[1] = -g_frame->verts[vert][1]; v1[2] = v2[2] = -g_frame->verts[vert][2]; vert = g_frame->quads[c][j]; v1[0] += g_frame->verts[vert][0]; v1[1] += g_frame->verts[vert][1]; v1[2] += g_frame->verts[vert][2]; vert = g_frame->quads[c][k]; v2[0] += g_frame->verts[vert][0]; v2[1] += g_frame->verts[vert][1]; v2[2] += g_frame->verts[vert][2]; cross(norm, v1, v2); // normal flipping if (normalflag == 1) { norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } } /************************** glBegin(GL_TRIANGLES); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; vert = g_frame->quads[c][index]; if (normalflag == -1 || flat_flag == 2) { // hexa flat shading + wireframe norm[0] = g_frame->normals[vert][0]; norm[1] = g_frame->normals[vert][1]; norm[2] = g_frame->normals[vert][2]; } if(normalflag == -2) {norm[0] = 1.0; norm[1] = 0.0; norm[2] = 0.0;} glNormal3d(norm[0], norm[1], norm[2]); // hexa cross section if((g_frame->verts[vert][0]-32.5f)*(g_frame->verts[vert][0]-32.5f)+(g_frame->verts[vert][1]-32.5f)*(g_frame->verts[vert][1]-32.5f) + (g_frame->verts[vert][2]-32.5f)*(g_frame->verts[vert][2]-32.5f) < 100000.5f && normalflag != -2 && g_frame->numhexas > 0) {//900.5 GLfloat diffRefl[] = {0.6f, 0.6f, 1.0f, 1.00f}; //GLfloat diffRefl[] = {1.0f, 0.7f, 0.0f, 1.00f}; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffRefl); } else { //GLfloat diffRefl_1[] = {0.9, 0.7, 0.0, 1.00}; GLfloat diffRefl_1[] = {1.0f, 0.7f, 0.0f, 1.00f}; //GLfloat diffRefl_1[] = {0.6, 0.6, 1.0, 1.00}; //GLfloat diffRefl_1[] = {1.0, 0.0, 0.0, 1.00}; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffRefl_1); } if(normalflag <= -1 && g_frame->verts[vert][0] < plane_x) //if(normalflag <= -1 && g_frame->verts[vert][0] < plane_x && g_frame->verts[vert][2] < plane_x) glVertex3d( //plane_x, g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); else glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } glEnd(); ******************/ f.resize(3); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; f[ii] = g_frame->triangles[c][index]; } if (normalflag == 1) { f0 = f[0]; f2 = f[2]; f[0] = f2; f[2] = f0; } newfaces->push_back(f); } } // void MyDrawer::display_tri0(int i, int j, int k, int c, int normalflag, int wire_flag, IntArray *newfaces) { //std::cout<< "Inside MyDrawer. display_tri0\n"; float v1[3], v2[3], norm[3]; int vert, ii, index, my_bool, my_bool_0, f0, f2, nflag; vector f; my_bool = (g_frame->bound_sign[g_frame->triangles[c][0]] == 1) && (g_frame->bound_sign[g_frame->triangles[c][1]] == 1) && (g_frame->bound_sign[g_frame->triangles[c][2]] == 1); my_bool_0 = (g_frame->bound_sign[g_frame->triangles[c][0]] == -1) && (g_frame->bound_sign[g_frame->triangles[c][1]] == -1) && (g_frame->bound_sign[g_frame->triangles[c][2]] == -1); if(my_bool || my_bool_0) { vert = g_frame->triangles[c][i]; v1[0] = v2[0] = -g_frame->verts[vert][0]; v1[1] = v2[1] = -g_frame->verts[vert][1]; v1[2] = v2[2] = -g_frame->verts[vert][2]; vert = g_frame->triangles[c][j]; v1[0] += g_frame->verts[vert][0]; v1[1] += g_frame->verts[vert][1]; v1[2] += g_frame->verts[vert][2]; vert = g_frame->triangles[c][k]; v2[0] += g_frame->verts[vert][0]; v2[1] += g_frame->verts[vert][1]; v2[2] += g_frame->verts[vert][2]; cross(norm, v1, v2); nflag = 0; // normal flipping if (normalflag == 1) { norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } if (g_frame->bound_tri[c] == 1) { //std::cout << "in display_tri0 normal flipping, c = " << c << "\n"; nflag = 1; norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } vert = g_frame->triangles[c][i]; v1[0] = g_frame->verts[vert][0]; v1[1] = g_frame->verts[vert][1]; v1[2] = g_frame->verts[vert][2]; /**************** if(my_bool_0) { //if(my_bool && v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] < 90000.0) { GLfloat diffRefl[] = {1.0f, 0.0f, 0.0f, 1.00f}; //GLfloat diffRefl[] = {1.0, 0.7, 0.0, 1.00}; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffRefl); } else { //GLfloat diffRefl_1[] = {0.0, 0.6, 0.5, 1.00}; GLfloat diffRefl_1[] = {1.0f, 0.7f, 0.0f, 1.0f}; //GLfloat diffRefl_1[] = {0.6f, 0.6f, 1.0f, 1.00f}; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffRefl_1); } ***************/ /**************** if(wire_flag == 0) { glBegin(GL_TRIANGLES); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; vert = g_frame->triangles[c][index]; if(flat_flag == 2) { norm[0] = g_frame->normals[vert][0]; norm[1] = g_frame->normals[vert][1]; norm[2] = g_frame->normals[vert][2]; } glNormal3d(norm[0], norm[1], norm[2]); glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2] ); } glEnd(); } else { glBegin(GL_LINE_STRIP); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; vert = g_frame->triangles[c][index]; if(flat_flag == 2) { norm[0] = g_frame->normals[vert][0]; norm[1] = g_frame->normals[vert][1]; norm[2] = g_frame->normals[vert][2]; if (my_bool_0) { norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } } glNormal3d(norm[0], norm[1], norm[2]); glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } vert = g_frame->triangles[c][i]; glNormal3d(norm[0], norm[1], norm[2]); glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); glEnd(); } **********************/ f.resize(3); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; f[ii] = g_frame->triangles[c][index]; } if (normalflag == 1 && nflag == 0) { f0 = f[0]; f2 = f[2]; f[0] = f2; f[2] = f0; } newfaces->push_back(f); } } // void MyDrawer::display_hexa(int c, int normalflag, int wireframe,IntArray *newfaces) { //std::cout<< "Inside MyDrawer. display_hexa\n"; float v0[3], v1[3], v2[3], v3[3], v4[3], v5[3], v6[3], v7[3]; int vert, ii, jj, my_bool, my_bool_1, my_bool_2, my_bool_3; vert = g_frame->quads[6*c][0]; for(ii = 0; ii < 3; ii++) v0[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c][1]; for(ii = 0; ii < 3; ii++) v3[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c][2]; for(ii = 0; ii < 3; ii++) v7[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c][3]; for(ii = 0; ii < 3; ii++) v4[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c+1][0]; for(ii = 0; ii < 3; ii++) v2[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c+1][1]; for(ii = 0; ii < 3; ii++) v1[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c+1][2]; for(ii = 0; ii < 3; ii++) v5[ii] = g_frame->verts[vert][ii]; vert = g_frame->quads[6*c+1][3]; for(ii = 0; ii < 3; ii++) v6[ii] = g_frame->verts[vert][ii]; my_bool = (v0[0] <= plane_x) && (v1[0] <= plane_x) && (v2[0] <= plane_x) && (v3[0] <= plane_x) && (v4[0] <= plane_x) && (v5[0] <= plane_x) && (v6[0] <= plane_x) && (v7[0] <= plane_x); my_bool_1 = (v0[0] >= plane_x) && (v1[0] > plane_x) && (v2[0] > plane_x) && (v3[0] >= plane_x) && (v4[0] >= plane_x) && (v5[0] > plane_x) && (v6[0] > plane_x) && (v7[0] >= plane_x); my_bool_3 = (v0[0] == plane_x) && (v3[0] == plane_x) && (v4[0] == plane_x) && (v7[0] == plane_x); /****************** if(wireframe == 0) { if(my_bool) { for(ii = 0; ii < 6; ii++) { display_tri(0, 1, 2, 6*c+ii, normalflag); display_tri(2, 3, 0, 6*c+ii, normalflag); } } else { if(my_bool_1 == 0 || my_bool_3 == 1) { for(ii = 0; ii < 6; ii++) { normalflag = -1; display_tri(0, 1, 2, 6*c+ii, normalflag); display_tri(2, 3, 0, 6*c+ii, normalflag); } } } } else { for (ii = 0; ii < 6; ii++) { glBegin(GL_LINE_STRIP); my_bool_2 = abs(g_frame->bound_sign[g_frame->quads[6*c+ii][0]]) == 1 && abs(g_frame->bound_sign[g_frame->quads[6*c+ii][1]]) == 1 && abs(g_frame->bound_sign[g_frame->quads[6*c+ii][2]]) == 1 && abs(g_frame->bound_sign[g_frame->quads[6*c+ii][3]]) == 1; if(my_bool) { if(my_bool_2) { for(jj = 0; jj < 4; jj++) { vert = g_frame->quads[6*c+ii][jj]; glVertex3d(g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } vert = g_frame->quads[6*c+ii][0]; glVertex3d(g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } } else { if(my_bool_1 == 0 || my_bool_3 == 1) { for(jj = 0; jj < 4; jj++) { vert = g_frame->quads[6*c+ii][jj]; if(g_frame->verts[vert][0] > plane_x) //glVertex3d(plane_x, g_frame->verts[vert][1], g_frame->verts[vert][2]); glVertex3d(g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); else glVertex3d(g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } vert = g_frame->quads[6*c+ii][0]; if(g_frame->verts[vert][0] > plane_x) //glVertex3d(plane_x, g_frame->verts[vert][1], g_frame->verts[vert][2]); glVertex3d(g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); else glVertex3d(g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } } glEnd(); } } ****************/ if(my_bool) { for(ii = 0; ii < 6; ii++) { display_tri(0, 1, 2, 6*c+ii, normalflag, newfaces); display_tri(2, 3, 0, 6*c+ii, normalflag, newfaces); } } else { if(my_bool_1 == 0 || my_bool_3 == 1) { for(ii = 0; ii < 6; ii++) { normalflag = -1; display_tri(0, 1, 2, 6*c+ii, normalflag, newfaces); display_tri(2, 3, 0, 6*c+ii, normalflag, newfaces); } } } } // void MyDrawer::display_tri00(int i, int j, int k, int c, int normalflag, int wire_flag, int num_eq, IntArray *newfaces) { //std::cout<< "Inside MyDrawer. display_tri00\n"; float v1[3], v2[3], norm[3]; int vert, ii, index, my_bool, my_bool_0 = 0, my_bool_1, my_bool_2, f0, f2, nflag; vector f; nflag = 0; my_bool = (g_frame->bound_sign[g_frame->triangles[c][0]] == 1) && (g_frame->bound_sign[g_frame->triangles[c][1]] == 1) && (g_frame->bound_sign[g_frame->triangles[c][2]] == 1); my_bool_0 = (g_frame->bound_sign[g_frame->triangles[c][0]] == -1) && (g_frame->bound_sign[g_frame->triangles[c][1]] == -1) && (g_frame->bound_sign[g_frame->triangles[c][2]] == -1); my_bool_1 = (g_frame->verts[g_frame->triangles[c][i]][0] == plane_x) && (g_frame->verts[g_frame->triangles[c][j]][0] == plane_x) && (g_frame->verts[g_frame->triangles[c][k]][0] == plane_x) && (num_eq == 3); my_bool_2 = (g_frame->verts[g_frame->triangles[c][i]][2] == plane_z) && (g_frame->verts[g_frame->triangles[c][j]][2] == plane_z) && (g_frame->verts[g_frame->triangles[c][k]][2] == plane_z) && (num_eq == -3); //if(my_bool || abs(num_eq) == 3) { if(my_bool || my_bool_0 || my_bool_1 || my_bool_2) { vert = g_frame->triangles[c][i]; v1[0] = v2[0] = -g_frame->verts[vert][0]; v1[1] = v2[1] = -g_frame->verts[vert][1]; v1[2] = v2[2] = -g_frame->verts[vert][2]; vert = g_frame->triangles[c][j]; v1[0] += g_frame->verts[vert][0]; v1[1] += g_frame->verts[vert][1]; v1[2] += g_frame->verts[vert][2]; vert = g_frame->triangles[c][k]; v2[0] += g_frame->verts[vert][0]; v2[1] += g_frame->verts[vert][1]; v2[2] += g_frame->verts[vert][2]; cross(norm, v1, v2); // normal flipping if (normalflag == 1 && my_bool) { norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } if (g_frame->bound_tri[c] == 1) { //std::cout << "in display_tri00 normal flipping, c = " << c << "\n"; nflag = 1; norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } vert = g_frame->triangles[c][i]; v1[0] = g_frame->verts[vert][0]; v1[1] = g_frame->verts[vert][1]; v1[2] = g_frame->verts[vert][2]; /********************** if(my_bool_0) { //if(my_bool && v1[0]*v1[0] + v1[1]*v1[1] + v1[2]*v1[2] < 90000.0) { GLfloat diffRefl[] = {1.0, 0.0, 0.0, 1.00}; //GLfloat diffRefl[] = {1.0, 0.7, 0.0, 1.00}; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffRefl); } else { //GLfloat diffRefl_1[] = {0.0, 0.6, 0.5, 1.00}; GLfloat diffRefl_1[] = {1.0f, 0.7f, 0.0f, 1.00f}; glMaterialfv(GL_FRONT, GL_DIFFUSE, diffRefl_1); } *********************/ /********************* if(wire_flag == 0) { glBegin(GL_TRIANGLES); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; vert = g_frame->triangles[c][index]; if(flat_flag == 2) { norm[0] = g_frame->normals[vert][0]; norm[1] = g_frame->normals[vert][1]; norm[2] = g_frame->normals[vert][2]; if (my_bool_0) { norm[0] = -norm[0]; norm[1] = -norm[1]; norm[2] = -norm[2]; } } if((my_bool == 0 || my_bool_0 == 1) && num_eq == 3) { norm[0] = 1.0; norm[1] = 0.0; norm[2] = 0.0; } if((my_bool == 0 || my_bool_0 == 1) && num_eq == -3) { norm[0] = 0.0; norm[1] = 0.0; norm[2] = 1.0; } glNormal3d(norm[0], norm[1], norm[2]); glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } glEnd(); } else { glBegin(GL_LINE_STRIP); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; vert = g_frame->triangles[c][index]; if(flat_flag == 2) { norm[0] = g_frame->normals[vert][0]; norm[1] = g_frame->normals[vert][1]; norm[2] = g_frame->normals[vert][2]; } if((my_bool == 0 || my_bool_0 == 1) && num_eq == 3) { norm[0] = 1.0; norm[1] = 0.0; norm[2] = 0.0; } if((my_bool == 0 || my_bool_0 == 1) && num_eq == -3) { norm[0] = 0.0; norm[1] = 0.0; norm[2] = 1.0; } glNormal3d(norm[0], norm[1], norm[2]); glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); } vert = g_frame->triangles[c][i]; glNormal3d(norm[0], norm[1], norm[2]); glVertex3d( g_frame->verts[vert][0], g_frame->verts[vert][1], g_frame->verts[vert][2]); glEnd(); } ************/ if (my_bool_1 && cut_flag) // this triangle is on the cut plane and is displayed // by display_tri_vv() { //std::cout << "[" << f[0] << " ," << f[1] << " ," << f[2] << "]," << "\n"; return; } if (my_bool_2 && cut_flag) // this triangle is on the cut plane and is displayed // by display_tri_vv() return; else { f.resize(3); for(ii = 0; ii < 3; ii++) { index = i; if(ii == 1) index = j; if(ii == 2) index = k; f[ii] = g_frame->triangles[c][index]; } if (normalflag == 1 && nflag == 0) { f0 = f[0]; f2 = f[2]; f[0] = f2; f[2] = f0; } newfaces->push_back(f); } } } // outputs vertices for the cutout section void MyDrawer::display_tri_vv(float* v0, float* v1, float* v2, int c, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_tri_vv\n"; float vv01[3], vv02[3], norm[3]; int ii, my_bool, my_bool_0, vert; if(c == -1) { my_bool = 1; my_bool_0 = 0; } else { my_bool = (g_frame->bound_sign[g_frame->triangles[c][0]] == 1) && (g_frame->bound_sign[g_frame->triangles[c][1]] == 1) && (g_frame->bound_sign[g_frame->triangles[c][2]] == 1); my_bool_0 = (g_frame->bound_sign[g_frame->triangles[c][0]] == -1) && (g_frame->bound_sign[g_frame->triangles[c][1]] == -1) && (g_frame->bound_sign[g_frame->triangles[c][2]] == -1); } for(ii = 0; ii < 3; ii++) { vv01[ii] = v1[ii] - v0[ii]; vv02[ii] = v2[ii] - v0[ii]; } cross(norm, vv01, vv02); // normal flipping if (normalflag == 1) { for(ii = 0; ii < 3; ii++) norm[ii] = - norm[ii]; } /**** vert = g_frame->triangles[c][0]; // this gave segmentation fault whith c= -1 vv01[0] = g_frame->verts[vert][0]; vv01[1] = g_frame->verts[vert][1]; vv01[2] = g_frame->verts[vert][2]; ***/ /***************** if(wire_flag == 1) { } else { glBegin(GL_TRIANGLES); if(flat_flag == 2 && c != -1) { vert = g_frame->triangles[c][0]; if(g_frame->bound_sign[vert] == -1) { norm[0] = -norm[0]; norm[1]= -norm[1]; norm[2]=-norm[2] } else { norm[0] = g_frame->normals[vert][0]; norm[1] = g_frame->normals[vert][1]; norm[2] = g_frame->normals[vert][2]; } glVertex3d(v0[0], v0[1], v0[2]); vert = g_frame->triangles[c][1]; if(g_frame->bound_sign[vert] == -1) { glNormal3d(-norm[0], -norm[1], -norm[2]); } else { glNormal3d(g_frame->normals[vert][0], g_frame->normals[vert][1], g_frame->normals[vert][2]); } glVertex3d(v1[0], v1[1], v1[2]); vert = g_frame->triangles[c][2]; if(g_frame->bound_sign[vert] == -1) { glNormal3d(-norm[0], -norm[1], -norm[2]); } else { glNormal3d(g_frame->normals[vert][0], g_frame->normals[vert][1], g_frame->normals[vert][2]); } glVertex3d(v2[0], v2[1], v2[2]); } else { glNormal3d(norm[0], norm[1], norm[2]); glVertex3d(v0[0], v0[1], v0[2]); glVertex3d(v1[0], v1[1], v1[2]); glVertex3d(v2[0], v2[1], v2[2]); } glEnd(); } ********************/ int noremove = 0; // indicates if the vertex can be removed from the list of vertices if it is duplicated if(c != -1) // vertices on the intersection of clipping planes with the isosurface { //std::cout << vcount << ", " < plane_z || v2[2] > plane_z) { v0[2] = plane_z; add_tri = 1; } } if (v1[2]< plane_z) { if (v0[2] > plane_z || v2[2] > plane_z) { v1[2] = plane_z; add_tri = 1; } } if ( v2[2] < plane_z) { if (v0[2] > plane_z || v1[2] > plane_z) { v2[2] = plane_z; add_tri = 1; } } if (! add_tri) return; /******* else{ std::cout << "vcount: " << vcount << "\n"; std::cout << "z_plane: old verts: \n" ; std::cout<< "["< plane_x || v2[0] > plane_x) { v0[0] = plane_x; add_tri = 1; } } if (v1[0]< plane_x) { if (v0[0] > plane_x || v2[0] > plane_x) { v1[0] = plane_x; add_tri = 1; } } if(v2[0] < plane_x) { if (v0[0] > plane_x || v1[0] > plane_x) { v2[0] = plane_x; add_tri = 1; } } if (!add_tri) return; /******* else{ std::cout << "vcount: " << vcount << "\n"; std::cout << "x_plane: old verts: \n" ; std::cout<< "["< t1, t2, t3; t1.resize(4); t2.resize(4); t3.resize(4); t1[0] = v0[0]; t1[1] = v0[1]; t1[2] = v0[2]; t1[3] = noremove; t2[0] = v1[0]; t2[1] = v1[1]; t2[2] = v1[2]; t2[3] = noremove; t3[0] = v2[0]; t3[1] = v2[1]; t3[2] = v2[2]; t3[3] = noremove; if (normalflag == 1) { vertset->push_back(t3); vertset->push_back(t2); vertset->push_back(t1); } else { vertset->push_back(t1); vertset->push_back(t2); vertset->push_back(t3); } /****** std::vector v; v.resize(3); v[0] = v0[0]; v[1]=v0[1]; v[2]= v0[2]; vertset->push_back(v); v[0] = v1[0]; v[1] = v1[1]; v[2] = v1[2]; vertset->push_back(v); v[0] = v2[0]; v[1]= v2[1]; v[2] = v2[2]; vertset->push_back(v); ***/ vcount = vcount +3; } // void MyDrawer::display_permute_1(float* v0, float* v1, float* v2, float* v3) { //std::cout<< "Inside MyDrawer. display_permute_1\n"; float vv0[3], vv1[3], vv2[3], vv3[3]; int ii; for(ii = 0; ii < 3; ii++) { vv0[ii] = v0[ii]; vv1[ii] = v1[ii]; vv2[ii] = v2[ii]; vv3[ii] = v3[ii]; } if(vv0[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv3[ii]; v2[ii] = vv2[ii]; v3[ii] = vv0[ii]; } } if(vv1[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv2[ii]; v2[ii] = vv3[ii]; v3[ii] = vv1[ii]; } } if(vv2[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv0[ii]; v2[ii] = vv3[ii]; v3[ii] = vv2[ii]; } } } // void MyDrawer::display_permute_1_z(float* v0, float* v1, float* v2, float* v3) { //std::cout<< "Inside MyDrawer. display)permute_1_z\n"; float vv0[3], vv1[3], vv2[3], vv3[3]; int ii; for(ii = 0; ii < 3; ii++) { vv0[ii] = v0[ii]; vv1[ii] = v1[ii]; vv2[ii] = v2[ii]; vv3[ii] = v3[ii]; } if(vv0[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv3[ii]; v2[ii] = vv2[ii]; v3[ii] = vv0[ii]; } } if(vv1[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv2[ii]; v2[ii] = vv3[ii]; v3[ii] = vv1[ii]; } } if(vv2[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv0[ii]; v2[ii] = vv3[ii]; v3[ii] = vv2[ii]; } } } // void MyDrawer::display_permute_2(float* v0, float* v1, float* v2, float* v3) { //std::cout<< "Inside MyDrawer. display_permute_2\n"; float vv0[3], vv1[3], vv2[3], vv3[3]; int ii; for(ii = 0; ii < 3; ii++) { vv0[ii] = v0[ii]; vv1[ii] = v1[ii]; vv2[ii] = v2[ii]; vv3[ii] = v3[ii]; } if(vv0[0] <= plane_x && vv2[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv2[ii]; v2[ii] = vv3[ii]; v3[ii] = vv1[ii]; } } if(vv0[0] <= plane_x && vv3[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv3[ii]; v2[ii] = vv1[ii]; v3[ii] = vv2[ii]; } } if(vv2[0] <= plane_x && vv1[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv2[ii]; v1[ii] = vv1[ii]; v2[ii] = vv3[ii]; v3[ii] = vv0[ii]; } } if(vv1[0] <= plane_x && vv3[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv3[ii]; v2[ii] = vv2[ii]; v3[ii] = vv0[ii]; } } if(vv2[0] <= plane_x && vv3[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv2[ii]; v1[ii] = vv3[ii]; v2[ii] = vv0[ii]; v3[ii] = vv1[ii]; } } } // void MyDrawer::display_permute_2_z(float* v0, float* v1, float* v2, float* v3) { //std::cout<< "Inside MyDrawer. display_permute_2_z.\n"; float vv0[3], vv1[3], vv2[3], vv3[3]; int ii; for(ii = 0; ii < 3; ii++) { vv0[ii] = v0[ii]; vv1[ii] = v1[ii]; vv2[ii] = v2[ii]; vv3[ii] = v3[ii]; } if(vv0[2] <= plane_z && vv2[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv2[ii]; v2[ii] = vv3[ii]; v3[ii] = vv1[ii]; } } if(vv0[2] <= plane_z && vv3[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv3[ii]; v2[ii] = vv1[ii]; v3[ii] = vv2[ii]; } } if(vv2[2] <= plane_z && vv1[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv2[ii]; v1[ii] = vv1[ii]; v2[ii] = vv3[ii]; v3[ii] = vv0[ii]; } } if(vv1[2] <= plane_z && vv3[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv3[ii]; v2[ii] = vv2[ii]; v3[ii] = vv0[ii]; } } if(vv2[2] <= plane_z && vv3[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv2[ii]; v1[ii] = vv3[ii]; v2[ii] = vv0[ii]; v3[ii] = vv1[ii]; } } } // void MyDrawer::display_permute_3(float* v0, float* v1, float* v2, float* v3) { //std::cout<< "Inside MyDrawer. display_permute_3.\n"; float vv0[3], vv1[3], vv2[3], vv3[3]; int ii; for(ii = 0; ii < 3; ii++) { vv0[ii] = v0[ii]; vv1[ii] = v1[ii]; vv2[ii] = v2[ii]; vv3[ii] = v3[ii]; } if(vv1[0] <= plane_x && vv2[0] <= plane_x && vv3[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv3[ii]; v2[ii] = vv2[ii]; v3[ii] = vv0[ii]; } } if(vv0[0] <= plane_x && vv2[0] <= plane_x && vv3[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv2[ii]; v2[ii] = vv3[ii]; v3[ii] = vv1[ii]; } } if(vv0[0] <= plane_x && vv1[0] <= plane_x && vv3[0] <= plane_x) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv0[ii]; v2[ii] = vv3[ii]; v3[ii] = vv2[ii]; } } } // void MyDrawer::display_permute_3_z(float* v0, float* v1, float* v2, float* v3) { //std::cout<< "Inside MyDrawer. display_permute_3_z\n"; float vv0[3], vv1[3], vv2[3], vv3[3]; int ii; for(ii = 0; ii < 3; ii++) { vv0[ii] = v0[ii]; vv1[ii] = v1[ii]; vv2[ii] = v2[ii]; vv3[ii] = v3[ii]; } if(vv1[2] <= plane_z && vv2[2] <= plane_z && vv3[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv3[ii]; v2[ii] = vv2[ii]; v3[ii] = vv0[ii]; } } if(vv0[2] <= plane_z && vv2[2] <= plane_z && vv3[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv0[ii]; v1[ii] = vv2[ii]; v2[ii] = vv3[ii]; v3[ii] = vv1[ii]; } } if(vv0[2] <= plane_z && vv1[2] <= plane_z && vv3[2] <= plane_z) { for(ii = 0; ii < 3; ii++) { v0[ii] = vv1[ii]; v1[ii] = vv0[ii]; v2[ii] = vv3[ii]; v3[ii] = vv2[ii]; } } } // void MyDrawer::display_1(int* vert_bound, int c, float* v0, float* v1, float* v2, float* v3, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_1.\n"; float vv0[3], vv1[3], vv2[3], ratio_0, ratio_1, ratio_2; vv0[0] = plane_x; ratio_0 = (plane_x - v0[0]) / (v3[0] - v0[0]); vv0[1] = v0[1] + ratio_0 * (v3[1] - v0[1]); vv0[2] = v0[2] + ratio_0 * (v3[2] - v0[2]); vv1[0] = plane_x; ratio_1 = (plane_x - v1[0]) / (v3[0] - v1[0]); vv1[1] = v1[1] + ratio_1 * (v3[1] - v1[1]); vv1[2] = v1[2] + ratio_1 * (v3[2] - v1[2]); vv2[0] = plane_x; ratio_2 = (plane_x - v2[0]) / (v3[0] - v2[0]); vv2[1] = v2[1] + ratio_2 * (v3[1] - v2[1]); vv2[2] = v2[2] + ratio_2 * (v3[2] - v2[2]); display_tri_vv(vv0, vv2, vv1, -1, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv1, vv2, v3, 4*c+1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv2, vv0, v3, 4*c+2, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) display_tri_vv(vv0, vv1, v3, 4*c+3, 1, wire_flag, vertset); } // void MyDrawer::display_1_z(int* vert_bound, int c, float* v0, float* v1, float* v2, float* v3, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_1_z.\n"; float vv0[3], vv1[3], vv2[3], ratio_0, ratio_1, ratio_2; vv0[2] = plane_z; ratio_0 = (plane_z - v0[2]) / (v3[2] - v0[2]); vv0[1] = v0[1] + ratio_0 * (v3[1] - v0[1]); vv0[0] = v0[0] + ratio_0 * (v3[0] - v0[0]); vv1[2] = plane_z; ratio_1 = (plane_z - v1[2]) / (v3[2] - v1[2]); vv1[1] = v1[1] + ratio_1 * (v3[1] - v1[1]); vv1[0] = v1[0] + ratio_1 * (v3[0] - v1[0]); vv2[2] = plane_z; ratio_2 = (plane_z - v2[2]) / (v3[2] - v2[2]); vv2[1] = v2[1] + ratio_2 * (v3[1] - v2[1]); vv2[0] = v2[0] + ratio_2 * (v3[0] - v2[0]); display_tri_vv(vv0, vv2, vv1, -1, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv1, vv2, v3, 4*c+1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv2, vv0, v3, 4*c+2, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) display_tri_vv(vv0, vv1, v3, 4*c+3, 1, wire_flag, vertset); } // void MyDrawer::display_2(int* vert_bound, int c, float* v0, float* v1, float* v2, float* v3, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_2.\n"; float vv0[3], vv1[3], vv2[3], vv3[3], ratio_0, ratio_1, ratio_2, ratio_3; vv0[0] = plane_x; ratio_0 = (plane_x - v0[0]) / (v3[0] - v0[0]); vv0[1] = v0[1] + ratio_0 * (v3[1] - v0[1]); vv0[2] = v0[2] + ratio_0 * (v3[2] - v0[2]); vv1[0] = plane_x; ratio_1 = (plane_x - v1[0]) / (v3[0] - v1[0]); vv1[1] = v1[1] + ratio_1 * (v3[1] - v1[1]); vv1[2] = v1[2] + ratio_1 * (v3[2] - v1[2]); vv2[0] = plane_x; ratio_2 = (plane_x - v0[0]) / (v2[0] - v0[0]); vv2[1] = v0[1] + ratio_2 * (v2[1] - v0[1]); vv2[2] = v0[2] + ratio_2 * (v2[2] - v0[2]); vv3[0] = plane_x; ratio_3 = (plane_x - v1[0]) / (v2[0] - v1[0]); vv3[1] = v1[1] + ratio_3 * (v2[1] - v1[1]); vv3[2] = v1[2] + ratio_3 * (v2[2] - v1[2]); if(ratio_0 != 0.0 && ratio_1 == 0.0) { display_tri_vv(vv0, v1, vv2, -1, 1, wire_flag, vertset); if(abs(vert_bound[0]) == 1) display_tri_vv(vv0, vv2, v0, 4*c+2, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) display_tri_vv(vv0, v0, v1, 4*c+3, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) display_tri_vv(vv2, v1, v0, 4*c, 1, wire_flag, vertset); } if(ratio_0 == 0.0 && ratio_1 != 0.0) { display_tri_vv(vv1, vv3, v0, -1, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv1, v1, vv3, 4*c+1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) display_tri_vv(vv1, v0, v1, 4*c+3, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) display_tri_vv(vv3, v1, v0, 4*c, 1, wire_flag, vertset); } if(ratio_0 != 0.0 && ratio_1 != 0.0) { display_tri_vv(vv0, vv1, vv2, -1, 1, wire_flag, vertset); display_tri_vv(vv1, vv3, vv2, -1, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv3, vv1, v1, 4*c+1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv0, vv2, v0, 4*c+2, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) { display_tri_vv(vv1, vv0, v0, 4*c+3, 1, wire_flag, vertset); display_tri_vv(vv1, v0, v1, 4*c+3, 1, wire_flag, vertset); } if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) { display_tri_vv(vv2, vv3, v1, 4*c, 1, wire_flag, vertset); display_tri_vv(vv2, v1, v0, 4*c, 1, wire_flag, vertset); } } } // void MyDrawer::display_2_z(int* vert_bound, int c, float* v0, float* v1, float* v2, float* v3, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_2_z.\n"; float vv0[3], vv1[3], vv2[3], vv3[3], ratio_0, ratio_1, ratio_2, ratio_3; vv0[2] = plane_z; ratio_0 = (plane_z - v0[2]) / (v3[2] - v0[2]); vv0[1] = v0[1] + ratio_0 * (v3[1] - v0[1]); vv0[0] = v0[0] + ratio_0 * (v3[0] - v0[0]); vv1[2] = plane_z; ratio_1 = (plane_z - v1[2]) / (v3[2] - v1[2]); vv1[1] = v1[1] + ratio_1 * (v3[1] - v1[1]); vv1[0] = v1[0] + ratio_1 * (v3[0] - v1[0]); vv2[2] = plane_z; ratio_2 = (plane_z - v0[2]) / (v2[2] - v0[2]); vv2[1] = v0[1] + ratio_2 * (v2[1] - v0[1]); vv2[0] = v0[0] + ratio_2 * (v2[0] - v0[0]); vv3[2] = plane_z; ratio_3 = (plane_z - v1[2]) / (v2[2] - v1[2]); vv3[1] = v1[1] + ratio_3 * (v2[1] - v1[1]); vv3[0] = v1[0] + ratio_3 * (v2[0] - v1[0]); if(ratio_0 != 0.0 && ratio_1 == 0.0) { display_tri_vv(vv0, v1, vv2, -1, 1, wire_flag, vertset); if(abs(vert_bound[0]) == 1) display_tri_vv(vv0, vv2, v0, 4*c+2, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) display_tri_vv(vv0, v0, v1, 4*c+3, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) display_tri_vv(vv2, v1, v0, 4*c, 1, wire_flag, vertset); } if(ratio_0 == 0.0 && ratio_1 != 0.0) { display_tri_vv(vv1, vv3, v0, -1, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv1, v1, vv3, 4*c+1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) display_tri_vv(vv1, v0, v1, 4*c+3, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) display_tri_vv(vv3, v1, v0, 4*c, 1, wire_flag, vertset); } if(ratio_0 != 0.0 && ratio_1 != 0.0) { display_tri_vv(vv0, vv1, vv2, -1, 1, wire_flag, vertset); display_tri_vv(vv1, vv3, vv2, -1, 1, wire_flag,vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv3, vv1, v1, 4*c+1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) display_tri_vv(vv0, vv2, v0, 4*c+2, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[3]) == 3) { display_tri_vv(vv1, vv0, v0, 4*c+3, 1, wire_flag, vertset); display_tri_vv(vv1, v0, v1, 4*c+3, 1, wire_flag, vertset); } if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) { display_tri_vv(vv2, vv3, v1, 4*c, 1, wire_flag, vertset); display_tri_vv(vv2, v1, v0, 4*c, 1, wire_flag, vertset); } } } // void MyDrawer::display_3(int* vert_bound, int c, float* v0, float* v1, float* v2, float* v3, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_3.\n"; float vv0[3], vv1[3], vv2[3], ratio_0, ratio_1, ratio_2; vv0[0] = plane_x; ratio_0 = (plane_x - v0[0]) / (v3[0] - v0[0]); vv0[1] = v0[1] + ratio_0 * (v3[1] - v0[1]); vv0[2] = v0[2] + ratio_0 * (v3[2] - v0[2]); vv1[0] = plane_x; ratio_1 = (plane_x - v1[0]) / (v3[0] - v1[0]); vv1[1] = v1[1] + ratio_1 * (v3[1] - v1[1]); vv1[2] = v1[2] + ratio_1 * (v3[2] - v1[2]); vv2[0] = plane_x; ratio_2 = (plane_x - v2[0]) / (v3[0] - v2[0]); vv2[1] = v2[1] + ratio_2 * (v3[1] - v2[1]); vv2[2] = v2[2] + ratio_2 * (v3[2] - v2[2]); if(ratio_0 <= 0.001 && ratio_1 <= 0.01 && ratio_2 <= 0.001) { //if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 0) { display_tri_vv(vv0, vv1, vv2, -1, 1, wire_flag, vertset); } else { display_tri_vv(vv0, vv1, vv2, -1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) display_tri_vv(v0, v2, v1, 4*c, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) { display_tri_vv(v1, v2, vv2, 4*c+1, 1, wire_flag, vertset); display_tri_vv(v1, vv2, vv1, 4*c+1, 1, wire_flag, vertset); } if(abs(vert_bound[0]) + abs(vert_bound[2]) == 2) { display_tri_vv(v2, v0, vv2, 4*c+2, 1, wire_flag, vertset); display_tri_vv(vv2, v0, vv0, 4*c+2, 1, wire_flag, vertset); } if(abs(vert_bound[0]) + abs(vert_bound[1]) == 2) { display_tri_vv(v1, vv0, v0, 4*c+3, 1, wire_flag, vertset); display_tri_vv(v1, vv1, vv0, 4*c+3, 1, wire_flag, vertset); } } } // void MyDrawer::display_3_z(int* vert_bound, int c, float* v0, float* v1, float* v2, float* v3, int normalflag, int wire_flag, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_3_z\n"; float vv0[3], vv1[3], vv2[3], ratio_0, ratio_1, ratio_2; vv0[2] = plane_z; ratio_0 = (plane_z - v0[2]) / (v3[2] - v0[2]); vv0[1] = v0[1] + ratio_0 * (v3[1] - v0[1]); vv0[0] = v0[0] + ratio_0 * (v3[0] - v0[0]); vv1[2] = plane_z; ratio_1 = (plane_z - v1[2]) / (v3[2] - v1[2]); vv1[1] = v1[1] + ratio_1 * (v3[1] - v1[1]); vv1[0] = v1[0] + ratio_1 * (v3[0] - v1[0]); vv2[2] = plane_z; ratio_2 = (plane_z - v2[2]) / (v3[2] - v2[2]); vv2[1] = v2[1] + ratio_2 * (v3[1] - v2[1]); vv2[0] = v2[0] + ratio_2 * (v3[0] - v2[0]); if(ratio_0 == 0.0 && ratio_1 == 0.0 && ratio_2 == 0.0) { display_tri_vv(vv0, vv1, vv2, -1, 1, wire_flag, vertset); } else { display_tri_vv(vv0, vv1, vv2, -1, 1, wire_flag, vertset); if(abs(vert_bound[0]) + abs(vert_bound[1]) + abs(vert_bound[2]) == 3) display_tri_vv(v0, v2, v1, 4*c, 1, wire_flag, vertset); if(abs(vert_bound[1]) + abs(vert_bound[2]) + abs(vert_bound[3]) == 3) { display_tri_vv(v1, v2, vv2, 4*c+1, 1, wire_flag, vertset); display_tri_vv(v1, vv2, vv1, 4*c+1, 1, wire_flag, vertset); } if(abs(vert_bound[0]) + abs(vert_bound[2]) == 2) { display_tri_vv(v2, v0, vv2, 4*c+2, 1, wire_flag, vertset); display_tri_vv(vv2, v0, vv0, 4*c+2, 1, wire_flag, vertset); } if(abs(vert_bound[0]) + abs(vert_bound[1]) == 2) { display_tri_vv(v1, vv1, vv0, 4*c+3, 1, wire_flag, vertset); display_tri_vv(v1, vv0, v0, 4*c+3, 1, wire_flag, vertset); } } } // void MyDrawer::display_tetra(int c, int normalflag, int wire_flag, IntArray *newfaces, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_tetra\n"; float v0[3], v1[3], v2[3], v3[3], v[4][3]; int vert, ii, jj, num_le, num_eq, vert_bound[4]; for(ii = 0; ii < 3; ii++) { vert = g_frame->triangles[4*c][ii]; vert_bound[ii] = g_frame->bound_sign[vert]; for(jj = 0; jj < 3; jj++) v[ii][jj] = g_frame->verts[vert][jj]; } vert = g_frame->triangles[4*c+1][2]; vert_bound[3] = g_frame->bound_sign[vert]; for(jj = 0; jj < 3; jj++) v[3][jj] = g_frame->verts[vert][jj]; num_le = 0; num_eq = 0; for(ii = 0; ii < 4; ii++) { if(v[ii][0] <= plane_x) num_le++; if(v[ii][0] == plane_x) num_eq++; } assert(num_le >= 0 && num_le <= 4); for(ii = 0; ii < 3; ii++) { v0[ii] = v[0][ii]; v1[ii] = v[2][ii]; v2[ii] = v[1][ii]; v3[ii] = v[3][ii]; } if(num_le == 1) { display_permute_1(v0, v1, v2, v3); display_1(vert_bound, c, v0, v1, v2, v3, normalflag, wire_flag, vertset); } if(num_le == 2) { display_permute_2(v0, v1, v2, v3); display_2(vert_bound, c, v0, v1, v2, v3, normalflag, wire_flag,vertset); } if(num_le == 3) { display_permute_3(v0, v1, v2, v3); display_3(vert_bound, c, v0, v1, v2, v3, normalflag, wire_flag, vertset); } if(num_le == 4) { display_tri00(0, 1, 2, 4*c, normalflag, wire_flag, num_eq, newfaces); display_tri00(0, 1, 2, 4*c+1, normalflag, wire_flag, num_eq, newfaces); display_tri00(0, 1, 2, 4*c+2, normalflag, wire_flag, num_eq, newfaces); display_tri00(0, 1, 2, 4*c+3, normalflag, wire_flag, num_eq, newfaces); } } // void MyDrawer::display_tetra_in(int c, int normalflag, int wire_flag, IntArray *newfaces, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display_tetra_in.\n"; float v0[3], v1[3], v2[3], v3[3], v[4][3]; int vert, ii, jj, num_le, num_eq, vert_bound[4]; for(ii = 0; ii < 3; ii++) { vert = g_frame->triangles[4*c][ii]; vert_bound[ii] = g_frame->bound_sign[vert]; for(jj = 0; jj < 3; jj++) v[ii][jj] = g_frame->verts[vert][jj]; } vert = g_frame->triangles[4*c+1][2]; vert_bound[3] = g_frame->bound_sign[vert]; for(jj = 0; jj < 3; jj++) v[3][jj] = g_frame->verts[vert][jj]; num_le = 0; num_eq = 0; for(ii = 0; ii < 4; ii++) { if(v[ii][2] <= plane_z) num_le++; if(v[ii][2] == plane_z) num_eq++; } assert(num_le >= 0 && num_le <= 4); for(ii = 0; ii < 3; ii++) { v0[ii] = v[0][ii]; v1[ii] = v[2][ii]; v2[ii] = v[1][ii]; v3[ii] = v[3][ii]; } if( (v[0][2] >= plane_z && v[0][0] >= plane_x) || (v[1][2] >= plane_z && v[1][0] >= plane_x) || (v[2][2] >= plane_z && v[2][0] >= plane_x) || (v[3][2] >= plane_z && v[3][0] >= plane_x)) { display_tetra(c, normalflag, wire_flag, newfaces, vertset); if(num_le == 1) { display_permute_1_z(v0, v1, v2, v3); display_1_z(vert_bound, c, v0, v1, v2, v3, normalflag, wire_flag, vertset); } if(num_le == 2) { display_permute_2_z(v0, v1, v2, v3); display_2_z(vert_bound, c, v0, v1, v2, v3, normalflag, wire_flag, vertset); } if(num_le == 3) { display_permute_3_z(v0, v1, v2, v3); display_3_z(vert_bound, c, v0, v1, v2, v3, normalflag, wire_flag, vertset); } if(num_le == 4) { display_tri00(0, 1, 2, 4*c, normalflag, wire_flag, -num_eq, newfaces); display_tri00(0, 1, 2, 4*c+1, normalflag, wire_flag, -num_eq, newfaces); display_tri00(0, 1, 2, 4*c+2, normalflag, wire_flag, -num_eq, newfaces); display_tri00(0, 1, 2, 4*c+3, normalflag, wire_flag, -num_eq, newfaces); } } else { display_tri0(0, 1, 2, 4*c, normalflag, wire_flag, newfaces); display_tri0(0, 1, 2, 4*c+1, normalflag, wire_flag, newfaces); display_tri0(0, 1, 2, 4*c+2, normalflag, wire_flag, newfaces); display_tri0(0, 1, 2, 4*c+3, normalflag, wire_flag, newfaces); } } void get_trinorm(float* tn, geoframe* g, int c, int normal_flag) { //std::cout<< "Inside MyDrawer. get_trinorm.\n"; float v1[3],v2[3]; int vert; vert = g->triangles[c][0]; v1[0] = v2[0] = -g->verts[vert][0]; v1[1] = v2[1] = -g->verts[vert][1]; v1[2] = v2[2] = -g->verts[vert][2]; vert = g->triangles[c][1]; v1[0] += g->verts[vert][0]; v1[1] += g->verts[vert][1]; v1[2] += g->verts[vert][2]; vert = g->triangles[c][2]; v2[0] += g->verts[vert][0]; v2[1] += g->verts[vert][1]; v2[2] += g->verts[vert][2]; cross(tn, v1, v2); // normal flipping if (normal_flag==1) { tn[0]=-tn[0]; tn[1]=-tn[1]; tn[2]=-tn[2]; } } // void MyDrawer::display(IntArray *newfaces, FloatArray * vertset) { //std::cout<< "Inside MyDrawer. display. " << "cut_flag = " << cut_flag << "\n"; int vert, c, index, ii, my_bool; //char* p; int normal_flag = 1; // 0, 1 std::vector f; //std::cout << "In Display : plane_x " << plane_x << ", plane_z " << plane_z << "\n"; //if (p=strstr("Head",fn)) normal_flag = 0; vcount =0; if (g_frame) { if((g_frame->numhexas * 6) != g_frame->numquads) cut_flag = 0; if(cut_flag == 1) { for(c = 0; c < ((g_frame->numtris)/4); c++) { display_tetra_in(c, normal_flag, 0, newfaces, vertset); //display_tetra(c, normal_flag, 0); } for(c = 0; c < g_frame->numhexas; c++) { display_hexa(c, normal_flag, 0, newfaces); } } else if(cut_flag == 2) { for (c=0; c<((g_frame->numtris)/4); c++) { display_tetra_in(c, normal_flag, 0, newfaces, vertset); } } else { for (c = 0; c < g_frame->numtris; c++) display_tri0(0, 1, 2, c, normal_flag, 0, newfaces); //display_tri0(0, 1, 2, c, 1, 0); for (c = 0; c < g_frame->numquads; c++) { //display_tri(0, 1, 2, c, normal_flag, newfaces); //display_tri(2, 3, 0, c, normal_flag, newfaces); my_bool = abs((int)g_frame->bound_sign[g_frame->quads[c][0]]) == 1 && abs((int)g_frame->bound_sign[g_frame->quads[c][1]]) == 1 && abs((int)g_frame->bound_sign[g_frame->quads[c][2]]) == 1 && abs((int)g_frame->bound_sign[g_frame->quads[c][3]]) == 1; if(my_bool) { f.push_back(g_frame->quads[c][3]); f.push_back(g_frame->quads[c][2]); f.push_back(g_frame->quads[c][1]); f.push_back(g_frame->quads[c][0]); newfaces->push_back(f); f.clear(); } } } } } void MyDrawer::setGeo(geoframe *g) { //std::cout<< "Inside MyDrawer. setGeo\n"; g_frame = g; } void MyDrawer::setExtents(double biggest, double cx, double cy, double cz) { //std::cout<< "Inside MyDrawer. setExtents\n"; biggestDim = biggest; centerx = cx; centery = cy; centerz = cz; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/interp_bit_generate.cpp0000755000175000017500000000371310150464521026562 0ustar debiandebian/* #include #include "octree.h" void Octree::interp_bit_generate() { int i_bit; int case_num; int i; case_num=(1<<18); interpol_bit=(int*)malloc(sizeof(int)*case_num); //fprintf(fp,"int interpol_bit[%d] = {\n",case_num); for (i=0;i #include #include #include "octree.h" #include "LBIE_Mesher.h" Octree oc; int main( int argc, char** argv ) { // We use head65.rawiv as a generic test input file const char* inputFile = "head65.rawiv"; // Files for storing the various different outputs const char* output_single = "test_single.raw"; const char* output_hexa = "test_hexa.raw"; const char* output_double = "test_double.raw"; const char* output_tetra = "test_tetra.raw"; const char* output_t_4_h = "test_t_4_h.raw"; const char* output_tetra2 = "test_tetra2.raw"; /**** Arguements for library tester LIBE_Mesher( input filename, output filename, outer isovalue, inner isovalue, outer err tol, inner err tol, meshtype ) To test the library, we first create an output .raw file with some arguements. Then we compare this with the .raw file created by LBIE-Mesher program. If they match, then the library is similar to the program. ****/ /* LBIE_Mesher( inputFile, output_single, 0.5, 0.0, 0.2, 0.0, 0 ); std::cout<< "Done!\n\n"; LBIE_Mesher( inputFile, output_hexa, 0.5, 0.0, 0.2, 0.0, 1 ); std::cout<< "Done!\n\n"; LBIE_Mesher( inputFile, output_tetra, 0.5, 0.0, 0.2, 0.0, 3 ); std::cout<< "Done!\n\n"; LBIE_Mesher( inputFile, output_t_4_h, 0.5, 0.0, 0.2, 0.0, 4 ); std::cout<< "Done!\n\n"; */ /* LBIE_Mesher( inputFile, output_double, 0.5, -0.1,0.2, -0.3,2 ); std::cout<< "Done!\n\n"; */ LBIE_Mesher( inputFile, output_tetra2, 0.5, -0.1,0.2, -0.3,5 ); std::cout<< "Done!\n\n"; return 0; }mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/normalspline.h0000755000175000017500000000073610150464521024723 0ustar debiandebian#include #include #include #include float InitialAntiCausalCoefficient(float *, int, float); float InitialCausalCoefficient(float *, int, float, float); void ConvertToInterpolationCoefficients(float *, int, float *, int ,float); void TransImg2Spline(float *, float *, int, int, int); double BS_Fun(double); double BS_GraFun(double); void GradientAtPoint(float *,float , float , float , int, int , int, float *); mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/cubes.h0000755000175000017500000007654310150464521023332 0ustar debiandebian/* * cubes.h - marching cubes table of cubes and associated tables * this file has been automatically generated * DO NOT EDIT * Copyright (c) 1997 Dan Schikore */ /* table of intersected edges (complete with holes) */ static unsigned char cubes[256][14] = { {0}, {1, 0, 3, 8}, {1, 9, 1, 0}, {2, 1, 3, 8, 1, 8, 9}, {1, 1, 11, 2}, {2, 0, 3, 8, 1, 11, 2}, {2, 9, 11, 2, 9, 2, 0}, {3, 2, 3, 11, 3, 8, 11, 11, 8, 9}, {1, 2, 10, 3}, {2, 0, 2, 10, 0, 10, 8}, {2, 3, 2, 10, 0, 9, 1}, {3, 1, 2, 9, 2, 10, 9, 9, 10, 8}, {2, 3, 1, 11, 3, 11, 10}, {3, 0, 1, 8, 1, 11, 8, 8, 11, 10}, {3, 3, 0, 10, 0, 9, 10, 10, 9, 11}, {2, 10, 8, 9, 10, 9, 11}, {1, 4, 8, 7}, {2, 3, 7, 4, 3, 4, 0}, {2, 4, 8, 7, 9, 1, 0}, {3, 4, 9, 7, 9, 1, 7, 7, 1, 3}, {2, 4, 8, 7, 2, 1, 11}, {3, 3, 7, 4, 3, 4, 0, 11, 2, 1}, {3, 9, 11, 2, 9, 2, 0, 7, 4, 8}, {4, 3, 7, 4, 3, 4, 9, 2, 3, 9, 11, 2, 9}, {2, 8, 7, 4, 3, 2, 10}, {3, 10, 7, 2, 7, 4, 2, 2, 4, 0}, {3, 1, 0, 9, 8, 7, 4, 2, 10, 3}, {4, 10, 7, 4, 10, 4, 2, 2, 4, 9, 2, 9, 1}, {3, 3, 1, 11, 3, 11, 10, 4, 8, 7}, {4, 1, 11, 10, 1, 10, 0, 0, 10, 7, 0, 7, 4}, {4, 4, 9, 7, 7, 9, 10, 9, 11, 10, 3, 0, 8}, {3, 4, 9, 7, 7, 9, 10, 9, 11, 10}, {1, 5, 9, 4}, {2, 8, 0, 3, 4, 5, 9}, {2, 5, 1, 0, 5, 0, 4}, {3, 8, 4, 3, 4, 5, 3, 3, 5, 1}, {2, 1, 11, 2, 9, 4, 5}, {3, 5, 9, 4, 0, 3, 8, 11, 2, 1}, {3, 5, 11, 4, 11, 2, 4, 4, 2, 0}, {4, 2, 5, 11, 2, 3, 5, 3, 4, 5, 3, 8, 4}, {2, 2, 10, 3, 4, 5, 9}, {3, 0, 2, 10, 0, 10, 8, 5, 9, 4}, {3, 0, 4, 5, 0, 5, 1, 10, 3, 2}, {4, 2, 10, 8, 2, 8, 1, 1, 8, 4, 1, 4, 5}, {3, 11, 10, 3, 11, 3, 1, 4, 5, 9}, {4, 0, 1, 8, 1, 11, 8, 8, 11, 10, 5, 9, 4}, {4, 10, 5, 11, 10, 4, 5, 3, 4, 10, 0, 4, 3}, {3, 5, 11, 4, 4, 11, 8, 11, 10, 8}, {2, 7, 5, 9, 7, 9, 8}, {3, 9, 0, 5, 0, 3, 5, 5, 3, 7}, {3, 0, 8, 1, 8, 7, 1, 1, 7, 5}, {2, 3, 7, 5, 3, 5, 1}, {3, 9, 8, 7, 9, 7, 5, 2, 1, 11}, {4, 9, 0, 5, 0, 3, 5, 5, 3, 7, 2, 1, 11}, {4, 11, 2, 0, 11, 0, 5, 5, 0, 8, 5, 8, 7}, {3, 2, 3, 11, 11, 3, 5, 3, 7, 5}, {3, 7, 5, 9, 7, 9, 8, 2, 10, 3}, {4, 0, 2, 10, 0, 10, 7, 9, 0, 7, 5, 9, 7}, {4, 0, 8, 1, 8, 7, 1, 1, 7, 5, 10, 3, 2}, {3, 10, 7, 2, 2, 7, 1, 7, 5, 1}, {4, 1, 11, 10, 1, 10, 3, 7, 5, 9, 7, 9, 8}, {3, 5, 10, 7, 5, 11, 10, 0, 1, 9}, {3, 10, 5, 11, 10, 7, 5, 0, 8, 3}, {2, 5, 10, 7, 5, 11, 10}, {1, 11, 5, 6}, {2, 0, 3, 8, 6, 11, 5}, {2, 9, 1, 0, 5, 6, 11}, {3, 1, 3, 8, 1, 8, 9, 6, 11, 5}, {2, 6, 2, 1, 6, 1, 5}, {3, 1, 5, 6, 1, 6, 2, 8, 0, 3}, {3, 9, 5, 0, 5, 6, 0, 0, 6, 2}, {4, 3, 6, 2, 3, 8, 6, 8, 5, 6, 8, 9, 5}, {2, 2, 10, 3, 11, 5, 6}, {3, 10, 8, 0, 10, 0, 2, 5, 6, 11}, {3, 6, 11, 5, 1, 0, 9, 10, 3, 2}, {4, 1, 2, 9, 2, 10, 9, 9, 10, 8, 6, 11, 5}, {3, 6, 10, 5, 10, 3, 5, 5, 3, 1}, {4, 8, 6, 10, 8, 5, 6, 0, 5, 8, 1, 5, 0}, {4, 3, 6, 10, 3, 0, 6, 0, 5, 6, 0, 9, 5}, {3, 6, 10, 5, 5, 10, 9, 10, 8, 9}, {2, 7, 4, 8, 6, 11, 5}, {3, 4, 0, 3, 4, 3, 7, 11, 5, 6}, {3, 7, 4, 8, 9, 1, 0, 6, 11, 5}, {4, 4, 9, 7, 9, 1, 7, 7, 1, 3, 11, 5, 6}, {3, 6, 2, 1, 6, 1, 5, 8, 7, 4}, {4, 6, 3, 7, 6, 2, 3, 0, 5, 4, 0, 1, 5}, {4, 7, 6, 8, 8, 6, 0, 6, 2, 0, 9, 5, 4}, {3, 7, 2, 3, 7, 6, 2, 9, 5, 4}, {3, 8, 7, 4, 6, 11, 5, 3, 2, 10}, {4, 10, 7, 2, 7, 4, 2, 2, 4, 0, 5, 6, 11}, {4, 0, 8, 3, 7, 6, 10, 11, 1, 2, 4, 9, 5}, {3, 4, 9, 5, 11, 1, 2, 7, 6, 10}, {4, 6, 10, 5, 10, 3, 5, 5, 3, 1, 8, 7, 4}, {3, 5, 0, 1, 5, 4, 0, 10, 7, 6}, {3, 3, 0, 8, 4, 9, 5, 10, 7, 6}, {2, 6, 10, 7, 5, 4, 9}, {2, 4, 6, 11, 4, 11, 9}, {3, 4, 6, 11, 4, 11, 9, 3, 8, 0}, {3, 11, 1, 6, 1, 0, 6, 6, 0, 4}, {4, 4, 6, 11, 4, 11, 1, 8, 4, 1, 3, 8, 1}, {3, 1, 9, 2, 9, 4, 2, 2, 4, 6}, {4, 1, 9, 2, 9, 4, 2, 2, 4, 6, 8, 0, 3}, {2, 2, 0, 4, 2, 4, 6}, {3, 8, 4, 3, 3, 4, 2, 4, 6, 2}, {3, 11, 9, 4, 11, 4, 6, 3, 2, 10}, {4, 2, 10, 8, 2, 8, 0, 4, 6, 11, 4, 11, 9}, {4, 3, 0, 10, 10, 0, 6, 0, 4, 6, 11, 1, 2}, {3, 6, 8, 4, 6, 10, 8, 1, 2, 11}, {4, 9, 3, 1, 9, 4, 3, 4, 10, 3, 4, 6, 10}, {3, 8, 6, 10, 8, 4, 6, 1, 9, 0}, {3, 3, 0, 10, 10, 0, 6, 0, 4, 6}, {2, 6, 8, 4, 6, 10, 8}, {3, 7, 6, 8, 6, 11, 8, 8, 11, 9}, {4, 0, 3, 7, 0, 7, 9, 9, 7, 6, 9, 6, 11}, {4, 7, 0, 8, 7, 6, 0, 6, 1, 0, 6, 11, 1}, {3, 11, 1, 6, 6, 1, 7, 1, 3, 7}, {4, 9, 8, 7, 9, 7, 6, 1, 9, 6, 2, 1, 6}, {3, 2, 7, 6, 2, 3, 7, 9, 0, 1}, {3, 7, 6, 8, 8, 6, 0, 6, 2, 0}, {2, 7, 2, 3, 7, 6, 2}, {4, 2, 11, 3, 3, 11, 8, 11, 9, 8, 7, 6, 10}, {3, 2, 9, 0, 2, 11, 9, 7, 6, 10}, {3, 0, 8, 3, 10, 7, 6, 1, 2, 11}, {2, 10, 7, 6, 2, 11, 1}, {3, 8, 1, 9, 8, 3, 1, 6, 10, 7}, {2, 6, 10, 7, 0, 1, 9}, {2, 7, 6, 10, 8, 3, 0}, {1, 6, 10, 7}, {1, 6, 7, 10}, {2, 7, 10, 6, 8, 0, 3}, {2, 6, 7, 10, 0, 9, 1}, {3, 8, 9, 1, 8, 1, 3, 6, 7, 10}, {2, 10, 6, 7, 2, 1, 11}, {3, 0, 3, 8, 10, 6, 7, 1, 11, 2}, {3, 2, 0, 9, 2, 9, 11, 7, 10, 6}, {4, 2, 3, 11, 3, 8, 11, 11, 8, 9, 7, 10, 6}, {2, 7, 3, 2, 7, 2, 6}, {3, 7, 8, 6, 8, 0, 6, 6, 0, 2}, {3, 2, 6, 7, 2, 7, 3, 9, 1, 0}, {4, 9, 7, 8, 9, 6, 7, 1, 6, 9, 2, 6, 1}, {3, 11, 6, 1, 6, 7, 1, 1, 7, 3}, {4, 7, 8, 0, 7, 0, 6, 6, 0, 1, 6, 1, 11}, {4, 0, 7, 3, 0, 9, 7, 9, 6, 7, 9, 11, 6}, {3, 7, 8, 6, 6, 8, 11, 8, 9, 11}, {2, 6, 4, 8, 6, 8, 10}, {3, 3, 10, 0, 10, 6, 0, 0, 6, 4}, {3, 8, 10, 6, 8, 6, 4, 1, 0, 9}, {4, 9, 1, 3, 9, 3, 4, 4, 3, 10, 4, 10, 6}, {3, 6, 4, 8, 6, 8, 10, 1, 11, 2}, {4, 3, 10, 0, 10, 6, 0, 0, 6, 4, 11, 2, 1}, {4, 2, 8, 10, 2, 0, 8, 4, 11, 6, 4, 9, 11}, {3, 11, 4, 9, 11, 6, 4, 3, 10, 2}, {3, 8, 3, 4, 3, 2, 4, 4, 2, 6}, {2, 2, 4, 0, 2, 6, 4}, {4, 1, 2, 9, 9, 2, 4, 2, 6, 4, 8, 3, 0}, {3, 1, 2, 9, 9, 2, 4, 2, 6, 4}, {4, 4, 11, 6, 4, 1, 11, 8, 1, 4, 3, 1, 8}, {3, 11, 6, 1, 1, 6, 0, 6, 4, 0}, {3, 4, 11, 6, 4, 9, 11, 3, 0, 8}, {2, 4, 11, 6, 4, 9, 11}, {2, 6, 7, 10, 5, 9, 4}, {3, 3, 8, 0, 4, 5, 9, 10, 6, 7}, {3, 5, 1, 0, 5, 0, 4, 10, 6, 7}, {4, 6, 5, 10, 10, 5, 3, 5, 1, 3, 8, 4, 7}, {3, 4, 5, 9, 11, 2, 1, 7, 10, 6}, {4, 0, 3, 8, 7, 10, 6, 11, 2, 1, 4, 5, 9}, {4, 10, 2, 7, 7, 2, 4, 2, 0, 4, 5, 11, 6}, {3, 8, 4, 7, 6, 5, 11, 3, 10, 2}, {3, 7, 3, 2, 7, 2, 6, 9, 4, 5}, {4, 7, 8, 6, 8, 0, 6, 6, 0, 2, 9, 4, 5}, {4, 6, 7, 3, 6, 3, 2, 0, 4, 5, 0, 5, 1}, {3, 6, 1, 2, 6, 5, 1, 8, 4, 7}, {4, 4, 7, 9, 9, 7, 1, 7, 3, 1, 11, 6, 5}, {3, 7, 8, 4, 9, 0, 1, 6, 5, 11}, {3, 4, 3, 0, 4, 7, 3, 11, 6, 5}, {2, 7, 8, 4, 6, 5, 11}, {3, 6, 5, 10, 5, 9, 10, 10, 9, 8}, {4, 3, 10, 6, 3, 6, 0, 0, 6, 5, 0, 5, 9}, {4, 8, 10, 6, 8, 6, 5, 0, 8, 5, 1, 0, 5}, {3, 6, 5, 10, 10, 5, 3, 5, 1, 3}, {4, 1, 9, 2, 2, 9, 10, 9, 8, 10, 6, 5, 11}, {3, 6, 5, 11, 1, 9, 0, 10, 2, 3}, {3, 10, 0, 8, 10, 2, 0, 5, 11, 6}, {2, 2, 3, 10, 11, 6, 5}, {4, 3, 2, 6, 3, 6, 8, 8, 6, 5, 8, 5, 9}, {3, 9, 0, 5, 5, 0, 6, 0, 2, 6}, {3, 1, 6, 5, 1, 2, 6, 8, 3, 0}, {2, 6, 1, 2, 6, 5, 1}, {3, 1, 8, 3, 1, 9, 8, 6, 5, 11}, {2, 9, 0, 1, 5, 11, 6}, {2, 0, 8, 3, 6, 5, 11}, {1, 11, 6, 5}, {2, 5, 7, 10, 5, 10, 11}, {3, 10, 11, 5, 10, 5, 7, 0, 3, 8}, {3, 5, 7, 10, 5, 10, 11, 0, 9, 1}, {4, 1, 10, 11, 1, 3, 10, 7, 9, 5, 7, 8, 9}, {3, 10, 2, 7, 2, 1, 7, 7, 1, 5}, {4, 0, 1, 8, 8, 1, 7, 1, 5, 7, 10, 2, 3}, {4, 0, 10, 2, 0, 7, 10, 9, 7, 0, 5, 7, 9}, {3, 7, 9, 5, 7, 8, 9, 2, 3, 10}, {3, 2, 11, 3, 11, 5, 3, 3, 5, 7}, {4, 11, 0, 2, 11, 5, 0, 5, 8, 0, 5, 7, 8}, {4, 9, 5, 0, 0, 5, 3, 5, 7, 3, 2, 11, 1}, {3, 9, 7, 8, 9, 5, 7, 2, 11, 1}, {2, 3, 5, 7, 3, 1, 5}, {3, 0, 1, 8, 8, 1, 7, 1, 5, 7}, {3, 9, 5, 0, 0, 5, 3, 5, 7, 3}, {2, 7, 9, 5, 7, 8, 9}, {3, 5, 4, 11, 4, 8, 11, 11, 8, 10}, {4, 10, 11, 5, 10, 5, 4, 3, 10, 4, 0, 3, 4}, {4, 0, 8, 1, 1, 8, 11, 8, 10, 11, 5, 4, 9}, {3, 11, 3, 10, 11, 1, 3, 4, 9, 5}, {4, 2, 8, 10, 2, 1, 8, 1, 4, 8, 1, 5, 4}, {3, 0, 5, 4, 0, 1, 5, 10, 2, 3}, {3, 0, 10, 2, 0, 8, 10, 5, 4, 9}, {2, 2, 3, 10, 4, 9, 5}, {4, 2, 11, 5, 2, 5, 3, 3, 5, 4, 3, 4, 8}, {3, 5, 4, 11, 11, 4, 2, 4, 0, 2}, {3, 5, 4, 9, 0, 8, 3, 11, 1, 2}, {2, 1, 2, 11, 9, 5, 4}, {3, 8, 3, 4, 4, 3, 5, 3, 1, 5}, {2, 5, 0, 1, 5, 4, 0}, {2, 8, 3, 0, 4, 9, 5}, {1, 5, 4, 9}, {3, 4, 7, 9, 7, 10, 9, 9, 10, 11}, {4, 4, 7, 9, 7, 10, 9, 9, 10, 11, 3, 8, 0}, {4, 1, 10, 11, 1, 0, 10, 0, 7, 10, 0, 4, 7}, {3, 3, 11, 1, 3, 10, 11, 4, 7, 8}, {4, 10, 4, 7, 10, 2, 4, 2, 9, 4, 2, 1, 9}, {3, 1, 9, 0, 8, 4, 7, 2, 3, 10}, {3, 10, 2, 7, 7, 2, 4, 2, 0, 4}, {2, 8, 4, 7, 3, 10, 2}, {4, 3, 4, 7, 3, 9, 4, 2, 9, 3, 11, 9, 2}, {3, 9, 2, 11, 9, 0, 2, 7, 8, 4}, {3, 3, 4, 7, 3, 0, 4, 11, 1, 2}, {2, 4, 7, 8, 2, 11, 1}, {3, 4, 7, 9, 9, 7, 1, 7, 3, 1}, {2, 4, 7, 8, 9, 0, 1}, {2, 3, 4, 7, 3, 0, 4}, {1, 4, 7, 8}, {2, 10, 9, 8, 10, 11, 9}, {3, 3, 10, 0, 0, 10, 9, 10, 11, 9}, {3, 0, 8, 1, 1, 8, 11, 8, 10, 11}, {2, 3, 11, 1, 3, 10, 11}, {3, 1, 9, 2, 2, 9, 10, 9, 8, 10}, {2, 3, 10, 2, 0, 1, 9}, {2, 0, 10, 2, 0, 8, 10}, {1, 2, 3, 10}, {3, 2, 11, 3, 3, 11, 8, 11, 9, 8}, {2, 9, 2, 11, 9, 0, 2}, {2, 0, 8, 3, 1, 2, 11}, {1, 1, 2, 11}, {2, 1, 8, 3, 1, 9, 8}, {1, 9, 0, 1}, {1, 0, 8, 3}, {0} }; /* table of adjacent faces to visit in contour propagation */ static unsigned char adjfaces[256][7] = { {0}, {3, 0, 1, 5}, {3, 3, 0, 5}, {4, 0, 1, 3, 5}, {3, 3, 4, 0}, {5, 0, 1, 3, 4, 5}, {4, 3, 4, 5, 0}, {5, 4, 1, 5, 3, 0}, {3, 4, 1, 0}, {4, 0, 4, 5, 1}, {5, 0, 4, 5, 3, 1}, {5, 3, 4, 1, 5, 0}, {4, 0, 3, 1, 4}, {5, 5, 3, 4, 1, 0}, {5, 1, 5, 3, 4, 0}, {4, 4, 1, 5, 3}, {3, 5, 1, 2}, {4, 1, 2, 0, 5}, {5, 5, 1, 3, 0, 2}, {5, 2, 3, 0, 1, 5}, {6, 5, 1, 4, 3, 0, 2}, {6, 1, 2, 3, 0, 4, 5}, {6, 3, 4, 1, 5, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {5, 1, 2, 0, 4, 5}, {5, 4, 2, 5, 0, 1}, {6, 1, 4, 3, 5, 0, 2}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 3, 2, 1, 5, 4}, {6, 3, 4, 1, 5, 2, 0}, {6, 5, 1, 4, 3, 0, 2}, {5, 5, 1, 4, 3, 2}, {3, 3, 5, 2}, {5, 5, 0, 2, 3, 1}, {4, 3, 0, 2, 5}, {5, 1, 2, 3, 0, 5}, {5, 3, 4, 5, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 2, 4, 0, 5, 3}, {6, 0, 4, 2, 5, 3, 1}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {6, 5, 2, 4, 0, 1, 3}, {6, 4, 1, 5, 3, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {6, 5, 3, 4, 1, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 3, 5, 1, 4, 2}, {4, 2, 3, 1, 5}, {5, 3, 0, 1, 2, 5}, {5, 0, 1, 2, 3, 5}, {4, 0, 1, 2, 3}, {6, 5, 1, 4, 3, 0, 2}, {6, 3, 0, 1, 2, 4, 5}, {6, 4, 0, 5, 2, 1, 3}, {5, 0, 3, 2, 1, 4}, {6, 2, 3, 0, 1, 4, 5}, {6, 3, 0, 1, 2, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {5, 1, 0, 3, 2, 4}, {6, 0, 4, 2, 5, 3, 1}, {6, 2, 1, 0, 3, 5, 4}, {6, 4, 3, 5, 1, 0, 2}, {4, 2, 1, 3, 4}, {3, 3, 2, 4}, {6, 0, 1, 2, 3, 4, 5}, {5, 3, 0, 2, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {4, 4, 0, 2, 3}, {6, 3, 2, 1, 0, 5, 4}, {5, 5, 2, 4, 0, 3}, {6, 0, 4, 2, 5, 3, 1}, {5, 4, 1, 3, 2, 0}, {6, 1, 5, 3, 4, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {6, 3, 4, 1, 5, 2, 0}, {5, 2, 1, 0, 3, 4}, {6, 0, 1, 2, 3, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {5, 4, 3, 5, 1, 2}, {5, 2, 5, 4, 3, 1}, {6, 5, 0, 4, 2, 3, 1}, {6, 3, 4, 1, 5, 2, 0}, {6, 2, 3, 0, 1, 4, 5}, {6, 4, 0, 5, 2, 1, 3}, {6, 4, 1, 5, 3, 2, 0}, {6, 2, 5, 0, 4, 3, 1}, {6, 1, 0, 3, 2, 5, 4}, {6, 4, 0, 5, 2, 1, 3}, {6, 4, 2, 5, 0, 3, 1}, {6, 0, 1, 2, 3, 4, 5}, {6, 4, 1, 5, 3, 2, 0}, {6, 2, 1, 0, 3, 5, 4}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 4, 0, 5, 1, 3}, {5, 2, 1, 3, 5, 4}, {4, 2, 4, 5, 3}, {6, 2, 4, 0, 5, 1, 3}, {5, 4, 0, 5, 2, 3}, {6, 1, 2, 3, 0, 4, 5}, {5, 0, 5, 2, 4, 3}, {6, 0, 5, 2, 4, 1, 3}, {4, 4, 0, 5, 2}, {5, 5, 0, 4, 2, 1}, {6, 3, 5, 1, 4, 0, 2}, {6, 0, 1, 2, 3, 4, 5}, {6, 0, 4, 2, 5, 3, 1}, {6, 2, 5, 0, 4, 3, 1}, {6, 3, 0, 1, 2, 4, 5}, {6, 1, 4, 3, 5, 0, 2}, {5, 0, 4, 2, 5, 1}, {4, 2, 5, 4, 1}, {5, 1, 4, 3, 5, 2}, {6, 0, 1, 2, 3, 4, 5}, {6, 2, 1, 0, 3, 5, 4}, {5, 3, 2, 1, 0, 4}, {6, 0, 5, 2, 4, 1, 3}, {6, 4, 2, 5, 0, 3, 1}, {5, 2, 5, 0, 4, 1}, {4, 1, 0, 2, 4}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 5, 2, 4, 1, 3}, {6, 4, 3, 5, 1, 0, 2}, {5, 4, 2, 0, 3, 1}, {6, 5, 3, 4, 1, 2, 0}, {6, 2, 1, 0, 3, 5, 4}, {5, 1, 4, 5, 0, 2}, {3, 2, 1, 4}, {3, 2, 1, 4}, {5, 1, 4, 5, 0, 2}, {6, 2, 1, 0, 3, 5, 4}, {6, 5, 3, 4, 1, 2, 0}, {5, 4, 2, 0, 3, 1}, {6, 4, 3, 5, 1, 0, 2}, {6, 0, 5, 2, 4, 1, 3}, {6, 4, 1, 5, 3, 2, 0}, {4, 1, 0, 2, 4}, {5, 2, 5, 0, 4, 1}, {6, 4, 2, 5, 0, 3, 1}, {6, 0, 5, 2, 4, 1, 3}, {5, 3, 2, 1, 0, 4}, {6, 2, 1, 0, 3, 5, 4}, {6, 0, 1, 2, 3, 4, 5}, {5, 1, 4, 3, 5, 2}, {4, 2, 5, 4, 1}, {5, 0, 4, 2, 5, 1}, {6, 1, 4, 3, 5, 0, 2}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 5, 0, 4, 3, 1}, {6, 0, 4, 2, 5, 3, 1}, {6, 0, 1, 2, 3, 4, 5}, {6, 3, 5, 1, 4, 0, 2}, {5, 5, 0, 4, 2, 1}, {4, 4, 0, 5, 2}, {6, 0, 5, 2, 4, 1, 3}, {5, 0, 5, 2, 4, 3}, {6, 1, 2, 3, 0, 4, 5}, {5, 4, 0, 5, 2, 3}, {6, 2, 4, 0, 5, 1, 3}, {4, 2, 4, 5, 3}, {5, 2, 1, 3, 5, 4}, {6, 2, 4, 0, 5, 1, 3}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 1, 0, 3, 5, 4}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {6, 4, 2, 5, 0, 3, 1}, {6, 4, 0, 5, 2, 1, 3}, {6, 1, 0, 3, 2, 5, 4}, {6, 2, 5, 0, 4, 3, 1}, {6, 4, 1, 5, 3, 2, 0}, {6, 4, 0, 5, 2, 1, 3}, {6, 2, 3, 0, 1, 4, 5}, {6, 3, 4, 1, 5, 2, 0}, {6, 5, 0, 4, 2, 3, 1}, {5, 2, 5, 4, 3, 1}, {5, 4, 3, 5, 1, 2}, {6, 0, 1, 2, 3, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {5, 2, 1, 0, 3, 4}, {6, 3, 4, 1, 5, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {6, 1, 5, 3, 4, 2, 0}, {5, 4, 1, 3, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 5, 2, 4, 0, 3}, {6, 3, 2, 1, 0, 5, 4}, {4, 4, 0, 2, 3}, {6, 0, 1, 2, 3, 4, 5}, {5, 3, 0, 2, 4, 5}, {6, 0, 1, 2, 3, 4, 5}, {3, 3, 2, 4}, {4, 2, 1, 3, 4}, {6, 4, 3, 5, 1, 0, 2}, {6, 2, 1, 0, 3, 5, 4}, {6, 0, 4, 2, 5, 3, 1}, {5, 1, 0, 3, 2, 4}, {6, 0, 1, 2, 3, 4, 5}, {6, 3, 0, 1, 2, 4, 5}, {6, 2, 3, 0, 1, 4, 5}, {5, 0, 3, 2, 1, 4}, {6, 4, 0, 5, 2, 1, 3}, {6, 3, 0, 1, 2, 4, 5}, {6, 5, 1, 4, 3, 0, 2}, {4, 0, 1, 2, 3}, {5, 0, 1, 2, 3, 5}, {5, 3, 0, 1, 2, 5}, {4, 2, 3, 1, 5}, {5, 3, 5, 1, 4, 2}, {6, 0, 4, 2, 5, 3, 1}, {6, 5, 3, 4, 1, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {6, 4, 1, 5, 3, 2, 0}, {6, 5, 2, 4, 0, 1, 3}, {6, 0, 4, 2, 5, 3, 1}, {6, 4, 1, 5, 3, 2, 0}, {6, 0, 4, 2, 5, 3, 1}, {5, 2, 4, 0, 5, 3}, {6, 0, 4, 2, 5, 3, 1}, {5, 3, 4, 5, 2, 0}, {5, 1, 2, 3, 0, 5}, {4, 3, 0, 2, 5}, {5, 5, 0, 2, 3, 1}, {3, 3, 5, 2}, {5, 5, 1, 4, 3, 2}, {6, 5, 1, 4, 3, 0, 2}, {6, 3, 4, 1, 5, 2, 0}, {6, 0, 3, 2, 1, 5, 4}, {6, 4, 1, 5, 3, 2, 0}, {6, 1, 4, 3, 5, 0, 2}, {5, 4, 2, 5, 0, 1}, {5, 1, 2, 0, 4, 5}, {6, 4, 1, 5, 3, 2, 0}, {6, 3, 4, 1, 5, 2, 0}, {6, 1, 2, 3, 0, 4, 5}, {6, 5, 1, 4, 3, 0, 2}, {5, 2, 3, 0, 1, 5}, {5, 5, 1, 3, 0, 2}, {4, 1, 2, 0, 5}, {3, 5, 1, 2}, {4, 4, 1, 5, 3}, {5, 1, 5, 3, 4, 0}, {5, 5, 3, 4, 1, 0}, {4, 0, 3, 1, 4}, {5, 3, 4, 1, 5, 0}, {5, 0, 4, 5, 3, 1}, {4, 0, 4, 5, 1}, {3, 4, 1, 0}, {5, 4, 1, 5, 3, 0}, {4, 3, 4, 5, 0}, {5, 0, 1, 3, 4, 5}, {3, 3, 4, 0}, {4, 0, 1, 3, 5}, {3, 3, 0, 5}, {3, 0, 1, 5}, {0} }; /* table of cube vertices involved in triangulation */ static unsigned char cubeverts[256][9] = { {0}, {4, 0, 1, 3, 4}, {4, 1, 5, 2, 0}, {6, 0, 1, 2, 3, 4, 5}, {4, 2, 1, 6, 3}, {6, 0, 1, 2, 3, 4, 6}, {6, 2, 1, 5, 6, 3, 0}, {7, 3, 2, 6, 0, 1, 5, 4}, {4, 3, 2, 7, 0}, {6, 3, 0, 1, 2, 7, 4}, {6, 3, 0, 1, 2, 7, 5}, {7, 2, 1, 5, 3, 0, 4, 7}, {6, 2, 3, 0, 1, 6, 7}, {7, 1, 0, 4, 2, 3, 7, 6}, {7, 0, 3, 7, 1, 2, 6, 5}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {4, 4, 5, 0, 7}, {6, 4, 0, 3, 7, 5, 1}, {6, 4, 5, 1, 0, 7, 2}, {7, 5, 4, 7, 1, 0, 3, 2}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {6, 4, 0, 3, 7, 5, 2}, {7, 7, 3, 2, 4, 0, 1, 5}, {7, 7, 4, 0, 3, 5, 1, 2}, {7, 3, 2, 7, 0, 1, 5, 4}, {8, 2, 3, 0, 1, 6, 7, 4, 5}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {7, 4, 5, 1, 7, 6, 2, 3}, {4, 5, 6, 1, 4}, {6, 0, 4, 5, 1, 3, 6}, {6, 1, 5, 6, 2, 0, 4}, {7, 4, 0, 3, 5, 1, 2, 6}, {6, 2, 1, 5, 6, 3, 4}, {7, 3, 0, 1, 2, 4, 5, 6}, {7, 6, 5, 4, 2, 1, 0, 3}, {7, 3, 0, 2, 7, 4, 5, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 5, 1, 0, 4, 6, 2, 3, 7}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {7, 5, 6, 2, 4, 7, 3, 0}, {6, 5, 4, 7, 6, 1, 0}, {7, 1, 5, 6, 0, 4, 7, 3}, {7, 0, 1, 2, 4, 5, 6, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {7, 2, 3, 0, 6, 7, 4, 5}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 3, 7, 4, 2, 6, 5, 1}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 6, 7, 3, 2, 5, 4, 0, 1}, {6, 7, 6, 5, 4, 3, 2}, {4, 6, 2, 5, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {6, 1, 5, 6, 2, 0, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {6, 2, 6, 7, 3, 1, 5}, {8, 6, 2, 1, 5, 7, 3, 0, 4}, {7, 5, 1, 0, 6, 2, 3, 7}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {6, 3, 2, 6, 7, 0, 5}, {8, 0, 3, 7, 4, 1, 2, 6, 5}, {7, 0, 1, 2, 3, 5, 6, 7}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {7, 7, 6, 5, 3, 2, 1, 0}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 0, 1, 3, 4, 5, 6, 7}, {7, 6, 7, 3, 5, 4, 0, 1}, {6, 4, 7, 6, 5, 0, 2}, {8, 0, 4, 5, 1, 3, 7, 6, 2}, {7, 2, 1, 5, 6, 0, 4, 7}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 3, 7, 4, 0, 2, 6, 5, 1}, {7, 2, 6, 7, 3, 5, 4, 0}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 3, 2, 6, 7, 1, 5, 4}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {7, 6, 5, 4, 7, 1, 0, 3}, {6, 7, 6, 5, 4, 3, 1}, {6, 6, 5, 4, 7, 2, 1}, {8, 6, 5, 4, 7, 2, 1, 0, 3}, {7, 2, 6, 7, 1, 5, 4, 0}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {7, 1, 2, 3, 5, 6, 7, 4}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {7, 0, 4, 5, 3, 7, 6, 2}, {8, 5, 6, 2, 1, 4, 7, 3, 0}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 7, 4, 0, 3, 6, 5, 1, 2}, {7, 3, 0, 1, 7, 4, 5, 6}, {6, 4, 7, 6, 5, 0, 3}, {7, 7, 4, 0, 6, 5, 1, 2}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 7, 6, 4, 3, 2, 1, 0}, {7, 6, 2, 1, 7, 3, 0, 4}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {7, 4, 7, 6, 0, 3, 2, 1}, {6, 3, 7, 4, 0, 2, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {7, 6, 7, 3, 2, 4, 0, 1}, {6, 7, 3, 2, 6, 4, 1}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {6, 7, 4, 0, 3, 6, 1}, {4, 7, 6, 4, 3}, {4, 7, 6, 4, 3}, {6, 7, 4, 0, 3, 6, 1}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {6, 7, 3, 2, 6, 4, 1}, {7, 6, 7, 3, 2, 4, 0, 1}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {6, 3, 7, 4, 0, 2, 6}, {7, 4, 7, 6, 0, 3, 2, 1}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {7, 6, 2, 1, 7, 3, 0, 4}, {7, 7, 6, 4, 3, 2, 1, 0}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 7, 4, 0, 6, 5, 1, 2}, {6, 4, 7, 6, 5, 0, 3}, {7, 3, 0, 1, 7, 4, 5, 6}, {8, 7, 4, 0, 3, 6, 5, 1, 2}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 5, 6, 2, 1, 4, 7, 3, 0}, {7, 0, 4, 5, 3, 7, 6, 2}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 1, 2, 3, 0, 5, 6, 7, 4}, {7, 1, 2, 3, 5, 6, 7, 4}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {7, 2, 6, 7, 1, 5, 4, 0}, {8, 6, 5, 4, 7, 2, 1, 0, 3}, {6, 6, 5, 4, 7, 2, 1}, {6, 7, 6, 5, 4, 3, 1}, {7, 6, 5, 4, 7, 1, 0, 3}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {7, 3, 2, 6, 7, 1, 5, 4}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 7, 3, 2, 6, 4, 0, 1, 5}, {7, 2, 6, 7, 3, 5, 4, 0}, {8, 3, 7, 4, 0, 2, 6, 5, 1}, {8, 4, 7, 6, 5, 0, 3, 2, 1}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {7, 2, 1, 5, 6, 0, 4, 7}, {8, 0, 4, 5, 1, 3, 7, 6, 2}, {6, 4, 7, 6, 5, 0, 2}, {7, 6, 7, 3, 5, 4, 0, 1}, {7, 0, 1, 3, 4, 5, 6, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 7, 6, 5, 3, 2, 1, 0}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {7, 0, 1, 2, 3, 5, 6, 7}, {8, 0, 3, 7, 4, 1, 2, 6, 5}, {6, 3, 2, 6, 7, 0, 5}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {7, 5, 1, 0, 6, 2, 3, 7}, {8, 6, 2, 1, 5, 7, 3, 0, 4}, {6, 2, 6, 7, 3, 1, 5}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {6, 1, 5, 6, 2, 0, 7}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {4, 6, 2, 5, 7}, {6, 7, 6, 5, 4, 3, 2}, {8, 6, 7, 3, 2, 5, 4, 0, 1}, {8, 7, 6, 5, 4, 3, 2, 1, 0}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {7, 3, 7, 4, 2, 6, 5, 1}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 5, 4, 7, 6, 1, 0, 3, 2}, {7, 2, 3, 0, 6, 7, 4, 5}, {8, 2, 6, 7, 3, 1, 5, 4, 0}, {8, 1, 5, 6, 2, 0, 4, 7, 3}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 0, 1, 2, 3, 4, 5, 6, 7}, {7, 0, 1, 2, 4, 5, 6, 7}, {7, 1, 5, 6, 0, 4, 7, 3}, {6, 5, 4, 7, 6, 1, 0}, {7, 5, 6, 2, 4, 7, 3, 0}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 1, 0, 4, 5, 2, 3, 7, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 5, 1, 0, 4, 6, 2, 3, 7}, {8, 3, 0, 1, 2, 7, 4, 5, 6}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {7, 3, 0, 2, 7, 4, 5, 6}, {7, 6, 5, 4, 2, 1, 0, 3}, {7, 3, 0, 1, 2, 4, 5, 6}, {6, 2, 1, 5, 6, 3, 4}, {7, 4, 0, 3, 5, 1, 2, 6}, {6, 1, 5, 6, 2, 0, 4}, {6, 0, 4, 5, 1, 3, 6}, {4, 5, 6, 1, 4}, {7, 4, 5, 1, 7, 6, 2, 3}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 2, 3, 0, 1, 6, 7, 4, 5}, {7, 3, 2, 7, 0, 1, 5, 4}, {7, 7, 4, 0, 3, 5, 1, 2}, {7, 7, 3, 2, 4, 0, 1, 5}, {6, 4, 0, 3, 7, 5, 2}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {8, 2, 1, 5, 6, 3, 0, 4, 7}, {8, 4, 0, 3, 7, 5, 1, 2, 6}, {8, 4, 5, 1, 0, 7, 6, 2, 3}, {7, 5, 4, 7, 1, 0, 3, 2}, {6, 4, 5, 1, 0, 7, 2}, {6, 4, 0, 3, 7, 5, 1}, {4, 4, 5, 0, 7}, {8, 3, 2, 6, 7, 0, 1, 5, 4}, {7, 0, 3, 7, 1, 2, 6, 5}, {7, 1, 0, 4, 2, 3, 7, 6}, {6, 2, 3, 0, 1, 6, 7}, {7, 2, 1, 5, 3, 0, 4, 7}, {6, 3, 0, 1, 2, 7, 5}, {6, 3, 0, 1, 2, 7, 4}, {4, 3, 2, 7, 0}, {7, 3, 2, 6, 0, 1, 5, 4}, {6, 2, 1, 5, 6, 3, 0}, {6, 0, 1, 2, 3, 4, 6}, {4, 2, 1, 6, 3}, {6, 0, 1, 2, 3, 4, 5}, {4, 1, 5, 2, 0}, {4, 0, 1, 3, 4}, {0} }; /* table of cube edges involved in triangulation */ static unsigned char cubeedges[256][13] = { {0}, {3, 0, 3, 8}, {3, 9, 1, 0}, {4, 1, 3, 8, 9}, {3, 1, 11, 2}, {6, 0, 1, 2, 3, 8, 11}, {4, 9, 11, 2, 0}, {5, 2, 11, 9, 8, 3}, {3, 2, 10, 3}, {4, 0, 2, 10, 8}, {6, 3, 0, 1, 2, 10, 9}, {5, 1, 9, 8, 10, 2}, {4, 3, 1, 11, 10}, {5, 0, 8, 10, 11, 1}, {5, 3, 10, 11, 9, 0}, {4, 11, 10, 9, 8}, {3, 4, 8, 7}, {4, 3, 7, 4, 0}, {6, 4, 9, 0, 8, 7, 1}, {5, 4, 7, 3, 1, 9}, {6, 4, 8, 11, 2, 7, 1}, {7, 3, 7, 1, 11, 4, 0, 2}, {7, 9, 11, 8, 7, 2, 0, 4}, {6, 2, 11, 9, 4, 3, 7}, {6, 8, 3, 10, 7, 4, 2}, {5, 10, 2, 0, 4, 7}, {9, 7, 8, 3, 10, 9, 1, 4, 2, 0}, {6, 2, 10, 9, 4, 1, 7}, {7, 3, 1, 7, 4, 11, 10, 8}, {6, 1, 11, 7, 10, 0, 4}, {8, 4, 9, 0, 8, 11, 10, 7, 3}, {5, 4, 9, 11, 10, 7}, {3, 5, 9, 4}, {6, 8, 4, 9, 0, 3, 5}, {4, 5, 1, 0, 4}, {5, 8, 3, 1, 5, 4}, {6, 1, 9, 5, 11, 2, 4}, {9, 3, 0, 1, 2, 4, 5, 8, 11, 9}, {5, 5, 4, 0, 2, 11}, {6, 3, 2, 4, 5, 8, 11}, {6, 2, 10, 9, 4, 3, 5}, {7, 0, 2, 4, 5, 10, 8, 9}, {7, 0, 4, 2, 10, 5, 1, 3}, {6, 2, 10, 4, 8, 1, 5}, {7, 11, 10, 9, 4, 3, 1, 5}, {8, 0, 8, 4, 9, 10, 11, 1, 5}, {6, 3, 0, 4, 5, 10, 11}, {5, 5, 11, 10, 8, 4}, {4, 7, 5, 9, 8}, {5, 9, 5, 7, 3, 0}, {5, 0, 1, 5, 7, 8}, {4, 1, 3, 5, 7}, {7, 9, 8, 11, 2, 7, 5, 1}, {8, 9, 5, 11, 1, 7, 3, 0, 2}, {6, 11, 2, 8, 0, 5, 7}, {5, 2, 3, 7, 5, 11}, {7, 7, 5, 3, 2, 9, 8, 10}, {6, 9, 5, 7, 10, 0, 2}, {8, 0, 1, 2, 3, 5, 7, 8, 10}, {5, 10, 7, 5, 1, 2}, {8, 3, 1, 7, 5, 10, 8, 11, 9}, {7, 5, 7, 1, 0, 10, 11, 9}, {7, 10, 11, 8, 0, 5, 7, 3}, {4, 5, 7, 10, 11}, {3, 11, 5, 6}, {6, 0, 3, 5, 6, 8, 11}, {6, 9, 5, 11, 1, 0, 6}, {7, 1, 3, 5, 6, 8, 9, 11}, {4, 6, 2, 1, 5}, {7, 1, 5, 3, 8, 6, 2, 0}, {5, 9, 0, 2, 6, 5}, {6, 3, 2, 5, 6, 8, 9}, {6, 2, 11, 6, 10, 3, 5}, {7, 10, 8, 11, 5, 0, 2, 6}, {9, 0, 1, 2, 3, 5, 6, 9, 10, 11}, {8, 1, 9, 5, 11, 8, 10, 2, 6}, {5, 6, 5, 1, 3, 10}, {6, 0, 1, 5, 6, 8, 10}, {6, 0, 3, 5, 6, 9, 10}, {5, 6, 10, 8, 9, 5}, {6, 7, 6, 5, 4, 8, 11}, {7, 4, 0, 6, 11, 3, 7, 5}, {9, 1, 9, 5, 11, 8, 7, 0, 6, 4}, {8, 4, 7, 6, 5, 3, 1, 9, 11}, {7, 6, 2, 4, 8, 1, 5, 7}, {8, 2, 6, 0, 4, 3, 1, 7, 5}, {8, 7, 6, 5, 4, 2, 0, 8, 9}, {7, 7, 3, 5, 9, 2, 6, 4}, {9, 11, 6, 10, 2, 4, 8, 5, 3, 7}, {8, 10, 2, 11, 6, 0, 4, 7, 5}, {12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {9, 2, 11, 6, 10, 9, 4, 1, 7, 5}, {8, 6, 5, 4, 7, 1, 3, 10, 8}, {7, 5, 1, 7, 10, 0, 4, 6}, {9, 5, 4, 7, 6, 0, 3, 9, 10, 8}, {6, 6, 5, 4, 7, 10, 9}, {4, 4, 6, 11, 9}, {7, 4, 6, 0, 3, 11, 9, 8}, {5, 11, 6, 4, 0, 1}, {6, 8, 3, 1, 11, 4, 6}, {5, 1, 2, 6, 4, 9}, {8, 1, 2, 3, 0, 6, 4, 9, 8}, {4, 6, 2, 4, 0}, {5, 8, 4, 6, 2, 3}, {7, 11, 9, 10, 3, 4, 6, 2}, {8, 0, 2, 4, 6, 8, 9, 10, 11}, {8, 3, 0, 1, 2, 4, 6, 10, 11}, {7, 6, 4, 2, 1, 8, 10, 11}, {6, 9, 1, 10, 3, 4, 6}, {7, 8, 10, 9, 1, 6, 4, 0}, {5, 3, 0, 4, 6, 10}, {4, 6, 4, 8, 10}, {5, 7, 8, 9, 11, 6}, {6, 0, 3, 6, 7, 9, 11}, {6, 6, 7, 1, 0, 11, 8}, {5, 11, 1, 3, 7, 6}, {6, 1, 2, 6, 7, 9, 8}, {7, 2, 6, 0, 9, 7, 3, 1}, {5, 7, 6, 2, 0, 8}, {4, 7, 3, 2, 6}, {8, 2, 11, 6, 10, 9, 8, 3, 7}, {7, 2, 0, 6, 7, 9, 11, 10}, {9, 6, 10, 2, 11, 8, 0, 7, 1, 3}, {6, 10, 2, 11, 6, 7, 1}, {7, 8, 9, 10, 6, 1, 3, 7}, {6, 6, 7, 1, 0, 10, 9}, {6, 7, 8, 3, 10, 6, 0}, {3, 6, 7, 10}, {3, 6, 7, 10}, {6, 7, 8, 3, 10, 6, 0}, {6, 6, 7, 1, 0, 10, 9}, {7, 8, 9, 10, 6, 1, 3, 7}, {6, 10, 2, 11, 6, 7, 1}, {9, 6, 10, 2, 11, 8, 0, 7, 1, 3}, {7, 2, 0, 6, 7, 9, 11, 10}, {8, 2, 11, 6, 10, 9, 8, 3, 7}, {4, 7, 3, 2, 6}, {5, 7, 6, 2, 0, 8}, {7, 2, 6, 0, 9, 7, 3, 1}, {6, 1, 2, 6, 7, 9, 8}, {5, 11, 1, 3, 7, 6}, {6, 6, 7, 1, 0, 11, 8}, {6, 0, 3, 6, 7, 9, 11}, {5, 7, 8, 9, 11, 6}, {4, 6, 4, 8, 10}, {5, 3, 0, 4, 6, 10}, {7, 8, 10, 9, 1, 6, 4, 0}, {6, 9, 1, 10, 3, 4, 6}, {7, 6, 4, 2, 1, 8, 10, 11}, {8, 3, 0, 1, 2, 4, 6, 10, 11}, {8, 0, 2, 4, 6, 8, 9, 10, 11}, {7, 11, 9, 10, 3, 4, 6, 2}, {5, 8, 4, 6, 2, 3}, {4, 6, 2, 4, 0}, {8, 1, 2, 3, 0, 6, 4, 9, 8}, {5, 1, 2, 6, 4, 9}, {6, 8, 3, 1, 11, 4, 6}, {5, 11, 6, 4, 0, 1}, {7, 4, 6, 0, 3, 11, 9, 8}, {4, 4, 6, 11, 9}, {6, 6, 5, 4, 7, 10, 9}, {9, 5, 4, 7, 6, 0, 3, 9, 10, 8}, {7, 5, 1, 7, 10, 0, 4, 6}, {8, 6, 5, 4, 7, 1, 3, 10, 8}, {9, 2, 11, 6, 10, 9, 4, 1, 7, 5}, {12, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, {8, 10, 2, 11, 6, 0, 4, 7, 5}, {9, 11, 6, 10, 2, 4, 8, 5, 3, 7}, {7, 7, 3, 5, 9, 2, 6, 4}, {8, 7, 6, 5, 4, 2, 0, 8, 9}, {8, 2, 6, 0, 4, 3, 1, 7, 5}, {7, 6, 2, 4, 8, 1, 5, 7}, {8, 4, 7, 6, 5, 3, 1, 9, 11}, {9, 1, 9, 5, 11, 8, 7, 0, 6, 4}, {7, 4, 0, 6, 11, 3, 7, 5}, {6, 7, 6, 5, 4, 8, 11}, {5, 6, 10, 8, 9, 5}, {6, 0, 3, 5, 6, 9, 10}, {6, 0, 1, 5, 6, 8, 10}, {5, 6, 5, 1, 3, 10}, {8, 1, 9, 5, 11, 8, 10, 2, 6}, {9, 0, 1, 2, 3, 5, 6, 9, 10, 11}, {7, 10, 8, 11, 5, 0, 2, 6}, {6, 2, 11, 6, 10, 3, 5}, {6, 3, 2, 5, 6, 8, 9}, {5, 9, 0, 2, 6, 5}, {7, 1, 5, 3, 8, 6, 2, 0}, {4, 6, 2, 1, 5}, {7, 1, 3, 5, 6, 8, 9, 11}, {6, 9, 5, 11, 1, 0, 6}, {6, 0, 3, 5, 6, 8, 11}, {3, 11, 5, 6}, {4, 5, 7, 10, 11}, {7, 10, 11, 8, 0, 5, 7, 3}, {7, 5, 7, 1, 0, 10, 11, 9}, {8, 3, 1, 7, 5, 10, 8, 11, 9}, {5, 10, 7, 5, 1, 2}, {8, 0, 1, 2, 3, 5, 7, 8, 10}, {6, 9, 5, 7, 10, 0, 2}, {7, 7, 5, 3, 2, 9, 8, 10}, {5, 2, 3, 7, 5, 11}, {6, 11, 2, 8, 0, 5, 7}, {8, 9, 5, 11, 1, 7, 3, 0, 2}, {7, 9, 8, 11, 2, 7, 5, 1}, {4, 1, 3, 5, 7}, {5, 0, 1, 5, 7, 8}, {5, 9, 5, 7, 3, 0}, {4, 7, 5, 9, 8}, {5, 5, 11, 10, 8, 4}, {6, 3, 0, 4, 5, 10, 11}, {8, 0, 8, 4, 9, 10, 11, 1, 5}, {7, 11, 10, 9, 4, 3, 1, 5}, {6, 2, 10, 4, 8, 1, 5}, {7, 0, 4, 2, 10, 5, 1, 3}, {7, 0, 2, 4, 5, 10, 8, 9}, {6, 2, 10, 9, 4, 3, 5}, {6, 3, 2, 4, 5, 8, 11}, {5, 5, 4, 0, 2, 11}, {9, 3, 0, 1, 2, 4, 5, 8, 11, 9}, {6, 1, 9, 5, 11, 2, 4}, {5, 8, 3, 1, 5, 4}, {4, 5, 1, 0, 4}, {6, 8, 4, 9, 0, 3, 5}, {3, 5, 9, 4}, {5, 4, 9, 11, 10, 7}, {8, 4, 9, 0, 8, 11, 10, 7, 3}, {6, 1, 11, 7, 10, 0, 4}, {7, 3, 1, 7, 4, 11, 10, 8}, {6, 2, 10, 9, 4, 1, 7}, {9, 7, 8, 3, 10, 9, 1, 4, 2, 0}, {5, 10, 2, 0, 4, 7}, {6, 8, 3, 10, 7, 4, 2}, {6, 2, 11, 9, 4, 3, 7}, {7, 9, 11, 8, 7, 2, 0, 4}, {7, 3, 7, 1, 11, 4, 0, 2}, {6, 4, 8, 11, 2, 7, 1}, {5, 4, 7, 3, 1, 9}, {6, 4, 9, 0, 8, 7, 1}, {4, 3, 7, 4, 0}, {3, 4, 8, 7}, {4, 11, 10, 9, 8}, {5, 3, 10, 11, 9, 0}, {5, 0, 8, 10, 11, 1}, {4, 3, 1, 11, 10}, {5, 1, 9, 8, 10, 2}, {6, 3, 0, 1, 2, 10, 9}, {4, 0, 2, 10, 8}, {3, 2, 10, 3}, {5, 2, 11, 9, 8, 3}, {4, 9, 11, 2, 0}, {6, 0, 1, 2, 3, 8, 11}, {3, 1, 11, 2}, {4, 1, 3, 8, 9}, {3, 9, 1, 0}, {3, 0, 3, 8}, {0} }; //----------------------------------------------------------------- // Masks to compute gradient with B-Spline approximation //----------------------------------------------------------------- static const float x_grad_mask[27] = { -1/72.f, 0.f, 1/72.f, -1/18.f, 0.f, 1/18.f, -1/72.f, 0.f, 1/72.f, -1/18.f, 0.f, 1/18.f, -2/9.f, 0.f, 2/9.f, -1/18.f, 0.f, 1/18.f, -1/72.f, 0.f, 1/72.f, -1/18.f, 0.f, 1/18.f, -1/72.f, 0.f, 1/72.f }; static const float y_grad_mask[27] = { -1/72.f, -1/18.f, -1/72.f, 0.f, 0.f, 0.f, 1/72.f, 1/18.f, 1/72.f, -1/18.f, -2/9.f, -1/18.f, 0.f, 0.f, 0.f, 1/18.f, 2/9.f, 1/18.f, -1/72.f, -1/18.f, -1/72.f, 0.f, 0.f, 0.f, 1/72.f, 1/18.f, 1/72.f }; static const float z_grad_mask[27] = { -1/72.f, -1/18.f, -1/72.f, -1/18.f, -2/9.f, -1/18.f, -1/72.f, -1/18.f, -1/72.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1/72.f, 1/18.f, 1/72.f, 1/18.f, 2/9.f, 1/18.f, 1/72.f, 1/18.f, 1/72.f }; mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/pcio.h0000755000175000017500000000036210150464521023145 0ustar debiandebian#ifndef _PC_IO_H #define _PC_IO_H #include size_t getFloat(float *, size_t, FILE *); size_t getInt(int *, size_t, FILE *); size_t getShort(short *, size_t, FILE *); size_t putFloat(float*,size_t,FILE*); #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/pcio.cpp0000755000175000017500000000450510150464521023503 0ustar debiandebian#include "pcio.h" #include size_t getFloat(float *flts, size_t n, FILE *fp) { unsigned char *pb = new unsigned char[n*4]; unsigned char *pf = (unsigned char *)flts; //float* temp; //float tempp; size_t nbytes = fread(pb, 1, 4*n, fp); //swap the byte order if(nbytes == n*4) { for(size_t i = 0; i < n; i++) { pf[4*i] = pb[4*i+3]; pf[4*i+1] = pb[4*i+2]; pf[4*i+2] = pb[4*i+1]; pf[4*i+3] = pb[4*i]; // temp=(float*)&pf[4*i]; // tempp=*temp; } } delete pb; return nbytes; } size_t putFloat(float *flts, size_t n, FILE *fp) { unsigned char *pb = new unsigned char[n*4]; unsigned char *pf = (unsigned char *)flts; //float* temp; //float tempp; //swap the byte order //if(nbytes == n*4) { for(size_t i = 0; i < n; i++) { pb[4*i] = pf[4*i+3]; pb[4*i+1] = pf[4*i+2]; pb[4*i+2] = pf[4*i+1]; pb[4*i+3] = pf[4*i]; // temp=(float*)&pf[4*i]; // tempp=*temp; } //} size_t nbytes = fwrite(pb, 1, 4*n, fp); delete pb; return nbytes; } size_t getInt(int *Ints, size_t n, FILE *fp) { unsigned char *pb = new unsigned char[4*n]; unsigned char *pf = (unsigned char *)Ints; int nbytes = fread(pb, 1, 4*n, fp); for(size_t i = 0; i < n; i++) { pf[4*i] = pb[4*i+3]; pf[4*i+1] = pb[4*i+2]; pf[4*i+2] = pb[4*i+1]; pf[4*i+3] = pb[4*i]; } delete pb; return nbytes; } size_t getShort(short *shts, size_t n, FILE *fp) { unsigned char *pb = new unsigned char[n*2]; unsigned char *ps = (unsigned char *)shts; size_t nbytes = fread(pb, sizeof(unsigned char), n*2, fp); //swap the byte order if(nbytes == n*2) { for(size_t i = 0; i < n; i++) { ps[2*i] = pb[2*i+1]; ps[2*i+1] = pb[2*i]; } } delete pb; return nbytes; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/e_face.cpp0000755000175000017500000003232610150464521023755 0ustar debiandebian#include"octree.h" #include"e_face.h" void Octree::e_face_initialization() { int i,j; for (i=0;i<12;i++) for (j=0;j<12;j++) { e_face[i][j].faceidx=-1; e_face[i][j].facebit=0; } e_face[0][9].faceidx=0; e_face[0][9].orientation[0]=0; e_face[0][9].orientation[1]=1; e_face[0][9].orientation[2]=3; e_face[0][9].orientation[3]=2; e_face[0][9].facebit=(1<<0); e_face[0][4].faceidx=0; e_face[0][4].orientation[0]=0; e_face[0][4].orientation[1]=1; e_face[0][4].orientation[2]=3; e_face[0][4].orientation[3]=2; e_face[0][4].facebit=(1<<0); e_face[0][8].faceidx=0; e_face[0][8].orientation[0]=0; e_face[0][8].orientation[1]=1; e_face[0][8].orientation[2]=3; e_face[0][8].orientation[3]=2; e_face[0][8].facebit=(1<<0); e_face[0][1].faceidx=1; e_face[0][1].orientation[0]=0; e_face[0][1].orientation[1]=1; e_face[0][1].orientation[2]=3; e_face[0][1].orientation[3]=2; e_face[0][1].facebit=(1<<1); e_face[0][2].faceidx=1; e_face[0][2].orientation[0]=0; e_face[0][2].orientation[1]=1; e_face[0][2].orientation[2]=3; e_face[0][2].orientation[3]=2; e_face[0][2].facebit=(1<<1); e_face[0][3].faceidx=1; e_face[0][3].orientation[0]=0; e_face[0][3].orientation[1]=1; e_face[0][3].orientation[2]=3; e_face[0][3].orientation[3]=2; e_face[0][3].facebit=(1<<1); e_face[1][0].faceidx=1; e_face[1][0].orientation[0]=1; e_face[1][0].orientation[1]=0; e_face[1][0].orientation[2]=2; e_face[1][0].orientation[3]=3; e_face[1][0].facebit=(1<<1); e_face[1][2].faceidx=1; e_face[1][2].orientation[0]=1; e_face[1][2].orientation[1]=0; e_face[1][2].orientation[2]=2; e_face[1][2].orientation[3]=3; e_face[1][2].facebit=(1<<1); e_face[1][3].faceidx=1; e_face[1][3].orientation[0]=1; e_face[1][3].orientation[1]=0; e_face[1][3].orientation[2]=2; e_face[1][3].orientation[3]=3; e_face[1][3].facebit=(1<<1); e_face[1][9].faceidx=2; e_face[1][9].orientation[0]=0; e_face[1][9].orientation[1]=1; e_face[1][9].orientation[2]=3; e_face[1][9].orientation[3]=2; e_face[1][9].facebit=(1<<2); e_face[1][5].faceidx=2; e_face[1][5].orientation[0]=0; e_face[1][5].orientation[1]=1; e_face[1][5].orientation[2]=3; e_face[1][5].orientation[3]=2; e_face[1][5].facebit=(1<<2); e_face[1][11].faceidx=2; e_face[1][11].orientation[0]=0; e_face[1][11].orientation[1]=1; e_face[1][11].orientation[2]=3; e_face[1][11].orientation[3]=2; e_face[1][11].facebit=(1<<2); e_face[2][0].faceidx=1; e_face[2][0].orientation[0]=2; e_face[2][0].orientation[1]=1; e_face[2][0].orientation[2]=3; e_face[2][0].orientation[3]=0; e_face[2][0].facebit=(1<<1); e_face[2][1].faceidx=1; e_face[2][1].orientation[0]=2; e_face[2][1].orientation[1]=1; e_face[2][1].orientation[2]=3; e_face[2][1].orientation[3]=0; e_face[2][1].facebit=(1<<1); e_face[2][3].faceidx=1; e_face[2][3].orientation[0]=2; e_face[2][3].orientation[1]=1; e_face[2][3].orientation[2]=3; e_face[2][3].orientation[3]=0; e_face[2][3].facebit=(1<<1); e_face[2][11].faceidx=5; e_face[2][11].orientation[0]=0; e_face[2][11].orientation[1]=1; e_face[2][11].orientation[2]=3; e_face[2][11].orientation[3]=2; e_face[2][11].facebit=(1<<5); e_face[2][6].faceidx=5; e_face[2][6].orientation[0]=0; e_face[2][6].orientation[1]=1; e_face[2][6].orientation[2]=3; e_face[2][6].orientation[3]=2; e_face[2][6].facebit=(1<<5); e_face[2][10].faceidx=5; e_face[2][10].orientation[0]=0; e_face[2][10].orientation[1]=1; e_face[2][10].orientation[2]=3; e_face[2][10].orientation[3]=2; e_face[2][10].facebit=(1<<5); e_face[3][0].faceidx=1; e_face[3][0].orientation[0]=3; e_face[3][0].orientation[1]=0; e_face[3][0].orientation[2]=2; e_face[3][0].orientation[3]=1; e_face[3][0].facebit=(1<<1); e_face[3][1].faceidx=1; e_face[3][1].orientation[0]=3; e_face[3][1].orientation[1]=0; e_face[3][1].orientation[2]=2; e_face[3][1].orientation[3]=1; e_face[3][1].facebit=(1<<1); e_face[3][2].faceidx=1; e_face[3][2].orientation[0]=3; e_face[3][2].orientation[1]=0; e_face[3][2].orientation[2]=2; e_face[3][2].orientation[3]=1; e_face[3][2].facebit=(1<<1); e_face[3][8].faceidx=4; e_face[3][8].orientation[0]=0; e_face[3][8].orientation[1]=1; e_face[3][8].orientation[2]=3; e_face[3][8].orientation[3]=2; e_face[3][8].facebit=(1<<4); e_face[3][7].faceidx=4; e_face[3][7].orientation[0]=0; e_face[3][7].orientation[1]=1; e_face[3][7].orientation[2]=3; e_face[3][7].orientation[3]=2; e_face[3][7].facebit=(1<<4); e_face[3][10].faceidx=4; e_face[3][10].orientation[0]=0; e_face[3][10].orientation[1]=1; e_face[3][10].orientation[2]=3; e_face[3][10].orientation[3]=2; e_face[3][10].facebit=(1<<4); e_face[4][0].faceidx=0; e_face[4][0].orientation[0]=2; e_face[4][0].orientation[1]=1; e_face[4][0].orientation[2]=3; e_face[4][0].orientation[3]=0; e_face[4][0].facebit=(1<<0); e_face[4][9].faceidx=0; e_face[4][9].orientation[0]=2; e_face[4][9].orientation[1]=1; e_face[4][9].orientation[2]=3; e_face[4][9].orientation[3]=0; e_face[4][9].facebit=(1<<0); e_face[4][8].faceidx=0; e_face[4][8].orientation[0]=2; e_face[4][8].orientation[1]=1; e_face[4][8].orientation[2]=3; e_face[4][8].orientation[3]=0; e_face[4][8].facebit=(1<<0); e_face[4][5].faceidx=3; e_face[4][5].orientation[0]=0; e_face[4][5].orientation[1]=1; e_face[4][5].orientation[2]=3; e_face[4][5].orientation[3]=2; e_face[4][5].facebit=(1<<3); e_face[4][6].faceidx=3; e_face[4][6].orientation[0]=0; e_face[4][6].orientation[1]=1; e_face[4][6].orientation[2]=3; e_face[4][6].orientation[3]=2; e_face[4][6].facebit=(1<<3); e_face[4][7].faceidx=3; e_face[4][7].orientation[0]=0; e_face[4][7].orientation[1]=1; e_face[4][7].orientation[2]=3; e_face[4][7].orientation[3]=2; e_face[4][7].facebit=(1<<3); e_face[5][1].faceidx=2; e_face[5][1].orientation[0]=2; e_face[5][1].orientation[1]=1; e_face[5][1].orientation[2]=3; e_face[5][1].orientation[3]=0; e_face[5][1].facebit=(1<<2); e_face[5][9].faceidx=2; e_face[5][9].orientation[0]=2; e_face[5][9].orientation[1]=1; e_face[5][9].orientation[2]=3; e_face[5][9].orientation[3]=0; e_face[5][9].facebit=(1<<2); e_face[5][11].faceidx=2; e_face[5][11].orientation[0]=2; e_face[5][11].orientation[1]=1; e_face[5][11].orientation[2]=3; e_face[5][11].orientation[3]=0; e_face[5][11].facebit=(1<<2); e_face[5][4].faceidx=3; e_face[5][4].orientation[0]=1; e_face[5][4].orientation[1]=0; e_face[5][4].orientation[2]=2; e_face[5][4].orientation[3]=3; e_face[5][4].facebit=(1<<3); e_face[5][6].faceidx=3; e_face[5][6].orientation[0]=1; e_face[5][6].orientation[1]=0; e_face[5][6].orientation[2]=2; e_face[5][6].orientation[3]=3; e_face[5][6].facebit=(1<<3); e_face[5][7].faceidx=3; e_face[5][7].orientation[0]=1; e_face[5][7].orientation[1]=0; e_face[5][7].orientation[2]=2; e_face[5][7].orientation[3]=3; e_face[5][7].facebit=(1<<3); e_face[6][4].faceidx=3; e_face[6][4].orientation[0]=2; e_face[6][4].orientation[1]=1; e_face[6][4].orientation[2]=3; e_face[6][4].orientation[3]=0; e_face[6][4].facebit=(1<<3); e_face[6][5].faceidx=3; e_face[6][5].orientation[0]=2; e_face[6][5].orientation[1]=1; e_face[6][5].orientation[2]=3; e_face[6][5].orientation[3]=0; e_face[6][5].facebit=(1<<3); e_face[6][7].faceidx=3; e_face[6][7].orientation[0]=2; e_face[6][7].orientation[1]=1; e_face[6][7].orientation[2]=3; e_face[6][7].orientation[3]=0; e_face[6][7].facebit=(1<<3); e_face[6][2].faceidx=5; e_face[6][2].orientation[0]=2; e_face[6][2].orientation[1]=1; e_face[6][2].orientation[2]=3; e_face[6][2].orientation[3]=0; e_face[6][2].facebit=(1<<5); e_face[6][11].faceidx=5; e_face[6][11].orientation[0]=2; e_face[6][11].orientation[1]=1; e_face[6][11].orientation[2]=3; e_face[6][11].orientation[3]=0; e_face[6][11].facebit=(1<<5); e_face[6][10].faceidx=5; e_face[6][10].orientation[0]=2; e_face[6][10].orientation[1]=1; e_face[6][10].orientation[2]=3; e_face[6][10].orientation[3]=0; e_face[6][10].facebit=(1<<5); e_face[7][4].faceidx=3; e_face[7][4].orientation[0]=3; e_face[7][4].orientation[1]=0; e_face[7][4].orientation[2]=2; e_face[7][4].orientation[3]=1; e_face[7][4].facebit=(1<<3); e_face[7][5].faceidx=3; e_face[7][5].orientation[0]=3; e_face[7][5].orientation[1]=0; e_face[7][5].orientation[2]=2; e_face[7][5].orientation[3]=1; e_face[7][5].facebit=(1<<3); e_face[7][6].faceidx=3; e_face[7][6].orientation[0]=3; e_face[7][6].orientation[1]=0; e_face[7][6].orientation[2]=2; e_face[7][6].orientation[3]=1; e_face[7][6].facebit=(1<<3); e_face[7][3].faceidx=4; e_face[7][3].orientation[0]=2; e_face[7][3].orientation[1]=1; e_face[7][3].orientation[2]=3; e_face[7][3].orientation[3]=0; e_face[7][3].facebit=(1<<4); e_face[7][8].faceidx=4; e_face[7][8].orientation[0]=2; e_face[7][8].orientation[1]=1; e_face[7][8].orientation[2]=3; e_face[7][8].orientation[3]=0; e_face[7][8].facebit=(1<<4); e_face[7][10].faceidx=4; e_face[7][10].orientation[0]=2; e_face[7][10].orientation[1]=1; e_face[7][10].orientation[2]=3; e_face[7][10].orientation[3]=0; e_face[7][10].facebit=(1<<4); e_face[8][0].faceidx=0; e_face[8][0].orientation[0]=3; e_face[8][0].orientation[1]=0; e_face[8][0].orientation[2]=2; e_face[8][0].orientation[3]=1; e_face[8][0].facebit=(1<<0); e_face[8][9].faceidx=0; e_face[8][9].orientation[0]=3; e_face[8][9].orientation[1]=0; e_face[8][9].orientation[2]=2; e_face[8][9].orientation[3]=1; e_face[8][9].facebit=(1<<0); e_face[8][4].faceidx=0; e_face[8][4].orientation[0]=3; e_face[8][4].orientation[1]=0; e_face[8][4].orientation[2]=2; e_face[8][4].orientation[3]=1; e_face[8][4].facebit=(1<<0); e_face[8][3].faceidx=4; e_face[8][3].orientation[0]=1; e_face[8][3].orientation[1]=0; e_face[8][3].orientation[2]=2; e_face[8][3].orientation[3]=3; e_face[8][3].facebit=(1<<4); e_face[8][7].faceidx=4; e_face[8][7].orientation[0]=1; e_face[8][7].orientation[1]=0; e_face[8][7].orientation[2]=2; e_face[8][7].orientation[3]=3; e_face[8][7].facebit=(1<<4); e_face[8][10].faceidx=4; e_face[8][10].orientation[0]=1; e_face[8][10].orientation[1]=0; e_face[8][10].orientation[2]=2; e_face[8][10].orientation[3]=3; e_face[8][10].facebit=(1<<4); e_face[9][0].faceidx=0; e_face[9][0].orientation[0]=1; e_face[9][0].orientation[1]=0; e_face[9][0].orientation[2]=2; e_face[9][0].orientation[3]=3; e_face[9][0].facebit=(1<<0); e_face[9][4].faceidx=0; e_face[9][4].orientation[0]=1; e_face[9][4].orientation[1]=0; e_face[9][4].orientation[2]=2; e_face[9][4].orientation[3]=3; e_face[9][4].facebit=(1<<0); e_face[9][8].faceidx=0; e_face[9][8].orientation[0]=1; e_face[9][8].orientation[1]=0; e_face[9][8].orientation[2]=2; e_face[9][8].orientation[3]=3; e_face[9][8].facebit=(1<<0); e_face[9][1].faceidx=2; e_face[9][1].orientation[0]=1; e_face[9][1].orientation[1]=0; e_face[9][1].orientation[2]=2; e_face[9][1].orientation[3]=3; e_face[9][1].facebit=(1<<2); e_face[9][5].faceidx=2; e_face[9][5].orientation[0]=1; e_face[9][5].orientation[1]=0; e_face[9][5].orientation[2]=2; e_face[9][5].orientation[3]=3; e_face[9][5].facebit=(1<<2); e_face[9][11].faceidx=2; e_face[9][11].orientation[0]=1; e_face[9][11].orientation[1]=0; e_face[9][11].orientation[2]=2; e_face[9][11].orientation[3]=3; e_face[9][11].facebit=(1<<2); e_face[10][3].faceidx=4; e_face[10][3].orientation[0]=3; e_face[10][3].orientation[1]=0; e_face[10][3].orientation[2]=2; e_face[10][3].orientation[3]=1; e_face[10][3].facebit=(1<<4); e_face[10][8].faceidx=4; e_face[10][8].orientation[0]=3; e_face[10][8].orientation[1]=0; e_face[10][8].orientation[2]=2; e_face[10][8].orientation[3]=1; e_face[10][8].facebit=(1<<4); e_face[10][7].faceidx=4; e_face[10][7].orientation[0]=3; e_face[10][7].orientation[1]=0; e_face[10][7].orientation[2]=2; e_face[10][7].orientation[3]=1; e_face[10][7].facebit=(1<<4); e_face[10][2].faceidx=5; e_face[10][2].orientation[0]=3; e_face[10][2].orientation[1]=0; e_face[10][2].orientation[2]=2; e_face[10][2].orientation[3]=1; e_face[10][2].facebit=(1<<5); e_face[10][11].faceidx=5; e_face[10][11].orientation[0]=3; e_face[10][11].orientation[1]=0; e_face[10][11].orientation[2]=2; e_face[10][11].orientation[3]=1; e_face[10][11].facebit=(1<<5); e_face[10][6].faceidx=5; e_face[10][6].orientation[0]=3; e_face[10][6].orientation[1]=0; e_face[10][6].orientation[2]=2; e_face[10][6].orientation[3]=1; e_face[10][6].facebit=(1<<5); e_face[11][1].faceidx=2; e_face[11][1].orientation[0]=3; e_face[11][1].orientation[1]=0; e_face[11][1].orientation[2]=2; e_face[11][1].orientation[3]=1; e_face[11][1].facebit=(1<<2); e_face[11][9].faceidx=2; e_face[11][9].orientation[0]=3; e_face[11][9].orientation[1]=0; e_face[11][9].orientation[2]=2; e_face[11][9].orientation[3]=1; e_face[11][9].facebit=(1<<2); e_face[11][5].faceidx=2; e_face[11][5].orientation[0]=3; e_face[11][5].orientation[1]=0; e_face[11][5].orientation[2]=2; e_face[11][5].orientation[3]=1; e_face[11][5].facebit=(1<<2); e_face[11][2].faceidx=5; e_face[11][2].orientation[0]=1; e_face[11][2].orientation[1]=0; e_face[11][2].orientation[2]=2; e_face[11][2].orientation[3]=3; e_face[11][2].facebit=(1<<5); e_face[11][6].faceidx=5; e_face[11][6].orientation[0]=1; e_face[11][6].orientation[1]=0; e_face[11][6].orientation[2]=2; e_face[11][6].orientation[3]=3; e_face[11][6].facebit=(1<<5); e_face[11][10].faceidx=5; e_face[11][10].orientation[0]=1; e_face[11][10].orientation[1]=0; e_face[11][10].orientation[2]=2; e_face[11][10].orientation[3]=3; e_face[11][10].facebit=(1<<5); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/src/invertMatrix.cpp0000755000175000017500000000255510150464521025250 0ustar debiandebian #include"invertMatrix.h" #include void m4_submat( MATRIX4 mr, MATRIX3 mb, int i, int j ) { int ti, tj, idst, jdst; for ( ti = 0; ti < 4; ti++ ) { if ( ti < i ) idst = ti; else if ( ti > i ) idst = ti-1; for ( tj = 0; tj < 4; tj++ ) { if ( tj < j ) jdst = tj; else if ( tj > j ) jdst = tj-1; if ( ti != i && tj != j ) mb[idst*3 + jdst] = mr[ti*4 + tj ]; } } } VFLOAT m4_det( MATRIX4 mr ) { VFLOAT det, result = 0, i = 1; MATRIX3 msub3; int n; for ( n = 0; n < 4; n++, i *= -1 ) { m4_submat( mr, msub3, 0, n ); det = m3_det( msub3 ); result += mr[n] * det * i; } return( result ); } int m4_inverse( MATRIX4 mr, MATRIX4 ma ) { VFLOAT mdet = m4_det( ma ); MATRIX3 mtemp; int i, j, sign; if ( fabs( mdet ) == 0.0 ) return( 0 ); for ( i = 0; i < 4; i++ ) for ( j = 0; j < 4; j++ ) { sign = 1 - ( (i +j) % 2 ) * 2; m4_submat( ma, mtemp, i, j ); mr[i+j*4] = ( m3_det( mtemp ) * sign ) / mdet; } return( 1 ); } VFLOAT m3_det( MATRIX3 mat ) { VFLOAT det; det = mat[0] * ( mat[4]*mat[8] - mat[7]*mat[5] ) - mat[1] * ( mat[3]*mat[8] - mat[6]*mat[5] ) + mat[2] * ( mat[3]*mat[7] - mat[6]*mat[4] ); return( det ); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/setup.py0000755000175000017500000001106110675046076023000 0ustar debiandebian# setup.py is used with Distutils for building UTmesh package import sys, os from os import path from distutils.core import setup, Extension from distutils.command.build_clib import build_clib from distutils.command.build_ext import build_ext from distutils.command.build import build from distutils.command.sdist import sdist from distutils.command.install_data import install_data packFullName = "UTpackages.UTmesh" packName = "UTmesh" ext_name = "_lbiemesher" platform = sys.platform py_packages = [packFullName, packFullName+'.Tests'] # HACK: replace cc with CC (gcc with g++) CC_exe = 'CC' cc_exe = 'cc' if platform == "linux2" or platform == "darwin": CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to',`g[n]` if platform != "win32": sysconfig._init_posix = my_init_posix # C++ sources : # lbie_sources = ["cellQueue.cpp", "e_face.cpp", "geoframe.cpp", "hexa.cpp", "LBIE_Mesher.cpp", "normalspline.cpp", "octree.cpp", "pcio.cpp", "tetra.cpp", "mydrawer.cpp"] for i in range(len(lbie_sources)): lbie_sources[i] = path.join("src", lbie_sources[i]) # Lists of macros, compiler and linker options lbie_macros = [] import numpy numpy_include = numpy.get_include() lbie_include = ["src", numpy_include] comp_opts = [] link_opts = [] if platform == "darwin": lbie_include.append("/usr/include/malloc") elif platform == "irix6": comp_opts.append( "-LANG:std" ) link_opts.append("-LANG:std") elif platform == "win32": lbie_macros = [("WIN32", None)] comp_opts.append("/MT") libs = [] if platform == "sunos5": libs = ["Crun", "Cstd"] data_files = [(path.join(packName,"Tests"), [path.join(packName, "Tests", "head65.rawiv"),] ), ] # Modify the order of commands called by 'build' command - # 'build-py' should go after 'build_ext'. This way a python module generated # by SWIG in 'build_ext'command is copied to the build directory by # 'build_py' command. class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] # Overwrite the run method of the install_data to install the data files # in the package instead of a particular data directory class modified_install_data(install_data): def run(self): install_cmd = self.get_finalized_command('install') self.install_dir = getattr(install_cmd, 'install_lib')+"UTpackages" return install_data.run(self) # This class overwrites the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. class modified_sdist(sdist): def prune_file_list(self): build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) dist = setup(name = packFullName, version="1.0", description = "LBIE_Mesher library extension module", author = "Molecular Graphics Laboratory", author_email = "mgltools@scripps.edu", url = "http://www.scripps.edu/~sanner/python/packager.html", packages = py_packages, package_dir = {packFullName: packName}, ext_package = packFullName, data_files = data_files, # use the derived command classes: cmdclass = {"build" : modified_build, "install_data": modified_install_data, "sdist" : modified_sdist}, ext_modules = [Extension (ext_name, [path.join(packName, "lbiemesher.i")]+lbie_sources, include_dirs = lbie_include, define_macros = lbie_macros, #library_dirs = [], libraries = libs, extra_compile_args = comp_opts, extra_link_args = link_opts, ) ] ,) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/0000755000175000017500000000000012146213527022461 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/lbiemesher.i0000755000175000017500000001050210706201320024737 0ustar debiandebian%feature ("kwargs"); %module lbiemesher %{ #include "LBIE_Mesher.h" %} #include using namespace std; %include "numarr.i" %apply float ARRAY2D[ANY][ANY] { float outverts[1][3] } %apply int ARRAY2D[ANY][ANY] { int outfaces[1][3] } %apply int ARRAY2D[ANY][ANY] { int outfaces[1][4] } %apply int ARRAY2D[ANY][ANY] { int outfaces[1][8] } %apply int VECTOR[ANY] {int dims[3]} %apply float VECTOR[ANY] {float origin[3]} %apply float VECTOR[ANY] {float spans[3]} #define DEFAULT_ERR 0.0001f //99.99f //0.0001f #define DEFAULT_ERR_IN 0.0001f #define DEFAULT_IVAL -0.0001f //-0.5000f //-0.0001f //-1.0331 0.0001 #define DEFAULT_IVAL_IN -9.5001f //10.000f #define SINGLE 0 #define HEXA 1 #define DOUBLE 2 #define TETRA 3 #define T_4_H 4 #define TETRA2 5 %typemap(python,in) (const unsigned char *data)(PyArrayObject *array) { if ($input != Py_None) { //array = contiguous_typed_array($input, PyArray_UBYTE,1, NULL); array = contiguous_typed_array($input, PyArray_FLOAT,1, NULL); if (! array) return NULL; $1 = (unsigned char *) array->data; //printf ("number of dimensions: %d \n", array->dimensions[0]); } else { array = NULL; } } typedef vector > IntArray; typedef vector > FloatArray; // to output newfaces as a Python list //%include "fragments.i" %include "typemaps.i" %typemap(in, numinputs=0) IntArray *newfaces (IntArray temp) { $1 = &temp; } /**** %typemap(argout ) IntArray *newfaces { int sizei, sizej; int element; PyObject * res1; sizei = (*$1).size(); $result = PyList_New(sizei); cout << "size of output vector: " << sizei << endl; if ( sizei > 0) { sizej = (*$1)[0].size(); for (unsigned int i=0; i 0) { sizej = (*$1)[0].size(); for (unsigned int i=0; i #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif #include "numpy/arrayobject.h" static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i, numitems, itemsize; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} /**********************************************************/ /* OUTPUT */ /**********************************************************/ %{ static PyObject* l_output_helper2(PyObject* target, PyObject* o) { PyObject* o2; PyObject* o3; if (!target) { target = o; } else if (target == Py_None) { Py_DECREF(Py_None); target = o; } else { if (!PyList_Check(target)) { o2 = target; target = PyList_New(0); PyList_Append(target, o2); Py_XDECREF(o2); } PyList_Append(target,o); Py_XDECREF(o); } return target; } %} /**********************************************************/ /* OUTPUT: int VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) int OUT_VECTOR[ANY], int OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) int OUT_VECTOR[ANY] (PyArrayObject *array, npy_intp out_dims[1]) %{ out_dims[0] = $1_dim0; $1 = (int *)malloc($1_dim0*sizeof(int)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_INT, (char *)$1); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif %} %typemap(in, numinputs=0) int OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { int *data = (int *)malloc($1_dim0*$1_dim1*sizeof(int)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_INT, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (int (*)[$1_dim1])data; } /**********************************************************/ /* OUTPUT: float VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) float OUT_VECTOR[ANY], float OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) float OUT_VECTOR[ANY](PyArrayObject *array, npy_intp out_dims[1]) %{ out_dims[0] = $1_dim0; $1= (float *)malloc($1_dim0*sizeof(float)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_FLOAT, (char *)($1)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif %} %typemap(in, numinputs=0) float OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { float *data = (float *)malloc($1_dim0*$1_dim1*sizeof(float)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_FLOAT, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (float (*)[$1_dim1])data; } /**********************************************************/ /* OUTPUT: double VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) double OUT_VECTOR[ANY], double OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) double OUT_VECTOR[ANY] (PyArrayObject *array, npy_intp out_dims[1]) { out_dims[0] = $1_dim0; $1= (double *)malloc($1_dim0*sizeof(double)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_DOUBLE, (char *)($1)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif } %typemap(in, numinputs=0) double OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { double *data = (double *)malloc($1_dim0*$1_dim1*sizeof(double)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_DOUBLE, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (double (*)[$1_dim1])data; } /*************************************************************/ /* INPUT */ /*************************************************************/ /*************************************************************/ /* INPUT: u_char VECTOR */ /*************************************************************/ %typemap(in) u_char VECTOR[ANY] (PyArrayObject *array=NULL, int expected_dims[1]) %{ expected_dims[1] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 1, expected_dims); if (! array) return NULL; $1 = (u_char *)array->data; %} %typemap(freearg) u_char VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: u_char ARRAY2D */ /*************************************************************/ %typemap(in) u_char ARRAY2D[ANY][ANY](PyArrayObject *array = NULL, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 2, expected_dims); if (! array) return NULL; $1 = (u_char (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) u_char ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: int VECTOR */ /*************************************************************/ %typemap(in) int VECTOR[ANY] (PyArrayObject *array=NULL, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; %} %typemap(freearg) int VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: int ARRAY2D */ /*************************************************************/ %typemap(in) int ARRAY2D[ANY][ANY](PyArrayObject *array=NULL, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = (int (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) int ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: float VECTOR */ /*************************************************************/ %typemap(in) float VECTOR[ANY] (PyArrayObject *array=NULL, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; } else { $1 = NULL; array = NULL; } %} %typemap(freearg) float VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: float ARRAY2D */ /*************************************************************/ %typemap(in) float ARRAY2D[ANY][ANY](PyArrayObject *array=NULL, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) float ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*******************************************************/ /** Input: float ARRAY2D_NULL **/ /*******************************************************/ %typemap(in) float ARRAY2D_NULL[ANY][ANY] (PyArrayObject *array=NULL , int expected_dims[2]) { if ($input == Py_None) { $1 = NULL; } else { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } } /*************************************************************/ /* INPUT: double VECTOR */ /*************************************************************/ %typemap(in) double VECTOR[ANY] (PyArrayObject *array=NULL, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 1, expected_dims); if (! array) return NULL; $1 = (double *)array->data; %} %typemap(freearg) double VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: double ARRAY2D */ /*************************************************************/ %typemap(in) double ARRAY2D[ANY][ANY](PyArrayObject *array=NULL, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 2, expected_dims); if (! array) return NULL; $1 = (double (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) double ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %define UCHAR_ARRAY2D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int* DIM, u_char ARRAYNAME##ARRAYSHAPE) (PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 2, expected_dims); if (! array) return NULL; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $1 = intdims; $2 = (u_char (*)[$2_dim1])array->data; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int* DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /*** Macros to generate typemaps for pairs of arguments *******/ /**************************************************************/ /**************************************************************/ /* Input: FLOAT_ARRAY4D */ /**************************************************************/ %define FLOAT_ARRAY4D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, float ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 4, expected_dims); if (! array) return NULL; $2 = (float(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, float ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: SHORT_ARRAY4D */ /**************************************************************/ %define SHORT_ARRAY4D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int *DIM, short ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_SHORT, 4, expected_dims); if (! array) return NULL; $2 = (short(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, short ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: UCHAR_ARRAY4D */ /**************************************************************/ %define UCHAR_ARRAY4D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 4, expected_dims); if (! array) return NULL; $2 = (u_char(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef %define SHORT_ARRAY5D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, short ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_SHORT, 5, expected_dims); if (! array) return NULL; $2 = (short(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, short ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: UCHAR_ARRAY5D */ /**************************************************************/ %define UCHAR_ARRAY5D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 5, expected_dims); if (! array) return NULL; $2 = (u_char(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_ARRAY5D */ /**************************************************************/ %define FLOAT_ARRAY5D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int* DIM, float ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 5, expected_dims); if (! array) return NULL; $2 = (float(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int* DIM, float ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: INT_VECTOR */ /**************************************************************/ %define INT_VECTOR( ARRAYNAME, ARRAYSHAPE, LENGTH ) %typemap(in) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_VECTOR */ /**************************************************************/ %define FLOAT_VECTOR( ARRAYNAME, ARRAYSHAPE, LENGTH ) %typemap(in) (float ARRAYNAME##ARRAYSHAPE, int LENGTH) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: INT_ARRAY2D */ /**************************************************************/ %define INT_ARRAY2D( ARRAYNAME, ARRAYSHAPE, DIMENSIONS ) %typemap(in) ( int ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS)(PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = (int (*)[$1_dim1])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $2 = intdims; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_ARRAY2D */ /**************************************************************/ %define FLOAT_ARRAY2D( ARRAYNAME, ARRAYSHAPE, DIMENSIONS ) %typemap(in) ( float ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS)(PyArrayObject *array = NULL, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $2 = intdims; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (float ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS ) %{ if (array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/Tests/0000755000175000017500000000000012146213576023567 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/Tests/__init__.py0000644000175000017500000000001510150464521025663 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/Tests/head65.rawiv0000755000175000017500000414151010150464521025715 0ustar debiandebianB€B€B€0ÁAAA?€?€?€Â ìQÂè@ÂìØÂÿ7 MÁú(ÁôâÁïA‘Á鬀Áä2ïÁÞàxÁÙ¯ÁÔˆ´Áω¢ÁÊ»áÁÆ#ÁÁ´ÑÁ½\|Á¹>ÄÁµc‚Á±º·Á®+oÁªå†Á§ðêÁ¥QùÁ¢ùÌÁ ¾šÁžÞRÁ[¨Á›üÁšò3ÁšFIÁ™¾‚Á™•µÁ™Ñ¢Áš3fÁšÖÁ›¤lÁœÖÁžm Á e§Á¢‡êÁ¤ä·Á§šÖÁª¥³Á­ñ¢Á±s`Áµ'ÎÁ¹§Á½5hÁÁ‘cÁÆ ôÁʳEÁÏŽØÁÔšõÁÙ»ÁÞì%ÁäFÁéÇ‘Áïl­Áõ%ÁúègÂdfÂZrÂUE ñKÂê×ÂîBÂø°Áü0ÁöajÁðª½Áë ÁåuÁßóóÁÚ‡ÉÁÕD`ÁÐ#•ÁËDÁÆ%ºÁÁpûÁ¼ôøÁ¸¢‡Á´k0Á°tðÁ¬´ŒÁ© ²Á¥«àÁ¢ž÷ÁŸé¶ÁŠ?Á›FÁÁ™UZÁ—ÉÁ–r‚Á•^ÅÁ”µ¦Á”:‡Á”5Á”AøÁ”›Á•R$Á–1¯Á—n`Á™­Á›µÁ1ÁŸ¢Á¢iˆÁ¥pŒÁ¨½'Á¬X±Á°9Á´HÿÁ¸y˜Á¼ÍÉÁÁYSÁÆçÁË’ÁÐ3<ÁÕYŠÁÚ¤ôÁàxÁ峕Áë]ÍÁñ×ÁöñâÁüà<Âi›Âoe»ÂúÂõ ÁýûÂÁø"ŽÁòYøÁì‡ÁæãÁÁáEØÁÛÊHÁÖ_íÁÑïÁËÕÁÆÇ“ÁÁÈ]Á¼÷ÌÁ¸_ñÁ´"Á¯Ê=Á«´+Á§àÁ¤&ÜÁ ¬¾Á‡Áš»Á˜MÁ– #Á” Á’lÁ‘":ÁãÁX;ÁŽò“ÁŽÆØÁŽæ¡Á=Á Áû—Á’BßÁ“ìCÁ•èŒÁ˜âÁš‹ÁFÁ WÿÁ£¾ÛÁ§uñÁ«xÁ¯œ"Á³ÌFÁ¸7ÄÁ¼ßÁÁ¿RÁÆÑøÁËô˜ÁÑ.ÁÖ”NÁÜ zÁáºfÁçjRÁí;Á‰ì=ÁŒÁŽ??ÁÀ"Á“¥AÁ–èØÁš„êÁžsjÁ¢—âÁ¦Â§Á«$Á¯ÇÚÁ´§XÁ¹»©Á¾ÜÇÁĆÁÉÎÁÎõ,ÁÔ‹ƒÁÚHOÁà(Áåô Áëà‹ÁñëÁø ÐÁþ)u©èÁÿ&ÖÁù ·ÁòöŒÁìä&ÁæìiÁáøÁÛ_“ÁÕµ„ÁÐ5ÁʃòÁÅIÁ¿Ë–Áº²­Áµ¢0Á°¯ýÁ«Ö—Á§ UÁ¢«ãÁžrÁšUÁ–tÁ’ÿÍÁÍÁŒÆnÁŠ%Á‡Ó«Á…µJÁƒïÐÁ‚•€ÁrüÁ€±ÍÁ€’ÁßuÁ€2kÁ€‹™ÁARÁ‚RKÁƒ˜¦Á…U¤Á‡vqÁ‰°(ÁŒEáÁB,Á’žÅÁ–U6Áš^ÁžƒÁ¢º°Á§4áÁ«îïÁ°ãºÁµÿÁ»%îÁÀz0ÁÅàÁËe¾ÁÑqÁÖ̱ÁÜŒ:ÁânÅÁèqªÁîGÁô°ôÁúÖ¾Âù±Áû½uÁõœÁï”ãÁéŽÁãÁÝ’Áׯ>ÁÒAÁÌmŽÁÆÙÁÁÁk-Á¼^Á¶çüÁ±×Á¬ÏlÁ§ûNÁ£@Áž¯ÌÁšg'Á–\GÁ’sÁŽÚÁ‹žÆÁˆµÁ…ûõÁƒ‚ÏÁ[ ÁNaÁ|kÁyç,ÁxazÁwb*Áw1Áwy‚Áx¦Áy“-Á{ä%Á~ïÁVÁƒ3þÁ…tÁˆaÁ‹1~ÁަŸÁ’nÚÁ–mâÁš‰˜ÁžÎóÁ£\Á¨+&Á­2Á²GdÁ·„ŠÁ¼òÁÂn¨ÁÈ$ÁÍ¡ÚÁÓS±ÁÙ*ÂÁß$"Áå<°ÁëXwÁñq•Á÷—OÁþ«#ÁøyËÁòLÆÁì2Áæ5ÁàG~ÁÚKÍÁÔižÁΪÊÁÉ‘ÁÃZ`Á½Ø Á¸…—Á³XöÁ®G Á©7òÁ¤JàÁŸš Á›BÁ–ŸßÁ’мÁ޶¾Á‹ ˜Á‡¸Á„Ë]Á‚øÁ~ê8ÁzvâÁvøØÁt-ŸÁq¢$ÁpÁoBüÁnåmÁoFMÁoÙnÁq^ÕÁsÙ Áv­MÁzaçÁ~ŒòÁ“Á„QpÁ‡yªÁŠírÁŽ¥tÁ’¡+Á–·åÁ›0ÁŸÀiÁ¤ªÁ©­ÈÁ®Ï2Á´%ÂÁ¹“Á¿_ÁÄ­zÁÊQÁПÁÖ5ÁÜ^ÁâãÁè?ÁîEÁôsªÁû‘ÁõP»Áï(YÁéÈÁâôiÁÝÁ×ÁÑ9JÁËsÁÅÇKÁÀGÁº…âÁµßÁ¯àAÁªÜcÁ¥éøÁ è”Áœ!XÁ—šMÁ“/.ÁèÁ‹(RÁ‡”|Á„0ÁóÁ|‹wÁwˆ´ÁrüÏÁobÛÁlªÆÁj*’ÁhŠœÁgã¼Ág›ÁgÒÁhg€ÁiùLÁldMÁoR Ás+þÁwm˜Á|+oÁ€Ü:ÁƒîÁ‡\žÁ‹&æÁñÁ“<7Á—¶<Áœx>Á¡gqÁ¦j-Á«¤hÁ°úKÁ¶b®Á»óóÁÁpÁÇEoÁÍ$ÁÓ)ÁØñ•ÁÞôËÁå"Áë;{ÁñZÜÁø®oÁò[¯Áì"FÁæìÁßð,ÁÙèâÁÓÿûÁÎéÁÈM$Á¢ÅÁ½ÕÁ·}Á±ùiÁ¬§“Á§ŒSÁ¢©¦ÁÏaÁ˜ûqÁ”aÛÁ Á‹ÕsÁ‡åçÁ„TVÁšÁ{l¸Áu‘Áp¡­ÁlY6Áh§£ÁeôäÁc’†Áaè…Áa4ÒÁ`§<Á`׌ÁaÖSÁcUmÁeY7ÁhPœÁlLôÁp¸lÁu¼9Á{¾Á€©8Á„-„Á‡ì½Á‹Ù±ÁÊÁ”®âÁ™ŒÁžb@Á£z*Á¨³‹Á®_Á³}ÖÁ¹ÐÁ¾³dÁÄ€žÁÊ8ñÁÐ –ÁÖ>ÁÜüÁâ(ôÁè?ÁîrÁõò Áï :ÁéUªÁã%ÁÝÁ×ÁÁÑïÁË8²ÁÅ`zÁ¿ŸúÁº Á´—|Á¯¦Á©¿¸Á¤…ÁŸ–•ÁšÆ9Á•ü¶Á‘lmÁÁ‰0Á… ZÁ^AÁ{ÍÒÁuhÙÁot­ÁjdaÁfQ¶ÁbÚ;Á_Ä’Á]uµÁ[ÛŸÁZȺÁZ{2ÁZ°JÁ[û"Á]=_Á_+PÁb7sÁfZÁjXÁoŸ:ÁuGŠÁ{¢ÁYPÁ…ØÁ‰ÔÁ_ºÁ’pÁ–ÆMÁ›´ÂÁ Ë~Á¥÷,Á«W$Á°Ü{Á¶^Á¼íÁÁ£ªÁÇdOÁÍKƒÁÓV ÁÙLHÁßVÏÁå~ÁëµáÁñ߀ÁìupÁæÄÅÁà„ÇÁÚ_AÁÔYZÁÎieÁȃ Á²öÁ¼ç¯Á·<†Á±¿@Á¬Y–Á¦ÿ@Á¡ÓýÁœÖòÁ˜xÁ“=êÁŽšBÁŠEUÁ†E§Á‚g„Á}[:ÁvB}Áoä+Áj=zÁe!Á`ñúÁ]ºÁZ`ÁXuÁVaÅÁUGkÁU9sÁU„tÁVgüÁWôÑÁYýÊÁ\ù&Á`ošÁdà—ÁjSŠÁp>úÁvÃ.Á}©(Á‚‰ÈÁ†ž®Á‹ ØÁ¤”Á”`ªÁ™PÌÁžS¢Á£Á¨×ºÁ®5çÁ³Â‘Á¹YcÁ¿FÁÄØ‹ÁÊÒ¸ÁЬUÁÖ¦ÁܳÁÁâÔ>Áé$Áì)oÁæ Áá6pÁÛø`ÁÖåÔÁÑÕEÁËÚ“ÁÅûgÁÀ BÁº[úÁ´´ŽÁ¯- Á©Ê"Á¤rÌÁŸ77Áš8iÁ•{oÁÖ±ÁŒ+fÁ‡ÂŸÁƒ°ŽÁÆ×ÁxTÛÁqˆŽÁk'üÁe˜ Á`ÌVÁ\ùÁXà®ÁUò1ÁS¡¥ÁQûxÁPÛxÁPëvÁPù¾ÁQ¨èÁSƒ˜ÁUÝsÁXrÖÁ[ã«Á`k²Áe²MÁk{¹ÁrŽÁy9Á€S|Á„~fÁˆÎ¹ÁO•Á’!Á–î¡Á›ýBÁ¡*ˆÁ¦g¥Á«Ù!Á±^0Á¶ì£Á¼§ÉÁÂ}èÁÈM«ÁÎ'_ÁÔ—ÁÚ*ÁàZ–ÁæwñÁæ–7Áàæ¢ÁÛ\ÁÕùCÁÐÁnÁË·ÁƽÁÁÈœÁ¼ù Á·àËÁ²;¨Á¬ÂÁ§m—Á¢&8Áœî“Á—áÁ“ÞÁŽ~ªÁ‰÷BÁ…¡ŒÁ‹ÊÁ{†ÏÁt-SÁmYjÁgSÁaÇéÁ]#¨ÁXñ¶ÁU™ÁR(­ÁP=÷ÁNŽ’ÁM‘ˆÁM0ÁMWoÁN ³ÁOäåÁRB¢ÁTï¨ÁXnÉÁ\Õ¾ÁaÀÎÁgÙÁn ÐÁtò¿Á|ª˜Á‚váÁ†¸€Á‹AKÁçaÁ”ÅÁ™ß”ÁŸ‚Á¤RÁ©Á®þVÁ´€ÁºgÕÁÀ+|ÁÅâHÁË¿UÁÑÀŒÁ×âèÁÝü™Áã'òÁá!õÁÛT×ÁÕ¥CÁШÁʾ8ÁÅaÁÀŠÁ»mÁ¶£:Á±Ã‰Á¬ë]Á¨PâÁ£ùJÁŸéÁšÅéÁ•ÏÌÁ‘ ÁŒw"ÁˆßÁƒ©ÁSÁxHÁpë‚ÁjìÁdìÁ^î0ÁZsÁU¾*ÁR<ŠÁOf>ÁMWüÁKŸ'ÁJÝõÁJ]ûÁJË&ÁKœÈÁLýØÁOO“ÁRS²ÁUôLÁYò@Á^ÞSÁd­@ÁjØ5ÁqÓãÁy’TÁ€ÉõÁ… Á‰rÕÁŽÞÁ’úŸÁ˜ ÁÜÁ¢#OÁ§mXÁ¬ì¿Á²œ•Á¸O–Á½µÿÁÃ}ÁÈF¬ÁÍ]ÁÒÑ Á×ñóÁÝÖÁÛi0ÁÕÙÁÐÁÊeŽÁÄß;Á¿…­Áº\¿Áµ_Á°eþÁ«ƒxÁ¦‘¦Á¡ÈïÁC4Á™dÁ•¸Á‘ÁŒÿ|ÁˆÉwÁ„ìªÁqÁ|ÁtÌxÁmïÁgM-Áa‰pÁ\YÖÁW‘(ÁSÍÁP-ÃÁM¦uÁKq ÁIЊÁI#äÁHÀ+ÁHÝçÁI¿ËÁK%ùÁM8úÁOü(ÁSº ÁWã|Á]AÁb{1Áh{oÁoV‚ÁvÞsÁ~¹çÁƒ”Á‡ÿÁŒÈÁ‘THÁ–=ÊÁš¬²ÁŸÒÁ£œ8Á¨uÿÁ­g‹Á²{±Á·ÅÁ½yÁÂa{ÁÇœ›Á̾YÁÑåÕÁ×5 ÁÕlÁÐ$¥ÁÊåÁÄ×9Á¿'ÏÁ¹¤Á´PÁ¯0.Áª6tÁ¥>WÁ ]¼Á›d*Á–­WÁ’?¶ÁŽ" ÁŠQFÁ†O=Á‚´Á{úCÁtžÁn:ÁhMLÁc˜Á^nÕÁYéÉÁV9ÁRÙ&ÁOþ§ÁM<£ÁKXÁI°³ÁH®fÁHÝÁG˜éÁGÊèÁH—çÁJÁKô6ÁN§±ÁQðYÁV(&Á[O3Á`yÁfZðÁlM9Ár’çÁy‡ Á€»ÁƒÁ,Á‡È=Á‹¹‰ÁÅtÁ”!Á˜…ÁOÊÁ¢;Á§DZÁ¬†ÅÁ±Ö{Á·(Á¼hXÁÁŽÁƯxÁËùÁÑnÃÁÏÜcÁÊI€ÁÄásÁ¿I¾Á¹›œÁ³ìdÁ®kµÁ©Á¤ƒÁŸÙÁšÁ•'Á<Á‹š6Á‡HçÁƒP#Á~øWÁvõ†Án_…Áf”?Á_¨äÁY’9ÁSÿ˜ÁOkMÁJšsÁFçïÁCD<Á@hCÁ=¡™Á;“áÁ:FIÁ9"OÁ8©½Á9q‹Á:s%Á:I‚Á;4³Á=yÞÁA ÍÁDnçÁH &ÁLÔÁRººÁXæÁ]ÉŽÁdn²Ák@¬Ár-/Áyå(Á6Á„í¡Á‰ hÁwÁ’.ÔÁ—¦ÁœÁ¡JøÁ¦žºÁ«ñ­Á±4ÿÁ¶`Á»|9ÁÀ¿|ÁÆ1ªÁËÎþÁÊP1ÁÄ•Á¿°Á¹ŸÚÁ´¾Á®b«Á¨³ÄÁ£6ÁðgÁ˜åpÁ“îÜÁÁ‰ô¨Á…ÛÁ€‘½ÁxÄ?Áq*¯Ái\åÁaÁXÐÁQpfÁKYÁE “Á@5;Á;h¤Á7l'Á3Â#Á0Ý@Á.WÁ+ÔÁÁ*îZÁ)«8Á)&HÁ)þ°Á+ ÜÁ+tÁ,Á.€:Á2_-Á5/:Á9„Á>@æÁDlÁIeæÁO}ÚÁVS×Á]öÁdimÁl”yÁtR¥Á|T Á‚tkÁ‡ùÁ‹ïcÁáRÁ–?Á›gFÁ ¼RÁ¦ÀÁ«6Á°L°Áµˆ·ÁºöáÁÀ’òÁÆJ8ÁÄï5Á¿ ÇÁ¹NÑÁ³¿2Á®`)Á¨¿Á£,ôÁ~‡Á˜ŽÁ’ÈÁÆŠÁˆÑ`ÁƒÜñÁ} Át…Ák-×ÁcÿÁ[ÞvÁS­ÉÁK_¡ÁC~`Á<¤ûÁ6G>Á1 zÁ,\*Á(^Á$X0Á![zÁ˜îÁ"ŠÁJUÁN Á¼]Á¨Áã(Áí¯Á_Á¹€Á#K”Á&ÁÁ*R®Á/í=Á5Š4Á:é ÁAf-ÁH4 ÁO,ÁVôöÁ^ücÁf¶[Ánÿ¼Áx,Á€ÒÁ…·”ÁŠÝ[Á0/Á•†"ÁšÑØÁ òÁ¥!žÁªURÁ¯¾ÜÁµYlÁ»™ÁÀÇxÁ¿½Á¹®qÁ³Æ»Á® âÁ¨|JÁ£"ÃÁ|+Á—÷yÁ’MtÁŒÙ|Á‡¦>Á‚¬âÁ{s.ÁqN>ÁgBrÁ]éÕÁU[òÁM²ÁF.‘Á=Ý´Á5ãÁ.Á'»®Á"¹Á¹Á»æÁ ßÁÝ<Á);Á ßÁ ‘wÁ ÖUÁ t„Á xpÁ È«Á „Á;¢Á5;ÁwÁ'WÁ΃Á!è­Á&ÝeÁ,±ÙÁ3TqÁ:.ÎÁAŒÁI³ÁQJgÁY6ÝÁaóÁkmgÁu)ÓÁZ˜Á„ùÁŠL»Á RÁ”ñÁ™ûöÁŸ&Á¤Š+Áª"êÁ¯×´ÁµŽ–Á»dÁº·VÁ´„%Á®o±Á¨„SÁ¢ÆˆÁ;NÁ—è-Á’;HÁŒº Á‡!–Á³´Áy·Áo3ÚÁeSSÁZí€ÁQëÁGíÁ?ºÁ8uÁ0u0Á(D8Á ¶¦ÁzNÁ8'Á}©Á -ÁîÁm¡ÀÿU'Àùò¯À÷Õ¡Àöi)Àö¶³ÀøÅÀû˜…ÀüóÀÿwÁ ‚Á1ÁymÁ œIÁ¢ÁtäÁ®óÁ%KœÁ,NdÁ4.Á<ÁC˜@ÁKùÎÁU4Á^öáÁiðÁs‡Á~&§Á„kªÁ‰ÉÁŽÜyÁ“û»Á™Y‡ÁžðÁ¤£ÁªXÌÁ°0>Á¶1®Áµª>Á¯‰9Á©NVÁ£3]ÁCêÁ—…Á‘ü°ÁŒ±Á†üúÁçÁwø¨Ám+ôÁbû~ÁYqÁO-ÁD›bÁ:ååÁ2{Á*ZFÁ#÷Á´ÁúÁ ™ÝÁ°ÀþØ­ÀõoBÀín.Àæ03Àà“ ÀÛ&nÀؼŠÀ×]ÀØÂ4ÀÚ›ÒÀÞ -Àà8TÀãELÀé0ÊÀì¡÷ÀôAÀÿ"ÁüXÁ _LÁ›fÁGªÁ¾¼Á&k_Á.3 Á6"?Á? KÁHÓ]ÁRóÁ]õÁg³ÙÁrn_Á}HÏÁƒÄ…Áˆ×±ÁŽ-çÁ“Á´Á™rzÁŸ&ÄÁ¥aÁ«–Á±4×Á°píÁª…>Á¤_ÊÁžOÁ—úÁ’÷ÁŒFÁ†Á Á}dÁwƒçÁl“øÁa¿GÁW˜ÁLãÔÁC"{Á8»êÁ.]Á$æ@Á€ÁY5Á l2Á+qÀüNfÀí'Àá9ÞÀØEÐÀÏ% ÀÇè2ÀÂ16À¼À«À¹ñàÀ¸¤NÀº¶ÅÀ¼Ï$ÀÁ@®ÀÄ›åÀǵ®ÀËêSÀÏÙþÀØ}&ÀäûÀí*„ÀøãÁsUÁ uÎÁÜsÁ Á z5Á(þ’Á2ˆ±Á<–±ÁF½ÁQAfÁ\àÁgGÁql`Á{w Áƒ“Áˆ˜äÁŽFÏÁ“ùVÁ™ÕCÁŸà¹Á¦UÁ¬'·Á«\OÁ¥BÁŸRÑÁ™<Á’îêÁŒÄQÁ†ËÁ ÁwNÁlŽxÁaaÁV3<ÁKœ¤Á@ë*Á6ÍÁ-EåÁ"qQÁ<¾Á×Á<òÁS‰Àï¼fÀà!…ÀÑØÀÄZ›À»iƒÀ±v3ÀªAqÀ¤6pÀžóàÀ›¤4Àšp®ÀœéaÀŸ½÷À¤w²À©1sÀ¬(ƒÀ¯júÀ´(ÝÀ½šèÀÇ¥ÑÀШßÀÜrvÀèÂÝÀ÷HIÁgÁÁ 2Á·ÁV¸Á&ˆÍÁ0mšÁ:ÖÁEýÁP¦JÁ[hÂÁeSFÁoÖ–Ázî&Áƒ!YÁˆÑ¥ÁްÁ”ÁFÁšúÄÁ óSÁ¦ÓfÁ¦‚rÁ 8ëÁšÁ”$ðÁŽ]Á‡ÇOÁ“BÁw(:Ák£ëÁ`¬WÁV-*ÁJ´6Á?á}Á5]Á*ÐèÁ ·iÁFGÁ BGÁGíÀó1fÀåÀÕ…ÖÀÅ kÀ·a™À¨eÀž¬À”¾#À¡]À†ãZÀâÀ|[kÀzEpÀ€,eÀƒ’SÀ‡í\ÀŒtKÀ„À”fÀš•À£ûÀªPáÀ´žªÀ¿ÍBÀÍ?½ÀÛîòÀì?ÖÀúïÁI³ÁY9Á5×Á$wõÁ/<Á:PpÁEpVÁO>õÁY±Ád¼™Áp¥Á{bmÁƒ’Á‰©ÉÁá*Á•ÁÁ›¦SÁ¡·yÁ¡ÛÏÁ›ozÁ•KÁŽôÁˆüµÁƒ ‚ÁyNÁlÐGÁ`ÄrÁU=çÁJSnÁ?Ú¶Á4a£Á)¤¦Á†ëÁ¶çÁ »—Á'˜Àì|žÀÙ3xÀÉ.×À¼~À«O‹À›ã4ÀŽ«ÏÀ‚!ÀsX/Àc¸¸ÀUçúÀL3•ÀD¡.ÀC’ÀJÐèÀR}¨ÀYÄ Àa‘êÀiÕ+ÀuX¶À€gšÀ†’+ÀªxÀ™FIÀ£ßÀ²%ÀÁãÀЃNÀàî¿Àôu@Á!°Á.µÁëÁ$jÁ/vÁ9+¸ÁC™ÞÁN¢ôÁYáVÁe.ÊÁpõ\Á}0€Á„ÆôÁŠèÁ~»Á––!ÁœÙsÁ"Á–¶aÁfÁŠÁƒ×±Á{·EÁpÞÁc †ÁV‰¢ÁJn3Á>å·Á4 oÁ)œûÁ%?Á†)Á „vÀýXkÀéý[ÀÖ~YÀÁÒÀ®ÍŽÀ ñ/À’EÀ‚iÊÀkG#ÀPÃÀBkOÀ/¤aÀ#zÀªÁÀìÀ$ÀOÑÀ%MÀ)ÈøÀ/UjÀ6¥)À@]_ÀJŽÙÀV Àe™]ÀyÜýÀ‰j…À—ÌÀ§Z•À¶ùÀȬ(ÀÜÀð XÁ³1Á »ûÁ€`Á#ºÁ-‚åÁ8ˆHÁCÇŒÁNûðÁZÈÁg ãÁs %Á~Ç4Á…]Á‹|XÁ‘É]Á˜?CÁ˜nÁ‘ï8Á‹—ÚÁ…hnÁ}üÛÁq‰ØÁe‡›ÁZÆÁM Á@WÿÁ4*ƒÁ( ÚÁÞñÁ}XÁ ìÀû,&Àç%wÀÑÀ…À¿W,À«mWÀ–žÀ†H`ÀwrnÀU ­À9Œ¬À&R:À7¦ÀN¿ùì_¿î(©¿å¿åû¿õ31Àƒ°Àœ!Àú.À GqÀ)À­¡À$IsÀ6œEÀE¯À`&ZÀ~-ŠÀŒ»øÀ·ùÀ±ÀÄ)ÀÙG¤Àï1Á[€Á Ál,Á"2QÁ-j{Á8ÉÁD›ïÁPëGÁ\¶ÁhsÎÁt‚8Á€lÁ†ÃñÁFåÁ“ï?Á”$fÁr¦Á†åUÁ€‚Átž“ÁhÕÁ[}jÁOpYÁCô4Á7÷Á*C–Á=ÁxÁ×pÀûoÀäEÊÀÏã‘À»ÚOÀ§ sÀ•ÖSÀÛ”À\ýÜÀCøpÀ,WÀ¦ÞÀ3ø¿ê(¿Û,2¿Ö¡8¿Ô5S¿Ïz¿Èh™¿Ç÷%¿Þ§¿å—}¿åÐ@¿é4À¿ìïE¿ò5C¿ü+À¤ÝÀTšÀ1¤ ÀL9¿Ài 8ÀˆÀ™À­·±ÀÃ\òÀÚ·ÜÀî—ÁQpÁ ôYÁæÁ"–HÁ.q•Á:¶ÚÁFQÁR)êÁ^X±ÁjÏúÁw˜Á‚]Á‰Áê€ÁšÉÁ‰ÏÁ‚…*ÁwÐNÁjî«Á^tÇÁR0–ÁE’Á9z7Á. Á!X ÁYtÁÿKÀøõÀäèÀÏʉÀ¹*—À¥©ŽÀ‘ÁnÀ|@ëÀ\OHÀ7®²À²vÀ Õû¿íÓâ¿ÞK,¿ÑÏl¿Äõ^¿È:ã¿Æ>ž¿À.d¿½w¿¾?п¿m*¿Âí½¿Æ†¿ÉOO¿ÌÝ¿Ñ9¿Óê¿Ø\*¿ðÏÈÀšQÀ®¼ÀAÜÐÀ_iÑÀƒEÀ˜^ðÀ¯QÀÂf¬ÀÖ…JÀë·/ÁðuÁ c|ÁI¸Á$^¬Á/ôdÁ;ìëÁHBsÁTãÁaË)ÁoÆÁ|ž¥Á…!pÁ‹÷ Á‹FÁ„%Á|7{ÁoÁaöÅÁTö‹ÁHeÁŒÁr0Á€-Á~¹TÁpcÁbEÌÁTmÁFç!Á9ÆÁ- ÑÁ !ÃÁ{”ÁXéÀöUèÀÞ ©ÀÆ*À®¸—À—’"À‚«¤ÀU²;À.pšÀõ{¿ÿ\C¿îL¿Ý§>¿Íy¿Æ#¿¿7Í¿º/N¿ºWö¿ºTx¿ºPú¿¹‘6¿·t(¿µW¿µÊ¿µÿ¿´‹¿´¡¿µA¬¿³Od¿¯0C¿¬jÛ¿ª¥’¿®ïQ¿µ ¿ÂB¿Ï]·¿Ð?•¿èŽ À|öÀ2$’ÀXç Àƒ%»À™1ëÀ¯·ÓÀȃzÀãWÀýbžÁ ¿µÁ”Á&H–Á3‰pÁ@ì ÁN©~Á\ Áj˜Áx¿ëÁx…’ÁiÍùÁ[DfÁLò¤Á>åEÁ1,Á#ÝÃÁçÁ nmÀûE,ÀãH£ÀËÞúÀµ3À EÀ…c·À_iAÀ9Ç ÀüdÀ–7¿îàÿ¿ÔÂØ¿Çå¿À/¿½NŸ¿½Š@¿½Å´ÑÙ¿½Î[¿¼I¿º+û¿¸í¿µñß¿µX¿µø¦¿¶™6¿·9Ç¿´Íð¿±ìs¿°'*¿®a⿬œ™¿¯¦¿¶vg¿¼¼×¿Ãˆ`¿Ôc¿ì¿ÓÀ¥›À7ÜÀ`•À…³Àž›òÀ¹%$ÀÒ Àì:ÁJ¢ÁxÁ³7Á+JÂÁ9.áÁGpÁU7¦Ácj¾Áqb<Ás74Ád( ÁU;üÁFzîÁ7ï<Á)¦ Á³Á/?ÁÀ¸= À¡€ÀŒK¤Àl,ÒÀ>ó©À\ºÀË ¿ë ¿Ý)¿ÕÔ'¿Ë‡¿Á'R¿Àmð¿À©‘¿Àå2¿Á Ó¿ÁO9¿Áè¿¿Û¿¼ãÍ¿ºˆ ¿¸¾¿·…¿¸Ÿ¿¸—°¿¹1â¿·n ¿µ¨Â¿³ÀÚ¿±³}¿¯¦¿­”û¿®Ì¿µg´8/¿Êùn¿Ò\¿ô[À:[À=n¾Àn\„ÀŽ›hÀ§”õÀÁ`ÛÀÛiLÀõæÁ‚ÁãTÁ#¿Á1ÈVÁ?øëÁMî–Á\PÁjzÁm®ûÁ^òQÁPB6ÁAðÁ2$oÁ#Z^ÁÐzÁ›‘Àñ³>À×mtÀ¾éDÀ¦fZÀމWÀqµ.ÀJ¾À(kÀ…·¿ð·¿ã¼¿ÓÄp¿Êz¿Âì¿Ã¿Ã{¯¿ÃÞ^¿Ä@$¿Ä{ſķg¿ÃÕq¿ÁV#¿¾ÖÕ¿¼W‡¿¹Ø9¿¹Ç¿ºP¿ºÙ)¿º7A¿¹jþ¿·ˆ|¿µ{¿³mÁ¿±`d¿¯G¿­)M¿®꿸Kÿ¿Âg ¿Î|Ò¿ÚSÌÀ—9À$Ý^ÀLÙÀ|·7À—OÄÀ°È‚ÀÊ­cÀåÀ`Á›9Á„˜ÁžÁ*Š^Á8¢UÁG&ÁU çÁdmHÁh~‘ÁYgîÁJu#Á;®ÂÁ- *Ám4ÁcªÁ•«Àä4ÎÀÈ+šÀ­‚ìÀ”øÀ}Œ‚ÀO³À)Ù»À Ô{¿õªÔ¿åp`¿×¿Ê`p¿ÄÞ"¿Ää4¿ÄêF¿Å= ¿ÅŸº¿Æi¿Æe¿Æ $¿Ä‹,¿ÂÖÿÀ¦P¿¾'¿»§³¿¼€¿»ïê¿» Ú¿ºQÊ¿¹„²¿¸º¿·5c¿µ(¿³;¿°ú¿®ÛÔ¿¬Ê™¿®È^¿¶™¿¾RԿƿܰ”À“bÀ0%hÀ]Ù™À‡=²À¡EÀ»Û™À×.›Àó§ÁYSÁUÕÁ#°áÁ2S£ÁA-ÐÁP-Á_4•ÁcZÁT€ÁÁE˜Á6y}Á'w(Á¨bÁ ÃÀ÷Þ‘ÀÚ™+À½$¿À ªQÀ…ÉãÀ[déÀ5zÀC ¿ùäg¿è‹©¿Úš&¿Ì­,¿ÆÛç¿ÆÕÈ¿ÆÛÚ¿Æáì¿Æþh¿Ça¿ÇÃÅ¿ÇC¿Åõ™¿Äb̿®c¿Àùú¿¿E‘¿½¨“¿¼Ùƒ¿¼ s¿»;c¿ºlS¿¹žf¿¸ÓÈ¿¸ +¿¶âK¿´Ê¿³¿±Z¿¯²¿­V`¿²=®¿ºé¿ÃÉá¿Ðœ¿ë.9À2‚À@æˆÀr…À’øHÀ­äZÀÉ$ŠÀä«ÁœÁBÊÁ"™Á-|Á<îÁK7óÁZ|1Á_LÑÁOïOÁ@¬BÁ1Š~Á"“NÁÓ Áä\Àì+aÀÏCâÀ³j4À™1ÆÀz¿°V鿱Ìñ¿½ĿǮî¿Ò7¡¿æ[ ÀÀ?žÀsXÀ•h^À²uÀϨ)ÀíàfÁA*ÁµºÁ%7ÌÁ4ÀÁDN¤ÁSéèÁZÅÁJPÑÁ:˜AÁ*ìôÁRìÁ ÏóÀøÙPÀÚlàÀ¼†?ÀŸpÉÀƒ·SÀTÖwÀ&éÀÓ¿è+ ¿ÜÖ¿Ñç„¿Î8 ¿Îên¿ÎÌû¿Î¯ˆ¿Î…¿ÎN°¿ÍŸ¿ÊÓi¿ÈC¿ÆÔ¡¿Åž¿Ãé«¿ÃWÏ¿Ä8ò¿Å¿Å³“¿Ã¤¿Àoµ¿½ÍÅ¿»+Ö¿¹ìÝ¿¹ 俹Z쿹º®¿ºp¿ºz2¿ºH¿¸hK¿µß­¿³5¿¯Vr¿´„翺ïH¿ÁY¨¿ØéqÀ~À-šÁÀbTêÀÞ À«›7ÀÉÒ´ÀèTÎÁŒÑÁÒÁ"¬ÛÁ2ZœÁB¬ÁQÙiÁXoÁH«*Á8ñ‡Á)EÁ©ÙÁ %°Àõ‚¬ÀÖßëÀ¸f!ÀšŠhÀ{{ÀEÚ{Às~¿ù:„¿ëîÀ¿Ücǿч´¿Ï~¿Ð3¿Ðè ¿ÑSŒ¿Ñ6¿Ñ±¿Ï™¿ÌKs¿ÉN¿Æ¿¿Åu³¿Å3Œ¿Æ°¿ÆõÔ¿Çzu¿Ç®@¿Å7¿ÂŠ-¿¿ø$¿½f¿ºÔ¿º"e¿ºe2¿ºÄô¿»$¶¿»„x¿»ä:¿»O¸¿¸p‹¿´¾È¿± ¿±¹Y¿¸#¹¿Âì:¿Ô…¿¿ý›ÀÀ'¶FÀ[`À‰×âÀ§oƒÀޏÀäk¬Á—šÁ Á ›%Á0=›Á?ï|ÁO­JÁW}óÁG®nÁ7ç,Á()ˆÁxEÁ×¥Àòœ.ÀÓË„Àµ_.À—”ÖÀuÏrÀ@°ÛÀkÉ¿õìó¿éFþ¿Ý–x¿Ñ'å¿ÐÄ¿Ñy¿Ò.¿Òã¿Ó˜ ¿Ó[ɿФ¿ÍÃ~¿Ë ;¿ÈYÊ¿ÆCÞ¿ÆUC¿Æ¦5¿Æ÷(¿ÇH¿Ç™ ¿ÅDg¿Â²]¿À T¿½Ž£¿¼Æý¿¼it¿¼zƒ¿¼»h¿¼üN¿½=3¿½~¿¼Þ쿺1¿¶u\¿²Ã™¿¯+³¿µX*¿ÅÉ©¿Óœ ¿ò­À ›¹ÀS˜ÀÀ…åuÀ£k…ÀÁ»OÀàƒ/Àÿ—ÄÁpÁ&ƒÁ.êJÁ>¸ÁN¤ÁV¥(ÁFÔ±Á7 ~Á'NäÁŸ1Á5ÀðþjÀÒChÀ³ùÑÀ–f8ÀtjÀ@ ôÀI¿ù'ç¿ë.¿Ú¨;¿Ób¿Ñ¶“¿Òmd¿Ó$4¿ÓÛ¿Ôb¿Ôk~¿ÒÇ|¿Ð ¿Í`›¿Ê­*¿È»Ù¿Ç‘ù¿Æsú¿ÆÄÍ¿ÇÀ¿Çf³¿Ål—¿ÂÚ¿À§»¿¿è”¿¿)m¿¾Öú¿¾µ„¿¾Ò ¿¿†¿¿Tk¿¾Ïp¿¼hö¿º|¿¶î ¿³Ñx¿°´ç¿µËn¿Å@¿Ôg•¿ï\$À¨ÚÀPÃ5À„ÂÀ¢|¶ÀÀñªÀßÔôÀþþ€Á+¯ÁèÆÁ.²Á>„iÁN]ÕÁVÅùÁFøÁ72÷Á'xûÁÍ¢Á5ùÀñs@ÀÒÉGÀ´–%À—!'Àuæ‹ÀBUyÀü¿þ~˜¿ä(¿Ý.˜¿Ö7'¿Ò—©¿ÓNy¿ÔJ¿ÔIR¿ÔGŒ¿ÔW~¿ÔoÓ¿Ògk¿Ï³ú¿ÍŠ¿Ë3Ô¿Ê ô¿Èà¿Ç¶4¿Æãf¿Ç4X¿Å”Æ¿ÃÉS¿Ã +¿ÂK¿Á‹Ý¿ÁD€¿Á# ¿Á“¿Á*¾¿À¿ó¿¾Yz¿»ó¿¹Œ†¿¶öq¿³Ù῰ॿ¸J&¿Æ¯½¿ÖÝ>¿órÀ ¼ÀS"ÉÀ…Ò:À£nRÀÁÍRÀà 9Àÿ½"Á…ÿÁ? Á/ðÁ>ÔƒÁN«‹ÁW¡ÁGT×Á7”qÁ'àÁ;vÁ¬ÀòsÃÀÓãÇÀµÒ™À˜‹EÀy8ËÀFU}À¯š¿ÿ¨¿îV¿àº1¿Ù H¿Óx¾¿Ô/¿Ô0“¿Ô.οÔ-¿ÔC~¿Ô[Ó¿Ôt(¿ÒZ¿ÏSé¿Í«Ð¿Ìï¿ËX¿Ê./¿ÉO¿ÇÚo¿Æêê¿Æ+ÿÅl›¿Ä­t¿ÃîM¿Ã²¿Ã¿Ão¿ÂÉc¿ÀO׿½ã„¿»} ¿¹¿¶°¿³âI¿¶ØØ¿¾Žå¿Èad¿Úyg¿ûóBÀ%‹hÀXëÀˆÕnÀ¦‡+ÀÄëTÀã²`Á\}Áõ^Á œêÁ0P¿Á@ öÁOÒnÁXsÁHÄÁ9"òÁ)“€ÁÁ Á~À÷$9ÀÙ=bÀ¼¶ÀŸäjÀ…q¹ÀXÒéÀ*tùÀ ø¿ù°M¿íAC¿á½I¿Ö Ž¿ÔÕ¿Ô¿ÔJ¿Ô*¿Ô/¿ÔGÔ¿Ô`(¿ÔZº¿Ñ§I¿Ð#Ë¿Îùë¿ÍÐ ¿Ìb¿Ë¿É¦Ï¿ÉE¿ÈŽ2¿ÇÏ ¿Çä¿ÆP½¿ÆŒ¿Åþ¿Äê«¿ÂÂl¿Àí¿¾º¿»•º¿¹»¿¶‹»¿µã7¿½šá¿Äտ̉°¿àZùÀ¨¡À2ú»Àe´@ÀŽu<À«˜×ÀÉ• Àè7Á]&ÁÓBÁ"c.Á2úÁA¹ÕÁQx]ÁZñÁKsÚÁ< èÁ,¿Á—ÁˆÀÿÇ\ÀãÀÆh À©ŒÛÀŽ !ÀhšGÀ9¦öÀ_–ÀJ¸¿øÍ¿é‰¿Þr¿×'o¿Óû‹¿ÓùÆ¿Ô+¿Ô¿Ô3Ô¿ÔL)¿Ôd}¿Óú©¿Ò›Æ¿Ñ*ÿ¿Ï·µ¿ÎDl¿ÌÑ"¿Ë“d¿Ë5¿Ê™¿Ê׿ÉrT¿È³,¿È¿Ç ó¿Ä㴿»t¿ÀT¿¾Ve¿»å¿¹`ž¿·[¿¾·{¿ÉE$¿ÓI¿à/пúÀQ™ÀI£ÀzÁóÀ˜6VÀ´c?ÀÑ'^Àî».Án—Á±:Á%»Á4˜îÁD.sÁSϘÁ^)ÁOW¬Á@?˜Á1P4Á"”·ÁÐÇÁãÀìzÀÏû?À´GÀ™D¡Àì×ÀQÂ=À)ú"À E¿ýÍ™¿ñ¿æÄo¿ßy_¿Ø.P¿ÓßB¿Óï+¿Ô€¿Ô4пԀ¿ÔËm¿Ô¹±¿ÓÔà¿ÒÝb¿Ñn¿¿Ïûu¿Îˆ+¿Í™T¿Í%¿Ìžö¿Ì!ǿˤ˜¿Ë¿É-;¿Çü¿Äܼ¿Â´}¿Àм¿¾SÍ¿¼Þ¿¹°¿À¿Ç‹¿¿ÐáU¿Û‘~¿é·TÀ ­0À4wÀaõ¸ÀŠŽ6À¤¹îÀÀCgÀÜ_·Àù3 Á # ÁîvÁ(ò'Á8 ]ÁGobÁVØ4Ác@üÁT^ ÁEmmÁ6YUÁ'q ÁÁfÁ \lÀøl>ÀÜv‚ÀÁ/YÀ§áÀŽ „Àm ÀBö\À À´À­o¿øÂY¿ï_¿è¹¿âëô¿Ùm¿Ô—Å¿Ôã¿Õ.b¿Õy±¿Õ¡b¿ÔúÉ¿Ô#É¿Ó,J¿Ò4Ì¿Ñ=M¿Ð?5¿Ï†f¿ÎÕ-¿Î#ó¿Írº¿ÌÁ€¿ËQ¿ÈÓð¿Æè¿ÄÕſ­†¿À…F¿¾Q5¿¼5í¿ÃJ¿Í)ª¿ÑB\¿×Ï%¿î›À?qÀ(/kÀOš(À~ÜþÀ˜‡‹À²n¼ÀÍÐÀé2]ÁÄÁÁ–Á.0iÁ<òæÁKåPÁZýÖÁhLÎÁYIÁJkÛÁ;¾ŒÁ-M<Á½ÁÝfÁÝ5Àê‹íÀÐÀ¶W»ÀÀmÀ†Õ¿ÀcÀ=h/À•æÀ ôøÀ²ï¿ø†d¿ì¥#¿à!Ò¿Úø#¿Õøe¿Ö'õ¿ÖsD¿Õâz¿Õ;á¿Ôr±¿Ó{3¿Òƒ´¿ÑŒ5¿ÐË´¿ÐB¹¿Ï‘¿ÎàE¿Î/ ¿Í}Ò¿Êé§¿È=f¿Æ9¡¿ÄM³¿ÂaÅ¿ÀuØ¿¿ºì¿Çƒ¿ÎT¿Ú•¿ää¶¿ñ ñÀ €úÀ$ÒƒÀI¦ÀszÀ˜²À§ñzÀÁý ÀÜ]dÀ÷JÁ ÁŒ.Á%Ú!Á4NÏÁB×ZÁQ|7Á`4ÉÁm£zÁ^ûÆÁP†¶ÁB45Á3ïsÁ%ÅèÁïéÁ gFÀúE{ÀàCÀÇR”À¯ç¸À™S)ÀƒüÀcq&À>² À À½À ª^ÀÑ¿÷/Á¿ç Ö¿â€ ¿Ý_j¿Ø>´¿ÖÊ+¿Ö#’¿Õ|ù¿ÔÁš¿ÓÊ¿ÒÒœ¿Ò´¿Ñ\¿ÐÝ¿ÐMѿϜ˜¿Îë^¿Íb=¿Êµü¿È ¼¿Å‹@¿ÃŸS¿ÂÀ¿ÅO¿ÎúÒ¿Òî-¿ÙÊ‘¿éZ¿ò.âÀ vÀ&m¬ÀI SÀm–¤ÀŒkÀ£GNÀ¹èÀÒ9fÀìZÁ†³ÁñÁ«µÁ,ÁÀÁ:Ï|ÁI'¸ÁW¯Áf@—ÁséaÁe´ÁW:ºÁHüÒÁ;îÁ-UÁÁÓµÁ†BÁ –Àò- ÀÚš‰ÀÃDâÀ­5À™„_À„Àb®À?öýÀ!ÁCÀ éÀ}°¿ïüº¿îaÓ¿ëh¿äÜ¿ÛTJ¿×. ¿Õ¾¿Õ‚¿Ô¿Óa³¿Ò§Q¿Ññ¿Ñr¿Ðó¿ÐXê¿Ï§°¿Í.“¿Ê‚R¿ÇÖ¿Åò*¿È…¿Ëöï¿Ïhÿقþ¿çW‰¿òIF¿ús@À À&±˜ÀLÊÀoÀ‹Ì³ÀŸÆÊÀ¶x½ÀÎ2ÊÀåWùÀýˆ¶Á ¦gÁ ¯Á&ˆÁ4"ÁAø¡ÁPÉÁ^<âÁl™<Áz§Ál_Á^R®ÁP‰*ÁBßÁ5rÁ(2Áa”Áâ¥ÁhÀî`<À×äîÀáÛÀ¬á³À˜­¸À„Í?Àdƒ.ÀD:À*ÃzÀ“åÀ ZW¿ÿr¿¿÷RÙ¿ïûË¿âΚ¿Þ¨[¿Ú‚¿ÖŠB¿ÔÝÿ¿ÓòQ¿Ó7ï¿Ò…”¿Ò”¿Ñ‡•¿Ñ•¿Ï§)¿ÎD¿Ñ”Ø¿Õ#“¿Õ^¿Õ_¿ÛÌP¿ÙË.¿ã©¿ùHÀ,ÀdeÀ2ÿŸÀMø.Ào\ÏÀ@zÀ Z¼Àµ·4ÀÊ•÷ÀáÀùÌqÁ¯‚Á¶8Á!mìÁ.¯úÁ<7¤ÁIÄÍÁWr+Áek^Ás™ Á€àîÁsã©Áf#ºÁXšLÁK.HÁ>ÔÁ1L›Á$èÁåÁ “ÁÂJÀîÂøÀ×z5ÀÂÄÀ­¡¹À™¹SÀ‡q†ÀnÂÀRèÀAŽÀ!>ÀšÀ“Ö¿û3¿ës¿ìL›¿çÌt¿ãl›¿ßÒf¿Þƒ¿Ü<Ÿ¿àZß¿ÞÉ"¿ÝÎå¿ÜÔ¨¿ß‹¿áF½¿äÕx¿èd4¿â‹¿á©d¿æ…D¿ëì#¿ùpþÀãÀ$‹@À>]wÀ_¸,À{½=ÀÙÀ œéÀ·+iÀËfÀàíëÀöEiÁ¯ ÁäÁßÁ*Õ³Á7jÁD}äÁQöbÁ_ŠdÁm"ÁzëÍÁ„Å Á{ä¨ÁnfYÁaÙÁT!ÁG_Á;†Á/-RÁ#*¬ÁÏGÁ &uÁ}Àí¥ÜÀØ9¾ÀàBÀ°NzÀž–nÀŽüOÀƒÉÀd €ÀEºîÀ2lÀFÀšùÀ³0¿ùŽ¿ó…8¿ðU¤¿ì÷Ì¿é(©¿ñ.Ú¿ö6D¿òåÍ¿ñ¾K¿õÜ…¿ûKü¿ùV¥¿úrÆ¿ú=%¿ï¹†¿ó7¿ö̉ÀKäÀëÀ15kÀPÊ‘Àg¥hÀ„ìýÀ–’4À¦>ìÀ·<îÀËb‰ÀâFñÀö²!ÁhhÁ8ÁÅïÁ(ÿäÁ5)âÁAÁM‰ÝÁZv­ÁgÅÏÁuYdÁzTÁˆß–Á‚%BÁwÅÁj:ÏÁ]Ž:ÁQVGÁEaèÁ9bóÁ.1Á#'=Á~ÐÁ ±PÁÜJÀî¯ ÀÚ¿hÀÈD_À·–RÀ§åöÀ™ž,À‡]eÀuD¦À[6¹ÀE×DÀ-jíÀâUÀYÔÀMëÀgÊÀ­ÀÀQÀÔÀ[ÀAÀ ñàÀ „ÂÀ ‡À ¥ À-mÀ ¢GÀ>ŽÀc£À,BEÀB0ˆÀ\E{Ày7;ÀŒ­ÛÀ›mÀ® À¿}MÀÐD¤ÀâBEÀ÷ Á±ÁhÉÁ‹ÂÁ'rƒÁ2ÿ?Á?/7ÁK†ØÁWe5ÁcÃÁpŽ•Á}·XÁ…—ÂÁ&4Á† nÁ€2aÁsÒ<Ág¬Á[¨ÁO±ÄÁDN)Á9N‰Á-©rÁ"Â'ÁÝ‘Á /LÁÏÀó3Àá—¡ÀÑ œÀÂÇÚÀ¯úâÀ K@À“žjÀ„à•ÀrS?ÀY:ìÀFÒÀ7dÀ'ùWÀ"ÜÀýÀ‹:ÀÚ À79Àñ‡ÀÂåÀB:À"¢XÀ')¦À-“9À;LÖÀ6 nÀ<™ÀDÖýÀWkÀpóSÀ‡ÍÀ”.+À¥->À´€yÀÅyÀØÎ]ÀéùtÀû"‡ÁkÁ˜<Á.Á'Ÿ'Á2ͦÁ=Å*ÁIO”ÁUmÁaà»ÁmÆ%ÁzµÁƒ^âÁ‰â—Á‘¸ØÁ‹PÚÁ…ïÁ~üÁqû6ÁfÁZ«†ÁOÁCïÁ8õÁ.ºÁ#;BÁ ÁZYÁ/:Àû¼Àë•4ÀÚmFÀÈ÷cÀ»^‡À¬;ÀŸ'oÀðEÀ† 'Àx^ÀgšÀWüÀQ¸6ÀLúÀLå‹ÀFƒÀBWÀALúÀG7oÀG ~ÀK³ÂÀRPîÀ[öìÀjÕLÀi˜NÀpu¸ÀyÚdÀ…iÕÀ’0ÀŸíoÀ®uUÀ½„ÀÏ}¸ÀÞi‹Àð®mÁêÁ ŒçÁU˜Á:Á'ÐÃÁ3S Á=îœÁHÄ™ÁSÜlÁ_Œ²Ák½‰Áx&lÁ‚ Áˆ45ÁŽdÁ–vÁÁBÀÁŠ=rÁ„-|Á|{ÁqqÁeäÁZGeÁO@—ÁDLíÁ9k Á/%Á%EèÁæNÁBiÁ ÙÔÁèsÀóCIÀã¶÷ÀÕ–ÀÆEVÀ¹<ñÀ«ikÀ¡¡^À—•ÀŽ ÆÀ‡ Àƒ³øÀ€òÈÀ€r}Ày‚1Àt|ÀsüÒÀyïÀyàÀ~EÅÀ‚’ÍÀˆRbÀWiÀ‘^À”¬"À™5À ÀJÀ¬&bÀºpƒÀÉÔuÀ×%tÀç¦{ÀøøºÁ¶.Á9ÑÁÅÁ IÂÁ)S·Á3QiÁ>!ÙÁI£"ÁTO?Á^ÝÁj:Áu®Á€édÁ‡*³ÁS9Á“fxÁ›wDÁ•v©ÁbsÁ‰w=ÁƒÄZÁ|EÅÁp­=Áeœ_ÁZ¤çÁO³0ÁE\lÁ;R¾Á1צÁ(ï2Á B’ÁBÞÁ;Á΀Àÿ¬3Àï-ÀâÐÀÓ‚=ÀÇ‚íÀ½!À³ùóÀ©ÒÉÀ£øÇÀ @ÚÀÃ4ÀœBÜÀ˜™#À– ¼À•ç¯À˜oÀ˜3áÀšÜÓÀž€À¤IMÀ«3À®¤¨À²5sÀ¶]jÀ½`rÀÇÞøÀÕl*ÀãöÀòŠÁ®“Á ‡³ÁÉÛÁ‰²Á$DËÁ-fÁ6$ñÁ?w¸ÁI¡œÁTƒÂÁ`QÁjrÁu/Á€ÕÁ…òËÁ‹þ£Á’:ˆÁ˜FÁ ®vÁš›gÁ”´]ÁÁ‰XäÁƒŽ’Á|pÁq nÁf šÁ[¤NÁQ~óÁGìdÁ>»åÁ5å Á-_Á%£Á9‡Á‰©Á Ál+ÀýYpÀï-êÀä£}ÀÙÐPÀÐÑÀÆÝ:ÀÁäÀ½ÀÀ»œºÀ¹iÀµ¶qÀ³AÀ³0(ÀµP—ÀµKŒÀ·ííÀ»6ÀÁ+áÀÇõœÀÌÉ÷ÀÐOçÀÔB¤ÀÚðQÀä†ÀÀð¥ÀÿnbÁWJÁ-˜Á;ÅÁfEÁ'pkÁ0áÁ:iÔÁCJ½ÁL&ÁUµÖÁ`òÁjñ¯ÁvoDÁ€Q_Á…©¼Á‹CHÁ‘yÁ—£ÁOìÁ¥×‡ÁŸô0ÁšAÁ”’âÁŽÊ^Á‰:åÁƒ½Á|r´Áqø&ÁgÁ©Á^ãÁT±žÁK¯üÁBÊ•Á:ÕÁ1êúÁ)»EÁ"¨šÁtðÁŠ.Á E•Áè}ÁÇÈÀ÷UNÀíHkÀä²7ÀàbBÀÛêÀÚ˜À×^^ÀÓ’çÀÑGÐÀÑD˜ÀÓìÀÓ:íÀÕÊgÀØÑ ÀÞžvÀå–ÀêôÆÀîQÀò±mÀù¢ÁËÞÁuôÁ d†ÁÓ7Á%áÁ#„>Á,½Á4ÖÁ=Q€ÁFºŽÁPw'ÁY?mÁbFÁÁl®ÁvnÁ€´=Á†URÁ‹r´ÁÓÁ–o"Áœ@Á¢A˜Â FhÂ7ŒÂ2EÂ:Áü£Áöå·Áñ/—Áë†cÁåà¬ÁàOeÁÚä¹ÁÕŸÁÐdÁËKpÁÆcdÁÁ°$Á½(wÁ¸µkÁ´|‹Á°†®Á¬×âÁ©KÕÁ¥ívÁ¢áÇÁ (qÁ­Á›oGÁ™Š>Á—ûoÁ–CÁ•|¾Á”À—Á”,®Á”XÁ”EƒÁ”¸¤Á•C,Á–ÏÁ—Q¼Á˜÷XÁ›nÁ4WÁŸ¥SÁ¢qàÁ¥•YÁ©8Á¬¿Á°F!Á´EÌÁ¸ˆÁ½”ÁÁ§¢ÁÆjvÁË`=ÁÐ{;ÁÕžgÁÚè'Áà[ Áåô!Á믿Áñx+Á÷PÁý8:“½Â˜‘ÂAÂ8/Â/ÁþYÁÁønúÁò¢ËÁìïäÁç?Áá™ÁÛýÁÖwbÁÑÊÁËã*ÁƸšÁÁ²çÁ¼áÊÁ¸IbÁ³Û­Á¯‡|Á«tQÁ§©lÁ¤%Á ŠoÁdÁš—_Á˜&ˆÁ•ØBÁ“Ô•Á’9½ÁÑ«Á³!ÁŽþ7ÁŽqˆÁŽE}ÁŽƒÝÁŽéÖÁ‘ ÁlhÁ‘µ¤Á“kLÁ•}xÁ—­‹Áš4îÁLÁ PíÁ£Â[Á§hÁ«BWÁ¯_IÁ³¸Á¸2NÁ¼Ú<ÁÁº ÁÆÌAÁËìXÁÑ&„ÁÖŒwÁÜùÁáÌ9ÁçˆÁíYvÁóCŠÁù1¿Áÿ7†Â¬<ÂFÂ;›Â1áÁú^’Áôi¶Áî†CÁèÁ%Áã ÁÝX°ÁצÁÒ;ûÁÌÆDÁÇxÁÂSÁ½;HÁ¸LIÁ³•ÝÁ¯”ÁªÌzÁ¦œÎÁ¢µ0ÁžøOÁ›aÁ˜`Á•9`Á’´†Áh5ÁŽPÖÁŒ¦(Á‹K(ÁŠ"Á‰l¥Áˆð­ÁˆÂÜÁˆô®Á‰SÁŠÁŠþùÁŒTñÁŽ*Á'ÆÁ’aNÁ”þêÁ—éhÁ›¾ÁžœmÁ¢o Á¦xDÁª¤>Á®ôÁ³~(Á¸D‡Á½B¨ÁÂc¢ÁÇŽýÁÌå¬ÁÒg‘ÁØ Áݹ¥Áãƒ0ÁékÓÁïZÓÁõ[¨ÁûxöÂØ[Âa ÂN8Áü†ÝÁör’ÁðsiÁêÊÁä¾&ÁÞþÁÙB+ÁÓ•SÁÎ!ÁÈ RÁÃAÖÁ¾ØÁ¸õiÁ³óúÁ¯¢ÁªˆdÁ¦2ƒÁ¡øeÁíÂÁš#EÁ–wYÁ“ÎÁõÁ}ÃÁ‹3BÁ‰ äÁ‡P™Á…üŽÁ„ÐÁÁ„^Áƒ¯ûÁƒÆÁƒž\ÁƒûÊÁ„ÏvÁ…Ó­Á‡0ÏÁˆôkÁ‹åÁN°Áá“Á’ËÁ–kÁ™´€Á¨3Á¡ËìÁ¥÷¤Áª^ÒÁ¯MÁ³ìÁ¹dÁ¾'ñÁÃlŒÁÈß_ÁÎrªÁÔ¡ÁÙѤÁß´êÁå¦ Áë¡DÁñ¸Á÷àÖÁýû§Â”SÁþìÌÁøÊ¸Áò´;Áì îÁæ§tÁàÎ8ÁÛŠÁÕ[óÁÏœÊÁÉûgÁÄ„Á¿0IÁ¹ï…Á´Ê‹Á¯Ò|Áªë}Á¦6‚Á¡ÂŽÁn?Á™AñÁ•eGÁ‘ËËÁŽZ Á‹@ÁˆŒÁ†<)Á„ CÁ‚@ùÁ€ëFÁŽÁ~fÁ}DgÁ|ì‚Á}üÁ}ØiÁ™GÁ€Ð¨Á‚ÁƒÞÁ† 9ÁˆNÁŠêlÁîÁ‘R~Á•6Á™ ÿÁGÁ¡†…Á¦ ÝÁªÒŠÁ¯Õ9Á´÷JÁº(Á¿ˆØÁÅcÁÊ•ÁÐIðÁÖ#ïÁܦÁáþ°ÁèŽÁî"<Áô?#ÁújÂÚ}ÁûoAÁõ80ÁïéÁéÁâòïÁÝ›Á×0[ÁÑ…ÁËÔ¬ÁÆ$4ÁÀ‘Á»*úÁµò©Á°ÔOÁ«ËtÁ¦åþÁ¢ ÁwËÁ™“Á”ÚÕÁà"Á<ØÁ‰à¾Á†³ÁƒçIÁŠÁ~ºrÁzÿ€Áx>±Áv–ÁtxÔÁsW Árö}ÁsrdÁt<@ÁuË•ÁwÍÁzxnÁ~þÁ>›ÁƒŠWÁ†>aÁ‰\=ÁŒÜãÁ¹)Á”ÙÂÁ™’Á]{Á¢ŽÁ¦äßÁ«ý»Á± zÁ¶k/Á»Ð’ÁÁKäÁÆòÁÌÀoÁÒ$ÁØl|ÁÞjøÁä…ùÁê¥ÍÁðÍ6Á÷¤ÁþAèÁøÓÁñȃÁë¢eÁåöÁßw¾ÁÙmXÁÓƒòÁ;´ÁÈ­ÁÂkÁ¼ØdÁ·]ÏÁ² EÁ¬íYÁ§Ü•Á¢å,ÁžÁ™Y5Á”éEÁ¹ºÁŒª_ÁˆêuÁ…ŠjÁ‚uÜÁ/tÁzFÁuè—Ár(ûÁo:»ÁlÂÁk%.ÁjjÁiÁj!ÉÁjÓÿÁla¬ÁnžAÁqcÊÁu,ùÁywÁ~3·ÁåŽÁ…zÁˆ¹ûÁŒ±ÁÔÁÁ•NÁ™uGÁž.Á£&¦Á¨A:Á­o$Á²Ë=Á¸ZÁ•ŠÂÁý_ÁŒ¾jÁˆÃÞÁ„ïvÁtÜÁ|ÇÁwB‚ÁqöQÁmH-Ái—µÁf¯Ád¢ÁbX^Áaj³Áa¥Áat@ÁbÒÁc³ÃÁf)bÁiÁlô4Áq2]Áv ZÁ{Ñ#Á9îÁ„ã:ÁˆÊúÁŒÞ[Á‘Á•¤^Ášv²ÁŸ-Á¤•ÔÁ©Þ¤Á¯S¾Á´ÒÐÁºlËÁÀ ˆÁÅРÁ˺oÁÑǯÁ׿yÁÝó¬ÁäüÁêACÁðzTÁ÷¿¿ÁñfÁë&%ÁäøŸÁÞÏÞÁØ¿ÉÁÒÎÁÌÝKÁÆñ8ÁÁ!ôÁ»sùÁµÊFÁ°8ÿÁªÙ3Á¥¬‚Á £.Á›”ùÁ–¢³Á‘ô„Ái‘Á‰IÁ… ¶ÁMôÁ{‘Áu-xÁo…NÁj3ÇÁe`4ÁaޤÁ^³ÃÁ\æÁZ[ÁYšÎÁYA9ÁY–EÁZ,ÐÁ[ØŸÁ^zÀÁa„\Áe{yÁi®tÁn®‡Át™ºÁ{'_Á-¿Á…ÝÁ‰"èÁzñÁ’"Á— ¤Áœ Á¡7ÔÁ¦”¢Á«þ(Á±ŠnÁ·%Á¼×Á²uÁȳÉÁΩÁÔ©²ÁÚËÁàý•Áç# Áí^‚ÁôÅGÁîdˆÁèñÁáÖoÁÛ´&ÁÕ—rÁÏ‘[ÁɨÁÃÂÁÁ½ô9Á¸E—Á²¤ÀÁ­ùÁ§‡ÉÁ¢CEÁ9ÓÁ˜a Á“_PÁŽ–ÛÁŠjÁ…¾ÃÁŸíÁ{Á¸ÁtÞÂÁnI‘Áh*ZÁbïÃÁ^V†ÁZfjÁWŒ ÁU¶ÁSG9ÁR¢sÁR.pÁR`ÐÁS-ºÁTÙ ÁWOÁZG:Á^tÃÁbï5Áh ÁmºgÁtGDÁ{§uÁ«Á…Ç/ÁŠ:>ÁŽürÁ“ã•Á˜êÁž(ÒÁ£w£Á¨ëõÁ®Á´ âÁ¹êvÁ¿ÑDÁÅŸ}ÁË“ÒÁÑ«Á×ÑôÁÝæÇÁäïÁêiÁñëÚÁëŽpÁå6@ÁÞè¼ÁØ·‡ÁÒ¡þÁÌ”ÔÁÆ›HÁÀ»}Áºß¦Áµ$7Á¯–6Áª–Á¤ˆåÁŸ+ÁšªÁ•"ÁPÁ‹Œ'Á‡ÌÁ‚½×Á}@MÁu“VÁn XÁgûÛÁa±(Á\OïÁWö@ÁT5ÈÁQ/ñÁNÆYÁM ÁLÓÁKœ¶ÁKÒGÁM÷ÁNsÁP„ŽÁSƲÁWÐMÁ\o†Áa–ÁgŽõÁnG@Áu“ÌÁ}=&Á‚ÒÉÁ‡^¸ÁŒ&VÁ‘ÀÁ–SÁ›LhÁ ¡ÁÁ¦(4Á«·ïÁ±gçÁ·žÁ¼Ô¸Á¹¾ÁÈÄÁÎÓÁÔܽÁÛ˜ÁáJ¬Áç•þÁïJsÁèÝ(ÁâˆÁÜ:ÁÕöwÁÏÏÛÁÉÈïÁÃÎÚÁ½åŽÁ¸ Á²BþÁ¬EÁ§%ÂÁ¡ºÁœ_3Á—/ùÁ’5§ÁgñÁˆ èÁ„ßÁË·Áwí¦Áp)ÁhÛ}ÁbÁ\"ÝÁV¬ïÁR;ÏÁNÝuÁK€QÁHõÜÁGPÁF$âÁFØÁFMêÁGmDÁHÖõÁJ÷pÁN*ZÁQßLÁVÁ\M„ÁbX6Ái™Áp4ÁxƒÁ€LÜÁ„æËÁ‰™ÄÁŽ… Á“‹¢Á˜» Áž&LÁ£„µÁ© ¡Á®©ÖÁ´QüÁº#ýÁÀ%ÁÆÁÌ ÐÁÒ&±ÁØRIÁÞ»Áä¶vÁë‹)ÁåúõÁà•ÁÙ¸ ÁÓwµÁÍ@ ÁÇ&ÒÁÁ0ÑÁ»MDÁµt?Á¯©Á©÷PÁ¤lÁŸ Á™®ƒÁ”€Á›ÁŠØÅÁ†/Áx‹ÁzdXÁrŽÌÁjï{ÁcȧÁ]íÁW(ŠÁR4ÁM‘tÁIì®ÁFÄ@ÁD?+ÁB’°ÁA`kÁAmÁA“nÁBRbÁD3ÁF‡,ÁINÑÁM¾ÁQÚÒÁWfüÁ]‹ÉÁdnHÁkœÿÁs›xÁ|VqÁ‚–$Á‡L\ÁŒ./Á‘-Á–_\Á›–uÁ¡Á¦ÔÁ¬!öÁ±Ü6Á·Á©Á½”yÁÃy­ÁÉtÙÁχ¥ÁÕºVÁÛßWÁâÓÁåôÁà@iÁÚ±˜ÁÕJ‡ÁÐPÁÊé$ÁÄÀÁ¾­¾Á¸¾”Á²èÁ­Á§yîÁ¡øŒÁœ©Á—N‡Á’=ÁcÁˆV£ÁƒÃ‚Á~x ÁuàÓÁmïœÁf~Á_KŸÁXî«ÁSÁN¢ÁIéšÁEÉýÁB¸#Á@®ìÁ>ø,Á=×jÁ=“ÈÁ=ªEÁ>kËÁ@l¨ÁBÖ­ÁE†ÃÁIJvÁMðöÁS,¸ÁYeìÁ`ÇÁgU&Áov·ÁwäIÁ€fßÁ…Á‰ßGÁŽðXÁ”¥Á™[OÁžÄGÁ¤*!Á©Ä–Á¯ Áµ`€Á»ÁÀûSÁÆý_ÁÍ"@ÁÓD§ÁÙa6ÁßœHÁà‚hÁÚªbÁÔöBÁÏhüÁÊÅÁÄÐÁ¿ÈÍÁºÍÁµÛ½Á°zªÁªÁÁ¥iÁŸ“oÁšFUÁ• hÁå¯ÁŠíÛÁ†)–Á¢4ÁzR¯ÁqåŸÁj(uÁbôÊÁ[ÔÙÁUmBÁOûöÁK×ÁFˆ˜ÁBÉ3Á?¼ÙÁ=§„Á;ÞˆÁ;FÁ:ˆŠÁ:ðtÁ;É/Á=LEÁ?ËãÁBÛVÁF™cÁJγÁP‡ÁVýÁ\›2ÁdœÁlÜÁtSÈÁ}"JÁƒÌÁ‡øæÁ ýÁ’.Á—< Áœ{ÎÁ¡õ$Á§¢}Á­pÎÁ³ 2Á¸ÏÁ¾½ÁÄТÁÊîÁÐú­Á×'áÁÜl`ÁÚú ÁÕ;¾ÁÏabÁɬÊÁÄ!CÁ¾ÂaÁ¹”Á´’€Á¯–ëÁª®ûÁ¥êQÁ¡ÁœtõÁ˜†Á’í·ÁÔÁˆíMÁ„G1Áž©ÁvÑÁn}OÁfÂjÁ_Á½ÁXç[ÁR»ÖÁMhÁHc_ÁD_Á@‡ËÁ=íÍÁ;¨£Á9è¼Á93eÁ8ÌÁ8öÁ9áDÁ;LáÁ=‚ÙÁ@}ÁD^°ÁH»úÁNÁS²ÏÁZ]Áal`ÁiD‚Áql¡Áz¥Á‘©Á†R8Á‹=ÂÁ2IÁ•DÁš”ÐÁ fÁ¥ÇdÁ«R¨Á°ûJÁ¶Ð³Á¼;IÁÁžïÁÆÅcÁËõÁÑ)ËÁÖ}ªÁÕ:ÁϯxÁÉö)ÁÄ9Á¾d#Á¸Ú—Á³€Á®Z—Á©](Á¤aÀÁŸ‡;Áš¿Á•óùÁ‘qÁ:Á‰€Á…`ÁSÁyÜkÁroÂÁkMÁd&×Á]-ñÁV‡£ÁPy²ÁKK‘ÁFy·ÁBu‚Á?L÷Á<‹PÁ:PÅÁ93Á8"AÁ7ž4Á7ÍJÁ8© Á:2­Á< !Á>ýëÁBs[ÁFþ‹ÁLK¾ÁQ–ôÁWà9Á^Û‘ÁfT‚ÁnÁwrtÁ€,fÁ„×Á‰°zÁŽ”¿Á“6Á—¨–Áœz]Á¡õÁ¦“îÁ«ÈLÁ°úÊÁ¶Y¯Á»ŠäÁÀ·ÁÅèÇÁË7ŽÁвNÁÏg ÁÉÐíÁÄeÁ¾±ÙÁ¸ÒÁ³sÁ­•,Á¨@ÌÁ£$RÁž(ùÁ™/zÁ”e Á™²ÁŠâÁ†yýÁ‚SVÁ|käÁtȶÁl"wÁdC Á]E¿ÁW>ÀÁRªÁMÏÁHõwÁDâFÁA0Á>JÁ;@òÁ8•~Á6¤)Á5ä%Á56àÁ5©ÚÁ6?Á6+ýÁ7@#Á9‘±Á=7„ÁAQšÁE&ÁJ†ÁOý¶ÁUp¸Á[3 ÁaòbÁh±sÁo¦uÁwršÁ’Áƒ¿þÁˆ 4ÁŒ‰5Á‘H¬Á–F3Á›UHÁ §Á¥¼qÁ«ãÁ°QrÁµzÏÁº©›Á¿ò¦ÁÅjzÁË QÁÉ×¢ÁÄùÁ¾ƒûÁ¹mÁ³o Á­ŒÁ§ÕìÁ¢QEÁ[Á—ñ/Á’ö8ÁŽøÁ‰K¨Á„x¬Á¶$Áw$½ÁnÞ?ÁfÐ'Á^¶BÁVYdÁNãCÁHm¥ÁCîÁ=ò²Á9‘™Á5œ|Á1¥gÁ.„ªÁ+°ÉÁ)óÁ'Á&%áÁ%’Á&&Á&£Á&¦ÿÁ'¸oÁ*@*Á.-XÁ1óbÁ5õÍÁ;7EÁAxQÁF‹dÁL¹ÁSÉ¿ÁZT×Áa»FÁiþGÁqºÂÁzAÁrPÁ†Á‹ÇÁžÁ•K¾Áš€¹ÁŸÓÝÁ¥HÁª@–Á¯lDÁ´¯*Áº#®Á¿ÅíÁÅ‚ÐÁÄsYÁ¾‹Á¸Ë*Á³7uÁ­Ô:Á¨.Á¢GŽÁœÎÁ—8Á‘ÈÔÁŒ¿ÒÁ‡Å>Á‚ÚrÁ|:gÁr¢}Ái¾lÁadmÁYÕÁQd*ÁH¾ÃÁ@ÂÁ9ÎÍÁ4ëÁ.âfÁ*6ÉÁ&Á"*BÁÿ Á&0ÁŽÂÁoGÁtÜÁïOÁ¢%ÁDâÁ(ÁI¦ÁåÁ}!ÁEL»ÁL6 ÁTMÁ\!ÎÁd+¶ÁlÌÁuì8Á´žÁ„ÜðÁŠ íÁH=Á””Á™ßuÁŸÚÁ¤0éÁ©mdÁ®ÞÁ´§Áº<(Á¿úÁ¿%âÁ¹+Á³?Á­}®Á§ësÁ¢(ÁœäƒÁ—ÉÁ‘MmÁ‹ÏyÁ†‘ôÁÁy-Áou%ÁeÌÄÁ\dNÁSưÁK¬çÁC„ßÁ;…Á2ñnÁ+oÁ%#SÁÞ€ÁûÞÁÁÉÁz_Á ›»Á ùèÁøBÁÕµÁO‰ÁKÁæ³ÁºÁü3Á WÁPÁOßÁ%ÁUNÁ#hËÁ)[µÁ0](Á6öŒÁ>d¯ÁFÃŒÁNeÁVËcÁ_±0ÁiSJÁsK±Á}zÁ„àÁ‰VÚÁާÁ“Ô,Á˜÷úÁž-±Á£šÁ©:¸Á®ö±Á´´cÁº Á¹ß‚Á³ã5Á­ãÏÁ§óƒÁ¢0˜Áœ Á—GwÁ‘—èÁ‹Ä3Á† ;Á€’£Áv¿rÁlÈÁbÕ·ÁYIjÁOj4ÁF²ÀÈ××ÀÁ}!À»Ÿ±À¶À³!~À±.TÀ¯¾ƒÀ²¯À´Ì ÀµCÀ¹^ÀÀSßÀÄ‚VÀÍŸ›ÀÚ¬²Àã Àð,ÍÀýÇhÁâ9ÁªÁºJÁ­ÞÁ&†©Á06Á:(ÁDÍ›ÁOXÄÁYývÁd{‚ÁnÅ ÁyRÁÚ‡Á‡w;Á0IÁ’íLÁ˜Ó€ÁžèÅÁ¥'çÁ«JgÁª~Á¤[œÁžc¾Á˜4ÇÁ’'ÏÁŒÔÁ†ßÁ€L½Áu†¦ÁjúÁ_m-ÁT-ÁHºÁ=ïÁÁ3Ü2Á)òsÁ B8Á¶Á ¹ÏÁ¹ýÀú‚ÀêTŠÀÙ¸ÜÀÊlÀ½aiÀ³à,ÀªVÀ¢­KÀœŠ‘À—À“|6À‘ýVÀ‘™œÀ“ìÀ—TêÀ˜ÇQÀ%îÀ¢ÒÀ¦òAÀ±pÀ½.ÀǤÀÔ øÀáºDÀðîÚÁ”hÁpÁxÁ÷²Á#ÆùÁ.QóÁ8æÓÁC‘fÁNÍÁXvþÁbŸùÁmAíÁxvåÁòíÁ‡¯“Á™öÁ“¶¦Á™ÿ§Á ÇÁ¥îûÁ¥¾ÁŸK1Á™ ÓÁ“#³ÁXÁ†ïPÁ€Ö´Áuœ¶ÁjðÁ^øôÁTn ÁHÛ¦Á=΋Á2[lÁ'§sÁ­©ÁʱÁ Ö¿ÀÿXÀí˜Àß ‡ÀÏÀ¾tÀ¯$…À p³À•]À‹ÕfÀ„lbÀzþÖÀpE©ÀgïÊÀeµÀgP»Àk÷Àu lÀz¯åÀµáÀ„€ÛÀŠx¨À•úþÀŸãˆÀ«ŸÀ·óßÀÆWÀÖ6TÀå¦_Àõ(BÁ¿LÁ ysÁáFÁ"uYÁ-&¯Á7ÁÆÁB9óÁLL’ÁVØWÁbZÁmr)ÁxêrÁ‚d\Áˆ‰‚ÁŽÛÁ”ÅÁš±gÁ ËÌÁ ýaÁšzbÁ”»ÁéuÁ‡æ[Á×DÁwvMÁk3^Á_>ÁSrüÁHo†Á=ç(Á2MòÁ'nßÁÏÁzkÁ˜VÀû‚ÿÀæ¹’ÀÒé¶ÀÂ`œÀµÀ£¬˜À“m À„é ÀnœÀ]5ÀL%À=^AÀ2«sÀ) ÑÀ'KÀ+ÝÀ2óÀ;{tÀCêƒÀKý±ÀP·àÀ_9wÀu™ÀƒDÀyÀ›ëûÀ«5À»y˜ÀÉìÂÀÛ‰Àî–yÁIÁ ŽÁ»÷Á!oÊÁ,Á6 <Á@{¢ÁK¢yÁW´Áb~zÁng›ÁzÅ[Áƒ·Á‰…ÅÁvÆÁ•˜ìÁ›æjÁœ- Á•×HÁ^ÁˆóÖÁ‚¶dÁyXåÁmdÁa>ÁTÁ‚ÁHŠ‹Á<äŠÁ1ëûÁ'gÁÅ»Áú+Áà¼ÀöÀ"ÀãUÜÀÏì£À¹ë-À¦ìÞÀ˜YrÀ‰8FÀp\XÀTWæÀ5+²À%SÀqTÀFé¿í&ÿ¿Ú•®¿ÖªU¿è N¿ómªÀ-¢À \ýÀ£ÀYÀ+LÀ;ëÅÀM¥ÀdøJÀ€v¥À‹ÉÀŸ¥YÀ¯.ÀÂnnÀÖxßÀë)®ÁQ@Á mÁÍÁåÏÁ*0ãÁ5L7Á@©¶ÁL"ÁX¹Ád…,ÁqÂÁ|“Á„?ÖÁŠjÕÁÃÂÁ—DÕÁ—‘þÁ‘ÆÁЦÞÁ„JÁ{£õÁo©ÁbíúÁW+­ÁJË,Á>Z¸Á2 kÁ&[ ÁpáÁñ2ÁEÉÀõ+;ÀߢÚÀÊŒÀ·ÐqÀ£cÀfÀwµCÀ`÷ÉÀ;¤ÀqÀ$¿Õ5ô¿¯AÅ¿•‰“¿‚;{¿fпdPÑ¿ŒÅÛ¿—Ó ¿Ÿ^쿪¨×¿»·$¿ÑJ3¿è$RÀL*Àš˜À,FÀI[$ÀknÀƒ®£À•µ—ÀªP À¾MêÀÓÆÞÀ逧ÀÿÔÝÁ ÝdÁ5Á ¼Á*]Á5Í´ÁAѤÁNIëÁZ¤ Áf"RÁr?Á~…—Á…¨ÆÁŒ8áÁ’íwÁ“@«ÁŒ„ÙÁ…ëæÁ~ø,ÁrwïÁermÁXÄ÷ÁLŽâÁ@æÛÁ4‘§Á(oÁ“·ÁØÉÁ‚ÀõÀݦMÀȘÀ³•&ÀžYMÀŒ&:Àn…ÀCÀ&E¢À %¬¿Ñ‡¿¤»¿q_í¿EHs¿/Jì¿*Û&¿#]t¿+¿¢|¿YM¿Vß®¿Tq¿¿ZÀ.¿iïr¿‚iÒ¿–fÜ¿À‘ª¿ìtÅÀZ¿À3B•ÀRÚ À}ÔoÀ‘‚ŠÀ¦á}À¼ÖÉÀÓË!Àç¶ÀûÏ4Áè-Á)«Á“"Á+§#Á8ÏÁD2SÁO¼ Á[Ã(ÁhEÁu/Á8ÂÁ‡ÿºÁŽâûÁŽú•ÁˆJ½ÁƒMÁu°ÒÁh±Á\·ÁOXéÁB‹¨Á6?ùÁ*‘äÁuSÁÂÇÁ+6ÀòéÀÝQ3ÀÈ~#À°ïéÀœiÀ‡¡ÑÀdÆHÀBZÒÀñ¿à Õ¿¹Ï¿z~X¿@ßÖ¿-¿»Ž¿šî¿Ê¿Úù¾õFf¾ùû;þ±3¿ éR¿J俬v¿" ¿*¢b¿1B)¿?ë©¿Šb–¿Ã\|¿ú1áÀ&ˆ¬ÀJ2_Àt=ÚÀH’À§×yÀ»ÅnÀÏŸŒÀåܘÀü+‚Á a Á„†Á!äöÁ-ÀÖÁ9b„ÁE{”ÁR&Á_%ïÁl‡ÁzDÁ„ƒÁŠì¬ÁŠbÇÁƒÑrÁz Ám—Á_¢7ÁR}'ÁEÃîÁ9`Á,m:Á ÁSÞÁ„_À÷IôÀݳÀÅû¸À°å]ÀœGÂÀ„—ÛÀb'[À8•À°¿á#¿•c\¿V*T¿<7·¿+ü—¿_¾ùzR¾çê5¾Ú,w¾Ñ&5¾×-æ¾ãoZ¾ï°Î¾èf¾Ù©¾ËKľÈïx¾êïð¿x4¿Ò#¿ I ¿SjC¿¨·Ò¿è‰À¿¸ÀGåžÀwJYÀûtÀ£oåÀ¹|µÀÏå¡Àæ^}ÀþÃÕÁ »ÂÁRÇÁ#MÁ/JÓÁ< ÁI>hÁVÔèÁd”'ÁrXbÁ€fÁ†ÚûÁ†øÁ~¦†Áq_3Ádq<ÁW;ÁI³öÁÁwÐYÁ‚Á¬Á‚1:Áv`†Áh mÁ[.ÁN6ÁA/³Á3ðÁ&m&ÁbØÁ ôúÁ¸kÀè#LÀЮ¡ÀºT?À ŠšÀ…¬*À[0ÐÀ5! ÀJP¿Äª¤¿‹Ð±¿Y‡Þ¿*ü¿ ™Æ¿Ü¿ûA¾â½©¾Û¾Û¾Ûq(¾Ó ľÍb¾ÙYÖ¾âQò¾Óô¡¾Êµ¾Í7V¾ÇJ¾·Ǿ§7¾¼…4¾Ôè"¾ïŽŒ¿ø¿4^¿™‡<¿í%AÀH›À@¢ÛÀm¼À›~À¦'RÀ½âÀÕ¥Àí`‡ÁW5ÁoÁúÏÁ+ÇÁ9KrÁFó;ÁTnYÁbëÁoå[Á~ÂÁ}OÙÁnã×Á`®ÁR»ÁE^Á7Õ1Á+ ;ÁÔ™Á«âÁk®Àí²bÀÕ·À½À¥T‘ÀñaÀnáÀ6ýÀÞ¿Í68¿HÛ¿cYð¿B^¿ªŠ¿ ßß¾þ*f¾èêz¾é‘¾é‚š¾ét¢¾ætD¾Þ¾Õ‹×¾ÔO¾ØI¾Ð@¾Ò•‚¾Õľ͊x¾½ õ¾±ï˾ªÚª¾¼âˆ¾Õ†[¿ðµ¿#µü¿0õø¿†J<¿ÔߎÀŠÀB’‡Às“uÀ‘ þÀ¨ƒõÀÁh³ÀÛfÀö3Á‰ÁWÁ#¸ÐÁ1((Á>¡›ÁLgÖÁZ{ÅÁhÏNÁvÔDÁwÁhCñÁY  ÁK0®Á=ÞÁ/#KÁ!©žÁ°HÁÅ$Àõd§ÀÛrðÀÁõ‚À©úýÀ’Àt-ãÀD{ûÀIö¿Ùþ™¿‹§¿`ßT¿Dú¿* /¿Ïd¿¸¾õg½¾öVB¾÷DǾ÷x¾÷j%¾ñS޾èßW¾àk!¾×öê¾Õql¾×ó®¾Úuð¾Üø2¾Ó„§¾Çö+¾Àá ¾¹Ëç¾²¶Æ¾½?Û¾á¾ôy‘¿¡(¿,Ñ*¿†Éd¿ØNÀ¦ÀI+­Àxr‹À– ÊÀ°ùeÀËÏQÀæv8Á˜ÕÁ þjÁXÙÁ)ŽÁ7ÍÁEW¤ÁS^}Áa8ìÁoWñÁq¼„Áb”2ÁS‹¨ÁDª-Á5ùXÁ'…öÁafÁ £ÀüÜCÀã×áÀÉ–À°$À—@À~–ÀO“ßÀV¿âƒª¿˜Í¿^nü¿¹¾Ö D¾ÍÓϾŞZ¾½;}¾´Â®¾¹Ñà¾æY¿¿g’¿sÒ¿:É}¿¥ÜàÀ¶QÀ4¹ÀiPÀ_BÀ©ðOÀÄ™Àà[±Àü{wÁ büÁ^>Á(ZmÁ6¦2ÁE4¥ÁSø ÁbæÁfîÄÁW¼,ÁH©‡Á9¾šÁ+ÌÁ%iÁ Ý›Àû‡JÀÝÔ‡ÀÀÞŸÀ¥ À‹©ÀeA¡À1aÀÿ¿¹,þ¿3¬¿MhÔ¿1¡¿Ì¿ Ä¿ Ð&¿ ÜJ¿ €Œ¿ Eê¿ H¿ Ð¥¿ Ó¿ 5¿³c¿_§¾øÂ¾îÄݾð7‚¾ïÂR¾ì†¾éIÒ¾æT¾âêÞ¾ÜòW¾Ô¼ã¾Ì~f¾Ä—¾»ŒÈ¾³W¾¼]Á¾Ûr¬¾ú‡—¿ ÎA¿[ˆw¿ÁUªÀV!ÀG–À|RŸÀ™u#ÀµVÂÀÑìÀíïÁä Á#Á!µ“Á0‡ Á?ˆØÁN°lÁ]߸Áb¦ÁRÕ•ÁCÌmÁ4{Á%J[ÁDÁÁx‹ÀñõÀÓîòÀµfLÀ—xìÀu1wÀ?uÀ¹¿Å =¿€Î(¿Srð¿7‹z¿±…¿ Æl¿ ³O¿ ¿s¿ Ë–¿E¿È¢¿Ž¿-¿ í¼¿Ët¿b£¿ùѾý!ÿ¾ö¤ö¾óh¶¾ð,v¾ìð5¾é³õ¾æ|#¾ãQ­¾à'7¾Û¥ö¾ÓH€¾Ì4·¾Å”¾¾ô̾µ–Ò¾Ê3¾éGì¿ ´}¿"3K¿† "¿åéÀ&n.À]RvÀЉÀ¦ï ÀÂîhÀß?÷ÀüqìÁ VÁ8ÏÁ+ZÁ:€ÎÁIÄÁY"jÁ]¶tÁN:­Á>Ô¸Á/ŠSÁ c`ÁjóÁ#÷ÀåõqÀÈ(ÝÀ«(0ÀoSÀb$]À&\Ç¿ÞÀª¿‘Û¿fùο? ¿#ª¿Rſ߿½¿PÌ¿ãú¿Ç¿K[¿AM¿ù¿ Â¥¿z³¿â¿©¾þ¢b¿{ú¾öp8¾ð–™¾íZY¾ê¾æâó¾ã¸|¾à޾Þl¾Þr^¾×Òi¾Ñ2t¾Ê’¾ÀøŽ¾¸óU¾Ø@¿{s¿Z¨¿7´Ï¿«GgÀ ‹âÀ@ÀlÀx ¨À˜GBÀµ”›ÀÓœdÀñÈtÁnÁKñÁ&¶Á6:ÁEÑÏÁUw°ÁZƒPÁJÉÁ;’Á+{-ÁïaÁ }¯Àú_ÀÜ)À¾ˆ#À ?‰À‚9`ÀJÔäÀwO¿Ç³¿od¿K$ð¿+¾S¿Õ´¿šÎ¿_ç¿!Ÿ¿´Î¿Gü¿Û+¿ʶ¿6¿ Öâ¿ ’Ä¿)ó¿Á!¿¬¿Êó¿¿¼<¾öð»¾íÄ|¾êˆ<¾çKü¾äK¾áG{¾âÆ„¾äEŒ¾ãp¾ÜÐ&¾Ö01¾ÌZI¾Á˜÷¾É‡4¾öªË¿*¼¿&<"¿vgð¿ÞtúÀ$\×À^ÝmÀ@ÕÀ«RùÀÉéÀèà„Á TÁ°2Á#UÂÁ2ûÚÁBªÁRd{ÁXsšÁHôÁ8±3Á(عÁyÁ CIÀóöÀÓÛÈÀ´àÀ–Q˜Àq À8bj¿ÿý¿›¹<¿T%Z¿:s¿¿$»›¿tV¿ÞP¿§ð¿m ¿п«ÿ¿S¿ºË¿"¿ «Ì¿ B¿Ù2¿À(¿‚o¿ D¶¿ „;¿@\¿ü~¾÷q?¾ì邾綾䆾åp’¾æï›¾èn£¾éí«¾èmؾáÍã¾×¼¾Ìc-¾½œ#¾Ò×§¾ì(¿U¿9¿¯ŠªÀõÀLz»À…3ÝÀ¤M¨ÀÃyÀâ»ùÁÕÁÝ{Á °FÁ0‹8Á@lLÁPRÁVË0ÁFåöÁ7eÁ'*ÔÁX$ÁÀï­ÃÀÐ2)À°’;À‘rÀcçxÀ&ÝA¿Úˆ0¿‚ž¿Xÿ%¿9´ ¿#ûû¿b¿ j\¿!ÔV¿"µ¿"z+¿"¿C+¿ªß¿”¿ €µ¿ ñC¿ w£¿ 9ê¿ ü1¿õ2¿iÄ¿ E±¿!Ÿ¾ÿû¾õ²ò¾ëj̾è›S¾éžé¾ë²¾ì—º¾îþï•˾ík•¾â…¾Ó={¾Ävq¾Ç©k¾áRí¿¡ã¿1q^¿›Þ€ÀòjÀB¦À€knÀŸÓEÀ¿cyÀÞñ»ÀþIÁÁÛZÁ ‡Á.pkÁ>HZÁN&zÁUÑLÁE߉Á5ðFÁ&ÁÞÁ5mÀ쪗ÀÌùÞÀ­a8Àð¹À]˜šÀ ©&¿Îü´¿vp-¿T·¿=Uæ¿#<[¿!Œn¿"öh¿$`b¿%Ê\¿'4V¿&Ë‹¿!3?¿›¿3ß¿Ìþ¿ –¢¿ ªÌ¿ L²¿ î—¿|¿2b¿ –¿qþ¿Mì¾öS²¾ó4î¾ñ½v¾ñûɾòÿ_¾ôõ¾õ‹¾ö !¾ó“–¾è/¾ÚɾËP¿¾¼¯í¾Ö$²¿þÞ¿(Æ­¿Œóa¿ûóUÀ:=wÀx4À› À»šÀÚÏòÀú™ÄÁ 7êÁ'4Á-“Á=?ÁM°ÁTñ\ÁDýìÁ5 ³Á%WÁ3ÀÁNKÀêàÀË8ÂÀ«²QÀŒbíÀZóµÀÝοÎS¿z3n¿WÔ¿7Va¿'5A¿#o·¿$ÝX¿&Jú¿'¸›¿(Ä&¿(׿%¨a¿ A€¿ÚŸ¿s¾¿†˜¿2Ø¿ è¿ ‰â¿+ǿͭ¿ æq¿Â^¿[ô¾ÿ»K¾ü¾®¾ûs޾úíµ¾û\?¾ü_Õ¾ýck¾ûU¤¾ñ»¾¾è!×¾ÛÞà¾Ïl¾ÂúZ¾Ý8²¿ ªe¿*¼¿†u¿õayÀ7ÉÕÀv]KÀšÂüÀº| ÀÚIÐÀú$eÁ ºÁø3Á,îÍÁ<æÿÁLàhÁUpÁE!­Á53šÁ%HýÁbòÁƒÀëWõÀËÃAÀ¬V(À+À\ä¦À!M‡¿Õß‚¿…ÕË¿Hï_¿:Îg¿,߃¿%1â¿&Ÿ„¿( %¿(’©¿(¿(¯¿(ß­¿$è?¿^¿}¿v¿"ϿϿ{N¿ Ç¿hø¿ 6Ñ¿Ÿ"¿ Ô¿¢…¿$7¿”Ó¿Qæ¿ù¿^[¿‹Ù¾ù}̾ïãæ¾æIÿ¾Üƒ¾ÏŽ?¾ÃÞS¾â´9¿_7¿0rÜ¿ŒZ¿û<ÜÀ:j‡Àx«ÆÀ›Ã×À»aûÀÛŠÀúè½Á `PÁPTÁ-CJÁ=8tÁM/MÁURNÁEc¶Á5x/Á%™Á®9ÁÒçÀìùÀÌ}%À­$(À޶À_ ?À$Xä¿ÞÁð¿ŠUÄ¿_.í¿FÛ¿2‰Å¿&ô¿(a¯¿(a,¿(]¡¿(Z¿(‡¿(·®¿(èW¿$(¿Á=¿f…¿Å¿¿¿kE¿…¿ÃÅ¿ âQ¿ d¿ å´¿ ge¿é¿oß¿,ò¿ê¿œ¿¬’¾÷¥ô¾î ¾är'¾ÚØ@¾Ï¯â¾Üîþ¾ûÇ2¿Dã¿9€X¿™éÀ¤ÀAÀ0üÀŸáÀ¾”ëÀÞ6ŠÀýã,Á˶Á«$Á.@Á>q&ÁNVkÁV©ŸÁFÖŒÁ7 HÁ'J Á•òÁóÀðÓŒÀÒÀ³¦!À•òLÀrÕ¢À:ÎÀQò¿¥Žv¿tÃ{¿\^¿F颿-6f¿(/¯¿(,$¿((™¿(.\¿(_¿(¯¿(ÀX¿(ÎÝ¿#gü¿ V{¿»¿®û¿$Ü¿>H¿Wµ¿)5¿(⿪“¿,E¿ ­ö¿ Jê¿ þ¿ Þ¥¿Ž'¿)©¾ø„±¾îp²¾ä\´¾ÚHµ¾Ù¢Ó¿ÎP¿ !Í¿Ù0¿W*K¿¼Y•À¾ÙÀNSÏÀ…6ÕÀ¤ÀÃ.õÀâŒÙÁýÒÁºÜÁ ~ûÁ0MÀÁ@$«ÁPáÁY-eÁIŒãÁ9üŸÁ* Á ZÁ ãjÀù®¢ÀÜ 7À¾HJÀŸ÷¦À‚u±ÀLusÀÅh¿ÊçF¿Š,§¿r5ó¿TÚï¿=ÚG¿/D(¿'÷¿'ó‘¿(]¿(7¿(g°¿(˜Y¿(É¿(»¿%Fr¿"`¿y‚¿’[¿/s¿5¿:·¿@Y¿ñ%¿rÖ¿%ö¿!5¿ з¿€8¿$x¾ùm5¾ï°?¾åœ@¾ß7]¾üóã¿°P¿(8¿AÛ¢¿{=¿ñú±À-suÀfÀïnÀ­2ÜÀÊøwÀéUEÁ ‘ÁŒŽÁ#&âÁ2Ó/ÁBÁRQÁ\Ó[ÁMyîÁ>;õÁ/ Á 1²ÁäÁâÀå´zÀÈ? À«ŒÀ¥Àfs\À1ŸËÀ? ¿¬:¿}}¿cžN¿N~(¿?è ¿1Qé¿'¾‰¿'Þ^¿(¿(k²¿)O¿)˜ì¿)t\¿'«Ð¿%¼Ó¿"ç•¿ ¿n¿;R¿@ô¿F—¿L9¿QÛ¿Cï¿cÅ¿F¿ ÂÈ¿rI¿G¾ùbÓ¾ð‡¾æÛÌ¿D7¿"z¿&ì¶¿9I¿m‘?¿Åu‚ÀóSÀIŽ@À€Ì³ÀœÀ¹’úÀÖ¿ÉÀôEÁÔÁÙÁ' ÄÁ6ceÁEÔÜÁU[VÁanÁRŒKÁCjýÁ4+ÝÁ%CÁ&6ÁzlÀò+"ÀÕ{À¸û6ÀtÈÀ‚žvÀQ1®À |ê¿ê…g¿ o¿sËÝ¿_"¿S÷Œ¿IŽ–¿5ˆG¿)1ž¿)È;¿*^Ø¿*õu¿+C¾¿)öŒ¿(I¡¿&Z£¿$k¦¿"|©¿ ˆ¿׿¬d¿Iñ¿ç~¿… ¿I¿°0¿ ØT¿ ´Ù¿dZ¿ܾùXq¾ñM~¿ Ÿ}¿¸„¿(ðh¿0ßô¿j7 ¿¶‹À×[À51Ài°sÀÀÇÀª÷®ÀÇa‘Àã‰ÜÁJeÁñ9Á ·Á,YÊÁ;AdÁJS×ÁYˆ;Áf˜8ÁWvÁHv=Á9¡IÁ+HÁ›JÁ5ÚÀÿ»›ÀãÕEÀÈnÀ­›pÀ“¨ Àuê‚ÀG[¿À†€¿éÓ¿¥PÛ¿‚¿scE¿Zݘ¿A—C¿6–ƒ¿,U¿,Qý¿,èš¿+Åî¿*x¼¿(çq¿&øt¿% w¿#z¿!™¿ ‡|¿% ¿•¿`"¿ý¯¿ᬿ‰+¿ {’¿£·¿ËÛ¿óÿ¿è<¿j¿—¿7[¦¿KÈ4¿pyd¿¹a°¿ÿ­GÀ-êÀ]Ð$À†QWÀ ÿÀ»0ïÀÖ_?Àñõ6Á9ÁaÀÁ#à”Á2‰ÁA8ÙÁOõÞÁ^ÇíÁkøÄÁ]4ÎÁNŸêÁ@9)Á1ʳÁ#jÂÁ\ïÁCÀóùSÀÙ8\À¿{ÓÀ¦ý·À-Àp,.ÀG¼IÀoI¿çÖk¿¦¥ø¿€÷"¿o¶þ¿Oçé¿E¦}¿;e¿1#¤¿-•O¿,H¿*úì¿)…B¿'–E¿%§H¿$/¿"ºW¿!¼J¿ ­¿;:¿ØÇ¿ÒÙ¿zX¿!Ö¿ Ñ¿Fõ¿Ÿé¿ ƒ‘¿ ¤^¿+¶¿5‡¿Vl¿qã0¿ºÛ+À‹‚À,l¢ÀU™YÀ‚®ßÀ›^ïÀ²Ö-ÀËÿµÀæÓIÁ Á¬²Áš;Á*Ü3Á9ÒÁGƒOÁV äÁdÌWÁrI¸ÁcãÜÁUmïÁG ~Á8ïÁ+[Á_ÁÙÁ±”ÀëÄ%ÀÓ‚[À»lzÀ¤8ÀˆÀoFÀEabÀ½b¿ëŒ¨¿­d濉™Í¿dè¿axˆ¿X«ú¿N—•¿7;¿.+}¿*#¿(9Þ¿&Å¿%PU¿#ãN¿"åO¿!çO¿ ³Þ¿Qk¿k…¿¿º‚¿ 憿îE¿Ñ쿵”¿B™9¿QRJ¿r~ñ¿ D¿Á‰ïÀŠÀ/2ÀV÷¤ÀªhÀ—OÀ®ý‚ÀÇâ’Àߦ¯Àøe€Á R‹ÁìÁ$‘ÈÁ2EQÁ@HtÁN‹lÁ\ÃêÁk-JÁyùÁj¹‹Á\’aÁN©ýÁ@Ü«Á3J'Á%ÞõÁâÚÁ .Á!>ÀçÿëÀÐÕ-À»ÙÛÀ£•>ÀŽ™Àp©¢ÀG¢À"¿l¿<Êó¿C¬]¿E£¿L®¿SË‘¿Fè¿F:\¿Pe ¿^z¥¿‰¼¿Ä7F¿ùà^ÀîÀCbîÀd†ÅÀƒ‹ À—Î:À¯…ÀÄ;®ÀÚDÀðSÔÁ"†Á|«ÁÐyÁ(ïùÁ5¥õÁBØ+ÁPkOÁ^pÁk¿ŸÁy›¤Á„ TÁzW‰ÁlÚÁ_Z&ÁRL&ÁEpúÁ9˜Á-­Á ÚDÁQØÁ ZÀüÝ7Àæü?ÀÐËÀ»u}À§`ûÀ”ÀXÀƒÎNÀiô)ÀG`˜À#×qÀ ’ë¿Ý~w¿´ˆN¿‘s·¿tò}¿hZ»¿aÿâ¿\f¬¿SOù¿i¾Ó¿pEð¿iŸç¿fž8¿tl'¿}-“¿x–ÿyë¿{SC¿b Å¿mÐë¿‚¹E¿«Uw¿ç¸‡À ÉÀ2¿mÀMiåÀrò¼ÀŒ÷ŒÀ®âÀ¯‘¿ÀÄ ÀÜ—ÀñÁ ÒÁ/DÁ,¯Á&¯Á3BAÁ?eƒÁKöÙÁXû¬Áf`´ÁtûÁ€Ù-Áˆ):ÁešÁuŠçÁh•íÁ[ÒÁOëÁCwnÁ7ZdÁ+×.Á ½Áä9Á âÊÀý‘ÀçÿÀÓ›ëÀÀ’WÀ¯ÌÀž(ÀŽëˆÀwÆÀZûoÀÞÁf]ÁYð³ÁMá¤ÁBbÚÁ7vÁ+e&Á VjÁ>)Á \Á"Àìà¬ÀÚÃÀÈ×÷À¹ DÀ§ËÀ–o€Àˆ¢pÀp¬óÀW…BÀ:ÜÀ&£À.À°o¿óÜ¿æ="¿èÌ ¿Ù’¿ÏU…¿ÍÈè¿ÛШ¿ÙžL¿ã(,¿ò¢MÀ8LÀ²À‹‹Àj‹À&À¤ÀÀ¢72À˜CEÀŒ”ÀƒfHÀw€?Àp#ÎÀjÀeÝ,À^/}ÀX-¡ÀX&tÀ_jÀ\GäÀbÀiËîÀwÈÀƒÚoÀ…æîÀ‹³À­¦À˜ºÀ¤À³ÑÀÂñ‹ÀÐ'îÀá,EÀó%¯ÁûßÁ §ÇÁØÁÓÁ'HŽÁ1cºÁÁ"¼Á%IÁ.†cÁ8#ùÁAf ÁJuÁTCÁ^w…Áiy¼ÁtÁÁ~LéÁ„ŠàÁŠ0 Á_Á–"Áœ\yÁ¥FšÁŸ\^Á™UýÁ“¬ÁßfÁˆ{ÚÁ‚ü¨Ázá ÁpVYÁfñÁ\VÉÁR½ÁHáóÁ?ÛDÁ7ÈSÁ/Á&ðÁ ÉÁÝŒÁ¬KÁ )ÁKÀûɵÀð¿¦ÀçÖÀÞ<"ÀØÐÀÓípÀÐ÷ÚÀ΂úÀËH*ÀÉV«ÀÉw¾ÀËcNÀËÀ͹3ÀÐÚrÀÖîÆÀÞjµÀ᩽ÀåCïÀ캬ÀóhÊÀü:sÁãÜÁ óFÁÑÁÂÎÁ!=Á)åðÁ2ØÁ;j’ÁDêçÁN9-ÁW§.Á`ÀOÁjwÁu³Á€ÃÁ…7çÁŠ_ÖÁÊrÁ•pzÁ›KtÁ¡U›ÂªáÂi‘7Áÿ·Áù9¤Áói\ÁíŸÂÁçæ.ÁâCòÁܤ—Á×"JÁÑdžÁÌ{ÁÇH^ÁÂFcÁ½yÁ¸ØÁ´JˆÁ¯ö‡Á«åÿÁ¨¿Á¤‡"Á¡+ÁžPÁ›&öÁ˜|¸Á–,UÁ”AZÁ’®ÓÁ‘A·Á6òÁq¨ÁŽÖÁŽªÁŽíŠÁcRÁæVÁ¿½Á’>Á“¼ñÁ•ØÞÁ˜ÆÁš¢XÁ…²Á ÁÈÁ¤>Á§ËCÁ«žÁ¯¸ÞÁ´¾Á¸²ðÁ½{ÁÂ]ÏÁÇjõÁÌ„ÁѺðÁ×)ÁܨÁâXŒÁè(`ÁîSÁóâÝÁùÊãÁÿÍÂõA â–=‡ðÁúöFÁôöÁïÓÁéO.Áã“QÁÝã5ÁØ=àÁÒ ¸ÁÍ)oÁÇÛëÁÂfÁ½{ÙÁ¸Ž”Á³ÙäÁ¯PñÁªßâÁ¦¯™Á¢ÈnÁŸ*/Á›¦§Á˜fÊÁ• Á’åíÁŠ/ÁŽƒ¹ÁŒßìÁ‹k"ÁŠBÁ‰}³Áˆá°Áˆ³ÚÁˆûoÁ‰q8Á‰ýÁŠßÅÁŒ6 Áü¥Á!qÁ’dÍÁ•'Á˜ÜÁ›[YÁžà2Á¢„ŠÁ¦vaÁª°íÁ¯-«Á³Ñ›Á¸—èÁ½“×Á°4ÁÇØ›ÁÍ-_ÁÒ­dÁØU]ÁÞcÁãéhÁéÍ9ÁïµðÁõ´‹Áûϰ¡ž ÂBÁý :Áöô/ÁðäÁêè_Áå ÁßP ÁÙŸ§ÁÓôcÁÎRÁÈÀ/ÁÃVÁ¾%Á¸ê)Á³ÜÞÁ¯âÁªpÁ¦‹Á¡³Á¬ÏÁ™ñ…Á–RµÁ’ôSÁó²ÁVÌÁ‹LÁˆÖ_Á‡eÁ…­/Á„wÁƒ¶RÁƒ%!Á‚õJÁƒ6%Áƒ¡oÁ„KýÁ…8Á†&ÁˆviÁŠ•ùÁŒå»Á¿Á’¶¹Á–OÁ™«ÒÁx¥Á¡Š Á¥Þ±ÁªXÞÁ¯Á³æjÁ¸ý±Á¾ÁÃcðÁÈÖþÁÎtšÁÔ-üÁÙñEÁßÒÚÁå¾TÁë¸YÁñÐIÁøöÁþF{³oÁÿ,„Áù ÁòøÅÁìèÁæè˜ÁàøÌÁÛ#>ÁÕjEÁÏ´ÍÁÊ ÁĆ.Á¿vÁ¹­ÿÁ´‚ªÁ¯hqÁªs$Á¥ºÅÁ¡D¢ÁœöúÁ˜Ð¿Á”÷¾Á‘=6Á¿êÁŠ¢qÁ‡ëbÁ…’/ÁƒY5ÁŠlÁ€$‡Á}ÑÒÁ|GhÁ{OöÁzìÁ{OÁ|Á}«AÁ¢ñÁEÁƒ-ÚÁ…?ìÁ‡¦~ÁŠn-Á~ýÁæÁ”¦ÍÁ˜¨ ÁœÏ¨Á¡·Á¥£ÁªlžÁ¯r6Á´” Á¹ÆëÁ¿*mÁÄ»pÁÊdÑÁÐYÁÕ÷—ÁÛæ=ÁáÜ<ÁçïÙÁî ’ÁôR‘Áú}ÂÛÁûoùÁõ7¦Áï½ÁéÁâõÁÝ€Á×'ÁÑ^ÐÁË¢“ÁÅêÁÁÀUåÁºáàÁµ2Á°8|Á«#@Á¦ »Á¡GþÁœ±~Á˜_æÁ”'«Á*°ÁŒi&ÁˆÐ¢Á…•·Á‚ÃÔÁ€^žÁ|A¼Áx}JÁu®2ÁsAPÁq¥¨ÁpÝ8Áp}ŸÁp®pÁqz Ás?=ÁubWÁxIOÁ| âÁ€.¬Á‚“Á…NHÁˆq Á‹ø%ÁÚÁ“üÁ˜$5Áœ†HÁ¡/ŒÁ¦Á«7&Á°]•Áµ®`Á»/[ÁÀÅgÁÆoÝÁÌAçÁÒ1ÁØ$™ÁÞ1¹ÁäZ‚Áêu>ÁðœáÁößBÁþ%úÁ÷ÞOÁñ—‚Áëb/ÁåF°Áß05ÁÙ$ÁÓ8§ÁÍpNÁÇ¿òÁÁþÁ¼LvÁ¶ÆÁ±k¥Á¬(¸Á¦þÁ¢KÁÁ˜elÁ“óƒÁBÁ‹|PÁ‡´ Á„+Á€Õ•Á{ÐïÁvÝÁrl|Án€JÁkšÁiOsÁg¢ÁfÇ•ÁfkãÁf£ìÁgzÙÁiU¹ÁkU¶Án$ÛÁqû ÁvoÙÁ{3÷Á€n Áƒ¯$Á‡UkÁ‹XkÁ~–Á“·’Á˜:EÁ4Á¢™Á§0†Á¬j×Á±×.Á·VQÁ¼ò Á¸‘ÁÈ£ÀÁΉdÁÔ…'ÁÚœ–Á้ÁæÝôÁí}Áó]›Áú¶ÍÁôhZÁî$Áçà‹Áá°;ÁÛ—ÁÕ€JÁÏzCÁÉ—qÁÃÛÁ¾2\Á¸€®Á²àýÁ­l;Á¨+CÁ£ sÁž³Á™ùÁ”?ùÁ§¾Á‹R@Á‡”Áƒ3ÁXWÁxÑ"ÁrÄçÁm ÎÁi=qÁe2Áb-YÁ_ëÁ^2‰Á\ùûÁ\¤Á]Á]æÆÁ_‰ÞÁa¥ZÁd’ýÁh·Álô¼Áqã|ÁwÂÁ~áÁƒÚÁ‡§Á‹E­Áš7Á”<úÁ™&!ÁžAøÁ£g Á¨»$Á® Á³ªCÁ¹bnÁ¿6FÁÄÿªÁÊïÁÑyÁ×"’ÁÝE>ÁãwÄÁé¯"Áïî¨Á÷TÁð÷—Áê²qÁäsAÁÞ?eÁØ!qÁÒòÁËú¤ÁÅý3ÁÀ%=ÁºrðÁ´È‹Á¯-€Á©¯,Á¤Q¦ÁŸ*~ÁšÁ•KÁKÊÁ‹–Á‡+¯Áƒ³Á~kÁvÊ-ÁpWHÁjtuÁe|Á`uçÁ\ªÁYm¶ÁV¹DÁTóVÁSÝyÁSnÁSðÁT¤…ÁV[]ÁX´ÙÁ[ÀüÁ_Õ]Ád.ÀÁiMÁoa‚ÁvZ Á~_Áƒ%ÛÁ‡K¯Á‹µöÁmCÁ•jZÁšƒYÁŸºéÁ¥"ÞÁªŸ¹Á°AÌÁµéWÁ»¤×ÁÁ‰ÁÇ“ÑÁ͵|ÁÓÖÁÙûÁà%(Áæ]ßÁì¬@ÁôqÁí¯ÑÁçV=ÁáÊÁÚáÁÔµdÁΨ¶ÁȶÁ¦Á¼³­Á¶éUÁ±=tÁ«”%Á¦ äÁ ¶èÁ›NÁ–m.Á‘_£ÁŒ…ÅÁ‡Û‚ÁƒSƒÁ~A8Ávt²ÁnÿÐÁhVºÁb™‘Á]2ÛÁXqÁT«ÁQkÁNHëÁLpAÁKgÁK'~ÁKŽŒÁL5GÁMþÁP›¤ÁSÆÓÁWßÁ\9BÁa…ÅÁgÎ7ÁnÐÒÁvhðÁ~yïÁƒmÁ‡óÜÁŒÉÖÁ‘Ñ Á–ëàÁœBÁ¡¶ÂÁ§<,Á¬ØØÁ²„Á¸Z¨Á¾YrÁÄxPÁÊzuÁЙÁÖæÁÜõÉÁãÓÁÇT¥Á͇½ÁÓ§oÁÙÚ†Áà*YÁæy`Áî2Áç¢gÁá@ÌÁÚâHÁÔ“ÁÎaÝÁÈE²ÁÂ0WÁ¼9^Á¶U]Á°x{ÁªÂ$Á¥1PÁŸ ÁšºÁ”±ÊÁ ›ÁŠÇ1Á…á*ÁÁyP•ÁpÌÁh·&ÁayüÁZÒ@ÁT=ûÁNƒ#ÁIØõÁEƶÁB¦±Á@4÷Á>SƒÁ=võÁ<ê-Á=#Á>E Á?Ò_ÁB[ÁE“}ÁIä ÁN·ÎÁSÿ›ÁZ%ëÁaAœÁhÃSÁpÒ°Áy¦?Á’ˆÁ†nýÁ‹{æÁµÂÁ–Á›…QÁ¡<Á¦ÆoÁ¬£¶Á²\ÅÁ¸>›Á¾HÁÄqÃÁÊy¼ÁУœÁÖìzÁÝ@÷ÁãwGÁëjåÁäâ¿ÁÞr%ÁØ”ÁÑÃôÁË}ÁÅU×Á¿IÉÁ¹EyÁ³\÷Á­‚Á§´ÈÁ¢þÁœ µÁ—#TÁ‘À2ÁŒ“ßÁ‡¬9Á‚Ü<Á|FÁsfrÁk„Ác ÇÁ[¨ÁT¤ºÁNNŽÁH|èÁC¹lÁ@íÁ<È“Á:åÁ8cÝÁ7(Á6èÁ7/Á8‡¹Á9Ï6Á<GÁ?ŒªÁCˆÁHœƒÁNLôÁT€Á[§”Ác_ÁkTŸÁtZþÁ}Ë‹ÁƒÁ=ÁˆÑ»Áø„Á“Z+Á˜ÝvÁžf‹Á¤ ÎÁ©´2Á¯‚úÁµ|yÁ»‹ÁÁ…gÁÇ£üÁÍÝZÁÔ$ðÁÚSÁà‡zÁèäDÁâZËÁÛÞÔÁÕv*ÁÏ&ÁÈÞ|Á¢¿Á¼ˆ‡Á¶3Á° íÁªÉÁ¤ú¶ÁŸCpÁ™À6Á”Z ÁŽÿÌÁ‰ÚpÁ„ëÖÁ€#þÁvÂsÁmŬÁeŒ£Á]Õ¦ÁVTÁOIpÁHõÁC†fÁ>´HÁ:ÿ-Á7¸úÁ4øÁ3@˜Á1üäÁ1ý#Á2< Á3‡Á4ë‹Á7MëÁ:O”Á>LÁC€¿ÁIUîÁOÛxÁVËbÁ^^|ÁfÍ—ÁoÔ¬Áy 'ÁlºÁ†a{Á‹—9ÁسÁ–8AÁ›È„Á¡_ÖÁ§¯Á¬ûòÁ²ê9Á¸ÓYÁ¾ÛâÁÄøvÁË-ÁÑYøÁׄqÁÝÌéÁå˜óÁߨ«ÁÙdÁÒþóÁÌ®ÁÆr>ÁÀ9ÄÁº AÁ³ÿpÁ®)Á¨96Á¢j²Áœ»mÁ—0¡Á‘ͲÁŒxbÁ‡A¸Á‚SBÁ{X Ár¸Ái‹Á`žÁXùÂÁQ…XÁJÃÁD–BÁ?>Á:ÝÿÁ6´•Á3`¿Á1!„Á/i6Á.$Á.®Á. éÁ.ÜÁ1¦Á3nýÁ67ëÁ:JÔÁ?6ÐÁDÑ4ÁK]ÁRDýÁZ †Áb}DÁk/EÁt‚6Á~2Á„ ÄÁ‰88ÁŽr‚Á“æFÁ™aáÁžøXÁ¤ÁtÁª” Á°d3Á¶HEÁ¼J¾ÁÂqåÁÈrÁλ_ÁÔùCÁÛTcÁà% ÁÚJ„ÁÔ“ÐÁÏçÁÉüÁÄ&Á½ÓfÁ·¯Á±”AÁ«Á¥µîÁŸñfÁšB@Á”ÅÅÁuÄÁŠ0üÁ…½Á€ ýÁv±;Ám¦QÁdÌêÁ\›[ÁU¹ÁMÐpÁFøaÁA*$Á<Á7qÌÁ3mÖÁ0#Á-ý!Á,)šÁ+KÖÁ*»Á+OÁ+ý«Á-©Á0KÁ3kÑÁ7L°Á;϶ÁA|AÁG±˜ÁN 9ÁVz>Á^¥€Ág`¿Ápp‹Áy÷»Á‚ éÁ‡-ÁŒe•Á‘˜ÂÁ— ¡Áœ´©Á¢‡ÌÁ¨6ûÁ­ùÁ³çèÁ¹ýÿÁÀ%ÑÁÆ3ûÁÌddÁÒ´ÁÙ«ÁÚÕ˜ÁÔÙmÁÎüIÁÉDÔÁö[Á¾TtÁ¹#Á´òÁ¯$XÁ©WÁ£iõÁ«2Á˜ ôÁ’ÕÁ,cÁˆeÁ‚çÛÁ|$ÁrÖ@Áiê6Áa+›ÁXýäÁQª(ÁJºáÁDÁÁ>v¼Á9WÁ4ÈÁ0ñïÁ.5%Á+æ½Á*yÁ)BæÁ(ÙÁ)ðÁ*+Á+{Á-Ù“Á1ÆÁ5žÁ9«AÁ?/vÁE‹ÁKÿ"ÁS·ŒÁ[Ì Ád6bÁm&3Áv fÁ€BxÁ…=QÁŠEúÁŒÙÁ•ÜÁšÊ&Á `EÁ¦¼Á«ÛÁ±ÛwÁ·õ±Á½÷ÁĺÁÊIÿÁÐ>ÁÖAÁÔøÇÁω ÁÉŽYÁîMÁ½öÁ¸i%Á³ ÇÁ­âKÁ¨ã±Á£è ÁŸ ØÁš¡Á•0jÁ—¦Á‹:IÁ†ÁÁx]VÁo?ÔÁfqbÁ]ø"ÁV%®ÁNóyÁH„ÁA³Á<,ªÁ7BòÁ2êuÁ/ =Á,ÌÞÁ*oïÁ)…Á(,¥Á'¤~Á'Ð!Á(½{Á*U>Á,T(Á/]œÁ3 gÁ7õ-Á=>!ÁBášÁI–ÄÁPÙ­ÁXÆÁa€DÁjf‡Ás“>Á}BºÁƒ„DÁˆ– ÁéÁ“e¶Á˜îÓÁžz“Á¤*-Á©ÿñÁ¯ø¹ÁµØÁº÷¡ÁÀ0ªÁÅsOÁÊÆ-ÁÐCèÁÏ@’ÁÉ©`ÁÄ<ëÁ¾CãÁ¸`™Á²§[Á­WÁ§Ä!Á¢£¼Á§žÁ˜¬áÁ“ÓøÁŽÍpÁŠÓÁ…ŸÉÁzÈÁzÂEÁrçHÁj÷iÁcJÁ[WœÁS¢;ÁL«ÁEïÑÁ@ Á:ÔïÁ6QÁ2™Á.ÉGÁ+î Á*#cÁ(¸»Á'ÒKÁ'uÞÁ'»ÐÁ(4CÁ)À2Á+üaÁ.ª¥Á2$þÁ6Œ‘Á;Ì„ÁAudÁG¼#ÁNŇÁV¼ Á_SkÁgê—Ápî´Áz‹ÆÁ‚7yÁ‡=tÁŒ“ÁÒdÁ•δÁšÔ„ÁŸùÁ¥,vÁª‹ÄÁ¯¶Á´êmÁº+­Á¿z˜ÁÄõÂÁÊ›×ÁɰÁÃðEÁ¾ZÁ¸ñNÁ²ú+Á­<Á§XñÁ¡ÐÁœ}¼Á—gŠÁ’kÄÁuÁˆ•þÁƒžÁ}êüÁuJ¯ÁmíÁdüÏÁ]GÁUÛÁMÄÁG ÁAŸ½ÁNÁ2»ÁëÁËžÁ dœÁ V§ÁrÕÁãqÁÔÁõ×Áf‰ÁtåÁ×½Áu×Á _Á ÕëÁøpÁûQÁ4<Á!võÁ'}|Á.ž×Á5ŒÁ<ˆ<ÁDÜÁLOÁU0½Á^yGÁh-JÁr:[Á|aÁƒ^ÂÁˆªÌÁÿÁ“ÕÁ˜XwÁ›íÁ£ Á¨²€Á®rÁ´4)ÁºpÁ¹_)Á³^“Á­‡GÁ§ÃûÁ¡ÿ_ÁœmÁ—±Á‘#*Á‹.Á…ožÁÞ¦ÁujüÁkl?ÁatrÁW؆ÁMèZÁDzjÁ;ë»Á3­Á+ÇHÁ#ÙúÁÉÁ¦éÁnÁ íÁ±øÁmªÀû£{Àõp/Àï³ÀêRTÀèk€Àæ˜LÀç©-Àè->Àè‹ÊÀëÅÀòÜÏÀû/ÁÁ®Á,×Á ,œÁˆöÁ$ ÁåMÁ&ÑÍÁ.ïÑÁ6ÆËÁ? ÁH(%ÁQµÒÁ[ÀiÁeà<Áp9ØÁzÃrÁ‚ÄÁ‡ÚÕÁÉÁ’S•Á—ÀaÁerÁ£%dÁ¨çcÁ®Ë.Á´ØzÁ´HmÁ®óÁ¨ØÁ¢:Áœu¾Á–¯Á‘Á‹ÊvÁ…ÞiÁÆÁtE‘ÁiM Á^ðzÁT÷ýÁKÁA™Á7–\Á.kNÁ&fÁÛòÁYvÁ Ë9ÁÀÿöØÀõÅÀìu¼ÀäW^ÀÜ}¾ÀÖ3ÎÀЉÀË aÀÈÈFÀÇHiÀÈžùÀÉpáÀÉr[ÀÌâ}ÀÔ°îÀÜzgÀå4·ÀñM Àü9<ÁØÛÁ ¸ÁbÛÁ÷ÙÁ!8”Á)]Á1ä®Á;H4ÁEF¥ÁOd“ÁY¸TÁd4+ÁoBÁy6±ÁÐWÁ‡ ’ÁŒt;Á’âÁ—Ø Á›Á£‚åÁ©–¨Á¯ÑØÁ¯Á©PÁ¢ØkÁœÌÁ–î>Á‘'ÔÁ‹^ÈÁ…Ð2Á€ƒ§Áu7”Ái2Á]­QÁR¾¥ÁH}Á>…UÁ4ŸÌÁ+8ÑÁ!ZHÁ†ÇÁBƒÁHùÁzÀïåUÀâøÀ׈FÀͦ+ÀÅÕ_À½hàÀ·ÜÀ±Q‰À«ûªÀ©E´À§ýùÀ©—DÀª´„Àªk_À®f^À¶ÔæÀ½Ë÷ÀÇZýÀÔYïÀÞ)ùÀë4Àø¹qÁ9?Á “»Á44Á´½Á$è‡Á.ÍÁ8ëCÁC9¶ÁM¨³ÁX“®Áb¾^ÁmùÁwŽ„Á(ÏÁ†ÌâÁŒŒ\Á’O{Á˜;ÍÁžVæÁ¤›‘ÁªÌÁ©ÿEÁ£ØÁ×^Á——ðÁ‘„sÁ‹¢¥Á…ÚQÁ€~Áu‰ÁjyÎÁ^·âÁR ¸ÁGöÁ<4¡Á2 ‚Á(íÁL¦ÁÜ-Á >œÁ¿óÀôóeÀæÞÀÔ›©ÀÄéHÀ¹TŽÀ¯)À§€Àž¢BÀ—ðÀ’#lÀ À‰ú/Àˆ¼»ÀŠÀ‹ø'À‹¾mÀ’EÀ˜îÀŸ)ÀªI—À¶ÀÀ›]ÀÎÇ\ÀÛ¬1Àë/ÀûPìÁ¢ ÁœÁSðÁ"r§Á,¿ Á7"sÁAÿÇÁLIoÁVqÁa¼Ák¼¥Áw-Á@ºÁ‡ ÁŒö/Á“®Á™iÁŸrÁ¥l{Á¥'ÁžÃfÁ˜“‹Á’¥ÁŒZÁ†>MÁ€WáÁu¤Ái|iÁ^i¦ÁSßÁH?›Á<Á0ƒ=Á%°ÇÁžîÁ§ÍÁÀý/iÀê«UÀÚ ÚÀÉÐúÀºÑÄÀ¨¾8À›9À‘rÀˆ9À€E\ÀqÍ_ÀfÀ\ŠŽÀV(DÀS³ÀW1`À[ ´À[§GÀg wÀtažÀ€úìÀŽ;ÓÀ—ÝðÀ£ó8À±ÉYÀ¿†ÀÐìªÀ߆ÀðÍÁÛÚÁ ú ÁJbÁ £œÁ+o9Á5ÕÁ@#ÁJ„½ÁU*&Á`npÁkëÐÁwu†Á²nÁ‡ß¡ÁŽ;bÁ”3wÁš%dÁ EÁ wÁ™îWÁ“ЦÁP÷Á‡GÁEÁuôÁj^Á^ÿÁRÛØÁGÐÁ=E0Á1¦gÁ%еÁóNÁ5þÁ5äÀö©ÀäFÀÐõ¸À¿bÛÀ®Æ1ÀŸ4`ÀŽ4™À{»cÀeþÚÀRÖëÀCÊ­À3º¶À'ñ/ÀèƒÀÌÀM;À}ZÀ jDÀ"òæÀ0¬ÛÀ6øOÀGßÀc2ÓÀt!ÿÀ‡³À•WÀ¤É@À´‡mÀĬpÀÖášÀëÜÀÿŽÔÁ /ÎÁã‹ÁaLÁ)±Á4æÁ>šÿÁIÜ+ÁUXPÁ`äcÁlâ#ÁyS5Áƒ„Áˆè3ÁŽßÂÁ•Á›[}Á›¿Á•_ÁŽÇÁˆUÌÁ‚ÅÁwý‡ÁkÑWÁ_pSÁS‹ÎÁGë)Á<;KÁ18BÁ&¬¬ÁØÁ ðÁiÀñ’®ÀݨPÀÉÔäÀ¸-²À¤ü"À”zŸÀƒOÞÀi´¸ÀDYØÀ*jµÀ½µÀ M¿êš×¿Ó:¿¿9s¿·o¿±û ¿¼ M¿Ï2ö¿ØP¿ò÷(¿õ“À3LÀ&ÓÀ;JÀV[:Àr±âÀŠX‡À™«ÀªD:À¾ÀÒ†ÌÀçŠåÀü¾±Áî«ÁK ÁmÁ(‹Á3MJÁ>Ç·ÁJV¶ÁVe¶Ábñ˜Áo¶—Á{;¯Áƒ›õÁ‰ÎJÁ.Á–µ¤Á— ºÁ’dÁŠ+Áƒ¦ëÁzKÅÁm§EÁapÁUnÿÁHóÁ<ÿÁ1VÐÁ%šÃÁ£ ÁÁeOÀñ*0ÀÙÐkÀÄàÀ°þ…À€À‹<ÀrsÑÀS\À0¨ïÀ,$¿àz¯¿²#A¿Ž]¿_-¿,B¶¿Fa¾é*Ù¾ì!ð¿P ¿8 ¿UŠ}¿uÓ¿Š´Ê¿±š‡¿×ÈÀ |À-ÙÀ>fÀ]ÃÀ|7®À‘4öÀ¥ÐÀº¶”ÀÏÎýÀäû}ÀùåÁ$ÿÁŒøÁÃGÁ(;0Á3ÍÌÁ?ñÊÁLRÁYBÁd©SÁpµÁ}0ëÁ…¡Á‹ž\Á’ZÁ’¿8ÁŒ ¥Á…k¨Á}ê¯ÁqUÁcø½ÁW5 ÁJæäÁ?QÁ2~ÚÁ&wÁÁÆÁúAÁ¹Àó ÀÛ‰šÀÄhµÀ¬ïÀÀ˜WÀ„ˆbÀcËÞÀ˜Ì‘>°s€>£>j°=Ø q=ë|ì=½½ê†¿¾§‚¿Ñd¿Hq¿•B¿ÐTûÀÜcÀ&>ÀI)3ÀpöÀâBÀ¢ø½À¸ŽÀÍ2áÀá–`Àö(Á@“Á´žÁK±Á)‰ÂÁ6MÉÁBŠÁNÁZ8>ÁfϘÁsÍ]Á€‘Á‡`cÁŽL¢ÁŽyßÁ‡³@Á€ûCÁt™Ág‰³ÁZÞLÁM¶ªÁ@ͦÁ4c”Á(”€ÁgÁø]Á:·Àð³”ÀÛ qÀÅèAÀ®H¶À—òûÀ€RúÀXPªÀ1'ŸÀœ¿Ç¸Å¿•f<¿óf½‡u>g]>œV¾>ÎÎ>ÝÒX>óÕµ?Þ‡?ƒÔ>Ôxi>Ó¿À>ÇNˆ>ºX%>«n>šªK=Œ¾”Š,¿I•¿£šy¿àŽZÀ4vÀBâÀlFÀ‹OAÀ ¡üÀµ ÀÉYÖÀß“5ÀönŒÁÓÌÁ3 Áþ…Á+÷×Á7"ÁCþÁP{ïÁ]¡Ák ÖÁxëÁƒeÜÁŠV¯ÁŠ3BÁƒ†ñÁyZ{ÁkÞ‘Á^nÆÁQ6gÁDhÁ7‹¸Á*ubÁè¤ÁùÁÃ5Àó ŸÀÛpFÀÃrËÀ® ãÀ˜Þ¡ÀÀXF+À(NÀp¿µ•&¿U쮾œh>A¾i>¥¸!>Äw?éx? ±‡?úk?w.?S?2^?¤? Öi??3º?¡;?¯I>ï^>ɶ=o‰¾Ð§)¿}Az¿ÐòÀ‡À=ðÀh±‹À‰5ÀœÍ«À²ÎjÀÉ’¬ÀàØ~ÀùÕÁ ¯©ÁiòÁ! AÁ-Z¸Á::ÛÁGŽÝÁUAÁc&ÁpþÇÁ~ߥÁ†GðÁ…ëîÁ~?7Ápò3Ácj,ÁUÏyÁHV­Á:õ´Á-ü´Á!lÁ3Áz@À÷ PÀߨÀÆMøÀ®Š5À–2HÀ<<ÀX¬À'Àa¶¿ Ê ¿6ß¾;>’…S>©g€>Ñ+f?àª? üª?ĸ?)Ñ?ÇŒ?Øy?·¿? —?ÚÚ? ƒ?L??"=S?=>ü~I>Ü‹>(i¢¾…³a¿bÆÝˆÀžÀ:vCÀaB?À†[ìÀœð À´BsÀÍKMÀæyÀýÅ^Á ŽkÁHÁ$ìÁ1 †Á?w¦ÁMT8Á[2Áhõ;Áv“_Á‚+†Áþ¶Áuõ¾Áh/QÁZ¶~ÁM†Á?ÑnÁ2ISÁ$Ï!Á¡<Á 3Àü$ÁÀâ?ÀÀÊlÀ³fÀ™ÞïÀãzÀQäÊÀ)¡¿þ¥ ¿š+‹¿-¯7=½ãã> ?9>³ ¥>×–²>÷†?GÍ?!?(?/?Wç?]Ú?= ?°£?ßL?œë?[Ê?g?$O©?*Ë!? æ2?ùM?>Û6›¾& 2¿bùŒ¿Æ]×À ÝÀ5jÀa•WÀ‡öSÀ Î\À¹¼°ÀÐ̰ÀèA½ÁÃÁ\ÁصÁ)°=Á7Š´ÁE^“ÁRúJÁ`©3ÁnÝÁ|БÁ|çýÁnu´Á`9rÁR>1ÁD‘ÑÁ7EûÁ)çcÁKÁÄ Á]ÑÀé%VÀÐQaÀµÐ‘À^SÀ‡x(À\7HÀ+¾=¿îÒ5¿¦Ej¿'Åß=¬U¶>rç>É_¹>äõ?E4? t"? [? &W? -R? ®'?èB?"^?Â?µ?íÕ?¬´?k“?P?!R’?&åê?*p{? ü?ŸÐ>îW>´¿6¾]Žê¿F¬9¿À ÑÀ sÀ7b6ÀhÚÀ:À£èÙÀ»—»ÀÕY±Àð“ÝÁÁëœÁ!Ã(Á/fbÁ=ÖÁJçÁYûÁg}ÊÁu–YÁv§ÁgÒ¨ÁY'!ÁJ¯&Á¾è¾S=Cÿ.>`(>¨Š£>á>ü«^?5?¾>?Fü?+•?2‘?>‚? xž?²¹?ìÔ?>¿?ýž?¼}?{\?9?âº?mK?"÷Ü?&‚m?6&? \)?>ë›#¾1(¿MÉ¿½¯‹À2ÍÀ@CÀnÜÀL¿À©¿KÀÅ1Àà»sÀüVgÁ Û‰ÁpZÁ'7=Á5[{ÁCÉÁQêåÁ_ÜTÁnÁp›(Áañ—ÁS ÁD#ÝÁ5h«Á&èÂÁµ¤Á æÝÀû;ÀàÖ>ÀÅ·°Àª³“ÀÚUÀnhjÀ=Þ·À A[¿½N ¿D;ݽÔrË>k‡¢>‡Å>Áì›>øÌT>ýí¿>üÿ:>üµ>û"0>úa¨>û)„?ÎÝ?ù? É×?Èt?ßb?ÍA?» ? ‹%?ß‹?j?aƒ?|=? –ø?$¸’? àÈ?ª ?¥ñ>ʾ½Éªž¿]ؼ¿Í„À­eÀG fÀ}l/À™ñÑÀµ\^ÀÐÅýÀëÚÁ“êÁªÁ [Á.J´Á<'_ÁJTâÁXÃaÁgf³Ájè&Á[ÝbÁL÷ÆÁ>@ Á/~éÁ ~FÁ®\Á"ªÀéð´ÀήþÀ´ü“À™ÐÁÀ~e~ÀHKÀ¿Ë?â¿U½½Ú»Ñ>KŠ0>«vŽ>ПÔ>ô.Ò>ó‚(>ñ÷m>ðl±>îáö>í¶h>ìÇã>ð^>ú[S?,F?*â? )? \q? JO? 8.? ŽÔ? 'x?Ò??ìù?´?"n?!S…?%í?"Sõ? Q>ïýî>À$¾Nø?¿t±¿é †À(”‡À]ÿ}ÀŠ'DÀ¥$ÀÀ-ÀÜ =ÀøýŽÁ ¾vÁzØÁ&žÌÁ5ÁCÃÁR¤éÁa­ìÁeûÁVÁŒÁGˆªÁ8bÁ)c`Á˜[Á ?ÀùÓ{ÀÛö À¾ºgÀ¢‡ÀˆÀ[ãÑÀ%·¾¿æàì¿€S ¾¯f7>@—°>Ñ‘>ìh€>ìP8>ì7ñ>êñü>égA>çÜ…>æQÊ>çÉF>í»Ý>ô€>ý¢?‹í?ŠŠ?Ù?‚? »¢? YÃ? ô?‰K?xo?“*?²?îx?"*à?&>?!2ü?¨†?Ãe>RŸ¿þ¿¥ªžÀêðÀ=fŸÀrþ&À•˜À²ÉÀε€Àé¼ïÁñéÁk]Á //Á/*’Á>PgÁM—LÁ\øfÁaiÙÁRßÁB¿=Á3‚ÃÁ$F‹Á ÑÁéìÀîßÀÐàGÀ²õ>À”®HÀneÀ6¬ÀÀ—¿›´^¾ÙÌu>(ÅÊ>Œ:°>Ãî™>äUé>䉿>äqž>äYW>ãì‹>âaÐ>à×>ã Ì>èt>î]_>õ/>ü¥?i$?¬1?JQ?èq? †‘? $±? À¨?Uä?ë? ?M?ÏI?D? o??%î?H\? ½æ>èU’=L¿Cò¿ÌšrÀ\¥ÀVï1ÀˆSÀ¢Î À¾±ÀÛ³GÀùpâÁ Ö­Á!¿Á*–Á:ÁI“ˆÁXõ^Á]FÁMÁãÁ>R(Á.üZÁ­6ÁaxÁ#™ÀãËyÀÅPøÀ§2~À‰íŽÀYè|Àµ/¿¾»ç¿,,ä=«bÌ>us->µO>Ù>‚>Ù´O>Úgˆ>ÛA+>ÜÍ>Übv>Û\_>ßxQ>ãöù>èu¡>îþà>õЃ>ü¢&?žE>þÍâ?ªÏ?³_? Q? ïŸ? A?"|?··?®Ø?°v?p?Pk? e?e?"è2?]¼>÷ø>Í$ç¾k¿“2À:ÉÀ8hËÀok³À”¼ûÀ²ÆéÀÑdaÀð]Á¼xÁ CÁ&{dÁ6aÁEŸéÁU@ùÁZSÁJN.Á:•fÁ*éÕÁO}Á Ì#ÀøÐ¾ÀÚcÀ¼jtÀ•TÀ}ÜgÀBLùÀ}¬¿¢ÖG¾”dh>J:A>¢~Y>Î8¤>ήq>Ï$>>ÏŸƒ>Ðy&>ÑRÉ>Ò,l>ÚB£>ßÎ>äM'>èξ>ï a>ör>ùÍ“>öI>óÅ¢>þM^?jŽ? n? ºŽ? X®? ï?YÑ?šM? ÚÉ?1—?’?ÑŒ?´3?Ü?AU?”½>ÚÉ>M±¿.¾Ø¿Ã7ÀÊßÀY,ëÀ‹ÛÑÀªnÀÉ'Àè8VÁ¸ÁV—Á"÷Á2žÁBT.ÁRÁX‡ÁH¾Á8*IÁ(EÁeŠÁ‹Àñ€2ÀÒðÀ²¶À“µ­Àj|À/¿v¿ãƇ¿NÝ?½2ãâ>‰?]>´¯¦>ÇØ>Ä:ã>Ä”.>Å û>ű">ÆŠÅ>É1ã>Ôbz>ß“>ä£U>ép@>ðAã>ò^œ>îÚ>ëU>è½a>óE>ýÌÛ?*L? n*? #œ? »­? EE? …Á? Æ=? ¹? ²¹?³?U?­=?!Â?2(? ]h> ¾Šh@¿œ¨·À -¦ÀIK^Àƒ¹{À¢ä½ÀÂ$eÀᔾÁ”DÁjÁ HDÁ0,’Á@yÁPìÁVV¤ÁFhÁ6|Á&”ùÁ²Á×!Àî ýÀÎQñÀ®ZþÀŽhÀ\ù¤ÀD¿¿»ìH¿E6>|Þ>‰*ö>¶.å>ÁöÀ>¿"Ì>¼N×>ºyê>ºï·>»ÂÀ>ÃQº>΂Q>Ù²è>äã>êÁ>êï¦>çk>ãæ‰>â>áð>ëZ>õ¢;>ÿêa?C? =V? ©x? '­? q5? ±±?ò-?2©? 3Ú?Ü‘?@?£›?ÉF?ô…>Õ°è¼–ô¦¿|YT¿ûî0À=iÀ} wÀž\°À¾7 ÀÝíuÀýX0ÁoåÁ?ÈÁ.vÁ=÷»ÁMÜÁUUTÁEYŽÁ5^…Á%dsÁkzÁrÅÀêô?ÀËóÀ«§À‹ [ÀV^Àˆ¿­ßA¾Èmù>$w>>´ÉÌ>¼Þ¨>º ´>·6À>´bË>±Ž×>²@ú>½q‘>È—¬>Óen>Þ30>æ´ð>æ©Ù>åf>ä"D>âÞy>áš®>ê¹V>õ|>ÿI¡?Èã?Y ?r?ùÎFÕ=ü~|¿[”ï¿ë]çÀ4×ðÀtMwÀ™òÁÀ¹ÏÃÀÙ·Àù¤¢Á Ë5ÁÅ‹Á,ÀïÁ<½ÁL¹ÞÁTomÁDqqÁ4sÏÁ$v¤ÁzÁ~ZÀé˜ÀÉñÀ©)¸À‰F´ÀRê‚À˜4¿©˜q¾°’â>B¡>eÇ›>°³>¹p>¶@.>³dë>°‰¨>®w©>®Që>´|k>¿J->Êï>Ôå±>ÜÕ>á|„>æ$>äë®>ã§ã>âd>ê–>ô`¼>ý/?Þ?”,?:f?}S?I?Ç6?Ek?I;?.? ã"?ý1?6S?ou?'O>â2‡>9†¿P09¿ç`üÀ3TîÀsõÀ™sÀ¹e¡ÀÙ\,ÀùU$Á §ÛÁ¥²Á,£ïÁ<¢xÁL¡<ÁT•ÁD“‹Á4•ªÁ$˜3Á›GÁŸÀéGòÀÉTÉÀ©fxÀ‰€aÀSSìÀî䌾à¿#>)ðÝ>‰€Æ>¥^Ž>µ—>²»×>¯à”>®Ú£>®á¹>®¡é>®@–>µü®>ÀÊp>˘2>Òõ>ל—>ÜD>àë—>äqN>ã-ƒ>éw×>ð¨Á>ó¥_>ö¡ü>ùž™>ú¾´>ûDŽ>ûÊg>û1Œ>üÐg?5'?? Ï?ì`?%‚?L.?7«>ܯ|>à5¿X²ð¿ë®öÀ5‚:Àu-¢ÀšqŒÀºPCÀÚ3ÀúæÁ çÁÿÁ,ùŒÁ<ôðÁLñ ÁT· ÁD»ßÁ4ÁÁ$È\ÁÐÁÚÚÀéÏÉÀÉòÀª!YÀŠfZÀU©À??¿¶ P¿ ¥p=íÚÍ>Y9>š >²Ã>¯7¤>¯=>¯D³>¯KÉ>®ñç>®”>®/B>·|ñ>ÂJ´>É*>ͼª>Òd*>× «>Û³+>àZ«>ä"e>ç>êŸ>í<>ðÙ>ñ>ñŽv>òP>ôµ6>þ?!?î? ºú?‡í?±?±?V—>¶” ¼œ3¿|Ä¿ûú•À<Ù¸À{ô%À´QÀ½z”ÀÝ@ÖÀý Áh…ÁR’Á.><Á>*ÁNÁVTÁF/ïÁ6V=Á&ƒßÁ»#ÁÿkÀÀÏcÀ°¿µÀ’uœÀj*ËÀ-¹h¿Ý¬ƒ¿J¡f= »r>6²>YEÀ>£R>¯ —>¯§­>¯®Ã>¯£8>¯Aå>®à“>®@>®/v>¸ý5>¿5=>Ãܾ>È„>>Í¢>ÓoB>ÙÛœA>Ý•B>à‘ß>ãŽ}>æ‹>çR…>çØ_>ì0>ôÑ>ý™?°Ã?ºÂ? ÄÂ?ÎÁ?ÙI>ôQK>ÑÜË>•¾±)¸¿¡»À zÄÀIk‚ÀƒR»À¢xÀÀÁåÐÀá{ÝÁމÁ_JÁ 00Á0Á?âßÁOÅÁX”äÁHè†Á9JtÁ)¾¡ÁJ‘Á ö1À÷šÀÙÃöÀ»WþÀœuÛÀ|EÀAº¬À?Ë¿œ*¾²ÙÕ=9[?>%q*>‚`Þ>Ÿ>°½>°Ó>¯ó6>¯‘ã>¯0‘>®Ï>>®më>¯¯¶>µ^€>»+§>ÀøÎ>ÆÅõ>Ì“>ÑÆ>Ó„‚>Õy>>×mù>Ú½>ÝZ>Ýœn>ãªø>ìKõ>ôìñ>ý£q??–?ü? $ü?YV?{>ÒSR>¬C9»ß"V¿P¨ú¿Û:‚À%À_ 2À6€À««úÀɼÀèB7Á‘ÁèÁ"ĦÁ2y”ÁB:ÃÁRqÁ\=bÁLØ·Á=ÈÁ.cZÁbµÁ)aÁÏwÀãFÑÀÅt¸À¨jHÀ‹ž­À]lÀ%3Ó¿ÜÙ¬¿fŽã¾úi=Ötò>B2:>|Š·>›qš>°‚ã>°C4>¯áá>¯$v>­÷<>¬Ê>­T>°¤B>´‚<>º¨>¿éÏ>Ŷö>Éx>ËlÂ>Ía~>ÏV:>ÑJö>Ó`}>Û%Ø>ãÆÕ>ìgÒ>õÏ>ý­Ó?DÇ?²¥? …6>ûa›>Ý¥>§¸å>n¿›c¿­áiÀ gÄÀB*±À{´ŒÀ™ü5À¶Ä3ÀÔ13Àò6hÁVæÁo‹Á&¬ÕÁ6 ‹ÁEƒáÁUAÁ`ú›ÁQîùÁB´ñÁ3fXÁ$9•Á8ùÁsOÀï÷ ÀÓ À¶îÀš À|ñ ÀFÊØÀHQ¿Æp¦¿L¦'¾"ϵ=î}ä>Ç>TS³>ºï>­˜Ÿ>¬ke>«>+>ªñ>©v>¬ô>¯h >³F›>·$•>»>¾àŠ>ÁÞ=>Ä£#>Çh >Ê,ï>ÌñÖ>ÓQ@>Ü>ä>¸>샰>õ$­>ýŪ?Iø?ù!>äÓB>¾‘h>D=À~ß¾Í_¿”iÆ¿ø]ŒÀ.ÀeºÀ$,À¨uÀÅ/3ÀáqfÀþðÁ §¨ÁˆáÁ+»Á:Ù¡ÁJ©ÁY>˜ÁeþÁVÐðÁGÄÉÁ8ášÁ*2"ÁÂŒÁ NßÀý©¼ÀညÀÅ¿+Àª…ÅÀâÀmu¬À=aâÀ U"¿Çˆ?¿Hbý·ÞT=$cé>bäj>‘†€>¦ Y>§Wà>¦*¦>¨r1>« ”>®,ÿ>² ù>µèó>¹Æî>¼Êd>¾ìô>Á±Ú>ÄvÀ>Ç;§>Ê>Ôé>ÞÐì>æø;>î§ò>öW©>þ`>ûJ¿>Þd>Àæ >ŒçÚ>Hä¾ÓE¿¿—‘‰¿çª|À#K§ÀV ÀƒŠ(ÀžD½À¹·™ÀÔcÀïÞÿÁ@'ÁrrÁ"¼Á1JÁ@ÁO 7Á^&WÁkbÁ\” ÁMóÆÁ?‰OÁ1µÁ"›ÈÁz`Á’#ÀñÈCÀÖâÀ¼Ï4À£ãŠÀ‹ÆÀg©kÀ=ÚEÀ ½¿¿‘¿I¾ 6\=oS>6'>fÍ>‡éf>œl?>¤Ón>§mÑ>ª4>¬ñ]>°ÏW>´­R>·že>º‡î>¼…>¾À‘>Á…w>ÄJ^>Ê=>Ôî’>ߟ•>é±¾>ñau>ôø>ç0Â>¹YÐ>ƒL >“ *>lq¾Ø‰e¿•má¿çÚ¿À¢ÿÀJ½FÀ|$„À—yÀ°QÈÀÊ^|Àåª@Á# Á ¨ªÁ¦Á)êÁ8'ÁFt6ÁTøÄÁc°3Áq¶ûÁcPÁTϱÁFbµÁ88UÁ*K«Á…dÁìAÁ­ÀéšHÀÑyÀ¸¦»À¡fÀŠ® Àf­À9ÕÀ É“¿ÅO ¿oÞœ¾Çª$½—ø}=ÏŠq>àr>e> þ>©Õ>«µ»>¯ˆß>²rg>µ[ð>¸7>º3>¼/ >¾”.>ÁY>Ë 8>Õ½;>àn>>Þ,¡>×Ó…>Ì” >¾Ì½>jßÿ>/ûò½¹_c¿2B&¿ž[¿êÁpÀ$ ÒÀM¥ËÀužGÀ‘EÀªYñÀÃîÈÀÝ1ùÀöÌëÁÅ©Á]ÚÁ#œ`Á1O7Á?]fÁMåÁ[áxÁj0áÁx’bÁj)¢Á[ù5ÁNkÁ@+Á2ŒÁ%ÈÁ ”Á DšÀþ9iÀ妘ÀÎ3¥À¶¢ÙÀ 2#À‰ðÔÀg?6À<ÉfÀH¿ã/á¿Ç?¿Eë½÷ÂÔ=_ïe=¸€‹>d÷º>ƒ×>“­Ò> bª>©@f>°/ñ>³z>µå>·á>¹Ý>»Ù>Á)Þ>»Úè>­Ÿú>Ÿe >¡Žy>¤êu>‰=É>}&o=ÅøÝ¾êÜ¿`‹ê¿¼ÈÀsÀ'ÑÈÀOÏ À}вÀ“)–À§/>À½Ê ÀÖ¿²ÀðqüÁ&Á´¨ÁÝúÁ,lðÁ9µÞÁG+éÁTûÆÁcÁqWQÁ»ÇÁq¿.ÁcÚòÁV-XÁH™XÁ;T¾Á.fWÁ!ÆCÁ²,Á [€Àû8µÀãGÀÌ·µÀ¶÷’À Þ À‹u¤Àn±©ÀJ:òÀ"\“À ¿¿ƒ¿…<õ¿ '¾àã¼,wE=罫>7 9>Yöb>yw™>ƒçY>Š4Ä>^]Ä>p©à>x{Æ>{¼Ñ>Vø!>V¾þ>A:ð>$Å>]<>YÁ->1ó8¾‘ô¿&e¾¿›¡Ó¿Þ«ÀÓÀ6uÁÀ[ïTÀ€ À• 2À«EÀ¿¯~ÀÓî¥Àê—ÁœÜÁ|YÁa Á(¯Á5ZÁBo¿ÁOéÁ],ùÁjÈ-Áx¬aÁƒÈ‰ÁyÎÒÁl4 Á^ÁñÁQ«“ÁDÌ Á8NbÁ,:JÁèzÁõÊÁéWÀùY’Àä ÉÀγÀ¸†•À¤ïÀ‘9"Àz ÀWå÷À6~7ÀП¿÷õ¿¯¡D¿|`8¿ >]¾Dµ=²§Î=å\%>ˆú>+p/=nð=> w=”^R=²,<8.ÿ¼aCÑ;S¡ù;‡Åô¾{€†¾–¾’¿qV¿‡¹H¿ÃA‡¿üáøÀ(%ÀEIÀk¥ÒÀ‡\­ÀšÈ:À­fÍÀÂYRÀØgºÀìP{ÁmÇÁ ÄÉÁó Á$ÁÁ1º»Á>u¬ÁKT?ÁXŒ¸Áf–ÁsJuÁ€\sÁ‡ê¨Á#ñÁu|Áh>Á[=ÄÁNÚÛÁB­¦Á6xvÁ*[ ÁYWÁ Áˆ+Àû]íÀå˜ÀÑÙÀ½µÀ©†UÀ–Õ›À‡RÜÀjJÀO¥øÀ/«)ÀÀ¿è'Í¿¾ 꿃ؿSª!¿#5Ì¿ÂC¾øI¿¾ªøâ¾^¾\E8¾¿ê£¾˜Bµ¾Å4ñ¿%¿ODZ¿Ž¢)¿†GÆ¿¢+œ¿Â#=¿ùÁ{Àz•À6ÀWí—À}ѲÀ6À¡÷BÀ³»”ÀÇÀÚk¶Àï’¥Á´­Á gÁðÕÁ"HøÁ.\jÁ;æÁHgÁTÜ>Áa¤{Án¼–Á|öÁ„¿ÁŒ9Á…§¿Á~e®Áq·YÁejfÁY(×ÁM Á@È7Á4ÕuÁ)þÁùÁO;Á Z?ÀþõÀêgöÀÖPŸÀµ:À²Ÿ¿À¡aÀ‘ .À„¤ÀfiÂÀJc%À/+)À¾'À²)¿â™T¿Ë[ˆ¿¾ã}¿²¼Ü¿¥ìZ¿™„ ¿š ¿­y«¿¡Vp¿­±¿Ã;L¿àás¿þ'X¿ý[Àä¼ÀÁ,À4ˆWÀRÌÀmÀ†}CÀ˜÷éÀ©ý>À»é~ÀÍÈÈÀàt×Àó¯ÁºQÁf ÁàÁ"ë‡Á-{”Á8ÔÁDÒoÁQZÁ^J,Ák=\Áwý¸Á‚}DÁ‰»ÁÕÁŠeÙÁ„hÁ{ü/Áo©ªÁc{zÁW<óÁKY­Á@€Á5oËÁ*ï˜Áí«Á— Á ŽHÁ–ŒÀïÎÀݨÀ͆À»ìuÀ­ÆÀž¿¸ÀMŽÀ.Àk›^ÀU)FÀ@ ­À/ɬÀ"®¤À„Àa<À=À xÀ "nÀ|WÀÀM5ÀÕ¢À-«cÀ:*§À<–ÀL@óÀ[ë¥ÀoŒ\À…Œ.À“o"À¡VÀ²• ÀÆ üÀÕøÀèÖÒÀùð¡Á¦|Á9ËÁD{Á%ÈÁ/y­Á9båÁD ]ÁOcéÁ[Q6Ág¼NÁt’Á€ÍBÁ‡.ÞÁ¡ŸÁ•?Á]dÁ‰GÔÁƒUÁyôXÁm¹þÁaã‘ÁV—ÁKê•ÁA~ÅÁ6„]Á,(úÁ!ó;Á ¯Á á9Á²ãÀùÉßÀç²çÀØÀÊY¨Àº‚WÀ«·çÀžlÀ”!uÀ‡kþÀ|}XÀmx!À_¹lÀXVÀSšÐÀN/ÈÀL6BÀMWÀSÀO›¸ÀUÔÀ]:_ÀjÁ?ÀwZ¥ÀzÌ!ÀƒÅîÀŒØÀ• ¿À¡ÌûÀ°å>À½HÀÍ+\Àß$ ÀñuiÁ1ÏÁ `åÁ6ýÁõÁ&ª÷Á0ÓjÁ;Ÿ‹ÁEÜ›ÁOã6ÁZž¡Áe÷ÁqÖNÁ~)’Á…paÁ‹ñWÁ’a5Áš¡!Á”„ ÁŽ[UÁˆ7¾Á‚šÁxq˜Ám$HÁbh-ÁWÿ¼ÁM>ÁB±cÁ8f½Á.ÔÁ$JÊÁÉvÁjäÁ ùÕÁ~ÀôˆhÀåì]ÀÖ«ÀÈ,!À¼‡sÀ°ÄšÀ¥&†ÀœéeÀ•¢ZÀŽrEÀЦ³Àˆ‡½À†CxÀ…ú¨À†t Àˆ«ÏÀ‡švÀŠ­€ÀŽ$À“ðáÀš²ØÀœë¤À¢&¶À¬àÀ³øýÀ¿óÀÌôëÀÚmÀè·Àù‚¹Á÷jÁ˜&Á‡<Á \$Á)—Á3s”Á=%áÁGe~ÁR:NÁ\A½ÁfiÚÁq4fÁ|ŒŽÁ„0 ÁŠOšÁžÁ—mÁŸÀËÁ™š{Á“v0ÁbŽÁ‡\ÁÚ<Áxê0Án‚1Ác·©ÁY9ÐÁNäÁD÷ôÁ:Á¢Á1ìÁ(9øÁ > Á`¯ÁŸÁvÁçæÀò¸ÖÀåiòÀÚ¶ùÀÍ{§ÀÃs.À»³ÓÀ´PËÀ­mÀ©œºÀ§œáÀ¥¼ùÀ¥Ú.À¦e”À¨UÀ§jÓÀªpóÀ­Ì*À²ÚÐÀ¹ŽðÀ¼|±ÀÁ ÖÀÊ^ÀÒËcÀÜÙ‘ÀéXÍÀ÷®äÁ‰Á èÓÁújÁm×Á$ª]Á-ðÁ6ÔÁ?ùÁIÍ‘ÁS§kÁ]ùÂÁhË}Ár°„Á|õ"ÁƒæÁ‰‘ôÁv¾Á•¨Á›ÐÒÁ¤Ú3ÁžµYÁ˜¨UÁ’ËÁ#¥Á‡¸¥Á‚‚áÁzS3ÁoÂnÁehTÁ[qtÁQ>GÁGSšÁ>:Á6•Á-fTÁ%9õÁÇŽÁ‘;ÁãÐÁ¡]Á¥vÀ÷„ Àê÷áÀâ!9ÀÚ—þÀÒðÏÀËä€ÀÈáhÀÆü}ÀÅaµÀʵÀÆV\ÀǶ+ÀÇ='ÀÊ4fÀÍuUÀÒ¡ÀØK(ÀÜFÀàCËÀèVÃÀñÖ,ÀúÉ‘Á;ÏÁ 8dÁ‡ÂÁœ¢Áü<Á):Á2EoÁ:Þ¦ÁCãýÁL¾×ÁVmÁ`4hÁj+FÁtšÁVbÁ„“âÁ‰ÁõÁ2‰Á”ÞVÁš¾×Á ÎFÂ"©ÂsÁûÿóÁö´Áð$(ÁêGàÁäyHÁÞÌ›ÁÙ1<ÁÓœ6ÁÎ+yÁÈÎøÁÄÁ¾h¹Á¹ÀÁ´ÇùÁ° YÁ«±zÁ§†nÁ£ çÁŸà­Áœ^ðÁ™3±Á–N%Á“ˆøÁ‘$aÁ(%Á†¤ÁŒ jÁŠÿ'ÁŠOØÁ‰Á_Á‰“ÓÁ‰ÀÁŠ!iÁŠÉ/Á‹«ëÁ@ÁŽÄXÁòTÁ“GqÁ•áÕÁ˜Ü.Áœ0³ÁŸªXÁ£I¥Á§6ÖÁ«l£Á¯åÖÁ´mÁ¹‰èÁ¾Š@Áß7ÁÈÅ–ÁÎ9ÁÓŽ>ÁÙ0\ÁÞ÷ˆÁäÙ Áê¹~Áð™BÁö’VÁü¨ÂlÂ(ÂÿÚÁýà­Á÷Ç{Áñµ,Á뾩Áåä£Áà~ÁÚNÁÔ¦«ÁÏ®ÁÉvºÁÄ_Á¾ÀáÁ¹„¡Á´{¨Á¯« Á«Á¦ypÁ¢,Áž(eÁšo5Á–ÞZÁ“’uÁœsÁÍ¥Á‹OáÁ‰>Á‡—ÓÁ†[Á„ýjÁ„53Áƒ’<ÁƒbŒÁƒ§Á„sÁ„§Á…’ÓÁ†öŠÁˆÎ—Á‹\Á]rÁ4Á“+¤Á–™üÁš‡ÁÜbÁ¡ëGÁ¦CkÁªß8Á¯­ Á´–¡Á¹§¤Á¾ÂSÁÄÈÁÉqŠÁÏ õÁÔ˪ÁÚ£ØÁà‚%ÁædnÁìZ9ÁònÁøÓÁþÚŠÂÁÿìVÁùÊpÁó²/Áí”_Áç‚ÏÁáíÁÛ½ÁÁÕû‘ÁÐAÿÁÊ›«ÁÄøHÁ¿rÀÁºòÁ´ØÙÁ¯®ÁªºÏÁ¦zÁ¡y´Á [Á˜å<Á•Á‘/ÁŽ ÚÁŠðÊÁˆ/WÁ…³¿Áƒ‡šÁÈÁ€KoÁ~^Á|wØÁ{/KÁzË_Á{d#Á|S½Á}q¾Á_Á#yÁƒ‚Á…C‚Á‡ªCÁŠ|–Á´JÁ‘4oÁ”ǶÁ˜©ÁœÚtÁ¡TãÁ¥ü0ÁªÆÁÁ¯É­Á´åâÁºýÁ¿wEÁÅÁʾ¬ÁЊÝÁÖdÁÜJ¼Áâ<ÈÁèMÞÁî|'Áô»­ÁúüåÂ8Áûñ£Áõ¼˜Áï¢aÁé’LÁãx;ÁÝl;Á×~Áѳ%ÁÌcÁÆP°ÁÀª¢Á»MÁµ•ÓÁ°N?Á«{Á¦²Á¡.4Áœ–òÁ˜)kÁ“àüÁéÁŒ:×Áˆ¨VÁ…lqÁ‚™©Á€. Á{ÍkÁx5ÁueÁr}=ÁpÝSÁo²îÁoJ6ÁoÐûÁp´aÁrVÁt®ÁwÁ{ Áh¬Á‚5Á…% Áˆn…Á‹ôNÁ²1Á“µíÁ˜oÁœÁ¡)NÁ¦öÁ«/NÁ°T Áµ¥Á»'ÁÀÔ•ÁÆ’lÁÌc¢ÁÒMßÁØ=ÂÁÞJûÁävãÁê¸Áðñ‡Á÷5$Áþg`Áø ™ÁñÚ½Áë§/ÁåŽ)Áß{MÁÙo>ÁÓtÁÍbÁÇÊ Á²Á¼fïÁ¶ÓÁ±N½Á«æ­Á¦²¡Á¡–ÙÁœš]Á—ß³Á“l÷Á"2Á‹µÁ‡:pÁƒˆ/Á€+3Ázt6Áux]ÁpãûÁlñJÁiûÞÁghuÁe·”ÁdÀ£ÁdSÚÁdµ"ÁeæÁg4VÁiU^Ál‚—Áp‚ãÁtÔZÁzlÁä¨Áƒ7pÁ†àôÁŠØÁŽüÁ“A©Á—ÇÜÁœ•LÁ¡¢›Á¦ÄtÁ¬ïÁ±t(Á·éÁ¼¿ÆÁ‡ÌÁÈqïÁÎa“ÁÔi”ÁÚ‘òÁàÏlÁæòÁí1xÁó…@ÁúÃÏÁônÁî&ÔÁçàÆÁᯤÁÛ—„ÁÕ‚tÁÏ|†ÁÉ•GÁÃÂ[Á¾Á¸GmÁ²¡:Á­$ÛÁ§½lÁ¢m~ÁQÁ˜NÙÁ“qÁŽÛoÁŠOÁ†XgÁ‚k»Á}f×ÁvkMÁpJúÁkÁfmÁbr Á_cÔÁ\î>Á[(«ÁZ]¯ÁYüKÁZ#ÏÁ[Á\éOÁ_$ Áb@DÁf@ÇÁj¿ÁoÎ Áu¹_Á|…Á‚ÏÁ†,‚ÁŠRWÁŽ®DÁ“XsÁ˜IµÁjTÁ¢–Á§ôúÁ­€zÁ³Á¸Ö¥Á¾¼ ÁÄ­cÁÊ®%ÁÐÎÁÖðnÁÝŸÁãMÁé™âÁïéÉÁ÷J„ÁðçýÁê“ùÁäLÎÁÞ¦Á×ÚÁÑ©ÁˬÁŬÁÁ¿ÒXÁºhÁ´b’Á®¤‚Á© ÃÁ£§yÁžbÁ™4HÁ”4©ÁOÁŠ”VÁ†$xÁÎ'Á{vÝÁtnÁm)¼ÁfËlÁaapÁ\Ø0ÁXŸeÁUm/ÁSOÁQJÔÁPOÅÁOëDÁP:-ÁQ'"ÁS–ÁU¿ÁX.ôÁ\[Á`Ö8Áf‰Ál1šÁsA„Á{#äÁ¸&Á…ë*ÁŠjšÁ8]Á”IÂÁ™kÇÁž²ÕÁ¤%ŒÁ©¨ûÁ¯WBÁµ2aÁ»HÁÁEÁÇòÁÍ3öÁÓSÁÙŠìÁßÌÓÁæ‡Áì`«Áóé–Á퀅Áç"\ÁàØAÁÚ“$ÁÔSÁÎ+kÁÈ“ÁÁÿæÁ¼6Á¶8kÁ°ŒÁªß Á¥7 ÁŸ²iÁšd`Á•F®Á74Á‹KåÁ†qÁÙôÁ{¼ÁrÅbÁk!sÁdUúÁ^ ÁXiTÁSËèÁO‘ ÁL;_ÁIÆÁGì=ÁF¬8ÁF5êÁFÉÍÁG’ÃÁIYKÁK˜=ÁNÕÛÁSÁW’Á\û1ÁcdÁj·ØÁrÕÝÁ{ —ÁÛÈÁ†{ëÁ‹h\Á…¹Á•¯çÁ› Á uýÁ¦+Á«ÞÓÁ±œtÁ·z^Á½€AÁßÔÁÉÀwÁÏîVÁÖ#/ÁÜ^‰Áâ¬mÁèüTÁð}Áê,gÁã½öÁÝe^Á×#bÁÐåsÁʹÁÄ¥Á¾“*Á¸‚ÿÁ²•ãÁ¬Ó”Á§)Á¡ƒ¤Áœ#Á–œÿÁ‘jÐÁŒYéÁ‡WÁ‚Š«Á{°lÁré«ÁjÃ*Ábð¸Á[ê6ÁUÒýÁPGsÁK/ÁFàçÁC®_Á@ÓÁ>Ù Á=ÒjÁ=[Á=ÕñÁ>¨Á@vÁBõÁFVÛÁJ‘ÁO ´ÁTÀÇÁ[g?ÁbåÊÁjî’Ás.×Á{îEÁ‚®]Á‡°ËÁŒÇêÁ’ ÛÁ—‚¤ÁûÁ¢¬]Á¨QÏÁ®!ÅÁ´´Áº:@ÁÀZÁÆ{ÃÁÌ¡úÁÒÓªÁÙiÁßoNÁåÉ‚ÁínÁæôÁà‡©ÁÚ\ÁÓÈGÁÍçÁÇZsÁÁ7—Á»8¡Áµ@®Á¯=œÁ©^2Á£©ÇÁÿSÁ˜gSÁ“3ÁÔÁˆÁ|Áƒ²ÙÁ}¨…ÁthÁkjfÁc#XÁ[ŠuÁTXÁNÁHŠ ÁC9ZÁ>¹ Á;y·Á8ÅÁ6µ$Á5ÜÄÁ5{†Á5ÓÌÁ6‚[Á8€ïÁ;APÁ>Ë‘ÁBì7ÁGœ¾ÁMmìÁT ¢Á[^SÁcQîÁk–Át™öÁ~MëÁ„)-Á‰KÎÁŽ«áÁ”>Á™­tÁŸJ-Á¥HÁªôÞÁ± ¥Á·ŽÁ½åÁÃFÍÁÉt×ÁϲôÁÖ—ÁÜTÂÁâŽÍÁêyïÁãêlÁÝršÁ× HÁШÁÊX8ÁÄ&ªÁ¾tÁ·ç®Á±ó:Á¬ Á¦)ƒÁ i+ÁšÁeÁ•·Á›OÁŠZuÁ…\ÁÁ€n–ÁvéÁm’ÂÁdÁLÁ\DaÁTšÑÁM¯ ÁGõÁA ZÁ<ØÁ7š&Á4<Á1½Á/¦ Á.ä–Á.jŽÁ.¡ØÁ/Œ³Á1cNÁ3çÙÁ7ª¹Á<£ÁA€ÁFŽpÁMÁT”‰Á\ZëÁdÚBÁnƒÁwézÁ€ðåÁ†-ïÁ‹€mÁù‹Á–Áœ8íÁ¢ÝÁ¨áÁ­Þ4Á³å­ÁºÑÁÀ1gÁÆZ™Á̤DÁÒÿÁÙ2ÖÁß‚ŒÁç°½Áá*ÁÚ’(ÁÔ¡ÁÍ¿üÁÇd[ÁÁËÁºô¤Á´ÞÖÁ®ÔDÁ¨ëáÁ£ üÁA‘Á—ªDÁ’%LÁŒŽvÁ‡/GÁ‚SÁzvPÁpÌÎÁgkMÁ^ üÁVXØÁN}ÊÁGtHÁ@Ï­Á:˜Á5w=Á1|ŒÁ.ØÁ+a'Á)™ÛÁ(ZÝÁ'ôEÁ(8ýÁ)£æÁ*ó„Á-pèÁ1,?Á5xÙÁ:¼ŸÁ@v ÁG5çÁN|'ÁVVÀÁ_ËÁhWÁr"Á|BàÁƒMÖÁˆ£"ÁŽ,âÁ“ÀuÁ™~ŒÁŸ/Á¤ùIÁªñ:Á±6Á·÷Á½4[ÁÃu„ÁÉÊúÁÐÁÖ<$ÁÜŽ}Áå ÁÞ~¸Á×ò2ÁÑk£ÁÊþ`ÁÄ©tÁ¾YYÁ¸ÆÁ²,Á«þ•Á¦CÁ -ÁšXiÁ”¦†Á*WÁ‰½ÈÁ„_¾Á~kÐÁt˜iÁkEÁa”äÁXåJÁPñÁI'ÁAÒðÁ; ÿÁ5; Á0 Á,µÁ(Ù£Á%ÓÀÁ$ ‰Á"·ŽÁ"¤ Á"öPÁ$Á%¯qÁ(9‘Á+~ÆÁ/ÑbÁ5fÿÁ;k©ÁB5`ÁISÝÁQ`ÁZIïÁcŒ Ám:úÁw2›Á€Á6Á†.}Á‹†Á‘ìÁ–²Áœd|Á¢HDÁ¨UªÁ®<¤Á´LêÁºxRÁÀ¶ÁÆêáÁÍÄÁÓ`ÁÙÇ-ÁâoOÁÛéÁÕn!ÁÎë'ÁÈwêÁ Á»Ð}ÁµLÁ¯^PÁ©SÚÁ£jXÁŠAÁ—¼Á’=ÁŒmôÁ‡ ÕÁ¯öÁy.ÁoZ*Áf²Á\dÁS«­ÁK¦HÁD©Á<ÞŸÁ6VÍÁ0’Á+ÜVÁ'±µÁ$)Á!¥ÃÁÚþÁ€ÁylÁ{ïÁb Á!¢2Á$ AÁ' KÁ+wFÁ0±÷Á6»˜Á=ÉÁDÚ¶ÁMžÁUÆ:Á^æìÁhªÁruÍÁ|Ì»Áƒ›1Á‰ÁŽ•*Á”-0Á™öCÁŸÙ£Á¥¯áÁ«¡ßÁ±«§Á·Ô±Á¾ ÉÁÄ( ÁÊi ÁÐÈÁ×B×ÁßöÁÙ`ÁÒãpÁÌoËÁÆÁ¿¦oÁ¹d<Á³/•Á­2Á¦ßŒÁ ÝrÁšÿcÁ•.mÁ€Á‰üÁ„¥4Á~¯ÁtLMÁjl¦Áa/sÁXbÁOg¡ÁG\áÁ?õ¢Á8Ä­Á2‡uÁ-EÁ(a5Á$1/Á OÁZ¡ÁƒáÁŽîÁ÷äÁJÁ<°ÁRÁ Ë%Á$¡Á(ÎÁ,þÌÁ3 PÁ9„xÁ@õ¦ÁI!•ÁQ¡jÁZºÁd´Án"TÁxkçÁtÎÁ†Ç¶ÁŒ0BÁ‘ÕÛÁ—§sÁn Á£4­Á©"ãÁ¯;<ÁµnÁ»}ÁÁ°õÁÈÁÎubÁÔÁ8ÁÚÄ`ÁÔÃþÁÎæ?ÁÉ.)Áß Á½J(Á¶ÿ‡Á°Î•Áª¢NÁ¤‹æÁž~ðÁ˜ÖÁ’ÐÑÁ$ŠÁ‡›]Á‚P6Áz6<Áp €ÁfUñÁ] lÁT5°ÁKÁCºcÁ<¯9Á5ºªÁ/˜TÁ*aÁ%•IÁ!pÙÁ|ÉÁ% Á((ÁT Áå´Á4&Á(ðÁ²„Á@ùÁ!¹ŠÁ%¸Á*¶ŸÁ0]ÃÁ6½îÁ>+ÁFåÁNr7ÁW1uÁ`œjÁjƒIÁt ?Á~¬·Á„‘ÁŠÕÁÊÅÁ•{gÁ›6Á ñöÁ¦ô¼Á­ŸÁ³ýÁ¹@ÁÁ¿„;ÁÅÕmÁÌEÁÒw.ÁÕ ;ÁÏ|ÊÁÉw¶ÁÖüÁ½ÝûÁ¸PgÁ²òLÁ­ÈÁ¨‚SÁ¢gŠÁœkoÁ–}qÁ¬¨Á‹žÁ…“RÁ€7wÁv1ØÁl4ÁbƒÁY† ÁPµžÁHnÁ@ÎîÁ9×qÁ3ùÁ-&sÁ(ÒÁ#uúÁôÁlÁ•…Á+×Á7 Á«ëÁÓÁÕðÁwÐÁ’ÁÁÉŒÁ#ÅÁ);Á.G)Á4d’Á;€ÆÁC!ÁK‘<ÁTvýÁ]Ág*þÁpú“Á{¢Á‚ÎPÁˆRØÁæÁÁ“rvÁ™&­ÁŸRÁ¥ éÁ«tÁ±Á·0%Á½oèÁö@ÁÊ@ÁÐ$ ÁÏiÁÉÓ ÁÄ64Á¾+èÁ¸GÚÁ²ÑÁ­üÁ§¨ïÁ¢‡®ÁÄÁ˜‘ÏÁ“|ÖÁŽs;Á‰CGÁƒÕkÁ} ZÁrÝTÁi ÍÁ_gÃÁVnÁMáqÁE¬vÁ>e£Á7z{Á1,EÁ+¶ÛÁ&¼€Á"èÁ+Á#¬Á4*ÁÈiÁÔîÁwAÁ¼ýÁ;bÁâ«Á5ÁöqÁ"°YÁ'oYÁ,¿Á2»‡Á9RðÁ@ãÁISÁR FÁZáµÁddÓÁn.šÁx8eÁR×Á†¸éÁŒ9^Á‘¶Á—^æÁ:cÁ£9*Á©(Á¯zÁ´¯½ÁºÁ¿WóÁÄÔÁÊ{ÁÉ¡^ÁÄ&Á¾†9Á¸ðÏÁ²à­Á¬øßÁ§=­Á¡³ÔÁœ`“Á—I£Á’PºÁTËÁˆ7«Áƒ<*Á}ýÁtx†ÁlSiÁdÁ\°ÁT.ÁK÷ÅÁCá”Á<¬ÏÁ6 ˜Á/æÁ*¼×Á%ÛÿÁ"mÁ½€ÁRxÁoÀÁôÁ[­Á;Á&ÿÁØÁ8ÁDÁÿÁ"c`Á&½!Á, Á1ÕšÁ8FÔÁ?‚zÁG|çÁOÅTÁXƒ¤ÁaýÀÁkÚ°ÁuŸ*ÁÃåÁ…7 ÁŠwÔÁeÁ”„yÁ™µÝÁŸ éÁ¤3?Á©d«Á®µ“Á´ ÊÁ¹„#Á¿+ÁÄëÖÁÃüÁ¾QJÁ¸ÍzÁ³9ØÁ­¬ÕÁ§– Á¡ªÁ›íÁ–eÿÁ‘tÁŒ Á‡ÅÁ‚)Áyé Áp«Áfï(Á^ŒÁVjÁN%ÂÁFvCÁ? ÍÁ84ñÁ2_ŠÁ,r—Á'=…Á"¨ëÁÅÏÁTRÁ?áÁèÁ›.ÁÁZ3Á²“Á‡ÊÁßÌÁ6HÁ2ÁÄæÁ•qÁ$Á)¿ÄÁ/‘"Á5º.Á<+%ÁBèÁJiÁQú`ÁYÝOÁaûçÁjéýÁtoÁ~~FÁ„'´Á‰=sÁŽmgÁ“½>Á˜ðÁž<Á£jÁ¨¾ Á®4?Á³ÛÁ¹›ûÁ¿^Á¾‚ Á¸¬8Á³>Á­€%Á§íþÁ¢j“ÁœLiÁ–[„ÁxÁ‹’Á…ÓãÁ€Ï‹Áw­ÖÁm´$ÁcgôÁY»hÁPÖSÁH£Á@myÁ8ZBÁ0ÞwÁ)¡)Á#XÊÁ°ÓÁúúÁZÁ7uÁ ­êÁ‰¢Á8ðÁ±DÁáÀÿ÷«ÀþʤÀþP»Á¢ÕÁú‡ÁF(Á ñÔÁpìÁSÁÔÁ ÄàÁ'äÁ-¦ÈÁ4}OÁ<ÞÁD7îÁKùŒÁT Á^ÚÁh³ÁqÚ%Á{ìÜÁƒ&$Áˆp©Á­AÁ’еÁ˜©ÁqÓÁ¢äjÁ¨‹+Á®L!Á´ªÁ¹ð Á¹7Á³5Á­\bÁ§±;Á¢3:Áœ¢ÉÁ—*iÁ‘¹Á‹ <Á…MkÁ—MÁu ˜Ák%CÁa/JÁW&~ÁLíÑÁCsÌÁ:ݽÁ2» Á*~ýÁ"¹¬ÁDZÁ‚xÁððÁã:Á ;ÀÿVEÀø$ðÀñÇ[ÀìÿèÀçšßÀäŒÀàž‘ÀßÙeÀß‘°ÀâÀç\ÀîúŸÀ÷wÁ{Á0Á îhÁƒÁj½Á#ËÁ&=GÁ.aÆÁ6Á>j©ÁG§ÑÁQššÁ[fdÁe`Áo¾=ÁzHaÁ‚jÁÁ‡ˆPÁŒÓIÁ’&Á—”§Á;JÁ¢üHÁ¨¿aÁ®¤…Á´³Á´$Á­ð3Á§èÁ¢ œÁœaBÁ–æÒÁ‘X`Á‹ìÙÁ…¼RÁ~ ÁsúÔÁhþÇÁ^ž“ÁT«´ÁJ°™Á@˜ØÁ6}2Á-CDÁ$ô¼ÁÈSÁ¨ÐÁ ¯ÁÞ“Àÿ§Àô õÀé~ÀàomÀÙÆÀÒ†ÙÀÍWÓÀÇå1ÀÅUiÀÁ)vÀÀÚÀÀ²ÀÂ×yÀÈBâÀЮÀØSÌÀã!Àî&Àú-ÁLÄÁ ëüÁ·ÁUÓÁ sÁ(QÊÁ1D!Á;ÁDô:ÁNØÒÁY04Ác¯¶ÁnQjÁx‚¶Á‡üÁ†ÚfÁŒDûÁ‘ësÁ—¬pÁp>Á£YÁ©nÏÁ¯«iÁ¯?Á¨âHÁ¢ªµÁœœ–Á–¼ëÁ‘XÁ‹› Á†ôÁ€£¦Átí!Áhã¶Á]ZóÁRhÁH#Á>2€Á47£Á* 6Á Á3øÁ ÐÁØ}Àþ~Àîü`Àá¹íÀÖ»ˆÀÊõëÀÁÒþÀºþÀ³QÔÀ­°zÀ¨HþÀ¥ÓÅÀ¡´hÀ¢©À¡ÓÀ£“¹À©9ÀÀ±:¿Àº VÀÅBÀзúÀÜ£¤ÀéTïÀöÁwÁ|;Á טÁbkÁò'Á$š[Á.„BÁ8WÁB¢.ÁMlÁW΂ÁaøŠÁlyŒÁwxÁ€õlÁ†›žÁŒ\™Á’!JÁ˜hÁž,7Á¤rƒÁª­TÁ©à›Á£¸3Á¨4Á—fÔÁ‘QIÁ‹mSÁ…Á~Á€PÁuœÁj¨¼Á^eçÁRJÁF»<Á;Ó–Á1©·Á'¹ËÁÆÛÁ€àÁ ËÁH ÀòF ÀâtÀÒÇÀÄ>PÀ¸º^À¬ÚÀ£F(ÀšþfÀ”)WÀŽ"9ÀˆÔÀ…Ü^À‚CÄÀƒHuÀƒ\À„PqÀŠN®À’wÀ›þiÀ§hâÀ²äÀ¿,ÍÀÌrfÀÙá¿Àéj9Àù\ÁºÑÁ¨ÁvÁ!ÝøÁ,+Á6°ÁA@=ÁKrƒÁUã`Á`†0ÁkLÁv—”Á ÃÁ†ÒÁŒÆ<Á’ë»Á™=ÁŸ^šÁ¥LÑÁ¤û”Áž¢Á˜q`Á’mÁŒ$óÁ†ÕÁ€ÜÁtãtÁj =Á_ÁT 4ÁGäiÁ;²Á0ÁÁ%B„Á0ÝÁAÐÁbSÀùý/Àç7ÀÖ½ŒÀÆdÀ¶°<À§q]Àš¤5ÀZ—À„œÀwü£ÀjÀ]›"ÀS1ŸÀKÎ:ÀEËÀH8¼ÀH¯ýÀJ$ÀWÀg´ À|GôÀ‰æAÀ•=À¡ÕÀ¯@‹À½BÀÎBBÀÝ\VÀïPÀÁ¯zÁ jÁ†.ÁéõÁ*¥âÁ4íðÁ?M‰ÁIîúÁT­Á_÷óÁkyàÁw>Á~OÁ‡­áÁŽ ÝÁ”ÁšhÁ $nÁ V‰Á™ÌyÁ“gPÁ,Á‡ ŒÁ€åšÁuzëÁiÁ^D$ÁSz«ÁHs½Á=k·Á1j×Á%XÁ|œÁ¶^Á¸ÃÀõ}*Àá·ÃÀÍUÀ»?ÀªëÀšÌÈÀ‹h€Ày¡jÀcјÀL<7À:Ç!À+¼ÖÀ!7ÀÍGÀ ä­À6À åhÀ 7BÀ ›ªÀ4À*À@”°ÀWª—Ào€%À…4IÀ’UdÀ¢NòÀ±ÓIÀÂŽÀÖjrÀéó¤ÀýðtÁ WÑÁ ‡ÁjÙÁ(¸)Á3WÜÁ>ŸÁIXXÁTÚ>Á`lÁloùÁxæ¿Á‚àÁˆÁîÁŽ»Á”äøÁ›9ÅÁ›ºAÁ•<ÁŽ¢›Áˆ/ŽÁè¯Áw©kÁkSÁ^êúÁRþòÁG¥ Á<é‰Á1è´Á&ÍJÁü¢ÁŠ(ÁÝúÀðcÓÀ܃»ÀÈ{*À´¤=À Z¦ÀniÀ~.ÓÀ_E†À?Õ<À'@[Àúw¿û·Í¿ÛY£¿Á”u¿¬ÑÝ¿—ý£¿ªo¿—¨ú¿›}¿›T¿½†„¿Ü WÀ“NÀÖôÀ4®vÀOŸ%Àl=}À†ÂþÀ–sÀ©_xÀ½ËÀÐÕ,Àå“*ÀúâZÁéûÁ#‡ÁÀßÁ'riÁ2¸ÆÁ>:£ÁIÑÁUç‹ÁbzkÁo`ÁzèBÁƒt%Á‰¨EÁ ÅÁ–’áÁ—#Á%ÁŠ%‡ÁƒPÁyøpÁmO€ÁaŠÁTãbÁH^ÎÁ‚¿ 딾¾S¹¾J§¾ï¼¾\Q>¾Œ¸‡¾©¦¿ €¿I^œ¿˜ï¿Á`[¿÷R†À’šÀ754ÀT•ßÀx®MÀVXÀ£É&À¸w^ÀÍ­¦ÀâÙRÀ÷$|Á*ÁÖDÁBÁ'›Á37IÁ?dÔÁL¡ÁXÀÁdM¦Áp]ìÁ|Þ"Á„ß>Á‹xÕÁ’6:Á’XÁ‹ýÊÁ…eøÁ}Þ½ÁpÈÓÁc<ÁVÔÁJ€Á>XÁ1×ÒÁ%Ä›Áh‚ÁÂÛÁÙ@Àó!ƒÀܼÀÂó½À«G³À–ˆÀ‚¹PÀ]·ÄÀ5(ÒÀ•<¿ßI•¿¤èù¿Dkç¾Ë÷{½QüS>YÜÁ>Þ–I?,?Bëa?QA¶?<Ò¯?iØ?MÈ>¦#o>Ðö¾€½à¿)î¿‚z¿»¾ ¿ýošÀ¬ÁÀGt Àm½›À‹[ÐÀ xöÀµé;ÀÊ¡Àß'AÀôw‹ÁyÑÁû‘ÁŸŽÁ(êÁ5È¥ÁB ÁM´\ÁYØ,ÁftÆÁswdÁ€hCÁ‡9¯ÁŽ(ÛÁŽPÜÁ‡ˆÁ€á!Át‹€Ág|™ÁZ¨ðÁMQ>Á@alÁ3ïâÁ(­ÁXJÁ)ÁËcÀò\YÀ܆æÀÅå˜À°*hÀ–«À|*vÀSUzÀ+ÝGÀŒ¦¿·n4¿f_™¾Ðn=[ed? ç?ec§?•C–?´<‰?ºÉ?Â0!?ÁÇ?­àž?¯–?­Ì¶?¡Uå?c ?1 N>˜°[½Ó¶¿*ì¶¿‹'M¿ÜÎ:ÀRÀ<®Àfˆ™Àˆû„ÀÆÀ±ûxÀÇGVÀݵÀô¸JÁ ÒÁ{ Á…;Á+€*Á7âÁCX¢ÁP_Á]BwÁjǰÁx—áÁƒA=ÁŠ6ÁŠXKÁƒ[íÁxü»ÁkŠùÁ^O6ÁQ'çÁDX‘Á7Á)úîÁdlÁy÷ÁäÀñãÀÚ_oÀÅ3 À¯EÅÀ˜ª‘Àƒ¾ÀRö­À!æ‹¿óÿ£)H¿:+U½¸D >Þ›?k:^?°b³?ÁH ?Ág?ú?ÇëÊ?Ê Ó?Ç5?ÃýØ?ÅØ?ÉoW?ÊM§?ÆÉÄ?Ãf?™÷`?:º·>v: ¾¥¿kÒ<¿Ä >À kÀ8˜À`9ñÀ„ÑüÀš0À°vÓÀÇyÀÀÞõÏÀø;÷Á F<ÁàÁ ‡ûÁ,áºÁ9Ê?ÁG%ÊÁTÞµÁbÈ×Áp³ŠÁ~žEÁ†._Á†2ÅÁ~Ø~ÁpïÇÁcÁUcÁHVÁ:ä$Á-ëDÁ!(Á¦,Áà Àõ·èÀÝ—ÀÃòÀ­-DÀ˜ àÀ‚·ÀVÛ¨À+Ý©¿õ)¿=*¿> QÇ?(¡³?ž²B?³˜ß?» ‹?ÆQ¥?ʵ­?̈º?Í×ë?ËaB?ÈPå?Å@ˆ?ÈZ;?Ëñ?Ρ»?Ït?Ð2J?Dz,?½š?ŠÄ­>ðà ¾²¿FÜ»¿»™œÀ^À/\µÀYÒÀƒ9Àš;ÄÀ±æõÀ˲Àåë‘Àü‚§Á öëÁwSÁ#”Á1*sÁ?fÁLú.ÁZäûÁh¸ Áv_KÁ‚æÁ‚;xÁv‚âÁhμÁ[A§ÁM/üÁ?W€Á1Û¨Á$¥›Á9Á õ`ÀúÙ<ÀàÎÀÈ~=À°~çÀ–ÑÀ€ÓÀUÁòÀ)‡´¿øÁk¿£#«¿›ó>‡i?`fo?ª”K?µLÇ?½ã?Æ÷7?É^?ÉÜ?É Y?Ë ?Ì£ó?É“–?ÇE ?ÊÜt?ÍJ0?Ì© ?Íõz?Ò›?Ôy1?Ë÷º?Ê3U?¡Ø#?,½\«Ð¿2 G¿ªŒ»¿þçÕÀ+ý8ÀYþÀ„úWÀŸ=uÀ¸ÖÀÏEdÀæ×åÁüÁ ¡ÁVNÁ)A,Á7, ÁE·ÁR»Á`pÁnhÁ|ØÁ}6•ÁnÞúÁ`½ÁRÛ…ÁEHÁ7€½Á)s3Á¶þÁhZÁDÅÀèñFÀοœÀ´µÀ›HûÀ„z9ÀS™ëÀ%³¿ö㿞M¿à½> ŸÝ?Z"2?²"?¸êx?¿ÏÎ?Å®Á?Ń?ņý?ÅŠ{?ÆK8?ÈhF?Ê…T?ÊÖF?ÉÇX?Ëò¥?ËR?ʱ„?Ìvî?Ж?ÓaÝ?Õ'%?Ð4¼?Åܪ?­Îß?5ax=J£¿Y±¿£7¿ÿ÷À0½ïÀe»—À‹À>À¢ YÀ¹×ÀÓÏÀï;¹ÁˆÊÁs¸Á!^¥Á/HÁ<ÀùÁJ§âÁXØçÁgFdÁubvÁv°ÁgþUÁYs¹ÁK:Á=µÁ/?™Á!ÊÐÁ¿ìÁ»ÙÀðZ§ÀÖoÀ¼9À¢ìAÀ‡ˆoÀ\;"À1Í2¿ôˆµ¿–ÿÇ&>0S]?\Ë”?¨&O?·òµ?¾Ø ?Âp?ÂSÏ?Â-? œ? ?Óf?Űs?ÇÍ?Éê?Ê›?ÉúŠ?ÉYù?ȹi?Êøc?ÍàE?Ï¥?ÑjÖ?Ó0?Î S?ÂÎ:?µÍe?I¹ˆ=Ѓ¶¿o뿯ýqÀ p°À=KVÀi¨3ÀŒÿSÀ§ÎêÀãsÀßy&ÀûNâÁ tÁËÁ&êƒÁ5¿ÁC‡ÁQ®.Á_£fÁmÚ€Ápk Áa°'ÁRøýÁDCÒÁ5±Á'\2ÁV€Á ·ÚÀüR6ÀßþžÀĸÀ©„}À=ÀmlkÀ7{À!¿²†7¿¨›>Rxþ?M'k? ¦¼?¯1²?½àI?¿p?¿4~?¾øÝ?¾½TÁ8#6Á)ÁLRÁ Àù­ ÀÜZ©À¿¾öÀ¤P‘À‰AxÀZĘÀ" á¿Ú2~¿h¨í¾¦¨?-ݪ?¤¨?³’®?»A?»/?» ?º¹D?ºV•?¹óæ?¹‘8?¹ñ ?»l ?½ r?¿=$?Á¼s?Ä;Á?Ãç_?Ä?ÄÝ'?Ŭ7?Æye?ÇD?ȵ?ÊÂb?ÌѪ?ÎïÞ?Ñ?ÓÞ?Ïæ!?ÆóY?¡¼k>ôŠ,¾¬hÞ¿–3@ÀMÀ98ÎÀo»À“°ÝÀ°ãØÀ;pÀèâŽÁ~ÁªÁß–Á.áËÁ> mÁMYNÁ\¾¹Á`à8ÁQt#ÁBÿÁ2éôÁ#ÆûÁ©‚Á“iÀíDÀϾÀ²BíÀ”Û\Àp¨ŸÀ:hwÀK]¿—©]¾§åx>îa[?¬Š?¯Ð?¹+?¹š?¹ˆ?¹w?¸÷è?¸•9?¸2Š?¸æî?º˜?»”i?½HÒ?¾ý;?À±¤?ÂUn?Ã$~?ÃóŽ?Äž?Å‘®?Æ_±?Ç*O?Çôì?É?Ë$?ÌÜw?΄t?Ð,r?Ò{£?ÌÕ?Åá?n5¾=â’¿4Ö¿ÄTÀÀá ÀSÞÀ‡QÀ¡”ÁÀ½¥,ÀÚÊâÀø¤rÁ |ÁÑÁ*E…Á9ÑœÁIoÚÁYVÁ]NÁMkÁ=úÁ.gÁê°ÁЬÁQ¤Àâa3ÀÄ0üÀ¦ÉÀˆr&ÀUÊcÀЕ¿Äœ¿0Ñ>%œä?ve™?¬}?¶H¤?¶f?¶’’?¶Èû?¶ÿd?·¾?¶ÓÝ?·ÜÏ?¸üy?º#?»¼Ê?½q2?¿%›?ÀFÝ?¿¤î?ÂFÝ?ÃÙ?Ĩ?Åw%?ÆEý?Ç›?ÇÛ9?ÈV3?ÈM ?Éõ ?Ë?ÍE?Ï£4?Ñ%?É_Ì?«®? ª¶¾‡©u¿hÀ¢ýÀ5X:Àl~kÀ“žPÀ±æ%Àб€ÀïÍ»Á€ÁJkÁ'vÁ6ä;ÁF¬PÁV4“ÁZËqÁJ÷æÁ;òÁ+F±Áz1Á ¹kÀø©ÀØÞíÀ¹òÀ›s(ÀzvŸÀ>]¤Àù¿xƒ¾L$ÿ?¼^?¥¾³?³‡,?³¤ ?³Â?³à‘?´ú?´Mc?´ƒË?¶†­?·ò[?¹?º1¯?»å*?½™“?¾k ?½‰ü?¼âÞ?¿„Í?Â&¼?Ä?Å\?Æ+­?Æöç?Ç«°?ÇKî?Æì+?Ç ž?ȵ›?Ê]™?ÌÊÅ?Ï{?ÌŸX?Á?p?X4=+.Ž¿/{¿½IžÀM#ÀXt;À‹¸‘À«`ÖÀ˸ÀêʸÁ^Á§ Á$!éÁ3¯#ÁCNåÁRýÁX¸=ÁH×Á8úvÁ)#¡ÁTcÁ [Àó]ÀÀÓŠiÀ³·¡À“ó Àhž#À)àG¿Ù_¿C‘Q=wa?n1Ú?¬µ ?±Á—?± š?±?±;‚?±dù?±›b?²B}?µ¢?·ÚÈ?¹'?ºY"?¼ Š?¼b?»®>?ºÍ?º Î?¼Â½?¿d¬?œ?Ĩ‹?Æ$?ÆÝ3?Æ¡j?ÆA¨?Åáæ?Å‚$?ÅÎ/?Çv,?ÉòV?ÌÆ?ÐwÊ?Êè?šìr>éìѾ :r¿¢#¦À[øÀO$ À†òAÀ¦R}ÀÅgAÀä¦ÜÁlÁ¹Á!wáÁ1@ùÁA¾ÁPÈÁV õÁF·ûÁ6ÓÁ&ó:Á:ÁJhÀïÓÀω!À¯ó~À_nÀaoÀ!ã½¿Ä‹è¿ %À>¿<¬?”w ?­p?°{‘?¯Æ”?¯—?®—~?®´ñ?®é`?°Êr?³–˜?¶b¾?¹.ä?º‚?º³¤?¹Ò?¸ñ]?¸… ?¸=û?ºÏã?½aí?¿óö?†?Å ?ÅÐL?Åg?Å7b?Ä× ?ÄwÞ?Ä?ÄŽ¿?Ç]²?Ët?ÎÁ7?ͳ¡?±|?#Ü‚¾a³ó¿èOÀHÀCb0À€ë›À 9À¿“¢ÀßÀþ±Á.UÁõÁ.çLÁ>ÈlÁN«²ÁU“ÜÁE–®Á5™ÓÁ%cÁ¡‚Á¦bÀëX¥ÀËgÀ«x·À‹’…ÀWwAÀŽ¿±ìf¾Ïˆ>ùúË?ŸS+?¬‰/?¯5‹?®€Ž?­Ë‘?­”?¬a—?¬†B?¯Rh?²6?´Ì§?·€?¹¥É?¹ªS?¹Y`?¹m?¸·{?¸fˆ?º§´?½9½?¿ËÆ?Â]Ð?Ã&H?ÄÏ?Ãx/?Ã7I?Âöd?µ~?Ât™?Ã(?ÅàÁ?ÉXá?Í £?Ð0?ÄbÁ?5Û½¸If¿nÅû¿óͨÀ9U‰Ày óÀœc—À¼AµÀÜÔÀûýóÁ î ÁÝÁ-Ì)Á=»9ÁMªHÁU!ŒÁE2Á5E^Á%\wÁx~Á›7À뎩ÀËÒÀ«ÿ«ÀŒ@€ÀY$„À’G¿´Š¾Ó€ò?Xâ?œ O?«ô)?®E”?­ŽÃ?¬×ò?¬!"?«è?«”w?­f?¯ÅÖ?²yG?µ,¸?·-Î?¸W®?¹Ž?¹:È?¸éÕ?¸˜ã?º„?½?¿E‰?À°?ÀÃØ?ÁJ?Á8À?Á ?Àß,?ÀžF?Á¤?Ã…?Åë—?Èôé?Ìz?Ï. ?¿›?4|3¾·Ä¿xF¿ö-"À:âÀy¥\Àœ¨ÛÀ¼XÀÜRÕÀü% Á û¢Áä¾Á-ÍÚÁ=¶öÁM šÁU*<ÁE8hÁ5IÁ%\õÁuÁ’þÀëqûÀËÕ¼À¬tÀŒeÀXHÎÀ‚~¿±ƒÅ¾É;€>üŠ€?¢'—?©?­d~?¬­­?«öÝ?«¶¦?«¸l?«¨v?«"?­rw?°%ç?²ÙX?´µÓ?µß³?· “?¸3s?¹0?¸Ë=?ºWT?¼#ò?¼ã?½¢@?¾ah?¾©Ä?¾Ë:?¾ì°?¾Çô?¿. ?Á”š?Ãû?Æa?Èì?Ì ?ÎC/?³¶?'_ö¾*7Û¿L%¿÷+À:qJÀyȘÀœ²&À¼ŽÀÜm¶ÀüN¦ÁgÁ éÁ-ûºÁ=íÆÁMßÿÁUOnÁE`›Á5tÍÁ%ŒåÁª ÁÎQÀëø“ÀÌq$À­üÀܽÀ\é¦ÀŒØ¿Ào±¿)ß>ªW?õ?¢Óò?¬ƒh?«Í½?«Ïe?«Ñ*?«Òð?«¼v?«¤!?«‹Í?­Òˆ?°…ø?²=Ø?³g¸?´‘˜?µ»x?¶åX?¸8?¹[?¹Á‚?º€©?»?Ñ?»þø?¼<>?¼]´?¼*?½(¦?¿œÓ? ?Äq ?Æ×ƒ?É=ý?Ì©?Çþq?£Ûi? ¾‘2¿’ŠuÀÊéÀCdÀ€¦ÀŸ»À¿8ÀÞ£·ÀþLSÁ2Áé Á.Ò×Á>ÀÁN®ÁV¦ÄÁFÓvÁ7îÁ'F_Á‘æÁï ÀðÉ[ÀÑûYÀ³˜xÀ”ͦÀk>.À-H0¿ã& ¿c=œ¼Ê†–?EÓM?š"ç?§üˆ?«è#?«éé?«ë®?«èÊ?«Ðu?«¸!?«ŸÌ?«ˆÑ?®2˜?¯ÅÜ?°ï¼?²œ?³c{?´ÖÅ?¶J?¶â»?·_ê?¸9?¸Ýa?¹œˆ?¹Î¸?¹ð.?»^?½/?¿a\?ÁÑï?ÄVï?ÆÛï?É`î?Ç9?¼VR?„‡%>§``¾ã u¿¤L©ÀÐðÀMƒ>À†XýÀ¦ÆÀÅv±Àä¼*ÁëOÁ€¯Á!*«Á0ãÈÁ@¨SÁPu´ÁY*’ÁI‰ØÁ9ùSÁ*}sÁfÁ ßÀù‡&ÀÚ€À»Ì„À|À€P‘ÀGßËÀ åÉ¿«pš¾ý‘ƒ>·¼Õ?“ÉÂ? “?§h¢?¬m?¬2?«üÊ?«äu?«Ì ?«³Ì?«›w?«ß9?­R•?®ÅÞ?°9(?±¬r?³»?´_œ?´ÜË?µYú?µ×)?¶zñ?·:?·a2?¸æ?»V?½6•?¿cõ?Ášä?Ä ?ÆŒ ?Ç'-?¿¸ ?¥Ç?5Bž¼²¿Gh¿Ôã§À$?À^MÀŒÛÀ«ttÀÊ|†ÀéÇzÁžÓÁh¥Á#óÕÁ3Ž?ÁC9ÁRðÀÁ\ДÁMvñÁ>8¼Á/ÁÉ”Á}›Á]7ÀäóbÀÇÑXÀ«3ÀŽOÀciÀ,楿ì]X¿v ½è?òë?—Ë¢?Ÿ²?¦aÂ?¬ ¶?¬É?«øt?«È?«|Å?«1w?«DØ?¬( ?­‡?®‚?¯õh?±h²?²Y¬?²ÖÛ?³T ?³Ñ9?´Nh?´Ò6?¶ÄÏ?¸í?»M?½=Œ?¿f?Á|?ÃÔk?Å ?¾Ré?³?g?E"?> n>¿-¿²$ýÀ #¥À?˜ÄÀxøïÀ™]À¶BqÀÓ¶™ÀñСÁ,ÈÁ—óÁ'Á6»ÁFgÁUø8ÁaжÁRZjÁC¦Á3ñoÁ$ðÁ¨ÁQèÀñï$ÀÕ7ºÀ¸†uÀ ŒÀÁAÀKg#À•¿ÁÌÀ¿<©a;*á?-uç?˜ï?™Ü8?£‚ý?«e?«Ð?ªÎ?ªƒ3?ª]'?«À?«Ù ?¬ÐŸ?­È?®¿œ?¯·?°vŠ?±'Ã?±Øý?²Š7?³;p?´Í ?·˜?¹ †?»D?½D„?¿lÃ?Á ?ÂC^?¸å?®¤ö?[ˆ0>“„¾½“ü¿’%¿ñbÀ/N0Àe\mÀ‹ÍÀ§BŠÀÃõÅÀàÍFÀý©bÁ uÞÁ[ÔÁ+t¥Á:³ûÁJÁY…¿Áf€lÁW\‰ÁHZÝÁ9ƒ¹Á*â1Á…NÁ-{Àÿ™jÀã°4ÀÈ5HÀ¬»À‘ÀmHÀ:Ô÷À %:¿¯üf¿)¯ò½Â>ýü¤?ýâ?™'+?¤‚?©/8?©Ôï?©‰ ?ª?ªÂ¨?«Š8?¬·?­y5?®p´?¯1À?¯º8?°kq?±«?±Íä?²?µË?·­ ?¹¹ç?»¥Ô?½‘Â?¿}°?¾}?¶Ìç?®Ñì?QÐN>q,›¾åø»¿uÉ{¿Ö{¶À  9ÀRtBÀƒ'ÀŸ)RÀ¸i3ÀÒëQÀîÆæÁ¼àÁ%ÀÁ"¹Á1"RÁ?îOÁNè*Á^šÁká„Á]ÿÁN…\Á@(GÁ1ÁðÁ#^ÞÁOíÁzMÀóΤÀØ6À½FcÀ£löÀŠb·Àc9 À1ùRÀ‚¿·ˆx¿aäξ0ƒ>Øý£?…ް?œ†…?¡§;?¥àj?©4^?©Ú÷?ª?«;P?¬2Î?­*M?­æÀ?®¡"?¯ ±?¯¯?°`Y?±’?²ˆ4?µ4u?·à¶?ºhG?¼T5?¼Ëý?¹Z*?¬ÿ?œ E?+Jè=û~ý¾óLü¿Ga¿âä+À{ÀD\ÀxÑqÀ–(ßÀ¯v¬ÀÊ|ÔÀåFÀÿ"™Á ÿÁ'ÒÁ)€ÒÁ7çÊÁFP¯ÁTשÁc‘=Ár3ÁcÖ†ÁUdæÁG»Á8äžÁ+ÞÁMIÁ«ÃÁ­ÀéÎ3ÀÐbŠÀ·[3Àž¨^À†ËÀ^£À5·kÀ{¿É&l¿_z^¾‘"¿>ƒ!)?FÓÆ?‘Î?–^1?£Ð?§öN?ª@x?ªìg?«á^?¬›À?­V"?® /?®Œ.?¯ .?¯¤?°U@?²»Þ?µh?¸`?¶ “?´*Ä?²²ü?¯A(?vmŒ>Ó*E½à›¿$ÇU¿š±9¿ëõhÀ ¬ïÀIÔbÀp iÀŽëûÀ¨ÀIÀÃ)ÀÜ(gÀöoåÁ÷ƒÁÔªÁ#\Á0×}Á>í'ÁME´Á[«RÁj½Áy,Áj±EÁ\‰’ÁNždÁ@ÍðÁ3Àä\ºÀË´ÌÀ³ôÀœjøÀ‡åTÀhá—À>r•ÀÌG¿Óø¿ŠÏ|¿½q¼âdŸ>Ô%?gÝó?˜‘—? {þ?¢øè?§n§?©ÐÆ?«›©?¬Å…?­x¬?­÷¬?®v¬?®õ«?°CH?­u%?©æj?¦W®?§;T?¨ƒ—?’¿?8‚Ñ>·È¾Ê9Y¿kË~¿¸Øô¿ÿð)À&ù[ÀO®7Àz³‡À‘{$À¥%óÀ»ÿzÀÕ6øÀï£ÏÁ…hÁdÆÁÕëÁ,0YÁ9?ˆÁF¼éÁT“‚Áb²þÁq Á€ÿÁrBÁdd]ÁV¿ßÁI-wÁ;¾ÌÁ.ŽÁ!¯ÇÁ(GÁ´ïÀøÁ„ÀàGBÀÉ•´À´óÀ ú7ÀŒ]gÀkÐÀC´ÀŸ¿øÈ㿵²B¿\~¾Ùª\=gó>ë´?M¹4?–8%?š”€?ž¯ ? zƒ?žÜ¢?™ß?œ„k?~¨?› ?—”7?˜U&?–¥É?¸g?uš;?+Š«>‰a}½â˾¿œ¿rA¿áNDÀQ3À3¬åÀY=gÀ€vÀ”ØAÀªwÀ¾(“ÀÒT_Àé$²Áõ\ÁøÁþÁ'°ŒÁ4ãâÁB‚íÁO}ÆÁ\ÈÁji'ÁxR¬Á„óÁzL/Ál¹›Á_<ÓÁQñ´ÁDâNÁ8(ôÁ+¤ Á;ƒÁç1Á¼LÀöȯÀâQÀ;sÀ¹²À£ IÀŽË>ÀvMëÀSf–À4;×Àò÷¿ßª¿¥Ûî¿RÀö¾ê"½——7>Ž x>í{?8e8?Kª¢?_Þ?^RÚ?Y (?NDC?N?2Ù’?AX>²þý>röG<ç"û¾†o¿"¥z¿ƒE ¿²ýÛ¿þ¤‰À&^ÀHÒæÀj"À…ÿgÀ™o§À­w(ÀÁöÀÀןÀêè{Àÿ‰tÁ )‚ÁdBÁ$E5Á1v¼Á>aÁK!ÁXz¦ÁeÏ:ÁrîÃÁ€1Áˆ$…Á`*Áub½Áh5©Á[BÁN¤<ÁB Á5ÂÁ)m¬ÁWAÁ Á‰9Àú¯–ÀæÇÖÀÐ9öÀ»ÂfÀ§ø¿À•[×À…¸RÀgÓyÀE¶ºÀ(¬‹À A!¿ÝῳMY¿u#&¿/Fk¿/ξeZæ¾$C˜½ù²~¾¥i¾K¾-G…¾;ï/¾”ß•¾Ø ¿„¿;ÔÓ¿pŠt¿s<¿Ãއ¿÷Ý€À£ßÀ0ò&ÀXæýÀ~`ðÀRÀ ç¡À²³0ÀÆO†ÀÚ{4Àï"`ÁS²Á æòÁaÁ!ÃPÁ-à Á:’øÁGµ ÁT}ïÁaWÁn‘óÁ| Á„•ÁŒn Á…ÌÎÁ~†4Áq­3Áe»ÁXŸÁLH±Á?ôwÁ3ó¡Á(Á†ÁÛÑÁ zÀýoßÀè¼ÀÔÝ ÀÁ‘(À± OÀ pÀŽ¥šÀ~q5ÀaÛ'ÀC·À+?5À€¿òÕb¿Ó4¿¼²„¿˜#?¿™2¿%ž¿ý,¿’³ç¿“z¿–B[¿¤-¿´Ät¿ÈÅ¿Ü>¿õ(®À ¯ÎÀ!ŽÀ665ÀP¾ÀgÿøÀ…9CÀ™Z À«çÀ¼;_ÀÌÙ Àß‹ãÀó8¨ÁÀXÁ)ïÁ¯cÁ"feÁ,þ“Á8^ÊÁDdJÁPòÁ]ò^ÁjôbÁw¬ºÁ‚`gÁ‰"ÁîÄÁŠpÁ„´Á{›bÁo$EÁbÏIÁV[ÁJôÁ?:îÁ4™øÁ*b Á xÁT—Á ÛÁåÀî+2Àܧ¼ÀÍPÀºÒÀª8ÊÀ›ÐÚÀ&ŒÀ}QÀgš ÀLW¹À7SWÀ(H/ÀºIÀ rÀð<ÀfÀõÀ :òÀ ?§À ™ÎÀ“&ÀÊåÀ#1ÍÀ-ÒÀ8„ ÀHkéÀZ‘´Àp…À…BÀ‘^ÉÀŸsÑÀ².LÀÆÀ×›Àè%Àù+aÁ6‚ÁqÁC~Á$ÃAÁ/ éÁ8íðÁCœÈÁNûdÁZîcÁg^ÈÁt9lÁ€±Á‡iÁ€ÖÁ• õÁMòÁ‰ ”Á‚ÕpÁyUãÁmcÁa.ñÁUÙbÁK$ËÁ@èåÁ6ܹÁ+òGÁ![Á^Á },ÁGåÀøœ‡Àç(PÀÕðaÀÆ´[À¸uÿÀ©bPÀœ †À‘I½ÀƒuÕÀu<Àg•LÀV«ÀKLÀGνÀGTRÀGîZÀIñÀI$ÀJ)†ÀQ'cÀY4­ÀbBˆÀlÜÄÀw&tÀ‚¥ñÀŒ!XÀ•ªYÀ¢fÐÀ¯w>À»{uÀ˰ûÀß%òÀòuÁ°Á €ÁãMÁ©{Á& 4Á0Ç9Á;\äÁEpÀÁOzðÁZ;}Áe˜ÈÁq|²Á}ÔPÁ…GÈÁ‹Ð/Á’=EÁš‹§Á”I‚Á޾Á‡î>ÁÐ=ÁwÍiÁlx@Áa³÷ÁWp,ÁMN|ÁB¢Á7ã Á-ØŸÁ#ðÁmÇÁ æÁ ÊWÁü‹Àñ¯1ÀãWdÀÔ­xÀÆßÀºÌ°À­¸[À¡Ç‘À™’pÀ“‡$À‰ËbÀ…PÀƒÞ®Àƒ¥ˆÀƒó×À„‚#À„ŠèÀ„î†Àˆ_ÌÀŒOhÀµÀ–)À›™À¡sàÀ«rÀ³¼ÊÀ¿ªÖÀÌ»¦ÀØzÀæÉÀøKôÁFÁ[Á·ÕÁ TÁ)FôÁ3óÁ=$ ÁGOêÁQö½Á[ßUÁf ËÁpÚŽÁ|6ÀÁ„ÁŠ(pÁx¦Á–ñÓÁŸˆ¹Á™\ Á“1‹ÁsÁ‡6Á‹¶ÁxFQÁm÷ÀÁcÉ…ÁY/sÁNpÁDT Á:eÛÁ0²ÅÁ'å Á âÁ#Á¡vÁÆÀÿýÌÀðéÀã°ÎÀØÕ,ÀÊÆHÀÀ ®À¸‹»À²À©}À¥xWÀ£ÙUÀ£¢ªÀ£ð‚À¤zÜÀ¤†‹À¤×À¨,ÁÀ¬À°SºÀµ‹ÍÀº^ÀÀ{ÒÀÉc&ÀÒ^øÀÝ zÀéÅøÀöuÑÁ€ŒÁ \RÁŒõÁ‹ÚÁ%kÁ-¬úÁ6Á—ãŸÁ”ŸëÁ‘¯êÁŽÜÁŒc ÁŠUXÁˆ¤™Á‡qÁ†CÁ…[fÁ„ØøÁ„¹Á„Á-Á…ÑÁ…èTÁ†à¸ÁˆAÁŠªÁŒT½ÁŽ»Á‘jPÁ”yÁ—ÓtÁ›UbÁŸjÁ£²Á§fÁ«úÁ°Ì|ÁµÄåÁºÊÄÁ¿üZÁÅFÑÁÊ­ÁÐ>yÁÕöéÁÛË-Á᪴ÁçÿÁí…ÇÁó’,Áùº‹Áÿî?Â¥B‚­ÁúÕ9Áô½¤Áî«çÁ袳ÁâµÁÜÑ’ÁÖö`ÁÑ:;ÁË“ÁÆÁÀ‡MÁ»%ÉÁµÑoÁ°­zÁ«ÁÁ§4Á¢YpÁïOÁ™ÏVÁ•ð7Á’7õÁŽÓÁ‹ÍaÁˆî©Á†YÂÁ„4Á‚}=Á€ð'Á–úÁ~/ïÁ}Á|³jÁ|ýzÁ}ÈüÁ/Á€vÁþêÁƒèÀÁ†3£ÁˆžµÁ‹lÁŽžbÁ’ªÁ•žëÁ™zßÁ¦¥Á¢Á¦ÕCÁ«ÈUÁ°ÉøÁµãPÁ»hÁÀn“ÁÅö{Á˨gÁÑ€Á×eÜÁÝB9Áã-–Áé8hÁï`£Áõ˜bÁûÒÁšÁüòÖÁö¶ŸÁðˆñÁêoÁäX ÁÞO…ÁØgVÁÒÁÌ¿àÁÇ ¶ÁÁkËÁ»Ò'Á¶_ŽÁ± dÁ«Ä¬Á¦³«Á¡ßTÁ7™Á˜ª/Á”dºÁpuÁŒÁÁ‰>îÁ†Áƒ6!Á€‡lÁ|ÊÁy`ÁuóŸÁs‹×Áqñ¹Áp¡¢Áp9RÁpÇÁq¬ƒÁrÖÁtØÔÁwàJÁ{ãÁ€8EÁ‚¶™Á…£²Áˆø0ÁŒvrÁšÁ” =Á˜qˆÁ ÔÁ¡àüÁ¦ÒÇÁ«æNÁ±þÁ¶OîÁ»ÌæÁÁv·ÁÇGÍÁÍ%LÁÓcÁØî,ÁÞöšÁåãÁëXõÁñ•ÓÁ÷åEÁÿ)AÁøæ’Áò¥ÁìtYÁæS:Áà7¿ÁÚÁÔ,ÁÎ2¿ÁÈiBÁ¨4Á¼úÁ·VzÁ±Á¼Á¬\ÄÁ§”Á¡â¢Áœè\Á˜0Á“¢ÕÁ8!Á‹:Á‡]«ÁƒÔªÁ€~ºÁ{îÁuÖÑÁq1mÁmhÎÁj\HÁg³ÄÁe÷-Ád±Ád/äÁdÓDÁeÅ;ÁfíýÁi Ál99ÁpbÁtÜ´ÁzHÁ€oÁƒ‰dÁ‡ÁŠÞœÁèÁ“|GÁ˜'Áœ÷bÁ¢ãÁ§…Á¬WRÁ±ÆîÁ·f¦Á½-ÆÁÂÿOÁÈâ—ÁÎË7ÁÔÐ:ÁÚõ´Áá3Áçr‹ÁíÀßÁôñÁûGSÁôõÁî°aÁèmZÁâ@ÁÜ,BÁÖ£ÁÏü•ÁÉú“ÁÄÁ¾ašÁ¸°&Á³µÁ­bÈÁ§ÚÁ¢…ÂÁQÝÁ˜3¢Á“TÒÁ޾ÁŠPOÁ†5Á‚*^Á} ÁvËÁoï.Áj¹‰Áf¡ÁaðrÁ^Ò(Á\IÁZNžÁY‰ÁX©çÁY5ÖÁZ&\Á[‹7Á]ÄÁa ÁeIåÁiÎVÁoC©Áu™ÝÁ|…÷Áî×Á…ãHÁŠ,DÁަ0Á“QŸÁ˜CÁa$Á¢‹½Á§êõÁ­~Á³7®Á¸ûëÁ¾Þ`ÁÄÉÁÊÉdÁÐë÷Á×*5ÁÝgÐÁã©UÁéö¦ÁðE›Á÷–iÁñ,úÁêÚËÁä”ÁÞPËÁØ%UÁÒaÁËÿ1ÁÅ÷LÁÀpÁº+mÁ´tÁ®Á Á©#,Á£—¡Áž"×Á˜âüÁ“Å–ÁŽÂÁŠ«Á…•ÁNfÁz…"Árú¨Ák¸2ÁeN¼Á_ÛŒÁ[5?ÁVçÉÁS®ÇÁQ ÁO+iÁN2ÁM½sÁN®ÁO äÁPÂÃÁSxÁV—=ÁZª‡Á_YdÁdæeÁk&‰Ár>=ÁzÁ)ÃÁ…iÁ‰ì¾Á޾½Á“ÓÁ˜õ×Áž@ÕÁ£ÄÁ©kÛÁ¯!Á´ýÑÁºìRÁÀçÁÇEÁÍBÃÁÓióÁÙ¡ÝÁßó(ÁæHuÁì™ÅÁôDÁí–EÁç/ZÁàÝëÁÚ–ÃÁÔSMÁÎ*ÆÁÈ¥ÁÂRÁ¼ #Á¶+ŒÁ°c³Áª§¹Á¤óÁŸi£Á™ü©Á”¥…Á~ïÁŠ}lÁ…šõÁ~Áyu{Áq4Ái]<ÁbvÁ[U‡ÁU¡>ÁPê/ÁL‡qÁI$ÁF¨tÁD³ÚÁCà¬ÁC{«ÁCžBÁD™EÁF ;ÁHîŠÁLKoÁP”ŸÁU9ÏÁZ²ÈÁa,QÁh‘÷Áp»ÁyÁ€ÖñÁ…‚7ÁŠ{•Áž Á”ÒDÁšAÁŸÒÁ¥vÁ«HÁ±8ƒÁ·.ÞÁ½DÁÃkËÁɆ¿ÁÏ»ÁÖcÁÜWGÁâ¥òÁèóÁð‘‡ÁêeÁã´]ÁÝRVÁ×wÁлMÁÊyxÁÄUÁ¾>¢Á¸,«Á²<°Á¬uŸÁ¦Ç1Á¡2Á›YÁ•äÁ›{Á‹lÆÁ†fÂÁ‚Áy†ÁpªÛÁhàÁ`ÁXÕÁRaÁL%"ÁGIÁBêLÁ?[[Á<öKÁ;zÁ9áLÁ9m‚Á9ÛÁÁ:ÔoÁ<²ØÁ>ì€ÁB`:ÁFÂfÁKošÁQ)ÁWëçÁ_ŸòÁgèÚÁpDVÁy;ÁoÏÁ†‡"Á‹«SÁ‘•Á–sëÁœ¿Á¡ÇkÁ§´¨Á­‘pÁ³’pÁ¹®iÁ¿ËëÁÅûñÁÌÁæÆrÁàR-ÁÙêÁÓŽ¡ÁÍH5ÁÇHÁÀÈœÁº© Á´’YÁ®„ìÁ¨ŸÁ¢æ8Á=3Á—‘'Á‘þèÁŒ¡Á‡îÁ‚o\Ázý¨ÁqJÁh¿Á_™ÆÁWe5ÁOúöÁI}tÁC‚èÁ>kgÁ: ™Á6rNÁ3¶ÌÁ1¨¬Á0r²Á/îQÁ0~éÁ1NÞÁ3@:Á5¯iÁ9O7Á=¤”ÁBwÁHrŸÁO~&ÁWwÿÁ_ÂÁh>æÁqu¼Á{V›Á‚ÇØÁ‡ûsÁ[iÁ’ÕÁ˜†(ÁžFcÁ¤ –ÁªèÁ°¼Á¶>¥Á¼fÌÁ˜ÁÈÐÁÏÁÕkÁÛÄîÁâ2aÁêÁã@ÁÝ.ÁÖ•PÁÐ(BÁÉÔ`ÁÔ×Á½Y·Á·6„Á±-kÁ« Á¥%ÁŸ:¤Á™‹9Á“à•ÁŽSqÁˆíÁƒ°7Á}=Ás-æÁi›{Á`C/ÁWŽ˜ÁO‘ÁGõLÁAFßÁ;ž‰Á6:‚Á1n*Á-ñÁ+DÁ(âVÁ'ä{Á'mgÁ'܈Á(ŸÜÁ*½ÿÁ-níÁ12>Á5i£Á:qÁ@¬ÁGÓõÁO£tÁWÏ Á`zvÁiìÁsöóÁ~&»Á„h3Á‰ä.Ár°Á•ÖÁšÆIÁ ­¹Á¦ÁuÁ¬äÁ²ü Á¹!¬Á¿LdÁÅ“ËÁËãŽÁÒ:JÁ؆åÁÞÜ'ÁçžÁàk.ÁÙÙRÁÓ`'ÁÌô¤ÁÆŒÁÀ$Á! áÁPêÁ(ÁÜÞÁüjÁ™ËÁi<ÁǽÁÒÁ‹ÁUÁéÁ! "Á'`ïÁ-¬qÁ4¢»Á<5zÁDË&ÁNÁW¦‹Áa³äÁkôÏÁv¼¸Á€ÞÊÁ†q[ÁŒ¶Á‘Ê*Á—«SÁ¼GÁ£¾ÃÁ©Î˜Á°eÁ¶S1Á¼‘ÁÂÀJÁÉ ëÁÏuÁÕúPÁÞ¹ÁØ›ÁÑOÁË 1ÁÄ}ãÁ½ûhÁ·’oÁ±CHÁªùÁ¤ÅeÁžºŒÁ˜ÅNÁ’àÌÁkÁ‡LÎÁÁ}Áxµ5ÁnÁcÆÌÁZfÁP‰êÁG+Á>ŸÁ6ß\Á/PËÁ(béÁ"%ÄÁ Á° Á`ÁE;Á[—ÁðDÁúÁÁ”Á=ÇÁ¹NÁÖÁÚùÁ"qqÁ(÷%Á/ñKÁ7¿&Á@„µÁIj‘ÁS«Á\ãœÁg>ÅÁq´Á|vÿÁƒÎwÁ‰hgÁ/BÁ•*¶Á›åÁ¡âÁ§xÁ­N'Á³"Á¹¬:Á¿î·ÁÆQ?ÁÌÐÓÁÓCþÁÜ=¥ÁÕÏÁÎô³ÁÈržÁÁøÌÁ»cÁµãÁ®ÅÌÁ¨‰‰Á¢Q„Áœ-©Á–3wÁUøÁŠ}RÁ„ÇÁ~hPÁs¥"Ái@Á^¡ƒÁTô`ÁKÃåÁBŸwÁ:ÒÁ2EùÁ*â]Á$ ŒÁLßÁP¬ÁWÁ2'Á›Á ðÁ Ò<Á B¢Á àÁ ‰ÉÁ AÁLqÁ¶TÁžÁhãÁ$Æ1Á+©~Á3¥Á<“ÁEéÁNm½ÁXFBÁb–+Ám‰ÁwìfÁfÁ‡dÁŒØ½Á’ªdÁ˜ÁžqIÁ¤‹wÁªÊÁ°Ú0Á·dÁ½hôÁÃàŠÁÊ:ÍÁЧPÁÙÚÙÁÓ2ÂÁÌ<ÁÅúÁ¿ëÁ¹ôÁ²¦\Á¬WXÁ¦ ÆÁŸïÁ™Î¶Á“¸EÁÊXÁˆXÁ‚KDÁy“Ánü Ád|UÁZI½ÁP”ÁGr Á>yÁ6¡Á.®|Á'¡MÁ ðxÁk¢Á¿Á &ÁÎÊÁ c^Á RÕÁ i Áó±Á W¨Á OöÁ õüÁ»ãÁ^XÁ€ÁÕ2Á!º‘Á(¬3Á0y„Á8­RÁA`¿ÁJ™ÁT‚/Á^¿GÁhñÁsIŸÁ~7Á„Ô,ÁФ ÁD®Á–#ÁœëÁ¢M‡Á¨TÁ®z‰Á´ÅŸÁ»*oÁÁnþÁÇÑçÁÎQ ÁÕ‰/Áϵ½Áɲ\ÁÃÈÊÁ½?vÁ¶Ð-Á°o—ÁªÑÁ£ÔRÁ¬7Á—‹³Á‘†ïÁ‹ŽÁ…½ïÁ€óÁu*÷Áj†ÎÁ`CeÁV1ÁLÄ?ÁCÒ*Á;'Á2ð†Á+•GÁ$ÃdÁPÏÁÏÁ$ÁR^Á OúÁ ýÁ :)ÁAmÁ´ØÁ×ÏÁñ‚Á šaÁ ßwÁE°Á£AÁòÁ‚÷Á&.pÁ-ªÄÁ5¾žÁ>‡uÁG ÁQÏÁZ÷‚ÁdîIÁoqåÁz…Á‚ê ÁˆvÁŽ(%Á”XÁš àÁ &ßÁ¦3rÁ¬`õÁ²¥žÁ¸éTÁ¿?lÁÅ´jÁÌE^ÁÏ™dÁÊ@‡ÁÄrlÁ¾j Á¸‡öÁ²ÏüÁ­FDÁ§ïdÁ¡×—Á›¬µÁ•˜ Á>Á‰¬ÔÁƒÛ Á|dÁq‹ÎÁfð(Á\ÂçÁRå·ÁIaFÁ@™Á8 ÇÁ0>äÁ)3ÚÁ"z¢Á¤Á†ãÁüÑÁmÏÁ a Á DñÁØÁלÁx×Á¾*ÁD-Á ÍÁ m¿ÁPnÁSâÁ]lÁÙˆÁ$(‘Á+2Á3WpÁ<ÁDÝ–ÁNCJÁWùÁaõäÁliiÁwA„Á%™Á†©IÁŒXýÁ’6©Á˜@ßÁž#íÁ¤/jÁªd.Á°­TÁ¶ùHÁ½_ûÁÃãÁÊMÁÉ͵ÁÄMéÁ¾øÁ¹0±Á³"¸Á­=+Á§„OÁ¡üáÁœ¬Á——¿Á’•˜ÁdiÁˆ ØÁ‚T;ÁyjbÁn~Ád#çÁZïÁPy1ÁGˆÁ>ScÁ6~Á.WÑÁ'ŒtÁ!uÁ‘­ÁoÁaqÁjÁ u‚Á ˆyÁ ÂÁc.Á{Á.ËÁåÀÁ QÁ UÁP`ÁçrÁ†ÉÁÅÁ#Á)ð›Á1£õÁ9ç˜ÁBnLÁK½°ÁUšÖÁ_n%Ái‹Át*Á Á…©ÁЏjÁ£/Á–nÁœ]Á¢xŸÁ¨·ÂÁ®ßŠÁ´@ÚÁ¹¸­Á¿^ÁÅÁÄ)»Á¾€CÁ¹Á³¯ÞÁ­ðÛÁ§ÜÁ¡ó%Áœ9NÁ–´‡Á‘jØÁŒa»Á‡LÛÁ‚"Áz ÔÁpNAÁg,Á^ÏýÁV›¶ÁN‹ÁDùÁÁŒ1úÁ†œÁ€»Át¼\ÁiÉgÁ_rœÁU‘oÁJìÁ@ÂöÁ6Ê?Á-”iÁ%Z©ÁùÿÁŽ*Á QgÁiäÁÀóûÆÀéŠÀà5ÀØ&ÀÑýµÀÌ-¥ÀÆiŒÀ¿§æÀºEÀ¸? À·ð½À»¿§ÀÀÞ‰ÀÉÊ ÀÔ±vÀà?EÀíŠæÀùð6Á_…Á õeÁuAÁ9Á îÁ)²Á2°Á;áÁEÉ?ÁO‡°ÁYÕeÁd´ÁnwvÁxÕUÁ·’Á‡ÁŒŠpÁ’.4Á—ì0Á­\Á£”yÁ©§šÁ¯â1Á¯@ Á©5Á¢á§ÁœÕ¨Á–ø5Á‘NòÁ‹à6Á†’§Á€äÁu­éÁi®mÁ^00ÁSHJÁI3Á>ûçÁ4c¬Á*IŽÁ qãÁíÁ–ÁÖ—Àýé[Àð‘Àâ”\ÀÖLËÀËÀÁœiÀ¹…°À²ªºÀ¬™sÀ¦ê<À¡M¯ÀœÀ™ªÀ™K‰ÀDôÀ¢¥!À¬¢À¶ÿAÀÞéÀÏøÀÜžãÀé„áÀ÷™Á{Á OÁ; ÁÑ»Á%qzÁ/…[Á9=ÁCZÄÁM—[ÁWî½ÁbNCÁlÜßÁw§íÁ@õÁ†ãóÁŒ¡uÁ’c Á˜N®Áži Á¤­Áªî˜Áª"SÁ£ücÁàåÁ—¡ÛÁ‘ŽÉÁ‹­jÁ†LÁ€š…ÁváÁk/oÁ_:%ÁS*pÁG¨¤Á<εÁ2¶,Á(fcÁâÁÖPÁ 1ÁÀKÀó/ÀáÃÈÀÓG°ÀÅn¼À¸èZÀ¬ïŽÀ£(èÀš‰tÀ“\“ÀBÀ‡o7À‚“’ÀyðÉÀuãÑÀu&À}š›À…!ˆÀÕõÀ™ŠöÀ¦Y®À²† À¿TÀÌ9ÀÛljÀê®xÀú²*Á¿ÁbÁBÁ"½<Á,å5Á7íÁAfDÁKÇÌÁVK¹Áa\Ákñ‘Áw5sÁW Á‡éÁ ’Á“-7Á™{ÙÁŸ¤}Á¥3Á¥??ÁžèïÁ˜ºšÁ’®”ÁŒd·Á†I€Á€c™Áuu`Áj«€Á_þ#ÁT–âÁHÐOÁ<­MÁ1'}Á&_¶ÁfçÁÐçÁeàÀúÙÀè*ÀØÀÆÉWÀ¶‚®À¨ÒýÀ›0ÈÀ‰À„»|Àw- ÀhtÀZåÛÀO÷ÒÀFâÀ;–À7×À7´çÀAÂÀÀPn²Àb-ÀxäkÀˆ8À•&¼À¢)ÇÀ°X¡À¿¾<ÀÎô€Àß§CÀñ’°ÁõÁ s ÁvüÁ ¦åÁ*Þ[Á5B)Á?½JÁJŒÍÁUd«Á`¥¬ÁlèÁw£ùÁÈ–Á‡ôÇÁŽO—Á”[TÁšK¸Á iûÁ œ)ÁšÁ“³ Á{!Á‡s"Á*ëÁv }Áj6Á^äàÁT$ZÁIn‚Á>Á2m”Á&7>Á¯NÁ?Á$¢Àöw9ÀáánÀÎ%À¼qRÀ¬¹ÀšœŽÀŒ¨À|2ÀbÜìÀLŸ5À9¢ØÀ)ÿ•À@À}Àm«¿úMê¿óã¿ó!ÙÀ[GÀK8À%À>RòÀV9IÀoÝÿÀ…8À”à•À£VVÀ³ÔzÀÅSNÀÙ´ÀìcÁôÁ ?]ÁZàÁ½´Á)3µÁ4Á>ÜoÁJxÁU›ÁaÁm©ÁyOÁƒ)ƒÁ‰YÁ Á•/ÃÁ›„ÁœxÁ•†èÁŽðÛÁˆ€Á‚>”Áx]žÁkêÙÁ_‹>ÁS¨=ÁHXÁ= oÁ2ã,Á'k}ÁæPÁÂ}Á; ÀójhÀßx&ÀÉT2ÀµyÀ¡¸/À‘4^À€O&À^•¨ÀCÒÀ'±-À:u¿ù¡*¿ØR›¿¼Æ”¿¤Ð¿’ʤ¿zæ(¿qè«¿oÛÅ¿ p¿­ пÕÀ‹À[2À5ÜûÀRÈAÀq ÀˆÀ™†À¬AÛÀ¿à=ÀÓz—Àç×#Àû¿1Á;Á±9Á}+Á(Z£Á3’.Á?oÁJƒÁV›QÁc$=Áp/Á{™ºÁƒÈ×Á‰ù(ÁWÁ–Ü×Á—vsÁùÁŠ{6ÁƒÔ,ÁzªûÁn ‰ÁaÙÃÁU‹-ÁI Á=çÁ1Ð+Á'!Á]üÁÚmÁGÀòžÀÛ“•ÀÆîûÀ²V‚ÀœB§ÀˆmãÀk¼ÀÀKõFÀ'îÀ €(¿Û°¿¨%¸¿Öï¿9C¾ÿ3°¾™+¾%Ï”»˜>É<}6¯<À䉾 6A¾Åô»¿?Ê ¿ŽÍ¿Â¡¹¿ø†ÀütÀ8ƒÃÀ[®ÀªyÀ“_ÁÀ¦Õ­À»T-ÀÎã¼ÀãvIÀøoQÁýBÁàGÁìÁ( Á4 µÁ@-©ÁLÖÁYWÁe¢Áq'Á}Ž;Á…3 Á‹È«Á’‚eÁ’å1ÁŒU Á…×óÁ~ÔyÁq‚(ÁdaAÁW£¾ÁK\KÁ?:ÊÁ2 ŒÁ&›áÁOˆÁ¨ZÁâ ÀôyÀÝR ÀÅ»NÀ®¶rÀšt»À…HsÀ^¯¤À8t·À¸#¿ç¿ ·%¿R^¨¾ÊÍ ½F¸>z"Á>õ£¡?0!u?R­?x…-?{Aó?{ê?TIô?9Ž>=VL¾H‡¿xW¿Š%Z¿ÅÜEÀujÀ(KFÀMÃþÀtÀŽ®ÉÀ¢9ÜÀ¶€VÀË‹xÀá ªÀöá+Áœ9ÁÁ”ºÁ)͈Á6”`ÁC+ÁNŒ¯ÁZ¤|Ág5ñÁt.DÁ€¾öÁ‡ŒÁŽwýÁŽšàÁ‡Ö7Á5žÁumÚÁh‰ýÁ[tôÁN*wÁAI0Á4ç—Á(ÿ¾Á=îÁ"!ÁÙÂÀôsôÀÞééÀǘÀ°5À˜¦ ÀæšÀ[ôõÀ0ÏÀÂý¿Àëæ¿xþc¾Ø¼[=šVM? g?ee?™Q?ºe?Öa?èÇ?ùŠ?úQV?øæ|?å°½?¼ÛÅ?ŽØ?5<>‹ù•¾YòÚ¿5Bi¿¢ùܿ饶À‘¡ÀD-ñÀkóáÀ‰ÉÀžÂ°À´AûÀÊ%XÀànØÀ÷,‚Á(ûÁ€EÁ TqÁ,ƒeÁ8ÃÁD<`ÁPí8Á^ ¢Ák…OÁyKmÁƒ™ÁŠŒ›ÁФØÁƒ¬Áy¥æÁl=ÅÁ_+ìÁRJéÁEvñÁ8 xÁ+ÁbÁ«ëÁð(ÀómÀÜêöÀǹÏÀ²C+Àš´‰À‚Ü·ÀVùÀ*rÀÈG¿®jÇ¿7¾?v>Èz??u°P?³Þû?êè@ ‘ @Õ:@#X²@$åØ@#@!ùo@"âh@$®@5Ï@Qp?ÍA ?‘R?%&=«Ù¾îž–¿…4±¿Ö:4ÀSÖÀ9Û­Àdi©À‡¸OÀ«ZÀ³àKÀÊzUÀᤲÀús»Á ŸÁ 6Á!œÐÁ-âæÁ:¹¥ÁH4ÁU¯ÆÁc’€Áqw¨Á]pÁ†ŽŽÁ†§±Á±›Áqž•Ác½–ÁV(fÁHîfÁ< üÁ/LÁ" jÁÓ©Á)ÖÀø‹HÀ߇lÀÆÇ.À°^]À›@2À…¸ÜÀ\,éÀ+R¿ùy>¿¢‰:¿%A:=?(ëƒ? €?ã~Ô@ ¼@#{@%D@&>F@&æ@%«$@$"õ@"šÇ@$#…@%ï/@'N»@'°f@#›?ý?Æ?¸÷?aÛY>¢&(¾ch¿r&ü¿ÄWRÀ ¤}À7¡×ÀcÀ‡ÆøÀž¢Àµ-ÚÀÍæúÀçTÀÿ2»Á 8¦Áž‰Á$£ÆÁ2%pÁ?üÅÁMÞ¢Á[Á¤Ái“Áw4lÁ‚xÁ‚—€ÁwZMÁià Á\ÏÁMý"Á@3nÁ2È.Á%ÐSÁÁ jÀýšìÀããÚÀËòDÀ³¢‘Àš{À„>0À^©À2]À,¿¢?ü¿ Ÿ=õwé?AÌt?·û·@0I@#Ó@#!ï@$|@$}×@$Ñ@%Š@&L|@$ÄN@#˜÷@%d¡@&¢õ@&R­@&ñ @)°@)Æi@&Ò?Õµ?ˆ‘¡>ä7n¾H,«¿[zº¿Ã¥À À9t¤ÀdÊxÀˆÌ„À¡ZTÀ»oÀÒj‚Àé׌Áz-Á¹eÁwªÁ*S€Á81ÁF‡ÁS±“ÁaZ†ÁoDÙÁ}n2Á}ÎyÁoŒÖÁa‡ÁSÉ5ÁF7ÜÁ8ZÑÁ*keÁÄðÁšäÁÙÃÀì!0ÀѰÖÀ·ÚOÀŸ¸ÀˆdáÀ]êºÀ2RÀ¯£¿²“4¿(¬|>¶}?JzöO­¾B¸f¿^ª¸¿ÈiˆÀ”ØÀ9*5Ài¤¯ÀŽ•€À¥Ð`À½BÀ×0Àò#œÁá>ÁµÍÁ"Ž/Á0<ÌÁ=×wÁK«^ÁYË{Áh)æÁv9BÁw?Áh–…ÁZUÁKà¼Á=êèÁ0C²Á"®“ÁÂùÁõÉÀóšÀÙ\À¿ÏÀ¥ÐÅÀŒMÀh1À:ž¿À ï„¿¿1Ö¿L^(¼þ&,?89™?¹” @«¨@BŸ@!B@!$?@!o@ þ·@!v@!ÃÅ@"ÒL@#àÓ@$ïZ@%Kj@$û"@$ªÚ@$Z’@%r”@&ç–@'Ê;@(¬ß@)ƒ@*&?éE®?’À”>ñ^!¾iÚÕ¿j6·¿ÃæÂÀ/ÄÀD&cÀs.9À‘ÚãÀ«èõÀÇDÓÀâÂcÀþS)Á à·ÁpôÁ(%/Á66÷ÁD”fÁR©eÁ`Án¸ÁqCfÁbvÁS©SÁDôZÁ6wÁ(@ÁbvÁ ÃHÀþ8ºÀâ‘ÀÇtJÀ­c"À“µÀt ÀBOóÀ·¿Ê õ¿[»j¾HöÎ? %?§7š@Vž@ƾ@²h@”—@vÆ@Xö@@@YU@ gÜ@!vc@"¨ò@#è™@$2x@#íð@#©h@#^„@$&Ë@% X@&.@'Ý@(‹@)&Æ@gá?ä³å?R>ÔÜ-¾rß ¿l¿×uÀÆ©ÀOÀÕÿÀœÑ²À¸kÀÓl9ÀîcjÁÁÍÁºùÁ!ÍÁ//öÁ<ûÑÁK€ÁY{âÁh‘Ák‹&Á\‹ÁMÃüÁ>ô@Á0$¹Á!buÁßUÁ³åÀíæíÀÒš%À·6ßÀœ'eÀ‚(ÈÀPØÀ`”¿Û,«¿€$z¾•n3>àŽ{?’Ž?ð¾l@ -@m @;³@ [@Ù@«}@¬@?@Aæ@ Ž@!Á5@#Ü@#¼@"Í4@"ˆ«@"ã @#I;@$-]@%4 @&:º@'Ai@(Mƒ@)\@«½?×ñ{?€Ž×>Ÿ-¾¾Ì´â¿–*È¿ûUéÀ1þUÀf‚ØÀë[À¨‘—ÀÃN"ÀÞÝçÀû{WÁ ÞÁ€±Á'ŽŽÁ5îÆÁDKÁSbÂÁb_*ÁfµÁW ŽÁHÚÁ93ŽÁ*\ÃÁ‹ùÁ »ÀûÝAÀÞË‹ÀÂ¥ËÀ§ADÀ‹á3ÀaʦÀ/5Ë¿ý|¹¿˜#ï¾òŠ>gbo?t‰%?×y@kƒ@†(@ƒ@[@)­@øV@Æþ@÷ä@´@ŽÂ@™Ð@ Ùw@"@!ñ@"¶@"n>@"ÕÆ@#ú­I¾a<¿O´¿ò® À,íÕÀbè¯À'<À¦›ÅÀÁòNÀÞ‡ùÀûð=Á ôÁ$¤Á+z‚Á:ìçÁJuLÁZþÁ]éîÁNE.Á>¯”Á/-)ÁÄÁz”Á]ñÀäþKÀǵ&Àª×iÀ´3À`ýVÀ(¿æHÕ¿€ V¾Ð'>Ö*^?Â?鯙@/@E¡@`Ö@| @ˆp@hQ@íÅ@}š@ o@Üî@·"@‘V@ L@Ë2@!)@!ì.@"S¶@"»>@#"­@#‡ü@#íK@$*}@$ ð@$ôî@%Èí@&œì@'Éð@) ?À£Ñ?Jzâ=”¤¿?º ¿ÉsíÀGÀFµÂÀzçÀ™áÀ¶z7ÀÔœÀó81Á ÒÁ¥ÙÁ(MSÁ8ÁG¿ÜÁWƒoÁ[vÁÁK¡ØÁ;Ô=Á,óÁWËÁ ¯ÖÀú@Ý‹@ì¡@Õ@# @>>@>X@ø‹@ˆ`@5@ñ@ËR@1m@ÀÛ@j*@»!@! @"Fq@"­ù@#@#{"@#Õ;@#¥Z@#uy@#8@$U7@%)5@&]¸@ú’?ÞûY?†Î]>»ÙžÉò"¿”Ë¿÷ŸÀ.T™ÀfîÀ‘9×À¯µÀΗÀí·ïÁ€ßÁ3•Á%áôÁ5¡ÁE2åÁTË'ÁY~´ÁIÆÁ:ÛÁ*H]ÁqÁ ×Àõ¡ÀÖzÀ¶²HÀ—æÀq¸ëÀ6$ô¿ýä(¿—…ξÏOÞ>¨ËÛ?†mW?à™»@…=@‹‰@šC@®Õ@Ê @@@‚S@èf@“&@+@N@CŽ@Òý@bk@ "@Z@«@ ü @"M@#=@#nH@#P@# 7@"ðV@"Àu@"á@#µ@$ñ@&Z¹?÷=n? íÁ?ðê¾0bÉ¿j"O¿Ôˆ™ÀKÀZ;>À‹³ÌÀª¶ËÀÉÖåÀèåÀÁà7Á\ÉÁ"ä=Á2vpÁB³ÁQÊóÁWC·ÁGgœÁ7‘¼Á'ÃÚÁuÁK1ÀñP@ÀÒ'€À³&,À”dúÀlQÀ0š¿îF¿€7$¾hßš?2Á?žÚ?ø´ @â:@‡¼@HA@Vú@q@`;@ÆN@,a@’t@?J@U°@å@t–@B~@t@d¡@­¥@öª@!?¯@"ˆ´@"åî@"Å|@"›@"k4@";S@" q@"AÉ@#¦Ž@%o@á¤?°Ëí?8Lí¼V(f¿A9Ë¿ÈYÀ/³ÀT&À‡EÀ¥HåÀÃÌJÀâ·ÍÁógÁ¡¼Á `4Á0*{Á?ý¨ÁOײÁV3âÁFB Á6R«Á&f~Á~†Áœ@ÀíƒëÀÍæ¬À®mvÀ0 À`À¯À$óW¿Úy‹¿d«ñ½Ë®£?#"²?­ŸV@8Ù@?7@ä¹@Š:@/¼@>#@¤6@A@_ù@¹±@Ï+@Õ@¬ž@„%@[¬@32@P‰@™Ž@â’@!+—@!@!¿s@!¹à@!™m@!xú@!X‡@!8@!„—@"ë‰@$¤%@.É?¸G¤?EZ >zq¿'µQ¿»«ÀJfÀJ6BÀ‚îÀ¡–›ÀÀ®ÿÀà¦Àÿ‹ŽÁ•ÁnÁ/N+Á?3•ÁOÁVURÁFf)Á6yóÁ&‘‡Á®ÁÑoÀíütÀÎq¬À¯tÀòaÀbg›À&|ê¿ÛÇ¿\¿Å½k4|?.OŠ?²÷@ñ@ƽ@kU@í@Îò@Ê9@‚Ù@Ü‘@6I@@“-@(@½@R@tÙ@L`@?$¼:ÿf?¿;’¿Æ{@ÀGIÀNÜaÀ„°‰À¢û\ÀÁÒÒÀàýÁ.Áï-Á¼ÑÁ/“Á?q&ÁOTÁVìÁGßÁ7_Á'6‹ÁYÝÁ…}ÀïylÀÐ ¡À°Í›À‘æÀg1ÞÀ,œ¿ëጿ„=Ô¾xL“?’?œJù?ö±n@æÛ@ç±@è”@év@Þ9@Ò@Åä@âé@<¢@2@°"@E@Ú@nò@â@~@Ý¢@=5@œÉ@ü]@*@+å@< @‘ÿ@Ë0@!K@"5ˆ@#hÅ@ÊU?áCË?’ê¿?8½ÐîÝ¿Sñ¿Ô&¯À*mÀV'Àˆ±À¥ì®ÀÄMÀãÄÁäÁÄÁÁ }3Á0B†Á@ŽÁOèÁXfôÁH™åÁ8ÕšÁ)‡ÁrÁ Û^Àô¾iÀÕé_À·3À˜®*ÀtþïÀ:OÄÀ&¿£Ò&¾í"\>ˆãÁ?u¤ª?Ò•ä@¢@ôó@õÖ@ôc@è9@Ü@Ïä@Ä0@ò@ß5@t%@ @¯8@hÝ@"‚@o3@­Ê@ ý@k‘@Ë%@äg@õ"@[@•{@®:@ å¿@"(>@#j¾@Oö?½¢ò?eH²>˜nq¾¨ ¿„¢Ã¿ç]úÀ&tžÀ^•ÀŒ÷†À«fÀÊ>âÀé'#Áð^ÁW®Á"Ð’Á2aJÁBÁQµÁZìÁKmÒÁ;èóÁ,ctÁáÁ d£ÀûÝ6ÀÝ*À¾ä\À¡IÈÀ„¸ÕÀQ3!À”¿ÐcA¿Ysǽ°œS?U£? ûW?ñðÑ@5@@þc@ò9@æ@Ùä@ͺ@éB@¦Å@`i@@Ó³@X@-¤@l;@ªÓ@éj@:Y@™í@­¤@p·@„×@˜÷@¯†@ Êþ@"M@ Ç?Ó ? 8?¾à»ü웿-¿¤Ù§Àw|À6áLÀmÏÀ“3ÓÀ°´cÀÎóRÀí§üÁUÁð¹Á%Ÿ”Á5\œÁE"ñÁT²ºÁ^ЦÁOøÁ?~[Á0 $Á ³}Á€Á}µÀç~¡ÀÊ¿À®JÀ‘ÛÕÀlÚ™À8íxÀk¿0Ü¿„> Ü?E·¡?±Ê÷@'U@Z@c@ü8@ã…@½Þ@˜7@¢-@@@@>‰@ø.@±Ó@*¬@iC@§Û@ær@% @f&@`@t3@ˆS@œr@°Ó@ ÌJ@âH?ÛîB?™åB?/)±>rÙ¾ÆË¿}M¿Ó©À9ËÀM8À‚ .Àž…žÀ»!ÏÀ×ü˜Àõ«Á ׬ÁßÁ({¨Á7úÁGÁW/éÁb^ðÁS OÁCÕkÁ4ÁEÁ%ÙWÁ*¶ÁÇ(Àõ øÀØ‹ÑÀ¼Š5À¡š»À†ýÔÀW4|À"$ù¿ç °¿Š ӾРe>aE?Tl?¶¤?þ+@¡°@Œc@f¼@A@.U@¢@ì @gÌ@ã‹@_J@Û @:Â@“_@ëü@D™@5@bø@¸@ƒ¯@‹Î@Ÿî@´@Ù>?à$Ç?l?7!>[§©¾¥®3¿fíý¿Ê5À vÆÀ;‰rÀniñÀ´À«@‚ÀÇ„ÀäU‡Á–ÁþÁÐ(Á,ÈtÁ;ì:ÁK1ÃÁZ‘ûÁg)üÁX.eÁIZäÁ:¹Á,UkÁªÁÑýÁ²JÀèkÀÍqÀ±À•U,ÀvâÀDü¤À<é¿Ð*œ¿€dO¾¼Ú>e%i?J…§?«‘*?í”h@n @éó@ÄK@ É@a@Ę@@X@¼@7Ö@˜s@Ü™@56@Ó@æp@? @|Î@Òî@Úß@ÐÖ@ÆÍ@ ½?Ø,Ý?˜Xü?.,–>I’˜¾—X±¿Vgæ¿·.ÇÀgÏÀ3ÅüÀ_CºÀˆ=9À¢‘ZÀ¼ ÀÖHÀñ—Á ËÁ|(Á#îÜÁ2kQÁAÁPÁ_ lÁlñRÁ^YÁOö³ÁA·Á3cBÁ%0ùÁZGÁ ÔËÀ÷ÄuÀÛ“MÀÀaÀ¦ÈÀ³ Àj™ÚÀ:—©ÀS¿Õ¤+¿| ‚¾åPA=ÿ“ª?(~å?“[w?ÑÓ®@©@™ñ@í=@@Š@$@ã@”£@òó@P$@@× @/ª@ˆF@@‚@–£@ìÃ@2@(@Ép?Ë R?Œ¡?Õ>õù¾«0/¿[Y¿µfÀ»”À'aPÀQ‹ŸÀ‚OsÀšë)À³XùÀÍÎ Àè2¿Áâ‹ÁRÁ=Á*†‹Á8ú ÁGn×ÁUéÄÁd‘°Ás£ÁedJÁVõÁH¶ÂÁ:ÀáÁ-!èÁZ&Á:ÁÁgÀì@”ÀÒë1À¹Ç_À¡FËÀˆáÀe€ÀAÀÀ6¦¿Ú¿’â'¿ ½ƒì5>Ûßµ?dí~?©äÞ?Þ! @ÛP@þ@u°@ðB@Ms@ª¥@M@EÍ@…L@Ñ@*@ZW@°x@˜@ ï]?ä×?¯Óž?lØç>å¾5»os¾ø´c¿}‚0¿Èí¯À 8ÙÀ0²*ÀX™ÏÀ{5ÃÀ“¤"À¬Ò@ÀÇŒÀßDÀù7¨Á 1|Áô4Á$$¤Á1Ë]Á?Ï ÁNóÁ\kÁk@Áz‡ Ál@qÁ^5“ÁPr-ÁBÀ…Á4ÂùÁ&Û,ÁOrÁ HIÀÿXŸÀæM˜ÀÍ·öÀµDoÀžà-À‹¦·ÀmQ6ÀCÀŒ“¿ò¿°5Œ¿Q펾®1é=ø¤¦? xÅ?qS~?¦®?Ñ¢ƒ?÷ þ@ _¿@Ž+@bV@¼ @û‹@; @z‹@ƒ#@  ?úO¦?×¼ß?°ðv?„þ°?' ø>h×¾tÞ~¿-:¸¿˜…¿ÝÌTÀöÿÀ6äÐÀ]ÎÞÀƒ±nÀ–ePÀ©?»À¿œ;ÀØhÀòÑ0ÁДÁ’ÚÁêÁ-*ÇÁ:(eÁG– ÁU^ŽÁcqoÁqÁ¯Á€ÙGÁsÒÁf ÁXNeÁJiüÁ<·´Á/f–Á"‘ Á÷ËÁ sÀú`íÀáÿØÀËrÀ·{À£i,ÀñîÀqðiÀN»À,{ÀÀ "¿Ê™¿ŒtS¿3hC¾€äó=Ý”>ö÷ð?G'?ˆ1®?¤”?»»ü?Éß?Ï&K?ͨÒ?ÇP¢?Àç?´Ù~?£ò?Œæ`?Z/²?=>€%µ½énv¿º¿ry¿¸T¿ÿA8À!h)ÀCYÉÀf–À…ܰÀ™ãÈÀ¯E‚ÀÁÀôÀÕƒÀìÛÁGäÁE;ÁæÁ(¶¹Á5×ÁCe!ÁPMÇÁ]‹ŸÁk!YÁy“Á„ºíÁ{ÎÁmû§Á`>ÁR½¦ÁEœÙÁ8èmÁ,OûÁèpÁ”0ÁsÜÀøY[ÀäÛÀÐ1ÌÀºÃwÀ¥EIÀ’"À€Ì!À^=À:JYÀ\m¿òßÞ¿Â冿ÏÌ¿91Ⱦ»‡™½®Š¯>:A >ÄÄw? ÞC?&´'?1ÜÌÆ>K½}œ¾‰ŒÙ¿Êß¿bKÅ¿¥”%¿Ü1À³À1¾…ÀUgÀvmèÀŒÀžjÀ±–ÀÅÜÀÛz$ÀíÏÁaÁ crÁ…Á%O}Á2ƒ>Á>÷ÙÁKêÖÁYEüÁf‹Ás „Á€…;ÁˆÆ³Áç^Áv5ÁháAÁ[èÍÁOGÎÁB³&Á6W8Á*!ÁôŽÁ©‚ÁPjÀüþ3ÀçÀlÀÑú™À¾ôÀ«ávÀšEbÀˆ¨¹ÀmàæÀJØÓÀ0xpÀ ž¿ûf\¿Îžç¿žÉ>¿v¦ ¿8©¯¿#s¾Ã³Ì¾†mô¾M8о–ëξ ûྚ*¾Ã¼±¿£¿4 3¿qµ¢¿’'F¿³3ÿÞ_PÀ<À ÷gÀ@ ¿ÀeO“ÀƒïÊÀ•ÌÀ¥Î¹À·6@ÀÉËåÀÝÌÑÀòNÁË8Á <ÁƒÌÁ"ѲÁ.Û³Á;}•ÁHš«ÁUMÁb}ÁoJ„Á|͹Á„æuÁŒßlÁ†$ÁÎÁrDtÁe¬ÙÁY"æÁLË;Á@u{Á4};Á)/âÁ±øÁÔÁ iÑÀþáQÀêcÀ×¼ËÀÅ«aÀ´DÀ¢ýµÀÇàÀd2Àh´ÐÀNËÀ6{‡ÀÕÀŠ¿ì™&¿ÏäÍ¿³~y¿¨¿˜ A¿•Û¿£¿¥aò¿¤ò¿¯Ã]¿Àå߿Ӻ£¿î[€À;À¾ÙÀ(¬fÀ@JðÀX /ÀsÔ[ÀІ1ÀžJÀ¯OvÀÀ"ÀÐÞVÀãkÀö ~Á&½Á€›ÁÝ{Á#s¹Á-ûÁ9L2ÁEC:ÁQÄ&Á^·¼Ák°­Áx^‡Á‚´ÛÁ‰bxÁ‘8›Áв‚Á„U©Á| ÁošÐÁcBíÁVòØÁK ;Á?¼pÁ5#Á+-ãÁ ùáÁñ Á ƒãÁý´ÀñwDÀßéQÀÏ ýÀ¼éÀ«´uÀóÀñÀƒÑÀoðoÀU\µÀ@‘2À0‹­À!¥ÊÀ´Àß_À žvÀ ]ÙÀAÀBvÀJ^ÀKÇÀ#¶À(ÒmÀ3'ûÀB/óÀMrÀbSgÀy­dÀ‰ ƒÀ•€À£ê½À¶;ùÀÉã½ÀÚÀ)Àë|–Àü|@Á¡oÁNïÁz˜Á%íIÁ0 Á9Ú¡ÁD|›ÁOÎøÁ[¶uÁh"ÁtìÖÁ Á‡XöÁΪÁ•ÞÁ‹HÁ‰A0Áƒ ÄÁy½NÁmvçÁaœöÁVM8ÁKž¸ÁA’¡Á7ŽÁ,záÁ!ëüÁ9ÁÑ ÁÉÏÀúÀ³ÀéEÀ×-kÀÈÌÀº‘ À¬¡ À %ƒÀ”g·À†ÿÀ{ÅIÀm•ýÀ\0UÀQ°fÀM¨‹ÀJ4ÀH—,ÀNú+ÀOÓóÀPV­ÀVµßÀ]ô„ÀgÐÀp4ÅÀ€À…OÀŽ|fÀ™„ À¦‰1À²³À¿K1ÀÏ4qÀâ~ÎÀõ}yÁ%Á ‚ ÁKõÁÖkÁ'­GÁ1ÚŸÁÁHDŠÁRåâÁ\¦ŽÁfÊ;ÁqyÁ|ä€Á„ZÁŠwÀÁÄÁ—:oÁŸµ|Á™ˆÁ“[ÖÁF\Á‡cðÁ»ˆÁxªÁnpŒÁdv¶ÁY›îÁNáÁDÝ­Á;GdÁ1ÔƒÁ)Á ÙšÁׄÁÁžèÁÂËÀó>ôÀæ4uÀÚð ÀͱÀÂû¾ÀºƒKÀ³éäÀªñZÀ§sàÀ¥ÐÀ¤§IÀ£ôÕÀ¦_ÖÀ¦­tÀ§8[ÀªŠ‘À®RÀ²É7À¶©JÀ¼ô5ÀÃàÀÊ­—ÀÔª»À߯^ÀíŸÀøáõÁãbÁ «ÁÆâÁÐ=Á&zÁ.ÓCÁ7_‰Á@ÅJÁJo8ÁT‚»Á^¹WÁijûÁs Á}LïÁ„Á‰ºRÁtÁ•²ËÁ›ôwÁ¤Ç·Ážœ;Á˜Ž9Á’¯õÁfÁ‡›EÁ‚sÁzä¿Áp1ÁefäÁ[@ÁQ˜1ÁH ÄÁ>ýÁ6±§Á.·Á%¾Áÿ¦Áþ`ÁúOÁÝgÁ÷<À÷/xÀêž¼Àá|ÀÙokÀÑÀ×ÀÊ1ÀÇ‹ÀÅ…}ÀćÀÃÝ>ÀÆ rÀÆQ¶ÀÆÈ|ÀÊ”À͘YÀÒ#ÀÖ8ÀÛÜÂÀã:jÀégÀòÅ©ÀýÁá-Á "3ÁA$ÁMeÁ £ÈÁ*ÈÁ3ïmÁ<\ÌÁD´wÁM†VÁW¡Á`Ñ.Ájô¿Áu62Á·ÊÁ„½ÄÁ‰êDÁYQÁ•¤Ášâ»Á ðÐÂ]›Â?µÁüXÁöIoÁðA8Áê?×ÁäG‘ÁÞTSÁØ~wÁÒÉXÁÍ&ÁÇ›ÀÁÂ-šÁ¼Â¨Á·{-Á²c~Á­zRÁ¨ þÁ£þEÁŸŸÈÁ›p\Á—i¥Á“´~ÁX“ÁY³ÁŠ}Á‡ï½Á…ÐÁ„{Á‚zMÁYÁ€œsÁ€ RÁêßÁ€ÈÁ€iÞÁHUÁ‚f$ÁƒÒlÁ…±HÁ‡èÁŠmÁ+ƒÁ/(Á“ËÁ—AÁ›UÁŸ@Á£ª_Á¨XbÁ­<”Á²,íÁ·H£Á¼—±ÁÂÏÁÇŠ1ÁÍ/ÜÁÒêÁرÚÁÞ•ÛÁä—ÿÁꪺÁðÌNÁöøõÁý)xÂ@øÁþ?=ÁøÁñÙ ÁëÊãÁåÂvÁßÂøÁÙÍ?ÁÓÞÁÎ ëÁÈ`ÁÂËÌÁ½@¤Á·ÏïÁ²f}Á­(Á¨"IÁ£J[Áž…bÁ™ÿ,Á•ÃRÁ‘¸ÁÞ ÁŠ]ÜÁ‡?ÃÁ„] Á±xÁ~ïeÁ{`Áx&ÁuÅÁtWãÁsDUÁsHÁs Ásä Áu—Áw°ÃÁz¯mÁ~¦èÁ®ãÁ„0hÁ‡nÁŠG(ÁÂtÁ‘nÁ•f7Á™®ZÁž@mÁ£6Á¨ ëÁ­ƒÁ²S–Á·«™Á½¶Á¿­ÁÈ„kÁÎX*ÁÔ9öÁÚ.‹Áà4 ÁæRÛÁìƒåÁò·„ÁøÿžÂ1aÁú–ÁóÕðÁí”ÒÁçm8Áá[ðÁÛM„ÁÕP;ÁÏdãÁÉwÁòÁ¾ ¥Á¸uüÁ²ëtÁ­ƒÁ¨%wÁ¢÷¥ÁžÁ™BÁ”–NÁ1ñÁŒäÁˆ?ŠÁ„™ºÁXÁ|ÜÁwNÁr¡ÕÁnð›Ák»–Ái:¶ÁgÂ5Áf¨lÁfF/Áf}ÁgV—Áh×[Ájñ ÁnÇÁrE ÁvùûÁ|&cÁ7Á„ÐÁ‡þÁ‹ÅÁä»Á”U“Á™‹ÁžÁ£ Á¨,dÁ­ièÁ²Ñ+Á¸hÅÁ¾,rÁÄ xÁÉî¥ÁÏÒ‡ÁÕÐ&ÁÛîzÁâ#OÁèZdÁÁõ±ÁüL”Áö×ÁïÁ‚Áé|ŸÁã?ÁÝÛÁ×ÁÐî€ÁÊó¥ÁŸÁ¿;pÁ¹tòÁ³Ò´Á®66Á¨´;Á£XÁž {Á˜ï(Á”ƒÁiñÁŠÝQÁ†¡yÁ‚¾äÁ~'ÁwYtÁq^ˆÁk°ãÁfÈtÁbæEÁ_Ä_Á]"+Á[y[ÁZ$ôÁY±ÞÁZ8oÁ[#øÁ\fOÁ^œìÁað¾ÁfGÁjî±Áp]wÁv·°Á}«íÁ‚iDÁ†XˆÁŠ¡‚Á<%Á”vÁ™îÁž&ØÁ£J‹Á¨£¯Á®0àÁ³íLÁ¹ÊÌÁ¿« ÁÅŠéÁË…wÁÑ¢‰Á×Ú)ÁÞÁä^íÁêÃÁñ §Áø_2ÁñùtÁ묱Áåk1Áß,yÁØü]ÁÒÛ¶ÁÌÀRÁÆ©ÔÁÀ²mÁºÝ•ÁµÙÁ¯Y³Á©¶ˆÁ¤ÏÁž£-Á™W*Á”Á›ÁŠ] Á…ÌqÁfœÁz·\Áse1Ál`QÁf7Á`m°Á[v ÁWU^ÁT"âÁQWÁOzUÁNcÁM•ŠÁNDÈÁO6ùÁPp}ÁRÇBÁVJ%ÁZ©0Á_b¦ÁeÁk¾¢ÁrÅyÁz/¢Á0“Á…£åÁŠSìÁ*OÁ”9aÁ™UÖÁž Á¤ÉÁ©ÐÙÁ¯¡öÁµ}<Á»a·ÁÁXÁÇrÏÁÍ«÷ÁÓê•ÁÚ4¥ÁàöÁæÖxÁí öÁô˜³Áî%HÁç½úÁápdÁÛ,_ÁÔìÊÁÎÈ(Áȶ?Á™ªÁ¼ƒÏÁ¶‘>Á°Ç)Á«âÁ¥cÁŸ¼»Áš#÷Á”À Á‡ÁŠaÁ…{ÒÁ€åIÁxînÁpƒ¯Áhã Áa¥ÝÁZðòÁU9øÁPkÁK÷éÁH‘;ÁE¼vÁCÁ,ÁBŠºÁB ªÁBšìÁC˜¸ÁE ŸÁG†“ÁK:ŽÁO|ŠÁTj¤ÁZg¹Áa-‹Áh^×Áp%;Áx¦nÁ€Ì÷Á…z­ÁŠtQÁ“BÁ”ÆõÁš6¸ÁŸÝ„Á¥ž3Á«p;Á±YãÁ·L³Á½cÜÁÜìÁÉÞ–ÁЯÁÖjõÁܸ.ÁãµÁéexÁðêîÁêtoÁäòÁÝlÁ×O€ÁÑ ŠÁÊÉ«ÁħöÁ¾–Á¸„^Á²€”Á¬•½Á¦Ô‘Á¡!Á›w|Á•ã„Ác{Á‹šÁ…ô‚Á€êfÁxS\Áo}^Áfø‘Á_AÁW€÷ÁPxîÁJv]ÁE‰ ÁAEÁ=i%Á:»2Á8¤?Á7¤EÁ7)“Á7‚àÁ8ŽzÁ:X¨Á<õoÁ@½¾ÁDî»ÁJ ÁOûHÁVÇ¢Á^y¿Áf±§Áo"#Áx#LÁ€é/Á†lÁ‹)½Á„¹Á–qÁ›Æ©Á¡Œ´Á§x+Á­ikÁ³{0Á¹²Á¿äÁÆÁÌaŽÁÒ¶WÁÙ ¾ÁßY²Áå¶ÕÁípÉÁæâ7Áàk™ÁÚ6ÁÓ›§ÁÍNÁÇúÁÀÈÁº¨ôÁ´”?Á®‡Á¨›EÁ¢ÆÁÁ—LøÁ‘°ÁÁŒ=6Á†àÚÁ­XÁyXQÁoŒ'ÁffÁ]ÐhÁUÁMëvÁF½ÙÁ@mŠÁ;EšÁ6É6Á2ü•Á0eÅÁ.J^Á-c´Á,û Á-ÄÁ.;3Á0NÁ2Å"Á6w×Á:î7Á?ÞgÁEíŸÁMPÁU•Á]i+Áf ÁoZDÁy_ÈÁÒ}Á‡;ÁŒ‘Á’$mÁ—Ü$Á÷Á£µnÁ©½Á¯çcÁ¶Á¼+“ÁÂtæÁÈÄÇÁϪÁÕaPÁÛ»+Áâ-Áê)$Á㈱ÁÜù(ÁÖ‚~ÁÐ7Áɽ@ÁÃpöÁ½)ÌÁ¶íƒÁ°ÑÁªºÁ¤² ÁžÖ’Á™!kÁ“iÛÁ®Áˆ$¥Á‚ÕÁ{J¹Áq3½ÁgkpÁ]äWÁU ÆÁLs“ÁDŸÉÁ=°gÁ7>2Á1Ò"Á-emÁ)o6Á&РÁ$ÃÁ#€Á"ø³Á#‡&Á$‚‹Á&i’Á(âíÁ,ÄvÁ1/”Á6TÞÁ<²ÁD*:ÁLiÁT»ÖÁ]§áÁgWsÁqŽ÷Á{áÁƒOXÁˆÃåÁŽhòÁ”ElÁš"ïÁ ¬Á¦(äÁ¬FƒÁ²mòÁ¸¬bÁ¾ïÆÁÅ:£Áˉ…ÁÑâÁØTÊÁÞÄ>ÁæåñÁàIÇÁÙ²ÇÁÓ.BÁ̺ÓÁÆT™Á¿ûÒÁ¹¸Á³rÁ­@ŸÁ§'IÁ¡•Á›fÁ•BVÁ—¿Á‰ì‡Á„R—Á}ÅñÁsr\ÁiQ6Á_eQÁU¹ÖÁL’—ÁD)(Á<OÁ5"Á.â Á)XâÁ$š Á ¼6ÁИÁzŽÁM‡ÁÀºÁI¥Á%ÏÁH”ÁùÇÁ#ù¤Á(VÂÁ-¿,Á4jxÁ<$NÁDcÏÁLÈÄÁUó£Á_ÞoÁjîÁt”ãÁeJÁ…?lÁ‹cÁ¬Á–Œ ÁœœŠÁ¢½×Á¨áÍÁ¯³ÁµC¿Á»ŠÁÁÚÁÈ0«ÁΠŠÁÔôšÁÛdBÁã³MÁÝÆÁÖ|yÁÏéÁÉnöÁÂþ^Á¼“&Á¶DñÁ°þÁ©ÐðÁ£¸ûÁ´Á— `Á‘®3Á‹ï´Á†DïÁ€¦áÁvz·ÁkúÁaÒÁW»nÁN-aÁDêuÁÚÁà£ÛÁÚ ©ÁÓp ÁÌÖðÁÆD½Á¿Í&Á¹b¢Á²üsÁ¬³Á¦‚RÁ W­ÁšPRÁ”dÁŽm^Áˆ•ÁÁ‚æÁzyØÁomOÁdö‡Á[ÌÁPù\ÁG'ÍÁ>zÁ5`Á-x‡Á&~Áè‚Áú”Á*YÁÁj{Á ’Á &¹Á ¨0Á åßÁ þ4Á ö€Áø3ÁDÁýÁeÁ%óÁ-„…Á5u®Á>YVÁH ÁQõ˜Á\i*Ág‚ÁrAÁ}HtÁ„Y­ÁŠI@Á@HÁ–0ÝÁœPmÁ¢‚éÁ¨©ÉÁ®íéÁµNBÁ»€wÁÁÊëÁÈ4†Áε€ÁÕ9¡ÁÝÂDÁ×!ÁЊrÁÉôEÁÃ_ Á¼ÏóÁ¶\sÁ¯úqÁ©œ5Á£[FÁ9eÁ—DÁ‘&nÁ‹AÆÁ…itÁ„JÁtheÁi,¡Á^jÅÁTROÁJ©ùÁ@ÿ¡Á7ÝÊÁ/ssÁ'u Á J‘Á¥#Á‹ÁÎäÁ KNÁ"RÁLÁ±ÁVÞÁ¸CÁïÁ˜½Á ¯¥Á¢6Á·FÁi{Á *Á'lèÁ/‘˜Á8º¼ÁBGøÁLJˆÁVžóÁaJ4Álc«Áw˜‚Á‰Á‡MUÁ*AÁ“:¹Á™^ÑÁŸlÝÁ¥¥0Á¬zÁ²>WÁ¸|"Á¾ÒvÁÅ?ÿÁËÃjÁÒKÁÛ ÁÔkÒÁÍÍÌÁÇ;¹ÁÀªñÁºÊÁ³’0Á­%+Á¦Î…Á {øÁšF‰Á”7qÁŽ4QÁˆMlÁ‚tíÁyf¬ÁnaXÁc„ˆÁXÀ¢ÁN|ÁÁDÈéÁ;2áÁ2ŸÁ)ð›Á"-åÁηÁ ÁzwÁ ·ÔÁ5áÁ ‚ÁöLÀþø¡Àþ÷ÀÿXCÁ˃ÁÝóÁ’¦Á >µÁ†íÁÁOíÁ"‡Á*ô\Á4ùÁ=sVÁGY¦ÁQ’ïÁ\c6ÁgÁr9~Á}v£Á„}­ÁŠyÁy.Á–uÿÁœžsÁ¢ß:Á©'5Á¯J1ÁµŽÁ»ó°ÁÂw£ÁÈú×ÁÏq“ÁØ’KÁÑæÓÁË=mÁÄŸEÁ¾‚Á·“˜Á± Áª’Á¤1Áé]Á—§KÁ‘ÿÁ‹Š6Á…¥ZÁ¢ÔÁt ÁhàÁ^ÁSd%ÁI,ËÁ?®;Á6Y{Á-(»Á$ÒCÁIAÁ "ÁÆÿÁ RÁÁëÀþh°ÀúÃ]Àø+À÷>®À÷‰PÀùÔŠÀþqîÁÏaÁ‰Á @þÁ/ÁÀ«Á6AÁ&Ÿ‚Á/^SÁ8Ô¢ÁB–ÁLßñÁWDÁb#ØÁm:!ÁxwµÁ‚ Á‡ï^ÁÑðÁ“Ô.Á™ò¦Á 8®Á¦M·Á¬†.Á²âàÁ¹`Á¿Ë`ÁÆ;ÎÁÌÈkÁÖ/ØÁÏyÁÁÈÉÖÁÂÁ»€UÁµcÁ®ŠLÁ¨ØÁ¡½ÝÁ›}øÁ•LñÁàÁ‰ÁƒuÁz…²Áo†Ácþ÷ÁYZìÁNÅðÁD‡:Á:âlÁ1Ò\Á(ðxÁ äîÁª•ÁÒÁ }ûÁtÁÊ‚Àþh†ÀùC]Àõ0ÀóäÀò ¼ÀòöTÀôî÷Àø“£Àþ~¥Á1ÁeOÁ òÁ_õÁíÁ"ðÞÁ+œÁ4¯=Á>ÒÁHÁ ÁS3ºÁ]™AÁhqÔÁsÛÓÁ‡=Á…}=Á‹Q,Á‘WyÁ—Œ™Áž Á£ÆñÁªÁ°Š9Á¶Ø­Á½@yÁÃÆRÁÊgNÁÓìaÁÍ+ÁÆr5Á¿ÎÁ¹1/Á²žxÁ¬(eÁ¥¿¬ÁŸ\Á™žÁ’è5ÁŒÂÁ†±KÁ€¯CÁuÁGÁjk%Á_MfÁT½ÁJd‰Á@i Á7 ½Á.(Á%qÁ„åÁƒ Á»;Á †Áð4ÁÃ"Àû&XÀõúøÀò÷Àð—¢Àï»Àïº_Àò=ÀõyæÀúykÁØYÁ«~Á áÁÁD“Á %Á(™ØÁ1’–Á;÷ÁE%ÁNùvÁY_wÁdkmÁoñCÁ{ðÁƒ7,Á‰! Á>%Á•HœÁ›\¢Á¡˜.Á§êúÁ®,{Á´ˆNÁ»eÁÁ…ÁÈPÍÁÐAÁʼ ÁÄZ@Á½§Á·ŸÁ°†›Áª›Á£ž"ÁGjÁ–ö»ÁÆÁŠ©?Á„›Á}\öÁq¥3ÁfZÁ[u ÁPÏÁF±àÁ<ÈÁ3$Á*ÇcÁ"e¦Á©ÁrÁ »¨Á\!Á”˜Àÿ“àÀùNŒÀô­BÀñÏŠÀï´²ÀîõeÀï~®ÀðžšÀôUßÀùLÛÀÿt”ÁÁ K…Á ÀÁÇüÁlýÁ&‘Á.å±Á8"_ÁAÖÁK´MÁV-¿Áa9Ál"CÁw;ÁV€Á‡>ªÁG:Á“=3Á™NwÁŸˆÁ¥Ï Á¬€Á²ŒÁ¹ÿÁ¿Ã»ÁÆ[¿ÁÊKÁÄÎÅÁ¿z4Á¹ÁUÁ³¿éÁ­ß±Á¨&)Á¡ÂAÁ›nlÁ•/‘ÁŽøÁˆâ5Á‚ß]ÁyäMÁng½ÁcÁX8ÁMã5ÁCÜÕÁ:GÕÁ0ù2Á(‰¥Á S¬Á Áf®Á k/Á]¥ÁÍòÀþÒìÀù0 ÀõBeÀòPßÀðÕ†Àð;×ÀðmñÀñæõÀôsýÀù":ÀÿC}Á|ÙÁq•Á9~Á‹ ÁàLÁ$ ñÁ,}Á5„ÌÁ?VÁI>ÜÁSRHÁ]óöÁhÛÌÁsоÁ9ÔÁ…ÌÁ‹ehÁ‘WÁ—y!ÁÀQÁ¤ïÁª]qÁ°ÒÁ·\ìÁ½åÍÁÄ~ÚÁĪ®Á¿ Á¹‹¸Á´9qÁ®v¡Á¨„RÁ¢ óÁœítÁ—o=Á’,PÁ$×Á‡fÙÁwÞÁw!"Ák·½Á`²÷ÁUÏøÁKˆ¨ÁAŒŽÁ8}Á.ÞóÁ&Ž|ÁȦÁ·ÁTÐÁ ¬µÁÙéÁ͸ÀÿšÀú)Àö¢òÀô\MÀòöPÀòIÀòsÀó’¦Àö&MÀú(ÃÀÿΘÁ®Á Á —\ÁðùÁÒÁ"¹¢Á*ÂPÁ3‘"Á=öÁF½£ÁPªáÁ[GŒÁf”ÁqãÁ|kÁ„Á‰ÎJÁÃtÁ•ã¡Áœ\Á¢Z(Á¨´ÒÁ¯ÉÁ´¢6Áº\8ÁÀøÁ¿5žÁ¹eqÁ³ÀNÁ®JdÁ¨ùöÁ£,¡ÁJ_Á—dÁ‘±=ÁŒ72Á†ý´ÁÞÚÁxõeÁnÃÁd÷BÁ[hÁR• ÁIaÁ?©9Á6>õÁ-–CÁ%=Á,rÁ@žÁ=kÁ ËrÁ+ÊÁbÁ-eÀüaÀøåöÀò§Àî&eÀëšîÀ뺫ÀîÂûÀôú2ÀûÁ™Á¤zÁ JÁt¨Á ˆúÁxÁw½Á!õBÁ)¤cÁ23ÑÁ;ˆÀÁEãÁNÙhÁY@ŸÁc¾”ÁnŒ3ÁyÎÁ‚•ûÁˆ[èÁŽGÚÁ“†Á˜Ý1ÁžKÜÁ£À'Á©_”Á¯ÂÁ´Ô1Áº¯nÁ¹ï°Á³óíÁ®!£Á¨}Á£ "Á¼ Á—ã~Á’ nÁŒ(sÁ†vÇÁúÁwªmÁm5©Áb|ÁXh™ÁN°¤ÁEPÓÁ<ÐfÁ4‡-Á+ƱÁ$©ÁØŠÁÎÁx2Á 8lÁæ¡Á4áSÁ)ÄÄÁSÁ¶Á kaÁÏ“ÀöaÀå4ÀÕíÕÀÇ?cÀº:[À¯TVÀ¥QÜÀœ7LÀ”<àÀŒ#ÙÀƒžÀv0àÀhs—Àc ÍÀbzTÀlÿ ÀzÑoÀˆƒ5À”…‡À£TšÀ±á‚ÀÀÃôÀЫÀß­×Àî•+Àþò|ÁyÏÁx#ÁÁ$Í<Á.öŠÁ8ÃÁB¿lÁMGòÁWÜãÁb¿$Ám«ÁxÚÐÁ‚ wÁ‡ÙìÁ‹Á“ÝÁš$õÁ P•Á¦6*Á¥å®ÁŸ•úÁ™nžÁ“ZÛÁ¬Á‡™Á(IÁwÆÁlTÜÁa²¯ÁUšÁIÓúÁ>^|Á3"Á(“ØÁvÜÁ`ÛÁ ™Àÿ_Àí,ÀÜ «ÀÊNÀ¹ÝSÀªxÀœò•ÀòÂÀ†¼¼Àzñ,Àj·ÀZIùÀIÆŠÀ:H«À,tòÀ&1ÛÀ%ýBÀ/ÖþÀ@eBÀVB”ÀqBˆÀ‡=KÀ•eÀ¤ŸfÀ´]{ÀÃä«ÀÓsäÀåUŸÀ÷ÇÁßÕÁ‹kÁ¡õÁ"—@Á,c:Á6æÁA}>ÁL[nÁWK'ÁbtüÁmÕ©ÁyFÅÁ‚lÁˆ³˜ÁôÁ•tÁšýÀÁ¡@Á¡GaÁšÇÁ”m'ÁŽ=bÁˆ;¨ÁîmÁw¦èÁkåÁ`©œÁUø(ÁKNùÁ?ïÁ3GƒÁ'ßßÁ´þÁIbÁuÀú°Àæ 4ÀÓ_¨ÀÁdÀ¯±sÀžAÀŽn)ÀйÀfçÀPêÀ=›&À,žhÀw=À {^¿ü¿œ¿á&t¿ÒοÒiÒ¿å]âÀ½¾À÷“À9ÛÀTýãÀr˜“Àˆ³7À˜£¤À¨ÏÀ¹¹…ÀˤRÀÝ‹àÀð£¾ÁOHÁ ŽÁŠÁ `Á+,ýÁ6ŠÁ@øBÁLðÁWu_ÁbãíÁnÇþÁ{7ÁƒÞýÁ‰Û ÁÉÁ•çÝÁœ2+ÁœéHÁ–>ÃÁ±#Á‰JËÁƒ}ÁzåÁm–ÆÁaN¬ÁU„ÎÁJO<Á?¨šÁ4ö Á(¤oÁÀ<ÁiVÁXÀ÷úâÀãTÀ͈=ÀºùÀ§‡†À•yÀƒU¹ÀdíÀF'´À+rßÀo§ÀV#¿ÝÝ¿½Òö¿ž·±¿ã ¿O)ô¿/h±¿1š¿Xu¿——¿Ç ]¿ÿ‰lÀæõÀ:xžÀZ ƒÀ{¥äÀŽ=À =&À±ÅcÀÄqxÀØÀí1ôÀÿæ(Á ICÁîIÁ¿ÙÁ*·qÁ5ÔaÁA#ÞÁLޝÁX~ÁdÙpÁqx&Á}MóÁ„™ÁŠÀ#Á‘UÁ—’çÁ˜-ýÁ‘ÍÑÁ‹?`Á„¤‘Á|a8ÁoØØÁc¿ÇÁWc‘ÁKzÁ?3¬Á4jÁ)kbÁ± Á:œÁA}ÀõþšÀà+ÀËcBÀ¶‡IÀ¡$:ÀŽPÀvnÀQ}rÀ.CÀ ã*¿áÆ¥¿¯vÅ¿†M}¿BÉp¿ä-¾Šðú½Ká‹>ä³>¿¤>…`à=ež¾ƒ¿,ë>¿Œqƒ¿ÇbÀ2¯À#ÜEÀEŸ2ÀižØÀ†” À˜½ÏÀ« bÀÀ©ÀÓùiÀè:‘Àý”>Á –1ÁÓÁ¥¡Á*æñÁ6LÁB@ÁN“ÐÁ[2ÁfïqÁrÞBÁ?Á†ÁŒÁ“=×Á“œÁëÁ†±&Á€A#ÁsH?ÁfAîÁY ÁMw‰ÁAI¿Á4Ô>Á(÷±ÁÖ–ÁHÐÁpÏÀ÷È­Àß ÓÀÉT>À³Í×ÀžÌÀ‰ºzÀjÍÀC“À"¿ñŠ¿¬C/¿\]g¾èž½Ô<©>J:˜>é  ?2~h?jëË?ŽÅ ?  …?—ù¤?t;?(ÜŽ>o¾R­¿.Éÿ™ !¿Þå3À]ÜÀ6ÝjÀZøÀ¼±À”?FÀ¨FéÀ¼=ÅÀÑ¢ Àç.CÀý$VÁ ›²ÁÇÕÁ "¨Á,xÁ8NdÁDøcÁPŸ1Á\™ëÁiWÁuï§Á”ÁˆV‹Á9JÁW8Áˆ›äÁ‚_Áw/ÁjnÃÁ]QÁP>qÁC€9Á7DóÁ+S!ÁÁ0ÁÚwÁËÿÀúžÀäa,ÀËMµÀ²î™Àœ÷7À‡–›Àd8¯À9ÛìÀŠ-¿Ó󦿇=¿$‘ìwÃ?WX`?“îã?¶sz?ÕeŽ?òÎ@ú_@ ¿š@”?òJÈ?Æö!?‘À?,T©>.ÅP¾ºÍž¿l ¿¾*À“fÀ)š$ÀQ*ÀyT¹Àû¿À¦L„À»Á>ÀÑ©CÀç—5Àý¬BÁ ÁÌÁ" #Á.½÷Á:bRÁFjwÁRùÀÁ_ùsÁmWÁ{®Á„lUÁ‹WûÁ‹]IÁ„wüÁ{SéÁnÁa ¦ÁTEWÁG[”Á:SSÁ-€ûÁ!0úÁ;ÁÜgÀùبÀã÷‚ÀÎùæÀ·íUÀŸÀ†œÀb…À7uXÀ 0n¿À¡¯¿_…í¾ƒ>©?`&?¯ÐÅ?âão@&Ö@H6@(Åy@7¿@C\Ï@K6ü@Eí~@5Î?@§ @£¦?ÅÏ?¤‹>äѽ¿3:.¿§dF¿ö" À"¦ïÀL~hÀvÙÊÀæ~À¦¸QÀ¼¶³ÀÒ\ŽÀèÙÀÿ1@Á äDÁ{Á$>óÁ0WÇÁ=ÔÁJ(ÙÁW°»Áey*ÁsHÁ€vÁ‡gyÁ‡XåÁ€‡úÁsCBÁe”{ÁXÁK³Á>2Á1d%Á$nÁ¬†Á J-Àÿa2À怉ÀΖ™À¹šÀ£oHÀ‹¶{ÀfX‚À6jVÀ ¥;¿¿ªm¿JXg½×´?Û?’q#?Ûa€@µÜ@, ü@C¦5@Vây@fßÙ@e¥§@dx@b•›@dì@eå–@WQ@9ÛX@ûÙ{¿¿–—ü¿í4ëÀ!ÊÁÀN`¾Àz+À×êÀ§M¬À¿ýÁÀاÀðßùÁÂÁµÁ3×Á,àÁ:•ÁHRjÁUÙÑÁcdèÁq1Á?$ÁV(Áq+­Ác?ŽÁUÅÁGâ3Á:9ºÁ,¶ÁÁm Áu™Á˜‚ÀñäÀØ–£ÀÀ©™À©tæÀ‘È’ÀuÌvÀK§ùÀzÙ¿Ö¤¿re·¾jžÔ?žù?¡þJ?ý=@,k@U3@bµ‘@b·P@b¹@cÁ@d(H@e6Î@e`)@dÐz@eõ @e¤Å@eT}@f(=@h7Î@Ykb@1â’@ ?¿8Š?U¯>&[¿K{¿™X!¿ñÕõÀ$ê2ÀM{0ÀyvóÀ”º§À­=°ÀÅò¼ÀÞî–Àù%‡Á ,Á¦ÞÁ%IÁ2ÏÄÁ@BnÁMìÉÁ[çÒÁj%Áx ÁxÑÁjA°Á[åžÁMljÁ?ôŸÁ2D!Á$”Á}Á ÓÔÀùãmÀà%çÀÆhšÀ­«"À–^ÉÀ~a*ÀPsUÀ"Êd¿ë Š¿‹Å¾·Fe>½vS?Ò?ò†Ö@)g@W;è@a—@aÆ@`ø @`ú_@a½Ø@bÌ^@cÚå@dél@eIH@døÿ@d¨·@dXo@eh÷@fß @gÁ¯@`gd@6é©@ iÊ?¿DE?MÒß=Ö)¿û¿¢ÏÔ¿ùâSÀ(jKÀU&ÂÀ‚ü?ÀœB@Àµ kÀÏÏ®Àêf?ÁŸ®Á(ÁeÁ*ÞÑÁ8»~ÁFêfÁTØ:Áb›“Áp¥ÉÁsóÁd@ÆÁU~bÁFìÁ8–lÁ*Œ¤ÁÐZÁÁtzÀè„SÀÏXÀ¶Àœz¬Àƒ»VÀZ rÀ-ˆ÷¿ý‹¿ŸI¿µ>nW“?u{¡?Û´@ L<@Q‹>@_Žï@_q@_SM@_9ð@_Sh@`aî@apu@b¤0@cã×@d/È@cë@@c¦¸@c\a@d>@eö@f •@gD@b‡T@5eY@Ý·?´æ?5ÝJ»¯+Ò¿4Ž¿²ã¯ÀkOÀ5BÏÀgjÀAÀ§7ÇÀÁviÀÛÎoÀõõôÁ1-ÁØoÁ#ìÁ1ÎlÁ?iúÁM]çÁ[™[ÁjJÁmVkÁ^¤¨ÁOëàÁA°Á2Z#Á#ÇÀÁ€5ÁšóÀóÔµÀØtêÀ½£^À¤š÷À]lÀh„YÀ8ó>À Ž ¿¼ Ó¿>QÊ»Áû´?<ïn?ÃG @Ža@CÊ`@^:@^¾@]×g@]§@]ˆ@]ý}@_=$@`|Ì@a¼s@bü@c @bÊ„@b…ý@bâ¶@cHé@d)Ä@e0s@f7!@g=Ð@\Ú—@-´¨?üGõ? <­?4Ö¾L¿h¼¸¿ÑUYÀÒöÀHØ«À}UÀ™«À³¸ÀÌ‹íÀç=Á\ÆÁ"PÁ|,Á*KÁ8t¹ÁFåÂÁU²Ádg’ÁgÊÁXÜÁJàÁ;|6Á,ýÁBýÁ†\ÁüëÀå®zÀÊM˜À¯lÀ”´ÀvæÀH9À‘F¿ØG¿€#?¾‚\>õÖ7?œÎ®@14@3Ga@]/@]Yg@](@\ö¸@\Åa@\÷A@]³@^J@_•@`Ôµ@b\@aîP@ba@bmé@bÕq@c<@c¡^@dSP@eYÿ@faw@gp‘@Oè·@íš?ßÑF?}ú'>€ø¾ð%¿•©¿óEZÀ.^Àc–À‹MÀ¤ÆþÀ¿e¶ÀÚZ›ÀôÏÁ–wÁÁ$^Á2©ãÁA‰±ÁP”-Á_ÀºÁc3ÙÁSóÁDÐÆÁ5ÔeÁ'5Áz=Á ,žÀ÷ÈäÀÚÜÀ½ÜoÀ¢OíÀ‡³&ÀZô[À*(&¿úÌð¿ r¿Cç>#Ò»?in?Õ“ú@—{@R–@\…\@\x¹@\Gb@\ @\r2@]@]ÇF@^¡{@_{¯@`Uã@a$õ@a‘•@aù@b`¥@bÈ-@c/6@c”„@cùÓ@d|Ü@eˆ4@fc@g7 @;6õ@ €B?²FG?„Ù¾ü€¿[Ŧ¿Çï°ÀÅgÀKYþÀî•À™p{À±[ýÀËA¨Àæ°½Á–6Á2•ÁrÁ.'?Á=aÓÁLº‡Á\+ Á_«*ÁP(0Á@¹¨Á1dèÁ"1@Á(òÁZÄÀë¹AÀÏ "À´—µÀ˜Ë2ÀzµàÀG¨ÅÀ´7¿ÌÍð¿e€¾7(Š?W~?¥Ú–@Fþ@7¶[@[].@[xb@[†€@[f´@[í#@\|ø@] Í@]Ûv@^µ«@_ß@`)@_Ãí@aä@aëØ@bS`@bºè@c"\@c‡«@cìù@d)á@dY@dïX@eÃV@Q‡@¿?×-2?iÍC>g¿¨=¿¢ÈÀ|mÀ4ÍÉÀeRÀ‹}À¤½LÀÀWãÀÝ"¡Àú´ÓÁ fµÁŸÁ*÷sÁ:gäÁIêåÁY|{Á]<öÁM‹ Á=æ,Á.Q×ÁÒëÁpZÁ4YÀâ\ùÀÄïÀ¨qíÀw!Àg©+À3£zÀ`7¿¤€ ¿ÎB> ¨?\°Ý?ÎIõ@‡Ô@Kçš@Z-@Zb@Z:–@[9Z@[÷è@\‡½@]’@]ï§@^ÉÛ@_-K@^¼¹@^bå@_³Ü@aÔ@bF@b­¤@c,@czÑ@cÔŸ@c¤¾@ctÝ@c{¡@dO @`Oå@,³š?óu?¾†>¹²˜¾©rý¿‚B¦¿àMÀ ­ÀQ×–À¼LÀœ™aÀ¹ æÀÖm’ÀôlÏÁ m¢ÁÍæÁ(KôÁ7ßêÁG|ÁVü¡Á[ACÁK±èÁ<,ÝÁ,9ÁýÏÁ n÷ÀûíÒÀÝF”À¿„À¡‹1À…,TÀU´qÀ#y_¿ä .¿…‹S¾¢76>Áœ}?Ž‚3?ð3á@(«ç@X–Ä@X«-@XÆa@YB@Z}U@[ãh@\’ƒ@])¢@^×@^?l@]ÎÚ@]^H@]á@^RÔ@_£Ì@`ôÃ@bE»@cè@cm÷@cO|@c›@bïº@b¿Ù@bÛê@c¯è@6@@@׫?¤Øù?é$¾ ߢ¿Pwü¿Ç%À¶ÀBÇÊÀucìÀ–Œ5À³ÉJÀÑÕÀðWsÁaÔÁ{»Á%²“Á5+ÁDuCÁSùÙÁY BÁIPåÁ9¤ÆÁ*GÁ€&Á 4À÷—:ÀÙl À»»²ÀžÈzÀ‚ìŠÀM’æÀmпήñ¿[Ë”¾"'¸? ‹3?¤e@tû@4ÃÓ@WDÂ@WS|@Wma@X[=@YÁP@['c@\v@]=Ó@]Q@\àû@\qþ@\Bm@\Î@]aP@^ªT@_óY@a<^@b…c@bã·@bÃD@bšx@bj—@b:¶@b Õ@b<2@;v@J+?±S0?&û¼À«(¿.Ž,¿´7wÀ ”À;¼ ÀsõÀ”]CÀ°KÀÌüïÀê³MÁyÁÇáÁ#8©Á2¤ÁB_ÆÁR ÉÁWû¨ÁH. Á8iLÁ(¯žÁ„Á lýÀóáÀÕ5îÀ¶ÿªÀ™ƒVÀz‰ÀEÖ·ÀvX¿ÀMË¿Edø½Tnþ?'vJ?²Ã@ P¹@:3þ@V‰+@V.¬@V9%@WŸ8@Xÿæ@ZYŸ@[³W@\Ër@\Õ@\¬@\„@\[š@\3!@]M8@^–=@_ßA@a(F@aŒå@a¼~@a·¨@a—5@avÂ@aVP@a5Ý@aš@9Wi@ :Ø?µÐ›?6ܸ<Ö„¿"Åh¿£ wÀP#À6ÁªÀkNÀOÃÀ¬œÀÊìÀèÉÁS“ÁÀúÁ"JÈÁ1éŠÁA˜/ÁQS%ÁXÑÁHQçÁ8"Á(ÚÁ3OÁ ¡ÀôVxÀÕ¼-À·œÀš;À{¾ÀDÈ/Àžu¿¼ ׿;sr¼rÿ?6Xä?¹oX@ Õ,@=@VH@UÎñ@UÊ8@V|~@WÖ6@Y/ï@Z‰§@[t@\$d@\¹T@\A@\tÇ@\LN@]9 @^‚%@_œ†@_ü@`[­@`…»@`–v@`‹™@`k&@`J´@`‰Y@a¼•@3²@ º?®’Ž?.Çé¾xWz¿a …¿¿a÷À q‚ÀAôöÀvüSÀ–oÀ±¹ ÀÎeGÀëç<ÁþsÁ<§Á#ŸáÁ3–ÁB²6ÁRVÁZ?¢ÁJ—tÁ:þ%Á+wÃÁ öÁ ¼ÒÀû7œÀÝK%À¿ÅÚÀ¢ßÞÀ†ÿ§ÀYëÀ'¸f¿æð¿Šc$¾Ç¨”>Ÿ3 ?Æ?Öôè@t@C}@Uôa@Uè7@UÜ @UÏâ@UÄ@W —@WÛ{@Xpk@Y[@Y¬²@ZfW@[ü@[m@[« @\Þ@\hr@\È@\ár@\ò.@]@^“'@_«Æ@Mc@$´²?ù½2?¬„è?:Ç?>E`¾èÔy¿ˆz¥¿Ù=ÀYmÀJÏvÀ~ŒÀšÀ¶SrÀÓ“AÀño?ÁªRÁ¼¦Á%èÁ54ÊÁDžÁTÀÁ\ÞWÁMiOÁ>¾Á.³÷Ál9Á5¦ÁˆÀäS•ÀÇ%\Àªú.ÀóÑÀkVÀ8‰À¦¿³ØÈ¿6R!¼ð›Ï?"C?¤îÊ?÷ €@%°Î@N‹@Uò7@Uæ @UÙâ@U͸@Uâè@V¤?@W]ä@Xˆ@XÑ-@YŠÒ@Z+y@Zj@Z¨¨@Zç?@[7:@[–Î@[ª°@\nd@]‚ƒ@^–£@U^€@-®ï@§Æ?Âß0?nàl>Â+Õ¾@I¿Ab¿©Tý¿ú£À)/zÀYÒZÀ…È6ÀŸÓkÀ»YÆÀØ•Àõ¬ÎÁ ä5Á#'Á(…éÁ8~ÁG“ÁWÁ`\hÁPôÁA•jÁ2P•Á#/¡Á=‹ÁŠÀîX¼ÀÒQ À¶}À›eÀ¡ÀRzÀ_Á¿ä&U¿u¾éUÇ>5@?Q î?¶¬¯@Êæ@)CU@M×ä@Uã@U½Y@U—²@U¡ï@Vý@V޼@W<@Wõ©@X¯M@Y(@Yg@Y¥°@YäH@Z"ß@Zc1@[]À@\qß@]…ÿ@Wë @1à @ í]?Ìà¢?…Ph>ÿ¢ì½+1¿Ü´¿w¿×`À1À:Â;ÀkOÀŽ„ÈÀ©^oÀÄæ3ÀàǧÀýUnÁ P=Á9ÉÁ+UšÁ:—zÁIöÈÁYmHÁd$AÁTòAÁEà½Á6÷½Á(BÁÎNÁ ŸÑÀúüÀÞßÀÃÅÀª2ÕÀ)aÀj€iÀ:û•ÀU:¿ÊªÂ¿u8¾®é>‹_¨?^4ÿ?¹|Á@zÀ@#kð@Cõ€@U@@U.@Uc@Uë‰@VgH@Vã@W^Ç@WÚ†@X:@@X’Ý@Xëy@YD@Yœ³@Z_a@[‹¤@\›@Sx@0üI@ÑÄ?Ño‹?Œ¤·? ŠF{¼ÁM˜Á\Æ‘ÁhåøÁZæÁKXÁ<Ý™Á.–Á hXÁ:3Á^éÀîáÀÔÀ¹7×Àž»À†¤xÀ_òZÀ25PÀfè¿Áa“¿fƒ>¾œ  >ƒû^?P‰?«t¬?홼@ÂÐ@3øÝ@Po@U`×@UÄ@V?Ô@V»“@W7R@W˜@WÜ@X4³@XP@Xåí@Y>Š@Zy6@[ÏV@G‚@'´º@]&?ÎAº?ŠW]? é<ãà“¾ø¡Æ¿~Õ:¿À=lÀ @À'-ÀRÁÜÀ{wðÀ“tÛÀ«#çÀÄ_EÀÝåCÀø†¦Á &*Áj¡Á&ÁšÁ5;ÁCœ4ÁRS Áa6ÆÁn¢Á`&ôÁQÞœÁC¡Á5g Á'f@ÁÉ9Á €Àþ}Àâ¹oÀÈ€¿À¯ß–À—»À‘ÀUõ›À-ʉÀî¿ÀeW¿o°x¾Âý@> ê?%|-?‘¯µ?Ìä@ G@¿N@5¯ò@K‚¼@V`@V”@Vò‡@WO¸@WÃ@WÖŠ@X/'@X‡Ä@X4@F Ì@1P@G?øZò?¼Tµ?|Ô>ò®½ пs¿ƒ^ó¿Á[›ÀPËÀ$hÀJdnÀoø¶ÀŽä!À¥›‡À¼¡ ÀÕ]HÀîå‰Á$ÁF˜ÁïÖÁ,ÿÛÁ;YºÁIÁDÁX*~Áf­ÎÁuEåÁgßÁXÆ{ÁJ°Á<èÃÁ/r½Á!ÚŸÁóÁgœÀòéÌÀÚWÀÁˆ[À©øûÀ’ÔZÀ|èNÀU„ÜÀ-1ªÀ hç¿Ê‡º¿†œU¿,¨½ˆÂ¥>ͳÒ?Ye˜?¢·ø?Ôö@.¢@Œ@'0@4Ó'@>„@A}G@@›8@<Žb@6bž@-‡X@"&í@%á?þ7?Ñ%y?òn?NMÅ>®'ë¾µù¿÷ž¿°¿ÉºCÀBWÀ$ÜMÀGøRÀrà@ÀŠŒ™ÀžÌ–À¶rÀÏ‚:ÀæÏ‘ÀÿødÁ °Á¾9Á&¶5Á4+"ÁBÁP*Á^YÁlüaÁ|CÁn Á`=@ÁR¤ÒÁEwÁ6ÿ-Á):÷ÁäÁÜÁ™;À앾ÀÔ’]À¼äÂÀ§†?À”ô»À}Ã3ÀY–GÀ6j>ÀJ¿àH§¿¡…,¿Iö7¾±?.=¢ê]>õ?YFç?˜-ý?¾’t?ßÛ©?øú²@«@˜à@¾¿@–:?úPë?ìöœ?Øgš?ºZˆ?—JÌ?[‡É>û‚7=×1-¾ªt¿Ihf¿¡¿Ü)À %ÂÀ,(ÆÀPɧÀuÀ0’À¡aÀ³ÈÀÈU‰Àà*ßÀùÕ'ÁúOÁw†Á"޾Á/š‘ÁÑêÁ1©(Á$ùÑÁm£Á "OÁ†Àè).ÀÒQÍÀ¿Z–À©ªÇÀ•òÀƒ»ËÀdeJÀAÞ“À!ÀØÜ¿ÅD¿Ž{O¿5uæ¾£×¾<á¤r>³Cñ?".?^Í>?‡)¢?–‡x?›y?™¨Q?’ÿÌ?‡Šw?z™¡?`Q ? ÷´>¹Œ=‚Ž×¾€ ,¿"ñÙ¿ƒEY¿½h€¿ùeyÀ4ßÀ7ªËÀYxÀ}ã8À‘›+À¤EfÀ¸;ÀÊbÀÝlÑÀó3BÁ…mÁ9&ÁØÁ+;¼Á8.ÁEÁRUvÁ_t„Álî8Áz³óÁ…Þ…Á}³‹Áo¹EÁb´ÁT $ÁGŸÁ:ÿ©Á.o Á")´ÁöÆÁ yÀýøÀê+§ÀÕy@ÀÀëbÀ­NîÀ›GfÀŠ?Às žÀPJ À1âëÀ‰ò¿ò–V¿À<0¿’Ö¿K ¿ö¾lSƒ»ê©É>*Z÷>‰¡•>ŸqE>”—>s€Q>&,,=Ÿ=„¼ú)f¾i!ݾêi¿Àù“CÁÛÁlÁOYÁ%l`Á1I!Á=ÁªÁJ¹=ÁWL©Ácý\ÁqûÁ~}ôÁ…²yÁ•Á†áòÁ€TúÁsèJÁgOÎÁZÒ©ÁNŠáÁBH£Á6o Á+BÁ çDÁ)Á ‚ÑÁœÀð=SÀÞÂÓÀÍì À»Ò@Àª¢À™NÞÀŠú`À}™QÀbóÀJõéÀ3œÜÀ •/ÀË¿ýïÖ¿ç²i¿Õ~¿È±©¿Äò;¿Åvª¿ÊNO¿ÌÃÜ¿× è¿ç§Õ¿ûJÀ ©ØÀ¶tÀ,vÀ@F?ÀTÚÏÀo2À…HÀ””‡À¥ÀoÀ·}BÀÈjúÀÙ>ÀêÐÀüîíÁj?Á•hÁžêÁ& ÜÁ0lÁ;—ÁGjãÁSË@Á` êÁm€ÁzlÁƒ…æÁŠ)iÁ‘èÁ‹j"Á…­Á}Ž%Áq ÏÁdÔ°ÁX•‚ÁLÆ>ÁA‘VÁ7$Á-^pÁ"ÈÏÁ2àÁ ûrÁÕÀø†Àæ¿“ÀÔÇœÀÃc À²ý À¦;ªÀ™ÕÀŒÕ À êÀjøqÀX¹ÀH`ÓÀ9ãVÀ-á¾À%»sÀ¿`ÀÎUÀ/À -ÎÀ­À$Ž3À,yÀÀ6šJÀGdöÀU3úÀbO Àuµ°À…p¦À‘¦'Àž£À® :À¾˜ŒÀÐ#ÀâA ÀòíÙÁÝ—Á ØÃÁ;~ÁLèÁ(™LÁ2rXÁ<#ÁÁF¦lÁQÚêÁ]¦EÁiñ®Áv©þÁß›Áˆ"áÁŽoÁ–ˆÁ7÷Á‰ì7Áƒ¼IÁ{)XÁnò"Ác+úÁWñ$ÁMX}ÁCx¹Á9$ÉÁ.q×Á$ _Á“òÁºÖÁõÿÁIÀîniÀÝïÀÎjÀÁìÀµL¤À¨Œ$ÀŽ6À‘aHÀˆz+À€éÀr¯EÀgdŠÀ`¡ÈÀY1pÀVÉýÀ[ê%À]^~À\ZÀ`ìJÀhNèÀr”À€ À‡š6À 7À–=À¡—VÀ­6mÀ¹âÀÇÄ(À×v—Àé³üÀû™6ÁhÁÀ¸ÁdÁ ‘ÔÁ*9Á4WVÁ>ÁâÁHsLÁRX¹Á\õ“Áh0¶ÁsôFÁ€¼Á†f ÁŒá}Á“C*Á›_ûÁ•ÎÁŽë×ÁˆÃÁ‚­;ÁyœUÁn]0Ác¯×ÁY©±ÁO£ÁDÇÁ:AŽÁ0†Á'w¥ÁžßÁÍÁ ÿÙÁ8À÷ðEÀê—ÀÝÆ¦ÀÐÆ,ÀÅ6ÉÀ¸§À­€ßÀ¤¯ôÀÞÀ•ƒúÀ‘S>ÀŽÀŠšzÀ‰¬™À@3ÀãºÀ?«Àe¯À’Å–À—ð7ÀžWÀ¥N À«E™À²ïÀ¾&fÀÉŸ©ÀÕ²÷À⟒Àñ>%ÁÁ ²OÁiÈÁÖ´Á$4+Á-+Á6zëÁ@XžÁJ|­ÁUµÁ^”GÁh¢qÁsSÆÁ~“¹Á…(Á‹<ÀÁ‘€úÁ—îåÁ H‹ÁšFÁ“ôÉÁåÜÁˆ XÁ‚i(Áz]Áoì¢ÁfÁ[+ÇÁP ÁFŸRÁ=aËÁ4[¥Á+­Á"êvÁè^ÁJ#Á ÷UÁr.Àù–ÌÀí ÞÀáš–ÀÔ?õÀÊ_åÀÁÑÀºòŸÀ²°À¯Z0À¬uøÀ©P3À¨|!À¬h"À­3+À¬¨À®¯À±»ÖÀ¶èÀ¼LÀÃ?“ÀÉ‘ÇÀÐ?ÉÀÚðßÀæo•Àò\BÀþt”Á(–Á ÇáÁ³“Á ~ïÁ)íÁ1e×Á9âÍÁCTÁL‹!ÁVÁ`¸ºÁkC®ÁtÌ™Á~ûxÁ„ÞœÁŠ€`Á[nÁ–iÁœ£zÁ¥RÿÁŸ*]Á™!úÁ“IšÁ§.ÁˆAiÁƒÈÁ|s3Áq›¤ÁféÁ\ÓûÁSk.ÁJAƒÁAYeÁ8¼²Á/à¥Á&ôPÁÁ5¶Á’XÁ ÆîÁð°Àý)iÀðè‡ÀçÈÀÀß»^ÀØ“ÀаªÀÍÀ!ÀËKÖÀÈg7ÀÇ«†ÀËŽÀÌ|^ÀÌ%ŠÀÎ*«ÀÐùSÀÖ-ÀÛ¸ÀáWWÀèC…ÀîA¤À÷èMÁ¡]Á¯€Á ”JÁ•Á$AÁ#UŽÁ,ŸÜÁ6@!Á>¬àÁG IÁOÅÁY%ÉÁb·ÑÁlПÁw Á€±$Á…‹7ÁаÁ¦Á•ºÅÁ›’òÁ¡šmÂÌÁÿüÄÁùÉÜÁóªÁí‘ðÁç€!ÁáˆIÁÛœäÁÕ¸™ÁÏç¨ÁÊ%ÜÁÄ…þÁ¿ @Á¹™#Á´LrÁ¯.DÁª"ŒÁ¥AÇÁ ”‡Áœ ÜÁ—ÇÇÁ“¦.ÁØ4ÁŒd¥Á‰RTÁ†s´ÁƒÒ^Á¡ôÁ¥RÁ|]!ÁzæÁx\ÐÁw*ZÁvþdÁwMOÁxÈÁyå÷Á|x0ÁQ‹ÁlÁƒ¡"Á†C*Á‰ ÛÁŒ!½ÁšÉÁ“n Á—~íÁ›»œÁ >µÁ¥Á©à+Á®ÜCÁ´Á¹vÜÁ¿ÁÄ–EÁÊ@}ÁÏòþÁÕÈ ÁÛÀ Áá×Áçö÷Áî!ÛÁôY¥Áú›€ÂñJÁûŸ5ÁõcÅÁï-ŸÁé`ÁâÿëÁÜôµÁÖú¿ÁÑ¢ÁË!ŽÁÅ\ÆÁ¿ªMÁºÎÁ´Ÿ=Á¯4Á©ëÁ¤Î’ÁŸÜÅÁ›ÕÁ–a¬Á’ôÁÏ#Á‰×ìÁ†<ãÁƒ¦Á€£Áz¿`Áv#ÙÁrr×ÁoïÁl¡,Ák òÁiÖŽÁi¤(Ái×nÁj«þÁl‘-Ánú&Ár”ÁuñƒÁz™Áö‰Á‚ÑIÁ† ðÁ‰®ÁÇÁ‘¤àÁ–uÁš¶"ÁŸ˜SÁ¤ˆÁ©¬iÁ¯­Á´†›ÁºÍÁ¿ÂAÁÅyÅÁËK+ÁÑAtÁ×U ÁÝuÁãŸUÁéÍ¢Áð 7Áö_jÁý¾"Á÷a²Áñ‘ÁêÛŒÁ䢦ÁÞ…VÁØ}ÁÒvÁÌ|ÁƃÿÁÀŸ”Áºã6ÁµC|Á¯´[ÁªBïÁ¤ÔóÁŸŒÁš~uÁ•ŸYÁÖAÁŒSÛÁˆµÁ„ ðÁ€IGÁyÕ®ÁsåÊÁn:zÁi_µÁeˆ@Áb/\Á_“Á^²Á\Ý­Á\ŸöÁ\·æÁ]™ Á_rÍÁa¼˜ÁeÍÁiMÁn!ÚÁs†óÁy–àÁ€/®ÁƒÙ]Á‡¿žÁ‹ýšÁ'Á•eÁšWMÁŸhÿÁ¤³ÁªŽÁ¯ôÁµM?Á»OÁÀæ0ÁÆ×RÁÌÜßÁÒô ÁÙ zÁßPÁå‘LÁëêÁòH¥Áù©&ÁóG¼ÁìòêÁæª÷ÁàfxÁÚ+tÁÔ&ÁÎãÁÇùÁÂÔÁ¼®Á¶6RÁ°€=ÁªêáÁ¥Z#ÁŸèÁšëÁ•H¸ÁP¶Á‹…ÍÁ†ØÁ‚zäÁ|áÁu"ÔÁn'ÁgæöÁb&Á]iÁXøÁU¯¨ÁRíÁQWÁP<ÁOÜKÁOÿ”ÁPí×ÁRŽàÁTà*ÁXZVÁ\ÞgÁa³|ÁgYÈÁmã$ÁtÒbÁ|.öÁ‚(1Á†“UÁ‹PKÁGÂÁ•LwÁš{ÅÁŸÇÎÁ¥> Áªç}Á°¹BÁ¶šoÁ¼|ÁÂq”ÁȃÌÁγ‚ÁÔçéÁÛ*Ááˆ>ÁçëÁî+#Áõ®»Áï8ãÁèÙ(ÁâÁÜN.ÁÖ»ÁÏËÁÉ­yÁÚºÁ½Ž“Á·¡kÁ±À`Á«êEÁ¦;ÙÁ ¡$Á›jÁ•¬¯ÁTjÁ‹/(Á†QyÁž¿Áz'BÁqÇgÁjÚÁbÕžÁ\YiÁV‘ÁQ.ÁLã'ÁI‡ÁF½ÁEhÁC°ÁC0=ÁC®ÁD œÁFÁHwŽÁL'ÜÁP¸ ÁU§ßÁ[ŒÁbrÁiwIÁq*›Áy§òÁm·Á†QDÁ‹Q¡ÁgôÁ•—TÁšÿÈÁ ŸªÁ¦pèÁ¬U›Á²2‡Á¸¯Á¾-/ÁÄ^üÁʘ1ÁÐÛÿÁ×<±ÁÝ“©ÁãÕÍÁê1zÁñËßÁëSðÁäÝëÁÞ{áÁØ4'ÁÑóìÁË´ûÁÅ„cÁ¿eûÁ¹LÚÁ³?üÁ­ZÁ§ˆ¶Á¡ÁÁœÅÁ–vÓÁïþÁ‹›uÁ†UxÁIÁy¶ÁoíbÁg.ØÁ_>|ÁX$ÁQ3ØÁK8ÁEáÇÁA\ÂÁ=òãÁ;áÁ9åÁ7…˜Á6ü½Á7·0Á8©Á9û‚Á<™¡Á@‚ÉÁDùÁJ(åÁPrÇÁWrÁ^¬3Áf»ÏÁo—ÛÁyIÁ`BÁ†s‰Á‹“:ÁêPÁ–}ÎÁœDúÁ¢‚Á§þÁ­çÁ³ôŸÁº&üÁÀd–ÁÆ©ÁÍ :ÁÓRÕÁÙ™oÁßöXÁækçÁî9Áç†,Áá‰ÁÚ›FÁÔ7pÁÍî;ÁÇ«ÁÁqÁ»Q9Áµ;¥Á¯¸Á©^Á£32ÁtvÁ—À¥Á’ÁŒu$Á†þ·Á¾ÏÁy ”ÁoF¯Áf*Á]<ØÁTí£ÁMvÁFNÓÁ?úÝÁ:Æ Á6%HÁ2XÁ/sšÁ-8MÁ+ùEÁ+i‡Á,QÁ- œÁ.™Á1b;Á5hÌÁ9Ò±Á?OêÁEØ*ÁLëÁT‰iÁ\ô¤Áeç²ÁoIrÁyN]ÁÅÀÁ‡ÅÁŒŠ"Á’BšÁ˜ €ÁìJÁ£Ö§Á©ßŠÁ°wÁ¶QÎÁ¼’)ÁÂá@ÁÉ,XÁÏy½ÁÕÕòÁÜ@þÁâ±Áê‰9ÁãçXÁÝZyÁÖäºÁÐt]ÁÊÁÃÅrÁ½ÜÁ·FDÁ±-ÇÁ«ÊÁ¥ 1ÁŸ Á™5wÁ“qÁÑ%Áˆ3MÁ‚©¿Áz’ÁpG^Áf'/Á\ƒÁSбÁKWðÁCˆ¬Á< HÁ5]ÎÁ/âðÁ+G÷Á';½Á$m–Á"$-Á!ÌÁ ™HÁ ëÁ"áÁ#üpÁ&é›Á*äÃÁ/i¦Á4ñÌÁ;c×ÁBã7ÁKÁSszÁ\m/Áf)ÿÁpg±ÁzÁóÁ‚Ï/ÁˆríÁŽ&<Á”IÁ™ò†ÁŸô¥Á¦!§Á¬_£Á²ˆˆÁ¸ÐËÁ¿$bÁÅyÁËÉTÁÒ%áÁØ”ÁßéÁç"”Áà~6ÁÙÛ˜ÁÓLŠÁÌ×SÁÆl`ÁÀñÁ¹¾—Á³wÁ­?ÞÁ§'ÜÁ¡|Á›;Á•0>Áh£Á‰­ ÁƒýnÁ|ÿÁr:|Ág»üÁ]¶?ÁSå·ÁJÆÁB+mÁ9óÓÁ2†éÁ+—%Á%É¢Á!)ÇÁ÷®Á&AÁñ;Áæ½ÁzmÁ«€ÁîáÁø¥Á­\Á ËåÁ%T®Á*ÕzÁ1œÈÁ9„?ÁAÏqÁJWÁS³TÁ]ÊÑÁh¨Árµ8Á}ÃlÁ„}oÁŠO.Á@ÇÁ–:ŽÁœZÖÁ¢{tÁ¨”Á®âmÁµ2HÁ»ƒ¿ÁÁÐÁÈ%ôÁΖJÁÕ èÁÛºÁãØãÁÝ3ÁÖ’]ÁÏñ ÁÉ`ÒÁÂëíÁ¼ˆÁ¶(èÁ¯ßuÁ©˜LÁ£d’ÁMÁ—7FÁ‘@ÌÁ‹{xÁ…ΙÁ€ ®ÁtÖíÁjÁ_»êÁUœjÁKÑÆÁBB,Á9oDÁ0ï5Á)XÛÁ"³ŒÁ¬ÆÁðyÁ¹Á¸ÁÁ‰Á 1±Á ‘òÁ 2×Á1èÁ5åÁCÁ?9ÁÏéÁ!£ÁÁ(ɯÁ0ôZÁ9A ÁBÑÁKÙÿÁV’Á`x;Ák^Á•`TÁ›‰FÁ¡¹xÁ§ù’Á®I˜Á´XÁ» îÁÁ^ïÁÇÌÁÎUmÁÔøVÁÝ[µÁÖ·—ÁпÁÉ€;ÁÂäþÁ¼PñÁµ×ÞÁ¯g›Á¨þ×Á¢¶qÁœzÁ–L)ÁB‰ÁŠ=uÁ„2Á|²]ÁqXêÁfÁ[:ÁPžÕÁFwÛÁ<\áÁ2ÐoÁ)°(Á!69Á¸óÁÐÁ èÁœ5ÁmÁ*.ÀûT¢Àù:àÀøxáÀù‚ÀúúmÀÿÝRÁ<ëÁp‹Á TÁ[@Á{ÃÁ!c’Á)ÓÝÁ3KdÁ=IäÁG”´ÁReÛÁ][ÆÁh“¼ÁsïdÁÅ Á…þ»ÁŒÁ’"@Á˜J*Áž€ÓÁ¤ÎôÁ«" Á±m[Á·¶ðÁ¾!{ÁÄ©ÀÁË>fÁÑ·æÁÚn°ÁÓ³gÁÍUÁÆurÁ¿Ü"Á¹CtÁ²±Á¬;;Á¥ÑýÁŸnûÁ™.sÁ“DÁŒßäÁ†é~Á€ýãÁv3óÁjÇÁ_wZÁTCûÁI©–Á?³Á5í¹Á, Á#.Á¹ Á ~Á tYÁä«Á§‘ÀùN×Àó'¼Àî°zÀìñÀêù=Àë·ÇÀîx:Àñ×Àø¿žÁ¼•Áã7Á Ô—ÁìÁ½îÁ#„¢Á-#éÁ7ÁAv<ÁLòÁW1ÌÁbe~ÁnÁyêØÁ‚ËÆÁˆÚ&Á'Á•,xÁ›eºÁ¡ÄÏÁ§ÿ_Á®B Á´¦ÓÁ»#ÅÁÁ¦ŒÁÈ%ÌÁηÁ׬˜ÁÐï<ÁÊ7ÁÔtÁ¼þNÁ¶iÁ¯ÕÁ©F£Á¢Ö3ÁœwÁ–ŠÁçnÁ‰Î>Áƒ¿ÇÁ{¯‘Áoî¨ÁdyìÁY|÷ÁN^NÁC‚îÁ9TåÁ/°ÂÁ&"ÁL ÁN'Á ”×Á`Á@¥ÀõõÉÀî°'Àè7ÀãktÀà_OÀà#§ÀàÓÀãLsÀç.ÓÀíJ9Àõ‡GÁzÓÁĺÁ ­žÁƒÁ‚_Á'ß6Á1ËxÁ;ú„ÁFÆÌÁQÁeÁ]ªÁhWÌÁsшÁʼnÁ† ÁŒÁ’/¯Á˜‚ƒÁžÈ³Á¤þÛÁ«KMÁ±³ÂÁ¸8Á¾ÁrÁÅE^ÁËÝ9ÁÕÁÎKŸÁÇšÁÀí*ÁºMÏÁ³¼æÁ­/"Á¦¢“Á 4Á™³Á“b"ÁáÁ†ïÔÁ€ïüÁuùÊÁjO„Á^´iÁS†²ÁH¶Á>'Á3áÅÁ*\ÉÁ ØvÁÕ{Áò"Á_æÁ“TÀ÷(ŒÀî²Àå©@ÀßyâÀÛ¥™Àص¼ÀØ ÀØ.ÀÚÌäÀߥtÀäȾÀíˆÀ÷lÁúÁ ÇÁBøÁóÁ#GJÁ- SÁ7OÁA¸0ÁL€‰ÁW¨ÕÁbé.Án£eÁzš8Áƒ0dÁ‰D“Át<Á•».Á›Ü¸Á¢°Á¨wÁ®ù‚ÁµvéÁ»êÅÁÂ|ÁÉ'òÁÒ“ˆÁËÕ™ÁÅXÁ¾mtÁ·ÂÁ±! Áª˜XÁ¤vÁœ)Á—/ÁݽÁŠ ÔÁ„jIÁ|­KÁpäeÁe%äÁY›^ÁNooÁC³lÁ9·Á.ÐÁ%eýÁGgÁÝÁ ÀÁ„ûÀû–¨Àðø»ÀçhfÀßjºÀÙ¿ÿÀÕ˜ãÀÓKNÀÒ8ÔÀÓ=WÀÕA™ÀÙj0Àߟ‰ÀçP6ÀñGÀüýÍÁe_Á dWÁÛ ÁòLÁ(ŒmÁ2ÎÁ=1…ÁHÁÁRÖKÁ^7ÚÁiߣÁu{ðÁ€ vÁ†¨ÏÁŒâ"Á’þ—Á™)áÁŸ~ÓÁ¥øªÁ¬YÿÁ²ÆjÁ¹RAÁ¿úLÁÆ·×ÁÐ@®ÁÉz­Á¿>Á¼˜ÁµXÁ®°Á¨`Á¡—fÁ›&]Á”ºòÁŽpÁˆ:‚Á‚ <ÁwÜÐÁkËÇÁ`'‹ÁT°³ÁIšåÁ? ‘Á4Ÿ]Á*¥OÁ!TÁi£ÁÛ[Á[ÜÁt§ÀöANÀëѺÀâ›ÓÀÛºÎÀÖ}ùÀÒ®ÍÀЬjÀϘzÀÏÈoÀÒQuÀÕÀEÀÛV‚Àã™À킚ÀøUõÁ×Á ³·ÁÔ´Á˜ZÁ%©Á/¤Á9'ÁCmÁNh¯ÁYùÑÁeZÁp¯¬Á|„ÉÁ„eÁŠ{ÖÁ’ÅÁ–×jÁB@Á£ƒ‡Á©å Á°h`Á· åÁ½ÅÇÁĉBÁÎ6NÁÇ^¿ÁÀ–lÁ¹Ð7Á³Á¬r]Á¥ÝóÁŸQØÁ˜ákÁ’MÁŒ'…Á…ðžÁ–ÁsmãÁgyÁ[±‘ÁPi½ÁEiZÁ:ÌvÁ0ªÁ&ÊZÁ¾ûÁú¹Á õ¡ÁÑÀþ§ÀòJÀè¡´Àà[(ÀÙï„ÀÔÖÀÑîæÀϺZÀÎùêÀÏÀл«ÀÔž#ÀÙ¾9Ààu=ÀêöÀôŽiÁ™äÁ¹«Á\Áñ Á"6Á+¶2Á5„sÁ?ó­ÁJí…ÁV¾Áa* Ál­ÞÁxš[Á‚Y.ÁˆZÿÁŽz]Á”»ÁšÿÁ¡Q½Á§È¢Á®`&Áµ¸Á»½üÁÂiÄÁËÚÁÅyïÁ¾¡WÁ·Ù›Á±Áªi}Á£ÒÊÁV«Á–åÁ‡™ÁŠ>¼ÁƒýàÁ{ÁJÁo©:ÁcÆfÁX3©ÁLÔ)ÁBKÁ7¤EÁ-¬®Á$xÁåÁ¬ŽÁ º9ÁæŠÀúã›ÀðdøÀæªÀ߃ÀÙxÀÕsØÀÒl¬ÀÐæÇÀÐJ¸ÀÐTÀÒkÀÔ³îÀÙ¥þÀßø ÀèTõÀó ÀþͨÁ=ÑÁ*«Á NÁg·Á),Á2ÿÁ=”ÁGÀ‚ÁRºÁ]°²Ái'Áu>Á€i6Á†]KÁŒ…pÁ’ÎyÁ™šÁŸ}:Á¦óÁ¬™Á³#(Á¹ÅÙÁÀƒÁÅ~UÁ¿ÞëÁºkÿÁ´öûÁ¯Á¨¦ÛÁ¢RÁ›ŠÒÁ•'ÁŽØèÁˆšÞÁ‚nvÁxžÁl¯ÆÁ`ÖnÁU^\ÁJL[Á?pýÁ5?ÀÁ+RÁ!ÛÁå>ÁÚ6Á @3Á¨JÀùLÀï$°ÀæUcÀßÀIÀÚl…ÀÖÕÒÀÔ|MÀÓIÀÒ^ÀÒ†‚ÀÓ­.ÀÖ^ÅÀÚBÀ௷Àè‚,ÀñÜ_ÀýËÑÁs Á ú<ÁÛ.ÁloÁ&ÔÁ0‡«Á:\ÇÁDãÉÁO»­ÁZ´‚Áf&öÁqÏ£Á}oNÁ„·îÁŠå«Á‘%yÁ—f£ÁÊ^Á¤NÿÁªÙÁ±nöÁ¸!_Á¾íxÁÀHÁºEæÁ´§ÇÁ¯9Á©ºqÁ£ÁxÁölÁ˜I¾Á’®³ÁGÁ‡)%Á€ôKÁuÅhÁiïØÁ^4>ÁRâ·ÁG÷gÁ=>7Á3>Á)XþÁ bÁ¥#ÁÞ‹Á¶ÝÁe±Àù(-Àï´ÀçŠ÷Ààê„ÀÜjwÀÙÀÖ»§ÀÕÀÔilÀÔ‹¿ÀÕÀÀØ`ÀÜÀáÖUÀé=ÀòŽÊÀýCÁùÁ YñÁÙ±ÁÖÁ%:¥Á.»;Á8sQÁBØMÁMe´ÁX&çÁcoÅÁnÝ6ÁzpÁƒ8±Á‰gpÁÁ•è{Áœ[¬Á¢ä Á©o Á° ‰Áµ¾Á»’ÁºÏ€Á´Û$Á¯ŠÁ©sûÁ¤ 0Áž€·Á˜‚¢Á’µ˜Á4Á‡x·Á‚¾Áyõ¹Áo:ñÁd4ÁZ£ÉÁPÊ!ÁF»Á;¾¿Á1ÆÁ(föÁ†[ÁQ[Áµ?Á¨¬ÁЧÀúcˆÀðÝŠÀéUBÀã#ªÀÝ#AÀÓ$ÀËB•ÀÆ”KÀÃÞKÀÄgyÀÇ©‰ÀΉÇÀÖg¶ÀááœÀêƒ>Àó{“Àþ,­ÁíPÁ çàÁsýÁJFÁ$2¬Á-v´Á6ú›ÁA,&ÁKƒ\ÁVN2ÁaU¼Ál†ƒÁx+Á‚ ÁˆJÈÁŽ}"Á”ªÁ™–†ÁŸ*èÁ¤ÙIÁª‹eÁ°a*Á¶`þÁµÃÁ¯¢ìÁ©ª¼Á£ÞâÁžD>Á˜àÁ“JqÁF•Á‡wVÁÕ”ÁxÁmÝkÁc©ÖÁXàÁNdÁD™òÁ;5¹Á1mÁ(\¡Á±¼Á(¢Á[[Á Áœ/À÷EÚÀì`âÀâ#À×iÀË,ÑÀ¿ÒÀ¶<šÀ­âÀ¨0À¥)oÀ¥ÛiÀ©bÝÀ°¿À¹FRÀÅû&ÀÓ£¦ÀãÀô7ÅÁûÁ ÷Ák#Á8ßÁ#ÃiÁ,ׯÁ6OoÁ@©ÁIÙwÁS£•Á^5Ágš ÁqÃæÁ|^XÁƒ€ÉÁˆõ$ÁŽoRÁ”êÁ™¬…ÁŸ\ëÁ¥4Á«8üÁ±dÁ°Ö/Áª¡âÁ¤{;Áž~ÜÁ˜±¿Á“|Á»Áˆ{Á‚ Áxx´ÁmAbÁb8óÁW—§ÁM^ÁBŠ(Á88iÁ.˜…Á$ÏmÁ%ÁGîÁ Á\"Àó¸ÄÀåÀµÀÙzàÀÎiÀÃáWÀ¹J`À®ÙÀ¢þ9À˜Î7ÀR'À‰€dÀ†•GÀ†ÞÁÀ‹U¸À“ÀœIÀ©ê7À¸v«ÀÈcpÀÚbÀëß|Àýí&ÁzÁí¡Á¢±Á!‘“Á*mþÁ3ÎÁ=mjÁGËYÁQƒÁ[‡‘ÁfÁpÂ¥Á{¥ÒÁƒN_ÁˆÝ$ÁŽ…KÁ”3“Áš IÁ ˜Á¦A©Á¬„mÁ«ÄÁ¥®&ÁŸ‡RÁ™Y}Á“XŒÁŠ3Á‡ôðÁ‚œhÁy×úÁm´ Áb ?ÁVáoÁKòàÁATaÁ6õEÁ,;Á"¡ÁCQÁiÁçªÀøf†ÀçqÀ×TqÀÈÑoÀ»çZÀ°U À¥}sÀ›ZŸÀ—VÀ…ÎÀv¿§ÀcÏéÀV¤ÀP‡ ÀOåÀZ•òÀj^QÀ€z~ÀŽ3À-ûÀ®6EÀ¿©çÀÑc¾ÀâýÀô˜$ÁèéÁ ànÁ´íÁäñÁ'SÈÁ1ŒvÁ;ŒÁEbÁOì}ÁZ–FÁeqžÁpjÖÁ{‚ÁƒeÁ‰ŸÁŽìfÁ”÷ Á›WÁ¡axÁ§=Á¦í»Á ¨fÁš‹øÁ”tßÁŽ?Áˆ9(Á‚i­Áy°‡Áo Ác&ÁWWÒÁK©Á@Ž»Á5ÁCÁ+pÁ òÁõÛÁ ÈŠÁÜþÀðÔÀÝ”³ÀÌ=1À»RŽÀ¬`QÀžSØÀ’2ŠÀ‡<Àz]ºÀeÆøÀPpÀ;ñÀ).À-EÀÉVÀpöÀжÀ0!ìÀH©ÆÀe¹§À‚[DÀ“Ú¬À¥°À¶ïÃÀÈ‚'ÀÚgsÀì'^Àþ>)Á-èÁc³Áh]Á%¬¥Á/[ðÁ9ÐËÁDEÁORãÁZMÊÁe_Áp›=Á{ë‚ÁƒÒŽÁ‰ØÁý*Á–9²ÁœÁ¢$ûÁ¢VñÁ›âaÁ•”ÁqÁ‰lÁƒ-ìÁzEÁn¤IÁc‹‰ÁXô·ÁMT•ÁA ‰Á5VzÁ*N{ÁŸ ÁÕáÁ 9]ÀÿE$Àê¼EÀÖìÏÀÃPÕÀ±kÀ ÛÀöÀq¿Ài,ªÀR—À=`wÀ)éiÀ¸9À¤~¿Ü«F¿»ñ¿«õÁ¿¬Põ¿Å5ô¿îö±À.1À.²ŒÀP&bÀr¨ÀŠŸ!ÀœnFÀ®(ÀÀj¡ÀÒÐ÷Àå©À÷`@Án ÁÀeÁ‚›Á#ÓÁ.…¢Á9QTÁDL©ÁOVhÁZƒœÁeÊ¡ÁqvÒÁ}sµÁ„ÝÁ‹ÿÁù@Á— µÁJXÁêaÁ—^?Áá­ÁЉhÁ„_Á|ÒßÁpQÁd.„ÁXŒ¸ÁM}ÁBú#Á7+ƒÁ*ÕqÁäÁ)Á ˆGÀý<ëÀçâíÀÒ{À½âuÀª¡À–ºÀ…ApÀgõ¾ÀJ½À. ÀcoÀ˜¯¿Úrw¿²©¿Š˜¿J𯿠Æ'7¾ÒÓÜ¿$v¿wÖ,¿³¥¸¿ð4:ÀUMÀ< mÀ`¸]À‚]À”› À¦ä/À¹‘ÀÌ'¡Àßl`ÀóÁÈEÁ3Á¶ Á#x·Á.rÁ9r0ÁDŠõÁO¼ßÁ[MqÁg9UÁs‹ÁõkÁ…â³Á‹û?Á’BÌÁ˜³Á™G×Á’á£ÁŒfÑÁ…íÁïÁr±WÁf¾{ÁZd×ÁN5äÁB”©Á7œÁ-Á!–Á¿wÁþÀüXÇÀç ÀÐîÀ»§À¥¹ÒÀ‘9Àz¤ñÀTàHÀ2/œÀ;ü¿çµ£¿µA¿ˆ|*¿@žá¾äÒ™¾BÈ>ÞQ>ɧ ?iq? d>–_®½ˆˆ_¿й¿„ƒ¿Ç^wÀàÿÀ+àÁÀP™ýÀuîÍÀªÀ ëÀ´rèÀÈ4þÀÜ@ÄÀðöÁ% Á ÜoÁÎZÁ#ÀûÁ.¼ùÁ9¼´ÁE*žÁQ ^Á]rßÁiÍRÁu­aÁ€õÞÁ‡GFÁÄ2Á”fíÁ”À[ÁŽF~Á‡ÝŸÁp¸ÁuùrÁi8]Á\ÂnÁPÈ ÁD¡ŽÁ8eéÁ,È Á!ê1Á*Á pÀý´@Àæ+ßÀÐæ1À» YÀ¤ óÀŽbÌÀqèRÀHtjÀ!/p¿ù ¿³¸²¿l :¾úú¾¿õ>P?ñF?G3§?‰N¿?ª3¦?†¡?½U“?š¦E?Lò6>®‘k¾?¿î¿:z•¿§wW¿ïûÌÀÐ:ÀCôÝÀkÆÀ‰XßÀ5²À±,kÀÆ=ÀÛjsÀðãµÁX ÁTöÁ#ñÁ#Ï‹Á/Á:ý]ÁGuQÁSºàÁ_°«ÁkýXÁxµçÁ‚åOÁ‰—-Áj÷Áƒ¼Á‰×…ÁƒP×ÁyÉîÁlóöÁ`®ÁSq^ÁFûUÁ:údÁ/lÁ"ÎìÁ9óÁ ƒ_ÁZ²ÀêŒGÀÒiúÀ» ™À¥þnÀŽëMÀpª4ÀCa¬À]¿Ý´¿{‹¿ç½ RÙ>Ù?O‘†?““?º Ï?Þ¥ø@›@à€@~Ë@½@ú?Ö²ñ?—n{?*„¹=®¯¾ûs¿ŠT&¿Ù_ºÀ£ŠÀ;ƒ¶Àd>ZÀ†-¹À›^rÀ°–£ÀÆ1ÀÛÄÙÀñÝrÁ°­Á þ2Á"ëÁ%†Á1ŒÒÁ=Å£ÁIØ#ÁV4 ÁctÁp6ÄÁ}»¸Á…¸ËÁŒ–°ÁŒoCÁ…®¢Á~ ÁpטÁcõëÁWÁJK©Á=·-Á1aßÁ%eYÁ½NÁ ‹Á 'ÀïGÀׇðÀ¿t¥À§èÙÀÝÀtà7ÀEwÀÐ6¿ÔL¿z–¾©ý«>‹F³?P¿?¨j?Þƒ@üð@I@,õñ@=¦ƒ@Møý@Z8Ê@W™›@@À$@#€t@en?½wø?f4>›*Á¾Ÿ„³¿n¬¾¿È¥õÀ XðÀ6j À`²´À…iÀ›J›À°â—ÀÇçÀÜÌTÀðÍ@ÁmTÁcåÁÀÍÁ'ùÁ4.Á@œlÁM†šÁZÙ:ÁhuØÁv MÁèÍÁˆ¶áÁˆsØÁœ2Áu³¥Áh]ŠÁ[6ÁNHÁAjÁ4VÁ(ÂÁçaÁìÁ{¦Àñ+ÀÚƒÀÀÅH¿À¬¿üÀ•-À{‰zÀLôJÀxc¿Úm©¿wP¾„üH>ÚïV?ˆ}{?Óy²@ µ#@*:µ@Aß\@WPè@jhž@zÿ=@…³£@Œˆ@ˆ‚x@x÷Ì@Zª@8ø@Ë÷?×é‡?Šv>ã©é¾?¶ì¿Xo¿¿W(À ª)À5rDÀažÀ†GøÀœU9À²I?ÀƇÄÀÜ-Àóè Á%ÁgOÁÔÁ+IDÁ8NgÁE¾=ÁSM?Á`ç{Án„¨Á{ìbÁ„µçÁ„ŽïÁ{jÁm·~Á`ÁR½2ÁE¥ Á8ͰÁ+ðhÁœÁƒßÁ—‹Àõö ÀÞ¼®ÀÇ£šÀ± EÀštiÀ‚GPÀUü|À%ëοéX,e¾›_™>à8.@c x@}âS@Šà@’¿"@“ Á@’\ª@‘Ã[@’¨·@“OX@ˆcm@lw@E@ ?êîŸ?˜Ëµ?]Ö¾ ¼¹¿P˜e¿ÀjžÀ †À8@íÀe)LÀˆV!ÀHºÀ²Å3ÀÉÈ5ÀᇰÀú]¢Á ¶ÁW¸Á#v9Á0ÖÁ>J©ÁKÎÆÁY*ŸÁf‡Át&vÁ¢Á€íÁsÕÁf;ÁX[éÁJ¨þÁ=,ÞÁ0hÁ#a<ÁÅ„Á ícÀú ñÀãÀÌËÀµ-ÒÀž#EÀ‡ À_…À0%`À©A¿Åh¾ã8>¤(¥?‹-"?ëÄ)@#†#@O;í@wAg@a·@‘Y|@‘‰ê@’-@’˜p@’­V@’cq@’ùu@’ÑQ@’©-@jH@vÆ5@Nn<@$Ç#?ó<×?œçú? ©¾$GP¿]P–¿ÉáàÀóÀ=ÏöÀj´cÀŠõ'À ÿ.À·ý[ÀÑ üÀêjßÁéÁþÕÁ.Á)|9Á6ÀÀÁCõBÁQaÝÁ_%yÁm0õÁzøåÁ{e¹ÁlþÿÁ^Ð$ÁPä‰ÁC0óÁ5€1Á'àåÁ«öÁ‡ÁîŠÀê›jÀÑl¿ÀºÀ£Ä®À>ÀjïÅÀ;³qÀ ¿·ö¨¿.Sà=÷M?j»Õ?Ú¿v@˜f@O!@}®@}@yD@z$@Ûõ@‘c8@‘ê|@’q¿@’£’@’{n@’SJ@’+&@’¯­@“k?@}Yæ@R|Ð@%¶6?òé?˜v½>î—’¾Š;”¿z°ï¿Ù5(ÀŽoÀFºÒÀsÂßÀ¦À¨¾ôÀÁÕŽÀÛ8ÇÀõpdÁ׃Áë¾Á!áMÁ/„Á<”#ÁJ~ ÁX1[ÁeÁaÁs,ÁuÍÁÁg2ÁX~þÁJ$$Á< RÁ.HUÁ  vÁúÜÁŸ ÀñÒKÀÚÀ‡mÀ©ìCÀ“ ÊÀyøÀJµ!ÀK.¿Ør~¿j…¼½ú?*¡`?»Áð@8@Ešy@ws @µ»@¦Ó@™ì@¦½@.@µD@‘O·@‘ïŠ@’Œ@‘ôH@‘Ò@‘­@’ Ù@’§@“þ@~e@P¨‚@"p?åå?‡3¯>– *¾å‚6¿”ç!¿óãÀ'p]ÀU»ÀÑßÀ™Y À²¤ßÀÌéÀçWÑÁ¥KÁ ]ƒÁõÁ(?Á5Í ÁC!UÁPÕ»Á^؃ÁmÇÁp Áa«“ÁS(ÄÁDv¯Á5ïqÁ'¬ÙÁÂÁ )áÀý;Àâ_nÀÈßÀ±ZaÀšmaÀƒYÀYxÀ, ¿øËп›`[¾ßOª>¹Du?•‡æ?ÿ&5@3¨9@gì‚@ŽIs@Žêå@ŽÒE@ŽÁ.@Žü^@œ1@<@ÛØ@‘{¬@‘†.@‘cê@‘Aù@‘q0@‘¤L@’@’–m@“Ä@z 1@Igt@zœ?Í?Sˆ”=Ž€¿/M ¿¶¾À >~À7äÀd]À‹ ÇÀ¥‡íÀ¿ÐˆÀÙ`ÀóMÁÌFÁ'Á!nÁ.u¾ÁÁJy÷ÁXåþÁg‡Áj_Á[ÒŽÁMEÁ>òÉÁ0àÁ"^ŠÁô6ÁæÀð¤KÀÕù½À»…xÀ¢9ŠÀ‹.€Ài'À<«MÀ‡¨¿Áˇ¿C¨=Æ®?Uþñ?Ñ;@®2@R­Â@ƒËÃ@Ž“9@Žz@Žaâ@Ž{O@ŽØÏ@Eê@È&@gú@‘Í@õÐ@‘@‘6Ê@‘jŽ@‘ß@‘І@’'Ü@’«3@ø|@lÿz@8È'@îÀ?¤Tä>ù¹J¾ŠŠ3¿ƒì4¿áÊ•À®/ÀMÃÁÀ~ŸTÀ™:dÀ³l#ÀÍ­…Àç!lÀÿ˜ŠÁ ÉÁVöÁ(RðÁ6£´ÁE6ÍÁSþŽÁbð¬ÁfKÁVúýÁH^Á9ZƒÁ*܆Á©¼ÁØ•Á+œÀæ"ÀË`À±,ÁÀ—¯À~£ÁÀQ‰GÀ$s¿í[¡¿¾T¾½‚K>ØÕÞ?œâó@¼ä@8Î(@nÌA@Ž;Ž@Ž"â@Ž 6@Ž8È@Ž€²@Žâè@P@½@*6@Žã@È @üd@‘0(@‘cì@‘—r@‘Ê@‘üÁ@’<¢@’ÂB@…¡@Uós@ L;?Õý'?Tê=gDj¿8Z¿½càÀ &À:lFÀj‹+ÀsõÀ¨QŠÀÀÀØîbÀòÓ6ÁÿÁjÁ#‡[Á2:ÔÁA#0ÁP5Á_hÁbŠêÁS=þÁD ªÁ5#Á&"#Á~Á 'ÓÀöu ÀÛ¼|ÀÂ,À§TjÀù­Ài¤À;À ·„¿À:Í¿I™‡¼tt¦?B{?ËJ¬@KV@Q[@ƒ‰ˆ@ÂH@²¶@ö@@Ž>+@ކ@Ží@Z@Ç4@ ƒ@Þw@†Ð@õÂ@‘)†@‘]J@‘‘@‘í@‘öT@’¢@’ á@‘d@k<)@4C?úÈc?Þ¬>ªß¾ê¢g¿œ¿õχÀ'íÀW3hÀ„,ÀÀœÀ‘ÀµTØÀμ›Àé·ÁäsÁPÁ ¹Á.íiÁ>\ÁM3{Á\€$Á`$±ÁPª¿ÁAF¤Á1þ Á"Ø­ÁáeÁ'»Àí…;ÀÑ©ÊÀ·*9À›×À„4ŸÀXœËÀ)™T¿øV‹¿ž;ÿ (>‡aS?‡ ?ðI×@-‚û@cÅ@ Ý@w@š.@û£@ŽC@Ž‹x@Ž÷@d2@””@\K@.@ÖL@~Ç@‘"ã@‘V§@‘Šk@‘½@@‘ê@‘Ò@‘º @‘»@wX¿@@m›@ ï?©l?トýÛ’?¢0@Ì@;ù„@qä<@Œa]@Œ‰"@<+@ï5@ŽHð@Ž”@0@¥@Žå\@Ž­@Ž}Ë@%È@ÎC@v¿@‘;@‘ƒÉ@‘¶Ó@‘§p@‘@‘w@‘_ž@~)f@GˆÀ@\?¹‡¡?(½½Û=¼¿\0†¿ÄwÀÀ 2ÔÀ<«—ÀlnÀŽ ìÀ¦ê ÀÁ²ºÀÝÞ?ÀúõGÁ WQÁ0qÁ)÷UÁ8ðtÁHIÁWT@Á[õÝÁLwÁ= ÙÁ-¿ÞÁ• Á˜„ÁÚsÀäåøÀÈý:À­‡,À’vZÀqÇÀ@ª„Àù¿ÇªH¿[ ¬½í?$#Ý?¶´@÷@DÚ@z}y@‹´Ü@Œ+@ŒÞ)@‘2@ŽD<@Žž.@ަµ@Žnl@Ž8E@Ž!-@Ž9@Ž®ÿ@S‚@ø@œ†@‘A @‘p¿@‘`†@‘Lî@‘4ý@‘ @}¾x@I](@X?Ã4ù?;8ˆ¼³ý¿AhŒ¿¶p9À·À3aOÀbÙ™ÀŠ<‘À¥çÀ¿ªÀÚ…QÀö›¦Á Æ_Á0Á'’Á6¹WÁFˆÁUmóÁZëÝÁKXÒÁ;ØÁ,n¢Á#FÁ ÿ¿Àþ$“ÀààäÀÄxÀ©X]À‘ ÀkÁ´À9ðXÀ {(¿»Z¿Aöμ\æz?< "?Á:¸@W_@Iá³@u,@‹@‹Í@Œ|Æ@)¢@Ö~@ŽcÜ@Žjz@ŽV=@ŽB@Ž-Ä@އ@ޤó@Iv@íø@’z@Äã@ÜÅ@Ú¸@Ê@ºE@ª @y×@D€ @þ´?¿ö?;o;Ú•¿3µ¿±–ÈÀ¹7À+¥¢À[DsÀ‡àÔÀ¢*ÂÀ¼{>À×¼Àô$Á¬;ÁŽÁ&¥ßÁ5äùÁEB£ÁT¸>Á[ ”ÁK| Á;þ9Á,˜*ÁP×Á2*Àþ•=Àá`/ÀÅŽÀ©€ŒÀŽßSÀj ùÀ8tÀ [i¿¶Ã¿35=#ͺ?J²Ý?ÇÕ€@¡¾@JŒÞ@€6£@Šå@‹;@‹çî@Œ”Ê@A¦@ÅÝ@ŽU@ŽZÍ@ŽN—@Ž:[@Ž&@Žšç@?j@̳@ü}@,G@Ac@IÁ@D±@4w@Æ=@m¯ÿ@:·§@ Z?´]Û?(”@½;±¿;-¿µ],Àñ8À.‘‚À]%À‰ÛÀ£¹^À¾ ŠÀÙRÀõZTÁ 6¶Á ‰Á'™Á6M9ÁE¢ÑÁUzÁ[ ÁKñ‹Á%Þ?Â@w@D~ë@xxÊ@Šê@Šä@‹S@‹ÿò@Œ¬Î@'Þ@rV@¼Î@ŽF@ŽFñ@Ž2µ@ŽÛ@N@4@cá@“«@¦@®_@¶½@®©@…b~@[IÜ@,LÎ?ùb?Ÿ?ïÖ¾$ÔŒ¿T¿½Ú@À nfÀ3VKÀ`HÀŠD¬À¤ÎhÀ¿wøÀÚlÀö€ Á ·­Á}ÇÁ'}“Á6¨ÚÁEõÁU\ªÁ[ʾÁL@ÜÁ<ʶÁ-m”Á0ÀÁ‹ÁEýÀã{UÀÇQgÀ¬WÀ’îõÀrìæÀASÆÀ­ó¿È­\¿W/t½úÐ?J¶?­.‘@Qé@5@eSÙ@Š 5@Šé@Šâð@‹k@Œö@Œ‰à@ŒÔX@Ð@iH@³À@þ8@Ž;è@Žk²@Ž›{@ŽËE@Žû@  @þ@\@ŽcQ@pkÚ@D)ù@i?ÕµÞ?{éa>œW¾­Sx¿|^z¿ÑÀIÀ9lÀf¯œÀC3À§‚cÀÁò¨ÀܵSÀø…¸Á žØÁNÁ(:ÏÁ7UûÁF•ÁUð;Á]=XÁMÏsÁ>y«Á/BTÁ 2ÁU.Á¼ªÀèà_ÀÍ À²N9À˜n˜À}ºÜÀL tÀFÒ¿á÷=¿‡4¾³"Ï>³Ó?†‹9?â|î@W@KPq@wë @Šî@Šçð@Šâ@‹ƒ@‹ëá@Œ6Y@Œ€Ñ@ŒÕ@1é@Ž»@µo@Ô»@Žß@Ž2©@Žbs@Žo?@Žwœ@޾Z@}>@R‘@'h?úñ?¦Ðx?$\í<šùû¿y¼¿š…¥¿ç©rÀØÀD9ŽÀpvKÀ‘7§À«LÂÀÅàcÀáÐÀýeÁ BÁ¯QÁ*sÁ9`ÁHw_ÁW°CÁ_ÓÁP–+ÁAvpÁ2mƒÁ#cÁ´#ÁrÀï•jÀÓõfÀ¹³rÀ ‹OÀ†|¼À[t!À.º<Àm‰¿­6x¿-R^»ÒšS?-LÇ?­Ì´@ð@,Nƒ@UŸ[@~lš@Šìð@ŠæÛ@ŠîM@‹PÜ@‹­¯@Œ @ŒgT@ŒÄ&@§@3ó@S?@rŠ@š @É×@ÓÝ@Ž6@€À8@XZÙ@0&X@ZX?½P}?[[c>ƒ&l¾³ Ö¿lE­¿¿·ÀlÀ+®˜ÀS×áÀþÀ˜œÀ±L)ÀÊ‹;ÀåhmÁ¹wÁ)#Áæ Á,ÜrÁ;þ“ÁK?úÁZÁcF`ÁTŸÁDôšÁ5øBÁ',Áž Á aÌÀù#wÀÞÀÃdÀ©ð¤À‘½Àr;ˆÀEøÀŸ¿ÝA¿Š]Õ¾Ü>>UÖH?^HE?ÀPd@Ę@.Ï‹@SU@uÿã@ŠË—@ŠÐØ@‹ =@‹G@‹œ¿@‹ù‘@ŒVd@Œ“+@Œ²w@ŒÑÃ@Œñ@Z@0@­¶@~•@YÒ¼@3wž@ •u?Í \?->ÃȾB4?¿D{<¿§d!¿í,„À›ˆÀ?Àf›’Àˆ®}À eÀ¸çíÀÒßÔÀí…ÙÁb7ÁuªÁ åJÁ/š]Á>„ÎÁM˜ÿÁ\ÎdÁguÁX ÁI-‚Á:ˆÁ, fÁÁ±ÁG:ÀérÃÀÏ»KÀ·leÀUÀ„·œÀ_ÙÀ51ÞÀ ?-¿Ä´Í¿hå¶¾šÁÜ> â›?j¥?¾á @×p@&6@F„c@dÉü@€Wo@Šõ‚@‹3b@‹qB@‹¯!@‹í@Œß@ŒI-@Œu{@Œ¡Ê@ŒÎ@‡}L@r%t@RªM@1"¥@ î?ÒI§?†#o>èß½ø´'¿,ÿþ¿›{˜¿ÞcØÀã}À3‹ÀVí›À~ ÅÀ“NòÀªe¾ÀÃ>ÈÀÜ“JÀ÷YÁ s^ÁZŽÁ%dÁ3»“ÁBTïÁQ"ËÁ`ÀÁkµ\Á]¯ÁNŽmÁ@QøÁ2=ÕÁ$1wÁKðÁÚIÀø¾ÀÞ47ÀÊ™Àª¹ À”QÜÀ}^ÀS®KÀ+ûÀŸÀ¿ºŸ"¿\ÿÔ¾wx>’ ó?UrŽ?®—z?ï9@#Ê@3›G@M~*@dëÆ@xú-@„l¯@Š2@‹ËÍ@‹íÊ@‰å’@…»@€Ï@oôÒ@[[V@Bí@%m@ ?ÊRŒ?„º?-à½ÁÐÔ¿T/¿–:K¿Ø¥(À @õÀ-oðÀO%ÙÀtbwÀê³À¢ó¬À¸zéÀÐ]ºÀé­%Á |Áþ8ÁÚdÁ*ökÁ9 #ÁG\ÁUÐäÁdzhÁq`ÚÁcÁTèYÁFÂxÁ8²áÁ*÷,Á© ÁÏ´Án÷ÀìuÀÓ™vÀ¼§ À¦-ËÀòÿÀví^ÀOsgÀ(\0ÀfC¿¼e¿iÃǾÀtÆ>á§?#¤+?a–?ÊöÇ@«L@o™@.Ïð@B:@Q4ñ@[!y@`Y@_:m@ZI"@Rl@GõB@9¿c@'Î@ô?íÏï?´]j?g!›>Ó_n½ïÿ%Î8¿—n¿ÙÿÀ 5ÉÀ-}ÀM÷æÀqŒfÀ‹À +À´¼ÍÀÊ[Àà ÓÀøÈÄÁ  Áã¼Á#*4Á0äBÁ>øûÁM=Á[ˆ|ÁiÝêÁwã7Ái°HÁ[ŠtÁM¥ Á@ŽÁ2ä/Á%È\Á7JÁ ÄÀýT'ÀåiyÀΰÀ·Ÿ„À¢-€ÀŽGÀtŒ›ÀN¼nÀ*y¦À¼œ¿Ê)¿‡Ã¢¿uͽ±h>>¿å¤?N– ?šó?Éš?ñßž@ ã&@ñ@!ù°@&eŸ@%i @ ˜@µ¾@$r@À?æFg?¼´â?ŽŽ£?0Ë>mùE¾|òÿ¿=´'¿ rÅ¿á ÝÀJ+À.éÀNÁÀmÕŒÀ‰QïÀœ˜ÌÀ¯+tÀÄÜÀÜMàÀò^ƒÁ‚ÁP]Áý‰Á*¿PÁ7èµÁE}‚ÁSiÁa›1Áoô§Á~¤qÁp¥FÁbéñÁU†ÁHJÁ:ФÁ-­Á ‰Á“ÀÁShÀöàfÀßÒIÀÉ_åÀµk]À¡tÙÀÛVÀwF‰ÀS“ À10üÀÓοâ쿤f·¿Un¾Ë"<©1=>ÊuÈ??m?†JV?§Ž£?ÁSÿ?ÒP?ÙN"?ÖØ?Î!a?Ây¡?°S¿?™Mz?wfæ?-þ4>­X½Fˆ ¾ìgí¿fi¿°~ë¿ìÚÀK–À6%DÀR„‰Àq§À‰²ßÀ›.…À¯ÌòÀÁ»)ÀÕ‹BÀì ÁE½Á â¡ÁøwÁ&‡sÁ3M·Á@šÁM JÁZ}›ÁhAÁvIÎÁƒ˜ÁxlNÁk¢Á]B•ÁO‘ÁB8×Á5OVÁ(×›ÁwÏÁ}øÁ³DÀòl¨ÀݘØÀÊjêÀµ>‰À£( À‘²+À~=ƒÀ]ІÀ=û|ÀÝ·ÀôÿËÂÚ¿•Ê(¿H\Ž¾Øø²½Â©Ð>G¢í>à¦-?  ?>Hç?IŠ›?FÎG?8V…? 7º>þÃú>²Ì>ì–¾ 8¾á«c¿J8æ¿—–V¿Ëï‚Àq,À LÀ=¹pÀ\—ÀyÎqÀÞÀžåºÀ°¨„ÀÃ:úÀ×x'ÀéqÊÀþ1-Á ‹‡ÁÓÁ#HÁ//Á;ÙÜÁHÔÆÁU‹ðÁb{]ÁoɉÁ}gˆÁ‡ IÁ€"ÁrpÃÁdäÞÁW¯ÁJà<Á>cUÁ1ùÁ%îÓÁú Á`5Á±'ÀôY†ÀÞÉ1ÀË”‰ÀºáÀ§ì¶À–_À…wÑÀkÔiÀNR÷À2=À&R¿ûžG¿ËåU¿ 2ð¿q2¿*í¾â.¾‹EE¾A½ì¾Žz¾3`T¾‰:¾¸™¾óîY¿4e\¿uˆ¿ŸP¿ÇÝ›¿ö«ƒÀ ØÀ.²4ÀKöÀi‘(À‚ùúÀ’v0À£ÀµàÀÇ®aÀÙ¦"Àí(»ÀÿÏÌÁ p'ÁõÁ¢þÁ+æÁ8¤0ÁDµ%ÁQMNÁ^S~ÁkJˆÁxäÁ‚§aÁŠÅÜÁƒî=Ázs…Ám\ÇÁ`¦rÁT!ÁG¹ìÁ; ÏÁ/’]Á#îPÁIÁ2=ÁÅ£ÀõƒÀâÇ2ÀÐãÀ¿ÊÀ®Z“À‹±ÀŽ„}À~¤¬Àc§ÀI¼%À0éÀ’8Àe¿äߨ¿Ä¿©K¿”ÛÌ¿†+Ä¿ƒ ƒ¿„ ©¿Š=.¿•*Œ¿ŸÇû¿«KÉ¿Æ ¿ä_ÀaeÀÆÀ+ ÀC‚;À\ŸPÀx¢ÀŠìxÀ™•XÀ©yÂÀºÀÌóÀÞF®Àñ2ÁâgÁ ÁÉÁ­MÁ)Á5wÁASÁN0ÁZt[Áfø²ÁsåaÁ€”Á†öãÁŽ»ïÁˆUÁšÁveÁjÇÁ]§!ÁQ²ÁEdŒÁ9½ÃÁ.ÇqÁ$¤ÛÁÍÁ9˜ÁrfÀúîÀèâtÀ×Ò ÀƉµÀ¶ORÀ¦æGÀ˜•ŠÀŠÛ À|³cÀeYNÀO À;›úÀ) AÀ£]À uÀ-q¿úÚâ¿ö=«¿ø¢ï¿þÊkÀûÙÀ zÀ€À-À'CÀ8ËÀJÀ^Ð]ÀtÕâÀ†öHÀ”PÓÀ¡ñûÀ±KjÀÁž1ÀÒ%ÉÀã«íÀõ°ÁÅéÁ iÛÁ7Á ìÑÁ*ÁÁ4A Á?2ÍÁJÐËÁVÿÁc¦Áp]3Á|ÏÁ„Ñ<Á‹døÁ“7ÁŒ•ŒÁ†H\Á€tÁs±,Ág~ÁÁ[`“ÁO¹úÁD°%Á:^òÁ0wpÁ&€ÁñêÁ+KÁ KªÁϺÀðº ÀÞ´ÂÀΘÎÀ¿^(À²˜À¤EÀ™fÀ2dÀ‚,IÀr‘À`ƒ«ÀR¡ ÀEv–À<žØÀ8àÀ5z½À6ÙJÀ9 ÜÀ=*´ÀB,YÀIÂêÀRHÀ^¶½Àn&¡À~ôÀ‰ÃæÀ“—üÀŸªìÀ¬ÚÀº¨ÀÉoõÀÚ,eÀë8jÀûüfÁíÙÁ»ìÁÈäÁ"¥ Á,·¸Á6dÁ"ÑýÁ¯TÁعÁZ Á†áÀôeóÀçÙÀÀÚæSÀÎíÂÀÆAÀ¹í À±LÌÀ¨ã À¢ÇÉÀaÀ™à¨À–dÀ•t.À–.ÔÀ—Y5À—D®À™vËÀœÊ€À¡Ç¬À¨&À°3uÀ·)ÛÀ¾«;ÀÈéÁÀÓ{9ÀßôèÀìñÀü Áõ™Á¶±Á•Á ðÁ(u!Á16ÊÁ:2qÁCã&ÁMíwÁXJÁa ôÁkÍÁv¬Á€Ÿ¯Á†oÁŒu‚Á’¬_Á™ ·Á¡@ÏÁ›^Á”û@ÁŽ÷sÁ‰'Áƒ’£Á|€¤ÁrråÁhOkÁ]ÊÁSlvÁI¢õÁ@ªÒÁ8 Á/3@Á&=jÁŽ%Á2„ÁQÁñ—Á¨SÀöJ_ÀëñÀßF¯ÀÖ1À͵§ÀÆ4ZÀ¿5Àº©ŠÀ·'éÀ³‹´À²›ìÀ´=Àµ7À´òõÀ·“ÀºrÀ¿$ ÀÄüqÀÍxÀÓ¤åÀÚj0Àä€ÀïX¯ÀûaÁÖÍÁ Ü´Á•XÁ Á$"WÁ,û Á5R_Á=¸)ÁF«œÁOÝÁÁY¾…ÁcÓûÁn&ÊÁw“?Á€ÓÁ†&7Á‹ºÇÁ‘‰/Á—ŠÊÁ¹¾Á¦@;Á uÁš Á”Q?Á޹<Á‰^<Á„G¨Á~˜ïÁsýÁi‚%Á_‹ÁVObÁMAÁDÊ:Á;ÝmÁ3 kÁ*]ªÁ"™Á†ÁËÁ[%Á >RÁ\jÀû%¬Àò"Àê0½Àâ¯$ÀÛÊÀØQÿÀÔ”ãÀÑÀÐ`ÌÀÒÁÛÀÓ´ÎÀÓNÓÀÕBŸÀØñÀݬÀâ‘fÀêžÀÀðó”À÷0êÁBØÁË Á v²Á£¤Á!ãÁˆ¾Á'…%Á0‹“Á9¥^ÁBD ÁJ›‘ÁS4ÖÁ\TQÁe¸bÁo¹#ÁyÛXÁ‚FÁ†Ñ.Á‹ê Á‘EóÁ–ÝÇÁœ«Á¢¨3Âë¿Áý ÇÁ÷sÁñGÄÁë ÁäýÄÁÞõdÁÙ îÁÓ1¬ÁÍFžÁÇlÁÁ·èÁ¼,™Á¶­SÁ±JIÁ¬ÝÁ¦ó/Á¡ùþÁ@ÆÁ˜ËÌÁ”s¡Á;FÁŒU–ÁˆÊmÁ…]Á‚½MÁ€PÁ{^ˆÁwšÌÁt€­Ár ûÁp52Án÷ÁnÆ’Áo'ùÁpeÁqà¤ÁtWDÁwD9ÁzÝ“ÁjüÁ‚i]Á…?ÔÁˆm·Á‹þIÁê6Á”&ÍÁ˜ÛÁ'ÚÁ¡î!Á¦Ç‹Á«Ú£Á±% Á¶œWÁ¼ÁÁ¾GÁÇuFÁÍ9DÁÓ!šÁÙ+ÌÁßBXÁåc÷Áë¡ÊÁñðñÁø5Áÿ{óÁù)ýÁòðÁì½ÐÁæ’ÁàpÁÚSTÁÔJŠÁÎ_ÊÁÈ}$ÁœœÁ¼Ê,Á·¾Á±–Á¬ Á¦ÄûÁ¡Ÿ×ÁœŒÁ—§•Á“ÁŽš‹ÁŠ?KÁ†-#Á‚x+Á~QÁxtÿÁrÛJÁnòÁj9vÁfÍ(Ád>pÁbu¬Áa'Á`÷<ÁaWèÁb5¶Ád05ÁfÓÈÁi½­Ám‹ƒÁrYÁwÙðÁ}¯pÁ‚-¯Á…èàÁ‰üÁŽ=tÁ’»Á—~ÁœS…Á¡U<Á¦’ÓÁ¬pÁ±,Á·*ÜÁ¼Ú¾Áš„ÁÈ>ÁÎŒ"ÁÔ¨ÁÚÌ Áá–ÁçNÁí’ºÁóÚŒÁûA©ÁôàÄÁî‹ÁèN2ÁâÁÁÛèZÁÕÎ>ÁϹnÁɱ¹ÁÃÁÜÁ½ÖÂÁ¸›Á²=>Á¬”XÁ§ÁÁ¡¦ïÁœ[Á—> Á’?8Ái—ÁˆÑpÁ„s Á€8ÌÁx¬ÔÁq· Ák¡×Áeè~Á`ßÃÁ\âUÁYe•ÁV­ÿÁTö´ÁS¦ÁSp&ÁS³ÁT¹ÁV²ßÁYPMÁ\ƒìÁ`“Áe¤EÁk ëÁq@ºÁxB?Á€QÁ„ùÁˆrÁüÁ‘üÁ–í3ÁœEÁ¡„LÁ§Á¬ªÁ²UzÁ¸îÁ½õ6ÁÃÿÂÁÊ 6ÁÐEÙÁÖwÁܳôÁâÿ…ÁéOöÁï¥lÁ÷"‘Áð»ŒÁêVÁãþÁݽ7Á×€˜ÁÑO¹ÁË;\ÁÅ0]Á¿-fÁ¹5ÁÁ³DÁ­u,Á§ÄeÁ¢)&Áœ´±Á—FðÁ‘ùçÁŒãöÁ‡ý—Áƒ0cÁ}eçÁtõ&ÁlÛ‘ÁeŠ»Á_"­ÁY\±ÁTíÁOÍÁL\ªÁIy#ÁGÄ|ÁF„,ÁFB½ÁFfäÁGa@ÁIiQÁKî%ÁO…çÁT¹ÁY'äÁ^ÍåÁeCdÁlŒ,ÁtI¿Á|¬>Á‚âKÁ‡»«ÁŒ© Á‘ÄÁ—Áœ–TÁ¢+Á§ÝÁ­ ]Á³Á¹…ñÁ¿žFÁÅÅ-ÁËñ°ÁÒ*ÐÁØ}³ÁÞ×Áå,fÁë„”Áó&oÁì­Áæ@sÁßÜ6ÁÙ„SÁÓ?²ÁÌýóÁÆËXÁÀ¹@Áº±”Á´°…Á®¹KÁ¨ÊÁ£ÁbMÁ—Ï¢Á’XÁŒé=Á‡¢ÌÁ‚£PÁ{ŸŸÁrAÁi˜ÅÁa…¡ÁYÜœÁSâÁM7ÈÁG§ÁC&•Á?µ#Á<³Á:ïCÁ9ÐÁ9rgÁ9ˆ$Á:’5Á<[ Á>ððÁBÏpÁGŽÁL·<ÁRÙÁY¯¬Á`êÁhåÛÁq­™Á{+òÁ‚Œ6Á‡”ÉÁŒÓJÁ’0pÁ—·õÁs‚Á£F:Á©&çÁ¯<Áµ"þÁ»JÁÁ|ÁÇ·xÁÎîÁÔr‰ÁÚ»aÁáÁçDÁï5ùÁè¶1Áâ;»ÁÛÇaÁÕjxÁϘÁÈØ¯ÁÂ’ Á¼^›Á¶IòÁ°;)Áª;yÁ¤P®Ážm‡Á˜ªNÁ“\ÁyÁˆ‹Á‚§gÁzêMÁq"^Ág­ÆÁ^œšÁV[ ÁN¼ÁGŸÜÁA†7Á;ÑuÁ7wÁ3}¡Á0sðÁ.Š Á-D?Á,¶µÁ-$Á.$qÁ/¬EÁ2q Á6‘Á;=Á@¯èÁGB<ÁN4jÁU°Á^´ÁgD¶Áq7Á{#ÃÁ‚­ÓÁ‡ì:Áf¥Á“AÁ˜ý8ÁžÞûÁ¤¿7Áª¿âÁ°è Á·±Á½]ˆÁùjÁÊÁÐ[-ÁÖ±èÁÝ$6Áã¬æÁër ÁäÕÁÞO7Á×ÖŽÁÑ`ýÁË€ÁÄÀdÁ¾ðÁ¸=˜Á² ©Á«ôæÁ¥ÞÍÁŸáŠÁšµÁ”3×ÁŽzˆÁˆÛÁƒE7Á{ÉVÁq+úÁfûJÁ]wÁTCãÁK—ÁCÖùÁ<»Á60°Á0~çÁ+‰HÁ'ÃmÁ$Á±Á"‡™Á!3Á f$Á!)™Á"RÁ#’Á&ŠòÁ*μÁ/x~Á5F ÁœÁÓ'ÁÌêÁÆGÁ¿·sÁ¹CuÁ²×ÔÁ¬wÁ¦/“ÁŸèüÁ™»ÐÁ“§‹Á–Á‡¢"ÁÊÅÁx“Ál¦ÏÁaˆVÁVµ;ÁL#ºÁBÓÁ8DÁ/% Á&†•Át=Á6ÄÁ§Á Ž]Á&BÁëƒÁ°äÁoÀÿóœÁFÁ©ëÁ¨¥Á½ Á %£Áù¨ÁC3Áí-Á&9Á.°ÛÁ8ÁB8ÈÁL„ôÁWQVÁbdÂÁmÅÁy˜ÊÁ‚¾WÁˆÏšÁŽ÷-Á•[Á›OöÁ¡ŸÌÁ§óQÁ®?MÁ´‘wÁºÿÍÁÁu ÁÇ÷Á΋“ÁÕ&ßÁ݉ÁÖæÁÐERÁÉœ~ÁÂû–Á¼Y™ÁµÈˆÁ¯U¸Á¨ñïÁ¢••ÁœMôÁ–ÁÁ߆Á‰É Áƒ¹Á{µñÁpTÁdâ…ÁYuØÁN’—ÁD- Á:qÁ08Á& ÁØôÁ}[Á<ùÁöìÁ’&Àüa9Àõ¤2Àð±âÀíÚÖÀì‚vÀí¿Àïæ†ÀôGBÀúã ÁÈ€ÁÙ Á Š›Á†ÁÚbÁ&žÁ0_úÁ:œíÁEÉÁOÚÕÁ[æÁfÀ\ÁrU>Á~?Á…<Á‹Z„Á‘ŽmÁ—ÎCÁžœÁ¤cÁªµÜÁ±$šÁ·–™Á¾ xÁÄ’ÃÁË4›ÁÑ¿˜ÁÚQ©ÁÓ•sÁÌð:ÁÆSÍÁ¿·Á¹OÁ²éÁ«þ Á¥ŒfÁŸ(ÁÁ˜Ú Á’–)ÁŒYÆÁ†<Á€%žÁt:êÁhŸXÁ]KzÁQÿLÁFù"Át$Á3’ Á(ÁãÁ—\ÁüJÁ yXÁñvÀök8Àç EÀÚapÀÐÀÇ£$ÀÀà€À¼‡ÖÀ¹X³À¹À¹±À»ÿÐÀÀØúÀÆQ/ÀÏ·PÀÛ&]ÀèÞ$À÷ÈŠÁ²ÿÁ ·¥ÁŽ‘Á!¤;Á,f(Á7ÊÁBJÿÁMjÁYCöÁe|~ÁqU‘Á}‰öÁ… Á‹T•Á‘‡¨Á—ÇmÁž*‘Á¤¯WÁ«8ÁÁ±·ÌÁ¸N;Á¾ý¹ÁųpÁÏ+ ÁÈYÅÁÁµÁºÌÁ´PÁ­q’Á¦Ï¡Á >Á™¹Á“.bÁŒ­?Á†LÁ€úÁs„‰Ág^–Á[…™ÁOÍ ÁD4<Á8æFÁ.bÁ#jØÁX ÁÅÁËKÀül.ÀíSßÀÞéEÀÓ&*ÀÉHÀÀ¾ÙÀºHÀ¶3RÀ³§¢À²wgÀ³„[Àµ®Àºg0ÀÀâFÀÈÉ?ÀÓºáÀàf®Àï¿,Á.×Á BpÁÈÓÁýÁ'Y–Á2;ÃÁ=DêÁH ÙÁTkôÁ`)ÁkübÁx,ÜÁ‚S§Áˆ{’ÁލaÁ•¨Á›öÁ¡÷Á¨hÁ®ù˜Áµ¨Á¼dÑÁÃ"&ÁÌÎÁÅéöÁ¿Á¸aÁ±ª»Áªù&Á¤IZÁ¥ÃÁ—!ùÁ¨¤ÁŠ2ªÁƒÕLÁ{/jÁnÕþÁbu¯ÁVkÎÁJ³ˆÁ? ³Á4ïÁ)kqÁãÃÁáœÁ ¡Áµ•ÀôáßÀæ»KÀÙÀÍí·ÀÃþÀ¼c­À·ÄÀ²Õ¦À°Á2À¯±:À¯ÛÀ²ˆ®À¶~À¼fûÀļæÀϬÀÛ>AÀê(ÈÀúPÄÁ¨×Á[Á'ôÁ#rÒÁ-¨‡Á8Œ%ÁD}ÁO´Á[^ÁfòùÁsAtÁ‹¬Á…ßÁŒ)cÁ’žXÁ˜ò ÁŸY¥Á¥ä0Á¬Ž6Á³N?ÁºðÁÀÚuÁʱcÁÃÄÁ¼âQÁ¶¤Á¯WÁ¨™{Á¡íÁÁ›LAÁ”´ÁŽ;qÁ‡Ñ„ÁncÁva¹Áj!Á]ÊeÁQµÀÁEäëÁ:ŽyÁ/pxÁ$êlÁ¯‡ÁüÁªÀþ±”ÀïEäÀá],ÀÔ–˜ÀÊ6žÀÁ/ÂÀº“NÀµFÀ²BÀ¯ÀGÀ®ÿ¤À¯ƒbÀ°â}À´íðÀº1ðÀÁ¸mÀËàÆÀ×Àä¯õÀôLÁÀÁ úùÁžiÁsøÁ)¿^Á4ͨÁ@©ÁK6ÁV¹qÁbÄÁnóØÁzûOÁƒ­gÁеÁ@“Á–™qÁøÁ£ºÁªx³Á±1ïÁ·êaÁ¾¸×ÁȵÌÁÁÐàÁºó?Á´éÁ­KþÁ¦‚çÁŸÄÁ™#Á’™ÎÁŒ3Á…²&Á~¼ÙÁr&ÁeÛìÁY¯mÁMÀÁBŽÁ6¨=Á+Ý}Á!hÁ‚®Á ê`Á&%Àù¢ÀêÛÉÀÝŸÀÒÔÀÈÍÀÀ3À¹ÔÁÀµªÇÀ²ÇÀ°û½À°Y™À°‘À²ÚÀ´÷ÐÀº>rÀÀßXÀÉöÀÀÕEqÀážáÀðš”ÁØÁ cõÁÛ¶Á¾¶Á&ÝgÁ1ŽiÁ<—•ÁG—ñÁSgÁ^þ^ÁjôÁvæeÁ¡¨Á‡é¥ÁŽ5íÁ”¥Á›9%Á¡ä5Á¨sÁ¯ãÁµèÁ¼È©ÁÆ£¦ÁÀ DÁ¹#øÁ²@‹Á«b7Á¤›uÁè°Á—BpÁ¯ÇÁŠ@’ÁƒãîÁ{29ÁnÉ<ÁbvÛÁVróÁJ¯Á? ~Á3æÁ)XÁøøÁ&³Á ¶¦Á>ÀöQSÀè%ÀÛIÇÀУ¹ÀÇFXÀÀoÀº¶…À· ôÀ´œMÀ³)ˆÀ²r«À²™uÀ³ÆÀÀ¶—=Àºú?ÀÁ˜AÀÉ»WÀÓÛ&Àà~(Àî‹ÈÀþ8ÁTÁ•wÁXžÁ$#*Á.Œ—Á9i›ÁDaÄÁOæÏÁ[©_ÁgGéÁs`ÑÁÚSÁ†1pÁŒ}!Á’îÜÁ™w±Á ÜÁ¦¢ëÁ­a˜Á´:‘Á»*óÁÁ<ÙÁ»|ÅÁµè@Á°ƒjÁ©ÅüÁ¢ïãÁœ47Á•˜}ÁþÁˆ¦Á‚QøÁx9ÁkЖÁ_“ÁS±§ÁGæÈÁ<‡iÁ1—«Á&ÕÉÁ¿îÁ Á :ÁÆÀôÍ>ÀçÀÛ%yÀÑ7ÀÈT^ÀÁŽ>À¼ºÀ¹5áÀ¶ØŒÀµ3¦À´wÀ´›øÀµØ4À¸a~À¼ŽÛÀµÀÊpAÀÔ7ûÀßwÀíBÀüx"ÁÁíZÁmœÁ"ÚÁ,hÂÁ7 ›ÁAÍÁMõÁXœ~Ád:åÁpGÁ|¯Á„ ÁŠå¶Á‘dbÁ—îwÁž€kÁ¥0¿Á«ü„Á²àrÁ¹Ñ¢Á¼|Á¶CÁ°[-ÁªÉ{Á¥j·ÁŸ}*Á™ˆïÁ“Æ2Á¨vÁ‡IÁHÁuƒ!Ái#ÉÁ\ôªÁQ!uÁEšàÁ:GÄÁ/’~Á%GÉÁ\ÎÁ0Á p§ÁžèÀôqàÀç0aÀÜH‚ÀÒ#UÀÊB Àä¿À¾Ÿ•ÀºÓÀ·ÙµÀµWÀ´ À´kAÀ¶ŒÀ¹º©À¾4ùÀÄ'kÀË·ÔÀÕ- Àà"ÀìÆ®Àû›æÁarÁ ê«Á)âÁ ”ýÁ*®yÁ5¼Á?Æ…ÁJÙ ÁVxÁa¼ÒÁmç9Áz@ÁƒWåÁ‰²ÇÁ!öÁ–¢»Á6‘Á£éQÁª¸ÃÁ±Á· ©Á·Á°ì}ÁªÿÏÁ¥?ìÁŸ±¬ÁšYIÁ”YúÁŽa—ÁˆžaÁƒÁ{n"Ápª Áf Á[ RÁOo%ÁD'íÁ9/¾Á.ƒUÁ$¨ÁÍXÁφÁ UNÁšÀõiÀèñÀݪëÀÔ6hÀËä¥ÀÃÅUÀ·€lÀ­KÀ¤¹¼Àž¼¬Àœ"àÀœ4žÀ¡T À§òoÀ±ðÀ¾_ÀÌKÀÖ\ÙÀáEuÀí‡^ÀûiýÁpdÁ “jÁ”œÁàIÁ)²xÁ3²ÔÁ>sÁIk”ÁTtKÁ`¤ÁlCÁxiµÁ‚r¤Áˆ²ˆÁCÁ•‘Á›){Á ÌÁ¦–ÝÁ¬†Á² Á²* Á«õ Á¥ÚøÁŸëÄÁš,cÁ”¢aÁP½Á‰>+ÁƒABÁzûžÁoø7ÁeXAÁZv÷ÁOÊñÁDßÿÁ:gÜÁ/ð¶Á%ô¹Á Áî:Á SKÁêîÀôê9Àæ— ÀÙ˜RÀÍu¹ÀÀÿæÀ³ØÑÀ§}×À›À?NÀ†ÊmÀ€­ˆÀzæHÀ{~¿Àƒ"dÀ‰üïÀ”·íÀ¢hÀ±¤™ÀÂiÝÀÔ¼²Àè>5ÀüÁ±Á¨Á~(Á¢ÏÁ)ôÁ3ÃÁ=¼ÁHVgÁSAâÁ^ÊŸÁi‰œÁt;³Á ™Á…~ÁŠˆÝÁ»Á•¾'Á›„­Á¡lŽÁ§rÁ­›ûÁ­"_Á§´Á ñâÁšÒ‡Á”àÊÁ"\Á‰¨Á„SNÁ|WeÁpSÅÁdÍ6ÁY×”ÁOEZÁDKbÁ9p¹Á.y²Á#ï(Áz´ÁÔÁ¶FÀù­Àèy?À؉:ÀÉÁ;À¼H¯À¯ÙäÀ£¿©À–÷ÏÀŠÓ?À}!2Àf=£ÀSšÀEíÀ=†ÎÀ>—×ÀIáxÀX¨ Àq”°À†¬äÀ— ªÀ¨Ý À»™RÀÏxÖÀãjÕÀ÷²ÁœãÁ‰ÁiÕÁ!Ý!Á+@wÁ5.Á?R`ÁIBdÁSªzÁ^^ Ái'vÁt"Á$oÁ…!ÀÁй¸ÁuÁ–T‹ÁœYÒÁ¢Š¦Á¨¤Á¨U˜Á¢0ÁœeÁ•ú6ÁÕAÁ‰áÁ„$9Á}LŠÁr¦cÁfJÁZJàÁIÄÁS«£Á^È>Ájt0Ávœ—Á¥Á‡›çÁ§tÁ“ÜÔÁš½ùA?,5?V¯Ð?Q¬?1”> _d¾µ=}¿he¿ÀìšÀH?À/ÌÀW¥üÀ€[sÀ”€nÀ¨ì²À½7ïÀÑÚ®ÀæmÀûU¨ÁJ9Á´ÁÞMÁ(ß®Á3—Á=ëwÁHô ÁTž…Á`ÑÁmFeÁybîÁ‚Æ/Á‰/ÁkÁ•ûÁ–O”ÁÞëÁ‰pÁƒcÁy‡Ám"9Á`ýÁU?¥ÁI1‡Á=AÁÁ1õ<Á'm6Á]%Ár×Á°pÀð¢sÀÙ ÀÀäÒÀ©-qÀ’>5Àw’ZÀLš^À$œº¿ü¹Ï¿·÷ì¿rb¿ìƒ½ñ*a>„åZ?n?sM?¤½.?Ë“–?æïÝ?áØ?¸åð?}Ç7>íg½ã>Y¿4¥^¿¬Æ¿û[ëÀ'4!ÀOÕ;ÀyxÀ‘ÁÀ¦OuÀ»4ÀÐP®Àå•SÀûGúÁoçÁy¸ÁGšÁ(dUÁ3RŒÁ>øÁK)ÌÁW‚íÁc²FÁoòéÁ|xlÁ„®ÛÁ‹J½Á’ CÁ’ Á‹„Á… Á}AhÁpeêÁcÔÈÁW—½ÁKœfÁ?ï‚Á4 @Á(HüÁÐÁ#:Á 6Àô¥ÀÝQ)ÀÄþbÀ¬‹ÒÀ”GŽÀxY¼ÀJ5šÀPå¿ånã¿•ƒØ¿ü½{Œ >ÍËá?PŠ5?—{??Ä“?ðVF@ ¥«@ ¾å@0|}@+äM@ýC?ê¶Ž?¤„Ï?0g‘=‚¿犿šgs¿í[À ¯ÁÀIÊ0ÀuB À˜„À¥LÀº¯`ÀÐÄ/ÀæEÀü8zÁ ÌÁ1¼Áø˜Á)“Á5©ûÁAãmÁN1DÁZŽ=Ág!aÁtÌÁ€µ»Á‡zôÁŽE³ÁݵÁ‡@ Á€½¹Át©ÑÁgÍùÁZï1ÁNMÁB'EÁ6aŠÁ*ƦÁÿÁ†ÄÁ]ËÀù€kÀáÑ(ÀÊf²À±ZÀ˜±±À€\ÀOŒ™ÀXî¿ßÝ–¿†á¾Æå>qŽ$?IN}?¤öö?Ý@ð@ ”@3Éc@I¸@\˜õ@lj@eý-@K Ô@*(Ø@;‹?¼b ?XèÂ>LÊß¾æëà¿q©¿âù Àù5ÀH!@Às´ÔÀ`À¦@dÀ»à½ÀÒIèÀè"(ÀüÍÿÁ £Á„ØÁ b.Á,HÁ8ðˆÁEljÁR\Á_¸Ál~ÁyõêÁƒ¼åÁŠyjÁ‰õþÁƒ'Áx÷>Ákô½Á_9ûÁR”7ÁE¹Á9VÁ,âHÁ!AxÁ³©Á 2ìÀý4À棫ÀÎðˆÀ·œˆÀŸïÀ…ÇëÀXÜÀ'P¿ì±Ñ¿ˆ¿n¾­?Ý>¹%?üU?З¬@ §¶@(Íw@Bo@YßÀ@o±@‚[@Œë@”MQ@2@€Ûç@^„¢@8Qy@ËÙ?Í¡W?t}¯>âX¾Ç迈#™¿â"îÀ²ÊÀIîDÀvýôÀ‘ó*À¨®½À¾|XÀÔ½Àép}ÀÿÇ‚Á lÁyñÁ$ Á0¤åÁ=YkÁJuôÁW¿çÁeøÁr‰kÁÀËÁ†ˆaÁ†<Á~ÆõÁqÏÁc£ÉÁVˆ8ÁI×QÁ=ˆ{Á0ÖzÁ$ ÏÁþ1Á |eÁòÀëI~ÀÔ–À¼p]À¤¿‘Àz(ÀgÂÀ3¥¸À¤S¿~¹¾åå >ª;?‰ w?âæó@Þ@@£5@av@}¼0@Š´¼@•Â@ 7 @©Õò@±À=@«ùM@›xÔ@‰&F@i–ü@@Õc@T?׿¦¬Ü¾Àî¿‹þ9¿æÕNÀ!8`ÀPCÀ~³À•ˆÀ¬!eÀÁÂAÀ×¾¹ÀîtÁûJÁ›LÁJ¾Á)lÁ6#ÁC=»ÁPvÈÁ]–­Áj·jÁxsÁ‚åBÁ‚©˜Áw€ƒÁiÔqÁ\)vÁN—BÁAaZÁ4ŸÁ(j«ÁhëÁ¿Á­UÀðÄüÀÚ€ ÀÃ%¾À«”EÀ“ñŒÀuéúÀDÀcÀ‡Ã¿ºJ(¿"èÒ>hd?s÷\?ÝØ]@†ª@K¶Î@tÒD@Œ}I@›ð¹@¨eÒ@²6@²•z@²ª—@²^¤@²ød@²Ð@@¡Õ%@m @q;@EÉñ@„÷?ÛåÀ?}©>–§T¾Ü=€¿—ôg¿ö‚›À*¼îÀYN(Àƒ¯ÊÀ™ô4À°ËÀÇ ÷ÀÞv—ÀöçôÁùÑÁ·ùÁ!Ô€Á.óÑÁ;ù»ÁHÝ{ÁUû±ÁcxÁqC+Á~ÓÁ~õDÁpÅÁbÒ¬ÁU#SÁGƒèÁ9éÂÁ,šgÁÉÁ˜4Á“À÷ÖoÀà^`Àɤ¿À²êèÀ›µïÀƒóßÀVæbÀ#Ó˜¿Þï:¿m½þ½èÑ;?6‡ ?Ä–ñ@8@HŠ%@xŠ^@“ à@§c7@°w@°Øþ@±`B@±ç…@²nÈ@²¢@²z]@²R9@²*@¥‹@Ø´@t.<@G¸k@”æ?×Qâ?pØâ>:¿VŠ¿­ÑúÀEmÀ7Q¨Àf ‚ÀŠGÀ ëâÀ¸@¿ÀÏSÌÀçhÁo/Á ›/ÁØoÁ'ºÁ4€ÁA¬¥ÁO?Á\§4ÁiõÁw”®ÁytÙÁjï«Á\žìÁN‚Á@ÉKÁ3>Á%ºÁZ¢Á ƒZÀþÇ_ÀçËÚÀиÓÀ¹í:À£gTÀ‹ãxÀi¤À8ÀöD¿¡÷¾ß§P>Æ+?Ÿ[†@|Ä@:eo@o6@‘*°@©Y|@¯–á@¯£Æ@°+ @°²M@±MV@±í)@²4@±òð@±Ð¬@±¬@²“@¦ëÁ@­È@r»ù@CÐâ@ÌÎ?Äø“?B%|½Ô™¿SÁÏ¿ÍgõÀzYÀG·2ÀuýÜÀ‘åáÀ¨¯¶ÀÀÀÙ\<ÀóàÚÁÁÞ,Á ½uÁ-ð\Á;CÁHŠÁUrõÁc,îÁq.¯ÁsÏuÁe©ÇÁWnHÁHÿöÁ:ÓÁ,÷ÔÁ|WÁ#ÞÁßåÀð*@ÀØK¸ÀÁƒ9ÀªØhÀ”ØÒÀ|QYÀL6À•?¿Î ;¿OÉ0=Å?]}Í?Ûïý@%Fº@\ '@‰ @£éÞ@®Ñj@®¾Z@®ùý@¯™Ð@°9¤@°Ùw@±yK@±„Ö@±b’@±AE@±q@±¤#@²I@¦+o@Ž^Í@k£Ø@9GÂ@ò ?¤Q%>êX¾µå¿•T¿ù bÀ-"ÏÀ\ú'À„èKÀ›Î‹À´ äÀÍjöÀçdaÁ»Á Ì™Á¸Á&óbÁ3õ)ÁAiûÁO;rÁ]X3Ák²ºÁnaäÁ_äyÁQŸQÁCž»Á5òÁ'ÔoÁí.Á x^ÀþÕÀå ÀËô¸À´ÙGÀžzÝÀ‡´×ÀcÔÀ2ñ’ÀŒ¡¿œN¾¾Æ{á>áòq?¦RG@ úa@BR©@yÍŽ@˜ÏÀ@®y¿@®a@®zþ@®Ø@¯E.@¯ÅÅ@°e™@±l@°ôx@±Ü@±6 @±jd@±¶@±Ð^@²&@¡Õ.@‡íð@[7´@%GÚ?ßj‰?h¥=†Þ_¿DZÔ¿É4DÀ NÀG# Àv@WÀ‘ÖÐÀ©P÷ÀÂßgÀÝ)²Àö=öÁ1¯Á‹Á ‡)Á.Á;åäÁJÿÁXŠŒÁg1wÁiìÁÁ[#ïÁL‰ùÁ>)¨Á0Á"SÁ‚ÁÈ1ÀôêÈÀÛq2ÀªÀ©¨&À’ú ÀxÔžÀJªÖÀp¾¿ÕSµ¿Yݼ¼ã­^?S¹?Õ>@#ÅÅ@\/Û@Š,2@¦_-@® h@®8v@®€a@®â,@¯OF@¯¼`@°){@°‹Å@°Èu@°ü9@±/ý@±cÁ@±—I@±Éñ@±ü˜@²:Õ@—šs@w7K@>Öz@z‹?ž÷A>È9@¾æÖ¿¤¿À¨cÀ4wRÀcz×Àˆz‡ÀŸÔñÀ¸ÔðÀÑLÀéÉvÁ0Á YÁ~Á)a²Á7[ÁFÉÁTÒCÁc°Áf~wÁWyjÁH›/Á9íÁ+{}ÁW Á–“ÁY¸Àë ÆÀÑiôÀ¸DÎÀŸîÈÀˆÐyÀdT2À6iÀJ]¿ªòe¿ $Ý>Ô?‘Ÿe@Je@9 @r9@•^`@­²?@­õï@®=Ù@®…Ä@®ìD@¯Y^@¯Æx@° r@¯Û@°ƒ-@°õ—@±)[@±]@±Ü@±Ã„@±ö+@²T@¢J@…¡@P e@û?½òÞ? (à¾^¾¿ƒê¿ê™JÀ&RÀSxPÀm³À–ý£À¯N ÀÇáÀàvcÀùwBÁ ènÁ›“Á%³ÂÁ4DÁB¼zÁQ’®Á`‘ÊÁd"áÁTóFÁEä†Á6þ»Á(LÈÁ݈Á Å¥ÀüDÚÀâ;4ÀÈáÐÀ¯Æ¬À˜õÀ€—ÀSq¯À&[~¿í8¿Œ¡"¾—Òÿ? ‘?±û°@’_@I{@rß@÷@@­—¯@­ûR@®C<@®‹'@®ö\@¯cv@¯’ƒ@¯Z:@¯+I@¯Ò©@°{%@±"¹@±V}@±ŠA@±½@±é³@±ÑÃ@§¦@Š,Â@[˜@"‚?ÓS,?N²6½(-`¿Yf‰¿ÓmÉÀ«åÀFeæÀr\AÀªÀ¨PÝÀÀ^ÀØ'JÀñ¸vÁU´ÁOáÁ"©˜Á1K¨Á@%‹ÁO+>Á^SáÁb$„ÁS ÁD6<Á5mÁ&™“ÁÁ ¸gÀ÷±§ÀÜ×ËÀÃ,iÀª;kÀ‘×EÀtMÀFÓÎÀäпÔ{L¿c›X½Íîà?âÁLßÃÁ[ÌrÁ_ýûÁPËÛÁAºäÁ2ÓzÁ$ ìÁ²ÎÁžûÀóéÓÀØþÀ¾ˆÀ¥@£À9úÀk3ÌÀ=‰ëÀs#¿Á³ê¿AŒ4=?^I?^ýr?Ù>ä@#ð•@]P@‹@ø@¨P(@¬Ûª@­Ž³@®A½@®r@®¤¤@®l[@®7Í@®!%@®@®­W@¯QÙ@¯ö\@°šÞ@±?`@±o¤@±_j@±L @¦Q=@Šq/@]lÿ@%óŽ?à4M?oñ’>Wy¿*Ÿ_¿¶óÀ jWÀ4ïµÀ_¹ÞÀ†U…Àž–À¶¿ÀÑÀë›ZÁó÷Á©&ÁÌCÁ-BhÁ;økÁJàhÁYðÁ^øÊÁO³Á@Œ«Á1‹ãÁ"»ÂÁ*àÁíáÀðE9ÀÕèðÀ¼6¸À¢†ˆÀ‰òÀe¦˜À8HÀ Øú¿¶6ª¿,¡=ðER?q¾m?â ø@(³Â@a@@[6@ªñ@¬y™@­&u@­ÓQ@®aÿ@®jq@®V5@®Aø@®-»@®@®£K@¯GÍ@¯ìP@°Ò@°ÃS@°ÛJ@°Ùœ@°Éc@¡ý@…ÇI@UIr@ þÍ?Øò?`èß=¸ßä¿.ê‚¿´`À8À3BÿÀ\ÁÀ‚öÀÀšr À´chÀί Àèý\ÁÊÿÁœ‰Á×·Á,baÁ;*ÁJ!7ÁY>/Á_éÁOÖ Á@±ÝÁ1´9Á"çÂÁ[2Á#UÀð©ÌÀÕµçÀ»” À¡ÄÝÀ‰kÏÀcÙøÀ5ÐÀ$Þ¿¯2}¿CÑ>$7?sûÌ?åx@'Æ–@_‡ì@‹êô@§¶k@«äÁ@¬‘@­>y@­Ä@®y@®Xñ@®N@®:R@®&@®™?@¯=Á@¯Ë$@¯úî@°*·@°?é@°HG@°C•@˜à@}%Ä@Hö,@Áø?Æ Æ?AvÛ;‘sº¿>þg¿ºD)À -À5¶À^úÒÀ„T’À›yOÀµQåÀÐ)Àêl5ÁwÁ8ŒÁe¿Á,ä~Á;¡åÁJFÁY¥ŽÁ_ @ÁP_œÁA=íÁ2CÁ#yÃÁð¶Á¼¾ÀñéëÀÖÍkÀ¼MÀ¢LÍÀŠOùÀex€À7ÙÀ *¿´ÄÊ¿)Ë·=è-'?fñ?×ÞÉ@!H @Uc¥@„ø+@Ÿ¹@«Oé@«üÅ@¬©¡@­&@­pz@­ºò@®j@®Fè@®2¬@®3@¯¾@¯2ˆ@¯bR@¯’@¯¤‡@¯¬å@¤[?@ŒL@gwÐ@7b2@Y¤?©û¼?Æa¾ª¾¿am»¿ÇuÀ uÀ9.Àd'ÐÀ†‹ÚÀ)¶À¶›ŽÀÑ%ÀëÍ+Á<ßÁé#Á²Á-thÁ<$åÁKÁZ¨Á_è˜ÁP­=ÁA‘ Á2ÍÁ#Ü«Á]?Á4®Àó±ÀØÚÀ¿^ÙÀ¦JÀ;JÀjà À= Àa"¿ÂÀœ¿L7ª¼ù½ ?=dÜ?¾Æf@:Õ@Aï2@s%]@’%–@ªF¨@«gí@¬É@¬ˆ@¬Ò{@­ó@­gk@­±ã@­ü[@®:X@®j"@®™ì@®É¶@®ù@¯ &@«Uû@”©8@{Ý@MãE@lª?âT>?„9>¤p¾¼˜ü¿‡K¿ÜkÇÀÿðÀAnxÀj\À‰—žÀ 3ÕÀ¹DÀÓÎÀî 8Á7PÁËCÁÒ Á.0&Á<ÑqÁK§‚ÁZ§œÁaTmÁR3qÁC6 Á4eÁ%ÌyÁ|ˆÁ ‹©Àø•ÀÝþÞÀÄðÀªºÌÀ’wèÀv"_ÀH¦ŸÀsd¿Ûž¦¿€µž¾–­>åU?•]i?ôñŸ@(å@XÄ@ƒ¥@˜|E@ªâ@«ñ@«ê@¬4|@¬~ô@¬ÓÓ@­0¦@­x@­´Z@­Ó¥@®P@®1@®`ä@¬Ú;@˜=Æ@ƒ Ñ@[„ƒ@/››@¾?®¸«?*Bb»¡6Ó¿+÷¿©Vy¿úZSÀ$¥ÀL[¨ÀsÙÀìÿÀ¤!©À½$¦À×Z[ÀñîÇÁPÁaÁ" GÁ0QzÁ>ÌÁM}øÁ\^ ÁcÞLÁTë‚ÁF ³Á7zÁ(þ¸Áº°Á ¾îÀþd‹Àä‹ÀË€$À±IGÀ˜•QÀ‚4ÀX¼À+šyÀ4¿¨¿ ^Î=œ<?B£?½“;@ Ñ¡@6XQ@`Ï@ƒÑL@•9@¥Y’@«Oš@«¬l@¬ >@¬f@¬Âã@­’@­2Þ@­R)@­qu@­˜~@©š2@—yZ@„޼@a7@7Çâ@Óf?È(?eg°>}Eä¾ÏúÈ¿„’}¿Ò/À»×À5\üÀ[„ûÀz¸À•—éÀ«·0ÀÄ#ÜÀÜÚ…Àö+yÁ>ïÁõ±Á$Á2ˆ[ÁA8ÀÁPtÁ_+ÁgBõÁXY=ÁI‹wÁ:ífÁ,Ž-Á~æÁÖÛÁ :Àí\RÀÓÓFÀ» ÄÀ£?MÀŒÊšÀmuíÀAœÀÇ¿Øz ¿‚H¾·}Û>žãõ?xë?ÎÕ÷@Ó@6C³@YÈ@z<ª@ŒX@™·Å@¥8ˆ@«›|@«øO@¬U!@¬’@¬±b@¬Ð­@©¼ó@Ÿn@‘ßN@<Î@^ÆP@9‚@aö?ÓàV?‚°>Ðo«¾vB¿[' ¿¹UQÀ:À&IÀJvÀn‹,À‰Ê.ÀžƒÖÀ´æÀËÈ¡ÀäI0Àý}ÇÁ µIÁ¼Á&ù_Á50NÁC­ÞÁRcvÁaFÁjïBÁ\5bÁM¬AÁ?^úÁ1\Á#©ÂÁüÁ·šÀ÷¼/Àߥ#ÀÆdŒÀ®¢dÀ˜…Àƒ. À[”‰À2î¹À ®¿Á•î¿\B ¾còq>Ê´ˆ?¶á?ËÊB@ ,\@*4@HÖÅ@e<Ô@~xU@‰æ®@’‚è@˜}Ë@›Ââ@››!@™Ø@”}s@Ž)]@„ÌJ@p˜t@SæŸ@3]@c?×¾?Šß>î3€¾â:¿8ŽË¿«‡¨¿ójÀ¹}À?Á¨Àb[¢À‚ÚWÀ•TÀ¨·…À½G/ÀÔ› Àìò\ÁèÁ:ÕÁ°˜Á+OÝÁ91¤ÁGd¾ÁUØøÁd÷ÁoŽtÁa"ÁRïÖÁDýLÁ7!¹Á)Z$ÁèÊÁþzÁÃ?Àë"±ÀÒÎÀ»>„À¦y-À‘HCÀyo9ÀPuæÀ(ûâÀοµWŽ¿OÃN¾h3ë>² €?cF ?´ÏÎ?ó^@Œ@1‚@I4)@]#þ@l¼Ç@x(@}t @}EN@xpc@oË^@c¤Ë@S±@>Ð@$ ü@žQ?Éàú?„Ù—>ñÂ%½´/¿.íÝ¿£jú¿ëÄÀ(3À:ÍÀ[ÌÀ|þÉÀÇÀ¡«RÀµ¡ ÀÊ ŽÀàèÀøDÀÁ¦MÁfÒÁ"·{Á0sÿÁ>U×ÁLKþÁZm:ÁhÌsÁu#+Ág 7ÁYŽÁK jÁ=KLÁ/ë†Á# Á4¸ÁñPÀø¦yÀá$JÀË@êÀµ´eÀ¡$ºÀW½Às`hÀLôÀ& *ÀÜ?¿·û¡¿bÊ£¾®E>2Û?+:?‘7O?ÇöN?úÌE@†ä@&@@4í!@?LÃ@D,U@C°Ë@>éþ@6Ù]@+Å”@*×@ Ù?åî?¬«x?a¶>Àüï¾¶ü¿1½¿u¨¿é©¥À)€À8ÃïÀYÎ`ÀyX”Àž ÀžµáÀ±†ÐÀÅ»ÀÚ°ÀïF£Á äÁRCÁýwÁ(Ï4Á6wÁCÑ3ÁQÔ³Á_ðvÁn×Á{rRÁmZÌÁ_kµÁQÈ#ÁDÓÁ7¦3Á*`÷Á0cÁ‘[Á­mÀòédÀܦTÀÇ£À²ÊSÀŸÀ‹‹ÍÀq:ÝÀL–ÑÀ(âÆÀ5¿È¿‡¤n¿3ܽ¿V­>·œH?CŒh?‘(ˆ?º'?ÝT?ùB½@>ª@ Ù@ èÑ@>N?ûÒ,?ço«?ËÚ)?¨I7?|¼ö?^>-k‰¾šd¿P³¿¨Em¿ì%áÀ)À:ÀZÌÁÀ{pÀCÖÀèŒÀ°eÀÂhÀÖ¼kÀëÀÓÁ„Á o_Á ^Á#cØÁ0•Á<ïPÁJ-ÂÁWËçÁe¸ºÁsã¹Á€ÿYÁt0¾Áf«tÁY|cÁL—(Á?ÄÁ1ùíÁ%a!ÁjjÁ ®2ÁN7ÀîJÁÀÙ`^ÀÅ+&À±‚¤Àž§“ÀŒƒ¥Àu*ÀRù}À1ªÀÀ¼¿ä1•¿§u®¿ZrÙ¾ß㓽G$¶>–ø0?¸¼?]·?ˆ¦I?™ÔR?¢Dü? h?—S ?Š0?ns\?<ç>ù´R>@ìØ¾.Xp¿Â¥¿€û°¿¾#I¿û€ÑÀèBÀ>´›À^ÒÀ}ñ’ÀŽoÀ¿ À®$ÀÀ”¼ÀÓÿeÀæx@Àûv€Á KVÁ\ôÁÌ_Á+²Á8 ŸÁDÆZÁQ’@Á^¼ÎÁl@ýÁzCÁ„¡ÐÁ{ÛÁÁn½èÁaSðÁSæÃÁFÚ­Á:DÁ.Á!þ ÁmõÁ  Á&Àì€KÀØ„©ÀÅÝÀ²Ý¾À øÀ¡ÿÀ~PÛÀ^yIÀ>ü¼À!GmÀó¿ÑŽÐ¿ž¿^üÀ¿ 8u¾|A‘;Si°>C…é>žJš>»]Ï>³bË>Êï>A˜=5³&¾ )é¾µH‰¿!:n¿uõ‘¿¨4¶¿Ý’„À LÞÀ'‹áÀF&ÀdZ;À‚LoÀ‘лÀ $GÀ°ÀÁãÀÒ¯ÀæXÀùrÁH»Á*ÔÁíóÁ(ÂóÁ4xÁ@¥ÖÁM!ÁYÓUÁf”åÁs©ÉÁ€‰ŸÁˆ£(ÁælÁv+WÁh×Á[ÝòÁOQ=ÁCÁ6ÙLÁ+-Á€>ÁSvÁ qÁZ²ÀìÀÙÕsÀÈ5…Àµæ“À¥|5À•š1À†ÑÀmñÀPþûÀ5©¶À>aÀ€¿Ø«K¿± ü¿²»¿` {¿1Î0¿Ô¿ f¿ I™¿«ß¿4ßè¿V9*¿|›â¿˜®Í¿¹ý+¿ß9ÀgÆÀ-àÀ7KíÀS’ÀoñºÀ†ãÀ•ÎtÀ¥+À³ÇÖÀÄLÀÕÇñÀç^ÖÀùàæÁ ÁyÁM‡Á%j®Á1GŒÁ=ªVÁInNÁU¾wÁbbÙÁo)TÁ{ßMÁ„o7ÁŒg‡Á…¥LÁ~Áq+tÁd¦ÿÁXB2ÁL=Á@8BÁ4n6Á)ÜÁ ãÁ–Á gÇÁÙæÀðr­ÀÞ2iÀ̈%À»ó½À¬6ãÀ ´ÀŽØÄÀ ÀgcŸÀN©À7lÎÀ!ØÀÆ`¿û¹q¿à±d¿ËÅÙ¿¾z)¿¹DŸ¿ºh)¿ÁwŽ¿ÌÕ¤¿Ûkâ¿ìÀ¤wÀõ‚À#¥>À7ÿÀM~üÀfÀ´ ÀïÙÀœ¿HÀ«7ÊÀ¹å¸ÀÉQºÀÙšÐÀë‡CÀý®:ÁÇYÁ|pÁøvÁ$}ŸÁ.õhÁ:6éÁFÅÁR“™Á^·“ÁkÒÁw·ŒÁ‚UÁˆ°ZÁR$Á‰Á"ÁƒXÙÁz0aÁm½ÅÁa”õÁUœ×ÁIºÁ>W3Á3¨ÇÁ)ÐÑÁ_½Ár¢Á ]}Á~CÀõeTÀähÀÓÀÃú”Àµ¨À§),À™ÃÀ(À$ÀlIîÀWÝÖÀEJ À52¤À(«îÀN«À”qÀYáÀŽÀfÀŒ„À%&ØÀ,6WÀ6øÀGâÀWñFÀk1µÀ~¿À‹ åÀ—gÀ¤7À²ðTÀÁbÀÏéòÀßÁÑÀðG¹ÁêÀÁ 8 ÁidÁ‰ÏÁ&’´Á/Œ:Á9dtÁD ×ÁOeNÁ[RˆÁg½Át>›Á€@&Á†“UÁjÁ”±ÁŽ1åÁ‡ðÁµ[ÁwCœÁk7šÁ_HêÁSÙ[ÁI ‚Á>ô€Á4¾?Á*RÁ!—Áì«Á6ÌÁÀûÔÍÀë±êÀÜ™aÀÍrvÀÀ0À³ hÀ¦«òÀ›sÜÀg,À†ýÀ|¥ÀmzrÀ`Î÷ÀXˆÀQýMÀP‘¿ÀPôÑÀT¹ÀXïÃÀ^wÀd ÀÀlâûÀ|«fÀ†R<À)‡À˜èèÀ£qÇÀ¯˜NÀ¼VSÀÉç˜ÀØ%µÀçRëÀ÷;üÁÄ­Á ŒBÁ”µÁÍóÁ(J8Á1¾4Á;QöÁD“|ÁN¨lÁYsbÁdÚÁpÇëÁ}(YÁ„õëÁ‹gÁ‘a—Á™%Á’Ø>ÁŒŸÁ†ŠàÁ€}pÁu /Ái‘¬Á^©~ÁTf»ÁJbÒÁ@tÁ6>{Á,º­Á#Ã^Á>ÍÁ´½Á šÁ)ýÀôÛœÀæë¨ÀÙ!ŠÀ̤ÅÀÀô Àµ­fÀ«ŽñÀ¢.]À™øöÀ’ÎÀŒÉJÀˆ£ÏÀ†À…êÀ…šðÀ‡·À‰FZÀŒ pÀŽàÀ’âÀ™½¸À £ÔÀ©`jÀ²Ë“À½1òÀÈOPÀÕ Àâ`ÇÀïÿÆÀÿ%hÁ³Á÷ÁZÒÁ!„)Á*V Á3…èÁ=JÉÁG%ÂÁPc˜ÁYìÎÁd/ÁoÊÁz„Áƒ7ÌÁ‰bjÁ»SÁ•þ°ÁÌÁ——½Á‘³Á‹n˜Á…wbÁrTÁtwóÁjîÁ`9/ÁU·eÁK¹ÆÁAñJÁ8ŸoÁ00Á'™ÁÌèÁH1ÁI²ÁÖÁhLÀò÷½ÀçX9ÀÛ‡˜ÀÐCÀÇ¢À½åiÀµ™äÀ¯DùÀ©jfÀ¥f3À£i¤À¢ýÀ¢ØÀ¤"¹À¦À¨APÀ«!À¯þ¯Àµ…µÀ¼&OÀÄ€tÀÍ,4ÀשÀázòÀíÀIÀúî·ÁcPÁ º½Áé‰ÁdÕÁ$½ìÁ-ljÁ6zdÁ?/VÁH£MÁR†9Á\«eÁeÁ(Áo‚@ÁyèUÁ‚oÖÁˆ+^ÁŽÁ”DÁš”•Á¢œwÁœƒbÁ–lýÁx–ÁЏäÁ…4¼ÁçŸÁuý|Ák—Áan|ÁWqœÁMÚÁEÚÁ<œEÁ3êêÁ*ö»Á"­ŸÁ«]ÁϸÁ |BÁöjÁžÀö0ÕÀëlXÀ➤ÀÙªçÀÑÆYÀËôÀÆÆ ÀÂë3ÀÀº@À¿Ã€ÀÀ,MÀÁOÐÀÂ7QÀÄD¥ÀÇF)ÀÌ·ÀÑyäÀØ£)Àà¯èÀè8‘Àñê ÀûáJÁ‘!Á þÁáCÁ\ìÁ 9Á(É´Á1k‚Á9Ò¿ÁB—ÁKh€ÁTX€Á^ FÁgÿ²Ár`Á{WJÁ‚¢vÁ‡ã€Áf~Á“$Á™„ÁŸ5$Á§ËÁ¡v´Á›…%Á•Ä Á;ÁŠîåÁ…çŒÁ€Ì ÁwM€Ám'šÁcZ¯ÁZHVÁQÏ£ÁI4pÁ@Á7‡HÁ/-Á'¢Á!MøÁð‹ÁŠÁ‡ÙÁ͸Á¾¼Àþ™ëÀõåýÀî¿ÓÀé#EÀä9CÀàÀÀݯÂÀݦÀ݇ ÀÞ¸ ÀÞÇÀà¸WÀ㓉Àèg{Àí¨hÀõM¥ÀýìÁä—ÁS±Á |jÁØgÁ&ÑÁ¤ˆÁ%hÁ,ÛêÁ5:_Á>öÁF¤±ÁOÁWÆ<Á`• ÁiÈÁs¤¬Á}ªgÁƒÎ‰ÁˆŒJÁ•2Á’á‡Á˜jAÁž) Á¤2ÂÚ”ÁûqÁõ7RÁïÓÁèÚnÁâºÏÁܤpÁÖ«DÁÐÀÿÁÊÜmÁÄûÇÁ¿5Á¹˜vÁ´ÌÁ®˜ÄÁ©OfÁ¤ÁŸÙÁš3jÁ•¨ßÁ‘^òÁ­Á‰Á…_dÁ‚­Á~BßÁx§ÁsÍ×ÁoìÁlöÇÁjPÆÁh˜Ág”°ÁgZÁgKÂÁh6Áj+ïÁl— ÁoçØÁs­aÁx\‡Á}ä“Á×ÒÁ…‹ÁˆÁOÁŒÄVÁ‘¦Á•—ßÁš5‹ÁŸ ¹Á¤ðÁ©,CÁ®ˆ”Á³ôšÁ¹{ÕÁ¿/-ÁÄñ°ÁÊÇÁÐÁÁÖË¡ÁÜßýÁã˜ÁéZ•Áï¤ÂÁõåTÁýCØÁöðÁð¨®ÁêtªÁäE¬ÁÞ¶Á×õ%ÁÑÛtÁËâÝÁÆïÁÀwÁº6IÁ´rÁ®ÚÁ©V6Á£ç:Áž©qÁ™{Á”|ÆÁÄÁ‹WÁ‡ õÁ‚ãÁ~Áw3ÙÁq°ÁkuæÁfVëÁb:›Á_.Á\u)ÁZ£ÁYL¼ÁY•ÁYRÃÁZ„sÁ\?æÁ^ÑÁb7ÁeðÎÁjæÁp…“Áv„×Á}aÁ‚…HÁ†·ßÁ‹-ŽÁ½”Á”JÁ™_¸ÁžyQÁ£ÎTÁ©C!Á®ÆFÁ´tìÁº2ÁÀ¢ÁÆÁÌ‘ÁÒ(&ÁØ\“ÁÞªAÁäõ¥Áë2¸Áñw5Áøë‘ÁòÁì8ÁåìåÁߺÁÙŒçÁÓcDÁͱÁÁ@ýãÁC³}ÁGÿÁKvWÁPßÁV`Á]N³Ádì°Ám+ËÁuÖ8Á,ÕÁ„kêÁ‰_(ÁŽ˜cÁ”óÁ™FÁŸ>LÁ¤ìçÁªº[Á°³ÅÁ¶ÎÁ¼í×ÁÃ"pÁÉdCÁϪBÁÕóXÁÜB{Áâ¦cÁéŠÁð«3Áê16Áã¼vÁÝX›ÁÖöžÁФlÁÊi0ÁÄ0÷Á¾ ÄÁ·õÁ±åzÁ«ë/Á¥ûoÁ ¼ÁšU¡Á”§TÁ'vÁ‰¹UÁ„iÓÁ~LÁtÀÁk-TÁb=ŸÁYµ¶ÁQº<ÁJ²ÁDªóÁ>þ#Á:HÁ6ªsÁ3€·Á1š¡Á0<ÒÁ/öJÁ0*3Á1CúÁ3…Á6NOÁ:.Á>ØÁDFcÁJOçÁQeÕÁY- ÁavŒÁj…—Át55Á~ Á„*ŽÁ‰”²ÁþÁ”¿ÁšnXÁ 7ÒÁ¦/^Á¬IzÁ²k¶Á¸˜xÁ¾Î‘ÁÅÁËmÁÑìÁØ AÁÞ‹5ÁåÜÁì´ Áæ.ˆÁß¶—ÁÙ?ÿÁÒ×ùÁÌr3ÁÆÍÁ¿ÜµÁ¹žÑÁ³wÁ­l2Á§d×Á¡i–Á›qQÁ•¬ÁßÁŠF˜Á„Ê=Á~¶–ÁtÈÁj÷Á`DòÁVä>ÁNNiÁF+ÚÁ>¶ÃÁ8XÆÁ2•ÍÁ-‰”Á)Í{Á&”ÒÁ$•Á#dŠÁ#ƒÁ#Á$I Á&D-Á)0uÁ-{ÓÁ2^ÒÁ8ÈÁ>ŽIÁE¿+ÁM´ÁVD\Á_LjÁi«¤ÁsÊLÁ~k&Á„¦õÁŠB|Á¾Á•ÓEÁ›ÂýÁ¡Ë¿Á§ëÁ®Á´L‘Áºž^ÁÀû“ÁÇOóÁÍ¡ìÁÔ ÁÚFÁáXÁèñ7ÁâO®ÁÛÁ¦ÁÕF›ÁÎÌwÁÈ\úÁÁüëÁ»¬‹ÁµghÁ¯$oÁ¨üdÁ¢ïªÁœæmÁ–ïcÁ‘ Á‹&ãÁ…ÙÁÜtÁtÝwÁj mÁ_†²ÁU®¦ÁL'vÁC[Á:ûÄÁ3\0Á,“Á&¿`Á!_ÕÁgÁ<üÁ€ÁÚ,ÁFÁœTÁ²©ÁlÿÁ–¯Á!AÁ&jÁ,#‚Á3 šÁ:HoÁB‰2ÁK¶œÁU›ÁÁ_¥"Áiö‡Át—íÁ·gÁ…§dÁ‹Š.Á‘i´Á—]¼ÁxñÁ£­Á©åÁ°:ÛÁ¶¢¦Á¼æ¿ÁÃ7VÁɦÁÐ-ÁÖ­ÞÁÝ*îÁåBTÁÞœqÁ×÷\ÁÑ\bÁÊ×ÌÁÄ^Á½é¾Á·‘}Á±NFÁ« _Á¤ÆZÁžžƒÁ˜Š>Á’zÚÁŒŽwÁ†±xÁ€ãüÁvƒ+ÁkKÁ`i2ÁU»YÁKlöÁAÜËÁ8ž3Á0ÓÁ({–Á!t½Á]·Áì¿Á¤lÁ‡Á ZÁ ‡.Á ÒÔÁ œÁ ”Á ;]Á©^Á%‚ÁJTÁ ÖƒÁ'×ÁÁ/XÁ8=ÜÁAÆÜÁK²—ÁUÞ¿Á`@hÁk?ˆÁvɲÁEŠÁ‡$Á,Á“'’Á™`ÿÁŸCÁ¥ôÓÁ¬WÈÁ²•“Á¸çÂÁ¿ZÁÅãsÁÌQÁÒÌÔÁÙbÁážÞÁÚô²ÁÔLÌÁͧ@ÁÇäÁÀ|ÇÁºkÁ³ÀÁ­6‘Á¦ô¯Á ´@Áš Á”b8ÁŽFÁˆ3ËÁ‚QÏÁysÁm¤ÁbY§ÁW ÁLj1ÁAï¾Á7éÁÁ.·EÁ%Þ“Áã¥Á¬ÿÁSÁ ÓšÁFÇÁófÁ?§Àý®pÀüS‹Àý™vÀÿè/ÁÝñÁ‰©Á ÚÁd`Á/)ÁkØÁ%’«Á.„UÁ7û2ÁB%ÁLd ÁW6tÁbŸ¦Án8ÖÁyüüÁ‚é Áˆþ{Á;CÁ•{«Á›ÌÂÁ¢¹Á¨cõÁ®·÷Áµ'Á» !Á ;ÁȈéÁÏ"ÁÕÓjÁÞ °Á×qƒÁÐÁÔÁÊdÁÃo§Á¼ËáÁ¶>ÈÁ¯É¤Á©WhÁ¢û¼Áœ¶ìÁ–sëÁPÁŠ@Á„$lÁ|4^Áp…ÀÁe#%ÁYÆïÁN†ÞÁC~‹Á9{Á.ÔdÁ%2sÁ}cÁ'Á ‘Áw¶Àÿß½Àö½jÀï¤ÍÀê“>Àè 8ÀçlÀ燴Àê†ÖÀî÷èÀö@8ÀÿÁÁ Ë+ÁÌÛÁ.Á%TÁ.å¡Á9)…ÁC¾6ÁNôÁZXHÁfIÁqòÁ~ªÁ…D‘Á‹w¥Á‘³1Á˜+ÁžUÎÁ¤¨—Á«ŸÁ±r‘Á·âÁ¾ckÁÅíÁË¥çÁÒ5ÁÚºqÁÔ ÁÍ`ÁÆ­ØÁ¿ü°Á¹W±Á²³mÁ¬#&Á¥°"ÁŸC¯Á˜èÁ’¡9ÁŒ] Á†;îÁ€(\Át=óÁhjnÁ\ÛQÁQebÁFdÁ;2ÏÁ0”/Á&t_Á¦†Á‡ Á áöÁ¸ÀøÀì%§Àã'ÀÛ“’À×ôÀÔÚÀÒò^ÀÓàrÀÖ̹ÀÚÉÖÀâžÀëÀö&jÁ_ÇÁ §ÚÁÓÁuöÁ&«$Á1›Á;îÜÁG6ÁR°œÁ^•Áj‘Ávæ²Á‹)Á‡½œÁŽ SÁ”a—Áš¯ Á ýöÁ§i±Á­Þ{Á´`Áº÷ÛÁÁ’×ÁÈ*šÁÎÄÆÁ×øÁдœÁÉø[ÁÃSKÁ¼²ÇÁ¶eÁ¯dÏÁ¨ÂgÁ¢0OÁ›¿Á•[ÏÁžÁˆ¼sÁ‚yÁx¶üÁlŠ Á`ŠÁUªÁI¬Á>,ZÁ3›Á(ž^ÁyKÁÚÁ þŸÁPKÀôUÀæÅÀÛPóÀÑ|îÀÊ%ÀÄ…¼ÀÁ| ÀÀ+×ÀÁFZÀÃÁQÀÈ›%ÀÐ@…ÀÙ lÀå ÆÀôhäÁ{èÁ ÛÁèYÁ!+Á)¶±Á4ŠøÁ?÷9ÁK–IÁWE ÁcmùÁo«‹Á|6Á„>LÁŠ‚,ÁÐ|Á— ´ÁŒ„Á¤Áªr Á°ûâÁ·ž•Á¾)yÁļÐÁËjJÁÔp†ÁÍ—¦ÁÆÂTÁÀ"Á¹Y<Á²¼ÑÁ¬ nÁ¥„;Ážé†Á˜f?Á‘õdÁ‹“wÁ…IþÁ~ ›Áq¥ÆÁeyqÁYM2ÁMk*ÁBáÁ6²Á+œ[Á õ‰Á̳Á À9ÁS\ÀôÁúÀåC[À×C£ÀËÖÀÁKÔÀ¹Â\À´ŠÆÀ±·À°ëËÀ±ÉÀ´dÀ¹v•ÀÁ\ÀÊ…ÀÖe÷ÀåRÀõ,sÁòÁ ŽÁͺÁ"³÷Á-ÂzÁ8ÿÿÁD{MÁPŒÇÁ\ÒTÁi ÁuY Á€Ý-Á‡*ÓÁ{Á“ãÉÁš5ÌÁ œ Á§%šÁ­ÍÁ´ClÁºØAÁÁˆuÁÈQIÁÑzÁʘÂÁÃÆqÁ¼ökÁ¶2;Á¯ˆŽÁ¨ìÒÁ¢Q^Á›¶OÁ•!ÁŽª?Áˆ:øÁÚÁw8äÁjËÑÁ^­$ÁRÍ<ÁF¼ñÁ;Á/Á\Á$~•Áë¿Á ÕÁ%ÀøñÏÀç·ÃÀ×ðÿÀÊŠÌÀ½{À³ö‘À¬þhÀ§ÄïÀ¤­­À£©À¤¿À§pKÀ««ØÀ³ÎÀ½¸,ÀÉkÀ×ë;ÀçÔzÀú’®Á§Á}ÀÁ*íÁ'OKÁ2•\Á>rJÁJpºÁVPØÁb ‹ÁnûxÁ{u)Á„ ]ÁŠa(Á˜,Á–ú=ÁìÁ¤¿ÁªŠsÁ±DÁ·ÐæÁ¾›ÁÅF‘ÁΰAÁÇÊFÁÀèäÁºÁ³SõÁ¬’‡Á¥èªÁŸO­Á˜·YÁ’ Á‹°Á…”Á}n¢Áp½¸Ádc“ÁX"YÁL(öÁ@]IÁ4¼èÁ)¢.ÁtÁ…kÁ ÀÿºÀíPÀܬØÀÍ[À¾¢À²Ý¡À©¡‰À¢Ì¾ÀwÇÀš6ÃÀš}Àš8’ÀG À¢À¨kmÀ³)oÀ¿ºÀͪÀÞ@Àð}–ÁòÁ #ÁÒ)Á!ÇfÁ-1²Á8…ØÁD,žÁPgMÁ\šoÁhËÂÁulïÁ [Á‡=½Á’Á”ÁšƒHÁ¡˜Á§—FÁ®>ŽÁ´ñhÁ» ½ÁÂ\þÁÌÁÅðÁ¾=ÕÁ·gfÁ°™¶Á©ß?Á£*Áœ‚ªÁ•ï+Á]ÁˆÍÁ‚AÂÁw´¼Ák ªÁ^vþÁRJÁFJÖÁ:„.Á.ÝvÁ#Œ˜Á¸›ÁèÁ¤Àõa—Àâ¡£ÀÒ0ÀÃ=CÀµðÀ«(JÀ¢‰ðÀ›ïÀ–çáÀ”&8À’Ñ+À“Ë_À–GºÀ›d¾À¢,WÀªÌiÀ¶þ,ÀÄÛ:ÀÕƒªÀç5[ÀúúÁ\¿Á¾­ÁeÁ'´¼Á3žÁ? ÍÁJÓˆÁVÕ¶Ác6ÁoÅuÁ|2­Á„IÁŠ¥µÁ‘*Á—²Áž*ñÁ¤Á‚Á«sâÁ²+aÁ¸èèÁ¿½›ÁÉœ¦Áœ Á»° Á´Ú1Á® Á§RÁ Ÿ”Á™ö)Á“Q«ÁŒÁtÁ†BíÁvãÁrÁeë¸ÁYp@ÁM˜ÁAéÁ5\Á)·AÁv±ÁÅÁ *ÊÀþC†ÀëüÜÀÚ+ÀʹjÀ¼®1À° ŒÀ¥Ë^À;/À—‹ÀÀ“ ™ÀÕúÀÉùÀ÷OÀ’ÀÍÀ–“(À­/À¦Á¸À±µäÀ¿½ÀÎ×±ÀߢÀòEÁ)ËÁ ~ªÁ-Á"ãªÁ.gúÁ:4ÁE­nÁQšLÁ]ðÁjYµÁvŽäÁ–èÁˆãÁŽÁ”ë&Á›|ªÁ¢.åÁ¨í6Á¯­'Á¶€ŒÁ½kzÁÇ^„ÁÀc~Á¹kÊÁ²ÆÁ««´Á¤ï<Áž84Á—…XÁÖÁŠ2¿Áƒ±¹Áz{ˆÁm¢šÁaÁT¨ÁHWÁ<íÁ0L)Á$ÐRÁ¥ÒÁ"ªÁÔoÀö€bÀä¤6ÀÓ”ïÀÄÞÌÀ·H„À«ÌÊÀ¢IãÀ›7À•IªÀ’-žÀƨÀåÀ…¼À‘ÆÀ•WæÀšÃ6À£c±À­¿;Àº+nÀÈòÀÚ"rÀëÿÊÀÿ)@Á ~Á¨×Á·€Á*QÈÁ5lrÁ@éÁM¿ÁY[ÆÁe]{ÁqÓÁ~¨JÁ…™œÁ‹ùÁ’pÁ™-sÁŸïÏÁ¦±‰Á­{PÁ´Z{Á»K7ÁÅOtÁ¾L•Á·\¿Á°tDÁ©‘UÁ¢ÁVÁ›ûÁ•7ºÁŽŒÁ‡óþÁdÓÁuåUÁi&…Á\yLÁP²ÁCÚ«Á7×ãÁ,úÁ œâÁ½ëÁ BÁ\ÈÀﻤÀÞ“žÀÎLÜÀÀ…'À³ÑãÀ©¦•À å¸ÀšPõÀ•ð À’³þÀ‘JÀhzÀ¢´À’9<À•B(Àš×îÀ¡åfÀ«ßÍÀ·}­ÀÅ# ÀÕ¶0Àæå»ÀùqÁÁ~QÁœuÁ^Á&hçÁ1‚Á=xÁIÁU?Áa0RÁm¡nÁz*sÁƒdÁ‰Þ7Á~ñÁ—>¸ÁÙXÁ¤ªÁ«d7Á²PÁÁ¹I~ÁÈÁ¼zãÁµzöÁ®÷Á§²Á Õ!Áš¿Á“?zÁŒˆÁ…è(Á~×3Áqý”ÁeLûÁXË4ÁLa Á@JjÁ4RMÁ(ÂÕÁ…Á¾¥Á²íÀþßÀëN ÀÚÅnÀË;À½úZÀ²86À¨ŒÀ¡éÀ› lÀ—H@À”¼MÀ“B¼À’‡@À’¬hÀ“ßvÀ–ϵÀ›møÀ¢€ËÀ« MÀ¶hÑÀÃ`ÒÀÒ†Àâž2Àô°+Á+Á ï„ÁJ(Á#) Á.÷Á9¬±ÁE›™ÁQ7@Á]^ßÁiëƒÁv}+Áš¸Áˆ³ÁŽ®›Á•|ÀžæžÀ›WÀ—þxÀ•‡ôÀ”'ÂÀ”{¬À–œpÀšÌÀž3À¤ôÀ¬òoÀ·#ŸÀÂv¸ÀÐM³ÀßeïÀïhdÁÝZÁ A›Á2{ÁŒÁ)AºÁ4aÊÁ?¦­ÁKYÁW”JÁcó#ÁpufÁ}HYÁ…"fÁ‹­4Á’QxÁ™oÁŸóÖÁ¦ØmÁ­½WÁ´¦%Á¸–×Á²†Á¬±8Á§BÁ¡oÁ›ízÁ•‚ÁŽÆ®Áˆ!¥Á1Áv&>Ái†§Á\ö‘ÁP—ÁD“>Á8ä„Á-”èÁ"—xÁûÁtÁxwÀ÷yµÀæÝ?ÀØ ÀËmÀ¿€{Àµ¶MÀ­ëÀ¥ô™Àžü‹À™1¹À“ä6ÀjnÀ5EÀc÷À’ÜFÀ˜ÀžaÀ¥MXÀ®pÀ¸óÀÇ%ÀÐgXÀßZÜÀï ’ÁR}Á €ÁRÁ8üÁ'çxÁ2ÛìÁ=ëÔÁIˆIÁUŸrÁb¡ÁnŽCÁ{ÂÁƒòÁŠz¸Á‘)Á—÷ùÁžÞJÁ¥Æ™Á¬­Á³žJÁ³ÕŸÁ­¤Á§™¯Á¡ºáÁœ Á–”8ÁòˆÁŠ× Á„í)Á~z4ÁsŸBÁgê;Á[^)ÁO‹ÁC%ÑÁ7ÅGÁ,ÇàÁ!òRÁ©ÿÁ ³)Á(Àøq_Àè` ÀÚisÀÍDýÀÁ¢ÞÀ·.ÏÀ¬k›Àž©ˆÀ‘,sÀ†½À{1‹Àm âÀhq/Ài¨íÀsäîÀ§…ÀŒµ@Àš’Àª1±À¸pÀÄqPÀÑßÀßß>ÀðöÁqÁ NPÁµáÁ~CÁ' HÁ1Ç=Á<§>ÁH6ÁTUÁ`¥“ÁmÏÁyu÷Áƒ"ÎÁ‰µZÁlËÁ—C'Á;Á¢ÿÁ¨ñ£Á¯ Á®Û=Á¨áVÁ¢¾Áœ°¶Á–ÑÓÁ‘'Á‹¶ÈÁ†@ÁÑ;ÁsùpÁh¡)Á]ÛôÁRiMÁF¦­Á;Á/ÆiÁ$¬†Á8Á}ÁmøÀú]¢Àé[iÀÙ!@ÀÊ `À¼SÀ®NÀ ¢)À’NÀƒ†ÅÀl-2ÀTgoÀ@~7À2}¾À+f.À,tÓÀ8d‡ÀGüËÀb~´À@À À£¶À¶óÀËeÀàæ_ÀñJ]ÁÓÑÁ ÝVÁ xÁ|Á&æ3Á1¦EÁ<…ÁGü–ÁSûÊÁ`Ál9ÁxÁÛÁ‡QÁŒ¯¶Á’<­Á—ÿˆÁôYÁ¤°ÁªV@ÁªèÁ£ô°ÁøîÁ—ç¦Á‘×|Á‹ù,Á†S>Á€íÁv8mÁj4Á^>÷ÁRò5ÁHÁ;íÁ0&Á$|pÁ)©ÁñÁ´8Àó5óÀà+EÀÎ3EÀ½F À­ÏãÀŸ*‡À‘NÀƒ©ÀlÀO¸À4}³ÀŸÀ퉿ì…3¿Ü!¿ß.Ç¿ù”À8iÀ*¼­ÀJÀ+Àm¿ÀŠ~2ÀžŠ`À³óSÀÉ"wÀÞÇçÀô¸ûÁ åÁ®ZÁê…Á$, Á.S6Á8‡çÁCPÁM²ÇÁXoÁcOÊÁnCÄÁy˜ÁÇÁ‡KŸÁ ºÁ“§Á™*ÁŸ`uÁ¥hsÁ¥nÁŸCàÁ™|Á“ 9Á$ZÁ‡ÎÁ5 Áw+uÁly=Á`õÁT‰qÁH·`Á={ÎÁ1Ê Á%r>Á£/Á âÒÁŒéÀï×ÀÚ`ÁÀÆp«À³•À¢ÜÀ‘œ©À‚„áÀi¨ÀM–“À3ZmÀí¿÷ïN¿Æ7j¿˜{¿h׿BÄB¿L¯Ø¿‚†¿¯`¿èJÀ`À;üÀcÖÍÀ†þGÀœâÀ±£ÀǃÅÀÝWÀò”pÁÒ2Á?æÁȃÁ#³Á-¦oÁ8H7ÁCPÁMÚLÁXÔuÁcÁmàAÁx×8Á‚)ëÁˆ"˜ÁŽKÁ”vàÁšˆóÁ ¨Á í¢Áš£ñÁ”ræÁŽW¿ÁˆZöÁ‚xˆÁxÉÁmÁaéÆÁWÁK 8Á?-EÁ3týÁ'»uÁ_ÁùcÁ Àî’kÀ×àSÀÁî3À­YÀ™¹ÊÀ‡ ÀlPÀLÇÀ/AÀø|¿ò%ù¿½dd¿…Oy¿(¶Ï¾‘¦<‰Šc>J~>u–½—R¾ü™M¿~LŸ¿ÆV’À Ê¡À4xÀ]ù¿À„BÀšD¼À°ÀÅ…1ÀÛ-ÀðYÔÁñqÁ r|Á$ Á"ÇÂÁ-¢ÓÁ8nƒÁCj‰ÁN-(ÁXcÁcCÁn¶÷Ázª{ÁƒwúÁ‰œiÁ¹sÁ•ßïÁœ*Áœ’Á–±ÁÐÁ‰©BÁƒvÁ{\+ÁoµóÁc¬ÁXËÁLóKÁA«»Á5ÅÁ*ÁÝGÁ¯Áë”Àñ¸ÀØí­ÀÁ_5Àª¦ÔÀ”ã€À€D"ÀZÑÀ5ÈžÀ01¿ëõŠ¿³ùž¿|#¿`€¾0ü>q‚'?/È?n×=?‘ïç?‹5Q?Nk>¶ÂV¾6þ ¿FùÑ¿´PÃÀåÀ.µçÀZ gÀ‚ÚÓÀ˜uóÀ®2ÀÄ|ÀÙÄ*Àï[>ÁšºÁ TêÁ`ÇÁ#!<Á.,Á9âÁC'ÇÁMè–ÁYOÁe?aÁqhÁ}©âÁ„ýÚÁ‹-|Á‘}ìÁ—÷Á˜CÁ‘ÕËÁ‹fqÁ…¼Á}Ò<Áqß#Áf-+ÁZŽŸÁN¶ëÁC<ðÁ88‡Á,cjÁ ­€Áe„ÁÇ)Àö{uÀÜðhÀÄ‹À«ÁpÀ”,ÀzÚ©ÀO· À&wÀ˜¿»8k¿v&¿´B½­7>©=«?>@l?‘Sæ?ÁrD?ìê¢@!ø@]Ä?ÖËÆ?˜–^?›¼2勵(¨/¿¨Ú—¿ÿ«À+5FÀVÍhÀWˆÀ—1ŸÀ­P5ÀÃ϶ÀÙ¡ÈÀïòÁ6Á åýÁnÁ#þ4Á.B…Á8ÛÂÁD-DÁP/Á\ƒÁhK…Át¶ÌÁ€–Á†ë÷ÁmÁ”µÁ“çóÁŠ!Á‡4ÆÁ€Æ‡ÁtÒÀÁh~áÁ\£UÁQ ÁEtÁ9çãÁ.|pÁ#Á7¹Á R5ÀüòBÀãs¦ÀÊÀ°#–À—+cÀ}=MÀMñÏÀ gâ¿ëP‚¿™Ð¿Ï.½­ù­>È¡Æ?T=®?Ÿ?ÒTZ@Òõ@Ä6@1R@B«P@<â¤@"©œ?ÿ¤?±9l??Pp=»j¿=¿¡iÍ¿ù]ÕÀ(XAÀT·hÀ€¥ À—SêÀ®(XÀÄÉÀÛSáÀñ•†Á&kÁÍÁ§†Á$:vÁ/jªÁ; ïÁFàÜÁS,zÁ_²…Ál@©ÁxöúÁƒ9Á‰®LÁaÁ¸òÁ‰2•Á‚Ö,ÁyBDÁlŠÁ_ÈÉÁSpÙÁGÿÁ<EÁ0¤NÁ%)ŽÁªÁ Ö6Á!FÀën‡ÀÑH[R?Ck‘?£‰?ÝÍÜ@ XP@#bg@="`@T³¶@k"R@f@vŠ@WS@1ì\@ ô?ÀGÙ?U»8>·¿ A´¿œ «¿õÙÔÀ'¬(ÀU¬TÀáAÀ˜Ý8À°8îÀÇ¡îÀÞ¤ÞÀô£zÁjùÁ(ÀÁ5Á&hÒÁ2ËÁ>bfÁKóÁW©ÆÁdk[Áq„>Á~½ñÁ†ÌÁŒªÂÁ‹ß$Á…(‚Á}0\ÁphÛÁd ÁWÕžÁKUÁ>¿Á2üpÁ' eÁUVÁ¬µÁêÛÀò rÀÚÀÀx?À¦20À‹§³Àb@À.@Í¿õv°¿’¡¾É2S>£bg?z¶È?Ëæï@ M@(#7@D´@^í@wL@‡†y@’çø@œô@–Ô0@…ž@d@:Ja@ìà?È—±?^8B>CMj¿Xj¿œ;<¿øãÀ*îzÀY´×À„Ü\À#îÀ´±«ÀËTñÀâRGÀø£ÞÁ?]ÁFVÁÎeÁ*xÁ6°›ÁCZÆÁPŽÁ]7qÁjVÂÁw.Á‚A,ÁˆÌ˜ÁˆO2Á|¾Áut˜Áh@BÁ[kAÁOQÁC)üÁ6ÙÁ*‹>Áæ@ÁÀÁiÌÀùDËÀá¬ÀÈØGÀ¯MÀ•mcÀt²ÈÀ?ÒÀ Ï2¿ª—y¿¹M>„ª¼?‚~¾?Ý£ì@åI@?%l@`”ñ@}úí@Œ@˜ÎŒ@¤Ï5@°^Ä@ºRþ@±²ó@žºÝ@Š.ï@jjò@>Ì8@ËŽ?ÌÜÁ?fã%>7¹¿ º=¿£›IÀÅIÀ2ÞÀc<‰ÀŠx¢À¢¶À¹úwÀЛlÀçBÀýµ»Á @ÈÁ;yÁ"ƒ;Á/ÛÁ;ÓÜÁHðÏÁVÁc oÁoæ9Á}Á…9QÁ„ÛÓÁ|×Án~ƒÁ`ï©ÁS©@ÁFÉ­Á:f@Á.™hÁ"÷bÁíŠÁ yEÁ%öÀéFFÀÑÿ¡À¹ŠCÀŸÉ‡À…q^ÀU"#À~é¿Ïî¿¿H6x=l@‰?^ ý?Ôö{@œ@I7 @s;@‹¿3@›™@©€Ž@¶%”@Â&@Í£x@ÒYØ@ËW@·<˜@¢t‚@Œ˜@l9R@@§ê@ù’?Êì0?\ÁM=íùD¿"ø¿µS8À ‰ÐÀ>Þ9Àq¬À‘¥ÿÀ©\ÀÀ®À×—ªÀîd«Áß®ÁŠ©ÁÂdÁ'’ÓÁ4ÄÆÁBVÁNàGÁ[§àÁhÐ3ÁvNºÁÍÂÁºªÁu‡ÁÁgÞŽÁZZÁLÛØÁ?ˆÁ2¤Á&JvÁ˜Á!ÚÁžèÀð…yÀÙ¸ÀÂ(ÀªjÀˆxÀløÀ7H¡¿ÿ¯¿‘A“¾‘b?šä?¶á„@uR@DUù@u‡ö@‘ѧ@¦?@·Ï@Ƈv@Ñ]K@ÑäŽ@ÒkÒ@Ò¡p@ÒyL@Ï›@¹Èý@£Y+@pº@n:Z@?¨ü@}%?ÁZq??ú€½(Æ0¿Veû¿ÒøæÀÜÀPìÀ¶À™·ªÀ±EÀÈN¬Àß#ûÀö›ÁŒÁÚ³Á!ãÁ.;žÁ; rÁGìŽÁU;Áb(ïÁo(nÁ|€>Á~ ÜÁoÏýÁaÎoÁT&ÁF¦ŠÁ9L9Á,$Á)\Áê¶Á^<À÷ëîÀárÀË‚ À³é¦À›ªŸÀÏüÀP‚&À.m¿ÅÏq¿-æ6>E†C?‡¡?÷TB@3 Ü@hêå@ަi@§Àã@¾ñk@Ï Ï@Ð(@ЯV@ÑJõ@ÑêÈ@ÒÜ@Ññ˜@ÑÏT@З¸@º‘î@¤=‘@Œíð@iîL@9ê§@ä?ªÆÕ?‰M¾žéc¿’ Ï¿ýƒÀ3hÀg@ÆÀŒ'ÂÀ¤L¢À»æÀÑjBÀèá°Áö1Á Ô”ÁÔ Á'ÓgÁ4ÚåÁAŒÁNKÁ[# Áh‡!Áv:üÁx„¹Áj§ÀÁ\½ÁN­¦Á@ëºÁ3‰ Á&g Á^}Á  ×ÁœÀê›ÖÀÔ+aÀ½ÜðÀ§‘À @Àj³¿À5[ÜÀ Ò¿fL¾€Ò÷? ÷1?ÀÉ‹@”{@Q>I@„ÇŒ@ M@»*˜@λ‹@Î÷œ@Ï—o@Ð7C@Ð×@Ñvê@у~@Ña:@Ñ@½@ÑpÛ@Ñ]ö@ºb@¡Ùm@‰„Œ@`-ý@,9?î²û?÷¾> úZ¿0jç¿Ä"§À ÀM-ˆÀ~³IÀ—û;À¯]±ÀÆ£ŸÀÞ¢ÀöŸ‚ÁJšÁo¸Á"qÁ.)îÁ:«7ÁG¬bÁU ÁbÕ¢ÁpÜvÁs2Áe©ÁW€ÁIuÁ<5ŸÁ.“÷Á!CªÁlRÁ­yÀö^Àß^ÀÈŒEÀ±Õ±Àšå5À‚ÉŒÀR•kÀÚ ¿Ï—‚¿@â©>7¢?û-?ó>m@2¶q@m9@’Äš@¯pX@Ëž¦@Îz­@Î×X@ÏDr@ÏÃd@Ðc8@Ñ @Ðó @ѱ@Ñ6u@Ñj9@ÑŽ@ÎË@¶@œW@n8@KÝ!@õ»?¸š? ¾E¾¢5H¿˜êÀ ÞÀ8ÍFÀkŸ™ÀއdÀ¦i?À¼þ‡ÀÔ'üÀìïfÁ<ÎÁmfÁ¢Á([Á4òƒÁBUÌÁPšÁ^&`ÁltcÁnÓîÁ`]áÁR ÷ÁD)£Á6‡ÝÁ)PQÁxôÁxÁÈÒÀì_ÿÀÔ-À½W4À¦¬zÀÞ™Àoy¡À>QñÀ K{¿¤Lo¾ÖKË>ñ‡?­“â@2-@Jâ¸@‚:4@Ÿ,B@¼‰´@Î8%@΀@Îáp@ÏN‹@Ï»¥@Ð(¿@Љ @ÐÈK@Ðü@Ñ/Ó@Ñc—@Ñ—!@ÑÉÈ@ÇíV@¬R_@•µ@eb1@*éL?áNx?Xi|½lL¿e«ˆ¿á„­À'Ê6ÀY̾À…ªÀÃÀ³¾ëÀÊÀùÀã'fÀûºÕÁ 'QÁu½Á#6eÁ0{ÖÁ>(áÁL(¸ÁZknÁhä»ÁkwîÁ\É”ÁNMwÁ@õÁ2ØÁ$Š‹ÁqÕÁ «eÀûÛ\ÀãXEÀ˧ÍÀ´jÀÆ›À†Ë½À^5À+yÏ¿í<ä¿‚Tú¾°¸?=ÜO?Òq¦@"³Ê@]fð@ŒW@©^0@ÆíÆ@Î=ˆ@Î…r@Îëˆ@ÏX£@ÏŽ@Ða@ÏØà@Њ@Ðõm@Ñ)1@Ñ\õ@Ñ´@ÑÃ[@Ñö@µbø@—c‰@s ¾@7ÎT?ûÑQ?‰ >5öÀ¿6©¿Çý¦ÀˆÀLˆÀ~:¡À–ïÀ«ÿ ÀÃ×ÀÚøjÀó'{ÁÍUÁ/–Á mÁ,”‡Á:oºÁHœ«ÁW 0Áe®íÁi)9ÁZS*ÁKª<Á=8íÁ/ Á!8ÇÁÔÛÁNÀôÛOÀÜuÀÄ-°À¬o À•ŽÀ~V–ÀM¦rÀÝ:¿Ð’¿I›™=b±Ø?sŸ9?íç«@0z¥@kTZ@“uY@±3¶@Íû@ÎBë@ΊÕ@Îõ¡@Ïb»@Ïq@ÏX)@Ï(Á@ÏÏ@Ðw‚@Ñþ@ÑVR@ÑŠ@Ѽî@Ñée@¸N'@šÌW@z¡@?ö@à?˜û_>›ŒÊ¿ I㿲ŸÀ±!ÀB¬ÀrÛ“À…öÀ¥}ÔÀ¼ÍÜÀÔÀìQ#Á²Á¸$ÁòeÁ)§Á7ºÚÁFfÁT³•Ác}ëÁg-ÁX|2ÁIþAÁ;¶@Á-j¾ÁmæÁ¿FÁs¿ÀïUˆÀÖ +À¾;èÀ¦‘[ÀÀr‰ÀBåµÀ^ø¿º­¼¿‰o>|¥¼?v|@Ts@;XŠ@uŠZ@˜´`@¶´¶@Íê7@ÎHN@Î’ž@Îÿ¹@Ï‚@Îá9@Ψð@Îx­@Ï‚@ÏÆþ@Ðoz@Ñö@уt@Ѷ@ѦÓ@¸¾@šÖ3@{¦ë@A‚@èé?¡ƒ¾>ÄÖ¬¾ös}¿©©¶ÀɘÀ:„ÌÀiücÀŠà½À ^?À·ÀIÀÏ“[ÀçS@ÁÁ õÁ^EÁ(3êÁ6dSÁDz¹ÁRÈãÁaQnÁe¤ÁV<ÙÁG•&Á9&}Á*ÿPÁ2ïÁÃÀÁ…BÀë‡ÀÒ$ØÀº²À¢ªÛÀ‹ÃüÀjÀ:K)À Ï¿ªnH¿Õ>ªÕ'?‘0@)¥@B@’@};Ä@œ °@¹Ív@ÍŒ4@Î?>@Μ·@΢“@ÎjJ@Î7w@Î!@Î@Ϋ®@ÏP1@Ïô³@Й5@Ñ=¸@Ñnˆ@ж~@´I‚@—õ§@wp3@=ÕÝ@1V?wí>¹Éݾê4ë¿¢ÉÀD À5‹Àdz‹À‡yºÀœï9À³!ÀʲsÀãPxÀýKhÁ àÈÁê±Á&Z’Á45ÀÁBeJÁPØÁ_€ÞÁdDÁU+´ÁFoÖÁ7ê*Á)¨Á½âÁCxÁJòÀèÝÀÏ9[À·…ÀŸþ!À‰1ÇÀe"9À5YÄÀ)Y¿¢Âƾä¦{>ÐãÞ?¤³@ ¶¡@E*ð@|@&ž@ºÂÜ@Í#H@ÍÐ$@Î`#@Îjh@ÎV,@ÎAï@Î-²@Îv@Ρ¢@ÏF%@Ïê§@Ð*@ÐÁÄ@ÐÙÐ@È "@¬ð½@‘¬@l†ú@5ò=?þå?Ùð>®¿¿Þc¿§úúÀ5]À4ˆlÀa¯¤À†Ý0À›f`À°)¹ÀÇuÀàç Àû3ËÁ Á=Áì®Á%q1Á3^gÁA¹ÁPKÁ^Ó`Ád2«ÁUMMÁF“îÁ8Á)ÒÒÁëÜÁ]Á«ÀèKMÀΰ0À¶œÀŸ,CÀˆPÀaÀ1ÄùÀó.¿ž¶¹¾Û.r>Í©¹?¡UO@ 7d@Aò`@z@™D!@µ@ @ÌŽp@Í;L@ÍÂ$@Î œ@ÎW@ÎN†@Î:I@Î& @Η–@Ï<@ÏÉ”@Ïù^@Ð)(@Ð>o@»¨¨@¢<@ˆO†@\Áƒ@'†—?å0~?}`>5 ¿#[㿳:ôÀ ¤CÀ77çÀcpNÀ‡ºkÀœ‚6À±oñÀÈ#Àá½ãÀüR3Á fpÁdÁ&™Á3é/ÁBWÁP•üÁ_C2ÁdË€ÁUéKÁG3iÁ8´sÁ*zlÁ˜ÁýÞÁ†àÀ膄ÀÏD÷À· ÀŸëQÀˆî¯ÀcuyÀ4ª}ÀoS¿¤Æ©¾ý¼~>¤ßã?“ì´@@K@5û‡@j‹Ý@îà@©òƒ@Ö*@̦t@Í$%@Ín@͹@Î@ÎFà@Î2£@΋@Ï.@Ï0ø@Ï`Â@ÏŒ@Åå@­à@•³@xN’@G%¯@ùr?ÄW¥?Ar¼Ì2 ¿Iù¿Å•ÉÀX[À='ÈÀg£1À‰¨&ÀžðÀ³¸ÀÊ5ÀãwÀý|gÁ /Áf%Á&ÒÊÁ4£@ÁBÉiÁQ3ãÁ_ÕzÁe6ÁV4êÁG„œÁ9 Á*ÙFÁÿ\Á—úÁ¦ÀëνÀÒ®3À¹ÚÀ¢À‹t­ÀiÝÀ:êÀ î‚¿µšÊ¿"×¶>Öð?o‰â?ݰ@"ô@Sô[@ƒ\o@œ Ç@³€@Ȳ™@̆&@ÌО@Í@ÍeŽ@Ͱ@Íú@Î8É@Îh’@Θ\@ÎÈ&@È?Y@²óS@œ8Œ@…²Ì@\;·@-~­?ù-v?™¾>åF¹¾˜yí¿„n÷¿ßñ`ÀùÀG39ÀpøžÀ)jÀ¢ ‡À¶‹]ÀÍ$ÙÀåöÁÁ ŠÁ ,hÁKTÁ'ŽÁ5]ÆÁCu¶ÁQÓ±Á`jDÁfuåÁW±ÁI–Á:ÜÁ,µÁ“ÁÌ“ÁÛóÀïïFÀ׋À¾êÀ§%ÀnÀsFÀE?•Àûâ¿ÑáÆ¿eÚn¾x¿?¸ ?¯)¿@?¥@8Âé@hA@Š @Ÿ,^@±3 @À®@Ì2Ÿ@Ì}@ÌÒ@Í/c@ÍŒ5@ͳD@ÍÒ@ÍÿÀ@ÄÅ÷@²vÑ@žÛÜ@‰ÉŒ@iKV@d“ª?vIÄ?ÕÖ•@k7@Cðé@lœò@ˆ>Ï@˜_{@¦Ý,@³­@¼¦@æW@È5>@É­@ÆCÌ@À(@¸ä@¬B@›Ç1@‰zÜ@l/@BÐ@œ!?Ûr»?ƒÚž>¬Í¾±Šš¿ƒ`¿Ør]À›´À>rÐÀeÀ«À…äÏÀ™0À­2KÀÁqãÀׄ_Àï§áÁFZÁ [Á_Á+"Á9jRÁG˜ôÁVµÁd¤5ÁlDBÁ]±ÁOEKÁARÁ35½Á%·>Á´Á .Àþ4ÁÀäî“ÀÍu;À·HxÀ¡"À‹DÀkK=À?ëKÀ8†¿Îõk¿p—0¾tì">íÞJ?‘P!?åÐ @¹¿@?4®@_ìX@~ T@Œts@—à’@ Ó*@§8˜@« ¥@«Í=@¨ñ±@£ì@œ•È@’M†@„)£@f˜j@A~¸@˜?å^\?“RÓ?¢à¾eo¿RÝZ¿»¯9ÀfîÀ.×7ÀUUuÀy¾eÀ@äÀ¡º;Àµ6Àɺ´ÀßPÀ÷R¿Áý¨Á^äÁ!²Á.PSÁ;ùbÁIúxÁXB}ÁfÄEÁoÝaÁavÁSItÁEdiÁ7× Á*‹øÁkôÁ¤"ÁR\ÀðÀØÔ£ÀÂV‡À¬rýÀ–Ö±À›ÚÀY4À/H¶ÀÕÌ¿´ ¿A85½Ù,? B¶?’;?Ûf@ÇØ@.Z¼@JÙ"@dÈ@xå|@„ °@Š¥ã@Ž'_@ŽŸî@‹ñÞ@‡\¿@€Še@n‚p@V×P@8T@@h?â?L?–h’?Fí½Pq¿4ûq¿¨|Û¿ûH©À$jhÀJ=…Àn HÀˆÃ²Àšm`À¬‹WÀ¿93ÀÓ.=ÀètÀÿÂ;Á ÖÆÁOÃÁ%BÈÁ2q Á?ÖvÁM”7Á[ TÁiì¯Átd¶ÁfEåÁXjÁJÁÉÁ=0+Á/ЋÁ"çïÁ—‹Á §Àûy)ÀäH0ÀÏvÀ¹œ¢À¤öÀWDÀw~”ÀNí·À%³¿ùV¿ª.í¿3°×½õe¦>âÀU?xÁ ?¼Šå?ø8\@´R@.Tò@A¼ @Qoý@\…@b¤è@bÛe@]ñ‡@U‹+@I1@8aª@",ï@DÍ?ΔÓ?‹-!?T´½3ÿ{¿$¹\¿¢)¿îëÀÝ3ÀC×€Àgg-À… À•ßÀ§'8À¸•·ÀËßÀÞªÔÀòþ‹Á¼ýÁ׺Á/Á)ãÏÁ7üÁD¥öÁRNqÁ`]Án/ÁyÝÅÁkþ®Á^,ÉÁPxÁCáÁ6&OÁ)¹8Á± ÁñÁÀò,7ÀÝO´ÀÈLMÀ³Ï£ÀŸf»À‹ß,ÀpµaÀIeíÀ"Šè¿øéö¿¯É¿P 뾌ÈZ>hÛ†?1Ú?ú¤?ÃÝ$?ïžX@ ^Ø@×¹@"ý:@(ˆ/@(eÕ@#Ç&@Š@0‰@_“?Ùó±?¨m=?bØ^>Éí¾ •&¿0@¿ û*¿èωÀÃÀ@;‹ÀcþbÀƒz›À“³qÀ¤/5À´ÇÀÆ-DÀØ}«Àì{¼Á…êÁ 7ÁÕ]Á#-·Á/»ÛÁ<ŒFÁIÑ8ÁWu6ÁeSÁsBÝÁéÁrÁd[²ÁW\ÁJwÁ=X¢Á0—Á#eåÁK°Á ùüÁÝÀì»ÒÀØ{@ÀıøÀ± äÀs»ÀŠm/Ào©ŽÀJÀ&§MÀ'!¿Âìп‚@»¿ ©e½¤Òi>¦á?32@?ƒjc?¥Î?Á5y?Ô\d?ÜÝì?ܵ¹?ÓÒT?ÄD_?®ì½?”Љ?`˜z?ݦ=üý̾­†a¿RV¿«•=¿ïâ“ÀálÀ=ˆÀc›À‚?qÀ“3oÀ£¥À³‡wÀÄÃÙÀÕÿÀèã=ÀüPDÁšmÁ'cÁ0±Á*ˆÁ6zÁC$»ÁOþÓÁ]AdÁjÛiÁx¾ŠÁƒ$#Áx·DÁkt‹Á^ŽÁQj…ÁD=·Á7„Á+WÁ×Á¹ÓÁ «ôÀþM‚Àê"ÎÀÖ|QÀÂí¬À°»À‘‡À‹ªMÀt9UÀQ!À0oÁÀ;Ê¿â¿b¿§¿b–$¾÷ù'¾ b>4¡>Û™ë?!8[?ES>?T¦Õ?S Ñ?A‹?$À¼>ûÓJ>•Ãv<õÙ¾“6M¿'ßÝ¿Šì¿Ä1¸À-`À"@ÀB¼BÀd²-Àƒ}FÀ”/¶À¤‹À´0ÀÃønÀÔÕ$Àçx1Àù¿\ÁÐWÁcÁfÁ&¿ÅÁ2WÁ=öÁJv6ÁW-ïÁdÆÁq@Á~ÊÁ†·ÍÁ€ÏÁsdÁeöÁXÚ ÁL(ØÁ?õ¸Á4ZÚÁ(ÙèÁš1Áœ?ÁIžÀüh{ÀèÃwÀÕðïÀÃÌMÀ±ÛÅÀ oÉÀ¹×À~fÀ^ð+À?‚éÀ"5À´5¿×oë¿§†}¿{Jx¿/L(¾â²°¾‚°Ö½üÖ ½…ôº½›|¾ó¾Pš¾Çö ¿²s¿T·¿ŽÑú¿¹íA¿é¿ØÀ),À-W>ÀMÝÀk±¡À†1½À–—éÀ¦&ÀµÌ}ÀÄæÀÔ¿Àå>SÀ÷ײÁ³ÁèÁÁ.IÁ$^ÝÁ/µÁ:Û£ÁFqYÁRrÕÁ^óÁk®™Áx‚ÂÁ‚ÖRÁŠª Á„ÞÁzÇ/Ám¹?Áa OÁTѳÁHÆ?Á<õ$Á1˜ Á&`}Á³ÁÑÁÜnÀüa)Àê ?ÀØ&zÀÆ«ÀÀ¶*±À¥½‡À•ùÀ†›GÀo¦ãÀS ?À8¤0À¨¾Àö ¿êw¿Æ/¿§ìŒ¿‘Dø¿‚vd¿wMu¿{ ¿¿…üÍ¿’#"¿£åÁ¿ºqÎ¿Õæˆ¿÷˜hÀ® À&ÞÀ?ÉJÀ[b–Àw^ðÀŠÈ*À™ç×À©hRÀ¹sÀÈ4@À×4ÀÀçT_ÀøQüÁî7ÁÔäÁ.,Á!Ý^Á,}÷Á7æ#ÁCÞþÁOHÊÁ[(<ÁgT…ÁsЦÁ€E Á†ªâÁŽw•Á‡Ï¤ÁN·ÁuõÿÁi©KÁ]s)ÁQ’ÊÁEÿ~Á:ŠÁ/ ~Á%‹2Á²˜Á–`Ág¯Àþû¤Àì÷šÀÜ5eÀÌ?7À¼žÈÀ¬ú™ÀžäÀ7(À‚š*Àk”¼ÀTKgÀ>Œ À*ó]À3kÀ 9ªÀ‹t¿ôî¿ïC¿ñ;:¿ùÀP¿À ÁxÀ§ÕÀ!j[À1oÀCÀkÀYøÀo|ëÀ„Ï!À’ªÀ À®÷æÀ½ÀyÀÌÈ#ÀÜ%'ÀêÇ}ÀûƒnÁjÕÁ)Ág]Á"€XÁ+š®Á5©¦Á@†ëÁLÁX-ÊÁdiÁp éÁ|eWÁ„{ËÁŠÕöÁ’TÁ‹Û2Á…Œ¼Á~ÀŽÁrx–ÁfÅÁZÑœÁO5bÁD$Á9ËÁ0ËÁ%¦<ÁfÁh%Á X˜ÁoæÀòš×ÀâÒZÀÓTÀÄÉOÀ¶Œ‘À¨ó­À›èfÀ¹ÜÀ„RÀtGÞÀa‡zÀQKÏÀD,À:•±À49À1Z­À2ZÛÀ67¹À;½ ÀC:fÀL$ÀX$SÀfªÿÀx êÀ…‚£À>;ÀœQÀ¨îøÀ¶=ÀĆšÀÓ‡"ÀáÈ/ÀðÔ_Á@Á>Á"çÁ—Á"üÒÁ,¥ÜÁ6:ìÁ?»dÁJ>ÁUéÁ`´îÁl×¹ÁyÁ‚ÇÁˆÇkÁœÁ–„!Á;`ÁŠÁƒá Á{Í%Áoò¡Ád?áÁYQÁN‰ŽÁD¼ÂÁ:LÓÁ0pÁ'wNÁ²™Á”åÁ ™Á¦<ÀùÐ Àêð§ÀÜÇ{ÀÏ+ŠÀÁòÌÀµ–À©ÝTÀŸ ;À•1þÀŒINÀ„Œ¥À|ÑÀsÊ\ÀnÀk¢çÀl8Ào›Àtã“À{GŸÀáˆÀ††CÀëñÀ–BcÀŸGÀ©š|À´<ÃÀÀª%ÀÍêÀÚÊäÀé‘SÀ÷×ÍÁJÁ &SÁcoÁ Á%O²Á.SÊÁ7u˜ÁAkÅÁJåÁT]Á^á[ÁjåÁu² Á€ëÁ‡0ŠÁ8ªÁ“l‰ÁšÿUÁ”ÆÁŽ 8Áˆ {Á‚§µÁy‘yÁnQÑÁc£ïÁYLÁO]"ÁEAÊÁ;êÁ2ù2Á*“Á!m›Á¼óÁ‹ðÁ ìÁŽ›Àõ:ÁÀçøÀÛiŒÀÏNßÀÄ=2À¹­ÝÀ°N(À§èQÀ ¹ÁÀš¹?À–šVÀ“³‡À’­,À’üÀ”€OÀ–óƒÀ™éWÀßÀ ÜÊÀ¨”À°ÃlÀ¹T,ÀÃ{ÀÌÐúÀØ“¸ÀäôõÀñÝ\Á-ÁF(ÁÂ*Á©ÎÁÈëÁ'5Á0“Á9â¦ÁBüDÁLbÞÁV qÁ_WÔÁi]‘Át³Á>ÃÁ…yÞÁ‹ŠóÁ‘ËÐÁ—ùÃÁŸ–/Á™tCÁ“nâÁmlÁ‡Œ³ÁæÁyâÁnφÁd¹õÁZo¥ÁPÐçÁG†aÁ>#Á6yÁ-SÁ$½rÁî*ÁW#Á ÚÁoÁž_ÀôêÜÀéž›ÀÞ~ŠÀÔ¼sÀˆ¡ÀîÎÀ¼æ¥À·8AÀ³NÀ°yÕÀ¯ÎÀ¯ì§À±r›À³¥ À¶˜ À¹MÍÀ¼sÀÃî©ÀË >ÀÓ¢ÐÀܯ&Àæ£Àñ[mÀý‹JÁ5Á õ+ÁáâÁ–Á"„5Á*­Á3ùÁ<*ÁE4WÁN„­ÁWóvÁa¤<Ájæ_ÁtríÁ~¥bÁ„µPÁŠXÂÁ5lÁ–DœÁœ€tÁ¤XæÁžM—Á˜FõÁ’eÖÁŒºLÁ‡KÁ‚¼ÁzO¶Áoá@Áf ÿÁ\{»ÁS3­ÁJýÁBjÁ9l;Á0÷~Á)$}Á!wrÁ¡ŽÁ¸ÛÁ wõÁ¢PÁé¤Àù0¢Àïù{Àç%úÀßv ÀØÙ ÀÓ¯ÒÀϺÄÀÍ€ÊÀÌœiÀÍ %ÀÎjæÀДöÀÓR¢ÀÖ|ÀÙ†×Àß‘8Àæ„ÀîäÀöÊ?ÁneÁÆÁ öÁçÁ8^ÁZÁ&åÁ.›Á6Þ\Á?!ÁGô;ÁPý ÁYéÁc`\Ám@Ávó÷Á€ÆÁ„çÁŠÁ’Á•(pÁ›"Á¡ãÁ©9tÁ£0ŸÁOÃÁ— ¦Á’)ÁŒïˆÁ‡û%Á‚Â÷Á{ƒ¢Áq¾)Áh5+Á_U6ÁVÔ·ÁNfãÁEz2Á=?!Á5GnÁ-ÿÂÁ'‹õÁ ªÿÁÎÁîfÁÁ MGÁÆóÁbkÀû®×ÀõoÀð= Àì®ÀêËóÀé…ÙÀêH5ÀëtZÀí›ÛÀï‚ÀòvUÀöÄxÀû°^Áý6ÁÃHÁû»Á –‹Á«¶Á»ÁöçÁ$‡ºÁ+€MÁ2ѼÁ:ǵÁC,ÿÁK‘3ÁSý¥Á] MÁeØKÁnØìÁx†úÁ4ˆÁ†ÁЏ(Á­—Á”æ×Áš]Á  èÁ¥çßÁÿ¹üÁùn)Áó,mÁìîþÁæ¼>Áà¤>ÁÚ•áÁÔŒ¸ÁΊ“ÁÈž ÁÂÌGÁ½^Á·RžÁ±Â3Á¬;¬Á¦ÞKÁ¡PÁœh4Á—‚Á’â»ÁŽƒKÁŠ/jÁ† ]Á‚?hÁ}³•Áw»Ár ðÁm”Ái£ÁfQÁcAhÁapÁ`¯Á`ëÁ`6kÁaƒ(Ác2qÁe°ZÁi>…ÁmY÷Ár(rÁwÌpÁ}³wÁ‚/¥Á…êÈÁŠðÁŽ\VÁ’ËwÁ—~†ÁœvÁ¡–úÁ¦Ô%Á¬&Á±¨Á·)dÁ¼ìyÁ¹ÁÈžÕÁΚnÁÔžÜÁÚÁgÁàýnÁç>ZÁí„*ÁóË5Áû3âÁôçvÁîœ:ÁèZNÁâ:ÁÛåvÁÕȼÁϳ1ÁɪSÁðšÁ½ÅâÁ·ì>Á²LÁ¬p¶Á¦ãYÁ¡bÁœ ¬Á–ÆùÁ‘°êÁŒà8Áˆ\:Á„\Á•KÁwŸšÁpwXÁj/ZÁdzƒÁ_1¬ÁZóÁWÅßÁTû«ÁSJÁR=¥ÁQ’XÁQÆ/ÁS/ÁTÒÅÁW{@Á[ªÁ_9ÓÁdT{Áj ˜Áp4»Áw=ØÁ†ÁƒÔáÁˆB¢ÁŒÛaÁ‘¾+Á–ÈüÁ›ù"Á¡R×Á¦ºÁ¬NçÁ²äÁ·Ø!Á½¾,Áÿ“ÁÉÇüÁÏíšÁÖ.¶ÁÜuWÁâ¹pÁèýêÁïPÁöÍ?ÁðiˆÁê²ÁãÊÒÁ݉oÁ×O’ÁÑŽÁÊùÁÄÛñÁ¾Ñ&Á¸àçÁ²ú Á­KÁ§DxÁ¡ùÁœ{Á–™êÁ‘PzÁŒdÁ‡˜Á‚[.Á{ïxÁsl¼Ák UÁc–Á\ðqÁW$hÁQ ~ÁMÁI¿ÁFùCÁDõ”ÁCØšÁCUCÁC”4ÁDõ÷ÁF²ÈÁIˆ¹ÁM LÁQ^ÇÁVÄ…Á\„“Ác ^ÁjwºÁrº5Á{@Á‚UjÁ‡ËÁŒTÁ‘.àÁ–Š|Á›õýÁ¡„–Á§@aÁ­ŒÁ²ë\Á¸òÁ¾ÿ1ÁÅ'ÉÁËmüÁѺ1Á×úÁÞ<ÒÁä“zÁë9Áò‰ÁìÍÁå¬ÁßVFÁÙÁÒÀ“ÁÌ¿ÁÆ_ÁÀ7JÁºSÁ´ÊÁ®bÁ¨=fÁ¢RØÁœ~×Á–ݪÁ‘Y*Á‹çHÁ†«\Á€öÁy'=ÁoöMÁgQgÁ^ÕÁVý=ÁPÁJÈÁDg¹Á?–íÁ;ù]Á9#îÁ7pÁ5”¹Á5AMÁ5£©Á6írÁ8áÁ;¿.Á?5¶ÁC×|ÁIhÁOU)ÁV@¿Á^´ÁfÉÁoÈöÁy3ÿÁl2Á†z©Á‹ÏwÁ‘D÷Á–ÍêÁœ„Á¢DÁ¨)Á®44Á´GÁºr`ÁÀ½™ÁÇ ‹ÁÍIgÁÓŠ«ÁÙåÈÁàYÁæÒŠÁîeŽÁççÁák4ÁÚýgÁÔ¢ÁÎJ ÁÈ–ÁÁÔjÁ»¦éÁµ~ÉÁ¯YŸÁ©KÌÁ£eJÁˆ‹Á—žÁ‘Î9ÁŒ3ùÁ†¶ÁOÁxIÁnÙÁdyGÁ[…€ÁRɤÁJˆ_ÁC=òÁ=Á7M®Á2M±Á.{;Á+OAÁ)8tÁ'Ÿ=Á'^ Á'Ç Á(õrÁ+T!Á.^Á1½HÁ6¶PÁŠiÁ6ůÁ0@Á*VqÁ%éÁ!¼Á·âÁ’ Á~ÁÁêÁ ŸÁLÁÐ4Á »¡Á$¸ßÁ)õ<Á/™(Á6Q­Á>ÐÁFd…ÁOfCÁY ‰ÁbÚÁm@eÁx9\Á«øÁ‡SÁkÁ’ä’Á˜õ)ÁŸeÁ¥@ÄÁ«|BÁ±ÂÁ¸ ÅÁ¾]?ÁĽÿÁË.”ÁÑ¢ïÁØbÁÞŸ Áæ–GÁßäÎÁÙHIÁÒÄGÁÌJñÁÅÖÁ¿qÁ¹ ôÁ²¿úÁ¬„ÉÁ¦MÁ 0ÑÁš íÁ”öÁŽ%_Áˆ6ÕÁ‚n ÁyìÁnwÁcœ´ÁXñBÁNÉwÁE¶Á;¡¹Á3 rÁ*ä=Á#ÁgÁÈÎÁ8ÁÁžæÁPCÁ ÛÁ  <Á ÀÝÁÁWßÁ©ÕÁ1›ÁwAÁ#}ÏÁ*˜ Á2WKÁ:ñæÁDvöÁNMGÁX9ÁcLùÁn\úÁy©9Á‚BÁˆlZÁŽuOÁ”“uÁš¾ Á ìºÁ§5èÁ­Œ,Á³å=Áº;ÁÀ£–ÁÇßÁÍŒÁÔ'žÁÚÂÁâ×LÁÜ1DÁÕzæÁÎØ`ÁÈNÿÁÁÖ»Á»^ Á´ô€Á®±Á¨@)Á¡þÁ›Á“Á•¨ Á ³Á‰žÁƒ¥áÁ{m3Áoõ_ÁdËSÁY¿“ÁNàíÁD:^Á:MzÁ0¯ÍÁ'²¡Á£ÁœÁ¢Á TÁpXÁ$ÒÁ¢ÁpÀÿ¹ Á5ÁP­ÁOÁýÁ ¿[Á7ÍÁëÁûyÁ' <Á05-Á:~ÁD,ÁN¦“ÁYu8ÁdÆÕÁph¨Á|)ŠÁ„ýÁŠHÁB‘Á–tðÁœÂÇÁ£%Á©xãÁ¯ÃpÁ¶.¯Á¼±óÁÃ6CÁɸ•ÁÐJiÁÖæZÁßôÁØn]ÁÑÌÞÁË"TÁÄ|éÁ½æ*Á·fŸÁ°ìÁªz"Á¤!°ÁÜ'Á—”ÐÁ‘S«Á‹84Á…(ÓÁ~MsÁry¾Áf»{Á[VòÁP$XÁEÁ:\LÁ/ë?Á&J„ÁþnÁ‰ Á "ŽÁ[ÞÁ”ÈÀ÷V¾Àð«Àë?ÈÀè‹Àæ‰{ÀèÓÀêˆÀíÿÜÀõ÷-Àÿ=…Á•ÝÁ ŽÛÁòGÁ•åÁ&36Á03kÁ:aîÁDé½ÁPÊÁ[ÙïÁgž¢ÁsYÙÁe_Á…åÚÁŒÓÁ’nÁÁ˜Ü¢ÁŸÏÁ¥f—Á«Õ–Á²`Á¸ÖÖÁ¿P¹ÁÅæLÁÌÁÓ.ÁÛ|]ÁÔÊßÁÎŒÁÇtƒÁÀÎ%Áº(öÁ³‡Á¬þÑÁ¦†cÁ Á™¿TÁ“€Á=eÁ‡ Á€ëLÁu¤›Ái¢ÞÁ]ùàÁRnÁGÑÁ;ÑÁ0ìðÁ&cÄÁ?Á!Á 3ÜÁwÀö±™ÀꣷÀá'ÀÙq“ÀÓµÀÐýÀÏÂÀÐhåÀÒÕ°À×TÞÀßoÀèÙfÀõ­ýÁîòÁ ã#ÁÓœÁ\9Á&‰œÁ0à“Á;ëæÁG~˜ÁS0‚Á^ùôÁjúfÁweeÁñíÁˆ@‘ÁŽ˜ßÁ”ÝHÁ›+ÄÁ¡›XÁ¨ûÁ®„}ÁµvÁ»œVÁÂLØÁÈÓ¤ÁÏtÔÁØëÁÑEÁÊ•ÿÁÃæÐÁ½8ƒÁ¶Œ4Á¯æmÁ©AçÁ¢´ÍÁœ?WÁ•ÌÁÁw—Á‰4 Á‚õðÁy³óÁmŠñÁaPÅÁU]€ÁIäœÁ>‚«Á338Á( ¯ÁhÁ0fÁ }Á×ìÀñ>ÈÀâ+äÀÕ÷ÀËfXÀÃ$¯À½ø®À»MÀº.Àºs†À½èÙÀ°cÀÊ¡ªÀÔ9¥Àà´ÀðVƒÁs´Á K¼ÁFˆÁ‹yÁ(V<Á3©hÁ?1HÁK ýÁWËÁch“ÁoâPÁ|NÙÁ„tÃÁŠÅIÁ‘9Á—wWÁä™Á¤RÁªÒÁÁ±rRÁ¸ÉÁ¾¥«ÁÅKaÁÌøÁÔÀ“ÁÍí·ÁÇ,ÁÀ|Á¹ÏnÁ³»Á¬k›Á¥ÅéÁŸ ÿÁ˜ñÁ’’Á‹°&Á…Z^Á~'±Áqª[Áe{DÁYU×ÁMUlÁAúÁ6%vÁ*·¢Á´¯ÁÁ ÕxÁ íÀïÑêÀÞ‚ÓÀÏiÂÀÂ2{À¸*qÀ¯ÑƒÀªÇÀ§u„À¥üÝÀ§7ÓÀª&ûÀ®› À¶ìÀÀ`0ÀÍÐèÀÞ?ÆÀîöcÁæ™Á $Áœ=Á Œ«Á+ÕµÁ7®JÁCFÁOÒ Á\2ÁhYÁÁtõ¾Á€ÏyÁ‡ÁkÝÁ“ÔÁšHSÁ ÊcÁ§eÁ­ÿDÁ´–¥Á»4ÁÁå]ÁȦ÷Áј¸ÁÊȽÁÃ÷ùÁ½'šÁ¶iHÁ¯ÀÔÁ©!,Á¢pãÁ›ÎÁ•+ŠÁŽ˜,Áˆ)hÁŲÁvä:ÁjUåÁ]ÞNÁQ®ïÁE„·Á9¿!Á.ePÁ"ñTÁŸbÁ §ÁëËÀòeÀÞÌ<ÀÍÀÀ¾"ÎÀ±ÿÀ§4$Àž§%À˜éÀ•uZÀ”bPÀ•8ŽÀ˜0üÀÓHÀ¦¢À¯ÚðÀ½ìCÀÎ:ÛÀß=PÀòâ#Á¨ ÁW¤Á[óÁ%ÎÁ0dõÁ~€Á2_Á&ÆîÁqËÁ@¨Á—pÀöÙÀâ°oÀИÀ¾°üÀ°@tÀ£ðÀ˜îÀ»´ÀНÀ‡ZWÀ†ZÀ‡íÀ‰æ®À_qÀ˜&óÀ¢I-À¯pÀ¾÷2ÀЬ7Àä‡OÀù6IÁxèÁ–ÅÁ×uÁ)¥dÁ5èUÁB3ÁNXÝÁZ¨úÁg:‘ÁsÚiÁ€PÜÁ†¢øÁ=Á“óÁš6»Á ªçÁ§A7Á­õÞÁ´ÅVÁ»‚¾ÁÂ@ÁËÔ»ÁÄä»Á½ö¹Á· ÑÁ°8vÁ©hÁ¢žßÁ›ñ7Á•UÁŽºÁˆ/Á‰cÁv'ÍÁiJÆÁ\•çÁP$)ÁCÇ#Á7ÒðÁ+å]Á $Á» Á lõÀý=øÀéŸ\ÀÖáÀÃq±À³.ÒÀ¤BÀ–¾„À‹Ü^À…?ZÀ}œÙÀw ¬Àv(Àw‹·À}kôÀƒ·ëÀ‹u_À—PÀ¤m×À³N…ÀÅ-ÀØËxÀíK|ÁYÛÁ {BÁô/Á#áoÁ/w_Á;¬ÁHÁTeuÁaÁmÇÁÁz0ÁƒhÓÁ‰îªÁ{¦Á–ôpÁЏÁ¤A Á«+Á±±mÁ¸q¸Á¿J«ÁÉ!^ÁÂ…Á»+#Á´D½Á­aàÁ¦ŒVÁŸÆþÁ™4Á’WXÁ‹¾ÝÁ…'\Á}"9ÁoþÇÁc#?ÁV_iÁIÀËÁ=~ÔÁ1W7Á%‡eÁÉâÁ’ïÁ¨MÀñ†ÁÀÝŒœÀÊm9À¸jÀ¨BÀ™¿”ÀfCÀ„rëÀxIQÀo…&ÀiY§Àf¸þÀh$ÕÀne ÀxÄ™Àƒ•ÑÀ±§À›nÀªÏðÀ¼I+ÀÏ„ÿÀãlÇÀøÒ4Á›Á`*Á¹ßÁ)µ‰Á5î ÁAé·ÁNoXÁ["†Ág‹ ÁtRÁ€rˆÁ†óîÁz.Á”·Áš®(Á¡_dÁ¨IÁ®ÒÁµ­¯Á¼ YÁÆ£ÖÁ¿•VÁ¸ŒªÁ±—èÁª¹yÁ£ävÁ:Á–YÇÁ¨-Á‰yÁ‚n¿Áw¿0Áj¥òÁ]–ÁPÕöÁD<Á7Ç^Á+ʧÁûÁ]*ÁïÝÀü=ÊÀæî9ÀÓPèÀÀøÀ¯rŒÀ ÀÀÀ’ªÈÀ‡Þ|À|Ö-Àp3çÀfÁêÀaÕƒÀ_ÅrÀ`E”ÀféÀnš,À}ìøÀˆíUÀ”zxÀ£«çÀ´8âÀÆYˆÀÚb¢ÀïËÁ\ƒÁ PÁàãÁ$˜Á0V ÁÁ¨;èÁ¡^,Áš˜¤Á“Ü”Á(vÁ†zÕÁ¨ÁrBÁe™–ÁX›¡ÁKÙ|Á?cÁ3÷Á&¹ZÁèþÁ<¬Á óÀò÷ëÀÞ%XÀˇÀ¹;+À¨©0Àš°,À·$ÀƒÊ‹ÀwµÁÀk`ÀdšÀ_›À^LÀ_,Àb”Àk’‰Àw%¿À…{=ÀøãÀž LÀ®QµÀÀÀÓ* ÀçIÀû†çÁ¸íÁ`CÁÈÃÁ+N¦Á7m¯ÁCöòÁOö¼Á\x¿Áih Áv!ÃÁvÁˆ¬Á޽nÁ•}åÁœA Á£œÁª ‡Á± ÝÁ·û]ÁÂ.KÁ» gÁ³ÿEÁ­SÁ¦.ÁŸ õÁ˜E¶Á‘ƒžÁŠÇ]Á„ÁzÖ3Ám˜"Á`žêÁSÇhÁGÛÁ:”MÁ.9¦Á"Á‰Á ´\ÀÿXÅÀêy¦ÀÖ{ÀÄ ÍÀ²ÛúÀ£ÇŸÀ–7#À‹Q‰À®uÀuóÈÀllBÀe°jÀbQ¬À`îµÀahÉÀd©<Àk0^ÀvóßÀƒ/´ÀޤÀš'žÀ©¹À»*ŽÀÍ.¯Àà˜/Àô¸0Á5_ÁRÁqýÁ'%´Á3VÏÁ?Q9ÁKŠÁX*(Ád«ÃÁqU6Á~^^Á…ÜðÁŒ¡!Á“UÁš6Á üÁ§ïÁ®åÁµÞÁÀJÁ¹+îÁ²ŸÁ«zÁ¤˜Á+£Á–NqÁw`Áˆ®6ÁælÁvrÁiZÁ\\[ÁOŠÁBñ÷Á6m[Á*@VÁ0Á‹´Á-ËÀøûžÀäÙÅÀѪYÀ¿z‹À¯HLÀ å¦À” TÀ‰÷ÏÀ̹ÀvßnÀoÐÀi¸šÀf·ßÀe7«Àe~·ÀgøÀn*aÀwõÌÀƒv+ÀŒ´àÀ™(À§ zÀ¶ß8ÀÈ@½ÀÛÙÀï{ŸÁÒÁ BÁõ‚Á#„wÁ/©Á;HôÁG~"ÁTcÁ`¤†Ám‚¶Áz´‹Áƒ÷9ÁŠÁ‘GDÁ˜ ùÁŸJÁ¦²Á­ }Á´Á¾ Á·mÁ°]Á©V!Á¢VsÁ›ePÁ”>Á›,Á†ÂzÁ€áÁrÀÁe™ÞÁX½øÁL:Á?¦ÐÁ3N…Á'5ÙÁY:ÁÒ ÁÛÀôMåÀàLÀÍVÀ¼,8À­A˜ÀŸÇ‘À“ú¯ÀŠ—yÀƒ]Àz¸´ÀrúCÀn'TÀjÐJÀi'Ài„ÁÀlBäÀqÛzÀ{vAÀ„?(Àl¯À˜ úÀ¦¡Àµ¹ÀÄóîÀ×¢ËÀ깚ÀÿeÁ UÃÁ!;Á Ÿ;Á,/%Á7ïKÁD5ìÁP¸<Á]<ËÁj Áw,‚Á‚"öÁˆÏGÁžQÁ–‹]Á‰Á¤{³Á«iHÁ²gÁ½ ÈÁµõ1Á®×Á§ÍXÁ Õ"Á™ßÁ’ì ÁŒôÁ…/ßÁ|ËvÁo~ÈÁb„íÁUÂÓÁI7gÁ<ɬÁ0d;Á$qTÁ¾dÁ ` ÁªPÀð´âÀÝÀÀË­±À»¼ÎÀ¬äNÀ ˆÀ•jPÀŒÀ„ßoÀ~vÀv¥7Àp:ÓÀk*°Àh…íÀi¥ÀmYºÀtÕÝÀ}¼[À…Á;ÀŽUÀ™ ÇÀ¥; À´ÛÀÃY‘ÀÕ"“ÀçéÀûrÑÁ°ÁÁŒÁòNÁ)JÁ5vÁAPÁM¶-ÁZPÁgDhÁtWCÁ€¿®Á‡wˆÁŽO¦Á•8jÁœÁ¢ÿÁ©ôæÁ±;Áº€ŽÁ´‰—Á­¢eÁ¦”aÁŸ‘ÍÁ˜”[Á‘—ÁŠ«ÁƒÞXÁzSƒÁm Á_õÿÁSBüÁF´xÁ::½Á.$ÇÁ"]´Á‚Á ÿ@Á{+Àï`XÀÜöÀËcåÀ»¶=À®êÀ¡ªöÀ—?\ÀŽS*À†œïÀwKÀt[:ÀiÓÀc ¾À_ÏÆÀaô‡ÀgJÀq‰¸À~ƒñÀ†‡3À‹6ÀšrÀ¦À³ä”ÀÃe]ÀÔ*ÌÀækåÀùØbÁÅ“Á]ÁL½Á'd/Á3½Á?HÃÁK»›ÁXÁ ªÁNØÁCÁ%å¯Á1aÁ=mƒÁIŽzÁU²gÁb2‘Áo6Á|SÖÁ„åÁ‹¢pÁ’gyÁ™I*ÁŸñPÁ¥ÿÜÁ¬-±Á¬4ÖÁ¦(±Á BÁš9HÁ”AgÁŽ|ŒÁˆñ*ÁƒXÊÁzÁöÁnèwÁb‹+ÁUŸÁIPÁ<ü.Á0ÒïÁ$óÀÁ‹ÁÉ>ÁCÀóŸàÀà¡pÀÎï£À½¥“À­¹ ÀžgbÀG§À}{À]„uÀ>O‰À! øÀ!4¿á(N¿Ä9¿¶ý¡¿¼‹¼¿Õ.à¿üzÑÀšÀ; èÀ_½²À„*#À™ÀÀ¯™óÀÆDãÀ×áŽÀén'Àû•¾Á"ÓÁ(©Á³ÕÁ&U=Á1¥"Á=e@ÁI@ ÁUD2Áa½Án¡ÈÁ{áÁ„1Á‰œ~ÁEËÁ•%øÁ›6&Á¡[Á§{ Á§‰Á¡tuÁ›v"Á•“¾Á ôÁ‰¬Áƒì÷Á|Ù:ÁqP$ÁeUÁYC,ÁLN,Á?gPÁ2ÑÁ&y­ÁH¨ÁW]Áì—ÀðuØÀÛiZÀƦúÀ´8ýÀ¢›»À‘Ä6À‚VXÀfT‰ÀH+"À(²À %!¿×>T¿¡ª„¿cLŒ¿Wk¾ñv¿QÔ¿>žÌ¿Ó¿Ê^Àª À0QëÀZZáÀ‚ÇÀ™^ÒÀ¯àgÀÆl•ÀÝ `ÀóÈ‘Á;æÁ«Á+wÁ'ˆ³Á2~iÁ=R¤ÁH[/ÁSìÁ^kÁhñRÁs!ÀÁ}Þ Á„‘¿ÁŠoÞÁ{wÁ–”ÆÁœ¹ Á¢ã.Á¢û ÁœÇjÁ–½(ÁϳÁŠüfÁ…{Á~h%ÁrþÙÁh ²Á\óÁPÔÁC>Á6·Á)2Á[“Á÷-Á¾ŒÀïy$ÀØùÀÃY3À®L5À™ØlÀ‡ä0Àl« ÀLo%À-ÑìÀe¿â[¿§þÝ¿W­E¾ËHÉ»þi>•«±>öáë>ÖÊL>7Ó_¾„¥Â¿Gç¿°VœÀ,ÿÀ,!zÀXÍyÀ‚¾ À™KªÀ¯ÓÀÆÑÀÝ8ÀôÁž¾Á"´ÁµÁ'îrÁ3 Á=àÑÁHßæÁSì&Á^&ÚÁhÁóÁsóÖÁ¨©Á…ÒdÁ‹Þ÷Á’ Á˜?xÁžz#Áž²\Á˜ReÁ’ÁŒ$Á†7eÁ€iòÁu+éÁiœÛÁ^>rÁR¿ÒÁFü¥Á:FÁ,ßÁÕ ÁÙâÁôMÀòéXÀÚhâÀÂHöÀ«e«À–<À"ØÀZ”åÀ7 ÀÚ¿ë]Í¿®Í¿i½‡¾ã<áI>ïß ?a ?œ§ ?¸IZ?¬³`?…`¼?é¹– ¿ Ù¿¥o ¿ýº›À+9zÀXU}À‚›¥À™WÀ¯ønÀÆÜÀÞ$ ÀõvRÁ+Á"Á”dÁ(¶)Á3çFÁ>ó‚ÁIoéÁSõcÁ_ ³Áj¬ÁvÁCÁ‡uòÁµÁ“ø2ÁšVµÁš„·Á”']ÁüÁ‡‰YÁ€ÖÁwZˆÁkÏÝÁ`KóÁTܰÁIYÁ=‰üÁ1‡Á$L0Á܈Á ™Àù*GÀß8ÂÀÅå À­T¬À•#À|fÁÀR?ÐÀ'ï À±{¿¼ñ¿u°%¾ö¨‘¼¼h‡>Û9?c9s?ª2ß?ßâ„@€@o@Y?õ¬?°ØÙ?Cñ=ÖN¿´‰¿¢Þ¿ü'LÀ*ÈÀX< À‚¸¿À™žuÀ± —ÀÈx_Àà<À÷èÁÚèÁ“òÁÈÁ*, Á4ø,Á?’’ÁJ„ŒÁUóeÁa’¸Ám÷ÁzÁƒJÁ‰–ùÁùDÁ–ƒÁ–PÁá<Á‰¹¢ÁƒUVÁz1òÁn%NÁb=ÁW'ÁK´ÞÁ@%'Á4aƒÁ(‚òÁÒIÁ^ˆÁì&ÀæýÀÌ ÉÀ²ÔÀ˜ùyÀ€@zÀP/À"¿ïßû¿›/k¿$&¦½ÅŸ­>Ê¡¨?^?¨ù½?á#Ê@ Â@(Æú@A‹t@Te@M»Ó@/ø@ ÄÜ?Àóù?TË&>ò±¿éç¿ ³§¿û-À*òÀXÁÎÀƒæŒÀ›UˆÀ³–FÀË…À㑈Àü |Á ÜÁeìÁ ”ÆÁ+™ŽÁ6vÁA”²ÁLþUÁXñ¾ÁecÁr 3Á~ºÔÁ…¿ÁŒMÁ’ä3Á‘þƒÁ‹“YÁ…SþÁ~ËÁrÁe¦ÁY£bÁN&wÁBÜ[Á7tBÁ+²ÁÛ6Á~2ÁAþÀñ ÆÀÕÿÿÀ»úÀ .QÀ†ÀX„îÀ&e&¿ëã‚¿Ìn¾ìê>??>x™?£. ?àOŽ@ so@)?@EÁ#@b)@z©¥@‡ç¿@‚Ôa@bÅ<@:d@ag?Æ•Š?ZÁ>!Nu¿ ý¿ å‚¿üfÀ-„éÀ\|ÖÀ†šHÀžæˆÀ·3âÀÐ{ˆÀé!QÁÌ1Á 9ãÁ®éÁ"Ÿ^Á-¦ëÁ8äžÁDÃÁQ'?Á]ÅéÁjiÐÁw:Á‚)àÁˆ¹ˆÁEÑÁŽ4vÁ‡›jÁ*ôÁuÒðÁi½Á]ù­ÁQˆ'ÁE˜Á:@8Á/ÍÁ#uIÁ³SÁ {ºÀüöºÀáŠIÀÅöYÀª.ÅÀBíÀhEfÀ2÷)¿þR”¿˜¶H¾ÞJŸ>“-¤?rÕÚ?Ê ™@Eö@(WQ@FuŠ@ci@~6í@x0@™ëb@¥?@m¾@‰ù«@iW@=}6@?ÉE?\äa> ÉÖ¿._¿¦ywÀwMÀ3<“ÀdZ2À‹%^À¤xGÀ½ÇØÀ×"éÀð9ÈÁ¢žÁâ;Á1ýÁ%r=Á1)aÁ=EgÁIŒ²ÁVòÁbïæÁp Á}.ºÁ…+Á‹}ÁŠÃCÁ„.ÁzÂÊÁmÙçÁaV™ÁUJÂÁI½^Á=Õ\Á2!äÁ&ÄÁkOÁÐÒÁÌÖÀí©AÀÒbäÀ¶¸XÀ›;À~*ÀFÕÀÀzP¿´Æ;¿6•>Vz€?y|f?ÙpÝ@1@=µ @`D@$¡@Ž/Ø@›çÆ@©ˆƒ@¶Ÿ¤@£Æ@¶Á@¡¡,@‹êž@k…Ç@>ò]@¹°?É÷?Z¾=ánI¿!Ó©¿²‰.À ýYÀ>°Àpê À’N–À¬uyÀÆ&7ÀßNŒÀöóÁ¶ÁbNÁ ÆÁ) {Á5QÁAÝ©ÁN»’Á[ï½Ái2lÁvoÁi<Á‡ûÔÁ‡}'Á€½8ÁtiÁf¶ÇÁYÊ™ÁMM…ÁAUÁ5ÕlÁ*TŸÁèþÁ’tÁæÀø8ÀÞ«ÀÃïÀ¨`UÀŒw\À`ĘÀ(v$¿àTx¿bód½'?MLü?͆™@‹}@G )@qZë@‹.n@›­6@ª±È@¹ @Æ;ã@Ó’D@ßPQ@Η @¹Õ@¢øD@Œ°Œ@l:G@? Z@V?§@?F5ã<3e…¿H¿Ê1£ÀÿIÀN Àk]À›ïbÀ¶r%ÀÏ”§Àç²PÀþ°3Á ÌçÁAzÁ!äÃÁ./ Á; .ÁHIZÁUgéÁb:ÅÁoPÁ|D©Á„¢¥Á„lÒÁ{8£ÁmнÁ`u9ÁS0jÁFHÿÁ9ÜÿÁ.ØÁ"™‹Á0²Á zÁækÀé«ëÀÐdÀ¶0.ÀšL&À|—ÝÀD¢ÃÀ os¿¦(x¾Ö?|>ïÁ?ªÈþ@ |@@ñ@rºú@®ò@¥Éó@·x–@ǽ@Õ¥ø@ã @ð.@ò ^@æG @Ð-À@¹çê@£]o@ŒÅ\@k[å@;›Î@ Ü?´ë8?õ[¾A/(¿ƒi¿ï.IÀ-J®Àd&PÀ-ÂÀ¨¹ÀÁÐ<ÀÙýÒÀñÍÁÈóÁ/ÁN[Á(Á4ùÏÁAúùÁNôÁ[ôžÁh£„ÁuK0Á(õÁÇuÁu¢ËÁgûQÁZ£÷ÁMtòÁ@XlÁ3ƒRÁ':BÁœäÁN›ÁûÀôüÀܪåÀàÀ¨ôÀ°WÀcu-À+¿â‰½¿_.Ç<™yî?jg‹?æGù@+÷s@cxå@Œ¯(@¦d)@½ØO@Ò9â@ã.Ä@ð¬_@ñH”@ñèg@ò„@ñð@@çð@л@º @¢Ñº@Šò@e’?@3rô?ÿõ]?–Õ.>©Ð^¿T¬¿²Š¾À(¯ÀG»ØÀ~`Àš]ÓÀ´“ÝÀÍLÀä„ÅÀûxõÁ {vÁ«—Á"8½Á/9gÁÔ¬)?ª[È@ZÂ@GèÏ@€œ÷@X@¸­—@Ó‘@ë¬@ï•@ð4â@ðÔµ@ñt‰@ñ‚&@ñ_â@ñ@P@çDº@Ïõ@¸;@ŸÊQ@†8X@Xdw@!ë(?×u9?P½©(Ú¿zò0¿îágÀ0X)ÀgýŠÀ‘“À©åJÀžßÀÚ¢Àñ´‹ÁJ#Áw[Á6ZÁ*ÈÁ6HýÁBwÂÁNû£Á[óKÁiKlÁvôcÁxòÁk™Á]©ÁP\ÝÁCl\Á6ATÁ)„•Á×FÁd%Á³>ÀòÀžÀÜvÀÄïµÀ¬»ðÀ’f^ÀmŸñÀ5ÒX¿úQ¯¿‡ð§¾æÅ?E¤¼?×€Î@&­Ü@a~L@{x@ªÊÄ@ÇÀ°@ä'û@îÖ@ïC·@ïÁ@ð`×@ñª@ðñÈ@ñ†@ñ6J@ñj@åŸ@̦@²Éâ@—»ƒ@x˜I@?~@·¡?˜ü>‹Ü ¿$k»¿Æª¸ÀÀT1ÝÀ…ƒdÀ ¢ßÀ¹b‹ÀÑ…ÑÀèBëÀÿ0›Á ´œÁÞÁ$UèÁ0šÁ<û‹ÁIÖÁW«Ád¾ Ár¨¥Át®DÁf–BÁX ÁK?uÁ>èÁ1O@Á$‚£ÁñâÁ ¡RÀÿJ»ÀèNÀÑÚjÀºÑÀ¢tEÀˆògÀ\ gÀ$ê¿ÕP>¿Dc¶>Æò?‡Ä[?ý=@:–'@vÁ@˜÷v@¶…ç@Ô:¡@î¾@îàµ@ïMÏ@ïºé@ð(@ð††@ðÈ @ðûä@ñ/¨@ñcl@ñ–ø@ÞÏ`@Ã.q@¥Ô@‡Þ‚@S6è@£v?¹L?Åõ¾ËÈ ¿¦ÿ–À ïÀFÀ|eõÀ˜g²À±¸1ÀÈîÔÀß<%ÀöªÁ&ÀÁk3ÁµØÁ,®Á8™$ÁE«òÁS"aÁ`êÁnöRÁqgÁcÁU ÁGJ&Á9ãÁ,í<Á 6‡ÁŽFÁuFÀ÷hºÀà2ÀÉiÐÀ²ž1ÀšŽ—À€Û‡ÀK£œÀ[.¿¶ô©¿o>ÀÙ@?§c@.@J³w@ƒsõ@¡ŽÆ@¿ª«@ÝÒÇ@î…!@îêÍ@ïWç@ïÅ@ðP@ïÖr@ð{è@ðõB@ñ)@ñ\Ê@ñ‹@é‚@Ê_ö@¬ ¢@Á%@^˜¾@"h?ÍîC?-Cm¾kֿзÀfÀ:,ÞÀp•ŠÀ’?ëÀ«+äÀÂRŸÀØMÄÀï^ ÁŸÁz×Áˆ¹Á'Ì\Á4›dÁAãõÁO޼Á]‰‹ÁkÆ&Áo'Á`¶`ÁRrÁDŽÕÁ6ô™Á)Å…ÁõÁ‚7Á3nÀð{ëÀغÔÀÁöOÀ«¸éÀ“!æÀt¥À>–íÀ¬4¿Ÿq¢¾¬ß??Àæ@Ç(@Wl¢@‰ö]@¨KÇ@Æ©Ë@åÐ@@îôå@ïaÿ@ïŽ`@ïV@ï&f@ïËd@ðsà@ñ[@ñV(@ñ‰ì@êup@Ìì@­Ëj@u<@b>£@&ð ?Øxv?F̾'¿ƒ²¹¿ô¢þÀ0s†ÀfÙ¥ÀÊÀ¦TÀ¼"ÀÑÐUÀéÃÁu%Á `(ÁSìÁ$É0Á1ÏÎÁ?JÁM!@Á[C²Ái£ÅÁm/Á^ã²ÁP×¥ÁCŽÁ5?5Á'±ÒÁ;Á ÁˆÁ‚vÀê¬ÀÓ7èÀ¼ÅÅÀ¥ì ÀÖÀiÆÀ4¬º¿üˆ¿Œ]h¾C6÷?89?Ñ“@$½Š@`Þ¥@ްt@¬ÿ@ËL @é³;@î‘ã@îþý@ïq@îß(@î¦ß@îvd@ïà@ïÃ\@ðk×@ñS@ñƒJ@çŠw@ɽ£@«úå@Ž•@aª`@&Ë×?ÙŒ·?K€½¸VX¿w¦ò¿ì!ŒÀ- ¯ÀbFÀŠUÀ¢ 6À·è×ÀÍAÔÀäuˆÀü6$Á üÚÁN±Á#'aÁ0iwÁ>1ÁKäüÁY¶ÁgÐÁk"oÁ\µ ÁNƒÁ@™sÁ3 EÁ%ÈOÁµßÁ Ü4Àÿ Àç%ÀÏ»ÐÀ¸ÒÕÀ¡Â=À‰Þ/Àb-¥À-kÁ¿ñ`«¿=½Ð²ð?OU½?Þ}@)ߪ@eô¯@‘Jæ@¯´_@Î/Í@ì}l@î›û@î @îh8@î76@î!@î ö@îª@ïNˆ@ïó @ð—@ñ<@àKÒ@ÄQ@§a@ŠŽ@[“@!Â?Òh˜?;ã¾û*¿Ö¿í?À*§aÀ^*À‡Þ8ÀŸ%xÀ´™eÀÊÀÀà >À÷V¹Áô³ÁÓSÁ"äÁ/ ‹Á&L@ýU?¦¤U>ê°¾ÄÌ'¿™Z2ÀÞÀ3p ÀcˆíÀˆŽHÀžâ¸À´ëüÀɇÀÞ’Àõ’ðÁ4`ÁNžÁ!–ÅÁ.¿ÛÁ<ÆÁI¦ÁWœwÁeÖðÁjñÁ\y:ÁN;OÁ@D>Á2š°Á%øÁ®¡Á —§ÀüWDÀä®ÀÍõÀ¶#ÀžàoÀ‡vùÀ^k¸À,Û¿ñt[¿…‹ä¾L ?+`òh¿ÃH¿°˜¿À JdÀ;«ÀjDÀ‹PêÀ Ü•À¶Á6ÀËÎoÀà§îÀ÷R²Áï1Áê)Á";ÉÁ/¿Á<æ‡ÁJy9ÁX`ãÁfŽ%Ák5÷Á\šÁN‰¿Á@˜]Á2ÿ)Á%ÎJÁßqÁ °ÀÿNÀæ”ÅÀÎûÇÀ¸?ÔÀ¡`MÀŠE6ÀdÏÀ3ŽhÀ[z¿™8U¾ÏâÇ>×RÍ?ž&l@‚@77Ú@jÃ<@Ž…—@¦Y@¼_Ì@ÍÖ1@ÜI£@ç€×@íc±@í®)@íøù@î79@íÊ@áÜ @ÐX@»¶`@¥¼¸@.>@o©@>‹^@ Á.?¸¯;?,5Ö½ÆÕK¿\uù¿ÑâÀ†lÀG¨5Àu™]À!ŒÀ¤ÿ»À¹ÏAÀÎéÀ㈫ÀúŠÁ IÁ4Á#RñÁ0qÐÁ= <ÁK%¯ÁY‡Ág$9ÁlkÁ^3—ÁPöÁB>âÁ4ÅyÁ'»9Áá¹ÁyÁÂ3Àë]‡ÀÔ À½bÀ¥Ì@ÀŽì ÀodÀ?%vÀI¿¼"ø¿1+·=·<ˆ?_£9?Ô.k@Û€@LÔ@zÂÄ@’y:@¤Áë@´0l@Á@^@ËIŸ@Ó@ØJo@Ú A@׋ÿ@ÐÞ]@Ç;â@¸l®@¦e@‘åì@yPF@Lf›@ã?ßê„?³z>·a¾ðÐJ¿›Ge¿ùWÁÀ+ÑÀWžÀZÔÀ–OÀªtSÀ¿)ÀÒ£èÀæÓ=ÀýR§Á ØŠÁ½ŒÁ$ô9Á28ÚÁ?oÁLù€ÁZ»FÁhÃ&Ánû¿Á`ÆÁRÑ`ÁE€Á7¶áÁ*ªÁÀØÁûßÁ}Àðë˜ÀÚYÀÃãÝÀ­HœÀ–sùÀ€ÇÀQÛ-À"7ì¿æ‹¿†¯¾œ]K>èµr?š?÷gK@( ª@R÷@w±@‹Õ1@šÝ@¥ý@¯z&@¶°@»6@¼}]@ºº@´Kž@«|@@ŸÏ @Ug@xuò@Q$À@&j?÷Õm?žu>?‘¾>ˆò¿f€Ž¿ÌãÀ6À@Àj«MÀ‰þÀøðÀ±.NÀÄϼÀØÿ®ÀíQ¡Á­”Á šðÁ,•Á'ZÁ4VÁAa@ÁOÁ\ôKÁk#öÁr:ÁdÛÁV ¿ÁHV¥Á;Á.[Á!’ Áz\ÁéäÀøHåÀâGÀËäwÀµÁÞÀŸÞæÀ‰ÄãÀfä_À9¹UÀ Mn¿»öQ¿>¸‘¼¬ þ?,R?­ž«?þó*@$Ö @FÉ@d¨ô@@Š®K@“qI@š ¥@ž#u@žÚÒ@œ­¢@—x0@çY@…~¦@nl@Kw^@&yg?ýBÓ?ªdÕ?,ñ…;À´¤¿/wZ¿¯žøÀ›¡À/ÀX³dÀ€®¬À”Z^À§zÀ¹ìòÀÌóíÀàØëÀõŸÁŽšÁwÁÍ€Á*(OÁ6ÃDÁCÕ­ÁQPLÁ_ @Ám6¡Áu½UÁg³…ÁYîøÁL}¬Á?gÖÁ2ˆÌÁ%¼4Á%Á þ@Á„2ÀìµÖÀÖ«¨ÀÀÒÀ«C£À•è¢À€,¬ÀTÑhÀ(¬Ÿ¿ùçn¿žð†¿á@=Ÿ"Ã?7hÚ?¦‚`?êL#@pg@1æ@IÔ^@^Lc@nß@z¹À@€ùÓ@—#@~»Ù@u/l@gZ@T.s@<"S@™?ó=s?§ê}?8JK=’⪿Ô=¿œí¿ïYAÀ"È™ÀLAÀt¼7À¨À /ùÀ²EöÀÄkÀÖgºÀé¦GÀþ^éÁ ìØÁ‘ÇÁ!‰DÁ-çÙÁ:›EÁG‹ÏÁTÊGÁbcõÁpI\Áz)qÁlbçÁ^ã<ÁQˆ5ÁDO‚Á7rÞÁ+±ÁÏÁ¯“Á5vÀø:2ÀâÁÀÍ9À¸sWÀ£›ÐÀޏ‰Àr»ÝÀHVNÀ!n¿éÇ8¿–Í¿g¶<”¦#?ÑÞ?‡…ó?Ã,?øg–@—2@&›h@5î„@AS¶@Gœs@H¼q@Dn@;®Ç@.·Ö@}@çt?Ø(¤?—Ì„? ê5=^rf¿ °¿’ì]¿åÊdÀ©‹ÀB”šÀkð·À‰PÀ›¯ À­ÂÀ¾§WÀÏóýÀâ$"ÀõÿÁ9oÁŸYÁûâÁ&²Á26êÁ>ܪÁKöGÁYEÀÁf¸vÁt^ëÁ€6ÁqÙÑÁdFêÁVòJÁJüÁ=‡ZÁ1<Á${ÒÁw®Á >gÁéæÀð$ÊÀÛu ÀÇ4ÊÀ²¾½ÀžyjÀŠ*ÖÀk? ÀC…~À±¿êvö¿ 4‚¿5N¾Kž>ž?8rÿ?ŽÁ?º†?Þ¤â?û" @)©@ §b@,Ã@ ®Ü@ÿF?ìo?Ìp¦?¤Ì‰?h¡§>ãs¥½’‡Ê¿ j¿˜qK¿âB¶ÀSÈÀ?×™ÀeÚÇÀ…×JÀ˜ý»ÀªŒ«À»b©ÀÌÄÀÝ!SÀî˜cÁ“Á ‡³Á«ZÁ™ÖÁ+TÁÁ7¤«ÁDÁPßÁ^¶ÁkŸ4ÁyMÒÁ‚äÁwœÁjIPÁ]QlÁPÅVÁC×ÖÁ7Á*âaÁYüÁ–…Á ÀÿdSÀêéYÀÖ­1ÀÃ@fÀ¯±úÀœÞÀˆ–6Àjf·ÀE}¦À Ö}¿ük¿º°p¿xkD¿ãy½ÀÜÇ>%Ç?_?]¹.?Š,Ä??§Nµ?¨ò?Ÿ%7? :?sס?9¼Ó>â‚û=¯´õ¾«T©¿O¾^¿§;†¿íDÀQíÀ? tÀc.À„¤À—7:À©ºÀ¹ü˜ÀÊ%ÀÚˆ‡ÀëJ„ÀýµÁÇhÁ¸ÖÁ *Á&’&Á1ׇÁ=Ë,ÁJDÁVÙ?Ácµ½ÁpòŽÁ~€ªÁ…ºÕÁ~+qÁq5…ÁdÁWNçÁJ„RÁ>6;Á2~dÁ'pDÁ›•Áï¬ÁêŠÀü 3Àèk•ÀÔÚŸÀÁÓÊÀ¯0CÀœ€KÀŠ?·Àp¨#ÀNJºÀ-1À ÿߪ ¿¨„a¿jlÄ¿M¾„§ê»taÇ>Gï>§÷[>ÌTÜ>Ì«J>«AÒ>`Ì={Šè¾ p¾Ï›a¿>“‰¿޿ƦÂÀ@jÀ"W­ÀC´ÛÀf§#À„ÀTÀ–.ÉÀ¨üoÀ¹dÀÊòÀÚ]ŠÀêjÎÀûî–Á«Á!IÁÐÁ$+JÁ.¶&Á9‚ÁDþ¹ÁQ‹Á]¡ÌÁjL\Áw.êÁ‚4þÁ‰=:Á‚ÅÌÁx€‡ÁkVðÁ^ŒŸÁR2öÁF_Á; ¶Á04Á%_ÁÄ5Á¾|ÁîÐÀúS‰ÀçrÀÔåÀÂåtÀ±9<ÀŸÕ)ÀŽª¬À|ªœÀ\°ßÀ>Ø­À!ÚJÀü†¿ß6¿´Y9¿Âl¿aÿî¿0¿@r¿H¿>W¿x=¿.û¿S ¿ƒ-¿¡ù ¿È?׿õ“ ÀQÀ1+UÀO?Ào³À‡þÀ˜ªçÀ©¨µÀºè0ÀËUãÀÛMXÀêÜûÀú­ÁåÁYmÁŒKÁ"VéÁ,îÁ7„±ÁB,¿ÁM1”ÁXÑ’ÁdøÙÁqÁ~F3Á…“ºÁ‚Á†ubÁÍæÁs £Áf¬°ÁZÈ“ÁOj¿ÁDÃÁ8è,Á.&íÁ#ã ÁØ/ÁÁžãÀû©Àé!ÍÀ׈½ÀÆš¦ÀµÊ•À¥ÆÚÀ•Ò¦À†ÁHÀo¯¨ÀU@™À;˜‹À%)ˆÀx¼¿ýÖ¿àŸB¿Ék¢¿¹o¿³±Õ¿´D|¿¼dY¿Ég#¿Û4µ¿òëüÀÊhÀ§tÀ.¬ÔÀFeßÀ`ínÀ|¾¡ÀJ¨Àz À¬ØDÀ½oYÀÍÉqÀݶýÀì 1Àû¹$ÁñcÁGYÁ’Á!fMÁ*˜•Á4µêÁ?¡ÁK&rÁVaÁak¨Ám% ÁyU‡Á‚öýÁ‰TuÁÓúÁŠLZÁƒîÁ{~}ÁoŽÏÁc¥¹ÁXÞÁLÜŸÁAÆ Á7LÁ-eTÁ#zšÁÒ’Á±‚Á­ ÀýÂÒÀí“À܇ëÀÌs¬À¼øÀ­·EÀŸÝÀ‘-ùÀ„)ƒÀp>RÀZ¹ÀFãÜÀ6¬ŠÀ(Q²ÀÎÀJÀDÀÛ¯À!¬À¨À&’‘À1~eÀ?+ÀO¦ŸÀbêþÀy~ÀˆG©À•À¢À¤ ™À²qÓÀÁÊcÀÐÏ#Àà¥îÀð™±ÀþÔ³Á-wÁQDÁÒ>Á ŸbÁ*jÁÁ3ÝÁ={áÁGìuÁS¥Á^Ê©ÁjN¯ÁuîPÁ€ìZÁ‡LÁQ©Á”¼KÁŽ_úÁˆ/ÃÁ‚­Áx$ãÁl€ºÁa ˜ÁUÀÁK ÁAÞÁ7&yÁ-.Á#÷ÎÁø“ÁÔÁ ¥ÁzýÀó(ÏÀãh©ÀÔ{ÀÅÒ4À·¼äÀª¥÷ÀžuÀ’{ÕÀˆyÓÀ}¢—ÀméaÀ` 0ÀVïÀOš:ÀLÜÀMÆÀQªŸÀW$èÀ_|?Ài’ÁÀuð¤À‚ÃÀ‹ŸÀ•éÀ¡1÷À­”µÀº®µÀÈhDÀÖ¿ÅÀåÕ«ÀôžÁêÁ pkÁøWÁ_úÁ!ýÔÁ*²“Á3ñÆÁ>-ÁG(}ÁQ’Á[É¥Ág\Árä¾Á~Û‘Á…P<Á‹]ÕÁ‘‡~Á˜Ü€Á’¬ÁŒŠ Á†}ÇÁ€ ZÁu ëÁj4CÁ_TÁUzÁKW|ÁAàÁ7†ÃÁ.±-Á%°XÁ¿”Á¨ªÁ ·fÁõLÀúÇ{Àì\ÀÞW´ÀÐПÀÄ”À¸iÀ­$ûÀ£_ÒÀšmUÀ’…ÚÀŒ^`À‡âÜÀ„š}ÀƒB•ÀƒÓÊÀ…›=Àˆ]ÀŒ,ßÀ¿šÀ–Ò|À²ëÀ¥öþÀ¯[•Àº".ÀÅrgÀÒ1­ÀÞâÛÀìÒKÀû"†Á'~Á T‚Áâ(ÁŒ¤Á#ÆÁ,—¶Á5q]Á>W‡ÁGöÁQ›ÒÁ[rÁeLÆÁp$"Á{ˆ’Áƒ³åÁ‰ØöÁÄíÁ•ÝÈÁBãÁ—NÁ‘ oÁ‹#´Á…CÉÁÁtSÁiœKÁ_Ú&ÁUm~ÁKŸBÁB£Á9ñ Á0­gÁ(%pÁê±Á ÁÁrƒÁ OøÁTýÀ÷€Àê1œÀÝêyÀÒ~PÀÈ_À¾elÀµö?À®™ÃÀ¨~©À¤bÀ¡~†À 0æÀ ²iÀ¢yÌÀ¥!À¨iUÀ¬îÀ±ÊµÀ¸‘&ÀÀŒ$ÀÉwñÀÓK‘ÀÝÄGÀéøqÀöQ(Á‹¹ÁµàÁ(éÁ&ÃÁ­ÕÁ&‚SÁ.³~Á7l®Á@†€ÁIrAÁR•þÁ\{¨Áe¿ïÁoÁyç6Á‚oMÁˆ*ÚÁމÁ”C—ÁšX›Á¡À†Á›´qÁ•ÂûÁ×9ÁŠÐÁ„…©Á~{Át‚Áj<èÁ`3eÁVã$ÁNÆÁE\ÁÁR5Á=²Á •WÁuiÁªcÁ|·Àþ'ÑÀúB#À÷öÀ÷K/À÷^æÀøäÙÀúØ/Àýï_ÁEÁÅdÁ†‰Áe.Á ÐÁ€ÁrÁN>Á£¤Á%¿#Á,?ôÁ2ý%Á9ØiÁAxŸÁIqyÁQ–:ÁYÖ&Áb³ Ákº¥ÁtÙ#Á~QÕÁƒÛâÁˆ¼#ÁO–Á’.†Á—Q§Áœ²FÁ¢JFÁ¨ Áýá4Á÷Œ0ÁñA‡Áë ûÁäÝïÁÞ»/Áذ—ÁÒ§ËÁÌœœÁÆ¢OÁÀÍ+Á»CÁµ]Á¯»+Áª-ìÁ¤Ä9ÁŸc?Áš+§Á•39Á€xÁŒ ˜Á‡¤ìÁƒjXÁëÁx'ÝÁr…ÁlX¾Ág<èÁc$ÂÁ_ù+Á]!5Á[R­ÁZ„uÁYá]ÁZ:Á[jfÁ])zÁ_¸™Áca@ÁgèRÁlÕ¨Ár†ÁxšlÁhXÁƒXÁ‡¦oÁ‹çCÁbOÁ•(ÒÁš3ÈÁŸt0Á¤¸ŽÁªÐÁ¯ÉÁµ)×ÁºøîÁÀÎÇÁÆ·ZĄ́¬ÁÒ¸ÍÁØäÐÁßÁåV4Áë¡ìÁñèOÁùZUÁóÁÁì¬@Áæ^ Áà$yÁÙï¢ÁÓÈæÁ;ÅÁǸ ÁÁ© Á»¬]ÁµÖáÁ°˜Áª^Á¤Æ‘ÁŸ9nÁ™Ñ$Á”t·ÁI’ÁŠcxÁ…ÉþÁe˜ÁzBÁqð;Áj›–Ád*SÁ^hDÁXþ¼ÁT kÁQWtÁNo)ÁLfÁK¦oÁJýôÁK3yÁL™sÁN^NÁQÌÁU_ÁY{ªÁ^¸Ád„˜ÁjмÁrúÁz¸ÁGäÁ…¨äÁŠWÀÁQÔÁ”ˆAÁ™Í;ÁŸÕÁ¤‡}Áª.½Á¯ü ÁµÐ”Á»¾xÁÁ´UÁÇÇÁÍøÚÁÔ1&ÁÚtÁà½þÁç ^Áí_¯Áôê¸Áî|–Áè#BÁáÒ1ÁÛ…½ÁÕF«ÁÏ ¾ÁÈá ÁÂÑHÁ¼È`Á¶¾Á°ÁÐÁªê%Á¥¦ÁŸgEÁ™ÓÓÁ”IeÁŽèéÁ‰•þÁ„yöÁTÁv[ÉÁm©•Áe$+Á]c'ÁVŒZÁP¢fÁKÁFV‡ÁBÝÁ?ò‹Á=ÜøÁ<÷ÁÁgιÁ][lÁSðÁIj­Á@Ž-Á7üÁ/ä,Á(ÝÁ"ðÁi&ÁiÁë±Á‹ÁäÁ„sÁõ:Á[ÏÁ¯\Á¶âÁÚ Á"K»Á(&&Á/'æÁ7K…Á@1ÙÁIfÁRûÁ\ù.Ág¡>ÁrŽ(Á}°äÁ„“?ÁŠ\kÁXÁ–iæÁœ‰ûÁ¢Ñ Á©#$Á¯`NÁµžéÁ»÷ŠÁÂkÑÁÈæÈÁÏZ0ÁÕÙ²ÁÜf,ÁähEÁݹ¸Á×ÁÐyeÁÉúÁÃ}ÎÁ½zÁ¶´¦Á°\eÁª8Á£îDÁÂTÁ—šÃÁ‘zDÁ‹€æÁ…£¾Á{OÁs¿ðÁhpÏÁ]víÁR§ÊÁH_)Á>JÎÁ4èUÁ,Á#½ÁÁêrÁ@áÁ ·Á3 Á»sÁ PÁ±ÊÁ—ÁŒ·Á+áÁ 2iÁ¹UÁ?wÁv‘Á#$Á+vðÁ4táÁ>ÑÁGÑkÁRUÖÁ]Y£ÁhzÉÁs܈ÁbíÁ…¬üÁ‹Ç%Á‘ë{Á˜-ÝÁžyËÁ¤¹ÜÁ«Á±^’Á·Ö5Á¾LÃÁĽ'ÁË@¢ÁÑÙÅÁØl°Áà—ÃÁÙåÂÁÓ2ëÁÌ‚ÁÅå]Á¿b¾Á¸çõÁ²u%Á¬eÁ¥¶ÁŸqJÁ™cÁ>ªÁ‡dÁ—Á“Ú"Áš'1Á zÖÁ¦ÖÌÁ­CáÁ³¹PÁº2_ÁÀ¼ ÁÇ]"ÁÍçÁÔzÁÜËÁÖÁÏlÓÁÈÁ·Á *Á»gVÁ´ß±Á®gPÁ§òBÁ¡ŒÁ›'´Á”ÞEÁŽ¡]ÁˆnÁ‚\gÁx§ëÁl®HÁ`¿ÄÁU õÁI»Á>¢áÁ3Ç Á)áÁ€ÁO]Á c·Á@ãÀùñÿÀî~ÀãwÀÜCÀÖŠªÀÔ ÀÒåBÀÓ-jÀÖÍÀÚÌýÀãY<ÀíQÀù–HÁÐÁ ¨hÁÇoÁ©gÁ(ÆYÁ3urÁ>}ÁIäÊÁU‚‘Áa]kÁmzÁyÇÈÁƒÅÁ‰SîÁ®ÎÁ– ÁœXYÁ¢¾¦Á©=]Á¯¿íÁ¶HÂÁ¼Þ6ÁÃsBÁÊ ÐÁЮåÁÙ‚ÁÒZLÁ˧aÁÄûzÁ¾]6Á·«jÁ±ÁªqzÁ£öèÁ|éÁ—Á²ßÁŠh¦Á„$$Á{ÙuÁo»!ÁcªgÁW¶lÁKÙ Á@8’Á5 “Á)ë÷Á8Á}*Á ÅÁh`ÀòBÐÀ㙽À׳ÀËïÔÀÄKãÀ¾vÀ»+öÀ¹\À»¤À½¤ÀÁæ·ÀÊÉÀÕ¸Àâ¢ÀðêšÁô)Á «ÃÁ´ÎÁõÞÁ)²*Á5+JÁ@óÝÁL°MÁX•TÁdäQÁqOjÁ}ÜÁÁ…VåÁ‹©ÎÁ‘ë°Á˜V1ÁžÝùÁ¥]‘Á«Û Á²p Á¹“Á¿§ÁÆD8ÁÌú<ÁÕ‹?ÁκJÁÇÿ„ÁÁMhÁºâÁ³ø”Á­S„Á¦®2Á  ËÁ™‡NÁ“ ‚ÁŒ›µÁ†M:Á€ éÁsÒÁg$ýÁZöÁNÐÁBú<Á7P"Á+×XÁ •XÁ~Á á~Áš£Àî° ÀÝÀÎ'6ÀÀgÀµÅÀ­-À§&¯À£oÊÀ¡×YÀ£<‘À¥Ê-À«_“À³ÒµÀ¿ÎÀÍãÀÜm"ÀîH<ÁÇ[Á ùYÁoøÁ ÄZÁ,r~Á83(ÁD jÁPZ–Á\ÕÆÁihÊÁv7ðÁ[Á‡£"ÁŽæÁ”–ñÁ›~Á¡~)Á¨`Á®ÉÚÁµO±Á»òÃÁ°ÁÉ{ÞÁÒ1£ÁËV@ÁÄ¡Á½¾Á· üÁ°^Á©±›Á£—Áœ`ÁÁ•»½Á.ÍÁˆ¸oÁ‚FGÁwðÁklÁ^ûtÁRÇîÁFÿÁ:_%Á.«²Á#D#Áë•Á §#ÁÌ`ÀïŸÀÛ’žÀÊeIÀºGÀ«]AÀ /À—5À‘lUÀŽ ÀïÀ| À‘_eÀ–·-ÀŸSÀª+»À¹PÀÉ¢¡ÀÛ--ÀïO Áö}Á µÁg…Á$%¶Á0—ÁƒaÁ2`–Á&ušÁåÁÁrDÁ=ˆÀò÷žÀÞr‹ÀÊârÀ¸•¿À§^±À™.À{…À„©OÀ}‘ÀuÑÜÀri^ÀuhÀ{;©Àƒ($À‹Þ›À—>†À§TcÀ·ò£ÀÊÓÀßRjÀôt<Á-ÁɈÁ¦ÅÁ(·Á5{ÁA> ÁMÐæÁZz·ÁgøÁs¶½Á€?RÁ†²¾Á4Á“ÓgÁšlSÁ¡2Á§¥ÓÁ®\üÁµ0Á»ã)Á²nÁËñÉÁÄøCÁ¾²Á·;ÍÁ°mBÁ©šôÁ¢ÚÕÁœ.òÁ•›ÁŽÜ4Áˆ7zÁ”ÄÁvYÁi&…Á\_7ÁOÁ8ÁC2äÁ6ÓÚÁ*¦åÁ“(ÁÁºÏÀø”ËÀã Àμ•ÀºÕjÀ§ÂÆÀ—GEÀˆíÀ{¿öÀgGhÀ[Ù²ÀTh/ÀR¾ùÀSðtÀZâèÀg÷Ày¯Àˆ–À—À¨BµÀ»êµÀÐooÀæ#âÀü–Á ±åÁ`·Á!›ŸÁ-ÜqÁ:C6ÁFÀNÁSTïÁ_òýÁl¸ÄÁy§EÁƒC1Á‰Ï‹ÁrŽÁ–þ’Á”öÁ¤JõÁ«6Á±ã¥Á¸ª°Á¿‚ÞÁÉ ýÁÂØÁ»"½Á´5=Á­VèÁ¦„ÁŸª/Á˜ÛÁÁ’,Á‹‹Á„òIÁ|¬-ÁoqÑÁbn;ÁU^ÁHØ·ÁÁYåÁf$)ÁrÙ[Áí$Á† –ÁdÁ“ª”ÁšdÊÁ¡:#Á§îÊÁ®±ÛÁµŽ³Á¼‚€ÁÆ[ŒÁ¿PMÁ¸S—Á±aÜÁªs‚Á£†#ÁœªšÁ•ÙÉÁ ðÁˆZ8Á¾RÁvFÁi›Á[äÁNü3ÁB!dÁ5~¹Á).ÁØŸÁþ-Á"JÀó•ÀÝ#UÀÇÀ³ZÀ tÀŽ«ÒÀ~3Àa–ÝÀLªËÀ;ÕÀ1HùÀ*~6À(XÀ(Ø–À0ÑêÀ:ÄuÀKz"Àcß»À€¼À‘Â’À¤TÀ¸/cÀÍÁ=À㤾Àúà_ÁÏìÁÂQÁ!:ÁÁ-c}Á9ñ|ÁFÑïÁS Á_³ÑÁl·<ÁyË—Áƒ_0Á‰÷OÁ²vÁ—qpÁž!Á¤ãëÁ«Å¨Á²¿<Á¹È°ÁÃÞ Á¼ÅÿÁµ²¨Á®£îÁ§§¦Á ¿;Á™ÜAÁ“ÁŒ:sÁ…zKÁ}…Áp`«Ác4+ÁV ÁHê,Á<Á/^ŸÁ"ÜíÁº~Á ÅÀþ&BÀç.ÅÀÑwýÀ¼þÀ¨ËOÀ– ;À„í¾ÀlëÀSæèÀ@V–À1QGÀ'¶NÀ!ÿÀöðÀ Ô`À&/À0×EÀ@——ÀV2ôÀq%­Àˆ¸À› –À®ÖÀÑûÀÙ6‚ÀïEÁOcÁ|XÁ/xÁ'†lÁ42Á@¨YÁMiÁYÉLÁfÎEÁsáÁ€xmÁ‡ÅÁÎ×Á”öÁ›JŽÁ¢/‹Á©-uÁ°>ÍÁ·LÇÁÁuJÁºMSÁ³7UÁ¬)&Á¥Áž±Á—5¦ÁbAÁ‰•pÁ‚ÖÿÁxTÁk·Á]àÑÁPÐÉÁC½ÄÁ6ÁÁ*GÁžÛÁ[½Á•ÁÀó¿‰ÀÜüˆÀÇ­)À²£äÀŸ§{ÀÔ|À|ZÖÀa"ÀJ¾êÀ9=À,˜÷À$Ý%À­ÆÀ$ÎÀàÀ#"çÀ,uEÀ9™|ÀN¿íÀf½ÏÀƒ3À”0ëÀ§&À»Ò1ÀÐYÀåðªÀý0ÊÁ 6]Áó!Á"$-Á.ÔŽÁ:ÚÁGfaÁTi{Áa]£Án3Á{f>Á„l%Á‹("Á‘ð&Á˜ÕóÁŸÖÁ¦èÁ­Ô9Á´ÕLÁ¿NsÁ¸œÁ°ìRÁ©ÒðÁ¢ÌåÁ›ÍÁ”ÑSÁêÁ‡!|Á€iùÁsiOÁf ‚ÁX°çÁK¢ÅÁ>²Á1Ò}Á%F“ÁßdÁ “ïÁxhÀéßáÀÓuSÀ¾üÀªx²À˜}lÀ‡‹ÿÀrÉÀZ"gÀEÒVÀ7SùÀ,øjÀ%øØÀ"~ÄÀ! wÀ!Œ*À$àÀ, ýÀ89bÀIÚ5À`œÀ{ÚûÀ9€À ôýÀ´UÀÈ9ÈÀÞ.ÀôÒ³ÁˆlÁH3Á» Á)¤ÅÁ5øÎÁBÍÁOe%Á\lÁi=/Áv¯áÁ‚“ÁˆßûÁ¼¡Á–±+Á£ Á¤”“Á«–ÐÁ²®^Á½G¶Á¶ÔÁ®îÁ§È\Á ­¦Á™©dÁ’¹Á‹Ï!Á„îŽÁ|K“ÁnÄmÁaRÞÁTTÁFñ•Á:ÙÁ-KoÁ ©”ÁbMÁ7sÀøÛðÀáÞ^À̇ûÀ¸^ÀÀ¥G¡À”-ÀƒúÓÀmb½ÀVø&ÀDù4À7èkÀ/ÚÀ)øšÀ&êFÀ%`ÕÀ%¥§À(I À.ô2À9‡3ÀIZ À^„Àw¼ïÀ‹4ZÀ›êôÀ¯O:ÀÃ^À×½ÀíÃÎÁÞ1Á ‚ZÁžiÁ%~6Á1ÍZÁ>WñÁJñÁWì’ÁeIÂÁr¬ ÁóÁ†Á>Á©“Á”¡¯Á›šdÁ¢›]Á©±2Á°Ò-Á»„CÁ´CyÁ­ŠÁ¥õÔÁžá*Á—ÒúÁÒJÁ‰ëpÁƒ Áxa³ÁjËÀÁ]R—ÁOÿöÁC?Á683Á)ž Á9°ÁýVÁ@ÀòðåÀÜèÏÀǵÖÀ³¹ÁÀ¡!À°“À‚XÙÀlPâÀWãùÀG«sÀ;¢À3yYÀ.wÀ+ÊÀ)CrÀ)µ½À,‘ÝÀ2g¹À<ŽÀJ·À^+¿ÀuÑüÀ‰ÕÀ˜øÀ«ýÀ¾/@ÀÒ4pÀçÎúÀý™ZÁ iZÁûïÁ!Õ‚Á.E"Á:Ð+ÁGqIÁTzÁa‹=Án³Á|,”Á„ö­Á‹ñ^Á’ïÁ™ånÁ å]Á§òÓÁ¯ÜÁ¹ú"Á²¼êÁ«„ÑÁ¤VÜÁ<ýÁ–9®ÁBÚÁˆMÁc8Át÷xÁg>­ÁYÎ ÁL¬¸Á?¾ìÁ3 Á&©`ÁBÁ1ÚÁfÀî ÀØpªÀÃÉ'À±†ÀŸ©$ÀSøÀ‚qÙÀn‚ÀZ0™ÀK/¥À?TšÀ7,ÂÀ0rÀ+EyÀ(¼WÀ)EöÀ-z•À5:rÀ>ò²ÀM¥qÀ`3sÀv\õÀˆËìÀ—ããÀ¨Œ!À»OÀΚ ÀãgcÀø˜¦ÁŽrÁþÙÁÅaÁ+!4Á72ÁDFÃÁQVXÁ^k…ÁkºÜÁyWZÁƒšƒÁІÁ‘f­Á˜SHÁŸYŸÁ¦v€Á­§'Á¸™^Á±[XÁª-ãÁ£ ÍÁ›í©Á”Ü£ÁÞhÁ†â£ÁÒ9ÁrÁd…îÁW¬ÁIÞ´Á= Á09Á#ý0Á¿Á ÜÁt—ÀêÎ?ÀÖèÀ„ýÀ°NêÀŸn6À‘'ŒÀ„ÈÀqdÀ^þ‘ÀNŠŠÀ@ö À5qxÀ+vVÀ$}wÀ!G6À#! À(< À2ötÀ?ÚìÀO¬DÀb€«ÀxƒUÀˆæ¥À—ßqÀ§ÉÃÀ¹å¾ÀÌÒÆÀà¸äÀõ¥jÁÁçÁÝ»Á¨Á(óÁ5d•ÁAü~ÁNÐÁ[×4Ái.ŽÁvÖÜÁ‚RÁ‰8ÖÁ ¦Á— Áž0IÁ¥TëÁ¬ËÁ·ŒÝÁ°CÏÁ© MÁ¡åŽÁšÔÞÁ“Ì~ÁŒÄ,Á…ýÁ}¥ÂÁoäÁbPÁU[ÁH!Á;FKÁ.¤±Á"#UÁûÁ —Àÿ.ëÀéÕÏÀÕS%ÀÂÚÀ±!YÀ úšÀ“ðÀ†CrÀuaQÀ`õÓÀLƒìÀ9ú0À)¹jÀ†ÀþÀ`€Àw®ÀöúÀ(ŒåÀ8îsÀM‰Àbk?ÀzWÃÀŠåÀ˜^ÎÀ¨ÔüÀ¹£üÀÌâÀÞýòÀóÒjÁ²iÁwÁMÁ'Z™Á3¼Á@(úÁLÎÚÁYåÁgY-Áu‹Át¿ÁˆB$Á.Á–5ƒÁMÜÁ¤fÁÁ«ˆÁ³SÁ­x Á§n"Á¡÷Á™ÿ0Á’ó®Á‹èdÁ„àFÁ{ãÁnK Á`íwÁSÅ.ÁFÝñÁ::Á-V‡Á! ¢Á`6Á 3ÏÀþc1ÀéL^ÀÖÈÀÃÅÀ²ÐëÀ£nÀ•FÀ‡áÍÀtRêÀWthÀ0öÀZ÷—Àwæ¨ÀŠ‹À™÷ÎÀªÇÀº½ÀÍ)ÀßSÿÀópÍÁ{(ÁF¥ÁÆÎÁ&ß;Á3æÁ?1nÁKÒøÁXàˆÁfEŸÁsÂÁ€ jÁ‡wiÁŽm]Á•}XÁœ”ÄÁ£¬QÁªÉ¹Á®— Á¨²>Á¢âÀÁœçiÁ— Á‘e¡Á‹N¿Á„[ñÁzöÁm^Á`¬ÁS2ÁFYžÁ9¢uÁ-#™Á!ïÁ„÷Á rIÀÿ×Àë;:ÀØIñÀÆLýÀµ|QÀ¥ž9À•cÀ‚?ZÀ_çeÀ<ŸßÀÕ¼¿ýÍ+¿Í¼C¿£ô¿Še›¿}Å¿…{Ö¿›’ë¿Æ˜Ë¿þg›ÀÄÀClkÀi›À‡ÐŠÀ™ä=À«„ÙÀ½J*ÀÏïÀáºÀõBsÁ)¤ÁÃÉÁ Á&ÍÄÁ2¨-Á>»7ÁKS¦ÁX_bÁe¹Ás/Á€HnÁ‡#QÁŽeÁ•+ýÁœ>3Á£PÉÁ©ÁÁ©âÄÁ£ñPÁž5Á˜OÃÁ’lêÁŒ¨éÁ‡ÝÁ8öÁuQ)ÁgÑ*ÁZs`ÁMV¥Á@?Á3¬FÁ'!ÁýúÁÁmŸÀñ ÀÛÇ Àlj.Àµ ¬À¢²ïÀ’RÀN{À`ïÀ<…¼À¿â—Û¿¤<ž¿\ÿ ¿òξd†}½Þ°4¾`"¾Î¿FÖ ¿¡Å¸¿êÌ´ÀõÃÀJ…ŒÀxŸ¸À“_ À«—$À¾é‡ÀÒ£ÀäøéÀø•÷ÁfoÁ)æÁ2€Á'¤ÊÁ3j»Á?y5ÁKüúÁXïÜÁeéJÁröÁ€,ÃÁ‡¥Á'ÃÁ“žÁ™ §ÁŸ RÁ¥WÁÁ¥eÁŸI‹Á™Z“Á“ŽÉÁÆÁ‡ÿÐÁ‚HÔÁyÁlÝûÁ_aËÁQÑóÁDZ@Á7“Á*&‹ÁSJÁ¡öÁrÀñÀÙ¤qÀÃÚvÀ®žÀšìªÀˆpÌÀmkÆÀL QÀ*õcÀ Œq¿Í翈ÂÞ¿ ? ½á>¬¢¥?"щ?Fv²?A…4>ïed<ø†¿5O¿‘&ß¿ç©À!q;ÀOÃëÀ~†iÀ–•À­µ­ÀÄã5ÀÛÿGÀóµ-Á·ôÁÃpÁÛÁ)ÆÁ4בÁ@ÎÁMfÁY®»Ád®žÁo2øÁzÁ‚êÁˆ˜þÁŽ‚ÁÁ”™•Áš×¿Á¡cÁ¡- ÁšçÁ”ËKÁŽßpÁ‰æÁƒ]ÍÁ{BÎÁoÏÁcùÅÁWóÁIrmÁ;ÙtÁ.YaÁ é%ÁÑWÁú•Àô]‘ÀÛÌdÀÃñøÀ¬máÀ–°áÀxÂÀ\¥žÀ7­ÙÀ¨&¿èû¿§4u¿H_é¾|à©>Žï0?B˜ü?—tß?Æ ?Ü3#?Ñ¿ ?§Å‡?PuÛ>R\i¾çs¿“[¿ì‰îÀ$Û"ÀSr¾À€¶îÀ—¹ÿÀ®ÚÀÆ fÀÞH"Àöx°Áš¿ÁÓlÁ yTÁ-)ÅÁ9±JÁE>ÈÁP<¹ÁZ÷ÁeÃoÁq<Á||HÁ„*ÁŠ2·ÁuËÁ–Ä–ÁŸÁøÁ–ЉÁˆ ÁŠn&Á„‡aÁ}ºÁr<·ÁfºÁ[ ÎÁO%kÁAl¡Á3“ Á%êÁZ*Á àÏÀû jÀáDÀÇ@À®´¥À–ÒÛÀ~d<ÀS™À(Ô¹Àqß¿½p¿vh¾åA+=‚(t?ÈL?ŠR­?ʲ8@dh@ŠÐ@+‚\@#ÿ¥@ ûS?Ê•?pvK>~jþçe‹¿–[l¿òÊøÀ'B(ÀU!•À´îÀ™jÒÀ± [ÀÉs’Àâ°Àú¬7Á +Á Á#ÍêÁ0TåÁ;®NÁG \ÁQÖ§Á\ÞMÁh˜ÁsÂÖÁæúÁ†8àÁŒYÁ’æ Á™P]Á˜µêÁ’–ÁŒ™‰Á†QTÁ€:#Át¶•ÁichÁ^'wÁR|òÁF¬äÁ9öcÁ+û3ÁèÌÁ©ÁaÁÀéÃ/Àη•À´ tÀšëØÀœòÀSg}À#칿ñvß¿žiý¿(ø~½Þ}>ÓÑ|?kò?¶Ø?ø÷@ý@8º2@Si@fo@]g1@=LŸ@Ku?Ó“?q®,>gû^¾øßq¿™ñ4¿õ­êÀ) þÀXjzÀƒø•ÀœnÛÀ´ýâÀÍÏ3ÀçÎ%ÁÉÉÁ ’Á•âÁ'[ÔÁ2ë#Á=ýèÁI7ÁT$@Á_µýÁkÌ}Áx?Á‚mkÁˆ½cÁ*æÁ•¸Á”©ŠÁŽ].Áˆ>“Á‚T)Áx•|ÁlsÔÁ`Î<ÁUæÁJJ:Á>“öÁ2zƒÁ$œŽÁžØÁ†!Àô´|ÀØêàÀ½ÄÀÀ¢µ†À‡ýýÀ\jÀ)8Í¿òRˆ¿’ê…¾óB1>àõ?;Ö?¡Ø?ä\þ@mz@1ç¢@Q×@nÇO@…§]@‘¼@‰ËÎ@mÉ@Bó¿@ ä?ÐŒ8?l¢p>U<¿6±¿êù¿ûþ¢À-¡žÀ^ÔHÀ‡âÀ¡%À»+7ÀÔò}ÀîêãÁØ—ÁÜÁÙ;Á*)úÁ5Œ.Á@ÅÁL37ÁX#;ÁdOWÁp—üÁ})¤Á…Á‹”ôÁ’(¦ÁñYÁŠy¶Á„- Á|#–Áp^üÁdÒ"ÁXåtÁMk¦ÁB+Á6˜þÁ*ÓÀÁñÁuÁH®Àæf–ÀʦÀ­›™À‘ÔÀmx?À7BáÀ‡ÇP?o«Ž?Æc5@ÀN@)]@I&'@i#r@„b†@’Ͱ@¡^|@®"G@¢÷Ñ@Ž.Ú@oý@BC@js?Ï4ý?fîs>7Ot¿P ¿¦¤#ÀÊÚÀ5ÀiªÀŽ…îÀ¨dÙÀÃÙÀÞ ýÀøè#Á ¿”Áu¾Á"MxÁ-µûÁ9!ÁDÖmÁPx„Á\¡ÁiEÁuæûÁºÁˆ/ÏÁŽ“Á“ûÁ†óÁ€z1Át_QÁh6 Á\‰‰ÁQ¹ÁE‘IÁ:3Á.É™Á#àÁIÁuSÀôÔ™ÀØ[ À»¹ÀŸ`ÃÀ‚÷ÀMšÀˆÚ¿¾ (¿'Þ>0‹?mÂê?Ö¢@> @}u½'B¿[«¿Õ§„À!d%ÀXAòÀ‡sÀ¢ù±À¾ú=ÀÚ¦÷Àõê¸Á×ÁšÁêFÁ*<ªÁ5öæÁBMwÁO8Á\!çÁi$lÁv$ÁŠMÁ‡á*Á‡ŠKÁ€áÃÁt‹åÁgcÙÁZçÁNðÁB#}Á6º+Á+c±Á ?®Á%ÄÁó À÷AŽÀÛYÄÀ¿‚À¡ô/À„•éÀOÐAÀÞÄ¿·!Ž¿ÉI>´â?Ÿ­Š@¼ó@<*@oÀ@¡@¤ê¹@·@ÇÍo@דV@æ C@õRJ@þè†@覷@Òü@»<Á@¤j†@[9@ku@:ôF@ Öù?­ î? ¯S¾œK¶¿”A•À!íÀ8kfÀpþÄÀ•~À±_øÀÍwŽÀèºrÁ<7Á >QÁ|ðÁ#ü&Á0HÁ<Š6ÁI=¸ÁV?gÁcRÁpÏÁ|KâÁ„}EÁ„ôÎÁ|WMÁoñÁb úÁUÙÁHZkÁ<fÁ0a$Á%+‘ÁåƒÁ²/ÁºÜÀëRJÀÏŒ²À²÷½À–;žÀr¹À7Ë¿ù¾ù¿†ø¾÷ë?Iƒ’?שƒ@%¨@^iz@Šoí@¤•Ù@½,°@Ñ„j@ã@óbAX!A¡A –@ÿ8ç@èkò@Ñ£F@ºÎ@¢âU@Š~Ú@câ™@/½÷?ôÖ;?‡sÈ>P\Ê¿)‡’¿Ê(;ÀÿšÀX]{À‰!ËÀ¥œ7ÀÁé›ÀÝœ8ÀöÍLÁ~Á4ÆÁ»¿Á*§TÁ7¨ÁD #ÁQ Á]. Áig·ÁvKÁUÁ‚QîÁwtùÁj=eÁ] …ÁP@XÁCƒpÁ6êÁ*ÞbÁowÁ)óÁ¸ìÀùúÀàc=ÀÄÖ¥À¨ÐÀŒjÀ]_‘À"6Ù¿ÎJî¿0‰\>rff?•}“@ŸÇ@@R@yÆm@™È^@¶a@ÑJ7@êX¿@þIAˆCAi*A¹AÀgA¯E@þÜ@çÆc@Ð @·…Ê@žˆ @„u»@QÓ@ý??Å’0? TѾ”õ}¿š•ÏÀSŒÀBQAÀ}*À›¬ÌÀ·ÄÇÀÓ[ÑÀíoKÁõ–Áe5ÁÓ¿Á%Í¥Á2LõÁ>œÁJþ“ÁW”ÎÁ2¬Á%©ÁìfÁ–œÁX_¿;ú_¿ÕôãÀ&‚À`c$ÀŒÎÀ©§¹Ù¿‹8¿Å/ À*ÀV%@À‡˜«À£q•À¾>´À׆ÀÀî¡VÁN{Á ÎÁ®¸Á%RÁ1zÁ=¥‹ÁJViÁWx1Ád÷wÁrÄ£Áv ZÁh~ÁZJ¬ÁLáûÁ?Ô‹Á3%„Á&žôÁeÌÁeÁ—¨ÀîfÀØ ŸÀ¿–À¥½VÀгÀ\ëÃÀ"ÙÖ¿ÐOl¿1 m>tCâ?—Ð9@—“@EÁ£@ï@ UF@¿6@Þ.@üüOAzA°¢AÆ'AªA’AãáA8AŒ\Aªÿ@ÿ×C@áo\@ÂÜà@¤@…Kû@MÌ1@5,?©#>ÀЀ¿ f÷¿º›‚À lÀPYùÀ„•ÀŸKeÀ¹Å?ÀÒ³‰ÀèºîÀþ[ÿÁ ÒNÁÁÏÁ"²;Á.£ÙÁ:ü‘ÁGزÁU!ÈÁbįÁp²"Át4Áf:»ÁXœJÁK¢Á=¬EÁ0Á#ð2ÁÅkÁ «DÀÿùhÀé–ƒÀÒÁGÀºtÀ åÀ†lÿÀTÑÀw»¿¿ZY¿ª>½µç?§ºý@÷@N¼@…w7@¤A@Ã/Z@â pAtÃA!AаAn‹ARgA:A‹ŸAßÜA4AˆX@ùù@Ü[y@¾Õ¢@¡n@ƒ‡T@Jõ`@°‡?¦:‹>¿Z>¿hÏ¿¸AXÀ‰ÉÀLŸçÀ‚_ÐÀ‚çÀ·2ÀÏèÀäÎßÀú%¢Á®ÁlwÁ PZÁ,AÁ9atÁF…ðÁSøÍÁaÇÁo3ÚÁrÁdÁViÂÁI ;Á;ïµÁ/«Á"<¦Á÷$Á ÿDÀüÌÆÀåá®ÀΠ±À¶°¾ÀMÀƒžÀN~~À4Ô¿µ+f¾ùfÍ>Þ7°?°Ð&@Z@R(C@‡N÷@¥1@Ä2Y@âåâA®®AO8A3A‚A…AõAT/A¦pAø±A¶Y@ñŸªZ¿î ¿¿v·À0»ÀN¯ØÀõ1À›ï¦Àµ äÀÌ,lÀáÄþÀ÷dÁ×Á¤ÁCWÁ+ ûÁ8)QÁE9 ÁRTÕÁ_ÀºÁm~tÁq(ïÁcœÁUX×ÁGé4Á:ÞïÁ-ûóÁ!NÁƒÆÁ£!ÀúkçÀãpÀÌÏÐÀ´×­Àœ À”sÀK:‡ÀbW¿±åë¾ò£”>êË?²5Æ@ ©@O(8@…•™@£_ @ÀR‹@ݱ¶@ú¯ A5+A+ A ïAÐA ²AO)A¡jAó«@ÿ“¬@å ,@Éîþ@®+½@’·S@m‰·@4éÇ?ø\ž?ˆ‹N>9ÇÔ¿4N(¿É`À$MÀR†Àƒ”RÀœü×À´¾òÀËOmÀáfÀõ{‹ÁOÁÚ¯Á.ŸÁ*ÉÁ7FdÁDn‚ÁQœqÁ_nÁlÛ6ÁqF¢Ác=&ÁUziÁHÁ:ÅOÁ-ÈÁ â?Ág7Á€›ÀùªÒÀâÛÀË"bÀ³1 ÀšÇDÀÀMØÀ¤=¿· Ø¿ ¥>ÄÆâ?¤~ @ z¡@E/@~ÀT@›ü6@·»”@Ó1q@îóAj³A)­A':AAýAJ#AœdAæ @îú@ÕÎ@¼h{@¢&«@‡*î@X:@"Ý×?×êç?VÛ`¼åX{¿a %¿Ý¶ÌÀ$¬3ÀXå À†T Àž¶ËÀµ†ÓÀÌ HÀâðÀö‹ÑÁÛ¯ÁWÁœ2Á*qÁ7ÇÁDð0ÁR=Á_‹ˆÁmLVÁqýüÁcøÅÁV:YÁH©¬Á;2™Á-â<Á!VÁ»èÁî–ÀúK‰Àã;—ÀÌ"À´˜³Àœ.ýÀ‚×0ÀPJÀÁ¢¿ÅŸ¿*nÍ>V›¿?Нk?ù¯@3t­@jXz@8E@ª×a@ÄSI@ÚÈ@ëd¦@÷›&A?+AEÆA·A¦ð@þÑ‹@ïm!@ÚœF@Äaµ@¬I?@“BÇ@sÖ{@?Ô©@ ­®?­Á6? ¾l¿Ž»y¿øñ À/[Àbö«ÀŠE«À¡Ö=À¸=9ÀÍõ¤ÀãÚEÀøÃÁã\Á:¡Á_ÕÁ+'$Á8fcÁE»YÁSOÁ`vsÁn(ÂÁr@ØÁd?¼ÁV† ÁI"¨Á<'Á/üÁ"bçÁû¡Á ½yÀüÍÀå9ÀÎ>uÀ·Àž×ÙÀ†$žÀY9À#Ìë¿Ü¦þ¿d³P½HÞ?K’?Ïå…@w@Pþ>@‚@šFœ@°@Â;N@Ð@Û“@ã“@é;@ë‰å@é–Ÿ@â…Ô@Ö|D@Ä@°|@šƒ@‚Ò>@Uƒ<@#{b?àò?zÓ>@­Ç¿?C¿´ðÀ ÔÀ?ÀpÕ\À³‰À§XaÀ¼Õ¿ÀÑ„Àæ®ôÀûÆ£ÁEfÁ¾Á¦¤Á,_Á9yyÁF˜ìÁSÃTÁa]ÁnÀ”Ás‘HÁe¤±ÁXÄÁJ·aÁ=ЂÁ1 @Á$\Á=Á é×ÁH†ÀéÍàÀÒo‘À»¥>À£îÈÀ‹;Àe 3À3lÀ./¿˜ Ý¾ÄÌ<>ÔUo?œ´I@~7@1Ë@a±@†g}@˜á¿@¨U@µÒ@¿/«@ÆÌo@˰@ÍÚS@Ëò›@Ž@»ºr@­5I@šm@…ï±@_ý@2̪@ï ?¥‰K? kô¾jõ&¿|Û¿âˆÀ!ÊÀQð­À€HçÀ—AèÀ­J¸ÀÂ.ÜÀÖñ¾Àë½ÀÿJÁ Õ…Á¹Á!/&Á-äöÁ;{ÁH3ÁUsÁbÂÁpR]ÁuêùÁh"|ÁZ¥äÁMx0Á@‚­Á3ÖÁ&ï€Á©òÁ³ÙÁ*`Àï¹]ÀÙÀÂ)vÀ«)À“þ5Àx0ÀFÌÀœ+¿ÈE|¿J)Ì»ÅÆ?CG#?À>–@.}@96Å@_ì@Õ=@޶@™zÙ@¢áâ@©È*@®––@°7í@®Ê@¨·»@ *„@“ÕÄ@ƒq¡@`¹K@7‚Ã@ ag?Ák?FŽ^=k³g¿.fh¿´¼(À BüÀ9BÀg5iÀŠdÀ gJÀµinÀɆ!ÀÜõòÀðËÈÁjÁ Á®[Á#‘/Á0 Á=3ÁJ–ÁW^ÁdËêÁr…¬ÁyûÁkKÒÁ]ÃPÁP‘=ÁCÆ3Á7 ¢Á*&öÁ±Áì,ÁÍ À÷u‚Àá`Àʪ¥À´n@Àx1À†³‘À^#PÀ/$A¿üý ¿ƒÑ¾öŽš>m€š?n ?˳™@ äˆ@-òH@K¬ª@e݇@{Zv@†@F@ŒË'@‘Z@’Ÿ@Ä®@‹¨@ƒðv@r¨ä@U~~@3”@ Ÿï?ÈãÍ?hŠ>lvÀ¾ñ0¿–…ã¿ñWÀ&ç=ÀSõÀ€òÀ–ÊÀ«À¿ ÊÀÒáÀå&ºÀøsÎÁ>VÁuQÁ|vÁ'DWÁ3ƒÁ?û—ÁL¤IÁY”ˆÁfæÁt‰âÁ|~=ÁnÚ Áa…qÁT ÁGè.Á:ö§Á.?¢Á"\Á­Á ™éÁ†¼Àë:ŸÀÕ ñÀ¿¶¤À©™À“ õÀx´BÀJ,wÀëÔ¿ÜÓ¾¿ƒ^j¾´ýŠ>•FV?fˆ?·_ä?÷&/@w @0@C¼C@SÔr@`6@h:Ø@jT%@f”n@]XÎ@N@]@:úS@"ñŠ@¼9?¿“??gÔ>ŽVr¾ÃY¿„F½¿ÚøÀ¨üÀEu Àq¾ÀŽ•À£ |À¶ðáÀÉÑ¿ÀÜ5°Àîk¸ÁyªÁ l_ÁÊäÁ 0Á+BqÁ7WÁC­XÁP+‡Á\í9Áj ýÁw…VÁ€fKÁsfHÁf=ÁY8nÁLl`Á?éÁ3ŸXÁ'°ÁOWÁNÁ%šÀö‹ÙÀá0ªÀËÿ„À¶uÃÀ¡?ÚÀŠìÀj ŽÀ=KJÀ$Í¿Ðqh¿}$™¾Çh‚>"R?)£?ë^?Äù™?òcM@ 6&@Ê@&nÎ@-ƒÔ@/ \@+95@"©€@fƒ@Þ5?ܯ ?¤$?D03>N¨m¾Ç]¿~Wù¿Ò:0À“ˆÀÀÚ ¿ÀÅÇ!À°P÷À›R°À†&ÿÀbôÀ8ð„ÀÕg¿Öæ¿[X¿˜Á½ÿ¦>¢;¢?4ˆÊ?…x?¨ït?Ä>?Ù¶"?拘?èvc?àÔ$?Ñt?¸ÓC?™H?aR>ûS<ØŽ¿T¿‰~F¿ÔNfÀ+ýÀ7þÀa\À… À˜™üÀ¬ÿÒÀÀ*kÀÒÀãIÀô”Áö!Á ÞwÁghÁ,Á)mÒÁ4…ŠÁ@N‘ÁLˆpÁXáØÁe¡0ÁrÃ6Á€øÁ…±öÁ~ÆÁq!ÙÁd|ÁX!vÁKdÒÁ?%0Á3|óÁ(‹ˆÁE,Áy;Á 4¸ÀþÀéÃ0ÀÕ¦vÀÁt:À¬ðCÀ˜÷(À„ZÀbDÀ<ÝùÀé•¿ï—}¿°Íð¿kÀ ¿B¾ -'>9:‹>〉?'eá?NE?d?g%t?W*œ?:w'? \>¡_"<˺°¾¦a¿@ªˆ¿ž<“¿áÔ<ÀUóÀ:†xÀ_rÛÀ‚Û¶À—SOÀªTŒÀ½@ÀÏôÒÀáFhÀñ¯ÃÁ$Á •Á{ŒÁÍVÁ%ÙjÁ0œÁ:¶WÁF!/ÁR%OÁ^‘sÁkõÁwì$Á‚ŽÏÁˆ¼øÁ‚?,ÁwÝ!ÁkÁ^2ÎÁQÓÜÁEú;Á:¿KÁ0¼Á%•ÿÁ>-Á –Á"Àú¡ Àç DÀÓYMÀ¿×À¬-­À™‹“À†áÜÀjœVÀI,À(£)À ’A¿Ý<ñ¿ªµQ¿{Žö¿/yp¾ß§¾yƒ½Ãżœ¹ç¼fV ½œ’¾>4M¾²Xm¿`w¿TI§¿”4¿Å€¿ÿ‹kÀéÑÀActÀd<ñÀ„Q¥À–¸éÀ¨ú5À¼.ÀÎYñÀà•Àð¯DÁA“ÁæÁhÁÃÁ#_ZÁ-:÷Á7•ÅÁB-ÁM ÖÁX«öÁdÕ<Áq`Á}ü­Á…p¹ÁŒ,Á…ÖÁ~~ÄÁq¨ÍÁe8ÔÁY@]ÁMÔCÁBê"Á8”Á-"Á#—¨Á³7Áä¢Á ÈÀù:dÀæ}MÀÓÁ ÀÁ9ÄÀ¯ÂÀ†ÀŒ˜ýÀxà³ÀZ{À=GÀ"ÂÀ Šø¿ê˜¿Æ)¸¿§¥Ù¿ å¿}Ù ¿mXË¿kó¿{¿ø¿‹g¿žµñ¿·»ñ¿Ø¥:¿ÿÖÀ1 À2÷ÀO ÀnºÝÀˆÀ˜Ú‘Àª®~À¼òÀÍšnÀà%°Àð‡8ÁŒ$Á‰Á¨ÕÁŒ©Á"Y"Á+ѲÁ5|sÁ?¼QÁJE¨ÁTíxÁ`&ßÁkí„Áx-NÁ‚dÍÁˆ»ÁÎôÁ‰;}Á‚ЪÁy)‰ÁmdÁa‘NÁVy ÁKvÁ@¤IÁ6föÁ,kšÁ"ŸwÁÝÁn*Á!UÀú'çÀèUÍÀÖÑÀÀÅXçÀ´m´À¤bÀ•=À†Àq³ÀW$ôÀ@3­À+ï¿À¤À M™ÀÜË¿ñþÇ¿êåä¿êv¿ñö׿ÿÀœÀÙ–À#yÉÀ5’õÀL2fÀd;}À}áÀŽÃÀž1ðÀ®‚ðÀ¾ôÀÀÏøfÀàøSÀò Á>ÁõÁĺÁ¼ Á!mÁ*øÁ49mÁ=é ÁHWCÁSÁ]ª†Áh~vÁsÞÁ¼“Á†ÁŒVðÁ“hÈÁUÁ†Ã|Á€¸”ÁuÍóÁj•YÁ_d ÁTKQÁI½5Á?||Á5€Á+±ÌÁ"J$Á/‚Á3®Á_æÀýõÀ쇩ÀÜŸÀÌ À¼jÀ­ƒÀŸGÀ’^À† ÁÀvsÀb©ðÀRÚÀD¢À9ÏÀ1ÕrÀ/•À/zÀ3!À9:‡ÀB>þÀMÅ3ÀZ¶Àl=tÀ€2ûÀ‹¥:À˜EÀ¦pfÀ´ÏgÀÄ2ãÀÔr§ÀäçÀô¬õÁx$Á ;³Á¹òÁXRÁ!‹ƒÁ)ô2Á3=8Á=›ÁFJDÁPIùÁ[[ÁfSðÁqk9Á|ŽtÁ„tÁ‰ýVÁ&»Á—YÁ‘ Á‹‰Á…6Á~²‰Ás[}Áh(µÁ]?wÁRç]ÁHù<Á?ÅÁ5tÀÁ,U—Á#O1ÁsZÁÁ ¶1ÁwWÀóUÔÀ㛃ÀÔЇÀÆÀ¸íÔÀ¬À À…À–ÅÀŒÙ±À„Þ;À|¤ùÀrªlÀkR0ÀhÛŠÀi °Àlâ*ÀrœžÀ{0ÿÀ‚ÝéÀ‰A‘À‘aÀšàNÀ¥nÀ±1^À¾2mÀËѰÀÚn Àép™ÀøÌÁì§Á é¿Áà)ÁÝ Á"ÅæÁ*û®Á3{ÝÁÌÀçÂ@ÀߥÀزqÀÒÛÀÎÿþÀÌ ;ÀÊÉ[ÀËXÅÀÌï3ÀÏ’ŸÀÒõÀ×›¯Àܹ¶ÀãMÀêàÀó¦gÀüø7Á×dÁ ~ÁÊXÁÁÄÇÁ$NÁ+~Á2pŒÁ:æÁAíÓÁJÔÁRÔŠÁ[ÕÁd²EÁmÙÁw°eÁ€…ôÁ…ašÁЇüÁñÁ••¨Á›o;Á¡x Á¨ç4Á£¦Á$Á—sDÁ‘úÁŒ¾´Á‡È‰Á‚¤ÇÁ{OÔÁqûáÁiH+Á`8<ÁWLÁNÞLÁF—ŒÁ>ÞÁ7\“Á0GSÁ)a·Á"˜ÍÁ88ÁFÁVšÁ ôÁÁ¥Àû;}ÀôÖ,Àï+ÀëyXÀèâMÀ組Àè7dÀé×¼Àìc–ÀïWQÀóÊ+Àø ñÀþ6Á½¤ÁêDÁ tÿÁžqÁ§ÃÁ­»Á!Ù­Á(,Á/2GÁ6“ÔÁ=³IÁE2˜ÁM ÁUI Á]ÍZÁfÞBÁoøÅÁxéªÁ*Á† ŒÁŠ·§Á­Á”æ_Áš\’Á  xÁ¥çrÁ­ŸŸÁ§¼ÄÁ¢*Áœ‚ãÁ—8ŒÁ’-TÁ3Áˆ Áƒ=Á}z~Át ËÁk¯±ÁcÁZ}•ÁRi"ÁJáºÁCt¶ÁxÁ­ÈÁ³ÐÁ¹T Á¿+ÂÁÅ€ÁËKÁѱÁ×9ÁÝgÁã«ÁéÒ*ÁðÁ÷™êÁñ8cÁêçBÁä›ÁÞZ—ÁØ1NÁÒ ÈÁËòºÁÅàZÁ¿ÞVÁ¹ä´Á´Á®=zÁ¨…ÛÁ¢Õ Á:àÁ—ÒÒÁ’‚ûÁKÞÁˆStÁƒ¡æÁ~OwÁuÁm2ÀÁe·eÁ_!ýÁYRvÁSÓbÁOY2ÁKðÁÁHòÞÁFõpÁFØÁE}¶ÁEµ ÁG&¿ÁHû”ÁKËœÁOÍ¢ÁToÁYHÁ_²5ÁfX‚Ámœ:Áu®bÁ~ qÁƒ~¿Áˆ@¨ÁMoÁ’¶Á—ÉËÁ-âÁ¢²Á¨iÁ®?WÁ´èÁ¹÷)Á¿ó½ÁÆXÁÌ7ÊÁÒkÁضÏÁÞéÆÁå1¾ÁëŒjÁóÁì¸ÛÁæTØÁßþ'ÁÙ¬?ÁÓfwÁÍ7‹ÁÇ ÆÁÀô~Áºè×Á´ß¬Á®ÝÕÁ¨ø˜Á£:ÇÁ„bÁ—×Á’EcÁŒÜÁ‡‚¦Á‚RÁzÙ½Áq´JÁhÖ{Á`!qÁX2qÁQ08ÁK)ÌÁEz¨Á@«2Á=ÞÁ: Á7âLÁ6ý&Á6WïÁ6“Á8çÁ9õçÁ<ÿ3ÁAJ¢ÁF ÁK™0ÁQÅrÁX£ÂÁ`b’ÁhÁ«Áq_LÁz¯ÃÁ‚STÁ‡‹zÁŒÐ¼Á’&)Á—¤ÃÁZiÁ£/?Á© ÝÁ®ð Á´ïÁ»šÁÁ?›ÁÇxqÁÍÄØÁÔÁÚUjÁà«ÎÁç'ÁîÆNÁèHôÁáÚÆÁÛv6ÁÕÃÁÎÇáÁÈ|•ÁÂG•Á¼-Áµü Á¯öÄÁ©ê¡Á£àÙÁúXÁ˜:Á’‚êÁŒß1Á‡PßÁè_ÁyÁnÐŒÁe5“Á\CæÁSvcÁK åÁCÁ=#ÔÁ7gGÁ27lÁ.XsÁ+QÁ(ú¼Á(dÁ'ZfÁ'›MÁ)'Á+¢Á.i#Á2Ù”Á7ÒÛÁ=˜‰ÁCæÜÁK62ÁSoÒÁ[õÁeiÁnÒFÁy;ÖÁãÁ‡*"ÁŒ¢Á’UÃÁ˜(pÁžkÁ£òüÁ©õcÁ°Á¶RÁ¼¸ÁÂÛ£ÁÉ%ÁÏyCÁÕÑQÁÜ9íÁâ·Áê”íÁãþJÁÝ|WÁ×ÇÁЗËÁÊ>SÁÃëÁ½ž´Á·c.Á±+×Á« ¸Á¥ ÁžúëÁ˜ðÁ“ŒÁ@§Á‡ƒ;Áê˜Áx¸ÐÁmîàÁcD­ÁY'ÁOÇ:ÁGûÁ>PïÁ6P´Á/iŠÁ)Á$ CÁÖÁÌgÁKbÁBÅÁ‘fÁØ”Ák Á±Á óÁ$qcÁ)ÈÊÁ/žùÁ6WGÁ>,=ÁF½²ÁO‘ØÁY'¹Ácj«ÁmðzÁxzzÁ¬ÐÁ‡]šÁ-Á“ Á™'ÁŸJÁ¥5ÐÁ«qDÁ±´?Á·üÀÁ¾GãÁÄ¢¥ÁË3ÁÑrVÁ×ú ÁÞu£ÁæpmÁßÑÁÙ7JÁÒ±ëÁÌ4ÂÁžOÁ¿bÿÁ¹Á²ËÀÁ¬Œ8Á¦NÁ *SÁš-Á”ÆÁŽ ”Áˆ%HÁ‚SÁy ”Ám÷AÁbä!ÁX0‰ÁM¢‘ÁCµ¤Á: ðÁ1ÿ+Á)Œ/Á"ÁíÁAŠÁ¤ÎÁƒ~Á åòÁ Ä$Á ÒÁ \xÁ ï€Á.ÁÜôÁG?ÁåÁ!ñSÁ)4ëÁ1˜ñÁ:dKÁC´åÁM¿üÁX·Áb¾ïÁm‘.ÁxêHÁ‚@Áˆ¬ÁŽÁ”'ñÁš\eÁ Ÿ»Á¦äÐÁ­*Á³v£Á¹Ú6ÁÀCÇÁƹóÁÍGËÁÓ¾åÁÚ@ƒÁâ`ÁÛ¼ªÁÕJÁÎwCÁÇëÁÁmÆÁºòËÁ´‘LÁ®D Á§ù·Á¡ºvÁ›€Á•W Á; Á‰-}Áƒ8ýÁz¤qÁnèÃÁc_HÁX@RÁM;£ÁB¥¾Á8=£Á.ÆÁ%ϰÁMÁP(Á‹ÁëµÁÝÁ‰”ÀûÆ6ÀøÊûÀ÷šŸÀøy’ÀûÁ>Á¾ØÁ…Á8mÁºwÁ›GÁ%t5Á.ŽUÁ8LŸÁBoôÁMÃÁWõ7ÁcA’ÁnÊÎÁz‡õÁƒJ=Á‰Z×Á•2Á•àÈÁœ% Á¢f5Á¨¶Á¯"Áµ•¬Á¼0Á”TÁÉ%ÁÏ£>ÁÖ:bÁÞq¼Á×ÄyÁÑBÁÊo4ÁÃÇvÁ½3:Á¶´ºÁ°7ðÁ©Ï¶Á£{¥Á+MÁ–ñnÁÀáÁŠ–EÁ„oéÁ|¸4ÁpêCÁe'sÁYR—ÁMÎ*ÁB¾*Á7Î÷Á-a·Á#-õÁØÁ0ÁÕÔÁ²çÀ÷²ìÀí!Àå‘~Àà ùÀ܃ÀÛ˜ÉÀÜ6ÀßÎïÀå 4ÀëýÃÀöcóÁøhÁÁŸ¯Á¤Á#&hÁ,ÿ.Á7£–ÁB“]ÁMÍÀÁYDýÁdýÁÁqnÁ}IRÁ„äÁ‹6ªÁ‘w4Á—´gÁž ŽÁ¤&ÁªúzÁ±lÁ·í´Á¾}»ÁŤÁË DÁÒCAÁÚ”ùÁÓìkÁÍ<ÁƈøÁ¿ØíÁ¹*¼Á²Ž(Á¬ ÎÁ¥±ÁŸ!íÁ˜ÆÈÁ’oEÁŒ5ÕÁ†Á»¦ÁsooÁgEëÁ[{OÁO½½ÁCònÁ8~"Á-„jÁ"µÁÁ}êÁŠÁxÀùjŠÀéã£ÀݧIÀÒ˜ÙÀÊÂEÀĉ›ÀÁ+ ÀÀ)2ÀÀ×tÀÄ«ÏÀÊ¥ÀÑÅœÀÜ»ÀèÓ—Àøa‘ÁÉ’Á5KÁæ¨Á"^eÁ-nIÁ8¡EÁCþjÁO®ÌÁ[ØÚÁh€ÁtŠ"Á€±Á†ÑÁÁ“uJÁ™êËÁ _ÍÁ¦ÑªÁ­YhÁ³øŠÁºƒÖÁÁ¼ÁǾnÁÎ|9ÁÖØÉÁМÁÉn6Á»PÁ¼ÉÁµXÁÁ®¤Á§ÿzÁ¡ygÁšÿ9Á”Œ5ÁŽ)÷Á‡ËRÁ‹uÁv«Áj[iÁ^+ ÁRÁF0ŠÁ:`îÁ.ÍØÁ#ˆ¢Á¬-Á î¹ÁÌÀô$ÀâW9ÀÑÜÀÄl‡À¸ð7À°|9Àª˜À§7úÀ¦zÀ¦RHÀ©Ü)À¯ŸÀ¸ÈÚÀÃÁžÀÑQ·Àà×DÀòõuÁJWÁ oÁsXÁ#£;Á/Á:¯_ÁFÏÝÁSÐÁ_n/ÁkåÅÁx†¦Á‚›‡Áˆñ“ÁY¦Á•ÑÆÁœNbÁ¢Ü[Á©xaÁ°ÆÁ¶ž Á½GeÁÃøÐÁÊ©}ÁÓSÁÌuÁŨÏÁ¾ðÎÁ¸=ÉÁ±ÞÁªï(Á¤9Á‹°Á–þêÁ‡ÁІÁƒ¨ŽÁz‹.Ámþ4ÁadÁU/ÈÁI¢Á=CÁ1&©Á%IÁøTÁÓÁÁñbÀò`ÀÞ«—ÀËÇØÀ»€MÀ­À¡kÜÀ—ñ À‘ÙÀŽ=ÈÀŒ‰ÀæuÀ!IÀ–{aÀŸåêÀ¬N9Àº4âÀÊ»„ÀÞR™ÀòlbÁ¨#Á«|ÁEÁ& Á1ãÐÁ>üÁJu#ÁVíšÁc¯:ÁpwzÁ|óçÁ„Þ4Á‹a’Á‘å›Á˜jÁžþWÁ¥›øÁ¬32Á²Ô^Á¹‰ðÁÀF|ÁÇ ×ÁÏß±ÁÈþ’ÁÂçÁ»FýÁ´ˆbÁ­Õ»Á§$ÂÁ ‚qÁ™ÜPÁ“3ƒÁŒ–£Á†Á9Ár\¸Áe·AÁY0ïÁL¡ÿÁ@NÁ4-Á(#üÁT<Á§ãÁ`òÀô]¬ÀÞà/ÀÉþ´À·UÅÀ¥ëýÀ—yðÀŠÅqÀ4|ÀubýÀl¬ÔÀi9ÎÀl3µÀq›NÀf:ÀˆßÊÀ–aŽÀ¥!IÀ¶íöÀʆ/ÀÞá Àô=àÁ¼ÁNÁ:ÍÁ)Z{Á5Ð?ÁBTgÁO.±Á[¿³Áh?¼ÁuIÁÁ‡‡ÑÁ޶Á”ÐÁ›K„Á¡ÐºÁ¨uêÁ¯6ÁµþÚÁ¼ÂjÁÃÁÌ•EÁÅîÁ¾º…Á·ÝGÁ±CÁª;ÉÁ£‰ÁœØ£Á–. Á…ÇÁˆà*Á‚;Áw]IÁjmBÁ]Œ^ÁPþ=ÁDWÁ8 {Á+ÔôÁ˜žÁ§Á»ÀùHoÀâ¯BÀÌwÈÀ·ÓZÀ¤-WÀ“»ÀƒOìÀjGñÀWpÛÀIÚ\ÀBB€À@!bÀA~|ÀIcýÀV«Àh–ªÀÕIÀ’_nÀ£Ä±À¸^ÀÌç.ÀãoCÀú‡'Á ÕÁ+öÁ!¯ìÁ."WÁ:ÁôÁGTkÁSðWÁ`³×Ám£¹ÁzwÁƒ¸wÁŠ]Á‘øÁ—ŒšÁž8žÁ¥QÁ«Ç‰Á²€ŠÁ¹O‹ÁÀ4uÁÉ}êÁÂyúÁ»{Á´RÁ­·Á¦ß³Á =Á™_Á’±vÁŒ’Á…OÎÁ}O9ÁpóÁbÞ"ÁUøÕÁI"Á<‡ÚÁ/ý/Á#³ÉÁ“’Á nÛÀÿMpÀèc©ÀÑ¥®À»ãûÀ§EÀ“¯ÀY”ÀaoÀHÀ3Œ#À%ЕÀÄËÀÜ\ÀòáÀ#o´À1JãÀCG8Àa1ÑÀ(À“ä‡À¨\ÑÀ½±aÀÓâÒÀëÊÁ¨YÁ Á.ªÁ&¬*Á3V|Á?ýéÁL–,ÁYWqÁf< Ás>HÁ€C’Á†ÚHÁpxÁ”ôÁš×¶Á¡–DÁ¨YÑÁ¯0*Á¶eÁ½øÁÆ€ÿÁ¿w‘Á¸yMÁ±|›ÁªŠ<Á£°ÁœßüÁ–ÍÁLiÁˆž%Áþ Áv‘{ÁiBbÁ[üTÁNÐÄÁAú?Á53Á(ž5ÁÁËËÁžãÀï’`ÀØíÀÂ’À«ùŠÀ—¥2Àƒ·3Àb5PÀCÂaÀ)q©À¿À;Ày¿û*À>MÀÓ+À‡À(oøÀB¥žÀbØ’À… xÀ™¹À¯ª ÀÆN¥ÀÜ÷³Àõ-ÔÁÙIÁ-3Á ŠÁ,.íÁ8Í ÁEˆ±ÁR{lÁ_W”ÁltìÁy¹ ÁƒiyÁŠÁ¾ÒÁ—‹4ÁžTùÁ¥#lÁ¬;Á²ô|Á¹èòÁÃÆ>Á¼¤-Áµ“#Á®–>Á§¡µÁ °Á™ËËÁ’ùeÁŒ ±Á…K¦Á},pÁoòùÁb¶mÁU~ÁHA}Á;?`Á.d\Á!·¦Á2]ÁÍÜÀùŽtÀáEÓÀÊ…À³rpÀÂÀŠ1ŸÀl¢’ÀJºžÀ, NÀ’Ÿ¿ÿŒ#¿æ/Ò¿ØN¿Ôµm¿Ôú¿æ€8¿ú<À¢0À-BØÀM@Àr2ÀS+À¢Ì7À¹ÀоVÀèΩÁZÁ ¦aÁ¥Á%®ßÁ2dÇÁ? ÁKªÿÁX¿<ÁfbÁróÊÁ€‡Á†ÕãÁ¯?Á”\ Á›&MÁ¢ ÕÁ©„Á°ûÁ· ‹ÁÁ2tÁº3Á²óÁ«Û Á¤ÖÁà Á–ðKÁIÁ‰)Á‚K‰Ávú5Ái‡}Á\N¿ÁOÁAã Á4¶mÁ'ÒsÁû#ÁnÇÁÀì´ÀÔtdÀ½s¥À§ŒÀ‘‹%À| ŸÀV.À5›ÉÀ´À$¿å,É¿Ñ_ ¿ÄQE¿ÀPß¿Âäé¿Î6)¿æÖÎÀXæÀ™nÀ;’À_Ù¸Àƒ–—À˜ØÀ®h4ÀÄü¸ÀÜìÀôàÆÁ{3ÁÞ=ÁÁ8Á,6Á8pÁE‘ÑÁR ¦Á_–/ÁlË6ÁzHµÁƒÚáÁŠŠ Á‘YÁ˜E©ÁŸJÄÁ¦VµÁ­dcÁ´véÁ¾Î‚Á·ýÁ°x¡Á©ZçÁ¢F,Á›2ØÁ”)¥Á9ÂÁ†V£Á~ñ_Áq] ÁcábÁVyCÁIJÕÁ<"iÁ.þ¼Á!ãZÁÛÁx¥ÀøNÀàp]ÀÉìÀ±ù–ÀœP¼À‡&Àhª~ÀEÀ(3„ÀU*¿õ­Æ¿ÛÄ`¿Ê@¿¿–z¿¼bž¿¾3(¿Çf߿ڰ¿û6¤À›XÀ0]8ÀPôlÀvJ}À§¾À¥*óÀºÃóÀÒXSÀé‰LÁÄëÁ =(ÁËÐÁ&cÁ2µÁ?¼ëÁLÒ˜ÁYÓÁgûÁt€éÁ€ö¾Á‡Ç÷Áޏ£Á•ÄAÁœÚ˜Á£ÓùÁªÞ Á±ý Á¼¢»ÁµfjÁ®)Á¦ò3ÁŸÍáÁ˜½Á‘±¸ÁŠ©¿Áƒ¶ÁyÂ=Ál0Á^²{ÁQ]ÊÁD íÁ6ä7Á)ä„Á× ÁmÁ˜Àîq¿ÀÖAÀ¾ÐŸÀ¨(6À“ôÀ}åMÀZÀ9úXÀTÀ /Ò¿ñhR¿Û•¿Ì‚¿ÅWº¿ÂTq¿Ã_¿Ê-‡¿ÙöÁ¿óäMÀ ËŒÀ%q¿ÀFqSÀiÿÀˆ%ÉÀ›ÿÀ²™ÀÉpøÀß¿¢À÷GPÁ>!ÁAFÁ ¡ŽÁ-™¾Á:o0ÁG5ÁTk ÁaäÀÁobFÁ}§Á…r?ÁŒ~Á“oÔÁšeÁ¡sÁ¨–¥Á¯Í3ÁºŽIÁ³DËÁ¬ cÁ¤Ô Á¡ùÁ–yšÁgÊÁˆiáÁq[ÁußÁgbÁYîéÁLÀÁ?"„Á1ÑDÁ$ÊýÁíMÁ ,OÀýŽ0Àäú~ÀÌô#ÀµÁ²À $ÀŒcÀqþÀPËLÀ3LšÀE‹ÀÕl¿ò†,¿àIÇ¿Ôq5¿Î9Z¿Ëþ¿Ë£Ô¿ÑNâ¿ß†`¿ö°‰À ÍÀ#lÎÀ?2eÀ` À‚ÉàÀ–»À«V6ÀÁh]ÀטaÀïI9Áµ¼ÁÄÁL³Á(×Á5w¤ÁB‘ÁP DÁ]ŠÁk‚Áx»ÁƒOpÁŠBýÁ‘;Á˜J#ÁŸoÃÁ¦¢Á­ÜÁ¸½ôÁ±g¿Áª Á¢ÚÜÁ›¯Á”ŒMÁoÁ†]ìÁ~ÐþÁq ÁcSEÁU³!ÁH ÛÁ:¤YÁ-€—Á …‰ÁÁäÁ7˜Àõ±§ÀݵyÀÆDiÀ°—À›$À‡TËÀiþ~ÀKkåÀ0ó7À¤;À 4=¿ùI¿è¸¿Ý™¿Ör”¿Ò¿È¿Óν¿Ù¢ ¿åçð¿ûL˜À DåÀ!‘¬À=@À[2¡À|ÞÀ‘³RÀ¥rñÀ»jÀÐôKÀè‚ÀÿÏoÁ Î ÁV²Á$ê¥Á1¼RÁ>üCÁLÉÁYX*ÁfôbÁtØ{ÁgÊÁˆcÊÁj[Á–}ðÁœ÷Á¤Í Á¬yÁ· Á¯¿ÞÁ¨vªÁ¡1ÒÁ™ô Á’ÉAÁ‹µ'Á„®¬Á{c6Ám…Á_¶"ÁQëùÁDSyÁ7:Á)àüÁ ñÁ“©Á->ÀïêãÀØGÙÀÁJNÀ«’vÀ–ÿKÀ„£ÛÀhv9ÀJ­íÀ2BÀ<À <ÀQÀ¿ïh™¿áR·¿ÖÀ¿Ñ倿ÒÚ¿Û6Þ¿ëÛ´À·bÀÀ$rÀ;e¦ÀY/ŸÀx4¼À޶@À¡Ñ÷À¶©ÀËÔÀâz4ÀùŒåÁ¥àÁyÁ!‰aÁ.cöÁ;x|ÁH›8ÁV½ÁcãÎÁqà9Á·<Á†ÃÁÁÁ”ÙÁœuÁ£H~ÁªÁµ¦(Á®HÃÁ¦úUÁŸ¼ÜÁ˜Š§Á‘_”ÁŠ=QÁƒ0tÁxmwÁj|èÁ\˜µÁNå]ÁAPQÁ3éÁ&ð×Á[‰Á ÕÁs›ÀêȯÀÓÓ{À½žLÀ©5À•³QÀ„%ªÀhqBÀM`ØÀ5@UÀ!¨×À À±Š¿ìW¿Új†¿ËÜ^¿Å€ê¿ÇÛ¿Òæu¿è“ À11À ®À&À=QÀX¾ŽÀwÓåÀ_—ÀŸáTÀ³ø ÀȧÀÞo Àô²EÁE»ÁiÁ¥Á+ÕÁ8Ó¥ÁEÿÑÁS†aÁaKƒÁoMÁ|ßéÁ…bíÁŒrtÁ“™‘ÁšÊPÁ¢|Á©;cÁ´”QÁ­,EÁ¥ÑNÁž†UÁ—M©Á* Á‰¾Á‚9ÁvÁhÁZ0ÁLo¬Á?ÑÁ1ÞíÁ$öqÁL´Á ¼VÀþöÔÀè]ÀÑþÀ¼ÐòÀ¨VùÀ•ÕJÀ…_eÀlùÀQAŒÀ9e.À$ïÀǦ¿ûÇ¢¿Ùó§¿¿ôý¿®™ð¿¨pŽ¿®œ|¿½õN¿Ö±Û¿ú´PÀ¤ À'ÅÀ?A@ÀZÒiÀyœíÀ–,ÀŸbEÀ²*MÀÆœvÀÜVòÀñÉzÁÆÁçbÁTeÁ)ÌûÁ6—ÄÁCÛlÁQ€þÁ_REÁm×ÁzÚ*Á„nÁ‹…?Á’žvÁ™½ƒÁ æ Á¨ ßÁ³¶hÁ¬ZaÁ¥jÁµZÁ–r«ÁD#Áˆ,ôÁ!ÙÁt-‡Áf$®ÁX]hÁJØÜÁ=Š’Á0%Á#µVÁísÁ ~Àý‚ÃÀç(—ÀÑ)2À¼]oÀ©‘bÀ—ÁÀ‡/ÇÀpø±ÀUŒÀ:c²ÀùôÀ8Í¿Ü忳à¿Ô¬¿8Q¿n,•¿|Úµ¿“¿L¿³–…¿ÛÁkÀN-À#VÀ?„À\Â÷À|fMÀŽŸuÀ ‚À²É ÀÆLkÀÛÏÀñP#Á.¯ÁPôÁuQÁ(¸tÁ5ƒÁBÀœÁPBÁ]Á‰ÁkVÁy1Áƒ¥ÁнÁ‘ÕÁ˜ñÁ "Á§eZÁ±>%Á«r1Á¤gƒÁ)ÝÁ•öÁŽÆ‹Á‡šrÁ€~}Áró!Áe,ÁWUÁIÓ Á<±OÁ/îùÁ#6Á¥Á yÀýÝáÀç¶^ÀÒÈÀ¾’aÀ«ÉÓÀš`eÀ‰ÆÀtvÕÀR¦ÊÀ0À ñç¿Üšî¿£àÓ¿h‡¾¿D¾Ó`¾®Ÿ¾Ì1¿Ú ¿f,X¿§¹«¿åÀñÀÑíÀ7†?ÀZ¾šÀ~™4À‘&,À¢¢7Àµ5iÀÈEúÀÝDÀòoúÁ|øÁ6zÁ_Á(8–Á4÷ùÁB1$ÁO’YÁ\ùÁj•ÁxyÛÁƒJ¸ÁŠ\îÁ‘oGÁ˜ŽîÁŸÃÒÁ§ 3Á¬“Á¦º°Á öÁ›4 Á•ycÁŽzÁ‡MhÁ€*oÁrE¹ÁdwüÁVøÁIÁ"Á<Ë[Á/òÁ#R6ÁÁ SƒÁàÀéÇpÀÕ_ÉÀÁ­À¯'rÀ)ÀŠºRÀjlŽÀ@µÀÖÏ¿ä^¿R­¿>fj¾šõ=2>Óç>ÔžÉ>¤ºÙ=̯o¾Šj¿?IŸ¿©†¿ûj•À(àÀRV‡À}!ÆÀ’ îÀ¥ŽÀ¸v5ÀËåÀßü>ÀõFjÁ¨ÅÁ·ÁçnÁ)ÒÁ5¤6ÁBºAÁOÁÁ\ÆÁjV<Áx0^Áƒ#±ÁŠ7ýÁ‘MHÁ˜jnÁŸœ†Á¦á^Á¨'ÑÁ¢&áÁœS´Á–˜ ÁàúÁ‹‚Á…*ÇÁ|EµÁn]ÆÁ` ZÁS‰ÁExëÁ7ôÁ*µTÁ×wÁMxÁÖ÷Àñ {ÀÚÂÌÀÄ™ÑÀ¯Ã¸À›t"ÀˆÀ ÀlŸŸÀGé3À e¿ïù¿Qå¿™½jH>Úbó?OSá?Šïý?–?‘ å?\9Ã>àÿľÜT¿F꿺pFÀ Ñ}À=•ÝÀo€ùÀ‘âÀ§çÀ»|žÀϧÀã‹wÀøéÁw=Á«TÁg¨Á*SŽÁ6²¹ÁCK¡ÁPÛÁ]?åÁjÈÁxœ`ÁƒPGÁŠVÁ‘_>Á—‚£Á¨iÁ£óRÁ¤ÁØ·Á—ÛVÁ’GÁŒ`€Á†¶:Á€ßüÁtÿ‚ÁfÌÁXµ¶ÁJÁ6Á=ðÁ/†ÏÁ!âÈÁuÕÁk1Àõ«¬ÀܦàÀÄoÀ­‰(À—p<À‚µÉÀ]‡#À8.Àè¿ß3‚¿’É¿ Rû=,j%?n?î™?ÉnH?õzè@ß—@¾ò?Ôà ?n5?;Ǿ9¨ì¿crr¿ÒðÀÊšÀKnÀz|À•EÀ¬Þ ÀÄqáÀÜì\ÀõNJÁ&ÁÝŸÁ «,Á,•íÁ8ǬÁE$`ÁQÊñÁ^ßÕÁlP½Áx:ÛÁ¨'Á‡aÁR¦Á“v Á™ÃGÁ ÁŸò3Á™ÖHÁ“¯KÁ·“Á‡õYÁ‚V†ÁyRÛÁmƒMÁ_¯ÁQz4ÁCEVÁ5{Á''òÁŽ6Á óGÀü£XÀâ@ÀȼhÀ¯µÀ—B^À€O„ÀTŽ•À+O´À5#¿½¸-¿lÅ|¾¹0Õ>UI±?F®m?¬ÐÉ?ñ2 @a@1M¢@@vÌ@9‚@oº?î?—­ÿ>å¡X¾’ß\¿ƒÉò¿ãt™À ðÀPQÄÀ¸|À—l·À¯Ü ÀÈa_Àál=Àû*üÁ ¤âÁ¤$Á$Ô±Á2bíÁ@ÀÁM¨äÁYUíÁdi–Áo~ÃÁzÓ4ÁƒQçÁ‰oìÁ«jÁ•ôïÁœGIÁ›¬ÊÁ•¬ ÁÕ­Á‰³äÁƒÄÈÁ| IÁpû•ÁebnÁX§ÝÁJYqÁ<qÁ-êËÁ ²Ák%Á–Àì ùÀа¼Àµ–ýÀ›Ê#À‚ÅÕÀT,žÀ&+Á¿ôÆë¿¢g«¿+Œ‹½¼,ù>é#I?ƒß?É„ø@Èn@+ì@L&@h0P@{6@olÕ@LÑ„@"Ër?é,Ö?‹4Ä>¶ÀžÀák¿ŽZC¿ìÝþÀ%žÀTçóÀ‚˺À›”À´—(ÀΡÀ襊Á_QÁÁ|ÁxöÁ*DgÁ7þ»ÁEwÁPÔuÁ\5ÁgcCÁsÁ&@Á…§Á‹Ò+Á’UÁ˜”;Á—´«Á‘Š Á‹Á…Ç ÁÆÆÁtÿÁh¶Á]a*ÁQÅÑÁC™ˆÁ56#Á&ÖEÁŒ Á R9À÷ø ÀÛŒÀÀÈÀ¤à;À‰zëÀ]¶-À+­"¿ó© ¿—pô¿^>,?9»u?¥«q?ë4ã@î¶@<0]@^z@€uA@ŽÍl@›1û@‘’y@yøü@L×Ã@;£?á2?ƒ8^>—>¾ã#ƒ¿–§Y¿õŒçÀ+vÓÀ]C‘À‡ãáÀ¢hÀ¼QÀÖZsÀñ¨Á”jÁj’Á"6¹Á0ÄÁ=dÁI áÁTQ´Á_û-Ák—KÁwaðÁÈõÁˆ‡ÁމûÁ•#ÑÁ”Á¼áÁ‡— Á¤ûÁwÈEÁlLØÁ`Û^ÁUÁIÝkÁ<ÿEÁ.œáÁ MjÁºOÁYÚÀéþåÀÍ[À°®¯À”I‹Àr©À;TÒÀC¿£1¾ýÿê>k¬Ø?gQ?ÄÏ¢@ÀÝ@+b/@N€|@q4@‰Ï@šC¼@©á@@·ý@©K\@’øÝ@xÜä@J9@TŒ?ÙüŠ?wè>ojÍ¿—G¿¢Ü…ÀƒûÀ6±Àj¾]ÀcBÀª^1ÀÅÔÀáu*Àý'¶Á {Á‘âÁ(³mÁ5ÄoÁABÙÁL¹ŸÁX3PÁcÔFÁoñ_Á|}XÁ„´<Á‹QGÁ‘áÁÅBÁŠKŽÁƒü°Á{¾/ÁoôœÁd‚´ÁYšÁMØ'ÁB¹&Á6cöÁ(™Áí1Á ~ÑÀùÉåÀÜ}·À¿ºÞÀ¢øÀ†FÀRʨÀ.Ç¿Çg¿3\ê>ð3?hz/?Ò\*@ÿ“@;¹Ñ@`ÜÐ@´™@“T`@¤ @µ@ÄÎW@Ó/Q@¿¤›@©?@‘ó8@u,ë@Gº@å?Ò‚ ?eë@><¿'‘¿ºô0ÀuêÀF,½À}„Àš0ÀµÅjÀÑÎÅÀîjÁ}ŒÁ Á!Ù6Á.“žÁ:mÁElÁPå¿Á\ãóÁi]TÁv;ÁÁ¥ÈÁˆ'§ÁŽ bÁÔÁ‡=Á€ÇêÁu½ÁháÿÁ]?bÁQà»ÁFŠNÁ;ÂÁ/ñ®Á"zÛÁL›Á‘>Àí´dÀÐZÁÀ²êBÀ•ˆ¨Àq„À7É"¿ûâž¿ˆoæ¾@µî?*ßR?Ä’@ýL@C¡\@n4 @Š…è@œÉø@­Ê @¾ã@Ïàç@ßž@ìYZ@ÖP@¾Éî@§•4@•˜@rjP@C‹_@›r?Ä!Ô??{‰½†4µ¿`µß¿Ý”À%m À\ÆiÀЇÀ§&*ÀÄSóÀá­åÀþˆÁ ›ªÁxäÁ(0™Á3€ºÁ>ÅÂÁJ“+ÁVçÇÁcƒÒÁpQÁ}QãÁ….ñÁ‹óÁ‹ ßÁ„±Á{ÿëÁo)9Áb¸nÁVÀrÁKQ•Á@ýÁ4ÙøÁ)©îÁÅöÁx)ÀÿñsÀâ ÀÅ 2À§jŒÀ‰¡íÀX?À4Þ¿Æó»¿&ˆ,>®ÀìÞÀ@•4ÀzòRÀšÌFÀ¸cÀÕšYÀò¶éÁÁvÁÅ/Á"ÇÁ-“ðÁ92OÁEþÁQSÁ]çÿÁjæzÁwøXÁ‚ DÁˆ5.Áˆ‡`ÁîÁvõ¼Áj/šÁ]ˆÁQ<ÖÁE Á:4EÁ.ùÁ#y1Á8LÁ D÷Àö&LÀزûÀºÅZÀ>À~a+ÀB{tÀä1¿–™Ú¾{Z?+H¾?É|@ª@X–Ž@ˆ{¸@£ùF@¼Gç@Ñ+b@ãÍ„@ôÖýAÔGA 2A AìAÊÿ@ê (@Ó‡“@»õT@£Òè@ŠÈŽ@b[@._???€Ù=ØEH¿K˜®¿ÚÀ'³ÇÀb÷6ÀwsÀ­žÀÀË'FÀè˜ÁÇÆÁª…ÁÁ(É#Á4yÁ?ñûÁLJÁY&ÁeŠ_ÁqÀOÁ~[Á…NŽÁ…÷4ÁKÁrMÁeP‘ÁX¨ÆÁL†Á@6Á4–†Á)C—ÁÒ¾ÁøDÁƒ ÀìËÀÏŒIÀ±ú7À“â,Àk—ùÀ.Éa¿ä‰»¿X‡A=®®a?‚É?úÈ.@9º^@s¦6@–É@³¾ó@Ïà˜@醓@ýÔbAù0ApµA¶ATUA Û[AXd@é ™@гØ@·¶2@Ò'@ƒAï@O@çÞ?µ¬¹?]¾â²‡¿±æ(À×ÀR,›À‡|èÀ¥¤ÖÀÃÀàU$Àü—GÁ àÁkîÁ$§Á/jÁ;9®ÁG…„ÁSÌÁ`'ÁlXIÁxÏ×Á‚ÔàÁƒ€4ÁyñiÁm"IÁ`VÏÁSÂ&ÁGb—Á;7äÁ/vÿÁ$ rÁÀ?Á øÁ-5Àä ÀÇ3ÎÀ©ÄþÀŒåÀ[îÁÀ¶÷¿Åš~¿·L>Àwn?«<Ó@‹;@NŠÊ@…E,@£{s@ÁG3@Þ=@û3 A c A>±A. A}ôAwŒAìÿA ï@ýŸó@äu:@Êy‚@¯`@‘å-@i,ƒ@+åq?Ýë?HY¢¾CÙ¿”òTÀ„ÉÀD/¶À€dÀžHÀ»î·ÀÙ²ÀõqÁõLÁ8ÁubÁ*ËqÁ6§nÁBæ ÁO0Á[{$ÁgÎÁtv©Á€½ÆÁ{ìÁu±þÁhÄÁ\ %ÁOVÁCúÁ7!ïÁ+aÁÚ‰ÁdÁò]Àø9ÞÀܨÀÀžÀ¢ÇûÀ… !ÀM¥”ÀÇ¿©3ô¾¹“?”?Èi@!Ãÿ@_S{@Žg3@­;@Ë˦@êVA3 AØ›AܹAFA@ôAcæA}ÈAJ[AŽw@öqR@Øš@¹*P@™Ä@tü@6¤Ð?ñÔ?lK½1q¿ £¿û6~À:³kÀw$À™e*À¶q=ÀÓÀïG Á´ÛÁ»WÁ¶¸Á'Á2ùÁ>ôJÁK QÁW3ÌÁc˜”ÁpiÐÁ}—³Áß’Árn\ÁeQGÁX”õÁKþ-Á?FÁ3|FÁ'ÁÏ[ÁÙÁõrÀñJÉÀÖWÀ¹ñ&ÀœµªÀ}åÀB À壿µ<¾1ž?GÃr?ßx@-‡8@kRi@”«‰@³´z@ÒÕ“@ò îAtîA«8AáÅA—Aè÷A:QAzvA”XA §z@ú¦@ÚÈ7@»ŠÇ@œ*@yê@:ä?ú'›?}Р<¨ó¿nc¿ðWhÀ4ôƒÀp©EÀ•¸¸À²]”ÀÎã ÀéíNÁ Á xÁvgÁ#íÁ/ÍÒÁ;®kÁG ÁS¨§Á`>ÝÁm>tÁz—Á}ÀaÁp0¡ÁbåýÁUåIÁI:Á<ÊcÁ0˜+Á$Œ1ÁÞäÁ ›½Á-1ÀëÇ6ÀÑnÀ´úpÀ˜ÀtÒìÀ8ƪ¿øt·¿~ͽ(Œ?m%…?òiå@7¢@tÃJ@™Dµ@¸I@×…ð@öæ A +ÝA°DAÅA¨úAÿAâA6MAŠ‹A ®@÷n@ؾG@º Š@›ª@xÎ@;©$?üVR?€íÑ=Z¢s¿d±î¿ë²«À1o·Àl#–À“[À¯¥ÖÀË4Àæ]BÀÿV¾Á ´üÁÁ!+šÁ-:Á9 lÁD÷ÑÁQFåÁ^Ák}Áx•8Á{ÕVÁnXÆÁ`õtÁS¯µÁF¸~Á::@Á. )Á"Áo¬Á 7ìÀÿ–ÃÀç(uÀÍcÀ±mDÀ”^ÀméšÀ1zŽ¿ê쇿bÂÖ=‹Ó?‚fs?þ ?@=@{ü@œlB@»œ²@ÚèÚ@úÐA œcA‰§AmƒAQ^A9 A‰ÍAÞ AÞtA=i@ðêY@Ó •@µ)‘@—2ç@rx}@5û†?òê8?uIH<“¡à¿l´¿í‘=À0úÃÀk7À‘½pÀ­Á&ÀÉŸQÀãíÀü0šÁÕ!Á…Áî·Á*½ÜÁ6¤ÁBíÁO¡"Á\­¢ÁjÎÁwhkÁyçlÁla>Á_-=ÁR.îÁES‚Á8¡±Á,i€Á  ÁîÝÁ xCÀû›QÀã§ÀɶŽÀ®£ëÀ‘òÀiÕÀ-““¿ãW ¿Ráê=ùk#?ˆ‚@À@>Kš@{»f@œU.@ºî=@ÙÛ\@ølîA m¬A2 AmAAðASZA¥œA¾MAù¼@çO@Ê ˆ@­C"@X@f @+dÊ?á+?V²t½·=>¿”¿óÀÀ4+\ÀnldÀ’ðâÀ®–²ÀÈ¥–ÀâÂÀùG Á{GÁ‹Áÿ!Á(vÁ4˜dÁAI7ÁNWaÁ[jÕÁh€þÁuÁ¡ÁxýkÁkiÌÁ^(ÕÁQ9gÁDUŽÁ7zPÁ+ %Á:ÿÁÓ¼Á_ Àùï*ÀáìÀÈ~ÙÀ­®À¸¥ÀhèÀ,Ô’¿â&#¿UFF=Í?ƒå„?úû@9€Ã@v#N@˜¡ @¶#¥@ÓŠ¼@ðñAµA%A êAÌA ®ANUAšµA§—@õÊÊ@Û(Ù@¿_ @£©â@‡7!@UF{@ï€?ƃP?'å¾v¨‡¿’‚NÀÝ‘À:X¬Àr;À• OÀ¯û;ÀÉßÀáüPÀø‹;ÁÓÁDÁí¼Á'qsÁ3¥_Á@gýÁMˆúÁZ±ÁgÙ£Áu#ãÁy/Ákˆ%Á^2šÁQµÁD#°Á7Q~Á*÷>ÁÁu ÁâÀøGUÀà^JÀǤ´À­v1À‘ÉÀj=–À0,o¿ë’ë¿mð¼›<'?gÚ?çn@-5º@gšÖ@Í©@¬Ýk@Èôì@ãÅh@ú‰ÃAgëA /úA -—A“A 4ÂAå@ûþ @ä™ü@Ëðß@±Þƒ@–ñŽ@w‚t@@@@ T?£ôz>ёǾí*¥¿«\À 4ÑÀD}ÉÀ{8¦À˜v À²¸ñÀËšyÀâ˜YÀù7ÙÁ„ÁÈOÁoOÁ'æùÁ4ŠÁ@ÇÁMôJÁ[!ðÁhKëÁu‘2ÁyÞ“ÁlDÁ^Á;ÁQVÁÁD-ñÁ7xÁ+PÁ†Á¾PÁ1Àù+ÕÀáºmÀÉdÀ®ü&À“œÉÀo˜HÀ7Êì¿ýõˆ¿‹£¾Y¨I?.f?É"~@ÇÖ@S‰¡@…G@ /¨@¹¤ @Ð’@àm´@ì”í@õ/Ï@úþ@þ @ü‹b@ôSq@åð@Ñþ@¹úÂ@¡Ø@ˆr@\ôÛ@'Ü’?ãÀù?nfa=Ö×½¿>˜•¿Ì £Ày¥ÀQa6Àƒ`kÀQyÀ¶×ÀΰDÀåF Àû³ÁyªÁã¬Át¡Á(Í(Á4ÙÁÁAxËÁNnÁ[åóÁi:éÁvlÁzSÁl•”Á_VµÁR@GÁER¨Á8±üÁ,bfÁ ==ÁŽuÁ $ÉÀû9;ÀãáÂÀË]8À²‚À˜:!ÀyÏÀCÙÀ ïl¿ª.¾ù»>»Ð4?œ`;@â}@9:C@m5œ@™!@¥ @· K@Åj<@Ða³@×õÉ@ÝX@ßö$@Þ¨×@×Ý~@Ì;,@ºŠ'@¥Ý›@L×@nÒ<@<äC@  |?®5…? ‹í¾‡t’¿‹vt¿ógYÀ-‘6Àa!ÀŠ šÀ£­\À¼¨ÀÓÙùÀéŒ_Àþ'þÁ Ö"ÁRÁÇÚÁ*MÁ6#ÁB9ÁO Á\ÁÁiîÁw*lÁ{e;ÁmîÁ`ËïÁTAÁGC-Á:«ƒÁ.JÁ"&Á—¼Á J#ÀÿB3Àèj%ÀÐ[½À·OóÀÍœÀ„”’ÀT¢À]œ¿Ó6§¿SA»…K$?R? ?Й@$V@J%§@vj"@›²@:-@©·7@³ˆP@º¥ê@¿Ùò@ÂM1@Àõã@»§@±Á@¢ƒC@°W@uVp@I h@ê$?Õáv?e V=悦¿0 i¿»È¨À-hÀBà[ÀtÁ²À“,ÅÀ«ÊçÀÃpYÀÙŒ)ÀÁµaÁ õ)Áß•Á P<Á+š4Á7–ÁD#ùÁQ%#Á^EïÁksÒÁx®žÁ}¬\ÁpU×ÁcP*ÁVa"ÁIÁ=WÁ0ãÁ$ñçÁ_¤Á á÷ÁySÀíù^ÀÖ‚¡À¾ú¶À¦®æÀ£?Àgß?À4ï—À"~¿œ¸ƒ¾àv>´êà?ŽŽ?ë×Ù@!CÞ@GÌ,@h·”@‚d•@º @–éü@&@¢gÇ@¤U@¢÷?@ák@”ëÖ@ˆ¥@pL@Iª@ =ˆ?é;r?>Âï6¾»‚G¿’¿ò¡™À*|fÀ[üÀ…ãLÀ¦sÀµUèÀË‚mÀàó$Àõ^Á^Á| Ál9Á"µ‰Á-×ÁÁ9°\ÁF¦ÁSÁ`$9Áme7ÁzµcÁ€^XÁsdóÁfVÁYƒŸÁL¸¶Á@¹Á3­äÁ'íJÁÇàÁ¸ÀÁk·Àö÷ÀßÖ&ÀÈQÙÀ°¦¡À˜“5À€ ‚ÀO)PÀ ¿×¿jáâ¾<ï? Cž?šl?æÍ®@÷@4ï@Má°@c°u@t@€‡q@„ÍÚ@†‹;@…„@€®p@pýã@[Dª@>ã¼@Qg?êÎ)?—÷æ?l`¾AõÁ¿hÓµ¿Ò"zÀàÀGÀu•åÀ’$À©’À¿ïÊÀÕR ÀéˈÀý.©?<'¨?’€Ê?¿*Þ?äú"@t@ k@Cö@† @P¨@ L;?ûµP?ÙFq?­ ?hzË>Ä;=tú¿Jd´¿µÐÀv<À/ƒxÀZ{ßÀƒÀ™ À¯M¿ÀÄÄkÀÙ¶âÀíBùÀÿRÚÁÀ$ÁÆ“ÁÛ­Á$ÄIÁ/þÁ9ÖÌÁEEúÁQ)Á]9:Ái¸lÁvxÁ²ÇÁ†“0Á€Ás+‰Áf­ùÁZl6ÁN2lÁBk“Á7|Á+þ<Á!,RÁdÁ ÐzÁœ“¥?!èâ?fô•? ?¥·?³m(?·8U?°n¸?¡?p?‡¶H?P²ì>÷á4=È 0¾¼ñ‘¿gÍr¿¿#“Ào?À-PÀVËàÀ€EiÀ•^õÀ©çˆÀ¿uÀÔR‡ÀçöCÀú*Á;Á¬ÉÁ“9Á »8Á*YöÁ4$åÁ>>ÁIÏ›ÁUžºÁaºÓÁnÁzµÁÁƒà‰Á‰+ðÁ‚³§ÁxÑëÁl¦CÁ`*ÁSâ¶ÁH(TÁ=Á2˜¿Á'¿‹ÁSHÁ“ÁÐÀüº)ÀçYeÀÒ~úÀ½A/À¨;ýÀ“o¿À~M­ÀW¡†À3¢ùÀH<¿äÌ¿©{-¿h•ä¿ å'¾mBŠ<Õµn>pÂí>ÄNþ>öÒi?>éÞQ>®¶}>.j™½ž½ ¾Àþ­¿99¿”N}¿ÒßøÀ ­áÀ1‰³ÀW¬¥À}ãƒÀ“CÀ§‘ëÀ¼?tÀÏøñÀãó–À÷EQÁWÁ ÁGÁGTÁöÚÁ&ÊÁ0hbÁ:PKÁD|µÁO]ôÁZàgÁfëõÁsAFÁµ¤Á†BŸÁŒ# Á…ÐÁ1ŽÁreÁeÿDÁZ²ÁN±*ÁCö>Á9§§Á.øjÁ$¹¶Á‚þÁtÁs1Àø§çÀäBdÀÐÅÀ»a­À§ÃâÀ”ãiÀ‚ØÀbÝÀBòrÀ$zoÀqp¿ßò¿²ÜS¿Z¿\k¿'ëi¿w¾Ü^ø¾Õ¿¾ï=¢¿Ò¿>_3¿w"¢¿ž¡R¿Çr¿ú¼üÀ¶À;I‹À]Ì0ÀH±À”À¦î´ÀºÁÀαÀỵÀô¨·ÁyIÁ ɧÁý<ÁIôÁ$ÇŽÁ-Ô*Á7,ÖÁA=:ÁKr¼ÁUúNÁa&OÁlàBÁyÁ‚ÇíÁ‰œÁ}êÁ‰Á‚ªyÁxÙSÁlÊÁa8²ÁV9}ÁK™oÁA&Á6ÍÁ,ªcÁ"¯¼ÁmÁ0GÁVvÀ÷Àã;]ÀÐXSÀ½…[À«X¸Àš@ À‰½EÀt¿ÏÀW"À=6lÀ$ÁƒÀÌ¡¿üP߿ީ¿Æˆ¿µ$Ì¿«“οªSn¿±·¿¾ e¿ÒJœ¿ì¬$À…{À_øÀ1ºÀLi–Àjá³À…ñ0À—…=À©<À»zSÀÍá—Àà`ÀójTÁÀÁ naÁ¶•Á îÁ$;Á,‘eÁ5–¯Á>ÿ ÁHÇÁS!kÁ]ŒÁh[dÁs¼¢Áœ±Á…õZÁŒ?²Á’×{ÁŒhgÁ†$~Á€ÁtqÁi@ðÁ^fAÁSœZÁI1zÁ?DÅÁ5`UÁ+“zÁ!ÔCÁPÁå,Ás³Àø3ÑÀåɈÀÓù°À SÀ²[\À¢rÀ““§À…¬ØÀráÀ[ »ÀG)À5¹DÀ't À³5ÀÀ)À4ùÀË"ÀX¹ÀªéÀ"¡SÀ.öÉÀ>•ÀQ 'Àf½±ÀMrÀüðÀ§8À­©À¾òYÀÐ ÷Àâ kÀó_Áƒ3Á §yÁÖ'ÁÁ#ã\Á,-Á5³Á>hÁGyÁQ+€Á[MµÁeÕŸÁpj#Á{nÁƒz¢Á‰w”Á¦·Á–^¸ÁþÁ‰þòÁ„éÁ|àOÁqÛÁfáXÁ\6bÁR íÁH¸Á>PÁ4‘òÁ+#QÁ!ÒžÁµ¿Á¹dÁɸÀü"ÀêÃfÀÚdúÀÊ_¦À»iùÀ¬â"ÀŸ¾ÃÀ“UÀˆ¥À~97ÀmÔžÀ`ðÀUAjÀMÉtÀJSÀÀIоÀMƒkÀS–À\"ÀhÒÀv›|ÀƒÀÕÀŽ€À™ðsÀ§d­Àµj»ÀÅ’ÀÔÅÀåxÀö†Á¤Á #øÁ¤>Áž½Á$GRÁ,&ÎÁ49–Á=›ÁF—ÁOæàÁY‚RÁcÊRÁnˆLÁy+ÁðÚÁ‡†uÁWÁ“]Áš;Á”ÐÁŽ1ÿÁˆ{lÁ‚é4Áz°¯ÁoÁ\ÁeV¤Á[¼ÁQ*-ÁG^Á=øOÁ4Ô0Á+ÖvÁ"ü[ÁC´Á¬‹Á = ÁñÀò(¥Àã¤ÀÔ+"ÀÆà›À¹ÜŒÀ®PÈÀ£ö÷ÀšÀ½À’ÀÀŒYªÀ‡m`Àƒ„'À‚8@À‚·ÀƒÇlÀ†³-ÀŠÿÛÀGÀ–õ ÀŸN{À¨ÓjÀ´<8ÀÀ@„ÀÍÔ<ÀÜpõÀëb|Àû) Áµ¢Á £VÁõIÁ Á%šçÁ-$ZÁ4åÿÁ=*jÁE£½ÁNëqÁXÌéÁaý!ÁkæÁvs/Á€ÈÁ†jMÁ‹æúÁ‘ÆÁ—hrÁžgæÁ˜uôÁ’¶ ÁŒð)Á‡S‡ÁÀ÷ÁxÆ3Án‚«Ád¿ÁZ¶ðÁQ ÁGúEÁ>ò“Á6ÉÁ-DÁ%(mÁÈâÁÒMÁ ßhÁ@–Àû˜ŒÀí ÛÀà½ÆÀÔN¢ÀÉ(ÛÀ¿ãÀ¶s5À®ØÊÀ¨|$À£ã…À 7+ÀŸF•ÀŸ2=À Í#À£©À§ôÀ¬üŸÀ³[áÀºÕÀÃÈ­ÀÎVÀÙå±ÀæGPÀô¶ÁÿÁ…7Á9iÁÜÿÁ{Á'}Á/ Á6d@Á>aXÁF¦ÁO%·ÁXÎÁa®wÁk@ÁtÉ)Á~ø+Á„ÝÁŠ~ÛÁYùÁ•þpÁ›ÀEÁ¢Ú\ÁœÜ`Á— ­Á‘[SÁ‹·'Á†=qÁMÁx3ŸÁn;tÁdp6Á[3 ÁRÁI>NÁ@˜åÁ8X›Á0$Á(.üÁ q&ÁÈÁoãÁ /ŠÁ®ÀúlÀîìFÀäzÀÚX ÀÒ UÀÊÆ2ÀÄÎ9ÀÀQ0À½!ŽÀ»ïÀ¼¿À½ÉÀÀkƒÀÄmÀÉéÀÏXÈÀÖ_ÔÀßkÀèìâÀó€„Àÿ-›Áö…Á «æÁµ²ÁÌ“Á"RÁÁ)ÈšÁ1HÁ9 Á@DÑÁH:ÁP !ÁY5»Áaä·Ák%¬ÁuÓÁ~^ŸÁ„Á‰JTÁŽ¿wÁ”o©ÁšTaÁ /(Á§&–Á¡NÁ›Œ¡Á•Ö/ÁM@Á‹ÒÁ…û.Á ÏÁxcÁnŒYÁe‘‚Á\šÁS¯)ÁKd:ÁCeŒÁ;Š|Á3©zÁ,("Á$ÒmÁ¡ÁêÜÁbIÁ UªÁ±ÀÿU¤ÀõÂðÀíîÀæ²xÀá RÀÜÖ2ÀÙì·ÀØ´ÌÀØýŸÀÚÀÓÀÝ.µÀá´Àå„8ÀëZPÀñýKÀú1±Á‹[Á†·Á CÁñiÁŽÁõÚÁ%Ú^Á,ÿðÁ4c;Á;ÆäÁCF>ÁJÊQÁR2ÁZíÑÁc¢ÀÁlbÁuJÈÁ~ØžÁ„IÁ‰ ÁŽ¿Á“OõÁ˜Ô¯ÁžœÁ¤{Á«±·Á¥ácÁ Áš‰jÁ•-(ÁžÁ‹+IÁ†lÁ)÷ÁyA¢Áp~”ÁgN©Á^¥ãÁV“FÁN¡ãÁFç0Á?KûÁ8dÁ0õ\Á*RÁ#­ÁSTÁ€Á)_Á 1”Á®JÁÄÌÁh,ÀýS>Àù€rÀö¸ Àõ…‘ÀõåíÀ÷‡§Àùö†Àý| ÁÿãÁ²?ÁÇ¢Á –Á¸HÁ}~ÁÃÁ,GÁ$c?Á*ZÁ1Á8&Á?VäÁFµ²ÁM×,ÁU…ÑÁ][}Áe‚hÁnJÁw3ÕÁ€Á„™úÁ‰†ÁŽ6>Á“ ‰Á˜)$Á‚hÁ£DÁ¨Ö:Á°S^Áª‡ƒÁ¤é®ÁŸøÁšOÞÁ•_aÁ;9Á‹ELÁ†š^Á‚;nÁ{o‡Árp‹Áj„ÁaÛ…ÁZ+ÁRdÁK53ÁD#ÝÁ=J­Á6žÅÁ0SÁ*e Á$©åÁ*Á³ÊÁ|OÁ”{ÁwâÁ ÖëÁ Á ĪÁ )Á mÁ !”Á cþÁ øKÁ4=Áƒ¿Á›ôÁùüÁ 1Á ŽmÁ%TÄÁ*¢¥Á0@ÞÁ6{ÚÁ<­EÁC2ýÁJ€úÁQÐûÁXëzÁ`‹ÁhhÃÁpœÁy zÁ•Á…•PÁŠ «ÁŽÂhÁ“©‘Á˜T‹ÁDKÁ¢r‹Á§ÙÁ­sâÁú£æÁôRIÁî*ÁçÜöÁá­ÛÁÛ‚öÁÕk€ÁÏ\CÁÉ[ËÁÃv_Á½–fÁ·¿FÁ±õ«Á¬A)Á¦—‚Á¡ÞÁ›Ü'Á–Ç®Á‘±«ÁŒµ\Á‡ÿgÁƒšßÁ~ùÏÁw —Áo¨XÁhímÁcbÁ^;ÁY²_ÁVÁS„ŽÁQŠ ÁPPšÁP@ÁPŠáÁQÆ4ÁT”ÁVÁgÁZx…Á^¤_Ác”WÁi‚ÇÁp8ƒÁw0Á~ê0Áƒ±´Áˆ0XÁŒÎÉÁ‘°VÁ–®Á›Õ®Á¡8BÁ¦ÉpÁ¬_ÞÁ²ðÁ·ÊÁ½®ÁÜÔÁÉ [ÁÏ¥ZÁÕÁRÁÛÜYÁá÷KÁè)æÁîwúÁöŸÁ酪ÁéM–Áã fÁÜÑIÁÖ *ÁÐyaÁÊ\„ÁÄF¯Á¾BBÁ¸[ÇÁ²z½Á¬¢Á¦ÖÝÁ¡"ÏÁ›z¶Á–vÁÌœÁ‹²öÁ†¢Á»,Áz<½Áq¬¢ÁiuåÁaÓ8ÁZßïÁT¯‡ÁO}ÁJæÁFÿDÁDGcÁBGªÁ@ùæÁ@ÙcÁA-&ÁBˆÁD°«ÁG–9ÁK… ÁOÑêÁUÝÁ[lQÁb3ôÁi‡UÁq±eÁz€þÁÉÎÁ†›)Á‹ž™Á¼ÇÁ–Á›¡ÖÁ¡9$Á¦çŸÁ¬²ËÁ²$Á¸|ZÁ¾ñÁÄ’HÁʰ¸ÁÐØˆÁÖõTÁÝ,ÒÁã€ÙÁéê¼Áñv†Áë (Áä¬SÁÞP{ÁØ •ÁÑȹÁË•+ÁÅsFÁ¿TtÁ¹7ñÁ³/’Á­B•Á§_;Á¡ˆ8Á›¿0Á– ëÁeêÁŠø:Á…¿FÁ€ŸPÁw9Ám¢GÁd¥¥Á\&ÁTìÁLæ¡ÁF~¾Á@æVÁ<æÁ8<Á5!nÁ3 @Á1ÁÁ1wóÁ1ÒÁ3M¯Á5a®Á8~>Á<ÇÁA/–ÁFÛ!ÁMzÂÁTf]Á\/oÁd¤Ám¥øÁw`Á€ïÁ…­)ÁŠÿÃÁ£Á–Á›ÊãÁ¡gÁ§u¡Á­]‚Á³gßÁ¹~·Á¿¢¼ÁÅÜìÁËûðÁÒ8“ÁØ’àÁÞ÷-ÁåNžÁíÁæŽoÁà»ÁÙ¼%ÁÓ\)ÁÍ4ÁÆÈ*ÁÀ Áºm{Á´N&Á®0ÙÁ¨$ùÁ¢/ŽÁœEÁ–s«Á°IÁŠþHÁ…[ÁéqÁuhÇÁkØÁaH=ÁWö?ÁO#ÄÁF¨ÇÁ?Á8`ùÁ2ŠÁ-^)Á)BŒÁ&pÁ#Ì6Á"£¢Á"&MÁ"{ûÁ$ˆÁ& óÁ)…FÁ-âÿÁ2É7Á8áÁ?™ºÁFíÁO0!ÁWÝIÁaÐÁk †ÁuQŒÁâ.Á…d0ÁŠñæÁ±WÁ–ˆÁœ_Á¢E5Á¨TçÁ®r¼Á´œÐÁºåáÁÁ –ÁÇNžÁÍ«dÁÔ ‰ÁÚn ÁàÝëÁèÏ‚Áâ=ºÁÛ°äÁÕ:ÁÎÕXÁÈrÁ±Á»ÑÁµ‘òÁ¯jÁ©GãÁ£/Á#EÁ—$^Á‘2UÁ‹fxÁ…«ÊÁõÍÁtº Áiî¸Á_Y[ÁU%ÁKz9ÁBvÁ9£Á1lÓÁ*RôÁ$Z&ÁÅiÁi‡Á4¢Á›lÁˆåÁénÁ6GÁÝ&Á¥ÁÀ½Á_ÈÁ$¬ÙÁ*üÍÁ1èaÁ9ÑzÁBE(ÁK:0ÁUÁ_WÁiÛûÁt¢¨Á¯*Á…›LÁ‹rŸÁ‘KƒÁ—55ÁJŠÁ£oüÁ© ¯Á¯ìrÁ¶%ëÁ¼oÖÁÂÈÁÉ)ÁÏ—“ÁÖ¹ÁÜŽÁ䡸ÁÞ Á×s+ÁÐ߈ÁÊaÁÃö—Á½’Á·9ÅÁ°å;ÁªŸºÁ¤pqÁžFòÁ˜4áÁ’,MÁŒ"âÁ†)ÝÁ€b>ÁuU ÁiöÁ^бÁTOÁIRéÁ?,¸Á5ÛsÁ,ý/Á$GÁ”èÁ3ÁxÓÁ «9Á^YÁ™tÁs±ÁÊÁfÁÉÁ#Á ;LÁÿ©Á®<Á‰Á$%Á,äÃÁ5‹$Á?GÁIj°ÁSóÇÁ^“@ÁiDÁuNÁ€_ÈÁ†@žÁŒ/yÁ’J»Á˜xuÁž°dÁ¤ü]Á«BXÁ±“¯Á·é¥Á¾QxÁÄÌÛÁËJJÁÑÁÛÁØP}Áà{ÁÙálÁÓJqÁ̲ÁÆ?Á¿“Á¹rÁ²³ÁÁ¬ZRÁ¦÷ÁŸºŸÁ™ƒHÁ“QüÁAzÁ‡<‹Á-€Áv\ÛÁjÇÁ_RêÁToÁHç¤Á>Á3jÁ)w?Á n+Á§ ÁOÁNñÁóÀúw5Àók Àí³ªÀë&ÀéÅSÀê>ÀíÕ]Àó OÀû™IÁÚdÁ²ÏÁx+Á’ÚÁ Á)^ˆÁ3žÁ>"ÁH¡ÁSŠšÁ_ ÏÁj°WÁv‚GÁ6¢Á‡X ÁŽÄÁ“Î Áš Á b7Á¦¹"Á­ùÁ³†ËÁºïÁÀ‡¦ÁÇÁÍ™¿ÁÔDuÁÜslÁÕÇ€ÁÏ%òÁÈŠ…ÁÁîºÁ»R¤Á´È«Á®K‚Á§Ö¦Á¡|8Á›-RÁ”ä|ÁŽ¥iÁˆkðÁ‚T}Áx–žÁl€BÁ`‡¶ÁTâ“ÁIV¸Á>rÁ3Á(B Á¶JÁDÁ CÒÁ¥âÀõÛ•Àé›`ÀÞs„ÀÖ¤„ÀÐñZÀÎÆÀÌžáÀÍt¿Àд@ÀÖ“/ÀÞÚÑÀé»×Àõ¼·ÁXªÁ õ$ÁêÁ×ËÁ(FNÁ2ÓèÁ=ª©ÁI"fÁT¿ªÁ` ×ÁlœŽÁxëæÁ‚¶_ÁˆúÚÁ@ÒÁ•‹5Á›ì¡Á¢U Á¨ÍDÁ¯\UÁµÐÂÁ¼U5ÁÂóÁÉž*ÁÐ@qÁØ}ÒÁÑÏÁË#¶ÁÄzÜÁ½Ö¨Á·3¾Á°‘³Á©ÿæÁ£‚DÁ‡Á–¦×Á[cÁŠnÁƒÓ)Á{1cÁnðJÁbÄŠÁV¿#ÁJß-Á?!Á3Á(PôÁCÁ¨¯ÁNöÀþ÷ÀìýÀÜnÀÎù˜Àè;Àº¾=Àµ>À±eÀ°CÀ±=·À´‰†Àº‡IÀÂà<ÀÎ5ÉÀÛ:½ÀëÔËÀýº}Áf‘ÁÿÁ&Á'ýËÁ3g0Á>øÁJæzÁVö×ÁcRlÁoçóÁ|týÁ„{^ÁŠÇ|Á‘3ÔÁ—§ªÁž"ÚÁ¤¦KÁ«*GÁ±¹øÁ¸RøÁ¾øÁŧnÁÌZüÁÔº"ÁÍî‡ÁÇ9ÈÁÀÆÁ¹ãPÁ³6Á¬‹tÁ¥ârÁŸFíÁ˜ÆßÁ’IÍÁ‹áõÁ…ŽÐÁ~ƒ ÁrÿÁeµvÁYcŽÁM½ÁA"aÁ5g¾Á)‘©Áà-ÁÄÁÏaÀúÖÔÀæ¾ãÀÔàÀþÀµ½À©…šÀŸëíÀ™reÀ•v4À”7À•<^À™XJÀžð‘À¨<À³›7ÀÂaÊÀÔ+Àæ±Àú‘Á¥ÿÁšÁë×Á)ifÁ5a=ÁAŠ*ÁMð­ÁZ”aÁg5Ás–jÁ€Á†“eÁ „Á“~ìÁšÁ —|Á§'*Á­¸¹Á´dÚÁ»";ÁÁÌÁÈñÁÑ(ÁÊI‚ÁÃtØÁ¼·”Á¶ qÁ¯_•Á¨«øÁ¡ùŒÁ›I–Á”¤fÁŽÛÁ‡£÷Á4ßÁu±üÁiÁ\Ÿ?ÁPCîÁCò±Á7­8Á+³ÓÁømÁ*ïÁ”ÑÀû/kÀå"ÀÑ;qÀ½Ê’À¬2À›¸ÝÀŒÑÀ…7À|nÄÀuøÀr„/Às…žÀ| àÀ„³•ÀŽåƒÀ›}ÀªÃ„À¼Ë¬ÀÐ;ÀäÜAÀûËÁË&Á,Á &‹Á,g³Á8ÀBÁEIŠÁQÑ7Á^h¦ÁkÔÁwþÃÁ‚s6Áˆç­ÁudÁ–QÁœœžÁ£3QÁ©æÁ°šßÁ·D´Á¾§ÁÄÒÜÁÍ« ÁÆÊŽÁ¿îÁ¹€Á²DvÁ« Á¤ÞŽÁž+ÞÁ—‚"ÁÌ ÁŠ€Áƒ’-Áz1ýÁmLÁ`‚éÁSÆÁGLXÁ:Þ>Á.¢ÆÁ"†)Á‰kÁ £±ÀýýµÀçÓÀÑ®ŠÀ¼ÁÀ¨À• +À„¾Àn¤7ÀXBIÀJàáÀBª­À?rþÀA•ûÀG1kÀWu¡Àl^ÀƒåôÀ“¾ÂÀ§S§À»Š©ÀÑ!Àç›õÀþ½ËÁ 5.ÁcÓÁ#¹†Á0¸Á<ŘÁI„ÁVôÁbâÜÁoÛÂÁ|ß Á„ýÁ‹’ÙÁ’'sÁ˜ÂòÁŸm„Á¦¢Á¬Õ³Á³š¿ÁºpäÁÁG~ÁÊf™ÁÃg6Á¼xÉÁµ™óÁ®¸TÁ§ÜZÁ¡Ášf Á“³óÁ9Á†jEÁq±ÁrB«ÁeNjÁX[+ÁKŠ*Á>Õ”Á2JÁ%ÄØÁ—“Á ˆ¤Á¤ÀëafÀÔrËÀ¾ ]À¨@%À’ñÀ€À]éUÀA®›À+Æ7Àx¡À•ˆÀÌ’Àû„À&[À(DÀ?brÀ[êDÀ= À“ˆõÀ§ìþÀ¾rÀÕ¦¹Àí!±ÁsÍÁÚHÁNkÁ(^Á4ÝÁÁAJoÁN QÁ[ [Áh6ÁuÁ%NÁ‡ÎôÁŽXÊÁ•VÁ›¾ÿÁ¢ƒåÁ©LÌÁ°"Á¶ùÁ½ÖbÁÇEiÁÀ<ÑÁ¹4%Á²4|Á«IwÁ¤j.Á‹¥Á–¾˜Á \Á‰XuÁ‚¯VÁxüÁjÊÁ]HÁPmñÁCyðÁ6¡Á*–Á”tÁ…ÁáWÀñ`bÀÙĹÀÂÊ@À¬ uÀ•À€*ÀYŸÊÀ7 YÀ±™ÀJ¿âKH¿Ò˜¿Ì=Ë¿ÐSØ¿à`¿ÿsÀbŽÀ68vÀXÁ“À€ÔvÀ–$ÜÀ¬÷ÈÀÄt–ÀÜ;'Àõ#%ÁÁ».Á E Á,×(Á9˜…ÁF••ÁSnñÁ`b–Ám³¾ÁzøÁ„jÁе¨Á‘‚Á˜F³ÁŸºÁ¥Ú¾Á¬¿ÑÁ³¬\Áº™‚ÁÄ@Á½"BÁ¶’Á¯SÁ¨ eÁ¡WÁš7&Á“]©ÁŒŠÁ…Ò¿Á~HÁpéÁc‹”ÁV:ÁHîuÁ;ÇjÁ.ß2Á"ÎÁ{FÁö‡ÀùŽûÀá=/ÀÉÕÀ±âêÀ› …À„Ø¿À`O‚À8÷’À;+¿êÞz¿¿§?¿¶1¿ŠÖ¿‡c¼¿‰äG¿›èE¿»œf¿çù¶ÀÖÀ9ëïÀbäsÀ†ðÏÀñnÀµkìÀÍésÀæSÏÀÿBÁ 2AÁÜçÁ%u¯Á248Á?bÁLËÁYlùÁf“4Ás½ŸÁ€ŽáÁ‡T1ÁŽÁ”ÔÁ›³zÁ¢£ƒÁ©ŽŒÁ°wEÁ·p;ÁÁn—ÁºD)Á³ÙÁ¬ØÁ¥ Áž¬Á— ¸Á%êÁ‰SûÁ‚ƒ_Áw|ÁjØÁ\ØôÁOmÃÁBÀÁ4ÏÛÁ'¡çÁÎÁ Á{3ÀéèvÀчÀ¹êiÁKÂØÁXþÃÁf“¦Át36Á€ËÁ‡ž~Á޶Á•ŽÏÁœyÁ£šêÁªºbÁ±è¾Á¼M¡ÁµÃÁ­ÒoÁ¦­yÁŸÓÁ˜oŽÁ‘^ÁŠ^ËÁƒm.Áxþ$Ák%±Á]z¸ÁOÝGÁB\9Á5!œÁ'ëìÁ¸Á аÁ¬?Àç·yÀÎÚüÀ¶b«Àž¾˜À‡b÷Àc9À8Z¢ÀÈ¿àXU¿¨g¿wµñ¿<¼—¿r¾ÿJ¾ñøò>¿ß¿8êõ¿ƒÛÞ¿³‰Ý¿ô6—ÀS?ÀG†$Àr°ÑÀšÈÀ§´wÀ¿—ÏÀ׺ÀñaÁuÁÏÁm“Á+vÿÁ8qÈÁEª`ÁS.:Á`‰*ÁmñÁ{¤¶Á„ÌæÁ‹ØÁÁ’ç Á™õÁ¡HÁ¨;öÁ¯n§Áº'Á²Ä–Á«†(Á¤JÇÁ_Á•ôýÁŽÙ±Á‡ÆYÁ€³´Ásk Áe¢ ÁWç’ÁJG+Á<Ò4Á/mŒÁ"ArÁ ]ÁØÀõîãÀÜõÀÚþÀ«žÌÀ”•ÀzÀO £À&ð³ÀF!¿ÊhN¿™o¿hRù¿8þ¿&Ò¿ cÕ¿é¿K©¿6¿8ž«¿pW6¿¤x´¿ÜèÚÀÀ8ˆsÀ`õÜÀ†F—ÀÀÀ´»/ÀÌÒ¢ÀæHÀþ“ˆÁ ² Áº Á%ÌÁ2¶ÁÁ?ÿ\ÁMjóÁZà•Áh™†Áv˜ÉÁ‚cPÁ‰`½Á`µÁ—yîÁž©Á¥ê¥Á­3óÁ·ò›Á°¢KÁ©]'Á¢ ¸ÁšäÁ“¦ÜÁŒq"Á…RÁ|‚ÁniÁ`€´ÁRÃ\ÁE;ÝÁ7ɸÁ*h¦Á,Áí×Áø?ÀìëÀÒôÀº7À¡¤@ÀŠÀgÜÀ?QÀÀuٿ󔿽¯x¿“/7¿j‚׿B¯³¿)û¥¿À,¹ÚÀT9æÀ}õBÀ•(êÀ«‡eÀÃÍ.ÀÜ¡ÀôCÞÁóàÁ£LÁ OxÁ-ˆ$Á; çÁHŽÁV=Ád.QÁr#(ÁýþÁ‡ÁŽÁÁ•TiÁœ˜Á£ßºÁ«‰Á¶ Á®È•Á§mÊÁ ñÁ˜ÉœÁ‘¨ÁŠ^¼Áƒ2;Áx UÁjÎÁ\-ÁNTeÁ@¡)Á3OÁ%Ÿ#ÁMÄÁ ZÀüT×ÀâåäÀÉÔ˜À±À™ÇÀƒN^À](‡À6‰À~¿ëK ¿»Mq¿–$„¿vœ¿Ru{¿<9¡¿-­Ð¿%ñY¿(cÿ¿4;U¿M¿^¿|ûr¿¡*Q¿Í¨ÖÀËOÀ$ žÀJ¤4ÀqïÀŽ”&À¤wÙÀ¼IÑÀÓú¬Àëû?ÁˆbÁ¹Á'MÁ) ÀÁ6ÛÞÁDE¸ÁR}Á_õvÁmåFÁ{êAÁ…êÁŒ9[Á“kÏÁšªgÁ¡ïvÁ©7Á´iÉÁ­!Á¥¨çÁžSÊÁ—/ÁµGÁˆx·ÁRûÁtuõÁfV6ÁXSÕÁJ‹ãÁ<ОÁ/ žÁ!—ØÁ9ÎÁ4]Àõ KÀÜ0ÓÀËÀ«È×À”‘åÀ}€AÀTÀbÀ0¢À›i¿ì¸!¿ÁcF¿ËZ¿ƒ" ¿`ï]¿C‚¿-ì#¿$¤¥¿&Rc¿6ñ%¿Z懿„»H¿¥¿Ï²ÕÀ”KÀ ïÀD9àÀj7À‰øßÀŸ#nÀ¶BÀÍ ÀåA>ÀþK Á ¯Á¬ÈÁ%¿-Á2þ¬Á@¨ÁNœ=Á\˜ŸÁj{ÆÁxyÐÁƒNvÁŠy&Á‘º Á™ŒÁ XgÁ§¨BÁ³jÁ«‡¯Á¤àÁœºuÁ•k‘ÁŽ*—Á†ïëÁxÎÁq4jÁc+ÁU@@ÁGU‰Á9€Á+¾EÁ$ÈÁüÁ7_Àï_GÀÖƒÑÀ½úíÀ¦Ì€ÀrÀx´eÀRcwÀ08¯À~¿óO¿É,Í¿¥'}¿‰f¿\Zü¿8wV¿@Z¿kx¿‹#¿+Õ¿V†í¿…–¿©ºÉ¿Óð¾ÀéÀ È ÀA²áÀfPÖÀ‡+4À›{äÀ±ZÐÀÇ´ÀßÞ$Àø2ÁÞ–ÁÒµÁ"çÙÁ0HÁ> ÁKÕûÁYšNÁgmyÁuÁäýÁ‰–ÁYÃÁ—›ŽÁžácÁ¦2±Á±×ÅÁª_ÂÁ¢ëVÁ›}ÛÁ”YÁŒÒxÁ…šÁ|î™ÁnÁœÁ`«çÁR©ÇÁD®äÁ6¾,Á)ãÁÉÁ³+Áô¶ÀêÇ-ÀÑúcÀºÖŒÀ¤ÎÀÌÀvÑ­ÀSÍmÀ3CùÀ<Û¿üÖ†¿ÏL´¿§ºX¿–ó¿?ËÔ¿¿¾Ôûß¾¸¶ž¾Íä°¿„·¿8\¿€|s¿¨‘k¿×›ÇÀ6À!Ê ÀCMÀewQÀ…uõÀ™h%À¯IÀį¥ÀÜ)æÀôÿýÁùöÁ…Á ~-Á-ø„Á;ÄVÁI•dÁW^`ÁeOÁsyCÁ€ØÛÁ‡ý–Á)¸Á–díÁ³%Á¥ÙÁ°ÖCÁ©c”Á¡úùÁš˜|Á“<#Á‹çÁ„¡çÁzæöÁl¾±Á^©†ÁP”ŽÁB˜œÁ4å$Á'ioÁ1°Á WOÁ[Àçò7ÀÐF&À¹é‘À£ñDÀžnÀzùÀW{À8@±ÀY¾À¯7¿Í!}¿˜â:¿P*Œ¾ÿVþ¾…ÊŠ½Ìs½+Þt½¶u€¾õ¾ÿ^~¿V’Ý¿œ§m¿Òè¤ÀIíÀ%1ÀEš-ÀgÖÀ†JVÀ™9À®ªÀÄÀÛ3ÝÀó…YÁè¼ÁK'ÁIkÁ,Á”Á:H¯ÁGÍÏÁU‘=ÁcŸ—ÁqЇÁ€ËÁ‡ÁŽMRÁ•“/Áœë+Á¤RØÁ°Á¨¦ØÁ¡AÀÁ™â(Á’’AÁ‹PBÁ„¶ÁyÑøÁk~¿Á]RùÁOHÌÁAgÁ3¸Á&a«Á…™Á Ì'ÁñÀçǪÀг(Àºˆ+À¥8±À‘éˆÀ6YÀ]ŽÀ!óó>¿?>âfB>Èæp>Gåc½ø§€¿åø¿€­¿Ã¥òÀqLÀ&(¶ÀI/UÀlòÄÀˆ²šÀ›pÀ°9ÀÅ`IÀÛÑÊÀó>ùÁx«Á¿>Á¯ØÁ, ,Á9mpÁFëQÁT¼ÆÁbÒæÁp÷RÁƒÁ†¬ÂÁã<Á•.EÁœŠÓÁ£ïUÁ¯‚ÜÁ¨%ÂÁ ÐÁ™nÁ’4†ÁŠó¦ÁƒÄ<Áy.(ÁjÔ‡Á\VÁNŒ„Á@×ÛÁ3|µÁ&pªÁ‰™Á ×ÚÁ‡TÀéš+ÀÓ8À¼àGÀ¨¡LÀ•EþÀƒtÀa¦¿À<Ÿ7ÀWw¿×A:¿Œ(í¿ ÝY½&B“>Æ'Þ?<”]?våä?‡â¨?}5ã?A?á>Á°÷½ÏcF¿&×e¿¥¿óM¿À"ùÀJ¶Àr0ôÀ‹ä+ÀŸ4@À³>9ÀÈKQÀÞB®ÀôúÁjOÁ”cÁVÙÁ,O÷Á9G{ÁF¯ÇÁTtÁb‚ÊÁp«®Á~Ö‰Á†‡«Á»+Á•fÁœ]“Á£À5Á«>ãÁ¥Z¯ÁŸ¢ûÁ™_œÁ’*ŸÁŠþ”Áƒ×@Áy^ØÁk‚Á\ì‚ÁNøÅÁAKÐÁ4Á'íÁN÷Á ³ÃÁÓÀìÕÝÀÖ\uÀÁU:À¬þÙÀ™¬iÀ„…ùÀZ´KÀ,x¿ÿ]·¿¨7*¿)ž´½sŽ>úiŒ?zÁó?®Ï?ÓŸò?èTg?Ùï ?·‚?{£Ó>Ï2–¾‡®¿pci¿Ø~žÀ¤IÀHSúÀs“OÀŽìÀ£;À¶ø ÀÌúÀâ/åÀø0Áþ§ÁäÁ W,Á,ìÁ9ØÁG6¡ÁTò'ÁbíMÁpóÞÁaÁ†š‘ÁÌõÁ•IÁœaaÁ£³úÁ§,¸Á¡"nÁ›E‰Á•™ƒÁÿäÁ‰¦Á‚~EÁvŸBÁh:ÁYïÁKß–Á=ßéÁ/ð—Á"=¨ÁÖÒÁ£CÀõÑÊÀÝØÀÄ®†À®ÓÀ—¿ÅÀ‚Ñ¢À\  À5#¸À X￾¢¶¿Q¤¾&¬>ÿy?PÍ?ÑÊŒ@ž³@±{@&Y‹@ F•@w"?Ê•Ÿ?oz>c'X¿T…¿¦¦<Àª’À8»`ÀlŸÀ´ÙÀ¦k2À¼KÀÑ¢6Àç:ÀýZ]Á qÁvÁ"«NÁ.þúÁ;ÆiÁI=ÁVœIÁdhtÁr=*Á€¡Á‡&¼ÁŽN?Á•~ßÁœ¶ìÁ£7PÁ£+ãÁ5xÁ—1ŸÁ‘^ÌÁ‹¾(Á†ÝÁ~,yÁoÏÁagVÁRü!ÁDtúÁ6+¬Á("õÁ#ÜÁ ?Àýf€À⺕ÀÈÛ,À¯ÿÖÀ—vóÀ€ÅÀU7™À+TTÀ)!¿·5]¿NÇ–¾7é7>ùÜž?5¶?ÛmÁ@"è@4ÿ’@N^%@]Ë @S¬@5¸@ K’?¼åT??q™¼_*¼¿J¿Êƒ6ÀTÀH<6Ày!ÌÀ”½(À­‘%ÀÆh¡Àß²YÀùø=Á ¡Á3àÁ$ÍÁ1÷ƒÁ>sLÁKmIÁXÊxÁfZ8Át °Á€õÁ‡>ÁAÁ“TÁ™(ÁŸXàÁžüªÁ™.Á“] ÁnÃÁ‡¯Á‚@Áw Ái åÁZ°ÁLR…Á=Ü‘Á/AžÁ °Ái‡ÁfUÀìÍjÀÑ4 À¶k)ÀœŽÀ‚öÓÀTŽâÀ'Y¿õè*¿¢ Æ¿'Vm½i/?Ô?–ê‚?ì2@ÞÌ@B.Ê@cæ @€¨Æ@‹š@ƒ2@_ç@3Þ³@æs?©M? Íw¾^y¿|þ¿Þ;À\íÀOÆ×À€¶ƒÀ™‘óÀ³?ÐÀÍoMÀç’RÁ&Á÷ Á«§Á*w'Á8’ÁFìëÁUAHÁc‡–Áo  Á{)Áƒf–Á‰5bÁ-‹Á•UgÁ›¨8Á›?Á•œÁ>}Á‰ƒ½ÁƒÂhÁ|%tÁp¼ÚÁc sÁTR4ÁE§ÈÁ7$ÍÁ(©×Á.áÁ ŒÝÀùׄÀÝSmÀÁSiÀ¥SŸÀŠ$À^àËÀ+Þ“¿ô¿˜¿™ f¿ÂD>Õ^?=÷ª?®.Æ?û¿l@#yˆ@K\™@p_&@‰Ù?@š7ä@¦”°@›YB@…=@[û\@,]ø?öt‘?” >Ñîã¾®™]¿‹0¿ì$fÀ'·ÁÀYzÀ†ÃWÀ æ\À»&FÀÖ˜Àò”Á¼—ÁÍ6Á#,¶Á1£ÂÁ@wÁNu5Á\€Ágõ¶ÁsoXÁ~ð Á…cÝÁ‹„×Á‘ÔAÁ˜LWÁ—Š‹Á‘^"Á‹aNÁ…˜½ÁÂÁta Ái-ŠÁ]/™ÁNkEÁ? Á0ÜáÁ"NÁjÆÁïÌÀìé«ÀϹšÀ²Q À•ÙáÀs´PÀ;à.ÀQ[¿£»>¿7>_¯:?fKË?Äæ¿@Ñp@/äÐ@V\@{±(@J@¢sÚ@³Òá@Â,]@±-R@™mR@ãz@S6@#—ó?ç“Ç?ˆ)>¡Í‘¾â応•À¾À4tËÀhºÕÀ/ñÀª·ÚÀÆúÀâ½ÀþÙÁ ãÁo)Á+ Á9œMÁHEÜÁUAkÁ`žªÁlÕÁw¹˜Áò»Áˆ;_Áޝ‡Á•;Á”S„ÁŽXÁ‡à±ÁòÁxo4Ám dÁaÑ2ÁVÒAÁHæ€Á:#}Á+=¬ÁZcÁ bÀüÕŸÀßfÀÂk€À¥u”ÀˆY|ÀU¢ÀÁA¿Éƒž¿7 Q=ôªv?gü?Ðù4@Öw@;Õm@b$ö@„l9@—RÈ@©¤g@»yD@Í2Ï@ܵ²@Å`¸@­Ý‹@–Õ@}3ð@MUë@Ü?Ü*q?ud{>;7t¿'¿¶ÅÓÀË3ÀFÐ?À}„Àš‡+À·XŸÀÔF½Àñb ÁU Á+Á$ÌãÁ3…ÒÁBSÁNbÁYʬÁeQìÁq[ßÁ}ÔÉÁ…FJÁ‹¶Á’5íÁ‘{ Á‹ ÎÁ„ÃúÁ}`ÁqªÐÁfW¯Á[¬ÁOõ3ÁC{>Á4äÁ&Á Á'CÀò‚äÀÔ!›ÀµÐ­À˜ËÀuîÑÀ<ùÀò½¿¨Ò¾\ëô?(ÜL?Àg6@ÖE@Bþ@@nú@ŠŸ½@¹a@°æ @Ãw‰@ÕC@æáD@ñ±³@ÚZí@Âݵ@«gö@“Žì@w¶ó@H)(@á?Ë“q?H(ƽAå¿`Ã+¿ÝÉ?À%ûùÀ_°rÀŒÆ‘À©ígÀÇcæÀåÀÁjÁCÁ/ÉÁ.)áÁ<–ëÁHL_ÁS¼"Á_’ Ák¿¹Áx(Á‚jKÁˆë¬ÁtpÁŽãpÁˆsŒÁ‚UÁw¹Ák¼Á`?IÁUbÁIµWÁ>?ËÁ0ŽÁ!!‹ÁíÁú/ÀçíVÀÉñ'À«ñ_ÀšqÀ^m÷À!ºÃ¿Î D¿4k(>Mð?×¥@#Â@8ÂA@mçc@Ž¿ó@¤.¿@·UÖ@ÊE[@Ý0V@ï!A{XAP@ï¬w@Ø5ô@À€O@¨Èñ@‘!?@pÅÞ@?†«@ )?¬êW>ýÖ§¾·È¿¡_JÀ Ž—ÀE7=À€l-ÀžbÐÀ¼tðÀÚæÀøÄÄÁ ~³Á”<Á)WüÁ7-ÁBüÄÁN!ÁZGÖÁf`MÁrëÎÁθÁ†/ÞÁŒH]ÁŒl”Á†*ÁYgÁr²ŠÁfq‘ÁZ¬¢ÁORÀÁD ÄÁ8†ÿÁ+?KÁÐÅÁ Ì Àýb ÀÞº7ÀÀ%±À¡¢ùÀƒ_ÚÀJ¼}À&¿¢¿F¾¤Å´?†3?ÚÊ@¼G@V¬ @ˆ "@£b7@¼Ç@Ñç@ä `@öÑ]A¨A šJADA†ø@íq±@Õº@¾@¥^@ŒMQ@d2!@.ZI?ïLé?yDž=ˆ¿J¿^W¿ç)LÀ/’•Àl¸vÀ•À³¥ÔÀÒVÀðŸÈÁ•OÁ/Á%VÁ2‡dÁ>SRÁIªIÁUhNÁa–Án"NÁzg‚ÁƒTÁ‰x,Á‰òsÁƒŠÁzaoÁmÑqÁahxÁU[ÂÁI×¼Á>éÁ3#/Á&ôÒÁŒnÁ ߥÀõºtÀ×ÉÀ¸È ÀšMÀvqÀ9 e¿÷R¨¿y¼ŒÅ?nºÃ?ðë:@5<‰@pµ”@•SŸ@²¶$@Ï„c@éAš@ýÎJAa’A®±Aã6Aú¶A 2xAa @êìÉ@Òmþ@¸×M@ž|ß@ƒ"ô@MQô@ë&?«8Ç>Íx!¿ Ì¿Á¶À‡jÀ\C¾À»À¬\ÀË2lÀéžùÁܧÁ©ÅÁ üÁÁ-øÒÁ9§ÙÁE"ÁP´ÄÁ\ØÁi!¶Áuk„Á€Ú´Á‡Á‡–^Á33Áu£¶Ái%+Á\óÁPõ¾ÁE>Á9åŸÁ.|šÁ"Á£ŸÁ2JÀîZÿÀÐçÀ±ÍwÀ’ÕÏÀgá À*Kˆ¿Ùx¿=]>déQ?˜ç¯@ ™@H¯¸@‚¾1@¡$†@¿ˆå@ÜÉ@úºA A7ABwA¦ŸA'í]A#³žAç`A ð&@ÿvº@åaI@Êr¯@®½@Ô@b S@#ŽÉ?Ë?áÀ¾¼¡&¿¬ÁsÀ•ÀSgôÀˆ¡ŸÀ§{ÀÅÙ.ÀäaÁ.úÁ¥ÜÁº@Á*5Á5URÁ@ž-ÁLvÁX–hÁdɲÁq Á}YuÁ„óŠÁ…¡áÁ~lxÁq½*Áe+ÁXÕûÁMeÁAA‡Á5§›Á*^ÿÁ2Át9Áö¢Àè8ÀÉôDÀ«–@À8;À\ȹÀýŒ¿Â(p¿ e>Ùɳ?³ƒ¬@^I@WÒ@Šªw@©Ì…@ÈãG@ç¢A:AKA ÀuA(èA(?ÛA(cÐA"sŒAÃAá4@ôf@ÔK»@´­@•+@kXë@,ZÕ?Ú4!?7R_¾ˆÑØ¿žÑ½À £)ÀKÝtÀ… ßÀ£bÀÁ»/Àß«:Àüì(Á ÂÚÁ®ãÁ&à»Á1Þ3Á=<;ÁIèÁTùÁ`ñÔÁmÁyV”ÁƒÕÁ„"/Á{F6Án EÁb‡ÁU­£ÁI£cÁ=ÀÈÁ1ð’Á&¥ÏÁEÁIêÁDõÀâ÷‘ÀÅ*£À¦Ñ!Àˆ;KÀR¼%Àú}¿®kS¾Ë{C? .?ÇXƒ@"x@aq@üÝ@¯A-@ΚÝ@íýIA¯ÛAa}A&ßA'ÿŽA'çäA(8€A(zaA iA íˆ@ôU-@ÔÐv@µK¾@•Ç@l¤²@.7ž?ßJ?C̾_óò¿™ŠâÀ ewÀGÝÀ‚§ˆÀ¡ßÀ¿PFÀÜËÝÀù¨‰Á ¶iÁçÁ#¦CÁ.ž†Á:þÁEïrÁQÔ†Á]»kÁiÉ×ÁvH¡Á•ÁƒùÁxìõÁkö¾Á_OÁRü¬ÁFÊ‹Á:¹òÁ/.)Á#òRÁ`†Á ¹{ÀûÃüÀÞ·?ÀÀÆDÀ¢XÔÀƒù—ÀK¶À $¿ž…¾ŒC?1¨y?Ö/@)Ѽ@h£æ@“»@³$@Ò”€@òqAÓKAœ.A'ÄA'§òA'ðA'à>A%Ä’Aµ#Agð@ð<}@ÑxH@²¢L@“â&@j °@+ª?Ú?;Œ³¾fw…¿—¿ÁÀ ”!ÀF÷ÀÇÀ žÀ½|ÃÀÚ˜À÷!OÁ 8®ÁhÁ!¦Á+þ—Á7ˆcÁCvÚÁO]ÐÁ[KÔÁg—xÁt=¼Á€œ»Á‚EÁvóÙÁiͰÁ\úÁP–óÁDŠ“Á8ЬÁ,ìÇÁ!¤–Á(oÁ §Àø‹ ÀÛzžÀ½¼­ÀŸvÀ3ÃÀEKÀ’<¿•’¾GíÄ?D˜ÿ?ß>o@./@l‘@•pz@´¡¯@Ôè@ó{xA {”AÒA'lzA'PVA'8A'‡üA iÇA £A4È@虨@ÊŽÚ@¬…J@Ž}¿@_àO@"œW?Ì{?'{¾˜f‡¿ I·À s†ÀH¶À‚…4ÀŸí©À½qÀÙ8!Àõ8‡ÁM°ÁÝÁBÓÁ)ÿÌÁ5X?ÁAAÁL÷ÌÁY=ÙÁeäÊÁrÝzÁ€ ¿Á:õÁucÎÁh~pÁ[¦ËÁO ×ÁBÛÜÁ7àÁ+wXÁÿ¯ÁR¦Á7ÀöwÀÙROÀ»µüÀè˜ÀÀB‘‘Àæ¿’äÚ¾<×á?F¬ ?Ý8ô@,”š@jØ™@”&¡@²+@ÑOÒ@ð4AMqAZ2A!:%A$°µA&Ý£A%3gA,A ¢ @úê%@ÞŽl@Á³7@¤q!@‡Û@Rµ @û?¶Aî>ù·þ¾Ý%s¿­€À­íÀMßbÀƒþ¯À¡p‹À¾Ž¶ÀÚLvÀõGÁ€Á6?ÁÄÁ(œéÁ3€õÁ>ðYÁJýÁWŽtÁd‰pÁqŸ¶Á~¸*Á€ÉØÁtzDÁg”ÁZ¯˜ÁMçÁA”ÞÁ5ÕÁ*r@ÁøZÁ‡BÁ€/ÀôÀØ@À»{À ƒÀ†ÀC¡^Àœ^¿˜#:¾}K?4Æ´?Òé¿@%¡@b@Næ@­?L@ʪe@è ìA=&A ÐA¤ÎA¨(AÓ³AÿARãAj.@ìú°@Ñâ9@¶0ž@š0š@z¿@@@Ì¡?™k#>”nb¿°Õ¿Äú7À?ÊÀV>®ÀˆeÀ¤@óÀÀUBÀÜ€Àö¬ØÁœ×Áã„Á•JÁ'̺Á2ŒáÁ> ÁJ%wÁVÃÁcË’Ápó»Á~;Á€ÕûÁtqnÁgjwÁZ^ÁMʽÁAŠGÁ5³¨Á*°Á~3Á¸ÁÆnÀômäÀÙ?ïÀ¼z ÀŸVßÀëŽÀIk©À‰a¿¥ о»aà? ûå?»¨W@ty@SF@†ÙŒ@£…²@¿‚‘@Ú‘v@ð%¡@þÉŽAöZAËAÀìAŽAa@òü @Û“2@Â0Ð@¨(@“-@cQ^@, ?æ’z?i_p<›Šë¿]%P¿ß¾gÀ(§fÀ`ýáÀŒ¹‡À¨ßèÀÄCÀÞÈRÀøY&ÁÜYÁ15Á(Á(J¶Á3ƒÁ>xGÁJŠ“ÁWåÁd"ÁqVÄÁ~QÁ+ÁtÚ;Ág‰ÛÁZ‹ÁMøÀÁAçÖÁ6§Á*WÁÄ?Á(ÄÁnÀõÒ™ÀÚ±ÊÀ¾¶pÀ¢a8À† ÀQÚ¨À|_¿¾®¿Ed>ž‘ö?›±!@¹‰@?1‘@uô£@–±@¯Ç—@Æ)@Öjç@â1ú@ê_W@ïëÀ@óLÕ@ò>ß@ê@Ü+ÿ@Çt@°lŸ@—´Ã@|š @HG@Ä ?¶¨M?Uˆ¾–4®¿“h&À{ÖÀ85/Ào{–À“J:À®†FÀÉ6¡Àã@kÀû›äÁ .Á÷ÁOÁ)fÁ4Á?`}ÁKYãÁWئÁdÆíÁrOÁeƒÁ^æÁu‹îÁhy˜Á[’•ÁOÁBÖmÁ6ÅÁ+ 0Á³ÑÁ#HÁT›À÷í¹ÀÞ˜GÀÃ’ÉÀ§œ»À‹âÀ_ÕkÀ'´!¿Ý°=¿^}_»=BÆ?^pf?ÜN@$i¤@XRÝ@…X]@šçˆ@¬÷/@º×z@Å]<@ÌÐI@Ò¡@Õ.@ÔÄ@ÍÃa@‡=@°«O@œ"!@…4@Z€$@(ͯ?ém#?‚1~>5m¿*•¿Á·ÏÀåÀK:üÀ€‡„À›ÆÀµÄðÀÏ3ÝÀè~sÁ% Á !Á|öÁ ]VÁ*ÀàÁ5K,Á@“âÁL|SÁXê1ÁeÇ×ÁréïÁ€ “Áü›ÁvùÙÁj83Á]{ÖÁPûwÁD”¿Á8rBÁ,ê×Á!¡OÁ Á —†ÀüȳÀ㎚ÀÉ)*À®½íÀ“¯âÀq¿À;°À€ ¿›àï¾Ä¿¥>èn?£‰L@;(@4È~@`œ>@‚÷…@’Œx@žÔº@¨—@¯MÇ@´`i@·#D@¶`@°šC@¦ëÇ@˜)@…•—@bC@4˜@4l?©Æñ?iÀ¾‰Ý¿Š¥é¿óeÀ-ŠÒÀbdÀŠõŽÀ¤‰ÂÀ¾,¤À×'µÀïÁýZÁ ”ÁînÁ"5jÁ,F^Á6ÓÁBÆÁNãÁZq‡ÁgMXÁtjŠÁ€ÅYÁƒ¡Áy>Ál^Á_”…ÁS0¨ÁGÁ;/öÁ/®Á$¿ÁŒÁ ;Á+NÀêMÀÑ]AÀ·¡!À±VÀ‚û†ÀQsüÀü`¿ÐT]¿PÙ%¼áv ?BØ4?¿ \@ ذ@1Ë@R3@n¯1@‚˜ä@‹¢’@‘íN@–²¤@˜ð¦@˜Š@“K~@Š:Ê@}Cq@[×õ@5¹b@ Þ=?½½ž?D~:躿CÚÞ¿ÅÙÀF»ÀH‚êÀzTÔÀ–F4À¯L9ÀÇĉÀßì­Àö× ÁTÆÁ›ºÁ®lÁ$ ›Á.‚JÁ8îþÁDcÁOëgÁ\B Ái ËÁv*&Á¶4Á„’Á|-=ÁoJhÁbÁV ÁIÎÿÁ>yÁ2ÊkÁ'¤õÁVöÁÚäÁv‹ÀóbwÀÚÄ0ÀÂ"À¨¢ÓÀgÕÀkiÀ8›¸À³‚¿§&b¿“>.æÆø¿ }`¿¥ä‡À³À3»êÀd²pÀŠÙ·À£dÀ»_ÀÓ¡ÀêYeÁ'²Á zÁA Áè<Á'ñJÁ2 ¨Á<[RÁG\ÃÁRý6Á_(mÁk¿)Áx‰dÁ‚½¡Á†.gÁ‘åÁrÝÁeîÁY\ïÁMF1ÁAÀÒÁ6¨øÁ+“ÿÁ gÁFžÁ )Àý—Àåò2ÀÍíûÀµšnÀœt»ÀƒäÀUìXÀ&˜‡¿íó¿’̾õ’œ>'g?3â&?™;­?Ðâ¨?ÿ8R@2¶@"‰÷@.³³@7)ß@:m¤@80@0cô@"9^@?/?럆?¬:B?GO'>!Â(¾ý/@¿•ÿ)¿ï  À%ÆÀT¢`À‚À™·uÀ±jÀÈ"KÀßfAÀõæýÁu$Á?|Á§Á"+ÀÁ+éÁ5í[Á@9‘ÁK=#ÁVØìÁbóÀÁoKÁ{³ëÁ„'×Áˆ5{ÁàÁvÓÁjöÁ]½îÁQçÊÁF¢ûÁ;–Á0}Á%˜ÁÄýÁ»ÒÁvrÀò/TÀÛqÀÂà>À«!±À“'SÀx@ÀIKÀS´¿äÅñ¿–O¿Gò½·ò(>¼m¶?Fvö?‰ê?´?ÑÒn?çû¹?÷O¼?üøÏ?øež?ê+?Ð?¬¿É?|d)? 0ý<⢢¿ ö¿”¦¿çÕþÀ0©ÀJð©ÀwÔüÀ’ˬÀ©z¿ÀÀ9¥À×5SÀíùÁ4ÆÁ 5îÁ“‘ÁÄ$Á&ÑÁ0/Á:UrÁD¹NÁOˆvÁZùUÁfݹÁsÙÁiNÁ…ÿÌÁŠ…ºÁ„áÁ{ ÝÁo7ëÁc#tÁW{[ÁL4\ÁAúÁ6Á+3Á ‚ÁÞöÁ ûÁ JÀè÷†ÀÒVÑÀºíŽÀ¤KmÀÙßÀpKÓÀEËùÀ•&¿óο°>/¿cÇÔ¾é?ƽª÷Ÿ>Æç?e¹?ç€ð=û›H¾ˆ7¿=Ö®¿£ ‚¿ît§ÀRÀGšåÀqÙáÀŽf"À£øÆÀº8ÎÀÐ…«ÀæDbÀû¯<ÁÁãÁ{UÁ#[Á,käÁ5¡vÁ?a¹ÁIy-ÁTüÁ_]Ák)×Áw'›Á³qÁˆþÁHÁ†»LÁ€žÁtåwÁhÔ‹Á]-"ÁQïšÁG­Áb¿«tM¿Îq›¿ùíÀg‡À3©-ÀTÌ Àx'dÀÀ¢iÂÀµÎRÀÊ€ÇÀÞ¡'ÀótËÁ®ÅÁ „¥Á8Á–.Á'åœÁ0HÁ8ÿeÁAî‡ÁKÁU}Á_´¤ÁjjÁu²îÁ€½êÁ†Ù¼Á aÁ“$ùÁŒ¹pÁ†yNÁ€jçÁu+;ÁjõÁ_m<ÁUÕÁJ‚øÁ@D£Á6 oÁ,§Á"ÅÁíÊÁ ÊœÁŒÀòdŒÀÞgÀË.*À¸“À§6/À–ž"À‡+zÀqpÜÀVǾÀ?sÀ*'WÀœkÀ ñ¿û^é¿ê¶¿ßTë¿Ü…¿â*C¿í÷ÂÀ ~ÀU”Àˆ¤À4ÀJô ÀfbýÀ‚láÀ“§ŒÀ¥bðÀ·ôªÀÊä‹ÀÞˆÀñYRÁí Á ‘oÁ·ÁðœÁ&õƒÁ/,éÁ7еÁ@ÂÁIE:ÁR£Á\¬gÁfìCÁqX^Á|QëÁƒç’Á‰ßÉÁ pÁ–=ÁõSÁ‰Ú¾ÁƒôÁ|‘GÁq¼kÁgpÁ\–†ÁRdOÁHMÎÁ>`AÁ4² Á*Ý:Á!IÁ"…Á ìÁ„ÀôþÀá«£ÀÏì‰À¿7 À¯À {×À’’[À†!Àu˜fÀaˆeÀP}ÀCvÀ78xÀ.ä„À*]ŠÀ)Œ—À,ÙÀ1øŸÀ;¾®ÀH)ÜÀXjÀkERÀ€!¾ÀsÀ›‹ÃÀªûƒÀ¼üÀÎÀà]Àò£Áˆ†Á äBÁf½ÁSæÁ&ÛzÁ/‰Á7 :Á?šëÁH «ÁQ1ÁZ£[Ád]\Án®gÁyDÁá*Á‡wkÁI!Á“O?Á™°ÄÁ“Ž6Á›YÁ‡ÞqÁ‚\©ÁyããÁo"¸ÁdÚ4ÁZñãÁQ²ÁGBRÁ=‡ÁÁ4ÌÁ*‹±Á ó=Á–ïÁHUÁ%hÀøš9ÀècÀ×Ð÷ÀÈ ‘Àº$À¬õÄÀ §uÀ•ûJÀŒ ´À„cÀ{YÀpuÀi <Àd›’ÀdËÀfæúÀl«/Àu¤nÀ@ÀˆqÀ‘,bÀ›>À§»À´\sÀÊïÀÓˆ…ÀäFËÀõÑíÁšWÁ ²,ÁW§Á9CÁ':ÖÁ/h·Á7[JÁ?=¸ÁG’ÁP¢%ÁYµ®Ác¥ÁlÜJÁväýÁ€²óÁ…ù\Á‹e¡Á‘þÁ–î•ÁxÐÁ—}|Á‘³ÅÁŒ SÁ†¡åÁ*ÌÁwИÁm´úÁcÅæÁZÆÁPF”ÁFØwÁ=…JÁ4XÁ+P+Á"5JÁN3Á–ÇÁ2ºÁÈÀðž<ÀáÞ-ÀÔ ÷ÀÇhÀ»˜ÜÀ±6nÀ¨QÀ •“Àš#À”ìÀ‘°8À‡NÀP²ÀØìÀ“§³À—½XÀ¦‡À¤sÀ¬¸ñÀ¶’©ÀÁ¸¤ÀκÀÜ!Àë_¹ÀûLÌÁÇ&Á6–Á¢ŸÁKÑÁ'ËÈÁ08‚Á8¤Á?¡ïÁGœÏÁOÆ2ÁXžÜÁb7kÁk”†Áu kÁKóÁ…9ÁŠW ÁªtÁ•*]ÁšâÁ¡°Á›¼—Á–²ÁŽ[Á‹oÁ…¢>Á€x Áv¶ÁlÕÞÁc ìÁY¨IÁPy•ÁGy=Á>˜ÐÁ5ËuÁ-'íÁ$‘§Á“Á|Á E<ÁËÀûACÀîpÀáÕ-ÀÖµtÀ̯¾ÀÄGÀ¼‹BÀ¶q)À±˜FÀ®8gÀ¬¨§À¬qOÀ® lÀ°ÀgÀ´Ã„Àº3ÙÀÀƒdÀÈ®§ÀѪéÀÜPCÀèHÀõ§Á¿»Á WNÁü+Á›Á!1ðÁ)I¯Á1”Á9žûÁA™ÁH™ÐÁP~}ÁXÌDÁaTýÁj›Át€7Á}°ÈÁƒÃáÁˆùÒÁŽr Á”%6Á™‘CÁŸ#‰Á¥ïÁ DÁš’ÈÁ”ù„ÁvkÁŠ+!Á…Á€¡ÁvUÁl¹qÁcžóÁZ•õÁQ¢xÁI>Á@ÁÁ8&Á/ù¯Á'÷”Á RÁœ…Á6LÁ  .ÁZÀü“"ÀñöÀèBŒÀßÉ:ÀعvÀÒ«VÀÎlZÀÊÈÀÉ·ÀÉy§ÀË"ÀÍÌQÀÑÂ"ÀÖ·¸ÀÜñÚÀäB<Àì÷úÀ÷ Á/éÁ9£Á öÁãÁIIÁ#ë€Á+º†Á3Q(Á;óÁC`ÁJaHÁQõ’ÁYþªÁbPÁjÏÍÁsº"Á}WÁƒy›Áˆ:PÁF$Á’•UÁ˜ ÔÁâIÁ£—éÁªY¥Á¤·Áž÷¤Á™_£Á“ø—ÁŽÐÁ‰ä[Á„é—Á€ 1ÁvÔáÁmµ.ÁdÕ‹Á\ »ÁSØqÁKvÁCkÿÁ;™ÊÁ3¿Á,J:Á$ÕÉÁý[ÁŒØÁIÂÁ ®TÁSÁë¶Àû˜AÀôïdÀïÀêâÀç£ÌÀæÅ`Àæ§œÀè ÀêáÀîÀòÀóW4Àù{wÀÿù{Á:ÄÁá&Á<ƒÁÁRÁ äƒÁ'Î.Á.ïöÁ60ÝÁ=ÓÝÁE7ÁLÎÁTwgÁ[ÅaÁcÝZÁlA,ÁtÖ˜Á}‡iÁƒdPÁˆTûÁáÁ‘âqÁ—)ÁœkOÁ¢ÂÁ§ÑùÁ®ÎaÁ©OÁ£n¢Á÷ðÁ˜º†Á“¼|ÁŽÉ{Á‰ÇëÁ…žÁ€ŒÁx Áo<¥ÁfÖÑÁ^Á%ÁVÉîÁNæÎÁG3öÁ?ÃxÁ8q¶Á1XÌÁ*ÄrÁ$^ÁŒÁ¯ÁmÁ®%Á ½)Án³Á±iÁ¦•ÁOÇÁ¹GÁÃ^Á‰Á×Á¥5ÁéÁ ¼ƒÁ ðrÁëKÁ[8ÁY²Á ɺÁ&”ìÁ,Î,Á3kBÁ:$PÁA%¾ÁHYÈÁOÏîÁW3-Á^¿Áf=IÁn AÁv†·Á1ªÁƒõZÁˆkpÁ/Á’¶Á–ÇaÁ›Ã·Á þWÁ¦qcÁ¬~Á³WâÁ­¥2Á¨"Á¢Ó¹Á¿¥Á˜ÖÁ“»BÁŽäsÁŠWÆÁ…ìÂÁ_äÁz4Áqî³ÁiõóÁb3+ÁZfäÁSDÁKÑhÁD¼˜Á>ËÁ7‰ Á1xµÁ+ÁÁ&¤kÁ!´‹ÁŒœÁ°¤ÁÁä\ÁôoÁ²ÒÁdÁAwÁ iÁ9)ÁýÁ'ÁÁšÁç{Áž«Á#µBÁ(gÎÁ-‚Á3ÓÁ8Ì[Á??ŸÁEYÁL?*ÁS[†ÁZµÁað_ÁiKøÁpöGÁxÊšÁ€cÁ„äsÁ‰PáÁ¸“Á’PÁ—0LÁ›îÁ Á“Á¥ÓíÁ«”Á°ŸaÁùJMÁòö&Áì´šÁæwÁàI„ÁÚ'’ÁÔ‘ÁÎÁÈ>ÁÂ%‘Á¼8ÖÁ¶oEÁ°¶ÅÁ«Á¥TÁŸÏIÁš‚0Á•``ÁN1Á‹N”Á†ŒÁ‚ÿÁ|%Át¸ÁlS~ÁexŠÁ_oÁZŸ!ÁVÅÁRT¬ÁOŲÁMÍÐÁLŽ¥ÁLuÑÁL±ÏÁMòëÁPUýÁSâÁVÍ«Á[_µÁ`iLÁflÁm4Át?Á|DÁ‚PœÁ†ÜNÁ‹ƒkÁgMÁ•d±Áš–ÂÁ  Á¥—æÁ«…Á°±ÁÁ¶|“Á¼`NÁÂF§ÁÈ3£ÁÎ;èÁÔR‹ÁÚiRÁà‰/ÁæÂÐÁí ˆÁôœÎÁîE"Áçë~Áá¦ÁÛf§ÁÕ3ÛÁÏ AÁÈî ÁÂékÁ¼îŠÁ¶û¢Á±µÁ«BÓÁ¥„kÁŸÏ)ÁšäÁ”žêÁZ/ÁŠD{Á…/!Á€5¯Áw°Áns}ÁfoöÁ^‚ÚÁW7]ÁPäøÁK¢ßÁGÁCjÁ@?KÁ>C*Á<éçÁ<ÏúÁ=mÁ>mâÁ@é¸ÁCÆ^ÁGÅêÁLX‚ÁQ¶ÜÁX"!Á^üÁfi³Án¯ Áw®AÁ€uåÁ…LlÁŠ=ïÁe.Á”ÌåÁšeëÁŸçëÁ¥ƒ_Á«OVÁ±7YÁ·#<Á½œÁÃ!VÁÉ8ÍÁÏP\ÁÕtWÁÛµÏÁâ PÁèXÒÁð ìÁéšüÁã>ÜÁÜã6ÁÖ—pÁÐYÇÁÊ$1ÁÃöúÁ½ÓWÁ·È­Á±Ç/Á«ÕCÁ¥ëãÁ gÁšUcÁ”Ÿ ÁŽð8Á‰sÆÁ„9 Á~]mÁt"®ÁjNËÁa0lÁXÞ ÁPígÁI9iÁBr²Á<ɳÁ82Á3ÎnÁ0ÎŒÁ.ÉøÁ-UÒÁ-:™Á-„§Á.ÿÁ1Ž»Á4˜÷Á8ÄIÁ=q†ÁC8æÁIòÁPø%ÁXà¿Áa¥?ÁjÝSÁtg{Á~= Á„8ÕÁ‰™×Á5-Á”½6ÁšYïÁ 'Á¦¢Á¬MÁ±ýëÁ¸ ÜÁ¾% ÁÄ=KÁÊfÁЮÎÁ× íÁÝW¤Áã­ðÁëÃÁåtÁÞœÁØ9²ÁÑÝÁËŠÁÅNaÁ¿Á¸çÌÁ²¿FÁ¬­ÖÁ¦¥Á ³0ÁšÎwÁ”öéÁ*¥Á‰t6ÁƒÆÁ|žÁrAÁh,«Á]ôÁTN ÁKubÁC]7Á;|‰Á4C¦Á.$ÊÁ)=ºÁ$ÁÁ!yµÁe¿Á×VÁºÁ ±Á«/Á"=gÁ%LÁ)ÄfÁ.¼DÁ4ûáÁ;ÍÃÁCBSÁK³_ÁTÔDÁ^8"Áh µÁr&UÁ|×üÁ„sÁ‰“–Á6‰Á•½ÁšòØÁ êtÁ¦êMÁ¬üüÁ³gÁ¹1ZÁ¿_‹Áů(ÁÌuÁÒ^ØÁØ»¬Áß3hÁç.[Áà¤ÑÁÚ!¬ÁÓ£ŒÁÍ;ÁÆÜAÁÀƒÁºCZÁ´ €Á­ÙÆÁ§³?Á¡šÁ›‰^Á•–SÁ³ßÁ‰ÙQÁ„2Á| ÁqFHÁff‡Á\ªÁQú§ÁGßÁ>rÈÁ5è}Á-ÜhÁ&XJÁ‚ÁxìÁäíÁIŠÁÁuÁPàÁ°úÁ`ºÁòÁœdÁØ‚Á FnÁ&çéÁ-å¥Á5ìUÁ>ÕKÁHµÁQßÒÁ[ìlÁf‰¾Áq«ÄÁ|Ö«Á„\Á‰è[ÁÒÁ•ËÞÁ›Ö¹Á¡ëàÁ¨DÁ®.0Á´b$Áº¹ÁÁ 4ÁÇoÁÍÓ•ÁÔSGÁÚâfÁâïÅÁÜSïÁÕÃÁÏ9ÎÁÈ´¹ÁÂDÚÁ»ãÔÁµ†Á¯>òÁ¨ÿ)Á¢Î£Áœ­PÁ–ÁuÕÁŠ}®Á„™HÁ}{QÁqÓÊÁfhåÁ[éÁPEÁEóVÁ;ËeÁ1ì Á(ËÁ b@Á†–Á¦KÁ Ý+ÁiÁJÇÁÛÀþtçÀýÔ Àþº¤ÁÝÁºÁ©Á (ûÁ"×ÁæFÁ a”Á(ú¿Á2–Á;¶JÁEÉ»ÁPMFÁ[ZÁf‰´Áq÷Á}¡VÁ„±žÁŠ­RÁ¾ Á–Û‚ÁlÁ£5“Á©o§Á¯Í Á¶.Á¼ŠÁÂ÷^ÁÉ|[ÁÐÉÁÖŠÁÞÉWÁØ&hÁÑ…ÝÁÊí0ÁÄ]€Á½ÑTÁ·XõÁ°õXÁª“ƒÁ¤DÛÁýbÁ—ÇÌÁ‘§…Á‹ˆÁÁ…lÁ~Ú#Árþ—ÁgF˜Á[°lÁPHmÁDøgÁ:9 Á/Ò)Á%²øÁ&ÁH»Á ã™ÁŸ0Àû!¬Àð¸õÀèÛ±Àã9Àà.™Àß"÷Àà"ÍÀã©EÀé:Àñ®„Àû—DÁ>ªÁ /ÁU†Á\Á%’rÁ/¸$Á:(òÁEƒÁPAkÁ[È%ÁgvÁs)NÁ'tÁ…­tÁ‹ÒÕÁ’˜Á˜IÁžŠWÁ¤æÁ«EõÁ±¯¸Á¸'æÁ¾¨ÁÅ0¾ÁËÇÁÒa­ÁÚ¬’ÁÔyÁÍ]¡Áƾ†ÁÀ%'Á¹ŽÊÁ²ûsÁ¬zÁ¦ÁŸ®Á™WMÁ“‡ÁŒÊYÁ†¢áÁ€‚ÓÁtÜ¢ÁhÎ5Á\ÙÄÁQ!™ÁE¦ Á:AÁ.ÿÃÁ$8”Á¶ïÁ¿•Áœ·ÀûŽ¡Àë~dÀÞîÀÓt¶ÀË"4ÀÅkÀÁ÷âÀÀ¬åÀÁ¥'ÀÅ,ÍÀËn1ÀÔ ãÀßÀì½íÀûé£ÁkrÁŒþÁ²Á$&>Á.êÁ:öÁE]ÁQKÅÁ\ÿpÁiúÁuPtÁ€Ö•Á‡"5ÁbÁ“®ÁšaÁ iÛÁ¦â·Á­^KÁ³Ù,ÁºkIÁÁ tÁDZÁÎWÁÖ¬µÁÏò@ÁÉF Á™ëÁ»ûÒÁµd×Á®Í9Á¨3ãÁ¡©×Á›5Á”ϺÁŽvTÁˆ rÁÚòÁwS*Ák®Á^òóÁRÞ@ÁFÍÁ;jÁ/£òÁ$?§Á¢ÁH™Á¬ Àô tÀâGôÀÐá¥ÀÂŒïÀ·½À­æÀ§^uÀ£à À¢‡4À£‘×À§ûÀ®X À·í“Àä9ÀÑ‚¥Àâ·Àó€üÁ¾ÕÁIÉÁÚïÁ#Ø:Á/ulÁ;&õÁFð>ÁS¸Á_c­ÁkÔyÁxj‚Á‚~·ÁˆÑôÁ+ØÁ•œhÁœ%ØÁ¢™ÛÁ©:Á¯µêÁ¶bxÁ½àÁéÁÊfsÁÒáiÁÌ}ÁÅA4Á¾‘Á·åtÁ±?£Áª¤˜Á¤ YÁoíÁ–ß~ÁbFÁ‰ñ}Áƒ–åÁzŠ"ÁmúéÁa‚‹ÁU"(ÁIÁ<þÒÁ0ã#Á%!TÁ¡ÙÁN}Á-ŒÀðÃVÀÛ¶yÀÉ9–À·ÍgÀ§ŒÀ›_¤À½eÀŠ‚˜À†•DÀ…%_À†FuÀ‰×RÀ‘ŠöÀ›Õ!À§Ï À·l?ÀȤ3ÀÛâ%Àðã¤ÁöŠÁ Õ_ÁjÃÁ%ÔÁ1qÁ='MÁIžBÁV"ÃÁb°ªÁoC Á{ÿIÁ„fÁŠá‹Á‘nyÁ—â±ÁžkCÁ¥òÁ«·UÁ²\ZÁ¹ ±Á¿Î~ÁÆ’PÁÏ3ëÁÈRÄÁÁrbÁº¢¤Á³ëßÁ­@”Á¦–!ÁŸðÃÁ™O:Á’­ÅÁŒEÁ…—ÝÁ~7Áq{ÖÁdåUÁXVÆÁKØ(Á?j¢Á3;TÁ'!èÁ$œÁZ]Á´0ÀðÔLÀÚ¢VÀÅYgÀ°æ,ÀŸ`ÀŽf¢À€ËIÀk81À]\YÀT?kÀQ¿ÀTlÀ\QÀjyÀ€9À,üÀž—cÀ± LÀÅ<ÜÀÚcºÀðtÁ’MÁB0ÁF‚Á'|{Á4{Á@ŸþÁM!ÁY²2ÁfŠ$Ást!Á€5«Á†¸cÁ?uÁ“ÐÌÁšl_Á¡†Á§Ê@Á®{FÁµ8„Á¼ñÁÂØNÁ˦ÁĵÁ½ÓàÁ¶óßÁ°9Á©YcÁ¢®>ÁœÁ•TÁލÁ‡þ9Á[×Áu²'Áh·èÁ[èÕÁOEVÁB³’Á6EÁ)êªÁ›ŸÁfíÁšóÀó¨3ÀÜËÀÅ”@À¯ ~ÀšýµÀ‡‘Àl;TÀMDÀ6°À&‹ÀöÈÀ±gÀýZÀ&åÀ4€ÿÀJ²FÀiÚ×À‡8ÀšA•À¯Q'ÀÅMrÀÜêÀóT5ÁÐÈÁÁ»mÁ+JÁ7Ä%ÁD^ŽÁQO÷Á^AÁk"žÁx2/Á‚´ðÁ‰=µÁÔAÁ–‹DÁCÁ£ê¾Áªª)Á±~#Á¸SdÁ¿(½ÁÈUüÁÁIùÁºNÁ³gÁ¬‰|Á¥¬,Ážà3Á˜.wÁ‘‚äÁŠÏ…Á„ŠÁzÔµÁmz{Á`fíÁSoèÁF×Á9Ö¹Á-1qÁ ÒòÁyÆÁ+§À÷óJÀàXÀÈÔÈÀ±‚À›t¶À…ØtÀcK·À=ª’ÀûhÀŸ0¿äg¿ÑñN¿Ë–Û¿ÎÅ”¿àsÀsÀIÀ:ŽdÀa%ùÀ…úÀ›OÇÀ±êÀÉ ÀátxÀú Á t2Á.Á"¢Á/PUÁ<(ÁIçÁVâÁc+nÁp`ËÁ}qÍÁ…WïÁŒÆÁ’ºNÁ™kkÁ 5ªÁ§ Á­âeÁ´¹ŸÁ»¡çÁÅÓÁ¾Á· ‡Á°ÌÁ©Á¢2ÈÁ›TžÁ”w­Á³­Á‡ÈÁ€OÁsK ÁeówÁX…WÁK]îÁ>n«Á1„øÁ$¹7ÁÿÃÁ „DÀþ6?Àåû¿ÀÍä¿À¶ŠÀž`ŽÀ‡þÀd\À8¨»À¢&¿á]¿¬J¿‡VW¿bº¿Qª¿¿_7¿€jŽ¿¤'¿ÜT{Àå<À9uÀbÅüÀˆE)ÀŸÓ–À·y¿ÀÐ ½ÀèÊ×ÁÁ ë‹ÁltÁ'Á4"ÁA)øÁN;pÁ[dŽÁh¦ Áu϶Á“ÉÁˆLÁ ùÁ•Ý›Áœ´1Á£ŠÆÁªgÁ±YáÁ¸aYÁÂÒÁºøýÁ³æÁ¬ÝfÁ¥ÔÊÁžÐÍÁ—à…ÁÿTÁŠOÁƒIŒÁy%EÁk¿àÁ^p ÁQ2tÁCÔ²Á6¯Á)ŽÃÁ™õÁÅÔÁ5ZÀíR£ÀÔ_tÀ¼ÄÀ£õ[ÀŒq@Àk#QÀ=ñMÀ£‡¿Ö)¿’ ¿0—¾Ï.T¾aõ¾AÆ“¾n£–¾·Ñ2¿#¦h¿d!¿Ô>ÄÀ4(À?ÀmšhÀŽe#À¦í8À¿óúÀÙK•Àò¡ÁÈ}Á€ÁŽÁ,tåÁ9bìÁF²‰ÁSøJÁa‡Áns-Á|Á„ÇKÁ‹eÁ’i3Á™KŸÁ 6lÁ§-CÁ®3Áµ@ÈÁ¿MóÁ¸üÁ°îûÁ©É~Á¢´#Á›«Á”£$Á¢†Á†¼xÁÀÒÁr+Ád”[ÁW4/ÁIÖæÁ<¤Á/0IÁ!å?Á¾8ÁÐYÀöÀÜý(ÀÄ ºÀ«¶ñÀ“IKÀvÄéÀIÀÏl¿ä2ÿ¿•T¿t¾S;=sô>]ƒà>‰>¿>XlÐ=šù¾EäÌ¿pÀ¿˜½¿ê¹›À äNÀP:5ÀKÀ˜LHÀ°ÉµÀÊ ÀãqWÀüª´Á ØÁóªÁ$ñgÁ2[åÁ?v=ÁLÈÁZ6Ág¦Áu@ÁSýÁˆ<ïÁ-¡Á–!Á¤Á¤ kÁ«%?Á²MÔÁ¼“ÁµO!Á®¯Á¦ð2ÁŸÄûÁ˜ NÁ‘‘äÁŠ=ÁƒUÁy?¹Ák“ÁÁ]ïîÁP_pÁC¾Á5µÔÁ(J¢ÁìÂÁ ¤·ÁtiÀçC·ÀÍÍÀ´°bÀ›ÑQÀƒwƒÀW\À**¿ùÉ࿪'–¿;»¾~c.=Ðr>ªÎ#>ì!ñ>ûMi>ê‹>¬–i=튾ûm¿Pù.¿µãÀù¡À2ý¿ÀcØ*ÀŠF@À¢àÀ»ÈWÀÕÀÀîTÁ‰Áú*Á$Á+aPÁ8€üÁEÍ¿ÁSS Á`çÁn‚ŸÁ|IÞÁ…@Á‹þìÁ’öÉÁš†Á¡,`Á¨YDÁ¯†bÁº‰Á²ÀSÁ«s‘Á¤5EÁÙÁ•áÉÁŽ»wÁ‡¢Á€¢µÁsZZÁew§ÁW»¹ÁJ’Áx<>>ÒÌ=>ÿÅÜ?Ö¶?t>Ù[ÿ>}9¾½»—<¿ ·¿g¿ãwñÀƒ1ÀJüšÀzæ§À–HoÀ¯ BÀȃrÀáí^Àú¦äÁ hÝÁÀ§Á$‘úÁ1×yÁ?}4ÁM€ÁZy¤Áh8«Áv,ŒÁ‚€Á‰Á3ÔÁ—aÁž]Á¥¿¬Á¬ðîÁ·ª—Á°WcÁ© ÕÁ¡ÅÆÁš€‰Á“KTÁŒ(ÆÁ… úÁ{Û†ÁmÄŽÁ_Ö³ÁQ÷¶ÁD³Á6^žÁ(ÀZÁ3èÁ õØÁÁ@ÀçYÀÌÆÀ³vÀ™œËÀ*äÀRË À$]þ¿ñÎ2¿ :ä¿2n¾…çc=…Zã>‹’^>Énê>çÏ’>ô¨Ý>ðA‚>Ò!T>„ùÔ;\Þ-¾»áø¿i¿ÁÐ'À )À6?OÀe…±ÀŠ$DÀ£AxÀ¼YnÀÕ0=Àî—RÁOÇÁSŽÁ‰–Á,ˆÁ9]pÁFÔ¤ÁT¤’Ábµ¢ÁpÓSÁ~ëÛÁ†ŒÁ´BÁ”æ®Áœ ‚Á£`˜ÁªŸbÁµŒðÁ®']Á¦ËrÁŸTÁ˜?ËÁ‘&Á‰ÇbÁ‚”ÁÁvâÒÁh³»ÁZ ÁLqÁ>–ÙÁ0ÞqÁ#9ÁÊ3ÁsIÀö‰ÀÜ^æÀÂ=ˆÀ¨oÀ¥ Àm¬ØÀ>|GÀoÉ¿ÍÒ7¿†.¿7¡¾Lˆk=€5G>l©>¨Þë>Ãô)>Ñe>Ïl>´Ýî>kM­- å>…à>£Ù”>³9¼>®õ>•šÖ>:o“¼qMC¾Ÿ(^¿9‚ü¿˜§¿ãÜoÀ€ÀD¦§Àp¡yÀ:‡À¨?ëÀÀßÀÚ7Àó4¨ÁÒÁ[&Á!ÑÔÁ/äÁ=l•ÁKL3ÁY8µÁgaÒÁuÃ5Á‚ÝÁ‰c7Á™Á—ÛåÁŸ#¼Á¦|iÁ±ÝƒÁªmÁ£ ªÁ›¯6Á”WØÁŒý Á…¢”Á|§þÁn8IÁ_äEÁQ6ÁCoÁ5†²Á'Ã>Á „Á w‘ÀýˉÀãNµÀÉd@À°µÀ—V’À~‘ØÀO´~À$=¿÷׿²ã®¿n\ ¿Ý—¾†ð½4ºÍ=瓹>n½>£Qx>µl>² ±>Ž•> #½}¿™¾¯š°¿26£¿”W¿ÖÀ¦À:coÀdèÁÀ‰°×À ½ÉÀ¹_áÀÒzéÀëìÁ0ªÁ>Á«*Á+†~Á9~ÁGv¢ÁU†[Ác¸!Ár–Á€AöÁ‡Œ‹ÁŽÙ¢Á–)/Á„-Á¤ìÁÁ°~Á¨þ™Á¡„›ÁšRÁ’¢ªÁ‹AÖÁƒðòÁyL¢ÁjÃÁ\QõÁN•Á@6Á29Á$@,Áp9Á§Àö‚kÀÜf¹ÀÃÀª8À‘tVÀsÉÀF±9Àý¯¿ôÑ¿³5ø¿z?p¿績¨±Ù½»{ï=î(Ã>‰A*>ã>ß“¤>Õ¨9>ŸV‚>Lï½­í¾Â®À¿9ð¿“xg¿ÑÛ%À DˆÀ4J;À\ÒïÀ„O½ÀšÛ±À³?žÀÌ jÀ壭ÀÿËÁ Á¼Á(´²Á6z¦ÁD=.ÁR:1Á`| ÁnôÁ}Á† \ÁVÒÁ”ª Áœ ÿÁ£~Á¯KrÁ§ÌÁ KÁÁ˜ÌNÁ‘PÁ‰Ý"Á‚zåÁvXºÁgéÁY”ËÁKW1Á=: Á/@êÁ!I‚ÁlÁâÀñ$6À×ASÀ¾ “À¥#À¯ÀoAÝÀEŽpÀ{Ò¿ø2f¿ºÅ­¿†;!¿-dR¾¶Ó_½akŠ>D7´>Íj? @2? “?ø>Û a>m޵½m$¾Ä§+¿Aô ¿—¹ª¿Ö$…À ¡­À1ÀXoÀ‚;1À—šÊÀ¯XÀÈN›ÀáFÑÀú¹ZÁ 2ÁF5Á&Á3åOÁAÄçÁOéèÁ^/WÁl‡ ÁzíßÁ„³˜ÁŒÁ“fÛÁšÙ;Á¢XŠÁ®%VÁ¦ª ÁŸ0Á—¸WÁHÖÁˆÞµÁz±Át=ïÁe­æÁWRÁI0ýÁ;IÁ- 9ÁíÁmhÁþýÀíû‡ÀÔl™À»À£ rÀŒª‹Àm{‡ÀFÀ!hg¿ÿÓ.¿Äž/¿ŒäŠ¿.ÁǾ”*=œ ´>ÎÄ®?%„Ý?Qeò?cG?T,Ñ?,øÏ>ÑÏ.=‰ò{¾£¼$¿B€º¿œ(R¿Ü„ÀqnÀ3¤ÀX–pÀ…<À–ÛûÀ®¾ÀÆhÊÀÞ¸óÀ÷ß¼Á 0âÁØ—Á$]}Á2Á?ÿDÁN0Á\aÔÁj—‹Áxù›ÁƒÅ´Á‹"¹Á’ÔÁšÂÁ¡‚TÁ­6¬Á¥¿ÃÁžPoÁ–ã¯ÁyëÁˆ$Á€ÀœÁrñ¶ÁdxèÁVÛÁGËPÁ9«ÈÁ+žÁÀÁ+FÁFÀìÅþÀÓPúÀºúÀ£Š„ÀYøÀq OÀJ†À&í7ÀkU¿Ëù¿Š†·¿i´½ØÄ6>«‘«?5¬?‚€]?š”Ì?§!?žƒe?„P¥?8ä>“õT¾2ä ¿- "¿š?ç¿à¢ÿÀ™À8_˜À]ŵÀƒ-lÀ˜PèÀ®©¥ÀÆÿÀÝÃnÀö¨ˆÁ0ÁãÁ#M'Á1­Á?]ÁM5Á[["Ái•÷Áx÷ÁƒSÁŠ´°Á’Á™†—Á ôüÁ¬¡ÁÁ¥$Á³FÁ–Q ÁŽ÷±Á‡£Á€UµÁr#ÚÁcÃsÁUh–ÁGsÁ8̽Á*ÙÁHÄÁ†Á-AÀìÇbÀÓûõÀ¼‘¡À¥î®À$ÀwÅŸÀQÜhÀ-kLÀþ ¿Æ¿s[¨¾³œ>R‰?7¾ð?‘ûà?½XH?Ý,p?ìã?à‹?¿Xn?:X?}J=ªÎ¿øë¿‘ ¿ã À…À>·UÀeßÀ†€À›YÓÀ±3óÀÇÜ0ÀßÚïÀøTÁ vÁê…Á#‹Á0»ôÁ>¾4ÁLçÁ[ÁiIÐÁw´šÁƒ&íÁІÁ‘è÷Á™L%Á ¹XÁ¬kuÁ¤ëYÁwÕÁ–ÈÁ޾rÁ‡}Á€GµÁr9ÁcêmÁUšÁGQÁ96yÁ+[FÁ×pÁÓ Á {Àî²)ÀÖÂÀÀ·À©»ÅÀ”œ†À€žýÀYU,À/%@ÀQI¿¬ÁP¿+É;¼¤ 9? T?”q?Ô`@}¶@Ch@6Ç@cd@Ù?Ì£?‚Èc>º†¾¢ú'¿Þo¿ÝpÀ ÀCÃÀlÓÀŠoÀŸljÀµqRÀËÉüÀã8¢Àû –Á ëÁ4Á#»¸Á1S€Á?@ŠÁM?èÁ[G{Áiv.ÁwÝÁƒ6'ÁŠ„Á‘×Á™4MÁ ¡Áª¨vÁ¤¾áÁ¤]Á–AÁŽï‘Á‡±HÁ€‚Ár¬ÁddwÁV;ÁH+¿Á:K$Á,ÇFÁ§Á¢ÉÁшÀó[ØÀÛæ?ÀÄ›jÀ­ˆÀ—b\À>ÇÀRSÒÀ Ÿo¿áùŽ¿ƒŽ%¾˜Â>Ãv?…êä?Õtz@ w—@+)½@A[£@M@EeY@,¨§@:q?·Û¾?6ƒ¼ðß}¿JìP¿È²_À.¹ÀE)ÀrsqÀ1qÀ¤ãwÀºœ>ÀÑ Àè¥ÞÁaÁ íÁñqÁ%×Á3:+Á@ø‚ÁNĺÁ\œ’Áj¸EÁxû¦Áƒ©—ÁŠÞÝÁ’%ÜÁ™EÁ è”Á¦¶»Á Ý~Á›¸Á•T+ÁŽI•Á†ñÁLŒÁp…ôÁaÄ>ÁS!òÁD Á6AuÁ( áÁõxÁ ƒÀüÖ„Àâ8ÀȯúÀ¯ÛLÀ—d9À€M#ÀTgyÀ(¶ž¿ù<7¿ ‡ß¿Æj>9R>?bç[?É2²@kå@5 ;@VúŽ@qz"@Î@t•@Ríµ@)C§?óê¹?‘[;>´ªt¾àÔ›¿ŸèÀ>‡À9@ÅÀnˆ~ÀÍ ÀªDœÀÁx‰ÀØ%|Àï;øÁ†ÜÁ¼úÁø8Á(EÁ5¬"ÁC !ÁPœ[Á^c ÁlpçÁz°Á„|âÁ‹§Á’ä%Áš4~Á¡•}Á¢ ÁœÞ.Á—"ŠÁ‘fßÁ‹iÖÁƒë;ÁxôõÁj4sÁ[›”ÁLÕÎÁ>qÁ/b4Á ÛžÁ÷ÁT>Àìu»ÀÐÂ8ÀµÂ]À›»;À‚Ù×ÀTg¬À&$M¿ôu¿žžc¿ /=ÛÙ°?J—R?À-@ ¦2@2‘ð@Zù¤@€þj@Ÿº@™ú-@‘±M@yƒ@I”)@¿p?Ж?S|8<Š K¿FÖ¿ÉJvÀ¯ªÀH­@À{MÀ— 0À°àþÀË&Àå©<ÁnoÁ&pÁùÃÁ*")Á8ŠæÁEú‹ÁS<Á`ØöÁnÁ¿Á|éÛÁ…¿ÁŒÍÊÁ’ãÚÁ˜åwÁŸ ÁžÔyÁ˜órÁ“8ÃÁ€ÙÁ‡ÙéÁMàÁso„ÁdZLÁUbÁF>Á7ä‹Á)%©Á_Á ¤)Àú.‚ÀÝ€öÀÁ57À¥ À‰ƒÀ]ΤÀ+º.¿ôc\¿—\ª¾ýgà>&n,?XNn?Àv™@Õ @4fK@^Ü+@‚ÿ@–™l@¨T@´ÐU@¥“Ó@ ç@m®3@lz2?jÁ ?Èðc@j<@9°z@`Û1@…}3@š}³@­Ví@¿¦É@Îö@¹Ðç@¡—`@ˆðÓ@`Ä@/?úk¶?˜?>ֶȾ·)ª¿’È3¿÷²À0=Àe@ÁÀÍcÀ©LšÀÅ@CÀâ–ÀþñvÁ¥Á¯`Á+sÁ:Q‡ÁIDêÁXPÁg{ËÁtèÿÁ€"«Á†øÁŒ ÐÁ’ixÁ˜ÏWÁ˜8>Á’,ÁŒÁ†^§Á€µÁv$gÁibÇÁZN˜ÁKFQÁ<–Á,âÛÁ± Á·ÀþзÀá´ÀʼÀ¥ýŠÀˆpYÀV=ÒÀ.–¿É:²¿1‡d>?g®`?Ò{7@ @>‘ @hÞ@‰+Â@œžþ@±@Å@×ki@äÈS@Í@´Òß@œ$ø@ƒM@Vhi@%M?èF^?„ñô>Ï„¿ N¿¯ê‚À ÎÀD¹À{‚ŽÀšŒ{À·qÀÔ®xÀò hÁÍ™ÁµÙÁ%¸ýÁ4ãóÁD0‚ÁS‘VÁbÁCÁn†µÁzRÁƒMÁ‰E:ÁЉÁ•éƒÁ•r¿Á/>Á‰Áƒ9~Á{ ÌÁoëIÁd£&ÁU ×ÁFdGÁ72zÁ(ÁÓÖÁ  ¬ÀôÛ(ÀÖw À¸*À™á´ÀxTâÀ=:À ¿ŽuT¾d€¸?)$Ç?Ãü@å@C³“@ojÀ@ŒU¤@¡3@µF@Ⱥå@ÜÖ)@ï\ @øÊD@à¾@È ý@¯¾8@—Í|@~™ß@MÖ©@,¯?ÓÇÙ?V'¢JŽ?u·@ž@9/¼@mÞ˜@Æ@¤á@¹bã@ÍùA@áÓ"@ôÙVAõÜAS!@ôJf@ÜW´@ÄfÃ@¬*V@“Å@uÖ¬@C @7$?²??›C¾¸dE¿¢¯ŸÀ LÀFÉnÀ!ÀŸnòÀ¾¾ÃÁ/gçÁ Á ;Á'¶Àã<ÊÀÄ*)À¥dÀ†IÈÀO¿¡ÀÙ¥¿«¹"¾Æûê?v[?ÀX@a@V{q@‡ÄÎ@£ì @¼OÂ@Ò{@æp3@úÀKAxA})Ai…A†N@ñ l@Ù Å@ÀŸ+@§ÀT@Û'@g.@0fM?ïó\?u:=%;¿`‹¿énÀ3àÀq»MÀ˜34À·ˆÁÀÖ“ÿÀõu¦Á +¦Á¤1Á)& Á8¤ûÁG‹¸ÁSéÙÁ_H»ÁjêÁvô>Á¢×Á‡ÆÁézÁކÁ‡ÉWÁ•‡Ávê±ÁjæÁ_[TÁT‘ÁHžßÁ;ýÁ+çYÁˆèÁ Àû<×ÀÜTÃÀ½2µÀž§À}Ý3À?™ÀTû¿†⽯Ö|?]ù?èöè@1xˆ@nuœ@•Ò@²ž@ÏD‘@銾@ÿGA › A¤…A&ØAéPAèÅA÷š@íyÍ@Ô•R@ºC @ŸŠ@ƒV¨@KôÓ@¨ù¿&ªn¿Ð«lÀ&òñÀe€À’ À±~—ÀÐÅÙÀð$¿ÁÅ…Á\©Á&’€Á5—)ÁC¾¿ÁOSÁZ¨ÜÁfGÁrbÛÁ~«&Á…zåÁ‹ 8Á‹ð6Á…”?Á~¶çÁr¥ÈÁf΢Á[nÁO²±ÁD_òÁ7œÁ(ÏÇÁ ÅÁ S_Àõ¿ÁÀÖ·ñÀ·À˜IÀqÍ.À3U¿è¯8¿X?M>=?­é@me@DÖ@€ë3@Ÿi½@½èG@ÜfÑ@ùþNA _xA ¹AøõA)ámA%ZKAk.A *8A{W@æËô@ʪ’@­Rï@û5@]»@f?¿Š?<©¾ù©Z¿½sÀ=×À]‘aÀŽG»À­ÆÆÀÍ%ÞÀìÁ‹Áù=Á$9aÁ2ÁãÁ@MãÁKVIÁV›“Ábk€ÁnpâÁzŠ1ÁƒZWÁ‰wŸÁŠùÁƒÌÁ{ßÁnÎsÁbô9ÁW&ÔÁKëÁ@;—Á4MüÁ%äËÁË·Á„¥Àðz^ÀÑ—>À²«xÀ“9]ÀgŽÌÀ(é¿ÔÀô¿.êV>˜R?£žÄ@àâ@Pá@‡R@¦çU@Æ6l@å¤AJàAŠ%A ¯LA,OA6X‹A/áêA#—‰A»õAA¨@ð°e@Ðêð@±5º@‘‚£@cp¸@#¡Ñ?Ç¥Ò?dоØ$¨¿´mÚÀ|fÀXÁßÀŒ¬À«aÁÀÊ‘ÆÀé®ëÁ#ŸÁ6Á!í™Á07±Á=ÝÁHóÁS`œÁ_5ÁkœÁvùÁxõÁ‡œÔÁˆªyÁ‚ZjÁx)ŸÁkàÁ_ʬÁSçåÁH-ƒÁ<äÑÁ1@›Á#• Á)Áv?Àì :ÀÍ*ýÀ®:LÀ!\À_cxÀ ‰å¿Ão¿ •‡>ßf@?µ‰M@ã¨@Yò@Œ0—@«Á—@ËR–@êã–A:KAÊA$ÄnA4ppA7æ×A6R-A&ßPANlA™S@ï¹6@Ðg@°Pö@¬¹@b2ß@#?È!X?õ¾ÐŠ¿²ÅÀÀVÆ6ÀŠÆ4Àª)MÀÈï^Àç VÁòÁäôÁ iÁ. fÁ9å\ÁDÏCÁPAÎÁ\%ÁhÂÁsûƒÁ€¨Á†5ÀÁ‡{Á^Áun[Ái/~Á]‹ÁPýúÁE‚½Á:HèÁ.—zÁ!g´Á¬ùÁ‹øÀè‹BÀÉååÀ«ÏÀŒ+¹ÀYÒ«À%F¿¸ïľì%^?j6?Á^q@Ãä@^ØŽ@Žûp@® ~@ÎG@íóÂAÕA±qA&Œ¡A6g¡A7ŽçA1ÚçA"çÐAÝÊA.@êˆÝ@ËÅê@¬”Ù@5¡@\+y@\Ü?À‘Æ?Д¾ìS-¿·œÀ÷6ÀX7yÀŠõuÀ©Ï–ÀÈ©¶Àæ÷åÁsßÁRÁ/Á,sÁ7‰ÁBoˆÁMéÃÁYÑ#Áe¯5ÁqŸàÁ}è®Á…BeÁ†…ËÁ€@ÁsMFÁgàÁZüÄÁO‹ÁCpqÁ8Á,„¼ÁÏÎÁJPÁA}Àæ'ØÀǹÊÀ©ÒÀŠ*ÀVž³À*e¿³bÛ¾Ùì?  ?ÃW@ Ê@_ËÒ@f‘@®ç:@ÎV†@í‘þAjA A%¬A.ýôA1"A*´0AõõA²º@ÿîF@áñ @Ãü@¥Î@‡,U@Q,Ú@)?­ßÙ>Ìkq¿·¿ÂÖÑÀéÀ\ÀŒ—êÀ«nÀÉI¡Àç^ÄÁ>GÁY°ÁXôÁ+"BÁ5µhÁ@‚NÁKÈÐÁWe¤ÁcK¨Áo<Á|+_Á„‰·Á…ÕHÁ~ÑGÁqþÎÁet/ÁYODÁM=ÁAÿÓÁ6‰¶Á*ÜIÁwÅÁQDÁvÙÀäºSÀÆw>À¨Z» ¿:ÉN¿Õ¹ïÀ'ôÀc.À—3À­ÁÀË5¤Àè·šÁóÁÔÐÁôTÁ)Ì$Á4±QÁ?&JÁJzÁUrºÁan—Ámã„Áz¿xÁƒëtÁ…j¤Á}ïÁq ,Ád^ôÁX$öÁLp„ÁAÁ5’CÁ*ÁíÁãÌÁ[¿ÀäÖ½ÀÆöÀ¨Ã®ÀŠÐ^ÀY(«À"L¿¾7Û¿Ó$>ÕXÔ?¯ü@xF@QÏ@†Ú‘@¥04@ÂÊ@ߨ”@ü0A†A ÕàAÎÔAß¼A?/A SØ@þÍ9@å3—@ÊIÖ@®Y@‘¸“@j8é@/S ?é¿?h--¼‚‚­¿qª…¿ðH°À3éÀmë)À”]4À±¤LÀήíÀëWdÁÊSÁ‰áÁ;†Á)kÁ4÷Á>[ÁI,ZÁT¥EÁ`¬Ám+<ÁzªÁƒ›,Á…]×Á}ÆÁpâ%ÁdKÁXcÁLNüÁ@´TÁ5ÕÁ)MƒÁ^ÁPÖÁå»Àæ]²ÀÈòaÀ«„±À†ÝÀ_-ýÀ#S¿Ðh”¿3[i>xNU?–Ëd@á@AA @|:@šþ€@¶ùŽ@ѰÔ@æÝâ@õ:@ýì•A½áA¡“A:â@ý§N@êæ1@Ó[7@ºr}@ õ@„¹-@Pý@Û~?Á1?¡£¾¡š¿š¿ZÀßÙÀ@õSÀzÕ9Àš¾À¶ÃúÀÓÀïo Á~ÇÁ‘mÁpÆÁ)ƃÁ4…ÀÁ>Í/ÁI˜ÁU Áa ÿÁmƒäÁzc>ÁƒÆöÁ…€5Á}ÐÁpôÝÁddÁX€ÁLµ0Á@ïÐÁ5WÒÁ)¹ùÁüÁß[ÁüÇÀé?[ÀÌ™0À¯{jÀ’'ÅÀjsOÀ0Éž¿ëè׿mxò¼^‰õ?eË-?æ„ì@,)G@d `@a’@¦A¡@¼B-@Ì—"@ØY®@à·@åT&@èõ¨@è:Ð@á³@Óm€@¿$´@§õ@_¤@k“@4ê5?ÿö?L >‚ˆT¿o"¿ÁŒÀÉ ÀQݪÀ…+¡À¡uÀ½yiÀÙ;hÀô¢¯ÁŸüÁGhÁ¼Á*£Á5€gÁ?èyÁJšIÁUô^ÁaÞ_ÁnB·Á{GÁ„vÁ…àûÁ~³ÁqãïÁe{ÁYSšÁMRfÁAµFÁ6GÁ*¯ŒÁÀÙÁJ=Á °ÀîH-ÀѵxÀµ[£À™H£ÀyÀ?nºÀò¿œq¾§Ë¨? %?´'ß@ËÂ@E³L@vñO@‘?u@¢ôÎ@°ç³@»Pr@Â(N@ÇlÕ@Êþ@Éúz@ÄÂ@¹3v@¨^¨@“c7@y"@Gîá@ûŒ?Â=;?2渾h´¿´N¿îuŸÀ.á4ÀeÉßÀŽŽ?À©ùlÀÅÀàŠÀúÉ•Á <ÎÁ]—Á!y(Á+óñÁ6çÁA0&ÁKÏÁW-Ábï8ÁoB7Á{ÿÁ„‰¯Á†™¥Á€8Ás¼ÙÁgKkÁZãŠÁNÐÉÁCJýÁ7øËÁ,xøÁ àUÁ“®Á“}ÀóéÀÙ {À½¦À¡AtÀ…ƒCÀSÏïÀؿȤ1¿7–5>8?uvŸ?à”@!?@L™f@qdÙ@ˆ}É@”ÁØ@ž@¤[@©£±@¬™Í@«Úu@¦ˆá@@=Ç@y°k@O]f@!ú&?ãCw?€ªð>Y:¿¿Ï¿¶XhÀ.ïÀG+À}Q?À™@vÀ³ºÎÀÎpÀè@pÁ)Á oYÁA…Á#ç"Á.'zÁ8‹ìÁBµÛÁMWÁX  ÁdwéÁpÉ•Á}ƒOÁ…H‰Á‡£•Á:}ÁuÁ¢Áin¶Á]U5ÁQnÁEá²Á:TíÁ.Ã.Á#Y;Á2ƒÁ »tÀüÀáq±ÀÆ|+À«‡¤ÀB%Àjz°À5g¿þ_ ¿“X¢¾·(·>ßΔ?–[Î?ìûr@4J@>1å@YÓ§@pDl@€ž‘@†Ö$@‹€â@ŽhI@xÔ@‰"@€|3@i´_@I?d@"£‡?ðÜ?•ãò>ßÊ©¾¡€¿ŒŒ¾¿ôŸÆÀ-¼Àa±ŽÀ‹ 0À¥™À¿$ÀØð®Àñó„ÁhüÁ^wÁHjÁ&¦<Á0í!Á:ÎvÁD³ŸÁO>ÈÁZsîÁf:=Ár|“Á)Á†QÁ‰õÁ‚^ÁxƒâÁl&Á`ÁTKôÁHÞ*Á=PÁ26»Á&µÍÁÁ%ðÁ¤³Àëc(ÀÑ,¬À·”ÀœÛ À‚r"ÀP~ûÀ3â¿Õ S¿bg’¾+¼?M\?²Ç?ÖŸÁ*×Á3ØæÁ=ÞÁGðiÁRSÁ]`\ÁiÜÁuªÁ€ÕyÁ‡@~ÁŠ¥€Á„?¬Á{µÄÁo7‰Ác*ÁW "ÁL‡lÁAvjÁ63Á*ôÁÊ`ÁߘÁØ"ÀöÍÛÀݺœÀÃðŠÀª†À‘ ÀoxÀ>ÏÀ ÔI¿ÀKÊ¿N ¾L)>¶‡?Y‘?¥Û?Ó:Â?úv@ ü¬@yÌ@ ±@$'”@"—”@Ã@ S£?óŒq?ÃA? ¯>犾˜¿Oúî¿Á~CÀ ü_À=¬œÀm ¯ÀŽ÷À¨ÆÀÀV(ÀØ«÷ÀðÍ1ÁjÌÁåïÁ§€Á$À±Á.?ÝÁ7ËÙÁAº¶ÁKÆÁV+3Áa.~Álº,Áx»AÁ‚‡¢ÁˆÆxÁŒ›Á†TÁ€=Ás3âÁg[Á\ @ÁPòýÁEÜ¿Á:ØyÁ/ÔàÁ$¿òÁ_>Á ¯ÜÁÎÀê³|ÀÒ•À¹îÀ ·ÈÀˆ¦¥Àb†À4½¯À츿ÃÇB¿u}¾ßzð<ä„Ä>Ü.ð?DæÜ?†âw?£?¹©?ɽ¶?Ï„±?ÌrÊ?¾¢Ó?¥?€Ô¼?(¸ >dɾ˜‰¿`1A¿¿z?À c‚À6@ÞÀcDÀˆJ»À ÂÀ·£‹ÀÏÚ¯ÀçoâÀþ§Á »6ÁíNÁ °Á)•=Á2ÛjÁ<-FÁEÌÁOùŒÁZYúÁe:ìÁp®bÁ|žvÁ„o&ÁŠ›*Á޶ßÁˆX†Á‚lÁx(jÁl¢ÁaZvÁVFEÁKF†Á@[ìÁ5$Á*¹°ÁŠ€Á,†ÁN¢Àù Ààû›ÀÉ„·À²åÀš³õÀ„…NÀ^¨…À5ù÷À¤ï¿ÝE翟o£¿Oš¾ác2½àÝã>j>¶Gš? ,?%D?0À¸?(“¡?ì >ÂÖ—=öª¾Teà¿ö¿ŠC¿Ï×—À ¥ÊÀ5z×À_‰XÀ…NqÀ›™À±ðªÀÉLÀßì)ÀößÁÜöÁðçÁ¦Á&AWÁ/E™Á8YVÁAW­ÁJ«äÁTµtÁ_ ¦ÁiÄ>Áu2Á€kØÁ†b ÁŒ}¼Á‘/øÁŠÿCÁ„àŸÁ}φÁrA8ÁfÿÁ[åˆÁQ ýÁF5Á;š¬Á0ö6Á&.@Á+ ÁÊýÁAÀñ|CÀÚ¯ ÀÄkÀ®sbÀ˜þ•À„ô¬ÀevÀA÷À!À´ø¿ÕLk¿¨(w¿1s¿A}%¿ €+¾Êä¾’'Ѿ|5c¾Œ{p¾½IпN–¿GÄ:¿‹>F¿¹A¿ò"‚ÀÈæÀQÁG8ÁP‘ÁZ1ûÁdýÁn›üÁy´SÁ‚§Áˆ©/Á޹àÁ”ÿÁÚ¨Á‡¸VÁÀ‹Áw÷›ÁlíòÁbPÃÁWˆŠÁLôÁB—Á8ÝÁ-ˆ”Á"¯Á¹kÁ }BÁŠzÀí$ÕÀ×Ä}À¤vÀ¯ýÀ›õÀŠ=ÀsæsÀU€-À9ÁóÀ!›°À Ƈ¿ó°¿Ô E¿ºØ1¿¨`ª¿šË ¿— ù¿›¿¿¦3Ü¿¹8²¿×aj¿û%ÀS_À-V¾ÀK/•ÀlO!À‡ä‡À›UÜÀ¯©ÀÃzqÀØ«@Àí» Á€_Á Á«zÁ!4RÁ*À‘Á3„Á;ýÿÁD£HÁM^IÁV~™Á`?XÁj®Át`ZÁ8‹Á…JâÁ‹3ÞÁ‘MPÁ–õíÁµÂÁŠ£§Á„ÅíÁ~G¬Ás‹OÁi'žÁ^d)ÁT+\ÁIûwÁ?ÏŒÁ5RŸÁ*ÖˆÁ +Á…Á ÒÕÁUgÀì/3ÀØtCÀÅTÀ³Ï[À¢ì™À“£À…½ÀoµöÀX@ØÀC·™À2%jÀ#LuÀjÁÀd=ÀÀÒàÀéÓÀUÀÙÜÀ&KÀ7¦ÀKvËÀbTVÀ~ÊÀßÀŸë[À±ÜøÀÅA*ÀذÛÀì«"Á­oÁ ØdÁUÁbYÁ)¾Á2‰ÃÁ:¼»ÁC 0ÁK\œÁT.õÁ]75ÁfÒ0Ápã,Á{EÁ‚ÌïÁˆY‡ÁŽ!ûÁ”IÁ™úÏÁ“ÛUÁë³Áˆ2-Á‚µßÁzæÚÁpoòÁfûÁ[ЦÁQžÁGµ²Á=¾ñÁ3‡ Á)iÓÁ éÁ®Á ›±ÁÇÀî¨=ÀÜà®ÀËÿÀ»ù‘À­ ×ÀŸQ­À’ÙúÀ‡¼"À|8ÍÀkJçÀ\Ü£ÀQdÈÀHΙÀCRñÀBÀD“-ÀIŽÀS*0À`#ŽÀoºˆÀ~ÀŒzAÀ™ŠÀ§ì¬À·ûÀÉHÃÀÛÂ1ÀîIuÁÓ¢Á zàÁM¸Át§Á(EÁ1±?Á:@¾ÁB4øÁJ}žÁRè;Á[›ÁdÅðÁn(:Áx#+Á5qÁ†dFÁ‹ÌeÁ‘qÃÁ—M…ÁYÁ—\‚Á‘‘|Á‹þ*Á†Ÿ±ÁNÓÁx& Án'Ácô+ÁZäÁPb¨ÁFŒÁ<ªÁ2¾Á(ŸÛÁØbÁ>VÁ ôPÁó‘ÀôÆÀä¤BÀÕIáÀÇÀ¹µÀ­±ñÀ£"À™Î|À‘ÅÞÀŠýëÀ…kUÀœ{À~/8À|ñÀ¨ŒÀ‚(OÀ†ìGÀŒÛÆÀ”§{ÀŒÀ¨À³ÌèÀÁxÄÀКhÀàåÀòB©ÁHïÁ s²ÁåÍÁ$÷Á'™#Á1PÁ9è7ÁBS‹ÁJp6ÁRzfÁ[+ÎÁc¹vÁlÐûÁvJ¿Áú£Á…'ÁŠU•ÁœDÁ•³ÁšÔòÁ¡ )Á›3Á•Ž$ÁíÁбJÁ…YƒÁ€B¡ÁvŸÁl¾ÏÁbñ+ÁY;?ÁO·ÁF26ÁÁž¯Á¥ cÁŸXåÁ™Ó·Á”X²ÁŽë@Á‰¸2Á„¯<ÁtlÁu±mÁkûfÁbžÁY8™ÁOû„ÁFâƒÁ=°„Á4‰²Á+À1Á#+Áä?ÁòÓÁ uoÁ;nÀûPRÀîÿqÀäCÀÚ ÀÑy'ÀÊKÎÀÃîÐÀ¿'À»À À¹¶žÀ¹‡ïÀº  À½Z9ÀÁvÎÀÆü²ÀÍ­JÀÕœHÀß0ÀéXÖÀõv–ÁQÁÒ‚ÁjÁË-Á!7®Á)±øÁ2E»Á:ó ÁCtxÁKÌÐÁSi¬Á[ rÁcŒÁk\¤ÁtAÔÁ}תÁƒ¡(Áˆa…ÁkóÁ’¹ÅÁ˜ßÁióÁ¢×Á©T;Á£Á½Áž8kÁ˜¸íÁ“h‚ÁŽDÁÁ‰,üÁ„AMÁ~½dÁuYtÁl"VÁcÁZ5EÁQWìÁHˆÅÁ?ßÞÁ76¤Á/ûÁ'ŠÁe8ÁZÁ5}Á ãÁßaÀÿ>MÀõé€ÀíwÃÀæ[ñÀà²KÀÛÆÀØë£ÀÖõºÀÖÃÊÀØ{ÀÚ©ïÀÞy®Àã½ÀéÿµÀñ¹ÀútœÁP_Á 8Á5lÁ/ŸÁ¡Á$xÁ,MwÁ4аÁ<±gÁDðÁM2åÁU6Á\l.Ád<ÁlªÁtpÁ}bÁƒ&ÁˆxÁŒ²Á‘–¯Á–¾þÁœ$ªÁ¡ÁÁ§C€Á­Û Á¨8¾Á¢¢ƒÁ2gÁ—öŒÁ’ܱÁã¹ÁˆùÐÁ„/6ÁC¡Áv9WÁmB|ÁdŽNÁ\ÁS…+ÁK)[ÁBý,Á:ýVÁ3]MÁ+á¥Á$ÐîÁ?«Á‘ÁdyÁ BpÁÂÁÅâÁMÀý7Àø—@ÀõŒÀô)|ÀóúÃÀõU"À÷æ–Àû®ŠÁ.‹ÁF¶ÁßGÁ ®ÁÙÇÁOÐÁP¹Á!áÍÁ(Ê[Á0%1Á7’»Á?bŸÁG;£ÁNÑ/ÁV§µÁ^£±ÁeÉ@ÁmŠ÷Áu9Á}ûÁƒ=æÁ‡·sÁŒ6Á‘SzÁ–Á›CÁ S¥Á¥ÌMÁ«wØÁ²8äÁ¬š»Á§{Á¡¹6Áœ›ùÁ—¯{Á’¸ÁÚSÁ‰;Á„«ÁÁ€6dÁw­aÁoQ¯Ág²Á^µ£ÁVÁ,ÁNÕ~ÁG¬Á?©8Á8\8Á1ÐÁ+F§Á%lÁöSÁõbÁ›~Á°»Áv)Á ¯Á µªÁ ÑÁšæÁ|†Á .QÁ }ãÁ KVÁ‰ÁŠÒÁÉûÁÕ7ÁZcÁ"£_Á(HäÁ.VÁ4õÁ;Ó‡ÁBúUÁJ<ÁQ§ÁYBËÁ`­ÁhWPÁo×fÁwQûÁ€'ÁƒñfÁˆ<µÁŒ—Á‘7§Á– ýÁšÔ,ÁŸ°'Á¤ÊëÁªÒÁ¯¦©Á¶©)Á±qÁ«ªiÁ¦xóÁ¡‚9Áœ‹hÁ—’ËÁ’ÜiÁŽSñÁ‰ÖÁ…iÁ+¥Áz(gÁräÁj$^ÁbfLÁZµ}ÁSQÚÁKêÚÁE&›Á>¹Á8lJÁ2È:Á-xvÁ(¦²Á$z0Á ¶ƒÁ„2Áñ‘Áð¢ÁŒîÁ"Á {Á¾jÁ{Á‡Á‚ÁÌÁ"ðxÁ&žÁ+ ÿÁ/çpÁ5MÁ;%‰ÁAwÁGº¬ÁNzHÁUT‹Á\qÁcÇÁk=$Ár«³Áz9nÁ€ØCÁ„ÐÁ‰ÏÁbÀÁ‘¼³Á–5bÁšö>ÁŸÙƒÁ¤ŽÁ©„ÇÁ®³ÌÁ´¡ÁøÁñ±ÍÁëmÈÁå>ÄÁßlÁØþÄÁÒôzÁÌôÁÆþ‡ÁÁÃÁ»,ŸÁµ]–Á¯®ÆÁªÁ¤fïÁžå0Á™ˆ‰Á”AÁ-¯ÁŠP—Á…‘Á¨Áy¼¹Áqµ:Áj:ÁcnÁ]ÁX QÁSˆ„ÁOÌ/ÁMÁK)ûÁJ$ÁIØ—ÁJ $ÁKPoÁM³èÁPpÇÁT7iÁY Á^EäÁd^‘ÁjýVÁr$IÁz—Á]Á…ÆÀÁŠo¹ÁdCÁ”„²Á™¼šÁŸTÁ¤jÁª ùÁ¯³™Áµ}½Á»JnÁÁÍÁÇ÷ÁÍKÁÓ'ªÁÙ5hÁßL_ÁåvjÁë³ÓÁóHœÁìïäÁæœÓÁàSÁÚ¦ÁÓðêÁÍÔ0ÁÇĶÁÁÀqÁ»ÍþÁµÜFÁ¯ó4Áª!žÁ¤uSÁžÈŸÁ™&ëÁ“£ÁŽL¹Á‰ ½Á„‡Á~UVÁtîSÁl3fÁdgÁ\/ÁT­qÁNG"ÁHïúÁDM'Á@FGÁ=rÉÁ;qWÁ:$mÁ9þ¥Á:2ÙÁ;“¡Á> öÁ@îÖÁEÁJzÁO|EÁUß Á\»µÁdJéÁl­âÁuzýÁ~œÁ„1uÁ‰J>ÁŽ|ìÁ“×ÅÁ™OyÁžÏÁ¤sðÁª@ýÁ°ÁÁµçÐÁ»Ø4ÁÁèSÁÇûØÁÎTÁÔ-ÅÁÚ`ÊÁà¦$Áæ÷uÁî±Áè@ÁááÍÁÛŒòÁÕ>ÁÏÂÁÈÐ1Á­òÁ¼˜ÏÁ¶¡Á°Ÿ=Áª¬@Á¤¼‘Ážè‰Á™²ÁÖÙ¢ÁЂúÁÊ/|ÁÃîûÁ½µÁ·ŒÓÁ±q~Á«bôÁ¥p’ÁŸ~†Á™‰XÁ“²ÿÁŽHÁˆVÁ‚©XÁzMÁoÁNÁep-Á[{ÊÁQ̈ÁHןÁ@«xÁ8¢‰Á19»Á*ÿ Á&Á!‚Á)eÁNÁƒqÁX¹ÁšÏÁBûÁÚ3Á"4xÁ&á?Á,4Á2eÁ9DðÁ@ØÔÁI`TÁRPõÁ[»úÁeÁ(ÁpÙÁz»×Á‚ÜMÁˆYøÁüÁ“Ð&Á™¬ùÁŸöÁ¥…öÁ«šÓÁ±°¨Á·Ë+Á½þ1ÁÄEÅÁÊ•;ÁÐä Á×BÔÁݰŠÁå»Áß9_ÁؽæÁÒDgÁËÖ ÁÅ}²Á¿$ëÁ¸ßÞÁ² ±Á¬qÓÁ¦O±Á ;GÁšBŸÁ”PÐÁŽZžÁˆàÁ‚ËÓÁz:1ÁnسÁcÛJÁYeŽÁO.ÎÁE2éÁ;¦›Á3,Á*üÁ#ÁR°ÁíóÁR·ÁŸÁ nAÁ ÃJÁ •7Á à¥Á ¶ëÁV€Á kÁÕÔÁaÁ$}Á+1Á3VÐÁÁ‰#RÁƒ0äÁz«[Áo/eÁcÈþÁXe˜ÁMsÀÁC­Á8ñÁ.í¼Á%¡ÜÁ[ŽÁ_ÇÁ ïÏÁùKÁG,Àþc‘Àù­Àö'<Àõ£ÀöpðÀúzEÀÿâÓÁ¨ÁÖÁÁô!ÁÐÐÁq¥Á&5ÿÁ/cnÁ9õÁC'”ÁMÍ_ÁXí ÁcìÁo){Ázà ÁƒYgÁ‰I–ÁLJÁ•dÁ›|Á¡ž³Á§æÇÁ®GAÁ´ŒîÁºæ§ÁÁ\ÁÇá£ÁÎ]þÁÔá³ÁÝ KÁÖ€KÁÏéÐÁÉYkÁÂÑNÁ¼S-ÁµÙHÁ¯rÛÁ©üÁ¢ÂóÁœ†˜Á–OÛÁ!¼Á‰ÿ­Áƒö Á{òIÁp¡Ád^XÁXÏÝÁM`„ÁAýÁ7@Á,ãªÁ"·9ÁÀ•ÁÍŠÁË”ÀÿÞeÀò‘ãÀè¡qÀßÛœÀÚ©qÀÖ÷DÀÖ‡ËÀ×TBÀÛ·ÀáoÀé÷½Àô+Á´¹ÁÉÿÁ)TÁWÉÁ"è?Á,ÏFÁ7[ùÁBнÁM”9ÁXÓ\Ád’˜ÁppÿÁ|eŒÁ„9ÖÁŠT³ÁmbÁ–•mÁœçSÁ£P\Á©”ËÁ¯öÁÁ¶wíÁ½¥ÁÃ{¨ÁʹÁТÁØóíÁÒOÐÁ˰æÁÅ´Á¾y‹Á·è^Á±cÁªâVÁ¤rÁžÁ—¹ÎÁ‘{7Á‹BÁ…~Á}ݨÁqµüÁeª ÁYÜÕÁN BÁB|Á7ÖÁ+£AÁ Ô¤Á¸Á ‚êÁ»ÀôwÀ䕃ÀÕòÀÊðÀÁÍ$À»çLÀ¸ÅÀ·»À¸…dÀ½TÀÃgOÀËïÀ×^ýÀå’ÀôÁNºÁ ¶âÁŒ”Á ÷¤Á,)JÁ7?ÁBŽtÁNPÁZ0ŽÁf>EÁrOÿÁ~ Á…i'Á‹—‡Á‘óÁ˜U¼Áž¨ŒÁ¥ÚÁ«žÁ²"wÁ¸¥ÖÁ¿;rÁÅÞ£Á̆¦ÁÔø ÁÎ4¢ÁLj§ÁÀëƒÁºHÁ³§…Á­ }Á¦¢ÁŸöþÁ™}=Á“hÁŒ»íÁ†teÁ€6_Át@ÁgÎâÁ[”‹ÁOtãÁC§¦Á7èñÁ,8Á ¾·Á^ÆÁ «@Á‘Àì·~ÀÙê'ÀÉu#Àº~À­©;À¤9óÀl>À™Š?À˜ÂhÀšÏÀžq¬À¥€„À®]ËÀ».ÎÀÉMqÀÚ”Àí«Á_Á ¦ãÁÇÝÁ í›Á,Z#Á8÷ÁCðÍÁPÁ\-Áh°+ÁtäSÁ€§ëÁ‡6ÁeåÁ“ÈéÁš?ÞÁ Æ„Á§LfÁ­ÞLÁ´QÁ»)!ÁÁØÁȘ¤ÁÑ%ÓÁÊR¾ÁÃÞÁ¼Ì Á¶+/Á¯ÄÁ¨Þ­Á¢@~Á›«XÁ•`ÁŽ–Áˆ/£ÁÌ7Ávõ™Áje5Á^,ÁQÃÁE†¸Á9Y»Á-t‡Á!± ÁGÁ ”˜Àþu¤Àé# ÀÔÅÀÀÈÀ®Ý‹Àž€šÀ‘1 À†·À~ÆQÀvMØÀs÷BÀwÀ¢nÀ‡£—À‘Ô<ÀŸA¥À®üŒÀÀêÆÀÔo÷ÀèéðÀþàÛÁ ¡ÆÁ.êÁ!ÝÁ-²Á9ÔäÁF ÁR£ Á_ ›Ák‘ ÁxB3Á‚ƒŒÁˆø¸ÁsQÁ•òúÁœ†Á£'ÍÁ©Ì0Á°v8Á·1æÁ½ô`ÁĶºÁÍk‰ÁÆlÁ¿·àÁ¸Û¯Á²Á«h¡Á¤¼|Áž‡Á—=ÁçÓÁŠOóÁƒÀœÁz ˜Ám×dÁa$­ÁT}ØÁHÁ;·ûÁ/|ùÁ#a¨ÁXaÁ |òÀÿéòÀéÙÀÒ‹¸À½ çÀ¨ggÀ•†®Àƒ×¿ÀiµŒÀRÊÛÀCRˆÀ9»ôÀ7íÀ:4dÀBônÀUnÀlöÀ„4qÀ•.;À¨6ëÀ¼ìçÀÒfXÀè½~Á"Á ²JÁ‚ Á#Á/Á0<Á<°ƒÁI<ˆÁUؾÁb…VÁodÀÁ|wÝÁ„¬Á‹/:Á‘Ó Á˜~ÁŸàÁ¥ËÒÁ¬ŽyÁ³Q•ÁºvÁÀðƒÁÉæ?ÁÂæÛÁ»û¸ÁµEÁ®<ªÁ§h‘Á ° ÁšéÁ“YŠÁŒ¾ÕÁ†'ÆÁÁqîÁdò˜ÁXìÁKeÇÁ>»ÉÁ21lÁ%Æ£ÁˆqÁ }ÁcüÀêϼÀÓåÀÀ½÷À¦¹MÀ‘!ÇÀxäÓÀU,°À2ºØÀ`¶ÀX#¿üo ¿ö´§¿üƒÀ ÀôXÀ4’ÛÀT«ÎÀxk]À‘:¬À¦J<À¼W*ÀÓ²³Àë!ÆÁyÁ ÙXÁQôÁ&ãÁ3v¡Á@'ŸÁLðKÁYîqÁg˜Ásé‚Á€ƒ’Á‡,²ÁÐÓÁ”zÁ›2ÑÁ¡ö…Á¨¾ŸÁ¯’oÁ¶eáÁ½;nÁƆxÁ¿wüÁ¸kŽÁ±rÁªôÁ£¬ÐÁœÎýÁ– <Á]qÁˆ²<Á‚ ÁvÔfÁi”gÁ\^CÁO]+ÁBeYÁ5«”Á)åÁˆ¯Á Á²DÀï8À× ?À¿&VÀ§é)À‘-ÀuÍñÀJÓaÀ#‹„À{j¿ÊwÛ¿¡½Ú¿ŒÒ¿„I÷¿‹†Õ¿Ÿ’£¿ÇÕï¿þØÀ"ÕÀK#Àu22ÀañÀ§˜«À¿EÀ×^5Àðj½ÁËŸÁKiÁÖ8Á*¬½Á7šŒÁD‘ŒÁQ•tÁ^­ ÁkÏ—Áy-Áƒ5¦Á‰ë¢Áž Á—bÁž6(Á¥ †Á«ÞŽÁ²ÀGÁ¹·ˆÁÃ<&Á¼#>ÁµèÁ®¿Á¦þÃÁ +Á™0UÁ’PÀÁ‹&Á„ÍnÁ|HóÁnèLÁaŠcÁT4sÁFæÁ9ÖÑÁ,ÜuÁ |ÁpÁä³Àôð]ÀÜCRÀîýÀ«¡›À”-ÙÀxøÀKA{ÀLÌ¿ìó¿¢ð¿D—¾¾Û{;u}¾B=Ò¾kzë¾Ð ‚¿<"¿žú’¿êW;À¯ÐÀKEÀx §À”/™À¬§¬ÀÅÄóÀÞïœÀ÷ãÄÁˆôÁy$Á"g1Á/G‚ÁÁI¤ÁV¨£Ácê‡Áqi’Á~¿%Á†_ÁŒÝÁ“²ÁšˆÁ¡a¹Á¨RŠÁ¯VªÁ¶]:ÁÀ0hÁ¸úÌÁ±Õ:ÁªÂbÁ£µœÁœ©Á•­ûÁŽËyÁ‡îÓÁÁt¡ÁgL$ÁYæ#ÁL‡Á?ûÁ1¶œÁ$tÁšÿÁ ºªÀûøqÀâÆZÀÊ KÀ±a‰À˜ØÜÀ€ÔqÀR¥wÀ#Æf¿ï+™¿˜RE¿I ½N¿>Ÿî5?z?‡ß? É¡>¹u*¼I“œ¿ mŠ¿–:¿îB€À$ò ÀT;ZÀ‚¤{À›VÝÀ´h>ÀÍÒ6Àç&xÁQßÁ ?sÁ>QÁ'mQÁ4ŒÁA·ØÁNúÙÁ\`®Ái¾·Áw90Á‚qÿÁ‰H’Á'Á—'ÁÿïÁ¥ +Á¬àÁ³'êÁ½JÆÁ¶¥Á®ÚÁ§¨‡Á ‰«Á™}ñÁ’udÁ‹nEÁ„yÒÁ{6Áms±Á_ÀÈÁRM;ÁDç5Á7’{Á*UøÁäÄÁ¢Á¯Àë|¤ÀÑä‹À¸š–ÀŸˆ–À†ë-À]›…À-«¿üw>¿¡ø¶¿Ââ=Xñ?I?o†X?‘R$?–y?’,,?t£?°J=è뿺U¿¥–àÀÆÀ1Ÿ÷Àc‹À‹ ÔÀ¤ÏËÀ½¢®ÀÖ݇Àñ«Á}qÁ|ìÁ¸{Á,ý‡Á:èÁG†­ÁUÁbœÁpDÁ}òGÁ…ØÁŒÇ™Á“Ì{ÁšØ—Á¡ê`Á© ½Á°.fÁº’ÌÁ³IÁ¬ SÁ¤ÔùÁ Á–t§ÁWJÁˆK²ÁC ÁtwÁf“<ÁXÕÁKôÁ=TÁ0,1Á"ÏÁ‚#Á7¼ÀõÛ(ÀÛœŠÀÁ²¬À¨.´À1¼ÀlSyÀ;¢jÀ ªÍ¿¸7Þ¿:Q›½xß\?cÑ?‚;?§²?·î(?¾WR?¹f?§/a? ƒ?’§½þÅØ¿TB#¿Æ)5À‰ÀE>üÀw§,À•(áÀ®jˆÀÈËÀá¸Àû©ÞÁ P‡ÁaÁ%…œÁ3ùÁ@¤fÁNËÁ[¸ûÁiŽ%ÁwkjÁ‚¡?Á‰Ÿ Á±½Á—×Ážÿ•Á¦("Á­S›Á¸ Á°·²Á©e0Á¢šÁšÒöÁ“ AÁŒtQÁ…HbÁ|Q‰ÁnBÁ`;ÁRAeÁD…œÁ6ÛûÁ)C Áã£Á‘]Á'•ÀçŒ(ÀÌøäÀ²”1À˜ëËÀ(ÀLÔÁÀ‚g¿Õ N¿s€t¾v>»F½?`öã?œ@z?´ò?¿ˆä?ÃRX?Á°¡?µ#Ò?—1?LÓN>c4+¾àÿY¿’¤¿ó)ûÀ)¹†À[À†·½ÀŸú·À¹Ü3ÀÓ—cÀíþ«Á5•ÁZ‡Á¿Á,@Á9ÏäÁG€8ÁU]hÁc-ÞÁq pÁÒÁ†«Á×Á•Áœ0MÁ£f1Áª¬aÁµ¡ Á®9nÁ¦ÞOÁŸÁ˜<ÂÁîmÁ‰¯ôÁ‚„ÙÁvºRÁhn ÁZLÜÁL[ZÁ>r¥Á0£AÁ#¢ÁUôÁ¼ÉÀôõ7ÀÚg´À¿ç2À¥iÀ‹eœÀc‚aÀ1]À6€¿¡s>¿7¼=ÐfF?!3z?fÈ? ¼0?±žE?¹™³?¼ÚM?»Ä”?³–Î?ž³†?p‡>ë¸Þ¾ðê¿MÝs¿À †À‰nÀAȹÀtÄ À”þÀ¬]åÀÆ…,Àá.UÀú‡Á µ¼ÁgáÁ%ÞJÁ3f ÁAAsÁO8 Á]9šÁk\>Áy²ëÁ„´Á‹7ýÁ’hÁ™©YÁ ÷§Á¨F“Á³gëÁ«ú¡Á¤÷Á'TÁ•Ð[ÁކÁ‡=ìÁðÌÁq‰žÁcIÁU ÌÁFÜÁ8ÓÿÁ*ñHÁDÁC'Á£mÀè#ÀÍšÀ³6À˜Ú·À}·ÀJ-ÆÀ+£¿Ò/^¿i¡£¾~oF>£f?>ÿ®?…9Þ?œI‹?©mH?°~?³ÖÓ?³‰ˆ?¬zª?›È±?y@þ?˜=€º¿ R¿›x¿øòtÀ*ÓŒÀ]øÀ‡«ˆÀ ^þÀº\!ÀÔšÀîÑ»ÁàíÁ3CÁÁ¶Á-¹ÐÁ;ØüÁI÷ ÁXÄÁfY&Át½pÁ™£ÁˆÛqÁhÁ—](Áž«KÁ¦VÁ±V5Á©ßãÁ¢u¯Á›Á“©ÐÁŒIpÁ„úŽÁ{x”ÁmFÁ^‰$ÁP FÁAÜ=Á3´Á%{ÁrÁ ÖˆÀøt·ÀÝž„ÀÂøíÀ¨ªÀކ\ÀhãPÀ6¶"À^q¿©y}¿+à˽˜”A>È£Z?>€é?~ÙÚ?”rŠ? äÀ?¨Ã²?¬ªC?«±Ñ?¤ë?•n?sÒ`? -E>!86¾ÇÇ>¿€ly¿Ø‡ÀªáÀIërÀyaµÀ–DÀ¯ùÀÉ(ÕÀãÞ¨ÀþÙÁ ÁÁ)(¸Á6ò!ÁDø£ÁSGÁaÏKÁpmSÁ~á°Á†¢mÁåÁ•;èÁœ¢ìÁ¤}Á¯™XÁ¨GÁ  Á™Á‘¼iÁŠa!Áƒ¦Áw_¼Áh¿%ÁZ9fÁKÂ=Á=SÐÁ.øÚÁ âÖÁíÙÁ ËÀîçÀÓÿ<À¹1ÏÀž”«À„šaÀV–ãÀ%’9¿ì”G¿”㥿 !Á½&Y…>ÁM?3ë(?o¬¹?j&?Pì?¨œU?¬Ôô?¬9Š?¢#Û?<?fÀk?ñj>Fô(¾Ž·ã¿_8¿ÁKMÀ “­À;öÀi*AÀ†wÀ¦±—ÀÀÝ”ÀÛÛxÀö1ÆÁÂàÁ«ÁÁ$˜/Á2¢Á@íëÁOWaÁ]Ô’ÁlSCÁzÚEÁ„·HÁŒÕÁ“žÁšíÁÁ¢\%Á® QÁ¦•3ÁŸ ±Á—‡AÁäÁˆ¤/Á@óÁsÎ6ÁeÁVmÉÁGÐÀÁ9hdÁ+,£Á¤Á›ÁAÀçÀËÊ#À°ðŽÀ–í;À|#ÀJ{\À}¿Ù¿Šñ¿r½•£ï>¤ÿ?! .?cMÐ?‹æ!? Êï?¯ñº?·%Á?´®?¦~®?X¶?_äê?‹ >?Q¾Ž‰µ¿Pàê¿´|ÀÃxÀ.¾ÓÀ\ªÀ†ù·ÀŸè‹À¹ÝÀÔÀîå£Áb¢Á_ôÁ!.ŸÁ/)$Á=[ŒÁKÑšÁZo1ÁiçÁw®žÁƒ/ÅÁŠ˜XÁ’ˆÁ™v‰Á ï|Á¬ÍÁ¥HÁƤÁ–GnÁŽÈÁ‡G~ÁÂÁp ?ÁaÔÁS5ÑÁD·ãÁ6L¨Á'ùèÁèâÁ úðÀü Àà‡=ÀÅTÀª×UÀ‘«ZÀq6öÀA#À ¿× l¿Š³ ¿kT¾[>‚«?Rq?eôH?“Ñê?¯QÊ?Ãe[?̸4?Å¢l?³à†?˜!e?c ? ïï>ê¾™;_¿RRŒ¿°Ÿ¨¿üIÝÀ*1¢ÀUvÀ‚©JÀ› À´Ê:ÀÎÈÀéÌŒÁ¯ôÁ{ÁK¨Á,d‹Á:ºÙÁI$ÐÁWõÁf#ŠÁtÈŸÁËVÁ‰C‡ÁÇpÁ˜LTÁŸÑ8Á«¥Á¤…Áœ—›Á•çÁ™-Á†ÿÁ}GÈÁna[Á_†­ÁPÀlÁB*Á3Ñ+Á%¶XÁ¥³Á ›&À÷TÀÛì“ÀÁ\ À§ÉžÀŽAÀk©µÀ>×À-¸¿ÙõÙ¿’õL¿&î×¾Hú>fRº?º§?~ñl?©¢à?ËQl?âß?ëóö?ä j?Ìrò?ªŒ1?{V?ø>ó•¾°ÆÙ¿\Âû¿µ%v¿þ¶¾À(À·ÀSTyÀ€ø/À™L;À±®¶ÀËdøÀæ–FÁþfÁŠ'Án7Á*œEÁ8ÎÁG…ÁUe@Ácþ6ÁrÄpÁ€×ÅÁˆS¼ÁÑ Á—O¥ÁžÖ–Áª«NÁ£Á›Á”ˆÁŒ›Á…) Á{sÁlÊÁ]çÜÁOI”Á@ÃùÁ2[þÁ$ZÁ—ÁôIÀô7ÒÀÙ‰À¿óÈÀ¦€ÉÀwóÀlÅ]À@WåÀÃd¿ã­A¿ž!Ú¿7„ξbÓú>‰ ¨??TÝ?˜Ô`?ÌYÓ?òt´@ú@ e<@h?ôÕ?ÊìÓ?”„û?/&±>/&õ¾¿ ¿olË¿¾¸ùÀÓÀ,E`ÀV„|ÀƒÀ˜æëÀ°ž§ÀÊrÀä²ÃÀÿœÁ N1ÁMÓÁ)sLÁ7š¬ÁEÓ£ÁTIõÁbõ$ÁqÂÁ€KÄÁ‡¹ÛÁ.+Á–°[Áž>àÁª”Á¢xÕÁšç0Á“a5Á‹èÃÁ„€$ÁzDšÁk“ìÁ\ðqÁNaœÁ?ÿÁ1£ŠÁ#H¸Á ¾Á/æÀó›‰ÀÙ¥ À¿èbÀ¦êªÀ‰ÀqºJÀFðœÀzž¿òY©¿© þ¿?Æú¾E¾>×y?zd`?¾ZG?ù‹£@X†@"´ @)™}@$oÂ@0ì?õm??µ1Ã?ZIÂ>„ê¾Âr´¿yá0¿Ë˜WÀ ²#À3…ÌÀ\ЪÀ„6ÔÀšÒ"À²á@ÀË“´Àåu•Àÿ2ÆÁ lÁùÝÁ)#tÁ7NyÁE„LÁSô&Áb™%Áq]­Á€¹Á‡wãÁŽí*Á–p…ÁÿðÁ©ÝxÁ¢?#Ášª«Á“!˜Á‹¥¿Á„9aÁy¾Ák5Á\ÉšÁNuÁ@&ZÁ1Ö'Á#‘Á‡©ÁÒ Àõ&%ÀÛ‘XÀÂÀª jÀ“EcÀzy ÀOܬÀ(~D¿þpο«²¿%f»§ ¾¡Uô¿z‘D¿ÔÀ~À;Ï¢Àe±øÀˆ²¾ÀŸEÀ¶yPÀΈ¬Àçf ÁkÁ É#Áž¼Á)’÷Á7’‘ÁEºÁT$µÁb²*ÁqMœÁõéÁ‡^ÎÁŽÓ|Á–V~ÁåÈÁ©¿*Á¢HÁšÓÎÁ“OÁ‹×8Á„n[Áz.ÊÁk¬ÈÁ]L$ÁNï\Á@ªKÁ2ÑÁ$“DÁÒ”Á ‹tÀùŽÀß6(ÀÆÌ9À¯yfÀ˜Á˜À‚ô¸ÀZêÑÀ-¬R¿øÔ|¿—š1¾á3¸>7ø?€Ä?ׂ¾@Ù°@8<3@VüX@n7û@x]@oÛI@TÅw@.§@c?¥? 1t¾DÂq¿q#³¿Õ÷¤À$ÀDTÀp=ÀŽ ÊÀ¤í@À¼o1ÀÔ¨2ÀíäÁèÙÁô~Áˆ¦Á+IèÁ9ÁG&*ÁUcmÁc­§ÁrOÁ€TªÁ‡³¡Á#åÁ–¢äÁž.‡ÁªïÁ¢Œ@Á›ÇÁ“©dÁŒ>¾Á„åLÁ{>ãÁlá6Á^º8ÁPS ÁB'ÈÁ4KÁ&¿êÁqgÁ ,pÀýSKÀâmhÀÈ{+À¯3]À–¼æÀ~FdÀMȾÀ¿Ñ…;¿V–§½™I|?)Oe?³ 6@ÇŠ@0²p@YGù@{¡V@‹jF@“^@Ã@u/@H|@.Ë?Ï’Ö?R "Á/~ÁÁ ßGÁG Áù‰Àì6ÊÀÑ%…À¶/ÿÀ› oÀ‚G­ÀSôÀ$G;¿êƒ[¿‹wy¾©/#>ÐÉ-?“KÅ?îн@%ó@Rò!@|ã@‘¹@¢v@«ì(@ ¨@ŠÉ‘@dÆ@2Õ­@†9?™o>º8À¾æß俤MúÀøïÀ<àòÀrÀ“´EÀ­Ñ{ÀÈ&OÀã.ÈÀûÛ[Á 9ÁÝÁ#‚WÁ0s÷Á=ÝÁK¥áÁY·ÔÁgî3Áv?]Á‚RrÁ‰˜¸Áò€Á˜\öÁŸÐúÁ¢Ý‡Á°Á—lÁðHÁ‰M¥Á¦…ÁsÿDÁdÁ§ÁUŸ’ÁFŸOÁ7ÈdÁ)þÁWÁ ¿·ÀúE”ÀÝuÀÀn³À¥sÀ‰øXÀ^ñÀ*Èr¿ñ”T¿“Çc¾×w³>”Y?€ñ+?ݸK@³î@Jú±@v%@&@¤ {@·î÷@Å¢µ@²m@š3@•æ@P#0@SÊ?Ï €?P¶È;è š¿L·t¿ÎÈÀŠÀO0}ÀsgÀœAeÀ·Y4ÀÒ‹£Àî}¶ÁŽÁãÔÁ"O‘Á0å#Á?¦¶ÁNŠÝÁ]9ÔÁkšÁy×Áƒ¨íÁŠÝ¿Á’'¶Á™sØÁŸœèÁŸz;Á™ŸŒÁ“îÁŽBÖÁ†ð5Á~{ÁoJÁ`bÁP¹#ÁAjäÁ2)Á# sÁáÁQ¦Àí0€ÀÐZÀ²ÌšÀ•‡iÀqëÀ;œ3Àª¿¢¾õº%>ƒþÁ?|¨,?ØÏ¬@ @Däs@r2Ô@åN@¤°3@¸ç@ÌÁø@Û}_@Ä@«­j@‘ð5@p+@=y@ ƒV?¯IÌ?M™¾nZQ¿…|¿ìå±À*¨À`Ú·À‹œJÀ§2OÀÃÊ%Àào Àý9QÁ HxÁ+$Á+/ Á:@*ÁIWyÁXƒ Ág¿¨Áw ,Áƒ0âÁŠräÁ\îÁ–x`Áœ¶ÙÁœlúÁ–séÁ¬ÿÁ‹ ŒÁ„ÏÁz*JÁj¼îÁ[XÀÁKÿÓÁ<´çÁ-s{Á%<ÁÖýÀÿ!*ÀàðöÀÃCÀ¥¹ßÀˆƒFÀV§@Àڿƨ¿4ë/> È ?miì?ÕÆÃ@3æ@FD‹@ra~@Ž‹4@¤1ë@º/í@Ïà@âÊ@îOq@Õ˜@¼k<@£ŒÙ@Š)@alé@//?ùYw?“ˆ >°!l¾í©›¿¦ À `âÀ?èØÀxî`À™šÀµÔ ÀÓIŸÀñL»Á¼—ÁÔÁ%ýïÁ5; ÁD†åÁSå¶ÁcZÅÁráÔÁ;ˆÁ‡›ÊÁš™Á“´Á™è/Á™ºæÁ“¥íÁÁÂÁˆªÁ‚y™Áv]·ÁfÐãÁWIæÁGÇ™Á8L´Á(Û@ÁvÁ !WÀõ¾À×"ªÀ¸†+À™ðwÀwÅ“À<« À e¿YÀ¾R®X?,J‘?š@,[@EFë@s=Á@ @¥Ü2@º÷L@ÏÏç@åM@ùõ›A8Ì@ç»@ÏÁ@µžÎ@œ•b@„A@U™@"Ó.?Þ&ª?lšÒ=–94¿Gm,¿Ô}àÀ#vÀ\ÞÌÀŒ!ÀªMÀÈ{_ÀæÙûÁµ´Á©Á!xÌÁ0úºÁ@ÌÁP3¶Á_ã]ÁoœrÁ~nµÁ…hÁŠó—Á‘<Á—`€Á—@SÁ‘CÁ‹‘Á…D¡Á6ÁröêÁceéÁSÕÁDD?Á4ŸûÁ%‚Á~–ÁùMÀìéÖÀÍöÀ¯'JÀ’ŒÀcõ·À&¼¹¿Óž¿7©Ð>O*?Žž@Ç@9yX@nóD@ÕV@¦£Î@¼ÍÊ@Ò‡¤@ç&¾@û®AfÏA ´Ä@ú’g@ác@Èþ@°ks@—C/@{âV@H"}@£?¹?¾¥Ø,¿œ6ÞÀ AïÀFGÀÉÀ ‚´À¿@pÀÞ(ÁÀýRÁSxÁ @Á-Ò3Á=Ÿ‰ÁMp€Á]5íÁl¾ìÁyЉÁ‚‘ÁˆŒžÁޱïÁ”ë{Á”Ñ ÁŽ™ÇÁˆ}µÁ‚•bÁyÃ2ÁnmRÁ`-öÁPŸ(ÁAÄÁ1r‹Á!ÐÁ*òÁ…VÀå¿tÀÆzÃÀ§fŠÀˆ[úÀR¢ÓÀ²¿­šÎ¾Í0Ò?K?Á—Â@íê@VKp@ˆ\‚@£àÙ@½ á@Ó¨¼@é'@ÿ3A ±0AÏ“A7Á€PÁuÁi½ÇÁ]tÁMöËÁ>^ÍÁ.¯_Áþ)ÁC3ÀÿƒÀßž*ÀÀF'À î#À–ÀD€5Àé¿?¡¾«?ROÜ?åŒr@0©‚@mâ€@•X@²£Ì@ÏÕ”@êFŽAVØA 'ÕAñ²AÒ“A9FAÿ*AŸê@ðH@×S@¼¬ @¡IY@„ls@Mm@ñ™?¤ìE>Ÿ.¾¿-Šë¿ÔðáÀ)Ž&Àh£ÜÀ“àŸÀ³eÀÓPkÀó ùÁ }.ÁlêÁ)^nÁ9?ƒÁIhÁX~kÁe"ÍÁpeÇÁ|qÁ„ ßÁŠ$ÀÁDlÁlUÁŠ9÷Á„9Á|¯Ápð»ÁeÃÁZ7{ÁK,)Á;ÏTÁ,%‹Áu¶Á ÐÔÀúUrÀÚÆÀ»5À›¤Àx&:À9;¿óòÿm$ü=Y²?„xÀ@(@?éø@~7È@ž6@½PY@Ü@ú!àA æAÜÉA!—ÖA,AýA'KðAðkAm4A¨@虃@Ëã@¬Ý(@[™@[¡|@>'?¸Ðã>ä•á¿ å¿Æ1]À"ô‘ÀbâÜÀ‘kÆÀ±f:ÀÑ<£ÀðïºÁPÃÁÁ'æ Á7£rÁG%UÁUìÍÁanÁl·¡Áx},Á‚5oÁˆ6|ÁŽ@sÁŽÈšÁˆ†¡Á‚qÖÁyìÁm(ÃÁa}ŠÁV<ÏÁHöŸÁ9ˆ¶Á* …ÁSåÁ šFÀõÁLÀÖN À¶ÚÍÀ—=µÀo<êÀ0ä¿áðc¿G]ÿ>T“"?˜ÓÈ@ ‹t@Jéµ@…-@¤¹@Ä$y@ãÝA~xA­A Ÿ¾A-cnA8 cA1NþA$ÄBA'öZˆ¿¦`¿Áq À WØÀ`rÀëÀ¯ÏÀÏ´,Àï™óÁ§tÁxÒÁ'2Á6–KÁE€§ÁS/8Á^-äÁi…ÏÁuTÁ€š[Á†Š§ÁŒVÁd²Á‡&2Á 1Áuô)Áj?Á^u^ÁS1‹ÁF·nÁ7‹%Á()~Á¯Á "ÕÀòÜ–ÀÓsÀ³ã›À”QÖÀi€#À*>¾¿Õ¹”¿-ëZ>Ÿ8è?¦”;@¶@R"@ˆÇ@¨}@È;Y@èçAìãAÉ$A#¥AA3]ACKA4|ðA%òAs2AÎr@ìSd@̾>@­)@“è@[°i@*ù?¹K>é¿ Ÿ¿¿Ä<ÑÀ!ضÀa“Àu{À°¸ÀÏ“öÀï#3ÁFdÁ÷ñÁ&RÀÁ5w¾ÁCä§ÁP0>Á[XÁf‰úÁrlïÁ~[QÁ…%1Á‹$ÞÁŒÞÁ…ЈÁoPÁsL¿ÁgSûÁ[ÛÁP¥3ÁD×+Á5õìÁ&¯…Á<³Á¿ˆÀð>“ÀÑÓÀ±ÏñÀ’EœÀevÀ&aâ¿Î;†¿BÉ>»âõ?­¶¾@K'@Uºï@Š•[@ªU@Ê$â@éöuAäA©A$š¥A4w°A<ÄA/BçA • A‰_A4¢@å¿ö@ÆÎ;@§ÐÑ@ˆÖç@S,Õ@Oþ?ªæN>´²¿!¿ÍëËÀ&ÊÀe9®À’-ÉÀ±²ÅÀÐÔÖÀïð ÁjÁ×Á&]Á4Ô¥ÁBÎyÁNÁXà¶ÁdNmÁp"ˆÁ|šÁƒùùÁŠ/Á‹$XÁ„ÖÅÁ}rqÁqo Áe†ÊÁY÷±ÁNZÁBá°Á4ÌìÁ%–•ÁXýÁ÷zÀï$ ÀÏúÀ°½…À‘ ÀdP„À%M¿Ì˜|¿+µ>½³?­oh@Ù5@U¤@Š @©bÿ@Ȭ§@èAÖA(0A"„ÔA*z6A,ÊkA'ÇöA( A ü¬@úÛ°@Ý'æ@¿d@ tz@Ó@FQà@¹?–0c>Wv¿D?¿ßÁ À-è]Àk¶ÑÀ”£7À³—üÀÒ¼¥Àñq¾Á€Á"Á%ûbÁ4kÁA–_ÁL1®ÁW˜Áb>QÁmÅ¡ÁyŸ®Á‚ðÁ‰:ÁŠ’Á„-ºÁ{à"ÁoÇàÁd¸ÁXˆqÁMVÁAhðÁ3ñJÁ$õlÁÒæÁµoÀîÒNÀÏÿ×À°ý…À‘âBÀe“¢À&íf¿Ðï+¿*ÝX>˜>£?¡ªI@J@MÎ$@†)@¥H×@Ãâä@â@qANAäþAFAU¶A¿AÛ.AÜtAÊ(@í´‹@ѯ)@´zø@— +@qêä@5Ár?ó/ÿ?rÌ&¼/ö¥¿xKÛ¿ö%ûÀ8ËÀun|À™h}À·áÀÖôÀôVÎÁ 4ÁÿUÁ& €Á4L|Á@dÁK=ŒÁU¯­Á`PÁkúäÁwèGÁ‚"ÑÁˆßÁŠ%Áƒ¶gÁzÝÁÁn¸/Ác ÁW°ÁL,”Á@ž Á3§·Á$öÜÁ|Áò†ÀïÀ‰ÀÑnšÀ²öËÀ”wÀjÕÕÀ-õò¿ácÊ¿K.>1­»?’x@±o@BmÅ@*@Ÿ(@»Yš@ØAH@óГAøEA JEA 9ÑA01A ó…A’œ@÷®€@Þã@Ã0-@§cë@‹T‚@\A]@" ™?Í+T?+$_¾ˆÓ¿š'jÀ 0$ÀEL’À€Ð÷ÀžäÏÀ¼ÛxÀÚ{§Àø>KÁ ËÁB]Á'r1Á4Ú5Á@RÁJ¢ÈÁTí,Á_ÌÁkAÁw7wÁΟÁˆ1ÁŠÜÁƒ§oÁzÐzÁnµùÁbë,ÁWSøÁKµxÁ?ãºÁ3ÐÌÁ%sÉÁ³%ÁüšÀò¿ÀÔPMÀµë­À˜ÁÀsþ$À7¥¿ôë^¿y‹C¼å¾•?k™§?í‚´@1Ào@l6l@’ù'@®ãî@Èüj@ݽÖ@ëô„@ô£ø@ùó“@ýÁ@ý[›@õ!T@ã&–@ËòR@²±l@˜O½@zEÇ@BÿÙ@ Ï?¢Tö>¹[a¿ñj¿¾‰Àï ÀTÿqÀˆ–À¥ÄöÀà êÀàU_ÀýDWÁ ïDÁÈÁ(ÐÆÁ5ÚÁ@]AÁKYÁUSJÁ`-9ÁkŽÁwVÁøCÁˆXùÁŠ|Áƒ´Á{ ´ÁoŒÁcL¸ÁWˆ¯ÁKí^Á@JÖÁ4h Á&®FÁ/Á ¸Àö}ÀØ:žÀºÍ?ÀPýÀ™MÀCåÀn¥¿š6¾”âf?!u"?Ãóô@wd@Rñ£@„YM@g@²Í%@ÃF,@Îó$@ÖqÈ@Û”a@ß$‘@ÞÛç@Ø ˜@ËYÉ@·>`@ 9@‡Xµ@[v@&Nw?ÞÅ•?^ôr¼Áìý¿j¨û¿æ§™À-ÃíÀh4ÀÅþÀ­|vÀÊTÀæ¸qÁ‘ƒÁ ¬ÁqÔÁ*³üÁ6ItÁA5ÁLÎÁVkÁa. Álˆ¤ÁxfÁ‚Z-Áˆ².ÁŠzÖÁ„!bÁ{ï~Áo×YÁcã‡ÁXL¬ÁLÝ1ÁA?vÁ52qÁ(S@Ám8Á ,Àû6xÀÞ½1ÀÁýÕÀ¤ÞÀ‡˜yÀT·ÀÍ‚¿Áû¯¿£æ>‹‡N?’Ì?ÿö¨@4@d3©@‡·x@™€@§ö@±¼ @¸}ý@½}0@À¤z@ÀfÖ@º½¹@°H·@ {@‹e•@hy@7Ìý@…A?¢j >Ø`¦¾Û¼S¿¦ ¤À ÷OÀBùUÀ{ðqÀšv×À¶°jÀÒ›æÀî|ÛÁ0ÁךÁ 'àÁ,£ÎÁ7ÕòÁBtÁMf±ÁW£^ÁbScÁm›EÁyg\Á‚ÒíÁ‰#¶Á‹T Á…Á}›`Áq?vÁe Õ?`é?ÅÜz@ (¦@*†Ù@FVN@\ƒ‹@lý@y£@HK@ƒÔ@ƒeÇ@~Ä@mï @W™@7l`@2É?ÏŠh?g‹û>&RZ¿0³¿´ÊˆÀ Ö¦ÀB/ãÀvÂ8À–ÚXÀ±ØcÀÌãKÀçŽ`ÁÿÁ ý¢ÁÜ‘Á'V*Á2cŒÁ<ÒeÁG+×ÁQ ÁZû¼ÁeždÁpÙÁ|—¡Á„d2ÁŠ®-ÁˆÆÁ‡GØÁ)ÁvBKÁj‰ïÁ_UÁS“SÁH&ÑÁ<¥SÁ0º¯Á$‚@Á–RÁ =’ÀùŽ®ÀÞshÀÃw÷À¨ÅÝÀ±\ÀeTŠÀ1ÚL¿ýíh¿˜ß¾ðÒ>L#Û?O4Þ?­‚¾?êB«@Ñ@"‚5@1|Ë@<áé@Ff²@KAœ@IÌ8@BX@4|@Ф@ö‹?Ãó?h•j>‚˾ê'r¿—Ïÿ¿úÉŒÀ.¾–Àa~ÀŠÝÀ¤ À¿ÀÙyÀófÁŸ¯Á?…Á‹”Á+S{Á6:Á@ÄÁIçpÁSÞøÁ]æ`ÁhfàÁs€ÀÁüÁ…™–Á‹Õ§Á!÷ÁˆÏ#Á‚™ïÁy/—Ám£§Áb…žÁWm<ÁL_Á@¯Á5R¯Á)1LÁ–Á·æÁ³•Àë7êÀÐÏ-À¶GAÀœRlÀ‚ÿ ÀSD«À"J¿è©×¿‘½[¿W¦="›8? Õ­?wâ?ª«É?Ð<õ?ìÕŸ@‹&@ z@í¹@ œ/@›Î?ò;Q?ÌÒK?œo'?<3&>7e¾çÀ“«wÀxÀJ?ÿÀu¿î_¿£’ˆ¿AÐ…¾•:†=Ö«>ârß?6ë?mcP?ŒhÉ?œZ?¥3®?¢½&?•bñ?y0Z?2Û%>²ûé½™R”¿¼ó¿—2¿çèÞÀvîÀJ\ÁÀx!fÀ“¨¨À¬VÀÄE†ÀÝnÀö!ÀÁ9ÆÁ:YÁ5Á*׫Á5\@Á>ßÁHCþÁQÄ"Á[˜Áe¯kÁp†Á{‰Áƒ@!Á‰5“ÁW¡Á’õHÁŒ½Á†µÁ€äÁv™·Ák…ÙÁ`vÁU“ÐÁJ§‰Á?®Á4:xÁ(~~Á~dÁNÁ²ùÀîn-ÀÖ¡À¾+dÀ¦_®ÀèüÀsi°ÀLôÀ%ÿ¥ÀA¿Ê£¥¿“T¶¿G1¾éGY¾K´ì:ÉRD>.>•^>°b½>¨£>mÝ=kB—¾OË#¿åp¿hS†¿³k¤¿÷“~À!õpÀIÈ ÀsÛ´À§À¦ÛŸÀ½ÌÀÕÄ‚ÀíR Á¿8ÁÑÁ…åÁ%ëJÁ0ÿñÁ;VÁD>ÏÁMUAÁVnFÁ`9ÁjBüÁt©JÁtÁ…bjÁ‹D-Á‘@˜Á•qÁUÁ‰hÇÁƒ¬SÁ|_ÁpÿKÁf‘Á[&¸ÁPv­ÁEÁäÁ:¡§Á/6Á#[EÁq7Á wLÀÿwÀç¦HÀЙWÀºDìÀ¤rCÀ…NÀz­ÜÀX?NÀ87¨ÀÀŸh¿Ô¶Z¿­pP¿Ž7,¿jšã¿Aì_¿$­»¿Ý¿pj¿3Âf¿[ܘ¿c,¿´÷¿ã\qÀ ¦vÀ.'iÀQH©ÀwMÀÉÁÀ¥ =Àºï†ÀÑQ˜Àç¨aÀÿ+½Á B,ÁªÁ"ÇÁ-MÁ7Í2ÁAáÁIõ³ÁRó´Á\ŸÁerßÁoMÁyn~Á‚_Á‡Ám,Á“guÁ˜?¡Á’,TÁŒA«Á†…Á€êòÁvïÎÁl#UÁa`bÁVÕ^ÁL2¼ÁAƒzÁ6døÁ+"ÁiˆÁõ ÁbˆÀúY#ÀäXÀÏ.¶Àº‘æÀ§±ûÀ•ÆùÀ…0þÀl zÀP>XÀ7Ò¯À"¢ÎÀ|rÀ‹´¿ê塿ׄò¿É€õ¿Ä¹7¿Çt“¿Ñ~ ¿äÒ:ÀúûÀ˜xÀ(ßBÀAò×À`‹`À€ö–À“#À¦®Àº«¿À϶dÀå¿ÀûA]Á’ÞÁÌ·ÁøéÁ*NÁ4ÝÄÁ>ãÃÁG§µÁP[ÛÁY «Áb‹Áke™ÁudÁ~ô9Á„®ìÁŠ(*ÁÞÁ•É“Á›nÁ•ÒÁ!ˆÁ‰têÁ„Á}ˆ Ár¼*ÁhWšÁ^„ÁS–NÁI™Á>-NÁ2ý¥Á'ï"Á¿üÁÞ”ÁûÀøÓ‚Àä¹ÀÑÆCÀ¿q«À®§ÀžÆÉÀy×Àƒ}ºÀoíkÀZû°ÀIê‰À;ä±À/̤À&¦ÏÀ #CÀÌÀ£åÀ$[oÀ-ÚÀ;_ôÀLoÁÀa$±ÀxÂÀŠEÖÀ™ö·À«j™À½t¡ÀÐþ÷ÀäܹÀùÓØÁn‰Á*|ÁØOÁ'¦šÁ21 Á<ÃjÁFÁN¦QÁWÃÁ_¤ÁhiðÁq“VÁ{^šÁ‚ªÁ‡ÁÁÖÁ’´LÁ˜ƒªÁž :Á˜”Á’OÍÁŒÄÁ‡wÁ‚:gÁyדÁo£OÁetÁ[O×ÁPÚgÁFmðÁ;§pÁ0êåÁ&.–Á rÁ3aÁQ~ÀûIÀétÀ×ÿÀÇÓþÀ¹2À«&ôÀžïÑÀ“áÄÀŠ}À¬„ÀuX²Àj(¼Àa‹%À[rÀYôPÀ[X<À`&ŒÀi-2ÀuÉ-Àƒ ½ÀŒœvÀ˜&ÛÀ¤¾¡À³Ã‰ÀüÀÕFÀçÀûŽÁ|äÁ—4ÁòÁ&fÁ0âÊÁ;ÁD¿ÁM¹—ÁUâÞÁ^1¼Áf’cÁo|jÁx˜.ÁÁ†!YÁ‹7¶Áq¡Á•ê<Á›šíÁ¡QÕÁ›|jÁ•Ú;ÁqEÁ‹1)Á…óÄÁ€ÍÁw]Ám9ÙÁc]ÛÁYg|ÁO"âÁDöêÁ:h Á0"üÁ%ÛýÁ•Á]ŽÁ E–Á£úÀðâÒÀáQˆÀÓ^—ÀÆ’ÀºLTÀ¯žÝÀ¦hFÀžy>À—®‹À’FyÀŽ%À‹[ñÀŠ¿°À‹‹ñÀð À’J~À˜8ÀŸãÀ¨ÒXÀ³Ý—À¿nUÀÍ‹ÀÜÄÊÀí‘ÙÀþµÜÁÉTÁH„Á1Á%é Á/ï0Á9üÔÁCø˜ÁM8WÁUšÀÁ]†=ÁeäíÁnXÁw9Á€(¢Á„ÛÏÁ‰Ð•ÁŽöÁ”"èÁ™yÔÁŸ ëÁ¤íÁŸ9ŒÁ™ºtÁ”a.ÁÁ‰Þ—Á„ÐòÁœ„ÁuÁ‡ÁlXÁb;ñÁXSðÁNY‰ÁD"ÅÁ:4…Á0z Á&ÿæÁíDÁ6Á å,Á›ÀûcîÀí YÀá+•ÀÕ±#À˵ÐÀ¶À» fÀ´°¡À¯B+À«`EÀ¨ðÀ¨^MÀ©X5À«’RÀ¯èÀµ6±À¼Ì^ÀÅr9ÀÏf”ÀÚŸ+ÀçàLÀö ÀÁÛ9Á ZÁ)ôÁ‚HÁ&ÝÁ0Z¾Á9ÄÁCNdÁLÉãÁUw£Á]ÒÊÁeÊ‚ÁmêrÁvÀúÁX®Á„:xÁˆú#ÁÎjÁ’åoÁ˜«Á]Á¢ËÁ¨ÕÍÁ£E0Á×íÁ˜qÁ“%?ÁŽ˜Á‰&Á„7»Á~ Átî¿ÁkjgÁaØ»ÁXJÁNk/ÁDë{Á;‘ÙÁ2]Á)´IÁ!EÁ]¾Á¸ËÁ µÚÁrÀûÿ„Àñ7–ÀçdÀÞÒrÀ×|«ÀÑTjÀÌXûÀÈ›ðÀÆ] ÀÅãÑÀÇûÀÉ-cÀÍHÒÀÒ‹(ÀÙÜ.Àá¹*Àël Àö pÁæÁæüÁgÁ2ÑÁÞ†Á(ŽÁ1¶‚Á:ÁÁCùöÁL°=ÁU¥Á^aÁf/áÁn Áv4Á~ŒÁƒßKÁˆ‰Á3ÙÁ’ Á—WÁœCˆÁ¡ˆÀÁ¦ØéÁ­ Á§‰jÁ¢NÁœ°mÁ—‰žÁ’„~Á’1Áˆ± ÁƒØ-Á~BÄÁtëíÁkŸÙÁb^òÁY&¹ÁOÖ5ÁFËZÁ>=Á5¨¶Á-¨-Á%æèÁˆ¹Á¥vÁiŸÁ |•Á>ëÁ–ýÀúÚbÀô .ÀíÊàÀézëÀåÏÛÀãÊcÀãláÀäz…ÀæÔwÀê«CÀïÔiÀös Àþq^Á°#ÁÍ–ÁaVÁçîÁåhÁ#|`Á+4Á3ý-Á<©NÁE9JÁMíxÁV›oÁ_ NÁgF¯ÁnÒÂÁv†+Á~ªäÁƒ|éÁ‡ôcÁŒ¼Á‘xÁ–4¨Á›5µÁ töÁ¥Ý®Á«,˜Á±lÁ«æ7Á¦s¾Á¡2GÁœàÁ—©Á’ Á7…Áˆ…ºÁƒæÛÁ~¾âÁuÍPÁlæ4ÁcéÁ[ÞÁR`ÈÁIþ ÁAÊ Á9ÿâÁ2š²Á+iËÁ$ÕpÁ¬CÁ¥ÁæÁ…žÁ (Á'Á>LÁ 5Á}ºÁŽÁ€½ÁëŒÁA Á ëÁ†ûÁ •QÁ lqÁ;ÁˆÿÁÊ7Á!êËÁ(zÁ/ߌÁ7‚ÚÁ?žÁGŸÏÁPgÁX=”Á`–uÁhÏ ÁpooÁwàfÁ¢ÁƒÞµÁˆ œÁŒ]KÁÿÉÁ•êôÁšŒÍÁŸjõÁ¤‡ßÁ©ÝàÁ¯gÃÁµÞ»Á°S!ÁªóXÁ¥ÃDÁ ªdÁ›³ÍÁ–ÊxÁ’\Át'Áˆî\Á„r?Á€&Áw…iÁnëÖÁftÁ]ÿÉÁU÷ÁN>ÁF{RÁ?9Á8eàÁ2âÁ+ÿDÁ&¨æÁ!¾xÁZ‚Á˜ZÁCÁ „Án:Á‡Á2GÁ„Á›ÁéiÁ¥?Áö#ÁÃÁ|ûÁ¶Á$3wÁ)XÁ/6Á5f€ÁŠÄÁ;RÏÁ9/gÁ8QÁ7Ö}Á8hÁ9cÁ:íûÁ=²8ÁA0ºÁE•6ÁK"ÁQ7ÁXN¨Á`+Áh¼×ÁrÑÁ{ã`Á‚ümÁˆCãÁÌ¢Á“"/Á˜ššÁžáÁ£ÄÁ©xKÁ¯)çÁ´øjÁºíÁÀò;ÁÆôJÁÌë»ÁÒúaÁÙ'ÖÁßkÁå±¾ÁívÁçuÁà±nÁÚcªÁÔÁÍÜ.ÁǺÁÁŸ:Á»•XÁµ’ÂÁ¯˜žÁ©¬Á£Ö÷ÁžèÁ˜UÁ’¢…ÁÞÁ‡ºˆÁ‚S\Áz|ÁpíÁf¯îÁ]fõÁTz¬ÁLW5ÁDõVÁ>ÖÁ8ðÁ2Ý Á.ú·Á+³ïÁ)_?Á(mÁ'ø´Á(†YÁ*<Á,wÁ/ÐËÁ4ÈÁ8ü7Á>¢œÁEFÁLvÉÁT¬GÁ]»óÁfïìÁpœ¥ÁzëôÁ‚žÁ‡ÛÁQmÁ’ÑòÁ˜z Áž33Á£èáÁ©¹…Á¯³BÁµ¿=Á»Â]ÁÁÀ¤ÁÇÖÁÎ ÿÁÔQ•ÁÚœÁàé€ÁèÚÏÁâiñÁÜÁÕœðÁÏHOÁÈù)Á¶‹Á¼ŽÁ¶oŒÁ°cÁª_YÁ¤dÁžqwÁ˜— Á’Í|ÁÖÁ‡ayÁÙwÁxë‰Án(Ác˜nÁYÂÁPj“ÁG4ÓÁ> Á6DZÁ/™Á).¸Á#´ÐÁuIÁ&Á™ÁŠÁßÁ¤©ÁFPÁÑÜÁ ^Á$áuÁ*69Á0Š*Á7?~Á?úÁGµ@ÁP®+ÁZ+0Áda7Án¾aÁy+XÁ‚ :Á‡‰Á2*Á’ïeÁ˜©µÁž}Á¤|iÁªŒJÁ°‘ÑÁ¶˜ÀÁ¼·éÁÂñöÁÉ=ãÁÏŒÁÕÞyÁÜD”Áä\tÁÝÝ$Á×dÏÁÐõ ÁÊ‹ ÁÄ0VÁ½ßÁ·– Á±g Á«B`Á¥0ZÁŸ+ñÁ™/ÓÁ“:<ÁYQÁ‡‰ÀÁÐtÁxEÆÁm,¤ÁbbÁW‘ËÁM(ÁCxdÁ:%8Á1 Á(ÒÓÁ!IuÁv)Á®8Á šÁ ‡ Á àÁ¦wÁCíÁÃÁ ‡RÁ 1ùÁÁËÑÁ“¦Á"bÁ);zÁ1›ìÁ:CÁCÄ—ÁMÚÁX@ôÁb¤ØÁm„ÁxƒÁêôÁ‡­1ÁlÑÁ“C»Á™HÒÁŸY‹Á¥dÁ«t°Á±žcÁ·à›Á¾0÷ÁÄ‚PÁÊÛÁÑHØÁ×Á†Áß÷“ÁÙgàÁÒçÁÌg¿ÁÅñ$Á¿€CÁ¹ Á²Ê~Á¬{ðÁ¦F[Á #ÁšŠÁ“øˆÁûŽÁˆÁ‚aÁxéÁm"ðÁaËŠÁV§ ÁKÔtÁAÁ6ÞÁ-/bÁ#æÁ*ØÁ4tÁ æ#Á»•ÁÄEÀùíÆÀôfÀñ†„ÀðÓøÀñÃAÀõ­«Àû2ÙÁ¿fÁÔÜÁ qÁ´Á˜'Á$]†Á-mÁ7WÒÁAÄÁL#ÂÁVù÷Áa÷™ÁmJ¸ÁxÙÁ‚2ÊÁˆ)ÁŽŽÁ”)ÞÁš9¹Á U>Á¦Š¹Á¬ÕäÁ³'=Á¹{KÁ¿ßÚÁÆV•ÁÌÖ~ÁÓ]ÕÁÛ­¤ÁÕ°ÁÎvzÁÇòAÁÁq ÁºõÝÁ´}ÖÁ®âÁ§¼³Á¡iDÁ›+äÁ”÷òÁŽ×ùÁˆÇ‹Á‚È_Áy°6ÁmÎÁbÁV«BÁKT±Á@"\Á5G_Á*”KÁ oàÁç7Á ÂØÁkkÀûK\ÀíÇpÀã?¥ÀÚÑpÀÕ qÀÑÈ(ÀÑ ÀÒÅÀÖR—ÀÜÛÀåJ,Àð#‡ÀýµÁÃoÁLœÁ+FÁ ÝðÁ+?7Á5¤DÁ@sÓÁKpÄÁVÃÃÁb\ŠÁmøãÁyºÓÁ‚êùÁˆþòÁ”Á•;uÁ›~+Á¡ÌÙÁ¨»Á®|WÁ´ííÁ»mRÁÁî¿ÁÈ{(ÁÏ EÁ×w‘ÁÐËyÁÊ+NÁÊÀÁ¼þÁ¶{ŸÁ¯ýCÁ©ƒüÁ£Áœ¶0Á–^gÁ·Á‰ÝCÁƒ´üÁ{8DÁo0ÃÁcRâÁWhªÁK›õÁ@9Á4áãÁ)žøÁ¿ÕÁ%Á $;Á QÀï˜&ÀßtÀЂÀņÀ»ñÀµµóÀ²À±l1À²GÀ¶÷ƒÀ½P´ÀÇ5ÀÓ~Ààv[Àð€Á 9Á p­Á¹XÁ$ÞÁ)óéÁ4ðSÁ@BŠÁKçªÁW•ÙÁceÓÁoˆÎÁ{´Áƒò³ÁŠ(±ÁzZÁ–ŪÁ]Á£‡)ÁªÁ°… Á· 'Á½™šÁÄ/àÁÊ×ãÁÓvtĄ́ØÁÅïÇÁ¿K«Á¸ª^Á²°Á«ˆ…Á¥Áž‹#Á˜&Á‘±Á‹WfÁ… "Á}—cÁq4ÍÁdïÝÁX×èÁLõÁA ˆÁ50iÁ)Æ÷ÁoÚÁwÁ@—ÀûŽÏÀç±TÀÔ׃ÀÄ ùÀ´'@À¦õ©À-À–`4À’šÀ‘¸NÀ’«¯À—£ÀžüíÀ©FÏÀ¶WÀÄ£ÀÕûµÀè.´Àüv!Á¥Á}Áx`Á)ÉRÁ5}XÁA?ÑÁM!gÁYKdÁeyËÁq³;Á~=Á…qÁ‹ÂDÁ’!EÁ˜ÜÁŸ&çÁ¥ßÁ¬+åÁ²ÃxÁ¹c”ÁÀcÁÆÔëÁωwÁȶ¾ÁÁä_Á»Á´tgÁ­ÔnÁ§6ßÁ ¡oÁš™Á“’öÁ¡Á†¬Á€QÁsù'Ág}Á[–ÁNºÁBŽkÁ6˜§Á*±ÁÓìÁWËÁýÐÀù=»Àã$ÀÏ À»vÀ¨ÚÃÀ˜¼ À‰~À~sÀn!ÝÀf!ÞÀdàÀfÃÀpæ À€ç¡À‹øÀ™‡šÀ©ãÀ»ÀkÀÏ’¥ÀäM,Àú"EÁ æÁ[ÆÁ" Á*ûåÁ6òòÁC#ÁOT Á[—Áh@€Áu dÁ€Ë7Á‡5`ÁÂÁ”B¹ÁšÂyÁ¡[vÁ§ýmÁ®§ÿÁµh2Á¼-NÁÂì¤ÁËÅ{ÁÄÙ6Á¾AÁ·.CÁ°_lÁ©¨ÓÁ£ Áœi—Á•ÉêÁ0™Áˆ¥«Á‚"´ÁwU˜Áj˜OÁ]áÓÁQfÜÁD÷ Á8šÍÁ,ZÁ HhÁ]@ÁâÀùéèÀãÀÌJCÀ¶çÀ¢Ÿ6ÀކƒÀzÚÀZåšÀB/™À0CéÀ'žŽÀ%:À(¡êÀ3\÷ÀE¥À^jûÀ{¢íÀ¥ À¢ÜöÀ·OçÀÍVCÀãbüÀúÏÁÛÁÏQÁ ÍÁ-ûÁ9J4ÁEšÁR\Á_ÒÁkÇìÁxµÕÁ‚éNÁ‰hqÁùÁ–ÈÁG™Á£þ…ÁªÃ]Á±„$Á¸G Á¿ ÁÈ7úÁÁ4©Áº;ÒÁ³XôÁ¬…†Á¥²UÁžî~Á˜G¿Á‘£ÖÁ‹DÁ„_¹Á{’úÁnxbÁaoØÁT¦GÁGäÁ;TÁ.ÝÁ"ƒXÁDÁ æÀü9yÀ䯬ÀÍMÍÀ¶HzÀŸwúÀŠ}´Àlv]ÀDÁóÀ$£¸À>4¿èÞŽ¿ÔW3¿Îʼn¿Ö·f¿î¼-À ìýÀ%@}ÀG$¿ÀlÞ–ÀŠ`wÀ “]À¶±|ÀÍ‚iÀå3Àý5YÁ §ÃÁ%%Á#dµÁ/Æ Á<‚ÄÁI?jÁVõÁcSÁpìÁ}AÚÁ…DÊÁ‹ê"Á’˜ÂÁ™ZMÁ ›Á¦áÚÁ­²ØÁ´‰Á»l€ÁÄ¿ëÁ½¸€Á¶¶Á¯´­Á¨Ä”Á¡ëÕÁ›¤Á”>ÖÁˆ€Á†áÁ€7~Ás3¤ÁfØÁXÕÏÁK²ôÁ>؉Á2YÁ%bíÁÏ«Á w>Á7}Àç÷ÜÀÏ×OÀ¸ENÀ ÝÀ‰ÃøÀeùzÀ(Áž>Á—VöÁyýÁ‰™ŽÁ‚ÐëÁxFGÁjíäÁ]²sÁP„~ÁCTþÁ6 Á)!ÔÁRÜÁÌÁòÀìð ÀÔW3À»ó À£ÎxÀ‹Û¥Ài[À;dñÀ2â¿ÇF ¿nŸm¾Âý<”c²>yßS>˜§>m©’¼GD¾ÌÔ¯¿nük¿ÆW!ÀDÀ:ù>Ài«=ÀŒ3FÀ¤eÈÀ½›ÀÖ=Àïj)ÁUeÁ+ÁÛÁ+&NÁ8$ÁE;õÁR•jÁ_ÖªÁm4ÚÁzµÁ„äÁŠð®Á‘Ä Á˜—½ÁŸ{7Á¦vˆÁ­{$Á´€PÁ¾zÁ·D‘Á°<Á¨í2Á¡ÞÁšÑÁ“ÂÒÁŒÊ‰Á…çýÁ~ ÀÁp^+ÁbôžÁUž@ÁHKnÁ;ÈÁ-βÁ •ÜÁŠªÁ—-Àó½åÀÚ„ëÀÁu2À¨}À)ÔÀp;À?¦ÞÀ8¿Æ²X¿Z8„¾6K†>Íõx?\zÚ?ŽÛ>?™7Ì?Þ·?_+Î>Ö>ƒ¾<3¿W“E¿Ä‹ÅÀÀ@ÊÀqvÁÀ‘ñŽÀªë›ÀÃùÀÝŸ?À÷…?Á¹Á»2Á"ãÁ/þHÁ=GÁJµšÁX:Áe‰™Ás(Á€h`Á‡<©ÁŽ%Á•IÁœNÁ£BÁª"Á±.rÁ»€šÁ´AœÁ­ ¢Á¥ÑÁž¿Á—~<Án±Á‰_ûÁ‚XkÁvÚÝÁi¦Á[`\ÁMÜÁ@ŠËÁ3.®Á%È‚ÁmmÁ ìÀûø+Àâ"ÀÈlaÀ¯=>À–,üÀz¯†ÀIbŸÀ¡†¿Ò_¿h ¾7¦9?¥?‘4O?Ò¾¤?óãu?ÿHé?÷×~?׌?”ë?æ¾<Á¿f2ß¿Õ$ÙÀ&ÀN–jÀ€?KÀ™|„À³D¡ÀÍ‹ÀæÜëÁ¤!Á Ò1ÁÛŒÁ(;¢Á5¯9ÁBù0ÁPyAÁ^$ìÁkÐÅÁy~+Áƒ¬ÁбóÁ‘¹ÖÁ˜ÅòÁŸÙeÁ¦ðãÁ®eÁ¸½þÁ±f¡ÁªPÁ¢ÜÁ›£~Á”jîÁ;ÌÁ†$@Á~2Áp+Áb&þÁTfúÁF¬FÁ8÷wÁ+Á,ÕÁÆ ÁtåÀì1ÀÑ€ŠÀ·ž˜ÀÚ'À„IÀVW{À$éd¿ç?|¿†l$¾›«ž>Ú~*?{¥?ã¸8@»ð@2›@j¹@Ie@¦ ?ãØÏ?ï^>Ʊ)¾´`¿·œ¿óÜuÀ-†0À_ÓÖÀˆý?À£ÔÀ½À×^hÀñ™Á`ÁFÍÁ ©Á.œÁ;»–ÁIhÀÁWëÁdÐÏÁrËÐÁ€qÿÁ‡~@ÁŽ–ªÁ•¶ÁœÙÁ¤ 3Á«NýÁ¶!0Á®ÈÁ§osÁ Á˜ÍmÁ‘“YÁŠ[þÁƒ%“ÁwûÁiØtÁ[Ç_ÁM¶Á?ÃÁ2cÁ$>1ÁŸÒÁ :!À÷¶oÀÝ<ôÀÂoÀ§ðlÀÞ¹ÀgëEÀ4ÍKÀÂ’¿¡'(¾ýÕ>…ˆ™?y—ã?Ô¥ @ T@ú@@…º@!œª@ Ó@¯-@-{?Èø»?\â8=óß`¿$“¨¿¶ƒÀ ÀÖÀ@TÔÀsÔKÀ“¶ËÀ­–/ÀÈŠRÀ⶘ÀüùÂÁ wÁ¢»Á'!üÁ4Ó£ÁB¢ÍÁP| Á^qÁlˆJÁzÁuÁ„‰@Á‹¯ Á’ØzÁšcÁ¡W'Á¨˜ŸÁ³´=Á¬I:Á¤çîÁÁ–:{ÁŽç#Á‡˜nÁ€YƒÁrJ2Ácò?ÁUžÁGt/Á9evÁ+Z>Á‚ ÁÐwÁ(iÀéÀÎÚ0À´À™O”À}qjÀHŸùÀ*þ¿ÅU¿A#Å<á×??æ¢?·_?ù:(@ýç@l=@ŸÁ@E2@¼d@R£@ Úb?ç?œp?ýξ[½D¿{£;¿á¾’À#_XÀW )À…;ƒÀŸÃŒÀºYÀÔpwÀïz Á0EÁ¾lÁ ·Á.l‘Á<<”ÁJ'ÁXY˜Áf¯Áu¶Á®©Áˆã*Á) Á—qzÁž»Á¦¨Á±lèÁªmÁ¢˜Á›(|Á“¾ÁŒ_ÝÁ… ÅÁ{vÁlÕŠÁ^XEÁPvÁA²IÁ3iàÁ%`öÁq»Á {À÷ÑÎÀ܇ÀÁ?ÿÀ¦«@ÀŒ ÅÀcÐÀ.Ò¿ô–¿ÙȾ¦é>×¶Œ?¥,?Ó€ù@®@ €@Py@ûŒ@²@“#@Þí@ ù?ô¢\?¶ý¿?Rn=替5¿±]À E;À<}•Àpu»À’Û\À¬aÑÀÇ9šÀâ©wÀýsÇÁ cÁK€Á(DzÁ6TÁD£¾ÁS"Áa`¤ÁoÀ¶Á~CïÁ†pÌÁ¿¸Á•³ÁœdÔÁ£Ç¬Á¯^ Á§ÚÑÁ _pÁ˜íÁ‘~úÁŠšÁ‚¦-Áv“ßÁgüãÁYl$ÁJàÚÁ<~ÂÁ.AÝÁ ¦ÁßcÁíQÀì¬ÀÐe¦Àµ ÿÀ™ïûÀ~²~ÀJ0ÀŸ]¿Ã?u¿@&ä<%©?7PÑ?¤§¹?اÍ?üQÛ@ m_@2Ä@H@Q @Ó-@$@ wu?ó^?Àý?€5Š>Ä B¾›Žo¿„)¿ë±;À$¥ßÀXw2À†}±À £À»hYÀÖèÀñ„²ÁßëÁ žÁ#3Á1JTÁ?­’ÁN&°Á\®ØÁk#SÁy«RÁ„&¿Á‹‡zÁ’óDÁšd'Á¡×#Á­—´Á¦ jÁžtˆÁ–èWÁhµÁ‡÷µÁ€‘SÁrY€Ác”ÜÁTï:ÁFtjÁ7þ@Á)„…Á Á ÛÀýl…Àá6”ÀÅ¢Àª{À¾HÀjÀ51þÀ[¤¿œ‰­¾èX>r‰ë?VJ,?¦Ù?Ó2í?ôâù@-ˆ@)Í@¤@G5@õt@a¨@ý©?î?Ãü§?‰±?“•½ÜûοIÞпƿpÀQ8ÀDÖÀvøÀ–GdÀ±X'À̈ÌÀè²»Á-õÁUÁLÉÁ,Ó·Á;qBÁIà=ÁXH_ÁfÐIÁu†ùÁ‚0ÊÁ‰¡9Á‘´Á˜†3Á ¶Á«ñ%Á¤exÁœÖâÁ•E\Á´õÁ†+ÌÁ}bnÁnçÁ_ÝüÁQ/–ÁB|SÁ3ËÁ%8 ÁÊÂÁlhÀôQºÀØzLÀ¼óBÀ¡œŽÀ†xÀW¡Ä?Tß? \¬?Ê£Õ?îý«@t÷@”t@kõ@\$@d§@È«@V?ê±¾?Àj?ŠuD?RF»Gp¿#ð1¿«"WÀ1(À6K=ÀhÀÀŽ­0À¨ã,ÀÄi·Àà[ÀüLÁ :úÁ%Á(ðŸÁ7}ÚÁF|ÁT±ŒÁcròÁrJŒÁ€‘;Á‡þäÁy`Á—ŒÁž•uÁªu€Á¢êpÁ›_÷Á“Ö+ÁŒMáÁ„ÇèÁz‰2ÁkŠ-Á\™YÁMºÁ>ðãÁ0GFÁ!¬^Á"æÁÌÀ톗Àѯ‹Àµö{ÀšV•À~ HÀJ ÀŸ‚¿ÎQÜ¿l}¾‹YR>“î:?E ?–z%?ÄÃÄ?ìÿ¥@ @±@ UO@%ý@!¨@@ž®@ 8Õ?ë+=?¼º?†E>? á<}eâ¿×z¿Ÿ°¿õé¯À+ö}À]èÎÀˆÃÊÀ£BìÀ¾ÿ ÀÚ|<ÀõþËÁýoÁ]þÁ%ßöÁ4p8ÁC ŽÁQ¶ãÁ`ŒZÁozÉÁ~ysÁ†ÁRÁŽIÓÁ•ÝEÁz_Á©/.Á¡ <Áš Á’—XÁ‹£Áƒ’OÁx$¿Ái%¿ÁZ%ÁK) Á<7ŒÁ-aÁÄCÁl_Á@Àè^QÀÌ_éÀ°n*À•ðÀvSÔÀC9­ÀT¿Èº€¿e…v¾žýé>c¹ð?1ý·?b?Åk~?õµ)@߃@"IÐ@.` @3ö@/áÝ@#q4@ÏÎ?ò+?»äð?¹’?ŒF¼ØOæ¿*£¿œíì¿òÀ'·AÀX_YÀ„Ç}ÀŸXÀº÷ÀÖSÐÀñÇÒÁ Á<þÁ#€¡Á1å0Á@†iÁO[zÁ^UÁmVBÁ|YÁ…°)Á?ˆÁ”Ú®ÁœâÁ¨F<Á «öÁ™ÏÁ‘‚^Á‰òjÁ‚mHÁuåÒÁfõ¡ÁX ;ÁI&Á:^ Á+¬GÁÁ¢šÁsûÀäºÌÀÈ”oÀ­ÙÀ“!“Às]'À@µxÀu²¿Ì1ä¿yéç¾Ìkò>è?$Å?’Øú?Ï÷v@œz@¼5@4L@@·@Fdå@Aýä@4J~@ì}@‚º?Ä=7?ú>éËñ½Ü Œ¿/e¿¥K¶¿øÖiÀ(²ÍÀW}ÀƒqÀ¢À¸i[ÀÓLNÀï2Á²ªÁÛËÁ"XÁ0ùÁ?LÁN"Á];ÁkäøÁzÞþÁ„ûÅÁŒ”ØÁ”8ÀÁ›â'Á§°%Á àÁ˜u‡ÁÓEÁ‰7>Á§AÁtKÁeiÎÁV¢ÖÁGç@Á99®Á*¡VÁ;óÁ ßiÀÿCÀâ—ºÀÇ4sÀ¬ï¿À“NÀs¸©ÀEÀœ`¿ÛH¿‹Ïq¿S*=Œ)Ò?$j8?œìœ?ä›d@o”@1}[@I‘)@[Z¼@b`ý@[„@J Ó@.ñˆ@ —Ö?Ñô?ƒ´Ñ>ܧ¬¾G¸æ¿IûÝ¿´2ÄÀí¯À.Š­À[¾‚À…ç‘Àžø¬À¸¡ÀÒÔ+ÀînÁ_lÁŠqÁ!¾ËÁ05ÃÁ>é§ÁM¯1Á\tùÁkPÁzNßÁ„µ¥ÁŒPFÁ“ó¼Á›˜Á§9·ÁŸ¤tÁ˜ Á’‰ÁˆòéÁ^íÁs±ƒÁdÆ@ÁVûÁGpÁ9ÐÁ*±ÁbFÁÏÀÿ¦ÀãͺÀÈéëÀ¯ ºÀ•‰§ÀzæÿÀMÀ!z‘¿îñ쿟}¿n†=‚Q?>Pé?² @þ³@'Ä@I‰F@enY@xÖé@)D@zÕô@c|ñ@Bã´@ó…?á ?ŒXv>Ü )¾ƒ§H¿dç…¿Åž'À æ À8ÖÀd$À‰ûeÀ¢?ûÀºèãÀÔÎÏÀð#HÁò¨ÁågÁ"ØÁ0n@Á>ø2ÁM“Á\BYÁkÁzNÁ„™àÁŒ4FÁ“ÙfÁ›„ìÁ§ŠÁŸƒËÁ—÷ÙÁxeÁ‰ÁŒ±Át Áe;WÁV„ÁGýÁ9˜;Á+6×Áõ‡ÁìòÁûÀçÂÀÍÀ³2«ÀšvÞÀƒZ›ÀYÃcÀ-Y%ÀÉ꿦Ô+¿›%>5¡á?mø?Ò4­@ü½@=Ü@c`ë@‚‹ð@ŽcT@” @Ç@€ ­@W++@*®Œ?ølh?› ›>îc‚¾‡3¨¿wÓ ¿Õ©ÎÀ ÀCÝ\Àq²¥À8ƒÀ¨‡cÀÀã(ÀÙÎ ÀôN¼ÁÏÁ_Á#”NÁ1ÑÁ@öÁNuÁ]ÀÁkÞfÁzÏìÁ„ðwÁŒ„1Á”³Á›¹Á§]YÁŸÉÇÁ˜AMÁŦÁ‰S{Áá—ÁtãÁf#ÂÁW’5ÁI8%Á; xÁ,ã…ÁÈ=Á°ÁÅ“ÀíuÀÒöÀº>>À¢5ÀŠð¿ÀhÀ6ß¿ÿž“¿”Q`¾¼<;>×EV?˜à?ú$C@*·á@W ß@€˜e@“^@¡†-@©s±@¡U‰@eÈ@kdt@;ƒý@ ëE?°ÇZ?\ü¾IE¿€œ¿ã7À"HòÀQ)^À€C‚À—ÞvÀ¯ÂXÀÈ>–Àá%ÑÀú|–Á =ZÁ§¹Á%‡QÁ3ÁwÁB!×ÁP‚KÁ^ÿ…Ám®3Á|…°Á…·ûÁ4Á”¶øÁœ?ßÁ¨«Á ußÁ˜õßÁ‘‚&ÁŠæÁ‚ŸÊÁvpûÁgÊþÁYUÒÁKãÁ=*Á/H_Á ÃÁ]ÔÁ ÀëúÀЛIÀµ¹{À›­ÀtÀPþ@%?£]‹@þ;@47-@c¨®@‰V&@ ,#@µ–›@Èí‘@תR@Àˆo@§¤Ô@Žt@ic@3æ´?ÿ™?”ƒÎ>¡k¯¿àL¿°è2À¼rÀE6wÀ{ëÀ˜§¯À³Ä1ÀÏ¡~ÀëÍVÁ tÁXHÁ`Á,È~Á:‹íÁHZÁV<ÁdaáÁršÁ€¨£Á‡þÍÁa:Á–ÎÁžCÁ£ãIÁž0bÁ–ž`ÁŽâ°Á‡,Á~ñÁoŠ4Á`$ïÁPÊÁA}LÁ2B5Á#Á wÁ$„Àìæ_ÀÏžíÀ²vÀ•¯Àr<À:ª½À·¿¿žC¾åX>§¦š?‹ÁË?ð˜ï@( â@Y;ˆ@„o@›)@±”™@Ç+@Ûä@èX@Ï’@¶›@›Ê'@í‚@PŠé@Ö?ËYp?FØ½Ž¡‘¿g>ô¿ÜèÀ#Õ“ÀYýtÀˆSLÀ¤|oÀÀá.Àݳ`Àú©ÈÁ ¤Áë•Á)óÉÁ9çÁH<'ÁWu—Áf¹šÁv8Á‚h!Á‰™{ÁÚ©Á˜)ÝÁŸÉÁ ëtÁ›µÁ”¾RÁŒð'Á…&hÁzÄmÁkF8Á[ÓKÁLkPÁ=eÁ-{Á:ÁçÀÿV¸ÀáÉÀÂú-À¥tžÀˆ-,ÀUßeÀRþ¿Åý°¿0õ>Úº?u6??ÝÚæ@bÝ@Pªå@wÓ@—Ô@®TK@Å8¹@ÚÃ@@ï_[@ù'#@ß‘t@Å*f@«^E@‘¯@oye@;´â@Áù?¤Ò>ñXz¾²Þ8¿™ÖÀ˜…À:XBÀs±aÀ–ÀEÀ³¨õÀÐýÀîÕëÁ‰™ÁÀüÁ%ˆÁ4YeÁC³éÁS{Áb‹­ÁréÁ€ÔvÁˆ¥dÁy°Á˜+ËÁž4«Áž@5Á˜Y1Á’¢˜Á‹RÁƒuÿÁw9ÕÁgŽèÁWìÇÁHU‚Á8ÌjÁ)QÁå‚Á ~—Àö/YÀ×aƒÀ¸¤®Àš*¤Àw»)À<áÀvÕ¿Ïâ¾Tn'?/„a?Äò@o@Hæ@y'N@”ZV@«­v@Â#Ð@Øø@ï§QAKÍAÄ @ï¼@ÖTD@¼Õô@£Pº@‰ð@^Œ&@*{_?ìb.F¿/´ó¿ËY¢ÀlfÀY+úÀ‰ï*À¨ÃÀƪ½ÀåkÁ¨ÁŠÁ ø6Á0uBÁ@ŠÁOªGÁ_ZÁo3Á~ÖäÁ‡PMÁ2ÇÁ•¡³Á›¼=Á›«¢Á•ª-ÁÚvÁ‰ÜéÁ‚ñÁtV0ÁdœzÁTÝÁE¿Á5_åÁ%©}ÁýYÁ_Àí¨ÙÀοhÀ¯ñ’À‘#¼Àd«ÎÀ'"¿Óÿµ¿5•>VÊÔ?÷"@Å9@:N@pã@‘oY@©uß@ÀÞ@××@íäöA +A |A z•Aà@èJ½@ÎÞ>@µÙ@›q0@L@N`@¿&?Å'{Á2ˆ¾Á"Ó Á;ÁXÞÀç3ÀÇ´GÀ¨7NÀˆ×üÀStAÀËë¿°`¾Ô¤¤? Z?À«%@P/@Vß@ˆhª@¤^@¾k©@ÖX:@í©A°A þjAöA–àA æ–@ú´Ð@áA@Ç‘@­‡í@“Lö@pkP@8G?ü¡e?…Î=ÔQw¿[°²¿é«ŒÀ2æmÀq½gÀ˜}°À¸/÷À×â¹À÷•{Á ¥>ÁõÁ+Z¬Á;5xÁKöÁZ÷2ÁjÞ7ÁzÈLÁ…FfÁ‹ôÁõ—Á—çÁ—$Á‘%üÁ‹=«Á…oÞÁFÁo>Á_uæÁO­¹Á?äùÁ0ÜÁ -žÁVáÁ†£ÀáBÀ 4À¢ŸÐÀƒ'úÀGRÀU ¿’¯*¾%™T?Q-:?ãÍó@/‚¥@mP@•U€@²áK@Ïî¸@ëK‘A¦A J|A`UA#lAÚØA{“AÂy@óÁ*@Ùæ¿@¿!@£aÖ@†)N@P&@ÿ?§’!>£e¿,Ý¿ÔÎöÀ)ÏéÀi:ÅÀ”WœÀ´'TÀÔ ÀóëAÁ ëƒÁãPÁ)Ü|Á9Ö®ÁIѧÁYÍ;ÁiÉJÁyŽÁƒ$“ÁˆöÁŽ÷†Á•›Á•)iÁ+•Á‰HÁƒgyÁ{N²Ám^Á]bÁM0Á=À(Á-òjÁ'¥Á_cÀýöÀÝd½À½¬ƒÀôJÀ|x#À=±¿û.}¿x€Ï$¤¿º¿Ëƒ7À%”³ÀegËÀ’rÀ²†þÀÒpŠÀòZÁ !ÝÁ%Á)Á9 SÁI~ÁXþkÁhú Áw•žÁo"Á‡NÁ>€Á“50Á“–WÁ…ýÁ‡“Á¡ØÁw˜ŠÁkoeÁ[¹õÁL'Á ?SÏ@›Þ@G Ô@ƒ?å@¢ú-@½G@âmlAùJA»ÝA TÞA.µA:8ÖA33-A&D,A‡§AŽJ@í)Ù@Í7@­Dd@Q©@Z½Ü@Øg?µåã>Øká¿_å¿ÉzÝÀ$¢äÀdˆYÀ’6çÀ²)¢ÀÒáÀò¾Á ¿Áõ}Á(è—Á8ÝqÁHÓ ÁXÊÙÁh½2ÁtUùÁ«Á…¹œÁ‹ªtÁ‘œ!Á’;áÁŒ"aÁ†ôÁ€$dÁtÂÛÁi‚’ÁZ[CÁJ¢PÁ:צÁ+ ÁBcÁ fõÀ÷uÀ×UKÀ·™–À—ÞžÀpIóÀ0Ô8¿âl³¿Faí>`V-?›F‚@ A@LÞý@†>n@¦ ]@ÅÜL@å«;A½A§SA"•«A2‡ABB§A2ü•A#§'A°AnÔ@é•ð@Ê5@ªrl@Н×@UÚ„@UY?­ ^>ºÿW¿ú¿ÏRÀ'cMÀg›À“kôÀ³IÀÓ&BÀóiÁ pHÁ^ÜÁ)MoÁ9<ÁIÁXÙ ÁfƒÁqnÁ|áÛÁ„a'ÁŠYwÁPGÁòbÁŠßFÁ„ÒªÁ}·5Ár?ÌÁg äÁY·ÁI‘aÁ9ûÜÁ*gáÁ¬?Á ß!Àö¹ÀÖq1À¶Ê¨À—¼Àn¿°À/Ö¿Þù_¿?f&>|™È?žÙ…@û!@N^ü@†ê-@¦¤Û@Æ_²@æõAî@AΦA"ŸA2S'A8ÎA-6)AÞ¿AñüA§=@â @ÃÞÜ@¤Î@…C@KëW@ Rã?r>+†¿<òß¿ÜÎÀ-‘eÀl»»À•ó ÀµÀÕIDÀõ üÁ gZÁH¶Á**Á9ä£ÁIZ`ÁXÏÁdo¿ÁoRÁzµ}Áƒ9ùÁ‰(ÿÁ$Á iÁ‰òLÁƒð¾Á| =ÁpÁeÁÁXCÁHÜŒÁ9|_Á)ïhÁQ*Á œÔÀõ²áÀÖ2'À¶±À—0ÖÀoPÁÀ0)R¿âÇ¿GiÓ>UƒM?™bt@ å"@JÃŒ@„Ó@¤D[@õ¦@âÔðAõfAzAšçA&uUA(˜ºA$ã»A±vA Äê@ö¼ð@Ù@Z@»Fo@œ«³@{ÿ'@>±@6K?†a;=Ÿ[‚¿f`¿ðVGÀ6¾#Àu€WÀš.—À¹ÀÙ nÀøSÕÁ ÉÁxÁ+ ÓÁ:…pÁI¬;ÁWÕ5Áb´ÐÁm‹ÛÁx·mÁ‚bÁ‡ýÃÁŽªÁ]ÔÁ‰'ÁÁƒ#Áz¡2Áo@Ácª2ÁW¶ÁHj–Á9L©Á)ïmÁr*Á æ ÀöŒ À×dÀ·¾TÀ˜‰eÀr­WÀ4$>¿ë6J¿\H0=ïw?‹¯$@€@B>d@€È@žÄá@½ˆ @Ûù@ùù™A KjAä¸A:…A9°AÁ²AáàAå¡@è¿§@Ì©{@¯¬ @’hB@i_@--µ?à;—?K? ¾'äs¿˜¡À³2ÀC¸àÀ€­¹ÀŸ~!À¾o:ÀÝ©'ÀüüRÁ Ý“Á<ýÁ,ŒæÁ;¢ÞÁJOÁVý‚ÁaÀÏÁl9ÁwPÁCªÁ‡4;ÁXÚÁŽì™Áˆ±Á‚¦ÜÁyªHÁnNäÁbÇ/ÁW(=ÁH‘ùÁ9‡Á*kœÁ;;Á ÈåÀø‹óÀÙÅÈÀºóÀœýÀzdÑÀ<Á¿üu¿•¼äš/?n0^?ñi@5JO@qä@–Š<@´&€@ÐûX@ëï@ÿi€A§AàBA á«A ¼ÅAþ¨@ñ‰Š@Ø9«@½Ô½@¢œ@…æ·@Q(@6™?¸X?DM¾ÛD꿯V„ÀÝ1ÀRÀ‡·èÀ¦ihÀÅèÀã¥ØÁšÁ3,Á:MÁ.5ÈÁ<Ô†ÁK-ÁV½8Áa)²Ák‚ÁvkîÁ€îæÁ†ã3Á YÁŽá—Áˆ¬æÁ‚¦ÔÁy‡ýÁmó›ÁbQ3ÁVzrÁIÁ:?¶Á+nŸÁ‚²Á A¢Àü7oÀÝÌVÀ¿\À §À¨ÀFu=À È¿šr¾‚?1Ÿ?Ï6Ð@#è@]¤Õ@‹7Æ@¦Ò\@Àq/@Ôô @ãDj@ëìø@ñô@ôÚ”@ôàj@ì´@Ûñœ@ÅOr@¬¶j@’U@nÔë@6—!?ý‘?‰»>(=¿@Q¿×@CÀ'ÉSÀcòÅÀÀ®3ÀÌ"äÀêJÁCžÁ÷Á!ÎÇÁ0fcÁ>’³ÁK µÁVõÅÁa†ñÁkÞtÁvÄ0ÁÁ‡ ƒÁ1çÁŽñ)ÁˆÌÄÁ‚ØžÁyäGÁn!›Áb„ŽÁVÛøÁJV¾Á;Ì7Á-.¿Á.Á7LÁj«Àâ÷§ÀÄÇJÀ¦ÖäÀˆ¦ÀT“”À#¥¿º7¼¿‹ž>ɪ?¥»i@ °ë@Bþ^@xäÔ@”ÛÞ@ªÔ@ºHý@Æ$@͵“@ÒÍ3@ÖÅ@Ö]@Ï»h@Ñ¡@¯ú„@™3@€­é@MÁW@²ù?ÂÃh?'¾]ƒø¿™pÀgÀ<vÀw.bÀ™Y€À¶õtÀÔ|îÀòÁÁÛÁC{Á$˜¢Á2Ì£Á@µ¿ÁLÖìÁWÈÀÁb…4ÁlðOÁwÂ5ÁŽšÁ‡xÁ•áÁU÷Á‰5“Áƒ/ýÁzwuÁnå^ÁcuJÁWÑÊÁK¡Á=³UÁ/RÙÁ ´ Á(šÁ–8ÀéŸvÀËß/À®'À­ÊÀfy”À+”¢¿ä¿a <}Ð/?b:]?Ýü¶@#CÁ@R~É@}u@ÆÀ@ž’O@¨Âß@¯{Ã@´Bü@·`¢@·m@²”@§óˆ@˜qw@ƒü_@Zß<@)É?í°ü?ƒ”?>E­<¿+¬i¿ÄbÀ%pÀSfgÀ†ˆKÀ£ŠÅÀÀؼÀÞýÀúÜ%Á ÈøÁòBÁ( ¯Á5ÛÇÁBø˜ÁNAÁXú†ÁcÕ Án[ÁxÙ¢Á‚©Á‡óÁŽ “Á*±Á‰øÀÁƒÓŽÁ{±KÁp/DÁdÑŒÁYPâÁM[Á@K‡Á2ëÁ#ùüÁÅØÁa¬ÀñÓÀÔbyÀ·†èÀšnÐÀzëÿÀAŒÂÀ Hw¿£í(¾Öo[>Ë%š?›Šà?÷l¿@&µ@L®@kBe@øc@ŠÞR@‘Cú@•°Æ@˜¯›@˜½±@”*@‹90@}QÓ@Y;„@/ò@|‘?£N->þ|¾¢Â¿‘Pç¿ýŽ¿À5ÎÀmM(À“†ÀËdDÀè ÁE­Á5ºÁ æÁ+¾>Á9#°ÁEªÙÁPoTÁZÀoÁe_ØÁo •Áz`Á‚ÓþÁˆ³¦ÁŽÇªÁ‘'ðÁŠü Á„ä,Á}ì7Ár~µÁg‚Á[pqÁOÞßÁC!£Á5ªÁ'Õ6Á˜ÅÁ p6ÀúÇôÀÞ§ÁÀÁÉÎÀ¥ÇlÀ‰¸À[ÝQÀ$⠿ބ׿l½«¾ GÕ?Ûž?¡ Ö?í£2@H%@3Î&@I£÷@Zí@fj@n#@t@tû@l2¢@[æä@F¼@'cJ@o•?¯×§?(g›½¹Qû¿\qͿӵ_À*©ÀSZ0À…áÀŸî¶À»ÑÀ×»™Àó3|Á…cÁ-Á"ÊÁ/ùUÁ<ímÁH™²ÁS#Á]jŒÁg9áÁqTRÁ| œÁƒ¤<Á‰€Á¾Á’VíÁŒE Á†?Á€cõÁu7‰Ái²}Á^9ÇÁR§PÁFw(Á9Î(Á,0Á§’ÁÙíÁðÔÀéªhÀÎ1ØÀ²â’À—~‡Àxm ÀC¸[ÀJ¿À%ò¿E]´½²K¡?Žý?‡X5?ÄJ?ö·S@s³@?”@)vÙ@2BN@6þB@6Ýô@/ª&@!Ãâ@ çß?å´Â?¡ÇY?&8;ì`¿7€Þ¿¹®àÀ þxÀ@Às¬ïÀ”fÀ®Þ¤ÀÉ.ÀäŸdÁ ¡Á ŽûÁî%Á(uÁ4ÉÁAVÁKöØÁUý)Á`Áií”ÁsúÁ~“aÁ„Û_ÁŠªÁ®?Á“ÎÖÁ¥ Á‡§WÁà¿Áx‡ðÁmWüÁaüãÁVuêÁJÑÁ>jªÁ1L­Á#Û÷Á]¿ÁÚÀöÚyÀÛ­{ÀÀª?À¦iÀÀŒ•ùÀf À6,„À4¿¹=…¿RÝû¾‡a">tãðÜͽ©ˆÉ¿7| ¿®x©À/~À3k®ÀdÒ^À‹À¤ã À¾oÀØ’DÀò®±Á›°ÁèïÁ Í´Á-šžÁ9þÃÁEµÕÁOì7ÁYŽ*ÁcbÃÁm{Áw–fÁ ¤Á†‰¯ÁŒFÁ’9ÇÁ•qiÁTÜÁ‰iþÁƒ·Á|Y¥ÁqFÁf tÁZÞ2ÁO|ÁCnÓÁ6ÇéÁ)ÞàÁÊcÁ–Á,ÝÀêïÀЉ À·™Àµ5À…ê À]t?À3êÀ ûü¿Ìˆg¿ˆA!¿õ4¾MÚ>RH>ÊȬ?§q?C a?d6Ó?u”j?s ?[>?,d#>Í¥„=tä¾½xÍ¿` ¿·Ò½ÀaþÀ.ÉiÀ\~ÃÀ…:›ÀÁÀ¶ RÀÎéRÀèL}Á0*Á Ð\Á¯Á'pÁ3µTÁ?œ#ÁJ¦ÁT[÷Á]ÝÞÁgpYÁqiÐÁ{uOÁ‚ø<ÁˆynÁŽ3–Á”íÁ—wCÁ‘p{Á‹œ~Á†Á€tñÁuÔjÁjÔ‚Á_Ê»ÁT•ÉÁI !Á<òYÁ0YÒÁ#€ Á©oÁ çXÀú^öÀá)´ÀÈ?ÓÀ°ærÀ™ÛÀ„ZVÀ`&¬À;ÀF_¿òÄ ¿»‘´¿‹Y ¿FÅÙ¿çW¾©>ô¾,—½Ex<{¼»­Ëw½°Ž-¾€ ¿°î¿SŽ¿™˜¿ÖzÎÀ uÀ2ê¾À\r›Àƒ-8À™ÕøÀ°ÎÀÈ~Àà·)ÀùëÁ 0Á¡ŸÁ" €Á..xÁ:QÁEË ÁOýõÁYC+ÁbzÁkÌÁu—[Áß Á…%ÃÁŠ’ÈÁ<¼Á–»Á™àéÁ“óKÁŽ9¨Áˆ§ÁƒùÁ{>ßÁpW,ÁešÎÁZ1ÁO2ÁC§Á7 ÚÁ*Ö7Á<¡ÁÔƒÁHÀòçUÀÛ×–ÀÄâÀ¯À›G À‡§£ÀlšÀL0šÀ.‚wÀ%õ¿ý¯Î¿Ø*b¿¹)"¿¡!¿ŒE!¿}·¿m`š¿r%¿‚Óö¿–£é¿µr¿Û°íÀ\‹À„ÖÀ@aúÀc0À„öCÀ™¿ÀÀ®ªûÀÄévÀÛî"ÀòÖñÁ¢ÁŒ†Ár|Á)˘Á5¯!ÁA4[ÁL= ÁUÒÈÁ^âÂÁgê[Ápö½ÁzŽbÁ‚SQÁ‡|ÏÁŒÙ³Á’sÉÁ˜DRÁœ¤®Á–Å€Á‘ÊÁ‹rCÁ…ê)Á€yxÁvÁkz¤Á`Ë‹ÁUÌqÁJ-+Á>j.Á2^,Á&qMÁxjÁ¾ÁÀï¿ÀÙ¯WÀŹäÀ²O›À váÀ™bÀ€‰ÀeÇÀLèáÀ7Î3À&HßÀ¯LÀ õÀZ¿ö®x¿ï}Ï¿ñmY¿û¶ ÀJ¼À«ûÀ'ŠÒÀ<õdÀUÊPÀt9YÀŠÏ0À ¦À°{!ÀÄÏ6ÀÙÜVÀïßÐÁ\‡Á«LÁN‚Á&1;Á1â¸Á=YÁH§[ÁSDÁ\ ÁdÉ%Ám¹GÁvÝQÁ€,Á…´ÁŠÁM“Á”ÐëÁš‹øÁŸ}*Á™žpÁ“ëUÁŽgÞÁ‰ ëÁƒ¨ýÁ|¦PÁr&üÁgˆ=Á\ì‰ÁQº·ÁF8BÁ:–gÁ/ÕÁ#rËÁïÁ  Á84ÀðÀÜí=ÀʇUÀ¹•_À©ýÀ› µÀŽc]À‚íUÀqÀ`{ÀRgÀG˜À=ÅàÀ72ÖÀ4§À4ñšÀ:)JÀC›ÀP3ÙÀa>lÀuMÀ†±ÓÀ“ÜâÀ¤‹æÀµ‡oÀÈ­ÀÛcTÀï´ñÁ‡]Á fÖÁÜÁ#°AÁ/Á:PåÁE‰àÁP_ÛÁZ-eÁbµ7ÁkX¼Át 3Á|â·Áƒ'UÁˆ ˆÁŒüóÁ’&¦Á—{Á0íÁ¢bªÁœ—jÁ–ÿÊÁ‘¡¼ÁŒa³Á‡ëÁà×Áyw¢ÁoÊÁdy-ÁY«˜ÁNPõÁCDcÁ7üÁ-mÁ"'Á}™Á * Á’ÛÀô›žÀãD´ÀÓTÀÄ1‘À¶I À©çÀŸ)ŸÀ•U¬À<À†wžÀ€áHÀy!jÀsEFÀp‡ÀqOÉÀvMÀ~¥†À…eçÀz`À—^žÀ¢~À®öÀ½úºÀÎy«ÀßúòÀò—'Á&<Á OeÁÔÁ"}{Á-RÀÁ80ìÁC-ÁM¼ÁXVuÁa|=ÁiË>ÁräÁz³ÔÁËêÁ†d‡Á‹J$ÁMÁ•_¡Áš«ŸÁ 1Á¥•2ÁŸçÁšn·Á•/ÁêÎÁЬ*Á…‘0Á€xÊÁvØêÁljüÁaóßÁWÒÁL@ÁAŠXÁ6ØEÁ,OæÁ"?Á‡Á]9ÁsQÀü†¡ÀìñÿÀÞ™1ÀÑ©¥ÀÅá¤À»:áÀ²0ÎÀªH‚À£Ü1Àž<®ÀšªÀ—KwÀ–"À–ÖüÀ˜îÊÀ9ùÀ¢·fÀªf¨À³Í§À¾UÀÊ{´ÀØ1Àç­¢ÀøoÁ7‡Á–ŒÁ[ÕÁ"huÁ,Á—Á7M±ÁAÝÁLjhÁV»Á`e¦ÁhêÁqžÁyqéÁ€ñÊÁ…oLÁŠÁŽÌÁ“Õ¿Á˜ð…ÁžÐÁ£‡pÁ©7Á£ŠåÁž1AÁ˜ï“Á“´kÁŽ“Á‰wlÁ„muÁËÁu!ÁjÁŠÁ`oÂÁUÐÁK`=ÁAÁ7#hÁ-w¿Á$'ÁBÞÁø'Á áòÁ§'ÀùWÖÀíËÀáÎ\À×)ÀÎÚüÀÇhþÀÀîÃÀ»´;À·–yÀ´ð°À´ãÀ´¶YÀ¶ðÀºëÀÀ -ÀÇ^ÀÐMÀÚ‚ÀåøVÀò¸sÁÛ,Á¬kÁ2ÁÁ#§ÖÁ-c Á7UÁAWwÁKæÁUŠkÁ_¬,Áh®4Ápù“Áxë¸Á€­ÏÁ„ëÁ‰LðÁòÁ’§0Á—”–Áœ¹Á¡æRÁ§.ÏÁ¬éÂÁ§{"Á¢"«ÁœÒ9Á—¬sÁ’¢µÁ£#Áˆ¹ÁƒÝÿÁ}èšÁsýÃÁißÁ_¤)ÁUœ™ÁKÀDÁBÍÁ8ÉXÁ0 GÁ'tîÁl†ÁÉ%ÁÕ8Á ,xÁFFÀý¤cÀóÑÀëgXÀä /ÀÝó‰ÀÙBÀÕRàÀÒ›ÅÀÒ7ÀÒ…ÀÔîÄÀØ¢qÀÝ‚\Àä¿ÚÀí"óÀözçÁúÚÁÙCÁ Þ¸ÁX\Á” Á&úÁ.þIÁ8¡\ÁB UÁK¼ÁUd°Á_ÜÁh{vÁqnÁyHÁ€’tÁ„­äÁ‰£Á~"Á’1Á–Ï®Á›¡PÁ ®8Á¥åÜÁ«"Á±_Á«–|Á¦1ÄÁ ó¦Á›îáÁ–üžÁ’Á'mÁˆQÁƒŽÚÁ}sƒÁs\ÁiÖÁ`)bÁV®ÐÁMf…ÁD—Á<ŽÁ3à*Á, ²Á$ßÁ÷ºÁ¾˜ÁÛQÁ ´“Á ºÁÃÁ`—ÀúñÆÀöËÀò”ÃÀðH)Àï´ÀðfÔÀò­TÀö:íÀû+ÁøbÁëÕÁ nÁ¾µÁh2Á¦Á"!<Á)ÒÁ2 Á:ËìÁCËÁM¦ÁVT}Á_ŽMÁh`Áq[¥ÁyÒ$Á€À¦Á„·*Áˆ¿¶Á Á‘©"Á–`@Á›øÁŸí[Á¤åÁª ïÁ¯PºÁµ@çÁ¯ËÎÁªy-Á¥\ Á Z"Á›j„Á–‰Á‘²³ÁŒûÁˆO¡Áƒ¢_Á}ÛoÁtŒ4Ák.ÁaöÁXÿ%ÁPxÊÁH>¨Á@qbÁ8؉Á1â«Á+/.Á%(Á¡~Á…°ÁâÁ0¹ÁÁlÁ ÜÁ £„Áè¬ÁÛ0Á©•ÁÁÁ(aÁ ÏÐÁ YæÁ„ ÁK¸Á¦)Á¦ìÁ"xÁ(9XÁ/Á6tYÁ> ÁÁF‰¥ÁO–ÁXïÁ`½¤Ái˜1ÁrC>ÁzÎnÁXDÁ…NÁ‰wÁ*Á‘MéÁ•ÉKÁšzÁŸO%Á¤ )Á©SÁ®5;Á³œÜÁ¹—CÁ´3pÁ®þÁ©à’Á¤ÕœÁŸïÁ›ÆÁ–_Á‘½|Á2&Áˆ³=Á„5WÁH¡ÁvGâÁmeûÁdÚÁ\‹íÁT¯0ÁLÿÇÁE´’Á>ÔÿÁ8“²Á2•HÁ-I{Á(WçÁ$ ˜Á G Á>Á25Á5!Á‰dÁsÁc?ÁâÁîÁ‹öÁ5ÁùûÁ!ЙÁ%ÌÁ*­"Á/Í!Á5бÁ<ÁBü¦ÁJ•ÃÁRgNÁZ¾UÁbÿõÁköÁsÒ'Á|<ØÁ‚1<Á…äLÁ‰®øÁ—™Á‘°Á•Ý»Áš70ÁžÙ]Á£¾Á¨gCÁ­@XÁ²S™Á·œ3Á¾ ÙÁ¸¸"Á³ûÁ®xÁ©…:Á¤œ™ÁŸØ½Á›F†Á–À Á’C›ÁàÁ‰„žÁ…%_Á€ÔÑÁy”Ápê‚ÁhÅÁasÁY»RÁR˜'ÁL·ÁEØÎÁ@4Á:áˆÁ6EŒÁ1ÿ(Á.v«Á+4“Á(™ÜÁ&ŠËÁ%kÁ$F Á$2ˆÁ$”ÉÁ%ÀdÁ'Q†Á)¼ Á,ŠlÁ0«Á4âÁ8{ÞÁ=„3ÁBïfÁI½ÁO¥ÑÁVíeÁ^~”ÁfvHÁn8ÔÁvXÉÁ~5ÈÁ‚ó0Á†ë†ÁбÉÁŽceÁ’^®Á–o¦Áš§öÁžì£Á£l§Á¨/OÁ­áÁ±ÀªÁ¶³ëÁ»ÝÁõÇ¿ÁïŒÁéZÁã.6ÁÝÁ× ÁѺÁË%ÁÅBÈÁ¿tÂÁ¹½[Á³õ!Á®EKÁ¨©%Á£!‘ÁÉ|Á˜{¾Á“=ÄÁŽ&¶Á‰ -Áƒõ¹Á}ÿðÁt¢UÁkèûÁcÅÍÁ\< ÁUQuÁO5íÁJ-`ÁEâ‘ÁB¬ÏÁ@I¸Á>þÁ>¢*Á>ß3Á?³©ÁAc[ÁCãÔÁG6ªÁK}pÁP¾´ÁVÜìÁ]ðOÁeÁÁn/¹ÁwNVÁ€tÓÁ…‡%ÁŠÅkÁ>CÁ•ï}Á›Á×Á¡·ðÁ§Ñ‘Á®‹Á´qÁ¹¾ðÁ¿€ÁÅOÁË-èÁÑ#¢Á×ÁÝ(‡ÁãRÌÁéƒóÁððœÁê°Áäf,ÁÞ/ÁØÁÑ݉ÁËÔÌÁÅÕñÁ¿åÁ¹þìÁ´.Á®sÇÁ¨«ªÁ¢úOÁ\Á—ÕÑÁ’ÁÁ2ÜÁ‡ø$Á‚êÕÁ|FÁr°AÁiÁ_ì ÁWg´ÁO€ÂÁHUÙÁAáÁ<€TÁ8EÁ4¢èÁ2#(Á0¿ÈÁ0`†Á0†tÁ1vÇÁ3-ƒÁ5ü¶Á9^ÛÁ=ñ§ÁCÁJ­ÁQWÎÁYr¿ÁbQÁká!ÁuÛ{Á€‘Á…ƒ¢Á‹(nÁ‘#Á–òŒÁjÁ£%¨Á¨ÙÁ®OÁ´CªÁºqÁ¿÷ºÁÅîwÁËçÁÑùöÁØ+ÄÁÞb¨Á䓸Áì-ÍÁåäÁß“ÿÁÙCÁÓÁÌÖÁÆ®XÁÀ kÁºœgÁ´§Á®¼¦Á¨èOÁ£*;Ác&Á—¯ÙÁ’/ÁŒŠÍÁ‡:ÝÁêÁyfkÁoeXÁeîyÁ\ŠÁS€üÁKS‡ÁC?LÁ;žÁ4ûÁ/5Á*ƒÁ&äÁ$R“Á"Ó9Á"rÁ"|ÔÁ#áÁ%A(Á(I#Á+â¼Á0ÎëÁ6²&Á=mùÁE HÁM ÒÁVüŽÁ`ÓÕÁk Áu¯çÁ€u0Á†LõÁŒ5ƒÁ’6 Á˜Á‘ÂÁ£B:Á©ÚÁ®Ø€Á´Ã&Áº¹MÁÀ³ÌÁÆÌ´ÁÍÁÓ=žÁÙtÁß»ÄÁçŠ+Áá*žÁÚÓ ÁÔ|DÁÎ$úÁÇáÅÁÁ¯iÁ»ƒÁµo{Á¯eÄÁ©k~Á£|IÁ£¹Á—áCÁ’¡ÁŒf Á†Â–Á@µÁwêÁmBÚÁbÞ]ÁXþ¬ÁO–òÁF8zÁ=xyÁ5µõÁ.ПÁ(`Á"fúÁy±Á}¼Áæ ÁM{ÁéÁعÁÖ0Á½ÈÁñøÁÞKÁ$&Á*2&Á1\åÁ9d*ÁBhBÁLçÁVÁ`˜öÁk¾—Áw]XÁ…èÁ‡´ÁŒ¼OÁ’JãÁ—øoÁÊÁ£žuÁ©HÁ¯„ÓÁµWÁ» ýÁÁÚÁÈ.ÁÎWÁÔ§ãÁÛÏÁã˜ÁܘÁÖ(mÁÏÈÛÁÉj]Áà žÁ¼ÁùÁ¶&Á°Y`ÁªB¤Á¤2 Áž2×Á˜>BÁ’`‘ÁŒ™7Á†ÕPÁ Ávì¬ÁkïœÁa`·ÁV±åÁLY¦ÁB£þÁ9?›Á/ú¥Á'˜ƒÁ Z?Á†¹ÁMŒÁ›GÁ /¡ÁZ=Á4Á˜»Ás²Á¬0Á Á!ÁkÁjÁØAÁS“Á%Æ Á.VÁ7ÀØÁA€(ÁKÖ„ÁVÒøÁaä9Ál¹7Áw¤FÁoÝÁ‡ŽÁŒ®¶Á’„ªÁ˜eƒÁž_[Á¤RTÁªQÁ°wÁ¶µ„Á¼÷~ÁÃ=eÁÉ•fÁÏöëÁÖ\4ÁÞŒ2ÁØRÁÑ‘ZÁË"ËÁĺüÁ¾YîÁ·øÁ±§Á«k'Á¥0_ÁŸÁ™ôÁ’ýÊÁ!Á‡2ÁRWÁw çÁkª8Á`UÁU`óÁJ×­Á@!gÁ5ÛÉÁ,LwÁ"égÁÙ¢ÁóWÁ ×ÁffÀþO À÷qÀñVÀîxHÀí=)Àï8ÀòcœÀø¶œÁŽÁlìÁ ÅeÁ‹ZÁ€Á#€ºÁ,ÊrÁ6¬<Á@éªÁKPBÁV†Áa =ÁlF×Áwz4ÁeÌÁ‡@wÁ-îÁ“.ïÁ™ ~ÁŸ%5Á¥R÷Á«•ÒÁ±ÜrÁ¸'ÂÁ¾‡ ÁÄðÉÁËbtÁÑåÌÁÚ?¨ÁÓ¥ËÁÍwÁÆ”5ÁÀÁ¹¬~Á³FGÁ¬ähÁ¦KÁ HÒÁš'Á“ë¡ÁÑ—Á‡ËËÁË­ÁwÀ2ÁlîÁ`˜ÁU!ÁI¿ Á>ÖQÁ4FeÁ)‘ÁgÂÁõ$Á •ÁãôÀù6ŸÀë‘ÁÀß¶vÀ×ÕˆÀÑgãÀΊMÀÍL‚ÀÏQ8ÀÒÊWÀÙâÀâTÿÀí=ïÀúf|Á‚¦Á :©Ál{Á 0QÁ*j‡Á4½bÁ?ƒÖÁJrVÁU­òÁ`æŠÁl<˜Áwü¸ÁøÁ‡ý(ÁðßÁ“þïÁš4}Á |ƒÁ¦È+Á­§Á³‚Á¹óyÁÀq@ÁÇ4ÁÍ”~ÁÖ ÐÁÏ_ÁÈÁ¹ÁÂ-YÁ»žjÁµQÁ®¥‡Á¨7Á¡Ð¿Á›t¨Á•'¥ÁŽáÁˆ¼@Á‚¡¶Áy3ßÁm//ÁaGêÁU’ÁÁJ6Á>“YÁ3+ÜÁ(LþÁ³òÁ­Á bÀÿ>~Àì¥ÿÀÜg ÀΨæÀÁ’<À¸”À±ñ¿À®ŸFÀ­a„À¯Ž§À³U…À»ÇÀÃÔ®ÀÐZÀÝŽÀíòˆÁ"dÁ ·ÖÁâ'Á,+Á(é%Á3ÙœÁ?ÁJT~ÁU±QÁa}ðÁm…³Áy–tÁ‚ÄñÁˆß^Á_Á•kÁ›»ÓÁ¢°Á¨†tÁ¯´Áµ‰ÁÁ¼ÑÁ±!ÁÉJùÁÒÐÁË;ôÁÄßÁ½ÝÁ·HÜÁ°­Áª(àÁ£¨Á0ÜÁ–ÁæÁ]»ÁŠ @Áƒ¿-Á{"þÁnä ÁbÏwÁVÇùÁJ×€Á?aÁ3†]Á( ;ÁœsÁûÁ!€Àøê„ÀåU^ÀÒ—»ÀÀzÀ±Á|À¤!¡À™oBÀ’­ÂÀ޹.À€ÀÒŠÀ”óÀœ;2À¥ä<À²íÀÁ±ËÀÓ¸}Àæ~äÀú®1Áž»ÁNtÁA"Á(|*Á3ĬÁ?+ÁKeÁW¨Ác2—Áo;~Á{”Á„fÁŠ`¿Á´Á—ÜÁ–½Á¤1Áª¥]Á±8lÁ·ÑžÁ¾w.ÁÅ3¤ÁÎŒÁÇ? ÁÀvêÁ¹¯dÁ²ý.Á¬cªÁ¥ÂkÁŸ4Á˜³KÁ’5;Á‹½QÁ…N›Á}ñÁqKïÁdÜ>ÁX‰ÂÁLh¥Á@a(Á4n‰Á(”¾Áý„ÁÁ×Àöu&ÀáÀËÖùÀ¸ª°À¥ú À”õÀ‡7ÐÀuq€Àfõ¨À]¸ŽÀ[`À`-ZÀj$¨ÀzÏ:Àˆ§~À– aÀ§,2À¹ )ÀÍšrÀâ.©À÷g†Á© ÁãFÁ8 Á(«ëÁ4˜ÌÁ@¹ÁÁLÒ:ÁXùzÁemÍÁr XÁ~® Á…¶HÁŒ-úÁ’®qÁ™4ãÁŸÂ8Á¦Y½Á­Á³² Áºz=ÁÁQÑÁÊO?ÁÃ]§Á¼€@Áµµ°Á®æ?Á¨$…Á¡~ŽÁšÜ}Á”AàÁ½ßÁ‡<ÖÁ€ÃYÁt–µÁgÝ\Á[0ÁN©ÁB?¡Á6£Á)úWÁþÁ"óÁuÀõïþÀß$ ÀÉcÀ³ù5ÀžÜZÀŒCÀrïyÀT¡À9§èÀ(®ˆÀ üÀí„À µ¡À,xÀ=²‡ÀVÿ%ÀuD¹ÀŒûÏÀ ‹Àµ3ÀÊ2$Àà"%Àö•ÚÁ°2Á7Á3ÒÁ*X'Á6|$ÁBÈÁOdöÁ[ùÁh¦ëÁu‹_ÁI*Á‡Æ:ÁŽRvÁ”æÁ›ŠÃÁ¢?yÁ¨þÞÁ¯ÊsÁ¶ âÁ½‚bÁÆ´Á¿¹pÁ¸¹<Á±Ë­Áªô¶Á¤$YÁU@Á–žÿÁýnÁ‰]\Á‚Í,ÁxŽyÁk•|Á^¢7ÁQÓ+ÁE#Á8‰÷Á, ÁººÁ”ûÁ¢€À÷€OÀßåÀÈäÈÀ²0lÀœPûÀ†ÔOÀd0¦À>î’Àb&¿ÿp¿Ôܦ¿½c”¿¹ z¿Â—k¿Ý¡­À×QÀ2‡À@ßÀg IÀˆ=¤ÀœüÃÀ²íÀÉk$Àà` À÷£¼ÁÜåÁ#Á 4²Á,­¶Á9xÁEïkÁR¼6Á_ËÚÁlɯÁyÈQÁƒ|.ÁŠZÁÏOÁ—“.ÁžSäÁ¥…Á«÷ÉÁ²ãdÁ¹Ð>ÁÃ56Á¼$ïÁµ%µÁ®"Á§#ÄÁ ;oÁ™gQÁ’”™Á‹ÏrÁ…)ÑÁ}ªÁoÛ‰Áb³SÁU¥ÄÁH°xÁ;ÉÈÁ/…Á"lÍÁî_Á ‡¹Àú‚UÀâŠVÀÊÉuÀ²ù=À›òÚÀ…KÀ^}ÎÀ3^ÔÀ c¿Ë²I¿‹~Q¿3cɾÿZ¾èï·¿ á¿D¦³¿‘<õ¿ÏpÀ "ûÀ6TÀ_‘ÙÀ…½ÀœKýÀ³z‘ÀË Àã@iÀûŸÕÁ 'Á´Á#x(Á0„Á<÷œÁJÁW gÁd+·ÁqxÁ~ÎÿÁ†'ÞÁŒí Á“ªÖÁšytÁ¡^vÁ¨KeÁ¯7ºÁ¶&ÿÁ¿õåÁ¸ÆEÁ±¤ŒÁª• Á£‘€ÁœŽ Á•– Á޹"Á‡åÿÁ÷ÁtȦÁgŽÕÁZC¸ÁMÙÁ?ÕmÁ2ljÁ%ËÉÁ Á S™Àÿ®’ÀæÕÕÀÎ[Àµ×±ÀžœÀ†8À^‚À0ÍäÀY¦¿²*¿G¿Ù¾]`C>uBý>öŽ»? '>>áŸ}>3â¾t±õ¿M–³¿¸ç ÀE‹À1/vÀ^ŒñÀ†ÊÚÀž±ÃÀ·!ÁÀφ Àè +ÁÓMÁ ‚îÁKšÁ'I•Á4W‡ÁAwšÁN¾HÁ\2Ái€sÁwÁ‚D¯Á‰VÁåÁ–ÆßÁµÂÁ¤«Á«¦ZÁ²²ÏÁ¼ÌâÁµš§Á®h°Á§8­Á cÁ™­Á’ 'Á‹ šÁ„ÌÁz”€ÁlàÁ_RÃÁR zÁD³†Á7qÁ*: ÁdÁñŽÁ À즡ÀÓ•Àºœ¾À¡íÎÀ‰rºÀb²~À33±Àh,¿® {¿(Õù;ïÊ ?•Û?‘ç¯?» ô?Ãc,?µ©n?Šè™?Ë¡½)$¿-H¿®~?ÀÀ4»`ÀdÆlÀ‹4<À£Ê©À¼„ÙÀÕî@Àï~qÁÌ«Á©ùÁÈÌÁ,Á9_“ÁF³hÁT8Áa½|ÁoZÿÁ|ÿÁ…RuÁŒ;[Á“7ëÁš9âÁ¡@gÁ¨RôÁ¯r÷Á¹ÚÁ²ŽïÁ«QSÁ¤ÁœêùÁ•¼ ÁŽ£1Á‡Ÿ)Á€–¡Ás* ÁeiKÁW«‚ÁIô[Á<‡ºÁ//PÁ!ç?Á¹JÁŠ1Àô±‘ÀÚ¨sÀÁšÀ§« ÀŽteÀk­DÀ:²ÊÀ Ä¿´½ê¿-Æv=0š0??º¦?²H/?ÿ+m@™¶@ [í@Ìz?ûßÎ?¯Ô{?9^Ô= v¿0Få¿·œÀ %ÄÀ> ¿Àp(À‘>ÀªtsÀÄŽ‹ÀÞ– Àøh Á vsÁÈTÁ$ëÁ1~Á?šÁLÁZD¿Ágë£Áu§ƒÁÏ ÁˆÔKÁÙúÁ–â!Áô‰Á¥nÁ¬MpÁ·üÁ¯·aÁ¨kaÁ¡ ®Á™ä‘Á’±Á‹x|Á„KÁzm°ÁlTÁ^4°ÁPFÁB„Á4ÁîÁ'.ƒÁØÁ ‚eÀþvSÀäèÀÉ¢;À¯pTÀ•œ©Àx[©ÀEÄÀ¶n¿ÅÀ¿HN¼Ùð-?5®—?¶×Ÿ@¬æ@1æü@RÊ+@Y¦ñ@SvC@1ãÐ@Ý?¶çÐ?2ê´½4Žý¿Qý4¿Í®À¨PÀKÏKÀ¢ÐÀ™È}À³ÈEÀÎ*ÜÀè]xÁˆíÁÿúÁTÈÁ)ã¸Á7ŒsÁE5.ÁRåÁ`Ò§ÁnÜËÁ|çÂÁ…~!ÁŒÁÁ“®‚ÁšäÁ¢¼Á©]ÃÁ´hcÁ­MÁ¥©¹ÁžQÞÁ–ÿQÁ³}ÁˆwÁ>\Át ~Áe·´ÁW•WÁIy¦Á;h~Á-›"ÁßèÁ.2ÁÌÖÀîêÿÀÔÀ¹RŽÀž¥°À„G1ÀT¤mÀ!ޤ¿Þix¿t†w¾7ò+?è¾?«“ª@ñ´@3w•@Wߦ@_G@a)@`ÀR@X3i@3ø@#p?¥à'?ÉŽ¾‰Ïy¿ˆÆ¿î[ëÀ*ÍiÀ^~ÇÀ‰Ì À¤µÀ¾?nÀÙ[ÀóÐ…ÁCÁéÁ"•ÚÁ0B±Á>ðÁL ¢ÁZ4nÁhTˆÁv‡]Á‚a´Á‰’JÁÔrÁ˜ÁŸ[áÁ¦¨nÁ±î±Áª…ŽÁ£øÁ›±ŽÁ”VšÁŒü[Á…¢­Á|¬nÁn8wÁ_ȃÁQZ´ÁC‘Á5oÁ&÷UÁöÙÁ 7mÀúítÀߦ(ÀÄæcÀª8À„ºÀi•ÜÀ48À>w¿™1 ¾ËL>ÆÔF?”ˆß?õ× @*èŽ@M•:@Wå3@\r©@^=@]–~@XÙà@J$>@#–c?åÔJ?€“È>i1 ¿Rc¿¯rÀ JÀ? äÀtç+À”¼À¯'DÀÊ-tÀåE@ÁDÞÁ ò\Á¸*Á)¤+Á7ºVÁEÚ©ÁT%ÕÁbm Ápº×Á5ZÁ†ÝŒÁŽ}Á•` Áœ®úÁ¤mÁ¯‘;Á¨ãÁ «,Á™>·Á‘ÒhÁŠlÁƒ1Áw|ÁhÒ+ÁZ7fÁKÁÁ=TŽÁ.ûÜÁ ·Á£äÁ’‰Àí('ÀÑ­œÀ¶=qÀ›Y>À€ÀKÈÁÀ¤,¿ÂÚ¿2ò=âð‘?f•å?×^º@Ý4@=a@LÜ[@SçÅ@W¸/@Yx§@Ya‚@U€„@J®å@3nM@ ã$?¹R?-ø=½ßë¿j`¿Û• À#jçÀW"À†BÁÀ¡vÊÀ¼OÑÀׇ&ÀóIæÁ{»ÁRrÁ#j$Á1¹’Á@ ÁN`GÁ\Å|ÁkN£ÁyÜOÁ„6•Á‹‚ëÁ’ßðÁšM1Á¡ÈqÁ­r’Á¥îŒÁžk‡Á–óÁ†¡ÁˆµÁ€°uÁr†sÁcÆÞÁUHÁFxEÁ7ÓÁÁ)VnÁÎÁ ¬ÖÀüàÊÀàì‰ÀÅ…À©šYÀŽbGÀfÀ0“¿÷j¿Œºx¾‹,Ä? ®‰?«&ó@ìf@'°W@òÖ¿“ο§ÂuÀ ÆÀ<>ÀrÞÀ”À¯A~ÀÊÝÉÀæ«HÁRìÁ”¾ÁòôÁ,QYÁ:°hÁI6ÁWÓâÁfqºÁu©Áâ[Á‰L:ÁÆÁ˜L»ÁŸÜ?Á«|Á£øÁœv‘Á”õ\ÁmWÁ…ëZÁ|æèÁnäÁ_,0ÁPQ%ÁA‰AÁ2íÈÁ$\pÁÑ•ÁvíÀòugÀÖTÀ¹ÔïÀžÏÀ‚XÉÀM¦JÀš¿ÅA¦¿8áÊ=ÀH?aÎV?ÐÝÇ@ h@&³@8– @E†Ò@M«$@S»@V+é@UÍL@O±c@E5#@4Nv@rÐ?õ:£?¤tš?³¡¾.þü¿u‰"¿ã-¶À$¡ÀÀZ(}À‡áØÀ£Õ9ÀÀ9ºÀÜ7ãÀøy¼Á ÎÁzÁ'«Á6¶ÁDœVÁSGÒÁb½Áp÷ïÁÙ¼Á‡d°ÁŽèÁ–wzÁžÁ©ËÐÁ¢;ÎÁš¯¹Á“,ÞÁ‹®±Á„Áy ’Áiò´ÁZú¬ÁL'œÁ=`ŸÁ.ŸLÁð›ÁpdÁú:ÀèÿÏÀÌÀ¯º$À“‹aÀoTÀ9ŒÀÞ¿œ½Ð¾Îµv>º÷G?Œ¢Ç?Ù4@ %j@"nc@4üY@C¾@NÃp@VÙ±@[%º@X¼w@QÚâ@DÚu@1Ñ@ÓŸ?úK>?²„Ø?Cð=RXÇ¿1«ð¿½UóÀDÀHPØÀ~!oÀšä]À¶¦ªÀÒÒ¬ÀﻩÁu2Áâ`Á#UÓÁ1âÈÁ@§ÄÁO†ÁÁ^fÁmG˜Á|CÙÁ…¯ÁHíÁ”ítÁœ˜iÁ¨HãÁ ¸îÁ™*uÁ‘ÁŠÊÁ‚‚|ÁuæjÁfÉ1ÁW¯»ÁH¢ÔÁ9½4Á*üyÁMáÁ šÚÀýʆÀà‰´ÀÃÚkÀ§ojÀ‹teÀ_ÛëÀ(õœ¿å¶9¿€¾eù>øL×?‘Ì3?Ôƒ@Oy@¯(@3‚“@F- @SÌÑ@^÷7@cˆ¾@`Ü´@V^ƒ@E¸Î@1H£@Öó?öàt?³ì?S^¡>*ÿ(¿É¿¥4ÌÀƒØÀ9ÕBÀpÜfÀ”SYÀ¯ÐqÀ˲tÀè^ãÁÍJÁmÁ ¹Á.Ê Á=¡»ÁL}GÁ[l8Áju'ÁyœËÁ„nŠÁŒÁ“ÄÑÁ›q‰Á§@ÁŸaÿÁ—ÂÁ- Áˆ¢tÁ³Ás(6ÁdÌÁUÝÁFqÁ7™Á(ŠÁ°Á 7+À÷*$ÀÚAaÀ½¦eÀ¡KÀ…ŠLÀS:ÀF¿Óôˆ¿]ìy¾W>ÿ‚Ÿ?‰0^?É’V@WÞ@yŽ@6U†@LÊc@_8;@k›@pl‘@mI@`–ƒ@K”ñ@3›þ@s?ð–B?­(ë?K6>=,­¾ö{ù¿šüG¿üN‚À0q¢ÀgpÀXØÀªÅ,ÀÆó¡ÀãiÞÁãÁˆ•Á2Á,gÁ;!"ÁJ*ÀÁY4ˆÁhJèÁw|ÉÁƒcŽÁ‹KÁ’¿ÑÁšnWÁ¦õÁžk"Á–¾³ÁkÁ‡‚×ÁåtÁpÍ^Áa¾øÁR½)ÁC¿„Á4Å^Á%ÐMÁïÁ"PÀòâñÀÕàµÀ¹™ÏÀlÙÀGUÀLÁÀ¸¼¿ÍvD¿`˜¾Gw²>Ös…?zî?À1C@‚™@³ @=e¸@Wd~@nr@|5R@‚@}n2@möi@UÖg@9SU@œ;?ìÍf?£¹Æ?4IT=×{r¿ P¿œÅŠ¿úY˜À-\ªÀb§ÝÀŒ, À§—ÀÃèœÀà@Àü­ŸÁ ßÁ¬ÿÁ*ŽCÁ9w`ÁHhÝÁWyÿÁf«OÁuöËÁ‚¦pÁŠQÝÁ‘ýŸÁ™©¦Á¥lÝÁÁÁ–ZÁŽsºÁ†×@Á~kLÁo+ÅÁ_õÁPÚ¨ÁAå$Á3xÁ$E‹ÁŠ$Áä™ÀðõõÀÔ:CÀ·ÜÀ›(ÒÀ€A¥ÀLÑÙÀ¬Q¿Õà¿wg¢¾¢¼>•OX?`AS?ºÂ&@&Û@&Õc@Hˆ)@h¢@€R@‰è±@¼ù@Šá@€85@búZ@AXç@e)?êH™?™×l?bq¼C2¿$*Í¿©¾sÀ:À1ÛÃÀd–yÀ‹ÛŠÀ¦ïDÀÃ6ÈÀߌÒÀûòžÁ {Á;Á*µÁ8ËÁG½ïÁVÖ´ÁfBÁuV‘Á‚O“Á‰óÞÁ‘˜ÓÁ™EÁ¤íèÁ<—Á•“;ÁónÁ†^ÒÁ}®gÁneÁ_MxÁP&óÁA#„Á2L Á#¬xÁ>ÁìÿÀñ'ˆç?T?¼*S@Fg@1`›@WÉ@zÔ:@Œ§@—‚Î@›ó@˜£@‹"H@r©i@Jv!@ ƒ5?ë*?” k?øK¾Z¿PxC¿½Ä1À oµÀ;ˆ±ÀlK€ÀŽÁmÀ©BnÀÄÙdÀàŽWÀü¨áÁ ¹èÁ>†Á)ØŠÁ8–IÁG…©ÁVœYÁeÒšÁu!©Á‚<–Á‰èÁ‘”‡Á™A¬Á¤Î‘ÁoÁ•p_ÁγÁ†8Á}\•ÁngúÁ_XÁPŽÁAžEÁ2ÚõÁ$PÁí3Á…¶Àò•áÀÖÉ›À»• À¡A}À‡l4À]TÀ.ÕÀª¿ªzË¿$Þ#=ÛØ?YX3?ÉyV@/õ@?Ëü@kËš@‰=Î@š‘@§ Ï@­ä%@§hª@–nj@GK@U @':ß?ïÛ?’^<>ÙúU¾’»¿|º5¿×þÖÀ£sÀH'ÀxÎçÀ”åÉÀ®-pÀÈÑxÀä(NÁçÁ>¾Á€¾Á*æ„Á9ŽÅÁHk¡ÁWqìÁfŽ=Áu¶éÁ‚tåÁŠ—Á‘´jÁ™^Á¥ Áb|Á•»ÁŽgÁ†‹(Á~ ¼Áo æÁ`!øO?{ÄO?ä¹Â@"kk@RŽp@€P@•m@¨‹@¸³O@Ác@¶|e@ o8@ˆžû@aš@0?ûçí?˜6g>Éþ²¾¾ËÅ¿‘ô¿ïå…À)£ÀY=àÀ„‹½ÀœÇÀ¶ ÈÀÏS^ÀéUÁUîÁt~ÁÅ\Á-%ÏÁ;¦ÁJ`ãÁYD Áh,lÁwwÁƒ¾ÁŠœØÁ’6,Á™ÙéÁ¤“Áþ™Á–i"ÁŽÛÁ‡W+Á½-ÁpÝüÁaÿ ÁS(ÅÁD|Á6 €Á'Þ’ÁíÁ i¥ÀýŒÀãƒÀɘÀ°Î¼À˜&ÑÀ|W“ÀEmÕÀ 󑿦Q—¾Þ;:>ÚXh? û@ÜC@68%@fè;@‹ @¡Ê©@·T!@Ê@ÖXå@Âðç@ªçœ@‘ö¡@p°@<í<@ ·Á?§îJ>ô¢Þ¾ŸôÉ¿’®^¿ýJ¶À4 OÀhQÀŽÀ¦X#À¿ ÎÀ×ÿ Àñ‹ÐÁ(VÁïôÁ!Å Á/ÌŽÁ>*ÁL­µÁ[pºÁjR]Áy>•Á„ªÁ‹– Á“#¯Áš¼¦Á£Š“Á 7Á–Ü\ÁåCÁˆn^Á€üÁs+GÁd}ÁU¥ÁFxiÁ7k§Á(ŠÁà;Á w!Àú86ÀÝ©:ÀÁ.cÀ¤³ŒÀˆ¤>ÀZƒ-À%¾¿à–N¿cʆ¼°¡Ç?GV?ÐúÅ@Îû@Pw)@#@˜ù@°«n@Æžœ@Û;@èã@ÐU@¶¯©@œ›H@Ý@N°Ç@o(?Dz?6ºe¾ M¿€¦¹¿ñ£À1ûgÀi5ŽÀ‘À®F¶ÀÈÕ_Àá· ÀûCÁ ~þÁ ÉÁ%á Á3·ÁA¾ðÁOÿÁ^mÌÁmWÁ{³´Á…?åÁŒ³òÁ”6–Á›üÁ¢Û»Áœt2Á–)*ÁŽÜ*Á‡çÁ~ÂÎÁobUÁ`ÁPÉÁA„ƒÁ2F´Á#€ÁåVÁâëÀìA‘ÀÏb.À²ª¯À–ÿÀsHOÀ:R¡ÀãQ¿›sZ¾È­>ݶƒ?¥ÅW@w@9~Q@lÓ@©@§Ü@¿{@ÖÓ8@컫@õêï@Ü®@ÃV@¨Pü@öË@fªÊ@0SÚ?óG=?†a><$û¿+5¿ÃÊÀªÀQ(À„¥ À Í»À½O’ÀÚêÀ÷Í>Á §xÁ•ýÁ(¨ÂÁ7Ö5ÁF&)ÁT/ÒÁb@NÁp{ Á~æ‘Á†¿âÁºÁ“ß7Áš$ÞÁ¢üÁœ*µÁ”òðÁ‚Á…IÙÁzñEÁkTµÁ[ÂpÁLAÁ<ÔòÁ-€)Á3ˆÁí¦ÀÿaÝÀàüÊÀÂ¥UÀ¤Î³À‡ÖÀV;9À)†¿Èg±¿,øª>,>[?}àÈ?èb¬@'ã'@]I@‡rÚ@ ƒJ@¹KS@Ðç¯@çß)@þ$Aá@êP@Ð1ˆ@¶yæ@››¢@€Èo@LËÒ@Öm?¾ow?'‚ɾSfJ¿†½h¿÷-OÀ3îmÀlgwÀ“KCÀ°­:ÀεÀì°xÁn¥ÁŸÁ#åšÁ39ÁB*ÁQóIÁag ÁpéÁ€:œÁ‡,Á&Á“?ÞÁ™‚Á¢‘¶Á›J“Á“iÂÁ‹‹´Áƒ±,Áwµ Áh âÁX^¥ÁH³gÁ9 AÁ)eQÁÎXÁ O&ÀõßñÀ×>`À¸­žÀš93Àw­*À;åÀ”¿ŽEë¾aPö?+‚z?Ç< @xï@M-;@€ ì@™ô±@³É@Ë¥µ@ãƒý@úÛÙAŠPA oe@øÿa@ß;›@ÄÆ@ªzº@?§@jf½@4²»?þ•J?’S@>³¿¿½2PÀ)”ÀSíRÀˆWÀ¦>ÀÄiÀâÓÑÁ¹JÁÁ’PÁ/äÁ>²ÁNS\Á]ü&Ám­Á}gËÁ†•XÁŒíVÁ“ Á™G…Á WoÁ™öéÁ’çÁŠ-hÁ‚I·ÁtÍùÁe »ÁUHSÁE‹³Á5Ù4Á&-åÁ‚§Á×iÀîVmÀÎûDÀ¯¶²ÀÂÀÀd9£À'P¿ÔKø¿5‚ü>hB?êh@ÿg@9õ@qy¬@“ü@¬­‚@Åïå@ßC@ö¶¥AóÖA|ÆAŠA°^@ïcA@ÕL›@ºÙx@ 2Þ@…êÃ@Vså@ 1·?ÏÉŠ?>4R¾$n¿BõÀüÀ?V¬À{ׂÀœƒºÀ»…!ÀÚº‘ÀújÁ ¼˜ÁxÊÁ,:KÁ;ÿÅÁKËQÁ[žuÁkw©Á{UÈÁ…›ùÁ Á“Á™QIÁž§Á˜.öÁð©Á‰îÁ|ÁrV¶Áb…LÁRµåÁBç"Á3²Á#MúÁ„…Á¼¨Àçý•ÀÈ¢³À©GŠÀ‰ì`ÀU"lÀl¿¯k‹¾Ïßç? 2k?ÀLÝ@ë¬@W ^@ˆ ï@¤„Æ@¿—[@ÙZ…@òPrAwAïÿA]A3"A gACF@æ7Ó@ÌE@±è)@–Õà@v†“@=÷Õ@‘?Žlî>-½ç¿J(~¿à§À/6aÀn¥À—‹À¶°xÀÖM1ÀõééÁ Å>ÁžlÁ*~ÎÁ:dÁJNiÁZ;xÁj+ÁzÀÁ…ÁqÁ“’Á™Á ÁœãÁ–-æÁyÁˆ:Á€%ûÁpoyÁ`’ûÁPµ‚Á@ѤÁ0íÇÁ! žÁ,úÁW¶Àã”ÀÃqÆÀ£ÒøÀ„4*ÀHûšÀ ²³¿•þt¾Då?I ?â<«@/Ô©@mŠA@•9m@³Ä@Ï”+@ìA7AnðAxiA&½!A#PAA è@ø«@Ý’å@ˆX@¥ï@ˆ˜)@Sx#@¿õ?¬Í">·d¿".¿Ïì»À'a9ÀfÖ†À“?_À³"|ÀÓ ËÀòþÁ xÌÁs«Á)oWÁ9hÅÁI^ÉÁYTÏÁiJ×Áy@àÁ„›uÁŒ–{Á“öÁ™ðºÁš+Á”AÞÁŽ[ÉÁ‡MÓÁ~²·ÁnÉÇÁ^àÙÁNø½Á?TÁ/.ÁL©ÁfùÀÿÂÀß>À¿vLÀŸ®‘ÀͬÀ@>5À±¬¿‚Õz½ HF?tAì?ø©¶@;Ö_@{IJ@œù’@¼Tb@Û¯Œ@ú_¢A 3AdþA%ÇdA1ŸA,6AÒABA¢®@ìïÍ@Í¢û@­¨T@­­@[f @p¾?¶öÞ>Ü1¿¼¶¿ÈÈøÀ$YÊÀdOÀ’"3À²1ÀÒTÀñô^ÁñÁéÁ(à­Á8ØqÁHÐKÁXÈ5ÁhÀ+Áx¸-Á„XÁŒT$Á’]¦Á˜MóÁ˜›ÝÁ’¦©ÁŒ·Á†œ0Á}]Ám‚ Á]Ÿ?ÁM·ÃÁ=ÐKÁ-èÔÁ\ÁåÀüdÛÀÜ•ëÀ¼ÆüÀœâ¥ÀyïzÀ:ÿ¿ôÂL¿jÕt=žÍ}?‰Dj@Mþ@CùÇ@ÒÈ@¡X@ÁD¥@àéÜAN~A,ËA mA/TQA<+DA5A%ÃfAÛÍAòZ@ì5@Ì?*@¬oc@Œ£#@Y°@÷?µ >×mB¿Éõ¿ÉÖhÀ$ãêÀdÜ¡À’j¬À²gÀÒcbÀò_¾Á . Á,:Á)*hÁ9(™ÁI&øÁY#äÁi"ÁyHÁ„}ÁŠë[ÁÎÁ–ÁvÁ—;‘Á‘)-Á‹CÁ…ŠIÁ|c·Ál…‰Á\§pÁLÉqÁ<ë‘Á-"ÁóÁ *ÅÀú{2ÀÚ àÀºÆ–Àšì[Àv$pÀ6pQ¿íxb¿\ D> 6b?í–@Að@H @ƒì@£Ñ¯@÷B@ãœÔAÁ3A³üA!¦ÆA1™A@åÇA21ÎA"¨FA‚A‘ @çÉÅ@ÈlF@©Æ@‰B˜@RæÌ@J?§ˆÂ>¢_¿- _¿ÕæÐÀ*£¸ÀjTÀ•,À´ÚTÀÔ²|Àô‚sÁ &ÃÁÁ)ûŽÁ9ëNÁIÝÁYјÁiÇ6Áy¾ Áƒé Á‰¢ ÁŽwÁ•†ÇÁ– áÁwÁŠ8Á„W Á{àÁl#Á\PHÁL}Á<¢\Á,¹±ÁÑRÁ éWÀúÐÀÚ6ƒÀºk”Àš¢-Àu¬XÀ6ð¿ìþ7¿[ÁH> ¹?&I@”Ý@GÌ@ƒZ@£/=@Ãm@â´A'íAò˜A ”ÎA06iA4P'A+pçACA¿§@ÿM|@à¼3@Á¨+@¢n@ƒr±@HKƒ@ xS?•R¬>>±…¿K?œ¿äpÀ1ŸQÀq &À˜P}À¸èÀ×ÑRÀ÷‘½Á ©ÁŠ)Á+o§Á;XâÁKD§Á[0»ÁkˆÁzß Á‚áÅÁˆÁŽe(Á”Q²Á•+uÁ+:Á‰H ÁƒƒEÁ{a?ÁkáÏÁ\%ÔÁL`þÁ<ŸÁ,ÞÃÁoÁ TÒÀû)ÀÛ[§À»®À›óhÀxqrÀ8ü¿ó o¿hEh=¢¸"?‡Ã.@­m@AyC@€"£@Ÿ‘:@¾¾¿@ÝéÂ@ýÅA ÜAè+A"¢öA$Í-A"9AQAß@óR»@Ö<.@¸^2@š5=@wD@:³?øbò?wïÿ»”-¿{eÄ¿úÑÂÀ<…Àzå[ÀœÜ™À¼F„ÀÛ¸×ÀûKÄÁ {UÁY&Á-:pÁ=»ÁLògÁ\¼ýÁl‹IÁy<ñÁ‚ëÁ‡™ŸÁMjÁ“0ðÁ”cÁŽdÑÁˆ•”Á‚ÑÒÁz>lÁkÞïÁ\gXÁLÒ=Á=|Á-^ ÁŸÁ ã±Àü]ÀÝiÀ½¾tÀžhÓÀ}ïÀ? |À)æ¿‚Ž¢½4&û?lâ?ò¯ô@7Œä@u½@™yô@·¸–@Ö&Ä@óƒ(AÎöAALCAL¸AÝ@A óÚ@ÿOð@äp!@ÈœS@¬]@±@bîÀ@&ž?ÔuÈ?4?¾€´ã¿šzÀ ícÀI"ÜÀƒË%À£ÝÀÂZ•Àá¢LÁuÁzÁЙÁ/…Á?<ŠÁNù×Á^«`Ám—ìÁxE0Áa;Á†×7ÁŒ‹Á’vÒÁ“õiÁòƒÁˆ$ Á‚vãÁyaÿÁlêÁ\û‡ÁMÁ=ÿÕÁ.yóÁnÁ“ÒÀÿå Àà£ÀÁbÄÀ¢B;Àƒ'JÀH¯À âο˜ ³¾o°Ø?:ùy?Øá¨@(Ô6@e7˜@…Q@­¶@ÉÜU@ä–@÷|A OAöAÖ5A²AT@ë–3@Ó#¯@¸¿M@l@@†e@Iù±@ïN?«O>Ì[¿ îp¿¾KPÀ‚}ÀYßUÀ‹žÀªHÂÀÉÈÀè›Á‰\ÁþÁ"­­Á2HÁAÖ|ÁQd­Á`bÁm[Áw°¯Á Á†…÷ÁŒ=ŽÁ’,Á“óÁóÁˆ£Á‚IŸÁxíEÁlŸÈÁ]ÒhÁN×°Á?ŠmÁ0FBÁ ù\ÁýÁVÀå<ÀÅûÿÀ§&Àˆ{éÀS¤À§_¿³Øˆ¾êî>øwD?´êT@’°@OÁb@ƒü@ŸŽ @¸¦×@ÌåË@Ûô@ãÛr@é@°@좯@ì«Ò@ä®@Ôú§@¿[ @¦óù@Œ÷>@dI^@-Q?ê,?p‡?=Û>¿aºU¿ç©‹À/³Àkö­À”:¸À²äÀÑ’kÀð9oÁp:ÁÈÁÁ&=BÁ5™öÁDÁ°ÁS£Áb¨ÁmÁx‰Á6¯Á†®cÁŒdUÁ’Q<Á”ŠÁŽ% Áˆ>Á‚]¡ÁyïÁmndÁ_OÎÁPaÁAYÁ2dÁ#EWÁí­Á§ÀêúîÀÌ¡GÀ®CÀäðÀc5À'|c¿Ø,¿BO9>.”?ˆ¨î?ù‚m@4'×@hœ¦@ŒÊ¦@¡Û¤@²'ò@½È´@Åi@Ê–±@͸Ö@ÍÓÙ@Ç©Ÿ@»½À@¨æš@“@uq–@AÂÃ@ /¤?¯h>û±ò¾Ãó4¿£l#À ÖÀFdÀ€½9Àž¨À¼“âÀÚŽjÀøª–Á zsÁ³Á)ãZÁ9 ÁG¿„ÁV ÃÁce¾Án]×Áy›Á¼=Á‡+UÁŒØþÁ’½õÁ”v,ÁŽv*Áˆ†¾Á‚¿Áz Ánd£ÁaFÁR‰|ÁC¶ŠÁ4ù”Á&* Á1«Á2zÀòÉÀÓÈÆÀµù†À˜|‹Àu…ÏÀ:À6忎Ç]¾i€?"YN?¾|í@_.@AŸ³@lÐs@ˆRr@•ï@ aÐ@§l@«Èð@®×$@®õÛ@©Íi@Ÿ¶#@ï@yG-@M*2@ý8?Õ\/?X¯ <¡ñ¿W7¿Ûû¯À&;¡À_hÀŒÑÀ©ú´ÀÇ;„ÀäÝoÁXïÁ_bÁ=Á.|Á<•5ÁJÔÕÁXéìÁd¶JÁo…|ÁzCfÁ‚KµÁ‡²ÁW¥Á“5Á•)cÁ ÜÁ‰¼ÁƒVŸÁ{KØÁoÂ:Ác›ÁU.NÁFÝ;Á8ˆ]Á)ÄÁçrÁ qÀú¨4ÀÝ+nÀ¿«À¢À…¡bÀQóïÀ?v¿Ãa6¿/BÙ>%¥ø?n'À?Ôîò@l @:–@YÕ`@r¡@‚I¾@ˆ~(@ x@ó^@©@‹êû@‚ÙŽ@l»ü@J“s@ ðG?éñ?‰><®¿ U¿«–êÀ HÀC4#À{GJÀ™qÀµþ<ÀÓ!2Àð+;Á–¾ÁKŠÁ$FÁ2nºÁ@‡øÁNuíÁ[ÀÂÁfµôÁq#ËÁ{ΟÁƒ ÁˆrÁŽ6Á“ñÁ– ƒÁ?ÁŠøÁ„h…Á}qµÁq׉Áf ÁX|ÓÁJŒUÁ<0Á-·¢Á8YÁÓ‡Á3ÓÀçwƒÀʸÎÀ®"ÌÀ’ºÀlª®À5¡¼¿ÿÖÅ¿—A¾Ú\\>™G ?{¨d?ÉÒò@eÚ@"cœ@8#`@Hc°@Sµn@\ëû@bØ@b²S@[÷@K”@5 9@»L?åäîF¾žÜ˜¿‰t¿ï’®À,´OÀa·•ÀŒ58À¨ þÀðõÀß™XÀü-³Á lâÁ¬æÁ)~Á7!=ÁDöÉÁRjÁ^ÊáÁiHGÁs£àÁ}òÁƒÜ˜Á‰>ÌÁŽßËÁ”¸uÁ—a™Á‘]Á‹‚óÁ…¼¤Áæ€Átf*Áh»\Á\/ÁNyÜÁ@_UÁ2YðÁ$\!ÁëNÁ®gÀó*ˆÀ×À»oeÀŸÜèÀ…!ÀUÜ¡À!y¿â,Ä¿‡®3¾Àü–>gÜi?H‹j?ŸÞr?Òñ]?ûKG@ ‚â@=r@ÎU@$žÈ@%2@–Ç@G@?ø‡?Äßê?ƒ"p>Ô»J¾nÁŒ¿oš¿ÖšsÀ$ÐÀNÑPÀΔÀœÀ¶–ÒÀÑî×Àí|Á£Á¨£Á ”Á.‡ÃÁ<@ÛÁI§QÁVª¸Áaì7ÁlÁv%ŽÁ€aÁ…8ÁŠiWÁþ«Á•Ì$Á˜ºDÁ’ÀÃÁŒöÙÁ‡K‹Á¢KÁwÛ„Ál>ÅÁ`JÑÁS-‘ÁE³MÁ7ßÁ)¾EÁÌ6ÁTÁ1bÀäêÀɧ4À¯@À•;úÀw\,ÀGÈQÀðæ¿ÜŒ†¿oñ¿ H¿½7¢>È2†??& ?„2 ? h?µV?Å)ó?Îy?Ϧô?óe?©÷Ø?…—?,)Š>hqɾ§ŸJ¿u_1¿Í´‘À$QÀBÏOÀt–wÀ“ÿÀ¬Ÿ¢ÀÆÅ1ÀáÀü8Á ~#ÁgÁ'ÇÁ4®ÁBÁNôÁ[?:Áe´;ÁofÍÁyS?Á±~Á†ÀÖÁŒ–Á‘ŒÁ—JLÁšKÁ”a¸ÁެƒÁ‰!ÎÁƒ™£Á{åÈÁp“‰Áe`ÁXO]ÁJöîÁ=†"Á/ø‰Á"jŠÁ×BÁMœÀóÊßÀÙÚÀ¿ÓlÀ§<À"ÎÀq>*ÀE=lÀÐe¿ðs¿®6¿e`¾ÿ¾)åª=ÊË>ï…>ìß ?'™?'là?)³V?<Ñ>ÆÒÃ=ûöã¾X’¿n¿Ùü¿×|ŒÀ#¼À>Í%Àl†ûÀm(À¥édÀ¾sôÀ×°rÀñˆ ÁשÁ)¶Á D4Á-ªÒÁ;[ÁGéöÁTŠ=Á`BÁië¡ÁszÁÁ}7AÁƒåÁˆ¬ÀÁò1Á“rÃÁ™(Áœ@ßÁ–k:ÁÊ)Á‹?Á…³˜Á€$£Áu0›ÁiÏÁ]ØmÁQ 8ÁCøÒÁ6ºsÁ)7ÀÁïÍÁàÁ&äÀê²1ÀÒ@AÀº‰ÄÀ£}ÍÀŽáÀsgFÀNÀ+§ÚÀ êr¿àv¿°½t¿‰"r¿S® ¿"ƒk¾öPþ¶ %¾šc€¾—Îx¾Ã‹8¿ ¿Iºm¿m¿½Ó8¿ö£óÀpPÀCi‡Àlà<À‹=+À¢¡À¹E±ÀÑ. Àéä÷Áe¦Á?Áü&Á( ¿Á4ÙÉÁAÔ˜ÁNn·ÁZ‹Áe.mÁn„|ÁwàæÁ€°Á…©JÁŠÃlÁûgÁ•pnÁ›ùÁž—áÁ˜ÙÁ“HxÁ¾dÁˆ8±Á‚LjÁz‘yÁod³ÁcÖãÁWŠ ÁJ§õÁ=¹ÁÁ0ØÁ$ ×Á\ìÁ ¨,ÀüÝ?Àå–®ÀÎîÀ¹v À¤—ÉÀ‘«À€%ÕÀ_Y6ÀB$÷À(VÀ4i¿ÿ;ü¿á¿Èã¿µí¿§pK¿ ™:¿Ÿ÷¿©ºá¿½›¿Ú| ÀePÀ7!À2V=ÀQ8bÀtºçÀYÀ¢1›À·œÀÍÀDÀäÙ§ÀügæÁ •ÂÁ½æÁ#9­Á/íÁ<®FÁIÁÁUŠÁ`†Áj·ˆÁsæÂÁ|éIÁƒqÁ‡ô@ÁCÁ’M Á—±VÁNÁ¡K‚Á›ž»Á–®Á{Á‹õÁ…ޝÁ€7‘Áu…Áj.]Á^5¹ÁQêñÁEQ.Á8É"Á,FÁÝáÁاÁSîÀù§]ÀäEêÀÏÌÀ¼YFÀªÕÈÀ™¤¾ÀŠ‘´Ày[êÀ`‹«ÀKÙBÀ:«LÀ,`‚À ½À Àu(À ÞÀ EŒÀL¹Àì2À(¸ÖÀ:…ªÀOÌÓÀhXéÀƒ8À“¸qÀ¥K8À¸å+ÀÍóÀâÐÀùgçÁ6ÏÁàýÁê@Á,‰Á8;ZÁDeÁPÆcÁ\}Ág‘­ÁpŸÁy‚åÁIkÁ…ݱÁЍ7Á!Á”³¡ÁšˆÁŸÀÁ¤$rÁžw]Á˜ÞÁ“g3Áü½Áˆ—aÁƒO†Á{îÁq ¥ÁeJkÁYRIÁM8GÁA.ÕÁ5 Á)/öÁÍÌÁVeÁ6ÀúïkÀçáÀÔîÀõnÀ³öŠÀ¥8pÀ˜€ÀŒí{À‚ò‘Àu([ÀgòËÀ\Á3ÀRôÀLŸËÀIJ$ÀJyÞÀMé ÀWIÀcÛÀtkóÀ„A‚À/‹À•>À­VÀ¾qÙÀк9ÀäqeÀù…HÁLÆÁWžÁÙ¸Á):ðÁ5ÞÁAñÁLÍ’ÁX–¯Ád¼ÁnS!Áw!Á¶Á„HÁˆ×¤ÁžÇÁ’x™Á—r¹Áœ¬ÃÁ¢ ÃÁ§DÁ¡`Á›òÁ–£šÁ‘@ðÁ‹ýõÁ†ÄFÁwgÁxA‚Ám ÜÁaO ÁUÍNÁIû’Á>fXÁ2üÃÁ'ÌÇÁÖfÁ¿,ÁøaÀÿ>ÀíßGÀÝk„ÀÎhçÀÀÏäÀ´0¾À©‚úÀ $nÀ˜ À‘‚cÀŒ úÀ‡bÀ„„ãÀ‚ÏÀƒTáÀ…UmÀ‰—NÀd'À—NÚÀ¡ À¬X¶À¸šÕÀÇM¬À×è_Àé7GÀü:èÁþØÁ]4ÁåiÁ'Ý¡Á3K?Á>Œ(ÁIí²ÁU© Á`ܺÁkâ}ÁufdÁ}ÂÃÁƒ*åÁ‡…„Á‹ôÁ«&Á•˜@ÁšqÁŸ¯iÁ¥ ôÁª“Á¤˜ ÁŸHhÁš™Á”¯ßÁ–ÁŠvÁ…TñÁèÁtíuÁi±Á^sõÁS ÁH9Á=NÁ27™Á'èÁF÷Á·@Á VÁ=À÷ÜÀéÖÀÜr´ÀЊÒÀÅøxÀ½^ÀµŽÀ¯&¿À©¸À¥‡æÀ¢À¡½À¡t‘À£· À§gÀ¬ê À´ÍVÀ½æ7ÀÈ2ÀÔŽœÀá¤âÀñÎûÁDsÁ /ªÁŃÁæÁ'ÐÁ2~›Á=ZåÁHx0ÁSu2Á^aÀÁiKÃÁséÁ|¢ûÁ‚wéÁ†üÁŠñ±ÁoÁ” UÁ˜íBÁö—Á£iÁ¨G³Á­ŠÁ¨!\Á¢è©Á¢0Á˜pJÁ“SHÁŽ:«Á‰5iÁ„ÏÁ}^¹Ár!ÁgýÁ\ÐLÁQÿÁGe5Á=ƒÁ3[®Á)ò™Á!ÁyÁœMÁ ñÁ0~À÷÷ÀìôÀâ„ÀÙÿáÀÒ¾(ÀÌ”ÀÇ3"ÀÃ6ÀÀ‹GÀ¿(ÏÀ¿ƒÀÁÒ}ÀÅsÅÀÊ—ðÀÒ ^ÀÚÀÀä§FÀð[ ÀüØwÁµ[ÁMÁ€*ÁšUÁ)óÁ3žÁ=I{ÁGÌêÁRfšÁ]"eÁgÊÁrV*Á|³Á‚—Á†0äÁŠdÁޤ(Á“'ÛÁ—ÄZÁœˆÁ¡šÁ¦«óÁ«Õ7Á±B-Á«ñ¸Á¦®~Á¡x°ÁœZ\Á—CÁ’?ßÁZÙÁˆXúÁƒ.ÔÁ{ÉXÁq'UÁf§ÎÁ\2ÁR%’ÁHR©Á?¹Á5Ý–Á-AbÁ%3ÁŽvÁ\FÁêÈÁ ÜïÁhÀÿJÀöçõÀï÷¼ÀéúÀäÛÀàÉ ÀÞ”£ÀÝ,ßÀÝ¢‡ÀßÀŠÀãZúÀèL†ÀïRÀ÷›üÁºEÁÒÁ K3ÁëÑÁµPÁ"ðAÁ+·ÒÁ4ÖiÁ>wËÁH9RÁRbÍÁ\œ¼Ág˜ÁqÃÁ{_ÁÁ‚ÞÁ†+®ÁŠ+#ÁŽnŸÁ’®cÁ—EÁ›¾>Á uMÁ¥\yÁª|{Á¯«dÁµÁ¥{öÁ u‚Á›x‡Á–‘gÁ‘³ÕÁŒÅîÁ‡ÓËÁ‚¯pÁ{èÁpæÁfþ3Á];xÁS½ÕÁJ¶zÁB ^Á9è‰Á1ìœÁ*¾þÁ#ÄÁÁš5ÁÝzÁ“õÁ²Á æýÁƒÙÁ“?Á,ªÀþyÀü6±Àû7žÀûÀ•ÀýÖÛÁŸÅÁÁLÁ 8NÁç‰Á"$ÁÿnÁ a#Á'¹ÇÁ/SÁ7ê¸Á@³öÁIÎ"ÁS„/Á]2cÁg&ÁpëÁz ÅÁ‚„Á†ItÁŠO*ÁŽAuÁ’gÁ–ØÙÁ›QTÁŸã7Á¤¥ÍÁ©u”Á®yéÁ³®!Á¹U{Á³ö8Á®ÄÁ©ÅeÁ¤Ó,ÁŸèbÁšþÝÁ–*ßÁ‘hŠÁŒ†¬Á‡‰:Á‚šóÁ{p¨ÁqÑXÁhi Á_l]ÁVÈKÁNi*ÁFg”Á>ëHÁ7û%Á1P¹Á+WAÁ%ÓÁ ²FÁ\ÂÁnÏÁôˆÁ!@ÁæµÁ%;Á ò?Á ˜°Á Í`Á æûÁ{ÁÚÎÁçêÁ¹,Á1&Á"7Á'ìfÁ-ûPÁ4ðÓÁüÁqÇËÁ{"¤Á‚¢Á†ˆçÁŠ˜ÁŽoCÁ’pLÁ–ïÁšÖÈÁŸtRÁ¤7cÁ¨Ü—Á­º¤Á²¹2Á·ÕðÁ½Š™Á¸D´Á³/CÁ®0Á©B×Á¤`rÁŸBÁšÔÄÁ–)KÁ‘q#ÁŒ§™Á‡ëwÁƒ*dÁ} ÎÁt ÁkMÇÁbíƒÁZàÁSÃÁL ÁE FÁ>áÁ8ð`Á3¯ÂÁ.ÔÄÁ*ƒâÁ&ÂÁ#vÁ §§Á}mÁæeÁÉOÁ…fÁ»>Áä+ÁZÁ ±¢Á#‰<Á'NŸÁ+›ÇÁ09ÂÁ5ЦÁ;„ÄÁB}ÁIEaÁPÖÁXèÇÁa‚Áj<åÁsbÁ|E3Á‚¢yÁ†õ‡Á‹?Á 1Á’ÕYÁ–Í¢ÁšéÁŸ °Á£ŸEÁ¨`Á­&ÁÁ±Þ·Á¶Ñ(Á»ùuÁÁöúÁ¼ËDÁ·°—Á²«ˆÁ­ÆJÁ¨ê[Á¤8ŒÁŸ”ÐÁ›WÁ–‚xÁ‘óÚÁSVÁˆ»äÁ„8¨Á¿8ÁwOgÁoA¤Ág…Á_ýïÁY|ÁR\­ÁLQ\ÁF®ÁAu:Á<ß?Á8¶ŒÁ5Á1èÁ/#ÇÁ-Á+„¯Á*QÁ*TµÁ*¥ Á+µÁ-©Á/ˆ®Á2.xÁ5ä'Á9ÛæÁ>q:ÁCœŽÁI)÷ÁObÊÁV=@Á]€Áe%KÁmBóÁuЯÁ~iuÁƒ}GÁ‡³³Á‹îÁúòÁ“˜Á—q#Á›aÁŸýÁ£±ûÁ¨NÁ¬³6Á±’|Á¶AØÁ»˜ÁÀ!ŽÁônÁîJƒÁè8ãÁâ&ÆÁÜÁÖ ½ÁÐ3cÁÊQNÁÄ…¨Á¾Ó°Á¹'ØÁ³ˆ™Á­íìÁ¨mýÁ¢ÚÁœõŸÁ—>Á‘‰œÁŒ ÒÁ†§ˆÁuÝÁxÖðÁoE¤ÁfkÁ^kÁV_ÁÁOWOÁI<’ÁD‰Á?³øÁÁŒLûÁ†™þÁ#´Áw«“Ám`»ÁcbÎÁZ ÁQj…ÁIfGÁB Á;€³Á5ï¼Á1]AÁ-Õ÷Á+AWÁ)ÎÆÁ)j€Á)ÃÁ*ˆeÁ,S±Á.ì Á2ŠýÁ77&Á<æ4ÁC£ÁKQÁS±ƒÁ\¦­ÁfL1Áp¯Á{ŒÁƒÁˆÙdÁŽ·ÙÁ”Å™ÁšõÆÁ¡7Á§–Á­¼’Á³zƒÁ¹<‰Á¿²ÁÅÁÁÊû¢ÁÑ”Á×+ŽÁÝ;—ÁãV‚Áê¿¢Áä~—ÁÞLìÁØ@ÁÑÿúÁËÛÀÁÅÇYÁ¿¸KÁ¹ÁÒÁ³ÔÚÁ®ÍÁ¨HÁ¢–mÁœíöÁ—P©Á‘Ñ,ÁŒ[…Á‡jÁiÿÁwwŠÁl™ÓÁb$öÁWü`ÁN.ôÁE$¶Á<¾ÞÁ5 Á.!ñÁ(ÍÁ#Q Á‡ÇÁÖUÁCÓÁÜÁÁ}Á2Á ͵Á$œ!Á)¦Á/¬Á6×IÁ>ÙÁG™™ÁQ ¥Á[[Áe‹nÁp‹@Á|$ÁƒâÅÁ‰ñ ÁÁ–[—Áœ£ŸÁ¢xÏÁ¨4»Á­ú.Á³Ý=Á¹ÈþÁ¿ÂÝÁÅÛÎÁËþäÁÒVÁØB·ÁÞy ÁææÁß»sÁÙsÁÓ9ÞÁÍÁÆÜIÁÀ±õÁº˜SÁ´¢Á®Š5Á¨—ÐÁ¢Ç¾ÁÁ—NÏÁ‘ ôÁŒ Á†‚ÃÁ-Áwk“Álé[ÁaçêÁWƒÁLΨÁBÉÖÁ9QuÁ0‹PÁ(u“Á!&4Á»íÁ öÁ…3Á·ïÁ ëÁ ž Á ÂjÁ Ó×Áß{ÁìPÁ÷jÁnÁ"ÕÁ*XÁ2´5Á<'ÁEæ©ÁP: Á[yÁfyºÁrD=Á~E¬Á…D-Á‹zÊÁ‘˜„Á—1­Áœð`Á¢¸ÂÁ¨ŸQÁ®ŽÂÁ´Áº«tÁÀÓìÁÆþ¬ÁÍ-ÁÓoyÁÙ§ÓÁáŠuÁÛ!QÁÔºÁÎjÁÈ)ÁÁðAÁ»¼`Áµ‡)Á¯f Á©K8Á£QØÁ[Á—‰ Á‘ºÁŒxÁ†T:Á€³kÁvhµÁk‚¾Á`Ô©ÁVbFÁLJ;ÁAáfÁ7ÇpÁ-ó7Á$é?Ác~Á„rÁ âUÁU¦Áö«Áÿ¹Àþn´Àý–ëÀý™·ÀÿÂÈÁ!ÁcÎÁ Ô°Á™ùÁb$ÁBmÁ'5Á0íÏÁ; ŸÁE¸tÁQ~Á\×TÁh»4ÁtÞ9Á€`Á†R¨Á‹ìÁ‘­ÆÁ—ysÁcäÁ£W‘Á©Z¹Á¯,Áµ­‹Á»ÝuÁÂTÁÈcTÁΣÁÔÿªÁÝÿÁÖ“£ÁÐ)ÁɽÓÁÃdWÁ½Á¶Ø£Á°—‰Áª\íÁ¤4ÁžÁ˜Á’¥ÁŒIÁ†sÁ€À!Áv´ÁjÉžÁ_ËãÁTêŠÁJ><Á?ßÏÁ5È?Á,Á"î]Á—ËÁÏÁ—«ÁutÀ÷6:ÀííÀç^‡Àã×ìÀâÊ^ÀâÃYÀäÛ+ÀéŸbÀðÝðÀúŠpÁG{Á ~ßÁçÜÁ\œÁ&7_Á0³|Á;ñµÁG˜¬ÁSI¡Á_>¸Ák/Áv×Á€¨=Á†m_ÁŒ<àÁ’+±Á˜"dÁž+Á¤WÊÁª‹¿Á°¼kÁ¶ÿÁ½Q§ÁÃûÁÊ€ÁÐ~îÁØÎŸÁÒ-yÁË£ýÁÅ3ßÁ¾ÅsÁ¸aoÁ²]Á«ÂþÁ¥s]ÁŸ3_Á™5Á’à}ÁŒÜÁ†âªÁ¹ÁvXrÁjñ”Á_wâÁT,tÁI/Á>S;Á3¨}Á)]ÏÁF´Á½{Á ·wÁ'Àø¶UÀë Àß–ÀÕ€ÀÍïÞÀÊ?ÀÉËÀÉpxÀËn ÀДAÀØ<ºÀâþÀïÛÀþÅÁF„ÁèRÁ]Á'Á2l Á=ùcÁI±DÁT9Á_‘þÁjͼÁv_ŠÁIÁ†ö[ÁŒí9Á’ýÁ™3jÁŸjŒÁ¥tÁ«ëžÁ²?“Á¸˜ÇÁ¿pÁÅŠ\ÁÌûÁÔŸ-ÁÍöyÁÇNÊÁÀ¹6Áº>ÒÁ³ÍÂÁ­aÁÁ§GÁ ­FÁšTœÁ” íÁÚ¿Á‡°aÁ¤öÁwNuÁk~VÁ_ÊèÁT`(ÁHáLÁ=ìÁ2’@Á'»ìÁ¶ÁÛÐÁÍ ÀþùRÀíœÀܨôÀÍÃÀÁÐÑÀ¸—À±ËøÀ­ãYÀ­,„À®›+À³3À¹dôÀÁÀËÜ'ÀÙÅ8Àée7Àû¯åÁôDÁJ0ÁZÈÁ(RÁ3$ŽÁ=ÿâÁI PÁTQWÁ_çèÁk–ÚÁw‚`Á¸ŒÁ‡ÑÁŽ «Á”E§ÁšÜÁ Ù Á§2wÁ­™Á´˜Áº tÁÁ0ÁÇΗÁÐŽeÁÉËÁÁÃVÁ¼ußÁµÔÁ¯H Á¨ÏˆÁ¢bÁ›ÿªÁ•œÁ=†ÁˆêõÁ‚µ×Áy ñÁlä/Á`ÙgÁTú!ÁI=žÁ=ÍeÁ2LlÁ&ôÁõoÁ$žÁ€¨Àø³¤ÀäÅ…ÀÒŠ«ÀÀôÀ±. À£¸ÎÀ™oðÀ’ÀކÀ.'ÀŽÂºÀ“Á7Àš°CÀ¥õ‚À²“zÀ‹ÀÓSYÀæ=zÀúÁKÁÀvÁ–¼Á'q{Á2‡ŸÁ=Ý"ÁIpGÁU+2ÁaUÁm ÒÁyNþÁ‚â¤Á‰"§ÁjjÁ•ÇÕÁœ-'Á¢¢‘Á©-áÁ¯¾Á¶Q¼Á¼ýÁÃÀëÁÌ«²ÁÅÐÌÁ¿xÁ¸BýÁ±–œÁªñ_Á¤\$ÁÔTÁ—]`Áð{ÁŠŒ-Á„+âÁ{¡¼Áo/ŽÁb¸ŠÁVŠ:ÁJlfÁ>|‘Á2±äÁ':¢Á¹.ÁXrÁXÀõÀßåEÀ˯®À¸"[À¦ßÀ•JkÀ†?Àv!ùÀe ØÀ\cÓÀZ_”À]Ø Àhž½ÀxÂ(ÀˆJÅÀ–ŠŒÀ§ÀÀ¹Y>ÀÍâÀápÀöbùÁfÁävÁûSÁ'k™Á2ø¦Á>ÅÁJ¶eÁV¦œÁbÿ`ÁoeÁ|lÁ„XsÁŠ¿ÀÁ‘1kÁ—·nÁžJAÁ¤ÜÑÁ«yŠÁ²2ÐÁ¸ýØÁ¿ËeÁÈØ(ÁÁï“Á»ÔÁ´<¾Á­tžÁ¦¸õÁ HÁ™wáÁ’älÁŒ_›Á…æÛÁ~õrÁr0mÁeqÁÁXó§ÁLhgÁ@4-Á4 @Á(QÁ,Á§àÁ&ÀózÑÀÝw˜ÀÇëÿÀ²ÚÔÀž«ÂÀ‹¦hÀsrFÀSY÷À9h®À&UþÀîÀbÚÀLZÀ)ÂÀ=TÝÀVqÀvhÇÀŒš¨À &†À´KÀÉMÐÀÞÔÀô³*Ál<ÁíØÁÁ(côÁ4R‡Á@P¨ÁL¾QÁYOvÁeëÁr¢ ÁˆÁ†AûÁŒÒ÷Á“fäÁ™ý-Á ¨¦Á§oAÁ®@ Áµ±Á»ù5ÁÅ9ÓÁ¾9åÁ·BUÁ°WuÁ©{Á¢°`Á›èÒÁ•/åÁŽ“€Á‡ûÍÁj£ÁuÔ Áhá±Á\ |ÁOEËÁB®üÁ6_Á)Ü;Á¨Á ÆÁ®pÀô*;ÀÝ%»ÀÆF…À°=õÀš½bÀ…ÖÑÀcO×À>q7À×ÿû4¿ÑHÔ¿ºýù¿´ÌA¿¾M¿ÖQÀŽÀÀ?é‚ÀfpTÀ‡( Àœ=.À±¦ÿÀÇ “ÀݾyÀô³Á ÁÁî¹Á* ¨Á6“TÁC4ƒÁOÙÕÁ\°ÃÁi¯°Áv½>Áî€Áˆ„éÁ(IÁ•â‚Áœ¶¡Á£Ž¯ÁªmªÁ±S'Á¸DÁÁ»SÁº¨ÕÁ³¡æÁ¬¦×Á¥­:ÁžÀßÁ—íoÁ‘%7ÁŠ[¿Áƒ®ÐÁz+ûÁlðÁ_ê™ÁRéIÁEùÚÁ9‘Á,s ÁÔ Á|ÿÁHdÀözÀÞz-ÀǧÀ¯ÿ¦À™•ÀƒRÀ[ˆÀ1¥§À ”›¿Ë+>¿‰.¿/¬|¾ðD¾ÓK8¿ =¿:¸¯¿ùê¿ÏwÀ “À4&~À^/gÀ„x¢Àš„­À°ª¢ÀÇ‹NÀß$€À÷DÁ’‰Áá Á ~]Á-!Á9âsÁFÝWÁSß?Á`÷æÁnrÁ{ekÁ„gµÁ‹/-Á’¯Á˜âÁŸÇ]Á¦± Á­¨ÇÁ´ªtÁ¾l¹Á·G€Á°$ÀÁ©úÁ¢²Á›Á”&Á1Á†dÁ'ÎÁq£ñÁd`[ÁW}ÁJ=Á<ýÐÁ0mÁ#eÁO‰Á ¦ÀúX^ÀáÒÀɱ{À±©À™óåÀ‚ã„ÀWØuÀ+•_ÀÀL¿¯;©¿B¢Å¾Q«>†q_?|®?MK>õ>J6¾~ý=¿K#K¿´QÀäqÀ.”‹ÀZ²zÀƒ˜ ÀšeˆÀ²MxÀÊ‚ßÀâ‘:Àû«xÁ jéÁ¿Á$ÍÁ1÷Á>äÁKZÁ•+2ÁœóÁ£rÁªŸÁ±._Á»9¡Á´Á¬ßÁ¥¸ÖÁž’âÁ—ºÁÁ‰ÁÁ‚ƒuÁwGuÁi¤‡Á\‹ÁN¡3ÁA_®Á4) Á'.Á8Á !mÁD'Àç,ôÀÍûRÀµ ÚÀœãØÀ„ØÀY÷ºÀ+£¥¿ûSò¿¢D2¿ŒD=ë³? Ë›?”^÷?Áœ?Ë ?»§?·×? »Ëh¿&e쿨o¤ÀO4À,ý§ÀZ¥ÞÀ…ªÀÀëÀ¶<ÀÀÏÈ©ÀèµìÁ@Á]‡ÁFÿÁ(k Á5µoÁC±ÁP¥»Á^&—Ák­‘ÁyrˆÁƒ¦=ÁŠ’²Á‘ïÁ˜ÁŸ—,Á¦»lÁ­ãhÁ¸@ÖÁ°üXÁ©¸fÁ¢ƒÁ›[~Á”+8ÁVÁ…ï»Á}ØÜÁoѯÁaäÝÁT6QÁF0Á9ÜÁ+ÇöÁ†æÁIUÁ'›Àî_\ÀÔ|;À»–À¡ÀÿÀˆÃ;À`9bÀ0±ÀSÄ¿£ƒ¿>9à?Ošƒ?¸©·@@K@%ŒÆ@FÕ?ýzã?²î?BÅì=Ĝ޿®¿¥MŽÀç”À1r‘ÀbâÀŠWkÀ£ÇÙÀ¼øýÀ×Àñ*`Á­Áú€Á PÁ-Ñ@Á;Y…ÁHßÿÁV„ÁdCÁrÁ€(Á†ý€ÁŽHÁ•31Áœ\JÁ£…2Áª°>ÁµbâÁ®5Á¦Î$ÁŸƒMÁ˜9ûÁ‘ÕÁ‰ÏÁ‚*ÁvèËÁhÍÐÁZÈœÁLÅÁ>÷Á1QVÁ#¢ÁGMÁüÀÀ÷hƒÀÜæUÀ À¨•TÀŽü|Àk"À9ÛÀ{.¿¬æd¿nz> 2?Z{ã?ÇA³@ ü|@5Çê@Xì@e‰€@V‰@3S»@ üq?Á@?Qß³=ö;¿ ù1¿² À à¤À=*OÀoË­À‘âÃÀ«»ÀÆ\Àà«»Àû&öÁ ÛÁˆÎÁ&ûÁ3¼ÁA`4ÁO$®Á]æÁk&Áy4!Áƒ¯ÁŠÔAÁ‘þÁ™+œÁ e Á§°ªÁ²Á„Á«\Á£ù‹Áœ£½Á•W€ÁŽ 2Á†ÀðÁÑÁp©=ÁbA_ÁSú¬ÁEîHÁ7ßPÁ)ÙÝÁ& Ác ÁÉxÀæî5ÀÌEgÀ±Ü+À—~ÉÀz>‘ÀF/ÉÀO¿Á‡¨¿<#ò=v?JfÕ?Ä^K@Ãr@=þ@gí¨@‡Yˆ@ÁÓ@†ŠQ@eGg@:ÞY@Û}?ÁêÌ??‡¼Ë瘿Kïe¿Ë]bÀοÀM¾éÀ€½tÀ›dóÀµô/ÀТæÀëœ<ÁXéÁ=Á¨!Á,Y:Á:QoÁHZãÁVgGÁdwŠÁr¦ËÁ€ƒ0Á‡¸ðÁŽòêÁ–=6Á™$Á¤þ•Á°4Á¨Æ|Á¡`èÁ™ûœÁ’–ðÁ‹=Áƒê¥Áy;ìÁj§Á\7§ÁMÉÚÁ?[?Á1 Á#/ÁäüÁúmÀòpqÀÖò)À¼$À¡ybÀ†ÝÀXý*À$1|¿ß-M¿pdY¾»¨?%ŒÑ?µá@ x^@;œØ@j×ä@‹­Á@Ž"È@Žú¤@ޏL@Š¢@i?@9“7@![?«ªõ?4ê¾Ù¿ˆ…G¿ðæ£À-]ÀaÛÀ‹µeÀ¦rÀÁDiÀÜNÀ÷áÄÁ š>Á„×Á%ŽûÁ3œdÁAºuÁOæÁ^>)Ál»ØÁ{>ëÁ„æ0ÁŒ9ÖÁ“˜öÁšþ—Á¢l!Á­ÚMÁ¦cÓÁžìFÁ—|PÁRÁˆ®ÏÁDbÁsÐ=Áe¯ÁVkÁGÐLÁ9\™Á*ë@Á‹ÁSeÁ<ÀäY­ÀÈÐÉÀ­^œÀ’ÄÀnïqÀ9VšÀ¹²¿œVH¾Ê&>Õ0?›n7@@2¼@c–¬@…Îc@‰¿‰@‹¾ß@ŒŸÂ@Œ—ð@Šsó@„6p@\k@*˜?ðZ¯?ˆÃ”>‚x ¿~t¿±«À §ÀCaYÀx«~À—wéÀ²Ò>ÀÎ,“Àé±VÁí'Á`Á5çÁ-zÚÁ;ÄúÁJ?îÁXÇäÁgIÅÁuÑÔÁ‚;ˆÁ‰ ™Á‘Á˜˜ÔÁ %Á««ÊÁ¤+Áœ²}Á•-ñÁ­3Á†:žÁ}›IÁnÀûÁ_êÁQ2œÁBƒÎÁ3×Á%?®ÁÏÁ`yÀô šÀ×Ê À»§¬ÀŸŽãÀ„×ÀQ¸Àæ9¿ÊŸ ¿@§ü=œØ?i¡â?Ý€L@"ƒB@U6l@yÆ…@ƒ´/@‡ÙÆ@Š æ@‹'@ŠãÛ@ˆ‘á@ƒ@n@o]Ä@Eã'@R?Ã_á?9ëû½î»‚¿kèA¿á yÀ&æéÀ\›3À‰±HÀ¥r^ÀÁÀÝ!\Àù™¿Á ïÁnþÁ'Í:Á6Q*ÁDÙ}ÁSf‰ÁbÇÁpÊRÁ·{Á‡bÁŽõ…Á–”/Áž6ùÁ©­“Á¢ëÁšÁ“0Á‹ƒñÁƒÿ»Áxû›ÁjªÁ[AÓÁLmüÁ=’zÁ.ÎÁ !¤Á|+Á×÷Àè¼ÙÀÌ À¯]RÀ“àÀn.RÀ6ÅÈÀYã¿“T.¾¡u$?]ð?¬¶¯@ P @?6¦@a‘!@vl|@‚V@†–=@‰¸Ì@‹ @ŠÒ5@‡€’@½)@p~&@SÕ½@*Ì4?ó0?‘f‹>œ©a¾ú²ß¿«šuÀ EÑÀBžEÀyóŒÀ˜ÀÀµ vÀÑÈÀî„UÁ “Á(TÁ"Æ,Á1dÁ@‘ÁNźÁ]®Ál·ÞÁ{ØuÁ……êÁ&pÁ”ǽÁœi Á§Ñ™Á ?Á˜¬©Á‘@Á‰‹ÐÁ‚»ÁuRÁfÁVùRÁGù{Á9âÁ*8ÁZ¯Á ƒaÀû¾\ÀÞ™xÀÁ‡ÃÀ¤ß‰ÀˆgÀXÀ À¿Ñ/±¿DÊU=‰Ð?eG’?ÚñC@ÃC@D €@^@Õ@rƒ!@€Íy@†ù6@‹#·@w©@Œ ]@ˆCÃ@K@nJ@T1x@2Nº@ Cá?¶†P?&Õ¾$¿wu¿èOàÀ,öFÀe42ÀŽgšÀ«¯ÀÈ0ÓÀåRìÁ ÁŽ>ÁHäÁ-'Á< VÁJîºÁYïÁiÁxNjÁƒÍÿÁ‹u’Á“®ÁšÆ@Á¦6NÁž˜LÁ—XÁtÙÁ‡å»Á€W Áq”»Áb‰ ÁSŠNÁD]8Á51EÁ&æÁ-çÁjoÀó`íÀÕýÐÀ¸Ø½À›ëÔÀ}í(ÀD“À äP¿©€ ¾òVØ>½õ ?”\¼?ò9î@ ñ¯@?ð]@Yëë@p'ê@í@‰H†@Žœ%@‘P@ç@‰õü@OÓ@l–¼@R5ü@2@$â?ÊAz?`‘K=Æ0‚¿7Ôe¿Ç5›À‘ÀS\ÛÀ…øªÀ¢òºÀ¿ß|ÀÜïÅÀú&’Á äiÁ¾YÁ)™©Á8ˆ¨ÁG¡ªÁVÜÁf/½Áuˆ.Á‚p_ÁгÁ‘Ê~Á™àÁ¤úÁLÄÁ•§±ÁŽØÁ†lðÁ}¯¼Án’Á_w¹ÁP^sÁAF‘Á20,Á#4Á7Á=Àì^ÀÎØVÀ±r¿À”Àn¶À5ôL¿ü’‘¿²w¾…ÖÖ?“W?¡$¼?ò&@Nt@;T@Wt@qZ}@„@C@”Xq@—VÛ@•?@ŽÜ@ƒNç@lý @OÚ@.Îe@ Ö?Ì9?mÀ>K¯ ¿ê2¿²XºÀfÓÀG§:À©ÂÀœ‘®À¹œ;ÀÖÓOÀôBvÁ Á ôÁ'¼Á6*íÁEaÖÁT²×Ád JÁshÛÁbäÁ‰ZÁÃ'Á˜{[Á¤ ÂÁœ]¿Á”±™ÁŒþ“Á…NSÁ{CŸÁkýåÁ\ÒÁMÃîÁ>¼…Á/µÁ ²yÁ²šÁ³SÀçf_ÀÉ€OÀ«Î£ÀŽ¥³ÀdæeÀ,£Ô¿é ž¿€(¢¾R@?¦’?š ý?æþl@ˆV@7âê@XV@vKœ@‰ @”-{@œ`†@ @œ¼Í@“ɬ@‡)j@p÷@N×1@*šÊ@B?À;$?_ ·>=Ü¢¿ r ¿© ýÀ .OÀ@VNÀxð€À˜×^ÀµDúÀÒvæÀð?iÁ Á;Á% Á4;°ÁC‹KÁRåÁb?VÁq™ïÁ€zkÁˆ,úÁçüÁ—ª&Á£>fÁ›ŽkÁ“åäÁŒ@eÁ„’ÁyÅÁÁjs»Á[0þÁKô#Á<¼öÁ-¿Á~LÁ•7Á·èÀãÑ=ÀÆ^jÀ©|ÅÀŒ¾ªÀ`À'¿P¿æÎ,¿e÷¾†÷Í>Ü»ú?‰„^?Öw@?»@6s3@Zʧ@~Gá@ŽÙ2@œÃ“@¦MÞ@ªŒí@§6@›¯@Œ8ë@tNÏ@NRÿ@&v–?ÿ·2?±†?BÀw=“½¶¿"+u¿¯ØÀ íYÀ? 0Àw]pÀ˜ÂÀ´g¼ÀÑ"ÀïñÁR8Á/yÁ$BÁ3}ÁBŪÁR?ÁaVÜÁp£ÇÁ€ Á‡»nÁ|Á—D;Á¢Ì2Á›Á“bÁ‹¯Áƒý,Áx¡´Ái_ÁZ8 ÁK*JÁ;ýáÁ,µSÁ‘1ÁÀÿÓÓÀâðËÀÆQëÀ©´?ÀÇÀaÉÓÀ,Öü¿ñíç¿‘Oz¾ÔfW>„F?eÈŠ?ÈÔË@$Ÿ@8Ï@a­A@„ªk@–è @¦Ó$@²Û˜@¸Eß@²û×@¥Ø@’}@z@W@O„¤@$€T?óû ? >y?ô!½´Ëz¿Lì‚¿ÆH`À ëÀE‡…À{óXÀ™“Àµq!ÀÒ¬Àï ÚÁ pÁ÷Á$½Á3>4ÁB¯ÁQèÁa@qÁp˜cÁø­Á‡µªÁvºÁ—;ÒÁ¢¼–Á›2Á“H9Á‹rÁƒÕªÁxMÏÁi*ÁYØÿÁJÌ?Á;åñÁ- žÁhÁ3ÂÁ£DÀ䦷ÀÇÇÌÀ«oÀ3ñÀkd¼À7KzÀø¿¬²Å¿)©g=1¤­?>).?Â4Æ@£C@>8@m-@‹ÀK@ Ìä@²Œ­@Àð½@ÇÈ@¿ÿ±@­T·@—e@€LÕ@Q÷*@#…?êPg?Žàq>Ї¾¡ Ò¿ƒBõ¿á»wÀ!¥ ÀRëßÀ‚Ö ÀT<À¸åKÀÕg=Àò§Áu›Á*—Á%©Á4! ÁC< ÁRe®ÁašûÁpßrÁ€GÁ‡ÔZÁ“hÁ—YÁ¡”ðÁ›‘Á“‡tÁ‹ÕÁ„'ÖÁy}ÁiŤÁZ¥ÄÁK¨'Á<Ã;Á-Þ«ÁÞÁYjÁLÀè9RÀÌé À±/rÀ–œÀy¥ÀGn‡Àç¿Ð­a¿[¾Ú½œ"E?BuÔ?ÇYA@ÎW@IÁ†@y @”L@ªy¢@¾©L@Ð*´@ÚE>@Ë’Ë@´u @œ¦Í@„Œ@VÂú@%9?åäQ?ƒŸ‘>‚¦â¾üp8¿¢ÚÀrÀ3ßÀcõ‹À‹"kÀ¤uñÀ¿,ÀÚ¿ZÀöó‘Á ÉTÁONÁ' Á6hÁDêÍÁSÙÅÁbêÁr)Á€°ÇÁˆ_‚ÁÁ—Ö(Á ÌÁ™’zÁ“'èÁŒgŸÁ„еÁz…7Ák~Á\ŽFÁM¨ýÁ>Ê!Á/ýšÁ!]äÁø…ÁêÝÀî|ãÀÓ;LÀ¸f¨ÀŸ(tÀ†`VÀZ®À)=?¿ãØø¿kÅý½0µÞ?T:Ù?Ù¼—@$ç@W¨@… ]@®N@µ4l@Ër@ß„=@ìñ`@ÔíV@½Ý@£~Œ@‰ý"@`¸@+a&?ïÕ¦?ˆ¤$>wÀ¿:û¿·rÀ’þÀEFñÀw¡!À”oÀ­]¶ÀÇ3ýÀâ‹GÀþ-PÁ ö}Á1Á)±åÁ8_¸ÁG0¡ÁVüÁeªÁt#Á©œÁ‰MQÁúÌÁ—¤Ážý Á˜tmÁ’!Á‹±ÓÁ…’Á|‹ÊÁmÁ^¾ŽÁOÿ¤ÁAg•Á2ýðÁ$ÐÁÒ}ÁÙØÀöPÉÀÛòÀ¿ìãÀ£›ÀÀ‡Á¾ÀVGÎÀÊÀ¿ÉÌR¿+Ä=>Q‡?«ï?ÿá@7ÿ@ká5@³º@©^[@Áì@ØNU@íö/@øÑ­@ßzí@Åiœ@«®¶@‘ÖÚ@n-i@8Z@¤µ?•>›¿î¿¶yÀØÀOÄÀ„ ÀžÑˆÀ¸[´ÀÑîÏÀëßÑÁ‚dÁZ|Á_|Á-lÖÁ;ª ÁJ÷ÁX¶ìÁg‚iÁvtvÁ‚Ã;Á‰¥ÄÁí™Á–_BÁžFÁ—µüÁ‘FÈÁŠð;Á„Ç|Á}¦ÇÁo¬;Á`P£ÁPõùÁA›PÁ2E‘Á# ÕÁò'Á ÌÀì…ÌÀÏR¼À²AbÀ•6´ÀpÛ’À8ÉxÀz¿–Ѿ…\?†K?¿L¦@»@Mëf@‚Yx@=í@¶Ž @Îý¦@æË€@ýÊ=A€@êãd@Ðô@µM/@š±@~Ê>@HCë@ŒÒ?´{€?gʾ¼L3¿ ×[Àù—ÀCH—À}±øÀœ ¬À¹3:ÀÖ]Àô ÁsÁÁï Á#ÄSÁ1ɇÁ?Ô¿ÁNRÁ\d¦ÁjôÞÁyšÁ‚ƒ$Áˆ±ˆÁ¥Á•pkÁöÁ—bƒÁó…ÁŠ¢ÍÁ„w¨Á{DðÁkª¼Á\gÁL–‘Á=!qÁ-ÀÊÁf!Á xÀÿbðÀàä'ÀÂЪÀ¥2‡À‡ÑÀU€MÀ^º¿ÃÓ3¿(ç;>Ué?Š%Q?ù¡u@3æË@lÇ@’É@ª•k@Ä‘÷@݉û@õ¡ÄAžyA®Ž@ö°@Ü3ï@Áo‰@¦= @ŠÞ¥@_’{@'„m?ßó³?`B¾;/gÄ¿^>†¿á %À*îsÀe&(À®[À­R¥ÀË0mÀérÁÇÁYÁ"ª-Á2[ÁAuYÁPõŒÁ`‚˜Ál;8ÁwÄ ÁáåÁˆˆÁŽQÁ”È|ÁñÛÁ—ePÁñçÁŠ ëÁƒÙ#ÁxÛÁhX|ÁX¬ÁHÿ¾Á9TæÁ)µnÁ%ÅÁ ŸbÀöb8À׬À¸÷>ÀšAëÀwk[À;ÈÀ¨¿Œû«¾E²?4-Ê?ÉPÚ@=|@SÒ-@…@ W @»X…@Ôeb@íÂ8A5¥AózA;AV¹@éÐ@ÎÙ@³WY@—ºƒ@y ñ@C\¼@ %'?¦yŸ>Ø9¾í¤¿¿¯Ë»À#ÀM8tÀ„Î]À£rlÀ£ÀàªhÀÿQ}Á„Á›ßÁ.0 Á=ÏœÁMtÁ]"IÁkï»ÁwqÁ£Á‡ÃÔÁŽúÁ”|§ÁžG-Á—¾QÁ‘Z1ÁŠUòÁ‚lVÁu DÁeDàÁU†òÁEÏ#Á6¶Á&oÀÁÃaÁÀîÕFÀσ¤À°^GÀ‘QÀe¾À'¯¿Ôˆé¿4°@>_Ù ?‘ D@§W@;òI@sŠ©@•ì@°¨ù@Ë$ÿ@æA@ÿAA A/kA”ÁA @R@øx@Üú0@ÁÞ¬@§'r@‹­ƒ@`ð@(µž?àØ¹?W¾î½”Ý­¿€ÀÞ¿û+ôÀ:Ë…ÀxÀšœaÀ¹tÀØŒÉÀ÷ϯÁ šnÁY"Á+ Á:î¥ÁJÁ²ÁZ˜­ÁjrÊÁwçÁÌÁ‡ÙŸÁŽ~Á”‚yÁžâêÁ˜e¥Á‘PŒÁ‰^ÁkqÁrñÃÁc ²ÁS'±ÁCCÝÁ3dÚÁ#ŒEÁ¼/Á÷oÀèvEÀÉ`À©µKÀŠ\ÀVžÀV!¿±Ä¾ÖÒÚ? A&?¿õÜ@š@W‡@ˆÔç@¥jB@Á6s@Üa2@ö¿TA›éA0‹A!Š—A0ÁAiA½Ú@ì¡C@ÑÇB@¶³˜@›4ì@~f@D] @ !ä?˜‘…>oW˜¿9w>¿×b1À)šåÀh}òÀ“é&À³¥`ÀÓk8Àó6êÁ ƒ7ÁlJÁ)VOÁ9AÁI,JÁYöÁi£ÁxóµÁ‚P³ÁˆX[ÁŽ‘­Á”î÷ÁŸÛÔÁ˜e¤Áq Áˆ|îÁ€‰Áq+ƒÁaEäÁQacÁA{eÁ1•ëÁ!°rÁÊøÁå~Àä ÀÄ5À¤j#À„¢¦ÀIíwÀ ºO¿—N¾Qb°?FmE?à™›@.ø~@lϬ@•(@³0@ÐV#@ìÛ`A-^AdüAhA*ùkA&kþA"áA Ã@üóV@áãá@Åã8@©'@‹e@XöS@vÀ?¶zž>ÛC¶¿¼¤¿È’À$iÀcö À‘ã‡À±½åÀјDÀñr¢Á¦€Á“ÁÁ(ƒ[Á8uÈÁHjYÁX`–ÁhX&ÁxP²Áƒ7‰Á‰%}ÁGÁ••ÂÁŸFËÁ—Á:ÁÈÁ‡ÐÂÁ³™ÁoÇÍÁ_ÜÛÁOñéÁ@öÁ0Á 1ÁF ÁXÍÀàÑ”ÀÀï½À¡ ÅÀ+åÀB¢ŽÀ 7¿†è ½wšf?nÝô?öšÇ@:º @yõ @œ˜@»÷Þ@ÛPœ@ú<ÚA êÆA&?A'w.A4gñA.¶"A!}A0¼A_@îÉs@ÎÞ@®òÂ@i@^8!@ap?½}>õ j¿Š¿ÁòªÀ ÐÀ`¦·À>´À°* ÀÐ Àð†ÁüeÁöÄÁ'ñ‰Á7ì—ÁGçÝÁWãPÁgÞåÁwÚ–Áƒë/ÁŠEžÁZçÁ––§Áº8Á—=—ÁH‹Á‡S®Á~¾ÁnÍüÁ^Ø…ÁNãÁ>íÁ.ø)ÁµÁ BÀþ/œÀÞF¥À¾dÀž‰¢À}S6À=“)¿û¦6¿xL4<Ö€g?‚Ú@-@@î_@€Y'@ ;@À@ßÿ@ÿáAØcA§#A/uâA=•A5–A%ƽAøðA, @ì£Ö@ÌÇk@¬ë@•@ZdU@¬ë?µð+>Úø¿Æ]¿ÈLÛÀ#ÛDÀc(À‘¢¡À±};ÀÑWÞÀñ1íÁLÁn•Á(_iÁ8RÞÁHHRÁX?UÁh7”Áx0ÇÁ„Á‹ØÁ‘ÎçÁ—ò0ÁœJÁ–f×Á Á‡ œÁ~,/Án?'Á^R ÁNeÁ>xÁ.‹“Á™Á¦VÀýgÀ݇À½›õÀ¶bÀ{¡ À;Ö{¿ø¬¿qÄ=b¼ú?†²T@/i@C§@mó@¡Y@ÁD1@á/lA Aˆ>A ‚ÆA0~CA?ˆdA1nJA"dAç#Ae{@ç›Â@È_@¨Žü@‰2@RÖÒ@£??¨ßX>©àÉ¿(â¿Óv¼À)t4Ài- À”rðÀ´NòÀÔ)]ÀôÈÁ ïÁÛcÁ)¿ëÁ9¤tÁIˆüÁYm„ÁiRPÁy9çÁ„’6ÁŒˆ±Á“†BÁ™›Á›:˜Á•L·ÁŽåLÁ†òÁ}ýäÁnKÁ^3ÁNLæÁ>f±Á.€|ÁšHÁ´Àý›ÄÀÝÅÀ½Ü.ÀõiÀ|$ÝÀ/ ¿Pp“¿æZéÀ2?uÀqi¯À˜N¡À·èjÀׂ4À÷#$Á kíÁMoÁ+4Á;žÁK>ÁZçÁjËpÁz¯ùÁ…JAÁ<…Á“Ç¡Á™”Ášg×Á”‹ëÁŽÆûÁ‡úÁ~^6Án‡õÁ^±´ÁNÙ¦Á>üNÁ/÷ÁAŸÁdHÀÿ âÀßN_À¿6ÀŸ¯DÀìâÀ@²`Àz°¿„†½BÔ-?o¸ ?õÁ}@9g)@wí“@›9ÿ@º}4@Ùx±@ø2xA T³A2AAÎA!I€A¬Aw‹AGÏ@ð´Ý@Ôu@·Kü@™9@u6&@7ʼ?óÅû?oqA½ ð=¿€2Ó¿ü[ÔÀ=#&À|/íÀžZÀ½$½ÀܬVÀü5=Á ßÁ¤Á-laÁ=7„ÁMUÁ\ÑÁl£¨Á|{Á†)¥ÁL.Á’Ø’Á˜ˆ,Á™¨ÁÁ“ÜCÁŽáÁ‡OÁ~×EÁoÁ_NõÁOŽtÁ?ÇÕÁ/øiÁ -ëÁiöÁ®óÀá÷€À‘•À£+ªÀƒÅ¿ÀH½bÀ Ê{¿–P^¾LHu?FE÷?ßÏ@.=ˆ@kÆ@”~³@²´8@дÏ@î pA™ìA EÒAÇCA½A\ûA V£@ú¢@àžØ@Åi÷@©†ç@Œ¹ˆ@_Ö@$“R?Ïr?+zム˜¿ŸúUÀ ý!ÀLÎÀ…ìÀ£ûÀÀÂÿÐÀâ>ËÁÕÁ—QÁ Z‚Á0´Á?àùÁO¥lÁ_iàÁo.TÁ~òÇÁ‡['ÁŒ¦µÁ’ ùÁ—ÔšÁ™>ÚÁ“s+ÁÆUÁ‡¬oÁ¼¼Áp(ìÁ`™ÉÁP÷ƒÁAU=Á1¨kÁ!ïÆÁ8XÁˆŒÀåÈ¢ÀÆ¢9À§œpÀˆ’ÑÀRð¹À»Ð¿­ ̾Ĉž?¢¥?ÂK(@"@ZÕ@Š˜ú@§ªª@ÃK@ÜöŠ@ð9¾@ú°éAIYA1÷A#@úÊ@æP@Îaú@´±$@š @|ˆ @DB4@ ¥ñ?¢]>¹¿òÓ¿Å<ÇÀx¯À\X€ÀŒýuÀ«ëgÀÊî ÀéñöÁxüÁõfÁ#wgÁ3 \ÁB³„ÁRfBÁb"õÁqåØÁ€Ô…Á‡ÝÁŒXÒÁ‘ÖÁ—ŒvÁ™?ŠÁ“auÁ™qÁ‡ÄÐÁ€‘™ÁqÀrÁb`OÁRéHÁCI¢Á3¶ãÁ$)jÁ›ñÁAÀë&öÀÌj!À­¤óÀ޶GÀ_‘}À"£¿Ì€;¿'rî>—ÿ¾ì¿¿±füÀàÕÀLœÀƒ[À £À¾»ÀÝ ÓÀû„ŠÁ ÿ<Á<ŸÁ+…½Á:ß#ÁJI)ÁYÀGÁiAâÁxÌÁ‚yöÁ‡ÅÁmÁ’u¬Á˜#xÁ™½ËÁ“Ò‘ÁŽ qÁˆR‚Á‚K%Áu¢3ÁfÈ‚ÁW»ÁH„ Á9]ŸÁ*/#Á Á ÐøÀùP‘ÀÛ#¡À½&ìÀŸ„oÀõ¬ÀHÃ=À á%¿ªê¬¾éê|>×~ì?Ÿ¼@B8@1÷@\£@€Z(@Ž0+@˜…á@Ÿ]@@£ó@§+d@§-Š@¢0e@˜Ñ@‰+±@m8Â@A ¥@HX?Ác°?3C‰¾ 4¿zò_¿í ÃÀ.K“Àg9À£ÈÀ­·ËÀʉ9ÀçÜóÁâÁñ Á!Á0MUÁ?ŠLÁNÈ÷Á^þÁm`~Á{2ëÁƒ ÁˆZ¾ÁÁ’ùÁ˜Ÿ)ÁšG¬Á”W™ÁŽ˜PÁˆæ0ÁƒpÁxUxÁiÀÁZ÷åÁKÿÏÁ<â4Á-Ä•ÁÇ7Áó÷Á'gÀä”\ÀÆß–À©‚ÍÀŒÍVÀ`ÐÀ(tB¿áw¿i«½Ô–á?.èµ?´ìx@*N@*†@IÙ@bßk@t¤»@€Â·@…Û@ˆë@ˆ=ò@ƒõ£@v (@\Ú@<o@SË?Ð[s?b…\> *¿.}¿ÀFÀ"eÀLàñÀ‚]aÀžC>Àº¯ëÀ×´ðÀôº$ÁóßÁ–ÅÁ&p$Á5u$ÁD„•ÁSžŽÁb·‰ÁqVŽÁ} tÁƒÈÏÁ‰³ÁŽJæÁ“µÁ™XŠÁ›0ÞÁ•JÁ”ÄÁ‰êÁ„ çÁ{d&ÁmFÕÁ^»`ÁOßLÁA HÁ2KhÁ#†üÁ¹)Á¾Àï!ðÀÒ„EÀ¶©À™Ã·À|pÊÀEÏîÀ\~¿¹è¥¿-Ë>=@Üë?7Úr?©e?ìU@»@'µÀ@83J@DA@L…e@Q¶X@Rs@Js$@;¼Û@%Yx@X±?È'(?m»L>tìÒ¾þž~¿¡H¤Àà!À7à‚Àm5ôÀ‘: À­*ƒÀÉ?ßÀå'gÁÏÈÁPpÁÛdÁ,|SÁ;#MÁIõÄÁXÞfÁg6’Átã«Á‚îÁ„ðÍÁ‰ëÚÁ»Á”|-ÁšdÁœ{@Á–¡ðÁâ“Á‹0Á…RÑÁ~ÈßÁqXÁb«÷ÁT@^ÁEã›Á73¶Á(¼ƒÁ](Á ò ÀûbÊÀß;YÀÃrÉÀ¨8fÀN¢ÀeTÀ3&7À®Ñ¿©“¿'¶M½Ì^?wš?|ÑŸ?°ùÖ?Ù·>?÷·@êÏ@Õ@Õã@sò@ ¥ö?ÿΑ?×gg?¥ô$?J¥ >B÷;¾ë™$¿“ >¿ð‘íÀ)£À[&À‡ÀÈÀ¢"ÕÀ¼‘À×ÌÀóäŽÁºÁý(Á$)5Á2ŸCÁA$ÓÁO¤aÁ^ÊÁkÉwÁwþ2Á#yÁ†'ÖÁ‹òÁ24Á•JÁ›({Á߃Á˜ìÁ’ZÁŒ£3Á†ê™ÁÍÁuEÁgDËÁYLâÁJôVÁ<šúÁ.\«Á C[ÁJ˜ÁxÀí:×ÀÒ8§À·”LÀ{öÀ…OÀYÛ„À,bÀ·Í¿±)(¿R“¾£¢ô=õ¢g>ô:û?E+ ?|¹G?“?¢ãý?¬$ý?­oë?¡þ•?ˆ]¶?Gøá>× T¼£>|¿–¡¿—iZ¿ìTÀ"føÀP½ìÀ€ÆiÀ™MÊÀ³D ÀÍ™^ÀèµÁeÁ?ÚÁOMÁ+$³Á9PÁGTÁUlÑÁc]ÁpšÝÁ{š•Á‚­]Á‡©KÁŒ«²Á‘¿ Á— Áœ™ÁŸeÔÁ™®ÁÁ”!®ÁŽ!Áˆá…Áƒ!ØÁz+wÁl±3Á^·°ÁPž¡ÁBÌÔÁ4È$Á&ñÀÁ*ÜÁ Œ(Àü§ÀâŽúÀÈtúÀ¯¿xÀ˜QÀ²IÀW9ÁÀ/žLÀ ^¶¿ÏŸ¿–P~¿E'à¾à ݾ.z}=åM>B/¼>¡»;>Â!9>ÉV†>¢Äó>fÞ¾¡X¾ñÙ]¿a†²¿¯YU¿õÎßÀ#³ŽÀMðÚÀzU(À”GÈÀ­€ÀÅhŠÀÞǬÀù ËÁ Ê}ÁÿÛÁ$ßÁ2@ƒÁ?öÁMÚÁ[Ç*Ái4kÁuŸ:Á†ôÁ„rÁ‰„ÀÁŽÁ“£QÁ˜ìcÁžl=Á¡K¼Á›¦Á–Á‘ÁŠöLÁ…dÁ#bÁroÁdŸ¤ÁWÁIg×Á;±wÁ.!Á —ËÁo{ÁqvÀó[òÀÚ¬_ÀõaÀ­,ZÀ–ðÝÀƒNŸÀ`(äÀ=GÌÀ4#Àñ.¿Ôf¿¬þq¿Á ¿jÉ5¿BÃo¿#ſϿpº¿$@¿OçR¿‡]Q¿¯¯¢¿ßÝîÀ < À-Ö¾ÀRšqÀ{ºHÀ’ï…À©5ÓÀÀZSÀØÅcÀñ¢ Á>ÃÁ)$Á:†Á,QÁ9·ÁG)½ÁT¢Áb7ZÁoÁzºÁûÂÁ†» Á‹ŒÐÁVÁ•žöÁšá(Á ]kÁ£GÁû¢Á˜pšÁ’æôÁhMÁ‡à™Á‚5œÁx5ÏÁk'PÁ]Ç@ÁP? ÁBãÉÁ5´ßÁ(˜›ÁÁÖÁHÁÀîÎIÀØ’tÀÂmwÀ®@ìÀ›6ÞÀ‰\‡ÀqmÍÀT±KÀ:«vÀ$]ÂÀŠÀ¼ô¿îCÁ¿Û€~¿Ìo3¿ÅËñ¿Ã©V¿Í¿àÕð¿ýОÀ^XÀ'ä¡ÀBzÀ`àÚÀ‚"À•2|À©àÀ¾æÂÀÕbšÀìƒZÁ@Á¯ÁùVÁ'°mÁ40ÁA¯ ÁNåUÁ[è|Áhý›ÁuWÚÁ±MÁ„vVÁ‰ ŽÁÀ™Á’¹ÈÁ—åúÁ¬Á¢‰UÁ¦/‘Á ¢fÁ›ÏÁ•›œÁ)6ÁŠ¿vÁ…"[Á~ÈÁqÒÁÁdºRÁW§xÁJÏÚÁ>ÌÁ13‡Á$Ç¡ÁÓ Á ïÁ¸ýÀíÝïÀÙ+cÀÆMËÀ³Õ,À£1ÈÀ“³,À…´_Às•hÀ^Þ8ÀMSÀ>ññÀ3‘sÀ*ÕaÀ#yVÀ G–À;PÀ#àËÀ,ÜÀ:}ñÀL >ÀaA ÀyâõÀŠ´šÀ›ž£À­f¹ÀÁtÀÕÛ†ÀêáþÁÉ÷Á ZOÁûÁ$dçÁ0¬øÁ==bÁJ#ÁVÂÁc¹üÁp<Á{Ò—Á‚µ@Á‡>Á‹¾‹ÁZ+Á•= ÁšKèÁŸupÁ¤ÑÝÁ©MÁ£eéÁãŒÁ˜pìÁ“qÁ²¬ÁˆSUÁ‚˜‹ÁxúuÁl`7Á_¿nÁS#+ÁFw-Á:‡Á.;SÁ"¡©Á>{Á °ÏÁ)gÀðù«ÀÞˆÀÍ}çÀ½HîÀ®çÀ¡ç¾À–IHÀŒd›À„RÀ{]AÀpC×Àg5qÀ`E9À]—"À\¢Àa1¤ÀiÆîÀvŸ…ÀƒPŒÀM+À˜Õ¹À¦FOÀµ=0ÀÆáêÀØÛÀìþlÁÙÁ VçÁ “Á"<™Á-ÔìÁ9øGÁFTÏÁR~=Á^þÌÁklZÁw¦QÁ[ÍÁ…ÀBÁŠ!ðÁޝÁ“IŠÁ˜ÁœùnÁ¢áÁ§MFÁ«ÞFÁ¦YmÁ òÁ›ÁÁ–1²ÁídÁ‹•9Á† ©Á€&ÙÁt ÀÁgí Á[˜\ÁOo¡ÁC±ëÁ82BÁ,Æ¥Á"¿ÁÕÛÁ Ñ1Á¡ÛÀ÷Û–Àç*­ÀØ.ÀÊReÀ½ýiÀ³6MÀ©Ñ0À¡ç’À›“êÀ–DqÀ‘À#ÀŽžîÀK¨À ÀàÀ“;ýÀ™ÙÀ ŠŒÀªOÕÀµjäÀÁëzÀÐ;ÀàG»ÀòÄÁ3æÁ M•Á¹ÛÁ!;xÁ,tüÁ8”ÁC’QÁOzÜÁ[—ŽÁg°áÁs‰‹ÁFÝÁ„´!Á‰³Á[QÁ‘½Á–FÖÁ›ÞÁŸ÷šÁ¤ï‹ÁªÏÁ®å›Á©‡ÝÁ¤<×Ážß.Á™®€Á”yµÁ0ÅÁ‰ÉzÁ„šÁ|qBÁpŸÁdÁ&ÁYÖÁM®ÛÁBGÒÁ7{NÁ-QÊÁ#M¤ÁàŸÁëÁ™¿ÁïçÀó0`ÀæFÀÚM{ÀÐòÀÇPîÀ¿µpÀ¹y3À´l À¯í!À¬ÿÜÀ«À«§ À­oçÀ±u€À¶­êÀ¾<~ÀÇ`ÀѵÈÀݰuÀëhÀúsÁ·áÁrÞÁô=Á"ÆÁ,š™Á7 ÁBDIÁM·CÁYÁd±½ÁpxÁ|-:Áƒ®VÁˆE•ÁŒm§ÁªòÁ•FÁ™‡wÁž>Á£/Á¨-UÁ­E6Á²:žÁ¬÷qÁ§©›Á¢eÁN"Á˜2¬Á“.Á±¬Áˆ Á‚ÃÁy^Án‰ÁbçÇÁW¾0ÁLÕ’ÁB¡eÁ8ѨÁ/ØÁ&.hÁ£×Á¤ÆÁ+ÁXFÁÎÀ÷®Àí gÀäYÀÝYÀ×e±ÀÒ6FÀÎ ºÀË4lÀÉÈÀÊL ÀËвÀϧnÀÔ™VÀÛÙÀäUÕÀîOÑÀùú¯Á.2Á |KÁ†¼Á•Á$ Á-µMÁ7ÖrÁBRÌÁLܨÁWÏ•Ác-fÁntœÁy°fÁ‚`ZÁ‡º­Á‹äàÁ ûÁ”8´Á˜•3ÁmÁ¡»Á¦˜¤Á«¥"Á°¹ ÁµÚ'Á°£ŠÁ«^wÁ¦5æÁ¡IÁœáÁ—’Á‘ÎJÁŒhSÁ†ï³ÁjqÁwë`Ám+Áb7ÁWÓ¬ÁNPÁDnØÁ;B Á2¸ÃÁ*lZÁ"Ý*Á– Á0-ÁœÁ ÍÁ"ÁéØÀúâðÀõ ãÀïéÅÀì,ØÀéinÀç÷‚ÀèftÀê Àíš3ÀòÀù`0Á°MÁ–ëÁ ÄÁ#œÁ½ÈÁ}íÁ'Ð9Á0sÅÁ9¿áÁCwƒÁM{:ÁWÆ¥ÁbuÙÁmPëÁxFÇÁüÁ†ëIÁ‹ÁÿÁ¹âÁ“à,Á˜6Áœ]ºÁ åùÁ¥ˆ"ÁªJ Á¯HMÁ´ihÁ¹²WÁ´mÎÁ¯>·Áª#ÝÁ¥®Á ®Á›2Á–%åÁòÁ‹^Á†A#Á€èéÁwO&ÁmÄÁc&tÁYªÒÁPdÒÁGÂ1Á?WÑÁ7—Á0çÁ)<1Á#ïÁPÜÁìÁ‹dÁ¡Á 3ÈÁ b¿ÁéÁïÁÇPÁ!ÁL´Á@LÁÎIÁEÁÁ c­Á^ýÁ‚ÁOÁ†Á%]ÚÁ,„¶Á4¿üÁ=!ŸÁEóÉÁOSþÁXóHÁbïkÁmCÊÁwÆÁ"áÁ†Y3Á‹‰«ÁÍÕÁ“ØÔÁ—ázÁœ3uÁ u›Á¤âšÁ©Œ…Á®EÁ³'XÁ¸@»Á½¥¥Á¸aqÁ³LÀÁ®IÁ©NOÁ¤i¸ÁŸŠ#Áš˜)Á•¦ŸÁd„Á‹5•Á† Á_Áx1»Án£àÁewGÁ\”ÓÁT!?ÁL&ÑÁD£õÁ=kpÁ6ønÁ0×Á+x Á&L-Á!ü¼Á%³ÁÜ’Á=ÁÀsÁÑËÁÇ®Á#–ÁKïÁIMÁÎZÁ3xÁHÁýhÁ"pxÁ'c~Á-½Á3:àÁ9׈ÁA‡2ÁIÊHÁR=8Á[<ëÁd–ÁnX½ÁxñÁ+:Á†,µÁ‹ •ÁïNÁ”$Á—úHÁ›ò Á !ÑÁ¤™SÁ©%“Á­¹Á²|_Á·JåÁ¼GâÁÁ½ìÁ¼–Á·›óÁ²©»Á­À¶Á¨Ö¸Á¤ŸÁŸBBÁšS½Á•J•ÁNóÁ‹\åÁ†€dÁ·„ÁzA’ÁqgÁhætÁ`ØëÁY¤ÁQάÁJÝÂÁD°Á>ÔöÁ9„%Á4Ÿ\Á0jVÁ,À¿Á)ŽnÁ&·ãÁ$‡KÁ"µôÁ!¿îÁ!&Á!U\Á"V5Á#ÄïÁ&¸Á(ØôÁ,ŸÁ0ØôÁ5ºûÁ;‡ÁA ™ÁGiZÁN˜aÁVpÁ^§ØÁgXÆÁp>„Áy îÁ¯âÁ†ÞÁ‹TÈÁá¶Á”cüÁ˜H±Áœ%»Á .CÁ¤H^Á¨£ÊÁ­AÇÁ²†Á¶±—Á»‰aÁÀŽOÁÆlÁÁÁ¼8Á·+Á²7áÁ­gÕÁ¨®jÁ¤õÁŸ8Áša×Á•—ÁÂxÁŒ ÕÁ‡v¶ÁƒpÁ}‹±ÁudGÁmiýÁfFÁ_|ÁXsfÁRh>ÁLÉMÁGcÁCŠÁ>ćÁ;:Á8 Á5dÁ3@`Á1›sÁ0˜AÁ0(Á0TÁ1]~Á2¸2Á5 Á7›”Á;:ÎÁ?AªÁCèÁI+ÁN×£ÁUrÁ[ßbÁcrÁk:¸Ás•—Á|2 Á‚ŒÁ‡NjÁ‹è'Áy5Á”ÉnÁ˜ÿïÁœÂÁ ‘¯Á¤—(Á¨µ¿Á¬ôÒÁ±vÁ¶4ÃÁºþæÁ¿µÁÄ¡¼ÁòKÁìbIÁæŠ(ÁàÎÑÁÚîÁÔü¢ÁÏåÁÉ6ÄÁÃm…Á½¬ƒÁ¸ûÁ²q8Á¬¼LÁ§'.Á¡-HÁ›3õÁ•j“ÁÿÁŠ!#Á„¥Á~ÁÁt’.Ájá&ÁaÐðÁYpMÁQ‚“ÁJNÑÁD$ÛÁ>ÐFÁ:dÁ6ØÝÁ4šÁ3a=Á2þmÁ3W"Á3ßTÁ5luÁ7áÁ;PèÁ?ÛPÁEižÁKÞøÁSRyÁ[W{Ád'gÁm“×Áw—éÁ€ø¾Á†j±ÁŒ§Á‘îqÁ—ßÞÁûÁ¤.¯ÁªyúÁ°æÁ·IÁ½:ÁÃ#ËÁÉPÕÁÏ&ZÁÔøÁÚÌÑÁà[FÁåÿüÁí£ÁçƒÁáöÁÛ³¬ÁÕ¾tÁÏÅsÁÉÒ<ÁÃçéÁ¾AÁ¸A3Á²ƒ?Á¬ÞèÁ§JÓÁ¡¼ØÁœ8AÁ–"FÁ%„ÁŠ\ÐÁ„³ÐÁ~4…ÁsKÁhÕFÁ^ÂVÁU8ÒÁLtãÁDA¦Á<¦¾Á6úÁ0_¤Á+¸GÁ'ôúÁ%ˆcÁ$"ðÁ#º5Á$+xÁ$À]Á&c£Á(üÁ,·ÚÁ1‡ÀÁ7gËÁ>V÷ÁF(ÀÁN¦˜ÁWÔÉÁa´‰ÁkÿSÁvÏHÁ‘Á†æ­ÁŒÖrÁ’øÁ™,¿ÁŸ€…Á¥í2Á¬îÁ²=Á¸:ÆÁ¾>šÁÄ;ÁÉâ,ÁϺ ÁÕ¬ÁÛw¬Áá;|ÁèËÄÁâ¾—ÁÜ¿áÁÖÁxÁЩ9ÁÊŸ½ÁÄFÁ¾©wÁ¸¸ðÁ²ÚJÁ­ºÁ§Z+Á¡¸ÊÁœ$ÔÁ– ©Á‘&øÁ‹ðÁ…"&Á~´ÁsTaÁhCÁ]l·ÁSÁI¾Á?ÉÜÁ7HoÁ/a›Á(@Á":ÁMÁJaÁ¢ÈÁ EÁyÁ¬ÁÈÁŒêÁOÔÁWWÁ# Á)À?Á1/ñÁ9jÁBIGÁKùžÁV1|Á`â€ÁlïÁw΋ÁÙ;Áˆ+ÁŽ7Á””Á›âÁ¡;~Á§8vÁ­63Á³¦Á¸ò@Á¾ÌKÁÄ«ÉÁÊ¡gÁОhÁÖ©ÁÜœÁä:{ÁÞ%Á×ù3ÁÑÍÍÁˬÁÅŽhÁ¿9Á¹v¯Á³€ÃÁ­‹Á§¬¢Á¡èQÁœ-ÐÁ–èÁþøÁ‹„ÒÁ† ¬Á€þÁtY°ÁhÌQÁ]]¯ÁRd ÁG¹˜Á=yÎÁ3œgÁ*¨{Á"iÁå™ÁfxÁþÁ ÝXÁï Á'NÁµŸÁéÁðÜÁñeÁ îÁÁ˜ÇÁ‘ôÁ‹õ*Á† „Á€0UÁu âÁi½æÁ^¶pÁSµhÁHÒÁ>/ƒÁ3^wÁ'äpÁœõÁê^ÁáiÀü©UÀëIÓÀÚøÌÀͶAÀÃAjÀ»¨íÀ·y÷À¶rÊÀ¶]ÆÀ¸½GÀ¾IoÀÆ ŸÀÑ(ñÀÞÕKÀï5éÁöÁ üÁÆ}Á!NlÁ- Á9 ¬ÁEl‰ÁQÄxÁ]åÁiŒÁtسÁ€4Á†|ÁŒÁ’"Á˜-œÁžH–Á¤jéÁª§ÁÁ°Ý*Á·1qÁ½ ŠÁÄáÁÊŒœÁÓ(?ÁÌ„{ÁÅß7Á¿D‹Á¸Å(Á²[ËÁ«ò§Á¥ ÌÁŸcÁ™-–Á“¢ÁŒÞãÁ†Ê³Á€ÀÁu”Áiã–Á^~•ÁS1—ÁHêÁ=úÁ28GÁ' BÁQÁ§ñÁ´Àúp­Àæ¤LÀÔ˜iÀÃþ Àµc)À©ërÀ¡¯ÀÀlÀœ$fÀœgÀž³À¤œzÀ­QÀ¹0ÀÇÇÀÙ«dÀìù3Áá]Á ( ÁÆjÁ#”ÓÁ/¨ìÁ;ÊÈÁG´¢ÁRÿòÁ^RÁiæ7Áu¸Á€Ì?Á†àÑÁõÁ“'šÁ™V[ÁŸœEÁ¥ÛÁ¬;ìÁ²± Á¹%§Á¿®±ÁÆRaÁÏSÁÈVÑÁÁ¨Á»“Á´\ÈÁ­ÐëÁ§bDÁ ø$ÁššáÁ”VUÁŽ_Á‡åqÁ´VÁw?žÁkuÁ_(ˆÁSf‹ÁGð´Á<¢ÈÁ1ƒdÁ&†‹Áž¸ÁlÁÇÁÀùÁÀækÀÑëÀ¿UÀ­óeÀŸ!—À’ŒCÀŠBöÀ…sÀ„:À„º´À‡?#À±À– À£ÄÀ²W Àľ°ÀØ÷KÀîhÁœæÁ+sÁÿHÁ%áXÁ1( Á+ÁÄaÁ½¹Á¶Ð¶Á°&ÙÁ©~GÁ¢å¤ÁœmÁ–‡Á˜iÁ‰O3ÁƒÁy’SÁm"Á`ÛÁT£aÁH¹ Á<éSÁ1f‚Á& ùÁéßÁïÁ‚ÀõäÀà+ÀÌÛÀ¹ªtÀ¦æÓÀ–…ÇÀ‡ÃÀw¨¿Àg‹¤À]6ãÀZ¼À^^;ÀcÒÀmôÛÀžÀ‡ËÀ@ÀÀ°ŸkÀÄøÿÀÛÃÀñàÿÁh|Á¼³ÁžkÁ%ÖÁ1CíÁ<êDÁHÂáÁT»ÁaÉÁmi¬ÁyÉÃÁƒ/YÁ‰}ÁÔÁ–J"ÁœÍùÁ£Z†Á©þêÁ°¿*Á·‘µÁ¾`üÁÇnGÁÀ†DÁ¹©°Á²Î5Á¬ˆÁ¥N³Áž¦!Á˜xÁ‘yóÁ‹ Á„š”Á||àÁoÝ"ÁcHÀÁVÁšÁJvšÁ>6Á2F Á&l6Áá›ÁxìÁPYÀò©GÀÜÙ±ÀÇÿÀ³£yÀŸèwÀŒî(Àu·…ÀU² À<Þ”À(ûnÀ½BÀ ÙÀ£WÀ'î¬À:$ÌÀR.MÀpS>Àˆ2ÓÀœAòÀ°Ì:ÀƃÍÀܬÆÀòzAÁÁA¬Áº—Á&nhÁ2TÁ>[ŽÁJ½|ÁW'FÁcÃÁp9‡Á|Ü(Á„Ö¯Á‹Z/Á‘è”Á˜~¥ÁŸ2ÉÁ¥ýÁ¬ÊÉÁ³ž¤Áº„iÁÃÔÚÁ¼ÌÁµÔ,Á®ñ*Á¨›Á¡Á'ÉšÁÐŽÁï`ÁaÏÀñÏ;ÀÛm¦ÀÅnÃÀ¯ªTÀšêÀ†½wÀfIÅÀ@c¹ÀMQÀá¿Õâ.¿½­b¿µg쿽Æ9¿Ô€¿ý÷QÀ<·À<¾ Àbm¤À…{Àš2ôÀ¯Ï[ÀÅY³ÀÛ!^ÀñaÙÁ8ÈÁü|Áê8Á(HÁ4v Á@äßÁM\OÁZ\ÁfÒmÁsËÁ€w0Á‡ßÁªƒÁ”n}Á›:Á¢=Á¨ëàÁ¯ãƒÁ¶âˆÁÀMÓÁ¹ABÁ²6RÁ«.ÝÁ¤;FÁ[0Á–€JÁ­äÁˆðÁ‚FÁwLõÁj,6Á];ÁPkÁCž£Á6ßÁ*+¦Á¿VÁdÙÁZûÀòåïÀÛ¬9ÀıÀÀ®:³À˜4@À‚~ôÀ[¬$À3®éÀ Õƒ¿Î9À¿×y¿<¿Ÿ¡¾Ö8—¾ù ¿7°]¿ˆÓÇ¿ÌuµÀ Ú À1È1À[AþÀ‚ÐCÀ˜9•À®½ÀÄMÔÀÛ€:Àó$LÁãÁ¯ÉÁ$¡Á*œíÁ75üÁCû_ÁPã„Á^HÁk*¸ÁxSeÁ‚àÁ‰«jÁ|•Á—XñÁžGßÁ¥FFÁ¬FÁ³F3Á¼óŠÁµÍZÁ®²ÌÁ§¤¥Á ™9Á™–ÄÁ’¤Á‹ÂRÁ„êeÁ|CÙÁnÍ(Áa„ÕÁT\ÁGBPÁ:PûÁ-jÁ ¾)ÁüÁAÀö °ÀÝÕMÀÅî‘À®”ÕÀ—”dÀdÀUóyÀ*»ÏÀƒ'¿³ÁÈ¿Ms¯¾y^>Oˆ¥>õÚ?—@?ug>e?ø¾lÐg¿F3¿°m×ÀhþÀ+x,ÀV2îÀ€àÀ—RÀ®øÀÆWüÀÞ+Àö¼”Á×èÁdVÁ!zÁ.Á;aÁH9NÁUcýÁb«×Áp;dÁ}æûÁ…̓ÁŒ²ÛÁ“¦Áš¦Á¡¨¼Á¨®EÁ¯Ã}Á¹²ÞÁ²‡RÁ«`fÁ¤:eÁoÁ–{ÁŽÿFÁˆµÁ eÁtS:Áf»ßÁY+ðÁK¿lÁ>“ Á1^‚Á$W¢ÁcùÁ ˜ Àû¨¦Àâ`ÀÉ‚LÀ±YÀ˜ù<À}pÀTîÀ'™¿öüã¿¡#±¿ÏM:¨_›?n®?±9?»^?Ê%f?½’Í?‘Aœ?11<­-3¿:¨¿¢w¿÷åfÀ'€&ÀTÆÕÀ¥“À™BÀ±Y)ÀÊ'§ÀãPÀü–úÁ 0%Á2 Á%K£Á2r˜Á?µŽÁM(GÁZÔüÁh…ÎÁvN1Á‚ ºÁ‰ŒÁ UÁ—ÀÁž)qÁ¥FoÁ¬ctÁ¶¬úÁ¯g_Á¨*/Á öùÁ™Î Á’¨¿Á‹„„Á„lÏÁzÖÒÁláNÁ^ïÏÁQ7¶ÁC§FÁ6CÁ(ȨÁŽÔÁnÁlõÀèó³ÀÏYùÀ¶ =Àœò¤À„r>ÀXAÊÀ(Ì¿õf®¿šHé¿6>€Ó?I`Æ?³\ø?þU @ì]@$ÿ–@?Ì?ÿí­?µ”1?K.©>™ó¿Éß¿š©Ç¿õð÷À)¨)ÀY‘À„¹>ÀâÄÀ·((Àо Àê¿*Ák\Á†|ÁËÝÁ*E]Á7˪ÁEsÁS7Áa Ánæ¼Á|ÛÞÁ…u„ÁŒdÁ“¬õÁšÎÉÁ¡õ_Á©*›Á³ÇÁ¬y/Á¥0ŸÁë¶Á–§¨ÁkÎÁˆ?CÁÁsä­Áeµ%ÁW¸ÁIºÚÁ;ÉÁ.%Á ƒ™Á½ÁÃ4Àñ À× À½OÀ£$\À‰›úÀ`ÒÀ/„пýhÉ¿Y¿ây>THè?epK?ǃå@ $6@3"y@V”¹@dìy@Wd«@4†@ Ÿ'?Æ»À?b7>Gªö¿É^¿ IšÀšÀ1&AÀcw¶À‹ãÀ¥DÀ¿ ÀÙYüÀóä¼Án½ÁøaÁ"s¿Á0(4Á>$ÁKÛTÁY´€ÁgµºÁuîóÁ‚@Á‰DæÁmÓÁ—¢-Ážé¾Á¦BÁ± Á©¹zÁ¢Z]Á›âÁ“¶gÁŒrÁ…,þÁ{Ó ÁmwtÁ_#ˆÁPÄÁB”öÁ4“fÁ&Œ%Á¨7Á HÀú¼¾ÀàÀÅ“À«4³À‘*ÀnÀ:ÔÀÚ¿¬˜¿ÕÙ>.p?g;0?Ï"_@Ŧ@=ëØ@e÷ê@†Mˆ@’l®@†¸Í@f1R@=tW@Éø?Ílk?bO2>èî¿È—¿²€ÆÀ )äÀ?W™Àse¡À“ÈmÀ®nÞÀÉ:2ÀäJ3ÀÿLÁ @¾ÁøqÁ(Ñ¢Á6²ÑÁD©²ÁRØtÁa)²Áo{‘Á}ÍbÁ†‘ÁdÁ”ÀÁœ#«Á£ƒ½Á®”ÌÁ§#ÁŸ¼ÓÁ˜[>Áù0Á‰—iÁ‚DÿÁuÿÞÁgeûÁXÔ·ÁJj®Á<õÁ-¥ÆÁ|„ÁwÁrëÀëg¹ÀÐWÀµÙÀšŒgÀÝÀÀJܶÀ»’¿ÅÜû¿?ÔL=+Îf?Q 7?Èïß@Ö@AÝÑ@n/9@Œ @Ÿõ~@®æ©@Ÿïì@‹Åg@lòS@A—@šô?ÅÃÖ?EÐ7¼Ÿa¿Qax¿Ñ$ÀìZÀR†Àƒ¢Àž©OÀ¹²¼ÀÔò!Àð:SÁÒÝÁÏ:Á!Ø]Á/çÁ>>ÁLkÒÁZÃÁi+ÁwÀyÁƒ?eÁŠ£ÁÁ’HÁ™pÉÁ ä\Á¬,½Á¤¸äÁElÁ•ϽÁŽ`Á†üJÁ-’Ápb«Áa¬tÁSQÁD{OÁ5èëÁ'~VÁÁÁ ³ÿÀù<}ÀÝ"ÇÀÁiÀ¥»¥ÀŠ64À_5À)¡„¿é&[¿Iy¾2x? ×¹?¶'¡@ f@>4@np@Ž9@¤Lf@«¡ú@¬‰s@¬ @£\@¥¤@làY@<0Ë@ø”?ªÿ0?¸ú¾’p>¿t¿ùcŸÀ2ZˆÀhxªÀzgÀªÉ?ÀÆüÀâ=Àþ`Á šÁ+ÂÁ)r2Á7áaÁFYÁTéíÁc¥MÁrpIÁ€¼Áˆ ·Á†ÒÁ—ðÁž Á©õÎÁ¢o{ÁšêAÁ“mìÁ‹÷±Á„ÁzèÁkHÏÁ\äÁM±Á>óFÁ0AvÁ!¡ÁþÁ¢¼Àìc_ÀϦ…À³p„À—.ÀvºÀ?²³À 2¬¿§ÕŸ¾ôAÐ>±|á?•Ú?ÿf¶@3&@ezv@‹“À@£3|@§´-@©þ9@«&°@ªàý@¨a@¡ýá@‰tD@_,Œ@+Ï?í F?„qû>TÏh¿"‘q¿»gÀkÀJ²WÀ€ª¢Àœn À¸†ÁÀÔ´~ÀñAÁÏ­ÁJ‚Á#ÔÁ2V‘Á@ìAÁO¥Á^{BÁmpmÁ|ƒÁ…ÒÁjáÁ•§Áœ˜~Á§à?Á VæÁ˜ÏÁ‘GQÁ‰¾lÁ‚@©Áu”bÁf#ÁW—SÁHÄ[Á9ë&Á+úÁM Á ˜}ÀýÉýÀà˜ŠÀúQÀ¦ÜæÀŠL.À\TÀ$"¿Ùƽ¿Wœ'7»Iß?V7:?ÖSÑ@ di@Uã†@„ø@™Ñç@¡r @¦Ul@©” @«@ª½Ä@§1D@ ‘‚@•;.@}ø @J™Œ@™)?Áöß?-Ó-¾.É¿‚)ã¿ï““À/(0Àg øÀÁøÀ¬bˆÀÈúœÀ客Á\ÚÁÞ½Ád®Á-5Á;ä0ÁJì˜ÁZ+ÁiZ9ÁxŸáÁƒñÁ‹…ÖÁ“ûÁš·†Á¦àÁžqìÁ–ÜúÁR Á‡ÀÁ€-~Áq>²Áb5¿ÁS,ÔÁD#ôÁ5$öÁ&JÄÁvdÁ¡¤ÀóªZÀÖQ—À¹!À›¹èÀ}¦ ÀD@”À r¿¥‚»¾Ô Ö>à¨;?¥?@N~@=d@sÅ@Œ|@—¬É@ @¦pè@ªÚ•@­\t@«Å§@§š @ŸÀ=@”Ù@…µ'@bdS@0;?ùM?Œöq>ƒ”U¿¼Ô¿¼`fÀéÀOX4À„f¸À¡"ÃÀ¾5=ÀÛpíÀø¬Á þÁÓÁ(ÖPÁ7ùÁG5HÁVwâÁeº|ÁtýÁ‚.Á‰ÃçÁ‘ryÁ™(‡Á¤pûÁœÅAÁ•2ÁyÁ…áÁÁ|ž¼ÁmzÁ^U’ÁO7ÿÁ@4'Á13¸Á"1IÁ Á šÀêÆÀÌÒjÀ¯À‘¤bÀhô&À.ì?¿ëDÛ¿rƽîî?N…?Õ8—@ #@S\4@x°X@Šr´@–54@ nh@¨¹Ç@­Ðö@°°L@¯—ê@¨ö´@Ÿêá@“çv@…ð@gr@?‰Ò@ÿ›?·Y?â¾Ú&¿’\jÀÀbÁZ?Š•?ö‰”@+ -@R1˜@sN_@ˆ˜V@–Fø@¢(.@¬”@³ @¶¹(@³÷Ï@¬HŠ@¡!@“E½@ƒ5M@dPô@?ˆ‡@¯‰?Íè/?OFؽm¿jº¿ä…ÈÀ,­ŒÀg,eÀÖ¡À®v-ÀÌ%ŠÀéó!Á tÁLrÁ"¥7Á1þ§ÁAXÁP³Á`XÁo‰ÆÁŠÁ‡D/ÁÁ–Å»Á¢ªÁšgÓÁ’±ÁŠûhÁƒEÆÁw(äÁgÎÁX{³ÁI3²Á9øâÁ*ÙÈÁƶÁ ¶ãÀûVïÀÝPãÀ¿T À¡VMÀƒT0ÀJ¦—À×ì¿®s¾öME>É;×?˜ì2?øòŸ@&‚x@KÇ2@nEï@‡™w@—B×@¥“2@±±Ç@º…k@¾¦`@ºÛš@±=¦@£Çì@“@Ñ)@_Î@9/ @Sí?Ëöµ?]Ï=m&µ¿I“d¿ÔæšÀ#:wÀ\sÀ‹wëÀ©töÀÇ}¦ÀåjÁìÁ>ÑÁ ›³Á/øœÁ?UŒÁN²ÀÁ^wÁmËÁ}-!Á†côÁŽ3ÔÁ–LÁ¡]aÁ™•UÁ‘ÓWÁŠkÁ‚eÖÁuyŠÁf2„ÁVפÁGjÙÁ8 PÁ(¿sÁŽÁ g2ÀöœíÀØ™ÀºªÀœÐuÀ~6BÀD À á¿¢)V¾Ïâš>Í4x?‘Ø¿?éÁt@æ@Cþ¼@j¯#@‡Ä^@™Š”@ª8‰@¸¯@ýg@ÈI(@Ä@f@·î@¦²1@“Ë•@€? @YBÝ@1™D@ x-?¼6*?Cõû<ÖcÔ¿Eã¿Ðš À ùeÀYº<ÀŠ1ôÀ§»ïÀÅNœÀã[Áì-Á4ÂÁ}qÁ.ÈÁ>§ÁM‡*Á]ÉÁl™^Á|3/Á…ç Áµ/Á•ƒ®Á Ü@Á™QÁ‘S,Á‰‘YÁÖÂÁtFuÁdâ÷ÁU‚§ÁF'Á6áÁ'´Á¦ŽÁ lÆÀô;?ÀÕükÀ¸UƒÀ›e×À}“±ÀDX0À @¿¨ÍÀ¿WÆ>7¢?t”Ð?Òrú@Hõ@>|Ø@ie˜@‰@¢6@°ˆÒ@Á®@ÎR³@ÕGT@ÎK³@¾bú@©öæ@”Æo@~úó@S¾O@)ž¯?ýð”?¦(–?²è¾/D¿n½Ë¿ÜgÓÀ%A}À\šmÀŠÉ?À§›?ÀÄæÀâáüÁ¬™ÁÿâÁWÓÁ.¯ÅÁ>ÍÁMt§Á\õÁlÌÁ| Á…Ê#ÁIÁ•UZÁŸFŽÁ˜£SÁ‘11Á‰y–ÁÄsÁtTÁd›äÁU&ÁE½ÐÁ6o»Á'BöÁAwÁ e ÀõÀ× åÀ¹í0ÀÃúÀ€Õ­ÀI´ùÀµj¿¿ˆ­¿@;@@jøø@‹×+@£2@·ºí@ÊëK@ÚëN@ã5@Ø–F@ÊØ@­ö@–S@}úb@O‚Û@!ý?ækÏ?ŠF>§üƾÓÁú¿•,ë¿ùkhÀ/FáÀd/fÀŽ—AÀ«X&ÀÈ7†ÀåÌHÁÏáÁÐËÁéÝÁ/—Á>^4ÁM´Á]=FÁlÉÁ|Y‚Á…ôúÁ½8Á•…|Ác8Á–ÇÌÁ>”Á‰²7Á‚Át•ôÁe2•ÁUÜ2ÁF•ÐÁ7cmÁ(MRÁaZÁ =À÷;‡ÀÙÍÂÀ½6(À¡¶7À†l<ÀVÛÌÀ$ ¿å“¿ƒxL¾­â?.?§î-@ :Ü@=M@nÛ”@€y@¨t@¿y@Õš@è C@óéŽ@àÎ4@ÉH@°·4@˜%Œ@M@LæD@>§?ÓG‡?`m¿=±äµ¿2²å¿»dÀàÍÀ@—WÀsÎÀ•L'À°éÀÍ °ÀêúÁæ<ÁÒuÁ!¾®Á0¾ÝÁ?ç­ÁO0YÁ^’QÁn¬Á}­Á†ŽJÁŽTöÁ• ÒÁ›ØœÁ•-,ÁŽžTÁˆ'óÁÝpÁu¦'ÁfpâÁWSSÁHNDÁ9aƒÁ*whÁ–kÁ ÛÀü¹òÀàgÀÄxŸÀ©PÀŽ[ ÀiªÀ7ÞHÀi¿£äk¾äèM>ÞŽç?§ìb@ >1@AHX@x Ø@—g@°’@ȈM@à¯@ôä@ÿÆl@èf@ÏQ=@µäž@œ6í@‚³@QBÜ@ƒG?ÏË?Hܽk¾Ù¿ico¿ÞЂÀ"ììÀT›HÀƒÞhÀçšÀ¹fHÀÕ3Àñ3»ÁÛ¬Áa<Á$‘Á2ö»ÁAÿ¥ÁQ-&Á`w9ÁoËÁ$1Á†L¦ÁŒºÁÁ“P?Áš´Á“û}ÁdøÁ†èÁ€æÁtÊzÁhOÚÁYL1ÁJ^HÁ;ˆjÁ,ÚÁ^RÁãÁ^Àè»À̈éÀ±Ð«À˜+ïÀ|ž ÀGIÀôù¿¥é­¾ºSã?»Ö?·JŠ@åÖ@P«@„/ú@Ÿ§»@¸Ø¬@ÒVÛ@ê… A«³A×j@ïÃ@@Ö1R@¼Rö@¡sø@†z2@Wo@ qD?ÓjŽ?I­c½ÇšÒ¿µ¿óâíÀ3Q~ÀiýYÀ9`À¨îÃÀÂÿÀÞ"ÀúžÁ ÚÁYÁ'jØÁ5ÿþÁDÍÁSÇ·Ábâ#ÁpÕqÁ}Á„Ý{Á‹\ˆÁ’ÒÁ™÷üÁ“6ÇÁŒ— Á†÷ÁvÙÁs3ÁgãÁ[•=ÁLÜ)Á>WàÁ0µÁ!ÛÔÁ±§Á(ÑÀì;ŽÀΰmÀ±msÀ”@?Ànÿ­À5ª¿ó´A¿}!–½Ç ½?Rêu?ÛŒ‘@'–@`¬{@mE@©lÓ@Ä:ˆ@Þ $@÷ïA=½A ¬Ü@ù0®@ÞÛð@Ä9w@©`Ü@ï6@dÚR@+ð¤?äï?_Îó½ræ¿p§‚¿îÀ1…âÀmóÀ•tHÀ³#dÀÎVAÀèßÁÆÁpÍÁmÁ+¶$Á:/JÁHÎ"ÁW(-Áb¢kÁn¢Á{ `ÁƒãíÁŠa Á‘ñÁ™¥Á’à¿ÁŒ<òÁ…¿HÁ~ÍvÁra¼Áfc]ÁZèOÁLÆ¥Á=ž9?™Î@@4©@?XI@y¢;@™M@µÁ@Ðt>@ëŒ_AIAd AEA¾¢@è“¡@ÍgÅ@²%­@–ñs@uvS@<’†@°3?–;>ï¿+0¿ËwOÀ àÀ\gFÀŒ ÉÀ©Ü1ÀÇнÀæIºÁ„ÿÁîLÁ!^–Á0SÕÁ>f¥ÁJ°?ÁU£`Áa1pÁm?ÅÁy•œÁƒ%ˆÁ‰¬5ÁXšÁ™—gÁ’Ù0ÁŒ<ÑÁ…Â.Á~DzÁrnÁf‡{ÁX»üÁI8Á9|~Á)êÁ[Á ÐÀö‹OÀ×±À¸Õ6Àšr¨ÀxË-À^ê?“nv@'T@>#‡@w¢¥@˜£@´Ä°@Д£@ìzšA ºAüAÃðAùÁA`LA„Ø@å†ù@ÊCk@®„¶@’‘ã@mmÈ@3_Ž?ò3Ö?yÉ=0¿h¥q¿îäõÀ5(¯ÀsiÀ˜–ÅÀ·ÂÀÖîQÀöëÁ ·÷Ás$Á*;Á: ÁIåOÁUïíÁaNGÁmFÁy1(Á‚ãÁÁ‰\iÁñ×ÁšƒÁ“Ô©ÁI\Á†æEÁ€±_ÁsnªÁc” ÁS½ÇÁCävÁ4 ?Á$6Á^õÁ‡ÐÀéaUÀɳ‹ÀªžÀŠšƒÀVµHÀ[–¿´ƾÝA…? y¾?¾ç”@Ú¬@XAŽ@‰}¶@¦—¢@Ã=@ßXr@ûbaA Œ2AoA&óA"ïïA BA‡i@ôO=@Ø3u@¼*ñ@ % @ƒ-@Kß>@ ê?£‡—>žËq¿*‰0¿ÑóâÀ'Q–Àe«‰À’;ðÀ±ØÀÀÑ“|Àñ`WÁœÁ‹ŸÁ(zÊÁ8iõÁHY ÁWWYÁbƒYÁn&«ÁzEmÁƒeàÁ‰ÈÁRVÁ›‚ùÁ”àÁŽaÁˆ Á€ÛOÁqŤÁaÕgÁQæ–ÁAù‹Á2¿Á"&|ÁA)Á\ðÀäõ§ÀÅ7²À¥ƒ’À…ÕHÀLMûÀ ñg¿›)¤¾cƒ×?C˜C?Þ‡@-™v@kó)@”ã[@³Ì@Ðì;@î€A9A8A!#ÂA.¶ýA*FA±ÍA!²AQ#@æ†C@ÉÍA@¬%>@Šy@\ú@r‡?¿dQ>ÿë^¾þu¡¿¿cÀp“À_-FÀtþÀ¯T ÀÏ5ÍÀïèÁ}NÁnÝÁ'`‘Á7RbÁGDGÁW6<Ád—JÁoþNÁ{ä€Á„ÑÁŠwIÁïÄÁœÅôÁ–:1ÁÔÁˆ5sÁ€<âÁp‰jÁ`™fÁP©Á@¸Á0ÇÁ ÖÁå;Áô×Àâ WÀÂ,}À¢N¼À‚k›ÀDùöÀµ¿ŠŒ½µ…d?g¢6?òúŒ@8ßÝ@xC@}Û£@žÚ™@¾É9@Þ·Ù@þ¦zAJAAÝA/1¸A>€áA5Ü A&šAV1A•.@í¬>@Î \@®@@Žw@][ü@ÉÛ?¼os>õ,À¿²%¿ÀýUÀ ½À_äíÀã}À¯ÖLÀÏÉÀï»ëÁϧÁ¼Á'©xÁ7–aÁGƒIÁWp2Ág\mÁvÓÁ€É{Á†ÊéÁŒø@Á“JšÁŸ®”Á—µ/Á»ËÁ‡ÂfÁ’ÁoŸ:Á_¬qÁO¹§Á?Æ?Á/аÁÛ Áä…ÀÿÏýÀßÖïÀ¿ÝâÀŸäÕÀ×À?åu¿ÿç¿€ »ŒEê?~?þ“K@?‰@~Ùn@ŸP©@¿* @Þõd@þÊæASžAD,A/6xA=[¦A0ƒA",AAóvA|D@çïß@Ȩ&@©(^@‰°^@T~*@›®?­rd>½ z¿Ám¿ÎKÀ&SðÀe±°À’•VÀ²XœÀÒ—ÀñèÁØÉÁ¾ÜÁ(§–Á8GÁHyÃÁXcÝÁhNtÁx9qÁ‚°}Áˆ‘GÁŽšdÁ”¾øÁŸ±Á—¾qÁÈÓÁ‡ÎTÁ§¬Áo²áÁ_¾lÁOÊ`Á?ÖØÁ/ãöÁñíÁÁ¬ÀàIÀÀvŠÀ ®rÀ€ê+ÀBKÆÀÃ6¿†uN½l…Ü?oYà?ö¾@:ç—@z7"@œš0@¼å@Û—Ò@ûãA #AŸkA+P?A-»9A'åÞA² A Óþ@üñ"@ß*à@ÀÑ6@¢\@ƒ ³@H@ ö?–ðî>I_¨¿I2¿â]üÀ0zÀnóöÀ–ûþÀ¶¡¶ÀÖJ›Àõó€Á Î3Á¢¥Á*wÁ:GÌÁJ§ÁYõ|ÁiΈÁy¨Á„ÁïÁЇ=ÁsŠÁ–ÁŸÐ(Á—ùbÁ +ÁˆôÁ€#ûÁp]^Á`rÆÁPˆCÁ@ 4Á0¼eÁ ÞÁÁ8/ÀâÔ‡ÀÃ8¯À£…ÀƒÍŸÀHrÀ“§¿’Å ¾&Tx?R_Ö?æÂ>@1Ñð@pBÂ@—YÊ@¶^)@ÕD”@ô#A žA „AîÒA%ÛAäA™A¹@î9|@Ò7a@µrÐ@˜,@sú|@7w?ôÊ?q,4¼ã"½¿^`¿û=¿À;á²Àz¡,Àœ°SÀ¼¡ÀÛvÛÀúâ.Á %ÁßMÁ,¢rÁÔ\›¤¿ 9¿È¼œÀ ¼À]3oÀ)8À«â†Àʰ(Àé¶%ÁYÁÃÁ#6Á2ÂXÁB`ýÁR ¸Áa½–ÁqkÁ€…#ÁˆT¸Á$|Á—¥±Á&Áž°lÁ˜éCÁ‘æÌÁŠ[Á‚83ÁtÅqÁe òÁU„TÁEñtÁ6jÁ&èIÁ[–ÁÎ[Àð‚AÀÑd6À²]´À“¯õÀj(ŠÀ-Ÿ¿à¢b¿Q…Ò=ó÷?‡?ûD@7£®@o7@’1@ªF·@¾z@̇<@ÕVÍ@Ûê@ÞA*@Þ.@× ¹@ÈÞ|@´;’@;­@„<ó@TÍî@€D?ÐCm?BAz¾ ¿ƒæO¿÷úÀ6£Àr[ÓÀ—\ÉÀµ4ÀÓÊcÀòC¥Á|ÁÚ:Á'N Á6Ñ­ÁF;®ÁU¦ŠÁe {Át«¬Á‚"‚Á‰õÁ‘ËcÁ—ÉŽÁH´ÁžÖEÁ˜ø>Á’èØÁ‹&gÁƒ_—Áw1¶Ág¥ýÁX%ŽÁH´WÁ9UˆÁ)Ý4ÁeßÁ ð°À÷0ÀØÛéÀº’|ÀœÀ{o‹À?œ•ÀÏn¿’Œ›¾qÚ?+º?Ãþ‰@\@L´¹@{ëÚ@’å @£a'@®Ý³@· ›@¼l@¿ 2@¿„Ó@¹BÏ@®2’@œ´e@‡å@a@/m?ùMµ?Žòú>‹:X¿èÔ¿»—À'°ÀP»ÓÀ…&”À¢+#ÀÀ7ÀÞKæÀü‡–Á ^XÁ}®Á+µ5Á;øÁJc ÁYÊgÁiD©Áx´VÁ„+Á‹Æ€Á“4Á˜GxÁÀÁŸ¿Á™WÒÁ“œÁŒRÁ„^ÁyÖ¢ÁjéÁ[*—ÁKØšÁ<ÖÁ-L5ÁáÁõáÀÿºÀáƒþÀÃLÀ¥b•Àˆ†ÀUì°ÀÂ4¿Ä£¿)eü>U_A?ƒwD?êœ^@#D“@M•D@r[h@†È˜@‘!‡@˜Lä@î@Ÿó4@ jœ@›íÏá?–Éþ?ë &@ü@;.r@Sµ8@fI@rà<@{êá@€Ú6@*Ž@ya=@gþì@Pr@/a>@c™?¸çè?9o¼ç†Š¿Quf¿Ð~ºÀÀ_ÀSdóÀ…—¨À¡yÀ½Œ+ÀÚU±À÷$+Á ÷ ÁhXÁ'>Á6…ÁEÍÁT6¨ÁcZgÁr‡•Á€×`ÁˆpßÁ¹Á”VÁ™‰sÁž÷šÁ |ÁšÆ8Á•ÆÁ3@Á‡åŸÁ€a#Áq¥†ÁbŸ{ÁS´ûÁDëEÁ6!Á'2þÁXãÁ ›ÃÀö³ÀÙrkÀ½UgÀ¡9dÀ…&ÀS}dÀŒ…¿Ú$U¿h`Û¾Jeh>ñh=?‹¾Ì?ÎQE@¾\@x¯@) È@4è”@=Ö!@Chù@CÔÿ@;í.@+ü¬@½ì?öB?®Õ»?=›8=Mÿ}¿+û ¿µðÀ ÞŸÀ@L·Àu ^À•yþÀ°Ö#À̽OÀè¤ÁuiÁÛOÁBŒÁ-©ÉÁ<ÝÁJ¹ÁYŒžÁh‡úÁw¡&ÁƒaÁŠßœÁyÁ•1ÁšN‹ÁŸ¼:Á¡ÁÁœ âÁ–=JÁyäÁ‰ÙÁ‚i‰ÁvbÁgB¶ÁXoËÁIŸ—Á:éÁ,S÷Áê3Á¯ðÁ}éÀæÔÝÀÊìÀ¯š¿À”‚æÀuðpÀC‡0ÀÅT¿Éè ¿dª¾–1>‹ŽV?>•{?’<±?ºƒ'?ئø?îÙ?ÿ”p@9·@X:?ýÇF?àõ/?¹Íž?‰’˜?×r¼1:¿%ø¦¿«YóÀ.éÀ3̦Àe_äÀŒRœÀ¦‚›ÀÁ}ÀÜ?¨À÷ûÉÁ ñ{ÁäRÁ&Á4ŒÁBó0ÁQZcÁ_ÆŸÁn]ÐÁ} žÁ†ëÁŒBQÁ‘?vÁ–/(Á›XOÁ ½Á£0~Ám Á—¯ Á‘óýÁ‹ÈÁ„¤`ÁzÛËÁl4»Á]¢FÁO&LÁ@¶ÍÁ2v‹Á$A×Á-îÁR‡Àõo)ÀÚÀ¿^ùÀ¦#êÀKÀiâÚÀpí¸?¬£?>lã?fÅß?ƒ|?ÑŠ?ŽÛ"?‚üð?Sž/? Q}>>*«¾Á¿Htt¿±×‡Àc!À.Œ˜À\¤À†ˆÀžð•À¸~ÝÀÒ6Àí1„Á ŽÁ¡tÁ¸Á-‚§Á;z­ÁI±ÈÁX(!Áf§wÁuˆÁ¼ÔÁˆÃGÁ³ûÁ’®¹Á—¬DÁœÈóÁ¢!fÁ¤»ÁŸ"ÇÁ™…‚Á“ÎäÁúåÁ‡èÁù¿Áq–³ÁcDÁU 9ÁFíÁ8ëêÁ+µÁFÂÁÏøÁI?ÀêB ÀÑ# À¸ˆÀÀ øÖÀ‰í’ÀhÇjÀ@âÀŒ»¿ñó…¿¶†º¿ƒ=ë¿0lK¾ÖÞ*¾Y½iÌÙ=r&<> }3>K¹={¹½ì„ƾÀwf¿8úœ¿ŽÒ©¿Í”<À s$À1&MÀ[HÀƒµÂÀšÆÀ²ôÜÀË<¤Àä«Àþ«OÁ täÁæãÁ'CæÁ5 ¾ÁC…ÁQ4Á_òÁmErÁ{°ÃÁ…®ÁŠ›£Ár?Á”vGÁ™‚vÁžšiÁ£æ›Á¦‘ëÁ¡Á›~Á•Ú1Á>×Á‰Ú±Á‚ÄÁw‡£Ái{¢Á[„½ÁM²Á?ãˆÁ2D:Á$ÜEÁš^Á ™øÀü[%Àä ºÀÌ‹êÀµ«ÓÀ ,ÚÀ‹u9ÀqLÐÀN€À.ðîÀ¶^¿õÃâ¿ÎMƒ¿®‹÷¿•Ò¿öc¿gžà¿Vä{¿Rg¿f”ῈÄú¿§xƿР¼¿ý²3ÀéPÀ<‹›ÀaS›À„²ÀšˆÀ°%8ÀÆÚ£Àß/oÀ÷—?ÁHúÁQ³Á"nÁ/ªÐÁ<êˆÁJ}]ÁXe%Áft‹ÁtqçÁ5 ÁˆùÁŒÆªÁ‘ŠÁ–s-Á›uPÁ ˆÈÁ¥Õ/Á¨ÂƒÁ£7RÁ«`Á˜ÐÁ’“pÁŒ›Á…ÚÁ~NÁp+ÎÁbgSÁT»sÁGLKÁ:%XÁ-ÒÁ ¡Á“?Á‘ÀøÑÀáSÀËmÔÀ¶÷æÀ£ìzÀ‘í0ÀOÛÀeÛÀL”À5hµÀ"™ÀtÀºS¿ü¦5¿îié¿ç‹Í¿åYÞ¿î„À QÀ„®À!¶¬À8IrÀRLÀprÀ‰CÀœ›ÞÀ°î}ÀÆzÍÀÜ”®Àó4fÁ´òÁè«Á;ÛÁ+wÁ8-óÁEjÁR¥ÃÁ` ÁmÅ¥Á{qÀÁ„úÁŠlëÁÅÁ“¿ZÁ˜ˆ¹Á‘Á¢µÁ§ñÜÁ«D9Á¥º Á 6«ÁšÅ(Á•?æÁÁ‰*ëÁ‚còÁw?ÏÁi¬ZÁ\fÔÁO?¥ÁBIÙÁ5ˆŸÁ)ËÁŒÁ¾ÁqPÀöÁzÀâv¯ÀÏýÀ¼ÓsÀ«‰Àœ¸ÿÀŽhÐÀ‚zóÀp&WÀ^.0ÀOÍtÀDø³À;ûóÀ4}mÀ1ŠCÀ0\²À4ýýÀ=Ù$ÀK=À[êÀqðÀ…)À’÷ûÀ£} À´éÈÀÈîÀÝ ÀòqåÁRÁ¸¨Á¨ÚÁ(·Á4BÀÁ@æ·ÁMïÁ[tÁh&ŒÁui‹ÁpZÁˆ?Á1cÁ‘¼ƒÁ–@šÁšôÁŸêŒÁ¥ÁªE­Á­ýóÁ¨w˜Á£!Á‹EÁ˜4ïÁ’ŸXÁŒžÁ…ß;Á~Ž»Áq„ÓÁdsaÁWœnÁKpÁ>»Á2Ë{Á'T4Á@§Á¾ÁÛ-Àú…ÀçžóÀÖY9ÀÆ0ÙÀ¸PÀª·£ÀŸHÀ•R À!÷À†:³À0ßÀyQ¸ÀqùÇÀo^nÀmìÉÀr´Àz—"ÀƒzûÀ‹ÂTÀ•ß3À¡;À®°ŽÀ½9{ÀΟZÀà ÀôÎÁƒÁ4ÁR:Á%Ñ2Á1ž¡Á=òÁJW ÁVÅ•Ácˆ¡ÁpvuÁ}‡Á…SxÁ‹y²Á–Á”‡Á™VÁ½ÅÁ¢™âÁ§”RÁ¬±Á°ÑFÁ«Z—Á¥íCÁ …ùÁ›<³Á•ÞÏÁüÁ‰°ZÁƒN¿ÁyÞ´ÁmÁ`ŠõÁTh ÁHŽ3Á<ã.Á1³ªÁ&ܪÁhïÁÃóÁ N×Á‡ûÀð^ ÀágÀÓS5ÀÇ,cÀ¼BƒÀ²«pÀ«.À¤‰FÀŸmúÀ›7¯À—®]À–„:À•ËýÀ˜ÏÀ›–7À¡Œ&À©oÀ²«À½Î\ÀÊn'ÀØÂÀè$hÀùÊ=ÁzÁ>Á…Á%0ÇÁ0^9Á;éÝÁGŸ]ÁSÏTÁ`!ëÁlpŠÁy^Á‚ä“Á‰?ÁŽÝ¿Á“8ŸÁ—”ØÁœhÁ ·‡Á¥ŠÂÁªfsÁ¯m[Á³àøÁ®ˆIÁ©%\Á£Ö:Áž“ëÁ™<ØÁ“qÁŽ¡Á‡dÌÁ#OÁuÔìÁiÁ Á^&ÁRxKÁG89Á<”ŠÁ2 Á()ÁÎÝÁÆøÁ máÁr Àü­„Àïc,Àã¢{ÀÙ‚¾ÀÐ{9ÀÈþdÀÂÂzÀ½ÏýÀ¹ËhÀ¶`6Àµ52À´ÐÀ¶Ä-Àº'(À¿¸[ÀÇ HÀÏýÀÚ‡Àæ3vÀóÁÁ8Á £dÁ†ÂÁì]Á&1Á0‡dÁ;+ÁFcxÁQÿ¶Á]»ÁivÚÁuÆÁzÁ‡ ¼Á2çÁ’@pÁ–†:ÁšÛ­ÁŸ:)Á£ÆÔÁ¨•#Á­‚3Á²zÕÁ·%åÁ±ØÁ¬„ŒÁ§býÁ¢2}Áœî¡Á—{`Á‘™OÁ‹¨”Á…rÁ(êÁs’ Áh¿Á\¾ÁR½ÁGÀgÁ=•ûÁ4!»Á+¾Á"“ñÁ]îÁîªÁ ÊÁÜðÁ2°Àö…-Àî.aÀç õÀàüBÀÜGHÀØWÀÔôÀÓåÊÀÓMPÀÕs’ÀØÌgÀÝîíÀäûçÀí_AÀ÷YÁU/Á´Á HÁt7ÁEÁ(1ZÁ1ÑkÁ<"éÁFz)ÁQ‡Á\<”ÁgÓˆÁsU«Á%Á…ŒCÁ‹–ÐÁ‘cÁ•ØpÁ™þcÁž7‰Á¢¦aÁ§&=Á«Ü’Á°Í†ÁµÑõÁº¬“ÁµYcÁ°!Á« §Á¥ñ'Á ÏðÁ›pNÁ•Å…ÁöÁŠ;OÁ„r~Á}ëÁr>äÁgxáÁ]:ˆÁS!8ÁIsˆÁ@xØÁ7ÈëÁ/cdÁ'ÀÞÁ † Áõ3ÁêèÁ©3Á é°ÁáñÁ{tÀÿ$Àú] ÀöHóÀóu†Àòn Àò õÀóû½À÷IÄÀü+Áx.ÁMKÁ 6ÁÁ–ÆÁiæÁ#»ÙÁ+ûnÁ4ä0Á=âkÁGŸ¢ÁQóPÁ\ZèÁfôÁrËÁ}”ÎÁ„…¦ÁŠ>-ÁlÁ•oZÁ™-Á¬âÁ¡Þ^Á¦AÃÁªÐtÁ¯qÁ´KUÁ¹WÁ¾__Á¹ŒÁ³ûèÁ®Ü½Á©ÊbÁ¤ËŸÁŸ˜UÁš!æÁ”ŒÁŽõòÁ‰iÇÁƒÙ1Á|ÔîÁr‰1Áh²Á^ÖrÁU•<ÁLÞÃÁDbªÁ<“åÁ5!æÁ.DŸÁ'ñµÁ"1ÃÁÁ¥ Á­¢ÁoœÁŸqÁ 0ãÁ U¾Áó(ÁY ÁUæÁ 3áÁ ¿äÁ '!ÁB†Á$Á¾˜ÁÐŒÁ#½pÁ*ƒÁ1eµÁ9vÁA“‰ÁJHóÁS–­Á]eÁg¶‹Ár;¦Á|ÔoÁƒá»Á‰†8Á,ôÁ”˜üÁ™oÁg€Á¡–RÁ¥ÐjÁªÂÁ®¨VÁ³O0Á¸fÁ½4ÁÂ-´Á½nÁ·ï‚Á²ßäÁ­èÁ© ºÁ£òÐÁž¦SÁ™;ÚÁ“áÜÁŽv,Á‰WÁƒãHÁ}êÁt> ÁjÄ[Áaò«ÁYlúÁQR‚ÁIÌiÁB‘UÁ<&Á5ìÌÁ0ñÁ+“Á'CBÁ#yöÁ X˜Á™Á¯Á^£Á oÁu¢Á¨)ÁhÕÁÛüÁD›ÁÁÁ"â=Á':ØÁ,3¾Á1âéÁ7ìmÁ>ª…ÁF8ÆÁNbmÁVð=Á_ÍÁiWÁs*ŸÁ}mÁƒß<Á‰6ŒÁŽ£õÁ” 5Á™NÜÁ*Á¡† Á¥˜Á©ðéÁ®?ÿÁ²±>Á·\iÁ¼QÁÀôÁÆ-)ÁÁŠÁ¼MÁ·$cÁ²B Á­`þÁ¨j×Á£[âÁžyÁ˜Ô¸Á“™ÁŽLÁ‰‰Á„· ÁþOÁw‹ÁnâÁf-Á^†¬ÁW -ÁPH(ÁI÷ÁÁDÁ>ÓwÁ:)«Á5áwÁ2@¨Á/#Á,nÄÁ*%Á(WÁ''ÂÁ&’«Á&ÁbÁ'„oÁ(ïcÁ+>BÁ-êµÁ1®Á5½ÆÁ:§RÁ?êkÁF .ÁLHÁS`òÁ[XbÁc¬ïÁlMòÁum=Á`Á„hÖÁ‰p^ÁŽŸÁ“Ñ#Á˜ðõÁÁÿÁ¡µWÁ¥§ Á©¨Á­áÁ²\ÆÁ¶ú£Á»-ÁÀSIÁÅ! ÁÊiaÁÅr‚ÁÀ€JÁ»˜eÁ¶¯Á±Þ`Á­¯Á¨°Á£ Áø%Á˜óÄÁ” øÁ/0ÁŠ”(Á†-Áª†Á{ £Ás+çÁk¹zÁdsºÁ^HÁW×îÁRW²ÁM ›ÁHˆ0ÁDfÁ@÷˜Á=êYÁ;.×Á9%Á7CÁ6@Á5¹«Á5ÙwÁ6©ŽÁ8ÇÁ:9ÅÁ<ÓÁ@aƒÁD_4ÁIéÁN=ÁSñ¿ÁZ(;Á`ÅŽÁhJ´Áp˜{Áxí;Á€Ý,Á…qlÁŠ0¶Á‹Á”…Á™&Á»%Á¢0!Á¥ú‡Á©â*Á­ïëÁ²Á¶rõÁ»FÁ¿å—ÁĆæÁÉYFÁð#Áê/Áä^cÁÞ—_ÁØçíÁÓ]"ÁÍöÁÈ¿ÁÂK†Á¼|RÁ¶ºÁ°Ä½ÁªñŠÁ¥LîÁŸÛ¶Á™×ÉÁ“üwÁŽ>Áˆ£ÛÁƒÆÁ{…"Áq2ÊÁgwÕÁ^( ÁU¢lÁMµ"ÁFpÈÁ@(mÁ:Õ£Á6S/Á2³`Á0hUÁ/0éÁ/þÁ/ µÁ/êÁ1>$Á3¨àÁ7,òÁ;ͨÁA}ZÁGùoÁOh)ÁW”Á`‡ÅÁj4ÁtB•Á~» Á„àUÁŠ “ÁŒ±Á–ˆÖÁœ±ØÁ¢äNÁ©9¡Á¯*Áµ/ Á»UdÁÁ‚ŽÁÇÇtÁÍL%ÁÒ¥‡ÁØöÁÝÖÁãPÀÁëC€Áå>SÁßWÁÙ„ÁÓ»bÁÎ6ÁÈTÁÂÆÑÁ¼ëôÁ·¼Á±LeÁ«‚Á¥¶ÉÁŸâõÁšAÁ”ºNÁŽ®aÁˆÓ|ÁƒZÁzöûÁoçÎÁeI³Á[\ÁQw‹ÁHh>Á@-Á8zÁ1¹ Á,žÁ'L3Á#nãÁ ñjÁ¢ëÁr†ÁöÁ 0Á!ÒÁ$bÁ(8Á-$QÁ3-*Á:#éÁAû²ÁJ£úÁTÁ^fÁh{OÁsu˜Á~ïèÁ…d^Á‹dCÁ‘‘fÁ—ÊjÁž,]Á¤+Áª2¦Á°N®Á¶€šÁ¼¿fÁÂ’2ÁÇÿCÁÍnËÁÒúAÁج$ÁÞ‚ZÁæ‰UÁàw¥ÁÚq^ÁÔ‚ÁÎ¥8ÁÈß.ÁÃ=«Á½zêÁ·— Á±¹)Á«è9Á¦†Á e/Áš²mÁ”Þ@Á?ÅÁ‰¿Áƒ‹žÁ{`nÁoõÁdµôÁY²gÁO$0ÁEÂÁ;œxÁ2à>Á*è’Á#”pÁƒ‚Áu7ÁQòÁ“'Á-¡ÁâðÁ™Á­Á„ÁB5Ág¡Á¼aÁ%,7Á,©äÁ4îªÁ>%FÁH çÁRP=Á];åÁh­ÁtƒµÁ€GYÁ†véÁŒ¹2Á“&²Á™7ÁŸA„Á¥PÑÁ«ˆÙÁ±««Á·s,Á½CÑÁÂÕMÁÈfòÁΜÁÓè3ÁÙÚäÁáæ5ÁÛÅyÁÕ²ûÁÏ­1ÁɳJÁÃÌ%Á¾IÁ¸:YÁ²R·Á¬gAÁ¦†¾Á µ·ÁšìçÁ•:ÎÁ£VÁ‰åÊÁ„KßÁ} áÁpâ±Áe(ŸÁYÌïÁN‰³ÁC•–Á9vÁ// Á%öSÁŸsÁÏ‚Á.¸Á ÁÁiøÁZñÁÙøÁnñÁÀgÁf6ÁWÁV?Á ÌnÁŠ—ÁLÁzÓÁ(ZÜÁ2 ‘Á”ÁqEÁ›åÁ{¡Á8•Àö©ŠÀín–Àæ±´Àã@€ÀâC±Àã'ŸÀä£þÀ軀Àïc^ÀùÁ¾ƒÁ U¬ÁÑ%Á7çÁ&Y,Á1Ár¯ÁJÝ×ÁW˜aÁdŒ,Áq ]Á}ºÁ„–°ÁЇÇÁV±Á–+âÁ›ÿ Á¡èÁ§ä+Á­æ Á´PÁº=$ÁÀS´ÁÆoôÁÌ}ÁÔâ·ÁÎsÆÁÈìÁÁà3Á»£NÁµs+Á¯/2Á© ‘Á¢ê„ÁœÖÁ–ÊøÁÑ~ÁŠÜaÁ„÷äÁ~PòÁrÕrÁgˆ Á\`pÁQ^ÁFeäÁ:çÁ.ÍNÁ#(ÊÁ¯úÁ µ‘ÁB»ÀðOÀÞ ÀÍÅzÀ¿ŒYÀ´k*À¬‹(À§ÁÀ¦¤À§IžÀ©ÆVÀ®þqÀ· À–\ÀÑ£ÂÀâíÀö=TÁäÁÅçÁwRÁ(²êÁ5$ÁAÕ ÁN€ÌÁZÖ¾Ág8^Ás¡Á~±ÕÁ…2ÕÁ‹ ñÁî Á–ߎÁœÚ½Á¢åŽÁ© ÑÁ¯SÁµ—¹Á»îKÁÂ>üÁÈ™8ÁÐÍ ÁÊTÁÃß?Á½Á·:“Á°â}ÁªËÁ¤.“ÁþBÁ—ÕÁ‘ºçÁ‹«+Á…©BÁe…Ás‘ÑÁgúÌÁ\‚ÒÁQ;ÐÁFgÁ;'gÁ05\Á$ùØÁ®Á yÌÁþ°Àî:³ÀÙõ²ÀÆwÇÀµ_À¥TÀ™,ÊÀ„àÀ‹ïÀŠM‡ÀІ¥ÀXÀ“d³Àœ€&À©ÙÀ¹ÅÀÌ&PÀà|<ÀöeòÁðÁ£ÁleÁ,/Á8hÄÁD§íÁPïBÁ\ª2ÁhB|Át ýÁãÁ…ØøÁ‹Ð(Á‘ÒÑÁ—ê€ÁžÁ¤WóÁª·rÁ±eÁ·¦Á¾MÁħ¥ÁÌÔÛÁÆJTÁ¿ÓÕÁ¹XzÁ²è Á¬\ÆÁ¥ïvÁŸŽÁ™.Á’ð˜ÁŒÀÚÁ†ŸÆÁ€ŒÇÁuëÁiÁ]3ÙÁQÁF—Á:âõÁ/É5Á$÷ìÁ"'Á •ÁŽ`ÀðQÀÙZ3ÀÃø?À°äÀíïÀCÄÀþ…Àle×Àa¼À^ØRÀ_ÐÀdÄ€ÀrTŒÀƒf†À‘À¢ÓÒÀ¶mÀËÃyÀãEÀúÑ„Á °ÒÁ.ºÁ"adÁ.‡#Á:¦AÁF5uÁQÎÁ]¬ÖÁiŠ5ÁutÁ€µ‚Á†½ûÁŒí¼Á“rÁ™^úÁŸÉ0Á¦5Á¬±#Á³KôÁºâÁÀÅûÁÉ&ÁÂmzÁ»ÖþÁµOÁ®­Á¨óÁ¡v;Áš÷áÁ”“ÁŽ+LÁ‡ãîÁ²OÁw sÁjÝŠÁ^¶ÌÁR±¢ÁFÎIÁ;*ÔÁ/®Á$t¬Á€lÁ·¶ÁþtÀòVvÀÜ¢ÀÅŒ…À¯¹¼À›$€ÀˆñÀnF6ÀQ0&À<¶áÀ0ý.À-øLÀ/X±À5HDÀB¤ºÀY<Àv’’ÀÛžÀ¢@§À¸ÆyÀÏó_Àçê?Á?ÙÁ fíÁz~Á$:ÛÁ/ºÁ;ZÝÁG0ÁS Á_¬Ák.¯ÁwS¼ÁàÙÁˆˆÁŽj‚Á”ÜÁ›MÐÁ¡×Á¨€Á¯EÁ¶3Á¼æðÁÅu!Á¾ÆÂÁ¸#Á±YÁªlÁ£×oÁ6–Á–ÞÁMÁ‰–cÁƒ,®Áy°‚Ám>†Á`Ø®ÁT¨âÁHe#ÁÀdªÀN”À F>À¬¿À-³=ÀL.‡Àsµ˜À޳ÙÀ¥šnÀ¼ÉÀÔ¢XÀì×ÂÁ\Á ÊüÁJÁ$ÜðÁ0²®Á<¬®ÁH¹0ÁTê€Áa&üÁm©Áz%zÁƒyöÁ‰íEÁfùÁ—UÁ»ÁÁ¤ŒûÁ«_€Á²2Á¹jÁÁùøÁ»+ËÁ´XÑÁ­zúÁ¦¦mÁŸË!Á™ïÁ’Y Á‹°îÁ…&Á}7 ÁpeÁc¢ÕÁWþÁJ¬]Á>[ÄÁ2ÇÁ%îÁÿaÁFYÁÒnÀï2-ÀÙ~gÀÃïiÀ®™À™¿+À„ŽÀ_òÀ82êÀ‚i¿í?K¿Á0&¿¨U¿£"{¿©6‘¿³iŒ¿Ñ:,À´À"Ù ÀKÐÀvåfÀ’­À©,aÀÀ nÀ×èðÀî¶]ÁÂoÁ^˜Á5EÁ&>…Á2_ZÁ>£;ÁKbÁW’$Ád¦Áq Á}ÿ Á……´ÁŒ1ÉÁ’ý­Á™ÑÞÁ ¤NÁ§’Á®oíÁµhÁ¾©÷Á·²?Á°ÄïÁ©ÃëÁ¢ÍðÁ›ï§Á•ÁŽ;5Á‡-Á€ÖwÁt^¼ÁgN!ÁZz±ÁMŸvÁA Á4‚mÁ(øÁÃ+ÁœÁ”'Àï“0ÀØ´ÐÀÂB À¬eøÀ–ôkÀ«ãÀZ<÷À/êÀÎŒ¿Åç‹¿‚î]¿Öž¾Ô”5¾ši8¾¶v¿x«¿Yo ¿¨Wá¿òjÔÀ!±VÀMÝ À{"cÀ”›TÀ«ÀÁ·üÀØuŸÀïÃZÁ·ÜÁÐ]ÁÇÁ(\¦Á4áÁAu¡ÁNoÁ[Áh&#ÁuZÎÁm·Áˆ>šÁ àÁ•èôÁœÙçÁ£Ô(ÁªÍ;Á±ÆOÁ»Y·Á´M0Á­?øÁ¦;ÏÁŸ5;Á˜-Á‘9ÁŠZ­Áƒ~óÁy\¿Ákü¢Á^«—ÁQrÔÁDŽ7Á7©ÜÁ*öËÁ[ÁçÁnxÀò‹ÏÀÚIÀ™¯À«ÄÅÀ•*©À~š=ÀSòÚÀ)¼QÀFA¿­}¿>„'¾*.M>–·?ØV?+Û¾?P}>Î%·¼üD¥¿øx¿˜Û±¿ì=CÀ#-ðÀO À|D–À”´À«f_ÀÂÉ…ÀÚv¨ÀòÊ4ÁºàÁÇÁ¼ÓÁ+S·Á8,­ÁEBoÁRbçÁ_¿ ÁmUQÁzï[Á„PÁ‹AõÁ’@×Á™<äÁ 5ùÁ§4.Á®ExÁ¸Á°ñÁ©ÛŽÁ¢ÎGÁ›®¡Á”¡áÁ—AÁ†/ÁDoÁqŒåÁc×/ÁVMœÁHû0Á;¬Á.˜hÁ!³ÂÁä£Á5„À÷XÀÞ;+ÀÅÔEÀ­jÀ• HÀ}_ÄÀP0½À$h‹¿óùº¿ŸÅÚ¿]Ö=ùx?%¤é?—ÿ‡?Å•Ò?ÑŒ?È«n?¡B.?J{>9¦×¾ôE‚¿”X¿ëÕýÀ"M$ÀO`YÀ|®@À•ϰÀ­ŠXÀÆlÀÞñ>À÷ÇÞÁ˜'ÁKèÁ"\ùÁ/~øÁ<±ÁJ8ÁWÏ*Áet;ÁsS£Á€©3Á‡¨8ÁŽ¥£Á•¢×Áœ´€Á£ÔUÁªôOÁµÔÁ­ÕýÁ¦š¬ÁŸo¦Á˜WgÁ‘0ïÁŠÉÁƒSÁwñÍÁiéZÁ\ÒÁN_Á@¶èÁ3;‹Á%ë(Á¹FÁ ·NÀýÊYÀä@íÀÊÏ×À±¥À™ @À€ŒÀQwZÀ#"“¿ìÄ¿”m±¾ýÈ >$ö‰?MM½?¶xy@&H@ ½‚@'±£@!ˆ,@»?Æe&?gMª>uÍê¾á­¥¿v1¿ê±À"ÁÀQ«¶À€ÄÞÀ™š‡À²l½ÀËzãÀäïìÀþßvÁ –>Á»Á'êÁ4³”ÁB`µÁP%Á^CÁlºÁz:Á„6Á‹#©Á’@9Á™\Á ƒ{Á§»úÁ²$¢ÁªÞ´Á£ ¼ÁœYÁ•ÁéñÁ†Â~Á7GÁpó=ÁbÐRÁTºlÁFÁ'Á8äØÁ+0PÁžøÁ*íÁñ#Àë’ÀѬšÀ¸2Àž‡À…bÀX„wÀ'[B¿ïD…¿‘ÕоßP1>€-?jˆÔ?É|@ þT@4j)@Y¨­@gP$@]Á]@:ƒ2@ï?Ò&|?uþT>Ž©0¾Ø<5¿âƒ¿ïÏòÀ(BPÀZ²À…è;ÀŸ4«À¹ ¶ÀÓMšÀíŸÁ­ÁžšÁN¶Á- ©Á:Ú½ÁHÒÛÁVØmÁdãBÁsëÁ€§sÁ‡Ä#ÁŽîüÁ–,žÁzrÁ¤ÐÁ¯wŒÁ¨Á ºIÁ™m¹Á’%ÁŠÜƒÁƒ—•Áx¹ÖÁj`DÁ\üÁMÉ®Á?˜Á1Á#› Á´‘ÁþÀõÀÚPªÀ¿þ3À¥¶QÀ‹Ô¾ÀdŠ À1¿þw©¿›J¾î_µ>ˆ[n?xåV?Ô¸@ý~@>´@f©9@†ÞG@“Œ4@‰†ï@l _@Bþr@<?×ÊÉ?}0œ>‹Âu¾ñõ¿øªÀÏ·À2õVÀfÉÀ}§À§¼2ÀÂ6ÓÀÝ/ëÀøymÁ ö“ÁÂoÁ%ž™Á3¡ÁAªÖÁOàÒÁ^Ál^aÁz¸(Á„ŸÚÁ‹õyÁ“S¦Áš¥tÁ¡úÁ¬ë‘Á¥‹.ÁžüÁ–µQÁSAÁ‡ùÁ€¨ØÁrÀÒÁd7—ÁU¯ÞÁG@MÁ8òÖÁ*§ÁkÁnÄÁv2Àå*äÀÊ<À®Ò—À”iiÀsÍNÀ?ÁìÀ þ£¿±ß‡¿v:>7ÿä?p)T?Ö»@~¶@D·˜@oXÇ@Œs5@ *@³n÷@¢Æ–@ŽA6@q8¨@Eõ£@ŸÕ?Ö-?mªÆ>$šZ¿ qŒ¿·4{À‡NÀCåîÀxàŠÀ—‰xÀ²‰ÎÀÍ¿4ÀéoŸÁ‘CÁksÁs§Á,¯Á:úùÁILÊÁW¦¤Áf0ôÁtèÖÁÓbÁ‰1*ÁŒ3Á—ô™ÁŸkDÁªyÁÁ£cÁ›£gÁ”0ÒÁŒÀoÁ…VuÁ{éIÁm&$Á^kNÁOÐdÁAG¼Á2¹^Á$:OÁëÁŽ.Àò•#ÀÖ{ÀºŽûÀŸÐÀƒ¾ÈÀQ©@À˜5¿Ð6|¿PF+»¤Ïó?JÞ?É%T@¯„@DõM@räÍ@‰p@¤Äõ@¹}ž@Ìy•@ºô{@¥§X@¬@sز@D˜‹@?Åxn?>$½Žö¿b ȿۢòÀ#¸pÀYßVÀ‡ûuÀ£[ËÀ¿"ÀÚÄ“Àö²÷Á š¿Áì¾Á&>Á4—#ÁC&5ÁQåÜÁ`­&ÁojÁ~4ÙÁ†qÁŽ ÕÁ•OÁeÁ¨0nÁ ³hÁ™:…Á‘ÄÎÁŠQÁ‚ÞjÁvÖ|Ágó—ÁY,>ÁJgëÁ;Á,í¥Á_@ÁÅ^Á7‹Àå§1ÀÈáaÀ¬X1ÀKÓÀhƒhÀ1ÂÊ¿öED¿‹þ¾‡SÕ?gW?¯ @ MÁ@=¥V@o¹@~n@¦¥r@¼·@ÉñŒ@Ë&[@ÊÞ @½%@¦Û›@@mŒ@:Ú@OÊ?¤G>èҾĿ+ ÀØ3À;h—Àr-À•ïÀ±TÀÍ5öÀ鹿Á/ùÁÁ !©Á.çœÁ=±mÁL| Á[`ÔÁjbÁy{•Á„RµÁ‹ÛåÁ“eÁšñ6Á¦-‘Ážœ=Á—ÅÁÁˆ+Á€‡ØÁr £Ác!½ÁT6]ÁEJýÁ6nÕÁ'¤ ÁÙPÁ ùÀöðöÀÙÀóÀ¼¦ÝÀŸÙ´ÀƒïÀM8ÑÀ Ù¿º+æ¿U—>€•?Šq_?ôÀ1@/HZ@c©@‹#~@¤3±@¼“Ÿ@Ƨ@Épk@Ê÷@Ê©S@Æç+@»Ëy@¢f÷@ˆ³@\ÁÝ@'wf?ä6h?q•=ÃŒT¿BÜ¿Î@À×8ÀVýôÀ‡›ÛÀ£ÕvÀÀ±€Àݽ.ÀúÎeÁ nÁãgÁ)ºÁ8¸gÁGÕ³ÁWÔÁf2NÁu`ÙÁ‚@vÁ‰×@Á‘wˆÁ™äÁ¤JMÁœ°äÁ•#ÁƒuÁ…ðãÁ|ÏHÁm¿ôÁ^°´ÁO¢‹Á@­ÒÁ1ÀãÁ"ÅÁÞnÁœÀì{OÀÎà"À±wÀ”•ÀmíÀ4*G¿ôÌ-¿ƒR¦¾Eª?9c ?Êx†@ @Pk#@‚®7@ @¶!@¿pc@ÅÌô@Ê‘t@Í;ß@Ë‘@Æî¯@½ük@±”'@˜f@|Ç@Fw}@Æ?´´?•x¾žÉË¿˜t;ÀcÀ>,lÀw‡ƒÀ˜ÓLÀµ× ÀÒÛØÀðB²ÁÜÁH½Á%Œ(Á4ÑÐÁDÅÁS,:ÁbXgÁqšžÁ€yåÁˆ.½ÁèaÁ—¢:Á¢·¾Á› çÁ“l†Á‹ÍžÁ„'£ÁyÁiØåÁZÄ ÁK¥‘Á<€oÁ-cÛÁ`SÁW!ÁMîÀâ¶.ÀÅÇÀ§WðÀ‰¸°ÀX¿ÎÀÙ¿Ç1è¿'x>y†?sB@~Ø@7â/@nï%@’:.@§Lû@´Mb@¾ïÈ@ÇÊÌ@Í/ü@Ðb¡@Îïm@Ç׃@½™Q@°¤­@ FÞ@Œä@bë@,Ep?é¦a?vL™=“Øø¿R—f¿Ü«À(3£Àb«ÀŽ‘2À¬ÀÉéÄÀè<Á`JÁ¢äÁ!åÁ1';Á@g{ÁOÂ%Á_0fÁn¢+Á~ïÁ†ÂàÁŽy”Á–0°Á¡SÊÁ™ ¨Á‘îbÁŠ>WÁ‚£ÁuÃîÁfk ÁW†ÁGä‚Á8ÀÁ)›úÁx)Á ZŒÀøµÀÚ¼,À¼«iÀžn(À€¥µÀEä¢À g뿞xš¾¥±i?’”?¼ôm@Th@O•Æ@‚Àþ@•)ƒ@¥ ½@³“@À­@Ê—Ë@Ñçh@Ö#"@ÒñÆ@ÊI @¾ “@¯k@žLw@ŒKW@oï@@?i@ $°?£F>»ù¿ cö¿¸+…À%úÀQª]À†—úÀ¤j‰ÀÂËDÀár‡ÁLÁdFÁ»\Á.&YÁ=£ ÁM ûÁ\Ÿ–Ál½Á{žUÁ…•ÁUÁ•«Á >Á˜„‰ÁË=Á‰)Á['ÁsK@Ácà”ÁTv]ÁE_Á5¿\Á&†“Á`žÁC¬ÀòOÉÀÔ’Àµå\À—±`ÀrÚÙÀ6¿õ)ô¿~»£½Ì~?WŸÕ?ÝÑj@&„@VÂ@¯F@’—@£=@³f@ÂTz@Ï@ØÇ/@Ý7@Ù0‰@ÎEE@¿Z1@®s‘@œü@‰"F@jÏ@@@ë@Dž?¶ &?Fs¾§¬o¿ž>À UïÀFt.ÀM¨ÀŸŸCÀ¾O·ÀÝÅÀû¿žÁ <»ÁŸÂÁ,=Á;šWÁK&ÁZº ÁjT¥ÁyôŸÁ„ËÜÁŒ;Á”mˆÁŸ…FÁ—É/Á öÁˆLdÁ€ƒ/Áq Áb„ÁR˜ôÁC7!Á3ä»Á$YÁ :ÁºÀìÛ‹ÀΤ À°”µÀ’…âÀiLÀ-пâB¿Tý[=‹ru?vì±?æ_@"s@Mß7@vAœ@ŽÓ @¢ á@´O”@Åx†@Ô´0@á''@æ›­@àÜ@Òÿ}@ÀŽH@­E«@™V»@…r7@b@;@7tK@ Y±?³Áf? ?¾J'¿•QÀ©ŠÀ@½ìÀ|dÀœ¶ŒÀ»HPÀÙâ™Àø„¾Á Ÿ‰ÁUÁ*±<Á:NÜÁIíŽÁYÁi-MÁxÎ Á„7 ÁŒ œÁ“ÜõÁ›æÁ–ë³Áz!Á‡²EÁÕäÁpHˆÁ`¼ºÁQ: ÁAË»Á2l{Á#:Á¾ÁjfÀêcçÀÌGŠÀ­·]À¦ÀaÕÔÀ'¸u¿Ý¿U‡=UÜj?] ?ÐMµ@Ðí@A@mÇ@ŒLÇ@¡×ð@¶%´@Ê=¡@ÛÒÕ@ꃿ@ò^@é&Q@Öä@ÁÚ~@¬ºÉ@–ô?@›T@WVŒ@*òàîH¾º±ž¿œºÀEÍÀ@hÀ{ŠXÀœ7þÀºÞkÀÙŽOÀø>2Á >Áý¸Á*‡õÁ:2ÁIœoÁY&±Áh³ÁxG’ÁƒôvÁ‹ÊÁ“£yÁ›jñÁ”®4ÁŽ Á‡iÁVpÁoߨÁ`móÁQÎÁA–úÁ2eÁ"¨.Á3ËÁÛÀé^tÀË÷À­ÈBÀí”Àe)“À-¹>¿éÕt¿y<­¾>O?÷?­C”@¦@5‡@c“~@Šq2@¢¨ @¸À @Ï6®@ã*È@ôÍ$@ÿjQ@ð\@ÙôI@Ã$¹@¬;&@”ô›@{5ë@Llƒ@@m?Ø+Ã?oPm>2Àv¿bD¿²ê À6 ÀI>`À‰ëÀŸIÀ½¿ÀÛ›Àù>ºÁ íçÁ`7Á*ë¤Á:|~ÁJ ZÁYž6Ái/Áx¿CÁ„+-Á‹ûÁ“BìÁ™y¡Á’²šÁŒ œÁ…tmÁ}öKÁpB¶Á`áÏÁQ‚ÇÁBÁ2»ÝÁ#l Á34ÁìÀìJ†ÀΊÅÀ°Í×À“}—Àn‚kÀ7õ’Àž›¿ž_þ¾ìþ>¡œê?‹F?ñ¤`@,l@aØB@‹wM@¤ZP@¼ÛV@ÔçF@ëW2A*A_3@õ‹Ò@Ý–³@Å}@¬y‚@“p’@tù@BäR@¹b?ºš~?#»¾ få¿g08¿×W¡À ?œÀW‘À‡ïÀ¤)4ÀÁŒ Àß[¸Àý?uÁ Á•ÁÑÁ,{ãÁ<¾ÁK~ÁZä?ÁjXÁyÔkÁƒÕÏÁŠbqÁ‘1Á—äÛÁ‘ ìÁŠP“Áƒ¸šÁzl¡Ám¹Áa„ŽÁR©¬ÁCZ Á4(dÁ%Á,ÄÁ=õÀðÇ“ÀÓ‘ŸÀ·$À›åÀ~?=ÀH¿ºÀÂp¿Å1€¿?´^=­—Û?fÒw?äˆê@*ª7@bbä@ŒF¶@§T’@ÂE@Ûý@óœA;A Ä\@û'p@âk@È“á@®³>@•¯@u®ú@@'M@ |Ž?¦^ö>Ûà.¾Òäï¿é.Àh©À5½ƒÀiMÀm–À¬€èÀÈ”9Àå ÝÁ"#Á ¢Á'•Á.`%Á=¢òÁLí³Á\?6Áj+<ÁvÒ;ÁãÁˆ†mÁMgÁ–¸¯ÁÐtÁ‰«Á‚`Áw´XÁjäêÁ^PÁR–>ÁE,Á6BÁ' íÁWáÁ Ã9ÀöæñÀÚ{lÀ¾OÐÀ¢ò3Àˆ ¿À[‹ºÀ'D¿ßW<¿aÈaºÁŠ?dìB?ç”L@/eÄ@hûS@‘a@¬øá@Èæ@ã‰@ü¾nA Š·A ”A±$@ç'–@Ìv@²Â@—c:@x)m@@É3@y0?œ7u>¡Š1¿•t¿½ºgÀÕ ÀL%À€ ÓÀšƒÀµnKÀÑ;NÀí{ÃÁ&ÕÁÆ2Á"ÚÁ1t<Á@q“ÁN£”ÁZ +ÁfóUÁs²OÁ€gLÁ‡OÁõˆÁ•÷‘ÁÁˆ2#Á€¦ÁuîNÁiÜÁ\˜\ÁP“|ÁE®Á8¿Á*’Á‹™Á XCÀþk±ÀâTDÀÆèÀ«þ–Àw©ÀhlÑÀ+›ö¿ÞhпN¶9>˜Y?ˆŽ?ÿ°@­Âþ¿j¿Å:rÀólÀ[t*ÀŠØ»À¥ÍRÀÀ„#ÀÛfÈÀöÛiÁ o£Á´’Á&+@Á4Õ§Á@¿üÁL;´ÁXE¦ÁdºãÁq—ÜÁ~¼®Á† ÁŒìeÁ•ÁŽ«¶Á‡ÕÁÒÁu 7Áh[ëÁ[ØÁOÈÁDHeÁ9såÁ-È‚Á_^Á>ÀÿéÅÀἡÀÚzÀ¥eºÀ‡0úÀQÃ?À¾/¿¶}ü¿ºî>àgf?­š5@œ¡@L>ä@ƒØÒ@ Ûr@½’‹@Úo@÷u€A HÇA2A7dAÌ@öŽé@Û‘@¿ @¢>”@…l;@Q¯é@¢ø?¹®/?ãR¾àT¿®Ç1À6)ÀP9À†žyÀ¥XAÀÄXËÀã.Áð˜ÁÏ'Á’ÔÁ* Á4&ØÁ? œÁJ¡óÁVÁiÁc-ƒÁp¦Á}2IÁ…W ÁŒ.ÔÁ•Š$ÁŽšêÁ‡É³ÁAÁu)ÀÁhUÁ[â±ÁOìõÁDŠ“Á9ÖPÁ*6RÁ’‹Á ï-Àö¥÷Àצ{À¸þÀš»^Ày-À<å9À{¹¿ˆ$q½ï*!?LB?ÛÈ@(O@czd@jb@«÷E@Èúè@æóA6ÏAHGAíhA]¬A Ä8A*@äÉZ@ÈWt@«æ @}ü@d!i@)(;?Ûûõ?J“Ö¾#z´¿¦çÀ…ãÀ?ß›À}aMÀqÀ¼0ÁÀÚûÛÀú CÁ ¦BÁQCÁ)¦Á3ÃÐÁ>°>ÁJ5dÁV%Áb’÷ÁoYsÁ|n Á„é­Á‹²,Á•ÔƒÁŽî"Áˆ&&Á€VÁveÁi]JÁ\úÄÁQÁEøÁ6 £Á&ñêÁGqÁœùÀïåÀÐ’'À±EßÀ‘ÿÀes&À'B¿Ö:Ñ¿;ƒ©>V¨?“¨@=‚@AIÂ@{Âl@›‹@¸˜¼@Õ0@òuá¿PéN¿ãÀ4À/§Àmn#À•ÉvÀµÿÀÔn‰ÀóÔ°Á ­ÎÁ|¿Á)SóÁ4˜«Á?XDÁJµÁVsÁbµ&ÁohfÁ|uDÁ„ÛšÁ‹ ŽÁ–ožÁ²ÁˆÑ5Á‚6 ÁwŠÁk Á^ú~ÁS8ÁÁD#©Á4@Á$_TÁÄÁ¦TÀé«WÀÊ#ÐÀªÂ À‹mÀX0UÀ†s¿µ¹!¾áüô? 7b?¾]†@l @W¿ž@Šâ@§Ë–@Äýó@â:H@ÿjêA pA?ÙA*‡vA'~ÑAµ©A ë©@ûäm@ßu@Â@U@¥ à@‡5{@R)T@Uî?­ €>ÅÝý¿-¿Æ5ÝÀ"$¤ÀaèÀ'À°7øÀÏòŒÀï®/ÁµAÁ“¨Á'r:Á6AãÁ@éµÁL óÁW³ÝÁcä¯ÁplÁ}N3Á…BáÁ‹øýÁ—hÁž3Á‰ñøÁƒeSÁzÚÁm©|ÁaÀÁRXÁBhùÁ2{òÁ"’LÁ¬zÁÇLÀåÄ;ÀÅùßÀ¦3´À†qTÀM]éÀ Ù*¿œ¨Õ¾tÛ?=¥S?Ü&o@,½@kfý@”½}@²á€@Ñ §@ï%¦AnA¬tA#.A1w´A.FàA ‹jA‹"Akd@ë¬ÿ@ÍÇ@®Ü­@òQ@aÎã@"6?Ä«? cx¾és¿¹ÀõÀvœÀ[ñâÀ¶”À­t7ÀÍ;ÀíÁy-ÁjŒÁ&[ëÁ6MJÁCA ÁN2XÁY—tÁe‰nÁqókÁ~¶¿Á…ÝÁŒ†/Á˜¥¯Á‘ê5Á‹P‚Á„ÝžÁ}.ïÁqÌÁaPaÁQYÁAaÁÁ1jqÁ!s!Á{ÐÁ„€Àã`ÀÃ+ÀÀ£= ÀƒNÀF¿¾Àâ}¿Ž ޽ë.È?`Í?ïoÿ@7<¿@vÁ~@›#@ºÖq@Ú+b@ù€SA AÔA)Ä­A8KMA5j8A'fAŒA v@òVx@Ò|§@²¢Ö@’É@eÞg@&*Å?ÌîE?¾Ç¿±IªÀf!ÀX>–ÀŒJÀ¬•ÀËùÀëì†Áð ÁéØÁ%ã¨Á5Ý{ÁE×OÁQ.‡Á\l%Áh8^Átb©Á€vhÁ†ê\Á†ÈÁ™òõÁ“TiÁŒØPÁ†…IÁ€CÁp‹EÁ`‰ÁP“ôÁ@˜Á0^Á ¢2Á§Á«ßÀáasÀÁk1À¡týÀ~ãÀC÷À'¿†þ½X–$?qëŸ?ø°P@<5h@|©@÷õ@½æ•@ÝÕ5@ýÃÕAÙ;AЋA.¹TA>™¾A6cA&ÌAœAlš@ï4I@Ïó@¯ð @R¤@al@"y?Å)|? ž¾æ-׿¸åïÀ 4À[ÍpÀ½VÀ­“õÀÍj“ÀíA1ÁŒ»Á|±Á&o»Á6e ÁF\ÁUYÁ_þ™Ák0ÁwšÁ‚ÌÁˆA‚Áެ(Á›bhÁ”ïæÁŽ–AÁˆ?Á€C ÁpŽÁ`–ÒÁP ¡Á@«ËÁ0¸«Á ƱÁÔ¸Áâ¿ÀááŒÀÁïñÀ¡üºÀ‚ „ÀD,šÀF-¿ˆ¿€½*S?m´j?ö§@;9õ@{ b@ƒh@½fŒ@ÝØ@üÇA>AWA-àRA:ƒÇA/tóA!ŸÆAËAäV@éÕ@Éâ¡@ªˆð@‹Cã@X @Žy?´Êê>Ùb¿3¼¿Æ™IÀ"°ÒÀbÀ¼—À°n®ÀÐ ÅÀïÒÜÁ¯ÁŸ$Á'~ÞÁ7aÁGEÁW+ÿÁdV‰Áo†Á{,°Áƒœ¢Á‰Ã®ÁÁPÁ–¨ŽÁ`žÁˆg¡Á€nÑÁpì´Á`üœÁQ ŒÁAÄÁ13ŸÁ!I—Áb_Á~ÞÀã9tÀÃfÀ£€Àƒ™üÀGgïÀ›ç¿ÇJ¾ì?[}(?ìÆ@5 |@tëÀ@™ñÖ@¹Xj@Ø­þ@ø’A ¢fAaA(WíA*ÔîA&@¼A[FA öI@ûÁÓ@ß@Àú¢@¢¬ê@ƒîV@J_†@ ^#?›µ“>uâ2¿1ÁMÌ`Á]vÁm+.Á|é´Á„çBÁŠ}ÁF0Á–>NÁ¡ë›ÁšÈÁ’"œÁŠ?6Á‚\¸Átö¡Áe6oÁUy;ÁE¿=Á6 ˆÁ&\šÁ·’ÁàÀîýXÀÏÄïÀ°Œ‡À‘ZÑÀd²•À&Õb¿Ò •¿-,Ê>‘AS?,@ Çã@FDé@€³t@œò‘@¸{á@Ðd•@âÉ*@ía/@ô*@÷…Ó@÷Rœ@ï8í@ÜIõ@ŧD@­[i@“z@qE@;ký@Ý?”õ.>‡{¿"³¿ÈxâÀ °qÀ]#”ÀŒË-À«dñÀÊ#„ÀèØÖÁ®´Á Á"•‰Á2-MÁAÉÃÁQcìÁ`æ¶ÁpiÁô[Á‡ÆgÁGÁ’ý-Á˜ÔKÁ¢ßWÁ›fÁ“)1Á‹QÁƒwÁwAÁgžzÁWüßÁH[`Á8½úÁ)'"Á‘¡Á ü ÀôåÄÀÖÃÀ·vfÀ˜Ÿ¸Às’À6=¿ó¹é¿wj"¼ì4?eö?çªÇ@-Ç@dÛ@Œšç@£è@¸/"@ÅÎ*@Îÿt@Ôå#@Ø$Î@×ø´@ÑCS@ï×@¯[@˜á”@€°@O ¿@`Ç?Ç?1Ú¾>מ¿‰Ü¿üCÀ7½±ÀrDýÀ—M,Àµ‡,ÀÓÀ_ÀñüÁ@òÁŸ£Á&öyÁ65îÁE!ÁTý!Ád€æÁt¬ÁÓ’Á‰•„ÁTÁ•ÙCÁ›•¹Á£ßdÁœžÁ”ICÁŒƒâÁ„ÂPÁyúýÁjmŸÁZØÁKBÁ;³SÁ,8ÁÖÓÁ ˆÈÀüuáÀݬÀ¿®À¡ ÍÀƒìÀJZÀw$¿§Ýˆ¾Î´u?›?®@ J€@@]Û@oË@ŒŒ=@œöW@¨ˆ@°‡s@µ£L@¸Å_@¸È@³)©@¨Üˆ@—6Ž@‚ú@X7Ç@("i?뺳?ƒ «>:iŸ¿(÷Ó¿Ä”/À»ÀS”CÀ†™<À£gPÀÀvÁÀÞF6Àü| Á [ÁwzÁ+–}Á:ÓÆÁJ-…ÁY€†Áh¾¹Áx ýÁƒ¹Á‹sûÁ“68Á™ôÁž¦Á¤¤2Á]IÁ•¡6ÁêøÁ†2™Á|èaÁmpšÁ]ý ÁNdÁ?X Á0Á ÔÁ—ÖÁ}¼Àç9ÀÉÀ«ŠÀy?À`ÎÜÀ&Í1¿Ù¢ä¿Uñÿ<Aå?Z´?ÎÙÊ@P@@¸H@dÒÛ@€æ@ŠP@‘£@–jý@™†œ@™ž@”ìÎ@‹¯B@|6Þ@U®–@+ÁS?ýrE?ž+>ä6¾µ­v¿˜i°À”À8ì§Àq[À”¼¬À±GÔÀÎ(Àêë%ÁóÕÁ¹¥Á!¸ÿÁ0ÕŠÁ?òŠÁOÄÁ^.ûÁmiÁ|»Á†JÁ¤Á•IÁœŒàÁ¢ @Á¥!—ÁžÐrÁ—%ÈÁ|'Á‡ÔôÁ€-JÁq Áa×7ÁRºöÁCœ¦Á4b½Á%G$ÁNÀÁ\“ÀñŠÀÓÜ®À¶ÈTÀ™Á,ÀyÕ®ÀBpÀ µ¿«¥Ú¿ó>xm?w$Ü?ÐÀQ@ ¹Û@-¹F@EЬ@Wí~@e})@n¦Q@tÉ@tè'@l~a@[‡«@D $@$ª?ú Ÿ?¤Áe?C˜¾"Þ‹¿rì ¿Þ$~À$L<ÀYïÀˆ —À£ÐBÀ¿ãOÀÜãÀøÆ&Á ɘÁ3Á'¯øÁ6b3ÁEEAÁTP ÁcmÁrŠÁ€ÓÁˆc½ÁÿµÁ—¥÷ÁŸJTÁ¤È›Á¥ûÒÁ P9Á˜êûÁ‘R™Á‰»6Á‚&DÁu1ÁfÁW ÁHÂÁ9|Á*H³ÁŸúÁ =Àý[Àà ÝÀÃuzÀ§¹ýÀ‹ðÅÀaQ1À-rj¿ñ“¼¿‘•¾ÕíK>€V?\q?±À»?èÑ"@ M2@@c@'æ @0w@5­}@6I"@/#'@¢@ ò\?à Ï?—–T?l!½ßýÇ¿P]Y¿Çr’ÀÇèÀHR¶À|ŒÀ˜ñeÀ³×—ÀÏa_Àë*1Á¡8ÁÈ!Á "<Á.‡Á<ð›ÁKjPÁZðÁhâÃÁwÖ Áƒs¿Á‹?Á’²Áš­Á QÁ¥ŒHÁ§2×Á¡jGÁšÃ[Á“>Á‹ÂÔÁ„P¢Áy­åÁjÍ„Á\ÐÁM:oÁ>zžÁ/ØaÁ!T&Áþ2ÁåÀíæÀÀÒÀ¶W À›ötÀ‚ ÎÀP²“À!ZÚ¿æ­ö¿•I¿0Æ=W¢²? ô?kö?ÎW?½©¤?ÔEÌ?äœ?î“?îÓµ?âýÚ?ÇŒ—? ›^?]“>È/¾H•`¿Ró¿ÀÁÀ ’À=DªÀnÔÈÀÌ=Àªg¥ÀÅUÀßÂÆÀúúÀÁ ]§ÁBÊÁ'PÉÁ5ƒÁCáeÁRD¡Á`® Áo%›Á}ÆÈÁ†ETÁµæÁ•4±ÁœYÁ¡PâÁ¦„Á¨‡˜Á¢Ã”Áœá²Á•|4ÁŽÔÁ†¬UÁ~‡ÁoÉåÁa%ÈÁRŸ‘ÁD=âÁ6¿Á'øÁêÁ äÈÀü6¾Àá-HÀÇptÀ­×YÀ”G)ÀxÙ‡ÀKR·À bJ¿ð‚Z¿¥íÿJm侸Uò:°‰Q>™2ü?§?0¬ø?OÉa?cc5?d>c?MÿÞ?,7>¦5¼·V¾á.[¿{Ìj¿É»¬À ×(À9Á/ÀfçÏÀ‹]4À£ðeÀ½7‹ÀÖµ(Àñ+šÁá$ÁMÁ!&5Á/ žÁ<ñLÁKÁY@{Ág ŽÁvÙÁ‚5ÒÁ‰p½Á¾ Á˜ŠÁ¸´Á¢³ÿÁ§Ü:Áª(ýÁ¤|‹ÁžÂpÁ—èNÁŒ7Á‰:-ÁóãÁuxÓÁg,NÁXù5ÁJÉáÁ<·ôÁ.Å(Á! dÁhÚÁDÀò¢iÀÙeeÀÀ7,À¨,™À‘Ì$ÀwϰÀOç­À)K±ÀÖJ¿Ô-/¿ é¿m$x¿$¤!¾Þ=¾ŽcO¾"ò0½¯­~½¦ƒÍ¾'ïß¾®À¸¿ n¿k|€¿©¡‹¿åxRÀé{À=9>Àg-À‰Ž\À (À¸ óÀÐ5áÀéx.ÁqíÁƒÁâ´Á)1\Á6ÎÁD¹ÐÁR¥~Á`ŽêÁn¬éÁ|þeÁ…¯ÜÁŒáÁ””ÁšdÌÁŸk.Á¤uÏÁ©’UÁ¬@Á¦tÁ Ä¶Áš~Á“K´ÁŒDÁ„òÁ{ªôÁm´Á_{€ÁQšÁC÷jÁ6Q%Á(¸ËÁ‹nÁæÕÁYýÀëˉÀÔ)¨À½å½À§Þ¤À“ äÀ€“À]кÀ>À!èOÀ Þ¿í O¿Ì±…¿²¹(¿Ÿˆ#¿Œ¿ˆQ¥¿†ï«¿‘ˆÁ–+9Á0ÁˆVÁÁtVÁfƒæÁX÷þÁKƒ½Á> uÁ0þÁ$fTÁ÷êÁ Í€Á-ÀéœUÀÓÙCÀ¿UîÀ«Í§À™óÀ‰:óÀu›`À[bTÀDµcÀ1·'À#À3“À ¿ËÀ\ïÀ‹ìÀ»ÀMÀkÈÀxÀ17.ÀFºaÀ`cÈÀ“ÌÀsÀ£ytÀ¶üqÀÌÀâ£uÀù4jÁ¦»Á‘¹Á ü¹Á-¨gÁ:ÁG·‚ÁU(ÁÁb]Áp‡Á}ëáÁ…ï»ÁŒéaÁ“êæÁ™ÊCÁž‡QÁ£cDÁ¨n¬Á­ŠéÁ°lcÁªäÁ¥f]ÁŸÜÁ™YõÁ’_«Á‹vÁ„Á{s5ÁmüÜÁ`¥ÁSjÀÁFvÁ9ìVÁ-¼SÁ!¤ÇÁ¬Á ­âÀÿ¸ÀêØžÀ×UÀÄþmÀ´"TÀ¤©À–uÀŠ|„ÀéßÀmÕWÀ_Ç[ÀTŒÀK¨dÀDsÕÀ@ÊÀ?äÀDïïÀMT˜ÀZ‘²ÀlzÀ€µ»ÀŒNÕÀšåPÀªöùÀ¼ØÀÏ–¸ÀãMYÀøÿ‚Á‰uÁˬÁËÈÁ*ÛÅÁ7°ÁCÅÕÁP³.Á]·ÁkåÁx~Á‚ó“Á‰Ë4Á¿ZÁ—¯kÁœC^Á ÜÁÁ¥¥þÁª¬êÁ¯Ü¿Á³¦Á­—öÁ¨&ÖÁ¢°ˆÁœ­ØÁ•ÑùÁŽúÎÁˆ2zÁŒdÁu÷mÁhè'Á[òÇÁO[½ÁC1Á7\ÏÁ+ãÁ |.Á #Á MŠÁ\yÀðA7ÀÞÁsÀΖ¹ÀÀ/åÀ³EÀ§:KÀŠÈÀ•.#ÀŽ\ÀˆòÄÀ„¬ÀE^À~Ö1À}ï.À['À…oŽÀ‹raÀ“Œ™ÀµxÀ©.À¶ìÀņÀÕà<Àç¿qÀû³ýÁÔ·Á¸ÿÁÁ0Á(þâÁ4éÁA2ÁMNÕÁYÙdÁfà ÁsÉgÁ€uúÁ‡"ÁÈZÁ”½Áš‚°ÁŸÁ£Œ½Á¨BiÁ­4Á²D€ÁµÞ"Á°j%Áªú*Á¥«Á ?Á™_tÁ’´žÁŒ"Á…ˆÁ~$5Áqd9ÁdÑýÁX¦/ÁLøîÁA¡aÁ6M’Á+LeÁ ùÜÁƒÁ ÈIÁȤÀøÃ™Àê5ÀÛØ'ÀÏ´ÝÀÄœÄÀºü×À³_lÀ¬÷À§žâÀ£„7À 0ÇÀž“‘ÀýÀ R—À¤0•À©Ä¥À±šÑÀºµÈÀÆÀÒ ^Àà,ÀïñNÁ“ÙÁ ÆÁß÷ÁÿÁ(ñ­Á3øëÁ?3<ÁK‡ÁW:iÁcn"ÁoÐÔÁ|’QÁ„ÏŸÁ‹bÁ‘ÿ7Á˜–`Áv_Á¡ï°Á¦‰Á«-|Á°VÁ´í³Á¸ÞüÁ³vÁ®$Á¨Ò Á£r£Á#²Á–¬oÁ'xÁ‰»öÁƒpÁzrÁnN½ÁbšÞÁWIÁLšÁAÁ6§±Á,ÞÁÁ#F‚Á<ÛÁ±Á ë×Á¶,ÀøçÀìR;ÀâðÀØÇOÀÑwÒÀËXmÀÆHáÀÂ\_À¿ ÜÀ½°ØÀ½ÜÀ¿:áÀƒëÀÈ"ÀÏxRÀ×ê®ÀâÓäÀîPÀûÉÁ-1Á ‹½Á>iÁ°uÁ)Ù©Á4"•Á>õ¯ÁJÂÁU`ÀÁaÊÁm4üÁy‹-Á‚ê¤Á‰:,Á°kÁ–'áÁœ`ŒÁ µÁ¥~Á©ÿÁ®'þÁ³hÁ·ãÍÁ¼ðÁ¶ÀÁ±Á¬>„Á¦ë˜Á¡CÁšØ¾Á”u‡ÁŽ,wÁˆ¯Á‚)ÁxH®ÁlÉÁa®mÁVÉíÁLCÁBuÁ8ëDÁ/¡ìÁ'FÁÍ9Á‰ÁrMÁ FÛÁÛÀÿdxÀöÓ¯Àï”ÆÀéâÀäòàÀá]ÀÝê[ÀÜ–lÀÛæ*ÀÞßÀàðÂÀæ{!ÀíTˆÀõ™2ÀÿºÁ{DÁ æÁ¼ÁulÁ#)«Á+þÎÁ5ŸúÁ?ÛSÁJ&ÁTñiÁ` øÁkykÁwÈÁ‘vÁ‡À¼Áî$Á”;ÁšuŸÁŸÍñÁ¤ Á¨]HÁ¬ÄÇÁ±TæÁ¶!ÀÁ»ÞÁ¿xªÁº0õÁµ Á¯îvÁª«ÈÁ¥0ÁžÿìÁ˜Ì|Á’²ñÁŒÃSÁ†ó8Á,<Áw3QÁl|“ÁaìÁWæÐÁNvºÁE·ÁíÁ%)?Ák[Á-Á+ÁX–Á `ñÁãôÁ2íÁ¿Àÿ“€Àü©‘Àû€ÀúÅiÀüáLÀÿ†´ÁlyÁšyÁ µÁS¿ÁÜuÁÐôÁ ˜#Á'²RÁ/ìCÁ8¹1ÁAÀÎÁK‰œÁUÝÁ`)™ÁjîbÁvÑÁ€É Á†–LÁŒ‹Á’˜”Á˜ÉùÁžÜrÁ£jºÁ§‘`Á«Ð­Á°G½Á´Î4Á¹„ Á¾rÁÃNÁ½àéÁ¸ÇÐÁ³°ßÁ®Œ¸Á©;Á£d Á`ÍÁ—{‡Á‘¹ªÁ‹óÒÁ†[ÇÁÁw£âÁmg$ÁcËÌÁZ„OÁQ£aÁIBÞÁA(ÃÁ9ÖdÁ2×1Á,žÁ&Ê:Á!Ë0Á)ÁX ÁvÁNÒÁàÁÙÁ ­µÁ #MÁ ÑÁ ËûÁkÁˆÂÁ yÁƒrÁùÊÁ"=3Á'ïÈÁ.rjÁ5IòÁ<æ_ÁExEÁNZÔÁW‹Áaw6ÁkÕâÁv-Á€qîÁ†qÁ‹ÉüÁ‘‘Á—gxÁ^óÁ£ØÁ§#àÁ«U¶Á¯ŒnÁ³õxÁ¸ŠÁ½-„ÁÂÈÁÆá¤ÁÁÁêÁ¼¢ßÁ·–rÁ²•Á­K2Á§ÈÔÁ¢ÛÁœeÁ–¸ÏÁ‘fÁ‹»–Á†•YÁ~¬Áy$ÁoÛøÁfù+Á^hîÁV&ÌÁNÁGp[Á@ÆâÁ:ÆÁ5@½Á0SÁ,òÁ(O'Á%üÁ"låÁ 5ÁP˜ÁýDÁ{™Á/ŠÁ#ÐÁqüÁ ³VÁ#®³Á'[qÁ+¬¶Á0ªÖÁ6C4Áî»Á:ÑÁ7=®Á41*Á1’EÁ/COÁ-}ÇÁ,>aÁ+ÇËÁ+ŽÁ,yÍÁ-ÁøÁ/û¼Á2¼—Á6WÎÁ:X>Á?EÁDˆ ÁJe«ÁPïiÁWìÁ_xöÁgÓ…Áp¹/Áy¦UÁ— Á†•"Á‹Ì§ÁÿµÁ–VSÁ›Ü0Á¡xþÁ§®Á«E‘Á¯4ÙÁ³P^Á·«ÿÁ¼ ÞÁÀ²ÁÅ-•ÁÉênÁÎñ ÁÉñþÁÄúñÁÀ[Á»8GÁ¶=ÞÁ±¾Á«¾ŒÁ¦göÁ¡#Á›Þ²Á–à Á’>Á8€Áˆ¥Á„SkÁ€ Áx=ýÁpÂhÁiŒÝÁcÁ\ÔSÁW>©ÁR#/ÁM£tÁI› ÁF2ÁC$EÁ@¦Á>NÝÁ<¶uÁ;t.Á:éÔÁ:ß÷Á;¯ÐÁ<ë·Á?&ÜÁA±•ÁE6þÁI wÁMÍ/ÁRÒÓÁX¤ÛÁ^ÁÑÁe—OÁlù ÁtÕiÁ}k4ÁƒèÁ‡£@ÁŒwÃÁ‘x>Á–®CÁ›ÛzÁ¡2+Á¦Ÿ†Á«„ÎÁ¯_ÈÁ³ZôÁ·dÁ»¥?ÁÀ#šÁÄÐWÁÉejÁÎ(úÁíï&Áçû¾ÁâKÁÜ^âÁÖ¸ÁÑ+àÁË®QÁÆU^ÁÁâÁ»sEÁµ`8Á¯bÁ©‚®Á£ÑpÁž7sÁ˜™¤Á’÷ëÁ(JÁ‡‘Á‚ ÁyE^ÁnÅVÁdÞÁ[š²ÁRíQÁJædÁC¶`Á=HÁ7ÖûÁ3~Á/êÁÁ-—€Á,)Á+#ÂÁ+5fÁ,¾wÁ.7,Á0¬ôÁ4UeÁ8ë#Á> ·ÁEùÁL§EÁTíÁ]ÿ’ÁgÊÁqìðÁ|~1ÁƒÍáÁ‰šRÁ—²Á•œcÁ›Â Á¡¯ûÁ§¡6Á­ ÉÁ³³WÁ¹æ‘ÁÀ)eÁÅW_ÁÊ£uÁÏì1ÁÕ]&ÁÚöTÁà´ºÁéïÁã¸ÁÝ-0Á×IWÁу_ÁË×ÛÁÆFfÁÀÕ|Á»ƒ~Á¶iÁ°:™Áª:MÁ¤<@ÁžZ~Á˜ªÁ“éÁ…kÁ‡º±Áê¯Áx«ÁmŒ£ÁbшÁXmwÁN±?ÁE“Á=*ëÁ5…<Á.Á]Á(áˆÁ$/ Á b|ÁÙÁ…ÉÁDÁWUÁðÁŽÁ!1IÁ%Á*rÁ0ÍÁ75Á? öÁGÔÒÁQxžÁ[‹€ÁfÁqöÁ|»½Á„YOÁŠdÉÁãÁ–›ÔÁœˆžÁ¢‡ŒÁ¨ž6Á®ÒkÁµðÁº©ÁÁ¿öÁÅI‡ÁÊ·ÁÐMÏÁÖ `ÁÛéñÁäaKÁÞKGÁØBÁÒOòÁÌtâÁÆ«ÁÀöËÁ»e›Á¶ Á°£5Áª×…Á¥¥ÁŸ_Á™©Á“8lÁ‰4Áˆ jÁ‚møÁyYÁmaEÁb<òÁWþÁLg‘ÁB&sÁ8”ÐÁ/²:Á'^Á _ŸÁ! Á$ÁôEÁ$ÖÁ ¹ Á ŒÁ ¥eÁ ,ÕÁø?ÁË:ÁÁjæÁ!ÄÁ)ZQÁ1ÇÈÁ;0IÁE8}ÁO˜ôÁZ§XÁfJžÁr<‚Á~cÁ…]ÍÁ‹‘SÁ‘xœÁ—uPÁ‘|Á£ÄÛÁªÁ° MÁµL4Áº¥£ÁÀÕÁŧçÁËeÞÁÑHqÁ×B„Áß½?ÁÙÁÓ{ÁÍk5ÁÇuÁÁžÁ»ÒHÁ¶oÁ°‘`Á« ÏÁ¥rIÁŸžÁ™ÉxÁ“ý·ÁŽÆÁˆüÁ‚pÁyÿGÁnr8Áb’ŸÁVö‚ÁKËÞÁ@¯ßÁ6 !Á+öÖÁ"‡½ÁþrÁBDÁ ‚ãÁ €Á©aÀýEÀùò¦Àù’ºÀùÄÀúñûÀþôÁzAÁ vÁ àìÁÑÕÁåÁ$ÿêÁ.ùkÁ97!ÁD:bÁOàÇÁ[ÏÁhòÁtgLÁ€VÁ†s1ÁŒlóÁ’EÁ˜¹‡ÁŸnÁ¥ïÁª¨LÁ¯ÿ×Áµr÷Á»KÁÀÂbÁƧ…ÁÌ¡WÁÒ¡QÁÛ?†ÁÔñÇÁÎÂÁÈ­LÁœœÁ¼£ÔÁ¶ÁbÁ°ómÁ«FŸÁ¥ÀwÁ õÁš<íÁ”g|ÁŽ•ºÁˆÌ£Á‚ö5ÁzgÁnÄuÁcýÛÁXòÁL,ÚÁ@˜YÁ5fšÁ*UnÁÁæÁå@Á ©SÁwÀúH#Àî{†Àä÷'ÀÝø¤ÀÚ˜—ÀÚ0ÀÚ`ÀÛ¶EÀßøÀæ±Àð¯ÀýNÛÁA[Áò¿Á¹&Á"æ©Á-ÚÏÁ9}ëÁEmoÁQ»­Á^"qÁj÷oÁvóAÁqÁ‡Š)ÁµÜÁ“õ½Á™ýnÁŸÉ!Á¥]ôÁªÜÁ°uËÁ¶.ªÁ¼‡ÁÂcÁÈ&ÁÎ#aÁÖáoÁІpÁÊ4ÕÁÄåÁ½èOÁ·ØyÁ±Ù“Á«ê~Á¦ŒÁ sPÁš·#Á”âóÁ Á‰4,ÁƒelÁ{=‡ÁoáýÁdÇÁXÃ2ÁN ÁAÅÁ5ÑÿÁ*K°ÁÁOÁ •4ÀÿÈÀî' ÀÞnÎÀÑ.-ÀÆþ À¿:þÀ»v¤ÀºþÀ»2À¼¼_ÀÁ7§ÀÈØ«ÀÓÖ˜ÀáϹÀò8 Á‘ÑÁ ¯ÍÁŽÁ#+•Á/ëÁ;rËÁGò1ÁTܱÁa°Ám æÁy)Á‚¿IÁˆð‚ÁŽÝîÁ”ª0Ášs·Á F]Á¥îÃÁ«°óÁ±‹uÁ·Á½}ÔÁÜ™ÁÉÝ ÁÒ–þÁÌ2âÁÅØÁ¿†Á¹M‡Á³&\Á­ Á§*Á¡9Á›F•Á•wVÁ–Á‰ºMÁƒ×yÁ|ñÁpjýÁdä©ÁY®”ÁN*ÁBæpÁ7îÙÁ+‹£Á‰2ÁRÁÕ÷ÀûÖKÀç*õÀÔ<ƒÀ×^À´ª9À©k+À û+Àœ®DÀ›ÖMÀœX Àž#MÀ¢ñÀ«€À·ÊAÀÇ?'ÀÙ9ÀíAäÁ_FÁ ò8Áá«Á%@Á1ÞEÁ>ÏÁKo2ÁW=±ÁcDŒÀ?÷ÓÀFÀR“ÀhpÀƒïËÀ–dÀ«"bÀ ˆÀÙרÀò¨êÁSÁÁžTÁ, eÁ7ì«ÁCÑÈÁO{@Á[.ÁfºêÁrhâÁ~SáÁ…'+Á‹>ÊÁ‘{PÁ—°1ÁžAÁ¤ZGÁªºÄÁ±*¿Á·«JÁ¾E§ÁÆ¿ ÁÀ¥Á¹lÍÁ²ãÊÁ¬lIÁ¥öhÁŸ—‘Á™N<Á“ìÁŒ¬èÁ†e¥Á€HÈÁtTSÁh;ëÁ\A—ÁP]ÁDŽÑÁ8Ó"Á-J Á!êÀÁĉÁ ²—ÁųÀêèóÀÒÑ®À»5eÀ¤6âÀŽ=<ÀtQÀO@gÀ.y«À ¿À ¯BÀ(Àm”À ÌÒÀö‰À5í×ÀXÜ(À€ˆåÀ–¾€À®‡“ÀÇPÀàªáÀùðUÁ ^ÁÁÍÒÁ!ìâÁ-¤ŠÁ99^ÁDßÁPŽúÁ\Q•ÁhAÁtDuÁ€CZÁ†‰kÁŒÞ|Á“:Á™µ©Á EÁ¦ÔïÁ­kÜÁ´]Áº·wÁÃ_Á¼QÈÁµ£[Á®ù%Á¨hIÁ¡ï†Á›qäÁ”ùüÁŽ‚ Áˆ¿Á¹›ÁvÇöÁjv‡Á^' ÁRªÁEòÁ: ŠÁ.0ØÁ"tÈÁ÷QÁ ž„Áw¿ÀêõÓÀÔþ¢À¾  À§‹ÛÀP¢ÀsûÀH¾{À",À×Ï¿Ë\ð¿®— ¿§b¿ª@½¿¸¹¿Ù‚¯ÀyÐÀ. ÚÀXR Àƒ‹£À›Ú¿ÀµPÀÍÂUÀæKâÀÿ]Á žÁKÌÁ"ë|Á.™øÁ:XçÁF9ÁR.(Á^H’Áj‘ÀÁwËÁï´ÁˆYQÁŽÕÿÁ•vðÁœ.¼Á¢ëäÁ©©XÁ°jÁ·5UÁ¿ˆ³Á¸´ðÁ±ùÀÁ«L¼Á¤›9Áù”Á—fÄÁÏrÁŠ;âÁƒ 'ÁzMïÁm‹ÙÁ`ÊãÁTS?ÁGý0Á;ÏiÁ/ªøÁ#»ÁÒáÁ Á¤±ÀꤑÀÔU½À¾ŽÄÀ¨Ñ˜À’»¬Àx‹6ÀK–®À `5¿ï…h¿©ÝÅ¿gE¿/à¿$ÛÕ¿'Ûã¿>R˜¿€­Æ¿»¸ÉÀ ÒÀ2FÃÀaÒÀ‰3œÀ¡»‘ÀºRÀÒÂÀêTÁä–Á ŠrÁK©Á$$‚Á0IÁ;þVÁHPÁT“öÁa-êÁnDÁzãÁƒþUÁбKÁ‘~ÕÁ˜KCÁŸEÁ¥ìÁ¬Í Á³´Á¼EÞÁµ]}Á®~XÁ§²pÁ öÁš>üÁ“‹mÁŒ¾Á†¯Á~ÉéÁq‡ˆÁdhÁW—’ÁJÈ]Á>9éÁ1Ö½Á%“9ÁmsÁ j™ÁxÀë‹CÀÔ¢„À¾ À§Á"À’/ÛÀyA3ÀMÂúÀ!|¿ì€À¿™ï¿"Z¡¾êÁKK†ÁX/`Áe³Ár^áÁìÁ†É4Á›ãÁ”rCÁ›VÛÁ¢G}Á©,½Á°&Á¹ŒÁ²"6Á«9>Á¤SQÁuçÁ–žÁ³Áˆà Á‚„ÁvtçÁi×Á[ÌÁN‰ÁA Á4΋Á( ÆÁ·7Á^=Á17Àî'üÀÖMfÀ¾Ó"À§¿ À‘UÀvs¶ÀK À †¿ë×x¿”;¿Âv=­ê—? ?h(„?jfJ?fÏ?E—>¹Bª¾F0ú¿]#5¿ÉPÀ ÚÀCÊõÀsA™ÀõªÀ¨ FÀ¿‹À×1ÿÀï¥Á”þÁ£mÁ¬Á(”ÿÁ5kjÁBSÁOc™Á\ÓZÁjziÁxªÁ‚ã¥Á‰Î#ÁÆÅÁ—·¢Áž«0Á¥°3Á¬¹Á¶×Á¯ úÁ¨ |Á¡ÛÁšùÁ“ ¸ÁŒXÁ… œÁ|^:Án¯¯Á`öüÁSbuÁFÌÁ8À”Á+©þÁ׈ÁéÁžÀòTuÀÙùeÀÁ{À©•À‘ôøÀu·•ÀHï\Ài¿ä.­¿Sa¾êQ¢>NYÕ?XV?µ€?ã‡?ïW ?çµ}?Êt?Œ5D>ñ®7¾d8¿pùH¿ÖmzÀ]ãÀHPÀvL3À’¡ÞÀªg:ÀÂ?¥ÀÚíÀòõØÁµÁ‘ÉÁЇÁ,{ÞÁ9¾BÁGZUÁU¶Áb¤ðÁprÍÁ~cKÁ†*HÁ õÁ” ÇÁ›6Á¢MpÁ©a©Á³:ÐÁ¬HÁ¤ì÷ÁÇTÁ–²DÁ¥€Áˆ˜yÁ“mÁu&AÁgûÁYA|ÁKˆaÁ=ÒmÁ0]bÁ# )ÁËšÁíÀø TÀÞôÝÀÅü+À­`½À”×±ÀyiôÀJLXÀØ¿Þg=¿‡Ë·¾ÆÖ¶>‰¾û?nÑó?Èo„@ u®@+¥~@5ïœ@1êª@—è?å÷n?‘Õ™>ݲ¹¾•M¿.}¿ÜŠ™ÀƒÜÀKoÀzóûÀ•~À­ùàÀÆ´€Àß×{Àù:ØÁ œýÁºÈÁ$8pÁ1ÖüÁ?vuÁMBìÁ[>KÁi1ÞÁw$Á‚cÁ‰£»ÁÀxÁ—ÜüÁŸ)Á¦9/Á°]¯Á©UÁ¡éÇÁš¹ŒÁ“ÂÁŒO‚Á…4Á|MÁn €Á`ÙÁQðbÁCã¯Á6TÁ(_•Á¶nÁ [ÝÁ ëÀæoÀÌDÀ²ÛUÀ™²À€ÒgÀPh¿ÀÕ%¿á]}¿„·¾«¿>­U?€ÃR?Õ:K@õÝ@<å¥@bšÒ@s#ü@lra@I¶œ@ zÎ?çV?Œ=•>É{2¾£æÿ¿…kE¿âòÅÀ!;ÀQŽmÀ[Àšp¦À³™ ÀÍhÔÀç¦ ÁÈÁ°tÁI$Á*aÁ8ÁF ÁTZÁaüÁp&pÁ~gÁ†Q¯Áy\Á”´ÅÁ›þßÁ£JeÁ­¥ Á¦ZÁŸ âÁ—¾XÁ‚(Á‰EºÁ‚˜ÁuŸ¯ÁgbÁY,éÁJåÁ<É3Á.³QÁ ­’Áî•Á8ªÀïT"ÀÔ´PÀº3À `=À†®–ÀZÍâÀ(Ùœ¿îK.¿ˆ¾·°ì>¼$O?ˆ‡¹?Þv9@$=@D @n)D@ŠÍå@˜2@µi@x"Ó@LA@Äf?åì?Š•>»Fä¾¼ì¿ë¿ðm-À)²À\N›À‡—NÀ¡à|À¼"{À×&‚ÀòW¤ÁäŠÁاÁ"ØÁ0×–Á>ÙqÁMmÁ[@šÁizÜÁwÚ°Áƒ25ÁŠ~ Á‘ɶÁ™ÍÁ nÉÁ«HÁ£² Áœ[˜Á•ÍÁ®¾Á†W»Á~#CÁo¢4Áa?ÁR™ÏÁDI+Á5ûRÁ'±ùÁ­Á xÕÀúüÎÀß}ÀÄ$À©3ÛÀŽœ«ÀhΪÀ5_OÀLy¿ Ö¾ïëÇ>–§(?…ùÊ?âÉA@íx@IX@t4@ŽÆ@£®@·!"@¨.¬@’«@yj@L¼e@RG?ã·?„ãÏ>‘±l¾ù/©¿¢'7À½0À8›Àl±ÍÀìÀ¬0©ÀÇšBÀã6 Àÿ.âÁ š0Á£Á)ÖõÁ8ïÁFLæÁT¸½ÁcSlÁrnÁ€I¬Á‡žCÁˆÁ–nÁäðÁ¨¤Á¡>4Á™ÙfÁ’u`Á‹ Áƒ»‚Áx ÁiÞlÁ[;ÁL©Á>Á/ÖÁ!%ÁÖ›ÁŒ À쮲ÀД—À´©À™¯À{è^ÀF'—ÀuÍ¿ºÂå¿):r> ÆÄ?l£O?Ørã@Û@KD·@wõC@‘¡6@¦ñ@»‚’@ÐHª@¿Z`@©Ži@“=Í@yZ@K¥Û@g?×w?gŒ;=ð"¿1T¿ÁØJÀ¬wÀLSÀmDÀÀ¸³ÙÀÔ¾ÇÀðÕoÁ¢ÜÁÜØÁ#!0Á1AÁ@MÁO sÁ]­áÁl^$Á{6rÁ…nÁŒÍÁ” Á›ŽLÁ¦hñÁžèTÁ—pWÁèÁˆŸÝÁ;øÁs™¯Ád¼ÁUæ-ÁGÄÁ8ZèÁ)±`Á ûÁ —ÂÀü!êÀßgjÀÂÑ}À¦D3ÀŠJÀ\¾–À%Îo¿ß\¿iF½²‡;?8·?¿\@O @E®¤@v˜ @’”@©n@¾µ*@ÓÕ@èQb@Öi @À!¡@©°ò@’Öå@v;K@D‹Õ@ì?¾Zð?+0ʾ#o›¿€µ‰¿í#‡À-µìÀeËÀŽJ ÀªiŽÀÆà[Àã{íÁÇÁŽ¥ÁNFÁ, ×Á:ÅgÁI†“ÁXn=ÁgiÁvfÁ‚³ÑÁŠ8ÌÁ‘ÉüÁ™cgÁ¤\£ÁœÕˆÁ•N¡ÁǹÁ†EÁ}™ÛÁn±oÁ_Ò„ÁPï¨ÁB }Á3'[Á$_‡Áœ]Á×ÀðhÀÓV¶À¶1À™VÿÀymÀ@À~¿ ¬¾Ì»>æÀi?£4‹@/ü@9Ü•@lÞ#@Ÿ·@¨*|@¿Ÿ?@Ö*¿@éRÖ@êîµ@ê—]@Ö´Ú@¿Ðº@§À@@ŽÖŽ@jv@@6L;@?•ß+>§t“¿8õ¿±ìÀX¬ÀH7&À€»ÕÀ_wÀºÀ× "Àô—XÁ ÁÐ{Á&³9Á5»ÁDÏÊÁSà5Ábò†ÁrŸÁ€šEÁˆ;ãÁâùÁ—Œ"Á¢zœÁšáYÁ“PÁ‹ÆÁ„=hÁy\èÁjCEÁ[EzÁLMÁ=C6Á.SKÁm`Á‚Á¢ÀåºìÀÈ$ëÀª£JÀ}DÀ`’ÿÀ&¿Ùî?¿No=’O”?rü?æ&Š@(ÈÄ@]Ö@ˆî;@¢¸ã@¼1Ñ@Õò@å;¥@êMz@ìÿ<@ëf#@æ?ù@Ôc=@ºž'@  Ÿ@†B@V:Ê@ "Ù?ÓFï?LLL½™âQ¿sÕ`¿ê{®À.€ºÀgïDÀ‘ŸÀ®­¹ÀÌC×ÀéöÁ )Á;)Á"iöÁ1‘Á@§ÁOÖÁÁ_ôÁnzêÁ}ã.Á†ŸÁŽLÑÁ•ûÜÁ õ¸Á™IžÁ‘Ÿ?Á‰úTÁ‚[ÖÁuƒÚÁfSÎÁW)&ÁHÁ8óÁ)äwÁÖÁ ʯÀù·ÀÛÜóÀ½ü¡À _[À‚ͺÀJL«À|È¿ª- ¾Ø>^>ôÔÇ?°­@)Û@Gö¶@~Ì~@š r@´©¯@ÎÄN@Ý0¼@æÛÒ@ì¨ÿ@ð!c@î×@æi&@Û<Ž@ËX+@°š=@•’Š@tЧ@=íÿ@` ?œq®>¬ã¿ÇP¿»¯¯ÀáHÀR.tÀ†¼&À¤ò®ÀÃ|/Àáó¾Á#TÁLÉÁ}ÃÁ-Ð~Á=;ñÁL¯¢Á\#TÁkz`ÁzÐãÁ…ÁŒÔÁ”•{ÁŸÛÁ—á[Á5eÁˆ‡ÕÁ€Ø†ÁrSÁcKÁSÅúÁD~!Á50§Á%ø5Áâ½ÁËÀñKÄÀÓ‡Àµ'«À—yÀr¥À6™n¿öYz¿1½œ'?WR‰?à]¾@)é³@c5]@¼Ú@©‹|@Àø+@Ð :@Ý›Î@貎@ðÛÓ@õ@ò$@è.@ÚÒ@ÊeÒ@¸Î%@£ú@@ˆKE@XQt@ 6?Ë“À?0 оgBÄ¿‘×ÀQnÀA"ÊÀ~-2À›ÎÀ¼!ÀÚ–Àù>ÞÁ ¿Á„Á*óLÁ:f½ÁIÚ5ÁYPÁhÑÁxYíÁƒôÉÁ‹¿5Á“ŠÁžvÁ–´õÁŽöLÁ‡^%?’°@ª @?H*@y7@˜p@¬/m@¾O”@Ï@Þ¬(@ìtH@÷ @üê@÷z@ëÎ@ÚDz@Èw@µ´P@¢%I@ó@h”{@1mp?î¶m?r¸ä<§¾ß¿hr¿î]À4híÀqάÀ—š@À¶aqÀÕ]kÀô]Á ®_Á.?Á(µÁ8GnÁGálÁW„®Ág)_ÁvÎÁƒ9`Á‹ÕÁ’ÓdÁœ¸ÖÁ•ñ=ÁŽ%vÁ†_‚Á}A‹ÁmËHÁ^U ÁNÞ×Á?]Á/èKÁ {àÁuÁ¥ÆÀäŽDÀÅ×1À§KPÀˆÿúÀU”ºÀ+迹Éa¿`d>Ù ¡?®:Z@!h@Lk@{ðG@“E@§^ˆ@»Öº@Γ9@ài¾@ðз@þ $A— @ý~Ì@í*F@ÚLL@Æ0@²UÆ@…-@ˆX@bÇ @2Ÿ?úM¶?ˆHâ> .¿HO¾¿Þ_¨À,‚ÚÀiçNÀ“©)À²‡“ÀѹØÀðÿæÁ# ÁÆMÁ'izÁ7 §ÁF¯'ÁVOÁÁeñ)Áu”ÈÁ‚"ÁŠpùÁ’HÌÁš€Á“OfÁŒ_Á…äœÁ|7ÉÁl¨Á]%”ÁM”7Á>ýÁ.n·ÁÞAÁ_½Á2Àáe¤ÀÂØTÀ¤ èÀ…eCÀN’ÚÀ*—¿§¿w¾ÅBƒ?2^?³Ù@Ï/@?9{@lY@ŒÈ€@£6@¹\†@Îî¯@âÿE@öN AyAºÑA»@î÷r@Ùø@Äù@®™á@˜G@hH@Sóx@$$n?åTO?~V=àr8¿I,°¿ÜmMÀ+z'ÀhÙîÀ“õÀ² ÂÀÑ <Àð4¶Á¤˜Á.ÕÁ&»¢Á6UhÁEÿÁU±nÁecÁuÑÁ‚dÁо5?– ,?ù=…@,Ó @\¯@‡…_@žÊÎ@·iÍ@ÏÓÛ@å¤j@ûw¢AFTAŒA}?@ðO~@ÙzZ@Â)Œ@ªÂž@’Ñ@t¾µ@B¬!@)÷?ÀvZ?:½®Ý¿r‘)¿ëÕÀ1™SÀmJ6À”­RÀ³V#ÀÒ_4Àñz@ÁKjÁÚ;Á'dØÁ6ç<ÁFzÁVCÁeÄõÁuwÁ‚CSÁˆïáÁ±çÁ•ãKÁŽðÀÁˆÏÁeCÁutcÁhiÁ[ÁÀÁM9¬Á=Ð;Á.j`ÁÁ£¯ÁFðÀâÀÃÏNÀ¥ñÀˆ ÇÀTç|À´ ¿ÇŽþ¿6$Š=®2E?]¸C?Ó™&@Ê@P˜Ø@‚á@œé¼@·ú@Ñk4@鎊AÊ3A ˜´A¼ABw@òR@Ùi½@Ào@§d @çi@iWT@4Çp?ÿ à?—‚›>Í t¾ÌåØ¿œ)æÀÀuÀ=çÀwbÀ™†À·6ûÀÕã Àô¥ Á ·¹ÁpÁ(‹°Á8ûÁG„TÁWÆÁe}×Ár{ÉÁ°6Á†•AÁtÁ”D»Á=ÍÁ†R¿Á7ÁqÆ“Ád®:ÁWêfÁK‹×Á>ò¤Á/³ŠÁ {™Á!™Áí¿ÀåÚÀÇü¼Àªq<À®xÀbÐPÀ*ÑI¿éo~¿ì™¾S°Ü?Äý?¸OÕ@(}@H@€¯ @œÖ?@¸TY@Ócí@íôFA½ŠAˆ¹A’£A+½@ôô@ÛY@ÁY{@§¶@Œ6j@aÙˆ@)À?á‚ä?kC=‘ýe¿@d±¿ÇvLÀwåÀO_½ÀƒÁõÀ @GÀ½€¦ÀÛ7ÔÀù;BÁ ¹Áæ×Á*.Á9“yÁH %ÁToÁa6ÁnC³Á{¨yÁ„«šÁ‹¢‚Á“(Á‹úËÁ„þñÁ|DÁnÒ¨Áa°åÁTÄRÁHGRÁñŽ?¬H0@ñ¡@HP@/'@žâŸ@»R@×!‰@ò÷AJWAçåA‹$A Tï@ø4¥@ÞR@ÃNÉ@§´ô@‹·¼@]l@"õí?ÑÈ ?NÁ’K7Á‹*ÅÁ„#íÁzuýÁlêjÁ_±çÁRÆãÁF)ÌÁ:4Á.›ÚÁ#è–Á5öÁCÀò.ÀÕv{À¹4À—¦À‚8rÀMi€Àjb¿µ”;¾ütî>çi/?°:ê@ži@O{@…?!@¢Æs@¿Ö‡@݇@ú\A &ÖA?(Aå2A kV@ýÏd@âDä@Ʀv@ª89@Œa@^†R@$±,?Î[?&O±¾™Š¨¿›`\À.–ÀC'+ÀzGÔÀ˜tñÀ³ùÝÀÏ~ÊÀë'7ÁÒ«Án“Á©Á*f·Á5à4ÁAê2ÁNw¬Á[xÁhÓ©ÁvfÄÁ‚ ;Á‰+Á‘ä[ÁŠÆwÁƒÀˆÁyªÎÁluÁ^Ï@ÁQë‘ÁES”Á9.Á-¨ªÁ"åmÁ WÁ SæÀùêÀÝ‚¤ÀÁ–ÎÀ£p5À…wÀMÃÀø¿¦'¾®cÿ?ì?Æ…@ve@[*Ö@‹z@©i5@Çš”@ä¸AŒ*AExAƒàAÜAA·A5@è>o@˃@­´@{¾@f‚j@*¤?Ú ·??òŸ¾UpÆ¿“ô[ÀËÅÀE2BÀL`ÀŸÿŸÀ¾²ÝÀÚ£pÀö* Á ^Á¸åÁ¤Á(zÂÁ4ÃÁ@JµÁLÑÙÁYÊ9Ág#åÁtÈÕÁM2ÁˆA±Á‘ЄÁб¤Áƒ¬¡Áy‹¯Ál,Á^ÒªÁQì9ÁE\*Á9SìÁ-ï®Á#QµÁxxÁ ùÓÀöÚtÀØzÀ¹~À›‚Àxß8À;K¿úտ勽‘1?_cË?è‹,@1<@mÉ>@”ò@²R˜@ÏÃ@@ícArhAÌ~A"FA"šA]UA 9@ïa±@ÒÙF@µÇ™@—Þ@s,.@7zd?øi?|?<«&û¿rÿ¿õp[À8¿kÀvd"Àš3DÀ¹zdÀØÇ×À÷ñ9Á |/ÁEiÁ2âÁ(ÙÁ3—ÿÁ?šÁL"ÙÁYñÁfCÁsÈ6Á€½ŒÁ‡·Á’âÁŠù¥Áƒþ#ÁzC«ÁlÔ2Á_¸¡ÁRÿ¡ÁF”Á:ŸãÁ/Q8Á$ÊÁŒ*ÁÖ~ÀðD©ÀÐÜÝÀ±uÀ’ÆÀeÛÀ(¦¿×iþ¿;‰>hÐ?—» @N%@Dܧ@€»@žsì@¼{@Ú“ñ@ø.A ©ÇAU A'ÓA'GÍA2ÒA ùý@ù†)@Ü`@¾mü@ Áy@‚ƒ@HÍ@ ˜g?šN>| ü¿6–¸¿×›ÖÀ*rûÀi À“ÞÀ³1ÀÒ‡lÀñóªÁ¿·ÁU’ÁæÁ(ÃÁ4ÆÁ?åƒÁLA;ÁYÞÁf7#Ás Á€ªnÁ‡¤üÁ’®úÁ‹ ÐÁ„®Á{¶ÈÁn\[ÁaZ@ÁTÀ¬ÁH£RÁ<ä‘Á1»5Á$áLÁƒÁ(¸Àê—²ÀÊê¦À«[ÙÀ‹î`ÀYÿÀ3È¿¶È`¾ä¤¼?¿£?½B @’<@X©¡@ŠâÉ@©4y@dž@åFAAo*AZ}A)¸A-“ A,Ä!AAL A?@å¥]@Çoò@©i'@ŠûQ@X‡í@!?¹gÄ>ðo¿|Á¿¾›ôÀ7À]úQÀ޲WÀ®VöÀÍû–Àí ëÁª2ÁiBÁýõÁ*ˆôÁ5šJÁAK½ÁMyÒÁZ/ÁgxÁthÁ€øAÁ‡ÞÑÁ“„ÁŒ—)Á…»9Á~ôÁpßJÁd'ÁW¥}ÁK­ÙÁ@#‡Á2À˜Á"ÕÁíéÁ ´Àæa|ÀÆ©êÀ¦òWÀ‡:ÅÀOeÀ•â¿ D}¾…tÜ?9Ü¡?Ú›Ñ@,!Á@jñZ@”{…@²õÉ@Ñ~s@ðjA,ÚA0$A$ÚuA3¦_A2¤ðA$B|A’³AÃç@@ÐÍÙ@±è@’‘y@eÄg@&WM?ÍÔg?Û¾¾O5¿¯ :ÀGqÀW ÆÀ‹f À«G7ÀË(aÀë ŒÁu[ÁeðÁ"ÞjÁ- SÁ7ÚªÁC=îÁO=vÁ[»«Áh…ùÁu«QÁ‘rÁˆn½Á”¨lÁÐnÁ‡iÁ€o$ÁsÛ¥Ág9Á[ÁO;ÁAÃLÁ1ÈjÁ!ͨÁÒçÁØ%ÀãºÈÀÃÅEÀ£ÏÂÀƒÚ?ÀGÉxÀÞr¿æØ¾BÕ?\«ß?í49@6 B@uxg@šu_@º/0@ÙÐè@ù;¥A |AUCA*–pA9¿–A8´ÜA)òõA1A Pñ@ôÎÂ@Ôß‚@´î¯@”ýÜ@j@*8k?Ô­‰?)Ôy¾«d@¿ªœ]À/ÕÀU{ÀŠy‘ÀªjdÀÊ[7ÀêL Á!Á7Á%Á0½™Á;2%ÁFdSÁR$¼Á^PzÁjñAÁwñÁ‚‡›Á‰7•Á•Ë*Á ýÁˆs´ÁôŸÁw0™ÁjÕêÁ^ÎÁQ]PÁAc²Á1j^Á!qeÁs-ÁtöÀâí}ÀÂñÀ¢ôŸÀ‚ø0ÀE÷ƒÀþ¥¿Œ ½ÁC?g¯Î?óÉ¢@9ݯ@yÖŒ@œçµ@¼ä$@Üà’@üÝAl¸AjïA.hÐA>U¦A6°A'xáAéÑAM³@ñmÅ@ÑÏŠ@²Â@’gú@ehf@&×?Í2?¾¿¿¿¯9À%ÀVÕ˜À‹G¹À«&²ÀËÀÀêçqÁdFÁTøÁ%EÃÁ5âÁ?6¶ÁJìÁU§KÁa±ÁmõzÁzlÁƒµ~ÁŠRˆÁ—ÍÁ|AÁŠùÁƒ©³Ázä†Áná¹Áa–&ÁQûÁA¥ÑÁ1­§Á!±¹Á²ßÁ´ÀãjSÀÃlžÀ£néÀƒqÂÀFìÖÀþô¿Žc½ô‚?_¿½?ïµ@7Æ@v¡1@›Î@ºã¹@Ú³T@ú…ÚA %LAéÂA,®8A8HA.¸ÿA! AêýA%@éØG@Ë> @¬•@ŒÝE@[¥ü@šÕ?¼àÅ>øF¿zí¿¿‚MÀéíÀ^´À޾À®2!ÀÍÖÐÀí“÷Á¯NÁ•'Á&{Á6`ÙÁD:ÏÁN¢¸ÁY±ÍÁeVPÁqS9Á}®®Á…6»Á‹ÀþÁ˜¼Á’0¹Á‹Ì Á…“ãÁýÁr˜Áb ÁR%ÁB" Á2.2Á";)ÁI\ÁZÿÀäã ÀÅ–À¥iÀ…¬ÒÀKà/À f¹¿™Ú…¾W<Ì?H¥?âþ>@0ª™@o²Q@—]@¶ÔG@Ö1R@õyñA <*ArA%©ÀA(VcA$Ç}Au_A .§@ú¡•@ÞH§@ÁEê@£ @„©@L’-@ߊ?¡i">•KT¿-†ñ¿ÒÙÆÀ'«ÀfÀ À’öSÀ²ŠÀÒôÀñ³WÁ£ÝÁnÁ(8AÁ8ÄÁGÛ6ÁSÈïÁ^–ÁiØXÁuWÁ€ÙÁ‡"ÁyÈÁšŽÁ”(6Áì Á‡ÑPÁ€[ÁsïÁc+üÁSF€ÁCeRÁ3‰—Á#±nÁÙHÁ!ÀèQöÀÈ¡ªÀ¨ñ^À‰AÀS5À3<¿ªàݾµ²Ç? ò?Í{¤@%wè@d1ý@‘ ±@¯Ñ«@·@@ìw*AÛ–A¶•AGçA‘A¦AHôA"°@ê(”@Ïý@³1@–»T@sÃ@84é?÷gÂ?{Ïh= ô¿jÇ¿ðÐÀ6y½Àt‹pÀ™N’À¸WkÀ×o/Àö¾Á IÁÚßÁ*› Á:]ÍÁJ!UÁY¼'Ád ,Ánù“Áz[>ÁƒWÁ‰,aÁp9Áœ¨ûÁ–[˜Á7ÉÁŠ/Á‚B„Át¬áÁdÔ»ÁTþÁE*ÐÁ5[äÁ%’‰ÁÐ~ÁƒÀì©ÀÍ0À­ÓÕÀŽ~AÀ^QZÀ¦2¿Áö¿ :>Û@å?±Ès@`V@SÞ}@‡Ûy@¥»x@§Ö@ß÷@÷Þ?AÞ)AÇjA˽AoìA\@ï˜@׉2@½óÙ@£ã@‡k@Wo-@\?ÉÖó?)+¾‘¿TòÀ j€ÀH*‡À‚]ˆÀ¡­À¿ò ÀÞóœÀýüvÁ‚¨ÁÁ-‘;Á=.ÁLÚ9Á\’MÁjfÁtª"ÁÊ•Á…®&Á‹£Á‘Á^ÁŸêÁ˜èKÁ’èëÁ‹$ ÁƒDøÁvÊ Ág QÁWLÁGŒ³Á7Ï\Á(ÁeŠÁ»íÀò01ÀÒüáÀ³æ¸À”ÚCÀk››À-„¿ßÝÆ¿IË>)4é?è¼@ ý@>M@w‡e@˜F÷@³@Ë>/@Üè@çœ@îed@ò Ô@ñp @é†ä@Ø(A@Š @ªÀ@‘r©@m¾Q@7ߦ@?±?Íd>t—¿'¶Ø¿ÈÅ4À &À\xëÀŒ„iÀªämÀÉ.ÓÀçxjÁEÁsêÁ!ßõÁ1X/Á@ÙšÁP^Á_âsÁokéÁzÌTÁ‚ÕÁˆn¬ÁŽBhÁ”H}Á¡ÑTÁ›ÆÀÁ”pÁŒC½Á„k!Áy*Áiƒ¶ÁYä“ÁJH^Á:¬1Á+@Á—QÁ  Àù1ƒÀÚ2óÀ»:éÀœ[ñÀ{«;À>ôÀ=¿Œ¾'a¬?C5¯?ÔvÌ@#3Ê@ZY«@†Ð @žŠ]@²7ï@¿Äb@É@Ï;ô@Òû@ÒÝ@˵ò@¾î!@«t¹@•ƒ‚@{Ïñ@Iš™@TÛ?¿)á?#ú¾j+¿gê¿ÿ²›À9Às:?À—âÀµ1ˆÀÓgëÀñ³–Á ÍÁÂÁ&I«Á5˜½ÁDú´ÁT]¬ÁcȘÁs<‹Á€ÇÐÁ…üšÁ‹u.Á‘)äÁ—êÁ¤¾~ÁK$Á•zWÁªUÁ…Ü|Á|"#ÁlŒ¡Á\ûíÁM{¢Á>áÁ.›µÁ*oÁ¹)ÁK÷Àâ!ÀÃÈ_À¥•êÀ‡oµÀS+„Àø)¿¹iE¿ s7>«K?š‚Þ@+B@5Q,@cyì@†žw@–Á,@¡ê@ª†»@° ˆ@²ï§@²êé@­’@£€n@’×ç@}q—@Pùï@!Ùy?àŽ?s­—=åo]¿:!(¿Ë‰cÀjžÀUΜÀ‡yúÀ¤ ÀÁòÀÞfwÀü8_Á .ÁI°Á+qaÁ:’CÁI¥çÁX×"Áh"…Áw£ÁƒrÁ‰ˆCÁŽÞÁ”qEÁš0JÁ¦Áž´PÁ–éÁ -Á‡\ºÁA4ÁoÚpÁ`‡nÁQ1ÁAÆ6Á2aÝÁ#èÁíÓÁáÀëÀŽÀÍ¿XÀ¯ùvÀ’hvÀj×À0Sοïì¿€Wè¾ã–?+žZ?¹+@ Až@4”›@Xa@s&´@„§@‹ÖR@ª@“_S@“•g@[@†Ø@qiä@L·Á@#‰?íÙ²?Æ>³¿–¾àV½¿¢{öÀîÿÀ<ÆûÀtlYÀ–üÀ²ržÀÏNÀëš9Á<ÁÁálÁ!µSÁ0®ñÁ?Ä9ÁNßlÁ^øÁm:Á|0ÈÁ…²MÁVÏÁ’вÁ—ì&Á†™Á§û\Á =“Á˜„DÁÒÁ‰)"Á‚6Ás·?Ádb8ÁU!vÁEû•Á6ö»Á'ÿJÁÙÁ vÀö]*ÀØñ¸À»ÞäÀžÔ´À‚bçÀM ÀÀj¿ÀeŸ¿4o=j?Eƒ?¸'U@(:@!Z.@8—Ù@K²@Y¸Y@b݆@g³>@h#Â@`°@P7¢@9õÂ@׿þ¾‘4Ò¿†4ÿê×À)§qÀ_U³ÀŠkŸÀ¥· ÀÁŠÀÝ‹{Àùô Á JQÁ“ºÁ'úãÁ6“ÁEYIÁT@ÉÁcC ÁrYôÁ€ºËÁˆFŽÁÍÑÁ–yšÁ›¸HÁ¡0ôÁ©²Á¢èÁšeîÁ’ÍöÁ‹3RÁƒ”jÁwüHÁhèÀÁYð7ÁJüìÁ;üëÁ-|Á[¿ÁÏïÁO„Àåž2ÀÈÔ”À¬ôëÀ‘¿ÀmDÀ7ošÀKi¿ª<Ø¿¶Ö=e*û?-Þ’?—?ÎX†?ú%á@Á]@·@$lM@(ìÇ@)¶@"´ð@æÉ@o?ȼ1?„¥>Ðp¾‚@¯¿t(¿Øg`À¬¶ÀNýÖÀÔÀ›Þ4À¶žùÀÑkZÀí ÞÁqþÁƒSÁ ºÑÁ/¡Á=Z]ÁK¼ÁZHJÁiÁwÝVÁƒhÁŠëÞÁ’w×ÁšhÁŸÓçÁ¥)°Á«¢Á¤hÁœ€ÇÁ”ó2ÁcÜÁ…Ù9Á|¶ZÁmÅŽÁ^éxÁP*ÁA‹Á3éÁ$|ÍÁý½Á®mÀóoÄÀØsÀ¼ò™À¡ñÀ‡—8À^F¡À.ÞÀt¿©²¿3¢5¾uZ>¨½¡?5À ?ƒE¹?£ô?»G°?ËÞ#?ÔU}?ÔŒT?Éû³?®¡M?‰lTc[¾¸Cý¿}cí¿ÔaJÀn<ÀEßYÀvfÀ”,óÀ­ghÀÇñ2ÀâÒSÀý“Á M@Á/YÁ()'Á6@éÁD{’ÁRÏbÁa!Áo~ÌÁ~jÁ†XRÁÀHÁ•3²Áœ°ÖÁ¤“Á©B%Á­®uÁ¦/Áž­„Á—2’Á¿@ÁˆT®Á€ó¸ÁsA6Ád«*ÁVOÁG™¢Á94HÁ*óºÁú¨Á¤Í+>ü…`?­?.4?/È}?IS>Ö#ð>OJ¾=Žì¿ƽ¿“m¿ßöƒÀ³åÀC´dÀoã)Àµ]À§¥0ÀÀØ>ÀÙñâÀôÜÁg%ÁÞÓÁ"EyÁ/ðªÁ=ÛŸÁKå¶ÁYþÌÁhŽÁ2PhÁ$l'ÁÝÁ ƽÀùp®À߉ÉÀÇbÀ¯³'À˜ÀðÀ‚ÅRÀ]¤•À8¼ÀP‹¿î›²¿¼~I¿’P¿]vJ¿$¼æ¾÷ 9¾·®²¾—T¾“\¾¸É>¿ Zð¿KÌ|¿E1¿Àˆ'¿û_gÀ!Ò%ÀH¥ ÀqœÀÀŽŠ‚À¤®ÛÀ¼{ ÀÔP+Àí~kÁL×Á–Ái’Á*Õ°Á8M_ÁEÑÎÁS™²ÁaÍÁo£LÁ}½~Á…þŠÁ(rÁ”SÁ›ƒ…Á¢¿ŽÁª Á¯lYÁ±i¥Áªý6Á£¦éÁœZ Á•¦Áå†Á†ÀMÁQÅÁqEpÁc7nÁU6‰ÁG_®Á9¹=Á,dãÁqÁ‹¢ÁÁÀó|ÀÜÀÅ`À¯-Àšù¡À‡YcÀk¡@ÀL_4À0@À+gÀtä¿èZ¿Íð1¿º6⿪V¿¢ÉD¿¢D¿« I¿¿ãì¿ÞXÀF^ÀqÛÀ4¸ÀU‡Àz&¥À§hÀ¥_À»:ÓÀÑm$Àé+hÀRÄñÀmÝÀ„áÀ–£¹À©=’À¼üKÀÒõÀçë#Àþ+çÁ ø7ÁàKÁ#E¦Á/ö’Á<¤ÁIŽyÁVß-Ád;Áq³ÁH“Á†…ŒÁ{Á”‚ØÁ›<Á¢ž(Á©YÏÁ®JºÁ³P¨Áµ¤ÔÁ°ÉÁ©‚‡Á¢p£Á›b¬Á”dºÁrðÁ†•‹Á’»ÁqíÁd}¼ÁWgøÁJ»µÁ>*TÁ1šïÁ%hFÁÊŽÁ¢ŽÁ¡–ÀòçEÀßTÀÌEŒÀ»i”À«í…ÀÞoÀ‘͹À‡_À|`Àm“7Àb>ÀYZŒÀRÖÿÀNe ÀN¹µÀR[žÀZ©~Àhb¿Àyø¹À†ÅRÀ“UÎÀ ©SÀ°KýÀžêÀÕnÖÀéQ/Àþ³êÁ MºÁuwÁ!RFÁ-?™Á9Œ ÁF9ÊÁRÛDÁ_µ.Álï%ÁzDÐÁƒÔÒÁŠ—íÁ‘p Á˜ZÇÁŸRÓÁ¦[§Á«ïÁ°k¼Áµ!Á¸4®Á²ÁßÁ¬²\Á¥¿‰ÁžÒ,Á—äýÁ‘™ÁŠUâÁƒ—FÁyÚ€ÁlÛÁ`;4ÁS¿­ÁGd‡Á;^ÐÁ/¶Á$¨»Á©¶ÁI…ÁcÌÀ÷žàÀ扠ÀÖ:ÀÇ­ÐÀºˆ:À®ÁCÀ¥BÀœT³À•kÒÀÉÀ‹ºÄÀˆ§5À††2À†~¶Àˆ?;ÀŒ(OÀ’¢òÀšÎsÀ¤|.À¯ŽÀ½ÇÀËK§ÀÛïuÀîšÁÖ!Á Ù¬Á¯pÁ ¥âÁ+ÕÁ7¬UÁC›nÁOÊÁ\`×ÁiVÁuätÁ~QÁˆ*dÁŽÐoÁ•‰§Áœ^ÊÁ£@üÁ©…Á®§Á²ßëÁ·âýÁºýNÁµˆÁÁ°Á©.tÁ¢UÎÁ›ŽËÁ”ßqÁŽ8Á‡ŸGÁ)Áu¹gÁik_Á]9fÁQ_êÁEÃfÁ:„$Á/£¯Á%!XÁHWÁ”ÄÁÇ ÁiÀñ¬mÀãŠöÀ×IEÀÌ;˜ÀÂÀ«ÀºÐäÀ´ äÀ¯ÀªÈBÀ§º À¥ÛæÀ¥ ‘À§{÷À«ºÀ±!À¸ÜÀÂ?¶ÀÌ«·ÀÙ!þÀæè(Àö«iÁÚ`Á J¥ÁðtÁ! 5Á+ô>Á6þ ÁB4³ÁNÉÁYëûÁfxÁr)Á%°Á…ý{ÁŒÏÁ“ÆÁ™ÑÁ |ìÁ§DkÁ¬]Á°îyÁµ¥âÁºVÁ½á-Á¸yÁ³.ßÁ¬ÈÁ¦ÁŸtÁ˜äÎÁ’]vÁ‹çwÁ…–„Á~à@Árä¢Ág-èÁ[³$ÁPYMÁEŠÒÁ; Á0ýCÁ'auÁW.Áá Á ÔÁµžÀÿîòÀôyÀéÙÝÀà~ìÀÙ9ÍÀÒÜÑÀÎqÀÉÐ"ÀÆÅÀÅ1™ÀÄÂmÀƼÀÊøÀÏÚÀÀÖéBÀàÀêQÀõ{2ÁjmÁÛeÁ —ÁƵÁ#M%Á-ÿÁ7>ÁB-|ÁM8 ÁXk‘Ád)cÁp<ÜÁ|>RÁ„Q}ÁŠ¢µÁ‘ ˆÁ—ˆgÁžmÁ¤È™ÁªçOÁ¯ZÏÁ³èpÁ¸ž†Á½v¾ÁÁ Á»´˜Á¶p3Á°—-ÁªÚÁ£s Áœÿ´Á– ÁQÞÁŠ)zÁ„3žÁ|×­Áq„ÀÁf%ÐÁ[8¸ÁPÕâÁF·ÂÁ=•Á3îÁ+<ÓÁ#`Á¡`Á„ ÁZ'ÁŽçÁ¸¦ÀþªëÀ÷•sÀñ~îÀìçÀèÖÀåÐòÀä,rÀãÜ<Àåë¥Àèå½ÀîJ~ÀõxÀý„ªÁ­Á L¬ÁuØÁ‘±ÁŠ%Á&½úÁ/—Á9HÑÁC ÁMrvÁXfºÁcoÅÁn¡•ÁzREÁƒ7FÁ‰@íÁf¹Á•²¸ÁœCÁ¢“wÁ©ŸÁ®3˜Á²#Á¶üíÁ»¤¿ÁÀ'ÁÄa_Á¿1³Á¹íãÁ´•âÁ®rÁ§ªÁ¡ZªÁ›)Á”øfÁMÁ‰=XÁƒœ»Á{ô‘ÁpïÁf~rÁ\vÝÁRÅ‚ÁIšUÁ@¡ÄÁ82`Á0Œ}Á)_Á"¥NÁ²&ÁB—Á|¨Áw1Á ú‹ÁôÁÈñÁîÁp†Á›õÁnØÁlàÁáÌÁl)Á šŒÁ žÍÁGÁípÁ¬éÁ$\­Á+Ó¢Á3Í:ÁÑÁŽEêÁ”_ðÁš{8Á ²çÁ§ üÁ­^êÁ±XÁµéÀÁº[>Á¾î Áù<ÁÇãÑÁÂÍÛÁ½«MÁ¸c?Á²c¡Á¬Á¥ævÁŸÙ;Á™âÁ” ‘ÁŽ[¥ÁˆÔÁƒX·Á|#ŠÁr.®Áh†¬Á_ ‹ÁV ÁMxÁE‡ŽÁ>HœÁ7(°Á0ôÝÁ+ìÁ& Á!P4ÁíÁ>ŒÁepÁZÁ[ÅÁúnÁ(oÁð*ÁïÁH[ÁÉÑÁ»%Á© Á ðœÁ&XÁ,¿Á2V"Á9VVÁ@ùÁIXõÁR Á[G¼Áe9ÂÁo^.ÁyÓžÁ‚Y6Á‡å¿Á†ÑÁ“QµÁ™EZÁŸadÁ¥ˆRÁ«´|Á±2Áµ,ˆÁ¹sšÁ½ñ%ÁÂ}lÁÇ2®ÁË¢ÛÁƈÁÁq¿Á¼KÈÁ¶®Á°ŒwÁªŠRÁ¤¬—ÁžÞaÁ™ ÞÁ“—ŒÁŽ5{ÁˆçÁƒØüÁ~ÁtžÁkyqÁbáúÁZ–êÁSVÁKõ”ÁE&!Á?1×Á9™šÁ4¹0Á0AàÁ,š²Á)iØÁ&»mÁ${üÁ"ªkÁ!kGÁ ¹°Á qÁ!jaÁ" áÁ$ó|Á'Ø Á+—&Á/½8Á4Ê;Á:i;Á@h?ÁG6ÁNWŠÁVOãÁ^ü¯ÁgêÁq,BÁ{3²Á‚·àÁ‡ëmÁW\Á’äYÁ˜‘Áž[Á¤EuÁªVCÁ°{»Á´ÐPÁ¹}Á½AÁÁ®ÍÁÆGìÁÊí­ÁχëÁÊjÖÁÅd‡ÁÀa<ÁºÿòÁµ=*Á¯hÃÁ©¦­Á£ç´ÁžYÁ™ÃÁ“ïÁŽŸ9Á‰½·Á…áÁ€qÁx;»ÁoáCÁgèìÁ`¯þÁY¨OÁSOýÁMn?ÁH4ãÁC^þÁ?>6Á;§ìÁ8–ÌÁ6°Á3â§Á1ú|Á0Ü Á03ÛÁ/â@Á0Ò‡Á2NÁ4'Á7ØÁ:…BÁ>§;ÁCM$ÁHÖÁN—%ÁU0­Á[üäÁcuÊÁkÇÁt/Á}„Áƒ„çÁˆ“Á¸·Á’íÁ˜VÁæMÁ£'Á©eÔÁ¯C¬Á´ÌgÁ¸ÐZÁ½=ÁÁOÐÁŦ£ÁÊ6UÁÎä|ÁÓ‹ÁÎÕÁÉ”™ÁıÃÁ¿u‹Á¹ðãÁ´ZÁ®¬ìÁ©,Á£ºïÁžuÁ™mØÁ”sDÁ·øÁ‹%ƒÁ†¿æÁ‚‹íÁ|í‚Áu`žÁnS®ÁgŒÁaŠyÁ[Ë]ÁVÕÁR!ÁN3¹ÁJ³ìÁGÊÂÁEBMÁC+DÁALùÁ@5žÁ?¨æÁ?TÁ@4GÁAd6ÁCQ=ÁF,éÁIw<ÁM€ìÁQõ…ÁW6ØÁ\ÚÁc ~Ái×þÁpâxÁx¼)Á€¨^Á…sÁ‰¡&ÁŽtËÁ“Œ–Á˜¹Áî·Á£NPÁ¨Û%Á®”'Á´]öÁ¸ð¯Á¼åoÁÁšÁÅg—ÁÉÛ´ÁÎS˜ÁÒÿÇÁëÀwÁåÊqÁßé¹ÁÚ*œÁÔw,ÁÎÐ!ÁÉO^ÁÃøýÁ¾ÇsÁ¹žiÁ´^©Á®Z¥Á¨gÞÁ¢ž!ÁœéYÁ—?iÁ‘˜ÁŒ]Á†¢ Á7žÁw×êÁmN†ÁcV¦ÁY÷¬ÁQ@žÁIR¢ÁBƒÁ;ƒÁ5ø"Á0¿‹Á,—žÁ)9–Á'5ÃÁ&9—Á&KÁÁ'äæÁ*‘Á.V€Á2Á75qÁ<ü$ÁCˆ ÁK iÁSwîÁ\™6ÁfNÈÁp—¡Á{A”Áƒ6GÁ‰ "ÁŽü,Á”×íÁšˆÜÁ g Á¦gpÁ¬rëÁ²RÁ¸•ÑÁ½ŽÅÁ»UÁÇþzÁÍU‡ÁÒ×–ÁØvÁÞPÁæú´ÁàíÚÁÚïOÁÕ ÁÏM¿ÁÉ›'ÁÃÿÁ¾ØÁ¹+Á³ú7Á®Ñ²Á©'ÆÁ£"ÓÁ1ýÁ—h¡Á‘·ÁŒçÁ†jçÁ€ð‹ÁvùšÁl!IÁaM:ÁVϰÁLýŸÁCÕPÁ;]RÁ3‰Á,Ý3Á&åDÁ"2Á¯OÁiÁçSÁÞÁòÁ­ÁŽáÁJ¥Á#3¶Á(4Á.HÝÁ5[ØÁ=k·ÁFGÁOÜ»ÁZWÁd«ZÁoÒTÁ{mÁƒ·µÁ‰«ÁY~Á•:xÁ›8kÁ¡EhÁ§gíÁ­¦ÁÁ²ãøÁ¸˜Á½HõÁ˜>ÁÈÁͺ2ÁÓ‡$ÁÙwÔÁâHœÁÜ*ìÁÖ¦ÁÐÆÁÊ9ÁÄqBÁ¾ÂÔÁ¹3VÁ³´{Á®]@Á©'­Á¤¥ÁôƒÁ—îTÁ‘þ7ÁŒ5iÁ†‰¼Á€æÁvˆhÁkžmÁ`œDÁU’üÁJèÁ@XÆÁ6´gÁ-½±Á%§!ÁXñÁôÁÞ Áþ‘Á 6gÁÁÁ¨pÁ¾±Á ›¦Á ÈãÁ·‹ÁåòÁcTÁÔsÁ'‚xÁ0-Á9vÁC“UÁNiÁY9nÁdïNÁpêÙÁ}Á„/»ÁЏÁšÁ–“ÁœE?Á¢…iÁ¨;ZÁ­X¸Á²¤:Á·ìÁ½aÁÃtÁÈÍÁνhÁÔÈ.ÁÝ«TÁ×yzÁÑS¾ÁËI?ÁÅSøÁ¿e–Á¹–=Á³çÖÁ®U Á¨Ý<Á£ŠÕÁžSäÁ˜á‚Á’ŵÁŒ½œÁ†ÉçÁCÁvŤÁk‡`Á`K¯ÁUI!ÁJ Á?Á4:)Á)ììÁ ºÁÊÄÁÁ ?ãÁ™ÀþضÀù$zÀó§GÀñNÀñ€šÀõ…Àú)sÁ?DÁÂ<Á ¦»Á²ÐÁåÚÁ# Á-sÁ7†—ÁB¢SÁNbËÁZhVÁf¨vÁrAÁ}è¨Á„ëKÁŠ÷ÇÁ‘'œÁ—kÁ™6Á¢«_Á§ö?Á­IÐÁ²ºúÁ¸Z_Á¾#åÁÄuÁÊÁÐ&(ÁÙ.¼ÁÒë ÁÌ©ÂÁƃÁÀrHÁºw–Á´Ž‰Á®¿ØÁ©QÁ£p‘Áž¨Á˜·gÁ“vqÁ¥)Á‡œuÁ‘OÁw5aÁk»ÐÁ`ˆbÁUUÎÁJ%$Á>¸¢Á3{™Á(~Á´ÇÁ‘/Á ]ÓÁ ‘ÀõqÀé .Àßæ±ÀÙ–ÁÀÖ:ÑÀÓà„ÀÔšÀ× ÀÚ±èÀá¼üÀ뱑ÀøWøÁîgÁ ÄŽÁ˜pÁ ú4Á, ¸Á7Û:ÁCæsÁP&Á[ç¶Ág¼ÒÁsž-Á·–Á†öÁŒY;Á’­Á˜ ÁLCÁ¢¥ÇÁ¨tÁ­´¯Á³€ŽÁ¹ruÁ¿qÈÁÅâÁË©ÁÔÎÁÎo=ÁÈbÁÁ×Á»²²Áµ Á¯šZÁ©¸ÞÁ£ì´Áž*rÁ˜–“Á“8ÁÉïÁˆ;–Á‚h§ÁxôˆÁlÓëÁ`ä3ÁUj‡ÁJa(Á?;*Á3úêÁ(,yÁòMÁõíÁ8|Àúœ`Àè°³ÀØîëÀËx;ÀÁDÀºßÀ¶ZmÀµéÒÀ¶À·F¢À»UêÀà ÀÎ<ÀÜ:bÀíQÁ,Á tlÁ|¿Á!Z¡Á-exÁ9ªîÁEÎ ÁQ”¡Á]uýÁi“¸ÁuúxÁK›Á‡˜MÁfÁ’¨åÁ˜šÁxhÁ£•Á¨ÞîÁ®Ò*Á´ÌÁºÜÁÁÞÁÇ_<ÁÐ~‹ÁÊ ˜Áî–Á½RÁ· Á°ãfÁªÑZÁ¤ÈLÁžÞ´Á™ ¾Á“QÓÁËÁˆD0Á‚Æ$Áyþ/ÁnW±Áb¢ãÁV“ÁJ¤£Á?+æÁ4K²Á)2¥Áu Á¦¨ÁpÖÀöä¶Àá•sÀÎTûÀ½¨À®o‰À¢ÎïÀšÜ>À–‡sÀ–À–9À—›[ÀœlßÀUXÀu|ÚÀŽ’¨À£ûHÀ»ËJÀÔAÀíÙÁ“.ÁùÁ¬™Á'š{Á3í¬Á@MŒÁL{eÁX"•Ác¼SÁoD)Á{ ÁƒSÁ‰5Á1úÁ•BñÁ›e7Á¡ŸÌÁ§ÿNÁ®·Áµ#Á»Æ;ÁÄ|Á½Î Á·1ÌÁ°š/ÁªíÁ£ ÓÁ={Á–ñ=Á¹¶ÁЉnÁ„~·Á|ýwÁq CÁeO~ÁYžÁMúLÁBP8Á6¤²Á*ýÝÁ`,Á}Á¥¼Àú†¦ÀåÑcÀÍ ­À´2bÀœÐùÀ†^CÀa"À9G»À@¿ýȯ¿àSÍ¿Ü\Ï¿Ý;¿ç­ÙÀ À-ÀDwFÀn¶%ÀŽøÆÀ§‹ÀÀÝgÀÛ7ÀõGÁ-mÁÑkÁMÁ*J´Á6WšÁAã”ÁM„”ÁY'®ÁesÁpþNÁ}Á„ .ÁŠÌÁý Á—M¦Á¯_Á¤,ÄÁªÉ.Á±xÛÁ¸1âÁÀ×KÁº -Á³WÑÁ¬«êÁ¦ÁŸ†¼Á™ ÉÁ’šWÁŒJ:Á†¥Á¤ØÁsaâÁgAþÁ[9¢ÁO;˜ÁCiüÁ7©²Á+ï>Á >Á Á ÀûŒõÀåZ¸ÀϸXÀ¹ºdÀ ˆcÀ‡¿;ÀaÀ4 IÀ w>¿Ç^T¿‹¥Î¿P× ¿?Cà¿Fxà¿c)¿—ŒÈ¿Úê™Às®ÀEUÀvutÀ”½kÀ®íÅÀÉ`öÀá}ÃÀøž Á.¡Ás8Á ½Á+§òÁ7JVÁBþ¼ÁNõbÁZó6ÁgWÁs–ªÁ€€Á†tåÁŒÚHÁ“XWÁ™ã®Á ƒÁ§:Á­õÁ´»RÁ½OÁ¶nnÁ¯±Á¨æ?Á¢7Á›‹lÁ”üÉÁކaÁˆ ÿÁ®BÁvÃÜÁj0ŸÁ]¤ÁÁQ?÷ÁE'•Á9)Á-*‰Á!\6Á®Á Ø÷ÀüyCÀåPúÀÎëÀ¸»[À£Ù¶ÀŒð¥Àh’ À7ZøÀ X*¿¹)-¿Sz°¾—¦¦=ÍH=Þ•Ð=ª /½PÁ€¾Ô19¿‚lu¿Üé;ÀlÀR]ÕÀƒ#>ÀœÌŸÀµ~>ÀͰãÀå Àüµ’Á ßàÁz;Á!+Á,ßÁ8ÙiÁDì¤ÁQb·Á]ì¿ÁjŸÈÁw¬fÁ‚Z`ÁˆðÁ˜ÄÁ–ESÁœ÷ÜÁ£¹öÁªõÁ±k&Á¹ò«Á³CÁ¬oÁ¥?uÁžôÁ—ÒOÁ‘$«ÁŠˆhÁ„ 7Á{žÁn•Áa7cÁTžÁGÊ2Á;:EÁ/ ÿÁ"ßÁݰÁ !Àþ`;ÀææÁÀϯ9À¸¤À¢Q‡ÀŒbÀmª&À@$ÀÀ¤¿Âxc¿Mlš¾(–Ç>É„Û?4¼á?C£Ó?A‚‰?#ÎÆ>DÓ¾Ê#ü¿‘Of¿÷:‹À-ËaÀ`=ÀˆÆÂÀ¡I¥À¹WÀÐ%ÀçOÌÀþœúÁ ò•ÁÎ&Á"ÆÁ.ö?Á;0ÁH6eÁTð¨ÁaþÁoC±Á|¤lÁ…RÁ‹Ð#Á’ ¬Á™z+Á SUÁ§2¤Á® <Á¶º¬Á¯»åÁ¨ÏîÁ¡ægÁ›éÁ”6ÁùÁ†ÏÑÁ€ ¨ÁsEÁeÍ=ÁX¹~ÁKÀÁ>¢Á1âÕÁ%3ÁòŠÁ ©=Á–$ÀéWjÀÑ¡Àº˜À¢å.ÀŒpÀkoçÀ?=À–¾¿ÌêÖ¿cáǾ?p>õU$?‰TÔ?²æÉ?»:·?¸œ­?¨CV?a°>P Ÿ¿K¦¿ªéºÀãÏÀ8‚ÅÀiõÀŒbVÀ£˜›ÀºÆ’ÀÒ!<À馇Á½9Á ½øÁÈÁ%‹tÁ2QaÁ?*¡ÁLOTÁYÇDÁg_XÁtþ\ÁK­Áˆ%™Á[Á•óËÁœä°Á£âÒÁªé+Á³ÊÁ¬±¦Á¥¦zÁž¬îÁ—ŸÁÞjÁ‰þ_Áƒ-‘Áx׊ÁkW“Á]â¹ÁPUhÁC×Á5ÝÓÁ(ÁÁûyÁ9ÁÈÀìò‡ÀÔ¾ŒÀ¼³YÀ¤åÂÀ]ŠÀld»À>ÓðÀ<À¿Ì½ª¿jãžhÖl>î\B?“`ª?âë+@ ‰@=´@À;@_T?ÂA?M¥W=%µò¿7¡ü¿¾ðoÀñ”À?†/ÀnsÀŽB˜À¥§‹À½D.ÀÕ&ìÀí‰dÁ Á£Á~(Á)i Á6ÀÞÁDcøÁRÁ_§ÂÁm`xÁ{?ÍÁ„…èÁ‹uÁ’z¢Á™…µÁ  1Á§¿Á°ñÁ©Í|Á¢¸—Á›§ÛÁ”™óÁÕÁ†¬¥Á{ÎÁq¾¾ÁcïïÁVÌÁHŽ;Á:å{Á-nfÁ .Áí%ÁÛÀòzAÀÙWïÀÀžŒÀ¨G€ÀiÀpMÀAC7À<¿ËF¿dª¾YØÿ>ëÞa?’NÑ?êð@ç@Ax®@I¥“@Gÿa@2ëk@q×?µ?('½ÍµO¿[4’¿Ì/ ÀtÆÀCÊÀr}‚ÀàòÀ¨¼UÀÁQGÀÙöPÀó…XÁ¦ùÁ¾áÁ!NÁ.ógÁ<˜pÁJYZÁXD–Áf$€ÁtÁCÁˆèÁÁ–DˆÁqúÁ¤Ÿ¦Á®G¬Á§6ÁŸÛÁ˜¼‡Á‘¢ÁŠ„ÁƒvAÁxÚvÁjÄÁÁ\ƒÁNçfÁ@úËÁ3(Á%ßÁÏ8Á u ÀúUŒÀà"½ÀƇvÀ­%CÀ”^ÈÀw›ßÀG^À;­¿Ï–µ¿g#å¾G >ÿôj?–@ˆ?ì"æ@ ò@L^@tÈü@‚\¾@€~„@^ä@1@ó;?¤Zr? ]-¾Hd¿kLd¿Ól2À8(ÀHûkÀx¤°À•,À®ÃÀÇÇÁÀážmÀübÁ ÙdÁ€SÁ'2>Á5¸ÁCýÁPö÷Á^ùìÁm(½Á{KYÁ„À/Á‹òšÁ“1ÔÁšprÁ¡®ÞÁ«·4Á¤n Á%ýÁ•ä'ÁޝþÁ‡„›Á€XGÁrSÁdRÁUû¢ÁGáõÁ9ÖfÁ+ß•ÁÓyÁ…ÁYóÀé|wÀÎßÀ´M„Àš•À€ùúÀP%<ÀÈ8¿Ü'½¿wØ4¾e7ã>ü}?™€?ñì@#Ùã@NíÇ@y>@‘Ÿ @ Ã®@™6T@ƒõ @Zg@*Ï?÷?š)±>õ¶¾‚›>¿Kú¿ßÚæÀÏ”ÀQÍÀ‚ nÀœ¿À¶2UÀÑrŸÀìºTÁÛÁ÷ËÁéóÁ-ÜÁ;Õ;ÁJÁX;Áfu¡ÁtÓÒÁ­PÁˆõçÁ>—Á—ŽYÁžîÖÁ©3tÁ¡ÐëÁšzgÁ“/lÁ‹æ Á„Áz±8ÁlFúÁ]ÝçÁOfKÁACÁ2þ’Á$ãÁÁñÁ± ÀõQÊÀÙÔ¶À¾d‹À£y:ÀˆÖÞÀ]~À*–¿ï>R¿‹ì;ªi>ÛÆ¾?–Mþ?ò @&0J@Qø›@|éÒ@“ÑÇ@¨îð@½+R@¯¿&@™*@¸ò@Tß@&à ?ñ 3?’“>ÍM€¾µ¶Ž¿Ž–M¿òâoÀ,ƒ¨À`œRÀ‹$~À¦aŠÀÁ­éÀÝ—CÀù’Á »oÁ²yÁ&äßÁ5$~ÁC`pÁQȬÁ`[ŽÁnò¦Á}‰Á†QÁzCÁ”îÁœfÀÁ¦ÓìÁŸiþÁ˜‹Á›îÁ‰:ÑÁèŠÁu0¾Áf‡âÁWélÁIl­Á:ðÌÁ,n3Á°ÁøÁ«iÀç¬ÀÊêbÀ®òÀ“‚‹Àp@vÀ:ì±ÀÔп¤ÑH¾û`Â>•¦†?‡Ø5?éÞN@$À4@Sô@ì@•µ@«%@À7¨@Õ#w@Å&@®$¯@—Q±@€Y‡@RX|@"³z?æg‹?…Aô>‰¼D¿Uj¿ª"bÀ Ò/À@.`Àv™À—8¶À³4ÉÀÏ0ÜÀë ÁÃÛÁÁÁ C.Á.ÁèÁ=YèÁKñHÁZ#ÁiGÁx™Áƒ†øÁ‹ñÁ’ƒÍÁšmÁ¤Ÿ–Á9Á•Ÿ;ÁŽ/gÁ†É!Á~ÇÀÁoþ`ÁaBxÁR‘UÁCÔnÁ5äÁ&‰.Á/Á p_Àö¶ÀÙÀ¼ãÑÀ žÀ„paÀQ=Àeä¿ÈGo¿;’=©Â¢?c.G?Öt™@ß@N5Ê@~Yi@–qï@¬Óâ@Âo´@×±e@ìÖ @ÚÍì@Ä5@­C @–ï@|‡@L½Û@øÅ?Ó†Ì?Z¼<þUÜ¿NæJ¿ÔsÀ!yvÀYwTÀˆº™À¤Å¯ÀÁ10ÀÝ ,Àú6(Á ³GÁd–Á(ó™Á7¤´ÁF}kÁUnÁda˜Ásk ÁEÜÁˆÊoÁO.Á—ß=Á¢ÅÁ›kÁ“‰´ÁŒÁ„zþÁyýhÁkÁ\S¾ÁM‹·Á>ëÁ/ømÁ!" ÁNBÁ›kÀêIÀÌïÀ¯ãÀ“5–Àm:À4ZÑ¿ø A¿ˆìL¾[Iµ? q¡?º*Ñ@Ð@CЖ@ué@“¾6@«ùO@ÃM}@Ù±Á@ï+´A3T@ñë@Ú,Š@Âÿ¡@«<­@“#ù@tÎŽ@B=˜@  ?±vu?ÿ¾§ÿÞ¿˜é@À„˜À<«ùÀu“—À—=ÄÀ³õâÀÑ^oÀî×5ÁåÁÐ]Á#Ä“Á2¿hÁA¶TÁP»7Á_Û=ÁoÁ~9Á†¹,ÁŽ\&Á–pÁ Ä×Á™$¢Á‘ŠòÁ‰øÛÁ‚oÁuÏ>ÁfÁoÁW³ÑÁH¸TÁ9ÛðÁ+Á'³Á BˆÀüʼnÀß$0ÀÁæÀ¤%&À‡NÀSß¶ÀØø¿ÁYå¿ ¸>„B„?¡š?ýVI@45ô@hÁÑ@óc@§Z!@Àiª¿?m¿Ñ‡1À"ÏÀ[¶oÀ‹b²À¨ÙÒÀÆPòÀä ûÁyÁÁìÁ./iÁ=a|ÁL©«Á[ønÁkLtÁz¤ôÁ…ˆÁŒ¼XÁ”s®ÁŸBÁ—’PÁâ¸Áˆ5¨Á€Ž•ÁqãtÁb¾ƒÁS«ÁD™ÚÁ5UÁ&j ÁpïÁyFÀóCÀÕ<­À·rÀ™ª”ÀxHxÀ=3:À^Š¿wѾ^¾?.Î?ÉФ@p@T¾1@…ù@Ÿÿ%@º@Ó›y@ìÍêA°ZAlAëžA PAx&@ìOË@Ò.@·åÅ@œÓµ@Èh@L3R@Ï–?¹‡J? ñ…¾®W¿ŸQ“À ÅîÀEÔ†À€›×Àžç¡À½E<ÀÛrÉÀùšÁ 8ÁW}Á*ÂýÁ:èÁIwdÁXÔ£ÁhC¨ÁwÄÕÁƒ¥ÑÁ‹d–Á“ÒÁÚîÁ–"ÍÁŽolÁ†Á¡Á~+ÍÁnÔµÁ_{ÚÁP%­Á@ÞÁ1¦VÁ"uWÁLÁ)uÀê:žÀÌ!QÀ®ÀˆÀdc‘À(¶¿Ú˜¿H€>À?‡Ý?û×Â@7Ôƒ@q^H@”ÒŽ@°„Ú@Ë“î@æq@úœÄAŠÄAîàA ocAn#AÊ£@ökª@ây @ÇWÃ@¬‘@3Ü@h=\@/»?ëû°?o®#ÂÁ‚hÁŠ1vÁ‘ÿZÁœ£ÄÁ”ýôÁ9ãÁ…{±Á{ªÁl}Á\®nÁMQ‡Á=òæÁ.”IÁ6ãÁð·Á¬üÀâ¾uÀÄ1NÀ¦ÚÀ‡àíÀS-TÀÍí¿¶4b¾÷ߺ>çSR?°9@‰=@N’¦@„ªd@¡Ÿ@¾} @Ø|¨@êK@ú¾A²¾A ƒ A ‹A A]¾@õ@â3`@ÎÜî@¹_ñ@œÉH@Òd@E«@ úi?œbY>‰+ÿ/Äž¿ÑðäÀ%õQÀc¼cÀÁºÀ¯ª¿ÀΜKÀ퓦ÁQ`Áå3Á%ÕÁ5$ÛÁDÃnÁTZŽÁcñ­ÁsˆÔÁ’òÁ‰fìÁ‘>ÈÁ™ Á’Ì#ÁŒÁ„©ÁyºŒÁj&5ÁZ•¨ÁK GÁ;–1Á,"¿Á¯äÁ =ÔÀûžiÀÜÊ^À½øÍÀŸ+'À€o ÀDL@ÀØx¿–Éa¾om?4ŸÁ?Ò/¤@%®@aÀ°@ŽŒ=@ªå@¿d&@Óæ^@蕾@ûuA5A z!AߢA ÁYA‹^@òÝ(@ß<@Ê&@´ÙX@š3@…3µ@RÞÎ@ò??³¯>àÅ4¿l*¿½óHÀøöÀ["µÀŒÓËÀ¬%ÀË`À꦳ÁóôÁ”ŽÁ$5(Á3ÕÂÁCvRÁSßÁb·Ár†…Á!ÔÁ‰©ÁÕÁ–ðèÁÿ¢Á‰+ÜÁ‚xZÁw°¥ÁižÁYïÁIí|Á:\ Á*ÒëÁZEÁ ÚªÀøŠ´ÀÙ`ÀºDÀ›fpÀy“RÀöDI¾ô¹ï¿¸pKÀaÀXŠÀ‹YÀªmûÀÉŠtÀèÔBÁïÁÎÁ#€QÁ32ÂÁBã‹ÁRÞÁbA¬ÁqõGÁ€Õ–ÁˆHUÁµÁ”¦ÑÁ˜ÑÁ†¥âÁ¤àÁr:ŠÁe/ÁX%×ÁI7Á9Ÿ@Á*¤Áp@Á æ$ÀöÓxÀ×êáÀ¹¢Àš`3ÀvßÃÀ8ÿ ¿öo3¿| D½aÈR?Z-Ò?ÚG@ðë@Q«¸@ah@š/;@³®@ËÌ%@äj£@üó]A LßAäŽAæAÀ¥A]@ï_B@×q@¿. @¥Ç“@Œ()@ftD@5JS@„?šP>ªÒ ¿¹¿ÁSÀ‚MÀ\³iÀrCÀ¬O“ÀË0ÐÀê)ÁžžÁ=†Á#ëhÁ3žaÁC@7ÁR×°Ábo)Áp?Á}ŠèÁ…’óÁŒ~rÁ’¦RÁ‹ŠˆÁ„ˆHÁ{<“Ám¡0Á`:ÁSkÁF\EÁ9Õ=Á*IÁÍÁ dòÀø˜ÀÙAuÀºmÀ›¯EÀzÜQÀ?.ùÀ{¼¿’ ·¾‡ñp?;'?³>B@ Õ@@?€è@tŸ@“÷ÿ@® @ÈÔW@ä1e@þ‹,A 4PA$A»›A•XA/ž@ícË@ÔOM@º]Š@Ÿã@….,@T…½@Åì?×á×?a“s=mÈi¿Q´-¿Ù,VÀ'uÀcQPÀ!JÀ®ÃÅÀÍ…YÀìysÁ¸?Á4CÁ$±ÕÁ4@ÉÁCÏNÁP‚Á]‘‹ÁjåAÁxx‰Áƒ(ëÁŠ3QÁþ€Á‰ÌÚÁ‚³4Áwk\Ái²­Á\H¿ÁOîÁB'Á5§0Á)½üÁߺÁ „ØÀúƒÖÀÜ/qÀ½×ôÀŸgÉÀ‚ÀH·˜Àà<¿®Ð¦¿7]>ž®¹?¨œ?ø´@2=Ê@hª.@º]@«Í?@È0G@äWc@ÿ|3A A¸üA]IAÂZAÿñ@íö]@Ó/7@¸:¦@›ñn@~1@Eï@íö?®vñ? ¶z¾™ M¿Ö¿üLAÀ7“ÆÀrgvÀ–ž À´`$ÀÒ˜íÀñóÁÚÍÁ1uÁ&Á2uÒÁ>èÁKÐÿÁXû{Áf€…ÁtRTÁ2KÁˆV€ÁÃíÁˆ´ÁUáÁtˆÈÁf¤,ÁY çÁKÈÁ>ÁÅÁ2)¬Á&'ãÁÚ_ÁîÀýøHÀà#7ÀÂ…šÀ¥.AÀˆ@ÌÀWó­Àè ¿Ò’¿LM=vH?dG¿?ã½ã@+œ¦@d݃@Žý¹@«²Â@Ȩâ@æYA CAáŒA¡~AI]A4ADn@ïN@Ó2ß@¶ L@˜»á@v¸á@<ä@q?Óê>\p«¿ {÷¿¼ À¨êÀK²ÃÀ^NÀ‹ãÀºêÀØ÷ƒÀ÷X Á ãÜÁò%Á"YÕÁ.z«Á; åÁHäÁUkÖÁc')Áq*ÁWÁ†Ó”ÁŽùiÁ‡¬[Á€t Ár¬ ÁdªwÁVð4ÁI‹ÐÁ<‡6Á/ÈÁ#™‘Á ’Á ‰>Á0ŽÀæû¾ÀÊ0À­ sÀ<”Àh¢›À1V2¿óÌ"¿…G½Ô%è?P‚›?Û ?@)N>@d¦ÿ@@­›µ@Ë9w@èÜœA' A½”AÌUA!ÜAl½A¢@ñ[Þ@Óˈ@¶¿@˜|M@s‹.@6ÖË?ö’þ?€/|=°h\¿V»T¿â«ºÀ*×UÀb^ÀŒt¹À¨BÀİPÀáE¿ÀþoèÁ 9ÁõBÁ…ÈÁ+œmÁ8K6ÁEu€ÁS0Á`ÐŒÁnÕ?Á} ZÁ…«”ÁŽ…eÁ‡:'Á€ƒÁqÎÈÁcÉÈÁVFÁH#Á;‚€Á.Ö(Á"•êÁ 3Á \ÍÁÇ®Àíó³ÀÑbþÀ´ÜÀ˜¯kÀy0;À?'˜ÀùÝ¿Œž¾jh?RÚ?äFc@/‡Ä@lÙØ@•Ì@³B@ÐùÌ@îÀA4¬A—dA#'tA%=3ApÜAÃê@óå@Ö‡Å@¹E•@š÷œ@xÏ–@;¯õ?þ–°?‚ŽÁ=Fnl¿lO´¿òƒ'À7(ëÀt^À—||À³¾UÀÏè5À鈚ÀúÏ8Á+RÁì+Á‘·Á)Þ±Á6‡-ÁCªêÁQ4¿Á_ÁlóvÁ{˜Á„§ÝÁŽoçÁ‡$­ÁÛÍÁq ÊÁc¡øÁUë'ÁH‹Á;ŽAÁ.Ü`Á"¼þÁV€Á ÕÕÁ'˜Àõ0LÀ×þSÀ¸ü‹À™ïnÀuº…À7‰ ¿ò¯¿lµ0=Lõ?}—¦?ú”@;.6@y\@šõ£@¹C[@×m¡@õDíA ‘.A‹A'A(«UA;ïA ®ƒ@ú`Ÿ@ܧý@½þ#@Ÿ`é@€ïÅ@D¸U@Q×?“Ö´>HMÈ¿C†„¿Ý™À.œÀm˜ À–ƒ™Àµº ÀÔð|Àé_õÀù÷rÁ§9ÁqÖÁûVÁ)êÁ5¼àÁBÅ×ÁP0gÁ]ÑÁk´‚ÁyØ›Á„ƒÁޤ¿Á‡`¹Á€3Ár?®ÁdW¸ÁVºxÁIwÁ<ŸRÁ0;‘Á$6(ÁëÖÁ‰Á) ÀðGÎÀÐÐØÀ±YãÀ‘úZÀeâÑÀ(/í¿Ôú¿1 >ãú?ŸÛ÷@M@K‹\@ƒù3@¢l•@Á'"@ßÛÖ@þ+èA ý¤AÆ`A+™˜A,²6AoAËâA«@ãH@Å®@¦«z@‡§Û@QO,@“q?ª[T>µûN¿µã¿ÌŸÀ$`Àb²ÖÀ¬À°=¥ÀÏäVÀëb0Àü<þÁ¤Á1BÁ„ØÁ)]Á5ØeÁBÎÝÁP Á]¤¹ÁkнÁy°yÁƒûÁ2sÁ‡ÿÎÁ€åbÁs¿Áeî;ÁXjÁKC]Á>‹ÎÁ2[ÃÁ&¥ÁˆHÁU¸ÁLÃÀêß´ÀË'þÀ«†˜ÀŒ óÀY0ØÀBí¿¶ª¾ã8½?§ž?¿9˜@O°@[&`@Œ˜£@«©ó@Ê`Â@è“°AiºAŸA!ÎSA0¿ A1É A"ð•A®@­Pt@ŽC6@^&Æ@Ô?Ã? ¹ò¾ÝØã¿¶*ÀV ÀY£†ÀŒx…À¬'-ÀË×åÀëŒ6Á„ÝÁ ÕµÁ'Á3JÁ*ØßÁ7 ÀÁCÊúÁPñÁ^VhÁl $Áz wÁ„5Á†Áˆé’ÁÛðÁuØÁh>(ÁZ÷gÁNËÁA§"Á5œ›Á*”ÁZšÁ)Á?Àæ³±ÀÆö6À§=À‡ƒéÀO•…À#9¿¡aؾ‰ôù?8Ói?Ú7¬@, Á@j÷¬@”ÛP@³´Â@ÒŽv@ñp A(A}ëA&—bA5ŸÉA6‡{A'gÅA*ÂAÐð@òiÅ@ÓI@³ÎÛ@”ƒá@i¾‚@*uC?ÖX?.Ba¾¡â¿§ÚÇÀ£XÀSYKÀ‰‡ À©b™ÀÉ=“ÀéÁYÁ þµÁðAÁ!—JÁ,öåÁ9 ÁE†‚ÁRl¹Á_¹ÁmWáÁ{ºÁ„€ÕÁÓÄÁ‰ØÁ‚ö‘Áx]âÁk!Á^¨ÁQY<ÁEÁ9XeÁ.;ßÁ";óÁAíÁH?Àä#ÀÄ©ÈÀ¤¶lÀ„ÃÀIŸkÀ ¸´¿“£ú¾´^?WíÅ?ëÄP@5zÈ@tí@š/±@¹è×@Ù¡þ@ù+7A QAÍA+98A:•PA:þ™A+'}A3A ?À@öœ)@Öº@¶×Ù@–õ°@n"ß@.E]?Üϵ?:)b¾Š™L¿¢aWÀ.ÀPë°Àˆd™À¨SZÀÈBÀè0ÜÁÖÁ‰RÁ ÔÁ%@bÁ0MÆÁ<ˆÁH]‚ÁU XÁaåúÁoûÁ|œ±Á…3êÁ‘Õ•ÁŠô¦Á„4 Á{ºÁn ïÁa|ÁUzÁI',Á=® Á1åÝÁ!ç¦ÁénÁë7ÀãÙÿÀÃÝ‘À£á"Àƒä³ÀGÑÐÀß«¿¨¾4Z?^i$?îåZ@7S°@w6ª@›2@»:@ÛqD@ûcOA ª­A£²A-œ¸A=‹MA6_‡A'ÈéAÅQA ]’@ó|N@Óçë@´S‡@”¿$@jU@*¿÷?ÖQ$?.GX¾ ï¿§$#À$ÀRµùÀ‰%öÀ¨ý€ÀÈÝ“Àè­ÁUÁJ¾Á¹fÁ)¡ Á4e¡Á?ÉõÁK­ÁWêÇÁd‡6ÁqŠ~Á~äàÁ†D¯Á“#ÁŒU,Á…§FÁ~?åÁq‹Áe ÛÁYËÁM˜ÙÁB3ÖÁ2?ŒÁ"L(ÁXÄÁeaÀäãúÀÄý3À¥kÀ…/¤ÀJ‘ÉÀ Äî¿•õ¾3ûA?QΈ?èMð@3È×@s+j@™Fþ@¸øH@Ø©‘@øZÛA ûìAÈA+”A5ÅÙA-­A œ•AžtA £@êºà@Ì|Å@­·Å@ŽòÅ@_÷@!JÑ?Äî? x¾ÝáÜ¿µ\iÀ€ ÀX®ôÀŒ¶À«ÜÙÀ˨µÀët’Á 7Á†%Á%lÁ.âdÁ9{ÁD žÁO£Á[’ÅÁgüWÁtИÁ€úÁ‡¨!Á”¤ÅÁúÁ‡oaÁXÁu…/ÁiunÁ]åRÁR»ÁC:¾Á3V£Á#rˆÁŒ)ÁŸSÀçdüÀÇ‹QÀ§±¦À‡×ûÀPKÀ…®¿¢F6¾ŽB?6Ž?Ù$õ@+¤R@j¹Ã@”õ @´?@ÓÇp@òתAëA•A#hwA&ùA#bsAD©A Œ’@ùæú@ݺÄ@ÀŸž@£lè@…®ö@NÝÎ@SÎ?§“>±þt¿Ù‹¿Ë92À$’ÌÀc‹ À‘/ÈÀ°™¿ÀÐsÀïhnÁi¯Á*ÜÁ&õ‰Á4æÁ>¿²ÁI:7ÁTUýÁ_ÿ+ÁlþÁxŠÖÁ‚ªèÁ‰:ÞÁ–c‡ÁÔÏÁ‰fÁƒ$XÁz*Án€ºÁc>UÁTsFÁD’¦Á4²«Á$Ó…ÁõÁÁÀêyÀÊÜRÀ«WKÀ‹Ñ ÀX;À~d¿´Ù¾Ú_?êË?Ä&£@ mt@^ÆÁ@ŽA¸@­\@ËPS@èÜ7AÝšAS[AýÀA(A+“A Ñ`Aà–@èL@Í÷©@²d @–8Ÿ@rPä@7Úw?ùÌ ?‚j/=˜B]¿c´¿ì£ÚÀ3ÛíÀqeìÀ—€¦À¶z7ÀÕ¬èÀõuÁ 96Áî2Á)£'Á9V$ÁE âÁO+*ÁYàëÁezÁpÒÁ|üÛÁ„ÄøÁ‹1¶Á˜zÁ’'Á‹¿rÁ…Ÿ‡Á\ÌÁsóÁfÁV@ÃÁFnRÁ6£ÐÁ&á$Á6Á]HÀï6µÀϵÝÀ°B…ÀâQÀc>¨À$ƾ¿Ì©¿ Z>¬íù?¦„©@^8@LÀ$@„v›@¡í#@¾Ý…@Ú[o@òùwAkA~fŠ®¿./(¿ÌFNÀ GàÀ[º¶À‹µÒÀ©ÀÇÂ…Àæ:qÁoóÁÐÁ!14Á0š/Á@+ÁOv'Á\FÙÁfDÁpË—Á{æÒÁƒÁ…Á‰ÇúÁúƒÁÔÁ—hIÁ‘_•Á‹‰ˆÁ…@ ÁzÕ@Ák*vÁ[¬ÁKÕ1Á<.qÁ,cÁôÁ mKÀûþ¸ÀÝ5À¾o‡ÀŸ©ŽÀ€ñJÀEeˆÀ N¬¿›C¾wT?!ºû?Ã0—@9ë@Pµ8@‚A@™A}@­k@ºª@Ä?e@Ê~{@Íwz@ÌÅV@ÆY”@ºnŽ@§ó@’H@@uÁÇ@De @U ?ºVŒ?ªT¾}@\¿‘ªÀ›ŸÀ:z!Àu~À—¢]ÀµOÀÒñÆÀðÆÁV¿ÁtÓÁ%¦“Á4êtÁD<<ÁS™ëÁc¨ÁmgŸÁw¡ˆÁ8ÍÁ†âäÁŒÂ‰Á’Ê Á ‘ŽÁš„¯Á”Ÿ¦ÁŽ…lÁ†¶JÁ}Ó;Án?ÂÁ^³fÁO,íÁ?­TÁ0=vÁ Ý Á~ÁýÀå”ùÀÇ2ÕÀ©B¤À‹cÀ[À<¿Ë_‚¿2u>J0?ˆY?ñ›œ@+8r@YN,@d@‘º@S@¥Ÿ@« .@­æá@­b1@¨-¦@ž#@ŽË@uâ @J’•@ËN?Ö4¡?`)E=šeG¿DZ&¿Î>ÉÀÁÀWN‡À‡ÐUÀ¤´<ÀÁÿêÀß" ÀüiLÁ ÝÁÁ*äÁ9ê†ÁI 8ÁX5yÁgp Áua€ÁGHÁ„ÒuÁŠFÁö¿Á•ÝsÁ£ÕÁèþÁ—ù†Á9âÁˆz>Á€¸Áqî–ÁbxéÁSÒÁC³“Á4aÄÁ%#ËÁõ£ÁÖØÀïÄsÀÑî#À´ZÀ–… Àsx¨À:s?ÀmÕ¿‘–t¾Ÿ)æ?µd?£|@š@*S!@MºQ@h_@}¿1@†«@‹µ®@ŽVG@Žn@‰½t@€’ê@g6ž@Dm]@èä?á0Þ?ƒ©¬>&x¿¿¨ ÍÀ W¨À?XYÀuöYÀ–âÏÀ³*ÀÏWÏÀì,1Á»‹ÁPÛÁ!è;Á0µmÁ?¡ÁNCÁ]néÁlÁ{ðÁƒ¦®Áˆ®’ÁüKÁ“ˆOÁ™KÏÁ§UýÁ¡pwÁ™Á Á’fÁŠOÃÁ‚™ÁuØ—Áf”ŽÁWk¥ÁHRjÁ9*ðÁ*·Á#!Á >ÎÀúÛ7ÀÝKüÀÀbTÀ£ßŸÀ‡j ÀV`pÀö*¿Ö¢U¿b5Þ½îõ ?aë?¢¯±?ìë@éæ@-¥p@@—[@OÁ@XÔ@]‹[@]AW@UÞ@DÚ&@.á*@ž{?Öt?„’ø>´òL¾Á ¿Û ¿õ@À-›Àa¿¬À‹Ì¼À¦Í}ÀÂk¿ÀÞe§Àú¬’Á pïÁÕÍÁ(w!Á7²ÁE¡ÁT\ÛÁc? Ár'tÁ€MÁ‡ÿÁŒäÁ’ ¡Á—oÃÁÁ«‰Á£SùÁ›¢ Á“÷IÁŒTàÁ„¼BÁz];ÁkNJÁ\IìÁMIQÁ>[oÁ/WÁ Ç×Á wÁ†ÑÀê•ÀÎN­À²À–‰ÓÀw$”ÀBàmÀÝ‹¿¿Çý¿Iž“½ôn >úmË?PC?·—~?ãŠ\@@¡@¶K@k@zÃ@æL@ Õ?éb?³¯?_K>ŽM‹¾¼ø–¿†·¸¿ä06À!¦TÀSÖÓÀƒrìÀ+ƒÀ·ô†ÀÒí£ÀîÁî(Áô@Á![Á/6xÁ=—ûÁL2¶ÁZЈÁi\âÁx ÁƒoVÁŠä Á‘F¥Á–B.Á›{‡Á ã˜Á¬ùxÁ¥YúÁÃÁ–5ÕÁŽ´Á‡8OÁqìÁpr|ÁaŒ/ÁRÂ0ÁDÁ5izÁ&åßÁ{Á t>ÀøÔ ÀÝQkÀÁñ®À§)À¤ÀÀi-¥À9QÀ îÅ¿Á=s¿bð쾯< >;6?4{?V©Í?‹›Á?¤œt?µ·ƒ?¾ª#?¾à?²Ÿ?˜PG?f*3?UÊ=ˆM¿fº¿:¼¿ãCÀXÀL”À{À–±§À°HÀÉ«ÐÀä)AÀÿ3Á GÁ¾tÁ(¦tÁ6µ¬ÁDØnÁRü?Áa[tÁoîLÁ~^Á†/ÁßþÁ•BçÁš½˜ÁŸÇZÁ¥ ¯Á¯2_Á§©úÁ +éÁ˜²CÁ‘7ÌÁ‰À%Á‚V•ÁuûPÁg]îÁXÔ=ÁJN0Á;ßÁ-¨Á¤{ÁèÁÁEìÀí`¹ÀÒò.À¹»CÀ ÐÇÀ‰uéÀe?ëÀ9C|ÀdŽ¿Ø[Ç¿—øÀ¿B?a¾Ñ¦®½Ê’›> ³}>ŸÚ×>àŠ?ѧ?Z>ÔÀ£>p ½t|¾º÷·¿K·|¿§]„¿ñ.}À!nÀKp0Àwb±À“ ¸ÀªÂxÀÃzÑÀܽ¤ÀöEúÁ3¼ÁžùÁ#Á0£9Á>v½ÁL`ÌÁZwÁh™€ÁvÂ+Á‚ØÁ‰Õ?Á‘'ÝÁ˜l}ÁŸw Á¤YsÁ©xuÁ±Ž˜ÁªHÁ¢§„Á›A1Á“åŸÁŒ”KÁ…NÔÁ|Ám˜šÁ_(œÁPç~ÁBßèÁ5 tÁ'ƒ¤Áô§Á rŽÀþÓ¸Àå¶ÁÀÍJñÀµénÀŸôÀˆí¬Àiø;ÀB·À"4¨Àäv¿Ö³u¿«¯’¿†‹ ¿S* ¿)^¿ HD¾÷aï¾òaº¿¦Q¿7οx{ƒ¿£ú!¿ÕëLÀÔÜÀ+Û6ÀQÚ<Àzk}À’¬`À¨¹ŠÀÀCÀ×½´ÀðCûÁ¶}Áu€ÁdºÁ+¹VÁ9)QÁF¨ÁTM˜Áb/Áp™Á~8…Á†-IÁDÁ”r5Á›´mÁ£ãÁ©,ÔÁ®'†Á´ ÄÁ¬ÁúÁ¥kÄÁž&Á–ÕŠÁ—÷ÁˆcØÁ2¡Át,ÇÁf&ÁXX9ÁJ¥”Á=©Á/žÁ"E©Á_ÌÁþrÀùÈÀâLÏÀË”|ÀµQúÀ¡;ÀZKÀxA†ÀXÎ!À<ëpÀ%qYÀmzÀ6t¿å}ž¿Ñ[ç¿Â°†¿¼Ë¿º¦‡¿ÃÖz¿×<2¿õcUÀ ¶ À#vºÀ?³BÀ`g…À‚ÕÀ•š“À©éGÀ¿ §ÀÕÂÌÀíÎÁ\xÁ‡ÁÛÁ'È.Á4¢DÁAÕïÁOC®Á\¸IÁj?øÁx+Á‚ó¨Á‰íóÁüùÁ˜ ÁŸ'Á¦T¼Á­”lÁ²øÒÁ¶ÅÁ¯}ðÁ¨@—Á¡ \Á™ãôÁ’ɧÁ‹¹>Á„¶6Á{™6Ámµ„Á`XÁR]ÁE^dÁ8.ÏÁ+\ÇÁ £Á ëÁW{À÷ß›Àá¬åÀÍm À¹|eÀ§J5À—OÙÀˆRÀw2FÀ`ܘÀM*À=+À0³À'1“ÀÏŒÀ-ÀZPÀ v)À)™.À7WËÀI~À]¬ÅÀx¿ÀŠÞ­À›ýÀ®:mÀÂHÀÖ©^Àì”ïÁfIÁ -ÁÚÁ$ñúÁ1pÁ>ÁJè9ÁWÿlÁe^ ÁrÎÁ€$^Á†ò)ÁÛÎÁ”ÏÌÁ›Í—Á¢Ý¯Á©ïrÁ± +Á·ü©Á¹­¨Á²‚çÁ«dÁ¤O¤ÁIgÁ–B{ÁD%ÁˆUœÁyjÁul†Áh3­Á[:^ÁN#‚ÁAYÏÁ5¿Á)Á€wÁ†ÁüÀùš<À妛ÀÓÑÀÁ÷À²Š•À¤NÀ˜x!ÀŽ)ÐÀ„ñøÀz?/Àn¯ßÀeµ@À^käÀ[ô À[WôÀ_S'Àg‰ðÀtN8À‚Î"ÀŒ¦QÀ˜2À¦QWÀ¶P.ÀÇÝ•ÀÚÍ>Àîõ|Á¾ÐÁ Ä›ÁÏzÁ#Œ»Á/W´Á;aàÁGäÁTxQÁa4Án3ÑÁ{ytÁ„t2Á‹,«Á‘ï.Á˜È]ÁŸ·òÁ¦¬ Á­­“Á´¾eÁ»AÓÁ¼ÒBÁµ¹~Á®¬Á§«ÎÁ ³mÁ™É˜Á’ð\ÁŒ!¼Á…m^Á}¾ÓÁpôÁd†ÁWVkÁJø]Á?ÊÁ3ªIÁ(3>Á"$ÁâxÁå™ÀþÞSÀí\NÀÝiÀÎ3ÀÁq¿ÀµÓþÀ«Ø À£S³À›íÎÀ–^bÀ’wÀŽ”À?[ÀŒæNÀŽÓ™À’| À˜Ö,À ý,Àª{SÀ´÷áÀ‚ÀÐìœÀáÎŒÀóáúÁ–KÁ ÍWÁ.›Á#"¯Á./"Á9çÅÁEÃNÁQÊ÷Á^HšÁjÚ§Áw|áÁ‚8+ÁˆÏ>ÁaÁ–9^Áœô‡Á£¿OÁª¡VÁ±”Á¸‰SÁ½’ÁÀ'Á¹ ÉÁ²ŸÁ«53Á¤g`Á—Á–ÎÕÁ&UÁ‰¢[ÁƒHWÁyú«ÁmNxÁ`ðÁU"ÁI$Á>L Á3H—Á(÷ÑÁòmÁ4}Á TìÁã¬Àø¼CÀê~BÀÞMÊÀÓr¶Àɵ8ÀÁªßÀºÒ=ÀµgèÀ±[ÌÀ­ì;À¬x§À¬FÈÀ­ýžÀ±{À·„ëÀ¿ rÀÈWÀÒaWÀÞë ÀìÒ0ÀûüåÁȉÁŒÁÀÁ#÷ÉÁ.“+Á9z×ÁDŽÔÁPAÔÁ\&&Áh#µÁt“ªÁ€˜&Á†âJÁQµÁ“æ}ÁšŽÇÁ¡FÁ§ýÁ®ºàÁµ’vÁ»fÁÀ0”ÁÂô­Á¼‰ãÁµ­ÊÁ®éäÁ¨0’Á¡u»Áš×yÁ”\ÁŽ Á‡ÇÌÁ¤ÁvÜ•ÁjõÐÁ_‚¢ÁT_ ÁIYôÁ>î}Á4øÐÁ+´Á!õ[ÁtÁrÒÁ 2ÍÁª Àû;@ÀñsÀçЄÀàlÀÙ¶­ÀÔixÀÐsmÀÍ[lÀ˱óÀ˶®ÀÍ'¤ÀЬ­ÀÖ4<ÀÝ>ªÀæIâÀð#€ÀûްÁÁ ŸÁ¸ ÁØuÁ& ˆÁ/êÃÁ:( ÁDè¦ÁOÒÿÁZîŒÁf›ûÁrˆÿÁ~~}Á…n5Á‹ÂùÁ’ ~Á˜lzÁžô¿Á¥šØÁ¬JËÁ³[Á¹¼ÍÁ¾WÀÁÃ*ÁÆÄÁÀ$VÁ¹kÎÁ²ÂÞÁ¬DÁ¥ŠþÁŸ'Á˜Æ1Á’”äÁŒqªÁ†cÁ€}›ÁuvÂÁj^˜Á_eÏÁTÒ,ÁJÏ%Á@ùmÁ7›Á/ \Á&»ÞÁF§Á7ÎÁÕÁ GPÁd™Áù¦Àþl÷ÀøzkÀóm1Àï‹ÀìË“Àêø*Àë&ÉÀìS„ÀïâkÀôâÀûпÁÓÁþ5Á K‹ÁÛÀÁ \Á!ËÁ)•ƒÁ2â#Á<>cÁFÁPdnÁ[> Áf+'ÁqNIÁ|öõÁ„uLÁŠmiÁ”·Á–åÁ3UÁ£‹zÁªHÁ°¢ÕÁ·M¬Á¼ÍVÁÁTIÁÆœÁÉX"ÁÃò˜Á½[ÔÁ¶ÍìÁ°HpÁ©ÕŠÁ£&ÁNôÁ—B Á‘QmÁ‹}|Á…¸÷Á€¡Áu[AÁjÀóÁ`¢ªÁVÝíÁMVZÁD”‘Á<:Á4R™Á-(+Á&lÁÁ p°Á?ÁB°Á éÁƒ‚Á žÁ :ƒÁSìÁÁ&×Á1®ÁÁ¢Á~GÁ ÍnÁ ,ìÁÔÁíîÁýÁ! ‰Á'Í£Á.ÎAÁ6Ê+Á?{ôÁHß»ÁR^åÁ\?jÁf©OÁq“›Á|ƒ‹Áƒ×Á‰©\Á¢TÁ•œ-Á›¼æÁ¢ÌÁ¨T•Á®­æÁµ¦Á»®ÁÀØÁÄ…AÁÉ.YÁÌå$ÁÇ¢(ÁÁ_ Áºí†Á´Ž1Á®<ÑÁ¨•Á¡ü¯Áœ—Á–\YÁ«mÁ‹}Á…’†Á€[¡Ávh\ÁlŸ~ÁcXÁZ&9ÁQ±ŸÁI±ÁB&fÁ;5Á4ŸÁ.ä8Á)ÝbÁ%$`Á!:qÁ×Á˜Á¿ÚÁã&Á£€ÁѱÁœÁ_¯ÁþÁ1ÅÁeÒÁ +Á$ϱÁ)½Á/^…Á5á±Á<½,ÁDMÁL¯ÁUh˜Á^ÝSÁh€ßÁreÁ|áñÁƒíœÁ‰n„ÁæÁ”Õ3ÁšÏ[Á ÃÌÁ¦Ø¸Á­jÁ³d¾Á¹Á3Á¿ÁÀòÁÇúôÁÌÁІ˜ÁËiÁŘqÁ¿FeÁ¹ºÁ²ÓjÁ¬É`Á¦é“Á¡1ÎÁ›VÁ•èAÁmPÁ‹/EÁ†lÁ(ÁxØõÁo¿áÁgîÁ^ÓŠÁWgÁOüºÁI+wÁC.çÁ=~FÁ8«2Á4Á0uÉÁ-/ˆÁ*‘‚Á(F:Á&hÁ%.CÁ$|‹Á$S¤Á$þ"Á&‚þÁ(œ¦Á+³4Á/GƒÁ3Å Á8½Á=ôÁCü½ÁJ¼9ÁQÿJÁYü_Áb]ÊÁkY‡ÁtÍ1Á~Á„FdÁ‰Œ3Á :Á”-Áš$çÁŸìáÁ¥âµÁ«êFÁ±öÆÁ¸'TÁ¾tçÁÂÐ5ÁÇMÁË üÁÐ2wÁÔJÁÏ5çÁÉýTÁÃÇ_Á½­ÍÁ·¥êÁ±Á·Á«û4Á¦UÁ Ï‘Á›L§Á–(ÁõVÁŒëÁ‡AòÁ‚¶0Á|}ÁtõÁl,¾Ádè|Á]ΑÁWv ÁQ‹ÁÁL7ÁGvÕÁC5–Á?£œÁ<ÜÁ: Á7ÌøÁ5íöÁ4·ÝÁ4 eÁ3å"Á4œÞÁ6¼Á8 -Á:ùÁ>aÍÁBŠ;ÁG>´ÁLª<ÁRWüÁXÆpÁ_ÒÁg‚=Áo¡ÐÁx.GÁ€‘”Á…\SÁŠP¤Á[¥Á”§©Áš&ÙÁŸ« Á¥@}Á«!Á°ô÷Á·¨Á½þÁ‚ÚÁƺÈÁÊúñÁÏl¥ÁÔ ^ÁØ4ÕÁÓ4;ÁÎ.qÁÈ[$ÁÂkÁ¼–JÁ¶ÉÅÁ±4Á«•¤Á¦.zÁ ÚÁ›ÀõÁ–äÌÁ’xÁl Áˆ÷ÑÁ„©ØÁ€ŸíÁyÓOÁr¢SÁkÜ™ÁeÔÁ_þ¹Á[6ÁVF«ÁRWQÁNÑoÁKÏ3ÁIYGÁG9~ÁEs…ÁDJ®ÁCŒÿÁCeÁD2ªÁE€VÁGr0ÁJ2£ÁM{ëÁQ{,ÁUìkÁ[9Á`ëÐÁfçšÁm¬ÛÁtùíÁ|Ê/Á‚“dÁ†ë3Á‹{ÁTÁ•\zÁšqüÁŸÃNÁ¥7¸ÁªÄÁ°\"Á¶ØÁ¼ÁÂóÁƆHÁÊÍ’ÁÏJÁÓoòÁØ÷Áé¢äÁã²FÁÝÇqÁ×ûèÁÒK‰Á̤×ÁÇ0ÁÁ±=Á¼x)Á·H Á²9ºÁ­dÁ§žøÁ¡¾ÁœšÁ–M}Á¨Á‹SÁ…‹áÁ€/Áu•oÁkovÁaÐÁX’dÁOç1ÁGÓ{Á?¶¥Á8]ÇÁ1ëÁ,³SÁ(K¾Á%BÁ#«þÁ"½½Á"ÐKÁ$n(Á'öÁ*ÙÁ/ÖÁ5Y!Á<%ÁC3¹ÁJØ ÁS7ZÁ\,lÁeÄ6Áp Ázë¥Áƒ "Áˆ“ÁŽ!_Á“ØNÁ™›^ÁŸ‚GÁ¥ŠdÁ«¢gÁ±AáÁ¶Á»ÁÀXøÁÅ BÁË)ÁИÐÁÖP9ÁÜ žÁäÇ!ÁÞÄjÁØÒ°ÁÒçÁÍÌÁÇh[ÁÁ»šÁ¼/ýÁ¶ÒôÁ±¡Á¬xYÁ§u’Á¢[àÁœZ°Á–{lÁ½]Á‹ ŸÁ…[ÁžÕÁt§Ái®µÁ_7ÖÁU4ŒÁK£ºÁB›Á:2ØÁ2JmÁ*r]Á#®ãÁ>Á±üÁ9ÿÁ_ÁÁ¤Á×PÁµPÁµ–Á Û&Á'³Á-ãÁ5“Á=#œÁEéŸÁOM€ÁYvÓÁdK¯Áo— Áz­ýÁ‚ç’Áˆ˜¿ÁŽYWÁ”DyÁšNâÁ fÚÁ¦‘ÛÁ«VÁ°Q¾Áµ„ÁºÉ>ÁÀ(äÁŶ ÁËløÁÑFzÁ×6tÁà†ÁÙörÁÓí«ÁÍó‚ÁÈÐÁÂ=ÅÁ¼‰lÁ¶ÛDÁ±TùÁ¬0Á¦ÒFÁ¡«ôÁœ´³Á—”Á‘GÁ‹:mÁ…{+Á”AÁt81Ái%\Á^(KÁSD¤ÁHé>Á?Á5‰åÁ,¼ðÁ$£ÛÁÓEÁrLÁz¸Á š:ÁñDÁjÀÁ]´Át¯ÁS´ÁzjÁ ÂÁG-Áó'ÁlÏÁ',Á/¶ÃÁ8áÁBåcÁM«ÝÁX÷÷ÁdEÝÁobàÁzµÝÁƒÆÁ‰ ·Á³Á•,±Á›_ÍÁ ¬Á¥—Áª½¥Á°ÁµX“ÁºàJÁÀ”rÁÆq7ÁÌlEÁÒyÁÛŠÐÁÕQ÷ÁÏ20ÁÉYÁÃñÁ½)ØÁ·`Á±¬Á¬Á¦†UÁ¡2oÁœ@Á–á;Á‘öÁ‹æIÁ…Ø7ÁøAÁtw'ÁiaÁ]ÀÁR´EÁG¼^Á<ç•Á2¯GÁ(ÚøÁ•ÖÁÁ;|Áš‚ÁÿiÀ÷yÄÀï˜ÒÀéÞ±ÀçÀçÑ0ÀëáÍÀòÛÃÀü!5ÁžÁ &@ÁHBÁÁ"‚ûÁ,WíÁ7 ?ÁBY@ÁMÔÁXþŽÁd?¸Áoº¸Á{¥–ÁƒÛ5Á‰õ›Á0CÁ–uÁší`Á æÁ¥I­Áª˜ÝÁ°ôÁµÊ‡Á»¦EÁÁ¨¦ÁÇ·—ÁÍÍoÁרÁпÁÊ‹£ÁÄj¼Á¾Q,Á¸GíÁ²VÁ¬„ãÁ¦Ð„Á¡9Á›¸ýÁ–d·Á‘3yÁŒ€Á†½Á€§Áu6GÁiÑÁ]þÅÁR¦’ÁGQ6Á¸Á0îøÁ%øÐÁvÁl§ÁMÀø®…ÀæÙ À×(¼ÀÉŽÀ¾ÔÀ´ÓÀ­rÀª[åÀª¢ÀÀ¯¨éÀ·Ó•ÀÁ,ÀÌàÎÀÛÀì~Àþ¢ÕÁ ÍýÁ‚Á œbÁ,PÁ7pYÁBä²ÁNà¬ÁZêUÁg,bÁs± Á€<Á…¦JÁŠ­ŒÁöeÁ•JÁš¿ôÁ jžÁ¦D²Á¬B¾Á²LöÁ¸c°Á¾œäÁÄöòÁ΄•ÁȇÁÁ›dÁ»BCÁµ¤Á®ÅHÁ¨§àÁ¢ ÕÁœ¯òÁ–ÖÁ‘Á‹~UÁ†PÁ€ÀlÁw;Ál¥†Á`«1ÁT]&ÁHWjÁ<“cÁ1,½Á%æCÁžäÁºeÁãíÀô˃Àß‚:ÀËúÀ»‚À¬' À Ä-À—•‰Àº ÀŒ¤2ÀŒü–À’À¸Àš‘DÀ£qÀ¯¾À¿Ô%ÀÑÂ?Àæ_yÀýÁ ÚÁZÁ!äÁ,Ž®Á8¡ÁDCÁPà´Á]kŸÁj=«Áv .Á€%Á…LRÁŠ¥÷Á2Á•Å{Á›£aÁ¡Á§£ãÁ­ÃýÁ´Áºf»ÁÀäRÁÊ]ÁÃËþÁ½OµÁ¶à~Á°ÐÁª1;Á£óYÁׯÁ—ÇîÁ‘Ô”ÁŒ_Á†<&Á€¸Áv{ÍÁk¾ÁÁa?ýÁV#ÍÁJVÙÁ=ï†Á1æ®Á&.nÁÛýÁ¤cÁj(Àó@'ÀÝÇÀÇ™ÆÀ²hÀŸ”ñÀÀ‚r`Àsb(ÀgÃÀ^òqÀa!7Àl§IÀvŒÀ…•óÀ“É;À¥`À¹%JÀÏÉÀæØ3Àÿ©›Á åÈÁNüÁ"4ÉÁ.BqÁ: yÁG:©ÁSö«Á`XtÁj×ÞÁuSiÁ€¥Á…ÎÁ‹&ËÁ‘èÁ–ýÁœþiÁ£'õÁ©v_Á¯äKÁ¶neÁ½LÁÆRÂÁ¿²ŠÁ¹ýÁ²‘ªÁ¬ïÁ¥ÀøÁŸe)Á™" Á“ÇÁŒõžÁ†ýËÁ'<ÁvÁ.Ák-Á`·ÁUÛÁK6#Á?§Á3ðôÁ'ÁƒªÁØ&Á¦OÀó ÀÜÂŽÀÇoLÀ°³ÀÀšaÀ…•Àg.§ÀIB¢À4ѬÀ+_HÀ(˜À+2ºÀ-À8ÌVÀP`êÀq€ßÀ‹ï©À¢‘À¹´LÀÒ¥NÀé¥ÖÁ1=Á ÕÁ ?Á$o,Á1xÁ=ÄÐÁIýGÁU·Á`ÁjÆ\ÁuâƒÁ€¤Á†zçÁŒnÝÁ’nVÁ˜™ÂÁžîúÁ¥i0Á¬œÁ²¬àÁ¹YÁÂotÁ»¯8Áµ Á®réÁ§ÞtÁ¡bðÁ›»Á”©ÓÁŽaªÁˆArÁ‚0Áx`‡Ál‘ÈÁa}ÁUóÁJÏ&Á?ámÁ4ÃöÁ).KÁx¬ÁCÀÁ39Àó/ÀÝ6 ÀÆþøÀ±IõÀš9ÞÀƒt4ÀZ^¬À1^hÀ&Ô¿îN¶¿×³¿Ù%(¿×j ¿Ü1@¿ù)ÀÉÀ=Š?Àj±<ÀŒ£CÀ¥¦~À¾ôÀÔ•FÀëðƒÁøsÁS¨Áê7Á'ŠñÁ3žðÁ>ìïÁJJ0ÁU}îÁ`¯&Ál,wÁwèíÁìÁ‡ûõÁŽ)bÁ”‚<Á›FÁ¡£MÁ¨LpÁ®÷]Áµ·«Á¾¿Á·êÁ±¶Áªp3Á£×)Á?µÁ–»÷ÁV¡Á‰üqÁƒ´.Á{>ÁnØÁbØæÁVè|ÁKe Á@2BÁ4Ô¼Á)¤ÁJ™Áµ ÁHÀö-¯ÀÝÿ·ÀÆ–½À±5ðÀ›žÊÀ…™ÀZ …À,lÝÀ™¿±%†¿jì¿0¿4©“¿2²=¿=Ö~¿‚6¿Ç’À@hÀ?víÀqt¸À’¿àÀ©‹ïÀÀQ ÀØ2âÀð‚PÁÊtÁJÏÁDëÁ(ÄrÁ42µÁ?žYÁKMÞÁVÔKÁbÆŸÁnëTÁ{>÷ÁƒÚÁŠ0jÁ®öÁ—OXÁúÊÁ¤±ÆÁ«y6Á²X&Á»'/Á´MÙÁ­y¦Á¦¨ùÁŸð Á™KÙÁ’³ÆÁŒ*±Á…³ýÁ~žÉÁr{Áe£~ÁYU{ÁMTýÁAVˆÁ5£yÁ*3ÙÁ³CÁ[ÏÁÕÀøvÜÀá,ÀÉ«™À±ïRÀš§sÀ…ߌÀayxÀ/æD¿ÿB£¿¤±¿Nk¼Œgá>—P>‰FÉ>†Úm>nƒJ¾5î¿WA±¿Ë.8À"+ÀLðlÀgÀ•ŽÀ¬”ÀÄÅîÀÝt(ÀöcÁû1ÁŠ5ÁÛÁ)ª¯Á5‡TÁAtuÁM|3ÁYâÁf5DÁrÚ4Á´åÁ†^Á]Á“»îÁšuöÁ¡BóÁ¨%Á¯ 0Á·ÌÏÁ°ÔšÁ©ëÄÁ£1Áœ<Á•~oÁŽÏ8Áˆ)3Áœ€ÁvGÁi^£Á\ÇeÁPPNÁCÝJÁ7¸3Á+§GÁ±´ÁÁt2Àùý ÀâÁ–À˃¤À´ÈÀœç¨À†'×À_Ž5À8¸™À¼X¿¬Ÿ ¿!å>Ó‚?PÝ5?;?”FÆ?›X?Œ·?­G¾8|S¿~ ¿æÔðÀ)QšÀWWÀ¤ŠÀ™StÀ±lQÀÉÎËÀáxaÀø˜ŠÁå(Á¬ÈÁ…_Á+¬Á7ׂÁDLËÁQ ÖÁ]ñáÁk¬ÁxJÔÁ‚ÃoÁ‰z~Á<ËÁ—çÁö‘Á¤ÜÜÁ«ÍUÁ´¤iÁ­<Á¦Ž÷ÁŸ ôÁ˜´¸Á‘Ó_Á‹;Á„_Á{`øÁn3ÁaD$ÁTLÂÁGŠƒÁ:ë@Á.[gÁ!ó­ÁËDÁ ÃSÀû½³ÀäPÀͲÀµÙ ÀžlÀ‡,¥À`À†À5&À e¿ÁÀ[¿:I`=P*¯?D`?»ž @܃@¯Ÿ@ Ö?ñÚ2?–jc>À£½¾Þë.¿ŸkÀ'À0{íÀ\SQÀ…óÀÖ À´þ¯ÀÌÆÀãhìÀû Á q‹ÁÂLÁ"#´Á.ÅÝÁ;פÁHßÅÁV0Ácv«Ápé&Á~pÎÁ†ÛÁŒå#Á“ÄÿÁš¶.Á¡¶ÕÁ¨º·Á±¨ÜÁª}"Á£\|ÁœQuÁ•^cÁŽs^Á‡Š+Á€¹¿Át øÁf°ÕÁYXìÁLFÿÁ?>^Á2>§Á%jÑÁÁáÁ BÀÿ…€ÀçMWÀÏm—À·¾´À Q5ÀˆõµÀcDèÀ4ÃsÀy…¿·‡ë¿R³ß¾ ‹Ò?9r?§ª}?þØ_@0*@7¯C@6Iò@…?Ýz›?r8[>ép¿! ¿²eëÀtâÀ4¾ÀcEÀˆ†õÀŸº–À·×ÀÎÉéÀæÄ‰Àÿ "Á næÁ2½Á&WŒÁ3ˆ¸Á@ð‚ÁNyÁ[ÿ]Ái¶ ÁwvÁ‚ Á‰ÈÁ…'Á—ŽzÁžœÕÁ¥µ2Á®ÌüÁ§ YÁ vÁ™O=Á’8ðÁ‹8ÕÁ„LmÁzÉNÁmðÁ_ržÁQþíÁD’çÁ7@|Á)þöÁìJÁÊ3Áõ£ÀìrJÀÓ`*À»ÚÀ¢óÿÀ‹#ÆÀgkëÀ8TôÀ ¹d¿¶ˆ¿8Ïå½1æ'?â?”w}?ñÜ@&5•@Tú‡@j»g@iÓó@CiÔ@ã‡?Æ–?E•<’®¨¿6vö¿¸¾À 7À87›ÀfÆ'ÀŠÁ>À¢¤0ÀºÓHÀÓàOÀí\ÁppÁ¥Á(*Á+Ä-Á9\•ÁFýÁTÍÎÁb›-Áp{ÀÁ~~’Á†LÁ^¿Á”}8Á››®Á¢Á5Á¬/WÁ¤äWÁ¥gÁ–uÀÁR^Áˆ>ÌÁ.AÁtW¡Áfv®ÁXª@ÁJï/Á=G¾Á/ bÁ"1‰Á­fÁWKÀôcaÀÚ"áÀÀ¤éÀ§>ÍÀŽÝÀlâèÀ=àÀ ôq¿½}^¿@•:¼âO°?+ü·?¬ñ?ùÑ@r·@O4´@}•l@3>@½@mÖ @;V@ ÆÇ?¶ûa?0½Dðà¿C…¿¾ÌÀ0À=>ÈÀlüîÀŽì´À§ôÖÀÁKÀÛháÀökÁÐéÁm“Á$wÁ1ðVÁ?¾@ÁM˜!Á[¥dÁi¿3Áwû®Áƒ¬ÁŠB8Á‘nÄÁ˜­wÁŸûSÁ©§fÁ¢[|Á›¥Á“Å ÁŒ…IÁ…[kÁ|}öÁnU+Á`8<ÁR9¡ÁD/ãÁ68ÐÁ(sRÁž¥Á â§Àþª¼ÀãuËÀÉ#À®‰À”Ö0Àv™DÀEƒÀ å¿Ç¹Í¿Q㮽§øÜ?%»?¯>y@2U@0°@Qb@xi#@“ñ«@«K‚@£?ö@‰±%@c¯\@5e@|Z?¬v? ž!½Ê=ê¿TŒî¿Ée=Àå:ÀEâÈÀxiÀ•èÀ°?ÅÀË‹òÀæØ\Á?Áö½ÁØ»Á*µÁ8À¦ÁFÑxÁTøØÁcXÝÁq·Á€ ÔÁ‡I”ÁŽœ Á•óáÁJRÁ§8×ÁŸ×4Á˜¿Á‘7ÕÁ‰ïGÁ‚¦¿ÁvÑ8Áh|•ÁZ5­ÁKèöÁ=£‚Á/VÁ!w¶ÁqëÁ–ÀïV¦ÀÓð—À¸ À£“Àƒ$¥ÀQèÀÉA¿Øð*¿lɾ-6?ÜU?¨|ñ@Ü@0Ò1@]fè@„’K@”¢e@©ÿ@À•>@¶ai@ž@‡M×@^¹º@/c@/?¥„a?¹_¾=׿qÁº¿ÛNæÀ çHÀT‹ËÀ…^À ¨"À»òwÀ׸IÀó˜“Á¬3Áµ¡Á#åVÁ1ýtÁ@H„ÁNÄ]Á]D½ÁkÈŽÁzhÁ„’’Á‹ò Á“QÄÁš¼•Á¥´Á”$Á–%ÍÁŽºÿÁ‡W"Á€;ÁqtvÁbçQÁTUŠÁEÞ™Á7‡ˆÁ)&+ÁÎ6Á ¬CÀý%íÀá ¿ÀÅ1ÔÀ© ¬ÀÅjÀd¬9À/dÿ¿ôR‡¿ÇU¾ •ï>ëѹ?œBÜ?üqì@-¸†@\^K@…@›8h@¯~%@Á&˜@Ö$‚@ËÒ@³è0@›û@„‘=@Z£ø@+Èb?øÿÖ?™áv>à.3¾®°¯¿’⼿üïÀ4á~ÀkƒÀ‘cËÀ­FTÀÉ(ñÀåáÁ¼WÁõAÁ9UÁ+ºLÁ:K«ÁHÝ ÁW€ÁfOMÁu:’Á‚²Á‰s[ÁïÿÁ˜y»Á¢ÜŸÁ›U{Á“×qÁŒbÁ„÷Á{ÁlK)Á]‡2ÁNå¤Á@PªÁ1²åÁ#‡Á¹XÁA˜Àï§ïÀÓ_'À·)?À›À}¸‰ÀEÕnÀó«¿°ó‘¿ ã•>ˆ]?ˆŸ+?ëïý@'@WzÖ@ƒ˜1@šÙŠ@±š@Ç´%@Û44@íò'@àzh@Èš<@±\T@š"Ò@‚–Æ@U_Ô@%Áí?èáS?ƒbW>_Ê_¿!„«¿½·•À ûÀNoÀ‚ç ÀžÑâÀ»FšÀ×½NÀôSeÁ¹_ÁPÁ%çhÁ4‘SÁCmÁR_çÁaU‹ÁpN$ÁHÏÁ‡/JÁŽÆ¨Á–hÁ ã¥Á™UÕÁ‘ÉTÁŠ<ÒÁ‚±¥Áv_ÞÁgv1ÁX¨ÁIÝ@Á;Á,V×Á§ÁúvÁRÃÀã¥0ÀÆ­nÀ©§ÀTÀaÚJÀ)%·¿á¸‚¿dÅS½õK?NB|?ÑpÃ@Ï@N’c@è†@˜Np@°<ý@Ç…Ø@Þ3@ô/âA¶Ü@õJI@Þ'k@ÆÛa@¯I[@—J@~Ò³@L̆@n`?Șì?7W"¾>¿‚¸¿ò–¿À1¿Àj &À‘ÑÀ®>ÜÀËorÀèžFÁîðÁ¾¦Á ¯KÁ/¼Á>ÀxÁMÄïÁ\ËhÁkêÉÁ{%Á…:»ÁŒçÁ””AÁŸÁ—t-ÁÕÁˆ=çÁ€¯€ÁrFÍÁc4|ÁT#3ÁEAÁ64Á'gbÁŸVÁ ×KÀö>¡ÀØ®tÀ»ÀÞ1À€ÀUÀG@èÀ]¿©Ó>¾áü>àÀ?¦èV@ KØ@?•þ@s¶Á@“o=@¬]+@Ä»§@ÜßÜ@ô8YAi¡AZAyº@óŒÁ@Ûûð@ÃïÚ@«ª±@’‘g@p¬r@:e@lû?–Þ9>›‰ñ¿4¿ºÅùÀ@ôÀPU{À…ŠÀ¢¬öÀÀ?zÀÞ$‡Àü —Á Á,ÂÁ+NzÁ:n,ÁI¢µÁXótÁhVTÁwº_Áƒ5Á‹@Á’óŒÁ©Á•êõÁŽ9+Á†‡¹Á}¶ÄÁno=Á_7ëÁP,ÁA÷Á1óoÁ"åÁÚ„ÁóÅÀìW¨ÀδßÀ°õ%À“=BÀk õÀ0Ø¿ë9¯¿m{\¼½õÀ?^íÛ?áOƒ@)"@`)@‹04@¥µZ@¿~@Ø£7@ñL×AÏ A‡‹AË\A'ÂAW×@ðšÚ@×ì@¾É@£l¦@ˆ@XqÑ@ sò?Иd?=‘¾äS¿ˆŠ÷¿þnÀ9ФÀuq*À˜®=À¶§„ÀÔ¾”Àó+,ÁÛÁ+qÁ'‚ƒÁ6è^ÁFVÔÁUÆ£Áe7†Át©HÁ‚€Á‰Ñ¸Á‘šŸÁœ;’Á”~ªÁŒÅÏÁ…TÁzÅÞÁkeÁ\ÄÁL¦•Á=KçÁ.ÁÜøÁÊÁ¸ãÀãK„ÀÅ(À§8ÛÀ‰dÃÀWB/À­ƒ¿ÀGÆ¿Tq>¯»º? õl@ Ÿœ@DI@}rÙ@šÐ¯@¶os@ÑPC@ëoHAv1Aó¿AUQA^A÷A£`Aü@é¥@Î/?@²šF@–¯È@u•@<4¤@´?\§>L)¿:Ç‚¿Ö{!À'‡ ÀcКÀh4À¯H1ÀÍóSÀìªMÁ±’Á%ÜÁ$¬bÁ43/ÁC¯EÁS)}Áb´1ÁrLXÁ€÷ÀÁˆÍãÁ¦ Á™óãÁ“jÁ‹Ÿ‡Áƒ×£Áx%úÁh¤yÁY,lÁIÃèÁ:l+Á+Á½’Á dxÀúÁÀÛ“úÀ½-¿ÀžàÀ€›§ÀE8'À ¿™«¾‰ðW?)·…?ËÁ@ ö›@\ù@‹5@¨@ê@ÄÛ÷@á/@üŸSA #ÂA ½A†,A‡A \AÓýAT÷@ø®S@Üûì@ÀÛØ@¤86@‡_ü@S¢Ô@¹ß?¶(>óGE¾òT8¿·Í˜Àµ“ÀW„ZÀŠy0À©(CÀÈ Àç ”Á$¦Á¹™Á"N÷Á1ä¤ÁA‚5ÁQ.¢Á`âÁp•­Á€$¦Á‡þ{ÁÕuÁ–Ý‘Áë\Á‰„Á‚OIÁvr¢ÁfÎQÁW/OÁGlÁ8ÉÁ(Œ­ÁÁ žÛÀôpFÀÕ¬KÀ¶ï À˜8šÀso^À68X¿ò¥¿rÈ»ÝÐ?pó†?ñ#@43Î@p3@•Ò´@³i[@Ðû™@ëÞûAVFA ª AËŽAÙ,A!>Aâ™Aç Al@öþ @àé—@ÉaÔ@®º.@.Þ@cG@&…R?ÑZR?*·Y¾š‹â¿¢°MÀÜÀN`šÀ†uOÀ¥¾°ÀÅÀäJ Á¼)Á\ÄÁ! ‹Á0ĸÁ@}þÁP%¶Á_Í­Áow Á#´Á‡lÈÁG’Á”$¾Á=Á†;Á~v'ÁqÁc½¥ÁV ¤ÁFz5Á6æèÁ'JÎÁ¬#ÁÂÀñ-ÀÒ bÀ³zÀ”2“Àj8YÀ,w¿Ü¤+¿B§>Kò?”€Ò@6E@C©™@€ @¸@µË:@Íaö@åU,@ü>*A µ¾Ax¨A •A$ŒŠA9[A=þAh@ñP‚@Ù~@Àí@§¢ð@ŽëJ@gì0@+§8?Úü‡?=U>¾m:G¿™ù1À VßÀJ?À„püÀ£ÕÅÀÃ; ÀâœüÁûíÁ®ÆÁ esÁ0íÁ?ÚƒÁO‹ÖÁ_CèÁo:Á|óÁÁ…P¾ÁŒGÁ‘ÏhÁŠœhÁƒÁy"ÁkE|Á]Ó#ÁPŽ ÁCªÏÁ6 ‡Á&r—ÁÛ©ÁDoÀïZÈÀÐ-‘À±²À‘æ²ÀeÍÀ(§¿ÕPŠ¿4 G>†ìŠ?›„@ LÛ@AFœ@t;@“d@¬~V@ÅÈÇ@ß‘j@øÍìA·ÒA¹AÌnA%[Aý&AJ¯A ;@ëi­@Ñz9@·8<@H,@ƒý@T„ß@»ª?Í* ?&Ÿî¾Ÿvç¿£ jÀ/àÀM!BÀ…‹òÀ¤ÂAÀÄ%gÀãxEÁS›ÁëÁ ƒßÁ0"WÁ?ÎmÁNË­Á\ÓÁiqöÁw*éÁ‚“ Á‰«ÀÁÈÁÁˆ†ÉÁYkÁt}|ÁfzæÁX¾ÚÁKL“Á>ãÁ1EÁ% ÁKÁzKÀïÉ‹ÀÐÁíÀ±óOÀ“=Ài¢ËÀ, R¿Ü´¯¿Hߨ>4s?„é´?ó«Ñ@.kE@b(„@Ь@¥1 @¿§y@Ùód@ôÈÙAÿ²A«aA!£RA& 'A«ØA )‰Apë@æW@Êä/@¯¿}@”•°@s¯@>JÕ@ -S?§ìi>Ý—÷¾ûÅ¿´šeÀØÀRüBÀˆ@uÀ§ ÀÅûŒÀå•Á0ÁádÁ!“hÁ/Á;ÝÉÁIˆÁVykÁd$ÁrÚÁ€%1Á‡WÂÁŽcÁ†¿$Á~óõÁp™Ábv°ÁT˜ÁG£Á9©•Á,Œ}ÁöÁÍÁ.@Àñ¡ÀÒèçÀ´2ÝÀ• îÀnŸÀ2:î¿íÓ¿vA½ŸLˆ?Gx¦?ÏB”@ge@QÕ=@„z„@ŸáY@»S@×$ @óWAسAÕ>A#0A'ƒA=ŒA $@ÿM–@ãÌ@Æ*ˆ@©n@ŒÝ‰@`˜(@)ç?è ¹?x­Ù=ó¿¿=Ç,¿Î;_À"²À_±÷ÀŽH¨À¬¸TÀË_ÀémáÁ½ÁŸÁ#æÁ)ªMÁ6³©ÁDyÁQ§JÁ_àÁmÖ0Á|@DÁ…^ÓÁŒ×VÁ…ljÁ|'sÁm¡OÁ_NØÁQ:©ÁCr:Á6ÀÁ(éÁ1ÁyÁ¶îÀô§ÀÖÒšÀ¸}Àš½mÀ{ ~À@ÌÀAß¿šÿ-¾³Ì'?Ár?¯Ž…@A@F‹ò@Xõ@œŠ @¹±r@Ö‚¢@ó=~AñA´=A$A(q,A*ÔA Dy@ý‹Ü@ßÕ’@ÂZÊ@¥ZL@ˆ¡@Up@«L?¿¾]?#a¾o; ¿‹Í¿ùbÆÀ5VìÀnXeÀ”l~À²i ÀÐÉ5ÀìæBÁ !Á p/Á¡eÁ%\sÁ2}Á@ VÁM÷7Á\'æÁjv~Áxò­ÁƒË ÁŒ‚Á„’ÁzY7Ák¶™Á]DaÁO ¯ÁAqÁ3„LÁ&XÿÁxÊÁ -´Á²GÀî…ÀÛ½À¿DÀ¡l)À„Q ÀOK‹Àa¿¼d׿Ó>‡¡q?–Ët@Dù@BÉ.@|a´@›Œ2@¹Bo@ÖøÆ@ôÀAþïAÂVA&ЏA*£AOáA ¢ì@ýƒ@Þì!@ÀÕ@¢®ê@„î@N|î@gÙ?©r>Ç7,¿âx¿¶¶0ÀaÀL âÀ‚TÀžÉìÀ»]yÀÒÙmÀåó¿Àû%ŠÁ 3tÁg•Á">ÖÁ/›Á=`$ÁK[ùÁYÛÁgî–ÁveÁ‚{VÁ‹‡$Á„›ÁyZ}ÁjºšÁ\K@ÁNÙÁ@KÁ2iÁ%(•ÁbmÁ ~Áj%À뺽ÀÙ;|ÀÆáÀ©ÒÀŒaPÀ_ï‡À'\¯¿Ûì¿G¥m>òâ?Šp@1‘@?Ýí@}ÒD@çg@¼sŒ@Û‹@øØÆA LA%/A(þ[A,# ALÓA©´@ÿ£k@áš@›!@¤ƒÙ@…yo@LÅ7@—‘? ÓÔ>•\}¿*&t¿ÑKïÀ'RFÀbªUÀŽ%4ÀªP÷À¾V<ÀÎ^_Àá„°ÀöÈ\ÁâÁ‚>Á T˜Á-¬ðÁ;o<ÁIqÁWzÁe¿­Át< ÁsÁ‹h ÁƒõËÁy&ÑÁjˆÁ\ÁMß×Á?ð‚Á2ZÁ%2;ÁfOÁ )0Á¿ïÀìÏŒÀÙïCÀÊ -À±7KÀ”1!Àl€GÀ/Í¿âs'¿J3Ð>CÆ\?– @ Ï@G¾w@‚“j@¡I@À@ÞÓ›@ýrÌA ]A1A,¯A.xÏAÓÄAÖÉAƒX@ä`¥@ÅlÇ@¦ƒr@‡²m@Qû/@”²?¬uO>µ™Â¿#PݿзMÀ'ãÀf¨<À’ÁÃÀ²XÊÀ¾TuÀͰÀàHÀõ¦ÖÁ`Á˜ÁeRÁ,–Á:1õÁGÿ€ÁV'Ádv«Ás8Á€Ï2Á‹ŠÌÁ„' Áy›öÁk åÁ\°ðÁN’ÀÁ@¿èÁ3IÖÁ&GÁÔÀÁ пÁŒÉÀð¹=ÀÞ‘žÀÏN'À°TÀ‘#NÀcŽÀ$ã ¿ÍŒ¿";{>³8Y?ªtj@U/@Qp*@‡Å’@¦Ô5@ÅÆJ@ä¸`AÕ;AK$A zHA/A2OA"¿A„APT@éêù@Ë7º@¬ƒ*@ŒÈñ@ZT-@(?ºDŒ>õ«¾ýïË¿½ßÀ$eÀ]YGÀŽGÀ­á†ÀÀÀŒÀÐ%ÀâMÀ÷IåÁïÇÁÛùÁMÁ,#Á9ýXÁGÎDÁUì%Ád0„Ár¢’Á€™¨ÁŒ ¡Á„­>ÁzÅWÁl_*Á^1ÁPFÁB ÐÁ5NvÁ(sŸÁ-ÑÁ‚8Áz6À÷MÀåëÍÀÊÝ À«Y2À‹ârÀXÍ.Àw$¿´B4¾Öݱ?q\?Å­@ ˜Ô@^¥Ñ@Ž]]@­z¼@̘)@ëµÑAZÞA¶´A$!A3–JA5}~A&ZUAá³Ap@ï­Â@Ðtq@±>@’@e¢;@&½¼?ÎÅ-? ¾ºª¿­]¶À ÀUe'ÀŠ`&Àª ¹ÀÇ]2ÀÕŸÞÀçu)Àûƒ¡ÁÅYÁ[šÁ «·Á-“¡Á:ÍpÁHd¨ÁVQÁdoæÁrº7Á€—HÁŒ—BÁ…];Á|rÝÁnT@Á`_ôÁR¦„ÁE5)Á8*ãÁ+Ÿ1ÁÑÁ<Á ŒIÁðÀæþ{ÀÇÀ§-‚À‡PwÀO éÀ‰®¿ 澄9½?:*?Úê—@,bÌ@kg‹@•P @´öx@Óü÷@ó A A–A("oA7ƒA9A)”ö-ÁKçÉÁYAºÁfð®Átå!Á‰,ÁŽ-UÁ‡ÄÁ€([Ár©åÁePÝÁXSÁK˜õÁ?JÜÁ3q$Á(Á–AÁxçÁ|FÀäÿKÀÅ À¥ ÈÀ…†ÀJ,À ,í¿”Zx¾"ؼ?WH“?룪@5Ñ…@u‹K@š”à@ºd@Ú3U@úA èåAÐ’A,¸sA< |A6a¹A'ú´A6zA ô@õck@Õùs@¶|@—)@nÍ_@/5¦?ß;Û?@ѾyL¿žR|ÀʯÀNÀ‡ÀÀ¦öôÀÆÓÀæ±…ÁvqÁ Ç—ÁLÁ³åÁ)àsÁ5¼ñÁAô¬ÁN«Á[Ï‚ÁiOdÁw+Á‚‡lÁQ9ÁˆcSÁ“¿Áu·²Áh‘kÁ[ÌÁOxòÁC~ŠÁ8 ÓÁ-N¶Á#¤Á …ÁûÀæIaÀÆiuÀ¦“éÀ†ÃËÀMçYÀG¿M¾¾pj%?Bfj?às¯@/Ú@ozQ@—G@·RÄ@Öõ:@öüA :Aé>A*~A3Ô#A-ZwA kPA¡UARY@ëd@Í”ø@¯Y @–®@cul@%mœ?Í3Z?))¾¸ Y¿«›AÀ™ÂÀS¸À‰“ÚÀ©\”ÀÉ(pÀèøOÁg'ÁÁÞ@Á#Î Á.¤øÁ:ÅÁEöþÁRY•Á_&ÂÁlH˜Áy³0Áƒ³×Á¹®Á‰ê`Áƒ4¨ÁyEîÁl|âÁ`ËÁTêÁH{ùÁ=—Á3'%Á$0YÁH¤ÁbHÀèû³ÀÉ8…À©~8À‰ÊAÀT,•ÀĨ¿ª¹u¾¯¦m?$úø?Ðàƒ@'¡Å@fÓI@“Ç@²IG@Ñ[À@ðhA;AxnA!pA#ò¼A"uAÏ·A 5]@ù¶Û@ÝÁå@Á%?@£µÔ@†=´@PÕ}@]¡?®þò>ÎÀìß6ÀÍBzÀ­³5ÀŽÀ]£ÀÕ?¿½I¶¾û£·>ù-?ºxU@T°@Ym5@‹ÂÝ@ª‚`@Èr‹@åÔ)A:ÕA iAŠA óAA ÓåA5[@ç ¶@̓»@²EÝ@–A@s1…@8µÝ?ûˆ’?…¨=Ð!)¿W!–¿å/À0æÀm²À•¬À´‡ÀÓ„ÀòÄÁ kÁÊäÁ'zÁ0uµÁ:+ÁD³KÁOîsÁ[¤íÁg·LÁt=[Á€âÁ‡SÁ”„ÁïßÁ‡€¹Á5)Áv5©ÁjrÁ_ ÁT@ÁG­¨Á7é2Á($¼Á[ÁŽçÀñ…ÀÑíÕÀ²k°À“£ÀgÜžÀ)«R¿×\Å¿6ÅÍ>‚[ß?œÖ@ “U@Gq¥@§û@ž¸T@»'i@ÖK@ïWG@ýEA‚RA(íA˜@ý³9@êl@Ó5ü@ºÂ-@¡Õ@†t@U©À@€±?È1?(dD¾‡–º¿—Æ+À[ÀCµyÀÇØÀžMŒÀ½þÀÛßæÀú©ÍÁ £˜ÁÕÁ+šVÁ7zôÁ@ÕßÁK«ÁUÁ#ÁaÏÁlç6Áy5uÁ‚è<Á‰ChÁ–úlÁÁŠ,FÁ„ÕÁ|$üÁp°‚Áe¢ÁYÜfÁJÁ:P¼Á*™\ÁïšÁ V À÷ÆÀØSwÀ¹6rÀš7ÈÀv€|À8ªù¿õ¬¿xS½+?gqP?éî³@/8ý@g²U@ö@©üí@Ât¹@Óèù@Þ¡å@å¡+@蛞@çÂ@ßû£@ÒR^@½W @¦C@ã›@i@4a¬?ü©?q->gòE¿,º¿ÉqsÀ©÷ÀZš5ÀŠÊÀ¨ÑGÀÆÚvÀäîÁ¯wÁ…Á sxÁ/ºœÁ?"ÁHUfÁQí{Á\DpÁg@«ÁrËÀÁ~ËõÁ…‰‡Á‹ÆÁ™žéÁ“IíÁ^Á‡çÁP Áw>ÁlS³Á\µÁMÇÁ=‚]Á-äÁRVÁÖÇÀþÕ­Àßë7ÀÁÁÀ¢=‡ÀƒñKÀKöÀ—N¿§Èt¾Ë6+?L?²Ô‹@ÿR@GÚ@{±÷@•ä@©!å@¶ki@À)]@Æ@ÈúN@ÈGs@Á â@¶©ÿ@¥’@.®@qX@Aõø@Uo?·À?'‘¾„k¿¿‘ìÀŒüÀ:hÀsºdÀ—/°À´¨<ÀÒ ÈÀïÏÁè€ÁíÁ%Á49¹ÁC’ ÁP€ÁY¼Ác¸WÁnD¥ÁyW’Á‚v¼ÁˆzÉÁŽ™€ÁœžãÁ–j=ÁbÑÁŠŽ…Á„ê0Á~â³Áo–‹Á` ZÁPŒpÁA °Á1·ŠÁ"K>ÁßsÁ“—ÀèáŒÀʰ•À¬‡™ÀŽ–½ÀbBYÀ'Žn¿ÚTÁ¿QDa=ˆ~?l’?ß0Ö@#2@Q]Q@z'¼@Œú‚@˜¨‘@¡G%@¦›@©^@¨Òý@£cY@™eÁ@‹ùK@qÄ?@F Ÿ@U«?ÐIt?Vav=,…¿Iz¿Ðy÷ÀosÀWJ‚À‡ÓiÀ¤™1ÀÁemÀÞˆ¸ÀüDÁ ¼èÁÍÁ*g;Á9h]ÁHm–ÁWŠ,Áb-ñÁk§zÁuÎ`Á€GÁ…êÁ‹ÇJÁ‘¸nÁŸêÁ™ÕSÁ“ïVÁŽ=yÁˆ·0Áj ÁsjðÁdÒÁTŸÁE?÷Á5÷dÁ&ÏÁº’Á¦‰ÀóJ#ÀÕ…À¸¦ÀšƒóÀ{HàÀBSÀ zl¿¥¥Ä¾äÔü>·ó¥?“D?îŸx@![‹@D›·@_}ä@t‘%@‚o@‡û@‰Áß@‰7(@„²@wK@_æu@?$O@¯É?×wÂ?tm§>b\©¿’п­²÷À êÀ@T}ÀvÍ×À—(·À³&ÀÏ`ÂÀì%®ÁwtÁõwÁ!­&Á0ilÁ?*¦ÁMû)Á\æïÁk2°ÁtRÁÁ~!Á„EÁ‰»…ÁeÁ•1Á£_ôÁtµÁ—¸¦Á’.<Á‹,.Áƒz°Áw•GÁhGLÁYJÁIödÁ:êWÁ+òéÁæÁ Àþ»ÏÀáiÕÀij°À¨éÀ‹¥bÀ`[ìÀ)ÄÔ¿é¡G¿ƒx’¾.ë>ê9?‘ F?ÛÆÖ@ ÒH@#õŽ@7qÝ@E×r@O1Ü@TK@S2ß@Kœ@:ñ¬@%{©@ ÚP?ˇ?u­ô>‹Y¾èö½¿˜‡P¿ûËÀ0–Àcó¶ÀŒtôÀ§m¨ÀÂÓUÀÞšŠÀú¦ÎÁ wÁÙÁ(:»Á6­¾ÁEY«ÁTñÁbÔ«ÁqžÁ}nôÁƒmâÁˆrÊÁ·úÁ“1gÁ˜ÝjÁ§ÈÁ¡S¢Á›½ÃÁ”ñ)ÁLŸÁ…¯,Á|:¬Ám0âÁ^@£ÁOPÂÁ@`¿Á1}èÁ"¿Á36ÁáxÀï.3ÀÒšMÀ¶–‘À›JgÀ€›ùÀM24À1¿Ó–пs-·¾‚»­>¨¹Ð?Z?¤®?Ñ ?ô¥+@Í@/Ã@Ö@÷o@ Qw?ý0‘?Ö'v?£X^?LŽ>F,ü¾æÆ{¿‘Ë5¿î²2À&­ÀW¬¯À…)ÏÀž‹@À¸àÚÀÓ€¸Àî±Á")Á xÁ!ÊÁ/=ÙÁ=ŸTÁKþÁZi´Ái.ÁwÂuÁƒ?ÊÁˆ¸ÁŒè†Á‘úÁ—LpÁœÐ(Á«"Á¥~pÁžÞðÁ—I-Á»ŠÁˆ8‹Á€ÀÅÁr–bÁc°ÜÁTÝ_ÁF'XÁ7¦1Á)\ÓÁyÁ ÔmÀýG¶Àá´«ÀÆõÀ¬®À’ÉâÀs%)ÀCŸÀW„¿Ó•u¿†Ð;ôkz½} >·–?06—?sÔE?’³³?¢]?ªß@?©R´?ž ½?„}Ë?=@ö>Á’½þm¿ô~¿š ”¿î:7À#6XÀQ“ZÀ€‹GÀ˜¾÷À²XÀËb¼ÀåLÀÀÿɵÁ ^iÁþõÁ(Ú¨Á6ǯÁDÔ.ÁS™Áae’ÁoÁLÁ~'ÍÁ†\ðÁŒÿêÁ‘¢«Á–‹Á›µÁ¡–Á¯o Á¨ÞtÁ¡Z8Á™Ø¹Á’`ŸÁŠðšÁƒ‡IÁx>ÐÁiŠ Á[ÁL¯ÓÁ>n¦Á08ÛÁ".Á'Á›,ÀòЀÀØUÀ¿uÀ¦OÈÀŽ*ïÀo‹éÀCšÀ³î¿ìÈ4¿®GÛ¿jó?¿÷¾†‚˼€Q>,‹ý>“n>²se>ªãP>ãs=“ãоPyè¿ϵ¿rØQ¿´†3¿ÿ;¿À'ÀQahÀ}‡À•æÎÀ­·[ÀŪúÀÞæáÀøAEÁæÁàÁ#mhÁ1!Á>°¾ÁL“'ÁZ†íÁh•¯ÁvË[Á‚•èÁ‰ÂJÁóžÁ–¢ÉÁ›b»Á axÁ¥“ÇÁ²íÉÁ«nBÁ£ø4Áœ&Á•*çÁË­Á†v÷Á~a¹Áp[ÁaÎYÁS©ÁE‡ÉÁ7lÁ)Û]ÁbÀÁ3ÚÁE±Àë†]ÀÒû:Àºá!À¤eµÀŽ5AÀt[iÀNqjÀ+ï1Àâæ¿ëÓ+¿¿Ÿ¿›\±¿{«Ó¿Ouÿ1èí¿#K¿&¹V¿:0¿dIø¿’¾õ¿¹!—¿êV>À}»À2ÃçÀXþŸÀ€„À•ÒÚÀ«ëìÀÃïÀÚÄÉÀò®ÙÁâµÁçÁ@õÁ,OÓÁ9‘:ÁG›ÁT¡ÿÁbhvÁpL$Á~FÄÁ†,LÁIÁ”yÁ›£îÁ ^NÁ¥/xÁª>Áµˆ­Á®$³Á¦ÉHÁŸsGÁ˜'uÁä2Á‰¬ Á‚†yÁvêãÁhÞbÁZü½ÁM=ûÁ?•‡Á2+ÄÁ%¨Á^¦Á ÙÀÿ4Àç—RÀÑÄÀºÝ6À¦«YÀ“J~ÀÄÒÀd6ÀH~À0Ö5ÀôEÀ ðg¿ù«]¿å4¿×²¿ÐÅ¿Ñq°¿ÚÜî¿í^¾ÀY À”òÀ/{•ÀJÔ#ÀhmÀ…öZÀ™/°À­†/ÀÂõÀØø6ÀðÁàÁÓíÁRÜÁ(ÿ+Á5¬]ÁBŒyÁOÃRÁ]ÙÁj§·ÁxJ‚ÁƒzÁŠÁ‘}Á˜4ÁŸ,qÁ¥yÁª; Á¯$RÁ¸c’Á±4Á©ÚžÁ¢™~Á›[bÁ”,ÒÁŒÁ† ÎÁ~;ÙÁpŽÒÁbì ÁUS¢ÁGû3Á; )Á.s,Á!ð;ÁÐ]Á .rÀý°Àç…+ÀÓ(þÀ¿_À­„'Àœ¬dÀŽ}yÀZXÀk²­ÀXmÀHwïÀ;CÈÀ1pÓÀ*™À'JlÀ'ÃZÀ,QóÀ4L@ÀBRÅÀTÖRÀi×ÀjûÀ |ÀŸöãÀ²ŽÀÅô¹ÀÚˆEÀð&ÁýxÁÁ]¡Á&J“Á2´9Á?h@ÁL¡ÁXÝ ÁeùEÁs>HÁ€XŠÁ‡$·Áý5Á”ìºÁ›áÈÁ¢ã®Á©ðmÁ¯~áÁ´CsÁ»cZÁ´/½Á¬÷žÁ¥ÌèÁž²ìÁ—¬Á»?Á‰ãCÁƒ}Áx˜JÁk0Á]ØéÁPýÁÁDn¶Á8ãÁ,3Á •!Á0]Á tÀÿ¦¢Àë®ÛÀØÄÝÀÈ!À¸‹Àª“Àž·CÀ“÷$ÀЦÀ‚ÿ»ÀyÔâÀpF•Ài®SÀfbÀfÍÝÀk5pÀr4òÀ¹TÀˆRÑÀ’?cÀÛ.À«ïŠÀºúÀÌrFÀß35Àòå­ÁÀ¹ÁXÁ€Á%WÁ0Û?Á<ÃkÁIÎÁUºîÁb~îÁo<Á|4 Á„¶Á‹d8Á’'¨Á˜ö=ÁŸ×ŸÁ¦ÈùÁ­ÀƒÁ´ÃàÁ¹–´Á¾†»Á·mLÁ°U»Á©OtÁ¢\µÁ›|OÁ”MÁÖ½Á‡">Á€o‰Ás¼õÁfôàÁZøÁNN—ÁBQøÁ6ÓˆÁ+nÜÁ EdÁó˜Á Á=ëÀóEoÀãHÅÀÔ‘ŽÀLj#À¼†À²*À©#hÀ¡ÍqÀœ*À—Ž,À”aÐÀ’Ú~À’ß«À”óÉÀ˜VÊÀžñÀ¦ZÀ°”ÀºñÊÀÇð‡ÀÖ‰ÄÀ澚ÀøòYÁщÁâÏÁ&!Á%áÁ0DÁ;‡ÁGXÝÁS=ÁÁ_êÁl2ÁxÑœÁ‚ÊÚÁ‰?^ÁÑ\Á–uÏÁ.cÁ£ø‚ÁªË Á±³¡Á¸¥†Á¿»ÁÁðÁºéëÁ³íÁ¬ü³Á¦„ÁŸHþÁ˜“×Á‘ýýÁ‹ZÝÁ„ÖÇÁ|ñçÁpŒsÁd}µÁXŽ]ÁM8ÁA ÛÁ6zÁ,ÞÁ"ºÁ@Á;¿Á2–ÀþÁ£ÀðÂhÀäíÀÙðŠÀÏÚ}ÀǨÊÀÀ ÕÀ»@™À¶ù À³ìvÀ²YKÀ²EÀ´AÀ·wíÀ½íÀÄÄÖÀÍÿÃÀØ'”Àä2BÀòRìÁÐËÁ \Á„IÁ:Á&<“Á0‘žÁ;jÁF‡ÁR âÁ]Ö{Ái¹'Áuë‹Á; Á‡’%Áô%Á”aÎÁšíÁ¡ŒÁ¨; Á®üÁµÉ^Á¼¢„ÁÃàÁÅ\Á¾o»Á·uÁ°¾Á©úÁ£RƒÁœË3Á–Q‹ÁÓ1Á‰w€ÁƒC€ÁzxÁn²¯Ác)úÁW±ÁLªDÁB4dÁ86ÇÁ.MÿÁ%NÁ¡ùÁØôÁ RÑÁÛëÁ÷À÷²þÀî*Àæ1ùÀßšûÀÚj ÀÖcîÀÓp£ÀÑàŠÀѲÀÓw}ÀÖ™ÀÛöÀã>sÀëê®ÀõÜfÁw¯Á; Á}Á©‘Á\óÁ(˜qÁ2qÉÁ<–WÁG ÁRÅÁ] ÁhŽ(ÁtTÁ€«Á†-GÁŒmjÁ’¼Á™|ÁŸ…ÔÁ¦¶Á¬¤ÒÁ³LŽÁºÁÀÌMÁÇ›»ÁÉ)ÁÂ5Á»fÜÁ´­¡Á®Á§ÇÁ¡3ÝÁšÏëÁ”uïÁŽ@AÁˆ6MÁ‚^'ÁyQ,ÁmåhÁbÑ€ÁXOòÁNNMÁD_ Á:ü½Á2@fÁ*-QÁ"†úÁzãÁd4Á³XÁ ¶õÁHvÁ]»Àþ•!Àù‚Àõ£mÀòѨÀñlëÀñ%Àòö†Àõº@Àúó¦ÁÜ›Á .Á ÜrÁ ßÁT¹ÁeÁ$ 6Á,Ž<Á5dºÁ>ÈüÁHȃÁRðÁ]spÁh‚éÁs`ÁqÁ…iÞÁ‹YÁ‘fÁ—ŸµÁê;Á¤FÓÁª««Á±'5Á·ºùÁ¾b ÁÅçÁËÃÁÌÃöÁÆ íÁ¿Y3Á¸ÃÁ²J„Á«ò×Á¥± ÁŸoøÁ™<±Á“/ÞÁP×Á‡ ¼Á‚NÁxøÆÁnm¶Ádc§ÁZgƒÁPô±ÁHfÁ?š^Á7ÑÁ0e›Á)á¬Á#Ö·Á’‡Á™ÏÁz^Á²ÁÈ}Á V«Á nÁ VÁ~FÁNÁ ‚QÁ8RåÁ2lÖÁ-i­Á(¦RÁ$¨3Á!ÁH’Á÷PÁ SÁÈËÁ~ÁyÁÑTÁ ÕÁ`aÁ‹Á#H·Á'ÌÁ,½ñÁ2vÁ8™MÁ?¥WÁGÿÁOaÝÁXM\Áa‰¥Ák<ÈÁub?Á­"Á….ÑÁЬ"Á7&Á•úâÁ›ìÁ¡ÖvÁ§Ú‘Á®RÁ´NnÁº›žÁÀû‰ÁÇj¸ÁÍŸ#ÁÒdÁÔ·ÁÎ4PÁÇÃÁÁlÙÁ»2§ÁµùÁ¯\Á©&-Á£O×Á–qÁ˜ :Á’‘2Á:Áˆ$5Áƒ.]Á|žÁsj%ÁjÉOÁbsAÁZ¿µÁS}ÁLÓÑÁF¾ÁA& Á<;’Á7É…Á3ÓƒÁ0†oÁ-ÊFÁ+˜;Á)£„Á(lÝÁ'½ÓÁ'¶ Á(fWÁ)©Á+ÑiÁ.ãÁ2mVÁ6ÐeÁ;¦ÃÁ@Ë*ÁFàÁM¾{ÁTÛ%Á\ŸcÁe5ÁnTéÁw§Á€²ãÁ…ÆXÁŠùÁfhÁ•ØBÁ›fÑÁ¡*Á§Á­eÁ³ÅÁ¹;ÔÁ¿€¹ÁÅË ÁÌ$=ÁÑ ÆÁÕ¢ÁØÛxÁÒ|VÁÌ(îÁÅìxÁ¿ÑˆÁ¹ÛlÁ´{Á®JœÁ¨’WÁ¢ôÁˆ°Á˜6ÜÁ“ ˜Á޹Á‰;#ÁA¯IÁEÖUÁJ˜MÁO˜=ÁUT”Á[ôÑÁbåÄÁj5.ÁrP@Á{¾Á‚5Á†ãNÁ‹Ç€ÁÛÛÁ–©Á›‘&Á¡ÐÁ¦–…Á¬Y=Á²G#Á¸9cÁ¾=-ÁÄdíÁÊ­[ÁÐzùÁÔÏHÁÙV ÁÜüÙÁÖërÁд!ÁÊ›|ÁÄ¥ÉÁ¾Ö9Á¹&~Á³}IÁ­Ø_Á¨cLÁ£#8Áû‰Á˜ú:Á”%ÖÁofÁŠúÆÁ†Á Á‚ šÁ}ÁvymÁo¨<Ái’`ÁcÆ>Á^ÍÕÁZÁUíŠÁRSÁOX’ÁLÀØÁJµ|ÁHâ ÁGÎÁG ÁG$ÁG”ÁHàÓÁJå;ÁM’ÊÁQuÁTÞáÁY‘¶Á^zÚÁcéêÁj@†ÁqÊÁx ‡Á¿KÁ„¥Áˆ…EÁ95Á‘óèÁ–Ü5Á›ôÑÁ¡B“Á¦»ãÁ¬1ÍÁ±Æ?Á·ˆŒÁ½t*ÁÃjƒÁÉkÁÏìÁÔt…ÁعÁÝ.'ÁçµÁá¿!ÁÛÌÁÕò­ÁлèÁ6 Á.eôÁ'æBÁ"TÁÌ™ÁލÁåOÁLãÁTÁDHÁ§Á#]³Á)Á/ÐÁ7‚ŠÁ@}ÁI"´ÁRÛ¡Á[ÝàÁeFqÁob`ÁyݾÁ‚H#Á‡Ð¼ÁfRÁ“0iÁ™˜ÁŸÁ¥ëÁª4ûÁ®úÎÁ³ØÁ¸å£Á¾! ÁÃ}DÁÈþ[ÁÎ>ÁÔ:ÑÁÚ§ÁâÍÃÁÜ¿HÁÖÉxÁÐ×ÁÊý±ÁÅIÏÁ¿£PÁº iÁ´ž‘Á¯bÁª9;Á¥*6Á UùÁ›¿‚Á•÷Á1óÁŠyÁ„Ä-Á~XøÁs&DÁh<äÁ]~¥ÁSW»ÁI?·Á>Ï_Á5/=Á,KÖÁ$1ŽÁ%Á'ÍÁgÁç Á #ÒÁ ¤Á LÁÄÝÁ^îÁ„Á>§Á$•EÁ+ƒãÁ3›ÛÁ<ªcÁE¿OÁNòwÁXê«ÁcYáÁmÿNÁyÊÁ‚cÁ‡è«ÁËÁ“¶ÜÁ™¾‡ÁŸ€NÁ¤.Á©&Á® Á³CaÁ¸’œÁ¾´ÁÞ£ÁÉPÛÁÏ?ÁÕ¸ÁÞÁ×å(ÁÑÒ¹ÁËÝMÁÅìRÁÀ!Áº_½Á´¹—Á¯#°Á©¾ƒÁ¤‡iÁŸXÆÁšUôÁ••ÀÁ _ÁŠ«dÁ„ä±Á~WJÁrï#Ág¿çÁ\“oÁQ«dÁFÿÁ<ý‚Á3°iÁ*·(Á" $Á~ÁÁ †´Áî6ÁñÖÁ‹¸ÁÛtÁê:ÁÑÁÔûÁ .•ÁÄLÁ$ÁµvÁ&yÁ/© Á8±%ÁB|tÁLÛLÁWq Áb~ŽÁm§SÁyBxÁ‚IÁˆnÁŽ}.Á”ªªÁ™rlÁž0ôÁ£.þÁ¨eÆÁ­­}Á³ŸÁ¸¯‚Á¾jâÁÄ@.ÁÊ1¦ÁÐFÁÙŠ°ÁÓ<ÁÍUÁÆñRÁÀûƒÁ» Áµ2Á¯{Á©ÏÞÁ¤=ŠÁžßöÁ™­uÁ”†Á“hÁŠæ÷Á…V1Á~ÀïÁs/ŸÁg½°Á\V¶ÁQ(yÁFÀÁ;‰Á0‡ØÁ&¶HÁzZÁ²ÝÁ f°Áy”ÀûhÕÀñO,ÀéˆÀã‘êÀáüßÀâ.°ÀæLÝÀìòuÀöu–Á&ÎÁ Á[+Á•/Á"Š Á,nÁ6côÁ@èaÁKñ“ÁWÁb´UÁnh ÁzNÜÁƒ>iÁ‰hùÁŽÁßÁ“qàÁ˜^‡Á‹„Á¢ÑÁ¨1ýÁ­ÆÁ³ˆßÁ¹i;Á¿aðÁÅxŒÁË­1ÁÕ¨Áξ˜ÁÈm<ÁÂ4xÁ¼æÁ¶ŽÁ°,ÁªSÁ¤œŽÁžéÄÁ™\VÁ”PÁŽÝfÁ‰»ÆÁ„ØÁ€÷ÁtKÁh-1Á\–ÙÁQ%šÁE¿ZÁ:“EÁ/xmÁ$”ÔÁÊÁƒcÁXÀýœIÀí‡ÿÀÞk¾ÀÓÝÀÊbpÀÄ4ÀÂ>ßÀ“CÀÇ%ÀÎj÷Àز¼Àå„yÀôجÁŽˆÁ púÁ͆ÁöæÁ*eTÁ5iÁ@ÁL'-ÁWÔêÁcÄÁpAÁ|SÈÁ„AÁˆÉÛÁ¢ Á’À§Á˜hÁ\ŽÁ¢ëŽÁ¨¬ÓÁ®˜8Á´¹Áº±ËÁÀàÀÁÇ&RÁо™ÁÊMÁÃïõÁ½¡’Á·mÜÁ±T&Á«GÝÁ¥LÎÁŸsæÁ™¾¯Á”·ÁŽŠÓÁ‰:ÀÁ„§Á}ç‘Át@ÚÁi¸ÌÁ]‹+ÁQœ9ÁEÿfÁ:–Á/)ÍÁ$6Áñ¦Á·ÁÄÀô†¹À⣗ÀÒn£ÀÂaÀµ7šÀ«É©À¥À¢šÀ£ìÀ§ê&À°#¨À»—ÀɘpÀÚâ¦Àì°LÀÿ2wÁ ™*ÁëMÁæêÁ* 0Á5›[ÁAD:ÁM>3ÁY„±ÁeÜcÁrq%Á|]Á‚ú,Áˆ œÁJqÁ’™°Á˜!§ÁßÒÁ£Î€Á©Ü6Á¯ìºÁ¶†Á¼c,ÁÂÊëÁÌ‚ìÁƵÁ¿7Á¹# Á²ÖÏÁ¬©gÁ¦Á x¡ÁšwáÁ”šoÁŽáòÁ‰>ÿÁƒ½Á|Ú Ár~ˆÁhb,Á^ÂöÁS7ÁGÁ; Á/iËÁ#üÁ—ƒÁ sÏÁmÀï<öÀÛ ºÀÈ1ÌÀ·xÀ§QTÀ˜P¼ÀŸÀ†9SÀƒ!HÀƒ¯wÀ‰9ÐÀ’~#ÀŸQ‚À¯‘ÀÀ¬•ÀÓÙÀæ¡ãÀúþJÁnHÁ ÁsÁ*·ÁÁ6¾ßÁCDÁOlAÁ\ DÁgÁp­»Áz¹šÁ‚¥ÄÁ‡íjÁlÂÁ“&Á™˜ÁŸ Á¥.:Á«ZÍÁ±¬®Á¸öÁ¾«úÁÈ]ïÁÁÍÁ»PXÁ´Õ…Á®cÿÁ¨‹Á¡ÝÁ›µ;Á•¤2Á«ÑÁ‰ÃjÁ„ãÁ|åŠÁqÝLÁg:.Á\Ú ÁRãÁI<ÂÁ<¼×Á0zZÁ$‡/Á×BÁ mºÁ 5ÀíÛhÀ×ܪÀÂz·À®¢ËÀœMqÀŒ!þÀy–JÀ`©rÀO°#ÀGüUÀI^FÀV?™ÀkÅÀ„2À•ìÀ¦ìÀ¹é×ÀÎSÒÀä —Àú?„Á‰ÐÁ1lÁ E®Á,ƒ¼Á8þ‘ÁE²ÄÁQ£Á[i,ÁeaCÁoíÁz”ØÁ‚Æ«Áˆ€{ÁŽn%Á”t¬Ášƒ)Á ³xÁ§ tÁ­„’Á´ëÁºÍ~ÁÄrGÁ½¼ÈÁ·ìÁ°—ƒÁª!RÁ£¬¤ÁV¨Á—¨ÁâøÁŠÎéÁ„ØEÁ}Ü=ÁrRÁg;Á\,\ÁQ’ûÁGE&Á=,³Á2¬¾Á&D|ÁüvÁ õûÁIœÀíË{À× ÀÀèÀªýÿÀ–¹À‚„èÀbšÀC@ºÀ)²À}À 3yÀ ºqÀ‚=À4óÙÀS”}ÀuðMÀv‚À¡ë?À·FœÀÍ|þÀä¤ÀûiÁ ÍÁ uÁ"“~Á/lÂÁÁ†–ÁùgÁsôXÁh3ºÁ\ž¿ÁQPEÁF‰Á;ç°Á1xIÁ'@)Á¸ÁÅOÁƒ?Àî̼ÀׇÔÀÀÒ˜ÀªÉÀ”$À|Ë@ÀTuÄÀ.'À¹¿ç ¿ºüº¿Ÿÿí¿¦î¹¿ÍþÀ7°À ñÀC³Àk_‰ÀЉ°À ÒËÀ·#ÀÎŒpÀæ±7Àÿ>,Á 3fÁ0ÅÁ%üÁÁ0•qÁ:Þ$ÁEUÃÁPUÁ[âÁfƒüÁrbjÁ~QÆÁ…BÓÁ‹…Á‘ÿQÁ˜’{ÁŸ;ãÁ¥îïÁ¬¨pÁ³iáÁ¼ÚvÁ¶ãÁ¯3xÁ¨ršÁ¡ÉEÁ›3CÁ”¤âÁŽ1IÁ‡Ó[Áy.Áv€ËÁjYÁ^@´ÁRƒuÁFêûÁ;¥ÀÁ0åËÁ&ÁŽÁõŒÁ¹Àò¥&ÀÚçÀÁ½`Àª˜òÀ”ÕÀz×÷ÀO“±À% ¿üÔY¿»pᅥû¿;Tx¿碿5N¿bÀ¿¢ö¿à‡@À¦À<Š÷ÀhˆeÀŠk\À¡ä,À¹ÞEÀÒ„¡Àë×âÁÑ|Á&Á¾ùÁ%WËÁ0zÁ:ϘÁF2ÁQ‡òÁ]S‡ÁiDèÁu{­Á KÁ‡ŠqÁŽ,ðÁ”×wÁ›„kÁ¢H Á©LÁ¯ýÁ¹9LÁ²NÅÁ«vòÁ¤ §ÁÒNÁ—!Á‰1Á‰óXÁƒt Áz,ÂÁmwÁ`øtÁTÊÁH³…Á<ÌêÁ1.½Á&ÁþVÁ"ÓÁŠÐÀôçBÀÝä®ÀÅâ—À­ÌÀ”ÌNÀ{Ê=ÀO<ýÀ"¶ô¿òä8¿¥Xz¿BÓø¾‹{é½fÈ<µJ=¦«¾+»k¾ê׿‰ÞÒ¿Îö,À ÿÀ<]ûÀkSÀ3À¥ç›À¿‹ïÀÙÀò.êÁykÁktÁw Á%œ.Á0Æ8Á<^lÁHF_ÁTf½Á`ÀmÁmcÁzcÁƒÕ‚ÁŠ~½Á‘2ƒÁ˜ñÁžä¡Á¥ÇÌÁ¬±ÁµÖ¦Á®É×Á§ÒÙÁ ô*ÁšñÁ“JØÁŒÈÁ…ðLÁ~±ÁqžüÁdÑ ÁX¶ÁK˜pÁ?B@Á3-ãÁ'0åÁ}ÁTæÁúÀôdÀÞÀçÀÇçŸÀ°ÉEÀ™6ØÀýŠÀP'¹À#|r¿ï|]¿ŸÖ¿,úÒ½ºiº>ê¢ô?eKý?j‡?‰n ?*l`>Á-¾ã~¿y¨#¿Î¡ýÀKFÀAÍiÀs÷À’ì À¬ŒúÀÅXNÀÜ;®Àòz¿ÁjÁåÙÁkÕÁ'ÃÁ3JmÁ?ƒ!ÁL \ÁXÅCÁe¼“Ás™Á€;ÒÁ†÷ÄÁÎÁ”°ÿÁ›–ÙÁ¢†cÁ©‰×Á²¯–Á«‘+Á¤x ÁtWÁ–‰Á±tÁˆÝAÁ‚ÁvÒÞÁi›$Á\€êÁOÕÁBµÁ6BŽÁ)ÒÿÁ©¬ÁªÞÁÛ$Àõ ¦ÀÞE*ÀÇñ®À±ø‰ÀšïØÀƒµxÀX}À&R–¿ì˽¿—½¿Ã˾IK&>çt1?žmÛ?ïc%?óIS@ É?ÏN&?r<Ë>h(i¾Öù¡¿}Ñ¿×AÑÀ·,ÀLÿÀËÀ˜†ˆÀ¯|ôÀÆ0~ÀÜñÜÀôGÁáwÁÂÁÁ*qCÁ7–ÁD!ÁQ9ØÁ^„ÒÁkú@ÁytÁƒœ¥ÁŠ‚ðÁ‘i¡Á˜a>ÁŸkqÁ¦wÁ¯¥ÄÁ¨}VÁ¡]_Áš?ÎÁ“1PÁŒ;ÑÁ…P¡Á|åxÁoMºÁaë¬ÁT#ÁGdÄÁ:tmÁ-‹vÁ ûÁxÁ&ÑÀø0&Àà[ÀÉÀ² ¿À›výÀ…#ãÀ\.À-sοý#«¿›‘@¿Q ½Ç°…>»³²?‡úÍ?ê{@'Pd@9UU@9¦ï@¸ ?ÈÊ´?QÈ>6ðØ¾Ø‡Z¿‡ö4¿é4ðÀ&„fÀWi…À‚È$À™ã…À°ËIÀÈM"Àà+ÀøLiÁu™Á0mÁ"0ãÁ/iÁ<¬áÁIÿÎÁW}èÁe+?ÁrÞ®Á€SÌÁ‡H›ÁŽK"Á•UàÁœb:Á£|Á¬Ñ»Á¥‘æÁžbšÁ—6¾Á ïÁˆô(Áô÷ÁvhÁh7¹ÁZ‚uÁMöÁ?¾aÁ2tÁ%{†Á€‘Á °~Àþ%GÀå LÀÌ”)À´{ ÀœòæÀ…Ò¹À]ÊúÀ0†kÀ@m¿§" ¿¸z>ó?Ç©?£ ?Þf{@Úˆ@Nê@y.ª@oÖ@<ï©@ ‰Y?¿— ?3ó«>?¾¶¾ç%¿›ý4¿û¾©À,‹¦ÀZélÀ„„ÛÀœGGÀ´O³ÀÌÖáÀå×óÀÿþìÁ ÁU’Á'ÀêÁ5UÁB÷ÞÁP¦²Á^iÁlH®ÁzNìÁ„4íÁ‹@·Á’\;Á™ÇÁ ¨HÁª17Á¢ÖœÁ›ŠWÁ”PœÁ%pÁ…ûÁ}©'Áo•Áa¬yÁSÙéÁFçÁ8z¦Á+Á±ÝÁt¼ÁhÀìÎ%ÀÓ",ÀºGÀ ÇÀˆ­çÀaOPÀ2t®À°2¿­j¨¿!iJ=Ê8y?TÌ?¶ù?ë¼@âß@H·@x/ò@“õ3@‹:Ÿ@g±é@7ãr@‰k?¾Sç?`@.>àT¿¶¿§GÀñäÀ0^ûÀ`0èÀˆ[ À¡T:ÀºòŸÀÕ3ðÀï{€ÁA_ÁÇ&Á sàÁ.4<Á;÷¡ÁIêNÁWä•Áeó[Át‘Á)¦ÁˆN›Áu’Á–©5Áê]Á§¬1Á O¯Á˜û'Á‘­ÁŠbÁƒ&ÔÁwõ‹Ái®¶Á[ŠÁMsùÁ?’ˆÁ1ÈÏÁ$Á_ÆÁëgÀ÷ØÀÜsÀÂ-tÀ¨žÀŽkÌÀj =À9eÀ¯¿²Ðd¿,úÈ=Fðà?F/!?Àj|@Ž@2B@L¡@uG@‘j<@©N¶@¡w@ˆx¿@`Ó@6Üw@\£?Ã$?NÁ=¬u¢¿$¿¿¯‹×À©ñÀ9ÀÀkŸLÀ‚žÀ©÷ ÀÅ/ÀàC½Àûg«Á ~æÁMœÁ')õÁ5>ÁCaŒÁQ…²Á_Ç“ÁnÒÁ||½Á…{pÁŒÄæÁ”×Á›bôÁ¥YdÁçÉÁ–Á&ƒÁ‡ÚDÁ€Ž_Ár…‚ÁdïÁU¹=ÁGCÁ9gÓÁ+[üÁfCÁˆsÁÎdÀè8ÀÌä§À±ølÀ—$TÀyÊ;ÀE”iÀž§¿Ád¿@‘°¼4Ý÷?:'?¹Ù¶@ qã@:®@hj@‚U¢@’Ô»@§Þ&@¾é@µWÒ@›´@‡ú9@gÈ@9èN@ qè?¼xd?>´;< rT¿=Óc¿ÂøöÀsüÀHoÀ~fêÀšfÉÀµ³EÀÑA¼Àìá`ÁFÁU„Á vçÁ.·%Á<ÿ¿ÁKRÁYÇ ÁhhpÁw¼Á‚ؽÁŠ+Á‘dÁ™ÅÁ£(Á›­°Á”3†ÁŒ¾cÁ…XÁ|ËÁmpìÁ^ÞsÁPKÁAÞÿÁ3—»Á%QÍÁ ×Á ¯ÀõçÇÀÙénÀ¾J]À¢›À‡byÀXrÀ#1ê¿Ü½ÿ¿lº¾ŽG?!Vá?°ý @¿´@6¹ó@eUs@‰ùß@ŸÉ @­‘¢@¿±Œ@Õo@ÊÒU@´àC@ }c@‰‹r@efÂ@6ë)@\M?±è?!aA¾X€¿sÈš¿ä¼KÀ(÷…À_s)À‹NŒÀ§ˆÀÂÅÛÀÞáŒÀûBÁ ¾›Á/kÁ(æÁ6ý®ÁE¤•ÁTa¸Ác›ÁqÈÓÁ€S2Á‡Ñ ÁZ§Á–ÐêÁ¡6Á™ˆ•Á’ÙÁŠŒÁƒØÁwWÁh|$ÁY¹ÆÁKÙÁ<†3Á-ø·Ás±ÁÚÁÃÀèÇÎÀÌ€nÀ°UUÀ”E$ÀqFÀ9wIÀ¿™í¾½D>ä© ?ŸP|@ýn@1±ç@`õ£@ˆn@Ÿ€Ê@¶¹”@ÉØ @Ù Y@ì´›@áêµ@Í6 @¶7@Ÿ<_@‡é½@`è›@1W@JÅ?›tª>Ï˪¾äùÔ¿¦f¾À bDÀBÀy…»À˜äsÀµ3.ÀÑi8ÀîJ%Á¤Á/ïÁ"ÒøÁ1”ïÁ@^TÁO0Á^!Ám3;Á|OØÁ…¶”Á=ÉÁ”ÊëÁŸ/Á—šÝÁ áÁˆz¿Á€ìÿÁrÐâÁcàÁU¹ÁF1ËÁ7]ÝÁ(˜GÁú5Á f+Àù¨zÀÜ»ªÀ¿ø£À£(À†¹ÉÀUXÀÙv¿Ê]¿5²>Fê?| !?èb„@'n³@Y¥$@…GÖ@"_@´ÜŽ@ÌKö@ãyY@ôÿ‚A Í@ùø¸@âè†@ËÀ#@´sÍ@œÛ†@„àØ@X†@%<?߇“?d´V=­Õ¿Uùl¿Ú†ÛÀ%žÀ]ÛˆÀ‹^ÔÀ¨1¨ÀÅWÀâyÏÀÿÍfÁÏìÁÁkÁ,œÁ;ŠPÁJ¡¦ÁYÙ€ÁizÁxetÁƒÈšÁ‹h÷Á“xÁqÁ•ÇÑÁŽ$½Á†ˆÊÁ}ê„ÁnÎØÁ_µ%ÁPœ#ÁA‰/Á2’ÆÁ#¼ÁðÁ%RÀîÙaÀÑ›ÅÀ´JÀ—’ÀtƒßÀ:•(À‚G¿’- ¾‡?ˆ–?½Ó¨@É.@KO@L£@™…@±´X@ÉßD@á›V@ù"AAeäAº@øCí@àáo@É>Ã@±ó@˜%’@|D@E¢–@ì?®4y>úŒÑ¾Ä"X¿¢þ<À c?ÀD\ÀÀ~¹sÀœŠˆÀºçÀ×ðÀõêÁÁ ö2Áù Á(ŸÁ7]­ÁF±ûÁV …Áec¥Át¿ÂÁ‚ÎÁ‰Ç‘Á‘…3Áœ2Á”JÛÁŒ˜QÁ„åÈÁzj Ák„Á[ÏGÁLž2Á=‚uÁ.jÁUÁD½ÁL³Àäù}ÀÇeìÀ©ÕÖÀŒg\À^ -À"å¿ÑÄ¿;‰->) è?…ý"?÷»Ô@4!„@k‚@‘®@«––@Å=k@Þ …@öhîA%¯AïÊAžArÓA§…@õ¡ÿ@ÝW @ÃÜ´@©¢@ÔÕ@c±ƒ@+ÔL?çÿ…?kô<ýà¿aXœ¿ågõÀ-‚îÀiM À’ºÀ°ý‡ÀÏ.Àí3ùÁ×µÁ8 Á$œÁ4 ÁC^sÁRÄßÁb>KÁqÇÁ€®?Áˆ~)ÁC‘ÁšªÁ’ç¹Á‹+‰ÁƒuÁwøÁhñÁX´×ÁIQCÁ9íðÁ*˜¶ÁZVÁ 7{ÀúO ÀÜ0wÀ¾•À $À‚®ÀIà0ÀÀÙ¿¦Òè¾À\ó? ýé?ºÒ@»@Oé¯@„^+@ ˆB@¼¶@× Ù@ñA+çAq?Av^A(×™Að„A A‘@ïoô@Ô3b@¸7O@œ;<@€Aè@Gœf@!ç?¦¨\>ÈË¿ * ¿½GêÀ°OÀW=­ÀŠóÀ¨À‰ÀÇŒ™ÀæmzÁ¨êÁáÁ!ŽÙÁ1 ëÁ@œ’ÁP=õÁ_åÇÁo®Á5¦Á‡nÖÁ6ÌÁ—¢çÁ­ÇÁ‰ÉÓÁ‚A7Átô^Áek~ÁUèñÁFq@Á7Á'¦·ÁFÁæèÀóqÀÔ[úÀµöÜÀ—ÒDÀs_²À7Ý¿õýÁ¿~'1½„KI?]ÉG?åÙV@. õ@hæä@‘=@®U\@ÊÕ*@æö¶A1FAwíAJCA'¦QA,¤ËA'‹A¹ÖA <™@þ¬!@â­1@Æ¢@ª/‹@ó@_@[@$ ö?Ï®ô?.7ø¾u连ÊÀ Ë¢ÀJ:4À„GÀ£'àÀÂ5yÀá-ŒÁ!óÁðÁt¦Á/(ŸÁ>Ü—ÁN¡Á^%ÁÁmÊÁ}rÝÁ†xÁŽjTÁ”‡Áo’Á†zpÁ+QÁqޏÁcºOÁTžÁDs Á4ÑdÁ%6Á£5ÁÀí`ÀΪáÀ¯ü°À‘L`Àe4XÀ'οÕÃB¿9JÝ>c?” ´@7‰@B›@}•Ç@œ‰¯@º@×yÓ@ô‹$Aš8A¨ŽA ÷vA)Ã6A0kA&jRAoHA¯¾A/Ø@ðŽi@Ó@µ À@–Ã%@p¯@2Îè?êB?^$ǽȹƒ¿‰±Àc.ÀA¿«À€ÀŸ=‰À¾‘ÀÝóèÀýIqÁQ‡ÁÿÃÁ-¯ Á=dˆÁM"Á\äÁl¨@Á|nµÁ…üxÁŒêLÁ‘»bÁЇXÁƒjçÁxÔ;Ák}Á]{²ÁP êÁC óÁ3‚§Á#äZÁFÁ¬=Àê1RÀÊóüÀ«¶¥ÀŒ{°ÀZÐ0Àù<¿¾Kþ¿¬l>Þó®?²t@C@@SÏ@‡¢)@¥Ó‹@Ãç@à‚Ú@øÆ}A¿àA„+A 2KA*ìàA0¾AA%Ø2AzäAª¼Aí¶@ê­›@ÒI@¸Rq@›N@xk @:P,?÷™J?u(õ¼¯ä›¿€W[¿ýÖÜÀ=¡6À|ˆ À¿ŠÀ½:ßÀܬ~Àûÿ;Á ´¯ÁsØÁ-7Á<úOÁL½‹Á\m°ÁiâaÁw•Á‚ÅaÁ‰ÜšÁ\ÁˆÐÁ€ÈÁs@ëÁe*òÁWYzÁIÙÖÁÀ}›ÿÀž¦À½Q]ÀÜ£~Àü Á Æ4Á‰ZÁ-LÁ;3sÁHbÌÁUÕðÁcœÁq«[Áó¢Á‡6•ÁPdÁ…ì+Á}- ÁnŸaÁ`>üÁR¶ÁD?Á6½Á)r!Á›óÁgÖÁÝÀèŽSÀÉfXÀª@¨À‹íÀWÙªÀ9€¿¹šÜ¾þèF>æ]’?´ˆC@6`@MT@dÕ@››ð@µ§Y@Ð;!@ëXAÛBAV™AîA+§A0(üA#¡SA¦oA¨¬@õx}@ÙØ†@½¶É@¢â@ˆ@Zz@#Ù?×øÒ?=䫾Y2æ¿”åÀ4"ÀDW¤Àb·À Ç0ÀÀ!©ÀßC&Àþd¢Ák=Áµ=Á'ŸÞÁ4ßÁBZ¬ÁP1©Á^O_Ál¢HÁ{#4Á„Ý|Á‹˜`Á„ŒÁy^Áj«ÁÁ\(ÁMܯÁ?ËÀÁ1ùÊÁ$}—Á>‘Á ‘µÀýLFÀçoKÀʬ~À«áõÀ*ÓÀ\ÌêÀE¿ÄkÜ¿ùq>˜Ã{?™à@Í'@;.K@r~@“Ê)@®òp@Ë9‘@çAO¼AO~Ap÷A+™EA0Œ˜A#/aA A L@ð;ì@Óà@µóã@™K{@{@DÊÃ@ '?­!ó>õ–F¾Ò2y¿«nÀvÃÀO&÷À†.À¤” À½ÀáÜÀø XÁ…ÁÔ¬Á!úÁ/ndÁ=6ÍÁKRkÁY±Áh6xÁvÔzÁ‚ÍõÁŠNüÁ‚ÁüÁvJÁg ŠÁXè²ÁJb®Á< Á.ãÁ ‚6ÁL8Á^èÀô"gÀÝ^4ÀÈûÀ°t‡À‘±ƒÀfGÀ*Å,¿ß0¯¿Wfˆ=s|´?qn¦?ç»(@+J¥@b¡­@”R@ªÁ@Æ”2@ãuAoAÆAdA+ÙA0ðÎA"`†Aw«A³î@ì/ø@ÎðÄ@±ªÝ@“ñ@lÄ@1Yp?ðmì?}”E=ö”¿CWâ¿ÓGeÀ"ëzÀ]å#ÀŒàŸÀ«BÐÀÁÄ”ÀÖ~pÀí“·Á ÚÁøÁAÁ+ËÁ9›ÁGyðÁUñ+Ád›Ásd\Á¿Á‰nÁÁßoÁt¨bÁe©ÁVΫÁH! Á9¬žÁ+}ÐÁ¨+ÁEXÁE]Àí«²ÀÖ²:ÀÂH,À°PÀ—KœÀs~ŒÀ8eß¿üÔ+¿Š]¾L1ã?-­î?Èb‹@®Ð@YŽ@Š6Ÿ@§àÙ@Ť|@â®A6åA`AÙA,ŠA1Q A" ¥AÝHAÝþ@éõù@Ì0Æ@­–(@Žû‘@`Æ@#ÅË?Î.Þ?-n]¾pk2¿‘£ À(ªÀ9ÏÀr¾TÀ–ÜFÀ§g·À¹Í¡ÀΖ»ÀåñŒÀþ±fÁ a­Áú Á'ùdÁ6%…ÁD‘—ÁSÁa¶îÁpe¼Á<œÁˆß†ÁOuÁsŠ„Ád‹~ÁU±ÁÁG§Á8Ž(Á*SDÁeíÁäìÁó|ÀêÞÄÀÓ—ƒÀ¾ÛEÀ­èÀžeÍÀ®ÀHŒÄÀàP¿ª1.¾Üæ>ü²X?¶c‘@ͼ@R«Y@‡¬x@¦4ò@ÄÜó@ãÌþAgDA™A…{A.W›A2(/A"ä*A¹3A±!@êO.@Ë8[@¬!‡@¤@\Qx@¤é?½ñ7?15¾ó¿µ£ÔÀrÀRÖbÀ…î`À“Ú,À¢`ÌÀ´ÃþÀÉÎqÀáQ’Àú{cÁ E³ÁÞÆÁ%âaÁ4ÁBCÉÁP¸Á_v9ÁnBIÁ}$iÁˆ§Á„Ás7 ÁdEÉÁUqŠÁFÇèÁ8SÁ*!hÁHßÁãµÁþûÀë4žÀÔ[JÀÀFÀ®ŠÀ FlÀ‰(‘ÀWõúÀ›Î¿ÁgÌ¿ué>Ï$Ó?°$”@?ú@To»@‰„'@¨èÔ@ÇÈB@æ û ¬¾ÿäV¿¾´–À¸ À^ÌÀ‹»nÀ”EÔÀ¡í½À³_.ÀÈkýÀß¡ÀøK‚Á #;Á—´Á$RKÁ2a€Á@¾>ÁOPHÁ]ùWÁl̼Á{ÂÑÁˆÄ–Á9¸Ás{ Ád§šÁUõnÁG^ïÁ9†Á*ð²Á=}ÁçÁh¯Àî×ðÀØb"ÀÄ”ŸÀ³sÀ¦€ìÀºÆÀ]<‰À‡¿À¿¦Þ>ùdœ?½…½@eI@ZlG@Œ{»@«¸\@Êö@ê>£AÇA@-A#«A3pA5ÁõA&YÄAù•Ar‡@ï#¸@Ïn@¯Ë @Fè@a²ó@"’?ÇX(?{r¾ÏrÕ¿±w$À­$ÀW_À‹?8À—¦À¤®‘Àµ÷ÀÊCkÀྐྵÀøÌ½Á 0ÍÁdõÁ$\Á2(ØÁ@iñÁNáÙÁ]yåÁl0™Á{™Á‰NÁ±!Át‘sÁeÏ€ÁW2ÛÁHÌiÁ:¨·Á,Ø'ÁpWÁ…Á& ÀôÖÈÀß.ïÀÌ(žÀ¼ yÀª‡oÀŠÆ ÀUâÀ?Á¿®7¾Â2ù?Z?Ë@$mÂ@cTx@‘ì@°•ô@Ðé@ï‹ÞAjvAñ4A&wóA5ù A8Ž(A(ÍA©A n’@ó¥ß@Ô½@´…K@”êÚ@j Ò@+l ?Ø©o?5w¾‘.À¿£L¼À&äÀP§iÀˆøÀŸŠªÀ«([À»’ÛÀÎìÀä¨fÀûÕÿÁ `°Áa¬Á$É_Á2žÁ@±ÅÁNøjÁ]l²Ákþ¶Áz´ZÁ‰UaÁ‚Áu‚Ág¦ÁXÒ¥ÁJÐÏÁ=“Á/„ Á"WpÁ©™Á ªœÀüŽsÀçäÀÕÿõÀÆ„;À§-ãÀ‡<ƒÀN˜!ÀÅ连H#¾z';??|¨?ÞÁ@.Øñ@n.û@–ƒ@¶î@Õ{ç@ôÞ:A mAÂrA)oA9NA;)^A+€cA³*A Þç@ø;@Øb¨@¸´³@˜íò@rNb@2Àà?æf¼?N—p¾>z]¿–êOÀ ©ÀJ™À…"À¤üXÀµÊ€ÀÄyOÀÖ¦ˆÀê÷;ÁÂúÁ ¾‡ÁipÁ&–ûÁ3ûÂÁA±÷ÁO´1Á]û_Ál{Á{2Á‰ØãÁ‚¤kÁvè»Áh´ÁÁZ¼)ÁLïÓÁ?{>Á2oýÁ%¬3Áq¯Á ½ Áí%Àò|ãÀádÌÀÅwËÀ¥…XÀ…“÷ÀKE.À bm¿–ÿX¾9α?QW?èQ-@4 W@sî@™è‹@¹Ú}@Ù̸@ù¿!A ØÔAºýA,€A Á3MƒÁ(ˆ¿Áj$ÁïÁ2ØÀꑃÀʽUÀªê À‹ ÁÀVÙ8À’+¿°–;¾È „?¹?Ë#@$Ë”@c1þ@Õø@°#n@Ïi@î“„A¯KAdLA×±A":£A ]kAJpA úû@ùÕ@Þ1@Á´Î@¤ì@‡_©@SšJ@ ñ?³>è.}¾ýßr¿»ÝSÀÂ*À[3ÿÀŒÒêÀ¬ ÕÀË:¡ÀêuUÁN@Á AëÁJ"ÁGÀÁ)ô%Á5I|ÁA:kÁM¯wÁZ‰Ágª ÁuÖÁVOÁ޽8Á‡á|Á'dÁu!øÁh<~Á[½ÛÁO¬¯ÁDÁ9*àÁ.ØhÁ%EµÁñùÁvÀîšÀÎó·À¯MjÀ§À` À É ¿Äoú¿FO>Ô¦«?±ñ9@#ò@Ud¹@‰Ø¹@¨8…@Æ@×@ã|'@ÿ‘JA ÎÞAE'ALÈAA (#@ÿ\«@æöû@ÍIv@²ˆ€@–¤Ÿ@tP²@;&ð@k?‰äÄ>Õ”¿K´•¿ßp‡À,zÀi<ÝÀ“b†À²¬ÀѼ†Àðé‘Á OÁçÒÁ!]Á%|Á/ÌÎÁ:åkÁFkœÁR“Á_ÊÁkæ ÁxîŸÁƒ"œÁÛ³ÁŠêÁƒ}÷ÁzÁm‹kÁag‚ÁU³2ÁJpiÁ?»Á5¾óÁ) Á8iÁ glÀóChÀÓÚ&À´ÇÀ•j“ÀlpøÀ.D7¿à6[¿GÈ>Cn[?“œo@$è@B‰Š@~¶@œp@¸n£@ÓŒ¼@ëï*@ùÙ[A´AcRAšn@úz@é¿@Ò$”@¹ü@ ½]@†ŠW@V_Ò@0U?Êo?0 ¾iÊ¿“k ÀÚÀ@!~À|­Àœ·¨À»ÎÀÙ{÷Àø#vÁ …oÁ:Á$õÁ,ã>Á6…—ÁAÜÁL3¨ÁXsÁdA®Áp¹¦Á}zeÁ…HdÁ“7*ÁŒ˜hÁ† +Á¦fÁs`”Ág‡BÁ\4ÁQ\“ÁG²Á;XeÁ+¬‘ÁÈÁ wJÀùÕ ÀÚÀ…À»¬ÀœœkÀ{ QÀ=Ì¿ÿW¿‡”/½øS?Rˆ&?ßI@) r@bƒ@@Œ|³@¦óA@¾ê@Ðu@Ûp;@â+@äøS@ã–R@ÛÙì@Ð~™@»å8@¤ì´@ C@h(@3üz?ý©?–>qv¬¿'„ˆ¿ÅÓ¿À8dÀX\ À‰¶À§>ÀÅfÀãRÁÙÚÁ mÁ=qÁ,¤Á4àÊÁ>•ÁH1GÁRúåÁ^C ÁjÁvRxÁ_§Á‡ÀŽÁ•ê½ÁkêÁ‰×Á‚îpÁyù1ÁnŒ‹Áct:ÁXØ9ÁNCüÁ>º#Á/3,Á­ Á&éÁ ÈÀâ5NÀÃ=¨À¤§‰À†"ÀQYïÀy™¿²ß¾û>I>ÐÏ@?§‹§@ +„@A©‡@tz@‘Òz@¥_t@²õ˜@¼‚Õ@ÂŽ(@Å*@Ãõ›@½ªý@³bš@£º @ޝ±@oj’@@E1@%G?µÈ?øé¾€Ú|¿ŽšxÀÀ8ú ÀqùLÀ•ëûÀ³hØÀÐðÖÀîxÔÁ–Á·Á$(©Á3WáÁ=âÁF…ÁPÁZI©Áe5ÌÁp³Á|'Á„TŠÁŠXÁ˜öÒÁ’™jÁŒfÁ†cKÁ€—ÒÁuþÁkCÁa&‰ÁQôÁBtÚÁ2ó[Á#pöÁÐÁÀÀëU9ÀÍeÀ¯u]À‘†4ÀgÅÀ-Ëù¿è=пiÕ½¹?P,y?ÑãŠ@@I’a@sK@‰;%@•Ó@yý@¢ù©@¥[±@¤dý@Ÿ)û@•Y=@‰Bh@m»@BôS@þP?Ì»Û?P‰ý<ÞÓì¿Jgä¿Ð¯À¸óÀV3½À‡5À¤ {ÀÀ„™ÀÝZ5Àú¨(Á ÔÁÙÓÁ)¥FÁ8—ÆÁGDEÁO­ÁXÖÁb}ßÁm PÁx´ÁÌÖÁ‡¬Á¿SÁœ$2Á•ïïÁéÁŠ4Á„v Á~pÁs›PÁeA6ÁUÏãÁFqêÁ7-×Á( ‚Á+Á —Àö@ÀØiWÀ»ÐÀžÒÀ+IÀICÀîM¿³&•¿Œ‚>}ÅD?ƒ^5?ß”î@Ù·@<²;@XPh@m/a@|âK@ƒe)@…_@„ÖX@€>«@n°@X«Œ@;1l@>?Ñ‹?jSt>?Gª¿ë濯T0À ²,À@*¹Àv©ûÀ–¹ŸÀ²ŸúÀϪÀë•ðÁÿ½Ák3Á!&Á/´9Á>w<ÁM=ÁY ŒÁa¸÷Ák+jÁuL"ÁñqÁ…‡­Á‹AðÁ‘(4ÁŸ¤ÀÁ™”¸Á“³ñÁŽGÁˆ• ÁƒHÆÁxáÊÁi¤ƒÁZ€ùÁKo×Á°*×?BF?Êòí@Y@¡,@0-@>¾q@G¡T@K~@Jg@B¦µ@2½“@6»@æ‡?ÃÀ±?g}Ü>aãt¾þ¤¯¿œéð¿ÿpÀ1žKÀdÙNÀŒ˜6À§M‚À£ÐÀÞ#UÀú*mÁ SÁ‡Á'¾Á6)ìÁD¹+ÁS]6Áb Ák^ÈÁtqÚÁ~'yÁ„0¨Á‰“ÊÁ!×Á”àÒÁ£vgÁŒÁ—ÒÁ’O²ÁŒ÷VÁ†|Á}à¹ÁnÓ÷Á_ÙÔÁPã0ÁB.Á3WTÁ$·÷ÁþÁ¹ìÀóÎÀÖäÀººÀŸSÒÀ„÷dÀVnÀ"`ç¿ävŸ¿‡‚¾ÃÛJ>]|m?:¾?”øñ?Á¥°?æU­@]@g@ áÛ@ Bb@Ð?ì\?Ä’v?•)é?2Ÿ>,x¿.]¿˜™®¿ô|À(ÞkÀY]vÀ…ЉÀŸÀ¹$OÀÓp½ÀîœSÁùZÁÇcÁ Û)Á/ÂÁ=C0ÁK~ ÁYé8ÁhuÁu®—Á~]ŸÁƒÏ¤Áˆ¿2ÁõzÁ“VôÁ˜í|Á§ŒšÁ¡ÎšÁœ<Á–ÍyÁ ÌÁ‰<ÁŸ˜ÁtWëÁe’‚ÁVÛÁH& Á9Á+GÀÁœÁàãÁØiÀæ?uÀË8À±}À—7–À{\8ÀL7™À…¿ä\п–‚®¿!MѾ"M>s¡?¨_?Ut?ƒ¤¿?‘üm?˜?—N"?‹ô?ck?Zá>€”ˆ¾+|¿*j|¿£u“¿õíJÀ&°ÀT§{À£ïÀ™—ZÀ²Æ1ÀËÏÆÀå¸rÀÿãoÁ L\Áõ“Á(¤þÁ6\ÁDœ=ÁRËÝÁ`ÿKÁo=áÁ}¨èÁ„dõÁˆØîÁ˜:Á’—”Á—×6ÁG´Á«ÞãÁ¦AäÁ Ì¤ÁšÉÁ“Q&Á‹àˆÁ„|›Áz:Ák˜cÁ]9ÁNÏ_Á@…Á2QŠÁ$T5Á–6Á |À÷:aÀÝ@ëÀÔêÀªM¬À’ÙUÀweÀKá¹À$p¿þfØ¿¾8±¿†·¿1EX¾ÇõD¾Ã=(šU>ô>K!»>@À0=Ù™ˆ½¢°ì¾°Üì¿*K8¿‡E¿ÃíÀ´XÀ+ˆZÀUa³À€€jÀ—ˆwÀ®Ø¨ÀÆêÀß®ÐÀø¹ÕÁ /ÈÁ7ÄÁ#f$Á0ñÕÁ>œüÁLR5ÁZ>¨Áh[XÁv‡ùÁ‚]³Á‰~øÁŽ.Á’”Á—ibÁœ/Á¡Õ=Á°dÚÁªâ¢Á¥6Á¹Á–*çÁŽÑÌÁ‡ˆŒÁ€QÚÁrVÿÁd œÁUÉ¢ÁG¹ãÁ9ï¬Á,L¤ÁÖîÁ¡˜ÁÎÀïòIÀÖúÀ¿–ÝÀ¨¯êÀ’Ê…À|ù‰ÀWIìÀ5)ÝÀñ¿üZ¢¿ÏÏQ¿«ÎÒ¿Žº5¿r63¿UÞ¿JM¿L¸$¿`ÆS¿…°¿¥¦P¿Ì E¿ü#2ÀV À8–À]†iÀ‚¥¾À—æaÀ­©9ÀĽ0ÀÜ bÀó¢ÁK¸ÁÙ0Á„EÁ,‚oÁ9™­ÁFölÁT™>ÁbDŠÁpYÁ}þÁ† fÁ"9Á“o‘Á—ÒÁœ}ñÁ¡l»Á¦˜„Áµ½Á¯?Á§ÛžÁ †bÁ™A‰Á’†ÁŠí¾ÁƒÊ#ÁyJßÁk"TÁ]1ÁOáÁB \Á4ÉGÁ'¬ÁætÁ+YÁÖRÀìdSÀÕ¶´À¿¤-Àªë2À˜ À†ØÀm?ÀQ'¬À9µ¦À$¿©ÀüŒÀ½ü¿÷Z¾¿é@2¿ã}„¿ä÷Ó¿î5Àc&ÀOPÀ"eDÀ8¶øÀQŠ[ÀoùÓÀˆ1&À›¬=À¯”*ÀÅóÀÚÔwÀñë°Á¡ Á_êÁÀÁ)WsÁ5æjÁBÕ†ÁOÝfÁ]íÁj•èÁx@§Á‚òØÁ‰ÛÁß!Á—í=ÁKÁ¡Î÷Á¦•xÁ«™zÁ¹#Á²7öÁªñ}Á£»«Áœ—>Á•xÁŽ^wÁ‡KGÁ€FÄÁrÁÕÁe=ÁWö ÁJÃ"Á=¿›Á1Á$jÁ4Á §„Á^¿Àì}ÖÀ×u–ÀÄq'À±Õ;À¡YÀ“AÀ…à Àu;Àa¨iÀPqcÀDÞÀ:¯xÀ3È­À0÷1À1ЗÀ6lÀ>»ÀL-æÀ^ÊóÀs*wÀ…ÏñÀ“¿^À£;¹À´Â·ÀÈ•FÀÜ–“Àò9RÁÁ„hÁ;jÁ&ò‡Á34²Á?ËÂÁLV?ÁY)=Áf(½ÁsDgÁ€QÁ‡tÁð‘Á”ÆÂÁ›·`Á¢¿AÁ§V±Á«õæÁ°ÒáÁ¼¡æÁµi'Á®>™Á§#ºÁ [Á™”Á‘þˆÁ‹ßÁ„<˜Á{wÁmÇÐÁ`¨·ÁSÓVÁG1”Á:¿LÁ.”òÁ"ù ÁÌfÁ ¨¸ÁMÀð×@ÀÞ'ÀÌ|AÀ½°èÀ¯yçÀ£‡JÀ˜lUÀ_À‡ZöÀ=ëÀy±’Àrø@Àp/ Àq%DÀuŒÀ|ÚSÀ„ÛjÀ’+À—¾À£XÀ¯ß÷À¾í¿ÀÎð(ÀášÀõ\ÙÁÑ Á°ØÁ—mÁ&vÁ1ÕÇÁ=‡‹ÁI¯ÝÁV@ÁbÏSÁoÁ|{CÁ„Á½Á‹`ÜÁ’ŽÁ˜ïÀÁŸ¾ÏÁ¦ÏÁ­ 8Á±ƒÅÁ¶:,Á¿èÁ¸ÄÄÁ±°ÄÁªª`Á£´eÁœÅ]Á•é ÁUÁˆeJÁÊ Áv˜NÁiêìÁ]g•ÁQrÁDõúÁ9M"Á.ÓÁ"ûÁ`ÔÁŽþÁ!yÀø1ÂÀè6ÀÚÓÀÌuÍÀÁDñÀ¶« À­î´À¦ˆ­À ‚XÀœYÖÀ™.¥À—¹(À˜<øÀš$þÀÀ£¬kÀ«¾ÝÀµ5DÀÀ9À̉IÀÚðUÀê,ŠÀû1:ÁAˆÁÁZ4Á&EÁ1.Á<¤vÁHp$ÁT2Á`1ÆÁl´aÁyKBÁ‚ò„Á‰g}Áç‹Á–x'Á'VÁ£ð0Áª½ÔÁ±Á·5ýÁ»ÇÏÁÃOvÁ¼GÁµQÍÁ®nÁ§šrÁ ÄÁ™û4Á“I¬ÁŒ¸¥Á†MîÁ€ÁÁsOÁg=CÁ[FÇÁO¥¤ÁDkÛÁ9MÞÁ.®àÁ$Â}Á4[Á Á —¾ÁEÀö^¡Àê ÀÞÂÀÕ¿ÀÌ~¢ÀÅ– À¿ÌXÀ»ÚâÀ¸é#À·^§À·çOÀ¹Â·À¼é-ÀÂÆVÀÉñÀÓa2ÀÝqkÀéª À÷ ÝÁ3Á äPÁßéÁ®˜Á'€oÁ1åyÁ<Ù7ÁGÅ¿ÁS6ìÁ_ €Áj¶Áv¸•Á”YÁ‡àÁŽ)CÁ”‘‰Á›€Á¡–.Á¨7ÂÁ®ó>Áµ½ Á¼‹èÁÁVÁÆñKÁÀ áÁ¹5åÁ²gpÁ«÷Á¤Û¬Áž3äÁ—¬QÁ‘IKÁ‹¬Á„ÌMÁ}l›Áq’äÁfÇÁZ½yÁO æÁDþDÁ;OÁ1>Á(9ÁcéÁoGÁy2Á “ÁÔwÀü¡Àó~¾Àë;òÀä‹hÀßcÀÛ=ìÀØ’fÀ×®À×{zÀÙ0ÊÀÜ:pÀážbÀègÀñ Àû¹ÁnrÁ ¾ÎÁ»ÁŒÃÁ ì„Á*>ÂÁ4ÈÁ=ü£ÁHr$ÁSmgÁ^]ÁiÊmÁu¤ÝÁ€§WÁ†¡‡ÁŒÏÁ“6Á™c¼ÁŸ¿pÁ¦:\Á¬º¹Á³NˆÁ¹ýÊÁÀÁÁÇbøÁʽÌÁÃãsÁ½fÁ¶t!Á¯¿+Á©!Á¢¡·ÁœEÁ–¥Áà·Á‰ÔÁƒó;Á|oMÁqÅÁeé¯Á[N—ÁQ@!ÁGXiÁ=æTÁ5W–Á,ñÑÁ%‰£Á”¢Á>\ÁƒÕÁ iïÁößÁÁËÀþp½Àú«0Àø#Àö£À÷¼Àø‘Àû£îÁ6iÁÁÂ[Á “îÁRÁ"ÖÁ^Á&vWÁ.UµÁ7åÁ@¬ôÁJaÁT}¦Á^ÿÇÁj–Átô’Á€/YÁ†ÀÁ‹ôÁ‘è-Á˜ UÁžT^Á¤ ´ÁªñØÁ±d8Á·ã_Á¾kÀÁÅ©ÁËÈÁÎ¥ÁÇØAÁÁ9ÝÁº¦8Á´®Á­›wÁ§C“Á¡ UÁšù¡Á”óIÁ¢Á‰Y,Áƒ§ºÁ|'%Áq‡’Ágv‘Á]ÌÁSÑ|ÁJî&ÁB²áÁ:ÅËÁ3˜pÁ,ÙÁ&ú‹Á!\ÄÁ„wÁ@ÓÁzdÁh”ÁãDÁ :Á ×CÁ "ÜÁ BþÁ ù(Á ŠÖÁ¤šÁçªÁÖÁ¡rÁ ±ªÁ&ŠÿÁ-3Á4Á<¯ÁDO(ÁM`hÁWôÁ`Ç‘Ájþ²ÁuŽÁ€IÑÁ…Æ Á‹yÅÁ‘bÁ—@éÁ/îÁ£KÿÁ©Ž†Á¯Ú>Á¶'íÁ¼YÁà ;ÁÉŽ§ÁÐ%fÁÒwÁËù%ÁÅ}„Á¿ çÁ¸˜¸Á²B#Á¬ 6Á¥ô_Á OÁš+Á”m[ÁŽ»Á‰.½ÁƒÜ`Á}–QÁsžüÁiÓÁ`¨„ÁXD|ÁPIÎÁH§ÁA¦ñÁ;dÚÁ5¨úÁ0hpÁ+œOÁ'¡åÁ#ó·Á! ÛÁ‘BÁÂÝÁœ–ÁôEÁLÁ©‰ÁCµÁ*æÁ"D¾Á&xÁ*•ZÁ/‰·Á5 Á;UÚÁBf”ÁIܱÁQÈòÁZjzÁcµÁm_$Áw8\Á€¿ëÁ†Á‹’[Á‘ÕÁ–ÄkÁœ¨EÁ¢ŽÁ¨x‘Á®ŽÁ´È­Á»cÁÁa ÁǾ€ÁÎ7ÁÔ¶MÁÖ¯€ÁÐ9ÁÉÞ°ÁÖÁ½@°Á·RÁ°ïYÁªüWÁ¥2KÁŸ~QÁ™ÍÁ”BwÁŽï*Á‰Ù#Á„Û„ÁßôÁv‹&ÁmÜÈÁeÐ9Á]÷SÁV¢{ÁOõÁJ®ÁDsÁ?kÇÁ:ÊÁ6èâÁ3nÆÁ0ª¸Á.D‰Á,z¡Á+aéÁ*¹žÁ*¸Á+Z Á,Ù¾Á.¹‡Á1¡ÜÁ5jgÁ9“nÁ>xKÁC³hÁI£ÑÁPuäÁW²gÁ_s½Ág¸ÍÁpžUÁz §ÁÛ¿Á†ØsÁŒrÁ‘V#Á–Ø!ÁœXÁÁ¢ pÁ§èÁ­× Á³ÁìÁ¹Ð«ÁÀ»ÁÆN‹ÁÌœ³ÁÒñ-ÁÙaÁÚó±ÁÔ ÁÎ_iÁÈ-ÁÁÿ¡Á»ê…ÁµóÓÁ°%uÁª|¡Á¤ßDÁŸV2ÁšŒÁ”ãÚÁç‹ÁŠ÷’Á†AìÁÏkÁ{?ŸÁsghÁkÄÔÁd¼DÁ^}×ÁX’æÁSUaÁNXÁJXÁF-ŒÁBëHÁ@?pÁ=ùùÁ<4äÁ;'<Á:vŒÁ:l^Á;AÁG©ÁAHÁD§ÈÁH³JÁMmOÁRt©ÁXÂÁ^‘FÁe¡aÁmïÁu:°Á}ÇvÁƒrÁˆ>Á $Á’³Á—>±Áœ–çÁ¢fÁ§š°Á­MðÁ³)Á¹ÚÁ¿ oÁÅÁË@çÁш³Á×Õ¯ÁÞ&ÖÁßY/ÁÙ6ÁÒóòÁÌê6ÁÆß¨ÁÀñ)Á»"ÈÁµy¸Á¯ìÁªhCÁ¥@ÁŸïrÁšðçÁ•ø)Á‘@ãÁŒ¿lÁˆp)Á„\ÑÁ€‰SÁy²OÁs ·ÁlûýÁg>XÁb4”Á]\ÁYB”ÁUx3ÁRh[ÁOÓ,ÁM¯jÁKæyÁJîcÁJ6ÁJ"ÜÁJÙÁLTÁMÖ*ÁP[ÁSè´ÁWÜ­Á\cÁa]"ÁfªwÁlÌQÁs¸ªÁzäbÁWhÁ…Ž˜Á‰è¹ÁŽyPÁ“:™Á˜6ÁHèÁ¢rXÁ§ÑéÁ­V«Á²Ü·Á¸vÁ¾j¢ÁÄT©ÁÊG/ÁÐU>ÁÖâÁÜÂÚÁâ…fÁåáºÁßêþÁÙôŽÁÔ 5ÁÎG°ÁÈ¡_Áà ØÁ½‹îÁ¸8—Á³sÁ®úÁ©#eÁ¤PúÁŸ¿GÁšö‰Á”¡ØÁŽkòÁˆeÎÁ‚–ÁxúèÁl²1Á`ÁìÁUYíÁJhsÁ@=Á6i]Á-RUÁ%DìÁm–ÁqÁëcÁÐûÁøÁJ4Á_GÁf'ÁçÁê>Á°”Á&ÎÁ.ÓÆÁ7¡ÁAQ©ÁK“:ÁVƒÃÁaà{Ámœ—Áy5…Á‚EÁ‡ˆÒÁ–Á’ë€Á˜ëÁžÙõÁ£a–Á¨²Á¬ÍoÁ±©}Á¶¼lÁ¼xÁÁz/ÁÇãÁÌ—¦ÁÒI ÁØfÁàîäÁÚé”ÁÔòÁÎû½ÁɃÁÃPÈÁ½¥ Á¸lÁ²‹/Á­B&Á¨-Á£.)Áž=³Á™ƒKÁ•jÁïÁ‰ÿ\ÁƒÊFÁ{ˆÁoñûÁd¼¸ÁX{ÁL±ñÁAThÁ6p5Á,XŠÁ# ¯ÁvmÁªÁ XÁ™ÁSÁgÁ¼bÁâ³Á "ÁýVÁ+ÁyÁþÁÁ$W@Á-‚ÆÁ7t|ÁB5ºÁM†ñÁWö²Áb›ÐÁmj¬ÁxrÄÁÎiÁ‡žcÁ£‚Á“NÁ˜ |Á0Á¡ø‰Á¦Ï@Á«ÕÁ±ÐÁ¶‚ûÁ¼GÁÁŸÁÇQ?ÁÍ)×ÁÓ&ÁÜ&vÁÕÿ‡ÁÏñÊÁÉø ÁÄÁ¾ÖÁ¸Z$Á²­”Á­ {Á§• Á¢UÁ?ôÁ˜=ÍÁ“c ÁŽÅ=ÁŠRýÁ„¹¢Á~rÁrCÁf‡ÁZÿ½ÁPÁD©)Á8ÿÁ-ÊYÁ#)øÁxúÁŸ0Á» Áõ½Àùz£ÀñJ™ÀíûÀì …Àî&ªÀóØÀû(zÁ óÁ ÃÁ¡¢ÁsNÁ#ýdÁ.>-Á7’]ÁAl1ÁL•ÁVÍcÁaÓæÁlü‡Áx£·Á‚\CÁˆABÁõ¦Á’jnÁ—'BÁ›ûÁ ù$Á¦.VÁ«˜Á±IÁ¶¨æÁ¼YìÁÂ4™ÁÈ5'ÁÎWíÁ׎åÁÑE­ÁËSÁÄýôÁ¾þåÁ¹ ŠÁ³"FÁ­cÁ§¹?Á¢%Áœ«µÁ—sªÁ’U¿ÁTèÁˆ– Á„ 2Á~ŠÁrÕ ÁgpQÁ[ïýÁPµ8ÁEužÁ:t9Á/¼›Á%ɆÁÐÁÜÚÁ¦Àþ—äÀïÜÀä§jÀÜ:À×oÀÖ:íÀ×ñAÀÞ»ÀæXÀñæÀÿz)Á´œÁ’Áû+Á!>Á*ç‰Á5jÁ@0ãÁK5 ÁV\MÁb *Án%aÁyëùÁƒCÁ‡¹ðÁŒ\~Á‘(pÁ–§Á›PgÁ £%Á¦!PÁ«· Á±jøÁ·E§Á½HÁÃoüÁÉ­ÀÁÓ&öÁÌ¿vÁÆnkÁÀ2ÖÁºÚÁ´ ¬Á®+Á¨0øÁ¢tIÁœÎ`Á—2«Á‘ËâÁŒ–¨Á‡oPÁ‚|‹Á{°lÁržäÁgñÁ\7MÁPÐ8ÁEPÁ:HÁ.×]Á#ÕÁ3ÒÁcÁù–ÀùÁÀé’dÀÛv†ÀÏàÀÇa´ÀÁÒÀ¿`?À¿˜ÒÀÃΈÀÊ^ÀÕh ÀâT}ÀñÜlÁÉwÁ ðgÁkcÁÒYÁ)•uÁ4–4Á?¼*ÁKv¢ÁWˆÁcWnÁož¼Áz#ÆÁ¥¡Á†XÁ‹DÀÁrËÁ•»µÁ›*ÛÁ ÇüÁ¦†2Á¬cGÁ²h=Á¸“¹Á¾ÕÇÁÅoÁÎϸÁÈYòÁÁôúÁ»ŸÁµVÁ¯)¯Á©$bÁ£4LÁLµÁ—ŽÑÁ‘ä§ÁŒKòÁ†íôÁ»öÁy.Áot¾ÁfE Á]4ÁQY‘ÁE™òÁ:0Á.°=Á#uˆÁ9ºÁ 60Á³GÀòÃÀßeWÀ͘³À¾¨$À±“"À¨œ‚À¡dóÀŸdôÀŸº)À¤MÀ«öÀ¸MÀÅõ}À×3qÀéYàÀûø—Á<Áú Á÷bÁ))Á4ãÞÁ@êÕÁLÅÁY%ÅÁdݯÁméÔÁw0ïÁ€pÁ…•nÁŠÛ–Á>Á•ÜZÁ›¦{Á¡ Á§–½Á­Ä½Á´ ÁºQGÁÀ± ÁÊ‘cÁÄ uÁ½Ž•Á·*ÑÁ°ÔÁªƒÏÁ¤RÿÁžIÁ˜TáÁ’léÁŒ¯±Á†ü—ÁfmÁx&.ÁmÑ ÁcžŸÁZ·ÁPäÁFç¥Á:ÄUÁ.üèÁ#Á­Á ÖÁ Àí/§ÀØz¥ÀÅŒûÀ²ï»À¢R À“öÀ‰ÃšÀÐÀ~ÔÀØKÀ„î—ÀŽ<©ÀšÖwÀª×TÀ¼õÑÀÏE|ÀãPÀøÀUÁX˜Á|XÁS…Á*MÁ67UÁB³6ÁO2HÁXˆhÁaÛqÁkc"Áu‰¬Á€·Á…a÷ÁŠúµÁÌžÁ–ÃÝÁœÑìÁ¢ùÁ©;MÁ¯‘­Á¶hÁ¼…9ÁÆo6Á¿Ó«Á¹NˆÁ²ÐïÁ¬`Á¦nÁŸ¸ÐÁ™ŒBÁ“xœÁv´Á‡ÁÐÕÁx;íÁm£ÁbˆðÁX3ÁNlÁD³Á;sLÁ0Q?Á$2;Á`RÁ ïìÁqnÀìnÀÖÖÀ¿õÀ«¤[À™+À†ÖCÀn…°ÀU˜ZÀEÀ>árÀ@vfÀKÉÝÀa¨LÀ}>—À˜NÀ¢À7À¶0ÀËŒ¤Àás¸À÷¹¦ÁÃðÁ°HÁ®RÁ,ÁW„ÁLîzÁB–%Á8˜ Á/9µÁ%ÚMÁ¼ØÁ ¤ÄÁÄnÀ쟥ÀÕ¥GÀ¿1ƒÀ¨Ó/À’¾“À}óhÀY—bÀ6ù´À ±Àcò¿ýè£À[NÀ ZÀ&ç@ÀHi˜Àlå9À‰$åÀž[<À´6nÀÊ{–ÀâkÀú& Á -Á·³Á"GwÁ.[Á7=Á@ÝÁJÀcÁUMÁ_ÛìÁjìmÁv†GÁF9Á‡R ÁqLÁ“¾ Áš3Á Ä¨Á§l4Á®$8Á´ßýÁ¾À@Á·ìHÁ±(!ÁªwÁ£à“Áb¶Á–ç¢ÁuaÁŠ)ÁƒùÁ{²ÚÁo¥xÁc¿ŸÁX.«ÁLðáÁAéÔÁ7Q–Á,÷Á#cÁ«bÁ‡~Á+…Àî5ÍÀÖSYÀ¿_rÀ¨gêÀ‘÷ÛÀw\ÀK#RÀ%ÂÀâê¿ÀÞ¿”G“¿||w¿…H]¿§]ˆ¿ßTÖÀŒ/À8!Àb]´À†ùÀ?ZÀµR:ÀÌíÄÀålAÀþy>Á ÛüÁÀèÁ!Þ•Á+Š Á5j³Á?ídÁJ•‰ÁU ‘Áa?Ám8ÆÁyMeÁ‚ÌCÁ‰ÁœSÁ–>¬Áœö±Á£°nÁªjÛÁ±/Á»RÁ´,›Á­X÷Á¦–9ÁŸÛŒÁ™4Á’ªvÁŒ3Á…½åÁ~ÙÁrfôÁfÿÁZ‰ÁN êÁBv2Á7<Á,:èÁ!©ŸÁl¹Á •mÁåKÀñàÀÙ@jÀÁ"ÑÀ©!êÀ’@ÀvUÀIŠÀ׿â2¿˜pD¿)ÞZ¾Hün;º]ó½|6V¾ËyJ¿r >¿¿ôîÀ#À3zýÀ`RÀˆ:îÀŸºFÀ¸Š#ÀÑœÀê÷óÁX\Á ‹{Á=¨Á M¸Á*˜àÁ5MBÁ@UÁKüÓÁWð…ÁcÿþÁpiïÁ}0€Á…#.Á‹ÍÆÁ’†ÞÁ™@^ÁŸý)Á¦Ï Á­ºÁ··Á°nÁ©Ÿ_Á¢ÅÁ›ý6Á•<#ÁŽ‹lÁ‡ô¼Áu¨Áv ÐÁiR^Á\ƒÁPh’ÁDIçÁ8hÁ,ÉÁ!n•Á–:Á ©ÁÅOÀïˆ[ÀÛ8Àij¡À¬@$À”4ÀwòÀI¾ÀÚa¿Þƒµ¿…7-¾¿ò >?­?ÜÕ?Vì­?>ºÚ>Îtˆ½òv;¿:›þ¿²½ÀµôÀ62WÀe#DÀ‹¦À¤£dÀ¾M¶À×Ã]Àíª^ÁÒ!Á èrÁX×Á 4Á+6Á6ÕÁB½dÁNÆ’Á[JÁh8·ÁuwÙÁf{Áˆ­ÁŽÚ Á•ªºÁœŠþÁ£~Áª}ÏÁ´"Á­—Á¦ ÁŸ]Á˜7:Á‘a=ÁŠ˜JÁƒâmÁz“ÁmpŽÁ`‡SÁSË|ÁGàÁ:È0Á.£ Á"¹EÁßÁ ±iÁõéÀì‚6ÀײéÀÃpfÀ®rüÀ—ŒÀ~¤½ÀMÜ„ÀÈ¿Þ{i¿‚¿n¾¦ÑÜ>¿ P?pJo? ¦N?´ÆÌ?±–¬???%µúÁXÁK OÁ>PÁ1›$Á%5±ÁÁ *Á_óÀì2=ÀÖYÌÀÀãûÀ«Ë«À—#À­ïÀTß'À$ÎX¿çZA¿‡Y‹¾¥ê{>È £?‚C?Ç’ã@ˆä@ øÛ@ ç?ã@s?ž±â?7Ê(¼¬ V¿Dih¿Æ‰&ÀåÀIlÀ{cNÀ”‹ñÀªD»À¿„ÒÀÕ)ÑÀëPbÁçÁ ªÔÁÏ Á%>*Á1ÈmÁ>ÂsÁL{ÁYwlÁf÷éÁt´ÆÁ=LÁˆ#­ÁõÁ–%Á+ Á¤6´Á­ÑõÁ¦™“ÁŸs¹Á˜TÁ‘4šÁŠ#šÁƒ.Áx©$ÁjÿÇÁ]d;ÁP0ÁBä‹Á5ÈÕÁ(ôÝÁAFÁȃÁˆÛÀï ðÀ×BDÀÀÍ­Àª0À”ÚÀØrÀTì~À)k÷¿õŸ2¿•³¾Î‘c>³‹M?‡Û ?¾àÐ@iœ@3â”@GDu@@ÿ›@u¾?î¬?¤E?"_;NV¿rÞN¿ß™8À!_ÀO‘À{ÁÀ“^ÙÀ©ÀÀJhÀ×/Àï87ÁÚ¡ÁF-ÁaÁ*)WÁ7‰§ÁDÿÁRŠÁ`Q\ÁnµÁ{óÛÁ„üpÁŒkÁ“Áš*^Á¡QÁ« ×Á£³ÁœkàÁ•7’ÁŽVÁ†øpÁ¹AÁq¯¸ÁcÛCÁV*ÁH†Á; Á-νÁ ¬vÁºŒÁçâÀôåAÀÜäÀÄwÀ¬ ~À•~À}tÀQéHÀ&ßO¿ö𜿞;t¿þ—>x¨z?€ £?ÁúÎ@.†@-©o@XâÒ@ÛE@v'¦@J Í@Ô?æXð? <>çBþ¾±xN¿Žµ³¿êT|À"iˆÀN?MÀ{ZŽÀ”°´À¬EaÀÄœ!ÀÝf—Àö¦aÁ‹Á½ðÁ#6Á0ƒsÁ>3 ÁKó®ÁYÂ*Ág¹kÁuÊÉÁñ"Á‰MÁ'Á—N°Ážv‚Á¨}Á¡áÁ™³øÁ’`CÁ‹ÁƒðÁyãÁkNÁ]+©ÁOFÁAm Á3­Á&8éÁÚ|Á –TÀýRvÀãqÉÀÊ]=À±@PÀ˜ú•À€ïgÀSKVÀ%ÄU¿òr¿œV¿€>4(Â?gKÒ?ÓÝ6@ £"@+/ë@U @xò@—ÒW@ê@ràg@D´‡@þ?í¦?†þ>•ßs¾ÜÖ¹¿’]¿ë`\À"þVÀR6ÖÀ%öÀ™NhÀ²«RÀÌÀfÀç[×ÁþÁwÁ¿Á)ÊNÁ78ÁE?ÁSÉÁaŸQÁoÂ[Á~ cÁ†+ÁÁSºÁ”‡‚Á›Ì[Á¥÷ßÁžÁ—&TÁÀ$Áˆ`ÁÁs²ÖÁe[’ÁWœÁHÀ“Á:™Á,îÁhÁƒÁ(¸ÀíˆmÀÓeÑÀ¹jÏÀŸ©âÀ†tÀZû”À*¬«¿öaé¿šÊø¿¬>6÷™?bá/?Ë9U@&@@Ÿv@YAÉ@èÍ@•»õ@­O(@¥Ù@DŸ@lp‚@Fê@@à¨?Ù¶h?w¤m>„?†¾é¿–:¿õÀ*äëÀ\HÈÀˆNÀ¢xøÀ½=áÀØ'@Àó”¥ÁƒÁIïÁ#)Á1%SÁ?@“ÁMqÁ[¸Áj4Áx[HÁƒhÔÁб3Á‘û½Á™FGÁ£‹&ÁœÁ”©Á9ÔÁ…×Á|ú­ÁnUÇÁ_ÂÁQTKÁBÿ—Á4¹Á&—fÁ¥÷Á ×¢Àú!iÀÞÿÎÀÄ&BÀ©e›À#»Àj?À6áæÀ¿¿¦òã¿ -,?bC°?Ê1@Й@?Óš@n7@‡Xü@—Lh@«Éÿ@ÁáÌ@¸úë@¡ÔG@ŽÖ@vû @F»@bw?Ó²î?nV‰>OJð¿ Q+¿§ýéÀ”ÍÀ;(Àp$ñÀ“$wÀ®cNÀÉäÒÀåfWÁžÜÁ¢nÁÅ)Á+TÁ9>˜ÁG‹ ÁUøÀÁdˆ7Ás¼Á€èÁˆ>­ÁŒ¬Á–å–Á¡KžÁ™Ì­Á’W>ÁŠårÁƒsÀÁxüÁiLyÁZ²ÁLPÁ=.Á/Á Å\ÁŸìÁ{æÀí^ÀÑ[¹Àµå#Àš–ÀéÀJÀ¨¿Á¼_¿7b=’I7?QÖ/?ÇmN@ÙF@>¼~@l´ª@E@£ø @±]:@Ã"ú@Ø4×@Î&0@¹Ÿj@§J'@ˆ@pÛÓ@BÕy@Y?Êÿ?Vt0=_«»¿A¬&¿Ê˜ƒÀœ¢ÀQÜaÀ„_ýÀ À»±NÀ×÷ÜÀôSòÁMëÁ”øÁ$ùùÁ3˜ÁB3ÒÁPÁ+Á_hRÁn8ÝÁ}yÁ…ô{Á]ßÁ”ÖnÁŸX£Á—Á\Á5-ÁˆµíÁ;‚Ás‚.Ád’ñÁU¶!ÁG/Á8n Á)Ù¼ÁEQÁ àÙÀýIÚÀàÙ­ÀÄœTÀ¨˜=ÀŒŠ»Àb>‰À+ x¿êX2¿|n(¾*RÓ?%aM?¸f^@ åA@<Ãã@jô@Œ@£;§@º ½@Íâ@ܪJ@@åÈþ@Ò£÷@¼ ã@¥È@è¾@mMJ@>o@ ?´ú?×;¾~Ú¿Œûœ¿ú‹2À4Œ~ÀkÐóÀ’ HÀ®deÀÊé#ÀçšÁ2áÁØ Á„ÜÁ.1¿Á<ïSÁKÖÁZܲÁiÏjÁx¸ ÁƒÞ¦Á‹m^Á“gÁ‚ Á•æ¸ÁŽL¥Á†µöÁ~FÁo3ÓÁ`8ÁQDVÁBblÁ3…ÀÁ$º¢ÁÁ‹WÀñô&ÀÕ¯À¸y•À›à'À ¹ÀFÆÀ’¬¿®¸W¿T„>°Ã?—€’@Vb@3§F@eWÞ@в @¢ ÷@¸ÿ<@Ð,O@ç<5@÷³ŠAOx@þy®@èX@Ñx‚@ºWÿ@£@‹9ª@dǨ@1Ð'?÷¥¦?ŠÞÆ>j v¿#œÃ¿ÀˆcÀ‚ŠÀPÄOÀ…7çÀ¢›À¾ÕÀÜ#jÀùŸÀÁ ‰Á\ÑÁ)b˜Á8#ÁG›ÀÁV›YÁeµ†ÁtéAÁ‚Á‰Á«Á‘^Á›ÒúÁ”$îÁŒ|ŸÁ„ÛÁzƒ+ÁkZ Á\4ÁMjÁ=û^Á.û{Á zÁAêÁmüÀçI ÀÊ$À­ÈÀàOÀfZuÀ,䥿瘼¿mÙó½Tnl?Plj?Ö¸@!Ýd@W @…Ÿ¿@žÚ±@· ¢@ÎÆª@åç“@ý\A æªA‹áA bV@ýð<@æ¯{@ÏB‡@·E@žJ¬@„ ê@Q€u@¬ ?ÆI÷?.•X¾K´x¿ŠIþ¿ü.@À8âÀr?.À–¿À´9ÉÀÑÛkÀï˜ÑÁæÓÁ)@Á%_úÁ4‡LÁC¸ÁS9ÁbgsÁq¼¾Á€‰¼Áˆ2 ÁÝ´ÁšsKÁ’·QÁŠþÏÁƒFLÁw ÁgÁ ÁXr/ÁI5Á:Á*òÁ×£Á ¾¡ÀûgƒÀݬ(ÀÀ¹À¢q?À…^ÀO°ÒÀ@(¿¶˜¿êø>¾OE? \F@f‘@@…@wR¼@–ßC@±_ @Êôà@ㆯ@ûr„A gõAÓAJ^A,ÈA „@ûfæ@ã<*@Éð¤@®ï@“¤ý@oó@7Û?ÿãþ?ŽfT>bVG¿0¶M¿Ìæ"À!†À]LÀŒ‰ ÀªjfÀȰlÀç@ÁïðÁESÁ!žÉÁ0ýÁ@p4ÁOì#Á_j¢Ánë1Á~mpÁ†ö–Á޲hÁ™ ÷Á‘h×Á‰¥eÁæãÁtXSÁdãÁUuÔÁFÁÁ6«®Á'HÁöéÁÀ–ÀóKÔÀÕõÀ¶íCÀ˜Ó³ÀvJaÀ; X¿ÿôU¿Š@^¾%ÊU?@‡?ÓÚµ@#»4@\%s@Š/³@¦>j@ÁÔ‹@ÜË›@öÔÈAíEAAÂyA+qAÃAAà2A¬ê@õ#ï@ÙÕ7@¾w@¢8£@†@þ@S˜>@+ý?¿ž>?Î ¾µá·¿¥Á†ÀòžÀKtÀ„3€À¢û–ÀÁÁ-Ààz>ÀÿFƒÁ&ZÁ¾ûÁ.e¨Á>GÁM‹Á]ÕÁl œÁ|1Á…ãGÁ§ÜÁ•µÁŽ­5Á‡¯ÄÁ€ÃÁqå7ÁbK×ÁR¼ÁC¬?‰áP?ÿ‹E@;"@@u†K@—Ðä@´B@ÐpÅ@ì”ATAaàA3A*JOA5û®A*~AšRA ÃA/Ý@èyü@̃@°³@“K@kÔ˜@0"+?èR?^#½ Âñ¿…HÀp À><À|âÀœð8À¼”ÀÛrÀú¼7Á ÃÁ©úÁ,P˜Á;ï™ÁK’yÁ[>lÁjñ Áz©$Á…0gÁŒýÜÁ’‡¦Á‹^+Á„MGÁzžÝÁlÀ+Á_)¥ÁP÷¼ÁARÞÁ1±ïÁ"¤ÁzÁæÅÀæ½½ÀÇÓÀ©ÀŠNwÀW 0À£•¿¸Ï£¿‚´>á!B?°ÆF@µ“@Oê@…I@¢þœ@À¡Æ@Ýþ@ú^A oþA~ªA'$ A4)†A<ò×A2ÔËA%_ AaA b†@öL¥@Øå<@»kQ@<5@}‡@?½U@Hn?ˆZw=ÂA/¿`$¢¿ìÓ³À59¼Àt žÀ™lÀÀ¸Ô²ÀØ$˜À÷‚Á vdÁ3jÁ*õÁ:¸ÉÁJoÁÁZ&äÁiÞ)Áy”OÁƒðÖÁŠøÈÁ¹ÐÁˆj©Á0yÁtóÁfƒÁX:|ÁJ‡¦Á=0ÆÁ0KfÁ µëÁÅÁp0Àã—4ÀÄN À¥À…Ç­ÀMzÀÅ¿¡õ±¾œó°?'?Î[b@$‚i@a”@ŽÁî@¬±C@Ê!@ègwAéAÕA :A*ôÏA6±ZA'Ë¿Qçå¿æäÀ1åÑÀp–­À—ËæÀ·R^ÀÖØÖÀö_NÁ õÈÁÀÝÁ*ŠËÁ:JþÁIå¤ÁWu–Áe/ŽÁs&Á€¬«Á‡ßèÁQÏÁ…á Á}‡ÁnnpÁ` çÁQãÁD Á6^Á(ô‚ÁÁ¸$Ál1Àá{ØÀÂ$À¢Ó’ÀƒšçÀHègÀ ›1¿˜›õ¾^—0?A‰?ÝP@,Ç¥@j¡s@”`@³Ä@Îæk@èÆ A2‚AA A~µA(r±A5~YA;ñA.‰•A!IA„"A¸™@ðй@Ö«@»dX@Ÿa@€Ìü@DŽ4@Ò7?ó>H]¿V·¿çÛ÷À2;›Àq öÀ˜ ²À·’ýÀ×GÀöŸ‘Á ÁÙQÁ(’Á5ZÂÁBá¥ÁP¯¯Á^ÈôÁm Á{ª]Á…&lÁ‹; ÁƒÀgÁx^Ái´pÁ[vÁL€Á>=Á0EáÁ"®ÐÁcKÁ€!Àø¤ùÀáŠÀÂD•À£ ¯ÀƒØÇÀIYôÀ \¿™m¾eèT?=Î|?Ù¿a@)è¹@f‘t@ô¨@«*º@Æ;p@à’@û8cA 6qA¼ÒA&3¿A3ÝA: äA, ÅAæ™A¡FA]@æÓ]@˧@°W4@”¼É@r¼}@9G!?øã°?7=Jj¿lå¿ó3ìÀ7ýÀva ÀšbIÀ¹gÀØû\ÀõüyÁ'ˆÁ¸Á!7ôÁ.ÀÅÁ<¬~ÁJæÃÁY`*Áh‰Áv¹GÁ‚ÆÁ‰nGÁßuÁt³YÁeµÁVÛ—ÁH./Á9¨CÁ+SrÁOÁ´ÌÁböÀëGÁÀÓ0À½ûÜÀ¤qÀ… ÀL»_À­j¿¥>꾨ß?!®ß?ÆŽ~@ñ@W?¡@‡!ò@¢ÐŽ@¾|@Ù“—@õAûIA jA%²A3ZA8A*«A„®A ÞÏ@üZ@ß+[@Âgº@¥è¶@‰™Â@[X @"ì?Ô˜ç?Aš ¾)ê—¿ŽEØÀ#­ÀA·?ÀUƒÀžyäÀ¹^RÀÏÙ"®?ªK@2B@FiK@~—å@›„@·mþ@ÔY(@ñ3AèA`cA$SA2ƾA7‘A(=0A A ·½@÷0õ@ÙÓ@»'j@X@S@Dœï@ §s?¤mQ>É‚D¾þf ¿´‹àÀYÀÀPmÀ†'[À—±£À«²¿ÀÂÉpÀÛÃïÀõÿÁy#Ál Á$¾Á3=±ÁAäÁP»ÞÁ_¸Án`êÁ}VÁ‡,Á~ú´Áo­åÁ`y¬ÁQ]ÁBI”Á3\$Á$¢PÁ+GÁ ZÀôÈÀÚ}ÀÁ?ÂÀªHÙÀ–;‰À…$bÀ`(¬À$Ÿû¿Ò‚É¿9_9>4 ¬?‰X_?û Š@6ðº@p–È@•ñy@³ªý@ÑAÛ@îÇBA]AÒA#×A2®±A6hžA'€ÈA!A @2@óåÏ@ÔÝ-@µ¢­@–«L@pU÷@4zÂ?ïÍŠ?k1z¼$81¿hoj¿æDuÀ,ÄÀ` !Àzd×ÀÏÀ¢jµÀ¹ÑÀÓ2À훘Á®NÁçÎÁ!Q›Á/öÁ>¦êÁM\EÁ\<\ÁkB@Ázg"Á†“ËÁ}Á“ÁnoÖÁ_6ÁP ÁA<Á2$Á#W&ÁÑßÁ–RÀñ‡¯ÀבÀ½ËRÀ¦])À’8ÀzÐÀl¼šÀ3Ŀ𑷿zrὌö¯?V·q?ß6@,C@h‚I@’þ@° £@Îp«@ìÚA¯pAû#A$_A3Ü3A7àA'’vA A|e@ñ´Á@ÒY3@²þ@“£½@hf=@(ÿ ?ÓSš?+l…¾‘yr¿ž®GÀ P¸ÀEÏ«ÀW kÀmäÿÀˆ¼Àœý‡À´™8ÀÎ.³ÀèÝ’ÁXgÁ“AÁßÁ-fÓÁ<¥ÁJþçÁYðÂÁi,Áx$Á†KÇÁ}6wÁmêXÁ^·‚ÁO£Á@©úÁ1Â3Á# aÁÁgÀñg†À×A%À¾'ºÀ§F5À“}åÀƒÀpë¼ÀBÍÀZq¿™Ÿ¾ˆþÄ?2o ?Òá @&F8@cœ_@½@¯Æ¶@ÎÜÄ@íóœAƒ®AðA%]A4È_A7vJA'é®AEÞA†`@ñ¡Æ@Ò#/@²tO@’Ån@f-@&Ï\?Îàï? $ó¾¹óU¿¬õmÀ·ÀRáÀXœõÀn À†±•À›4ºÀ²bÉÀˉXÀæ!Á³Á®Á mÁ+©åÁ:aGÁIH¨ÁXLùÁg]ÁvŠ.Á†U4Á}b/Án.Á^ÿÙÁOñÁA *Á2PàÁ#»ßÁ_ÖÁbÀóÆSÀÚ$BÀÂ&À«Î¶À˜ç(À‰°À~ìÀÀN\çÀ0¿¤é¾žÅ¾?)+?Ñ2š@&bC@e s@’ž@±Ì˜@Ñ È@ïùA‘ÁA<ËA&íA6ž¿A8ªÔA(Ï·AüGA 0w@òÐþ@ÓK¦@³Öv@”o™@jú@*ÞE?Öä‡?0'¾›)}¿¥¡ÒÀ<¢ÀQ¨\ÀcvýÀu :À‰ä3À^«À³®1ÀÌxÀåÒÿÁfÑÁgYÁ£hÁ+#Á9Å®ÁHjÁWzÉÁfn˜ÁumñÁ†0¨Á}‚Án¨ƒÁ_¼ÕÁP÷ŽÁB<­Á3µ2Á%P/Á=ÜÁ —˜ÀùæÀàLÀÀȽ¡À³ª)À¡æ!À“vÀˆIdÀPÕ¾À³¿¢·S¾Œôú?8y¬?Û¶ê@,†ç@k@”Ü!@´Kh@ÓÊ@ób’A …’A4ÜA(×hA8|ÉA:Z™A*œ Aâ0A -Ñ@öõ@׎l@·æ@˜0@pô@1ˆ?ä7é?JÀì¾Kú ¿˜r$À ²zÀK,!ÀvÀÀ‚“ÑÀ‰{À¢²3À·èNÀÏ™ÀèPàÁF2Áö*Á÷¦Á+6ÇÁ9ªEÁHCYÁWÝÁeÙ<ÁtÊšÁ†EkÁ}®.Án÷&Á`]xÁQÖpÁCnðÁ5>¨Á'U2Á·‚Á }ÚÀÿÀçYŽÀÑ5³À½3ÀÀ¬˜ØÀŸQ]À†QOÀL¹¦À Ю¿™Ò¾S°Ø?IiÎ?ãßé@1…v@q÷@˜X<@¸"ü@×î@÷½…A œºAVhA+A:ÉÃA<Œ”A,ËgA A (Þ@ú‘z@ÚÑ7@»ô@›P±@w@7~É?ïÁ?aõ½ë¿ôžÀ˜•ÀF6ÛÀ‚ê‘À0 À›)+À«’tÀ¿#ñÀÕHþÀí•RÁ„3Á˜"ÁUÁ, MÁ:O~ÁHÕÁÁWh¼ÁfºÁté·Á†¶Á~ª{ÁpÁa©;ÁSV!ÁE+Á7MÁ)Ï_Á›sÁñÁºuÀðSÓÀÛ`gÀÈÇÅÀ¹1þÀ¤û‹À…ÀJ£À ,I¿”}Þ¾%R?Vo?ë>@5vy@ucÓ@š¨—@ºŸD@Ú•ñ@úŒžA AÀA,ÂA-3A<÷©A>A.X Ag%Av?@ýå@Ý%@½AO@]„@zóq@;+Û?öȉ?nz½½„É#¿‡ÖƒÀ°:ÀCuYÀ£WÀ¾bÀ¨dÀ¶áµÀÈÉÀÝ„ÀôgdÁZXÁÿÁ =dÁ-òÁ;øÁJ'€ÁX{pÁfÝðÁus¦Á‡x=Á€/¢Áqã{ÁcŽ,ÁUu‰ÁG£ÖÁ: Á,È©Á ÞÁÊÆÁîÀú§üÀç.%ÀÕâgÀÅŒ\À¥žÀ…±±ÀKŠÀ ±Ù¿—²+¾@?OaÊ?çbm@3‰ú@sb¾@™Á@¹Š#@Ùvô@ùb¶A ‰AAaŽA,;%A<ßA6ЇA(Õ½Ay¾A »ž@ùA|@Ú7¹@»@›Ö„@yÄ@9Dæ?ó?g ­½¿¶F¿‹}ÀmÀE7ôÀ‚_zÀ¢"ùÀ¶ðùÀÄk4ÀÔzÀ箸ÀýxêÁ CÁ˜"Á#bÓÁ0¨èÁ>@éÁL/¦ÁZ8„Áh\xÁv¹KÁˆ\—Á*GÁtÄÁfŽÁX@FÁJ®±Á=t³Á0°OÁ$U¥Á‘Á ÆÁJ)Àô+!Àä:ÀÇv,À§˜ÍÀ‡ÂýÀOåœÀE?¿¡IľˆòN?97?ÛAË@-}@lcP@•å@µ˜‘@ÕL@ô·4A §A°gA)¡A0A,ÀùA œQA9BA¢@ívJ@Ð ÁxZÀï=?ÀωËÀ¯ášÀ\EÀaò´À#.‚¿ÈÔž¿˜r>ÈÑ×?¯N’@ö@R™Ÿ@ˆ'@§»@Ä”ÿ@áôä@ý¡IA ˆèAcA´AV®A gñ@ÿý@ç@‘@ÍðD@³1Ú@—x3@v…@<÷Ï@ÆA?û>M“š¿ Ù?Œ|Æ@ @?‰1@zHü@š„d@¶rÞ@Ñ É@é?ß@÷Ê@þ³SA˧@ÿP3@÷k @è Ï@ÑØƒ@º?-@¡IÄ@†á@X S@ïa?Ï?7õ¯¾CB¿ŒË_ÀJÀ=4aÀy§Àš®¹À¹¿À×ÐÌÀö^‘Á uÁ?ÜÁIóÁ"‚šÁ,¹aÁ7ÃíÁC[ôÁO{òÁ[ÙÁh–Áu¬1Á„þÁÅÁ‰¬Á‚[ãÁw¾Ák#ìÁ^ùnÁSMÁHÑÁ=N¾Á3JãÁ*1XÁá¢Á 2‰Àû$ƒÀÛùÆÀ¼ÛyÀòWÀ~ƒÀA&ÀÉ¿ŒŸ¾!y¬?B Á?ÖÏö@&'Æ@^ –@Š{÷@¤~[@¼së@Í¿@Ø–Œ@ß3Ì@áΖ@ß¿Œ@ØÚ©@ÎZL@ºç@¤ @ý@h§¥@5 Š?ÿGm?’³v>‡rä¿ô¿ÁàåÀãÀU;SÀ‡ÈDÀ¥˜ÀÃ×Àá–!Àÿ°=Á ‡Á«¹Á"?UÁ*àxÁ4kÁ>ÓZÁI÷;ÁU¹TÁaÄ{ÁnõÁzÕ¼Áƒ÷5Á’u¯Á‹ßeÁ…cÁ~¶ÁqÏ¿Áeû[ÁZžÈÁO¶ÁE{uÁ;ó»Á/ð¡Á _)ÁÛÀÁkÁÀä#TÀÅtÙÀ¦Æ_Àˆ'GÀSä¹Àøœ¿¼q¢¿ ä>ºÞ?žxE@/Â@<@pp@u`@¢T@°$û@¹Î @¿Ä@Â^@À>™@º!ž@°Æ&@¡õ)@±ø@nÏ@?³@»Ã?·ú[?„¾g«1¿‹N”¿ü%QÀ6iàÀo²©À”ì À±þÅÀÏ'±ÀìšTÁE‚ÁH.Á#IHÁ+¾†Á3ÒZÁ<é_ÁFàÁQ•ºÁ\Ù?ÁhwáÁttìÁ€púÁ†×2Á•jRÁŽëcÁˆ•XÁ‚n'Áx÷…Ám‡Áb‡oÁWùbÁN:ÁCL2Á3ÞkÁ$‚’Á+UÁÛ2Àí?ÅÀϨÀ±ÐÀ“½QÀlØÀ25‡¿ï]V¿}ma½ì" ?=]ò?ÆÇ4@<Ö@D¡|@lì@†^þ@’_º@š™@ 8ž@¢_‡@ Ö’@›<€@’Œ[@‡3@j®h@@øã@^'?ʲÙ?Rë%=+“ë¿F}Ñ¿Î8‘ÀÐcÀT¨OÀ†}ãÀ¢¯ÿÀ¿BÜÀÜM(Àù_÷Á FKÁé[Á(À‘Á5ѦÁ=j¶ÁFÁO|²ÁY¹7Ád€TÁoÌRÁ{g„Áƒ¹Á‰ñîÁ˜§Á’LýÁŒÁ† tÁ€ZèÁuª³Ájü§Á`ÔXÁVòwÁG£ÇÁ8aoÁ)0<ÁçÁ îÀøQÀÚóÌÀ½¢†À Q_ÀƒQˆÀMì+Àñ俽áÿ%²>*³4?pÏ…?Ô°o@¾¼@6õð@R^T@gåÔ@vÇ|@€s@‚–R@gW@xÖ×@h;F@Süœ@6ïÓ@Q?Í«?g´È>/\¿ù¿®l0À ™ÈÀ?½ÞÀu:²À•²LÀ±ÆÕÀÍðiÀê2ùÁ]Á×!Á a[Á.ø½Á=’ÍÁG‰ÁO¶éÁXÄÁbÁlÕ¿Áw¼¾Á|úÁ‡W5ÁgUÁœ2¾Á–ŠÁÁŠ0 Á„—ÝÁ~dsÁt}ÁjfmÁ[ÁÚÁL¥ïÁ=‘(Á.—=ÁÂ’Á$ÁlÀç£AÀÊÍ?À®A›À’A\Àm9?À7¹ÀþS¿ž.¾îúË>€wœ?g–?¾˜V?üU@Ø@*µÚ@8z¦@A[ @EY @CZ¥@;…@+‡7@÷„?þÈg?¼iø?]Àë>B,ƒ¿œ¿žòB¿þ•‹À1!ûÀcè¦ÀŒ/¹À¦î#ÀÁ±úÀÝãÀù9\Á ±xÁÛ Á'fÁ5ˆ/ÁDTÁRc´ÁZ(øÁb½úÁkýÁuí¨Á€6›Á…¥wÁ‹SÁ‘8”Á ÍÁš&Á”3—ÁŽ“ÐÁ‰GÁƒÕ…Á}¼ Áp ‰ÁamÁR*˜ÁC]Á4°bÁ& KÁ†ãÁ ${Àõ¤ºÀÙ‰ÅÀ½É[À¢¯ À‡ ïÀZÔÄÀ)­¿ïå(¿”t¡¾þÓ=ôL½?$A?ˆíc?¶‰X?Øßt?ô)ø@Ïñ@…l@æœ?ù7…?ܯH?·Vú?‹ ?"T=›&Ò¿ ¨¿œŠ¿õûÀ)ãuÀYW²À…†ïÀž¤wÀ¸›/ÀÓ>îÀíýXÁqåÁDüÁ UñÁ.kÁ<œžÁJÚëÁY=©Áe"‚Ám><ÁvªÁ„Á„ÑNÁŠ ·Á¤¯Á•^Á¤'™ÁžNUÁ˜¢>Á“"ÁÐIÁˆÅÓÁ‚R“ÁuÀ;Áf÷ÉÁXL¬ÁI¸Á;AjÁ,âVÁŠ(ÁiÁ‚tÀéÓ;ÀΦ”À³ÓÙÀš8¿ÀŠ)ÀRÏÀ$ƒ•¿òÍ¿£µZ¿:>¾ƒnš> >ò£?8vƒ?m0?„‰°?‹c ?ˆå$?xFÙ?Bó×>ùZ®>'L¾t?é¿=í|¿©‹À¿ùï‡À(³RÀUx¶À‚*3À™Í8À²…ÈÀˉëÀå?ÎÀÿ¹Á 'ÁzÒÁ(Á5üôÁD4ÁR'ÃÁ`^.Án›Áx$`Á€DEÁ„Í|Á‰§ŒÁŽÊ9Á”-õÁ™»}Á¨ƒ Á¢ÔÁAÁ—åhÁ’ÆÒÁŒ¢´Á…DUÁ{ç–Ám_?Á^ò·ÁPˆÁB6,Á4Á&øÁZÁ »VÀúŽ}ÀàJCÀÆðgÀ®l]À– …À~¾ÛÀR´ÌÀ+$ÔÀ/„¿Ê»©¿“íË¿JV@¾ôß0¾y¤½dXè=.o»=»Æs=ÕY¼lؾQÒ‹¾ëÍŸ¿Flì¿’%¿ËÄRÀœjÀ.døÀWbÑÀ0À—úÀ¯b­ÀÆûHÀ߇+ÀøÜÁóžÁúÁ#OwÁ0šÐÁ>gÁKÈýÁYµdÁgÈxÁuæïÁ½ZÁ…¿‹ÁвÁŽÆ«Á“»ËÁ˜òöÁžX>Á­‡Á§‰'Á¢"’Áœò§Á— Á¿dÁˆxhÁ@QÁtZÁeÖŽÁW¶ÞÁI³Á;Ð8Á.#mÁ ©WÁmkÁo„Àó£oÀÛÀà ¢À¬o^À–^ãÀ‚2^À]ïÜÀ<£ÀâÏÀڿܿrl¿œø¿…sEh¿gÕ£¿jŽ^¿€ÀH¿–#L¿´[…¿Ü6ÄÀ’ÀõôÀ=ä]ÀaêÀ„íÀ˜æïÀ®Ä·ÀÅ7·ÀÜ›(Àô.ÞÁDHÁºçÁPæÁ,E¤Á9wÜÁFÊ,ÁTÓÁa¶«ÁozMÁ}nÁ…ÀÝÁ‹y0Á§íÁ”'Á˜ï¤ÁúÝÁ£8Á±ÚÇÁ¬mÜÁ§2ÄÁ¡…pÁš=šÁ“Á‹Ú½Á„¼dÁ{]ÓÁmIþÁ_VeÁQ‘—ÁD  Á6ÁGÁ)¯sÁ¾7Á+=Áð½Àð nÀÙQóÀÃpþÀ®ÒQÀ›rQÀŠ!¹ÀsÞiÀXj×À@}À+P@ÀJåÀ ÈßÀ‚]¿÷÷@¿ó&-¿ôkÌ¿ÿDKÀö"À]ÏÀ*›‰À?ÓÀX#lÀtUùÀŠÊÀZ@À°à»ÀÆvÀÛûvÀòukÁéÑÁ±ÁÁÅvÁ)5ßÁ5¾½ÁB™\ÁO©yÁ\ÿvÁj9+Áw²#Á‚°9Á‰–ÚÁ“}Á•m'Á™À×Áž]¼Á£=£Á¨SGÁ¶ÉOÁ±‰öÁ«üÁ¤È®Á¢sÁ–úÁi…Áˆ`ºÁi@Áu ÁgsWÁZnÁLõ—Á?ôÐÁ3ŸÁ&²ÁbÀÁ‡"ÁbÀðˆEÀÛu5ÀÈ›ÀµÂ™À¥[¿À–«æÀ‰C>À|"ÀhB–ÀX\•ÀK _ÀAèmÀ;@ÆÀ9/¹À9Ô¿À>¿oÀFÌÃÀU9—Àg.À{bÀ‰3UÀ–O*À¦ ÑÀ¶ä>ÀÊ0¢ÀÝÚSÀóQüÁ™øÁÙÁ†Á'LÁ3LfÁ?´zÁL7]ÁXî‘ÁeíÃÁs'ÜÁ€1Á†ßrÁ©¾Á”…µÁ›VbÁŸ€›Á£ó½Á¨ªÁ­—ŠÁ»ìÁ¶‹ÌÁ¯fCÁ¨AÁ¡$$ÁšCÁ“&,ÁŒCˆÁ…t(Á}c:ÁpÓÁc+ÁV)hÁIUžÁ<Ï¿Á0Ù’Á%ÉÁ•¢Á¾“ÁõÀôªäÀáúÀÑ$"ÀÁ/™À³odÀ§ÀœlÀ’¢mÀ‹7"À„§À€ˆ¶Àz©¢ÀxÌ\ÀypÀ}ܸÀ‚À‰ˆÀ‘–¨À›ºCÀ¦}ÆÀ³O“ÀÁxJÀÑÝÝÀão¹À÷ÁuWÁCÂÁ6±Á&xkÁ2"LÁ=ædÁIØ£ÁV5,Áb²VÁoO”Á|?Á„¬|Á‹J?Á‘ìƒÁ˜©´ÁŸ~Á¥n™Á©¹ôÁ®HGÁ³ÞÁÁ*ÁºäÁ²ãÁ«ÐÊÁ¤ÑLÁçÁ—¶ÁT»Á‰§rÁƒ ‡Áy(vÁlXÁ_cÁS!lÁG8:Á;ˆ¥Á0>Á%,¨Áv¡ÁíÁÀüÀ}Àìo´ÀÝæKÀÐR•ÀÄé¢ÀºzrÀ±@KÀª?úÀ£ð|À 5À ?Àœ4Àœ…±Àž}À¡ÛœÀ¨smÀ¯óÐÀ¹³„ÀÄÁÀÐoÞÀÝ–"Àí$HÀý¿BÁµÁî´ÁøÁ&Þ…Á1Ó¶Á=GÁH¾‰ÁT€¶Á`h–ÁlµÞÁy-OÁ‚ݼÁ‰IhÁÌ•Á–gTÁœþÛÁ£°Áªy Á¯¬ÝÁ´­Á¸µzÁÄ ‡Á½‹_Á¶‚âÁ¯ŽšÁ¨²Á¡ïrÁ›@Á”¢IÁŽÏÁ‡ QÁ@.ÁuÌOÁiu°Á]–üÁQþ ÁFŒkÁ;™|Á0ئÁ&Õ‡ÁUîÁ=:Á ðGÁ8Àú©)ÀíßhÀâ»ÀØùÕÀÐ\ÀÉT6ÀÃiÉÀ¿±´À¼½­À¼ÐÀ¼SYÀ¾ –ÀÁ[NÀÇ^½ÀΈÍÀ׿ßÀáíðÀí ¨Àú]]Ád½Á xÚÁý/ÁŒ—Á(ZÁ2–šÁ=yHÁHpïÁS¶"Á_ZÆÁkÁvû9Á›XÁ‡Ô$ÁŽÕÁ”uÁÁšò›Á¡„aÁ¨oÁ®¼ÑÁµz{Áº ‚Á¾zÌÁÈ:ÂÁÁA,Áº[œÁ³ŒüÁ¬ÒÕÁ¦.CÁŸ™[Á™ Á’¬ƒÁŒQ·Á†MÁËÝÁsõ}ÁhkiÁ] ¯ÁRPÁG=ŒÁ=¾Á3޾Á*=Á!¨<Á«£Áz'Á ¯NÁÖ¢Á\À÷zøÀîÿkÀè„iÀâýÑÀßHôÀÜrÒÀÛÑ"ÀÜ!ÀÝžðÀàî‹ÀæJÀíZ,Àö@ÀÿæñÁz<Á ½•ÁrTÁ3iÁ"bÁ+Í)ÁI+åÁT Á_KÁjTþÁu÷Á€Ú­Á†ÇðÁŒÝjÁ“ Á™TãÁŸ§!Á¦GÁ¬£Á³1uÁ¹Í¯ÁÀOÁÄbŸÁÌ7ÁÅ5}Á¾lxÁ·µáÁ±ÐÁª…–Á¤yÁ»˜Á—lwÁ‘.Á‹,Á…),Á~ß¿ÁsŠ£Áhs¼Á]¤tÁSa™ÁIÅÄÁ@añÁ7o9Á/:úÁ'ÆxÁ ÇÁSÁ·bÁ†WÁ þÁeÁÚmÁJæÀþë Àü-|Àû€¢ÀûÔ­Àý-ÄÁ<„Áž©ÁÁ 9ƒÁ÷ Á;:ÁY_Á ÂÁ(uÁ0øÁ8dQÁA‘dÁKnÀÁUIlÁ_à Áj®ÏÁu«ÁÁ€yíÁ†I ÁŒ'ôÁ’ Á˜!sÁžSaÁ¤’_ÁªÜÁ±FÁ·ÆþÁ¾SÁÄâØÁÊoIÁÐÑÁÉL¾Á™WÁ»ûåÁµzšÁ¯·Á¨ÈãÁ¢‡ÁœZ·Á–DßÁWóÁŠ™)Á…fÁ~áÃÁt ÑÁi³VÁ_üÊÁV”ýÁMc+ÁDàÑÁ=$WÁ5ù!Á/!†Á).rÁ#™+ÁÀ‡ÁHùÁ˜;Ár¾ÁãÁ?«Á ò`Á ŽmÁ ¼øÁe>Áö¿Á.íÁ|¸Á]ÿÁ Á#§Á)¶Á/>ÑÁ6&Á=ÚûÁEä.ÁNˆAÁWõ¨ÁaÙñÁkÌ:Áv[‡Á€¤ÉÁ†$¥Á‹É[Á‘—¿Á—u©Á^¾Á£g Á©“ºÁ¯ÏÛÁ¶JÁ¼t™ÁÂï&ÁÉvHÁÏýÖÁÔ-ÁÍ€BÁÆë3ÁÀpÎÁºÞÁ³Ì2Á­’YÁ§pQÁ¡mäÁ›‡Á•ÃZÁ*jÁŠ™ÐÁ…1ÑÁ€Áv3ÿÁlÀ~Ácu¥ÁZ¤ ÁRŸCÁKO'ÁD:¶Á=¸GÁ8ˆÁ2–µÁ-ú·Á)šàÁ&/Á#Á âáÁ ÐÁÏÁ\–Á’$Á4Á°úÁ!Ç=Á$âtÁ(‘ÎÁ-8=Á1þîÁ7¬Á=É‘ÁD^ÁK¸¶ÁS™ŒÁ[ÓþÁdÄÁndÐÁxE#Á)ïÁ†z‚Á‹ò+Á‘sqÁ—ÉÁœåÝÁ¢ÃµÁ¨ªðÁ®­çÁ´ÔÁ» ZÁÁPÁÁǦyÁÎÁÔ™vÁØjfÁÑÜXÁËgùÁÅÔÁ¾ÐÁ¸¡©Á²‡¥Á¬Ž“Á¦±JÁ òÁ›R¦Á•ÂæÁ[‹Á‹+dÁ†7Áh€ÁyIÁpïÁh3½Á`œZÁY‚ÁR”$ÁL„®ÁFñÐÁA´ëÁ=;ˆÁ9¥Á5ÅñÁ2Å"Á0¥@Á.ÓõÁ-¬GÁ-,£Á-gOÁ.…Á/k5Á1gHÁ4^ Á7ÚúÁžÁ=‰†Á<þ÷Á=†ÁËXsÁÑŒ,Á×Ë“ÁÞmÁá`ÁÛ ËÁÔÒsÁγ<ÁȲ]ÁÂÍæÁ¼úñÁ·EâÁ±•»Á¬[Á¦¤¸Á¡xjÁœv"Á—€£Á’²ÐÁŽ.7Á‰ìÁ…ÆÛÁ÷3Á|èÁuþNÁoÍÁj!ÌÁdÁVÁ`æÁ[ËgÁX^ÁTÕÁR'¥ÁP$þÁNh?ÁMfÅÁLЊÁMåÁM” ÁNíÜÁP±7ÁSYÃÁV”‚ÁZHÁ_5BÁcþèÁi•—Áo´•Áv4Á}féÁ‚yÁ†gJÁŠ¡äÁ$YÁ“èlÁ˜ß~ÁÓ@Á¢þàÁ¨bdÁ­ÚPÁ³_òÁ¹Á¾ÐnÁÄ®ÁÊ‘’ÁЇùÁÖœµÁÜÌ…Áã ÁämÁÞÿÁØ0“ÁÒMáÁÌ}ÁÆÒØÁÁLÞÁ»ËüÁ¶Z-Á±ªÁ¬ NÁ§3ôÁ¢j»ÁÌÁ˜ýÁ’ŠÿÁŒ=kÁ†3Áñ:Ás3ŸÁf¥ÁZ`¡ÁNž™ÁCwÁ8ÖïÁ.ÄžÁ%ÝÁ=úÁ Áè¯Á ù§ÁÂ=ÁÁ]ÁeŒÁ.ËÁ­ªÁ b±ÁH¡ÁcXÁàÁ'AÁ0O.Á:kVÁE`ÁPLØÁ[è£ÁgòÁtpÁ€“bÁ†¾¯ÁŒØÁ“Á˜Ç’ÁóÁ¡vÉÁ¦ÉÁªÕÁ¯¾uÁ´ß*Áº2ÖÁ¿£2ÁÅïÁʰÑÁÐmÁÖN”Áß=µÁÙ ªÁÓ1ÁÍ+ÁÇA²ÁÁp>Á»ÇéÁ¶@lÁ°¿¬Á«XkÁ¦!BÁ¡#ÁœFžÁ—€æÁ’øÛÁŽ0iÁ‡ÂÆÁmæÁv”NÁj¿©Á^rÁRhÁE˪Á:åÁ/nÁ$“¡Áß–Á׆Á ‘Á¨[Àü‹ÃÀõr¤ÀñkùÀïôÀòJçÀöö·Àÿ`_ÁÛ*Á ]Ái.ÁvÁ%æ Á0U?Á;zÁFóÁRøÁ_|ÝÁl »ÁwèˆÁþ‡Á‡ÌrÁÇëÁ’FkÁ–žqÁ›4/ÁŸì*Á¤Ä Á©Ù7Á¯&"Á´›ZÁº)Á¿®tÁÅi¤ÁËLÁÑRpÁÚoKÁÔ;äÁÎ#|ÁÈ#ÁÂ--Á¼=DÁ¶k¬Á°ÄÁ«4ŸÁ¥µ‚Á [¾Á›5¦Á–>Á‘ZêÁŒ }Áˆ3óÁƒx^ÁzfÁmlÊÁaÁUJïÁJ EÁ=µ½Á1™¡Á&•ÁócÁµÚÁ`;ÀýÞÀð¶ÀäÍaÀÜ‚÷À×é|ÀÖeWÀØðÀÞ>Àç6$Àò‰©Á~/Á±·ÁêãÁûFÁ&øèÁ2eïÁ>^ÌÁJÀÆÁVÁ6ÁbHhÁmeïÁy1Á‚€9Á‡“ÒÁ‹ÍÁRÁÁ• ×Á™ÖAÁžÝºÁ¤!Á©˜¹Á¯!SÁ´´©Áºo#ÁÀR™ÁÆ[³Á̆!ÁÕÎJÁÏw|ÁÉ>ûÁÃ'¡Á½,=Á·5†Á±AåÁ«p¶Á¥ÄóÁ ,8Áš®£Á•dxÁRåÁ‹[ëÁ†uLÁÒþÁ{FÁq¸0ÁdÄ“ÁX3»ÁKæIÁ@Á4õˆÁ)È®ÁÄÁjLÁ‹‰Àû…ŸÀéîbÀÚ§±ÀÎSžÀÅŸÀ¿øÀ¾Ê»ÀÁ=nÀÇ[ÀÐ5-ÀÜé¶ÀëõÀý¹ÁYrÁPÁiðÁ*CéÁ5·ÞÁ@ÁÿÁK·ŒÁVÐÐÁbyýÁnqÁyÛÜÁÆÁ…yÁŠ-yÁŽ÷³Á“ïÁ™(%ÁžœeÁ¤)·Á©¼vÁ¯wÖÁµ^Á»l°ÁÁ ÁÇÔÃÁÑ\9ÁÊç-ÁĉµÁ¾KØÁ¸0´Á²3Á¬;™Á¦I Á y<ÁšËmÁ•(QÁ®¥ÁŠsáÁ…mÁ€p½ÁwAxÁn3IÁe¨uÁ\Ç3ÁOÀÔÁC+ÛÁ7¿Á+I¡Á J\Á1ýÁ É#ÀÿtGÀê™fÀ×ÿ´ÀÇš¯À¹ý÷À°pªÀªŒ„À©À«BÀÀ²KÀ»É;ÀÈížÀÙY€Àë—ðÁÍÁ õ^ÁÁÁ' Á*3iÁ5*2Á@>dÁKìPÁWá«Ác÷Ál×.ÁuhñÁ~ª9Á„%ëÁ‰ÕÁŽÀ•å0À˜©ÀŸ=‚Àª2À¸GÀÆ\£À×$ÀéGÀü¶¹Á›uÁ§…Á ÔÁ)¯ÁÁ5_ÁAQuÁMvÚÁW—Á`*ÁiÛÁr©Á|n1Áƒ]lÁˆµ(ÁŽ;>Á“ÏrÁ™‹PÁŸxãÁ¥“Á«ÌÙÁ² (Á¸W)Á¾ÂèÁȱÚÁÂ(Á»²Áµ=6Á®ÓÈÁ¨‡ìÁ¢V‰ÁœA÷Á–JúÁXµÁŠ‹ÔÁ„ã+Á~„ÎÁs²ÑÁiPæÁ_ÁUg·ÁLEÃÁCcÁ;ÊÁ/·Á#óÐÁcáÁ ýÁÀfÀîÀÙKyÀÅ3yÀ²)OÀ¡À”‘Àˆ¤˜ÀƒŒäÀ‚ SÀ‚pæÀ…ÀŽ^»À›2À« 4À¼qÓÀÏîøÀä0cÀú7‡ÁúÁ&¤ÁÒqÁ*ÄrÁ6öåÁBeZÁJáFÁS²¸Á] ÈÁf¾ÈÁpÿ¥Á{•LÁƒDFÁˆà~ÁŽ¢‰Á”‘CÁš¯±Á î²Á§0ÉÁ­„YÁ³ùþÁºŽÁĤ¹Á½÷¡Á·e Á°åYÁªoõÁ¤ CÁ´dÁ—sÁ‘TÁ‹^Á…mÍÁDOÁsòàÁhµàÁ]øÅÁS–lÁI_ÁÁ?äËÁ6Ï­Á. ‘Á%,úÁ;ÞÁ ]®ÁÌ)ÀìÈñÀÖOÀÁ@À¬IJÀ˜À…ÏÖÀmýxÀTËÀG¯ ÀD¨ÕÀEÞÀLA¤Àaé4À}ùÂÀ#€À£,À·FÉÀÍ ÀãFÀùLÁF»Á=OÁ vñÁ,²zÁ5®Á>Y¼ÁG•ëÁQdÁ[D¡ÁeÑ ÁpžÁ{ëDÁƒÅýÁ‰ºˆÁÜöÁ–Áœe Á¢ÂiÁ©@[Á¯Þ Á¶“ŸÁÀÆÁ¹øvÁ³AÌÁ¬§*Á¦"nÁŸ£Á™?MÁ’é†ÁŒ›YÁ†w€Á€}´ÁuñÁi…©Á^ »ÁRèkÁHCÁ=çNÁ3ÓÁ*…×Á!c’ÁíôÁ§+ÁµÀí—ÀÖoŒÀ¿¼À©&½À” ´À~¶0ÀWê-À4IÀiÀDÀ9À›pÀí›À'fÀHÀlçEÀŠ–?À  pÀ¶¤ÀÌd}ÀãxúÀûyÁ ÷¢Á;ŽÁ ‘ãÁ) Á24{Á;’ÁE–ÁPzÁZÓ~Áf ZÁqâ#Á}ëÏÁ…Á‹QÐÁ‘£SÁ˜MÁž›ªÁ¥CaÁ«þÁ²¹;Á¼û˜Á¶#°Á¯PÁ¨JÁ¡ëÁ›cÁ”ãDÁŽsyÁˆçÁÐßÁw[•ÁkE8Á_\ÉÁSÇÚÁH_HÁ=(òÁ2=Á(IÐÁ[ÄÁ%…Á KÁ¢ÀðUªÀØ\XÀÀ€aÀ©RÈÀ’ïÀx¡ÀNCãÀ%u¿ý~¿¾%‰¿‘AL¿‹¿Ž`.¿©R=¿ßsüÀÄ¢À<\RÀf7žÀ‰‡ÀŸ¬À¶i˜À΀aÀæüÀÿ¦°Á VÁÔ+ÁÞ¹Á&QWÁ0!:Á:˜…ÁE9ÁPw\Á\KòÁhhÊÁt“ßÁ€ˆwÁ†í‘Áp±Á” àÁšÂÁ¡JÁ¨<“Á¯ Á¹MÁ²b’Á«‰UÁ¤± Áä}Á—4þÁ§©ÁŠ,`Áƒ±ŸÁz˜ˆÁnÁaØjÁU¬ÁI¢‰Á> eÁ2¦©Á'4ÁŒÁ¬üÁóRÀÿ_žÀí‘ñÀÛ) ÀÃh¥À«TÀ“ƒÁÀxž0ÀKÛÀRy¿èîÍ¿—qy¿ZǾ$­ð½Åáê½ø—³¾Ë%¿pŠÃ¿Ç-'À lÀ8Q¤Àeõ`À‰d{À¡œËÀºTÀÓ§Àëá.ÀýGpÁ‰ÄÁ’ÁË5Á%NžÁ/ÝWÁ; ÁFÚ²ÁRðPÁ_eÁkŸÁxðÁ‚àÃÁ‰“¼ÁMzÁ— (ÁÌðÁ¤¦¦Á«–ÁµÚ¹Á®ÎbÁ§Õ<Á óÁšžÁ“NÁŒ“>Á…ô¬Á~ê+ÁqóýÁe ¨ÁX‚ÁL2kÁ@ÎÁ4RÁ(RýÁüñÁó8ÁhÀú1rÀæî¶ÀÔ%\ÀÂ)bÀ­ì„À–|ŸÀ|Æ6ÀMnÀ¿ã@5¿ŠBy¾ÕWO>W&??_¾?f“s?\>Útµ¾0³‹¿PF]¿¾À ± À9}ÀiÎ’Àj¡À¦l}ÀÀÈÀÒ’pÀä‘À÷hQÁzìÁí°Á–[Á%¾¥Á1’ÁÁ=œ¢ÁIÍ!ÁVjüÁco,ÁpÌjÁ~?åÁ…Ù°ÁŒ—Á“lšÁšZ‘Á¡X‘Á¨WVÁ²{ZÁ«i6Á¤^ÔÁ[pÁ–fŠÁ‰ôÁˆ»NÁþÜÁv˜ªÁizãÁ\‰ÏÁOžKÁCÁ6•áÁ*WƒÁo»ÁÙÁ[ÆÀø–`Àã‚lÀÏ1ÅÀ»öÊÀ¨Ø@À–(¨À€°ÀSDÀ#;v¿è ¿‹Â­¾Ã1å> 2?|yÞ?Í;?òñ’?䆈?šx?V½Ñ°—¿M·€¿Á}À¦‘ÀAÊ8Às­2À“¼À§n×À¹ì$ÀÌÂŽÀàÅOÀõ1ýÁN¡Áu”ÁQæÁ(J$Á4™€ÁAeÁN•àÁ[òFÁie9ÁvÛvÁ‚9´Á‰ ÁOÁ—öÁž°Á¥WÁ¯FsÁ¨éÁ øáÁ™ìFÁ’èÈÁ‹æàÁ„ùÁ|K}ÁnÇHÁaNÁT¹ÁGDÁ:0Á-Á òóÁ²šÁµ¶ÀùìÀã¶ÀÍFáÀ¸2€À¤4†ÀšWÀzyæÀRqkÀ&æ÷¿ó&ý¿“Ec¾Ôô>š«1?|G?Ú[Á@¶@4zˆ@$Ç?öÙ2?¢^W?QY¾O¿]ú?¿Ñ¶!À‚èÀLnÀv®óÀŽ‘ïÀ¢( Àµó£ÀʶÂÀà(yÀöÜÁ3Á €ÁcÁ,{Á9ÍÁG"$ÁT”wÁb9ŠÁoþÁ}ÖÁ…èòÁŒçQÁ“ê“Ášõ¨Á¢ðÁ¬PÁ¥ÎÁÆÁ–œ&Á}#ÁˆiÜÁd}ÁtÝàÁg(…ÁY‚6ÁLÁ>¿Á1˜Á$¬+ÁðAÁ N)Àþ$pÀåó ÀΡjÀ·‹vÀ¢lÀŒØkÀpÐíÀI™qÀ"A’¿ñ# ¿˜Ûܾþ…>a;?zûï?Ù5@§Ñ@EË@fÿ@Roè@(¥@?ûH?ŸÁ©? „¾~¹ÿ¿EZ¿ã7{À8éÀEqÀmÊõÀŠÊ¼À <¿ÀµÐœÀÌÕŽÀäN¿ÀüžÁ ÌYÁÊhÁ%ÂÁ2wLÁ@÷ÁMÍiÁ[“jÁin–ÁwwSÁ‚Á9Á‰Ç¨Áß;Á—üÁŸQÁ©‚#Á¢!—ÁšÇÖÁ“~ÃÁŒH½Á…%½Á| :ÁmÔ¾Á_Ï:ÁR£ÁDbÁ6¼ùÁ)k Á?”Á,”ÁsbÀë‚"ÀÒù‡ÀºÀ-À£)ÞÀŒ?ÀmnRÀBtÀ/Û¿âGñ¿‘JؾõŒÿ>`±²?j9[?Ó±@á:@E ^@qþs@ŽMß@„@Tžu@(¾?ôåW?’ U>Ê‹¾¾¸Ða¿‡¿ØŒÀ^¨À?râÀjzIÀ‹hvÀ¢.³ÀºYÿÀÓÈÀìS8Á"îÁ‹„Áþ×Á+ Á9h®ÁG5ÁU%Ác0ÁqBÈÁdfÁ†ÕoÁöëÁ•QÁœIÚÁ¦ãyÁŸyeÁ˜†Á§ÃÁ‰LÂÁ‚?Áu©cÁgj0ÁY,ÁJþàÁ=AÁ/nÔÁ!ÆnÁNÁ$ÀóèºÀÚ1aÀÀÑ]À§ôÅÀ´ëÀozêÀB?ÀпÖg¿‚Æ®¾À—>‡µÕ?n±Õ?ÑH@îž@C$z@qµ@P²@¡ú>@–û@€3Þ@RÔ@"Ÿø?æ}z?†ÏJ>µo¾š b¿xFà¿Ð@ÐÀ˜@ÀA/dÀoMiÀK°À¨ýñÀÂÿ3ÀÝYèÀøëÁ ‰OÁ?×Á% mÁ2àcÁ@éÒÁO6Á]»ÁkYœÁy§þÁƒúÁ‹&LÁ’\Á™›Á¤\ Áœë‡Á•~íÁއÁ†®‡Á~‘8ÁoÞ¿ÁaX¬ÁRÿùÁDÀmÁ6…CÁ({äÁ¤|Á ñUÀþÒ”ÀäùÀɰ¸À¯Ì)À–#cÀzûÀIW©Àa¿Öƒ9¿y‰¾—qN>²³×?‚Ÿã?Õbò@R@Bý-@oNð@Œmu@ r\@¶+@¬‘@•Í@|Y@M+,@éV?âˆ?‹;à>מÀ¾}Ft¿q¥,¿Ô´pÀ@ÀKÄ“À~b#À™¡ƒÀ´<6ÀÏ aÀêjµÁénÁ²ŠÁ³GÁ,¾ZÁ:Ö"ÁI8ÁW^uÁe®Át çÁIqÁˆ‘?Á×’Á—ÍÁ¡èæÁšu·Á“Á‹Á„#nÁyyzÁj¬|Á[âêÁM=¯Á>ÎlÁ0vµÁ"!1ÁôÅÁ…ÀðwÀÕåÀºe~ÀŸ²«À…Á;ÀW¢¤À%~ɿ晓¿†‰•¾£|]>ÊÊ·?‰í?ÞÈu@©¤@DÂæ@p|/@Ž»@¢k@µ>û@ÊE@Áä\@«M]@“‹@xk@KÝ@QÝ?çøÈ?û%>Üd`¾ f7¿†êпëüJÀ*_ZÀ_œÀŠÑ’À¥ü6ÀÁMuÀÜàÀø°lÁ r:Á\Á&ÐôÁ5 ÁCh>ÁQÍÁ`\‘Ánñ¥Á}…DÁ† âÁhûÁ”ÒÁŸªæÁ˜ÓÁšKÁ‰!ÞÁ±Át€âÁeŸÖÁVÎ|ÁH ÑÁ9VŒÁ*¿øÁ^QÁ ¢Àÿˆ°ÀãsäÀÇÎÀ¬:"À‘&bÀl¶¹À7©,ÀšŠ¿ŸáS¾ì-c>œRä?‡Ä?âï@qA@Hwq@tV@qw@¥r@º¦5@Ëœä@ßÂD@Ö0í@ÀŒå@©v\@“@y[2@M@!Ÿ?æ¯]?‡_>˜ ¿ñš¿«ç·À ¤ÀÀBœÀy:À˜!À´8ÀÏ÷vÀìHµÁYËÁ¤—Á ýèÁ/†¡Á> 9ÁLÓÈÁ[o[Áj êÁxÊtÁƒÕáÁ‹J}Á’¿8Á´Á–ÅÁŽ€Á†éDÁ~½rÁoÆÉÁ`âÿÁQÿÁC:Á4N:Á%®îÁÄÁ|§Àô<ÀפuÀ»a†ÀŸ<6Àƒ˜ØÀPyÀ±w¿ÈÞ¿;¹Ø=£È ?b)?Õ+¸@úZ@IJ†@veƒ@©@¦±'@¼ƒ‹@Ò¦¢@ä1ô@öu@íÌ@Ö·5@À!@©²C@“:J@y½@Jð2@Éã?ÑwF?Qf@¼´1Ö¿^_l¿Ý„±À%ÅbÀ]M¦ÀŠÓ.À§ÖÀðIÀàX9ÀýMóÁ <ÛÁÑ"Á*zÄÁ9SÝÁH,oÁVèAÁeÎTÁtÖñÁìÍÁ‰b†ÁØnÁ›ÙÁ”;¿ÁŒ¡Á…‚Áz×ÙÁk¥ÁÁ\ŒâÁM’§Á>ÑÁ/«ºÁ Æ¥Á Áj Àéª ÀÌ€DÀ¯ÅkÀ“MöÀmÿfÀ6\¿ü—k¿ŽðV¾…1d?ë«?´£/@[Ó@A&R@rFÎ@Áe@§Œã@½h@Ó‡¸@é–~@þn±AwHAü@í)Œ@Ö²¹@¿þÍ@©Â@‘˜W@r+‡@>f–@ N8?¦ð>ãÝ!¾ÖOw¿¤ERÀ ÜçÀCÉšÀ|X×ÀšÎCÀ¸ …ÀÕ\Àòž¸Á ÁÁ%ýSÁ4àAÁCܼÁRûÁb(’ÁqLøÁ€9?Á‡½”ÁH8Áš7uÁ’„ÁŠØÁƒ2]Áw)Ágò{ÁX¼ ÁIŒÔÁ:eÖÁ+XßÁbñÁ oÝÀý"QÀßx`ÀÂ;£À¥gÀ‡öÞÀVzÄÀcª¿È©Ä¿1Û>?P›?…Î=?ó–A@/©5@dà@Œ+¤@¥1Æ@¼úÆ@Ôl@ê<©A>QA TòAk¸A A¹@움@Õy'@½Ç*@¤Í~@ŠwŒ@^jí@'Ñõ?áS‡?eÁ9<”w~¿^×à¿áÿÌÀ*ïÀe=CÀý¥À­XáÀË'Àé\ÞÁÊxÁ»îÁ!ÕÝÁ10Á@còÁO®HÁ^ášÁnäÁ}WaÁ†RvÁäÁ˜í@Á‘,FÁ‰nsÁ°¯ÁsìÁdƒ¿ÁU(”ÁEÝýÁ6¨"Á'ÁV Á 5VÀô<ÇÀÖc¯À¸«^Àšü4ÀzâÀ@Àl¿˜ãõ¾™•N?§?¼ÜÛ@¥â@MÜc@‚XE@\Ã@·¨û@Ñ7Í@étsA[šA ˆ¨AÁ(A!ÞÆAkA ‹¢AíF@é¦n@ÐLá@µ&@™â«@|V®@Dó×@ ¾Ó?¨µ>Дƾü&¿³öªÀÿOÀPE•À†e‰À¤´.ÀÃÒÀáQvÀÿÌoÁJÁ¢*Á-û‡Á=U{ÁL³˜Á\ŽÁkŠ1ÁzâxÁ…ÁŒ¼çÁ—'ÁñÑÁˆ+kÁ€hìÁqO”ÁaÍPÁRQ$ÁBàÁ3nÿÁ#ÿÁ XÁY[ÀìcjÀÎ,JÀ¯õ)À‘Â=ÀgÁ$À,v£¿â_c¿Y\=:I?y?ï~à@1Dæ@i½°@ók@¬»…@ÈÀ@âõÄ@üö™A ÖáA¦A!çØA-G9A"ÈãAJA Âó@û@ßÕþ@Ä(@¨h3@Œ2I@`^@&kG?Ø‚¾?C¾+Oì¿‹ð…ÀŸÉÀ?·±À|ÏÔÀ“À»·"ÀÚ£%Àùœ¿Á OÁÒ|Á+WäÁ:Þ©ÁJXÁYÕÁiU+Áx׫Á„"‡Á‹ØÁ”/ÁŒþ*Á…øŒÁ~ÛÁo¿Á_hcÁOÍuÁ@9ÚÁ0²<Á!9%ÁÃíÁUóÀåáÀÀÇ™À¨MþÀ‰ÅóÀW%|Àÿ¿¼Ä¿ ‡%>ÄAü?§i½@Sâ@H÷P@zÞ@žQ‘@ºµÏ@ÖÓL@ò¨ÆA 3A[óA ðêA,à#A8G1A-$&A ¤tAþÁA'@îƒ@ÒÎ@¶ d@™)¤@x |@<^û@M ?ˆ$M=Ð?X¿[ô"¿èÞUÀ2¨Àpž+À—ŸÉÀ¶ð}ÀÖ­Àõ;Á JÁµ‰Á)]Á9¤ÁH©BÁX91ÁgÉ ÁwYÁƒc"Á‹ÖÁúÁ‰»‡Á‚ŽÙÁví’Áhð›Á[7ÁM1Á>n‹Á.¿ÊÁÁbÇÀÿ{2Àà[ËÀÁZ™À¢~rÀƒ®cÀIÊÅÀ Œõ¿4—Å¿×lâÀ*FðÀh×pÀ“´\À³ÞÀÒ‚ ÀñòºÁ±nÁi‚Á(!—Á7Ä€ÁGh>ÁW Áf¬lÁvI Á‚ZáÁ‰w™ÁŽ$Á†¿HÁ~ÙºÁpa*Áb`ÁT ÝÁF”Á8h*Á+&œÁ¸£ÁÀüÇZÀÝmÓÀ¾ÓÀžÖÃÀ)fÀ@ªÀ T¿†ñý½´4?_z ?ê¶‚@2¹Û@oc-@•Í—@³¨ @Ñ7ã@îÛÐAEmAûËA#[ÖA1} A?‡yAG:›A:CA,¢ÀA_ªAzAx@æõp@Ç·@¨<:@ˆÁ@RË@,9?«³>´þ&¿!´­¿Îô6À&¤!ÀeÒÏÀ’€¾À² ÀÑ…pÀñÖÁ8Áì'Á'¨„Á7j ÁEÃÁS”êÁa†àÁo³ûÁ~wÁ†KFÁ‹§BÁ„*®ÁyháÁjšwÁ[öÝÁM‡:Á?WPÁ1cŠÁ#”¯Á0ïÁ \tÀúxÜÀÛÿÀ»ÅœÀœlýÀz)ÄÀ;ƒ¿úX¿z#æº|r?y=ì?ù9b@:éç@yYÎ@›èš@» x@ÙÐ`@øDïA ¦ÝA­âA#ÇÌA1<—A>W@ACýÃA6ÉA(RA[lA äs@þOA@âø@Ųõ@§ã@‡²§@QQ@ÚX?©.¿>¯”ê¿$gÞ¿Ð[ŸÀ'TªÀf{„À’Ñ/À²?ÀѤaÀñ ®Á8ñÁèeÁ#­Á0¼VÁ>¤ÁL©DÁ[èÁi½Áx*ôÁƒx`Á‰zJÁì+ÁtÑÓÁeÌ?ÁVÔôÁH“Á9kÁ+@ÁÖÁI¹ÁÊñÀéÓéÀÑË—À»$Àœg]ÀzxÀ;M«¿ù¡\¿ys…:‰p?y¢ö?ù€±@;Î@y ½@›¬@¸Fê@ÔÁw@ðoA¹|AÿÅA µcA.|A<ìAAöA2˜[A$)£AåAØs@ó†m@×u@»Hð@Ÿ=@Õ×@H?È@ ÖJ?šp >xê]¿< ¿Û‡2À,…ïÀkHEÀ•MÀ´fxÀЦ„ÀèÃñÁ±ÁXoÁù,Á)íÁ86DÁFÀìÁUb,Ád*ÁsxÁ¼Á‡¦ùÁúÁp½¡Áa›¸ÁR™âÁC£Á4¸§Á%õ Áq¹Á CÀ÷ ÝÀÜl²ÀÂÔÀ«5À•;íÀ|·‰À>B¥¿ÿ›‚¿ƒ®y½”‚|?a1~?ê´©@2”î@nn—@”=Ž@°³@̈­@è=®AøBAýŠA&‰A,YÊA:ªA>ëðA0EŒA!RyAkåA¢Í@é¥å@ÌÇ@®Ô@’‹@jñ.@1ñ7?òq?x½î=,°‡¿j/Ë¿ðšQÀ6Às² À’á¨À¨”#ÀÀ++ÀÙ¬Àô"CÁ»·ÁÜ¿Á$U¯Á2ý¬ÁA¿oÁP¥(Á_ƒÔÁn7Á}sÁ†GƒÁ}Ám¤^Á^L|ÁOÁ?îøÁ0ß³Á!ìÁ0ÔÁ¹ÛÀíyÀÑ“:À¶á¶ÀÈÊÀ‡'Àh…°ÀE„úÀѶ¿”]6S?;B3?Ô‘¡@%a}@_Y@‹ìL@¨Ñ@ÄŒ¨@áD'@þ!£A ¨»AC¾A*—3A9 •A<ê}A-±^A^éAm@ÿÕý@áâ @ÃVþ@¤»R@†c@QûŠ@|—?½-Ò?5W¾™+⿘ŒÀôÝÀ@¬YÀ]ÏÎÀ‚‡ËÀ™,ÊÀ²©NÀÍ?dÀè­{Áƒ¼ÁíÁ¤vÁ.xsÁ=r<ÁL@-Á[3ÁjJkÁy~YÁ…V!Á{Ák–Á\ýÁL²ÃÁ=c·Á.4{ÁrÁ]ÁJÀåªZÀÉ®ªÀ®þ!À•G»À|ŒÀT~’À7BXÀ€…¿¬7¥¾Ö&@?>?¶Ø´@±@O&@„{Ã@¡Mj@¾¹R@Ü|j@úL¸A û0AÐúA)ÁƒA8É`A;¬JA,6AUZA ž‰@ùä‘@ÚªJ@»T@œØ@|Šz@?S"@S?‹Ä+>8 Ë¿9£¿ËóÃÀ‘”À&ùÀE>ÞÀmfÀŽdùÀ¨HÆÀÃgÀßÐÀü²GÁ µÁäzÁ*¡‚Á9‡øÁH™ÐÁWÍõÁg¡Áv}EÁ„¹ˆÁyÒœÁj?ÁZ»)ÁKJ‚Á;ñØÁ,·ŽÁšÁ¡ÀÿcŽÀâ.QÀŹ"ÀªLÀÔrÀrOèÀK½]À/[ÖÀ Ü¿ÊRõ¿&p>‰d?—:@å@@v4@{“Ž@œ$Y@º¯@غ´@öÌäA PAÌ3A)]A8EžA:»¢A+“AQ)A w[@÷;@ׇ{@·Êk@—þ@p{Œ@1(•?ä¢à?S6í¾ E¿ŒÀÕµÀyRÀºìÀ7™ÞÀ`ÛbÀ‡ææÀ¢ .À½¿˜ÀÚ*ËÀ÷ Á HÁÒBÁ'ÇÁ6éÁFâÁU@Ád‚]ÁsÜñÁ„^ÓÁy%ÂÁi•…ÁZuÁJ©IÁ;UëÁ,!úÁGÁHÀþ›éÀá–0ÀÅlâÀªÃÀ‘;fÀt£‚ÀNºjÀ4l6À'óa¿è5¿d½ =mi?}½Ð?ô€Ê@7–µ@v'Ø@™è@¸Rá@Öâ@õµÙA P^AÍ×A)Q#A8×´A:wŽA*žÈAÆ1A í×@ö1 @Ö’*@¶ô@—UÞ@ooq@0¢?à¡A?BFz¾rÖ6¿ØÊÀ¯'À­ÃÀ©xÀ5¶À\À…G#ÀŸˆÀº8ŠÀÖ¦ÀòÎÁ”ÁßeÁ%ߣÁ4ïüÁD„ÁS^UÁb’µÁqÝ ÁƒëLÁxÎÁi^XÁZçÁJÍÁ;œšÁ,rÁz•Á¨ØÁùÀã§ËÀÇ÷vÀ­ÃßÀ•·Àj§À\ñÿÀCépÀ8ŽKÀÁ¿‰gé½ô?]"0?ìW@4ÿ<@sÄ@˜þ@¸@×ä@öG×A ÎfA‡ÙA*4A9¹ A:ÌÉA*ü¿A.ªA N@öÜÔ@×ê@·]j@—ž–@oÁê@0Kª?á½?E¿/¾_^`¿šŸ‰À ©£À"N´À&ÖÀ=gÝÀa‡KÀ†¾RÀŸZ`À¹’™ÀÕRíÀñ¹æÁiÕÁþÁ$øÒÁ3éÉÁBí­ÁR|Áa(TÁpdÌÁƒ‰ßÁwã>ÁhÎŽÁYÛsÁK5Á<÷Á-G‹Á¦ÓÁ‚ÁÞ;ÀèíÀÍE¦À´1#ÀœÀöÀˆ–…ÀpxaÀZ}åÀH nÀ >*¿”ˆ!¾4Ÿz?Oî“?ç2@37¢@rÕý@™:,@¹ Z@Økö@÷ÍúA ˜.ALÀA+\A:Ú’AËA.>PA_öAœ@ýF„@ݱ@½¶:@ìÄ@|F›@<³®?úA?v!ؽ¶à¿ƒ\ZÀI~À@àîÀXxàÀh1OÀ“HÀ“‰lÀ©V ÀÁÎäÀÚæ%ÀõQÁt«Á°-Á%'Á3µ€ÁByÇÁQ5çÁ` ÁoÁƒêRÁxÛmÁiïŸÁ[ 9ÁL~½Á>ÅÁ/ؽÁ!¼ÁùÁÈeÀôœÀÛÌYÀÅJŒÀ±GÀ {¸À“qûÀ„-áÀH{9Àš°¿‘tM¾ ™Ò?\±?íÎë@6È@v±Œ@›Q‘@»LX@ÛH<@ûDÒA  îAŸœA-žgA=HA>ÛdA/‘™AªAÀ8@ÿó@ß·ÿ@¿Í‘@Ÿã$@ñn@@”@Kö?Xç˜C?þ ç?}ÎŽºõb9¿~Ãð¿þ.žÀ>ÅÀ~6ÕÀ“ËsÀ\µÀ¬ìÀ½àªÀÒ{4ÀéXFÁÞûÁ ¸hÁvÁ(Ù˜Á6µÁDʦÁS&ÁaºÁpsùÁ…T¶Á{ìÎÁmYrÁ^øÁPÓÁBç=Á5@eÁ'÷¹ÁŠÁÕÁ]2Àñ&¤ÀÝyÀÌŒóÀ¾e·À¦¼¶À†ùÉÀNntÀéU¿žÈÀ¾~óÁ?>ë?Ýß´@.*e@m~¼@–sê@¶(v@Õ£¡@ôþ«A ¯AŸ=A)²A/¯QA,m¬A ºA‘ A¶œ@îô‘@ÑÌù@´7ã@–3@o˜Œ@2}?é¡ã?WÒt¾àl¿Ü_À`GÀDb¾ÀëÀ¡´AÀ®;$À»‰ÀËaõÀÞ¤ŸÀóýÁ†Á×Á¯ƒÁ+ߨÁ9fÃÁGB`ÁU^IÁc¹ÁrCÚÁ†œ3Á~µJÁpO#ÁbÁT.ÈÁFUÁ9PÁ,o Á KÁVáÁ E¢ÀþóÀë·ÀÛìVÀÊO¤Àª™ãÀŠùþÀV¹qÀ|t¿°&·¾ÅR?)U?ÊÓ@#¶}@bm÷@R`@¯NÎ@ÎNb@í A­A0èA¼‹A¹‹A¥ÌAãÑA :@ú©@à#@Ãê@§v¢@Šh@Zp"@Š»?Å/3?`¾¸B¿§ÖïÀ¨ýÀP À‡CùÀ¦|ÀÁŸCÀÌ=ÀÚFNÀëÂÁìÁ JÁÎ.Á#I^Á0 ÿÁ= ÁJš>ÁXküÁf…ØÁtÖ—ÁˆFõÁ& Át)–ÁfA‘ÁX£—ÁKYcÁ>f?Á1ç€Á&/Á·nÁ&,ÁqÏÀûÆðÀízÀÎãÀ¯]„ÀþBÀaFpÀ"\¿Ç´¿¨'>ÆGå?­|Ï@Ù@RÍà@‡üÝ@¦6p@Ä )@àÜ’@ü—A ®‰AìAÅ…A$1A ™?@þ¡·@çE@Î1×@´ @˜ÆÔ@xÍë@?î3@`?—L³>…ƒ¿-ø¿ÎÕÀ$ÀÀ`ñ­ÀŽÞ#À­„LÀÌ´Àß–ÀìÀû‚ÁõµÁY?Á¯sÁ(«.Á5ÁAµÁÁNÓwÁ\K‘ÁjäÁx1ÁŠ.dÁƒ/žÁx’¦ÁjôêÁ] ëÁP­%ÁD,¦Á816Á,ÁáÁ!Ô Á°hÁ–…Á†ÀôkšÀÕÀµ¶×À–…ÀoâÀ0û»¿åÝ(¿S…³>[?‹d§@%y@>˜F@y8k@™]@µJ"@Ð9F@çx6@õA@üè²@ÿ¤¹@üðå@ôè-@æt@Ñc£@º_@¡‹ö@‡Š=@YØ+@"¨œ?Ób?D0 ¾Ú0¿†î¿úóÑÀ9 •ÀuØÀ˜˜ŒÀ·ÃÀÕj.Àó[œÀþ× Á¤­ÁBÛÁÙîÁ#r¶Á.Þ^Á:ëlÁG&ÿÁSÒÁ`éŒÁn[÷Á|ÆÁŒ‚ÁÁ…£:Á}ËÁp•ëÁcž£ÁWàÁJåZÁ?T—Á45µÁ)ÓôÁ >(Á¨ÊÁ 2ÙÀû[ÀÜT‹À½M÷ÀžGcÀ~¹ÀAh”À•¿CÚ¾:ìu?>Ùx?Ô¬¨@#Ì¢@[ú{@‰^G@£r @º~þ@ËÕ_@ÖŠz@Ýb(@ß¾h@Ý•ø@ÖlE@ËãE@¹TP@¤%@Œî$@i3¯@6å@Ût?–b>B~¿~¿»«À»ÀQ†À†5À£¨sÀÁy‹Àßp™ÀýçÁ ˜¶ÁKpÁ%¢Á!5›Á+J6Á63}ÁA®•ÁMz+ÁYƶÁf‡­Ás©âÁ€ŽuÁ6ÁˆzÁÔyÁv®NÁj{Á]çvÁR7HÁGŽÁ<]~Á2l_Á)];Á ’RÁ-Á‘Àä|ÚÀÅÛØÀ§n=À‰4ªÀUö.ÀÛ)¿¾W¿Lb>¦þÛ?šWJ@2”@:GM@lúo@Wo@  y@®mÚ@·ªÙ@½ÈÎ@¿Ø@¾@·šF@®6E@ ì@Œ4@mÎö@?Žo@X¸?ºC?#w¾InS¿†ì¿ö–”À42Àl·À’ÙÀ°ÓÀÍK’ÀêèÁÁN½Á5)ÁxhÁ!ÑGÁ*MwÁ3Ð_Á>-×ÁI"=ÁT™!Á`pÒÁlÅÃÁy…lÁƒP Á’)Á‹ŒLÁ…Á}zhÁq:“ÁeqÁZ1ÁOpoÁE)Á;¯ÓÁ3$KÁ$ÑôÁƒAÁJÑÀîX]ÀÐÊÀ±þÀ”VËÀn qÀ3|…¿ô׿ƒ‚D¾%E?2ç?Áq©@«@@_¿@hG@„M«@?!@˜Šâ@ž)à@ŸñÅ@žKŠ@˜©º@ìr@„¯ @f×ñ@>'j@RÎ?Ê-?V,=c<ˆ¿@eæ¿ÈáêÀ>ÀQö‰À…¹À¡q`À½ÌTÀÚ=À÷H_Á I{Á‡Á%<¶Á,äÁ4ˆÁ=îÁFÚkÁQUƒÁ\W–ÁgÊ Ás¿âÁ€ZÁ†wqÁ•cïÁŽð Áˆ¦ Á‚ˆ+Áy4qÁmÐ<ÁbåÁXu•ÁN»ñÁEÊÁ8à)Á)¾Á¡?Á ŽƒÀù@ÀÛÇ¿À¾ymÀ¡2ùÀ„|ÙÀP­éÀÛ8¿ÄY¿1,0=åK?a?Ì!C@ûç@3<@N§Z@c.@r.@|ù3@€ s@}í@sZ@cÕ@Nª…@2¦!@ T?ÇÍ ?cZ—>/+㿇.¿¬vÀ 2ÅÀ=T}ÀsêÀ”×áÀ°?bÀÌØÀèázÁžÁÔ ÁF¬Á-í.Á7'ÅÁ>±ÁG"WÁP`AÁZf{ÁdñžÁoû Á{VÁƒËÁ‰þÁ˜øGÁ’¬üÁŒÚÁ†¡3Á€íÇÁvÊ"Ál*–Áb(ÈÁXßCÁM3Á>mÁ/%³Á MPÁœYÁ÷Àè«ÀËôTÀ¯ÍXÀ“ÎãÀp‡’À9ÔÀ–¹¿¤È8¿os><4?Y'Å?µÛh?ó¥@¼ê@%^ë@4$š@=í@@JC@=zÇ@4Ä:@& ü@Ç·?ö¾?³”Ê?O„Ý>c^¿– ¿ž¶4¿ýßHÀ0hÀbw-À‹6åÀ¥vlÀÀ´}ÀÜ iÀ÷›XÁ õûÁ&ÌÁ&VñÁ4ŠŽÁBÂuÁIÆÓÁQ¸ÛÁZ8ÁcöÁnÉÁxäœÁ‚ uÁ‡ØÙÁÖ¼ÁœÓKÁ–¸…ÁÊ!Á‹ _Á…r7Á€ÑÁv çÁl…KÁa°üÁRÉ‘ÁD4Á5TÚÁ&±mÁëÁ ¸ÓÀ÷C¼ÀÛ:ÿÀ¿‡<À¤ÿÀ‰r‡À_ZÀ+øØ¿øñA¿œÑ$¿³=ó?’£?€©?¬ô®?Ï?N?êmÞ?ú…L@} ?ûÙ@?ì[¯?ÐQË?¬j[?òº?pI;ÚÔ¿}¿ ov¿øCUÀ)¨óÀY=|À„ø‹À÷œÀ·Ã‹ÀÑÔqÀìŸÓÁóÁyÁ°Á-¬ Á;ÜÜÁJ ƒÁUMÁ\Ê/Áe úÁnCÁwÖ¾ÁÁ†‹ŠÁŒ#Á‘óÄÁ õ.Á›©Á•EmÁ«ÁŠ?$Á…@Á€5þÁvtÁg¶ÁYÁJkÈÁ;ÕKÁ-yÁ]ÁSŸÁl¶Àë]iÀÐ=À¶^ÀœG®À‚úŠÀVÕeÀ(Å¿ü¨–¿¬ª¿K„‚¾ªD=‘'>É;??'‡?Xï?u?aû?yyå?\õÄ?) h>ˈS=£! ¾žœ¿Lÿ¤¿±ßÊÀŸýÀ*xÀVÓÀýsÀ™ÅªÀ±æÀÊÞnÀäecÀþa Á V ÁèÄÁ'‹ÇÁ5ÁŸ™WÁ™øÔÁ”…ÂÁNþÁŠYôÁ…­íÁ|É]Án&#Á_–PÁQ9÷ÁCAÁ5 HÁ'!qÁPnÁ § Àü¿·Àâ¾4ÀÉêÀ°}À˜„´Àk„ÀXnHÀ/dÀ }¿Õ!«¿mù¿]‡z¿_o¾¤¸2¾çy½ù¸ŠÁ!ÉqÁ²¯Á¶bÀõÖ˜ÀÝ;¤ÀÅŽQÀ®&À™3€À„[YÀdÙÀ@ìEÀ#ýÿÀ |Õ¿ç'¿Ãà࿦6¿ÂV¿„ž[¿{¡!¿‚ ¼¿Žñì¿£Så¿ÂS¿æÛ;À˜À"¯äÀ@êÌÀeú3À…ÓÀš†À¯–¸ÀÅËÀÜh÷ÀôƒÁ*ÁYÁã2Á+ǘÁ8ÅšÁEñÁS{"ÁayÁn½-Á|Œ—Áƒô×Á‡åoÁŒ.ªÁȪÁ•«Áš¼Á aÁ®ºŒÁ©? Á£ø’Ážé>ÁšÔÁ“Œ­ÁŒ^{Á…GVÁ|~ ÁnÁ`¥_ÁRÝHÁEK[Á8~Á+›ÁÁZÁ3¦Àò—óÀÛ´ÈÀÆ/ÝÀ±SÒÀž/ÆÀŒ¹=ÀyFTÀ]w)ÀEzEÀ0Ï_À%Àˆ/À“ÞÀ*t¿ýiÖÀØÀÔ*À.^ÀäÚÀ0<ÀD”À[¥SÀxžqÀŒÔIÀŸŽGÀ²¬‹ÀÇ™ÿÀÜÌ&Àó &ÁÑ÷Á7Á“Á(ÎÈÁ5MöÁB…ÁO (Á\ Áix~ÁwýÁ‚YªÁ‰,¾Áé Á’Á–qlÁ›&zÁ  ¨Á¥)†Á³½Á®iñÁ©LµÁ¤jpÁž?bÁ—%ƒÁ$Á‰HÁ‚$ŠÁvzÈÁhÚzÁ[s|ÁN>ÁA=Á4iyÁ'Ô­ÁÁˆÁÓYÁl¹Àó,tÀÞKáÀÊ‹YÀ¹kÀ§ºsÀ™Y¿À‹É©À€»ÛÀn¹À]J’ÀPVäÀFË8ÀBºÀ>yËÀ@šÀEãjÀNÝÀ\ÚBÀm\ÅÀ€L=À‹&}À˜Æ#À§’øÀ¹m”ÀÌÒÀߣÙÀô­õÁKÁ#Áp,Á'0®Á3!Á?JÁKÁªÁXo³Áe\~ÁrZ®ÁGÁ††ÀÁV[Á”ÆÁ˜ ôÁœN”Á ×ëÁ¥’­Áª†Á¸õŠÁ³ÉùÁ®ÕÁ©SÁ¡ó¢ÁšñbÁ“öwÁ ÐÁ†7ÌÁ~íÁq’ŠÁdiÁW}áÁJÊ…Á>W Á2FWÁ&^ÁÿRÁxÁ¢³À÷:"ÀäóÈÀÓ´ ÀÃýéÀ¶«À©³óÀž±9À•›ÚÀâºÀ‡Ä’Àƒ`À€Ã¬À~1:À€.À‚a¥À†ìÞÀbMÀ•>ÅÀžˆ4À©èÀµ>tÀó0ÀÓ—5ÀåëCÀø¾‚ÁUÙÁáÁŸ\Á&§Á2ÔÁ=Ä$ÁI¯hÁUÍ6Áb6ÖÁnÌ3Á{°kÁ„P¼ÁŠÛ|Á‘ˆmÁ˜R²ÁžCrÁ¢ZuÁ¦°ÚÁ«BöÁ°Á¾^ãÁ¹WÁ³Ê–Á¬Ã}Á¥ÈrÁžÜÚÁ˜MÁ‘;ÜÁŠ:ÁƒÚoÁzpÁmÐgÁa7éÁTÛAÁHË&Á<êÑÁ1’(Á&¥@ÁàÁ úÁ‰­Àÿí¢ÀïæÀà¶1ÀÓ ‰ÀDz«À½ýÀ´5…À­ *À§PÀ¢Ô“À w„ÀžüÝÀŸßOÀ¢ èÀ¦1äÀ¬9°À³ÖÿÀ¼þ‹ÀÇ"ÀÒBNÀà&ÈÀîâ¼ÀÿäqÁ 4yÁÆÁÞwÁ'o[Á2<óÁ=a±ÁH­ÈÁTW›Á`?‡ÁlUòÁx¬Á‚™IÁ‰,Áx²Á•øxÁœ“uÁ£KøÁ¨„7Á¬«1Á±ÒÁµ¿)ÁÃè|Á¾–¢Á·˜TÁ°¦ËÁ©Ã—Á¢õÁœ8Á•ŠYÁŽîPÁˆqÇÁ‚ Áw®JÁk]æÁ_OôÁSyÁH%(Á=4<Á2šJÁ(CÁÂ7ÁáBÁ høÁ¬ÂÀý{ÁÀð«ªÀå{cÀÛ§~ÀÓ‹ÀÌ]›Àƹ ÀšÀÀ+[À¾å^À¿¨pÀÁÃëÀÅvëÀË3ìÀÒ¡çÀÛk’Àå$IÀïï•Àü¢Áƒ¤Á WïÁ&sÁzØÁ).ŠÁ3hrÁ>úÁHÚäÁT»Á_LñÁjìoÁvÑÁqaÁ‡‘·ÁÐ<Á”,•Áš¢©Á¡hÁ§¦»Á®OMÁ²ÎÁ·ÄÁ»–ÁÉYŽÁÂf£Á»LÁ´«QÁ­êøÁ§:€Á ™WÁš FÁ“™þÁF˜Á‡wÁ€ðwÁuÔÃÁjQÁ^¸DÁSÅ…ÁI öÁ>÷Á5Á+ÞêÁ#edÁ6~Á $Á -ÁT¾ÁìÀú?{Àò;vÀ댓Àæ#7Àâ_¬Àßß3ÀÞÏ,Àßq‘Àá}ðÀäÐðÀê/ÌÀño>ÀùÅšÁªÀÁõÁ Ê;Á½qÁÙÁ#cSÁ,b÷Á5ÕGÁ?6ÁIòmÁT—“Á_yÁjŸÅÁuìAÁ€ÁœÁ†±ßÁŒ¸ZÁ’ЂÁ™ ÁŸZÎÁ¥ÌŸÁ¬C%Á²ÁnÁ¹NÁ½5ÎÁÁ”tÁÍ7òÁÆgiÁ¿ž¡Á¸ègÁ²FNÁ«°iÁ¥-1ÁžÂôÁ˜rÁ’<üÁŒ(ªÁ†+ÍÁ€L+ÁuKuÁjQJÁ_‚%ÁURvÁKxÁBÕÁ9NžÁ1Á)P·Á"mìÁáaÁ7vÁù'Á l‹Á¼sÁe]ÁÌnÁœÀÿ“Àþ¸úÀÿ:³Á›úÁ)ŒÁž5Á)Á ÷ÁÑÁöaÁ¬Á"3Á).MÁ0õmÁ9€8ÁB¢‹ÁL;êÁVÌÁ`|hÁk/JÁvnÁ€ŸhÁ†EÖÁŒ ¿Á‘ûÁ—ÿTÁžÊÁ¤D¥ÁªŒÏÁ°ö–Á·mÁ½â@ÁÃ{YÁǶáÁÑA@ÁÊ‹æÁÃäkÁ½JÔÁ¶ÇÑÁ°R¢Á©ìiÁ£—ÇÁeÁ—]~Á‘kÙÁ‹ŽÎÁ…æÁ€n‹ÁuþÁk¬–ÁaÚ›ÁX=ÅÁO=LÁFéDÁ>ÒoÁ7«ÛÁ0ØtÁ*ÏÊÁ%ûÁ 59ÁÑÁ[+Á FÁ•ÜÁõbÁ¥`ÁQdÁƒ¼ÁxýÁøJÁ-ÉÁ¦!Á^@Áù×Á$ûfÁ*]5Á0~ Á7g}Á>ÉÁFòÄÁO©ÁXï¿Áb£¯Ál ÁwKÁ€äHÁ†ZõÁ‹îíÁ‘•—Á—ZtÁEJÁ£FMÁ©UÁ¯ÁµÁåÁ¼ ÿÁ”|ÁÉùÁÍúÁÕ{JÁÎßîÁÈK½ÁÁÐ[Á»mEÁµ ¶Á®¹‹Á¨ŽÁ¢‹[Áœ¬ Á–ÏsÁ‘#Á‹­Á†>ÁÁ"Áx*lÁn…ÁeGØÁ\ÐÁTÁLð¾ÁFTÁ?q~Á9±RÁ4.ÅÁ/tKÁ+R¦Á'ïJÁ$»€Á"iåÁ Ø)Á‡<ÁFKÁnÁ UÿÁ!ÍÞÁ#ÌëÁ' ìÁ*¾Á/$[Á4nÁ9X Á?ÁE´ÝÁLÙìÁT˜>Á\üÇÁeÚNÁoKcÁy uÁˆ=Á†ÊÍÁŒ1Á‘ªAÁ—>rÁœåaÁ¢§ŸÁ¨Á®GÁ´™õÁº¼°ÁÀóýÁÇEàÁͳ¿ÁÔ%ÁÙÉÝÁÓE{ÁÌ×dÁÆz@ÁÀ$\Á¹Ü÷Á³·àÁ­¹qÁ§âFÁ¢Áœa‚Á–å·Á‘yˆÁŒ8[Á‡:Á‚i—Á{hŸÁr©üÁjn@ÁbnïÁ[IÁTr ÁN<%ÁH’ÚÁCbPÁ>¾aÁ:èÑÁ7‚€Á4nfÁ2E´Á0ºïÁ/jêÁ/;2Á/[&Á0*kÁ1—½Á3x&Á6–”Á:-^Á>P ÁC9xÁHYOÁMáÓÁT3BÁ[ÎÁbu¨ÁjŒúÁseÁ|£Á‚Ø›Á‡ºjÁŒÊ Á’`Á—~âÁœù–Á¢ûÁ¨51Á­õ'Á³ÕCÁ¹ÏòÁ¿à/ÁÅû©ÁÌ%™ÁÒnTÁØÓ+ÁÞ>BÁ×Û…ÁÑLÁË@$ÁÅÛÁ¾âŽÁ¸çúÁ³2Á­PÇÁ§ŸØÁ¢GÁœ¯3Á—g±Á’]÷Á©ÁˆÍÁ„PZÁ€'ÁxuÁpÒÁi«nÁbüÁ]&ÁW„ßÁRžbÁNÁJoµÁGµÁD#ÐÁB'0Á@޵Á?OEÁ?,ÞÁ?JoÁ?ösÁAbÁC,ÁF `ÁI£FÁM‡QÁRI6ÁWfHÁ\¨ÁbÈ>ÁihWÁp†Áx>Á€FØÁ„šÔÁ‰3†ÁŽ ~Á’ò0Á˜ Á]Á¢ÌDÁ¨HôÁ­ÝÁ³…Á¹BüÁ¿…ÁÅõÁË%øÁÑ6”Á×YaÁÝ™ÏÁâÞ„ÁÜ–ÏÁÖZ1ÁÐ*XÁÊÁÄùÁ¾@iÁ¸ŒaÁ²Þ|Á­UÁ§åÁ¢˜$Á„8Á˜®+Á“ìqÁVúÁ‹ÒÁ†ìèÁƒ9Á~æYÁx ‚Áq²-Ál ·Áf™àÁaÚtÁ]€ÁYô!ÁV¬UÁSá¿ÁRŠÁPdØÁO4%ÁOÁO;`ÁOÇXÁQ,×ÁRèÁUåÁY/Á\ÑiÁac>ÁfbéÁk­ËÁqy/ÁwèyÁ~¾šÁƒ>Á‡=Á‹KqÁ±LÁ”`óÁ™@aÁž,”Á£QhÁ¨§ Á®¦Á³˜XÁ¹--Á¾ÔâÁÄ‘ÁÊ`3ÁÐPñÁÖb¦ÁÜr«ÁâlÁâ— Á܇êÁÖ™WÁÐÇJÁÊþÐÁÅFbÁ¿«¡Áº(£Á´¹ÜÁ¯mÁªUÁ¥sÁ ŸÁ›õ;Á—KÁÁÄ–ÁŠdÿÁ„2¶Á{T…ÁnZ±Áa’=ÁU±ÁHðUÁ=s5Á2š’Á(-8Á©nÁ@›ÁÅ|Ás’Á`¢ÀÿåÔÀûmÀú·ÉÀübPÁÚƒÁ”ãÁ õkÁcNÁ(€Á ¥IÁ*.ÏÁ4 Á?P7ÁJÏRÁVßæÁcDZÁoõVÁ|ÏSÁ„бÁŠÿÊÁ‘[Á–ðªÁ›?èÁŸ@Á¤6žÁ©êÁ®äÁ³B÷Á¸…ôÁ½ìiÁÃmAÁÉ­ÁÎ׋ÁÔÄ6ÁÝ·ÿÁ×…ÑÁÑròÁË‚0ÁÅ«Á¿Ü`Áº'kÁ´•óÁ¯gÁ©Ÿ;Á¤Y/ÁŸMVÁšvƒÁ•¬HÁ‘ÁÁŒ}†Á…éÛÁ~ÿHÁrІÁf&CÁY!ØÁLj0Á?ÚŽÁ3É Á(_¨Á¢åÁq—Á Z£ÁMBÀ÷ôÀë·íÀäüÀß‹÷ÀÞ·YÀàÀæSàÀî’AÀù¤UÁà=Á “Á*cÁb&Á*’Á5‹÷ÁAy4ÁMÐTÁZ‘`Ágc¬ÁsµÁ€9Á†nžÁŒ"ºÁn\Á”ǨÁ™KÛÁžÁ£Á¨1WÁ­vQÁ²ßgÁ¸WwÁ½õ%ÁýAÁɬ0ÁϼöÁØûiÁÒ±cÁÌ{}ÁÆd­ÁÀq¤Áº“åÁ´¿1Á¯ rÁ©[Á£þÏÁžŠÓÁ™NÁ”PƒÁ„PÁŠÄñÁ†KbÁ£CÁv/ýÁiE£Á\º²ÁP¨÷ÁD9uÁ7…¾Á+áÁ ÆÁÁ»Á )ÇÀþ³ÀìñÀÞ`ÀÒÚÀÉ~FÀÄì³ÀÃ&ÀÅòÂÀËÀBÀÔòšÀàÑ#Àð6ÏÁ² Á •.Á@¢Á ˆiÁ,EsÁ8¤ ÁER^ÁQéÑÁ]íÁjgñÁwvÁk Á…žaÁ‰ö¶ÁŽlÑÁ“ ¡Á˜FÁ»Á¢føÁ§ÒeÁ­F^Á²áZÁ¸©†Á¾šÆÁıÁÊÖ~ÁÔLsÁÍôÁÇ«‚ÁÁxÁ»^JÁµhÁ¯‚åÁ©¨ÃÁ£ö;Ážo Á˜íùÁ“ƒÁŽMÙÁ‰`?Á„•?ÁÊeÁwÑÁmºHÁ`‹ÂÁSª9ÁG bÁ:òâÁ/yÁ#Á¹ÐÁ ØÀÿÀê9 À×qÝÀÇ›Àºb›À°£À«/^À©jYÀ¬2^À²|ÀÀ¼¸iÀÊ5ÀÚ)‘À칌Áœ]Á ÓýÁ{Á#Û—Á0M¹Á3ÿÁ1šÁ%{°ÁÁÁ¼ÄÀî uÀ×òÝÀĤÀ²°ZÀ¤ÑÀ™À’ç¯À‘wÀ”fXÀ›]ÍÀ¦vÝÀ´¹˜ÀÆ=ÀÙ}ÝÀï†ÁL‘ÁnåÁœiÁ&èÁ2é´Á?OðÁL¤ÁX£Á``\Áhµ@Áqm³Áz®Á‚{Á‡ ÖÁŒJ Á‘¼†Á—=ÁœÓ²Á¢›Á¨‘Á®°kÁ´áÁ»ŠÁÁ\ÁËZÁÄß4Á¾gÁ·÷HÁ±¤’Á«u€Á¥fÁŸmùÁ™xÁ“–GÁæ|ÁˆV5Á‚טÁ{ ÁÁpðdÁgÍÁ]zEÁTŒ·ÁLúÁC]¤Á5íÝÁ(ð•ÁvaÁ_pÁUÀõ¥qÀß;ÀÈÒ¶À³¨À ¹oÀérÀ…E²À{Ú¡ÀwðÌÀ}öhÀ†‘ßÀ’x³À¢ðÀ´b<ÀÉxæÀßhJÀ÷(áÁxÁž@ÁšãÁ*pÁ6êèÁB–*ÁK,ÁSNÜÁ[Ã8Ádé Án_Áx%äÁEcÁ†¹àÁŒD'Á‘ÚÃÁ—¢ÒÁ›æÁ£ÀrÁ©ößÁ°.ÔÁ¶~˜Á¼í¯ÁÇ æÁÀs¾Á¹õØÁ³}ÿÁ­EÁ¦­­Á xÊÁšm†Á”vƒÁŽqÁˆœ€Á‚é¹Áz›:Áo£ÆÁe,ÛÁ[1uÁQHiÁGÐÁ?(%Á6ºÉÁ.ºÌÁ!);Á*ÁŸ¡À÷™_ÀáleÀÍÙÀ»†9À¥ëoÀ’*»ÀdºÀgì”ÀX“ÎÀS¹6ÀYÇ Àk@êÀ‚¥VÀ’îöÀ¥«BÀºm1ÀÐfDÀã§ÍÀùŠÁ¬VÁ ãÁ €¯Á,4(Á6Á>ÁFDXÁO(,ÁX©ÕÁbXïÁlžÁw~HÁL‹Á†â‡ÁŒ¬ÃÁ’«ƒÁ˜×þÁŸÁ¥MŠÁ«©_Á²$¶Á¸¼?ÁÂøjÁ¼;·Áµ™DÁ¯Á¨9Á¢&Á›Ã’Á•ˆGÁusÁ‰|Áƒ†ÅÁ{H™Áoå\Ád•ŒÁY§dÁO\–ÁE^‚Á;†CÁ2YDÁ)ËTÁ!}ÿÁø(Á ÷nÀÿ£ëÀæË)ÀÏãªÀºÊžÀ¨ÏÍÀšÍ+À‡H¿Àk—ÀOÖVÀ=q”À9 ºÀ?uÀR4¬Àl »ÀƒR²À•|¨À¨Ž"À¼59ÀÑRñÀçF_Àþ'~Á (#ÁäíÁ!ÎÁ(¾UÁ0ûlÁ9”©ÁCyÁL¬<ÁVÕžÁa“/ÁlªXÁwÔ”Á·Á‡¼dÁïnÁ”*ÐÁšpqÁ ÙÍÁ§c©Á® ]Á´¾™Á¿fÁ¸CëÁ±{ƒÁªÎÁ¤>êÁÈtÁ—S’Áé%ÁФèÁ„‚yÁ}HÁq1ÁeXrÁYø/ÁN§ËÁCÎöÁ9†0Á/}GÁ%íÅÁìYÁpÁ }îÁŒ Àñ®=ÀÙùÀÀ}kÀªyàÀ—bèÀ‚Å#À^PçÀ9˜÷À­NÀ m6À )8À ?7Àm¯À1~áÀSNxÀy ÐÀJ©À¥LMÀº×?ÀÑ…žÀçÖ¥ÀÿEòÁ ÖçÁ¬¶Á¼PÁ$BEÁ-fÇÁ7ÁAIÁKµ§ÁV¼gÁaòÁmŒ®Áy¡¿Áƒ Á‰J Á™cÁ–Áœ«1Á£^EÁªóÁ°Ê˜Á»I@Á´qnÁ­qÁ¦Í;Á eÁ™zèÁ’û@ÁŒ†PÁ†ŽÁ–ýÁs-ÁgØÁ[3iÁOqÁDrÁ8ÕõÁ.úÁ#ºùÁ°`Áw"Á…DÀþ©qÀïÀÜVOÀÅnÀ® xÀ—r@À:ÀVŽGÀ, CÀJ¿ÆÈ¿—Þ¿“*ο˜Ás¿½ðŸ¿ö÷ÊÀ!uÀHó ÀrÂÀޝ¿À¤ìïÀ»¢DÀÒÎîÀë©Àý]rÁ”àÁ BÁü`Á!bTÁ+a}Á5ëIÁ@ÎvÁL«ÁWÑLÁcíÓÁpl:Á|ôuÁ„ÓåÁ‹VÁ‘þ2Á˜µæÁŸnDÁ¦.õÁ­ ðÁ·žòÁ°ªÁ©ÌsÁ¢ùÃÁœ'4Á•bZÁ޾ Áˆ7hÁ¹Áv§MÁiûÀÁ]lÁQMnÁElüÁ9¬ÄÁ.IÁ#wÁa•Á ÿ¼Á#cÀö3Àäi†ÀÔŸ±ÀĦÀ¯‰ìÀ˜^žÀoÀUÇÀ)ž÷¿ü2f¿¥ÄJ¿0æO¾_Q¾0•¾H#Ä¿÷¿”1¶¿ãüúÀ9ÀE¡VÀq$À#À¦o%À¾ sÀÓC[Àã`Àó´ÁšðÁ àÁª€Á 0Á*ëËÁ6Y ÁB6éÁN\ÁZѲÁgjlÁtIÁ€´˜Á‡g”ÁŽ#Á”ÞëÁ›ª•Á¢’QÁ©Ž]Á´7‡Á­$ Á¦äÁŸ2¨Á˜YÁ‘ƒ†ÁŠ´ðÁ„JÁzïÿÁmë±ÁaðÁT`ÀÁGÔ÷Á;£ÚÁ/®&Á#î[Á…~Á :Á³}ÀðÁ²ÀÝŽ·ÀË1”Àº4NÀ©ö`À˜– À‚¿ÒÀW¢4À)Ó¿úŽ=¿¢"¿“-=ºH?+¨?X©??=y>I„}¾ØŠú¿‡Ú§¿ÜíÀ+àÀFñÀtxðÀ’(NÀ¨ÁËÀ¸ÁªÀÉnÀÚåÀí oÁ-«Á ›Á>±Á ¨³Á,²Á8ÑÁE8âÁQþÁ_èÁlaÏÁyØUÁƒ©tÁŠjÓÁ‘DÝÁ˜9rÁŸ7¿Á¦6 Á°å­Á©ÈUÁ¢µ2Á›¤SÁ”¤•Á¿Á†æÎÁ€cÁr ^Áet}ÁX}kÁK‡¥Á>ÃzÁ2I«Á&%Áù(Á0­ÁÊÀï,îÀÚ-<ÀÅ—À²Î À ”˜Àÿ8À}:>ÀVù"À+ë¿ý`¿¢‘(¿Áò=éåÈ?LÛ8?½†?ì4…?ÉR ?nR>—qO¾·f°¿„#¢¿Ý€À<èÀK`QÀymÀŽ?-ÀžöLÀ°CÀªÀÕ¾ýÀê PÀÿ¾ëÁ 9)Á>ŽÁ#TaÁ/¸Á<¹\ÁJ­ÁWyüÁdîÁrj¿Á€ œÁ†ûÒÁúÁ”øµÁ›öÛÁ¢ÿ9Á­ÃnÁ¦†¤ÁŸ\;Á˜EÁ‘4)ÁŠ%»Áƒ-GÁx¡ºÁjöÁ]ilÁPíÁCéÁ6»Á)0öÁ¸WÁ}ÁUïÀð÷üÀÚ"ñÀÃúÀ®øOÀš‰ÔÀ‡âÀkø¿ÀHw¯À$Œ¿ù@¿¤¯-¿,’=æ)f?Mi?¾Èh@ éA@6S@í+?ÒëÓ?ƒ4>©gó¾±tÜ¿‡Å8¿ã0ÀnÀF HÀhoÀ…ĪÀ—ÙÀ«1ÐÀ¿ÛúÀÕ.óÀëé’ÁìÁ ÁšªÁ'´7Á5"ÁB•ÁPÁ]¡}Ák€ÆÁy~MÁƒ½ëÁмaÁ‘ÂÁ˜ÖÖÁŸìÁªÚÂÁ£Š¶Áœ=)Á”ÿÆÁÖûÁ†Â”ÁlyÁqeEÁc%ÁUÎÊÁHE›Á:ÑÁ- Á ­eÁÀÐÁ5Àõ”ÖÀÝ{$ÀŦpÀ®ß~À˜ÀøÀƒ±šÀ_À9†ýÀ¹)¿âyc¿–å¿w=õ1Ì?Q ?¿Æ3@ |@7t@@d“@?ö<@–ì?Úê/?„XÛ>¨>o¾¼Òà¿ÜúÆÀ˜[À6*SÀZ<=À€ï-À•2<Àª£ÀÁl"ÀÙNÀñ”ÕÁŸhÁëÁ IµÁ-½\Á;UðÁICÁWÁe £Ás FÁ€‡Á‡ Áޏ3Á•ÓfÁœócÁ¨ÐÁ ªûÁ™W¿Á’óÁŠ·Áƒy.Áx¦6ÁjˆœÁ\±ÁN|®Á@©Á3SÁ%”&ÁAEÁ 77Àü©úÀã^!ÀÊO!À² iÀšMèÀƒ\BÀZœÀ0ÃZÀ µ¿Åã6¿wù_¾Ê*Ò>d\m?`óà?ÃT‘@\ï@9vE@dV­@‡Ü@o» @EÈ”@lß?ÜÑ?„¯n>¤sᄀÀ¿kt­¿¿ãÓÀ÷3À,0ÚÀU†ÉÀ€UŒÀ—]zÀ¯"áÀǤ#Àá«ÌÀüP,Á |œÁ!Á&çsÁ4±KÁB¨*ÁP®ÚÁ^¹úÁlØÁ{¼Á„¥1Á‹ÅÁ’õ]Áš&UÁ¥lœÁù5Á–ŽãÁ4tÁ‡ÛUÁ€]ÁrdbÁc÷ÒÁU´‚ÁG„ŸÁ9yÁ+‘Áâ–ÁL{Áì)Àë‚„ÀÑ¢ŽÀ¸*ÀŸýÀ†¸€À]öÆÀ/žåÀ7²¿µy¿IʾC…·>Ïõº?€1?Ï7¬@bj@;Ãü@h®@‰…6@žÝ@"@s%†@H8Q@IÌ?ÝA‡?Œ2f>ìc×¾ †¿;3 ¿¬3nÀ¢òÀ+ò ÀZ[ŸÀ…‘˜Àž€OÀ¸[ùÀÓ—ÀîÁ¹AÁ€Á TÁ.\YÁ¼Q´?“ÄH?ö«@+Ì@XOY@ëÇ@–XE@ªÏ@¿y÷@Óž“@èWv@ý3è@ì}@×@Â&ý@­L½@˜µË@ƒzä@ZBª@*îT?ò¯P?‰xÍ>t6ª¿à§¿¼)ÀE”ÀLÃïÀ‚‘CÀžïÀÀ»~ÆÀØRÀõ Á &ýÁÅëÁ&a\Á5ìÁCÒ~ÁR»“Áa¥ÁpŽºÁkìÁ‡.îÁŽ©ŒÁšXÁ’§wÁŠÿÍÁƒb:Áw"Áh]ÁY+¯ÁIýVÁ:é‚Á+üôÁèÁ6ïÀþ°ñÀáTÄÀÄ"cÀ¦ð~ÀŠ&RÀ[z—À"ô»¿×/³¿QîÈ<×ÑT?]ж?×|í@qÇ@Q¼Œ@n@˜Š@­ãá@ÂÇÉ@×@ìiêAM[A Ä·Ag@ï<Ê@Ú !@Å8“@¯¦û@˜Ôz@€ÊJ@N$R@ã'?ÅÜ"?/üK¾1Cš¿…þL¿öh"À40xÀmæÀ“K:À°v‰ÀÍ¢LÀë!–Áo“Á!NÁ!ññÁ0õûÁ@ÁOÁ]ë®Álá“Á{ò Á……¡ÁØÁ˜ÒÁ‘‚Á‰TyÁðÁsá¼ÁdžXÁUhÞÁF3—Á6þmÁ'É¿Á°Á ¹uÀõŠSÀ×½}Àº‚ÀœÏ.ÀA<ÀDí®À ’I¿¥»G¾Ô_î>éÐà?¨Pd@ œ¡@?ú]@t{…@“ì³@¬¡k@Ãó±@Úˆ@ïUAA5–A ¬îAÕ|A)LApÒ@ñ¶@Ûáó@Ä®¥@¬ @‘¼@mRþ@6f0?þƒÕ?ŽX>s~ë¿%]:¿Å,PÀÛ‰ÀWF¶Àˆ½õÀ¦YÀÄVvÀânÀÿùwÁçÁM@Á-t8Á<›ÒÁK¿óÁZØ ÁiôeÁy*Á„ Á‹§,Á—|œÁµ9Á‡î^Á€("ÁpÇ„ÁaNÁQæÞÁB?Á3N'Á$…ÁàãÁ­¼Àí RÀϪÀ±§À“9'Àk4À0|P¿ìoÅ¿oãG½9Ö¯?X¯[?ÜúÂ@&’£@]‚Ý@Št@¤ÃŸ@¾Ù @Ø»@ðôABA ñbA›õA#%£AêA*öA(@ð^@ÖÙÙ@»ü©@ Û¢@…8›@SÖ@5ê?ÂkH?"Ð¾Ž¢t¿™¶ÀAÄÀCvëÀÇpÀ¾ËÀ»ð‹ÀÚ‰Àù+°Á ÓÄÁ XÁ*RmÁ9£êÁHþ$ÁX@BÁgd·ÁvüÁ‚çÁŠ‹Á–_ÁŽ’Á†ÄµÁ}ô=Án_}Á^ËMÁOBƒÁ?ÆKÁ0J¤Á ÏŸÁašÁÁÀåš5ÀÇGýÀ¨õÅÀŠª…ÀY% À´2¿Ä‡¿ä5>™Oè?šÉ„@ð`@@#;@x®@˜r„@´‹@Ï6ú@éãAÕAµAoA$8rA/ÒA%‡A,ûA©AÔê@æ]–@Êð@¯Wç@“.“@m{@3œ‘?òz?xsn=%à ¿g¸]¿íÀÀ3+hÀp¿+À—"œÀµÜ2ÀÔ•ÇÀóbCÁ (ÄÁž Á(Á7lªÁFÂÐÁVsÁejÁt»ÍÁ‚ÊÁ‰¬KÁ’èÁ‹¹JÁ„¢zÁ{O\Ál=UÁ\ŽEÁLæ›Á=LPÁ-¼“Á6ßÁ´›ÀþhCÀß„×ÀÀ¢ÍÀ¡½µÀƒ¥ÀIUlÀ ç,¿ ñ×¾¡Oµ?‚)?Ä×3@Jn@W’&@ˆ¿|@¥g±@ÁÑv@Ýï9@ùŠyA ]ÖA¤A$ 3A/¢@A:ŠA0G¤A#Ê5A+„Ae#@õ @Ù@¼Gá@ŸV@‚“@H¿â@ !3?ž—>‹¿+´™¿Ñ—´À&ÐbÀdñ«À‘ŽÀ°£¤ÀϽÀîË´Áï¾Á{¢Á&÷Á5—]ÁE ÜÁTxLÁcãÁs;æÁPhÁ‰ÁÊŠÁˆu%Á0{Át‹ÁeãÏÁX³ÁJrëÁ; (Á+îFÁD…Á šÍÀùâ+ÀÚ‰ À»HÖÀœ4§Àz’ýÀ<ØF¿þ‡ô¿ƒWP½‚»—?a2½?é\Ù@1@l:Â@“³Õ@°ð‚@Î%§@êôòA¼wAÈA¯ A-7oA:JAEçÏA9!vA+_—A~ðAh‚A:@åU@Çr@©~=@ŠÄ$@X&@¸ä?¶.ø>ã°¢¿Ùî¿ÀC.À–KÀ]tËÀŽ)»À­™ÀÌäMÀìtÁ«NÁAÁ$Þ‹Á4{½ÁCõûÁS`RÁbÓ©ÁrMñÁ€äþÁˆ^ÇÁŒáŽÁ…w†Á|=àÁm˜dÁ_ ×ÁP¹†ÁB§ãÁ4äƒÁ'bWÁ8ÖÁ ÕÀöÄÓÀ×lÀ¸£À˜Ã–ÀráÀ4:ý¿ëG¿\=ï“U?ŠQr@¹ˆ@@Ce@}hÎ@œÖ‚@ºù@Ø™¿@ö)ÕA ƾAL-A&ªFA4¹¨AB›LANm‚A@ŒPA2ƒOA$6³AQDAÈ@í¿@ͳÍ@®N»@ŽÝ™@^Œ…@]Ø?À^U?_J¾ïGп¹ÓÀÊÀZ™ŸÀŒ´ÂÀ¬8ÿÀË«œÀë§Á+ÙÁÃÁ$U¦Á3é@ÁBÜ\ÁPÛ<Á^õrÁm> Á{¤Á…@ÁŠ[UÁ‚̱Áv˜¶Ágº6ÁXüÁJXÁ;á@Á-žqÁ ÁâaÁ£jÀïÙ‘ÀÕ@ÀµáàÀ–YUÀmðmÀ/>ݿឿGc>M¤º?–Ûr@ @H†±@ƒò@¢¼‹@ÁêJ@àÜ2@ÿiœAÀ A‡ØA, A9LAFÁ£AJ™›A<ŽæA.¹/A VACôAÿŽ@ë„Ú@Ì®î@­zˆ@Ž^@]pe@l]?¾‹?z¡¾õº„¿»ØÀRÉÀ[BÎÀŒæÀ¬GÀ˼ˆÀë>ZÁ>ÁvÁKÁ-x)Á;„ËÁIÑ_ÁX;gÁfÔœÁušˆÁ‚BEÁˆ+«Á€‰ÝÁqÝ|Áb±˜ÁS¢ÏÁD¸)Á5áÇÁ'8_ÁÓÂÁ ¼Àù‘PÀÞ§nÀÅCðÀ­©BÀ–äÀmeÀ.˜¿ß˜2¿DZ;>XQ?˜‚ó@ çÎ@I[›@ƒç´@£¸@ÁÑ÷@àn @ý¢A ØìA´uA(gA6)ACõÜAG4òA8ÖA)œeA»A l@ûdm@Þ]+@Á¡ú@¥q—@ˆ¼¯@T;ü@ƒ!?±¦T>ÐÑÌ¿xö¿Æ›À!~]À_ó‘Àb”À®ÔÀŃÀÞÁ™Àù¹Á F°Á<†Á&€ªÁ4÷èÁC”ÅÁReUÁa[0ÁpPÀÁP¨Á†SÎÁ}+*ÁmÀ'Á^j0ÁO-òÁ@×Á1Á!þøÁÁrZÀìMYÀЋjÀµOÈÀ›Â1À„yŒÀ_ö!À1J>¿åÔÝ¿R*z>[[?ŽN@¿@CÆû@€K0@ž²â@¼uÙ@ÙQ§@õ‚AÍAß*A$õ+A3;-AAˆ‘ACÀ£A4£æA%VA FAÙ @ï£J@Òô@´Ò@—®i@vç³@?ö@}Á?•÷1>oK¿;2¿×óuÀ)5À^• Àƒâ¦À›XÀ´.ßÀÎò÷Àê‚;ÁlÁïÆÁ ½Á/k&Á>géÁMT!Á\b¥Ák€¸Áz¡ÓÁ„ð×Áz9QÁjœÈÁ[›ÁK’Á<+ŠÁ,àåÁº>Á½ëÀÿŒäÀáÙ²ÀÄÊoÀ¨ÌRÀŽÅÀiÌ©À<ÉÀ h¿ñì¿ošG<¥Oô?z]?øBì@8Ô¸@t>@—¦@´f @Ñ6º@íé—AO‰AÄÕA"v:A1/(A?æíA@fæA0àêA!i·A ˜A½ö@æÊA@ÇÿU@©wq@‹‹l@\z@"uÕ?Ösq?Nݽ•©¿}ß`¿óç=À°À7ZÀd¯›À‹NÀ¥èÀÁ´ˆÀÞ¢8ÀûôÔÁ ÖÍÁ¼’Á*«&Á9¯”ÁH¾sÁWðÁg=nÁv˜ÂÁƒóÉÁx.8Áh}*ÁXÑ’ÁI,SÁ9’äÁ* „ÁžóÁ RmÀø_°ÀÚ9¾À¼ZÀŸÇzÀ„A®ÀSo“À#üÑ¿üÉ1¿×PÜ¿Š£¹¾„i?KÄ“?ÜœE@*²@eç@@¬Ï•@ÉÞý@æýàAX&Ad¨A oQA/V2A>7ÁA> ßA.E"A„[AÎ.@þM@ß'@À>o@¡}@‚µ€@GÓ@ rÛ? T>¼í¾ý'¹¿­âã¿´BK¿âçtÀ¿ÀHêªÀ~6ÒÀšïÀ·îàÀÕC>Àó'ÜÁqšÁS¨Á&jÏÁ5©ÓÁE¸ÁTkzÁcÕÖÁs=<Áƒ#\Áv×2ÁgÁWXîÁG¥TÁ7þäÁ(iKÁé­Á ‡yÀôÈÀÖS]À¸@2ÀšÀ~À|Æ)ÀHÆÀ$¿ç·Œ¿Ä6y¿¥â¾ºÜÝ?¥ ?¿b¥@œÏ@UÞø@ˆÝ,@¦"Ù@ÃÙd@â'AY-AžÓA½zA-à¸A=ËA<ð¾A-9AìA 5A@úŸ­@ÚÛO@»%8@›`@x,[@9U6?õi’?s(Ì»ñ»Ó¿m¶¿¦¾;¿œù ¿¿Œ2ÀϸÀ7(ñÀmغÀ“hãÀ°ªöÀÎ&Àë¡<ÁÛ¦ÁÁ#sêÁ2¶ÁB &ÁQtÁ`ß±ÁpVxÁʈÁtëÁf¿ÁVsÁFÙ Á74¶Á' ÿÁ#ÃÁÄ¥Àó)ÀÕåÀ·2ÀšpÀ|lÀI7À`[¿òÿœ¿ÒÏοÄ]D¿¨$>§i? ÷Í@ d¾@JlE@ƒIþ@¡Ž§@ÀX¡@ßpÖ@þº¡AÁŽA†A-a“A<ÏA<ßA,îUAþA @ú30@ÚNH@ºi_@š„v@u?@5vú?ë™Ó?Y¼P¾ –R¿ß~¿Æ½¿¨L@¿¾RÀÈ À0¢ÌÀf_ÀãÀ«»'ÀÉDÞÀçKÁ 'ÁÄšÁ!ëÁ0e²Á?´oÁO±Á^yvÁmóÌÁ€Ý©ÁspÁd}ÁUZEÁFIÁ6ÏíÁ'„ÄÁ:-Á tÀóüÀÖ´À¸ÔVÀœ£ïÀþãÀRÿ°À) À ùe¿ú)s¿ãD±¿TêÎ=ô\?‰„@ë@@nf@;[@Ÿ?@¾}ë@Ýú÷@ýxAf€Aø©A-…ÉA=2A<Á+A,âA5A !ó@útÇ@Ú®‡@ºõ®@›EÝ@w,@7Ìy?ðÙ°?d4Û½ÊMD¿Š«Q¿ò;a¿Í Q¿Ö‘­ÀÌ}À4 pÀek–ÀéRÀª-UÀÇpÀÀäîŽÁnÑÁj«Áˆ´Á.¹nÁ>çÁM[¨Á\ÌœÁkË^Á€[ïÁqÿÁÁcsñÁTƒÁEN¬Á6ALÁ'^ÁŒÁ žçÀõØAÀÙåÀ¼Ñ«À¡ØÀˆ=)ÀbâµÀ=œÀ"·Àšd¿ý1Ó¿€±¼5/8?zwé?û7„@2íA?e8A/‹1A´8AÝÁAI@à`¹@À© @ ñ[@4y@BÜ@O4?‡„«=†®Û¿mH¿õFHÀ$;À"Ú›À4“åÀR†™À{‹·À•²-À®æÝÀÉìlÀæ/QÁoÁ ”ÁÆôÁ-ˆíÁ<{SÁK– ÁZÆ:Áj¥Á€Ö¬ÁsÁdeÁUU–ÁFk¸Á7­WÁ(þsÁŽÁ lÍÀü÷ãÀârÀÈŠüÀ°`lÀš¾¦Àˆ;PÀr¸}À`ÔÀD&DÀQ:¿ˆøa½”äÎ?l·Ž?öÛ@:×ø@z­@BF@½1ò@Ý!©@ý`A€ŒAxgA.pqA>h“A?ºÞA0äuA ý¡AÍA/ø@â’H@ÂÄã@¢ú9@ƒ3c@FÙç@Rpå¿^ðš¿îþ¶À7BÀG LÀR 'Àl£À‡ÐïÀšVÀµÀÏxíÀê€Á+Á:TÁ›•Á.4“Á<øÆÁKæõÁZö•ÁjªÁ¾íÁt€ãÁeƒyÁV›ÿÁGßËÁ9XÏÁ*þ<ÁãuÁÁ¬5Àé×ÀÑsÀ»O°À§‹À–†æÀ‰¡ ÀÕÎÀF‹¹ÀÃô¿øÚ½æœ¨?bJ‰?ð´T@8!²@wé9@›Ø`@»³ã@Û\÷@û§A fÁAAùA-œA<³5¤ÁLðuÁ[ØÁjä4Á‚ÊÁv.ŽÁgd»ÁX²IÁJ Á;ÄÁ-³ÇÁý®Áž²ÁÆUÀóšÀÜg]ÀÇÅÒÀµ(ÆÀ¥é À››À…tzÀK2À „‘¿˜]M¾O!?I*?ã5@0é„@p'È@—»_@·KÆ@Öw%@õ¥ñA q‘Aÿ„A)R–A/ðA,& A!aÚAcÞA|W@ð— @Ó¥@µóÀ@˜I@t¢@6ëÈ?ñ@µ?j@A½Ù—¿‚XðÀQXÀ?v8À~DÀªmÀ–Ï-À£à¬ÀµfÀÉ¿ŠÀà°ºÀùUÁ jßÁ”œÁ$0ÃÁ2+Á@m¨ÁNí¡Á]¢CÁlv¯ÁƒÃGÁxÐSÁj>TÁ[Õ>ÁM“Á?~LÁ1¹¢Á$\’Á‚UÁ CðÀÿ8eÀér¨ÀÕÛ‹ÀÅÇÀ·gÄÀ©³À‰i•ÀS–ïÀIÈ¿©íN¾­0?#·y?Ή7@%›Y@cò@‘$¥@°;è@Îã.@튇A×tApÌAõA>AݯAôA Óç@ü‚G@á–@ÅŒ@©*í@Œk@]ó@"cC?ÍÖ3?)-쾓•U¿¡tÀÀK‡À„k(À¢-àÀª!ÀµXƒÀÄ£qÀÖüjÀìBÓÁß%Á:ÁÞÞÁ( ËÁ5¢ÜÁCŒ‰ÁQ±äÁ`Án ¯Á…NµÁ|Ám¾Á_ž§ÁQ®NÁCôLÁ6•TÁ)«ÁK8Á€ÿÁs>ÀøDÑÀå÷gÀÖdrÀÊ~LÀ­ øÀŽ]èÀ^eÀ T¿Ão.¿ ƒe>ׯ"?²F©@n¿@Sº)@ˆ‚Í@¦èþ@ÄtÚ@áh5@ü›HA "áA rxAsA KåA~l@ÿÛ@艠@ÏÚm@µ£@šdf@|@à@C}æ@ ›?žæ³>¢]¿pK¿Æ ÜÀ†À\LÁÀŒÈhÀ«OžÀ¾/ûÀÈÑXÀÖ0ÍÀç&.Àú²¹Á4ÎÁÿëÁ ?SÁ,àËÁ9÷IÁGx¼ÁUR”Áct«ÁqÒWÁ‡=ØÁ€ÔÁr`Ád=NÁV°«ÁImçÁÍ™?ŽP‡@Í@?_@z;@™á@µ´@ÏþN@æ½N@ô@ûf„@þC€@û_x@ó1›@åi@Ñׯ@»b³@£"@‰X{@\â¿@&+æ?ÚéÔ?S ɽ‡GÜ¿z‘¿ó—øÀ4ó²Àp™À–…ûÀ´¬eÀÒáÀÝB\Àéè«Àøú„Á‚öÁÀìÁë¶Á&˜îÁ2µÁ?cªÁL‰…ÁZ[ÁgåPÁu÷1Á‰‡£Á‚ˆ¯ÁwQŠÁiЬÁ\.ÁO‰ÁCèÁ7 Á+£KÁ ÊgÁºÙÁ ®Á§1ÀùÇÛÀÚìØÀ¼+ÀK©À}KàÀ@vÀÈü¾%ï?C°»?ÖMÇ@$³4@\˜@‰KS@¢äÞ@¹ðq@Êß™@ÕK¸@ÛÍ™@ÞP@Û¼P@Ô¥V@Éœ’@¸ù°@¤¬°@Ž0v@lHÚ@9aA@ü²?œþ¨>»|¿ôÏ¿³Ó×ÀšÀMEâÀƒòÀ¡…©À¿*UÀÝJGÀó.fÀþsÉÁCÏÁ˜%Á'½Á"­ÊÁ-ÞÍÁ9ƒ¢ÁE¯3ÁR^6Á_zLÁlñ[Áz­ÌÁŒ0æÁ…WÁ}'¥Áoç ÁbóXÁVa>ÁJKGÁ>É Á3ê—Á)‚xÁÿ)Á”cÁQÿÁUÀ㔘ÀÄô,À¦†²ÀˆdÐÀT?À¡h¿»$Ô¿´ä>¬ø¸?›¦C@ ê@9\É@kg@ŒÃB@ŸŸ³@­@w@¶L×@¼/‚@¾\³@¼…@¶b@¬Xr@žVŠ@ŒZ@o6@Aâ@ ?À#?1us¾kŽ¿3Î¿î¥ À/ïRÀhœ ÀýzÀ®ÀË18Àè“áÁøÁ \lÁ´~ÁwÁ!l%Á+;Á5â ÁA»ÁL¾:ÁYºÁe¾ÍÁrÓ–Á€ÒÁ'+ÁˆhÁÍ2Áv¹=Áj:™Á^&ÁR‡‚ÁGtÁ<ÜJÁ3¶Á*3ÕÁ"_ÍÁSÁÖdÀ튗ÀÏtgÀ±^ÇÀ“ˆèÀlŽöÀ3V¿òê ¿îª¾ؽ?/ÛN?ÀEÖ@<@?,$@f½0@ƒyq@ŽðÊ@—S†@œ‘k@žiL@œbø@–ã@Ž)ª@‚Wó@dCø@>j @’»?ÎÆy?_dþ=×äl¿3É`¿Â™ŒÀ² ÀNžÀƒ GÀŸQPÀ»§ÀØm¨ÀõƒLÁ LxÁü-Á¶Á#NÁ+ŽÕÁ4ËIÁ>åûÁI„!ÁTÅâÁ`›,Álá¸Áy†FÁƒD4Á’eÁ‹ÕÐÁ…k±Á~XÁr>5ÁfžÁ[oÌÁP³hÁFž”Á=U`Á4üîÁ)X0ÁC4Á 1iÀøtÁÀÚØÀ½ÐáÀ¡ ¹À„D‘ÀOÃ;Àˆ¿Ãž¿5 )=×ï©?Z‘%?É£‹@ ß}@0IW@Kò&@`ï @o±@@yæ¨@|ëÌ@ynÖ@oc¦@_EX@JB,@.Û]@ ÚÝ?ÉJ»?hZM>NFD¿ z6¿¦+ÀB À9ñÉÀo—!À’üÚÀ®EÀÊmKÀæ²èÁ~4ÁÓÁVÁ'ÞÌÁ.‡ÌÁ6A÷Á>æ4ÁHcTÁRªÁ]ðÁhñ\ÁtºÁ€{®Á†ÌÏÁ•ôêÁ‘rÁ‰WÇÁƒO\ÁzûÁo©µÁdÊñÁZÝÁQ 5ÁHRqÁ=¨‹Á.³JÁ×ÿÁbÁ¦ŠÀè”ÈÀËΠÀ¯XþÀ“©<Àp —À:¨ÿÀ|迦Ee¿ò¨>'vi?R‚ä?±ºë?ïáÙ@Co@"ñL@0´e@:ªz@=ÿ@:½@1@"7\@X$?ìð€?¬ï1?H9>&Ô¿–T¿›4è¿ù,µÀ,úºÀ_‘ÁÀ‰¢øÀ£µÀ¾í°ÀÚ °Àõ˜]Áç¨ÁûÒÁ%!sÁ3fÁ:]šÁA…ÁIŸEÁR ßÁ\mòÁfì@ÁqÕÀÁ}4qÁ„†ÒÁЍÓÁ™ÒHÁ“¡:Á—…Á‡¿{Á‚ÁyDEÁnÚEÁe¾Á\›ÁRLSÁC|‡Á4δÁ&[›Áÿ}Á œÒÀöÉÙÀÛwÀ¿]À¤%FÀ‰ñoÀ_·,À-¿ü;:¿ŸÅñ¿v·s¡Ÿ?M$?t—U?§ K?Éñz?ãvh?õ¦,?úµb‹?/ß?JôÊ?k߃?tÝ”?jvü?MÏo?Å>ª ±<¦¨%¾½íâ¿]Ê¿´óiÀ{À*KøÀU]åÀLÀ˜zœÀ°²§ÀÉEÀâò­Àü²WÁ iÁõWÁ&”ÊÁ48¥ÁB%ÁP"×ÁY¯ÜÁ`é„Ái\ÁqæáÁ{~µÁ‚ÎîÁˆKÁÁ“^ãÁ¢`ÍÁœ†Á–ÍÖÁ‘LÂÁŒ$Á†ýÓÁ‚9:Á{‘vÁmÅ¿Á_e™ÁPýÁBÁóÁ4Ï¢Á'4Á4fÁ »øÀý/Àã+LÀÉwáÀ± tÀ™_ÈÀ‚SiÀZaÀ1¿AÀ ß÷¿ÛE‹¿£L÷¿gúƒ¿Ü[¾»T6¾H‡å½œj½,н¦Øƒ¾<¢¾¿Šn¿'•¿jù`¿¤Sš¿Ü‹RÀ«·À3ËBÀ[?½À‚QÀ—íÀ®‹~ÀÅ~sÀÝÎŽÀö/åÁÍDÁ®«Á!—KÁ.çfÁ<{çÁJ¶ÁWÒBÁe´ŠÁm))ÁtÛÁ}T5Áƒ@™ÁˆÁ0ÓÁ’‡wÁ˜èÁ§þÁ¡NIÁ›ÃÁ–pjÁ‘\¬ÁŒ‹áÁ‡ü´ÁŠŽÁt®¡ÁfqÿÁXr}ÁJ¯œÁ<ÙZÁ/;iÁ!ó»ÁãYÁçÀön…ÀÞPíÀƇNÀ¯ŠÀš6`À… Àf½©ÀD“À&À §7¿í®‘¿Éi±¿¬Îÿ—œ^¿‰ƒU¿…Dý¿ŠŽ¿–Bv¿¬§º¿ÉØ4¿ïu€À áþÀ&_UÀEV ÀhCÀ†ÎÎÀš…¦À¯|&ÀÅ+ÀÛÊêÀòŽIÁhÁ•fÁÆÁ*ýIÁ7àƒÁD÷«ÁRfÁ_÷RÁmšÁyÕÁ€“Á„XÁ‰ÞÁ«µÁ’ŽSÁ—´©Á Á«ã'Á¦UÙÁ öõÁ›ÑßÁ–ì~Á’LúÁŒ/íÁ…BÁ|“ÁnKãÁ`ƒ=ÁRÌÄÁEdìÁ81áÁ+/0ÁEcÁ¼ÐÁÀ´Àó¯óÀÜÃOÀÇcÀ²ÀŸÍ®Àë÷À|˜ÔÀ`rÍÀGáwÀ3°À"¢WÀd<À ÁÀ²äÀ”ùÀßÊÀ xUÀè À"÷åÀ4½,ÀHÁ^À`_ÉÀ},†À޵¡À „]À³À³ÀÇ‹qÀܧ<Àòi/Á~ÁÒ>ÁácÁ(ÉÁ4icÁA;ÎÁN%½Á[6Áhd‹ÁußïÁ·„Á†êHÁŠÅ`ÁŽøÁ“iÁ˜#?Á&Á¢TÁ°ðÊÁ«—1Á¦b÷Á¡fŒÁœ¨Á–é«Áá©ÁˆôÁ‚[ÁvhHÁhá Á[œŸÁNxKÁA{/Á4³ˆÁ(HÁXðÁo’Áÿ:Àô¿Àß…©ÀÌ<âÀºJ¡À©ªöÀšºÀ¹ÄÀ‚-qÀpŸZÀ`ÀSÿFÀJMïÀD¤wÀB‡sÀD´MÀIÏ•ÀSÄ3ÀaUÀqË'À‚mÀ’pÀš¡éÀªÀºçƒÀÍ 1Àà¥Àô¦ÆÁé(ÁÓ¢Á1Á&_:Á2Z¿Á>½ÁJÈßÁWzXÁddBÁqFÁ~møÁ…íñÁŒ¤tÁ‘3Á• Á™N&ÁÛ°Á¢­`Á§½WÁ¶4Á±ÿÁ«ójÁ§€Á¡·mÁšÃÑÁ“ä~Á¸Á†1åÁ MÁqÕÁdôÁWÑèÁK,ŒÁ>Ø!Á2ñ-Á' ‘ÁSÁÞ÷ÁJ¥ÀøÔ³À潋ÀÕ$ÀÅÇqÀ·¢ À«:À ™ÛÀ—.À[ûÀ‰gÀ„ÅÀ‚KÀ<÷À‚DhÀ„¨À‰P#À£!À—n¨À èžÀ«wyÀ·VºÀÆ ²ÀÕÄ‚Àç?DÀù­©ÁÅDÁæÊÁ~³Á&r¬Á1¡âÁ<ílÁHÔÁU ¥Áa1fÁmÀàÁz¢ÈÁƒÀ4ÁŠD%ÁíüÁ—Á›IÑÁŸb:Á£Ä†Á¨jòÁ­PÁ»©ºÁ¶—ŸÁ±±†Á¬‰Á¥ ÃÁžÇÁ—ñëÁ‘2ˆÁŠ’nÁ„‘Á{‹Án6MÁaªÁUjwÁI†{Á=¥Á2;ÀÁ'uÁÙ.ÁÍjÁ –2Á™QÀñ ^Àâ5ÀÕÀɵÀ¿EÀ¶(SÀ®Á”À¨þ)À¤d™À¢CÏÀ¡64À¢.ªÀ¤~DÀ¨¾,À®ÔhÀ¶IõÀ¿fÒÀÉhÀÔ¶¼ÀâÀÀñ‡‹ÁåÁ åðÁ;øÁ9­Á'|TÁ2OÁ=ÆÁH3“ÁS|pÁ_R2Ák†Áw ‚Á‚ ÂÁˆp¦ÁŽàãÁ•WâÁ›å¹Á¡°8Á¥ #Á©Ù6Á®V!Á³ËÁÁJïÁ¼YªÁ·ZÁ°}©Á©®èÁ¢ëÁœ9=Á•£ÑÁ!ÓÁˆ±Á‚RmÁx, ÁkþºÁ`>ÁTA®ÁHÚdÁ> Á3kçÁ)>;ÁͦÁÍJÁ8½Á—!Àÿ ûÀò}ŒÀç<öÀÝu%ÀÕ¶ÀÎ@ÀÈ—ƒÀÄRÀÂ<™ÀÁ/qÀÂëÀÄ_ÖÀÈ0eÀÎ3ÀÕR-ÀÝæ;Àç´ÀòŽBÀþ©¦Á»þÁˆ®Á‘Á  Á)¬ÔÁ3²ŠÁ>®ÁH­ÕÁS§dÁ^ÅCÁj ÁuÓ Á€ÿ¯Á‡ GÁ7³Á“ÀÁšÊÁ e)Á¦ÝÃÁ¬TÁ°4Á´jpÁ¸þLÁÇ ÁÂ5Á»eÇÁ´¢ÃÁ­ê¯Á§FoÁ ½–ÁšGÁ“àÁ’Á‡Y:ÁJ5Áv®ÁjßÁ_y.ÁTžÇÁJiÁ?³8Á6Á-!Á$'7Á6ãÁÓÁ,pÁMÁÕÔÀüAÀôÀ홽Àè1¿ÀãàªÀâ4þÀá'ŽÀáùïÀäGúÀç´;Àí~!ÀôZdÀümÝÁùîÁ?hÁ ëñÁÂåÁjÁ$iÁ-@eÁ6YÉÁ@IÁJ3ÁT‰ÙÁ_;Áj7¼ÁuVôÁ€N Á†+ìÁŒ<]Á’F5Á˜i?Áž®DÁ¥­Á«uÁ±Ø°Á¶tyÁº£ÚÁ¿ÁÌóHÁÆR"Á¿ œÁ¸òÇÁ²XvÁ«ØeÁ¥qñÁŸËÁ˜Ë»Á’ž!ÁŒ•–Á† âÁ€¾qÁvÁk2MÁ`˜ÁV1'ÁL`ÕÁCEÁ:?ÜÁ1ã§Á*OöÁ#? Áá,Á RÁÁ ÿÁ “nÁn…ÁéÝÁÙåÁ ¨Á‡+ÁèçÁJÁ¥úÁfÁ ²Á “ØÁ9Á7½ÁÀÁ#Á*VÅÁ2¥Á:vUÁC‚TÁL®ÁV’Á`±'Ák#ÁuÂuÁ€d Á…ôRÁ‹–9Á‘oÁ—y Á~žÁ£Á©ÇËÁ°$Á¶oçÁ¼¥èÁÀþÈÁÅGùÁÑB‘ÁÊÁÃÿVÁ½l»Á¶óWÁ°• ÁªH/Á¤òÁãxÁ—ÙÅÁ‘ë<ÁŒ —Á†[ˆÁ€ãíÁw.™Álµ{Áb¼ˆÁYv¤ÁPuCÁGÁ·Á?ç—Á8–_Á1ÒíÁ+¨<Á&$MÁ!FÑÁúîÁ4ÍÁ!ØÁ»JÁÇÂÁÐÁ{WÁÙ?ÁñÔÁ{®Á ¯Á24Á yÁ!j¸Á&I8Á+¶ŸÁ1Š5Á8w/Á?ü™ÁGòeÁP¢-ÁY©gÁcâÁm ÅÁw/¹Á€ËAÁ†%ÍÁ‹¬6Á‘=+Á–Þ‡Áœ³!Á¢³Á¨«…Á®´ËÁ´änÁ»,1ÁÁ4¿ÁÇ]±ÁËš}ÁÕœ ÁÏ ÁÈ‚ßÁÂ’Á»·ÉÁµt Á¯?»Á©ÀÁ£‡Á6@Á—\åÁ‘« ÁŒ/Á†â˜ÁŸDÁy$yÁoª Áf¶[Á]ÆnÁU¬ÁN ÂÁFýÁ@ƒ“Á:˜ÕÁ5VÎÁ0“ÇÁ,v Á(çæÁ%ã§Á#Œ¶Á!¹Á óùÁ pÁ ̰Á!Õ^Á#TÐÁ%µØÁ(¿¸Á,ƒ¾Á0«rÁ5qTÁ:®´Á@BÁF»)ÁMþ£ÁU¬ËÁ]ñÁfâ§ÁoäðÁyzˆÁÄ Á†×ÕÁŒyÁ‘jKÁ–ð¼Áœ†Á¢&ðÁ§ïÄÁ­â„Á³Ó«Á¹ÊÁ¿âŽÁÅäÝÁËäµÁÒ!ÁÚÁÓšâÁÍ.jÁÆÙôÁÀŸ¾Áºw»Á´^nÁ®bÍÁ¨€ÇÁ¢¬UÁœú™Á—{®Á’-äÁŒå˜Á‡ÊÏÁ‚÷úÁ|â‰ÁsçUÁkcÁcšñÁ\YøÁUƒ£ÁOC,ÁI–žÁDŽûÁ?øêÁ;ñ®Á8™ìÁ5¯Á3^"Á1­Á0çhÁ0eJÁ0Á:Á1¸çÁ3/ÎÁ5mÉÁ8YÆÁ;ü˜Á?ø0ÁD¢]ÁI®7ÁO#LÁU0ÕÁ\.AÁc—–Ák~{Át SÁ}ûÁƒÝÁ‡õáÁÎÁ’TÁ—Q¸Áœ¥·Á¢+êÁ§É7Á­`DÁ³$(Á¹Á¾ÎÍÁįÍÁʨ¿ÁЗÁÖ‘îÁÞ¶OÁØMåÁÑüYÁËÃÌÁÅ©Á¿žÜÁ¹©PÁ³ËíÁ­ûßÁ¨J*Á¢ÈZÁtèÁ˜-QÁ“ðÁŽ"Á‰‚²Á…²Á€¬gÁy>ÝÁqËÂÁj½¦Ád&šÁ^&°ÁX«æÁSɆÁOjdÁKzÕÁH80ÁE{ÆÁC0UÁA¢ÞÁ@ÛhÁ@ZÌÁ@µÅÁAœ{ÁC 3ÁE0¬ÁGý$ÁKyòÁOZBÁSÖ+ÁX¶ƒÁ^þÁcÔ­Ájp0Áq­ÖÁy@qÁ€¹Á…[Á‰ž;ÁŽCÁ“0³Á˜AŽÁY>Á¢Œ(Á§á/Á­g,Á²ÿÑÁ¸—Á¾T}ÁÃõÁɬ¶ÁÏ„cÁÕgëÁÛL”ÁãjÁÝbÁÖêÁÐÔNÁÊÜÁÄî_Á¿–Á¹GœÁ³™¾Á®jÁ¨¶ËÁ£v%ÁžEÛÁ™QÁ”œkÁ ŒÁ‹´¾Á‡„SÁƒ¨ Á€àÁy:}ÁràéÁm ˆÁg×íÁcIÁ^áÐÁ[ÁWß7ÁUHsÁSUÁQ™­ÁPÏÙÁPPŽÁPªOÁQ‚¼ÁRé¯ÁTüÁW”­ÁZ÷LÁ^ÎbÁc·ÁgÚ Ám%ÁržXÁxÜ7ÁåZÁƒžeÁ‡†CÁ‹Á=Á@WÁ”¹ÒÁ™s:ÁžmòÁ£€NÁ¨šÁ­Ä³Á³±Á¸ 2Á¾&ŒÁù,ÁÉ>ºÁÎÏnÁÔ{]ÁÚIÁà,¾ÁáQ~ÁÛ<¶ÁÕDîÁÏk‹ÁɧUÁÃåÁ¾.\Á¸¡¹Á³DWÁ® §Á¨ù Á¤.ÁŸ"ñÁšmkÁ•ðÁYÁˆè€Á‚irÁw”ÍÁjOÔÁ]aÁP¼!ÁDf‰Á8¡-Á-‰VÁ"å4Á tÁQ Á„aÁèbÀùþáÀò~—ÀîüÀín¶Àï€SÀô‘•Àü¨“ÁçÝÁ žÁLÚÁMÅÁ%C Á/˜„Á:°yÁFt3ÁRÆñÁ_bQÁlASÁyQEÁƒV5Á‰˜fÁÄÁ•pÁ™§4ÁžXÁ¢ª@Á§Á¬œÁ±³³Á¶êßÁ¼TÁÁë+ÁÇ«ˆÁÍ‚´ÁÓcéÁÜfÁÖ2ÁÐÁÊÁÄD&Á¾xÁ¸¿=Á³ £Á­9Á¨%²Á¢ì|ÁÙkÁ˜ðßÁ”èÁs[Á‹ÃÁ„`{Á{ÄêÁo&~Áaÿ©ÁTàrÁGá“Á;aÁ.²ÌÁ"îKÁìÁ cÝÁâEÀ÷beÀèÚyÀÝÙÅÀÕÞvÀÐûÓÀÐvÀÒ¸À×Ô-Àà—FÀìÐÀû*ëÁøÁª6ÁæÍÁ$æöÁ0«%Á=*ÁI·+ÁV‡LÁc­2ÁpòÁ}›Á…øÁŠ’¥ÁŽÊšÁ“OÁ—¢õÁœxfÁ¡….Á¦¡“Á«Ò¨Á±6%Á¶ÊŸÁ¼†hÁÂ\'ÁÈD»ÁÎF%Áמ›ÁÑSûÁËÁÄôCÁ¾õÌÁ¹&Á³[»Á­™ÅÁ§ìÁ¢fÖÁzÁ—ËcÁ’ÀÂÁßcÁ‰!Á„‡ºÁ€/cÁrðÁeÕµÁYÉÁL¤CÁ?|Á2}/Á%¸ ÁC¢Á …ôÁŸ‹Àð˜0ÀÞ”ÙÀÏHªÀ¶sÀ¹ŽÀ´9À³.)ÀµqßÀ»µŸÀÅ îÀÒÀâs ÀôŽ ÁƒµÁ`%ÁÛÁ'r<Á4ƒÁ@÷'ÁN"JÁZfÁg@ÁtÁw%ÁƒîßÁˆ2ÙÁŒ§EÁ‘i‚Á–pkÁ›ØÁ ÀøÁ¦ÿÁ«­ïÁ±bZÁ·7nÁ½(zÁÃ3@ÁÉR¯ÁÒÞîÁÌáÁÆE6Á¿ÿeÁ¹ØÁ³ÕÞÁ­ûíÁ¨6Á¢uÐÁœÑÑÁ—NÏÁ‘éÇÁŒ­Á‡±Á‚ÖHÁ|/xÁs\ˆÁjÁ,Á]IÁP ƒÁC:Á6çýÁ*YøÁSÝÁ¨ÔÁ:iÀñÃÀÛ¥>ÀÇÁ¾À¶œÁÀ¨íRÀžEÚÀ˜ÁŸÀ—u™ÀšÛÀ¡ ŠÀ«i²À¹ë€ÀÊÛâÀÞáÀô~ÁÔ€Áú©Á¶JÁ+‡PÁ8!ŽÁDjßÁQ*KÁ^?Áiò7Ár(}Áz¸xÁº!Á†e‚Á‹^WÁ~Á•°CÁ›”Á “šÁ¦?–Á¬4Á²°Á¸$×Á¾GÁÄw;ÁÎGNÁÇÜÁÁˆ•Á»:­Á´ïÌÁ®ÂyÁ¨¼_Á¢ÞÉÁžÁ—SÙÁ‘º ÁŒ8NÁ†ÌºÁ—4ÁyUKÁo¯»ÁfcÁ]»®ÁU"ÿÁG$Á:pcÁ-z-Á!¿ÁIwÁ¢ûÀø 5Àß”ÙÀȆÄÀ³*fÀ 8BÀ™À…>À}‚÷ÀyDƒÀ~pÀ‡ÒÀ“OÀ£bÀµÀéÀÊÚÀá™òÀùÒÍÁ †/ÁOeÁ"=§Á.™÷Á;PÁHUÁT¨6Á\ñÁe“Ám¾’ÁvÞ¢Á€SÁ…lcÁŠŸ¹Á’Á•|&Á› ÙÁ ÷ÝÁ¦ûÁ­=Á³;¿Á¹o‡Á¿ÅVÁÉåáÁÃVÁ¼ááÁ¶‚¸Á°3LÁ©çìÁ£´õÁª«Á—ÇØÁ‘òjÁŒ4[Á†¥þÁ#rÁwiÁmßÁc`2ÁYΊÁPÀóÁH ]Á?¾“Á2âÁ$½ÁÐÁ IYÀÿ6Àè„]ÀÏõ“À·˜XÀ¡¥ÀŒ®oÀw'˜À\½;ÀLaÀH¤ÄÀOqëÀ`–†À{S¢ÀŽ¿^À¢nóÀ¸÷ÀÐ÷ÌÀéhÌÁëŸÁ •Áõ%Á% ŒÁ2ËAÁ?…jÁG@ÁOlNÁXÿÁaÁj¤yÁtµPÁÉÁ„õÁŠh¼Á ÔÁ•â&Á›ë}Á¢%Á¨6ïÁ®qÁ´ÎîÁ»LÓÁÅ®_Á¿úÁ¸moÁ±ðóÁ«„vÁ¥+êÁžáëÁ˜°ÍÁ’¢†ÁŒ¸’Á†ÙÚÁìÁw#ÂÁl nÁaOÁW @ÁM€ÒÁDÛÁ;0Á2’¦Á*«ÈÁÀaÁD_ÁWüÀë¨8ÀÔ<¶À¿1éÀ©:À’JÔÀy»OÀS4ŠÀ6AÀ#ÁîÀ÷À%óéÀ9q‘ÀVåÀz¶*À’À©3UÀÁZ`À×D€ÀîV{Á~2Á:wÁ Á*d­Á1ç=Á9ÜjÁB} ÁKV¿ÁT¾Á^–£Áhþ©ÁsÑÁ~½äÁ„üvÁŠÕäÁãüÁ—tÁ<ØÁ£}åÁ©äPÁ°l#Á·!ÁÁ™ÁºÑFÁ´Á­…àÁ§õÁ ðÁš(ãÁ“Ü[Á°CÁ‡¦Á²ìÁw” ÁlÑÁaÌÁVÁKR®ÁAI;Á7¢°Á.K)Á%¡¶ÁCvÁÃmÁç<ÀômJÀÚNÃÀÁ¿ÕÀª¥LÀ–¹»À…“oÀ`‚DÀ9Œ›À¯ÀÝä¿ú ’ÀýôÀòÁÀ9á÷À^ÎçÀ„MÀ™Š]À­vÀÃÝÆÀÜœfÀö_ÓÁ¸ùÁ…sÁÕaÁ$‹ŒÁ,ß%Á5Ÿ‹Á>õÁH ÁRßÑÁ]» Áh¾iÁsö¿Á«Á…è¡ÁŒqÁ’OàÁ˜˜@ÁŸêÁ¥šWÁ¬=Á²äõÁ½±òÁ¶ÑDÁ¯ûÁ©>jÁ¢žþÁœÁ•¥Á0ÁˆÙäÁ‚±%Áy^rÁmq©Áa­ÁV1ÁJïîÁ?ó¨Á5r9Á+~LÁ!Ä‘Á²ÊÁlž¿9û¿˜l¡¿ç ²ÀeìÀ7§¥ÀVÍ—Àx)‘ÀË0À ‘JÀµ=ãÀÊ“:ÀáöÏÀú2PÁ e;Á!TÁ#GYÁ0´Á>,ªÁK§ÜÁYQ‚Ág;Áu7ÛÁšÁˆ™cÁ«ŸÁ–Ç€Áç Á©r±Á¢ÃÁšÍÁ“¤ÁŒHíÁ…$yÁ| ÁmùÈÁ_øÏÁR8òÁDˆÁ6ãùÁ)›¸Á¢Á¬ ÁîlÀíÉÀÔ¿ÀÀ¼ÄÔÀ¥ÜŒÀ@BÀt±ÀL% À'eëÀÞ¿Éc­¿‰¡ã¿z=–.6?4©ñ?®;>@±@,¶@Wž@1ù@ ýŠ?ÃÏØ?aB§>\þ¾ÔP¿pW¿ÄÌÝÀKÀ#p“ÀF:õÀl?˜ÀŠ¡hÀŸÇÀ·õÀÏDÔÀçϘÁí/ÁYÁÌ€Á)BfÁ6ÝGÁDÄÄÁRÂNÁ`¿3Án»ÝÁ|Ø Á…‹ÁŒ–ÌÁ“³ÁšáèÁ¦§ÒÁŸ?Á—æ]Á’Á‰>›ÁòÌÁuwóÁg>ÁY3ÁJúÓÁ= VÁ/\vÁ!µ/ÁCÉÁ3§ÀôzñÀÚ«ÀÁøñÀ©PÀ‘nÀtÓ0ÀH À@ç¿íD¿£³n¿Bî·¾_õ9>œÚ¿?\¬B?¼ñƒ@^?@17@[eå@ƒ1$@cDK@;¯é@'s?Ïm!?yÖ¨>ÄÊžBÄ¿4¼‚¿4¿âs À*úÀ?¹'ÀjfxÀŒ’À¤ŸÕÀ½˜kÀ؃Àòó&Áì“ÁsõÁ"NYÁ0KŒÁ>IÁLF‹ÁZ]§ÁhŠQÁv¾ëÁ‚{YÁ‰¦‹ÁÙÁ˜sÁ¤uÁœ—èÁ• ðÁµÁ†Z8Á~òÁorÚÁ`ØŸÁRk>ÁD8 Á6[Á(úÁ5*Á [Àþ-ÅÀã‹OÀÉ¡õÀ¯Æ¶À–Æ#À|AsÀL}±Àòð¿ã–¿ƒ¿ê‰=L}8?€f?&:?Øàœ@ò`@8D@a’@…ˆg@šc@ŠÉî@kþ;@AÉo@)>?ãÕ¹?•µ7?#Ôß=Ük×¾ã4-¿„d0¿ÔÉúÀo©ÀDJ&Àt tÀ“ÖCÀ®€{ÀÉBcÀävÿÁÒÁ æFÁâéÁ)æbÁ7õ ÁF+MÁTb€ÁbšMÁpòÇÁT¸Á†Û^ÁŽ uÁ•H“Á¡…RÁš Á’•ŠÁ‹öÁƒ§3Áxp€Ái·7Á[ÁLiôÁ=ÌÁ/_þÁ!8¬Á1ÓÁ+¹ÀîÍrÀÓÆaÀ¸Ü–ÀžºTÀ„ñÀW|bÀ%¯7¿ë¸ ¿Žo5¾×»¬>lr?TÔÝ?²ã?ù©[@Ài@DÏx@j¹°@ˆï;@át@²…3@¢êƒ@ú@r@Z@K<`@$G?ÿ á?¹tB?c‡M>›÷w¾®fC¿ƒ2Ý¿à6qÀ!3òÀTéAÀ…ïÀ 8À»£ÈÀ×/kÀó*Á“®ÁžÎÁ#ÇÁ2üÁ@B%ÁN™6Á\úÁk\‘ÁyÎrÁ„+AÁ‹xžÁ’κÁŸ"|Á—“£Á}Áˆ˜'Á ÀÁsTlÁdmWÁU‰˜ÁFÊ*Á8Á)^†ÁÄÖÁ pøÀülûÀàRyÀÄ’‰À©;“ÀŽ9LÀg¶lÀ3Ü`À꥿ž[[¾÷\6>{A?nMÏ?Ƀ=@ ´í@0Y@T A@x•_@޹Ä@¢@€@µî%@ÊÝÑ@» @¦4Â@’Fò@}ãê@VÔè@3O@£?ÑzÑ?|Îg>›UÛ¾áò;¿œí9À|„À8JØÀn”`À’àÀ®yÓÀÊ‚ìÀæ«¶Ás4Á¿âÁqÁ,QöÁ:²ÁI!FÁW¨XÁfD%ÁtáˆÁÁˆÁ‰Áq'Áœå{Á•K£Á²ÙÁ† ÓÁ}7xÁnF(Á_[>ÁPw·ÁA‘Á2«áÁ#×ÃÁ uÁK ÀïƒÀÓMÀ¶‡ËÀš_þÀ~ °ÀG[­Àb„¿»”N¿+§=è{á?_5~?ÌÍX@j@;Pá@b‰®@„+ @•ì@¨Å€@»}_@Ï$0@âøŠ@ÓL—@¿¿@«×G@—™½@…Tg@fk@?D…@?ÐÿA?^=n=†¥Z¿Bü¿Ìš—ÀSÀTKåÀ…þÀ¢'ÐÀ¾VÇÀÚØ¶À÷wÿÁ øÁ$Á' 1Á5—fÁD*‰ÁRËiÁapNÁp!QÁ~î|Á†æœÁŽ]PÁšÔÁ“0ÉÁ‹ŽÁƒìˆÁx™CÁihAÁZTÒÁKdñÁ<ƒ¤Á-¢pÁ¿ÐÁâLÁUÀä}lÀÆòœÀª BÀŒ8Àb,ìÀ*Ÿ,¿çê ¿x‡‹¾ì?)ú‡?¹ÂA@ ãä@=f\@hº‰@‰†@œÝi@°)’@Âl²@ÕV›@è`÷@ü L@ëíb@ر<@ÄC;@±{…@žÂa@‹0@kV€@=u@ þâ?­ü’? ³¾¦¬p¿—o—ÀB‡À;U™Às¡ÁÀ–SkÀ²ìGÀϰÀì¡ÏÁåüÁtXÁ"bÁ0ÙqÁ?¦`ÁNi2Á]6Ál$Á{ÈÁ…tÁŒ‚ÅÁ™Á‘SÚÁ‰ž÷ÁñŠÁt˜ÕÁeSÁVèÁFÜÁ7¸¯Á(´xÁ̃Á æ4Àø`ÀÚP%À¼µaÀŸJÀ³—ÀIÿ¶À ×¿°Å†¿ùS>«u?•”?ýÒW@2 #@cðŒ@‰õì@ ,l@µH@È÷*@ÜN@ï&JAö×A ¢PA¬ÿ@ñ%@ݰÅ@ÊÉE@¶²?@¡!C@‰O5@_N@*0È?çÜò?u“É=Ä—¿G©›¿Ô·6À#hºÀ\•†À‹`À¨ú›h¾Ì­¿¥_ÃÀ æ»ÀGIbÀYÄÀžèKÀ¼8¨ÀÚ*WÀøk¾Á FÑÁ1Á)"BÁ86ÁGR}ÁVnêÁe‹GÁt§YÁáüÁ‰sÉÁ–$ ÁŽSÔÁ†‰;Á}ŠSÁnÂÁ^‰ÁO iÁ?‹Á0„Á ÇžÁ´ÁZ?ÀæJÀÇß®À©ª1À‹À…À[ÛiÀ Mß¿Ë)F¿,Õç>rRÃ?ƒô@×¹@8¿Ü@oàÿ@’þÝ@­‹»@Çj@à&@÷€‹AŽ{AŠøAl?A$4Àñ8Áï8Á!èÁ&@õÁ5a¦ÁDƒœÁS°RÁbé§Ár)Á€·mÁˆ[ñÁ•#~ÁE‘Á…jÆÁ{(«Ák†;Á[ðqÁLa$Á<ÑØÁ-BŒÁ³µÁ0\Àý‰<ÀÞè.ÀÀyÀ¢ ÜÀƒž´ÀJ—ìÀ¶Þ¿¥Å²¾¹i®? ú?»†(@Í@P¿1@„²§@ ­Ñ@¼8ý@×\v@ñìeAË’A¯4A…IA&ºYA0ÈøA'è’AuòA×¢A-@íÐè@Ò0w@¶R»@š @{@Ak«@Îy?—½Þ>y° ¿0þ¿Ñ)NÀ%ÙÐÀc¹ÀòÅÀ®‡!ÀÍOÀÀì>ÁZ£Á´WÁ#çÈÁ3,°ÁB~FÁQÎzÁaÁp[‡Á¢GÁ‡x@Á’ ªÁŠç–ÁƒÅ~ÁynÁi±¦ÁYõ˜ÁJ>hÁ:’+Á*ïÁWÁ ÂHÀø^›ÀÙ_`ÀºhÀ›o¾Ày½À;ÈS¿þGÈ¿„þé½»`«?W¹_?â¾@,Я@gA@¯©@­?ð@ɰ“@åÁQAŸúA#ÖACA'­¦A2¡üA=,A3ªmA'9 A©A ë5@ü$„@ߤ]@Ã&ë@¦!ì@ˆÈ%@UgÞ@îä?·r6>ïÒ¾üŠÕ¿º ÀŠzÀXiÀ‹#ËÀªÀÉoÀçû¾Ác7ÁÒ-Á":õÁ1ªÁ@àÃÁP?$Á_œÁn÷]Á~T-Á†ÚôÁŽüÅÁ‡ždÁ€MÁr%ÏÁcåDÁUä ÁH/?Á9+ŠÁ)gÜÁ¤/Á à‚Àô;¢ÀÔÏ–Àµ€”À–HÅÀno—À0f†¿å&“¿S<Ô>RT?Œ7õ@Š;@>ù@zÚ”@›&@¸}X@Õ’¢@òSbAj?AzA#NÄA0Ç A=‹˜AHÛ†Ašâ?£Óx@§?@M;‹@…lì@£ßœ@ @ßôæ@ý;A c°AÝ7A*5ÚA8EÀAF íAQ´›ACØA5Ã;A'GAq2A I@ò¯é@Ó>@³œv@”@iL/@*|§?×Z>?3a¾’ký¿¢ —À²aÀN^wÀ†uîÀ¥œhÀÄÀ*ÀãæLÁ†ãÁãÁ ªãÁ0<äÁ?µÓÁO SÁ]OûÁk[‡ÁyvJÁƒä:Á‰ƒœÁèlÁt´1Áe¶WÁVݼÁH$ÚÁ9tÁ*ø0ÁÇAÁø>ÁŽÄÀèÂÀÏñ²À°þÃÀ‘kËÀc±¦À$rÖ¿ÊW¿¡g>Æ&ä?®Õè@œ@TÇ©@‰½[@© (@ÈK7@ç‘‘A0AJ.A!7“A/ø/A> ¯AMAOYÜA@ oA1ûŠA#aAAAå@ñm@Ò Õ@²«@“eÍ@gû @) z?Ô3Ò?-Ù¾—î¶¿¢äSÀAXÀN¼¤À†›ÿÀ¥Ù°ÀÅcÀäF›Á®˜ÁäÁ|[Á+höÁ9¥ÙÁGø+ÁVgÁd®Ás,Á€ëàÁ‡SÁH Áoð¿Á`¢*ÁQmxÁBYnÁ3nFÁ$³Á%Á‡hÀòÓ(À×™ãÀ¼í²À£ºÀ ,Àb'XÀ# I¿Èþ¿Ô>Ïü¨?±Ï¢@´E@V€¹@ŠœP@©èq@ÉK¶@èŠ A£òAçnA!€´A/Œ[A=kAKI«AJK²A;'qA,(RAXóA´€A0™@ã×’@È/N@¬kq@Žß@`g6@"³å?È“W?}ȾÃ1¡¿­luÀ ÀS{?Àˆñ:À¦²-À¿$ÀÙ ÅÀóõ[ÁØLÁ Á$UÁ2ßkÁA¤ÆÁPF»Á^èFÁm°ÅÁ|žùÁ…x;Á{XùÁkÏ|Á\VöÁLó?Á=£ÒÁ.[Á+îÁ* Áb×Àå|=ÀȧAÀ¬¤¥À‘¡Àp‘\ÀC°õÀ¾±¿ËS ¿ƒ5>ºžà?« @½Ü@R•@‡ò€@¦·›@Å|¶@ãâXA»ŒA•ADKA+„?A9ØIAH(AFA8A6ÛÉA'x¡A.@A u@ôFµ@×Ý@º‹<@ž[Ê@‚ÀÐ@MÒ8@€ø?±ÕK>á6˜¿~¿¼<ÀêºÀGÌÀtHÀ’ã÷À­éÀÈ¿KÀäùíÁűÁY%Á1ƒÁ-™Á<½ÁJïÝÁYæ(ÁhÿÅÁx6BÁ„÷Áxa™Áh¥kÁXó)ÁIM$Á9¶vÁ*3VÁÉ£Á ´Àø¥ÀÚuóÀ¼žeÀŸ4 À‚á’ÀNhÎÀš­¿ãèž¿­Øù¿.U:>‘â?ž=ù@ +ß@I]@ƒ)F@¡ ]@¾½¨@Ü~q@ùe+A K\AÁéA(=PA6ï‹AE¶ßABŽA3"A#‡YA3A´*@êÍ.@Ì`@®¢&@‘iƒ@i‘ú@1Ûq?÷ º?‰oJ>Mµ¿4V¿§c ¿ä®QÀ^LÀN0—ÀûÀž–ÀºÀYÀ×û2ÀõÖ·Á â&ÁäðÁ(lÁ79LÁFsÁU¶ýÁežÁtuÁ‚F`Áv ÆÁfmcÁV¢uÁFÚsÁ7‹Á'S]ÁžìÁüÀðã‰ÀÒ’À³²±À•ÌÛÀo»6À5‹í¿þõª¿ Ûô¿H)¿5¾d>óG?‰«%@…ó@<"H@wá@™ËJ@·4q@Ô«Ú@òÜA²šAlA%W´A4i¬AC™A?ýA0HüA ˜DAëŠADB@ãIW@Ä+‚@¥bj@‡*@R¶@¿!?Àþþ?'£®½ø9ö¾ÛØ£¿¿“n-¿óÉ“À/êmÀikÞÀ’ÜÀ°.ÀÍÒÀì ìÁñÁK¬Á#TÁ2úwÁBq4ÁQÞ•Áa@áÁp ÞÁ€hÁÁr"Ácy}ÁUŽÁE<$Á5`Á%‹×ÁÀdÁiÀì§ÃÀÍxÛÀ®wÀ¾ Àbò×À&ýY¿Þft¿y8W¿ ·¿#I콊å6?X¬?ãH¼@-—@h©W@’G@¯ÙÅ@Î5q@ìGäA”AšA#VA2´ƒAAü®A>²aA.݉A A<í@þé-@ßh¬@¿éd@ gM@@D¬@~¦?—h>¤…{¾ðÏê¾´B6¾iA ¿7Ü ¿Ãú,À¦qÀVÖ~À‰eÖÀ¦íéÀÅ’ÀãÇéÁHZÁµÁ Á/­Á>øqÁN…>Á]$ûÁk¹TÁ}ÖÒÁoXÁ`\õÁQ®ÁC4=Á4EÁ$X–Á¬=Áþ\Àê—…ÀËb˜À¬x'ÀŽ1À_à÷À% ¿ßB˜¿†-µ¿1A¿Sžn¾­Œ9#A.M‘AeNA‚R@ýMG@ݪÍ@¾y@ž†¥@}êø@>ì@Ì'?…æo=Çžô¿Bþ¿1ÙÞ¾¸më¿Är¿¯‚ŸÀK®ÀJºÀ‚ÏTÀ¡$À¿nHÀÝù¨ÀüÊÅÁ Í™Á<ÈÁ,¬Á<'ÀÁK‘ÁYZÁhK Á{×ÓÁlú’Á^=:ÁO‡Á@æ Á2^ Á"ïÁÁHÓÀéé!ÀËZUÀ¬ù”ÀÀcKIÀ+â¿õb²¿¨êS¿„Ýþ¿•ÍÀ¿½>­¼ ?¥Í@ãX@MB@…«ø@¤Æñ@Äç@ãžeA…æA9#A îA0«ÈA@jNA>mA.°¥AØ(A?@þRð@Þ³ó@¿*Ã@Ÿ¨I@€ @A"@?‡¨=¢ëª¿dE¿’C"¿4£¿HY¦¿µÀ 8iÀEC½À€–ÀÞƒÀ»ìŠÀÚ1Àø¯Á ±^Á!íÁ*›åÁ9ÚåÁHZýÁVþ1ÁeÏêÁzÚˆÁkíSÁ]®ÁNL8Á?¶¢Á1C Á!îÁ¼ðÁ¼ÑÀé¯zÀËÿÀ®q»À‘È„ÀlNÕÀ8ÝæÀ y'¿Ú+¿½wõ¿ÔÆD¿S9V>ðž?‘Ó@ÿ™@E€è@‚Y3@¢È@Á¬\@áUñAæAK A šA/â A?´æA?˜´A/Ä@AïÍAYAG@àòK@Ánd@¡ò@‚u‹@Eñ-@÷D?ú·>°ƒ¿Rþ¿Ó%U¿šœ ¿˜’¦¿Ð”°ÀáýÀH}…ÀÒÀœÔÀºfPÀØ4–Àöˆ†Á ¹ÁÉ]Á(û\Á8:„ÁFÄ ÁUy>ÁdEsÁzÉ¡ÁkëÀÁ]ˆÁNFfÁ?°_Á1:bÁ!úòÁâüÁÿÌÀê¸ ÀÍâÏÀ±ŒjÀ–myÀyˆiÀJ›úÀ%cÀ &ÀDÀ¿ö¿î¿rp=@9%?…M@L:@AÀï@€‘•@ B²@¿øv@ß¿ß@ÿ“šA·ÇA¨£A/›˜A? A@ýÁA1&âA!K9Aq´A›¤@ã”õ@Ä-@¤€8@„ûQ@Jß@ Çc?™_‰>Y‚^¿Fõ¿ßÓç¿ãÅ¿Ý7Àß8À$›ÀS7èÀƒ0IÀžûÙÀ»‡\ÀØË¸ÀöíÁ éhÁý†Á(/¹Á7uêÁF@ÁTåéÁcºTÁ{•7ÁlÄUÁ^†ÁO}`Á@þÜÁ1éÁ"æpÁúÁ~×Àî«ÀÒÀ¶ÚoÀ }À…ÉÀa±À@ßïÀ,.À&Þ ¿ýñE¿}ÂT:»Á&?~´T?þÑ“@?3N@~þ­@Ÿfç@¿N@ß66@ÿÝA‚ÂAv–A/jiA?^=A@ÂA2#9A"‰tA«ÜAÓ5@åΗ@Åòt@¦!µ@†ds@MŒ—@]Ü?žmE>€”¿0A‹A‡¹@ÿr@á:5@¦t@£´®@„IA@J79@ Ø?šÃë>_߆¿E˜¿á”À0-ÿÀ:O‚ÀD›ÚÀ[ýÀ}©À”,ÑÀ¬ŠÀů*ÀàS8ÀûþÕÁ 7äÁ¾Á)†Á8y³ÁG\ÁV•ñÁeŒÁ€üÁq9Áaõ©ÁS(ÁD6ðÁ5–{Á'oÁÔ0Á êÀúþßÀácšÀÉEÀ²ÚLÀžñûÀŽrÀ‚”Àx ÙÀF؇Àgš¿íZ¾[û?ZÖ¼?ëµ£@4ÿô@t+ù@™²á@¹Bû@ØvÑ@÷ª§A fäAÑ»A)õA.î¼A,A!ýîAHðA.@òµ¤@ÕŸf@¸‰¢@š~¸@y@<ŒÉ?ÿF8?ƒ‚^=g µ¿j¥¿ñ¹À7_±Àe…ƒÀk¸"À~§=À}À d*À¶kñÀÏèÀè_ôÁ]LÁÃÁB§Á+µÁ:NŽÁI ”ÁW¾+ÁfžÁ=éÁswäÁd–,ÁUÝÏÁGWõÁ9 ðÁ*êGÁ ÔÁž.Á¼nÀìíqÀÖB}ÀÁL^À®Ï[À 4À–+úÀ†âØÀN©±À¿ îܾŠòe?5ó>?×€6@*D@hh£@“ -@±áÛ@а@îݽA†uAí[AÖßAïAºwAY‰A së@þ è@ão@ǸW@«U;@Ž=Z@bJü@'Ž_?×Ar?>ÌL¾KŸS¿“GCÀÃÀCïFÀ€»ÔÀŠÄÀ“aãÀŸR×À¯À.ÀÃîeÀÚgJÀòÉÒÁõ Á ¨Á »ZÁ.¹:Á=¾ÁK†&ÁZèÁhÈèÁ‚´2Áv¢EÁgþjÁYƒºÁK@œÁ=D­Á/ž#Á"G]ÁU°Á ‰ÀúõýÀå4ÀѨâÀÁW[À´/À«#À‹´ ÀY ÈÀÈ|¿¹@í¾ôsP>ù³ë?¹bˆ@, @W}~@‰òô@¨'*@ÅßÅ@â…x@ý¥ÒAþûA 9¿AïcA )CAo@ÿ–@éÄf@Ñbé@·“G@œNŽ@€XB@HRŸ@2[?¨$/>ηP¿펿»\kÀ›ÜÀV³À‰ÌÀ¡vÀ¨-¡À³t‘ÀÁ¹äÀÓ¤©ÀèšÀÿš)Á µÁFeÁ%oÃÁ3ŸÁA bÁO7Á]~ÁkùQÁ„‡lÁz“pÁl>AÁ^„ÁP>éÁB¬’Á5XÁ(i ÁdÁGdÁCøÀövÀäÀÀÔ(ÀÉ iÀ±ÒÀ’ÉÀg€À)¶b¿Øw7¿;+>[ã§?”`Þ@˜Ú@B|s@|ëC@›4@¶Ç¨@І @æÈÐ@óµµ@û(@ýßm@úô~@òÜ_@æ/Ï@ÒP@¼¡@¤¡?@Šÿt@`ä×@*[”?är?gL»;.Ø¿gÒÿ¿èºçÀ/nÀjìÀ“u"À±^#À¿ÀÈn"ÀÕ–ËÀåÆÁÀù ‰Á?øÁµÓÁ¥Á+;‰Á8YÁEãgÁS½>ÁaÇoÁo÷ÛÁ†Â=ÁR³ÁqV§Ác–!ÁUÿ‰ÁH¶¶Á;È5Á/RÅÁ#{qÁfÁ àâÁPïÀø+VÀê„ÅÀØ/£À¹Q¡Àš¥tÀxRÀ< 4¿ÿ +¿†9?½êmë?O·J?Ü-ø@'©÷@_@ŠX<@£gi@¹å“@Ê•·@ÔÝà@Ûc@Ýà@Û†´@Ô–'@ÉdÊ@ºZð@¥pÆ@}£@o]@<»%@ ,’?¥i«>àQ­¾á¢%¿©w™À ÛSÀH 0ÀHèÀžŒ8À¼À×NDÀß®4ÀêþÔÀùÌYÁÀÀÁ¥¨Át?Á%ÒôÁ1æùÁ>&ÁK¤zÁY §ÁfÆÅÁt³|Á‰Y>Á‚l3Áw5 Ái©õÁ\n4ÁO–FÁC5ËÁ7YæÁ,Á!MÁkÁ¥ŠÁ'@ÀÿVçÀáâÀÂÏ*À¤ŽrÀ†lCÀQ#RÀ⿵Aœ¿ìš>Ç_j?¡@}@ëˆ@;Ñ @l—…@ŒØD@Ÿ@¬Óˆ@µÊ:@»ž3@½à¼@»Ø‰@µŠ@«øÙ@ž¹L@f@pÆo@D´ƒ@wž?Ç?@_½œó¡¿lãf¿äÇÀÀ*¡ŒÀcJÈÀŽ(À«€ÀÈ`BÀå”À÷g3ÁÁþÑÁÿÏÁ?ƒÁ#\Á.-ÁÁ9¶ÚÁEÐnÁR^õÁ_^Ál±¯Áz*%ÁŒRÁ…†}Á}¥µÁp‡KÁcÃ4ÁWeXÁK€ËÁ@$ÄÁ5?³Á+fÁ!Ú·Á®ºÁvˆÁ”Àë(iÀÍF§À¯¸À’+ìÀiAfÀ/y0¿ë¤:¿wCk½Û}?82½?ê@q)@?VZ@fÿ‰@ƒ×@Ž˜³@–ú@›ÙL@ác@œ@–h#@² @îÞ@f@Ô@@Ö5@«R?ÔÛ?nHµ>,VÊ¿#‰8¿¹b<ÀÕLÀIh8À€j|Àœ”À¸ÍÀÕ6ÀòÁ£Á :.ÁuQÁÜ Á#VÀÁ,Ü Á7HÛÁB[ZÁMÜóÁYï¦Áf|ëÁsc¦Á€AsÁŒTÁˆè£Á‚jBÁx"<ÁkËÄÁ_ëØÁT‰WÁI)Á?"¨Á5˜+Á-pÁ%[$ÁùZÁ Àö¨üÀÙ(QÀ»ÉÃÀŸÀ‚HÀLAôÀT+¿¾É׿*É(=öÅ»?b-š?Ê$?@ ÿÅ@0ÑZ@Kœ@_˯@n«t@x(È@{Ä@x“3@n^æ@^ØÐ@IQ @.…‘@·?ÍÀh?r@Õ>7ï¾òš¿æÀÜcÀ5rÕÀjŽ}Àa}À«éåÀÇ£7Àã¦Àÿ¸ùÁ ÿÞÁ¶{Á‰tÁ&etÁ.IéÁ7=ÈÁATÁK¬ÁV¯ÁbIqÁnfCÁzëgÁƒÖµÁ“ÁŒ¦tÁ†YÈÁ€:èÁt˜oÁi($Á^9ÁS’‚ÁIǤÁ@ʲÁ8¸DÁ-“ÁÓîÁºÁzPÀæ[yÀɧÀ­\òÀ‘â¢Àl·|À7ÕÀˆ¿¤,ô¿:î>-õ?PÕŽ?±X£?î7Ù@R3@!æ@0 ù@8’ö@;Åc@8ÙÂ@/ þ@!…(@ ž4?é÷Ã?®§œ?UéU>N£3¾ì‹¿”?Š¿ðqgÀ(âÓÀZÖxÀ‡=À¡GrÀ¼6 À×qbÀòômÁZ.ÁP&Á#MÍÁ,7Á2—Á9öÁB`ÁK²®ÁUÆÆÁ`LÃÁknÁwLÁ›$Á‡ÌŒÁ–óOÁ±HÁŠ›£Á„±$Á}ÐÔÁr¿’Áh/îÁ^0ÁTêyÁLz>ÁBZÁ3¢0Á%œÁÆÛÁƒ¤Àô¬ÀÙ/À½‚À¢{ìÀˆ&3À]ŠÀ+ã"¿÷u#¿žàB¿Sö;ã[b?Ù:?t²–?¥îÄ?ǃ?⢼?ñŸY?÷b?òa?áŠÕ?Æ€ª?¢#‡?i{>üÄY;)y¿š›¿ï¥ŠÀ$f‡ÀR$ÀiRÀ™ìÀ³¼$ÀÍ{üÀè6Á„[Á$LÁêÁ*ÝÁ8¨Á?*oÁF|ÁMú2ÁVÊáÁ`b0Ájv;Áu#!Á€/Á† %ÁŒ Á›Á•åÁ#ºÁ‰_uÁƒËÁ|ò°Árä)ÁiiÁ`š[ÁW.ÛÁH©ÆÁ:_ûÁ,+MÁ=Á&¿Á]AÀé@¨ÀγþÀ´·À›_]À‚×åÀV,|À)±A¿þ኿¯ða¿V›—¾¿^Ÿ<§@>¬X?c¬?G|Ç?d1‹?oþ?dÖ}?G§[?î>¤*˜»#b¾Ï/Ä¿^dá¿®«º¿üãYÀ'óÀR'À~­JÀ– ÇÀ®a:ÀÆ $Àà9.Àùï7Á HÁƒëÁ$ÞAÁ2‹ŽÁ@LýÁL/AÁR¨EÁZ&ÁbuÁk“ÐÁu3†ÁmžÁ…¼ÁŠÃÁ•ŠÁŸ“³Á™ª„Á“ò&ÁŽYMÁˆøßÁƒÜ¤Á~«Áu PÁlBkÁ]ùÁOÆÁA™Á3˜ÛÁ%ÛÎÁ)ÛÁ ¥/ÀûÀá€?ÀÈ:+À¯ÀÙÀ˜O3Àù1ÀYzÖÀ1z2À ኿ÚÉz¿£Cº¿l ©¿Sc¾Èܦ¾Z©Ô½ÖÜ但ÖA½ÓŽ>¾P1«¾Ë ¿!Õ¿rÕ$¿©(2¿Þ¨öÀÊüÀ/ÿ©ÀXg­À€‹œÀ–*ÄÀ¬zÀØÀÛY"Àóy¡Á[Á9hÁ .BÁ-…Á:ÊÁH=òÁU×ÇÁ_¯©Áf¸ØÁnŸöÁw;ñÁ€9cÁ…#ÁŠTÁÅâÁ•_ÿÁ¤>×Áž‘Á˜ô*Á“—EÁŽhdÁ‰{cÁ„ØÛÁ€‹ÁsX­Áe4#ÁWÁIFÆÁ;˜Á.›Á ÂéÁÖ‚Á%{Àõ¹ÀÜĽÀň(À¯ÁÀ™ÂsÀ…¢JÀf,<ÀDÐÀ&ó”À %¿î¶Ö¿Ëß ¿¯!p¿šhÙ¿Œôb¿ˆjÇ¿ŒÝ¿™$¿¯×ò¿ÌŸ8¿òƒsÀ1À(ÇÓÀF†>ÀfyÀ„Ü}À™.×À­–RÀÃKuÀÙhÀð.ÉÁ(…Á3ŽÁ kÁ){5Á6KÁÁCWÝÁPLÁ]ýïÁk‹¥Ás©dÁ{AÁ›AÁ†jÁŠ»ýÁ¿ÜÁ”þÁÁšfÁ©&Á£’íÁž5Á™$Á”âÁD%ÁŠÓÁ„VÚÁz¤_Ál¸±Á_qÁQ|oÁDœÁ6îûÁ*(mÁ|VÁýéÁî&ÀòÁÀÜ;ÀÆÍøÀ²‡zÀŸOûÀŽ`À|ÉÀ`©žÀI]À4¨YÀ$'ÀIÀ ¾;À={À4À@”À ùÀ§À$”oÀ5Î+ÀJ|VÀc|OÀ~BZÀŽÜÀžÜGÀ±ËÄÀÆ)×ÀÚ¢5Àðl&Á`eÁ¤°Á¤yÁ&¯9Á2æ¥Á? OÁLk‹ÁYGÁfnÁsÃÁ€leÁƒò:Á‡ÍšÁŒèÁŠKÁ•\JÁšopÁŸªRÁ®H Á¨àKÁ£®½Áž¤%Á™ÏÎÁ•AMÁIÁˆ¡Á8“Átç6Ág‚‹ÁZ0ûÁM!šÁ@g)Á3ÎSÁ'rÓÁ}Áý Á±‚Àóá¡ÀßrÀËÏÀº7²À©hÀšýªÀ¸HÀ‚«ÄÀrÀbnÀU¯ÀLH ÀFÄÀD2ÇÀF¦ÀK¯éÀU‚”ÀbÙCÀrÅ8Àƒ„cÀÀ›ÔøÀª¹¢Àºu=ÀË>ÀÞÁzÀó$ØÁ×UÁ·DÁðòÁ%3IÁ1ëÁ=ñÁI(BÁUÂÁb‘€ÁoSÁ|HØÁ„ÀÁŠ€0ÁŽ.Á’4lÁ–Œ$Á›.eÁ Á¥&ÔÁ³ŸµÁ®b_Á©Y’Á¤uÁŸÎPÁ™ßÑÁ’óŠÁŒ¹Á…g®Á}ÁpQ¶ÁcXÚÁV¬fÁJ1ÊÁ=ðCÁ2uÁ&™„ÁGýÁ|ÏÁ9ãÀø‡¤ÀæiZÀÕDÀÅÍjÀ·Ø¯À«—ŸÀ ÞýÀ—Ö¤ÀqOÀ‰íÁÀ…èíÀ‚ã3À‚¼À‚ò[À…ŸlÀŠ/À’”À˜ âÀ¡Ê›À¬f<À¹/ÀÆ¢âÀÖR„ÀæÅÀ÷äcÁÛÑÁìÁH£Á%-‹Á0nüÁ;§ªÁGmØÁSjÙÁ_qÁkë9Áx·uÁ‚±ÌÁ‰¿Á›êÁ”¶½Á˜üÁœ»›Á¡0]Á¥éKÁªÖÁ¹(lÁ´SÁ¯)þÁªq×Á¤³ÕÁÑNÁ— ŽÁ_˜Á‰Ç Áƒ<•Áy”ÕÁm’Á`¡‚ÁToÁH”ÎÁ=1Á1àÁ' Á¼gÁ¯ºÁ R+Á°§ÀðåáÀâ‹ÀÕ²ÀÉ­À¿q.À¶âœÀ¯«ŽÀ©‹÷À¥¢¦À¢ÏÀ¢À¢ÛdÀ¥g™À©4À¯Ö1À·0ÀÀ`ÀÊgêÀÖuÀãP²Àò0%ÁëÀÁ CÁSKÁVåÁ&rûÁ0º”Á;£ÓÁFåÁR“Á]ÍbÁiÆÁÁu¿ÁcÁ‡kÁ©VÁ“óáÁšNÀÁŸoÁ£Á§] Á«èWÁ°¤íÁ¾ÝëÁ¹ä‚ÁµoÁ¯€™Á¨±PÁ¡ûÁ›_Á”ÒþÁŽTtÁ‡êwÁ¥MÁwåÁjïÝÁ_4ÁS²ÅÁHrPÁ=–»Á3>ëÁ)";ÁˆUÁÂèÁCâÁ­xÀÿ\ÀòÏ.ÀçÖ2ÀÞ$ ÀÕöŠÀÎòÀÉHÐÀÅa-ÀÂÁQÀÂnÀÂÄÀÀÅ8zÀÉ#ÀÏÆÀÖ4šÀÞyÀè®"ÀóÇ¥ÁPÁwÁäƒÁµeÁJÁ(¼ÆÁ2ÑùÁ<ÔÉÁG-ÉÁRKÁ]RJÁh¬Át/_Á€TÁ†ðÁŒHÁ’a¨Á˜“[Áž¼þÁ¥VÁ©HÁ­¯àÁ²2Á¶š.ÁÄ®ýÁ¿Ö]ÁºZØÁ³œÁ¬õôÁ¦iëÁŸè5Á™ožÁ“ *ÁŒÉ1Á†®pÁ€²ŸÁu¥Áj4ÐÁ^ù#ÁTGÁIÁoÁ?—yÁ5ÔoÁ,ÞKÁ$EuÁ5‚Á3Á9‹Á[ÚÁ#ÀüÞÖÀõtÀîOÀé ¸Àå/€Àâ·5ÀâÇÀâ²ÂÀåÀÀèÃÊÀîw¨ÀõWÀý#ØÁz-Á»sÁüqÁj‚ÁÓTÁ$›®Á,®«Á5’4Á?+°ÁI,éÁS?„Á]¡àÁhùÁs¿~Á~îèÁ…I®Á‹/#Á‘ ÌÁ—‡ÁQŒÁ£XµÁ©uzÁ¯®;Á´ Á¸IÁ¼¶ÁÊ §ÁÅ5þÁ¾ƒ’Á·ê¤Á±jÁªö/Á¤‰†Áž,>Á—í™Á‘Ù/Á‹ç¹Á†nÁ€\ËÁuöÁj“›Á`@ÁV1ÁL/KÁBü`Á:T"Á1ôÁ*t;Á#p8ÁšÁlÁHºÁ âYÁ *iÁÖ¯ÁiPÁƒíÁW³Á ÁR‡ÁvÚÁ:ïÁò¤Á =yÁ ûñÁ‹ÁÈÔÁºÁ$wÁ*ÚªÁ2ŸÅÁ:`$ÁBÇtÁKæhÁUžSÁ_Áiª¹Át›ÁÏÁ…ÁФ»ÁnÜÁ–;VÁœ€Á¢Á¨ôÁ® Á´ ÁÁºRßÁ¾­ÁÂõÁÐ ÃÁÉfÊÁÂÕóÁ¼_ÁµööÁ¯šjÁ©JFÁ£ÚÁ½Á—øÁ‘PaÁ‹ Á†eÁ€ŠÁv«þÁl—”Áb”ŠÁY.#ÁPl†ÁGßñÁ?ù°Á8Ç2Á1óéÁ+ó Á&€PÁ! †Áf¸ÁljÁ‰BÁKÃÁszÁT‘Á ËÁMÁféÁØÁ©‰ÁÛ2Á~¿Á!¿Á&æÙÁ,\dÁ2µ–Á9.yÁ@Ž–ÁH/ùÁPM*ÁXøzÁbChÁkë²ÁuÐþÁ€jÁ…EèÁŠ­ÕÁ1ÏÁ•ÈEÁ›*Á¡%ÃÁ¦ëMÁ¬ÛúÁ²Ê¯Á¸¼Á¾Ç2ÁÄëÖÁÉSÜÁÔRGÁÍËÁÇ]âÁÁ£Áº±¨Á´mRÁ®D¤Á¨<ªÁ¢Z´Áœ‘ÎÁ–ã¯Á‘FÎÁ‹ÊñÁ†Ž;Á‰¬Áxþ[Áoq`Áf‡êÁ]èìÁU¬ÁÁN:þÁG2(Á@¬~Á:îéÁ5 ÇÁ0ú¼Á,ñÓÁ)eÜÁ&I¨Á$.7Á"eiÁ!QúÁ! Á!HµÁ"XÁ#üÁÁ&`„Á)}ÐÁ-~Á1‘Á5é·Á;JŽÁAZoÁGÀîÁN oÁV5PÁ]ÏðÁf2ôÁoëÁxÁ€øeÁ…úÛÁ‹(ÁrJÁ•ÔÁ›T‰Á åAÁ¦qsÁ¬Á±Ä™Á·¡ùÁ½…ÉÁÃlµÁÉjçÁσaÁØÄ~ÁÒduÁÌÅÁÅ̈Á¿”Á¹umÁ³t&Á­—sÁ§ÔjÁ¢! Áœ‡4Á— %Á‘È1ÁŒÁ‚Á‡¶wÁ‚àÑÁ|¦–ÁsúÙÁk‡‘Ác¾·Á\ŒÁU°ÛÁOŽäÁJ=ÁDÜøÁ@bŽÁ<„;Á9qÁ6!Á4 ’Á2VXÁ1OÉÁ1 YÁ1E Á2JÁ3à}Á6Á9!ùÁ< ³Á@}òÁE ÁJ]´ÁP µÁVn Á\ó^ÁdK9Ák¢Ás‹€Á|$zÁ‚™Á‡5ÇÁ‹ÿÑÁ‘ãÁ–LÛÁ›™Á ó©Á¦CBÁ«¼9Á±FúÁ¶Ø¼Á¼TÁÂfÌÁÈF:ÁÎÎÁÔ ÁÝUÁ׺ÁÐìÞÁÊ¿%ÁĨ®Á¾®„Á¸Ò¨Á³ ¨Á­S¤Á§½õÁ¢M¨ÁÁ—ô\Á’ïÛÁŽ ŸÁ‰jæÁ… :Á€¿éÁyiÁrÁÁjôÁd\’Á^ÀÁY²ÁT/ÁOÙlÁL«ÁH½KÁEéÁCÝóÁBG+ÁAMãÁA )ÁAAìÁB<ªÁCÄ^ÁEäVÁHÏWÁL2RÁOòËÁTAúÁYVÂÁ^áÌÁe  ÁkoÁrb?Áy¶ðÁ€˜ÏÁ„­ñÁ‰óÁ‘íÁ’0Á— 8Áœ,Á¡rOÁ¦€Á«¥"Á± Á¶…Á¼%ÁÁ¦ÁÇV½ÁÍ+ŸÁÓÁØ×ÁáûÔÁÛádÁÕæHÁÏÛìÁÉåŽÁÄ -Á¾?=Á¸‡1Á²ôëÁ­ˆÁ¨?çÁ£'fÁž)ëÁ™;ÏÁ”‰¼Á)Á‹ÀKÁ‡›·ÁƒÂÁ€(ÀÁyoFÁs-ãÁmƒÁh9kÁcˆvÁ_\6Á[µGÁXl2ÁUÃxÁS¶†ÁR7ýÁQL8ÁQ ýÁQ?<ÁR/½ÁSªMÁU±|ÁX„¤Á[ÌÁ_u|Ác”YÁh_ÁmÜÁs²|Áz vÁ€R'ÁƒþGÁ‡ŒËÁ‹mãÁžçÁ” *Á˜‹Á6(Á¢#¶Á§NÁ¬:Á±4šÁ¶e½Á»ÉgÁÁWÁÆç¸ÁÌstÁÒ ºÁ×éiÁݺÃÁà$ìÁÚfÁÔ%œÁÎ1ìÁÈUüÁ“Á¼ù Á·hÁ²cÁ¬Î]Á§ÃµÁ¢Å1ÁÑkÁ™ëÁ”¢$ÁŽ]Á‡àÁÁt ÝÁg*€ÁZ üÁMV)ÁAÐÁ5 Á)¤cÁõÉÁëºÁ Ì@Áß½Àú!3Àïî?Àè1gÀä¨ÀâªCÀäþPÀê9¥ÀòÄ…ÀýÇÁóÁ ð]Á3ÒÁ!s"Á, iÁ7YwÁCP¸ÁO±YÁ\[ýÁio…ÁvÌ,Á‚&GÁˆ¥jÁ°Á”ùÁ˜e‡ÁœÍwÁ¡w¶Á¦]Á«NÖÁ°ZIÁµ›aÁ»MÁÀ®ÕÁÆqwÁÌ=ÁÒXÁÛ*¸ÁÔþfÁÎïòÁÈ÷$ÁÃ1Á½+íÁ·oÈÁ±Å^Á¬3DÁ¦ÑôÁ¡¨0Áœ¢/Á—¦.Á’¾×ÁŽ´Á‰¿ÁƒO~Áy†ˆÁlr°Á^èÁQsÈÁD/œÁ7[GÁ*ôàÁë?ÁÁò…Àþ8%Àí¹ÀÝþŒÀÒq/ÀÊ$ƒÀÅ ÀĆÀƆ¨À̉àÀÕ³·Àâ!Àðó&ÁL Á Y®ÁÕ&Á!~Á-"®Á9—”ÁFa ÁS‘Á`îÜÁnQyÁ{ÚÁ„¹Á‰*¾ÁoïÁ‘ÉYÁ–`lÁ›;âÁ /!Á¥4aÁªmSÁ¯ÛÃÁµzåÁ»@ÁÁÁQÁÆìÁÌç>ÁÖ^ëÁЧÁÉÜgÁÃÅÃÁ½È¬Á·ÙÁ²ÞÁ¬DœÁ¦“šÁ¡ZÁ›§FÁ–†dÁ‘óÁŒŠ=Á‡±æÁƒ"Á}É1Ápœ©Ác_ñÁVƒ´ÁI8¦Á;ݤÁ.…JÁ!Ž/ÁþÁâ§ÀûMüÀæÀÓ-ÍÀà ÙÀµÌHÀ¬Ë8À§™¤À¦À¨ ˜À¯rgÀ¹š´ÀÇ%À×a•ÀêâãÀÿ‹(Á ÿ²Á£Á#¢¯Á0ŒÁ=¸¤ÁK7ÁXwÁdЫÁqïyÁ|¨sÁ‚„ Á†Í«Á‹MƒÁ§Á•6Áš¨ÁŸDÁ¤­KÁªJµÁ°—ÁµémÁ»È|ÁÁÇ-ÁÇéÐÁѧ¿ÁËKÁÄø‰Á¾¾ZÁ¸žDÁ²š4Á¬­…Á¦ÞåÁ¡™Á›d–Á•Ö'Á‚rÁ‹dÓÁ†bðÁtÁyUeÁpm ÁhÌÁZº¦ÁMSøÁ@SÁ3ÄÄÁ&:ÕÁKÁ ÎÀþ€ÿÀæ*9ÀÏß?Àº÷ªÀ©L"ÀšzÀ^ŠÀŠ úÀˆ¬|À‹…iÀ’¨PÀž“pÀ­6åÀ¿žÀÓæ„Àê*¡Á=üÁ ã!ÁÄÒÁ(¶Á5<ÁA¿¶ÁN²7Á[ÓÁg°ÁoG×Áw¾&Á€BîÁ„û}Á‰òFÁŽúïÁ” ÔÁ™ƒÉÁŸÁ¤ê°ÁªÂªÁ°¨ùÁ¶­Á¼Õ?ÁàÁÍ LÁÆ“ÐÁÀ89Á¹èÁ³¤Á­yøÁ§l’Á¡‚ÕÁ›¹Á•ö¸Á:›ÁНÎÁ…aîÁ€CCÁvŠLÁl¾˜ÁcUÔÁZ¯ÔÁRa ÁELÁ7l8Á*@Á™ýÁã·Á¤¨Àí?ùÀÓÄiÀ»WÍÀ¥TZÀ‘'œÀ4Ài)‚ÀZã%ÀWKÈÀ^?çÀn¾vÀ„VÀ”üÛÀ© ÀÀ¿(À×B{Àð„üÁ$Áp@ÁÿnÁ+˜Á8œÑÁEÑ ÁQ°!ÁYgÁaúµÁj‹IÁsÉ„Á}«(ÁƒãwÁ‰ìÁŽ`fÁ“øþÁ™ÃìÁŸœæÁ¥ŒÂÁ«™øÁ±Ç¥Á¸ìÁ¾}_ÁÈ¡+ÁÂ%Á»†íÁµ&yÁ®ÙÔÁ¨àÁ¢YŠÁœCÁ–Y#Á“*ÁŠÐèÁ…Á!´Átƒ^ÁjCoÁ`]6ÁVš†ÁMjÁDûáÁ<¿Á/ZÃÁ!·fÁW“Á‰¹ÀöÏgÀÝ$—ÀÃ2¥ÀªÀ‘ÿÀxœŽÀRinÀ6"À%øÀ }À(I’À:âýÀXž²À~4*À”ïÜÀ¬`©Àż–ÀßYÀùTØÁÔ¾Á‘QÁ"“^Á/øÁ<[ ÁCïÁL?ÂÁT³ŠÁ]³TÁgtôÁqœùÁ{âùÁƒD³ÁˆØãÁŽ)Á”yÛÁštŒÁ SÁ¦»±Á­ cÁ³u Á¹ëòÁÄnÄÁ½²åÁ· fÁ°‚–ÁªÄÁ£ËÁ€jÁ—=ÒÁ‘žÁ‹2PÁ…mfÁV[ÁsòðÁhíŸÁ^CnÁTƒÁJ3¯Á@ŠÁ7£ÜÁ/HÁ'GÀÁÛÁ $Àý_ËÀãa‡ÀËÀ³½ÀšÏœÀÇ8ÀTÀ*‹À /„¿æºE¿Üf¿î|ªÀ íÞÀ.Ñ,ÀWx<À‚ÝìÀ›ªLÀµOÀÍpÞÀå®ÖÀÿ=#Á ¶¯ÁY Á''¤Á.t^Á6„ÏÁ>üÓÁG¼%ÁQJÙÁ[x•Áe¿îÁpe†Á{wrÁƒvÏÁ‰Z6ÁaEÁ•»Á›¯¿Á¢¼Á¨sŸÁ®ó©Áµ{‘ÁÀUÄÁ¹’>Á²ÐÒÁ¬ÝÁ¥ˆ~ÁŸaÁ˜ÀxÁ’ráÁŒ)Á†©Á€¬ÁtÁi Á]¿²ÁR¼¾ÁH:Á=ÕÁ4ßÁ*ŸuÁ!ùòÁ˜VÁ ”Á–ÇÀí­ÀÑÿBÀ·óÕÀŸ](À‰V´Àf+'À7žèÀ :¥¿Ì‘s¿˜n ¿Š´“¿Ÿ‘¿Ò#À ÙþÀ7 ÕÀf£òÀ‹«#À¢ËÀºC{ÀÓœ“ÀîF„Á"ÁÁ8&Á ÒÁ)K‰Á1ïpÁ;= ÁEU ÁOœûÁZKzÁeC†Áp¥‡Á|}ºÁ„SâÁŠv#Á¥µÁ–ÿ—Á}8Á¤EÁª™$Á±AyÁ¼eÈÁµˆPÁ®·§Á§õ·Á¡;"ÁššÕÁ”oÁºÁ‡k/ÁÁuâƒÁi÷æÁ^MÁRÜÁG•AÁ<2Á1ÊJÁ'Ä{Á"êÁë3Á U Á(6Àùø¬Àß¡À½~À¦ýKÀŒú·Àh÷À?wÓÀÞ¿í‚Ü¿¢[g¿Q­Æ¿,²¿_4¶¿¥ý¿éaÃÀgÎÀEðüÀn¯À]ñÀ¨ÏÊÀÄÀà—!Àú+xÁÁ aÜÁŸ¯ÁL’Á%VëÁ/2DÁ9z'ÁD1vÁOÁZn0ÁfR*ÁrìÁ~ݪÁ…¦ÁŒ Á’”gÁ™)QÁŸÅüÁ¦z¹Á­K•Á¸†—Á±¡ÐÁªÄ Á£ç3Á Á–[´Á´ÿÁ‰.¶Á‚¼ßÁxÇšÁl0·Á_ÖqÁSßÁH…Á<„ºÁ1lÁ&gÁ«ÌÁ×&ÁE!Àþ´bÀíx·ÀÞI[ÀÐ+¾À·Ñ³Àš#BÀ{$„ÀF@JÀ¡¿í)¿Ê}2¿“>h¿è¾Á¯6¿5%¿›YN¿¼tC¿ñª¿ÀugÀJ4ÃÀ}û«À›%À¸IaÀÐMÀÝõœÀì{ÀüŒÁ¬ Á‘þÁ#8Á#WÁ.rÁ8ÿôÁDNæÁP;‹Á\ŒDÁhêºÁulÁ&aÁ‡¼tÁŽ]Á•lÁ›Ç|Á¢¦gÁ©™(Á´ßãÁ­Ö²Á¦ã¤Á ûÁ™"xÁ’FÁ‹~TÁ„ÐDÁ|‰ÁÁo™‡ÁbÀèÁV%sÁIÚ#Á=áëÁ2^Á&^fÁLÆÁKÁ¸àÀ÷òÀäøQÀÓ’ÀÂùwÀ´lÀ¦-À’SuÀiÀ/ÅÔ¿öÑ”¿§+ö¿²Ù¿lÞ(½ÏØç>Ã|Q½7që¿WÞÙ¿ƒÄÕ¿«Ä€¿õÅøÀ.¢†Àh¤À‘ñ¥À¦pÀ´WÀÂBTÀÑBÀâ\Àó§ÙÁ;ûÁ 50ÁþÃÁ#ØÁ.PˆÁ:FÁFª¦ÁSqÁ_°´Ál«ÇÁyó‡Áƒ§ÁŠ[-Á‘+øÁ˜(ÁŸ!Á¦Á±~çÁªTNÁ£9sÁœ4 Á•FãÁŽcÚÁ‡zÁ€§FÁsÚBÁf¶¢ÁYÅÜÁLÖÁ@œÁ3ã"Á'ô)ÁîÁ\ØÁ3ãÀôqÐÀßëÈÀÌ9‹À¹·ÁÀ¨¿.À™aÀе€ÀyCÀ\Ÿ®À$Ãð¿Ýí§¿qõ¿Bòd¾§6þ>Ú’?¤=t?6(¾‘.§¿8ÁÍ¿DV¿×éTÀ"nsÀU;ÐÀw±kÀŠ˜¹À˜kÀ§cÍÀ·:˜ÀÈA=ÀÚìÀî[ÁùmÁ ŸÁbSÁ$l\Á0ßÁ=OÁJ4ÁW6²ÁdšèÁqû@Á}XÁ†¢1ÁœäÁ”’¢Á›‡þÁ¢ŒvÁ®2ãÁ§bÁŸØQÁ˜­Á‘“âÁŠ’Áƒª€ÁyŽîÁkËËÁ^1ÁPíDÁCøªÁ7 ¦Á*9ÅÁò<ÁÁñÀôßÀÞBnÀÈx=À´mêÀ •ªÀŽÜÜÀ|0„À^—øÀAâÐÀ%xËÀÁ¿¿jM¿ZÊû¾6->ì/©?†Ö+?ãú¨?/B>ôÌC½¿¹ç¿5³s¿ªÔ?¿øHšÀ zžÀ@ÐÀ]÷úÀz ÀŒ¥À…À¯q ÀÂÍÜÀØ)ÀîHÍÁtâÁ™uÁ8Á'’€Á4„ÁAÛÁOFùÁ\¯µÁjZêÁxGÁƒàÁŠUÁ‘}Á˜*xÁŸAâÁ«£Á£ÏÞÁœ‘^Á•`bÁŽ1ÂÁ‡ÒÁÝKÁqåUÁd!žÁVjÁH¾|Á;SÁÁ.OÌÁ!fÁŒlÁDÀø4ÀàG1ÀÉÃÀ²RƒÀœÁ×ÀˆÁdÀjÏÞÀHDFÀ(J_À ¼û¿ÜMf¿ž§+¿2û¶½³þ’?vs?žÃ?ìÍØ@¿?î‘ì?¤æô?/¤N=ˆ™¿ ÒÍ¿’ ™¿×,òÀ ânÀ&§ÀDò°Àe²À„*À—t À¬JÀÂlYÀÙèÀñ™eÁPBÁïµÁ0Á,…RÁ9õÁG|ÁUU›ÁcN¶ÁqH9ÁCÂÁ†²þÁÑGÁ”õÏÁœÆÁ¨/Á ÓÁ™ÑÁ’3ÑÁŠò8ÁƒÀ²Áy ÕÁjÈÍÁ\¤ÁNĸÁAqÁ3vRÁ%ç¶Á¶Á ËŒÀýñfÀä¢]ÀÌ7À´iCÀ8HÀ† ¤ÀbzPÀ9ý¯À÷†¿æ¿¨ìþ¿Yþƒ¾È¢È=Õxæ?2RØ?¨ê{?ûÛð@(á¶@NJ(@+ªÅ@¢Ò?¼ae?[lj>ƒŠY¾Ÿp¿R›p¿¥þÄ¿áÜxÀ1ßÀ2µòÀXY#À€ÇìÀ–~À­Ì5ÀÆ[¬ÀßlüÀù0?Á ð×ÁkCÁ$å×Á2‘eÁ@ˆÁN„šÁ\%ÁjõÁxÑ$ÁƒJÁб{Á‘ÏÔÁ˜ô\Á¥l®ÁöÁ–£Á5pÁ‡çÁ€˜ÉÁr¦°ÁdBÁUç·ÁG­&Á9Á+ØhÁ.÷Á‹úÁCåÀìx¥ÀÒÈKÀ¹mHÀ ®!Àˆâ¿ÀcH+À5óÀ ¤¿¿ÆÒØ¿|ž-¾ø¯e»ñüË>éè*?wé¤?ÀS|@êÑ@.„®@X>T@…¡@_E`@8s@Öí?ÔX?‡ÿ°?,¹<˜Ôâ¾çDZ¿ocñ¿ºùÏÀF½À*¤ZÀUŸàÀ‚ÄÌÀ›&¢À´‹ÀÀÏ&7Àê 0Á€ÿÁZÁÆÁ,£Á:ïÁH@ÁV. Ád]Ár—êÁ€szÁ‡¢ŽÁŽ×£Á–jÁ¢Ú˜Á›]Á“àçÁŒiÁ„ü¡Á{CÖÁlœ›Á]üÁOiÂÁAAÁ2϶Á$¬YÁ©¯ÁóäÀö‡ÀÛ/ÀÁ„À§ êÀŽ2¼Àk>}À:Ê#À Pñ¿½cß¿T(¾_Ñ>­bþ?T)…?§ºI?æ 3@,@99'@_¸d@„Ià@™GX@‰@jz–@CDÞ@I2?ñ+?­Ä‹?\ݲ>ÃuK¾Ö¿4à(¿ªˆ¿ÿ’ÝÀ/Ç[À`KãÀŠpÀ¥WÀÀ>ÀÛKwÀ÷#ÞÁ yÁŒûÁ%Œ+Á3³ÁA݆ÁP ŠÁ^VÁlÂïÁ{1#Á„Ð$ÁŒÚÁ“WÒÁ Q¶Á˜ËÉÁ‘N Á‰ÓÁ‚[{ÁuÇçÁfå‘ÁX+-ÁI‚ŸÁ:ÚÆÁ,EÈÁñpÁÎÁ«bÀç…èÀÌ.cÀ±,À–°ÉÀyˆÚÀEýyÀ ¿È™¿¿UÀ¾Ö9?¯Ð?(/?Ô“@ ‰@(þò@JƒÕ@lÑ?@‰63@œæ @±_‹@¢Ü@ŽZ@uÖC@QÅ@-¸@ ¸­?Ú,?—õÕ?½ç;‹KF¿*ª¿´ú¼À $¢ÀAzÀwD=À–­8À²HÎÀÎB Àê;OÁêÁD6ÁzžÁ-±Á;úÔÁJ\ÆÁX¾ËÁg"ŸÁuš²Á‚€Á‰stÁÍvÁžDÁ–hRÁŽÐdÁ‡D Á‹{ÁpœeÁa­TÁR¾FÁCÓûÁ5…Á&p`ÁÐIÁ 8.ÀõÕÓÀÙ”ÜÀ½…yÀ¡ß¼À†½‹ÀW»%À#ÒA¿à0Ø¿y¾[P¥?à?œ#³?ïÀ.@jï@>iÖ@`3ˆ@€]@Ü.@£:„@µØœ@Éïó@»JÄ@§Èƒ@”Ðþ@‚R@bÖF@A°ê@ êc?úôU?ªù$?&ƒ½¸@ÿdjB¿ÜÆ£À$“½À[­À‰yÀ¥€-ÀÁ–lÀÝÁDÀú4°Á TÁ ‡Á(uÁ6dhÁD˃ÁSLüÁaéªÁp—ÖÁGÂÁ†ü’ÁŽ^ÐÁ›ÇkÁ”,yÁŒ‘­Á„ø¦Áz¿½Ák¥Á\™‚ÁMªeÁ>»=Á/ÌÁ âÁ~Áp¿Àé’(ÀÌUþÀ¯ÑxÀ“ÃéÀomÀ8ÈîÀÀ9¿œë¾Óƒ¤>¾ë?‘¿n?ð—‚@$·½@N|@rdÊ@ŠFç@šÅš@«è|@¼ù@Ïð@⣧@Ô¥ä@Á!@®Ç@œ Ž@‹Î*@v5Ú@RØ©@)ëa?úܱ?™©µ>̨¾âO³¿¥íÚÀ TÀA¶ÊÀyãÀ™›Àµ–EÀÒ5Àî©RÁµ/ÁÈÁ"œ^Á19AÁ?Ö¤ÁN|3Á])%ÁkÝîÁz§ïÁ„Ä”ÁŒBÆÁ™©FÁ‘ûUÁŠV±Á‚»ÁÁvEÕÁg(ÁWâ{ÁH¸ŽÁ9¯“Á*À„ÁÑ©Á è‹ÀüìÀÞW¯ÀÀò½À£»À†[$ÀS´¸Àez¿È«¿6†<=òì¥?n/M?Ü­¥@ª2@O @{^š@’}@¤N@µ¬É@ÆS½@×½D@éh@üw@í¼ž@ÛDŒ@ÈWa@·+È@¦N@”Ù@ D@RET@ y?ׄ?VN`¼¾Dn¿b»x¿á—‰À)(ñÀaÛõÀнÀª'ÀÆì™ÀäÁ‹=Á!hÁÂHÁ,f+Á;¶ÁI÷ÁXâ¸ÁgÖíÁvÐKÁ‚æ{ÁŠe˜Á—æ^Á iÁˆa*Á€©ØÁq÷îÁb±cÁSrïÁD9:Á5WÁ%Õ¢ÁÅÉÁÖ¯Àñç•ÀÔ rÀ¶S(À˜ùÀuìÀ:²9Àr¿à¾z—J?à•?¹º@˜<@D†ñ@v%p@’ËT@¨ôÂ@½a@ÏH@ái@ò€tAÚ\A PAàü@ô˜»@â£:@Ñ>@¿œ@ªn¼@“7&@r~(@=oó@Ù1?ŸùÃ>Àãw¿w•¿±„XÀô[ÀK2ìÀ‚–&ÀŸ¾|À¼×ÅÀÚßÀ÷É9Á §nÁj~Á(MyÁ7@8ÁF3ÁU+ÝÁd66ÁsP`Á:ÁˆÌÁ–pÉÁޤ=Á†×±Á~MÁn‹ÆÁ_ yÁO”(Á@1-Á0äIÁ!žIÁXJÁiÀçâ4ÀÊ,À¬=ÀŽvzÀah4À&'5¿Õ냿?E%>ô?…1?ôU…@0©+@eòÛ@Œõâ@¦k@¾BÉ@ÔŸ@è¥Ü@ûVúAPÀAjýA˜A“ûA(ô@ü¤œ@êue@Õˆ-@½\Ã@¢ÜÁ@‡Ù@XÖ‚@!M¸?ÑÃþ?@û‘¾×}¿„6ú¿ø¦À6­DÀq×À–ÏÀ³äUÀѸ6ÀïŒðÁ°ÈÁ«MÁ$¶„Á3ÎWÁBêªÁR¼Áa$–ÁpF/ÁxÇÁ‡anÁ•òÁ@˜Á…l¿Á{:Ák âÁ\¶ÁL{8Á<÷¬Á-tbÁñÁy Àþ>-ÀßÐðÀÁoÆÀ£À„ÃÀMØÀGQ¿­…P¾ÛŽí>þI?´ ‹@c@Kàñ@C@œ@·Ñ@ШØ@éLŽ@ÿÏA A ÂAT0A%ZÙA8A)ýA ‚AUr@ç4¼@Ì%f@°é1@•NI@r»û@:X@äï?Ž?:>Es³¿<Ž¿Ó1-À$Ó_ÀaV¤ÀŽìôÀ¬îÀÊ̺ÀèüoÁ™üÁ¶$Á!ÒtÁ0ðjÁ@~ÁOL Á^‡ÁÁmË¡Á}$UÁ†HÁ”*ÁŒ8ÓÁ„T{ÁxáúÁi´ÁYc3ÁI¯JÁ:UÁ*qêÁîÁ næÀ÷ßœÀØámÀ¹öÀ›mÀzQÀ=.}ÀYª¿‡ß1¾½˜?MFÄ?Üê.@(Ô@@c3i@û«@ª"Î@ź@à° @úñÊA )AÁRAóHA)q¡A2~WA*#hA ïÜAÑA§Ì@õß?@Ú4@¾@R@¡Ú0@…O@PFÅ@ä(?´³Ä>ö‰¾î+3¿µÀ'0ÀSŘÀˆT‹À§`ÀÅe¹À㮤ÁÿÁ@íÁ‹lÁ.ÔºÁ>ÁMglÁ\µÁlTÁ{Ž^Á…‚ØÁ‘ÈÁÁŠ‹ÁƒcûÁw"ÌÁg[ÁW–IÁGÕ^Á8¾Á(\ûÁ¢/ÁódÀò°¼ÀÓ’#À´sŠÀ•TòÀldÕÀ.‰“¿ã Ò¿R¯‡>êW?‰“$@—@Á<ƒ>ÁKÜiÁ[FgÁjÁSÁz=ÑÁ„Ý-ÁŽ bÁ‡?¦ÁÒÐÁqQÁc ÁTì·ÁF_¡Á6šÁ&Ú±ÁÇÁ\ÜÀï;äÀϽ½À°7ÀÂ÷Àbè&À$”L¿ÌÈ­¿!Öî>¬Ç?¦íü@H2@Lì¢@„ÊË@¢”¹@ÀN@ÝŠi@ú~gA ƒØAŒÚA'Q?A4ÀAAlµALˆA@7\A2fA$gA=MAì¸@òUX@ÔŽ@µ4 @–X¹@o"„@1¯Y?ç¢?Vl:¾ JÿÈÎÀ$!ÀC‚4À€Ž[ÀŸ[œÀ¾+ËÀÝhÀû÷éÁ zjÁøàÁ,v–Á;Ø-ÁKDÙÁZÄ`ÁjHÁyÉ£Á„¢zÁ‹®Á„2ÚÁyÁjÎwÁ\ËÁM—Á?@CÁ12dÁ#ZìÁïöÁUíÀìÿ‹ÀÍa4À­ÕEÀŽJÁÀ]€{Àkt¿¾±¸¿5w>õ64?º›L@ô…@Yã@‹Ö€@ªÀï@ÈÿÙ@ç<"AzuA,ïA´úA.±A<¨AIæUAU:AGVöA9òA*ˆgAZA Ñ+@øa²@Øùï@¹~c@™þV@uJ¡@6ž‹?ïäê?e\k½£t翆ÆVÀª¯À?ô/À~@™ÀžDMÀ½hNÀÜŒOÀûŠˆÁ 0kÁ›“Á,¡Á;wíÁJ÷ÝÁZ{>ÁhƲÁw3Á‚½ÀÁ‰žÁUÁsÙ<ÁdÍ ÁUä=ÁG‚Á8_Á)ÊõÁ~‹Á }÷Àÿ‘ÿÀåIâÀËÌ_À¬QCÀŒ™ÖÀYÄÖÀ[ð¿¶-³¾ß‡G? Ô?ĵð@!€è@`«y@½@¯@Îc+@í¶7AoÎAÍPA$à>A3²ßABJwAP¥îAQÁnAC';A4ÂÓA&‰®AyFA ª@÷?@×»P@¸W4@™K@sÂ~@5VÇ?íäp?br½·&¿ˆ À}ÒÀ@Á2À~ëâÀž‹ÆÀ½¡ÛÀܲ`Àû¸nÁ _xÁˆTÁ)Ù[Á7lÁEXÕÁSÊÁbÀÁp¬¹Á}Á†ÉÁ~VÈÁoùÁ_³‘ÁPmwÁAEuÁ2C7Á#oñÁ®:Á  ÀïãÀÓªÒÀ¸ÀÀžøøÀ‡AìÀXË+ÀvÓ¿´Ej¾Ötµ??Ç‘ø@"ÿk@b4V@œP@°u@ÏšR@ïŒA3cAÍsA&j&A5¬ÃACè.ARcAL¤åA=¦AßSAµq@뇣@Ð \@´+e@•¸+@m}«@/ž}?⺙?L4¾4Nm¿’;ZÀFÞÀEdˆÀ¥îÀ ¦’À¼•„ÀÖÁSÀññ‡Á¿ÁGÁ"Á0:ðÁ>®WÁM\•Á\9åÁk=$ÁzMšÁ„ã}ÁzPˆÁjì‚Á[j,ÁKô˜Á<Œ¢Á-'3ÁÚÁµ)ÀÿŠRÀâ ÀÄž/À¨ßÀŒ•°ÀdÞ2À4ÚÌÀ oÓ¿³›Í¾ÔÝ5?ìŒ?Ä*Ñ@!×@`1ý@3S@®M¨@Í,o@ëÅA.ÐAMA#*&A1žÄA@-hANˆ&AH7 A9EA)ñ,Aÿ}A )ý@û)¡@Þ1x@ ±@¦ºƒ@‹|8@`²¶@%Ó"?Ñ­ ?.z%¾ˆó߿ʲÀ ¬6À?™ÀlèÀÍ Àª®ÀÆ6àÀâ“êÀþ$YÁ Á‰ôÁ*>Á9%.ÁH,ÁWEDÁfsqÁu¼1Á‚;@ÁuþÁg£çÁX§ÁHIÙÁ8HÁ)ZÁwÕÁ VÀõGæÀÖ™åÀ¸\'Àš»]Àz‚YÀAžîÀ ¹¿·„8¿Yξ°¹Í?c_?¿¦ß@[@ZQH@‹š@©Ÿa@Ǭï@å¬QAÃŒA“GAHA-é‚A<|6AK‡AD©øA5+&A%ÄáA~³Acx@ðô=@ÓR@¶jÏ@šÖ@|·Ð@F›½@Ï„?½nþ?†¯¾žã™¿uÆm¿Éw÷À‡ÀFß À}r6À›C À¸%`ÀÔâmÀñj0ÁO6Á0ÍÁ%GïÁ4‚ÁCÉÌÁS(ÁbœÔÁpçÕÁŸ¼Áq ¿ÁbvòÁTŠÁE³¥Á5ìðÁ&zÁFÁ{Àí|ØÀÎ,óÀ¯ÆÀW¨ÀcLÞÀ'Dñ¿Ù8H¿Rz•½‚k.>Pçè?ó?¹ R@é¯@O€Ú@…l@¢µ.@ÀwÌ@Þ7Á@ûþ\A ÅsA¹†A*³ÈA9pÇAH\ØAB^A2¬¾A# 2A{°AO@éu«@Ë@@­RÜ@áâ@fà@0:š?˜œe?0ŸÈ>¬ßÞ¾&$|¿eЮ¿Ý|ÁÀ'máÀaO¨ÀŽÀ¬ŒÀÉ HÀçimÁÜCÁ.EÁ!‡þÁ0éöÁ@dnÁN‰FÁ\ëËÁkƒ¯Á{±ÁlïoÁ^:{ÁO„ÁA¾Á2£AÁ#÷×Á÷Á;vÀèÇ{ÀÉ/À©wiÀ‰×ÀTwÀ}·¿¯í…¾á^6>ÎÌÏ>ƒEE>Úçå?˜¨@þ@>«@yŸJ@šrª@¸•]@Ö`@ô”~A }ÝA·A'úOA7!!AFPsA@ø=A1/(A!göA«ïA@äØú@Åõå@§}í@‰•l@Wñ@,Š?ѬÆ?Z‘d>ÓŽ:? ÒÏ>û0ˆ¾Â®]¿¤èÒÀ>ÀJ4Àƒo¥À¡èNÀÀmiÀßU)Àþ-Ám%ÁÞÁ,½MÁ:üuÁI ÁX3ôÁf÷=Áx¸¿ÁiºéÁZÏ>ÁL RÁ=ZoÁ.¨ŽÁ 6½ÁÐXÁmgÀåRÀÅË!À¦ZÆÀ†¶¦ÀN'ñÀ„5¿¤¿6¾°Ð+>¨½ iÿ¼”(i?Tµu?áH~@+þâ@g÷ÿ@’€Š@±@Ï¥l@î$ºAièA×^A%SA4ØnADk0A@Z®A0“A ËçAéANò@ãV-@ÄId@¥[_@†N,@OHÖ@ª¬?´xº?ò0¼58%=“{Š? ¢c½Tœv¿{³¿ö&ÇÀ8™uÀvwÀšÅÀ¸ÍlÀ×ÙÕÀöêÁ ÖÁãXÁ(5£Á6Ï8ÁE…íÁT[!ÁcXßÁv»1Ág‘ÁX}¡ÁI?Á:ÍÖÁ,@ÁfEÁøõÁ)Àá\ÀÂ2À£­1À„â•ÀLÎ\À‰¿¬¿ >Á¾ ¸º¾àb¾ÑR$?ø?¾œG@Íg@Z Û@‹´È@ªÊ¯@Ê©@ébcA<AÔA#€A3:°ACA@¿×A0þšA!=]AtQA²1@ãþz@Ä»£@¥}ö@†W @NËM@Iê?©ÒÈ>Ý/ʾ¢N¾ûR“=²K»©ê ¿Yì¿ãƒÀ.—àÀkKÀ”^ÎÀ³5ÀÒAÀñHŽÁ^Á~üÁ%£Á3¹¼ÁB™sÁQnÁ`¬¹Áu‹ñÁfy¡ÁWVÄÁHRjÁ9s„Á* ÎÁý¾Á ”…ÀýìÀÞÆpÀÀeÀ¢‡•À„²kÀN3]Àq¿Ãõ"¿d·…¿$Åy¿nù¿#e1>¤Ý³?¤÷@ þ@OäA@‡T@¦¶@Æ@åéAƒ®ASöA"- A2 ÎAAìóAA¶A1÷•A"9BA{ A¼Ú@åý¾@Æ•É@§W@ˆUÇ@R¶³@¿€?­±æ>Ò9¿‹C¿‰m¯¾ù7Û¾¾þM¿un(¿áé•À*ܾÀf7ŽÀ‘e?À°<»ÀÎçTÀíu§ÁiÁÁ#!Á1çCÁ@Æ_ÁOÏÁ^ã:ÁuK–Áf5ÁW5ØÁHC±Á9tyÁ*™ÅÁö Á ŠRÀýWUÀÞÝ3ÀÀÈÀ£kŸÀ†½¹ÀUmÀ"ò¿ì^E¿®vU¿™nˆ¿¾Â¿KÕj>>Ï·?•¥Õ@ ¸Ú@HªI@ƒø¸@£¶‚@Ã@ãJAŒüAvQA!_»A1DAA¥ACvA3EŽA#†§AÇ¿Al@è@Èõ9@©v#@Š&@U÷L@Åè?³<>Ùò¿þW¿¾_¶¿‰µG¿gÏó¿¡v£¿÷¯‘À0ƒÅÀhÇbÀ‘`¹À®¾©ÀÌÊÀë5ñÁêÊÁüiÁ"|Á16/Á@!ÁO4Á^;ÉÁv Ág ½ÁX ÕÁIBhÁ:JÁ,gÁrÁ„áÀÿ]Àá8ÛÀÄ,À§lßÀ‹ØŽÀd{oÀ6»xÀ€â¿òÖ6¿ès?¿ï×ö¿b|•=Ù!;?Œ¢.@Ù$@Ea2@‚tŸ@¢8ù@Âï@áÒ AÏ•A¶$A œÚA0†ÁA@t6AAíöA3eA$jA³yAçË@ê:½@ʨ­@«@‹u*@W„Q@+(?³t>Ú‡µ¿ ë ¿ÁŒù¿Ù@u¿À±œ¿ÝpåÀÈÑÀ>Àqß…À”›åÀ°Ã™ÀÍäÀë¶ÆÁîëÁ,fÁ#D¾Á1æÚÁ@§¨ÁO–ÍÁ^ª*ÁwèÃÁhý•ÁZ6ÍÁK‚æÁ<ý Á-ξÁ¼™ÁÙÁ[Àå ÀÈÌ¿À­¡·À“ö>ÀyQóÀP®|À0êÃÀí|ÀÁÈ¿÷±N¿q z=Tú„?…Ôe@€{@Aë@€¤R@ S@À4@ß¼«@ÿu"A’bA[«A/$óA>Þ?A9ªzA,sÉAgLAãÉA,“@ä_x@ÆÈ@§„V@ˆÅ²@Rë@M°?«¨P>¼xå¿=¿Ë6vÀÜFÀ –Àþ’À,ñïÀTtáÀxjÀ› qÀµËÀÑÓ Àî¿ÌÁ$îÁ'âÁ$Á3ÜÁBÁQ*ûÁ`! Áz½ùÁl¨Á]CÜÁNñÁ>çÍÁ/ñŸÁ!.‡Á¦Á\LÀ즳ÀÑŒÀ·¦µÀŸÕ?ÀŠZ¥ÀoÍ"ÀU4”ÀG°À?ù=ÀÀ4¿ƒU½Àî?r€õ?÷ Ì@:wa@yˆÄ@œPó@»Ý„@ÛBº@úKÀA ªcA€A+ žA.ìÅA,QÌA#$AŒ"Aá¯@õ‡@ؼ@»xÉ@À–@ƒj@Bïì@;?’ªý>IÚ8¿EݿߡfÀ-ËÀ7åœÀ<á@ÀR‘ÀpÁ,Àc À¥#gÀ¾1ÀØ¿ÀôvÞÁvÁKÁ%¡ÝÁ4ažÁCSÏÁRm±Áa§MÁ}â>Án»ûÁ_¨ÁP¨¶ÁAÈØÁ3»Á$–+ÁihÁ™ªÀöGmÀÜtíÀÄuÀ®*ÀšB«ÀŠ’eÀ~Q'Àsî6ÀGèÀ ò¿”>«¾3»?Mð ?ãöÚ@/Îî@m£í@•Òç@´Û¹@ÓH@ñ\âAxÕAèHAõ‹AíéA òA!\A “zAM@æ"‚@ÊŒ»@®?@‘¡ë@h½6@.6•?äÊÊ?[e½ v$¿ƒ–Û¿ý%À;1¸Àg*ÀiÆ Àz—²ÀŠœ¯ÀœK°À±üñÀɱÐÀâm²ÀüÈóÁ (ÍÁ[†Á(£Á7$ðÁEßÁTÆÁcÈUÁ€FæÁq—ÃÁbÃZÁT]ÁE’•Á7A^Á)9ãÁ‰Á1©ÁLŠÀê+aÀÓ›À¾¹ÅÀ¬®ÚÀžK¸À•S=ÀˆŸFÀRç®Àhi¿¬Te¾Âí²?»?ÆZ8@ Y¹@\Û*@Œ®M@ªf@Çò'@ä—Y@ÿƒÞA 1A PJAï A q¸AÎäAØó@ìC@Ô/@º:s@Ÿ„@ƒPs@N'C@VC?µ‘{?ìà¾ÒKο«ÄêÀ{qÀMÀ„¥DÀ ÓÀ“qŠÀžàÀ®_gÀÁÜUÀ×éÀïZ€ÁàÁ@VÁæÃÁ,â"Á;XÁIbÁWðØÁf©ZÁ‚ÿÁu\UÁfÖGÁX|wÁJYíÁ<bÁ.Ú¯Á!…åÁ 8ÁX.ÀùÐÓÀäˆÈÀÑN)ÀÁm-Àµ-‘À¬á#À›Àa êÀ#ž¿Ì*ã¿"ç£>žžÀþ%FÁ Õ²Á`?Á$vPÁ1ðSÁ?̾ÁMÍWÁ\¼Ájp-Á„0=Áyû ÁkÃ>Á]É¡ÁPuÁB†Á5D%Á(yãÁG+ÁÄ4ÁÍêÀ÷–ÏÀæJ³À×Î@ÀÌ‹öÀµÏ9À—^wÀqäóÀ5VÜ¿ò׿v**½üž?c¥‡?æ{Ä@,Q@c‚G@Œ’d@¥jK@»9¹@ËGÁ@Õ'‹@ÛµÙ@Ýâ¨@Ûùä@Õ>å@ÊA@»„†@§Ã‹@‘Äâ@t°@B ÿ@—ÁÀ·–×ÀÄjÀÌãRÀÙzÀèå·Àû;ÁßnÁûYÁÎÓÁ+<Á85êÁE…&ÁS§Á`îÅÁo Á†ÀêÁz Áq™Ácï1ÁVƒlÁIfÁ<·Á0ŠÁ$ö&ÁÖ×Áš[ÁpiÀýíÀïFCÀÝa8À¿&…À¡:ªÀƒY€ÀKÏÀ²¿ªaǾÙ4Ñ>ía?ª!í@ H@?Y@pi@Ž6@ q×@­XÃ@¶•@»üª@½äð@¼\þ@¶9n@¬å”@ŸƒÚ@%@@ušÇ@IHb@­ß?ÓLÊ?Y .“ÁÎÁ b1Á¾›Àç›úÀÉÛuÀ¬:À îÀcK)À)‹¿á@¿b¼ìnï?MŒÐ?Ì6]@ß@BoÓ@iÈ@„˜@ŽÓN@–Ï@œCz@ç7@œtD@—#X@Žï@‚ä@@h{¯@D‹ @µ³?Þ?|>„˜w¿ ¿®ŒÜÀ ?.ÀBCâÀyã À˜ÞÀ´]uÀÐîðÀíD!Àÿ÷$ÁÜÁ €ÁêÁø*Á%çäÁ0uvÁ;²€ÁG–+ÁS÷¿Á`¦ŒÁmºÁ{$gÁŒß«Á†%ƒÁ!ÿÁrN&ÁeÕ•ÁYÇ×ÁN°ÁBíïÁ8QøÁ.$Á%¥ËÁºbÁÈÓÁGhÀòÿÀÕßHÀ¸¸¡À›÷ÉÀ/«ÀF„bÀ„¾¿²ts¿^ã>Q×w?p*Á?Ñ|@¼’@1û¨@L¯@`‚"@o Ò@y•@{Òý@y@o©Ð@`·£@K]<@0Ov@H“?Õ=u?ƒ—~>¦:־Ɏ¿’¹ƒ¿÷–´À/K“Àd^èÀŒ«ôÀ§ÞÀÃa²ÀÞøžÀûHIÁ ©ûÁÁ@ÁÖÁ'>¿Á0‹zÁ:•dÁEA&ÁP›™Á\…›ÁhÂZÁufÌÁ5HÁrXÁ‰ä×Áƒ€\Áz–`Án™kÁbïÃÁW­ˆÁM ãÁC<Á9Ú6Á1„¿Á)ð³ÁåWÁXPÀÿºÕÀãØÀÆÎÀªrýÀŽ˜OÀfÝõÀ1އ¿ý%K¿™XϾïÓ>j˜R?]‰è?¶3ì?ò2T@`À@"ná@0Ï@9¢6@;׌@9Ež@0¿ý@"¬µ@ä’?îí?³y¡?^(>…›K¾Àj&F¿å½ÓÀ#HÀTeÀƒÙÊÀÑÀ¸_üÀÓ@¾ÀîjÁánÁÌUÁŒ'Á%;Á+}fÁ3%ÔÁ;ÛõÁEU…ÁOsçÁZF¼Áe³Áq~íÁ}³ÙÁ…'ÚÁ”]†ÁþXÁ‡ËNÁʽÁxÂÁl¼PÁa÷4ÁWØfÁNwMÁEÖýÁ=ÆÁ1ÉšÁ#^›Áü~ÁÖõÀñv±ÀÕ|ÅÀºEdÀŸ”À…%­ÀWŸ[À&£’¿ïþí¿– È¿ /¤=10? NŠ?yñ…?¦´Ç?È·A?äô?ô_®?÷¸5?òèS?ãÔÛ?ÉCŒ?¨9l?rŽË?ÑÓ=©¸¿Ò¿‘Bå¿ãÌôÀì?ÀLZÀ|}ûÀ–{ÊÀ°!ÝÀɪFÀä‚Àþ½Á î™ÁUmÁ(EÁ2zÁ8üÁ?¥ÞÁGЫÁP³DÁZV×Ád¨Áo—ÁzæÁƒUhÁ‰n‰Á˜—ÂÁ’dÁŒ^xÁ†¨Á€øÍÁw.ÃÁlßöÁc1÷ÁZ>ÁR ÁFÔ|Á8yRÁ*FåÁ1@ÁBÃÁ{hÀæFSÀ˺À±žØÀ˜ª6À€M_ÀRŠÀ%þ¿øô˜¿«r©¿M] ¾®và=3ŸÑ>²?ì”?J:l?j—Œ?o‚¥?fŠÕ?LoÄ?[^>·‹ä<âë{¾»Ÿ‘¿S½d¿¬ïÊ¿ô›•À!ôÀK¿—ÀxÅ\À’ðèÀªü×ÀÂôpÀÜe^Àõê²ÁØ®Á!¥Á"}ÒÁ/à,Á=]ŽÁEвÁL‡,ÁT!Á\sèÁe¡jÁo†ÈÁyýïÁ‚iÜÁˆMÁú:Á $Á—ÐÁ‘2qÁ‹•)Á†5äÁ +Áx+ãÁnîòÁfoæÁ[Ö7ÁM¥xÁ?­pÁ1Ç$Á#ìˆÁW&Á À÷Õ˜ÀÞ&(ÀÅ¥´À­HôÀ–×À(ˆÀVf¬À.¢ÌÀ 3¿×¨Ç¿ Žb¿gÀ¿xI¾Äƒî¾N8ÀÚ%ÀÃŽÀ¬ ÇÀ—þ¾ÀƒëÀcˆHÀBJ À$¿À d ¿íìÄ¿Êâ§¿®'¿˜¬G¿Š<¼¿ˆ,r¿Œh¿•, ¿¬æ…¿ÊH¿묢À ‚PÀ%íÄÀCŠZÀbÔeÀƒBÀ–pÀª•îÀ¿ºÀÖ$LÀì“Á7Á»ÁzÁ'ACÁ3ÏdÁ@¬6ÁMÜpÁZüDÁgDFÁméZÁuf#Á}­ÁƒUnÁˆ&ºÁ.Á’nùÁ—í<Á¦¿ÒÁ¡mÁ›£®Á–jPÁ‘lcÁŒšíÁˆÇÁƒ'ÃÁx‹_ÁjÖÁ] ôÁO ÁBHAÁ5C}Á(R ÁŸ4Áh Á©Àð,ÀÙ­ÂÀÄÊ'À°ÂcÀž$ ÀŒ¦ Àz¼iÀ_(ÙÀGHbÀ3ÿ]À#„”Àƒ©À ȃÀ~ÀªÀÑÊÀ 5MÀKàÀ#/OÀ2ŽpÀH ¿À`¾ÊÀ{ÀŒwÀOÀ¯…ªÀÃkÀ×lYÀì¨MÁZÁ ´§Á“Á$r_Á0®ƒÁ=AÁIźÁVhEÁccgÁpUÄÁ{[{Á:PÁ…)ÙÁ‰sÙÁŽÁ’èBÁ—ùöÁF±Á«ô!Á¦y Á¡3éÁœ(¢Á—IÒÁ’®Áç¬Á‡IÁ€3ñÁrÉ Áep÷ÁX`ËÁKsÉÁ>ŠÁ1æ@Á%¾ÛÁû¶Á—Á]|Àñ–OÀݲÀʘÅÀ¸À À¨žkÀ™ÛEÀŒåwÀ‚ fÀq@wÀa™yÀT¼ÀK:âÀDâŸÀD ÀE£øÀJÀT\Àa:>Àpw™ÀôNÀQÀš<‰À¨ö\À·»¥ÀÉ4¯ÀÜÀïÅ–Á!bÁ ËeÁìÁ#©Á.éÃÁ:¤hÁF­pÁS.=Á_¤TÁlóÁx¿âÁ‚ÂÛÁ‡éÚÁ‹©0ÁÁ˜Á”"|Á˜ÅGÁ­%Á¢Ó˜Á±]€Á¬ÐÁ¦ôÔÁ¢¬ÁRÁ˜§6Á‘ÝDÁ‹ ÊÁ„QºÁ{z~ÁnuÚÁaˆÁTµŒÁH3xÁ<$aÁ0|€Á%"kÁä'Á8ÁAgÀ÷ºÀäú™ÀÓø_ÀÄÓ¢À·@Àª¢ŠÀ £”À—Ÿ#À ÀÀ‰{QÀ…VÀÀ‚b`À‚FÀ‚»À„ë½À‰tlÀ©jÀ—BíÀ  9À«½À·œNÀÅGÀÓsÀãtºÀõcrÁW?Á?÷ÁƒúÁ#,NÁ.4²Á9frÁE)^ÁP¹YÁ\®\ÁieÁut³Á€ÖÞÁ‡VÁiRÁ’N©Á–4JÁš]9ÁžÑ~Á£ŠòÁ¨ƒÃÁ¶èôÁ±ÊÁ¬ÐŸÁ¨ ÉÁ£T2Áœ¡PÁ•âˆÁ4ÉÁˆ©]Á‚1±Áw™*Ájì–Á^ŽÁR“ðÁG½Á; µÁ0c Á%¬ÝÁ¥0ÁÎ)Áµ´ÀÿÆâÀðÏÀáWSÀÔP ÀÈÊ;À¿dÀ¶9À¯PûÀ©'>À¥æÀ¢SˆÀ¢ÿÀ¢¤,À¤ÔxÀ¨Û«À®Ó0À¶J À¾UÓÀÉ«ÀÔúÀá²ÀðÅÀþoÑÁ¬ŒÁò7ÁXJÁ$d¯Á.ÌÑÁ9{µÁDz%ÁO­LÁ[aEÁfÏIÁr³ÝÁ~ä°Á……Á‹"Á‘ÇãÁ—ÿŠÁœÂ”Á ÀÁ¥EÁ©•nÁ®b-Á¼šÁ·£ÌÁ²Ö(Á­ý0Á§cÁ ºöÁštÁ“šËÁ2SÁ†ÜŠÁ€™HÁtñæÁi ÅÁ]nõÁRQÁFÑÁÁ<%™Á2ùÁ(ßÁàgÁòvÁ ²‚ÁÔÀþvÀñÆÄÀçHÈÀݘçÀÕ}ÒÀÎÆÀÈànÀÄÕÏÀÂDÛÀÁÿ·ÀÂCÀĽ2ÀÈC’ÀÎ3›ÀÕQ.ÀÜþ±ÀæüÀòGåÀþÙ6Á/ìÁ ;ÚÁí(Á²"Á&êèÁ0d¢Á:¹ÁE¸ÁOÌÁZ¿™Áeô0ÁquóÁ|³šÁ„4eÁŠBjÁ;>Á–?›Áœl_Á¢Ÿ…Á§F‡Á«düÁ¯ÇþÁ´jŒÁÂtÖÁ½¥ÇÁ¸´ºÁ²*ÀÁ« >Á¥ ØÁž™Á˜>CÁ‘õùÁ‹ÁóÁ…®OÁ‡,ÁsÝQÁhfGÁ]@âÁR•ÎÁHlÂÁ>j©Á5@Á, Á#wøÁ­?Ái¼Á àoÁÕŒÁÔÀü^4Àô}ZÀíÊÀ虞À䕸Àâ6HÀáýpÀâq„Àä¥ìÀçÆ&ÀíÓÀôW3ÀûìÌÁ–ÔÁ „Á ÝÁt­Á…—Á"¥^Á*ÄjÁ3§ÈÁ<ÖåÁF}ÁPÏSÁ[bŸÁfzÁpüAÁ|·ÁƒœHÁ‰9*Á mÁ”þÍÁšíñÁ ë¢Á§ 8Á­:GÁ±ãÁ¶ŠÁº˜ÏÁÈuÁÃiáÁ¼õŠÁ¶s¿Á°ZÁ©žBÁ£PlÁßÁ–î?ÁäÁŠÿ¥Á…&DÁ~̤Ás°PÁiÅÁ^ÑõÁTÈiÁK.3ÁB'‚Á9pŠÁ1IÁ)ÀÞÁ"ótÁ…zÁð{ÁªÁ ¥pÁ Ë’Á‰*Á)gÁ*ÑÁâÁõ Á)~ÁGSÁ³4Á„Á ­GÁ yöÁ¸ÌÁþ9Á¹ÅÁ#¢Á)ͤÁ0¿ØÁ8@"Á@µ©ÁI›>ÁRËgÁ\£pÁgüÁq­áÁ|QÎÁƒ{\ÁˆÿèÁŽ}™Á”Á™Ü†ÁŸ¿ŽÁ¥£øÁ«”ZÁ±¤RÁ·Ð@Á¼•rÁÀéRÁÎNÁǬÁÁJ—Áºá‡Á´’§Á®UœÁ¨-þÁ¢ÿÁœ Á–&ÛÁU½ÁоÁ…üÁt Áu9Ák+®ÁahŸÁXJÁOzÚÁG0Á?C‹Á8QÁ1ŒÁ+]ÁÁ&HÁ!IdÁàÁlãÁ?VÁþÁ VÁ ¥ÁëÁÁ;°ÁeÁ9#Á7<Áý‡Á ü‡Á& nÁ+Š-Á1ƒ‹Á8ùÁ?!ÁFìÁN ÁV©&Á_ŽçÁhÞíÁrßÀÁ}\gÁƒÑªÁˆõðÁŽD Á“À2Á™P ÁžãaÁ¤£Áª„aÁ°\àÁ¶A´Á¼G†ÁÂo[ÁÇXÒÁÒcýÁ̪ÁÅÁµÁ¿q¸Á¹>Á³.Á­,rÁ§$ÈÁ¡D†Á›ˆÁ•×oÁHŸÁŠñÈÁ…ІÁ€ÁˆÁw¯|Ánm÷ÁeŠ Á\ô)ÁTÞ•ÁMj³ÁF¡»Á@*GÁ:\pÁ5MµÁ0™:Á,—¾Á)1Á&xÁ#âùÁ!ô?Á!lÁ àõÁ!ÊÁ"*¨Á#nºÁ%î?Á(ÕtÁ,€KÁ0[áÁ5'‹Á:ƒaÁ@ÁFgÁMJvÁT+Á[ª÷Ácô/ÁlœÑÁu‰jÁ /Á„–„Á‰2ÁŽŠËÁ“§Á™ËÁžºÁ¤vÁ©° Á¯j¶ÁµD­Á»¤ÁÀöÆÁÆú´ÁÍtÁÖåMÁЛ–ÁÊR–ÁÄ# Á¾ÝÁ¸*{Á²=¢Á¬b”Á¦³<Á¡zÁ›„Á–#cÁø¥Á‹è Á†ûòÁ‚I Á{ŸçÁrûüÁjš ÁbàÆÁ[Ì&ÁU5‘ÁNó«ÁIqBÁD†oÁ@ÝÁ<ÈÁ8¿~Á5ÑïÁ3ÂeÁ1Þ^Á0þ6Á0ÖéÁ1 òÁ2ËÁ3UMÁ5¢ªÁ8ƒÁ<øÁ?Ð8ÁDH.ÁI†yÁNãÃÁTá?Á[Œ,Ábg;Ái†œÁqn,Áyâ~ÁGwÁ…ÎõÁŠ¥ ÁšƒÁ”T¯Á™?•ÁžjàÁ£ÐxÁ©`8Á®îÁ´|úÁº2.Á¿þ—ÁÅÑKÁ˯‹ÁѰ²ÁÛs·ÁÕ9©ÁÏ8ÁÉ 5ÁÃ"~Á½R|Á·€ñÁ±ÓÄÁ¬EFÁ¦ÀÁ¡WÁœ¶Á—™Á’ 'ÁY¹ÁˆÝiÁ„~Á€>[Áxt*Áq¤ÁjR—ÁcÐÙÁ]ãšÁX—øÁSÈ-ÁOy4ÁKýÁHhÌÁE§¹ÁC¢YÁAÊéÁ@öÁ@ÌÝÁA8ÁAüíÁC?ÖÁEZ+ÁH8*ÁKƒ¦ÁOBHÁSƒÁX4Á]Ö”ÁcztÁi¼³Áp§ŸÁw÷ÁuÁƒ©¸Á‡áâÁŒBˆÁäÁ•£ÁšN·ÁŸ »Á¤ @Á©AÁ®«XÁ´2½Á¹»éÁ¿HSÁÄõ¹Áʾ¿ÁЋZÁÖhŸÁàUÁÚaÁÔÞÁÎ ÙÁÈV@ÁŸ‘Á¼ôNÁ·eçÁ±â Á¬ƒ'Á§IÁ¢52ÁE+Á˜pHÁ“ÞqÁ{ZÁ‹0”Á‡oÁƒA¯Á}ÁxÕ§ÁrÁlã†ÁgÇÊÁcáÁ^ñÁ[3=ÁXœÁUvŠÁS‚NÁQ¹RÁPìÙÁPÂÒÁPûZÁQæÁS-oÁU”ÁWíFÁ[vÁ^³ëÁbÍ€Ág—FÁlÓÎÁr?]Áx$uÁ~³‹Á‚ÈÓÁ†k&ÁŠj¾ÁŽŒaÁ’ÌnÁ—$Á›®îÁ [àÁ¥ûÁ©ØŠÁ®ãñÁ´%–Á¹ŠÁ¿&ÁĆ3ÁÊÁϺ¦ÁÕ€VÁÛM"Áß/ ÁÙôÁÓ$ÁÍ)ÁÇD=ÁÁ†5Á»ò3Á¶zêÁ±‹Á«ÔGÁ¦¥Á¡£KÁœÀcÁ—üêÁ“€¨ÁÓÁ‡¨Á€$,Ár¢;ÁeÓÁWÚ ÁK"Á>‘áÁ2WüÁ&¸ðÁáÁ×ÃÁwcÁg•Àó¾+ÀèœñÀáMùÀÜ›sÀÛä…ÀÝü—Àãš,Àì'åÀ÷òÁ9Á JÁ« Á¾Á)´Á5XîÁA`%ÁM¯6ÁZw¬Ág¦ŒÁu+RÁqˆÁˆ),Áަ+Á“ âÁ—OçÁ›µµÁ aîÁ¥LÓÁªHõÁ¯[¼Á´¤;ÁºdÁ¿ÀcÁÅnÔÁË):ÁÑhÁÚ/9ÁÓû“ÁÍç±ÁÇëìÁÁñÁ¼ ïÁ¶K=Á°·EÁ«éÁoUÔÁbøÁTáãÁGFÁ9[òÁ+ÅIÁ”ªÁô1Á¸hÀôÀÞåÀË:ÙÀº’jÀ­—¢À£íÀžvñÀœï¥ÀŸÆâÀ¦ÔÔÀ°ëÌÀ¿hSÀÐXõÀä6%Àù¯Á^»Á†õÁ!+Á.2<Á;ºXÁIi6ÁVÀÐÁc§âÁpã$ÁzG_Á^eÁ…°7ÁŠ.ÁŽúlÁ“ïðÁ˜ñÁž*Á£œ•Á©@ÈÁ®÷pÁ´¸2Áº™/ÁÀ¡PÁÆÍÁе³ÁÊA¡ÁÃàŒÁ½žðÁ·€Á±‚€Á«Š«Á¥žNÁŸÞSÁšDvÁ”ÀìÁc@ÁŠ8ùÁ…*ýÁ€5ÒÁvÅÁmË<Áe‡ÁYRêÁKÔ—Á>¹˜Á1P£Á#‘7ÁþÁ’ÜÀ÷ŠTÀ߬ÀÇÍ`À²ÔÀŸÝkÀɘÀ†ŠÀ=¢À{hVÀ€×vÀˆÈqÀ”Â(À¤bæÀ·Å¯ÀÌíhÀãæiÀüj¶Á îúÁCŸÁ%Ö7Á3ƒäÁ@`ÛÁMkHÁZµPÁd¬ÁlËpÁuqEÁ~BŠÁƒÙrÁˆÉÁÂ%Á’ñjÁ˜_Áž²Á£¿5Á©„lÁ¯hÁµu2Á»§¥ÁÁö¿Á̰ÁÅ›Á¿(@Á¸À¯Á²w Á¬QÄÁ¦R,Á [¥ÁšnJÁ”­YÁ Á‰„tÁ„-›Á~¢ÁtèÁj'ÉÁ`­"ÁW÷ÇÁOÐÁCsÜÁ5¾§Á(pÜÁž\Á ×_ÁJVÀå»ÀËeÀ²Ô°À›ÁxÀ†Í[Àjÿ€ÀP©cÀAÑÿÀ=÷¾ÀE*èÀWFÉÀrÂqÀ‹wÀ Q)À·C˜ÀÐ ˜ÀéñÁ_-Á9Á=.Á* }Á7=|ÁD“äÁO ÁVéÁ_‚Áh7ÌÁq{ Á{MÖÁ‚˜üÁ‡¼°Á$ Á’ÈúÁ˜‰ùÁžTµÁ¤;WÁªMÛÁ°‡»Á¶ßfÁ½CÁǪ¬ÁÁÞÁº€ÔÁ´3Á­§Á§T•Á¡(EÁ›#³Á•--ÁBÞÁ‰SÁƒ×qÁ|–MÁqùØÁgØ¿Á]ÙâÁSôÁJ³kÁB@ÐÁ:NÁ-§OÁωÁCÁB&ÀðÍnÀÕ$+Àº¥ªÀ LÀ†æ[À_äÀ7‚À; À¢ŒÀwÀ ï–À ´À?î ÀhQ8À‹ZÀ¤(À¾>6ÀÙ4Àôd„ÁÞÇÁÍÁ!+Á.“Á9¬ëÁA2lÁI“ÁR?þÁ[LmÁe _ÁníbÁyåÁíðÁ‡‘7ÁXqÁ“)¨Á™ÇÁŸ,MÁ¥nbÁ«ÏzÁ²<Á¸«•ÁÃY}Á¼ª)ÁµÿÚÁ¯lÁ¨öŒÁ¢ÕÁœ8´Á–sÁõ·Á‰þ´Á„FÁ|©©ÁqH;Áf,µÁ[¥pÁQ•²ÁG›ÜÁ=לÁ4ÜpÁ,ŠÂÁ$™¯Á÷âÁ 6Àø}¬ÀÝðÀĹIÀªnÀšÀkCÀ8ƒ6À Fë¿Ëž›¿›À8¿œ¿¥V5¿Ù“ÃÀ$5À?Q­Àq·ØÀ’Ä–À­ðÍÀÇÀWÀáÀûCÁ öŸÁÀþÁ$OÚÁ+¸/Á3´CÁŠš#xÉ?©î=Ö[¾„Kð¿8·‚¿°vlÀ9¢À8h^Àoœ:À•&4À²ÞÈÀÊ+qÀטÞÀæIÑÀõØáÁZAÁ $:ÁûÁ 5Á*­áÁ5ÏLÁAl¸ÁMF¾ÁYx¿ÁeОÁrÁkTÁ†6õÁŒÈ!Á“{ÁÁšOÁ¡:ÙÁ¨*MÁ³ÈBÁ¬³¬Á¥³yÁžÀ[Á—ÙœÁ‘œÁŠ?aÁƒ~WÁy£ÁlŽÁ_ñ%ÁSYÔÁFËÁ:ž¦Á.þ#Á#y±Á Á ±Á•ÿÀñ\ÀÝð0À̬‡À¼6¤À­âÀŸÂÀ‹“ÀY ,Àn·¿ÁŠO¿+¶b¾]$—¾Ðò>>.,?{?‰>‹’½0—ñ¾ADk¿> `¿Æ#XÀ3pÀX£aÀŠü¸À ŒÁÀ­ŸØÀ»¹âÀÊ’ÀÛ>œÀì\LÀÿ¥³Á ’Á‘ëÁ“ Á+ üÁ7«ÁCaÁO¹NÁ\{)Ái‚¨ÁvŸãÁïŠÁˆ³oÁ—ÊÁ–‰GÁ{Á¤n`Á°dßÁ©,€Á¢]ÁšõˆÁ“üÄÁÁ†7ÄÁ~É ÁqE¶ÁcÔÁV®³ÁIãÁ=F#Á0ªýÁ$i-ÁµóÁ .<ÁÞ†Àí·ÖÀاcÀÅõÀ²3LÀ¡E^À‘ЏÀƒ-TÀk”’ÀQ¯îÀÔŸ¿¨ ¾®'t>8íh¾l¹>§ ã?Ÿ‰`?9~Å>ÁÕë>ÍT¾¨O¤¿£äÐÀ«ÀM¼ÃÀlwÛÀƒêtÀ‘m"ÀŸÛ À¯Ê£ÀÀøKÀÓrXÀçÜ:Àüï—Á `ÛÁß¼Á!ÝÁ-MåÁ9¸ÁF™ÍÁSÀzÁ`ûEÁnZpÁ|ñÁ„ô+Á‹çÆÁ’ÛˆÁ™ÙDÁ ìñÁ­ Á¥áñÁž¦çÁ—p»ÁLÄÁ‰AÁ‚QžÁvç—Ái,8Á[ˆÁN”Á@Û»Á3ìhÁ'7`Á¾ÁUyÁƒÏÀíÅÀ×jªÀÁ`zÀ¬g¡À™5À‡ÃÀkÕ‡ÀN³(À2Ú Àl:¿ø¹Ž¿³4Ö¿æ¥>¡s ?Q ?ht2?×Ðá?¬þ^?W!P>Áÿü¾Ö¬Ç¿¡,¿ìEéÀ=À3ßÝÀO-Àk@À„k¨À•¸gÀ§®¥À»•OÀлÀæ„EÀýuÒÁ û¨Á]Á#âFÁ0èpÁ>2ÁK ÁYÁfàÒÁtÊ®ÁZLÁˆQüÁ`lÁ–wÝÁQÁªÀÁ¢«ïÁ›`óÁ”%ôÁŒðhÁ…¿ŠÁ}=æÁo4{ÁadVÁS¤GÁEéNÁ8VÅÁ+ ÞÁ^Á0rÁ’0ÀðÈÔÀØïtÀÁWOÀ«!À•öÀ€ŸõÀZñ´À7ͼÀb¸¿öAó¿¾ü6¿Š/¿Ñ»"?/Ý?»Mp?åÍ @4@¼Í?ÃB?NS)>G@¾íY¿€Y¿¾°N¿öÅÓÀ°À4ÀTñÀxG5ÀP?À¤‡ˆÀºýÀÑlÀêF«Á‘"Á=ÁxéÁ(ÙîÁ6@JÁCóhÁQç¸Á_Ó†Ám½þÁ{ÌVÁ„ý-ÁŒ6Á“-yÁšRÄÁ§+ÍÁŸÁ@Á˜W)Áø&Á‰«Á‚r”Áv‰ Áh0êÁYòEÁKôÁ>+Á0e}Á"§öÁ>¸ÁA³Àö¢ôÀÝÀÄíPÀ­ÎÀ•XÁÀ}ßqÀRPÀ*=ÀC¿Ä+¿‡˜p¿˜¾>³F>‚åù?IHk?³%œ@›@0g @Góþ@4Ò:@ Ak?Ä“1?k¨·>µKú¾&¿²ã¿‡7ö¿¿µ¿þ$À!F%ÀFò·ÀpùÞÀ޲À¥ÊlÀ¾¬(À׃Àñs)Á ÕÁ‡+Á!1Á.õrÁ<í±ÁJÞìÁXÞÁg ¦Áu=«ÁÁfÁˆáÐÁÎÁ—ê>|zS?/ë?òÈ?ÏH^@ W‹@3E@]%g@€£$@egõ@;¸Â@_×?ÝÒÆ?™O?5Òy>€)¾>ýõ¿(æå¿•›å¿à‹ÅÀ?üÀE¨9Àt8ÅÀ“  À¬.ËÀƺËÀá“–Àüv¥Á cÁüÁ'öPÁ5óÁD ©ÁRhÁ`±ÀÁnóÁ}.Á…À{ÁþÁ”OVÁ¡¹¾Áš? Á’ÆVÁ‹NHÁƒØóÁxÙ™ÁjÁ[fØÁLË¿Á>VÓÁ/öDÁ!–ÒÁ_'Á‰ Àï¹®ÀÔopÀ¹ÙQÀŸð‡À†BÌÀZMÀ*Œ‚¿ö‡$¿›Ï¿ ö=TÙ?Àû?ŒwS?ÆÅê?þîë@™Ð@?€@d’ @†q˜@›Nõ@Š”„@mÙñ@G—Â@#ðë@JÏ?Ȫw?Ž„æ?'·!>%´ù¾Íæ:¿ƒð ¿ÛàºÀo¢ÀOŽôÀ›ÝÀœŠ À·1ÀÒ¬Àî˜(ÁH`ÁD«Á![ÚÁ/˜aÁ=àµÁL"ÜÁZlÁhƵÁw?9Á‚è€ÁŠ4GÁ‘ƒXÁŸJdÁ—µÎÁ+ÌÁˆ¬ÜÁ/LÁseÁdo!ÁUŠîÁFÐ%Á81UÁ)”ÆÁsÁ ¶äÀüÇ6Àà˜¯ÀÅ*øÀ©àºÀŽÜËÀi™À66¶À†Y¿¦/¿…>c‚?O…?´…ÿ?øô@Š@7@U­@sÈ|@‹ÉF@žï½@³Ax@£ª.@$F@{p­@Y¿¾@9_ô@4?ûçŸ?¾7?p}º>§¦»¾µt‡¿ŽL/¿ó—ðÀ/–|ÀekÀ¹À©«áÀŦØÀáŸoÀý¼Á yÁ2ïÁ)mWÁ7Õ,ÁFC`ÁT²ôÁc:ÁqÃFÁ€+Á‡‡§ÁŽìïÁœø¯Á•`zÁÊÁ†3ŠÁ}EÁÁn@šÁ_EzÁPJZÁAPpÁ2cŽÁ#¢IÁü„Á_FÀï°'ÀÓ bÀ¶¾Àš¾tÀ~»SÀHõÀ­µ¿¿¦û¿4E=l¥ö?LW×?Áh@ œø@0X@P@nR@…†@•lº@¥Ã@¸[—@˽À@¼±&@ªð@˜šˆ@‡fÎ@pV@R @3c3@¥,?Õu”?{ëÆ>j“R¿ÞÔ¿¸iÀÖQÀI|ÛÀ€¹GÀœ´[À¸ÆÀÕ%wÀñ’EÁ+ÁdÕÁ#ÇSÁ23pÁ@­ÆÁO@|Á]ìçÁl¡sÁ{iØÁ…7ÁŒ‰9ÁšÁ3Á“…Á‹€¤Áƒæ&Áx—RÁifOÁZ:ÇÁK'çÁ<,\Á-4œÁEwÁVlÁ‰¡ÀãÂ%ÀÆqÀ©WÏÀéÀax1À)öÀ¿æn¿wÒ'¾!½?$<Ã?³~µ@ Ð@7…A@`üÛ@‚h @’¡@¡Ae@°²@À[°@ÑûÝ@å@ÖŽ˜@ÄW1@³:@¢¹°@’÷ˆ@ƒÅV@fvï@@Ds@ ?Å G?4§D¾Ó“¿€-¿ïºSÀ/ÞxÀh ÷ÀgÒÀ¬ÙoÀÉQ“ÀæÁlvÁÎ{ÁDiÁ,åÁ;–TÁJIbÁXþñÁgÒÊÁvÅŒÁ‚ãYÁŠcõÁ˜Í,Á‘Á‰ZaÁ­vÁtêÁdßËÁU©çÁFtÁ7>#Á(ÁñÁ *ãÀöwªÀØ™ŽÀºâƒÀ›À€[oÀF~¢À 눿«‹ò¾õSE>¹þb?—>Ñ?þvŽ@0—ñ@`ÃŒ@†ò?@›G @¬—Õ@¼w~@Ë‘²@ܹ@ì e@þg@ðo}@Þ÷.@ͦ.@½¯-@­ú¬@³4@Š”j@hfÂ@5SÆ?ÿm×?‘M >Œ+¿P-¿½€¶ÀO1ÀP[À„³yÀ¡o½À¾0ÎÀÛ"•Àø\ºÁ ËÀÁuXÁ("IÁ6Û&ÁE¯<ÁT¦Ác¥½Ár¥©Á€ÕXÁˆdÉÁ—ÖÁNìÁ‡‚¢ÁxûÁoûaÁ`‚ÁQ9HÁAüRÁ2ÆnÁ#‘Á_]Á0,ÀìRßÀÎuÀ°–ËÀ’»lÀiíÄÀ/Gÿ¿éR2¿iŒÅ½)?WI—?Ø8@![¾@U5@ƒ±@›’’@²%@Æ4@ÖÛ½@çA@öäÉA’oA ¤Awå@ù"@è¹É@Ø]ž@È)Â@´Û€@Í @ƒµ˜@QT@"¤?Åi€?)q$¾`»Å¿ŽŠ…Àt1À9ÃÀsÏ|À–þ(À´0ŽÀÑrNÀî¸#Á"¾Á ÐÁ#ÿÁ2öXÁAóÁPò)Á`Áo!Á~XsÁ†ÓƒÁ•’(ÁÀCÁ…î^Á|8óÁl•YÁ\óFÁM]ZÁ=ÙÁ.k.Á%Áå“Á³æÀãrÀÄ¡À¦~’Àˆ¡tÀUŽÿÀòª¿¼¬«¿ «„>»Ù?¢²Þ@ Ùÿ@A g@vå6@•z@®ËY@Ç@Ý”à@ðãVAò.AáxA?SAhA’žA çA®·@òÉ_@ßz)@Ç4@¬¾„@‘]@kŽw@3eö?ö?ƒß³> ˆ¿DSë¿Ö¶?À%³À`<ÅÀËUÀ«PùÀÈíñÀæÓ]Á\nÁRÁ c»Á/†TÁ>ªNÁMÏÁ]ôÁl[XÁ{²ÊÁ……Á”3ðÁŒRûÁ„u¿Áy9ßÁi’äÁYóhÁJU Á:·ÿÁ+¨ÁƒBÁ õNÀùŸÀÚ_yÀ»Ó}ÀQÀ}Í ÀATŠÀ·¿”dˆ¾j.Ž?3”)?ÐiÊ@#~ƒ@\Ð×@ŠœÙ@¥í¦@Àf @ÙûÑ@òp¯Am*A ñ¼A˜ñA”lA&ù0A¥#A=AׯA)Z@ðœ±@Õ•'@º$ @ž•@‚ ë@J÷3@È·?¯ˆŽ>ë¼¾ç"À¿°Æ*À ¼ÀOº¦À…´~À£¼ùÀÁòFÀà+"Àþc®ÁMêÁiýÁ,‰SÁ;Ã[ÁKŠÁZ»Áiç¥ÁyR˜Á„`Á“6ØÁ‹LùÁƒc«Ávö}Ág(šÁWaÇÁG¤ Á7ïkÁ(DÌÁ¦êÁ ÓÀòévÀÓÈCÀ´Á­À•»Àm¤XÀ0„¿ç-™¿[Qæ=©3˜?Å´?øöÎ@7ÚÜ@sU@–í´@³#@ÏnY@êvùAOiAËAÿéA#ŒA, ÕA4u‚A,îzA$jÁA^‰A õX@þ²h@âú @ÆÄ0@ª<à@’û@_ç@%4?Õ>Ð?8¨Ï¾e‘¿•¸¬À«ªÀCšÀˆ­ÀüÀ¼@.ÀÚ¬ûÀù4ÁÁ ã¸Á-Á*z´Á9â„ÁIY­ÁXÐÁhEŽÁw»ÁƒšÞÁ‘QõÁŠ,ÏÁ‚”Áu,mÁe_×ÁU—xÁEÐ>Á6 Á&A¾ÁyÁ°`ÀíÏcÀÎG³À®Û‘À§ªÀaQ+À#T̿ʰڿÕë>«Ê?¤lZ@ @Kc¶@ƒx @¡>¸@¾oq@Û™q@÷Ü`A ÆFADGA$ ÏA/¼@A9TºAA¿cA:oA/Q)A!œbAÈAÎ@ï/²@Ò&†@´Î¬@— (@q¤¨@4×_?ð[P?mY½©T¿}î:¿ùjßÀ9X5Àv—?À™ï-À¸ŠÀ×—Àõ©¥Á 5ÁxRÁ(íŸÁ8hCÁGã=ÁW^{ÁfÛWÁve—Á‚û`ÁóÐÁ†­HÁ~ùYÁp¯ˆÁb˜ÁT?UÁD`€Á4ƒEÁ$¨ÁÏ£ÁúßÀêV•ÀÊÉ'À«MrÀ‹ÕíÀX¼ÏÀÍÅ¿¶Y¾æØ?äÙ?¿•O@äú@Z¿ô@‹Í>@ªá@ÇüŒ@åÉÉAyÈAïŽAýA+ôÞA9I AE mAO*AD2‹A6evA(Y~A ÁA €t@ù/÷@Úî@¼C’@Tš@|ÏÖ@?@7Ò?‡*“=¾8l¿_([¿ë âÀ3ÀpuäÀ—,À¶)ÀÕ"CÀóåpÁ VÁÐ_Á(TÁ7ÔUÁGO¥ÁVÊõÁfNõÁu߆Á‚¸wÁŠö·Áƒ…ãÁxM¼ÁiºÁ[WÆÁM€Á?iÁ1?ÛÁ#h Á'3ÁDoÀèÍ;ÀÉtÀ©]®À‰¥çÀSÜBÀ€¿«$û¾´°§?!â‚?Ϭ@&– @e¤Á@‘òW@°ó@ÏÚ@î07A>ôA A#ÃàA2$A@DOANAY|AJýƒA<¼˜A-»éALAÅ@þQ@ßá@¿Íâ@ Ð@\ÿ@Drz@*ö?l‹>¥‰¿R¶¥¿åëVÀ1:LÀoJÀ–¸ÀµVÀÔ,VÀó[ÁÿíÁƒ/Á(ŽÁ7ŠÁG ˆÁV‘ÁfÅÁuNÁ‚ÛÁˆKÅÁ€ÃòÁr)ÁcŽwÁTÂöÁF'kÁ7ÄmÁ)ÝÁŠÀÁ ÊÀÿ³ŠÀåqÀÈZÀ¨ZýÀˆ¢GÀQÓ"ÀaG¿¥Ä ¾›'?0qñ?×7z@+þ@jš?@”â@´gÓ@Óí’@ósQA dÜA nA(_áA7g!AFZAT˜ÚAU~AFœ¬A8GîA*=ÀAr A?€@ýKf@ÞË@¾ä0@Ÿ¶'@€‹L@BÃ@—Ï?#Ì>µÑ¿Vl°¿çckÀ1¸ûÀo²ÏÀ–ÚìÀµÞ²ÀÔè­Àóû†Á ‡/ÁœÁ'– Á5rþÁC“ÁQéÊÁ`yÿÁo97Á~AÁ…ñ‰Á|²ÁmNÛÁ^+1ÁO%·Á@,yÁ1PcÁ"«·ÁI‹Á ªÀïô˜ÀÓÓÀ¸î~ÀŸ4'À‡òÀP¢—À$Ž¿£M ¾‘Cß?5V5?Ù¥É@,Aº@k°@•„ñ@µ/@ÔÙ@ô}ÅA ÐAÙ?A)žA9F1AHÅAXxAOÊÝAA A2yÐA$aAÍçAøf@ô¸S@Ùž@»¾À@œ¹@{}>@=¸?ÿ¬ó?ƒil=sX¬¿hg¿ðV×À6-ˆÀt À˜ýMÀ·îÀÔ¯ŸÀî Á'ÛÁßyÁèfÁ.>=Á<Ø•ÁK¨²ÁZ£¨Ái±²ÁxÈmÁ‚ööÁw²]ÁhýYÁYŒÍÁJ2‘Á:ô$Á+ØëÁæ˜Á$Àþ´DÀáüZÀÅ ·À¨¢åÀŒÒ ÀeK"À3ä…À8â¿ ¥á¾†¢û?9·ä?ÛNc@,àj@l¢@•´#@´ßˆ@Ô½@ó„·A Z AšÔA'®ßA6¡tAEŽÆAT-AK>àAØAMH®AEG%A5ÔüA&}ŸAI6A>À@ò‘}@ÕF@¸d›@œ¢„@¦ê@OºA@ ¶$?üf?¨3ì?Ÿº¾ Ã¿qýȿބÒÀ ×ÓÀWàÀ‡Ò¡À¥díÀÃ{‚ÀáÀfÁ3Á«œÁ>ùÁ-îwÁ<ƒÁJ„ãÁY‘Ág&Áw)>Áh&€ÁYGêÁJ•sÁ<ãÁ-f?Á ËÁò¿Áo¯ÀåŠÀÆ[ÔÀ§uÐÀ‰WÀU _Àõ®¿´ÿ ¾ü7>ÔoÏ?’·È?”=¡?ÔÚª@€Â@N¹°@„:þ@¡å…@¿†W@Ý{Ù@û°ÔA ÙA^lA+ª.A:éÚAJ/ãACË A48hA$º£AX-AJ@íæ[@Ïó @²-¶@•BY@sz˜@>w@J¦?ÍÖ ?§‘N? V >ãém¾Ìý¿œRÀf(À?`À|AÀœÙÀ»¥ÀÚ¶ÂÀú…Á “ÖÁ‘Á'êlÁ6‰ÍÁEC3ÁSßLÁb¤¢Át ÑÁdï3ÁU×eÁFãÇÁ8 Á)LyÁŸ~Á òÀûUÂÀÞ¬|ÀÁGuÀ¢WÀƒQuÀHÃÀ ~…¿˜N½¾\RÊ?<=L?0gé?©?V±?üW~@8ÅS@u,¬@˜Ê{@·$p@ÕÞ@ô§A ŸàAüqA(vA8AG¢}AC;A3¡)A$mAž‘A¢@ëEn@̸ñ@®ˆ¯@©Á@gš@0°Œ?ü]?¦¾=?X›\?R›Ü?r¶(<Ü´Œ¿hQ–¿í…çÀ3XÊÀp.QÀ–yÙÀµÀÓQpÀï’Áî:ÁsúÁ#/ºÁ2³Á@åµÁOÄ·Á^°_ÁqüÁbÁ ÁS&ÁDi¥Á5N Á&K)Á|ÁÊFÀôOÀ×U×ÀºYÝÀœ—½À{pÀ=b6¿þ¦¿Š’½D¶?8õ>+†»½±fy?CΙ?Ù“î@)G0@f<ï@‘Øù@°“€@ÏgÞ@îe²AÍšA{’A&,A5ÝAEŽACƒ³A3á)A$EÓA§FAu@ëE*@Ìf@­Õ¸@˜Ñ@c›6@*ˆK?èZy?†þš>ÑVš><¿¾?(G)>´[¿Ý’¿È ¥À!xCÀ_»Àމ™À­@8ÀÊ1ÀæÊAÁÿ ÁµdÁ£HÁ.¹›Á=ŸIÁL˜ÒÁ[·_ÁpÛKÁa~šÁR4ÁC”Á3í Á$Ê•ÁÕ{ÁÔÀðšdÀÓ¾ÙÀ¶âÛÀ˜ÝãÀs½`À7ò¿õ‡~¿~V¾0¢¾>@H£¾³G;¾Ï'è?âí?¾jñ@%÷@[u@Œ‚U@«”U@Êí¸@ê^ZAçÛA öA$Z^A4‰AC×ADZ\A4ªSA%²Av Aú‘@í­@Íÿr@¯ã@jœ@drå@(¹?Ü0?W{Ð=ùc¾øÓý¾ã ð¿±þXÀå:ÀTêÀ‰NúÀ§Ú~ÀÅ;ÀáßÀÀÿ$€ÁoÎÁgØÁ,„]Á;~ÁJŸðÁYá‰ÁpŸ$Áa8„ÁQè×ÁBµ‡Á3¥µÁ$¨¸ÁÊiÁûÀð†nÀÓ¬õÀ¶ÙìÀ˜<‘ÀsÓ†À8tB¿ÿÈð¿—Õc¿´ð¾Ø#7¿bêÖ¿Þ½>¸Ÿ>?«D @2z@RÂï@ˆ©²@¨õ@Çz\@ç üAZäA5žA#0A2øNABÜÀAE‘˜A5Û¡A&*‚A„­Aî@îË}@Ϻâ@°˜ý@‘}S@e8y@((?Ö1ô?:/¾;âÿ„YZ¾éòú½ëÑ.¿•»¿¶SsÀЙÀO24À†ÞÀ¤àœÀßÀàq%Àý„ÞÁ ’.ÁœŽÁ+ªÁ:¶ðÁIçµÁY6>Áqm„ÁbôÁRÕJÁC´XÁ4¹ÖÁ%ÝÚÁLÁŸ{Àôo<ÀÖPpÀ¸ Àš: ÀzìÀAÍÀ ¿Ç•›¿ŽF¿‡Ë­¿¾ Ë¿4±‡>‡ ñ?žux@VD@M£@†wø@¦c@ÅÀÙ@å^ÌA¼AX-A"7mA2˜AB*AC‚3A5 VA&6¦A ÇA=Ø@îý„@Ϥ¾@°~%@‘b¡@dŸQ@&“—?Ñ»?*1G¾ŒF¿œBF¿ŠGe¿CÀì¿í¢¿ÒñÀ$/ÀS5aÀ†ÊªÀ¤¼DÀÃDªÀáñŠÀÿ|LÁNkÁ#^Á,-ÔÁ;L]ÁJsŒÁY¸AÁs4œÁd ²ÁTõRÁEýöÁ73[Á(•ÛÁê5Á §“À÷JÀÙ8À»êÃÀŸ0ûÀƒ†ïÀT…PÀ&à À‡À¿Üî_¿á +¿âX·¿Iݹ>C=?•¶,@ $@H·£@ƒøV@£”ü@Ã5±@âÚA@ñAƒA ØdA0‘ŒA?hîA:êxA-æ3A ´A”€Aóõ@è7g@Ê:@«ÙÃ@@w@\§¹@a¡?ÃÓ´? õù¾Ë¬ìø¿ß> ¿¼¿Í¡À/‡À/&ÀaTBÀ‹À¨/ßÀÅ®+ÀãÁ…ÎÁ„¡Áµ¶Á-õjÁ<ó¬ÁLÁ[YóÁuðYÁfúÁX)ãÁIîÁ:~ Á+;HÁ¯Á Àü}ÅÀß”DÀÃh2À¨«ÀŽnžÀnë%ÀEÈÀ(QÀî´À`¿ïŠ˜¿eW$=«?ˆxÿ@+®@BÜ@€…@ŸóQ@¿2ô@Þr–@ýuA9ABA,‹ A/pfA-7A$dSAö A zö@ùU@Ü<º@¿/B@¡éŒ@„@L“ò@þ?¦óG>ºˆ¦¿Ö¿ÅeÀÃ,À ˜üÀÿÀ'¢ÀJFÀx|À”…¢À®öÀÊöiÀçã–ÁlžÁ96Á @íÁ/sÁ>ÁçÁNAÁ]fðÁy£ƒÁjZëÁ[»ÁKé¿Á<Ö-Á-ë#Á'Á”¦ÁN°ÀèÙ²ÀεÀ´hÁÀœ¹vÀ‡aÆÀjÝîÀR{”ÀHMÀ>,W¿ÿšY¿‚ܽCóH?lAÁ?òa[@7Pë@u@™@·Òy@Öwª@ôh)A ÚA; A—¢AwÞA³tA®A åÕA×U@éSN@ÍþÄ@²å@•}%@qBÑ@6ù!?÷–¸?€Ò;=©AÍ¿[XU¿å¹~À.µÐÀ>•ÀA¼ÀQLwÀmúŒÀŠÖEÀ¡žÀºÀÔaÀðÆÁdÁräÁ#-Á1ç±Á@àÁOÿGÁ_‘Á|Álø$Á]ûÔÁOËÁ@[YÁ1Ì;Á#vCÁp•Á¹‰Àôª†ÀÚý…ÀæÀ­aÒÀš ½À‹1œÀ€Ú“Àx/ÀI6À Î¿š£º¾{$2?6zõ?Õe@'e¨@cëÒ@×@­š¯@Ë@ç”øAA ÔæA î†AVA$A ¸ÔA@îÞG@×.‚@½Cq@¢È¨@†öT@VCc@Þ—?ÈN;?'A¾…¼W¿–ú‚ÀÿÀAúÀq§ºÀr©ƒÀûêÀŒ:ÈÀœßRÀ±HJÀǺÅÀàeÇÀú“ýÁ áGÁâ‡Á'¢Á5t¸ÁDÚÁRõ¬ÁaÙÁL©Áp…xÁaÛJÁSPÁDî#Á6É’Á(ùØÁd$ÁaÁj Àë ÀÔÉÀÀqÝÀ¯Œ,À¡å¬À™glÀŠFŸÀVèÀ»C¿»‚¿¦>ÙÉÏ?®Rc@Î@MyÊ@ƒ÷n@ ]s@¼œ@Հ³¿$FØ¿Ål=À ¬ÀV±ïÀˆ ïÀ“ê8À™ÌÀ£‹ÔÀ±ìñÀÃ÷{ÀØÿÏÀï×fÁÕÁdÁZáÁ,éÁ:ÓÁH[ÁVêÆÁe§@Á¹×ÁtöÁf§ŸÁXˆ-ÁJšHÁ<ÓÕÁ/a%Á"LsÁ¹àÁ Ú Àý|Àè@:ÀÖ%ÀÆÙ±Àº©–À°H À’IíÀhïÀ-J+¿â·‚¿W…÷=¬ü£?\^?ówø@2L@j_|@Ü@¨@Þ@½Ÿ@Ì¥,@Ö}©@Ü—¡@ß Ÿ@Ýh¨@Ö½ @Ì1J@½ªß@ªï®@•+@{c@IØr@ ?Áê€?*ìu¾E-P¿‰4µ¿ú€-À5MÀnç*À”YLÀ¯ ÞÀ³F£À»þFÀÈ÷kÀØç!Àì‹Á¼Á %¡ÁcÁ%![Á2C¿Á?Õ­ÁMÁÁ[ôûÁjZHÁ„ÀCH6ÀÄ¿›—6¾ ÊO?«??¹²Ë@*„@EßÀ@v’€@€t@¡ý(@®¶~@·Š`@¼Þ­@¿4·@½”ú@··í@®–@¡ÚM@‘ÅÉ@|S-@P19@!ç`?â¢â?x”Ó>#O¿0* ¿Ä¬÷ÀUœÀQ`¡À„´ÄÀ ÅkÀ½AÀΑ<ÀÖ-=ÀáØÔÀðÈÁÊiÁ À\ÁhÁ òíÁ-ÝÁ9±xÁFÁ±ÁT8òÁbÑÁoõÈÁ‡eÁ€2«ÁrȦÁeF¯ÁXèÁKYAÁ?^Á3:˜Á'Ò2Á,§ÁUàÁ ™EÁ×CÀù~Àâª"ÀÅPâÀ¨ÀŠÊOÀ[ĪÀ" ¿Ò©å¿D¤F=«•?i‹\?Øá@ˆÖ@Gj@lé@…R @QÂ@˜`>@)"@ŸHÎ@´@˜´‘@aÕ@„ôb@nø@Já @"¦W?ìÙ‘?×Y>Æ,§¾Ó”ö¿›!±À:À9F3ÀnÓ À“!–À¯TÀʪŒÀæÅŒÀñTÛÀûÌiÁV9Á N·Á„åÁ}÷Á*[zÁ5ôêÁAü'ÁN…_Á[þÁhÞµÁvzÒÁŠ` Áƒ£DÁzøÁlì´Á`5ÁSïWÁH.¼Á<ÊôÁ1ÿšÁ( FÁýßÁ¹dÁ‚äÁ×ýÀî}ÀÑ\À´µ½À˜gÀwµÀ?:”ÀÊ¿¤Æ5¾ñø>šu¬?„µï?Û¦Ž@4F@5¡=@O¹H@c†@rE@zó(@~¹Ë@{àÞ@rëX@d&S@O½@5µ@Ax?ãA,?‘ó>å¿»¾ˆ€9¿T¿æåÀ%üšÀZîÀ‡Á À¢†@À½ªÀÙL®Àô½ÁžüÁ aÁTkÁ¢-Á!òÁ*oÁ4¨-Á?¥âÁK˜ÁW¢ÁcšªÁp„Á}ÄïÁŽòÁ‡v—ÁÀÁu^)ÁiÄÁ]C³ÁQÿÁG/Á<öÅÁ3ŒªÁ+ÄÁ#aÁwÄÁ û ÀûU‰ÀÞ¸³ÀÂI…À¦¦ ÀŠíÂÀ_) À*Û«¿î+e¿‹¦<¾¾—8>¡ã´?n“?¾;ƒ?÷ùZ@†c@%¬C@3v@;œ|@>áú@<ÂoϾ…š™¿sóh¿ÕuÀªÀK›;À~”mÀ˜”sÀ³•À͸†ÀèIëÁÉÁTÁ@êÁ«Á%hWÁ- YÁ5à°Á?‘aÁIþbÁTÞÀÁ`YïÁl[ÅÁxÐÄÁ‚Ô=Á’àÁ‹¡]Á…RuÁ~^„Ár‡eÁg0¦Á\nÁRÁHg4Á?ˆÞÁ7œ-Á/'ÎÁ úÝÁ¬›ÁwÀíHvÀÑÁ­À¶(–À›®ôÀÙ'ÀO÷˜ÀZ„¿ä‹¿Š´´¾êMB=Þ•7?.ä?ƒÝ?­PÀ?Ï`©?é¯?ø‹Ÿ?þR?ù/?ê‡?Ð,¾?­ W?;Ø?h>/uä¾Îä¿‚žÛ¿ÔÍWÀ±¬ÀDnÀs‰IÀ’aÀ«b‹ÀÄwÀÞ˜èÀùNÁ  XÁøIÁ$OÁ,j+Á2œÁ9À3ÁAîëÁK ˆÁTöÁ_W·ÁjO­ÁuÕÁ€êƒÁ‡Á–I\ÁŠÁ‰îÖÁ„Á|¡æÁqÄ“Ág{Á]šèÁTj·ÁL5ÁDQÁ5üÝÁ'ÉÒÁçýÁ 9mÀüà-ÀáìÀÇÙÀ®¸À”zÀyn+ÀKÿxÀ$¿í±˜¿¢å+¿<…O¾–7t=³¥@>Í F?&Àµ?T²Z?s¼‹?|É`?sÌõ?YÑ?(> >ÑV=²p⾘Vú¿8–²¿™¤ô¿æ «À»½ÀDíÀpÀŽ¢À¦vgÀ¾?óÀ×XÀðrµÁóPÁ6Á$Á,<Á9\ëÁ@9UÁFÜ—ÁN†ÁW¬Á`"Ájp®Áté‰ÁôêÁ…ÀVÁ‹¾sÁšÒñÁ”ÃÕÁŽ×åÁ‰!ôÁƒ©Á|êˆÁs2Áiœ­Á`íwÁY<ÁK ¹Á=/>Á/}#Á!΢Á2!ÁoÀôEÀÚ:bÀÁ&bÀ©•>À’ÄõÀxÚ@ÀPgðÀ*øÀ ¿ÎÑ‚¿š¬¿Y€á¿$4¾¦ì¾"²©½1šœ¼%y½,Sc¾°„¾Ÿ¸z¿ ¿Z]G¿šC¿ÎÀ 3À%q4ÀK%»ÀsNÀŽ¢°À¤–rÀ»!ÀÒï ÀêCìÁ™+ÁàÁIÁ'†¾Á4{]ÁAr)ÁN+_ÁT^vÁ[ÍÁc§KÁlˆßÁuúÁ€@Á…T ÁŠáÁ¨ãÁŸŸùÁ™»ÔÁ”§ÁŽ…<Á‰CiÁ„=¼Á~é)ÁvßÁmÑÁ`G?ÁR° ÁEËÁ7oêÁ*;Áþ Á½ÁEzÀíûõÀÖy¨À¿Š.À©M·À”û‹ÀIÀ_9!À=v×À!ŠŠÀ”¯¿æ¥‡¿Ãgà¿§¿“׿… ¿€ú”¿„«±¿Ä¿¥s¿ÁÛE¿å„UÀ«‰À …ÊÀ<8{ÀY<þÀ}©À‘“LÀ¦nÀ»C„ÀÑ!YÀ稇Àÿ"üÁ +œÁ†SÁ#ú§Á0D6Á<âYÁI¬FÁVƒ³Áb3¢Áh÷¾Áp›ìÁxåçÁ€ñ¤Á…Ä@ÁŠâ ÁAùÁ•×pÁ¤  ÁžêÕÁ™iúÁ”#jÁ ~ÁŠ-¢Á…š÷Á]­Áu´îÁh(ÁZ¥(ÁM5Á?ÕKÁ2Û5Á&ƒÁ‹ Á s˜Á¶ÀìOfÀÖ.±ÀÁÊMÀ­Ç/À›±3ÀŠŠ^Àv,_À[“5ÀDOtÀ0Y»À´ÀiÀÚ­ÀMŸÀUÀÿjÀoÀÀˆØÀÕÀ.ïCÀC±¤ÀZ…nÀuAÏÀˆ‘À˜vÀª¬À½Ð³ÀÒš-ÀçäWÀý¬@Á Á«vÁ!9ÈÁ-søÁ9ÂÊÁEìÁRQ)Á^þšÁk’¯Áv§˜Á}Ï–Á‚Ó÷Á‡_Á‹¸‡Á nÁ•Ì£Á›6Á©ÎÁ¤F­Ážõ*Á™ßÁ”ýÁP’Á‹ñFÁ…xDÁ}‡Áp-ÁbÖ#ÁU¯ÓÁHÛÝÁ<>àÁ/àóÁ#æ&Á+ÌÁ IÁ‡íÀî™eÀÚyöÀÇÚûÀ¶žêÀ¥ç À˜kÀ‹JÊÀ€ ]Àme¹À]´?ÀP¶ÀH2nÀB9À@-òÀAÐàÀGžÀPX$À\½`Àl'‘À¹-ÀŠŽÀ—%’À¥áÀ³^§ÀÄ^ÀÖ„yÀê-Àÿ/üÁ B•Á–Á ^‹Á+ÅnÁ7)÷ÁC&IÁObîÁ[`Ág¼ÅÁt5;Á€WmÁ…¥‚Á‰`qÁv Á‘ÞðÁ–“•Á›+Á ÅMÁ¯18Á©ÖÀÁ¤³@ÁŸÌÁ›%Á– NÁÌÁ‰{wÁ‚ñÁx¯˜Ák«¤Á^û…ÁR‚æÁF74Á:6ÁÁ.}WÁ"ü+Áø)Á ­gÁ‹ÓÀô‘Àâ”ÌÀÑp‚ÀÂbûÀ´ä¥À© ÀžˆÀ•Œ…ÀîýÀ‡²AÀƒÁ™À€êjÀ€<À€ÏÙÀƒ`¾À‡“¸ÀRŸÀ”ÖvÀñmÀ¨z(À³þÀÁš‹ÀÏNWÀßÉÀðFPÁ7ÆÁ O[ÁâåÁ ’ÿÁ+A…Á6a.ÁAŽ‚ÁLãüÁXÈÒÁdÜ©ÁpÇDÁ} ¾Á„ºêÁŠì[ÁtÁ“øÚÁ˜1hÁœµzÁ¡~»Á¦‡4Á´ÅðÁ¯— ÁªŸéÁ¥å‡Á¡a£ÁšÍ¶Á”BÏÁÀ;Á‡E$Á€Ù×ÁuèÁh¿‚Á\~ÁP…uÁDؾÁ9pÓÁ.d×Á#ûÁØ1Á%ÁCpÀý0!Àí7²Àß.ÓÀÒEWÀÆËdÀ½*À´…ÊÀ­=½À§3³À£c}À Ì7ÀŸ÷À ¶ÑÀ£5-À¦û^À¬p}À³¤+À¼½ÀÆ}5ÀÑ;AÀÞ5ÀëÍÅÀú;DÁtèÁfÁZ^Á!œAÁ,…Á6 ~ÁA;ÁL\ÁWQ1ÁbŸªÁnjbÁzBÁƒDÁ‰)oÁXÁ•‡õÁšŸ`ÁžªªÁ£ÙÁ§œÁ¬víÁº‡ÃÁµ‚úÁ°¶tÁ¬ ¾Á¥} ÁŸÎÁ˜Ž;Á’ Á‹ÈÞÁ…ŒGÁ~Ö„ÁrµKÁf»GÁ[<ÛÁOécÁD׿Á:HäÁ0$åÁ&XþÁBµÁ„ÔÁ I_ÁÏ1Àûÿ´ÀïñÀäÛsÀÛ‡.ÀÓp>ÀÌŠWÀÆÏVÀÃüÀÀ¯À¿èªÀÀÉÀÂõdÀÆkoÀËÎ8ÀÒÒÀÚ»©Àä^Àï}Àú  Á)¢Á ‚ÁìßÁ_ÔÁ$^Á-wÁ7ðFÁA÷…ÁL’ÁWÁbäÁm ›ÁxIäÁùœÁ‡Ý$ÁÃMÁ“Ç(Á™í=Á !@Á¥F(Á©qÁ­à±Á²æÁÀr¦Á»–iÁ¶«XÁ°(Á©½¨Á£aõÁœþ$Á–°ÎÁ‡NÁŠ~;Á„nÁ|óÁq}ÂÁfabÁ[NùÁPžÄÁFqÔÁ<%Á3C˜Á*}%Á"xÁOeÁ$ÜÁ ¢Á×[Á¬ Àú WÀò[ÀëÖñÀæyIÀâÇÎÀà• ÀßÚ¹Àà„ÁÀâ”1ÀåýðÀë>!Àñ„ÁÀùfÁ&˜ÁjÁ êÁJôÁ@ÒÁ ŒQÁ(×bÁ1(fÁ:.?ÁCõþÁMÃiÁWâÉÁañÞÁlŒ Áw‹BÁW5Á†ðÁŒ¾oÁ’ KÁ˜vÕÁžlWÁ¤‰àÁª¼GÁ°Á´H_Á¸Î ÁÆ‚íÁÁIÁºÒõÁ´vðÁ®+‘Á§ÚÁ¡ŽÖÁ›e<Á•fìÁ‚ Á‰–;Áƒß\Á|¡fÁqPÁfõêÁ\¾ëÁRç-ÁIXÝÁ@|jÁ7âkÁ/îˆÁ(waÁ!bÁv{Á¿àÁì£Á i®Á¤Á‘ÆÁ•ÁA Á>’Àÿ ‚Á5ÜÁ†ÁЮÁSºÁ<`Á ôÁ-^ÁAÁ¹hÁ gÁ'aÒÁ.MuÁ69ˆÁ>v[ÁGMÁPfþÁZ vÁc’ Ám2OÁwSÁ’Á†–ßÁŒ%ÇÁ‘»ÄÁ—ƒsÁ[?Á£.ÆÁ©Á¯9¡Áµc|ÁºÏÁ¿-´ÁËíùÁÅ…\Á¿6VÁ¸ý¸Á²¶ÆÁ¬uÁ¦R;Á W„Áš/Á”³€ÁŽÿÝÁ‰qTÁƒñmÁ}BÁs ´Ái16Á_ëÁV{®ÁMȉÁE—¡Á>@Á6¼”Á0&µÁ*LLÁ$Ö½Á ÁÞÑÁ)NÁ8nÁè€ÁèÁ3QÁ«ÔÁ%×ÁíÍÁš˜ÁÚ7ÁÄ|ÁdÛÁJÓÁ$.QÁ)äÁ/>Á5bŒÁÁÉúÞÁÃÄMÁ½ŒÙÁ·aÁ±I¬Á«SdÁ¥ÝÁŸÉVÁš%Á”’”ÁGÁ‰ÀÁ„ž…Á[ÅÁu¹fÁl|êÁc½2Á[D™ÁSŠ*ÁL$ÁE*Á>ñ0Á9)<Á4(Á/OÊÁ+T.Á'¿¹Á$è Á"±]Á ÿÇÁ ŒÁ‰aÁöÁ ÁÇÁ"dÚÁ$kVÁ'acÁ*¿Á.Á3*ðÁ8–Á=ŒCÁCq7ÁJLçÁQR‡ÁY'{Áak·ÁiîÁrw?Á{¦eÁ‚¡Á‡0kÁŒuÁ‘N£Á–µ«Áœ;ÝÁ¡ÁÁ§QHÁ­iÁ²ÒÃÁ¸¡ôÁ¾Ž ÁĘÁʵqÁÔÁyÁΊâÁÈXîÁÂBÁ¼DÀÁ¶W\Á°}¼Áª»˜Á¥pÁŸ™+Áš- Á”Ù~Á¤sÁŠ­>Á…é-ÁGÁy¶ÁqIÁi€Áa‹ÁZZÌÁS¢úÁM¸¤ÁH,ÁC<ÉÁ>ŸäÁ:ÊMÁ7bóÁ4–RÁ2z:Á0àtÁ0õÁ/h_Á/Ê|Á0Ž@Á2/Á4 'Á6è¹Á:,¯Á=¿ÁB'êÁFß4ÁLÌÁQ«UÁX8AÁ_@§ÁfžñÁnÀÈÁvç¥Á¹ÁƒìùÁˆ“fÁ@«Á‘ÿÁ–ýfÁœ7ÚÁ¡•­Á§CÁ¬ŒaÁ²Á·ÊBÁ½”YÁÃeÁÉIùÁÏG\ÁÙTÁÓ(³ÁÍ)ÁÇ*(ÁÁ@&Á»d¯Áµ©¼Á°~Áª˜FÁ¥*YÁŸçªÁš´ÏÁ•®÷ÁçÜÁŒMòÁ‡Ø·Áƒz1Á~¡RÁvößÁo¯SÁh¬óÁbPÄÁ\‹«ÁW7ÁRhkÁN¼ÁJ@'ÁFúXÁDE£ÁB2]Á@À~Á?ê]Á?2+Á?œ\Á@\üÁAó ÁC»ªÁFn)ÁIv0ÁLë<ÁQ*ÅÁU®TÁZÊÓÁ`mÁf@ˆÁm6yÁt\]Á|eÁ‚tÁ†ÁÁŠ4¹Á޳eÁ“V“Á˜ØÁœÜAÁ¡ìÞÁ§#[Á¬eèÁ±ÑŠÁ·XÊÁ¼åÃÁÂŽªÁÈZ:ÁÎ/ ÁÔ „ÁÞ Á×öýÁÒ \ÁÌ$pÁÆLðÁÀ™?Á»ºÁµ–EÁ°&ÉÁªÕÏÁ¥¹šÁ ¹ÉÁ›á—Á—IÁ’ÍGÁŽgÌÁŠ&:Á†2Á‚<Á}ô¿Áw$9ÁqØÁkk Áf0VÁa’³Á]]5ÁY²—ÁV„ÁSÿ¡ÁQÝ7ÁPŒÁO®õÁNûmÁOZEÁP$ÆÁQ ¿ÁSSfÁUâÁX¸±Á\öÁ`cÁdxðÁixÕÁn¹zÁt†tÁ{/ÕÁ&|Á„ÙäÁˆÂ0ÁŒ¨aÁ§Á”ó§Á™}Áž{Á¢Ä Á§¯•Á¬ÆÑÁ±ôÁ·2ÁÁ¼œÁÂ%5ÁDZ²ÁÍZÍÁÓ'ÁØùéÁÞÁØeñÁÒe?ÁÌkÂÁƃžÁÀ¿ÙÁ»&0Áµº…Á°oÜÁ«ŽÁ¥ÝÁ ÕNÁœ$Á—NMÁ’̶Á›NÁ†—¤ÁÁ‡ÅÆÁ‚¡*Áw~,ÁisÁ[ˆÁMüÁ@š¤Á3„ÒÁ&äpÁxºÁ³DÁÒ¤Àóì¹ÀáÃqÀÒä™ÀÆêÀ¾ZKÀ¹!aÀ¸FgÀº»ÀÀÖæÀËXÀ×ÍÀçq+Àú)ÁòmÁðMÁ¤TÁ)Ï„Á6wMÁCv¨ÁPÚçÁ^m»Ál$‰ÁyÓ£Áƒ[Á‡bÁ‹‰×ÁØôÁ”vfÁ™YlÁž]Á£fyÁ¨¦éÁ®ÈÁ³º:Á¹^óÁ¿üÁÄÿmÁËÂÁÔ ÁÎJrÁÈ ±ÁÁêrÁ»çtÁµé\Á¯ù@Áª2Á¤›ÁŸ7NÁ™ëVÁ”—ÁfhÁŠz!Á…³¼ÁfÁy—óÁoìÁaÅÔÁSÊ ÁE»ÅÁ7ïÁ*všÁ/²ÁnEÁó2Àð4§ÀÚ£0ÀÇ+À¶$<À©)ÃÀŸkÀ™_žÀ˜R—À›AéÀ¢ªÀ­¥=À»†#ÀÍIÀàÌÀö¥ûÁÁZ<Á ˆÁ-GÎÁ:Ì…ÁH{ŽÁVHJÁc—ÈÁp´°ÁxÛºÁ€’ÙÁ„Ê»Á‰OýÁŽ#¹Á“'qÁ˜,RÁfÁ¢Ø[Á¨vÇÁ®ÚÁ³ØÁ¹¿ùÁ¿ÎÂÁÅô$ÁÏçÓÁÉxšÁÃ’Á¼ÒáÁ¶­Á°¨ŽÁªªjÁ¤¶ZÁžíûÁ™X©Á“õúÁލ‡Á‰V8Á„0pÁ~¡-ÁuWÁl -ÁcÆ:ÁYŒÁK•IÁ>DÁ0€Á" ½Á_sÁó»ÀóôúÀÚñ¯Àà åÀ­ÁçÀš«áÀ‹<À€/…Às|îÀpÊMÀw¬‰ÀƒÝ¨Àn À ¦LÀ³Ç¤ÀÉnUÀáÀùÐ*Á È™Á2%Á$ÔŒÁ2‘íÁ@#—ÁMI'ÁZ‡ÅÁc øÁk7ÛÁs‘LÁ|bÁ‚ð®Á‡ð`ÁŒóªÁ’%±Á—”òÁ3TÁ¢×@Á¨•~Á®BÁ´•ÍÁºÁ¬ÁÀûDÁËR„ÁÄÌ×Á¾VÁ·î¨Á±ž,Á«qÁ¥i»ÁŸk÷Á™unÁ“«1ÁŽçÁˆ´¾Áƒe¸Á|0]Áqþ¼ÁhN-Á^ÓÃÁV 'ÁNIÁC2Á5w¥Á($<ÁO Á a½ÀüÌ3Àá³§ÀÇ0ëÀ®]À•ì³À¼À]’²ÀCûoÀ4¯¦À1 õÀ8ô>ÀL¡ÀhÓµÀ†ëêÀœ<=À´ âÀÌöÀç5¥Á0ÞÁãÔÁ vÁ)ôÁ7KÁDu@ÁMb.ÁUJÁ] 4Áf7iÁo†ÁysÁ¼åÁ†åÐÁŒQŽÁ‘ïàÁ—•8ÁTËÁ£D­Á©_»Á¯“ÁµÔcÁ¼"ÁÆæÁÀCÙÁ¹³YÁ³9 Á¬ÇyÁ¦m3Á 7ùÁš,-Á”/DÁŽ6óÁˆj¤Á‚Ù˜ÁzçAÁpEíÁe»vÁ[©UÁQûLÁH¦;Á@/5Á8rÃÁ-i'Á~ÄÁêÙÁ×ÀíçÀQÝ!À(®ôÀ \¿ìd«¿ã!Å¿õ»xÀNvÀ4§åÀ^,òÀ‡\À ;§À»$dÀÖƒ5ÀòîÁsÈÁ¡Á Ù©Á.…ëÁ7éçÁ?i¶ÁG¯ÐÁP&$ÁY9;Ác ×Ám/ÁwM1Á/Á†¬mÁŒTÞÁ’Á˜ Áž-fÁ¤hþÁª²öÁ± âÁ·yJÁ„nÁ»ÛšÁµ9%Á®ßÁ¨"Á¡¦Á›@ÅÁ•TÁŽð¢ÁˆôÎÁ‚û‰ÁzYÛÁo8ÐÁdeVÁYÄ?ÁOPÁEZµÁ;©èÁ2••Á*{êÁ"̳Á³Á ²*À÷­ÁÀÝ–ÀÁÙöÀ¥÷ ÀŠÖÀ]”¸À)ï¿ñSa¿ –J¿a}É¿J,¿z¿·5ðÀ aÀ4-èÀgÑWÀPlÀª¶QÀÅâŠÀà“ZÀú­‰Á ÓÌÁÃþÁ"…=Á)µ»Á1¿×Á:0‘ÁBÿ¥ÁL§'ÁV¥”Á`Ð|Ák•²ÁvÒbÁ¤Á†Û<ÁŒÔÿÁ’ÿ§Á™D’ÁŸ˜ Á¥øÊÁ¬réÁ³ Á¾OÁ·ƒPÁ°ÑNÁª.¿Á£CÁ;Á–ŠTÁñÁ‰Ñ Áƒ·ÌÁ{z`ÁoˆÁcåÍÁXÀdÁMãÓÁCIµÁ8ñ¥Á/ VÁ%j Á®ÁψÁ (eÁJEÀçì=ÀËûàÀ°@À•åžÀu;IÀ=ƒsÀÝ¿¢B¿~Ì=SæA>:­Æ½Œøß¿)WR¿´|šÀ3²ÀG ùÀ}|ÇÀ™‰‰À³ú¬ÀÎ\Àê :Á7nÁ ’ÁAoÁÓ£Á$>}Á,àÍÁ6MòÁ@BèÁJWìÁUÁ`O5Ák¶GÁwG˜Á£‰Á‡×¡ÁŽ'Á”…]ÁšðÎÁ¡vŸÁ¨Á®àMÁºYoÁ³g?Á¬ŒpÁ¥ËçÁŸ$[Á˜äÁ‘ê•Á‹omÁ„úÁ}JŠÁq…Áe~ÁY#xÁM{„ÁBJšÁ7bàÁ,ÙÁ"¥‰ÁÁÄÁH|ÁôtÀþNoÀïWÀÚ¾ŠÀ½*À „ À„¢hÀSÁGÀux¿Ï'¯¿?ÅP=aX†?In?‹??6Ó×½v8¿báû¿ÞvÇÀ%ÍÀZgØÀ‡VªÀ¢Ž5À¾îHÀÛÈÀ契Àý¸öÁeÁLhÁæ6Á rÁ)ééÁ3éHÁ>‹xÁIÐéÁUFvÁ`â°ÁlïßÁym»ÁƒGÁ‰||Áï&Á–LÁ5DÁ¤êÁªîhÁ¶ƒÁ¯êÁ¨&Á¡¡ãÁšÑNÁ” Áw’Á†×PÁ€T†ÁsÁÁg9ÁZ¨âÁN³xÁBƲÁ7ÃÁ+Ø{Á ã5ÁvÛÁ ggÁyrÀò««À‬ÀÓ2ÀÄ&XÀ²~cÀ“æ9ÀkÕQÀ2¡÷¿ög0¿Š­ÿ¾ƒþ›?Ó)?ˆ¹Ñ?½ ?€yÅ>óÎò¾· c¿˜í¿Àf”À69xÀnݨÀ”Z<À²LÀÀņ÷ÀÒï‚ÀáJòÀðµÁ÷ Á ØcÁžùÁˆðÁ( Á3YSÁ>à[ÁJ‹ÁV¨Ác>üÁpûÁ|ïmÁ„ñwÁ‹‘±Á’TþÁ™6 Á šÁ§Á²ñÁ«ß£Á¤Ñ>ÁéÁ–ÆYÁãþÁ‰ ¨Á‚r³Áw•ÍÁjs^Á]¯ÁPʰÁDZBÁ8VˆÁ,kƒÁ ˯Ák¬Á lEÁ*ÀìRÂÀØ–ïÀÇ4³À·©À§÷ãÀše²À‹ÀÞÀYzPÀ!'¿¾_"¿jÔ>‘ØÆ?–X?S\Ý?ÆÄÏ?‡!Â?\ã>Ep3¿ ×È¿¿ÛÀO¤ÀW¶ÞÀŠüæÀ›´QÀ¨\ŠÀ¶€¼ÀÅ,òÀÖÊÀç}ƒÀú¹Á=†ÁŸ,ÁëTÁ(‡×Á4EeÁ@t÷ÁM(ÔÁZpÁfåâÁsñ¢Á€©DÁ‡~ÁŽg;Á•QÁœ9ùÁ£.Á¯y`Á¨HFÁ¡%çÁš]Á“Á‹ý*Á…<Á|ajÁnðŠÁa×ÁTKIÁG_»Á:¤aÁ.‚Á!ù—Á’Á ôÀþÀè ÀÓÎ À¿Ö¶À¬‘iÀ›È2ÀŒUÀz¦¦Àbc¼ÀH#õÀšÀ¿¤–“¾›† ? ‰Ž?½`?FS?ÉZ*?ÄyÆ?£]F?0徂ƒ<¿ºFÀ7CÀHS,ÀcnYÀ}âÀ‹·Àš]ÚÀª3ŒÀ»‹ŒÀÎ4ÀáúDÀö€¬Á‹ºÁ:,Á Á*Y­Á7ÕÁCøéÁPà…Á^oÁk•ÙÁyaØÁƒ-ÁŠŠSÁ‘~fÁ˜†ÿÁŸœžÁ¬@6Á¤õÈÁ¶ÃÁ–€ÛÁ[ÁˆGÁ<ˆÁt|ßÁf¦·ÁYçÁK£4Á>?–Á12rÁ$ƒ%ÁíÜÁ Ÿ ÀÿzÀèhqÀÑ__À»rbÀ§GñÀ“jÚÀ€üÀ`ƪÀB«ëÀ(,ÓÀ=b¿çü¯¿©ÀT¾·aé? -?Ž×U?§©?ñlD?ûåh?Í#‡?9SÙ¾ŠÈ>¿—øý¿áñžÀåöÀ)aäÀBÃpÀ_\¢À}cBÀ­;À¡¯XÀµ‚ìÀÉý¦Àày`À÷Ù\ÁîÁA÷Á!×Á-ïjÁ:÷ÁHOhÁVŠÁcâÖÁq†Á¥YÁ†ÙÌÁïüÁ•TÁœRÁ©ÃÁ¡Ë$Áš~"Á“4Á‹õ“Á„ºÐÁ{!:ÁlùÁ^÷¾ÁQÉÁC^óÁ5Ù Á([VÁGÁe«ÁÐFÀê¤dÀÒÚ<À»ÐüÀ¤É‡ÀŽîóÀu“zÀN+3À+&€À !¿ÛþQ¿©Ý0¿g¥À¾û ƒ=‰5µ?UÉ“?Ýä<@¼k@#|\@#\?î¾O?z=‹>dD3¾ÉÌP¿g¨7¿ª¹—¿ÞèyÀ vÀ'½üÀH¿Àj”OÀ‰-Àº À³á¨ÀËO°Àã­±ÀüT¼Á ÿQÁPÁ%@?Á2ÈhÁ@¤WÁN‰“Á\otÁjlAÁx˜6ÁƒctÁŠzÔÁ‘iÁ˜Ó×Á¦2;ÁžÅÁ—bIÁ .Áˆ¼Ár•ÁthÐÁeí—ÁW‘2ÁIsQÁ;Á-ÎÞÁ "êÁŸýÁ6ßÀð¤À×kÓÀ¾;vÀ¦BôÀ:Àp ‡ÀDÜžÀ¦"¿ës¿¨®¿WšY¾Úh'¼>I>Ïò?bD%?ºúI@ =¾@=1@Sû9@L1¡@rW?ÏT?€R½>ê¹¼©Ð¾âfÍ¿Xf”¿¤Í„¿â_çÀçQÀ9©ÝÀbúaÀ‡]wÀžöoÀ·yÀÐHTÀê\ªÁpŸÁÐßÁ¥Á+yQÁ9cÁGRlÁUvˆÁc¥}ÁqÔyÁ€žÁ‡?!ÁŽƒ¤Á•ÅÁ£eâÁ›õÇÁ”ˆÁZÁ…°Á|&Ámó÷Á_boÁPæzÁBo Á4åÁ& (ÁFîÁ ‹ÀùÓžÀÞßÀÄÉÀÀ«NMÀ’ÝÀs¸­ÀEFHÀúj¿×Ýo¿‡÷B¾ö$n<ðëÌ>ô‰?b»ë?¦fÃ?Þ P@C4@7-•@e…®@…]y@pß@AIO@Ø’?ée»?©M?aOÞ>èmð=å¾Ö@Û¿p¼m¿Â8À vÀ6îÀe¬íÀ‹ª±À¤Ö À¿q9ÀÚ1éÀõGoÁ•©ÁÉÁ$lÁ2þÁ@°ÁNÞ4Á]ÍÁkqÜÁyìÁ„5EÁ‹oÅÁ’±ãÁ Í8Á™DBÁ‘ÅŸÁŠN=Á‚ÞÊÁvâ%Áh ›ÁY6yÁJvàÁ;à–Á-nÁ ´Á½]ÁÈ3Àê`ÀÎ}À³aÅÀ™"jÀ~‡ÐÀKûÃÀ肿؃¿}V˜¾š^›>§Ù?^& ?¬þø?ä0@ PÀ@'Ä@F÷b@jxž@ˆ³+@Ÿ½@£‚@sfÒ@MAâ@+µ0@ £O?á×ê?¬5.?hV5>Ò…n¾Þ¿H¡¿¼q5ÀoÀÀ@'HÀsêÅÀ”Ë´À¯”ÂÀËFÆÀç7DÁ/Á’JÁÀgÁ+ÿ>Á:HÁHƒæÁVܵÁeV‡Ásá¡Á=¿ÁˆGÁâèÁžQÁ–¾éÁ2!Á‡§ÈÁ€&\Áq\6ÁbmzÁSšÁD¶ Á5àôÁ'¹ÁtÁ IÀ÷xPÀÚãUÀ¿ÚÀ£’´Àˆ ÞÀZö'À'5B¿çÕ쿈Vþ¾£‹>È…H?ˆ$ß?Ö[@ g1@*Y@EÄ#@`o@}‡_@?q@¡Ù·@µáÝ@¦E–@“ £@€¹@bï[@EŒq@)•$@ˆ4?à¢"?›i®?¾½Ïw-¿\­¿Ò)LÀŠuÀT9)À…bXÀ¡UÀ½IÅÀÙH¡ÀõÉ Á .3Áw~Á%²…Á3ó¤ÁBgOÁQ¤Á_£´ÁnC*Á|÷‡Á…ؾÁ5ÁÁ›ýãÁ”cRÁŒÌWÁ…5[Á{=YÁl,Á]ùÁNLÁ?-0Á0>†Á!a©ÁŒfÁËÍÀêc'ÀÍ—gÀ°ÝúÀ”OXÀqZœÀ:xóÀZo¿¡'ؾéC> Ä?†¨?âdX@,@A+Õ@a@}\7@Œhã@šzé@ª“@»q @΄@¿ª@­~@ò@ Ú@~®@avû@D³X@${?û??¢€k>ýƾ£ö»¿”ÊÏÀwdÀ8grÀpX¡À”$èÀ°fÙÀÌĨÀéM¬ÁðlÁUÁÅïÁ.NyÁ<ÚhÁKsûÁZ1·Áhö¼Áw¿EÁƒGõÁŠ¿ŽÁ™ÜÅÁ’) ÁŠ2Á‚ßÁvjÁgbQÁX5aÁIpÁ9èúÁ*êÁñ#Á þ+ÀüXÀÞx2ÀÁ)À£ðÀ‡§ÀT¯ÀúϿʷ¿;,=·ãª?d™ü?Öç`@a@H¿ñ@rtw@‹Rb@š`Ù@¨œ@¶i¾@Åa=@Ö'E@çý‘@ÙÞ§@È~„@¸"@©Lú@šŸÇ@Œg @y³_@TŒ«@'´ð?éÚÂ?|}Ô>:…¿:1³¿Í+ÀvÀVáÎÀ‡ÅìÀ¤/PÀÀÙÇÀÝ®òÀú‹ZÁ Â)ÁLþÁ(òåÁ7¯üÁF~“ÁUMRÁd.øÁs*ÚÁÁˆ¤KÁ˜ªÁH#ÁˆƒúÁ€Ç Ár%eÁbÑpÁS•uÁDa¨Á54œÁ&¬ÁÛêÁÐãÀñ«†ÀÓµFÀµ¿À˜ŽÀu|À; äÀ3Ï¿I¾ƒEn?Y†?·tÁ@Œñ@Aó›@r(ö@Ü@¤¾Â@µá@ÄT]@Ò^@áq@ðØ{Aþ4@ô)â@㥨@Ó™Â@ĽI@¶>p@§+Þ@•\Ì@}k‚@HjZ@™J?¶TÎ? ßq¾¥ä²¿škÎÀVÀ>ìóÀxJ;À˜é Àµ­ÀÒ}†ÀïΧÁ›XÁO]Á$PÁ2ïYÁAíÁPîGÁ_ô>Áo•Á~*AÁ†¯GÁ–aŒÁŽ–=Á†ËàÁ~5ÁnsiÁ^äÁOdÁ?øÙÁ0§½Á!pcÁ;iÁ Àç³îÀÉpÀÀ«yKÀ†À_OÞÀ#¥ª¿Ñü0¿9oy>3 œ?‡x˜?ö<Ÿ@1x@eQ7@Œ#@¤X7@»Š&@Ï‘¥@ßyÒ@î2k@ü¡AøAZ„A@þs'@ï+0@à%J@Ñ6’@¿æÝ@¨‘;@­Ÿ@dC¨@,º·?ép?ql"=] Ä¿V&c¿ÝÔpÀ(l[Àb5ÀŽFòÀ«ƒ%ÀÈÜ÷Àæ6ÚÁÛæÁƳÁÆ-Á.ÅôÁ=È÷ÁLêÜÁ\+ÄÁk=ÁzÝÁ…SÁ”ÖKÁCÁ…4üÁzÏêÁk5ÛÁ[›ÌÁKþwÁ<`¥Á,Æ Á=”Á ÎÒÀýVÀÞšÀÀ.ÇÀ¡Ã ÀƒXüÀJ¡ÊÀå‘¿¦R±¾»hý? L,?»¦Ð@Hõ@O~ÿ@ƒ @†@·A¢@ϵÙ@æÛ’@ùûAÅÂA °AÛýA–PA÷ãA èÁA*³@û> @êjŒ@ѳF@¶{_@šâ­@}×@E„}@ Šö?¦ÒQ>Ñ’¾üöµ¿³—VÀ<˜ÀNÀÀ„«…À¢eÑÀÀN;ÀÞ8ÉÀü2Á Á2 Á+YgÁ:œôÁIô+ÁYQvÁh³ÁÁxÁƒ¼:Á“›4Á‹µÁƒÐ®ÁwßzÁh%èÁXvuÁHÑUÁ9-‹Á)Š|Áë¼Á MêÀõ`/ÀÖ7À·T?À˜ÓÀtÏ«À7ük¿öko¿{šP½J·?bG?èqW@/2ý@iÑã@‘|Î@­c¸@Èaø@â3¼@úö5A ˜A#AÜgA![”A)DŠA"Z’A†äAµA aê@ú³"@ß4¢@Ãté@§Eò@Šê@\•}@#W?Ñp?:P“¾G°þ¿5ÅÀ¦+À>L’ÀzÀšüBÀ¹1DÀ×y8ÀõÁ,Á /ÁRdÁ(©ÕÁ8FÁG[ÕÁV»ÔÁf(pÁu§ßÁ‚™\Á’ºÁŠ™·Á‚²Áu•ºÁeÈ3ÁUúÊÁF-aÁ6`!Á&™?ÁÞÁ2´ÀïÔÀÏÖ@À°Ž­À‘GÀdbÀ&#¿Ò ¿2p>ö¿?™„ @|B@Ds@¶@‡Ü@ºúÞ@׌¼@ò÷hA—A1YAµWA'E0A/rA6ùèA/ñcA'õ@A1A¬ AéÁ@ëÉù@Ïmï@²Öv@•íÍ@q‡J@6ª®?õÿˆ?}ZÝ=kj¤¿b>ð¿êçÀ1s+ÀmäÀ•*.À³uÈÀÑêgÀð€$Á¬ûÁ"_Á&—îÁ6 }ÁEƒ ÁU<Ád‚JÁtWÁÃjÁòeÁ‰´OÁĶÁs­ÁcÓîÁSþÑÁD+Á4W:Á$ƒnÁ¯¢ÁÛÖÀêÀÊh”ÀªÎÀ‹`±ÀXOlÀë ¿· ]¾é©x?_ò?¼œY@f*@Xa@‰òé@§µP@Å}‰@ã)A[ A†…Aÿ·A(Ñ»A4L¾A<ÂEADkƒA=v~A3æm„Ó¿6æ$¿ÕÐÀ(ÀÀe*ÚÀ‘&‚À¯¹4ÀÎu.ÀícÇÁ)5Á ‡Á%Á4™ÝÁD"ÁS¯xÁc@÷ÁrÕÇÁ6§Á‘ãÁ†F Á~ÐÁoÜ1Áa·¨ÁR¸þÁBË Á2Þ=Á"òëÁ ‘Á"æÀæ‚8ÀÆÑåÀ§<ªÀ‡®6ÀP?†À"Ÿ¿¤Ⱦ–ùG?1I?Ö°@)¡@g@’b‚@°Ík@Ï8U@íkAnàAÑAI¿/AR”AHprA:Ÿ®A,zŒAÙAK?AC®@â ·@Ãlà@¤²ç@†œ@N´£@¶?§;>±ú^¿.¿É5À"®±À`5 ÀŽÝ´À­¸½ÀÌÀ Àë¾ ÁZWÁÕ§Á$Y Á3ê7ÁC}HÁSƒÁb±„ÁrMþÁ€÷NÁŠ’¬Áƒ+ÁwmµÁhÌÁZ[yÁLmÁ=ûÁ01NÁ"TüÁgÁ|mÀå*øÀÅ`À¥•BÀ…ÊgÀL À yE¿™Øû¾Uû_?H›Õ?ã-@0¿@oº«@—[*@¶ÎF@Õö?@õåA ÁIAâ£A'×yA6~ADæYARÙ£A]ÀANæ´A@lèA10KA!´BA$SAî@åçy@Æ­@§†$@ˆ¨-@S-H@åF?­L >İݿôÉ¿ÅÓ À –nÀ^C ÀŽõÀ­­ÀÌÀë#ºÁWÁ˜çÁ$$NÁ3¼_ÁCV¦ÁRò¢ÁbùÁr-ÞÁ€çÁ‡ï]Á€]Áq›ÀÁb™íÁS½VÁEhÁ6˜'Á(SiÁCÁ œúÀÿ&ÀäÎÀ݃À¤ß8À… íÀJyDÀ Ö¯¿–\î¾8X‘?P_?ç^@2úš@rl@˜î¹@¸§n@Øaú@ø!›A çüA­>A+r€A:öŸAJ8AXžAYRAJ¼>A<¶CA/ A!…AŠ—Aâ@äï,@ÅÚ”@¦Üq@‡ÙÐ@Q@†Ž?« Â>¼Ó¿@€¿ÈuAÀ"0-À`DÀ4ŒÀ®GeÀÍZ=ÀìmÁ¼Á8Á$»kÁ4L9ÁBðaÁQo£Á`½ÁnÖtÁ}Á¸Á„fÍÁzìyÁlz{Á]HHÁN% Á? ªÁ0!Á!TñÁÖ—ÁøÀí(¡ÀÒVÀ¸ê[ÀŸÿÀ„ÌÀIîcÀ D¿•5®¾/?RâÓ?èÄõ@4 A@s¶@™«@¹j@Ù)!@øè%A SA.ÆA, {A;â¦AK·®A[‹†ASÀ(AEI6A7GA(ñËAGA ZŒAƒ@â= @ÃZ@¤g´@…sP@LÿM@ Ø?¢F>™V~¿*Û¿Ñ0µÀ&ƒ¥Àdp’À‘.óÀ°/½ÀÏ3tÀë´:ÁÁï°Á* Á-°ßÁ<[jÁK4¨ÁZ+Ái+1ÁxI Á8Ásï ÁeèrÁX ÁI9%Á9æEÁ*³"Á’qÁ  ÀûFJÀÞ0úÀÁ£²À¥ô—ÀŒ>Àeð À6áÒÀ€·¿“G¾ Ý9?[>¹?ìz`@5ª²@u3@šBÛ@¹þ¢@Ù½ë@ùvùA ‰ËAXA+ñÂA;09AJ ËAXýÏAOlžA@¥mA2ÍA#´^AàA¦™@ô8î@Ù¨@Àv¿@¡Óå@ƒ·@Hvn@ È"?šDî>wç¿9ù ¿ÙÀ*”UÀh˜’ÀŽCjÀ¥‘8À¿ÀÚa†ÀöÈÁ ó¿Á®WÁ'œ¥Á6–íÁE°vÁTë«Ábþ*ÁpÖÁ|jåÁmÐþÁ_gÈÁQ4ÑÁCLÁ59xÁ&+Á³ïÁUiÀðAÑÀÒ óÀ´GÀ–ÅŠÀto‚À> À 袿¹¸e¿0Mv=æ¥H?„<¥?ÿ„÷@=S~@zê¾@œhÕ@»†ñ@ÚÍ‚@ù“³A 5A†ŸA(K2A7'JAEóZATèÞAKôcA<é©A.ZAQ†AçÁAÜ9@ê6÷@Ï4ç@µÆ@œ˜ã@ƒy@I¥@ RT?è5>‘o¦¿%ý?¿¾xÀrIÀB¨ÀqqÀ’óEÀ¯=“ÀÌsúÀêòÁôÁÐÁ"W2Á1¸tÁ?ÞÞÁM±2Á[¶ðÁiý­Áw‰¨ÁhŸ+ÁYÓºÁK0¹Á<Á Á.{³Á lcÁ§¼ÁY»ÀçŽyÀÈ‚°À©›ÆÀ‹/úÀZ8À0¿Ì«Ï¿KšB½>_­?8äË?¾B;@4@O9>@‚38@šqÂ@´ç[@ÐëT@íäA§TAƒÍA#~òA2øAA­IAPä%AIHA:+A+6»AV‚A žd@þa:@â0]@Æ™f@¬@’Ε@va±@PS@Bl?Å”N?4± ½Ô2ƒ¿r ¿ÏTùÀÀOoKÀ…QÀ¢ïZÀÀþjÀßÀþv”ÁλÁŒçÁ*¦ Á8µÁFìÁUcÔÁdÁsfÿÁdQÁU8_ÁF8ãÁ7dÈÁ(Ç}ÁkËÁ 1Àûì­Àà³~ÀÂ;ïÀ¢ÁjÀƒW¥ÀH=À 〿› n¾ ËÊ?H?«À½?ðÝr@ ¥¥@2& @dX®@%,@©@Æ4®@äôA!íA:úA`zA.«A> |AMjMAGÇ™A8x>A)=PA -A ,#@øÔœ@Ûä @¿”·@¤1ì@Š +@e…:@;~@Äw@¹v?”u­>Ö£þ¾Sź¿€åö¿÷€›À7›#Àu ˆÀ™Ä²À¹E<ÀØ1ZÀòþëÁvíÁÖ¢Á$(ÎÁ2“’ÁA>*ÁP†Á^ügÁp;Á`Ú8ÁQŸcÁBqÁ3N'Á$SáÁÛÁ>Àð«rÀÔ¡À¸£Àœ À|â¥À>)¿þ÷ä¿j½rl?Y8 ?¯<ö?ª ?Ï;í@Ñ@Jì@‚WD@ %1@¾(¢@ÜeG@ú»4A ² ALA+l¤A:Ò7AJF'AG×A7ŒA(+lAë|A Ë–@õz@×ÜÝ@ºñ@Ÿ ƒ@ƒá!@U÷œ@*iÃ@Äo?Ötó?¾‘ã?F¥›>Œ @¿2¤v¿×·SÀ+]+Àk#MÀ’âòÀ®öÀÉf ÀåîÄÁ›¾Á<=ÁÙeÁ-³;Á<žXÁKªÆÁZÙÅÁmÛ«Á^tôÁOÒÁ?ÅtÁ0‹ÁÁ!XºÁE¼ÁK+Àèâ¡ÀË”À®'À‘£ŒÀi<À0¦4¿ç¸Ù¿XŒ=øëe?‹È?@¡È?Yr?” _?üðK@9ar@uuç@˜É&@· D@ÕÊb@ô¾"A ÚATýA(ÒA8a·AHAGÞA7‰¾A(ûAÂ1A ƒM@ôÃ-@Ö·à@¹K´@œÈo@€ù±@L&Ò@Ìæ?Ûi@?Ž®?eþ_?ŒK>Üк¿ ÿº}·À’:ÀRªÕÀ† À¡ÆøÀ¾ÝÙÀÜ\´ÀúF®Á RÁä Á)éÇÁ9yÁHi˜ÁWÓ<Álª Á].+ÁMÓÁ>\0Á/¦Á¸ôÁ޼ÁeŠÀä’ìÀÆÝÀ©^ïÀŒT‰À^âßÀ%&ã¿Ñ’h¿+ùÅ>”g?T¾>$»ÓZV­? Ÿ?8ï{¾t# ¿˜±À#sÁ.®íÁUóÁ!PÁìÀäGÖÀÆá<À©B½ÀŒiÿÀ`À#àn¿ÌQa¿*íÏ>“>u[¾Ùz'¾“Í?#|Ô?Ê»ü@"Ù@_…?@ŽÉ€@­âŸ@Í%@ìiáA×XAóA%:2A4ü†ADÆòAHÕ=A9MªA)ÆA8üA ²ƒ@öz¥@×Á´@¹2½@š»\@x” @<áñ@æ™?‘y]>g¾õ'ûß_?B½T¿…5†ÀqfÀ>KÀx"ÕÀ˜éxÀ¶NÀÔ ˆÀò3ÜÁšÁQ:Á&©Á6¥ÁE©äÁUFjÁmSVÁ]ç£ÁN}QÁ?ŒÁ/Ê1Á ŒòÁxÕÁ›éÀçÁÀÊÎÀ®"ÎÀƒúÀbZhÀ&=B¿Øõ3¿i`é¾³ʾØp¿ƒÖ‰¾åMÕ? +?ºe”@a@Y0T@‹®t@ªý£@Ê_Í@éȤA¢éAhÖA$3ýA4ACÑ·AEoqA7$üA({êA†qA I­@õÉ#@Ö—.@·©¶@˜ý¥@tœ@6´ ?õ% ?zÚO=|òž¿TÎv¿ñ¢½±ø¾ª¬6¿¬Æ¿ÿ(´ÀÁæ1Á ŸÁ'RÍÁ6¹ ÁF8¹ÁUÈ£Áo–Á_Å?ÁPzWÁACâÁ20¾Á#H ÁˆÁôÀîK]ÀÏj˜À°ðÀ“-ÀlŒÀ4?_À¬”¿®„Ö¿ù¨¿ê2¿Ã‰B¿ø>>Äbì?­z@…@S\[@ˆø@¨M>@Dz©@ç+KANOAXA"Ã[A2xA@a©A<À:A/ØA!þÇAÞAN­@ìû@Ïhö@±9C@“*¦@i9@, :?â9Y?RU‰½Üz¿ƒÕÁ¿œ\ú¿Ruˆ¿kvÈ¿¸ªÀ X°ÀC²íÀ}¿nÀœYÀº/ÀØl¦À÷3ËÁ òùÁcÁ)-#Á8n¦ÁG¸ÔÁWÁqã€Áb¿ïÁS©ÁD±šÁ5çBÁ&ìšÁŽ0ÁQèÀòqˆÀÔ‘ºÀ·<|ÀšÉJÀžåÀL¬À 0i¿ùöˆ¿Üî/¿èÖë¿Ô+ž¿2XB>‰(?ž9Å@ {ä@L-¶@…WC@¤†Ø@ï¶@â¿ÔAçúA(¶AbdA.×A0jyA.:5A&K1Aò_A ¼@ýu«@áG@ÄÐ@¦à@‰`–@W­`@)è?Á*=?³ð¾ª5¿ žM¿÷¨š¿Ì¯R¿Ñ)¯¿þ¸À(]€ÀWŽYÀ†^—À¢€HÀ¿)ÀÜ«Àú°‡Á tÁÅžÁ+ GÁ:ZùÁIÄhÁYCœÁuN^ÁfÁVË>ÁGŠÛÁ8ZPÁ)<óÁ:Á a¦Àù…6ÀÜðÍÀÁ?‚À¦J(ÀŒÝmÀl©"ÀE´üÀ*Ò®À©ºÀ%™¿æÉÖ¿X›å=âÄn?‰¶ö@2Å@A¡@~ ;@ì1@¼O@Ú[à@øRA Û0A¤A–ÎA qAƘA?AÛVAã¿@í³·@Ò•Ö@¶­î@š1A@{À‹@AÕþ@H?™\>”Œ>¿ ü²¿ÆÁÀ¡®À’üÀ×[À+ô]ÀKaÀt·,À’À¬DÀÇÙ"Àä\Á{ÕÁ<£Á+Á-"ÆÁ@±ž©@ÎÎ<@ë8ØA­€A Ø9AçAx=A*IA ù_A÷@òÜC@Û‚@Áþÿ@§6;@Œ?@`Ó@'þM?ß#?VèÔ½wÝ¿w5¿ï-çÀ0ê‚ÀQi&ÀOå’À\Ã*Àv€øÀŒÒÆÀ¢‹Àº±ÀÓÊpÀîj5ÁcÁJÁÁ!áUÁ0¦Á?}ˆÁN}XÁ]UÁzº›Ákô/Á]ßÁNeÁ?æpÁ1¡äÁ#œèÁ¦Á>ãÀöx3ÀÝÀ?ÀÆá»À±[ÀŸ²FÀ‘OpÀˆ4Àƒ|ÍÀJj\À ù¿£9p¾³Ž ?9C?Àï²@~@Uײ@‡ËÛ@¤S´@¿«O@ØH¼@ëÎ+@÷RÚ@þ®A€1@þëå@÷ÝQ@ìB@ÛAc@ÆÛ@®ÊF@•³@ws¿@A@°@ ˜)?§q]>ަؾåZ¿«[ÊÀ¼ÄÀHNºÀ€‡ŒÀƒþ4Àˆ„­À“¡$À¢„JÀµÇŽÀË1ÀâöËÀü²Á 2øÁã@Á&üÞÁ5MÁC¿»ÁRkãÁaFUÁ~ÑBÁpFþÁaÃÁSsÁE^ÜÁ7†üÁ)Õ›ÁbÁÆ…ÁŸÀð iÀÚ™ÀÇšÀ·œ.À«4À£ÕÙÀŒÀ\êÀ"/Œ¿Îß¿0†¶>f®Ž?õñ@µP@:–@rw@“?þ@«M¬@¿¼~@ÎÍ@؇,@ß7@á†@ßLT@ÙOC@Ï=@ÁÛ@®rU@™'r@‚v@RÎW@Ü£?Õä4?UžÁ¼ªƒ6¿dÒ¿àQîÀ(VÀ`çZÀŒ…yÀ ¨ÊÀ¤(µÀ­ŠˆÀºnËÀËyiÀß!_ÀõîÁaÎÁÉüÁÓ1Á-[ŸÁ;!dÁI(òÁWvÚÁeýüÁê Áu‡[ÁgWÌÁYhÄÁKÇ~Á>T½Á1(ÐÁ$}Ár•Á ã‘Á2Àð­âÀߊêÀÐ¥ÀÅÖ9À³¿÷À–hÄÀr¹RÀ8üó¿ý."¿‰‰<¾8¤f?4.š?È£^@TÒ@MÙÒ@|ùp@“§ó@¤¡˜@± Ë@¹‘¿@¿VV@Á(@¿…Þ@º[T@±Z.@¥S@•­¶@ÏM@X®J@*µM?ôm?F9>¢rŸ¿µ¿¬ÜòÀ t÷ÀDU¡À{´ À™›óÀµ\‡ÀÀžÎÀȲñÀÔNÀãwšÀõ47Á¨OÁºãÁi]Á'ÇÁ4·ÁBÊÁO©Á]Œ Ák³°Á„ÚÞÁ{°xÁmß Á`WçÁS)UÁF0ßÁ9’÷Á-VÁ"’Á/Á úÁ)Àø«ÀëNÅÀܘÀ¿4ÐÀ¢yÀ…̆ÀR5ÀÊü¿Àg¿$ô]>`×?„û?ê¦Ä@#nþ@M¼Î@qš×@‡ÓÀ@’‚Ì@š‹@Ÿ«Ç@¡@â@ŸÑO@›QÃ@“Lú@ˆ©@u¼G@RÞ0@*õ‚?ÿ?¢þ?´î¾ƒž¿¿…eö¿ïÓÊÀ,’ìÀbÀŒkÀ§\çÀ£ÀÞ ÀäþWÀï±Àü•ÃÁMÁ£ÁþßÁ$ð2Á0¢òÁ<÷bÁIÏÓÁV÷êÁdjåÁr-VÁˆ2ªÁXÜÁuEeÁh,¼Á[hŠÁNÔÙÁBºèÁ7:HÁ,pƒÁ"0´ÁǸÁˆ†Á >¯Á…OÀèKƒÀË·ÌÀ¯†ÒÀ“Àm-LÀ6Wü¿þßX¿”–¾²n¹>Û%Ž?“É?è==@›@;Ö@TRê@h@vsï@Ò½@Yê@€1*@wö@i†±@Uq±@<²ò@ Y?öYÎ?£þu?ä½ïìn¿Z{î¿Ð·‘À§ÀN[”ÀmKÀ›­[À¶qþÀÑ.ÀìY Á ·Á}dÁ €0ÁÆÜÁ]]Á% XÁ/Z…Á:f9ÁF\ÁRhòÁ_"èÁl!‚Áyw!Á‹ÞXÁ…5Á}gÁpÀÁdQ¨ÁX<{ÁL±ÁAÈ Á7“‡Á-æaÁ%(‰Áˆ­ÁÊ ÁãÞÀõ¡§ÀÙz§À½8†À¡³kÀ†VkÀV•‚À"›¿Ý>X¿z'ú¾z^G>Ô|?ƒr…?É8@r²@{Á@*€c@7Ùð@@Mì@Båä@A$¹@8ãæ@,W@k–@Œ…?Ï¥ñ?‘S3? Šá½åŒ;¿Js6¿Àû£ÀÛÀ@fÀr=±À’PÀ¬ûÀÆ“ÀàÌ7Àû2Á ëkÁØæÁ:ÂÁá Á'ÌÆÁ0ШÁ:ŽBÁDúÆÁPŒÁ[ÖqÁhðÁt¥¼Á€ÅsÁ؈Á‰`­Áƒ"ÁyñÈÁmòTÁbaåÁWaâÁM ±ÁC@ÞÁ:4üÁ2¡Á*íÉÁÒxÁÁûÁ½ÜÀè#QÀÌêÀ±˜ºÀ–úëÀzÀG—§ÀJž¿ÒÂg¿{r¾³‡>L?0Õ£?ŒÊ?¶ëà?ÙVõ?òx@É@;@ç?ô*?ÜÕ ?ºÊö?^ ?;ì>›…¥¾pe¹¿X'Z¿ÀÂ;À ²œÀ9|@Àgn»À‹âÀ¤àfÀ½©À×T*ÀñGÁ ¼Á¥)ÁÊ’Á'[üÁ-xíÁ4ËðÁ=?ÁF5ÅÁP)GÁZÌ…Áeþ?Áq¯ÍÁ}Á*Á…^Á”&ÁàxÁ‡ÉeÁÛäÁx2Ám*MÁb²ñÁX´”ÁOeÕÁFñÁ?g Á2•õÁ$ȹÁŒÁ Š™Àø`ÀÜï+À«¹À©$!Àw¼ÀqŒnÀBóâÀT¿ß0£¿–O¿(Ì–¾L!Ù>0¹õ>õñú?;P—?jS ?‚ˆ–?‡X?„˜å?mŽï?B Ÿ?ý«>DȾ$0$¿h¤¿ˆr³¿Íl¢À5sÀ9¢ÅÀdÉfÀ‰=WÀŸëMÀ·½«ÀМ[Àé ²ÁÁ ÕYÁ²FÁ'µSÁ4³¼Á;`³ÁB/ÁIÒóÁRd^Á[ÊÜÁeìKÁp±Á{ßüÁƒ¼ÿÁ‰ÂrÁ˜¿æÁ’«ÚÁŒÀÁ†úÇÁrPÁx]}Án]ÙÁdÒKÁ\éÁTŸÁGŠàÁ:sÁ,ÁïÁ‰HÁ<Àî©ÀÕ¸ À½#öÀ¥gÀŽmÏÀqI÷ÀHÀrÀ#$›À¦Ø¿Å4 ¿%r¿D‘f¾ðÓ4¾uG ½˜2]<ß½=ލ= ¥½[±Ž¾_%š¾éY„¿«YÀhaÀ‰r6Àžû‘Àµi…ÀÌ=Àã‘£ÀüÅÁ AÁw{Á#"šÁ/ÃÁ<¨5ÁI€ÆÁO×sÁVþ‰Á_˜ÁgñÓÁqîÁ{ÖaÁƒQ„ÁˆäýÁ޲ÈÁ“tÁ—«SÁ‘äüÁŒUðÁ‡µÁûÿÁztùÁqcíÁiÁ\º\ÁO=¡ÁAÂÇÁ4†Á'HÂÁ1ãÁ lõÁ#ÕÀéÐkÀÒ ÝÀ»hkÀ¥^…Àõ¨À{.VÀXÀ8ÏŽÀEÀéþ¿ÛËß¿·Þ¿œb¿‡Ê¿w[¿kž¿tµš¿…/¿™¤T¿µ”¿Õ¯XÀÌÀKÀ3JÀQÃBÀs*À‹ú¶À ÆUÀµó€ÀËOÀá_]À÷Ê`ÁrÌÁ¤‡ÁµoÁ+åpÁ8k°ÁDá~ÁQ¡¨Á]ÏøÁd†ªÁl ÁtŠLÁ}¯8Áƒ½ìÁˆîÌÁŽPWÁ“ç¼Á¢¡KÁœÝ©Á—I…Á‘ïÁŒÔúÁˆeÁƒzýÁ~WrÁqÄ?ÁdqžÁW(-ÁJºÁ=5Á03TÁ#} Á5CÁ ±ÀþªWÀècÀÒ<óÀ½ÒÀ©öÀ˜¸À‡GrÀpÁ«ÀULÀ>%ÑÀ* ÀÆvÀ ºñÀ{¿ú•M¿ôZ“¿øÎWÀÀ×À ïÖÀòdÀ&öÀ;^wÀQb°Àk¸âÀƒÿçÀ”p8À¥BÀ¸Í=ÀÍÃÀáÚUÀ÷]ÁªšÁ§ÝÁ#œÁ)B8Á5#>ÁA?(ÁM¨ÕÁZ$Áf£ŸÁr[ÕÁy‰òÁ€ÁÏÁ…FÁ‰È›ÁŽÁŽÁ“÷pÁ™ZQÁ§áùÁ¢IÒÁœçÁ—¿cÁ’ÙÁŽ:°Á‰âNÁƒwåÁyȇÁlµ¼Á_°”ÁR¹´ÁEÿ Á9‡¢Á-XÝÁ!;sÁ•¥Á y/Àþì°Àê';ÀÖˆ ÀÄAÀ²®FÀ£@À”½JÀˆ4öÀz EÀgUQÀWžóÀK0šÀB+ïÀ<àÀ9µèÀ;ºMÀ@éßÀI ÅÀUsÜÀcöíÀwÖÀ†S×À’”ÀŸåóÀ¯;)À¿¤fÀÑ™gÀ塦Àø¼ËÁÝXÁz\Á‡½Á'j‹Á2ØÄÁ>©·ÁJˆ¤ÁVÁbì>ÁoINÁ{»5ÁƒžµÁ‡gïÁ‹ŒcÁ3Á”ÇÜÁ™Ï‹ÁŸ1Á­TmÁ§êÂÁ¢·¹ÁÀ¹Á™ ™Á”žœÁŽ"Á‡‘ÁÁuWãÁhtÛÁ[äÁOžÅÁCÂÁ7jÜÁ+ÖSÁ ¸?Á½äÁ ]ÁŽÀð‘ÀÞ–‰ÀÎ +À¿^æÀ±ƒëÀ¥Ò½À›YåÀ’FJÀŠ»åÀ„±À€§²À|u¾ÀyEYÀ{ tÀöÙÀƒ›kÀ‰¹ÍÀ­CÀ™”ØÀ£¾À¯ÍÀ¼'ôÀʨÀÚk¯ÀëLÀþ2'Á‘­Á@=Á´lÁ'+Á2 ùÁ=çÁHnCÁT.dÁ_ö8ÁkÚÁxëÁ‚·Á1-ZÁ(dxÁýMÁ€ýÁt?Á ÔÂÁ)=ÀÿÀöZíÀî…Àç×Àã PÀÞâ¨ÀÝâÀÛWsÀÜsÞÀÞbJÀáÝ•ÀæšÀì¹sÀóëiÀüÕÁR*Á–hÁæéÁïrÁzÂÁ%¾­Á.Á6¨ÚÁ?ôãÁIKëÁRÉÁ\÷¯ÁgÆÁråÁ}õSÁ„”EÁŠYÜÁ+oÁ–mÁœ bÁ¢/gÁ¨T6Á®yoÁ²ÄÐÁ·CÁÄÞ¤Á¿cÁ¸ª•Á²QWÁ¬IÁ¥ÜqÁŸ¨ÿÁ™ØÁ“ÞÁ­KÁ‡æ—Á‚B<Áyu Án¢ÈÁdoÁYÔºÁP;€ÁG Á>B'Á5¥ÙÁ-Ü®Á&žžÁÄÂÁŽ>ÁÿÁè Á jQÁµxÁw4Á¡Àþu>ÀüTùÀúè'ÀûÒÀýËÙÁxÁÁÁ§ºÁ žÁ S­ÁÁ66Á÷ÒÁ#ç¿Á+7Á3Á;oÁC< ÁLnÁUjÐÁ^ÅZÁho*ÁrÂ!Á}€ñÁ„B>Á‰ÆuÁ[‘Á•bÁšæÏÁ ¾ŠÁ¦¼[Á¬Õ3Á²ý-Á¹/sÁ½¬ÁɾjÁÃcœÁ½-Á¶ÙñÁ°£#ÁªyMÁ¤rÁž†¤Á˜ŸKÁ’ÔÖÁ5¤Á‡¹»Á‚NÏÁz4¡ÁoôÓÁf.Á]¶ÁT!ûÁKhŸÁCM±Á;Ï9Á4ϪÁ.0„Á(bÁ"ÇÖÁjÁÀ.Á'(ÁmÁ§ÁÁù7Á ÄÁ =Á f×ÁyLÁÿ9Á4öÁùðÁ;žÁ7íÁ ÈgÁ%â7Á+^œÁ1ãÁ8ÿFÁ@“®ÁHgßÁP<óÁXŒ»ÁaœÝÁjñ*ÁtYHÁ~?µÁ„MuÁ‰äÁ oÁ”’ÐÁš$4ÁŸÜùÁ¥¨ÿÁ«€Á±p³Á·|LÁ½§ÁÃÞ×ÁÎ%‚ÁÇÙÁÁ¨nÁ»n ÁµMeÁ¯P@Á©f9Á£‚½ÁÂ-Á˜*‚Á’¸òÁIGÁˆÅÁƒCÁ|+<ÁrÑÆÁjƒÁa>ÁXß(ÁQ, ÁIÂÉÁC'¢Á<ÈNÁ7'ÃÁ1º1Á-*—Á)BÁ%ofÁ"©'Á 8£Á†cÁ]§ÁÕQÁèVÁ ¬ÁrxÁ!”Á$:4Á'^–Á+*#Á/Œ®Á4“$Á9ðbÁ@åÁFùiÁN;WÁUÍtÁ]‹¹ÁevÁnXÁw-vÁ€9PÁ…ÁŠÁ0Á”jÊÁ™Ö ÁŸ_9Á¤íìÁªŸŸÁ°ruÁ¶GRÁ¼+½ÁÂ1yÁÈYâÁÒŸÕÁÌv¡ÁÆDçÁÀ)Áº0îÁ´LCÁ®mgÁ¨±Á£ Á°qÁ˜B Á’õ†ÁãòÁ‰ ýÁ„T Á˜àÁvÃRÁncÁf¨±Á^á¿ÁWôÁQnªÁK\;ÁEÍ«Á@¸Á<'žÁ8QâÁ4ÎeÁ1ÿDÁ/¾Á. ÁÁ,ÒÁ,b5Á,eÄÁ-nÅÁ.Ó9Á0ïÁ3„PÁ6ƒìÁ:=3Á>[ÞÁCQÁH‰âÁNxUÁUíÁ\,ÁcMuÁj±$Ár³@ÁzÐÊÁÐÁ†WÓÁŠè‹Á¿7Á”ДÁ™ýPÁŸ7´Á¤¡5Áª,8Á¯»HÁµo+Á»?ºÁÁNÁÆòbÁÌõSÁ×AŒÁÑÁË,ÁÅtÁ¿:vÁ¹\DÁ³ŸMÁ®óÁ¨¥/Á£8'Áî”Á˜Ñ"Á“ìiÁBiÁФtÁ†+^ÁÜ Á{Ì›Át4Ál×âÁf)7Á_ÃóÁYèMÁTy¬ÁOŸÁK+fÁGnæÁD!SÁA6›Á?=+Á=võÁ<@3Á;ÔöÁ;à¢Á<°FÁ>Á@¶ÁBËFÁE˜WÁID¾ÁMPlÁRÎÁW-2Á\çèÁcOøÁiÃøÁp®Áwê_ÁHÁƒèbÁˆ[ÁŒäÁûÐÁ•›NÁš}æÁŸšˆÁ¤ÊÁª2Á¯vÃÁµÛÁº“vÁÀGFÁÆÖÁËâqÁѾ>ÁÛö*ÁÕè ÁÏøCÁÊ&VÁÄK#Á¾”Á¸úåÁ³”„Á®.­Á¨çºÁ£ÅÁžÊ½Áš ¿Á•HÁ÷ôÁŒ“ÛÁˆyÀÁ„«ìÁ€ø»ÁzÞÁt-9Án:ÁhO&Ác2•Á^T²ÁZ4£ÁVQIÁSN”ÁPk¡ÁN`ÁLÞuÁK¢ÁK^ÁK2 ÁKùíÁM;êÁOGÁQà£ÁT¨ºÁX­Á\=µÁ`$Áe×ÌÁk]DÁqdÁwz Á~Á‚£ˆÁ†OÁŠKÇÁŽ…Á’̧Á—(ŒÁ›¡áÁ QÌÁ¥B¾ÁªjôÁ¯žúÁ´äÍÁºSrÁ¿ÛZÁÅl\ÁË{ÁÐî“ÁÖ²1ÁÝíÁ×ȾÁÑÄvÁËàPÁÆWÁÀMöÁº°WÁµ1Á¯ÍÈÁª³Á¥lxÁ lRÁ› ÙÁ—úÁ’‡áÁŸÛÁ†’Á0ÓÁq~…ÁdÁVÖ0ÁIÀåÁ=’Á1tÁ%nÁvÁKÜÁñÀþ%–Àð Àå{–ÀÝ¿+ÀÙžÀØgÜÀÚÜúÀà}‚Àé;ÀõËÁ«nÁ  ÁúÁØ5Á(Ø¡Á4D1Á@U¯ÁLñ4ÁYþ—Ág:!Át”­Á›Á‡üfÁ®äÁ‘ÄMÁ–ÞÁšr1ÁŸ¦Á£î<Á¨ãxÁ­òLÁ³7äÁ¸¯²Á¾KÁÃìYÁÉ«`ÁÏ ÁØñ©ÁÒ²¡Á̈ÁÆ~þÁÀ—6ÁºÂÁ´ÿŸÁ¯bðÁ©çêÁ¤ŠÁŸKsÁš-'Á•4]Áz]Á‹äæÁ‡{WÁ‚ÇèÁwˆ•ÁifÄÁ[‚ýÁMí®Á@¯žÁ3j£Á& ÁnðÁØyÁ÷òÀó¿²ÀâÀÓ ÀÆåòÀ¾ŠðÀ¹¼À¸v À»`ÀÁžÕÀËÓÀØS}ÀçôìÀú-pÁE‚ÁB©Á°£Á)ÚòÁ6œèÁCËÁQ •Á^“ÎÁlO›Áz,)Á‚×ìÁ†ÈßÁ‹°Á]Á“é@Á˜¸`Á®-Á¢´#Á§ò…Á­fÓÁ³âÁ¸¥YÁ¾etÁÄMêÁÊ[2ÁÓþTÁͺ€ÁÇzŽÁÁI0Á»:ÕÁµNúÁ¯vEÁ©±‹Á¤äÁžŸ?Á™G#Á” PÁŽîjÁŠbÁ…UfÁ€ÆÁxõõÁoû«ÁaÑ>ÁSɹÁE¬»Á7ÞèÁ*s}Á)©Á,?ÁذÀðˆnÀÚá“ÀÇPÀ¶ª+À¨ÖÔÀŸ”˜À™â9À˜Š_À›x1À¢ÚÿÀ­­žÀ¼(§ÀÍ„ÝÀágiÀ÷[ÕÁ!uÁkÌÁ \RÁ-•Á:ùëÁH«OÁVwÕÁdÁp8Áw¸ºÁÿ1Á„OÁˆÅûÁ…ÊÁ’ywÁ—x­Áœ®¹Á¢þÁ§»˜Á­_Á³ ×Á¹ ÜÁ¿TÁÅ?ÁÏ3…ÁÈÍÁƒÁÁ¼CÁÁ¶ {Á¯ø;ÁªÇÁ¤+ÁžcÈÁ˜ÉHÁ“W´ÁŽ5ÁˆÇOÁƒ°fÁ}¢ÞÁtbŸÁk`ÜÁcÃÁZ €ÁLJ%Á>ÓÁ0 œÁ!øcÁKœÁyÀó’ÀÚwÀÃdÊÀ­ÔMÀšÇÓÀ‹¥7À€ªyÀt8ÖÀqR²ÀxOÀ„;>À‘yÀ¡!ßÀ´K+ÀÊ6ÛÀá2ŒÀúöÁ #«Ár¡Á% »Á2ÊòÁ@®oÁMüšÁZv™Áaÿ‚ÁjbÁr‰áÁ{OàÁ‚V>Á‡EzÁŒ@Á‘lßÁ–ØnÁœusÁ¢!Á§ÝÇÁ­ÍÊÁ³äèÁºZÁÀ+GÁÊœ–ÁÄ;Á½ fÁ·NÁ± ÁªÒÁ¤·‚ÁžÁ×Á˜à“Á“jÁ}7ÁˆÁ‚ÁHÁ{ õÁpç_ÁgQeÁ^»ÁUN+ÁM8\ÁD>ùÁ6––Á(ŽCÁ_¾Á LµÀü!Àá±÷ÀÇÀ­xÖÀ–JlÀ€ÌËÀ^u°ÀC÷yÀ4ÿOÀ1½2À9ÒdÀLÔÆÀjŒ|À‡GwÀ‰À´:­ÀÍ7ÀçæÃÁraÁ+ÁŸÁ*”®Á7ÛgÁDå¬ÁLa‘ÁTØÁ\vÎÁe!FÁnSÎÁx$Á æÁ†-AÁ‹“qÁ‘0´Á–×Áœ›sÁ¢@Á¨«eÁ®ËÙÁ´÷vÁ»DRÁÆ;Á¿Š…Á¸òiÁ²w¾Á¬ßÁ¥ÖDÁŸ˜‡Á™xòÁ“}sÁ–øÁ‡É‰Á‚1ÕÁyšhÁnüºÁd‡½ÁZu|ÁQÂÁGÜ•Á?\¢Á7fÖÁ. ÕÁ ŘÁˆÁ×ÀÀí[ÈÀÑ,5Àµw[ÀšÙ¥À€ƒ•ÀR~,À'÷zÀúõ¿í6¿å;u¿ùwýÀñHÀ5sÀ`,xÀ‡s¶À¡ )À»ÐMÀ×6 ÀòßEÁ9ÏÁ‚/Á!ÏØÁ/j!Á6ÄòÁ>RŒÁFv?ÁObÁX‰Áa¸IÁk®ÁuÝuÁ€P Á…ìœÁ‹’ìÁ‘YeÁ—S±ÁqäÁ£”Á©ÇlÁ°¶Á¶•qÁÁéÁ»4"Á´ûÁ­ÛÁ§TiÁ íØÁšŸ›Á”` ÁŽ;1Áˆ:þÁ‚N|ÁxúÁmάÁcõÁXvêÁNÁDXÁ:¹ÅÁ1²æÁ)‚©Á! dÁ’Á 5!Àú¦ÂÀÞÕÀÂYÀ¥úÁÀ‰ß(À]8¤À'Àg¿ðÞ„¿ ¤Ð¿eâ¿O§–¿€MË¿º—À+MÀ5Ý!Ài{¦À3RÀ«º™ÀǰÇÀâi0ÀüÿôÁ ð¿ÁÐ.Á!9ºÁ(¯êÁ0ˆÁ8ðÁA¾•ÁKL®ÁUGÇÁ_blÁj½ÁuQÁ€NÑÁ†°ÁŒWÁ’8cÁ˜_ÆÁž›öÁ¤üÇÁ«€kÁ²#Á½¸öÁ¶çYÁ°-CÁ©x}Á¢Ë¤Áœ7‹Á•Ä÷Ák¶Á‰(ÇÁ‚ýÔÁyõòÁnÞÁbc¬ÁW<ÁL’ÁAñÁ7ƒMÁ-¶Á$qÁ«tÁ²NÁ  ÁîuÀëšëÀÏ¢5À³¿{À—ÏçÀvzeÀ=DèÀóö¿žò^¾óO=9y<>*‹Ò½Ä"€¿1S迹ÖqÀE’ÀItÀ€’~À›ý#À¶†ÖÀÑUÀì´ýÁphÁ àÑÁKÁ«MÁ"êMÁ+‰YÁ4æoÁ>àñÁHêÁS“ŠÁ^ÉÁjlÁu¬ÕÁ€ÞnÁ†ÿÐÁ0Á“vÁ™âÁÁ s«Á§$2Á­åaÁ¹ÇÁ²ÏÁ«íïÁ¥&¸ÁžqÁ—ÁèÁ‘"^ÁŠ¢wÁ„<¥Á{äÁoðÁcx'ÁW„ŠÁKÎñÁ@¬ÝÁ6+Á+k^Á!ºÁeÌÁ-ÁÌöÀûá&Àí,_ÀÞ¥ ÀÁ¨êÀ¥XKÀˆü8ÀZ­ˆÀ!Šë¿ÑÓ¿>¢=÷?f’? ?0Œò½©p¿ord¿æ~´À*ìÌÀa!GÀ‹9À¦U ÀÂ5ÎÀÞ›§Àí`‘Àû!ÁþBÁ û£Áj†Á‡ÐÁ(xDÁ2urÁ= ‹ÁHB¦ÁS6Á_+qÁkIÚÁw–¼Á‚èÁˆWGÁŽÑAÁ•qÁœ/·Á¢ûäÁ©Ñ}ÁµöæÁ®ó€Á§ðµÁ þ”Áš&ŸÁ“j±ÁŒ¸¶Á†íÁ NÁr'ÁexNÁY ‰ÁLú\Á@ÿNÁ5=-Á*"8Á‹ÇÁå©Á øÁµÀðsÀßý ÀЕÊÀÂÏnÀµñ´À™kDÀxŒ À? ÄÀ$'¿œb\¾©“? ü?¶åù@{? õí>É.ѾôMC¿ªƒhÀ 0¡ÀAu€Àx‡žÀ˜‚/ÀµÅ¾ÀÃAÀÐiÃÀÞÃGÀîËÀþ½hÁ4•Á "Á Á&‡ÕÁ1»ÀÁ=ÁH«”ÁT×Áa8þÁmÆÁz‚—ÁƒÊlÁŠzëÁ‘GñÁ˜ ÁŸºÁ¥ãÁ²4[Á«%ˆÁ¤ Á‹Á–yÁ0ÍÁˆdzÁ°ÁvÁhܾÁ[åÏÁOÁB’éÁ6|‘Á*€HÁ¯¥ÁÛÁ bÀüÀ Àè]>ÀÕ’õÀÄ.‰À´ŠÓÀ¥©§À˜‡”ÀŒ«Àe®ãÀ*!?¿â!¿bȺIâÂ?cZß?ØÅ @ ‰¾?×ïU?SÜó¼¶þ¤¿_ó2¿Ûè¡À'ÿPÀb¨0ÀŒpšÀ˜Ö™À¦õÀ³ÏkÀ™6ÀÒÞˆÀãæÛÀ÷8ÁÉÁ‹Á4ÙÁ&|ÔÁ2-ÓÁ>mõÁJêÁW“&ÁdmÁq¢[Á)Á†oöÁQõÁ”4<Á›ŸÁ¢!Á®´Á§·Á ^žÁ™QÁ’JFÁ‹E—Á„GÑÁzÍ ÁmPƒÁ_þ<ÁRºÁE¯åÁ8ÅFÁ,üÁþÆÁ²Á(qÀú7rÀåÀÀÏ´ÐÀ»µïÀ©±À˜™À‰?_ÀvÚ`À]•ÀDWCÀ X¨¿É ÿ¿'ƒW>¼‚?’ÉU?Îô«@ £H@\³n¨¿s]¿»ÀF’ÀEƺÀ]ƒùÀwwfÀ‰åÀ—_ùÀ§ÚÀ·§¸ÀÊ[»ÀÞmæÀòûÒÁ­òÁùÁ¶Á(,Á4¯{ÁAy´ÁNsÔÁ[Ï)ÁiPÁwFwÁ‚…]Á‰g¿ÁQ9Á—OõÁžafÁ«dÁ¤(ÝÁœàðÁ•«ÎÁŽŒSÁ‡„Á€uûÁrÞYÁdí}ÁWEvÁIéqÁ<¤†Á/zÁ"ˆHÁ¹ÈÁ ƒaÀûÀãV­ÀÍ4¤À·ûƒÀ¢·†ÀçÀy°ÀZ‡ÀÒJ7 ¾Â§U¿\Å•¿¹S¿ÑÈ”ÀtÀúÀ?Ô8Àa¿ À„¸À˜ñÕÀ¯@dÀÆ iÀÝñ"À÷SÁÁˆ-Ál'Á"·,Á0pöÁ>DÁLÁYâØÁgå­Áv<Á‚ôÁ‰>SÁ`Á—ˆ2Á¥i9ÁûÁ––óÁ=JÁ‡çyÁ€•Ár‘åÁd$†ÁUåiÁGÇ·Á9ªíÁ+™ÁØÝÁ{QÁ6Àì9ZÀÒdšÀ¹bEÀ¡…1À‰Þ'Àft}À;ÊÀÛ—¿×M¿—Óœ¿5cÚ¾›#t=®vŽ>ó–‚?kš=?¼…+@ 7Œ@=|@n c@Håš@TD?Ì +?€G>ô®=‰.ʾ¤7Ï¿:Íä¿”°š¿Ð9¸À ¯þÀ/ÑHÀWð€À‚AÒÀ™t1À±–éÀË>ÔÀäýDÀþðßÁ ’ÁÓhÁ(©Á6ƒ ÁDŠÁRµ¹Á`áëÁo†Á}c8Á…á2Á.Á”VÁ¢›äÁ›!{Á“¯¹ÁŒ>wÁ„Ñ‹ÁzäyÁl?†Á]£ÁO XÁ@–ëÁ2MäÁ$/-ÁnÁšÀôý{ÀÚE/À¿ÎÀ¦ÅÀŒÒëÀi–¡À:aÀ ¢¿Ãà!¿gý¾Ÿp=>*àä?¶7??²‚“?å•-@Ój@89@dÄ@Šãß@lêÀ@?³N@ýü?ëe?¯AŒ?¯?»I>3¥Ò¾Š=”¿GÍU¿­m-¿üƒìÀ*òsÀYÁiÀ…hÄÀŸ×À¸çÀÓO/Àîâ¥ÁP¢Á2Á!0ÙÁ/^Á=‹’ÁK»cÁZ¶Áh‡„Áw Á‚¿ Á‰÷¯Á‘7gÁŸõ»Á˜lwÁçñÁ‰i†Áö8Áu îÁf'ÂÁW[CÁH¸ðÁ:ìÁ+ŠZÁ‹Á·0Á–¢Àå#ÀÉqÈÀ®j™À“–ÞÀsrÀAáÀ"߿¼é¿M/Ô¾Š>ø¤Å?…WØ?Â~?öàÈ@?ú@-^™@I‰@kKÑ@‰@ŸÁ@Œx5@p¿§@MPá@-œe@ÞË?ó]?¿Éž^?m?ô@)À¤@W…E@ <@“´@¡i@@®}‚@»:Û@Èk@×ô]@èÒj@Øçý@É)ý@ºê”@®/Ú@ ø2@“Á1@„¨í@d€@7½O@õö? ÁW>Óö`¾ë“¿ªÇ{À †UÀFª˜ÀÑRÀœmõÀ¸ëËÀÕ³¢ÀòØ£Á ¬Á«Á%dPÁ4£ÁBàÃÁQ¿àÁ`ƘÁoÜGÁ~ñøÁ‡=Á—!Áb¥Á‡©¾ÁçîÁpƒÀÁa#¨ÁQÄÁBsÙÁ3=™Á$¢ÁáõÁÃGÀía²ÀÏ{¡À±›jÀ“ÚRÀlQÿÀ0ý¿í ¿tvb½sIÎ?M,“?ÔÆâ@¹7@QÌž@€Ä>@˜a@¬ê@½Ù@Ë?‰@؆Ý@å›@ó‰$Aâ½@ô{î@å´´@Ø @ÊÛä@½¥~@¯ -@žMg@‡€=@Z3“@$ID?ØÇ?QÀô½cf«¿pÝÍ¿é—À-î Àg¦ØÀ¯ÔÀ­­ÀÊ¿vÀçòòÁÄ·Á“MÁ c\Á/Q<Á>[ÅÁMn.Á\€–Ák˜÷ÁzËåÁ… oÁ•†²Á¶„Á…è©Á|?YÁl¸çÁ]7ÁM»Á>F7Á.ÙIÁx±Á4ÁâÀã¯ÕÀÅSèÀ¦ú£ÀˆýÌÀV;+Àz½¿½ÿ‰¿{·>³Ç¢?Ÿöa@ f@?žá@uQ@”AÚ@¬ªñ@Ãü@ØON@ç¢ý@õSAÆZAÿïACÕA+~A;ö@õø@ç@"@ÙÎv@ɹ³@±Ñ©@–ê³@v>é@>HÀ@RÝ?›e>¥”¬¿©¾¿»äšÀz^ÀQ(ìÀ…Ú¥À£B®ÀÀ®ÀÞJJÀü&ÙÁ ¥Á×Á+,?Á:MÁI…¦ÁXÑÁh+‡ÁwŒÐÁƒz±Á” ñÁŒ61Á„bÀÁy$üÁi…'ÁYíqÁJa{Á:عÁ+OøÁÇ6Á 6pÀùX¢ÀÚ…zÀ¼ !ÀªjÀ~¡ÀAíPÀ„±¿“0c¾Z»?97?Ñî'@#iO@\îº@ŠUÇ@¥‰J@¿p”@Øq.@ï³¹Aw˜A’A à¡AšqA½ŠAkWA¡A¼[A¤P@ô…¸@ÛyÁ@¿è¨@£îL@‡Ø @W ì@'?ÉýŠ?-Ü8¾a +¿Ä¦Àê¹À=žÀxRRÀ™ÐÀ·ÍÜÀÕ̰ÀóÎÈÁ FÁ^¬Á'½TÁ7{ÁF{¶ÁUÛ—Áe<Átž;Á‚žÁ’å Á‹ Áƒ¢ÁvpúÁf®&ÁVóÁGAvÁ7œŸÁ(9Áh`ÁÐÿÀò{ÀÓW‚À´3êÀ•Àl\,À/}ü¿åT#¿W¨÷=Ù0}?…˜‹?ýq‹@:v@uˆ@˜)@´x–@а@ê_9A¼WA ŸbAisA=îA "¹A%»ÔA$Ô‚AásAž~AUðA%'@è“G@Ì}@°-—@“£A@n'@4‘Î?ôÉô?Ÿ¯=¬¿U°¿ây°À- ¬ÀhümÀ’‹(À°ÑÌÀÏ-ÀíÖ6ÁBŒÁ}Á$ÿµÁ4b¿ÁCÑ|ÁSM+ÁbÓ%Ár`œÁ€ùuÁ‘éýÁŠÁ‚üÁt^*Ádˆ[ÁT´ºÁDæÁ5 Á%RIÁˆÂÁÇQÀì*ÏÀÌî‰À­ºkÀކLÀ^¤]À < ¿Ã—¿ z>ȧ…?«Ôk@¾ @O$2@…p5@£NR@Àî©@Þ.×@úaûA žŠA[A#ZMA(½€A-#›A2(yA3æA+¤]A$N(A“Aƒÿ@ô×D@Ø:@»”@žtH@Zþ@Gl-@ `å?¢+>ª½¿Ãp¿ÆÃ>ÀÑêÀ\[vÀŒ’çÀ«B’ÀʹÀèÕÂÁÙbÁL&Á"ψÁ2X‚ÁAã£ÁQpoÁ`þËÁp—`Á€[Á‘¦Á‰æÁ)`ÁroÂÁb>ÁR±ÄÁBØÁ3úÁ#,?ÁZšÁ¸Àç‹ñÀÇ÷À¨\EÀˆÁsÀRNˆÀ~ä¿©ß{¾³y¨? T?Ìþ½@$¢Õ@azd@%¨@­lK@ËJ@@é%íAk~AãAåA,ëÝA6…ÃA:‰ÇA?rA@Ö4A8£,A*ÁA¯hAdH@ÿùv@âÏN@Äö“@§h@‰Já@VP @à÷?ºßÛ?œÊ¾áñ‹¿²Ç+ÀˆùÀTÀˆúcÀ§è_ÀÆÓ}ÀåÃ2Ác§Áå¹Á!lMÁ0ùYÁ@‹LÁP!6Á_ÁØÁooÁ%­Á£Á†X¬Á~G-Áp7ÁahûÁQwÿÁA‡Á1–Á!¥/ÁµÁÆ`Àã·ÁÀÃí'À¤.HÀ„ˆÀI³âÀ d³¿–+¾ìÂA0¥ÃA!ýJAJùA*(@éê–@Ë9=@¬À@ŽeN@_ƒ@"HÅÁ0…$Á ×1Áö+Á©ÀâC¼ÀÂh—À¢šÀ‚²ÀE¯@ÀùE¿Œ†–½Ñª?d¢¨?ñ½I@8‡­@xc@›Òƒ@»`÷@Úð:@ú˜A ÝWA?àA+W¡A:=ðAI€AVSŒAZ7 AS ðADåA4¢ØA%%gAœfA+}@í„@Î`@¯Cv@;\@b… @$Øn?ÎW ?%üȾ£')¿¤®aÀ\'ÀNgtÀ†:ZÀ¥AfÀÄ]éÀã’ÁeèÁ¹Á ¤¬Á0?¦Á?ßÒÁO…KÁ_.öÁnÛýÁ~ŒÁ†°zÁÂôÁq­ùÁbÀ ÁSì“ÁEA)Á6ÎìÁ(¢©Á¢ÚÁ ùÀÿ²“ÀáÀÁ)1À¡QÓÀzúÀCM®À²î¿ˆXð½”ÖC?k†?õ.@:&­@yÉC@œµì@¼‡7@ÜX‚@ü)ÝA ò=AÎqA-ªÌA=‡&AMcA\»ÕA]ë¯AOãnAB5A4>ìA$´ A4ˆAº³@ìj­@Í_h@®`Æ@k†@`ì‹@#P?Ê;À?zr¾·@÷¿©Ý´ÀÀQ&‡À‡¦À¦¬ÀÅ´ZÀäÖLÁüÁÁ!!ÝÁ0¿ÎÁ@Y»ÁOòàÁ_“ Áo:‡Á~V§Á‚ûbÁwðŸÁj(KÁ\¬?ÁN)‚Á?%;Á0ItÁ!’ëÁ­ÁøNÀî!ÀÓ_”À¹cÀ m2À€ÂàÀB1ÀÜx¿‡©½†f?m‰?õÑ·@:’0@z;ö@œòÞ@¼ÇÁ@Üœ¤@üq‡A#5A ¦A-øA=â‰AMÌûA]³@AX¿tAJ{6A6\AN_A];&AT>–AEÎ A7ŸòA)ªAúA‘ôAf:@çà¹@É™@ªöݾøó*¿º BÀïÏÀYA–À‹Ã"À¨mÀÁš]ÀÜŽZÀøµUÁ ÙÁ£õÁ(qàÁ7P6ÁEˆ}ÁRíœÁ`Ÿ½Án›SÁy5¯ÁjÁ\ ÁM¥Á?}ŽÁ1¥¼Á$2fÁàÁ‰¡Àðo?ÀÒ3 À´’ÎÀ—ÄcÀxÀB6õÀ¼Š¿¼¼¿-Öf>Gó? Þ@Lî@E­@ùÈ@¡dà@Àľ@à ·@ÿoàA<]AkÉA+ØýA:uyAIGAX@²APÛ AB*A3²rA%ƒA›&A ë)@ù9@ß|-@Æè“@ªü @Œ9@@Z§0@[Œ?¼=n?‹ž¾ÜÜþ¿¬-“À^cÀEkJÀxÚûÀ–)ãÀ±ñ™ÀÎòKÀì¤{Á×ÁýÁ"J!Á/­Á=,$ÁK2ÁYD3Ág±‘Át$VÁe*ÓÁVW6ÁG åÁ9êÁ*¨Á›>ÁÐÇÁIöÀç·mÀÈß.ÀªK=À‹‰ßÀZÿmÀ!ò‚¿Ø€³¿a¼0¾]?5W£?Ãåþ@WÌ@UÔö@ˆÁj@¦ìÊ@À„@ÛgÝ@öÔ*A —*A#A&ëïA5ìIADþ—ATÓANd(A?xÜA0¶mA",=AïMA5@ñ>ý@ÖëŽ@¾ @¦’S@ÙÑ@e³ƒ@)ñí?Üù3?Y}ǼËKB¿q,j¿ëÌãÀ#ŸçÀXqïÀ‰ÁÀ¦5…Àø ÀáèjÀþŒëÁ `bÁß$Á'¥ËÁ5ÉËÁD6÷ÁRÙsÁa_Áp Á`ÉžÁQ¦ÒÁB§%Á3¾gÁ$ìÁN ÁöCÀóðÀ×øæÀ½‘àÀ¢ñÀƒ„ÀI:“À Ù¿Ÿ¤ù¾ß"> NF?a²š?ä©@+Gy@VIO@€ÃÝ@™?@³•Í@Ïzn@ìhºAù‚AëXA"ö*A2{AA8´APzéALk°A=c'A.…ËAÌ3A@ AÙ@êao@Ï…¬@¶ @ž{¶@‰'@mÛ @@€@¶#?‰ðJ>4~¿†ª¿­§ŠÀ éUÀB½½À}ŒÀ,ÒÀ¸eýÀÒbåÀív¤Áh’Át£Á Þ0Á/ŒÁ>Q¨ÁM>.Á\QaÁl×Á]^AÁMúÁ>¯›Á/…dÁ spÁ^¦ÁkôÀç‚ÀÊÖæÀ®dDÀ’ïàÀpVÀ<ð À²¿ˆ<¾h‰>m$ ?N‡±?Òš¸@h’@5m@f?@J@©G@Æi%@ä?A)ìA>$A^A.¡BA>(AMtgAKz‘A>kž¿ÿG¿‰ÿ¬¿ô8sÀ5VÀg"ÀŒ À¦ÎÏÀÃõÀÞÐeÀû‡ŠÁ zÁQHÁ*MaÁ9tëÁH¾ÁX!®ÁjqÁZëAÁKWªÁ;ÖMÁ,lÁ–Á Ô»ÀýCÀÞö™ÀÁ-OÀ£õjÀ†‹“ÀTCaÀýb¿Í5~¿>ßo=‡Ë+? 4?ˆð½?¨À¬?Üùh@o¥@O&X@ƒºV@¡JÈ@¿Pà@Ýxœ@ûè²A 5âA†§A+ó¤A;ovAJíŠAKU÷A<ÁA,øÃAæ·AûAh*@äMà@È.À@¬´@‘ø@qd‰@Aºs@ÈM?ëæ?õU>¹.½ÔEw¿-*½¿¶c6À¢’ÀA»ÀxÝ,À™›“À¶_¬ÀÓ½ÀñŠúÁÌEÁGÁ&evÁ5àdÁEpŠÁUCÁiW’ÁYŸ ÁIñìÁ:RÍÁ*ÅžÁOÄÁ è×ÀùSÀÚŸ¥À¼K®Àä8À¶¡ÀEÀ Ó¿¡)¾µèé? F?œå?<&+?* ?¥ Ô@öR@?Üõ@zm@›q@¹Êq@Ø#Ê@ö‹ A ¡mA»A)´LA9V–AHùAKâoA<èA-U4A<™A@AI“@âür@ź«@¨×r@ŒkÂ@aÉ‹@,êÒ?öÚ?=å?iš?u‡?#F¼å%P¿cïë¿ß:À)È¢Àe À§À®niÀÌX€ÀêÌ€ÁÎÖÁWÁ#÷Á3§³ÁCe+ÁS,£ÁièÁYfjÁIÂÁ:(èÁ*œ¢Á"òÁ ¸ÀøcEÀÙäÀ»#àÀ+À~úÏÀDµVÀ jg¿¦þÅÃE?£O?+&ô=·>Gž? =?ó*y@5 ?@qFw@–Áþ@µ1@ÔB@ó!A A“ÈA(#XA7ÀÿAGgïAL¦éA=0\A-ÈèAr×AÆ@ÿÑ@ájh@ÃIý@¥/.@‡§¼@UUï@¸?ˈ}?B>"ry>ØÆ¤?ŽY]>-­@¿Bþú¿ÒâÀ"ÜÀ]ºÀ¹À«ºÀÉyìÀèNLÁµÁ[vÁ#;Á2×…ÁBŸ4ÁR[oÁiɬÁZ& ÁJØÁ; ®Á+¡Á?›Á âÞÀûF¿ÀÝÀ¿?ˆÀ¢!À…xçÀQÒÀÀ+¿©ìž¾ÎgY>·œs=¨¿½ëþ(?P: ?Þôæ@+Ãó@i @“Æ@±À‡@жø@ïÔAŒzA;ÈA&ìÝA6òAFHèAGÕüA9šA+dAGAA Va@ümå@Þ@¿ãó@¡ƒo@ƒ¨<@K_"@^à?¬³Ì>érš¾Ó/@¾HîÕ>ú ¨>YHK¿=å’¿ØÎ½À)IJÀcíÀ"èÀ­'žÀË“EÀê.àÁ~eÁï»Á#qÜÁ3ÁB«ÎÁR_Ák’ÁÁ\žÁLŸ¶Á=G¿Á. aÁá•ÁÈÉÁáŒÀä‰ÉÀÇ“¢À¨‰çÀ‰âÀV ûÀµP¿Æ“¿H‰`¾¨82¿f©¿›³Ú¾â×?(Åd?Íð=@#¸@a1@§%@®¨¶@ͤ¦@ì¡“Aâ±AŠfA%6ÚA4âXAAŠnA>ÓÝA28ÜA$y%A\EA*@òæÓ@Õdµ@·ð2@š;õ@y?d@>‹@”Í?’€%>m†Ó¿-ê ¿P1¹¾{~7¾‘{<¿móI¿äJÀ+0?Àg‡À’ À±»¢ÀÐpŠÀî’Áw³Á°ñÁ%{Á4u÷ÁCþRÁS˜‚ÁnkäÁ_yÁOå‚Á@ÏŒÁ1Å·Á"ÕÁxvÁbÀéOÀËÐÀ¬ù>ÀwÌÀf*ÿÀ/Ú/¿ýy¿°,¿‹ð׿¨@|¿°„ݾá[0?eð?¼S@rº@X»ò@Šüß@©¨M@È“™@ç¬KAGšA„ùA!~A/y¯A1ŸA/ÍDA(kËAO½Aø+AQf@æžX@Ê8@­-ê@&Ê@f7å@+j?áú‘?^3°¼ü&ó¿nUË¿ÂÔ>¿Šœƒ¿†KP¿º<ðÀÈÒÀ<%,ÀteßÀ—çÀ´ó|ÀÓ9ÀñvÁ ÃÁ‚‡Á'VÁ6µ†ÁF5œÁUûÁq}Áa³øÁRbÜÁC#ìÁ4†Á$ÆÁ§ðÁ¨>Àï¡ ÀÒ^œÀµÄšÀšQIÀY·ÀON•À$ï À“î¿õ­ÃÀ'¶¿Åú•¿žÓ>°G?¥Ð‡@í@MŒ@„Ü×@£L¥@Á¢€@ßb‰@üÇËA çsAÖÚA ðA!·£A [sA¥€AÚA)û@ò³†@×íð@¼Sk@ c­@„@O&;@}O?·ö? æ(¾´MÊ¿žîÀS’¿ú€r¿ò‰À ¶ëÀ,:ÀXQIÀ…nZÀ 4×À¼taÀÙ»$À÷T«Á ¥ÁÏÁ)”Á8s\ÁGÑÁWAgÁs>»ÁdpÁTÞ”ÁE߯Á7 PÁ(…ÁX)Á ×mÀùIÀÝ~DÀÂ<÷À¨xÝÀÂÍÀuø)ÀSu¨À; îÀ2V&À,25¿ßÓ¿NäÔ>T.?‰Gl@)@<1V@w*¿@™/5@¶fô@Ó.@ïKùA—(A P£A^ AÕ¡A§ìA «ALv@÷šY@àD@Æú-@¬Ë@‘Ì@kì@4ûn?ù½Á?ˆ—g>4 ¿5ã׿ÌxÀÐÀ5ì¹À2“YÀXÌ À~ÞHÀ•›—À®,£ÀÈvˆÀä6üÁCÁ²–Áo¥Á,fSÁ;‚‹ÁJ­AÁYêÁvk§ÁgbïÁX}­ÁIüÁ;;ÁÁ,´ãÁtÁÁ‰¶ÁÎ7Àêþ³ÀÑÔ–Àº+À¤U[À‘šÀ‚EÿÀqàDÀk‰¨À;B›¿ÿ‹>¿‰o¾å³?DEM?×=í@%f @_Ëï@ŒŽ:@¨¢K@ÃÆ@Ü^t@înH@úEnA±PAúõAb@û+Ù@ðf-@àsk@Ër@³l@šî³@LÍ@Ml@@¯o?Á‰?%õð¾gNð¿‹ì/¿üm+À6HhÀmîÀl¨ÂÀvÀ…ôCÀ•÷«À©Q3À¿¾ÚÀ×ì_Àñå|Á{ÀÁQsÁ"Œ@Á1{Á?׎ÁNº#Á]° Áz”MÁkÏ€Á]6ŽÁNÒÂÁ@šÁ2ƒ6Á$żÁzÁ XÅÀû­qÀä]ŒÀÎ`“ÀºÔ~ÀªVHÀ%¾À•À„·.ÀNÁ§ÀÜ¥¿³]οEY>Éù-?¥DÎ@ Ûl@D5¼@zïÏ@—›õ@¯‡K@Ã_X@ÑÄq@ÛÎ$@áíö@äT7@âb@ÜjZ@ÒøK@Æ3œ@³ÿ@ž„‹@‡5@]ø@+¥8?î'º?…*6>Dež¿(‚¿Àä×Àú¹ÀOcøÀƒs À”À˜[‰À¡1À®a]À¿ŒåÀÓþáÀêãÁ"Á û;Á?0Á(çÁ6ñ>ÁE?ºÁS³IÁbSøÁ¬fÁq7~Áb÷¡ÁT÷tÁGaÁ9…GÁ,WÁŽ·ÁüÁJÁÀøæ#Àä¦ÀÒÿ·ÀÄ3uÀ¹}À«Ò=À"ÅÀe_4À+Á£¿äË»¿gN³¼²ÍÝ?\›‰?Û¿ @#\à@VØ#@‚àÇ@—`Ï@§l @³ÿ(@¼áæ@Â_¹@Ä‘Ú@ÃÞ@½©­@µHÃ@©®@šÛp@‡iC@cóI@5Lv@Câ?§ñQ?5C¾“<¿Ä$¿ûëQÀ3ß}Àj=àÀi7À«çÜÀ¶jgÀ½‘ýÀÈØ|À×ëÛÀêcšÀþ¾ÞÁ ŒbÁ˜ØÁ#EÁ0QZÁ=ÎáÁK§ÁYµ½Ágõ¸Á‚ÒûÁwŠrÁi­bÁ\ÁNœ…ÁA‹ÏÁ4óíÁ(“MÁɇÁÍÒÁ¸ìÀüÓŠÀìþ©Àß›ÀÔ1–À·Ô±À›k3À~U‚ÀF VÀ ·Ž¿«š7¾úIë>ºÌ?—öÊ?û,¨@+ð`@UÌ-@yÅ@‹^@•¤@õ§@¢Ôo@¤Ç @£tZ@žÄ”@—u…@ŒÎÿ@~ú@^ù@5¦ê@ µ¬?¹å?:=½e¿9¿UÝb¿ÓÍÀÊ#ÀR>œÀƒ¯°ÀžœÀ¹ÉåÀÔ[xÀÛ²Àä¹·ÀòLÁV Á °«ÁòÁ YHÁ,[/Á8ÎIÁEºõÁS)Á`±Ánˆ¥Á†8÷Á~¶ÛÁq/ÒÁcÛ†ÁVäŸÁJ]Á>I1Á2ŒuÁ'zŠÁ4ñÁ ·Á 1aÁæ»ÀûäÀàš-ÀIJÀ© hÀŒåÀaåxÀ+´ƒ¿ëQ½¿}Ur¾MÞÙ?+Õ?£öQ?ùH@!ÚÉ@A&¨@Zã¹@n•“@}]§@ƒL÷@„ük@ƒï:@o:@qª@^H¾@F'×@(A˜@ ?¸öœ?EÐ=‹"\¿$¦X¿¶40À @ÜÀ?5°Às4nÀ“žŸÀ­­ÀÈ#ÀâìÑÀøÈcÁ£-Á¨öÁmÁ—„Á N)Á*÷BÁ6>3ÁB ÌÁNl1Á[CàÁhëÁuùlÁŠbÁƒGpÁyX8ÁlyÁÁ`®ÁT¸ÁHWaÁ=D)Á2éÁ)Á ,ëÁvÁ¸uÁàŠÀîOåÀÒµ^À·ˆÀ›ßÀ€ÎîÀK—HÀ,ª¿ÌA=¿T3@½ÿAÎ? ï®?“»o?ÖΣ@@cæ@1X{@?1L@G]6@J…@Hïõ@AUK@4F€@"¬ß@ ÛA?ãt?£^Ï?1°$=P_ ¿>¿¨ÀoÔÀ2q$ÀcKÓÀŠPÏÀ¤ŽÀ½Á²À×ÚÌÀñàýÁ.Á1cÁ¡ÁQ]Á#1Á,2!Á6)­Á@æFÁLŒÁWç–Ád6ÔÁpõ,Á~äÁŽßÁ‡‚7Á^ÁuÎ+ÁiÍ6Á^ 8ÁRúCÁH|ÅÁ>ÂJÁ5ˆÁ-JÓÁ&+ÁŠ»Á ã7Àü¯ÙÀá´VÀưcÀ«ÚZÀ‘ŠÐÀolEÀ>cGÀ տ™߿VŒT¾h7i>¤ÔÊ?KI”?šÈ?ź?ç·§@ØO@4P@ Vo@ »ã@ã”?í?Í2 ?£,‡?e/ù>ß̽™x¿4óÝ¿ª>«¿þÊ€À+ø¹ÀXý¿À„‹÷ÀAÀµF‰ÀÎ4ÀçæýÁÞdÁ Ù¾Áô·Á"øDÁ)`Á0XÁ8µ8ÁBÁL0ÁVãÁbSÁmç`Áz'zÁƒgkÁ’bWÁŒóÁ…ÒmÁ¨–Át ÐÁhÖúÁ^:ÈÁTKÏÁK"/ÁBÕÁ:ØÁ.kqÁ!ÖÁˆõÁ¿Àñl¨À×fëÀ½ˆûÀ£ÖåÀ‹jˆÀfÃÚÀ:CïÀ½é¿ÏW/¿†oÿ¿ ¥½Ë:P>!å?Ày?Y|±?ƒ”£?’§?˜t?”Ñw?‡y®?b8Ï?*¦>¸::Ä!¾Ô¤¿iž:¿¼é‚ÀXªÀ,à ÀW:øÀò4À˜$À¯Ì@ÀÈ/^Àà*ÀùDIÁ ÁØ#Á"Â-Á/ªôÁ76iÁ=îøÁE¹;ÁNv;ÁX…ÁbG2Álû Áx?QÁ‚cÁˆxÁ–÷@ÁÌ{ÁŠÑ¢Á…åÁ~ÕçÁt!ýÁj Á`ŸÖÁWê)ÁOУÁC]%Á6èÁ(³ñÁZYÁJØÁJhÀèÞÀÏùÀ·¸RÀŸß€À‰ž2ÀgépÀ@ÇlÀ  ¿ðã´¿¶£s¿»§¿&nX¾³¾g½î:®=/>Uj>SËI>1YM=™Å4½®DÛ¾•L­¿—¿¿j⿦1 ¿ß|›ÀÓKÀ6RôÀ\[À‚PbÀ—ˆXÀ­ºnÀÆ[ÀÛ ‰ÀóÕÁz*ÁÛÕÁEôÁ*Õ›Á7®üÁD‰ºÁKß‘ÁS&UÁ[Z”Ádb·Án%êÁxbÁÁ•Á‡:LÁ¦Á›ÒàÁ•ÛSÁèÁŠwrÁ…Áí¢ÁvPŽÁmd#Áe }ÁXWSÁKƒÁ=óÕÁ0åÛÁ#á“Áí¡Á WÀüCûÀäÀÌ_:À¶ ´À Œ ÀŒµ}Às•ÀOåfÀ0ÀÊY¿ö|¿ÊõÊ¿§4$¿Šœ/¿nh6¿U™¿G–¿PïÍ¿hV¿†U¢¿Ÿë׿À±{¿é¦=À —À&”?ÀFXÀh:ÇÀ†å_À™™À®0¾ÀÃMÀÙ$ÐÀï ÁÚÁîÑÁÔõÁ'%2Á3‚³Á?ì¿ÁL®«ÁYƒÛÁ`é´Áh¡ÓÁq*ÊÁzo@Á‚üÁ‡B9ÁŒ¯úÁ’YšÁ ë·Á›"¤Á••Á#1ÁŠø1Á†wÁ€Ázƒ<ÁmläÁ`mšÁSLÒÁFRèÁ9–ÈÁ,®ÚÁ $HÁlÁ·ÀøßôÀâ¥ëÀÌé À¸ª7À¥iŒÀ“®À‚ÃÊÀhy™ÀMƒÀJ$0ÀXïdÀjtzÀ~ú+À‹+$À™?ÕÀ¨îuÀ¹½óÀË$ÀÝ©´Àð€pÁ–Á –1Á­XÁ"Ç­Á.,­Á9ó5ÁEœ³ÁQŽ{Á]äåÁjP¡ÁvÙ8ÁÏ¥Á…â~ÁŠ ÏÁŽyÄÁ“4úÁ˜6>ÁvâÁ«´®Á¦K„Á¡‘Áœ§Á—UOÁ’eŒÁ‹êLÁ…p×Á}êTÁq?+Ád»øÁXùÁK´rÁ?º:Á4.[Á(Ô¸Á³SÁÝ´ÁZWÀýQIÀëL«ÀÙ¥¾ÀɆÀºÃxÀ­tBÀ¡ŸÀ–’À¼LÀ†&£À€ŽÀvîŠÀqðÀnÚ—ÀoÔ§ÀuIÀ|O[ÀƒáôÀŠ‹–À’ù'ÀœÓÀ§Àµ4ÀÃØ_ÀÔ#DÀ䊄ÀõÀ'ÁFàÁ žQÁhŸÁ"(ÈÁ-RUÁ8dÑÁCº‘ÁOjºÁ[ ÁfíGÁs3PÁŒ Á†@ÁŒXÆÁ±€Á”ìèÁ™u>ÁžCïÁ£RÄÁ±d³Á¬)RÁ§&Á¢TÐÁœúØÁ–‡Á^Á‰¨úÁƒeÁz[QÁmä[Áa ÁUÀ-ÁJ"Á>Ó!Á3·ÆÁ(ð3Á…'Á™Á ™Á°Àôw´Àå ÇÀ×BŽÀÊTþÀ¿=À´á¸À«ôªÀ¤«£ÀŸ67Àš×ÑÀ—µuÀ–¥À–îÆÀ™¯dÀÀ¢{ÛÀ¨¶ŽÀ°Á¨ÀºBµÀĬÀÑ0»ÀßdÀïfÀþšmÁfÎÁUÄÁ¯dÁ#ŸÁ-ÂÁ7Ù˜ÁBö'ÁNõÁYFMÁdÞ!ÁpƒîÁ|[Á„LçÁŠopÁ 2Á–å‘Á›„ðÁŸÝqÁ¤|9Á©[‡Á·@õÁ²1¦Á­[Á§“ŒÁ¡#2Áš»ÔÁ”euÁŽ+´Á‡ôZÁÊ>Áw–›ÁkÈpÁ` ˜ÁT²jÁI¶aÁ>ë¥Á4³ Á*›£Á!M>Á–çÁåÁ lÁvÀóÊcÀç…½ÀÜiÀÒÓùÀÊv•ÀÃV”À½çñÀ¹é¢À¶çÝÀµÕÀµÿ¦À¸È`À»ÐÀÀüÍÀÆü{ÀΔÀ×ÇÀáô¬ÀíÌ^ÀûWpÁ4Á £bÁqBÁ°ÞÁ%Ú¤Á/5.Á8¼ÁBñÁM˜/ÁXŽÕÁc™­ÁnÏòÁz^ÌÁ‚ûÅÁˆä”ÁŽõÁ•%Á›HÃÁ¡ƒîÁ¦höÁªÚuÁ¯Œ‰Á½EWÁ¸`SÁ²3·Á«ÏØÁ¥v•ÁŸ)šÁ˜òvÁ’¼ÁŒ +Á†¬¶Á€ÃÁuÝ„ÁjšíÁ_¶`ÁTÙ‡ÁJzµÁ@¡¥Á7_Á.+ÑÁ%gjÁ~ÁžÁ°ñÁ.ŸÁg³ÀùïSÀðÀBÀèï$ÀâµÀÜ’øÀØûrÀÕ×èÀÔéÀÔüÝÀ× WÀÚ™%Àߪ~ÀåJÅÀ컦ÀõFsÀÿSÁV(Á ÌùÁ·‡ÁEÁ!ưÁ) Á2;Á;dsÁD¼¹ÁNŠ¿ÁXÑ7ÁcEüÁn#7Áy2~Á‚.ËÁ‡ðüÁÀxÁ“ŸÃÁ™Ÿ‡ÁŸ¿çÁ¥öGÁ¬/ŸÁ±ZŒÁµá¯ÁÃXWÁ¼äuÁ¶£Á°8‹Á©ðÊÁ£Â¾Á‹’Á—yÓÁ‘ŒaÁ‹¦Á…ÚôÁ€B¸Áu¦;ÁjË¥Á`L5ÁVm ÁLôÁCÅJÁ:ê\Á2œ‰Á+ êÁ#ŠæÁó ÁŸÛÁ ;Á æeÁL•Á"Á^^ÀûTûÀ÷ÆÀôµüÀóÃJÀóÜ›ÀöOÀù!ÀþFÁÁïÁdùÁ ¨Á`¬ÁŦÁ Á ™'Á'µÙÁ/(Á6í•Á>ô ÁGÐÒÁPëWÁZ5kÁd0•ÁnsŠÁxßîÁÛÌÁ‡e¨ÁŒ÷(Á’µÞÁ˜Š¯ÁžaëÁ¤UTÁªrpÁ°¦šÁ¶ÞYÁ¼WTÁǘGÁÁH¹Áºú˜Á´¸ÝÁ®—Á¨e«Á¢YÇÁœt½Á–” ÁÉAÁ‹60Á…ÈTÁ€\bÁv<•Ál/ ÁbÃöÁY‰ÑÁP ÁGâãÁ@xÁ8ªâÁ1†.Á*ûÜÁ$òWÁˆhÁæÁTÁŠ7Á…Á õFÁ =¸Á ÊÁ [Á gXÁ C´Á ¿ Á6¾ÁñýÁlIÁ‰´Á4Á"dÁ(.`Á.“…Á50 ÁÁÁ’ñÁÌ}ÁޏÁ¿«Á¹b Á³AWÁ­;‹Á§^sÁ¡‚ˆÁ›·ÝÁ– úÁ¼ÅÁ‹SdÁ†°ÁßÁxVlÁo1²ÁfÐÁ]L#ÁU1ÁMºÁFWpÁ?mŸÁ9<‡Á3OÕÁ.2jÁ)VéÁ%A’Á!ƒKÁ "ÁDsÁo"Á+4Áp1Á¢ÖÁëÁîæÁRÁ Á#$Á'>·Á+Ž¢Á0æ³Á6—BÁÁkÔüÁs+ Ázî,ÁœÄÁ…ÝUÁŠ1ÊÁŽ•Á“?ïÁ˜1CÁZÕÁ¢öÁ§×ÖÁ­>´Á²½ÀÁ¸R¯Á¾=ÁÃÓ°ÁÉ›óÁÏ‚WÁÙð ÁÓé\ÁÍé\ÁÈ ÁÂ?¿Á¼†1Á¶æŽÁ±tùÁ¬$ùÁ¦ë‘Á¡Â_Áœ²TÁ—ãÁ“R¤ÁŽámÁЇ%Á†P®Á‚rßÁ}lÁvb=ÁoÛ®ÁiqtÁc¼dÁ^’LÁY±ÁU_ÁQ·-ÁN`UÁK¸ýÁI_OÁGÅÁFˆ8ÁFÁFGxÁFÅÝÁH ÁJHrÁL®½ÁO­<ÁRóüÁW!¥Á[ÖÁ`ãÁf¨íÁl«’Árº Áyj&Á€_"Á„‡Áˆ-ÁŒ=ÎÁ…àÁ”׊Á™X×ÁžÚÁ£ÀÁ¨<9Á­q2Á²¼äÁ¸!¬Á½—úÁÃ+ÃÁÈçÁήzÁÔxÁÝ—“Á×pÇÁÑi÷ÁË…ûÁÅÆýÁÀwÁºr>Á´Ø¹Á¯hæÁª,ëÁ¥(ÌÁ NêÁ›• Á–óÁ’‡KÁŽ ÏÁ‡ÞÁ€ÃÁr€õÁeìÁW¼ŸÁJ¶4Á>$/Á24Á&ÁqÁß Á›+Ál Á”|Àó–ÞÀé¶Àá‘áÀÝpÀÜFðÀÞµÚÀä?†Àìá¹Àø8ÁjƒÁ ±©ÁãíÁ*ÙÁ*<ÃÁ5³ìÁA³FÁN5Á[ Áh&GÁu£)Á«‰Áˆ‡UÁd Á‘{Á•¿CÁšàÁž¶Á£’ Á¨|Á­ÅÁ²ÖSÁ¸LAÁ½ÛBÁÃvËÁÉ9fÁÏ!ìÁØ’[ÁÒXZÁÌ+=ÁÆYÁÀ8ÁºwÜÁ´ÅGÁ¯"ýÁ©Š&Á¤DÁžê-Á™ïžÁ•sÁhrÁ‹Ô—Á‡‚ÍÁƒFqÁxkzÁjpáÁ\ŸGÁO ÁAªÛÁ4~QÁ'ÈÄÁ®àÁEÇÁrëÀöØBÀåcÌÀÖöÀË!À¦À¾¿À¼ñvÀ¿…ÑÀÅ¿ÀÏKÐÀÛôäÀë¾ÛÀýn³ÁɱÁÁUÁF§Á+faÁ7î^ÁDÒšÁR$=Á_Í©ÁmŒ7Á{Z"Á‚‡åÁ†z/Áж¢ÁôÁ“ˆçÁ˜XùÁBÁ¢H¤Á§ŠcÁ¬þ™Á²ØÁ¸(ÙÁ½ì¾ÁÃØØÁÉé8ÁÓ—ßÁÍTÁÇŸÁÀæöÁºÕlÁ´êZÁ¯(»Á©vÁ£Ó½Áž;ÓÁ˜ÔzÁ“©ÁŽ·ûÁ‰ð©Á…?ÐÁ€¾Áy'Áq õÁbéBÁTËÁFåŒÁ9%zÁ+œãÁbMÁ‚ÁÁNâÀóœrÀÞ2ÀÊÞ£Àº¹ À­¦À¤#ÀžÈðÀ©À £À§YCÀ²>ÀÀ;yÀÑxêÀåüÀú¢zÁà½Á&`Á!±¦Á.±Áî6ÀFçcÀYˆgÀuU¨ÀŒÙÀ¡ƒ×À¸´FÀÑŽÜÀëT‰Á,ãÁÜÁÀZÁ,›Á9à¾ÁDUüÁK³%ÁSX¦Á[ÃjÁdViÁmqÁÁw-ÂÁ€…Á…«Á‹¤Á¥¡Á–@>Áœ ×Á¢«Á¨1Á®= Á´kWÁº¼îÁÅÈcÁ¿Á¸|ñÁ±ýÿÁ«Ÿ–Á¥_ÄÁŸ$\Á˜ýMÁ“ÈÁ;ŠÁ‡ˆªÁåüÁx¦Ámý ÁcçoÁZ>%ÁPÕ†ÁGÌØÁ?ŠBÁ7r\Á/´>Á"ÿÁÞ¥ÁšãÀð²HÀÔú¼À¹<ßÀž§iÀ…ÛnÀ\3öÀ5ƒÀKŠÀÀLÀ £¶À ›ØÀA°bÀjµ7ÀŒ7À¥ ¢À¿Ú~ÀÛQÀöÄÁ O/ÁÞFÁ$9£Á.ïRÁ6 /Á=‹UÁE²IÁN?]ÁW©Á`»§Áj“ZÁtÅyÁþÁ…XÁŠóšÁ¿«Á–¿bÁœÜòÁ¢ûfÁ©2 Á¯¸Á¶ 4ÁÁjâÁº·{Á´ÓÁ­^Á¦Ò‰Á h½Áš"àÁ“æÖÁ·åÁ‡¸ÁìÅÁxsÁm-xÁb þÁWuöÁMttÁCãwÁ:‹‡Á1»EÁ)»©Á!˜ÁfÁ ʇÀÿˆÀâÿÀÆ”ÀªtøÀŽ—3Àg%ýÀ3ü‰Às¿ÂK¿•NŠ¿‰²`¿¡Q½¿Ø;Àg7ÀAl|Àt1À”¡À°gnÀÌ- ÀçèÁJcÁÑ•Á¼Á ÒÁ'íËÁ/ª:Á8,…Á@Ù-ÁJIÁT!ÀÁ^8'ÁhôàÁt„ÁO9Á…v‰Á‹}Á‘›tÁ—»ÕÁüÁ¤c ÁªèªÁ±}‚Á½;sÁ¶eÁ¯§§Á¨öHÁ¢F#Á›¬fÁ•5»ÁŽæºÁˆ©úÁ‚taÁxÚhÁm<}ÁaÔÐÁVŽ÷ÁKu£Á@ô_Á7 Á-ˆëÁ$IÎÁÐÁÊ©Á øTÁ{±ÀòWÀÕã&À¹[KÀœóÀ€«±ÀIVÙÀ̈¿½ò¿?cF¾CŸ¾,žƂ­¿pµÙ¿ÕAÉÀ‚YÀTº,À† À¡ÉÀ¼öÀØÀó2Á‹ðÁ -ŽÁZFÁÌdÁ"Á*®1Á3Ü%Á=°`ÁG¯3ÁRZ×Á]Áh¸ìÁt]uÁ€<Á†ZéÁŒ~õÁ’ÊÁ™=âÁŸÍ•Á¦kÍÁ­µÁ¹L&Á²O<Á«h×Á¤›ñÁæýÁ—5HÁŒÑÁŠ‚Áƒ«üÁzÛñÁnf’ÁbF×ÁV ÁK6ŽÁ?ðwÁ4à™Á*u>Á žgÁ.sÁIÁ/Àų̂Àíq!Àà£ÕÀÉTÚÀ­K¶À‘`Ài'ëÀ0Þ¿ïq„¿€¡ ¾-!é? \ ?G^Y>ÌI¾«··¿”ËGÀTƒÀ8þ¸ÀoŸðÀ’çûÀ­ß*ÀÉAêÀÞæÿÀëøÇÀù“ÒÁ(ËÁ OÁ™wÁ}MÁ'?5Á1,GÁ;ÂeÁFçáÁR$ÖÁ]ÑOÁiønÁv7%ÁExÁ‡ÁŽ,Á”¹0Á›aÔÁ¢`Á¨íîÁµ}ŠÁ®v†Á§pPÁ x\Á™š&Á’Ù;ÁŒ&¬Á…umÁ}¾¦Ápê(Ádf!ÁWê¿ÁK¶+Á@‰Á4˜LÁ)QþÁNÝÁø.Á @(ÁÞaÀð6 ÀàFÀЇâÀøÏÀµû¿À¢}(À†5ÀSÁAÀr¿Ã¢›¿$j>w)¡?¥N?ÖÝÑ?wÚ=öqø¿=ñú¿ÍlIÀ¬cÀTWÀ…ÂÀ¡ÎÀµ½_ÀÁ™õÀÎÚÀÝ(ÞÀì$•Àý gÁ4[ÁÎZÁ²Á%,/Á0R—Á;“ÇÁGIÌÁS{ïÁ_»žÁl ­ÁxíÁƒ|Á‰­Áa^Á—)IÁž üÁ¤ímÁ±¸`ÁªªÕÁ££pÁœœ Á•–$Áޤ¤Á‡ÐëÁíÁt͵Ág}ÞÁZ†ÑÁMó<ÁAu˜Á5)zÁ)j5Áú Á³çÁÂÀúü–ÀçË9ÀÕ5âÀÄ–À´lHÀ¦.jÀ™'[ÀŒ[ÈÀ|àÀB€0À »p¿¢Y¡¾¾x@?ɤ?· W@í°?°&÷?î·¾¶îù¿œvsÀŠÛÀ=fáÀv¢ÀŒ®‡À—®¤À¤zÀ²,ÀÀÉÀÐäkÀâÅÀô»óÁB­Á™FÁ¿úÁ%ùÁ0È´Á=®ÁIDIÁUÁßÁb°uÁoñnÁ}VêÁ…láÁŒFÁ“*$Áš ¬Á þCÁ®/_Á¦ýÁŸÝ"Á˜Ð»Á‘ÉVÁŠÁñÁƒ¾~ÁyªÜÁl"Á^¶üÁQQ£ÁD1ŠÁ7„:Á+cÁ¢vÁÑ©Á[ÇÀø-ÀâvÐÀÎUÀ»!À¨ãîÀ˜ö¹À‰. Àxú4À]žRÀFÀ-¿öúb¿„(¾ X-?CF%?ÕMZ@$У?ÞX_?]6:¼]Àò¿a{¿äÁRÀ,¥ÙÀF%xÀ]_VÀtB¾À‡ZdÀ•‚À¤Æ©Àµó ÀÇãÀÛ­EÀð Á1mÁ~–ÁOßÁ&Á2ÔÁ?rŠÁL‰ÕÁYë%Ágn‘ÁuÁkÚÁˆO;Á8ëÁ–<ŠÁT ÁªðrÁ£ÁœVØÁ•"9ÁŽìÁ†ö¡ÁÞxÁqÑjÁcÔÂÁV¦ÁH¦lÁ;<ØÁ-ï¾Á!óÁ–¼Á#ñÀøw¶Àá{ ÀÊôŒÀµjøÀ¡=aÀŽeÀzACÀZ)qÀ=á‚À#z!À :‡¿å¥¿­ C¿94:>v?Õ¢?ò³!@3˜°@’X?™ZÄ>¡‡¸¿“¿ªu¿æ-À ¼®À!-eÀ:`ÀTú Àr‰zÀ‰ÊTÀ›=hÀ®ÛsÀà ãÀÙP–ÀïíÁÜ5ÁÁrÝÁ)8ÌÁ6uÁDõÁQ©Á_ißÁm/bÁzøFÁ„xÓÁ‹‘Á’¶…Á™Ý9Á§ÇïÁ sYÁ™TÁ‘Ê&ÁŠÁƒGuÁxM…Áj9Á\*éÁN#IÁ@2ÿÁ2˜®Á%/ÁÉÿÁ ÀcÀüR~ÀãZðÀËUCÀ´>†ÀÀdÀˆ_!Ài 6ÀC¶2À#²ÀßοԘ$¿ õž¿b9¾®£“<Ω7>×jñ?]>f?³VÎ@kL@1ø®@cRŠ@9Rq@Æq?¶ðS?]è”>×A4=rNϾ˜`ª¿-=¿‹Õª¿ÇM&À~¬À*€2ÀRJ¨À~_§À•ͪÀ­ì`ÀÆ™ŸÀßöóÀúh!Á é‘Á­ÍÁ&rHÁ47 ÁBÁP?pÁ^‹ÁlÆ´Á{¿Á„°ÙÁ‹èuÁ“'WÁ¡ò–ÁštíÁ’øýÁ‹ˆ¤Á„(¥Áy¨ÛÁkGÁ\TÀÁM¦hÁ?%6Á0áaÁ"ÕÁÎEÁÈ»Àò'&À×SÂÀ¼´À¢»¢À‰œ‰ÀbŽnÀ3ŠüÀ¿¹í¿XÓ^¾¡‡³>'­ý?á/?qt)?©×m?ߣ§@ò@2¡I@[0@„Há@_6c@3«¯@fç?Ýb?©âD?}1? áÒ>nH4¾SA¿4´ï¿¡œ!¿ñTÀ$C_ÀQ}¨ÀÏÀš(WÀ³õ+ÀÏfÀê ²Á”ÁÙMÁ¿«Á,å;Á;jÁI`¡ÁW¤ØÁeñ_Átj¤ÁzÇÁˆÀŠÁ 1ÁŸ79Á—¸)Á:©Áˆ½EÁ?òÁsïÁd¾}ÁV ÍÁGd9Á8¶jÁ*kÁq¬Á /%ÀþNTÀâ@ºÀÆE‹À«8FÀЇÀlŽÀ9ƒÀ—C¿²#ç¿3éú½þm? û?†'?½“?íõ«@ÌÎ@' ž@Dü@eKE@…#®@™ƒ@…¸S@dùg@D%}@'ò9@` ?ö¤?ÆŽŽ?’?+¬«> tÿ¾øwt¿”O‰¿îÉÀ(ºåÀ\#¥Àˆ7êÀ£Í-À¿nBÀÚ÷ÀöÄÁ ‹¹Á¸•Á%ûÁ4AéÁBžÙÁQùÁ_ž£Án**Á|ÈÐÁ…ÇÁ.EÁœ¸§Á•ÚÁ‰gÁ†SÁ} ­ÁnÁ_dÁP^ÁA:ÔÁ2p^Á#Æ+ÁÁb²ÀïŠÅÀÓÓÀ¶òƒÀšäêÀ~<ÀHÁßÀ¹@¿¿à.¿:€\<¨‡2?4LO?­Ük?õu‹@jj@0è@Gâz@`G@{•D@ŒïÃ@ÜÈ@°Í—@žj@(@|>Ì@aýæ@L<@5ñ@{ @’…?ÁÑ?j1­>=f¾ëˆM¿¡fÀýzÀ9×eÀq#æÀ”84À° /ÀÌdlÀè¼ÐÁ–ÁñLÁjÁ-ä­Á£Á B¼Àô¨ÀÖãÀ¹%ßÀ›¾ëÀ}SÀBµqÀ Q¡¿¡¼ò¾ÃZƒ>çÁ:?£}•@ã@4¹@a.8@„Ó@@’^ö@œÀ9@§ðÃ@³?V@¿«Û@δ¢@Þ±@Òn[@Ä ²@·\´@¬tb@¡Ôä@–É@ˆ,‘@mêx@D+ @pI?¾J±? çZ¾w“ ¿ŽD˜¿ÿkFÀ8mëÀqr3À•VFÀ²gœÀÏJ¦ÀìFŠÁ¾IÁm«Á"6ªÁ1'Á?ísÁNêÕÁ]ÿ‡Ám _Á|RZÁ…Ä"Á–jSÁŽ rÁ†ÚƒÁ~7ÁnÉãÁ_n/ÁP—Á@Ì Á1‡dÁ"JÁ! Á Àéê=ÀË¿!À­ÂÀý™Àdz°À)]ÿÝëi¿R°e=¢þ?vÂ?éD¬@*_@]@‡ ü@ŸÚ@¯Ej@¹Àr@Ã*ø@Í«œ@Øú@æ7¯@ôÙê@íž&@àrõ@ÔŽ—@Ê@¿E@³&º@£§@Ž«Š@iñÄ@4ï?øCå?ˆ²]>@’®¿4-¿Ì\ À1ÀX`WÀ‰P¾À¦ŽÝÀÃÍìÀá>ÄÀþ²¯Á!°ÁLÁ,-Á;BÁJY¼ÁY…^ÁhÌéÁx*ÀÁƒÌÑÁ”»šÁŒï©Á…%JÁz¶¯Ák"ÊÁ[ÚÁL qÁ<ž>Á-CÁéËÁÀþq¤ÀßܯÀÁœúÀ£rlÀ…GßÀN=aÀš²¿®Yñ¾Þ% >ø×M?²º}@Lû@J×@€ÃE@šò›@³¡s@ʪŽ@ÖÃ+@ßpd@è‘Ú@ò­@ý¾æAU[A—å@ü–^@ñÑæ@籕@Ý!5@Ï‚¿@ºrŽ@Ÿ¤×@ƒ«=@OeL@À?¼yÅ?X¢¾Ÿ~^¿›Q5À«¸ÀAÑÊÀ|];À›µíÀ¹PÀÖøÆÀõæÁ ”‰Á¨$Á'ÂAÁ6ÿÁFZ§ÁUÎYÁeQÁtÙÁ‚1˜Á“HrÁ‹løÁƒ•bÁw„ØÁgäxÁXDÁH¤ Á9”Á)qÁåÁ ršÀö!7À×aÀ¸ ÕÀ™áXÀvÒ8À:l¿ûn ¿‚ÃÕ½¯*a?XtØ?ãß@,áú@gf–@lM@«ò'@ÆÎ®@ßÛS@ó­ë@ü#ÞAœAK#A O$A-)AwëA {TAjA»@úo@äq@È—q@¬œ@„R@hR@/u]?ëÚò?q?Ê=!bn¿_5¿å:«À-¬»ÀhòÀ’vÀ°~ÞÀΣ®ÀìàÁ±[Á [Á$jÙÁ3ÒaÁCC)ÁR»(Áb:ÁqÉ*Á€²×Á’­ÁŠ@,Á‚aÁtùPÁe0ŸÁUlÀÁE±-Á6 Á&[³Á»TÁõÀîõBÀÏÍ#À°» À‘±HÀe¿À( R¿ÕVk¿7Íh>lH?–íœ@‚V@CBÃ@~Õ@@ºRº@ÖÝÙ@ò7ÃAà&A \A¤AÕÏA:MA¢yA ÞAÙˆAíA³A¹•@ñyæ@ÕSÔ@¸áå@œoI@VÚ@EÎó@ É=?¢am>³ç„¿ÿÉ¿ÀQÀWÀXÀŠ|?À©:OÀÇú9À漞ÁÀOÁ"¨Á!†*Á0û¬Á@‡ÉÁP%wÁ_Ñ Áo‡ÄÁG›Á‘ÃÁ‰,ÁÁFêÁrÅÁbÿ«ÁS<—ÁCs´Á3ªÞÁ#âÁ0ÁPYÀéFÀɪ¬ÀªeÀ‹(IÀX&À{¿·Àê¾íØð?0E?¼Q–@Ü@WN@Š@¨U@Åÿm@ãµ#Ah½Am®AúBAW¿A!ºçA%«ƒA*ž A-ˆìA)[A$“@ARA 2@ý‘í@á ý@ÄMO@§Gø@Š8@YŽ’@"Æ?Ä£æ?­€¾¯fw¿¤ùlÀˆšÀLæ_À…"À£ÓHÀ¦¶Àá«@ÁcãÁòeÁ"Á/xÁ>ÈÁN€Á^AùÁn ÉÁ}Ù£Á8þÁˆRÁ€k6Áq Áa<5ÁQoÉÁA••Á1¸AÁ!á¾ÁKÁF‹Àäó•ÀÅZÀ¥À“À†'ÀLúäÀ ¸ª¿Q&¾ð•?8¡·?Øß:@*¶Ì@hýû@“bÊ@±É°@Ð#‘@îEAèA“A#‰¢A,òœA/ï‰A3†×A7ÿLA;3¦A7A/N A!OAÃFAB @ëVŠ@ͳú@°.V@’1ú@gò<@+¬?Þ"Á?I×¾4@¿’4zÀðxÀDÆ´ÀX5À \PÀ¿`lÀÞd‡ÀýmlÁIÌÁònÁ-ªþÁ=m1ÁM2dÁ\ùÑÁlÃÁ|±ÁÔ÷Á†äSÁWüÁo…´Á_³kÁOá³Á@ŠÁ04@Á SmÁrŸÁ‘ÕÀáb$ÀÁÀ¡ÕÕÀ‚&ÀDçÀÔ¿Œq2½Ü+¨?a×y?ï?/@6Æ•@uí”@š*ÿ@¹_@Ø“;@÷¬îA qA:‹A))šA8¨A>R_AA£›AEÃ}AI6-AC]UA5A&KkAKêA_w@ò†ñ@Ô<Í@µ™@@— @pïû@3Õá?ì?Û?`¹c½·Ý ¿‡XSÀ¹À@FÀ~,Àž À½¹ýÀÜó’ÀüB½Á ÊæÁtnÁ-öÁ<È&ÁL|Á\:ÑÁlgÁ{ÑÁ‰{ŸÁ‚ÔgÁxnÁj.5Á[á+ÁMÇêÁ>ÀßÁ.îÁYÁ@ØÀþ¿£ÀÞý–À¿=&ÀŸ ÀŠzÀ@áÀ›G¿‚Bܼ®¿C?y™Å?üTÂ@=îP@}²@@žµô@¾€—@ÞT@ý¶%A¨|AQôA-ïÇA=$ÃAL÷AOÿºASØAW ŒAGæ]A88A)#ÕA™âA Õ@õ)p@ÖMV@·w@˜ ¸@sLì@53?î‡?eN7½“Ž`¿…CùÀïhÀ?n–À}î±Àž7fÀ½tæÀÜ£MÀûã³Á ™ÑÁGÁ,÷ƒÁ<²—ÁLw0Á\A Ál Á{ÕÁ…gKÁ}.ÁoÅaÁb˜ªÁU<ÁFœyÁ8^#Á*aîÁ¦éÁ#—Àü§¦ÀÝÌÀ½N¼À’œÀ{´ÑÀA^•&Ab.AUÈ+AGA8gA(}ÅAÿŽA „î@ôÝ@Õ%@¶0§@—:@pmf@2f«?è¿ß?YdÒ½õ°Ü¿‹|ŠÀägÀB(JÀ€6ÀŸXÀ¾zÀÝ­¸Àüâ“Á5Á¾þÁ-h/Á=ÁLØ®Á\–¨ÁlT¢Á| Á¯$ÁuWÁgPÁYÿÁL±7Á?ʱÁ1¢ÃÁ#!îÁï§Á"ðÀóGëÀ؇À»‚—À›íŽÀx¯æÀ9„°¿ôŠÉ¿kHh=”&?ˆ(ö@já@B¿…@ @ ´f@ÀaŸ@àÓ@ÿÙ´AÎKA²˜A/šüA?„ÐAOo A_YGA^rAPŠrABôÑA5”øA']™Aì—At:@ñð˜@Òùò@³ÿÀ@•á@l @.0I?àaØ?Hº†¾=:‹¿“±—ÀÿìÀF1èÀ‚1òÀ¡JïÀÀg!Àß–8ÀþÏ{Á^Á¡Á.=¡Á=ÞLÁM“ÁYÕýÁfýÈÁtz—Á|’¥Án.RÁ`âÁRÕÁDJeÁ6Ö%Á)ÒjÁ—ÁSÀÿ¤ÀãoÀÈUŒÀ­€gÀ“¦ªÀq¨ÎÀ4J ¿êØÕ¿Yn/> U-?j;@—Û@Eƒb@‚]²@¢ &@Á¶¦@ác'A‹|AjŽA J=A0)ìA@ ¶AOë=A_ÌÛAZéALÈA>KüA0²ÂA#LoAQEA“†@ðEä@Ñ@,@²:•@“55@hwU@*‘?Ù;‘?9#¾€a濜°ûÀ l\ÀJfÀ„)˜À£JóÀÁ9èÀÞ€«ÀüEWÁ ;xÁwÁ*\ÞÁ6ÅÿÁC² ÁQ *Á^·èÁl§bÁvœ­ÁgÙµÁYC¥ÁJãÁ<Á=Á.ÆzÁ!2Áç:ÁM„ÀôT™ÀÖ¥À¹º²ÀžêÀƒWÀS/KÀ¿ÅÄÁ¿*÷>–dÙ?¡2Æ@S @L£ò@…º©@¥#À@ÄŒì@ãøAº@A£A!OA0`BA>¥—AM*1A[ã(AVÁžAHvˆA:eÓA,‰éA±Aß#A*Ü@ðè‹@ÑÍ·@²ÀÁ@“Ä@i‘Ï@+iw?Û¶í?Ëu¿9d¿ÌlÀ"À]ÈÊÀ’~À¬»`ÀËìÀâñÀûkÁ mèÁÃVÁ%‘ßÁ3½›ÁB"kÁP•ŒÁ_>ÖÁm|£Á^ÏÁN̘Á?—EÁ0‚yÁ!šÁÁí{ÁpŽÀì`hÀÐÞCÀ¶£À•À†oÀY¿«À!²»¿ã°ƒ¿‡æË¾_Î:?% ?ÍyÓ@#Àó@a°@h@¨ h@ÁU~@Û”@öüøA «RA.êA&ôA5ïsAEIATAQïçAC0`A4§ A&bŒAv1A Ð/@ûH@ááÑ@Ê^ý@²ò@“è@m—5@7Aµ@ .²?± æ?:Ó¾Öjƒ¿«0hÀÀSuÐÀ‰8Àž„Àµ•ÀÎÀèø½Á!´Á<Á²—Á-açÁ<žÁJõGÁYÿƒÁj#ýÁZ—ÁK&Á;¯¤Á,FüÁø…Á ÑCÀý»ÑÀàÒÀÂãœÀ¦§nÀ‹Ñ³Ò?²? @˜Ð@X[P@ƒ8í@›Í¤@µ{@Ñ@íš A{²AoìA#A2¨AA¶iAPôIAPÎqAAîA37ÉA$¶~A‘A²@öYV@Ür|@Ä6c@«Ãˆ@ŒRe@ZhÁ@˜c?Éœò?SDE=œ¿1|¿¿ÅnrÀ3óÀ8V‹Àb ¿Àˆ,KÀ¢0ÉÀ½QÈÀÙ¿ÜÀö¦­Á !ÁùÁ(Á76‚ÁFw8ÁUÒiÁgÐÁXUÁHl Á8ÎÁ)ByÁ¿Á ¿ä@mãÚ@‘(@¬à”@ÉŽ¶@æÖŠA@\AI·A xA/¯ÏA>ìŽAN6APx;AA‚A2¹öA$,bAéÓA»0@óž_@Ø6É@½~á@£šE@‰Ä @TÈ@¾?±–J>㪾d°¿6Ñ=¿†Q‰¿½MUÀ’)À7G<ÀlÞúÀ’¤hÀ¯ñèÀÍ£ÀëìqÁN,Áµ¯Á$" Á3¡@ÁC.ÁRÇÓÁf“ÁVÄÁFüÿÁ7?ÈÁ'8Áå!Á+öÀñ àÀÑóÑÀ³$ À”iÀkèkÀ/K¿¿ç—¿cÏæ¼ÌtÊ>ûÁý?K:?£µV?°••?îïÝ@%©@Z0@‰@¥úÑ@ÃN@áKâ@ÿw»AçdAÞA-^…A<ÂÊALÎ =Ì-'¾8I¬¿8w¿Á–ŒÀ¿°ÀSàÀ‡èìÀ¦”jÀÅ«ûÀåÁBÁöcÁ!¨ÆÁ1[¼ÁAªÁPÙéÁfqSÁVŸêÁFÓÛÁ7 Á'BéÁƒÁÓMÀðn\ÀÑanÀ²|#À“Ài9wÀ,aʿ⵿][¼®s&?V|ú?‡‘ÿ?mo??Ö?¶þé@Zw@KJ-@‚ðX@ ¨@¾œ@Ü®ä@ûA ÔA-A+¡HA;&\AJ¬˜APö$AA ÇA2^üA#)…AºAû{@ìè@΃@±&‚@”c‰@oèì@8 @̵?¡¹A?B>Ó?e&N?}}Û?x™¾¥j¿ ­¾À íÇÀHÆyÀƒŽ\À£ ûÀÂ¥ýÀâ:™Áà$Á HÁ eÃÁ00ØÁ@ŒÁOÝ/Ág+ÁWgßÁG©¼Á7ï·Á(;°Á–Á 3Àó"ŒÀÔ…XÀ¶7À—ÖõÀtÕžÀ; 'À„¢¿“ˆÆ¾4¶?L¾ >ãi;¾R^Ä>Œ&>?”¢@x´@@2ß@{žÏ@›Øñ@º7@ؾz@÷c±A ÆAzÆA*5A9–ÝAI-©AJ”A<žÅA.3ôA%Að¶A®@沪@É.j@«·)@Ž=›@b ­@'ìƒ?Ý¢?[8j=s›D>d?U»>뿚‰¿³ &À^cÀNmœÀ…¾êÀ¤\ÖÀÃ;÷ÀâkZÁæñÁ©vÁ x'Á0O½Á@.ÁPÁhçHÁYDkÁI°&Á:*Á*²²ÁNËÁ ƒÀùèSÀÛØqÀ¾/,À¡:jÀ‚VMÀFÀ4w¿–]¾™æu>’ýO¾>âM¿]¨=<^?wßú?ó7-@5°_@r±@—sT@¶£@ÔÂ{@ó‚ZA %xA‰’A'îõA7ejACQöAA/A5 A'e?AsúA BX@ùÞ@Ü×B@¿ªr@¢Ÿ@…Ü*@R4@І?½#×?¾ ‡8¿Ö´=èÖƒ>‰\¿¿·ÇÀ}ªÀV¹UÀŠtÀ©¿ÀÈtÓÀæïöÁãüÁoÃÁ"*Á1Å;ÁA„åÁQG¹Ák¶ÙÁ\GÁLítÁ=šþÁ. QÁŠ8Á¡ÀÿšÞÀá(¶ÀÂtpÀ£ô`À…ËcÀP~À"-¿Æ8¿^Ä+¿ ü%¿c㿈— ¾ áÿ?K>`?ÝÕ1@+pœ@hCŒ@’’@±¤@Ϫù@î;MAM|A^OA$2ÂA14®A3v}A1ÒÛA+(#A ©Aø–AH@íê@Ñ î@´a4@—Å'@vº@=‰Ú@¡=?—½v>—(y¿¥t¿Ÿiü¿6ûŒ¿ #ý¿~Û¿Ü]ÀÀ$©éÀ_€+À›PÀ¬#ÀËËÀéó>ÁlBÁù5Á#œXÁ3OßÁCÔÁRÐ9Ám¬ÕÁ^ÁN~ôÁ? Á/˜yÁ N­Á,Á5UÀæjmÀÈžÃÀ«’îÀ~œÀhÀ5áÌÀ 67¿Ï—¿¹r(¿Ù4¿¡ô ¾ª²ì?ÈQ?Åõu@Ca@[“Þ@‹»ê@©×“@Ç›¡@äï«Aó€Ap·A°»A!Ò2A#¡A"r7AöüA×¹A 2@ø8@ÞAÇ@Âù•@§Y<@‹1ÿ@^Ìß@&?Ú¸#?V˜½.7l¿iè¡¿åØþ¿Ï µ¿½Í#¿Þ~uÀ¥:ÀA Àup˜À–„ÿÀ³SÁÀѽÀïCïÁÐüÁƒÁ%ÌÁ56ÁD±ÍÁTY…Áoß Á`fÁQ„ÁA¶Á2ŠbÁ#‡!Á¸Á0OÀïR_ÀÓ^À·ÓzÀÌÀ„£gÀ\ÈÀ8ßÊÀÊtÀ¾›À­´¿¾xÊ¿ ½á>ÃÓ¦?§ñ|@²@Jî@‚T±@Ÿ@»¸C@Ø@ë@ô5?A±ÊA\AdÍAÓcAå÷AåA´@ýŸ@æ@Í&x@³ò@˜±n@z™@D2H@ °Ñ?ª_Q>èÀr¾Ôl濤À ƒoÀ#1À½=À&ééÀ@ÁÁÀh<ÀжÀ¤gÀ¿YÀÛ{ÀøŒ^Á õÁØ«Á(ðAÁ8/ÁGŒ'ÁVÿ³Ás@ÁcÖPÁT±uÁE¯$Á6×ÞÁ(7ÁÜ)Á ÇåÀûÂÎÀá&ÀÇk×À®ÚÀ˜ë¶À…MqÀlŽÀX†ÀT µÀ*†¿ß0Ó¿UKA=¦×‰?}n?ñò*@2‡1@kfK@‘Ù<@­ Ý@ÈÚ@àuâ@ò7 @þ6ñAªìA ƒA(ÞAî@õŒ™@å@@ÐmË@¹Ì@¡O‹@‡û@[v}@&b¿?áñY?jUq=V5οN¡ê¿Ö½&À"aèÀYVaÀXÚÓÀb´%ÀuñIÀ‹™ÀžÔ•Àµµ©ÀÎОÀévÁUˆÁs‘ÁÔIÁ-|éÁ<]uÁKi¨ÁZ•âÁwN<ÁhT.ÁYsÁJØ9ÁèI%¾ÇVl¿Ø×ÀmÒÀ;÷«Àr•ÕÀ‹qÀtŒÀ—0õÀ¤” ÀµÂ ÀÊ|DÀá~ÂÀùïÁ òwÁlõÁ%6ÕÁ3ZÁAÇ}ÁPo¸Á_A”Á|w>ÁmÐqÁ_YÁQÚÁC"pÁ5~(Á( ãÁ½Á¡€ÁÀ=Àï9¯ÀÚË ÀȯÀ¹ð-À®¤šÀ£\ãÀ†œŽÀU¬Àr=¿ÈfW¿3{>79'?…vÁ?ñ°@.ÃÑ@` m@‡)ï@›^‰@«Wž@·Þp@Á'÷@Æ”u@Èñv@Çc<@ÂI•@ºtm@¯(q@Ÿø@Œ5Ù@o5¹@BÈr@Œœ?Å j?@óνv§6¿_Þ%¿Ø?-À!É‚ÀWâjÀ†ÓÃÀ¢!3À­Ï´À´d_À¿º—ÀΧ¾Àá$îÀöS€Á}QÁ¦Á}”Á,ÖÁ:h‡ÁHTÁV‰ÕÁdó¶ÁAåÁt9ôÁf)¿ÁX]­ÁJßÁ=Á0¯!Á$Z-Áˆ Á T8Á Àó[äÀã6¶ÀÖBÀËsÀ®ôTÀ’ëŒÀnöZÀ7ÀðÀ}‡¿’°[¾™ç? q?­Žö@¹V@5\ß@]Ó“@€ã‹@Õ@šÅ@¢AT@§qC@©r¨@§ëý@£`@œ{@’ø@…Qo@gKö@@¸±@`?ÕšŽ?qˆÿ>7»â¿{¿±ŽÏÀ =¯À@{ÀtÎÀ”ú1À¯º/ÀÊ´ÀÒh ÀÜ/XÀéJÀùÑÁ’ÄÁ%äÁ{”Á(“]Á5FiÁBvRÁOÜiÁ]–?Ák•PÁ„©vÁ{g[Ám¾ÔÁ`e—ÁSF5ÁFyŸÁ:)‰Á.bNÁ# Á¯³ÁJ5Á°sÀþæHÀó!À×<6À»þKÀ ÇÀ…KOÀTšÀ•%¿ÒPÌ¿U€:¼º×Ü?@ƒTò@ˆ{@‰óÛ@ˆ} @„ h@|oì@i°J@RÝ@4Pw@¾g?Ó1?~)">— ¾¾Ðò“¿–!Ê¿÷i0À-ªgÀ`†ˆÀŠ/zÀ¤,KÀ¾xÀÙñÀðäuÀù€Á‘7Á ÿ·ÁÍøÁ²vÁ'E3Á2¢iÁ>ª@ÁK>lÁX7lÁeqIÁsžÁˆiƒÁ§NÁvNÁi ŸÁ\YjÁPºÁDbFÁ9fÁ.„)Á$ÐQÁöÁ'AÁ ›êÁ;¦Àå{…ÀÊ%À¯¤ÝÀ”«®Às›ÀÀ?øÀ Ä¿³ü¿%÷I=XÌf?1¤&?¥³G?éÚ@}P@'Íp@:¿S@Hƒ`@PÜ·@Tê@RPŠ@KÔÑ@?XÊ@.žI@«ö?ýFF?»© ?am>‘ž¿¾Â[|¿‰•…¿ábóÀ!‘wÀQƒÀ§ßÀš™'À´¤ÀÎJÀçüÁÁ1ôÁ ¥òÁèÒÁ¦ Á´Á(ä©Á2Æ Á=y¡ÁHà%ÁTÜ×ÁaWÃÁnlÁ{4ÁŒƒÄÁ…ôêÁ~ùÁr\žÁf,ÁZx;ÁO7­ÁD†ÔÁ:˜ÊÁ1ŽBÁ)P’Á" ÿÁtÁ¯(ÀôŒâÀÙæMÀ¿bÀ¤õìÀŠí7ÀcÀ2—RÀ91¿«^~¿.«½œ™>óü?q}–?¬mÂ?ØÈU?ú;N@ ?|@Ö@ì‚@åÚ@ ľ@A¨?ä§2?½ â?8÷?"T~=Ìy¾øÐË¿‹¿¿àBOÀÒNÀG˜eÀw¶)À“ŸþÀ¬©ÀÄóÀÞ{À÷ÉqÁÆLÁØÓÁy/Á%®)Á-ÅÁ5–üÁ>ÏÓÁHâûÁS±LÁ_•Ák«ÁwlÁ‚ _ÁäœÁŠ€ÊÁ„;ÏÁ|NEÁp”×Áe_ÁZ©¿ÁPOÁG; Á>ÆPÁ7-Á)è¢Á“ÁMñÁ#Àê>ÀÐ7åÀ¶QKÀ‡•À…c¿À[+‡À.õØÀxO¿¹^y¿dVå¾Çí³=4=>ÙcC?>Ä?€$?˜ %?§ž°?®I•?«´?Ÿ??‰)?WÕC?ñ›>nñ>¾TŽV¿7Q÷¿¢(º¿ëÅaÀM—ÀFŸÀr]ðÀ>DÀ¦«²À¾jÊÀÖ°dÀïx/Á×Áã}ÁºâÁ*§üÁ3ô<Á:Ü·ÁBÁDÁKcŒÁTÞˆÁ_uÁiøLÁugþÁ€¥ÞÁ†ÂëÁ•ŠŽÁKóÁ‰;ÓÁƒ`ÒÁ{„¸ÁpÑÖÁf¦¸Á]²ÁTQ ÁL#sÁ>Û<Á1ÕÁ$–Áx Á ußÀûsÉÀáÕ(ÀÈÛèÀ°ó+À™ø´Àƒì À\kØÀ4yôÀ²Ž¿ÝK¿ ×_¿Y)õ¾þOF¾Ga=>ñ>\¼ >¬ÕP>ÆR>¼d>‹©=ß,‚½·7¾µò+¿-O!¿Šbæ¿ÆÑ@Àá À&èøÀL«HÀs~hÀŽ=AÀ¤5YÀºs ÀÑ»UÀéIuÁ” Á ð>ÁQ8Á%ê Á2µƒÁ?‹½ÁHåYÁPMÁXkÁaYîÁküÁua„Á€'€Á…Þ×Á‹Å‘ÁšcáÁ”YaÁŽ€TÁˆßÁƒ|¿Á|ÂÞÁs ÁjGÁa$œÁSéÁFÀdÁ9ÐÁ,¿ƒÁè5Á:ÿÁœÀôeÎÀÜûÀÆCÐÀ¯í¿ÀšV“À†õÀh}FÀE ¶À%µ{À xy¿áL¿µ~P¿‘%—¿h„%¿>ŠÍ¿"h¿| ¿ð¿2óŒ¿X¦¿ƒ×{¿¤M̗ܿ¿úêšÀµÀ9´HÀYÇsÀ|ªÀÀ‘1ºÀ¤<À¹7ÀÏHÀ媇ÀüΡÁ !÷ÁßbÁ"-Á.†êÁ;rÁGÎÁT—1Á^(„ÁeÒÈÁnAÁwnÿÁ€¤Á…Ü¢Á‹XÐÁ‘ ÁŸ~Á™¦öÁ”•ÁŽšÁ‰qGÁ„¾ÁòuÁv(Áhù¬Á[ùªÁO (ÁB ‹Á5méÁ(òXÁ[bÁ+…ÁwïÀòO4ÀÛõÀƘŠÀ²,2ÀŸ´»ÀŽ@À{ÇÀ\¬qÀB‘oÀ+9YÀ™×À™J¿ïÉG¿Úí¿Íe¿Çþ!¿Êõ¿Õ O¿æYô¿üï1À ·ðÀ òÍÀ7ÀQxÀo °À‡\À—&žÀ©GÀ»õ ÀÏŸÀäuÚÀúÉBÁqºÁðöÁ—ÕÁ+DíÁ7i«ÁCÁÁP.GÁ\á Ái¬HÁsŠºÁ{ƒjÁ‚ÚÁ†Í›Á‹Ë[Á‘'Á–Á¤ÓFÁŸ.HÁ™¾×Á”ŠÕÁ˜¶ÁŠï†Á…ÖÁ~sÁq4ÁdGÁWv¼ÁJûÁ>‹!Á22#Á&1ÁsÈÁüÝÁùKÀòÀÞ‡^ÀË À¹~jÀ¨“âÀ˜ÙÌÀŠÛ‘À|êÀeÃÑÀRt‡ÀBW:À5%•À+š`À$œXÀ"¦À# À(clÀ0™À;"åÀIúÀ[ì;Àp¾ãÀ…NSÀ’ܤÀ¡Û÷À±XÀÁ®ÙÀÔ=OÀæòbÀú˜eÁîÁÉÁ ¹Á)lÝÁ5 $Á@·ÁLÐ)ÁYŸÁesÁqøäÁ~Á_Á„‰ŸÁˆ­{Á&nÁ‘ì¦Á–øÍÁœDÁª]òÁ¤é‰ÁŸ¬Áš«#Á•ìÊÁ.üÁ‰¦ÊÁƒ5EÁyš-Álö1Á`ˆ=ÁTÁGêOÁ<eÁ0F§Á$á¢ÁùKÁ%dÁƒÀöËÀä¨=ÀÓÐÀèºÀ´} À§l0À›IÀGÞÀ†áeÀ~­xÀrm¡ÀinôÀbI6À_Î!À`#ÉÀeÀ6ÀmëDÀwü`Àƒ NÀ‹qGÀ•˜ªÀ¡„NÀ®žÀ¼ÜVÀÌOÀÛ¤_ÀìÖÀÀÿJÁ ‹Á2Á²ŽÁ(™.Á3¦ŠÁ>ð4ÁJ†ÓÁV)Áb, Áni6ÁzÅ Áƒ˜_Á‰ôDÁcsÁ“¨fÁ˜:fÁºÁ¢+Á° ÁªÓ€Á¥ÅëÁ õÁšÁ-Á”EÁá]Á‡‰žÁB+Áv Ái²0Á]¥“ÁQÑŽÁFµÁ:ÊéÁ/ë•Á%FÁÉyÁ<‘Áú¶Àþ$ÛÀíÏÕÀÞȘÀП–ÀáÀÀ¸À­ÙÀ¤èüÀŽþÀ—w-À“wûÀý#ÀŽÇ©ÀŽïÀ‘K†À•&ËÀš†ØÀ¡šÀ©tºÀ²ê-À¾üÀÊ˧ÀØPùÀæÑEÀöOÔÁàÁ fÁ(8ÁÂÁ(ò­Á3Q>Á>-ÁI?\ÁTwÒÁ` (Ák±ÅÁwœÁÚöÁˆ ·ÁŽEÙÁ””2ÁšNLÁž¯PÁ£V¤Á¨>rÁµÿùÁ°ç|Á«æ¼Á¥jNÁžõœÁ˜ ¬Á’K”ÁŒ Á…ÝÁ]PÁsewÁgœ¢Á[ë^ÁP¶…ÁEÖóÁ;ÚÁ0¦%Á&öGÁѧÁ§òÁ ËÁt¶Àú'…ÀìmÀà(ÀÕ‡ÀË9pÀÂõðÀ»¦|Àµ½žÀ±ÃêÀ®×ÐÀ­Ä˜À­§ßÀ¯µhÀ³u}À¸áíÀ¿,ÀÇ. ÀÏö¦ÀÛ; Àç˜Àó¿ÁÇ}Á®Á1·Á…ÄÁ!tDÁ*-Á4EÁ>…ûÁHëNÁSÁýÁ^Ø-ÁjôÁuœ2Á€¢êÁ††ÁŒÁ’¾TÁ˜õÉÁŸ9Á¥FÌÁ©¿ãÁ®y“Á¼¡Á¶”yÁ°‚Á©©ÁÁ£]…Á1Á–ÔÂÁ±òÁŠŒ$Á„—¯Á}yŸÁqÉ0ÁfŽ*Á[¿ÔÁPòQÁF–yÁÁ¦ããÁ¬ÝLÁ²ü¯Á¹'fÁ¿XÁÉýÁôûÁ½oºÁ·E“Á±9¯Á«3 Á¥DhÁŸtÞÁ™°ÞÁ” æÁŽÁ‰MùÁ„ŒÁ}éóÁt LÁjÓ|ÁaæèÁY2WÁPÎÞÁI;aÁAÏvÁ;)^Á4˜”Á.¾oÁ)‚<Á$£‚Á ”)ÁßñÁµ»ÁA{ÁeÛÁrÁtfÁ´#Á?ÁûÊÁ.‚ÁøzÁÌÁ"¾Á&Á+ðÁ1Â:Á7ÄÁ=üUÁEöÁL~§ÁT[¦Á\ Áe2”Ám×ÁvîÖÁ€O^Á…lÅÁŠ¢àÁæ Á•KÁšÇ¨Á aöÁ¦#ËÁ«éßÁ±º¢Á·²ÚÁ½ÌÄÁÃîÃÁΊÁÈRŸÁÂ,’Á¼!ôÁ¶Á°(ÇÁª[vÁ¤£YÁŸ:Á™ŠòÁ”8ëÁkÁ‰à!Á„ÝÁ€(ÉÁwe#Án¯´Áf°Á^÷ÁV•6ÁOvdÁHüÁBkÁ<öLÁ7÷ÍÁ3-ÒÁ/6aÁ+™àÁ(®'Á&-ƒÁ$sSÁ#, Á"¾PÁ"ñ Á#iÁ$ú“Á'(ôÁ)×HÁ,îêÁ0®ýÁ5"Á9ùâÁ?©+ÁEÊÁL"ÁR½ÁZ;Áa¢³Ái6ÁqàYÁzx¦Á¢rÁ†KÁ‹-:ÁN)Á•ƒÁšËÁ /†Á¥¢7Á«<ÍÁ°þ°Á¶ÆÁ¼–ìÁÂQÁÈ¥KÁÓ<¼ÁÍÆÁÇ gÁÁÅÁ»çÁµHþÁ¯›ƒÁª†Á¤€éÁŸ$Á™éJÁ”ÇåÁ¾2ÁŠñÅÁ†goÁúÛÁ{SHÁs%Ákq©ÁcþýÁ]E´ÁVÏLÁP ÁK`iÁF^ˆÁA¹wÁ=ô{Á:\/Á7–ËÁ5&¢Á3wÁ2R7Á1÷µÁ2ƒÁ2œUÁ4¥Á6*-Á8¹%Á;ÖÁ?NTÁC’ÝÁH5`ÁMš­ÁSŠÈÁZ ]Á`„ÁÁg³?Áo.ÁváÕÁ~ØàÁƒ‹Á‡á×ÁŒkœÁ‘!ÕÁ– §Á›/Á cXÁ¥°1Á«°Á°…cÁ¶$*Á»Þ‰ÁÁ¢JÁÇs9ÁÍgüÁØÁÑôÚÁËôõÁÆwÁÀ=öÁº˜\Áµ#Á¯}gÁªÍÁ¤Î@ÁŸ²Áš«–Á•Ë«Á‘,ÙÁŒ§¤ÁˆI)Á„)%Á€<ÁxÈLÁq›§ÁkâÁd·Á^ÙÁY¶ÁÁTÄŽÁP^2ÁL¸ÁI2BÁF}üÁD"bÁB~²ÁAjpÁAFÁA1†ÁAѧÁCeÁE3ÎÁG¦MÁJ¸?ÁNþÁR1ïÁV®óÁ[ÉZÁabøÁgÑÁnbÁuLKÁ|“tÁ‚ Á…ù‰Á‰þáÁŽ1˜Á’˜ôÁ—>eÁ›ù¨Á ê‡Á¦>Á«CþÁ°–ýÁµÿÁ»uÁÁŒÁÆÇGÁÌ‚DÁÒRBÁÝ‹Á×d®ÁÑ]¢ÁËwáÁŤxÁ¿ä´ÁºL£Á´Ì‡Á¯aOÁª%Á¥!¥Á [AÁ›¬ÕÁ—{Á’£†ÁŽŽäÁ‡ßÁ€øëÁt7ÁfÈFÁY±ÙÁLêæÁ@~ Á4ÎÁ(ý;Á@¤ÁwzÁ ¢¬Á iÀú ·Àï²$ÀècÀãìÀã0þÀå‚uÀêûÀódöÀÿhÁjÁµPÁÎ$Á!ðáÁ,ŸÁ7þ”ÁDXÁPpþÁ]KÁjÌÁw{wÁ‚ÃÁ‰kUÁŒ3Á‘öÁ•ÏâÁš$¾Áž¿©Á£‘“Á¨u Á­„ÒÁ²º¨Á¸óÁ½ˆ€ÁÃ'`ÁÈïÁÎÝ—ÁØ|jÁÒI¨ÁÌMÁÆPÁÀ)ŽÁºU Á´”ŠÁ®ý Á©~Á¤(ÁžáÌÁ™êâÁ•0•ÁƒÀÁ‹íeÁ‡¥!Áƒ«èÁz2ÁlaÁÁ^ˆlÁPíßÁC°5Á6áôÁ*qSÁPƒÁÌ–Á1aÀýrÆÀì^hÀݨ7ÀÒOÀÊ4}ÀÅ_`ÀÄkdÀÇTÀÌöãÀÖ”oÀâßÅÀòYÓÁãAÁ Ë.Á}\Á!ÕÎÁ-äcÁ:WéÁGÓÁTKÁaÏÁÁov¥Á}JsÁ‚³ÌÁ† ûÁŠÏ\ÁÑÁ“”“Á˜ZtÁ9£Á¢@YÁ§p¼Á¬ÅÁ²:`Á·ØžÁ½¢ªÁÔ¢ÁÉ ÇÁÓ~ÀÁÍ;ÁÇ3ÁÀÙÁºÇŒÁ´ÛcÁ¯ÐÁ©DeÁ£­|Áž/­Á˜ËÃÁ“ }Áޏ&ÁŠ Á…[«Á€Û’ÁyjÊÁq’}ÁdÛ—ÁVÝÁIˆÁ;B“Á-×hÁ å>Á|ÁCÓÀùˆ`ÀäµöÀÒy<ÀÂI¸ÀµªTÀ¬ À§ À¥ÅOÀ¨æuÀ¯U‚À¹þwÀÇš%ÀØ…œÀë›8ÁiÏÁ ѰÁ˸Á$YÚÁ1OëÁ>“ÃÁL-áÁYôÙÁgÓœÁoÚýÁwdÈÁ¬Á„ÍÁˆo?Á#ÞÁ’Á–ý@Áœ'\Á¡x]Á¦ìÁ¬ŠÁ²V4Á¸L“Á¾[»ÁÄo<ÁΰðÁÈFÊÁÁúÂÁ»Æ½Áµ•Á¯}iÁ©gÁ£¶‰ÁôGÁ˜]ïÁ’áŠÁ‚QÁˆaªÁƒŠzÁ}»Áto1Ák«=Ác¥Á[ÓmÁOÂBÁA™-Á3­YÁ%ØÁ9Á ôÀýšÀäÃhÀÍûÃÀ¹¨yÀ§ÙfÀ™”÷À7ŽÀ‰úÀ‡u'ÀŠÍ7À’e…Àž,À­®”ÀÀÐÀÔ¯KÀëµ§ÁÑþÁ„”Á‰Á(ðgÁ6¼ÁDšÁRiÁZ^ Áa­ÓÁi9ÁrxÁz¢fÁðìÁ†ÉâÁ‹»šÁÞ¦Á–+ÄÁ›žäÁ¡;ÀÁ§ CÁ­iÁ³¿Á¹+ÝÁ¿]ÁÊ‹ÁÃ…ÙÁ½»Á¶¼Á°…GÁªR‰Á¤4Áž?¦Á˜gMÁ’¤0ÁhÁ‡“«Á‚:ÁzKûÁpÀÔÁgkPÁ^8éÁU¾nÁMájÁF<;Á:¾ÀÁ,”…Á‹kÁ‘ØÁìÎÀëC=ÀѤ,À¹2®À£ xÀŽéqÀ}CÀdà ÀVÉeÀSY‡ÀZXJÀk¼Àƒ>ÌÀ”ÜqÀ¨ëbÀÀsÀØ-šÀñÁúÁõ[Á–)Á!r“Á/`_Á<÷ÒÁDã}ÁL”ÁS³ŠÁ[ÿlÁdy"Ám†6Áw%†Á€{&Á…–ÇÁŠßXÁQ;Á•í½Á›¾ÇÁ¡¿;Á§ÑÄÁ­é‹Á´" Áº|HÁÅ£lÁ¾øþÁ¸^êÁ±àÁ«€›Á¥CÑÁŸÁ˜ë“Á’òÁÁ‡T"Á¾êÁxŒCÁmæ«ÁcÜÍÁZnÂÁQÁHvÁ?õÀÁ8 àÁ0àžÁ%î?Á¼EÁ ¥+À÷D ÀÛ¦ÄÀÀå¦À¦è}ÀŽbÀo„¤ÀJ}ÊÀ-¯ÊÀñìÀ&ÔÀÏÀ5ÀT5ÂÀ{ý±À”ªÀ¬çÒÀÆäÀá{Àü÷§Á W´Á,¡Á'±aÁ/+Á6Ÿ›Á=ôfÁEþ_ÁNd ÁW8Á`·IÁjz[ÁtŸóÁ&IÁ…“ÁŠŸÞÁs­Á–zÁœŒÉÁ¢¨~Á¨éCÁ¯KCÁµ´›ÁÁ7oÁº‹Á³â Á­<ïÁ¦²[Á G—Áš[Á“ÏœÁ¤CÁ‡¤´ÁÉÁxAÁlÞêÁaò ÁW]=ÁMxwÁDoÁ:ÖkÁ2»Á*5Á"ŒRÁÇÁ€2ÁFÀê8:ÀÍÚÔÀ²D/À—#ÀyoWÀGîfÀÃö¿òЬ¿ÆmV¿¹ ª¿Î^UÀÀ&d¤ÀSKüÀ‚f"Àœ€­À·xÕÀÓ-zÀîÿ?Á+/Á—ÅÁœÂÁ!&UÁ(_Á0"Á8a,Á@ûòÁJIÓÁTóÁ^#ÁhŽsÁskÖÁ~¤Á…)Á‹5Á‘GÎÁ—iÁ³(Á¤=Áª†¯Á±ûÁ¼ý©Á¶,cÁ¯r™Á¨ËmÁ¢ ðÁ›‰"Á•ÁŽÁ¯ÁˆŽ'Á‚^cÁx¯nÁlóðÁah]ÁV@ÁKXþÁ@Ù>Á7"mÁ-ÓêÁ$¡)ÁLeÁvâÁ D\Á¬ÀûÓÀÞ¨2ÀÁïíÀ¥³)À‰·,À\sàÀ&®?¿èHõ¿’dX¿/qå¿ ˜„¿C¿¢ºá¿ü¹VÀ0äEÀeòäÀŽP0À©ôYÀÅu±Àà£÷Àû¸DÁ„Á ñ¢ÁáÁ;ŽÁ"`Á*Ø<Á3ååÁ=–&ÁGŽÁQ÷^Á\ЇÁhSÁs¾!Áà@Á†ÒÁŒ+oÁ’€WÁ˜éEÁŸ\,Á¥æ¶Á¬ÀÁ¹>Á²  Á«*&Á¤axÁ³›Á— Áe‚Á‰àÅÁƒƒ˜Áz™bÁn4»Áb€ÁVVÁJÈ¢Á?¡qÁ4Á†Á*\ÓÁ ÓÍÁßÁ°Á‘ ÀýÀHÀðZ’Àã]YÀÓËSÀ·‰aÀšïvÀ}³ÀDŠŸÀ …&¿«¿Ð¿ úÞ=Æ”a>§ar;E$7¿-"¨¿¼q×ÀDsÀKB<ÀLËÀœÌ‰À¸!(ÀÓPÀáXýÀíîAÀúÔ3Á£Á _zÁÃØÁ‘úÁ''èÁ1 ÛÁ;aOÁF59ÁQl¯Á]+¿ÁiVIÁu|<Á€ðMÁ‡OQÁº©Á”7bÁšÐÓÁ¡‡Á¨WçÁµ$Á®&Á§#ÄÁ 2ˆÁ™YLÁ’›lÁ‹ónÁ…HâÁ}hÈÁp‘ØÁdvÁW°øÁK~ûÁ?¸‘Á4)!Á)ùÁ,RÁëtÁ Š-ÁMôÀñ]Àá¶NÀÓ^0ÀÆOQÀº"1À®Z]À’(ªÀkLÐÀ1¸%¿ðE¿|HZ½æ“¢?6Ÿ?–`×?Òµ¾Z0¿ˆ"¿ö”$À2­ÆÀj-3ÀÚpÀ¬•ïÀ¸0vÀÃÆžÀР°ÀÞE%Àí£Àýƒ¿ÁVÁ¹ªÁˆÁ$̳Á/™íÁ:ÑÁF›ˆÁRÌSÁ^õpÁkp–Áx<—Á‚TÁ‰¶ÁÄÁ–Œ9ÁkwÁ¤NdÁ±_ÁªJûÁ£IƒÁœHÉÁ•GàÁŽ\(Á‡Œ'Á€Ü'ÁtdÁgËÁZ%5ÁM“ŠÁA. Á4éeÁ)uÁ‰ñÁdÊÁš„ÀûÀèÀÖEMÀÅýÀ¶ŽÊÀ©aôÀœÑ@À‘ oÀ„—÷À[d™À"U¿ÑY¿:ÜF>-œÎ?†|é?êØO?€¨³>ùE¿3U[¿É:À“’ÀTQ+À„”«ÀóÀš¯HÀ¦¢þÀ³_ÍÀÁÑoÀѦÀâo'Àô—ÔÁ ¨Á::Áþ¤Á$5œÁ0OÁÔ ?©H@ ‚û?¯’?ôm¾¸J¿ž]À[ÙÀ5ÌâÀMyÁÀb©³Ày{õÀ‰a¾À–ÈÀ¥?À¶GGÀÇÚ'ÀÛ1ÀïV2Ác`Á š?Á„ŒÁ%¸fÁ1ô%Á>¦¾ÁKˆÁX›ÄÁe÷ðÁsŸ#Á€±èÁ‡”¡ÁŽ}ÑÁ•tÔÁœxnÁª}0Á£4»Á›õÿÁ”ÁÊÁž`Á†‘ÜÁ#¡ÁqOÁc%öÁUpÁH dÁ:´Á-oÒÁ —Á(5ÁÇâÀ÷ÆâÀà™ÎÀÊTÀµåÀ¢‘Àš]À~»À_;ÀEìÔÀ-ÑšÀWD¿ûпÀ t¿læâ¾9Œ…?/£–?ËÖa@?ÛÃï?[®<»§Æ¨¿VÄE¿À,ó¿øÜÀˆ)À'ÐVÀ>¯tÀWïÀt¹~ÀŠE&À›cYÀ®T’ÀÂCIÀ×DÀíþ*Áû?Á.oÁ}6Á(EˆÁ5AWÁBwÁPbÁ]ÇëÁkŒ™Áy\#Áƒ¦hÁЬÑÁ‘¿UÁ˜ããÁ§R9ÁŸùÔÁ˜¥Á‘X@ÁŠÁ‚à5Áw}2ÁinOÁ[iÁMa­Á?vÁ1ÛZÁ$†ßÁ1‹Á &lÀûJ“ÀâžÀÊÃÀ³]JÀéÀˆ9Àk ¦ÀGPšÀ'À Kõ¿èš¿¸Ü¿ˆ{ª¿$B¢¾vÏ>â¡y?”¾?ú9H@3íÏ@+Ê?£„?'“¾b´¿!ÅÚ¿A8¿«¨t¿Øg;ÀE˜À–(À<†ûÀ^[«ÀxÀ•=ÀªYáÀÀȆÀØããÀñHñÁÁï°ÁëÁ,riÁ:-MÁGòñÁU¼ÍÁc°ÑÁqÄÛÁó„Á‡9ÁŽNöÁ•€ÌÁ¤7ÍÁœÙùÁ•~ÅÁŽ%ŒÁ†Ï¨Á~ûGÁpmôÁaýJÁS¾ÞÁEµ±Á7®^Á)§ Á̦ÁY ÁÀç‹úÀÎD¼ÀµyÀÀZ£À† ÆÀ_׬À7$ýÀ+¿à}W¿¥ìV¿f)¿¿ ¯m¾A>\¤l?*õP?™&U?ç®ø@ ê{@R À@%Ñ?ïò?šEQ?/3>„y_½ )D¾Ñ!0¿A à¿’Ë'¿Ë >ÀMÀ)8ÀPn”ÀzGbÀ“”5À«ÑHÀÄ5ÀÝ]µÀ÷]*Áú¾Á™ÿÁ$`¼Á2'…Á@(ÁN3ÐÁ\o'Áj¼Áy Áƒ¼¥ÁŠìñÁ’ Á¡WiÁ™Ú§Á’kÁ‹ãÁƒ«PÁx¢‡Áiö¿Á[KœÁL²¼Á>;(Á0†Á!ûÁó¼ÁíoÀð^µÀÕ­ÀÀ»áÀ¡EÀˆséÀ`I À1È„Àš¸¿»ñ‰¿gu›¾Î¯ï;«ÉR>·³?2Ð?‰¯Å?¿s?ý³Ð@"¢<@JØé@wJI@M¹'@$p½@ÙQ?Æ\?–¶/?[z?/½>#„ʾyÁq¿84m¿ †È¿ìÙJÀÛÛÀLÅèÀ}}\À—'IÀ°¯(À˵Àæ-ìÁÜ,Á£ÁœÁ*¨ÕÁ8òÁG?|ÁU•²ÁcõÜÁrVÁ€^ãÁ‡¤¥ÁŽþLÁž£®Á—!ÁžƒÁˆžÁ€¤iÁro5Ác¯¸ÁTú ÁFN/Á7¢gÁ(ü1Á{?Á I$Àü€ÛÀàr5ÀÄm×À©SDÀލ@Àh¢sÀ6Ü$ÀÜÊ¿®žö¿0ú½Ÿd>êWÇ?f>)?¡¿×?ËG?÷ò/@Ù@1œœ@Q}ï@wJ¦@ëŠ@z`“@Vî@6\@ãŒ@+‹?ä#4?¹îª?Š0¡?$e>o}¾å•L¿Šá¿äðÀ#X&ÀTišÀ„LBÀŸ`LÀºå¤ÀÖo.ÀòbÁ(%ÁuÁ#ÂöÁ2_Á@rnÁN×{Á]OÄÁkà¥Ázœ”Á„µ ÁŒÇÁœÁ”{pÁŒíÅÁ…i¨Á{Î%ÁlÉ[Á]Í5ÁNÝÌÁ@ ÖÁ1RgÁ"¥ŸÁù×ÁNÀí%ÀÑ%]Àµ fÀ˜üòÀz#PÀD›‡ÀE€¿¹ ë¿-Â/=JcW?5Vr?§+˜?äá@ ãº@Nå@3³7@Iéf@bÏR@€ÐÂ@‘õy@¥‰"@•Ö@„Ûk@mø@UxÖ@@AÕ@-©@·¥?þ»ô?À×É?t7>§Ö¾Âl¿’eâ¿ö ¹À1C›ÀhT‰À³®À«CÂÀÇxØÀäÊÁGÁ“ØÁñÉÁ+k$Á9õ•ÁH[ÁWRAÁf Átí…Áà±Á‰YÏÁ™·àÁ’˜ÁŠ{PÁ‚Ü¢Áv…'Ágg-ÁX_BÁIZÁ:\äÁ+a“ÁshÁ «}ÀýúÀà¢ÀÃL‹À¦½À‰¼öÀ[>ÃÀ#^¿×Í¿ZB½11Æ?;DÃ?»E,@ª?@*2Ê@E?¿@Y^_@k€@$e@ŠÄË@˜·Á@¨6I@ºà’@®à@Ÿ¸ù@’ñN@‡Ýæ@{™I@hÖY@SRS@8 @???ÞnÀ?ƒ¦>†ÑÚ¿73¿µ½uÀð]ÀIÀÀ€ÃqÀ6ŠÀ¹¾÷ÀÖGdÀó8Á#ÁžªÁ%=;Á4 ÁB×yÁQ¥Á`‡TÁoÃÁ~±}Á†ïÁ—‡ðÁÓÁˆ'Á€ƒ~ÁqÊlÁbÉÁSObÁDÌÁ4òÕÁ%ë5Áì’ÁñBÀñëâÀÔÀ¶ªÀ™[9Àx#À=kÙÀ©¿˜Û꾡–\?‘Ï?®cR@Üß@8ž@_Èè@}èO@‰«@@’fÛ@šÓÊ@¤®O@°[T@¾:@͆×@Èt$@»XÐ@®ë¦@¤á@›‘N@’L@†ê @n©›@IBÒ@©Þ?Ó²Ó?J\M½;T¿n1É¿èA®À,Ø“ÀeémÀœÍÀ¬–‚ÀÉ~åÀæ}ÁñkÁ¿×ÁŽzÁ.a‘Á=Z°ÁLzðÁ[¨%Áj×fÁzcÁ„¢ñÁ•­ Áì=Á†'ÞÁ|ËYÁmUÁ]ïÍÁNŸeÁ?a§Á0#éÁ åƒÁ§=Á~†ÀæøÀÉàÀ« PÀ´À^؈À$>9¿ÓGÕ¿;›œ>"zó?„Ų?õ‰@0(å@bèŽ@ˆÞ­@›&A@§!@¯>@¶ù\@¿1B@ÈîL@Ô®*@âºö@âÿŽ@ÖÔ @ËÃ<@ˆ@¹\C@¯Å˜@£t‹@‘¡é@uuè@@R@ ™?£Õ>Ê)˜¾û\¦¿±&À¸ÅÀL®PÀƒ2iÀ  À½zàÀÛ+ôÀøÞKÁ NYÁ]WÁ)Á8ÅìÁGû¼ÁW: Áf†ÁuøQÁ‚¹;Á“ê*ÁŒ"Á„_ãÁy?;Ái¾°ÁZ.¢ÁJ› Á;rÁ+šgÁ;kÁ øpÀûtÀÜøÀ¾}–À *bÀ‚)EÀHgöÀ }d¿¡u8¾®0?Q8?¿$å@ø}@Q)Ò@„/ï@žz@µ‰»@Ä8e@ÌQ•@ÓNû@ÚqV@âÐ @í!5@ùÝ•@ý5\@ò|@èAn@ß&º@×4Å@Í%½@¾`ñ@¦Á @ŠæÞ@^$©@%s‡?Ù8?N>…½É{S¿€_9¿ô)‹À4‘ÀoiÐÀ•N#À³‰ÀÑÝÀï2ÖÁÀKÁöÁ%=Á4 ÓÁDƒÁS¢°Ác,'ÁrµžÁÁ’€ÁŠ£gÁ‚ÉwÁuç+ÁfE/ÁV¯ÁG'§Á7¥Á(KÁ}€Áé¶Àò²ºÀÓÌ^Àµ-{À–¯ Àpj¼À3v9¿íû¿jçÅ<˜P·?tE¢?ñ6í@3L‡@n Ì@“ã @¯ð¹@Ë@à‘´@êQì@ðˆ>@öÆŸ@ýøßAŒ¹A MÅA “éAµðANÞ@üz²@õ @ê»@е@´Ð@˜ƒt@wà/@>Ñø@åß?—H>ŠS+¿%#_¿ÈaYÀ†ÀZɤÀ‹=À©»¨ÀÇõWÀæ–ÁÅXÁOYÁ!ÙÓÁ1dNÁ@îÈÁPyUÁ` ÍÁo©©ÁPÑÁ‘GiÁ‰ikÁ‹lÁsZÜÁcžßÁSâãÁD&æÁ4m-Á$½íÁ Á‡{Àëç,ÀÌ¿aÀ­—–ÀŽoÌÀ^ç%À!‚$¿È:k¿—&>¯ÿ1?¤¯|@¯–@JÉ9@ƒ3¾@ â`@¾?Õ@Û>ð@÷:8AâA A ÏÉA UA pAZtAî…AÀAž-A  A !@ú@ÝÙ@Á„“@¤ßç@ˆ€@V3ÿ@A?Âul?p¾¬+Ú¿£(9À ݾÀJQ2ÀƒÖ^À¢”¬ÀÁ^÷ÀàI¡ÀÿIìÁ0¿ÁÐIÁ.}#Á>4ÁMò˜Á]·CÁm€ÌÁ}M´Á0¬ÁˆI7Á€diÁqýÁaAÁQƒWÁAÆVÁ2 UÁ"LTÁSÁÒRÀæ ÌÀÆ“wÀ§'„À‡äÀQF¬ÀÅ1¿¨Ïw¾±ÚÔ?¦O?É@" L@_I÷@ω@«ú@É÷ˆ@ç®eA¤A4,AOA†¡AWÉAõÃA#âtA&À‰A"ªuA4ÂA4$AXÕA"m@é›S@Ì×]@¯úg@’¦@j˜`@/?>?æ™*?]g²½ÁnF¿‡)²À@À>§¦À|1 ÀœóÿÀ¼ÿÀÛJâÀú¼ÌÁ &­ÁôÁ,ÂrÁ)ÎÁ.TîÁ€DÁ°ÀýÇÀÞ.¥À¾–1Àžý¼À~ÊÀ?™§À¦¿,p¼¥9«?w¢9?ú7 @ñ¿Ud¿ç•ÜÀ2F°ÀpìÐÀ—ÉxÀ·‡ÀÖr5ÀõÞ_Á µsÁ‡—Á*bÁ:>ÀÁJ‹ÁYøoÁiÕhÁy²rÁˆŠ ÁãWÁv°™Áií¾Á\TYÁLƒÁ<²Á,âÎÁÁ BÎÀúá ÀÛ<{À»—ëÀ›óZÀx’À9]“¿ô/X¿jPø=åý?ˆå<@ö @Cyz@~t@¡8‰@ÀÕE@àxÆAOAå­A»|A/u[A?'AGÈgAJ‘öANb­AQò0AKï‘A<‹pA-:A¬A@ë@ý€H@Þmp@¿f@ n@v@Dü@µL?jc>Qp¿S,¿ætèÀ1’ÿÀpPÀ—dqÀ¶ÅŠÀÖIÀõÝÁ ¸‚Á‚}Á*M†Á:\ÁI÷[ÁYѶÁi¬Áy‡%Á„nHÁ{!‡Ám¯3Á`†ÈÁS ÁG*¬Á:ãÁ+Œ¨ÁÉÁ úÒÀøY(Àؼ¬À¹ /À™ƒ²ÀsÎlÀ4¿ê… ¿WÞ >pð?‘¶S@_D@Gã^@ƒ³¼@£uÉ@Ã7Ö@âùãA]øA>A!$A0ý¯A@ãúAPÎ.AY„£A] ”AZιAKTJA;ÛãA,c~Aé/A mô@ûáv@ÜÞ@½Úº@ž×@¦È@AŸZ@|:?Š‚A=à‹ý¿\á„¿êêCÀ3ÇŽÀrj²À˜†ëÀ·Ø}À×: ÀöµÆÁ ÝÁÖ×Á*•lÁ:YÁJ$wÁY÷+ÁiÏ›ÁyCÁ€°cÁs9¬ÁePËÁW²*ÁJi®Á=^CÁ0ÈWÁ$ÊPÁ4GÁ 5Àõ ÆÀÕãÀ¶uÀ—Ào26À0'%¿áÌä¿F–ý>Y*\?™{·@ é@Kc@…8@¤ñÂ@Ä«g@äe AYAì A!Á2A1— AAp AQLAa*AeÞAWWAJ(”>ô?¢w­@Bª@OJÎ@‡)y@¦­‹@Æ1õ@å¿tA¯›A…(A"[hA21©ABéAQÞ)Aa´jA`ê×`?±_^@N @Uúô@ŠU@©¬©@É@èœ!A åAÅ•A#~DA36óABóœAQ××A`P¦A]@&AO]—AA½ A4h7A'N AºüA Ôœ@øœ@ÙW@º0¯@›=@xö@9Ûš?øHé?z®Ç<{8¿r‘¿ô<£À5ÈßÀp©À•¦ZÀ³Ú5ÀÒUWÀïhcÁGHÁA¦ÁÜoÁ+÷ÞÁ9TÁG]–ÁU{—ÁcÔ<Áo­ÜÁ`~ŠÁQfþÁBrùÁ3­%Á%!ÁÚÁìÉÀö¶“ÀÜq:ÀÃÙ®À­­ÐÀšhBÀ{À³{AM2!A[æ0AZp>ALEXA>Q^A0´+A#ƒRAÇ«A ¤-@÷N@Ù§@¼`Q@Ÿ"ä@€ÔÏ@D¿Ñ@( ?š9z>• Ø¿âv¿Âø©ÀVþÀ[(3ÀŒöSÀ¬’‚ÀÉ8ØÀ߸BÀ÷­ŸÁ£eÁ Á#ȱÁ1ÒÏÁ@*ãÁNÁ9Á]‰ƒÁk€aÁ\ÁL­çÁ=]OÁ.)5ÁÁE‰Á´†Àç JÀËTÈÀ°2À—ÆõÀíBÀ^1„À6߯¿íÐ’¿\·=Æ‹Ì?d†‰?ÙF @&š`@bãK@)@¯V(@Îü@éÕAÞÛAo·At§A+ÑAA:q§AIG’AXG&AX-¨AIâ¦A;ÝrA."A gAoAê4@îØv@ϲÙ@°Û4@’‚å@iÌ1@0²?ùYN?¤¢™?C̾§áH¿©?®ÀIÈÀSûŽÀˆõ‹Àœ9”À²Á>ÀËËÀå%ÛÁCRÁ9,Á Á+0Á: ²ÁIÙÁX?”ÁhJ3ÁX¦ØÁIrÁ9ÿÁ)úYÁ†Á 1wÀø´ÀÚ, À¼è¿À ŽôÀ„éoÀWDÔÀ+‘ÀB¿èÓ¿ ¿¡Ä>ÖR?±£j@>k@Xz@‹ïò@«ä¥@ÄÉê@ßÙ@ú ÒA ÎAv¤A()A6ÿÛAEì2ATù¥AVÞ¹AHc A:&ùA,:SA£xAT!Aް@éµÔ@Éãø@ª#k@Š€@V'@“?¶™ ? ’½½ç}¿9㻿Âx"ÀÀÀ:JÀ^sÎÀ…Ë ÀžžÀ¹€¨ÀÕ{±ÀòBÁ¼GÁ°{Á%Ö³Á5"bÁDŠÊÁT §ÁeðWÁV"1ÁF[ÀÁ6›ŒÁ&âRÁ2WÁ’ûÀð+ÀÑFÀ²}À”$€Àm/ÆÀ3ÆÓ¿ýEÞ¿£‰ì¿X쟿mà¾aŒ?äß?ºéÞ@"@[?ñ@ˆ#v@ ˜ñ@ºÀ@ÖI@òl†A‡IA'¿A% ~A4TACH]ARuAVtíAGñ“A9§{A+eA?"APÀA¡ê@ç×L@ÇÝA@§åz@‡ñ’@P 4@Sá?¢"R>“Ï¿‚Ö¿Õe¿§¯z¿ËÉÀ’‘À1²<ÀejÀޱyÀ«ƒSÀÉ~Àç/BÁädÁW‚Á!æÁ1ˆ¬ÁA:¡ÁPølÁd®tÁTÈgÁDæ|Á5µÁ%'îÁJwÁrÀëH¢ÀË̘À¬&À…åÀ\{žÀ p¿Åö]¿!z>=¿%ü>½G™?+øl?–Xˆ?óä«@ž}@GnÚ@w¦r@–š›@²sg@Ï!Á@ìAÆyA´JA"ÂÚA1ÐA@ì‘AP'ïAVb­AG†ßA8°£A)ýVAZÙA à¨@ý)…@àþ¦@ÅP–@©Ä±@‹¤Š@Yžš@Ò¼?Í3Ä?N¢é>I‘@¾1ü¾´¢¿.¿°:@À@¢ÀJ‘»ÀƒaöÀ¢DÀÁÍÀàWKÀÿÂÃÁ§ƒÁy,Á/S?Á?3£ÁOåÁd‰FÁT âÁD¼ Á4؆Á$õ&ÁáÁ31Àê» ÀËÀ«&À‹êÊÀYmÀ3È¿ºñ(¿óë>¼hà?g²?ºhí?’ÌÏ?ªëÃ?÷Ûà@-˜v@d^¨@Ži!@«uÌ@É%Ø@æÞ½AK‹ANÆA ~íA/È%A?DANbÞATwBAEéiA7£A(3†A>ªA cV@÷s@Ú]:@½~P@¡@„ç@Ræ˜@+Ø?ã>S?ª…í?ŠÙI?SD5?O–½ù•¿2l¿þ^†À>¨À|ÇÜÀîÿÀ½¡CÀÝiåÀý@yÁãÁ€XÁ.mÚÁ>X~ÁNE³Áe2@ÁUXÁEøÁ5®ŽÁ%ÞŸÁ«ÁTÀíK[ÀÎ À¯'À}OÀdffÀ(:¿à7z¿v-S¾3X?R7Z?@{±>«CÎ?Dw[?ÆÛ»@´@U†@ˆ,@¥ô@ÃÒÜ@áØëA¨AJ³AA-͉A=,¥AL¢AM•%A?ÑA1¿ÃA#CAßkA_Ë@ïñÞ@Ó/¾@¶Jý@™/Í@x‘e@?n0@n6?£G©?±9>ý?º?ˆËj?.´œ¾b󯿌ù{À~À?MýÀ~3¼ÀžÅ.À¾<®ÀÝÌÌÀýxúÁ›ðÁîÁ.l®Á>ZþÁNL ÁfíƒÁW4ÁG„æÁ7ßwÁ(FÁ¼cÁ JòÀóü‰ÀÕ¡À·i;À™f/Àt ìÀ6†¿ñ2®¿kó¹=5ÔÜ?>¬J=ª¾Þ@ó>Ñ#ü?§h…@†Å@IÄJ@‚£D@ ±Ç@¾ÄŽ@Üï£@ûaqA ûcAM±A+ŸzA:îÁAE©¬ACœ?A8 –A*ÅäAúAâÿAÆg@å0 @È¥7@¬\à@ûŸ@fûï@.1&?éÁ´?p-n=†PO¾£–> æ¢?1š¾SW3¿˜Œ½À éÊÀHÓÎÀƒ×GÀ£ZïÀÂéˆÀâFÁ²¶ÁZúÁ ™Á/ÚëÁ?ªÌÁO‚Ái›—ÁYÎ(ÁJ¯Á:M1Á*žqÁý-Á ]£À÷ŸÀØyjÀ¹ªfÀ›%<ÀzAsÀ=c/Àz¿—v´¾é–¾*¦W¿ÿˆ¿9e>C0À?Ž&K@3J@=óÎ@y·d@šï‚@¹æ@×C¸@õ| A ·aA¥ŒA'WA3iIA5ã.A49«A-ĺA";ÁAXûAì1@ôzù@عä@¼Ñ¼@ xx@„@Q“¼=¿Vß¿º)K¿·fa¿›™¼¿µTŸ¿ü2À..¯ÀdúÀŽ£xÀ¬ 0ÀÊ8ÒÀèâ\ÁÞÁE^Á"Á3Á2?mÁAϤÁQpµÁm' Á]¤äÁN5øÁ>ÌÛÁ/aÃÁ ½ÁéùÁôÛÀæŽûÀÊ^À®rTÀ“ªðÀuaöÀGç;À"GÀ GGÀË”À¢þ¿–•+¾ˆ·?%øN?É*°@ÈÑ@YRI@‰>Ï@¥Ðç@Â8Ï@Þaø@ù¦òAãAMIA¬HAdAV¶AûEA `ÆA~Ò@ìÏõ@Ô7 @º<@ t¿@…ê8@U‰Ä@T?ÏÍ/?B0%½ÅoÛ¿u/¿è3´À•£À ßÀ’-À-áÉÀU¹™À‚F Àœ{›À·Ë[ÀÔNBÀñ±*ÁÇ[ÁÄ@Á%ñŽÁ5CÁD°6ÁT,âÁprpÁa*iÁQýËÁBÖ Á3›Á$ÛËÁ.âÁΦÀó¬|ÀØ—ÇÀ¾^œÀ¦íÀtÛÀwj(ÀYJÀEš¤ÀBBÀ딿º¦§¿ *>²€?žâÕ@Dh@@ýæ@xdT@˜X©@³«µ@Î<²@åf¦@÷eAv'A/A§"A¿ñAïv@û^Ó@êçà@ס@ÀÉ£@¨§#@×Ì@k4@7N+@ŽX?˜¸í>°¦s¿£¤¿­‡À 5ÀCÙrÀKiVÀRÄÀe30À‚v¡À–ÔŸÀ®ÀǦþÀâsnÀþ48Á `ÁÓäÁ*ŽÁ9~:ÁH˜VÁWÏîÁt¾ÉÁe¿ýÁVäõÁHëÁ9jÏÁ+IÁãÁ)úÁØÖÀéÜ(ÀÑ ùÀºÏ•À¦óUÀ•ÚâÀ‰l¡À?·Àd«|À+ „¿å*)¿gź¼ìê?Xr½?ÚÐ:@$µ^@[CÝ@ˆD¯@¢G¼@¹+5@ÌKa@ÚF¦@ä’¸@ë<$@íç"@ìk™@çSÀ@Þ9 @у•@¿+û@«'Å@”ÓÌ@ziI@Iv¶@~M?Æ ?:ýнÇxW¿opۿ㱉À(\À^EÀ….ÂÀ‡ï¨ÀÏ÷ÀœïÀ®¹|ÀÃ(kÀÚ\©Àó‹ÌÁÍ.Áb>Á"PkÁ0€PÁ>ùŽÁM¬ºÁ\Œ˜ÁyþÔÁkQ¾Á\»ZÁNI1Á@òÁ20ÛÁ$­µÁõÁ ÄíÀýn†Àæ·ÀÒ"3ÀÀycÀ±‰5À§rÀ™såÀz•]ÀBpKÀ V‹¿§0±¾å‚:>Ò? l÷@!@9æ>@kóå@ŒïÉ@ "@°t@¼Ë}@Æ(¶@Ì¡@ΛÆ@ÍVô@È¢ˆ@À§d@µðì@¦7¯@“r@~yÑ@Qç@#è·?åìH?ƒ‹4>lç¿BO¿²¢¨Àu2ÀC‚÷Ày1 À—˜>À§(À­¯ÌÀ¸ÒfÀÈM…ÀÚ‡éÀï“qÁi×ÁÏÁ¢¶Á)úœÁ7§$ÁEšvÁSØÁbQVÁ€ ÷Áq±·ÁctÁUv^ÁGÄïÁ:o=Á-qMÁ Î&ÁÎÁ ‡eÀþ ÂÀë€îÀÛoÀÎnÀÁ¥áÀ¥y¤À‰o$À\wÀ&V¿àßC¿jt½z¹?>þæ?ÅÇ@YR@@˜ù@i7Œ@…´p@“éj@Ÿ7¹@§£¶@­@¯h,@®05@©»l@¢¤‚@™8I@‹šÆ@túî@Pu@&¬Õ?õ¯–?šÐI>çŸÐ¾žýῌ?¿ò$À,ô…ÀaeÀ‹!sÀ¥µdÀÀ@~ÀÌ0ÏÀÕ¾Àã`Àó¶!Á_»Á±Á¨óÁ%ÚäÁ2— Á?Ë ÁMD‚Á[¡Ái ‹Áƒu‚ÁxØ`ÁkùÁ]wLÁPDÔÁCxeÁ6í:Á*ï~Á¥ïÁ,YÁ ‹Á&ÐÀ÷“¹ÀéðtÀÎ!ËÀ²Õ6À˜ôÀz ³ÀDÒÁÀF ¿µX¡¿|J>$Ê}?k?Φ0@lÔ@50­@T ó@m¿m@F,@‰À@é @6@ v@Šùn@„ÑV@wÝí@`R@@ßM@™­?ò¼?Ø:?A¾†Ö¿cbÀ¿Ò¥À¼ªÀLùÀ€GãÀšUÀ´ZÀÎÔ^Àé1áÀóo`Àÿ‰2Á+LÁÏÁ¢5Á$n\Á/óŠÁ<)ÁHžÁU­uÁcŠÁp£ÿÁ‡.ZÁ€WüÁsKàÁf=ÁY‹žÁMGÁA'nÁ5ÖˆÁ+EMÁ!‡Á·ÈÁù„Á s"À÷¥¯ÀÜvÀÁÂpÀ§ ³ÀŒ”ãÀd¬‹À1|³¿ûNO¿˜½ª¾é1J>q›g?hp?ºÓ?ýrC@”*@3,@F³Æ@THÉ@]®x@b ù@_Åm@Xèc@M• @<ÔX@'j@ g?Ô;?)?8½ÕÍ»¿IÉ¿¾AÀnHÀ>-ÀoÕ"À¥ÃÀª/œÀÃãÑÀÝâ½Àø5.ÁÒÁ<7ÁµÁä*Á%ñzÁ/ü³Á:Ø7ÁFG|ÁREÁ^ÃÄÁk¯ ÁxöÁ‹AÜÁ„¡UÁ|S&Áo¸¨ÁcZbÁWu)ÁL»ÁAsbÁ7Á.ŠëÁ&J¥Á&Á‚“ÁdÀë«°ÀÑ}À·FÝÀ1øÀƒºÀT…-À#O\¿ëxÁ¿‘Óe¾ôæ¿=Ë2Ð?"ž(?Ä“?ÄÉ?ñº@ º•@¯@Š×@#«ì@!¥I@Žþ@ç¨@¤s?Úíc?§ l?TQÖ>¬1¾`j›¿OS¿¹¤À³ÉÀ5MTÀdcXÀ‰Â¤À¢Y_À»íÀÔ/#ÀíÖØÁÇ~ÁéxÁýBÁ#;Á*xÞÁ2ÖŠÁ<1éÁFgÁQCvÁ\©JÁh™AÁtÿîÁ€æÁ©çÁ‰?âÁ‚ü{Áy­{ÁmÒÁbzEÁW¹BÁM§@ÁD_-Á;áŠÁ2¾{Á%\›Á!cÁ êÀûñ0ÀáÏöÀÈâÀ®ÜÌÀ•¦/À{H¶ÀMð­À öʿ¿ f«¿5)¾TO¸>tØ-?KÄ?r²¸?š_«?³µ¦?Ã-?Ë5ä?Ǥ ?¼Eé?§ |?‹Œ?JÑ5>Ó÷Ö¼Wò¾¾ød¤¿{þœ¿Ç¬cÀ 2À2 –À_G½À…ПÀDøÀ´žjÀ̬WÀåzdÀþg¿Á û8ÁÄ©Á%¾Á1»öÁ8pÿÁ@3BÁHï•ÁR†ÚÁ\ÖÄÁg±IÁsºÁ~úìÁ…¦zÁ”^óÁŽ$Áˆ²Á‚ÈÁxázÁnAÁcÛdÁZXÓÁQ ³ÁG’kÁ:d7Á-/,Á ¼Á2¢Á.ÂÀó=~ÀÚQpÀÁ[,À©¶À’ ÀxðØÀO*À'f²Àž ¿Äæ|¿‡¸À¿'T ¾•°‡<ŸAè>†Ìµ>åš?1ê?¡Ú?ÝŸ?Üm>µ$I>jܾ¨ý¾ïgÙ¿`U±¿©Þa¿ç7öÀ!¬À9Š­À_‹À„šEÀšäŒÀ±cÀÈ=¸À߉ÍÀ÷A+ÁöÁ_oÁ!µÁ-ÙµÁ:¼ÁF·—ÁMðWÁV\Á_#ÎÁhêÁsF‹Á~'aÁ„ÆlÁгgÁ™Q[Á“;˜ÁV¸Á‡©Á‚9ûÁz"ûÁpquÁgsmÁ\§ÁOj;ÁBI1Á5Z"Á(lçÁ‚Á+éÁºòÀí>¿ÀÕœÆÀ¾UÃÀ¨xkÀ“$À~½ÀYñ²À6ãÚÀœð¿øÎ$¿Å@½¿™ðú¿iFº¿0eA¿:Y¾ÌП¾®P'¾´O¾àúJ¿³¿J׫¿‡X6¿°.F¿à÷2À }À)nÀH2ÀjoÒÀ‡Ò À›,eÀ° XÀÆIÀÜ5yÀó)ÉÁ85Á ÌÁYÝÁ)¦Á6&ÃÁBîÌÁOÓ>Á[û¾Ác§ÈÁl)æÁukÕÁQÛÁ„ÜkÁŠR4ÁÏÁžtdÁ˜“Á’å%Áp®Áˆ<ŸÁƒP Á}j-Áq¦ÐÁdŒ‡ÁWt–ÁJ°Á=¼¼Á1&5Á$¹ÁRÂÁ ^‰Á‹ÿÀê!ôÀÔaÞÀ¾À²À« §À˜¢À†uwÀlë%ÀO4µÀ4´À1(À°¿í´¿Ñ!q¿»›®¿®Ë¿§‘m¿¨+Ë¿±æ¿Æ8N¿Ý¥¿ÿhÙÀpPÀ(ü%ÀC)›À_vfÀ}ˆûÀŽ{dÀ cöÀ²ß‹ÀÆøÐÀÛ‰¨ÀñG Á³hÁÁ®ÚÁ&uüÁ2© Á>øÁK]‘ÁX ŸÁdð¯ÁqCÁyˆ¬Á(Á…àñÁŠÝ~ÁÁ•“gÁ£Ò>Áž$Á˜«)Á“mlÁŽqeÁ‰¾7Áƒ[ôÁy©¯Ál¬æÁ_æÁS9MÁF½BÁ:G©Á-ü„Á"³ÁPgÁ û”Á<Àê¢ïÀÖlÐÀÄ%À±±¸À À‘¹¹ÀƒˆÀm ÆÀV+!ÀBn(À1û;À$üìÀ Ào²ÀK™À.kÀÆÑÀ>‘À*”0À:l€ÀK÷œÀcGÀz¼DÀŠ•ZÀ˜â§À¨Í\À¹VÀË_ìÀÝÉõÀò;Á^·Á7èÁL:Á$›>Á088Á;ë‡ÁGôèÁTJüÁ`ºÁmMÁz%ËÁƒ€JÁ‡ÄÁŒDàÁ‘Á–@Á›XœÁ©eRÁ£è¤Áž¢±Á™™Á”…ÁøËÁ‡|EÁËÁugjÁh½’Á\ScÁOîÀÁC¶ÑÁ7î-Á,-zÁ Ú|ÁÁ CÁvÀï! ÀÜóäÀË#‘À»§¨À¬×¡ÀŸÀ’ǵÀˆ$¥À},nÀm$üÀaN»ÀWfOÀQ5HÀME1ÀNƒHÀRš•À[´*ÀfŽ+Àtô5À‚çBÀŽAÀ™bCÀ¥´fÀ³œ ÀÂ\ôÀÒóÀäfÀõïáÁ^ÏÁ˜kÁø¨Á#ÎxÁ.å Á:&ÏÁĘÁQvVÁ]Y¿Ái¬ƒÁvrÁL:Á‡¯òÁŽkÁ’ÐØÁ—hŸÁœ=°Á¡N“Á¯(ŒÁ©ÛŒÁ¤Æ]ÁŸ)zÁ˜¦ñÁ’)yÁ‹»fÁ…rPÁ~EBÁqé9Áe›áÁYzÁMÊöÁB ÿÁ6°×Á+ì Á!5Áã×Á ªÁáÀö™ÀåeÎÀÖ‰ÒÀÈ ˆÀ»!‘À¯|™À¥ Àœ%«À”[)ÀŽ®ýÀ‰ÄíÀ†ü-À„¬ÆÀ…ÞNÀ‡ŒuÀŒ »À‘P­À—~EÀŸýƒÀªzuÀµ·‡ÀÁl?ÀÎV_ÀÜÕ~À삚ÀývâÁ\[ÁAÁÞÁÁ$1òÁ.–?Á9uøÁD%ÁOÕ¹Á[uBÁg5ÁræòÁ)¯Á…Å1Á‹û‹Á’UÁ˜¹âÁæÐÁ¢bÁ§pÁµSÁ¯øÁ©ÙcÁ£XÜÁœÚÁ–tHÁ-]Á‰è'Áƒ¿ˆÁ{KÁo>äÁc•ÁWè˜ÁLˆÎÁAº»Á7%žÁ,ÂÁ"³µÁƒìÁŒXÁáxÁ Àñq«Àä•À×GåÀÌ×À EÀ¹µÀ²z‹À¬‡KÀ§ùjÀ¥/ZÀ£0VÀ£ÝÃÀ¥¢À©¸hÀ¯ eÀ´ÔÀ½ ·ÀƲ¥ÀÒ …ÀÝš2Àé—õÀ÷Ë7ÁOõÁ ‚ýÁÉÁ®³Á%ÎÁ/yÙÁ9äèÁDXÁO*ôÁZA"Áe†SÁq$½Á|°ŽÁ„ ZÁGw}ÁPëëÁZýÆÁei–Áoè’Áz±Á‚Ñ‘ÁˆtÁŽ:Á”xÁ™á8ÁŸï§Á¦rÁ¬2úÁ²røÁ¸ÔTÁêÝÁ½?ÜÁ¶îÁ°«ÁªxtÁ¤[’ÁžTÁ˜QÁ’w.ÁŒÀþÁ‡#ÜÁ£iÁx™ÁÁn:ŠÁcÿÞÁZ$ÝÁPùºÁH#šÁ?x+Á7\ýÁ/¾ÓÁ(Š‘Á"tÁ®„ÁR.ÁNÄÁ ¾¨Á QÁ©EÁûÁ&wÀÿ’ÀþÊ Àþü¼Á).ÁØíÁ!bÁÁ T=ÁŠdÁ),Á©jÁÑcÁ%LìÁ,lÁ3n0Á;µÁC÷ÁKEÛÁSì1Á]ÿÁf¡tÁpÀMÁ{* Á‚Ù-Áˆ=©Á­ùÁ“S2Á™JÁžÝ®Á¤¼áÁªÈEÁ°ågÁ·ÙÁ½9ùÁÈÁÁÈHÁ»‘æÁµcÁ¯E0Á©=vÁ£A»ÁgúÁ—»XÁ’(]ÁŒž‰Á‡8Á‚(ÁyÚ…ÁoèñÁfŠ»Á]zÁT·—ÁL‚ÊÁD³íÁ=ªÁ6[Á/èøÁ)ØýÁ$¨†Á³¼Án©ÁÏÅÁ·ÁÁ$nÁä\ÁrÀÁ›aÁa9ÁØ>Á,™Áù Á!RÁ(ÑÁ! Á&¿¼Á,.Á3Á9ÉöÁ@õ£ÁHS5ÁP&¿ÁX) Á`ŠäÁic[Ár½ÝÁ|YcÁƒA~ÁˆuCÁ¾VÁ“$WÁ˜™/Áž>»Á£ößÁ©¹èÁ¯˜¢Áµ Á»¶ÁÁϬÁ̬@ÁÆ|†ÁÀM´Áº.ìÁ´+'Á®;¤Á¨e>Á¢±+ÁïÁ—š%Á’(iÁŒéXÁ‡ÜºÁ‚Ý=Á|, ÁsãÁj€Áa¯ÁYÎYÁQýYÁJÂfÁD5ŽÁ=ìÁ8IÁ3©Á.4bÁ*)žÁ&–jÁ#vèÁ öBÁ',ÁFÁ…Á¸hÁ™DÁî#Á"7÷Á$رÁ(Á+È‘Á0-Á5çÁ:|ÜÁ@äyÁG|ÔÁNqQÁU¾§Á]KhÁeA«ÁmRWÁuÙ@ÁÁ„1sÁ‰ ”ÁŽ$ÆÁ“Y™Á˜«,ÁžcÁ£ŒUÁ©1ÈÁ®á‚Á´œžÁº{wÁÀÁÆfÁÑhlÁË8¿ÁÅ>Á¿”Á¹; Á³h­Á­©Á¨ Á¢±Á"”Á—Ú÷Á’Ì‚ÁÊÝÁˆîÁ„SÍÁŠ(Ávê"ÁnÎ=ÁfïêÁ_€‚ÁX˜½ÁR¡ÁL=ÁF_-ÁAw­Á<ÚÙÁ8ä×Á5Y¡Á2exÁ/ëŸÁ.<—Á-#«Á,œÇÁ,ßCÁ-ÈèÁ/ âÁ1EœÁ3ÆÁ6ßÁ:‚ÏÁ>ÀóÁCjÐÁHŠÁN·^ÁU;ôÁ\ÙÁc/°Áj™Ár5!Áz'jÁ@ÜÁ… VÁŠ9¯ÁŽôÖÁ“éuÁ™ÁžI5Á£œ‰Á©8Á®Á´%rÁ¹ÓÝÁ¿‹ÇÁÅiãÁËi¥ÁÖ+sÁПÁÊ­ÁÄ?Á¾nYÁ¸¥˜Á²ÿFÁ­†!Á¨Á¢ÐxÁ»\Á˜º¥Á“Í7Á#§ÁŠuÁ†)<Áý»Á{êNÁtT…ÁmJ ÁfkÁ`!~ÁZ!~ÁTËÁOëKÁKŽ6ÁG &ÁD/+ÁA`LÁ>ãùÁ=[Á,Á@S@ÁBÒsÁE¾mÁIXjÁMOÑÁQÐøÁV®ãÁ\Ác+Ái™õÁpœÒÁxöÁaÁƒ‚Á‡ŸRÁ‹îÁT»Á”ò`Á™ÅÙÁžÒ“Á¤òÁ©;Á®MÁ³öÁ¹rÖÁ¿ÁÄÇÁÊ~‘ÁÐZÂÁÝœ Á×{ŽÁÑ{PÁË—ÉÁŽCÁ¿ü‹ÁºfIÁ´ý—Á¯±fÁª}yÁ¥|´Á º ÁœÁ—ˆ~Á“(Á;Á‰ wÁ‚5tÁvÓÛÁi‹Á\ž‰ÁP$ÁCÑ-Á7êRÁ,ŸùÁ"!ÁˆÁ¿Á%Á£(Àù3=Àñ¼·ÀíÍ›Àì›ÀîÚ¸Àô’Àü€\ÁÒ6Á ’~Á³ÁµXÁ%y¦Á0§Á;p”ÁG6GÁS`hÁ`ÁmŒÁz#UÁƒË&Áˆ”‡ÁŒ‹ÚÁÎyÁ•WÁš$»ÁžðäÁ£©3Á¨˜Á­¨ªÁ²¿¿Á¸÷Á½saÁÃÝÁÈÛ¤ÁÎÀßÁؘŸÁÒZûÁÌ42ÁÆ/6ÁÀJCÁºpÁ´­àÁ¯ÓÁ©´Á¤lµÁŸ@nÁšLÁ•š+ÁýnÁŒx7Áˆ4oÁ„>¿Á|ðxÁoÁae ÁSù‡ÁFïÈÁ:IÄÁ-ë½Á"$†Áø`Á ¦FÁÀõ°úÀç¨ÀÜP€ÀÔcÞÀÏ®ðÀÎ¥&ÀÐÕ ÀÖèIÀßàyÀì*®ÀúÍÁ%”Á°Á#UÁ%yÔÁ1V‰Á=ŽKÁJLéÁWEMÁdˆ Ár˜Á|·QÁ‚$ßÁ†C³ÁŠ®RÁfâÁ“ÏPÁ˜v0ÁXÆÁ¢g<Á§zâÁ¬µ Á²#êÁ·ÂØÁ½ŽÁÃsðÁÉg-ÁÓ›qÁÍZ“ÁÇ~ÁÀíâÁºãšÁ´ü½Á¯"ßÁ©_lÁ£ËÂÁžkYÁ™)¥Á”QÁ!xÁŠz|Á…àÍÁrdÁz¢jÁrÐëÁgÜhÁYßµÁL&yÁ>¦íÁ1}tÁ$¬ïÁ6öÁ x¿Ái{Àît·ÀÜBXÀ̲ñÀÀgDÀ·2µÀ²CÀ°­ºÀ³8ÔÀ¹ÛòÀÃâ¯ÀÑ:9Àái Àôg:Ák»Á°ÒÁŸ:Á'å‘Á4¶øÁA½[ÁO$˜Á\áèÁh­ÁoÐZÁw·šÁ€­Á„Y—ÁˆµÁGzÁ’ŸÁ—%ÍÁœ7YÁ¡iÀÁ¦Ô‘Á¬rÜÁ²?¦Á¸')Á¾9ÁÄ*6ÁοÁÈ`·Á†Á»Ý=Áµ¨ÐÁ¯˜™Á©¯7Á£ÕÉÁž=Á˜,Á“#¾Áè—ÁˆÏÝÁƒüDÁ~µ™Áu™¹ÁlôóÁdøûÁ]1:ÁRötÁDñ@Á7æÁ)‰ÇÁ>hÁOœÁÒ3ÀíòÇÀ×½–ÀÄ<ŒÀ²ÛãÀ¤ýˆÀšºÀ”È2À’ÜÀ•øEÀ[œÀ¨›ìÀ·¡™ÀÉ¢ÖÀÝù‘Àô"HÁö…ÁNUÁEßÁ,yÁ:ÛÁGÉLÁT>³Á[ Ábr­Áj,²Ár˜—Á{G³Á‚,Á†á+Á‹ä_ÁõZÁ–5Á›…\Á¡"ìÁ¦ñÉÁ¬Ú“Á²ÑÕÁ¸åÛÁ¿"ÁÊ+ÁÃwÁ½(1Á¶ÞzÁ°Ÿ1Áªe<Á¤NSÁža²Á˜ˆÅÁ’ÃaÁ3.Á‡Ý{Á‚ªÁ{<Áq²åÁhvºÁ_ˆ}ÁW)¿ÁOUàÁGÆ2Á>GÚÁ0*ûÁ"O¹Á¨-Á)ÍÀô,DÀÛa@ÀÃxÀ­±óÀšz…ÀŠÒ…À~ÂÀo#TÀk–ÍÀrhÀ„ˆÀŽaÀŸ2JÀ³)5ÀÉ,ÀáÀúÈÁ xÁT–Á%Á2ãÞÁ?S ÁE­ÁLÝÛÁT[­Á\…UÁe-Ám÷—ÁwTÁ€¢ñÁ…³ìÁŠÕ™Á6TÁ•Ó Á›£øÁ¡Ž6Á§ˆ=Á­£Á³ãïÁº:˜ÁÅ Á¾ñÁ¸c|Á±òIÁ« xÁ¥a$ÁŸ#vÁ™ðÁ“.Á;ÖÁ‡uïÁçñÁy1ÜÁnÝÁdäsÁ[pzÁRE‹ÁI•TÁAÉÁ9½ïÁ2§Á)ô"ÁÉ]Á ÈiÁ Àäþ ÀÊ–kÀ±A—À™†vÀ„3rÀcÇ&ÀH8À7‰À2jmÀ9ŸRÀMhÿÀjíDÀˆfÀž“sÀ¶cJÀÏ×÷Àê£Á•XÁS©Á)ÂÁ*deÁ0›ŸÁ7MÏÁ>¸UÁF„ÁO…ÁWÄüÁ`ïþÁjÃÁtäûÁ]Á„ç‚ÁŠƒ:ÁV7Á–B Áœ?žÁ¢b#Á¨¬ Á¯‰Áµ`ÁÁ¯Áºs Á³ÔµÁ­;âÁ¦¿„Á cêÁš#Á“ãèÁ¼©Á‡Æ«ÁïÁxRÁm;WÁb­4ÁXoÁN”âÁE0øÁ<-Á3Å8Á+ß\Á$cËÁÑ€ÁþhÁÍpÀó8Àפ>À¼9‡À¡‘jÀ‡êœÀ_þÂÀ6ŠyÀ‡^Àb®¿óFÀdíÀ&À>a ÀiC\ÀŒ ÆÀ¦GÀÀ·ÀÜ{À÷¯œÁ ¤áÁ±wÁ´&Á!ø*Á)#ƒÁ0¦†Á8÷îÁA§ ÁJ—ÑÁTBHÁ^bÁhŒ˜Ás1ðÁ~gÁ…ŠÁŠöbÁø1Á—#ƒÁuÁ£Ï…Áª-ŒÁ°Ÿ„Á¼ÓðÁ¶ÀÁ¯W¡Á¨¸Á¢ãÁ›’Á•)ßÁŽå Áˆ¥ËÁ‚uÆÁxòrÁmDŸÁa¹ƒÁV©VÁL.vÁB èÁ8FÁÁ.õlÁ&7#Á gÁTIÁiVÁ ÁÀè’iÀÌDvÀ°tÀ”==Àr’wÀ>‡‚ÀõŠ¿Ï7F¿—~¿ƒÎ,¿˜\¿ÛÅÙÀv’ÀFe§ÀzlÚÀ˜6ÉÀ³¡XÀÏ@6ÀêÌIÁZ†ÁÕWÁ ü%Á’èÁýýÁ"ä¢Á+ŒsÁ4PÁ=Ç¿ÁGßBÁRáÁ\•–ÁgÇÉÁsuíÁV)Á…²EÁ‹ç¾Á’?Á˜›ÆÁžýÐÁ¥|SÁ¬ìÁ¸ÌMÁ±Ü+Á«?Á¤@×Á›µÁ–üÎÁf[Á‰òõÁƒ¦ÿÁzÏnÁnaWÁbXŽÁV«—ÁK"ÓÁ@ÅÁ5·ÓÁ+¶HÁ!ú¨ÁÒïÁhlÁhßÁ!ÀõQ™Àé&UÀÝ!ÀÂÆðÀ¦ëÀ‰ƒÕÀZ£À#U&¿Ý¦Ú¿~¢¾Ñí¾5àé¾÷¹¿Œ´¿¿ê À*7aÀ`1ÀÀ‹ÃéÀ§UIÀÃ1ˆÀÙé Àä¿ZÀð7 Àü’ÎÁiËÁ ô.ÁqÜÁ!YÁ'WÁ1\eÁ;~mÁEú4ÁQ(ÞÁ\ÛÁhÀ¯Át܈Á€¯‹Á‡ uÁiÁ“ÓÁš_³Á¡ ¿Á§ÊLÁ´ÜºÁ­ãÿÁ¦ïžÁ èÁ™2wÁ’£Á‹à,Á…BnÁ}ÿÁpÑæÁdSTÁWÛÓÁKÀ)Á@ Á4ŽŸÁ)‘ÁL»ÁaµÁ ±•ÁØöÀõ=£ÀåíÀ؈âÀËùÚÀÀm/À´>ˆÀûÒÀ/ÀH¸JÀÉÍ¿¯Òq¿«#>r]?)› >ú¿"Æ¿·z8À•:ÀI´À€= Àœ&¸À±tžÀ¼oÀÆË ÀÒÈÀß¿bÀî‡NÀþ®ŠÁaÁõKÁÙŽÁ$ûÑÁ/`-Á:Š]ÁF@zÁR,²Á^Y…ÁjóˆÁw®¶Á‚6ÉÁˆ®fÁK)Á–ÑÁœÏÿÁ£ªuÁ±ÍÁª¹Á¢ýòÁœ(Á•üÁŽ.wÁ‡i#Á€ÃËÁtIÒÁg$KÁZXðÁM×;ÁA\Á5)ÑÁ){)ÁýøÁJÁñÞÀþMÀêù³ÀÚ>ÀÉêcÀ»ø»À¯çÀ£¤=À—´HÀ‹¢›Às¬À9R(¿þY¿¿Œwj¾P®?.Y?º;O?!qJ¾dÌÇ¿‰W‹¿öDÍÀ2¸BÀk{À‰;”À“©)Àž:,À©=0ÀµYÙÀÃl[ÀÒ—­Àã×”ÀõS ÁVèÁy{ÁÈÁ#ìqÁ/¦hÁ;š½ÁGÝ2ÁT‹LÁaI‡Án“Á{#$Á„@TÁ‹Á‘áVÁ˜Å6ÁŸ³+Á­“ÀÁ¦anÁŸ:ÏÁ˜$Á‘ OÁŠ*TÁƒ7tÁxºÁkOyÁ^}ÁPÖ¼ÁCç©Á7["Á*à Á–fÁäEÁrjÀù,ÉÀå8®ÀÑq/À¾õ©À®„cÀŸi!À’EÿÀ†gNÀv~ßÀ_÷ÀD QÀ" ¶¿ÜrŠ¿Q•w=˜nw?{rÄ?ò{Ù?}É|> À´¿8Ȳ¿Ê±gÀzxÀB âÀWWÀkö/À€tÀ‹ÛýÀ˜}À§ÐÀ·¤ŒÀÉžÀÛ©ÈÀïïÁ2ýÁ ObÁ Á% ¥Á1i~Á>%ÿÁJäXÁWÃÜÁdý Ár$Á€8Á†ûãÁâSÁ”ÕíÁ›Í¹Áª-¬Á¢ë©Á›µ/Á”‚ ÁY×Á†CdÁ~†óÁp›Áb¼ÚÁU#`ÁG×ÈÁ:šÁ-Á ß ÁcˆÁ`ÀøÍÀáÚ¯ÀÌ`ñÀ¸ À¤ÖõÀ“nêÀƒ7DÀkxñÀRgIÀ=XÀ'G.À ðh¿àß"¿–O½¾êÂ>Åœu?¤"@ ÒÐ?«>÷×¾²ü¹¿{i¿ÜR±ÀKgÀ[eÀ0yÅÀE·À]oÀxQ‡À‹‚øÀœËéÀ®¼^ÀÂìµÀ×EnÀíftÁt³Á€„Á*Á'ÀÏÁ4€©ÁA‰ZÁNò·Á\ž;ÁjewÁx-jÁƒ£Á‰úSÁ‘eÁ˜›Á¦éÁŸ—GÁ˜NÇÁ‘ ™Á‰ÖŸÁ‚£$ÁvñÓÁhÆÁZÍNÁLádÁ?šÁ1ŸïÁ$`¡Á*LÁ bñÀûÎ Àâþ´ÀËx"À´æ€ÀŸµ{À‹ãDÀq^`ÀPeÀ2°ÕÀ¢ÇÀ"‚¿Üôk¿®‡¿p5%¾âÞ>2?`Õ–?×6”@"Bœ?Ýü*?qn£>_5B¾Ê_¿[O¿›xê¿Âš>¿êbÀ 82À#YkÀ?®ýÀaN¡À‚ "À•ìýÀª6=ÀÀ.À×¼*ÀïóÁGÁ[ Á+»Á+i‰Á9 tÁFÓ(ÁT›ÁbeÁpMßÁ~]Á†G&Án8Á”¦Á£ÎÁœnžÁ•ÍÁ¼RÁ†oüÁ~[ÁoðÁa‰'ÁS0ÁE†Á7±Á)'ÛÁuŠÁ(ÁêuÀçÕBÀÎÕÀ¶ìÀž[ßÀˆJÀfDÀ>tNÀ‘V¿ô¬¿¿¹¿’,G¿SŒe¾ú"H½ó:Ä>­F?^Æ>?¿ü@ Ä$@?<…@K•?ÈHö?pz>ß•<òÂo¾°\¿ù°¿f¯º¿ ž7¿Õ²CÀ ^À+—WÀQàÀzqmÀ’÷Àª•ÀÂôÀÜp/ÀõìâÁïÊÁpDÁ#6Á1«Á>ËEÁL§ªÁZºmÁhôlÁwNÁ‚Û[ÁŠ*Á‘Z7Á ó˜Á™s@Á‘ÿÁŠš†Áƒ>¬ÁwÇ¢Ái$ÀÁZÁL2üÁ=ÌÁ/nÁ!L¨ÁZ!Ár¾ÀïáoÀÕaŒÀ»VÀ¡ÜÀ‰ËÀb¨…À6P´À Á¿Ë_I¿ˆB2¿*S¾k¡å=¦Ìã>¼'??5UÉ?g+?ËOá@ @4|4@cÕ@:æF@yÕ?ÜÄÿ?¥iÌ?në?=>®oÕ<€U¾³g¿GC¿§VÊ¿ïÌ1À w„ÀK×ÀzôÒÀ–À¯¥ÑÀÉ+žÀã¶ùÀÿ0®Á a›Á,6Á)Á7aÁE_:ÁSÁsÁb%’ÁpœhÁ¬Á†Ú¹ÁŽ9±Áž%jÁ–¨·Á2¥Á‡°eÁ€3¦ÁqÁbÕ'ÁTsÁEmÅÁ6ÞÅÁ(taÁ 9Á ¬Àû*ÀßAYÀÕSÀ¨ðÉÀŽvjÀiÆÀ8VÎÀÛ¥¿¹%§¿M¸Ä¾o×*>ˆÌî?.3Î?}¾[?¡Ü¼?Åf?ò‹:@“)@7(æ@]ú÷@„å¹@f'P@Bÿ•@#Ù@ 4¸?ë´l?Ʊv?£´Â?qŸ? ¤=…¬q¾ò¤¿Œû6¿â<À ÌøÀR˜ÞÀ‚ÛrÀœ­çÀ·øãÀÓ…ÀïLÁjÈÁ0Á!ÐáÁ04ÎÁ>˜¼ÁM·Á[†gÁj+ŽÁxó#ÁƒÞÔÁ‹FBÁ›œ#Á“ÿ•ÁŒm Á„çPÁzÞ0ÁkÞäÁ\ÚÑÁMïÁ?,÷Á0uBÁ!½ÔÁ »Á±DÀì”9ÀÏÕFÀ³½èÀ—ÎñÀy:ÀD¾ÀÔ¿½¿<½5<ç?9¦?B\?Èñ?ôM?@ Àˆ@Õ¨@-7‹@E[Ç@c K@ƒtÁ@—‹@‹D-@tô@Z«@CHÑ@0E@ @ Gë?í)¢?¸ Y?g€G>›âp¾¶m¿J;¿ò!bÀ,"'Àa‚/ÀŒJtÀ§Ü,ÀÜÙÀßéÀÀüçÁ ¨}Á Á)päÁ7òÆÁF¨`ÁUräÁd=hÁs vÁ€úÁˆ~ºÁ™1ÝÁ‘•VÁ‰øÁ‚YÒÁuzBÁfXUÁWV…ÁH\þÁ9XÁ*XÉÁ„ÇÁ ÍÀü*»ÀÞÏôÀÁÜPÀ¥ÀˆTRÀX§À ¼˜¿ÖJs¿Y]½–é,?+8q?­jf?øÅg@#º@4Tè@Er@Sw«@c€Î@v]Û@‡zÊ@–Q¯@§À:@£ÁÑ@”ª@ˆšr@|¤@j¢Ü@Z¹ú@IŸ@0vJ@¸Û?Úìn?‡b>œâ¾üD"¿¦&ÛÀ %PÀA<Àx×À˜î;Àµ‰ÑÀÒI`Àï µÁåÁgõÁ#+8Á1÷fÁ@ÃÈÁO™ÝÁ^–™Ámµ$Á|ïnÁ††Á–ý±ÁF‹Á‡—8ÁâAÁp§¼Áak`ÁR/ÁBõ_Á3ØeÁ$ÛÁÖ™ÁÒÀïÀÛÀÒIÄÀ´ÜÀ—uyÀt¬.À;À½­¿“¤ª¾’\­? œÔ?ª0ñ@¢ý@/ä@Rá¤@n‹Ó@€Šƒ@†ú7@‚ @•5X@Ÿ:ñ@¬Dü@»Ä¬@¼…M@¯¬@£û{@š¡@’Âß@‹qp@ôG@i‘£@GÑ@Ñ?Úa?h-=‰HÍ¿K!È¿ÕisÀ#ê\À]þÀ‹BƒÀ¨ÙÀÄØ¾ÀâNÀÿ™Á™õÁgfÁ,L÷Á;aÁJ”õÁYÓßÁijÁxg/ÁƒÞ±Á•®ÁV™Á…’ƒÁ{¯Ál!îÁ\·…ÁMb[Á>#Á.æ¾ÁªbÁpˆÁ[/Àä¬4ÀÆ¢$À¨˜®ÀŠûÀ[_À H²¿ËLü¿0 w>Qq?ŠÒ?÷%@.õý@^hï@ƒX†@“I„@ž^g@¥.f@ª­I@°ØF@¹D@Äj™@ÒE^@Õ3Í@ɤ@¿ÇÜ@·tW@°Î%@©Õx@ŸAÊ@£Ó@x ƒ@FÎÞ@ |?µôÏ? Oq¾¯ç￞[ÈÀwNÀBÍÀ|L¨À›kÀ¹öÀÖ¢îÀôFòÁ )¸ÁUÁ'‚ÖÁ6ºúÁEþ½ÁUZQÁdÌnÁtOÝÁîÉÁ“FñÁ‹|ÁƒµÁwå6Áh] ÁXÔàÁILµÁ9Ä¥Á*I7ÁèŸÁ ¦žÀøÓ|ÀÚYÁÀ»åÂÀÆÀwyÀCbÎÀmˆ¿™y¾8±?$"¸?Ƨ@ëÎ@SéD@„r¤@›Óö@®¬ñ@¼*ž@ÃuÓ@È@†@Íh@Ô€u@Þ‡e@êÉ@îÍ£@ãúë@ÛÚ@Ôüî@Ïh@Çìò@»Ž@©7ö@Á÷@hqg@0‡+?ï/?z¢=§o¿S €¿Ýá÷À)±fÀdëÀóÀ­é+ÀÌ=Àê–0Áx‚Á¶>Á#wÁ2–mÁB)uÁQÅpÁaaíÁpþiÁ€MsÁ‘ÉÁ‰ìîÁ‚ Átw­ÁdÏÅÁU/ÉÁE™µÁ6ÜÁ&ŠAÁ"Á~¨Àïó—ÀÑ 0À²x¿À“ÿŸÀk þÀ.¿ãwà¿V=˃?„5Ë?ùé@7ªï@rÅ@•`F@°ü"@Çò@Ù€Ÿ@á£À@æoz@ê¬#@ðÐ÷@ù¶dAv“Aä‘Aä@øÂé@òÞý@í{”@æHo@Ö3@ºô3@žöš@‚–@Kʘ@·_?°»>òRá¾å’2¿°0qÀ€kÀOø1À†gºÀ¤Ó[ÀÃ[¡Àâ<°Á¦ËÁ2<ÁÃÁ/XÁ>ð ÁNLÁ^7ÐÁmíµÁ}¬ÞÁ•Áˆ²ÊÁ€Ð ÁqÞ—Áb?ÁR_çÁB Á2â:Á#)‚Á|¶ÁãèÀèÁ(ÀÉÀÀª¾üÀ‹®ÀY ÚÀNk¿¼¸V¿›u>Ü•ß?°(‰@^@P  @…È@£&˜@À~'@ÜЃ@ò©xAArÑAI;Aø÷A ì­A'Aã9As(A #wAœ®AAÕ>@åNX@ÈÁ¾@¬Á@ @dS[@)Êá?ÝÆ?Nˆ~¾vÑ¿‰š¿À3À?%ÌÀ}K¨À¸ÂÀ¼Ë°ÀÛßÉÀúö&Á DÁÂvÁ,~ÞÁ§Á.DýÁqáÁŸƒÀý eÀÞòÀ¾ž¦ÀŸ$¤ÀUDÀ@a?Àm;¿„ò…½b D?lþy?óq@7Ý9@v,Î@š>2@¸ëÌ@×f@õÀÑA Û AÕ²A!G'A"É-A$æÈA( A,^ÇA/¨›A+ï¤A)FÔA'hAAc A ÿr@ü°~@ßHu@ÁZ1@£.@„b^@K;U@ ±î?ŸË>^/¿4Ù¿Øv€À+rÊÀjªSÀ”ðïÀ´Œ³ÀÔ(xÀóÆ×Á ²ùÁ‚‡Á)U,Á9-QÁI }ÁXæƒÁhÅfÁx¨yÁ‹TçÁ„KÖÁzÀÌÁkâ«Á\ÞÁL+JÁA:÷ A>hèA:û.A8’ÊA/ÏA DLA9ÚA M@å*@Æ?d@§P@ˆKó@RP@Þ?ª£ó>µ^пé¿Íº•À&¥ÀeiÃÀ’nîÀ²(úÀÑãÀñÁ«¨ÁˆÙÁ(fÁ8DÇÁH(ÁXcÁgû˜ÁwézÁ‡öCÁ€õGÁsÎ ÁeÓàÁX!•ÁJ”uÁ:¼ÉÁ*å#ÁÔÁ E™Àö÷À×býÀ·ÎâÀ˜/ÜÀq 9À1¸¹¿äÊs¿LO>CUÒ?–ÌÂ@ —J@IÈ2@„|@¤@ï—@ãZ~A‰VAi“A!:ÒA1A@É#ACqÒAF ÅAIŶAMYAJ,EA@­ A1#¡A!šYAA@æB;@Ç(C@§ì}@ˆ¬p@RØÄ@tä?¬8±>¼U9¿ u¿ÌàÀ%—õÀd¿áÀ‘ùÀ±ª³ÀÑ_kÀñ"Áf—ÁIÁ(/ÜÁ8—ÁHQÁWê ÁgÒÚÁw½<ÁƒÖëÁyê,Álm‹Á_ ’ÁQA¶ÁCm´Á5ØöÁ(‹Á¹^Á õWÀô>ÎÀÔ’îÀ´íuÀ•JúÀkPþÀ, ¿ÙŽ¡¿68Ö>«­?¢@K@O–œ@‡pÕ@§[@Æ»â@æhA `AêuA"ÊíA2«ÈABŒ¤ARj×AU:.AX´…A\oUAO>ÏA?ÂüA0CÒA Á÷A@A¾?@äxÇ@Åa@¦H@‡)½@P¹@Ó¨?¦ÂH>§e¿' ^¿ÐøòÀ'taÀflIÀ’¾áÀ²K´ÀÑÙäÀñ}Áš>Á|ÜÁ(d-Á8LXÁH4‚ÁX¬ÁfˆýÁt»Á€¨ÁqúeÁdÑÁV\ÁHó÷Á;ÓÇÁ/.Á!‡ÁéÏÁrÀðr&ÀѦÀ±“%À’#¥ÀehIÀ&‰H¿ÏY"¿"ü%>´ L?«„¸@@TCÂ@‰Â:@©b”@Éí@èŸÔA˜AðÞA#É„A3¦HACƒAS_ÍAc;¼AgÃA]¶×AN6XA>µØA/5YA¯¨A*ùA© @âMº@ÃA@¤1@…q@Kôé@ ¡ ?ž>†´¿6‹¿Ø\À*ìyÀiª¢À”`yÀ³ìáÀÓyIÀó _Á RQÁ!·Á'ÓiÁ6W:ÁDY‡ÁRkÁ`¾åÁoµÁyuöÁjÝ\Á\v©ÁNLPÁ@kÁ2ßÕÁ%_Á¿ÝÁ –âÀÿµcÀä†]ÀÉt*À¬˜xÀ£À]ùÀmß¿¿¥ˆ¿³›>ç~.?·G@­@YŒ_@Œ5ž@«›O@Ëê@ê—AœAÙlA$¤,A4núAD9ÇATáAcÜ@Ah2zAZÞAAMƒÉA=ùA.sØAîiA^3@ÿ¤ø@àšC@Á“Ø@¢Y@ƒŽr@H¬N@ ;ñ?—âa>Vè¿D•c¿ßg À.P0ÀmùÀ–„Àµ¡¼ÀÒDÀî¬ZÁ¥FÁ PÁ"”jÁ0°(Á>ÝhÁMÿÁ[Y¿Ái³\Ás›Ád¦ÀÁUÕÁG2Á8ÇèÁ*¤ÁÙšÁjÁc Àì/ÀÕ†²À¾À¢*`À…mÐÀNH‘ÀÝ¿©ØE¾¸â·?Š^?Èá$@"?·@`KÌ@rŽ@®È=@Îà@ívAgÜA".A%åàA5ªAEnLAU2ƒAdïxAd‡fAVóùAI»A<à˜A.‡AùºAuÌ@ÿèu@àË·@Á²’@¢· @ƒ°ñ@Hèñ@ c,?—Û«>[ó¿Bb¿Ýù_À+ÐÀf¿ºÀŽý€ÀªÚ^ÀÇ‹ÀåDÁù?Á¥'ÁnÐÁ*¡ÛÁ8F¤ÁFE²ÁT0ÁcEÁnmmÁ_5ŸÁPÛÁA"Á2AqÁ#ŒÚÁ:ÁþÁÀò°LÀØC•À¿EõÀ¨Œ¥À”PÀz4'À=÷¹¿þÛm¿ƒú°½¶,Þ?Wrh?äÆ@.vk@kÆ#@”ݽ@³¼r@Ò‘¶@ñ–AeäAýA'»ÉA6p§ADK,ARrÞA`Ù+Aa’yASÕãAF\ÇA98yA*Ø"A…7A K£@ú-\@Ûý·@¾e3@¡·È@†Œ@RdË@Ò?¯í>ÜE¿pV¿»³IÀsÞÀQVyÀ…¾‰À£cVÀÀÑßÀÜW“ÀôÁ'`ÁœÁ"†óÁ0Ì$Á?V¥ÁN‚Á\ÒÊÁj4NÁZ±QÁKA¸Á;êHÁ,±rÁ Á¹ßÀÿظÀâÙ/ÀÆÁøÀ«ûÉÀ’jÀw/”ÀPSÀ2`ê¿öj+¿qù=¾ ?|•"?ï¡û@0צ@ka‘@“õW@²Ô@Ò L@ñi©AgæAZvA#ÆgA1ŸÏA?ÎøANB4A\ì&A_ZÍAQ}†AC̓A6e.A'ÁAÖAAk@ñš@Òéá@´[D@•Ý4@p[@7c|@z“?­$—? ª¾Ðœï¿­0À6\ÀL'Àƒ*æÀ˜»rÀ¯ZÀÇÆûÀâËÀý™£Á Á¤(Á*]‘Á9EÁHWêÁWŒïÁfÿÌÁWE7ÁG’£Á7ì™Á(WzÁØsÁ vûÀô|xÀÖtŽÀ¸±‘À›“©À± ÀKWŠÀ¹\¿õw¨¿ÆPW¿Ý¡¾h¦?* 6?Ì.@"4u@`<6@@®î8@ÎqÙ@îA¯A©OA«ÀA-êdAiS›>þ¸³?Iy ?¦En@®é@9‹@i¿Ó@‹„ô@¥ê@¿ßÈ@Û›^@÷í8A g‡AA'âyA6¿2AE¸7ATÇXA\8MAM`ÕA>¹4A0*–A!ÄAu˜AAû@íPà@Î0¤@¯`à@ìô@eï@,‹Ü?ïü?ˆ°>Óà =m¸½¾Lòö¿´,¿¤·%À¦£ÀB·äÀçÀŸÀ¾‡(ÀÞ„ÀýÈ`Á½òÁ™ÂÁ.xØÁ>\`ÁNCQÁc1íÁS9ˆÁCBaÁ3LÎÁ#YEÁhkÁy!Àç ÀÇ9“À§_íÀ‡“×ÀO˜úÀ ’¿¡ š¾9O?&„¿?®6"?Ù¡×?Û#Ù?øè:@àê@K߀@'@šö!@·A`@ÔA@ñe¬AŽMAxvA%U„A4TæACy$ARª.AX AIØßA;pA-‘A¢¹AeA‚@æÁ@É‚z@­Io@‘Áo@n:Q@<Ëm@h…?ß¾I?Ÿ¦?v?=Wí=Æó0¿\Ÿä¿í…À6x+Àv'ÊÀšúÀºçyÀÚÖšÀúÆÉÁ [ÕÁT„Á-M`Á=F^ÁM?uÁdlÁTÁD&úÁ4<Á$U,Ás¸Á™œÀé“«ÀÊ€ÀªÀ‡À‹¼äÀZ.µÀ<¿ÆÁ¿;¥¶<šmÆ?qÌV?ƒù†?VfÈ?£úÉ?ÿT@5Oõ@mx0@“dç@°¡7@Î;ì@ëϼAÙÅAÞçA"èbA23AAI:APŽyAQ#*AC{ôA5ºA'{ØABøA Ï@úâ@ÝŠ»@Á×@¤oº@‡çt@Wv·@ n¥?ÛÐ?‡ÙB?\ë¹??X‡­½Hô&¿s%)¿ô4—À8ÅÀx±À›ÛêÀ»ºÀÛ¡¦ÀûÁ ³ðÁŸFÁ-TÁ=~6ÁMqqÁeÃ=ÁUóÒÁF,4Á6nhÁ&½8ÁÁ’'ÀðMAÀÑ EÀ±ŸnÀ’sÀfçÍÀ(9™¿Ô;¹¿/ϰ>K?a½H>N±‘=1¬?Lä?Ö¸@%@_D±@ @ªš€@ÈmQ@æD2A"ýA7ÉA ^ÜA/{A>—.AHt¾AF¨‚A;’A.töA!³A&bA@îCÄ@Òm×@¶S÷@š/@|ŽÍ@D Î@ \x?¦X>ß)Ľ£¦^>ѯ?]î{½M<¿_Ä¿þX›À=ÚtÀ|ùÀ À¼ðåÀÜ€8Àü+óÁ õÁ×Á-ºÁ=œÀÁM{Ág ÁW4¾ÁGf9Á7 EÁ'åNÁ3ÐÁ~>Àño]ÀÑûôÀ²¶»À“ýÀh«=À+5¼¿á,M¿_¯¾ ¡ç=)§É¿J…¾¿#Q?þ ?¹8ž@Gÿ@Rµ@†“…@¤(þ@ÁÝ@ßÀ;@ý¹©A {AA*k×A5øA8ÒõA7rcA1TA%ÉìAGA Ô@ý$¥@ážù@Æ$@ª!å@ŽmÊ@eÒe@.„"?í¸z?z7=̶q¿F½¾æ¯Ì½Ö‰3¾º›,¿”ßÊÀóãÀBü?À€W…ÀŸS_À¾jÙÀÝÄiÀýGžÁsSÁL•Á.,ÙÁ>œÁMóÁhS(ÁX•âÁHã(Á9=§Á)¥^Á+Á ˆ}Àö(ÀדÀ¸ö&Àš¡¤ÀzBEÀBi¶À ŽÌ¿¾†4¿{Ç׿h«ø¿¦þH¿„/>œj©?›ôú@Û×@C%v@}p­@œa@¹yÜ@ÖzÝ@òäÁAk+AoYA!nRA&å±A)8ŽA'þùA#ýqA=AvAÈ@íl‚@ÓRˆ@¸u@A7@Á°@LÂr@ÿt?½ñ?õn¾xk(¿ŽF¿­¯¥¿‹•¿šç²¿ßâÀ ò’ÀWuxÀˆdÖÀ¦JÀÄ„|ÀãCÁÈÁ¤«Á F`Á/÷ÀÁ?­šÁOfîÁj²OÁ[ ªÁK "Á<2AÁ,Ñ»ÁÁP Àþ¢|ÀáâÀõ7À§8üÀŒ;&ÀdÎ=À6‰˜À‚¿øëe¿ò n¿âwö¿]E=rsY¿°E¿½/ŸÀÑÀÚ¡À ÅÀ"5ÀH¬ÒÀxîyÀ–·jÀ².ªÀÎ×9ÀìHÁ{Á<ÁÁ#†–Á2ðHÁBrÁRŽÁn<Á^ÊçÁOŽŽÁ@fsÁ1V…Á"lŽÁ¼LÁ<‚ÀíåÜÀÒ:OÀ·í{ÀžÀ‡ÅçÀhNûÀJñòÀ:9À8<Àö¿“HŒ¾„¯?" ?ÂÂ0@zØ@Pù(@„I@Ÿ‚Ð@º…@Ôj@ëtž@üœ«Ac±A%‚A ÁA 'A?ÄAMw@ñÐ-@ÞÀ¹@ÈÀò@°÷à@˜šÍ@~“@I½Ì@u?ÀSù?(gX¾=Å´¿ƒÃ…¿ïØÓÀ.›iÀD\ÀHFëÀ[v¥Ày-À‘+†À¨¤;ÀÂh¹ÀÝVŽÀùÁ ×7ÁkÜÁ(=CÁ7A”ÁFm@ÁU·æÁrŽ€Ác…YÁT–-ÁEÅZÁ7¡Á(µÖÁkÊÁ eÀý­ÀãÏÄÀÊØ@À³æ£À ÀnEÀƒ±Àx‰ÐÀQ0Àè‹¿¾tP¿ù|>‰‘?Úv?üÀÂ@4Uû@jGË@¡@¨*x@¿=@Ñ”2@àKæ@êÛ@ñŸo@ôÛ{@ó@ƒ@îla@å¸E@×~t@Æv¼@²à]@=,@…¾ @[E@)?ì*‡?„;ƒ>Röf¿÷뿹ôüÀí¬ÀHаÀ~³³Àƒ’À‹&ÙÀ˜;À©CãÀ¾áÀÕ:ÕÀîy[Á†ÁÂÁ ¡Á.L¢Á<Õ¼ÁK—ÁZ…RÁwñSÁi8®ÁZ§ÁL-³Á=ëéÁ/׋Á"ÁɶÁ À÷k9ÀàxÀËø÷Àºy\À«ý–À¡=™Àï×ÀgÛˆÀ/Ãà¿îôV¿‚ž\¾6Mõ?(œc?¿#µ@~z@HT@xú&@“Á@¦Y@¶œ@Ã@Ìü@Òó­@Õ¬I@ÔRñ@ÏëÚ@È3{@¼*ú@¬Ê^@›`ý@‡-8@c~’@5œŒ@ ý?¨Ó?¹¾Œm7¿‹j¿ôûÓÀ/Z€Àdr.ÀiÀ£99À©dÙÀ´ÓhÀÃÀÕû®ÀêëPÁoÁ uÁ‡+Á'íÁ5’2ÁC‘!ÁQÙsÁ`]%Á~pÁo­fÁapÏÁScÁE‡ÕÁ8"Á*ê"ÁTNÁäÁ¢"ÀøX#Àåü=ÀÖ‚ÀÉ‚†À¸6ÜÀœ>ËÀ€•ÀJxHÀÎ}¿¾Tì¿'aÿ>+áv?vöÀ?â—à@!Þ@N@u·@‹•Ž@š(m@¥×…@®[r@³æ%@¶¨É@µiO@±F@ª‚-@ŸÍN@‘îš@‚iÜ@`l@8û7@ yo?¿å¡?AÝ—¼!!m¿H¿¿Ê`ûÀ CÀLòÊÀ€ÎÀ›+›ÀµåöÀÈ.õÀÒ,–ÀßX@Àï»fÁ`½Á ögÁüÁ#ÊÁ0£Á=äÞÁKVsÁYÁg++Á‚~¾ÁvñÁiÕÁ[h°ÁN‚ÁA(DÁ4± Á(ŽKÁüÁ~?ÁðäÁ)ÀòÃÀÀà—ÌÀÅ0À©õ ÀŽÇïÀh8ØÀ3•ó¿þuã¿•àɾÀÌ>Ö1w?‘z?ë¨*@gñ@Be@a,t@zãG@ˆ h@H@•ß@—χ@–‡o@’¢¹@Œqû@ƒ#é@m ÿ@OÅö@0Mî@ áÚ?ƹ»?\ $>׿@¿«IÀmÀ91;Àl‰ËÀãÀªkTÀÄ®êÀßôÀðdÀü±ÁaìÁ ÁÍ Á"€Á.ªÁ:/ÞÁFÛ8ÁSîtÁaF$ÁnÚ[Á†PÁ~éöÁqlçÁdB¾ÁWzéÁK*Á? Á3šSÁ(åOÁhÁTWÁ—+ÁÒWÀîuVÀÓKwÀ¸²tÀž7þÀ„B#ÀTAÔÀ!¿Ý&.¿t(ý¾i%D>ðé?So?×|@ AF@(sX@@Û4@U.›@c Ü@lŸ°@qì“@o÷ß@h4"@\Ç^@K‘?@4  @§·?öðO?µn#?UlÕ>Qcɾü8g¿˜´¼¿ö°ÇÀ*N°À[ÍêÀ†Ä À P§À¹åÀÔÞÀîJÁH+Á ±GÁd¬ÁX¥Á$X…Á.FÃÁ98ÁDýÁP ÊÁ]&ÿÁjÁwSÑÁŠpÚÁƒÅÏÁz…qÁmÜKÁa‘bÁU“ÁJ"§Á?YêÁ5VÑÁ,;ØÁ$(”Áb%Á Û±Àý?ÝÀâÎ_ÀȇÀ®¶8À”¡ûÀw<×ÀEuÀ/Á¿ÌSv¿gñÿ¾½°>ª¸?_ÌC?«Ë@?áP @ÿ:@ðï@&•C@/÷@4œ@2ýí@+‹@ ªÆ@w¦?ö?Ãú7?‹\Ý?’g=–À{¿Ї¿’ûo¿ë÷;À"=ÀQ0iÀÉÀ˜VQÀ±*Àʃ“ÀäDÀýÔÁ þOÁ,²Á!™Á)Á1nþÁ:®¬ÁDÉgÁO¢9Á[ÊÁgŽÁs>Á€%´ÁŽßWÁˆkÌÁ‚$NÁx ôÁl+Á`¯ÜÁU×ÍÁK­þÁBMÊÁ9Õ·Á.OÁ Å>ÁšÁw>Àòÿ•ÀÙ*LÀ¿“ÂÀ¦¹2ÀèÀÀla,À=iÀÙ"¿Îxο„E5¾ìa,<Ór*>õ6ã?^jØ?˜ŽS?º>V?ÔR?ä&‚?ëׄ?ì ?ÞŒž?È ?¨x¨?‚iÏ?&Š>kðÖ¾fH¿7#¿£¿ïXÀ  ºÀLeôÀx­ÚÀ“~ÕÀªÊÌÀà oÀÛ¸ôÀô©ÖÁ9Áþ—Á óUÁ.ËÁ7"ÖÁ>ï‘ÁG™±ÁQ×Á[R6Áf7æÁq­ÈÁ}˜Á„ó¡Á“šÙÁ^¢Á‡HÁV€Áw@Ál\QÁbÇÁX}3ÁO±=ÁCmÁ5Ø"Á(»Áœ¹Áµ¹ÁßeÀê®ÀÑÓÑÀ¹U[À¡­VÀŠ¢ÀiŽÀ>ÅÀî°¿èõF¿¥/¯¿T[ؾÎ3޽=>Œõ?Õ¨?6óq?U6^?cÇõ?bò¡?J£’?a²>Ì!ÿ=û’Ú¾uÁ¿¶¿¿‡ ¬¿ÄÝ$À]*À'®žÀN\8Àw[“À‘[½À§€¢À¾€2ÀÕ±EÀíÑÁÁ,Á¸Á4EÁ)ÔÁ6¡ÁC 'ÁLÅFÁTîIÁ]ÙbÁg†`ÁqßxÁ|ψÁ„ ÁŠ zÁ˜œ4Á’‹˜ÁŒŸXÁ†êÁrÞÁx„9ÁnÁÝÁeÁX|ÁJè'Á=ÓJÁ0Ð4Á$ Á_^Á ñäÀüôÀäÓ®ÀÍBªÀ¶NQÀ ˜ÏÀ‹HÀo|ÀJ¤LÀ&Ò…À©¡¿ÖhW¿¤¡¿p$k¿%%_¾Ï®’¾r£‚½ïE½A昽“–¾He¾¢Oì¿È¿G$¿Ö•¿¾&‘¿ò<þÀèÀ6BÀXãÀ|ΤÀ’7À¦à×À¼… ÀÒ²/À醌Áh®Á ;`Á~Á$éaÁ1q²Á>J×ÁK&ÂÁX/ÂÁb•HÁkNÁt*åÁ~DÁ„8Á‰´=ÁiÐÁÐèÁ—éMÁ’4½ÁŒ¹pÁ‡~WÁ‚‹,ÁzšÁm/2Á`éÁSxÁF0Á9{Á,åÝÁ ”_Á(ñÁ;0Àøü¥ÀáùÛÀÌj‘À·-¶À¢¹ŠÀbÀ|ÇgÀ\À>möÀ#%­À \¿ëëá¿Èп¬¡Ë¿–à«¿ˆy,¿|¥¾¿ƒo|¿ŒQ¿ Ê¿¶B<¿×ŸÅÀ÷6ÀoQÀ/TeÀK[Ài™tÀ…À¥À— ‘À© À½U¸ÀÒåÀç¶·Àýæ¹Á W£Áý!Á!¯ Á-Ý1Á:IRÁF¿©ÁS…òÁ`\äÁmFÆÁx€qÁ€—šÁ…DßÁŠ@=ÁÁ•ÊÁ£4#Á€EÁ˜tÁ’½¨Á»sÁ‡æÁ>ÁusÁhvßÁ[š®ÁO7ÁBq_Á6*6Á)ß½ÁXÁ[OÁÕVÀøWÀãxÀÎCúÀ»dGÀ©`ËÀ˜ ÈÀˆëmÀu@¢ÀZþMÀD/mÀ/ØbÀ†RÀB#À‚ÀÍ׿ø/8¿ûKïÀ11À ¶&ÀëÀ%ïÐÀ9g—ÀPU;Àgƒ&À€…ÞÀ@ÑÀŸO½À°V°ÀÁ©‡ÀÓÿZÀè^ÀýeÂÁ ‰ÆÁ£óÁ Á+§ßÁ7EÐÁC\bÁO¼üÁ\ ÅÁhÍ¢Áu–ñÁ6‹Á‡B¼Á‹¶éÁylÁ•‚ÉÁšÌÁ¨ÌpÁ£JžÁÿeÁ˜ðpÁ’†~Á‹ì…Á…krÁ}Ù'ÁqÁd„ÔÁXiÁKÁÁ?›ÃÁ3Ï€Á(2õÁ¯GÁÜÇÁW(Àù÷HÀæ`ZÀÔ^¡ÀÂôãÀ²¢œÀ£µŸÀ–^ÙÀ‰ŠÙÀ}ˆwÀj^yÀZ—¦ÀM*ÓÀCMÀ<Ð.À9?^À:5ßÀ>:iÀGEÀR\âÀ`QÀqâ·À„1¼Àï†Àœ ÀªtÀ¹„âÀÉÓÀÚûfÀìPAÀÿRLÁ ÈÁvŠÁ@?Á*TñÁ5¶•ÁAPïÁLà²ÁXàwÁe:Áq—nÁ~*¶Á…xºÁ‹ßoÁ’PBÁ–Ý‚Á›±üÁ ÇEÁ®”µÁ©CÁ£ÛåÁ,¶Á–žZÁ$’Á‰³\ÁƒXDÁz ¬Ám CÁawÓÁUjÁI• Á=ùÒÁ2ŽÁ'³Á!ÁØÂÁÆÙÀÿ[¨ÀíñlÀܲ6ÀÍl_À¾þöÀ² gÀ¥É]À›°À’e1ÀŠÇüÀ„xÜÀ5ÀxÒ†Àvg Àw)€ÀzD¸Àx=À†íŒÀIšÀ•Ø£À 0éÀ«ÅjÀ¸_QÀŰWÀÔfÀäPÀôVÁÈ Á ³3ÁgêÁËÁ*<ôÁ5KÁ@ïÁKfÁVñ;Áb€WÁnuÁz»ŒÁƒ‰Á‰ÆìÁ+.Á–˜4Á _Á¢ ãÁ¦íÀÁ´ˆXÁ®‡ÓÁ§ãÜÁ¡_rÁšñÁ”„ÁŽ/âÁ‡éJÁ´ñÁwHEÁk:PÁ_ZgÁSÒªÁHŠ©Á=úÁ2ïiÁ(¢€Á}´Á$ºÁ Q|ÁÀ÷5 ÀèÀÚ¤VÀÍ·-À†ïÀ¸~À¯’›À¨DNÀ¢NŠÀ¤\ÀšËÀ™¤¨À™ÐqÀ›sàÀŸsœÀ¤´ÌÀªìÀ³ÜÀ¼=¨ÀÇ‚ïÀÔ5½ÀárÀï -Àþ›+Á6ºÁmdÁjÁ!YÁ+'âÁ5kÁ@/ÁJÍFÁU¶öÁa”Ál£\Áx7ÿÁ‚¶Áˆ0ëÁŽPŸÁ”‡DÁšæ}Á¡QtÁ§¾3Á­:îÁ¹FÁ²­åÁ¬1§Á¥ÁoÁŸV§Á™ÆÁ’ÍžÁŒŸ‰Á†–Á€†QÁu.DÁi¾ÝÁ^“-ÁS~ÁHÂ.Á>nÁ4YPÁ*»ÄÁ!¤ãÁÝ0Á»žÁñ¥ÁžÉÀöPXÀéËÄÀß4—ÀÕEøÀÍ\ÀÅÎåÀÀ#À»§”À¸ÐÛÀ·¿ÍÀ¸ wÀ¹ãöÀ½ƒÅÀÂt¿ÀÈ´ÀÐ?hÀÙ&ƒÀãsÍÀï³ÀüÒÁWÓÁ ¦hÁ[[ÁV"Á$²—Á-›–Á7xÁ@è¤ÁKMãÁUέÁ`—šÁk}Áv×ÉÁ-äÁ†øcÁŒíÁ“kÁ™ ¨ÁŸO Á¥¦Á¬¼Á²{þÁ½…rÁ·êÁ°•îÁª-ËÁ£èÁ¸=Á—Š!Á‘w Á‹vçÁ…‘ÙÁ®JÁtŒ Ái}cÁ^š³ÁTAÏÁJ8àÁ@hŠÁ78ìÁ.*Á%à8ÁWÁNÁtÇÁ uÁ»ÀûæÀòO¾Àê»ÀãcAÀÝöMÀÙ£ƒÀ×ëÀÕÞÀÖEKÀØS¥ÀÛœfÀàbŒÀæt¹À툩ÀöÁvq¤Á€°×Á†ZZÁŒwÁ‘Õ‰Á—ÈçÁÚlÁ£ñBÁª¸Á°g‹Á¶ÒÁÁÞÁ»l»Áµ¦Á®ÒÆÁ¨£Á¢t»ÁœbÁ–ožÁ–ôÁŠÐYÁ…0<Á`ÝÁt‹ÊÁjÖÁ`qÁV)§ÁLØ¢ÁCµgÁ;Á3Á+2åÁ$ÁO:Á'cÁS^Á fÖÁ×ÙÁ­Á†cÀûÚrÀ÷¡¸ÀõRûÀô uÀô”²Àö¤Àù·¯Àþ…EÁµÁ–0Á ²^ÁbvÁ—„ÁûNÁ ¡åÁ'–äÁ.íØÁ6nÁ>f·ÁF¦¦ÁOriÁXÁÂÁbUeÁl³ÁvêÇÁ€ÁÁ†)¨Á‹¤8Á‘NÁ–ü“Áœ¾äÁ¢°¯Á¨¹EÁ®ÇÁ´ëÁ»3–ÁÆG—Á¿õJÁ¹¿¨Á³Á­eÁ§V3Á¡nÐÁ›œ³Á•ÎøÁ!ÜÁЍ“Á…@hÁ€Áu÷7ÁkùzÁbxYÁYRÁPv½ÁH"÷Á@$«Á8ÄâÁ1Û0Á+@~Á%3ßÁ¼FÁÚuÁ‹7Á¾üÁq«Á á?Á ãÁ ÇFÁ %Á vÁ xxÁ ìsÁXbÁûlÁqÁD…ÁÅŽÁ!¬Á'ÑÓÁ.CðÁ5>Á”Á!ŠgÁh?ÁátÁýÁÚKÁVhÁ´ÀÁ–Á•ÁVhÁã Á#"±Á&ΦÁ+?SÁ/ëéÁ5«{Á<MÁB—àÁIµ4ÁQHCÁX{0Á`5Áh²-Áq]ÁzLÁèÁ†ðÛÁŒ }Á‘VXÁ–¨ÆÁœ SÁ¡‹Á§5YÁ¬âÁ²£cÁ¸Ž·Á¾“£ÁÄœ!ÁÏ¥cÁɃ ÁÃdïÁ½ZøÁ·u¸Á±¡™Á«ÕeÁ¦*DÁ ¤ Á›6PÁ•éÑÁØžÁ‹ÎªÁ†ñzÁ‚GYÁ{wÇÁrÔÏÁjVÁb„’Á[-$ÁT3ÁM‚„ÁGJ¸ÁA´Á<™ÙÁ8ÉÁ3ñyÁ0eÓÁ-d'Á+HÁ)ñÁ'ü–Á'‰ëÁ'ê Á(¦´Á*' Á,7ÞÁ.ÄûÁ1ðÁ5iMÁ9º?Á>mïÁCÃfÁIïçÁPI¼ÁWÈÁ^°ÁfùÁmRˆÁulÚÁ~ÃÁƒ]åÁ‡è¹ÁŒÂƒÁ‘à»Á—ÕÁœHÓÁ¡fÁ¦ü)Á¬~•Á²(cÁ·ÕkÁ½•ÌÁÃ~\ÁÉ„€ÁÔ‡¤ÁÎiäÁÈ`JÁÂy´Á¼¢iÁ¶ÚôÁ±6Á«¬yÁ¦2Á ßçÁ›Ä<Á–·fÁ‘ÒËÁ ôÁˆ„Á„&…ÁÎUÁw´nÁp ØÁhɤÁaÐ,Á[„`ÁUi\ÁPÞÁKÆÁFÅJÁBÃ`Á?AËÁ‘çÁ2{ Á&ÙiÁÝâÁÐÎÁÆÁuÄÀóJ Àèu%ÀàV°ÀÛÆ€ÀÚQõÀÜÚÝÀâÀë=ÒÀöÊ+ÁÅ}Á *Á¬æÁû@Á)ðoÁ5¡ÁA¬ÄÁN*»Á[wÁhEÁpUZÁwc=Á*ÁƒËïÁˆNÁôÁ’{Á—CûÁœV#Á¡¡Á§êÁ¬µ*Á²i^Á¸ Á½À]ÁÊwÁÉn°ÁÓÌAÁÍ“ÞÁÇaÁÁ7©Á»/ÂÁµNãÁ¯ŽÌÁ©ÛÁ¤KˆÁžñaÁ™ÐˆÁ”ÔÁå‡Á‹óÁ†œÁ‚ceÁ|—ÁtÕrÁk‹þÁ]Ë ÁPG–ÁBèPÁ5çQÁ)g]ÁBSÁ’lÁÁTÀùÇÑÀè3)ÀÙÇÀÌÚ1ÀĵÀ¾ªdÀ½T¼À¿ÇÀÅÍùÀÏ®áÀ܇ÍÀ솒Àþ»¼Á #ÁyûÁ $ÕÁ,IÁ8ÝÓÁEáºÁS2Á\FãÁbÝÁj1,ÁrWòÁ{/Á‚EÁ‡6ÁŒc\Á‘ŠÁ–ÉhÁœ6àÁ¡µOÁ§¹Á¬º>Á²rÈÁ¸ ?ÁH´=ÁN½ÓÁUÁ]]ßÁeØ Áo &ÁxÊ0Á€áÁ†ÓÍÁŒÙÁ‘AÎÁ–n€Á›Ô¼Á¡n¯Á§%JÁ¬îƒÁ²Ú Á¸èCÁ¿üÁÊ?•ÁþÀÁ½[GÁ·,Á°æ\Áª¸ÀÁ¤¤íÁž¼ÆÁ˜ÿÁ“QèÁÇRÁˆ{8ÁƒqÎÁ|ýçÁs+¾Áiì ÁaiüÁY2¡ÁQmCÁJ_®ÁBšÁ4¾›Á&ÿYÁt¨Á @íÀÿsÀæbqÀÏ„1Àº¯%À§àœÀ˜ý½ÀhÄÀ†›åÀ„^>À‡PÀ<À›~ÂÀ««ßÀ¾‰TÀÓêêÀë€EÁö…ÁØÁóüÁ)y®Á5²ñÁ;/ÌÁA~<ÁH¿ªÁPÚÌÁYÁÌÁcUýÁmeáÁx ìÁ€ôÁ†‘Á‹(<ÁŠ×Á–#†Á›×åÁ¡¡Á§‘Á­¢ÈÁ³Ò ÁºKÁŶ2Á¿ ñÁ¸•IÁ²'OÁ«ÛÁ¥©8ÁŸ|dÁ™aëÁ“ucÁ¸ŠÁˆìÁ‚ˆçÁz‹½ÁpŽÁf©XÁ\ïØÁSíÁK¡aÁC‚sÁ<+tÁ5ƒ?Á.©1Á ¬ÌÁÑtÁ âÀïÎ ÀÕõïÀ½DÀ¦yBÀ’.FÀ€¸ªÀgb{ÀVŸdÀPg<ÀY&aÀj¨.Àƒ­§À•í…Àª³QÀÁðÀÚUÐÀô7ðÁ]ŒÁüÁ"ºÁ(2ÔÁ-ýTÁ4œÊÁ<>ÏÁDÇ‹ÁN"ÁWÿnÁa¹YÁkv<Áu†¨ÁÅLÁ…@þÁŠØÝÁŠ¢Á–SõÁœG`Á¢^9Á¨“¶Á®âYÁµ9{ÁÁ8!Áº•ùÁ´Á­pÚÁ¦÷*Á  ªÁšl>Á”@‡ÁŽ!Áˆ/{Á‚s=Áy  Án›»Ád+°ÁZ8ŽÁPU;ÁFÊ­Á>îÁ5äÁ.†Á';0Á ®)ÁžÁ ÏÀþ®ÀâfËÀÇwIÀ­lÀÀ”â÷À|¸`ÀU‰ðÀ5{ÅÀ ï“ÀöNÀ#úÀ9“+À\]ÀáöÀ˜(À±WÕÀËnÀæR¤ÁÑËÁÁ2sÁ,Á!#‚Á('ÞÁ05íÁ9DƒÁBªúÁKy=ÁU ÚÁ_3Ái;âÁsîbÁ‘Á…=‡Á‹kÁþ¤Á—ËÁW]Á£©gÁªÁ°qœÁ¼òÕÁ¶(æÁ¯yÁ¨åBÁ¢RÁ›Ë©Á•i†Á/xÁ‰Á‚âÇÁyÖéÁn^þÁc%®ÁX.„ÁMÕÄÁCãÁ:Á0ÄÊÁ(_Á =©Áó¢Áb«Á (FÁ¨ Àóƒ À×F‹À»]ÀŸÚXÀ…¼‡ÀZ ?À-ƒÀ'¯¿Ùü¿Åá4¹À &PÀ3q§À_L¥Àˆð|À£løÀ¾DÀÙÖTÀõnÁ­¤Á™8Á{&ÁËåÁ6NÁ$.öÁ,³¸Á5PÁ>®ûÁHYÁR´ËÁ]ZëÁh‰¶ÁsáBÁwÁ…¶zÁ‹ØÄÁ’kÁ˜p±ÁžÒaÁ¥EÅÁ«Î}Á¸Þ€Á±ûuÁ«!ëÁ¤büÁÂÁ—4ŽÁ¥³ÁŠ6}ÁƒòòÁ{”*ÁoN-ÁcS½ÁWÛœÁL²}ÁAÇ Á7€ Á-ÔÁ#ß4Áë†Á¿5Á ßüÁ&ÀûVhÀð1“Àå<(ÀÎ#wÀ±šFÀ•}hÀs‰rÀ=,”À Þv¿¼:¹¿n2¿5„7¿xÅ¿ÅfÀLŒÀBýÀxSÀ—CÀ²ÁÎÀÎ7*Àߨ Àé©§ÀôŽÁHÁ'#ÁkÁ½†ÁFgÁ(Z@Á2kÁ<0ÜÁFÇ£ÁQõÜÁ]GÿÁhßýÁtÞÁ€˜Á†äyÁ9ÑÁ“¡1ÁšÓÁ °„Á§Y±Á´Æ£Á­à¿Á§ ÈÁ $ãÁ™UÁ’£ÿÁŒÁ……@Á~ÔÁqp…ÁeÁXØ¡ÁLÔßÁA]ÁÁ6CÁ+aêÁ!+¥Á:¸Á ÔÁGÀúT>ÀëìTÀÞá-ÀÓ-8ÀÈšÕÀ½q×À©X¤ÀŒåÔÀ`ý~À(ir¿à«x¿i£ ¾Cg^=å¡{¾}aJ¿uøg¿åÅÀ*…óÀa%¼À‹ÄÀ§NÈÀ·þ/ÀÁ±iÀÌ<À×"“Àä'×ÀñàÁÇUÁ PÚÁÌÁ²ÕÁ%±Á04šÁ;bÁF¯sÁRI%Á^QÁjµ ÁwWÁ‚„Áˆs‡ÁŽú®Á•˜ŸÁœQhÁ£&?Á°èöÁ©ß¦Á¢ë³Áœ üÁ•2øÁŽQHÁ‡æÁ€îÊÁtϬÁg»sÁ[¸ÁN«ÁBd™Á6VDÁ*äëÁÓÁ5Á ÖáÁüùÀðvÀß\tÀÏΗÀÂ~ñÀ¶ ®À«’xÀ¡:ÅÀ”í^À„.èÀOZ…À=O¿´t¾ýÆÞ>¿Cl?mëh>«¿øm¿µ‚VÀ­«ÀJNFÀ€»îÀÒ:ÀšY•À£Å…À®›—À¹ÿ ÀÇ?ÀÕé{ÀæµPÀ÷׌ÁZÁ3gÁ¡îÁ$Î(Á0(Á;²¢ÁGƳÁT?Á`å+Ám¤ßÁz”¥ÁƒÝÁЉ/Á‘T0Á˜9âÁŸ/ÐÁ­S^Á¦#5ÁŸèÁ˜?Á‘HÁŠ:YÁƒZ)Áy×ÁkñÁ^ÄÁQr—ÁD–óÁ84XÁ+ð©Á×ÈÁmèÁ dÀýGuÀéWÀÕÐÏÀÄ«ÉÀ´6×À¦>¼À™(nÀŽˆÀ„ŠŒÀrÕ¾ÀXfrÀ4–IÀÍ©¿z¾3'å?>pÿþ?‡Z3?üØ?‡æH>0$÷¿-”Õ¿·ŸÀ-âÀ‚âÀ+úzÀ=>¡ÀP€QÀfçsÀ€3ÀŽýÅÀŸî½À±e£ÀĵÒÀØý"Àï;KÁßBÁ‡AÁ½ôÁ'[NÁ4 Á@î ÁN4Á[yfÁi_ÁwÖÁ‚yeÁ‰p^ÁkçÁ—~Á¦íÁŸY¾Á˜”ÁÑÕÁ‰CÁ‚\öÁvˆÁh ÁZÍíÁM#âÁ?`Á1ô<Á$õÁà+Á =µÀþ sÀå¶áÀÏÑÀ¹ JÀ£ò¥Àù9Ã?•¨ ?õœ‹@/W@}+?£y=?¯g=ç­Y¾‡¦¯¿¶¿R¿Š{ˆ¿³=æ¿äÕÌÀ3fÀ2I'ÀV¾tÀ}ÅrÀ”ÈÝÀ«Z ÀÂÁ2ÀÛ¢âÀôïÁH_ÁsoÁ!îÁ/¯­Á=›ÚÁKˆBÁYvÁg¹Áuå[Á‚1SÁ‰r Á³åÁ sÁ™òÁ‘£MÁŠ9ÑÁ‚âÁw5êÁh«ÈÁZ"{ÁKš<Á=.yÁ/>Á!*›ÁŒ6ÁÂHÀð–·ÀÖ´éÀ¼º‰À¤'À‹Ê ÀjoÀ>Ü×À- ¿åo•¿£Å¿¿W4{¾þ7×¾e£;Äz˜>Šì)?(q-?”:?ãp€@xÎ@Nú£@'Éf?÷¸[?³m?xöÓ?"óT>¹/v=ñä±¾é¾õY¿hÚQ¿´ê¦¿úÏâÀ$;aÀOKÀ|SÌÀ•£nÀ®¿ÀÈ9ÀáýÔÀüÁ.Á «Áõ/Á'álÁ5ͳÁCÝ•ÁR3jÁ`³eÁo4×Á}¸?Á†.Á’ÄÁ¼4Á–:ªÁŽÃJÁ‡LÃÁ¬vÁpɶÁb åÁSx ÁDíÎÁ6cƒÁ'ÙýÁi˜Á JÞÀû ÀßèÀÄ@RÀ©ÿÀ ¶ÀnGÀ=í‚Àq¿Ë­œ¿}Ýo¾à–R<©‹ˆ>Õ—¯?5Y3?m ø?‘ä"?¶"k?ë{³@@?ÿê@kƒ¶@Q1@+ªí@ ß?éƒn?Ã5?¤Ð?ˆ®j?Ov`>ÛmA½(_·¿ÓU¿•¹B¿éY¸À!óXÀQ+¡ÀÛUÀ›KUÀµ­ÆÀѸÀìMÁ:ÁÁ&ýÁ 3=Á.ˆÁ=ÙÁKŠÁZùÁh¾ÊÁw•ÌÁƒ;'ÁŠ«Á›5Á“˜aÁŒÁ„usÁyð-Ák+Á\,ÁM)äÁ>[”Á/ºµÁ!0Á¥²Á`ÀëKíÀÏ! À³ÉàÀ˜`gÀz–jÀFÿ4ÀW¶¿È¿Ä¿_uÓ¾`k>>»Ì‚?d©m?ª«;?Ñëµ?ï«@ÈD@²c@#=‹@>ƒ¡@`«š@„¶@}²€@\Îu@AÀ™@,P.@:q@1@ø7?Þ„?§JÅ?L{ü>h!ú¾ÑÓk¿%ƿÀ)ïÀ]`ûÀ‰ÜÀ¥lÀÁ(-ÀÝ¥Àù%lÁ êdÁjJÁ'êeÁ6sµÁE0¡ÁTÁbíÁqÌ`Á€^æÁ‡çÁ˜Ä>Á‘'XÁ‰Š¶ÁîÁt¢ãÁesHÁVa¨ÁGoêÁ8ƒ@Á)–§Á´Á qÀúäsÀÝÏÐÀÀ»,À£ÈÈÀ‡¾¨ÀYUÀ!úÉ¿Û'¿i¡¨¾-$?—Ã?“c?Ü/á@ B@$ŠÏ@4}M@>ÌŒ@H¹ý@Vá¤@lE@„éf@–Œ=@–½@‡#@vˆ·@d†B@WnO@KÎW@>t*@)sž@ ùI?ÏÁÀ?€p>–l¾ìyª¿ Y4ÀnùÀ<ŽÅÀs·%À•³PÀ±ïÀα/À뤽ÁRzÁæ Á!®Á0‰ÈÁ?h¿ÁNN_Á]V»Ál~ÂÁ{ÀáÁ…Œ[Á–‹ÂÁŽÓÏÁ‡$>Á~ý$ÁoÂÿÁ`‰ôÁQPòÁBûÁ2éÁ#áñÁöÁ ·Àî2&ÀУ À³hßÀ–T;Àr0À8‘Àö©¿”þ.¾¡?'>û[X?v¾?õŽŠ@!E@DvÁ@_G"@q"Ç@{tó@‚ ”@‡‹w@Nù@œ~´@¬`Y@®‘„@ â@–޽@6S@‰ûª@„“Ë@{àé@b]@@@µm@´?Ú\ ?páa> ¤)¿9%¿ÊʪÀËöÀU À‡—äÀ¤tçÀÁuÀÞľÀüYÆÁ qÁä¿Á*âÓÁ: ÔÁISIÁX®ñÁh ^ÁwgÝÁƒb¸Á”¡BÁŒÝ4Á…+Áz¬^Ák1>Á[É'ÁLxbÁ==­Á.%ÁÌÁ“¤ÁfáÀâÜXÀŧÀ§#ÌÀ‰R­ÀWÜÇÀ±N¿Ç¿&oÿ>X¼/?ˆŽÓ?ñ®%@(I@RT@w1í@ŒØE@—<ä@œ£@ UÐ@¤¾@«å"@¶ Á@ÄÖ@Çòz@»Î‡@³°@­)Ô@¨£@£ˆ@›ô¥@ŒP@s Õ@GŽ{@ÿæ?À(à?#¨¾c¾S¿ŽÚüÀý5À:Ž7ÀtŒ[À—Ä@ÀµYHÀÓ5ÀðߎÁ—¤ÁéÒÁ&F?Á5¢¬ÁDûÙÁTSÁcµ_Ás&UÁR‘Á’Ë,ÁŠÿVÁƒ9TÁvêŠÁgbnÁWÚRÁHRõÁ8ÍPÁ)VqÁùkÁ ºÌÀ÷ˆÀØ“xÀºÀ›ÏøÀ{ë¾À@>[À. ¿’KŒ¾k¢S?-¼‡?ʱ@/@RBº@€õ@“Õa@¥±n@µ¤~@»ç>@¿,¨@®@ÈÅ{@Òû@Þ¡…@â×H@Ø1,@Ð@˺Ë@Ƕ>@ÂÊ@¸Eo@¦ @÷x@n¯@7fE@c?cã>Sw¿1i\¿ÌºåÀ!‡ƒÀ\±”À‹ÿÀªMÀÈúìÀç©Á+ŽÁ‚šÁ!âúÁ1W­Á@ÛõÁPlYÁ`åÁo²‡ÁfSÁ‘EsÁ‰dhÁ‡)Ás\âÁc¶bÁT>ÁD’ºÁ5 Á%†ÊÁ¢Á| ÀíèÀÏÀ°o×À‘þÆÀgõÀ*)„¿Û˜^¿H{1>™k?Šõõ@=@:fJ@t(Û@•K5@¬ž6@½g@ÐR;@Û^y@ÞV®@ás@æt/@îœ8@ùü€@þàm@õ?•@î›/@ꧦ@ç¨@â@Ò¹;@¾­@¢ñB@‡¾@T¿ª@??Ã|¬?ø§¾Ÿ¼Ï¿žZ»À 0…ÀH\À‚¶…À¡dœÀÀ!‘Àß2Àþ@+Á¼tÁY€Á.‡Á=¸ûÁMy¶Á]=ÖÁmöÁ|Æ4ÁûçÁˆ£Á€5_Áp¤8Á`ݶÁQ7ÁAQÇÁ1•_Á!æ8ÁH2Á»MÀælJÀÇaúÀ¨W«À‰GvÀTn?ÀÔ*¿³ä¾èCy>ÿH ?¸†@á0@Só+@‡}G@¤®º@ÁU£@Ö@è¬@úÕÐ@ýµ,@ÿÛ)AL)Aò½A ÛA àOA zÄA’ÄAÖ#A7Y@ÿª@ê/a@ÍùË@±^ú@”¦]@o=@4bß?òTº?v¦·ß|Á/ïÁTbÁŽÕÀÿ’‘ÀàÅÀÀŠ>À¡òÀÒùÀEbÀlÿ’œ£¾2ÚM?KÌ?à2ö@- @iûˆ@’ôe@°ýc@Îͧ@ì*NA.ŒA ¯A›jAtA€A×AwŒAÉA‘ AûlAk5Añ¥A g@ø^@Û3F@¾LX@ ÃÙ@ƒ@IxÈ@ ¡…?GØ>ƒð€¿6Ÿ0¿×ô&À*ÚÀi»^À”ˆ†À´3]ÀÓÞ3Àó‰ Á ™ðÁo\Á)DÈÁ9;ÁHðñÁXÍ<Áh®kÁx“ÁjuÁ…ÿéÁ|&‹ÁlN"Á\uôÁLÆÁ<Å™Á,ížÁTÁ EÀúçJÀÛSîÀ»ÈÕÀœ=»ÀyeDÀ:SÏ¿ö¬Þ¿qd==)2?ƒCa?ÿä‘@=ü¤@{þÐ@@»ŽN@Ùû.@ø/A A¾^AgvA‹A ÛJA#âiA(.A+}UA'ÎEA%vfA$ÞA'›A®ßAï@æ—ô@ÈzÀ@©ì@Šá›@W™M@Ç·?³%‹>Ò\r¿ÈÀ#@ÿÀbuðÀÕpÀ°oéÀЮÀïÑÁΰÁºCÁ'©ºÁ7œÁG—ÁW…úÁg{tÁwqÁ‰£2Á‚´åÁw†åÁiÅ»ÁZ¡]ÁJÈ.Á:ïÚÁ+¬Á?~Á gPÀ÷EÀ×méÀ·½•À˜òÀpÚÀ1‹5¿äw¼¿K²>E©¨?–Ó@ b@IR@„ û@£˜õ@Ãî@â.AÂA1BAp{A+”A.¶A0SÜA3A7ìA:…!A7%iA5WA3R@A$‡ A?šA݆@ì¶ð@Í­ß@®@Žt¼@]«@@m?¾] >ÿÀ´R¢À”›ÀiÆ×À*W ¿ÕÕT¿.å6>œšã?¥­@ Ó@Q?@ˆ9­@§ÔØ@Çr@ç8AV4A½A"×¾A2”¿A>|ÍA?â¦ABn9AF4AI³ AF•xAD;A5;A%u5Aß0A?*@í?B@Î@®åØ@m@_²@ Š1?ÂeÎú*?²õ@/°@WWæ@‹Gd@ªñ#@Êšã@êD£AôÍAÇA$–½A4b÷AD/2AO‚¨AQݽAUfAXÿMAS¨AC’ÌA4sA$ôAõuAh¥@ë²½@Ìy{@­@9@Ž÷@]z³@h0?¾?Ó¾÷&¿¼@¹À¿ëÀ]`”ÀŽ€ŸÀ®PôÀÎ#ÎÀíûùÁëÑÁÚ×Á&ʪÁ6º¡ÁF¦ãÁT‘}Áb€Áq(¶Á»CÁqƒÂÁcCÁTãöÁF½YÁ8³³Á*Á“±ÁúöÁ¦YÀém/ÀÌ×§À­^+Àæ¾À\Þ¡ÀïÆ¿¾Ö¿H?>÷ á?¼n)@ŽÔ@\àˆ@Ž¿@­±€@ÍMý@ìêzAC{A¹A%ßøA5°\AEƒAUUâAaajAd¬sAaŒ¡AQýæ97¿ Úˆ¿ÃhÕÀ ò3À`/üÀ¶åÀ¯gÖÀÏ0±ÀïëÁt9ÁÿâÁ$©Á1ÏÁ?ç,ÁNFvÁ\‡ÿÁjáÁyÅÁjc Á[ôlÁMÁÁ?Ö_Á2E)Á$ƒ¥ÁbÝÁ8aÀôñdÀÙðZÀ¿àÀ¥‘À‰YÀS˜ûÀB¿­­¾ÀÏ®?,?ËH@$ƒ @cb @‘ ‡@°ŽÚ@ÏüÔ@ïjÍAoÍA2ñA&üˆA6ÊæAF›AVjAf4ÏAp3ÃA`ÜQAQP‡AAÈjA2DïA"¾jABÅA¯@è&´@Èîi@©¬ @Še~@V>…@ªq?±0‰>Ì0¿¿0R¿É<‚À#°nÀbèQÀ‘0TÀ®ÀÉÂÀåöcÁ,ÁÁu«Á+»ªÁ:ÑÁHURÁVÖ›Áeƒ­Ás6Ád nÁUMŽÁF¡ëÁ8-žÁ*DÁ-.ÁĹÁ½;ÀégæÀͪÀ±®ŸÀ–/Àv×ÈÀB·ÊÀÝ¿”ö…¾Ru¡?Dq?ÞY@-bj@kú?@•J­@´l @Ó‚÷@òÏ:A $AÕÛA(ŒöA89*AGåòAW›ÐAg[kAldöA_FAO»îA@|7A1ZfA"c4A<A½P@èQ˜@ɹ@©Ã„@ŠYZ@UÁZ@³?¯~›>—¿XS¿ËÄ"ÀžÀSY8À„Ã/À¡5‰À½ú‚ÀÛóÀ÷ŒíÁ Ò‰Á œÁ&MÚÁ4¥êÁCRÁQ£ÇÁ`YÇÁnéÁ^»ÀÁO)Á@„’Á1ž>Á"ã;ÁfáÁBªÀñ+'ÀÖ¸*À½¨À¦DiÀŒSÀ`èBÀ(¿ã\¿b§=hÜ?€›?ù‰X@9Ó@ww™@š´Ú@¹•P@Ø{4@÷b1A 'A¯A*JóA9ò§AI›wAXk§AfpIAiwŠA[JœAK×A<|A-1ÚAçøA±ù@ÿZÊ@áÛè@Å%i@©-@•@\Õ@ ?İ®?´D¾¡xÏ¿•´mÀ€,À;•Àv6lÀ˜.ëÀµ³ ÀÒOãÀí©†ÁÝÁûŽÁ!LÁ/º9Á>^pÁM0üÁ\%ÔÁi·²ÁZ6dÁJÈÅÁ;p5Á,&ÒÁúýÁ ùGÀþQVÀá@‡ÀůÀª,fÀ†·ÀrÄÀJV%ÀµÞ¿Ä6¸¿žÀ>&á?šÞ@ a(@CÛÑ@~×@œ*ø@¹²Ù@×ë@ö–LA ÇGA^OA*ÚA8~UAFQ ATTOAb™ÇAg18AX²AI ìA9u)A)ñ÷Aˆ;A =±@÷ø@Ù‡k@»‹‹@žZ2@‚{™@Qý¸@,µ?Í|?WÁ2½g”¿x’¿ïy˜À3+ëÀo.!À”j]À­ª•ÀÆãWÀáKšÀüéˆÁ ºÃÁV¯Á*)¡Á9"ŽÁH9çÁWq ÁfmMÁV¯1ÁFû—Á7U4Á'¿ºÁ@[ÁÝûÀó'¼ÀÔÒÀ¶êèÀ™³äÀ{OÀG“À‹™¿áß#¿ ï¿?6>&Ë?‰µ­?þ‘W@9ˆ@sÖ3@—³õ@¶@ÔæÍ@óùåA ž¢AA&†NA4VABv,APºóA_%ÚAe·/AWB­AGÄA7ÇjA(•AƒqA @óBØ@ÔÛi@¶®ª@˜ªs@w$e@>øµ@&{?’tÖ>e€¿ ‡¿¥)ÀgÚÀ*‰gÀS|ÀÀ€ŽwÀšE¸ÀµjÀÑí„ÀïL§Á“_Áª6Á$ã¬Á4?FÁCµ9ÁS?¼Ád6sÁTNwÁDj:Á4ŠäÁ$±áÁá5ÁÚÀê̼ÀË8À¬›aÀŽŽÀ_^IÀ$RË¿ÛR<¿tx”¾Ê ×=TXñ>îÆã?–(@¨'@;‚è@u\$@˜N_@¶¡æ@Õr®@òòãAÿAzëA"Š´A0»ƒA?ÀAM¨åA\\“AdP‚AV ÐAG%ÐA7oA'ÁÆAõAoã@ñÁ„@ÒæÜ@´r@–¢…@sßv@<¢¡@>q?Ñ>¸ÔÓ¾'|¿/ªý¿¢§%¿ñùÀÀ'4™À[ú@ÀŠk‘À¨ £ÀÆ9ÐÀä¹ÀÁÇóÁS9Á õ_Á0¨QÁ@gôÁP1fÁbú4ÁSÁC ôÁ3‡Á#Á'´Á1KÀævÀƃÀ¦¬DÀ†Ø.ÀN>uÀK)¿£6¾ª)>âá?_ƒ†?”S?×h×@ö­@L6k@‚¶@œ˜@´„@Í«9@è¬]A-ÓAlQAÆ=A-X(A o¾óçÿ¿›¹EÀö#ÀBIŒÀqšÀžÒƒÀ¾8¤ÀÝÊ¿ÀýpÙÁŒ-Áb²Á.>¬Á> °ÁNWÁbš¶ÁR›KÁB›ùÁ2œÆÁ"»ÁžæÁ ZÀåDkÀÅIWÀ¥P,À…ZFÀJÕÀ {¿—>A¾K9b?@nL?ÂFâ?þÕ›@ ¹@'>@@k:@k…á@ì @¨‰©@ÄÐ@à&é@üääA þÓAµóA*}:A9jŽAHZpAW\uA\W AN1A@ÑA2 IA#ÐÙAFA$ä@ñÈ @ÕŒ½@¹Ãî@ž‚@„Ö^@X´@/ô@?×ý4?²?náB=ûñ¿YÞÄ¿ë÷,À5…«Àu_Àš\·Àº?ÑÀÚ+aÀú*Á 3Á„Á,ÿ³Á<ü‡ÁLùÙÁc\ÁSk<ÁC|ïÁ3‘ÈÁ#ª±ÁÈûÁî—Àè= ÀÈ»IÀ©\1ÀŠ „ÀUÛmÀv¿½E[¿$©">ëï?Ž1…?›±?¢ÎM?ݱÄ@j·@O[ @‚í@ŸTã@¼I@Ù ƒ@ölGA aAÔ|A'¿ÔA6Á:AEÊžATÚ¦ATøðAGȹA9ôUA+úA•A%JA'@èMÚ@ËýÐ@¯¦ž@“}À@o3’@8„P@P?ºÓ?‘`??©T“?dd°½('/¿tx'¿ôåJÀ8õóÀw¤éÀ›bþÀ»jÀÚâ/Àú6MÁ ÕrÁÁ,oöÁÈÓ?ZKp>º÷>ã4P?—dÑ@éµ@;Þ›@u’k@—ò @µ@Z6#@!ÙS?Ô¨Ã?T»>IñL>Ô¼g?Wh°=ç\0¿UbŒ¿ç³zÀ3">Àr2À˜þÀ¸¹åÀØwÀø7JÁ ,ÁìíÁ+زÁ;Å&ÁK²!Ád¾åÁTònÁE' Á5\xÁ%–¦ÁÚ[Áü™ÀìK£ÀÌ·ºÀ­K}ÀŽ %À]É}Àà׿ÇCŸ¿'aë=œÊ=rd¿ ²i¼ü´,?_¥P?äy@@,¶ @g%Ã@Ó‡@®3@Ë¥ñ@èÊÀAAÈ_A ŒA-òA9'IAäð—¾×ø¾ò+Œ½Ù´S¾s:¿+g¿õ[ÌÀ8N»Àvß±ÀšÙÀºXàÀÙûÅÀù¶fÁ ¿PÁ¤.Á,‰3Á•ÁMì¬Ái«ÁYuDÁIÚðÁ:M8Á*ÑmÁp^Á 2æÀúL ÀܲÀ¿zaÀ¢ê|À‡PÀ[(ñÀ,UÀ 옿ë=Ÿ¿îDQ¿º(z¿ AÏ>»"é?¢’ÿ@ ˆ[@C£@|®ˆ@šy›@¶(¼@ј @ìÌAŒúAÔ±AQsA}ACgAR AA&=A 8–@ýs@å#X@Ì-Ï@²’â@˜y@{Î\@FPÖ@Zg?´Ÿ€?c¾“…Z¿’¨ÀÌ/À+…ÀäÀ`2ÀBÑÙÀq•ÚÀ“®À®ˆ´ÀËNÀè×~Ám±ÁEÁ!ô¨Á1iØÁ@õ©ÁP“Ál˜~Á].<ÁMÖ³Á>™\Á/~°Á vÁÜIÁNÜÀêîÀÎZÜÀ³¤FÀš£VÀƒ[nÀ`$­ÀD¶QÀ5;âÀ)~F¿ÞŒl¿WGf=EÏs?pØF?è¨_@,˜Ÿ@cQÚ@Œy@§> @Á¼@Û£@òÇAt}A±A Ñ™A ÕjA û_A ÅA‰è@ú¦@çC@Ñ® @º< @¡ÇÙ@ˆªÅ@]uˆ@)À?è?{Îð>ü“¿1Ìç¿ÄË~ÀMÒÀC×£ÀEÚ‹ÀW"”ÀuÓóÀŽÛÀ¥¸ À¿k,ÀÚ'-ÀõþÁ ZeÁÿ6Á&ÚvÁ5å8ÁEÁTf]ÁqnÁaóöÁRóûÁD}Á5wkÁ&÷HÁ¨pÁ ¸[ÀúmYÀàV-ÀǾPÀ°”²ÀœZôÀŒ$À€wöÀu À=¼xÀ§&¿˜Íl¾£—U?¤U?³ÏÍ@ŒD@E%x@zß@–˜ž@¯Á4@Åò˜@ؾ@æÆb@òL@ùr@üÑ•@û>@ö¤@ì±@ßGZ@Ï£ @¼Rn@¦¦è@oY@n’ß@<ë!@ é(?¬›I??¾šQ´¿Æ¾¿üÀ3…fÀiÁœÀ‚¨À‰² À– »À§ŽZÀ»¼ëÀÒÉ,ÀëêÛÁ(ËÁº`Á¾WÁ-°Á;£wÁJf°ÁYV³Áv€àÁgº§ÁY ëÁJªvÁØâ'?œrä@“i@0(£@\÷Ö@‚`@“SÊ@¡¿{@­{x@¶(v@¼p@¾åŠ@¾Ew@¹];@±Ÿ‘@§O@™ññ@Šý£@s¥ö@LÍ@ Fm?åqê?‡åI>š0¾ò¯ë¿¢«{À¥FÀ9/ñÀm·À‘4rÀ«àÙÀÆšíÀЧ?Àݤ;Àî>õÁ–qÁ Á‹]Á"ÅÁ/öÁ<ÌzÁJQ™ÁX&¼Áf=tÁç\Áu²LÁgÔ¸ÁZAõÁM2Á@ ›Á3‘‚Á'‰”Á'-ÁzÑÁØŸÀþ¯7Àð¥©À×ÉÀ»ç[À ¢]À…³ÀV{RÀ!£²¿Ü8¿g7½ÿƒJ?%¶Š?±]K@w@,¾@QÈ·@p`@…p@p@˜tò@€0@Ÿüå@ŸÛ•@›@@”Š@Šm@|#=@`+à@AS$@Œ?ëªÏ?“£º>å ;¾%œ¿ƒÔ¿æZ”À%¾ÃÀXÒóÀ†DCÀ ‡zÀºÞ²ÀÕ>¼ÀîâèÀúd^Á™êÁ mžÁ\Á!±òÁ-#ïÁ9A£ÁEäYÁRó³Á`Y€ÁmüiÁ…¾]Á}Í´ÁpgñÁcTüÁVŠÐÁJOÁ>õÁ2Æ÷Á({Á%„Á;ùÁ ~~ÁY{ÀäóÀÊ0À¯¥îÀ•LÐÀv“tÀBöÀêÚ¿¼cM¿6:`<Üq?5bý?¬¡Ø?õf…@Î~@9dR@R%€@eÁu@tž»@~‚L@—ç@SÞ@z]·@mu@[°Ê@D“@*l@ ½”?×Á?ŽÉX>ôÛ,¾Hõh¿d⨿ÏcÜÀJÀHg®Àz~À–“MÀ°WäÀÊPÀä±åÀÿÜÁ ì¨Á–eÁ Á#Á×Á-›Á8P!ÁC¾]ÁOÆÁ\G~Ái.ÞÁvq¯Á‰ðåÁƒQkÁy°þÁlúüÁ`›ÁT¶¹ÁIdHÁ>“–Á4…}Á+PàÁ"ËfÁüSÁIÃÀôéÀÙÓJÀ¿1À¥·ˆÀŒÓÀf‚À4g3À‹>¿«šõ¿)+»2ª¥?|Á?´±mf¾jß¿^•W¿ÅÁ¹ÀIPÀ= Àl¢ØÀŽÏ·À§†xÀÀ½ŸÀÚðÀôgëÁSlÁ~\Á ó Á(MqÁ0ÍÁ:!gÁD'ÎÁNî×ÁZZÁfOìÁr¶ Á{ÙÁŽvßÁˆ çÁ¸aÁw'IÁkP1Á_ý›ÁU&gÁJó·ÁA„Á7µ€Á)þ$ÁWšÁyÁÀééSÀÐ_@À· þÀžM À…v×À[ËÀ-$ ÀîJ¿¯ï²¿F/¾UyÏ>”²å?>‹m?‘¨ó?¼”o?ß«?÷ó{@Ž@ ’á@MZ@Œ%?îDò?Ђ ?¥³?q:÷ÁGùÁPÃÁZ¸žÁeîÁpö¶Á|ÝãÁ„–ŒÁ“= ÁŒö–Á†Û{Á€õuÁv˜DÁk»ÞÁalÁWÌÁL‚&Á>ìÿÁ1hÉÁ$:ªÁ@fÁ RÉÀûgÀâ&6ÀÉ ™À°ùÚÀ™Ÿ»À‚E ÀYvpÀ/{vÀl¿Æ¤É¿°¿ µ”¾›>|)ƒ?Ÿ?Q¬?p?‘‡ ?œbç?˜½Í?Œv?m 6?8ß0>Ô°æ=mæN¾žG¿?ñ¿žeÿ¿â‡<À(À:õ3ÀdqÀ‡Ù.Àž ‰ÀµuÀÌ[IÀä ÀüðcÁ é"Á«¿Á$‚òÁ1vfÁ>•lÁKÄÁTNÁ]gCÁg<ÁqLeÁ|-KÁƒÊÁ‰·tÁ˜7zÁ’$¡ÁŒCKÁ†™öÁ)¤Áwë¤Án"àÁa‰ÿÁTRÁF«ÕÁ9˜<Á,šÍÁ¿×Á7yÁ¥ÀôÖcÀÜ…ÀÅF^À­ýUÀ˜\žÀƒ{†À]ºòÀ9QÇÀyý¿í7ˆ¿³¼Y¿~LZ¿% é¾³Û½åç‚=•:‹>L é>ˆMŽ>€»¶>${z;²˜¾>Ôë¾îÒ$¿RÖ0¿˜”É¿ÌÏXÀè~À$9ÁÀF ÀiNCÀˆÓÁÀ­À³;*ÀÉo„ÀàsmÀ÷­.Á˜OÁï•Á OìÁ,ð$Á9º‘ÁF”ÁSµµÁ`òœÁj{oÁs¾Á}‚4Áƒñ/Á‰foÁïÁnÍÁ—‘Á‘è-ÁŒvÁ‡8dÁ‚%mÁvÄÁiMDÁ\GÁNüÁAþðÁ5:·Á(¯MÁ: Á ZÁ Àð׌ÀÙ¶±ÀÄ KÀ¯¸ÀšläÀ‡¦[Àlr¹ÀJCÀ,…À(ì¿ï?ð¿ÆD¿¡Ë¿„%\¿\d¿=EK¿0x@¿3Pþ¿Fè3¿k«<¿Ž’¬¿¯R¿ÙgÌÀÃÀV"À:GâÀXÞ!Ày@ƒÀ߀ÀŸì¦À´YQÀÉ.0ÀÞ­«ÀôÑ™Áé2ÁvãÁ'êÁ)mîÁ5ÊÁÁBMtÁOöÁ[á‘ÁhéÁv$šÁ€]þÁ…xÁŠëÁ=Á”¶LÁ¢ßÿÁ6±Á—ÃÁ’}ÁŒÄÔÁ†"Á~ÞÁqbPÁdq[ÁW“ÕÁJãÁ>S¤Á1ê²Á%ÚõÁÖÁ1uÁÎLÀïµøÀÚ¥4ÀÆÀ² CÀ þ¾À„8À1ÀbO‡ÀHs¬À0ÎÐÀ¼øÀ |²¿ùïä¿å?•¿Öîr¿Ñý¿Ò˜¿Û`¿¿í{®Àç´ÀåáÀ$tPÀ;ŒxÀU‘jÀpÍÀ‡À–Ö­À§*/À¸tÀËPòÀßÞâÀôµöÁ9ÁÁ’Á'JÁ2ÉWÁ>÷íÁKFMÁW³*ÁdyCÁqS\Á~7#Á…¬–Á‹…‘ÁDãÁ•FíÁš‰~Á¨…sÁ£^ÁÃmÁ—f6ÁªêÁ‰ÿ¯ÁƒuÌÁzBÁm5^Á`’½ÁTûÁG¾˜Á;¬^Á/£Á$ ÁÕ¡Á ÂHÁ¡Àñ»rÀÝéåÀËŸÆÀº|À©îÀšlGÀŒÎ¿Àø®Àj0DÀVJÀFƒpÀ84À.DCÀ'¸ÿÀ%4ØÀ%¼XÀ* óÀ2ê´À>j»ÀLZ[À^’ÀsØÀ†J‰À“•-À¢ À±ïÀÁsÀÑ´”À㸹ÀöÁuÁ±@Á" ÁéÁ%ÎüÁ1CÈÁ<ÒÁH€lÁT§ÌÁ`ä_Ám9MÁyñLÁƒccÁ‰Ï­ÁMáÁ–°=Á›~3Á ŒªÁ®ZÁ¨ÏœÁ¢NÁ›hdÁ”ÎÁŽKhÁ‡ÙHÁm‘ÁvIûÁiçéÁ]“ ÁQDÁE‹JÁ9úwÁ.Ú<Á#ÅÕÁëÑÁ»˜Á¼[ÀöÓêÀä¡,ÀÔ4ÛÀÄx©Àµ À¨ƒ°ÀœB†À‘Å«ÀˆB÷À€ÎgÀtøÀjTÀd;Àak!Àb9¿ÀfËÍÀoåÀyê†Àƒ¡UÀŒÉÀ•óÀ¡ÙQÀ®û­À¼÷žÀË«1ÀÛ7»ÀëL™Àü\&Á‚;ÁYÁq¸Á%ëTÁ0ºƒÁ;¬ ÁG @ÁRŠýÁ^7ÖÁjVÜÁv‡LÁfäÁ‡¸BÁŽ"åÁ”!Á›HÁ¡´Á¦ºŸÁ³ƒiÁ¬ÒVÁ¦8HÁŸ§ÄÁ™"oÁ’¯ÁŒJŠÁ† sÁ½*Ásg¢ÁgYRÁ[‹ÁOñÁD®‡Á9¦ÖÁ.ÕnÁ$›(Á—ÞÁ «ÁåäÀþp³ÀîuýÀß‹ÀÑ9kÀÄÀ¸™iÀ®«üÀ¥©³ÀžEÀ—æÀ“¸À^ŸÀŽÝ\ÀqÀ‘¶TÀ•¨;Àš·&À¡WÀ©I¤À²´8À½‚Àʇ—ÀØ6ôÀæ…2Àõ}üÁ°vÁ Ì„Á°…Á'Á&ߥÁ1DGÁ;Ë€ÁFœ/ÁQ“1Á\í-ÁhPôÁs÷úÁ€×Á†òÁŒ3Á’z¦Á˜æ ÁŸXÁ¥ÎÏÁ¬[íÁ·£lÁ±ÁªŸÁ£ùøÁ†¸Á—/KÁúIÁŠÊÁ„¡/Á}G_Áq–ÁeôþÁZŠóÁO–ÁDÈ~Á:xƒÁ0wnÁ&®àÁ„Á›Á KÁhêÀú©ÑÀìà­ÀàždÀÕ]ÀË“FÀÃnÀ»¿£ÀµÚhÀ°ü®À®²À­À­Ô¾À°ÁÀ³Ã„À¸È™À¿ ±ÀÆ{KÀÏwÀÙf²Àæ)¨Àó\ˆÁ®ÄÁÙÁ”Á’GÁ #»Á)!"Á2š{Á<¼¦ÁG$$ÁQ³aÁ\}ÚÁgz_ÁrÔ‚Á~1TÁ„ëÁŠëæÁó‡Á— ÃÁK¿Á£°JÁª!¥Á°˜aÁ»ë8Áµ[yÁ®ÑëÁ¨c2Á¢õÁ›ç¨Á•½›Áœ—Á‰£JÁƒÏ¼Á{ýÁp†RÁeŒ]ÁZ¼ÌÁPVÁFT¹Á’ÁHMâÁRVÁ]Ágœ¢Ár_…Á}a”Á„]ëÁŠ  ÁÜ"Á•Ú¬Á›àÁ¡óÁ¨-•Á®†Á´ìmÁÀ5qÁ¹±EÁ³KÁ­åÁ¦ÞtÁ ½?Áš¡hÁ”§ÊÁŽÐqÁˆÿêÁƒLÅÁ{ŠvÁp²Áf7ÏÁ\)ÛÁR2ÃÁHÅÃÁ?Ÿ¬Á6ùÁ.¨³Á&ÕÁ› Á²hÁnÏÁ ¦WÁ‰=ÁwÀýù À÷+®ÀñÖÀí¤ÀêëÀéâéÀê©æÀìpÀïÞgÀôm×ÀúSÌÁƒÁ­ÊÁ a°ÁæLÁ!'Á—EÁ"è7Á*ƒÁ1›ËÁ9JÁB3-ÁJâXÁTJÁ^SÁh~Árä2Á}…ãÁ„ ˜Á‰¤gÁPõÁ”þ–ÁšÍxÁ ÉrÁ¦ÓCÁ¬ç@Á³ÛÁ¹háÁÄ_Á¾?Á¸aÁ±à Á«ÂÁ¥¦°ÁŸ¬jÁ™ÒàÁ”!ÁŽX5ÁˆÎtÁƒT Á|²ÁqýZÁgüËÁ^^ÁU6ÈÁLqPÁCõÁ;õAÁ4oþÁ-5ÒÁ&±“Á xðÁ£ÁkÁ¿ÃÁ ã÷Á yjÁ¬ÁÇÁŸCÁ'5Á…®ÁOoÁ¼Á RÁ ÏÁA´Á+Á÷üÁ$ Á#3BÁ)d”Á0>Á8ÀÁ?<˜ÁF¦1ÁNÿ×ÁW&Á`cŽÁiÞaÁtÊÁ~^¶Á„c»Á‰·’ÁzÁ”˜ºÁšD…ÁŸñúÁ¥À Á«»SÁ±É¯Á·Ý-Á¾?ÁÉ=NÁìÁ¼äÞÁ¶ÆæÁ°«ýÁª±$Á¤ÖÝÁŸgÁ™dmÁ“Û¢ÁŽXÁ‰ÛÁƒî&Á}ɺÁt=mÁjä»Áaê1ÁYW(ÁQ'ÞÁIcƒÁB ZÁ;ëÁ4¹¤Á.Ä;Á)ßÁ$ž.Á l\ÁÍ(Áz¹Á;EÁ)YÁâäÁ^ŠÁ¯'ÁjÁ6tÁ Áì³Á ³Á!Ä©Á&ŽYÁ+‹€Á1nßÁ7€ÓÁ=äšÁERéÁLþÂÁT"Á\FÁd†«ÁmÃÁvRÁÅqÁ„û¸ÁŠ"#ÁWûÁ”­ÚÁš CÁŸ–áÁ¥AoÁªîÁ°¼˜Á¶´ÚÁ¼ÀÁÂÓ(ÁÎ$ÁÇêÅÁÁ˹Á»±LÁµµóÁ¯ÛqÁªÁÁ¤q?ÁžçÇÁ™cÆÁ”  ÁŽëRÁ‰×6Á„þ[Á€TçÁwƒrÁnÝ€Áfk"Á^’°ÁVê·ÁO¿`ÁI­ÁBÐöÁ="jÁ7ýïÁ3?ÀÁ/BÝÁ+¶ÐÁ(Á&J~Á$OšÁ#=ÁÁ"“ÍÁ"Õ4Á#Œ¸Á%8mÁ'%wÁ)ÛÁ,ÿÁ0ˆðÁ5hÁ:HÁ?™‰ÁE¿ßÁKâªÁRÓØÁZ‰þÁaÆNÁiZGÁq”ÁzüÁ]ÞÁ…úÁŠå ÁüƒÁ•ÁšWYÁŸ®>Á¥ÞÁªŸÃÁ°HÁµô‘Á»ÃÁÁ¶üÁǹwÁÒóìÁÌнÁƶŸÁÀºèÁºãïÁµ&Á¯áÁ©óxÁ¤oÁÁŸ€Á™ñÁ”×ÁëÆÁ‹7§Á†š¿Á‚,Á: æÁ7¥¸Á5\—Á3Š«Á2×Á1ÁOÁ1üIÁ2¹‚Á46+Á6+Á8ØÁ;à­Á?fÁC“ÁH”OÁMàEÁSõ)ÁZÇÁ`§ÙÁgôŸÁov¯ÁvÜÁ~Ð!Áƒ˜lÁ‡Û¶ÁŒB†Á÷Á•ðÓÁ›eÁ îÁ¥`ßÁª¸Á°Áµ±.Á»XÁÁ‘ÁÆÑˆÁÌÀ*ÁÜÙÁÕÇjÁÏ’'ÁÉ}@Á˺Á½ÀçÁ¸åÁ²nÁ­7õÁ¨FÁ¢ã6Áå3Á™(‹Á”•þÁ&XÁ‹ß§Á‡íPÁ„0üÁ~µ‰Áq¾ÃÁe'°ÁXèÏÁLñŽÁAzMÁ6±àÁ,°ZÁ#fÁ©Á»SÁ |>ÁÄÛÁƒÁvÁo'ÁRÁÖ Á ¥ÊÁøûÁf*ÁBÁ%Á>Á/BTÁ9ŒòÁDkÁOÞ%Á[×jÁh)ÁsˆÅÁy»íÁ€HJÁ„ÁÁˆ1¼ÁŒÁ‘‡Á•ÚPÁšÌ‹ÁŸÜ'Á¥7Áª~ñÁ°®Áµ¿ Á» "ÁÁ¤;ÁǶ<ÁÍ×¶Á×pÝÁÑ›ÁÊÖñÁÄoÁ¾„ÿÁ¸‘ÐÁ²Ç˜Á­*tÁ§¶ÊÁ¢`¿Á3âÁ˜uÁ“4BÁŽŒQÁ‰þ˜Á…¢ŽÁ”Á{xkÁsûÐÁi·Á\®ÁP ëÁC´XÁ7ÌÁ,€!Á!Ö¥ÁØDÁéŽÁ"TÁNsÀõÝÀî>SÀé«Àè?BÀê‡Àïo…À÷àüÁ©2ÁMÁã«Á.ùÁ$) Á/ÆÁ:’ÒÁFr~ÁRÑÒÁ_ZÁeO Ák·õÁrñ“ÁzÜúÁ·lÁ†HñÁ‹'¦ÁÙÁ”þhÁš)üÁŸ‰¨Á¥ 8ÁªÀ<Á°œêÁ¶ `Á¼¸ëÁÂß{ÁÉ&oÁÒì1ÁÌ~íÁÆ-ûÁ¿ë—Á¹³³Á³—¬Á­¢ýÁ§ÙÖÁ¢@àÁœÚüÁ—‘ßÁ’eÞÁc›Áˆ›9Á„hÁ óÁvñÁn–nÁgÁ`TÁUÆÁGêÁ;0lÁ.·YÁ"Ô Á§×Á $¹ÁYmÀõŒ³Àç8BÀÛ öÀÒËÀÍm¥ÀËëÀͬŽÀÔáÀÝW%Àé ®ÀøÖ@ÁqÜÁmÁÎÁ%ZoÁ1FSÁ=°lÁJ‰ÑÁQFÐÁW;ƒÁ]øºÁeŒÈÁmÜJÁvÎÁ€/£Á…4´ÁŠ%‹ÁDŠÁ”›kÁš¡ÁŸÅ`Á¥Ÿ‘Á«¥5Á±À­Á·ñÌÁ¾?ÁÄVÖÁÎŒÁÈ ßÁÁ—ÖÁ»AOÁµdÁ®ÕfÁ¨·fÁ¢Á~Áœú Á—fbÁ’ åÁŒÃÁ‡ŸMÁ‚¼Á|1Ás~Ájg­ÁbxÁZ›ÁS© ÁL˜¥Á@y;Á3IóÁ&‚ÎÁñüÁyÁó¤ÀñDÓÀÞgÀÎrçÀÁ¥mÀ·‚¡À±µóÀ¯›šÀ²ƒ¼À¹:7ÀÃb·ÀÑsÑÀâ!÷Àõ7•Á …ÁySÁs«Á(ÓÙÁ5ÀvÁ=ÀqÁC.#ÁI[·ÁPƒ†ÁXsÁa5ØÁjÅÁtsàÁ~µºÁ„eÔÁ‰®YÁ'¨Á”ÒÁš®Á ­œÁ¦Î!Á­ ÐÁ³ÛÁ¹ HÁ¿+ÁʈbÁÃÔ®Á½:ÍÁ¶½‹Á°`Áª%UÁ£þþÁæßÁ—ð1Á’+XÁŒžxÁ‡G÷ÁýÒÁy×¹ÁpTîÁg<Á^pjÁV:ÁN)íÁG6\Á@IMÁ9ÑÓÁ,3ÁüØÁÁwÀók¬ÀÝÀÉ+À·qmÀ¨çÀ~¼À–p"À”BÀ—PØÀŸÛÀªÂáÀº<½À̺¿Àá2wÀ÷[¼ÁŸœÁ)ŒÁ!(³Á*ÛaÁ/ŸéÁ59åÁ;ÒgÁCP2ÁKÀ¿ÁTàŒÁ^ žÁh÷RÁs)CÁ}ž¡Á„@’Á‰æñÁÃvÁ•¼àÁ›ã>Á¡úiÁ§Î8Á­ÄÁ³ÙÉÁºàÁÅô|Á¿{4Á¹©Á²xdÁ«òxÁ¥ºÁŸN)Á™1¦Á“&©Á2ÌÁ‡qÐÁíÁÁy0¶Án¤µÁd­(Á[jØÁR‹ÁJ,õÁB"Á:IFÁ3zrÁ-³iÁ&‚ÁVºÁ ×÷Àû©JÀâÍÞÀÊó¨ÀµiAÀ¡ÒËÀçšÀƒÐíÀvƒ(ÀqlàÀx¦À…oÀ“ À¥]À¸ã3ÀÎ/·Àåú”ÀÿŒàÁ ÜàÁÒ¯Á³ßÁ!£sÁ'—‰Á.Á6ŽšÁ?]ŠÁHúÇÁSýÁ]¹Áh æÁrÙ}Á~ØÁ„áÞÁŠÛcÁè¹Á–®ZÁœ‚¨Á¢{=Á¨—Á®ØKÁµ7ýÁÁpÍÁºÑÁ´MÇÁ­Ü Á§qãÁ¡%èÁšÍfÁ”ˆ[ÁŽooÁˆtQÁ‚Ž<Áy¥ÃÁn²íÁdÐÁYrÁOÑwÁFÛ¢Á>A Á55ÓÁ-,>Á%à@ÁÍ\ÁÿµÁ%Á¶*Àî#ÂÀÔËÀºä}À£p5À ÁÀt—YÀV[ ÀA¿ˆÀ;?¼ÀDVÒÀYóyÀxg¾À„”À¦*áÀ½÷À×FÁÀñ¿ÁGÛÁ ÑvÁÏÿÁ¨ÁPyÁ!¾•Á*$°Á3Š8Á=svÁH#¿ÁR®xÁ]]OÁh•Át$ÔÁß>Á…œTÁ‹bLÁ‘7-Á—2éÁVÁ£ OÁª“Á°iÊÁ½'êÁ¶`PÁ¯²ÿÁ©#Á¢­äÁœDÁ•î=ÁÁÌÁ‰¦ÒÁƒ™NÁ{uÁoø`Ád„8ÁY³ÁOÜÁDÔEÁ;_Á2‡”Á(ðÜÁ JÁ½3ÁÇÁ ¥Áò•ÀÿñÀã'ÃÀÇĽÀ¬ãfÀ’ûÀvæÀKT´À' }À ›ÔÀuÈÀÞÀ)À¥ÀNÔ§ÀzS6À–ZÀ¯Ë§ÀÊH¨ÀåkoÀô@…ÀúG9Á6*ÁÖ[Á |UÁU ÁY…Á( ÚÁ2“CÁ=j,ÁG÷þÁS2%Á^KÕÁiCFÁt wÁ€=Á…ëÎÁ‹ëTÁ’Á˜k{ÁžÑ)Á¥5lÁ«©ƒÁ¸ö™Á²(\Á«WæÁ¤›“ÁýrÁ—€kÁ‘lÁЏ½Á„ƒäÁ|ÓcÁp¸QÁdöpÁYºXÁN½<ÁCà±Á9¥9Á/¼(Á&vÁEÁîÁ æ—Áï&ÀüæêÀñÖ Àé*¦ÀÚ6ÓÀ¾2³À¡Ó·À…ú`ÀV’9À%%¿òÿ¶4?¿£I¿½ ¨¿ùÖèÀ&ùôÀYlÀ†ö„À¢îÀ¾Ù³ÀÕ¢HÀÙš}Àß—ûÀèrXÀôƒÁ#†Á ž)ÁýŠÁOMÁ(e8Á2Ü Á=]_ÁG¿sÁR§àÁ^ZÁi”]ÁuA$Á€¥<Á†ÚƒÁ8Á“¾Áš»Á ƒÁ§9Á´ÐÁ­ô@Á§%öÁ W´Á™Œ(Á’ÞÁŒSEÁ…ãÁ ÎÁr“ÁfYîÁZDïÁNz3ÁCE@Á8MGÁ-ZÁ#jÜÁ²éÁÑdÁVøÀÿPQÀî¬/ÀßðtÀÔ/ ÀÊÒ|ÀÄ,ºÀ´T¦À–ñÀs¥þÀ; ˜À#}¿£´¿.Šç¾èfï¿9Ë¿ª«ÀÿÀ<ìÞÀuXàÀ—bÅÀ³;MÀ¶Á„À»óJÀÄVDÀϧ‘ÀÛÊÀëÒÀüúEÁz>Á@AÁ$MÁ&ýÁ17¸Á< CÁGp=ÁRü@Á^«ÁjÁ¯ÁwBÁ‚§ÁˆiÙÁŽÖ*Á•b>Áœ Á¢ÍÁ°åÚÁ©ãôÁ¢÷ÖÁœ#Á•USÁކžÁ‡Æ_Á*¨Áug†Áh¤(Á\ÁOá†ÁCÕ"Á8µÁ,×tÁ!êÆÁ5DÁ PÁØÐÀöcOÀå§fÀÔ7ÀÃèÌÀ· ˆÀ¬Û1À¥žðÀ hšÀŒÿÀ^ÿÖÀ$Yh¿ÕlP¿Ln’¼ÇÓ>¸½=n4¿Q"ë¿×¥‹À%¥VÀ_–™ÀŒÕÛÀ–oúÀ˜8ÀÝñÀ§:æÀ³ÏqÀÃcAÀÔùEÀè3—Àû#ŽÁÎOÁ¥^Á¶¬Á%sÊÁ0Ø ÁnÁE¨ìÁ9jŽÁ-iÁ!ž1ÁxÄÁ ˜ŽÁ ÀÀÜMûÀË#×Àº’VÀ¨ÐyÀšFšÀgÞÀ‡\5À‚‡&Àq•¬ÀIikÀÿ›¿«C‡¾Þ¥>éRW?”® >ð j¾×§¿ª†ªÀ±×ÀD:ÃÀd§Àp—qÀtR.À€X—Àв À˜ÁfÀ©O?À¼ÕÀÏ5aÀàôÀô›[Á?»ÁÜxÁ@Á%ÌÁ1€ˆÁ=½ÁJpLÁW;¦ÁdœÁqúÁ~nÁÁ†#ÁŒækÁ“ܨÁšÔÁ©ÈgÁ¢VÁ›Z&Á”4‚Á$2Á†+šÁ~¡Áq•ÁcgÁUâmÁH²Á;ÙóÁ/>WÁ"õžÁ~Á 7àÁ%QÀꑤÀÕü ÀÂÞpÀ°÷£À '”ÀMaÀ}Ü*Àe ýÀSwÑÀH®ËÀ?[§À¥G¿è¿{w޽Ë.K?L`õ?Ùb3?Wía½Xb¿hZ£¿Ú¸¾ÀŒÀ+w8À5à,À9ƒ ÀFìCÀ^1úÀ|²]À¢ýÀ£@À´ƒÓÀÇëûÀÛ²+Àð‘IÁ¨ƒÁ3èÁídÁ'DÎÁ4 wÁ@ÓÑÁM²ÁZåªÁhc[ÁvõÁ‚ÅÁˆü$ÁöËÁ—nÁ¦bùÁŸ"}Á—çrÁ®ÒÁ‰wëÁ‚RÁvˆÁh¥‚ÁZÿÉÁMc6Á?ÇÐÁ2i|Á%w;ÁÓÞÁ žÁŸÀé£&ÀÓ™÷À¾ÀªYÀ—5ôÀ…¡PÀkæ£ÀIåsÀ-†Àã\À/À Ðy¿äkÖ¿›èŸ¾ûžÂ> ÿ1?•ʪ@î=?£0ô>ÜÍÿ¾½\Ê¿‚å4¿¼M>¿ä[™¿ú³›ÀNVÀOÀ(çÀJiéÀn•QÀˆeTÀ›CHÀ¯]ÀÃuyÀÚ'Àñ7–Á\ìÁ×IÁ¢£Á*jÜÁ7k€ÁDÊrÁRu»Á`ZfÁnH§Á|8ÍÁ…)7ÁŒPÁ“TÁ£?¿Á›ÚjÁ”… ÁB4Á† Á}ššÁo+¢Á`ߢÁRÊÁDûzÁ7^ƒÁ)ÀøÁ7ÕÁÁi‘Àì¦ÀÔw[À¼ÖœÀ¦éMÀ‘ À|†vÀW¾lÀ5XÅÀ#¿óx¿Ç;±¿­Es¿ôô¿§_¿=Ø=œJÍ?Kî˜?ËÉÅ@«à?áüU?xœþ>ˆ„¶¾§¿·h¿]¯Ý¿„yH¿“pJ¿²~ï¿ë!:ÀΚÀ8Ù-À]T?À‚[úÀ–p%À­éÀÄ :ÀÛ¡‹ÀôàéÁ;ÏÁ ûÁ!;ˆÁ.ÏÁ<¬÷ÁJ›ÁX‰Áf™BÁtæÁ²ÐÁˆþQÁIÒÁ VYÁ˜ä?Á‘oUÁŠ Á‚¨4ÁvÃ×ÁhM‰ÁY×áÁKgÓÁ=iÁ/Á!Y¸Á½ÁÀñŠÕÀ×ÿÀ¿F:À§vºÀ 0ÀtqFÀK>|À$Ü<À*¿ÀŒ¿ˆ¯“¿9”¾âZ‡¾…T$¾ï>ãë?$ñq?¤ä@|`@3HJ@R½?Íwž?æ?”•>V…=¾ƒ¥½\×¾kK•¿ ½Ê¿|½¥¿ÁÜèÀzÕÀ+…£ÀSáÀùˆÀ–ã;À®˜’ÀÈAÀá§ÞÀû~-Á ,øÁÿ’Á&í’Á4Û ÁBã¥ÁQ0Á_³fÁnJLÁ|áPÁ…Å Á, ÁwèÁ•úxÁއ¥Á‡ŠÁDGÁp]=Áa™SÁSƒÁDŒ÷Á6©Á'¤›ÁTþÁ [eÀûpäÀà5ÀÀÅÀÀ«, À’pÉÀtãoÀF|À_Æ¿çS¿œcJ¿*_;¾2÷t>Q ˜?I®?:ðú?O•?rW-?¡øY?ã¸)@r‡@JŽ@=NÚ@?ãŪ?µÝ?˜ë'?‡Í4?n¶?9Ãx>º]ž¾qŒ¿/©¿¤¦¦¿ó*¢À& gÀSw À®èÀ›E˜À´ÕÂÀÏ(.Àê¤[Á@"Á.0Á.|Á-}ŸÁ<mÁJ—÷ÁY/©ÁgæÁvÁßÁ‚Ó‹ÁŠNhÁšçÁ“K|Á‹·ÙÁ„0ûÁyqßÁjªÁ[©tÁL½VÁ=æ‹Á/DÁ ÌdÁVÁá’Àë ÔÀÏgMÀ´. À˜ñEÀ|ÈìÀK6°ÀÙk¿Ùhÿ¿‡¾àÀ|>†ï?)Ü ?X›?½G²?ÚþÏ?äå2?ï¦@9@»S@?«@i‡e@g"‡@AŽ@$qŠ@ì@ B2@P?õÍ?Ö‘?‰t?2f=Ûß·¿vR¿˜2©¿ò4À)ÂvÀ\ïßÀˆ%ÙÀ£IšÀ¿%xÀÛ~ÀöóZÁ ÌÒÁOàÁ&å¡Á5TÁDIôÁS+ØÁbœÁq6Á€FÁ‡œóÁ˜wDÁ×WÁ‰:¯Áž1ÁtDÁdÞÕÁUØZÁFð?Á8 Á)#SÁ;Á †7Àú¥ÀÝ+ ÀÀ>pÀ£›“Àˆ$ÁÀYÓÀ#‘ѿ㞿žÍ¾ÖŒ>¢¯?fü¦?¹@@¦@©Z@,öí@1ç1@5ÆØ@=Òæ@PÉÏ@mc·@‰Eˆ@‰ñ7@s`ê@\GÄ@NÝg@H™}@C€@9„±@&ê@ h?¿Õ?chŸ>]kÓ¾õãž¿ NKÀP5À7åõÀo•]À“¦À¯‹LÀÌ; Àé>BÁ3LÁØéÁ ³êÁ/•ÑÁ>„ÁMŠ0Á\¢MÁkÕ¢Á{­Á…9‚Á–MÓÁŽ’>Á†Ý2Á~b»Áo µÁ_ç1ÁP­¬ÁAt‚Á2P Á#RÜÁnŸÁ‰QÀí8ÄÀÏ—$À²–€À•©äÀqz‘À8F”Àô¿–”O¾¾x>ÉÔñ?‰Ëù?Õòü@ ®<@2Ït@VÍ‘@j¸@q›@t~ÿ@z~Û@„{œ@¶é@ É¸@¢Ø:@”å'@‹F–@†;Æ@ƒÑî@WÄ@w¾Â@\—¡@8~Ÿ@ä?ÏÄ‹?n„Š>B½¿&¯h¿Á¿–À—˜ÀPP À„ÜzÀ¡ßXÀ¿íÀÜwöÀú;ÅÁ UÁø`Á* ñÁ9?3ÁHŽ ÁWæ¤ÁgF›Áv«2ÁƒÁ”GÁŒŠmÁ„Î?Áz$"Áj«ÆÁ[7¾ÁKØÁ<’¿Á-Y:ÁµÁæXÀÿƒÿÀá¢jÀÃÚÀ¦¿Àˆ2dÀV*¸ÀQ€¿Äð¿&Äõ>LT1?ƒòˆ?æ@ðÛ@=¿Ã@b>„@…[ @”g@˜·m@™²5@œU@¡÷@¬i¶@º¯†@½Œž@±´z@©pO@¥tP@£…Ä@¡Ž@š€»@ˆ¬ì@k?,@B8¢@þ¹?Æú?7W¾ V¿ƒ3Û¿õ÷ À5ŒÀo<øÀ•KèÀ³¶ÀÐÚ3ÀîèHÁªwÁYÁ%aÁ4ÅäÁD*·ÁSåÁcaÁr‚zÁ0Á’|ÁЧÂÁ‚ØÊÁv <ÁføÁW$úÁG¬žÁ84BÁ(»æÁO¬Á ÈÀõ–†À×#~À¸°ôÀšl>Ày>VÀ=¡uÀí¸¿ŽPß¾Tóz?293?É©\@N:@Lzë@pªó@ˆÀ¼@œÓ@±í+@¸¨õ@¹RÝ@» @À±@É7í@Õ¶;@Ù¯Ê@Ï`‰@È"@@ÄÊ#@ÃIâ@ÀÎP@µ õ@¢3Ò@ŽK@oØ7@<ŠQ@Ó?š7€>ž ¥¿›¿Áp*À?²ÀWÇPÀ‰¿©À¨4TÀÆ÷‰ÀåÁ/ÁEjÁª=Á!Á0´Á@vÁO·VÁ_`„Áo‚Á~É}Á‘ØÁ‰.ßÁM*ÁrØGÁc¬ÁSlÑÁCÈnÁ44!Á$°ËÁ5Á¼¾ÀìˆÃÀÍ™¿À®í¢Àz˜Àd‚À'*n¿Õ‘X¿<ß[>G¥?³²@³@;•õ@s]¥@’¼P@¢;@´@É$“@ØžÂ@Ù a@ÚM@Þ˜2@æÐM@ñô)@öÄf@í^-@ç@ä1­@ã›@àmò@Îá7@»;¢@¤¹Ä@‰º@[Ã@">X?Ð{×?5æ¾`%k¿’üiÀ\ÑÀCí)À€À:ÀŸ‰àÀ¾S†ÀÝ3HÀüN Á ËoÁ¼Á-87Á<óRÁL°qÁ\o'Ál/!Á{ñ<Á´Á‡Ó¸Áå²Áp!RÁ`\òÁP™Á@Õ°Á1EÁ!NùÁ“~Áç¬Àä£áÀÅ“§À¦ŒÀ‡™»ÀQRÀ£Œ¿­z«¾ÎÀH? 4+?¾{¦@â[@V–@ˆZ­@¥NÐ@¼ô@ÍS@à.Í@õ•>@øÀ®@ù¿Á@ý„6AwÅA„!A >sAè A!äAÝËAqŠ@ûy~@çÏÍ@ÑZ@µù@˜O@v™@;Šâ@?†›h=»ø¿^VÒ¿ê%'À2¥ªÀpÞÔÀ—ß²À·];ÀÖàOÀöfÏÁ ÷Á»¡Á*ƒêÁ:TCÁJ+ÏÁZ‘Áié,ÁyÌâÁކkÁ†—zÁ}T‚Ám~-Á]¬ÙÁMá®Á> Á.\–Á˜6ÁÔwÀþ"ÀÞ›DÀ¿nÀŸ™À€ÆÀAÇgÀ¦ô¿‹ ½î~Ñ?Yµé?æô¹@0_p@mD„@”¥2@²@ÏÛÑ@ç•,@ùÅAT÷A 9pA ©AV¡A¯ZAXåA?ÓAJ¤AÎýA¯¡A_cA 2@ü4C@ßlh@Â]Ç@¤È¿@†x?@O~Ê@2?©a(>°‚I¿$à¿Ð!rÀ'!:Àf3þÀ’¾kÀ²iBÀÒ.ÀñÉýÁÆçÁ¬¶Á(’ÀÁ8xÊÁH^ÕÁXDßÁh*éÁxóÁŒ1©Á…e#Á{^ýÁk›Á[ 9ÁKÀ×Á;ávÁ,Á"²Á CÀøÒÀÀÙ0–À¹¦òÀš¨Àu1¥À6#û¿î,Ÿ¿`"’=à Ê?‹qç@Ùf@AùÙ@€ &@žØë@½Ku@Û½þ@ù³A y4A¨ÿAWAJA£A! ‹A%L#A(iÐA$Ë;A"Œ?A!ŠA ‡ÖA@ÂAž(@ëU@̦ø@­¿Ø@ŽV@]›@UÆ?¾2>ýS[¾ýZ¿¾ `ÀšÄÀ^2ìÀŽåŠÀ®±žÀÎÀîWnÁpÁ ÀÁ'éÁ6÷oÁFísÁVãwÁfÙzÁvÏ~ÁˆN:Á`QÁu0Ági¶ÁY­ÁIÎÁ9ò_Á*þÁ3œÁ T:Àôé±ÀÕ*íÀµl*À•­fÀkÝóÀ,c«¿Ùàâ¿67Å>ŒçL?¡f8@ÉO@Nß@†úÚ@¦…ó@Ũ@ä²RAÞQA+æAY®A(åOA+æ³A-‰@A0gÀA4ieA7¸A4bA2UaA1l%A'æþAR\A„y@ñm-@ÑÑh@²5¤@’˜‡@e€@%±•?ËÆ4?=®¾ÎE¿³AcÀxÀÀYPÎÀŒ”nÀ¬€wÀÌl„ÀìX”Á"RÁ[Á&Á6\ÁFèÁUûkÁeö±Áuò•Á„¿ŽÁ{CÞÁmBXÁ_g[ÁQÂÕÁCþgÁ6NÁ(DrÁ_«ÁzäÀñ,:ÀÑb¬À±šcÀ‘àEÀdXðÀ$ø8¿Ë/¿Û&>ÉOo?±J@ë]@WL@‹Vf@ªþm@ʦ@êMÅAíeA²ñA$tA4.õA;”!A=ýA?ÁßACœÞAG"]AD ÞAB'€A8‹A(ôåA? A n©@ó$p@ÓRú@³…@“«º@g€.@'¨é?Ï£I?é¾¾ç*¿¯hTÀŽÚÀW{`À‹·žÀ«±ÁÀË«äÀë¦ÁÐÁÍ&Á%Ê8Á5ÇIÁEÄ[ÁUÁlÁe¾~ÁuÁ€|Át‹MÁf)ýÁWùžÁJAÁ<2ùÁ.^ìÁ ºÁŠ´Á±ÀíìGÀÎ"¸À®Y*ÀŽœÀ]ŒÀ f¿½Te¾údY?Dq?¾Ý‡@Ðí@^@$@Ž×­@®I@ÎFä@íþ€AÏ:A wA&uWA6F´AFÅAL°ÌAO5ARÇÌAV¢1AS¾ÙAG:‰A7£¿A(¼Ak¹AÌ^@ò T@Òì@²ó„@“¡@foh@&¯Ž?Íßh?¿i¾Äü¿°Ÿ²À³ÀWÛºÀ‹ßNÀ«ÖÀËÏÀëÈ]ÁàÎÁÝnÁ%ÚÁ5ÃÁC’AÁQ©ßÁ_âˆÁn"êÁ}^ÁnvgÁ_ÓÁQ]·ÁBþdÁ4ß«Á&ç}Á ÚÁ $“ÀûzàÀád»ÀÈ‘ÀªÎ|À‹üÀV®úÀ7ü¿¯û¾ÂÊq?tÔ?Ëå±@%J™@d¢Y@‘ý @±¨í@ÑTÍ@ñ­AVFA(ÀA'ùýA7ÉWAG“dAW`A^¼3AbAe=­AU¸êAF3 A6ŸÝA' AvjAÍ@ðIh@ÐÌ @±$ä@‘})@cªÚ@$[c?Éä×?³¹¾Ôè¶¿´Î8À1!ÀYû&ÀŒâ•À¬Ç˜À̬›Àì‘ÁïeÁ®{Á R>Á.\OÁ<¤LÁJâ†ÁY85ÁgÅ·ÁwÊÇÁhÕÁZ<ÁKeÁ<ÞªÁ.k¥Á ±Á¢Á Àëæ½ÀÐ’¡À¶YÀœ¿þÀ„p´ÀNf‚Àƒu¿¡l¾ˆ…½?9™?ÛºŠ@-(7@l@•‚ö@´úd@ÔqÑ@óé?A ³ðAzfA)F A9AHÚQAX¥þAhuAqp9Ad´NAU3ëAE—ÛA5üXA&_ÌA¾ A¸@îÎ…@ÏB¦@¯¹@) @`ÐÉ@!O€?Ó…?Œ¾ìö¿ºTÿÀÑ@À\xÀŽaÀ¨6¨ÀÃâçÀß?@Àú½‡Á A­Á‹Á'ÛÁ6"éÁD®‹ÁSe†Áb"ÀÁsÁdœÁUÁF *Á77NÁ(š[Á9ðÁ áÃÀûU¥ÀßA—ÀÂÐÀ¦æeÀ‹ÛCÀce|À0°‰ÀÜc¿ˆ†c½¼4é?c;Ä?îÿ@60"@tõÅ@™ÈÎ@¹v@ØmT@÷Ï=A œ;ASYA+ A:ÂÙAJyþAZ0ûAiçøApüAa¶ARˆýAC}žA4œPA%ðdA¸\AîÒ@î@Ü@Δ&@®Ì’@n@^„*@Ý]?¾m>ü~¿Í¿¿÷HÀlµÀCöÀz 'À™À)ÀµÛÀÑ8Àí‰FÁ9œÁcÁ!äaÁ0—ãÁ?BÁN RÁ\ý±ÁnH¤Á_ÁOÝÓÁ@ÙžÁ2NÁ#`ÛÁÞ%ÁTbÀïòÀÓ×À¸ ŽÀ›ÞåÀ\'ÀG]ÐÀß6¿µì,¿#³²>TD°?‘{@7û@Br4@€.½@ŸXä@¾”±@ݳó@üÊ&A õíA˜—A-?^A<ÇGALRÑA[î Ak–3Am¥;A^QêAO æA?ÈÎA0—žA!ŽbA¹bA*5@ëõn@Ðo@°é¯@‘o@dT@&a?п?0åà¾ó›¿aH¿ÜúrÀ'ÔzÀb‹NÀŽ+.À©žlÀÆ-=À⃩Àÿ1ÁÊÁ£]Á+jÙÁ:eöÁI‰2ÁXÌÁj»ÁZ¤§ÁK0:Á;Ì?Á,„¨Áa¹Áo#Àÿ{¿ÀâÎ@ÀƯüÀ«·@À’kEÀnù0À8ó2À)V¿‘œŠ¾}r ?) ¦?ÃÔ @­™@U¸@ˆ½@§2q@ă^@âÜ@ÿ¦bAÑÂAÛA-Y3A<˵ALTAZí?AhíAk@„A[Â}ALX~A=oA-ÒøA¨ŸA‹AŸÎ@ãÿ{@Ç—Ñ@«%@¼ð@^¸@"}n?×çC?n¡>Ÿ[Q¿潿À,®À-ØÀTªÅÀ„¶vÀŸûÝÀ¼À؇‘Àõ]Á ^ ÁFÁ'WYÁ6ŒÍÁEÎæÁU"˜Áf¹¨ÁWÊÁG[àÁ7Á÷Á(;=ÁÅ"Á UeÀô ¥ÀÕØwÀ¸>mÀ›…­À^ÀKöÀ›c¿éý0¿¡j¿Y>Ê?±>}@o™@Rðž@†ÍÈ@£ë @Á5ú@Þ­h@ü©ÁA ‹Aê6A,cA;FÊAIŒAW íAePéAiîQAZXLAJÒÈA;a¥A,9A½qA šÂ@ýE@ßz@š›@¤Íq@†Ö]@S–@M¢?§Þ[>´cܾÆU¿vRR¿Ø:$À-bÀGñÉÀzw¢À—˜¬À³ZvÀÏâhÀíMLÁ¨!Á¾ Á#á„Á3%’ÁB‡_ÁRÑÁdg=ÁT†vÁDª¾Á4ÕkÁ%TÁFÁ’†ÀëçÀÌÕ&À­ÒÙÀyÀb+¬À(8?¿ã‹â¿„ÑE¾Ý<=æèµ?¼Œ?t>D?¿lª@ …h@6h“@hª@ŽÞö@ª2"@ÃCÊ@Ü,@ö‚ˆAÙ¶A´£A$áÂA31AA·“APRZA_XAfðLAXÝÕAJwôA;ÍA,8ÄAò¾A Õ¿@ýàà@à±ô@Äd,@©aP@Œ@co@/ÈX?ü€ß?¥ƒô?=iø>60·¾õòn¿¦€[À ® ÀG{¾À‚+gÀ¡&ÁÀÀvýÀßìªÀÿu0Á…-ÁÇÁ.³Á>ZÔÁN½Áb4¼ÁRjÁB¨)Á2ñ?Á# Á&'Á./Àæm-ÀÆ‚À¦œÀ†Ä{ÀNlÀ¥¿žˆ¾ƒ ®?* ì?¾™@“Ã@ ¹@5BU@[v@ƒÎÓ@œT@¶?@ÐÔO@ìÔàA‚_AÖA!EÔA/çUA>³cAMxGA\X[A`ÊUARè©ADù‰A7 2A))]A-A ÑÁ@ýeÃ@áeI@ÅŽ@ªl@‘$@s¬@H™­@(Uw@Fd?ÉÕ ?ik½ ÿá¿€›¿ý›“À=Y–À|v ÀÞÅÀ¼Å]ÀÛ‚ÀÀúøÁ ê¦ÁŸÆÁ,b«Á'9f?‘š>?£ñÛ?Ài°@.@4Ú@hVg@ƒÌ@«gž@ÇÞ@ä‡A˳Aj¢A!ñA,ÜCA;¬ÆAJ“›AY„€AY!°AL2—A>œ¬A0ÆA"ÿûAJAvì@ó6q@×ì@ºì8@žÓ+@ƒp+@Qˆ.@ /?æª?© ï?ŸìÆ?aþ£½âZk¿…¿ñ«À3M4Àp«UÀ—ÏÀ· ÀÖ®ðÀöj¢Á ýÁÁ*õÁ:æùÁJÛÁbCïÁRSxÁBeŽÁ2zÒÁ"‘»Á©eÁÂÀå»SÀÆÇÀ¦a‰À†ÂÀNEúÀBø¿¡¾”©í? ïÈ?:¥>˜`÷?5G?Âô@çO@R3ž@…á¸@¢ðÔ@À&‘@Ý_@ú«A çAÆPA)nûA8tAF¥ðAOpœAMÐÐAC¾A7$¿A)èñAn8Aã†A<Ï@ç'‘@ËÀ‡@°~@”-Ì@p5n@8Àä@7z?•ƒ‰>Ùëä>•ø3?(nö>‡›Ð¿0í ¿×ôþÀ+¹¹Àk|âÀ•ªÀÀµ™aÀÕˆÀõv£Á ²¢Á©óÁ*¡¢Á:šªÁJ”ÌÁc6ÁSN™ÁCjUÁ3ŠØÁ#±¯ÁàäÁvÀè½ãÀÉAŸÀ©Å(ÀŠZ;ÀV!5ÀbJ¿¹ôB¿4k=<• ½Üàã¿#p9>‰g?˜K @ "@Aš6@|P(@›m„@¸{»@ÕŸa@òÃÄAưAdA$:òA1ýlA<‘6A@A>Ù6A8ÐöA.1ÛA!ïäA Aíû@ôï@ÙÒÄ@¾Ô‘@£Àû@ˆP¿@Y®¡@!Ò_?Óeø?FWü½õ†¿B‰¾€dû¾”î÷¿u½¿ï:êÀ4¼èÀr¤ÆÀ˜®šÀ¸C,À×÷`À÷¿Á ÉÏÁ¸Á+§•Á;—ÒÁK‡`Áe ÁUM<ÁE‡¹Á5Ç|Á&&ÁnjÁ×Àîž ÀϺqÀ±,™À“(QÀkçlÀ3PÕ¿ýÅ¿£eF¿fLÁ¿€§¿gÆÒ<› »?pè??î8@1®@k£÷@’Ä@¯Z~@Ëå‹@è5`AõÃA\ãA­|A'õA-ü`A0©ìA/”âA++A#mžA»ÐA ­xA4@æ7¬@ËΚ@±Cë@–Eõ@vB@@‚À@ »Ð?¥°ó>Öé¾ë¬9¿® V¿™4¿›;•¿ÔØÆÀ'MÀLBÀ‚þÀ ì²À¿@(ÀÝõfÀüü®Á‘ÁÐ1Á-òÁ=\OÁM/ÔÁgÎÁX.™ÁHž[Á9 (Á)²fÁXÔÁ ÄÀøÀÚzÀ½j\À ãÀ…ØŽÀX»lÀ+‚òÀ 꾿ñz‚¿ú?Ì¿•5#¾wÍ?*í ?Éæ­@H•@W4 @‡ÏW@£óD@¿!@Ú©@ô±ÓA)2A™AÄAï’A!BÉA \2A—ÅAB.A ÊAA(@îâ0@ÖC@¼u£@¢q @‡åþ@[@%ˆ?ßÔx?gl=0Þ÷¿R¡"¿Ù{ŽÀ àgÀ ¦ÐÀP’ÀDV•ÀqOÉÀ’8À­’jÀÊh~Àè2ÁðÁ*ÏÁ!x·Á0æ'Á@kˆÁP~Ák‡çÁ\*RÁLÞžÁ=¨ÝÁ.>Á£éÁògÁq´ÀèPéÀÌ£À²j™À™‚À‚ç À`ÂÀD`ÅÀ8jÇÀ–쿺\D¿ >,>²µä?ï_@‹@>¼¨@uU•@•^l@¯¶L@ÉûZ@ãE6@ù€´AGmA »ªAë¯Aê¢AIõA ÊäAMÇADB@ñJô@ÛD<@Ãùp@«¶@’–@qÁü@=p@Æ?§Z->ñ@̾ºç¿›˜|À–<À<²ÄÀIîÀYDwÀvž=À+±À¥Ä1À¾¦öÀÙ;œÀõ¶ÁòhÁ¦CÁ&ŽPÁ5•æÁD¼·ÁTtÁp84ÁaÁR!VÁCMÁ4­'Á&2@ÁæéÁ û‘Àù »Àß1ÀÆÈ;À°ÑÀœ ÀŒ@ŒÀ€ Àf#[À,4¿äƒâ¿g(–¼Ç m?Vle?Ø c@!Í@VQ‹@…=/@ž½@·I@Íçt@àUu@ïŠ@ú"'AÒ“A‘ÃA6‹@þ'@ô?«@ç;Ä@Ø4è@Æ"n@° ô@˜ëŠ@(!@PÎ}@×ñ?Ôv?V|´<Œ ¿Pí¿Ò°À8ÀUÙúÀ„sÀÀŠñ…À–²À§ÏðÀ¼6#ÀÒãaÀëzhÁ·ÝÁLÁTOÁ,´4Á;V’ÁJ'0ÁY‡ÁuÂÁg\ÁXkèÁIõÁ;¨˜Á-¨0Á ÎÁÛÁWÀôÀÝTÀÈ¿òÀ·xgÀ©1"ÀšÏêÀ{´oÀBÅÆÀ ÓH¿¦°¾ç{C>Å0É?›+ã@a›@5†x@gD£@‹Ãƒ@¢ @´ùo@Å5Æ@ÒÎO@ÜÙf@ãvî@濪@æb@à²à@׸@ËÒ@½õ„@­@š[@„Ϭ@[ÿ@-g?÷ó)?“š>³uä¾ìò)¿¤IdÀÇÿÀ;öÀq¬GÀ“ü`À©ßÀ³ ÀÂ2¾ÀÔ¢ ÀéQÐÁÁ 3¶ÁùJÁ&FsÁ43ÁB ÁPwÃÁ_ ·Á|,ëÁm¹Á_köÁQ]ÊÁCœ+Á68oÁ)2GÁ“çÁ »ÁH ÀõšìÀãÒ|?iÁ?ÒϾ@ø@=Âð@b-@€ž¬@ŽI€@™E0@¡£ @§,¿@ª'S@©0b@¤¨@ž",@“\é@‡ù¦@t?@SW­@0ü@è?¹äŽ?@j<ß°Á¿:{ ¿¿µþÀ0ªÀEÈqÀyšŒÀ—À±wÀËþÂÀæþuÀúëÁ¸äÁ mÐÁO(Á!ÔQÁ-,Á94oÁEºÁR¤ÜÁ_óÁm–fÁ…v»Á}CïÁoäsÁbÕ°ÁVšÁI®ŒÁ=ßrÁ2†Á'Ñ£ÁÁGxÁ ÛÀøMdÀÜæóÀÁfÀ¦•—ÀŒf§ÀdláÀ1VÇ¿ýÌ¿šÙC¾èt>ŸQ?uT)?Î4@ û;@-Ñr@J‹<@c´@x†›@ƒ„@‰"±@‹ò™@‹1â@†ô»@@n‰@W—g@>ˆÔ@ 9|?üLH?µÜ’?F«0=Ñà:¿ȹ¿¨ÿ½ÀÍÀ5"¿ÀfîˆÀ)ÝÀ¦ïÑÀÁ&ëÀÛgÀõÖÁiÐÁÃ*Á®IÁ#È¢Á-Ò4Á8nÁCÅÂÁOº§Á\*®ÁhôÍÁv}Á‰°”Áƒ>Áy1-Álƒ Á`A³ÁT,ÁI%ŽÁ>^–Á4^ŠÁ+HEÁÚµÁóGÁNØÀëlÎÀÐÁ5À¶È§Àœì¨Àƒ³<ÀU=iÀ$»¿è›H¿‹¾ÏûŒ>yæÆ?Wóå?±ë›?ð&@0@*ø@=gã@Ký¶@VBD@[RÁ@ZdÍ@R˜Z@G!ö@6#o@ø`@!S?ÕG„?–et?#rã=˜!J¿€m¿ /¿øìÙÀ*óbÀYz\À…N"Àž.‹À·¡•ÀÑQþÀëN|ÁÆDÁ÷ÁUMÁ(i Á0ÎàÁ:4QÁDXcÁO BÁZ`ÁfE†Ár þÁR¬ÁŽ=4Á‡ËLÁ‚Áv×QÁk Á_ÅOÁTïµÁJÉcÁAmõÁ3¨šÁ%Ù&ÁZÁ äñÀûzÑÀá}vÀÇÐBÀ®»À•ÊaÀz°·ÀKvEÀóÿ¿â±—¿†Ž¾ÿÑ+=?Y.?z?ƒ r?·ª?â:@ÿL@Õ+@ @+@„V@ÂÜ@ ¦ò?ù;ç?Íô ?›?P¯É>²Rñ¾@~¿1w1¿¤n¿÷ÒÅÀ&ÅŽÀS=PÀ€Ø¨À—ùtÀ°D]ÀÉÆÀâ%MÀû¾ŠÁ ¾¥Áè-Á%%Á2bÁ>IrÁG CÁP«nÁZãüÁe¥ŒÁpüVÁ|ÔHÁ„÷Á“ŠÁŒÅ"Á†·dÁ€ß…Áve:ÁkƒÍÁa>þÁV ÔÁH¹TÁ;…Á-”sÁ -´Á!=Á%KÀòÐIÀÙµÀÀÿpÀ¨ÜrÀ‘HÀtT#ÀH²&Àê@¿ìO¿¥j ¿>ʾ…¯Ã>(W–? Àó?^U?Oî?ª6?»«¾?˜d? ”?µ™? Ÿ?„wí?<¸c>º§§½ô¾ýÆ¿yÿ-¿½æTÀÞBÀ)B$ÀRëBÀ}įÀ•HÀ¬/[ÀÃ9°ÀÛB¶Àóü\ÁpŒÁ6xÁ |Á-†Á:VxÁG“kÁTRÁ]]ÃÁg*¤ÁqsƒÁ|BœÁƒÌ€Á‰²üÁ˜ +Á’ÕÁŒ/ŽÁ†‚¡Á Áw¼mÁk»%Á]æ°ÁPUWÁBÒÀÁ5ŠÁ(›¾ÁÀôÁyÁ‹ÑÀì™FÀÔ|ÝÀ¼Ò¤À¦0*À þÀv9ÀMmÒÀ'ï À»¿É““¿BB¿3Gf¾¯ºÊ½¹h>Q݃>Ì;?Må?W¥?pö>ö,>¤‘=ùC;¾aã¾ý(¿g¼¿«-÷¿æ$ ÀÁCÀ4ôÀXu»À€&£À”ö¥ÀªvÿÀÀe÷À×u&Àî’±Á<…Á}ÞÁÚåÁ(œ7Á5vOÁB\pÁO‹ Á\ÐàÁj#ÂÁs½ÛÁ}¯KÁ„üÁ‰p!Á$ÁPÔÁ—ŸÁ‘Ò±ÁŒYÁ‡ÞÁ€lÐÁs‡Áe\ÁX@æÁKlÁ><`Á1b‡Á$Æ—Á_XÁ ‰ÁwÀ莊ÀÒBÏÀ¼‘À¦œÀ’v À~køÀYìFÀ9TrÀÍK¿ü^¿ÉËI¿ž¡v¿qç¿¿7òø¿‘ž¾Ò“?¾¹ý¾Á‚@¾ë–¨¿ìÙ¿N_¿‡ÿb¿¯‚ý¿áÄþÀ ÍcÀ(©jÀG;%ÀgMÀ„ÀÀ—†šÀ«ª)ÀÀÀÖ ÂÀëôQÁrüÁ ÅÁíÁÁ%*UÁ1hlÁ>žÁJëÁWÂNÁdÈ­Ár†ÁihÁ…nÁŠoÁMTÁ”¿.Á¢Ï·Á"ÊÁ—¥¥Á‘òhÁ‹nÁ„7gÁ{uÁmäZÁ`Í»ÁSå¥ÁG ·Á:’;Á.4˜Á!òoÁóÁÁ F3ÀýùmÀçÜfÀÒPÀ¾5*ÀªwØÀ˜/ÌÀ†¿KÀmÇòÀPM«À5p;Àj†À ˜¿î¯¿Ò À¿»Ùe¿­©¿¦½¿©ß“¿³aI¿Æ£Þ¿ÞÈ¿üÖÀGÀ(ÍÀBŠÀ^,À|$ÀØ ÀêåÀ¯ý ÀÂÌXÀ×;Àì*§Áå Á á}Á>ÌÁ"º1Á.ž8Á:ÍSÁGzÁS”õÁ`jÁmFoÁz<7Áƒ»UÁŠ_‘ÁNÁ•]QÁš˜ŒÁ¨rëÁ¢òÇÁœ“ÓÁ•·6ÁŽøåÁˆ\kÁÌÁv~+Ái’Á\ÒºÁPiÔÁD bÁ7ÇÁ+òìÁ QsÁÕæÁ Û Àþ*ïÀéòÀÕ÷µÀÃl<À±~‘À é›À‘Àƒ¾QÀmªÀVƒ_ÀBãWÀ2'JÀ$<À¸ÀV¨ÀâlÀa[À4oÀ¨ìÀ*zÔÀ9&sÀJÌÀ_mßÀyRüÀŠeíÀ˜åÀ§¾À·•ÀÈ*ÀÚß Àî8eÁ}¤Á þxÁƹÁ!ÈÑÁ-%¦Á8ŠÁDeßÁPyÐÁ\¡RÁi•Áuõ±ÁlÝÁ‡çIÁŽwÁ• Á›‹Á ¡iÁ®1ßÁ§LÁ ~SÁ™Ë²Á“5ÁŒ¥ãÁ†»ÁA÷Ár¤ÁfC™ÁYí0ÁMºþÁAý)Á6[MÁ*ÌÌÁÑRÁ\Á ÖÁÎÀÀÜt»ÀË|yÀ»CçÀ­ËÀŸ5%À’âíÀˆgÀ}yÐÀmóÀ_ÖàÀUÑÀO£ÀL—VÀN*GÀRÈÌÀ[´úÀeÿÀsÕ»À‚NtÀ‹­’À˜AíÀ¥VÀ³³ÀÂÃÀÑQ@ÀáóÂÀóNGÁåÜÁ ù²Á]Á!ç¸Á,¨dÁ7°&ÁC úÁNoÄÁZCkÁfN=ÁraÙÁ~ÎtÁ…ÆÃÁŒ6‚Á’°ŸÁ™=ÆÁŸÕÁ¦yÁ²NÁ«L×Á¤¡8ÁžaÁ—~óÁñÅÁŠ‚¹Á„?wÁ|/$Áoï\ÁcÅ€ÁWÿäÁL\¸Á@ß.Á5ÌÜÁ*ùeÁ ³ÁŸ°Á ÅÁÊðÀö:¶Àå§ÀÖu ÀÈ'mÀ»7pÀ¯2²À¤ñ¿Àœ&JÀ”70ÀâÀ‰VªÀ…ö)À„²?À…·À‡ž À‹’ˆÀÇZÀ—BÒÀŸC{À¨¯vÀ´OÀÀ¶´ÀÎ\xÀÝÆvÀì+Àûc÷ÁWÁ `ÁŒUÁ"ÚbÁ-=^Á7ÐùÁBŠÁM—zÁXó ÁdUƒÁp ùÁ|+ýÁ„#FÁŠRÝÁ¢nÁ—,ÁzÁ¤ôÁª•Á¶\Á¯wõÁ¨èÁ¢] Á›Ù Á•t‰Á9fÁ‰zÁ‚üÁyÐHÁnÝÁb^"ÁVôýÁKáÁ@íÜÁ6ŽGÁ,rŽÁ"ÀÔÁiƒÁ•–ÁØÁ7pÀñ¯ØÀã½ÈÀ×>wÀÌ ÐÀÁìŸÀ¹tzÀ² ŒÀ«ëúÀ§Å†À¤'À£ ^À£æÀ¥ê±À©ÃLÀ®+À´ö;À¼9ÀÅÜ1ÀІ=Àܸ#ÀéUÆÀøŽÈÁÍuÁ å£Á%üÁÀhÁ$˜DÁ.cªÁ8»ÁC<ÁMº9ÁXkÃÁc~ÉÁnØÉÁz;KÁ‚ÿÂÁ‰ ‡Á‘Á•FXÁ›ŒóÁ¡Þ±Á¨K£Á®Ò{ÁºT½Á³Ì£Á­IÁ¦ÎOÁ stÁš?DÁ”MÁŽUÁ‡í‰Á‚ëÁxdOÁm ÁaûsÁVõÃÁLwÁBLoÁ8}^Á/$’Á& Á|)Ái™Á µ:Á|ÇÀÿͰÀóž¶ÀèéIÀß'TÀÖõ[ÀÏÜÀÊ$ëÀÅøÐÀÂÆÀÁ’yÀÂ8«ÀÄ(ŒÀÇð ÀÌh[ÀÒ´{ÀÙ…=ÀãëÀíÚÀù5ÈÁª!Á ”EÁ[áÁ…aÁ :kÁ(µíÁ1DcÁ:ežÁDa‹ÁN¤œÁXÿÁc¥AÁnXÁyvŸÁ‚f.Áˆ.Áø=Á”òÁšâÁ :<Á¦ýÁ¬Ç&Á³+AÁ¾½qÁ¸@èÁ±ÎÁ«yÙÁ¥HÓÁŸ$¦Á™(Á’òîÁ çÁ‡=ïÁ“ÔÁx'Ám Áb{ÁXGõÁNKºÁDêÁ;µÁ3Á*¤íÁ"ÔßÁQÁc Á ïDÁ'ÏÁïøÀütÀôÇWÀí°JÀè[2ÀäBÀá†GÀßÿNÀà„´Àâ:XÀåü˜ÀêadÀðnµÀ÷<ìÁÉÁ kÁ ÉiÁéÁU¢ÁÁÁ&;OÁ-¨ Á5ÍRÁ>R,ÁF÷¥ÁP` ÁZnæÁd vÁnú}Áy§5Á‚0õÁ‡Ä¤Ám&Á“ÕÁ˜ý‚ÁžûÔÁ¥7Á«.sÁ±o¹Á·²¬ÁÃ>Á¼Ð%Á¶€çÁ°RdÁª-›Á¤ üÁøTÁ˜êÁ’NpÁŒ§KÁ‡DÁ’¾ÁxHÁnU°ÁdA®ÁZ¯ÁQiÊÁH«OÁ@cÁ8^Á0BwÁ)Á"OŒÁ+ÛÁ„/ÁsÚÁ çiÁ MpÁËrÁIŽÁ+¢Á"ºÀþZÂÀþÚôÁ:2ÁýNÁ-¥ÁÐÁ †»Áƒ¦Á‰(ÁødÁ&Á%eŒÁ,]3Á3ÖÁÁ;0ßÁCeÁKhrÁSòCÁ\Ú‘ÁfyªÁp‡9Áz©éÁ‚‰Á‡à]ÁAÔÁ’Ø[Á˜~wÁž.âÁ¤ ¤ÁªoÁ°aÁ¶%ÙÁ¼^åÁÇÓ=ÁÁˆaÁ»\Áµ7;Á¯fÁ©Á£ŠÁbÁ—¿LÁ’"DÁŒž¯Á‡P5Á‚2.ÁzGÁp‹bÁg&NÁ^H—ÁUÁMV ÁEyñÁ=Ø2Á6þïÁ0WKÁ*~³Á% ŸÁùÁÁœÁ6ZÁÍáÁh-ÁfáÁNâÁ[Á¢9ÁefÁiÁ4cÁ ÜÁlÁ'¾Á" —Á'MÁ-SþÁ3ˆ_Á:P÷ÁAsÎÁHÏ¥ÁPÆÁX¨kÁa;Ái¸iÁrà?Á|šÞÁƒSÏÁˆ`IÁŸÁ’ö>Á˜Z¾Áò£Á£——Á©E‘Á¯BÁµ Á»”ÁÁ&¸ÁÌ“íÁÆj­ÁÀEUÁº ”Á´–Á®0ïÁ¨yºÁ¢×vÁ5ˆÁ—«,Á’YJÁ:ºÁˆ(±ÁƒB>Á|ì±ÁsçœÁk5åÁbÇéÁZ¼æÁRòøÁK±úÁDììÁ>“iÁ8ÔeÁ3¤èÁ.¨¹Á*¦Á'…Á#îlÁ!—Á¶¶ÁzÁ’'ÁÝÁ§WÁ -QÁ"IAÁ$ÿÁ(INÁ+ö¸Á0‹þÁ5ÅÁ;„^ÁA·”ÁHS™ÁOK ÁV‰ïÁ]øJÁfHÁn2ÆÁv±ÈÁ¤]Á„zYÁ‰^PÁŽeÁ“tõÁ˜»—Áž ÛÁ£t”Á© TÁ®²HÁ´]bÁº(ëÁÀÜÁÆ’ÁÑ|šÁËW>ÁÅ6CÁ¿.SÁ¹L‘Á³“ƒÁ­ðµÁ¨M÷Á¢¾ÚÁe(Á˜CiÁ“/½ÁŽ@îÁ‰iÁ„ËaÁ€i6ÁxAÊÁp¡Áh.¶Á`£ìÁYœ{ÁS AÁL׌ÁGZ#ÁB6èÁ=}dÁ9Š…Á6)³Á3mÁ0ÉîÁ/ÄÁ-á¸Á,ëjÁ-%Á-ìÁ/WÁ1_ÐÁ3öîÁ7&†Á:æZÁ?1CÁDGÁI»¢ÁOèKÁVTÁ]0ÁdD?Ák®àÁscÔÁ{ÖÁãËÁ†BçÁŠÕÁ…ÓÁ”oiÁ™uÆÁžŒ›Á£ØÒÁ©#½Á®Ž‡Á´(Á¹Í9Á¿v ÁÅ;HÁË ÚÁÚ¢hÁÔDÂÁÎÙÁÇâÔÁÁä¹Á¼ Á¶M+Á°§OÁ«.¶Á¥éŒÁ ·µÁ›§ÞÁ–Ù7Á’GÁÉßÁ‰poÁ…h«ÁtŽÁzýüÁsÔtÁjYÁ^6ÁR—mÁGOÁ<ôæÁ3ÇÁ)åKÁ!ÈVÁº ÁŠfÁÛÁ sÁ OˆÁ »òÁ `PÁ ÏJÁ©ÉÁÊÅÁï’Á#IUÁ+Ñ Á5 Á?aÁI¹sÁUÁ`àÁgVŒÁm³LÁt¯ÞÁ{ÓHÁºÕÁ…ÎÁŠ9CÁŽÄ˜Á“’¶Á˜¥Áâ…Á£<‹Á¨¹SÁ®\×Á´!8Áº§ÁÀ¼ÁÆ0ÁÌ]oÁÖ8ÁÏŸÎÁÉ@ÁÂøÀÁ¼Ò¼Á¶ÑkÁ°øˆÁ«C_Á¥¦ÁÁ 4>Áš÷ÔÁ•ÍÁÌŸÁŒÁ‡†’Áƒ±Á}ºÞÁuü'Án Áf„ÈÁ_·ÁUˆÁIZeÁ=¶Á2½’Á(b­Á–ÐÁÝDÁDÁÉäÁsßÀýY\Àø™^À÷ƒÀùfÀþ„¿ÁG.ÁË.Á§ÃÁ–Á §°Á*L{Á4ÌüÁ@ÁKé8ÁS·¿ÁYÆ_Á`‚Ág]YÁnÍ™Áv™;Á)Á„–Áˆº¡Á½1Á’äRÁ˜2TÁ§ŠÁ£DKÁ©.Á®ùÁµ€Á»ÁÁO½ÁÇ£DÁÑ|4ÁËJÁÄŸZÁ¾C`Á·öÁ±Ê»Á«ÆÁ¥ìJÁ ?\Áš°¦Á•F˜Á+ÁŠòŽÁ†¾ÁaÁy´Áp÷ÐÁhÜÁa\ÎÁY‡ÁRwÁL yÁ@ÞdÁ4­MÁ)Á4ÁôÁ ¾{ÁQÎÀö£{Àê÷¸ÀâÈÀÝÀÛtµÀÝÔ]ÀäúÀìãÀøÊêÁÍ©Á Q´Áý‘Á J”Á+`wÁ7ÜÁ@˜»ÁFe¹ÁLmÁSAÅÁZ$­Áaæ6ÁjïÁr¹IÁ{ïiÁ‚æÁ‡ó˜Á1šÁ’ŸÁ˜36ÁöÈÁ£êqÁ©úqÁ°>Á¶J8Á¼¥„ÁÿÁÍ%ÕÁƈ¼ÁÀ§Á¹¡oÁ³JŽÁ¬ýhÁ¦ÌiÁ ÄNÁšéßÁ•BkÁÄ3ÁŠhÎÁ…A(Á€,%Ávª¡Ám{8Ád’JÁ\ ÿÁTY‡ÁLözÁEynÁ>ÝuÁ9BÁ,„ÍÁ €ŽÁÛ^Á ùPÁ"ªÀîAàÀÞ•!ÀÑqÎÀÇÌÀÁø‰ÀÀ»ÀÂD¬ÀÉdÀÓ)Àà®àÀñÁÝwÁ õhÁªÁ":rÁ.#ÕÁ3_òÁ9[Á>«=ÁE!JÁLwxÁTŸ1Á]cØÁfŸ¸ÁpK=Áz'ÃÁ‚=ÐÁ‡ ÌÁ,(Á’îöÁ˜ãTÁžóoÁ¥¼Á«NtÁ±²"Á¸3Á¾ºuÁÉ ÁÂHÁ» IÁµRÁ®§ZÁ¨U†Á¢òÁ›ÙÔÁ•Î@Áó‰ÁŠOáÁ„ã•Á2@ÁtævÁjñ¤Áa‰5ÁX`ýÁO¯&ÁGÓÁ@P´Á8îeÁ2àÁ+ÿ8Á$övÁvZÁ >ÁÊÀìZÀØâÀÇN•À¸ÖÑÀ­ËÆÀ§‹À¤ÅÃÀ§H À¯”ÆÀºÐPÀÉUÃÀÛK²ÀïÀRÁcoÁ ÍÜÁ ˜Á! óÁ%¨%Á*™*Á0„/Á7HCÁ?ÁGœåÁPêQÁZæ Ád†?Án«ÖÁy^kÁ‚1­Á‡ïJÁÞËÁ“õÁšÁ ^rÁ¦Ë(Á­PÁ³Õ€Áº,‡ÁÅÍÁ¾ENÁ·x@Á°ÄåÁª.HÁ£·ãÁeÁ—&©Áõ¤ÁŠæ¬Á… CÁ~ÛQÁt!óÁi”‰Á_^¤ÁU·™ÁL‹¯ÁC›ÃÁ;&ÛÁ3w(Á,¢'Á%‘áÁGýÁÞÁ5õÁ…&Àð¬ßÀÚXÀÄå?À±*NÀ¡ XÀ”owÀŒƒ;ÀŠ {À;ÛÀ•œùÀ¢ÑkÀ²ú]ÀÇÎÀܽJÀó€‰ÁéíÁ¯ ÁïÕÁ)ÁJÁ"|ÇÁ)É Á2¸Á; îÁD×YÁNõàÁXîÃÁc'ÁnäÁyéÁ‚åQÁˆûvÁ+åÁ•|ÆÁ›òâÁ¢s(Á¨½Á®îˆÁµ@·ÁÁFÁºe×Á³ŽPÁ¬¸×Á¥ù ÁŸWÁ˜Ö…Á’{öÁŒEÁ† Á€EÁtp0Ái@ËÁ^’ÀÁT¤ÁIÿÁ@²œÁ7±Á/F¢Á')Á FÁVEÁ aÁ \ÀÁ‰.Àû<Àá;€ÀÈÑ+À² yÀœ#ÐÀ‰ñ Àv˜ÐÀdš¤À_@ ÀedCÀyµ@ÀŠ÷@Àž{À²÷dÀÊ}.ÀäŸÀþãÁ\ÍÁPÁºUÁ@ÇÁÛLÁ—0Á%d+Á.íôÁ9;KÁCGÝÁM¯õÁXÁd šÁoåÁ|FÁ„IÎÁЬ*Á‘(ÜÁ—g˜Áx Á£²sÁª èÁ°h=Á½I•Á¶‚×Á¯¸ŒÁ¨â[Á¢  Á›@;Á”‘çÁŽÁ‡£ÁmEÁv«ÙÁj¦&Á^ù.ÁSÝÁI1 Á>¬Á4äÁ+ãuÁ#ApÁ_ûÁeçÁ ‡#ÁÁAÓÀøæÀïŒóÀÓÊ'À¹,À +¾Àˆ(²ÀfýQÀFŸÀ1mÀ*¯&À2éßÀHò“ÀkÚÀ‰ÕÀ¡MÀºwzÀÔßõÀâJ¿Àå±iÀìÀÀõN—ÁwØÁ:Áê Á9NÁ#JÃÁ-Õ“Á8?ÁBäNÁNH%ÁZÁfC‘ÁrçAÁÉ*Á†6ÁŒéÁ’5ùÁ˜xzÁž×Á¥.GÁ«’Á¹cÁ²@ÌÁ«‚€Á¤ÛÁž(Á—pjÁžlÁ‰ã ÁƒLÁy¾½ÁmGmÁa5ÁUZhÁIÀ½Á>ºÁ4 Á)«(Á 4|Á•ðÁ­ÂÁ=ïÀý‘ûÀñºêÀèrÀßGÀÙþkÀÇ0BÀ«8DÀ,!Àm¬ŽÀ>ÇÀóÕ¿þsŸ¿ìý}À9ÀÿÀA‚‘Àp®À‘1lÀ¬ÂÀÅp°ÀÅÉÀÉLoÀÐÆÀÙÅ‚ÀæIüÀõ¦ÖÁ·gÁ Š@Á:¶Á"´3Á-b€Á8´æÁDgƒÁP¥6Á]VÃÁj(±ÁuÑâÁ€ÔåÁ†õ}ÁAÁ“¢UÁ™öÉÁ fÔÁ¦ùxÁ´É‰Á­ùÁÁ§8ÉÁ tXÁ™ÁnÁ“)1ÁŒ¦ÙÁ†ÞÁ~ (ÁqZ/Ádm¼ÁWêãÁKáçÁ@4Á4§Á)¤ÙÁ#ÒÁ$Á QÁµ½ÀòãÀãDøÀÕú›ÀÌ`ÉÀÃtuÀ½ÞÀ»µ ÀŸg°ÀƒIdÀOŠãÀó3¿ÞÊÙ¿¿i¿ƒÔô¿žÄŸ¿à•¨Às!ÀP¯Àƒ9hÀŸµ/Àª À©þôÀ­ûTÀ´ÍÏÀ¿mpÀÌÇ ÀÝ>†Àð94Á˜HÁ y›Áý?Á#NºÁ.ýºÁ;<)ÁGÓVÁSØ'Á_7ËÁk²ÁwméÁ‚ *ÁˆkrÁŽÃÁ•AÁ›âëÁ¢¤HÁ°ËÁ©ÕÁ¢õ Áœ. Á•làÁŽ­ÁˆºÁ„>ÁvICÁi¯¾Á\bÎÁOaºÁBÂIÁ6–Á*ä™Á‡ºÁ·˜Á °ÜÁ>@ÀîíÀÚóŸÀÉ¢ÜÀ»€fÀ±(À§SÀŸÉCÀ›î@À”âSÀo×âÀ6ÍÀ¿þU¿”óî¿̾e»<¾ü<~¿‘½¿øÝÀ42sÀn¯ÀÀŽ«cÀ)¡À“ÕÀ›=À¦+|À´‹üÀÆo@ÀÚ¹ÖÀðäÆÁôˆÁžÁºþÁ%îæÁ22Á=@}ÁHæÁT Á`õ•Ám®ÁÁzb§Áƒ”BÁŠ""ÁÕ7Á—£ÁžvÕÁ­•Á¥õòÁží Á—ûDÁ‘$8ÁŠbqÁƒŸ9ÁyÚÁl¸MÁ_ä¶ÁSm–ÁG"NÁ:vÁ-¬žÁ![—Á¼öÁ Á:ÁWGÀí”ÀÙT×ÀÄiþÀ±žÃÀ¢AÀ”ÑzÀ‰ÃÀ€±îÀx^èÀwÃ[ÀYÜvÀ úæ¿ÎƒL¿9 ì=ÒZ¨?'->8Ž¿!-†¿Ã.‚ÀnÅÀSU™Àa­íÀ^nbÀcpÓÀqWZÀ‚ëIÀŽŒÔÀžKÀ±aÊÀÆÉ"ÀÜŠÀòAËÁ·$Áo©Áš¯Á&©Á2GÁ>€ÁJƒ’ÁWE/ÁcðàÁp×Á~¢Á…ÑœÁŒ£Á“€rÁšo>Á©TÁ¢_rÁ›1DÁ”aÁ³Á†#áÁ~¯cÁq-­Ác¯+ÁVpÁI„(Á<üVÁ0·–Á$€dÁ¯÷Á âÁþ¯ÀìôBÀÙ|¿ÀÅ{¼À¯† À›Ð5À‰´ÀpãÀVWLÀCY¨À9%¶À8oTÀ9€_À‡ð¿¡M6¾¿<›?í9?ªAm?,vw¾]¥¿xë¿ûŸ€À,@3À$ -ÀŦÀ%»õÀ5o„ÀNsÀnÿ À‰Ó6Àä[À´"ÀÈäÀßhpÀóîÁ}Á±ÁkÅÁ'iÁ4ØÁ@ÛœÁMˆÚÁZ•µÁh0Áu ÈÁª=Áˆ” Á—XÁ–³ÒÁ¦#üÁžâÁ—¯Á~Á‰N¤Á‚2ÆÁvc5ÁhŸéÁ[0ÁM”¡Á@2¸Á3)Á&ŒÁHÍÁøÁRÀîkÀØÒ¾ÀÄŠ À± ’ÀœTWÀ†P]À`©À9óÀfnÀ<Ä¿ô†S¿ò\ŽÀ?¿Ðfî¿ZÕ» ‚?a‘â?ã½­?Œð¿>^Å•¿"ǽ¿²>пìÜ•¿Îóò¿Å“¿Ð朿õ™ýÀ®}À¸XÏ?šÝ‰@×Ï?Æ68?8Î6½©¿'à¿j3g¿6ˆî¿{v¿3ÜŠ¿…Á¿ÇGÓÀ l„ÀuŒ¾ˆÏ¼ ‘¼<Õ_4¾e!¾‘qÑ=CQy?8;S?Âm@g@Ï??¥‚¾?G…>~ =x¸^>:Í6>‰)Â>F~J¾UêI¿Q©¿Ä‚À »À3F÷ÀZa‹À‚±‡À˜¯À¯a8ÀÈ2¸Àá¸AÀû?Á ¼úÁXÓÁ&`Á4òÁB'ÊÁP+Á_ƒÁm´FÁ|TÁ…‚ÁŒë°ÁG¼Á•Á±ÁŽHãÁ†×…Á~ÌÃÁoêÑÁa!gÁR…dÁDuÁ5¸0Á'M«Á!ÐÁ VâÀû¨•Àà³_ÀÆž<À­å0À•SÀ{¨ÀQÓÀ(m]ÀN¿Âl ¿@‚K½P"I?úu?R)f?kÊ'?R«œ?4íÊ?Rôµ?¥r¥?ühu@/·›@&²5?õùï?®TŠ?ˆ²ñ?‡Ô?‘~B?’r¬?…Rà? ¶3¾¤P¿I\k¿´ƒÀ5=À++ ÀW&&À‚@À›_“À´ÞñÀÎsŒÀékÁi×ÁPŠÁhyÁ,Ò·Á;c4ÁI÷˜ÁX˜‰ÁgUÁv9èÁ‚ ÁŠ)ìÁšÇlÁ“(ÑÁ‹ÃÁƒþÁx÷¾Áj6Á[-ðÁLK©Á=qÇÁ.ÇÅÁ XèÁõ'Áˆ—ÀêËÀÏ}™À´yÌÀ™èMÀ ÀP6ÇÀ!Ù=¿ñj¿£RF¿Bt6¾,c¢?Šc?Ÿ½Ù?Ôjg?î#Ì?æ•d?Ùus?áä@;#@)AÄ@Ské@OÚv@*Ÿ@¼r@Ðø@ŸZ@xƒ@¯D?ð+?¡`à?¿–¼)i¿ 7ç¿¡æ¿ùåyÀ*O‰À]ÜÀ‡öxÀ¢&À½xŒÀÙA…ÀõS@Á IÁ¦åÁ&:îÁ4ß+ÁC®‹ÁRª|Áa½ÈÁpÑcÁæ§Á‡ˆtÁ˜WyÁ´ÂÁ‰XÁ|PÁs»kÁd…ÁUj5ÁFrÁ7Á(¬ÖÁʰÁ eÀù.·ÀÜd:À¿‡dÀ£bXÀˆO2ÀZ«0À(!ž¿ìŸ€¿‘\ ¾ýºÃ<̰M? EE?Ÿ/B?û¬3@"š$@3«@2Œ™@,A@/=@?£‡@\ˆd@€c±@å2@`¤ˆ@Kªh@B)y@C[@F¥à@AÄP@*‘³@˜Ë?²9Å?DeÙ>OÈ¿ ª¿ ÏÀr’À6=wÀlE»À‘áöÀ­×¨ÀʳóÀçÕ+Á~IÁ,wÁ ˆÁ/'ÍÁ>;[ÁMO]Á\xµÁk½Á{xÁ…)^Á–30ÁŽu’Á†½cÁ~øÁnÒ!Á_œŸÁPbiÁA%3Á1îÎÁ"Û[ÁðçÁÀìWxÀΫ4À±«À”Þ&Àoý6À8HmÀA”¿œu/¾ãEÌ>ƒ}R?`T?ª;$?÷o@)up@Wû…@q‘}@r1¨@l@{@n¦@{u@‰µµ@™ÿ¼@š{@Xˆ@„3@€ê @—@‚Öª@@[Ãò@3E@ P©?Æaä?]½>ìš¿'1¿»mÀÏÀLÅ!Àƒ;UÀ \ŒÀ½ƒbÀÛ ìÀù$Á ¥tÁ¸÷Á)àÌÁ9'¬ÁHrTÁW½òÁg UÁv[äÁ‚à|Á”1™ÁŒr9Á„³0ÁyêÁjnüÁZôÜÁK‹Á<;%Á-ÁÌ1ÁŽüÀþ±¨Àà§ÀÂßsÀ¥ÒÀ‡UEÀTQÀ°&¿Áàõ¿'®u>=¤Ø?uù4?Ó·@ Ah@,2@UÆ@×T@–åÀ@˜þ@•x@–,k@œE@¦‹I@´Ïö@¶Å@«i¦@£Á@ Ð:@¡xF@¢o´@šÞ‹@†Y›@d@»^{¿ Z¿»AoÀì{ÀV8¸À‰fÜÀ§úÀÆ‘WÀå+«ÁäfÁK8Á Ï÷Á0j¼Á@ ÁOÃsÁ_qÜÁo FÁ~ίÁãÁÁ‰BÁ"yÁr…æÁbÏLÁS#ÁCƒ‘Á3ôCÁ$tTÁõ”ÁwxÀë÷¬ÀÍhÀ®"kÀ¨ÕÀbÀ%Š2¿Ñ¨/¿5*>d¨+?“v¹@h'@<Ç)@qR¢@ŒÍ@›æ…@¯8=@Ĺ@ÖÛ£@Óä¸@Ôd@ÙF@â Å@íÄ@ñ¿@è“x@âÉÄ@à²@á_È@à%@Ì1@·ÓÞ@£ï@‹Ô@_|ì@&Sæ?×ï±?A™a¾>^I¿ðËÀŸ­ÀBÕ5À€¦Àž´ À½ºÀÝ‘Àü]PÁ ÝÁ‹{Á-9äÁ<èMÁL˜FÁ\OÁl Á{Ï@Á€öÁ‡ vÁ€Áo¿OÁ_þŒÁP=ÊÁ@}Á0»¥Á ÷°Á<·Á‘„Àãù2ÀÄùÉÀ¥üIÀ‡(ÀPÉÀ#B¿©âʾÁ"V?:´?Âa9@¿ê@XO7@‰:'@¥‘ü@·M‚@Èb@Ü-˜@ñçÐ@ói¨@óØ‘@ø=óAƒA¦kAü;AÒA=¹ANA~@ù Y@ä³}@Ð,ü@·W@šŽž@zªš@>lï@Üí?‰Y{=î”Ï¿W ÿçn-À2gtÀq!À—í_À·J1ÀÖ§Àö SÁ ÁÂÁ€ÓÁ*GšÁ:ÁIíÁYÈKÁi§¢ÁyŠNÁŽBJÁ†UÁ|ÔIÁmÁ]:¤ÁMx/Á=·mÁ-öªÁ5èÁu&ÀýhÆÀÝçBÀ¾eÀžÜRÀ~¬¬À@À׿ˆ5¬½ÄX?_/?êÝÁ@2;û@o'Œ@•š©@³bO@ÐÀ:@â½ö@ô¨ AžbA …ƒA ¶™A ¸žA0ÍAPcAE¬AsäA(A÷æA%¿AÒ@ý^\@áóI@Ä_á@¦X@‡{L@Q¾‚@ë¸?ªd'>³Ãu¿!Ù¿Íõ¶À%ÚÀdÔîÀ‘îYÀ±”»ÀÑR`ÀñÎÁt]ÁZSÁ(@HÁ8&>ÁH 4ÁWòÍÁgÛ1ÁwÅÁ‹\ÒÁ„”´Áz¼ Ájà“Á[†ÁK(xÁ;LkÁ+p^Á”DÁ ½óÀ÷á+ÀØ\ À¸Ú‡À™YÀs®ûÀ4«ñ¿ëQпZ–Ã>¼ê?Žúœ@Çæ@CÂç@€Ýg@ŸÔª@¾N @ÜÀ5@úA[9A¸òA`AŒA` A‡A#,A&ž‡A#(A!¥A²ÔAR¸A«úAž#@ì :@Í @®eÍ@û@_Rí@ X ?–ƒ?ͪ¾ï#d¿ºø‡ÀÀ\«ñÀŽ!äÀ­òÀÍÇìÀíž5Á½‰Á¯°Á&¤~Á6›@ÁF“ÁV‹Áf‚åÁvzÿÁ‡iÜÁ€rÁs4VÁe¬ÁX\NÁI&¬Á9IxÁ)muÁ‘qÁ µmÀó²ÓÀÓúËÀ´BÄÀ”мÀi™+À*¤¿ÕF#¿.=Ë>›œ·?¤íA@yª@P|³@‡¿ã@§H @ÆÐà@åÐQAfA¿"A…ÛA'-¼A)iuA+A-üÌA2:OA6uA2éšA0ÈÖA/z?A(DzAIA aB@óM@Ó8b@³lv@“ ‹@g V@'ÒL?Ïås? F9¾¾Ä~¿¯…\À¬ÌÀW–êÀ‹À„À«µ“À˪¢À럱ÁÊ`ÁÄèÁ%¿oÁ5¹ùÁEµÁU°¯Áe¬ãÁu©‚ÁƒÌÃÁyT Ák5Á]WsÁO³KÁBDÞÁ4ñjÁ'ŽÁ¬XÁÊ‘ÀïÑ“ÀÐÀ°JwÀ†úÀašÀ"*€¿Åtã¿ )‰>á-f?·-¤@Y@Z‘à@³@¬Æw@ÌN@ëÏ£A¨”Ai[A%--A3ÍãA9LÕA:Ñ_A=‰AAojAEž‡ABµ]A@~,A:‰A*ŠtA‹àA L@õo@Õ G@µ#@•%÷@jQŸ@*WO?Ô¹þ?)н¾¬½¿«#áÀŒ@ÀU†ÀŠÀpÀª½˜ÀʺÀÀê·èÁZˆÁYÁ%W°Á5VDÁETßÁUSÁe%WÁsCWÁ€|Árd‡Ád=ÁU·ûÁG¤¬Á9ÜRÁ,BFÁÙJÁôÁÒ:Àì0½ÀÌh|À¬¢ÀŒÞÀZ4ðÀ­Ó¿¶Mm¾ÜüÎ?ž ?ÆÝ?@"õ¼@b|Ù@øb@°°i@Ðhq@ð"+AðwAÏÙA'¯;A7ŽœAGmþAJšÊAM'(APÂÜAU:åARˆëAJS7A:bšA*r¡A€A ƒþ@õ½@Õ}@µ>@•"ÿ@jOÃ@*WÚ?Ô¿â?) !¾¬¿«“À²ÀUw›ÀŠ·ÂÀª³¶Àʯ«À꫟ÁSÊÁQÄÁ%O¾Á3ƺÁAŠ×ÁOGÁ]äÿÁl(ÍÁ{ UÁl@LÁ]w‹ÁNÝ"Á@wºÁ2-Á$,ÁiÁèBÀöÐÀÜØ;ÀÄrÀ¨û0À‰B¤ÀS/À£¿¨cü¾¦+?*Þæ?Ô•¬@)Ýó@iq@”‚@´K¤@Ô3@óÞÁA Ô(A¸ïA)™A9pˆAIIiAY%1A\ÓAA`.kAdœIAYMÌAI—ÅA9Ê^A)ãˆAü²A  @ôB=@Ô]:@´p´@”}Q@iÛ@)-?ÒŒ?%~ ¾´9ô¿¬é¿ÀmXÀVe×À‹/+À«+kÀË'«ÀêæÚÁæMÁE ÁïÁ,ÝÁ:QzÁH†ÁW ãÁe³£Áu¦9ÁfšfÁW£ÜÁHÖBÁ:êÁ+p,ÁàÁÀ;ÁÐÚÀæ9rÀÊåFÀ°GÔÀ—#‘ÀÓwÀJÀ­À “ø¿™ ¾Pú?IŒh?ã¨e@1EK@p¶d@˜¾@·ÌK@ׄ×@÷=cA zøAYñA+4ëA;{AJÖõAZ«µAj¢Ao­rAhMMAX¬³AHä‹A9¬A)#qAB5A `'@òãû@Ó V@³.Ó@“TP@fó›@'>•?Ï?ª&¾Áæ¿°H!À ^ÀWò«À‹NûÀ¤˜JÀ¾»©ÀÙ½ÀõÁ„ÇÁÑ·Á% Á3‹5ÁB9±ÁPðÎÁ_ÏÁpå ÁaŸòÁRt\ÁCeEÁ4_IÁ%‚ÁÚ9Á2IÀóˆyÀ×oÀ»8ìÀŸ¨–À„/ËÀTÅ(À%…¿ø‹ô¿„2_½Pb?oªÀ?ö.Ë@:.@y)@›û@»Šb@Û69@úðÍA V&A3æA-¦A<ïeALºžA\vUAl2 AtsEAeeîAV{ºAG¼‹A8)A(£ßA´bAÅK@ñ®?@ÑÔ”@±ún@’ Œ@d•©@$ü7?Ê•Z?껾Ҫz¿´À p%À<öOÀpLõÀ“)wÀ®=ÄÀÊNâÀæç™Á¨xÁ+ÊÁáØÁ-¢–Á<’vÁK¡ÁZÀ¹Ál–°Á]C‹ÁMôòÁ>³ƒÁ/}õÁ ^¯ÁYöÁl˜ÀçÀÊ©@À­ÔwÀ‘ŸÀk°·À2†l¿ùo0¿–öl¿ ó†>}¤¿?–KÖ@¥¹@E¢ä@û @¡`@Àã®@àpŸ@ÿâ%A©ÖAb™A/wA>áÉAN®-A^y~An(1AquàAb?}ASWADFA5GþA&«0AUÔA ‚ê@óNõ@Ó„ì@³ºü@”F@hÐä@*,f?וÚ?8è¾7&®¿M«~¿Ç¼‚ÀQ•ÀPœLÀƒî{À ÛßÀ½&²ÀÚ÷À÷’¢Á ŽõÁvÝÁ(…¨Á7½>ÁGDÁVƒúÁh»”ÁY@MÁIÙ»Á:‹hÁ+@…Áì×Á ¹¨ÀûZäÀÝ{“À¿µ-À¢À…äMÀT\´Àwu¿È’å¿4lM><‰ ?ZáØ?Îþ{@]@Y‹.@Šp@¨ßR@ǰå@泜AíÏA’^A"B¯A1ùBAA¬APS‘A_¥­Ao’Ao&…A_í”APÏ>AA¹>A2³¯A#Ý$ACèAÏ­@ï/ê@Ð@±Wf@“÷@iû@/~}?õ$?šsø?ÑC¾u¿*¿“+ô¿ÿÈ7À8è*ÀpéÂÀ•õÀ²GÀÏg£Àí4“ÁÁÛÁ®Á$~;Á3ÏöÁC=§ÁRÁ*Áe©ÐÁVQÁFuÝÁ6ñ3Á'yæÁ`ÁÖ ÀóSÀÔÛ.À¶ÌÿÀ™‡±ÀzwhÀAúËÀ ¿²×t¿.U½"æ?+/ø?ÌRž@"ê‚@aR3@@¯“Á@Î7¹@ëR AKA÷YA!Ò|A0à½A@AOiòA]½AkÀ$AmͪA^n$AO&¶A?ý[A0ùÐA"!þAm®AÒ@ëv0@Ì)ž@¬»@Î@]±À@!ÀY?Ìo­?JJƒ>A¿”¾·í¿|FI¿Þñ÷À%¿À]/–À‹LDÀ¨Ï¡ÀÆõ ÀåqÁÅÁp™Á õIÁ0‰tÁ@)UÁOÒLÁc@äÁS„çÁCÓðÁ40àÁ$Ž€Á÷àÁz4Àì>”ÀÍí]À¯éÀ‘Û‘Àh¨‹À-k0¿è€ö¿n„¾ŸÉ>w¦J?_h?ÝS@)=‰@eü @‘ík@±N@ÏA@ì?A†¡A-A!ö©A/¹eA=qAKgAYFAgôÈAmU…A]íxANœ†A?h:A0WýA!uçAÐAzI@ëHá@Í @­ÞŸ@Žðú@a:@&o7?Û-?iÜ>_¬þ¾Â=Š¿lÜ¿ÆuÇÀåÀLÒ“Àƒù)À¡Â|ÀÀ ˆÀÞÊ‚Àý×`ÁÁADÁ.SÁ=ϼÁM¢<Áag/ÁQ“jÁAÆèÁ2ËÁ"G§Á˜PÁùÀæà‹ÀÈÓÀ©¤#À‹^ÀYKYÀ^þ¿»ó¿:°>Ìf ?ƒ25?Æci@“Z@AR@y*Œ@š#ÿ@·™T@Ñwÿ@ê˜@A1àA}YAAA+0¡A9MHAGœYAV}Ad›AkÞîA^ %AOO A@(áA1)A"ZAÊØA @ïSH@ÒNÅ@´Áù@—>ž@u`”@>$³@ à?¹Æe?a,ø>‰vÚ¿!¿« Àv¡À@ìeÀ|m¡Àœ£PÀ»‡íÀÚ±ÈÀúüÁ ¼ˆÁ‡Á,QeÁ<)gÁL¦Á`X0ÁPo'Á@‰èÁ0©yÁ ÏGÁýZÁ5þÀâú±ÀõÀ¤±ýÀ…Ù‚ÀO¬Àƒ¿¶Ä±¾þU{>Þd»?²â´@nò@ 3@;dD@hùP@Ÿ@§Áç@ÂeQ@ݼ@ù5"A 5AÒ`A''ÙA5AD"«ARÒ¼Aa‘°AeqíAW¿+AJ –A©³Ç?ŸÚ"?R@?Ãû@ä²@Doû@{«Ÿ@š?@¶ƒ)@Ó:@ïÆAh8AôA#ŠžA¤ÚA áù@þ5@â G@Æ q@ªX=@Žz@e.ó@.ê?ôr¶?\ö?d¡s?|g(>9D¿8xÿÕAÞÀ)·cÀiM2À”ˆPÀ´tÀÀÔgÀô\ûÁ *œÁ'‰Á*% Á:"ùÁJ!;Á`Ÿ¦ÁP¶]Á@ÐÎÁ0í7Á! RÁ(ZÁG¥ÀâÎÆÀÃFÀ£B¬ÀƒvÀGSÀ£ð¿>ñ¾õ¾?> n>èÅ­>-ê?]´[?á\ð@+•@e¾v@Q@­qó@Ê»;@è ½A­BAGAÙTA.kyA<ÏÜAK¦AS AQ{?AHr½A;çA.ÍEA!uBA÷"Av©@ñ׬@ÖbG@ºÌ¥@žÅ‡@‚³#@L"@X—?± ^?/o¼Û½>Œ×\>Lìë¿19ê¿×À+ÍÀj»À•:Àµ"ÊÀÕ_Àõ$Á ~RÁz„Á*wdÁ:t6ÁJo]ÁbÄÁRCáÁBl(Á2“ZÁ"²ÁÑéÁ÷ÀæL×ÀÆÉùÀ§r°ÀˆJ\ÀRê À´¿¹I(¿"T~¾X#¾·¶w¾Ì=æ? ló?¼^©@Üü@U'/@ˆ©@¥Š»@Âå @ßñ…@üÜâA ¸gA÷A(¹A6•A@²öADJæABdzA<Ö½A3 ëA&Ô¡AûYA Ý£@ÿ(t@ä^¶@Éaœ@®e@’ô@n´¯@6cØ?ú%Ì?†€>«‹¿OH¥¿\6¿Ä󿎽½¿ùÀ6¾«ÀsÝLÀ™íÀ¸…ÅÀØ §À÷Õ~Á Í»Á¶‹Á+ ØÁ;‹'ÁKuuÁd=%ÁTofÁD©ÇÁ4îiÁ%@:Á£^ÁèÀíK‚ÀΠéÀ°UaÀ’»<Àk„PÀ4pöÀz¹¿µCL¿Ø·¿ží#¿(°>Åé?›çp@ I/@D˜Ê@~ôË@œ–o@¹1‚@Õ‡t@ñŠøA\ÏA±ùA ÔŸA+ÑüA2ÜA5îA4¶A.ý4A'á@AˆœAvA¾@ð]¹@Õß*@»Š'@ Ëp@…ý@UÞò@ÔÊ?ÍÝa?9%ξ5¿‹ö¿½šÃ¿½ã…¿îœÀHÜÀRðCÀ…À¢áÀÀ +ÀÞ°Àý™¼Á_üÁlÁ-ÀlÁ=„ÁMPÌÁg,ÁW•UÁHçÁ8˜Á)3{ÁæÅÁ »úÀ÷ÀÚ3øÀ½5âÀ¡"AÀ†Ñ"À\5À1¦ Àÿ+À…\¿í ¿j6D·Q¿ ¿´£€À‹EÀ©RÀ+¿{ÀM6`ÀwžÀ”ë%À¯úÀËûZÀéŸÁ_1ÁyuÁ!¿íÁ1')Á@§MÁP:ÅÁk ©Á[ÅHÁL}DÁ=Q9Á.KÁu¡ÁÖÛÁX¬ÀèpÀÍJÀ³²©À›DåÀ…]ñÀf=ãÀM©ÀB•ÀL•¿™ð“¾‘ŠE?í ?ÂÒ‹@´3@Qw@ƒÃÅ@žZ=@¸f©@Òa‘@ë.zAÇ«A iÖACAz‘A³_AÝlAuŽA î AÁõ@ú ™@ä·¶@Í¥@µ9@œl/@‚ØŒ@QEý@¾ê?Ïœ-?IÐ%½dJl¿hοãjzÀ*p¯ÀW¸ÀeAjÀ€PNÀ’¿gÀ¨‚àÀÁ„ÀÛ’©À÷ˆÁ žÁïÁ&ܽÁ5Õ;ÁD÷-ÁT9µÁoçëÁ`ؼÁQí2ÁC-xÁ4“ìÁ&]Áî`Á (¾ÀùÑVÀàž¿ÀÈ]’À²DÀÀžñPÀh_À„ùàÀV}÷À—÷¿Ã[„¿6Ë>ì8?–?ýVÚ@38@hCú@î±@§G=@¿°'@Õèè@è¯9@÷­ÃA²¢AfßA‚šAÒ¤Aë@ýcS@ñB7@áb@Îûò@¹Žó@¢¾|@Šò¾@doa@1ed?ûÉž?’³|>¤Ú^¿©`¿¬L½À ‰/ÀC­«À{ÝÀúÀ›Þ À«¢HÀ¿]MÀÕrHÀí§çÁº@Á7ÁòÁ-NfÁ;ËÁJt ÁYTÁušÁféÑÁXQVÁIÝêÁ;ªãÁ-È Á HÿÁ?kÁÆÀõ|¢ÀßNäÀËW,ÀºMÀ¬ÀÀ’Ê)Àk¸‚À2 g¿ò_…¿ƒ§¾Áõ?+“Ñ?¾ÖK@`@F†Ï@xYÑ@”Ù@ª ø@½Ÿ\@Î=s@ÛÓQ@æ4Ù@íg@ð¼˜@ïíS@ê{`@á€@Õ¤R@Çdz@¶Çó@£ã’@Ž_h@ozh@@aç@Vñ?º3C?&+ú¾&yö¿|zò¿çÅXÀ)WyÀ_XgÀ‹1pÀ§7ÚÀ¸UéÀÆQeÀ×¼&Àì/÷Á9–Á -©Á×&Á'¦Á4ÀáÁBÆdÁQ¾Á_v‡Á|ôÁm¢|Á_j¼ÁQtÙÁCÎpÁ6ÈÁ)¡NÁ?ÉÁO9Á2À÷ñÒÀå¢ùÀÖ…YÀ»!TÀž;GÀ†àÀK£;À¡{¿»àò¿&Jb>.q?xCÌ?à,@!ÀÕ@P­½@|£J@’¢ @¤2Ì@²úœ@¿•,@Ȩá@Ï8\@Ò¹Ü@Ñþ;@ÌâÙ@Å’@¹o @¬’{@O›@Œ#=@qa @F[‹@dÔ?Õ|•?h<Å>s¿+«#¿½5bÀéÀG´bÀ|ÿ€À™€ÞÀ´¹èÀÐBØÀâ%òÀñÉtÁÂÁ Á»QÁ#”CÁ0ËÁ=zÁJ‘=ÁX^ºÁftáÁ–EÁu)FÁggçÁYï4ÁLÊOÁ@ ÔÁ3»Á'àòÁ¿jÁT„ÁÔTÁ4TÀãUÀÇIÉÀ«žÀ{ëÀhtÀ21I¿üB ¿”ð꾿õ÷>Íõ1?•‘¨?òwl@%`þ@N¸O@rmƒ@‰¶K@—R@¢®@«b¢@±O@´:@³î„@¯K@¨bÈ@Sù@û@‚¡ö@e˜s@Cg@c?ß^[?…Š„>¢?¾Ú¾¿š1)¿ÿ®±À3<1Àg`YÀî9À¨[øÀÃWØÀÞ‡MÀùüDÁqYÁçRÁyûÁ#äÁ.>ÇÁ:)ÁFhÔÁSF2Á`ŠÕÁn%{Á…†±Á}u¢Áp!ÖÁc˜ÁVÁJ;¤Á>s2Á3NhÁ(¹ÁùÁ¨òÁˆdÀðÝSÀÔ­àÀ¹D(ÀžW˜ÀƒÅ*ÀSФÀ FÞ¿Üâ¿rbξEÅE?S‹?œI?îëÒ@”y@?£Ê@]~Ÿ@wZy@…à‘@æP@“Œ+@•Ëš@•¦ƒ@‘„ì@‹.ç@fó@j/@NÊ@0­Ã@n ?Ú:è?‡“>ÇY·¾ŸÅe¿„꯿â¦?À"ÕñÀTÔ¡À„ žÀÛÄÀ¸5]ÀÒ¯?Àí6ÝÁ*YÁíðÁ*'Á%;Á.çÌÁ9–SÁDÈ+ÁP…»Á\ÌuÁi†¹Áv¢£Á‰ÊþÁƒ1ÁyÆÁlù]Á`ÀºÁUÏÁIÞ‚Á?+)Á56hÁ)v¥ÁZþÁ P'ÀþÜáÀ㼄ÀÈËœÀ®ŒÔÀ”›3ÀvhÖÀD)fÀ|P¿ÆâŸ¿U¨Š¾^?;¿?Žw?Õî@ HŽ@&1X@>A’@R*8@`¿!@k@o`«@nlÛ@fÜû@[¬@JMV@37¬@Ó"?÷o"?¹ Ü?mdü>±rϾ›Ô±¿x×,¿Õm7Àö‰ÀG`HÀxÆmÀ•)©À®±óÀÈNÒÀâ–ÈÀý­Á ÅÉÁ+ Á&èðÁ2QÁ;\pÁEa7ÁP´Á[VXÁg %Ás;`ÁØÁŽXÁ‡õºÁ¹ÁwJ¿Ák™!Á`mÁU¦®ÁK‰|Á>K Á0TWÁ"lÈÁ¥\Á!ÀónÒÀÙ‘”À¿Ü#À¦’äÀ­ÀjÂðÀ:‘rÀ m¿ÂUâ¿[ÛľsÇ>ªÐÚ?W>Z?©p—?Ýs‡@è0@='@%£±@/,@3*b@1ŒË@*¬@·@3Ù?øY>?ÃÛG?‹²'?ɦ=ÿÂV¾Ô?¿¹¿ÔøëÀ_ÀAkïÀo§À×À§~ÀÀˆÀÙ~UÀó2†ÁƒÜÁ¼èÁ! HÁ._°Á<-ÁH4ùÁQ·=Á[âÁf©ÁqævÁ}“”Á„Ù\Á“/]ÁŒ÷¿Á†ìFÁMÁvþHÁl)HÁaieÁSaòÁEr Á7Œ‹Á)ç¦Á„ƒÁY¡ÁlMÀëÀÒTÀ¹XÀ¡DÀ‰ERÀe+˜À8êOÀu,¿Ìп‚Iy¾ñX…<® >ëj?X³\?–]Ž?¸ŸÕ?Óö0?æ(^?íè2?éÐ(?Üë?Ȭ?«rÜ?…´Ã?+@M>xùP¾Vb°¿1‘½¿™u¿â4ÂÀãÕÀAŠ4Àl·±ÀŒeBÀ£DaÀº|ÛÀÒà”ÀëEÁ9ñÁhÁå[Á(üõÁ6NïÁC¡ÑÁQ¡Á^hºÁhCÁreÁ}2xÁ„;hÁŠgÁ˜9 Á’4¡ÁŒbðÁ†ÉÁXÁv‰[Áh“¶ÁZžŠÁLϹÁ?XHÁ2,âÁ% bÁÆÁ G@Àý¾,ÀåÀ̺DÀµ\PÀžCÀˆ?þÀeé7À=æÀ ~¿çt¿¥="¿UüY¾Ð»Ú½'À>Šþã?Џ?8^9?ZH:?iÇÂ?aº?Hû¿? ¨>Ó}<>M™¾GÚ'¿/É¿†=ž¿Á‰4ÀBìÀ!¯ßÀF÷¨Ào\“ÀŒ“À¢/À¸3ëÀÎí”ÀåòGÀþ' Á CÉÁ¹Á$ŽÆÁ1p)Á>qÁK²%ÁXùÆÁfWôÁsüÞÁ~‘Á„t”Á‰ÞVÁƒ®Á~ Á—¯EÁ’ßÁŒžyÁ…ÝéÁ}ѳÁoø™ÁbU?ÁUhÁGà˜Á:¿ÒÁ-Å?Á!nÁ¸ÚÁ_*Àøµ³ÀáqüÀÊ2—À´,Àž·dÀŠ­Àn çÀIíÀ'–À%_¿×Û_¿¤fJ¿oè:¿%²¾ÍH@¾]ƒÌ½¸)ª½ÇÙ½{|n¾†=¾žgW¿9»¿A²×¿‡•©¿» ¿ñ}•ÀÜìÀ3ÎâÀTvîÀwNîÀޱÁÀ£nÀ¸eœÀÍâ†Àä”Àú¼=ÁØàÁÜOÁ íõÁ-JÁ:kÁGtÁTõÁa(8Áno»Á{ÃÕÁ„ÓÁŠ„ðÁ· Á•%Á¢ü(Á_~Á—vþÁˆ)Á‰ ÍÁ‚¿¡Áwô'Áj±oÁ]’”ÁPsˆÁCyÁ6ò[Á*¡ŸÁd:ÁbÁºiÀöM Àà’ÀÊŽÀ¶_íÀ¢ˆuÀøÁÀ}„À\9gÀ>‰÷À#"„À Rô¿ëNü¿Èod¿ª-i¿”2‡¿„=¿|#h¿V$¿Œ’¿žn¿¶‡á¿Ô­‡¿ún¼ÀàçÀ.žðÀLü ÀjcßÀƒ«AÀ”õ¹À¦‚Àºm{ÀÏ-òÀä8Àù¥ÝÁèžÁD.Á»ÿÁ*¹ÛÁ6ÆûÁC+ÁO¾:Á\–¿Ái•QÁv°.ÁòÙÁˆšñÁQÏÁ•Â+ÁšúÁ¨«»Á¢+TÁ›F3Á”a,Á‡âÁ†ÌÁ€1ŠÁsEÜÁf2ŠÁYTjÁLå÷Á@©ÑÁ4màÁ(jÁ»ÓÁ9þÁ%FÀön ÀâëÀÎ}À»L­À©s¸À˜ŒÀ‰ ÀtÿfÀ[1¾ÀCàµÀ/¡SÀÙsÀ–SÀöü¿ýnÔ¿÷åÝ¿ûtÀôÀ ²åÀÓ“À$AÐÀ7ÓÀMÐ:ÀfºÀ€ï\ÀQÀž‰¼À®¢4À¿É1ÀÑÄIÀæ.ÞÀúïDÁOÁ´¤ÁÏÜÁ))ìÁ4ŸÍÁ@˜1ÁL³ŒÁXùÁe‡PÁr7WÁ(¨Á†!EÁŒ°EÁ“TnÁš µÁ Ã/Á¬ê¹Á¦’ÁŸ#Á˜SkÁ‘¡?Á‹#Á„ŠÓÁ|)ÁoTRÁbñîÁV³xÁJw‡Á>rÁ2Â.Á'Q:Á?_Á>lÁæÈÀù™OÀæÉmÀÔzZÀÃIEÀ³W‘À¤7DÀ–>À‰¸«À}¦Àj6òÀZm%ÀLO ÀCE“À;¢³À8ÝÀ:%îÀ?aüÀFæYÀRO!À_[«ÀqêGÀƒ<Àˆ0ÀœãÀ«cÀº ÀÉ ÀÙÙûÀêë7Àý·0Á †ÁX‚ÁïÁ(œÁÁ3¿ñÁ?fÁJ‹£ÁVƒ”Áb cÁnáiÁ{kýÁƒÿNÁŠlÁðºÁ—y0Áž0Á¤Æ Á°ÆBÁ©ëÁ£(ÕÁœ„¡Á•þ¶Á‚\Á‰ ãÁ‚°›ÁyÁl½TÁ`.ÁT{}ÁHÐÆÁ=oÁ2V¿Á'U¿ÁñºÁ¿KÁ *6ÀÿΚÀî\ÀÝÊòÀÎ.À¿SÀ²8SÀ¦f;À›ÄÀ’iÀ‹ \À„<ÂÀ‚vÀy"ÀuËÒÀv¿öÀ{dšÀ»À†èíÀ~^À•ìTÀ ›À«ô³À¸8–ÀÆ" ÀÕFÀãî9ÀôÍÁ‰ÆÁ I­ÁûóÁ¾Á)N:Á3óÁ>§ºÁIÓ½ÁU#ÍÁ`˜|Ál~¯Áx9Á‚eBÁˆ§OÁŽêGÁ•L3Á›Í’Á¢QŸÁ¨ßÁ´ÂmÁ® áÁ§vtÁ ùŽÁšxÁ” \Á·»Á‡ŒÁgKÁvŠÕÁj„îÁ^íGÁS'ÁHn Á=m9Á2ÿÁ(ÏÁüéÁ Á ݦÁKÜÀø¢Àé*ÐÀÛs|ÀÎoÀÓÀ¸ËÇÀ¯ô^À¨ÝˆÀ¢qŠÀà%À›I„À™?jÀ™ÆáÀ›®”ÀŸ‰—À¤áàÀ«NçÀ²èËÀ½OÀÈN‘ÀÔ£Àáÿ;ÀðhôÀÿ·ÁlªÁ¡ãÁ6Á!R5Á+”Á5-KÁ?jKÁJPÁTÑÁÁ`ÁkLÁv¼hÁH]Á‡C_Á\KÁ“•ÈÁ™×Á /•Á¦«Á­0Á¸ÿ³Á²qYÁ«ö‹Á¥|•ÁŸ DÁ˜¿ÃÁ’–vÁŒqfÁ†M°Á€NíÁuÁiÍzÁ^‹àÁS„ÍÁI Á>àaÁ4ö³Á+cJÁ"z-ÁÌ Á”Á ¼¥ÁjÞÀ÷N¯ÀëƒÀàÀÕ߸ÀÍÃLÀƬÉÀÀ·oÀ¼1lÀ¹§ÿÀ·™À¸1À¹Û À½¼JÀÂÆ«ÀÉ`ÀÐL—ÀÚ EÀä¹¢Àñ ˆÀþÁù Á >]ÁÌ[Áö¯Á%=KÁ.Á7e¢ÁAA6ÁKOIÁUŸäÁ`MÐÁkÌÁv7{Á€À²Á†rôÁŒS8Á’KOÁ˜_ÁžŒõÁ¤Å×Á«Á±‰&Á½mpÁ¶ókÁ°zwÁª)Á£Î£Á§=Á—áÁ‘`¥Á‹fEÁ…¢Áþ!Át¹EÁiŸûÁ_dÁTñÁÁJôÁA@Á8øÁ/c9Á&þ”Áÿ“Á[ÁWÁ Ï7ÁÙfÀýGÑÀó`õÀëŒ5Àä®ÍÀßïÀÚÈcÀØD ÀÖ(ÀÖ®dÀØ^ˆÀÛøÀà»}ÀæËÏÀîÞÀ÷ëÁÁÁµ¤Á äÁâ=ÁþƒÁ"c¶Á*U¯Á2ÆÁ:ÿ·ÁD#QÁM|ÄÁWc×ÁaoÿÁkÚBÁv}ùÁ€œÁ†6oÁ‹Û¬Á‘‰cÁ—_éÁVBÁ£i Á©FÁ¯½ïÁ¶ÉÁÁðfÁ»€ÁµäÁ®ßµÁ¨¹*Á¢”¿Áœ|`Á–…ûÁ½ÒÁ‹LÁ…vÅÁϼÁu3·Ák Á`òþÁW=eÁMÚÏÁDÿÀÁÁìWÁ#&Á)bÊÁ/ÕÁ6Ÿ!Á=×ÀÁEZYÁMIÁU€XÁ]ä°ÁfæÅÁp5Áy²ªÁÒ¡Á†àqÁŒ'–Á‘gòÁ–ÐÁœkÑÁ¢­Á§¹÷Á­€Á³l4Á¹}˜Á¿£xÁË;ˆÁŘÁ¾áqÁ¸Í5Á²ÃXÁ¬ÊþÁ¦øáÁ¡NHÁ›·9Á–0äÁÑ—Á‹žÁ†zÁžÉÁyÊùÁpŒÁg’#Á_2ºÁWžÁOuiÁGðáÁAÁ:ǾÁ4¼rÁ/ymÁ*ÁÁ&MÃÁ"ÕyÁ–Á-›ÁOÁ2iÁS&ÁtÂÁý£Á†•Á§†Á X Á#éàÁ(ØÁ,¹`Á1«uÁ7”yÁ=ìµÁD ÁK…˜ÁSñÁZ¬éÁbêTÁk›ÁsÈçÁ|âEÁƒÎÁ‡è†ÁŒâÄÁ‘÷ôÁ—?ÏÁœ}¿Á¡êÁ§†‚Á­,®Á²Ó¦Á¸“îÁ¾{ÎÁĉ¡ÁÐ ÁÉýÁÃðýÁ½çºÁ·íÚÁ²ØÁ¬lÁ¦ÜÏÁ¡\Á›öêÁ–ºÁ‘ÁŒŸjÁ‡ç5ÁƒC÷Á}[Át¼ÓÁl“aÁd³‘Á]+ØÁUÛ¨ÁOYaÁI)ÁC9vÁ>2~Á9›ÑÁ5H)Á1ãkÁ.´zÁ,z‘Á*¡òÁ)ˆGÁ(ÈÜÁ(ðÁ)`™Á*àìÁ,ßùÁ/ž€Á2êRÁ7åÁ;†ÍÁ@k¶ÁEï!ÁLÆÁR¢CÁY\Á`²”ÁhQ Áp0÷ÁxÂÁ€kÀÁ„Ø6Á‰núÁŽ „Á’÷ÜÁ—òçÁ Á¢S<Á§”1Á­CÁ²¡eÁ¸G¯Á½î ÁìªÁÉ’˜ÁÙt#ÁÓ ÁÌ–ÁÆ—§ÁÀŽ:ÁºšÁ´»‹Á¯Á©öÁ¤,ÕÁžëÐÁ™Ì×Á”îÛÁWZÁ‹ØƒÁ‡o*Áƒ=nÁ~/!ÁvC]Ánñ ÁhEòÁbVÁXÁ¨ÁMø.ÁC«=Á9÷ÜÁ1$ƒÁ))ÄÁ"BÑÁeeÁ“3ÁLÁºÁ]ÞÁgcÁÛåÁp’Á6äÁ#lÁ*®bÁ2ÌÐÁ;æŒÁE¡ÖÁOü.ÁV“JÁ[ùÁbÌÁh—XÁo«Ávæ Á~ÎÓÁƒ”bÁˆ ÁŒÔÁ‘²’Á–Õ‚Áœ0SÁ¡«ýÁ§5RÁ¬Û„Á²¯µÁ¸­ŠÁ¾ÊØÁÄöÙÁË1ÁÔÞÁÎf[ÁÇ÷/ÁÁ¥,Á»tÁµgÁ¯x–Á©ž$Á£éxÁžg¦Á™EÁ“ß+ÁŽÍÁŠóÁ…z Á€û%Áy_ªÁq3 Ái øÁa\HÁZ`‰ÁT-yÁNÍiÁDVuÁ9¼Á/mÁ&<úÁ ÕÁ2ÊÁ´¿Á ›ÿÁºÁr‰ÁÂôÁûÁC³Á `}Á“uÁK›ÁÁ'³¤Á1bÁ;œ¸ÁC~>ÁHO®ÁMý‹ÁT/»Á[ ÆÁb$¶Ái¨óÁqÂÕÁz|ùÁéþÁ†³ÜÁ‹ÉÁ‘ÝÁ–åÁœ¶Á¡¼ïÁ§’PÁ­“_Á³¬SÁ¹ÔÁÀÁÆoÆÁÐW²ÁÉÒ´ÁÃ[Á¼èIÁ¶ŽÁ°VÁªD?Á¤Y‰Áž‡5Á˜ÔƒÁ“WÚÁŽÁˆÝ–ÁƒÛÛÁ~Q2ÁuGÓÁlb0Ád†Á\ÁT ÁÁLɇÁFCÁ@’˜Á;xÔÁ0!zÁ%‚XÁ¶ÿÁ”wÁ k!ÁJ_ÀûKïÀò”‚ÀíÝÀëòBÀí¬;Àó yÀüøÁ4YÁ yÁëÁpŽÁ'aäÁ1 Á58èÁ:PoÁ@FwÁFš¶ÁM¤ƒÁTÑ Á\›¼Áe Án%þÁw‡¸Á€ÈOÁ†RÁ‹t€Áû]Á–¢^Áœw‚Á¢z±Á¨4Á®´HÁ´ùCÁ»_ýÁÁâ™ÁËûËÁÅTµÁ¾ÈÁ¸P½Á±à…Á«~RÁ¥>úÁŸ'ÐÁ™=wÁ“tòÁÈîÁˆR¦ÁƒxÁ{ÓìÁq÷EÁh½RÁ_»tÁWRÁOÁG$ÌÁ?mƒÁ8”ZÁ2š°Á-|±Á'YÁ4äÁ¥¸Áð’ÀýܰÀî>ÀâR ÀØ€óÀÓ*ÀÐøÀÓÀÙÍáÀã«§Àðš¼ÀÿÛ¼Áþ…Á5CÁʶÁ"ÐíÁ'.¥Á,“ÏÁ2žÁ9]bÁ@KÁGÇpÁOÎ~ÁX©¤ÁaͲÁk­[Áv™Á€`ŸÁ…ß¾Á‹‡êÁ‘\ÀÁ—bÁsÅÁ£šMÁ©ç¸Á°XeÁ¶ßdÁ½haÁÇØÞÁÁ MÁºZ;Á³ÂdÁ­GêÁ¦ÛkÁ w¤Áš0/Á”<ÁŽ&GÁˆhÁ‚ÉÁzµ§ÁpQ‘ÁfÁ\cýÁSA8ÁJXÎÁAññÁ:VùÁ2uÏÁ+I¥Á$ýTÁ°3Áá¯Áu.Áp=Àû¬—Àè ;À×aÞÀÉ>ÚÀ¾„ØÀ¸£IÀ¶“rÀ¹iÀ¿œ*ÀÊÓ…Àس>Àé¶MÀý~¾Á S^Á@XÁÞ”Á„¸Á=ÖÁ%_ÜÁ,‘Á3@òÁ:ëœÁCoMÁLEÄÁUñ‚Á`(¢Áj¬¾Áu”‡Á€m—Á†B\ÁŒIøÁ’[FÁ˜ˆMÁžßÁ¥ZEÁ«â Á²pvÁ¹>ÁÃÚIÁ½üÁ¶*ÂÁ¯jªÁ¨ÆŠÁ¢AÑÁ›Ø­Á•yÕÁ+¢Á‰lÁƒªÁzÄHÁo©ðÁdèzÁZœáÁP|UÁG Á=î-Á55ýÁ-BßÁ%õdÁO1Á±IÁ°Á <ÊÁ ÀþßkÀç¥ZÀÒ ÀÀqÁÀ°þŒÀ¥(kÀžaÀ›þ¥Àž“À¦9nÀ²/bÀÁŠÀÔ|bÀéoÀÿÏ`ÁœvÁ`Á TÁšÁNÕÁÖSÁ&RéÁ.Á7œÁ@jmÁJWÁT±dÁ_€=Áj²AÁv^TÁ9AÁ‡KRÁ€*Á“á$Ášd4Á ë¿Á§„NÁ®:ÝÁµáÁ¿öãÁ¹ jÁ²/±Á«VXÁ¤ˆ.ÁÖžÁ—EŽÁØÕÁŠ€FÁ„3áÁ|ßÁp.öÁdÊWÁYÛ‡ÁOC<ÁEoÁ;$\Á1ápÁ(íÁ {!Á ÉÁÞ#Á ê©ÁPÁGÀ÷¨ØÀíݾÀÕ*êÀ¾u1Àª•·À™´ ÀŒŒ À„4kÀØLÀ„àÀÈjÀšâ€À¬DÝÀÀ BÀÖ—òÀæ9¿Àì¬gÀô§ÌÀþ‘fÁ,:Á õ,ÁÝÁëgÁ!¾©Á+,Á4¸vÁ>×JÁI†uÁT¢Á`O-Álb©ÁxéÁ‚„bÁˆð²Áw)Á–µÁœ¤?Á£aÁÁªPÁ°G,Á¼UDÁµELÁ®JÁ§f%Á Á™µÁ’õLÁŒV§Á…ÞžÁ.Ár‘Áf6ŸÁZLôÁNð›ÁD/Á9¥ÛÁ/ÙÁ& ÁëëÁO›Á V©Á¡8ÀýbÀðìHÀæ4¾ÀÞáÀ×ÔÀÄÕ0À¬W6À–ƒçÀƒIWÀhõ¶ÀUcÚÀOa£ÀWÌÀjn‚À„q{À—iÅÀ­‹ÀÅ…ÀÌ~±ÀÓ>ÀÚ;úÀá;ÕÀë2–À÷£^ÁTQÁ ÕÁmãÁH×Á)„Á3©¶Á>±IÁJI?ÁVbžÁb¡ÅÁo0»Á| Á„•_Á‹‹Á‘ÆÆÁ˜Š]ÁžÄ+Á¥ YÁ«ræÁ¸LRÁ±užÁª¥LÁ£,Áœ©°Á•ÍÁŽõaÁˆ&Áx}Áuæ¬Ái:NÁ\ËkÁPƒÁD– Á9F¥Á.—Á$ ½Á9%ÁÈÁ^ËÁE…Àò'tÀäóEÀØMÀÍÔ™ÀÅ0 À¿îÀ¶ ÚÀœIÀƒÑÀ]yÀ:©¯À#Z8À9À#ë<À:ùÄÀ]|‘ÀƒÄ©Àœ À°+?À´’›À¸…2À¼l®ÀÃÿ)ÀÎÄ:ÀÜKÀìVäÀþÐmÁ ˜öÁk ÁËÑÁ(ÈëÁ4]KÁ@n„ÁLÌÿÁY¹Áf}ÿÁsb Á€<óÁ†êŒÁLlÁ“†pÁ™ÖjÁ HOÁ¦Ü­Á´]ÝÁ­oÁ¦ŒIÁŸºìÁ˜ëÁ’?Á‹eÁ„C–ÁzÛ=Ám_VÁ`81ÁSu ÁGQÁ:ù¸Á/ŠÁ#ßgÁ1‹Á¸pÁBEÀøï'ÀéÆÀÙtÒÀˆ«ÀÀ¹,À¶aÀ­å À§ç¶À¢PÀµÎÀfT_À7vÀl¿ä C¿Ï×<¿âå¸À úÀ4;¬ÀbüiÀ‹“Àš.ÞÀš?cÀšø›ÀŸ"äÀ§ÄÀ²ÎÕÀÁ{AÀÓ?¨Àç×ÀüóÁôÁö/Á‰dÁ*‡Á7áÁCò_ÁPÏpÁ]˜ÙÁj¹ÁwÉaÁ‚ ‚ÁˆJvÁŽ£fÁ•#QÁ›ÆÿÁ¢ŠÁ°x²Á©~«Á¢“—Á›­/Á”Ô¬ÁŽŒÁ‡5 Á€j’Ás;{ÁefÁX(ÁJ¾§Á=ãÍÁ1‹òÁ%›*Áè2ÁÁ>ÁüÀóµÌÀáÇ{ÀÑGÀ¿ ¤À¯‘—À¤:Àš-2À“ YÀt#ÀŽ¿ºÀ «ÀJ4 À7V¿ÍÞ¿‡½V¿TIÆ¿€o“¿Âf€ÀXáÀB%ÀyáÀÚnÀ|4%À|qýÀƒ ¶À‹ŽkÀ—þ¡À¨0AÀ»hHÀÐÍŒÀåq*ÀúÔÁÚNÁÕÁ!}tÁ.c»Á;ÔÁGØòÁUVÁa=ÎÁm“¤Áz bÁƒuMÁŠHÁºNÁ—‰fÁžb»Á¬ÌªÁ¥« ÁžžÏÁ—ª®ÁÏ}Á‰óïÁƒ%€Áx¯‹Ák=Á]­cÁPp4ÁBô¦Á5ŒÚÁ(™Á3ëÁgÁÄnÀóX{ÀÞ©MÀË{—À¹ÕÛÀ¥ÚnÀ•0íÀ‡Û¼À}‘bÀmÔ`ÀhåÀl©ÀhŘÀ2#Ù¿ñ⿈gѾÅL¦½´-¾xT¿dÍL¿ÙõˆÀ%1À]Ý,ÀP=ÀG6ÇÀF ÀPÀÀbµ±À};3ÀÀ¥F@À»1»ÀбÀæâ1ÀþáÁ ÷•Á­Á%[Á2M Á>’çÁJ³aÁW}Ác¯ØÁpšÿÁ}àÁ…·[ÁŒŒÈÁ“hèÁšT5Á©VÁ¢­ÁšîÏÁ“Î\ÁŒÅïÁ…ÙSÁ~&ÁpŠ-Ác-ÁUj½ÁGïøÁ:Á8Á-ß+Á ½òÁÚÁ&Àö#ÀßRçÀÉ× À¶‘RÀ¤ƒ˜ÀŽ’ÄÀw~­ÀZNòÀG­(À9×ÊÀ4­‹À7ÓÀ?…°Àbl¿Â0©¿m³>nc?5ë>ç)¾ºÇ\¿Ÿz\À À(äÃÀ-zÀÀ®ÀaÀ1²ÀN·•Àuñ À‘«À¦-}À¼bWÀÔjiÀísÁ:<ÁîØÁ<¡Á(<Á4*ŠÁ@›¯ÁMI—ÁZ[ÖÁgÌ-ÁuokÁ’æÁˆwÁv‡Á–ŽiÁ¥ïíÁž¬HÁ—tMÁ>lÁ‰lÁï¶ÁuÙ_Áh»ÁZœ¢ÁM0çÁ?Õ+Á2KpÁ% ¢Á3×Á uÑÀý8RÀãÖeÀËÖÀ¶XÀ¢8òÀˆõÀrà>ÀIÝâÀ)iÀëyÀß”¿ðϲ¿ïMïÀ;ßÀoS¿šú¾‡Y?,p?ÆJ^?z £=£µð¿Rm¿ÖðÜ¿ÕÑ¿¹ó›¿±|Á¿ÂSؿ饉À{ÚÀ$ÿÑÀN¡=ÀzaþÀ’¦‡ÀªuDÀÂÑjÀÛ¶MÀô—8ÁÁsÓÁ£÷Á*&ËÁ6ñnÁD2µÁQÉdÁ_yäÁm7…Á{*ÔÁ„«mÁ‹Ù}Á“Á¢ÓäÁ›k Á”êÁŒÊüÁ…’™Á|º¥ÁnZ°Á` ÒÁR(9ÁD~ÑÁ7'¡Á)Ï·Á¶ZÁ{–Á™UÀëòoÀÒàÀº8þÀ£ÔÀŽŽ?ÀvèªÀLŽÀ ¡;¿ûX%¿ÆûÄ¿‘8~¿gf¿eP^¿‰ÖÝ¿¨=пjóY¼ýÃÈ?iª?ðv}?³‰?eE¾¶-ö¿y<ú¿6) ¾îßþ¾É…¼¿ `¿o¿¿ÓÀó½À+åÀSÄ_À€êÀ™ZÀ±†ÀÇ}ÀÝû½ÀõÊ×Á ÈÁ³lÁ ­<Á.&–Á;ÍýÁI†IÁWiÙÁeäÁsïªÁ>qÁˆ˜Á9Á 7Á˜ƒeÁ‘–Á‰”TÁ‚5ÁuÔÁgaÈÁXø·ÁJ˜ŠÁ¥mÛ?—Är@E"?湬?t<`>†›<¦]>j®¨>ÿ,?Jb>ÌÔ½×HØ¿E ¢¿¿¥}ÀšÔÀ0‚LÀ]5GÀ„^MÀšM¤À°¾LÀÈ®ÀáFÀú™ŠÁ †¤Á$½Á%Ú:Á3ªÞÁAÊðÁP-GÁ^Å ÁmˆhÁ|kÁ…–þÁŒû¦Á@ÚÁ•¸6ÁŽ9ÊÁ†¼_Á~uHÁo‚7Á`´1ÁR ÁCž`Á56ÌÁ&ÖeÁ¨¡Á à2Àû%.ÀàYÀÆË¥À®§3À– ‘À}=úÀOªLÀ(6TÀ#Ç¿¶?–¿B"“½¬\g? Õ?›ª?xºn??¹Ó?Ü?.uðŽë?šxé?ûžˆ@. `@9›ˆ@*„—@!ýÆ@$ú@:\@U.µ@w!~@s `@VV>@F¶™@<J@>Y@Oć@WêÕ@+_Q?þ¨{?¬Þ¼?<}¶=Йy¿Å—¿¤¢²À½À5IsÀko¢À‘RÀ¬ò¨ÀÉêòÀç™—Á TÁV‚Á -QÁ/5éÁ>JqÁMtÁ\¶ðÁlÁ{K÷Á…HÁ–=ÁŽ~§Á†ÄÁ~#:ÁnÒ Á_”nÁPYEÁAdÁ1ßýÁ"½ËÁ¿ZÁÄ‚ÀëýÀÍÀiÀ°¨KÀ“âÀn@hÀ6í©Àá¿6s¾øó2>B§¡?J­¬?œ ƒ?ðÂÞ@'*¦@WÃ=@wih@ih/@a¶ä@cý@t/’@‡‚â@•ø@•[ô@‰lû@‚à÷@zN@{òÞ@…qý@‚I@Xø@0¸@ F?À½?Tæð=ýô¿#9Æ¿¹ÈûÀ‹ÀJÏHÀ‚–­À búÀ½ÕÀÛL¤Àù?˜Á ³™ÁÝ~Á*'PÁ9všÁH¹²ÁWþ|ÁgS§ÁvºÒÁƒ2Á”=–ÁŒ}ÍÁ„¿OÁzºÁj„ÕÁ[ÁK—Á<=Á,üÝÁÁ´Á„ïÀþªÀàU+ÀÂ_RÀ¤i£À†peÀRC"À¼{¿¾qi¿%8B>8ÖB?l¡à?Ì[¥@ V@' !@RºÄ@€Àj@˜ì>@“å0@Åo@‘›Ÿ@˜>ü@¤ƒd@²Ò@²:Á@¨Q@¡Þ¶@œžð@GD@£”Á@™fý@…s:@cP0@:_º@¤Þ?ÄCÐ?D ½›l·¿o ²¿í€BÀ1ú„ÀlÓ+À” À²:ÞÀЩÀï/ýÁäUÁ'lÁ%miÁ4ÍHÁDB{ÁSÅ‹ÁcJ2ÁrÎÙÁ+¥Á’f>ÁŠ–Á‚Ë£ÁvÁfˆsÁWÌÁG‰BÁ8 ^Á(yÁ(Á ªµÀôÊ™ÀÖTHÀ·ÚôÀ™`DÀvk>À:á¿ý)¿†q&¾LÒ?>Að?É:@oV@@`<@\E@€gx@–“©@­÷@³]ô@°µI@±\+@·@Át–@ÏÇ@ÐÂ@Ç}Œ@ÀÞW@¼D¿@¼ÐÞ@ÂNæ@²Mÿ@žbó@ŠC2@j@<[ˆ@ °Þ?¥çD>½ª¿ É¿»ø?ÀFÀVÝ+ÀŠZÀ¨¤ ÀÇ*OÀåÆ ÁTüÁÙbÁ!^ Á0â°Á@hÅÁOûLÁ_š(ÁoDðÁ~ú7Áì[Á‰ ´Á+Árš‡ÁbèTÁSA¾ÁC©ŽÁ4 Á$˜`ÁÁ“çÀì.ÀÍ4;À®>°À›xÀbJMÀ%X¿ÐÅh¿0±í>{î#?—T@Rà@=06@o¶4@Š›œ@šb¸@­zt@ÃÍL@Òÿj@ШO@Ñ0@Ö*“@ß$Ò@ëô @î\ž@æÇ®@à!ð@ܧ@Ü|š@ß".@Ë*„@·V‡@¢=‘@‹J”@a£A@&ŒF?×g??@ì¾¾IþJ¿“ÊÛÀÿ+ÀD úÀ€ÔìÀŸÙ¯À¾ãdÀÝí ÀüöjÁ ´Á³½Á-kÁ=)ÑÁLèºÁ\§¯Álf¤Á|%™Á†¬Á‡§ªÁ‘PÁoÐ>Á`ïÁPMŸÁ@ŒPÁ0ËÁ! -ÁZ—Á¼ÀädcÀÅTûÀ¦E’À‡=(ÀP†šÀ“¿©±Z¾¿`O?ÿ?Ãö@@H@Yý¥@Š-G@¥¤@µ´‡@ÆØ¨@Ú Œ@ñh@ð=@ñ¡@õ†Ø@ýeHAuîA‹A+@ÿv!@ûÔÉ@ü=›@ø@äiÜ@Ïs"@¸#@š±¬@zв@=b@Wè?†“Ò=»÷€¿_þ¿ì&À4&yÀr;˜À˜UìÀ·ÀñÀ×>ÜÀö¼ÇÁ YÁÜNÁ*›DÁ:\œÁJ$õÁYó ÁiÇ1Áy ðÁŽAbÁ†WSÁ|ßÁmúÁ]DÁM}ßÁ=¾òÁ.îÁBêÁƒØÀý…ÀÞsÀ¾ÔÀžýcÀ> ÀA:Àòi¿‰§1½Ö˜ò?];T?ê„Î@2r9@oc”@–,z@´(†@ѱ@á‚Å@óRAçùAI´A{eA ƒçAóA.A ½A™kAtöA רA`A¾˜@ü¨³@â5@ÃíT@¥O­@†´E@OªD@ «?§‚>©ý8¿%b+¿Ð¨ÁÀ'P6ÀfL À’£ñÀ²*ØÀÑË2Àñz»Á–%Áp²Á(OËÁ82WÁH†ÁWþÂÁgçŸÁwÑÌÁŠóšÁ„+–Áz•EÁj½üÁZæ²ÁKiÁ;8Á+a Á‘Á ÃÀ÷êÀØ]%À¸áÀ™eÀsÒÀ4ڿ뱿[M4>ü?L¥@Å#@Bãô@€b@ŸË@¾h>@Üà´@ûR8Aá‡A+AE=Aq”AHòAxA"$CA%¢A"#A<ÓAÉ AòâA…üA:@뙉@̪3@­“É@ŽP6@]Ô÷@Ù!?¿º˜?·¾öûn¿¼…À¥¥À]ÀÀŽAaÀ® qÀÍá„Àí·¼ÁÊ!Á¼$Á&°ÕÁ6§€ÁFŸVÁV—;Áf@Áv‡žÁ†ýiÁÿ½ÁrDPÁdÔ`ÁWžtÁHá]Á8ÿòÁ)"åÁJÌÁ s‚Àó8rÀÓ‰ßÀ³ÛLÀ”,ºÀi ¦À)Ôˆ¿Õ8Ó¿.“>›»U?¤Þô@g‰@P_™@‡¬¬@§.ï@Æ>X@åMÀA.”A¶HA«A&¤êA(i A*ÂA-†A1HôA5@vA1ÁÉA/âA-¼ùA(?fA¢Aÿ5@òLÛ@Ò›N@²éÀ@“82@g V@'ˆ?Ï<"?Ðh¾Á®è¿°?¨À ËÀWóÂÀ‹îÝÀ«ãØÀËØÔÀëÍÏÁáeÁÛãÁ%ÖaÁ5ÐßÁEË]ÁUÆ ÁeÁYÁu½2ÁƒIòÁxTžÁj;{Á\N:ÁN­âÁA^ƒÁ4GÔÁ'KÁc˜Á|/Àï)‹ÀÏ\ŸÀ¯•ìÀГÀ`vÀ ¤$¿Âý¿§d>ëše?¹ å@+ @[c'@M£@¬Üz@ÌX‚@ëÔŠA¨IAfLA% `A3bûA8c A9éA<¦0A@‘ADécAAn›A>è™A:f?A*n AnäA o¿@ôá3@Ôâé@´äŸ@”æU@iÐ@)Ó‚?Ó­Ü?'ii¾±Ï¿¬=œÀbÀVöÀ‹ EÀ«ÀËÙÀë#Á·Á€ÜÁ%€Á5ÁE~ÁU}ÁdYÁrgmÁë¸ÁqGæÁbÓ"ÁT–ÖÁF~wÁ8¥Á+*ÑÁõ§Á)ÁhbÀëªBÀËÛpÀ¬ žÀŒ=ËÀXÝòÀ@M¿³ER¾Ð(!?b‚?Ê[‹@$¸v@dC'@‘æì@± @ÑN™@ðý,AUßA&¶A'ô½A7¼£AGz§AIÅALUAOôôATsñAQÁAJ™ÀA:›kA*Až¿A  j@õD(@ÕG}@µJÒ@•N&@j¢ö@*©Ÿ?Õ`‘?*ÛǾª(¿ªwwÀ5ÀU.iÀŠ“àÀª‹ÀÊ7Àê‰âÁCGÁAœÁ%?ýÁ2ÐÁ@ŸNÁN¦³Á\è†ÁkA¡Áz¥Ák=Á\?âÁMUÁ?±Á0ÚiÁ"ÅÍÁ Á²#ÀõCiÀÛÕÚÀÑEÀ¨¦6ÀˆÐºÀQüÚÀX”¿¥h¾˜€E?2Põ?Øi­@+Ò{@kp @•†â@µUµ@Õ$‡@ôóYA aAD…A*'1A: ÝAIì‰AY¥õA\£A_nºAcàRAZ˜°AJ˜ïA:™0A*™uA™¾A š @õ4É@Õ5@µ6|@•7¡@jqµ@*t)?Ôí:?)äE¾¬#Ö¿«À“ÀU}ÀнUÀª¼ÀʺáÀ꯰Á `Á5nÁæÁ*è‘Á9%ÜÁGÁVÁd²Áty÷Áen~ÁVm&ÁGˆ€Á8ž‰Á)ÜÑÁZ(Á ·Àþ*YÀã ÔÀÈ2À®ëFÀ–[­ÀrÀKbHÀ Á¿˜?¾GD?LÜ5?åÄ·@2ª@r8ø@˜ò#@¸Å@Ø—>@øiaA ÂAÓA+ïŒA;ÖöAK¾_A[¥ÈAk1Anú.AjGGAZXéAJgƒA:lžA*q¸AvÓA {î@õ@Õ F@µ|@• ²@jUÑ@*]{?Ô»&?)v­¾­æ¿«1DÀŒeÀU‚rÀн8À¤\ºÀ½ÓqÀ×pƒÀòd°Á,ïÁeÁ#¾ŒÁ2FAÁ@ÞÖÁO¨Á^œcÁo´sÁ`XÁQ(ÁAð<Á2èAÁ#ì{Á3Á5,ÀïNÀÒÑÀ¶ëöÀœLÀ‚þÀRNÅÀ%aÿÀÎÆ¿‡fñ½›•?hlj?óGG@9DÔ@xæ@œC›@¼4@ÛäÌ@ûµeA ÄIA¯A-™ðA=„ÄAMo—A]ZkAmDRAxã¸AiÜvAYñ5AJ£A:¾A*"tA1ÌA ?K@ôš@ÔµË@´Çµ@”Ý‘@iõ7@*MÈ?Õâ?*—T¾©ú7¿ªHÆÀ}xÀ>â¾Àoz”Àç¡À«ƒÀÆãÀãOëÁ‡Á‘ Á6Á,„Á;&ÁJZqÁY¦¨Ák4!Á[ÉìÁLv·Á=<*Á-؈Á³ÁqÁhRÀãpÀÅHfÀ¨ ŽÀ‹vAÀ_Ä À*ž¿¿ïÙ…¿˜¢,¿6(ß>M@?Œjè@åú@CŽÅ@ç@ wD@¿ö@ß’0@ÿBœA€`AdAA/K•A?3áAO-A_zAnìÆAuý5Ag ‰AXZÀº ¾ÀœµÀ}@“ÀB]%À ;¿£Ø°¾ï8€=Éø3?ó—?¶ÉW@p‡@Qç¶@‡^@¦_Ì@Å¢Y@äýA5—AóJA!µ©A1{qAABƒAQƒA`ãAp½jAsõ%AdèóAU÷ïAG1A8žVA)²A•rA *ü@õÍŠ@×£n@¹”¸@šò(@wG/@9 ¿?õ=r?x—ß>_ù¾1ÌD¿pk¿àN‡À)wNÀb°[ÀޱâÀ¬dºÀÊ´Àé0ÁúòÁÁ"ø²Á2l¹ÁAö®ÁQ’hÁd\ÀÁT¡*ÁDèÃÁ54Á%ŠÂÁóÎÁu‹Àî PÀÏiÀ°ÐÃÀ’AóÀgÈDÀ+Ǥ¿â¥¿a`ê¼ :+?5k°?˜?ò?족@+Žh@fD{@Œ@®‰Ô@Ìèð@ë¬îAPvAÜ–A$}ãA4/ÑACì…AS­+Acp½Ar ÌArv}AcguAT{ªAE¹ÚA7YA'á¶A;sA©û@òj¡@ÓÔ@µ¶-@—Èl@t`˜@Ï0“¾íúÇ¿¬<’Àä‹ÀL³À„aéÀ£VÀÂQQÀáðÁµÁ¹Án·Á/1ÞÁ>ýÁNÊÞÁbŸÁRAÁBgëÁ2ŽdÁ"¼eÁô]Á9ãÀçxÀÇâæÀ¨ÉRÀŠ AÀWzûÀ;z¿½í}¿)ˆe=’b?HÁ¸?³ñ8@§@>05@v E@˜m@¶•Y@ÔÜi@óo?A &ÓA°ZA(A6›YAD8¬AQþŒA_ê,An SArxAbé›ASôôAE*KA6“ÔA(&ÕAŽUA H@ó:±@ÔÂ@¶Ïu@™W6@xsi@A)@—‰?ÈBc?j=>Ûm=¾9õ)¿„÷ø¿ýwÁÀ;¿Ày—ÜÀœ®À»:ÀÛ^Àúª·Á $rÁüÈÁ,ÜnÁ<ÁŠÁLªdÁ`WæÁPl®Á@‚ŠÁ0™ÆÁ ²ÉÁÎfÁð-Àâ6òÀ©ÞÀ£IŠÀƒ÷ÿÀI‰³À ‡²¿¡êk¾×»'>áü?¨3k?Íã%@ ÿ…@@FV@x @™…T@·©=@ÖWX@ô—ôA'vAÏ A#Ÿ!A1e^A?k‹AM¦!A[ó£AjbTAq0AcMpAT¢þAEåWA7]ÃA)2A‹eA <-@ø3,@Úla@½0¨@ `p@„éÖ@U¢@$Ę?æ ?žˆi?.´¤=3,R¿Q~ ¿âWhÀ0/~Ào–TÀ—À·UÏÀ×"wÀöñ}Á a ÁJ,Á+6ÍÁ;&½ÁK3Á_TúÁOXÀÁ?]'Á/b]ÁhÁpCÀþó¦Àß CÀ¿-ÀŸ[À@9À@$ÖÀ¿‰Ñš¾Ujª?­Ž?Žz?¦¹:?øö@/é@gÔ@sa@­»ó@ʃp@çdêAûBACÙA{¬A,ÛLA;L“AIÈÍAX\ÙAfýÛAjqRA\ϧAOLOAA°i\ÿ¿-kÔ¿Õ%ðÀ*_¥ÀjG§À•¶ÀµåÀÕWÀõÁ ‡¢Á†ªÁ*…ÒÁ:…ÁJ„bÁ_GÁOHìÁ?K&Á/MÈÁPñÁTËÀþ±áÀÞº7À¾ÂšÀžËÀ}§qÀ=¹Y¿û™¹¿w›Ç<߈?X¿h?¾?4À»?²ë@@LÞH@ƒá@¡Þ²@¿r2@Üåq@ú3¯A °qAVêA(ñåA7“AF/ATË AcuAb rAU±OAH€'A;âA-ƒ Aö³A:»AX-@ì›G@Ð Ý@²ëy@•&@nè@3ë?óÊ?‚†>ŸŒ]>©9>b×™¿-TÝ¿Öf{À+}Àjï½À•aÂÀµK–ÀÕ5{Àõ!³Á ˆ@Á€‰Á*ywÁ:rÞÁJl¢Á`ºÁP!æÁ@0Á0@ÝÁ TùÁm‡Á‹>ÀáVÀÁš À¡à1À‚;,ÀE˜³À¤¿”¨x¾“›ÿ>_Í”½'ÿp=Sf_?}!«?÷™º@8ç@u©@˜ç0@¶ÇW@ÔˆÌ@ò€AÊ”Ao^A$û£A3u‰AAÃAOuJAX!AUºåAMMqA@Ù A3Ð+A&†üA@ìA È,@ü{œ@á @Ū@¨›@‹Ÿn@[jK@7‡?ÄÞ?ý]¾™A¾ uK¾­u¿w¢¿ê RÀ1ˆÀoÖýÀ—m\À·TÀÖÅ|ÀötÁ lÁûíÁ*åÁ:ÓÁJÃeÁaÈÁQè“ÁB [Á24$Á"dìÁ IÁêÀæEÀdž.À¨†ëÀ‰¬ÀV÷ôÀk ¿ÍŠÅ¿jÝ׿>–¿FÈE¾W‹K?>ÇÌ?Ù3Û@)Q@eq2@¶š@®–w@Ì=è@é—*AXAŸ\AáA-8:A:M¤AEÁAI’AGv‘AAƒ»A7ÄYA+¼˜AðAó§AÉ&@îÒØ@Ô@¸ø @M”@1¶@HÂ@z?¤XÔ>®5ä¿–?¿‡Pò¿ˆm†¿Á@<ÀeâÀCÀ}Ä…ÀÀ»ïÂÀÛaÀútGÁ úVÁÆÉÁ,–®ÁšrÁNQÕÁglÁWÚzÁHYËÁ8îÌÁ)ŸjÁsÙÁ wËÀùuÉÀÜA'À¿¿"À¤xÀ‹=Àf©bÀ?xÏÀ#±SÀƒF¿ÑF¿1˜§>}k)?–í2@¸‚@AÀÊ@{ªþ@šsÏ@¶L @ÑX@ëÍðAÒFArÉA »A"žCA(2A*È,A)âDA%~'A…(A>jA »¨A2-@éÝt@ÐR‰@¶h™@œ%b@ÈX@N?¶@öå?Âæj?#? ¾„¿•K‘ÀÛÀ2À@BÀ_œ`Àƒ|YÀ›EÀµŒ¾ÀÐͬÀí1äÁ3ìÁÁÁ#39Á2u¶ÁAÖÆÁQO«Ákh1Á\ZÁLðSÁ=äÊÁ/£Á U…Á½yÁi¼ÀëðÀÐiÀ·RÀŸ©¥À‹,ÀsÞhÀ\mÝÀ5žê¿òá6¿wÛä½,Ä?ahm?ä8G@+f…@c@$@§Xu@Ád:@ÚÚ#@ómÂAÊÚA íAÇAIAÁ%A ýAy¥AšA rÅAßX@îE¬@×m%@¿2þ@¦.@Œm_@d°”@/ì¥?öQk?Šz>kßú¿%;M¿Â¿¤ÀÊjÀU0¸Àx öÀˆÀµÀšTLÀ¯ ÀÆÆNÀà ÀûŽ‹Á ¢“ÁèaÁ(}´Á7O“ÁFPlÁUvWÁpd&ÁapçÁR£wÁCô­Á5\ÆÁ'—ÁÁ j ÀüÇ<Àã¤ÑÀÌpÀ·ÔÀ¤«ÌÀ•”fÀäïÀH.-À èð¿¤t;ÂG?+²?³`@Šï@E¨@z'»@–¼V@¯Œž@ǽ @Ýî=@ðîÐAg˜Af×A dA ¯HA ŒA :1A‰×@ùÜJ@êg@؆@Ãõ@¬Q~@”›Ñ@w«²@Dh¦@˜>ß&K?ž%@YI@26 @a3Ç@†´ @›DÎ@¬ê¶@¼–‚@É=>@Òì½@Ù£†@ÜÕ¶@Üê@×Ä@Ï@e@Ãß@µª@¥Ù>@•]9@{û@X‚i@+<Ý?ùå«?˜¿U>Õ ¹¾Åk¿˜õÒÀ4ÀÀ6(„Àk¸À‘A>À¬ß…ÀÈ¿¾ÀåC(À÷ëÑÁá0ÁΑÁÂQÁ%ˆþÁ1ø¾Á>ð‹ÁLV€ÁY÷vÁgÙ.Á÷ëÁuýDÁhK®ÁZç€ÁMâ%ÁA8Á4ó”Á)GøÁ8ƒÁ Á ä¥ÀúÀÝ`ÀÀ\«À¤æÀˆÀXµSÀ"³³¿Û\µ¿g§º½æ—-?*ïð?µë•@ fÄ@5Ë@@_ [@‚Jü@’z#@ åT@¬@µaW@»Ñå@¾º’@½²5@¹FQ@².@§~a@š @‹}h@wIµ@TxÎ@+ö@Y?© ?ƾB¿l¼¿ÛÛÛÀ!)WÀUõÀ…tiÀŸøÀ»5çÀÖÕ|Àò}VÁd\Á‹÷ÁãúÁ%BÁ0ßÁ;Ò.ÁH&àÁTø«Áb2JÁo¼ÀÁ…éšÁ~JÁqVÁd-bÁWCÁKpeÁ?ÀCÁ4¡àÁ*JîÁ @Á´ÓÁN“Àéø»ÀÎ ôÀ²<ÕÀ–àNÀwÔ·ÀCסÀl¿¿¼Æ¿2@Ç=k+4?Fn¨?»¹æ@@. @Pø÷@o†à@„æ @¹@—êJ@íÀ@ Ÿm@ŸaÈ@›3V@”Âß@‹}å@}sf@aFÎ@Bç3@"½h?û«?©èm?(“N½ /Í¿A„¿À(ÀXÀCˆwÀvðÚÀ•c¨À¯ßÀʃcÀåj–Át®Á6/Á+ëÁ'`;Á1 pÁ;fíÁFyÁR.Á^lÁkÄÁx.ßÁŠ1!Áƒ¤ñÁz‡îÁn »ÁañóÁV=fÁKÁ@ õÁ4Ü_Á&~5Á(°Á 2ÀøM¼ÀÜ‚çÀÁIÀ§AßÀ>ÛÀf÷ÒÀ5YeÀãß¿¨Vë¿ÖC=͆M?@S2?¯0?÷Á^@…w@8s{@QŸ@es„@tçX@€ š@‚c'@¦@z°@ng@]vB@Frš@*ðb@ Ó?Ý+?š±?á#½å:¿5‡h¿³XÎÀE’À6ØýÀg¢CÀŒ¼…À¦guÀÀgÀÚjOÀõ¯ÁàÖÁRÁ#S^Á1(ºÁ=d~ÁGKWÁQÎ<Á\é§Áh—;Át Á€«ÁŽÊ¨ÁˆvøÁ‚CDÁxs’ÁlÁIÁa•¶ÁW–ÁI¶4Á;^>Á-C©ÁNÁbÁ®HÀìêÔÀÒ©JÀ¸—ÎÀŸÀ†\8À[DüÀ,Ys¿û¦œ¿¢ÙØ¿|ú<9b,?ýX?™¦?ËÝ@0å@<²@* Á@9–æ@C˜@HŽ@EÌÔ@=ï«@38Ý@#Ã}@5€?ê×ÍJ¾R ¿A)Ü¿³ï!Àè‡À1I¸À^½ À†ÔÄÀŸŸÀ·¼»ÀÑk´Àë3ÅÁ§zÁíŸÁ5ªÁ*µðÁ8uWÁFAÁS‰ÃÁ]œRÁh@¦ÁscÁ 2Á…‘7Á“®%Á‚’Á‡zóÁ¥Áx.ÁlõÁ^–>ÁPmyÁB}ëÁ4¥ìÁ&Ü‘ÁQPÁ 'BÀþ´ÀãðÁÀÊΣÀ²*À™²ÔÀ‚02ÀUØøÀ)G›¿ý¦“¿­)5¿Bæ'¾Yy«>•îë?>…?’X ?½„?ß¼Ï?üF@º_@ =ã@ p]@…Ž?ï©æ?Ó²Ý?­½Ž?y/Ê? å=ÂÆ¾ÁM°¿iën¿¼³¡ÀÍ7À1œ“À\o5À„s…À›*¢À²ÜÀÊ¥ÀãûÀü’JÁ -.Á7˜Á%c–Á2«5Á@¦ÁMœÁ[]­ÁiQêÁsúÐÁ~ºÁ„ñ˜ÁŠÁIÁ˜ÂoÁ’¾+ÁŒëoÁ‡Q­Á€õ„ÁsµïÁe½5ÁWðªÁJ&œÁ‚¡µ?é@?RÑŠ?ƒG?“å‡?œ§ž?™¨F?‹Øw?q@?=ÜÁ>äµà=°qW¾–3ö¿Hƒ$¿ž€‰¿Ü>wÀ9`À5ÓaÀ_O÷À„ ÊÀ™ûÀ°AýÀÆöÀÞJóÀöjyÁeïÁ÷BÁ ÀyÁ-ÉóÁ:äÑÁH!+ÁUƒsÁbñ’Áp†úÁ~c‘Á…2=ÁŠ›ãÁ3AÁžAÁ˜3BÁ’˜Á‹&Á„ˆ~Á{8·ÁmqÁ_§ZÁQÿGÁD«{Á7™øÁ*™oÁÂ3ÁefÁ(VÀñÜ™ÀÚH“ÀÃ+À­ïÀ— óÀ‚­ÈÀ^“ªÀ9¾ïÀIû¿ïoº¿´N-¿€ ¢¿%¢è¾±É½Þ =¬Ï->[^ >‹MÖ>+Ó>{õž‹ÀLæ•À`ÉÀv#»À‡‡À•(ÐÀ£z6À²DåÀÂ’5ÀÓ<Àå97À÷Ü[ÁèºÁ Á°äÁ%TƒÁ0‰°Á;Ô<ÁGFžÁS&pÁ_1qÁk†ËÁwù¸Á‚PqÁˆÍüÁZãÁ•ïIÁœ˜mÁ£VÞÁ¯œÆÁ¨ÉÁ¢2Á›N<Á”³CÁŽ4¬Á‡»(ÁOãÁv—ÁiÇšÁ]}1ÁQRTÁE›jÁ:OLÁ/ ÐÁ#ð(Á•ãÁoòÁ­žÀø VÀç!ÀÖj€ÀÆ—À·ôÀª09ÀÅGÀ“A¸À‰t]ÀÌÑÀvcüÀlÜPÀfÎJÀbC'ÀcEƒÀgaÀooùÀzWdÀ„B±À¯À—‰”À£èeÀ°ðÐÀ¾ÞÀÍʘÀÝaØÀí½ÀþÇHÁ¥tÁ ±Á Á&>ŒÁ0ålÁ;‡„ÁF¿ÁR >Á]n_Ái<ÁuFƒÁ€ÈlÁ†ô(Á=ŸÁ“±‡ÁšBîÁ ×{Á§xØÁ³©÷Á¬ð^Á¦A¨ÁŸ­”Á™1‹Á’À½ÁŒ[¦Á†DÁësÁs¯Ág™8Á[ØNÁPƒÆÁEAaÁ:-ÑÁ/®ÐÁ%nÁ«nÁ9@Á .ÔÁ¯Àñ4ÀáõÀÓ^<ÀÆ”rÀº«çÀ°e™À§ÀŸç„À™n£À•(À’ ¡ÀìãÀ.UÀ’1ÎÀ•â–À›À¢(ƒÀª´“À´‚‘ÀÀIµÀ͉ÀÚ¢˜Àé9úÀø0_ÁH…Á {`ÁUšÁ£ZÁ((!Á2)FÁGVÁHIŒÁR²AÁ]3!ÁgîäÁs)ØÁ~vAÁ„äèÁж]Á¸Á–Ý…Á?Á£@ƒÁ©Ÿ>Á° Á¼.Áµ¨tÁ¯<Á¨ÒGÁ¢v?Áœ?ìÁ–'ÌÁMÁŠßÁ„,Á|ðËÁqÑÁfÔÒÁ\+ÂÁQºÁG¬IÁ>@Á4ùòÁ+×ÌÁ#„LÁt¤Áç Á Œ“Á‹ÀÿÉÀôï„À럆ÀâÓÇÀÜ-tÀÖ ÀÒ6’ÀÏyÀͪ£ÀÍõ ÀÏFïÀÒŒÀ×ÁŽÀÞÀæwIÀï  Àù¼²ÁÞ'Á VÁ0ÁwÒÁhÁ':Á/wgÁ844ÁAJºÁJ²óÁTfÄÁ^m¹ÁhçÁsZˆÁ~#Á„¯ØÁŠV!ÁýÔÁ•ÉäÁ›ÇãÁ¡í¬Á¨¤Á®QÁ´¦§ÁÀ±)ÁºFƒÁ³ÜŽÁ­ˆÞÁ§YÞÁ¡JñÁ›A®Á•9ÁN²Á‰šÁ„—Á}+ ÁrtrÁgú!Á]ÆIÁT?‹ÁJô·ÁA¹éÁ9OÁ0÷Á)%ÖÁ!¯jÁ±ÅÁh—ÁNIÁ =Á°¬ÁkNÀúLØÀô£TÀð×Àî hÀì¼ÀìÖ†Àî*FÀñiuÀöo%ÀüTîÁ8vÁsÁ œ¶Á@+ÁjDÁúÁ%RÁ,ºÊÁ4GÁ<ÜáÁE; ÁNøÁWFhÁ`ÏÁj†[Át—éÁ ëÁ„ÂÁŠ+®ÁÊÙÁ•qeÁ›…Á åàÁ¦ßïÁ­Á³3îÁ¹g€ÁÅU”Á¾îJÁ¸¢øÁ²z£Á¬oÁ¦f¡Á _Ášw¤Á”ÂxÁ=ÈÁ‰À¶Á„^¥Á~BÐÁsøùÁjEPÁ`ê/ÁW§ÑÁNÖÁFŒ;Á>ttÁ6á‘Á/ /Á(õúÁ"¾§ÁØfÁÁ‘”ÁtÓÁ WIÁ ³ÕÁ»ÊÁcöÁÚèÁÙ Á—QÁBfÁ ’Á gšÁ?TÁs Ám+ÁÕGÁ%¯Á,*ÙÁ2ÝÁ:4ÛÁAîiÁJ rÁRtÞÁ[xÁd:ÁmH¦ÁvìÁ€SÁ…cOÁŠš´Á×ÉÁ•FyÁšçîÁ ‘øÁ¦>"Á¬®Á±ÿÁ¸…Á¾LšÁÊõÁÃÃGÁ½¡ Á·—ìÁ±èÁ«ŠJÁ¥¥íÁŸðwÁšhùÁ”ëçÁ„ÁŠEøÁ…ÖÁ€2‰Ávä‹Ám˜‹Ád­tÁ\9ÌÁSþÂÁLïÁDÌÉÁ=©ªÁ7E3Á1àÁ+Ÿ¾Á'ŠÁ"sõÁ£³Á“ÀÁ<Á ÁÆšÁgcÁFÔÁ’ÁÔóÁü ÁºÁ F=Á$xÁ)= Á.oCÁ4*¥Á:K€Á@òºÁGØòÁO`’ÁW`)Á_ÄçÁh.&Áq;ÁyõüÁ¯ÈÁ†„OÁ‹czÁ~ÄÁ•³ ÁšòµÁ gAÁ¦ ŸÁ«¸µÁ±gÁ·1Á½$ÁÃ;.ÁÎèËÁÈÌÁÂÃöÁ¼¼@Á¶¹¾Á°Ø‹Á«"øÁ¥•ïÁ Ášª¨Á•jýÁE,Á‹H2Á†{…ÁÅÑÁz‹=Áqõ Ái¤CÁaxîÁYùÕÁR½"ÁKÔÁE¨lÁ?­ÅÁ:|UÁ5ëDÁ1tÎÁ-àÁ*Þ^Á(ŒÕÁ&b°Á%>‡Á$óÞÁ$½Á%›ßÁ'g€Á)kÁ,×Á/RËÁ3‰,Á8ÛÁ=#‹ÁB¿%ÁH~ÕÁO^ÁUÐÁ\éÁd¯-Ám ;Áuq÷Á~ »ÁƒvÁ‡ø]ÁŒ¾‡Á‘’ÚÁ–{@Á›ŸÁ Ð]Á¦ÕÁ«ŽAÁ±44Á¶áÛÁ¼‘#ÁÂ]_ÁÈMØÁØ€vÁÒ!ÁËÏËÁÅ›üÁ¿y•Á¹iÉÁ³!Á­¿6Á¨.kÁ¢ÐÁ‚ÐÁ˜WµÁ“mhÁŽÊ›ÁŠS×Á…·gÁG‚Áz@ÇÁrIÁk ÁdBÁÁ^XÁX¢pÁSô†ÁJíkÁA±0Á9ÄÁ1?Á*8Á$rÁ°¸ÁFãÁn×Á¢(ÁLÁšÁ xMÁ%?YÁ+'µÁ2MõÁ:`>ÁC-sÁI¤ ÁMˆ}ÁR0”ÁW¨ Á]Ý6Ád|ºÁk7ÁríÁzöRÁÏPÁ†\Á‹8¡Á=×Á•m¯ÁšÔPÁ \Á¥ñÁ«¡ãÁ±€aÁ·ˆÁ½µ'ÁÃý0ÁÊP»ÁÓÓÊÁÍbÁÆý7ÁÀ¤`Áºj²Á´J¡Á®:ÊÁ¨LÖÁ¢ŒSÁœþBÁ—¥Á’ZíÁ;RÁˆb¥Áƒ×Á~±(Áu¬ Ám‹ÁdξÁ]2âÁV·ÁOÄ{ÁJ£ÁE7Á@´uÁ7@‘Á.øÁ%™>Á%žÁüÁÁ¿Á5Á ù»Á AÁ ÏÁWÞÁ‘9ÁÔèÁ)ÜÁ&ž/Á/#þÁ7\ÃÁ:¡iÁ>¯sÁC›+ÁI_ÞÁO®àÁVcÁ]ÍÁeuÇÁmç>ÁvÄRÁ€)mÁ… vÁŠDtÁ¦Á•*RÁš½Á m’Á¦NÅÁ¬[´Á² Á¸ÕÁ¿(ÁÅiÁÏYÍÁÈþÁÂHÒÁ»Þ!Áµ}‡Á¯;ìÁ©IÁ£ëÁ×Á—]ÐÁ‘ÓÁŒXÁ‡9ÁÁ‚'áÁzÈ‘ÁqÏñÁhÏ„Á` ÁWªÁO–YÁH9ÏÁA‹bÁ;£YÁ6ƒçÁ1ãBÁ-*æÁ#vÄÁVnÁ^@Á ´ Áó_ÁÜÏÀÿ6²ÀýdhÀÿ"Áa]ÁŒÁ ZèÁPYÁBwÁ$aáÁ(EñÁ+¼VÁ0IÁ54Á;KµÁAÉÁHç=ÁP2UÁXVnÁ`ò¥ÁjMRÁt¨Á~DCÁ„}xÁ‰ý™ÁžÁ•={Á›!žÁ¡4NÁ§i¼Á­®:Á´ñÁºp3ÁÀôWÁËHÁÄ[ Á½»FÁ·5íÁ°Ä¼Áª\%Á¤ÀÁî«Á—æáÁ‘ö"ÁŒ4ºÁ†®Á`qÁxB9Án?ÃÁdëÌÁ[ó÷ÁSÁJ¥ÁBV†Á:ªÁ3 Á-W½Á(ÌÁ#K>Á.]Á3Áo#ÁíÀþé¨ÀònkÀéJÀä¶•ÀâûUÀäë4ÀêFÈÀóÀ’Á .ÁdþÁ(EÁ|3Á^lÁÉÁ!ƒÎÁ' iÁ->TÁ4ÚÁ;@ÎÁBôÂÁKN:ÁTheÁ^®ÁhjÁr·ÌÁ}®_Á„cºÁŠ£ÁùõÁ–gÁœDùÁ¢‡Á¨ß!Á¯YÁµÞ›Á¼jÞÁÆ÷·ÁÀ"Á¹a!Á²¸MÁ¬*PÁ¥²,ÁŸAaÁ˜í/Á’ÂÉÁŒ¿Á†ÔÁxÁw!ÙÁl”vÁb'ÁXM§ÁO(ÒÁF);Á=‰òÁ5]~Á-:ÌÁ%ÐiÁHöÁÿÁÎÓÁ‘ïÁ oÁ¡{À÷ ÄÀç6ÀÙÁ<ÀÐSÀÊ=2ÀÈ’OÀÊÔXÀÑÎÀÛXþÀèBpÀø|®Á8¾ÁµÍÁ µrÁHÁSÁ4¯ÁŽ)Á&¤àÁ-ãàÁ5ç:Á>¯PÁHÁQöÁ\‡ÁgqÏÁrìÁ}ÜßÁ„Ù-ÁŠò‘Á‘ ßÁ—a\ÁÃíÁ¤F ÁªÌbÁ±cGÁ¸ÍÁÂäaÁ¼ Áµ5YÁ®jHÁ§¸Á¡!¤Áš¦Á”.¶ÁÏŒÁ‡œ–Áš9ÁwoyÁkñóÁ`ûþÁV~ÑÁL)ÁBƒÁ9u¿Á0†VÁ(DÁ NKÁc…ÁydÁ ™LÁŒ‚Á7wÀý€aÀõ%MÀá¬ìÀÐF¦ÀÁËXÀ·?ÇÀ°GDÀ®wÀ°µ<À¸•ÁyG Áƒ+“Á‰ËÿÁÁ—r­Áž\íÁ¥þÁ«{HÁ·¨ŽÁ°³ÃÁ©ŒöÁ¢u¬Á›túÁ”ŽÁ´öÁ†Ý Á€RÁs 3Áf))ÁYa¾ÁLÂöÁ@š˜Á5 oÁ)õ»ÁXóÁâÁ hÅÁ>cÀóyÀãã]ÀÕ‰©ÀǹcÀ¼GVÀ²ó˜À«+3À¤šÀ›SâÀ’4œÀ|)rÀ]Ú#ÀI!ÀA*ÀG­êÀ[ÄnÀxû\ÀÖ;À–â À›Ö¼À ]ˆÀ§®À°þÀ¼p<ÀǶÁÀÖ[Àæ¼ÀöÝÕÁ÷ÁÁÂiÁ%oÁ0ñÁ=™ÁImgÁVCOÁcRÁpl‰Á}Ð'Á…¼ÁŒ¦æÁ“lpÁ™á Á OTÁ¦Þ`Á³ÉÑÁ¬Æ7Á¥ÙfÁžñ]Á—˦Á¸Á‰¾bÁ‚ß»Áx ¾ÁjkTÁ]:ÁP#&ÁCl Á6Ö÷Á*žÓÁ½Á<"Á ¼ÏÀÿWÀìÐÌÀÚÿ€ÀʆÀ¼îÓÀ¯&ØÀ£z)À™‰³À’ÉÀŒ|iÀ‚åÀs;,ÀTvAÀ0³àÀcÀìúÀYñÀ+3}ÀN'·ÀlGâÀ}'ãÀƒ47Àˆ À'ÈÀ•yÀž½òÀ«@ŽÀºÌ…ÀÌ·cÀßVöÀò‹eÁÎMÁôÞÁßwÁ'ãÁ3uîÁ@h ÁMu†ÁZ¤šÁhÏÁuÚDÁºßÁˆSïÁŽ­bÁ•("Á›ÅÁ¢éÁ°¥Á¨ükÁ¡ð_ÁšòÁ” bÁ7GÁ†kÁ~ 1Áp*.Ábw ÁTÅVÁGGsÁ:/bÁ-„Á! úÁÔÁ P–Àý={ÀèCüÀÕTÀÃPÀ²û“À¤DíÀ—SàÀ‹®[À‚1ÀvpãÀlÕMÀYé¿ÀDî:À.þªÀ{ž¿Ô.Å¿¼–¨¿ÊKœ¿÷Ï¥À"ÈÀ=H;ÀR{[ÀZæxÀa^÷Àc®ÑÀn~>Àj³ÀV À \‹À´±@ÀÇCUÀÛëÀòÄÁÛÁáÁ®SÁ*¯‡Á7­ÁDç÷ÁRtñÁ`?Ám›[Áz8UÁƒ}¶ÁŠÙÁ³uÁ—~ÙÁž\\Á¬pÍÁ¥JõÁž1²Á— »ÁGÁ‰!&Á‚FÁvê¤Áh̲ÁZÃÎÁLýbÁ?N"Á1«ðÁ$iöÁ¯œÁ _pÀþ¨ÏÀçLJÀÒdüÀ½¢’À«À›êÀŒ~ÓÀ}°hÀfºÀTL½ÀLÔIÀD¶ÉÀ5óÀF(¿ýô念ëá¿bÑR¿( 1¿9Ez¿–<¼¿åD©À¯2À/6ÀÀ/–(À%œñÀ'ÁkÀ3Ë•ÀJ&ÆÀia}Àˆ-Àœ“åÀ°AÄÀÆ2¿ÀÝÔ]ÀöŠbÁ€Á rÁ!å«Á/.ÀÁ<ÇÁJm ÁW"äÁcÉ7Áp¦}Á}ÚÁ…«•ÁŒ…žÁ“hÛÁšY4Á©^Á¡É©ÁšÆÁ“jWÁŒSÜÁ…GÁ|‹HÁn«µÁa:ÁSaÉÁE‚jÁ7¢?Á*çÁYøÁè´Á ‡ÀëÄGÀÔDXÀ½‘3À¨CÝÀ”¤Àƒû×ÀeªÀD[À-àÀÀÂ3ÀÖÝÀy£ÀI²¿ü I¿¯‰¿2Ðļäm%>˜â>4¨õ¾ÚÓ—¿—Ð ¿ò3¦À ј¿ñ>;¿Ü-¿Ü‚·¿÷&ÀǤÀ7¿=ÀcküÀ…†‡ÀšðvÀ².öÀËKîÀå'Àþ‡€Á =Á†ÂÁ'7iÁ4$ÅÁ@¯ÜÁM_aÁZ_,Ág¹ªÁu^¨Á)Áˆ|«ÁxÑÁ–Œ„Á¥ÎôÁž}³Á—1wÁëÁˆ¯bÁŠvÁtï@ÁfàáÁXîVÁK&Á=…xÁ/ÜgÁ"1êÁ®@ÁXsÀóŸwÀÙšlÀÁ*ñÀ©åîÀ“oOÀÀÀ[À5SÀÆø¿éˆ¿Ås¿¿µ›«¿¾›.¿ÐFŒ¿Û6!¿~(´¾/ÛØ?3³†? ­“?xv-=æÊà¿M\¬¿Ðf¿±Ž ¿“ÉÙ¿E;¿v{N¿Ž.¿Ä®À À7Ü‹À`d„À‡iÄÀ 7­À¹´ÖÀÓöÀí ?Á%;Á3ÆÁ¤þÁ*@®Á7«ÁD*ÁQ²•Á_mƒÁm@üÁ{3³Á„ª™Á‹Õ"Á“°Á¢¶ Á›LÁ“ñuÁŒŸ8Á…RÁ|çÁmŸØÁ_WnÁQ;ÁC<ÚÁ5aËÁ'´iÁÁ wÀþEÀä/ÀÊG”À¯¿À––>À5ïÀUêLÀ0^JÀ õÁ¿»–Ä¿wʪ¿Pe¿?®Ù¿W ¿LrÝ¿ƒã>¿]<»o… ?r ?ô8ï?°÷Ü>àû÷¾þß¿g!H¿3ªÁ¾ê¶¾‘—j¾Èß¾ìXº¿ZuпljOÀ GÀ:PkÀjãmÀŽ»zÀ¨#7ÀŠ¢À܃vÀõvŽÁ*†ÁÑ…Á ±½Á.FÁ;À4ÁI‰ÀÁWx%Áe’TÁsçøÁ7ÖÁˆ¹ÁûiÁŸð€Á˜fPÁæeÁ‰tìÁ‚`ÁuºÁfçQÁX\ÁIãžÁ;nÁ-ÍÁ¨OÁñ¦Á[ŽÀí‡0ÀÒ¤jÀ¸Æ‡ÀŸGŸÀ……–ÀY™À.ÏÀNU¿ÇÂC¿NO‘¾–¯è½¯'>pï¢=áÎ+¾/I¾¹Ë¾Lk>¢A?•†ï@àí?Ýq?UØ>#)=@=7¨¾>Ú5M?.ÛV?€=“Pi¾“}@¿r™œ¿Í§îÀI$ÀH+ñÀzÁbÀ–íùÀ¯’XÀÈt°Àáp`ÀúÈ…Á z7Á Á%Ô[Á3½ÁAÐ÷ÁP'BÁ^·’Ámw7Á|WeÁ…ÇÁàÁKÜÁ•¼ûÁŽ1Á†¥2Á~8 ÁoBÏÁ`q¸ÁQÅcÁC)„Á4Ÿ„Á&(zÁå×Á ñàÀøaÀÝ0ÙÀÂmJÀ§gbÀ}£Àh‘òÀ6ÿÓÀ Ïn¿ÁãÏ¿|³¾^Ü_>€^b?O9v?™­Á?…€?AZ^?(~Ï?F¢ò?ŠØM?ÙQ@ $¾@r?Â9É??mtg?w0µ?¨V?Ø”¾¹Ð ¿ˆÄ¿è ËÀ$8ªÀTw…À‚¡9À›fÀ´’ ÀÎyÀèÎÿÁ"PÁÁÁ,i#Á;$ÁIÓÔÁX·øÁgœ!Áv€JÁ‚¸ÀÁŠ@\Áš×5Á“6¼Á‹—UÁ„FÁxã^ÁiËlÁZ³ÇÁK¦õÁ<ÀµÁ. ¨Ák¹Áã§Ám¦Àèa“ÀÌà¬À±«¾À–´^ÀyÂuÀDàÂÀ®Ï¿Çî)¿fhm¾®ªK>nO?LÌ=?¼›ÿ@Th?ü²?ÚWë?ËÒ?à#å@ ™@Ûf@F¸a@:ëå@Ýc@ö6?òå"?õÏ@‹o@&Xí@®?©Ü(?C±>gëõ¾íg;¿›U¿ô¿¼À+`4À\Ê À‡³»À¡•À¼êYÀØŽÎÀô¯{Á¯ŸÁX,Á&4bÁ5‹ÁCü´ÁRå·Áaí:Áq»Á€+GÁ‡ÓÉÁ˜xÁÐ3Á‰.—ÁÈÁsÙñÁd™›ÁUieÁFLÆÁ74ÔÁ(,ÁïÁ OÀ÷[âÀÚQ÷À½f³À¡JÀ…û ÀUîSÀ!Ò>¿ÝÛü¿xw|¾è•>—¹Ò?Pð…?¬ð”@Ã@4Ws@:ò…@+i@$…°@*ûÉ@=Tí@SÆ÷@vq‰@oŽÆ@TG©@F‘Ý@7ûï@9¾@JŒa@ZuÕ@,—(@S“?ÁT?]%ú>?Ø¿‘Ê¿¢ûìÀ#À5ªÐÀk"dÀ‘EÀ­A|ÀÉó*Àçb6Á”õÁyÁ ^ëÁ/\»Á>éÁMÇëÁ]œÁli­Á{¸ÌÁ…†RÁ–gøÁŽ¥ØÁ†èþÁ~hçÁoçÁ_Ê’ÁPˆóÁAGTÁ2:Á"ÒHÁ¶.Áž;Àë lÀÍ0ÒÀ¯à^À’Ý–Àkä¢À3š¿ü y¿‘˾¾¹#€>µª?>Û?¼±@Œÿ@,‹þ@[Šä@wæ—@iÞÞ@cÂå@h™¿@y©/@‡2„@•R @“ív@ˆß¬@‚$¼@w<•@xÞ¤@ƒ“*@ƒ¶@ZçÉ@5èR@ª?Ë?fE>þÕ¿%ö¿¸æ6À\æÀK¸¥À‚ˆ-À "¾À½ëÀÛ³hÀù¤ÙÁ óTÁ<†Á*‹ÅÁ9Û»ÁI,ÃÁXŠØÁgöèÁwfzÁƒkÁ”~\ÁŒºQÁ„öFÁzdwÁjÞ™Á[^ÚÁKê9Á<ˆ'Á-8<ÁöWÁ´¸ÀþæÉÀàvÀÂ?+À¤FÀ…æ ÀPÊÀÒh¿¹÷¾¿¨8>}8u?‚S?ÞÅÛ@Ëy@0?@Z,@‚ÐÕ@š+C@”–Á@‘–Œ@“1@š}·@¥0F@±ZZ@±5@§ñ@ ä¼@›eÏ@œu@¢YŽ@šÀ@†Úz@iv@?mé@†ô?Åj”?AÜŸ½•´¿sÇì¿ìˆæÀ1ÇÈÀmXlÀ”–žÀ²×cÀÑn‚Àð¿ÁQWÁ¨SÁ&µÁ5„FÁDóØÁTd*Ácá?ÁsfÁxAÁ’£èÁŠØ Áƒ!Áv‘©Ág iÁWSÁGù>Á8qäÁ(ñ%ÁuwÁ 1ÀõRÝÀÖÇtÀ¸D7À™ÁÀv’À:#õ¿ûˆX¿ƒ«E½ý4?G³’?ÐiQ@ãÚ@G‹Þ@dÆÎ@ƒÆg@™S'@¯¬°@´J3@±[‹@³$w@¸â¬@ÃFE@Ή²@ÏJÙ@Ç"0@À *@»@’@»Ís@ÁR@³(|@ lP@Œie@mpÀ@<Üz@ ¹?£©^>Â4…¿ (N¿¾(‹ÀœêÀXÐfÀ‹pÀ©š­ÀÈbÅÀçCðÁ¤Á6Á!õfÁ1yßÁA ™ÁP§}Á`IFÁoëÁÁ‘ Á‰<-Á`©ÁsÞÁchpÁSÊòÁD2œÁ4 ˆÁ%ÁŽÁïÀíàÀÎWÀ¯ÔÀLˆÀcDwÀ&=û¿Òo¿1»>³`?™,i@ÿ@@•Ê@s¡Ö@ŽU=@C½@°<Å@Åô@@ÓÙô@Ñ2J@ÒÈg@×¾F@à¹@ì:–@íà@æŠT@ßO³@Û&.@Ûž›@ß•@̳„@¹ @£—8@‹L@`›Y@&ÄE?Ö P?9¿ý¾l<Ž¿—ì…À 15ÀFñæÀ‚ZÀ¡;IÀÀ‘Àß!Àþ[ÁÏKÁqÁ.ßÁ=´ÙÁM^»Á]ºÁlÏÁ|’¼Á¥fÁ‡ÆZÁÒÉÁpÁ`b©ÁP«uÁ@ôAÁ1>ÑÁ!”­Áó&ÁQÊÀåjÓÀÆFZÀ§5lÀˆ+vÀRgÙÀxÔ¿­bÁ¾ÈŠÑ?1Ú?Â%ä@ (@ZÍ@Šý¥@¦°»@¸_+@É/@Ý‹@òÎß@ñõ@ò}Ç@öä @þÉ–AºAa}Aß8@þ¶Ÿ@û‚@û{¦@ùT@åå@ЀK@·±@šŽË@x|è@;I?ü,¶?H*=8o»¿k‚\¿ñ~À6ìëÀugÄÀ™ôŸÀ¹5\ÀØv‰À÷¹ðÁ /ÁM®Á+öÁ:í‹ÁJÅVÁZüÁju˜ÁzM4ÁŽa±Á†z»Á}(TÁm\=Á]‘kÁMÈEÁ>åÁ.LùÁ•ÅÁÞ‘ÀþN¹ÀÞàPÀ¿ƒÀ @À€ýÀCtXÀît¿@I¾ O?T÷ÿ?æZ @0ÖU@nVè@•®²@´+?@Òu—@ãØ@õ—aAøA~]A ’A ŒA¢ùAÇ{Aì ATA»A ¤A °IA cK@ý…_@áDè@ªô@¤|@…;Ý@L9@†¡? ‚>Ž{í¿2Çò¿ÖfîÀ)´ñÀhƒ¦À“ÖŠÀ³nƒÀÓšÀòÃOÁ 9CÁßÁ(è{Á8ÀBÁH›YÁXz4Áh\Áx@RÁ‹#Á„8ÄÁz¾ŽÁjåÁ[ ÁKC}Á;vÁ+ªÁßéÁ +Àø§wÀÙ!ƒÀ¹›ÑÀš#XÀuißÀ6¿ïsy¿dΞ=ªG†?‡°@@bY@@ã@~ôÔ@žqì@½_@Ü/@úÓëA¶|A!7Au/A¼A×¶A~A"¯ŸA%£A!äÛAðA{’A¥}AØ´A~^@éño@Êæ#@«·w@Œ€H@Z…E@Ê?¹¿r>í¦µ¿Ø.¿ÁAÜÀó¼À_RúÀiÀ¯8¥ÀÏ×ÀîëæÁeÁV-Á'FüÁ77ÊÁG(™ÁWhÁg 6Ávû¥Á†ükÁ€ ÁraÁdòÒÁWÞQÁI+Á9HmÁ)eÍÁƒ4Á ¡­ÀóŽ·ÀÓð'À´^üÀ”ÖõÀj¢À+–¿Ùa¿5ù!>Œm?¡3@ƒT@NÐ@†Q@¥—Z@ÄÝ@ä"ÕA ´A"lA×XA'…FA(íøA*—ÏA-ˆ%A1ÈqA5%JA1ˆ5A.ÉA-vŸA'BÏA§7A Ÿ@ðƒÛ@ÐåÛ@±HM@‘ªÀ@de@$rÝ?ÉJÃ?_—¾×¬¯¿µ†#ÀÀZ^ ÀÂÀ¬ü€ÀÌã>ÀìÉüÁX`ÁL±Á&A>Á67AÁF.˜ÁV&ùÁf +Áv ÁƒC«ÁxGWÁjA:Á\mÚÁNÏ–ÁAŽ·Á4ºÁ'…Á¢øÁÁÀï¾ìÀÏûÊÀ°8§Àu…ÀadÄÀ!Þ¿ÄÓž¿ n´>à’?¶;J@)˜@Y5‹@Œ ¿@«¦¸@Ë,²@ê±AþÄA¡£A$DA3ç`A8ÛõA:ajA=AA…ADÈøAA1A>¨–A9–›A)ÁÕAÒA ר@óºy@ÓÅ @³ÐÈ@“Ûð@gÎ0@'ä?Ïõž? D{¾¾Ä¿¯„„À«òÀW•¯À‹ÂŒÀ«½!À˸UÀ볊Á×_ÁÔùÁ%Ò”Á5ÐIÁEÎVÁUÌ£ÁdlùÁryÁÞÖÁq:<ÁbÄ™ÁT‡‚ÁF!Á8ʽÁ+T^ÁWÁÀœÁSGÀìÄÀÌA8À¬€`ÀŒ½@ÀYô;Àmõ¿µÏa¾Û Y?“h?ÇV>@#1d@b§å@û@°¢@ÐI&@ïð7A¾ AA'D™A7ðAFÅ©AJ3“ALÄCAPa®ATDsAPäRAIýåA:üA*A sA $@ôLç@ÔQ²@´V}@”[I@hÀ(@(É¿?Ѧ¬?#s²¾¸Ëå¿®ÌÀOÀVü¸À‹y‘À«tÅÀËoúÀëk/Á³DÁ±]Á%¯²Á3œÁ@¼~ÁN»gÁ\ÿÿÁkcŸÁyý‰Ák6Á\0êÁMKÁ?oÁ0ÊÁ"ähÁ8ÆÁ×Àö¿€ÀÞšÀÆöÀ©ôÀ‰AÀRâÀB.¿§D‰¾ Û?.v7?ÖYò@*®ª@j0Z@”Ù@´š_@Ô]@ô ¤A îfAÁïA)•wA9iAI<ŠAY*A\weA_ÓïAcÒ@AZDÇAJFpA:H,A*JAKõA N@ô Û@Ô¥Õ@´ªÐ@”¯Ê@ii‰@)s~?Òúæ?&ž¾³u¿¬É]ÀZºÀVPÅÀ‹#hÀ«nÀËÛÀëiÁ¥@ÁšÁ<Á+™Á9CÁG£¾ÁUùYÁdƒáÁtX®ÁeL`ÁV`JÁG€ÐÁ8Œ­Á)ÉgÁDîÁ §Àþ‹ÀãÀÉü{À±áÀ™› À„À‹ÀKØ&À 8k¿™]à¾Rìs?IE†?ãË´@1…Ã@q%¬@˜bË@¸2¿@Ø´@÷Ò¨A ÑNA·A+—…A;wñAKX]A[8ÉAk@AoXÑAjŒ5AZšAJŽþA:eA*‘òA“»A •Ó@õ0¶@Õ7 @µ>@•F#@j›k@*ª‘?Õsl?+#n¾©?ø¿ª1³À ´ÀTúŽÀŠu´À§j±À¿)Àئ®ÀóaÁN»ÁŠçÁ#æ„Á2:ÏÁ@ϦÁOšÁ^:Áov¥Á`3+ÁPî;ÁAÆEÁ2ÃúÁ#ã9ÁùÁ™ÀïðÀÒÉèÀ·€—ÀK À„QšÀ[hÀ4!ŠÀG$¿‹•<½Ä˜©?fN?òBË@8Á!@x`Ü@œL@»Ð*@Û™@ûY/A Œ¢Al¬A-N™A=3ÇAMPA]KAlëEA{ –Ak!A[±AKGA;ÛA+!wA%ÊA +@ö`õ@Ökæ@¶v×@–È@mr@-/T?ÚŠl?5l_¾”ª¨¿¥ÀmPÀI†Àu—iÀ“ `À¬6^ÀÇT…ÀãµÁ.&Á€|Á#íÁ,~Á;\ÁJK÷ÁYž›Ájæ¤Á[vùÁLŠÁ<ßÃÁ-¢Á]YÁ8KÁGžÀâã>ÀÅÀ§»À‹¢5ÀbTÀ0,YÀ·t¿ÃÊÌ¿l}l=z97?…Û @ÂÏ@@Á@Üv@Ÿ…K@¿‰A/&xA?gANöUA^ÞDAnÄ×A{kÝAk™A[¡AK¨A;¯äA+·¬AÀÄA Ëð@÷³¯@×Ñ„@·ïX@˜ -@pI@0y¡?áp¨?Cܾl­¿œï¿é¬EÀaÀLßÀ€XbÀœfÃÀ¹’ÀÕ3ÀóhÁ‹UÁÂ+Á',Á6XàÁE¼åÁU7ãÁgKÁWt-ÁGê+Á8mŠÁ(ò³ÁŒïÁ J4Àö#ÛÀן-À¹lÀ›É/À|¯ÀAQþÀ ›¿±ç ¿N­À¿5e>–ˆŸ?Ÿ¦ž@ ëS@KeÉ@…6[@¤º{@Ä>›@ãÅA©[ArÔA!>&A1 AA@ßAP¹nA`™Ap|ÞAy^aAj£—A[AAKŸOA<9tA,ïJAÿ@A G@ú?¢@Úaá@º…µ@š«Ñ@u–t@5ж?ìò?Y7¿5ö%¿¦—¿ëÀ*ªqÀc°œÀŽc»À¬ ¶ÀÊŽzÀéËÁÐMÁEDÁ"ÓþÁ2i4ÁAÿáÁQ›Ád(VÁT]$ÁD”ÎÁ4ÖÁ%#æÁ‚9ÁöÔÀìö:ÀΉÀ¯p„À‘Àe’À)Ÿã¿ÝG•¿Zr^¾H <•$½?[?¿¯D@Y„@X‹á@‹N?@ªs)@ɹF@é;A=ëAÿA#ÄéA3ACVõAS"4Abî…Ar»²Ax^Ai^ïAZ)FAJšÖA;A+¼›Ay,A _v@üÎ÷@ÝÅ@½<+@y)@{ª@<Ê^?ý¢?‚ê>¨¥½·²‹¿ Á)¿«˜wÀ“íÀKäÀƒõþÀ¢·‡ÀÁÛ‰ÀáÃÁ#èÁÆGÁz¬Á/<ÀÁ?èÁNÛxÁaû¸ÁR,ÁB0¤Á2R4Á"zYÁªþÁÞêÀæ%µÀÆ—ÐÀ§4dÀˆhÀRU,À⢿±·#¾æ0%>A€>“B¾?H_Ë?ÍñE@"â/@`©@€y@®Ø“@ÎK/@íÍñA³'A†¾A&_ŸA6Ïhð>Tî½ã`¿~⛿úœYÀ;¥ÃÀyéÀœ1lÀ»¨ÀÛ@«ÀúòÖÁ Y¿Á:ŽÁ-`Á<ü5ÁLß[Á`^¢ÁPmYÁ@|UÁ0Á ¢3Á»eÁÚÖÀâËÀÂDgÀ¢rfÀ‚°âÀF+ÒÀ3¿‘6ʾ`HW>µì$>¼H\?NÖ?Óÿ@@%íª@c,p@Î@°J@ÏêF@ï XA²PA™TA'ƒÓA6ÿtAEH¿AS€.AaÙÄAp3QAvYbAh»•AZî\ALYA=YA-Ê*A¹MAÜA3Û@ã+-@ÃO@£}¤@ƒ¾½@HPg@ æb?œ*d>ع>à<Öú¿Uvü¿åûÀ1òÅÀq2°À˜JåÀ¸_À×ä]À÷µÓÁ Ä Á­­Á+—wÁ;pÁKlÐÁ_iíÁOoQÁ?ušÁ/} Á…öÁßÀÿ=Àß` À¿Ž ÀŸÇ‰À€’À@ãUÀ迆~Ò¾%ni>¤>C; ? òo?Ã*?@—@\:M@‰@­ ð@Ì"y@ë-AA{“A#sÌA2&€A@²òAONXA]ÜËAlxÍAoqfAbATjAFÿwA9EÚA+CÔA&AU@ýá{@ß ‡@¿î{@ |¾@Ä@C©@»K?ŠX±>0bÓ¾ö˾/~@¿Z1¿ä$¿À01!ÀnäÀ–ïÀ¶–ŸÀÖXkÀö*SÁ hÁõOÁ*éÙÁ:àYÁJØXÁ_ˆ•ÁOÁ?˜ªÁ/¢ßÁ¯Á¾Àÿ¡GÀßÑÀÀ³À i„À€îÀC`"ÀæÇ¿©¾³u<õ§¸¾XÍ#>ª=*?¤‹É@’@O,¥@†°_@¥Þå@ÅÊ@ãó™A;`AR˜A8A.ûA<ÁÆAKl5AYþƒAhyØAgƒ3AZÁjAM‡6A@KqA2߉A%HÔAƒ¬A Vf@õBó@Öõk@¸w±@™Í¿@uë@6öC?ñ%?faø½¤$ª¿T ¿qü¿Š4~¿ó·›À4ç˜ÀrzÀ˜†[À¸sÀ×¹ÏÀ÷zæÁ ¥'Á‘ÒÁ+‚Á;tûÁKiðÁ`ÁP˜éÁ@·Á0Ú‘Á!$Á8¢ÁcsÀã* Àî¶À¤eÂÀ…s¢ÀNM-À‰¥¿»®û¿R;ï¿[ó¿9ˆ@=õ*\?Œ´@õ@CD¢@€¹@Ÿhù@½õ?@Ü\j@úsHA 8kAäA)Ù÷A8`AFzûASé0A\ÝsAZ{©ARdAE×eA8à>A+¹ArhA)Az4@ë w@Îfë@°Ì·@’–U@h²@*1Ï?Øí²?7^®¾‡³3¿„~¿…*-¿½#IÀ óÀBS À|~Àœ{ÊÀ»M‘ÀÚvPÀùÕ€Á ¬vÁzÐÁ,RUÁ<0³ÁL*ÁbJtÁRv˜ÁB©òÁ2ænÁ#.±Á†}Áó[ÀèûÀÊfdÀ¬HÑÀŽ(ÀcW*À.é¿ü: ¿µåÍ¿—ÜF¿‚½2‚?l›Ú?ñ³›@5Ú @rÏØ@—âÒ@¶@Ô*u@ñ÷~AÆ”AC$A$@¯A1¯NA>­4AIxJAN çALe AF,fA<¨A0¹PA#ù0AîÝA Í6@ùé@Þ/=@Âæl@¦´ˆ@‰8@WøÂ@©QA8XeA0þBA'øAYªAæîA B@éÙ6@Ïyý@´äÉ@™³a@{Ò @C!¦@þý?›£A>ŒôÙ¿*Q©¿Ï¶ÀñôÀ.àEÀN¶ÀyG'À•R À¯ÀÀËÅQÀèѬÁF~Á`ÜÁ!¦ìÁ1 aÁ@ŒtÁP¦ÁhqæÁYÁI¢$Á:L—Á+DÁNÁ /žÀý=êÀàä£ÀÅl±À« ’À’³!Àya„ÀVM›À=ªƒÀ澿·ñ€¾ù ˆ>ëF÷?³6¸@é@Pͯ@…û>@¢Ù<@¿'¢@ÚsÃ@ô¶¿A8AAÅjA'S1A-ÏA0›A/!…A*{ÝA#¤JAÌAu,AøI@ór<@ÙÞ @¿å”@¥“(@‹%ÿ@`L–@)?x?â|?any½M2¿t´¿ñõ·À4ôÀ]‡<ÀzRÀf!À¥ÂÀ¾~]ÀØ}Àô#çÁRqÁì¼Á%ÉÁ4×GÁD ÄÁS^OÁl¤;Á]lÁNQíÁ?\ÄÁ0–>Á" KÁ³nÁ£ ÀðÿÀÖMDÀ½ø6À§g²À”HóÀ„ETÀeˆÀ(ä+¿Ù}§¿B÷š>2¥Ü?ŒÛ¸@‡@;7è@tö@•U‰@°Qa@Êk@ãhZ@û³þAû¬AGxA€ A^±A ý‹A )+A›.A*&A¸A\X@÷ˆ\@à˜*@ȸ7@¯€%@•ɲ@wß@B«@  3?¬^“>ú"¢¾ÐF¶¿§“žÀ ŠÇÀHŠÀù¦À”ÿ«À¥–GÀ¹!VÀÏ»¹Àè‡9ÁahÁä¼ÁߨÁ+5dÁ9ÐuÁH¡ÝÁWžgÁq«%ÁbËEÁT ÁEx£Á7 2Á(áÿÁÔÁ ‘Á ÀéÏ]ÀÒöãÀ¾¹sÀ­<4À™ÎÀwv÷À;s¿ÿžN¿‰¢g¾Ô@?AV/?Ñt @ æT@Vîæ@…¨ @Ÿ67@¸9š@Ð)V@æ`¸@ùèêA»A VA˜ AïùAƒA %As9AhY@óJ¬@á4Q@̧@µ9™@Ê£@… @VºY@"Á¶?Ür?cÈý=% ¿RÇ¿Ø×ÓÀ%švÀ_kfÀŒ¡"À©ý*À½53ÀÏ RÀãt[ÀúM­Á }êÁ…ÍÁ#ó«Á1¶zÁ?ÒLÁN4ÝÁ\ÐXÁw‘’ÁhóÁZƒÌÁLP>Á>eÈÁ0ÕOÁ#²tÁ;Á ãÀþÏñÀéû­À×]ÀÁ`À£aÓÀ…ËÄÀP” À±¿·Ï÷¿ ·>©©À?˜7p@¼ò@5a™@gÿc@Œ•Ì@¤2@ºX§@Ω~@à€@î æ@ùÚÃAÖOAÒAÞ@þ˜<@õWª@çÆ‰@ÙY@É…@µ³a@ sÿ@‰÷=@e™@4*Ü@ˆ ?œn‘>Ê÷¾Ý‚U¿¢t‡ÀrÀ?´RÀx‚.À˜Æ©ÀµoÀÒÂrÀç-aÀù»YÁZ|ÁÖ¸ÁÁ+üÔÁ9XÞÁFîêÁTÖ‘ÁcêÁ~ÐÁoØ:ÁaÖ³ÁT™ÁF²\Á9²6Á-1 Á!ÄÁ‰Á ð<ÁB5ÀéFÎÀ˯õÀ®+tÀ‘ ÂÀh|†À.åÒ¿í¼ç¿}ؾù?-ž«?½½’@Èà@Aà@pç.@Ž©†@£ h@µ§Ì@Å2}@Ò˜é@ÜÀ$@ãñ÷@çc@åûû@àâÆ@ØËÕ@Ìj@¾>@®×ˆ@ž £@Š5@iz«@=@Ô ?»Ã¦?/®ê½ï”ú¿n;¿á9ÁÀ%èiÀ\¦ÇÀ‰ÒiÀ¥Æ§ÀÂVÀÞôàÀû¶jÁñÁ“¬Á@UÁ(Ä›Á4÷XÁA·™ÁNëCÁ\nÑÁj'¼Á‚ªÁw{aÁiéÁ\ªÁOÎUÁCTæÁ75µÁ+¸OÁ!wÁ"¤ÁÜ{Àô:À×ZÊÀºžÍÀâÐÀ¬ÿÀKƒnÀ/°¿¿Kº¿-(ë=þ˜?eÊ!?Ôgq@¹0@EA@nžÅ@Š{¨@›—Û@ª7@¶9¹@¿W@Åú@É)@ÇÃÍ@Âí@»ù×@±ë@£8v@”_ @…@fD@<ªö@óý?Êãm?_öw=è´'¿()J¿ºÀcÀÁFÀEµ‡ÀzÿÀ˜Š«À´Àϵ{ÀìJÁQãÁ¡IÁsšÁ(c¤Á34ÜÁ>ÀõÁJçÒÁW,Ád¡®Ár ŒÁ†¢ÜÁÛÁrÀ¹ÁfÚÁYƒVÁMsHÁAõFÁ7$ÑÁ,ÁhDÁðcÁˆ©ÀäRÍÀÇûíÀ¬OÀ€'ÀjïÀÀ6tTÀü‘¿žäœ¾ñ<¶>‘1j?`‹?ÛLF@*Ð@>[4@a×N@€žt@Ž]FN¾üÎv¿Ÿ“À.À3~PÀgrÀÂôÀ¨R3ÀÂÿaÀÞTÀùäJÁ ­ÁB¨Á'~§Á41”Á>W\ÁI@*ÁTÎÁ`çxÁmw2ÁzkgÁŠôœÁ„w[Á|9­ÁoÆUÁcÄ^ÁXFëÁMcëÁ@¾¢Á2>¿Á#Ö^ÁoûÁ3SÀò©ÝÀ×ÀÀ»…ðÀ Û(À†qÀXÎ À'=õ¿ìœd¿‹óh¾º«%>ªK¡?fó?ÎÕð@ ë”@,ì}@JÇy@dK@xi@„”@‰Oh@ŒMF@‹?\@‡fJ@H @p¾K@XÞº@<˜‘@ù@ê2?½Ð ?\ún>Y!0¾èÙ+¿“‘¿îa‡À&ùxÀWVÀ„æ Àž­×À¸ØuÀÓ> Àíâ÷ÁadÁ9Á 7Á.@°Á<|«ÁJ!UÁTo_Á_iUÁj÷!ÁwÁ¿%Á•oÁ‰<7Áƒ ¯Áz#¿Án§oÁc± ÁUgÁG&§Á8Ô>Á*œÁœ‰ÁÔ_Á žÀæ¯åÀÌB¤À²8MÀ˜a¸ÀdºÀNtÍÀ•¿ÞÙÑ¿†4|¾À +>ƒ\.?UÙÓ?¯Ì0?î~Ï@@&@*Ì2@=õ@@LŠÿ@Vaí@[mF@Z×@R‘z@G‹@6@ Ú@ŒW?Ñ…k?–í}?*<Þ=à:‚¿B¿”%Þ¿é€OÀ!_yÀNǸÀ~ À—ƒ3À°ˆÀÉ×°Àãý,Àþ3mÁ cIÁÑDÁ'JkÁ5ŒÁC<ÌÁQuuÁ_®Áj¡mÁu¨IÁ€š‡Á†›AÁ”bçÁŽ©3¾+s¿0ÐÌ¿¢D ¿ò[ªÀ"|5ÀM,éÀyÄÀ“vÒÀ«#ÀÃ\ÀÜU#Àõg¬Á¥:Á¯sÁ!×Á/KìÁ<ÏjÁJoÐÁX[RÁfq°Át¥uÁ€scÁ…ûÌÁ‹ÁjÁ™pÄÁ“€/ÁÂÁ†û.Á¾Áq‰DÁcZ“ÁU`UÁGš¹Á9çÁ,JDÁý2ÁÁ˜Àð–¸À×ýÅÀ¿j£À§-ÀuÒÀs܈ÀHpÀ½Æ¿ñz¿©Âr¿K“*¾šÌÍ> øÑ?:??Z¢a?Ží?©¡?º¹r?Âë?Ád?´Ö¸?Ÿ¿¾?„Y•?8[“>®Åa½£I¯¿±¿€Š>¿ÁåÉÀW•À)†XÀQ²òÀ{f À’ëÇÀ©MÀ¿âBÀ×B=Àï7úÁ pÁŒMÁ`>Á*hYÁ7{MÁDÝtÁRj0Á_úúÁmÀŠÁ{§Á„×÷Á‹gÁ‘)¾Áž¼²Á˜¹‡Á‘›qÁŠ€Áƒf7Áx½QÁjíšÁ]CpÁOéÁB&°Á4òàÁ'þLÁ ÁgæÁàÀë¤PÀÓ©À¼ØÀ¦MgÀTÀxDÀPVÀ+SUÀÌ¿ÐÊÞ¿” \¿=±1¾Áb´½t~I>7‘s>ÀÊ'?Áñ?¼?‘Ó>ð×Ý> ÊY=ÔçØ¾?q¿ £P¿ržA¿±J¿ìÌ_ÀšÖÀ7šÜÀ\QÍÀ•À•Àª'ñÀ¿KÀÕ·ËÀìNEÁ¶ÌÁ «ÁôÁ&hÄÁ3§Á@'JÁMJÁZŒeÁh³Áu’tÁŸÁÁˆŠÎÁ{Á–€¿Á£WäÁœ=Á•%ïÁŽPÁ‡( Á€O­Ár÷ùÁepÁX |ÁJëÚÁ=øÁ1ŸÁ$‹rÁ@ºÁ ñÁ›Àé@ôÀÒµüÀ¼ªÁÀ¨$aÀ”:lÀV‡À^÷†À=¯­À×9À¦¤¿Ði|¿¤îx¿|D3¿BS¿Ží¾è£Ü¾Ä¤¾Éqë¾òå+¿ª¿So}¿¿·T¨¿éôÃÀ ÝÀ-ˆëÀKüxÀlðŽÀ‡šõÀš BÀ­EÀÁaÀÖ™¾À뮜ÁHÁ ]$ÁÒÁ#ÁÁ07ÁÁOî5Á\/òÁh‡ÃÁtø*Á€áÀÁ‡bðÁó‡Á”šMÁ›MRÁ¢žÁ®‹Á§²ÈÁ ñ Áš:1Á“†®ÁŒðwÁ†~/Á€²Ásf7ÁgßÁZîÁNÛûÁBÔŠÁ7J¸Á,A°Á!H‡Á´Á K#Á«ÀòÁhÀà{ÃÀÏÐ*À¿Ã;À°ÍÀ¢â®À–dóÀŠð¹ÀÉ<ÀrO<Àe_îÀ[¶$ÀUºÀQlWÀQâÛÀUâ‡À]ç×Ài9¶ÀyrsÀ…Ù¦Àg|ÀœPyÀ©‡wÀ·¥dÀÇ„À׎Àç¨Àù?Á³/ÁB|ÁVÁ#N„Á-ÁoÁ8qßÁC²–ÁNÿ)ÁZUÁf ÁrV"Á~·GÁ…ÏÁ‹ëYÁ’]êÁ˜àjÁŸ{èÁ¦0Á²—{Á«à?Á¥,"ÁžƒuÁ—ûYÁ‘ŽhÁ‹# Á„Ì0Á}JðÁq9EÁe(PÁY'*ÁMŸKÁB˜Á7ÿÁ,ýLÁ"•£ÁºšÁV-Á!Àû(XÀêµ¹ÀÛ2ºÀÌ­ÉÀ¿rŠÀ³À¨¢ÀŸ‹ À—CÀ‘¬ÀŒ{“À‰0CÀ‡Ë1À‡ÌÿÀŠ]ÀÅøÀ“DRÀšÆÒÀ£z’À­§6À¹0ÀÅ»ƒÀÓÿÀâÚÀñ¢!Á+Á ¤Á†EÁ·8Á%_ Á/#›Á9uíÁCèJÁN¦2ÁYê=Áe=µÁp›Á|XðÁ„C÷ÁŠtOÁ§FÁ–ú0ÁdðÁ£ÚkÁªiÁ¶ÖZÁ°&¦Á©‹8Á£´Áœ£ÊÁ–9ÁíÞÁ‰ÏgÁƒÇ±Á{õÁoˆjÁdÞÁXî€ÁMôPÁCEüÁ8ãØÁ.ã˜Á%S@Á •ÁU5Á þˆÁÛªÀ÷ßÀè¶ÀÜ5ÀÐiÀÆq¥À½RyÀµ¦ãÀ¯§àÀ«+CÀ§×©À¦ä'À¦¨À© FÀ¬«¬À±ùÀ¸Ô¥ÀÁd'ÀË=áÀÖ]ÐÀáþAÀïHÀý.Á1æÁu¢ÁÐîÁŠÅÁ(mõÁ1ÒŒÁ;{˜ÁEMŠÁO©°ÁZ—ÁdäÒÁp1£Á{Œ³Áƒw…Á‰TIÁc‘Á•ŒúÁ›¾Á¢  Á¨sAÁ®ßnÁ»*îÁ´›öÁ®)}Á§½OÁ¡XÁ›LÁ”ü¼ÁŽô!ÁˆìkÁ‚øAÁzqiÁoL\ÁdJ²ÁYŽ«ÁO2ÁEõÁ;r$Á1û,Á)+yÁ ¸»Ái­Á²;Á tHÁ—¢ÀùoÀí“#ÀäAÀÛJÀÔÀÎ}}ÀÉýÀÆž‰ÀÅýÀÅŒ„ÀÈ$œÀ˱ÀÐÊÆÀÖç#Àß·ÀèßKÀó‹Àþ£ìÁÄGÁ NÁª Á¦ Á$$Á,”:Á5sgÁ>g}ÁGõdÁQœóÁ[=ÁeêÓÁpU Á{4òÁƒAÙÁˆïÁŽ¢¶Á”Áš‰¯Á ¨"Á¦Ö©Á­ŸÁ³ãÁ¿³ÄÁ¹EÉÁ²Ù”Á¬}Á¦DÁ +—Áš ‘Á”-ÁŽ-fÁˆrÙÁ‚ÚUÁz¡¿Áo×…Áe€DÁ[PÞÁQ›§ÁH%Á?áÁ6sÁ.#Á&/Á«âÁmÚÁÅÁ {ÁœŽÁ Àù›SÀò˜;ÀíX®ÀèØ3Àå°Àå ½Àä±-Àç(òÀê˼Àï§®ÀõShÀý¸AÁg<Áb€Á ÞÁäíÁ›íÁ!g¥Á(ðsÁ1aJÁ9Ò|ÁB|bÁK^ÁT‚Á^"RÁg˲ÁqààÁ|5ÍÁƒRöÁˆÉ&ÁŽkÊÁ”¥Á™Î-ÁŸ®*Á¥´äÁ«É Á±ïˆÁ¸/çÁÄb9Á½ùKÁ·¦æÁ±tíÁ«[ªÁ¥MÁŸGºÁ™cgÁ“­(ÁŽzÁˆ€µÁƒÞÁ{ÎyÁq–âÁgÅ)Á^*ÎÁTçvÁLEÁCÝIÁ;Ÿ‘Á3òºÁ,ªZÁ%²MÁ¤‰Á¬sÁ–ÁlÁ ÿðÁˆ‹ÁïÁâ#Á}Á6TÁ]Á àÁ÷âÁBKÁ €Á ñeÁsTÁ$öÁs¦Á"êÁ(¶Á/yÏÁ6|.Á>„7ÁG%®ÁO´ÁXg}ÁaO#ÁjªQÁtPÁ~ zÁ„¾Á‰DÁޱÁ“üáÁ™™„ÁŸAËÁ¤ùÞÁªÛEÁ°á}Á¶ðdÁ½ bÁÉéÁÂÒÁ¼¦€Á¶Œ½Á°z_ÁªwêÁ¤šÁžç‘Á™LâÁ“µ ÁŽBOÁ‰WÁƒñÀÁ}ïÁtTGÁjïžÁbÁY—|ÁQQ²ÁIQÁAñBÁ:ºÐÁ4%Á.2–Á(TmÁ#x¿Á,»Á2}ÁÔûÁÜÁjèÁ)OÁÞÁºÁÄßÁÁ±¥ÁŠ‚Á ?Á!mÁ&—Á+)KÁ0ˆ^Á6Ñ-Á=—iÁDfyÁKâuÁTGÝÁ\ÔÁetÁnR—ÁwYàÁ€k”Á…>êÁŠ*×ÁKÁ”p3Á™µUÁŸ3Á¤Ê›ÁªlÙÁ°%¼Á¶`Á¼ÁÂ~ÁÍÿuÁÇØÁÁ¾—Á»©Áµ©Á¯ÑTÁª" Á¤‡\Áží@Á™u¶Á”8ÁÛÁŠ[Á…>áÁ€ˆXÁx aÁo^¦Ág¨Á^ì+ÁW8)ÁOõCÁHñ‰ÁB°ŠÁ<¿_Á7gÁ2‹ÐÁ.XüÁ*f”Á'@ Á%ÉÁ#ŠÁ!Ö€Á!…ÖÁ!o7Á"sèÁ$Á&%óÁ) pÁ,AÁ0‹…Á5*çÁ:µÁ?1ÔÁE®ÁK½ÚÁR=ÁY›ŸÁa†"Áj˜ÁrŽ»Á{\±Á‚(Á†¼øÁ‹‚tÁVÔÁ•UCÁšyŠÁŸžÁÁ¤ìUÁªljÁ¯þjÁµ›GÁ»SªÁÁ5ƒÁÇ6·Á×ÃyÁÑp†ÁË*ùÁÄàÈÁ¾¦±Á¸ŽEÁ²œXÁ¬ÔâÁ§õÁ¿õBÁ¹­KÁ³o÷Á­QÁ§ZáÁ¡‘ÁÁ›úÄÁ–˜Á‘C“ÁŒÁÁ‡2šÁ‚€‘Á{«îÁrWHÁi™ÞÁaŒèÁYßþÁRé!ÁLWÁFh ÁAÁ<ÿþÁ8›•Á4ôNÁ-žjÁ&j“Á ÁôÁ«KÁ¿&ÁöþÁÅýÁø‚Á¥«Á ÊÁÁ'Á.E³Á0éÁ3§¯Á6üdÁ; SÁ@¨ÁEò ÁLV.ÁSMÁZ‹ÿÁbPÜÁjëMÁt 5Á}¯–ÁƒërÁ‰1hÁŽžŠÁ”,¨Á™ÉÁŸ‚KÁ¥kÛÁ«€ËÁ±¼¨Á¸UÁ¾‡>ÁÄûEÁΓ ÁÇösÁÁt²Á»˜Á´Á«Á®yÏÁ¨{Á7¾ŠÁ2ŽÕÁ-û²Á)}ÎÁ%ɺÁ",ÁmÁµÁiÁ ±ØÁ`,Á¬Á™lÁ Ú ÁßÁz ÁìyÁPÁ!p‰Á$9ÁÁ'Ä;Á,"\Á1c$Á7”WÁ>-„ÁEYÒÁL¹âÁTÿòÁ]óñÁgmžÁq†˜Á{ïÏÁƒ_œÁˆë<Áކ~Á”@sÁš.BÁ J*Á¦Á¬ñIÁ³^±Á¹ÖøÁÀV ÁÊLRÁÊ·Á¼áýÁ¶TßÁ¯ærÁ©‘QÁ£FSÁ ›Á–ßcÁÞãÁ‹íÁ…8Á€$¤Áu®„ÁkÁbÖÁY÷ÁO¹mÁFÀ˜Á>„×Á6¾ËÁ/¾^Á)RYÁ#¯¦Á„ÁšÁ´<Á#ÁаÁ¥÷ÁÿËÀûµrÀöcçÀõ)ÈÀ÷öÀügõÁµ¸ÁF:Á §ãÁ¡LÁÁêªÁ« ÁG Á"ä®Á)7ŸÁ0(vÁ7bÿÁ?>ÕÁGüŸÁQ;ÃÁ[Àø¼¢Àü“ÖÁ7cÁ¿vÁÅÁ ²»Á§ZÁ¥qÁ+*Á"WüÁ)¸4Á2.žÁ;$rÁDþ+ÁO$ ÁY×LÁdâdÁpüÁ{‰Áƒ¼­Á‰é~Á<×Á–Ÿ6ÁJÁ£ªÁª…Á°±PÁ·kVÁÂ@úÁ»hØÁ´tQÁ­•×Á¦Ñ.Á )›Á™¢åÁ“=@ÁŒäÁ†¤hÁ€|*ÁtàÊÁi=’Á^%vÁS‚ÖÁIÊÁ?6ÄÁ62$Á-/BÁ$8ÏÁСÁëYÁ ÎÐÁ«„ÁxoÀùÂKÀñÃ\Àê,jÀã„ËÀÞ*öÀÓž¤ÀÉ/±ÀÃDëÀÀë ÀÃÀÉ îÀÓé{ÀÚ7’ÀÞ3xÀáî}ÀçSŸÀ힀Àõì¿Á=ÁqùÁ UÁ…€Á~ÊÁ%2PÁ.ÑÂÁ8Ò¦ÁCqÍÁNtýÁYŸhÁeÁqõÁ}‚Á…Á‹v.Á‘í1Á˜n×Ážû[Á¥§®Á¬pëÁ³SÊÁ¾TƒÁ·X?Á°r Á©˜¡Á¢¬zÁ›Ø>Á•!1ÁŽŒÁˆžÁ»ÁväÁj™ªÁ^‡ÁRÙÁGÊ›Á=2üÁ2̃Á)89Á KCÁSÁÏÑÁ‚ÀýòÿÀðÓƒÀåóÀÜxLÀÔ„ÀÍÜÀŦÀÀXÀ¼ EÀ°„LÀª)À§+ÖÀ©ÐEÀ°WMÀ·ð“À»Ý…ÀÀ6ÀÃèÆÀÉ•ƒÀÐNÀØëfÀäl Àñ2¡Àÿ‡ÁÁvnÁÇpÁ"—Á-ïÁ8ÁC7vÁN±bÁZ¼öÁg4ÁsÖÁ€NVÁ†Í­ÁPÝÁ“ë±Áš¨DÁ¡‚\Á¨u Á¯dÛÁºª”Á³ŠÁ¬|ÜÁ¥…ËÁž§Á—Ë`ÁéÏÁŠ$ Áƒ#Áz)Ám/ùÁ`…µÁT<ÃÁH0Á<‚ÏÁ1pÁ&öõÁ²Ác§Á fÂÁ´üÀó¥ÀâéÀÔÝwÀÉxtÀ¿PÀ·k9À°'aÀ¨x4À¢YÜÀ”&À˜SÀÏQÀŽ;ÀyÀ–ÜSÀ™ÐÀÀž ÚÀ¢ŠÀ¦“¢À¬3 À³+À¼Ñ­ÀÈÃÀÖD²Àäq{Àô˜ÁðnÁ {»ÁÙ4Á!ÄøÁ,ÞHÁ8XÝÁDtàÁPæçÁ]…Áj[5ÁwbrÁ‚:Áˆæ™ÁµiÁ–¢:Áœ©Á¤k”Á«EøÁ· Á¯ø™Á¨ÐñÁ¡±‚Áš§ïÁ“·tÁŒßAÁ†AÁ~\éÁpøgÁcâŸÁVûÁJ6 Á=â?Á1æ®Á&@»ÁQÁ×âÁÄFÀûKêÀéYÀØð¿ÀÉ;8À¹íŽÀ­yÀÀ£kÔÀšô,À”+\ÀŒ0¦À…kÀ~ÇñÀv¶ƒÀpgÀhð:ÀlœðÀp2òÀwu#À1…À…øÜÀŠ;ÂÀï7À—TÃÀ¡Ê.À®dÀ»XÀÊZÀÚÖóÀí%|Á·‘Á Áš'Á"ZÁ.4”Á:šíÁG5žÁT'”Áa1~Án^Á{ݱÁ„Ò:Á‹Í6Á’¥Á™v_Á ^Á¦øiÁ³M Á¬BŽÁ¥CoÁž!ŠÁ–ù˜ÁÛºÁˆÖÎÁîìÁv1ÁÁh~YÁZû÷ÁMÍÁ@Ü=Á3ú™Á'Á¥àÁÁFvÀõÊÍÀâ9ÜÀÐÀ¾­žÀ¯dÀ ÑÀ’ÑŠÀˆ°À€|Àr{¶Àaë ÀRXòÀDMÀ:±MÀ3À9À.ΗÀ.ëÈÀ3Ù„À="šÀJ˜)ÀU°•À_]1Ài÷cÀyèùÀ‡mÀ”O;À¡ž À°éÀÁünÀÕ”Àê°eÁa;Á ÞÜÁù…Á$P Á0÷¹Á=þœÁK ÈÁXcŸÁf‚ÁtÁ€åLÁ‡¬ÁŽÁ•>vÁ›ß§Á¢“îÁ¯·éÁ¨Á¡röÁšk§Á“q%ÁŒMšÁ…%vÁ|¦Án[Á`XÄÁRªœÁE ËÁ7½WÁ*ÅcÁÛâÁMÁqÛÀô9MÀÞèíÀÊrõÀ·ŒkÀ¥ŸXÀ•‰^À‡ŽÀsÖhÀ]I\ÀMïÀ@Ú©À0ÍÀ¬«À ĈÀaпîwõ¿às3¿á÷ƒ¿ïùèÀàÄÀ×À$¯À,÷³À7šòÀGù À]¸Àv9Àˆ¬À˜ lÀªuçÀ¾~ÖÀÔWLÀëSÁÅÜÁ þÁÖÁ'ä…Á5ÐÁBDÁPp3Á^WqÁkÒuÁyÁƒ‡ßÁŠ"aÁÌfÁ—‘«ÁžtIÁ¬9iÁ¥}ÁÚÁ–´Á˜üÁˆ— Á£ŠÁtüLÁf¬ÁX{nÁJçÁ<ÜóÁ/,Á!¶Á®œÁÓÀö`´ÀÞ¤ÀÈ–}À³®µÀŸÑÀ„ÏÀyQ¡À]]^ÀCÍPÀ-^rÀŽ»ÀŠÁÀ"Ÿ¿àCN¿µ Ÿ¿‘E¿iC^¿BÅ¿F2©¿u¥ã¿¢uö¿Óm¿ô/˜ÀXaÀ ŽûÀ”‚À)t€ÀAíÀ_êÙÀ€ŽÀ’çäÀ¨ ŽÀ¾ê‚À×)[Àï¼4ÁЄÁàÁ-?Á,ì-Á:ä¦ÁH^íÁUòGÁcªëÁpϘÁ~˜Á…ÃÁŒ›ÍÁ“‘ëÁš›±Á¨ÞGÁ¡“ ÁšX±Á“'-Á‹ý"Á„Ø#Á{DÁmˆêÁ_¶~ÁQjîÁCÞÁ4õ¥Á'#%Áp²Á Ê«Àý9Àã¯qÀÊ™âÀ²ÊiÀVåÀˆ~ Àk¶ÀJrÀ-' ÀcÃÀáh¿é¿Ø¿¿Å>%¿˜^p¿;²ž¾›=P3s>r-§>J`»½ý>¿ä ¿ŽóÝ¿µåv¿½kš¿­F€¿µ4µ¿ÚôÀ À-ò¹ÀOÔiÀxpÎÀ’¼ûÀªú§ÀÃÏ]ÀÝß8ÀøéÁ ÃÁaaÁ$ïíÁ2yÜÁ@,ñÁMbœÁZ™rÁgõvÁuÁ´¹Áˆ½#ÁÒüÁ–ð+Á¥Ê}Ážc Á— Á³¬ÁˆwûÁHvÁtB<Áeø]ÁWÎoÁIêŠÁ<'Á-ïjÁ¤#ÁÈÁÓöÀìCúÀÑ[%À·æùÀŸMÑÀ‡Ü?ÀdÓðÀ¯E?n°?œÝ ?“ÇÅ>ðÐ…¾<Ë¿R›ï¿€¾±¿U¾À½Ý¾àm¿Kj¿¬i¿ö_À!LÀMz'À~!´À˜'À²–êÀ̇–Àç¿ÀÁ…ìÁNÁ©šÁ)þ Á7"`ÁDp²ÁQìÁ_²âÁm¸Á{ð‘Á…UÁŒ:Á“oÁ¢ÎmÁ›a8Á“õžÁŒ”Á…)°Á{ª Ám,·Á^ÕDÁPŠPÁB@˜Á4 —Á&VÌÁ—¯Á ‰ùÀø•*ÀÜÎÆÀÁ|ZÀ¦<6ÀŒyoÀiwÀ;C"À:*¿Û*R¿¡ÇÆ¿@v¾¡Å ½ŠëϾ"ŸM¾í¬¿]¾.\Ò?x²?«IÑ@ ‹?Ê`Ù?8+¼tt¾Üº¾k„Ú>p« >°†š>Ñ#=e#.¿tÝ¿—¥²¿ì©_À':ÇÀZýžÀ‡†À¡ÑÀ¼MÀב;Àò›(Á› ÁµÃÁ ïµÁ.ZuÁ<WÁI÷XÁX*¤Áf}Át¿ÊÁ“ÂÁˆÜ Á5©ÁŸÿ{Á˜wÏÁüµÁ‰ÓÁ‚ ÿÁup3Áf¥×ÁWîêÁIiµÁ;ûÁ,ÒdÁ‰ÁwðÁÇ3Àê~ÀÎ4À²"WÀ—K·Ày¸ÀDPÀt¿Ï!M¿ƒ Ë¿S<—÷??™? bô>¿/Ö½±=>6Lù?>‚-?Á`H@Ðç?ðµó?Š|Œ>ñ¾è>B§ ? ’§?W¼ð?ƒ5u?vr™?FË&=À½Ã¿,4¿¢°ÀX7À6àCÀk“ÜÀ‘<ÊÀ¬$ÇÀƺ Àà©fÀúêÕÁ ÑÁ\ Á&9Á4dpÁBºQÁQ Á_q ÁnQÁ|À¸Á…Ï(ÁI×ÁwnÁ•ÚÁŽC5Á†´0Á~_ÁouVÁ`™ÁQÅxÁBú†Á47HÁ%§ÁX@Á 7Àõ¤/ÀÙ³/À¾o2À¢è7À‡(zÀX×ÛÀ%5<¿áx'¿€DZ¾Î³'=š4µ?0©×?¢2Ü?¸ÜÔ?«÷ù?š”L?_t?i‹?©²?ú±{@.»7@ÇY?Ùëà?£†?•—`?®ò"?г?õÓ=?á’É?­%`?F ¹=ch;¿8׿Á¨žÀäÀLÀ€oTÀš À´€ÀΔUÀé‘)Á5ÁžSÁóîÁ-M®Á;º•ÁJSßÁYÜÁh «ÁwŽÁƒŠÁŠ™žÁ› ­Á“k°Á‹ÌÙÁ„.Áy<ÁiïJÁZÒ_ÁKÒÁ<ò1Á.ÁO5Á…·Áå+Àç) Àʤ÷À®7¶À’’iÀnŸüÀ7†/ÀJÁ¿ž™á¾ß;>XÇ–?;%?¬?û¨@Dÿ@ Ø(@Þ ?êóÆ?ëY>@ Ç@)8T@RÀ@@C‡p@!m€@ wô@ ³R@ °[@0Œ@6á@ ?ï,¥?­¶?³¾6;“¿€4ø¿çæÑÀ($JÀZè…À‡’ÂÀ¢{™À½¢ÀÙ°ÉÀö[Á ‰•Á˜Á&¦ÓÁ5„NÁD‰ºÁSšÙÁb¬+ÁqÏnÁ€†zÁˆ,ÊÁ˜Ë_Á‘ZÁ‰jrÁÂøÁtDrÁeÝÁUÉ0ÁF‹‚Á7X5Á(=áÁLßÁ qYÀ÷GÇÀÙ´‹À¼I„ÀŸ¡“Àƒ€ÀMºAÀÏ¿Á¥¿.uÊ=ÃFŽ?R¼?°Ëc?ü*©@!ã @JÊí@HVq@Àd¾áà{¿¯?ÀŒ$À6ÌÀlÛëÀ’%ÐÀ®ÎQÀËŽÝÀèžìÁ´ÁtÁ!Á0%ÇÁ?GCÁN‰`Á]ÖZÁm#TÁ|oýÁ…àãÁ–¶¤ÁŽù`Á‡BjÁÒÁo´ÐÁ`OVÁP÷bÁA®ØÁ2rÜÁ#6ZÁø­ÁÁ8ÀëY¸ÀÍ‘ÈÀ¯ñ%À’]éÀi¢‚À048¿î\•¿€o¾.;Í?'×?³´›@«0@#é@DŸ¿@oÀÏ@åÏ@w³©@sµ@r¼}@~š¦@Š{@™by@–Úù@‹*dU¿"ƒ¼¿½a”À<ÀNƒÀ„ÌÀ¡WäÀ¿mÀÝÄÀû?Á ¿KÁ&Á+S Á: ÁIìÖÁYDÁh°˜Áx!-ÁƒÊ#Á”Â>ÁŒþxÁ…=ÐÁzÿ”ÁkƒÓÁ\ ÁL¢æÁ=:åÁ-ÒãÁnqÁ'Àÿ¹rÀáBŽÀÂË©À¤UÀ†GÀQ5ÀŽ¿µÐ*¿•/>¸U@?–p*?ÿõ@,Øc@J¡š@pL7@‹ ú@Ÿê@šl%@˜÷@™”@ÿq@§¯@´Ø@³¸.@©ø @¤n²@ ê@ \»@¦)Â@¡ ‚@ŽŸÓ@v›N@G´Ó@žR?É ¹?=é\½Ò°‡¿}¦0¿ó#À4Ž|Àp šÀ–2 À´o´ÀÓØÀñŸÌÁàÁiêÁ&ËÁ6<ÁE³­ÁU2•Ád· Át<²ÁãÑÁ“_Á‹=aÁƒkñÁw:ºÁg©~ÁX¯ÁH”“Á9Á)š\Á(úÁ ÀùÀö±îÀ×ÙhÀ¹Àš+Àx,À;>Å¿ü£ß¿……½ì)4?O½?ÛÓB@$:@V%ú@z²ˆ@*þ@¡‰‘@µïÇ@¹P¿@¶ác@¸Ý®@½´@ÅN@Ñ2ˆ@Ñ{,@È߈@ÃÖw@¿tÓ@¿›À@Ä}-@¹3¢@§&@Ž^@p{É@=¥Ì@•?Ÿ ª>¤FÍ¿Ї¿Ä˜¥ÀÊÞÀ[þÇÀŒ™WÀ«3KÀÉÒèÀè³öÁÚYÁ_ýÁ"å£Á2kIÁAøîÁQ“»Áa/SÁpÎaÁ€7`Á‘keÁ‰—1ÁÆIÁsê‰ÁdGªÁT¤ÌÁEíÁ5bÁ%ПÁA«Á³ÀîYèÀÏb™À°ŽÀ‘·Àe¹…À(¿Õƒ‘¿7Oþ>qœ‘?—˵@Kû@Brs@{y¾@–Äb@¥³ê@·]à@ÌŠ©@ØA@Ök@Øé@ÜX4@ã’ @îsá@ïÍ­@è@âÀG@Þç@߃@ãF?@Ò–C@½n•@¥-0@ŠãR@] 0@"£4?ÏLr?-*¾Ží¿žKŒÀ …ºÀJ¹À„ÛÀ£'ÀÂ(sÀá3ÀÁ,¨ÁÈ@Ác×Á/‘Á> ðÁNBnÁ]î.Ám¤;Á}b¬Á»Áˆ!>Á€?ÙÁp¿÷ÁaŒÁQ\ÁA·rÁ2“Á"qµÁÎÖÁ+øÀçÁÀÇïÀ¨Ñ—À‰³®ÀU+ŒÀ+“¿²ëõ¾Þ?¾¼?¾ØR@„Ž@YrW@ŠüŸ@¨Ü@ÀÒ@ÏØÕ@â¿K@÷W @õe‘@÷@û¬¬A ¬A?A5œA« Aôn@þ^@þ¨ô@ý÷À@êVu@Ò@µöþ@˜c:@uNó@7à?ôÜ2?sðu¼x–H¿{å¿ú„À;!êÀy„³À›ù‰À»0¸ÀÚgèÀù¦©Á €`Á<ÖÁ,YÁ;ÏÁK™ÊÁ[dƒÁk/;ÁzùôÁޱàÁ†ÐaÁ}ÝÆÁnÉÁ^WÍÁN”ÐÁ>ÑÓÁ/·ÁPõÁ–¾ÀÿÖÕÀà‡dÀÁ8ŒÀ¡ñÁÀ‚¬ÀFÌŽÀ{€¿”`¾@Þ?I4~?áP@.8À@kîY@”½´@³nŽ@Ñår@éíH@û‹A^üA tDA A =æAœËA jAœAhVA’lAø‡A$µA ~Ù@ý/Z@ßU¦@À¬{@¡÷ø@ƒ@H'Œ@ &Þ?˜-l>ZAâ¿C9ç¿Þ‚#À-³ªÀlnºÀ•ÎPÀµj±ÀÕ{Àô¤…Á ÝÁï…Á)¾9Á9ŒÁIb¦ÁY=\ÁiŠÁxÿUÁ‹€Á„Á”Á{m!Ák™™Á[ÇÛÁKùÜÁ<0Á,l‰Á©ŒÁ æÀúG%ÀÚœÀ»E)À›Ç·Àx—ŠÀ9ëþ¿öš7¿r¸ã<øTå??ýÏû@=5#@{„!@œé@¼@Úó¾@ùÅTA dSAtÿA?^AÑpAÄA eA$4A&+A#.A >/AÌÂAöTA¥,A:Á@ço^@Èi:@©Så@Š=_@V3¬@¸Ž?°Êë>È’é¿í¿Ë'§À$æìÀd:À‘Æ$À±c²ÀÑ?Àð Á(4ÁŽÁ'ì<Á7ÔÜÁGÀ|ÁW®rÁgžCÁw“Á‡oÁ€Š¾Ás‰ôÁf.¨ÁY--ÁIÏÅÁ9ü<Á*(´ÁU+Á ¢Àõ\4ÀÕµ#À¶$À–rJÀmÕHÀ.˶¿ß¡¡¿CW¯>bO•?š?¼@ Õ¯@Jt‘@„†–@£ÒÕ@Ã!u@â]šAˆAVGAêA)çA*‘uA,`jA/X”A3ƒÒA5µùA2¶uA/ùA.¨øA%ØALÎAÁŒ@î>@Δó@®ëW@A»@_0?@Ý?ÁŸ?Ú^¾ð忺ófÀIÀ\šÀŽÈÀ­ø°ÀÍà{ÀíÎÇÁà£ÁÚôÁ&ÕRÁ6Ï´ÁFÊÁVÄ~Áf¾æÁv¹OÁƒ¹ÿÁyA‡ÁkJTÁ]™™ÁP,öÁCæÁ6O1Á(ýÁ7Á_1Àñ8ÀÑk×À±ÃuÀ’ÀdådÀ%”¡¿Ì‡¼¿Ìk>ÂíC?¯\×@Ìû@UÅM@Š^Ð@©Úù@ÉW"@èÀËA…A¬¥A#RøA3A:\`A< ‘A>ÇNABÈŠAE]™ABDZA?¿xA8r A(ˆ2AžYA´€@ñÌ@Ñ›î@±«C@‘¼–@c£'@#Õ?È(?䇾ܦ‡¿¶Å‡À0¶ÀZþ¨ÀfMÀ­MµÀÍ:•Àí,2ÁQÁнÁ&…)Á6•ÁFzÁVtnÁeÐÁs˜YÁ€hÑÁr;µÁcÖjÁU«“ÁGÇ¡Á::qÁ,ùˆÁ fÁ¨–Ák–ÀíSÀÍU{À­”£ÀÔ:À\D#Àì ¿»'á¾ñÞ·?q ?Àå@ÃJ@_@2h@®ÚÊ@΃+@îàAÌÌA8A&KMA6'AE¼yAKÇ™ANL,ARÞAUuAQâûAI8žA9>÷A)EQAK«A R@ò°¼@Ò½o@²Ê#@’ÖÖ@eÇ@%àz?ËóÁ?M¾Îš“¿³s×À …ÀY‡NÀŒ·&À¬ª°ÀÌž@Àì®ÁAòÁ<˜Á&8(Á4—ÕÁB%hÁP Á^0€Álr1ÁzíÍÁl¯Á]JÞÁN­LÁ@H1Á2)=Á$b‡Á CÁ íÀû@¸Àâ÷%ÀɬãÀ©ìÎÀŠ,ºÀTÆSÀ&j¿« ¾¯÷m?& ?Ñé@(L™@g¤³@“~f@³*s@ÒÖ@ò‚ŒA LAíSA(ÃYA8—‘AH_VAX"±A]âˆAaV¥AdÅ#AYAI–ÚA9œ¹A)¡'A¥½A ª†@ó_.@Ój$@³vG@“‚Ê@g™@'7Ÿ?ΡI?¦©¾Ãꀿ°È”ÀKDÀX2?ÀŒ œÀ¬ÀËó«ÀëéYÁÁeÁ}ÁÐ?Á,—Á:ŸÿÁHà˜ÁW)Áe•6Áu6ÁfCóÁWnwÁH˜…Á9×nÁ+6qÁÓÆÁÉ,Á3\ÀèiJÀÏeùÀ·;ÔÀ¡iðÀ†=¡ÀLùkÀ yC¿›ò4¾g?DÝ?áÀ@0ˆ@o‡±@—ƒí@·E?@×–@öžA 7VA mA*ã“A:¹ÅAJûAZf0AjÀ02ÀVEÀŠïÀªÛ?ÀŘyÀÝ¡ À÷yÁ F@Á'_Á%a2Á3˜½ÁBKÁPÆ»Á_§×Áp;îÁ`ú¬ÁQÔÛÁBÑðÁ3ùØÁ%<šÁp}ÁãAÀóÀ×ZTÀ¼ìôÀ¤ÅÀŒIåÀnÓþÀE À¦Š¿Œyç½Úk¤?bXå?ðBw@7À÷@w`²@›sÝ@»3ñ@Úô@ú´A :A!A,ú+A<Ú6AL¹}A\ŒoAl`ÍAzÂÑAjÌÇAZ×BAJá½A:ì8A*ö³A.A ª@ö,J@ÖA@@¶V6@–k-@lÿ&@-&¬?Úœf?5ÆÎ¾“€Ÿ¿¤£¶À3¢ÀRéÀ„®ÀšO;À²o5ÀÌ|4Àç½âÁôïÁ56Á°cÁ-oóÁÎ\AN²8A^æAnoA{ÆÃAkÓ¸A[àéAKîA;ûA,ôAA ?@øTÉ@Øk@¸^@˜—•@qZ7@1…C?ã`?Gmj¾_ƒC¿›qÍÀ sîÀ5×>À`úGÀ‡ämÀ¢ÓÀ½þÀÚ ,À÷ ÅÁ QzÁCÁ(EIÁ7rlÁFÀ¥ÁV(ÝÁgßôÁXTöÁHÜYÁ9pÁ* àÁ¿æÁ ž¼ÀøßÀÚÐ:À½d¤À ÕùÀ„SÖÀRÚžÀ" ô¿óV¿ÁÂß¿L¼©>>”?•á”@ øR@Iá@„0”@£àQ@Ã@ã?ÌAu“ALA!&^A1ÄA@Û)APµA`õApjZA|ö°AmšA]ïAMA=*SA-8ÂAGþA Y'@úÔË@Ú÷G@»Ã@›;n@v´ô@6í«?î;÷?]…¾ +¿Ö'¿Üä´À À=¶SÀpç£À”L\À± ¹ÀÎ¥"ÀìoTÁT¹Á¡QÁ$&Á3˜fÁC2åÁRÐÙÁeÎÁUATÁE‹Á5áªÁ&HÁÁÅsÁ^çÀð›ÀÑ—TÀ³š¸À•¤PÀp«dÀ9DÀŠ¿µ{ù¿†žÛ¿/w8>³û?¦•š@ß@Rsh@‰Û@¨Ço@Èjä@èYAʬAŽvA#\)A32AC àARá¿Ab¹­Ar“åA}Am¤A^KÏANtâA>~sA.…AŒ•A“¼@ý5õ@ÝD¶@½SÞ@c©@zäc@;þ?ö;T?léW½•Ñ¿wy¿™ã$¿ãoýÀ"UÀYJ´À‰å'À§–¶ÀÅûˆÀäЕÁôêÁeªÁ çÁ0ÞÁ@)GÁOßàÁbí—ÁSaÁCJÁ3„wÁ#Ç@Á ÁXîÀékÝÀÊ`À«®À‹ À_Ü À$ó¿Þ†"¿ŠÇ ¿B_™¿B­>Å—?°ôr@A@Xæ@‹è@«ËÊ@˯u@ë€2A§9AŽXA%uxA5\—AECûAU,*AeiAtÚ$A}BûAmÙ/A^„šAOIîA?pòA/xwA€ÄA‰_@ÿ#û@ß5@@¿F’@ŸWù@~Ó@>ö­?þ7y?}s»½•l¿?¿fc¿½yHÀzÀKmcÀƒd8À¡eÊÀ¿ûÀÞöVÀþ23ÁÌÀÁ«Á.]·Á>2sÁN &ÁaxaÁQšÁA¾Á1â Á"‰Á4¡ÁlºÀåh¿ÀÆ%ïÀ§*ÇÀˆ¨ ÀVmÀ‚„¿Ì]¨¿rÀD¿!yY¿;Å>ÛÂ^?¶@Æ@ZÎ@L«@­:ä@Í.{@í%EAAŒ/A&ˆ™A6~ AFs|AVhîAf^`Au»|A{›ÑAn ÎA_âÎAPkÎ7¢?²š"@A@Xë÷@ŒnH@¬hú@ÌcÊ@ì^›A$OA`A%½ A5l6AD÷ëAT'óAc7Aq¸*At‹IAgO%AYçüALR~A>_BA/C,A‹ïA»8@ÿÖ@à ·@À3@ \x@€…Ù@A^s@†Ü?ƒ W<̽½¿ytÓ¿‹ª¿Â1:À¹ÜÀD_À~×À»ºÀ¼š¡ÀÛÌIÀû**Á KLÁdÁ,ÊÁ<—÷ÁLm¢Á`ÄmÁPäSÁA ~Á15WÁ!iÖÁ©ÌÁùaÀä¾ ÀÅÄÈÀ¦êiÀˆNµÀUÎÀ躿ـ£¿“¿d{&¿%›£>±è?«ÁÑ@jÄ@TµÛ@‰ö @©yÄ@Èó @èSHAÔ¸AqýA"ˈA2AAÊAPÔA^äÆAmX‡Al}æA_Å,AR¢ÂAEo¸A8ÇA*q$A09A Ï@ûB­@Ûõ«@¼««@&†@{ —@;È"?øãß?t¢½(Œ¿„±¿¿³Ë¿ä;òÀ´äÀM¶2À‚Ä—À 7NÀ¾}7ÀÝ?±ÀüQ2Á ËáÁÊÁ-ECÁ=çÁLè\ÁaéXÁR™ÁB[Á2šÿÁ"ÝÿÁ.jÁ’4Àè"\ÀÉoÏÀ«7‰ÀÇÐÀcw®À/¼.Àò¿Æ N¿ª%D¿;Ù>b?û8@ Îö@L Q@…¥@¤ÀP@ÃÅ@â–ýAˆñAÆdA߯A-çòA<½AK"AXf AbwA_7\AVýMAJ¶ÚA=Ð*A0©ôA#sàAù¢A/x@óq@Õ`M@·µ@˜?!@r'u@3™(?ê¶?Yò8¾.}¿_T¿ê£·À &kÀ.¥À_ÁÀŠP—À¦f6Àð-Àá¶”Á›Á…Á Á.ª,Á>W¢ÁN³ÁcÍÁÁTVÁDlÇÁ4Ñ,Á%HÀÁÙ{ÁŒÀîÚ¸ÀÑ#£À´5=À˜$ÀzÀJæ@¿£¿»QÛÀaÀUÀq|³À‹âÒÀ¢[ÏÀ»mÆÀÖEÀòŽÁb­Á cÁ$õÅÁ4ÁCMÁR§ÈÁj ¥ÁZÅrÁKžÁ<–ûÁ-œöÁÏÁBÁ ±Àè—ƒÀÎ^¨ÀµHŽÀžhÊÀŠ#iÀu ¶ÀK*—À àã¿¡.\¾›it?%þÆ?ËÆ¯@" °@^’@ŒÐh@ª6º@Æù¨@âÖË@ý]²A q…A¹TA"á"A+ÐBA1þ9A5LAA4ÒA/\9A(:ÂA U+Aè A uö@ü¤A@ã@Èÿ*@®›™@“Ëâ@p²§@8£Y?ý×r?Š5“>#@„¿HBz¿ÜË¡À+:£Àh€bÀŽ÷Àžk¥À²Þ}ÀÊU¢ÀãžÀýùÁ ½êÁíÁ)n¸Á8/@ÁG ¼ÁV8ëÁn€pÁ_h ÁPr8ÁA¦÷Á3ÕÁ$½ñÁÁvÁ 4õÀø  Àß •ÀÈÀ²åÀ¡ÌÀ‹ß^ÀZR.À‡¿Âp¡¿R«>º”c?¥ˆ’@ Ýö@HÁæ@$D@7V@¸u2@ÒV@ëu’AÝA hAª A…A#cA&+¹A$òA!nNA»A<ØA ±AÌ@韨@Ñ®”@¸@ž·è@„>@Sˆ=@ƺ?Ë *?24U¾Gà㿎€hÀ´À=÷/Àz;ÖÀ›P–À³â`ÀÆ,‚ÀÛž¿Àó]·ÁFÁ5TÁ ÓZÁ.ØÑÁ=.»ÁKÄÁZŒEÁs‡áÁdÄÁV.ŸÁGÐ4Á9¶Á+ñÁnxÁ]fÁðÊÀòjLÀÜ”IÀÉxýÀ²ÉÍÀ”{ÓÀlc÷À/Þ6¿èoí¿db=Ç?q?ë«+@.Z¥@eÔ#@D÷@§Ì@¿Ë@×£.@î5¸A ÒA w©A*0A®ÕAVAëßAû2A +AÙÍ@üŠZ@é¢z@ÔhA@¾“@¦dÿ@¯ö@g÷Š@3©À?ý÷?‘ R>Œ9¬¿m¿¿‚æÀÎÀSôþÀ‡¢“À¥BSÀöÀÛ›5Àï#‹Á‘®Á€ÁÙÁ( AÁ5‚0ÁC[ÁQ‚›Á_éÄÁy|ÁkïÁ\î"ÁNìÁA1¾Á3רÁ&ôìÁ£@ÁºÁ¥¯ÀóUÇÀÚ, À¼ÊÀž)À€`TÀEEuÀ  ¿¡¾¾¸S#?ó$?²ÝC@8õ@C»@v¸©@”y@«œÁ@ÂI(@Ö©|@è£@÷ȰA¿0AÔ¬Aò×A‰AN'@þ¹S@ð—ª@áÔŒ@Ò3)@½âÀ@¨¤ê@’Gê@v-†@Ede@†?¼õ¿?%¾>–j¿…倿ôŒþÀ36iÀl\ÖÀ’ØŒÀ°JÀÍóÈÀë|ÁnêÁ ‚~ÁšÛÁ#ƒÍÁ0Á='jÁJ‚ÌÁX/úÁf)ÇÁ€ÁrµÁd7XÁV¨XÁIu Á<°öÁ0p Á$ŠÔÁ\¶ÁÁ)³Àäg'ÀÆ¥FÀ© -À‹·¥À]¥.À$«¿ÕÒI¿NòA=Zê[?aÉ•?ÙÛ¤@î•@OÞX@3Ù@–]@«~@½|@Íñá@Û×@æSA@í¥o@ñl @﯈@êÔ{@âXn@Õèß@ÆÈÏ@·Ø@¦ŽV@’#@y¸‚@Lòñ@Î=?ÝEë?ok#>¿1ÏH¿Ã$ Àz£ÀNºÀƒ—EÀ :À¼‡/ÀÙ3²Àö™©Á #Á^{Á!¸ŽÁ,ï‚Á8Û)ÁEZÇÁRSüÁ_«Ám4‹Áƒ¸vÁy¾¬ÁlV‘Á_EøÁR+ÁFeýÁ:x¦Á//¸Á$KÁTÇÁˆVÀ﹨ÀÒeÊÀµoOÀ˜¨ŠÀxhûÀ@Þ‹À ¿‰¿¥ b¾óâ>ª£w?ó?ïoy@'@S×a@~4E@’Uì@£|"@²Èÿ@¿^@Èë@φý@Ò«Ý@чÉ@Í1@Å]É@¹Ÿ”@«¡»@œò @ŒÄ…@töN@L¾@"€?ê·ù?ް>··Á¾ÖÀ¿œ/üÀƒvÀ7j)Àlý0À‘‰)À­“VÀÊ KÀæ|ªÁ~;Áè,Á4Á,º—Á7EkÁB9ÁNx®ÁZç¾ÁgÆèÁu‚Á‡¹âÁ4Áu;ñÁh¨\Á\`xÁPxàÁE%åÁ8›üÁ)á«Á5BÁ Š.ÀüšÀß0ÀÃ"ºÀ¦ù]À‹jÀ_ÇÛÀ*5@¿ìÊD¿…N¾‹ãö>ü‰ ?4G?öóÀ@%÷.@Mœc@pÛ’@ˆ¤ý@–ò°@¢„Ž@«?@±Xo@´ê@³}û@¯:ñ@¨kf@EÁ@ƒ@´Ê@cìg@AéÏ@kÊ?çîõ?’~Ó>ç•J¾ƒyª¿xÿ䴥À$1ÀXÌäÀ†¡AÀ¡b3À¼Q?À×»áÀóúÁ5«Áu8Á$ÙµÁ3KÁAé’ÁM ºÁXcÁdHpÁp§UÁ}nQÁŒ’Á…Ÿ=Á~º7ÁrwöÁf˜"Á[>ÀÁMWâÁ>§8Á/ùoÁ!{ÌÁ=áÁ|Àí±ÀÑ÷bÀ¶š¨À›k­ÀÀNLþÀóy¿Ó“¿bŠû¾"rs? «á?›c`?ëo–@iv@<>%@[K@uhW@…Uý@E`@“ä@•¶Ó@•s6@‘Dý@ŠÕ.@€å@hŒ @Lvæ@.d6@ –°?Óö/?‡Î’>Øm%¾vb¿o‹„¿Ò ;À„›ÀIâoÀ{íÑÀ—Ò®À±âãÀÌkÀç„MÁWÁ-HÁ3mÁ+lQÁ9ÍÀÁH<ÊÁV­ïÁbûjÁnZ®Áz;fÁƒFÁ¨mÁŠnÁ„PSÁ|ÉÁpØ4Áb(ºÁS|¹ÁDüqÁ6¶ÈÁ(€ÿÁO*Á TXÀýR|ÀâÜÀÇ&fÀ­œÀ“úÀs‚ßÀBXÀi=¿Åér¿W{¾)<ä>îR?‡Ì?̲u@;@#o/@;× @Pµ@^Ã_@iaß@ný@mû»@f—{@Z4Ù@H »@/ý[@)v?ï"??¯Ý|?ZßÀ>c¾¤Îu¿wpÆ¿ÐÀ¸kÀAè$ÀpÛRÀÆWÀ©¯ßÀÃHµÀÝmÀ÷ÑÁ ]ªÁênÁ$¨¾Á2€0Á@}:ÁN´Á]0ÔÁkŸÞÁxïõÁ‚+¿ÁˆÈÁ•–ÁgPÁ‰~äÁ‚Õ*Áw<Áh~ ÁZ/®ÁKú+Á=ÕÖÁ/Ñ,Á"(Á]ÇÁÜýÀòöÀØõÀ¿=ØÀ¦ #ÀuÞÀjŒJÀ;Æ ÀÇпÆíÒ¿hèþ¤Û>‚™I?E Ù?žø.?Õ'n@”÷@Æ¢@"u:@,3¡@1 @0é@*DŠ@¦+@ Y?îuw?º®?‚&? +<̃B¿Œu¿‹âÔ¿Ú5ÌÀÆÀ@§lÀmöÀ`À¤™À¼ï)ÀÕ‡ºÀîÇÒÁ‡µÁ±‰ÁýÁ,…íÁ:'×ÁGýÏÁUÛôÁcë'Ár/)Á€KWÁ‡}Á2õÁš†Á”•wÁAéÁ†Á}©?Áoy»ÁabÁS`äÁEqÁ7¹±Á*'iÁ¹¹ÁkäÁ„Àë`ìÀÒPÖÀ¹ü¹À¡×¬ÀŠLDÀh>À<™§À°d¿Ù]¿Ž¹Â¿Bッ—á>Áë?E›C?ŽÛ?²7¥?ÌN)?Þ É?çõ?çŠ?Ûá“?Ådf?£ÃI?vܵ?'‚>#^e¾ I²¿O¸¿©ê=¿ñ"PÀc£ÀE›ýÀol³ÀŒ´fÀ£2òÀ¹ÌÀÐÄ»ÀéÁÚKÁ X|ÁY’Á'‚Á4ϾÁB5²ÁO³~Á]|’ÁkYúÁyJ÷Áƒ³¦ÁŠÐ…Á‘þqÁŸ^Á—Ã'Á–Á‰ÓÁ‚x»Ávò{ÁhôáÁ[TÁMuMÁ@$Á2–õÁ%mGÁ–¨Á ÂûÀþ´uÀæŽ?ÀÎi2À¶ÃœÀ ¼bÀŠÞæÀkÓ1ÀD^’À2Ä¿÷tf¿µ·³¿qÛ)¿H½þ-Ú>9Ü >ç T?'c¼?Gê?WúW?WX?Aºí?\Ð>¯Ú=1Ü—¾žÏ÷¿7wÓ¿”¿€¿ÑßgÀ KÀ,,ÀPÖÀvÕÛÀ¡À¤À¹ìÀÏžõÀæ8ÀýÆÁ §Á²Á#xpÁ0L=Á=ThÁJ~ÁW÷ÁeeFÁsÛÁ€m4Á‡]ÖÁŽb¤Á•rVÁ¢^öÁ›EáÁ”AgÁB Á†B«Á~‘aÁpÍÅÁcOTÁUç†ÁHŠÁ;‘Á.¹ŽÁ!ïYÁ¦oÁ –ÖÀûÓÀã€|ÀÍi&À·|ËÀ¢#ÀŽq6Àw§ÀRìWÀ1c¢ÀOˆ¿èpW¿´:¿„3¿?—‰¾úí¾š§7¾7 n½ø$W½ùù¾]·Œ¾¼‘ƒ¿wê¿a鿜jô¿Ì…PÀæqÀKùÀ?YãÀ`Å%À‚À”QñÀ§¤ À»lÍÀÐQÄÀåzÀü Á W|ÁÄcÁ ÖÓÁ-8 Á9¡‰ÁFc„ÁSDyÁ`[oÁmÀsÁ{6`Á„Z‘Á‹0•Á’#Á™!Á¦aÁŸdÁ˜aÁ‘ ÁŠgÁƒQœÁy> Áká¶Á^©ÊÁQÄÉÁDìRÁ87þÁ+ÿCÁï·ÁàSÁ2TÀúÀä#cÀÏ‹ÀºÇCÀ§Ž†À•"íÀ„&6Àg ÀHìYÀ,<‘À¨¿ûpØ¿Öô)¿¸ù¿¢‘¿‘v¿‹æ¿‹ Þ¿˜KZ¿ª]ò¿Äs@¿è°ÀõÀçÀ9Z#ÀU4@ÀtO-À‹èÀœ ®À­äìÀÀ´ÀÓà7Àçä}Àü¬ Áû.ÁL¯Á§üÁ+mÁ7 ÁCi`ÁOÎÁ\€ÈÁiVÁvJ&ÁÉYÁˆ…áÁBÀÁ–~ÁœÞíÁ©ÉšÁ¢ÑjÁ›á¼Á•¡ÁŽLÁ‡žžÁ€ö½ÁtØ©Ágý©Á['sÁN’gÁB[ïÁ6H˜Á*=±Á¦²ÁrÀÁg4Àû³ÃÀçDIÀÓáTÀÀæ¾À¯©YÀžúîÀŽîbÀ€]ãÀeÐRÀMã(À9WTÀ'^äÀÿTÀÁªÀüðÀ$ùÀL À R*ÀèÉÀuTÀ0;ºÀCBØÀYc¡ÀqܽÀ†d9À”ñÀ¥¤ŸÀ¶bÂÀÇöãÀÙÍ)ÀìëBÁ¨Á A«Á˜kÁOâÁ*žûÁ5úHÁAt°ÁModÁYŸ–ÁeýÁržÁsVÁ†+5ÁŒ½ÐÁ“q}Áš-tÁ êRÁ­©¾Á¦ÇYÁŸýÙÁ™LaÁ’ŸÄÁŒÃÁ…‡€Á~6ˆÁqq/ÁdñöÁX¼¯ÁL¡xÁ@ ÌÁ5zÁ)æÁÀsÁ'ûÁ îÍÁ-Àí’ÀÛUãÀÊoSÀ¹ûÕÀªërÀœm¹À°À„(ÀtöíÀcø.ÀUð«ÀLx ÀCÿÀB‘õÀAÏ,ÀHZÕÀP¢™À[¿nÀlpéÀ~äÀ‰Û>À•0ÚÀ¢™xÀ°+À¿ã}ÀÑ 'Àâ SÀóÍÁ:Á £bÁ\fÁ œFÁ*ééÁ5·*Á@óZÁLL”ÁWÎ%ÁcÈ–Áoç<Á|.Á„_&ÁŠÉLÁ‘; Á—¼ÀÁž_«Á¥éÁ±¸šÁªúxÁ¤L®Á©¦Á—ÁÁ£ïÁŠ8?ÁƒàJÁ{T+Áo 4Ábú’ÁWÙÁKnÁ@[Á5)1Á*xNÁ =ÁC¯Á ¯šÁŽ Àõä/Àå]¡ÀÕzùÀÆè­À¹œÀ­!hÀ¡…À˜–:À`¥À‰˜oÀ… "À`;À€˜|À€T›ÀƒK{À‡.4ÀŒÝYÀ”bâÀŠ2À§5tÀ±ú1À¾Î·ÀÌU:ÀÚ7ÀëqÄÀüfÁï‡ÁÒ-Á+tÁ"Ñ#Á,¯ÅÁ6ù5ÁAJöÁL'ÑÁWRAÁbžàÁn'¾Áz!ÈÁƒKÁ‰5‹ÁsxÁ•Ú„ÁœMÁ¢ÃïÁ©VÜÁµúqÁ¯PƒÁ¨ºŠÁ¢0LÁ›À_Á•ZÚÁ øÁˆÜÁ‚ÂÁyVÙÁmq»ÁbcÁVÐÁKžKÁ@ØTÁ6‹8Á,prÁ"Ø>ÁŸFÁÄŸÁa4ÁJ…ÀñvQÀã$êÀÖQÀÊ:úÀ¿XcÀ¶¼ÑÀ®Å4À¨xRÀ¤üÀ ÂÀŸçþÀŸÁÝÀ¢¦xÀ¦îÀ«Û6À²‰À»¢cÀÅ#MÀÏC«ÀÛÆÀè™ÁÀöA6ÁâœÁ €ÁÿÁÚ¢Á%Ù³Á/X8Á8ÿÁC ~ÁMV#ÁW±àÁbœšÁm¹ÓÁxö Á‚@ºÁˆ=ÁŽH€Á”ZÆÁš?Á í{Á§_Á­ÑÊÁº]Á³ËÏÁ­IºÁ¦Ý Á ‚ Áš5œÁ” Áô Á‡Ý+ÁïÔÁxzWÁmGVÁbÁWEÖÁLܧÁBªöÁ9Á/¾ºÁ&¶4Á•ÁûjÁÁËãÀÿãÀó6ãÀçlªÀÝ}ÀÕ¼ÀÍ.)ÀÇlCÀà ÀÀ#åÀ¿9UÀ¿/>ÀÂSÀÅ[òÀÊÙÀÐù¡ÀÙºšÀãHÀíÖÀ÷­ÃÁ|UÁ VÁu‘Á¤÷Á!4 Á)çËÁ2żÁ;üžÁE…ùÁO9«ÁYilÁc°pÁnÁy„Á‚éÁ‡«ùÁp˜Á“d=Á™nLÁŸ€ÞÁ¥³šÁ¬ùÁ²rõÁ¾ÞØÁ¸ezÁ±þ Á«©‡Á¥bÑÁŸ@ Á™&#Á“–Á*µÁ‡x­Áâ]ÁxœYÁm¼ÁcÁo×Áx°™Á€ÕæÁ…ŒxÁŠK=Á.ùÁ”IÀÁ™iúÁž‘–Á£ì>Á©r•Á®ýBÁ´–ßÁºP§ÁÀ$rÁÆ!Á×P¦ÁÐúâÁÊà ÁÄfÚÁ¾'yÁ¸ ×Á²†Á¬H‚Á¦«4Á¡?­Á›ãRÁ–šÏÁ‘x‹ÁŒŠGÁ‡Ð.Áƒ”Á} ZÁtÅ›ÁlûƒÁeWÙÁ^kEÁX@ÆÁRXÁMoÚÁI hÁEMÁA³–Á>Þ Á:›ÔÁ4øÜÁ0›Á-œ Á+Á¥Á+,þÁ+ôÁ-ÀYÁ0úçÁ5‘Á9g_Á;N™Á=¦âÁ@† ÁD)pÁH)ˆÁLè<ÁRoiÁX¾"Á_oõÁf¤ÅÁn{Áv:4Á)¬Á„9úÁ‰PÁŽA,Á“¨BÁ™3mÁžÑÑÁ¤zdÁªF2Á°3bÁ¶F"Á¼}ºÁÂÓùÁÉ7ÁÒ›àÁÌ ¼ÁÅÂÁ¿‚¾Á¹0ÌÁ²èÅÁ¬Å"Á¦ÉåÁ ûÁ›_+Á•ö¨Á›oÁ‹[^Á†EgÁh‰ÁybNÁoýÁg)XÁ_çÁWnÒÁP6ÁIªoÁC–AÁ>L,Á9ôÊÁ5ÜÁ22ôÁ/:-Á,šeÁ(ˆÁ#ôkÁ šÁmÁñˆÁÒ,Á ÎhÁ$LìÁ(MŸÁ)©·Á+—$Á.ÆÁ1¢Á4°}Á8âÚÁ=àïÁCÄùÁJ4XÁQ'¼ÁXmìÁ`E‘ÁhóVÁr2!Á{É Áƒ9ÁˆbiÁìLÁ“‰áÁ™0?ÁžûKÁ¤ë.Á«²Á±DìÁ·¡ÜÁ¾ eÁĉ›ÁÎÁÇz‡ÁÀô™ÁºŒÁ´D3Á­þÁ§¬pÁ¡€èÁ›€Á•¯ ÁÎÁŠ®@Á…TùÁ€äÁv/.Ál—fÁc)ãÁYàIÁQVzÁI‘TÁAý)Á;"hÁ4þ.Á/O¥Á*ÎjÁ&„ÿÁ"È2Á–ÁìiÁÖjÁ{Á¨ Án.ÁãnÁ™ÉÁùÁuaÁƒ±ÁñÀÁí.Áo2Á!MÁ%AñÁ)®Á.ôðÁ54VÁ;ÕQÁC ÝÁJvÑÁRÓœÁ\¦ÁejIÁo„WÁz;ÐÁ‚¦ºÁˆAqÁæ<Á“°fÁ™¤+ÁŸÅ\Á¦NÁ¬rdÁ²âÁ¹lÁÀÊÁÉÑÖÁà üÁ¼^ÈÁµÌïÁ¯Y†Á©Á¢ÌfÁœrüÁ–>€Á7NÁŠcRÁ„ÉIÁ~Í<Át ¦ÁiÌvÁ_áhÁVdžÁLøñÁCáÁ;´UÁ4 1Á,Ó¡Á&l!Á _Á®{ÁO²ÁgÁþ¿Á HpÁ £Á lèÁíÂÁ£¾ÁËÁ§ÇÁð•Áœ¾ÁÀ]Á AmÁ QÑÁð%ÁÁê#Á–vÁ >=Á&¢èÁ-”zÁ4Û¨Á<ÒqÁEÃ"ÁOÔÁYÓÁc¶WÁnÆQÁyòtÁ‚œaÁˆe„ÁŽ^¢Á”ˆ™ÁšÜõÁ¡FÁ§¾@Á®R}Á´ßÁ»r¾ÁÅéÁ¾ØûÁ¸ÊÁ±I®Áªª Á¤+ÁμÁ—•Á‘=ÁŠþZÁ„ïÍÁ~0¢Árÿ¯Áh?õÁ]œÁSe8ÁI¦Á@;Á6Ô¤Á. KÁ&.vÁ³‘ÁóMÁË´Á ¥ÁGyÁÁ}®ÀûMóÀöƒ„Àó4(ÀñÀï<ÈÀíšhÀî=sÀî;;Àï•Àò¯Àõ7XÀù”°ÀþúÈÁ Á¤Á ¡Á´-ÁNbÁ‰Á&ûêÁ/”Á8ÜÊÁB¥†ÁM6ÁXAXÁcb:Án¥xÁz6=ÁƒõÁ‰O Á­ÂÁ–!ÁœžÁ£8Á©º‚Á°[£Á·ÏÁÁðäÁºå‡Á³ê÷Á­ Á¦<ÁŸŽÉÁ™yÁ’˜úÁŒWšÁ† .Á‚ÁsSÝÁgœ³Á\oÁQµRÁGäÁ= ¢Á3„Á*}Á Ð×Án²Á¯-Á ¦¢Á.xÀûqŽÀòŠãÀéˆzÀâ9iÀܘÀ×+ÀÓ©¬Àч†ÀÏœkÀÎȹÀÎp§ÀΘ›ÀÐvÀÒÏ)ÀÖ ?ÀÚº(Àà–Àæ{áÀïÀùµ¼Á.“Á êÁc?Á†9Á"¬¯Á,ImÁ6¾ÃÁA¼ÁLÒÁX¹Ác£ËÁo³PÁ|3#Á„‚~ÁŠõ¬Á‘‚\Á˜ fÁžœÁ¥LIÁ¬!Á²ýnÁ¾|Á· Á°cÁ© áÁ¢¤Á›9Á”zßÁÞÁ‡g£ÁÁu¯ÁiàÁ\ÌeÁQ ƒÁEãSÁ;.FÁ0¨wÁ&Å1Át¡ÁŠÁ ÿpÁçÏÀ÷”Àé¡%ÀݱbÀÔ]hÀËERÀÃÑOÀ½èÀ·¶ýÀ´G,À²zÀ°ŽÀ¯‚À®£ÚÀ®ûÀ°’À³¨NÀ· OÀ»˜¿ÀÁ"ÀÇé ÀÑ ÚÀܾŠÀéÖ©ÀøQwÁª1Á „ÁŸÁ R†Á+,YÁ6AÆÁA€·ÁMxÁY6óÁeÒ²Ár³àÁ£ñÁ†g¥ÁŒå¯Á“…PÁšF[Á¡$vÁ¨ÇÁ®úíÁºUlÁ³4Á¬#oÁ¥(˜Áž8bÁ—0ÁA“Á‰pÌÁ‚ÂeÁxwÒÁkÇmÁ_J'ÁR¤éÁFJ§Á:~Á/\EÁ$¬KÁ?¥Áš¾Á}]ÀüK¾ÀêæÙÀÚè·ÀÌøÀÀIìÀ¶¸LÀ­”ˆÀ¥¶ ÀžNÅÀ˜¯ÉÀ•˜À’РÀÉ÷ÀBKÀŽ×iÀg»À‘JûÀ”†ÀÀ˜gðÀœ³>À¢9áÀ©ž‚À³À¿ïBÀͲØÀÜ;aÀí`Àÿ}#Á êÁ öÁ²Á*ï¼Á6‰nÁBÂýÁO~Á\bÍÁifYÁvwßÁÆ,ÁˆwôÁLÁ–5ÚÁ"úÁ¤ ½Áª÷&Á¶ºúÁ¯–ÜÁ¨sÁ¡RÁšD,Á“NþÁŒ\‘Á…XßÁ|æIÁoa$Áb.êÁU^ýÁHØÒÁ<=èÁ/ÐØÁ#õäÁÜÁÁ1ÈÁéÝÀõ6ÚÀã1¸ÀÐÅùÀ¿öñÀ°ãÏÀ£šåÀ˜ç†Àé±Àˆ ¿À€*"ÀtMtÀl~™Àg5-ÀbÿñÀ_ÎÀ^6ÌÀ`ŠÀd†7ÀkhOÀt îÀ|5Àƒ×À‹ÜSÀ–ÐYÀ£µwÀ²4ÿÀÁ]ÀÓ&ØÀçðÀü8PÁ 'YÁaÃÁ {Á,Z¶Á9-~ÁF«ÁS.ÖÁ`%+Ám_ÆÁzíÁ„\òÁ‹JwÁ’3PÁ™ˆÁ êÁ§$Á³½Á«ïDÁ¤ÙÁµÁ–ÿÁpuÁˆfÁxÁuìÁg çÁYW>ÁKùRÁ?%Á2hÁ%ÖèÁbqÁ u‡Ág8Àï…äÀÛe~ÀÉmýÀ·]ÿÀ¥õÀ•oÃÀ‡!NÀw»pÀdÁ™ÀV*‡ÀF_+À8ßëÀ/àÀ(ÉÀ${’ÀÊ•À+—À!®+À&ûâÀ/,À7Õ¤À@RÓÀL™ÊÀ]³ÆÀu ,ÀˆBÀ–¥À§NŒÀº¨sÀÏD•ÀåJ]Àû´ñÁ ˆžÁ¬Á"ÜlÁ/˺Á<ØáÁIãÁWKZÁeÁrä2Á€^Á‡C1ÁŽ1]Á•1³Áœ0bÁ¢üùÁ¯y'Á¨E)Á¡$FÁš ÞÁ’ø›Á‹Ó½Á„¯;Á{ªÁmëÁ_J~ÁQY_ÁCoÌÁ5ÞÁ(¹¦Á«ÁoéÁÿeÀîÌÀØhÀÂÏûÀ¯b:À…âÀ‹ÅqÀvÊæÀWt{À>ý4À+«ÞÀ]ÎÀ s)¿þÏû¿æ(|¿ÕNÚ¿Ëñq¿ÂlU¿Â# ¿Èê¿Õ` ¿êl`¿ý@ÀµAÀ9À&ù›À?M>ÀZßkÀxóUÀŽŸüÀ¢{1À¸cÕÀμyÀæ6RÀÿa"Á ‹ZÁnÁ&…æÁ3¸oÁAW]ÁO3ãÁ]Áj×kÁx« ÁƒR]ÁŠVÁ‘7•Á—ù§ÁžÊÆÁ¬SÁ¤ÙÁ—„Á–b)ÁBÁˆ,÷ÁNÁsåæÁe›ãÁW]ùÁI^·Á;­/Á-´ ÁèDÁŠÜÁ®>Àò×ÀÙ=.ÀÁDÀ«iøÀ–kPÀƒ·\ÀcljÀBõäÀ$}eÀ ¢½¿íí¿Ð†J¿³Õv¿Žd„¿_½>¿-h~>­dY>Õ Q>Ö7>¥6ƒ=G޾£cþ¿ "ç¿" 3¿Mâ…¿ŠøX¿¶¿éT²À>À?ºÀjÊšÀÀ¦àÀ¿åäÀÙÞ1Àô35ÁÕæÁÁTÁ#ŽdÁ1H@Á?(€ÁM0ðÁ[sÁhÒÆÁv`ËÁ‚äÁˆ÷UÁÂÁ—,@Á¥ÎÚÁž_—Á–ÿÁ¬²Áˆ_bÁÁs©2Áe92ÁVýÁHÛjÁ:¶VÁ,iÁ?ÁåçÁÀèÜ™ÀÍ'hÀ²·ŠÀ˜ÚYÀ¨*ÀQŽÐÀ'ǘÀs¿½ì¿‚§­¿+yE¾ã%¼¾®7@¾j™N<|d>ãÝG?{è?¡þ×?°Õ?°ï??Œ@Œ?=AK½ºÓ×¾Pk¾w[¦¾Íe¿'“’¿ˆe¿ÍDÞÀó¢ÀA9´ÀréäÀ“PŽÀ­XŒÀÈUòÀä8:ÀÿÿìÁ ¡ÁmÀÁ)t‹Á7r¯ÁE-%ÁRÉ'Á`e×Án9)Á|MØÁ…LþÁŒŠÁ“ÑœÁ¢ùwÁ›}ZÁ”ôÁŒŒ^Á…%>Á{žÙÁm/Á^lŽÁOæHÁAteÁ3;mÁ% êÁÿïÁ±ÀôÄÉÀØiZÀ¼ø®À¡™À†‹ÀYUŒÀ&¥œ¿õÄ(¿£Iz¿9¬e¾[§¼¼;ž=Ù…=1®j=òY€>™ST?&¾?œ˜é?öÏ!@DË@ ÿ?¬t?C ™>Û÷á>¡9>ã v?ú>Ùöë> b±¾‘¿d¢ô¿ÐèÀ¦ÀMÄ4À4ÀþÀ¹ -ÀÔÛÀïtŽÁ¹àÁÄXÁ!|ãÁ/1¦Á<ÅÀÁJ‰ÐÁX“<ÁfÞÁu]áÁúÉÁ‰LáÁ¤HÁ 1Á˜°µÁ‘3¡Á‰¶Á‚9ÊÁuz¸Áf›˜ÁWåÁIC&Á:«‰Á,#aÁ°Á|BÁmÀæ§1ÀÊ¥À­f&À‘1¨Àk­HÀ5À°¿ ‚¿¼–»`>ÌÝÿ?6±?fËò[¾~jÓ¿ƒÒ¿ëÊÇÀ+ãåÀcñþÀ!úÀ¨-þÀĦÀà‚ÀûœCÁ •:Á(ÍÁ&âpÁ4Ý€ÁC&8ÁQ­kÁ`OõÁnÿ‰Á}¹äÁ†BíÁµÛÁž”Á–ÛÁŽrBÁ†ëoÁ~ÛÁoáuÁ`çNÁQèŸÁBô9Á4,ÛÁ%ˆšÁëkÁ`~ÀóÝÀׄÀ»ÀŸ}¤À‚áÒÀL‘pÀÃñ¿»þÒ¿)™»=‰ˆ?0þ?‹å?Äè¾?íF¢ž8¾÷ø¯¿«›GÀ xÈÀB]­ÀyC®À˜¹À´]SÀÏÉðÀë! Á<|Á0<ÁuÁ.)Á<¶ïÁKtÁZ3MÁiàÁwëÙÁƒw¦Á‹€Á›IÁ“œÁ‹ô“Á„S‚ÁyrZÁjSáÁ[OøÁLUÐÁ=[kÁ.ZNÁYpÁy'ÁÏ?ÀæZÀÉ;FÀ¬_ÂÀ'òÀhÛÏÀ1T˜¿ðU-¿}G&¾1=9?+3Ê?©j?ã~&@'@3(@&áœ@á@¤Ö@ ¬Þ@"ðõ@BZ…@j@Yˆ@8ø&@$(ÿ@5^@#t@:çx@O?Â@AŸ«@ ý?Õ_|?`žÊ<©2¿Rk;¿Õ¸À"«’ÀZšàÀˆikÀ£òÀ¿.^ÀÛhÀ÷¡<Á i.Á.8Á'íwÁ6¬¶ÁE||ÁTn=ÁczÁrœ7Á€ìTÁˆ’‰Á™kÁ‘fTÁ‰¶ÅÁ‚6Át¯zÁeXìÁV@ÁFÝiÁ7ÆLÁ(Ê+ÁÍÁ ËüÀ÷•¾ÀÙŸŽÀ¼+ÊÀžäµÀµÀÀIÙDÀ$¿µ«B¿?”g¦?øµ@&3@AÙ@jm@aú}@Mä½@D1 @E@VÆ@pä@‰·@„9{@myS@\åâ@V‹@^IÂ@oÉù@‚z@e–@A8|@J?®z>?—N¾Ÿ(®¿˜&ëÀ@À943ÀoÎÔÀ“ÝÀ°|’ÀÍ—Àë(¶Áb/Á& Á!ùÁ0ô;Á@øÁOTÝÁ^£ ÁmõÁ}JxÁ†QKÁ— ÁJ°Á‡ùÁ´ŒÁpI€Á`é»ÁQŠœÁB+~Á2ÍAÁ#} ÁINÁ>†Àì}‘ÀÎ{VÀ°yÀ’váÀir*À.ãÿ¿èÄE¿kæP½qa­?N}³?Ö™ @úË@FÅÛ@kWç@ˆ1@ŒÉ@…(3@Öw@€8ê@‡;§@’`¢@¡Ÿ @žfž@’ñ @ŒŸ@‰üC@5m@“l¯@—¾ò@†EÄ@bÑ·@-’f?ób?…f >B1«¿)Ì£¿Â¿Àt³ÀRÐñÀ†[ÅÀ£ð?ÀÁ‹èÀß(ñÀüòÁ ÞÁÖ?Á,,­Á;†ÞÁJãEÁZ?ÄÁi rÁyGÁ„IaÁ•9%Áo‹Á…¥«Á{·´Ál*ŸÁ\©TÁM6DÁ=ÈáÁ.eëÁÌÁ§®ÁHÀáÙÀÃl À¥a8À‡^³ÀR¸òÀ´}¿µ`¿¾ÿô¬>Ô|§?§P\@ x@AäN@níµ@ˆ¬ô@™£Õ@©¥ä@£ž_@ž–µ@žÌY@¤{µ@®A @»²)@ºÂ@°J@ªœá@©ˆ@ªJ@¯·í@¬ù,@œOy@‚ܲ@Píy@>d?È›Â?4­é¾4ܽ¿‰T¿ü‚VÀ9o‘Àt§ƒÀ˜*¯À¶KZÀÔÜmÀó“£Á &PÁ‚ÏÁ'ßfÁ7K²ÁFÊÁVJºÁeË!ÁuOÂÁ‚kŠÁ“xCÁ‹§†ÁƒÛÄÁx%Áh‘UÁXý–ÁIiÖÁ9ÖÁ*CdÁ½xÁ J•À÷Ä6ÀÙùÀºG¼À›‰Ày’UÀ<Ž£À…Ò¿ˆÿY¾³x?N$÷?ÝÍ©@)tÿ@aæ–@Œ?q@œB›@®Àú@ÁPç@Â'’@½²Ï@½Ø@ƒú@Ë d@×#1@ÖÔ&@Îjo@Ék@Ç£“@Çý@Ì«Ø@ļ@®íe@”UN@rá@;ì„@ ?’ù»>ú¿+ú¿ÎUOÀ# èÀ`y ÀŽå²À­=ÀÌD³Àë ËÁZÁ‚†Á$²Á3‚þÁCSÁRžÒÁb;;ÁqרÁ€º?Á‘à/ÁŠ RÁ‚8vÁtÉ4Áe!`ÁUu^ÁEÔ‘Á6?ûÁ&­~ÁÁˆWÀïé/ÀÐÁ°À±¤pÀ’¾$Àgü³À*;¿ÙüÒ¿=ö\>Zår?“m˜@¾@Aƒ@}Æø@œ-4@²È°@ɶ@×L@à«…@Ý@Ý)„@á[@èÌr@ó¬Ù@ôr@ìÿ:@èœ*@æ Â@æNî@êbj@Ú¸@À~/@¥VÇ@ˆìâ@X#@<Ä?Ãx ?¾¹ê¿©OÀáýÀOB$À†Ž9À¥”]ÀÄšÀã ¥ÁWlÁäÁ z¸Á0OÁ?³õÁOQ¯Á^ù®Án¬Á~füÁo€Áˆ#Á€°ÎÁq¨ÁaøÁROôÁB©(Á3 Á#\éÁ¨¥Áø«ÀèµWÀÉ^ÀªkeÀ‹FlÀXBåÀøò¿·\ǾïZy>ü¬?º,ª@—'@Wêõ@‰ùµ@§ýä@Æ@Ú¨é@ì²¾@ÿÜ@ü–@ü¥³@ÿãaAm™ANÌA LƒAåxAï°AiêAƒ˜Ae@ì·L@ÐQ¾@³tm@•vw@n0•@1¶4?éX(?\¹½ÎýŸ¿‰jÀ}À@¥4À~Ò?Àž¥À½–*Àܲ%Àûç Á œÁT[Á-Á<ä>ÁL¶ùÁ\‹¿Ál`…Á|5KÁ³Á‡9OÁ~°¸ÁnòˆÁ_4nÁOvZÁ?¸EÁ/ú1Á @ÁŽ?ÁåîÀâÀÃ3^À£ÚÀ„gzÀIñNÀ ‹¿šƒ¾oy£?=Ia?Û8•@+æœ@iª–@“•‰@²Uò@ÑÊ@ïA ‘A ƒA ôAÝA€A »AóA2Af·Ab'AïèAïA Ú´@ú#Ô@Ûλ@½lñ@žÏU@ú@B Q@G?‹Ìx=÷&-¿YÏf¿éOÀ2ê–ÀqXÿÀ˜*ÕÀ·¾ÍÀ×d¸À÷SÁ [øÁ0ÆÁ+“Á:ÚaÁJ¯/ÁZƒýÁjXËÁz-™ÁŒeÁ…Á}Á|[(Ál†÷Á\²ùÁLãfÁ=Á-WµÁ”êÁ ÖžÀü1ÀÜ´êÀ½8ÁÀË#À|ÄþÀ=ö+¿þ³¨¿‚«¼ð›|?t‡?÷Ñõ@:S°@x£@›sË@º˜Ä@ÙÁ@ø¢ŸA °)APàAh¢Aå¶A%A!ømA& bA'ò¥A%,A"ÜxA!¶A .2AöqA–@äbk@ÅO\@¦.¹@‡ 2@O×X@”L?¦qª> ÄJ¿, ¿ÔPÀ)KXÀhš™À“öèÀ³ „ÀÓJ Àòô¾Á SXÁ/uÁ) ÓÁ8íßÁHÏ1ÁX±ƒÁh” ÁxxaÁˆZÁ‚RÁu›´Áh€ÂÁZ„ÁJ®Á:Ù^Á+-Á0üÁ \ËÀ÷À׊UÀ¸žÀ˜|æÀqì^À2êä¿çå$¿S÷ >8>?‘I•@v@FGX@‚†C@¡øÏ@Ák\@àÝèA ¸AŸ4A1±A,í®A-©®A.ÚkA1mÖA52cA7_0A4«‘A2naA1= A$=«A¬±A¸@ë}@ËÔF@¬Tµ@ŒÂþ@Zb@=0?·ª¼>áƒÄ¿ Û±¿Æ<¢À"ŵÀbmÀ‘ ?À°ÚŽÀЧõÀðu[Á!áÁ Á'ø×Á7çzÁG×ÁWȽÁgºÑÁw­›Á„«¡Á{@ÁmfõÁ_×MÁRŸXÁEÂmÁ8¸ Á(âÁ üÁ 5öÀò¿ßÀÓÒÀ³gÅÀ“»¹ÀhXÀ(Ή¿Óz)¿*¾–>¢îL?¦Öq@x¨@Q„¯@ˆ6@§ž¦@Ç ³@æ‚AÿCAºâA"qËA2*cA=2„A>œ=A@ù×AD|§AFá”ADd›AB3A6ð[A'EÐAm¼A‡é@ïAÇ@Ïn@¯šb@ư@_åû@ )¸?ÀÑ?Z¾øÎÑ¿½¶À¢ùÀ^…ÇÀ65À¯)†ÀÏ×Àï)Á½Á{fÁ'uÁ7n·ÁGh`ÁWbÁg[±Áu­ÇÁ_äÁtHøÁfÁWþWÁJCBÁ<ã²Á/ô‡Á#nÁâÌÁÜÀîy|ÀÎÍÀ¯ ¥Àt9À_›À 6ÿÁ»Ù¿T>îž?ºY3@…q@[ÛÒ@q‚@¬õ@Ìx³@ëüLA¿óA‚,A%@eA4ÿ~AD¾–ANg AP—eASáÄAVvnASü5AH7óA8EA(R3A_SAls@ðó'@Ñ g@±'§@‘?²@b–@@"­?Ňô? k[¾èrd¿¹îßÀà“À\ɶÀŽYmÀ®MþÀÎBÀî6MÁÍÁsÁ'Á7ÀÁDÓéÁRnÁ`TßÁnxÁ|ÀÁnÁ_t”ÁQuÁBÜIÁ4ðàÁ'dÅÁQÁ ÖÅÁRÀêHFÀÊ‹ÓÀªÏaÀ‹îÀVºŸÀnà¿°FB¾Æ» ?Ñw?Ë€:@%–@dom@‘ä"@±Ž@Ñ<ù@ðéeAJèA!A'âþA7¤ÊAGf—AW(ÇA`BÓAc\?AfýAXÒvAHÛfA8âñA(êmAñéAùe@òÂ@Ò»@²³@’.«@d{E@$™5?ÉnJ?Jª¾Ø”¯¿µï­ÀÝÀZÂWÀSÌÀ­FlÀÍ9 Àí+­Á'ÁÁ"lÁ/eÁ=* ÁK,ƒÁYeŽÁgÀ¾Ávð8ÁhûÁYx©ÁJÞŽÁÞ[ÁM»°Á\§ÞÁmŒ±Á^L!ÁO(tÁ@„Á1áÁ"#òÁ{ŽÁ"bÀî.³ÀÒXÈÀ·»ÎÀŸÀ‡†ÏÀgû¥À=,:¿û™c¿y¹^n5ANDA^îAmïËA{9ZAkG#A[TìAKbµA;p~A+~GAŒA ™Ù@÷OE@×j;@·„@—£M@oÔ@/ך?à<Â?A”¾uA$¿ž—ÀÆ…ÀN„pÀ~qÀ•7À¬Ô ÀƨœÀáð÷ÀýøPÁ g¦Á!®Á*÷?Á9ìÁI ÁXH ÁiÉÜÁZa¿ÁKÎÁ;ÎkÁ,œ—Á’”Á«ÿÀÿœLÀârúÀÆ*oÀªçÀ‰Àqƒ³ÀF»¶À'Õ¶¿êUd¿Vâà> î?’9¬@‡@Gòd@ƒ®•@£_~@ë@â½ØA7rAA îAA0Ë`A@¨–AP…/A`]§Ap3„A|VÞAlh×A\|¸ALÅA<¤ÒA,¸ÞAÌëA á@ùêL@Ú@º:Ò@šc@u/@5}Í?ë»G?Xõæ¾+¿’ÊÀ´àÀ8Ò¹À^„ÛÀ†OšÀŸQéÀºTãÀÖ·öÀóôÁ·uÁ¬¹Á&Ó„Á6zÁE‡øÁUÎÁfñËÁWUÁGÉ:Á8P£Á(ñGÁ²¹Á žÀ÷TåÀÙ‘bÀ¼>òÀŸô/À…V!ÀZdûÀ/ ÈÀ‰¤¿ÝuÈ¿<k>…au? ¿p@B@OÇ@‡¿§@§›Þ@Ç`Æ@çºAiAD@A#òA2ù¤ABÒªARªAAbØArZ4A}·2AmÍA]å^AMý×A>]A..ãAGiA`[@üò–@Ý#m@½TD@~*@{GÉ@;•”?÷¦\?oû^½u_«¿‡SªÀ~+ÀE ÀF…bÀvfÀ•ã§À²#+ÀÏ Àì«æÁo“ÁˆÈÁ#¾¢Á3¹ÁB‹·ÁR­Ádç4ÁU=_ÁE¡*Á6Á&‡^Á †Á¬Àðï‘ÀÒÿÀµÃÐÀ™ŒÀz,ÀFÈAÀxî¿û¬µ¿Ò냿&ˆÅ>±Šõ?¬ Ý@Ø~@U¬@Š¿Ï@ª¤¶@Ê~{@êX?AAäA$òÇA4ß©ADÌîAT»Ad©At‹èAJAob4A_zXAO‹,A?—¥A/¤gA±ˆA¿'@ÿšå@߸1@¿Õ|@Ÿæw@ì—@@ ?@+è?€—!;ÖrE¿}Ôy¿ì7ÚÀ…XÀ8~ÀiÕÀ®”À¬A,ÀÉ[¶ÀçôÁ¬ßÁþ)Á!qZÁ0ý“Á@œÃÁPJ¦ÁcƒhÁS¿BÁDÐÁ4V›Á$¸#Á.WÁÀmÀìò—ÀÎÔEÀ±^õÀ”÷ ÀsñÎÀ@7'ÀñR¿íÞs¿Ë´¿­>ÐÄ?³åq@á¹@Yй@ŒßÜ@¬×\@ÌÎÜ@ìÆÊA[ÂAPA&DÊA69®AF.’AV#vAfZAv >A€K©ApŸÝ'‘?·@p`@[^/@¨ð@­£ÿ@ÍŸ.@íš]AÊÆAÈ^A&ÅõA6ÃAFÁ$AV¶ÿAfhöAuÐìAyŠºAldyA_cAPƒ´A@•®A0§‡A ¹aAÇJAÍ¿@á¨f@ÁµS@¡ÂI@ÏN@C¸ä@ÓÂ?‡á¸=‚IU¿o0ç¿÷U|ÀyûÀ:cŽÀh'êÀÙ›À©šQÀÆ£(Àäw)ÁhÁÂÁ <¨Á/ÏÁ?sÁO%ÙÁcAÁSjJÁCÃÍÁ4- Á$ªxÁAêÁå®ÀíG¨ÀÏ3À±ÇÀ•e>ÀtÞìÀD)fÀ À\3¿ÈNF¿´”>ÚfÈ?¶ ®@ÀÕ@ZÇ@r@¬ÑP@̉.@ìA AüuA´&A%h}A4ûIAD]íAS›`Ab¸JAq©8Aq7Ad˜½AW€AAJOEA<Õ­A.xõA$2A€Ÿ@ÿ’ @ßß6@À-Ì@ |b@€²{@A½Þ@Æ?„ß\=2%ˆ¿sz¿ù 3À&xïÀF5Àq^HÀ’"àÀ­T}ÀɤÑÀæì"Ák©Á™òÁ ðáÁ0eÜÁ?ñ¡ÁOÁd]¦ÁT»xÁEMÁ5’YÁ&„Á½ÐÁ§ÀðçŽÀÓQ×À¶Œ?À› æÀ vÀVISÀ0ä‚ÀÅò¿ÎÕ}¿rL>¼ŒD?­É¢@ýd@U÷@Š @©`Æ@ȵm@çíAhðAÛfA"'0A1[A@ožAON©A\¿EAg ÌAcâ-A[‡¡AOuûAB|A5Z×A'üA<ãA Ñ.@ù‚~@ÚÖí@»Èg@œ @z|µ@;Uí?ø^³?t#z½g¿‚ˆ/Àj’À=î4À[P7À‚ÝÀšHWÀ´«ÀÏ{dÀìÄÁ¯åÁ¢/Á"ÇÃÁ2‹ÁA|wÁPüÁf%ÁVšæÁG#VÁ7Ã%Á(€¸ÁdñÁ |yÀ÷³¬ÀÛ2 À¿ËhÀ¥±ÀOéÀp÷dÀNª&À,ôÅ¿ÛØj¿;Ž“>'[?è @ H@Kœ!@„ø@£Ú9@Šr@á$@ÿœUAãAàõA,¨ÈA:‰¬AGCZARxAXQ}AV4)AOÍAEËÆA:kA-b|A N½A‰At™@î¡l@Ѹô@³× @•,@m¹Á@0Î?ã ?MµG¾2d¿“ÜŸÀ¶]ÀG’˜ÀvXÀïiÀ¤—|À½®¯À×ë6ÀóqEÁùMÁ“óÁ%pÀÁ4_ÁC´PÁSJÁhùŠÁY¢ãÁJfsÁ;J Á,WüÁšAÁ!ÈÁ"ÀæBÁÀË÷À²µ_À›è‚ÀˆTQÀqñ­À6tN¿ï“:¿e‰= J–?†‰D@Â@@>?Þ@{™n@œ#š@ºUm@Øj@ö&A Ë$AêA$þ*A1nA<¥æADü£AId÷AGÝZAA6A:¶A/ëBA$ÇAÿA *@ûÚG@àÿÉ@ÅS¾@¨Î,@‹î@[À]@†˜?Å,‚?l¢¾Ácr¿¬t¢ÀH4ÀRhñÀˆ‡ÏÀäŠÀ²’£ÀÉ•QÀâÈÀýe”Á t£Á£Á)$«Á7å½ÁFØ)ÁUñ—ÁlžÖÁ]ˆ8ÁN”½Á?Ì›Á1+¶Á"´~ÁŒŸÁ·Àó<-ÀÚY@À±À­ŒñÀ›qÀ€ ÀAð]ÀiH¿ðõ¾>­?Nwù?áN“@-:ù@iΨ@’«Ü@°Aë@ÍHh@鸶AYôA8èAp°A&ÈäA0"A6ÌàA:/A9‘A4éA,”ŽA$—kA –AÒÑA³Í@ëµÞ@Ñq#@¶Ïì@›Y“@~fÛ@E)C@ Kž?õÕ>9¿$ ó¿Ì'NÀ#$QÀ`xyÀK‹À®egÀÃ$cÀبÐÀð^¶ÁßEÁ5åÁ ÃÁ.QÁA#e?t6@w0@9”d@p²Ö@“¬@­¤e@ÆzA@ÞÊL@õd€AìdA {dA£µATâAÐÈASA½„AUA GA{@ñ,+@ÜNx@Æ ¹@®x@•™ñ@w^å@BžE@ J¯?­EÜ>íí ¾Ù’E¿¨EwÀ ûÀJqÀƒ ôÀ ÔÀ¿”ÀÝ›ÛÀü50Á óÁoÓÁ =Á-"]Á:;-ÁGÀ\ÁUXÁcÂÁ|CŠÁn ùÁ`ÞÁR^{ÁDúÓÁ7Þ\Á+?…ÁS7?†í^?ïQð@+(@\Rç@†L;@œ×4@±à=@ÄÚ@Õ™¸@ä2"@ïYž@÷L@ú²Ä@ùô:@ô›ª@êzŒ@Ý0d@Î`@¾"@¬,£@˜«@ƒ~ @ZÔJ@-9ò?øÁÅ?”«>±²¾òÞ¿¨ÐèÀ ÷wÀBôÜÀ{ÜYÀš½°À·›ÄÀÔÓ‹Àòƒ'ÁÁøÿÁ%óÆÁ2fºÁ>;ÁJ2ÁVà¢ÁcÙBÁq(«Á…7LÁ|åÒÁoª×ÁbÊ"ÁVSwÁJ?<Á>™CÁ1‰VÁ"„ÌÁ—çÁ´žÀëóÙÀΡœÀ±@_À”mZÀp’À7‹ÀþÛ?¥1C@Ã@3Æ@`ÈE@…½~@˜Ú¬@ª¿F@ºF|@ÇÈ@Ñî²@ØÐ³@Üæ@Û×E@Ößö@Íù9@ÁD@²ûN@£P @’…^@€!U@X—@.`©@þ?©˜…?˜x¾QÆ»¿kš¿ê_ZÀ*Ö€Àa ‡ÀŒ%ÞÀ§ò¸ÀÄ¥ÅÀáƒÙÀþaíÁ ÂÆÁ“ÌÁ+l/Á:EÁGxÁSœÁ_GªÁkéÁÁxïÁ‰-‹Á‚¿ÁxrHÁl }Á_úáÁTQyÁEèöÁ7EÁ((7Áw5Á Ï]ÀøEÂÀÛ_ À¾ú!À¢è¹À†íØÀWRÀ!%í¿×è¿b½¾Ø¡?*U?µÜ_@n¾@2e«@YÇÝ@~Õ5@Ê@ž B@ªÐ•@´(ø@ºr3@½db@½kÀ@¸ù,@°^_@¥’@—¶œ@ˆu¢@p"›@Mo®@'Ðr?ÿ[Q?«Š|?$š#½xs¿N¯.¿É²ÅÀÐVÀLt¹À€ÕÁÀ›»ÈÀ·!âÀÒÕ_ÀîÙ6Á¸•Á'6Á"—§Á1(HÁ?îcÁNÊ>Á\Ð/Áh{4Át£ÆÁ€œ Á{LÁ‡! Á€õÂÁuߢÁiVTÁZr¤ÁK RÁ<ô~Á.L¦Á¦Á.ÁŠÀê æÀÎnÀ²?kÀ—'ÎÀx˜ÛÀD×ÀÇ ¿½’%¿9ûà<âCƒ?8TÛ?²…Û@Ɉ@'G@I2Ü@h¬œ@‚ª@fü@– f@›Þ¼@ž›Z@ž¦2@šfÔ@’´!@ˆ(V@wS@Z‹H@;Ë@]­?ëš?ž¼s?Ö½5‹,¿>Åö¿¹Ç”À ýµÀ=XqÀo‚À‘ÜâÀ¬WBÀÇ#,Àâ!|ÀýÖ<Á ÏŸÁê€Á)$Á76ÁF òÁT§£ÁcXÐÁr-æÁ~@Á…ÃÁ’ÓÁ‹ô=Á…é Á}áÁoïÁ`sÁQÑ„ÁC6¬Á4ÂOÁ&“RÁ•CÁ ˜ÎÀù5ÀݼåÀÂð À¨C‘ÀŽmÀÀiy¦À8_ÀÜ®¿¯¿-B;¾‘?$ò?žŽÈ?ä”"@‰m@0ë;@JÌÚ@_JV@oß@z}ú@Þá@;5@w7™@i4ð@Uõ1@>ñ¶@$>@y¸?Èñ5?ƒ„Ð>ì¾?ô¿F—©¿¶î§À‰„À5Å9Àd–òÀ‹çÀ£û­À½ªNÀ×ÛÀòªÁËÁl|Á"HýÁ0I/Á>hŒÁL—!ÁZùbÁi‰$Áx){ÁƒgcÁ‰êÝÁ–õvÁ­nÁ‰O¸Á‚bÁuiÁfØ ÁXfæÁJ&Á<Á.Á #¤ÁJfÁÓÀîð.ÀÔ“ºÀºß€À¡MWÀˆÁdÀa@0À1ŸNÀÉÝ¿²¿?¡ƒ¾kA>Ø®6?r‚‰?¸.|?ñeX@£š@#°É@31Î@=.@Aâ1@A2‰@9}É@,ßÜ@­–@±2?×´w?Ÿô?<¯D>Y«k¾¯P ¿l¿Ã|äÀ Š]À4G•ÀaŸãÀ‡†ŠÀžéýÀ·q•ÀÐDÀéà¯ÁÐ_Á&´Á sÁ* Á7ÉöÁE¯_ÁSÇ;Áaæ ÁpÁ~y™Á†…hÁÕªÁ›™Á“Î%ÁŒ†EÁ…A¿Á||ÁmÁþÁ_žîÁQ æÁC®àÁ5ØuÁ(2ÁÓÁ ‰ÁÀçQ?ÀÍùÍÀµ†uÀQÚÀ…¹À^°À2'IÀ !7¿Ãy~¿q.Þ¾ÒAE=ÑÞ?tv?yí?«§?Ϭ­?ì€í?þïL@°F@)Þ?÷‡ó?á‘?¼úg?”¼®?M^ƒ>⤽±>¿7Ž¿”Þ¿Û3gÀÚÆÀ:ÖÂÀcýWÀ†íÓÀtŠÀ´+#ÀËœbÀãß`Àü›EÁ ›ÁèßÁ%tÁ2v¯Á?ï—ÁMoCÁ[(9Ái& ÁwF¬Á‚·ÇÁ‰Ó¿Á‘˜Áž\Á—ÍÁÝúÁˆ±¸Á—¤Áu&?Ág<½ÁYk‚ÁK­ÉÁ>/#Á0ÕÛÁ#«˜Á¹öÁ ê™Àú·‡ÀâN€ÀÊ›À²£yÀœ8ÁÀ…àÔÀbZÀ:bÊÀÅ'¿â¡'¿ iN¿Cú¾¡ÍÜ=ˆ–Ô>Ñ¥?-"?c5?ƒmÒ?Š,Ç?‰Ñ?vpâ?JÒ? 3D>w‡Ç½»ïì¾ÿ±K¿lC˜¿¹O<¿üš¶À!ºYÀFžÀl‘ËÀŠ%>Àž¸ˆÀ³×¥ÀÊ ÀàÏ»ÀøNÆÁB2Á}QÁ!*ðÁ. èÁ:ÿíÁHOÍÁULJÁc?@ÁpÊ Á~š'Á†T1Áj'Á”‚tÁ¡´XÁš„BÁ“cÑÁŒYÁ…fÁ|þÃÁo<¥Áa•”ÁT/½ÁFðœÁ9ÒÆÁ,òÖÁ 9‘Á¿Á‹FÀö¸ÒÀßcÀÉ(À²ÝÀÊ>À‰„kÀmB÷ÀHû;À&ø>À£w¿Ò>è¿›f8¿W¹·¿Ü澌Ÿ½Ÿ.Ô=f- =Îëô=¸$(¼LÍ“¾4q`¾ÏŠ¿1öô¿€•¶¿°ÁN¿æáÀ"ûÀ3”bÀUéÏÀyfÃÀYÔÀ¢¤hÀ¶ßÀËl¶ÀàÁxÀöî¶Áº3Á€•Á›dÁ*½(Á7MÁD0ñÁQ_Á^4^Ák ¥Áy¶ÁƒKhÁŠÁ‘zÁ˜ìÁ¥4.Áž%?Á—.TÁIÁ‰g÷Á‚‰ÏÁwŒ Áj8ÊÁ]%ÁPªÁC0zÁ6ˆ‰Á*#ÁïKÁÇÃÁ=¬Àö(nÀßÛ­ÀÊ”‹Àµ÷À¢àîÀ¼…À}ƨÀ]gÀ>>À!¨qÀæ@¿á„¿¼ˆÏ¿œ—á¿…²X¿lªZ¿`ž¿cø™¿~¿’¡v¿¬6 ¿Ñn¬¿ùþÀè3À,NuÀGëXÀhAçÀ…'À–ÆHÀ¨´ÎÀ»²’ÀÏÌÀã˜öÀø_ÁÕ¦ÁéñÁøÁ(ÔÉÁ4éJÁA TÁM„¶ÁZVÌÁg:Át3)Á€½OÁ‡zÜÁŽÄ6Á3A Á(ÿÁíwÁ6ôÁ¬¾ÀûqÎÀé4€À׌ÀŧÀµgÀ¥ÇoÀ—‹“ÀŠÛÀ}^ÀhµÀW»ôÀI)³À>ÓrÀ8±1À5µ»À6†À<ùïÀEû ÀQBÈÀa*ˆÀtyKÀ„@½ÀIUÀœñ[ÀªèšÀºQRÀË*PÀÜ·*ÀîxÁ¤9Á 4ËÁ<²Á Á(ÑkÁ3¿xÁ>ÓÄÁIýÐÁU”ÂÁa€¦Ám¡³Áz„ÁƒfÀÁ‰ÌéÁ7Á–ºÁ`FÁ¤"'Á±äÁª0§Á£yÈÁœàÁ–NÁŪÁ‰`¸Áƒ ¸ÁyŒÍÁmQÕÁa;˜ÁULóÁIÊzÁ>•cÁ3mŒÁ(­…Á ®ÁõÀÁ ±¿Á˜:ÀñxáÀàöjÀÐÄÎÀ‚À³ÐùÀ§îÀœdXÀ’/™ÀŠçÀƒ»½À}VFÀwíÀuÀÀuµ"À{¸yÀ‚9ÛÀ‡ËýÀŽã‚À˜%JÀ¢euÀ¬¹À¹t:ÀÇN.ÀÕéÅÀ庡ÀöÖ«ÁDFÁ QÀÁÉ'Á i_Á*™ Á4ÙàÁ?:¿ÁJ4bÁUH±Á`}œÁlNÁwÓûÁöóÁˆ,²Áއ(Á”í@Á›SeÁ¡ÉgÁ¨aÁµ/ŠÁ®‡Á§òôÁ¡`}ÁšãÁ”ˆPÁŽ5DÁ‡ö=ÁáÁw»Ák×üÁ`V\ÁUÇÁIí¹Á?$Á4—LÁ*LãÁ Ê¥Á¯¸ÁÄTÁBÞÀüE½ÀìÂ5ÀÞm—ÀЈÀŇÀº%‘À°¥ÿÀ©"~À¢ãaÀž À›;GÀš7ýÀš‘ ÀU€À¡w‹À¦ö–À­¢À¶.HÀÀbØÀÊ‚UÀÖD+Àã»ÍÀñÛ¤Á’8Á™)ÁS©Á,ìÁ#v®Á,îÁ6²XÁ@òçÁK2´ÁU§BÁ`©KÁkÁjÁvÿ¹Á9©Á‡\Á¡Á“P÷Á™§Á  ¨Á¦s·Á¬àEÁ¹›Á³Á¬xfÁ¦DÁŸ±ëÁ™_·Á“*ÁóÁ‡:Á2;ÁvärÁk– Á`mùÁUš¨ÁK“Á@µ,Á6û‚Á-Ç7Á$ÎôÁ&ÈÁê‡Á ïÁ‰dÀúÅ<ÀíïKÀâÅÌÀ×ë@ÀÏJ ÀÇÅÀ €À½ræÀºÂ¡À¹îšÀºO'À¼ä¾ÀÀµ:ÀÆ!.ÀÌw;ÀÔ’WÀÞK'Àèw‰Àó¼ìÁ"jÁ ŽÁhÁ0´Áf¿Á'8ZÁ0-nÁ9›ÁCyÁM ØÁWK»Áa‹‰Ál Áw5ÁÌÁ†Á«ÁŒt¿Á’JaÁ˜IdÁžu½Á¤ÈJÁ«.Á±” Á¾YÁ·—1Á±1ÁªÝØÁ¤FÁžbõÁ˜[êÁ’`¥ÁŒyÁ†ºÁ qÁvîEÁlYÁa†~ÁW)AÁMDVÁCßÁ:ÝÁ2%ÏÁ)²0Á!—BÁæ"Á²îÁ îÁÅÁC‚ÀöºÀíò³ÀæÀáRBÀÜß@ÀÚfÕÀÙ¥7ÀÚ DÀÜsûÀà „ÀåKÇÀë_#ÀóEÀüIvÁDõÁ²·Á¢ÁSXÁg‰Á$iÁ+بÁ4DtÁ=sÁFQ¥ÁOÂtÁYJÁcdÂÁm¤ÁwæÁCAÁ†É•ÁŒ`õÁ’•Á—±sÁ€4Á£z-Á©žÛÁ¯éÄÁ¶NgÁ»±Á¼^ÇÁ¶ ©Á¯ÃÁ©ž|Á£ Á¢'Á—À:Á’„ÁŒQ'Á†·MÁD³ÁwþàÁm£€ÁcžÁZŠÁPí³ÁH.]Á?’0Á7YÚÁ/}©Á(†Á íqÁR®Á”(Á+°Á TKÁOJÁÅâÁPFÀüNoÀúòÀù[ÔÀùËbÀü9Àÿ|ÁAôÁ.hÁ Á :±ÁE©ÁŒÞÁ`*Á#˜fÁ*šÁ1ÉVÁ9‹íÁA`ÁJ(³ÁS$yÁ\ƒ-ÁeïÁo‘Áy½äÁþ²Á‡"ºÁŒ|!Á’¸Á—¢ßÁEÁ¢ïoÁ¨¹‘Á®¯Á´ÌØÁ»ÁÇŽÁÁ;Áºú7Á´ÜšÁ®ÞuÁ¨ä‰Á£ÆÁKÁ—–Á‘÷|ÁŒhÁ‡;ÎÁ‚÷Áz;ÁpGÚÁgÁ^7’ÁUÙÁM!…ÁE)Á=o¸Á6/îÁ/V Á)<Á#t<Á4eÁ¯kÁ¦ZÁYkÁ÷lÁ ßÁÁ ï+Á ‰AÁ Ä¿Á É;Á¡Áá“Á´¹Áw‚ÁxíÁ!IbÁ&wÙÁ,4kÁ2# Á8ØÁ?ËçÁGOIÁO0AÁWW)Á`lÁiFÞÁr¸xÁ| ™Á‚ósÁˆ žÁ+‡Á’TWÁ—µ€ÁD"Á¢äÉÁ¨‡iÁ®.tÁ³õÍÁ¹ç3Á¿þÛÁÌm[ÁÆ4CÁÀÛÁºàÁ´'ÔÁ®O˜Á¨“€Á¢ÜÁ8FÁ—¾ªÁ’xOÁL/Áˆ9ÚÁƒK¹Á} „Át@ÆÁk‡ÁbþÙÁZÍ=ÁS 6ÁK‚7ÁD«Á=ÍÁ7Ê Á2dkÁ-Y!Á) Á%Á!ÿŒÁž‘Á›9ÁÐáÁeÉÁ£ÎÁ‘ËÁBþÁ!Ž,Á$@fÁ'áéÁ+ÇoÁ0Q Á5lOÁ:ÿ¿Á@ÖµÁG%$ÁN9ÁU%Á\ÜúÁdÝÁm)Áv™Á~ÿÁ„x Á‰/ËÁŽ$NÁ“>ƒÁ˜ZŠÁ‰Á¢ðÁ¨„]Á®&³Á³ÉSÁ¹n†Á¿4hÁÅ""Á×)ÈÁÐÒ×ÁÊ“¥ÁÄ>ëÁ½þ<Á·à:Á±è|Á¬üÁ¦{OÁ¡¬Á›ŽÂÁ–†Áè…Á‹ôçÁ‡8êÁ‚€sÁ{å'Ás~èÁksmÁc£CÁ\¨ýÁV}AÁPÑÁK˜µÁG ÓÁCFÁÁ@ œÁ=%šÁ:ÂVÁ8ÕåÁ7¤ÚÁ6} Á4ª!Á4<¬Á4õ#Á57²Á5¥`Á6•zÁ7ö¬Á: ŠÁ< úÁ>ìéÁBË›ÁFÀXÁK}®ÁQWÈÁW¿'Á^•ªÁeÅMÁm,Áue2Á~\&ÁƒËÙÁˆ¯ÁÚÔÁ“?Á˜Ë ÁžgLÁ¤œÁ©õMÁ¯ýïÁ¶$GÁ¼]¯Áž ÁÈ÷dÁÒt$ÁË÷½ÁÅ—ÂÁ¿SÎÁ¹¬Á²¼ïÁ¬—½Á¦šÞÁ Ê×Á›+©Á•¸lÁAÁŠÖ‚Á…©_Á€ÆGÁx^Án°öÁeÐÁ]¤kÁU¥óÁN2 ÁG½tÁA«ÊÁÁ´²Á­ÎÁ§}©Á¡PXÁ›M¦Á•z¸ÁÜÁŠlZÁ„ó—Á’ÁtÚÃÁk7ÁaÅÃÁXqÆÁOØêÁGÒµÁ?úÂÁ9 nÁ2ëÂÁ-+ÊÁ(^Á$1SÁ Þ·ÁÌçÁŽÁÙÁÌÁÔ=ÁR•ÁÁÁeÁ?-Á¼ÇÁ¶ÈÁEµÁR÷Á|ÞÁéFÁ#Ú“Á( ÝÁ-³}Á4Á:ÑpÁB«ÁIsÁQÚ°ÁZú·ÁdlAÁn‘ÁyIùÁ‚-FÁ‡ÉQÁzÁ“`íÁ™rõÁŸ£¾Á¥ß’Á¬,8Á²š[Á¹'ÓÁ¿ÎŽÁɨ^ÁÂáÁ¼2ZÁµžæÁ¯)ÊÁ¨ÖuÁ¢˜nÁœ@ÙÁ– JÁéÁŠ*¡Á„Œ¬Á~@ÁsM Áh‘wÁ^kÁTâ¤ÁKqKÁBIÁ:<Á2 Á*ZÁ$2dÁ.0Á;ÁË]ÁPRÁ'mÁ UFÁ @÷Áã,ÁßsÁU±ÁÅYÁh»ÁDCÁÌ›ÁÈÏÁn©Á zÂÁ ÈmÁs‘ÁeúÁBÁÿÁ%!Á,sbÁ3¹>Á;¼ZÁD¹ªÁNJÁXDÁb°ˆÁm¼ÀÁxõIÁ‚,AÁˆÁŽ.ÄÁ”cùÁš¢Á ø9Á§r¦Á® Á´¸Á»aÎÁÅ™XÁ¾­!Á·×OÁ±yÁªy•Á£øÁ™±Á—[QÁ‘ÁÁŠÅèÁ„´ÈÁ}µ*ÁrzÈÁg¨lÁ\´hÁR ÄÁHLÁ>ËÁ5DÁ,?Á$6øÁ`'Á)ÁfüÁ ùOÁ†ÁÈzÀýæÀ÷3ìÀòè!ÀïûvÀíÛ<À챨Àë“äÀêÚ•Àê•zÀëÁVÀí¸Àñ0yÀõN[ÀúNEÁŠÁüÞÁ RÁRÁÁ?‡Á%Á3Á.häÁ7¡>ÁAyÜÁLWÁW|ÁbX‡Ám½ïÁyŸÁ‚ë¿Á‰$4ÁfFÁ•ÈzÁœPÇÁ¢÷ Á©¡¢Á°LÁ· ÒÁÁÀÊÁº¸ÀÁ³¼rÁ¬Ö©Á¦ 5ÁŸZSÁ˜ÊÃÁ’_ßÁŒÛÁ…ÎÅÁFÁrÒÞÁg+Á[ÜžÁQHÁFzÁ;ˆÁ1°kÁ(? ÁÞçÁbQÁ}üÁþóÁ¹ Àõ¶NÀì—àÀä‹çÀÝ¡À×á¢ÀÓ[QÀÐ5BÀÎ:À̸ÀËžÀÊæ+ÀʦƒÀËõèÀÍãÀÑ…lÀÕ´“ÀÛB^Àã(¼ÀëuÀö¼LÁÀaÁ¯åÁù[Á/¯Á!T}Á*ö—Á5~Á@‚ïÁK¼ÁW$¢ÁcÁoToÁ{É€Á„-¹ÁŠžÁ‘6Á—à¯Áž‰ÒÁ¥>"Á¬Á²ï8Á½ö¬Á¶éAÁ¯ßÛÁ¨Ø]Á¡àÿÁ›0Á”B}Á£Á‡)ÎÁ€ÛNÁu2¬Áhˆ/Á\>5ÁPuNÁE>ýÁ:u!Á/‰Á%ÕÁbÁñ_Á¾%Á¤UÀñ¿yÀä*hÀ×üNÀÎ+MÀŲÀ¾ºwÀ¸˜gÀ³Ñ¢À°oÀ®2ŒÀ¬¼À«©ÕÀªõ˜Àª½ìÀ¬9÷À®—À±Ý$À¶/"À¼h_ÀÄB°ÀÍNÀÙPçÀæœ ÀõaÁ&Á Á|=Áæ*Á)ç`Á5!¬Á@ ÁL€hÁXÔ†ÁeM;Áqó2Á~ô|Á†ÐÁŒÊkÁ“ttÁš9°Á¡²Á§øãÁ®Þ=ÁºUÁ³/ÏÁ¬3Á¥JÁþîÁ–ø¶Á‹Á‰3áÁ‚‚\ÁwñÁk9ØÁ^Í_ÁRBÁE¬GÁ9Õ¡Á.¢Á#ÙÖÁø'Á¢ ÁèÀ÷PÝÀåž‹ÀÖ»ÀÇ+KÀºÉ‘À¯Ì#À§B‰ÀŸÖtÀ™OïÀ”GòÀ¨ÚÀŽlEÀŒÁšÀ‹¸3À‹ €ÀŠßøÀŒ‰ÈÀŽgêÀ’9lÀ–ÊÇÀöÀ¥b»À¯|À¼õÀÉݵÀØ|>ÀéBÀü,ÁOWÁMGÁˆTÁ)÷0Á5ó‚ÁBTüÁNÔ”Á[–‚Áh¾ÁvVÁ±ÙÁˆhœÁ@-Á–!Á‰Á£öLÁª÷cÁ¶¬#Á¯"Á¨sÁ¡L|Áš1íÁ“'SÁŒÁ…Á|a×ÁnÕ3ÁašÉÁTÁñÁHHwÁ;žúÁ/%Á#67ÁLÁ >ŒÁl·Àð‘`ÀݬwÀÊÛÀºJxÀ«SÀ¥vÀ‘ØzÀ‰'À€òqÀtXÀi€ŸÀaá‘À]KüÀY’ãÀW—ÀV[`ÀV,9ÀY®~À]ÅnÀe^fÀoCÀ}sÀ†ÎöÀ’äÀŸ#£À­Ž7À½dÀÏsÀãxÈÀùjÜÁñMÁa|Ái(Á+ÕsÁ8aÁEIQÁR’*Á_çcÁm:ÁzјÁ„IÁ‹+ÏÁ’ëÁ™ôÁ îÁ§ =Á³›Á«ë†Á¤ÉtÁ¬ÚÁ–‘YÁi+ÁˆOíÁF\Átz;ÁfyæÁX½ÁKUÁ>S§Á1Å.Á%4çÁ•|Á —0Ál"ÀíF„À×Ô?ÀÄÎÀ±?dÀžÓ À=GÀ€ÑÖÀhªÀÀUÖ3ÀD :À5ŽAÀ*ÔÃÀ"¯À¿nÀ®íÀÔ À×oÀåÀKºÀ/‡À&ÃÑÀ1vªÀ?qÝÀQ1eÀix1À‚hŒÀ‘ÚÀ£mÀ¶`nÀÌB¦Àâ»ðÀù—¸ÁâÁVÕÁ!ø«Á/ˆÁ<¿¼cn¿˜Û†¿sÌk¿6ßX¿Ca¾õ2“¾ÔF ¾ÅãU¾Ážÿ¾ÄL•¾ÝÀ§¿VÛ¿-—ê¿X¨K¿ˆµ¿¶ø`¿ì¼ÚÀ.©À9ODÀd;§Àˆƒ†ÀŸB'À·ÄÀÐÖÞÀêÑ@Á½QÁ Á†Á+GÎÁ9 èÁFó^ÁUÁbæÆÁpÞ{Á~âÄÁ†s¨Ác‰Á”TÁ›TÁ© ÀÁ¡»•ÁšjjÁ“KÁ‹ÐÅÁ„š¼ÁzÛµÁlˆÁ^E2ÁPBÁAÜ@Á3~sÁ%Z¾ÁFþÁ 6‰ÀöîdÀܧ‰ÀÃÅ'ÀªqsÀ‘€ÀvŽ9ÀK]=À$ À7¿¹*H¿røY¿²¸¾‰±‚½ví!>H¡6>ËoÊ?Rù?-?(?–ä?Í?0G>À°û>h€+=r‚T¾-^¿ †z¿€†ò¿ÀãêÀ 'ÄÀ6»6Àd1)ÀŠÄûÀ¤¤À¾‚HÀÙ*÷Àó¿ÂÁ˜ÃÁ\.Á#5Á1A¢Á?1œÁMÁ["Ái6ûÁw”Á‚#Á‰õÁÞÁ—°ØÁ¥û{ÁžŽùÁ—1„Áß…ÁˆŽZÁ=/ÁsæÁex!ÁWÏÁHÄ"Á:‚4Á,OÅÁ–Á·ÙÁžÀç =ÀÊõçÀ¯ð@À–¶›À{m¢ÀH¥ÂÀ-¨¿â’é¿™‰¿"0¾v>ŒEõ>ûÊ?"°*?b:¢?žÚÿ?»mÄ?ÃâE?Ì ä?Íþ¤?ʾ”?ª/ý?uì?P$Š?><ý? èR>€íæ¾2“í¿@Oˆ¿¸åÀ ãàÀ;•äÀo†À’3ÓÀ¬©BÀÇÓpÀãW5Àþö¤Á ƒ5ÁHÁ)_ÎÁ7b ÁEvfÁSfMÁaW)Áo`œÁ}…jÁ…ãKÁ Á”_ÍÁ£.žÁ›®·Á”0'ÁŒ¼7Á…X{Á|ìÁmd–Á^Â@ÁP+™ÁA½¶Á3\-Á%hÁÀîÁ­Àô¥ÖÀ×âŽÀ»½òÀŸ† Àƒ—jÀSRÀ!øs¿Ý3¿ƒš-¾Æ¸>1B?$ö?kØÐ?yØÚ?‡×?šû€?Âñ;@§‹@ E„@%¨g@&ƒï@Žf?Ík¦?§J4?œÝM?šm?“¡­?yýñ?jt½ Zˆ¿>鮿Ä¿Ày^ÀKÊ»À€uYÀ›øûÀ·ŽõÀÓ‰Àï™êÁ¢ØÁ¢¡Á!³ÿÁ/¶Á=¡YÁK¾ŠÁYì‰Áh8.Ávœ©Á‚’ Á‰äºÁ‘DÁ iëÁ˜èÚÁ‘h Á‰è[Á‚iÁuÜÁgZÁXOØÁI¬wÁ; !Á,pªÁàÁ¡+Á@ÏÀæ«ÀÉŸ(À­€ÀU•Àh‰LÀ0å¿ò£Ú¿>¬¾§í»>¾qÒ?t­Y?¬IE?½çí?´i?³çJ?Åäƒ?ëu@L_@1ºÓ@]¦@>­@éº@x?Þ|`?Õ‘Ø?ëØµ?õ‚%?ÞÊ8?®î?ˆîð?Ù»e@öú@„f@±Ä@ï@Êò@äø@'A­@F§6@né@Xd@7.@@õ#@ùj@$µ{@3ÍI@$ŽÐ@(? #¨>Ö·¾ÓÌá¿£úÀ «ÀAhÀxåuÀ˜G¬À´^kÀЪíÀìnÝÁ]õÁ¼ÀÁ!$ºÁ/{äÁ=ïzÁLŽ?Á[P-Áj+.Áy€Á„ÜÁ‹…ZÁ›‘Á“áƒÁŒ2vÁ„‹<ÁyÜÕÁj¼Á[¶WÁL·KÁ=¸œÁ.¹ìÁÃPÁöƒÁ<­Àç3ÈÀÉö À­ eÀZüÀgZÀ.‘¿ê{¿pNª½)L?Tà?Ø5¹@­’@1£h@G·q@;÷Ò@0§q@,Mã@5î@J Y@fˆ}@…ey@zÄG@] ¾@H!G@>E@B³Ï@TãÂ@nó:@Z×`@(®¾?çÒ®?tí4=¸k¿I¹f¿Ô8NÀ!‘ÁÀY³^À‰0äÀ¥ žÀÁXJÀÞ¶Àúï§Á æ|ÁWÁ(ñPÁ7Á—ÁF¯RÁU«"Ád²CÁsÅ|ÁyEÁ‰ËÁ™Z±Á‘«5Á‰üPÁ‚MkÁu= ÁeÝ¢ÁV†âÁGHêÁ8+Á)*–Á+æÁ -6Àø]ÀÚ¡hÀ½ÉÀŸÃ‹À‚ÀKYoÀÌÕ¿°d½¾øn>ÎË?¥þ@ Íë@BÛ @_y•@~ÈŠ@uET@eÑÎ@_®@d‡$@uŧ@‡È­@˜NU@’£@…~š@yû«@rMŽ@w@„}È@‘6@€§@K÷z@Œ?¹¼?´œ¾”¸µ¿•TÂÀYÀ;RÀsï&À–·ÿÀ³ŠËÀÐhrÀít³Ád÷ÁMãÁ#TÁ2fíÁA‚ñÁP¨Á_è–Áo;ïÁ~…Á†óŠÁ—^êÁ–ÀÁ‡Ô’Á€vÁpÍxÁao®ÁRäÁB´Á3U³Á#øRÁ¶ÁŸ Àí>aÀÏAÀ±C¢À“X'Àk XÀ0¦¿ì:‡¿qÈP½6>À?ZÜÅ?ßò!@(Ã<@b«@…Ša@— A@–²˜@'Ç@‹¿E@.±@“è3@Ÿx«@®F¹@ª±N@Ÿq¼@˜fH@•(6@—Äá@Ÿ.¢@©¶!@‘¬@k…@3vu?ødo?ˆ¼”>:øÝ¿2CŽ¿Ê[pÀ®‘ÀXKÝÀ‰xÀ¦o8ÀÄÀâ±Á+¶ÁIFÁgÁ-›ìÁ<íÁLA•Á[–+Ájí ÁzSœÁ„æ'Á•–@ÁÍÁ†ÄÁ|p!ÁlÔ¿Á]?ÀÁM¹ÙÁ>F½Á.æ½ÁˆóÁ+)ÁËwÀâÖ±ÀÄJXÀ¦+UÀˆ'–ÀTTmÀY¯¿º>¿÷|>ƶ?¤îÉ@ ß@E Á@~â @š¦t@¬‚Í@³€O@¬8Â@©¢@©´®@¯ @¹QË@ÆuD@Äë7@»y@´å6@²gß@µm@»ˆa@½?g@¡#ú@…}Ã@S]¨@¸9?Ä`t?&Nؾ~Ò9¿“ xÀeùÀ?gÀzØåÀ›½ÆÀº4ÀØZTÀö¤HÁ žÁò§Á)KØÁ8³ÁH"!ÁW¢ëÁg%ýÁv©Áƒ1Á“ÝÁŒÆÁ„8BÁxÙ®ÁiG2ÁY´µÁJ"8Á:ˆ®Á*íLÁSTÁ Ê•Àø»˜ÀÚÀ»B¼Àœ‚tÀ{„YÀ>SžÀ2²¿ŒC-¾"m~?F8j?Ù2´@'£±@ak?@‡]@ªE(@¿Â@ÐĦ@Ê-@ÆÉ@Çt@˨H@ÔÃ@à–¥@à¿@׬õ@Ò_@Ðvà@Òë±@Øß@Ìâj@±-Ÿ@”àr@qÜ@8U$?ý¥[?ˆm&>öà¿H°¿ÜßÀ*ËÀgŽ—À’"À°žDÀÏ[¨Àî-ñÁ€$ÁùÊÁ%|ÜÁ4ÿîÁD‡ÏÁTÁcžUÁs)—ÁZmÁ’a½ÁŠŽdÁ‚´ Áu®ÍÁeõ‡ÁV@IÁF”¿Á6õeÁ'aãÁÏfÁ<ÀñBvÀÒ ²À²ÔíÀ“¶ÏÀiÜEÀ,\…¿Ý·ì¿Em™>=Tû?âŠ@ ÿ@@½@{0“@›é@¸/Œ@Ót»@å€[@èžo@äèÆ@å!@é ˆ@ñEí@ûô(@ý¤@õÊ@ð~a@ï @ñ,;@õzÈ@ÜdÇ@À i@£ˆc@†¯²@Qò¤@ •?¶ >óÀÞ¾òèe¿¶djÀ\+ÀUëÀ‰ÈÀ¨¢ÀǧtÀæ³aÁäóÁp6Á!ûyÁ1ˆîÁAkÁPª†Á`E¨Áoí%ÁžÆÁòeÁ‰•Áîci?¶™ú@ÍŒ@UùG@‰ ž@§™@Äãï@âmë@ú_ Aa?A½žAÓ¨A˜A>uA šA ,A ‘oA…öAö9A…ëAÈß@êä…@ÍŽ¦@¯×Z@’.S@gg’@*’i?Ûz‚?AŸ¾Sž¿•ˆ~À®FÀFÜÀ‚ŽÒÀ¡°XÀÀÑÞÀßódÀÿëÁ±ÁÂ-Á.uúÁ>5NÁMüwÁ]ÄŠÁmŒžÁ}WLÁ¤ÙÁ‡Ã+ÁÂüÁpªÁ`D–ÁP‡éÁ@Ò·Á1eÁ!_ÅÁ¡ÁéGÀädÎÀÄ÷À¥‰NÀ†9ÀMKYÀmo¿ &<¾¶ö?2Ú©?ÖIG@)œ@gö@’ºø@±{@@П@îšAJAh/A.AA?zAÔsABA†ˆAÊAÇ Aó!A]}ArA 6Í@öµc@Ø7<@¹Àð@›3†@xç{@;=“?û`?}ô…<œ¡¿t*«¿ö!À9’wÀwö]À›,ŽÁ.jÁÁ¨õÁãˆÀþ=lÀÞ¿À¿@äÀŸÂ³À€HªÀAµÕÀÚV¿‡ý®½¤k?fàœ?ñ'L@7o%@uæí@š,È@¹h@ؤX@÷φA GÜANA ºòA ÈEA"6zA% ãA)CpA+;A("?A&|A%A_§A@ÿQÒ@àvê@Áž@¢Æ¥@ƒÒæ@I&æ@ ¤g?˜CÏ>Yö…¿CŒ\¿ßLÔÀ.ÉØÀmíFÀ–ÍÀ¶4ÆÀÕÚ,Àõ€Á ™RÁyyÁ*^ZÁ:DqÁJ-ÁZZÁjRÁyçÁ‰»5Á‚õgÁx©èÁk(»Á[R…ÁK|OÁ;¦Á+ÓTÁ ¹Á G¶Àù ÓÀÙˆ:Àº¡Àš|–Àu×AÀ6µW¿ï&Ú¿b i=Έé?Š»á@9o@Cï@€ø7@ eö@¿ÕÖ@ßH§@þ½RA‰AŸmA.=RA0f`A1´iA4QA83ñA:N)A7™šA6A1àµA"oÿAÿHAã@红@Èq~@©(Z@‰ß5@TÄ@p‡?¬Ks>¶×_¿!¿·¿ÐÀ'—ØÀg/#À“c7À³1wÀÓ*ÀòØÜÁ VGÁ@ Á))ùÁ9AÁIÁXò¨ÁhâôÁxÓ@Á†÷Á~<öÁpÚÁc0ÁV-xÁIR>Á9NÁ)«šÁÕeÁ ÿ/ÀôQòÀÔ¥†À´ùÀ•M¤Àk}À,uä¿ÚÝd¿9Ý>…í—?Ÿ¿:@‡@N#q@†¢®@¦3£@Ŧà@å—AEPAÿA!ºyA1u½A@šAAF AC¢jAG:ªAI¡¥AG%aAE&¶A5‰A%äeA RA6N@ì¾¼@ÌñÕ@­$Ý@Y8@[$@ƒÙ?·Ù>âF¿ ´«¿Æ\·À"ïŒÀb±uÀ‘;îÀ± …ÀÑÝÀðë—Áh«Á[‹Á(NkÁ8AKÁH4+ÁX'ËÁhÁxÌÁ‚¨ÁwOÁiFþÁ[v3ÁMöWÁ@ØÁ42Á'iÙÁ–éÁÃùÀïâÀÐ<4À°–TÀðtÀb•)À#Ij¿ÇûV¿“q>ÕŸ×?´¤@+Þ@X3;@‹©S@«:H@ÊË=@ê\3A÷AÁ”A$_A4YÿAD„APãAS ¢AVc½AYHAV·ŸAG4«A7H’A'\yAp`A„G@ïˆ@Ï-÷@¯?f@PÔ@^Ä…@çc?¾€>ùhç¿À¿ÁRÀ jLÀ`GoÀIÀ°ÚÀÏíÁÀïÓ€ÁÞÁÔäÁ'ÍpÁ7ÇGÁGÁÁUâ¯ÁcŠÁqd²ÁygÁpÿáÁb¡ŠÁT~ëÁF¤…Á9-Á+ØrÁ"ÁÝÙÁwhÀëEûÀË¢qÀ«þèÀŒ[JÀYnçÀ'9¿µ¿¾Ü¾ì?¿A?Åîü@"?,@a‡y@is@°S@ϵ2@ï[%AyçABbA' ÆA6Ö{AF¢2AVn°Ab~Ae©üAhÛAX!íAH(þA80A(7!A>3AED@ð˜«@ЦÎ@°´ñ@Ã@a¢n@!¾´?õó?Üþ¾ïcÖ¿» jÀ³ïÀ]—©À޽²À®¯ÀΡlÀî‘Á@ Á7TÁ&„Á3†)Á@åJÁN—,Á\˜ŒÁjÚÁy®LÁk VÁ\”œÁNZ Á@iÁ2‚Á$lùÁ?„Á ´Àü~-ÀåíÀÇÀ§n/À‡ÄYÀP5ÀáV¿£,A¾’xx?3à ?Ø~)@+†&@jÍÁ@• ·@´®Ž@ÔRe@óöÁe×°ÁW ¥ÁHj§Á:ÍÁ+éžÁüûÁGtÁ ÀìôûÀÔãÔÀ¾À¢¬ëÀƒ€ÀFÈ*À„¦¿“¾æÞ?X²¸?êç4@4ÇH@t @™¯Ù@¹Sb@Øöê@øšsA þAðÂA+šA;”†AKfqA[8]Ak HAy ·Ai©[AY±ÿAIº£A9ÃGA)ËëAÔA Ý3@óËÕ@ÓÞó@³÷@”¬@h\|@(“X?ÑÊ?#ñȾ¶x ¿­4éÀeèÀV1[ÀŠþgÀªä!ÀÊÉÛÀâ¨ÎÀû¸Á {ŒÁûrÁ%Ê Á3ñïÁBcÁQhÁ_ÜkÁpwÁai ÁR~~ÁCšÜÁ4Ö+Á&I‘Á«Á '˜Àù,oÀÞ×®ÀÆ/À¯,RÀš\ÅÀ|èìÀ=tû¿üI³¿{Rà;öÒé?(3?þ%Æ@>[¹@}¤J@žo³@¾ A@ݪÏ@ýH]As+AD+A.wA=ç%AM¸êA]Š®Am\sAz—üAj£¶AZ¯pAJ»+A:ÆåA*Ò AÞ^A êt@õîY@ÖŸ@¶"å@–=,@l®ä@,ãq?Ú0o?5”d¾’U¤¿£õÀªOÀQZÀˆ„õÀ¦GØÀ¼Q$ÀÔ=ÞÀí­SÁ6üÁ–Á jNÁ/wÁ=¸ÁLŽVÁ[ŽdÁlÅ6Á]’4ÁN|¼Á?{ÛÁ0“ëÁ!¾Á#tÁÛSÀîÙÀÓkíÀ¹ì°À¡ùàÀÀu(ßÀ5¢p¿ì8¿ZVE> â?î›@ý½@G„,@ƒvg@£w@ÂÆˆ@ân™A UAß]A ²A0‚A@PÝAP¤A_îŠAo½A{¨ÇAkµA[ÂØAKÒjA;ä@A+÷†A 3A H@øjÀ@Ø”ð@¸¿!@˜éQ@r'@2{™?广?Lú©¾Eø´¿—ûÀ ™÷ÀK4À„>À˜ÔÀ¯ƒ‰ÀÈZÀâþ}ÀþÞÔÁ Ê»ÁNKÁ+ 1Á9ÿ[ÁIêÁXY/ÁiömÁZ‘tÁKDnÁ<4Á- žÁ2gÁ‡ÁÙ-Àå ÉÀÉeÍÀ¯=ðÀ—YKÀ‚MÀ_ïÖÀ.÷5¿Þ‡A¿>@/>G?Ÿ®;@в@O2å@‡a9@§(Œ@ÆëÄ@æ®ûA9AµA"üQA2Ó¥AB§®AR{¶AbO¾Ar#ÇA}MAmeA],}AMA•A=VÛA-n­A‡A Ÿ’@ûq¢@Û¤“@»×„@œ u@xzÌ@8à¯?ò‹ ?fcH½ÂÕN¿‹ŒNÀu£ÀE¯ÀsÕNÀŽ^À¦}»ÀÀƒxÀÛ›þÀ÷à(Á zOÁ;¶Á(Á7 ÁF2‚ÁUw{ÁgëãÁXyýÁIQÁ9Þ`Á*°•ÁÞÁ ¿”ÀüPƒÀßçQÀÃïÀ¨þÞÀäÀtùmÀPþ¥À)¿Ò™%¿&B—>±Z9?«Îh@£!@U_ @Š}@ªhð@ÊB»@ê…Aû(Aè A$ÔòA4Á×AD©ÇATªAdqŽAtT`A~‹ An¥;A^À(ANÜA>ùA/A3&ALï@þÅœ@ÞñZ@¿@ŸHÖ@~é(@?@¤?ÿ)?ŒH;EUÝ¿~¿þdHÀ>ãàÀgøþÀ‰A@À ûœÀ»,&ÀÖפÀó-ÛÁ OÁÓÁ%Ó+Á4ÿÁDLÃÁS´ÈÁfŒ¿ÁW¢ÁGˆÿÁ8'Á(ãxÁŬÁ Ú›ÀøiÀÛÞ3ÀÀj—À¦:UÀ>ÀoBÀKg¡À$:‹¿Èîm¿ÏŠ>Ø{Ž?µ¥Œ@–@Z_f@ @­f@Ín@ìÿAvˆAfŸA&UšA6D–AF3‘AV"ŒAf‡Av‚A€'’ApeA`zãAP*A@£»A0·LA ÊÝAÞnAñÿ@â @Âý@¢*Í@‚9i@Dà@¬î?‰“ù=œác¿kïš¿õ½°À:ɨÀeYRÀ‡$çÀŸKóÀ¹†äÀÔä Àñ:\Á.Á ËÁ%Á4PMÁCš¾ÁRþJÁfDgÁVµìÁG8êÁ7ÑÍÁ(†•Á_´Á i¥À÷lmÀÚÀ“À¿#öÀ¤ðxÀŒ4.ÀmÔÀK·À ˜7¿Áw¿{,>÷ïU?½µA@·V@^” @8a@¯&¼@Ï@ïqAxžAisA'ZIA7LZAG@TAW5ÉAg,kAw#ÿA~L7Aq°Aa•AQyAA¤jA1ªÅA!± A·wA½~@ã‡@Ó@£Ÿ"@ƒ«/@Gnx@†‘?=W=öØ¢¿`Ä„¿ð2šÀ8Àk!úÀ‰ÁßÀ ÌPÀº24ÀÕ ­ÀñçÁ#ÁËMÁ$ÌîÁ3úfÁCI~ÁR²âÁfŒâÁWÂÁG´ÎÁ8]ŠÁ)"­Á¯Á .3Àù'ZÀÜ´ÊÀÁ‚À¦®¬ÀޱTÀtØIÀR½cÀ€3¿¿*.¾ýOÚ?‚?ÀXy@ X@_Çh@·š@¯Œ@ÏdÔ@ï?‚AAznA'gÅA7@ÁAFóAV…ŸAeöÛAu.ÅAu¢cAiêh­?¹Õë@ˆÕ@\&µ@âK@­{A@Ìÿ‰@ìƒÑAé AiA$þóA4Q`ACŠ˜AR•wA`æAkØ Ah8A_À·ASú}AF÷»A9ºÊA+í°AOûA6@@ý£-@Þœ@¿$þ@Ÿ­Ý@€6¯@A\@ÅZ?„â±=F~â¿q !¿÷½SÀ;¯®À{À˜ÐÀ­`ÀÄïUÀÞrAÀùK'Á žMÁüäÁ'§(Á6ŠÞÁE› ÁTÎ:ÁiŒõÁZ@ÙÁKyÁ<Á- Ár¾Á æÁü8ÀèÕ…ÀÏÀ¶ÁÃÀ Ñ!ÀŽzøÀeÑÊÀ&Gœ¿Í·¿Ö>>¼)2?¬Qå@Ña@S}€@‰Ï@¨jÞ@ljx@æHGAykA¶zA ÛfA/·êA>AJÑêAVcxA]YAZ¦-AS?NAI×ôA>p#A1·ûA$‚oA÷ÆAÔd@ôF@Ö~@¸$@™P1@to‚@6:Ë?ïi±?cR½Â$y¿‰þÊÀí§ÀC#'À;”À å•À·"#ÀÎ:ÉÀçt‡ÁÔ(Áb›ÁgrÁ*ņÁ9hÁH@ÁWBdÁlWèÁ]=AÁNE2Á?wÙÁ0ßïÁ"‹ØÁ8ÁóÀó«ZÀÚ£éÀç[À¯y~À–q±ÀmçLÀ/Aì¿áJ—”?–K@ r_@G ±@‚/!@ Æb@¿WÅ@Ý£¤@û‰¼A ŠßAÉqA(OIA4ÈCA@n¨AI8¶AN-_ALžOAE£þA=¥8A3Ä(A(¯ A6‰A)­AÙþ@çÈì@ËP÷@­ó­@5r@cþg@&ÈA?ÓÈ?-ÚÕ¾•Ë¿¡˜ÎÀ'ÀMןÀ†[üÀ¥Ì(ÀÄíÚÀÚ£{Àò†ËÁÌ5ÁâÁ aÁ.„pÁ<Ú%ÁKouÁZ7ŸÁp+âÁaRæÁR¥ÁD,>Á5ôåÁ'úÁA²Á ÿ3Á[2Àé8ÀÒó}À»b*Àœ;»Àz*˜À;ݺ¿û!¹¿}ü¼”•Ÿ?p@Ý?ò8”@5ñy@ré@—T@µ¢@Òq8@îàgABúAUJAº$A*MOA3Û°A;CøA?ÅA>ŽA7æA0A¶A'©ŠA‰²A˜@A‘e@óF-@ØØ.@½ÌÛ@¡Tæ@„â~@NÀ­@D7?®Ø.>Óyç¿ 6v¿¿‹aÀ›ÉÀ[²øÀŒåÀ«ð«ÀËõÀé…íÀÿš Á Ì_Áˆ@Á%Ò‘Á3v°ÁAn¥ÁO±²Á^1`ÁtÇÁf2®ÁW¼ŽÁI~µÁ;‰‚Á-îrÁ ÄjÁ)ÁiÀùoÑÀáe…ÀÂ?¦À£ÈÀƒÿ7ÀJÖÀ /¿ ‘q¾›œM?%†•?Êû+@!UG@\%ï@‹ró@§ð:@ÃÎ!@ÞÏw@ø¡ÄA™*AAüÔA&gvA,¯ÜA/Î$A/ 'A)î@A"¸´AªvA°AW’@øÅ~@áU­@È%@­ëº@“Ù@nÊJ@5ç¤?ø€?ƒ—=ñL¿U{®¿äF&À/íÀlÈÀ”Ž-À³WþÀÒa`Àñk6Á³ÇÁ+ÁC¨Á,  Á9S½ÁG*ÁTôZÁc^Áyÿ_Ák§bÁ]‰ÁO±•ÁB.”Á5‚Á(seÁ-àÁ—æÁÐÍÀè£vÀÉÉ!À«H®ÀŒÙ´À\ØŒÀ ]¿ÇYï¿»Ô>œ‹h?œa™@ß@Aà­@yÛ@˜M„@²Ûù@ÌZ@ä Î@û~]AúAòWAŒ÷AæÉA |æA Aµ´A"ÆA YÞA×b@÷C@âan@ÌY{@µlS@œ“s@‚i@Oɧ@g»?Äš?!ÀY¾Š`¿—,À)!ÀBЬÀ~µcÀÑvÀ¼E÷ÀÚºxÀùOÁ rÁ64Á&ì Á3K×Á@'ŒÁML¥ÁZιÁh¡kÁ€ ÁrÁdE5ÁVÙKÁİÁ=mÁ0ʯÁ%"@ÁCaÁ#Àñ“KÀÓ$QÀ´µWÀ–lŠÀq31À5¤o¿ôÇl¿Y½¤žÕ?NiJ?×*…@#Zw@Y(@†®@Ÿãç@¸À@ÎÑ™@ãç¸@ökªArÄA ?dAÓCAÚAç6A nA!@ÿ»(@ïn%@Ýá=@ÊÉ'@¶¹@Ÿíx@‰C^@aY%@-ÙÇ?ñÉà?†Q/>A ¿/¿¿ÊHçÀÞøÀY6‰ÀŠQ?À¨õÀÅçOÀäzÁ9óÁt3ÁµþÁ/FÁ;;ÑÁG‰ÒÁT7 ÁaP ÁnèÁƒTÁy×Ák´¢Á^œÕÁQáèÁE ÑÁ9ñ¨Á+/îÁûÁ ÆÀû;»ÀÝF¼À¿tsÀ¡¬õÀ„,lÀM¿ÓÀ‚𿵒¿ x´>ª{?—‘@´@4x¤@fdK@‹Pÿ@¢t@·XÍ@ʸN@Û›@ë @÷=G@ÿˆãAÃ~AT©@üe@ñzÎ@äý@ÔØ@ÃÑ@±Ç@žz(@‰Æ@gé@9Î÷@¤ˆ?¬•8?‡¸¾¯(¿“âÀfËÀ9¹žÀr¼sÀ–S9À³”ÀÑÀîÐEÁQ\ÁUÁ$`þÁ3‹GÁBÈŠÁOÇ^Á\DÁh»!ÁuÆãÁ‡ Á€bwÁs¸þÁg -ÁZÏÁNm Á?9RÁ0=Á!1Á"¸Á2*Àè• ÀËAîÀ®*1À‘!àÀh«SÀ0­¿ñ{Y¿ƒL ¾Cè? Í*?¶ÿg@ Öæ@=>z@j]@мb@žwš@°'+@ÀwÑ@Î@ÙmÓ@á30@äÛ¸@ã”Ë@Ýï4@ÔM@ȇM@º)š@©{D@—úê@…kÿ@c@:vk@ òø?Á Œ??|­½ œT¿Uþu¿ÕÛ0À Ô–ÀWh…À‡š,À£ØæÀÀ7ÀÝVœÀú—ÄÁ õ+ÁËÊÁ)°ÔÁ8²¾ÁG¶‘ÁV¿üÁd™ßÁpú’Á}›:Á‹+Á„Š£Á|wjÁp@ÎÁb”ßÁSŽÆÁD”,Á5£XÁ&²æÁßõÁ IuÀõŠ™ÀØ‚HÀ»•eÀŸ^kÀƒyÎÀOãíÀ§õ¿É9¿BÀÒ=õ ?M=?Çg¥@r±@ýÀ þ´ÀBJ¥Àx*'À—“À²p+ÀΖCÀêá“Á­YÁ2Á ͺÁ/n¼Á>/™ÁMÒÁ\`Ák3Áy–øÁ‚÷:ÁPtÁ‰ æÁ‚ñˆÁw2ÁhÌÁY#÷ÁJBRÁ;†Á,ï ÁsTÁñXÁtÀækÀÊ¢À¯‰À“›ôÀq³À=&¤À ”¿®1-¿%>ùç?YÄ…?ÄÙj@ £@0>é@SŽ\@sÙä@ˆ3Ó@”LŒ@B`@£|Ï@¦_^@¥#Ø@ ‹å@˜{m@ŽL@‚£N@iï@Fð @$%}?ÿ«X?²Óç?BÖ;=í‘¿’¿¤A‘ÀƒûÀ34ÁÀfŽÙÀ·À§ÇÀ¶vÀݨíÀùUüÁ Ö:ÁèÁ'F4Á5ÆàÁDWÆÁRðFÁa„ÁptZÁnÁ‡: Á“áNÁC"Á…ʶÁ|¬5Ámà4Á_-‹ÁP”™ÁBçÁ3œOÁ% àÁÒdÁá¶Àö?ÀÚºâÀ¿Œ;À¥[ÀŠì†ÀbËëÀ0¨­¿ÿ²½¿ œá¿A¼> '?JËã?¯ƒ·?ø5D@ ‡@;î@V¡F@m>@}»£@„@‡Ü@…Åþ@aL@t½A@a9@L²Ø@1*@ú?ßÓ”?˜ò'?Î;ÐÖG¿"⿤Î:¿ýp“À+‰JÀ[×íÀ†!þÀŸÍÀ¹YºÀÓ{Àîh³Á°ÁEÎÁ >¨Á.lvÁ<$ÁJßÁY[ÈÁgì©Áv}ŠÁ‚ùÁ‰ôwÁ—Œ¿Á!ÁˆÃÁj†Át:ÅÁe¼{ÁW@ãÁHÏ#Á:XÁ,yðÁ²üÁðºÁ3¥Àë§cÀÑblÀ·^FÀžåÀ…bÀY À*’`¿û#þ¿¢ª¿Qä¼ë?$J?‹ÙÉ?ÌŠ>@øñ@l@0ðÓ@@¹K@K*•@Or @LÌ´@Dmg@84w@%JŸ@=œ?ðHª?¸1ó?k¦+>Â8B¾7B¿E¥”¿²›ÀØÀ,:ÃÀX‹ïÀ‚ {Àšƒ&À²º>À̳Àå¥ÈÀÿuÁÁ Á“þÁ( }Á5Õ,ÁCßQÁR_Á`3aÁnwñÁ|ð±Á…ÀÈÁ yÁš–£Á“>LÁ‹ð©Á„°ˆÁzéŸÁl‚¨Á^4§ÁP!PÁBNQÁ4†„Á&ÁñÁ'‹Á ö:Àý§~ÀãíÖÀÊ¡ÕÀ±äÌÀ™Õ½À‚k(ÀW“À+"£À±õù¿RS¡¾Œ >tãÛ?7õ?”Òm?Á9?è®ë@6@ R$@’@ Û—@ôL?õ±?Òô ?©èZ?zö|? Ž]=´t}¾ß¿Ì¿}nç¿ÈÃÀ jÀ2À[*Àƒ4À™/ËÀ¯›?ÀÇUÀßR“Àø‡QÁ ÚÁÞÔÁ"øÒÁ0{[Á>ÁK™­ÁYl»Ág*Áu 0ÁäÑÁ‰jÁCÁÄÁ–ƒ~ÁLAÁˆêÁ€÷mÁsÑÈÁeï­ÁX%ÈÁJ\;Á<£.Á/DlÁ"¯Áþ ÁFÀ÷AdÀÞÊ¡ÀÆÛkÀ¯ À˜ÊÀ‚‡kÀZÉÀ1ûžÀ òã¿Ó¿ Ê¿ÔG¾.±>s·l?0©?\Ÿ¶?‰}à?šÙ?¡V°?z7?ŽñÚ?qíj?3·->Çñ×=[&Ǿ«g¿Fæ¿¡¿{¿ç5wÀ®À<›šÀbæãÀ…ñ£Àšq>À¯ñÀÆÝÀÜ¡eÀóƉÁõyÁ„xÁP©Á,ÖÁ9 kÁFeöÁSï¡Áa|UÁo Á}ÁÁ…‘ÁŒ »Á“²¸Á¡%ÁÁ™ù±Á’ÖÁ‹ÃgÁ„É|Á{Ç>ÁmýXÁ`6ÂÁR«êÁEqüÁ8F3Á+EÁœÁÁæ}ÀóáÀܯÀÅÑùÀ¯ƒ ÀšS|À…ìLÀePÞÀA²SÀ*y¿üñf¿ÀW¿‡È‚¿/öî¾²½Ã¨ =Ìcë>hn>‰ðì>yê> ™ ¼ì듾…Þ›¿ jë¿_‘£¿ž’`¿Õ‰À)À'àIÀK=}ÀoQ·ÀŠ—ªÀžñÀ²£LÀÇ#*ÀÜÚÚÀóŽÁÔ†ÁJÁA¬Á(ÅÒÁ5‘xÁB]€ÁO3Á\`(ÁiÜzÁwcëÁ‚yÁ‰WŠÁSËÁ—bmÁ¤µŽÁŸSÁ–žzÁ´ZÁˆÏgÁëŒÁv.öÁhÑÊÁ[¢)ÁNx>ÁA Á4úÁ(r€ÁiTÁvÁèˆÀòèÀÜÀÇE(À²Þ~Àž÷ÀŒë“Àw%nÀU¯À6/BÀѵ¿ûp ¿Îí|¿¦kŒ¿†ÄÜ¿`åØ¿A{¿8¼s¿>ûÉ¿Xoþ¿€^¿œÊ俽Ó8¿æ¾ýÀ †ŠÀ#b8À?œ›À^ˆÀm§À‘hçÀ£ôÀÀ¶á†ÀÊÕZÀßTõÀóãÁâVÁÁXZÁ&ºðÁ2—Á? ~ÁKÒ6ÁXž)Áej–Árp˜ÁÍÁ†©Ál’Á”94Á›!ÔÁ¨uóÁ¡…Áš "Á“¼jÁŒá˜Á†!–ÁÁqÔ;Ád¾kÁXñÁK]™Á>ïÁ2ì,Á&ÿ>Áy„ÁÁ¿üÀô8 ÀßаÀ˨6À¸þžÀ§šÒÀ–j„À†XÀnDÀR8¿À8ذÀ#=~À¢ZÀ±K¿í¬¿ß¿ÛP÷¿ÞvZ¿êRë¿ý?À ÀÈBÀ/mUÀE‘ À]&°Àx’’ÀŠËhÀšvïÀ«€6À½{&ÀÐUÖÀã=À÷‡ÁOÁYƒÁXŒÁ&–ïÁ1Ü.Á=2;ÁHýUÁUT²ÁbàÁnÞÓÁ{ªÆÁ„HûÁŠäÒÁ‘¡ÊÁ˜dÁÁŸ(›Á¬pÜÁ¥IÁž°NÁ—äNÁ‘5aÁŠœEÁ„ÞÁ{ÄÁni>ÁaÇÁUrCÁIoÁ=ŠÚÁ2 €Á&“ýÁ@‹Á•ÌÁaqÀø‹²Àå)çÀÓ­;ÀÂgcÀ±§·À¢4¹À“qÎÀ…ópÀt9¦À_†wÀNíÀ>÷iÀ5r¡À/½À-/EÀ.·hÀ46ìÀ=Z&ÀI¸¯ÀXó Àk|6À€S~À‹óñÀ˜ÌÀ¦ÀµÜÀÅÛ!À×KgÀéùZÀüÄbÁîüÁ Á\/Á&ÅÀÁ1Ö<Á=ÃÁH`ÁS®÷Á_oRÁk¯àÁxY\Á‚úÁˆõ¸Á`+Á•ìÁœšsÁ£] Á°€ÇÁ©­KÁ¢ðWÁœNÁ•¶Á&îÁˆºáÁ‚hÁx9éÁkõúÁ_ñÚÁTÁH›|Á=$ùÁ1ÇÑÁ'ÃÁÚŠÁ¾òÁÓ<Àÿ¿¤ÀîdÞÀÝD’ÀÍu¥À¾ùÀ°FŸÀ¢úaÀ˜ÀŽ-¸À…½ÀÀ}ÊÀtƒÀnŽ•Àl¶Àn3¢ÀsDbÀ|<ÓÀƒ±CÀ‹GŠÀ“è Àž& À©y#Àµ¨=ÀÃXËÀÑc(Àá&>ÀñreÁ³ëÁ 6ÁšÁUõÁ(„—Á2º Á=6çÁHYWÁSž—Á^ãàÁj2jÁuéÛÁ ”Á‡UÁ´ƒÁ”ôÁš|vÁ úQÁ§™“Á´³@Á®ÈÁ§h=Á ÑÁšOÁ“íõÁ›qÁ‡ZÁ<ÙÁvt±Áj¦€Á_,xÁSµõÁHTÎÁ=ŠÍÁ3S£Á)8 Á-@ÁðmÁ 7rÁžÀø¶‘ÀéQñÀÚ™ÎÀͯÀÀŠÀ¶4ÞÀ¬±pÀ¤uÝÀž\BÀ™rOÀ— ÙÀ–zÀ–×ïÀ™(ìÀ¿À¢¥¿Àª½À²mÀ¼ÀÇjÀÒì‹ÀßæîÀíS Àü|ÙÁ?äÁ›=ÁìŒÁ!mÑÁ*ÚÁ4ÄÏÁ>îEÁI`ÁS±¡Á^Ý2Áj#mÁujçÁ€]}Á†5eÁŒCÓÁ’‚Á˜ÝrÁŸÀð:¿Àü½«Á Á ÿDÁêÆÁï Á$«Á.2øÁ7¥ ÁA.ÁK69ÁU[ƒÁ_‹ÒÁj3¨Áud Á€UöÁ…ùÜÁ‹¢¯Á‘xRÁ—¥Á³äÁ¤ áÁªeÍÁ°Ä„Á½FÁ·UÁ°©¶ÁªTÈÁ¤mÁÛ&Á—À“Á‘½ÍÁ‹â×Á†'8Á€lÁuyžÁj”gÁ`CÁV!ÎÁL<ÁBVÁ9U¦Á0›‚Á( ÊÁónÁE6ÁëÝÁ &ÚÁ ³Àü«¬ÀòØ ÀêýÀâ‰?ÀÝKæÀØ‹;ÀÖµ³ÀÕ¶'ÀÖdÀØV_ÀÜrlÀáOyÀçãzÀï{–Àøp…ÁOàÁ×ÜÁ ¸Á€ëÁ øÁ!•¨Á)™Á1ÈÁ:ÝqÁDydÁMßyÁWËÁa¨QÁkËLÁv¤Á€]ˆÁ…özÁ‹š_Á‘>EÁ–çåÁœ¼wÁ¢¾OÁ¨éÒÁ¯9%Áµ’@ÁÂ@›Á»ÚýÁµˆ1Á¯C¸Á©:Á£qÁÁ—+ Á‘oËÁ‹¶ÉÁ†ÏÁ€DÁv»-Ál•¯Ábt ÁX§¹ÁO|jÁF¢„Á> àÁ5ªÁ-ïOÁ&KéÁ\ÉÁ–$ÁŒ¥Á eÁ¡ùÁm…Áæ¾ÀüøÀø?Àö•¦Àõ’áÀö:‰Àø3ÀûëõÁ\ÙÁvªÁÁ {Á:ØÁ¹sÁ¢ßÁ!ëQÁ(n‡Á/^`Á7IÁ?U$ÁGÍ™ÁQ"×ÁZ±@Ád)ÜÁmøwÁxiÁvÁ†@=Á‹£EÁ‘;ÈÁ–ÞÈÁœ‚®Á¢-Á¨ÅÁ­þÌÁ´# Áºj»ÁÇÁÀ¼ÕÁºwÁ´]NÁ®DPÁ¨F Á¢suÁœ¹AÁ—ÞÁ‘SÁ‹×üÁ†œWÁ„ÉÁxèQÁoÔÁe¯ÍÁ\»ÁT øÁK‘ÁC™œÁ;ì‰Á4•ôÁ-Í¿Á',~Á!’]Á‹<ÁæÁçOÁ—(ÁÅÁ Á :ÌÁ ¹ƒÁ ²Á îÆÁ ¹KÁÔÁþrÁ’ÑÁÀAÁI¿Á$¨Á*H¥Á0‹*Á6ïDÁ=}ÓÁDû9ÁM †ÁU(FÁ]òPÁgiCÁpéÁz~HÁ‚5Á‡FAÁŒW‚Á‘ÛÁ–ê˜Áœ‚hÁ¢#4Á§ÇÁ­rYÁ³E3Á¹?åÁ¿^´ÁËôkÁÅÁ?Á¿žpÁ¹†>Á³ŒiÁ­¼IÁ¨¡Á¢MÁœŸcÁ— ýÁ‘Ý.ÁŒ¿iÁ‡®Á‚±BÁ{ì¸Árâ8Áj cÁaŽÒÁYMÁQ–ÖÁIÿAÁCÁÁ#ošÁ Q'ÁÙ®Áç´Á*ÆÁªòÁöÁ×§Á|ìÁÉlÁ"šÁ&¾Á* TÁ.ƒ?Á3›ÆÁ9¤Á?-ƒÁExèÁKäRÁRÞðÁZ¿FÁbÓMÁk!ÅÁt-Á}¯¯Áƒ•DÁˆjæÁn Á’MÁ—‘«ÁœÅ–Á¢3+Á§ÊÁ­hrÁ³ €Á¸·—Á¾‰»ÁÄzÁ×NlÁÐësÁÊ”_ÁÄSSÁ¾&—Á¸­Á²ñÁ¬9UÁ¦~çÁ ðˆÁ›rŠÁ–ÁÉÁ‹ÔDÁ‡3Á‚ebÁ{­TÁs73Ájí®Ác ¿Á\ ³ÁUçÂÁP'ÁJ÷¡ÁF?ÁBt¹Á?5¬Á<’’Á:P Á8ˆ¥Á7^ÂÁ6”JÁ6SUÁ5Ù{Á5“dÁ5P;Á5X¸Á6dæÁ7èÁ: |Á;Ç)Á>©"ÁB}—ÁFgÁK&rÁQÁW²‡Á^s^ÁeÈÜÁmc§ÁušßÁ~8ÁƒÙÙÁˆ¼œÁçÖÁ“CñÁ˜ÎÁžcIÁ¤ZÁ©ñ1Á¯ûÁ¶+„Á¼mÁ°WÁÉ ÁÒš:ÁÌ ÁÅ·Á¿[WÁ¹‹Á²ã–Á¬É.Á¦ÊÁ ê¼Á›.ÃÁ•¡—Á#žÁеœÁ…‡2Á€¢ÎÁwÛÁnv Áe’ÕÁ]<…ÁUŒÁMŒiÁG[ÁA Á;´}Á6ê[Á2ÎÁ/†åÁ,ŸÁ*k"Á(žTÁ'iøÁ&–vÁ&S¢Á%ÜuÁ%› Á%TåÁ%[ªÁ&v€Á( 7Á*"oÁ+ôÁ/ÊÁ2øÁÁ7¾Á<#¾ÁBs~ÁI/ÔÁP!ÐÁW¸–Á_–—ÁhG¦Áq`'ÁzÿÁ‚Ÿ2Á‡÷Á2Á“ Á˜Ã˜Áž¦GÁ¤¶žÁªî3Á±0zÁ·wÁ½Ù¢ÁÄZuÁÎmÁÇxËÁÀòÍÁº„ÛÁ´$Á­Ô˜Á§ øÁ¡„)Á›€Á•œcÁÞ¥ÁŠR®Á„Ô¼Á~ÕóÁt"Ájë‡Áa‚#ÁX0ÌÁO‘CÁGC‘Á?H0Á8Q$Á2<ÝÁ,~©Á'¥>Á#7“ÁÝ‚ÁùšÁ‰ÈÁ¸NÁuuÁ™ ÁSîÁßrÁ¢áÁZ„Á_<Á‰ Á5³Á8bÁ*$Á”3Á#sôÁ'·>Á-NdÁ3ðšÁ:®¶ÁB dÁI´íÁRqÁ[ÓÁdŒ‘Án°ÁyUÆÁ‚0Á‡ÄòÁuÁ“\0Á™s÷ÁŸ±TÁ¥ô|Á¬@æÁ²®JÁ¹; Á¿àjÁÉÐÁà 6Á¼\ñÁµËÁ¯UÁ¨î‘Á¢—¤Áœ^ÒÁ–?DÁ6ïÁŠNZÁ„Ž‘Á~žÁs ÊÁhBãÁ^ÛÁT’iÁK)ŒÁB²Á9”ùÁ1OÈÁ)ÆCÁ#iYÁp“Á`êÁ·—Á4,Á .xÁ ¯yÁÓ ÁTÁœ(ÁT:ÁâsÁª¢ÁaJÁcªÁ"Áa8Á NUÁ ltÁÈÁï4Á“/Á²iÁ%mÀÁ,\ðÁ4Á<}ÁDܾÁN$ÁX%oÁb¾ûÁmÄ0ÁxìÁ‚&ãÁˆ"ÁŽ3{Á”uÁš¹$Á¡VÁ§‡éÁ®!ðÁ´ÊAÁ»r¼ÁÅÁèÁ¾×*Á¸èÁ±GºÁª¨˜Á¤(RÁ»rÁ—]’Á‘@ÁŠú‰Á„ïÁ~mÁr} ÁgiùÁ\n9ÁQ²ÀÁGªëÁ>9¯Á4Ñ™Á+íðÁ#šYÁ„¹Á™“Á’Á ¡ÁVÁŠçÀúÉeÀõ¼!ÀñÞÀïtÀí@Àì© ÀëÊôÀëdÇÀêЗÀêÒ˜Àíd[ÀñjÀôÈÀùHÁ‹ƒÁw<Á  íÁ/aÁë$ÁL•Á&ŸÁ.¨ÞÁ7ÉnÁA ÁL*^ÁW(ÁbNÊÁm².Áy–ÈÁ‚õ¶Á‰9_ÁÁ•à>ÁœgÁ£ Á©´4Á°^ÔÁ·åÁÁÜqÁºà Á³é Á­Á¦:yÁŸŒÁ˜ÿ6Á’‹+ÁŒ&žÁ…ÜhÁlÁsQvÁgg*Á[ÝÁPÌuÁEÐÑÁ;&—Á1IÜÁ'á€Á†UÁïŸÁ ¢*ÁˆÀÿ|ÊÀóÍJÀê©ÀáÃvÀÛF#ÀÖEÀÒÀÏ5ÎÀÍJÀÌ©¦ÀËÑÀËtJÀÊÞ›ÀÊákÀÍŽxÀÑtcÀÔôûÀÚUóÀâäÀêG„ÀõåGÁ¬\Á™$ÁTÄÁ…áÁ!‚Á+!ÁÁ5˜ªÁ@ŒýÁK²'ÁW¥Ác µÁoslÁ{ý5Á„H§ÁŠ·³Á‘N’Á—öNÁžžHÁ¥RðÁ¬#ÉÁ³ ýÁ¾ ýÁ¶þˆÁ°;Á©Á¢Á›6ãÁ”xŠÁÛ£Á‡^oÁ€òJÁu:ÁhãyÁ\ÆÑÁPÎAÁE=DÁ:/ Á/3¡Á$  Áñ‡ÁŠÁW4ÀÿåÀÀáÖÀÕÏXÀË”®À„CÀ»é—À¶ƒÀ²L…À¯RŽÀ­W¥À¬ª>À«×GÀ«ƒÌÀªìŸÀªõÉÀ­¸”À±Í\Àµ,À»P{ÀÃ_ÀÌ žÀØßÀæRºÀõ)ƒÁGÁ ELÁ­îÁ äÁ)óEÁ5nÁ@~‰ÁLƒ,ÁXýHÁe‰êÁr. Á,SÁ†9KÁŒàÄÁ“‹nÁšP÷Á¡3TÁ¨$ëÁ¯äÁº:Á³NŸÁ¬-€Á¥ ÎÁž%Á—-Á?,Á‰nGÁ‚¿¾ÁxljÁk‚ŒÁ^ÂÁR[ŸÁF<-Á:70Á.¨Á#’ Á—Á!ÊÁšÀögðÀäÀÓðÀÄw\À¸'À­ ‹À£Ž•Àœ˜bÀ–æŒÀ’„‡ÀsLÀk ÀŒª×À‹Ý§À‹“NÀŠú¢À‹nÀëÕÀ’&VÀ•yÀœMÀ¤ÎÀ®nöÀ»ØèÀɯ%ÀÙnÀê,¸Àü”4ÁÁ[‘Á|Á)çnÁ6ÜÁB‰¦ÁO˜Á[×VÁhû&ÁvH¨ÁËzÁˆ‚Á[0Á–KkÁ=dÁ¤/›Á«*HÁ¶ïÁ¯Ð×Á¨žOÁ¡mëÁšM³Á“DxÁŒKpÁ…V)Á|àÎÁo[ZÁb'£ÁU)6ÁHSDÁ;Ô¶Á/±‰Á#¢»ÁþYÁ õWÁûÍÀï`øÀ܇®ÀÉÅ/À¸ˆÀ¨ RÀš€ÀŽŸ+À„õ·Àz`Àn–Àe{GÀ_6¯À[×ÀYVàÀWÈ­ÀWA~ÀVLÀVfHÀ\YöÀd¸ÀkܳÀz™“À…0]À‘fKÀžÒ¼À­ÐÀ¾ .ÀÐ3ÀãôÌÀù÷ÁãÁS>Á‰hÁ,‚Á8®>ÁE‘vÁRÓÁ`†Ámt¯Á{ Á„qëÁ‹cåÁ’UÞÁ™PÁ 8ÕÁ§(²Á³e±Á¬8Á¥¤Áï©Á–½ÒÁéÁˆnÜÁj ÁtçÖÁgçÁYPÝÁKò†Á>Û¢Á1îãÁ%OVÁ&åÁ "Á_Àì²sÀÖŵÀ§nÀ¯ßÿÀo}ÀŒ¡gÀyäÝÀa¤ÀLÑQÀ;ôÀ/{uÀ%ò:ÀŒ£ÀZŽÀX À×uÀRÚÀ-SÀ²°ÀÜÀ%ßÀ-sªÀ<¦ÀN2«ÀhÃÀ‚7|À’~£À£Ÿ_À·7ÀÌo)Àâœ|Àù‡ Á †Á®mÁ"PƒÁ/b’Á<¬@ÁI÷tÁWlaÁe2—ÁsÊÁ€|^Á‡rzÁŽ_ÔÁ•K¾ÁœKMÁ£ZÁ¯íìÁ¨»¥Á¡‡;ÁšZÎÁ“2´ÁŒßÁ„ÝïÁ{]ÃÁm"ÖÁ_#ÁQ?BÁCh´Á5Ö€Á(žzÁ•ËÁÐÙÁœ@Àí /ÀÕ‚ÊÀ¿|>À©œÀ–qÀƒAÁÀbÔÀAZ£À&T+À¿«¿úÃÌ¿àúv¿Ìùÿ¿¿¯ ¿·FŽ¿²³(¿¯Ñ=¿®Èm¿¬’¶¿® Ò¿º¾¿ÊÏW¿ß¤o¿ý¤ÜÀžÀ.»RÀMv°Àné)ÀŠ9JÀŸc†Àµ|ÈÀÌv½Àå`¹Àþ–&Á IÁ@Á&‡jÁ3Û™ÁA†ñÁOaãÁ]E½Ák+§Áy ¦ÁƒoÒÁŠl‚Á‘wóÁ˜ÁŸžðÁ¬†¼Á¥E0ÁžÁ–Ý*Á¨ØÁˆ}œÁU`Át]MÁeýÚÁW¢§ÁIl:Á;yÓÁ-¡ÁߘÁy:ÁMžÀð¾OÀØ#9À¿÷æÀ¨IKÀ’IíÀyÂÀRËÀ-c¡À ÊS¿ÖÔ¿¦½¿X­¿H[¯¿îþ¿µ0¾ßÂ¾Êæ5¾¿ÏÕ¾»¬”¾³+¾ºÙ¾ïv¿ýÝ¿I"8¿‚—â¿´jm¿ë½|À®µÀ;­êÀe\ÀˆráÀŸ‚À¸¥˜ÀÑèÏÀëÂjÁ![ÁebÁåÁ+²ÛÁ9’½ÁGv°ÁU[¤Ác*ÒÁquÁ,@Á†­kÁÃ÷Á”Ó6Á›õ Á©]iÁ¡þªÁšªtÁ“gºÁŒ3Á„þ¯Á{•Ám@ÔÁ^ð\ÁPž‘ÁBB“Á3ì'Á%¼ªÁÛeÁ xÀøñEÀÞAÀÄÀ«åÀ’ã-Àv*øÀJAqÀ1׿óZ‚¿©c0¿K¾½wt½C›ˆ>?1Ó>À$Ù>ú˜"?¾?ø‡?Ò¥?!äE?%úZ?!B–?«Ø>ÏEå>4¼½êü>¿Œý¿€iÄ¿ÆkÌÀ ÒpÀ7=àÀe’þÀŒàÀ¥kxÀ¿œeÀÚÍÀô°ÝÁ ûÁà‡Á#ðÁ1©£Á?x¾ÁM]çÁ[i{Ái–­ÁwÅÐÁ‚ø ÁŠþÁ‘KãÁ˜|HÁ¦NjÁžëêÁ—Š‚Á(ŠÁˆÐ ÁŠhÁt©EÁf@gÁWØØÁI†pÁ;5øÁ,âÁ‹àÁ=$ÁðÀ襈ÀÍIŸÀ²EsÀ—‘TÀ|òÀK¶>Àâ‹¿àZ—¿‹÷™¿;”=V+? jª?e¥z?“úL?®N?½¦©?Æ®Ÿ?ËvC?ÏÆš?ÐÏj?ÒÅ?ÏøÚ?Ár?¯’ñ?‘•‹?Fi¯>®Á›¾+ßÑ¿L³°¿¼7îÀ ÛºÀ?JÀrb‹À“x?À­íIÀÈíTÀälTÁ±Á ÷¡ÁƽÁ)¡%Á7¨ÁEÒ‚ÁT¥Áb9äÁp‡5Á~çkÁ†£ÒÁÙúÁ•ÆÁ£_xÁ›å÷Á”yÁÁ…¶»Á|¦ÿÁmí¸Á_]<ÁPìOÁBƒpÁ4Á%Ì Á{”Á +šÀõ»…ÀÙ9ÈÀ½%$À¡ÉÀ†ŠÎÀW6àÀ"gø¿äˆ¿„r¨¾ºK™>™6Ö?a·k?¶Ä'?ê%?ý¿º@ç«@vü@"ÿ@%8"@'ŽÅ@(VY@)Fˆ@,§@ 2*@ 1-@²“?Ó€Ç?•Ò¸?¢D½´„ ¿QxÙ¿Í£ÔÀò«ÀN¨3ÀÝ…À:ºÀ¸ÁÓÀÔƒ²Àð)vÁæéÁé!Á"XÁ0={Á>¯ÁLÖÙÁ[7Ái—FÁx¦ÁƒD¶ÁŠŽÁ‘ÝñÁ ®øÁ™#ªÁ‘™ ÁŠüÁ‚¤BÁv€¾ÁgÃËÁXýTÁJ<ÏÁ;¦æÁ-0>ÁÆzÁb Á¨ÀçƒýÀÊý‚À®…~À’+ÙÀl§—À5Ý¿ÿƒ+¿•(á¾Î»w>­O*?‚iÕ?× >@5b@‘[@-Æ@A@-“b@Di¦@ca²@fnò@hDý@M(Ç@6 @'¸Ê@"èì@%Ö—@P\?øyÜ?¥‘?6¾bŠ¿ƒ¿¿ìËÖÀ,*qÀc>À]À¨ÅsÀÄcªÀàW%Àü”[Á yQÁÁSÁ)&~Á7†ãÁEèTÁT^*ÁbîâÁq6Á€=Á‡€RÁŽó`Áž&Á–{ñÁŽðVÁ‡cŸÁ°¡ÁpýÁa¥OÁRÏ>ÁD!Á5SªÁ&ŽCÁðÁ xwÀöÀÙOxÀ¼®ˆÀ !-Àƒ©XÀNüvÀJÆ¿¾Ì¿!1,>¶“¸¾ñ亿©ŠxÀ « ÀBÂàÀyÿMÀ˜Ü Àµ ÀÑjMÀîÁwZÁØÎÁ":íÁ0ÀÿÁ?cEÁNÑÁ\ÓÁk£üÁz˜EÁ„ÕuÁŒc6Á›»Á”ðÁŒg«Á„È8Ázh¹ÁkI—Á\0ŒÁMðÁ> Á/"®Á eÑÁ©ÿÁãˆÀètØÀË„,À®™À‘Ú°ÀjНÀ1‰’¿ñ–&¿ß¾p?:FÍ?ÄÕw@@E>¿@hUè@_Ó@@Z1@YòL@dMÛ@x`@‰YÔ@™×Ý@’0%@„?Á@tuQ@j¤@l±@yâˆ@€³-@TDY@"Å$?Þ$?f='þ9¿Oëg¿ÖnŽÀ"ÁØÀ[dÀ‰áøÀ¦ŽÐÀÃ|fÀàUyÀý"›Á /BÁðËÁ*¶hÁ9}DÁHUvÁWV’ÁfyÁu©æÁ‚cñÁ‰ô‹Á™„œÁ‘ÎEÁŠ[Á‚s ÁurÁfÁ ~ÕÀùbñÀÛþâÀ¾s»À¡èÀ„jÀNNÓÀÓ"¿·£Ï¿ C*>­€?šAL@7>@:[X@m(@Ž{H@‰Y#@„Ø@ƒ@†~­@Žõ@›€£@ªlê@¤ø×@˜ª@ùü@Œ5z@ž{@”†@–¹ @{³W@G5æ@êû?µ6?Bü¾ž\ó¿—íuÀ³GÀ>..ÀxeÀ˜ùWÀµàJÀÓhJÀñŸÁaÁ'êÁ% áÁ4ÁCLßÁR}ÄÁa«ÆÁpÖIÁ€ ¬Á‡¶jÁ—¡ÁÓBÁˆ 8Á€GÁq,Áa¯1ÁRV ÁBýjÁ3¨ìÁ$kÜÁ?TÁqÀîQÀÏÙWÀ±ý+À”–2Àn@ÌÀ3<ï¿òª£¿}Õ?½ÃG–?K›€?×Ïú@$ s@[z†@ˆ¯Ê@¢°(@¤mh@ž.Î@œV¹@žq"@¥šB@°l¡@¾šË@»!f@¯ë“@¨Ä`@¥`B@§BV@­ô1@ªè@šþ@h¡Y@2XÅ?ö8°?†"~>%Ö"¿<úï¿ÒGþÀ# À]žçÀŒ‰VÀªA–ÀÇêžÀå•4ÁÈ@ÁóíÁ (Á/\ÖÁ>’ÁMÏÈÁ](Ál_Á{ùƒÁ…±WÁ•ØúÁŽ.Á†IJÁ|ôôÁmWÁ]¹,ÁN!ÊÁ>™…Á/$`ÁÆÁmbÁÀã²nÀÅWúÀ§ÊÀˆØîÀUd³À[¿¿%Ì¿>¬!?Ÿœ@Ö@AŸ§@z Ä@™;[@´`ì@¿}÷@¹ƒÍ@·è@¸V@¾}¹@Èo@ÕH@ÓUÁ@É} @Ã2¼@À†G@ÂUm@È>…@»p-@ ®@„ò/@Rx@n ?¿an?¾£¿ŸÁüÀ TÃÀFÇÀ •Àžó­À½dÜÀÛ×!ÀúAµÁ V%ÁNÁ*üÁ:] ÁIÆÁY1ZÁh¬vÁx/ŽÁƒÜÁ”<ÉÁŒ_jÁ„…\Áy_#Ái½ÌÁZ(éÁJ›!Á; ÏÁ+kêÁÎÁ 1ÀùI¡ÀÚl1À»º´À qÀ}XÀ@epÀµî¿Ž®(¾8šM?<ùç?ÔLÈ@$]µ@^y5@‹åµ@¨:9@ĬÆ@Û¯»@Õ·T@ÓA¿@ÔBÖ@Ù ^@áÐ;@í·X@íd<@ä®@ß5@ܵö@Þ’e@ãû @ÌV2@°~Ù@”/@n )@4°Î?ó'}?x3î=Ú#¿d*|¿ém‡À1¹–Àn¼üÀ•ÉúÀ´7~ÀÒçrÀñ§;Á3‚Á” Á'Á6ŠÁFÁU¦.Áe6ñÁtÇ´Á‚,<Á’Ê¢ÁŠìÜÁƒÁvbeÁf¦ƒÁVê¢ÁG.ÁÁ7w¸Á'ÌÏÁ1ÇÁ£®Àò+ÌÀÓŠÀ³ÅÂÀ”‰úÀjÀsÀ-5H¿ß¥…¿K?M>QI?3ù@³@>Ù@x×ø@™  @¶¹@Ó`k@ï²Â@òÅ4@ðd@ðûf@ôê[@ü¾”AÔAS–Au\@ûÍF@ùÇ«@ûµ¿@÷ùö@Û¦Ï@¾ÇÎ@¡n@ƒÅ¯@Küd@ZÑ?¨ÊÀ>º´k¿³f¿ÅHýÀ­À]-ÀXtÀ¬,ìÀË^Àéç¦ÁÁÁ#¡ Á32ÁBÃÁRU´ÁaíÁqˆÄÁ€—JÁ‘`£Á‰ÁžxÁs~ÁcÁîÁTdÁDJÙÁ4NÁ$ÓvÁ•Á[³Àë?¥ÀËÊFÀ¬xÀXvÀ\yÌÀB¬¿¿½Ý¿x>èVÀ?´Ú¼@z±@T/™@ˆr@@¦p@ÃÔ¬@áš@þ5A>!AYA$ÉAׯA [=A^“AVAÚ‡A œA ¾ÁA ©ßA 9@èj¾@ÊÁ~@¬÷@ŽîA@`»;@#˜­?Ìì??#bY¾§Q¿¥X´À[>ÀN !À…ÜÙÀ¤éßÀÄ ÓÀã>sÁ>œÁß<Á ÜÁ0 |Á?îÁOsÁ_.£Ánò¶Á~»„ÁæÁˆ6‹Á€P-ÁpÓ Áa|ÁQCÁA~ßÁ1º£Á!öˆÁ4éÁw„ÀåwòÀÆÐÀ¦‰À‡LÀO3ÀCŽ¿¢¨¾–˜ý?-?Ó6@@'Õ@fE7@’V¿@°â›@Ï=@í—ƒAž®AIµAè7AõA.A»PAYvA ·ÒAŽàAоAÔAÀðAå@ó©&@ÕÒ@¶ˆ‹@—Þ@r*¸@4gÿ?íJŒ?cŠ2½¡¢Ø¿†–À½œÀ@8À~ÊØÀž®À½÷µÀÝ@ÙÀü”6Á©ÁÆ%Á-‘"Á=_¿ÁM1^Á]ÁlÖÅÁ|©xÁŽÓ/Á†ïîÁ~ðÁnXdÁ^‹ªÁN¾ïÁ>ò4Á/%yÁX¾ÁŒ Àÿ‰êÀàqÀÀxøÀ ð€ÀhÀC¿À´…¿‹‹Ê½ÚÌ ?`d?îQ@5ø-@tç±@™ æ@¸¼v@ר@öýªA ïA1(A% A%úA&­A)f A-­²A/abA,~*A*¨ÁA*dAê¸A š1@üx @Ý»ß@¾Ý@Ÿá¦@€Â«@CG_@Ó?Œº=üпZ`¿êTÙÀ4^Àsd6À™_~À¹ âÀغEÀøeèÁ §ÁØgÁ+¯šÁ;ŒÐÁKn¡Á[SÕÁk9¨Á{{Á‹õÁ„ßôÁ{¿ÁkéÁ\šÁL?ÀÁB*A;šQA9ìšA0ŠêA!+nAŸ,A@äýš@Å¿¯@¦„Ø@‡J@O®ñ@WÏ?¡õ2>Œë¿6ÿM¿Ú:À,zõÀl»À•ÔæÀµ¥ïÀÕv÷ÀõHÁ Œ„Ár¼Á*XÁ:>ŽÁJ'oÁZKÁiü…Áyé¼Á‡òÁ ÁtºŸÁg˜åÁYÉŽÁI÷£Á:%·Á*OìÁx¶Á ¡Àõ”–ÀÕì À¶GÀ–¡åÀnDÀ.òc¿ß©¿BÚ„>gA3?›Mý@ Ùê@KîS@…¢@¥ q@ĘÎ@ä)@A݃A¦ØA!iÿA1$8A@àADãêAGY9AK ÁAMN*AJÙOACã+A4@\A$–2AåA@êvO@ÊÌg@« ú@‹4Ç@V¹+@Æ?®°Ä>½?í¿ !›¿Ïq–À'i/Àg”À“düÀ³=.ÀÓ`ÀòíñÁ feÁXýÁ)MÝÁ9DnÁI;¶ÁY2ÿÁi*HÁy!‘Á„šjÁ{4 ÁmtÁ_þžÁRÐzÁFûÁ7Ó¿Á(ûÁ0'Á^;ÀñŸÀÑm‹À±¿ À’µÀdÄ’À%g»¿ÌÉ¿Åô>ÄÅí?¯Åñ@-3@VQ‰@Š·µ@ªF¥@ÉÕ–@éfaA|wACÅA$ ÅA3ÔKAC4ASfkAV‹¬AYõ+A\|‡AVYAF/±A6@ºA&QÂAbÊAsÓ@í ¶@Í+Ç@­MØ@oé@[#ó@h?·Xl>ß‚½¿.¿Ç\À#4ÀbùIÀ‘j-À±XÏÀÑI Àñ:¶Á–IÁ8Á(ˆ&Á8ÁHzÁXròÁg´ÖÁuR]ÁŽ×ÁtþyÁfßÎÁYüÁKx¬Á>OÁ1™ñÁ%.dÁÊÁû:ÀìWÈÀ̹À­qÀ{ÅÀ[º4Àuª¿º3M¾íæ~?€?Áù¼@ Yµ@_¶‹@‰±@¯8@ÎßÀ@î„ÝAýAå]A&¬ÕA6tMAF;ÆAV>AeËUAiêAg(AW8=AGHfA7W¼A'fAtvA‚Ó@ï"a@Ï?@¯[Ö@x@_Û@.W?¾•¦>û:x¿ðÔ¿À¿rÀ C=À`&ÁÀ#À¯öåÀÏè§ÀïÕèÁáqÁ×íÁ'ÎjÁ7ÄçÁEÊ'ÁS*ØÁ`ãLÁnÖrÁ}gãÁnýcÁ`ÉÈÁRÔÁDþçÁ7kbÁ*:Á‰ÁfpÁŠ)ÀçvMÀÇØHÀ¨:CÀˆœœÀQþ6ÀÂØ¿§ ¾¢AL?+Ô·?Ôe @)oÜ@h´Ô@”^@³°¼@Ó_'@ó ’A ]ÿA55A) jA8ã AH¹‘AXŒAh^®Ax gAh´AX)AH7OA8CA(LˆAV A_@ðÒ$@Ðå+@°ø1@‘ 8@b<|@"b‰?Å,? ºŒ¾éZ€¿º †Àß6À\¹)ÀŽK À®9ÅÀÎ(}Àî5ÁöÁ÷jÁ$©†Á1§#Á?EÁL½¾ÁZ·ŠÁhôÁx—äÁiâ7Á[Z ÁM ÜÁ>þCÁ1DÁ#»>Á–tÁ _ÀüsTÀâ­JÀÃÈÀ£VFÀƒ²„ÀH0Àû*¿“¾(K\?RÝT?çå×@3-î@rhð@˜ÒH@¸pó@ØŸ@÷®JA ¦{AwÛA+LÎA;!ÈAJ÷'AZÎ[Aj¥‘AyíAi BAY–AIëA9)@A)2”A<"A GE@ò¦@Ò½‚@²Õ@’ì@fü@&6ù?ÌËí?SξÉà{¿²$ÀÞÀX¯ÀŒ@ À¬(ÀÌÀëù’Áê`Á5@ÁÁ+T:Á9ÃÁG" ÁUyèÁd =Áte'Áe„PÁVÀôÁH.GÁ9×½Á+É0Á³ÁÃÜÁÉýÀîÖÎÀØïÀ¾y×ÀžÌÜÀ~?ÃÀ>åÌ¿ÿ¬¿€iM¼]¡‚?yå?û—Í@=Ö@|5Å@µ@½S’@Üñ˜@üˆA„AåEA-´A=‚þAMRSA]!©AlñAzáAj  AZ_AJ$A:/ÝA*;œAG\A S@ô½µ@ÔÕ3@´ì²@•0@j7^@*f[?Õ*°?+U¾¨, ¿©pÌÀkJÀT/À‰èŠÀ©ÁüÀÉ›nÀå%åÀüç…Á $Á`EÁ&"cÁ4CWÁB®rÁQ=}Á_íFÁpÇÛÁaÙúÁSýÁD>6Á5˜&Á'1ŒÁQÁ q Àü¤ÏÀãátÀÌÔ.À·RYÀšß]Àv-ØÀ6œô¿î"¿]ì¸>[V? …@Þ¹@F8¯@‚ÉS@¢vN@Â#I@áÏ©A½–AŒqA Y­A0&éA?ôÀAOÃÂA_’ÅAoaA{ ¹AkxA[$²AK2yA;B9A+TsAgºA {@÷@×C@·i«@—9@om@/º¨?à‡?AS{¾u±#¿ú,À–TÀN"À†ÖìÀ¦œÌÀÃ/ÀÚ(Àòä`Á8Á?xÁ"T¼Á0˜ÏÁ?! ÁMßÁ\ÈSÁn.Á^çþÁOìÂÁA`Á2~EÁ$ÂÁ¥NÁ ÕÀô2ÃÀÚzäÀ¢5À­lKÀ—'kÀnÁYÀ/:ë¿ßU•¿@g>wo¿?ž¾@˜Â@N)¦@†ÝD@¦¥¶@Æn(@æ6™AÿMAÕÊA"¬HA2‚ÆABYCAR/ÁAb>AqØ­A|]ðAlqdA\…WAL™åA<¯7A,ÅAÜA ó¢@úg@ÚG¦@º˜@š»°@uëŽ@6_½?í§Ø?] k¾;c¿ŸÀ[XÀFç)Àƒ9wÀ¢ÿ²Àºt+ÀÒ`UÀë¯DÁ¤ÁïÁ*Á-¬ ÁëBÁ05âÁ!§)ÁeÁyŒÀïÎÀÕiôÀ½ÕÀ§ À“å!Àh&,À(‚¿Ñ¶ ¿$¯X>´É?¬e@á·@Uç@Šœ=@ª`&@Ê#Ü@éétAØ/A¼A$ IA4„‚ADhºATLóAd1,AteA}õ¥An MA^'ˆANDUA>aaA.~lA›xA¸„@ý«@Ýå7@¾N@žYf@})1@=°ß?ü1u?yœ«¼¥2’¿÷êÀ­…À@_À€RÀŸáÀ¶MžÀÍÌÀçW=Á&ÌÁÞÁ$ÇÁ+—±Á:KÁI2ÁX@ìÁj£ðÁ[cÁL?rÁ=@Á.ndÁ×Á‹~Á¤”Àì‹„ÀÒâíÀºiûÀ¤‡³À‘®ÀbI*À"Šø¿Å’m¿ þ©>æO?¹&Ü@\ú@\…@ÙÎ@­«Ú@Í}å@íOøA“IAA&jàA6V¬AFBxAV.CAfµAuóA¼ AoÙA_ö$AP!A@5hA0WdA s£A‡?AšÛ@á\í@Á„&@¡«^@Ò–@Cóœ@B ?‰ ù=›Ý¿kHÍ¿ôíÝÀ:…ÀyÜ÷ÀœÙ‰À´e·ÀÌ8éÀåãOÁWˆÁ0ŸÁc¥Á*æäÁ9¨ÁÁH›kÁW®Ája)Á[£ÁKò¸Á<íHÁ.…ÁtêÁ½Á-iÀë‚ÀÑûÀ¹qÀ£ÇÔÀŽñ_À]ý½À¼¿¼gu¾òuÎ?Y?ÂèV@!LÄ@a%]@~û@°kG@ÐW”@ð8ÏA ôAû€A'ìiA7ÞËAGÑ.AWÑAgµdAwžjA€Ä'Aq›ëAa¯‡AQÃ#AAÖ¿A1ê[A!þA—A2@äAö@ÄM‰@¤Y@„d¯@Hà„@÷ª?’ >_Z¿[ ’¿íW}À6”™Àv}sÀ›31À¶ŒsÀͼÀæ±jÁŒÁ6«ÁPÁ*¿:Á9pDÁHT¦ÁWaºÁjÙ±Á[¡ÔÁLˆƒÁ=”€Á.ÎüÁ DÓÁÁÁ ŽÀí @ÀÓYOÀ»œÞÀ¦£#ÀŽtÀ\ ÿÀ迸`$¾âP³?o•?ÇÂ@#gÜ@cMØ@‘™ê@±Œè@Ñå@ñrãA²ðA¬×A(§ŽA8¢UAHš}AX„pAhn`Ax1Ay<ÄAm‘ÈA`BÂAQgAAÁòA2ÚA"&lA1•A<¾@äÎ@Ħ @¤¼s@„Òv@IÍ‘@ ö7?“÷½>Ö«¿X%¿ëþúÀ5ýñÀuüeÀšýlÀºü¦ÀѾãÀê/ZÁ ÁnÁˆÁ+ÝÁ:w¤ÁIHŠÁXD¥Ákð®Á\ĵÁM¸ßÁ>ÔÇÁ0"€Á!¯¡ÁŽÌÁÙýÀñl ÀØžÀÀÁ¢À¬ðmÀŽ¿ÃÀ]˜õÀ²e¿»—©¾ï*#?0?Ãϸ@!Á'@a`@m@°NÙ@С@ïÅÀA·£A`–A' ‰A6¤ÓAEõTAU>AcÒÈAo§Akò Ac&žAX ÏAJî2A=A.hêA"|Aœ°Aå@ཨ@ÁLˆ@¡Ú\@‚$ñ@Dз@W?‹¼Æ=Ë;9¿eæ¿ò™¼À9 :ÀxôÇÀœfÀ¼Q½ÀØŸÀïþ$ÁɆÁ‰ÁÂ5Á-Ú€Á<@ÔÁJä’ÁY¹XÁmìôÁ^ãâÁOÿ[ÁAH(Á2É{Á$’DÁ¶¼Á R©Àù/Àá4aÀË«À°ˆÉÀ·òÀaÐPÀ"Pì¿Åг¿ ÿ>ßFc?¶¢¿@¹ò@Z"…@ŒgL@«*@ʳ@éØçAcAºûA"ðFA1çÃA@coAMÓàAY™ýAa²éA^]ˆAVP:ALñ–ABÙA5ntA("\Aé³A (•@ø >@Ù‹Ñ@º³z@›©¤@y?›@:©?÷¡]?s±[¼üS¿‚ ÀrjÀ?ßQÀL8ÀŸ\À¿ÀÞÉvÀù8Áû?ÁЯÁ#3§Á1ÒÁ?/ÁMnÁ\CMÁpº ÁaêxÁSGLÁDÚrÁ6°ÉÁ(ÚyÁkAÁ±ÁÈÀì–ÀÓîÀ´:SÀ”† Ài°ªÀ*‘T¿Öø]¿1¤Ü>m ? r¼@…@LÐØ@…qÆ@¤RH@ÂÁB@á. @ÿ@ÙAj{AÑÙA*·HA7‘žACJëALshAR¥AP\sAI ¬A@i€A6ÉDA+Ù×AÈvAšsAï¾@íÛ@ϯ<@±Ê—@“V@iÃ)@,Hª?ܤ²?@ú±¾_)¿™3]À AºÀIéÒÀ„`1À£Ò]ÀÃKãÀâæöÁL©Á ÌÁŽÉÁ'¨âÁ5!KÁBû•ÁQ$OÁ_Œ‘Át|ÁeëÁWuÁIoÁ;öÁ.ZÁ ë0Á?ùÁHžÀø+¨ÀØ¡À¹À™ªòÀtóUÀ6§˜¿ð½ ¿ix =g‘?ƒ5 ?þbÃ@<û@xâœ@š‘À@¸f@Õº¼@ò”KAF-Aš»A!.­A,Í+A6+A>¸éAC|ÇAA±îA;‚´A3^¼A*b°A „1A£ÕA Ù·@ùº±@Þãw@Ãz@¦L¶@ˆñþ@Vt@PO?ºÎš?µd¾ê²ê¿µ´'ÀÂCÀVÕïÀŠš-À©î3ÀÉB9Àè–?Áõ"Á [Á 4>Á,ÓÂÁ9ëdÁGo¹ÁULÁcphÁy7ÿÁjñžÁ\æòÁOÁAh­Á4/ÍÁ'rgÁOºÁ‘CÀýê%ÀÞÐPÀ¿ÏÉÀ Ñ¤ÀÕ¹ÀEµÃÀÞ(¿•j¾[‘Ð@N=?‘Ëà>PX¿<5“¿×ÜžÀ)q®ÀfõeÀ’<ŽÀ°þ~ÀÏëoÀîýŸÁÏÁÇÇÁ&qÊÁ2âÎÁ?±¼ÁLó¤ÁZˆ½Áh\NÁ~}¡ÁpjOÁb˜kÁU¯ÁGîøÁ;;Á/Á!¼(Á>¼ÁÁPÀæ‡ÈÀÇ¡pÀ¨ãÊÀŠ/PÀW#Àµ ¿½;n¿ “E>Èô?¨[@$í@HN@€H9@›Ìs@¶u@Ð/@èÍD@ÿ˜ÇA c>Af6AdA!3A$ºTA#JÈA·ÉA»xA]AŠP@ü[@ç—ç@Òk@º²Ì@¡Ñ!@‡³E@Yƒ@"¼ ?Ôj˜?C<¾’A¿‰QaÀt£À<ƒíÀx¤NÀšÂšÀ¹‚®ÀØEvÀ÷?Á å„ÁH÷Á)ÀÁ9NvÁFcHÁS9¿Á`xMÁn –Á‚4¢Áv¬|Ái9›Á\,ÁOjÅÁCöÁ5äÁ%ªžÁJ´Áì@Àï!QÀФ™À²P=À”F‰Àl€üÀ0§Q¿êoŽ¿i¹Ù»Úź?fù?äQÝ@)KÀ@_×)@Š/K@£‘&@»Ë¿@Ò—ÿ@è²@ú¼ÐAÉýA BBApÎAÅAµ{AâA i¬AG@ôþ3@âå{@Ïn@ºæ>@¥˜@Žh@kï@7z@#*?˜ˆ‰>¤ø¯¿Ž“¿»!ÀÒ”ÀRH/À†õ•À¥ ÀàÀáG’ÀÿªâÁ!ŸÁûÁ-ã`Á=DÿÁL®®ÁZjmÁgNÁtx1Á…”yÁ}ÉÁp»ùÁdáÁW‘DÁHÅÁ9f›Á* }ÁÄíÁ £ÄÀù>6ÀÛ8+À½6‘ÀŸ[óÀêÀI "Àÿ³¿ªT¾âç@>ÖUk?£ä†@M@;Nm@m« @Ž«á@¥—6@»%€@Λ‹@ß÷À@ï߀@ý(ßA8BAIùAA³@÷3@ê±Å@Ú¶û@É,u@¶›Ÿ@¢´R@Ž4•@pcŠ@BÆí@ø?½Öh?*ú½¾2µT¿‚¼t¿ósµÀ2|•Àkâ°À“À°6ÀÍ¿CÀëάÁó¢ÁÁ##Á2R–ÁA™ÁPâ.Á`B Án•NÁ{T–Á‰DHÁ‚¾²Áx°ùÁkátÁ\‡KÁMDwÁ> ÁÁ/òÁ ìÁçÁÀæœÊÀÉ8"À«ÔžÀŽÉÀd%OÀ+10¿çvR¿rNN½Å!?:_Ê?ÃöQ@©@CÑ@píÛ@Ž3N@¢j~@³úE@Ĩ=@ÓŒk@ßq»@ç¢P@êÐ…@èÒz@â“!@Ùa@ÍôJ@¿áº@¯ Q@@‘@ŠI,@l@Bá@t?Òðí?dbë=¼þ׿5#6¿Å“8ÀümÀO¿ À„nÀ jÃÀ½(ÀÚ>ÌÀ÷pðÁ luÁSAÁ(XóÁ7e?ÁFw"ÁU¢uÁdÑóÁt´Á~ûÁ4ñÁ†ÔIÁÍòÁp§'Áa›zÁR•òÁC‘IÁ4ŽÏÁ%­<ÁõuÁC Àó#ØÀÖ$‘À¹¿À­À €ÀKjÀ5Ó¿½óÅ¿)<»>ýâ?fv™?ÑŸÃ@©ë@B‚9@jñt@‡è¾@™#@¨Ì@¶»e@Ám@Èg@Ë @É\‡@ÿf@»gK@°nu@£µÚ@”§@ƒ;ð@aíi@;§™@¡½?Ò×?qø‘>v’p¾ÿ¤ý¿¦6ÀKŸÀ:y=Àpš´À“fÂÀ¯#5ÀË`Àç¯Á%=Á¼ÖÁV3Á.aÁ<ÝÁKÇPÁZÊÁiÖóÁxó4Á„ëÁ‘oóÁŠVÁ‚éÁvÁg²ÁX<ÁINîÁ:œÇÁ+êÒÁ=wÁÉåÁ‡kÀä”ÄÀÈd±À¬Ï À‘VtÀlŒÀ7ÇÌÀÏ‹¿¢vØ¿¶Ú>h¿?q—ï?Ñ;«@Ÿ@7¬«@ZK2@{I@ŒsT@™G@¢¼|@©Ì@«I®@©ÕÌ@¤ì@(ð@’é6@‡@@r›@R8Þ@.Õ@ Y°?Ä{A?dù¬>sœ[¾ì‰[¿•LQ¿òIûÀ,yÀ_NEÀ‰LúÀ¤)§À¿6ÀÚbTÀöfåÁ R/ÁuÊÁ%ÍfÁ4Z‘ÁBóîÁQœ¦Á`nÁoNÖÁ~;_Á†ž*Á”NmÁŒÊÿÁ…K Á{¶‡ÁlùÞÁ^HÍÁO˜Á@òÄÁ2…‰Á$FwÁ nÁàÀô‹ÀØ™sÀ½U§À¢¬ÑÀˆTèÀ]jÖÀ++¿ôò&¿—oü¾îï¡>l‘^?]8]?¾%ê@N,@$ŽÀ@C]ð@_8‡@vø@„3@‰ÈÃ@‹†B@ŠO@…À@} @j;ü@S{­@95â@îT?õCè?¬}¯?B»ƒ> ¤ê¿“œ¿•3À¿ï@öÀ$µxÀRrúÀ‚Àœ(vÀµÀ\ÀÐ ÑÀë¯ÁGÁÃ&Á×\Á,ùÁ;$¬ÁI}‚ÁWúvÁf‘©Áu7?Á‚VÁ‰p'Á—DÁ®´ÁˆT—Á€ü‘ÁsI`Ád­”ÁVD|ÁH‚Á9ÈyÁ+•èÁª¿Áî:Á<ªÀé};ÀÏÆÀ´íÀ›ƒÀ‚™ÚÀT„pÀ%ûî¿ðE%¿–n5¿ Á=Àr"?(¥g?™Cµ?Ùkå@ oÝ@%]¦@9…e@Jz=@T¡â@Wa\@U~¹@Lž@?h¼@.-@q.@¶?Éžì?‹ W? <»½(ô¿ ò3¿¡?æ¿órÀ$šÍÀQ¯ËÀ~ÆÀ–-À¯ÀÈ©ÉÀâA¯ÀüÎÁ {íÁÁ&‘¨Á4fiÁB~ÜÁP¡Á^ÖòÁm1Á{¢Á…²ÁŒiVÁš-Á’Õ°Á‹~zÁ„5‚ÁzˆÁkÄÐÁ]‡…ÁOOÈÁAOÁ3¹Á%× ÁH3Á îXÀûƒ¯ÀáÀÈP¶À¯ž*À—GæÀ€ïÀR{À%Z³¿ø¡ï¿§—í¿9íå¾5‘µ>°f?S&?¡X ?ÒT·?ù[H@ ×ß@wL@¡v@Ю@ »â@§‰?âû?¹ãg?‹5?,¥>kí<¾‰cL¿V±Ö¿¶ÿ>ÀÝÎÀ*g×ÀSŠÀ~«$À•äùÀ¬t‘ÀÃ>UÀÛÚ¿Àõ?ÞÁbÁ2³Á!mÁ.ôzÁ<…æÁJ){ÁXÁf&]ÁtI£ÁEšÁˆsÓÁ§ŽÁYÌÁ–°ÁŽãjÁ‡ÂÑÁ€£`Ás âÁdý€ÁW19ÁIxÔÁ;Ù“Á.[ÜÁ!!ÓÁ 7Á45Àõ3zÀÜ¢{ÀÄPsÀ­D~À–j»À›îÀV"ÆÀ-›~Àf¿Æ³î¿ƒ/{¿ ¤½†®>·Ad?3®ä?}7°?™Ñ§?«lŠ?¯Ã ?¬=ð?²l?‡'¨?PÓû?*¾>/wê¾b-¿"Ì࿯ä¿ÑdjÀÆ'À4^ÚÀ[¦/À‚À–`ÕÀ¬gÀÂöœÀÙ†4ÀðPøÁW‹ÁüÖÁ°¨Á*p¦Á7u”ÁDèÁR{}Á`µÁm̺Á{· Á„æïÁ‹û&Á“ ]Á ÄÁ™£XÁ’ƒ¸Á‹eÁ„YBÁzÓõÁmTÁ_l/ÁQå’ÁD†HÁ7YßÁ*YÁ›ÁÁÓeÀñh}ÀÚq*ÀׯÀ¬öFÀ˜ÑÀƒµƒÀ`P‡À< çÀ‚À¿ñ"·¿³ÿ¿wå%¿\Ǿ|ó¿<Ûƒ>_œƒ>¯©õ>Á R>³j>hœ=§ µ¾©ƒ¾Öœ¿Aª¿‘S]¿Åó¿ýôÀ‹ÀAkðÀg®À†¿ÜÀš·HÀ®üMÀÃg-ÀÙ~Àð?ÁKìÁ²5ÁÉ×Á'dQÁ4 ÒÁ@ÁiÁMžŸÁZâ¸ÁhqÁvRÁÔðÁˆ¸ÌÁ° Á–º¯Á¤d?ÁE6Á–5æÁ?:Áˆ]êÁ‚íÁuvòÁgù…ÁZ¹ÂÁM£ßÁ@®ÓÁ4èÁ'›/ÁUÁFÂÁÏÀðÄ¢ÀÚ!~ÀÅ'ŽÀ°FÀœ«uÀŠz7ÀqmÃÀOýåÀ0†EÀÚ¿¿ïž“¿ÀÆ¿™Mû¿q¬±¿CÕ ¿'/¿xî¿%ο< ©¿f'¿àù¿¯ð<¿Ø€jÀA»ÀS4À66™ÀU=NÀu€·ÀBÑÀ F­À³juÀÇ›xÀÛà}ÀðãÁPiÁŒñÁÔ½Á%<,Á1BNÁ=ÎCÁJrÁWÁcß+Ápù¥Á~gšÁ…ýôÁŒÉÁ“¥~Áš‹«Á¨þÁ¡¡Áš.ÐÁ“RyÁŒ„)Á…ÁxÁ~ˆÁpòÁcïùÁWjÁJpÁ>XÁ1ØÁ%ÝÁeˆÁøËÁ§Àò8LÀÝnÀÉa\À¶ï{À¤É‡À“ôtÀƒ—¼ÀhÐÀLž—À2Æ¡ÀLÀ €c¿õ'¿ßÉ'¿Óœ¿Î½¤¿ÑìS¿ÜBÁ¿ð¡À2À¸À(ãÀ>3fÀVá>Àp9ºÀ†ŒÀ–2KÀ¦àTÀ¹Ï©À̼·Àà:¤Àô©Ác7ÁÐŒÁã«Á%ÖÁ0]Á;ÆJÁG¾ÜÁT86Á`ÛåÁm€‘Áz0ôÁƒ“üÁŠ87ÁøÁÁ—Ã_Áž•‚Á¬ƒÁ¥#7ÁžMßÁ—Š(ÁˬÁŠ(ÙÁƒCÁz<¯Ámt‡Á`è!ÁTŸ€ÁH^‡ÁBÁj¢¬ÁwEØÁôÃÁˆFçÁŽ´Á•GfÁ›ùoÁ¢¾*Á°fÁ©RØÁ¢5Á›ÝIÁ•E/ÁŽÃQÁˆHkÁí¾ÁwgJÁk!¨Á^éOÁSmÁG”>Á<%¾Á0Ô½Á&,ãÁÑiÁ‰åÁíÀý®?ÀëÜóÀÛ'‡ÀÊæÉÀ»ÐRÀ­¡óÀ »À”°'À‹&À‚——Àw¦4ÀmÄlÀiÛÀg €ÀhY•ÀmRzÀuÞÀ€©GÀ‡ýQÀ«SÀšÛ÷À¦"nÀ²—kÀ¿NcÀÍ*ÏÀÝXÇÀíÉ~ÀÿÎÁ fÅÁBÁƒÁ'$Á1Y‰Á;òuÁG .ÁR9-Á]púÁhÚÎÁt¿¸Á€ˆàÁ†×åÁ)½Á“xÁ™ÚjÁ _©Á§ÛÁ´XØÁ­š¡Á¦ôÑÁ h˜Á™é^Á“vXÁ$'Á†ô¹Á€ÒzÁuw›Ái¬Á^-«ÁR¼8ÁGkÜÁ<µBÁ2YÈÁ(SÁ3LÁ]Á ýùÁŽ„Àöl=ÀæîÀØ%ëÀÊ¡ÆÀ¾:õÀ²Ù¼À©„’À¡©(À›JæÀ–ytÀ”gñÀ“r3À”¥À–xOÀšRoÀ §À¦ß÷À¯8íÀ¸ÐÛÀÃâ²ÀÏîvÀÜPÀézöÀøÏÞÁ„UÁ +Á( Á­ Á)]¿Á3s›Á=—hÁGàèÁR„/Á]pÁhÌnÁsþöÁeÂÁ…¡\Á‹Â Á’ ßÁ˜\÷Ážª›Á¥3Á«~vÁ¸«GÁ²YÁ«Ž¥Á¥îÁž§LÁ˜^JÁ’5ÍÁŒ×Á†DÁ€$$ÁtÈÁiRàÁ^ÁS?(ÁHâ&Á>‡äÁ4ˆPÁ+M›Á"/¥Á‡ÛÁ-NÁ ìÁœLÀôôšÀèÀÀÛÅ7ÀÑ_²ÀÈ)­ÀÀ¾ÀºË_À¶1àÀ´HtÀ³_'À³Þ€À¶G`À¹¿°À¿l ÀÅ×÷ÀÍ̪À×'/Àá°ÂÀíEÀùÔëÁOTÁ B}Á?àÁsÁ#.Á,jÎÁ6ƒÁ?Ä—ÁIå³ÁT ‰Á^lÚÁi;Át0±Á_°Á…G½ÁŠùñÁãšÁ–þÁAØÁ£œÁ©Ý@Á°0ÊÁ½3ùÁ¶´²Á°9³Á©ÚŠÁ£›aÁvæÁ—Y•Á‘M¼Á‹r^Á…±—ÁêÁÁtšiÁiË·Á_j…ÁU ÁJìTÁAˆÙÁ8jãÁ/ƒ Á''öÁ×äÁ+ÁÅhÁÿkÁÉVÀù’lÀïðãÀç%ðÀßÕ†ÀÚTsÀÕþÌÀÔ(÷ÀÓLÀÓ·[ÀÖrÀÙKÀÞÏoÀäáÒÀìš²ÀõŠ´Àÿ—ÔÁoWÁ ‹œÁù½Áv8Á Á(ÓÁ0„VÁ9`ÅÁB®ÏÁLV ÁV5IÁ`WËÁjƒÁtùWÁ¨Á…aùÁŠùyÁøÁ–BfÁœ'œÁ¢:þÁ¨vNÁ®Â@ÁµäÁÁÚ¿Á»fˆÁµÁ®ÚÛÁ¨¹Á¢TÁœ—þÁ–À ÁÿmÁ‹AÞÁ…˜ëÁ€-ÁuòäÁk—iÁa\sÁWȈÁN¦!ÁE—YÁ=!<Á4Æ×Á,£Á%PnÁ#¢Áµ<Á‰LÁ é¢ÁD¤Á êÀÿÀùââÀõØùÀô {Àó9Àó6ÀõåƒÀøò—Àþ3`Áÿ–Á¾«Á ùÁÕ½ÁUØÁ6'Á Ž·Á&ú«Á-ú/Á5ÓÔÁ>WÁF @ÁO—£ÁXýÄÁbª¨Ál§aÁvË™Á€€íÁ…ÂêÁ‹{Á«šÁ–CÁ›ÚÆÁ¡‹óÁ§mFÁ­z Á³­Á¹ôøÁÆ–bÁÀI”ÁºÚÁ³ü|Á­áîÁ§âáÁ¢âÁœMzÁ–ŽÉÁå)Á‹uÁ†=¡ÁäÁwÕdÁn©Ádá_Á[ÄÁSƒÁJÁWÁB{ÇÁ:ß@Á3xŠÁ,­ôÁ&u2Á TàÁ1¦Á”gÁ®îÁ;Á ºoÁ ÝæÁ õ Á “Á ´ðÁ ÚJÁ T÷ÁѸÁ¦EÁ/þÁ;òÁ\Á#ÜÁ¬Ö[Á²pÁ¸!‹Á½üfÁÃþÁר˜ÁÑ2 ÁÊÖÖÁÄ™¾Á¾~TÁ¸s6Á²j]Á¬|Á¦ÅDÁ¡9eÁ›¾\Á–OÎÁ‘ŠÁŒ(°Á‡t\Á‚ÇDÁ|x_Ásè<ÁkrÿÁc–ƒÁ\›ÖÁV‚ÁÁP¬ÁK|ÁF»3ÁBóÁ?³×Á=/˜Á;"Á9sIÁ8a¢Á7–DÁ6é`Á6ŽÁ6g;Á67öÁ6XÕÁ7 8Á8ÄãÁ: ÝÁ<§Á?¼CÁC~óÁGWaÁL5ÁQèÄÁXƒôÁ_1“Áf†èÁnúÁvÙ ÁŽ¿Á„cÔÁ‰A®ÁŽgUÁ“·ãÁ™:ÖÁžÆ2Á¤qÙÁªMeÁ°TÁ¶–Á¼Ê¦ÁÃÁÉl9ÁÓ bÁÌ„‘ÁÆÁ¿¡çÁ¹\¥Á³:¦Á­//Á§$¶Á¡7¯Á›z?Á•ïùÁugÁ‹ ¶Á…ß—Á€þÁx¡ÁoMRÁfe Á]åÏÁU˜]ÁN$ŒÁG²ZÁAÉÁÁµ6ÜÁ»Ú ÁÆ<#Á¿VÞÁ¸‡VÁ±Ñ+Á«2éÁ¤ŸÅÁž‚Á—¶zÁ‘{8Á‹h³Á…] Á~ÂlÁs>)Áh4¼Á]D%ÁR“·ÁH—"Á?${Á5ØùÁ,ÛÃÁ$^zÁM–Ák¾Á…6Á FÁÚÁI Àü@)À÷WÀóÖTÀñffÀïáÿÀî†5Àí|ÀíúÀ쳨Àí êÀîóÀòŽÛÀö†7ÀüžaÁ EÁÞ.Á úŠÁkeÁõÁh[Á'΋Á04œÁ9TˆÁC0ÁMxYÁX^ÁccãÁn¹‘Áz‘«ÁƒmHÁ‰¹JÁÈÁ–eÁœæßÁ£…AÁª'Á°Ì~Á·‰†ÁÂF:Á»Y;Á´p*Á­‘ÙÁ¦ÍÁ #ŽÁ™‡çÁ’ø%ÁŒ‡Á†@ôÁ€)9Át;Áh:NÁ\±þÁQ­)ÁF¿'Á<"‡Á2KÁ(ÜäÁ§ÁÕMÁz÷ÁérÁÀWÀõçfÀë¿}ÀãrdÀÜù½À×µOÀÔûÀÑ‹ÝÀÐÀÎǵÀͦ¯ÀÍjÀÌÊ=ÀÍ<ºÀÏ3ZÀÒÐ À×XÀÝ×ïÀåU¶Àír&ÀøèlÁþ‡Á Î ÁåUÁQJÁ#;jÁ,ÉÍÁ7êÁAçœÁLæ)ÁX:’ÁdfÁp|^Á}sÁ„ßÁ‹G1Á‘×sÁ˜wnÁŸKÁ¥ÇéÁ¬”#Á³s—Á¾x5Á·lÖÁ°vTÁ©_Á¢¨ËÁ›ÓËÁ•UÁŽw:Á‡Ý\Á]gÁvtÁi×yÁ]À"ÁQ·vÁF*}Á;+Á0@¢Á%¾<Áÿ Á˜ÝÁ v@ÁÖÑÀñoÀãükÀØDêÀÍ{ÀÄw‘À½ÌOÀ¸/À´W£À±±SÀ°&0À¯ 5À­àòÀ­6"À¬å À­X‹À¯t À³fÀ·È¿À¿uÀÆòÀÏ«jÀÜ)TÀé.ÓÀøFÁ.Á '&Á•BÁ ·:Á+|Á6qÁAÃhÁMµÁZ*ìÁfΦÁsv—Á€2Á†ÌiÁk Á”rÁšÎ@Á¡§6Á¨‡ÂÁ¯`RÁºæÁ³¿0Á¬¢·Á¥›Ážª™Á—ÆzÁçöÁŠeÁƒoÁy– Álv'Á_³‚ÁSa¿ÁGJÓÁ;;ÍÁ/©qÁ$°©ÁËœÁlšÁ³9ÀøËöÀæ§{ÀÕùÇÀÆïŸÀºÈÀ¯;½À¥ÆÀž­À˜¢jÀ”™KÀ‘Ø0ÀHHÀJµÀŽ5YÀbºÀÚÀt[À¶]À“R«À˜ËÜÀ OìÀ¨ À²©ðÀ¿¯ÀÌðûÀÝBCÀîB•ÁvþÁ uêÁ ƒÁ )Á+W'Á7YQÁCå ÁP‹ÚÁ]AÁjLÿÁw†EÁ‚`rÁ‰šÁÝÈÁ–º°ÁŒÁ¤jeÁ«=FÁ·ZƒÁ°6Á©RÁ¡êÓÁšÐtÁ“ÍsÁŒäAÁ††Á~a—Ápæ¶Ác…ŒÁVDÆÁI_’Á<ôÁ0Ý;Á$ÊAÁ1²ÁA¤Áe†ÀòHÔÀÞÏEÀÌh3ÀºŸ@ÀªÔ‰ÀB¼À‘v)À‡'TÀœÀrµÀiÅ,Àd©À`Ö”À_jÀ]lnÀ[R’ÀZFºÀ[!À_û”Àg0=Àt–À‹ÀŠ/ÑÀ–0»À¢öjÀ±ßñÀÂw ÀÔ²ñÀè«Àý­nÁ ±dÁú½Á!ÎÁ-®˜Á:WûÁG!^ÁT9³Áat2Án¶'Á|0-Á„ñÁ‹»IÁ’“ÒÁ™h|Á J¿Á§BÁ³Ë0Á¬¤‡Á¥€ÕÁž_}Á—;dÁÁ‰¬Á‚æÁvK=Áh|Á[pÁM´Á@-WÁ3ãÁ&”ÁzµÁgœÁÈ ÀïȽÀÚ/7Àż;À²TNÀ æÀãÀ€<ðÀh¡ÀQ` À@ó¨À4A+À*zÀ$±nÀ!DtÀ¤­ÀŒAÀHÖÀÂHÀw«À ¦)À(’À6‰£ÀE“àÀZ[‘Àso(À‡5À—& À¨ycÀ¼}xÀÑKÀæØÀýmÁ âÒÁƒ0Á$,ïÁ1ìÁ>'šÁKb†ÁX¶vÁfO|ÁsÞÁ€½KÁ‡—?ÁŽpjÁ•dgÁœbsÁ£rfÁ°CÁ©\Á¡íšÁšÊIÁ“©/ÁŒ‰;Á…kkÁ|œŠÁnvÅÁ`ŽpÁRÝ4ÁE1QÁ7±nÁ*9ÂÁù¤ÁHAÁ(áÀð5€ÀØêxÀÃJÀ­âaÀ™6·À† óÀguvÀH›]À-hÀNÐÀ¿ë™Š¿×¿Ë“¿Äl[¿ÀÌÊ¿¿X'¿ºÑR¿·À¿¸…¿ÃDû¿ÓðÍ¿ò_À ›ÙÀ ñ}À;ÀYKëÀyhÔÀOÓÀ¤¡¿ÀºnÀÑ1JÀé}àÁWØÁ gÁìöÁ(‡Á5XÁBÄÁPUUÁ]Ò#ÁkÁy0·Áƒ†ÎÁŠ‚FÁ‘˜Á˜¯ÉÁŸÙ®Á¬ë}Á¥§0Ážb§Á—.”Á¥Áˆò:ÁÒÁudüÁgByÁY¢ÁJøãÁ=$ªÁ/oôÁ!ÔÁ\çÁýVÀô7HÀÛãÖÀÃÜøÀ¬•éÀ— (À¶ßÀY‚LÀ3àÀÞ²¿æ¥'¿´Û,¿Œwh¿]a~¿3V÷¿,É¿¿uU¿/š¾ôCà¾ë²õ¾î¥¿ºG¿4§:¿nq¿Ÿ}ñ¿Ð×ÀÚëÀ$eõÀI*ÀpÌcÀŽ>ÍÀ¥²À½@ÀÖYÀïàÜÁÓ·ÁÄÁP|Á,Ø%Á:3ÍÁGáõÁU‡jÁcR‡ÁqFÁYÜÁ†ÌÁö~Á•/ Áœk$Á©™”Á¢RÚÁ›¼Á“ÈÁŒ‚ZÁ…MÒÁ|_îÁn6BÁ_õúÁQ¸ÁC­Á5gÁ'»Á¼žÁ ´Àý;Àâ`æÀÈEöÀ¯Ï³À—àÀ€•áÀU“òÀ+¼Àâ>¿¹«b¿qcs¿dq¾™ú=Ý‚>Œü>¼J>ÙHþ>ê¦f>ñP?0½?Í,>ÿĈ>Ї>nE?;'Í}¾¯"®¿E¿Ÿþg¿äÕ¾ÀŽWÀDR1Àqô±À‘{ÀªTÀèëÀÝw:À÷öÝÁ X4Á¦¿Á$4ÏÁ1ç®Á?šÁMŠ'Á[”óÁiÒ¬Áx&¢ÁƒMzÁŠ6Á‘ÉÄÁ™ »Á¦frÁŸ 7Á—º:ÁreÁ‰.GÁèöÁuDqÁfÚ2ÁX¢“ÁJyhÁ½e;?Aƒñ?ˆ@Á?Ÿ×w?¬V ?³œ{?·un?ºf!?¼µ¨?¾‘D?»ˆ?¯iç?•äí?e§º?&=Œñ¸¾äö»¿„óó¿ÙmíÀ¿RÀIþ‰À{ }À—>æÀ±^ÀËÚ"ÀæSÁŒkÁIkÁçÁ)ÎôÁ7дÁF 9ÁT`TÁb×ÒÁqZªÁØîÁ‡.sÁŽu°Á•ÄÁ£vºÁ›üøÁ”YÁ-æÁ…ÛFÁ}#âÁn›¥Á`iÁQ„°ÁCßÁ4å9Á&¼ Á’áÁ aþÀøîÂÀÝÀÁU|À¦îÀ‹itÀc†õÀ0¼ÀH¿£:°¿\Û=Œ=ú?*îú?šë'?Óߟ’ ¾«dB¿‚—~¿áÉùÀ".ÂÀUÁ‹À…C¦ÀŸbÀ¹ðpÀÕ8ŠÀð} ÁÂÁ ™Á"EÆÁ0šÁ?±ÁM—ìÁ\UÁjªñÁyMÇÁƒüÍÁ‹`ÏÁ’ÆuÁ ±"Á™+¼Á‘­8ÁŠ/bÁ‚º5Áv¨œÁgùÐÁYbøÁJÚ¼ÁÁv¾½¿’z¿ûDwÀ11ÀeëŠÀÞ?À©AÅÀıÀà™uÀüþ¥Á ÓúÁQÁ)ÖHÁ8fÁGÁU³ÁdwÁsP©Á¢Áˆ~üÁãÀÁž!ÌÁ–†¡ÁŽòjÁ‡fNÁÇnÁpËqÁaÒˆÁRö4ÁD>çÁ5¢1Á'ÓÁ‘—Á …À÷-ìÀÚÕÀ¾‚.À¢-ßÀ†–ÀU+œÀÓ¹¿Ñ}\¿OÝ™¸X\??O³?¼Ø€@ $v@37Þ@W‚õ@h§i@oFÚ@}@ˆÏÊ@‹&"@‹¯ï@Œ]°@@„Q@|—Ù@y„ž@aL@A¹ó@a?â,Q?ƒGy>u„u¿æó¿°-ŒÀ (ÀD Àzz¦À™ ™Àµq¿ÀÒ8ÀïÞÁ›Á´,Á#`ñÁ2)"ÁAÁOá/Á^¾ Ám’ÃÁ|jßÁ…®‘Á4ÃÁ›ËŽÁ”±ÁŒx¤Á„×<Ázu·ÁkLôÁ\8ÁM8nÁ>‚Óv?ޏ‚?úl@0ž1@aô@‡ÿZ@œß@š@™í®@ÎÇ@¥ù@±è¨@¿ÁH@ºe€@®™O@¦-n@¢d<@¢íÒ@¥º@‘~¸@txM@A“z@–­?²´‚? ^‘¾£<÷¿™_ÈÀVÀ@ ´Àz ŠÀšßŒÀ¸“ÀÖF¡Àô«Áð>ÁÕ'Á&ÁŒÁ5ÌwÁDùÁT9CÁcu(ÁrªrÁ€ðÁˆ”Á—ÀÁøxÁˆ-˜Á€gÈÁqQ!Áaâ™ÁR~ÁC’Á3È Á$„DÁGÊÁÀÀî,ÖÀÐ4ÜÀ²DxÀ”Ê•Ào\[À5;j¿ö!Ä¿‚̼¾ E??‘7?Ð_Â@¡x@U /@„áz@¿,@´Þþ@±“:@°2.@³È@ºKB@Ä ‘@Ò(¨@Îe@ÃÑr@¼I @¹Hˆ@ºV|@¾@§ @¸O@g†¹@1??õ U?„ÓÑ>rß¿DP½¿×ºÜÀ'&ÖÀbìÀŒÀ­ÊÀÊ×Àè¯6Ás¿Á´`Á!õ:Á16Á@n•ÁO¨ŒÁ^ùLÁnXÁÁ}¸¥Á†ŒDÁ•ê÷ÁŽÁ†RÙÁ}–Ám‰yÁ]û]ÁNdÐÁ>×TÁ/[©ÁóÄÁ5Á4(ÀãÞSÀÅd«À§,À‰×ÀV-¹À°–¿À±l¿ß>Ÿœ?›Bì@3è@>܆@vvê@–t@@±w @Ê™ù@ÊOF@É@ÊÕ!@Ðãä@Úl3@æÕ2@ä¡9@Û5@Ôí@Ò ¹@ÓšQ@ÓÚR@º¢@ŸÞ9@„žd@Qƒµ@²?»¥? b¾Ät§¿§ëVÀlÀL¦ÀƒÑ9À¢£ÀÀ®<Àß>ÀýÏbÁ0UÁsùÁ,ÐhÁ<0aÁK” ÁZü‚Ájh Áy×Á„©ýÁ”\½ÁŒÁ„¦7Áy˜gÁiè†ÁZD3ÁJ®)Á; Á+‘ðÁÓÁ o±Àù¾/ÀÚÓ À¼ êÀD!À}h<À@tíÀÑ¢¿Ã[¾?Ž?:«¾?Ñ—À@"÷ê@\©I@Š–@¦ê`@Â^ú@Ý—â@äÚ@@ã(÷@ä–Õ@é® @òC<@ýzˆ@üëä@ô‹X@îÑè@ìg×@íÞE@ç@ËÙm@°I€@“ˆ@l•¤@1pÂ?ìX?g³Ë½Jò¿w¶ß¿õ’øÀ7æ°ÀuäÀ™.À·§ÝÀÖb8Àõ"ËÁ óÁq¡Á(âOÁ8RþÁGÉZÁWJ³ÁfÓ†Ávd[Á‚üÁ’ܲÁ‹Áƒ%YÁv“`ÁfÜÁW$»ÁGmiÁ7·:Á(4ÁSëÁ¶ÝÀòQÀÓ4ÎÀ´•À”õ†Àk›sÀ-êÜ¿à±1¿LOJ>÷Ê?ŒÔ»@ZR@=®•@wÏÓ@˜þ{@µØŽ@Ò5@îI³A>'@þ{¬@ÿ¢KAôAÁ¤A úÙA cA¢AõZAýèAªx@÷¿å@Û]@½¬`@ ‚@ü©@G‹@ ¸Ã?Xš>ŒxÉ¿.8k¿Ñ[äÀ&»Àc>À„aÀ¯XÔÀÎ:1ÀíÚÁWÁ Á%0 Á4òÁDa<ÁSþÜÁcžŠÁsB½Ás¨Á‘‡Á‰Ÿ³Á¸ÓÁs¨;ÁcãZÁT%ÁDmEÁ4µòÁ$þ ÁGNÁûÀë±RÀÌD À¬ÜÀ‚fÀ\ÃéÀ‹w¿À¦ ¿]^>áðß?³ À@@—@T3æ@ˆS/@¦K)@Ãj•@àa@ý\xA ÉÃA dþA ÊA°ŒA ¶ïÁNPÁ^dÁn;ëÁ~8ÁfÁ‡Á~g®Án— Á^ËJÁO£Á?:ÔÁ/m¬Á „ÁÓ\Á5ÀàrÀÀÕ§À¡7ðÀš9ÀD·À¿Œc—½ê??^#?ìÌ"@5CZ@t ¤@™xÊ@¸˜i@×´¢@öÐÛA í%A7.A)8?A*ËÕA,+£A.ùðA3,$A4þNA26A0ëA+‘AËŒA }p@ú#f@ÛX^@¼“@ƒ@|Õ@>¢Ó@nÒ?ƒ}=B.¡¿n´L¿ô±¿À9 »ÀxNËÀ›ÑNÀ»{7ÀÛ%ÀúÏÁ <ÈÁÁ,ëaÁ<Ã<ÁLŸ·Á\€­Ále7Á|L§ÁÎiÁ…ïôÁ| VÁl:ÇÁ\h8ÁL•ªÁ<ÃÁ,ðŒÁþÁ KoÀúöWÀÛePÀ»ÓpÀœ9 Ày=¡À: ¿õ¨Å¿n=fâÃ?…­ò@g@A8Ì@€š@Ÿ?@¾íã@Þ\ˆ@ýË-AœéAC¾A-ÑÚA9™A:Ö«A=maAAOXACqÒA@°PA>íQA/“A åA“µA{@âö@ûâ@¤Y @„ö7@J¬@ z¼?˜V)>M˜&¿Ià>¿ã“CÀ14ÀpmdÀ—îzÀ·³7À×…×À÷`Á œaÁˆzÁ+t“Á;`¬ÁKLÆÁ[8ßÁk$øÁ{ÁŠ/{Áƒ{PÁyƆÁiñ‹ÁZéÁJD³Á:m}Á*–ŸÁÃ¥Á ñÀö=ÀÖ—òÀ¶òÕÀ—M·ÀoQ4À0ù¿áy}¿FÐ>YÙ?™¤_@ Ï@K;n@…8@¤Ó«@Äq2@äêAÖPA A!T_A1 ±A@ÃAIµ’ALAO·ÆARÔAO‘>ABÕ«A3/ÈA#mUA›YAÉ]@çîÂ@ÈJL@¨•ã@ˆÒÄ@RI@™ ?¦%š>œdv¿/æ¿¿×_ªÀ+k´Àk'’À•q¸ÀµO§ÀÕ-—Àõ †Á t»Ác²Á*RªÁ:A¡ÁJ0 ÁZÉÁjÁyþˆÁ†å`Á€#ÁrpÁei®ÁWÈÁGõþÁ8#ãÁ(PàÁ{æÁ¦ìÀñ£äÀÑùðÀ²K×À’lÀeçÒÀ&—¿Î¦¹¿ $ˆ>ºÇ?­§@ÕŽ@UÉ@Š5@©Ú@Éq@é OARÐA÷A#íƒA3»­ACŠPASY+AZùóA^WøA`úAT¨*ADÒÊA4ýkA%rA=8A[þ@êõY@Ë&@«W¨@‹ˆÐ@W`@ »?¯ÂÄ>ÁF¿uB¿Î¹TÀ'ÀfÛ\À“MûÀ³19ÀÓ~Àò÷ÄÁ m…Á_(Á)PËÁ9BmÁI4ÁY%âÁiHÁy?Áƒ×ÁyÐôÁl Á^“€ÁQi¬ÁD¦Á5Ä2Á%óœÁ ÁLÀìòÀÍKóÀ­§½ÀއÀ\¾¢Àq2¿¼:”¾öK?*?¿ÆÞ@>ð@^‰+@Žé³@®ŽÐ@Î3î@íÙ A¿A‘£A&d2A66×AF AUÖÄAe£ìAm%žAeü§AV¾AF.ðA6H'A&a_Az–AŽÓ@í:Q@ÍVü@­s§@R@[Yû@“Q?·™N>à/꿲¿Ç­À#NÀcªÀ‘mªÀ±OÜÀÑ2 ÀñÁ‚ÁxÆÁ(orÁ8fÁH\ÈÁXStÁf0ZÁsÅ!Á Ásî6Áf¾ÁXbßÁJä×Á=ÃÀÁ1±Á#v‡Á«†Áà…Àè+ÀÈÓÀ¨ð?À‰I2ÀSDIÀö/¿©P)¾ªÏÏ?'Âj?Òr @(r@gÉÞ@“‰E@³0°@ÒÚ‚@ò„vA £AëûA(¾ŠA8‘AHc¿AX6Ah …Aw0´AgBAWPsAG^ÈA7mA'{êAŠÚA™É@ïQr@ÏoR@¯1@«@_‘á@Í ?À¾?z¾ü N¿¾ÝnÀIeÀ_$À`À¯l¶ÀÏZ ÀïGdÁ˜êÁ,Á'nÁ7u°ÁE6"ÁRxÝÁ`;Án„Á};¥ÁnÝ/Á`³KÁRÆ7ÁE#ùÁ7×pÁ*ÈÁ9xÁChÁl1Àã)ôÀÃ}ƒÀ£ä‰À„N‡ÀIq À E¿–2¾>ÏÉ?Mn:?åSR@1÷Ä@qEÞ@˜Iü@·ñ @ט@÷Ž@‚Kâ@¡úP@Á¨¾@áW,AwEABFA GA/Ø–A?¦cAOvA_HƒAo÷AztçAj€­AZ6AJš°A:©YA*¹…AË­A à~@õï@Ö%@¶KJ@–yn@mO$@-«m?Üj?9÷¾‰ýο¡ÆãÀ‡)ÀP*àÀ‡çLÀ§¹(ÀÇ‹ÀçWXÁ£7Á ÁæÁ)dÑÁ7OÁE1ŒÁSŠÁb\Ás»ÁdIÁU®„ÁGJÔÁ9DÁ*è¢Á(¸ÁàÁ3ÀÀÖ =À¶ÞƒÀ—ÉÀn¶À/2ª¿ßOZ¿@g?>w@Û?žÖ@ÿ@Nb@†Íc@¦ˆ’@Æ3ÿ@åßlAÅlA›#A"pÙA2FABpAQô§AaƉAq‘ŠA{â%AkùA\DAL'lA<>”A,U¼AlßA ƒñ@ù6@Ùd+@¹’O@™Às@sÝ/@49x?é+?SÈ$¾*Ë¿”X¼À ¸/ÀICtÀ„]ÂÀ¤ÊÀÃÕÒÀã‘ÛÀþ¯$Á ÁÖÁÌ•Á&[»Á4QmÁB•€ÁQðÁ_‹wÁq ïÁb:ÐÁS”®ÁE$YÁ6öÁ(ý(Á1zÁ ÏÐÁÀéùœÀÓÀ³J/À“wÎÀgJÛÀ'¦¿Ð±¿!r]>¹uî?­dc@5¦@U¹@ŠžG@ªb%@Ê(ã@éïÒAÛ`A¾ØA$¢NA4ƒæADeAT;5AdëAsæ¢A}…¦AmœÎA]³öAMËA=â>A-ùPAbA't@ü~Ž@ܶÌ@¼ñ…@4Ÿ@zñ.@;y?ø?r#ò½;Äö¿„ÎIÀß5ÀAsÀ€’SÀ kÀÀCãÀàÀúÄ Á îGÁ!YÁ$½ÜÁ2œ”Á@Ç–ÁO6ëÁ]Ý>Áo»+Á`ÒÈÁRÁC†ÉÁ58¥Á'94ÁûÁ „Àÿ¼ªÀç˜çÀЊÀ°=eÀ[?À`ò4À!-ê¿ÂÓ>¿ÑË>ï‚s?»*@9Ñ@\Þ’@ŽAª@® @Íæk@í¸ËAÅ–A©7A&ŠA6kAFLãAV/ˆAfÎAuöFA*ôAoF#A_eAO†bA?§ÜA/ɇAëpA lA/h@à¢Ç@Àæ¿@¡!]@H•@Bç‘@BÕ?‡<4=~W¾¿n­q¿ö /À:ôÓÀz™ŽÀ$À¼ñ‚ÀÜÃàÀùBGÁ AtÁg2Á$WÁ1ò;Á@*HÁN¤šÁ]TœÁoyÏÁ`ÁQÈôÁC6¡Á4â&Á&ÛtÁ7èÁ °Àþµ‚À毭ÀÍðxÀ­ôvÀú=À\¸À4¿¸kb¾â²? ¹u?Æeù@"÷œ@b¼<@‘@n@±"½@Ñ @ðç]AdÖATùA(DA8-AHAWÿAgè%AwÑ+A€EAqAdAabOAQ‚AA˜ÙA1¯ªA!Æ{AÜþAóe@ä˜@Ä@e@¤m3@„š@Iˆª@ ‹¼?“!±>g¿Yá¿ì¼ÂÀ6XÉÀvS2À›&ÍÀ»$ÀÛ!6Àú~—Á £DÁ­ÁÁ$"[Á1ðÁ@„ÁN~kÁ] 5ÁpäÁa)»ÁRvÁCö‹Á5¶çÁ'²ÌÁøÈÁ ¹êÁiÀè¨BÀÍR°À­T«ÀV¦ÀZ±BÀµ8¿µr]¾Õé"?û—?Êuß@%6ú@e3@’—‡@²•Œ@Ò“‘@ò‘–A GÍAFÐA)EÒA9DÕAIC×AYBÚAiAÜAy@ßA{áŸAq9ÑAbXARnABíA2”A"”~A”îA•e@å+Ë@Å,å@¥.*@…/·@Jc£@ i/?”Ý>'EÞ¿V*¿ëæÀ5zÜÀuuDÀš·ÖÀºµ ÀÚ²?Àú¯sÁ W:ÁõÁ%LcÁ3|ÁAÔÁOkÁ]ýAÁqùÁbKýÁS¤ÝÁE3_Á78Á)(Áµ*Á¼tÁTÅÀí‹1ÀÍç½À­óøÀŽ3À\ÜÀ1R¿¸“¾ãì?3?ÆÙ®@#Ta@c;ì@‘‘»@±…€@Ño[@ñ?ÒAˆ%Ap`A(Q&A7ò/AGqBAV»ÁAe…ÊAq¿\AnìpAe°êA[>”ANsA?$óA/ÄA HªAž§Aô¤@âqŒ@´i@¢÷F@ƒ:$@Fú@¼? 7>PË¿^l¿îÖ"À7; Àw .À›n©À»\@ÀÛLÑÀû?:Á ™mÁÁ'·‹Á5B!ÁCÀÁQEÌÁ_®bÁs¯Ád^ÁUÛ8ÁG’¼Á9’Á+ê£Á³¢Á ‡ÁÏÀïuàÀÏŽÀ¯®rÀÚÆÀ`ŸÀ s±¿Á¥†¿ëo>ò‘½?»¾–@l^@\ò¥@Ž ’@­ŸÒ@Í3@ì<A›vAæA$?êA3AÃAAÖqAOˆA[T÷AdE÷Aa«AYFAOT=ADɪA8EÑA*‰ËAÖA ½6@ú¸‡@Ûö¬@¼ï‘@›@|'@=ä)?þK?€":<<9¿{&Ê¿üžÚÀ=Õ(À}W'Àžh¶À¾%ÙÀÝâüÀý§!Á¼$ÁM§Á+yÁ8LÝÁEñÁSé®Áb'9Áv6Ág‡ÁY:KÁK.ƒÁ=r"Á0½Á#7bÁíàÁ KÈÀòÑÀÓ }À³CóÀ“}iÀgzÀ(A¿Ò5¿'Ð>©“ñ?¨Kz@¼@Pô×@‡Š@¦`.@Å@ãˆ'AÇAœ3AgA, šA9qADÅôANWxAV°ASAKôABðA8ûYA.R-A"D¤AõAõ@ðÜî@ÒÝ@´°!@•÷@ni@0°?å0ð?O½é¾+˜9¿’ÅÀ_ÀFýÄÀ‚ö}À¢‰*ÀÂ)þÀáËÁ»KÁ—UÁ w¯Á/ÄÁ<˜ÁÁIñÿÁW§¬Áe©<ÁyÀêÁk‚ÖÁ]‚7ÁOË|ÁBnFÁ5t‚Á(ÒôÁ)>Á ])À÷'ÀדÓÀ¸‡À˜„:Àr,`À3[_¿ê#l¿[cÃ=ëú•?Šw¹@¯-@@"~@}?@œŽÖ@ºx@×ב@ôª´AhAð.A"šIA./zA89!A@¢ÂAFš+ADA>M A6 OA,Ë"A"¢„AÎYA Õ@þ-@ãa@ƽ³@©³@Œa@[ó’@bÀ?Ää??²9¾Ç¿‹¿®9À"HÀSZ¬À‰À¨T–ÀǪ©ÀçÁHRÁÁ"ÃRÁ2ŽÁAwIÁN‚,Á[ìŽÁiªHÁ~cGÁpk„Áb¸KÁU=ÁH €Á;IýÁ-_ÁÖ¤ÁŸÀüÕªÀÝŽßÀ¾o¿ÀŸS\À€6ùÀBq€ÀãS¿Žà¾ l?KBÇ?Ýü<@+d@f'&@s @­(š@É4@ääƒ@ÿY›A !A™A!ýûA*½îA2znA6ª2A4À¼A/·ÈA(æcA ›A‰}A I°AJ…@ë† @Ñî @·DŽ@›Â°@ @Dò–@ *›?œ¼˜>‘©¿*k ¿Î±tÀ$›áÀb ÀZ–À¯e,ÀÎoÁÀí|ŸÁUCÁûõÁ%¦ûÁ5ZwÁEhÁSèjÁaŒÁnuKÁðÿÁvçÁh’öÁ[`–ÁN“nÁ@UÀÁ0º.Á!+QÁ ÁÀå$-ÀÆäÜ?®¼0@@KLÿ@‚#@ºÿ@¸°}@Òš@ëÍA‡A ŸRAăAû;A#ÁÊA&º8A%3óA ÞùA¿–AÞA åÐA$Ï@ëá·@Õc@¾þO@¥lº@‹e¦@`³@(ú?àÓ¹?Yƒi°¿~r€¿öÐRÀ7ÚNÀt˜EÀ˜±WÀ·9ÊÀÖ ŽÀõ-îÁ šÁ¡åÁ)'/Á8¬~ÁH9ãÁWÓîÁfÝÏÁt Á„سÁ|>MÁo«ÁbW…ÁS’ÁDÁ4‡ÍÁ% åÁ¥@ÁHlÀíÜTÀÏ^îÀ°ñªÀ’ ÍÀi%“À-}>¿ä‡¿]«Ø=Ró“?q#+?ê8–@,ïÿ@cSŠ@Œ,J@¥œ]@½ÚÆ@ÔØ@ê-ç@ýJA$jAÑA£žAÊ?A‚AAÐ@A 5¦A™J@ú,¨@ç\@Óen@¿I@¨|E@‘ì¬@qÎ{@>§@ñ;?¥`?>Òà.¾óxø¿¯ö‚ÀkbÀMâ‰À„±îÀ¢—ÊÀÀìÇÀßXæÀýÐjÁ)/Á„àÁ,ûÁ<ÁL¼Á[ŽsÁk*ÁzhÍÁˆ'ÊÁš9ÁvpàÁgEÁWoÁH- Á8Ð>Á)ÈÁE÷Á UÀ÷¿tÀÙ¢ÏÀ»ÃµÀžˆÀ€‚±ÀF4À ¸–¿¥vÓ¾Ï{>óOÿ?ª@ :@?(+@q0@¡¾@§§…@½[@ÐÓ£@âVC@ò–`A)A-bAÚEAÐA‡@úõ&@îmƒ@ßý›@Í´a@ºÆB@¦>@‘àÆ@vÕC@I¶@&°?Ë/è?D»š½£x¿oW¼¿èƒøÀ-HÀf¼íÀm‹À®9ÀËÔâÀé–·ÁÍ¥Á€Á"<…Á1{?Á@ºxÁP ˜Á_nþÁnæ\Á~kÁ‹Ø Á… Áz´ØÁk[òÁ\1ÁLÜxÁ=¥ÖÁ.sMÁYÈÁd£Áƒ8ÀåYÌÀÇåÀª~‰À^ÐÀa¿žÀ(ÿª¿àè9¿dêZ½H|o?G÷Ñ?Ëœ@@FÑn@tÜü@û@¤Vº@¶c¶@Ç@ÖK½@âžÉ@ë%e@íÔ˜@ìÉ@æ5%@Ý €@ÑD€@Äy‰@´Lå@¡DÃ@â@s:@It†@±ü?ß%–?yû—>?˜¿Ã¿¹å°ÀQþÀJmÍÀoÿÀž‹ÀºÊôÀ׬<Àõ7-Á }eÁaÄÁ'KÀÁ6\ÁEÙÁTÏjÁduÁsMÁJ~ÁŽõòÁ‡TêÁrùÁp@…?tK?ؾ¾@jí@Eë5@oE|@Š"—@›#€@«.@¸Ü¬@Ä1`@Ë”@Íê@ÌMÔ@Ç$ @¾ÙÎ@³íu@§0:@™0K@‡À @iªL@AûÃ@q*?ÞNÿ?„× >«|&¾ÙG&¿›oBÀ,ÉÀ4É4Àk+ÀìÀ¬‡IÀÈÉNÀå}Á¹Á…uÁ3Á-vÁ;úCÁJà,ÁY×hÁhïÁx"yÁƒ±PÁ‘ilÁ‰ÎìÁ‚<ìÁuq²ÁfˆNÁW§ ÁHÌÁ:5Á+TåÁ¦ôÁ1üÀÿæØÀãÏÀÇC]À«*»ÀÖzÀi—mÀ4\­Àb࿜ž¾èâÊ>j‚?ãx?׈è@&W@;X8@^aå@Æ•@Žà¤@›j.@¥m @«õÄ@­ý@¬|Þ@§À¼@ c¢@–,'@ŠF@zGh@Z¹¶@6ff@dc?ÐfÄ?~‚Ÿ>¦Óʾ¿ ¿‰g„¿é¡_À'TÍÀYÁíÀ†™KÀ¡zCÀ¼«pÀØ/ ÀóØ;ÁûÁtÄÁ$ÔÍÁ3>4ÁAÛûÁP­Á_’ÎÁnxœÁ}eÁ†3ýÁ“ÿ¥ÁŒ…’Á…ÖÁ{H‚ÁlzÃÁ]À]ÁO…Á@`ÉÁ1óGÁ#¶FÁŠfÁdÀò—3ÀÖûÿÀ»îwÀ éNÀ†Æ‹ÀYŸŽÀ(ª¿îtŠ¿‘ }¾ÓÓÙ>Œí—?kþZ?Ä9è@|Ê@'áz@GgÜ@c@zôÌ@†r@Œ2»@Ž@Œ«é@ˆW&@œ@p¡F@YQ@?¦£@$£@PÝ?º÷˜?[Ô*>f°¾Óö4¿Šå¿ä]ÀêÀNxzÀ€tùÀ™«‰À³ >ÀÍÃÀèíÁöˆÁ¹ Á–éÁ+ÍÛÁ:.ÁH’1ÁVû¬ÁeÝÁtM!Á•¬Á‰“Á–å„Áw ÁˆõÁ€¸ÃÁr¸uÁdÿÁU´“ÁGyaÁ9MåÁ+&VÁ pÁöÁˆœÀèÆÀÍ^‰À³^ÀÀ™žÀÀËÀQZXÀ"öοéé\¿‘ù¾ù9T> a—?7Ø?Ÿø¾?ââ@­@(2@>6Û@NâÓ@X–ß@\FW@Yµè@QÄé@ErÑ@3ì‹@`V@¢×?×6+?™5Ù?' =ŽkÏ¿ MZ¿–¿1¿éasÀ¿“ÀL{Ày7ˆÀ”·À­?‹ÀÆvÀß²ÖÀùÚ6Á AÀÁ×2Á%˜ Á3ZÅÁAKÁO‡Á]ë9ÁlQ‚Áz»]Á„¢µÁ‹ûÁ™î‰Á’‘VÁ‹6åÁƒíÓÁyvZÁk< Á]dÁNè©Á@ʧÁ2ÉßÁ%oÁ—Á ÀùûÀß÷¤ÀƘrÀ®(ÁÀ•ϰÀ}hÜÀOnàÀ"×Q¿ò›×¿¡$n¿,r½ý†>Êå›?aPÆ?¨é‘?Ùs”@Õ…@3Ö@ÈH@lp@ý@Û‡@ªØ?î0÷?ÅŒ ?–I(?CÅÉ>©Êµ¾<ÞË¿:*˜¿©½Ž¿ù7oÀ%0ÀNâ­Àz šÀ“dJÀ©Â\ÀÁÀÚ Àó@­Á;žÁ/Á ^{Á-È÷Á;wÁI:ÁWÁeÁsE&Á€Õ3ÁˆuÁ=—Á‘Á•Î#ÁŽœ±Á‡ûÁ€jqÁr« ÁdŒúÁVsÁH²´Á;*˜Á-©¼Á RáÁLJÁN…Àó¥iÀÛ7·ÀÂýèÀ«ívÀ”ôŠÀ}&SÀSt¬À*yÀs‹¿¿›®¿zD¾ð)Ò»Ì >Ì~q?B°?†4¯?¢L×?±óc?¹ ?´ä$?§hV?‘Í?fÕ?$¥>ƒBë¾;¿ Ee¿ƒ6F¿Èm‹ÀCÀ.0íÀVdÀÁÀ”ŠPÀª,ÐÀÀŠÍÀÖíòÀî,fÁp]ÁŸÁ çÁ)`%Á6‘ÁCÖ€ÁQY Á_tÁlá*ÁzµáÁ„aNÁ‹‚‘Á’´çÁ ~¥Á™a¬Á’L0Á‹6ïÁ„'§Áz9ýÁlX¸Á^¾pÁQ=ÿÁCƆÁ6 ßÁ)›PÁµçÁZfÁ#WÀð18ÀÙ&ÏÀÂ1£À«»AÀ–Í·À‚8À]ÊfÀ8dIÀdU¿ê~¨¿­~ó¿hµü¿á¾?P¦=«åK>È>ÉXØ>ä’>Ö;>£‰ó>Ò½… *¾±"Ý¿-俆Ê@¿»uÁ¿óZgÀ×ïÀ<ŸžÀ`ÏÌÀƒÑîÀ˜.À¬ÿÀÁ£JÀ×SSÀí±PÁ;Á ¨ÁÁèZÁ&jîÁ30Á?°ƒÁL¼ËÁYþáÁgWVÁtøåÁ`nÁˆF6Á6wÁ–A.Á¤-ðÁ‹Á–ÑÁŽûÐÁˆ°Á*)ÁtÒKÁgS·ÁYý*ÁLðrÁ?êÈÁ3+­Á&â×ÁªÑÁ³›Á1-Àïn¼ÀØêÀÃáÀ¯8À› ÀˆÖ˜ÀnEÆÀMØÀ-åÀ?¿ê$ó¿»ù¿’f<¿bßH¿4Oˆ¿î¿ 烿G ¿+F¹¿S°ç¿„ 濦#Á¿Î„ž¿ûËÁÀÎRÀ1ú~ÀPj2Àr#ÉÀŠÀùÀ°µhÀÅoÀÙ™÷Àî¼CÁ<ëÁ kêÁ¨ÜÁ$>¡Á0hXÁ<Ö×ÁIkzÁV ÈÁbõ_Áp.Á}r&Á…t!ÁŒPGÁ“6 ÁšêÁ§éúÁ Û«Á™ÝÖÁ’úYÁŒ3MÁ…t Á}t„ÁpGVÁc@ÁVEdÁI«Á=kÐÁ12£Á%OdÁÏ©ÁUëÁÀðø™ÀÜDXÀÈCtÀµ‚À£ïÀ’€.À‚£ÀeÓ%ÀHùøÀ/úwÀœÁÀê<¿í쟿؇¿Ìä$¿Æí¨¿Èç\¿ÔŸ¹¿ç«9¿ÿÌxÀGÁÀ#a3À9¡kÀQîÔÀlg3À„IßÀ“׈À¥7ÑÀ¶Î—Àɺ ÀÝ™™Àñè°ÁYxÁ êžÁÐ-Á#ÿ+Á/CUÁ:Ö”ÁFíÁSKÿÁ_Ñ#Áll&Áy:µÁƒ.–Á‰Ï«Áy|Á—BöÁž%ÜÁ«¹íÁ¤Î·Áý§Á—>9Á¾Á‰ÔýÁƒKŽÁy¹Ál­NÁ`1ÁSõ&ÁG¾Á;ë®Á0n6Á$ôwÁ«^Á ªÁ«sÀõ"gÀâ-sÀÏyXÀ¾pqÀ­ÝðÀžHÀMnÀÚ`ÀkÉÿÀV!ÀD¥iÀ5æJÀ+v÷À&@©À#sÇÀ$3êÀ)ñÇÀ2¾ÿÀ>AâÀN|À`N¸ÀuÀ†6§À“DzÀ wDÀ¯§þÀ¿ð¢ÀÑ]ÅÀãOlÀöc&Á@HÁikÁåõÁ$wÁ/cnÁ:’mÁEÞ[ÁQoíÁ]rÛÁiǼÁv=tÁhªÁ‡ÄÔÁŽH&Á”ç>Á›‰šÁ¢A˜Á¯Ë­Á©hÁ¢IÍÁ›‘°Á”÷ÉÁŽsrÁ‡ñgÁŠÁvºöÁj~½Á^M²ÁRˆgÁG ÂÁ;“Á0HÁ%ŸÉÁ5#Á çÁlpÀüØÀê`³ÀÙÎ2ÀÉm'ÀºshÀ¬ÍÀŸLãÀ“ëâÀ‰¯+À0KÀtóµÀj÷ÀfëÀcpºÀd ÙÀi“²ÀqÕªÀ|ÝlÀ…ó ÀŽžÀ˜®ËÀ£ê›À°C×À½‰ÃÀ˽$ÀÛåÀìÀý¤˜Áï¥Á‘Á´hÁ%çäÁ0rrÁ;ÁEö°ÁQ%±Á\yÂÁh EÁsü©Á€$)Á†X}ÁŒ›ÊÁ’ðÁ™g*ÁŸþÑÁ¦ 0Á´ïÁ­V[Á¦¬Á wÁ™›WÁ“ ÁŒÌ,Á†¢‘Á€„BÁtà‚Ái%ÒÁ]«OÁR1‘ÁFåpÁ<3‰Á1¾ÔÁ'‹±ÁÂ'Áe#Á 7ÔÁß:Àõ0UÀå ÀÖÛFÀÉ,¦À½!À±òÄÀ¨wgÀ )fÀšÀ•VèÀ’ð%À‘¶×À‘õÀ”šÎÀ˜ŒKÀÓ/À¤áØÀ­8zÀ¶ÇüÀÁÞZÀÍ{fÀÚ¡ÊÀçñ³À÷ãÁq¼Á TÁÕÁ;ëÁ(“Á2(‰Á {Á4úÁ*ºÙÁ!h/Á×[ÁŽÁr ÁþŸÀó‹ÞÀæžÀÛ cÀÐ2{ÀÇTþÀ¿F0À¹‡EÀµ=vÀ²ØTÀ±µPÀ±åjÀ´kÄÀ¸-ÁÀ½CfÀÃÝ ÀËö¸ÀÕ<ŠÀßÍdÀëÀ÷ ðÁpaÁ ˜5Á;‚Áz§Á"?jÁ+A3Á4ŠíÁ>txÁHœªÁRúFÁ]‹lÁh!­Ás3Á~OîÁ„تÁŠ {ÁŒùÁ–¨ÙÁœÓ¹Á£ LÁ©OôÁ¯±¿Á¼ó°Á¶oGÁ¯ï:Á©Œ6Á£M˜Á,ØÁ—=Á‘KÁ‹1Á…t4ÁnªÁt!DÁi[ Á^ÕûÁT‰\ÁJŠ‘ÁAÁ7³¾Á.ÑßÁ&†<ÁJWÁ”úÁ4‘ÁJUÁxÀùEÀîÅÀæ2”ÀÞŒDÀÙÄÀÕ$ÂÀÒÀ„ÀѳÊÀÑÚeÀÔ<¹À×Ï8ÀܸÀâÿ½ÀêãÀó³LÀý¼oÁ{ÚÁ ` ÁÿÁ¶ ÁFäÁ'ðÁ/ÎÁ8rtÁA~‘ÁJã!ÁTè™Á_ìÁi†ÂÁtèÁ~±¯Á„Ø:ÁŠszÁ&°Á•î€Á›ÖÁ¡ëpÁ¨)Á®FèÁ´…ÁÁ—/Á»lÁ´Æ÷Á®‘TÁ¨rÁ¢SåÁœRvÁ–€ZÁÃ{Á‹›Á…_ÇÁîËÁue„Ák RÁa ÁWfGÁN BÁDå°Á<~]Á45AÁ,1áÁ$ÉÁ‹ÍÁ÷’ÁrÁ ŒßÁ½ÁˆÀþ>Àø¡vÀõ Àò©Àñ²CÀñÒGÀô ýÀ÷p®Àü,òÁ 3ÁèõÁ &ŠÁ ðÑÁuÿÁ9Á Á&!Á-Q×Á4óÓÁ<÷¾ÁE­dÁNªœÁWÁLÁaIÆÁk\ºÁuÁ€  Á…R3ÁŠ¡Á!ÛÁ•¿nÁ›tÅÁ¡<±Á§âÁ­.eÁ³VÁ¹„wÁÆSBÁÀ@Á¹ÖlÁ³·8Á­šíÁ§Ÿ0Á¡Ï¥ÁœÁÁ–UâÁ¯Á‹A½Á…ûwÁ€ÈÇÁw}ŠÁm¼ŒÁd^ùÁ[=ÁRv˜ÁJ->ÁAÿ>Á:YäÁ2ûÁ,.Á%¾ˆÁ ãÁ­ÃÁ+¤Á†ÁÃuÁ ÐÁ y¬Á JÚÁØ_ÁæÁ òÑÁ ŠvÁ ÙóÁÃÅÁ`sÁ‚6Á(ÜÁ"m„Á(ìÁ.šÁ4®5Á;snÁCVÁJ¯îÁRýöÁ[ÜwÁdâÅÁnŽÁw¸Á€èmÁ† Á‹OÞÁ˜qÁ•éœÁ›k|Á¡ ¼Á¦ÂçÁ¬‹Á²joÁ¸rÃÁ¾˜˜ÁËC¥ÁŲÁ¾üoÁ¸ãÁ²ì]Á­üÁ§bÁ¡¥(Á›þPÁ–ŒãÁ‘DäÁŒ HÁ†ýªÁ‚Áz´°Áq[™ÁhyµÁ`%_ÁWá°ÁOóØÁHˆtÁAR Á:£|Á4¦0Á/TÁ)í°Á%šoÁ!‰ŒÁ†ÐÁïÕÁmRÁCÁ×›ÁãÁáþÁc9Á¨›Á m•Á#äÁ'é·Á,d Á1fåÁ7fÁ<¶½ÁC-äÁI×ÁQ zÁX­FÁ`‹IÁi×Ár<Á{$Á‚.Á‡ÝÁŒ"~Á‘N Á––Á›Þ¯Á¡2DÁ¦µÁ¬XQÁ²Á·ÙhÁ½µ‹ÁøbÁØ4©ÁÑÁ'ÁËiÑÁÅ1aÁ¿-Á¹ Á³¤Á­$!Á§m{Á¡çsÁœræÁ— úÁ‘ÜeÁŒì7ÁˆªÁƒt“Á}ÅÿÁuºÁl÷‰Áe>ˆÁ^Q+ÁX=dÁRVÁLõ!ÁHqwÁD™¿ÁA^IÁ>nåÁXŒÁAâ{ÁE£ÁI‡éÁN9«ÁTÁZ€5ÁaÁhY4ÁpwÁxìÁ€Ì#Á…hHÁŠ<öÁSÿÁ”™åÁšõÁŸ­Á¥4jÁ« LÁ± “Á·0úÁ½z*ÁÃË¢ÁÊ EÁÓ±òÁÍðÁÆŸÁÀ=tÁ¹ýqÁ³àãÁ­Õ…Á§ÌŽÁ¡å¬Áœ. Á–«Á‘7þÁ‹ÔøÁ†±œÁÆ>Áyí©Ápº´Ág¦€Á_:'ÁWVˆÁOøNÁI€ÁC˜œÁ=ÞâÁ9$ŽÁ5"{Á1Ã¥Á.ɰÁ,“Á*õõÁ)í¬Á)JìÁ(ÒÁ(ažÁ'íÁ'«ÑÁ'Ú¨Á(pÈÁ*!ÚÁ+ô"Á.ÏÁ2€¾Á6@­Á:döÁ?tºÁE¢ÁL ÁRï ÁZ­ÎÁcÝÁk›7Át¹šÁ~CÊÁ„,×Á‰i0ÁŽÛéÁ”W[Á™úöÁŸÒ-Á¥×ŽÁ¬>Á²TÆÁ¸§&Á¿%ÁÅx=ÁÏQ¼ÁȧýÁ†Á»sÁµŽÁ®Í)Á¨ªÁ¢žºÁœ”‡Á–©ãÁò|Á‹qÃÁ†}Á€£‘Áw•Ám@ŸÁc¹×ÁZ޾ÁQ¢”ÁIƒðÁAá¹Á:ð0Á4Þ0Á.ò)Á)Þ+Á%ÄdÁ"2[Á,xÁÉõÁ-WÁFÁmqÁÿ’Á›îÁæÁÒÁý²Á¡JÁ[ Á< Á\‹Á#Á&ë5Á+j Á0æžÁ7M>Á=Í(ÁE ÁMC¿ÁU­»Á^¤Áh íÁr“Á||9Áƒ«€Á‰"úÁŽÅÁ”žàÁš©ñÁ àÂÁ§3Á­†HÁ³è'ÁºiØÁÁéÁË"ÁÄVOÁ½¥Á¶ûÁ°g¨Á©óÁ£¡HÁvµÁ—jÂÁ‘`DÁ‹qkÁ…¹¿Á€q`Á4IbÁ*¤Á!Y¯Ár&Á­]Á OêÁÇqÀù½¶ÀïžVÀ状ÀੱÀÛ„ðÀØ`ÀÕĪÀÔ" ÀÓQ^ÀÒãÀÑÁ×ÀÑ™ÀÑK&ÀÓòÀÖx–ÀÛ!ùÀâ…aÀê$Àóâ¯Àÿx:Á/Á ÔªÁ©6ÁÔŸÁ%ÏžÁ/²ÌÁ9ÔÁDp¥ÁOR®ÁZˆ­ÁfN Ár}Á&ŽÁ…èÁŒGhÁ’¼›Á™J ÁŸäSÁ¦lUÁ¬ÿÁ³®îÁ¿7óÁ¸3êÁ±E9ÁªjðÁ£”tÁœÊ’Á–»ÁUSÁˆ¸oÁ‚CfÁwøçÁkϯÁ_ÁQÁSÌñÁH^»Á=€»Á2¼.Á(@jÁ ¤Á…ZÁ K,ÁÌÝÀö¶VÀèiùÀÜv:ÀÑ[ŽÀÈâ™ÀÁoNÀ¼^ÒÀ¸Å>À¶bèÀ´ÈäÀ³ÍTÀ³svÀ²T’À±×ÜÀ²þÀ³îëÀ·Q-À¼–‹ÀÃó?ÀÌËÀÖæŽÀâý‰Àð ™ÀþÀ¹ÁSÁáÁ›kÁ#¹UÁ.(¾Á9IÁDUÁP!Á\kNÁhû6Áu¤ÆÁ9kÁ‡¯ïÁŽ7[Á”ÁÖÁ›FsÁ¡çÁ¨¥JÁ¯i¨Á»’?Á´ˆ½Á­vÁ¦wÁŸ·Á˜´RÁ‘ßÅÁ‹ Á„fMÁ{u"ÁnmÁaÆçÁU‘ÈÁIˆ,Á=—Á2%Á'VcÁœ)ÁÎÁä†ÀýÀêÎÍÀÚùÙÀÌ¥À¿JzÀ³²çÀªs$À¢RiÀ8´À™kÀ—&À•qÀ”háÀ”_À“ ¡À’£À’Ò,À•vÀ˜fêÀžMTÀ¥ëÀ®†îÀ¹ù=ÀƘ‰ÀÔ¬RÀä8ÀôgÁ™Á ¤mÁë‡Á"î¨Á.<òÁ: ›ÁFIŽÁRÏéÁ_€cÁlVÞÁy/~Áƒ‡Á‰˜fÁ'Á–Ø]Áœ–Á¤a–Á«/…Á·ÁùÁ°ºÁ©·Á¢ÂíÁ›¶¸Á”½­ÁÛ±Á†þÁ€1jÁrôSÁe™ÁXoUÁK­AÁ?gòÁ3ežÁ'oÁÅÁ6ËÁ…&À÷÷°ÀãßõÀÑWíÀ¿¶ùÀ°˜À¢UÀ–Å=ÀŒn¦Àƒ¡ÀÀ|%,Àt#wÀo?¨ÀlDÀjg›Ài QÀgÆ%ÀfÞÀgaYÀlk)ÀsbiÀ€AçÀ‡qHÀ‘›ùÀEŒÀ« óÀ¹ÿ…ÀÉÚÂÀÛ¥öÀïgóÁ϶Á ÕÑÁ0cÁ$ªÁ0+Á<¥7ÁIThÁV;ÁbÌ}ÁoÛêÁ|àlÁ…¦Á‹ÏƒÁ’“äÁ™\7Á :Á§1±Á³üþÁ¬íÀÁ¥àhÁžÚÎÁ—ÝmÁñÁ‰øiÁƒëÁxOVÁj˜Á]×ÁOÍ3ÁB–æÁ5´×Á)[Áb Áo»Á¨Àö.hÀàÞËÀËísÀ¸zÀ¥ûWÀ••À†zÀsç×À]_ÀKLÀ=êOÀ5zLÀ0Ÿ“À-à§À,±À*r„À)wÀ(‰³À)˜À.¹gÀ6âEÀDu¬ÀTãÀiÇ~ÀtÀÎÀŸ§bÀ°¨¸ÀÃÛ‰À×ÒNÀí˜+Á$OÁ ÷»ÁÁ&[VÁ3]Á?ŸeÁLv—ÁY‰ Áfž)ÁtáÁ€ÆÏÁ‡Œ[ÁŽ`ÙÁ•R4Áœ]oÁ£~øÁ°OQÁ©/-Á¢®Á› /Á“þñÁŒüMÁ†¾Á~GÁpwÁb¥ƒÁTëSÁGUòÁ:§Á,âÁë]ÁxlÁiúÀöîŸÀàˆÀÉï°À´·¾À ?ØÀRgÀvåÀW)bÀ:F“À"î7ÀAŠÀz ¿íó$¿äu¦¿ÞúÚ¿Û7¿ØØ'¿ÖQ¸¿Ôv¿Ø ©¿âH¿õhÊÀg‰À¢ À0ÜÀLU¡ÀjèÀ…ìÀ˜gÌÀ¬3ùÀÁÀaÀØ1þÀïÙŠÁÏZÁ5Á•ÇÁ)0¨Á62hÁC65ÁPoÅÁ]óxÁk|´Áy ÁƒsÍÁŠ{Á‘›ÉÁ˜ÄôÁŸîÁ¬Ú)Á¥ýÁžkéÁ—L‰Á8Á‰*Á‚¿Áv=ãÁhaþÁZ´®ÁLóYÁ?.¶Á1©ØÁ$FšÁ»å>L>gªí>y C>‡B}>‘xñ>q‡> ÿf½)R¾—¨&¿"Ç¿†|R¿ÄAÀHÊÀ)ÃOÀSqdÀ~M–À–lÆÀ®IGÀÆaˆÀßH·ÀùÁ ŽhÁÀØÁ$GêÁ1Ò9Á?yYÁMoÁ[ªÜÁiý-ÁxO‚Áƒ[iÁŠ£ØÁ‘ýdÁ™[Á¦KWÁžèæÁ—–sÁRøÁ‰FÁÚÁuJ;ÁgÁXé¤ÁJÎóÁ<¹Á.ÔòÁ!âÁ‰‹ÁÑyÀð}ŒÀÖS£À¼¶ØÀ¢ÌtÀЍMÀe®¯À8DÀ ¹¿Ã¹º¿o+¾¾áÙ=ê®?k‹?P_è?‚6?[|?•¬“?˜¿Â?›"&?Úl?ŸÕ?˜ø8?Œ¦G?gTê?¨>>v݆¾L‹¿34 ¿¥b ¿õÀ%S«ÀSR À3,À™VGÀ²c¥ÀÌsÀærÁ­ÅÁ6ƒÁË[Á)­½Á7äŸÁF6ÐÁT‰%ÁbôæÁqÝÁ€$ßÁ‡‚²ÁŽàMÁ–C³Á£rUÁ›îÄÁ”wwÁ~Á…¶ÕÁ|âÁnh©Á_ð%ÁQƒuÁCJÁ5&Á' ÏÁûZÁ +5ÀúódÀßásÀĈ´À©Û”À!GÀmqÀ<:>À Í]¿½&¿Kç²¾ P>Úß‹?tAÿ?³¦ì?߀l?üG¢@Š@Ѓ@ E@ œR@ ò@ fý@ ßÇ@œR?êA%?¾ñ?‹ÀC?Šl=¥f*¿v“¿˜°Ó¿òìÀ(F¤ÀXÃÀ…·jÀŸÍNÀº'?ÀÕ8¸ÀðOˆÁïVÁÁ"psÁ0ÂÈÁ?4¬ÁMÜïÁ\˜µÁkT{ÁzcÁ„qYÁ‹çÁ“dçÁ ¿åÁ™7ºÁ‘¯šÁŠ'ÍÁ‚§§ÁvmkÁg°ÍÁY?ÁJ¤ÆÁ<,AÁ-¼¸Á…Ác^ÁH¬Àê‚qÀϹÀ³»¶À˜¯ÑÀ{ÞÀGlÀì ¿Äü¿HGb½ŠIë?w½?.?ã†S@v@*B7@:ò@C2î@Fó$@H*F@Iô2@J÷@Jãl@GCq@>å€@/s@ ?øâ¯?ºF6?Z¦A>Xu¾õ÷¿œMà¿ýN&À2GÀfOÀŽmÀ©wÀÄj¸Àà²ÀýT-Á üoÁwNÁ*+åÁ8ç«ÁG£qÁVcÿÁeGVÁtAÏÁ¦nÁ‰2ŸÁ©äÁž>Á–ˆcÁŽý¯Á‡u„ÁÚ±ÁpÊpÁa»§ÁRÅ‘ÁC÷Á5\OÁ&àâÁh^Á öÀ÷€ÀÛ@tÀ¿ À£! À‡µÀY&À"ü\¿ÛÄ¿i¼ÿ¾ò‡?¦²?«nF?þ›F@&@GÁ@c@v‡ø@î<@‚s@ƒ‚@„&@„Pg@„/î@‚SŽ@{.®@iÎ>@P²&@3Ø@îê?βq?n*Ð>?ŒD¿/Ê¿±÷-À  FÀCÃ7ÀzoÀ™)ÀµÇsÀÒlNÀï~¸ÁzÛÁ6¡Á#ò½Á2ÁÒÁA¹ÕÁPÇaÁ_â%ÁnèéÁ}Û¯Á†tÁŽ<Á›ÊÁ”2ÁŒpgÁ„ÑÁzy}ÁkfœÁ\VEÁMEîÁ>5­Á/)ËÁ DÁ™êÁÿÀéHöÀÌ^îÀ¯öÀ“º-Ào ”À7 ²ÀÌ~¿•aÁ¾¦>K>øq?¤@™#@.ìŒ@Xƒ @}ÿ@Ž%¢@™f·@ž¡V@¡l–@¢=¯@£R @£]#@¢ÞX@ ÚÙ@›jW@‘ÿª@„nƒ@gH@A2 @ÔI?Ì0ñ?Q_¸;ŸÔõ¿Uj‡¿× 4À#M[À\usÀŠàÀ¨ÀÅ“¢Àã PÁF Á1åÁC{Á-_Á>Y©¯?‡dÉ?ñ@+ÎÖ@[æ@„.Œ@˜Î@©ÖÂ@²ùY@¶å%@¾ûÚ@Ávù@Â~@²ñ@Á×Q@¿-S@¹=,@®¯ä@Ÿ®Ø@…m@p@@8-@ £o?²æ? ¬ ¾¢z—¿š·ÿÀªÀAtÀ|cÀ›« À¹ZwÀ×pÀõ²_Á ÷ˆÁþ]Á( -Á7;eÁF€žÁUÇëÁe8ÁtWsÁÐ'Á‰yÅÁ—¶WÁîÁˆ,HÁ€p¯ÁqxûÁb ÒÁR‘ÁC.Á3¸Á$qCÁMoÁ=ÀîYÀÐ8ÒÀ²VÀ”;ÀnTâÀ4rÑ¿õ!€¿ƒŒ ¾³í?;(;?ËD&@ýà@Q©@‚±@›“@±P@Äò@Ç@Ê${@Ñï@Û-@áª@â–@ÙÉ@Ò®@ÏŠè@ʱß@¹Â!@¤ñ'@,¦@fîð@1S—?õ]j?ƒzé>ó¡¿J¿t¿ÛC‹À(¬âÀd©ÀŒøÀ®ÏWÀÍ·Àë?ŒÁÛßÁ#,Á#gKÁ2¢QÁAçSÁQEñÁ`¦Áp/Áb^Á‡d%Á•òŸÁŽ!eÁ†S-Á}ÃÁmw_Á]å ÁNa Á>îôÁ/Š,Á Á›ÅÁ)½Àã²,ÀÅqXÀ§PªÀ‰/üÀV›ÀÙÜ¿¾Šª¿>£öi?š@±O@=kq@tCu@•0“@¯o²@ÈB"@Þº@Ý\D@ß÷•@åê@îíB@û ã@ø™ï@ïg¿@èö9@æd@åîž@ÑÛ)@º!:@ŸÞ@„Ên@PÖè@b?¸%?{ ¾ÔÔŽ¿­žFÀSâÀOØ À†YÌÀ¤Õ&ÀÃK1ÀáÁ=Á¨ÁkÊÁÕøÁ.A¶Á=¤üÁM©Á\lÁkà]Á{`ƒÁ…rÁ”aêÁŒ‡ýÁ„­VÁy¦IÁiøÎÁZR*ÁJ²>Á;ÖÁ+‚rÁíNÁ j4ÀùÿÜÀÛ/ÙÀ¼>aÀLèÀ}ÿÀ@¦ÀNJ¿Û¾<¹??(á?ÓX“@#ŽZ@\S@Š^î@¦j@ÁVQ@Ü ì@õi²@õÚæ@÷ˆÊ@üÖRAŽËA ’A£VApSA¦²@þè¿@þÓ@æÆû@Ìè@¯ñ@’ãq@jÓ@/t@?æà_?[Û®½±ºZ¿… ‚¿ÿ!BÀ<{íÀygÇÀ›-éÀ¹ôµÀØÌ0À÷£«Á 7FÁ™üÁ* qÁ9’ŒÁIÆÁX« Áh8 ÁwÅ ÁƒªäÁ’ßúÁ‹’Áƒ%Áv–5Áfâ[ÁW.‚ÁGz¨Á7ÅÚÁ(·ÁdýÁ¿¥ÀòIÑÀÓ À³ì™À”ë®ÀlD}À.Šp¿áNý¿K5>6??Œ @F@>‡y@x»Ö@™Nô@µ¯Ò@Ñå5@íWA4àAÐdAiŠA ²äAˆ1A…ßAÃA÷©A zBA ZðA š™@÷p@ÚCµ@¼Á‰@ž¿@€ Ü@D®¸@“?•>YÛ¿=6O¿ØõéÀ*)êÀgØàÀ’ÃëÀ±“ ÀÐm+ÀÁL“ÁØÎÁ&eÁ5ñæÁE„ÇÁU'dÁdÔ6ÁtªÁ‚ŽÁ‘oÁ‰ªÁÅØÁsÃCÁcúÖÁT2iÁDn[Á4´¼Á%âÁM Á™/ÀëÊ«ÀÌbÀ¬öNÀ£ À\¿íÀb]¿À ™¿n>Ûµú?²•§@-Å@Tn@ˆ+å@¦L“@ÃäD@àÖº@ý6A åA'åA³aA¬ AšAÅÿA ‘ÂA ¬A¿AÖ×AÑüAãu@åÄâ@Çi@¨Û6@ŠQT@W·]@Ì?ºk >üV„¾ñð¿·™Àˆ<ÀWµ€ÀŠñxÀª/ÀÉçÀè:WÁ¶‡ÁaýÁ#‹Á2ÁÿÁBs ÁR$‹Áa×Áq[Á€¨«ÁGâÁˆ`ÍÁ€y¹Áq$ÓÁaW[ÁQŽïÁAȽÁ2Á"8²ÁpEÁ§ØÀå¾ÔÀÆ>úÀ¦× À‡omÀPsÀ@ ¿¤áM¾œ·j?,?Òâ±@'Îé@eŸ·@‘¡@° @Ï4¼@íUjA²ÐA/@sä¤@™\À@¸¢‡@×ÑO@ö®aA Å·A/!A)?xA1~üA37A5ËœA9ÖiA;¨WA8¯A6›‚A*8^AóA ‹h@øF@Ùu@ºŸF@›œ@xÇ]@:/Ñ?÷0?tí¼Ëgú¿€h¿ýþÀ>.RÀ}vBÀž_À¾Àݧ ÀýKÁyzÁMÞÁ."CÁ=öÔÁMΉÁ]©ÆÁm‡ÕÁ}h/ÁÜÄÁ…ñTÁ| ÈÁl4èÁ\_”ÁLÁ<ÀÛÁ,ò²Á$ˆÁ V_ÀûkÀÛtÀ»×ÆÀœ;sÀy>AÀ:š¿õ”W¿nªØ=\p!?…&ì@µ+@@Öà@ø•@Ÿ~+@¾åÞ@ÞM‘@ýµDAŽ|AA×A-Ý•A=IÏAA=LAC¾WAG€ÙAI½·AFå°A=öNA.Ž'AÉAd—@ÿx§@à.@Àãˆ@¡˜ù@‚J|@EQù@ú?—÷=ñ¿^è ¿íúÀ6CÀu“IÀš‰*ÀºLIÀÚhÀùÒ‡Á ÊÓÁ¬cÁ,òÁYƒV?™¡¶@ €@KB&@…>W@¤Îú@Ä^Ý@ãï¸AÀIAˆ·A!Q$A1AA@¼AO¦úAQü AU~bAXxAPñiAA?A1ˆXA!ÁÉAû;A4p@äÁO@ž@¥r-@…Êœ@LC¤@ î&?›1P>cn[¿E8 ¿á¥×À0WÔÀoܽÀ—±!À·}-À×LÀ÷ÞÁ tÛÁ\þÁ+H¯Á;7bÁK'8Á[ÁkåÁzö»Á‰•Á‚ÞöÁwkÒÁgœ ÁWÌAÁGüyÁ8,&Á(U™Á~¹Á§ÔÀñ¡ÑÀÑóúÀ²F$À’˜MÀeÔîÀ&yA¿Î;(¿¹>¼LC?­‰x@ýa@U6@Š7V@©Ó©@Éoû@é NATPA"zA#ðâA3º?AC‚mASJÚA`vqAc¿³Ab£iARÚÝACPA3IÄA#ÉA¬âAØZ@è¤@È^”@¨µ„@ˆï¢@RBç@§¬?¦>›‹@¿0¦é¿×‰¹À+_þÀjû!À•K!ÀµTÀÔ÷íÀôÛÁ _6ÁPáÁ*B‹Á:46ÁJ%àÁZ‹Áj 5ÁyúàÁ†:Á‚àÁrßÁdòZÁUc¸ÁE‘4Á5¾°Á%ì+ÁÆÁJþÀìökÀÍVÚÀ­·JÀŽ À\ͰÀr¿¼,­¾õÕM?„ ?¿ù`@X]@^´ @Û@®µ²@Î^¯@î AÑIAŸrA&m›A6;ÅAF îAUØAe¦AAr8ÖAdTãATƒHAD±­A4ÞèA%bA$½AD@êÆé@Ë¡@«DX@‹ƒ@W|C@á!?°‹þ>Å"`¿‰w¿ÍÒÀ&¯±Àfv[À“À²ÿ¢ÀÒáÂÀòÃãÁ SÁDÁ)5"Á9&2ÁIBÁYSÁhùcÁxêsÁƒÐ ÁyÌÑÁl?ÌÁ^ð[ÁQÙ$ÁC/kÁ3]2Á#ŠùÁ¸ÀÁæ‚Àè'üÀÈ‚óÀ¨ÝëÀ‰8âÀS'´ÀçÈ¿©QM¾«L+?'Vo?Ò,1@(`í@g»G@“‹z@³9Q@Òç'@ò”ýA !jAøUA(Ï@A8¦,AH|MAXOûAh#9Au½¬AeßAV‚AF!ôA6CfA&d×A†IA§»@í’@Íà @­àÅ@þ@\8x@sï?¹^Ì>çVè¿ f°¿Å|ÁÁðîÁ#ضÁ1ÁÁ>ÁQÁLM$ÁZ.ÁhTðÁy ·Áj¢}Á\sªÁN\:Á@{«Á2õíÁ%á8ÁZ{Á ãhÀöbÀÖCÖÀ¶‚KÀ–À¿ÀmþfÀ.{O¿Ýð›¿>7Ç>}…t?ž}@@¤é@N 2@†¸¾@¦kâ@Æ@åËAºIAŽÌA"c#A27_AB ›AQß×Aa´Aq†©A{†Ak›•A[°¨AKżA;ÚÏA+ïâAöA  @ø^9@؈`@¸²†@˜Ý1@ré@2sŠ?å V?L³/¾Gi9¿˜ À ƒÀJÿãÀ…>ZÀ¤üÂÀÄ»ÈÀä}Á CÁ¸Á!ÞDÁ.¹œÁ<”ÁIÊ©ÁWÔçÁfÙÁw Áh›ÒÁZcUÁLn:Á>¹GÁ1"ÕÁ#ûõÁaÀÁ !gÀòkGÀÒ“¾À²¼6À’ä®Àf$ðÀ&ž¨¿Î7ý¿eS>¿M”?®Ù”@ïâ@Vrù@Šû@ª¼”@Ê~ @ê1pAòJAËÝA$¥oA4ADX“AT2&Ad‚AsÝA}¬Am0A]E†AMZšA=p@A-‡SAž}A ·¶@û«+@ÛìÂ@¼.Z@œlà@ySì@9Î?ôŽ?k Ò½˜kÄ¿ˆ’aÀÏÀCTÖÀmTÀ¡0>ÀÀöÀà½iÁD¡Á/Á Á-C½Á:¬LÁHUÁÁVBðÁdu±Áu‡Ág=¹ÁXîKÁJ߇Á=ÛÁ/ÁÖÁ"Ý‚ÁXÇÁ–[ÀïJÀÏhÏÀ¯Œ¥À·ŒÀ_ųÀ M¿ÀåÍ¿&>öÿ*?½–@2±@]Ü@ŽÃÚ@®›%@Îl'@î-‰A÷ŠAØPA&¹A6™ÜAFz¢AV[hAf;ZAvíA~Ê9AnèÅA_PAO%ÜA?DgA/bòA~A  @ÿ}(@ߺ?@¿÷V@ 4m@€qƒ@A]4@Ïñ?„‚²=)Ä¿t¨¿ùaÉÀ<\ÞÀ|ÙÀÚiÀ½°$À݃VÀýWÁ˜øÁ‰ÑÁ,š-Á9øhÁGµHÁUµ\ÁcñÁu‚ÆÁfùöÁX¦ÁJ’GÁ<ÌûÁ/h¦Á"u¿ÁßšÁ¹ÀízxÀÍòÀ­‰lÀæÀ[0ÁÀ?µ¿¶R¾Úìè?M»?Éõ@$Zn@d¹@‘ñ‚@±Ó§@Ñ­ @ñÓA«CA•œA(öA8jOAHT©AX?Ah)\AxµA€WApÌ‹A`ëAQ ¢AA(-A1F­A!cAaA—§@ãYP@ÃS@£­V@ƒ×Y@Gô§@,?cÜ>`ü¿^—9¿ï#YÀ7}ŠÀwihÀ›ª£À» ’ÀÛ–ÀûŒhÁ À–ÁºøÁ,Þ¶Á:-@ÁGÈÿÁU®ÁcÙÈÁv$áÁg«>ÁYhYÁKbÁ=ŒÁ0íÁ# ¹Áq"ÁqwÀìãšÀÌäFÀ¬äñÀŒåÀYÌ‘ÀÍ翳ž}¾Î„«?¸O?ÌYz@&+f@f*@“\@³±@Ó@óZA ˆ×AˆA)ˆ,A9‡ÖAI‡€AY‡*Ai†ÕAy†A}ÿdAr}AbˆëAR’ AB™A2žA"£A¨ A­)@ådb@Åns@¥w@…}ø@K ª@ e?–J?>3-¥¿RÿÛ¿éw À4¹Àt·ÿÀš[YÀºZ¾ÀÚZ*ÀúY›Á ,‡Á,BÁ-+ýÁ;@ÙÁH½ÁV’»Ád°UÁw;Áh˲ÁZ”6ÁL .Á>ýâÁ1°’Á$ÌÂÁ³†Á·%ÀíwZÀÍ€ôÀ­ŠŽÀ”)À[;†ÀN»¿¶Ãß¾Û©"?Þ?ÈÈå@$Q>@d$@‘ïš@±Í%@Ѫ°@ñuÇAŸ÷A… A(jA8;9AGðbAWI³AeÐØArKAqhAgLA\Û®AOpjA@|A0”ÄA ÿNAFHAyÞ@ã79@Ãz·@£¾5@ƒòH@HA÷@aŽ?â >¿]¼²¿î¾ÖÀ7O©Àw?èÀ›˜À»2ÀÛˆQÀû€qÁ ¼HÁ¸WÁ-´gÁ={«ÁJëeÁX¥ÃÁf˜¼Áy ‚ÁjÏÁ\¸ÆÁNéÀÁAq?Á4b§Á'‚LÁŽñÁž)Àï^ºÀÏ/À¯£¤ÀÆÀ_ѹÀ 2ª¿Á<º¿(?>ôQë?¼=@²Ø@]G%@Ž[ @­Üä@ÍP¿@ìÄ›AûÌAqÛA$±ºA3¯ñAB#ÐAOÏ™A[»Ad¾Ac^NA[0KAQ4AFHlA9÷¨A+æeAß:A ž%@übÜ@ÝUn@¾1Ô@žÓû@~êr@@s@àÙ?‚Ï©<÷hE¿v(οúpÀ<|<À|£ÀѼÀ½£ÀÝtUÀýHÁ’…Á„~Á.yÁ>ojÁM¹TÁ[3)ÁhþËÁ|éÁmâ(Á_ýfÁRePÁE)ÃÁ8^«Á) Á$þÁ ?ëÀòµ°ÀÒë‰À³!cÀ“W<Àg%kÀ'Âþ¿ÐÒí¿%åW>«s ?¨¬1@=Ï@R"@ˆ D@¦÷a@źj@ä3„A(üAïcAbOA,>9A9lSAE+ANÆ AVJ ATošAN0(ADËžA: úA/µ+A#©®A^÷A*¤@òÚ¨@Ôž…@¶Þ@——Ë@q‚@2çû?é'•?X@é¾ Ô¿ŽÕœÀ(ÍÀE âÀ‚ ¬À¡Ñ ÀÁ‹çÀáHiÁ‚uÁ`¶Á >÷Á0?Á?þDÁOãÁ^ßšÁltdÁâàÁqúKÁdU¸ÁWÁJóÁ:ƾÁ*ècÁÁ 8}ÀöÕòÀ×V9À·â^À˜n‚ÀqõNÀ3 —¿èK¿¿Vin>Ýç?Œ,1@îR@A @~'@3W@»&Æ@Ø]©@õ<×A‘1A5*A"æ>A.®A8 ÝAA +AFédAE<{A?°•A8ŸA.Y…A$}A!éA DeAw=@åzè@ÈÖy@«©“@¾m@^ý,@!ïß?Éŵ?@£¾´–¿©ÏÆÀ<ÀQ“MÀˆ"ƒÀ§EÀÆàÀæ>ÉÁÑÄÁ±Á"\XÁ21HÁB ÆÁQæ‹ÁaÄÁp¹oÁ‚8(ÁvÐGÁi}jÁ\oëÁLøÞÁ==öÁ-„ÁÊÁ-Àü¬ÀÝ9|À½ÙØÀž¹àÀšËÀA‘ÀêW¿Œ©Ì¾J ?N?àRÞ@,M@g¦C@Ü@­µ@ÉÈR@å<@ÿËðA `)Aó_A"]‡A+'…A2­¯A7±A5³–A0ã‚A*A!æ©AçmA ˆAާ@í¾7@Ô‡§@¹¼ã@ž b@Wª@HT@ YÃ?¢cÒ>¥ês¿!?ý¿ÊºšÀ"fBÀ`9À1ÈÀ®[áÀÍ…ùÀì°Á÷éÁ¦’Á%UóÁ5TÁD´µÁTe¥Ád„ÁsâƒÁ„ê›Á|^\Áo1OÁ_£1ÁOéÚÁ@1&Á0€×Á à:ÁTbÁÜÝÀäÍžÀÅáÀ¦÷ÿÀˆTÐÀS[À¸›¿´'¡¾ñg™>íÏR?±H@¶â@LZ’@‚nB@ý$@¹»@ÓÇ@ëŠÄAVA ìØAbAKyA#ĵA'$JA&çA!éAíA­ÑA ’As{@í÷@×öÌ@ÀÊ@§½@ÀÑ@dÎÜ@-7j?çck?f¡¼„2ô¿sy¿ò2À5‚ÀrÝÀ—ΕÀ¶U<ÀÔùãÀóñèÁ ŒÜÁ!èÁ(¶ôÁ8LÁGå ÁWŒ¾Ág;âÁvëCÁ‡ßÁ èÁroÔÁbÖgÁSLSÁCÓÁ4\ùÁ$æëÁpÜÁ ØÀí.ÀÎöHÀ°Œ>À’/„Àhj3À,ƒU¿áI¿Yx·=k­ö?u,?ìPÈ@-F'@càt@ŒzW@¥øü@¾M¡@Õqƒ@깺@ýåöAtGAñÖAŽŽA3AR©A²/A WpAÒÛ@ý5µ@êK~@Õþµ@ÀÞ @ªÐI@“¿³@uå@BÅ @ PD?¬;">ñp|¾Ú_B¿ª™¨À¬RÀK§Àƒ”¨À¡±üÀ¿åRÀÞgÞÀüî„Á »+Á Á,oQÁ;ï6ÁK€ÓÁ[ßÁjªìÁz?øÁŠ¢4Á‚äœÁvS$ÁfÝÁWgÁGö~Á8 Á)TÆÁÁ ÞÀ÷]ÀÙS¹À»`KÀlÜÀ{‘ÀE`fÀ `׿£‰¾ÅÓŽ>ô9?ªì2@ ‡@?·ä@qÙ¤@‘}@¨6æ@½™Ä@Ñ_J@ãs@ó =AD&AªAAâA‚ALõ@ü¹ë@ð¦Š@âL×@ÐË@½fÖ@¨ç`@“Å@{S‹@M]Ø@*Ý?ÓÅ…?S†¼°ƒŒ¿bNç¿á¶•À*I†ÀdAèÀP³À¬³ ÀÊœÌÀèº ÁkºÁ†`Á!ÃæÁ1:Á@LuÁOš®Á^õ>ÁndðÁ}æ€ÁŒ®™Á„ôqÁzƒ`Ák2Á[êpÁL«#Á=vÁ.F‘Á9-Á?uÁE¾Àä£CÀÇ=¢Àª1OÀ83À`ÔÀ'ÃÀ¿àD2¿dW½.ˬ?IEí?Ìý÷@ÁQ@G¦´@uø@yÍ@¤Øž@¶Õu@Ç‚@ÖV÷@âro@ë ^@î¡]@íJ—@ç|@ÞÄö@Ó9@Æ3Ñ@¶V÷@¤Z²@~•@wœÌ@MX5@!„?åÕw?„,K>‚lð¿ó1¿²¦¥ÀRÀGhÜÀäÝÀœ£’À¹›~ÀÖË=ÀôûÁÚÁá"Á&ïÌÁ5þvÁE|ÁTSÞÁc—1ÁrÞÁFÁŽãšÁ‡@~ÁC-ÁpÁ`ÞŽÁQÉòÁBÎÅÁ3ÕÁ$Û£ÁÿWÁ_Àñ²kÀÔ¿úÀ·ò{À›gÀ~ÖSÀG¸vÀ"p¿¶`3¿­9>Fh·?v£ú?ÚXÙ@ƒU@F³®@pQ@ŠŠ1@›»‰@«}ˆ@¹4@Ä‹@Ë›Ð@λà@Íe@ÈZl@ÀOÄ@µŸš@©I9@šÙò@‰÷Ä@o³.@G,§@jÙ?æLƒ?rü>üý¾¿ô“¿’”k¿øòÇÀ1Ö[Àg¡€ÀaÎÀ«8gÀÇx6Àä"aÁ‹Á"ãÁ»XÁ,vÃÁ;fkÁJsÞÁY‚ˆÁh‘:Áw®¿ÁƒrÁ‘SÁ‰»SÁ‚.ÊÁu^Áfd^ÁWj¦ÁH{Á9¶ÂÁ+xÁ™ÃÁ#àÀÿ}‰Àâï%ÀÆÕõÀ«6KÀÆfÀirHÀ4Q·À%¿›~¾ãz£>•‘/?‚3?Øç‚@1˜@< @_`Æ@€}@ŽÊA@›}6@¥”¦@«éÞ@®É•@­—ç@©@¡˜k@—¬Ò@ŒJ@}Ø@^ðs@;æ@üê?Ú¸I?†qÌ>Ç¢s¾}ü¿ƒöù¿ä&•À#SÀUc¥À…-óÀ ¨À»!ÀÖºtÀò½Á9ÁИÁ$H§Á2à(ÁAxÁP!èÁ^ù¾Ám÷øÁ}šÁ† ¢Á“ö³ÁŒy×Á„üûÁ{Ál&~Á]s/ÁNßêÁ@ZQÁ1çÄÁ#„äÁ<­Á'?Àò[À×;À»ÞMÀ õÎÀ†Ç@ÀYeÏÀ'䢿íO¿B¾Ë9 >‘ž ?oÆ®?Åóg@ôL@(ª@Gá¦@c¿¼@z­Ï@†{‡@Œ7ì@ŽÐG@°i@‰’½@‚®Ð@soº@\ê@CÌÍ@&Î@I ?Ä]1?p±ž>š\Q¾·Èj¿‚{J¿ÜE·Àn˜ÀL(À}gÓÀ—r‹À±áÀÌG,Àç!5Á<àÁ9Á áÁ+BlÁ9ÿÁH ÁVmÁe5MÁsÕ1ÁM¨ÁˆÂ`Á–ÇÚÁRUÁ‡ìÁ€˜èÁr fÁdàÁU«¨ÁGKJÁ9xÁ*æÁ÷½Á-ÅÁ‰UÀè±ÀÍztÀ³e À™•=À€ÿÀPÃvÀ"Bh¿çÀd¿2¾òr >%ø?9se?¢r?⺽@{@(¹¥@=Ð@NŽ@Y ó@]£š@[‘Ö@T ©@G!î@6uü@!Ü@ ¯ú?Ý?? 5×?5Âà>ØC¾í Û¿ÌÒ¿âVÀ…ÀH•÷Àvá´À“]À«¾EÀÄbÀÝàÀøˆÖÁ °ÔÁ*jÁ$é3Á2ÉÁ@ã7ÁO©Á]OÃÁkÅáÁzZ²Á„yIÁ‹ÆÀÁ™È=Á’xvÁ‹0sÁƒîÁyoŒÁk×Á\ÈžÁN¦!Á@­ùÁ2ÚÍÁ%#ìÁšëÁ *UÀúÙÀàÀÆ¡3À® +À•”zÀ|¼¯ÀNZ[À"L¿ñ\¿Ÿ ¿*Áø½êºî>ÎèÜ?c?ª)?Ùaß@ò=@%@¨@¦§@ÂÚ@Ê@æ=?òH?ÊO=?$Ù?S™º>¿gB½è䤿-)d¿ŸI ¿îé<À!\ÀK\ôÀuÉäÀ‘„ŠÀ¨ªhÀÀ*¦ÀØÈ¡ÀñhŠÁ=pÁi9ÁÑ–Á->Á:ÍÐÁH•§ÁV‡ðÁd¥ŽÁrÈìÁ€ˆ_Á‡Â|Á üÁµÁ•ÏÁŽ™ðÁ‡l=Á€G}ÁrfàÁdhÁVˆdÁHÄpÁ;0Á-¸Á f‘Á[ŸÁWmÀó³þÀÛTÀÂͺÀ«›{À”jNÀ|‹üÀRÎÀ)mpÀ½Õ¿¿„£¿v¿Â¾ë±ç¼R’>Љ·?AÛ?†¸"?¢ƒ¯?´;Y?»Sh?·ç»?«Ì?”ëà?ncË?%„>•ž½¦Ì˜¿W]¿{Ë¿ÀlÀjÀ(ùfÀQE!À{JOÀ’ÇsÀ¨ ôÀ¾¾ÀÕãöÀíFÁéÁ9sÁ¢ÛÁ(–Á5òXÁC^ÓÁPЛÁ^v2ÁlGHÁzHÂÁ„3òÁ‹FÁ’i‘Á |bÁ™O—Á’*»Á‹1Á„'Áz:ÏÁlm„Á^ÊÁQHªÁCÙÔÁ6µ9Á)©°ÁÂÍÁceÁ¿Àð ÎÀØØžÀÁ§qÀ«fÀ–‡À¶À\Ì4À8Z°À§í¿éæ9¿¬©þ¿h¿=¾Fp‘=­L>‘˜â>Òjp>íf>á' >²&$>>K±½%8¾´0¿$µï¿ƒŒ¿³ÿà¿íçlÀŸ°À8½GÀ\ÜÀJ>À•‰Àª¾!À¿àmÀÕ1CÀë÷¦ÁŽÂÁ 6 Án­Á%¾£Á2>Á>Ü>ÁLIÁY•ÁfìÁtl‹Á¿Á‡ÿ<ÁwÁ–Á¤ÁœõŒÁ•ñÁŽøœÁˆ <Á2ŸÁtÚzÁgeåÁZ²ÁMkÁ?øùÁ3;aÁ&ìËÁ—ìÁ£wÁ áÀîä•ÀØŠÀæúÀ®ÉÆÀ› }Àˆ´Àn uÀL|ìÀ,aÀ·½¿é.o¿»1¿’‰¤¿cú[¿4¿ C¿ E ¿¨k¿$kr¿LWØ¿h¿¢C¿Ês¿÷B±ÀÃÀ/`´ÀM¦QÀm~_Àˆ¼,À›/À®(À´ÏÀ××ÀìùfÁ.Á ˜šÁ+‰Á#Ì?Á/ôÁÀô^ ÁùÑÁsaÁŠÁ#˜)Á.aŠÁ9Ò(ÁEeÁPÿ.Á]ZÁiNäÁužíÁ(Á‡jÁ÷ÄÁ”§+Á›]iÁ¢ÕÁ¯Ó™Á© eÁ¢RÁ›œoÁ•yÁŽ}úÁ‡úNÁ™ ÁvÍ¡Áj”Á^D³ÁR,ÁFæ–Á;NÁ0,Á%ƒoÁùÁÊÿÁ*¯ÀüÈÀêaŠÀÙkzÀÉM*ÀºEÿÀ¬ÛÀŸ$¸À“ñÀ‰½ñÀ"½ÀtéŒÀk/‘ÀeÀbMäÀc@ÙÀgÓäÀpsôÀ{ÈùÀ…'eÀ­°À—¢‰À¢ëØÀ®¸7À»æWÀÊZ¥ÀÙ§]ÀééÿÀûÓãÁ( ÁŠYÁv|Á$ÿÞÁ/’Á:(úÁDý©ÁPnïÁ\:Ágš¾Ás‹ØÁÔPÁ†,ÁŒBXÁ’˜¥Á™ÕÁŸ¸ Á¦mÊÁ´aÁ­`ÅÁ¦·?Á +Á™¤þÁ“)ûÁŒÖÁ†«ƒÁ€ƒÔÁtÚÁi¾Á]…(ÁQíÁF­ÚÁ<jÁ1£ôÁ'KƒÁÁK:Á KãÁ¬êÀõ -ÀåB7ÀÖõIÀɧÀ½…À² mÀ¨_ˆÀ E À™ü$À•I»À’YÀ‘&bÀ‘›lÀ“Ñ7À—ÛKÀ5 À¤E>À¬`àÀµª9ÀÀÜwÀÌ=æÀØôÀÀæ»7Àõ³ÇÁ¡ªÁ ˜Á'jÁ{?Á&ìÄÁ0üQÁ;NÁF"¾ÁP»%Á[šµÁg ¶ÁrŸ›Á~74Á… uÁ‹,ÞÁ‘TâÁ—€ÁÌÁ¤<ŸÁªÎýÁ¸t3Á±ØÁÁ«R‹Á¤Ì¦Áž^>Á˜÷Á‘ð6Á‹ÇÁ…¸¦Á¼PÁt#¹ÁhŒ[Á]KVÁR£zÁH3ïÁ=ÑYÁ3ÛñÁ*ŽÁ!tzÁÃNÁhüÁ[|ÁéßÀó¨ÀæwÀÛ #ÀÐj”ÀÇ?šÀ¿zÀ¹ƒÀµÀ²s¤À±%ÓÀ±˜8À³¸µÀ·|œÀ¼¨³ÀÃcÀËãÀÔ kÀÞÍÀêÀö"&Á®/ÁéýÁаÁ†Á!FQÁ*tOÁ3ÎsÁ=T6ÁGˆ1ÁRËÁ\´JÁgNNÁr8kÁ}¨”Á„ž™ÁŠj,ÁV\Á–o”Áœ—™Á¢ÂÁ©FÁ¯gÛÁ¼ÿhÁ¶yÁ¯ø½Á©–/Á£X Á4éÁ— íÁ‘ùÁ‹-qÁ…a&Á+äÁségÁi41Á^ÃëÁTZÖÁJG•Á@ÔæÁ7µÆÁ.ÞlÁ&PÁ:´ÁfÁ@ÿÁ>ŽÁÚÀùÂÀîÙŒÀæ hÀÞ±éÀÙ ÐÀÔÌvÀÒeîÀÑ%CÀÑ•ÿÀÓ 3À×ìÀÜ& ÀâƒzÀéø,ÀòÏIÀü½ÉÁ‚Á ÏWÁ3øÁ SÁ’ Á&WbÁ.‹«Á7~,Á@ÇÁJ!´ÁSÅ(Á^Áh­ÁÁsFÜÁ}ãNÁ„kQÁŠ"ÜÁíxÁ•¹Á› VÁ¡²jÁ§ÚOÁ®iÁ´=¦ÁÁ ”Á»)#Á´ÑÁ®›ïÁ¨xµÁ¢R[ÁœQÜÁ–|ºÁ°nÁŠåÍÁ…CóÁÅÁuSæÁjæîÁ`½±ÁW#öÁMùÁDùŸÁÌõÁ=RñÁÜÁ@±{ÁDR+ÁH ]ÁL`ÙÁQ|IÁW@ Á](Ád¡Ák?Ás: Á{qˆÁ‚Á†¹yÁ‹¥IÁ®LÁ•åðÁ›MvÁ ¾9Á¦X²Á¬#®Á²qÁ¸8»Á¾z¼ÁÄÏ[ÁË$3ÁÔŒ¸ÁÍûèÁÇ…çÁÁ-gÁºõjÁ´àÁ®Ø0Á¨ÔæÁ¢÷—ÁJÁ—Ñ^Á’i¤ÁkÁ‡ìƒÁ‚Ü‹Á|‚ÁrÙ¨ÁiÈBÁaq,ÁYâ¡ÁRƒ¢ÁKÊ%ÁEÝxÁ@-3Á;‡¡Á7X†Á3·]Á13£Á/äÁ-¬*Á,¡fÁ+çBÁ+x¡Á+@|Á*·Á*zFÁ*’¥Á+! Á,ÄYÁ.ˆZÁ1^Á5 uÁ8ÏñÁ=}©ÁBöÐÁHý½ÁOa)ÁVEÁ]ÁdÁeÝ%ÁnCPÁwdLÁ€–ÏÁ…¡ÕÁŠÉ Á)`Á•œ–Á›4cÁ¡<Á¦ú¹Á­Á³e`Á¹¹¯ÁÀ÷ÁÆcéÁÐD¾ÁÉ¿ÁÂõEÁ¼upÁ¶5Á¯ÔéÁ©»@Á£´Á¯®Á—ÐÁ’$0ÁŒ¯Á‡KƒÁüÁy¢ÃÁo‹‰ÁfNÁ\ÖQÁSý ÁL1ÁD–fÁ=lZÁ7F Á1r0Á,p¨Á(-Á$:-Á! ”Áu‡ÁcÁð†Á;^ÁÅkÁˆqÁgÁßÚÁ÷kÁ—Á?üÁÁ"),Á%ÒŠÁ)¹âÁ.̯Á4*Á:Á)ÁANõÁH| ÁPl&ÁX“tÁar—ÁkÁu,×Á`'Á…dÁŠÝÁðÁ•ãƒÁ›áÿÁ¢ ðÁ¨PDÁ®¤Á´ê¹Á»+?ÁÁŒ®ÁÌöÁÅVFÁ¾ž£Á·÷–Á±mÁ«=Á¤ºíÁž›NÁ˜•dÁ’‘ÁŒ¯Á‡ÝÁ••ÁxluÁmÕsÁcpÓÁYu´ÁPÎÁFéˆÁ>c¥Á6ÃãÁ/W Á(»Á"èÁ}zÁÁجÁ …ÁÒ Á^œÁ @]Á –]Á "{Á Ò-Á yÈÁ ExÁ ]DÁ &ÉÁ Ï Á¸ÒÁêÁ§ÿÁÒÔÁ OªÁ&#óÁ,–¹Á3‰€Á;)úÁCOÁK§-ÁU=Á_ZÁi8DÁsÉÁ~ÎBÁ…ÁŠÏ ÁÑßÁ–úŸÁ;vÁ£‡VÁ©«êÁ¯õžÁ¶^ÎÁ¼ÐBÁÇûSÁÁ'<Áºh[Á³²ÊÁ­Á¦nEÁŸøýÁ™¨ÝÁ“‚ªÁ}—Á‡z°Á–GÁwÜÓÁmšÁbLÜÁW»PÁMLäÁCžÁ::õÁ1)òÁ)(Á!ÂÁk!ÁpÏÁ¼sÁ >ÁœkÁ…LÁ9ëÀýoªÀû#vÀùùbÀùÀøOÀ÷Ì=À÷YTÀ÷’âÀùz°ÀüÅ6Áˆ‰ÁúüÁ“Á )ÄÁÙÁèÁ¼ÓÁ& †Á-å Á6ÑÁ?25ÁIµÁS#Á]™˜Áh§ ÁsïîÁ‰ÂÁ…ÇìÁ‹ê@Á’&–Á˜CÕÁžošÁ¤Ã¢Á«0õÁ±£"Á¸*5ÁÃôÁ½% Á¶G5Á¯|_Á¨ÇåÁ¢ÓÁ›{8Á”úgÁŽ ’Áˆs+Á‚n`ÁxÜòÁmòÁaƪÁVéÁL/õÁA¥Á7GfÁ-±ÅÁ$ngÁª‘ÁõAÁ x€Á*Á<4Àö›Àí&CÀæ1Àád³ÀÞ(ìÀÛÔLÀÚÇÅÀÙß ÀÙ!'ÀؤëÀØ.ÀØ‚«ÀÚªÄÀÝìUÀâô­ÀéîçÀñaDÀû†«ÁfnÁ ò~ÁvÁÈÊÁ Á{Á)‡HÁ3= Á=.|ÁGƒ—ÁRUÁ]åÁi|1Áu€ÁÁ€ÛÁ†ô=ÁÁ“6YÁ™•/Á %Á¦yÂÁ­ ðÁ³¿”Á¿ÊîÁ¸ñÁ²&êÁ«hØÁ¤œ"ÁÞAÁ—5’Á•ôÁŠ Áƒ¤ÁzÞwÁnÔ=ÁbÜ;ÁWQÁK¿æÁ@ÊÁ6Á+˜GÁ!lÕÁêÁÏ—ÁÚÀýã?Àï‡ÎÀãµ6ÀØTÍÀÏF´ÀÇœ™À—[À¿ »À¼½šÀ»–«Àº­hÀº¹À¹~yÀ¹±À¹•«À»ß?À¿&ÀÄݽÀËçÖÀÔ(•ÀÞé½Àê|ôÀøeÁ¬ŠÁ §•Á‹Á|Á'`•Á1‚Á<…dÁGÚ8ÁSnµÁ_u®ÁkZíÁw`ÁÀœÁˆêÁŽgÁ”Õ`Á›VÁ¡øßÁ¨´žÁ¯ußÁ»¹xÁ´ÓÁ­ôEÁ§¼Á [‰Á™¦FÁ’þ³ÁŒQUÁ…¶òÁ~P‰ÁqpÁdôfÁXÜØÁLä*ÁA Á5ÄoÁ*°bÁ "Á²Á ¹ÁpaÀòÇÉÀâýrÀÓßðÀÆé÷À»À±qÀ©O}À£ñÀ kÀÌ"Àœ…ýÀ›¤¾À›‚ÀšwÓÀ™ß_ÀšË6À%À ¢lÀ¦ÇAÀ­ç^À·\ÎÀÂXÆÀÏ ÀÝF7ÀíÉÀý™ßÁé·Á›~Á¼ÐÁ&•lÁ1ÆüÁ=9ÌÁHëcÁTÓÁ`Ø Ám2ÁyŸ&Áƒ9Á‰©[Á96Á–ë˜ÁªDÁ¤ppÁ«NNÁ·½òÁ°ÈûÁ©ßˆÁ¢û÷ÁœóÁ•Q¨ÁŽ‘ÜÁ‡ëtÁRñÁuƒ®Áh¢tÁ[½dÁO([ÁBüÁ6ìNÁ+"WÁÒ—Á‘Á ˆÀÿºDÀì9õÀÙÍ%ÀÈ7À¸öîÀªUGÀžbhÀ“§¦À‹löÀ…J®À€óòÀ}¶DÀzö¢ÀyVçÀx>•ÀvêÁÀu£òÀx:À|šÀ‚{Àˆ³ÀÀmˆÀšÅµÀ¦,KÀ³áåÀ¹ÞÀÓJöÀäíiÀ÷µÚÁê‚ÁºJÁydÁ&¹µÁ2XþÁ>KÁJO\ÁV`ÁcB¥ÁpîÁ}DÁ…%Á‹à+Á’ ÑÁ™uÇÁ dÁ§fîÁ³ø¥Á¬ãõÁ¥ßÁžïÁ˜ Á‘%>ÁŠL Áƒ†8Áyœ÷ÁlrpÁ_=gÁRCÁE|ÏÁ8øšÁ,©Á ÅZÁðtÁ ¥$Àý bÀèAÇÀÓš’ÀÀõåÀ®{8ÀäJÀŽÏjÀÀcÀl¢À[N¹ÀMSjÀDgÀ?ÔDÀ<í!À;q´À:>&À8åÚÀ7É«À:–ºÀ?±ÀHÉ>ÀULÀg1ÛÀ|lQÀŠ‹äÀ˜¨)À¨È„À¹d|ÀÌbÁÀß«ÀôýÁ*#Á,¤ÁÇ?Á'Ã%Á3ÉXÁ@ ±ÁLæuÁYº"ÁfÌgÁt0zÁ€ÕeÁ‡ŸzÁއ¦Á•‡¹Áœ›™Á£´­Á°LþÁ©-bÁ¢Á›PÁ”RÁÁ†-~Á~Ápù,Ácv’ÁV)XÁI ­Á;èWÁ/„Á"…•Á]Á 2FÀü¸ÈÀæ>GÀÐäžÀ»öPÀ§l:À•`ÐÀƒµÀgU£ÀJäÀ2¬UÀ¦}À4hÀâíÀö¿þ¿û¿ør‘¿õÁè¿ôšw¿úfÀ¾üÀ ÓÀuáÀ-’ÇÀD- À^ªGÀ|5¾Àí~À ŽÐÀ³›ÀÈ"MÀÝj¨ÀóCÁ8:Á9ˆÁD®Á)¹”Á6ŠFÁCiVÁP§/Á^QÁkšIÁyXaÁƒ¨©ÁŠ»ØÁ‘ÔìÁ˜ëœÁ ûÁ¬ÐLÁ¥”ÊÁži½Á—JfÁ3ˆÁ‰!Á‚$ýÁvv=Áh¬ÁZò¼ÁMaÍÁ?íbÁ2ÆjÁ%Ÿ£Á®4Á Àÿ3>Àç>rÀÏ=À¹- À¤VpÀjbÀwMÀS*ôÀ2N°ÀAµ¿òЙ¿È|V¿¨„¿“–x¿ˆB¿Ÿ6¿~@¿w…Q¿sp7¿sC1¿=‘¿ŠÑ¿ qI¿½[†¿çÇŒÀ ¿À(0ŸÀF¤Ài%¶À‡`À›5äÀ° ÀÆ3¦ÀÝ[UÀõ_ÁÃ4Á\9Á .Á--CÁ:Œ.ÁH‘ÁU¤ÌÁc“¡Áq¸-ÁçøÁ‡ öÁŽ/Á•gUÁœ²aÁ©…ïÁ¢9§Ášï+Á“²'ÁŒ†}Á…gÁ|¡óÁn€·Á`•.ÁRÂ]ÁDÿÁ7OÆÁ)Ë Á}ÁcÊÁO&Àë?ÀÒ(LÀºXÀ¢f´ÀŒöÀnÎ~ÀE¼éÀè]¿øÏí¿¹lp¿‚§|¿'«¾Åp†¾NI;½É€ö½%éÁ¼Í(6;í@ë<+£½ ‚¾ ‰Ú¾Ÿ{¶¿kQ¿iD‘¿¨¥â¿ãdíÀ?™À6¡,À\’÷Àƒ—kÀ™0ÄÀ°HÀÈK#ÀàÀúÁ Ø&Á Á$r Á1øÃÁ?ÖžÁMø«Á\%ÁjP§Áxœ‡Áƒ‰ÊÁŠØýÁ’4©Á™“#Á¦OœÁžôëÁ—¦mÁZ%Á‰wÁÏÁuF‚Ág lÁXÜÖÁJÁÁ<áLÁ/ïÁ!Q©Á·+Á=ÑÀò4ÉÀØ!À¾XÿÀ¥*ÁÀŒò>Àj€À>ÀË&¿Ø§5¿@ò¿-{¾ ÀØ>„!å? ‡ƒ??\:?\˜¶?mâ:?sTl?{:Q?|¤n?x I?kt?Opµ?ã{>¯ýT¼Z»–¾à„|¿lÇ+¿¼‡0ÀñpÀ-[šÀXrÀƒ4À›7ÇÀ³¬;ÀÍG´Àç,oÁídÁZ;Á Á*7tÁ8b?ÁFpÁTÛ¨Ác[ŒÁr£Á€\˜Á‡»Á’Á–ŠÁ£fcÁ›è”Á”x[ÁßÁ…ÆëÁ|õGÁn\ÀÁ_ÙýÁQ€ÁCD4Á5ºÁ'%Á-kÁ a,ÀûPFÀà@ÑÀÅ¡þÀ«o‡À‘móÀpzKÀ?šàÀ3ä¿ÇÓn¿k6¾Ÿ2œ>‚H?<°i?“”?½c€?Û3k?ééò?ò×$?ö_?úM?ûøÊ?øï?ð–_?à¦?Æ»?¡O¥?a r>Ö¢½½ˆV¿)ý¿¦õø¿ü°FÀ,@IÀ\ZñÀ†ë™À ”±ÀºÝ–ÀÕ¡iÀðÊÝÁtžÁŸbÁ"ÊMÁ1ÐÁ?§ÀÁNOTÁ] ÁkÆ?Áz–Á„Á2ÁŒ@ÊÁ“ÁLÁ Ä$Á™4Á‘¤YÁŠ7Á‚¤sÁvyTÁgÎðÁY6CÁJ³Á<Á-¹³ÁÁRÁL\ÀêóÀÏgtÀ´À™—À}¹yÀIgÐÀ {¿Ê¯ ¿WžÀ¾hA>ùÜU?ˆ„¢?˹B@•Ä@n€@*3Ã@2¿Ù@7jÖ@9ºD@;‚´@<Ï®@:ÿf@6È(@-¯à@%@ Y?á•Î?£Ÿ\?7Èu=ÓÞ•¿øÊ¿¤0µÀGÀ4fuÀhZÀޤ#À©|æÀÅg1Àá¹ Àþ Á ]ÄÁö{Á*žÁ9XíÁH`ÁW-ÁeýàÁtþäÁ‚Á‰†lÁ‘Áž*.Á–˜XÁRÁ‡xMÁÐŽÁp±þÁaªíÁRÈ„ÁDÁ5w?Á&Þ¯ÁPTÁ óoÀ÷sôÀÛÀ¿0õÀ£‹SÀˆ ÀY×À$“ä¿à]ì¿s°¾1Bš?’? Y¨?ñU @k$@;w @TY1@f¹s@pй@uƒð@x1@z2Ù@{¢÷@yß@t¼@jci@Z„«@DX,@'‹°@Fí?ÁqË?Wnù>ù<¿ Í¿µëoÀMãÀDÕaÀ{äEÀš3QÀ¶ˆçÀÓF®ÀðŠmÁìíÁ¨ÑÁ$!Á3z,ÁB{0ÁQ|4Á`€<Áo——Á~Ä‚Á‡¿ÁŽ¥3Á›Æ¸Á”£ÁŒwêÁ„ÞWÁz™Ákx÷Á\XìÁM8àÁ>XÁ/ »Á W$Á¸;Á«ÀéAÀÌZÃÀ¯éºÀ“‘=Ào’fÀ8W-À‡–¿–ù¹¾¸K >è™?ž^d?ýap@*0,@Qj¿@rï™@‡LK@‘Qk@—.Ý@™ÿ»@›‰®@œ{æ@; @œ,@™*Ë@“y»@ŠÎ×@}ak@^›½@:8 @õ¯?Äo?G ÷¼ï噿[kö¿Ú¶‡À%[0À^ZÀ‹àoÀ©'ãÀÆwúÀä¥ÁöwÁ÷{ÁøÁ-ùƒÁ=ôÁL67Á[z¨ÁjÁÁzyÁ„¢{ÁŒ?äÁ™¸ÅÁ‘ù¼ÁŠ;žÁ‚‚›Áu¥XÁf[3ÁW%ÁHTÁ8áIÁ)Á=Á¡2Á ˆæÀùDšÀÛòmÀ¾ÁNÀ¡’*À„Ï•ÀP¿À¯¿Á…Á¿&…’>M7)?„8h?ìñ@)J×@Xüì@‚Â@”¸@£éÉ@¯,Ò@¶GÉ@¹j‡@» P@»úå@¼¤Å@»@h@·îì@±ÁÁ@¨9ç@š]î@‰DÆ@j @<[¨@ 3;?®>Ì?ÿ~¾³}Þ¿õÏÀûÊÀCгÀ~.NÀœå…ÀºçÀØçÀöä Á |Á«<Á(ñÒÁ88»ÁG£ÁV¾ŒÁeù«ÁuB'Á‚N4ÁŠÁ—½\ÁúÎÁˆ;ÅÁ€|¼Áq{gÁaýÁR„YÁCõÁ3ÈfÁ$Ái¦ÁI›ÀîSÀÐÀ±öÕÀ”teÀn†ŒÀ4$M¿õ¨¿ƒU¾ê>?82’?Ê(È@.{@O¦·@’S@™£»@®Ô2@À=¥@Í!@Õ\í@ØÜÁ@Ú¸%@Û—­@Û÷ƒ@Új@Ö¶o@Ð@Ää¼@µm†@¢È@‹7À@dWÃ@/[?ïÖÎ?€!=¹)<¿S¿ßlŸÀ+°GÀgª?À‘ÒÀ¯ëbÀÎQƒÀìÔÁ¯åÁöÎÁ$8#Á3v9ÁBÊ;ÁR0;Áa˜hÁqÁ€7Á‡ìyÁ–âÁŽ/ØÁ†[ïÁ}ªÁm„Á]ÿxÁNgÁ?VÁ/…EÁ ^Á”{Á9‰ÀãìöÀÅ£ðÀ§cÙÀ‰#ÃÀUÈ Àþ(¿¿÷¿ ô>¤d ?šÓË@á@<ÖW@s}ý@”f&@®;@ÆÅh@Û•@ê @ô ô@øNû@úOú@û>ô@û<‘@ùVº@õ @íÛú@àÕë@Îñ@¸"Û@ž²î@ƒ#E@NÚ†@j@?³Ž >óœè¾ì2Ö¿³¥ÀÓpÀR¡ÔÀ‡ÒlÀ¦SîÀÄÛðÀãctÁùÁ]-ÁÅUÁ/-|Á>—.ÁNÁ]mÁlá>Á|fµÁ…ùÁ”^ÁŒˆÈÁ„µ7ÁyÃfÁjÑÁZs¼ÁJ˧Á;%jÁ+~Á VÁ ‹EÀúhÀÛÀ¼,VÀ]²À}ëÀ@é'Àhú¿Ñ™¾9#ò?=ÆR?Ó§¦@#¢W@\~Y@Š03@¥Æ@Àìƒ@Û+h@óçAAXA{ZA÷ÈA î·A sA J×A 1PA  Aƒ¨@ûu˜@äÔä@Ê[³@®¯®@‘w3@hÏ@,‰?áG$?P Ë¾ *¿‹GMÀ¦ªÀ?©®À|¯eÀ?À»äŽÀÚ´ÝÀù…,Á +AÁ–-Á+ëÁ:ˆÿÁJ[ÁYŸæÁi0ÁxŶÁ„/ûÁ’áÑÁ‹âÁƒ#iÁvQÁfÙÞÁW'ÉÁG~Á7Ö÷Á(/ÝÁ‡ÈÁß´Àòo=ÀÓ.¸À´&gÀ•*EÀl\GÀ.nQ¿á&e¿M=>Y?‹ë}@uì@>m¤@xÏã@™\@µÉf@Ñ—ö@íDAßA„bA4A~;A0cA&AcAx‘AøAA—øA¿l@õòÿ@عE@»!¯@c»@~#Ö@A`@]‹?޵>%x5¿K— ¿àúqÀ. Àk¾!À”¯_À³®ÀÒTÕÀñV“Á7oÁˇÁ'g"Á7TÁF­„ÁVSgÁeùJÁuŸ0Á‚¥Á‘‹‡Á‰¨SÁÅÁsÃ×ÁcýpÁT7 ÁDqÁ4²YÁ$ûÁEÁ’ƒÀëÕÀ̇À­7ªÀç€À].¬À޶¿Àè¿ ð >Ûà]?²¼ô@ãØ@SÔJ@ˆ*<@¦] @Ãåú@àç@ýS A ÜA äA¬zA ÃTA$fA(»¸A)`A%è·A#¬¨A›(Aô)AÀ@ä @Å®„@§/^@ˆ¢C@TJ@Æ?²[.>Üi{¿Là¿¿g?ÀTAÀ[EgÀŒãúÀ¬/¿ÀË{…ÀêÇJÁ ˆÁ¯kÁ$UNÁ3û0ÁC¢wÁSSyÁc ÁrÍÁIBÁAVÁˆZ¯Á€s¸ÁqîÁaRÑÁQŠñÁAÄ<Á1ýÕÁ"7mÁqÁªŸÀåÈnÀÆ>IÀ¦ÍZÀ‡`dÀOøhÀ\G¿¥ ¾ ù‰?*Š?ÒBì@'dB@e\†@‘¤k@°‡?@Ï@íY˜A®öA8öA"`ëA+ºÿA-‘wA0¨ A4çA6A2â.A0¿ÇA$i*AJ®A æ@íx.@ÎØ@°8ó@‘l3@e']@'I?ÒÕ­?-f¾›t¿¤A½ÀËfÀO`ƒÀ†úÐÀ¦E_ÀÅîÀäÚ}ÁõÁÔîÁ!œ¿Á1lÁA=ôÁQÄÁ`áÀÁp³½Á€BÜÁ;Á‡vÁ~gWÁn™ÂÁ^Ì-ÁNþ˜Á?1Á/cnÁ•ÁÈÀÿÿÀÀàoïÀÀâÖÀ¡VÀÉ8ÀDxÒÀ_4¿Œ‹-½èí¯?^Iú?ìªç@4ñ•@s@™y@¸h¢@מe@ö™™A ÅhA ÅA)AœA7þkA:ÜbA=¶>AA™@ACF_A@A@rø@4EÃ?ë&Í?[„*½ú*5¿\À$ÀCÝ£ÀˆÊÀ¡*IÀÀËÉÀàmJÁúÁÚÁ¬ÃÁ/ÔÁ?S3ÁO&ÎÁ^ü7Án×Á~¶iÁÆòÁ…ÝÁ{éÈÁlRÁ\K¼ÁL~'Á<°’Á,âýÁhÁ GÓÀúô{ÀÛYQÀ»¾'Àœ"ýÀyÀÀ9Ö*¿õg|¿nP=af£?…>q@¸Ö@@Òt@ì@Ÿ‚Ø@¾òã@ÞQ¨@ý 6Ax0A EA-ÅUA=?ÿAHŒ¢AK `ANÀ†APØáAKßADô?þUt?€!Á:CüÁ*p»ÁyÁ È8Àõó˜ÀÖXnÀ¶½DÀ—"Ào ßÀ/׋¿áBm¿E«Š>\·?šŒ@ 8¿@KqT@…L@¤Û¡@Ähp@ãõ?AÁA‡nA!MÖA1CA@¼KAPd$AXâA\HSA^:©AN¨ÈA?˜A/nØA±YAñ°A2@àã—@ÁR@¡Áf@‚0N@E>j@:?ô=öÁ¿^…æ¿íç2À6F ÀušæÀšx2Àº&tÀÙçØÀù´aÁ ÁÁ¨«Á,sÁῤq>¾i¿?®@9à@Up4@ŠSD@©în@ɉ˜@é$ÂA`A.5A#øòA3À¢AC‡ ASMqAcØAjëA`|ñAP¾žAALA1AúA!ƒ§AÅ”A@än@ÄÊÙ@¥'¤@…„n@KÂq@ xÀ?šMA>]H¿Fœ°¿âS{À0¬OÀp.àÀ—عÀ·šÀ×[JÀ÷•Á sÓÁZNÁ+AÁ;'ßÁK×ÁZø€ÁjåÁzÔÁ‰°Á‚`Átì–Áe°ÁUDËÁEpæÁ5Á%ÉÁó÷ÁÕÀì”uÀÌíñÀ­GnÀ êÀ[ôÎÀ§Ç¿ºµ€¾ðmÉ?ýÂ?Á&m@ç@_>L@Læ@®ïQ@Ί|@î%¦AàhA­ýA&{’A6I'AF¼AUäQAe±ðAr&ûAbjhAR®ABñ§A3&œA#R A}{A¨ê@ç©€@Èê@¨[†@ˆži@Qš@Ha?¥œP>šŸy¿0™'¿×AÀ+¼Àj™ýÀ•À´×/ÀÔž`ÀôrÁ 'ÙÁôÁ* Á9û9ÁIì[ÁYÝ}ÁiΠÁy¿ÂÁ†öÁ€>€ÁršôÁbÈÁRõAÁC"hÁ3MQÁ#vÕÁ¢DÁÎ_ÀçôóÀÈM(À¨¥^Àˆý“ÀR«‘ÀY ¿¨ ¾¥¢?*c?ÓË–@)2Ò@hÙ@“æp@³œ@Ó7c@òáHA E–AÅA(ñœA8È|AH—.AXdÃAh2XAt&7Ad[¬AT‰ÇAD·âA4åýA%3A7ÃA\S@ëÅ@ËG©@«‡o@‹ÂW@Wú}@pM?±Ì9>Êßa¿¹¿ËÌÆÀ%ªìÀeouÀ’™ÿÀ²|CÀÒ^ˆÀò9Á LÁöÁ(ââÁ8Ï­ÁH¼yÁX©DÁh–Áx‚ÛÁ„‹¤Á{fÁmÿÃÁ`m#ÁP—DÁ@ÄjÁ0ñ‘Á!·ÁKÝÁyÀãLUÀæ¢À¤ïÀ„Y”ÀI_ÈÀ 3¿•<¾7Ž?Oz1?æ\C@2}·@qÍL@˜Žå@¸9*@×à2@÷†¶A –œAiÞA+=ÀA;•AJçˆAZ¼zAj‘mAuòµAf AV6TAFUœA6tæA&”]A´&AÔ]@íê_@Î-È@®s/@Ž¡W@]4@ݹ?¼V}>óÆ¿æÜ¿ÁØdÀ ž¬À`Q'ÀÑÀ¯ÛÀϰžÀïzŠÁ¦.Á½Á'yLÁ7bÛÁGLjÁW5ùÁgœÁvS®Á‚“iÁw>XÁišwÁ\GðÁN[RÁ>€–Á.§QÁÐÁøîÀþCyÀÞ•À¾ê¦ÀŸDóÀ>À?óÀ§´¿‚¸½:?téø?ù È@;ÑÉ@{Í@4@¼Ü@܃ê@ü+´A é¿A½¥A-‘ŠA=eoAM:A] CAlàAw”žAg·iAWÚ4AGýA8ËA(:ªAQAd•@ðïí@ѯ@±=r@‘d5@c@#ƒg?Çå}?ˆW¾Ùt—¿µ5ÀnVÀZ’ÀŒÝgÀ¬°…À̃¢ÀìVÀÁïÁþ~Á%è Á5ÑœÁE»+ÁU¤¹Áe{Ár¤DÁ¤Át÷Áf<ëÁXµtÁK‰ÕÁ<^ÇÁ,ƒYÁ§ìÁ Ì~ÀùâÀÚ+CÀºuÀš¿œÀvSÀ6¶¿î²¯¿_òG=ì€?dé@ýÛ@EIA@‚JS@¡ð@Á•º@á;mApACA …A/èÈA?»`AOŽIA_asAo4ÐAy6åAiMXAYdRAI}öA9šA)µØAÑ®A í„@ô´@ÔJ`@´‚ @”±$@i¼ @*Ò?Ôß,?+%j¾¦ç ¿©9À)XÀSÏ”À‰ºèÀ©ŽÀÉa#Àé0ÍÁÁbCÁ$C-Á4$ÁDWÁSæÌÁaÂ÷Áow6Á߃Áqà‘ÁcòÁVFXÁHñçÁ:YÁ*x@Á—|Á ¶¸Àõ«êÀÕê³À¶2`À–{„Àm‰OÀ.˜¿Ý[À¿= >l~?Ÿ1ì@æ@Nn×@†ê!@¦˜„@ÆFç@åõJAÎŽA¡gA"tAA2GABôAQìÍAa¿§Aq’€AzØüAjöäA[ËAK1ÚA;LºA+c+AyœA @÷Lý@×yß@·§÷@—Úa@pG@0Ì?áÊ£?E+\¾dÍÿ›¡À T,ÀL×ÔÀ†-¾À¥ï’ÀűªÀåt“Á›¾Á}3Á"^¨Á2@ÁB!‘ÁQ÷:Á_~5ÁmSÿÁ}éfÁoãÁb×ÁTœŸÁG;hÁ8wÁ(•`Áª•Á´Àñ½ÓÀÑüqÀ²;À’y¶Àep]À%íN¿ÌÔ~¿œÂ>ÄÞñ?°=Ú@@VúÇ@‹4?@ªë@Ê¡÷@êX’AAáÁA$¼}A4—9ADnÚATF Ad=Asð~A|Œ)Al¥ŠA\¾ëALØLA<ñ®A- A$pA =Ü@úµÖ@Úô@»2.@›pZ@w] @7Ùd?ð«y?cHR½Ö2j¿Œn9À¼ïÀEBÂÀ‚dJÀ¢'3ÀÁêÀá­¬Áº|Áž"Á ÈÁ0enÁ@I!ÁP/\Á^;áÁkõ"Á|¨ÔÁnžÁ`·¤ÁS-¼ÁFéÁ7HÕÁ'S&Á]xÁgÉÀîä5ÀÎø×À¯ zÀ"À^qyÀ³ú¿¾ Ó¾ú®Å?dà?¿ö×@~@_¿@Aµ@¯2@ÎĹ@î†@A#äAIA&ß·A6»%AF–“AVrAfMAv'ÍA~D5AngòA^‡9AN¦OA>ÅeA.ä{A‘A"§@þƒz@ÞÁ¦@¾ÿÓ@Ÿ=w@~õ@?oH?ÿÒë?€Á¦ì‰ÁNãhÁ]šëÁknÀÁ|jÑÁnMðÁ`qéÁRã‡ÁE²ÂÁ6tóÁ&vÓÁyÁ{ìÀìÿÀÍ´À­ÀMÀZD3ÀUÌ¿´ÎʾÓÇï?Õ¥?ÊœK@%$à@dû›@’i+@²Tˆ@Ò?å@ò%ÖAþ¯AêsA(Ö7A8½CAHíAX~˜Ah_IAx@ A€yApN°A`n AP!A@¬7A0Ë>A éÉAüA@âjU@˜„@¢Æ³@‚ç®@EúW@#b?ŒŒ=Í¡¿eÒU¿ò£ÏÀ9/:Ày ŒÀœtïÀ¼c˜ÀÜRAÀü@ëÁ¾ÁœÁ.{Á=üZÁMó9Á]ÂÑÁkxóÁ}‡ÁoÁa/´ÁS>ÁFI£Á6IñÁ&JÁJÁJ*Àì”{ÀÌ”¢À¬”ÉÀŒ”ñÀY*5À*Ž¿²U÷¾É] ?N­?ÍŸ[@&Ê™@fÅ…@“`9@³]¯@Ó[%@óX›A «A©ÃA) îA9—AIz@AYfêAiS“Ax¢ÚA'ÞAqþyAb ­ARlAB"+A2,êA"7A?ÅAHq@ä¢8@ij@¤Äæ@„Ö=@IÁe@ Ô ?“Í`>•P¿WпëÅLÀ5ÕüÀuÊìÀšà<ÀºÛ(ÀÚÖ)ÀúÑ7Á f'Ác¾Á-a¯Á=_úÁM^ˆÁ]]LÁlH“Á~3 Áp/ªÁbl×ÁTéJÁF“ÌÁ6•¶Á&—ÄÁšÁœ€Àí>°ÀÍEjÀ­M¿ÀXÇÀZÑÁÀœ¿¶«ß¾Ý ?/Þ?Çwä@#kí@cç@‘eñ@±=î@Ñì@ðíéARuA'ÿA'ü A7ÄiAGGgAUß&Acè‚ApÝAq“uAh›bA]zKAO›…A@).A0’QA àÉA)rA]6@âøI@Ã1@£cž@ƒ–-@GŒ@ ?[ù=÷ÝÆ¿`À€¿ð>\À8<ÀwýJÀ›ö,À»í³ÀÛå:ÀûÜÁÁ ê$ÁåèÁ-á«Á=ÝoÁMÙ2Á]ÔöÁmйÁ€õÁr#LÁd€ÍÁW1ÀÁGzHÁ7‹šÁ'œñÁ®MÁ¿±Àï¢@ÀÏÅ?À¯èpÀ ôÀ``$À «¿Áõ ¿¿¿>ï1³?ºx¹@’‚@[è©@Ÿg@­>ã@Ì•x@ëÔÚA³Aß¼A#ôqA2¡ýA@²ÕANhAZö‘AbäAb;A\lÙARåAFÜA:PAA,×A ›A É%@ü|‚@ÝXb@¾ â@žŸê@~gã@?ó@¸?‚îá<îFÜ¿vùT¿ú²oÀ<ôÀ|ŽýÀžðÀ½âaÀݯßÀý„•Á±`Á£ÃÁ.˜Á>#ÁN‡Á^€%ÁnzÁo<ÁußÁg©TÁXÞÁHïIÁ9èÁ)tÁ.JÁ LáÀòäRÀÓ4jÀ³„‚À“Ô™ÀhIcÀ(é’¿Ó„¿(©œ>£v¡?¥Û.@lZ@Oë@‡4ð@¦3F@ÄÙ@ã0úAlÁAßALÊA+ A8SLADp%AM¥sAT2MARíAN˜ßAFŽA;ØA0>3A$(IA—AOÜ@óQ¼@ÔíE@¶ƒþ@—¥z@qFÜ@3F?éXÊ?WQÓ¾7µ¿¶×À³\ÀEŒZÀ‚4ÉÀ¡½ÍÀÁm&Àá1#Á|”ÁanÁ FßÁ0,¾Á@ðÁOùbÁ_àÁoÆ¿ÁƒQžÁyæÁj™ÁZ¸{ÁJà‡Á;“Á+0žÁXªÁ €¶À÷RÂÀ×µ¿À¸7À˜ÔÁÀs3AÀ4Ä2¿ì¤{¿_Mê=Õi?ŠT@©È@?}[@|2Ê@œL‚@¹¸¦@ÖÕB@óOA•ŠA¤A!û@A-ÝóA7ÄpA?¤ÕAE3AC„nA?1A9A/‡A$è}A ²A ÆaAº‘@廎@É!Á@«ù@Ž+Ì@_Žª@"ż?Ê«6?¿¦¾´¿©-¸ÀÛ²ÀQ–êÀˆ7mÀ§£eÀÇÞÀæ~$ÁöfÁ­¹Á"i­Á20ýÁBÁQØeÁaµlÁq–åÁ…¥½Á|žüÁlÈ,Á\ö‹ÁM+˜Á=hþÁ-®jÁù§ÁPÀýe·ÀÞ.0À¾ö¨ÀŸ¿!À€‡šÀB”ŒÀWx¿ŽÎ}¾+þ?H{?Üüg@*ló@e¦@œÆ@¬ˆ@È+S@ã_?@þ&A Ž5AKÀA!¾A*2A1+òA5NöA4€A0S3A+ãA"ÍfAóÏAOŒA³@î¶=@Õû@ºDs@ž?@£Ë@HöG@k'?¤m>ªF¿”¿ÉÇ\À"x´À`k À.ÇÀ®+ÝÀÍ=ÒÀìƒîÁöŽÁ¬ÑÁ%cÂÁ5ÁDÒgÁT‰ºÁdAÁsúfÁ‡}–ÁATÁo‹lÁ_Ü€ÁP6"Á@˜çÁ0ý#Á!a_ÁÅœÁ)ØÀå !ÀÆ›À§9aÀˆË5ÀTàûÀ+Œ¿·9;¾ýnï>áÝ­?­34@È”@Iw@ |@œ€@·pl@ÑRï@ê1EA³†A LbAm¢A3A"W A%‡’A$x‰A!&A8æAæA zhA_f@ïm5@ØÍ˜@Á‹ñ@¨[,@Ž!®@eÎu@-n¹?è—S?géh»Ü¢¿o‹ù¿ð€UÀ5 ÀqÒ¦À—Ž|À¶KÀÕ)ßÀô#Á Ž&Á rÁ(‘Á8*ÁGÓqÁWˆ†Ág?ÁÁv÷Á‰Á?yÁrã.ÁcGkÁS«§ÁDvÁ4Á$ùðÁ…(Á0ÅÀíæöÀψÀ±-\À’ÞÀiȯÀ-ÞC¿å91¿`w™=_I?k%s?æ²y@+Ò@a\Å@‹é@¤¤©@½#d@Ô5Ï@é¯9@ü¾ÌA°æA Å‚A3vA½ØAÐýA¯áA .òûv¾Õ‚¿ª%Àb¬ÀJåÀƒ’À¡JÀÀ¿ª|ÀÞÀü«<Á ³ÖÁæÁ,‹²Á<MÁK„èÁ[ÆÁj†‘Áz´ÁŠÊtÁƒêÁvuRÁfð¸ÁWwHÁHNÁ8ÅÏÁ)…‚ÁOñÁ "yÀ÷ôÓÀÙñÀÀ»ýIÀž%ÙÀ€¾7ÀFý»À È+[¾Ü.n>âìã?§T-@Äž@<Ë@oš+@ƒ@§“@¼Ãv@Ðq@áÇì@ñ6¢@þ3AÕ!AÛXA+A?x@ûÿ @ñAg@ãŽÀ@Ò^@¿”r@ªm%@• p@|³÷@N#6@§?Ô¦W?V?»çÄÌ¿_íÅ¿á_¶À)¬SÀcýÀ+ƒÀ¬mŸÀÊ(àÀèACÁ†\u¿ õ¿±_,ÀÞ±ÀGÀ¿%ÀœZõÀ¹|¶ÀÖ¦ëÀóæ°Á®ÅÁ§äÁ&¶ËÁ5Ó¶ÁDüaÁT0 Ácx1ÁrÐ{Á`ÁŽøÁ‡VŽÁpVÁp:éÁa)ÁRHÁC ïÁ4[Á%5ÁoÁÏÀòdÈÀÕsúÀ¸éáÀœ¡ñÀ€‰ÉÀIÅ;À¤a¿»?\¿%6f>§?mŠŸ?Ö°L@D5@E¢Ñ@mÉÑ@‰˜¯@š¦È@ªØ@·L¨@Áø@Ép@Ì"@Ë2ï@Æ3@¾ÔŠ@µ`X@©á`@œp@‹Ç@r.™@Jª'@ .Ú?êcñ?™{>ÉtT¾²Ü¿‘x¿ø À14=ÀgNÀŽÓyÀ«²ÀÇg7Àãã™Á}VÁíÁ°oÁ,[\Á;7_ÁJ;mÁYMšÁhk Áw‘íÁƒb^Á‘e+Á‰Ï´Á‚F÷Áu”Áf¥¢ÁWºÏÁHÚgÁ:&¨Á+†ûÁòiÁ}àÁ.ÀävÀÇèkÀ¬>éÀ¡ÇÀkrÀ6–ÖÀƒÖ¿ŸX¤¾õÈÑ>‡e?{†ô?ÖÅr@þG@:x·@]z @}á*@G¯@™ë@£Y¼@©ù¸@¬L @«”@§L@@ Ñ@— ß@Œc@ ˜@`øÄ@>H;@Ñ?à±?‹–)>ÕJ¾•6ù¿‚——¿à«˜À"C«ÀU—žÀ„ß…ÀŸ³íÀº¸UÀÖD¯ÀòWÁwnÁ¶ªÁ$‰?h›?Â…•@Dî@&ç<@Emo@`+ @w#H@„§B@ŠFñ@Œv0@‹Ä@‡ô@3|@q®@\óE@Eô@(îï@ ®ö?Êé?|¦á>°6Ö¾¤Å…¿*™¿Ú4øÀÆ!ÀJu¾À{æ²À—žÀ±LÀËøÀæÚ)ÁøöÁßãÁ þÁ+;AÁ9{ÃÁGûMÁV Áe*œÁsË@ÁAˆÁˆ¯'Á–îEÁ}¨ÁˆÔÁ€ËIÁrú¬Áds˜ÁV¨ÁG«GÁ9x@Á+\·Á{ÀÁªôÁê¤ÀèИÀÎz•À´`‚Àšª¡ÀÝÑÀRðžÀ#êe¿ëâU¿’<ë¾ý†.>ÍÖ?3”‹?ž®V?Þ‘N@ ×Ó@%}£@:«@JÑ´@U(S@Y@@Wï@Q þ@D™ˆ@3ïœ@ Áf@ I?à—?¤V?Dl[>;ªÙ¾Óí*¿ˆ•—¿ÝøìÀHöÀGŽÀv“ð?Zǵ?£KŒ?Òþi?ú†@ Mp@ÂÅ@”¡@V@ô@Ž?í¹?È/=?K®?Y[Q>η÷½¥~ü¿ ®À¿›t¿èmÀœrÀI`;ÀtÇEÀ‘ÛÀ¨WÿÀ¿˜åÀ×ëÿÀñÝÁ`šÁRÑÁªöÁ-Á:›{ÁHW²ÁVdaÁd“£ÁrÂåÁ€ƒ!Á‡½=ÁËÁ<«Á•û¨ÁŽÆ·Á‡—Á€uÁrÉ]ÁdØ ÁW‹ÁI=“Á;óÁ. ¥Á ÕqÁÇÖÁνÀôƒ´ÀÛå}ÀÃ¥‚À¬`¶À•h´À}ìÀSÔ<À+dÜÀ&©¿Â&¿{~ö¾ü¼$½7î}>·ªL?5—`?Fô?›’V?¬ºl?³¯2?±z?¥]?gó?e„×?5>–ê½—˜¾ø¿sm¸¿¹x.ÀrwÀ'.ÀNzïÀxîÀ‘âÀ§¢ÊÀ¾:©ÀÕ‘ÍÀìÒGÁ{,Á÷(ÁÂÁ(žzÁ5ÎGÁC7¸ÁP®CÁ^<ëÁl§Áz(SÁ„+»Á‹C\Á’eËÁ ¨©Á™xJÁ’TÁ‹@Á„C×Áz³BÁlê›Á_,÷ÁQ›íÁD7¯Á7%Á* Á.3ÁÃÄÁvdÀðÏrÀÙ–xÀ ÃÀ¬-SÀ— *À‚œ¶À^\–À9gÀÒ¿ì¿£¿°•Ÿ¿s}ý¿“}¾vÉÚ<þ¾‹>q÷9>·½?>Ð’~>É ,>›Gn>Wx½•I¾¾°t ¿$÷”¿~й¿°ªS¿êãÀÀ5XÕÀZ¹>À€jºÀ”fKÀ©£MÀ¿ãÀÔáòÀët„ÁeÎÁ Á¡Á%kqÁ2$iÁ>ùsÁL›ÁYYéÁfÇöÁtD=Á€ô_Á‡çƒÁŽöCÁ– ¤Á¤3WÁ{Á–ŸÁ0ÁˆKÑÁiÁu6Ág³ÛÁZn:ÁM_kÁ@TØÁ3YÁ'E®Áü/Áÿ¾ÁfÀïØÓÀÙeÀÄ*6À¯ˆyÀ›É À‰-Ào5ïÀMhÀÁÀÖÔÀìEÅÁÁ WúÁµÁ#¥Á/Š)Á;åˆÁHˆØÁU[MÁbF¦Áo~1Á|æ¬Á…-lÁ‹ïîÁ’Í•Á™ÇPÁ§ö5Á¡ŒÁš"UÁ“>ÁŒhWÁ…¡YÁ}Ù—Áp²pÁc¥pÁV«wÁJ‡Á=ǘÁ1ƒÁ%™ÁýÁˆqÁN€ÀñJAÀÜëÀȇbÀµÈÀ£µ†À’’xÀ‚ŸþÀgGŒÀKdÄÀ2“}À«±À ¸t¿õ]T¿ß,M¿Ð›<¿Êð‡¿ÌTT¿ÖDq¿è$:ÀÁUÀ„À"ù”À7OKÀNt<ÀgF‹À‚,~À‘€À¡§þÀ³ó1ÀÆÃùÀÚßÀî·ñÁóÁ »ÔÁ°!Á"ö€Á.ŸœÁ:D2ÁFñÁRc’Á^õ Ák½4Áx˜¥Á‚؈Á‰„nÁ;*Á–÷¹ÁœÁ«øÙÁ¥!Áž7³Á—nÁ­5ÁŠ`Áƒ}ÁyíXÁm!Á`˜ŸÁTI‚ÁH ¼Á<4^Á0ŸÁ%$ˆÁê‡Á5&ÁÆkÀõfKÀâcÀÏáPÀ¾°áÀ®%Àž¬`À.¦Àƒ µÀmâÙÀY„LÀG-QÀ9OÀ.ðôÀ(nÀ%=À& .À*hSÀ2îÀ>Ú‚ÀN6¹À`0tÀs?ÆÀ„äoÀ‘pÀž¢MÀ­[{À½ÀÀÍúžÀà–”Àó–¡Á.Á ðbÁ›äÁ#TÅÁ.OµÁ9•‰ÁE<ƒÁPâÈÁ\«\ÁhäiÁug*Á­Á‡z2ÁùÁ”—!Á›JÑÁ¢%Á° Á©;gÁ¢tÊÁ›¿Á•(ÁŽ¡³ÁˆâÁ¿˜Áw‘ÁjËlÁ^–…ÁRÏ?ÁGÀeÖÀeézÀiÉðÀqáèÀ}‡ÏÀ† ÞÀޏÙÀ—ò±À¢Î\À®š%À»+þÀɹÀØõ!ÀèñWÀú‰ÅÁžÞÁ5(ÁÁ$„ÌÁ/4ÕÁ9íÚÁDïHÁP4êÁ[ÙkÁg]Ás@hÁgQÁ…îÝÁŒC3Á’«Á™$ÁŸ°jÁ¦[èÁ´A-Á­€–Á¦Ø·Á MÁ™ÆÖÁ“M6ÁŒûÁ†ÎƒÁ€¦«Áu%ÌÁij Á]Ù¤ÁR]‰ÁG"¯ÁWÁ4)FÁ*ËßÁ!–ÒÁücÁƒØÁÀÁPAÀôTÀçÒÀÛÑ ÀÑÍýÀÈYõÀÀÿÙÀºŸýÀ¶‚”À³°oÀ²H‡À²ÕÀ´vèÀ¸CcÀ½‚iÀÄWÀÌ#ÀÕ-]ÀÞ­xÀéõÀõú+Á[¹Á¢áÁ5Á&ûÁ ©ôÁ)èEÁ3a¥Á= ÁGrÁQ°eÁ\f¸Ág#•Ár.pÁ}tVÁ„‰œÁŠ_DÁ7õÁ–;ÕÁœj+Á¢²Á© ÆÁ¯w´Á½Á¶˜pÁ°–Á©·bÁ£z¯ÁQ¾Á—*ÜÁ‘&*Á‹P9Á…Š!Á—6ÁtZèÁi{ŒÁ_äÁTž.ÁJÁA[Á7Ó«Á/ ÆÁ&5ÁržÁÏ"Á’bÁË#Á©'Àú@Àð:KÀç4¥Àà*ãÀÚEfÀÖ56ÀÓ’×ÀÒ2òÀÒÅ.ÀÔW‹À×üÀÜáÆÀãAÀêë2ÀóÍýÀý(Áï€Á »ðÁë†ÁÝÌÁ3ƒÁ&¿Á.>Á6ç½Á@<ŒÁIËÁSyúÁ]¨RÁhGÖÁrÿ©Á}¿ÓÁ„gÁŠ "ÁØÁ•­ÙÁ›„ËÁ¡‚{Á§©ŽÁ­ìNÁ´BÁÁ¾—Á»HUÁ´ñŽÁ®¼ÏÁ¨“¥Á¢o°Áœq>Á–žSÁØÈÁ‹Á…{…Á€†Áu’êÁk&—Á`ÿ(ÁWfÖÁNNÁEbÁ<’ÑÁ48Á,x Á%pÁááÁ‹«Án%Á 6ÃÁS^Á)$ÀÿUìÀùòÌÀõçþÀóu?Àò!IÀòµSÀô?¹À÷¹”ÀüHÁ#GÁìÙÁ 6^Á ÐñÁäÁŽ´Á­Á%!îÁ,i4Á3ïÁ;ؘÁD/ ÁM3ÁV˜¹Á`4óÁió*Át:aÁ~ßüÁ„ÌMÁŠ.XÁ¶ÌÁ•Z'Á›&„Á üMÁ¦ÒÁ¬ÊeÁ²éîÁ¹( ÁÆ{ÄÁÀ.RÁ¹ÿ Á³Õ±Á­¶Á§½Á¡ì»Áœ'pÁ–h¡ÁÉ–Á‹SÑÁ†xÁ€Ù/Áwv·Ám¶íÁdiÇÁ[BWÁR¤pÁJÑÁB+.Á:cÁ3Q‘Á,sÁÁ&LqÁ bòÁlêÁ–Á¾©ÁE3Á ÐÁ ÍÁ «ÔÁ Á R¼Á Á ¼ÀÁ ÜðÁÐæÁdÁ„»Á!@Á!æµÁ'ƒÃÁ-l-Á3¤µÁ:¤ ÁAøtÁI¾FÁQÃÁZWÁÁc…@ÁlúÚÁvžÊÁ€96Á…g ÁмUÁÆÁ•}Á›–Á ª7Á¦t÷Á¬JÀÁ²ÇÁ¸VÁ¾,ÁËm@ÁÅA_Á¿ÚÁ¸ýÁ³ bÁ­;[Á§vÁ¡·/Áœ¨Á–Ÿ‡Á‘Y{ÁŒ ZÁ†úfÁ‚ÈÁzµ×Áq|˜Áh¶Á`*ÁWïãÁP0*ÁHΠÁAŸLÁ;3;Á5 eÁ/†ãÁ*£Á%õOÁ"TWÁñ¼Á¦ÍÁ«'ÁÁhÁJøÁ øÁœ¼Á¢µÁ ‚TÁ#ÝüÁ'çQÁ,qÁ1Á6y.ÁèjÁ>xÁ>úÁ=Ú´Á=¡âÁ=¼ÒÁ>lÁ?þ1ÁA¸¨ÁDN}ÁGÕÑÁKqüÁOÄdÁU,8ÁZè†Áa0˜ÁgùgÁo,ÁvóÙÁ~ê Áƒ¼ÁˆX®ÁBEÁ’JgÁ—e>Áœ»Á¢B-Á§Ü´Á­š¾Á³… Á¹–SÁ¿¿ÛÁÅÊ«ÁËÙˆÁÕ²ÁÏ+ÁȾÑÁÂp‡Á¼C6Á¶8Á°5šÁª;üÁ¤k|ÁžË°Á™]iÁ“ÿ‰Á޲ƒÁ‰pSÁ„` Á9EÁuöÁlúDÁdÁÁ]/ïÁUÂoÁO#ëÁISÁC¢Á>ܹÁ:høÁ6Ò"Á4L7Á2‰Á0×wÁ/ÐÉÁ/OœÁ.Þ Á.…ìÁ.G Á. ÖÁ.//Á/ßÁ0‘ÁÁ2h±Á5B”Á8Ñ|Á<~ÁA&*ÁF»—ÁLxÁS5IÁZJ·ÁaÖÁi®ÁqìÝÁzëÀÁ‚KlÁ‡K3ÁŒZÈÁ‘§¨Á—/×ÁœÓ2Á¢ËÁ¨|ØÁ®†×Á´„²Áº‡ÁÀ™©ÁÆË£ÁÑiýÁÊÆÁÄ5wÁ½À™Á·jäÁ±7­Á«)ðÁ¥)éÁŸ/êÁ™_Á“ÂKÁŽN3Áˆï×Áƒ§£Á|×LÁrÙ‰Áiw<Á`7›ÁWÖÁO¦ŠÁH±ÁAÁ:êÙÁ5ÚÁ/èºÁ+z]Á'ŽÁ$òÁ"ŸÁ!O[Á EqÁ¸§ÁJbÁ®Á´ŸÁwîÁªÂÁ¸RÁ!%PÁ#,èÁ&:õÁ)ÍóÁ-·‘Á2ÂÁ8UÁ>xEÁE~ ÁLÀÄÁT‘ÑÁ\™@ÁePÁnÉ/Áx²ÝÁ\dÁ†ž^ÁŒ"ÓÁ‘͸Á—‰×ÁaòÁ£A#Á©?´Á¯DuÁµZÌÁ»“ÔÁÁíÈÁÌÊ~ÁÆA&Á¿¿›Á¹@wÁ²Ì¡Á¬nìÁ¦5dÁ $1Áš'7Á”.$ÁŽ];Áˆ¾Áƒ@äÁ{ÃÓÁq>žÁfë6Á]FÁSÎBÁJ¨zÁBF~Á:¥óÁ3)ÓÁ,‹©Á&®hÁ!Á Á„àÁžÜÁ;OÁȳÁƘÁ0äÁÈ"ÁƒÁ0®Áä\Á2‰ÁSÅÁ¸ßÁ †Á4ÉÁÌ"Á$oÁ$wÝÁ*£Á0±×Á7ÖÁ?u’ÁG{yÁOêÁÁY!ÁbêÄÁlÚÞÁwCÚÁÁ†ÈKÁŒhäÁ’fÁ—ûÁú¶Á¤úÁª$Á°^Á¶¿±Á½*ëÁÈ[ÏÁÁ­Á»ÎÁ´–ÃÁ®8Á§£Á¡T;Á›$°Á•(Á üÁ‰1åÁƒcÁ{}vÁplÁe­[Á[HÁQƒÁGz±Á>9¬Á5A—Á-3 Á%£4Ák6ÁLàÁo“Á «@Á ŒöÁK±Áè£ÁB ÁNÁ«ŽÁJQÁsÀÿ^èÀþ»Àÿ“‚Áï9ÁQøÁÿÁ0~Á ìMÁ»ŠÁ/5ÁÏÁ#[Á*ZÁ2aÈÁ:¤IÁC£YÁM'šÁWÁai^ÁlM~ÁwOŒÁ%Á†ÔLÁŒ¶ Á’µ¹Á˜¿ÁžàôÁ¥*ÓÁ«‘™Á²œÁ¸‰CÁÄSÁ½Q€Á¶•çÁ¯ô˜Á©mÿÁ¢ì`ÁœpÍÁ–ŠÁàõÁ‰Í€ÁƒØÁ{ÒºÁp7=ÁeÉÁZKÁÁO§,ÁEoXÁ;T³Á1ä(Á(±TÁòÁ,Á£\Á ÷ãÁÀý¢‚ÀõVÀíÿÀé55ÀåvÅÀã«#ÀâZÀá¡¥Àá¯Àà\uÀßÇÄÀàÔÈÀãÃÀæíÀëè)ÀòYìÀúŽeÁeÙÁ*ÁgZÁvÈÁ8`Á%y:Á.1cÁ7„3ÁAHùÁK„ÁVÁ`Ú½ÁkÄAÁw¡Áp™Á‡pèÁ}IÁ“¦‘Á™ú˜Á d¤Á¦á Á­nùÁ´¢Á¿Û$Á¹ ŒÁ²IhÁ«†2Á¤ÖcÁžEªÁ—ÉÁ‘B ÁŠÛ‹Á„žÁ} !Áq IÁe?ŒÁY¢@ÁNæÁCÃFÁ9b8Á/qÁ`’ÛÁlVƒÁx[CÁ‚<ÁˆnmÁŽÌ{Á•<§Á›¿âÁ¢Z'Á© FÁ¯¿§Á»ÌÁ´ãvÁ®žÁ§A¡Á }}Á™¿~Á“–ÁŒ›Á†&ÁH Ár¸¸Áf}ÑÁZsÁN¬[ÁC kÁ89Á-;Á"ã_ÁòÁ]‘ÁIÀûMUÀë^ÀÜîÀÎðtÀÃD À¹²zÀ±» À¬ åÀ§ÅÛÀ¥ÐÕÀ¤S×À£¼sÀ¢ÛmÀ¢WÀ¢B‚À£z‹À¥µÀ©œÀ¯«eÀ¶¼ÀÀçÏÀËë2ÀØF›Àæ]„ÀõÓ"Á¾×Á Û¢Á"[Á±mÁ)#QÁ3Ú›Á>¸yÁJVÁUÌÁaÖMÁmø7ÁzrDÁƒž­ÁŠÁ£<Á—JùÁýÁ¤¿ Á«šRÁ·ËêÁ°ÛŒÁ©òaÁ£ ìÁœ9àÁ•uµÁޱÁˆVÁsÁuàÖÁhãÝÁ\8(ÁOð@ÁCþœÁ8êÁ,xÏÁ!zÁ³gÁ nFÁœÀòÕ]Àà›íÀЙ.ÀÀ²ûÀ³¡À¦wÂÀœ5‘À“ñÀ‚ À‰cÔÀ†æ&À…7ÝÀ„š¶Àƒ¯sÀƒf÷Àƒ„KÀ„Ø”À‡ÀÀ‹O”À‘‰ÜÀ™IýÀ£ÎšÀ¯•šÀ¼¬ÀË}ÀÚ›lÀëÇßÀþÁZ÷Á QÁTÁ(2ÜÁ3~*Á?AûÁKQXÁW{¯ÁdÁpëjÁ}ð§Á…Œ×ÁŒ<Á’øÁ™ÊÁ ·Á§¶íÁ³ÿ…Á¬í Á¥ïæÁŸ“Á˜ªÁ‘78ÁŠmîÁƒ©ÊÁyÓÍÁl˜=Á_ ÁR‹ÚÁE½Á9c´Á-mÅÁ!ÌÁä…Á ðáÁ,fÀì ÀØœBÀÆÁ Àµ ÇÀ¥¤—À–á°ÀоÀ~¸Àl7À^-ÀV 5ÀOØÀL7ÅÀJÑ(ÀIòÀH@bÀIŒ&ÀLm9ÀPòÀZEüÀgbðÀx)*À†‰‹À’ç]À ŠÓÀ¯ÝÀ¿Ç´ÀÑë°Àä9ÀøOrÁÍ£Á­ÇÁô~Á(·ÿÁ4ÌbÁA²ÁM²‰ÁZ¦JÁg°îÁtú¡Á2óÁ‡þ£ÁŽã7Á•Þ*ÁœáaÁ£ë×Á°mbÁ©BnÁ¢®Á› ºÁ”6Á'ÜÁ†?Á~ÍÁqDÁc¼.ÁVVÚÁIB/Á<;"Á/K¾Á"ؘÁÜîÁ ê+Àþ¡sÀèÎjÀÓM^À¿eNÀ¬B€Àš¬¹ÀŠE.Àu–FÀ[ZÖÀCv8À/÷tÀ!‘WÀ)ÀÁîÀÀ ^“À ®þÀ mÀ ÀÕ#Àq~ÀûšÀ+¾KÀ=ÎéÀS@Àlž<À„Ú—À”CDÀ¥ÁIÀ·õÄÀË€éÀàŽMÀöRÐÁk’Á.LÁGmÁ*’ Á7]”ÁDbÄÁQwÁ^ß°ÁlkPÁz'ÅÁ„GÁ‹ÎÁ’ ÈÁ™'KÁ V„Á¬ãˆÁ¥¶3ÁžŠÜÁ—`VÁ<>Á‰/Á‚8ÓÁvœIÁhÎÎÁ[4yÁM¬1Á@+µÁ2ö*Á%ìmÁèLÁ O ÁKçÀèªÀÑ~À»¸IÀ¦V£À’¹>À€,ÔÀ]²8À>ÅýÀ"À³&¿êÓÝ¿Êw¿µY¿§Vš¿ ¿›×þ¿—ò¿•3Ÿ¿˜ì¿ ©V¿®i¿ÃYe¿à3MÀ&ÁÀÞ«À4:1ÀRÂåÀs-ÂÀ‹ÍÀžÊŠÀ³UÀÉJdÀßDzÀ÷QNÁÂwÁ)žÁ!fÁ.BÁ;_NÁHÛÁV‘Ádm6Ár]¤Á€1<Á‡HÁŽxkÁ•½gÁÇÁ©ŽÁ¢>ÌÁ›øÁ“ÓÁŒ¨ŒÁ…~”Á|¶ÄÁn¥?Á`»ÂÁRèÛÁE'âÁ7œ£Á*ÕÁ±ÒÁ ¨Á–«Àë–ªÀÓo%À»ôÀ¤_]À޹Às(®ÀL[À(@ÀO¿Ó+‡¿žÿ¶¿j/Ò¿"z¾æ¿f¾­|žŠÄÖ¾mç¾SZ#¾Áy7¸ÁƒäsÁ‹6äÁ’‰­Á™ÝfÁ¦~…ÁŸhÁ—²èÁ_%Á‰¤ÁðôÁuÁg: ÁXöÃÁJì Á=?Á/5lÁ!ÁÍÁ‡EÀò°ˆÀØ–¢À¾¨3À¦F|ÀŽYKÀnÎÀCQÀÖa¿æbt¿¢7¿Dé3¾²ðþ<6ìº>ž‚[?g×?!s?6Ó?A^0?GÍ#?L3 ?Bx`?0d!?oð>»›4=ê·#¾\â÷¿¼¿‹%t¿Íî À AÀ3r«À^sÀ…·ÀQ Àµ€,ÀÏ5Àé"´ÁÅaÁdÃÁ=ÜÁ+ÃÁ9VÁGÞÁUƒ:Ád ÁrÂéÁ€µ,Áˆ _ÁqPÁ–åBÁ£|Áœ&Á”°@Á@yÁ…ÙÑÁ}"ÁnyNÁ`WÁQÉóÁCy€Á59Á'3ÁSÐÁ …úÀûê}Ààâ<ÀÆ%"À¬tÀ‘ìËÀr;¥ÀBaDÀDâ¿Ñ¢`¿'¾Ü»l=¾Á?? &s?q>ž?ŸO?¼l?Íð?ز?ßl?⃫?ãÀ?ÞPU?ÓÝ]?ÂÞ²?¨†?„è*?.í>€p;¾jXR¿K¾P¿´ ÚÀ{À1£À`æÈÀˆ²µÀ¢•|À¼ LÀמjÀóN&ÁŒÁYZÁ#puÁ1Ö&Á@vvÁO2Á]ÇîÁl}/Á{UÁ…ÁŒ™Á”šÁ ×ÑÁ™RÓÁ‘ÔÉÁŠ]:Á‚æUÁvá8ÁhúÁYG3ÁJ¶`ÁÆqÍ?n6”?·?ëù‰@ D@’@$áÒ@+1Ô@.»±@0b@0w\@-²=@'ÄU@–@ʱ?û¯?ɪ£?ŽÂÙ?‡³¼/—¿*Ý`À À}yÀ8‡†ÀlRƒÀzÀ¬ÂÀÇ¿ÇÀãkÍÀÿˆÁ4gÁÕmÁ+~)Á:'hÁHï(ÁWÉöÁf±ÛÁu¦ÌÁ‚WVÁ‰äÁ‘wèÁžRJÁ–²$ÁdÁ‡ŽŸÁ€ Áq'ÌÁb:ÁSL;ÁDbÐÁ5’bÁ&õ)Á—2Á G˜À÷ð&ÀÛ’+À¿„À£ÙçÀˆ›µÀ[5uÀ%Õ.¿ã1¿xeþ[é÷?Ó×?•£Í?ã=@æE@/(ý@FÍ‘@Xî@cB'@j £@mý`@oÞï@oB@lBê@e™û@\7@L¨ÿ@7·ä@ÏÇ?ú4 ?±zË?;n"<ÔÅ‹¿8oO¿¿ÊêÀ±¤ÀIµ0À€|vÀœ({À¸/ ÀÕ,kÀòhÈÁÝ ÁŽ$Á%eÁ4>½ÁC%‰ÁR%óÁaCTÁpp£Á¡?Á‡kÄÁ $Áœ<Á”[þÁŒ²ÁÁ… UÁzÏŒÁkŸïÁ\¸ÁM•&Á>§]Á/¹”Á ËËÁæsÁ7Àé¬ÌÀÍ ÃÀ°n×À”#sÀp-ïÀ8úxÀݵ¿™üd¾ÃÂw>ÜÖQ?™%f?ôãÃ@$K&@I˜@gþ„@€¶Ï@Š™@Ò@”q¹@–¤Ó@—–¾@—3ò@•j@@‘Ü^@Œ|m@„(@q @Sá!@1)b@ä·?¶’?,ör½èl€¿nºÑ¿åNÀ)ÊTÀa±4ÀðÀ«&µÀÈx-ÀæeÁÚàÁ´Á£'Á.Á8Á=ñºÁM"VÁ\W>Ák—üÁzؽÁ… ¿ÁŒ®žÁ™ßËÁ’#óÁŠmÒÁ‚¿çÁv-SÁfÚØÁWˆ]ÁH<ÎÁ9 0Á*žÁ<Á %¥ÀúnÀÜ‘ À¾ÿ,À¢+_À…ŒVÀQá×Àiu¿Â¿H¿*gd>5˜è??Ñ?é·±@&ä@T®Î@}žÆ@ÿ‰@¥ß@¨Ç@¯ò&@³Þó@¶^ý@·>@¶È:@´«»@°Âí@ªÃÅ@¡…§@”ÈÄ@„T¶@`î«@4p¹@— ?¢4v>Ü¡k¾Úz¤¿¦(]À gJÀGÉEÀ>?ÀžïÀ¼¡ÈÀÚiDÀøŒšÁ rÑÁ£nÁ)ÖùÁ9°ÁHXuÁWÌÁfêÁv;ËÁ‚ΈÁŠ‚•Á—ÚÏÁMÁˆ^ÍÁ€¢ÁqÌcÁbWãÁRõ¤ÁC¢©Á4P.Á$ý³Á®Á~èÀîù|ÀÑ-À³>þÀ•aÐÀoRæÀ5Så¿ø+¥¿…þi¾(À@?5¸W?Çbž@Ò@Mü@€Pe@—uÝ@ª÷Ô@ºL @Æ‚N@ÎÄ7@Ó]/@Ö”@Öéc@Ö\@Óí6@Ï©{@ÈÉ­@¾s0@¯ù¶@œþi@†å@]ɶ@)™?åŽ?ms<ˆ½‰¿e¿è¡ëÀ/ÔóÀk}ÿÀ“¾ïÀ±øXÀÐI Àî­~Á—ˆÁßÙÁ%/TÁ4#ÁCÐ2ÁS2\ÁbšvÁrÁ€µUÁˆibÁ–ëÁŽDœÁ†tXÁ}PJÁmÄñÁ^CÝÁNÊhÁ?QÌÁ/Ù1Á lúÁÁÅ„ÀäæÀÆK;À§ò1À‰íÀXÂÀee¿Ák ¿Éï>—h9?—¼x@Qm@<·@qè’@“Š€@­*‚@Ä^‡@ÖVÈ@ã´@í ?@òëì@õ¾—@öš.@õðÈ@ó.±@îcÈ@æ@Ú‚>@É…}@³k?@šåW@€=ó@Hß8@ ¤?ªl>Ëî忬½¿»ÚuÀ_ÚÀVÒyÀ‰¯ÙÀ¨IÀÆéÀ刼Á-Ád¤Á ǨÁ0/ÂÁ?—áÁO:Á^oÀÁmßÖÁ}XHÁ†pAÁ”s(ÁŒŸ!Á„ËÁyî%ÁjFÁZžVÁJü½Á;e#Á+×ÁQ Á ×5Àú½3ÀÛÏËÀ½¬ÀžuµÀ¤<ÀBwÛÀÚ ¿“ƒ¾`r°?6ÌÉ?Ðc¢@!ïá@Z»¬@‰—o@¥ )@À @Úò@ñ[Ac‰AAA 0MA µMA %|A ˆA *ÐAaAÐv@õ@ß̪@ÆžË@«Õ@Žh@b“@''¡?Öý*?<Ã&¾Tœ¬¿“ì±Àï†ÀD+ðÀ€´-ÀŸRvÀ½ò]ÀÜ»ðÀû˜±Á >ÙÁ´BÁ,+•Á;£jÁK([ÁZ¾cÁjaœÁz€Á„Ö³Á’ìTÁ‹¥Áƒ4DÁv±ôÁfÿDÁWT‚ÁG¬sÁ8eÁ(\VÁ´HÁ ÊÀò÷ËÀÓÛJÀ´ÂÀ•ÈÀm­œÀ0 ±¿åˆ¿Vo=ôÕC?ˆ`K@W@<l@vÖ@˜y]@´Ì@ÑI@ì;ËAb…A`Aå*AÖA‹OAüÂA‹°AšìAj‚AÞLAëÐ@ñÌ@Õ>@¸±@šXé@x¤@;÷‡?þ•ó?…<Ø=®gG¿_$Á¿ê 6À2¦lÀpuBÀ—) À¶*ÀÕLÀóömÁ ¢ÁÁ(È Á8t¡ÁH!8ÁWÇMÁgl•ÁwÜÁƒ[’Á‘ˆ%Á‰¥GÁÃÁsÃ×Ád•ÁTHßÁD‘?Á4Ú¨Á%$ÁnuÁ³Àì5IÀÌå,À­•ÀŽI¬À^LˆÀ ‡¿Ãµ ¿ ÿ>Ðùu?®ÓÆ@˜é@QÅ/@‡*@¥7Ó@½5@ßÓû@ü:BA !vA cA#xÖA(cÎA*aPA*ÓBA*-+A'é˜A$œA¹±A ã¤@þ{¶@àŸ@‚x@¤;a@…ïß@Oe@”E?§B[>­p¶¿ >ø¿Ë™½À#‰ÿÀaMmÀ±4À¯–ÀÎ\ÄÀíµòÁ‡Á4'Á%à¾Á5UÁE80ÁTÝwÁdˆEÁt=ÁýÁ5¬ÁˆP÷Á€lBÁq3ÁaI ÁQƒNÁA½’Á1÷ÕÁ"3éÁtÁ¹öÀæ¾ÀÆ™‘À§,cÀ‡¿6ÀPÑÀ#V¿§7¾§V?%Z?Ï @%Ȉ@dŠ@Å”@¯[·@Íì@ì"BAûA”ÌA!Ó¦A/¬&A6ábA9è¥A:©ÃA9Â8A6ÿâA0ÚïA"%AYDAS“@êH}@˹é@¬ôd@úØ@^@ Qõ?Å)¨?￾γÁ¿°˜ Àø[ÀU¤²ÀŠ(„À©~°ÀÈÔÛÀè+ÁÀàÁmÜÁ#!¥Á2âÍÁB®6ÁRhÁbQ8Ár#pÁ€úþÁŽè/Á‡ÇÁ~>$ÁntºÁ^«QÁNáèÁ?~Á/OÁ…«Á¼PÀÿì¤Ààa+ÀÀÕ±À¡J8ÀÇtÀD°WÀÕý¿÷D¾w?ZäL?ëV@4#æ@rÀ@˜|É@·™J@ÖµË@õíA 5}Ax–A(A7?ACž’AF`PAJS%AI,•ADç¬A6 A&÷ÎAôAZñ@ñä\@Òñ @³ÈO@”Ÿ@jí£@,’[?ܶ?=]¾xŸ¿œ À ¥ÀKß À…S8À¤ËûÀÄXÙÀãåöÁ¹‰Á‚Á!QzÁ1%Á@øãÁPÌ«Á` tÁpt<Á€$Á¬öÁ…ÄæÁ{¹ªÁkéˆÁ\gÁLI”Á<}ëÁ,´´ÁëJÁ !áÀú°ïÀÛÀ»‹JÀ›øwÀxËHÀ9¥²¿õÊ¿mÝÇ=gàh?…Y›@‡(@@aƒ@;Ý@Ÿ @¾xI@Ýås@ý1ÏA&¤A²A->yA<¤¶AKê„ASQñAVó AXF—AI A9¥¼A*?rAÅA 3&@÷B‰@ØÆ@¸ì‘@™µ§@t²È@5ßá?íÂw?_ŠY½ã迌BïÀC©ÀDeÚÀÄÀ¡UÀÀæ6ÀàwOÁ¦ÁÔÁ©@Á/~2Á?SUÁO(œÁ^ýúÁnÓZÁ~ªIÁŒuuÁ„wÁyJóÁizøÁYªüÁIÛÁ: Á*; ÁkÁ ›Àõ–ÀÕõÍÀ¶WœÀ–õÀnaÅÀ/<¿à,ó¿CÃP>cM?š´î@ €@K¥Œ@…^?@¤é¹@Är&@ãßTA¦@A\×A!nA0ÊA@}sAP ]A_•HAcþqA[TÈAKåAÄŠx?¯‡ö@é @VF@Ššv@ª-I@ÉÀ@éRîAràA<A$ÙA3ÆóAC}ŠAS4 Abê·AmyÕA]áNANHÈA>°BA/»AeÝA¦Ë@ÿѳ@àX„@ÀßÃ@¡g@îA@Dã@¾?Œ|ø=݇?¿a˜ ¿ïoÀ6ÿÀvF²ÀšÌöÀºƒ×ÀÚ>jÀùû‡Á ÜRÁºàÁ,™nÁ_™E¿Eг¿áÃÜÀ0O¯Ào½pÀ—•¹À·WªÀ×ÂÀöáÛÁ SyÁ6Á+’Á:ûÁJÝ­ÁZŸÁj«%Áz–‘Á‰ ÔÁ"LÁro‰ÁbšDÁRÃÇÁBíIÁ3ËÁ#@NÁiÁ‘°Àçt‘ÀÇÅÃÀ¨ÚÀˆiòÀQxÀ+¿¥“B¾›¨¶?/l`?ÖP>@*u&@iÂ-@”†Ã@´&º@ÓÆ±@óf§A ƒOASKA)#FA8óAAHÃ=AX‘„Ah^ËAr2yAb}ÁARÁZABõA3(¨A#\OAöAÄ @çòH@È_f@¨Æ‹@‰ ¯@R’€@£?§Š> W8¿-§Ñ¿Õ½À*S›ÀiÈnÀ”ž¡À´Y ÀÔ‡ÀóØ/Á Ô›Á¾(Á)§´Á9’ ÁI~AÁYjàÁiW~ÁyDÁ‡ôtÁ€PÁp4 Á`XÁP{¦Á@£Á0ÍêÁ øÛÁ#ÌÁN½Àâó\ÀÃFÀ£™„ÀƒìˆÀHÀ %$¿“’̾&¼V?SÇm?èœP@3©ù@s@™,T@¸Ö™@Ø€Þ@ø'ßA ç1AºsA+µA;`÷AK2ÍA[ÈAjÒÄAtEßAdxlATªùADÝ…A5A%?ÑAk‹A—E@ë…ý@ËÑÖ@¬m@Œ]@YE3@Ð`?´·>×5Ë¿8g¿È*,À#»JÀca}À‘ƒØÀ±VòÀÑ* ÀðüÁb ÁFJÁ(*tÁ8ŸÁGòÉÁWÖóÁg»Áw mÁ†3ÛÁ}âkÁn ¾Á^/wÁNU/Á>zçÁ.  ÁÆXÁìÀþ#ÕÀÞpÀ¾³zÀŸXÀ~´tÀ?`9À ý¿oƒ¼±Âå?wÔx?úž)@<© @|@®|@½[x@ÝË@ü·›A3A šA-Þ¼A=³ßAM‰A]]ØAm1Av=AfG}AVq÷AFœ·A6ÇÑA&ó[AAJÎ@îí@Ï?Ã@¯…Z@Á@_Û×@ 6î?ÁXó?_¾ó"R¿»ÙXÀuÀ\ýpÀŽBéÀ®ÀÍÌaÀ픑Á®sÁ”QÁ&}„Á6d³ÁFKRÁV1ðÁfÁuÿ.Á„½™Á{«JÁkÑiÁ[ùÁL ³Á‚´æ?Ÿw@(Ú@N‘ù@†ýŒ@¦²@Æfª@æéAæÜA¿mA"”|A2i‹AB>šAR©Aaè¸Aq¾VAyÔ~Aiõ2AZ AJ93A:[\A*}„AŸ¬A ÁÔ@õÇø@Ö I@¶N@–„˜@mvP@-ãp?Ü¡ ?:öÁ¾†¶¿ bÀÀ¢iÀOrÀ‡B=À¦ÿ ÀÆ¿ŽÀæ€Á LÁŽÁ"àÐÁ2ÁÁB¡UÁR—ÁbaÜÁrBVÁ‚ɾÁwü.Áh9âÁXKÖÁH`>Á8w·Á(›Á©ÁÂbÀñ¶‹ÀÑèSÀ²À’KáÀdûPÀ%^޿˄ڿÄ®>ÉœZ?±)ˆ@õý@WW6@‹\7@« Ô@ʽp@êplA~AìÅA$Ç A4¡UAD{œATUäAd/&AtŒA{¬—AkοA[ðçALûA<+CA,FùAe¼A ˆ‹@ùX’@Ù @¹ç‰@š/@tí@5{÷?ìÜ?Zg•¾œ¿Â¦Àâ\ÀGcfÀƒr8À£2¼ÀÂóAÀâ³ÆÁ:rÁ¢Á! ~Á0öGÁ@ß/ÁPÈÁ`±Áp™éÁ‚.-Áv³èÁgLÁW%ÁG+IÁ71èÁ'9ÁAÁJÀî¨SÀμÈÀ®Ñ=ÀŽåÐÀ^´ÀV¿½s-¾øé%?ý4?À7}@¸0@_T¢@xŠ@¯@@Ï @îÑAH#A qA&ø¿A6ÑAF©\AVªAfZÅAv5 A}ˆ¨Am¬fA]Ð#AMóáA>ŸA.;]A_A‚Ø@ýM,@Ý”§@½Ü#@žÀ@|¼v@=;m?ûtÆ?xåg¼¹ÞÉ¿‚S¯ÀßòÀ@– À€&ÀŸý”À¿ÏeÀß¡6ÀÿsÁ¢ÄÁ£Á/ùÁ?rêÁOgÄÁ_]ÁoRFÁ‚ÁvtfÁf†úÁVˆÑÁFŠëÁ6VÁ&,Á“ŽÁ—=Àí5×ÀÍ=4À­D‘ÀKïÀZ¦˜ÀµS¿µˆ¾Ö–@?yö?ʆ@%@dòN@’qÉ@²jl@Òc@ò[±A ìAÿíA(âçA8ÅáAH¨ÛAWèAf«µAuH{Ax’AožaA_Ä/AOéêA@ÃA0 ÓA 8¼AQØAl@á «@Á2@¡Vû@{î@CAÃ@‹©?‡Åš=‡åG¿nFÀ¿öÍhÀ;;¸À{¼ÀràÀ½]bÀÝGäÀý2fÁŽtÁƒµÁ.xöÁ>n7ÁNcxÁ^YÁnO¯Á‚m÷ÁvXmÁfY^ÁVZWÁF[XÁ6\cÁ&]}Á^¨Á_ëÀì¢ÀÌÅÓÀ¬É ÀŒÎuÀYªtÀÀµ¿³Þš¾ÑQM?kç?ÊÀ;@%%A@dêd@’WÄ@²:V@Òç@ñÿyAñAÑ?A(gA7ýÜAFý?AUÂfAdUÐArÍAyYËAp#A`šµAPÈ'A@í7A1GA!7dAXrAdr@âá(@Âùm@£±@ƒ)ö@F„u@´þ?¼+=ßÒ ¿cƒÎ¿ñ€ðÀ8ŸýÀx©Àœ/ÉÀ¼ÌÀÜ×ÀüéÁ ú˜ÁõëÁ-òÁ=îïÁMìÁ]éSÁmæ›Á‚ù?Áv®%Áf¶ÁV¿ÁFÉšÁ6ÕôÁ&ä«Áö{Á ÓÀî:XÀÎa À®‡¾ÀŽ®vÀ]ªeÀ÷ø¿¼‹«¾ô¡¨?u¢?Áž @ €£@`2@@ñï@¯Ê¾@Ïgf@îÐ]AIA¢ëA%óçA4ôAC›HAR5A`©Al=Am7AhYëA\.}AN#:A>Ú»A/L%A¢óA÷^AG+@àó‚@ÁI6@¡žé@ô@Dd#@Ýq?ŠjI=ª¢¿jMi¿ôï3À:[ÙÀz@À,À½KÀÜökÀüèŠÁmUÁfqÁ.`PÁ>ZüÁNV:Á^QÁnLçÁƒàÐÁwààÁgô7ÁXÁHäÁ8.;Á(A‘ÁTèÁh?Àð÷+ÀÑæÀ±FéÀ‘nëÀc-ÜÀ#}â¿ÇŸª¿¥©>×eÞ?´I*@M@@Xuê@‹ÏJ@«Fí@Ê4‰@é×AËŸA®ÉA!:´A/oöA=”¾AKgŽAWnA^\A^(rA[öAQÑ¢AFbA8÷aA*æOA A Ε@úŸ9@Û¡I@¼fw@­@{A$@ôúÁNèÕÁ^ÞnÁnÕkÁ„˜„ÁyE ÁiY ÁYm ÁIÁ9—+Á)°ÅÁÏÁ ó„Àô;qÀÔ^À´åKÀ•<‚ÀkMÒÀ,%'¿Ùøú¿7OK>ˆý ?Ÿ¼v@z@L â@„òz@£§N@ÁÜ_@ß”D@üŠQA ŽA™NAt6@ñ–@Ó~@´é¡@–9ã@n£W@0'+?ãUþ?L»N¾7òÅ¿”žÆÀ šÀHãÀƒƒBÀ££ÀÂ¥RÀâ^ŽÁYÁñkÁ Ò|Á0³ŽÁ@” ÁPu²Á`VÃÁp8™Á…gnÁzö¤Ák!Á[KÁKvÁ; zÁ+ËÁúnÁ 0ÀøËÇÀÙ8DÀ¹ºðÀšZcÀuö?À77¸¿ñQ¿jÄ =AÎg?7k?ü^Ð@;žH@w–@™ Þ@¶Jì@ÒÎ @ï~AT·AëMA rA+þA5CïAA ï@ÿ–O@ä~@Çë @ª„p@ŒÌ@]lâ@ @Œ?Å—^?[I¾Æ!w¿®?FÀ}KÀSóÀ‰7¤À¨‡ÙÀÇömÀçu Áz­Á:ÕÁ"úýÁ2¼ôÁB‡¶ÁRZÁb2ŠÁrÒÁ†|cÁ}%*ÁmVèÁ]Œ¨ÁMżÁ>ÉÁ.QòÁ¢PÁò®Àþ†Àß&ÕÀ¿Ó:À º¡ÀíTÀFa!Àèý¿–á²¾eÜè?9|Ö?ÓN@$Z@_2€@ŒA4@¨fû@Ä9ô@ߘ½@úšA ÜAŸXA§õA'–¢A. áA1ä)A0— A-¹UA)‘;A"ÉÿAlA6AŠj@ìüY@ÓK»@¸ª@œ»¥@€‘Y@Fzö@ Óo?Ÿ3->™ÀW¿&I ¿Î À$z¤ÀbEzÀ8…À¯\ÀΉËÀí·…Ár Á íÁ%º±Á5uNÁE3éÁTóáÁd´ Átt1Á‡¼6ÁÇÁpoÁ`h6ÁPºÁA NÁ1bAÁ!ÀåÁ4Á¾ÖÀæ¼ÃÀȱÀ©DŸÀЦÀXYåÀx“¿¾bù¿>³Ê[?¢@ ž@CB+@{@™,«@³ïÎ@Î{@ç­@þrwA ¡HA=¶A¨AUtA"e!A!G»ANAp$AA lA}ë@îéz@×ó@@À¨@§(@Œ—Þ@bÇj@*¯:?äÞ?_O½7ñÌ¿xæÔ¿ôõ À7 ÕÀsÒsÀ˜l¹À·& ÀÕñçÀôûÐÁ ÌÁ”óÁ)+Á8ÁâÁHX¿ÁWò#Ág–¨ÁwE‡Á‰I„Áu ÁsEûÁc«:ÁTªÁD›×Á5(—Á%ÆrÁhiÁÀÀÑ*þÀ²ºUÀ”O¸ÀlóRÀ2]ß¿ïÙ¿uú½t½Ê?UÓ?Ú³ @$ß@Z«@‡Ï @¡³@ºNd@Ñ P@æ¯W@ù= Av¹A QÃAowAÄÅAÍÝA(GA Hß&˜¾âyf¿­×žÀ’ýÀLFFÀ„&îÀ¢KðÀÀ©ÚÀß )ÀývéÁBÁhÍÁ,á Á´Wõ?™ý@ ¤@7ñ@iøc@iñ@¤°@º@Íâ@Þ.(@ìÓ@ù3ÄA7FA$hA?1@ÿ¸E@ø,l@îñ-@â¸<@Òc@¿5û@ª—Ž@”{˜@{`Ã@LG©@5A?Ðã?Lã½!Ka¿jÕƒ¿åË(À+2#ÀeŸ(À#À­vŸÀËüÀé1ÁµPÁæeÁ"Á1IYÁ@‰yÁOÞÈÁ_KòÁnÌXÁ~VüÁŒþÁ…KÌÁ{E Ál4Á\ËßÁM•Á>d±Á/7¦Á "²Á/ÅÁaÀçp§ÀÊ=‡À­ ÀZsÀg±À/¿ïÄ¿j*¾-ñ™?*'ü?¼ùË@Q@A7@oS’@1¥@ ú’@²©c@Â`²@Ðeœ@ÛŸ×@ãѪ@æñ¢@åV0@àÏV@ÙÀS@ÐȘ@Åê@·hµ@¦Ÿ@’@Œ@zÁ:@N‰M@!ã?ä?‚½>sô¿k¿´ü“Àb}ÀI„2À€×ýÀ “Àº)/À×|µÀôÐ;Á [Á ’Á'Á6F¶ÁEwÝÁT©ÁcÚ,ÁsÁ0¿ÁAÇÁ‡§QÁ€÷ÁpðzÁaÃÉÁR«zÁC­»Á4ÁÈÁ%ô4ÁJØÁ¹ÇÀôR+À×’ïÀ»"ŽÀžÔ”À‚ÍaÀN¯aÀc-¿Åy¿8>=¤O?Zª{?Î]@@q@@þ@hép@†¡ã@—^@¦I@³(5@½©e@ÄÞL@ÇŽ¡@Æ(y@ÁÒx@»@²[@¨p@›K @‹n-@rv¼@J–:@ SW?è0q?¶ >½ã#¾ÃÁ2¿”Œ™¿üµûÀ3>€Àhœ›À#¸À¬4WÀÈDöÀä—ÁÃèÁk(ÁëÁ,ÀjÁ;’áÁJ’]ÁY«ÁhØ-Áx UÁƒ>Á‘¾"ÁŠ'úÁ‚šÌÁv4CÁg:öÁXT`ÁI‡òÁ:æ#Á,TÊÁÄýÁe¹Á6JÀæšÀÉákÀ®T×À“Àp@ÒÀ:¡;Àa¿¨É¿ f=>U¾?kÞ˜?Ía@×Õ@54Å@Xœ@wPÇ@‰»Ã@•}@ŸG@¥¶‚@§ü@¦Ä\@¢Ò›@œd @” @@Š\Ä@}wü@_÷ @>pù@©×?áV¸?‹Êé>Í"ô¾›>Õ¿…|¿ä³À#ØžÀW2À…ÿ[À y}À»›+À×–1Àó¦ÑÁÛ¸Á™Á$zûÁ3ÇÁAÁïÁPk{Á_)DÁnèÁ}¬Á†ïÁ”]|ÁŒß¤Á…d÷Á{ç¦Ám&%Á^‰²ÁOóµÁAcFÁ3;Á$ÛMÁ´PÁ³ÀõRÀÚµÀ¾ârÀ¤?À‰¨VÀ`oÏÀ. k¿ùËu¿™¾ú‰'>Lî{?Zî'?º!|@ò@ ß+@>û¬@Yb@o¨!@€¡p@†Ž¸@ˆij@‡[\@ƒÆG@{T@k@Xg@Bƒß@'»½@‰ ?Ë‘ƒ?zûä>µ…[¾¤Cq¿žø¿ÛUsÀÎáÀL/´À}˜+À˜SjÀ²_vÀÌÑ7Àç›þÁÒÁ„UÁŒ¥Á+–-Á9ÄÃÁH6óÁVÒYÁes¨Át)Áe/ÁˆÏŽÁ—-1ÁÁðÁˆgÁÁs›Áe tÁV®ÕÁHƒ_Á:]Á,6òÁ7ËÁ€ãÁÙWÀêÓºÀÐ6úÀ¶TÀœåÀƒÙ(ÀV±æÀ&¤Õ¿ó3ß¿š%u¿ f =‰¤›? /?”5€?Òâá@ž@@Í?@3c˜@C§¥@Nk3@Q­œ@OžÒ@I\@=ßõ@.ž@È¢@eÇ?Þ³?¢9^?Bs>Bö¾Ù_&¿‡f¿Ýì¡ÀCVÀGöÉÀwƒÀ“+MÀ«³_ÀÅ1ÀÞÔ¥Àù1SÁ áXÁgðÁ%66Á3=’ÁAEâÁOT¨Á]‰%Ákö=ÁzŒWÁ„”õÁ‹åÅÁš?_Á’ñsÁ‹£ïÁ„^ÕÁz`ÎÁl3FÁ^ÁOé#ÁAÛ)Á4,Á&YÊÁÍ/Á ~ðÀü¨ôÀãªÀÉ’UÀ°¼ÈÀ˜B÷À€uÀSâºÀ'¿ùõ¿¿ª<Ž¿@1j¾UËç>—,[?Cwx?—¥?Åë‰?í2u@°y@,ò@ˆd@†ì@ >?ÿ«Ù?á{G?¾Ž?•©?P›>ÆNνÅ@¿‘¿›…¿ê-…À¯ÀId3Àu·0À‘,ÚÀ¨­ÀÀM€ÀØ€ÀñØ÷ÁÁ×ÁÈÌÁ >Á-tÚÁ; ªÁHîŠÁVöÏÁdÿÁsŸÁ€§Á‡ÛÅÁ$<Á|IÁ–:Á Á‡ôÁ€âÁs  Áe‰™ÁW¯iÁIì†Á<>xÁ.âØÁ!¯‚Á£0ÁÛ÷ÀöE“ÀÝ¥ÀÅG‚À­£dÀ—ÃÀ€–ÀVâ›À.å;À@ç¿Ê{Ž¿‡¸9¿y6¾›>‰Kg?_è?f(ñ?ŽžO?ŸÝa?¦´4?¢ŸA?–ׂ?‚ÆG?MY?J}>gwZ½Þñ ¾ÿ¦`¿vö¼¿»¨mÀ—£À'0ÅÀO Àxz\À‘é À¨…À¾bVÀÕÏäÀípRÁÄeÁP·Á#:Á)'Á61¥ÁC‡OÁQ 1Á^¸ÍÁl§¼Áz° Á„\ÒÁ‹lÁ’‰×Á é\Á™ÏÞÁ’½âÁ‹«æÁ„Ÿ2Á{U¬Ám‹1Á_ʬÁRHõÁEíÁ7ëïÁ*û‹Á6ÁŠ<ÁPyÀòUbÀÚÔ±ÀÄ:DÀ­·À˜e•À„VÀa$À=pîÀS›¿ör¢¿»m¿„ é¿)û¾ªîÀ½…6±> ¿G>…ƒ{>ž€Ç>Œ>GõŠ=<Œ¾( Ͼ×PC¿6ÌÇ¿„§ð¿´l¹¿ìf˜ÀÙÀ5Î!ÀZ6=À€y”À”v?À©oÀ¿üÀÕOrÀ뙇ÁybÁ I‘Á= Á%ºÁ2„Á?[‰ÁLc³ÁY¥•ÁgµÁt©LÁ4¤Áˆ0|Á4¤Á–;‰Á¤™ÃÁ‡ÇÁ–zWÁ€ÖÁˆ˜‘Á³ƒÁuÅÁhoêÁ[H”ÁN1[ÁAUœÁ4Á(ðÁÕØÁ´;ÁÀñe:ÀÚÛFÀÅYÿÀ±<êÀ_†ÀŠþÌÀràlÀQÖ.À33ÛÀ˜^¿ùµÞ¿ÌDt¿¤já¿„.ð¿WÜü¿:7G¿.ç ¿4²e¿J:¿n?c¿ƒ¿°K¿Ôg ¿ý³nÀTØÀ.ñòÀL˜ Àl…‚À‡*À™ï`À­lqÀÁsXÀÖ ÜÀìWÁD°Á hÍÁ ðÁ#ÚûÁ/¿!Á<&ŸÁHæÁU»\Áb¥þÁoÌÏÁ}-¶Á…ZÁŒ&±Á“BÁš Á¨U£Á¡Y7ÁšméÁ“†RÁŒªÁ…í†Á~¦¶Áq„9Ád}KÁW¯­ÁJïoÁ>Á2\ÉÁ&CiÁ?ÁKÁÿØÀòNwÀÞ(­ÀÊCÀ·FïÀ¥•ƒÀ”¼úÀ„ÇoÀkíKÀPMvÀ7‹dÀ" ãÀk›ÀF’¿é’ä¿Û˜&¿ÖŒö¿Ù!¿âþë¿ô$/ÀçÀ•hÀ'5ŽÀ;^ÀP}ÙÀh”~À‚˜9À‘ÅlÀ¢¿À³’×ÀÆÃ¡ÀÚaßÀÁéYÁ ÇRÁá¦Á#'Á.¢øÁ:mîÁFH*ÁR•¯Á_G›Ál¿Áx÷&Á‚ÿþÁ‰¤¡ÁaHÁ—&XÁûkÁ¬DÄÁ¥[fÁžwÓÁ—­·Á‘:ÁŠpÓÁƒäZÁzЙÁn ¿Áa[”ÁUðÁHã¹Á<ÖIÁ17>Á%ã¢Á”JÁ§=ÁŠ8À÷&zÀãÄîÀÑÝ6ÀÀ‘ZÀ°$À ÄµÀ’¡À…o¦Às\nÀ^-¼ÀL¨#À>ŽïÀ3íÀ-&ìÀ*òÀ,"îÀ0šcÀ8”VÀCþ¬ÀSW Àd`Àw0À†DÀ‘ÙÀž÷ŒÀ­ºÆÀ½›gÀÎíÀàH“Àó—âÁ«§Á ÓeÁ‚YÁ#c;Á.~Á9¢ZÁE:¡ÁQÁ\ÖÁi ôÁu¬1Á?Á‡©ÀÁŽ!êÁ”¶»Á›j'Á¢-sÁ°JÁ©uTÁ¢»íÁœåÁ•ŽsÁ Áˆ”©Á‚2…ÁwÑDÁkŽàÁ_jªÁSk¬ÁGÑqÁ<|@Á1+¹Á&0ÁÁúÁ2BÀþ$éÀìŽ_ÀÛÞÀËø÷À½)pÀ¯V§À¢¸À—¢ À’uÀ…’À|×LÀsÀÀl®­ÀjâÀkµTÀoâ‹Àw(hÀ3ïÀˆŒÀÅGÀ™ÎrÀ¤=?À¯o‚À»ŸeÀÊÌÀÙ$ÐÀéqaÀúY8ÁOÁ7ïÁ&_Á$g0Á/ Á9ÿ:ÁE´ÁP@KÁ[ÓjÁg™ËÁsg^Á‰²Á† ðÁŒoÃÁ’ÚqÁ™IÌÁŸÐ‰Á¦wÁ´}Á­ÒTÁ§=]Á °%Áš,lÁ“Á²ÁdÓÁ‡'Á èÁuñŸÁjØÁ^kÈÁSÞÁGÄxÁ<¾¤Á2uûÁ(vÏÁ‘(Á:«Á ]ÐÁÙ?À÷ndÀçðÀÙÏ ÀÌ”œÀÀL=Àµ–À¬0»À£ûÀkÀ™¤À–!®À•$áÀ•£ÝÀ—•ZÀ›´À t’À§l)À¯Z‰À¸]ÜÀÂdSÀÍoÀÙ¹ÀævÀõ6 ÁzÁ ¥ÄÁmÎÁ÷pÁ&©žÁ0¡«Á:ý_ÁE¶RÁP›ÔÁ[¹MÁfÞÂÁrmÁ~1¦Á„ý§Á‹ŒÁ‘@Á— tÁž "Á¤veÁªñ|Á¸ìÔÁ²ZãÁ«ÒÈÁ¥T›Ážî¾Á˜›ŽÁ’gÏÁŒNaÁ†=xÁ€MªÁu8Ái­}Á^^FÁSQ ÁHìžÁ>ìbÁ4ûàÁ+|ÔÁ"ªÁÐ Á€}Á žÁ3GÀö£#ÀéÓyÀÞJìÀÓ¦dÀÊØZÀÃ+×À¼ÔÀ¸¹_Àµ÷–À´úÑÀµmÀ·=©Àº¿{À¿ÌÞÀÆL9ÀÎÐÀÖðâÀà‹«ÀëŠÀö²)Á‰˜ÁʯÁE„ÁeÁ ©ŸÁ)Â|Á3aÁ=6ÁG##ÁQ•,Á\QÁg97ÁrWMÁ}}›Á„ƒ›ÁŠe.ÁHÁ–JqÁœyøÁ¢Ñ‡Á©;ÔÁ¯¦‚Á½{ïÁ¶õ’Á°!ÁªvÁ£ÕÎÁ¨îÁ—‘ÙÁ‘ƒÇÁ‹šgÁ…Ð^Á€# ÁtùÁiæ4Á_iˆÁUbCÁKm+ÁAÊOÁ8¥ƒÁ/Ý/Á'iÐÁ\bÁ–½Á•³Á ëŸÁ›TÀüS¦Àò(PÀéŒãÀâh«ÀÜLáÀØd4ÀÕÒ*ÀÔÐÁÀÕ6CÀÖôÀÚc’Àß8«Àå2FÀì÷OÀõ…|ÀþÌüÁžQÁ '®Á0aÁûÁZXÁ&&YÁ.PÁ6лÁ@#ÜÁI˱ÁS—yÁ]ªZÁh-üÁrëüÁ}×.Á„zÍÁŠ`ÁÐûÁ•±ßÁ›”ZÁ¡Á§¶ÜÁ®&Á´l…ÁÂyÁ»«ÁµR9Á¯åÁ¨êÁ¢ÕQÁœËcÁ–ç‡Á‘§Á‹o\Á…Ê@Á€>±ÁuìÕÁkØ%ÁaÞèÁX~ÁNÓØÁEñ˜Á=[VÁ5XÁ-CÁ%Þ/ÁüRÁŠ¢ÁŒÁ 0*Áp[Á.¿ÁÕ_ÀûçÍÀøüÀõ²=Àô¦±ÀôÿvÀö³ËÀúÀÀþ¦°Á$CÁì;Á ^Á©®Á±üÁ Áÿ~Á%I"Á,‹#Á3ûáÁ<VÁDA9ÁMTÁVÁ`6ÁjžÁt5¸Á~ÆçÁ„ØÁŠ:ÊÁÊÁ•^Á›ÁÁ þÔÁ¦à«Á¬×Á²ö3Á¹9ûÁÆÙ’ÁÀ‰RÁºROÁ´,ÆÁ®ÉÁ¨Á¢4íÁœjöÁ–»«Á‘<Á‹‹ Á†:‰Á'ÁxP¥ÁnwÎÁeDÁ\¸ÁSeçÁJúbÁC‘Á;DMÁ4C–Á-ŒñÁ'3_Á!’ØÁGpÁÌ­Á¶vÁvpÁ ËOÁ äaÁ ÊlÁ >QÁ dlÁ <âÁ ÕÿÁ [ÁȯÁdDÁX»ÁîsÁ"ŨÁ(Á-Î×Á3ß-Á:½BÁBDÁIÒ¬ÁQüSÁZPWÁccòÁl÷/Áv¥Á€F+Á…bÁНéÁGÁ•Š&Á›jÁ ­ÓÁ¦làÁ¬KþÁ²-IÁ¸CÁ¾7ÁËÃ5ÁÅ“2Á¿oTÁ¹\YÁ³]‚Á­‚]Á§¸JÁ¢!Áœf@Á–×ýÁ‘€‹ÁŒc1Á‡b6Á‚naÁ{d¬Ár9¡Áis.Á`èµÁXÀ ÁPë\ÁIÁÁB©Á<+óÁ6 Á0™/Á+„Á'(þÁ#NÔÁ ¦Á¤‘ÁÀyÁ»¾Á)IÁJÁ"Á¨"ÁÛÁ!zÝÁ$ãÅÁ(¸Á-3†Á1èÁ7#Á<¡¾ÁB¨2ÁI MÁPM‰ÁW·”Á_½©ÁgçdÁpzÁy¿ßÁ°¨Á†‹yÁ‹… Áª„Á•ü_Á›_Á Ù–Á¦h×Á«ý«Á±»FÁ·™UÁ½z"ÁÃh^ÁÛ\ÁÔÄ£ÁΙ;Áȉ:Á‡Á¼˜†Á¶ÆnÁ±‹Á«ˆ”Á¦¿Á ¹lÁ›sDÁ–BKÁ‘5ÁŒl•Á‡ÊìÁƒAÏÁ~ÿÁvZGÁnË€Ág­Áaf»Á[‚AÁUÿ4ÁQ‚‚ÁMfEÁJÁG}°ÁEXWÁD ¸ÁC.ùÁBš2ÁB@ ÁA÷BÁA¤8ÁAR‡ÁA›BÁB·ëÁCìÁEÜÁHÁRÁL ‡ÁO¹«ÁT4½ÁYzÜÁ_Áe9¥Ál?EÁsxÞÁ{@³Á§®Á…ß#ÁŠi“Á:íÁ”.ËÁ™7ÔÁž}ôÁ£üšÁ©p Á®ôÁÁ´™Áº^®ÁÀE¦ÁÆJïÁÌX<ÁÖJ ÁÏÛlÁɉ‹ÁÃW5Á½BµÁ·=+Á±LäÁ«zñÁ¥ÊVÁ BŸÁšØÏÁ•{HÁWŒÁ‹SÝÁ†V0Á ïÁzmÁqLÁhñÁaX·ÁYÝgÁS!AÁM)ìÁGfÃÁBŸ4Á>rÁ:ÊGÁ8/œÁ5îÂÁ4ŽkÁ3¶Á3»Á2Å8Á2w&Á2"ÿÁ1ØDÁ20^Á3SbÁ4ƒ€Á6©›Á9µÚÁ=þÁ@òÁEÊ”ÁK24ÁPìzÁWˆÂÁ^š¯Áf$>Án5¬Áv{ÃÁ^uÁ„c#Á‰L?ÁŽOÁ“}‡Á˜ÌYÁž,bÁ£²VÁ©UÁ¯ÔÁµVÁ»tÁÁÕÁÇ?ÁѪYÁË#üÁÄ«ÙÁ¾P÷Á¸ðÁ±ýFÁ«ôÁ¦IÁ /€Áš‚Á”ûËÁ’*ÁŠ:ÕÁ…"ìÁ€<¯ÁvÚÍÁm«¨Ád~€Á[Ì”ÁSØþÁLMÁEÄÁ>ØêÁ8ùÀÁ3ÖôÁ/œùÁ+©«Á(á¦Á&“Á%cÁ$=ÓÁ#§"Á#KëÁ"÷ Á"¡ÅÁ"mŽÁ"Ú“Á#ø,Á%/çÁ'¶Á*ªbÁ.ºÁ2W¦Á7kcÁ<ðÔÁC7ÁIíåÁQ¦ÁYÁa?|Ái÷MÁs9Á|¥ÃÁƒ'ƒÁˆCÿÁ‰vÁ’è¼Á˜pÁžAÁ£ÒþÁ©¼SÁ¯Æ)ÁµÖNÁ¼zÁÂV•ÁÍzÁƆRÁ¿ÿÔÁ¹€:Á³`Á¬ØÂÁ¦¹'Á «¯ÁšµµÁ”äÁ9&Á‰µÁ„K†Á}úfÁsærÁj#WÁ`«ÍÁWÉïÁNèÁFŽLÁ>ºÑÁ7MÁ0¢€Á*£ÎÁ%9äÁ ²êÁ«þÁ›ÁH£Á¡^ÁÇûÁðÁÈÁcÁ ŒÁOÁ‰‹ÁŸBÁõÁ}RÁ;Á(Á#êâÁ) 0Á.ÞüÁ5C×Á{vÁGSÁPofÁY¼ÉÁc¼[ÁnVÁxÂâÁëãÁ‡ŠÛÁH>Á“9ïÁ™CµÁŸ[sÁ¥›©Á¬ýÁ²§Á¹ÁÄN+Á½’;Á¶Ý<Á°BPÁ©·ÆÁ£1gÁœ»5Á–d‘Á6ÁŠ\Á„¹Á|› ÁqS{ÁfO¢Á[ÁQÁG:Á=ˆëÁ4‡„Á+Ö>Á#¼VÁòÚÁµÊÁ5GÁ*óÁ&ÀýÁÀö„Àñ‰¼Àíø·ÀëœóÀêìÀé;µÀèn<ÀçÔðÀè—_ÀéÏ'ÀëÚÙÀï_$Àô±vÀû?_Á¥ëÁÚòÁ d„Á±šÁ†°Á!*Á(ÃKÁ1?¤Á:[ÁCƒ÷ÁMa+ÁW ÝÁb;žÁmSÁxÏÁ‚JÁ‡ûxÁŽçÁ”"VÁšl¿Á Þ Á§`qÁ­æiÁ´†ÁÀQÁ¹C3Á²‡CÁ«ËàÁ¥#ÇÁž”ÏÁ˜ AÁ‘4Á‹/ÝÁ„÷öÁ}³æÁq¨ ÁfãÁZÄ@ÁOÂZÁDüŽÁ:¸¯Á0äöÁ'UTÁˆsÁÁA-Á´ÞÁ Àói@Àé»Àß«æÀØ„›ÀÒþÀÏQ|ÀÌš ÀÊëòÀÉønÀÉ­ÀÈkKÀÉYÁ®<ÁgÚÀñ‹¶ÀãØ®ÀÖ¹ÖÀ˸VÀÂNÀº@•À´*À°l À­Ž¹À«|ˆÀª`À©¤eÀ©§À©öÛÀ«¸¿À®QvÀ²×À¸äÀ¿š¾ÀÈξÀÓ!×Àßk,À쟤Àûª¼Á|ÙÁ1ÁDÊÁ ²õÁ*Ø‘Á5:ËÁ@LàÁKÏÁW˜Ác}Áo¾Á{y(Á„üÁŠŸ˜Á‘!ÏÁ—¿ Áž}Á¥SüÁ¬;IÁ¸‡Á±pÁª†Á£6˜ÁœqSÁ•µbÁŽù¸ÁˆSXÁÆ,Áv}£Ái›KÁ] vÁP°$ÁD…Á8ÙkÁ-¥ÊÁ"§ÉÁ‡ÁgÁDÀö ÀåÓ¬ÀÕ¼‚ÀÇ[øÀºGéÀ®F©À¤¸À›üŽÀ•žsÀ‘†œÀŽIùÀŒÀŠ¿9À‰ýÀ‰˜ÀбÒÀŒx‚ÀgXÀ”´ÀšNZÀ¡ÐŠÀ«gåÀ¶ÊÀÂË–ÀÐÍ3Àßð§Àð?Á0jÁ jÙÁ}aÁÈÁ)Ñ£Á5@Á@žqÁL—AÁX¨øÁe$ÀÁrÁÁ† ¡ÁŒ¹ÙÁ“‰“ÁšoäÁ¡\¤Á¨G¥Á´S Á­DgÁ¦7/ÁŸ1ÌÁ˜?Á‘iÁŠªjÁƒîzÁzr6ÁmJÁ`5\ÁS>¹ÁFžšÁ:8ŽÁ-ù\Á"DxÁÁ ÁœtÀïa§ÀÜ0yÀÊø©ÀºK À«™ÀªkÀ‘MÀ‡ HÀ{s/ÀnMÖÀdè®À]¯~ÀYG5ÀV<ÃÀT«°ÀT\ºÀVÙ‘ÀZz‹Àa;ÀjŽ+Àx ¨ÀƒÑ8ÀØ·À™]AÀ¦F—Àµ1ÀÄx+ÀÖ8ÀèiöÀüDdÁd Á_WÁ©^Á*9ÝÁ6.yÁBH8ÁNàéÁ[ÓÁhÍËÁvÁÁ’Áˆ¢?Á‹ÏÁ–vÑÁeæÁ¤j#Á°±]Á©ŒÂÁ¢wÁ›h¹Á”ZñÁV›Á†kìÁA…ÁqÇÁdOFÁWÏÁIïÁ<ç¶Á03VÁ#É÷ÁsúÁ ±.Á‡TÀë”ÀÖ{ÊÀ¸€À°0ÀŸLXÀŽûÀ,HÀhSðÀRqÀ?}}À0ñÊÀ&«§ÀË ÀneÀûÀ]#ÀŒöÀOÀ‰øÀ#€*À,úãÀ;lãÀKüÀ`ÒãÀyd×ÀŠgÀ™tÀª5$À¼4ZÀÏŽÀä.OÀùÜéÁ8|Áß¹ÁÐ*Á+ø"Á8²'ÁE¤ÄÁR¨ŸÁ`RÁm°Á{xÁ„¥üÁ‹’°Á’”!Á™¬ÔÁ Ù´Á­-9Á¥úäÁžÑÁ—®Á›qÁ‰ Á‚~ÙÁvûœÁi:DÁ[²ÐÁN93Á@ÎÁ3¬ÎÁ&˜{ÁÊœÁ \èÁø!ÀêEÓÀÓð1À¾êÀ©¿+À–ÇÀ„@ŒÀgOaÀIŸíÀ.øPÀìëÀ;¿ç+{¿ÐÝB¿¿Í-¿¶ü+¿¯&„¿¬,¿¬Ë^¿³#q¿½h£¿ËïϿߵ³¿ýUéÀµ…À&©ÖÀ@YÀ]z£À|îtÀ-+À¢ÛÀ·©!ÀÍÐÀãÊÀû ÒÁ x\Á³ðÁ"‰¢Á/{äÁ< ÂÁJ)ÁWã+Áe«¡Ás€ÏÁ€¾9Á‡ÖºÁòÁ–H–Á“ÃÁ©Û^Á¢œÁ›QŸÁ”HÁŒð¦Á…ÏçÁ}…Áob¹ÁaF,ÁSQ;ÁE©CÁ8$3Á*«bÁjŠÁQÎÁe¸Àíß²ÀÕÀ½:ÔÀ¦Ñ»À‘sÀzÀSäÈÀ1¾ÀLä¿ëò^¿¹Å¿î»¿Xù ¿(È¿ñ¾á0z¾Àê̾µÁè¾¹ó;¾ÓIR¿L¨¿!—¿Lúç¿…~¿«.Q¿Ú?dÀ HÀ&žÀHÙ†ÀlÚ;À‹$ŠÀ 6À¶±ëÀÎZ3ÀæCÿÀþî=Á aÁeeÁ&´Á4[ñÁB:ÁOß]Á]ÐîÁljÁzeÝÁ„y~Á‹ÄÁ“ ÁškÁ¦È9ÁŸa Á˜êÁ¹äÁ‰w¥Á‚>Áv šÁgåvÁYÈ)ÁK«ŠÁ=“PÁ/²wÁ"¥Á•ÁÁ+‰ÀôÀÚÀÁ•À¨>áÀI—ÀshkÀH…­À  s¿÷ö-¿´ðð¿tV¿ Õ•¾G=¹ï=>› >éð? ÇÜ?b;?"¥a?£€?ý>ï~]>ªï'>„º½Ü–¾Ú³d¿Pƒ¿¡qÆ¿â²ùÀ >À=>ÜÀg!ÂÀ‰ÚÍÀ¡ªqÀ¹—GÀÒŒ¸Àìu7Áe®Á×&Á<Á,IJÁ:'ÏÁHU¢ÁVÂÁeTÊÁsé‘ÁE…Áˆ–Á Á—q£Á£å)ÁœmEÁ”øºÁÁ†2†Á}ʶÁo@ Á`ÄOÁR`ñÁD-™Á6 Á'õÁéDÁ $ŒÀýnÀâCÀÇšˆÀ­nÆÀ”+ÁÀvÓIÀF¸´ÀYw¿ÞÜ¿ŽÚÿÂý½—QÁ>¶4g?:;«?…™æ?¢D»?·}X?Åú?Í›?ÐÛ?Î O?ÆÉŽ?¸åƒ?¦V?Œ£?RúÂ>ö”ý=ŽØÈ¾ÔZ”¿uê–¿ÈaiÀ”À:(lÀiûqÀŒë±À¦;¯ÀÀhNÀÚØYÀöNÁ‡Á‹ìÁ$®ÈÁ3!øÁA¶™ÁPK`Á^êÁm§­Á|õÁ…­îÁØÁ””ˆÁ¡+µÁ™¢2Á’‰ÁŠ¡°Áƒ*¤Áwz9Áh¼tÁZ!¢ÁK–NÁ=žÁ.¤;Á v‘ÁZˆÁ?fÀì•ÒÀÑ3·ÀµüfÀ›YÀ€óÀN¬—À(ѿټq¿}ûᆲ°ù>ƒar?I+²?ŸUq?ѽ??ýce@ã+@Uy@!â@&, @'j\@&7o@!ía@¥¶@¤ @3¶?ß„?¯í?mŸí>Ч•¾2(Ó¿T,ã¿Á©À¢À@ŒéÀt À”iÀ¯ Àʃ)Àæ‡Á˜Á–ÁÁ,­|Á;MÁJtÁXþ'Ágå}ÁvÏÀÁ‚å$ÁŠpLÁ‘ÿæÁž£zÁ—ÁwÊÁ‡ê?Á€_Áqµ7Áb¼×ÁSØ.ÁE'Á6xÁ'í;ÁaçÁ ìlÀù€ÀÝHÀÁ( À¥a‰ÀŠWÀ]ÅÀ) οêš=¿†ü²¾˜ê>Ñsb?‡ Ö?Ïë€@@#0÷@:" @L,®@XìG@a]@eŠŽ@fÄ]@e^¶@`uû@Xf(@Ma@=éž@)V‰@æD?âvy?š`? »½ýåÊ¿]¦‘¿ÎáÀ ®ÀPèbÀƒ©ÞÀŸQEÀ»O}ÀØ#‰Àõ&Á ”ÁÄAÁ&¦†Á5ÉÁD{ ÁSkoÁb|pÁq™Á€[Á‡ìÌÁ†âÁœNMÁ”¨ÄÁ<Á…_hÁ{‹ÁlmÁ]QñÁN8sÁ?-^Á09Á!lXÁÏ|ÁD(ÀëpñÀÎmÖÀ² À•ÚýÀsÚ'À<‰BÀì¿ ¥Š¾ãŸ–>°]t?­|?çK3@²@?Cñ@\©Ú@u ª@„™i@‹Šo@ßÛ@’ta@“/@’Bÿ@J@‹M@… @ya–@bŒ@Fç@$Já?øÖô?¡§P?dɾ|¿‰Õ¿ó©¢À1#žÀi#1À‘CáÀ®AFÀËC;Àè·üÁ<Á&XÁ!âÁ0GÁ?4îÁNQ–Á]p/Ál¢®Á{ë¿Á…mÁE Áš:Á’\{ÁаBÁƒ |ÁvÉçÁg~ÖÁX6ªÁIÁ9ê|Á*ÏfÁ´TÁ ¥£ÀûŠáÀÞLÑÀÁ4ïÀ¤MÀ‡©ÀULÀý¿ÊËm¿9z=û¯h?qS?Þ‘@ Œq@LÎÅ@s‹¦@Š(Å@—¬¯@¢ªö@ªœu@¯>@±ö@²µè@±Ö¢@®Ã—@©ó†@£#™@™¸”@bÑ@z³@Tvj@)–?ó†?ŽÓy>—+ñ¿¤¿¿·Œ-Àé¶ÀN¼À„cÀ¡úÍÀ¿©[ÀÝwÍÀûiPÁ ÐÆÁððÁ+¶Á:FóÁI…ÁXÓÁh"*ÁwqEÁƒ`0Á‹ 8Á˜'óÁ`ÓÁˆ™íÁ€ØÁr<¥ÁbÜ›ÁS‹ÁDBFÁ4÷5Á%®‡ÁƒÁgðÀð™³ÀÒc†À´S¶À–ùÀs¾—À9‹T¿þ°#¿Œãä¾hŠŠ?$:ç?¿Ì@Ê@H…S@yÔ@’ûù@¥‡Õ@´‚#@À]Ö@É:t@Π@Ñw¬@ÒE @Ñ01@Í‘O@È0¿@ÀÖ@¶–Æ@¨BÓ@•üŸ@€È¦@R æ@”ê?Óf‡?FYl½év?¿ìi¿ö?‹À6{=ÀqÖÌÀ–¨åÀ´è7ÀÓ>}Àñ”ÄÁõ…Á$VÁ&kEÁ5º_ÁE zÁT_WÁcÀÁÁs-7ÁQ·Á‰ gÁ–PÁŽˆòÁ†ÁÒÁ}õcÁng­Á^ÛDÁOOÞÁ?ÏHÁ0dÁ! °Á»ÚÁo“ÀæLÌÀÈöÀ©ÊÉÀ‹™ÀZóVÀt*¿ÊG÷¿+€6>u3S?¨Ê?ÿÈñ@7AQ@lñû@Ê›@©ed@¿Sn@ÐQ™@ÝŽÍ@çÎ8@íÿÐ@ðùR@ñÔ2@ðZJ@ìDW@æ^²@Þ&ï@ÒÌý@RR?™PS>’Õ†¿$’À¿É»×À ÈcÀ]V“ÀŒôÓÀ«JbÀÉ ©Àè ˆÁR§Á¬ýÁ"·Á1‹ÓÁAŠÁPuÁ_êwÁobÁ~Ù’Á‡* Á”ÝÁŒÅ”Á„òÁzH6Áj·aÁ[)AÁKœOÁ<aÁ,„vÁøŒÁ róÀûü¿ÀÝ@ìÀ¾‹·ÀŸÙöÀ<žÀEþ;À À§¿› “¾ŠWd?%F²?ÇC¶@ò @V¬&@‡ ´@¢Œo@¼ìž@Õà@ëº@úbÈAñQA{A8‘A§uAÂ2A{ÜA4â@úÀÎ@ëàŠ@תÃ@¿ÔC@¥FT@‰pe@Y&u@§û?Æq‘?þ5¾£ø1¿¢lÀ ›fÀJ)•Àƒ\†À¢nÀÀù?ÀßòËÀþìVÁëÁZfÁ-É®Á=8øÁL­YÁ\3áÁkʧÁ{n¢Á…fÁ“dÁ‹DcÁƒidÁwËÁgfÍÁW±fÁHÒÁ8blÁ(ÑgÁE}Á ¹’Àô[PÀÕC{À¶/—À—A|ÀpàÁÀ3vX¿ìÜ¿b»Q=mô?Ÿ ?øE?@7ÇT@rƒ@–(‹@²aä@Î!,@èôzAê"A A²–Aê¥A„A_^ANdAÏ‚AüA 4A*Ÿ@êiR@Ïe¯@²²@•!@o@3Ý?ï”­?lðœ¼Ðæ~¿zÚp¿ønÀ9žFÀw‘ÀšÂÀ¹¥bÀ؃òÀ÷dÂÁ /¯Á¹<Á*M Á9ñÁIœÁYG5ÁhòwÁxäÁ„$»Á‘ (Á‰ÅüÁêýÁtýÁdiÿÁT´ÁDþÁ5HÁ%’ ÁÜ Á(ùÀí êÀÍß§À®ÅˆÀ­³Àa+½À"ü¿Ê$Ž¿ÿ¯>±Uô?§*P@ã¬@M{ý@„Óv@¢èî@À6%@Ý?ä@ù]\A cµA¢˜A A%æA'MÓA'ùA&®ÁA#®AAQÙA öþ@÷üâ@Úê·@½IŠ@Ÿž¦@{@F÷@ (?—P >b̹¿=9ã¿ÚWáÀ*ðcÀi"ÃÀ“º•À²ãÉÀÒ ýÀñ7–Á@åÁëúÁ'—Á7ByÁFï)ÁVœíÁfKŒÁuúÜÁ‚Õ_Á0 ÁˆN-Á€nÁq Áag¿ÁQ°3ÁAÿ}Á2K:Á"•<Áß?Á)AÀææˆÀÇzÀ¨“Àˆ¢˜ÀR¨žÀOß¿¬\¾¾„!?|—?ȼÓ@"2-@_ËÕ@Žš]@­;@Ë¡í@é¦4A«»A.A žA,mA3û1A6õA7ROA5¿mA2-|A*æ+A[AãWAEü@äz®@ÆPÏ@¨@‰@Û@TÞ«@; ?²þ$>Ûο ÄŽ¿Â…BÀ”À]îáÀŽ.[À­~ŸÀÌäAÀìIãÁÖÌÁˆ¥Á%:Á4ìXÁD¢ƒÁT`Ád#ÁsêÁØRÁŽÝøÁ†úÇÁ~/,Ánf$Á^œÞÁNÓÅÁ? ™Á/LÁªÁØ“Á }ÀàÞ ÀÁ~áÀ¢÷À‚¨ýÀFzÀ¢¿‘”1¾"0?Së?æ=ò@1w·@oº^@–ç@µÑo@Ô¶u@ócA A$»A'tA5ŽOA@ZACô´AD‘ABîÍA>œKA1ÔeA#[¢AknA:º@ëË1@ͪ@®8W@Rk@`£—@"g?È>û?ð¾Å@Å¿®+ÚÀ‹ÊÀTUÑÀ‰ŠÀ©\ÀÈwÀèÉÁÀÁ‚¿Á#KÁ3 ÁBÜ,ÁR¤¸ÁbmEÁr5Á€þ/ÁˆÁ…¨Á{ƒÒÁk¼zÁ[öÁL/·Áˆô@}`ê@žŠ@½Fé@ÜsH@û˜OA DäA¹ÕA,!A;A§AJRAOmŠAO÷bANÛüAE%]A69A'ôA¡A7¶@ñ¬Ø@ÒŠ7@³g•@”Dô@jD¤@+à‹?Úò¥?ck ?š.+@ ÷q@JÇ.@„ÂÖ@¤"@´@âîA,þAâûA x”A0åA?†ANñAY“iAZ=âAVMAH˜×A9G@A)ÚéAn’A Øý@ö€î@×Oá@¸Õ@˜íÈ@sqÔ@4¨›?ëUÂ?Z´¾y¿Žr&À*•ÀEÀ‚ÌÀ¡éÀÁžÀà¼yÁ2ÍÁ^ÁÛîÁ/°Á?‚ÁOSéÁ_%êÁnûøÁ~Ö¹Á‹3ÇÁƒICÁv½~ÁfèvÁWnÁG>‘Á7l¿Á'›0ÁÉ ÁøÀðMÀЩãÀ±ÃÀ‘d Àc‡À$]¿Ê‡#¿¨.>Ç{Ô?°@#ì@VI@Š·@ª9¶@É©ã@éAB9AñÙA#¡xA3QACLAR¨ÑAa: Ab.{AZåÀAKs_A<ðA,ˆxAïòA R@ûe¤@Ü'E@¼Ð0@_“@{Ýê@<ø?ûô½?{ò”º‘ 3¿|ÕÖ¿ü±“À=|À|¤»ÀõeÀ½™/ÀÝ<øÀüàÂÁBFÁæÁ-ñÙÁ=ÍIÁM¨ºÁ]„*Ám_šÁ}<”ÁŠ&Á‚$UÁtoöÁdšÁTÅÁDðÁ5Á%EÿÁp÷Á›ïÀëÏÀËã¿À¬;ÑÀŒ˜±ÀYë$À¤æ¿¶½O¾àÃF? ·W?ÄâÌ@!±ì@`íP@k@¯.@Ïñ@î©´AÈAåA&¬A6dAF5AUÆæAenÓAgR¢A]•‰AN)»A>¾A.ì‹AKÆA¥,@ÿà°@àwA@Á Ñ@¡˜k@ÿ¹@DÎ @œ¨?ŒÖˆ=ç;â¿_Þ¿îP¹À6K°ÀuzøÀšc«ÀºeÀÙÚ'Àù—Á ¨ûÁ†0Á,ceÁ<@šÁLÎÁ[ûÁkØ8Á{µmÁ‰zÁçÁrJ©Ábm·ÁR‘DÁBµpÁ2ÚdÁ#\Á'«ÁP4ÀæòQÀÇGÀ§À‡òñÀP‘ÂÀ=¢¿£Ó¾”«?2ú÷?Øô@+P8@j–w@”î[@´‘z@Ô4™@óÕpA ºÚAŠûA)TPA9±AHáAX§tAhk@AköA`CÜAP£ÆA@ñ¶A1?A!ŒuAÙÕAZ@ä ±@ÅË@¥jä@…Ïþ@Lj0@ 4c?›í0>jW÷¿B®e¿ßùdÀ/MÊÀnžãÀ–ü”À¶´ÌÀÖo6Àö)ŸÁ òÁÏ9Á*¬nÁ:‰£ÁJg{ÁZI}Áj/eÁzOÁ‡úÓÁ€ ëÁp8éÁ`YýÁP{Á@œOÁ0¿eÁ ä9ÁàÁ*»Àâ›+ÀÂààÀ£'ÀƒpXÀG~´À!¿‘†å¾kþ?WÔB?ê˜r@4 Y@sôy@™¤L@¹N\@Øøl@ø¢|A "åAôuA+ÆA;—”AKhöA[9Ak 8An%:Ab‹oARØ„AClA3b-A#”ÚAdžAú2@èYÎ@ÈÁ@©%I@‰w@S‘¾@5T?©±Ó>«ãû¿'uÉ¿Ò]À(¤ÀgмÀ“’HÀ³FòÀÓIÀòÂÆÁ DïÁ'>Á) —Á8ëøÁHÎ`ÁX°ËÁh“;Áxu­Á†àËÁ}è¤Án²Á^6¿ÁN]ÍÁ>„ÚÁ.«èÁÒõÁ÷ãÀþ1ìÀÞtÀ¾¶:ÀžøaÀ~yàÀ? d¿ÿ?Œ¿€Va¼6›?z÷é?üe @=¡@|þ¨@ž.$@½Üõ@Ý‹Ž@ý9wAs¯AI¥A.­A=óµAMȽA]ÅAmq¼Ap—AdžœATØÂAE &A5?ÊA%snA§AÚ¶@ì´@̃ü@¬ëE@Py@[Dˆ@è?¹h>éMF¿ ¼¿ÃÕ À!tžÀ`þ¶À<èÀ¯ø˜ÀÏ´GÀïo÷Á•ÓÁs«Á'QƒÁ7/[ÁGiÁVñîÁfÖ¦Áv»^Á…à–Á{ÙAÁkó8Á\yÁL.ŽÁÔ[?Ÿ<ª@@Neé@†äÙ@¦–¾@ÆMß@æ ¹AäÉAõA"¢¢A2~gABY†AR5Ab6Aqï\AsÅöAh†ÖAX¼AHîBA9 tA)Q,A€KA ªõ@ó¤—@ÓóC@´Aï@”›@i¾@*dT?Ö4H?.ÙŠ¾“¿¦?%ÀœÀR¥Àˆ¹WÀ¨qÛÀÈ*`ÀçâäÁÍ´Á©÷Á#†9Á3b{ÁC>¾ÁSÁbø¹ÁrØ®Á„/ÁxqÁh…PÁX›ÁH²¹Á8ÌÆÁ(éhÁoÁ #uÀò€öÀÒ³ÇÀ²á^À“öÀfyÀ&ÔJ¿Î^ò¿*¡>À?¯@ º@V‘ú@‹ õ@ªÒí@Ê—å@ê\ÞA FAã9A$¼+A4•ADnATG×Ack?ArÜAtµ£AjjkAZÎAJÑ|A; £A+8Ae‹A ’ÿ@÷€æ@×ÛÍ@¸3I@˜~æ@q•@2,??å†ñ?MjȾ@áG¿–í¶À ß¡ÀJHhÀ„Ø—À¤ŒúÀÄA^ÀãõöÁ×^ÁºêÁ!¤Á1ÙÁA~!ÁQkˆÁaYÁqFŽÁƒ¼ÝÁwøÁg†9ÁWÁG”óÁ7ž.Á'©Á´§ÁÀ7Àï—ŒÀÏ®«À¯ÅÊÀÜèÀ_é±À ‚¿ÀØ%¿z²>õ„ ?¼ª¤@÷ª@]{Ö@Ž€@®B@Î,@íÆAAÀÝAœ A&wA5¼tAD²†ASAbAApضAtüÙAlHÝA\›œALÂnA<ëÆA-AIIA wj@ûH;@Ûž@@»ææ@œ/Œ@xðb@9®?ô%ó?iå¥t¿‰‡¥ÀcjÀDÃÀÍÄÀ¡™GÀÁdÉÀá0LÁ~žÁf½Á P Á0:4Á@%ÁPSÁ_üYÁoê½ÁƒtÊÁvïÁfõÍÁVü ÁGKÁ7ŠÁ'ÉÁÁGÀîC ÀÎOŠÀ®\ÀŽh…À\êÀ¿º7û¾é§ö? wÊ?İ@!Þz@ad¦@ui@°8~@Ïû”@ïM½A>ÁAA%A4{.ACCAQç0A`ncAnÅìArJëAmHÆA]°ŒANâA>nÜA.®÷AæÆA ^@þG@ÞwË@¾§î@ž×Á@~*@>nÑ?ýœð?|λÆú˜¿ê ¿ÿ#À?(À~ÃÍÀŸ<¨A.¨AûÛA>H@þÞj@ß<–@¿”,@Ÿàx@€,Å@@ò#@м?„F«=&±š¿tÜé¿úvÀ<ÚGÀ|©¾Àž=ÈÀ¾)ÀÞÁÀþMÁø¶ÁïúÁ.çbÁ>ÞçÁNÖÁ^Î,ÁnÅäÁƒÂœÁw“ðÁg¢§ÁW±^ÁGÀÁ7ÎÍÁ'Ý„Áì;Áû ÀðWÀÐ3zÀ°SÿÀvÍÀa:^À!ˆÁ¿Ã®F¿–>ëÙ{?¸£B@À@YW@‹¹H@ªåä@Ê@èÚaA†NAx5A!;¸A/ÑvA>5;ALyŽAZ AaoÑAbÜÀAa£ÛAWóöAJµ;A;ÑNA,‡XAÔA c@üÉ@ÜæÌ@½¼ë@žb@|µ–@=]Ý?ü J?z¹²¼)Kο€¿þ±yÀ>°uÀ~AÀžßÀ¾À%ÀÞª Àþ™ÁDiÁ¤ìò?¦Ök@ñ÷@P|@‡€@¦,Ã@Ä6•@â3A §AŽAšA+=«A9VAFî AQI¨AW2AWå‡AUð)ANÎABæ´A5âOA(bA‚ÚA †–@ö\¯@׈­@¸‡º@™{›@tNL@5Ÿ÷?íãE?a ½ÍŠ¿‹düÀ«ÀD[DÀ×îÀ¡‚:ÀÁ,‡Àà×ÁE¸Á%¶Á üÁ/ðšÁ?Û”ÁOÉ%Á_¸¿Áo©ûÁ„óÖÁyûÁjYÁZ!åÁJ6µÁ:NíÁ*k­ÁŽ\Á ¹ÀõܳÀÖRÀ¶ÍÂÀ—S…ÀoÑÔÀ1=¿ämL¿Ov>#Ÿ ?-~@ó„@CÐI@äe@õH@»œ@س¤@õRQAÒ…Aç¦A$á¯A2Y¯A=CgADôAJ´ÍAJÿAGz÷ABÉA8ÇÕA-JÖA 0AéA Ü@íÎ@Ïx‰@±j@’È,@gíŸ@)ý‡?Øß?7w¾„Œ¿ž€ÂÀ'ÝÀM¯À†ÀÀ¥w)ÀÄïwÀ䀗ÁšÁèÀÁ!¾&Á1—´ÁAu¶ÁQVãÁa8Áq;Á…ÅãÁ{´ÿÁkàVÁ\ØÁLFZÁ<|0Á,²ÁçÚÁ °Àú§êÀÛÀ»—VÀœKrÀzŸõÀ<æÛ¿þ\¿‚ëI½rÐ?e¿2?êäH@1]“@lDù@“;˜@°Ù@Ìwº@è‡&A·AÒ AA( ÁA0ÙA7YaAþa¾ñ¤¿¸hjÀ0ÀX4À‹PUÀª«,ÀÊGÀé|GÁtuÁ,'Á#äÔÁ3ž:ÁC]GÁS&Ábö ÁrÍcÁ†ìeÁ~ŸÁnDtÁ^zJÁN±Á>îeÁ/53Á…hÁá3ÁPhÀá£iÀ§µÀ£¬SÀ„ÀÀL2ÊÀïÏ¿£æÐ¾°‰?X{?Ád¶@¡@T~b@†z¥@¢^@¾xN@Ùê@@ôÑãA0€AhA§ÉA#3 A)ZlA-hA, ÐA)¢«A&$A hÀAPA ‘ÀAñ]@éIT@Ï ¾@´®c@™o@y¥¯@@V@¹‰?•„>_ƒ¿;‘ƿד­À))RÀfàÀ’_™À±]ŠÀÐlhÀï£6Áp¦ÁüÁ&ºÁ6mÅÁF!ÓÁUÕáÁe‰îÁu=ýÁˆ.ÒÁ€T×Ápú ÁaK9ÁQ¤ðÁB &Á2"Á#Á…9Á “ÀéNxÀÊ„:À«½òÀ rÀ]dcÀ!ã–¿Í;¿.p>dIò?:_@®{@8ÛK@p« @“º‰@®ë$@Ɇ@â)"@øø†AfêA€AzºAàA:žAð.A–jA-APtA ÓAü‡@ìE+@Õ.å@½¨@£q¸@‰:T@\9ò@%r?×çÀ?HïÁ¾íο…Ë}¿ý§êÀ;bÖÀx8ðÀš¢úÀ¹R·ÀØuÀö¾NÁ ÓÁ_ÎÁ)û Á9šÁI9"ÁXØ-ÁhxÁx wÁ‰´ÖÁåÀÁt8NÁd²PÁU5~ÁEÄGÁ6^«Á&ùŒÁ”mÁ1Àñ§ ÀÓ7¢ÀµGWÀ—®ñÀt4cÀ9[ó¿ýd¾¿‰½¾E˜O?0—Û?Ç÷=@ÓV@Q‡F@ƒ ß@*5@µß³@Ì¿¢@á¶,¦¿ñ5¿·ìÀ/ÀQûÀ†8lÀ¤I£ÀÂhãÀàÆâÀÿaÁcÁ`“Á-ºPÁ=åÁL›Á\*ÁkÅ®Á{c4Á‹u—Áƒ½´Áx…Áh³ûÁYT;ÁIö2Á:˜“Á+IçÁ¨Á ölÀüâÀÞwJÀÀûÀ£ŽÎÀ†"˜ÀQî’Àˆ.¿Ây@¿$Ð#>^¶Á?‰€P?óÆ@.a6@aõÄ@‰‡@ 0N@µAÀ@ÇØP@Ø'x@æ6s@ò2 @úù±@þÔÿ@üì=@øƒ@ò-@éÐ^@ÞÂ@ÏŠ@½ñ@¨E™@’]–@w›@Fž^@Þg?ÄkÑ?6S½÷^¿~Xó¿îî‘À/{QÀixoÀ’)*À¯–ÀͧÀëÁ”¦Áž¡Á"ÆÔÁ2»ÁApâÁPÍÜÁ`+ÁoŠÕÁ~úiÁ*Á…Þ%Á|^SÁm §Á]ÇÁNŽÀÁ?cRÁ0UÁ!l6Á¤ÁíìÀêppÀÍ›À¯ýƒÀ“zÀnÈlÀ6³¿þ`R¿N¾”¼?ý?­f @àˆ@9}@gm@ˆòÅ@œ9°@­E@¼™>@Éõ­@Ô¿ @ܼ @ßé‡@Þ3@ÙÜ­@Ó¾i@Ë¥¥@ÁÅÛ@´UT@£š€@Q*@vt5@JÓ˜@@`?Ù¦·?pvÓ>²¿+<Ë¿¾Ó À ÀMâ›À‚àÚÀžââÀ»Ú™ÀÙ?DÀö¨vÁ vÁó‹Á'ü)Á7@ÁFÕÁUB«Ád‹aÁsåÁ¡ÁÀíÁˆ# Á€†âÁqÚÁbºÊÁSµŸÁDÑ"Á6®Á'gFÁÀ‰Á ]À÷87ÀÚ¨9À¾4õÀ¢ À†W™ÀU9yÀiÜ¿ÓÇK¿V&2¼ÌöG?>ê?¿‘+@ š@9)³@`Úî@‚)±@’#í@ Ì@­"”@·$ª@¾K„@ÀßU@¿P@»2 @µRs@­bÝ@¤vv@˜' @ˆô¢@n(ÿ@G@]9?áO9?†ã>˜BȾí꿺IÀdYÀ7þ­ÀlÿëÀ’I*À®8ÀÊ&þÀæEÔÁ•DÁ?¡Áí{Á-ÁÁ³µÔ¾º é¿…T¿îÇ_À(=À[ù€ÀˆIêÀ¢±ÎÀ½§ÀÙÀõ~îÁ¿yÁÛEÁ%FÁ3ëÁB•~ÁQ@ÅÁ_þ&ÁnäÁ}ì"Á†~,Á”ÂüÁOaÁ…ëÝÁ},Án†ÂÁ_äoÁQS0ÁB×/Á4Œ˜Á&F]Á÷Á %ùÀø©ÅÀÝ5_ÀÂPcÀ§€°ÀPÀf¨ýÀ4pbÀ<Ÿ¿§B€¿£å=ÁìŸ?;3©?©ü-?ð½‘@"%@4²Ð@Nè¶@dš6@usÒ@€‹T@‚k5@Q-@{@!@p]]@aÁ@Prž@=œ@"ƒX@?æ?ÄPh?n†®>—Fž¾…ü¿‡zË¿ã WÀ ¡iÀQ$aÀ)PÀšJ4À´”}ÀÎúbÀé}uÁsúÁkoÁgÁ,rÁ:“ÈÁHú‚ÁW˜gÁfBVÁtìEÁÎûÁ‰8îÁ—µaÁ^FÁ‰ ˜Á¿yÁtî3ÁftÊÁX(ÖÁIã3Á;´OÁ-¬EÁÙ›Á%ÁˆÈÀî?æÀÓ”ÏÀ¹—¨ÀŸ¸VÀ†íÎÀ\»ýÀ-rB¿þ¥¿§6…¿)f½W§6?‹º?ƒ½?¿Ú‘?÷Ú“@ß@(È@8ˆ’@Bêß@FT÷@D3È@=‡—@2þW@$“@¹ò@O?Ò¾š?™¹ß?2K> Ìù¾íÍÇ¿ŽV4¿ä ˜À ðÀKÇúÀzÛÀ•rÊÀ® ÀÆÛ·ÀàßÀûBõÁ ÛÈÁAeÁ&fÁ4…ÁB ÁP$­Á^L^Ál¯èÁ{E@Á„÷—ÁŒLÁšÕÃÁ“ŒúÁŒDºÁ… 6Á{ÅÁmƒcÁ_YRÁQ>ëÁC^SÁ5—ÀÁ'ñßÁ€1Á µÀÿÚ!Àåß…ÀÌ^ZÀ³¦óÀ›>µÀƒ¢wÀYIxÀ-i-À…q¿¸àp¿^†Â¾¥¸ë>+w”?á±?„ï ?±Àž?ØöÓ?ö?ë@·c@Å»@€¢?þwÎ?êP¦?ÎX®?­ÔÎ?ˆ²À?=”Œ>¢Ku¾Pu¿.*D¿¡*¿ïÜÀ!? ÀLZÀxalÀ“¤Àª6ÀÂX:ÀÚì²Àó¥†Á•ÈÁÅÄÁ!Á.@PÁ;ÓaÁI»7ÁW¿-ÁeË:Ás×tÁ€Áˆ3ÁyžÁž Á–ØÁ°©Áˆ“Á+ÁtÚÜÁfã‹ÁYôÁKn§Á=á6Á0wšÁ#õÁäÁ )šÀù,“ÀàxqÀÈ( À°’«À™«ÀƒžñÀ]>eÀ5ÓÀæP¿Øöm¿–ú¬¿4ÿÁ¾…[=þ!2>íVø?>þ.?u|E?ŒƒJ?‘î?›V?Àò?\߇?'â×>ÐÖÝ=üM¹¾8Ü㿎¿ƒwË¿Âú6ÀúÝÀ)éùÀQqÀ{SÀ“W[À©[ÀÀ'LÀ×°ÞÀïQ=Áç1ÁCGÁÒ6Á)êÁ7$\ÁD^©ÁQºîÁ_nÁmfƒÁ{qÇÁ„¾êÁ‹ÅÂÁ’ÞÕÁ¡3Áše+Á“Q¬ÁŒ>FÁ…8ËÁ|™âÁní:ÁaIäÁSØŸÁFoÁ92eÁ,AèÁ|ÍÁÁ§ÿÀõuÀÝ‘ÀƱgÀ°‰—À›‰ÙÀ‡MØÀh-ÿÀDŠ7À!ÎÔÀ賿ÊÞ¨¿•H¿M™¾ñßg¾U¤ü¼Hñê=ê ì>º>Aœ=!B¬½Øúî¾›?ô¿ Ò¿¿QÛg¿]ë<¿óàöÀ=ÇÀ9€À\È<À¯kÀ•ª²Àª´­ÀÀ¶ÀÖ…kÀíHóÁiBÁ0kÁZ Á&´†Á3&ÏÁ@vÁMJÁÁZ„¼ÁgÄþÁuH™ÁŠ_ÁˆŒ*Á’0Á–˜7Á¥$.Áž¯Á—'Á¡Á‰5çÁ‚bÁw9¤ÁiÐÁ\pOÁO]ÄÁB‹:Á5Õ—Á)i»ÁüÁý¨ÁK#Àó¸äÀÝ{4ÀÈt~À³áÀ †BÀŽL›Ày¢‰ÀYƒÀ:~jÀ¦ÀÑ«¿ÝÀ¿µ˜æ¿•ë¿|b¿^„¿UM¯¿Zá…¿oYŽ¿‰!¿¡¸¿¿p¿âŒÊÀ]-ÀèÀ2âÀPT»Ào‚ Àˆø5À› À®™âÀ¤ýÀ×À÷Àí¬Á×ãÁ 5BÁúÁ$¾ßÁ0Ï»Á=)´ÁIŒ_ÁVP+ÁcvlÁp¯ÍÁ}éIÁ…¡ßÁŒrgÁ“atÁše¡Á¨ÓÖÁ¡ØËÁšöÅÁ”!^ÁQÁ†˜”ÁÐcÁr¼ÁežŠÁXá_ÁL4õÁ?ÓsÁ3ŽÁ'r¾ÁÎNÁf)Á?@Àõ_ÝÀàƒþÀÍÀºe[À¨ØÄÀ—Ñ0ÀˆD¨ÀrÚžÀX­À?iÀ* àÀwóÀÄ¿úÐ6¿í$¸¿èñG¿ëR‰¿ôfÜÀÌøÀp×À'ÐÀ.0|À@®YÀTÜÆÀmP_À„5×À“kNÀ£»Àµ0ZÀÇ»JÀÛ‹uÀï¥4ÁlìÁ k5Ám–Á#ÇeÁ/ŠËÁ;OÁGJÁSŸaÁ_ýqÁl ¡Áy¦QÁƒoYÁŠ ÊÁ¬4Á—i¾ÁžETÁ¬½KÁ¥ãCÁŸ ÿÁ˜IŠÁ‘š7ÁŠñóÁ„`ªÁ{ïUÁo7úÁb™3ÁV@ÁJÁ=è"Á2QxÁ&ôÕÁÆ–Á(WÁ¨ Àù—ÝÀæˆÂÀÔàDÀíÀ³…À£ýúÀ–gÀ‰ÀzÏ;Àf>þÀTQŒÀF8ÆÀ;·°À5„TÀ3ÛÀ4åkÀ9"8ÀA3ØÀLtkÀZ—“Àk8íÀ} Àˆc À”!¨À ‹’À¯vÈÀ¾ÌYÀÏòûÀávýÀô…cÁ>„ÁTEÁþÓÁ$cÁ/§Á:\&ÁF‚ÁQàŠÁ]ËNÁjÁvqÁ€Á‡ñ¼Áއ`Á•#ÐÁ›ÀeÁ¢mJÁ°ÏîÁªÜÁ£LLÁœ¤3Á–³Á‚ûÁ‰"øÁ‚ÇKÁyÁl²ýÁ`tÁTcÆÁH×JÁ=†…Á2QrÁ' ¿ÁùÁ³Á m¶ÁsâÀïwÐÀÞÐgÀÏ;îÀÀs#À²÷zÀ¦'¹À›2KÀ‘idÀˆöòÀ‚/¯ÀzC„Àt²ÿÀrÃÀt#ˆÀx7„Àõ‹À…(Á3–gÁ)n£Á°AÁw¢Á ¿²Á>"ÀúáÀëœÀÝ úÀÐ1ÀÃØ³À¹CÀ¯Í±À§é‚À¡€¬Àœ¨€À™ø À˜ô%À™°ÒÀ›¦õÀŸcìÀ¤cuÀª»ãÀ²´]À»t#ÀÅXÀÏ,€ÀÛOÀçߺÀöɼÁÄÁ váÁ1£ÁHÈÁ'/0Á10Á;ZÿÁF(õÁQ.îÁ\:ÁgŠwÁs<òÁÁ…m¤Á‹€mÁ‘­Á—ëYÁžD Á¤À Á«SÞÁ¹f§Á²ËÁ¬B5Á¥Ø}ÁŸyªÁ™!ÍÁ’ìÁŒÌñÁ†±5Á€·@Áuï(ÁjªêÁ_m{ÁT’-ÁJÁ?ÓÁ6AÁ,‡¹Á#Ã{ÁŽÁçÖÁ !ëÁÅèÀùäbÀí%iÀáÄpÀ×]nÀÎJkÀÆàcÀÀÒEÀ¼<¼À¹ªÀ¸ÖÀ¹OáÀ»2nÀ¾ÍÀÜÙÀÉÃÀÑl?ÀÙóôÀãQÀÀíE¹ÀøÉÁ‚¼Á qMÁ ¤ÁäPÁ!’·Á*PlÁ3®#Á=§ùÁG¨àÁQä¤Á\¿¾ÁgȲÁrÖÁ~#,Á„æÕÁŠÊ8Á³ùÁ–½ÄÁœè!Á£#MÁ©tüÁ¯äêÁ½æßÁ·j Á±?Áª¥fÁ¤RêÁž%ÍÁ˜ AÁ‘ñEÁ‹ý:Á†?”Á€žÁuýÁkÅÁ`‰ÅÁVCŒÁLaOÁB¸Á9ÊÁ1ÚÁ(»ÙÁ ¿¨Á$ƒÁÈÁ wpÁF¡Àÿ°=ÀõÉ:ÀìùÀåà8Àà#ßÀÛÔLÀÙRµÀØ9ÀØîïÀÚ¾ÀÞ6ØÀâÜÀè¥IÀð(úÀøuÁÌ!ÁÑÍÁ '‹Á?Á§‚ÁÜÁ&²äÁ.ò¡Á7­Á@†-ÁJ VÁT ÃÁ^!óÁhrÀÁsX5Á~cŠÁ„¹žÁŠ^JÁ/1Á–ìÁ›ûjÁ¡ýlÁ¨"àÁ®[·Á´©ƒÁ•7Á¼2+ÁµÑ±Á¯‡÷Á©a»Á£G¿Á3©Á—D¿Á‘ˆ…Á‹ç¨Á†G3Á€ÈÁÁwŸÁl»ÌÁbÇ&ÁXÿ¯ÁOÛ,ÁGòÁ>™¹Á6g|Á.¶ÎÁ'_,Á nxÁÌÁ19ÁÒÒÁ ŠÁê’ÁÂÀÿuyÀûmïÀù,À÷ï’ÀøŽÀúIÇÀý²ýÁœÁëÁßÁ {ÒÁ ¹Áý+Á CÁüÁ&&äÁ-(¬Á4ÀŸÁ<‚=ÁE .ÁMÈhÁVÒ=Á`˜¥Áj™ŒÁtœøÁ$Á„øöÁŠ~ÁÁ•«BÁ›w©Á¡[¡Á§C¼Á­>òÁ³]´Á¹”‚ÁÇ_2ÁÁXÁºÀNÁ´Ÿ®Á®ˆÁ¨wëÁ¢}ÁœÒfÁ—0ÁÁ‘ýÁŒ 2Á†¾ÅÁšoÁy2­ÁoWøÁeúdÁ](ÁTzÁL9ÁDMÁ<½?Á5£—Á.òÁ(¹ôÁ#'Áç]Áb«ÁelÁÙÁlÁ „yÁ k|Á ÖÀÁ )Á ï$Á™XÁ±ËÁ‡ÉÁð=ÁÕ?ÁIãÁ$ÕÁ)¡Á.¾ßÁ4ÖPÁ;c-ÁBÏsÁJiÁR|úÁ[(ÁcíHÁm.RÁwŠÁ€‰+Á…ŽLÁŠÌÁFKÁ•Í;Á›V•Á øqÁ¦ÀÙÁ¬¤UÁ²ŒpÁ¸þÁ¾™!ÁÌ4˜ÁÅû`Á¿ßKÁ¹É²Á³½°Á­×7Á¨Á¢yàÁœÙ Á—NßÁ‘ûÆÁŒ×Á‡Ñ=Á‚ÞWÁ|0&Ás@ÏÁjv×ÁbúÁYîïÁRL1ÁJø‘ÁCòóÁ=”ãÁ7…Á2 ‰Á-HÁ(±ÍÁ$áÁ!ª,Á,1ÁRvÁMüÁ¸ªÁùŽÁÄÁY9Á ZSÁ#${Á&`¡Á*EÁ.‰Á3#CÁ8K Á=$ÁC“WÁIÔ¤ÁPärÁXw7Á`-:ÁhеÁqBßÁz$†ÁË$Á†Å|Á‹Å»ÁЮÁ–æÁ›“ùÁ¡÷Á¦¥Á¬EÌÁ² ´Á·í Á½Õ%ÁÃÆLÁÛŠÁÕH[ÁÏŒÁÈñtÁÂæzÁ½¾Á·C×Á±¬hÁ¬öÁ¦²ûÁ¡l ÁœU‡Á—d¬Á’…©ÁáÁ‰€wÁ…9OÁ+ÝÁznKÁrà ÁkÞçÁesÁ_ˆñÁZE"ÁU£ÑÁQ˜yÁN»ÁK–ÚÁIfBÁH ÑÁG#bÁF‡øÁFéÁEÂ}ÁE{ÁEœBÁFÕÁG ÁH>ÁJG,ÁM2ÁPWŽÁT(·ÁXúÁ^#/ÁcÉRÁiæ¨ÁpÉoÁwäéÁ¤3Áƒ³€Á‡ßðÁŒ\LÁæ×Á•‘Áš9ÁŸ˜…Á¤ÈyÁª+œÁ¯¿‰Áµ_÷Á»—ÁÀîÕÁÆí•ÁÌósÁÖµ4ÁÐWÎÁÊCÁÃÞfÁ½³Á·¢Á±¹^Á«ûgÁ¦dËÁ ×•Á›nßÁ–1ÈÁ‘&_ÁŒ:bÁ‡gvÁ‚Û$Á}oÁt·ÉÁlÐÛÁe+ªÁ^°ÁWcJÁQ4™ÁK±.ÁFÕ–ÁB±Á? †Á DÁAf£ÁEc:ÁJjKÁOªçÁUšªÁ[ñUÁbÇõÁj3×ÁqØÂÁyàZÁQµÁ…ܧÁŠu²ÁUêÁ”j;Á™çÁžíSÁ¤€Áª!ïÁ¯ÔûÁµ³ÝÁ»³¯ÁÁ¹òÁÇÜêÁÒÁˉÁÅ&lÁ¾Ü¡Á¸§ˆÁ²výÁ¬`aÁ¦s6Á ´Á›-Á•=Á,EÁŠú«Á…÷ŠÁ2Áx¤ÁoÄ0ÁgQ.Á_ØÁWN´ÁP-ÁI_âÁBã¯Á=(rÁ81EÁ3´ñÁ0Á- “Á+óÁ):jÁ()ŽÁ'08Á&¹Á&M”Á&rÁ&|RÁ'C²Á(VnÁ)È´Á,Á/ ùÁ2}—Á6¨Á;ΗÁAÁGCLÁM´âÁTÊËÁ\iÁd!UÁlšÁu¤îÁ~¿ðÁ„-dÁ‰<¤ÁŽ[Á“±ËÁ™BÆÁžæZÁ¤™ïÁª{·Á°{|Á¶ƒAÁ¼¬ÁÁÂøqÁÍn‹ÁÆãKÁÀ_,Á¹öÁ³§ŠÁ­qÁ§=šÁ¡ Á›.ˆÁ•nÁÕŸÁŠHñÁ„ëŽÁÁu•œÁkÕ&ÁbªÁYß[ÁQŒÉÁInýÁAü Á;*8Á4¥SÁ.‘ºÁ)”IÁ$Ç)Á ÿÁÆAÁØÁħÁvêÁjxÁÍNÁyðÁ\mÁÙXÁ£”ÁÊ´Á¤¢ÁõJÁ ëÁ#˜Á'úÁ-$Á2¥ÀÁ8óÁ?‘lÁFúÃÁNÁVª×Á_øÁh£ÁrÚÁ|Áƒ+Áˆy±ÁŽjÁ“­kÁ™bÁŸFýÁ¥ETÁ«OîÁ±€¬Á·Õ/Á¾IÁÈð&ÁÂOÁ»Â×Áµ9ËÁ®ÆüÁ¨sÁ¢:zÁœÌÁ•âEÁë­ÁŠ)ÐÁ„ŽÚÁ~—ÁsZƒÁi0DÁ_@¢ÁU›ÁL’¸ÁDêÁ;ÆUÁ3÷FÁ,ö‡Á&a¢Á ÁÚÈÁ†ÁÝÁœûÁ ^Á «Á¾ÂÁ’ÁùÁ¦MÁ¥öÁ6ÓÁvÁ Q{Á B’Á §RÁ1Á¸ôÁFàÁu½Á$?RÁ*¤Á1›Á9"Á@ã"ÁI‰úÁRŽÈÁ[Ð0ÁeÂèÁp¥Áz‹æÁ‚ÏöÁˆtúÁŽ-sÁ”çÁš©Á  ¯Á¦Y|Á¬·ÈÁ³0ÔÁ¹¬¸ÁĦÁ½ãXÁ·5UÁ°¢—ÁªXÁ£›-Á?uÁ—òÁнÁЧnÁ„«Á}ÏWÁr’šÁgx)Á\ä6ÁRÑôÁHìÁ?x0Á6š¹Á.0YÁ&WÁÉþÁäÁ©ôÁ ¸Á:Á·¯ÀþºÑÀùÀôý‡ÀòVÀïs‚Àî7KÀí¡ ÀíªÀï(ÀðƯÀó¸#À÷ÁÀü¡ŽÁã.Á·MÁ ~YÁÍ'ÁéµÁoÉÁ#ÆÁ+S¯Á3›uÁ<†=ÁE:ÁOhhÁY°Ád/¤Áo0 ÁzyÁ‚ú=ÁˆèBÁŽá*Á”önÁ›8@Á¡¡6Á¨‰Á®˜µÁµ1àÁÀqÁ¹¦;Á²Þ§Á¬"µÁ¥ƒCÁžùöÁ˜t¿Á’ MÁ‹ÍkÁ…›VÁ~Ý×ÁrÚêÁgPNÁ\ ²ÁPñOÁFvZÁ–Á¦ æÁ¬èÁ¸‚ØÁ±‚·ÁªaÁ£´-ÁœåIÁ–®ÁY”Áˆ¼­Á‚7_Áwq9ÁjÅ#Á^aqÁRñÁEêQÁ:`–Á/ fÁ#øèÁ·6Á¸ÎÁUÀû|Àêx'ÀÛöÀÍÀÀÂÃÀµ]À«0ÅÀ¢Ù0Àœ}ØÀ—V‡À“LÀaÁÀnÀŽTÀŽç;ÀqªÀ“-¿À–¼ªÀ›eÀ¡Z0À¨Þ€À±ûqÀ¼ÜÀÉ=ÀÖ‹VÀå—DÀõ½œÁ³DÁ É/ÁÛÁ!SãÁ+õ¹Á7(MÁBÔ$ÁNÆŸÁZÁ}ÁgÁsÖ£Á€d²Á†ïþÁˆÁ”N8Á›%RÁ¢ÂÁ¨àrÁ´À˜Á­²¬Á¦¬ÁŸ²%Á˜Ä²Á‘îÑÁ‹æÁ„SÖÁ{I§Án5¶Áa3GÁTh ÁGöÓÁ;•áÁ/rBÁ#é÷Á’)Á ŽÁ`)ÀòÓÀ൧ÀÏCüÀ¿™ À±XÀ£½>À—àåÀlÑÀ„©zÀ{:ãÀp@ÀgȉÀabåÀ^–ôÀ]ÄPÀ^§0ÀaºÆÀg؈Ào_ÓÀxüòÀƒvÀ‹!À”`~ÀŸÇÀ¬ªæÀºÊyÀÊ… ÀÛ¦ƒÀí¤ÈÁ˜eÁ —Á™iÁ ºÁ,zÕÁ8pCÁDn‰ÁPÖ-Á]®Áj±ÁwàcÁ‚™[Á‰bÞÁ>÷Á—çÁžxÁ¥ Á±PÁ©õÁ¢åUÁ›ØãÁ”ØÁã—Á†ú¯Á€)yÁrµ#Áe0ÁWþòÁKÙÁ>ëÁ1‘ðÁ%+CÁúrÁ sXÁ!¥Àîo?ÀÚ$ÀÆ|ÞÀ´èdÀ¤ ÛÀ”Á¹À‡ÞÀuªúÀ_cÀLU|À=zÀ1DÀ) /À" XÀ-uÀjOÀèÀ"²žÀ)U“À1ŸaÀ;–ÀI~æÀZw½Ànj„À‚äýÀ[ÒÀŸ‹bÀ¯æ~ÀÁÜüÀÔÀÀéœ`Àþ‘œÁ OÁ#|Á"çÁ.5Á:œoÁGˆÑÁT®ÜÁaâëÁoMcÁ|ùÁ…[©ÁŒ@{Á“>PÁšU;Á¡îÁ­­uÁ¦kÁŸ9IÁ˜{Á‘ ÁŠnÁƒõÁx*Ájf4Á\ÈBÁO3„ÁAÕŒÁ4ÒÁ'ÝÁ<ÂÁÁ{ÁƒÀíùsÀ×nÒÀÁÚÐÀ­•ºÀš›¨À‰#›Àr^‰ÀU9‘À;X£À#úwÀ¥<À ¿æ×M¿ÔŸª¿Æ1п¿â7¿¾ ¿À±B¿È¯EÁKì®ÁYyiÁg<þÁu$Áy ÁˆŒ1Á¸/Á–øßÁž?¼Áªd–Á£uÁ›Ø Á”“‚Á^kÁ†=âÁ~^ÁpZ°ÁbrÎÁTމÁFÛgÁ9FóÁ+ÊgÁ£ßÁ¬+ÁíŽÀðÍÀØ¥ÀÁHÀªšÀ•FŒÀÀ]®ÛÀ;$oÀpÀ&¿Òþ¢¿¨WŒ¿† ¹¿Ui¿.Mì¿ã=¿·B¾þÑu¿Åf¿V/¿1>Ÿ¿X[¿„ ª¿¢á[¿È„>¿õ¬,À?ÑÀ3c­ÀTšàÀyPÀŽ8À¥Ÿ‹À»x{ÀÓ¯ÀêäÁ…ËÁMÁ~sÁ(³?Á6ÍÁCÌ'ÁQœµÁ_zÝÁm–/Á{ësÁ…5ÌÁŒyÑÁ“¿AÁ› …Á§-_ÁŸ×ŒÁ˜tÁ‘I ÁФÁ‚¼„ÁwÁhÄšÁZ­äÁL»ŠÁ>Õ²Á0öÁ#ZwÁÑöÁˆbÀöûñÀÝ=,ÀÄ.µÀ«GƒÀ”?ÐÀ{“ÀQePÀ*ÓÀ'Ü¿Ë.¿Ò¿<Âu¾Æ0,½¿×2> Ç>™Fù>Õ:L>ð«Ô>ú Þ>í¶Ž>Çl>ŒÞ4=ö˽­&ܾ®ð¿(å5¿„ü„¿½,¿ûêÀ!‰ÀHgÀrÌ÷À9À¦¶=À¾sxÀÖ¼àÀð¸CÁ–ÁÓDÁ i8Á.<ÐÁ<ÇÁJ+ƒÁX{kÁfõÁuuÊÁýÁ‰MKÁ°$Á˜!Á¤D>ÁœË“Á•`ìÁŽ}Á†»¬Á~çŸÁpZvÁaÍ¥ÁSRøÁE ¸Á7dÁ)nÁ:OÁ ogÀÿÉ&ÀäüÐÀʤÀ°´¦À—KÀ}wÌÀNÖ²À">~¿ðï¿¥1½¿:Ÿt¾†æ7>1áh? ~ë?[i?Œï?£O”?³Å?ºþ?¼ÄÌ?¹ Õ?®ƒm?žs?‰;¤?[o?;>yO£¾&?¿#¸‹¿–~¿ßT~ÀfšÀE„sÀt©¤À’1ßÀªáLÀÄþÙÀßrÂÀú'uÁ ÝÁÁÿÁ&ÌhÁ5êÁCƒvÁRïÁ`†öÁo/Á}þ&Á†m.ÁàòÁ•VÁ¡¢“ÁšÁ’Á‹ iÁƒš¶ÁxtaÁiØÁ[DÁL±ºÁ>"ÔÁ/ŸÁ!\+Ág+Á†tÀïY#ÀÓð1À¸ïÀž‰0À„SÁÀUãÄÀ$™V¿êÀ¿’*¤¾ùI=žÊ?•?‡´?¹’?äß*@o@Ú@b:@@g@aü@•é@  »@ó?å?¿<±?N\?/qñ>5Ÿß¾ÅÊS¿„›¿ÙߤÀšÀLÜÀ~’/À™KªÀ³¹žÀÎú´ÀêÕxÁqöÁ¬kÁ óÁ.’QÁ=KÁKÊÁZŸŽÁivËÁxWÇÁƒ£rÁ‹(¾Á’·ÁŸ -Á—|0Áð–ÁˆftÁ€Þ Ár®ÁcµþÁTâCÁF:µÁ7¦©Á)žÁ~’Á ó´ÀûmÀߨíÀÃõLÀ¨A«ÀjÀdêxÀ0+¿ùMä¿—uÓ¾ãMõ>~i?a¬Ë?¹v?öøÈ@’@-ÖP@@y@Mwé@W32@Zþ@\RI@Yì÷@S¿ç@J§@={Ú@-®W@l#@z?Ã$4?v+·>ªË¾§¤­¿‡›o¿ç¬À'gÀ[VÜÀˆ=ZÀ¤'?ÀÀ5³ÀÜŠÀù^åÁ ´Á¨âÁ(jÁ7@÷ÁFÛÁTô@Ácó7ÁsÁ0Áˆ³ÁÁISÁœ·ÖÁ• “ÁgÕÁ…ÍÂÁ|óÁmoiÁ^`²ÁOQûÁ@EƒÁ1XÝÁ"úÁ ?Áu4ÀíÃùÀд›À´UðÀ˜‘’Ày»¨ÀB_\À ‘¿°o¿ «?>R8,?r2*?ÐsÂ@ÍË@2‰„@O|¯@hg^@|„Œ@…’å@ŠÊ0@ŒÄ@žÁ@Œ;ù@ˆÜ"@ƒ·J@y°3@h)L@Q–@5Ì•@Ï&?Ù“W?„g&>þF¾â_¨¿ wjÀ5ÀÀ;ÀsôÀ•¼%À²ãÀÏd÷Àìy·Á {ÁåÁ"Æ›Á1´GÁ@ÈúÁOîoÁ_MÁnBQÁ}muÁ†LÅÁéZÁšŒEÁ’Ý>Á‹/ñÁƒ‚¤Áw«Áh^JÁY(ŠÁJ‚Á;ÆÁ+ö˜ÁçáÁ Þ¾Àþ ÃÀà׫ÀóúÀ¦ŸñÀ‰¬(ÀZ´ìÀ# ¿×Þ¿Rj¤:Œ50?QÇ7?ËÑ®@ç¸@@h‘@föh@ƒ®í@‘0@œB}@¤';@©wÍ@«í@¬ã@«w@§–ï@¡à`@šfŒ@É@„^g@hÛ@CÉA@3N?Öh?i)×=Ýþ¿<ㆿÌÇÄÀêÀÀW•ïÀˆ§ÓÀ¥ÅñÀÕ ÀáqªÀÿNGÁ›ÓÁ¶¢Á,Ú.Á;ýºÁK!ÏÁZI ÁixuÁxÀ7Á„ÛÁ‹Ã¹Á˜ŒøÁÏÁ‰ÁZëÁsR7Ác÷ÁTÁEEÁ5õÁ&·GÁœŠÁ‘ÎÀó%ÀÔø­À¶ù¯À™¦ Ày$¬À>ý@À_a¿™{ø¾©HÌ? ‚O?¯¢z@ î@=²ž@m2_@‹ô]@žkö@­‹‘@¹½ó@Âl@È&4@˺@Ì@ÊnS@Æ<å@À“@·ôþ@¬çÚ@ž±ß@Œv@o}p@Bö@gè?¹ ß?„¥¾Ž2g¿—æÀA¥À?©÷Àzß\À›BíÀ¹‹À× OÀõH–Á Ç×ÁëcÁ(ÇÁ7=ýÁF…ÁUçDÁe^PÁtÛÁ‚+îÁ‰é&Á–°FÁŽê,Á‡$7Á~¿¯ÁoAùÁ_ÌÒÁPWáÁ@êÒÁ1WÁ"4½Áà{ÁÀèŽ}ÀÊU&À¬?®ÀŽ.À`xÀ%'ô¿ÕÄ¿Bêw> ˜ô?‚qç?ñE¢@/U@cÎ@н,@¢2@·I¸@É[@ÖЪ@à–é@æÒr@éñ¹@ëÁ@èìæ@ä^š@݆@ÔCá@ÇÓ·@¶ò@¢YL@‹¤­@e½#@0b0?ô¥?€¶¼=ÓiF¿P?&¿Þ}©À*màÀeážÀÞ°À¯#èÀÍwaÀëìÁ:YÁƒŠÁ#áÎÁ3MÁBÅõÁRB»Áa¹ßÁq)'Á€L\Áˆ6Á”î·Á!ÊÁ…V³Á{5ÁkÁ[ñŸÁLfgÁ<åúÁ-p¦ÁûµÁ‡oÀþN#Àß™wÀÀ÷¶À¢VýÀƒ¶…ÀJéfÀ ¿¦c¾½H)? n»?º¦@ƒ@Nå@‚Ôë@v@¶‘2@Íx)@â'­@òËn@þ-Ak±A.#AÈQA³;A%×@ú‚Œ@ïã²@à¢\@̾°@µó@œÆ€@Òú@K´£@x:?¯È>âÚÆ¾ö”¿´$ ÀýÀSÀˆ hÀ¦—ÐÀÅ,ªÀãê=ÁSðÁ¸Á -šÁ/¡¡Á?ÁNšoÁ^#ÓÁm³šÁ}GËÁ†nKÁ“^hÁ‹ƒjÁƒ©Áw¤¹ÁhßÁXgÞÁHѯÁ9;Á)¥PÁÐÁ Š#Àö(óÀ×?À¸U/À™}˜Àuž]À8\ì¿öNx¿x£ó¼è²"?hSÙ?ë§”@0Ø~@k ¿@’h@®@ÈÊ~@á´>@ø3uAlA S&AðMAôpA¶ŽAþA­_A ^A^M@öH(@ß@ÅÊÿ@ª†¹@ŽÚ@b†™@'…=?ØJ+?@ ¾Duë¿‘xøÀuÛÀB¨oÀ€ÚÀžÏ|À½ÀÜY«Àûb'Á D÷ÁÙ‘Á,n+Á<ÅÁK—_Á[+ûÁjÈÁzp–Á…þÁ‘Í Á‰õvÁ‚¦Át‹­ÁdÜÁU,nÁE|Á5ÊÁ&$PÁŒ(ÁõùÀÀÏš6À°òÀ‘‚ Àe÷À';.¿ÒËÕ¿0s>‡ ¯?›¾Û@ Ý…@G $@ê@Ÿ Ç@¼$á@Ø¿Ð@óÝæA:ÝA*`A&¸A·áA ðA!>JA )eAYUAîdA‡AÌ@íÿ @Òw‡@µ¾@˜§¾@uÝ%@9º’?úÈ?qc=b ¦¿h-†¿ï\ÚÀ5QyÀr÷íÀ˜zHÀ·´ÀÖ¹rÀõâ1Á …xÁ Á)·|Á9UÜÁIÁX´GÁhgÁxˆÁƒå±ÁS Áˆv|Á€šÁq{BÁa¾ÁR (ÁBZ±Á2«_Á"ü=ÁMXÁžÉÀçáaÀÈÀ©aÅÀŠC ÀV\ÖÀ3’¿´ž¾àâQ?'O?¿¨@Éê@YÓµ@‹nÀ@©Ü@ÇÅ@åxºAOƒA/€ATëA%GëA*ëoA-Š,A-ŠÝA,žÙA)~ŠA#=¶A=A Ι@ù¯L@ÜÈ@¿´@¡ ‹@‚ÍG@Hs-@ Æ?š÷o>~9f¿768¿×™À)Ð Àgþ‘À“(µÀ²]ÀÀÑ”ªÀðË”Á?Á¥ºÁ'W›Á7 rÁFÀÁV{RÁf9ÆÁuùoÁ‚ܾÁŽ÷ÉÁ‡äÁ~\yÁn˜NÁ^Û^ÁO!)Á?fþÁ/¬âÁòÙÁ8èÁ•Àá ÖÀÂGhÀ¢ð¸Àƒž¼ÀH©oÀ Ú¿—ã¾XÈC?Brþ?ÝŒ@,åc@jÀÖ@”@²Í?@ÑQ@ï¥AâA²öA#å[A/¼WA5îÏA9fA9[îA8…A4.ËA+»«AaëAàAm'@ä´ @ÆYö@§Ô@‰÷@T{B@úí?±´>Ô¦$¿Áû¿Ãë„À ;À^ƒ^ÀŽtŸÀ­¨;ÀÌçkÀìUƒÁéÁ§fÁ%e¹Á5$ ÁDã*ÁT¢ÔÁdb}Át"&ÁñÿÁ§KÁ…ŧÁ{ÈrÁlNÁ\=ÁLsFÁ<©|Á,ß²ÁÁ _ÆÀû[=ÀÛæOÀ¼qaÀœüsÀ{ À<5¸¿û]M¿||G¼}?x^?ùX@;^@y>d@›½5@ºÛ8@Ùc@øTyA pÅA¥YA)Š®A8.‹A?íKACrÌACô AB5 A;øQA1¥ A#0A-AÏ@ëß@ÌOW@­v©@Žû@_B±@ à—?Äüü?q”¾Ò- ¿±OšÀ æÀU„¡ÀŠ*€À©¡ýÀÉ ÚÀ蟷Á kÁÈËÁ#…,Á3AŒÁBýíÁR»mÁb€ÎÁrMºÁTÁŒRùÁ„m´ÁyñÁiNàÁY‹‘ÁIÈJÁ:Á*A»Á‰Á ½dÀõíöÀÖZbÀ¶ÆÍÀ—7¾Àož@À0‿ä*‹¿L­¥>;ç*?”þÌ@Äò@G[e@‚ýŒ@¢Me@Áœ™@àâ×@ÿÕæA`&AÉôA.|A=CnAH›#AL.|ALÑbAIABe.A5eçA&aÿAõAÉÍ@ð®½@ÑÉÓ@²äé@“ÏB@iÀÄùÀäwøÁþ”ÁÇ'Á!üÁ1XÑÁA!­ÁPíYÁ`¼üÁpŽÔÁ€0\Á‹6cÁƒIFÁv¸PÁfÞÁWúÁG+$Á7WŸÁ'ŒŽÁÈÁFÀðƒüÀÐýmÀ±vßÀ‘ñ‡ÀdÚ}À%Ñë¿Í‡-¿q´>¼"¢?¬€*@ûÕ@S·–@‰Eø@¨’`@ǵ @æãTAîAÀÛA"M>A1ǧAA>,ANß%ARÌSAS¥¦AOgAGáäA8´°A)[uAéA v³@öG@×!Â@·ßO@˜œÛ@rµ @45Ç?ë\?Zãv¾ ¿ÙÁÀ¿¿ÀD¥ÀêÀ¡ƒCÀÁõÀà´§Á&­ÁóÁ¿_Á/‹¸Á?UÇÁO"fÁ^òßÁnǪÁ~ŸÊÁŠ#uÁ‚5÷ÁtñÁdµôÁTÛ_ÁE#Á5&èÁ%L¬ÁrqÁ˜5Àë|ˆÀËÍLÀ¬%úÀŒ‰ÀYûèÀîÊ¿·ÃY¾æ¤x?à?Â/@ I)@_Qº@-'@®°‘@Îú@íNA<‰AÞZA%€:A5yAD…¨ARö—AWË)AWÜVAT?3AJÿ?A;“‡A,'ÏA¼A 9F@ûF«@Ü ^@¼Â»@]{@{ðu@=%õ?ü¶ê?~CÓ< Öü¿zRÞ¿û•À=QÀ|6ÀµõÀ½PÛÀÜëÂÀü‰?ÁËÁíÁ-ÁXÁ=•žÁMiäÁ]>*ÁmDÁ|ê¢Á‰Á&|ÁroÒÁb“UÁR¸RÁBÝVÁ3YÁ#'\ÁL_ÁqbÀç,ËÀÇvÒÀ§ÂÀˆ šÀP²FÀIX¿£Ñ¾•¢¨?1ù2?×r°@*þ½@j7‚@”¢P@´(Þ@Ó­Ö@ó2A F›AñìA(†‡A8™AG¯sAVGÆA[©A[—AXIEAMÑÏA>j A.×GA=ÛA¤o@ÿõ\@àè@Á,u@¡¼Ž@‚H`@E¨b@{ð?ŽC>)¿\ñ¿ì°PÀ5‰˜Àt»À™ö<À¹“?ÀÙ9ýÀøæÍÁ JÁ!›Á+ø¶Á;ÏÐÁK¦ëÁ[~ÁkU Á{,AÁˆýÁ€÷ÁpR¶Á`w—ÁPœxÁ@ÁYÁ0æ:Á! .Á- ÁOäÀâçÀÃ1ˆÀ£{ŽÀƒÅ•ÀH6À³C¿’ŽŸ¾µÂ?VB\?éø’@4e7@s«ƒ@™o@¹c@Ø¡³@ø=PA ðA° A+b˜A;$AJÂ8AXÿôA^O6A^uLA[ßAPcòA@Ê;A1/€A!Œ½AÒ¦AŽ@ä¼î@ÅHÀ@¥ÅÈ@†+#@M$Ó@ óc?ƒç>y=¿>ƒ¯¿Ý¤·À.ËÀm5;À–3UÀµÌ ÀÕi“Àõ¾Á ]ÏÁ8aÁ*åÁ9ò ÁIÏ©ÁY­Ái‹YÁyi1Á‡ Á~1ÁnPÁ^oGÁNŽÅÁ>®œÁ.ÎXÁî®ÁðÀþdëÀÞ­nÀ¾÷0ÀŸ@òÀhÀ?¨íÀ4i¿§¼¨dA?xl«?û<@<ó@|_@å|@½—(@Ý=:@üã;ACáA$A-ègA=µxAMh³A[‹A`[ÕA`Ã-A]³ARš,ABþØA3J–A#‘sAØYAB@èÈx@É5@©Ÿ:@Ї@Tã©@¶C?­¼>ºÛ¿Gµ¿ÍÿôÀ&CjÀe†ìÀ’fùÀ²ÛÀÑÉ/ÀñzƒÁ•ëÁn•Á(GVÁ8!ÁGûæÁW×|Ág³µÁwŽ€Á†*-Á|sPÁl‘8Á\®¼ÁLÌ@Á<éÄÁ-HÁ$ÌÁ BPÀú¿§ÀÚú¯À»5¬À›pÀwkäÀ7₿𩾿cî=ØÍ?Œ¨@á¯@En@‚mJ@¢$ã@ÁÇÙ@áp"AŒ6A`ZA 4A0¤A?ÐANåÆA\S×Ab£Ab‡õA_…ßAT‘PADð*A5JUA%–AÝUA"ª@ì±õ@Í”@­‹4@ñQ@\«k@t4?¼yû>ø œ¿9¿¿% Àõ.À^WÕÀŽÖÀ®{3ÀÎ LÀíÅdÁµ>Á‰Á&bsÁ6<¤ÁFÖÁUñÁeË9Áu¥kÁ…LýÁz¸SÁj×IÁZö>ÁK3Á;4(Á+SÁrÁ ‘À÷_óÀךûÀ·ÖÀ˜ Àp˜%À1 ¿ã[¿GÙi>YO?š@˜@ ‘}@Kå+@…œl@¥FC@Ä÷È@ä¶ÓA>‘A!úA"ØA1HºA@CxAOvA\W­AbÖóAcÒA`ÍãAVusAFÔÃA74A'ƒ#AÔ A©@ðˆ@Ðîß@±U¥@‘¼l@dhÀ@%o†?ÌR?ŠS¾Ã!¿¯TºÀðÖÀV7˜ÀŠÀØÀªlÍÀÊ!9ÀéÖmÁÆ8Á¡Á$|øÁ4X–ÁD4CÁTðÁcëÁsÇKÁ„Áy-LÁi>ÁYR>ÁIiÁ9ƒéÁ)¢„ÁÁ{Á à‚Àóÿ<ÀÔ=²À´|…À”»ôÀiøôÀ*~¥¿ÖE¿.†b>Ÿ" ?¦äú@¶@RŽï@‰”@¨‚@Çþ¶@çšµA AéÒA"¡A1 A?ÅXANn¿A[æýAcU·Ad¹óAaý AX 9AHNA8ñcA)K‹A „A Ý@ô9h@ÔÌ@µq®@•¾X@l@,¯]?Ú±?8V-¾‰oÅ¿ öUÀÈ\ÀOŽÀ‡2dÀ¦ã®ÀÆšËÀæR%ÁßÁèšÁ"Í!Á2³´ÁB›YÁRƒÁbj¬ÁrRˆÁ„#<ÁxR&Áh^ŒÁXkèÁHzuÁ8Š€Á(œwÁ°ôÁÈÙÀñÊÂÀÒ¬À²D—À’…ÃÀeÄÀ&¿Í0¿qû>Âú?¯¥e@?¼@V¬Ç@ŠÓ¤@ªÉ@ÉIU@çö€A1˜AGA!)ÕA/ü¤A>´êAMIZA[(¯AcŸAdýAbÎýAY!´AI¯6A:6œA* ]A"A dþ@÷s6@Øi@¸–Í@™â@rÙ¦@3Œt?ègƒ?S‹¾*÷Ä¿”B6À ’ºÀISÀ„\ýÀ¤,QÀÃû¤ÀãËlÁÍÌÁµãÁ!ùÁ1†ÁAkØÁQQ™Áa7[ÁqÁƒÛÈÁw¾›ÁgÆ9ÁWÎøÁGÙÁ7åÁ'ó2ÁYÁ‡Àðh§ÀÐ¥-À°âÀ‘™Àb¼„À#>ȿǙO¿x³>Ø‚o?´ã@hæ@VÈp@Š“ý@©—ã@È @æa‚A)A>AÌâA.„³A<þZAKl–AY8Aa`„AbÒÓAb¬òAY™AJ8¢A:σA+SæAÍ®A 3@ù/®@Ùó›@ºˆ.@šüÆ@vÕÁ@7±õ?ñS?e¢Ê½º“À¿Š_mÀÆbÀDdÿÀ‚¨À¡ÒÔÀÁ£ÀápÂÁ¢*ÁqÁ ,Á0p°Á@cŒÁPWpÁ`KìÁp@lÁƒù‡ÁxàÁhêÁX(õÁH:ÿÁ8M Á(_ÁrÁˆ›ÀñGïÀÑ…öÀ±Ä À’Àd€aÀ$üˆ¿ÊóÖ¿.×>Åoù?®9c@‹d@SïÂ@ˆ´-@§?@ÅJ–@ãCíAxíA%qAÂ6A,?SA:§òAHÜYAUárA\{A]ÑáA]òµAVpLAI©§A:u„A+‚A±A %@øê@Ù³V@ºTð@šì—@vâà@7ÞÝ?ñ6l?e^>½½‚꿊_|À}ùÀCå`À¦cÀ¡ZÀÁŠÀàΞÁLÈÁ5åÁ !Á0Á?þÁOîÁ_ßWÁoÒ—Á„M Áx«"Áh»eÁXÌ ÁHÝmÁ8ï\Á)fÁuÁ 'wÀòYÀÒºÀÀ²ý.À“V¸Àg·]À)&#¿Õ1¿0Úä>‘? ÷v@Ôõ@M’@„ö¨@£@Á{@ÞÞ›@üJ—A · A–¯?$Y@-@Bˆ[@~ä–@‰@»R@@ØÁ@@õýŠA ƒâA´±A%¾A3ÝA>²ƒAF¤hAKK1ALKµAKô,AF¼A<«8A1èA#îmAÈ'A 9@ïä@Ѽµ@²ç=@“ø5@jE@+ÌJ?Û0Ÿ?=…q¾nMk¿šugÀ þ ÀK9æÀ…?èÀ¤ã%ÀĈ¬Àä/üÁì6ÁÀÐÁ!•®Á1j¿ÁA?öÁQúÁ`ñÁpÑÁ…mKÁzúÉÁk!Á[HƒÁKxÁ;¯Á+ðÔÁ:ÕÁ …8ÀùŸ8ÀÚ3ÿÀºËóÀ›i»Àx…8À:b³¿ø€\¿xv£9›‡˜?t!d?ò @4úG@pó=@•õÆ@³â@Ï÷Þ@ìxçAh3AjAÒÄA,pA5¥ÑA=@A@³ÊAAEA@É_A;ÙGA2ÙŸA(VSA@³ADPAÉ@æiÚ@ÉZ‘@«•b@‹g@]Éä@ 6å?ÅGÍ?ªH¾Êº¦¿®Ç„ÀòyÀT¡ÄÀ‰¨ˆÀ©.ÀÈWÓÀ糃Á–/Á^óÁ#/ÝÁ3„ÁBÕÏÁR©™Áb}ÈÁrRHÁ†LÁ|ЫÁm£Á]U~ÁMHÁ=è¢Á.5<ÁÖÁΘÀþN«Àß/FÀÀÀ¡ØÀ‚‘ÀF`]Àƒ˜¿–ó¿¾xÐý?1ùj?ÑD@#DJ@]\Ë@‹³ @¨Ú@Ä<3@àS²@ü,ËA t²AÊA"[ÇA*ª§A1êA4æA50dA3ÝA.îEA'ÔÅA!ÄAVûA@ô<@Ùp;@½†¦@¡z@ƒÛ@Lµ6@ËÄ?¨Q>¸Œk¿Ï¿ÆóáÀ!¬mÀ_æÇÀÀ®-½ÀÍg“Àì¾³Á ïÁ·RÁ%jGÁ5#NÁDÞƒÁT›WÁd_–Át*lÁ‡uÁ(«ÁohäÁ_«+ÁOòÁ@DÁ0¥®Á!îÁ¡ÐÁ,[ÀåoäÀÆŠ"À§©"ÀˆÒÎÀTéUÀæþ¿¹ÉN¿ûƒ>Ë V?§z$@ ;›@E؈@~€ @›{G@·?‘@Ò°@íÁ×´ÀíÖÀÎhÄÀ°&EÀ’%Àh[ûÀ,Å ¿äbf¿_ñ¼<ïMm?lH¿?çU“@+É¢@c?ñ@[@¨H@Â[W@ÚÉÅ@ð|A¥A {aADSAÌÊAâíAíËA©A‰–A û%AÚü@û ,@æ%§@Ï•Ù@·~k@ž7»@ƒÝO@R©=@’®?Äâñ?'±ä¾‚JÄ¿—ÀÑ»ÀBsUÀ(Àï:À¼U"ÀÚóîÀùß×Á lñÁê÷Á+i·Á:è¯ÁJhPÁYòÆÁiŒµÁy3–ÁŠS Á‚”DÁu«MÁf0ŒÁV¸ãÁGGÖÁ7í Á(œMÁKÁ }Àõ×àÀ×ݸÀº¸ÀœF@À}Ã÷ÀCÒÀ ëC¿ ïN¾ÂrÙ>þ¸¶?¯uº@åï@EJö@zi@—)™@¯:Ý@ÅVv@ØÊÄ@éžÞ@øjUAxvAdÌA 3Aù[AȾAÍ|@ÿTé@ó‰ý@ã.@ϼ@ºF@£i3@‹ya@e& @0Æ„?÷øD?‹Ä¾>\ôQ¿*Qv¿Ç¡ªÀâUÀX+cÀ‰|óÀ§PwÀÅ¢‡ÀãþÚÁ1”ÁfìÁ²¦Á/„Á>ÁN Á]ŒwÁm oÁ|ŽÁŒ/Á„r Áyx¶ÁjcÁZ½ÇÁKfªÁ<¶Á,ÝÁËìÁä}ÁÀâNRÀÄò©À¨MÀ‹À\»3À$w5¿Ø”Ë¿PvX=.½r?ep·?ÞÑ @#¾¢@Vx*@ƒY@™Á–@­¼y@¿Â@Ï}Ø@ÝÀ@裠@ñ„ð@õí@ó¯@ït8@éå @â3f@×¶†@ÉRc@·1@£q@»•@mã/@>D*@ ºy?²Ò›?šR¾ˆÙŠ¿Ž¹ñ¿þ+NÀ8Q¬ÀqŽ#À•ÉFÀ²íËÀÐ9ÀíªtÁçnÁLÁ$PÒÁ3†YÁB¿õÁR¢ÁaiÁpËBÁ€vÁŽ1KÁ†BÁ}ÁnGÚÁ_ ®ÁOêÊÁ@ïÁ2AÁ#FýÁ{½ÁËÒÀîÆÀÑ•~À´âsÀ˜¢µÀx×À@ºrÀ ÓC¿¦¾åHë>Â}y?˜$6?ü¹–@.: @[´@‚ @•ü@¥|¢@´N @Á9‡@Ëðù@Óñ{@×jh@Õgç@ÑTç@Ëù[@ć7@ºÞE@®5Ÿ@ž()@‹‹ø@n @BÃÈ@Í%?Ê“š?Q9F<}%ä¿IP¿Ð.9ÀQÓÀTŸÒÀ†f„À£À¿ úÀܬ{ÀùÑáÁ ˆuÁFÁ)7?Á8JhÁGqŽÁV¥òÁeÛxÁuÅÁ‚7ÔÁNèÁˆ¯âÁ˜Ás.xÁdDëÁUv×ÁFªëÁ7ëÁ)4ïÁ÷Á {Àûg‹Àß'ŽÀÂè®À¦À>À‹E§À_µ&À(é¿è’¿}«f¾;éˆ?'·?« @˜—@,±Í@SñÂ@v“ù@Šß‚@˜ý¤@¤Æž@®±°@µÔ³@¸®§@·@³é@­¿`@¦ªˆ@¸‰@’,–@ƒÉ"@eM7@>¦&@Är?Ó).?m¥¥>Cì-¿l¿®ÅÏÀ ªÇÀ?`Àu.ëÀ•´ÑÀ±^ÀÍb€ÀéÚ¦Á?•ÁÈWÁ `|Á/<Á=ȪÁL¤õÁ[§Áj´ÁyÑ Á„}øÁ’Æ Á‹G ÁƒÔ‘ÁxÛÁj)Á[[nÁL¥SÁ=ñ(Á/W.Á þÁä±ÁÑÎÀíÇÀѾ7À¶NˆÀšêyÀ€!ŠÀKÄÒÀ2’¿ÇÝ2¿K#½½[2?'³B?¨â?øM0@ cÈ@B-@^Ö¹@y^ç@ˆCÀ@‘»@—¤b@™Ýl@˜\è@”“@@\à@ˆŽ·@€@jû@P³_@1r@ ø'?ÊíÎ?mñÍ>zоòr뿚Ѩ¿úó×À/³²Àbû‘À‹¤™À¦­ÀÁ#]ÀÜŽ-Àø|Á 9ÅÁ^AÁ&¯÷Á5<ÁCã$ÁR™ ÁaOÁp×ÁñÁ‡ tÁ•†­ÁŽšÁ†ÀúÁ~ËØÁpÄÁab¼ÁRÍÁDoÁÁ6H×Á(4ÁÁ#gÁ BŠâ¾îÙ¿”u&¿ð HÀ'kÀWBÆÀ„(1À¦4À·Ê–ÀÒ)Àì Áê6ÁÕ5ÁÍxÁ-Æ\Á;Û½ÁJ,xÁX¹ŽÁgkaÁv!ÚÁ‚l*Á‰Í|Á˜y_Á‘ )Á‰É/Á‚tÑÁvZRÁgû˜ÁYÃÁK›Á=†Á/œÁ!»[ÁìÁvÌÀò*uÀ×ÅRÀ½‹ÍÀ£‰çÀŠÛ¢ÀdÆôÀ5Í6À{2¿¹ª„¿P˜m¾[‘H>­K•?XON?¨Û?ݼ@ŸO@qž@*Ç@4[@8w@5º@/ Å@$þ®@‚@Q¨?ëF&?¿Àá?ˆa?öÒ<ÍË¿-Ù¿š~U¿ïU2À$"(ÀQ½êÀ€\À˜†åÀ°ç1ÀÉØäÀãð”ÀþA&Á HÜÁ¡Á'l+Á5dlÁC\¯ÁQTòÁ_k3Ám¿Á|FzÁ…z¢ÁŒÕrÁ›³Á”?ÁŒú´Á…ÊýÁ}Q‰ÁolÁ`ð£ÁRþòÁE"ÐÁ7JEÁ)°ÁÁLßÁïÁ×.Àé |ÀЗÀ·‡2ÀŸPÀ‡ŠÀÀaÑÜÀ6 'À ¸Ô¿Ê¬¿‚½í¾ÿࣼDìz>ã½?X1;?˜‚Z?¾y´?Ú]Ó?íRø?óÑ?ï€Î?ãÚV?ÏS(?¶xÊ?—•É?jL1?8Í>7ó¾VÔ¿Jj¶¿®%é¿û7"À&ßcÀQz¡À~ ½À•ɉÀ­0ÉÀÅlfÀÝljÀö[aÁ0Á5ÚÁ"]¥Á/3Á=ÁJÿÎÁX÷ÿÁfð3Áté[Á„øÁˆ¯°ÁðãÁžÉeÁ—™AÁuûÁ‰SÓÁ‚9žÁvr3Áh›ÁZÇÖÁM –Á?šÁ23­Á$ò'ÁñòÁ õ Àü¸,Àä6¹ÀËícÀ´HˆÀ®À‡ÐÂÀeKÀ=ήÀ¤Ð¿ìG”¿¬ Ý¿`ø¯¾ä轄'­>Šˆ›? ­=?A"?c¾?nr’?gº?Oê°?).v>ó#Í>vò¼úò¹¾ª„¹¿5!¿’Åâ¿ÐìxÀ FjÀ/êYÀW;ÊÀ€N²À•´ÂÀ«ø©À½SÀÚÀòQçÁSñÁŒ[Á9†Á+X Á8~ŸÁE¥4ÁRý&Á`­ùÁnž{Á|–Á…FÝÁŒE'Á“Y5Á¢DÁ› ýÁ”%ÁŒü\Á†ÎÁ~L…Áp†ÄÁbøÄÁU³ÁH-*Á;¼Á.àÁ!,CÁ¶åÁs ÀøÇÙÀá¹ÀÊyDÀ´›ñÀŸ »À‹Q)Àp>þÀLðÀ,WÀ û ¿à€Í¿«Íe¿z¹{¿*¾Ï«ž¾Mbv½¥Á…½93~½‡yà¾$E¾šÃ•¾õ[:¿4Ñl¿z¿ ³*¿Í¬‡À¿À«(À?΋Àbñ¢À„’À˜nÀ­V:À¸[ÀØñSÀïºIÁ{&Á›´ÁÄÁ'û1Á4}ÁA}TÁN£éÁ[Ê~Ái;Áv„Á‚&/Á‰ ïÁªÁ—dÁ¥ÒAÁžÆ°Á—Ñ1ÁèžÁŠ®Áƒ1CÁxðNÁkˆtÁ^;—ÁQ7‘ÁD9ÎÁ7tìÁ+´ÁÊãÁÑ'Áù„À÷IIÀámÀËÈÃÀ·âmÀ¤_äÀ’M[À·Àb)ÀEîÀ(öªÀ}¯¿óm¿ÌçX¿­¬n¿• ü¿†¤Á¿‚Ì¿…â\¿õi¿¡ù¿·ÌƿԵ¿õéÀ µóÀ }gÀ:oÀVÝçÀuœ÷À‹™þÀä¹À±.ÿÀÅ>ÀÚ`3ÀïÁDÁÁf!ÁûXÁ&uÁ24JÁ>lÁJÖøÁW¨ÏÁdÉ3ÁqïÈÁ"Á†<ŽÁ ´Á“öûÁšò¦Á©–tÁ¢ªúÁ›Ä¡Á”íúÁŽ(šÁ‡tÁ€ÁÁtXÑÁg[dÁZf˜ÁMÉkÁAl‚Á5&qÁ)>bÁqšÁaÁ Àø°Àäu¥ÀÐäðÀ¾n¯À¬¨ÀœY{ÀŒé´À}:ÊÀbDùÀJ[ÊÀ4ÎÀ"ÀTÀýÁÀ úÀÿž¿ÿÏfÀÎ_ÀµîÀ£ÌÀxÀ'Á>À7 aÀIðÀ[PÁÀtàÀ‡¥fÀ–ÀÀ¦‚À·{øÀʈÀÝËéÀò&ÁµuÁfæÁŒRÁ$òZÁ0ƒÐÁÁ­† Á¦­DÁŸÝpÁ™$NÁ’oèÁ‹ÅþÁ…>PÁ}áÁp£Ád$ ÁWÇQÁKŠ;Á?°ãÁ3î3Á(ˆ8Áˆ´ÁÍ>Á„“Àýp¿ÀêþÀØœQÀǤKÀ·ÁÀ©µÀšËjÀîÀ‚¿‰Àp=ÈÀ_‹ÀQh^ÀG7vÀ@³µÀ>i&À@’+ÀEÀL†¶ÀWNÀexÀthyÀ‚ßÎÀ‹ô”À–äÙÀ¤XÀ²bKÀÁŠÕÀÒHkÀãØÀ÷qÁ9>ÁÁ;4Á$ò²Á0Á;~’ÁG§ÁRúÁÁ_ÁkMºÁw§€Á‚vÁˆŒrÁ.Á•µMÁœRtÁ¢üPÁ±˜âÁªÔÝÁ¤ Ál¶Á–ÐáÁPHÁ‰ÙÁƒwÐÁzÌÁn&.Áaø­ÁV%ŽÁJmÃÁ?TÁ3ò—Á)B‘ÁÚŽÁÁÁ ccÁ_IÀó))Àâç ÀÓŒ„ÀÅïÀ·rpÀ«7…À ZAÀ–`Àþ÷À‡»À‚ÃãÀwÀÀ}8ÀE#À¶FÀ…o‡ÀŠš–À‘%…À˜˜LÀ¡G”ÀªjÝÀ´õÀÁYÀμÏÀÝ:^Àíd`Àþ‘Á<9ÁßZÁš,Á&ýÁ0ÀóÁ;ƒÁF¦ÁR ËÁ]¢]Ái{˜Áu‰ÚÁ€ßLÁ‡ *ÁFéÁ“©wÁš/ÒÁ ÇtÁ§d™ÁµÐ…Á¯·Á¨oeÁ¡àØÁ›gdÁ”úÁޤ²Áˆs„Á‚FŒÁxmêÁlš9Á`ïgÁU‚ ÁJ_@Á?·äÁ5?NÁ+K]Á!™ÜÁpqÁ’MÁ¡Àþ‘Àï ¢Àá9iÀÔ{ÝÀÈÑãÀ¾CÀ´ÁéÀ¬É]À¦‚À¡ðlÀŸEÀž*:Àžü À ûýÀ¤£›À©šsÀ¯Ì À· ãÀ¿¯ZÀÈå®ÀÒsÀÝórÀë)–Àù@ÁMzÁ  5Á#tÁ’£Á(4FÁ2 Á<˜ùÁGF³ÁR¥Á]5NÁh—0Át31Á€ùÁ…ÿ’ÁŒ¼Á’D—Á˜wÌÁžÌêÁ¥D¹Á«Ù©ÁºêÁ³xçÁ¬öTÁ¦…ÎÁ !OÁ™ÖŒÁ“¨MÁ~EÁ‡q²Á‡sÁwrfÁlSÁ`Ó§ÁV-7ÁK­óÁA”ùÁ7ÝòÁ.™Á%– ÁàèÁÕ¿Á $õÁÜ*Àýô!Àñ“Àæl›ÀÛñ&ÀÓ#ÁÀËœ Àŧ>ÀÁ LÀ¾…ŸÀ½¼ÕÀ¾U¥ÀÀ`JÀÃׯÀÈšOÀΆ»ÀÕÏßÀÞÀçÀðoÀû-%ÁÙÁ ìâÁ@IÁ3kÁ"޼Á+[œÁ4é|Á>‹BÁH†ÇÁSöÁ]ÌrÁh«ÈÁsÅ´Á$NÁ…bÁ‹F<Á‘=zÁ—P-Á}Á£¬6Á©õ†Á°`ÑÁ¾ŠŸÁ¸Á±ª)Á«M"Á¥ UÁžÝ*Á˜·ÔÁ’¬pÁŒÂÀÁ†úÈÁC&ÁwPÁl¢ŠÁb"«ÁWâÁN"XÁDš#Á;›õÁ2Ü!Á*j°Á"°—ÁïÁ‰Á „òÁsÆÁ¸Àú7…Àñ޵ÀêxšÀäÏ Ààq¿ÀÝñÐÀÝOqÀÝʼnÀ߯ˆÀã ÃÀçš,Àíh Àô‰èÀü~åÁ¯ýÁtíÁ gOÁ†TÁ"Á SÇÁ'æ²Á0!pÁ8’ÁA¤sÁK@UÁTê^Á_ gÁi¢óÁtT²Á@õÁ…+ÁŠÙÁªlÁ–Áœ}ÿÁ¢‰ªÁ¨µoÁ®ãzÁµ"{ÁÃ4ŒÁ¼ÓeÁ¶{Á°?Áª`Á£ñ‰Áç.Á—ÿ{Á’<]ÁŒ…—Á†éPÁŒ2Áx—þÁn;\Ádf¿ÁZÇ­ÁQ©ŒÁHßáÁ@4'Á8@ÓÁ0‹nÁ)8ãÁ"c`Á:ÁA­ÁñàÁ ?äÁ Á­rÁûiÀÿàÀýa¸Àüâ ÀýQ‡Àÿ4áÁ kÁOÁ4ªÁ ¡øÁ }9ÁãàÁ—GÁcoÁ!-,Á'‘Á.{\Á5ærÁ=¶gÁFYÁN²ÁWõãÁa—/ÁkT›ÁuKÁ€øÁ…peÁŠëÁt{Á– Á›òÖÁ¡Õ:Á§ÀšÁ­Æ Á³îCÁºúÁÇþ³ÁÁª§Á»sëÁµJGÁ¯+aÁ©!íÁ£=YÁ}óÁ—É¿Á’,äÁŒÈ Á‡†¨Á‚O.Áz«&ÁqÁgº²Á^ã¡ÁV(¿ÁMâ‹ÁF0Á>zôÁ7€fÁ0è¸Á*Ÿ–Á% ÏÁøæÁf_Á†ØÁ%÷ÁOÁ¬_Án3Á:TÁrÁ^ÁÇ Áã¾ÁµÁþüÁÓ‹Á!ÞÁ%«‘Á*ÇÁ/ëZÁ6÷Á<¯ÖÁCñÁK‡ÉÁS¢¬Á\KÁdä7ÁnLfÁwðñÁ€ä+Á†°Á‹VwÁ·éÁ–5¨Á›½»Á¡gzÁ§;@Á­¤Á³èÁ¹ÛÁ¿(ˆÁÌÛ–ÁƨÇÁÀƒËÁºeVÁ´]=Á®|)Á¨¿ÈÁ£EÁrLÁ˜×Á’Â4Á„dÁˆzëÁƒ¤¶Á}ÑöÁtçaÁl,(Ác§Á[¼ÜÁS÷ÁL¯ÁEÝÖÁ?noÁ9^MÁ4xÁ/‡Á*˜ÊÁ&îŠÁ#µÃÁ!(ÕÁm0Á8}Á¢Á=ÿÁ$ˆÁ {èÁ"‹ËÁ%6ßÁ(\Á,/|Á0_úÁ4ÇÇÁ9ª;Á>ÅvÁDÃÜÁKqÁR þÁYŒ§ÁaEIÁi‘ÿÁr(½Á{!ÁÁ‚QŸÁ‡*ÁŒ!¤Á‘JÍÁ–™LÁœ”Á¡€?Á§2Á¬¯×Á²ƒ©Á¸fÁ¾JšÁÄE­ÁÜ$VÁÕñ¦ÁÏÁ-ÁÉœÜÁÙ&Á½¹jÁ¸ÀÁ²\ÇÁ¬ÇÁ§bœÁ¢4¸Á3Á˜>Á“{ƒÁŽ÷IÁŠ‘ÜÁ†c‰Á‚arÁ}+ Áv?ÁoŸPÁi?Ác~·Á^”ÁYà ÁU¼ÞÁRkŸÁO“©ÁMƒÁKQÁJ’ÁI GÁHuÁHBÆÁHK!ÁHÿîÁIÌÁJöTÁLš/ÁNàøÁQgÁTç4ÁXˆOÁ\ø€ÁbºÁge–Ámz5ÁsåàÁzÙIÁ,\Á„úNÁ‰îÁ€Á‘ûœÁ–žúÁ›ˆPÁ §„Á¥×hÁ«1ÏÁ°¹%Á¶\ÔÁ¼ÃÁÁë5ÁÇàØÁÍÜšÁ×C?ÁÐò ÁʼWÁÄ‹ÞÁ¾dÁ¸]|Á²|ñÁ¬ÄÝÁ§˜Á¡ˆ/Áœ( Á—ªÁ’ÚÁDÁˆlÁƒúÁ<·Áw¸ÁoE·ÁhÝÁaUôÁZÞUÁTßöÁO»ÑÁJï{ÁF”„ÁC'\Á@%¸Á=ê€Á;Ù{Á:4;Á95¦Á8—šÁ8jaÁ8zÖÁ95ËÁ:ÁÁ;z;Á=*ªÁ?|ëÁBÁEÃ1ÁISÁNÂÁS@?ÁXßLÁ_$ÊÁe¼LÁlý Át†wÁ|v„Á‚‹ìÁ†þÁ‹ŒLÁd—Á•aÁš²kÁ ©Á¥‚ÉÁ«$cÁ°ÝÁ¶¼oÁ¼´Á°ŠÁÈËÊÁÒ’óÁÌÊÁÅÃWÁ¿‡ŒÁ¹VÁ³+¨Á­!îÁ§@†Á¡‰Á›ÞPÁ–KIÁòÁ‹Ø+Á†ÕIÁùnÁzϽÁqùìÁivéÁabÁYúrÁS':ÁLˆ?ÁF`±Á@ÛYÁ;ûíÁ7†ÒÁ3ÐYÁ0ÄiÁ.F2Á,%Á*h¬Á)^Á(»&Á(“?Á(¬¸Á)k§Á*cxÁ,ÒÁ-¾oÁ0œÁ2ã§Á6– Á:–ìÁ?I‡ÁD’ÁJm€ÁPÖÍÁW±œÁ_(GÁfæÇÁo;„ÁxÁ€„[Á…HaÁŠXÖÁÑÁ”ØÁšM¦ÁŸëÿÁ¥©Á« Á±‡\Á·†¯Á½¦UÁÃèEÁÍù\ÁÇwîÁÀû4Áº˜˜Á´UµÁ®!@Á§óÔÁ¡æÁœÁ–N0Á¢LÁ‹ŠÁ…¿ôÁ€­mÁwT“ÁmÇ(ÁdÕOÁ\3ÁSݦÁL”ÁDê…Á>;ÃÁ7õiÁ2¶Á-=Á(z-Á$Á!VíÁ †ÁvÁ§Á‡†Áà.Á¼¿ÁásÁ¡ƒÁº ÁpÊÁVsÁ ²LÁ#¶¾Á'e³Á+­Á0(Á6xÁ<ÁB­|ÁḬÁQk@ÁYz¥Áb3þÁkYÁtkuÁ~l—Á„o«Á‰¯zÁÁ”³ÙÁšvÁ bxÁ¦\Á¬]1Á²ÅÁ¸ÊaÁ¿3wÁÉ}ÙÁÂá–Á¼]½ÁµßcÁ¯rªÁ©'¯Á¢í”Áœ¼ªÁ–«7ÁǶÁ‹áÁ…h¬Á·‰Áu&¦Ák ÓÁa {ÁW³ZÁNå×ÁFFºÁ>jiÁ6ΤÁ0JÁ)€?Á#…HÁ;™ÁQ ÁJDÁæ ÁLÁ ÆïÁ ò•Á ¹3Á ³Áæ?Á ¢Á ×`Á áÁ Ð Áé:ÁK×ÁжÁGþÁÃOÁ!³Á'|¶Á-ÈÇÁ46Á;û€ÁCâFÁLSûÁU2TÁ^]Áh4ÀÁr Á}ÂÁƒèIÁ‰|ÁD Á•5ÑÁ›0ÕÁ¡4#Á§^IÁ­®aÁ´1ÁºœìÁÅ:¯Á¾yDÁ·Ð´Á±DˆÁªÇ¸Á¤RLÁþ8Á—½ãÁ‘†±Á‹p Á…‹QÁ¯"Átd©ÁiV=Á^ÚµÁT¾¦ÁJÚ6ÁA¾ÅÁ9pÁ0¥Á(úîÁ!ÃÒÁàÁ %Á^BÁ M\ÁYÁuÕÀþöÀú0¿Àö~êÀóëåÀò|Àò#½Àò›ŸÀôxÀöëuÀú^ŸÀþìyÁñßÁc‰Á P Á Û+Á1žÁ4Á¡ Á&œŽÁ.e`Á6‚âÁ?PáÁHd-ÁRµÁ\Y’ÁfÓ6ÁqqôÁ|Œ·Á„nÁŠ qÁ§Á– Áœ<Á¢”¨Á© Á¯•0Á¶-ŒÁÁ°ÁºD:Á³~Á¬È Á¦//ÁŸ°ŸÁ™5ûÁ’×,ÁŒ“ Á†T·Á€6 ÁtÞÁi:†Á]únÁRÿ<ÁH’rÁ>wxÁ4ÂÁ+Ü4Á#&zÁ0KÁ¢ÝÁ ÀÁxÁšãÀöÚýÀí»õÀæ$ÞÀßäÀÚØËÀ×nÀÔj@ÀÒúJÀÒÀÓ _ÀÔ–À×§(ÀÛ-èÀàëÀåraÀìÀô×Àþ¤Á¨FÁ ½0Áy ÁèÁ ÞŒÁ)p)Á2~SÁ;â^ÁFÁP3Á[¨Áf+×ÁqÊŽÁ}¾†Á„ÚyÁŠãÁÁ‘‹Á—}¹ÁþþÁ¤”ÉÁ«.9Á±Ù)Á½¦Á¶ÌÁ¯MÆÁ¨‡¯Á¡È£Á›"TÁ”™‰ÁެÁ‡²£Ák„ÁvPyÁjÁ^'ìÁRÍ(ÁGƒÁ<®ÿÁ2JµÁ(9¹ÁÐÁùÐÁ o‘ÁÄÞÀýáÀïËßÀä¦ÀÙ#ÛÀÏLaÀÇžEÀÀÒ À»ˆÛÀ·­òÀ´ëÉÀ³~IÀ³ñÀ³“@ÀµêÀ¸bÛÀ¼4áÀÁ\ÀÇ"ÀÎS§À×½ÀàùÌÀìZƒÀùF9Á…ÓÁ aÁ’AÁšmÁ%ÏlÁ/ÒšÁ:L©ÁDÓ4ÁOØÆÁ[{wÁgjjÁs^–ÁyˆÁ…ývÁŒk–Á’üÁ™”ýÁ 1&Á¦çjÁ­¹Á¹çÁ²)Á«8$Á¤YMÁ‘rÁ–ÍÉÁÁ‰‡…Áƒ“Áy"ÙÁl‡ÓÁ`ÖÁSŸ9ÁG»}Á\Áfõ…ÁYÅÎÁL¹Á?êÁ3džÁ' âÁÁ‘ÁcÎÀóŸÝÀÞó±ÀÌ^²ÀºdLÀ©”JÀ›ÊÀŒÄVÀ€ÇêÀk­`ÀXe‚ÀHݺÀ<æ±À2èûÀ-5ÎÀ*‰À(ä|À*™·À/•À5¹ÁÀ?GÀJÈ ÀX®ÀiiÚÀ~\ÀŠ™ À—ÃEÀ¦ÈËÀ¶­òÀÈgÍÀÚ¦ÀïWãÁgÃÁ @yÁÛÔÁ$ºrÁ0£€Á<ñDÁIÃðÁVò(Ád,!ÁqtÁ‹Á†hÁSšÁ”LÙÁ›WÓÁ¢yÁ®<çÁ¦÷¥ÁŸÃ†Á˜£¸Á‘›5ÁŠ©ûÁƒ½Áy UÁkÙûÁ^JÕÁPëâÁC»µÁ6}Á)¢:Á·ÁТÁÒIÀògwÀܪÀÇ žÀ²³ñÀ —^ÀŽÂíÀ~d©Àan×ÀGÆÈÀ0\¥ÀYÀ ˜j¿ýýB¿é$¨¿Ü«k¿Ö9 ¿Óò‡¿×€à¿á|Ä¿ï­Àà"À!—ÀÈ¢À.D ÀCûJÀ\ß/ÀxÃíÀ‹ð×À3¯À¯ÍÀÃ6ýÀØœWÀî0]Á«Á‰Á’AÁ&ÿdÁ3îÁAmÁNOgÁ[· ÁiqBÁwIÁ‚¡$Á‰¨HÁÆÁ—ø8ÁŸ3_Á«*Á£¸$Áœn[Á•(7ÁóÁ†Õ×Á¥ÊÁqÈ=ÁcîjÁVšÁH^GÁ:çbÁ-±»Á åÁfðÁÏBÀõ2 ÀÝ)nÀÅÏCÀ¯…ÿÀš­±À†éÀiøÀG„çÀ)ªjÀx¿ë÷6¿Àë:¿|¿‚¿¡¿Z^†¿>ÐŽ¿2K¿,8+¿4µ—¿I¨»¿iØ¿ˆòs¿£‹b¿Âì«¿è¬lÀ ‘À$§,ÀCÀcÿ!ÀƒøCÀ—lmÀ¬ˆµÀÁçÂÀØüÀðú=ÁˆÁ$!Á‚Á+9!Á8{xÁF¿ÁSë¾Áaë,ÁoôÁ~&ŽÁ†DxÁ{1Á”ºÏÁ›þoÁ§Ñ‚Á }šÁ™3uÁ‘éíÁŠ¢£Áƒ^1ÁxRdÁjÁ\#ëÁN@^Á@b±Á2‰ïÁ$ë¨Á§ÁÁ wëÀú—ÕÀá ÀÈÂ×À°®IÀ™XyÀƒIÀ]ˆÀ6mÞÀƒ ¿äü¿«˜e¿qf¿o—¾– b½‚f¢=éëC>e Ù>ŽÏ>>þ>Šìª>< "=9z̾¾«›€¿>¿jỿ¤Ì޿ܘâÀ  ÎÀ1¬NÀWµÖÀ€µDÀ•åmÀ¬ßwÀÄÕKÀÝÃÀö±wÁT²Á_mÁ"À’Á0¯Á>”ÁL›JÁZÁ°Ái!nÁw‹ùÁƒÁŠFûÁ‘žuÁ™Á¤éÒÁs Á– ßÁް'Á‡ežÁ€ Áq´6Ác/6ÁTÍÞÁFšæÁ8¦/Á*À÷ÁÜÁìÁžÀèè÷ÀΪÑÀ´Ð(ÀœS¡À„3%ÀZ={À.pÀ³è¿¾Œ¿rq³¾ïWå½!f>ª/„?%…?cÉb?‰U(?˜Ð}? ?¤ˆ?ŸÑ!?“r?€ƒ¸?Q Ø?§ > %Ó¼Ò±¾¾×;¼¿c}a¿¶Ð,À”®À)Ã¥ÀTQ‰À)À˜¾6À±2 ÀËàÀåÀÀÿGkÁ C•Á= Á)D-Á7]ðÁE¹íÁT$xÁb’½Áq ÁØdÁ‡VÓÁŽÃ©Á–2ÀÁ¢ANÁš»ðÁ“7Á‹·NÁ„F<ÁyͯÁk7DÁ\­iÁN#ŽÁ?¥qÁ1O¢Á#3Á(sÁC;Àò¿ÝÀ×Y£À½À¢ÊöÀˆì÷À`VÝÀ/sšÀ𳿬ÌU¿4eþ¾åø>ÇSR?W:?žì?ÉËÌ?ëïÌ@’@ vo@³4@\ë@ì@¬&?û;™?á¹?ÁM?šù¦?W õ>ÐsH½ÁLþ¿'¿¤ËÌ¿úTLÀ+¥ÀZ×À…ªŽÀŸ†À¹ŠeÀÔ|µÀðŽÁóÁüUÁ"RáÁ0¾Á?+ÁM»=Á\~gÁk_˜ÁzE¸Á„—ÆÁŒ!Á“–êÁŸ¤†Á˜tÁ°Á‰¤Á…“Át 'Áe&ÁVLzÁG¨èÁ9ÀÁ*’åÁ!fÁ ÑfÀÿ//ÀãUvÀdžÀ¬¡À‘4 ÀmÖ6À:'¼À¿¯6ã¿&ª<Ò?' @2%`@>ì7@HmÇ@MØ@N]g@KŠ˜@D©K@:–“@,‘/@ã‹@Žy?Úy?œüp?,KÝ=ƒŽd¿©¬¿§ÉÒÀCÀ4óÈÀgàvÀŽ Àª4áÀÅÊaÀᄃÀþÞÁ | ÁëÒÁ*}ñÁ9LuÁH:/ÁW(~ÁfÍÁu çÁ‚ šÁ‰–Á‘/\ÁTÂÁ•¬”ÁŽ¥Á†këÁ}¶ØÁn®4Á_­kÁP³hÁA½îÁ2ä÷Á$)öÁŒ"Á ÀñFÀÔ¦TÀ¸5Àœ|hÀ€ÓyÀKs[ÀEä¿Äó7¿C5Hº§(?8÷b?°¸¼@ @"ð@Ag@Y»œ@m1d@{_™@‚\÷@…¼@…÷ß@„=|@€…¬@uà~@g °@T—Í@=ÿ@!Ãé?ÿAi?²~§?>•h=F´ƒ¿4¿½»¡À»xÀH¦ÀÊUÀ›…§À¸±ÀÔ÷ÇÀñÔàÁ€oÁK Á%%›Á4 ÁBÿnÁQóœÁa|Áp(ÕÁLaÁ‡8²ÁŽÎ±Á› ŒÁ“sŽÁ‹Ê Á„"rÁxôˆÁi¦¼ÁZmÁKS Á½%D?—R«?üE‡@-å(@[VG@‚zÂ@•e@¤ïí@°Âc@¸Ýù@¾|@ÁU…@ÂUÿ@ÀÐ5@¼«#@¶Ç@¬ú°@¡‹º@“2@b:@Y„ê@,ê¿?ú_?•ì >©vë¿sò¿±"<À)ýÀKïàÀƒcÇÀ ûMÀ¾’ÒÀÜ*XÀùÄ?Á ÛµÁ ¹Á*N2Á9“fÁHØšÁXÁgupÁvÔAÁƒ?ÁŠÏÁ—(sÁdÖÁ‡§ÁÕ"Áp\žÁ`äËÁQu¥ÁB¹Á2ÔÁ#‘vÁQñÁkÀëÀxÀÍ®ÔÀ¯¢ýÀ‘¥wÀh!åÀ-V„¿åÃy¿fP-»Œ´?_D7?ÛæÂ@"RQ@UG?@úÞ@˜<@¬¶.@¾Ó0@̱O@Õ§ƒ@ÛŒ`@Þ‚Q@ày@Þ[X@Ù–B@Ñ÷Ñ@È—@ºÇ?@ª_s@–«@€o@Q@£½?ÏþJ?C!G½û¿N¿ö²3À6›tÀqÝÎÀ–}À´x+ÀÒ˜.ÀðÜ!Á¥ˆÁê)Á&0 Á5‰>ÁDèÁTFàÁc¥±Ás %ÁAÁ‰­Á•_ÓÁ˜ùÁ…ÓÁ|®Ál’]Á] ëÁM”?Á>¸Á.¡3Á0ÁÓÁðÀ⟬ÀÄ ¡À¥¡•À‡LèÀR‚ À—¿¶;\¿…y>ÒÒ2?§5@ 9‚@C¼W@xR @•zÝ@¬¨È@Âj·@ÖPC@æY_@ðõ@÷X¯@úÎ+@ûϾ@ùíb@õdÑ@íˆ@áÝ@Ò´¯@¿¶ä@©¹1@‘^t@o@9G8@bU?vë>gT-¿.?ß¿ÍæCÀ#´À_8GÀÂ|À«ý ÀÊ7šÀè–CÁ¦ÒÁ ¹Á"q`Á1×”ÁA?iÁP¸ÈÁ`EÁoÙêÁnÉÁ‡ÔÁ“¶ÆÁ‹ã6Á„[ÁxŠGÁhýAÁYrêÁIèšÁ:^IÁ*ÓøÁSÔÁ ÚLÀøÈ[ÀÚòÀ»GäÀœ·@À|dµÀ?ZêÀXe¿Œ ®¾#^p?E´è?Ù+Ï@' *@`2'@‹ãž@¦ÁÒ@¿ñT@ÖìV@ë©@ý¡ïA%ÍA¬A ¡ˆA ÙªA ÖœA¸ÙAHŸ@ù†ž@èo@Ò|¡@º)£@ŸË‹@„Œ%@Q@j¯?ºK}?8•¾Ë˜Å¿«oÀÙ–ÀN“À…ß…À¤‚·ÀÃL=ÀâÃÁw¤ÁàÁY½Á.ÚéÁ>hÊÁMý)Á]‘‰Ám%èÁ|¼“Á†+æÁ’(¹ÁŠU8Á‚‚€Áu`ÕÁe¼ðÁV ÁFu%Á6Ù Á'ItÁºsÁ+†Àñ?ÇÀÒ+yÀ³4AÀ”g1ÀkX5À-â¿á;Õ¿NiÀ>Ø ?‹.È@Äš@=ÍI@xYb@™P@µ‹#@дÐ@ê+ŸA:ÇA æóA¹`AÍ,A ïA(A*tAâÑAØXAŒ,@ùù@áÈw@ÇX @«ß@³†@eù@*I?ݰü?KQо!P¿°}ÀŽÀA„ÖÀäÀžTÁÀ½'ÀÜ ˜Àû!7Á ¤Áœ„Á,4œÁ;Ï/ÁKj¤Á[Áj¡ŽÁz?×Á„ôBÁº¦ÁˆÝjÁ1ÁrJEÁbœûÁRúyÁC[‹Á3¶sÁ$ŽÁn©ÁÊÄÀêR”ÀË1AÀ¬>ÀŒõ;À[³ËÀÇ„¿À£ù¿ H>ÔRÂ?¯;o@p@Q@†hÇ@¤&5@Áʘ@ÞZ@ù¾PA ެA!Aw-A vA"ÇA"½.A!ø(AßA!A] ¿i›ƒ¿ïÎmÀ5gŒÀs`^À˜ÒÑÀ·õrÀ×Àö:µÁ ®¬Á?üÁ)ÓÛÁ9lÂÁI>ÁX°1ÁhdÁx úÁƒï¦Á>”Á‡a$ÁÿÁo`Á_±ÁP/Á@LþÁ0•<Á éÁLåÁ»ˆÀä2gÀÄâÀ¥’´À†BÛÀMñóÀŸP¿£X˾ž¼Ð?'ôÆ?ÏV@%b@b2ƒ@Þ@­ßÌ@ËÉŒ@é|¼A5äA)îA²@A%n A*F)A- ÙA-rbA,ÔêA(A! ÊA´ A «v@ùE@Ü7=@¾]@ n@‚@FÜ©@ ¤ ?˜@¹>fð¿= p¿ÙÜ¥À+6Ài8À”8À³3|ÀÒd‰Àñ••ÁcQÁÿÁ'£?Á7VRÁGÁVÌ$Áf‹’ÁvJ‘ÁƒyÁßÁ…þÁ|;fÁl{ÂÁ\½‹ÁMÁ=GîÁ-˜ ÁéƒÁ;$ÀýýÀݾUÀ¾mãÀŸG À€$bÀAü,À\z¿‰yŽ½Ã¢’?_æë?ëÅ{@3¼Ò@q–ç@—Ÿ@¶Qr@Ôç¸@òñ An­A »A%BA.„ÌA3yëA6gúA6ÎFA4ñpA/A'ÒùA¨[AhAœˆ@ã­@Åy@¦Ÿ @ˆ|@R·2@í^?®G>Êͯ¿ ¿ÅÉ´À!FóÀ_©ßÀÀ®QvÀÍÕÀìÑ Á ÁÒ[Á%ŠªÁ5BùÁDûÁT¸GÁdw³Át7:ÁýÁŒœOÁ„³³Áy—®ÁiÊ$ÁYÿ@ÁJ9>Á:yúÁ*¼ÑÁ/Á JñÀ÷0ÄÀ×ÖßÀ¸À™+šÀs¬cÀ5 r¿í‚|¿`ç=É·N?‰CÔ@ (@A^¼@J=@žšß@½ @Üa`@ú÷A ÆhAÎÆA*zA5 ÂA:ÜA=ø!A>Á\A;TyA5ufA-ÈA!ÔßA+æAà@éÅX@ËLÀ@¬@šA@]jý@¡x?ÃÞ˜?,ª¾ÕÍæ¿²}HÀËÀVBôÀŠ_ÙÀ©»ŽÀÉ'ÓÀè‘BÁýYÁ²Á#fæÁ3#‹ÁBê€ÁR¶ÆÁbƒÁrOxÁ éÁ‹m¬Áƒ‡WÁwBÁgu^ÁW¨¶ÁGÙ¥Á8LÁ(6óÁe™Á”EÀñŽ ÀÒ ÚÀ²­À“TÿÀgùÙÀ)Iµ¿Õ6í¿/•>“´à?¡mÉ@ ˆ@M’@† À@¥s@Ãýö@âÞìAá2AYAŸºA.„A:;TA@¾ÄACâsADr%AA A;/ËA3QšA%‹¹AdGA5÷@ï¼O@ÐäÞ@² n@“5þ@hº½@*bý?Øx?6yо‡4&¿Ÿ ×ÀPìÀMlÀ…òöÀ¥X6ÀĽvÀä#LÁÏÄÁšÉÁ!h'Á15›ÁAÁPÐÁ`ôÁpkgÁ€mÁŠQ¥Á‚fäÁtùÁe%xÁURoÁEàÁ5­ÁÁ%ÝÍÁÀÁDÀìîßÀÍR¦À­¯óÀŽ AÀ\ã À ¿¾ï¿µg>ðæ¾?¹Î@¢7@Yô‘@Œm@«:‘@Êi\@éaA,WA•µA"áÑA1’\A=œ»AD½ÑAH‡4AH]ÉAE¯lA?íA7³eA(¬"Ao˜A o@õf@Ö˜#@·¥9@˜sÈ@rß@4-?ëOc?[{*½ýC„¿fÀ‡yÀDoÖÀ¬À¡ ¡ÀÀ­ÃÀàHjÀÿãÁ¾ÝÁŒ0Á/XûÁ?%WÁNñ³Á^¾ÁnŠŸÁ~YÁ‰<\ÁQ4ÁrÌ×Ábø,ÁS$šÁCQ‘Á3~ˆÁ#«ÁØwÁnÀèe ÀÈÀ„À©þÀ‰wxÀS¥ãÀ\׿ª1F¾¯ ?$Jð?Ï:@& @dâ<@‘Ö7@±"¦@Ðhú@ï‰A(÷A’ÔA%Ó0A4;[A@Ž«AGü¸AL.bAKÛDAI¯œACË&A:ŸÂA+}ªA._A Éj@ú¤@ÛŒî@¼Wz@"@{Ù"@=2^?ü”?}†‘;òާ¿y¼V¿ú®åÀ ‚Á¿Y9¿êèÀ4šÁÀsÁÀ™t!À¹×ÀØŸ€Àø63Á æsÁ±ÌÁ+ÙÁ;P¹ÁK!šÁZòzÁjÄ´Áz›„Á‡vÖÁ Áo.?Á_U2ÁO€Á? Á/¼šÁÙ1ÁõÈÁ_Àà]ìÀÀ™¡À êCÀX#ÀCy›À) ¿‰°ì½°üx?g"»?ò2‚@8e@wUr@›"ê@º˜\@Ú j@ùPOA –AXûA*?®A8ŒzADèŠAL¢~APĈAPéÄAO ÃAH;A>“íA0 A µ8AIðA¬g@ä‚@ÄÔ6@¥…\@†æ@MY.@tÔ?Ÿ ñ>…`ï¿9é¿ÛB À,ÇÇÀkóÄÀ••}Àµ1ÀÔÌ´ÀôhOÁ õÁІÁ)¡3Á9qtÁICÁY¸ÁhæÙÁx¹aÁ†ŸKÁ}[ÁÁmxìÁ]–ÁM³BÁ=ÐmÁ-í™Á âÁ,ƒÀü«[ÀÝ„À½W­À­ÖÀ|ÿÀ<´R¿úaË¿v <õ0¨?‚J½@BÒ@?`E@~}¹@žÍ–@¾2É@Ý\ì@üO"A nœAmèA+.ëA9[+AEÒçAN$wARWAR¤æAPÁÂAIÓ]A@ rA2ßA"A(šA‘S@çáF@ÈŸŸ@©Yp@‰ðú@U@Sr?¯.>õ©¿î÷¿ËÜaÀ% £ÀdSÀ‘© À±"ÀÀЪÀðJçÁ÷ÁȰÁ'šNÁ7lÁG>éÁWÁfèFÁv¿gÁ…ØZÁ{ТÁkð»Á\ÁL1“Á]î?ޝê@z @EH&@í‚@¡6ñ@ÀN»@ßÜ@ýb€A ˉA’øA+D·A9>ÍAEÂPAOˆASHASÞAR5AKëAA|¹A3˜A$3ÏAϘAmI@ë—C@ÌK@¬þÀ@°_@\Ãù@'5?¾~?Å'¾öão¿»ÔKÀº›À\À»dÀ­n¹ÀÍ"ÀìÕcÁ>„ÁCÁ%á³Á5´ÿÁEˆLÁU[˜Áe/EÁuÛÁ…5ÈÁz Áj³iÁZØ&ÁJüäÁ;!¡Á+F_ÁkÁ ÙÀ÷i.Àײ©À·íêÀ˜&ÍÀp¿aÀ1D:¿älè¿MÂe>5T?”hª@ y•@H9£@ƒ-8@¢(r@Àªæ@ß¡@ý{A qŒAóA*½ìA8¸ AEgdAOFÅAS«€AT½ŽAS0[AL>[ABÔA4ý¦A%¬bAFzAÀ@îd<@ÏHJ@°,W@éX@c)ø@$K?˱;?¿Á¾¿/ ¿®Q½ÀkÛÀU®ØÀŠxëÀªiÀÉ¿–Àéf/ÁˆJÁb,Á$>„Á4ìÁC÷SÁSÔ0Ác´ÜÁs™NÁ„Ï+Áy¼ÌÁiÛAÁYù¶ÁJ+Á:6 Á*UûÁw Á ˜ÀõrSÀÕ´rÀµö‘À–8°Àm¾À-ÂD¿Ýû ¿BTO>^“H?˜Îú@ åÅ@HRè@‚ÖŸ@¡Mx@¿†„@Ý€t@ûAÝA gêAÂA)°A7å]AD©AN³tAS^|ATý\AS™—ALü.AC†jA5ù"A&¨ÛAI©A×,@ðÇÅ@ѬÓ@²vÿ@“A,@h°@)be?Ôün?.h'¾šQ¿¤\¢À:ÀPNöÀ‡³0À§O^ÀÆø4Àæ¨}Á.ÃÁ ÕÁ"è{Á2ËhÁB²¤ÁRš¨Áb‚¾ÁrjÔÁ„Š7Áy1xÁiPXÁYobÁIŽ Á9® Á)ÍõÁî7Á ÀôagÀÔ§À´ú9À•pâÀl0CÀ-É®¿ÞÔH¿D*j>UNö?—hò@ 6~@F@dÁ@Ÿ\@½ió@Û&¬É?és@þÃ@AY@}­Ì@œŒ @º9÷@×ö@ôÇAøAW¶A%ŒùA3†;A@ AI®FAMÜàANñ–AO¹AJ8A@žMA5­A&R²AIDAÃ@ñ$¢@ÒA¿@³Kz@”@¾@j:@+Ý ?Ú@?9о‚ʼ¿žf»À)¬ÀMBÀÀ†C3À¥åÀņÚÀå(®Áe@Á62Á" cÁ1âìÁA½"ÁQšÅÁa{×Áq_ªÁ…ÀÁz%ÁjDÁZc"ÁJ‚KÁ:¤¢Á*ÌeÁû?Á 3™Àöò3À× ©À¸ZÀ™aÀs™zÀ5 2¿ìÿõ¿abJ=ì¥?‚¬±?üO¤@:!’@vƒ@˜?@µð›@Ól@ïì±Aa.AŸA"®;A/ì7A;ÁAC%ÀAG9’AHJˆAH€ADWdA; ®A0A#©A@äAK#@î5b@ωÅ@°Þ(@’æ@eÓ3@'€®?Ò\R?+Vã¾’¨¿¤tÅÀÂpÀOb½À‡5À¦²ÀÆc³Àæ‘ÁåýÁÀdÁ"šîÁ2u’ÁBPJÁR+ÁbäÁqàÁÁ…b_ÁzèôÁkÁ[A*ÁKwŸÁ;·LÁ,»Á]wÁ ÅHÀú]ôÀÛ1WÀ¼ºÀœØÀ{VÿÀ<ýÅ¿ýI¿³½ƒö?`´?èóp@03ð@k£‹@“FW@°s@ÍQõ@éìA6 A*AŽcA*sgA4–A;¿A>£xA?Å A?š A;гA3î©A)¥¼AÌ¥AØA´“@çÞü@ʬ@«µQ@[¬@]†@*’?£Ëßö¿yê¿ÄyÀ hþÀ^[ÀŽn€À­‘˜ÀÌ´±ÀëÚºÁÁ<˜Á$úÇÁ4¹ÁD‘ýÁTcxÁd4òÁtsÁ‡>>Á~ÆàÁoDÁ_[§ÁO¦ÅÁ?õ‰Á0QNÁ ¿Á6xÁ­ÛÀäJ÷ÀÅ;À¦,úÀ‡bÀRjÀj‹¿´ã)¾óÄî>ê\¥?¯`÷@Õ@K½ @‚vx@žÍÄ@» ¢@Ö«v@ñMA$‚ApØA¶A!ÈLA'‹/A*"ùA*¤zA*K”A'}A RŠAb¸A 4|AÜü@êö:@мÿ@µ´@™šG@ybL@?^Ü@3? >;ûp¿D–N¿Ýq+À,K”ÀiÞ“À“Ý(À²ÞÀÑ߉ÀðôAÁ—Á¹]Á'eÁ7îÁF¼ÁÁVh”ÁfqÁuÑAÁˆaOÁ€‡áÁqdÖÁaÅØÁR5oÁB¬ÍÁ3$,Á#žˆÁ$AÁ­Àêm”À˹À­uªÀBÀbíÛÀ&Ê,¿Õø¿BÛæ>$Ý?†·*?ú«@5R3@mŒ@’Èé@®jœ@Él@áóÔ@ù'Aô©A–AêÕAúòAsAêÒAÛúA¢÷AÅâA ¶5A¶@ñ4¥@Ù̪@Áf@¦þn@Œ*ø@a@(»©?Ýb!?Q뻽»M®¿„¿üoŽÀ:©ãÀwÀäÀškòÀ¹-À×Ú7ÀöÝBÁ ùwÁˆ Á* Á9§ÁID÷ÁXîºÁhšOÁxEäÁ‰žÏÁ×RÁt-ŠÁdµHÁU>ÁEÆæÁ6OºÁ&ØàÁgbÁ2ÀñÛžÀÓÙ_ÀµÙYÀ—ÚoÀtk[À:ì¿ÿ¤û¿‹¾c¾T"??-†³?Ç ·@í @S±/@…2ž@ŸrM@¸Ê}@Ð-@å%ì@÷iA™“A d)A7Av|A…ÔA¹,A Í`AçA @ðvš@Ü_s@ÆÔÒ@¯sk@–X@y?y@CòÈ@ ¿l?«•Î>ìZ¾ãð¿­XÀ¤ÀLæ‚À„C™À¢eqÀÀæoÀßvÁÀþÁ[ÎÁÁ[Á-<¨Á<¾PÁLDèÁ[ÏbÁk\ôÁzì'Á‹<Áƒƒ›Áw—:Áh(|ÁXºUÁIOòÁ9ù,Á*¿!Á©kÁ ¨ÕÀûPÀÝ[“À¿ºDÀ¢ŠaÀ…\ÀPÁPÀ•«¿½å/¿'ð>’B-?’§@"Ô@6ex@kgé@Ždð@¦ §@»b@ÎNL@ÞÚ=@í^s@ù½ÛAd¥AŒÏAKâA:\@üü½@ôeJ@è‘@Ù@Æ9Ê@±À@›»@„(ü@W û@#ïÁ?ÝÑÖ?e¶<ÿÈe¿X¿Üç4À'­eÀb~üÀŽà´À¬‚ÀÊ$!Àçù×Á"ãÁe_Á!´¥Á1™Á@\NÁOÉ™Á_EÁnÁ$Á~=*Á‰Á…_ZÁ{bóÁlÁ\Ç“ÁM•mÁ>‚:Á/¢Á …åÁŸ§ÁÈUÀèS°ÀË8À®DZÀ‘ˆsÀiàZÀ1™á¿òö¿ƒëž¾.Ç,?/è?¬»@Y<@GÁ@v2@´‚@¤KÄ@µŸ@ÄÓ&@Ò`è@ݹ¸@æqD@ꔢ@é9Ÿ@å@ßÄt@ØS@ÍûŒ@¿ö§@®ô½@›Nq@†¬A@`v—@1U @‘?š•L>Ç“”¾àÐp¿¤õ™À ÀB£4Àz¾¶À™ìÍÀ·UQÀÔóÀò•Á Á SÁ&&ŒÁ5T!ÁDƒ'ÁS½˜ÁcÓÁra«Á€é.ÁôÁ‡mÍÁ˜ÖÁplzÁa[ÁR^£ÁCw@Á4‘„Á%¶_Á$Á‘Àô/qÀ×JTÀºÛÏÀžÉÀ‚¶ˆÀMzãÀOÑ¿¾g&¿&}â>2ó¼?|³…?áP@BÞ@K÷@r÷£@‹âò@›Ü@ªQ@·f@Á‹s@Él3@Í x@Ëp.@ÇM¶@Â!C@»+@²–@¥¿Ú@–!@„„@` ›@5S¾@²?³Jÿ?"µ‘¾ÉB¿wj³¿å À'i"À_~À‹ŸÚÀ§°uÀÄqÀàÁ{ÀýæÁ ™šÁW?Á+&OÁ:âÁI.£ÁX[\ÁgˆòÁv¶ Á‚ômÁ‘6¿Á‰¤Á‚…ÁuRÜÁfpÉÁWEÁH»Á:äÁ+špÁ"ÍÁ¬šÁrÀäÎïÀȹ#À¬£ÂÀ‘ÉÀk]îÀ5 õ¿þÖ¯¿•ï̾¿¼>Ìx~?3?èa@õ@B†@d6@Ç+@'R@š÷Ä@¤³8@¬@®ùê@­d‹@©TF@¤bo@´8@•F@ŠŠ…@xK@Vàm@1@ t?ºñ?B¹%<¹A¿=,¬¿Â¤ÀÎÀI˜eÀ~rÀšLCÀµñ÷ÀÒŽÀîHÁr ÁλÁ"^vÁ0ðÐÁ?ŸÁNJúÁ]1Ál<Á{d•Á…KÁ“ª>ÁŒ9>Á„̼ÁzÂÝÁkø&Á]VXÁNÕ1Á@_ Á1ëµÁ#¬2ÁRÁ,Àòè¬À×=€À»Þ®À ¿À…ÀÀUÔüÀ"p9¿ß£X¿z"‹¾¶l>äÑþ?‹J©?Ù;¦@hð@/ò³@LÔ@fô@}$Ð@‡±@Žš@ÆÎ@m@‹9‹@†i@€Å@pI@[Ó¡@B-4@#`:@_“?²ìL?@ýÍ=”ê7¿ ‡¿®ùúÀ¦MÀ9buÀlnâÀVùÀªÂÙÀÅÉ•ÀàërÀükÎÁ GÁ’BÁ(á_Á7=fÁEʃÁT\±ÁbïiÁqžïÁ€;]Á‡¸Á–s¶Á Á‡¬¡Á€XTÁriÁcœÉÁU,ÏÁFîŸÁ8ÎÀÁ*®áÁšåÁÊ ÁjÀæ¾3ÀË—ÒÀ°ë¥À–ËüÀzÁÀGÀÁÀ€¿Ð_‘¿oCá¾ø°>®»Ò?k%?·àŽ?õ±â@S³@.*@C£n@Tªf@`:«@d¿)@a´@Z+@PÖM@D”{@5<@!®3@ =T?Ýú?š5?#¨<æ¤C¿"Z5¿¨ ÀGËÀ0l5À`8žÀˆà+À¢m…À¼ÿÀÖM"ÀñH]Á4 ÁÅnÁ!öÁ/³hÁ=ÿ‡ÁLN=ÁZ®@Ái;wÁwÎ*Áƒ2òÁŠˆ4Á™dxÁ’ Áй4Áƒp€ÁxoBÁj1Á\àÁMö)Á?ß,Á1ú Á$DóÁiÁá/À÷³ÀÜÈqÀ·MÀ¨èÎÀÆÀo±oÀ@ßâÀN¿Ó¤¿‚þò¾Ù”Ÿ=éÜ?ý?ˆpA?¼Ø‘?ëÛ@ yt@5-@#S @'NŸ@$ìù@Š@e5@Ô|?óˆš?Ï?¤sI?\ÇR>Æ¢Ÿ¾Ò¿<\L¿¬ÝYÀlŽÀ,¿rÀZŽ[À„­¶Àœ˜íÀµ–ÀΣ˜ÀèL.ÁLÁ`6Áî¬Á)}YÁ7#»ÁE tÁS,ñÁak®ÁoºHÁ~ÖÁ†VÈÁ¡ÁœjNÁ•©Áä&Á†ÁÁg€ÁqTtÁcA’ÁULÚÁG~íÁ9ÉcÁ,úÁ§“Áz¶ÁRÛÀî¢ÀÔþwÀ¼_À¤+\ÀŒó_ÀlË5ÀBDÀØv¿äÁ-¿Ý°¿3÷ξuo>Qñ)?ý³?qË?œ??¹­ì?Ì5{?ÓXT?Ï)?ÁÃ?¯N:?˜¨Ö?wƒn?3•>½º5¼`=2¾äÐd¿w5¿ÁµçÀˆÝÀ/¾iÀZ’sÀ‚ÕçÀ™êyÀ±+ÀÉ(ÀáR–ÀúÔŸÁ –,ñ?âû?#.œ?0?(òZ?š˜>Ö.\>xö¯<ËEJ¾píé¿ k¿cÊt¿©Ô¿æjÀoÀ90À_ûHÀ„‡À™í9À¯¨-ÀƲÀÝâ’ÀõÆ ÁíåÁñÁ PzÁ-,uÁ:EÁGuÁTíÁb¾Áp@„Á~-æÁ†ZÁlÁ”,KÁ£’Áœ”Á•¼ÁŽ5Á‡ÒÁ€%þÁr’Áe8ÁW±ÁJl$Á=O5Á01Á#NœÁäÁ —~ÀüìÀæÄÀÏgRÀ¹k À¤ÐbÀûuÀ|¨HÀY À8YÀÔ‚¿û¸N¿ÇÂZ¿š5P¿f¿"Q3¾á(ܾ¥Ýí¾Ž‰x¾™{¾Ì^_¿ ð¿4í%¿jÏ¿•ä]¿»ï¿æ¡&À {†À(÷†ÀI~ÀkÞ¯ÀˆÂŠÀœ‚&À±.ûÀÆ”=ÀÜ™wÀóŽÁ]‹ÁKÜÁLÄÁ)¶ßÁ6e#ÁCA¸ÁPXÁ]€kÁjÄÁx5ÃÁ‚óÁ‰â ÁÞÁ—Ú±Á¦·åÁŸ¶žÁ˜Æ1Á‘ÖôÁŠïÁ„%`Ázç˜Ám†µÁ`U[ÁS<³ÁF,¤Á9p9Á-;Á ØnÁɨÁ Y5Àü hÀå÷FÀÑ.OÀ½À©÷¾À—úàÀ‡DEÀnÝ•ÀQ4pÀ6(À×]ÀxÊ¿élf¿Ê¢®¿²¢¿¤†E¿Ÿ{á¿¢J¿­ü|¿¾ë–¿Ô>'¿îš)ÀØëÀoSÀ-þÆÀD³XÀ`ÊÀZSÀüÀ¢àÀ´ð®ÀÉ)CÀÝÖßÀóbÕÁÆÁ4òÁÊcÁ'µÂÁ3»»Á@·ÁL‰ÁYVüÁfkÁs“XÁ€^îÁ‡gÁËŒÁ”°ÆÁ›ª Áª{ÆÁ£ŽšÁœ£'Á•Ì ÁÁˆ`Á´ ÁvOƒÁiCeÁ\H…ÁO«¥ÁCgúÁ7-xÁ+/ŒÁªAÁY®Á XqÀýŒ;ÀégÜÀÕÔ-ÀÃìÀ²fÜÀ¢9"À’ínÀ„mlÀnØLÀW8’ÀB€€À/îjÀ"94À¡üÀʇÀ í©ÀBÀ­ÐÀÊåÀ'/À4,ÀC/ñÀTd‰Àh¬À~‡]ÀŒ§ÜÀšÜÊÀ« SÀ»´²ÀÎX ÀáK¶ÀõÑtÁAÁ$ùÁ?ßÁ&¥GÁ27‚Á>¨ÁJ.|ÁVc²ÁbÍzÁow[Á|~Á„Ó+Á‹gPÁ‘ÿnÁ˜´7ÁŸ‡ŒÁ®`•Á§˜Á ¸àÁšQÁ“R}ÁŒ´hÁ†0-Á_¶Ár|äÁeúÏÁY¿TÁM‡žÁA™ÉÁ5ý,Á*µRÁ½ûÁúŽÁ ØœÁùdÀï@ûÀÝÂ,ÀÍAÀ½rVÀ®³À ³)À”KÀˆÜKÀ}ËpÀl}÷À_ ÅÀTT ÀM‚œÀL!7ÀM{ÀRªÜÀZ<ŽÀdf3ÀqÀ½4ÀˆwÃÀ‘ ÀœwáÀ¨óìÀ¶ý,ÀÆ šÀÖydÀçï¶Àú­uÁùAÁGÆÁ¨Á&˜ÖÁ1¹ÅÁ= ÁH¤ÑÁTŠÝÁ`¡=ÁlÎöÁy§Á‚ÖÍÁ‰K3ÁݱÁ–q®Á´Á£ªõÁ²jqÁ«°áÁ¤ý,ÁžOiÁ—¿ðÁ‘@ÀÁŠÂ½Á„`×Á|TÁpÁcèÔÁX3ÁLWÁARÁ6#“Á+DÁ ýßÁ!hÁ ‚DÁ²ŒÀøM®ÀèEÃÀÙ—ÀÊ™ÏÀ½e”À±CÑÀ¦.sÀœÍÛÀ”¯]ÀŽÈÀ‰-À†À…PÀ…§äÀˆU-À‹ðOÀøƒÀ–íúÀžLyÀ¦ÀSÀ¯€ÕÀ¹Ç ÀŲ«ÀÓBÒÀá¨Àñ†KÁÑÁ # Á†~Á^šÁ'¯`Á2€Á= ³ÁH3ªÁS•ÿÁ_GÁjø^ÁwþÁŸ‘Á‡¾iÁúRÁ”aÁšì@Á¡áÁ¨Á¶¬gÁ¯ø°Á©V´Á¢Ñ¥ÁœR·Á•ÛnÁ‡ÒÁ‰VæÁƒ7mÁzOoÁnsnÁb·ðÁWxRÁL‰*ÁA·Á72‹Á-WiÁ#•”ÁލÁÈnÁ ¦ÜÁ»rÀôü’ÀæíZÀÚÿÀΊøÀÃâ‚Àº×µÀ³¿À¬®=À¨5ËÀ¥Z|À¤¼À¥ =À§U‹ÀªÝÀÀ¯Ê‹Àµ|ÞÀ¼¼%ÀÄ÷²ÀͯÀ×¶Àâ‚âÀïŽàÀý¸EÁNdÁˆ:Á¹Á NfÁ)ÍáÁ3ÆzÁ>nÁHœœÁSŒÁ^­ÁjäÁu…Á€³ÊÁ†Ã_ÁŒ×¨Á’ò€Á™$iÁŸ3Á¥þaÁ¬‘oÁºù4Á´cpÁ­ã‘Á§dÐÁ ù‚Áš²[Á”ƒ÷ÁŽcPÁˆ]Á‚pTÁy#ÏÁmàYÁbðóÁXšÁM~mÁC—ÆÁ9ÊçÁ0‰'Á'¤ƒÁ5ÿÁ1ÜÁ¯«Á‹€ÁÊ;ÀööNÀì Àá®ÀØþÀÑ”ZÀËzÇÀÇ>®ÀÄ´ˆÀÃÑuÀÄwÕÀÆaÞÀÉ÷ðÀΣvÀÔ-CÀÛWjÀã,SÀëäsÀôøRÀÿ€¥Á#TÁ ó)Á$‹ÁØÁ$a–Á-tÁ6†Á@)ÁJ.ˆÁT„ìÁ_^ÁiúÁu(<Á€EÁÁ…ÿÊÁ‹ìhÁ‘ü¿Á˜¾Áž* Á¤SºÁª£çÁ±OÁ¿t/Á¸õzÁ²zÐÁ¬ïÁ¥ßmÁŸ±*Á™ÉÁ““œÁ§`Á‡Ì7Á‚(ÁyZÁnsÁcÛÁYßDÁPùÁF˜ÐÁ= Á4áÊÁ,ÑÁ$ïÁ¼âÁ¤¸ÁÏÁ /]ÁËðÀÿµuÀ÷$ÍÀðB Àêz:ÀæLÀä“Àã.ÀãænÀå¬ÀéLÀí‹]ÀòýQÀú ÇÁ¿ðÁ Á ’ªÁbSÁ‡ÁGÁ":àÁ)—ðÁ1Õ1Á:>ÇÁCFÁLÅšÁVr'Á`––Ájü'Áu£?Á€:þÁ…Ô/Á‹†jÁ‘@Á—( Á6 Á£GÿÁ©b6Á¯‡EÁµÍÛÁÄÁ½•íÁ·AéÁ± ÔÁªÞyÁ¤ÀÜÁžÊ:Á˜á6Á“ æÁb<Á‡áÁ‚q ÁzCÖÁp(åÁf\•Á\¼éÁS®4ÁJÀÁÁBvƒÁ:u[Á2õ/Á+ÊÁ$ðfÁŒÁ÷ÙÁ’\ÁîýÁ »UÁ}nÁÉ”Á±hÁ´OÁ,+Á©>Át Á fÁ<ƒÁñÁ WŽÁü}Á@”Á¬™ÁFVÁ"î<Á)rÁ0TTÁ7†qÁ?J½ÁG®ŽÁP7/ÁYxÁcÁlÌ ÁvþðÁ€½JÁ†ûÁ‹{½Á‘ÅÁ–ÉiÁœ‚ˆÁ¢f³Á¨o€Á®Á´šLÁº¾HÁȶ¶ÁÂkCÁ¼:oÁ¶ eÁ¯ô–Áª¡Á¤¢ÁžJ Á˜ž'Á“Á©ÁˆZ×Áƒ<¦Á|¦2ÁròmÁi¿\Á`Å^ÁX*vÁP•ÁHM@ÁAÁ9ÛlÁ3M^Á-7´Á'ÄøÁ"t'ÁêÁÁçˆÁ[×ÁQ§ÁdÒÁÞ²ÁUüÁ'Á·AÁ¾'Áh˜Á£³ÁKPÁ#ršÁ'ÒFÁ,]-Á1ŠGÁ7ßoÁ>}ÏÁE¨AÁLÿvÁU&ZÁ]ŠÁfKJÁo½tÁybƒÁ”æÁ†¶÷Á‹ÿ&Á‘V©Á–¾ÑÁœ[TÁ¢AÁ§ÆëÁ­§•Á³ªÁ¹ºrÁ¿ÒgÁ͘ÄÁÇj?ÁÁ=ÑÁ»+ÀÁµ<ðÁ¯WÁ©‹GÁ£ÛxÁžKhÁ˜á“Á“•~ÁŽiüÁ‰wçÁ„š.ÁÑÅÁvÖ&Án~Áe»ýÁ]ÖêÁVE‹ÁO áÁHœÁAÒÛÁ<ÊÁ6’TÁ1‡>Á-EÄÁ){.Á&[ÒÁ#òÁ".Á!…Á  4Á!ºÁ!Ú.Á#NÁ%M³Á'è}Á*óÁ.¤ˆÁ2¤¡Á7.Á;‹,Á@^þÁFQ+ÁLâUÁSÐÁ[åÁb²ÁkkÁsvLÁ|xEÁƒäÁ‡Ø|ÁŒÅKÁ‘òEÁ—A¤Áœ™‡Á¢½Á§¡FÁ­TJÁ³ ÎÁ¸êXÁ¾ç:ÁÄóÒÁÜòüÁÖ²þÁÐ}‘ÁÊfHÁÄrÁ¾£õÁ¸ö6Á³S×Á­ÆxÁ¨i¡Á£BÑÁž5ŸÁ™B6Á”’€Á&ëÁ‹ÊrÁ‡¥1ÁƒÌhÁ€ ÕÁy9\ÁrŸ…Ál­;ÁfçDÁaÐTÁ]€ÁY'ÅÁU&ÁR’)ÁPÁNBÁLY¥ÁKk—ÁJÈÁJ™‹ÁJ¿&ÁKx2ÁL›YÁNBmÁP(ÁR€:ÁUâÁXièÁ\$\Á`^ÁeL;ÁjÊ ÁpŸgÁw2Á}ÛåÁ‚—ÿÁ†‚ˆÁŠÁŽèoÁ“] Á—ù2ÁœÖHÁ¡òÁ§/TÁ¬p#Á±Õ»Á·fñÁ½$ÑÁà tÁÉ%ÁÎþZÁØîÁÑË[ÁˈÁÅLÂÁ¿/çÁ¹7àÁ³hZÁ­½áÁ¨¹Á¢—jÁB\Á˜9Á“èÁŽ0Á‰–ÝÁ…5¹Á€äÁyÈôÁr,òÁkâÁd;UÁ^öÁX^Á<¡.Á;ªÅÁ;Á:ÑøÁ;BÁ;´Á<øœÁ>¡dÁ@ZÁC òÁEÃÁIDWÁMŠÁQ¥ÁV"Á\?ÉÁb=õÁhì¨ÁoÜpÁwˆ=Á€EÁƒøîÁˆlÁŒûïÁ‘Ä¢Á–ÒÁœ ÊÁ¡KÁ¦¦¼Á¬5TÁ±ó˜Á·ÜËÁ½×÷ÁÃÓ-ÁÉà¡ÁÓeCÁÌõ÷ÁÆ£ÁÁÀ`AÁºÂÁ³üÄÁ®ŒÁ¨/=Á¢ˆÁœéßÁ—içÁ’/ÁŒû¢Á‡õOÁƒ(nÁ}J×Át‰ ÁlWÁdZ©Á\ëDÁUù”ÁO‡iÁI¤ÒÁDêÁ?ˆÁ:¦–Á6ÝÁ3;Á0ÍÕÁ.©ÆÁ,èºÁ+éòÁ+EÇÁ+ pÁ+JÁ+ùËÁ-VvÁ/§Á1+¶Á3šKÁ6’ÍÁ:!VÁ>9&ÁB¿ÁGû÷ÁM¶øÁT :ÁZÆ¢Áb:Áj}Ár'2Ázõ:Á‚Á†¸Á‹µÁìÁ–)Á›|…Á¡Á¦Æ‘Á¬²BÁ²¬ÉÁ¸¨ Á¾¹-ÁÄí@ÁÎÍ®ÁÈN*ÁÁ׌Á»|ãÁµ8§Á®÷EÁ¨Í…Á¢Ì­ÁœùtÁ—RøÁ‘µ¶ÁŒ>HÁ†øÁØ Áy½YÁpZ³ÁgiÁ^«¯ÁV‹NÁOlÁGÍ_ÁA aÁ;%Á5G2Á0%‡Á+ldÁ'—ÀÁ$ VÁ!KZÁõäÁ0GÁ)?Á‡ÇÁEÇÁ”(ÁJ¨Á·ÁbŒÁ!»šÁ$6mÁ'eJÁ+ ¯Á/UúÁ3þÀÁ9ƒüÁ?W-ÁEñÁLÐýÁTˆfÁ\,Áe¥Án*BÁwc¤Á€šÇÁ…Ê@Á‹yÁX>Á•ßïÁ›ž¤Á¡‹Á§ƒaÁ­}²Á³“†Á¹Î†ÁÀ+ÁÊX»ÁÃÁ Á½7‘Á¶¼#Á°XÁª Á£ÑÁ¢ÿÁ—Á‘ÇÅÁŒÛÁ†‚jÁ Áw¥¨Ámi Ác¢ÁZz4ÁQ‡FÁHêNÁA(ÊÁ9Û;Á2»WÁ,}xÁ&—eÁ!LÁS^ÁMÞÁ­îÁÑSÁM¦Á w×Á lÖÁ ÉÆÁ †×Á ÝÂÁ ¦Á!]ÁÕnÁK}Áì Á>ëÁãÁ rÍÁ%n)Á+jÁ1:Á7ã­Á?-FÁG ÁOFÿÁXF\ÁagÈÁk hÁuP÷ÁÖÁ…;cÁоbÁ|þÁ–i×Áœ^aÁ¢WµÁ¨s_Á®¶)ÁµÁ»¡^ÁƪÁ¿UáÁ¸»NÁ²&ÐÁ«¤Á¥5´ÁžérÁ˜«_Á’~DÁŒrÁ†›Á€é€Áv nÁkÝŠÁa[MÁW*ÏÁMžÁD›7Á;¦ÏÁ3\Á+øEÁ$±¢ÁôÁÁr•Á ^öÁ ËÁXkÁWOÀÿv Àû~ÔÀùiŒÀøŠÀ÷˜ÀøN¸Àú­Àý ÁcaÁÛaÁºäÁ êÁ ÁšiÁí·Á¯¨Á#2›Á* ìÁ1¿ŒÁ9®SÁBpaÁK´ÁTè¨Á_Ái£‰ÁtOáÁJÁ…b¦Á‹NIÁ‘>ËÁ—8ÁZÁ£¥wÁªÁ°¥óÁ·AOÁÁÏ”Á» Á´TõÁ­¶QÁ§fÁ Ž×ÁšXÁ“ÁØÁ†LÁ‡] ÁNÉÁvåÒÁkoUÁ`>ãÁU“@ÁKõÁ@þQÁ7¸zÁ.¹óÁ%êrÁÆÁÊ™Á¬¾Á †ÈÁ¨1Àüü¦ÀóÒ¦ÀìÕÀåºóÀàwRÀÜ`ÀÙûgÀØ¢fÀØ"hÀØáìÀÚÄÛÀÝî†Àâ õÀæåÀí‰ÀôÀü] ÁùðÁy‹ÁŽÁ+âÁŒ Á$VƒÁ, Á5°Á>áÄÁHßüÁS{ÜÁ^5ßÁiåÁt”\Á€5îÁ†%=ÁŒ Á’I;Á˜žÁŸsÁ¥²Á¬OqÁ²ðNÁ½Ê Á¶ã×Á°JÁ©VXÁ¢±TÁœiÁ•äÁŽû™Áˆ›Á‚bÁx}3ÁlaµÁ`Ÿ¥ÁU]ÁIâßÁ?IìÁ4ÑóÁ*ï$Á!Ó|ÁÖ(ÁjÓÁâÞÁ­îÀö+hÀê/nÀßIIÀÕÌrÀÍc‹ÀÆò¶ÀÁyùÀ¼¼ Àº¬¯À¹VÌÀ¸¬ÓÀ¹u÷À»‹îÀ¾Ü{ÀÃ^üÀÈDjÀκíÀÖ ÀÞ‰ËÀèìÀôOÁzâÁ`³Á"¶Á0¯Á /Á)ƒÁ2ÌÁ=`pÁHHÁR÷5Á^coÁj;'ÁvÁôÁ‡BáÁ¢;Á”)aÁšÄÁ¡aÁ¨ fÁ®ÒQÁ¹ßÁ²ñÁ¬/Á¥" ÁžZ…Á—­TÁ‘lÁŠ|Áƒé»Ázø”Án}nÁbCSÁV&ëÁJaÙÁ>¾÷Á3—Á)Á®ŽÁ Á ì Á%Àö,Àçq–ÀÙ‡ûÀÍQÉÀÁÏçÀ·Æ>À¯ ûÀ¨GÀ¢| À¯…À›•‰Àš xÀ™FµÀš#áÀœ_=ÀŸàLÀ¤¬±À©ãQÀ°ƒžÀ¸N3ÀÁ³ÀËäMÀ×˽Àäè@ÀóßÁÁÁOÁ pÁ\ÉÁà^Á'P5Á2±Á<ÐzÁH2†ÁT WÁ`ÏÁlÅÁx’‹Á‚´¾Á‰=tÁÕºÁ–tºÁ-kÁ¤ÁªìÌÁ¶`Á¯pÁ¨ŠÁ¡,kÁš>õÁ“eÂÁŒ«°Á†oÁ~ðºÁqÆÜÁdÍGÁX;ÁL ¸Á?ìÉÁ4$FÁ(~²ÁceÁóvÁ¨¦ÀþU7ÀìÒÀÛLpÀË™&À½ŠŠÀ°tIÀ¤~üÀ™ÍËÀ‘ÒÀ‰·ªÀƒ‹xÀ}éšÀyâÀuÔHÀtyÀu¼ÈÀzjGÀ€äÀ…ù:À‹¿À’gÀšºÀ¤=dÀ®è+À»¢IÀÉxÿÀÙNÀé¬ Àû“áÁ!`Áa×Á÷Á&® Á2SÁ=óÆÁIôVÁVÁb®„ÁožxÁ|¥{Á„ç^Á‹ŽêÁ’WçÁ™=8Á 3WÁ§5ÎÁ²dÁ«JªÁ¤DEÁO’Á–\öÁj‹ÁˆÝÁ³mÁv×ÁhïpÁ[ÌnÁN»hÁB xÁ5ÔÁ)³Áæ´ÁY7ÁRlÀùº~ÀåfÀÒ£wÀÀËÖÀ°P&À¡™êÀ“»åÀ‡vXÀx»ÀfwÀViÆÀI«>À@Ž`À; LÀ7gŸÀ5¨•À74ÑÀ<>ƒÀCÖ¤ÀN‹ˆÀ[9ÔÀiy“ÀzN£À‡n€À’ÉÕÀŸ>À®ŸþÀ¾ƒÌÀÐqÅÀâßZÀ÷,Á œÁªµÁø¸Á'á°Á3áÞÁ@áÁLØ ÁYÓ­ÁfÓ)Ás÷·Á€³{Á‡ŽÅÁކÆÁ•Š@ÁœŽFÁ£¡´Á¯(Á§ÌñÁ ¤$Á™‰½Á’„`Á‹´Á„žÁ{YPÁm—\Á`!eÁR÷˜ÁEÛWÁ8ÅÁ+ý8Áª Á{’Á­öÀøŠóÀ⟥ÀÍŽÀ¹ª”À§kÀ•öXÀ…¿šÀoiÀU9-À>šÀ*NÀd8À ò%À3&¿ù¸¿ñõî¿îô:¿ò§î¿ü¯]ÀV™À$œÀõmÀ.\¯À@×ÀUƒ¸Àn³À„±—À“ݲÀ¥O©À·ž®ÀËr´ÀàCÇÀõ“æÁÁã÷ÁÐwÁ*+ùÁ7 ëÁDáÁQ–Á^DÒÁkÚ Áy¹­ÁƒÞ²ÁŠâOÁ‘ðŽÁ™xÁ K:Á«ÀÁ¤{‘Á<¥Á– ˆÁŽä¤Á‡ÈÐÁ€ÄÄÁs¤ÁeÆDÁWñèÁJPGÁ=‰Á/ëiÁ"ÓÁ ˆÁ ¥¤Àú«»Àã¤ÀÌdÀ¶šsÀ¡d´ÀŽÀw‚ÖÀVckÀ7­À_vÀ[f¿Ýr\¿¹Æ#¿ ‘¿‹ ¿z»M¿jIõ¿eæ„¿nìH¿‚—C¿“;¿¨{ô¿Åb¿æ”À˜ŠÀWKÀ6²TÀT„ÀtïîÀŒ|`ÀŸâ À´pVÀÉàªÀà¢jÀøØÁà ÁVWÁ!B Á.=ùÁ;XÈÁHÆqÁV†ûÁds$Árn‹Á€@*Á‡cÁŽ—Á•Í;ÁÑÁ¨•òÁ¡BÝÁ™ø:Á’³kÁ‹x”Á„MjÁzJôÁlÇÁ^ÎÁP5«ÁB^"Á4«?Á'9•ÁüzÁ áÌÁ ÀçfeÀη¢À· çÀ >+ÀŠ•AÀkMmÀEbyÀ!ÈœÀU¿Èga¿”<¿Oe§¿\6¾ž*¾—«¼ž«=OÏ=ˆH<î齉Ï|¾Ts2¾Æ@í¿RÑ¿`ž6¿šñ=¿ËìÀ­ýÀ l{ÀCÕPÀhÜÝÀˆÊ¼ÀžDåÀµ!.ÀÌw"ÀäY“ÀýLBÁ wHÁ|ùÁ%Ù‘Á3‰¹ÁAV,ÁO4]Á]21ÁkoÁyÙ'Á„#Á‹\“Á’¦ÍÁšÁ¥¯úÁžA½Á–ßãÁ…Áˆ3Á€ìÁsm.Áe˜ÁVÎöÁH™4Á:¥Á,ÍÁÝÁ„_Á1Àíã?ÀÔ`£À»Š~À¢ÓÀ‹E‡Àh?øÀ=Ú´ÀØR¿ÝDL¿˜¼=¿2«¾Šiw=µ9>ɘ ?!è/?Pi¿?n?€oZ?ƒŸø?|e‰?bº¦?;ðÜ? 7º>—Ò­<'Ö⾩r¿:éO¿™Ô4¿Þ—oÀ dÀ;[Àe¥À‰¡QÀ ÖnÀ¹@¬ÀÒÀëhNÁî,Á›èÁf¨Á,0ñÁ::ÁH?äÁV§ÇÁeÿÁsˆ«ÁÁˆn(ÁÞÁ—TìÁ¢û“Á›€¢Á”ÆÁŒ“Á…0 Á{žúÁlè Á^QÁOîÉÁA¦:Á3_—Á%):Á<Á s­À÷˵ÀÜå_ÀÂUYÀ¨”ËÀ³nÀmÝcÀ?‚À\3¿Î_ý¿zxA¾Æç>Œ3?¼4?{ [?§Çë?È6Ý?ߨg?ïšÑ?ú¨?þ"×?øƒ?ëWž?ÖB?ºÇö?™Õ?d?Y=´[¾Õïпyö¿ÍÔÀ2½À<¯EÀj¾8ÀŽ1À§˜ÀÀnrÀÛa¨ÀöèÆÁ =uÁ$Á%<äÁ3§]ÁBêÁP†YÁ_+ÁmßGÁ|³¢Á…Ê{Á@dÁ”·ŒÁ ]ÑÁ˜ÔaÁ‘TÁ‰×ÑÁ‚\ßÁu̧ÁgäÁX?·ÁI€ÃÁ:ãPÁ,‚Á7XÁðªÁ¹uÀç´¶ÀÌÀ±}üÀ–ÝkÀzBQÀHXÀ?¿Ð<à¿k?ð¾†x£>¹ù?n^¦?·¿ñ?î 6@ …H@`p@+•©@3Øê@8ë@:}É@80@2@&ò[@hb@ ¦?áT£?­V¢?b E>³f¾Ìå¿lùH¿Î´ ÀuÑÀFø’ÀxÎOÀ–wnÀ±]LÀÌ™&Àè/°Á=‡Á­/Á®Á-èÁ¢Áq]ÁpkrÁaj#ÁRt›ÁC¡±Á4äØÁ&1¦Á Á /âÀõ¸ìÀÙCÀ¼¨jÀ¡VOÀ†CÐÀVÕ¤À#™V¿á¹»¿~y"¾Ê¡>ݲÞ?Š"à?Ø @›p@-Ð@Eì@XkS@f1ý@oq@t‹+@v<ü@sœ@l2´@`›ï@Q Ó@>'@&g…@ O~?ÑÍ?†3a>Ìcª¾Œ#¿µë¿äØÀ#ÜUÀY&À‡£ˆÀ¢’õÀ¾˜ÖÀÛe ÀøLþÁ ™èÁF`Á(#Á6ÝæÁE©¨ÁTuŠÁcN»ÁrJ¥Á€²ðÁˆM}ÁíÄÁ›Í.Á”,”ÁŒŒÑÁ„íÁzš–Ák`ãÁ\AµÁM:{Á>4Á/1ÀÁ OTÁ—4Áä\Àè|ÃÀËÁÃÀ¯ëÀ’”Àm|À6®ÌÀÇO¿š#ƾ΂£>±½Ö?ˆ®€?á§@_@@)@b ÷@|Ñv@ˆ\@YC@”œ@—Â@˜²¬@—Z¼@“1,@ŒâŸ@„|Ö@s¦Ÿ@Y£É@:–@8 ?Ü83?„§ë>œT#¾ëxê¿¡ÒÇÀþ¶À‡3?qÈ}?׎@‡–@E^@mèA@ˆúÓ@˜eM@£•×@«|Õ@°¢Ç@³¦W@´k @²õá@¯N½@¨é¸@Ÿ’´@“¬@„ï @gð@@¢@è¹?Íú¥?SO<´!Í¿Nž¥¿Õ‹|À"ÄbÀ[eXÀŠJÀ§Z¸ÀÄÔ¦ÀâuÓÁÁ¢Á ÈÁ-}Á<8ÅÁK]ÁZ©ÁiÍÛÁy¼Á„>CÁ‹î[Á—МÁ‡ÁˆX´Á€¢ßÁqåGÁb‡¼ÁS.ïÁCéºÁ4§HÁ%dÕÁ(eÁüëÀïçfÀÑúíÀ´"À–w)ÀqǺÀ7,S¿ûv6¿Š‰¾WB¦?&Ö ?¼rå@še@A4@n]©@Œmƒ@Ÿ‹£@°kh@½9¨@Æ]@ËÓÊ@νy@ÏGw@Í¢°@Ê€@Â÷¬@¸ù—@¬Pñ@œÞ@‰„@gk{@8¨³@wœ?¥$j>ç'¾Ë\Œ¿¥ÒÀ ¶ÉÀEœÀšNÀÔÀ»õÀÙ(?À÷9ˆÁ °¥ÁÍìÁ(ë]Á8mÁG\ºÁV½äÁf%ÁuŒ`Á‚yóÁŠ.Á– ÕÁŽBUÁ†zÔÁ}hœÁmèxÁ^yÁOfÁ?¹ÛÁ0\PÁ ÿ8Áµ•ÁxªÀæ—ÀÈC—ÀªÀ‹ÿmÀ[Ò‡À ¢¿Ì2&¿0ñ>Xs@?Œ! ?û3@2“‘@e¹¡@ŠÍ@ ¸@´Ñm@Æà@Õ*B@߇@åŒ@衉@è²Å@æòn@ã.@Ü(B@Ñj¡@Ã@°ò @›¹@„Ðc@WØó@#/ë?Ùb>?Ulž½< -¿r¾C¿îýÀ1ÏQÀmBûÀ”cÀÀ²]ÀÐŽ6ÀîõýÁÂÁ ±Á%dÂÁ4ÉeÁD2(ÁSšêÁc´ÁrvçÁ€ûSÁˆ½XÁ”\¹ÁŒ‹üÁ„À~ÁyñØÁjb×ÁZÕlÁKMBÁ;˾Á,VƒÁ÷°Á œ%Àü6ÀÝËIÀ¿CÒÀ å‡À‚‘ÀH›UÀ w/¿¡àU¾«ª|?¶Û?½Û§@ ¿@Oý@‚½Õ@œ]I@³Þâ@Éç`@ÜÏA@륺@öDÎ@ý;A{Aus@ÿ@@û©G@óIá@ç¿­@×µD@ÃP¹@¬–@@“hu@r%Ê@;öç@Ë@?–S">‹!á¿&TÝ¿Éü À x£À\˜/ÀŒŸ\À«ÕÀɧýÀèDÁ„œÁçàÁ"M§Á1¶|ÁA,åÁP­5Á`-„Áo¯ÖÁ<ÁÁ‡jƒÁ’ÔÁ‹ Áƒ0ªÁv¹gÁgƒÁWkÔÁGÑÜÁ8G;Á(ÄþÁKóÁ ÖÀÀôÃÀÕðÜÀ·9ÇÀ˜…ÀsðêÀ7Ÿ¿ôfœ¿v:¼ç¼K?f³?êR@/Â`@hö!@º°@«£Í@Ågò@ܲ@ñ ”AqåA ÅA ÖÚA ñ¼A ´A k;A ?üA]³@ûSP@é†C@ÓŽ@ºÄ@ g-@„ú‚@QÊÝ@/’?»Ó#? ˆë¾È ¦¿«!&ÀD¼ÀNøåÀ…ðÄÀ¤¢­ÀÃd­Àâ%_Át ÁêzÁxÁ/ SÁ>š£ÁN+ôÁ]½EÁmN–Á|ßçÁ†8ßÁ‘9ùÁ‰d“Á“uÁsYÁcþçÁTm’ÁDÇ+Á5>Á%x ÁÜÍÁQNÀí¬‘Àο†À¯Ò|ÀåqÀcôRÀ&®0¿Ó¿1W­>ƒã.?™wF@ô@DK%@Z/@œx@¸Ôç@Ô0p@í¼jA1bA bkA0ARgA¢æAî·AZ˜A-A {ëAî§@øÔ¾@á†s@Ç }@«Ë4@>K@dB@);-?ÚßN?Fƒ¾2•ô¿žŽÀ‚õÀB»°À€.ûÀŸ©À½àWÀÜ­jÀû²Á j^ÁÁ,™ÀÁ<3ŽÁKÍ\Á[g*ÁkøÁzšÆÁ…æÁÂ<Á‡ì¦Á€LÁpƒãÁ`Ù—ÁQ5œÁA›kÁ1û¿Á"]øÁÅaÁ-Àç­ÀÇñ À¨øÀŠÀÀVÿÀ9Ê¿´¿i¾çÈ?w?»Íé@ˆT@Va@‰L7@¦ù¥@Ä Y@àšm@û¾ŒA Ÿ(Až„A†AìA CœA ’ÒAßZA@†A×nA òqAT@íKÓ@Ñ›ï@´åh@—¥ø@sAq@7 ?õž?xDv”óÁ.ìÁMmÁ»&Á*)Àá”ÀÁÌÖÀ¢‰ÀƒPŠÀH¦àÀ Ľ¿™Å6¾p…?;†©?ØÝR@)”²@fÀ"@‘ï,@¯ô@Í»,@êïA¬AøóAeOA!ÌÓA&„A(˜A)ßA'#œA!ÙAmêAVAø:@ö×´@ÙöÅ@¼¤Ò@ž¥@€{·@DB @k¿?”]D>H㻿Dí&¿Þ À,ÎTÀj•À”/ÑÀ³XœÀÒ™ ÀñÛÁŽùÁ.ìÁ'ÎÁ7pÁG4ÁVÖ ÁfŠÂÁv?zÁ‚úÁzÁ…"ÏÁz…/ÁjÊ¢Á[=ÁKkÑÁ;¹\Á,ŸÁVóÁ §±ÀúÇÀÚ×wÀ»·RÀœ—.ÀzÜÞÀ¼³Û¿a•¿ÇŽŒÀ!Ç^À`À;oÀ®lþÀͯoÀìñãÁ$“Á×3Á%‰ÓÁ5( Þ?ù‹@q¤@D`õ@€ùB@Ÿ”Ÿ@¾/þ@Üm@ú8ÔA …!AáA$‚3A,wA2'4A4ÀÆA5BA2³{A-w§A&¢±A¶;A‚AøÆ@çæÔ@ÉÚj@«ZÑ@Œ·½@[ïƒ@RÈ?ÁjÒ? !¾Ù½H¿³ÓÀó¯ÀVY`ÀŠ_šÀ©²ÀÉ‘Àè{Áï¼Á¢˜Á#\Á32ÁBÐIÁRŒÁbO­ÁrÁ€ó³ÁŠÄ·Á‚Û…ÁuåÁfÁÁVC{ÁFtkÁ6¦áÁ&ÛLÁIÁL¾Àï‚ÀÏ¿¹À°zìÀ‘<ûÀcÅèÀ% í¿Ìü¿Æ~>´Ø;?©»û@~Æ@P@†ã’@¥º<@Ä,g@âP4AA_áAºòA'YA0ÉA6=A9ËA8ÑèA6³UA1éœA+’A!±XAÎIA;@î¦@φE@°òÊ@’\ñ@fÛ@(üC?Ö?2–¾ŽX¿ kÙÀ ÕÀM :À…çÀ¥[JÀÄÏyÀäC§ÁÛëÁ–Á!PÁ1‹Á@ÖXÁP£Á`pQÁp<­Á€…Á‰¿ÁÔRÁsÓ-Ácý¶ÁT(AÁDRÎÁ4}åÁ$¯¹Áè™Á%|ÀêÏÚÀËZˆÀ«å6ÀŒoäÀYõ$À €¿¸Da¾éà©?Ï?¾Q@NÒ@Z÷/@Œ- @ªß@Ég@çÂAA‰MAé¬AkïA*B5A3òA9hMAçìÁN±œÁ^{LÁnDüÁ~ÁÁˆÞJÁ€ïØÁrgÁb4±ÁRhÎÁB ºÁ2Ì•Á"øqÁ$LÁP(ÀæøÀÇPÞÀ§ÂèÀˆJ·ÀQ¥À·µ¿§£3¾§[î?'êw?Ñ(ˆ@&¯­@d¾¤@‘B.@°Ù@Γ|@ì›­Aõ÷A4#A ůA,µOA5™èA;Ç%A>ÞãA>×ÍA='aA8›A0…;A&UuA A 4+@÷á?@ÙQ@º{k@›–@yP5@:óA?ù ê?xS»ß¢ù¿|O¿ûÉžÀ<ÂùÀ{§SÀE×À¼¸ÀÜ*2Àû¡±Á – Á_ÎÁ-)~Á<óBÁLÀXÁ\Ž&Ál[óÁ|)ÁÁ‡ý±Á€ÁpQÁ`| ÁP§!Á@Ò6Á0ô)Á!;Á?ÀÁs_ÀãXÀÃÉKÀ¤:‘À„«×ÀJ:;À ôÄ¿—™ç¾MÉ2?G?àN²@.j±@lWº@•@³Ï@Ò¯@ïÝxA±õAü{A"n²A.a.A7‰KA=°"AA0AA iA?›4A:2²A26A(A˜A K@ü.@ÝaÏ@¾‚É@Ÿ™ù@€›Æ@B´É@01?‹W1=äà¿]®ë¿ìyMÀ5 ’ÀsÞ~À™T¡À¸²òÀØ#òÀ÷¬¨Á ¡ëÁnˆÁ+;$Á;dÁJÃ=ÁZ€Áj@0Áz°Á‡/ÈÁ~z…Án—šÁ^¸ÚÁNß8Á? cÁ/6$Áb9ÁŽ»Àÿw¦ÀßÓ„ÀÀ1äÀ ”?À€ýƒÀCrÀ‹Ü¿Œ ½ïÈz?[û†?ê¦R@3§q@qMÒ@—Dƒ@µÖ»@ÓÞ¢@ñ’5AquA­ÕA#,}A/2wA8ÓžA? IAB‹ëAB»ƒAA:A;åjA3²A)—XAå&A ª@ÿ–ž@àÎ/@¿@£<±@„Sá@J?Å@ ½?šoŽ>i÷Ø¿?ã0¿Ý"+À-)_ÀkɬÀ•@.À´§»ÀÔ,ËÀó³¢Á hÁaÁ)%Á8ï¡ÁHÂ!ÁXšÁht;ÁxMåÁ†ªkÁ}qGÁm¹Á]ª*ÁMÇ‚Á=èkÁ. ÿÁ9¦ÁmfÀýX‹ÀÝÆ›À¾+‰Àž˜ÕÀ~“À>ÿ3À`Ù¿ƒ›ö½Rg ?kÝË?ñé@6‡@sü}@˜3Í@¶l—@Ô:Y@ñÄîA‡¨A§ëA"ä%A/,ôA9p(A?æVAC}ùACê;AB•ÖA=#¬A5"ŸA*ñA!¹A¹AUð@ãèœ@Å%X@¦b@‡zO@P¼ò@…E?¨/ >«Ö ¿$ˆ ¿Ï}À&¥“Àe± À’,çÀ±=ÀÐÕ¹ÀðC%Áè§ÁºþÁ'ŽÁ7^ÝÁG/ÁW\ÁfÑÁv¢³Á†ªÁ|aQÁlƒÄÁ\¦ÇÁLÊ|Á<ë­Á-ËÁ;îÁ oÀûZ³ÀÛò‡À¼šÀ,­À{‡ÀDìA6=UA,<‰A $ A°YA‹¶@æ’¥@ÇÌ@¨ä@‰ý@UÎ@–?²¼m>× Ëò¿ÄªÀ ºâÀ_hnÀØÀ®„tÀÍôÀídýÁp+Á2\Á%úÁ5ËaÁE¡ÁUyyÁeRÉÁu-7Á…´ÈÁ{Š5Ák¬›Á[ÑÁK÷ÝÁ÷¶š¾û¦Ÿ¿»¿ìÀP À[#3À°À¬uÇÀËêQÀësÁ~ÁC´Á%ÊÁ4ÍàÁD”ÛÁT_ÖÁd.ëÁt%Á…†„Á{-ÁkNvÁ[qèÁKšçÁ;ÊØÁ,¨ÁHÁ ›ÒÀùþ!ÀÚÎ\À»ž—ÀœnÒÀz~À<‘¿üï¿ÇN½ƒD›?b½u?êñ¿@1=I@lÖ^@”$j@±†è@Îå6@ì»Aq’A¢iA :zA,.A7 ­A>­XABYáAC‘uACpþA?bA6ŒA,±ÑA iA²žA©Ë@èäæ@Ê>W@«|Ð@Œ½ @[— @¨–?¿,m?#Á¾éy±¿·N¹ÀƒÀXªöÀ‹²¿À«vÀʤ|Àê6bÁä$Á­Á$v Á4BÁDáÁSá5Ác°‰Ás€PÁ…´[Á{Ák²œÁ[ÝKÁL¤Á͵A?½0A?ô=A=(´A4nÄA*­&A5A¨Aïõ@çÝ¢@ÉÆ-@«º@Œ5×@Z¥ç@à ?½©¥?!7¾ë½¿·^0ÀiaÀY&-À‹ñ|À«OâÀʯÀêõÁÎéÁ™%Á$jÁ4:ëÁD ÔÁSܾÁc­¨Ás~‘Á…øÁ|°ÁlKIÁ\ÁL¿Á=|Á-](Á½¤Á ÀýNÀÝÐõÀ¾™žÀŸ†yÀ€¾¶ÀD”ýÀÌÚ¿–d¾l0?4—Ï?Ñ”„@#ÇJ@^|²@Œt*@©_@ÆI¾@âçJ@ÿZmA ^LAU™A%îA/\‰A686A9‰A: éA:6ŒA7˜þA0/fA&‘­AVNA±AÎø@ä‰&@Æ–ž@¨Zô@‰ç@V½œ@?¶>è¿mο¾sÀW›À[—°À¼À¬YÀËÀ¶Àë3öÁWÁ¥Á$ÕSÁ4 rÁDqLÁTDÄÁdÂÁsõGÁ†z¶Á}9ÿÁm‡Á]ÞKÁN:ùÁ>—§Á.õnÁWÏÁ¿þÁ)°Àá&ÂÀÂÈÀ£aÀ„”½ÀLR†ÀÓ6¿§ t¾¼øx?3Q?¾™»@@Ta @‡;@¤ä@À•U@Ü×@øž€A sßA…hA A(D_A.Ž×A1itA2NA2†ðA/ßQA)r-A bŽA§¡A ­|@ùŒ.@ÝÞ‚@Àçd@£?Q@…>è@Mѳ@ê5?§!f>°Ùz¿þ׿Ë56À#†ñÀaÐuÀ}À¯OqÀΓxÀíØ»ÁZÁ4VÁ%Ú¾Á5ŽîÁEOBÁU ÁdêRÁtÁ¥Á‡EªÁ~ê¥ÁoPBÁ_¹æÁP#˜Á@JÁ0öüÁ!`®ÁÊ_Á4ÀåGAÀÆM­À§®6À‰uŠÀV†œÀ"%¿»¶È¿ aœ>Ĺu?¦¿ï@ ¶ñ@Gû @€«o@ &@¹G|@Ô¶¡@ïVA –A!AÄãA &¡A%ljA(o‘A)icA)3!A&³A AƒA9kA8vAùÔ@íi¿@Ó @·í+@›eÓ@{Â6@@­á@Ó¬?:ø>6·Æ¿E¸»¿ÞŽFÀ- Àjù À”k\À³[eÀÒogÀñ‰dÁQ±Áâ\Á'yeÁ7-ÁF¹OÁVjéÁf'PÁuìoÁˆTÁ€)Áq`yÁaĉÁR2éÁBª¶Á3(«Á#¦«Á$«Á¥VÀêƒòÀÌtÀ­è9ÀÍrÀclzÀ'?Å¿Öß¿B¸î>!1@?ˆpx?û™m@7a)@pHÛ@“û@¯†Þ@É•·@ãE¡@ú\wAs~A1AÞA#Ae)A@AÛ’AzÚA©*AÓA‹ß@õäY@Þªt@ÅÐÖ@«Áý@Ý@hmñ@.ú2?è:À?e½-)ç¿|‚Õ¿÷†À7ô½Àus`À™†ÉÀ¸bÕÀ×H¾ÀöOkÁ ¶†ÁFñÁ)ØbÁ9iïÁHû|ÁXŽwÁh)cÁwÍÖÁ‰wþÁ®¼ÁsÔ·ÁdL”ÁTÄ®ÁE=Á5µ×Á&5àÁÐ ÁõÀðõkÀÒï‰À´îÄÀ–ò<Àqë‚À6ÄÆ¿ù(¿„¼f¾Z&?C L?Ó,„@"?Á@Z¶@ˆ‚Ï@¢õ™@¼\£@Ô@é¹ü@ü®ATŽA &ìA’yA‘¸AôA´AA^UA t AËï@÷¬@ã»,@͹Ö@¶Ö@ @‚ä@P=ë@p?¿z?· ¾¡B¿÷UÀ :>ÀG ÀáíÀ æÀ¾ÔÀ݈ÀügÁ ˜CÁôÁ,ˆFÁ<ÇÁKŽYÁ[wÁj²·ÁzQÎÁŠàüÁƒ°Ávµ%Ág99ÁWÂÁHOéÁ8ófÁ)³ZÁ˜1Á ›þÀù- ÀÛ1À½ ÀŸwûÀ‚`¼ÀJ¸0À®è¿­w¾îæÀ>Ó.r?¥?:@ D¤@@¤Æ@v@”@¬\Ä@¨Á@Öæì@èSD@÷¸·AèðAÅA%A^(AÎÆAF5Ažx@ô+ò@âÂ@Ï¥…@ºâ%@¤{¬@Œ~/@fàÏ@2ÅU?úÖ³?ŒÖ´>tˆ¿*Ò±¿Éq¡ÀÛWÀY-ñÀŠœÀ¨‰:ÀÆ©ÀäÉLÁ¤ÕÁîÚÁ ETÁ/¥eÁ? ÁN…rÁ^ãÁmŒûÁ}GÁŒmïÁ„²VÁyí~ÁjxÁ[% ÁKã™Á<Á·Á-¿ãÁÂGÁÅwÁÏyÀä/¢ÀÇ kÀ©æÖÀŒâ3À`\ÐÀ'¼²¿Þ«¯¿\p#Ûo?Ÿì×@û@2É@`ðc@…a@˜–æ@©«ò@¸è´@Æq›@ÑqÅ@Ø[‘@ÛÌv@Û´@ØzN@Ó°Û@Ëÿ;@ÁØ@´<>@£|Ñ@Íœ@xö¼@MÓò@ ?ßí”?vôœ> nä¿,C¿Á?äÀdÀOw}ÀƒÚXÀ E´À½a˜ÀÚˆÉÀ÷þ±Á ÏóÁ¢8Á(ˆøÁ7ŠÁF±fÁU÷ÁeEþÁt–ëÁóðÁ'ÍÁˆ”Á EÁsëÁdUÁUïÁF9FÁ7{/Á(â»ÁKÒÁ ÉŠÀúØWÀÞA½ÀÁÞVÀ¥”òÀ‰nôÀ[×’À$ꚿܷ¿b¸~½|²r?7¬,?»þ”@ dà@6ÅO@]«„@€ÔÄ@Áê@Ÿu@«‘Ö@µË@¼–R@¿ž@¿Jê@»¯*@¶Õ^@¯ÿ¼@¦Vì@š,@‹>@s¿@L¤@#°³?ï´?“nT>Íf˾Âè¿–ò|ÀÀ5­õÀkdéÀ‘“AÀ­³£ÀÉÙÎÀæ!Á„'Á6£Á­Á-×HÁ<¨/ÁK{ÓÁZmíÁi‚ðÁxµ7Áƒû«Á’x²ÁŠø\ÁƒzÖÁx Ái*iÁZeÁKÇcÁ=8òÁ.¿Á M¤ÁÁÃDÀëoFÀÏ_ÚÀ³•ÇÀ˜ çÀyKtÀBÈåÀ þÁ¿´ˆ¿gp> ¾?Ygj?ÂÔI@ GV@.+7@OŸ2@m_@„:@×þ@™v]@  J@£=@¢#ª@ž^@™Ÿ™@“@ï@ŠªB@£Ñ@dO{@Df¨@„ ?íò¦?›¦?û¾LèY¿sðÚ¿Ý1dÀ!ç3ÀUÕ¹À…„xÀ XwÀ»ÏkÀ×Ù…ÀóãŸÁößÁxÁ$ŽMÁ3CÆÁBŸÁPà«Á_±·Án‡÷Á}{oÁ†EFÁ”òÒÁôÁ† áÁ}QÁn­nÁ`.wÁQ´¡ÁC:ÿÁ4ãZÁ&¾ÆÁµjÁ ¬oÀùZ ÀÝÂÈÀÂ-]À§ÜÀŒEYÀd À00‘¿üeû¿œGš¾ÿï>4Çv?O÷?³¯_?øÈ’@Â@8g‚@QûÇ@g¤W@y³ @ƒ ~@…¹â@„¢’@€ßÓ@xR@lÂr@\ŠÔ@H_6@/pÅ@ýD?ÞD?’J!?ðš¾ðÓ¿Y‘¿È½À–*ÀE¾^Àx®mÀ–QlÀ°«ÙÀË›Àæ éÁ ŸÁ«ÁøÁ+*jÁ9ckÁGÛ_ÁV}¤Áe0OÁsðLÁ]©ÁˆÊDÁ—Á+þÁˆÚ„Á›(Át½áÁfE ÁWãçÁI¿šÁ;µVÁ-«EÁ¡wÁÅÁ hÀìÂ}ÀÑçÀ·MÐÀÀƒ?áÀUKøÀ$ô$¿ï2)¿—ü¿ "#=EÑ?$TÉ?‘}?Îp@úl@Qª@.ê$@?´@Kwz@O÷—@M ¹@FÊö¾[–¿X\¿ÃG¤À(ÚÀ<—×ÀlE´ÀŽÑÀ§Ã§ÀÁ·üÀÜhÀöq5Á‚‹ÁAÁ$<8Á2D…Á@QãÁN‚¿Á\ÐÄÁkF9ÁyØàÁ„;–Á‹‘ Ášt@Á“4ÀÁ‹ù®Á„¾œÁ{ÚÁlçoÁ^ÓÌÁPȘÁB½eÁ4Î Á'ÞÁuÁ äÀüÏäÀâg­ÀÈzÀ¯7À–SÛÀ|sÀOB+À"€m¿ñåe¿¢x¿2‹Ó¾.Oì>¥÷#?DÒÌ?–‹?Ãúo?ês[@ü¨@O›@žÝ@–í@ -@@i ?ìŠL?Ï5Û?¬Ëu?‚rh?áb>¡T¾ÃL¿s¨¿É£ºÀ ¢zÀ9¨—ÀeínÀŠh–À¢aÀºÇOÀÓ¤pÀí5ÐÁË;ÁýÔÁ?rÁ+ÇÁ9…0ÁGo ÁUy–Ác¦ÁqïãÁ€ <Á‡Y˜ÁŽ¢+Á˜ŒÁ–]“Á.QÁˆÌÁÝÁsíáÁeáÌÁWù¡ÁJ>YÁœ˜»?#Ä+?m‘?”]:?¦-?®‚!?ªa?›ï•?Š^3?i|?1Ý>áZ*=ø©Z¾€F¿/ðö¿—Ȥ¿ÝÔ·À®úÀc|=>¶éó>ÕL>ÁÁ[>‹‰Ø>I5¼Øª$¾pÖà¾ô²¿I€‰¿õ¿ÆÀC«À")ÅÀE~ÿÀlsíÀŠ$ ÀŸœ’ÀµmôÀË®ôÀã*~ÀúîbÁ yÁÿÁ"¬ÎÁ/†Á<ŒÆÁIÈKÁWB,ÁdÒžÁreÁ€ =Á‡ ÁŽÌÁ•>ãÁ¤IoÁ«Á¯FHÁµ^vÁ»ˆ¾ÁÉ¡ÄÁÃUbÁ½'<Á· iÁ°ðõÁª÷…Á¥½ÁŸGªÁ™ªÂÁ”/bÁ޹~Á‰fEÁ„VHÁ~ÑÅÁu^Ál¼Ác;åÁZÆßÁRÄhÁK¶ÁC½êÁ<²µÁ6EÁ0;‚Á*°ÑÁ%³ Á!:ÊÁj1ÁÐÁu-Á¬Á‡žÁ7,ÁMÁbÁíßÁQÁŒÁ‰QÁ"7áÁ&:ŽÁ*Œ.Á/)“Á4tdÁ:eVÁ@ùWÁHÑÁOYzÁWh¼Á_©6Áhb€ÁqµÁ{¬Á‚z5Á‡ VÁŒÊäÁ’"Á—£ƒÁ5áÁ¢æªÁ¨¡;Á®zÁ´u@Áº„ÁÀ•*Á΀ ÁÈSÉÁÂ5KÁ¼"BÁ¶.#Á°E«ÁªydÁ¤Û”ÁŸb.Á™êÙÁ”Ž¡ÁqIÁŠƒòÁ…žÁ€÷ÇÁy¯ÁpefÁhJÉÁ`QxÁXï ÁQÈNÁK8ÁDŸ Á>àÁ9vÏÁ4¨Á0N;Á,¢bÁ)x³Á'_Á%1Á$4 Á#׈Á$>Á$éYÁ&|‹Á(pìÁ*úÁ-ÙÁ1rƒÁ5TÏÁ9°uÁ>&ÁC¾ÁHÝÁOGÁV"žÁ]HÂÁdó¥Ám!˜ÁuŠqÁ~‚1Áƒð2Áˆ­Á«‚Á’ÓtÁ˜}Á^QÁ¢ÝrÁ¨r¡Á®#Á³ÙµÁ¹°ÆÁ¿¬mÁŸäÁÝÞæÁ×¥5ÁÑxðÁËi/ÁÅ|ÆÁ¿¶ÃÁº ÊÁ´pŸÁ®ýÁ©´Á¤{ÁŸmâÁš™Á–«Á‘„5Á5ÁˆþcÁ…74Á“uÁ|ÏÁu‘²Áo¥ÿÁiû¼Ádß?Á`!fÁ\?ÁXy¹ÁUtñÁRÑjÁP€)ÁOQÁN„ÁM’´ÁM^åÁM¨KÁNl­ÁO¶oÁQTÂÁSnuÁUê ÁXàÁ\¹Á_ì¿Ád@iÁhõüÁngñÁt#7Ázƒ”Á€˜YÁ„2iÁˆñÁŒÁbÀÁ”ëÁ™~ÁžGeÁ£P—Á¨‹&Á­ÒmÁ³*úÁ¸±àÁ¾eÆÁÄB¿ÁÊ6ÁÐ,ÁØý™ÁÒ¸ÁÌ€ƒÁÆV(ÁÀAçÁºR¨Á´Š$Á®×äÁ©>ƒÁ£Ó%ÁžŽíÁ™V¢Á”UËÁ—ZÁ‹,Á†”EÁ‚A¹Á|–/ÁuBÜÁmüñÁg*ƒÁa(Á[?MÁV‘ÁQêÁLÔfÁI$²ÁEþCÁCR¾Á@ß,Á?h|Á>khÁ=Ü“Á=¤Á=ñäÁ>ÉíÁ@!cÁA̰ÁDKÁFãÁI”ÁLü¸ÁPúüÁU]TÁZbÝÁ_ô_Áeæ‚Ál|!ÁsSÏÁzè»Á_ÙÁ…‡Á‰ý“Áއ¸Á“;¦Á˜6Ám¯Á¢ºlÁ¨©Á­•œÁ³H—Á¹'Á¿ÃÁÅ ‚ÁË /ÁÔCÆÁÍÛáÁÇ‘oÁÁ\cÁ»5nÁµ·Á¯-pÁ©`QÁ£§Áž$Á˜«†Á“iÝÁŽ7Á‰FLÁ„ ÐÁ€ àÁwVAÁnú7Ág[!Á`LÁXü|ÁRªÊÁL±–ÁG./ÁB&Á=¹˜Á9ÐgÁ6šÎÁ3ÔÁ1O#Á/»Á.ÄþÁ.3TÁ-êµÁ.;~Á/'.Á0ŒVÁ2NÁ4ªÁ7)ìÁ:eaÁ=ãÁB 9ÁFÔÁKÞøÁQ„§ÁWϵÁ^w–Áe¶Ám~pÁu€ìÁ~:4Áƒœ7Áˆ:LÁ$Á’S…Á—¦fÁ&Á¢ªÁ¨0BÁ®¤Á³ýóÁ¹í±Á¿óïÁÆþÁϽ ÁÉ0ŽÁ¿ˆÁ¼mÁ¶8ðÁ°ÖÁª™Á¤ —Áž9âÁ˜y Á’âuÁ‡ÁˆIÁƒ äÁ|„”Ás[`ÁjZƒÁa«ÚÁY˜¦ÁR,‘ÁK&ÁDDÁ>A£Á8xîÁ3:Á.¶+Á*ŠLÁ'DóÁ$UdÁ!ÔÁ *Á.kÁ–ñÁ8Á…ÜÁ„oÁ ÷TÁ"Ó*Á%PKÁ'ðÄÁ+6\Á.çàÁ3Á7î¿Á=^£ÁC?KÁIÄIÁP¢õÁXKÁ`ßÁh˜rÁq}ÐÁzŽÁ‚­Á‡?RÁŒ—FÁ‘õ2Á—k>Á?Á¢öIÁ¨å˜Á®×OÁ´á‚Á»bÁÁcRÁËOúÁĸOÁ¾$‡Á·©‡Á±NOÁ«LÁ¤÷™ÁžæfÁ˜îìÁ“›ÁPSÁ‡¼×Á‚i-Áz`gÁp)úÁf™žÁ]teÁTŠ=ÁL)ÓÁDK)Á= Á6RÁ/ÑÁ)Ô{Á$e Á³DÁcÁôYÁØOÁiÁŽÎÁ¤çÁûÇÁŽáÁÙÁá°Án ÁaþÁöÁÐÁoÁúiÁ$9”Á)j¿Á.êÁ5'vÁ;ÀÁC›ÁJß™ÁS eÁ[àvÁd˯ÁnFÁxkØÁŠzÁ†èfÁŒWxÁ’NÁ—ÝîÁΣÁ£ÈgÁ©×=Á° `Á¶g3Á¼áÁÆåÛÁÀK…Á¹µ~Á³ üÁ¬›Á¦64ÁŸöTÁ™ÛÁ“ÊŠÁÐGÁ‡ø´Á‚.sÁy=×Án¨/ÁdBÁZ,óÁP»ÔÁGŽÁ>é’Á6²iÁ/!Á(}Á!bñÁSêÁ¸¿Á³ñÁ SoÁ²ÜÁsÁ ¨Á½Á˜ÀþÁ9ÀýãiÀþm'Á?lÁïóÁþêÁœÔÁ ¾áÁ GÁ&6Á” ÁçóÁ ˜ŸÁ'¼Á-ôçÁ5¬ñÁ=”ÊÁFFgÁO0ÁXvgÁbu Ám˜Áw·7ÁD€Á†èuÁŒÆ.Á’¾ñÁ˜¿ÁžÔøÁ¥kÁ«vÁ±öñÁ¸†]Á¨ÇÁ»ëàÁµI@Á®µ@Á¨#Á¡•ÇÁ›&8Á”݃ÁŽ¿4Áˆ®½Á‚±©Áy´aÁn*§ÁcêÁXÁN-•ÁD@âÁ:à»Á1à Á)k6Á!NÅÁ+Á+5Á å*ÁIÁÒÀú¤HÀòâòÀìièÀçi³Àã0‚Àá’Àß‹ÐÀÞ³!ÀßI"ÀáE.Àäã¸ÀéOFÀî8ÀõVÇÀüOQÁ\‚Á'ÖÁ qBÁ„²Á PÁ zJÁ(@ýÁ0¬XÁ9š‰ÁBËÇÁL¡¥ÁWÑÁa«¦ÁljrÁwªÑÁµÁ‡µÁ¶dÁ“ÕÁšbÁ ŽºÁ§zÁ­š=Á´2Á¾©‹Á·Ç%Á°üÅÁªMKÁ£¸Á(žÁ–šÕÁ 8Á‰Í¹Áƒ§žÁ{%ÞÁo&&Ác›ÁXÊÁMYÁBz7Á8cÁ.d4Á% ?Á4ÿÁó/Á +ÐÁ,xÀýWÀðÛÎÀæ2áÀÜÁÀÔ`GÀÎsÀȺ<ÀÄOýÀÂôÀÀX]À¿¨’ÀÀ_íÀÂD/ÀÅïýÀÊ¡NÀÐÀ×(ÓÀÞÀÀç7¿Àñ€ÉÀürÁˆôÁ XãÁ ÈÁ›Á$øÁ-.ÈÁ6ÜÁA)=ÁK¼—ÁVf ÁaÁm^äÁyX…Á‚¯DÁˆÙÁ/âÁ•©TÁœ'yÁ¢¯Á©LdÁ°-ÁºÎÐÁ³ß_Á¬ó¸Á¦¯ÁŸ]$Á˜¾°Á’0¢Á‹¢¤Á…%Á}’¥Áq4éÁdøPÁXìàÁMXKÁAû¾Á7Á,i©Á"§ÁŒ¬ÁS:ÁÏ=Àý3äÀîeBÀàÃÚÀÓû÷ÀÈÖYÀ¾ö”À¶4À¯¾¦ÀªòÀ¥‰À¢ïVÀ¡/–À ¨eÀ¡“{À£¡ìÀ§>À¬-À±Ý¢À¸üBÀÁ1ÀÊ"4ÀÔÌ‹Àà øÀí`SÀü¹Á»öÁu£Á Á!çÁ+MÿÁ5ÒÞÁ@€ÕÁK¯sÁWizÁcMžÁoTaÁ{ÀŽÁ„F ÁŠÃîÁ‘AéÁ—ÊÆÁžuÁ¥=ÄÁ¬!-Á¶ûÁ° Á©‘Á¢*”Á›H$Á”{fÁÎvÁ‡8­Á€ª£ÁtWGÁg ÂÁ[5‘ÁNãjÁBɪÁ7AmÁ+èéÁ!èÁbKÁ %eÁÔ<Àós¸ÀâØ ÀÒ·NÀÄ´dÀ·4À«‡ìÀ¡0À˜oÁÀ‘rRÀ‹\œÀ†ßòÀ„ =À‚.bÀº'À‚ÇÀ…'ŒÀˆÀTÀ¶êÀ“ÌáÀ›KÀ££À­WOÀ¸XËÀÄá|ÀÒñÀ᤹Àñù­Á Á `kÁ…>Áé%Á*¤Á5çãÁAbÁMZÁY_°ÁeßJÁrÁ Á¼üÁ†^žÁŒ÷‚Á“¯ùÁš‡¦Á¡y³Á¨uõÁ³bmÁ¬F˜Á¥?¡ÁžNJÁ—bCÁ|?Á‰©—Á‚í4Áx’0ÁkeXÁ^d„ÁQ±ÅÁECYÁ8ë’Á,ÆôÁ!2±ÁÖcÁ þOÁmYÀìàÀÚC ÀÈŒpÀ¸+À¨®÷À›4,ÀŽÙKÀƒå"ÀuÓ{Àf¨ÀZWÀQ\ÀKÒÀF¡‡ÀEÞÉÀGõ+ÀM^µÀTçÀ_*iÀlP®À{gÀ†%îÀÆþÀœ„™À©F.À¸-ØÀÇ¿ÀÙ]kÀëpUÀÿyèÁ ÁÌ}Á 'ôÁ+ÀÁ7ƒÍÁC’5ÁP"ãÁ\ø„ÁiòÁwoÁ‚6¤Á‰HÁçÇÁ–ÙÿÁÒhÁ¤×ÎÁ¯óÁ¨ËÍÁ¡§ZÁšpÁ“‰ÁŒ™ûÁ…±Á}¶@Áp,mÁbйÁU‡æÁHrÁ;êÁ/W*Á"ù!ÁÜÝÁ @NÀÿŽ‚ÀêwÀÕh†ÀÁ»ÞÀ®ÞÉÀÚzÀ²òÀ~KÀdÓÌÀNkiÀ:ÎïÀ*ƒåÀ ÀËhÀ"™À œÀOÇÀ _–ÀnVÀ¤SÀ"ýÀ1:¢ÀAÀSHÀh‚KÀ€¼ïÀŽ´ÇÀ×gÀ¯ÀÀÕ ÀÔ?ÎÀèuAÀýúÁ hÁï¬Á!¾ÍÁ-÷ÚÁ:xRÁG6–ÁT4ÁÁaƒæÁoÒÁ|ÕñÁ…QÁŒ=³Á“;ÁšQ–Á¡}èÁ¬™ßÁ¥_XÁž6’Á—5ÁïãÁˆÕNÁÓÁuÍZÁhïÁZŽÁMÁ?È>Á2šÁ%ØJÁk¢Á ¯ÁõÈÀê½UÀÓÑŽÀ¾³ˆÀª,À–žêÀƒã§Àg>ÿÀHY7À,i´À":À\Þ¿Þâ¿Å¿°öê¿¢Ïü¿™™ø¿•ø©¿š¯¨¿¦û쿸ÃB¿Ï‰¿ìI+À"ÁÀëòÀ1Y×ÀJ†9Àh¦âÀ„ÔËÀ–†´À©¦™À½žÀÀÒ´ÚÀéQÁ 1Á EÁoæÁ$ݦÁ1„TÁ>¡ÁL%xÁYè Ág²¿Áu{ÐÁ±¨ÁˆÁNÁê Á—![ÁžXöÁ© Á¢0¥ÁšãƒÁ“¨ëÁŒ€eÁ…[ÃÁ|pÚÁn:^Á`;ÛÁR~hÁDð0Á7g&Á* ÔÁâÝÁ-Á‰]Àî*ÀÖ%ãÀ¿"ŸÀ¨Š¿À“s>À}…dÀWVÀ3šßÀál¿ì k¿¹ °¿w¿Sæ¿È¾á´¾«õœ¾‡ž¾xä̾Š„¾´ˆú¿{¼¿2¿,¿n§á¿›Ò¸¿ÅË)¿õ¤ùÀ‰À5d.ÀXªÀ~*RÀ“-ÞÀ¨ ½À¾C®ÀÔǵÀì÷‹Áé¸Á[UÁ Á)RþÁ6ùöÁD¿CÁRˆTÁ`evÁn€£Á|Ñ^Á… ²ÁŒ×øÁ”xÁ›^Á¦ŸwÁŸ>*Á—à­Á†ÞÁ‰7íÁý×Áu§UÁgTÃÁYÎÁJÓÁ<ê³Á/R’Á!ÉpÁLÁ.òÀôÂ~ÀÛ€}ÀÂÚÀª„ À“Ü>Àz”ÀPš]À'týÀGj¿¿ð¿€-~¿ô»¾Y½k=¡úº>ov>ø¿?oº?+²R?0;?(¯=?]p>Ø2í>_x½‡?¾­,‰¿.ùª¿‹­?¿Æo­À}WÀ) žÀQˆoÀ{6ÇÀ“™3ÀªKÀÂ?‡ÀÛ%Àô´ÁòÊÁXeÁ!æ&Á/–°Á=hÆÁK¯ÁYÕNÁhI/Áv¸´Á‚—”Á‰æ&Á‘F•Á˜¬wÁ£äKÁœeÛÁ”ô²Á“Á†9œÁ}À`ÁoiÁ`«çÁRXUÁDèÁ5¶©Á'”šÁÏ»Á F|Àý|ÀãeÀÉnÀ¯îÀ— 7À~êÜÀQWÐÀ$!á¿õ¥H¿¦<‘¿4ã@¾EŸÉ>ŠáÒ?'Zø?v¿á?›’·?²Z`?ÂŽ?Ë|?Ï›ô?Ë/ž?½íW?©ù.?Ž3‹?Xød?•±>yR¾‘“—¿HÖ/¿ªP“¿ùjDÀ&lÀQÝqÀ×9À—Ú†À°†DÀɘ±ÀäÖÀþ÷ËÁ îËÁЍÁ(‰ñÁ6ÜPÁEN†ÁSÁxÁb9ÚÁpÞ¿Á¦ŸÁ‡91ÁŽŸÁ–õÁ¡RÁ™ÎÆÁ’MjÁŠÏzÁƒXùÁwäŸÁi&òÁZsÁKÍ Á=\ÀÁ/ ·Á Å=ÁÓÁ–åÀíªÐÀÒ—SÀ¸ËÀž= À„‹IÀW°>À)[¿öÐ’¿žÊî¿©<‡iË?<%?‹§?ÀU?ëj0@í@ÿ@ý@jd@"›¿@ M¸@#1@1é?þ1 ?Ùü”?®0!?väR>÷KȽKuü¿!;7¿£Bq¿ùY<À+q¿ÀZëÀ†-ŠÀŸ¾èÀºVÉÀÕ:^ÀðM%Áö¬ÁˆÁ"iæÁ0ʸÁ?EIÁMô„Á\ÀÁkŒUÁzZ%Á„”¦Á‹ýxÁ“r4ÁžòQÁ—TGÁÀ¯Áˆ9|Á€¼þÁr…¿Ác“ãÁT¿]ÁEõ1Á7-uÁ(ÁÁ ׈Àû>¦Àß)]ÀÃ[#À§·"À<„Àf9À2öÀ&$¿¦÷¿Ê=¤4?9ˆ»?©LE?íX@yß@+Q’@=_¡@Jt„@S*2@XÒò@Z ±@W„I@Q[™@Fÿ@7_@"ìñ@ á!?ÛæÀ?‘û?%çï<¨øh¿&ƒ¿¿¯>À%TÀ9X`ÀlÒ¦À—À«óçÀÇ‚ñÀã„ÁÀÿÔòÁÁ|BÁ+(!Á9òÁHÃÁW“¬Áfg\ÁuN£Á‚$_Á‰ªöÁ‘;ÖÁœ»êÁ•±Áz8Á…Ý_Á|ŠÁmlÁ^f³ÁOmsÁ@y9Á1œ£Á"ÒwÁ¿ÁdëÀíöÆÀÑcÙÀµ$ñÀ™XºÀ{EqÀEX­À¾¿¹ÚŒ¿4äs<ôb¢?;ŠŸ?²eç@¦ã@%[’@E@_o+@rÝ»@€O^@…Ù@‡Ì/@ˆšy@‡À@ƒ’m@{»ì@k«Z@VÃâ@<¯&@•?ö¿rn7¾êX?±6?­¹¸@õ@+Ÿf@Q“g@sóò@ˆ.@’¸@šÿ@Ÿž–@¢¾@¢~8@ çç@ÄO@˜ ˜@*w@ƒÂ¿@k©P@J…^@$^'?ö?š>À>åM¾®mv¿“ß`¿þú°À5}¤Àm[KÀ“AÀ¯ÛYÀÌÖµÀéÕàÁƒÁ^Á!ZrÁ0bÒÁ?kvÁN€ Á]SÁl¾%Á{ë¾Á…“ßÁ¸¦ý?”¿A?øåQ@))@Uh@{ô¶@@Ÿ @ªÂ@³0@¸—@»º1@»[@º·@¶Ž@°§ä@§€ˆ@›'å@Œ/û@s©X@Iê¤@™á?Û2?lhM=Öœ÷¿>Ø0¿ÌÇ%ÀzÀVâkÀˆl§À¥–ÞÀÂÚ¡Àà‹7ÀþJÁ÷ÁÿÁ,}Á;RLÁJ•§ÁYàŒÁi,aÁxˆ)ÁƒöUÁ‹ª·Á–ÒùÁnÁ‡[ÍÁC&ÁoÛÄÁ`€ÁQ$ŠÁAОÁ2…9Á#J¾Á*Áá–ÀëuÓÀÍ”<À¯ÖÏÀ’bÀh·èÀ-ŠÙ¿è¥ò¿lÐ5½Ï?O‘B?Óe@~@NXà@{$'@’À®@¥¨Ë@µ:‘@Á~Û@Êç@П @ÓÕg@ÓÕ|@Ò&j@Ï ’@È0,@½Ä¢@°ÿ @ R1@Œ ?@lÀ@=Õ@@ ä?«6ü>ü™¾¾¨å¿ OvÀ êÀBÅÀ}s‡Àœn+Àº$CÀ×ìæÀöÁ *×Á^îÁ(¦ÙÁ7ñíÁGEÁV¨Áf GÁupíÁ‚lØÁŠ%˜Á•»ÁT®Á…“³Á{±Ál;½Á\ÆŠÁMQXÁ=ß¼Á.‚Á4gÁèßÁŸ—ÀâÔ{ÀÄp8À¦I>Àˆ5ÙÀTêÜÀnÖ¿¼©j¿“Ú>©ƒÝ?œ®(@6@;=@n¶@@¦Ø@¹Õ@Ê;ø@× C@à}@ç @ê±ü@êüt@鼚@æb#@Þ=@Òß#@Ä,ô@²6ô@&J@…àÄ@XÌü@$q²?Ûe?XqĽ/.¿oÉ¿ìpÉÀ1D8Àl£CÀ”?!À²†sÀÐàˆÀï:œÁÌàÁåÁ%mŒÁ4Ï]ÁD1oÁS“ýÁc¡Ár‡¶Á òÁˆÒ<Á“ŽåÁ‹¾)Áƒñ?ÁxQÀÁhËéÁYP0ÁIÕOÁ:]jÁ*æåÁp`Á pÀùSfÀÚ¡‰À¼@À|¡À~€ÂÀBHSÀœ¿”È?¾uB:?.§ƒ?ÊÄ@%Q@U§¼@…ßÅ@Ÿ–ˆ@·£[@Í@Þ @ëŒ@õ®@ü^OAuAk @ÿ«À@û0æ@ñ¨q@äÏå@ÕY‹@Â%Ô@«Û—@“+ç@qÔ@;e!@ˆÚ?”Þ>€Lè¿)猿̾À!ÚåÀ]¬À.ýÀ«ÁñÀÊUÀèñIÁÌ:Á7Á"£iÁ2 ÐÁAq÷ÁPí>Á`xåÁp 6Áœ¸Á‡™zÁ’ úÁŠ:ŠÁ‚i›Áu1WÁe—ÁUú¸ÁFræÁ6öïÁ'|Á/Á†NÀò3ÀÓ6À´ÀÀ•ÒÀnoÒÀ1Db¿é”L¿cS=Q®?{«±?óøÇ@3÷…@m%K@’gÿ@­p@Æòû@Þš;@ðž©@ýÛBA=’A(A ÊA OA ÁqAmÐAá@ônp@ã̵@Ïζ@¸Ýî@Ÿ>R@ƒã@OA­@ó^?· ]?¾ßyä¿°_ÀoßÀQˆÀ‡'@À¥Ã…ÀÄ_ÉÀã!ÃÁýKÁo+Áá Á/TIÁ>ÓGÁNb”Á]úåÁm“lÁ}+òÁ†c Áy¼Áˆ«ðÁ€âDÁr4wÁb¤ÁS#ÁC`uÁ3ųÁ$7ZÁ·ëÁBÀë˜öÀ̧åÀ­¶ÓÀŽÅÂÀ_Ó-À"¸ ¿Ë2¸¿!·°>¤[$?¡*b@ w6@G>à@€ÓZ@k·@¹#…@ÓÝ¢@íhA†›AƒSA Ç A¹ AÖ2A@ùA[A ä•Añ#AÚü@ð›|@Ü„@Ä3u@©'b@¿@`ˆ@%ã±?ÓÜ ?7|J¾e %¿– âÀÃÀDÿÀÀŸðÈÀ¾Õ‹ÀݺMÀüŸÁ ÁéÁ4QÁ,·§Á>Á9ÖÁIuÎÁYÁhºÁxg‹Á„ Á´£Á…âgÁ|%ÁÁlhÁ\ÌÜÁMÁ=x¥Á-Õ{Á4=ÁšÀþ÷ÀÞåóÀ¿ã›À ùàÀü„ÀEþQÀ™¿”×¾SLŠ?@Ö?Úax@)@eÒ¿@Õ|@­ô4@Ê—“@æ%@ÿ¢¯A ñA‹çAü}A<…A ‹âA!{AäA%YAŒA ¦A‡e@ðÚü@Õî'@¹¡²@œ*O@|æz@@ͧ@l&?YÍ>&kæ¿K·ð¿ánÀ.'rÀkÎ÷À”¾ìÀ³²6ÀÒÜâÀòÂÁš³Á3»Á'Í>Á7nýÁG ÁVÎDÁf€}Áv2·Á‚ò‰ÁŒ‚ŸÁ„¢Áy†ÁiÍqÁZeÁJjfÁ:Á»Á+3Ás Á ÐvÀøZ™ÀÙFÀ¹ÏQÀš°öÀw¦NÀ:…¿øÉx¿zÊn¼^«?q?òŠÿ@5ó¼@r@–÷O@´1z@Ч×@ì%AÜ{AX3AîAZA#dÈA%‚úA%œQA#¢$A3A%A…oAïg@ø·’@Ýa-@À6³@¢µw@„¦ñ@M@"k?¥öê>®/ ¿½¿ÊáÁÀ#O°Àa.ŸÀ·”À®í ÀÎ"}ÀíWòÁFŸÁà8Á%ƒcÁ53ýÁDíÊÁT§âÁdaùÁtÁëÁ‹oÁƒFÁwbÁg§VÁWì­ÁH2Á8w[Á(¼ÅÁ°Á I Àó!¸ÀÓÏ À´¨\À•’ÛÀlÿgÀ.Ù¿â‚Ø¿Ow)>OÍ?ψ@bÓ@A³@}¶ê@œ«B@¹ƒ@Ö.½@ñn¿A”bA!’AкA!ÝSA'EA)…A)D«A'ŽÎA#dÅAmxA€cA z @ÿ/ç@ã±Ò@ÆR§@¨i%@Š€"@X›@Î?»Õ>ÿM˾î¡%¿·$Àd\ÀW—?À‹ñÀªL°ÀÉ‘nÀèÖ,Á ôÁ¼ÞÁ#u¯Á3.ÒÁBçõÁR¡ÁbZ6ÁrMÁ€æŠÁЉ=Á‚Ÿ+ÁulUÁe ¦ÁUܾÁF Á6cüÁ&¨"Áî‚Á4ûÀîöèÀσÚÀ°ýÀßwÀc¢ÿÀ%‡•¿ÎØW¿%:¡>¡P"?£¤@ò @LVA@ƒéX@¡¥Î@¾€y@Û<@öuHA:¿AðžA®IA$Ì,A*JµA,±ÎA,{ªA*ÅrA'2A  AP£A ï A@èðü@ËGB@­ŽÇ@Q»@a·s@$ºt?Íûä?$ˆš¾¥Í$¿¥*ßÀÓïÀOA<À†×DÀ¦ êÀÅDÿÀä™”ÁÁ·òÁ!pßÁ1)õÁ@ã ÁPœ#Á`U9Áp¸ÁÌàÁ‰˜˜Á´\Ás¡\ÁcÙÿÁT¢ÁDKEÁ4­Á$±ƒÁíþÁ1ÝÀêëŠÀËsxÀ¬|ÀŒqÀZ¦¼À‹ô¿½s¿¾K>æ±2?µ7¾@œË@Tà@ˆ4{@¥ÄË@Âöˆ@ßu6@ûbA LACA )A'PßA,ŒzA/2A/LA-«õA)Á˜A"Õ­A`”AÙ A½@í\x@Ð^@²?D@“¸-@jb,@,å“?Þtq?F;{¾Aǵ¿”´‡ÀÞÜÀGctÀ‚ôÀ¢6RÀÁxŸÀàÇ/ÁÐÁË ÁFÁ/3Á>ç¼ÁN™©Á^PžÁn ñÁ}ÐtÁˆ¼žÁ€ÒŒÁqÑ0ÁaýŽÁR+xÁB`fÁ2ž/Á"ßÁ# ÁihÀçg—ÀÈ?À¨»9À‰ŠxÀTÄ!ÀD¿°wÙ¾Ïàö?ëŒ?Âð@:@ZX“@‹ Ê@¨æ@Åÿ”@â¡É@þÓA 0›AÍÇA!ÉïA) 5A.afA19XA11A/î3A+ëºA$ÈAÊA’Aëº@ñ]Ê@Óêö@¶@—¹¸@ri€@4®+?í¹?d+°½˜Öw¿…›÷ÀP¼À?Ó|À~V<Àžl~À½­ÞÀÜøžÀüL$Á Ò™ÁÁ-0)Á<ßMÁL“~Á\O<Ál|Á{ÔJÁˆåÁ€,…Áp~Á`ÃeÁPú¸ÁA23Á1i­Á!¡pÁá Á.ÛÀå7ÀÅÉËÀ¦…ÜÀ‡BvÀP‡À¿?¿§K¾±S?î>?ÈçŽ@! {@]Âè@Œ•@ªB@Çgü@äý@ÿ|gA °¤A’A"åA*€)A/¦¤A2¸×A2ÐMA1xA-“vA&7³A—CA>Ax.@ôÅí@×o½@¹`’@›N@xŠ@:ùÀ8|cÀw'ÀšÚõÀº)WÀÙw¹ÀøÆÁ GÁ»7Á+z)Á;=–ÁJ÷eÁZ£OÁjXúÁz«Á‡’ƒÁWdÁouÁ_ÎnÁPáÁ@Q„Á0€4Á ¯ëÁçÂÁ-VÀã ­ÀÃÒIÀ¤¨?À…‡¸ÀLÎaÀ³ö¿¢Bk¾œs§?&|¨?Ì@"zÚ@^‹@ŒÙX@ª^Ð@Ç‚¤@ãí'@ÿLÁA ‰}A——A#5aA+PäA0{¥A3”¾A3öqA2ѱA.º®A'uŸAÛ8AePAÊë@÷\ˆ@Ú3d@¼"#@Ûý@~„ó@A$‘@Ä0?ŒYI=þŸ¿Y Ñ¿èôÁÀ2² Àpé¹À——À¶Ö|ÀÖ.ÈÀõ‡$Á oÁÁðÁ)È!Á9xÁI4ÁX÷5Áh¼ÁxƒŒÁ‡ŠÁ~[Án‘yÁ^Ï ÁO²Á?dêÁ/³tÁ ýÁP†Á”ÀáÉÀÂVÀ£ŒïÀ„|¸ÀJÿðÀ sq¿ ¤-¾ši{?&‘¥?ˆN@!Žø@]G·@Œ9@©‚ñ@Æ”O@ãý@þ-ØA ŠA8ŸA#aA+…¡A0ÑWA4A4Ä A3ÅöA/à§A(ŽA zA¥A É•@ù1E@ÜQ@¾}`@ 3Œ@®Æ@F”@G‘?”ñ>J˜´¿D±ç¿ÞÈ·À- ÀláÀ•@èÀ´y_ÀÓ¸Àó ÒÁ 4ýÁìŒÁ(¤ZÁ8\(ÁHÁWÌùÁgˆÏÁwLÁ†Ê™Á}ÌÆÁn Á^JéÁN“ÀÁ>åAÁ/A¿Á£áÁOÁd½ÀáŠVÀÂX;À£pºÀ„ÃzÀL,ÀÒG¿£{µ¾ª`p?–ú?ÆJŽ@™p@YÍ{@ŠOK@§¨„@ÄïB@á\–@üÚ$A erA}"A"GA*þzA0’mA3ÈÈA4ýßA4}A0[,A)P|A AP\A e @úƒß@ÝǨ@¿ÍŽ@¡©”@ƒó]¿7e;¿×âÀ*) Àh”±À“€,À²µ·ÀÑë Àñ!ÖÁ7äÁêmÁ'£>Á7_ÚÁG$fÁVé}Áf®“ÁvsªÁ†ª?Á}“àÁmÛ¸Á^-ÒÁNŒgÁ>óÓÁ/[ðÁÄÁ,,Á”IÀáøÐÀÂÜÀ£øÖÀ…€ÁÀN:»Àsô¿©ZZ¾Ã‚ï? ¢Û?½y¡@ @TÝß@‡Í>@¤é@Áè!@Þ#K@ùÖ#A +A€A àA)´>A/|.A2©ÐA3ËrA3—÷A0% A)M÷A 9þAøA N@úA•@ÝÝ@Àc}@¢%»@ƒ¶ @JW@ Äî?žŠÑ>Þ¿0ñà¿ÔU×À(HÞÀf€ÅÀ’{@À±·SÀÐófÀð/·ÁÀ#ÁnÅÁ'!¨Á6ÝzÁF )ÁVgûÁf0îÁuùáÁ†åéÁ~œÁn^¡Á^ª¯ÁNö½Á?BèÁ/”Áô]ÁiÃÁúšÀã5-ÀÄuCÀ¥µXÀ‡+ÍÀQÆ&Àƒ¬¿²«´¾íZ>íûº?±Ñ2@È¢@N}˜@„@U@¡D@½ü4@Úm@õ~A½ÿAÁqAwˆA'0™A-!A/‚ A0cA0™rA/+A'¶cAtAgA¸ì@÷×A@Ü#˜@¾òl@¡z@ƒà@ID@ ¼?->†B~¿3õÝ¿ÕÁ”À(íOÀfùÔÀ’ƒ}À±§ÀÐùÀðWçÁÛ&ÁŠYÁ'9ŒÁ6è¿ÁFšÖÁVTlÁf_Áuâ4Á‡6ZÁ~½pÁosÁ_wÕÁOÜ$Á@@wÁ0¤ËÁ!Á‹Á!rÀå}úÀÆá„À¨|±ÀŠ%#ÀWïóÀž¿ÀÁ¿–>³ »?¢µ@ uñ@E Þ@u|@œR…@¸¶+@Ô¥7@ï¤A‘AC%AwûA"¦VA(7 A*‡`A+leA+”AA)ØÒA#]AA×…A;A¸Í@ò¯Æ@×ÂÃ@»C}@ž92@€5<@D:Æ@™X?•bþ>Y…¿@Š;¿Ûé¸À+îîÀj‹À”PÀ³ZÀÒ1’ÀñK¹Á=oÁê`Á'¤rÁ7azÁG ÁVÜ¡Áfš5ÁvXžÁ‡àâÁ€9Áp{ Á`×ÎÁQ4|ÁA‘+Á1ôŸÁ"kYÁûaÁ¨ÀèáÓÀÊvYÀ¬ àÀÇOÀ_¨sÀ#¿ÐOì¿5P?>Wýd?‰<@™'@;m¯@t|@–¾¿@²ÒU@Î^@è5 A4bA !!A~QA=A!RsA#£¸A$‡ØA$ÁîA"ûAAH´A-A ·AÜŒ@éå8@ÐAÀ@´Íˆ@˜y]@v¾-@;LÞ?þâ²?†«!=ƪ‰¿\‡•¿èò>À1ÐXÀo:ÅÀ–¦iÀµÏ`ÀÔø¢Àô!åÁ ¥”Á=’Á(ß{Á8~ÁH#‚ÁWÆÁglÝÁwšÁˆ»ÍÁ€ð¥ÁrJûÁb´­ÁS^ÁCˆÁ3÷GÁ$uÑÁ†Á¶_Àí‡ÀÎðÀ°ÉÃÀ’¤âÀi|qÀ. Ö¿å:w¿_çÖ=áÇ?q¸Ó?ësD@.Ý@gÊ@­@«@Å… @Þˆ–@õV AÑÿA IUAL—AóAYAA A7ÂAº×A“A%‹A¾@ô­_@Ýû@Å`ì@«S¿@R²@h&U@-âÛ?å÷ ?^Àž½“³¿‚›•¿ûþÀ:¹ñÀx, À›pÀ¹ðãÀØÞUÀ÷ËÈÁ \«ÁÛ&Á*m•Á: ŽÁI®ÁYR„ÁhöÁxš}Á‰ÀñÁõÊÁtUQÁdÃXÁU9‚ÁE·Á6?ŠÁ&àÝÁ¢‰Á…ÞÀòÙÀÔ§FÀ¶‹âÀ˜ŠÀuÒÏÀ:×+¿ÿòW¿‹(¶¾5=»?;Rá?Î,À@DÞ@Wü@†Ûî@¡a/@º¶o@Òth@熇@ú“ÓAA 1AÜkA%]AXA¹AðwA Ä`AáD@ùZ@å^š@ÏtL@·Ü @Ÿ$S@…G[@SÓ“@6?Åaæ¡?©3@ 7÷@Biº@v‡k@•&l@­r‘@Ãrò@×~¿@éS@÷‘†A‡AÿAÛÐA„…AF•Az÷Aáð@ösq@æ`‘@ÓÆ"@¿A@¨¥˜@µª@oQ‘@; i@2?šèƒ>¥óT¿ƒW¿ÀõÀØ•ÀUÙ¨À‰¶À§J½ÀÅ€ÄÀã³2Á×Á}±ÁæwÁ/S2Á>ÂêÁN;FÁ]ÆÁmV«Á|çøÁŒ*µÁ„hÁyW÷Áiò6ÁZ¢œÁKn,Á<[%Á-WuÁUÁTtÁU×ÀâЋÀÅ}À¨bÒÀ‹OIÀ\¨QÀ#Ê¿ÔÞ¿G=ή?wšŒ?éhŸ@);C@\v@†\<@µ«@²’H@ÅUi@ÕÁŸ@ä4‰@ï[J@ö¥ø@ùöj@úÆÛ@ú2–@ölc@îu0@âN-@Ò@ÀŠO@¬¼@—Vj@€s@Pƒ @àš?ÓŒ¢?Pø’½@pÉ¿n‹…¿èvvÀ.¼ÀgñÀ‘DBÀ¯<€ÀÍ^èÀëOÁÑÛÁëÁ#+VÁ2ŠÁAïaÁQT"Á`¸âÁp$³Á¡~Á´íÁ†DÁ|Â8ÁmŽ•Á^vEÁOx[Á@q’Á1h¦Á"_ºÁnyÁ¸øÀìeúÀÏcQÀ²kÀ•wÀqà…À9.ýÀ”¿Õ·¾^m?ÑR?³3¬@ œ@=g"@køS@‹¨*@Ÿ”M@±fÖ@Àæ¾@εf@Øÿ‚@ßÊX@âô‡@ã¢ý@âù@Þˆ~@ÖØ@Ì›@½tÔ@¬Þ@™@„`c@];m@.Þ,?ü¾Ï?—ø>»¾ñ·[¿¨æ®À ÜŒÀDxRÀ~=Àœ“À¹ÏÀÖIïÀôÊÁ Á ÐÁ'ŸÁ6$ÿÁE[vÁTªÔÁdÁsbÁbýÁy Á‡ÞÁ€N€Áq™ÁbœÏÁS¡JÁD Á5Á*Á'ËÁ¯Á ö ÀöçqÀÙòÄÀ½mGÀ¡>À…!ÀR ˜ÀPà¿Åœ]¿2.=÷–Ø?kt?׋¿@£U@Fɽ@oÓó@н|@›³@ª?@·*@À¥Y@Ç4ì@Ê3@ÊÕ@É*Â@Äæ+@½¿t@³F¥@¦jœ@–S@ƒÕd@`[d@6„Å@ š?·%È?'él¾­Y¿q<>¿âûÀ'pJÀ^•ÀŠøèÀ§h›ÀÄhmÀáo´ÀþŠÅÁ ÕÁ“tÁ+‡ªÁ:”úÁI¢zÁX³lÁgß0Áw"0Áƒ3øÁ‘€Á‰þ]Á‚}ÐÁuúŽÁfÿ2ÁX%ëÁIy¬Á:ä Á,N³ÁÄÁs˜ÁJ;ÀæC]ÀÉþñÀ­â À‘ñqÀl6äÀ5æ¿ÿ# ¿—; ¾À4>ʤ?‘+4?ê#Ñ@V¼@Dò@gå\@ƒ­@‘²å@žµ@¦ø‚@¬ªÄ@¯ÓÃ@¯þm@­Í¹@©’N@¢ü–@™nw@Œæ/@}cÚ@Zç—@5W@ YA?Å‹?WËî=àd|¿)Ó'¿¸uÀCÿÀE>FÀzÁæÀ˜öÀ´¤ÕÀб§ÀìëÞÁä Áv?Á"ûÁ0¢Á?`ÁNAÁ]4mÁl6bÁ{DHÁ…4_Á“ÖÿÁŒVšÁ„ÛŠÁzáeÁl2«Á]›§ÁO¶Á@saÁ2Á#ÞÁ¶–ÁŒ™ÀòÅšÀÖÅÀºý6ÀŸ—_À„ˆ°ÀS¥µÀ÷Ä¿ØM'¿mÞ‚¾@e~?Hÿ?–p½?äZ@ê¸@7'?@U?@p5Ç@ƒl@‹ö-@‘Z@”aA@”UH@‘Œ1@) @‡W@|¹@f@@KÞè@,!ë@ Ì?æ?dºI>_ä ¾õµ­¿œº‚¿þÍ}À1¤ÆÀe1œÀÀ§ÑÕÀ³´ÀÞQÀú\ýÁ =,Á],Á'»¿Á6IQÁDàñÁS—“ÁbfFÁq6áÁ€ØÁ‡z8Á–RmÁŽçgÁ‡Œ Á€@#ÁqéŠÁcfrÁTöFÁF¨ Á8\âÁ*/†ÁÏÁ ,Á@»ÀåÄÀɱ«À®ƒîÀ“âLÀsRwÀA6¢ÀBº¿Á™Ø¿Ne|¾™>õ\?ˆ5?ÌsÀ@S/@!hÀ@:—°@PË@`Qó@k:€@pE<@oØT@iÓ5@`öq@USv@E>Œ@0‘@—?õR|?³*ß?T8>MHó¾àö¾¿Ø}¿ê YÀ$Ê•ÀUSïÀƒãÀqÀ·XÀÒTìÀí"kÁ<ÁÐÁ )ÒÁ.<çÁ)ÁM™Á?ÎÁ1Á#TÁPÊÁ–8ÀóâÀØÕÑÀ¾¬ºÀ¤µíÀ‹{§Àe?<À6à™À –Ù¿½)w¿X„Ô¾tž°>™Ç_?Nó?¢.c?ØMN@ìŠ@]¡@(1…@3.@7@5é-@/<@&œõ@°å@ ¥^?ó)?Æ„3?ă?"=¸Oð¾þF¿‘¬p¿ãújÀx}ÀKš“À{s¥À•ÐðÀ®õgÀÈÝÀâWfÀüûùÁ çôÁ]ëÁ'0ÃÁ55ÅÁC:ÒÁQBšÁ_Z!Ám©ðÁ|-¸Á…nÁŒÓ&Á›å¯Á”¨ÄÁkÙÁ†5½Á~+Áp°ÁbSÁSý™ÁEý¦Á8.ÔÁ*dÁ±ÌÁ;|Áë±À髼ÀÏÈ6À¶—²Àž»À†£\À_¨ À4m=À v'¿É?¯¿ ô¾ùÕ¼ %Ý>à¦Ñ?V¶ü?—Ȇ?¾Ô˜¬ƒ¾)á¿*7œ¿ž+¿ëøtÀNÀH”ÆÀuzŽÀ‘IÑÀ©@¢ÀÁhêÀÚK€Àóð"ÁÜÄÁ÷Á!H=Á.ªÀÁú¬?´j?QCœ?w.??ƒj¬?€%ä?dÛU?B¢?æd>Çö>çc¾6ã¿ ø¿yeS¿¼HFÀ3À$õ2ÀLÀñÀu¤”ÀKNÀ¦Ÿ‘À½SÀÕgÀíCéÁƒÁ©àÁžÁ)»?Á6èuÁD5ÁQ¢ºÁ_zYÁmöÁ{ˆCÁ„ÈXÁ‹Õ˜Á’ðÜÁ¢'õÁ›àÁ”œÁ Á†hÁ~ÁpOnÁb¤ÁUTÁG„œÁ:#TÁ,ÿsÁôÁ*ZÁÑjÀõkÀÝ£šÀÇ:„À± zÀœ^ÀˆìÀjãÀFµÀ&;À¶ó¿ÕÎw¿¡ó|¿f‚—¿ y¾ž¹½ÇìD=lq=´Sì=ŠÖº½©‡¾0ß`¾«<¯¿h¿E+¿‡÷|¿´T²¿èg™ÀÁÀ2íÀUÞ>À{¤IÀ‘Ï~À¦O½À¼M±ÀÒÛÀémõÁ†-Á ”LÁü`Á%rÅÁ2D•Á?n´ÁLžEÁYÐ*Ág*ÎÁtÖ{ÁZ©ÁˆXhÁ\˜Á–hðÁ¥£sÁžš–Á—•#ÁšÇÁ‰´*Á‚ÝùÁx¤Áj……Á]~ÁO¯óÁB­†Á5ÈZÁ)¥Á¼cÁiøÁ¼¢ÀóŠÀÜ®'ÀÇnÀ³xÂÀ 0ñÀéóÀzÀZ\5ÀIÁ@DÁ ÛÇÁ,´UÁ8¨ÁEŠÁQw“Á^_ÁkmÁx(YÁ‚­yÁ‰SeÁgÁ–ÛœÁµÁ¬àÁ¦éÁŸ)ÎÁ˜OÁ‘Š ÁŠØñÁ„3ßÁ{V¿ÁnwgÁa¡7ÁUÁHĉÁ<§§Á0êÁ%|lÁg”Á™³ÁnÀ÷OÀãÎ?ÀÒ ‹ÀÁëÀ±œ…À¢€*À”¾¦Àˆ6‘ÀyÀdÙšÀSSSÀDL5À9<®À2¢íÀ/À1µüÀ7§‹À?€eÀHÙÀT8õÀb¸ûÀrjîÀƒ7<ÀØèÀšœ=À¨jdÀ·ÈÀÈ·)ÀÚZ’Àía«ÁˆÁ ´2Áx%Á jðÁ+s¢Á7qÁBíJÁNÚOÁ[RÁgŽvÁt''Á€‘Á†ÿ‰Á5Á”5‰ÁšðjÁ¡¸NÁ°Ä˜Á©éÔÁ£ˆÁœbKÁ•¾ÝÁ'ÔÁˆ¦4Á‚2ÒÁw’\ÁkÚÁ^æTÁRÑ ÁGUÁ;ŒPÁ0†ÜÁ%®<ÁSPÁ]äÁ‰æÀüø?Àë¦ðÀÛ}ÀÌ#³À½É À°rsÀ¤`cÀ™[ÇÀGæÀ‡À€+6ÀuuoÀo±²ÀlοÀo EÀt@6À| šÀ‚yUÀˆ$¦À!šÀ–ð1À W Àª©À¶”,ÀÄÀÒ+7ÀâÄIÀóÙâÁæ&Á ¢Ár¦Á àIÁ+¬oÁ6—ÉÁA¸ˆÁMN¤ÁY)ÁeÁq:iÁ}¦Á…!0Á‹‰Á‘ú-Á˜{÷ÁŸ"Á¥ÐÉÁ´´»Á­ò³Á§IïÁ ²ïÁšÛÁ“¡Á-hÁ†Ë>Á€–yÁu ÁhûIÁ]CˆÁQ»ÁF¦#Á;ÅÅÁ1\,Á'4çÁgáÁ>Á eÁèëÀõûwÀçòÀÙ2àÀÌÏÀÀß#À¶À¬Ú(À¤¹bÀžO™À™RyÀ–k À•8šÀ•ùÄÀ˜ˆ>ÀœVDÀ ÛÿÀ¦YHÀ¬ø[À´¬À½8ÀÇ»ÍÀÒ²ÀàŽÀí—¬ÀüجÁôÀÁ‚zÁÒ[Á"–¸Á,zÁ7ÈÁAáïÁLÅÁXÁc—:ÁodæÁ{T²Áƒ°»Á‰ßÁ.ÌÁ––œÁåÁ£ugÁª¶Á¸Ú³Á²<¦Á«ª@Á¥aÁž›ÜÁ˜,-Á‘ÙÁ‹¬ Á…—áÁ&'ÁsrÇÁgþqÁ\É"ÁQß\ÁGmIÁ=AÁ3PÁ)ØÒÁ ùÁhBÁ çÁ aÁyKÀõI½Àèõ˜ÀÝzÍÀÓ)'ÀʇÀÂòÀ¼sûÀ·ñ+ÀµãÀ´ ÔÀ´meÀ·0åÀº¦¼À¿L§ÀĨŒÀË ÀÒ~tÀÛ%hÀäÖZÀï£ Àü—ÁÐ?Á ß§ÁGÁ™¥Á%M³Á.ÝúÁ8¢¯ÁB¤”ÁMONÁXŒÁbù–ÁnQ­ÁyæÙÁ‚ÐZÁˆÉ¥ÁŽÈÿÁ”íŒÁ›ÁP‘ÌÁHYÁ@€ÁÁ9 ýÁ2FÁ+zWÁ%&·Á©·Á‹ûÁørÁâÃÁœµÁ ȲÁ ÒÁʤÁSòÁT}Á ¦‹Á <Á eØÁìCÁä¦ÁpcÁhºÁÅ¥Á#ÁCÁ)5”Á.÷ÙÁ5½Á<ÐCÁDqöÁL›jÁU¢Á^EÁgz¦Áq2žÁ{0ÙÁ‚ÆÅÁˆdÁ{#Á’÷qÁ˜«ÂÁžuÁ¤FRÁª;mÁ°6:Á¶H Á¼~ÇÁʬœÁÄhÁ¾?+Á¸ËÁ±ÿÁ¬•Á¦=ÝÁ ’‚Ášè™Á•WôÁÁŠÓÙÁ…½žÁ€ÓnÁx#âÁo TÁf2tÁ]êiÁUפÁN=ÉÁFð˜Á@²Á9œÁÁ3™IÁ.A?Á)Y,Á$ÇÁ!eÁÐ Á&ZÁi­Á@[ÁÚ‘ÁÝmÁ»Á˜¡Á®XÁ:ÉÁ"žÁ%ŠëÁ)^7Á-¿TÁ2oøÁ7Þ·Á=^mÁC¼¥ÁJÌžÁR ÔÁZIÁb=tÁjßÖÁt!Á}“îÁƒ¬hÁˆÀÁð­Á“FdÁ˜ª Áž+ˆÁ£àÁ©¨oÁ¯xÁµkÁ»e(ÁÁqÚÁÏ„þÁÉ`ÁÃ>‡Á½'XÁ·4WÁ±iÁ«»Á¦5Á „)Á›"øÁ•ëTÁÑÁ‹ß¹Á‡ ¤Á‚naÁ{ü»Ás{µÁkYMÁc‚‡Á\ ¬ÁTÙªÁN7PÁGá[ÁB4&Á<á‹Á8&]Á3»Á0B\Á-jÁ*ŽLÁ(ÏkÁ'¶Á'fÁ'gÁ(›HÁ*‰Á+þ¢Á.Á1VªÁ4¿Á8m•Á<¹0ÁA8ÕÁFŠÁKùÁQî¬ÁXÎfÁ_á4Ág‡/Áo¬½ÁwíŸÁ€iìÁ…%Á‰ÖôÁŽÈ7Á“éÝÁ™—Ážp<Á£Ý&Á©c_Á¯Á´ÞüÁº­ŠÁÀž*ÁÆ—¶ÁÞî ÁØÎzÁÒ»~Á̶äÁÆÔ¡ÁÁ&Á»C#Áµ¯õÁ°LšÁ« Á¥ÜQÁ ÙTÁœ+Á—€•Á“AÁŽ·ºÁŠ yÁ†ÈÁÁƒ-ôÁdPÁxõWÁrì¹ÁmI¹Áh‡Ác„ÊÁ_AÁ[ËGÁXFÁVáÁS¿ÁRkÁQv0ÁPç[ÁP{áÁP¦òÁQ¨HÁR÷µÁTÐFÁWœÁY˜æÁ\©ºÁ_éæÁcÒ ÁhúÁlärÁrOÇÁx§Á~i Á‚†2Á†#@ÁŠòÁøÁ’7õÁ–¨‘Á›&±ÁŸâÁ¤ÞÁªÁ¯qˆÁ´Ï{ÁºFðÁ¿ë€ÁŹMÁË¥óÁÑ–°ÁÚ ÁÓÎàÁͰ½ÁÇŸ°ÁÁ™Á»µØÁµßcÁ° ŽÁªCÁ¥34ÁŸüÁšÏÝÁ•ÛŸÁ‘&òÁŒŽÁˆ"çÁƒ÷hÁÝÁxiÁqiµÁjŸ\Ád}èÁ^¡CÁY=ÁT„ˆÁP)qÁL‰äÁIA“ÁFŸ³ÁD\ÔÁBçxÁAæiÁAMwÁ@ß‹ÁA ¦ÁB3ÁCnÁER.ÁG¹ ÁJLnÁM’ÀÁPâÉÁTòmÁY;òÁ^`ËÁcÏšÁiÕžÁpVpÁw9GÁ~Ö€ÁƒPÁ‡r Á‹Û_ÁNjÁ”óýÁ™à.ÁŸ nÁ¤dÃÁ©Â©Á¯3ˆÁ´Ô3Áº ÍÁÀŽMÁÆ…SÁÌ„öÁÕV+ÁÎöÄÁȵ5Á”ZÁ¼ƒãÁ¶{9Á°—ÁªÁÿÁ¥2ÁŸwhÁš!ËÁ”ï–ÁË9ÁŠç©Á†8¥Á¡ŠÁz®fÁrpÂÁjvÁcq`Á\{ÅÁVªÁPîÁJÁE™ØÁA#ªÁ=HÁ:>Á7FÁ5Á3dÁ2Z?Á1³¾Á1M0Á1€Á2r Á3ïæÁ5ÕÅÁ8b¤Á;¶Á>{ÆÁA÷ßÁF%­ÁJ ùÁOæöÁUkÁ[À×ÁbU4Ái£ÌÁqiÔÁykCÁXÁ…‚VÁŠÀÁŽï#Á”˜Á™]™Áž¶Á¤ ×Á©½Á¯‰™Áµ|Á»zWÁÁ}¾ÁÇÖÁÐÕ~ÁÊQøÁÃêwÁ½¡ÿÁ·{¨Á±hÁ«]”Á¥xEÁŸ¨¥Á™ïgÁ”fíÁÛÁ‰ä{Á„ÉâÁóÁv–ðÁmŽ÷Áe2©Á]“ÁU|ÁN~­ÁGÌEÁA0Á;äÁ6¾>Á2-‚Á. }Á*×Á'îüÁ%¬HÁ#â¶Á"ÎðÁ"hÁ!Ê Á" Á"íÚÁ$}#Á&eØÁ) §Á+ã¬Á/dÌÁ3(ÖÁ7\DÁ<0ûÁAxÓÁGDÕÁM³ÁTŒzÁ\7-Ád ¾Ál‚ÕÁumèÁ~ŽUÁ„ zÁ‰¬ÁŽaæÁ“°mÁ™ÍÁž­DÁ¤y“ÁªpÓÁ°qÁ¶wÆÁ¼ŸšÁÂè™ÁÌkÁÅ݇Á¿VNÁ¸æcÁ²–sÁ¬jÁ¦OÔÁ @»ÁšZnÁ””ÁŽãƒÁ‰`*Á„Á}²ÀÁs˜ùÁjxÁ`ÍoÁX xÁOÆ™ÁGÄÚÁ@„×Á9¯3Á3;ëÁ-:CÁ(Á#HIÁîÁ¬ƒÁ¦†ÁTÆÁdýÁD®ÁEÁJ‘Á¤¶ÁŒÁ rÁ)Á¹½ÁÎ#Á SoÁ$aÁ(§ÑÁ-ɉÁ3+÷Á9QåÁ?ŵÁGxÁN̲ÁVõQÁ_ØSÁhûêÁrdœÁ|miÁƒm Áˆ¶ÉÁŽ[Á“¦¾Á™ríÁŸh±Á¥gÞÁ«sJÁ±£ÂÁ·öÊÁ¾hÑÁÈíÁÁs™Áºå‘Á´]CÁ­ë3Á§”Á¡a.Á›?”Á•*jÁA´Á‰…„ÁƒÚfÁ|¹BÁrÜÁgžZÁ]¨êÁTOþÁK&€ÁB£NÁ:jŠÁ2 BÁ+§xÁ%³Á¼ËÁUçÁcÁ|Á ƒëÁ rûÁû!ÁñçÁÍòÁ óÁÑÃÁ>}Á,£ÁÜúÁåòÁ zKÁ ¾„Á] ÁšdÁ»ÁkœÁ%©Á+oúÁ2/†Á9Â~ÁA“hÁJDPÁSjÜÁ\´’Áf¥Ápò Á{ƒØÁƒþÁˆ¬GÁŽwÕÁ”g“Áš_ÚÁ p£Á¦ªÉÁ­ Á³ƒlÁºgÁÃÏÁ½«Á¶¢Á¯íšÁ©dCÁ¢ñåÁœ›Á–b¿Á9,ÁŠ€Á„2HÁ|÷‡Áq¢ÞÁf´¤Á\úÁQžKÁGØ(Á>nÁ5“$Á-?ÆÁ%ùÁ¢Áç\ÁÁ Ã)Á‰©Á7ÀúåÀô”ôÀïRyÀëEÂÀèòüÀçÀæÇ‚Àç°‡ÀéØUÀí;aÀñ¥ÍÀö´2ÀýŽÁ‹€ÁÓ+Á ³YÁ$¼Á< Á¥‘Á$óRÁ,‚âÁ4ÌãÁ=Ú+ÁG çÁPÝ_Á[ëÁeš ÁpY×Á{‚ÁƒŠlÁ‰oöÁ`EÁ•u§Á›·nÁ¢ tÁ¨žÁ¯øÁµ¤Á¿ÌÕÁ¸ýÁ²?jÁ«—ŠÁ¤ùÇÁžkRÁ—øšÁ‘£hÁ‹jVÁ…=ÀÁ~8æÁr]®ÁfåÚÁ[‘UÁP±þÁFÿÁ;ÄjÁ2,ÕÁ(ëÁ YÁéÁæ¹ÁæJÁH.ÀøÍÍÀíìëÀäçõÀÜݤÀÖsrÀÐæÀÍ IÀÊxÐÀÈKâÀÇÿFÀÈäÀË`%ÀμÏÀÓ„ÀØÔmÀßìŸÀç¼óÀðCüÀúѬÁœÁ \OÁ6üÁÁèÁ¥ZÁ(o¨Á1v1Á;×ÁEQ#ÁO°gÁZ Áe¿QÁqDýÁ}ÊÁ„n=ÁŠˆfÁÑæÁ—=bÁ¸‹Á¤:%ÁªÒZÁ±„Á»áËÁµrÁ®/Á§jHÁ ¸-Áš$Á“wÆÁŒÿUÁ†¬Á€tŠÁt‰ÁhH¯Á\sÂÁPäÆÁEƒOÁ:·ÎÁ0DˆÁ&fÁ‹ÖÁ;ŸÁ ÃÁ«kÀöJ.Àèe€ÀÜ\¯ÀÑ?vÀÇh–À¿7À¸l-À²Æ#À®äØÀ«þ´À©·ôÀ©7ÅÀª¢À¬çõÀ°@ŸÀµbcÀ»=¯ÀÂa™ÀÊ•0ÀÓ/ÀÞA×Àê]ŒÀ÷3¿Á2Á ¬²ÁEïÁ!®Á%w8Á/‘MÁ9ЧÁD¨µÁOÿbÁ[xOÁg7oÁsìÁXÑÁ…ù%ÁŒ\ØÁ’ÓRÁ™cDÁ  XÁ¦ÎoÁ­¤Á¸Á±!Áª4ˆÁ£`¥Áœ›Á•Û·Á3ïÁˆ“"Á‚ÁwjÉÁjýŒÁ^–œÁRYDÁF’Á:ü5Á/”×Á$è%Á—ZÁˆ Á÷eÀûnÀëCaÀÛPÉÀÍšÀ¿ùéÀ´”LÀªNÙÀ¡¹xÀšœ.À”ë-ÀÀhÀ„ÍÀ‹XzÀŠ©ÆÀ‹e¾ÀŽoÆÀ‘ïKÀ—@­À³TÀ¥®À­˜À·môÀÂ-,ÀΚ)ÀÜ’À몤ÀüGŽÁþuÁúÁ +Á$"—Á.àÁ:?tÁE°5ÁQh+Á]mÁiÇjÁvJàÁzÁ‡øûÁŽ™îÁ•WÜÁœ,©Á£Á©÷Á´x…Á­^GÁ¦XÁŸihÁ˜’Á‘Ì,Á‹¨Á„TºÁ{jLÁn\5Áa•ÁUÓÁH¦òÁ»xÁK.UÁWë£ÁeÁÁr¦Á€"Á‡ÁéšÁ”ÛdÁ›åbÁ£rÁ­À'Á¦‘šÁŸgäÁ˜>.Á‘ÁŠ“Áƒ dÁxlAÁjã2Á]Z2ÁOú<ÁBûÁ61êÁ)€'ÁÿÖÁáÁ(}Àó©DÀÝ5²ÀÈ2ÒÀ³öÀ mgÀ÷vÀzÅxÀ\fˆÀ@ºÀ)~ÀÕãÀ ©¿î×v¿Ý0Ì¿Ïk­¿Æ4æ¿ÄÀƒ¿Ç°ý¿ÒÓ¹¿ä:i¿úû@À §ÈÀ·À1–ÊÀH( ÀbjàÀ7ÀðùÀ ê À´lÔÀÈ«¡ÀÝ—žÀó…>ÁêÍÁ˜½Áë˜Á)aÁ5ßtÁB¾IÁPÁ]ˆ£Ák)¾ÁxáEÁƒ\öÁŠdïÁ‘„¶Á˜¸›ÁŸòÁª§•Á£VõÁœŒÁ”êÁÀeÁ†š%Á~ö(ÁpßÚÁc fÁUoÁGærÁ:t‘Á-Y¬Á ‡®ÁÀÈÁ?8ÀöiýÀß@cÀÈ{&À² )À[\À‰ ‹ÀlFRÀG¥CÀ(OiÀ f‘¿ä迺Ϳ˜@¿¿{eí¿Qfo¿4¼¿$7׿„!¿!±ü¿:Ç"¿_¶B¿ˆ¨¤¿§u ¿ÊS¿ô¦Àø[À.´dÀMc?Àow*ÀŠlÀžAúÀ³2:ÀÈÚÄÀßl–ÀöàÁ¯êÁ Á ¤´Á-ºuÁ;&ÁH˜§ÁV ÐÁcÖÎÁqÔÁ€ÆÁ‡;FÁŽuCÁ•­¿ÁœíÁ§½…Á ]Á™íÁ‘®hÁŠnÿÁƒCkÁxAYÁj6Á[Þ–ÁMèlÁ@"Á2t4Á%/ÁæQÁ ø‘Àü=®ÀãïÀË|ƒÀ´8‹À—×À‡ª!Àe\‡À=þÀA`¿ëп­Þ}¿rЄ¿”¾¢´Ö½Ê9Ž=ªÒ>@l>…=^>ž‘)>þ4>=ñ =„ç¾2°:¾Þs€¿<è´¿‹ ¿¼Ò¿úBÀÇTÀA´²Àg°±ÀˆÌ×Àž0IÀµ7ÀÌœÿÀäúÜÀý´`Á ‘Á×Á&HæÁ3º°ÁAF£ÁO ¤Á]DæÁk–-Áyö¼Á„1óÁ‹ræÁ’ÆúÁš*HÁ¥ ÁÎÁ–+ ÁŽÆ Á‡bnÁ€ ÈÁqÃÁcR¶ÁUÁFçDÁ8æ6Á*ÿÁïÁ5Áx­ÀêõsÀÑ/7À¸@$À ®­À‰h:ÀfÀ:Í'À&è¿Ôˆ‹¿Œ˜Ó¿rb¾˜ô>s/›? ŒÍ?FòC?tßË?‰®?“ÞÒ?–†–?‘ì¯?‡ºm?lV?4zµ>ÚÃô=Ï5¾Žý¿7ÝS¿™‡ ¿ßtÀü"À=è*Àh€ÒÀ‹³À¢hýÀºš²ÀÓòÀÀí¯äÁùÁkwÁ Á,ÒrÁ:Ó©ÁHýBÁW8ÆÁe‰ÁtÁW`Áˆ½VÁ%¡Á—ìÁ¢lâÁšîÿÁ“tšÁŒ}Á„™ÃÁzkÅÁk®àÁ]FÁN‹ÞÁ@9uÁ1õTÁ#äÁýkÁ 6ÀôÈRÀÚPþÀÀ0bÀ¦/LÀÀ¶Àl ©À=“œÀÞ^¿ÍB;¿vþƾº >1Ã.?$sð?†‚S?±¦ ?ÐN?èw•?ø°à@)8@µ¡@,é?óã1?à°Ú?Å‹?¢)_?jrm?8œ=½º¾ó°Î¿†¯Ä¿×V‡À“ÀCq‹ÀqkÌÀødÀª­wÀÄeVÀÞy3ÀùÇNÁ «,Á„)Á&¥Á4ͦÁCîÁQpVÁ` ÛÁnÀ{Á}†²Á†+‘Á—PÁ• óÁ  Á˜|wÁö_Á‰p¹ÁíFÁtçðÁf†ÁWeÁH¿Á:#éÁ+´=ÁL+ÁŒÁnÀæisÀÊÚ÷À°:dÀ•òßÀwübÀF›öÀ!á¿Ðé^¿v ¾™(>Ÿ‚Y?^ð?²K?ê 2@ y^@qð@)p@2:Î@7@8 @5ºÁ@/¬9@%ET@y]@a¾?ØF?¡Å,?Co®>\ a¾ÏÎ过/9¿áØÀ’ÀPˆÀÛhÀ›£*À¶#¢ÀÑ'MÀ옸ÁOYÁ… Á ÎÁÁ/-|Á=­ ÁL7ÁZÛ÷Ái¤tÁx“ÁƒËrÁ‹OÄÁ’ÔÁÈŠÁ–3‹ÁŽžÁ‡ ÁÁoýPÁ`ùÁRÁC.tÁ4€+Á%ÝÍÁQ²ÁéÀõ0‚ÀØÇ¬À¼ÊoÀ ó·À†HsÀW–ÞÀ$O¿äЇ¿„°Õ¾¬øE>¬:_?wÅ ?È@`T@$@Ó@[Ed¾úãz¿œ K¿þÎ?À2úÀfq•ÀïÐÀ¨óoÀÄgpÀà¨HÀý:3Á ðîÁo°Á)ñÞÁ8ˆòÁGLÁV4AÁe,—Át1„ÁÁ‰'¹Á¶‘Á›¬ÕÁ”ŒÁŒj Á„ÏÀÁzkÒÁk=Á\&<ÁM(•Á>;8Á/[ÖÁ }Á©VÁü¾ÀéhÀÌ}3À¯í½À“”~Ào¦®À9ä2ÀÙ¿¢´ç¾ùqß>}¿\?r‰?Ð:Q@F“@2¸B@Q¨&@kö«@~áé@‡ V@‹ô@Žžó@Ž„W@‡@‰î5@„À @xê@dT‘@I|@)þ6@n•?¸Ýû?@IP=9aR¿:Hd¿ÃI™À øÀL7ÀNÀ_À¹'˜ÀÕtÝÀò†ÁÕÞÁpáÁ%=0Á4ÁBùOÁQÞ&Á`Ø×ÁoôÁ)ÑÁ‡5@ÁŽÙ´Á™²Á’µÁŠ^¡Á‚¸ÝÁv)øÁfó”ÁW¿ÁH/Á9x&Á*u9Á“[Á ´LÀûªzÀÞÍÀÀ¨|À£úAÀ‡fõÀU§RÀüT¿Ðhò¿IõÀ<œ¬s?K(0?Ã~…@Pµ@7A@]e@}2,@Œ;@–w @žSb@£¸@¦¢÷@¦¾<@¥ ”@¢G¶@œÃR@“tâ@‡îP@t'c@QÞ:@+/N?þý?¢°?³;¾•y ¿è†¿ú³À3Œ¨ÀkÈÀ’ [À®¨³ÀË{lÀè´AÁ.©ÁÝÁ æiÁ/ÕÁ>áþÁNÿÁ]81ÁlyöÁ{ÄÈÁ…ˆÁ4 Á—߬Á$iÁˆk‰Á€º–Ár"0ÁbÕƒÁS‰ûÁDG§Á5Á%óæÁåœÁ×€ÀñÁ>ÀÔ |À¶„À˜ú”Àx MÀ>­KÀn’¿›A³¾¸JÑ>öG?¤Õ—@]s@2ßÐ@^¤¼@‚ž{@“0¤@¡:0@¬%@´§@º\¾@½}$@½½€@¼¢¿@¹º'@²ÿ|@¨èì@œ…³@™@uÏI@LÄ\@I>?ß0ò?pFò=þ5¿:¨•¿ËU•ÀÈ|ÀVv8Àˆ äÀ¥--À•VÀàBCÀþæÁ þýÁ"NÁ,OYÁ;|cÁJ©¨ÁYáÁi-¾ÁxóÁƒø2Á‹©zÁ–'ÿÁŽjÁ†­‰Á}äŒÁnpVÁ_ ?ÁO±åÁ@X¯Á0ÿyÁ!©©ÁsÁbŽÀè¶Àʲ;À¬¸±À'ÀbóžÀ(=w¿Ýïv¿W¨ö=Î?f9?Þ÷᾿¤Ð¿¡ iÀ Ä0ÀD.ÈÀ~›^ÀœÈìÀº¯ŠÀØ›üÀö‘MÁ lÁ®Á(÷™Á8BjÁGÁVëLÁfV¦ÁuÂýÁ‚‘ÀÁŠFžÁ”y-ÁŒ¹æÁ„üÁz~yÁkÚÁ[‰EÁLÁ<£qÁ-L²Áý<Á²TÀþÎðÀà@_ÀÂÀ¤ §À†ÀP‹ÀÜ¿´u¿®¥>ÈÝ?¤Z@D@>´@qP @‘sÓ@§ƒ’@¹€@È7r@ÓÎ#@Ýd|@ãû¬@çVO@èÌ@æÍõ@âqõ@Øät@Ìßx@¾I @­œW@™Xe@ƒ€Ä@UÐ@"—?Ø>Ô?PÕg½˜4¿wN¿ð¬ÿÀ3ˆÎÀoI(À•‘4À³°ÀÑÐHÀð'-Á]eÁ«‡Á%ùªÁ5J‚ÁD°vÁTÍÁc‹2Árý§Á8Áˆõ Á’ñäÁ‹(¡Áƒc¼ÁwGÙÁgÌÁXW–ÁHçÁ9o>Á)öµÁ~-Á CÀ÷|1ÀØï_ÀºbÀ›ÍýÀzÇâÀ>½ÃÀȶ¿ŽÏÛ¾O‰n?5¼ô?ÍÞè@X@UÞ@…¥Ê@Ÿ3"@¶ƒ@ÊT@Ùè’@æj@ïI0@ö€@ùÛ«@ú@Ä@ù Y@òTn@èCE@Ûdð@Ì€@ºð@¦v@s8@l[Ž@6úæ?þš?ŒEä>Cÿ¹¿6‡ÿ¿ÒÜ À%}Àa‹÷ÀŽÒ1À­&ÁÀ˃wÀêoÁZÁ«SÁ#WÁ2†¸ÁAùÁQk{Á`ÝèÁpPÌÁÎÁ‡¬Á‘q&Á‰¦ÁÛ Át%ÝÁd  ÁU#ÁE§¼Á6+çÁ&²ÁAÁÑÀðÁÀÑàÀ³—À”c—Àkø‘À/Œ ¿æyì¿^Û“=jUg?|&@?òþ„@2{é@jn’@v¦@ªÞ@ÃHê@ØN²@ètó@õxr@ÿrA¥AýæApÑA=¼AA–@õV,@肚@ØÔš@Æî'@±ñg@šzÃ@€xì@Ioé@_ü?«‰Ä>Ùì¾ü9¿¶xÀ« ÀT_ØÀˆŠTÀ¦ä»ÀÅhºÀä µÁ‚°ÁðÙÁ \‘Á/ÈIÁ?4ÁN¢RÁ^"IÁm²åÁ}HÕÁ†ocÁ0Áˆ1›Á€anÁq+½Áa•ÊÁRÝÁB„[Á3€Á#šcÁµÁÀê=öÀËqhÀ¬ÉhÀŽ. À_%SÀ"+`¿Ë¹ü¿&ñ>”>?œ,î@ €@BE @{‰­@™4Ö@³¡±@Ìd'@âÚè@ôÌAÕ7A% A Á5A ð"A }»A TAyAV@ô@äTY@Ò¼@¼EÀ@£Øè@ˆÖ+@Yì;@d¤?ÉŒH?'=ƒ¾Ì2¿œmJÀ ìÀG¥EÀ‚PÿÀ ôÀ¿´ÀÞ‚xÀýRUÁÖÁ€ŽÁ,òÁýZù?¶ó%@è&@PT›@„zû@ "W@ºŸ@ÓcÉ@ê:¹@üé AÓóA ¶AxâA€ÇAòyA* A &ÿAyñ@ÿYÍ@ï @Û­@ÅO@¬(µ@eÜ@hU(@-ÉŠ?å-¾?Yì"½´@¿ƒ”¿ýhÀ;ü³ÀyBÛÀ›H Àº¿ÀØäUÀ÷ÍÑÁ ^¶Áã²Á*zHÁ:ÁI¯¼ÁYJwÁhäÁx}§Á„æÁ~yÁ…¡žÁ{‰µÁkÓcÁ\&èÁL‡]Á<òÁ-`|ÁÓsÁIÔÀý‰ëÀÞ½ÀÀ®À¡C]À‚ ÀG}vÀ D¿šÀs¾‡®?,*B?ÎqT@!Ùè@[é1@Š7™@¦@Àvz@Ùr·@ðPAþŽA §ÓA÷ŒAIA&A@AnSA£A WâA…e@ø'ó@ä±@̽é@³Ô@—Œƒ@t¿[@:y5?ýŸC?…0=Ì Y¿[é¿çÙPÀ11@Àn‚À–"À´þÀÓèÀÀòØ'Áî#Á„MÁ(Á7¾RÁG`²ÁWÁf¥pÁvMÁ‚þóÁŒtNÁ„—‹ÁyuÁi¼ÁZ–ÁJN²Á:¥BÁ+ $Á}kÁ öÀøßlÀÙÎqÀºÆäÀœKÀzªIÀ=Eû¿ÿÅ’¿…½º2I?WL?ãžü@,ç@e¡@¨Ÿ@«ƒ©5¿1Ûp¿ÓNÉÀ'*9ÀdéˆÀ‘a¿À°O¥ÀÏ=˜ÀîN‹ÁÂÁ]nÁ%øÇÁ5–^ÁE7 ÁTÚæÁd‰MÁt?ÆÁûøÁ‹t¦Áƒ–KÁwp}Ág´eÁWølÁH> Á8†Á(ÑÅÁ*Á —ÄÀô(ùÀÕ1:À¶K£À—hÆÀq ÓÀ3ƒ®¿ìv¿bš´=r@2?~ø?ö”±@69@@oàÐ@”“@°P@Êãm@ãÿ—@û#˜AÈsAÙ(AOºAÞAöýAËëAHAQ{AY{A ¿A=@îý–@×y¨@¾&v@¢1@…Ê@Oò@sj?­ W>˳í¿^Á¿ÁðóÀ£ÓÀ\O-À?À«ü%ÀË ÝÀêAÁ½ÆÁ^ìÁ$Á3¡8ÁCCDÁRíÁbžwÁrR²ÁwÁŠˆóÁ‚¨úÁu“ÁeÕ“ÁV§ÁFdÁ6¹Á'Áv…ÁâtÀð£=ÀÑÊÀ²†ªÀ“nÀihcÀ+™d¿Üzí¿FU>.4Ô?Žà@n@=j@xƒ@˜z…@´Q-@Ï}@èCœ@ÿ™sA ÿFA%OA—æA ƒµ?˜~S@+@C‡@}6U@›Cþ@·ü@ÑÇ0@ëeRA:`A žEAï²AkÄAÕ8A!Y8A!T³A #QAÝ€Aµ”Aê~A8@öø@ßÁ@ÅĪ@ªk$@0´@_iM@#ç?ÌdL?%E•¾¡Í¿£”þÀ[cÀMÀ…wÝÀ¤`ØÀÃoÇÀâ«!ÁöAÁš&Á @8Á/æJÁ?Œ]ÁO2oÁ^ØÁn~£Á~%úÁ‰F ÁbCÁsÁcI€ÁS™ÁÁCóÜÁ4O$Á$ªmÁµÁbåÀë’øÀÌy«À­ÎÀŽÑLÀ`'yÀ"Ù¯¿ËBï¿!±ù>žD]?ž_b@ –×@EÛ¨@Ú@œ¦<@¸!»@Ó/x@ìfËAñ—A lÚA+ZAÇ.A +óA"á°A"åA!¸ AoâAHíAWåA4@ù G@áþZ@Èÿ&@­¥@jª@e}R@),?Ù†¢?=ßc¾a]¿—QcÀ /9ÀFµÁÀ‚*À¡%ÔÀÀA«Àß_ÞÀþŠÁè{ÁŽ+Á.5[Á=ÜŒÁM„èÁ]7TÁlèVÁ|“/Áˆà=Á€øîÁr)ÁbhéÁR±žÁCòÁ3hðÁ#ÕÚÁE”ÁµQÀêJÀË7©À¬döÀ›–À]²UÀ ¾ª¿È¦¿ê>¤“?Ÿ·@ ð®@EÊ£@ëð@œfÇ@¸ Ù@Ò™ã@ì ÉAQA »øAÊ AèA îÓA#­*A$¿A"þ A»øAyuA”TA‚¬@û³9@äÄÚ@Ë:ä@¯ì+@“3;@jÂè@.~À?ãàu?Sš·¾0 ¿‹†ÄÀ,;À@úöÀˆÀžŸ7À½»)ÀÜ×ÀûóÁ ‡ÈÁ!dÁ,Á«Á™¿?gB@ Éj@DZ@~A@›—@·2 @ÑìU@ëmAšóA ŒìA̪AµùA!fÒA$FZA$ÇMA#û¤A ±+A’“A³‰A ´@þn@擆@Í]†@±Ù³@•@nÜ‚@34q?í>´?e˽tFŸ¿‚¿þ!‡À<Ú¹Àz§!Àœ;À»1²ÀÚWcÀùÚÁ d)ÁdÁ+œ Á;9ÉÁJâÆÁZ˜ÁjQ&Áz 2Áˆ=Á€iªÁq3oÁa“fÁQóÔÁBTBÁ2´üÁ#"6Á¦¯ÁHCÀéã[ÀË60À¬„Àü¹À_zßÀ# ¿ÍŸý¿,_l>‚ân?– (@ ò@@¼c@{eu@šp@µÏÁ@Ð{ @éçuAëÑA ÌuA?’Ah‹A!GA#ýîA$þ A$ŠžA! ¾Aw™AkéA Iï@ÿj«@çÞ9@ÎZu@²þ\@–bB@q¨Õ@5\‡?ò?q…Ó¼[ò¾¿xeh¿öí¡À9^PÀwvÀšÆÞÀ¹Ò»ÀØàÞÀøÁ ¢÷Á=ºÁ*ØcÁ:s ÁJTÁY±;Ái\5ÁyÁˆ@<Á€tKÁqP³Áa¸ÑÁR îÁB‰ Á2ñwÁ#aÂÁåìÁ‰eÀê“ÐÀÌ0jÀ­ÍÀi¦ÀbW»À&„ð¿Õ×·¿=› >@Žwo@©Ö@Ä3ú@Ý]ï@ô²ÙAò÷A âýA@pA|xA’ÞA[ýAzëACVA7^A4fAª@öä@߉q@Ǭ@¬¹`@‘@i3@.øN?æ%ò?[¦ï½¨¾Ú¿ƒ^ˆ¿ý.8À<QÀyÄXÀ›¼/Àº–3ÀÙzÈÀøªÁ ÕsÁeÄÁ*÷KÁ:‰)ÁJæÁYÁ¡ÁipøÁy)ÝÁ‰h®ÁšÁs™¬Ád ÄÁTŽÍÁE&ÄÁ5ØüÁ&¤•ÁrŒÁ@ƒÀò+ŸÀÔ>À¶&ËÀ˜0Àu'ŒÀ:`Ó¿ÿ8Ö¿Š­Ó¾8_?9M ?Ïš°@ Õ–@Y¹G@ˆUé@£5n@½Î@ÕhË@ëåÒ@ÿì-ARiA2-Ab°AvIAGñAzcA6kAŽÙA l²A®"@í-¯@×'{@¿<5@¥Ø{@Šôá@^iÒ@$Ä?Õ‡C?=ˆ²¾IØù¿‘MFÀaÀBgÀwÓÀžg†À½%#ÀÜxÀûÁ aÁ•æÁ,âÁ;¯ÁKBiÁZ×VÁju:Áz±ÁŠ9,Á‚p¶ÁuZÊÁeà‡ÁVuQÁG¨Á7Û!Á(¥dÁyOÁ dïÀö¨ÕÀØ´ŠÀºÑÆÀùÀ'ŒÀDtÀ Ï¿  ¹¾¯¨? ÿq?¸Cç@g²@L\3@A›@›:²@´ -@ËYu@আ@ó9ŠAOyA¼0A ãwA ÙÄA´¬AñqA ¹§AùªA¬@öKy@áM@˽U@´ý[@œ%€@‚¯ˆ@N¼]@?»jl?£ð¾¹ˆ¿¦ÀÿÀK'bÀƒùLÀ¢žóÀÁK´ÀßøuÀþ¨kÁ¾Á5¯Á-¶öÁ=@ªÁLÐáÁ\e;ÁkûÁ{šžÁ‹>pÁƒvPÁwg¹ÁgóhÁX“aÁILJÁ:$<Á+ sÁôîÁ ÝÀÀû¢BÀÝî ÀÀQÀ¢»À…räÀPŽÏÀES¿¹¤Û¿”7>©‘Á?œ@Ý&@;®@oÝ @‘(@¨õÙ@¾Ùì@Óº@äE•@ò°º@þ¼–ADvA@ÝA&gAñ_AÏ×AUb@ôY@åm·@Ób¿@½ùÀ@§¼Î@Nq@n@:#@&I?™®>¡ÓC¿$E¿ÁíÿÀô~ÀW,²À‰ßFÀ¨:ÀÆ•9Àäð”Á´wÁGÁ Á0¾Á?{ûÁNò8Á^huÁmà)Á}e¯ÁŒfoÁ„¬"Áyô–Áj¥%Á[n.ÁLPøÁ=7ÚÁ.!ÁàÁ QÁÀä‘ÂÀÇ"ÂÀ©³ÂÀŒqÄÀ^Ï À%%*¿Øƒu¿P:c=„‘"?lð%?ã´U@&R„@YnÉ@…³@›¯;@°£N@Ãá@ÓQ©@áWÊ@ìoâ@ó³+@÷a<@øýë@øhr@õ¡ @í«i@ái@Ò¨@ÁÞ@®/™@˜Ö\@‚$N@S‹.@!’ ?Û°8?^NÕ;©‰ ¿^ש¿âÔÒÀ,LjÀgI¡À‘.ûÀ®Å6ÀÌãÕÀë=ÁËÁ÷Á#.Á2…ÑÁA÷ÁQnÁ`åœÁp] ÁÔ¯Á¶oÁ† 9Á|Ð.Ám¤Á^’1ÁOˆdÁ@ƒ¬Á1„Á"†BÁšMÁâmÀìd3ÀÏ0wÀ²\À•;Àpá¨À7T!¿ýÿ¿Ž¡©¾z"?Ý?³ÆÑ@ Üþ@?%@m];@ŒfC@ €@±áS@Àç=@Î’ÿ@Øùu@ßf7@â¤í@ãÙ”@ã`€@àur@Ù(­@Íœë@¿r9@¯¸@œt†@ˆ @d?‚@5»K@IŽ?¥¾¹>òéÞ¾ºV3¿œÛÀ1ŸÀ?o¬Ày;ÿÀšïÀ·|8ÀÔçcÀò¥‚ÁgŒÁ‚Á&“Á5¹dÁDë5ÁT:òÁcŸÜÁs Á:èÁ>5Á‡§šÁ€ÓÁq7 Áb4~ÁS2nÁD1®Á57‹Á&h&ÁÍSÁ @€Àõp ÀØnÀ»“4ÀŸ:%À‚åeÀM6À†¿¼ÕU¿c›>H)Å?€wÙ?⑃@ N@M(Ô@vx@@üÍ@ž¨À@­¥?@ºu0@ä@Éí@ÌÉe@Í…Î@Ìü©@Éà@Ã:¸@¹¿@«Ze@›Vï@‰eñ@kyÈ@AƒŒ@Â?Êãë?RÄ<ÎFοIø¿Ï‰VÀz~ÀV§¤À‡©ëÀ£ÿÆÀÀà¾ÀÞžÀûPqÁ vµÁ|âÁ*XÁ9¡ŒÁH²ÀÁWÉöÁfývÁvJmÁ‚ÕœÁ‘*IÁ‰ª\Á‚&PÁuC³Áf:ÇÁW;òÁHb8Á9¹>Á+8eÁ¼5ÁB7ÀÿsÀâò±ÀÆ™íÀªA)Àë’Àd|aÀ.?¿ïÉ¿†,2¾€I™?-I?¤/ï?ýÞà@)1ÿ@Pƒ_@t®@ŠÆ@˜qÍ@¤5¦@­Q@³@µáÉ@¶u)@µÎS@²S @«Ëò@¢^@–š`@†e±@i´„@DÍ@±“?â ?†˜Q>Àõ¾ê@q¿Ÿ÷+ÀDòÀ9Ù0Àoy6À“ŸÀ¯ÇwÀÌRÀèøÊÁñçÁhÓÁþ¨Á.Ñ Á=ÍeÁLÒ4Á[ׯÁjßMÁyó'Á„‘/Á“øªÁ0vXÁ!ôÌÁŽÁiÀî´8ÀÒ—PÀ¶ŽºÀšÉ4À~ÜzÀIŽÀãØ¿ÂÏ¿?¶P<wU?7ˆ€?²Öô@7}@'ª@I—6@hnŽ@£*@Œ¯C@”÷0@šÈ@…|@žï@œë„@™¥@’ðU@‰óá@}«R@`Ï@>¦P@?æ_,?“fE>òßV¾w“¿|Å·¿áE7À#|©ÀW†–À†UáÀ¡2#À¼¸ÀØLµÀôO¿ÁCÁLÁ%‘UÁ4ôÁB­ÂÁQiÀÁ`MóÁoOÁ~V=Á†±®Á•b.ÁíÁ†ˆõÁ~nÁoÚ…ÁaGaÁR½õÁDVÁ6¹Á'éFÁÉÁ º’ÀûaÀß} ÀûHÀ¨ „À&Àg1xÀ3]Àƒt¿£Z)¿˜>q?D×?°ú?öv[@¾U@8k\@Rï¨@gö¾@wþ@€í@ƒ™ @„@‚Q@}W@qK…@`,k@J•@0@œ ?Ý/H?’ˆÔ?®ü¾ ý>¿SËð¿Åb6ÀoÀE¨Àw6zÀ•±ºÀ°yÀÊ«æÀæ;VÁí ÁÍÁætÁ+<ßÁ9»BÁHFgÁVÓïÁectÁtšÁuÉÁˆñ™Á—ÓEÁ~êÁ‰3cÁçÞÁu>:Áf×+ÁX¤|ÁJ}AÁã¤Û¾µ°¿I»¤¿¹èÙÀ q^À7Ë¢Àgñ%ÀŒ¾ÂÀ¥›JÀ¿¾€ÀÚ;hÀôЛÁõeÁÃLÁ#¢íÁ1©mÁ?¹.ÁMýÁÁ\|ÁkÄÁy¡€Á„ Á‹|_Ášœ•Á“Q ÁŒÁ„Ï}Á{R-Ám[Á^éBÁP¿{ÁB™ŠÁ4 øÁ&ÈbÁÊÁ v×ÀûèFÀá\¦ÀÆõ À­¤ À”ïÓÀzB7ÀJÕÃÀÎÛ¿é¿™§q¿¦Ì½—)j>שZ?a„V?§°?ÖGé?ü @ ‘”@-¹@Üj@À@%Õ@ ÿø@˜?çsÛ?À&?’ø¨?ƒp辊þš¿VàP¿»ê8À™—À1×qÀ^*À†–çÀžs×À·b$ÀЇ1Àê?*ÁY#Á©ÙÁ ¡Á*žÁ8xäÁF]ÁT:Áb¦ÁpèêÁU%Á†ðëÁŽ?Á­Á–E±ÁiÁ‡ñöÁ€ÍÈÁszÁedóÁW[<ÁI‹’Á;͹Á.1Á xøÁø¤ÁÁÑÀñ_¡ÀØ2´À¿rÔÀ§†¨À jÀs˜?ÀI8qÀ a®¿õm&¿­±¿W‡"¾·;Ö=–Ì>ð]Ÿ?P;¯?Œ Â?¨ØX?º·?œu?Â5¨?¸W?§_à?’ /?m?n?%'<>£¢ü½¥Še¿8S¿É¿5À b#À2úóÀ[îdÀƒá†Àš62À±ÁcÀÉ·ÚÀâX¼Àû—€Á ’ÏÁ”žÁ$ëdÁ2OfÁ?º ÁMiåÁ[g?ÁiyÒÁwŒçÁ‚ÑmÁ‰í]Á‘úÁ ‰ÙÁ™b`Á’BTÁ‹1gÁ„,üÁzRBÁleÄÁ^›þÁPÝÇÁC4gÁ5—Á(6HÁ- Á5uÁ•0ÀêXÀÒHéÀ»!À¤ÃÆÀIÎÀu‰ÀÀN{æÀ*3 À¹_¿Ñ=œ¿–äý¿@›´¾Â=°½V(>c*Â>Üä¢?‹4? ?,?ë¶>Ë’>r½4= Á¾XÛ¿ u“¿eÿ¡¿¨¿æ×ñÀ.üÀ8ö†À_˜SÀ„RâÀ˜ò]À¯ <ÀÅ‘“ÀÜûìÀõ bÁ«ŸÁTóÁ ˜Á,÷¦Á::\ÁG£­ÁU ¬ÁbŸKÁpzrÁ~~ÇÁ†B¦ÁHIÁ”QýÁ£»~Áœ°MÁ•«žÁާbÁ‡§xÁ€¾"Ás±€ÁeñÝÁX`iÁJöÁ=ºBÁ0¬‹Á#½ÈÁ GÁ ®YÀýˆãÀæ:bÀÏÉHÀº(zÀ¥_(À‘ë^À}úŒÀ[wÅÀ:ÙŽÀÐ]ÀOo¿Í?ª¿Ÿ¾_¿l÷S¿*èÿ¾òo¾®èH¾‘of¾—I~¾Æ&n¿Rì¿-¦¿]¦7¿ô`¿´q³¿ß/ûÀ E¤À&! ÀEèWÀh’À†Ï¦ÀšÄ×À¯O¹ÀÄ ÀÚh¸ÀðïÓÁ(ªÁ8aÁTÁ(ðçÁ5ćÁBžQÁO½&Á]ÁjdlÁwâªÁ‚Ñ÷Á‰Î¯ÁÑ6Á—Ó¼Á§*ôÁ &DÁ™"Á’.ÅÁ‹JÀÁ„jÁ{.üÁmÇ]Á`kÁSD ÁF,gÁ9G6Á,¾Á tŠÁx‡ÁÑýÀûxÀå|ÀÐbNÀ¼»QÀ©©ÕÀ—›À‡ <Ànp—ÀQs¿À6®À"$Àêy¿èWY¿Ç¾(¿°¨Ã¿¡ j¿š%*¿›b¿¨迸oÀ¿Ëþ€¿âtOÀËÊÀ™ôÀ'38À?~²ÀZ[~ÀyøÀŒôTÀŸ÷À±çzÀÆzÀÚ™ÀïÅÁZÁV¿Á Á&Á28„Á>²JÁKvVÁXQÞÁemJÁršÐÁ×ìÁ†œJÁniÁ”^´Á›aÚÁª¨LÁ£«€ÁœÆ˜Á•ëàÁ7ÁˆPìÁÁuêHÁhÍÓÁ[¹ŸÁNéyÁB†ÁÁ6:ÉÁ*-öÁ¡³ÁiùÁs]Àû¸åÀç¢oÀÔ`•ÀÁþ–À°¨$À àOÀ‘w‹ÀƒŒØÀmÀU>ƒÀ@%­À-ØÖÀfÀ¦þÀ „À À 7ÀUÀ¶iÀ!NÀ,tBÀ:ÞtÀK­èÀ_;™Àv-CÀˆûÀ–ÍÀ¦¨èÀ·¸òÀÉì¨ÀÝV Àñ^:Á‹Á ã‹Á€Á$P‹Á0¯Á<ÁH-jÁT—ÆÁa/Án{Á{ ’Á„&äÁнÁ‘_Á˜!VÁŸ'Á®MßÁ§u=Á ¡Á™Ñ´Á“ÁŒW Á…ºsÁ~k†ÁqsÐÁd¼»ÁX[xÁLgÁ?øHÁ4„²Á)T>Á/ÊÁŠpÁ z Àÿ,[ÀìÑUÀÚÅBÀʧÀº×VÀ¬ÑÀž—•À’ßÀ†É{Àyo`Àg†ÀYxÀNOÀGK~ÀD²XÀD÷›ÀKH¹ÀSlÿÀ\œÇÀgìœÀuÒMÀ‚² ÀŒ?À–Þ~À£ öÀ±^ÀÀ}@Àи…À⎎ÀôߥÁb“Áa`ÁáæÁ#ä¼Á.÷µÁ:RgÁFØÁQõlÁ^$Áj=Áw ÁààÁˆj2ÁÁ•š°Áœ5ÄÁ¢é‰Á²-Á«YÁ¤“DÁÓ?Á—!“Á‘nÁŠBÁƒª:Áz±ÁnNÙÁañ´ÁUîfÁJvˆÁ?B2Á4ÕÁ)E¶Á4íÁHFÁ â»ÁÍyÀô³Àä»§ÀÕ'mÀÇa³Àº.AÀ­âïÀ£øÀ™hÀö÷À‰îKÀ…—À‰ À€…‰À€‚¤ÀƒÚ¦À‡ÅvÀŒ*§À‘³ªÀ˜aÏÀ  À©DÀ³?<À¾¯wÀÌQ¥ÀÚÏÇÀê»àÀû€ÁÈâÁ2ëÁ0PÁ$6ZÁ.áÁ9åñÁDîêÁPYÄÁ\%-Ág÷>ÁtïÁ€EpÁ†|½ÁŒÏàÁ“L¾Á™ä Á }XÁ§"Á¶½Á¯W•Á¨¢fÁ¡ýÜÁ›y³Á• þÁŽ¡QÁˆVÁ‚%OÁwþeÁl»Á`|ÁUdÁsòÁRÀÿÍÀðO£Àâ¦ðÀÕð?ÀÊRqÀ¿ÅÿÀ¶g°À®^þÀ§·À£AÀŸ¥©Àž±æÀŸ ;À¢ÄÀ¥à1ÀªEÀ¯©Àµ÷nÀ½xÈÀÆSÀÐ+°ÀÛ7³ÀçÂÀõëðÁŠ›Á  FÁ_ŽÁqÄÁ& Á0Á:;¶ÁDý«ÁOöáÁZùéÁfjèÁr<(Á~›Á…Á‹LÁ‘ƒ‡Á—Í$Áž>4Á¤ÉÁ«` Áº*·Á³vÁ¬éÁ¦nÑÁ Á™™«Á“SÉÁ'^Á‡ØÁÌÁv‘;Ák7¼Á`"~ÁUBÈÁJë@Á@øÁ7äÁ-³–Á$ß±ÁTTÁŽ­Á ØôÁÌxÀþ@sÀñþÀæß¸ÀÜŒÀÓ©ÀËÇÀŹ·ÀÁ À¾8dÀ¼å¤À½ÒÀÀdãÀÃýYÀÈbbÀͪ¯ÀÓ¿ºÀÛ2¢Àã6fÀíDhÀ÷ÆüÁÞ3Á¦ÁÎgÁ¹ãÁ ,·Á(ÿÅÁ2F1Á< ŸÁF­ÁPZÉÁ[*)ÁfæÁq šÁ|”1Á„4TÁŠ"±Á)’Á–WgÁœŽòÁ¢ÕÇÁ©¤ðÁH5íÁQúÁÁ\¨ÁfˆþÁqX¦Á|K¿Áƒ­ªÁ‰hwÁQ¥Á•@¼Á›@þÁ¡cÁ§š˜Á­ã1Á´D.ÁÂÙÀÁ¼chÁµðmÁ¯“µÁ©ZÁ£D5Á5=Á—DÅÁ‘nXÁ‹µ Á†/çÁ€»­Ávù}Ál²>ÁbÆSÁY õÁOàÍÁG9®Á>¾ÔÁ6·™Á/HùÁ( ñÁ!G(Á/ÁpEÁ"Á h£ÁV$ÁÆpÁï(ÀýóÀûq•Àú?ñÀúù˜ÀýZÁ[9ÁpæÁó.ÁÄiÁ ^XÁJ¡ÁÆÁá|Á0FÁ$–Á+X}Á2J×Á:;rÁBĤÁKS¡ÁTn<Á^'*Ágë^ÁrrÁ|¾nÁƒÅÁ‰ Á*àÁݾÁ&ÁDÁ &Á ˆ–Á ¶ŸÁ á´ÁŒ"ÁŸ—ÁdÁê`ÁZ•Á(íÁ"‡MÁ'j×Á,®ZÁ2œ$Á9X!Á@ùÁG€ÁOÑŸÁX[ÁaöÁj^Át"‘Á}ðÁ„ÒÁ‰y÷ÁŽà Á”T·Á™ò|ÁŸ¶ Á¥Ž^Á«~QÁ±yÐÁ·†DÁ½²ÖÁËøRÁů£Á¿ƒÁ¹icÁ³\£Á­qòÁ§¤«Á¡òRÁœUøÁ–ØÁ‘ÛÁŒ^Á‡F^Á‚oÚÁ{k·ÁriËÁi¿KÁaL¾ÁY1éÁQä@ÁJ¾œÁCçBÁ=”Á7µ Á2OÁ-_ðÁ)…Á%bÁ!õLÁAfÁ“pÁ_uÁñ3Áö±Á7ÁÁÍ Á Ö–Á#CEÁ&tÁ)jVÁ-°Á1eŒÁ5ù0Á;IùÁ@áõÁG\¥ÁN6ÁU$¯Á\ýMÁex¤ÁnÁvßqÁ€5‘Á…ïÁŠïÁ6¢Á”–«Á™úöÁŸpíÁ¥­ÁªÞÜÁ°°EÁ¶™Á¼™ÁžÁÐÅßÁÊ]ÁÄ~›Á¾qÁ¸‰&Á²ÄÁ­Á§pÙÁ¡éÖÁœ—ÔÁ—j Á’J,ÁgåÁˆ« Á„dÁPÝÁvÐîÁn‚ÁfÚÁ_Ÿ¦ÁX¢•ÁR¥ÁKËWÁFÁ@»ºÁ<+ìÁ7ëÁ4{Á1 áÁ.‚Á,ë¼Á+ÎŒÁ+YÚÁ+I§Á,ÍÁ.#ÇÁ0kÁ2vÕÁ5L´Á8zÁ<,ôÁ@UñÁD´tÁIé™ÁOcÚÁUjâÁ\#:ÁcÊÁjydÁr¡Á{!ÁßKÁ†mÆÁ‹B½Á%Á•­ÁšZÁŸ¸ÁÁ¥ÖÁª“_Á°>?Á¶®Á»ÔÒÁÁ¾FÁǹ±Áà<{ÁÚ$4ÁÔÿÁÎÁÈBŠÁÂ|yÁ¼ËNÁ·DÁ±ìlÁ¬²ÊÁ§‡ûÁ¢—ÁÔ±Á™)KÁ”±Á€ÅÁŒcZÁˆ‚nÁ„ë†Á~<Á||ÁvDGÁpʨÁkª‰ÁgGÁbÏÁ_y¸Á\jÅÁYä;ÁWªzÁV3ÁU¨ÁT‚íÁTA+ÁT¡ÁUZbÁV¤¡ÁX{ŸÁZÃ\Á]r–Á`­vÁd*Áh*sÁl`´Áq:Áv÷Á|vÁ8¯Á„}ÏÁˆµÁ‹úÁí‘Á”-8Á˜¡5Á-cÁ¡ÜªÁ¦Ê!Á«ñÁ±:ëÁ¶‹(Á»òŒÁÁ‡µÁÇGÁÍ-ÁÓ,oÁÛ_ñÁÕ.ÅÁÏÁÈùÇÁÂþãÁ½)‰Á·kßÁ±À³Á¬=œÁ¦èÁ¡§ñÁœƒGÁ—šÐÁ’ê*ÁŽNÁ‰ðÒÁ…ÍUÁ¾­Á{ìÊÁtô¾ÁnH“Ágì»Áb!^Á\îÄÁX19ÁSÕJÁPPIÁM@,ÁJŠ–ÁHNÁFºÁEšKÁEµÁDÇÔÁE¶ÁEôdÁGZ5ÁI*OÁK‰ÁN35ÁQœkÁU2þÁYc9Á]´ÏÁbÒ­Áh,ÁnÁty\Á{G•ÁjÁ…HcÁ‰gúÁÕáÁ’dÜÁ—sÁ›éKÁ¡cÁ¦E‡Á«\Á°ïöÁ¶‘Á¼@ÁÂ'gÁÈ#dÁÎ#íÁÖ³ÁÐ^×ÁÊ(mÁÄçÁ½è.Á·ê=Á²´Á¬`jÁ¦·åÁ¡94Á›æ!Á–žÖÁ‘ƒMÁŒ¬ÓÁˆ †Áƒ~EÁ~w_Áv=ÿÁnB³ÁfñzÁ`4¢ÁY·ŒÁS¢*ÁNHpÁIPzÁDÿèÁA;GÁ>¾Á;3´Á9ìÁ7VUÁ67µÁ5‚ÍÁ5UDÁ5µÚÁ6–§Á8ìÁ9ïˆÁ<`xÁ?ÆÁB–íÁFTÒÁJœÁO('ÁTq&ÁZbÁ`;IÁf©‹ÁmÜòÁuÁ}mßÁƒ yÁ‡œUÁŒ5¤Á‘ Á–§Á›PªÁ šiÁ¥÷ÕÁ«…Á±BHÁ·)*Á½¶ÁÃÅÁÉ8ØÁÒ$|Á˹éÁÅe¦Á¿*¶Á¹ßÁ²ÞnÁ¬ÝRÁ§Á¡VÑÁ›¯@Á–5ÁäÔÁ‹œ×Á†ÁÎçÁzf ÁqluÁi=Á`çVÁY!®ÁR/ÁKƒEÁEZÍÁ?Å€Á:‹¯Á66qÁ2<ÖÁ/AÁ+õxÁ)ÊAÁ( –Á&ð*Á& ~Á%ë_Á&PÁ'GhÁ(Û£Á*ˆÁ-K´Á0áÁ3© Á7Á;Õ;Á@¼ ÁF(ùÁL ÁR[‹ÁY"ÓÁ`Ÿ"ÁhH,Áp£ÊÁy¨mÁhÁ†,ÞÁ‹8‚Á]òÁ•¥£Á›/Á ”@Á¦O•Á¬2àÁ² ëÁ¸8Á¾=˜ÁÄ€vÁÍ­<ÁÇ+/ÁÀÀÅÁºmüÁ´3DÁ®¶Á§ÞÁ¡Ù¶ÁœüÁ–MhÁ¦ÍÁ‹3Á…åFÁ€¨oÁw[WÁmð^Ád´îÁ[ðZÁS¼ÁK£õÁDOzÁ=u*Á7"RÁ1iÌÁ+ÿRÁ'sÁ#^uÁóÁÝØÁ©tÁÛÁ²ÚÁ¤Á‡”Áê`ÁxÁœYÁ¥ÍÁ:ÙÁ!LÁ$ØtÁ(ä0Á-2*Á2n-Á7õƒÁ>(7ÁD›•ÁKâ«ÁSm(Á[m:Ád7§ÁmC4Áv¤AÁ€T]Á…rìÁбBÁøÁ•®<Á›h~Á¡F Á§+aÁ­(Á³LíÁ¹•ÿÁ¿þ°ÁÉbôÁÂÀêÁ¼5bÁµÇ§Á¯vŠÁ©=€Á£ }ÁœåÁ–àèÁ‘ dÁ‹I=Á… 4Á€3ÓÁuåIÁkŠÑÁa¾ÁXHdÁOÿÁF˜ãÁ>~åÁ6°Á/¦^Á(òiÁ#'¼Á¤Á»aÁ›ÁëUÁ ñÁ •wÁ ¿ÆÁt¾ÁQíÁ(TÁ„ÙÁÌ`Á ]Á ”ÿÁ,hÁ‡ Á lÁO/ÁÒVÁ$'Á)ÿÁ0GàÁ7(aÁ>±sÁFpêÁNÿQÁWâ×Áa ÅÁjè³ÁubÁ|‚Á…-CÁŠËŠÁ„˜Á–]óÁœ@…Á¢?tÁ¨häÁ®¸CÁµfÁ»’åÁÅ.ÓÁ¾ƒ¿Á·ß¦Á±JÉÁªÓÏÁ¤hÁžG»Á˜FÁ‘ìRÁ‹ë£Á†ÕÁ€NÁuK Áj…ÕÁ`%ÁUå—ÁL/äÁB§°Á9¡_Á1s¡Á)hìÁ"^ÁéÁðwÁOÁ 7¡ÁÝ8ÁWÀþÀùÀõ[Àòw/ÀðM«ÀïØÀðjlÀó –Àö;ÔÀû¦Á2ïÁÁÁ‡nÁ ÏÏÁ²÷ÁùýÁ«Á"½Á)õÁ1‹ýÁ9Þ+ÁB¸©ÁK¬ªÁUSnÁ_otÁi²|Át…ØÁÖÑÁ…¢ÊÁ‹uÅÁ‘]JÁ—eóÁ”Á£á~Áª@Á°±HÁ·>ìÁÁ @Áº[¾Á³¤æÁ­ÛÁ¦l ÁŸìÔÁ™Á“RËÁnÁ†ó©Á€÷ ÁvNÁj¾xÁ_x ÁTËâÁJzqÁ@E‹Á6¡jÁ-)QÁ$üÁ\<Á‰Á {QÁëÁ¥À÷ž™Àî?Àæ¹›ÀàJûÀÚý›À×6çÀÔ\ZÀÒSjÀÑÎ ÀÒ4VÀÔØÀ×ÔâÀÜçyÀâ´ÁÀéø3Àñé£Àû–Á›ìÁ,«ÁT Á<(ÁÄzÁ$È7Á-–!Á6yÁ?øôÁIôâÁTlÁ^Ï}Áj"Áu…Á€˜Á†EÁŒ—Á’ËžÁ™ÊÁŸfWÁ¥ÝVÁ¬uPÁ³*tÁ½/Á¶QWÁ¯ŒÒÁ¨ËKÁ¢",Á›•Á•ÒÁŽ®ÚÁˆi&Á‚)ÿÁw÷ÑÁl Á`q ÁU½ÁIÎWÁ?2KÁ4ÏÄÁ*ªÁ!"¢ÁìeÁy¢ÁFýÀÿÞÍÀòçÀåè‹ÀÚÑúÀÑ$œÀÉ•òÀ‚˜À½'ÍÀ¹FÿÀ¶~¦À´enÀ´À´t‘À·QÀ¹îÁÀ¾ÿÝÀÅ/ÞÀÌpóÀÕ.WÀÞµÀé@CÀõ§ÁâÐÁ3vÁÑÁr±Á!LåÁ*²EÁ4©³Á>´œÁILÂÁTx_Á_ÊNÁkQMÁwOªÁÑmÁˆ‚ÁŽA#Á”š—Á›'Á¡¾Á¨eÁ¯ZèÁ¹C¥Á²Y…Á«‡Á¤ÂóÁþWÁ—HNÁ³šÁŠ;]ÁƒÖjÁ{ .Ánˆ=Áb#KÁV--ÁJ²rÁ?^3Á4/6Á)ŸCÁ-¨Á&1Á ÛÎÁÁ’Àôæ‘Àå'ÀÖ¿ÎÀÊjÀ¾y³À´ÎÙÀ¬rIÀ¥0 ÀŸŽÀ›~gÀ˜°)À–}ÂÀ–G?À–Á}À™JQÀœ¹ƒÀ¡¤ÅÀ¨4À¯m+À¸À AÀÍŽ“ÀÚ ›ÀçСÀö EÁt©Á (Ál¢ÁbÁ).Á4Á? âÁJ6ÊÁU°ÁaµÞÁnÁzaÁƒ‚ÓÁ‰äÁn±Á—;ÁêÏÁ¤ÇLÁ«ªÁµ³Á®¥eÁ§¬äÁ ÌíÁšèÁ“@ÁŒ€•Á…ÞÖÁ~Ê™Ár•ÁeD_ÁX¿ÊÁLqcÁ@€þÁ5ÂÁ)»%Á‘'Á CÁ µšÀÿáSÀí0OÀÛUVÀË[®À¼[)À®Œ À¢Û¡À˜—XÀ½îÀˆ/=À‚oŠÀ|tÀuÛÏÀq¢ÀpÏDÀrãÀwkÀFÀ„¡ÓÀ‹åÀ“DªÀœ IÀ¦ÄÀ²]ÑÀ¿ŠYÀÎSÀÝ£GÀîq2Á*«Á *ÁJ ÁÉìÁ)¸¥Á4ØàÁ@I¿ÁLQÁX½Áe2oÁq·óÁ~SÁ…Ý'ÁŒ—/Á“cÁš8hÁ¡Á¨’Á²X÷Á«8¯Á¤ïÁ.Á–(CÁO@Áˆ‡ÁÆ¡Áv>%Ái4Á\\ÁOUÁBý Á6ÎÁ+Á‡ÑÁ%2Á ÀýMfÀèГÀÕ´À½lÀ±Ì`À¢1ÐÀ”®À‡_`Ày×ÀfÛºÀW øÀK.ÀB'¹À;Ý@À7Ð)À5¬À6ÂÌÀ<³ÀEüÀOþÀ]×úÀn?À€°¥À‹EÆÀ—Ô%À¥›*À´tÀÅJhÀÖ”ÀéëÀþ)íÁ —:ÁcgÁÏÁ+&LÁ7åÁCr¡ÁOÝ Á\}¢Ái~?ÁvÐ)Á‚!QÁˆâûÁ¯çÁ–’õÁñÁ¤¦mÁ¯¶Á§ß"Á Á²Á™¥ùÁ’—4Á‹œúÁ„®ËÁ{¥<Án×Á`ÌÁSÀ¼ÁFÒÁ9øãÁ-QCÁ!<ßÁ‡Á «Àý{‰À硆ÀÒ¨vÀ¾ˆŽÀ«§[À™SÉÀˆÂ5Às² ÀYvìÀB£À/À+,À²À2Àƒy¿ü5¿õîê¿ù»áÀúíÀ íwÀȰÀ%¸À6ÚjÀKr¤Àb'HÀ{oÀŒvÝÀœqÓÀ­Ÿ¥ÀÀòÀÓ¿äÀèÉÀþ! Á ]$Á îÁ!î9Á.@Á:žÁGYÁT….Áaô;Áof6Á|Ù{Á…>IÁŒ/ÑÁ“<ÏÁša_Á¡‘“Á«ÝœÁ¤š¾Áj7Á–JØÁ.½ÁˆFÁßÁtP¡ÁfmÁX¹vÁK[¥Á>SÁ1U%Á$rTÁÞàÁ ÓÁ( ÀéF%ÀÒç¾À½]ùÀ¨yÀ”¨ÍÀá[ÀakÀ@ó¯À% þÀ ÷\¿ñE‡¿Ï‘K¿µGš¿ ½U¿’ø0¿‰èA¿‡ 6¿‹/3¿“}þ¿¢ÑM¿»+À¿Û§ÝÀž'À½À.caÀIâ Àh¯ À„²|À— À©Î™À¾Ÿ ÀÓæeÀꄹÁóÁ ÁÁrÁ%§~Á2€tÁ?©´ÁMKÁZ‹³Áh%ïÁuè4ÁôNÁ‰ šÁ0VÁ—YÚÁž‹)Á©&Á¡§ ÁšS|Á“¼Á‹ãqÁ„½*Á{>’Ám5çÁ_NÈÁQoÁCŸŒÁ6:Á(ü‡ÁðÇÁõ<Á€gÀí*}ÀÕÒÀ¾®ÊÀ¨UVÀ“:—À}EÃÀU›gÀ23PÀlx¿å¥x¿±á¸¿…ÌË¿F€Â¿ ~¾È ¾ŽÅ²¾T^ç¾AÝ>é ?g4?%FÂ?*n?"@í? a>ÍŽ’>I2ƽnby¾¾lz¿<ý…¿•Dž¿Ô~œÀ ì©À0*ïÀXèÀhÜÀ—ºøÀ®©œÀÆ('ÀßiÀøÏøÁ BÝÁNðÁ#ÕcÁ1”àÁ?^mÁM`£Á[ˆºÁi·ÄÁwÿ Áƒ7ðÁŠ€Á‘Ò Á™,wÁ£³Áœ5qÁ”ÃÁÁažÁ†dÁ}zjÁnåxÁ`w–ÁR×ÁC–Á5¥6Á'§øÁ¾àÁ 'ØÀýÌÀã]bÀÉ•DÀ°ŽÅÀ˜EÀ€¨×ÀTÎgÀ)öÑÀ¿³Œš¿W1¾›­ >'Cc?Íc„<)àœ¾Þ´7¿rc‰¿ÀêÀsvÀ0‡KÀ\ó/À…g‚ÀˆÚÀ¶W"ÀÏþ ÀéãÔÁ*ŒÁ¨±Á<Á+ Á9:ÁG˜ÁUËPÁd1ÒÁr±`Á€™ûÁ‡æÁCÊÁ–²Á¡KÁ™É©Á’M?ÁŠÖ¦Áƒf$ÁwøìÁi=lÁZ˜þÁL Á=² Á/htÁ!!pÁ ¯ÁOÀî¶ ÀÔ£À¹ŸðÀŸÚ²À†ÂiÀ[ãžÀ.ÆmÀí¿­õ=¿>ó†¾N?>Æã¥?_æü?¤AQ?ΛZ?ð‚Ã@H@ ¾t@°@×q@“S@ ‚@pˆ?åÍX?ÂWD?”¢(?;Å0>ŒÂ‚¾³À¿_>¿ÀpˆÀ »À:ìÀj lÀ·„À§;èÀÁy½ÀÜ ôÀ÷( Á 6ÁÁ)ÿÁ%QèÁ3™©ÁAôÔÁPtÁ^úêÁm‘eÁ|G‰Á…Á:Á”€NÁŸ òÁ—t#Áç{ÁˆgîÁ€ôõÁs 2Ád,|ÁUMÅÁFu‘Á7ǨÁ)W ÁÙÁ ÇÀýâÀáÀÅÚÀªþ{Àc‡Àm‡À:ý^À ²K¿¹{P¿?É„½²h?a»?Š$o?ɽï?ÿuß@;û@(,µ@5«—@>£×@Ci@BÍ‚@?þ;@:œš@1Žn@"³Ê@HÎ?ñ·?·„ù?nqÛ>¸žÃ¾‡»¿u}„¿Ó‹øÀ9HÀJÔÀ~c¬À™dlÀ´B1ÀÏ—Àêü—Áƒ{ÁŠ2ÁžÁ.K2Á<àNÁKxRÁZ5Ái÷ÁwíHÁƒfÌÁŠÚ•Á’[ Áœè¦Á•N5Áµ¸Á†$þÁ}9$Án,÷Á_9mÁPZ4ÁA{ÝÁ2¬|Á#égÁN¢ÁðŸÀñIÈÀÔ¶|À¸vÀÙÀ‚4»ÀN˜À•É¿Ò ,¿^§Ã¾-ò¶?ñ‰?‘NO?݃ú@å?@+.%@Cí@V c@cñ@m¡‰@rß>@sAL@oå}@kµ@`ÇD@Pÿ @;±&@#`þ@P«?Æ0&?qï{>ê¾ÝµŽ¿’Û•¿÷&mÀ/o&Àc®ÖÀŒÊÀ§Þ³ÀôWÀßÝŠÀürÁ c¸ÁÌ­Á)_¾Á8&=ÁGqÁUÚ«Ád½+ÁsµÁa#Áˆð¹Á‰7Ášå©Á“<>Á‹•ôÁƒø~ÁxÉ;Ái´¶ÁZ¦šÁK˜~Á<ÚÁ-°ÿÁìWÁ(”ÁoÀåùÒÀÉJQÀ¬›"ÀoÀi¢‰À3H·¿ûcÜ¿“Áñ¾¿r‹>ÈÔ?‹ù?àpC@ÏÛ@85@U¤­@nBo@€ê#@ˆj@c@HM@~Œ@rB@Œ¹î@‡h@|<÷@fˆ€@K™Í@+Àz@0ª?½~$?JN®={¤¿4‹¿ÁSÀ¡'ÀKÍÀ€âþÀœÁ®À¸Ý¼ÀÕYÙÀò'ÛÁŸÁFüÁ%¾Á3ñ5ÁBÚ ÁQßMÁacÁp.nÁ[xÁ‡DAÁŽÝÁ™ ©Á‘] Á‰°xÁ‚Át· ÁenxÁV@1ÁG1´Á8/ŽÁ)-‹Á,.Á L«ÀøøÜÀÛXfÀ¾°À¡ƒ¥À„üæÀQÀ´µ¿ÄÄ;¿6 Œ=Ò± ?av?ÏIÐ@ƒá@@¦ '@¦«‹@¥•ã@¢½v@›ô@’x¤@†oƒ@ps¾@Nó@) 9?ý;Ó? ~Ç?c~¾˜“(¿Ž¿úáJÀ4^ÀkÍ,À’I!À¯ÀÌ3–ÀéiâÁ]Á:—Á!0ÕÁ0'Á?(}ÁNIcÁ]€ŒÁlÄ¿Á|9Á…­)ÁUqÁ—MPÁ‘KÁ‡ÛÿÁ€/ÛÁqÁaÈ´ÁR}ØÁC2üÁ3õCÁ$ÜÁÙÁ×-Àï«9ÀÑònÀ´mKÀ—8ÁÀtN×À; rÀò ¿”Ò¾¢??}?©vÆ@T@5¤ô@`X^@‚‚V@’@ž—Â@©<’@±õ@·×†@ºh3@» w@º ±@¶ƒ@®ªs@¤9þ@—]š@ˆ@m«u@E~¹@ ?ײc?g2ï=°È׿A5Ì¿ÎxžÀ±kÀXÂÁÀˆëÙÀ¦×ÀñØÀádÀÿIÚÁ™Á¤:Á,¶žÁ;ã·ÁK)©ÁZuMÁiÃoÁy‘Á„4Á‹èÁ•¶ŠÁþMÁ†EEÁ}Ám™xÁ^*ÁNÏzÁ?‡ÅÁ0A\Á úóÁ³–ÁˆŸÀç ÀÉ'À«K¬ÀËñÀa0À&È:¿ÙöM¿R_:=HØw?e“L?Ý·Ê@"\@S³@µe@“†@£êE@°¸Ë@»ƒ6@Ä.š@ÊJo@Íxà@ÍÏ…@Ìâ@È0B@¿I“@³×g@¦Já@–z·@…þ@`H @45±@ï/? ”>Û¾â4¿¨j–À ¸îÀG™0À€Å3Àž[¶À¼]@ÀÚtÀø{Á CÁeeÁ)“—Á8Ö¨ÁH%ïÁWu6ÁfÈÐÁv0VÁ‚ÑVÁŠŠ†Á”ÕÁŒ]ëÁ„ ÁyÇ}ÁjVýÁZæ‚ÁKw0Á< ÝÁ,¢VÁHzÁ »Àý¹ÀßsžÀÁGÀ£lÀ…»èÀP ÀÒ·¿´êF¿áï>»h?¤*@ Õ@9r¾@kòö@©=@¢U~@³H¼@ÀÛš@ÌX@Ôóñ@Û N@Þz†@ßÙ@ÝÓ&@×´Q@Íœ@Á†S@³º“@£nl@‘=@y@0@K«i@¤G?Êm?8®¾Ún¿†ý"¿ûB$À8D÷ÀrêEÀ—/¢Àµ6÷ÀÓyÀñÓõÁ.ÁDbÁ&€3Á5ÏÁE-qÁTž£ÁdÁs}©Át±Á‰*Á’ŒCÁŠÏÕÁƒBÁv·×Ág9)ÁWº{ÁH@Á8Û0Á)€íÁ.†Á àÖÀ÷&oÀØÃ¾Àº›ÏÀœoœÀ|ª¬ÀAYÀ‚%¿”„꾇“?!VU?Á¾@"ü@MEÄ@€D@˜§è@®$*@À5¡@ΑA@ÚN©@ã$B@éÀ@í‚å@î˜)@ëú@䢹@Úåû@Î) @¿ç¸@¯X-@œŒ¬@‡­ë@`"œ@,À ?î ?tô=Á¯N¿Qès¿ÞhÀ)¿Àe³ÀŒÃÀ®ÅvÀÍ"Àë~·ÁïÿÁ<8Á#’Á2øœÁB_ÔÁQÊ6Áa5îÁp¡¦Á€+Á‡ÇÁ‘ ÇÁ‰ESÁƒ¥Ás” Ád+¹ÁTÇÁE[UÁ5çýÁ&wôÁ!KÁׯÀñ&ÀÒˆ÷À´À•»_Ào'˜À2Øs¿î@Š¿rî½i“?\t:?ßæx@'J@]@ˆƒÐ@ ¦ô@¶ïö@Ê I@Ù7&@æ?@ï¹[@ön@új¤@û4@ø!@ðë)@æU?@Ùêš@ËJž@º²Ý@§7H@‘w@r­@>A@ ¢?ž`>«ˆÝ¿¿ÀøÕÀi"ÀXõÀŠMdÀ¨côÀÆß£Àå‚·ÁæÁdpÁ Á¿Á0(îÁ?ÁNû¹Á^qÄÁmòñÁ}€ÃÁ†ŒcÁÉÁ‡ÿÁ€6qÁpÞ‘ÁaTÁQÖ8ÁBk°Á3áÁ# žÁ<ÁÙÀëÀÌ«îÀ®9ÄÀ×—Àc¢À'zË¿Öyû¿Bl>—1?‡’u?øªT@3ñø@iþQ@ޝÁ@§ z@½óç@Ñàr@âJ@ïm§@úUA£€AWsA |AI@û’È@ñ"q@äº@Õ¡ñ@Ä:!@°Š@™Ýk@ U@MUÞ@}®?¸ê_?²ú¾ÂË?¿§ïoÀ)ÀLNÈÀ„L5À¢ÕíÀÁihÀßüãÀþ˜BÁªÁëÁ-©Á=]ÁLÁ[þ ÁkŠêÁ{"ËÁ…^ÃÁŽŸíÁ†ÒÁ~ÒÁn‹;Á_ZÁOzÇÁ?ñbÁ0uÁ!ÌÁ¸¹Á_§Àæ éÀÇ\†À¨«"ÀŠðÀWâUÀÞî¿¿½6¿é0>§™æ??r@±€@?-Ó@ul@”uÕ@­4@ÃjÛ@Øk¶@é @÷ ÂAS£AOA«QA‰™A0ÙAÄ@ùðë@ín‚@ÞœÖ@ÌŽ<@·í8@ £î@‡ç¨@Z‡ @"þJ?ѱÁ?9Ù¼¾Pvâ¿‘´äÀ­vÀ@Í%À}ÙmÀ޼À¼1ÀÚÔòÀù©Á DÁ³}Á+#wÁ:˜ëÁJ‹ÁY³çÁiO<ÁxìÁ„E±Á‡šÁ…²/Á{Ä Ál.ÖÁ\¥ˆÁMÁÁ=šxÁ.‰Á ;Á-Àÿ—hÀàÝ/ÀÂ"öÀ£hÊÀ„¹þÀMG?ÀÛ࿬á¾Ô[þ>÷e%?°Ç«@ëŽ@I¹ô@C@™â,@²\5@ÉJ¶@Þ…@ï×@ý™+A¼sA¯{A d†A lA™PAéAÉŠ@õ›@åz×@Ò¾·@½Á]@¦u@Pñ@eG–@-[W?çŒ?a;9½HŠd¿zL†¿õuÊÀ7¦èÀt’êÀ˜ÈÆÀ·kFÀÖ@óÀõ%FÁ –Á€‰Á(÷ÂÁ8|yÁHWÁW­ªÁgHýÁvåAÁƒCÁŒš¢Á„ÄÁyàƒÁj<6ÁZ ÁK{Á;~/Á,LÁ”‰Á !IÀû]wÀÜz(À½²ÀŸ$¢À€à–ÀE[Àõ¿šy©¾©p?!7’?Åaî@Ä@Rú@„s,@žÈÇ@·€@Îlè@ã-@õ ÞA€AlÜA g#A 8A MA ¾9AñoA?@únÄ@ꘞ@×i@Âì@ªçM@‘ûÒ@nÚô@6à"?ùbU?ƒó`=è5ñ¿Rý*¿ãšñÀ.Û¦ÀkéÔÀ”‡À³Z‹ÀÒ08ÀñåÁíÉÁ_•Á&æ®Á6|®ÁFoÁU½Áe^!ÁtÿGÁ‚P7Á‹ÎÁƒ÷.ÁxHÁh­÷ÁYòÁIŒÁ9ûFÁ*jpÁÝÁ c­À÷ÞõÀÙyÀºk‚À›Æ¸ÀzžrÀ>9PÀ㿌̥¾0eé?=æv?Óó3@"ö@ZÖy@ˆ²›@¢˜¨@»hŸ@Ò¬»@ç¡$@ùmAçA ©A y A–ïA]aATàA žpAPÇ@þ±©@îEl@ÛD@Å¿Í@®†a@•öý@vöF@?¶@@Þ+?“ñ>q-¿¿4¨Ý¿ÓÆÀÀ&œˆÀcr*À‹þÀ¯t©ÀÎ]yÀíFHÁŒÁŒÁ% ]Á4œæÁD9±ÁSÚaÁc{ÁsÁÁ^öÁ‹3ßÁƒcÁw$WÁg‚¤ÁWãâÁHNpÁ8¹^Á)$LÁ“VÁ #Àõ@=ÀÖUÀ·ÿ°À™wÏÀußÝÀ9‡k¿û6„¿ƒ´½ÄZ/?RDí?Ü$@'Å^@_uZ@Šÿ¯@¥ˆ@¾^u@ÕMó@ê†ï@ü…^A‡«A `OA=ëAykAorAXoA ôA†“A?}@ñ¾ @Þ=M@É Ñ@²™@™°j@}üª@F\@ ÎC?£À`>±ä¸¿¹¿ÆIÀïåÀ]KãÀnaÀ¬6ÐÀÊÿ?ÀéÇ®ÁJäÁº¬Á#5|Á2ÆŽÁBfôÁR ûÁa³%ÁqZUÁ€€ÃÁНÁ‚ܲÁv¬Áfp8ÁVÍiÁG-Á7˜zÁ(Á¦ÞÁ F´ÀóÏ×ÀÕiÀ¶wwÀ—Û[Àr€UÀ63²¿õ•U¿}޽Ü?[ëê?áÈ‚@*`g@aŽ@Œ8½@¦i!@¿lM@Ö¢N@ëèÚ@þ–†AÛÛA ˜IA—ÁAîùAùâAáXAÔA ¼A­@ô¹Ó@áy@Ëø@´õF@œ{H@‚ º@Lµ@“–?¯$¦>ßÕ¹¿¤¿¹™þÀ§¡ÀWPÀŠLÖÀ©ÀÇÓ^Àæ—ªÁÅaÁRÔÁ!à¿Á1nªÁ@ü•ÁPŒ—Á`"žÁo½£Á\ÜÁŠEÛÁ‚tmÁuQÚÁeÇMÁV7 ÁF¦ÅÁ7‚Á'€Á¨Á·øÀò§ÓÀÔÀµ0À—X/ÀrAÏÀ5Î¥¿ô09¿{™ý½tTø?[^•?á¥/@)ÀÌ@a‰‚@‹ú,@¥ä”@¾ö@ÖÁÂ@ì…@ÿ¾æA¡?A W{AbAÅøA*AªAZ™A 2‹A× @÷^‡@äT?@ΞÝ@·Ãí@ž¢:@„€X@Q u@C!?¹?ž?ñ¾Ú60¿¯¯ÀáÀQíºÀ‡¥zÀ¦ZÀÅ>PÀä%ÑÁ‰ÁOÁ œ3Á0*,Á?¸%ÁOIuÁ^åÁnUÁ~2Á‰ù¹Á‚&iÁt±ÂÁe$žÁU¡HÁF"ºÁ6ª*Á'9CÁÒZÁ~€Àò}<ÀÔ‚ÀµÙÀ—M¸Àr¶×À6ë¿ö„n¿Ó½}d?TÓš?Þ™I@(4z@`$¸@Šð†@¥EE@¾»@Õú@ìï@ÿ§WAÄ}A ŸAÀ¿ALÜAÊAAAV A 5AÝÕ@ùUÚ@æpi@Ðêf@¹“ã@ ¹[@†5i@UY@,?Á~#?\¾´ˆ…¿¦¯fÀ›”ÀMßuÀ…‘«À¤S}ÀÃ8wÀârÁ6Áó´Án€Á.ÿhÁ>š¦ÁN6 Á]ÑÁmm-Á}ìÁ‰ñ­Á‚!äÁt§}ÁedÁU™äÁF/ãÁ6Ø4Á'žÁ(ßÁÒWÀó#ÀÔÔØÀ¶›ñÀ˜r ÀtÿcÀ9Tý¿ü d¿†zK¾«:?Hžù?Ù;@%)J@]Z´@‰Í#@£Í|@½@Ô´þ@ê£X@þ>™AIA \+A™A3AþaAŽQA­6A ùLA¤Ê@úMŽ@ç¬i@Ò4@ºÆð@¡Â @‡Pò@Vñ³@äÛ?ÅìÆ?.G¾§™¿¢~À µÆÀJó,À„zÀ¢Ï{ÀÁžŽÀà“÷Àÿ•ÀÁPŠÁÖyÁ.\lÁ=ëŠÁM…ØÁ] ˜Ál»AÁ|UêÁŠ ØÁ‚>çÁtæ¸ÁeW„ÁUØ„ÁFmïÁ7×Á'Õ¶Á¡»Á p Àô~ÀÖA–À¸pÀšLÁÀy 4À=ŠaÀ|Œ¿6ç¾Loœ?5 ™?Î;î@¶ª@Xš@‡: @¡K@ºœ³@Òú@è+@ûèA#‹A VAA€¨A”A-‡AóÔAwåA ÕA¸\@ùàG@çÁ@ÑÍ=@º)9@¡97@‡1¨@WH£@™‚?Æö?!¥¾œ¥ ¿ ×ëÀ O`ÀJ3QÀƒÉ,À¢‘ýÀÁQÀÀà1ÀþúƒÁøßÁw’Á.ÁÁ=ŽÃÁM!øÁ\¿NÁl]XÁ{ûaÁŠ$ÊÁ‚dŒÁuRÉÁeè·ÁVˆlÁG(±Á7ÙÁ(¢ùÁp™Á C;ÀöZ‘ÀØT´Àº{Àœ¡…À}¯ ÀBê“À-ö¿šâ´¾šg?µ?À g@®Ú@PÁi@ƒ6@«è@¶Åù@Îm’@äD0@÷Œ0A:A FËAGXAmªATAmåAAÀA EKAŒ@÷:@äb@ϯ@·ÿ@Ÿ Ì@…?@SÒ@Â?Ád?3¾®©¿¢óŸÀC^ÀKL„À„*ÚÀ¢Ý?ÀÁ—vÀà] Àÿ?6Á/Á™CÁ.dÁ=ŸêÁM%¿Á\± ÁlKÁ{ñòÁŠ]Á‚ÕÁvFiÁfãíÁWrÁH"ÊÁ8ÙdÁ)±`ÁœÁ ‡¨ÀøîúÀÛ*ÈÀ½ƒ'ÀŸÛ†À‚SÌÀJ}À£¿ªoܾÛàu>ð߆?®X3@»h@Fì@@}EÁ@˜lK@±m @Ȭ@Þ%i@ð÷æA¬hA-A ”A jXA '˜A \€A „~AÉAR¢@ñ@…@Þn[@ÉîN@³P@šÿ‚@Dá@Lîe@º|?·×?YM¾Óô5¿¬ùÀ¢EÀNÇÿÀ…‚SÀ¤¢ÀÂÙ Àá³ÁF¶Áµ,Á$ÅÁ.œ Á>(uÁMºSÁ]L2ÁlÞÁ|oïÁ‹(1Áƒo‡Áw}­Áh,ÒÁXï·ÁI½®Á:‹¥Á+dÔÁNÁÁ NRÀü¥1ÀÞß|ÀÁ=ßÀ£ÚÀ†‹ÀR£ Àž`¿½‘J¿áü>ŸT?™h—@a>@;<õ@pDF@‘¶.@ªÑ@Àº”@Õae@ç¸@÷»AœëAéAéAÉAØA¶Aw@øæ“@è±@ÖX5@Â(:@«ôª@”3@v@Ahw@ º!?¤>Á2ë¿¿ºkóÀ©ÀTÐÀˆ¸‰À§,ÌÀÅ¡ÀäQÁY)ÁÌ|Á JõÁ/ÉzÁ?HUÁNÏ,Á^V±ÁmÞ6Á}e»Á‹ñ+Á„CÁy:úÁj¬ÁZËðÁK–3Áá!?€å&?îç*@- s@a {@‰OÝ@ ”»@¶K@Ê\@ÛR6@éð0@õA$@üB'@ÿâ¡AÅ(A^Ak@ø¬@ì\ç@Þ•@ÌF˜@·|Q@¡Þ–@о@dïµ@1;?÷­?ˆñ8>KV7¿5µï¿ÏDÀ"’ÏÀ^iÕÀ,»À«1,ÀÉoÜÀèÁUÕÁ«¤Á"rÁ1W@Á@´ÐÁP(©Á_°9ÁoD,Á~ØÎÁŒ÷£Á…IÜÁ{I!ÁlàÁ\û^ÁMè1Á>ÕÁ/Å7Á ÌùÁïNÁgÀè~fÀË@MÀ®ŽÀöÀh{À/BI¿ì=§¿u½¨¿?FA¿?ÎÒJ@³S@NQ@}ë‡@•Œí@ªiÚ@½Ö@̺@ÚÄè@ås‘@ì(é@ïÝ@ñOo@ñµÚ@ïÿ;@èI@Ü¿@σÑ@¿î¥@ªèÎ@•xñ@~|@O]_@d+?Ò+ ?NÙC½wÓð¿p2Õ¿ëAèÀ/¦ÀiÿñÀ’åïÀ°æXÀÎçÀí#pÁ¾ ÁïçÁ$5ÅÁ3Š&ÁBæDÁRPéÁaÆ)Áq<ãÁ€YÕÁŽ"äÁ†„:Á}ãÁnÉþÁ_°ïÁP—ãÁA…(Á2•†Á#ÄhÁ÷Á9ÀïxÀÑëûÀ´Ê(À—¶šÀv6µÀ=rüÀ/d¿šp¾´1b>þÉF?¨Õ£@âË@7‰\@f`ª@ˆ?#@œc}@­À@¼¢E@ÉêF@Óê@ÚxÊ@Þ A@ߘ{@ßbT@ÜõN@ÖK@Ë£@½ˆ@®Zì@œFC@‡F!@bÈ"@5/@¥À?¤j>솞¾¸Ì«¿B À÷MÀ?µ£Àyú/ÀštÂÀ·óÀÕs¸ÀóBµÁ­ÁðZÁ'Á6KhÁE|±ÁTÈÀÁd-BÁs¢+ÁŒ4ÁœòÁˆ Á€zÁqñiÁbåÏÁSÚ5ÁDÒ.Á5çÁ')KÁs:Á ½ŽÀöMAÀÙm£À¼£JÀŸæíÀƒ¶ÀO9ýÀ{°¿ÁGŸ¿)s±> N?sû¿?Þ@Â@ $@I¨@sK;@Œ‹ê@œ—/@«-7@·¾ @Á$s@Ç8Ó@Êw½@Ëí%@Ë]@ÈÙl@°K@·û\@ª³Á@›Žx@Š3a@mâŽ@Cíj@:??ÐuV?]5ê=›n`¿;yõ¿ÉXQÀ¸÷ÀSs\À…ç-À¢ÄåÀÀ3¸ÀݪXÀû->Á [ƒÁ8~Á*H“Á9rùÁHžnÁWʉÁfùþÁv?ÛÁ‚ÍýÁ‘2OÁ‰¯†Á‚.àÁu_vÁfa8ÁWi‚ÁH—3Á9å²Á+8ÝÁ¦ÿÁæÀÿKÂÀâˆÀÅÂ~À©U¸À}”ÀcLbÀ+®B¿í¿—¿…5¾j.™? _ê?¦`?ÿ{Ì@*†Å@Q\„@uz¤@Š2Î@˜sÅ@¤|×@¬ý¦@²ºÆ@µ’;@¶¦‰@¶*8@³“h@­ $@£Õ@—X×@ˆQ®@om@JDï@!åœ?îð?“.B>ÏB¾¶ÁÁ¿“%°¿ü¡ãÀ3³Àj3À WÀ­ÑÀÉÎáÀæ³ãÁ9ÁÆÁ{™Á.?7Á=0cÁLD¾Á[_ÁÁj{‹Áy™¹Á„bÁ“ 6Á‹ˆÔÁ„äÁy©Áj,SÁ[oîÁLÜÁ>PQÁ/ȃÁ!EÇÁÒ2ÁždÀìèÀГHÀ´˜.À˜ÇµÀz»øÀD™:À>ò¿¸è¿)Ž=›Ü×?O’H?½Ì¡@©a@-Ha@NùH@m{‡@„]ñ@w‡@—µ@@Ÿœ`@ DÁ@ŸÆ¼@@¬@— @Ž•Í@‚ÓO@hš>@HÇ@$Fa?úõò?§6b?Ll½ºK¿X :¿ÏV.À²¯ÀNðYÀãÊÀ=„À¸Ý/ÀÕ&ÃÀñ|ÛÁò=ÁmÁ$|Á2±ÁAl½ÁPQ—Á_Z8Ánq=Á}‚qÁ†IÒÁ• ëÁˆÆÁ†ìÁ}`ÁnÀŸÁ`BúÁQÈáÁCNãÁ4ÔåÁ&zäÁN.Á !ÌÀ÷êÔÀÛ¿ïÀÀ\'À¥&XÀŠ!hÀ_ÆÀ,4Ì¿õ ú¿’ø]¾ØÕÓ>ŠTí?kŠY?ú¾@N@&kÿ@Cö¿@^”~@r_¢@«@†=@ˆ±Ð@‰<§@ˆ££@…³‚@€@o@Ze!@?%ã@°õ?öÊ»?«Œ?7Á=eŒþ¿$1ˆ¿®±HÀȃÀ9iÜÀl$…À$oÀªçÏÀÅ­'Àá6ÀýYÁ ÐÐÁ@Á)i†Á7ßÁFVzÁTçÛÁc©lÁr“`Á€ÌÁˆP*Á—:‹ÁØ„Áˆ‡`Á?ÁsûIÁexøÁVö¦ÁH‚%Á:HªÁ,,²ÁvÁÁÁÅÀè¶§À͆vÀ²¯èÀ˜žÀ|ÉìÀKµÀ ƒ¿×ŸÚ¿{ºœ¾¢ >¡:Ë?eì¾?··Æ?õ}Ô@ž˜@/ìë@C«3@RSÅ@\q@aR„@b 8@`Cí@Yõ´@NÂØ@>ÀJ@+‚@NG?ç5Ë?¢Só?2a=¾w¿ A…¿›a ¿öjOÀ)·™ÀZýÀ…äÞÀŸg>À¹dXÀÔ'ÀîóëÁ³Áç™Á å3Á/…Á=wÁKî{ÁZmjÁhð‰Áw†âÁƒ ´ÁŠŽOÁ™µIÁ’k¼Á‹";Áƒß1ÁyHòÁjíSÁ\°ÁN’’Á@„Á2u«Á$uóÁŽ=Á®ÉÀõðfÀÛjÒÀÁbµÀ§‘½ÀޤNÀl¼zÀ=+7À›~¿Ê8—¿pªù¾«­z>g+?<Ǿ?š|Õ?ÐJæ?þ¢Ô@[@ \¯@)â…@.@.ûÎ@,?Á@&‡@K@ Z?ð ë?ÃÚ?‹H?w&<¡ø·¿奿—€¿êÞiÀ ”ÀN@À|ä£À— À¯ÔÇÀÉD'ÀãM}Àý¢ÉÁ / ÁÒðÁ'›8Á5cÍÁC^KÁQ¢gÁ`OÁn—XÁ}øÁ…ÔÀÁÁœY(Á•úÁÚ Á†·ÁÁCìÁqÈÁbôÕÁTä”ÁFß%Á8ì´Á+¾Á9ÍÁ©VÁƒ ÀëÔÀÑ@CÀ·«ÀŸ›À‡à‘Àb­À6rƒÀ ̿˽¬¿ƒÛ¾üÖ»„´æ>áý¬?["J?š?v?½Ì|?×^ô?鿜?òt?òè²?ìÁ=?ß *?ËÓ-?¯Ì?ˆ•6?9Æg>›Fž¾W‡¿,Èø¿Ÿ³¿ìaqÀ dÀH•RÀtWVÀ‘ ºÀ¨€¯ÀÁ9wÀÚÕÀó!YÁöÁƯÁ þOÁ.– ÁÅ î?%+^?Y|?z¸”?†HÛ?…pÂ?{W×?a©?8~j?!X>s <½¤ž¾ûõù¿j3k¿µSâ¿úãºÀ"–ÀI’—Àr7ÀŽfäÀ¤ƒ…À»ZŠÀÓ \Àë|ðÁ$ÄÁ¨ Á­‚Á(ë×Á6, ÁC•®ÁQ<®Á_ ŽÁló€ÁzúÁ„‚HÁ‹šiÁ’É÷Á¢G$Á›'wÁ”ÁŒþpÁ…ïÁ}ç7Áp€ÁbKeÁTª£ÁG!ÿÁ9µ Á,s9ÁF³Á›6Á=¡ÀôBÀ܆fÀÄü/À¯WûÀš0ŽÀ…êSÀf*uÀA?À ]NÀO$¿È®(¿’J.¿DŸl¾æXf¾U”­¼ Ÿ¡=èÒ>/e>+›l=Ïr°¼p\¾%П¾¸= ¿ª°¿oÃ8¿¦Žµ¿ÛPéÀ HCÀ+ê5ÀOÆÚÀu´ÀŽÞÉÀ£0åÀ¸×ŸÀÎùQÀåÿ:ÀýסÁ ÿÁˆtÁ$Á0øÁ>'EÁKk_ÁXΈÁf>Ásä¹Á€ä´Á‡è,ÁŽîÙÁ•ùuÁ¥q#ÁžcÞÁ—ZÁV±Á‰k4Á‚ŒHÁw_ŒÁiº`Á\ NÁNÂ$ÁA–ÜÁ4ŒµÁ'ìµÁ¤ÁSÕÁ€ÓÀï¾ÌÀÙËÀÄ›©À¯ÞïÀœÛKÀŠ8PÀqóñÀRnÀ3—íÀ“¿ý‘¿Ï²¿§‡c¿‰ÝZ¿cX#¿DD¿6£¿6áÉ¿H¹â¿hž0¿‡f—¿Ÿ¿¾ ø¿å…%ÀÃzÀ!ðÀ=2]À]Y¬À 0À‘ºÀ¥ÓÀ¹e;ÀÍæ„ÀãÌîÀúiÁ™Á€FÁ NÁ-ÀÁ9¦ÁFmGÁSg[Á`¬SÁnÁ{tÐÁ„zÞÁ‹\¾Á’[Á™déÁ¨Õ’Á¡Ñ·ÁšÚ&Á“ôKÁOÁ†;áÁ~ÓÖÁqJýÁd VÁW¶ÁJÁ=lÁ0ÙàÁ$£òÁüÒÁ j–Á^ÀïI>ÀÚ}/ÀÆñ¨À³ôØÀ¢“ À‘¥/À‚a,Àgü/ÀLtìÀ4¬ŒÀâÀ пùk™¿âõU¿Ô‘)¿Î­¿Í«Û¿Øƒû¿èU˜¿úü˜ÀžÀæ,À)”WÀ>z!ÀVAêÀpËÀ‡¬™À—¸À©\ À»ØÀϳíÀä:§ÀøéÁrzÁ¯ÈÁ.yÁ*$ Á6/’ÁBÁO/2Á[öAÁhÌÊÁuø4Á¯³Áˆd³Á Á•ò‘ÁœâBÁ¬P;Á¥dÚÁžxÁ—œlÁË—ÁŠ €ÁƒYmÁy‰ˆÁlƒ8Á_—ôÁR÷£ÁFlçÁ:AWÁ.ŽrÁ"õÇÁàÑÁ iÁ\ÀñŒÔÀÞ&ÀÌhlÀ»CÀ«j=Àœ‹ÊÀŽkÔÀxßÀk¢¢ÀVôÀDú|À5û¬À+#LÀ$=×À!À!M2À&ÐäÀ.ÕÒÀ7áôÀBÕ5ÀQFÀaD‰ÀuøÏÀ…ØýÀ’ÑÀ áQÀ°ÌnÀÁ ÀÓ‰ôÀæ:ÎÀú˜¼Á•$Áú“ÁÍÁ(]yÁ3ÑÐÁ?ÎÃÁKÛðÁXºÁdÀ Áq‘RÁ~fuÁ…»PÁŒaÁ“=Á™Æ*Á ‘ˆÁ¯ðˆÁ© îÁ¢2÷Á›qÀÁ”ÀüÁŽvÁ‡‰NÁ\Áu ÌÁh‹Á\+LÁOÿÁDABÁ8 'Á-yˆÁ"¬`Á Á+bÁwóÀör%ÀåhÀÔÙ±ÀÅ\LÀ¶äãÀ©›ÀœÃ7À‘ÕtÀ‡maÀ~()ÀoéîÀe%ÀÀ^Ù{À[ãmÀ[Ä‘Àa¥­Àil–ÀrEÈÀ}ƒMÀ…p•ÀYÔÀ— À¡’·À­ìóÀ».ÔÀʈ•ÀÚtÉÀë½îÀþCSÁµ¡ÁêšÁ/ßÁ'²uÁ2Þ£Á>!ÁIš%ÁU˜Áa«!ÁmÛ¨ÁzsDÁƒ¡fÁŠ ¢ÁùÁ—(=ÁÉÂÁ¤tIÁ³°Á¬á Á¦)³ÁŸzlÁ˜ÛdÁ’N2Á‹ÄÁ…[/Á~> Áqñ‹Áe¾ŽÁYõXÁNq­ÁC>¿Á8a}Á-¸Á#¢ÁÞeÁ†Á|ŒÀþw&Àî£ÀߢŽÀѦÀÄ·©À¸n0À­ç½À¤õÀ›Ò‚À•LÀ«ÀŒÁ>À‹qŽÀ‹;ÀŽœGÀ’`XÀ–©ïÀœ,À¢RÀªBÀ³[)À½~SÀÉMÀÖÀä`»ÀôCDÁPÞÁ H¾Á9ÁmÁ(lÁ2ÞùÁ= SÁHÌÁT Á_vÁkÇÁw•ëÁã°Áˆ!ËÁŽzÍÁ”æ$Á›iÅÁ¡ÿéÁ¨–ûÁ·ŸîÁ°å,Áª5öÁ£ ™ÁuÁ–˜èÁ9§ÁŠÁƒÜÁ{€·Áo³ïÁdRÁY õÁNDÁCjEÁ9IŒÁ/K\Á%êæÁ¼JÁ`Á .’ÁNòÀú. ÀìºKÀà!àÀÔ˜iÀÊ3ÀÀÚáÀ¸ë"À²cqÀ­gÍÀª„™À©g¸À©w"À¬jWÀ°À´€aÀ¹ÓvÀ¿¸ÀÇXÀÏéüÀÙÀäÛCÀñ&ÀÿkÁàÁßÁ¬1Á ²ÌÁ*(0Á4$‘Á>5ÁH±RÁS¡oÁ^½7ÁjºÁu™ˆÁ€ºVÁ†ÀçÁŒßVÁ“Á™^"ÁŸÀ6Á¦C–Á¬ÙÁ»¤ Á´ü¼Á®qšÁ§ó¿Á¡~­Á›(fÁ”õ%ÁŽÈÁˆ®“Á‚É%Áz;¯Áo ;ÁcáûÁY±ÁNôNÁDï»Á;X‚Á22íÁ)?Á!HÁ1OÁt;Á  DÁ —ÀûËÀð¢ÀæÎÀݳÑÀÖFÕÀϳ.ÀËzßÀÈpyÀǃ¨ÀÇoLÀÊJ©ÀÍêÈÀÒ[¬À׈ÙÀÝOþÀäÑ`ÀìÑÀö> Á`AÁ9•Á ÿ Á#ÁAÁ$2ÚÁ-,Á6%sÁ?ÞaÁIÝÁSò Á^ž[Ái¢ Át±Áý+Á…ÓîÁ‹»ÊÁ‘·ØÁ—ÛuÁž Á¤MÁª¥KÁ±êÁ¿ÓXÁ¹QÎÁ²ÝŠÁ¬rÁ¦#%ÁŸð§Á™ÀeÁ“«’ÁÇ‘ÁˆXÁ‚~7ÁyÉŽÁnï_Ád¯qÁZ»YÁPïÂÁG¬ýÁ>¨eÁ6¼Á.$šÁ&Q‹Á¨ÁG¦ÁæyÁ ðvÁ“lÁÒÃÀúÖœÀó©qÀízôÀéŽÏÀ怎Àå°Àå“(Àès»Àì•ÀðcæÀõVEÀúúKÁ$HÁú*Á —×ÁšqÁLæÁ•«Á!¶¾Á)4Á1.+Á9– ÁBœ*ÁKÐ.ÁU°DÁ_­üÁiÙéÁtŸ^Á£èÁ…UæÁŠþãÁÛÁ–Â…Áœ·ÃÁ¢Ø}Á©bÁ¯G)Áµ—}ÁÄ>°Á½ÑÚÁ·jPÁ± ÁªîŠÁ¤ÃôÁž´GÁ˜ÑñÁ“2Á{PÁ‡æ–Á‚r(Áz…eÁp”>Áf°°Á](µÁTÁÁKP^ÁCõÁ;R&Á3«?Á,ÀnÁ&”ÁѺÁ1ÔÁò Á>³Á >ÁGÁ½ÈÁÇÈÁ]fÁî1ÁÁ\mÁòÁ?ÍÁ §ÚÁ s*Áç‹Á®òÁ Á¤Á"’ÏÁ(}gÁ/^õÁ6‹#Á>ZÕÁFvjÁO2 ÁX<Áa«1Ák™"Áu–½ÁáñÁ…ZêÁŠÙÁZØÁ–œÁ›äYÁ¡ÎmÁ§Â_Á­Ý¶Á´1ÁºK¡ÁÈÇkÁÂctÁ¼dÁµîŽÁ¯Ï|Á©ÆHÁ£ä‹Áž oÁ˜z Á’ïTÁz(Áˆ=vÁƒ6­Á|†-ÁrĤÁiˆÁ`ºÕÁX*$ÁPNâÁH–ŠÁA=™Á:YHÁ3óÁ-ïÌÁ(xxÁ#U©ÁÔCÁÌÁ}SÁ¾[ÁÛ‡Á¡~ÁnÁd’ÁiÁAˆÁNoÁ¤‘Áw@ÁÈWÁ"„cÁ&£ˆÁ+©¥Á0ß/Á6¡­Á=+ßÁD,ÁK‹¼ÁS;Á[þ ÁdÒ@ÁmõdÁwœ-Á€Á¬Á…È!Á‹<ÁoÁ•éªÁ›jÁ¡fÁ¦õüÁ¬â¤Á²Õ±Á¸ëçÁ¿$ÁÍ]bÁǸÁÀõÃÁºàâÁ´Û@Á®ú‘Á©,ÏÁ£€.ÁýÁ˜ˆ Á“BÙÁŽ%ÿÁ‰-õÁ„BÁ ÂÁv39Ám‚ëÁePQÁ]†žÁUüdÁNâ`ÁHáÁBºÁÁ¿ðrÁº+Á´>PÁ®±Á© ½Á£–PÁžKgÁ™ YÁ”ÙÁ.ÁŠ` Á…Ü2Á‡+Áz”ÒÁreÁjäáÁc«HÁ\‘ÁV"¡ÁP ÁJpùÁE Á@h¹Á4Á/¥¹Á/ü¶Á0öŽÁ2—çÁ4ŽÁ6ÅýÁ9…¤Á<“`Á@F¹ÁD?‘ÁHÌžÁMåÁS$qÁY.™Á_åúÁf²~ÁmùlÁvÁ~•ÇÁƒ”QÁˆ+ÁŒÝ‚Á‘¿SÁ–°Á›ÚkÁ¡3ŠÁ¦œ¯Á¬GÁ±¡’Á·RãÁ½-ÁÃ’ÁÉ+ÁáÈ­ÁÛ£ÁÕ”xÁϧšÁÉßbÁÄ1ÞÁ¾qÁ¹>Á³¾¬Á®quÁ©L\Á¤a¿ÁŸ³ Á›÷Á–¢äÁ’sqÁŽ]WÁŠdôÁ†Æ•Áƒ_+Á€!¤ÁzHrÁtÈðÁo”LÁk5ÉÁg&¸Ác»¤Á`“$Á^_Á[úÁZ„EÁYeéÁXˆ‹ÁXsEÁXÑŠÁY® Á[&~Á\è¤Á_C%ÁaÈ\ÁdúñÁh‹–Ál•³ÁpÜ“ÁuÅÁ{.PÁ€q Áƒ“mÁ†ÏLÁŠ`3ÁŽ(ØÁ’ ÁÁ–>ºÁš»_ÁŸNkÁ£üÉÁ¨èzÁ®™Á³4UÁ¸!Á½ã›ÁÃk­ÁÉ4ÁÎõÍÁÔã ÁÜü9ÁÖÍ­ÁУIÁÊ‘lÁÄ¢îÁ¾ÚÇÁ¹(HÁ³…7Á®œÁ¨¾JÁ£y:Áž`ZÁ™†íÁ”ÛLÁB Á‹ãíÁ‡ÈsÁƒ·ÿÁÒ¢ÁxÛ!ÁrXÁl-Áfn­Áa ÷Á\sÁX\¹ÁT¬ÁQHÁNÙcÁLâêÁKGïÁJ'ÍÁI"ºÁI¡ÁIlóÁJbÂÁKêfÁM°ÁP2KÁRÉÜÁV.ÇÁYÄ0Á]êfÁbB­Ágs„ÁlìpÁrø†ÁyHŒÁ€ NÁƒÆìÁ‡VÁ‹ž¯Á'Á”ˆ¿Á™'çÁž Á£tÁ¨C*Á­‹\Á²ôæÁ¸¸Á¾1vÁÄdÁÉîPÁÏÜñÁØAÁÒuÁËÔtÁÅ©åÁ¿—Á¹§[Á³ÜëÁ®!öÁ¨~óÁ£ ÁÇMÁ˜ÝÁ“ƒyÁŽ·ÝÁŠoÁ…uÁ7\ÁzS€Ár_vÁk"ºÁd/¨Á]ØÔÁX!.ÁR¬ÁMÇZÁI›’ÁE°‰ÁBBÁ?ÔÁ=ÎíÁ<¾Á:é±Á9ÔÁ9ºªÁ: ùÁ;$ÅÁ<®NÁ>‚×ÁA!pÁCݦÁGiDÁKíÁOSÅÁS܆ÁY-–Á^ÔåÁe±Ák‘éÁrÑÁz\nÁÁ…]9Á‰ÔßÁŽ_ˆÁ“,¡Á˜:¬ÁXäÁ¢˜Á¨SÁ­›µÁ³NÝÁ¹ .Á¿ÔÁÄíLÁÊûdÁÓ›{ÁÍIºÁDZÁÀÛ˜Áº°ÒÁ´ŸÑÁ®³¼Á¨æ«Á£"¶Á‚mÁ˜ŸÁ’ÝÐÁ²@Áˆ¶<ÁƒìlÁ~g“Áu}’ÁmE’Áe7ßÁ]•ÁVˆ]ÁOÍÁIémÁDSïÁ?GÖÁ:Ý´Á6àÁ3·Á0æ:Á.ºðÁ,úçÁ+µÑÁ*§&Á*ƒKÁ*ÄÉÁ+ìbÁ-r6Á/d Á2–Á5>Á8£ÁÁ<ŒÁ@ÕÁE¯ÁÁJõ%ÁPìŸÁW5„Á^¹Áe äÁmJÁu‘Á~r Áƒ­ûÁˆcSÁbIÁ’xgÁ—«ÊÁÁ¢¸ Á¨ngÁ®8'Á´§Áº 7ÁÀèÁÆM¼ÁÏ%ÙÁȰ)ÁÂWÑÁ¼@ÁµåcÁ¯·ÃÁ©¨ÇÁ£ÁVÁõÈÁ˜.ÉÁ’’§Á1ŒÁˆÁ‚ÞeÁ{ÚÁrIZÁhíÇÁ`M‚ÁX.-ÁP6üÁHûúÁBÏÁ;ÍÁÁ5ÿºÁ0ßÁ,$ZÁ(8‹Á$Ñ´Á!ûÝÁ¦óÁìnÁ¥/Á¢ïÁr3Á¢ÂÁÏäÁB0Á W&Á#Á&BêÁ)ßÁ-û Á2„AÁ7—éÁ<÷;ÁC›ÁIŒaÁPãúÁXs Á`ÁiOãÁr*îÁ{cˆÁ‚‚Á‡©ÁŒÏKÁ’6Á—×ÁŽoÁ£Q(Á©2ÉÁ¯-˜ÁµEýÁ»}wÁÁÊ/ÁÊÕ2ÁÄJÁ½ÐªÁ·q\Á±-ìÁªñpÁ¤¿!Áž² Á˜ÏìÁ“uÁIkÁ‡²¶Á‚\\Áz]ˆÁp÷ÁfKnÁ\˧ÁS¯,ÁKFEÁCšÁ;p¦Á4iÁ-Û¯Á'×çÁ"w»ÁœÑÁœ€Á ÂÁ€Á™5ÁùgÁ ­ÏÁ °[Á Ž—Á ±°Á Ü<Á6vÁjYÁ 0Á~¡Á1¥Áš~Á$VÁ)ŠÁ/FÚÁ5k¢ÁÁª}@Á°´Á¶ø/Á½O¸ÁÆ—ÁÁ¿÷«Á¹nöÁ²ù:Á¬•Á¦IÁ ¢Á™ÏÁÁ“¿UÁàÁˆ" Á‚sâÁyþÁo%Ád¶ÍÁZs¼ÁPˇÁGÁ>Œ Á6?ëÁ.(\Á&ã†Áù–Áè•Á0ÃÁZÇÁ SÁyLÁ)XÁ¾LÁ¾Àý…fÀû‚gÀû^\Àû³óÀþxÁbtÁ«KÁN³ÁØÁ ²*ÁKÁ?ÎÁŸnÁ!¥Á( ãÁ/K Á6ÇþÁ?HÁGãÁPé×ÁZ˜éÁd”çÁn­ÞÁyIÞÁ‚4&Á‡×ÌÁŒ£Á“rªÁ™‡GÁŸ¹4Á¥ïJÁ¬+ÆÁ²ˆ)Á¹!ÁÂŽ³Á»ÍSÁµ"§Á®”ªÁ¨"åÁ¡¾¿Á›e‹Á•$ÁŽî”ÁˆÛeÁ‚ü<Áz˜SÁoD¶Ád%3ÁY’ÁO zÁDò²Á;€xÁ2=·Á)w¶Á!M;Á§dÁe‹Á ïÁCÈÁ= Àùk­ÀñäáÀêèØÀæGüÀâhÏÀß¶êÀÝ®dÀÝ~ÀÀÞSÀàLxÀãrÀè6ŽÀíË—ÀôÕ¢ÀüãÇÁÁLoÁ ßÿÁ1ÉÁÍÁ"hsÁ*K_Á2Í›Á;±ýÁEP9ÁOS ÁYwsÁd"ÁoèÁz)vÁ‚À¯Áˆ¦ÁŽÀÁ”÷LÁ›/­Á¡o°Á§ÒœÁ®W¡Á´ûÁ¾™ÒÁ·ÔãÁ±uÁª]ªÁ£Å`ÁNkÁ–é Á‡ŠÁŠ?àÁ„±Á|ªÁpXâÁd÷=ÁY¡¨ÁN‡›ÁD‰Á9®•Á/¸²Á&EKÁÿÎÁ„&Á «2ÁA‡Àü×5ÀñÀæO2ÀÝœÀÔÚ0ÀÎ96ÀÉ2ðÀÅ'ÝÀÂ7äÀÀ8,À¿Ÿ#ÀÀY©À¶'ÀÆEQÀ˼ÀÑ6ðÀØPñÀà¶Àê ¬Àô£ÁYbÁð…ÁÂÁµÝÁ½Á&š†Á0ÂÁ:ÓÁDB3ÁNÈ ÁY®ªÁdÍÍÁp>Á{átÁ„ 8ÁŠG7ÁïÁ–ÈhÁ2¾Á£ÀÁªlìÁ±3“ÁºÍ¯Á³íãÁ­–Á¦X ÁŸ£ÈÁ™ÎÁ’‡]ÁŒÁ…°øÁ~¾ÓÁrzTÁf†'ÁZÚœÁOopÁD }Á9¾Á.Ÿ¸Á$UùÁ¢ûÁ$JÁù[ÀÿÇ[ÀðW„ÀâvÀÕ•²ÀʆáÀÀÌ`À¸nëÀ±îæÀ¬5wÀ¨7À¥U/À£I/À¡Ü˜À¢µ’À¥ZÀ©/À® –À´¢IÀ¼G\ÀÄÁÛÀÎÌáÀÙ{ãÀæ,©ÀóÜ"ÁDÑÁ uÁõGÁÿœÁ$éÁ/ óÁ9•XÁDYÈÁO|ÁZè`Áf¬úÁrßYÁ;‡Á…×}ÁŒ+bÁ’¥nÁ™@ÉÁŸöVÁ¦¶rÁ­âÁ·?†Á°E¾Á©UgÁ¢rzÁ› jÁ”ê ÁŽOyÁ‡Í”ÁVUÁuÒ÷Ái"kÁ\ÛÁQ qÁEbÌÁ9íJÁ.¯žÁ#ÌvÁQ_Á´Á—ÀøXéÀæÿÙÀÖ¯ÀÈ:kÀ»À®þ)À¥ Àœ²«À•«Àá’À‹^!Àˆ‡¬À†n^À„ó«À…ßðÀˆ(ÎÀŒÌÀ‘OØÀ˜ ¢À TäÀ©d©À³ÕÀ¿dÄÀËá~ÀÚÀêºÀû¢Áh\ÁÕOÁ×´Á$b¦Á/ >Á:7%ÁEËÿÁQ‡ÛÁ]¬ÝÁj¼ÁvivÁ•”Áˆ!eÁŽÏ.Á•ˆ,ÁœAtÁ£Á©ß[Á³ÐøÁ¬ÁãÁ¥Ä£ÁžÑÁ—ÞPÁûõÁŠ89Áƒ—ÿÁz-ƒÁm/Á`M`ÁS­ÍÁGlWÁ; qÁ/ø¾Á$•jÁeñÁª¯Á1‘ÀôCåÀáPçÀÏG<À¾qÀ®°À è6À”“4ÀŠ.\ÀRÀs€ˆÀgN6À^EÀWÝ ÀSתÀROÀTAÀX‹À_%*ÀiµuÀw²2À„bMÀŽKFÀ™R&À¥‚ÑÀ²ë‡ÀÂM]ÀÒ:·ÀãÓÀöcúÁ¿uÁ=¨Áß<Á%¤Á0² ÁÁn1EÁ{[;Á„`Á‹æÁ‘ÖÁ˜¢ðÁŸ‰ÊÁ¦‰ÎÁ°‚±Á©^Á¢EðÁ›CÝÁ”PÁ_OÁ†s“ÁB›ÁqèÁdÓöÁWʦÁJÒöÁ>BÌÁ2'SÁ&LMÁŸœÁIãÁ"$Àó$ ÀÞkÎÀÊ}ƒÀ·Å)À¦’îÀ–8ÓÀ‡uJÀu"âÀ_ÏÀKÁ’À<ƒ;À/qÞÀ&‘}À ÜÀà ÀÝ+ÀîûÀ!uAÀ(͘À3~ˆÀA)*ÀRVßÀfÂrÀ~„ÀŒ9ìÀšÉ9Àª.ËÀºÖWÀÍzÀàVœÀôö7ÁñÁ —Á©›Á'L4Á3M0Á?ÒÉÁL–ùÁYw1ÁfЧÁsßµÁ€²oÁ‡…JÁŽe¡Á•X(ÁœdÁ£{“Á­iÈÁ¦5æÁŸ¬Á—ßjÁÎ Á‰Ö{Á‚é6ÁwøËÁjH_Á\ßRÁO°KÁBžˆÁ5˜£Á(ù„ÁìšÁàÁFŸÀô´ÀÞ=öÀÉ%ÈÀ´³ÒÀ õˆÀ03À|/À^¢ÀBv‹À*ðôÀþ|Àó¿óHR¿àU¿Ò—ì¿Éô}¿ÆØ¿ËpÑ¿Öy¿æcÌ¿ü­À ¾åÀP5À3 ŠÀKsÙÀfÅÿÀ‚´yÀ’ÒLÀ¤¨mÀ·w8ÀËëÀáéÀöÿÍÁöªÁxEÁp_Á+UÁ7î_ÁD̨ÁQÌÁ_,×ÁlÝdÁz¤éÁ„9`Á‹9©Á’MÁ™aÁ zrÁª‹„Á£?ÁœÎÁ”οÁœ½Á†{CÁ~æ³ÁpðýÁc iÁUR–ÁGæTÁ:§ÎÁ-<Á ÇÁýtÁ·eÀ÷¬Àà%ÉÀÊ$µÀ´ºwÀŸ”AÀ‹éÀqû?ÀOˆóÀ.Ö…ÀM ¿ñ)Û¿Çò¿£pg¿Š8“¿gqß¿MEп>c¿:s*¿??{¿T¿v¹|¿“ÿ±ù=¿ÖûÌÀ‚ÜÀ¸À6ñÀÀVøkÀyc9ÀŽ›nÀ£aÀ·ÍðÀ;lÀä¢ÀûÉ*Á –ÁžpÁ#yOÁ0U×Á=m"ÁJÞ%ÁX‚ÁfFÁt'­Á!çÁˆ7öÁWèÁ–êÁ¹ÁÁ§Ã‹Á kíÁ™»Á‘Ó×ÁŠxÁƒmÚÁx’OÁjVËÁ\MÁNN­Á@t“Á2ôÏÁ%´ßÁvãÁ –zÀþ&ôÀå6ÀÍbÿÀ¶ÁÏÀ ›µÀ‹<^ÀmÀVÀG|åÀ#P%Àð“¿Ãîà¿‘%6¿HV ¿I¸¾†E ½Ú~<´¼H=”î=ŸöÇ='Qî½Jh¾Ö¶¾ªÐ¢¿Õä¿g¼¿¡©ê¿ÖôÀ¾¹À*ŒÀN-`Àu`À£À¤À»›(ÀÒêØÀëŒÎÁ9ØÁYÁcÁ)EÝÁ6ÁCÁDC)ÁQöºÁ_÷DÁn4pÁ|~(Á…d¼ÁŒ›Á“ÚÛÁ›ÇÁ¥=ÐÁÎuÁ–báÁÏÁ‡¬XÁ€lJÁr€dÁd8§ÁUðìÁG¸Á9µæÁ+æÊÁ_Á OÁËvÀí·ÏÀÔžaÀ»š À¤íÀ¡)Àn–ÒÀC½WÀk¿îZT¿©NÕ¿QwƾÑ3^¼¬/â>ˆ‹¶?Ä!?-’y?O½²?_ÏU?_߇?S}??]Ó?ô4>Û4â>4¡¾¯¿^Àªx]Àà ™ÀÛÀxÀõ{æÁÝXÁ) Á"®VÁ0K»Á>ŒÁL#ýÁZOÌÁh–9ÁvøôÁ‚¼nÁŠmÁ‘McÁ˜¤QÁ¢ÉƒÁ›YlÁ“éåÁŒz`Á…žÁ{UÁl°‹Á^;UÁOïoÁA¥åÁ3\`Á%3ZÁgÑÁ ó2Àù àÀÞZ‚ÀÄgNÀ«f@À’æÀv"ÀIWFÀ™¿çÝM¿šÄ¿#í¾èH>™·¿?1r3?~c? ?¸Çe?ÉÜÏ?Ñ¡Ø?Ñ$¬?˦Î?Â4¥?²O ?—£‘?fá?q=>AŸ¾i¿K#¿®ç…¿þ À*ÀVÀW-¿À‚ ÖÀš½‹À³©áÀÍ‘FÀçÃÜÁ?ºÁÚ–Á-Á*s)Á8xÆÁF‡ÎÁTÓÖÁcUÈÁqê½Á€@žÁ‡™ÞÁEÁ–p¢Á }Á˜öÁ‘t§ÁŠÁ‚’jÁvXÁg”MÁXØÆÁJI<Á;êtÁ-–NÁL§ÁàÁ:àÀë=‡ÀÐTiÀµkÍÀ›QöÀ‚j¸ÀSC…À$?@¿ðfý¿˜ïÈ¿Ê;û*{?aG?y¹Ö?°÷{?Úƒ?ý“@ 1‰@Òõ@xŽ@!@±Ñ@SŠ@ä?ôž?Î-J? sÌ?X=->À%ò¾:áC¿I)!¿¶Ÿ’ÀÅsÀ6|bÀeU¾ÀŒ)žÀ¦–ÀÀ6‰ÀÛ9Àö¾ÁÈýÁÖÜÁ$ë„Á3WÁAsÁOÜSÁ^h.Ám fÁ{øÁ…iÁŒ×UÁ”LBÁžBÀÁ–ºâÁ4¥Á‡¯ŸÁ€,@ÁqhÁb˜íÁSÔ)ÁEfÁ6fÁ'ö¾ÁžþÁ HmÀú$;ÀÞoöÀÂÓ3À§Ä À)¢Àf1TÀ4:À` ¿¨ˆþ¿&¸<åÃ+?!‹?“§š?Ъ@ý@]@*/}@7µê@A^ @F&ê@F1@DuÁ@?sj@5ãT@&gµ@êT?ó”¿?ºÓ®?uÏ >ÄU¾tcy¿i®¿ÑsÀlÀIÞÀ}dÄÀ˜«¬À³±ÔÀÏRÀê¥LÁWˆÁm§Á¼KÁ.#3Á<§’ÁKIXÁZ[ÁhêÑÁwÄÁƒZSÁŠßíÁ’pSÁœ?’Á” *Á eÁ…ƒÁ|üÁmøÁ]ÿõÁO/Á@>†Á1nIÁ"¨€Á1ÁŶÀï­ÀÒ~$À¶†œÀšÜQÀ~à•ÀJ(ÀÇ|¿Ç×ù¿Jú®½³*F?û™?›` ?áï·@T–@+-T@AÁ@TLd@bï@lÿØ@qôŒ@rÙ.@pÕ¯@k”:@a!Ï@Oû@9\`@ ˆQ@›b?¿r ?i®f>„œ¾áú`¿–¿øP”À/Ç~Àc×ZÀŒîÁÀ¨8ÀÃÊ4ÀßÜGÀüOèÁ Á'äÁ)à Á8aÂÁG'ŽÁV­Áe ëÁt•Á„jÁ‰=Á¬êÁšo‰Á’ÊÁ‹$®Áƒ€\Áw˵Áh±ÄÁY®MÁJ«ÚÁ;©—Á,»“ÁïuÁBÇÁªÀä?ÀÇ¡ÐÀ« žÀްöÀfôýÀ0ÓÓ¿öÂZ¿²Œ¾ªE>ÙVó?Ä…?ãS.@èY@6Ò„@Rcº@i U@{ï¯@…®›@‹ä@z@Ž!@N@Š”@ƒç}@tdì@^‰r@B#À@#Zw?ÿÛº?°AÉ?;§–:Ö-¡¿AW(¿ÅÏÀ ÀLºÚÀ’úÀf¥À¹ÙÑÀÖb|ÀòôOÁ€ÁÏ·Á%œqÁ4„®ÁCwÁRk™ÁaprÁp†ëÁ´¯Á‡{hÁ %Á˜£*Áó7Á‰KîÁ¨¹Át ÁdÆÁU†ÀÁFapÁ7^Á(h Á{àÁ žfÀ÷ç­ÀÚ³ÃÀ½ÙÀ ~ÈÀ„CÝÀP'eÀZ¿Æ1N¿6O,=¯–t?\¨û?ͳö@#F@9´@Z¥J@uÿ6@†ÛÇ@ÔE@˜ð@žP@¡Ÿ@¡Gò@ ™;@DÖ@•Kä@‹!¬@}Ž2@aiü@@‚È@»f?æûþ?’Æ>ɦξÀ[¿—¡çÀ¨™À7šqÀo¦$À”kÀ°È0À͸QÀê¼LÁ“Á~Á!ûÆÁ1 àÁ@ƒÁOˆÁ^8Áme•Á|£­Á…ø°Á SÁ–ÿÊÁIùÁ‡•gÁÄÁpfùÁa‡ÁQê$ÁB»‚Á3•+Á$y„Á#Á¦ºÀ省ÀÑÿÀ´qÆÀ—K8ÀuláÀ<…¬ÀÌñ¿š¾¹Ý'>íÄÚ?¡Á1@ßc@.¸†@W}#@zKI@‹ç@˜ {@¡åæ@ªYr@¯Ç”@²£@³$Ô@±þ…@­œâ@¤ÞÔ@™ò @@|·â@[A@6ðÕ@ „ª?ÁõS?CØñ¼ó®Æ¿[S;¿Ú¯‚À%9¤À]{ÇÀ‹®À¨ 0ÀÅÕuÀã3›Át™ÁrvÁvHÁ-Á<»ÿÁKé2Á[fÁjNëÁyš…Á„uÁŒ%‡Á•lÁ±“Á…ÿÁ|¡¶ÁmJ"Á]øbÁNª©Á?b³Á09Á!$&Á Áû”Àè”ÀÊTnÀ¬¡ˆÀGÀd,qÀ*Þƒ¿ã-¿g¼€½Gâ…?I0œ?Ì$@5@G²}@q¯@ŠÄc@šI@§5m@±—|@¹‚¸@¿l>@º6@Ã~®@Á°t@»ßb@²¿!@¦ú9@š#@Šæ@så@NA[@#æÛ?îu´?‹²â>Æ3¿}5¿µ£À=ÀM¿áÀ„,oÀ¡p:À¾´ÀÜ#§ÀúZÁ áÁ8ÅÁ*gÁ9•fÁHöÁWÿÈÁgPùÁv°Áƒ •ÁŠ¿âÁ“òZÁŒ>7Á„„,Áyš~Áj=ZÁZñMÁK§±Á<^Á-yÁѳÁ³žÀÿ@ ÀáÚÀà ÀÀ¥G)À‡¿çÀU&·ÀÃ[¿ÄÎ=¿%º->U4Þ?‡~E?ï³@*Sh@Zf!@ƒ%@–9ë@¦&%@³ž@¾…§@ÆÁp@Í =@Њq@Ñ›%@Ïf@ÈÂE@¿,7@³Ñs@¥áƒ@–§h@…o¸@d`u@9XÄ@ h»?°óP?¿Ÿ¾œun¿–^@ÀÕÀ>$RÀy!ÀšrÀ·©HÀÕ´‘ÀóÀûÁçìÁÎÁ'6æÁ6ƒ‹ÁEÕÁU&ŸÁd|]ÁsàNÁ£¾Á‰WVÁ’vôÁŠÁíÁƒ;Ávµ>ÁgN8ÁWèÁH“FÁ9T(Á*ÊÁáµÁ «)Àù'fÀÛ À¼ó¿ÀžëäÀˆÀH¡\À4翨Õs¾â¾>Ü~{?£ï@v;@9`Ô@iPˆ@ŠÝš@Ÿ—@¯Êz@½ð³@Êp@Òò @Ù»@ÜZ@Ým@Ú‡µ@Ô/@Êp—@¾øu@±F½@¡”@…@wÛ'@Kþõ@ I?ÑéÞ?L½Žb¿qW‰¿ì]PÀ0ºFÀk3@À“eHÀ±sÏÀÏ‚VÀíšÊÁåÁ%~Á$o<Á3¸ùÁC½ÁRQ—ÁaµºÁq*òÁ€QSÁˆ -Á‘BaÁ‰dÁÃrÁt KÁdÆàÁUméÁF7Á6¼…Á'[nÁ»ÁÆ{ÀóHÈÀÕEÍÀ·E¤À™/‡Àw'-À<¯ÙÀ=J¿’K-¾„Ç5?l?»V×@ˆE@E‚Ä@uqÉ@‘lù@¥ìz@·¯@Æ^÷@Ó@Üï@âãÒ@æ ø@æVÐ@ã³™@ÝÒ?@ÔSö@É4@»z¾@«eÊ@™Ý@„‹Û@\ Õ@+À??ƒž¯>öi¿=«&¿ÓtßÀ$–À^ŒmÀOTÀ«j£ÀɆsÀç½Á$ôÁvÁ!Ç/Á1UÁ@qFÁOÞÁ_NÁn½|Á~-Á†Ð Á?ÁˆRßÁ€}ÁqŸJÁb(žÁRÆ'ÁCl:Á4ðÁ$¹ÝÁ`æÁÛÀíÂ%ÀÏÀÙÀ²îÀ“ùØÀl —À2f¿ðÈï¿zÑ ½¢ñì?G™€?Ñ¥u@Q@P:@€²2@–å+@¬Å@¾st@Ín @Ú[Y@å@ë²@îE@íú@ëtÎ@åÆ@ÜúN@Ñ¡I@òs@³t @ —ö@‹ÂW@iˆ@8€[@Nn?›×t>®á~¿ y¿»³À¨KÀU]EÀˆgÀ¦*ÃÀÄtšÀâê›Á°NÁîUÁ8žÁ.ždÁ>ÁMŒ Á]ÿÁlyòÁ{òÁ…ºàÁŽò˜Á‡27Á~í¤Áo{LÁ` ÝÁP˜oÁA'Á1ÂÃÁ"e§Á âÁ»°ÀéuÀÊÌŽÀ¬êÀÀ Àb¢ªÀ'®Ï¿Üo<¿Sž=–ÞÀ?s~ü?äÈ@@'êA@[L@…Å*@œ²ˆ@±åé@ÄYr@Ó¦e@àÅp@ë£ö@òŠ@õb&@ôÇ @òá@í‡@ä¥{@Øœp@ÊŒç@¹¿Ü@¦…&@‘@sÙ@Bnè@?¯»>ÿ>2¾ÉŒƒ¿§ÒÀ&ÅÀJ—½ÀƒHÀ¡kzÀ¿ãªÀÞjÁÀüñØÁ ÀÍÁ$ÉÁ,ŸÁ;úvÁKfxÁZÙKÁjPÏÁyÓºÁ„² ÁŽôÁ†V‰Á}‹Ám8Á^'ûÁN³\Á?>¾Á/Ê€Á _øÁ=ÁÒÓÀår¢ÀÇ?˜À© ÀŠä¶ÀZgÑÀ ‰¿Ë:`¿,æÙ>Q-?Š9ó?÷g¯@1’l@dßA@Šä @¡¿™@¶Á‡@Ézs@Øú @æÄ@ðŇ@÷v•@úÔð@úyX@ø(¶@ó3@êôî@ÝþŸ@Ï„)@¾L'@ª£ø@•3f@|†à@K¬@yF?Âb´?$Ú¾†yõ¿—çÀJÀA;À}”€À&ÔÀ»—ÀÚüÀø¦Á ±–ÁmÁ*ŠmÁ9þÂÁIs*ÁXç±ÁhdþÁwî|ÁƒÁÁi²Á…ŸIÁ{ªUÁlËÁ\„…ÁLþ˜Á=ŒøÁ..áÁÜ%Á‰¿Á7rÀáæJÀÃÁjÀ¥ÚÀˆQÀTUÀ*+¿½T^¿K7>£Šý?™®é@±{@8ÆJ@lS§@އƒ@¥À@»Ã@ͼ@Ý@°@êR@ôá¡@ûϳ@ÿ«@ÿ×@ý2@øQÉ@ï¬u@ân@Ó„“@Áÿr@®3A@˜Æ§@Î9@R»·@þ@?ÒC?GÃ2¾ Ê¿‡D¿ýÞÀ9“öÀv [À™pÍÀ·á.ÀÖT3ÀõÏÁ èÁM£Á(ºrÁ8-fÁG¡ÎÁW6ÁfŽÓÁvóÁ‚ÑÚÁŒÔÁ… …Áz~)Ájî±Á[h3ÁKì½Á<Á-åÁËúÁƒÀþ~LÀßødÀÁ»À£ÉÀÀ…ÚVÀOøBÀËY¿´É@¿œÄ>Çøœ?¡ew@b¶@=‚@q‹ô@‘W—@¨'%@½Ÿ@ÐŽ\@à­³@î Î@øY@ÿE¡A™žA„ÌAŒê@üæ@óZ~@æn®@Öî—@Åun@±Z*@œª@… Y@Yîd@%éj?àßý?_‡½¼Æha¿oy¿ïñÀ3KÀo®âÀ–(8À´˜˜ÀÓ/Àñ÷‚Á_øÁÄ0Á'(hÁ6‹ëÁEîÁU_5ÁdãÁtrÁ‚ÁŒSÁ„†ZÁyzÁi÷;ÁZ…ãÁK$ÁÁ;ÅùÁ,g1ÁÁ Á ÀüæöÀÞaxÀÀ"ÓÀ¢bƒÀ„®ñÀMö»Àm¿¯õÁ¾ð@>ÚU‚?¥±ˆ@ Ï™@?º!@ræµ@’7±@©an@¾ø@ÒÖX@ã@ð‰ß@ú‹jAì/AüCAeAûn@ÿK7@öv(@é8@Ùy¤@ÈrO@´¸Ì@žåÞ@‡ëé@_I:@,e?놘?yrÓ=ŠÈ¿Z½¨¿ãaiÀ-šmÀj»À“FaÀ±«øÀÐGÊÀî÷ûÁÔÁ-eÁ%Š×Á4ü¿ÁD„¾ÁT·Ác ¨Ás.“Á^?ÁŒ?Á„LÁyøÁižÁZ…ÁJ¢&Á;=ˆÁ+áïÁ˜ÀÁ `µÀü†ØÀÞPÀÀ}À¢À„_1ÀM¨À“­¿°6°¾ò6>Õ Y?¥åE@ ‘@>Ã_@r^‰@‘ËW@©€â@¿’¡@Ótô@ä™@ñÜ@üÛA¼çAÞÇA¿A4´Aë:@ø„F@ëž}@Ü @Êò @·jª@¡‘˜@Ѝ+@c¢z@0j?õóƒ?„ª|>ø¿F ª¿ÚM®À(ÊdÀe LÀÐ:À¯ThÀÍÙ.ÀìigÁMÁÿ’Á$sSÁ3çÁCZáÁRÕòÁb[£ÁqèÊÁ€»pÁ‹ÉÍÁ„ ŽÁxŸGÁi- ÁYÁ’ÁJ_UÁ;Á+Õ¹Á™ÄÁ _'ÀüyBÀÞléÀÀ†÷À¢¡)À„ë&ÀNtŠÀ׿¿³€¾ýB>ÉÕÕ?¢îG@ém@=^@p Ú@‘ã@¨¿8@¿@Ó8Û@ä*@òb@ü“dAˆAS^AÍÌADAÕ @ú¬Õ@íÖt@Þ 2@Í ì@¹x”@£º]@Œ”?@gë @4ƒÍ?ûy‡?ŒDp>D屿7ÖØ¿Ò àÀ$®À`¹ßÀ޵èÀ­T÷ÀËöçÀê˜ØÁžÁÿÁ#tFÁ2æÄÁBYÖÁQÔ±ÁaWÕÁpäÔÁ€>ˆÁ‹ÇDÁ„ÔÁx¾ºÁih$ÁZ¶ÁJµÇÁ;eáÁ,%mÁö‚Á Ù­ÀýGÀߊRÀÁ—dÀ£ÉÀ†BÀQÑËÀ#Í¿¸üd¿í¹>²-–?©T@Uw@:àx@n ª@-@§’O@½­Æ@ÑâÑ@ãS~@ñX@üÔAðAdÅAþ£A’AGÀ@ûˆÆ@ï…{@ßš @ÍÃK@ºI@¤þ@”¤@i©@6 í@G ?Í\>pS2¿.ð=¿Íà2À"²èÀ_ mÀÄÀ«öoÀÊ…2Àé)¦ÁòPÁXÁ"Ã~Á2>ºÁA¼;ÁQ>:Á`ÔÁpI‚ÁÓŽÁ‹æ¡Á„-ùÁxü‰ÁiªTÁZcµÁK+AÁ;ùÁ,É›Á«§ÁûÀÿ#•ÀáYÐÀØfÀ¥Ø¨Àˆd¤ÀUñèÀ,€¿Â\ ¿¡®>‹'R?“„°@¦ @6]ž@iÔh@Æ@¥5@»t@φþ@á#ä@ïR@úHAü®APOAIA@A×T@û0¡@ð @ßG§@Í5*@ºR8@¤“$@&ˆ@iÎ@5i?ÿ«Š?v)>h“¿-1‚¿Ì³3À!¿À]ðZÀd”À«ÖÀÊH…ÀèÞ ÁÕŠÁ6 Á"•îÁ1ú‰ÁAr"ÁPíÆÁ`oEÁoù‡Á†ˆÁŒ/æÁ„¬Áy¤qÁj]zÁ[)ƒÁK÷"Á<ÄãÁ-žkÁŽ_ÁžfÁ³WÀã˜öÀÅò>À¨BÀ‹.ôÀ[¤|À!Y¿Ï+3¿8t>*$ ?…ú¹?ó5@/"@bÀ@Š L@¡•™@·©{@Ëaz@Ý%a@ëšÑ@öƒ@ýˆõAà‡A´ÖAº+A‹@úF@îÂ@Üíë@Êê˜@·zÀ@¢ @‹™@dÝ"@1~&?ù#,?Š¥ï>H:f¿7¿¿ÐûÚÀ$ ŠÀ_¹ÞÀãÀ¬KOÀÊÊgÀéNúÁùÁV5Á"³PÁ2ÁAˆÎÁQªÁ`‰ÌÁp ¼Á“³ÁŒ£ÈÁ„òõÁz‰ÝÁkBûÁ\hÁM5Á=ò—Á.áøÁç'Á{Á.ƒÀæ¶ÀÉA'À«ÑPÀŽ‹ÍÀbøÀ)<5¿ß«¿W—×=Š?gVZ?àãV@%Ë×@X·K@…3@œL²@²Ë@ÅŒ7@Öðæ@å‹B@ðZ_@ö³€@ú1¼@ûÔï@ü'å@úÚ.@ôa@èœß@×Ð"@źK@²_Ñ@—¢@†Ú¡@]½ @*¦Ñ?ë;?| Ý=ãÈ¿J^ö¿Ú—NÀ(G`ÀdgÀÀ®åÀÌ+ÂÀê[ÁoNÁ×jÁ#GZÁ2¸ ÁB)OÁQšÁÁa oÁpˆ»Á€«ÁCFÁ…Ÿ—Á|ÐÁlÖâÁ]³ÙÁNDÁ?Š«Á0…Á!¢§Á˰Á÷,Àê„*ÀÍHÀ°|À’ÞyÀkæÀ2bõ¿ò¡¿1t½ÿJ8?;#?Ê?œ@f@L=@|ëÿ@•(¬@ªR2@½X‡@Î,@ÜtÂ@çé@ì®1@ðgA@ñÑJ@òT@ð­¦@ê¡@Þv–@Ï&}@¾o@ªã#@–“g@€EÀ@Qmˆ@]€?Ö#­?Ulá½!ì¿lï@¿éê,À.ÊÀÀiÐÀ’éôÀ±°ÀωÀí[¹ÁçÃÁ!ºÁ$_\Á3²åÁCõÁR¯Áb ^Áqˆ·Á€„RÁŽÏÁ†{žÁ}Ã/Án Á_pyÁPnøÁAs„Á2xÁ#iÁÕÕÁ"åÀîá,ÀÑËÀ´àÀÀ—ö|ÀvêÀ=3¦À#h¿–î¾£Cz? &?®è@ ÈÒ@@K?Ž6?ò• @).1@Væ–@€¯G@”Q¢@¥{»@´ #@Á`š@Ë.;@ÑV^@ÔŽá@Ö6²@Ö…Ë@ÕHƒ@΃m@ÃüQ@·\Û@¨Û?@–™@Š»@X @+0N?÷/4?’à‰>µ!¾÷H¥¿¬K8À ™=ÀFx®À€AVÀ[ÀºšaÀØsÛÀö_^Á %Á!*Á(@§Á7…ÁFÙÁV/áÁe†BÁtÜ¢Á‚jÁEÁˆ¹ôÁ/ÁsH•Ád?–ÁUYÊÁFƒ™Á7¯–Á(æöÁK%Á µ)ÀúH¾ÀÝ„ÀÀâ7À¤VyÀ‡íîÀW øÀ¿Ó6+¿NÆÞ<-§a?MÅA?ÉmF@ðê@> š@gÝ@†º@–Át@¥p@±F@ºƒç@Àxú@ÿ†@Å5@Å;@ÃÖ @½î~@³ºU@¦É£@™z@‰0@hj^@=¢#@Ad?Ç…Ù?M¥;à!*¿Mmh¿Ïo©ÀЮÀVþÀ‡¦|À¤ž8ÀÁ¿õÀÞò¥ÀüîÁ (‚Á&ËÁ+1·Á:Y—ÁI…éÁX²:ÁgäbÁw%nÁƒ=žÁ‘½ÌÁŠ1=Á‚¨QÁvO0ÁgdÍÁX“ÁIÌ5Á;¶Á,`¹ÁÈóÁ8ÓÁ©(ÀäWÀÈSþÀ¬<¿À%€ÀhírÀ2;“¿÷f¿Ž¢æ¾¥ýÓ>çå?˜§?ò$’@#/æ@J¾t@n®@†Ie@”!®@ŸðÑ@¨Ží@®;ˆ@±u @²ä'@²…æ@°KÍ@«(Å@¡K@”æ @†µa@nH'@J@!%?ë.?©i>Îï5¾½Êª¿• ý¿þÀÀ3òÀjk_À‘4˜À­bÓÀÉ×§ÀæøNÁ7ÁöbÁ¸–Á.„ºÁ=z‘ÁL–)Á[ÃÅÁjñrÁz_Á„¥õÁ“ZßÁ‹ÕÁ„O³Áy§ÁjÒÁ\tÁMhîÁ>¶^Á0&ëÁ!¿ÁYÿÁõÀíiÀÑL­Àµl'À™ŸÀ|ƒ¨ÀGïÀã>¿¾áÓ¿2ƒ|=A‡¿?C_?·ØÓ@OÙ@*u^@K‰g@i@‚L@Œõ@•Jœ@š´[@Ž\@žÜ_@žRŒ@œÖ@–Á»@ÔK@ÎÓ@gà]@HÙœ@%‘Ê?þËÔ?«¸Î?'ùy½Yú¿OÍš¿Ê#5ÀÛ&ÀK˜-À€z¨À›üjÀ·˜§ÀÓŸYÀïýIÁnÓÁ žÁ#Ú”Á2˜ùÁAZðÁP$Á_/Án%VÁ}MPÁ†;uÁ•ÁŸéÁ†-­Á}™KÁnèøÁ`D[ÁQµÃÁC(¤Á4®MÁ&I/Áí“Á §”À÷RüÀÛ{uÀ¿£ÿÀ¤ À‰ÍíÀ_dÀ+Fì¿ðê>¿ÈV¾ÏóÅ>Lv?q?Å@2£@&–¤@C’@]s·@rˆU@€ê]@†§@ˆˆ@‰iq@ˆóð@†±^@ˆ@r•í@[Ï@A(ì@"'«@ h?·›?NË÷>{¢¿ Ò3¿£¼¥À9ƒÀ2ûˆÀf'8ÀÀ¨âÀÃM³ÀÞ˜Àú‡íÁ —IÁòöÁ(gLÁ7ûÁEÍ{ÁTƒÁc<Ár,Á€‡%ÁˆøÁ–þêÁ•¾Áˆ=¢Á€õ‰Ás`kÁdØùÁVUcÁGÞÁ9ŸµÁ+uUÁJõÁ6¸ÁJúÀæíyÀˆ£À°¬ÇÀ–tÀy#ñÀFasÀпÏè¿e§¾uÃ%>ÆÔ?z\¢?Àɸ?ÿY@kW@59@GüÖ@V®‹@`Z¾@dÞ¶@fi@e!Ÿ@`­8@V\ô@FÔk@2(©@s?ôÃu?²·Ì?VBý>q=¨¾Ô¤¿Št¿äöÀ!TgÀQv¯À÷’À›‘`Àµ±FÀÏñËÀë=ÈÁbêÁR„Á|ÙÁ-«Á;ñ¦ÁJp?ÁY†Ág¹ÜÁvn9Á‚ŸJÁŠ Á™2GÁ‘å»ÁЧÅÁƒjÆÁx[Áiá‘Á[€tÁMOeÁ?#Á0ö¡Á"ÏJÁî=Á@"Àó>˜ÀØSÀ¾:ûÀ¤cøÀ‹v&Àe—ÇÀ5»‹ÀMl¿¹ïË¿M³I¾LÄ>ºåp?by?­LF?ä9ž@ª5@T3@)hÓ@2¬`@7¬@8J@6ïþ@1³h@'§E@ø@?±?Þúû?¡o€?AŽ%>Qcp¾Äs¿€%¿Ó×ÀɰÀCM¬ÀrÌèÀ‘¤’ÀªÅÕÀÄ5ÀÞDÆÀøé7Á ÙeÁ~.Á%p—Á3™—ÁA½äÁOñWÁ^V§ÁlÍ Á{OÁ„ðqÁŒJýÁ›ÀÁ”~ôÁ=ËÁ…ü¹Á}‚DÁo:LÁaŸÁRöÄÁDÚöÁ6ÌéÁ)ZÁg`Á ÏqÁo…ÀæF’ÀÌmÏÀ³Á2À›3åÀ‚ë<ÀX‘"À+ËpÀP俳àN¿S#¾³>Pã¤?- N?ŠD¹?´À8?Ø$ý?ô0Ü@ÞÃ@H¹@Ø‘@°Ò@U¾?í†?Ѫõ?¬«?f¨?ÿÆ=Í·°¾äã¿‚‰/¿ÎáÿÀyíÀ:š7ÀfüGÀŠ{»À¢R†ÀºdÀÓ²þÀí!8Á—žÁüzÁb‡Á+ÚBÁ9¬_ÁG®ÔÁUËÓÁdœÁrd<Á€lßÁ‡§æÁŽå²Áž`{Á—!ÄÁìÍÁˆÃÁ®OÁuM«Ág?8ÁY1!ÁK>ÕÁ=_ùÁ/Á"†Á¼‚Á˜ÍÀõk“À܈ÀÃþ1À«ÿqÀ”óÀ}u–ÀRzŽÀ)Ç4Àô\¿¾’Ö¿v&k¾õ+½Uóµ>®gf?*&F?m=»?‘\?¡W°?©p=?«Öã?§¿?›?ˆù?Z€Ù?`z>x’š½ðÔœ¿Ù¿á¿Ø‚À‹®À8ò¿Àb^À†yéÀœücÀ³ôüÀËã™ÀäT†Àýj°Á vˆÁt Á%±6Á3+Á@”4ÁNRäÁ\Áj!Áx#ÌÁƒ;†ÁŠy2Á‘¹·Á¡&vÁšªÁ’ñ®Á‹ßÁ„×Á{Ÿ­Ám¤ŠÁ_¸VÁQרÁDXÁ6îÁ)hÁlæÁƒWÁÀ¾Àìþ6ÀÕ˜À½ª­À§‘6À‘×qÀz÷@ÀS^À.%À cL¿×ä=¿Àó¿Lü²¾Û\½ì]É>YÍ>¡Ÿ»>ãŽ2?ïs?wë>òÄ”>Å->s &=.&¾j.x¿˜‹¿jª[¿¬&¿ëÿÙÀÓ–À<–fÀb× À…WÚÀšYAÀ¯ØÀƘÀÀÝ·Àõº×ÁC†Á®hÁ eWÁ-kØÁ:”7ÁGÎ ÁUQ(Ác!ÁpÚöÁ~©ŸÁ†QñÁj,Á”•Á¤;yÁ'%Á–gÁKÁˆÞÁ ¥Át4žÁfq ÁXÒÁKl…Á>AíÁ1CvÁ$\,Á“ÌÁ O”ÀþñàÀçi˜ÀÑ cÀ»^À¦”À’@ À–~À\X~À:œ•ÀC ¿ÿê5¿Ë#οœy)¿ld§¿/œ¿4(¾Æ‰Å¾¥ìÒ¾©$!¾ÀMƾñ¶¿nÁ¿Lݯ¿‡:€¿¯.j¿ÛÝ%À M^À%<ÀFmPÀi‰ÍÀ‡)èÀšÖµÀ®êÓÀÄ5~ÀÙý&Àð¼çÁì¸Áü”Á^êÁ(ÂëÁ5WÁBcÁOïÁ\ßÁj*ËÁwÞ>Á‚×Á‰¿Á·$Á—¼jÁ§\šÁ GöÁ™?Á’JÁ‹YùÁ„uJÁ{VàÁmϵÁ`s…ÁS3~ÁFÁ9GÁ, Á mÁ îÁË|ÀúÑÀå,“ÀÐ#ÿÀ»àKÀ¨ÞùÀ– äÀ…¨=Àk¶ÝÀM^ÝÀ1ð„ÀØþÀ´N¿àã1¿Ã¤‚¿­Æp¿Ÿps¿—‰¹¿˜8ô¿ŸD¿«[¡¿½`¿Õ¯>¿ôRÀ ÏJÀ!@À<$NÀW2jÀvZRÀ‹Í0ÀåYÀ°•:ÀÄ­`ÀÙ˜ÀîT‰Á7Á ~ˆÁCàÁ%5*Á1öÁ=ôFÁJ„yÁW}"Ád¹ùÁqø’ÁN#Á†h¯ÁB?Á”*“Á›" Áª”YÁ£˜¨Áœ¯‚Á•ËsÁŽó¡Áˆ*@Ág¡Áuz…Áh8öÁ[ÁNfÅÁB Á5»TÁ)Ó´Áö ÁeîÁ¤]Àú!À剚ÀÒ•œÀ¿Â¨À®qlÀž7‚ÀŽÉ¹À€‡ŸÀeÔ9ÀM³×À8­AÀ'AVÀ¯ ÀÃÀàÓÀïÈÀMÀ.ªÀà5À›BÀ"•À0Û¯ÀC˜£ÀX ŠÀp À…6À“‚°À£Ó3À´õ]ÀÇ*ÀÚuÀîÆ2ÁÁ caÁtåÁ"¿íÁ.ŸÑÁ:—ÁFÒûÁS_ÖÁ_øÁlÒæÁyõhÁƒš/ÁŠG»ÁúBÁ—½cÁž˜%Á®úÁ§1³Á RûÁ™~ÞÁ’­ºÁ‹ëÁ…IEÁ}m.ÁpjÁcÂ=ÁWKËÁJøQÁ? ]Á3NûÁ'ÈÁå€ÁMŒÁ×Àü[MÀéŒUÀ×­FÀÆÉØÀ·!‰À¨( Àš_ÞÀ‡ÀçÛÀo¬ËÀ^òÀPiwÀF À?¬2À<¬À<¿=À@ëùÀGüFÀP¿½À[™¥ÀiaÞÀzª•À‡o§À’71ÀŸYØÀ¬ÇÖÀ¼‹—ÀÌáOÀÞ¿Àñ&Á€JÁ ¦~ÁíŽÁ!Ü*Á,ñ]Á8MÎÁD/.ÁP#$Á\TñÁhÛ"Áu€@Á$+Á‡Ÿ ÁŽ8êÁ”èÁ›šfÁ¢OßÁ±¹ºÁªÝ‘Á¤ ùÁ>,Á–‡DÁñˆÁ‰m2Á‚õMÁyCéÁl°,Á`QAÁTl¾ÁHÕ/Á=R•Á2Z<Á'¤WÁ+·ÁR÷Á ¬‚Á­EÀð •Àß¼ÀÐròÀÂBïÀ´vwÀ¨‹ÀiÀ“[À‹\ À„ƒNÀ~ÌMÀxóõÀv'PÀu¨ÀzŸÛÀ€ÚõÀ…uÀŠ ÄÀ‘?µÀ™ TÀ¢Ø‰À­KnÀ¹öÀÆÆ‚ÀÕ£6Àå˜yÀögYÁ\FÁ ¸˜ÁÎ$Á"6Á,p)Á7gÞÁB–ÇÁMõ0ÁYÌrÁeÍTÁqç»Á~V‚Á…„¹Á‹è@Á’R¾Á˜àÁŸÁ¦BÁµj—Á®¢5Á§æ0Á¡;÷Áš®¿Á”,òÁ¹(Á‡g€ÁÎÁuäVÁj‹Á^`ÔÁRÝ?ÁGÜþÁ= –Á2€ñÁ( ÁÝßÁ5Á ðÉÁ€°Àù|Àê¯eÀܰ¬ÀϨ‹ÀÃàÀ¹U,À¯§¶À§ÐÉÀ¡d`ÀœVÀ™OSÀ˜CÀ˜ …Àš—aÀž+tÀ¢S³À§©‹À­ÜïÀµ’À¾iÜÀÈÞ ÀÔ©ÀáÐÀîÝÎÀþ¹èÁYpÁ.öÁn„Á"ýÿÁ-?Á7ˆ¡ÁAõ ÁMÒÁXDxÁcæÁolÁ{w˜ÁƒÃ“Á‰ñÁJêÁ–±rÁgÁ£NÁª?ŠÁ¹NÁ²žKÁ«þ Á¥pØÁžì´Á˜}dÁ’.Á‹òÍÁ…ÐYÁ´¹Át ýÁhyIÁ]kÁRœ”ÁGòÓÁ=ùÁ4C‡Á*Ä`Á!àbÁX*ÁT”Á ¿ôÁ…®À÷¦eÀêöÀß·.ÀÕGàÀÌ>ŒÀÄG?À¾]¦À¹ZqÀ¶$ÀµZ#ÀµAþÀ·ÕGÀ»kRÀ¿ª¡ÀÄæ‚Àʹ:ÀÒ^õÀÚ°tÀäãÀï’LÀüÁš3Á (ÁåÁOGÁ%rëÁ.·`Á8‰ZÁBÍ÷ÁMRÁW—Áb¶»ÁmúÁyUwÁ‚‘¾Áˆ™ÁÁŽ¢ãÁ”ÊáÁ›øÁ¡‡¡Á§ñÃÁ®m/Á½YÑÁ¶Â©Á°5{Á©®Á£D¼ÁœÿÛÁ–Ô&Á² Áж#Á„ß·Á~A±Ás!tÁhOÁ]œŽÁSsÁI«€Á@ Á6ôÁ.;8Á&#NÁ:«ÁæÉÁßÐÁ pâÁ-EÀû¼µÀñW§Àèß-ÀáFÀÛ_ÀÖ§XÀÓê÷ÀÒÌwÀÒ íÀÕiäÀØú&ÀݲÀâ=ŽÀçá{ÀïB–À÷P{Áw¦Á¶-Á ž_ÁÁ%CÁ!MÁ)èÁ1¨¬Á:Û€ÁD>©ÁN5^ÁXrÉÁb¿„ÁmirÁx’Áé»Á‡™1ÁBÁ“ˆYÁ™’†ÁŸµ0Á¥ÿÁ¬`ˆÁ²ÊüÁÁ‡ŽÁºýÁ´}.Á®­Á§Ý´Á¡·FÁ›”/Á•“2ÁÀùÁŠ8Á„y^Á~ºÁsOÒÁiÁ_!ÁU~ÁLJ!ÁC8pÁ:óåÁ3óÁ+KàÁ$$ÎÁqBÁpÁ3¬Á íÁeÁÚ½ÀþOÛÀø—>Àô'åÀñhpÀðŒTÀðŠíÀó3UÀö¤ÀÀúÔšÀÿÏâÁ¬DÁ«Á •Á´¬Á²LÁn\Á¨MÁ&ƒÀÁ-æÌÁ5í Á>'‘ÁGzÁPD_ÁYçæÁcç‡Án›ÁxˆsÁ¯Á‡AdÁŒáÝÁ’–nÁ˜zÁž~JÁ¤‰ŒÁª¬³Á°ë-Á·>?ÁÅÒˆÁ¿[CÁ¹(Á²ÈÁ¬žÁ¦yÛÁ zcÁš©UÁ•3ÁkùÁ‰áBÁ„²Á~ÙÁt·gÁjçËÁa«XÁX„£ÁOâWÁGîƒÁ@ TÁ8uŠÁ1¨ÈÁ+åÁ$â’ÁHÈÁ Át”ÁUgÁ ÓžÁ ÿÁ FÁ®cÁDÏÁCÁ‡­Á (9Á WóÁ»¢Á‡˜ÁÍÁ¡ ÁåÁ!Ì\Á'PÁ-?*Á3ú^Á;æÁBÔlÁJëoÁS{øÁ\~GÁeÁ`ÁoŸeÁyžÁãuÁ‡4oÁŒ¯©Á’:wÁ—Û Á™©Á£}Á©uÁ¯ŽÁµ¨êÁ»àJÁÊEßÁÃò¿Á½½gÁ·AÁ±l2Á«o4Á¥ºÁŸù˜ÁšaÁ”ËÁa{ÁŠ7¶Á…5¸Á€A Áw"¨Ámý/ÁeÁ\áÁTøÁMoÁEû)Á?;“Á8Ý@Á2ÖDÁ-_/Á(r9Á#àÒÁÿwÁÜÁè¿ÁÁ¸ãÁWÁA6Áx|Á tÁG>ÁÁ e®Á#йÁ'\6Á+x£Á0/€Á5UÁ;!¶ÁAx<ÁH„ÆÁOâÁWàKÁ` ÁÁhè¾ÁqîóÁ{d¥Á‚­iÁ‡¬¹ÁŒÌ•Á’-ÁÁ—°BÁ6EÁ¢ÖÑÁ¨žJÁ®ƒÝÁ´qaÁºz}ÁÀ¥]ÁÎí®ÁȹâÁ‰KÁ¼i¤Á¶o0Á°·ÁªõvÁ¥[TÁŸÂÝÁšQÁ•kÁ–Á‹# Á†TÅÁ»ŸÁzƒQÁqëWÁië`ÁbKÁZ†ÁS®àÁLýÁFµáÁ@õzÁ; nÁ6ÝÒÁ2jïÁ.²LÁ+LÁ(îDÁ'?Á%͇Á%m@Á%[ãÁ&†–Á(@›Á*PÆÁ,‡ØÁ/GÍÁ2NÁ6©Á:•Á>¨ŸÁCœ—ÁID_ÁO<…ÁV ƒÁ]IlÁeKÁlÿ@ÁuoðÁ~oÔÁƒÅ\Áˆ˜cÁ—Á’—mÁ—ÄÑÁ.¥Á¢°ôÁ¨4“Á­Õ©Á³¤Á¹‹Á¿tAÁÅyóÁÓ·ÅÁÍŠ°ÁÇp[ÁÁxqÁ»§4Áµõ'Á°XmÁªÅXÁ¥MÇÁ  TÁ›ÉÁ–ÚÁ‘)™ÁŒx§Á‡ø´Áƒ–hÁ~àÍÁweÁo[žÁh%îÁaMpÁZÝíÁT¹KÁO:pÁJAÁEIªÁA±Á=fPÁ:FLÁ7êgÁ6 ·Á4îlÁ4ƒnÁ4šºÁ5ª:Á7d#Á9^#Á;‘¿Á>BõÁA)EÁD×ÁH¥ÁM(.ÁR SÁW‰ÅÁ]MÂÁcÐDÁjìàÁr?¦Áz+Á&ÜÁ…‚…ÁŠþÁާyÁ“Œ(Á˜Š­ÁiÁ¢ÉÁ¨87Á­·QÁ³9,Á¸ÜþÁ¾¬ÁÄ”ØÁÊrÁãw‹ÁÝ\JÁ×^fÁÑ€fÁ˸PÁÅúûÁÀ`ÁºñÍÁµ®¿Á°zuÁ«e Á¦ˆ*Á¡ÅÀÁgÁ˜­5Á”‹àÁ„èÁŒ›ÒÁ‰7Á…†EÁ‚VÁ~âÑÁy[±ÁtX ÁoÞ0ÁkÔÈÁhbõÁetmÁbë¯ÁaÁ_TªÁ^0^Á]2NÁ]Á]X‡Á^LÁ_Ì(ÁaqfÁcð=Áf™Áið¡Ám†âÁq›ÁuÚËÁz°NÁùMÁ‚Þ¸Á†•Á‰D4ÁŒà:Á¥ýÁ”†Á˜¯×Á¶Á¡Ž=Á¦0Á«žÁ°$UÁµ@ÁºƒÁ¿ôàÁʼnXÁË:ÁÐý ÁÖÛâÁÞ®YÁØ~ZÁÒd/ÁÌiÁÆ‚ÁÀÄÁ»ÖÁµl‚Á°ÒÁªÌ1Á¥¢æÁ –Á›ÀìÁ–ùÕÁ’^MÁŽíÁŠÁ…üÄÁ‚?IÁ}tõÁv¿¢Áp¸ÁkDÁeï¶Áa.ËÁ]&8ÁYÁVŽyÁSð6ÁQîäÁP@¾ÁO¶ÁN#œÁN]ÁN3?ÁO3ÆÁP¤†ÁRS¶ÁTã^ÁW¦èÁ[+sÁ^Ò"ÁcoÁg‡ºÁl“çÁqߪÁwèzÁ~,Á‚ˆÁ†GäÁŠ)ÁŽ)LÁ’„¢Á–òbÁ›|RÁ KÁ¥RqÁªfÁ¯ž]Áµ ·Áº¤ôÁÀZÁÆøÁËó´ÁÑÛ¸ÁÙô ÁÓ¹ÁÍ…ZÁÇl5ÁÁtÁ»ž±ÁµÔ»Á°ùÁª…Á¥%8ÁŸõ¦ÁšÍÁÁ•ȤÁù¯ÁŒ;žÁ‡»rÁƒ‰yÁ~éžÁwÁoé Áhø'Áb¾+Á\Ç,ÁW‡vÁRªŒÁN~aÁJãÍÁG¨·ÁEŠÁBß÷ÁAONÁ@$£Á?2Á?YÁ?1›Á@:VÁA™ÁCZÁEí—ÁHÊøÁLf€ÁP5ÁTÐÁYS“Á^}@ÁdBÁj*ˆÁp˜;ÁwÙÁ`¥Áƒ¨‘Á‡óŽÁŒ`ÔÁݹÁ•˜æÁš’ ÁŸ›ÏÁ¤È>Áª,¹Á¯ÄÁµz&Á»4*ÁÁ ‡ÁÆûµÁͨÁÕVÁÏ žÁÈÍYÁ“-Á¼vÌÁ¶ÔÁ°®zÁªíOÁ¥9¡ÁŸ¬2ÁšU}Á•!6Áù2ÁŠüýÁ†:~Á•+ÁzWÑÁr ÁiâÁbg[Á[VÓÁTÌRÁNÉÐÁI3òÁDZÁ?è’ÁÁ[ Á¨öÁ§OÁ4•Ád,Áé£ÁFVÁ ÝíÁ%.`Á)ç¯Á/H½Á4ú.Á;]ÅÁB)jÁIÌÁQ2øÁYÄÁb5iÁkjüÁu;eÁF[Á„¸ìÁ‰ÿ.Á|÷Á•«Áš°Á  Á¦úÁ¬¨DÁ²à%Á¹­Á¿]1ÁÈ@ÁÁ®Á»9?Á´ÒÁ®n|Á¨åÁ¡ð‰Á›ÜµÁ•çÌÁéÁŠoiÁ„ÄIÁ~(ÁsúçÁi§šÁ_Ž·ÁV%ÁL öÁCSÁ;}#Á3¯8Á,ZÁ%–ƒÁ“0Á!Á?,ÁäÁ KYÁ QjÁûGÁ ÏÁÊeÁϯÁnNÁÒ¡ÁÛ€ÁˆŸÁØCÁ ‹|ÁüÁÙ+Á3ÁnÁ!hÂÁ'…MÁ.(Á5@>Á<´ÁDêäÁMSÁV?nÁ_õ?ÁjˆÁt<´Á~Æ'Á„ÒXÁŠaéÁýFÁ•ʶÁ›ÊÁ¡õ7Á¨/îÁ®j¦Á´´îÁ»¨ÁÄ/ Á½†‡Á¶òÁ°t·ÁªþÁ£›®ÁE;Á—0Á‘Á‹)Á…]AÁWÁsûÁi•Á^˜ÌÁTJøÁJk®Á@ìýÁ7~ìÁ.×Á&á+ÁA´Ák½Áñ…Á ?Á'hÁéDÀþýÀøTóÀòâdÀï?KÀ컿ÀêªHÀéMÆÀê%<Àì_ÀïÕ/Àô˜³Àú|NÁ´ÏÁÞ&Á @ÁtŽÁä®ÁDtÁ!Á(a"Á0JÝÁ8ÀÁAeÃÁJ׺ÁTÜ´Á_–Ái“uÁtRÂÁnÀÁ…^~Á‹,ÃÁ‘*áÁ—QIÁ…KÁ£ÁšÁªÁ°çÁ·ùÁÀ;ÂÁ¹wÁ²ÍÁ¬:ËÁ¥ºÉÁŸC[Á˜ÖµÁ’|`ÁŒIÁ†GjÁ€n[Áu:ÖÁiÚgÁ^¡£ÁSÈOÁIN‡Á>ÿ>Á5ZÛÁ+ëÁ"¿DÁgÁYkÁ MèÁ¿kÀýïÀòíSÀêiÀâ4#ÀÜçÀÖ;QÀÒ£?ÀÏå“ÀÍÏ¢ÀÌzÀÍ_‹ÀÏqrÀÒÍôÀׂ*ÀÝá¥ÀåDmÀíÆAÀ÷aÁù±ÁÚòÁ ÞÁSøÁñþÁ$PfÁ,åÑÁ6 5Á?µrÁIÒÁT`ÃÁ_ Áj =Áu6Á€ž¸Á†”TÁŒ·ÂÁ’â¿Á™ÁŸ€ÄÁ¦5Á¬¦nÁ³]<Á¼†˜ÁµŸ,Á®Ï}Á¨ Á¡ƒíÁ›÷Á”…ÁŽEÁ‡ÁÁ‘ÊÁw}Ákq$Á_ÎfÁT‡DÁI[ÎÁ>¦bÁ4(’Á)ûêÁ kÉÁ½ÁbøÁNÀüÉíÀïIîÀâ¹ÔÀØkÀΚÚÀÆ‚ßÀ¿ÔÀº<'À¶LÀ³1À±]§À°ÒÀ±…•À³NAÀ¶uNÀºúÀÀÁf¤ÀÉRbÀÒ9íÀÜeZÀç™mÀóÓñÁTÁ!•Áó2ÁrÁ!‹vÁ*ÚéÁ4¬ÁÁ?4¢ÁIÔÂÁTß Á`q±Ál$ ÁwýcÁ‚„ÁˆLÒÁŽ–Á”ù5Á›‡–Á¢5ÜÁ¨îÂÁ¯§§Á¸øÛÁ²~Á« Á¤=þÁ}ôÁ–Ý6ÁVkÁ‰Ò|ÁƒX^ÁzÁmÌÁaÜ6ÁVÁJyÁ?Àš8&À—æÀ•aËÀ”ÓHÀ•Ò˜À—ºsÀ›%ýÀŸ³öÀ¥ÖòÀ­±TÀ·»ÀÁ£ÀÍøÀÚjkÀè¾”Àø$%ÁŠÁ ÚÁZÎÁæqÁ*LÏÁ4ðDÁ?Ú’ÁK`ÁW ¯ÁbÔzÁo äÁ{¢Á„ ïÁŠÀÁ‘ŠÁ—ÆQÁž Á¥BxÁ¬¦ÁµvÁ®}èÁ§£Á £_Á™ÂÁ’ú±ÁŒPÊÁ…ÁlÁ~qÁql±Ád¿*ÁX‚gÁL ôÁ@Å­Á5%€Á)ôÙÁÆÁ…óÁ ;mÁFEÀí¾´À܈ˆÀËüsÀ½6ÀñPöÁñ¾Á tâÁ³SÁ Q{Á+,ZÁ6˜‡ÁBWÁMÏŒÁZ åÁf¶tÁs‘IÁ€8Á†¹÷Á\ÎÁ”!~Ášø‰Á¡ÚyÁ¨ÃðÁ²4øÁ«áÁ¤êÁbÁ–-¡ÁH¤Áˆ~»ÁÔ ÁvkéÁiSÈÁ\\[ÁO³†ÁC\çÁ7h Á+‰›ÁærÁñwÁ <ÂÀÿQ’Àë cÀ×¹EÀÅàrÀ´šÉÀ¥+À–¥õÀ‰êzÀ~~Àk}›À\ÆÏÀPÒÍÀG{·À@ÖÀ=K¦À<0ºÀ=oÀBòÂÀJª†ÀTâZÀbµþÀsnÀƒ7¼ÀŽYÀ›%À© RÀ¹ ÒÀɈ\ÀÛ+jÀî ëÁDºÁ µÁŠ=Á!ómÁ-oÁ9)ÝÁEbJÁRîÁ^ô”ÁkбÁxÓ4Áƒ Á‰ä ÁÇNÁ—«3ÁžžáÁ¥ª‹Á¯0xÁ¨½Á ÞŽÁ™ÉHÁ’ÇGÁ‹ÈdÁ„Ö°Á| |Án¯EÁap¥ÁT:ËÁGX²Á:ÉŒÁ.N}Á"0ÁoåÁ DÁ,~ÀêûlÀÖøÀÂÄfÀ¯ÌéÀž”BÀ¨ÉÀ}9ÇÀcPÞÀL˜À93!À(¨]ÀJíÀ¾À ½kÀƒ>ÀØÀ XÄÀFèÀIŽÀ >ùÀ.†À?ÜñÀTåÀlÀƒÀ‘Ù_À¡íÇÀ³läÀÅ}¯ÀÙ·RÀîYÁè Á R¼ÁÌ]Á$ºÁ1‘Á=¯ÀÁJŠ¡ÁWn¤ÁdŒÔÁqó¾Á~Á†˜ÁµÁ”€TÁ›”‘Á¢±åÁ¬5Á¤ÿÁÁÕ$Á–±AÁüÁˆzâÁz†Áu ¡ÁgSÙÁYã ÁL¤Á?gÁ2wgÁ%ç½Á_‚Á "UÁªÁÀìÿÂÀÖÓûÀÁ~UÀ­·=Àš™¿ÀˆjÀnƒ8ÀN}^À3ó ÀÖÂÀZF¿íf-¿ÒwY¿¾Úš¿¯³)¿©Fò¿©%’¿®-¿·Rð¿ÅÚu¿Û$S¿÷ À µ¢À#§À<'ÄÀXr¡Àu¶}ÀŒ wÀž'9À±©ÊÀÆðÀÚÿêÀñÙÁv³ÁlöÁÈaÁ)I•Á6#!ÁC2ÜÁPc Á]ÙÕÁkX$ÁxócÁƒiuÁŠvšÁ‘˜€Á˜½\ÁŸäÚÁ©híÁ¢ÞÁšÖÁ“¨ÚÁŒ„¹Á…`¬Á|{?Án^0Á`=ÁRØ„ÁEeRÁ8ãÁ*ÇÁζÁ=¶ÁÀÎÀñãÀÚO»ÀÃêÀ­‰[À˜¡JÀ…Œ•Àdç8ÀB-ÑÀ!ÀÓÀdæ¿Ø-¿®ëË¿ŠÃô¿_}C¿5ÙÜ¿©%¿¡ƒ¿‘P¿S/¿%Žc¿F ¿r,@¿–VÛ¿¼Ê¿æoëÀ ÕoÀ+Z‰ÀJ¿ ÀmòNÀŠ"…Àž »À³jÀɺ‰ÀàœÀødVÁ‡>ÁïQÁ!ÞƒÁ.ýÑÁkµÁ0ù™Á#‹¢Á(áÁ &3ÀùMÑÀà…wÀÈÁÀ±^À›À…4Àb[ÀÀ;»üÀ¿îx¿³*¿z|¿$4¦¾·I¾ƒø=AqU>1K>i¦ô>erª>:‰7=òU»‰ôC¾@Š{¾ål¿A½Ð¿Žf¿ÂH¬¿ÿ9ƒÀ!'ÔÀF\Àm×ÚÀŒ¥À¢GZÀ¸“üÀÐ ÀèÞsÁÿBÁ ø[Á¦Á(bMÁ5ôaÁC”LÁQdFÁ_htÁmnÁ{qÁ„ñ†ÁŒ1Á“z–ÁšÅnÁ¤gqÁÕÁ•ŸñÁŽ>Á†æQÁCëÁpäJÁbŒŠÁT>ÁF~Á8 ™Á*=ÌÁ®›Á: ÁÐ¥À鉒ÀÐ~-À·HÀŸ ¦Àˆ±°Àe‡ÒÀ:ÊÏÀ3 ¿ÛÕ?¿›i6¿9Øn¾ ÆÈ=Kˆê>³œø?cT?H°w?h‡?xGw?zåÿ?mø–?\¦è?<99? ©S>Œíú½„Þñ¾ß޽¿_³¿¬²¿ôú1À!oÀHÁ›ÀuÔ4À‘Å’À¨¥VÀÀÔÀÚ‰ Àôw˜ÁJòÁª0Á"0òÁ/ÌÃÁ=¿yÁKÓ›ÁYè»Áh$\Áv‚vÁ‚vÁ‰¹ÀÁ‘`Á˜wÌÁ¢`Áš˜ãÁ“* Á‹ÃÁ„^eÁyü1Ák^ÍÁ\ð”ÁN˜þÁ@HeÁ2=Á$ Á8gÁqÀõåÕÀÛzMÀÁX«À¨BíÀTÆÀn‡KÀAµÇÀ6ÿ¿ÙB)¿Œ”¿Âk½ŸRÀ>´R/?9K?„Óc?¥3?½$²?Ï:—?×zv?Ø“?Ô ÿ?ÊÉ^?ºó8?ž„[?qUÑ?Jê>NSo¾‡¿Ccп¬)¿ûx¹À'ôÀU+ÀÀò4À™·°À³L£ÀÍÀç ÇÁõÁŸÓÁS¦Á*HËÁ8S´ÁFtçÁT˪Ác2ÜÁq±µÁ€'Á‡‡WÁŽò7Á–]rÁŸì6Á˜k3Áê1Á‰mÄÁ‚NÁu0`ÁfdµÁW®èÁI! Á:Ê>Á,†:ÁBÛÁ÷ÁDIÀèêÁÀÍÉ—À³p6À™/éÀ€¿ÀNx:Àüå¿å½Y¿•=¿Uo=(I)? K¼?z×i?­’y?Øö>?ùâ^@ š°@BA@ÎÈ@[G@fí@­ˆ@Óþ?òëê?ËW¯?›R?OÅ{>¢‹¬¾j)¿PÌ¿»-…À½ûÀ7pºÀfc‹ÀŒn±À¦>LÀÀ94ÀÛ%0ÀöfWÁåÂÁÛ?Á$îsÁ3.yÁAŸšÁP5þÁ^Ð5Ámh,Á|"”Á…}ñÁŒöaÁ”qÁÑRÁ–D+ÁŽÁ…Á‡@LÁ~$Áp…dÁa®†ÁRòÁDP„Á5·ÚÁ'-uÁÙ³Á ŽÀøœDÀÜÙ+ÀÁÀwÀ¦¯âÀŒÏÀdmïÀ1Øw¿ÿÔ¿¤/¦¿(=>³ð?#0?‘lb?Ëœ%?ý?Þ@|N@%9@2Ð:@<¡#@Aô@Aõ˜@@.‰@<[Ð@0­þ@äÝ@ 1×?äwf?«\?Z~}>.˜¾©çz¿xGÆ¿Ø ÏÀ,?ÀL¤¼À"À™Ì-À´ ZÀÏÉÀë0iÁ©2Áí¤Á 4Á.…²Á= ÖÁKÇrÁZ“Áig3ÁxWQÁƒ¥Á‹÷Á’Ÿ¡Á›ìrÁ”L_ÁŒ°0Á…HÁ{8CÁlC3Á]UÁNo/Á?¢AÁ1´Á"g¿ÁÍÊÁK[Àî;ÒÀÒ ¨À¶SÀšëÉÀ–!ÀJ†Àô¿É†¿QÎY½Ì1Ä?Â'?•6À?Ù @ 1@#é@9~@KЧ@YÑs@cÉ<@hº-@i€¼@g—¼@býë@U–ä@BÜñ@,±H@5ž?éî°?¨ H?<¸³=Ò+œ¿ q ¿£ öÀý[À3ø\ÀgëöÀŽbvÀ©~MÀÅ‹æÀá›êÀþ ‡Á ZáÁÒÁ*YÍÁ9_ÁGäEÁVÓ!ÁeËÜÁt× ÁóÁ‰{šÁ‘ÃÁš0Á’}©ÁŠäÁƒM ÁwreÁhSQÁYOÛÁJqÁ;©Á,ÊSÁ÷´ÁF5Á³Àä°£ÀÈ6ÓÀ«×_À¦eÀi:fÀ3¤¦¿ýn)¿”ø,¾ÉAW>®'Œ?ƒt½?ÓOg@ z×@,±i@G&M@\»@o=@}à€@„)½@†–@†ã¥@…ð@‚­®@u‹ø@bÈ@@K.Ò@0@Ì)?Þú'?–æ?2¾"Úõ¿fê ¿ÓÅ?Àò¹ÀRà*À„VñÀ LœÀ¼;šÀج\ÀõÕÁ G¨ÁÉÙÁ&{ Á5T¦ÁDI³ÁSM8ÁbQÁqd±Á€GÁ‡Ý›Át6Á˜‰ÖÁá$Á‰:sÁ›&ÁtHÁdúeÁUäLÁFÐ+Á7Ú~Á(ôêÁ Á @ÿÀøédÀÛ¿À¿¸À¢\À†6ŒÀU‹Àéú¿Ò Ÿ¿UÅP½™›?7ó–?¸‰¢@ø@*.Œ@JRu@ea@|Ë@‡ë‡@HA@”¨@—)@—·“@–ŠÏ@’:É@ŠX2@~ݬ@fTÀ@K.@+wÂ@¢º?Åoä?e¨>[ú¿ ©Ù¿ªïÀ {}À>t˜Àv;•À—”À³ÕÀЕ©ÀíäÝÁ›gÁDaÁ"óAÁ1ÅBÁ@ÄxÁOâ:Á_ÏÁn= Á}kpÁ†LàÁæMÁ—vÁ`§Á‡»ÙÁ€HÁpà9Áa§PÁRŠ¥ÁCw Á4bÙÁ%U4Ák€Á†ÖÀñcÀÔ,À·mQÀšÌŠÀ|LåÀD-ÚÀ ê-¿¬D¹¿¸ >ŒV ?†<õ?ä_$@hÌ@B°ë@d¶À@€7í@ŒV«@–0‘@L@£%Û@¦. @§à@¥t@Ÿ¸J@–Þ­@Œ…f@’@cÜ‚@CŽ @ R|?ò_ƒ?žä? õ¾eWð¿„ø¬¿îÊÀ. Àe^pÀŽ¿ýÀ«½LÀÉÀæQuÁæWÁ¦¡Á”Á.šIÁ= £ÁL´2Á[ÚIÁkåÁzG6Á„Ë¢ÁŒtgÁ•8ÁÔ$Á†/ØÁ}‹ÁmßôÁ^¦ˆÁOnZÁ@HSÁ18nÁ"&½ÁÁ,ÀêË:ÀÍžKÀ°q[À“…DÀm³gÀ5H®¿ûý¿Ž_ß¾×?;ì?¦ S@M1@.é@WÜ@y@‹V}@˜W@¢mE@ª6«@¯ÏF@³Da@´@±þE@«î@£;{@˜^n@‹°@z™o@Z/i@6EÔ@¿?Çv‘?Rr=Z>£¿Am¿Íõ1À› ÀV•±y¿­#¿¯ÄÀÆýÀGïgÀPÀžF†À»i™ÀØÄëÀö­/Á aÁoÁ(|ìÁ7NÁFÞ‡ÁV(EÁeuÙÁtÆÿÁ‚ ˜Á‰½ Á’éÏÁ‹=Áƒ‹ÁwÈÁho)ÁYxÁIÇ+Á:ŒñÁ+mgÁi~Á fœÀüÇÈÀÞï(ÀÁŸ°À¤‘›À‡¹”ÀUææÀ^пÊN¿:6r=å°Z?jÄ\?Úd–@Üø@IÌ@såä@Œªþ@œf£@ªFZ@¶@¿Ç@ĈÎ@ÇD @ÇT @Äð°@¿¼!@·.A@¬íh@Ÿà^@‘¸@@€Ã·@[gL@1¼@ 1?¦ß?wž¾ é¸¿•yÀâwÀ;OrÀu±ãÀ˜ *ÀµuSÀÓZÀñC—Á™7Áš(Á%ÅáÁ5wÁDG\ÁS“¤ÁbäˆÁr:¥Á€ÑÅÁˆ‰­Á‘Á.ÁŠÑÁ‚VÆÁuPoÁeóSÁV–6ÁG:”Á7í«Á(ÁYÁ¿ÊÁ âœÀø‰ÀÚ/À¼væÀŸ“ÔÀ‚Ø<ÀLòÀi½¿µ˜æ¿ïq>ŠÌ ?‹!{?ïF„@(_c@Tìl@Å›@“¿@£j@±*ô@½†@ÆÚ˜@̽n@Ï0@Îߟ@ÌvU@Ç}%@¿öÜ@´ÓÃ@¨I?@™jÄ@ˆÙ@hÏH@>Q"@¬?¿×e?2r¹½ñƒÈ¿} ÿî‹ÕÀ/®*Àjv#À’øtÀ°°ðÀÎilÀì!ëÁ±ÁAQÁ#|QÁ2·RÁA÷cÁQ? Á`œ}Áp"ÁsOÁ‡r Á½gÁ‰ÀÁJCÁs"Ác»äÁThØÁE"ˆÁ5ëwÁ&ÇÉÁ®DÁœ%Àóa¡ÀÕ”ìÀ·æŠÀš¨\À{TÀAܱÀ–[¿ Üó¾Ò'~>ÚN?¡ =@'^@2•‡@`1@…`Ž@˜µF@©H@·Y¶@í @ÍG‘@Ó:Š@Õï¾@Õfù@Ó Þ@Î5@Çy¢@¼(@®ï¢@Ÿ†¤@««@sÏn@H})@Çä?Òº™?[<=î ¿VTÕ¿Û0^À&§úÀa_uÀŽ xÀ«pÀɈÀçÆÁÂÓÁ^Á!IêÁ0uÁ?Ò ÁO**Á^“ðÁmþÆÁ}iÁ†j>ÁÞšÁˆ$)Á€jÁqfkÁbOÁR¬ ÁCZúÁ4qÁ%ÁçUÁÎ ÀïtOÀуÀ´'XÀ–õœÀs‡½À91ÀÓM¿‘±Œ¾Œ«¼?~d?±­@ û@<%@iì@ŠUô@±f@®bo@¼†Œ@ÈÉm@Ò @ؼ@Û9?@ÚÚs@ØÆ@Ô\@Í9ñ@Ásî@³c@¤@‘÷@{¨«@PwH@"ö ?ã ?|èu>(Ùj¿1öÐ¿Èæ&ÀP—ÀYÌÀ‰òsÀ§eGÀÅ ãÀãERÁÐóÁÿ=Á.ÛÁ.irÁ=¾rÁM+þÁ\ 4ÁlœÁ{‰Á…~¶Á#¸Á‡_[ÁD‚ÁoÛÜÁ`‡ÁQ8¡ÁAëÊÁ2¡Á#_ÿÁE<ÁT ÀìÑxÀÎù°À±!çÀ“¦üÀlížÀ3[{¿ôyù¿ƒuô¾!Y?,éo?¿«•@uý@CB»@qp©@Ž"¯@¡}.@²]ì@Àº0@ÌÁˆ@ÖVä@Ü­Q@ßÂ@ßk|@Ý6@ÙH @Ñ´æ@Å¿î@··ø@§©Û@•îÝ@P{@W‹ˆ@* °?ò–Ð?âˆ>t*¿ëÅ¿¸îÀ'2ÀQ‡À…þÑÀ£|½ÀÁKtÀß¡ÀþsÁ@êÁy“Á,ÈóÁ<,°ÁKçÁZõÁjYÁyÁëÁ„—ŸÁŽ âÁ†åEÁ~^ÁnüòÁ_ KÁPQJÁAUÁ1ÂdÁ"µÁb7ÁdcÀêÏÊÀÌêÀ¯F˜À‘»gÀiZ{À/•ô¿ëài¿x4&½Ëüý??Ìb?ɸO@¡å@HT@uñ(@·!@¤f;@µS3@ÃÈ¢@Ð'@ÙN_@à…@ãc†@ã7¦@áSt@Ý @Õ »@Ê:ß@»^ˆ@« ¤@™{@„w¾@]ç@0 ®@1v?›Ð>Ã¯Ž¾éUm¿¬À`À­˜ÀJÀ‚ DÀ rÀ¾pÀÜ¢ÀúטÁ œŸÁßåÁ+@QÁ:£DÁJæÁYfˆÁhÈ*Áx*WÁƒÌ£ÁŽ5GÁ†ÈÁ}¤ÁnE>Á^æÁO”iÁ@FíÁ1ÑÁ!Æ$Á¢ Á°`Àé¬ÀËøŒÀ®DùÀ› Àfð¼À-&†¿ç– ¿ow]½œ¸?FÞ®?Íä@û(@Iüó@xA@’&@¥öÍ@·Cï@Æ^»@ÒŸE@Û¬@âz¡@æ@æ4œ@ä+@à"„@Ø ô@Í÷@¾œ@­¸™@›±N@‡Ã@c§S@5Ài@²D?¦`B>õ(¾ÄBw¿ §ÜÀ ªÀÀDÂ9ÀÜBÀ†7À»¤ÀÙæ Àø)$Á GëÁŠèÁ)ÝâÁ95úÁHŽÁWçdÁgPNÁvÇ©Áƒ$JÁû±Á†F*Á}'£ÁmÇ÷Á^t¯ÁO0ŒÁ?ù\Á0ÚÁÁ!¿žÁ¢ÓÁ‘»Àé]žÀË¿×À®5AÀ¾ËÀgVÀ-`¿è½¿où½ h?E<²?ÊØ·@¿ @IA<@x€@’…š@¦‚"@¸sØ@ÇÐ@Óõâ@Ý'@ä@çï+@èQ@æŸ{@âUŸ@Ú‡@ÏOb@Àe¹@°Ix@žF%@Ša@i @;Ó@ #¤?®ºv? Ó´¾ž)ƒ¿˜ÁñÀZÂÀ?¸vÀ{H¬À›v¿À¹I¿À×héÀõµ€Á $Á^‡Á( êÁ7ó,ÁG_þÁVÓ½ÁfG~Áu»?Á‚—€ÁÙÄÁ†%ÕÁ|ð‰Ámª Á^mEÁO1ÈÁ?÷ŸÁ0Ó‘Á!ÄfÁÌ5ÁÙAÀéæÀÌ51À®%À‘fSÀh´éÀ.+¿ë~ ¿v p½ËRI?=™›?Èi@·)@H.7@wÁ@‘Ï@¦g/@¸œG@È´@Ô>s@ݾ[@äÒò@賿@é¢@èN@äc¨@ÜXÇ@Ñ2å@Â[4@²BA@ —@Œmy@mª@?à@ ëÄ?·;3?л¾‡ŠT¿‘Ñ›À‘MÀ<Ñ£Àw<÷À™fŸÀ·cªÀÕ}ÀóÌÔÁ 0ÁvÁ'ÐÁ7 ûÁFuŠÁUÚÏÁeLQÁtÀ¨Á‚>ÁûGÁ†NOÁ}C‡Ámú?Á^¹ŠÁO…ÍÁ@eaÁ1J•Á"JyÁQÁXeÀêîvÀÍŒ¼À°9À’æ²Àk9âÀ1)‚¿ñ9,¿€Ú¾õj?4ؽ?à ]@BÌ@E¿k@tÎ/@¤Ï@¤í?@·=`@ÇR@ÓÜc@ÝyÚ@äJ„@èô•@éýÈ@é+k@å_Þ@ÝÉ@Ò¥?@Ãò2@³|û@¡9@R)@o‘@@IJ@Ñ\?ºë? 7œ¾fˆË¿ŽNŒÀwÀ:nÀu¢‹À˜mäÀ¶x±ÀÔ¯tÀòæ6ÁŒ÷ÁÈñÁ'¸Á6|üÁEá{ÁUFüÁd¸"Át3šÁ×ãÁŽjÁ†yTÁ}µ²ÁnƒÁ_TVÁP6ƒÁAýÁ2äÁ#ïÁ5ÎÁWùÀíÀÏ£WÀ²8À”ÞÙÀoŸFÀ5îοúBð¿‰Ó¾UE?#ªÆ?ºfß@Eß@A¾ß@p3b@Ž1ì@¢Ä"@µO@Å4@Ñè’@Û¿<@âÂ6@æíŠ@è¾Ö@èU3@äSõ@Ü€Q@Òô/@ÄE@³á@ Š @+”@n²@@G¬@d)?¸z?(¾k|M¿¤õÀ‡"À:@)Àu ýÀ˜›Àµñ ÀÔ&Àò“qÁ‚µÁ»±Á&ÿæÁ6^ñÁEÃ9ÁU#ÁdƒÁsíÞÁ³ÁŽqÁ†ØÁ~}«ÁoKKÁ`‘ÁPþHÁBÁ3*Á$7åÁTSÁ‰’Àï¥;ÀÒFíÀ´ï‚À—ßdÀu ¥À<mÀšS¿–‹a¾ B7?mé?­‡d@ Ûu@:>@ivx@ŠäY@žïÙ@±‚Z@Á«à@ÎKA@Ø&G@Þƒ:@âyÝ@ä+,@äñ@á–Ñ@Û‰g@Ñ÷Í@ÂÌ…@°Ã°@ž`±@ŠÞ@jA!@;ü·@ o’?±§š?®@¾Œ†¿’ ^ÀÀ<'ÀvðnÀ™,À¶ýOÀÔînÀó’Á¼•Á÷FÁ'9Á6ƒñÁEà®ÁU=ÉÁd›VÁtÁºÔÁŽÞœÁ‡GPÁr/ÁpaÁaPvÁRI"ÁC[3Á4rÁ%›rÁÏCÁAÀò¾}ÀÕTÏÀ¸^oÀ›‡´À}b ÀC×À G¿¦‚&¾åKØ>˳?œ0Ý@]§@0Ùû@_Ú»@…·ª@™Þ1@«»Ã@»â5@Èåå@ÒC7@Ø @Ûr6@Üöc@ÝJá@Û¼'@Ö…§@Ì¡A@¾ f@¬jó@™Ðü@†7æ@bs@4PS@†8?¤q[>ïp·¾½f¢¿žÀÀ/ÀAÀ{q^À›ßÀ¸ì ÀÖÐ#ÀôÍÊÁ pšÁˆÅÁ'³ Á6ñŽÁFM÷ÁU½ÑÁe/CÁt µÁ‚ Á‘–ÁˆoÁ€v%ÁqÕµÁbÈ™ÁSÖóÁDþ™Á6'¢Á'QwÁŸ¥Á îÀöÌoÀÙ“À¼¤eÀŸæµÀƒ2ÀM·²À ¥¿ºøÇ¿¬>h¾i?„¦ ?é"@@%@R›/@}y@@’qî@¤,¬@³†Ž@À¥@ɹ÷@Îâf@ÒWg@ÓŒÉ@ÓÆ@@ÒΘ@Ìî¾@É*@µ,Z@¤³)@’Ò@~}¥@U=$@(†C?ò´?Å>¥]]¿´Í¿¯BNÀá­ÀHª À:oÀž4mÀ»›3ÀÙ’kÀ÷©5Á à‡ÁìtÁ)"Á89êÁGtlÁV½°ÁfáÁu‚<Á‚wŸÁlËÁˆÛÁSôÁs«4Ád¯{ÁU¹ÕÁFá¦Á8(·Á)w ÁËÒÁ 1°ÀûnÏÀÞƒñÀÁ™nÀ¤íÇÀˆlÒÀX¿À ‡ò¿Ó-œ¿NÒó< )?Pùô?Ëjy@*)@AÉ@kšÄ@ˆÑ&@™Ã“@¨Çð@µ@ï@¾f@Ã7 @Æ•¦@È6{@È7Þ@Ç$@Ádó@·ßÇ@« N@›€F@Š!b@mD @Dqg@†x?ÓØ?d†i=Öù8¿6 h¿Æ‘lÀfoÀSÀ†‡À£&¦ÀÀ:wÀÝ•0Àûs Á ¬2Á¡kÁ*´ Á9è{ÁI"gÁX\SÁg–ŒÁvÝÅÁƒ`Á‘jÊÁ‰äÉÁ‚gÁuÕãÁfàÞÁX“ÁID2Á:9Á+ÞÁJéÁŤÁE4Àã¨ÀÇ4GÀªÂ^ÀŽd$ÀdÓÈÀ-‘N¿îÈx¿„4ë¾f¶6?M4?¨6@d@,§‡@U˜¡@zÐ@Bq@› ‰@§IÎ@°.t@µu$@¸}Ñ@ºð@º‰›@¹8­@³Å @ªÿ@ž(f@†@€*@XÂ@/@@ÑÕ?­öS?¦e¾°z¿xoc¿æ1üÀ)¢À`©×ÀŒ©À¨âáÀÅë¿Àã Á(Á`Á Á- aÁ< IÁKXÁZGFÁiŽøÁxã1Á„€Á’¢’Á‹ÁƒŸÁx[fÁiÁZ£»ÁKÝìÁ=AÑÁ.«pÁ Á¬{ÁYÀêÀÍ‘œÀ±>2À•E»ÀsÞÀ=À`Ÿ¿§M†¿Ò->€Ë*?z„??ÖÍÍ@qñ@;ë@_d@} ”@Œž@˜,N@ tK@¥Ð´@¨í£@ªÈ@ª”@©],@£Ò&@šŸK@ŽÈ´@ÉË@eúÉ@@xt@¨Z?×aØ?~Ι>‹þo¾ú _¿¤XÀò·À9èÀq+¨À”LÀ°[ÕÀÌçlÀéèÛÁuHÁ Á ÚKÁ/Ó`Á>ÒbÁMÒ–Á\ÚÈÁkübÁ{1aÁ…9ŠÁ“ïâÁŒu¡Á… )Á{FÏÁly‹Á]½ÁO,Á@‡nÁ1õ1Á#oyÁ2ÁÑ2Àñ9óÀÔä°À¸Ç÷Àw÷À‚cMÀNÌ”ÀM¿ÏN¿Y;ò½Ô=K?£ö?£4*?õ+7@ ~@@Ãû@^ z@xê.@‡@J@o@”•¤@—í@˜ó_@˜›@—h@’OH@‰ùŠ@{õÈ@acò@D†W@#Ä‘?ö+ã? uË?°>¾Л¿\·¹¿ÑªÀˆwÀOÌ9À‚NÀœï„À¹ óÀÕBFÀñš)ÁJÁÚõÁ$wÁ34ÁBÔÁPä†Á_ÝÒÁnöWÁ~!wÁ†¦äÁ•ÜÁŽ Á†±BÁ~§ÌÁoðLÁa9¶ÁRüÁD„Á5‘ðÁ'$-ÁýíÁ ñ*ÀùÊÀݾŠÀÂQ˜À§ À‹Ã¡Àck>À0|Ë¿ü远‰Ð¾÷Òü>:ƒ?Vf‡?¹kÞ@'Ê@¯¡@<Ÿ@U¯P@j+¦@y$@Ûu@„àÖ@†/Ó@…§â@ƒ¢M@}õ«@m’Œ@W0@<þ(@·Ç?ÿ‡Ž?·(å?J×B=ü*¿Á¿¤¤WÀ/À4kÀg:ÀÉÊÀ¨óÀÃSÀßQÀûÓÁ ¥ÁêÁ(yæÁ73£ÁEóŽÁT·†Ác|»ÁrW³Á€©åÁˆ5ÆÁ—HÆÁåÁÁˆŒ¢Á3åÁs¹XÁe.7ÁVÇxÁHbYÁ9ý=Á+¥OÁ~ÊÁ;Á¥žÀçˆÇÀÌ@‡À±ÒyÀ—àÀ{àÃÀHÉÐÀ9ô¿Ò."¿r‡¾wÁ>¸,~?o#c?º´+?÷“(@4G@0¸@DKV@R§%@\Tà@aJÎ@c—2@b2@^X@TüÌ@EÚ#@0¿¡@1?óÉê?´’F?ZóD>†œ¾Âô¿†ƒp¿àè4ÀCêÀP!xÀ€¸XÀšHàÀ´,÷Àά’ÀêYÁÑ`Á¾;ÁÎJÁ- Á;|ÁJ'`ÁXà°ÁgcÁv]Á‚ÈÁ‰üaÁ™NHÁ‘÷ÁЍñÁƒbDÁx7eÁi¸¨Á[RíÁLùíÁ>¯…Á0”pÁ"¨tÁ¼®ÁÒÀòt[ÀØ.À¾áÀ£õxÀŠ>¹ÀdÀ4ÎÁÀÍ¿¸1¿H.<¾DGG>ÇU ?aö?¬{`?ã‘Ã@ 6D@³g@)Uì@2-y@6ªŒ@8X±@7{O@3iÎ@*r'@¦9@Ìw?Þ´?¦Lø?Nq˜>Žƒé¾™2¢¿jÌ ¿ÉI<À€:À>îÀm õÀ-¤À§ŸîÀÁj|ÀÛÖ¦ÀöTTÁÀðÁ`íÁ$&vÁ2IÁ@¢ÏÁNþ|Á]uUÁl½ÁzÔ=Á„ÅÃÁŒ ›Á›}GÁ”8SÁŒô¸Á…²«Á|ìèÁn¢ôÁ`v§ÁRLGÁD)ýÁ65‹Á(JäÁ‹Á Ý©Àÿ òÀäãŒÀÊéðÀ±EÀ™CÀ}UÀSõ_À'†z¿ûA²¿«è¶¿@k¾bù >Žì·?<¬~?’'?¾N0?àÆÀ?ûPO@yu@ }=@ …O@ µÆ@ §?ú…z?àr?º‰?‡ì?-Û>>ù¾ªïÖ¿d”±¿¿+îÀ´rÀ2¡¢À_{êÀ†“åÀžƒ"À¶¸ØÀИÀéÊ{Áõ0Á2ÁŸÿÁ*c Á8/ÁF;EÁTh[Áb¦ŠÁpøÁÁvÐÁ‡ õÁŽa`ÁñÁ–´ÁwÁˆDeÁ(NÁt$:Áe÷ØÁWÍ"ÁIÅ=Á<Á.S5Á ­®ÁJ¹ÁIyÀòº¦ÀÙ„ÀÀÙËÀ¨•×À‘6ˆÀu‚ºÀKDÀ!¼;¿öëÿ®™ä¿Uës¾µSÎ=²dg>÷t?Jz/?‡? ùþ?± ?¹7?».?¸ý…?¯ÿ—?ž ó?ƒÜW?@¸g>ÙJ=]ƾí³¿wæÛ¿ÂqßÀËlÀ._ÀW©²À\VÀ—ÛÀ¯ŒÀÇ úÀ߇6ÀøØlÁ 1Á<Á#udÁ0ÜÌÁ>~\ÁLLâÁZXÇÁhƒÓÁvªøÁ‚q7Á‰¢ÁázÁ ÁÁ™DÁ’eÁ‹×ÁƒóUÁyÄ@Ák¦.Á]¶UÁP …ÁBs|Á4ßMÁ'‡ÁEÁ S Áä½Àé!yÀÐWÀ¹"FÀ¢«¡ÀŒ§yÀp`ÀH ªÀ#Y1À¿ÁF¨¿„¬¿ß ¾szŽ=ši¤>£ÎS?û ?$E?4e ?6—©?3Ô? q>ôáÙ>íÜ;Óp³¾š×ï¿*§ ¿œÇ¿Ïj(À ù¢À/wAÀU‰ªÀ}ÝÀ“î’À©³RÀÀ™óÀ×̶Àð Á8ÞÁÝÞÁ]Á*™äÁ7÷XÁEYcÁRÅ”Á`{¾Ánx{Á|”šÁ…\tÁŒxÚÁ“¨ÌÁ£7ÓÁœÁ•ºÁŽðÁ†ý(Áó.Ár*ÁdJ4ÁV£‹ÁI Á;ÎÆÁ.•Á!¦»Á5éÁð´Àù‡$ÀáÙkÀËSªÀµ-.ÀŸõAÀ‹ÄÓÀp~»ÀM"SÀ+)«À O©¿ÝÏ¿ª=]¿z_r¿*¢t¾à•¾‚Ì ¾CA½’éK½]ç#½¸Ðã¾06–¾Žc¾ý«>¿A¯v¿‡üD¿³­„¿èMÀ,/À5ìßÀYcsÀóÀ“zÀ§²À¼Ô½ÀÒØºÀéÒÞÁ“¡Á ªpÁÜIÁ%‰êÁ2JýÁ?D©ÁL™IÁYÿ¼ÁgkÁu nÁoÐÁˆgCÁj>Á–èÁ¦CÇÁŸ;×Á˜4Á‘.ÑÁŠ5 ÁƒD!Áxª1ÁjìhÁ]y¸ÁPTAÁCQãÁ6fíÁ)³÷ÁVÁOµÁbÀôÀÝþBÀȃ“À´lÀ uWÀàKÀy+ÈÀX›†À: sÀà»ÀmÀ¿ß;Ï¿ºWú¿œÉm¿†©Ù¿oñ¿a&¿^ɉ¿h'’¿}0¿ä¿§¸=¿Æœh¿í¼À ŒÈÀ$¤ÀBpÀbþ/À‚¥ À”õ À¨lÀ»ðjÀжÀæÀütdÁ ¦ÝÁ^œÁ!‰³Á-êÄÁ:xAÁG: ÁT9¹ÁacøÁn´aÁ|$TÁ„å!Á‹É Á’­íÁ™ŸÎÁ©lÁ¢e)Á›iÁ”qLÁCÁ†šÏÁúÁr5"Áe#§ÁX(rÁK?aÁ>epÁ1í³Á%öÁMÁ›cÁ€ÖÀñK¦ÀÜüšÀÈÍwÀ¶ À¤O¨À“¡ÀÀƒïrÀk ÀOtÀ74À!ë­À<]À¯¿ñÚ¿â ˜¿Úwú¿Ú(Q¿ß‹q¿ê8ý¿û $Àð‘À|VÀ*Q&À?Ò»ÀWX!Àr·ÅÀˆXOÀ™%^ÀªðÀ½VkÀÐùIÀäèSÀúÁËoÁÁˆÁ*JÁ6äÁCÁOrâÁ\*²Ái0ñÁvYQÁÁìÁˆr ÁDŸÁ–)^ÁdÁ¬ž2Á¥¦½Áž³öÁ—Ô:Á‘7ÁŠ@ëÁƒ˜·ÁzÔÁlÿÁ`ÜÁS_yÁFó™Á;¬Á/,ËÁ#†¸Á`"Á €–Á,vÀòfÀÞØ>ÀÌÎÁÀ»™»À«B“Àœ!ÝÀŽ.ÈÀ€ö1Àj`jÀVnöÀEÃÀ7eùÀ-ÚuÀ&úÀ#2‰À#Å…À&ÎÀ,F‡À4+ˆÀ?êÀLÀÕÀ^úfÀsyÀ…QCÀ’ü®À ¨åÀ°ÔºÀÁÈ$ÀÔÿÀæ±äÀú•Áj«Á*Áó®Á(7ŠÁ3±ßÁ?ŠÌÁK¾ÁX!Ád„·Áq'+Á~*¾Á…­¶ÁŒH†Á’î Á™´¢Á “>Á¯ýœÁ©ÌÁ¢D»Á›Á”ÂÁŽ5Á‡|`Á€îyÁupÁh‹Á\2pÁP1oÁDSóÁ8Á-HzÁ"ŽÁÿ_Á Î}Á/­Àõ©ªÀäâÀÓ{<ÀÃý–Àµ ÂÀ§P»Àš¬SÀuÀ…fÀ{„KÀm$¢ÀdÐ2À^#*ÀZ·wÀ[åÀ^2}ÀcÆØÀkµÀvågÀ‚@ÀŠ¥ÿÀ”gÿÀŸ¡À¬eÀ¹ëüÀÉÀÙfîÀêå©ÀýÁ)äÁH»Áv”Á'!)Á2,oÁ=W’ÁHøwÁTá%Á`ê|ÁmM¼ÁyÇÁƒ0ÅÁ‰©%ÁDÁ–ãZÁ‡­Á¤>†Á³”sÁ¬ÆÁ¥ÿÓÁŸCßÁ˜ŸÉÁ’aÁ‹zßÁ…{Á}ÎwÁqsÀÁed5ÁY†ZÁM·ÁBY±Á7ŸRÁ- 1Á"¤kÁ þÁ¡TÁo0ÀüCmÀìOÔÀÜí•ÀÎã½ÀÁH+Àµ)ƒÀªFÀ ¢ÃÀ™OxÀ’{)ÀŽ8ôÀŠÌ6À‰jðÀ‰©ïÀ‹lyÀŽ\qÀ’u>À—†ÝÀž( À¦äÀ¯ÌšÀº#ÀÆg\ÀÓ—éÀá}˜Àñ±óÁ*Á €Á>Á/AÁ'WšÁ1‹uÁ<[{ÁGmQÁRœÁ^SäÁj@˜ÁvC.ÁTôÁ‡›œÁé’Á”VïÁšâ}Á¡Á¨(2Á·NÁ°äÁ©ÍÁ£2ÐÁœ¢Á–#ÎÁÌKÁ‰ªÁƒ[ Áz™IÁnÏÁc#†ÁWº3ÁLå:ÁBMDÁ7ËyÁ-õ‘Á$†+ÁD[Á˜—Á ^EÁœîÀö„ Àè»óÀÛÙUÀÐŒÀÅÏÕÀ¼p Àµ¦À®ÍzÀªG˜À§5tÀ¥ßõÀ¥ãÀ§Ô½Àªè€À¯eÀ´.„ÀºpGÀÁÐÀË1ZÀÕ~Àà•]Àí»¯ÀûQÁ;3Á \½ÁéôÁþÁ(`FÁ2t+Á<š_ÁFè™ÁQÑÞÁ\æ²Áh"ÁsÞÁÎÂÁ…è½ÁŒÁ’YBÁ˜­CÁŸØÁ¥‹XÁ¬ËÁ»SÁ´mfÁ­ÝgÁ§XˆÁ â™Áš£Á”CzÁŽ ~Á‡üNÁ‚! Áx­ŒÁmB÷ÁbViÁW¤ÁM!ªÁC-Á9y Á0#=Á'j ÁÌÁëÁGQÁEXÁdNÀöË~Àë^ ÀáI˜ÀØa©ÀÐæÎÀËËÀÆfƒÀÃÏ«ÀŸeÀÂVwÀÄ„&Àǧ[ÀËÎvÀÑuÀÖÛãÀÞJäÀæµ?ÀðæçÀûe™Áñ{Á “ÁÁÍcÁÅ*Á!ë§Á*ÑÁ4 ‡Á=žêÁGŠÁRÁ\kÜÁg]‘Ár~>Á}ÌÁ„½ëÁжŒÁ»ZÁ–×dÁoÁ£qÙÁ©Õ`Á°?öÁ¿!øÁ¸šÁ²IÁ«¦aÁ¥S.ÁŸZÁ˜Ï,Á’ÄÁŒè#Á‡-ÁfMÁwÙ*Ám bÁbxÁXz>ÁN¶ÁEŽÁÁ#õÁ´»Á…eÁ&VúÁ.O)Á6¯Á?Û÷ÁI·ÁRìßÁ]2ñÁg|„ÁqðØÁ|ìÿÁ„»Á‰»¿ÁñÁ•ŠºÁ›pÁ¡¡½Á§Ú™Á®6àÁ´œ$ÁÃZAÁ¼ØoÁ¶j|Á°ÃÁ©ÕÅÁ£§ÁžJÁ—¾`Á‘é°ÁŒ/ÚÁ†°±ÁIÁwå3ÁmÊOÁd@ÁZf<ÁQBÁHœõÁ@7¯Á8L,Á0ÑÁÁ) 'Á"æ˜Á”’ÁÎHÁ’ÀÁ ·þÁ¦ÈÁWÁc+Á<¥ÀýÍÃÀüâÀü³ÐÀÿÌÁïÁ8Á˜7ÁVÔÁ Ì^Á§¿Á(¡Áa‹ÁÉÕÁ%$Á+¬–Á3Á;¹ÁCÁKÍmÁUMÁ^lÃÁhmêÁr´ÌÁ|üÁƒÃ8Á‰K¢ÁŽíqÁ”“uÁšd¸Á cÁ¦jlÁ¬zÁ²­èÁ¹ÁÇ™yÁÁ/òÁºå+Á´°LÁ®ŠÁ¨}SÁ¢˜kÁœÅ¬Á— âÁ‘…¬ÁŒßÁ†ÂÁ¢(Áyy:ÁoÊ¡Áf~üÁ]éÁUZÁM ÁE=2Á=üJÁ6ðµÁ0„ÒÁ*=ôÁ$Î…Á‘€ÁÿíÁîœÁ•ÁãÈÁç–Á ìÁ rÁ úßÁ)ÔÁÊÁÞ¨Á2œÁZÁ3%ÁÿÁ"_QÁ'dçÁ,±ðÁ2²¦Á91Á@üÁGäÁOÖÁÁXrÁa,~Ájo®Ás÷ÎÁ~ñÁ„+Á‰PˆÁŽ¢XÁ”0«Á™ÑýÁŸyPÁ¥KÁ«I7Á±RcÁ·`ÒÁ½ÐÁÌ|ÁżŒÁ¿’§Á¹lôÁ³\ïÁ­r|Á§¨Á¡÷¤ÁœhÁ–ùmÁ‘œ"ÁŒtTÁ‡uóÁ‚˜Á{Ú\Ár¯JÁiðVÁaÚÁYñTÁR[#ÁK5sÁD†GÁ>!MÁ85Á2דÁ-±}Á)`ïÁ%WÏÁ"/†ÁjûÁ–ßÁCTÁàóÁÓ×ÁyÁ¤yÁ ® Á"æ¾Á%° Á(©\Á,fÁ0ª¾Á5xuÁ:¦ÀÁ@oÁF¿ÁM„JÁTÑÁ\½’ÁdÕ)ÁmxcÁv•VÁãLÁ„ÔðÁ‰ÜÛÁŽý|Á”1ÆÁ™‘ÒÁŸ$-Á¤Ä¦Áªm Á°?—Á¶;­Á¼E¿ÁÂS­ÁР;ÁÊvÌÁÄOúÁ¾>öÁ¸S»Á²ÒÁ¬ê”Á§TÁ¡ÕÁœv:Á—J9Á’CuÁN„ÁˆšÞÁ„»Á»Áv°¾ÁnÎ]Áfð(Á_†õÁXµeÁR!ÁKãqÁF0@Á@æfÁ<“Á7Ì:Á3üÁ0Ó˜Á.)Á,sÃÁ+&ðÁ*ÖÃÁ*ÑsÁ+ëÁ-†ÂÁ/…ìÁ1ÂÁ4~+Á7X¿Á;MÁ? ÁC»ÄÁH¦NÁNP¬ÁTP•ÁZúèÁbLÁi¤qÁq¸xÁyþEÁq™Á…ÿÁйÚÁ°±Á”³ÕÁ™Ó»ÁŸpÁ¤ŽÁªÚÁ¯½8Áµk#Á»>¦ÁÁ3òÁÇ;°ÁÕbìÁÏ:(ÁÉ+õÁÃAšÁ½~tÁ·ß±Á²GwÁ¬¹GÁ§Q¢Á¢ ¾ÁÈÁ˜áÁ“O`Á޹uÁŠ*ýÁ…ÛùÁÚEÁ{Ì1Át±ÁlúuÁf;[Á_ßÁYǤÁTE\ÁO(ÁJ±ÁF>ØÁB©òÁ?xwÁ=Á;e¢Á:1Á9׿Á9ÏÁÁ:Ú-ÁoµÁ@ª‰ÁCR7ÁF-óÁIÁªÁM—ÐÁR ÁVÖ-Á\9ÁbìÁhu0ÁorÁv°ôÁ~¡ñÁƒ]:Á‡¦âÁŒ&ÿÁ¸Á• ÁšŒsÁŸÁ¤µžÁªƒÁ¯Ž›Áµ}ÁºµéÁÀl ÁÆE5ÁÌ1ÒÁå5"Áß/HÁÙI`ÁÓ}Á͹ÇÁÈ ÁÂzÐÁ½Á·çŽÁ²¿Á­¬Á¨Î²Á¤JÁŸp-Á›Á–ì˜Á’Õ5ÁŽûOÁ‹kyÁ‡ö^Á„×_ÁÖÙÁ~<ÚÁyavÁtÙ‡Áq.Ám™ Áj—ÌÁhhÁf=mÁdÂ1Ác¤EÁbÉùÁb¸ÁbÒÁc¹cÁe ¸Áf–PÁhÿÇÁkžÁnûYÁr—Áv¼èÁ{Q¶Á€¸Á‚¸¦Á…ŽÓÁˆ 9Á‹×@Ám Á“-”Á—nÁ›C¸ÁŸ¬ªÁ¤€Á¨µ¹Á­†æÁ²†ÚÁ·‘Á¼ÂûÁÂ%½Áǵ_ÁÍfÁÓ1ÁØæˆÁàn`ÁÚFÌÁÔ>»ÁÎXñÁÈ’åÁÂÙ¥Á½-ØÁ·¦ÿÁ²O=Á­Á§éÄÁ¢ÝÜÁžWÁ™e†Á”ÖfÁ‰ÁŒikÁˆd™Á„´Á%ËÁ{Á&ÁuȵÁp„Ák%ùÁfvÁbœ:Á^üÌÁ[À…ÁYRÁWZ(ÁUÛÁT°»ÁSáœÁSÖ~ÁSûmÁTÞcÁV1XÁWÔïÁZEîÁ\ïÁ`f¿Ád¥ÁhhùÁmÁr$2Áw‡½Á}{8ÁئÁ…8ÂÁˆê™ÁŒ¯oÁ¿ŒÁ•òÁ™‡‰Áž$Á¢ã6Á§ÜÁ¬Û·Á²œÁ·[âÁ¼æÁÂŽTÁÈ>HÁÎÊÁÓîYÁÛÈŠÁÕŒ ÁÏb÷ÁÉXÃÁÃrÁ½²4Á¸3Á²\mÁ¬×ÇÁ§…aÁ¢L‹ÁÇÁ˜—Á“e6ÁŽÃ³ÁŠ@Á† ÁôµÁ|52Átï)Án¼Ág÷Áb(ÚÁ]ÈÁXGÁT ÁPvóÁMÌÁJ©ZÁH™bÁFôIÁEËÙÁDý3ÁDæ¯ÁE%ÁFcÁGd×ÁI=OÁK¯AÁNrFÁQõTÁU®‰ÁZ™Á^ÞýÁd3+Ái¼~ÁoáàÁvdëÁ}~Á‚tÑÁ†ZxÁŠ•¢ÁŽõ›Á“{§Á˜@eÁ7¨Á¢8³Á§SÁ¬£?Á²&²Á·ÃÊÁ½iÜÁÃ-]ÁÉÁÏ&žÁ×.ÅÁÐãûÁʬÁĉsÁ¾2Á¸™ Á²ÜÁ­2¬Á§‹Á¢ÞÁœ»ÝÁ—…pÁ’_#ÁuôÁˆÄñÁ„"7Á\`Áw FÁoBçÁgÏIÁ`—ÁZ;×ÁTdÁNÿÁJ&NÁEØÅÁAû-Á>¢Á<‰Á:$Á8+fÁ7 \Á6.!Á5÷kÁ6NÃÁ7(cÁ8´ãÁ:±ôÁ=#XÁ@"ÚÁC¦àÁG.ÁKëÁPåÁVEXÁ\9Áb‰ÁÁiL»Áp›$Áx.Á€2PÁ„s´ÁˆâÁðÁ’“^Á—Áœ¶±Á¡þSÁ§wúÁ­öÁ²¤ÀÁ¸e•Á¾PÁÄ`>ÁÊôÁÒ»æÁÌVRÁÆ Á¿Î[Á¹³ÌÁ³²‚Á­ÎÁ¨¹Á¢c;Áœº8Á—<§Á‘ùjÁŒÐPÁ‡¹gÁ‚å¦Á|W;Ás´ÁjkµÁbz~ÁZ¼ÁS{|ÁLðÁF¦ÁA’Á<bÁ7°»Á3—8Á0`šÁ-(Á+nÁ)›Á(|JÁ'ƒJÁ'èÁ'yîÁ(\{Á*ÞÁ,&ÒÁ. -Á1דÁ5g©Á9‘ÚÁ=èsÁCÁH}¡ÁN±IÁUGíÁ\`ºÁc¿ÜÁkÄÁt*þÁ|ÂØÁƒÍÁ‡ó:ÁžÁ’3Á—b&ÁœÍóÁ¢\ìÁ§ñóÁ­¯,Á³˜²Á¹ªIÁ¿ÝîÁÆ¥ÁÎbÁÇôÁÁ‡¤Á»-õÁ´õÇÁ®áÑÁ¨ìÁ£?ÁP¦Á—ŸWÁ‘÷XÁŒ‚½Á‡IuÁ‚!›Áz=ÔÁpµ±Ág7Á^?ÁUÎÔÁMÞ©ÁFa Á?œpÁ9~Á3=ÉÁ.²Á)›(Á%zƒÁ"8ˆÁUÁÜ•ÁA Á'Á±Áf5ÁÏËÁÁdÁYÁ›±Á 6{Á#5Á'WãÁ+–ÔÁ0;}Á5‚¬Á;ÂÁAs¤ÁH0XÁO€¸ÁW/ŽÁ_‘BÁhÐÁqOÁz½'Á‚h5Á‡»ÁŒÈÉÁ’&ÄÁ—²MÁO;Á£ Á¨õXÁ¯¹Áµ5ÀÁ»mþÁÁ¬„ÁÊ'*ÁçÿÁ½0bÁ¶ÄÁ°hÍÁª,%Á¤¨Áž+ŸÁ˜W~Á’Ž®ÁŒä£Á‡KEÁâQÁyK°Ánñ4Áe êÁ[®eÁRMbÁI‡âÁAW8Á9n„Á2~Á+ðGÁ%§Á sÁ¹ˆÁpÁØÁ77Á~„Á ô.Á ¦Á ›ÛÁ “Á q\Á `vÁ Õ1Á¯Áæ’ÁC§Á^ÞÁ´ŠÁ"¼tÁ(hÁ.ˆÁ4QkÁ;lêÁBõ.ÁKzÁS ÍÁ\j¨ÁeÎHÁo ÁyΔÁ‚/pÁ‡ƒCÁ]Á’²Á˜~>ÁžaÒÁ¤o,Áª™Á°ÆŒÁ· $Á½l—ÁÆÏÁ¿pÊÁ¸ñ-Á²rQÁ¬âÁ¥¬‹ÁŸt-Á™]¶Á“tÆÁ ìÁ‡ØÒÁ‚<ŽÁyT‚Án¢Ád#GÁYÛâÁP/ÁFÀ.Á=µTÁ5>`Á,ý Á%‹ÿÁÕÒÁ~ÓÁ<ÁêÁ ÂêÁ/hÁØÁ€¹Àýu¶Àú}GÀøÑ À÷üLÀøêbÀú™àÀýX¾ÁÒäÁ¼ÅÁ)¥Á eØÁ Á@ËÁðZÁ!‰Á'—‘Á/{Á6ÜÁ?4ØÁGï!ÁQ--ÁZ£dÁd¡çÁo/!ÁyÎOÁ‚c¢ÁˆÁñÁ“ÏÿÁ™×ÁŸÿ×Á¦.ÞÁ¬uYÁ²Þ“Á¹gmÁÂ¥Á»`oÁ´ÈJÁ®C4Á§¿¿Á¡GDÁšòeÁ”ÃUÁޏ-ÁˆË5Á‚ô[Áz`rÁo.àÁdšÁY€¡ÁO0ÁDÿ±Á;A:Á2„Á)YûÁ ÷Á'ÜÁí1Á q6ÁÕßÁ¥Àø5°Àðµ[Àê ÀåOŒÀáa¹ÀÞBÿÀÜÓÀÜ7ûÀÝ7eÀÞùîÀáå/ÀååÀëÕÙÀòæ§Àû+žÁÁôÁ ðŒÁN8ÁZîÁ# ÕÁ*Þ”Á3t§Á<®ÁEøëÁO¹wÁZ/ÎÁdÒÁo°…Á{¼ÁƒdàÁ‰?¼Á?’Á•höÁ›¨qÁ¡û Á¨iÁ®÷ÁÁµ±Á¾d*Á·‘¢Á°ÕäÁª5nÁ£ª²Á!öÁ–¢PÁGkÁŠTÁ„„Á|U×Áp•ÁeiÁYçåÁNòûÁDzïÁ:"Á0&¤Á&jrÁ—ÁbÁ ·ÁŸ Àý0½Àñ¥@ÀæŸØÀÝI ÀÕ¿8ÀΆLÀÉ»©ÀÅŽVÀÂ×!ÀÀïnÀÀ~ÐÀÁ„hÀÃCÀÆÚþÀ˯ÀÑ œÀØ6¡ÀàšÀêHÒÀõ×(ÁçÁß´ÁKdÁÿ"ÁjÁ(;…Á1EÁ;0"ÁE|hÁP ÁZèÁf;•ÁqÉÞÁ}kFÁ„±gÁŠá0Á‘4UÁ—šMÁž ÉÁ¤’ÄÁ«1NÁ±è(ÁºÕÁ³ëàÁ­´Á¦YvÁŸ´òÁ™gÁ’“*ÁŒÍÁ…·¢Á 1Árú\Ág«Á[AˆÁOÎÁD×iÁ:JÁ/‹ÚÁ%KÁwÁÉÁ lÌÁúøÀó Àä¥\À×ê~ÀÌ­xÀª¶Àº÷"À´$bÀ®¡ÉÀªŽ\À§x.À¥œ¿À¥¸À¥Õ…À¨pãÀ«ÔéÀ°h{À¶²À¾NÀÆÚŒÀÐÇ”ÀÜ!Àé?‰À÷ÇÁMÞÁ Q“ÁùÁ&5Á&ÀLÁ1DÁ;„ÁFFnÁQ•×Á]òÁh™ÇÁtŠÁ€uÏÁ†Ö„ÁEÍÁ“µÁš3ŠÁ ÔVÁ§“ÎÁ®lfÁ·hÁ°k¾Á©x•Á¢œðÁ›Ý!Á•8vÁŽ™5Áˆ Á‘JÁvÁjOÁ]ˬÁQä#ÁF.QÁ:Õ Á0 ?Á%]=ÁÒbÁå-ÁJÀü¬FÀëfôÀÛV—ÀÌsÜÀ¿>qÀ³–À©aËÀ ”ŸÀ™æÆÀ”¸À©ÍÀŒwËÀ‹ÀЧÐÀŠÌ¹ÀqøÀ‘“À•ÄzÀœk À¤9MÀ­CHÀ¸ 'Àù»ÀÐÊòÀßcRÀïfaÁ!ÒÁéçÁPäÁ“êÁ&ìCÁ1¤ØÁ<õ'ÁHhñÁT„Á`vÁlhàÁy* ÁƒuÁ‰pÁòÜÁ–šbÁaÜÁ¤<‡Á«ëÁ´'†Á­ÏÁ¦<ÁŸ ±Á˜9—Á‘oÁŠÄ£Á„$ðÁ{UÁn'ñÁa•£ÁU3ÁH°#Á<ÍKÁ1]{Á&/qÁF¢Áž1ÁbùÀùŸ²Àæ¢ÀÀÕWéÀÄ.ÖÀ´Ø'À§ ^À›< À~þÀ‡¢ÀË6Àt yÀj™HÀdÚÀÀa³çÀaj„Àc ÓÀg¼zÀnKÀw/UÀ‚*˜ÀŠuºÀ”S™ÀŸfÀ«ÅÀ¹nþÀÈG³ÀØ™ÀÀêI½Àü—áÁLkÁ„CÁ ¿Á(WÁ3Ó Á?‚%ÁK³ÁXÁdÁÁq›ôÁ~ŠþÁ…ÖaÁŒ†(Á“G Áš Á ñ÷Á§æWÁ±[Á©õ}Á¢×—Á›ÍÀÁ”ÖãÁòÿÁ‡$ûÁ€p›ÁsŸÁfcâÁYmïÁLÔrÁ@GÄÁ3Þ Á(HÁɺÁžÚÁ‡zÀ÷ópÀäŽOÀÑu À¿+ñÀ®‹Àˆ¥ÀÀƒ;BÀp /À]¬ÀMíÉÀAô©À8ªÀ1$À.CîÀ.%À0Ê×À5þÀ<- ÀEÊ>ÀRîXÀboÀvïoÀ‡À”À¢µšÀ±“úÀÃlÀÕ>ÀèÁ’Àüû>ÁéØÁ ÕÁ•§Á+;oÁ7nçÁCÊ\ÁPYöÁ];”ÁjSUÁwiÁ‚y4Á‰8[Áÿ$Á–âVÁàdÁ¤õTÁ®eÁ¦ó‘ÁŸÎðÁ˜ªXÁ‘’ÁŠ“Áƒ±bÁyÙGÁlk„Á_¸ÁQÃ6ÁDűÁ8,;Á+´–ÁYŒÁˆÐÁNEÀú6çÀãôOÀÏ’À¼f·À©PªÀ—útÀ‡ç(ÀrÏ ÀXƒ=À@ À.]ÀbÝÀòÀ»¢¿ÿ‡þ¿ø›¿ø¯—¿ýåÀž¦À ‘ÀŠ¿À"—TÀ4%ìÀHkÀ^;oÀ{½ÀŒnpÀœeÀ®!ÀÁ?çÀÕ 3ÀêU Á>IÁ m]ÁòÁ#4Á/‹sÁ< ÁI+ÁV!dÁc]ÝÁpâõÁ~QÁ†£ÁŒÿÈÁ”èÁ› Á¢%ÛÁ«P,Á¤­ÁœéIÁ•èÁŽžÕÁ‡éÁ€v¬ÁsyÁe{1ÁX¢ÁJ“?Á=,ÀÁ0#ÑÁ#š±Á6„Á ׸ÀþÀ笵ÀÑ£fÀ»ùÀÀ¨dmÀ•‹À‚®¯ÀeI|ÀFK"À+:FÀ†’¿ÿ`ÿÜT¿Á³¿¬°O¿¢D¿—Y•¿—È¿€¿¤Ò¶¿³c¿È e¿åÒTÀâ®À9|À2òðÀN²³ÀmTåÀ‡áæÀšbƒÀ®/»ÀÂŬÀØ÷ÔÀï:-ÁŠÁ Á€Á(,·Á5(ÁBA^ÁO†nÁ]ÞÁj­ßÁxcàÁƒ,ÁŠ.àÁ‘3Á˜K€ÁŸyiÁ¨´ Á¡abÁšRÁ’ïÁ‹Ã0Á„˜ÁzònÁläwÁ_ ¥ÁQE«ÁC¾rÁ6IãÁ(ótÁæãÁRÁÕ^ÀìÈóÀÕVµÀ¿[ÙÀ©nÀ”›µÀPÀ\{¶À<ˆÀðgÀîb¿ÎØ¿¥a3¿’e¿JP[¿z4¿>„¾â¦“¾Ýza¾õ¬/¿ W¿(‹“¿W¿Š{(¿±‚ñ¿Þ×ÀÅ1À%ž%ÀEÀiNèÀ‡ëKÀ›s9À±uÀÈLòÀß(jÀödNÁAÁtÑÁ!kÍÁ.z©Á;ÌÃÁIS…ÁVáÁd°JÁr»²Á€h-Á‡uâÁŽ™¹Á•ÈêÁœþ$Á¦;ÁžÔ«Á—wÝÁ,sÁˆõ5ÁË ÁuJ­ÁgÁXé|ÁK Á=8ÓÁ/|›Á"Áå|ÁÑ$ÀöhÏÀÝy‡ÀÄÔ3À­âÂÀ—“ˆÀh¿À[*+À4x¨Àµ¿åJ–¿¬üp¿r¸Ù¿@¾§yö½º'™=¤ò¦>]Bë>Šœ_>Œ>y’¢>3ƒ=Œ«B¾dú¾ËÄq¿7ô»¿ŠíN¿Àª¿þ_/À)îÀD«3ÀlZüÀŠøÂÀ¡DÀ¸.ˆÀÏŸŠÀçúÁÕ!Á ¸VÁ´MÁ(7Á5¶ýÁCfÉÁQ;5Á_>÷ÁmPsÁ{€7Á„í…ÁŒ!WÁ“^ÿÁšªfÁ£â&Áœy<Á•Á²dÁ†\ºÁ~/ŽÁoÒˆÁaŠÁSF¿ÁE²Á7jÁ)FÁ‹ØÁºÁç‡Àç‰ ÀÎAaÀµ`ÞÀ4ªÀ†À`OõÀ6”#ÀÚ¼¿×k%¿—&¿9ò(¾¥><õ„>©ÊÔ?N¼?Eõ?d”W?v¤?wu}?oà¬?_[??ýZ? Å>€Ö–½½".¾ðîð¿g„¿³ðï¿ùùjÀ"Ñ¥ÀK›ÀvÀ‘÷µÀ©QÀÁ8jÀÚÉ>Àô˜ØÁG€Á®@Á"JóÁ/ú!Á=Í\ÁKÒÁYðLÁh9Áv¯#Á‚¢ Á‰ìYÁ‘7­Á˜‘=Á¡©äÁš+ºÁ’¹!Á‹UÁƒý;Áy^@ÁjÅ—Á\<ÁMâÁ?–æÁ1SëÁ#@£Á‹ôÁ7Àôö¡ÀÚqÀÀLÀ§6ÀöqÀl‘éÀ?Z…Àëó¿×gᅧµ®¿ìç½æRÏ> 4$?*O'?tY“?›¿ž?´†y?Æý?Í÷*?ÏÍÜ?Ì1Y?Äé?±¢Ù?’¹&?\Å?’=´wN¾¸; ¿^¡ª¿¹DmÀšÃÀ+Â…ÀX,ëÀƒ©aÀ›n*À´y×ÀÍë•Àè ÁtÁÿÄÁž™Á*zËÁ8ª‚ÁFðöÁU7kÁc“,ÁrÍÁ€c˜Á‡ÄòÁ+WÁ–›ªÁŸ‰õÁ˜#Á—‡Á‰#Á´Át«ÄÁf’ÁWužÁHÛ­Á:Z Á,CÁÏÁìFÁ%ŸÀé*†ÀÎ ñÀ³L÷À™ØNÀ€Š“ÀPÆÀ ž¼¿èIr¿“7G¿ÿ¼Ì]¢>îÊ,?_Ð3?žOñ?È;Ò?êÈÈ@¬-@ žW@á®@Tv@ ý@ Ùš?ýê?Üj3?³S·?„±j?ú>új¾Ã˜h¿y|0¿ÍXÀHåÀ<ô€Àl¬fÀŽ÷™À§ù…ÀÂ~ÀÜ‘)À÷zaÁ ¢]Áª*Á%ÁþÁ4QÁBV5ÁPÇáÁ_U{Án µÁ|Ö«Á…Ù³ÁRâÁ”ÎŽÁ¨$Á–aÁŽ”[Á‡“Áh|Áp•&ÁaÁÐÁRùÁDTÁ5ÁFÁ'W¿ÁOÁ å®ÀùmÚÀݬrÀÂÑ´À¨ÓÀ“bÀf¼+À4ö+À]©¿®­·¿.Ïë½…·†?‰œ?Õ?·?ç?G@¸¬@ @&¹´@/äN@4@ @4òÌ@3ާ@-çz@!CŸ@ÅÏ?õZv?Â[Ð?‹"À?f=L='¿¡7¿—Š!¿ìX²À$kBÀT—ÔÀ‚éUÀÄÀ·uÂÀÒ,wÀíöŒÁö¬ÁúÁ!MÐÁ/ÆŽÁ>?KÁL»ÄÁ[bKÁj5ÁÁy$aÁ„Á‹“ýÁ“ñÁ›ôÁ”hRÁŒÝEÁ…RÑÁ{¦‘Ál¿žÁ]áVÁO HÁ@19Á1g÷Á"ÏËÁzðÁ93Àïý¹ÀÔìÀ¸” Àf¸À‚ZrÀPþQÀÓ+¿ØöT¿r¾Ú>ÈÌÑ?y?½†ï?öÎÐ@4@(è7@:®@HDâ@RE·@VÃ@Wú@UÀÆ@On^@@{6@-Ó*@A¤?ûD_?Àá‡?CÑ>êºÞ¾ v¿H Æ¿»|ÛÀ õ‹À=„XÀpÉÀ’‹ñÀ­ÀÀÈÓÉÀä¼’Áa:Á¾ŽÁ8+Á+Ì)Á:täÁIÞÁWÓ¶Áf¥[ÁuŽzÁ‚J}Á‰ÛwÁ‘rNÁšX Á’¾ÜÁ‹0ÖÁƒ§ Áx9Ái(]ÁZ64ÁKP Ád¡ñ¾à2Z¿KÑ¿î`ýÀ)U/À]ƒœÀˆüZÀ¤Y·À¿å‘ÀÛÍÐÀø€ÙÁ ÖVÁx<Á("Á6ÉöÁE‡§ÁTYÑÁcTÁrZIÁ€´'ÁˆBïÁØ*Á˜ÔnÁ‘5àÁ‰™EÁ‚Átï¥ÁeÜOÁVÉÁGÁÁÁ8ãlÁ*$èÁ}_Á æôÀüõyÀàGZÀÙ<À§GZÀ‹áˆÀaìÀ+§ä¿ï4¿ˆF‘¾Ÿ  >ÜÎÉ?#Õ?Ý …@Éa@0xü@K"¡@ad¯@tí@€ð @†8—@‰4ž@Ц@ˆGÄ@‚÷Æ@uùp@bb€@Já»@/_Ú@ç6?àÝI?˜ÑÑ?ÅÆ½´&Ì¿R¶l¿ÈeVÀ¾€ÀKG5À€²Àœe-À¸5fÀÔ#$ÀðºBÁþ¢Á»™Á$yJÁ3;èÁB(/ÁQ.0Á`4dÁo:™Á~CIÁ†±œÁŽMÓÁ—aÁĆÁˆ'ûÁ€ŽÿÁr Ábù(ÁSðHÁDÞ­Á5ààÁ' |Áf|Á Ê·Àö_4ÀÙ=„À¼ÓRÀ ¿aÀ„Å_ÀRì‘Àɤ¿Ñ…¿Sûý’Ôe?-»ß?®="@úü@$Ø@Dvß@_íJ@xQ@…Û_@=G@’dD@•}X@–K@”8ö@ ‡@†ô†@xöG@aú@FN“@'µÍ@Ó?³?aq>J>§¿膿¦q‚Àg‹À:¾žÀr /À”Ö×À°ÍGÀÍ,8ÀêY<ÁφÁjÁ!"xÁ0 [Á?‘ÁNÏÁ](·Ál7ÓÁ{\(Á…L’ÁŒñfÁ–]ÁŽf4Á†¾ãÁ~>®ÁoÁ`qÁQ\ÁBHÁ3ÚÁ$[Ál;ÁÎfÀðc/ÀÓlûÀ·­ÀšÉUÀ}71ÀFŽæÀ€¿¸þ¿"ó">hn?`Ñ}?ʱ‹@ÄŠ@5£@Ur.@r?Â@…ϧ@W@—õ*@œÖÍ@Ÿœp@ H @ž ì@˜áß@‘…·@‡HU@v–›@[€;@;øÑ@šö?ç^Z?“ ï>éò¾Š¶ƒ¿‡"¿ïa À,ÒõÀcNàÀª¢À©Ý±ÀÆ÷ ÀäÁž­Á:¦ÁiÁ-ZÁ<fÁK#›ÁZ2šÁi]°Áx¢…ÁƒøuÁ‹¡Á”ÕÁ´Á…j<Á{‘œÁlcÈÁ]LUÁNP,Á?pÕÁ0m¸Á!mæÁ˜°ÁÀë7äÀÎa¦À±‹hÀ•BÀrG5À;HÀM·¿¡U—¾ê•>¢¢«?ˆ¦É?á!™@—)@Bù@d]]@€² @´#@˜ÆÍ@¡ý@¦-É@¨lv@¨P4@¦Í@¡Mw@š @öÌ@„EÌ@m<þ@MÒ@*]m@“ë?±ß?.×õ½—¶¿XZï¿Ô¡áÀŸÑÀVîiÀ‡{¯À£ØøÀÀô‚ÀÞ(ýÀûÂ^Á ÕBÁÃ}Á*Ÿ»Á9ˆ[ÁHšÁWÌäÁgåÁvBæÁ‚¿dÁŠaBÁ“£¿Á‹öÁ„LÁyMàÁj×ÁZÝäÁKÈWÁ<×»Á-óÁ<Á03Á}%Àæ%õÀÉj]À¬®ÄÀç¶ÀgQíÀ0¶ð¿öS?¿‹ê{¾’­g>øfý?ž?÷ø‚@'ê@N@pâe@‡~´@”œï@Ÿë@¨‘°@­Çm@¯ýy@¯Å%@­oæ@© @¢˜@—Ê@Œ Í@{ݯ@\@7Ë@`?Ê;)?^¬=áïp¿,Î’¿¾²<ÀÀÀÀL¬ÿÀ‚LŸÀžwFÀ»¡ÀÙAÀö´/Á 5ÝÁÁ'û}Á7ÁFHTÁU„êÁdÈaÁt ìÁ¨gÁ‰RÌÁ’ 9ÁŠîâÁƒFïÁwSüÁh+®ÁYÏÁI÷JÁ:ÝÄÁ+ÔÏÁìAÁ4ÀþÏ“Àáž ÀÄm\À§‘À‹TIÀ^‹¸À'nô¿ãW¿o1¾A ?$ë?³/Ö@À;@1³µ@XÿN@|>z@B¿@šdX@¥ìs@®v@³ç‰@¶}U@¶}@³ïÁ@¯J¨@©" @Ÿ3‘@’G)@„ ÷@g×Å@B¤P@E´?Ýs©?‚¾>‚Un¿'!¿«QÀ ÀÀC1À{$Àš&À·k ÀÔÇ&Àò#@ÁÄ]Á¨#Á%½…Á4ëŸÁD ¨ÁS^¨Áb¡þÁqå–Á€š²ÁˆL Á‘Ô ÁŠ)‚Á‚€OÁu®ÛÁfm·ÁWGÅÁH.ŠÁ9èÁ*oÁ!åÁ CWÀû3ÕÀÝó×ÀÀ¹%À£šØÀ‡\æÀV×ÊÀ"¿Ñ¶í¿MÕB:Õr®?IìÁ?İ@A—@;ØÑ@b”Â@‚í;@’/@Ÿ}ï@ª±Ž@³&î@¸Àä@»Ñ@»6 @¹cZ@µ…@®½±@¤kd@—@Ð@ˆã@plM@KDy@"›?íˆ?’ºŒ>Áþ4¾È¯¿›c$À% À:R]ÀrÀ•èøÀ³MÀпØÀî2¬ÁÖ0ÁÂûÁ#à2Á3|ÁB<ÆÁQnÁ`©RÁoúÑÁ] Á‡bWÁ‘"4Á‰zGÁÕ­Átd Áe<ÁUá€ÁFÀ1Á7ÃKÁ(ÓƒÁåÁ ø‡Àø WÀÚÀÀ½ÒhÀ¡À„u¬ÀPiVÀF¼¿Å*¿4ó=Ü©U?gž?ÒìÞ@X[@BK7@j?Þ@†é7@–6Á@£˜º@®ä&@·1Ì@½Nâ@¿ñ¶@¿Ä*@½î•@ºæ@³ˆ@¨ì@›mª@ŒÃ@võÕ@R-@(Û?û±?  `>þ“˾ˆÞ¿‹üî¿öÙàÀ2¡Àjñ:À’?ŠÀ¯;ÐÀÌ£”ÀêDÁ 7Á zÁ"'Á1Y Á@‘<ÁOÉÁ_Ánq@Á}ÕxÁ†œØÁ¾Á‰TÁkMÁs‰òÁdE£ÁU›ÁEåÃÁ6ãæÁ'çhÁí[Á ÓÀöšÜÀÙ%À¼(+ÀŸB\À‚pïÀLËžÀ T¿»@a¿"ù>;ck?vßY?ÛÚ@Œ†@Gžr@oDŠ@‰•`@™g@¦ã’@²€@º†e@À‘ü@ÓZ@Ãh@Á@½Ê @¶˜@@¬œT@Ÿ-Ä@Õj@}‚¡@Xu«@/,1@Åe?«ó?Ò¾0ŽË¿}ŽÓ¿éû À+³JÀd€÷ÀŽèôÀ¬,lÀÉ­ÀçQXÁ’ÁTÁ ¶KÁ/ÏAÁ>ñ›ÁN1MÁ]ˆêÁlå+Á|CbÁ…ÑœÁbDÁˆ´ZÁ 1ÁrÒ»Ác“ÁT\æÁE6ÐÁ64œÁ'V#Á{:Á ¡ÀõŽ”À×ú¶ÀºöõÀž Àp^ÀJ•„À›¿¹Hˆ¿¶N>O(û?|1ß?ß '@¿[@J,˜@r ç@‹ƒÁ@›±‡@©N’@´-‚@¼”Â@Ã?@Æ-¬@ÆLl@Ä_0@À¢f@¹†ó@¯s§@¡ÓD@’[A@ø°@]à›@5X1@ ‚ê?·R?0m:½¸пhüÍ¿ÞÚ¥À&ÓêÀ_4§ÀŒÀ©`UÀÆíZÀ䓽Á4ºÁCpÁd±Á.…ôÁ=¹ÛÁLü>Á\BƒÁk—ßÁzï÷Á…$ãÁ+§Áˆ„ÄÁ€äFÁr’ÁcrÁTW3ÁE:hÁ6#^Á'1KÁXGÁ lÀõ–BÀØ8JÀ»?Àž<¸À»ñÀJ¿<À‘¿¹ó_¿‡0>@É?{ ‹?Ý×’@þD@JŒ@sŸ@Œt@œ”ü@ª}5@µ‘@@¾ d@Īë@ȇ@ÈkP@ÆÕŽ@ÂÓÊ@»ÚÈ@±—D@¤J@”è„@„A@c4@:°æ@ï?Á ?Bß´½/Ü¿V‡¿Ö/ÖÀ"…:À[0ÀŠPÀ§>ÀijÀÀâ‡Á- ÁÐÁ%èÁ-MuÁ<ŽÁKÑÁ[Ájh^ÁyÉ[Á„›ÌÁ ßÁˆ‚‚Á€äæÁr.ÁcjÞÁTW ÁEUVÁ6aûÁ'qÁ˜Á ¿ÙÀõþ(ÀØàÇÀ»ÔèÀžÍ™À‚]IÀL|\Àñr¿½"p¿$r|>+¦ý?s5â?Û®;@‘@I'‹@r¼ @ŒJ@œ£@ªéc@¶®@¾éQ@ÅEº@ÈÀÇ@ɨ—@Èb‘@ÄÇ£@½ºŠ@³ÏM@¦†­@–¿¬@†1 @gx±@>Ãc@´™?É€š?O´9=P¿HÝ0¿Ðs¿ÀŸYÀWóÒÀˆ¸{À¥Ø|ÀÂùæÀàxoÀþnÈÁCÈÁS#Á,vaÁ;¶4ÁKDÁZTžÁi¤‘Áxõ‰Á„&öÁGOÁˆ¦áÁ ŒÁrñÁcÕmÁTÏÊÁEÖSÁ6ÜÛÁ'æÆÁVÁ pŒÀ÷ŽKÀÚ;}À½«À  %Àƒº¬ÀNò„À4%¿Áì¿-H„>žV?iï¸?Öߎ@w¿@Fòò@oïZ@Šý'@›é‰@ªM›@µ²@¾yÞ@Ä´Ð@É Z@ÉþJ@É2Ð@ÆÕ@¾Bº@´Ø¿@¨F@˜;í@†ò¸@i]‰@@J@$æ?ÌÀ5?Wæ¦=fp?¿AÌC¿Ì¦ØÀzÒÀV9‹À‡†ãÀ¤“¢ÀÂ*ÀßăÀý|Á Ë÷ÁçXÁ,ºÁ;xÁJVÁY©Ái±ÁxkHÁƒé5Á†NÁˆï‘Á`°Ás¤ÙÁdЍÁU†>ÁF¡VÁ7ÄKÁ(çnÁ&ÝÁ qÀù‚:ÀÜ)À¿À¢:˜À…ÓíÀRÛöÀIi¿Ê:·¿>5ˆ=(?Zbˆ?Ïñ@:Z@B¨@k°@@ˆþ¢@™ön@¨aj@³ÐÔ@¼´A@Ã2–@Ç:v@È×ò@Èqå@Äþ@½Þd@´z«@¨• @˜q@†¡v@g½ß@@ Þ@=æ?Ìr ?U„µ=+Íu¿C¬™¿Í‡ ÀU6ÀUá³À‡ËºÀ¤¦ÄÀÁô0ÀßzÍÀýÆÁ …äÁ©ñÁ+á'Á;#ÁJSÁY“ÞÁhêÁxOæÁƒØ#ÁèêÁ‰OäÁ¾¾ÁtvšÁe‰”ÁV£OÁG½íÁ8ÝñÁ*Áa¾Á ¯sÀü ¨ÀÞþÀÁïÀ¥¦Àˆî°ÀYˆ½À!ž¨¿Öò&¿X$\¼ÎÚ?A”G?Â\õ@·L@<„@dßA@…°Î@–‘S@¤ú€@°ªy@¹¦±@¿}@Ã2­@ļU@Ä‘ë@Âm@¼£¯@³ó–@§õ|@–™K@„™v@cµ@Áh_ôÁYŒ#ÁJ½Á<£Á-elÁȵÁ/±Á½3ÀæžšÀÉÞ@À­dÙÀ‘"¥ÀjmäÀ3œH¿ú<¿‘ž«§­>åÌH?˜ÀË?õI!@%ó@N :@r‘ƒ@‰Ñ¦@˜V€@¤›@«Òf@°ù@´ ?@µ$@µ‰†@´fï@¯†@§xF@šw@Šùè@s>%@NÄ@' ?ùúW? ]E?H‘¿†!{¿ï~×À-®ÌÀeÉÀަYÀ«öÀȼÀå<ÁNÁ/8Á-Á.6…Á=@¶ÁLL£Á[`©ÁjŒeÁyÍÙÁ„ÿÁ’óÁ‹u4ÁƒùÁy Áj<+Á[}„ÁLËÖÁ>*HÁ/‚Á þÓÁ‰EÁÀësQÀÏ£À²¨bÀ–s£Àuò^À?/ØÀ ä…¿«;Ù¿ #V>h ?wJ?ÖÌ@7r@<¸Ÿ@`_^@€O!@ŽLü@™† @¡K²@¦ý@©0†@ª‹œ@ªóG@©¨j@¤±]@œz×@bó@yG@aöò@>Ç‚@Iå?Ûð?‚U >—C\¾ê£L¿ŸY@ÀŠäÀ9>ÀnÞÄÀ“›RÀ¯öÀÌ’Àé‹aÁNuÁøiÁ ßÁ/ÓhÁ>Î"ÁMÑ;Á\ñ„Ál)ÀÁ{c·Á…NÙÁ“ï}ÁŒr%Á„ù©Á{#ÁlmxÁ]¸üÁOÍÁ@v¾Á2oÁ#‹MÁ*ÁÅÎÀñRÀÔŽ3À¸^´Àœ¾YÀEÕÀLݯÀÜô¿Èûî¿J|þ½F?-ïC?¯ß6@GW@'[ç@I»©@ho@½¯@ŒÆ½@”i"@™.,@œ$3@|@ž!@œÖ×@—è@e]@„†1@m¸Œ@N1@+@æ?µ a?9î<´a¿:‹s¿¾ô8ÀüÌÀGÔÀ}‰qÀš-’Àµï›ÀÒI6Àï›Á ÁˆûÁ#-’Á2 ^ÁA ‘ÁP ÊÁ_Án‡Á}BÁ†=>Á•#õÁ²–Á†D£Á}ºÿÁoÁ``TÁQÉôÁC>¿Á4¹„Á&FÁùÁ ·CÀ÷2ÀÛ‚À¿AÀ£wÀˆ‡À[¿éÀ(Fç¿êþ¡¿ŠȾ°IÆ>·•š?‚à?Ô@^±@/{Ö@Lñ+@f¥Ñ@{­Ý@…—E@Šƒ¶@a€@ޏn@ª@Ž0@‰&@€Ék@kŸ@Rd1@54b@Y ?Û*2?†åò>ļ¾œÚ³¿…œ¿åõœÀ%jxÀX•ÇÀ†¬ÜÀ¢ÄÀ½ŽVÀÙ84Àõh“Á +÷Á¸¹Á&EÜÁ4âxÁC³ÇÁR§šÁa\Áp“ÁŒ“Á‡OïÁ–uÁ nÁ‡ž²Á€@ÁqäÀÁcMÒÁTºSÁFOŠÁ7üZÁ)°ÁnÁÁ :|Àþ! ÀâKGÀÇlÀ¬ïÀ‘HôÀnÑÀ;‘ŒÀ öæ¿´}&¿1f6¼J%…?$Ÿ?ñ?å)»@ÖÜ@.më@G:Ù@[’å@jÙ@sÿN@yµp@|¼@|²‚@zn@q:¿@aÅ/@KÏV@2Ø}@‘?óV.?§mw?('üv±N¿0]T¿³ùµÀcÀ:ôhÀmíÀ]ÀªÅ#ÀÆÚÀáÎÀýÔ„Á øÔÁI¬Á)Ê Á8N!ÁFÞEÁU®Ád‡¥Ás…ÌÁCÁˆÄ$Á˜ ´Á§ÇÁ‰LÁ÷ÓÁuY·ÁfÈðÁX8ýÁI½ÔÁ;z²Á-TœÁ<Á/ÐÁJÞÀë<ÍÀÏû˜À´÷\ÀšñÕÀ¢XÀQpÀ!¡¿ä! ¿‹JǾÜÇž>Sù?I ?§ž?ãÐø@ By@%h-@8Š;@Fô“@Pba@V+@X¨W@X b@T½‰@MÓ@>›y@(Éð@\?éŒç?­vë?U‡s>\Cá¾éb¿¿k}¿éÇ À#"ÀSoÀ‚C?À›òZÀ¶ŒÀÐJÈÀêå‘ÁUÿÁuQÁ”¸Á-Ë,Á‘ß0?Hê¯? ?Ô‡mÙ¾š οoO¿ËÃîÀ’1À?C0Àm~ÐÀp"À¨?¯ÀÁ÷ÍÀÜäÀö\Á¹Á€Á${°Á2€qÁ@šbÁNëçÁ]xcÁl0EÁzñ·Á„Û;ÁŒ=ÆÁ›µXÁ”`¦ÁÁ…çéÁ}j´Áo—Á`¤AÁRd|ÁDdcÁ6|ÆÁ(•)ÁºáÁ 5aÁ=Àæ¢ÀÌ(NÀ²š,Àš‡À‚ ”ÀVVKÀ)ÛàÀ(3¿¯&<¿K޳¾‡>hv?+¯j?Ї'?¶"?ÙP?ó/@¹¨@Ac@ oð@yL@«V?øìE?ÞÔ?·ô²?ˆÎù?&ö.>=êÞ¾¢:¯¿``Ÿ¿»ÓMÀ™oÀ1À]¯ûÀ…iÀ¸þÀ¶'ÛÀÎî×Àè¤-ÁGTÁzÁ‚Á)áXÁ7°‰ÁE²ÁSÓuÁbûÁp‹ Á.*Á†ó‹ÁŽQZÁé¥Á–£ÁbRÁˆ.ÙÁ%Ásº|ÁeŠCÁW“3ÁI§iÁ;»£Á-âhÁ hÁG Á1JÀòG~ÀØiPÀ¿î¿À¨OÀÀëÀu=!ÀJ­À Î ¿ö)â¿«¿W)ç¾»ˆš=ª×æ>î ƒ?K ?‡h?Ÿïï?°@?¸›`?»½?º}?²€á?¢°V?‰9?KaŽ>â=@=!ÿx¾Öß¿k»|¿¹þÛÀÛöÀ)V;ÀRÀöÀ}ªÂÀ•”NÀ¬»øÀÄÞJÀÝ>‡ÀõØÍÁàåÁÞÁ"Q‡Á/ÛÁ={ÁK'.ÁYsÁgSÁu®UÁ‚VÁ‰AÓÁ‘«Á :»Á˜þ Á‘ÔÛÁŠ»üÁƒ¦ÌÁy%iÁk Á]4nÁOUÁAŸdÁ4fÁ&¶”Á¢ÖÁ ¢5Àÿ~žÀæÔDÀÏ51À·²[À aØÀŠàÀkðBÀDÃ9Àìq¿ù‡û¿¸w=¿yl¤¿ ¨¾'ƒÞ> Î>ÄQ¥?ª?0å\?@$g?D Ô?A­?1Ò?¢>ÅÕ =æl¹¾[ⲿ´¿„/ÿÅÀÜÀ'îðÀNKuÀvçÀ]À¦[ìÀ¼êÙÀÔqZÀì_•ÁrµÁÏÁÊÁ)+Á68ÞÁC­FÁQcÆÁ_'4Ám ¦Á{&Á„°8Á‹Õ Á“²Á¢ÉFÁ›¨êÁ”’¹Á|ˆÁ†gÁ~´ÁpÎÁcäÁUf¾ÁGÄÁ:pÈÁ-uuÁ ‰OÁÌÖÁsÙÀön¼ÀÞÊŽÀÇÅ$À±«AÀœÉµÀˆ•Àj‚ÀEûqÀ$IÀû¿Ï¾¿šÍ¿\[…¿Ð¾£ú$¾ )×¼¨6%= ”=I¥=a½¼Ùèb¾µ+¾²£¿ß-¿fq¿ SA¿ÕïÀÀ ä‹À,V÷ÀOˆÀu*ÀŽ À¢ÓýÀ·ÿiÀÎQ´ÀäóøÀüÁ®Á p ÁÆúÁ#}Á0JãÁ=Y+ÁJ~ÁWàwÁe|ÁsB•Á€” Á‡¡Á޶¦Á•ÌÁ¥ƒEÁžo+Á—[ÿÁIâÁ‰CÞÁ‚ZžÁw¡Ái™Á[òvÁNž«ÁAkòÁ4wwÁ'ë±Á–ÁAÇÁ(ˆÀï íÀÙ2õÀö<À¯7•À›6JÀˆÿ7ÀnaÅÀNU3À/›Àyr¿òèG¿ÉxÛ¿£´Š¿†DË¿_œd¿Cñ¿4XÇ¿22ò¿5`׿FýM¿gΙ¿‹„G¿«\ä¿ÐÅÁ¿ü;ZÀJÃÀ5dÀUûàÀyVâÀŽÔõÀ¡èŸÀµêYÀÊ­OÀà= ÀöÆ8ÁÝØÁÃVÁå,Á+:Á7æQÁDž\ÁQªÁ^ø ÁlZÁyÅÒÁƒ³]ÁŠ£ÛÁ‘®±Á˜À×Á¨qxÁ¡e¹Áš[¿Á“a\ÁŒ|kÁ…¤“Á}¯§Áp4»ÁbåæÁU }ÁH¨ÒÁ<'ÎÁ/â•Á#—Á•-Á XÁÚEÀëÑoÀÖñ}ÀÂÏSÀ¯;WÀ­ÀŒzÀzÀ[8ªÀ@µSÀ'ÒbÀéwÀAQ¿çZw¿Òfb¿Äí¿¼3P¿ºÆ·¿¾³D¿Ç»¿×À3¿ï&CÀìïÀäçÀ-ÀE7ôÀa´ÜÀ€šTÀ‘´ÝÀ£lÆÀ¶Z<ÀÉÄ9ÀÞR¶ÀóU°Áh:ÁÙ Á[„Á'L¤Á3gÁ?ºÿÁLoÁY*ÞÁf,}Ás‚×Á€tKÁ‡'eÁì°Á”Ñ;Á›ËÁ«’*Á¤âÁœmÁ–­±ÁÈîÁˆô¦Á‚A[ÁwPöÁj9³Á]NýÁP§ÁDGvÁ8êÁ, OÁ mŒÁ?Á :qÀÿ1IÀêâóÀ×?ÁÀÄÆ°À³$ÃÀ¢­œÀ“ªÀ…AÿÀp?ŽÀXÁÀDoBÀ3ëéÀ%búÀtÀ+4À°À¿ÀóýÀoËÀŒ8À)ë‹À8¿ªÀJ7†À^ýªÀušÚÀ‡[éÀ—~­À§þ8À¹cKÀË£éÀÞ£¾ÀòVÁ›ËÁ9óÁ)TÁ$•ÍÁ0èÁ<>ÁH;$ÁT™¥ÁaL¶Án¿Á{ØÁ„!ÁŠÎyÁ‘‚-Á˜GºÁŸ$áÁ®ÌBÁ§Ù.Á èÛÁšÁ“6ïÁŒŒEÁ†RÁ oÁr"—ÁeQkÁXÀœÁL¡ÃÁ@²®Á4å¤Á)¯gÁ¡=Áô3Á ÉÀÿ›™Àì¾ÊÀÚ­‚ÀÊéÀ¹à—À«(ÀH±ÀTlÀ„ïvÀv¼›ÀfâÄÀYÀÀOýpÀImÀEº`ÀEPàÀGñÀL·xÀT”À_¿Àm»À}DÀ‰6{À”XVÀ a’À®¤ÚÀ¾ÍòÀÏdÀá~žÀóæ°Á¼ŸÁ ´Á)ŸÁ"Þ›Á-ö3Á9a8ÁDå‹ÁPïlÁ]E"Ái«DÁv;sÁµÁ‡ÿrÁŽ“™Á•.bÁ›Ý¨Á¢¦7Á²êÁ«5îÁ¤^ùÁž0Á–üÁp+Á‰ñÿÁƒ}¶Áz#HÁm’˜ÁaqnÁU“yÁIÇLÁ>ulÁ3WÁÁ(ÖÁJoÁ" Á ŽòÁ‚Àñ¿]Àá5ÀÑïÊÀÛãÀµî=À©±<ÀžDÀ• ÀÀeÀ‡XÑÀ‚›éÀ À{GDÀ{­À~'êÀqXÀ…VìÀŠY(ÀïÀ™CÀ£{À­ä'ÀºùÀǶûÀÖ«Àæ·\À÷Ì,Á‰ÁitÁWßÁ"ZÂÁ,û²Á7»ÝÁBñÁN`ÁYð•ÁeÿbÁr^Á~ćÁ…›ÁÁ‹ø’Á’{Á™5ÁŸ¤9Á¦HPÁµžÁ®×ÈÁ¨_Á¡{:Ášã…Á”]GÁímÁ‡•ºÁY*ÁvÁjµ‡Á^áÓÁS\íÁH>ãÁ=xÝÁ3åÁ(ãGÁÇÁì/Á ÷Á‰ÛÀùQrÀê'1ÀÜcÀÏ#îÀÃGmÀ¸âaÀ¯¾/À¨KDÀ¢rÀ§ãÀš²ÁÀ˜÷UÀ™9 Àš}À+áÀ ¿À¥Û&À¬<ÊÀ³öÀ½BçÀÇ­kÀÓ¬ÀáOvÀîé¦Àþ‘aÁ¤SÁwWÁŸŒÁ#7!Á-1€Á7aUÁB”ÁLéÁX8Ác‚ÈÁo<ÌÁ{8%ÁƒÀÁ‰ñ©Á'ÉÁ–~YÁœûÊÁ£“÷Áª/jÁ¹V£Á² èÁ«þ¨Á¥_ÁžÔõÁ˜n–Á’*¸Á‹ûÁ…ãgÁäÁt¢ÁhZqÁ]38ÁR†×ÁGóäÁ=®éÁ3ïþÁ*…jÁ!WÁß±Á¿Á ßÁ´$Àõ«ÖÀèû˜ÀÝíÀÓ+6ÀÊÀÃS¶À½0ÒÀ¹^–À¶G…À´ÕbÀ´ú`À¶mÿÀ¸õùÀ¼Ä{ÀÁÚ¡ÀÈ äÀÏ]*ÀØ\œÀâi•Àí{¢Àú¾ÁbÁ r9Á™,Áü­Á% Á.4ìÁ8¡ÁB:ÅÁLm`ÁWÁb!ÛÁm;²Áx¹ÀÁ‚JkÁˆ@—ÁŽV Á”ÁšÎ7Á¡rÁ§•EÁ®+Á½#ÍÁ¶„fÁ¯êÛÁ©hNÁ£·ÁœË‘Á–Á€ÁŠ‹mÁ„ŸÁ}Ž&ÁrRMÁgœEÁ]oÁR’]ÁHË1Á?aVÁ6@Á-DcÁ% ÑÁ4Á”‡Á "ÁÔJÁÀÀø5…ÀîDpÀæC~ÀÞ÷ÖÀÙ7ÔÀÕ2ÀÒ@«ÀÐß”ÀÑ-TÀÒÊ_ÀÕ[hÀÙjlÀÞ%0Àãî—Àë ÀóéçÀýÌôÁÆÁ d™ÁüàÁÖÁÈpÁ'ðžÁ0¢YÁ9¶VÁC"ÁM$'ÁWL`Áa‰ÁlSÌÁweÐÁB·Á‡®ÁŒúBÁ’ñ Á™?ÁŸ@Á¥‡MÁ«ÖëÁ²DÁÁÁººÁ´ Á­·õÁ§vÛÁ¡?¡Á›HÁ•+;ÁNÁ‰~ÁƒØ°Á|äöÁrLýÁgħÁ]ÆLÁTF+ÁJãÝÁA÷&Á9qÈÁ1j,Á)©Á"pÁŒÁÁ2@Á âWÁîJÁ ®ÀúÏ­ÀõoøÀñC‚Àîª6ÀíkÀífiÀï3}ÀñØ8Àö Àú·nÁ ¦Á™ýÁ»ÇÁ ˜ÇÁÆ2Áz¾ÁÃÁ$¶÷Á,6yÁ4LÁ<ÁE‡6ÁN©çÁXFŒÁbh ÁlŽVÁväïÁ€ãÉÁ†n3ÁŒqÁ‘ÊãÁ—¾ÕÁ·IÁ£ÈÁ©ýÄÁ°DþÁ¶špÁÅCæÁ¾ÏåÁ¸yQÁ².ýÁ«ï?Á¥ÐöÁŸÝ>Áš íÁ”CoÁŽ›ÁÁ‰)OÁƒÑäÁ}lÁs~ÁiKíÁ_ÇßÁVÍÙÁN&ÍÁE·¿Á=ø¼Á6c#Á/mxÁ(‘Á"ˆ\Á¼2Á [ÁÈRÁ÷tÁ wÁàsÁÒ‰Á–Á‘Áï…ÁæHÁE+Á X_Á ²ÁzÑÁÓnÁ³SÁK1Áz£Á$ÏÞÁ+!üÁ1ÄBÁ8ØÁ@ÀxÁHѼÁQ\ƒÁZzêÁcÀèÁmgÁw·Á€ü~Á†3ÌÁ‹©¢Á‘5ÕÁ–Õ¨ÁœœvÁ¢wÁ¨Š<Á®•PÁ´¾«Á»õÁÉ“ ÁÃ>ÝÁ¼ñ‘Á¶² Á°–kÁª¢ÝÁ¤Ò’ÁŸùÁ™`Á“ê¬ÁŽƒ–Á‰9#Á„+%Á~¢Át×ãÁk©ÈÁcõÁZoèÁRqsÁJÏËÁCŠðÁ<.Á68Á0"DÁ*…ïÁ%oÁ îöÁ"9ÁÐ0Á³Á3¦ÁíÁ†ÛÁ| ÁzŸÁâÁìûÁ)ÜÁåeÁ ³Á#òôÁ(Á-2Á2lÁ8LtÁ>ájÁE¦oÁMR7ÁUJwÁ]j ÁfKîÁo‰ÓÁxéÁp™Á†“jÁ‹¸3ÁöSÁ–o¡Áœ ;Á¡¬Á§oÁ­\3Á³_^Á¹f>Á¿…!ÁÎhÁǼLÁÁ„øÁ»l<Áµy1Á¯¢èÁ©ÒÆÁ¤&ÌÁž­,Á™EBÁ“íÿÁŽÔPÁ‰ðØÁ…³Á€_ÀÁwó9ÁoZPÁg×Á_TOÁWãÁPÁÃÁIûyÁC® Á=ÓÕÁ8‚tÁ3rÁ/8mÁ+]¶Á(K…Á%š¬Á#ÑrÁ"†ÙÁ"^Á"ãÁ#pÁ$…"Á&š0Á(Ã;Á+t€Á.pnÁ2C~Á62Á;£Á@Q¤ÁEÕPÁL=QÁRÊbÁZoÁañÁiçTÁrSËÁ{q&Á‚YEÁ‡JÁŒ,âÁ‘PüÁ–ufÁ›½LÁ¡>’Á¦àÁ¬‚¦Á²CÆÁ¸/ÚÁ¾5ßÁÄ<ÓÁÒ‘ÁÌdìÁÆL‹ÁÀUnÁº|ÉÁ´¬4Á®üŸÁ©|æÁ¤Áž¸AÁ™ Á”£yÁȯÁ‹BÁ†}Á‚$Á{îùÁsòûÁlLÎÁeXÁ^ ÁW˜7ÁQWpÁK¿bÁF‚/ÁAŸ¿Á=ƒØÁ9¨YÁ6É+Á4'AÁ2{ÈÁ16Á0ΨÁ0°ÐÁ1¶èÁ30ˆÁ5:xÁ7b^Á:ÈÁ<÷GÁ@ªEÁD”èÁI&[ÁNTåÁS¯ÒÁYÉ$Á`G¤ÁgqÁnÇæÁv¹´Á~Ë\ÁƒÂÎÁˆ`¨ÁBÁ‘á,Á–úÁœÂÁ¡B©Á¦•@Á¬îÁ±¾ˆÁ·aÁÁ½$ÕÁÃXÁÉ\Á×H ÁÑ-¦ÁË2zÁÅW(Á¿(Á¹á Á´ZYÁ®ð}Á©‘0Á¤^æÁŸ^^Áš|¬Á•·“Á‘ÙÁŒ ]Áˆc]Á„`¿Á€m¡Áyp¢ÁrG«Ák›UÁe6DÁ_ÁYÂ;ÁT†ÉÁOç¼ÁKÕÁH¡ÁEMáÁBºôÁA&ºÁ?ç2Á?Š…Á?qoÁ@o®ÁBØÁCúôÁF[ÁHÀNÁK’òÁOÁS ÁWfiÁ\XRÁaŸ¹ÁgtˆÁmÕçÁt„àÁ{Â`ÁÐÁ…Ï5Á‰ú¤ÁŽt»Á“ÂÁ—ǯÁœ¶ùÁ¡ÌˆÁ¦ï*Á¬ |Á±|;Á·þÁ¼ªÁÂMÉÁÈ;ÁÍüãÁç(°Áá03ÁÛXÏÁÕ¢ÁÏ÷uÁÊSÁÄÒÝÁ¿~ïÁºEôÁµgÁ°ÍÁ«: Á¦–Á¡úƒÁ“$Á™l¤Á•npÁ‘¤ÁþÀÁŠðÁ‡„*Á„›¥Áò,Á¨Áz°žÁvÎÁs?RÁpGÜÁnÂÁlãÁj{ÅÁi^¥Áh¤ Áh‚pÁhÊäÁi…›Ájæ^Álž"Ánø&Áq‚ðÁtÌ»ÁxS«Á|eÁ€l¤Á‚æÿÁ…—½Áˆi7Á‹ƒVÁŽÈQÁ’MùÁ–yÁ™ÔýÁö=Á¢GÁ¦´<Á«WüÁ°0ÇÁµ-BÁº1šÁ¿QäÁÄ¢·ÁÊ ÓÁÏ»˜ÁÕ^LÁÛÁâe)ÁÜRïÁÖYÔÁЃKÁÊÏéÁÅ%îÁ¿ÉÁºÁ´µLÁ¯€ÔÁªW‘Á¥^wÁ Ÿ"Á›ôˆÁ—_qÁ“Á OÁ‹#vÁ‡qžÁƒá€Á€­TÁ{v°Áuú9ÁpøŠÁl‡šÁh`ÝÁdÜïÁaÐHÁ_~<Á]xÁ[Â^ÁZ¯ÉÁYÝäÁY–¾ÁYôÁZª­Á\51Á^šÁ`l=ÁcÁf‚fÁj/ÁnKÔÁrºÊÁwècÁ}H£Á›½Á„ÚßÁˆ9EÁ‹Ú}Áš^Á“ŸmÁ—ÖyÁœ(ŒÁ º/Á¥'ÁªŠIÁ¯–âÁ´´ÎÁ¹ý}Á¿sÁÅzÁÊ›¾ÁÐPqÁÖ*¼ÁÝ­EÁ×ZÁуUÁËœÁÅ»ˆÁÀŽÁºWÁ´²ÑÁ¯:ˆÁ©õ‰Á¤ÌÒÁŸ¯QÁšÊ/Á– ÒÁ‘XLÁŒØ®Áˆ«#Á„»íÁ€æÈÁz¡ÃÁsò Ám¿{ÁhHÁbëfÁ^_šÁZ)ÁVŠ3ÁSŽùÁPõ°ÁNåÁM9áÁL/…ÁK6çÁJƯÁK)´ÁKéÉÁM‡,ÁOwÚÁQàTÁTÊ"ÁX8Á\ Á`JˆÁdÛ´Áj&ÃÁo›ºÁuÝFÁ|sÃÁÀ›Á…i—Á‰TÃÁ‚Á‘ºJÁ–0ÁšîÒÁŸìÅÁ¤üyÁªeÁ¯aCÁ´Ê„ÁºWïÁ¿étÁÅšOÁËröÁÑpÁÙdÁÒÙÁ̸ÖÁÆ· ÁÀÏöÁºýBÁµDvÁ¯“nÁ©òäÁ¤‚³ÁŸFúÁšÁ•Á?2Á‹ÙÁ†Ò”Á‚s®Á|É>ÁtÞjÁm†.ÁfÍ#Á`I…ÁZK<ÁUWÁPNAÁL(ŽÁHW ÁEnóÁBƒÁ@eÁ>ä/Á=ÄoÁ<¶>Á<(lÁàÎÁ@ìÁÁCXöÁF|ÍÁIôÁNŠÁR[ÁWF<Á\ÑÁb<íÁh£[ÁoU¶Áv £Á~+“Áƒ3Á‡mäÁ‹ÄüÁiêÁ•T«ÁšbÁŸ€Á¤ÇØÁª$ªÁ¯­PÁµCÛÁºöXÁÀÌÁÆÉqÁÌéZÁÔ±‡ÁÎU°ÁÈuÁÁï¦Á»ð¾Á¶tÁ°@ÅÁªƒÁ¤Ü‘ÁŸFùÁ™à¶Á”¤mÁsîÁŠx³Á…¸üÁFÁxàÚÁpnWÁhKØÁ`aÁY¯lÁS!#ÁLÌ7ÁGqYÁB’Á>KãÁ:iXÁ7MÁ4aUÁ21Á0–½Á/YYÁ.RÂÁ-ȇÁ.3¢Á/ ‡Á0d”Á2{²Á4í¥Á8/¬Á;×{Á@öÁD¥´ÁIÊ’ÁO,TÁU-êÁ[‚+ÁbˆƒÁjáÁqéyÁzgâÁ~çÁ†(ÁŠÑ”ÁÈ Á”å©Áš.ÁŸ‚ Á¥±Áª¢VÁ°`¥Á¶9Á¼2CÁÂOyÁÈz³ÁÐ_¨ÁÉï‚ÁجÁ½Z Á·6ÂÁ±7pÁ«]@Á¥‰eÁŸÎ¢Áš5{Á”§VÁNäÁŠ}Á„ãÁøpÁvƒ+Ám4ëÁdqPÁ\$ÁSýyÁL¶ÔÁF®Á?¦êÁ9þºÁ5òÁ0zÁ,¶Á)0îÁ&M{Á#óÁ"SÁ ñwÁ "ÑÁ·Á '¨Á õ Á".rÁ$CæÁ&ÈSÁ*·Á-áwÁ2-ÉÁ7IÁìÁŠMhÁ•±Á”äøÁš[qÁ ŽÁ¥ÑÁ«ª‡Á± Á·¶;Á½á+ÁÄpÁÌ0.ÁÅ­Á¿6+Á¸ÝÞÁ²¦ Á¬ŒÁ¦‘˜Á °ŽÁšÜêÁ•'ŒÁˆÁŠ pÁ„¾Á4Átá5ÁkÆÁaœmÁX­çÁPÏÁGݰÁ@0ÏÁ9^Á2–Á,àtÁ'›¢Á"æ4ÁÂÁD¿ÁOTÁ mÁE¦ÁÆ3Á"«ÁиÁNÁ sÁU¯ÁUÁöKÁ"ÌÁ {Á$†¿Á)‹ÝÁ/*Á5Á;l•ÁB` ÁJ»ÁQÉÁZ‰ÁcÁlPGÁu­öÁZÁ…•ÁŠ_ ÁÊ>Á•pƒÁ›DhÁ¡–Á§³Á­ Á³JýÁ¹‰/Á¿ÙìÁÈÁÁ”5Á» tÁ´BÁ®1°Á§÷ëÁ¡åëÁ›óöÁ–ÑÁ0ØÁŠ—Á„í|Á~é"ÁtoóÁj­Á`)ÁV)¸ÁLòÕÁDS´Á;Ø™Á4íÁ,¥•Á%®”Áß"ÁXæÁZjÁJ¨Á ™ÝÁ q¼Á7<ÁU§ÁýTÁ%ÖÁñÂÁtšÁSøÁÍÁÃXÁ Á´®ÁŽLÁ'.Á,²Á"8Á(7 Á.÷ôÁ6FÁ=øÚÁEÕIÁNŒYÁWÙ Áa/µÁjíÃÁuLuÁðÁ…XkÁŠõ}Á¿¨Á–’"ÁœvúÁ¢ˆ¼Á¨ÁûÁ¯}ÁµoÁ»áFÁÄ7Á½–SÁ·RÁ°|pÁ©þÁ£›’Á^³Á—JºÁ‘VÞÁ‹g¼Á…‡šÁ¿qÁtƒÁiüÁ_w‚ÁU&7ÁK;GÁAŒeÁ8©•Á0 ¸Á'äÕÁ ‰™ÁRbÁü%Á TŠÁ ÁîNÁ5£Àùø¬Àõ@_Àñ_DÀîœÀìÆ¤Àì>Àí68ÀïhdÀòþÀöÄSÀü\¨Á™Áx2Á áÁMÛÁÁ·ôÁ"›CÁ*7“Á21Á:bóÁCprÁLÄ©ÁV|qÁ`¼ÎÁkRŒÁv BÁ€œ5Á†YgÁŒÃÁ‘ü7Á˜ PÁžJiÁ¤©²Á«qÁ±‡ªÁ¸ @ÁÀo¨Á¹º•Á³[Á¬{Á¥îvÁŸwéÁ™ÉÁ’ÜUÁŒ¹AÁ†ºÛÁ€ÍµÁuïÁj±óÁ_éÿÁU<ÄÁJªÁ@‚íÁ6ÎÒÁ-o±Á$ÁÌÁ6pÁ†+Á 4MÁ—\Áƒ¿ÀöˆöÀíxñÀåÎ+À߯—ÀÚ'sÀÖuÎÀÓH¢ÀÑôÀÑqÈÀѵÅÀÔL À׿ÀÜÀáíhÀèÿ”ÀñAµÀú®üÁÐçÁ¶”ÁYvÁ€»ÁyÿÁ&˜Á/TgÁ8[£ÁB ÆÁLOtÁV¶¥Áai«Ál—’Áx ÍÁÅ…Á‡£ÉÁ²¥Á“ðÇÁšVtÁ ÅÁ§3âÁ­´Á´SÁ¼Ó Áµþ!Á¯BrÁ¨Ÿ=Á¡ÿ­Á›iXÁ”õUÁŽ¥ÚÁˆd¢Á‚/€ÁxC¥Ál‹¡Áa(ÁUð ÁK%cÁ@}¸Á6FÁ,RÓÁ"¸•Á·Á^ÁÌ5ÁDÀô—*ÀèšòÀÝÉ5ÀÔE’ÀË×ÛÀÅkªÀ¿³À»ÚAÀ¸îŠÀ·KÀ·7rÀ·‰OÀ¹ìÀ½ˆÀÁE}ÀǦXÀÏAÀ× êÀáÌbÀìù“ÀùvQÁ\€Á äDÁã·ÁvÁ$NkÁ-²’Á7ä&ÁB7FÁLÉdÁWöàÁch­ÁníŒÁzËŠÁƒ~ÈÁ‰º­Á®Á–‹ÁœúÁ£ÇÁª$&Á°åÁ¹rÖÁ²…^Á«¨­Á¤äUÁžÀÆ@˜À¹-$À¬ÞôÀ¢ýìÀ™þñÀ’üïÀV?ÀˆsÀ…fÀ„JÀƒîôÀ…?sÀ‡IHÀжlÀ7À•RGÀœÊEÀ¥ìfÀ°Ž¹À¼}}ÀÊ•SÀÙD ÀèŸÀú(bÁ,£ÁïzÁøÅÁ$^¬Á/NÁ:´›ÁF?”ÁR#FÁ^pÙÁjÍ"Áwj¬Á‚+ÍÁˆ¹çÁP&Á–}ÁœÄ«Á£‰)ÁªbzÁ³õÁ¬žÁ¤ö¢ÁžÁ—,)Áo¼Á‰¸ÛÁƒjÁx¿½Ák¾ÆÁ_ÌÁR¨_ÁFD4Á:&ûÁ.§~Á#t­ÁHÌÁ `@ÁX·ÀómÂÀà?®ÀÎðþÀ¾íåÀ¯ÈÀ¢_|À•u/À‹Z%À‚SÝÀu†‘Àh«cÀ`ÍÀYÖÀV„ ÀV’÷ÀYUÀ\$zÀd`ÀlÂÔÀz"%À…-ÀŽ´¦À™^uÀ¥…À´)ÀÃF?ÀÓÁEÀå$™Àø`$Á^Á“õÁ ,Á&¶hÁ2iÁ=èÉÁJ7_ÁV™ƒÁc/ÁÁp+àÁ}I%Á…?ßÁ‹þ¢Á’ÌŽÁ™œÁÁ ~¹Á§ylÁ°<]Á©ŠÁ¡÷SÁšèÚÁ“ïVÁ %Á†E„ÁyÁq¡êÁd?¡ÁW3‚ÁJ“iÁ>*OÁ1Æ Á%£`Á.½Á«Á&ÈÀó "ÀßšúÀÌKÀ¹ä“À©¾ÉÀ™ÏÀŒ¹À~ÕÀhÖrÀV)«ÀFm#À9˜üÀ/¶À(ï$À&{À&,À(­À,“*À3XiÀ<´ÀI¬aÀ\ÏÀp'¶Àƒ>0ÀŸÑÀž3åÀ­·À¿AÐÀÑÅ—ÀåsˆÀù²ÕÁÔ'ÁòÁ7ñÁ)ì'Á6)yÁB™ÎÁO[‡Á\WÕÁiqÁv®)Á‚)ÁˆãÕÁ·µÁ–¥+Á¦·Á¤©•Á­kûÁ¦@ÁŸAÁ—ðÇÁãzÁ‰íÁƒˆÁxP<ÁjÎIÁ]]ÁPÇÁC }Á6dùÁ)èOÁlJÁSdÁ{ÀöÀà¶ÀËÒÀ¸†À¥‡éÀ•#ÉÀ…yÀm{¤ÀS_×À<º´À)'éÀFLÀ SÀm ¿ôb#¿íw¿ì00¿ñÒc¿úSËÀTÀƒgÀuûÀ-Ç ÀCÿÀ[”’ÀuãÀ‰ºnÀ™î¡À¬lÀ¿N_ÀÒ´ÒÀèUÀþÔSÁ ×åÁJ&Á"/ÚÁ.¶°Á;¤ÓÁH›ÏÁUªaÁbñtÁpvÁ}þ/Á…ÙDÁŒÒrÁ“Ü9ÁšæŒÁ¡ùªÁª¬gÁ£sðÁœKÁ•'ÁŽPÁ†í4Áà{Ár Ád9?ÁV‹NÁI/ÁÁ< ÒÁ.÷†Á"GXÁÏ$Á e{Àû*ÀäŒ*ÀÎL,À¸‰*À¤íUÀ‘Š1À€|µÀ`ñZÀCÍÚÀ(ÓÀ‰´¿û«¿Ù8D¿½¢þ¿¨†]¿˜Çú¿’4û¿‘õ ¿•©I¿ž}¿ª…·¿Â•¿à„kÀ’ÀYÆÀ2[ÐÀN+ºÀm|OÀ†àµÀ™ªÂÀ­|ÍÀÁûgÀ×¶èÀîƒÁíØÁ¹ÍÁ&Á(ñÁ4èFÁAäÁO7PÁ\Ï,Áj}óÁx:ìÁƒ_ÁŠPÁ‘(Á˜F¼ÁŸu6Á¨5Á ã Á™Ÿ7Á’mºÁ‹GøÁ„%QÁz rÁk÷_Á^fÁPRrÁB©Á5CUÁ(ZÁóbÁ;ÜÁÂÏÀêá+ÀÓÏYÀ½<­À¦é•À’®ÔÀ~ ÀZ JÀ9ùÀ®»À!¥¿ÑÃõ¿¦¶ð¿„‡€¿NZÈ¿õ¿àS¾ähš¾åB¾ó´·¿×+¿% @¿V¦¿‹ˆ×¿´GŸ¿ã À æÀ(+ ÀHBdÀkW˜Àˆ¸"ÀœÑ¹À²ÿÀÈ7 ÀßlÀöïØÁ¸ŒÁ‘åÁ!y²Á.sÎÁ;ͧÁId„ÁWKÁdÌÁÁrÃ2Á€fŠÁ‡yÏÁŽ¢ÑÁ•ßVÁ'ØÁ¥×Áž‚ÓÁ—5ÿÁéªÁˆ¥gÁu¥ÁtŸ¹Áf\7ÁX2SÁJKTÁ<®~Á/&4Á!£qÁh ÁhŒÀõ€äÀÜ5„ÀûþÀ¬êMÀ–N›À€©£ÀZcðÀ47ÀÑñ¿èȵ¿±¤¿¿/п.$¾Ìô½¾'&n<·=í>ý¥>M]>]„?>@-> ÿZ>ïî„?&ž?EÍÇ?T$»?YqI?Q‰?Ah ?À7>ʉ=¯½¾x“¿"£Ž¿Š®Ã¿È¶ÀÞ À+ìEÀT ÞÀ}5‡À”‡5À«úbÀÃû@ÀÜóaÀögÁ©ÁgeÁ"ÓÂÁ0Ž*Á>†”ÁLêÁZÁ‰ÁißÁwSÇÁ‚ßÁŠ(—Á‘ÇÁ˜æ»Á¡™óÁš/üÁ’ÆRÁ‹]°Á„ZÁyañÁjϤÁ\]öÁNZÁ?߬Á1²Á#¡þÁñÁƒÀö;TÀÛË:ÀÁ£tÀ¨qØÀ"VÀp°ÀDr©ÀF¿ä%«¿šo¿3͹¾ôä> ÿ­>ú‚Q?Ik(?…¿?%?®wÖ?¶§?·ÇJ?µb2?«Ò”?—˜½?lË?ì¿>„X¾±ô¿ǰ¿Ž2@¿Ò6TÀOaÀ8¡mÀbšÀ‡ŽsÀŸ©À·í¢ÀÐñÀëEÁ½¸Á#ÁÐLÁ+ˤÁ9È!ÁGå\ÁVEÁd½Ás5(Á€ÛÁˆ,tÁŽ¢Á—àÁŸ»ZÁ˜E)ÁÔÐÁ‰hÉÁüÁÁu!ÔÁfb#ÁWÐÁIuvÁ;6LÁ,ø±ÁÒÁæ³Á7—ÀëXtÀÐfâÀ¶P+Àœ°ÀƒÆÄÀVµ‹À(ðå¿ùy¿¨<¿9]>¾Y>>ŠãÎ?+u›éh¾$È¿,OT¿œˆö¿è×ùÀˆ‡ÀI½Àw¦JÀ“Õ[À¬2OÀÆ"±Àà‘‹Àû—Á ?óÁ9HÁ'-¯Á5NKÁC¶1ÁR.îÁ`±ŒÁoNbÁ}ø]Á†ZwÁÃÃÁ•6nÁž«Á–~yÁéÁ‡ªÁ€àÁqTDÁb‹ëÁSáòÁE]Á7 Á(­EÁY Á A Àüö¸ÀáŒÝÀÆ\À¬RÀ’6\Àq*]À@¹Àgè¿Æóô¿g*¾™àè>tË?7 í?’ï?Áõ*?éÛà@ß~@ÇJ@ 7@]@ ·—@„ð@|Ó@ M™?ðÆÎ?Ä)?“9³?;$>y|ê¾_=¿WéB¿º´À½ÜÀ1\6À`»1ÀˆÂ%À¢IòÀ¼KÉÀÖs†Àñ®yÁ­àÁ•ZÁ"»=Á10AÁ?ÎÁNoìÁ]ÒÁkµ6ÁzkEÁ„—×ÁŒ ìÁ“Š Áœ\Á”Ò›ÁH·Á…±Á|–nÁm¿ãÁ^öGÁP<>ÁAœ Á33—Á$à3ÁžÁEÀôÀØÿqÀ½–À¢»¦ÀˆÐåÀ]éÀ+5Y¿÷k¿šAX¿ Úð=žÒZ?JU?Õ?Çza?øÉs@íˆ@! Œ@.¥ö@7ð@=Ø@?-@;êj@3r@$ë(@5C?ø“@?Å¡Õ?Žò«?£=×¾ð”Æ¿s©¿àî«ÀØ…ÀMŸÀ}µÀ˜Ü\À³’ÀÎÀéàÁ¦‡Á‰Á×/Á-H‘Á;å;ÁJŸ8ÁY\éÁhÁÁvïÚÁ‚óýÁŠwÁ‘ú2ÁšÝ8Á“SRÁ‹Î’Á„EºÁy}:Áj‡QÁ[±õÁMûÁ>oiÁ/ØòÁ!OÈÁõÁ´¡ÀíBLÀÑŒ†À¶% ÀšÛÀ€§WÀM(”ÀU!¿ÖOk¿mDs¾ƒ00>Êð¢?u¨‹?»–?õ×T@ @)e^@:ëb@HìÙ@RI@WЮ@YÇ=@UÈð@K°´@>ö@*ê÷@£è?õÖx?¼M=?{V>æ ô¾ ¡"¿C½Ù¿·-À KÀ:)5ÀkÛÀϹÀª`ÉÀÆ#ÀáëÏÀý¼ŽÁ áÅÁ:[Á)Õ”Á8yÈÁG$ÅÁUâ‚ÁdÆ[ÁsÇGÁgEÁˆêçÁq5Á™h’Á‘ÜZÁŠYÄÁ‚Ù¹Áv¨GÁg§ ÁXÅiÁJ Á;k©Á,ÎdÁ4äÁÀÐÁŠ“Àæó÷ÀÊÚ»À¯_×À”B-Às."À?œ"À ƒÙ¿¸ñ¾¿2˜–¼e[Å?#×p?¾C?àý[@I@(âw@?õÒ@QÖ«@_z~@i"à@o H@o»É@lI@c]C@Ti‡@A,ö@*o@Œ?袎?§þ¹?D®÷>:š¾ö…~¿•0e¿ñ=ÔÀ)Ú|À\¦KÀˆV8À£@À¾yÀÚ…ÔÀö”ËÁ Ž¥Á$œÁ&ÁµÁ5S?ÁCóëÁRÀÁa°ÍÁp¼qÁÊWÁ‡lÁŽõ½Á˜‰Áv[Áˆí¼Án ÁsØøÁdÕìÁUà’ÁGUÁ8r{Á)á³ÁcÁ ÷Àýz‘Àá7ÀÄõÂÀ©?>ÀŽj¹Àg¬À3¾oÀ›f¿ TÓ¿0>E!Ì?Z¿­?» ?ÿär@|@: @RV@fÍ@t‹í@|Öî@€ø‚@]á@~¾©@u>3@g÷Ù@TË@>¸-@$ ¥@™r?Îíô?†É…>é%§¾ZO8¿j_¿Ó\ÀSÀMÅbÀ€@Àœ4“À·ÏCÀÓ…éÀïÛÆÁvÁ*Á#§ÆÁ2OîÁA%UÁPFÁ_ßÁn CÁ} ºÁ†Á¬<Á–À5Á&sÁ‡˜uÁ€OÁqN@ÁbsiÁS~4ÁD’ÑÁ5Ô…Á'O<Áñ1Á ‡ÜÀø7žÀÛˆLÀ¿ÆÀ¤GùÀˆäyÀ\Å À(¤æ¿ëYj¿‰A¾§ Ü>¹ï?†Ú?Õ…@%%@,ÿ2@I3Ç@aáG@v³Ú@‚¹@‡¦7@‰‚á@‰Hè@‡é@‚ÞÌ@xÝE@f`@P(ä@6à@H?ï@z?¦$e?.|ĤÁM âÁ\€yÁkÁz>Á„éôÁŒ‡tÁ•»ºÁŽ"ºÁ†Á~Ánþ%Á`lÁQ,ÁBE¶Á3n³Á$ÉCÁ[)ÁýRÀó>ôÀÖ‡HÀº»ÀžÊ¢À„áÀR‚¨ÀCü¿Õè#¿f& ¾$ôh? ¿ ?œ2!?ìÎ@EŽ@: ÷@V2@o2@‚$ì@‰×@ŽÏs@ßÙ@›)@Žiw@Š4¸@„8@u£â@_ @Då‚@&à¦@â9?¾´?_Ââ>> z¿Ó³¿£ŸóÀsÞÀ7&Àkw“À‘gÀ­ ‡ÀÉ 5ÀåJÁ.&ÁÜÁ‹õÁ-JèÁ<ÅÁJóìÁYõ4Ái`ÁxUÓÁƒÌ¯Á‹nuÁ”ÌÎÁ9yÁ…¬ÏÁ|@PÁm&ÊÁ^®ÁOþÁ@4€Á1|ÐÁ"â ÁIÜÁ°þÀÀÒbeÀ¶T{Àš`À~­<ÀHÁsÀØÃ¿Âò¿>¥¥:å I?5É?±Fó@‚Ë@%2@Ewù@añ=@zÝó@‡Ù@²p@””‰@–ÿW@–˜@”„œ@[I@Šb…@‚ @k=b@Py1@1ÖE@é?Óc?wö>§´¾Àb¿‘´¿õƒÀ-ÖòÀb5ÀŒg@À¨^–ÀÄ\ ÀàæÐÀþ+·Á ÃéÁqÿÁ+)þÁ9ñ•ÁHä½ÁWûÔÁg)ÁvWXÁ‚Ã¥ÁŠ_Á”œÁŒ_êÁ„ÉRÁz}¾Áku†Á\xáÁM‰yÁ>œÁ/ɼÁ!"ÞÁ‚ßÁâàÀê¯æÀÎ\½À²kgÀ–{°Àv_ À@0À 1/¿±jö¿ë&> ?YÍ9?Äa@ Æ·@.rl@NþÐ@km@‚uQ@Œ’Õ@”@Î@™_V@œc@›’Ì@™þå@–#­@ j@‡ç@u/î@Yk @:æ@ød?ãJg?©m>䳦¾„‘ï¿‚ ô¿ä£øÀ%ð»ÀZAÀˆ|èÀ¤‘À¿ë`ÀܱºÀúnÁ ÆŸÁ€ Á)9sÁ8ëÁG³ÁVÍÁeNuÁt…ÚÁßÁ‰|3Á“s5Á‹Ñ=Á„3ËÁyD­Áj=ÜÁ[I¥ÁLYeÁ=i%Á.yÁžÁMÁ›_ÀèvjÀËÍeÀ¯‹ÙÀ“„­Àp,¼À;4ÀɆ¿¤j¿ªp>z¢/?tƒ´?Т@ý@5ù´@V‹2@s!#@†&@c@˜2@Í;@ !X@ .@žLô@šßÀ@”Sò@‹0@}Ô @ax@B@ù²?ð¥@?ž)Ÿ?¥¾ 5¿g;¹¿ÔëãÀ‡ÀSyÀ„§À FÈÀ¼µ³ÀÙ| ÀöKÁ ¹ ÁõÁ'xÛÁ6cðÁEnÃÁT‡þÁc­(ÁráÁ âÁˆ®þÁ“0Á‹dqÁƒÆÕÁxjpÁiciÁZfëÁKnhÁ<†ÖÁ-½äÁ÷ÁLÓÁÑŒÀæ¹½ÀÉéðÀ­ÅÀ‘ïuÀl4RÀ6X²ÀŸ'¿œZ£¾á‘Ç>œ/÷?‚OÉ?Û1Â@t¼@:Ú~@\IW@yÞ@‰Q@“iç@›n(@ ð:@£À•@£˜’@¡Æ¼@žE‡@—Ù²@ލv@‚ûM@hAR@H— @$Ðí?ýdÀ?ªßñ?&ƒï½ƒú¿LµÎ¿Éj‹Àõ8ÀL×-Àr=À%ôÀ¹WRÀÖ%ÀóMJÁföÁ'†Á&6Á4ð°ÁDÁS”Áb6†Áq\®Á€MMÁ‡ôœÁ’±jÁ‹²ÁƒzÁwÍ.ÁhÁZÁY×ËÁJüÁ< ×Á-F ÁlAÁ¶µÁ>˜Àå­ÀÈû9À¬¬ìÀ‘(>ÀkYÀ5#ÀÝ¿™ñù¾×D&>¨fu?†{5?à2ž@*3@?|‹@_â±@}ãJ@‹Ó@•»¿@|õ@£ˆå@¦H?@¦d=@¤“[@¡"G@š¾·@‘·%@…ªW@m’\@M1R@+/g@^™?¶RÂ?=z<ÈÌ¿5¾šVÀ#gÀG²—À}¸íÀš«µÀ· °ÀÓ|ëÀðx’Á÷(ÁÒ1Á$ºÿÁ3©*ÁBµˆÁQÖÁ`÷´Áp+ÑÁn.Á‡XLÁ’•ZÁ‹µÁƒwQÁwÑýÁh·ÿÁY¸0ÁJ×ÁÁ<iÁ-@ìÁ|‡ÁØäÁA ÀåÉdÀÉHÂÀ¬åBÀ‘ÄÀkмÀ5VÀÄ¿šÑľÙÒ">¤²·?†ù?à@8ú@@Wû@bQ”@€Gg@7@—‰@žó¿@¥(@¨Æ@¨…¡@§ ¡@£Qô@ @“·1@‡Õš@r:¾@RYÁ@0E@ ܹ?Á=_?SSú=Õ9›¿%j¿·bïÀ‰ÿÀCÖÀyÖÝÀ˜¦LÀ´æ³ÀÑ‹eÀî¬Áõ#ÁÊèÁ#´ìÁ2ž²ÁACÁP˜ŒÁ_ÀXÁoáÁ~K7Á†ÌoÁ’”dÁ‹Áƒu×Áwã Áhê´ÁY÷ÀÁK…Á<=Á-kÇÁ»ÁÁ-žÁ§®ÀæR@ÀÉâ§À­»À‘Ä]ÀlÙÜÀ7>ÀMƒ¿®¾èáÁ>œ!?„4Ç?Ýa¸@©»@?·@bB@€„m@HŽ@—‚@Ÿ«û@¥¸‚@¨Î@©¯@¨v–@¥+@žÕÔ@•–Ù@Š­@v8@VHj@3…«@ ‰?ÉW«?aR#>&+–¿0ò¿® xÀ ùÂÀ@/ïÀvçîÀ—*éÀ³lÀÐ)7ÀíHPÁ4)ÁÙ¤Á"¾:Á1Æ×Á@ÖÁOåÞÁ_ÉÁn@cÁ}‹Á†m6Á’¿-Á‹0WÁƒª°Áx[£Áib,ÁZi;ÁKƒÁ<ÄäÁ.òÁq‹ÁÌ×ÁB7Àç…¢ÀË' À®ë À’Ê(Ào9fÀ9uçÀš¿£ç¾û€]>‰?€BŸ?Ù8Œ@6@=ˆñ@`xM@2.@Œ·@—Î@Ÿmr@¥@©@©þÍ@©:4@¦™@Ÿ«@–[3@‹Wè@y5@X¨@4Ðê@I?Ëߤ?jã'>?¸5¿Ñ¡¿¬„Àú#À>‰ßÀtÝÀ–F‹À²¥èÀÏ ‹Àëû*ÁÁÜÁŽÞÁ"\êÁ1JÁ@[–ÁOv÷Á^’cÁm²ÉÁ|çØÁ†CÁ“ÛÁ‹‰œÁ„¨Áy;Áj0žÁ[S”ÁL}âÁ=Æ7Á/ãÁ fFÁ¹ªÁ cÀé}ÊÀÍÀ°°˜À”£„Às%iÀ=(ÝÀ¹Ó¿ªAÛ¿ Ø•>U!"?põ^?Ñ œ@ô„@9\c@\‚O@{ŽY@ŠÞŸ@•lX@•‡@£“Ý@§wÌ@¨ñ@¨Ž˜@¥¨ @Ÿ.…@–(@‹«Æ@yëï@WæÂ@3ì±@g¤?Ëy)?g&Ð>@Xí¿Ø¿­XÓÀ HƒÀ>ÏHÀuQÀ–´À²yÀÏSâÀì.ÂÁ¬¦Áo?Á"6 Á1dÁ@ŠÁO@ßÁ^x•Ám±’Á|êŽÁ†—Á“yñÁ‹û±Á„‡\Áz(sÁkFÔÁ\iùÁMªwÁ>ò1Á0;wÁ!– ÁŒÁ‘¾Àì^WÀÐÀ³ç˜À—ÀÏÀy  ÀCÀhé¿´yø¿$Á=øG?WM?Ĥ°@ Û@2Ë@V>@uñ@‡Âm@’‘×@šy†@ lS@£Ã<@¥0N@¥š@¢—»@xž@•6n@‹ @x‘È@TÞ @0Ü»@ ^ ?ijt?Ys“=÷,_¿!Ÿ‰¿³›pÀ /oÀAñÀx@À—«ªÀ³g?ÀÐ ªÀìóƒÁ Á½'Á"¡ãÁ1—@Á@ûÁO“Á^µ;ÁmêpÁ} œÁ†.ßÁ”¶ÁŒ˜ Á…!¥Á{VÒÁl|$Á]Ä×ÁO“Á@flÁ1½ÔÁ#55Á¾ÝÁS†Àïø#ÀÓ£‹À·R%À›„öÀ€URÀJ‹Àsö¿Æ]\¿C¬Z¼©Ü³?6J_?²Æ@Ÿt@(ýü@L©©@k/@‚ùK@‡@•b@šŒ}@s‰@žÎ`@Ÿ!˜@‰“@™°B@‘Ж@†°•@qt@Mê@(úà@ Ð?µz ?;ò÷<À"ã¿9}Ñ¿ÀJ[À§¿ÀG+&À|¼ ÀšµÀµôÃÀÒûÀïxÁ#ÒÁ½‡Á#zÁ2^ZÁAGÁP5)Á_@‚ÁneÃÁ}•®Á†gÁ”¾&ÁPZÁ…ærÁ|ùÁn3OÁ_{MÁPÊ„ÁB+3Á3œuÁ%-<Á¾EÁOMÀóøÓÀ×ãCÀ»Ø‰À YyÀ… tÀT‚ÆÀ 5|¿Û,‚¿mUp¾E;ó?-¼?œo?ìú@R¼@>ƒƒ@]–í@wïÿ@†…g@¸·@’£Z@•J¸@–»‡@—Õ@–0@‘Ð@Š\@~bÄ@buy@@f<@„?í¾s?ž,A?]¾è¿^ü½¿ÐÉÀbÐÀOS}À‚R¤ÀFBÀ¹KÀÕb†Àñ×¥Á{„Á&¿Á$ÓðÁ3¢hÁB“pÁQøÁ`šfÁo£ÕÁ~­HÁ†à9Á•¢ŽÁŽ6ÿÁ†Ë¯Á~ÒšÁp%ŠÁaˆ¾ÁRëøÁDPÂÁ5Ñ$Á'm±ÁÙÁ Ñ£ÀùM¿ÀÜéÀÁ&÷À¥ÆBÀІóÀ`x À,|+¿ó’¿‘ʤ¾ÎTŒ>œ6©?x¼„?ÍLÙ@ tÌ@-6º@KEN@eÐ^@zGÐ@ƒðã@ˆšÂ@‹|@Œ¿®@ŒØô@ŒPS@‡V}@€o@jè@NA@.ñ“@ ¯À?Ï=?€>±±N¾²DÔ¿ˆ°°¿è<À&¤‹ÀZOZÀ‡¶´À¢¢]À¾YÀÚIÀö£ÍÁ ¨üÁJÁ&‘“Á55LÁDzÁS „Áb~ÁqÁ€¢Á‡¤¡Á––+Á2jÁ‡Ù_Á€€ˆÁrR|Ác¿ÁUG7ÁFÑèÁ8\ÆÁ)ôßÁµ#Á q4ÀþqzÀâ¹'ÀÇ@>À«â¯À‘\ˆÀmÊ¿À:ïbÀÕo¿±çÍ¿*#=Ó?/;?¥§e?îQ@•z@4ó@Nê@bKw@o¼à@xþ½@~º@€­œ@€¿‹@û>@w×@gÌÕ@S5D@9¸Æ@/$?óš8?«G2?7^¨=’KA¿bT¿¨åÀáÀ5à„Àh¢ŠÀŽ7æÀ©ÀÄ 0ÀßˤÀüËÁ A4Á­Á)0=Á7º&ÁF^ÁU3ŸÁd%ŽÁsœÁ ›ÁˆÁ—Î<Áp¦Á‰*Á¿·ÁtêÁfdhÁWßgÁIa›Á;Á,ÜQÁŸwÁƒ©Á†‰ÀéRÈÀβÀ³"ÞÀ˜³˜À}áAÀKy!Àr|¿×¿xš½¾š7Æ>±ÓÓ?q%ª?½Šc?ü(T@¡Ã@2“z@F8@T ‘@]PC@b2@dÿ @fó@cÕG@[ì–@Lgý@7÷<@ô[@ð?Ês”?‚>ǸF¾†q¿pf¿ÏÚwÀ¨âÀG¬éÀy&À–¹]À±êÀËì}ÀçbHÁsÁYxÁ•Á,Á:•ÁIIÁW¾?Áf޶Áu‚Á‚>ÙÁ‰¾BÁ™™Á‘¿†ÁŠqïÁƒ&¥Áw¹ÁiByÁZæƒÁL—eÁ>NˆÁ0 PÁ!ðÉÁô¸Á ÀðÉ“ÀÕçÀ»EmÀ¡€mÀ‡û´À^°pÀ.å‚À©h¿¨˜¿(¢²½*žÕ? TŒ?‡/ ?ÃIž?ùàj@ t@':@4ù@=ö.@C‰á@EÔC@F«E@DÑ-@<ÎY@-é@ëq@žm?Ï=š?”bÓ?%…ó<‰Ïª¿#žw¿§ ¿ÿ"¿À-J›À\²hÀ‡$À tôÀ¹Ý•ÀÓðLÀïS‘ÁƒhÁ]Á!X¨Á/‹VÁ=ÿæÁL€õÁ[ (Ái¢ÁxbÁƒ£‰Á‹Áš¤Á“WNÁŒ oÁ„¬Á{ÇÁlŸ Á^PŸÁP·ÁAàrÁ3®ÝÁ%štÁãyÁ Y˜Àù¥]ÀÞáÀÄ×cÀ«ÐÀ’lˆÀsêYÀEDðÀÄå¿ÚÕÈ¿‡8ç¾ñB¾=¯TÙ?$—?„øå?»&?çE¶@¯Î@ÓÇ@Ù:@!<@#À @#“ó@!ñÿ@ñ„@ e®?ñÔ?ÂP¼? ¹?/5>8t¾Ë)¿†Ð¿Ü,îÀÞ²ÀE× Àtp/À’÷À«tAÀÄðÛÀÞ¯Àøä{Á árÁ¨LÁ%¦šÁ3±óÁAÌHÁP'Á^®Ám;Á{ÌŽÁ…?íÁŒ«‰ÁœbsÁ•gÁÎWÁ†‡4Á~ŽÁp¼P©?.UÕ?pð÷?‘~ô?¢±?¬J=?±Y?¯ ?¨¹ç?šÅ?€áÏ?9Ì‘>¾ˆÏ¼´¡F¾ï,´¿r*ö¿»Ð¢À¦À*CxÀS¬”ÀH¦À–À­XÀÄÖ¼ÀÝŸ­ÀöˆÉÁ)Á-ÿÁ"SÁÁ/Î?Á=ŒªÁKkÁYm¸ÁgtFÁu˜ÓÁùµÁ‰>PÁ–²Á lÁ™9‡Á’ùÁŠÔŸÁƒ­ÆÁyA—ÁkU˜Á]lúÁO„ËÁA¾WÁ4S±Á';>Á3ÒÁ 2çÁi ÀçêÀÏÐÀ¸+ÐÀ¡×zÀ‹ë ÀnmòÀFQ\À!2¿þJ÷¿½­A¿„¹%¿aá¾ma= ž¢>¤ú6?Y+?"uÍ?3’?¶óh=Êv'¾n麿 ×⿇Œî¿ÄªÃÀ×ÏÀ&í!ÀL—Àt÷ŠÀ‚3À¥uîÀ¼:ÀÓdJÀëÐÁ&.Áœ_Á½Á(xLÁ5£†ÁC4MÁPñOÁ^µ ÁlŸ Áz®›Á„mŸÁ‹’²Á’ÍCÁ¢´~Á›‰TÁ”búÁE Á†?Á~’(Áp¦_Áb»5ÁTþÇÁG–ÇÁ:w5Á-`‰Á NîÁT‡ÁêBÀõéÀÞTYÀÇ|ÀÀ±‰cÀœJÀ‡ÏCÀiåmÀDRÀ${À@ ¿Ïü\¿›Ëä¿ZFé¿Ñ‚¾¥™Ï¾Dn½NW<øi£=YN=(‹~¼hìÓ½û……¾ž\Þ¿ÏR¿`D¹¿ Gò¿ÕU%ÀÞcÀ)z$ÀKÏXÀp•0À‹üºÀ n§Àµ¤5ÀÌ%ÀâégÀúœkÁ w–Á§µÁ"ÒÁ/OÁIèÀR ÀiQÀÌmÀ‘É2À¢)À³Õ ÀÅîJÀÙ þÀìëÃÁ½ÁÁ { Á Á!óoÁ-–Á9¢ÈÁEÇ\ÁRAãÁ^îþÁkµÁxÀQÁ‚ý¸Á‰­fÁdÐÁ—1äÁžžÁ­ÃUÁ¦ÔQÁŸù7Á™)æÁ’^Á‹¦Á„þ¼Á|·_Áoº?Ác˜ÁVÔvÁJBÁ>ZbÁ2ŽÖÁ'F¦Á ÁE²Áü‡ÀùÛÀæmÀÔÎùÀÃ{ªÀ³ÙSÀ¤o&À–bÀ‰“ À}[ÀivFÀYÚlÀKÑÀB áÀ<ÌÀ8+BÀ7”×À8ì½À=!ÀDfÀOŠâÀ\¤òÀnX±ÀãÀ‹óôÀ˜j2À§¡™À·N¨Àȧ{ÀÚuÛÀíXžÁMúÁ }ŠÁîÇÁ—Á*ÝhÁ6YcÁBgÁNÊÁZ=¿Áfµ™ÁsfíÁ€ˆÁ†”ËÁ=jÁ“î¾Áš dÁ¡_¤Á±JÁª «Á£EŒÁœyŸÁ•Ê|Á+éÁˆ˜Á‚gÁw›YÁk9WÁ^ô‹ÁRä(ÁGxÁ;›åÁ0vÁ%Š©Áñ¥ÁÛÆÁãÀû¯!ÀêèÀÙIÀɯòÀ»8À­ÞhÀ¡H>À–×ÀŒÜ½À…ZŽÀ}u­ÀsªöÀn†wÀk „Àiï¾ÀlIÀoü·ÀwÀÀ€ÔÀ‡WkÀÌÀ™†ãÀ£ßŽÀ¯éfÀ½×•ÀÍù¢ÀÞ‰ Àð!vÁ4Á °çÁ™úÁâ?Á)nAÁ4.¿Á?„ÄÁK”ÁV»³ÁbÏâÁnðYÁ{fÁ„:ÁŠrÁïÁ—2ÁžBÁÁ¤õûÁ´RÎÁ­tÁ¦¯<Á tÁ™zFÁ’ù6ÁŒ‚òÁ† !Á¯oÁshëÁgpKÁ[€ÄÁOô”ÁDáKÁ9ÞRÁ/GHÁ%Á4êÁ¿Á®€Á2Àð4~Àà²@ÀÓ=ÀŰ7À¹æªÀ¯QÞÀ¦4oÀžÎŒÀ˜´©À“Î/Àñ»ÀfÀ0IÀ5>À’f/À•ÉÕÀšÙ#À¡ŽIÀ©ZaÀ²‹ÒÀ½u!ÀÈß_ÀÕ_ŒÀäçBÀõMÁ‰Á <ÁT²Á“Á)Á3_4Á> ÆÁHíâÁTO^Á_ÂôÁk…ÃÁw£—ÁöŽÁˆ/ÁއÐÁ”êÁ›g Á¡ûoÁ¨ž¦Á·Ã»Á±<ÁªfºÁ£âÁd}Á–ïQÁ€¤ÁŠ-`Á„£Á|]Áp9ÈÁdšåÁYrŠÁN[ïÁC±!Á9‰•Á/k²Á%ÙÖÁ¤AÁ Á Ä ÁÞÜÀù+ûÀëYÎÀÞ5GÀÒªjÀÈ–˜À¿ÂaÀ¸sÀ³þÀ®c]À«¡ZÀ©ÙÀ©ÎUÀª÷ÏÀ­ðÀ°ÆDÀµµYÀ»ïÀÃqrÀÌ|ÉÀ×,ÇÀâjIÀî¼ÂÀü¶ÍÁIÁrÁ ÏÁ <8Á)-Á3|ÞÁ=yœÁHNÁR¹Á]»ÊÁi&bÁt˜ÐÁ€3EÁ†PKÁŒ‚ÑÁ’¶/Á˜ÿ¢ÁŸbßÁ¥âjÁ¬v&Á»{íÁ´Þ‚Á®OîÁ§ÏÅÁ¡[»Ášõ Á”§1ÁŽƒÁˆŒtÁ‚¡3Áy’aÁnOÝÁc5›ÁXj®ÁN)½ÁCý°Á:$™Á1ÅÁ(%–Á—‰Áˆ.ÁøÁÙÁ<À÷Ê¢Àì`¶À⿵ÀÚTDÀÒê™ÀÍ¿†ÀÉ–ÀÆ|-ÀÄß ÀÅ"ýÀÆEÀÈ…ŽÀÌ1ÞÀÐÖÀÖ£îÀݯ>ÀæñšÀñ cÀûõ3Á1,Á ÁÁ*ŠÁ"•Á+€šÁ4³Á>DxÁH7 ÁRLñÁ\ñÁg²)ÁrÍYÁ~9¦Á„ÛiÁŠÅ£ÁßFÁ—QÁB„Á£~ZÁ©ÝÁ°]ÙÁ¿]ÇÁ¸ÅuÁ²<²Á«Ð8Á¥{ÈÁŸ=ƒÁ™ÌÁ“ çÁ4±Á‡PÔÁš†Áx'œÁmq#ÁbôÕÁXŇÁNà6ÁE|åÁÁTŸEÁ]þ¾Áh°Ár,ÏÁ|dÁƒ‡€Á‰ ¤ÁŽ”‘Á”C\Áš$EÁ Á¦6Á¬;ÃÁ²x{Á¸¹#ÁÇV.ÁÀôÁº±­Á´:Á®YÁ¨S»Á¢fÁœyÁ–¹#Á‘&­Á‹ÍÁ†÷ÁCÁx”jÁo!gÁe¹ÚÁ\––ÁT,ÁLªÁDA@Á<º2Á5ÎeÁ/âÁ(ëiÁ#0ÁîÁ‘Áù&Áy6ÁÔÁŒÁ Ü{Á /TÁ X]Á ÁIÖÁ1<Áb&Áþ/Áf$Á1ÍÁ ÞÁ%æ§Á+=Á1•…Á8-ÌÁ>÷òÁF·ðÁNàÁW<øÁ`@1ÁiZ…Árù$Á} Áƒ ¢ÁˆÃËÁŽ&~Á“¯-Á™:õÁžïYÁ¤ÔAÁªÊ²Á°È¹Á¶êéÁ½,ÁˤŠÁÅ`ÒÁ¿&{Á¸ûÁ²óhÁ­°Á§6ÎÁ¡o.Á›Õ¢Á–rZÁ‘&ZÁ‹àÁ†Ñ~Á‚fÁzž±ÁqmÁh·åÁ`XPÁXvUÁP»kÁIž%ÁBºcÁ«.ÁE?¯ÁKäµÁS6”Á[;ÁceVÁlªÁu$}Á~emÁ„ýÁ‰-öÁŽACÁ“q;Á˜ÞÏÁži#Á£øÁ©°¡Á¯–¢ÁµŽÂÁ»ŒßÁÁ¬"ÁБÁÉ×·Áí¤Á½¦­Á·ÅÆÁ±ùÁ¬4Á¦—4Á¡'ÅÁ›ÑÀÁ–‹–Á‘uÁŒøÁ‡Ä¶Áƒ& Á}Š‹ÁtçbÁlºWÁe Á]†|ÁV—ÅÁO¿‹ÁI«[ÁCÖ‘Á>Á9œÁ5{‚Á1Â,Á.Á2Á,6àÁ*| Á)M_Á(ÛoÁ(´îÁ)=Á*ÔÁ,Ë.Á.ô°Á1«ªÁ4´rÁ8QYÁTÁÍ\3ÁljªÁÁÁÁ¼ Á¶ªrÁ±BaÁ«ê®Á¦ÈOÁ¡ÜÁœüÄÁ˜0’Á“¨~ÁWæÁ‹Á‡áÁƒ.™Á~õ]Áwä/Áq©ÁjDzÁdçÁ_r–ÁZhMÁUͪÁQÝ*ÁNG'ÁKÁHô‡ÁGi¥ÁF.¬ÁEÛÁEÓEÁF°úÁHÍÁIúuÁL ÁNŸÁQZ‹ÁTãFÁXÀäÁ\óÁb ÁgG?Álí9Ás]ÀÁyî<Á€‡2Á„rJÁˆmÁŒ„³Áí¼Á•Œ\Áš1ŽÁŸ tÁ¤$éÁ©IkÁ®oÁ³¸õÁ¹4ªÁ¾Ó’ÁÄuhÁÊ*¢ÁÐ Áé[dÁãt«ÁݬaÁ×úeÁÒJëÁÌ­&ÁÇ8ëÁÁñìÁ¼ÉUÁ·§—Á²³–Á­ïÁ©4üÁ¤–|Á :ïÁœ(”Á˜:šÁ”pÑÁåvÁ‹ÁŠoÂÁ‡ŒÅÁ„òlÁ‚‰qÁ€m'Á|؉Áy¤ÁvÈ#ÁtUiÁri+ÁpäŸÁoâÍÁnê…Án~ÍÁnßNÁoˆAÁqÁrÏöÁu*üÁwËüÁ{¸Á~¦ðÁdXÁƒ„bÁ…ðÁˆšÁ‹_•ÁŽ…Á‘ÏÒÁ•PÙÁ˜ö4ÁœÏuÁ î¦Á¥" Á©uëÁ® LÁ²à2Á·æ Á¼öSÁÂÎÁÇ`fÁÌdzÁÒRòÁ×âÙÁ݉õÁ䈑ÁÞ•ÁظWÁÒì%ÁÍ8EÁLj£ÁÁï‹Á¼‚¬Á·DÇÁ² Á­7Á¨#”Á£d3Áž¨Áš",Á•æ#Á‘â=ÁõÁŠWUÁ†þëÁƒ»×Á€±ÃÁ|-ÁwõÁrÙ„ÁnÆSÁkyœÁh›ÁeÞcÁcùûÁb‡¸Áaw†Á`f÷Á_ì%Á`O÷Áa`ÁbsÇÁdC¹ÁfŸõÁirÁlÉgÁpíÁtͪÁy<‹Á~TZÁÏïÁ„µ¡Á‡é¯Á‹?%ÁŽà`Á’šàÁ–ŸÁšÖÄÁŸ÷Á£•˜Á¨TþÁ­L½Á²[éÁ·~Á¼ÆæÁÂ"äÁǨSÁÍ;ÁÒähÁجáÁßÎÁÙÀlÁÓÓ=ÁÍý–ÁÈ-9ÁÂxºÁ¼ÔÍÁ·C˜Á±ß‚Á¬£Á§p˜Á¢góÁ›“Á˜âäÁ”7ÈÁÏ.Á‹­òÁ‡¢œÁƒØÕÁ€p$ÁzQþÁsôèÁnp‰ÁijÁdúÂÁ`ç:Á]fÈÁZ}¥ÁWìÁU¥°ÁT9KÁS ÁR ÁQŽÑÁQö>ÁR³@ÁTÁUã¬ÁX.}Á[*êÁ^ƒÑÁb“ÁfÙVÁk£ÁpذÁvJûÁ|ZFÁY„Á„ÓwÁˆŽ«ÁŒj–Á—£Á”Ü%Á™=ÔÁåÁ¢ÁÁ§Á€Á¬ä:Á²-ŽÁ·Á¼ý´Á–_ÁÈIÛÁ΀ÁÔÁÛB.ÁÕñÁϼÁÉEÁÃEäÁ½u?Á·ÆáÁ².hÁ¬¤ØÁ§L½Á¢ VÁœÛšÁ—å Á“#@ÁŽnAÁ‰ç¢Á…¢Á~òÁ{ Ásã¡Ám7ŠÁfÒ ÁašÁ[ùHÁWCÎÁS •ÁO~¯ÁL`FÁI˜ÁGâÁEðÀÁD¨´ÁCÝaÁCr“ÁCÝìÁDž5ÁEÉGÁGµBÁIøKÁM XÁPs^ÁTœ-ÁYæÁ^ÌÁcg›Ái7ìÁoc©ÁuÝ‘Á})NÁ‚dìÁ†gˆÁЦ*ÁÁ“”1Á˜N¡Á1ˆÁ¢JéÁ§”RÁ¬ãcÁ²UsÁ·õ‚Á½´ÁÉÎÁÉmÁÏsYÁÖÊMÁÐŒ ÁÊg~ÁÄ]“Á¾pVÁ¸˜èÁ²É¾Á­ ­Á§‰uÁ¢¸Áœ»ÚÁ—‚Á’aÂÁqìÁˆ«ùÁ„ ÁjÁvüèÁnÏÁgF Á`@ÁY¿5ÁSì…ÁN’ðÁI·²ÁEJñÁA¦hÁ>GbÁ;¬+Á9ÜÁ7ÚoÁ6xNÁ5ÛÁ5ˆKÁ6Á6ÃðÁ7ÖÁ9ÃÁÁ< µÁ?%¦ÁB®»ÁFÆ5ÁK‚ýÁP–ÏÁV;ÎÁ\A¬ÁbŽzÁilÁq¢Áx»ˆÁ€q:Á„ÄÁ‰TàÁùVÁ’½ºÁ—ÅÁÁ¢XÁ§À;Á­[ŸÁ³#óÁ¸ýÁ¾Ü*ÁÄܤÁÊþQÁÒ|ÄÁÌRÁÅÜ$Á¿¼2Á¹½Á³ÎiÁ­ìgÁ¨Á¢zÖÁœçÁ—q4Á’2|Á˜Á‡ô×Á‚ÿõÁ|£Ás§•ÁkXÁbÁ§Á[ ×ÁS²ãÁLÏÁFë£ÁAcQÁ<5ÏÁ7ÎñÁ4WÁ0o½Á-ÒfÁ+š"Á)æÜÁ(—gÁ'ݦÁ'¤ÓÁ('Á(öKÁ*6ùÁ,KÁ.zQÁ1„Á5,(Á9<ÄÁ>]ÁCEVÁI2ÛÁO\`ÁV3Á]A#Ádó‡Álµ¾Áu^Á~+$Áƒ»iÁˆm Á^Á’”ÐÁ—æFÁEÁ¢Ø<Á¨œÁ®pÔÁ´LÁºFëÁÀgeÁÆ£.ÁÎe·ÁÇæìÁÁ‚çÁ»>ŽÁµ+Á¯çÁ©0ÆÁ£DuÁvÁ—Ù3Á’XÁŒñŽÁ‡³ÃÁ‚‡$Á{Áq;7ÁgýÁ_UÀÁVÇ*ÁNçÁG†uÁ@R¹Á:›Á4^ÚÁ.æœÁ*cÏÁ&žiÁ"û|Á +×ÁïzÁ0AÁè¤ÁÿÁÉxÁM‚Á4ËÁ«îÁ¡9Á!(­Á$@Á'í…Á,ðÁ0Ú}Á6TOÁ<7CÁBÐ4ÁI¬ÁQ2+ÁXícÁ`÷:ÁiÃÁs „Á|l8ÁƒzÁˆ@»Á‰Á’èÿÁ˜r3Áž,ÅÁ£õÁ©ÇÙÁ¯ÁÁµâBÁ¼'ÁÂ?ÁÊaIÁÃ×áÁ½_kÁ¶ýÃÁ°·%ÁªYÁ¤……Áž”¡Á˜ªwÁ’àgÁMaÁ‡äkÁ‚Ž&Áz‰ÁpE£ÁfsîÁ\Ó?ÁSäEÁKB`ÁBñ§Á;zøÁ40¡Á-ÍÁ'pÓÁ" aÁ1"Á=ÁÁÁ/ÁÇšÁc4Á£'Á 9îÁ o6Á 0åÁ y8Á ¡ÂÁ#<Á@QÁ×úÁèÁÝÿÁFÁ$±Á)§œÁ/ªÁ6d±Á=sàÁEB~ÁMCPÁU¿ÇÁ^¯§Ágÿ\ÁqÉgÁ| ýÁƒB‹Áˆ™,ÁŽ öÁ“ÖUÁ™•ÁŸ_£Á¥VÁ«wÁ±¾Á¸%PÁ¾”™ÁÆ}èÁ¿Þ—Á¹MñÁ²ÚàÁ¬‚™Á¦?«Á ÉÁ™ð]Á“üÁŽ%Áˆh°Á‚à—Á{#Áp]?ÁeܲÁ[ÙüÁR:èÁHÚ%Á@)ZÁ7Œ.Á/ öÁ(&XÁ!@ Á@Á‰ÊÁ†+Á '¹Á¡Á£uÁçEÁ9ëÀÿ†ÀþiºÀþ;Àþ ‹Á1öÁ¯%ÁßpÁ”ZÁ þÁ ú%ÁvŸÁ©pÁFèÁ#“ÅÁ*-÷Á1¨4Á9¨FÁAì-ÁJ² ÁS§ùÁ]ZÁgž£ÁqõÁ|“ÁƒÐÁ‰…ŒÁAœÁ•}Á› ,Á¡*£Á§r¦Á­ÛYÁ´IIÁº··Á±ýÁ¼ÁµoÚÁ®ÙLÁ¨aaÁ¢ {Á›Ê¯Á•Š{ÁgÐÁ‰vCÁƒµ‰Á|(SÁqÁf?‡Á[Ÿ;ÁQeÂÁG¾‡Á>&ÌÁ5Á,ƒBÁ$yÁa“Á$fÁüuÁ >Á AÀÿ:ÖÀ÷iÖÀñDÀëÞ*ÀèÕÀå|Àä 6Àãê_Àäb Àæ£Àé‚ÀíRgÀóÀù×?Á\ÁâÁ JðÁ"Á™tÁzÁ&ÁÁ.&YÁ6ÝéÁ?ÉÁI+zÁSFîÁ]ŠœÁgû~ÁrþˆÁ~k»Á„ñãÁŠÏjÁ×Á–ÿ•ÁA‰Á£¦WÁªÇÁ°†µÁ·.Á¿ Á¸aÁ±¹ÅÁ«XÁ¤€1Áž Á—¬ÚÁ‘fƒÁ‹!ºÁ„ÿQÁ~$&ÁrÂâÁg˜Á\nÁQ{£ÁGßÁ=3Á3©3Á**µÁ!mäÁÙ±Á¯™Á šÝÁßÀú/ÙÀïd!ÀænÙÀÞi¬À×£ÀÒ¿5ÀÍáxÀ˰mÀÊF ÀÊGÁÀË:yÀÍSÏÀÐ`–ÀÔ&„ÀÙæxÀàµåÀ躺Àòé Àþ¡ÁöÁ åÁ3ÈÁ§Á#%pÁ,1ëÁ5kBÁ?EÙÁIrÁSº¦Á^—ÇÁjÕÁuŒÁ€œÁ†¬_ÁŒÛ}Á“6Á™qÜÁŸá!Á¦dªÁ¬öÁ³ŸìÁ»°TÁ´ãÌÁ®(ÌÁ§rñÁ Ë=Áš.ÿÁ“°LÁX¾Á‡æÁ€ÛÁuqÿÁiiÁ^F¹ÁSçÁGáÁ<êÒÁ2´¾Á)…Á“ßÁY(Á ÓÁSÀülÀïP®ÀâO¶À×HcÀÎÀÅŽÀ¿À¹¢îÀµ­À²R´À°éìÀ°ãËÀ²{À´LÀ·VTÀ»qîÀÁM<ÀÈ€9ÀÐçÈÀÚ¢PÀåéNÀò}jÁ]ÁõJÁàáÁ²Á!ºÓÁ+~*Á5sìÁ?ÕoÁJ©êÁUàQÁa]ºÁmûÁyÅÁ‚¹eÁˆéÔÁ>®Á•ºæÁœJ$Á¢ßÊÁ©‘ÆÁ°Q$Á¸f,Á±}ÀÁª­ÂÁ£óTÁ;ôÁ–…zÁßbÁ‰]-ÁƒFÁyœ'Ám7úÁ`îÓÁU6ÁIÍæÁ>žÁ3–‡Á(ÛÒÁòðÁK,Á ¯Á÷HÀõô£ÀæO†ÀØ 'ÀËpvÀ¿Ù'À¶«ÁÀ­ÆåÀ¦Õ#À ú@Àœ¢üÀ™¼ÉÀ˜]DÀ˜gÀ™¤À›aÀž¥-À¢½áÀ© éÀ°i‹À¹Æ)ÀÃäVÀÎÎVÀÜXÀêÒ§Àú!ÓÁyÁ.ÞÁÇÖÁ!¸‰Á,Á7ÁB@ÁMB‰ÁXÏöÁdãïÁqCZÁ}­ÁÁ…+¶Á‹«xÁ’9³Á˜ÒÄÁŸ‹ßÁ¦YsÁ­)MÁµ\òÁ®\BÁ§n§Á ’,Á™ÍoÁ“(ÁŒY Á…­®Á~M}Áqš_Áe&îÁXºèÁLlUÁ@ž®Á5jùÁ*rÀÁ}ˆÁìÁ hÃÁÀÒÀñ$ Ààå@ÀÐÒÂÀÂnÀÀµšÀ©´ØÀŸ{•À–hÀsÀ‰BˆÀ„—ŒÀˆJÀ€=À€-,ÀkôÀƒ^}À†qÀŠÊšÀéÈÀ™%;À¢ª À­ˆÍÀ¹JÕÀÆHÀÕ4ÀäâÀö§‘Á”UÁ[«Ád~Á#,dÁ.I"Á9„ÂÁDø™ÁPç™Á]9ìÁi»\Áv‹ÁÃÜÁˆPgÁŽì Á•¨eÁœpºÁ£ANÁª$6Á²lQÁ«W¸Á¤X‰Ám5Á–…ùÁ®3ÁˆïÁ‚;ÎÁwAÚÁj1WÁ]xÁPû@ÁD~øÁ85dÁ,’Á!^jÁX^Á }—Á„(Àï¼ëÀÜÒWÀÌEýÀ¼6ïÀ­L€À À“©ëÀ‰QaÀ€WÀpuÀdBmÀ[;´ÀTRƒÀQ"2ÀP€äÀSÝÀWSµÀ\™BÀgBÇÀtHÊÀ‚`üÀŒLËÀ—žZÀ¤‹À±ÛÀÀ±¸ÀÑTºÀãyhÀö±rÁ;Ák¶Á® Á&•Á1‰QÁ=!ŽÁI@òÁUâéÁbÔÔÁoËÐÁ|ÚÁ… ´Á‹ÌVÁ’ÔÁ™`]Á L}Á§PDÁ¯¨òÁ¨‡BÁ¡iæÁšaXÁ“p’ÁŒ…ÿÁ…žbÁ}£KÁpTâÁc6(ÁVŸÁIZåÁ<á„Á0r>Á$R’ÁÙÕÁ ¢gÁ‚iÀïÌáÀÜJçÀÈèqÀ·¡ÁÀ§šáÀ˜Ž¾Àг£À|_Àg}ÀT²ÀDIÀ7ï•À-ä À&œ(À#˜À#xmÀ%BsÀ)6vÀ/CNÀ99žÀG¯óÀYXÑÀmä²À‚[×À |ÀžsÀ­äƒÀ¾<ÀÑZÀäÌÀøÿ¼ÁC²Áy!Á øÁ)ăÁ5ÂÁBRLÁO2ÁÁ\HÁiMÁv\òÁõyÁˆÊÁ£¶Á–’Á“qÁ¤š¤Á¬òïÁ¥ÌCÁž§nÁ—…·ÁrGÁ‰xÅÁ‚ŽÁwgUÁiËIÁ\s@ÁOGZÁB#'Á5[Á(ÙÁlíÁˆ.Á7;ÀóÝ3ÀÝïˆÀÊ–À¶²¿À¤>)À”/À„pÔÀmMÀTk>À=ë À)û”ÀÕ‚À Àkg¿ö*¿íüT¿î<à¿ñʲ¿ølzÀ*À Ò¿ÀðëÀ/ÅqÀE.ƒÀ]S¤ÀvÄrÀ‹:}À›F(À¬Ù=ÀÀqÀÓó6Àé$tÀþ±‚Á çâÁ”ÏÁ"j™Á.Þ0Á;¿,ÁH¦ùÁU ¾Ábï¤ÁpÁ~(uÁ…ìúÁŒÛ#Á“Ü«Ášå„Á¡ý{ÁªpŽÁ£,ÞÁ›úUÁ”ÔRÁ²iÁ†˜'Á)íÁqbyÁcÑzÁVI0ÁHÎÕÁ;˜¼Á.”ŒÁ!åœÁ@?ÁÉÿÀú(FÀ㋦ÀÌù~À·üæÀ¤vÀ‘h«ÀTÀb=ãÀF$À+ΓÀ'ÀÂì¿á” ¿ÅŒ{¿¯åƒ¿¡7濚Ÿã¿˜lÍ¿œ&¿¢æ¿°a_¿È^í¿ê+)ÀÝâÀ¾ À7*ÁÀS‰ÃÀqtYÀŠ(õÀœ¢sÀ¯@‡ÀÃêÖÀÙ$ÃÀïÞ’Á±hÁ‚#ÁÙIÁ(sÁ5PWÁB[SÁO»©Á]63ÁjÐõÁxvÁƒ+†ÁŠ9BÁ‘X¤Á˜{ßÁŸ£Á¨ÏÁ ÈãÁ™|fÁ’<þÁ‹´Áƒý˜Áyá¯ÁkÑ-Á]û8ÁPd\ÁBÔÁ5EfÁ(oÁ7{ÁÁíÀë±õÀÔ À½bÚÀ§óñÀ“{¥À€k`À]ÖÀÀ=ÈÀ hÅÀпÞÏ9¿µ• ¿‘ù ¿j<³¿:Ž¿ÝοH¿É`¿|ä¿$–P¿D·g¿w.翞uß¿Çt?¿ñæ À@ÜÀ1ìóÀQ¬Àt%šÀŒÀÍÀ ³ÙÀµ‚ÀʼáÀâ›Àù~jÁøÉÁ~Á"þÁ/+\Á<‰ÁIóÃÁW’ºÁeiÚÁsjÌÁ€Á\Á‡á Á6Á–)4Á^›Á¥ÝõÁž…¶Á—7çÁï Áˆ³¸ÁˆnÁtÙ«Áf®ÁXÁJ¨Á=7Á/[Á"7êÁ‰Á÷(Àö‡/ÀÞÀÅðÆÀ®ÇÀ˜åwÀƒmÙÀ` OÀ;AÀR=¿øƒ¿Ä÷B¿•¦Û¿Vº¿ë¾¢£‘¾FҼܷ8=|m=5‡<½®O½'G†¾;ö0¾Îq¿0ÉJ¿ƒT¿³°¿çN·À»*À3‹ÄÀU¬ñÀ|ÜTÀ’Ç.À§½×À½E–ÀÕ?Àí<ŠÁðÁ€ÁŽcÁ)ÃLÁ7 ËÁD¯«ÁR ¾Á`¡µÁnª°Á|Ý5Á…ž–ÁŒÙzÁ”‚Á›XeÁ£àæÁœuÁ• OÁ²hÁ†kzÁ~túÁp3eÁaôDÁSÃÁE­Á7ÍRÁ*0›Á²wÁN·Á1]ÀêztÀÑOòÀ¸Ë^À êhÀŠÈ»Ài”HÀAË5À6ý¿ôÈ ¿¶37¿~N¿¥¾”ªºÁè>r–Ó>ÓŠ? ý?Ï?4+?® ?L>¾Ó=ÍâV¾=)¿^|¿mHR¿­k|¿ëŸ~À_ôÀ:ZyÀ`ýdÀ…–²ÀšÝàÀ±9ËÀÉ-»Àá3êÀùö¢Á @ÁKœÁ$Œ Á2"_Á@ðÁN¬Á\AÁj@HÁx­ÔÁƒ“IÁŠÐÁÁ’ªÁ™j½Á¢:ÁšŽ|Á“"ÁÁ‹¿¨Á„hÕÁz@ßÁkÔwÁ]ƒ¹ÁO5Á@ÿ€Á32Á%asÁ±'Á %¿Àù¾§Àßñ2ÀÆ[žÀ­pCÀ•LÀ{M[ÀOŽ!À%Ú¸¿ÿ«¿¹š¿sõ¿üþñ®>Zp??@ùq?mí#?‡øO?€&?’[¶?Ž`0?„z‹Æ®½¬ê¾÷I¿oYk¿µ¤¿ú|À!<²ÀH“ÃÀq¤ÑÀަëÀ¥p©À½ª‰ÀÖ/EÀïò’Áú9ÁcÁ›ÑÁ-|ÕÁ;n)ÁImÁW¬Áf {Át°¦Á« Áˆÿ‡ÁTÁ—©5Á .Á˜¼ïÁ‘OÏÁ‰ç«Á‚†ØÁvp‡ÁhÁY®1ÁK]ÍÁ= %Á.ÞÁ þ”Á-©Á_ÛÀïåœÀÕý-À¼ >À¢OÃÀŠˆÀeyYÀ8"{À;ã¿Ë@¿†½¿Ÿ½£>©k(?00\?z\Y?›™Ÿ?´}0?ÄÙ%?Ïâ ?ÒÙ?ÌQ?¾ 3?¥Ío?‚ÎÉ?4NT>¤%'½¥‘†¿·ú¿„>È¿É^FÀ TúÀ1´çÀ[ïáÀƒ_±À›êÀ²ïJÀÌHÉÀæ_ÿÁGÄÁ ®ÂÁqäÁ)8 Á7)ôÁEXÿÁS·Áb;8ÁpÚAÁ„rÁ‡ CÁŽÁ•âÁž“SÁ—xÁ›"Áˆ5ŠÁ€ÝðÁsqÁd†ùÁVÿÁG­“Á9V„Á+ ¾ÁóÚÁ6[ÁŠRÀçÔtÀ͇uÀ³‡À™¸•À4}ÀR—|À#U(¿òNP¿ a‘¿/C¾̸> ”?9¿à?‹]¤?³Mx?ÐÐÔ?ëyS?ýÄ@°I@DP@íí?ô½?Ùú´?´Úâ?Œ“?8‚@>—åo¾]°¿+¬ô¿›qª¿åsæÀ.ÀE(ÀsàWÀ‘t®À©zóÀÂûTÀÝ?®À÷ÈqÁ žLÁ‚Á%ižÁ3YÇÁA|ÁOë†Á^‹ÐÁm=ÛÁ{ô@Á…WàÁŒÃHÁ”>&Á*Á•£JÁŽ&EÁ†¶JÁ~«HÁpìÁamÁRÑûÁD<éÁ5ÛDÁ'¸´Á®«Á ¯ÀûêáÀຜÀÅóËÀ«ÞÝÀ‘ýBÀrÔaÀBŽÀºl¿Ï×4¿u…¾ÂÁ>a?"ŽB?‡ò\?¸ûD?â="@ÕØ@Ts@(k@¡K@üÃ@Ž@±Ò@¼V?æû?ºÁ?Œs?'f\>DǾ¤p¿_j¿¼†”À"À2· À`[¼ÀˆbAÀ¡>eÀºÚÌÀÔÔeÀïçÁÒ8Áº˜Á!·ÎÁ/Ñ­Á>3ˆÁLÍ’Á[pzÁj;Áx²‰Áƒ¿¼Á‹4ÂÁ’µÁ›·pÁ”7ÁŒ·HÁ…BIÁ{¸eÁm¬Á^p×ÁOÔ;ÁAKxÁ2ñ Á$ÆGÁ£²Á•oÀõuêÀÚyzÀ¿QÛÀ¥<­À‹};Àd„ÂÀ4½,Àóý¿±Ê ¿<C½ô°<>ÜÝž?lD ?¯ƒ,?áÓq@ŠL@[–@$kð@-ì@2T#@3=@/ðx@'F¢@¡@G8?åKˆ?¶??v?˜3»ëT“¿4y¿–µÄ¿ëûIÀ!ØnÀOí:À€3’À™r†À³XÖÀÍêÀè¢ñÁ$€Á&|Á4aÁ,‡uÁ;÷ÁI«œÁX?dÁfÚ¬ÁuœQÁ‚AÈÁ‰ÂNÁ‘D¢Áš`{Á’î=Á‹oBÁƒî³ÁxõtÁj1,Á[˜õÁM!Á>µ‹Á0JlÁ!ðÄÁË5Á·éÀï» ÀÔ”¤À¹·ÀŸByÀ…ÅcÀXºÀ(ÆÚ¿òVý¿™u‹¿ =µ#ˆ?*Dä?•òu?Ï-ª@‹Ð@- @*‚ë@8£@@ ä@D©'@Dæ@@÷“@8Šÿ@,^\@?+@æ”?Ú×Î?¤Cà?P%H>“@¾› b¿j8 ¿Ë£ÃÀt%ÀB8ÀrÔÀ’VéÀ¬—‘ÀÇ5 ÀâQ‘ÀýüØÁ òÌÁÁ)‰*Á8òÁF¶ªÁUnéÁdL}Ás@qÁÔÁˆ† ÁýªÁ™BÁ‘ŸðÁŠ.ÉÁ‚¾pÁv™yÁgÂÎÁY½ÁJ˜Á<:BÁ-ÜuÁu;Á;ÁÀê ‰ÀÏFËÀ´jÀÀšEÀ€,nÀNt¢ÀIâ¿Ü Þ¿ƒŸ ¾¬ôd>‘%B?\üº?°®L?ëB @æN@'fÅ@:§&@H£t@QIç@T³@TlÞ@PT @Há?@íz?†ª·?ÊU@AÉ@ Ÿ@4¦È@Hí@V8½@_®ó@cX(@bsã@^Á¯@Vo @K‚“@;ä@%(Ñ@ ù?àWW?¢;?4ít=Ý!:¿Š¿š‡K¿ö@À*á•À\PÀ‡yÀ¡¡¦À¼ëÀ×ÊoÀódzÁä˜ÁbÁ$ŒìÁ39ŸÁAç~ÁP•]Á_JkÁn Á}þÁ† Á¢Á—C¾Á·'Áˆ-Á€§ìÁraGÁc—ãÁTö<ÁF]^Á7ÄÁ),œÁÃ&Á ªºÀýP`ÀáSKÀÅðÀªüªÀ ÀlƒrÀ9å(À˜¿²¿0Yì»ÙƒH?®?›Í,?ß(R@ f@'ç@@@S<ÿ@aqù@jƒ@nÖé@n'@j3@b×Õ@WF@H:a@1À¢@q¿?õØu?µA„?]>&>ƒÀe¾Æmõ¿‰™¨¿ã~À!þ¼ÀS¤öÀƒÀ,]À·Â[ÀÓMhÀï3dÁšÀÁàÊÁ"v2Á1$?Á?×FÁN°Á]LAÁl&OÁ{"@Á…,ÁŒ³LÁ–lÁŽêkÁ‡oÁñ Áq(Áb×ÁSQÁD«ÑÁ6 ÒÁ'u¤Áü¶Á ÅÅÀùoPÀÝz°ÀÁõ½À¦Ï¸ÀŒ?ÀexÀ1“$Àðÿ¢5j¿ ˜ˆ>s?Câ±?¬Ýñ?ñ€@©Š@1Ñ…@I-u@\YÉ@jB‹@s³ç@x´Æ@wÝñ@u@mº‹@b=5@Rf5@;M@ ɱ@ÒÎ?Ç¢Ý?~a>¿þÕ¾ŠÙp¿uo^¿ÕƒÀà»ÀKÂLÀ~¹À™n5À³ë]ÀÏgKÀêþÔÁ|!ÁÜÿÁ m+Á/\Á=Ù$ÁL—+Á[^^Áj@±ÁyF^Á„4«Á‹ÎþÁ•äðÁŽ^ÂÁ†àÄÁ~ÐÁoß¿Á`ïÁR¬ÁC@±Á4°;Á&MŠÁíaÁ •Àöã¹ÀÚåýÀ¿!TÀ¤UÀ‰¾ªÀ^¶ðÀ+7W¿ôp­¿”Jê¾ées>env?^`y?»èí?ÿ®M@Y¦@9Tµ@PÝÝ@cÃÒ@q©-@|‰-@€Pù@€_x@}UÜ@vö•@kD¶@ZdË@DQÇ@(Üä@ 5å?Ô ‰?û>ôbϾ+y¿Yþ¿È¡ÀpVÀD ¨ÀvDƒÀ•ÒHÀ°‚àÀË™‘Àç^hÁùeÁ\ÛÁ¶ÆÁ-E$Á<pÁJèÁYÑeÁhÃsÁwÔ Áƒv‚Á‹Á•wÖÁñ‹Á†s=Á}ïÝÁo_Á`.ZÁQhÁB¤Á4 ]Á%ÁÁ±~Àõ$dÀÙN¿À½{~À¢ üÀ‡œÊÀZ†À(Ú¿ì8¿Â ¾Éåë>œ(4?n“³?Å@$Õ@$@™@?5ý@V†~@iCÚ@xb@J)@ƒÝ,@ƒÉ @‚ž@}~Ñ@r Œ@`³d@K]I@/Ù²@gÌ?àA¶?˜v&?öo½‡ì¿B µ¿¼UŽÀ ¶À>r4Àpæ(À’vÀ­2êÀȼ·ÀärVÁDÁ”²Á5äÁ+÷eÁ:·¶ÁI{bÁXYÀÁgR”ÁvhÁ‚Ã(ÁŠSÉÁ•2+Á©.Á†-øÁ}~Án¢.Á_ưÁPëžÁBØÁ3uyÁ%1Á ÁC Àô$«ÀØ„À½{À¡–ŽÀ†ÖªÀYLªÀ&䉿黿ŠÖí¾º!+>¬âÙ?y!û?Ì"@bU@(¸9@Cà9@[8l@mø„@|³z@ƒåæ@†bÒ@†| @„Ç´@¢(@w€ÿ@fhH@PÆÒ@4ô&@}R?ëXF?£e&?+«{¬o£?}MV?Î-‹@ ’ö@*½@F;Ø@]Ÿç@pb¸@iù@…\m@ˆ+@ˆœP@‡Aµ@ƒËð@|ª—@k‚S@U¹º@9ëC@@U?ôÉ!?­†ù?A{;=Ñ¿Á—¿§mÀF¢À4ùÏÀh+ùÀÖÂÀ¨›ÐÀÄJçÀà ÷ÀüAÏÁ }BÁ Á)¡CÁ8[cÁG¡Ñh?z]¥?Í@ ©{@*O®@FáR@^!ì@q^!@€WŒ@†#´@ˆÛÖ@‰µ•@ˆŠ›@…—@§¡@n‡\@YÏh@>*D@¾L?üuÃ?µ>G?Ney>$P¿. ¿Ÿõ´À‡À1L÷ÀcξÀŒy2À§4ýÀÂÊþÀÞžÕÀûîÁ Ñ#Á\Á(ìÁ7‡7ÁFRÕÁUJÕÁdYÁshVÁ’,Ò?pdK?ɸ@ÿ @(׊@EÚ @]Šú@på¨@€P³@…‰i@‰2ä@‰ÿP@‰A™@†½ê@€¤¡@o»O@[CJ@AB#@!»š@DJ?·xÆ?Xz.>9Y#¾ýš‘¿œÒ(¿üYœÀ0ºÀbtÇÀ‹ƒ‡À¦wóÀÁ½xÀÝÏ®Àú/ Á IðÁ¸LÁ(nxÁ7;{ÁF}ÁTß“Ác×Árë4ÁKÁˆ’Á•ÅÇÁŽOŸÁ†ßóÁ~â÷ÁphÁae£ÁR¸ ÁD pÁ5^ÓÁ&À[ÁaÁ 0ÇÀødÀÛ×`ÀÀ–»À¥˜uÀŠÇ ÀaæCÀ.cg¿ú‚¿™Ê©¾ð@¼>dè?`ã ?Áp}@‚F@%i}@BPA@Zr@mÚ´@|í˜@ƒõ$@‡­@‰ *@ˆ«K@†!×@€-@nÞ @[‰§@B@@!âv?ÿ%W?µ,î?TE§>6ô®¿©ö¿œÝF¿ýSbÀ0Àc¥àÀ‹­ÖÀ¦®iÀÁïMÀÝzëÀú+Á nÁÛvÁ(eAÁ7!ÁEäÁT¶ Ác ÒÁr­¯Á€ëæÁˆˆÁ–IïÁŽØ7Á‡gÝÁ÷Áq:êÁb‚£ÁSÊ]ÁE(ÔÁ6«Á(-ûÁÐËÁ ŸÀû8ÀÞä½ÀÃ^rÀ¨X ÀšÙÀfåóÀ3ÎîÀsr¿¤¾¿]‰> 2Â?J‹?³•M?ýKø@*`@<Ú@TE}@gÔÖ@v–†@€éy@„9ì@…n@…uã@ƒ´@|™]@ló„@ZI\@A›˜@ ’ ?ùV?¯â±?D±r>þö¿n0¿¤ÓÕÀmFÀ3® Àf tÀOCÀ§Õ¦ÀÃ^4ÀÞ÷…ÀúãíÁ ȹÁ5ÞÁ(· Á7ZûÁF4ÁU'EÁd ÁsQÁÁˆ¦Á–ÜeÁhÀÁˆRÁ€¨[Ár¡ÁcòhÁULÔÁFÄŠÁ8@Á)ÑÁ8Á TïÀþqÇÀâf²ÀÇÀ«íŸÀ‘WwÀnÆÏÀ;Ò<À bq¿´=¿0‡Ö¹ nq?'(Ô?¡´?êó¡@â@2”`@K;Ä@^£A@l¸³@w);@|ÕW@Á@ƒ£@|­Œ@u ó@f¿[@RË@8Ú²@æi?éaç?¡G7?&]b<Ó ¬¿*ÀÁ¿°(ÀÒJÀ9TÀk×Àã{Àª=UÀÅ]lÀá7èÀýTÁ °WÁ0©Á)É@Á8cìÁGvÁUðQÁdÔ8Ás¹vÁWiÁˆáÁ—œéÁ3ŸÁˆÔþÁxýÁt:eÁeiÁW >ÁHžÁ:1ùÁ+Æ¢Áp€ÁR3ÁKmÀæäÎÀËšÀ°dÀ–‰Àwý%ÀEÚ/À!u¿Ê$Ò¿Zk¿¾.ýa>óo?‰í`?Ðý@ 06@&3ó@>âÌ@Q=@^ç¬@hy|@mv@oóñ@pÅ@nin@gv @YeÁ@F¦Ù@,Ü×@ ¾?ÓFu?ŠF—>ô{+¾ óû¿QXG¿ÂrïÀ¥ÈÀ@µ:Às´ãÀ“€»À®ÜÀÈÛ ÀäMÁ%Á)+ÁnÐÁ+CÁ9¯>ÁH\8ÁWºÁf§Át÷¨ÁúnÁ‰$Á˜yÁ‘ÉÁ‰ÂyÁ‚tÁvK„Ág®âÁY+þÁJÈOÁ…?W4Í?²­?ñÊÞ@.v@-N%@?²@LBw@U~@Zêq@\Ã-@]-Ž@\»@Sõ»@Fpl@4k@pˆ?öRZ?³ö?YK£>‚=ܾºˆ¿ƒg¿ÜÊbÀ¢ÎÀLj(À~+“À˜§åÀ²ì“ÀÍæ“ÀèôÕÁjÁ{±Á©²Á-îÁ;|=ÁIþÁXœíÁggËÁvYQÁ‚±ÒÁŠ7ÈÁ™ƒÆÁ’*îÁŠØFÁƒŠÁxŽ’ÁjÁ[£¦ÁM2Á>ìŠÁ0¶ÔÁ"‚4Áw…Á¶äÀñýØÀÖï+À¼tlÀ¢PðÀˆÛZÀ`[À/îŸÀfµ¿©IF¿)0?½‡:? ^Ö?ŠZ©?ÈPÂ@-)@G@)§Í@5\•@>Ôú@Cçð@F‹Û@Fõê@EF]@=ÿ3@/™Ë@xÈ@ž¡?Ε\?¥»?kØ»Æ©ê¿ 6¾¿£Xпük¾À+œ±À[ŽäÀ†(ÀŸ¬À¹1 ÀÓÒ/Àî—}ÁìhÁ0Á!0±Á/gÁ=ØèÁLawÁZëeÁiŽþÁx][Áƒ¥ÌÁ‹"ÁšªKÁ“Q†ÁŒ1Á„É!Á{[Ál¦9Á^AžÁPüÁAÉiÁ3‹SÁ%€ñÁ¤=Á çšÀø¥×ÀÞÌÀÃeÀ©âyÀßÎÀp²1ÀAÀ/¿ÏüÓ¿zf„¾¼eÆ>J;:?6ç?—ü¸?ÍŠ?úß~@ÿì@y(@$G)@)„‹@+ä)@-ž@*ç4@#"ï@˜‚@Ðì?ئí?¢ö²?K 1>‰aϾ Œ¿o2j¿ÊÍLÀn3À=— Àm;ÛÀŽÁÕÀ§j8ÀÁ)×ÀÛfÜÀö:aÁŸÁ_gÁ$GûÁ2lÁ@³ÆÁO,¦Á]¨hÁl&ýÁzÈ)Á„ÈçÁŒ>ÃÁœþÁ”µÏÁnÁÁ†,%Á}ß Áo€§Áa<™ÁRü(ÁDØÁ6ÚØÁ(ݸÁùïÁ rÊÀÿõÔÀåšäÀËÞ À²FÀ™ìÝÀâ–ÀUHwÀ)/¿üü㿪.¿=PоQÎë>Ê ?Aí5?•Ú?À?ãß?üÃÜ@,€@ @f@@ im@é?ñCî?Ë}ê?žM:?YPQ>Å’(½®ŽŠ¿(ií¿¤œ’¿øàÓÀ'-›ÀS jÀ€™ÎÀ˜°4À°à°ÀÊ#öÀãö«Àþ3(Á ÅÁKÁ( åÁ5ÛwÁCèZÁR<¡Á`ãÁoPÆÁ}ÝéÁ†=IÁž{ÁvÁ–+sÁŽïòÁ‡ÄäÁ€›÷ÁrïÁd²FÁV~ÁHaÃÁ:oÈÁ,·oÁ-Áº7ÁnÀîâkÀÕPÌÀ¼|áÀ£õÀŒÄ…ÀkÞ‰À@4åÀz5¿ß +¿“Ø¿!›>¾ËÈ>”Ò•?.}?‚Ÿ?£(³?»êà?Í¢\?×–ý?Û@Ý?Üá?Ù 2?Ë›Ê?°­?Œ¦?@3y>¹nÀ½c5º¿x¿…, ¿×LÀT¹À@7¨ÀkˆèÀŒc¡À£}ŽÀ»{ÌÀÔÍÜÀî5ÁÒŒÁÞÁpÁ,DëÁ: ÁHÿÁV#ÁÁdb“ÁrÕqÁ€«Á‡ërÁ4 ÁŸ,†Á—åˆÁ¨4Á‰ylÁ‚]ÎÁv޹ÁhjPÁZP ÁLaÁ>·µÁ1$yÁ#šìÁ=$Á 98ÀøäÓÀßýJÀÇX—À¯™–À˜VKÀ‚5µÀZ®À0û˜À Wô¿Ï_¿Žg¿%÷}¾\)>(ÇÏ>û&š?>"°?mÏ ?‡Ç?‘…"?–Q×?”ùã?‘hà?„ÜÂ?W]÷?ŸÒ>nů¾) û¿t¿ƒÉ¿ÅˆÀ~À0™›À[}µÀƒ"øÀ™ ßÀ°HÀÇ¢ÝÀàjÀùnNÁ vòÁsÄÁ#ŠlÁ0ײÁ>tÁLcdÁZsPÁh‡rÁvµÁ‚ŒÁ‰Ñ~Á‘ÓÁ ùdÁ™ºGÁ’ŒÜÁ‹v]Á„p>ÁzÔÞÁlÉ>Á^ØùÁQ%’ÁCy:Á5Ð"Á(XÑÁ\[Á¯]Á àÀë7õÀÓròÀ»ÍXÀ¥0QÀ!Àv*ÀMãÌÀ)ÉÀì.¿Ï±â¿•<¿A8Y¾Äœ€½šÓ‡>,ƒ>µ j>öG?Y÷?\!?xo? ó>Ýíy>ƒ¦Û¼ Hо¯¬v¿7â¿’;¿Í:óÀ À'ÉÀNB¹ÀwèåÀ‘|­À§YrÀ¾7ÀÔ÷˜Àìê“ÁÀœÁ3"Á3ëÁ)OÏÁ6lÁC©±ÁQ@àÁ_)ÐÁm=XÁ{\}Á„¿ƒÁ‹äÁ“Á£–Á›æ§Á”ƺÁµÈÁ†°cÁiØÁq‚jÁc¸IÁVÁHˆwÁ;FÁ.=>Á!g¡Á Á ÀøÀàŒ ÀÉ™ÏÀ³½ÀžÎÀŠ ÀnRSÀIãcÀ)@‚À ài¿Û¹‡¿¨€-¿w9S¿))޾ܾ‚K³¾…<½x[=¼Îp+½"x)½°ð¾GJÞ¾¿œ×¿C5¿oet¿¨=û¿Ý 1À s¥À*°SÀL¾]Àpí²ÀŒ`À ìŠÀ¶‡ÃÀÌŸðÀãyÛÀúžVÁ ÍÁçœÁ"m³Á/W3ÁÀsÀUxóÀ9»bÀ!ðÖÀ Q¿ö4l¿ÙßO¿ÅÁ ¿¸…%¿±•¿®+½¿¯”Å¿¶$•¿Ã@¿ØS¿ö ÏÀ ‡À#•ýÀ<¬"ÀX—{Àw$´ÀŒ´ÀO¢À¯­¢ÀÃNVÀ×~À쯷ÁOþÁ ·+ÁE]Á$OéÁ0€Á<²[ÁI=fÁV=ÁcmõÁp¥Á~°Á…×—ÁŒ¨Á“…²Áš~äÁªƒ–Á£„ÈÁœŽñÁ•œáÁ޽»Á‡çÎÁ*ÁuÓÁhùÁ[ÌÁN_ÁAp¢Á5W2Á)ýÁϪÁ#dÁ"ÉÀù½ÀäsÀÑ0{À¾N8À¬÷–ÀœiÀŒüŒÀ|÷!ÀbÕ9ÀJ] À7ÆÀ&OÀõ>À²ÚÀM/Àß-ÀÿÀ›ÌÀãÈÀ1|À;¦À&býÀ8r³ÀM¥YÀeL5À€gyÀyÒÀŸ¶>À°ÅÏÀÂÆíÀÕÛ\Àé¯IÀþ‹>Á ß¡Á iÁ bpÁ,Á8"ÁD1ÁPŸÁ]CÁj<™Áw])Á‚F›ÁˆòñÁ¿ÁÁ–—ÆÁvÁ­M¯Á¦YÁŸy{Á˜ŸÅÁ‘ÇpÁ‹¨Á„c(Á{ÍmÁnáFÁbúÁUÁÁI2cÁ=#YÁ1[«Á%¿åÁŒ;ÁõÖÁŒÀöºÝÀãÃ¥ÀѳYÀÀœÀ°LÀ¡+—À“1À†~OÀvß±ÀcLtÀSšÀF"À<&$À5•UÀ2ÄÀ1»ÅÀ2ÔðÀ55§À<+ÀGXÿÀTp³Àe˜ÀyhpÀ‡ýÅÀ”6tÀ£êÀ´ ²ÀÄŽÁÀÖ*ðÀèìmÀü;äÁiBÁá6Á¢ÙÁ(âÁ46yÁ@ÝÁL}ÁXFDÁdßýÁqŸÁ~‚XÁ…É"ÁŒSdÁ’úKÁ™ÂÁ ¡^Á°?ÜÁ©hôÁ¢˜ãÁ›ËéÁ•ÀÁŽlûÁ‡ÞØÁeÁv ÉÁi¤xÁ]OVÁQ8ÁE¤Á9žƒÁ.h¥Á#epÁùÁ¨lÁâ À÷¤sÀå’µÀÕœÀÅoRÀ¶ÂƒÀ©ÛÀœ,æÀ‘÷ëÀˆ.pÀ€ÎTÀt#›ÀjÁïÀe:ØÀa|ßÀ`ò Àa¯€ÀeC2ÀlWrÀv†ÉÀàÀŠIÀ“‰ÀžwWÀª …À¸ŸžÀÉÀÙVÀêü¡ÀýŸÁ®Áö–Á;7Á&ÛzÁ1ËÌÁ=™ÁH‰¥ÁTpŽÁ`‚ðÁl·bÁyJVÁ‚ÿ,Á‰gcÁíÁ–ƒhÁ-¿Á£æÁÁ³|Á¬¯ôÁ¥å¦ÁŸ1ÖÁ˜Š„Á‘ê¥Á‹jIÁ…ÁÁ}ÌžÁq¶Áe< ÁY33ÁM³6ÁBw@Á7KˆÁ,¼Á"€PÁsiÁÚÖÁøxÀú Àê²ÀÛF÷ÀÌ‘À¿ ,À³xÀ©sðÀ  À˜º{À’UÀqÀŠÙ¬À‰-[Àˆã¿À‰_ôÀ‹2ÀŽVíÀ“ØÚÀšpÀ¢8nÀ«ŠÀµÝÅÀÁ¢‚ÀÎÑ4ÀÞhÃÀîDàÀÿÌ,ÁÌÀÁ8÷ÁщÁ%è4Á0> Á:ö–ÁEùîÁQlýÁ\î7ÁhÕ‰ÁtøÁ€–˜Á†ÞkÁ4ñÁ“•+ÁšðÁ ½þÁ§nÄÁ¶È#Á°™Á©UxÁ¢²˜Áœ›Á•ÁG Á‰ŸÁ‚óÁy®íÁmµ|ÁbMÁVÌ2ÁK¬›Á@â:Á6`_Á,UUÁ"s=ÁLkÁ€eÁsÁDÀñNQÀã ÀÖÁØÀËTNÀÁ/£À¸YÀ± ÐÀ«!–À¦{5À£ððÀ¢DiÀ¡´’À¢² À¤ˆ­À¨$fÀ¬é[À³±Àº€®ÀÃúÜÀÍòÀÙ9©Àå³iÀô•Á?"Á  ÁoíÁ™AÁ&bÁ/ìÅÁ:4;ÁD¯"ÁOMûÁZtáÁeô»Áq€¶Á}q’Á„Å5ÁŠßLÁ‘&ºÁ—ƒ…Áä®Á¤dsÁ«ÏÁº.OÁ³‰Á¬öPÁ¦m\ÁŸõþÁ™˜;Á“QÒÁ%ÁÁ‡Á sÁvxCÁk%,Á`ÑÁU,ßÁJ›ªÁ@qXÁ6œÁ-ÃÁ$ 8Ál@ÁL|Á kÁpïÀûo9Àîå”Àã×TÀÙá"ÀÑ“¡ÀÊ+¶ÀĉQÀ¿ôŒÀ½ À¼ À»¸xÀ¼¸íÀ¾sgÀÂüÀƵÀÌ‘«ÀÔÀܯóÀæâµÀñØuÀýš Á¤9Á ±ÁæÁw\Á'i(Á0¹CÁ:S>ÁDS¹ÁN¡'ÁY7Ácü[Áo=ŠÁz±îÁƒ"±Á‰WÁ,ŸÁ•M\Á›’WÁ¡ò Á¨ToÁ®ÏUÁ½ÚcÁ·TžÁ°ÖûÁª`ëÁ£õuÁžoÁ—k9Á‘d+Á‹m…Á…ƒ$ÁžìÁt‹ Ái‡1Á^þñÁTÔ`ÁJÍyÁA9Á7ìiÁ/<[Á&îÒÁäÁ^#ÁxøÁ ­WÁÂHÀüo¹Àó $Àë “ÀãþyÀÞÑ¿ÀÚsˆÀ×ÀãÀÖÀÖÊÀ×\ÀÙ)^ÀÜn2Àá»ÀæïÀî2aÀöd‡Á<òÁµùÁ x©ÁÊ÷ÁBÁ!OGÁ)®Á2ZàÁ;ŠÒÁDÞºÁNÃ|ÁX¾rÁc'ÁmÛ™Áx·-Á‚°Á‡»/Á†ÑÁ“†ÍÁ™¦}ÁŸÖpÁ¦fÁ¬iDÁ²Í0ÁÁÀÁ»BCÁ´ÍVÁ®^uÁ¨zÁ¡ÔÁ›ËËÁ•Û0ÁñÁŠ5Á„£¾Á~0{ÁsƒÍÁiQjÁ_*ºÁU^yÁL*]ÁC5ˆÁ:¿žÁ2ŽƒÁ*ßÁ# çÁ¸ZÁ)­ÁZZÁ žÁ\rÁ}VÀþ0¹ÀùnðÀôû…Àò›ÀðñÉÀñÄÀò'!ÀôŸÀ÷¤¶Àü¾ÁËÎÁ8¸Á]ÚÁ 3®Á‘ŠÁ?'ÁŒÁ%wLÁ,íÎÁ5,ÅÁ=˜ÇÁF™EÁOÌ#ÁYXmÁcLºÁmUàÁwæ&ÁP«Á†ÊËÁŒ{*Á’2—Á˜ÁžNÁ¤0ÁªcÁ°—YÁ¶á´ÁÅ­‹Á¿:ÓÁ¸ÙXÁ²ŠÉÁ¬Z$Á¦Q Á e‘Áš|Á”±ZÁ'Á‰ŽTÁ„.™Á~ ,ÁsàÁiã£Á`—ÁWˆÆÁNÜTÁFW÷Á>ˆRÁ6ø¾Á/îÁ)+vÁ"ûfÁ+Á5MÁ£ÁÖéÁ ›Á >Áþ”ÁÉÁ`Á;þÁ»ÁßçÁ ‰ Á ¯<ÁFxÁŸ¾Á›¢ÁQÖÁ}¦Á%”Á+^íÁ26—Á9+þÁ@þÐÁId€ÁQýàÁ[&Ád]Án#¥ÁxOÁ!ôÁ†s@Á‹ÔÁ‘ZKÁ— ^ÁœÃÃÁ¢œŽÁ¨ÞÁ®¿âÁ´ñhÁ»"üÁÉ´MÁÃaßÁ½"ŒÁ¶öÁ°êpÁªú:Á¥žÁŸ4áÁ™‡‡Á” àÁŽ´µÁ‰q1Á„SîÁ~´,Áu,ÁkôÁcÎÁZ•AÁRhàÁJÂàÁCIDÁú‚ÁEÀýÁM,ÁULæÁ]®XÁf´Áoª)ÁyuÁ{ªÁ†ŠÁ‹§ÿÁø5Á–iùÁ›òûÁ¡™*Á§^ÜÁ­FâÁ³@sÁ¹TíÁ¿ƒÆÁÍõýÁÇÃmÁÁ—0Á»†Áµ“Á¯¤°Á©ÃTÁ¤²ÁžŒßÁ™;²Á“ñ×ÁŽ»ûÁ‰ÅwÁ…ßÁ€MéÁwpDÁnìCÁf±NÁ^ÛÁW3¸ÁP³ÁI1åÁBѧÁ<Î;Á7wCÁ2—Á.”xÁ*ðSÁ'ªZÁ%gÁ#¨IÁ"„JÁ!ägÁ!ýÄÁ"aÁ#ÈÏÁ%g;Á'nÁ*.‘Á-W›Á0ñÅÁ5Q×Á:úÁ?>rÁE$ÁK½2ÁRr¬ÁY…XÁasÁiœ#ÁrNÁ{!]Á‚áÁ†íåÁ‹úÝÁ‘mÁ–.Á›ƒ4Á¡ZÁ¦ïÁ¬0yÁ²jÁ·òçÁ½è-ÁÃôÓÁÒeŠÁÌ84ÁÆ"±ÁÀ-{ÁºE™Á´hpÁ®¯Á©$çÁ£ÌRÁžÁ™?›Á”7GÁpÁÁмíÁ†ÙÁ­­Á{Ás {ÁkR9Ácã³Á\ü©ÁV5¥ÁPÅÁJ-ÄÁEšÁ@HRÁÕ§ÁC QÁGÑpÁLç±ÁRczÁXÆqÁ_^·ÁfÁm¬ÙÁuÏŽÁ~ÁƒeÁ‡ïÁŒ_Á‘sÛÁ–‡Á››Á ÃBÁ¦$ Á««uÁ±5LÁ¶ÝdÁ¼°ìÁ¤£ÁÈ›`ÁÖÜ(ÁÐÆÁÊÑâÁÄôÞÁ¿!Á¹d.Á³ÓdÁ®r9Á©&6Á£Þ€ÁžÅ*Á™é{Á•/YÁ„ÁŒ %Á‡ÄªÁƒ¦*Á‚~Áw×rÁpÌ/Áiè¦Ácn»Á]x?ÁWÖÁRÓÁN$ÁJ\ÖÁF¸¦ÁCè…ÁA™¯Á?Ö•Á>Ð}Á>A,Á>8Á>øÁ@VÁAóbÁDâÁF‡~ÁId^ÁLáBÁPÖíÁUŽ3ÁZ›_Á_ßÔÁeÛÌÁlpšÁsrÁzE%ÁÁ…)8Á‰Z×Á×oÁ’d¦Á—7ÁœÌÁ¡'æÁ¦;uÁ«pWÁ°Ú¨Á¶dhÁ»ðiÁÁœÞÁÇr+ÁÍfãÁÛzOÁÕ…ÝÁϰHÁÉåJÁÄ(%Á¾“dÁ¹&šÁ³ÑœÁ®Š Á©jŒÁ¤|ÙÁŸªöÁšõ…Á–xµÁ’#¨ÁßÁ‰äÁ† UÁ‚VüÁ}Ã<ÁvîÓÁpÎZÁj÷‹Áe™]Á`IÁ\ïÁXE¬ÁT½‘ÁR­ÁO§‘ÁN'xÁM^ÁL¡NÁLzàÁM:xÁNvÞÁP>ÐÁRZìÁTÝÌÁW®¤Á[UÁ^áQÁcTèÁhOÁm‰Ás=ÁyƒÁ€¡Áƒ‡´Á‡[ŠÁ‹YÊÁoGÁ“ÂÊÁ˜M¢Áœì_Á¡¶&Á¦»’Á«ÐÁ°ðaÁ¶/Á»ŸzÁÁ)ÀÁƼÁÌkîÁÒAÁ뺌Áåæ¹ÁàÁÚo#ÁÔÍ<ÁÏ@ÿÁÉÞ˜ÁÄ¡—Á¿nÁº[‚Áµ~îÁ°ÄÁ¬ÃÁ§ƒJÁ£;¼ÁŸ&¬Á›%¥Á—l¢Á”’ÁÁmÁ÷ÁŠ»`Áˆ2ÄÁ…Ù ÁƒÇÉÁÜZÁ€GÁ}§ÂÁ{8ÁyG‡ÁwÛÚÁvº²ÁuÄ(ÁuUKÁu¹ Áv`”Áwª¤ÁyPyÁ{‘iÁ~/ëÁ€ºaÁ‚ˆÏÁ„§ÝÁ†ÙhÁ‰PÞÁ‹ógÁ޵ŸÁ‘ÃèÁ”ñúÁ˜eÁœ+ÁŸèéÁ£ý¤Á¨?¯Á¬‹LÁ± ;ÁµÌ[Áº´íÁ¿»pÁÄâêÁÊ,œÁÏ€ÁÔøÏÁÚŒèÁà7ÐÁæà¨Áá…ÁÛ.¤ÁÕe ÁÏ¿†ÁÊ'TÁÄ¢ŸÁ¿J™Áº 0Á´ÖÁ¯ÒpÁ«ðÁ¦MGÁ¡«Á@ËÁ™&Á”ôƒÁ‘ÙÁˆÊÁŠ43Á†ÿpÁ„ °ÁwçÁ~.Áy¶¥ÁußüÁr}(ÁoŒçÁlð•ÁkZÁibÁhaÁg˜Ág1Ág˜4ÁhGîÁiqMÁk&ÐÁmUlÁpQÁsRÖÁwÁ{YÁ€ÛÁ‚KÁ…A-Áˆ.ÌÁ‹FÁŽƒ1Á’Á•èCÁ™×#Áž ´Á¢QñÁ¦Å´Á«kÁÁ°8 Áµ'¯ÁºIÁ¿“CÁÄâ2ÁÊPáÁÏéÁÕpÁÛioÁâ2ÁÜ5ÔÁÖU>ÁÐBÁʺÞÁÅìÁ¿‚½ÁºÁ´¹³Á¯}ÁªUºÁ¥^–Á ýÁ›ÞpÁ—bÁ“¬ÁŽíVÁŠä¶Á‡1¦Áƒ¶ÇÁ€ueÁzýOÁuêÁp”âÁl ðÁh XÁd”Áa~èÁ_ÔÁ] ¯Á[o8ÁZ16ÁY”oÁYAMÁY²æÁZglÁ[mcÁ]3"Á_RcÁb3ÂÁekOÁiWóÁm’úÁr€•Áw¨EÁ}_qÁµÁ„Ù,Áˆ>ïÁ‹þÌÁÙTÁ“ÜlÁ˜ªÁœ‡ÄÁ¡%»Á¥ÓGÁª«Á¯¾Áµ@ÁºRÝÁ¿¸¹ÁÅKÏÁËŒÁÐܧÁÖ¶†ÁÝ™Á׋ÎÁÑ—qÁˬçÁÅÔ±ÁÀÁºtÁ´à°Á¯nÂÁª-Á¤ûêÁŸå™ÁšíþÁ–=Á‘ˆ†Á2ÁˆîãÁ„ÙÑÁ fÁzËNÁsôæÁmøîÁhmæÁc)Á^‚€ÁZm;ÁVÐ[ÁSŒãÁQ7âÁO ¿ÁMyaÁL;ÄÁK–ˆÁKZ»ÁKÙgÁL™ÈÁM²dÁO}òÁQ˜GÁTŠ;ÁWÎ+Á[¼3Á`¦ÁejÁjeåÁpVÁv‚¯Á}(sÁ‚!tÁ…÷Á‰ÓöÁçÁ’J Á–æmÁ›‹"Á LOÁ¥M-ÁªˆBÁ¯ÙNÁµ6ÖÁºÂ{ÁÀz^ÁÆPÁÌ)&ÁÒ£ÁÙ"ÁÒöŒÁÌêéÁÆùÐÁÁ :Á»(šÁµi6Á¯Ò³ÁªO¾Á¤è²ÁŸ¬÷Áš~Á•yÁ‚uÁ‹Ã5Á‡RGÁƒ±Á}¦=ÁuìÁnŠÁg^ßÁaJÁ[ipÁUè<ÁQWÁM ÉÁIXSÁEçÁC{^ÁAC·Á?¼ŠÁ>„mÁ=¤”Á=yîÁ=ÿéÁ>ÌyÁ@#!ÁA÷ËÁD.5ÁG$ÁJ…pÁNYPÁRä§ÁWÃ#Á]h$ÁcYüÁiètÁpÀ‚Áx,ÙÁß¡ÁƒÜâÁˆ'ÁŒ«¥Á‘U…Á– RÁšû©Á 'Á¥xDÁªÏTÁ°QÓÁ¶©Á»ÏÁÁ iÁLJ%ÁÍ’9ÁÔá(ÁΔœÁÈfíÁÂTúÁ¼]ªÁ¶ngÁ°Š´ÁªÏÇÁ¥DoÁŸÕÈÁš}éÁ•8\Á\Á‹AÁ†72Á•ÚÁzznÁqàtÁiÓýÁbuÁ[.(ÁTŠ>ÁNwYÁHôÁCÎ Á?²*Á;õ(Á8 aÁ5ï>Á3¼ãÁ2ÈÁ0Õ¸Á/÷ÓÁ/ðÁ0%ÜÁ1¿Á2”øÁ4[Á6ÖÕÁ9Þ“Á=kKÁAUÈÁEìkÁJçôÁPœ»ÁV´ Á]z²ÁdzÁl#LÁt JÁ|9zÁ‚†Á‡ þÁ‹Ö0ÁÃÁ•ã~Á›)ÎÁ ~”Á¥û‡Á«§UÁ±gLÁ·-AÁ½ÔÁÃäÁÉGúÁÐÁ¥ÁÊcÁÄ´Á½â¢Á·ÄÁ±ÁáÁ«ÙÁ¦3Á OYÁšÎRÁ•qrÁcÁŠØ'Á…ÂÁ€ãBÁx2ÖÁo9rÁf•vÁ^(LÁVz(ÁO^ÁH:>ÁAê(Á<>ýÁ7 ÎÁ2™æÁ.¥NÁ+“Á(’øÁ&@¸Á$–üÁ#;äÁ"¡•Á"fHÁ"‚ëÁ#•GÁ%xÁ'zÁ)‚IÁ,º!Á0R„Á4{ÙÁ9$5Á>uCÁD§ÁJvzÁQ#ÁXuÒÁ`oÁhÁqkÁyù¡ÁŸ_Á†‹hÁ‹­ÁÝ‚Á–/dÁ›ªxÁ¡VÁÁ§ŠÁ¬ÔïÁ²µÁ¸½&Á¾êCÁÅ8óÁÌ·˜ÁÆA:Á¿èuÁ¹¥·Á³e~Á­92Á§1Á¡SµÁ›“^Á•í-Áo0Á‹#Á…¾ÝÁ€›Áw@=Ám¨ŽÁdE”Á[ÁRí(ÁJÄÁC9ÇÁ;ÿ Á5¶ƒÁ/ݨÁ*£aÁ%øÉÁ!³ÁbÅÁpÁò(ÁSàÁfÁo{ÁHWÁU²ÁgÁÆ`ÁËáÁ9ÁÁ–™Á#_Á'©®Á,ž‚Á2ÃÁ7óuÁ>rÁE:ùÁLÛÝÁTÖËÁ]HyÁf½Áo ¾Áx´çÁwÁ† ÿÁ‹àzÁ‘YiÁ—iÁœ¿OÁ¢‡‹Á¨r“Á®}‡Á´©¬Áºù<ÁÁc{ÁÈçÔÁÂQgÁ»Ö¬Áµ{Á¯5ýÁ¨ò?Á¢Á‡ÁœºÄÁ–ãÁ‘9wÁ‹£¦Á† Á€¬ÕÁvÐ ÁlÁpÁc*ÁY•ÁPzËÁGä×Á?V®Á7,Á0<ÕÁ)®ÌÁ#Æ&ÁGÚÁt´Á5pÁ}ïÁŒZÁ Á !ðÁ ‚ÁWùÁYÏÁšÁ ¯+Á 6Á ÝÁaÁ™Á… ÁèkÁ 0„Á%ÔSÁ+ï’Á2“ Á9ΟÁAS|ÁIwÏÁRLÁ[O¥Ád³?Án»ùÁxðùÁ¤KÁ‡«ÁŒºèÁ’y,Á˜AîÁž7ªÁ¤Q‘Áª1Á°ÈÎÁ·/Á½œqÁÅ7èÁ¾˜Á·þÖÁ±XÁ«$uÁ¤ÝÅÁž˜ËÁ˜hÔÁ’dòÁŒ“–Á†òúÁ[|ÁwcÁl¤ÀÁbRËÁXŸÁO¼ÁE˜'Á<ÎÛÁ4>fÁ+ù²Á$¶#Á~ÁÆ×ÁåÁ !®ÁËàÁ ÞÁúæÀÿ ãÀúl‘ÀøRËÀ÷TÀ÷ÀøÀú˜ÀüþÁc ÁAÁ2ÒÁ ™Á™ÎÁÎ#Á­ÒÁüèÁ'#¥Á.rÁ6bÁ>¬qÁG¹fÁPúøÁZÎ Ádí-Áo2zÁyå9Á‚ðÁˆUŠÁŽ Á”Áš-AÁ \{Á¦šhÁ¬ú†Á³m:Á¹ôæÁÁ«åÁºõJÁ´IqÁ­­’Á§-©Á ÐAÁš‹AÁ”TêÁŽ'ŽÁˆ#Á‚TƒÁym Án:OÁc‹ÁXJÁÁN1æÁD–ßÁ;Á1ÁPÁ)H"Á!çÁpçÁ·³Á 0ZÁuÁ/ÊÀù>¡Àñ—âÀë7ÀæiÀáÎìÀß@çÀÝóKÀÝñEÀß½ÀàÕäÀãö;ÀèÞÀíbÃÀô6,Àü¹ÁÄÁÁõïÁ ­»Á~ªÁßñÁ#_Á+wƒÁ4,lÁ=I{ÁG ÛÁPóCÁ[MfÁf–Áq'-Á|<Á„¦Á‰ñ›ÁÕÁ–:^Áœo¿Á¢ËoÁ©JµÁ¯ÚaÁ¶oÁ¾4 Á·y…Á°À=ÁªŒÁ£dPÁœàŒÁ–xÁGøÁŠáÁƒæûÁ{†Áp+ÖÁdõÍÁYâàÁNì·ÁDa¥Á:Ž7Á0æFÁ'K?Á{¼Á}±ÁãÁ€WÁÆFÀõ6{Àêþ¸Àá÷>ÀÙÌÀÒì5ÀÍ£dÀÉSàÀƪüÀÅx‚ÀÅ„§Àƹ~ÀÈ4bÀËfÂÀÏ\¶ÀÕ¿ÀÜ ªÀäÝ®ÀîwýÀù:–ÁtçÁ U´ÁÔ„ÁóÁ!‚Á)ÓáÁ3d´Á=Y§ÁG…‚ÁR`ÅÁ]x#Áh˜ÁsåNÁ²Á…öÝÁŒ)áÁ’dÏÁ˜ÀÂÁŸA¾Á¥Ï¢Á¬fñÁ³ÜÁºïµÁ´äÁ­U[Á¦›ÁŸã°Á™>FÁ’¶ÒÁŒV^Á† Á» ÁsTÇÁgLÃÁ[Æ|ÁP¾¸ÁEÇÕÁ:åVÁ0¬áÁ' Á\Á3àÁ ÛÁúzÀøÜbÀë„ÆÀßœÀÔ\ÈÀÊÊßÀÂFæÀ»°áÀµîÁÀ±zÀ®™À­pmÀ­JÂÀ®]À°seÀ³5ìÀ·cgÀ½@5ÀÄL…À͸À×ïüÀã'»Àï`´ÀüëßÁ3ÁÇÁUÁ EßÁ)ÿôÁ3ú§Á>ŠÁI ~ÁTÔÉÁ`+ÁkÙ$ÁwìtÁ‚%Áˆp®ÁŽÝ~Á•[×Á›èCÁ¢·Á©9®Á¯þ¼Á·ÔõÁ°íkÁªðÁ£4ËÁœwiÁ•Ë`Á5Áˆ«ôÁ‚GÖÁx1Ák‘ÂÁ_0ûÁS;ÆÁGÔÁ<¹ÁÁ1¯Á&üžÁOÁyœÁ vÁ´Àó]fÀãõÀÖl>ÀÉaÀ¾UÄÀ´c_À«ÍäÀ¤Œ˜Àž°Àš…$À—H»À•ÄqÀ•u•À–¨DÀ˜¾ÂÀ›À À¦<áÀ­ý/À¶ÄÍÀÁë™ÀÍ›¦ÀÚu°ÀèÆzÀ÷Ç»Á]°Á q3Á CÁ ²jÁ*êÁ5ö2ÁA_FÁLÍÁXA§Ád™Áp\wÁ} Á…kÁ‹}éÁ’èÁ˜¡®ÁŸ]ŸÁ¦!Á¬ëiÁ´ØaÁ­ÜqÁ¦ñÁ }Á™%`Á’aÁ‹½þÁ…/?Á}FÁpsâÁcóåÁW„”ÁK»¿·ÍS¿Æ–I¿à@ÉÀê³ÀBÀ+¾ÀD1À`<ñÀeÓÀCÀ¡yÌÀµ4ÇÀÉkfÀÞ4(Àó—2ÁFxÁLÚÁuÁ)íåÁ6ˆ¡ÁC•$ÁPʆÁ^.Ák  ÁyyÁƒ¾ºÁŠÂ Á‘ÎdÁ˜îKÁ  Á¨5üÁ ðŽÁ™¼ÍÁ’˜?Á‹xªÁ„^zÁz’©ÁlŒÁ^½¹ÁQ6<ÁCÉ…Á6k1Á)J\ÁNsÁK0ÁY‚ÁfäûÁtàNÁlÁˆvNÁš<Á–Ò»ÁžÁ¦9\ÁžáNÁ—•àÁ]Á‰5½Á‚ûÁuásÁgÔ,ÁYýÁLH’Á>©.Á1Á#ÄÄÁÛØÁ ÀúùrÀâwèÀÊÝÀ³æÀíŒÀ‰BÉÀl²ÀHwÖÀ) ‰À ¿âò¿´g¿ŒÐP¿Ršù¿ƒ‘¾ØX¾›Pü¾vj‡}¾4¢¾§)ž¾ï„¿:}D¿P!¿ªãx¿Û¢NÀ «À&“ŸÀE¦(Àhã•À†?‰Àš>À®ønÀĦ?ÀÚðdÀòË?Á{½ÁÞŸÁÍ™Á+àªÁ9êÁF‡ÁTT’ÁbI(Áp=¥Á~T*Á†P¹Á‹Á”ÌÎÁœ³Á¤VÆÁœùŸÁ•¬dÁŽmaÁ‡>0Á€ŸÁqÕäÁcmÁUƒ|ÁG¯<Á9çÁ,/XÁÏ!ÁÐ6Áâ»Àð)À× {À¿=WÀ§´À‘©Ày†-ÀPçaÀ.)¬À ¬Í¿Ý˜ý¿¦ÈB¿mn¿T¾¨“½É&‚=ŸÂ0>H€>†D;>€>~?ý>&ù¼î±¾Ï¿Ûµ¿ii{¿¦6¿Û•pÀ H%À,€yÀOñ„Àt¬¢ÀŽfSÀ£^qÀ¸¢ÃÀÏ{HÀç­Á·Á ëÿÁñÑÁ'ÂÁ4aqÁBYÁOç‰Á]žÁkß,Áz.úÁ„P¾Á‹˜^Á’èøÁš:?Á¢ðÁ›@áÁ“êÁŒ›‘Á…_HÁ|e­ÁnÁ_º„ÁQƒÏÁC’ Á5ÆÙÁ(¤Áp<Á 7•ÁEdÀæ®fÀÍÉÀ´ôdÀ~"À†…ŠÀcVDÀ:OÀçÿæTÖ¿©@¿cÚv¿è¾0'.=å%>«ú?V3?& ?:Π??úh?4¸n?  >ÓSm>gȾ-A¿Þ+¿gÁ¿©Ó®¿çòPÀ¬À8EÉÀ]FÀƒQµÀ˜0vÀ®^YÀÆ!9ÀÝÑrÀöŠÿÁ=GÁZÓÁ"›ÝÁ0G‹Á>ÜÁKõrÁYæÉÁhüÁvOlÁ‚`TÁ‰®ÈÁ‘ VÁ˜i½Á¡ èÁ™§KÁ’S³Á‹×Áƒ¼›ÁxèàÁj^Á\2ªÁN°Á?ð!Á2 ×Á$YÁ¥ŠÁ 5üÀøTpÀÞD¸ÀÄô[À¬ÎNÀ”À˜Àz£ÀO»žÀ&@lÀ„ñ¿º/пwÛI¿Àm¾‰4>[ëï?'ÿ?=Ä—?pbr?ˆôn?’16?•Ðß?Žõ:? ?Mbl? /ß>m D½î¡|¿ÿç¿y9w¿¹ ­¿üIÀ!¥÷ÀHQeÀpžyÀxüÀ¤¾éÀ¼eÀÔyÅÀí˜mÁÁ"ÁáZÁwKÁ,\´Á:EÁH-uÁV/ÁdhzÁrÚ1Á€»DÁˆ ¼Á_ÓÁ–¸ÕÁŸ•ñÁ˜.ÑÁÖÁ‰‡ Á‚8bÁu×"ÁgUãÁXùÎÁJÎ^Á<Á¢Á.µ€Á ßRÁOùÁÅxÀñ-»À×KñÀ½ŸÀ¥=—À-8ÀjÑ×À?¶ŠÀ…ü¿Ü¢ ¿• ¿)ÅL¾Wƒ>Nå³?Ä?_ë?ð#?§DÛ?·ua?Á¥j?ÃÊJ?½Àa?®R?–—?gÛë?@>g±§¾'7 ¿Sa¿ŽSH¿Ðæ¢À û›?^UÇ?™Aq?¹4ƒ?Ò2è?á@®?ê'é?í?ås7?ÕW&?½@?âš?iÁi? ù{>á¾™Y¿Mo(¿ª|­¿ö”À"n ÀM ïÀy>QÀ“ÇñÀ«¿8ÀĘYÀÞ[´ÀøñåÁ ǺÁW%Á%,Á3hÁA+ÁO‰MÁ^>Ál±ÚÁ{JwÁ„÷ÁŒX´Á“ÈUÁœ÷xÁ•}ÎÁŽ$Á†¶ÍÁ~Ý7ÁpuJÁb •ÁSžuÁE6KÁ6ý0Á(þ†Á/bÁ s®Àÿô²ÀåHTÀËC’À±ÆÀ˜ÇßÀ€¨7ÀQþÀ%È¡¿ôF뿤o/¿2ˆ¾%±¥>œ–œ?>ĸ?‘m?»]O?Ýšÿ?ö”á@jÜ@•@Þã@a?÷ww?à,1?¿á?—ò·?Xe·>×\›¼mLd¿R»¿ˆÖ¿ÕÛÀºùÀ=ûmÀjd³À.6À¥\tÀ¾ \ÀØZÀòP½Á€±Á@DÁ"7_Á0;BÁ>YßÁL­lÁ[+£ÁiÌOÁx½ÁƒºÁ‹*IÁ’˜hÁ›ÆÖÁ”S¸ÁŒáóÁ…}eÁ|WŸÁmáÁ_ƒRÁQ%†ÁBǺÁ4hÁ&@ÃÁq³Á ÔQÀúË'Àà®ÀÅìoÀ¬9À“…‚ÀuíÞÀGmÀ­r¿Ý:¸¿ŒÏ¾ý6>=°?› ?t»ž?¬Èæ?Ù'?ü¨J@ -N@=Í@`M@Gì@a@ ÅQ?ÿr¼?á%Á?¸U?Š”ß?-¼u>["d¾–o?¿XÂx¿º¤·Àb€À1EìÀ^]”À†ÜCÀŸkÀ¸‡ñÀÒ“9Àì°ÔÁÆøÁ­UÁ¨eÁ-£vÁ;»ÖÁJCÁX²NÁgadÁvèÁ‚o‰Á‰ÖÁ‘@jÁš¸¦Á“DÜÁ‹ØÖÁ„xCÁzJGÁk±ƒÁ]oÁNšÁ@K–Á2ÜÁ$CÁÁvÀõúÀÛ4ÞÀÀ–À§øÀŽN!Àk…kÀ<ˆÎÀr°¿Çùá¿k:#¾¥6=>cñ?6ô?“Fv?Æ* ?òâŠ@ Ä@°j@!\È@$sW@#±s@ JH@@)@ ³­?ÿF?× b?¦Qm?ck@>ÖŒN½Çè ¿+´¿£_æ¿õ—ÈÀ&ͬÀT‹’Àù˜Àš®äÀ³‘_ÀÍŠBÀç³%ÁS&ÁCÁC×Á+E Á9wÃÁGïKÁV—‘ÁeEŸÁsó¬ÁQ*Áˆ²DÁ#IÁ™ÕjÁ’X}ÁŠè¶Áƒ‰ÜÁxs_ÁiØÁ[?#ÁLªXÁ>D«Á0$BÁ""$Á)gÁVƒÀñš2ÀÖ¦ÍÀ¼VâÀ¢—%À‰d«ÀaøcÀ2¢*Àq¿³*ˆ¿D®¾'r>Ãw“?`Ûi?©šA?Û¥C@ïº@ÒÕ@#BÈ@+Õ@/žÎ@/C@+s•@$°¶@•›@ %?ïF«?¼Æö?…¬Ü?} =wl ¿ÇU¿’#Z¿ä®ðÀ(ÀK¢@À{LLÀ–dÖÀ¯QbÀÉKñÀã¢lÀþ ‹Á lÁÁ) 9Á7OÁE×…ÁT…6Ác=ùÁq÷cÁ€XfÁ‡»üÁ/LÁ™,PÁ‘¶^ÁŠ@lÁ‚΀ÁvØÌÁh4ÄÁY›®ÁK¹Á<­‡Á.ocÁ Q+ÁA‘Á_„Àí¥XÀÒÂáÀ¸®aÀžóÀ…_RÀZ¦¼À*ç¿ú%¿£| ¿U{½¹Œ?G™?‚HK?»n?î:°@ ð@½«@+ýÇ@4©"@9cI@8Žè@5Ëý@/@$d0@fY@3Nx¾Çmš¿ƒ`¿Ö%ÀN$ÀDqEÀtQàÀ’™MÀ«DÀÀÅx3Àßä Àú¾ÕÁ *YÁü¯Á'Á5szÁCìtÁR™Áa-qÁoï>Á~Â.Á†Ñ ÁŽKÁ˜£`Á‘+-Á‰³ Á‚>™Áu¤ÁÁfî‚ÁXgÁJúÁ;ŸŒÁ-EÁ©Á#¦Á7ÎÀë!|ÀГ¤Àµú:À›Ó¸À‚ŒzÀTFÀ$4ì¿îô”¿—m”¿3=›…ó? U‡?I?É›Î?ý;@ˆÿ@&\Ú@3Kø@=Z)@A*@AM‚@=ì@7ÓÛ@-E^@b:@ 3›?àœX?¦ìÇ?Q ô>1¾Û¿lç´¿Èï}ÀŒÀ>QÀm@ÀŽÖˆÀ§›ÀÁÎpÀܘÀ÷L~Á FFÁD3Á%“Á3æiÁBE~ÁP×PÁ_‘£Án\ûÁ}A Á†Á’ªÁ˜8°ÁÂÅÁ‰RrÁì>Áu(ÁfVnÁWÆÌÁILzÁ:ÔoÁ,nÁC¢ÁWÁn´Àé<žÀÎlSÀ´ ;Àš&À€ú1ÀPžÀ!H¿çB¾¿"½¾ñW>Ïh?4žj?›Ø?Ôìñ@éÝ@jÔ@+­á@9çß@CH0@Gó‡@Gòþ@Du@>r”@49@$Ü@¼?ï4?³~ù?iV>>½»ý¾D5c¿RÆö¿¼¡3À §ÖÀ8ArÀgòÀŒÀ¤öÀ¾é:ÀÙÀôWVÁ'Áß_Á#åfÁ27îÁ@Æ?ÁOzØÁ^AQÁmÓÁ{Ñ$Á…[ÁŒÜþÁ˜7Á’#Á‰$*Á¶VÁt‘‚ÁeÍ ÁW6óÁHÈ{Á:cÁ,‡ÁÒ°ÁïõÁ1Àèæ½ÀÍÝùÀ³_ÖÀ™w'À€h ÀNáWÀ㻿ã‹Ë¿‰Á1¾ÜÉ©>Bƒƒ?Cî?¢{?Þ ä@þ@Tæ@/ÒÖ@>6@Hv¨@LúÊ@M'»@JÜ@DD@9}F@)c„@e?ùÞ?½Ó?{àŒ>ñ7½õó¿¿9ÝJ¿²h€Àý›À29ÀacbÀ‰GÀ¢“ˆÀ¼¡ðÀ×Àñ§ÁŸqÁÃ?Á"õµÁ1* Á?†ÐÁNµÁ\æ)ÁkÌ‹ÁzµnÁ„Ï)ÁŒIFÁ—ïüÁ€{Á‰+Á³œÁt¡íÁeîKÁWRcÁHÉåÁ:q^Á,1;Áú_ÁãÞÁ+6Àé ·ÀÎÀÀ³ÛøÀ™â×À€„ÀOÛæÀ Ž¿ã ù¿‰âA¾Ô’y>S0&?HÐŽ?§EY?âü@ oÚ@ ç@2­@@À@KOb@PnŠ@QIÞ@Nï‘@H‡L@=ç1@-ý>@ûU@·|?ÇT?ˆA#? õ½%þ¿&á¿§ |¿ÿÀ-Å=À]EéÀ‡D©À ÃJÀºI\ÀÔž#ÀïôDÁÕ0Á·ôÁ!ÑvÁ04ÒÁ>ÃÿÁMUwÁ[ü<ÁjÇuÁy­©Á„KÖÁ‹Á•Á˜ “ÁœÁ‰0ÁÉ ÁtÔƒÁf5¯ÁW¨ÁI""Á:¯×Á,w´ÁZgÁL’ÁçÀé­gÀÎÇqÀ´iÀš àÀDBÀQMÀ!/¿å¥ô¿Œy¾Û×E>T¬?GeŽ?¦—?ä—@ ["@!Æc@3´@B=@LüÚ@QÕ+@Sx)@Q=@@Kç"@A£š@1wN@^@h6?ήã?¼?h<×—¿Y-¿ Jb¿ø×1À*ZÛÀYþÒÀ…£!Àž~ïÀ¸ÚmÀÓu„ÀîxÁÁÚÁ!E8Á/;Á>üÁL£ýÁ[<&ÁiöÉÁxØÏÁƒìÃÁ‹u°Á˜B"ÁÐOÁ‰iÿÁ‚ Áuo½ÁfËéÁX>«ÁIµüÁ;;WÁ,ÿèÁâÁÅåÁðàÀêßžÀÐþÀµfàÀ›¨øÀ‚‹‚ÀSlÒÀ#&¿éJª¿"#¾îˆ>*9?>8â?¤ë´?à[o@ ê¥@!W¸@3ƒ4@Aâ0@Kçj@RQ@Sÿ¥@R‘ü@Møu@C /@2V @VX@?Õ ¬?”ù?¿=)÷/¿îÑ¿#¿ôLDÀ(Í«ÀXe4À„ø¶Àž(KÀ·ÎPÀÒ˜õÀí¼Á”ÃÁ¬hÁ ÜÁ/îÁ=w ÁL ÁZèÁiµÁxƒ#Áƒ³šÁ‹2øÁ˜§—Á‘;¡Á‰ÝaÁ‚„éÁv]5Ág°™ÁY%ÁJkÉÁ< iÁ-à Á¹oÁ›MÁÓ—Àìœ{ÀÑž5À·XèÀ‰ZÀ„yÀVÞ]À'»¿ð½¿—替 Ð=àÙE?/„ü?œ7i?Ùà„@X1@êO@0Fc@>°#@H¬Ö@OÄ @R=!@Qû@L·@Aˆo@1Œ@– @¼³?Ö?“ ­?øb< 9¿:›¿»ý¿ö=^À(ã ÀXÇSÀ„×êÀžŸÀ¸NbÀÒ¸Àíõ.Áœ#Á~˜Á ÄþÁ/2Á=ŸŠÁL"ÁZÒñÁi–?Áx^ÌÁƒ Á‹‰Á™,RÁ‘ÃÂÁŠgpÁƒ ÷Áwb!ÁhÇVÁZGDÁKÊ™Á=r{Á/?Á!mÁ[Á.0Àï6PÀÔ)ÃÀ¹ÓUÀ À†¾À[î–À,)¿üá0¿¢X¿<c•?ã1?ÿ?ͤE@jœ@‘Œ@*…ý@8:@Bºz@I*Ô@KºŠ@Kžû@Fá@>?÷@/z-@çs@¨Ž?Ôa?F¶?ÔØ¼¦ùí¿ íÉ¿£Ço¿ûXÂÀ,8À\r©À†ÇÄÀŸ´-À¹©ÂÀÔÏÀïxÁVãÁ#ÙÁ!2™Á/ŒÁ=ö ÁLnbÁ[…ÁiË©Áx·qÁƒØÁ‹T`Á™ÊsÁ’n¿Á‹ÆÁƒ¿2ÁxÛòÁjSæÁ[Ì]ÁMOMÁ?^Á0ßÁ"ɦÁ·ÿÁôçÀò¹3ÀׯRÀ½„aÀ£ØÀŠTÀcÙËÀ3@ÉÀÖƒ¿³í¿ñ¥?’?½à9?ñÿ3@S%@!ºô@.­<@8ˆ@>@@¢Á@@¶‹@=Á.@6Õ@)šE@Jn?ÿÊ!?Çí?€¹Ÿ>âÍ{¾|“¿>‡°¿°5zÀ¢OÀ2‰ÀaJ¢À‰E]À¢‡ÇÀ¼8§ÀÖ}ÀðýÄÁBâÁ)¸Á"?Á0VlÁ>ÖÁMo•Á\ ZÁj²ÕÁyƒ Á„3sÁ‹¥fÁšUÁ“4TÁ‹Ø£Á„„ Áz†ØÁlÒÁ]¯{ÁOD$Á@óŸÁ2ÈùÁ$¬&Á¹KÁ ÍÀ÷ ]ÀÜ8©ÀÁÛ¦À¨<ñÀXÀmQÐÀ>1 ÀXâ¿ÇÑÈ¿hRO¾“*Ý>‹`¡?PpA?¥Œã?ÙÚy@ÀT@Y@!£$@*ûé@/”@2MS@2Å»@0H¦@*”$Ó¾”ŒÇ¿g»¿ÂqÀ ™À:”PÀj ¸ÀŒúPÀ¦)À¿RÀÙíæÀô¶ ÁÙoÁ¿4Á#ºÁ1¿´Á@ ÁN•´Á]9ËÁkä·ÁzœiÁ„¼'ÁŒ4ïÁ›upÁ”%\ÁŒ×Á…Š{Á|›bÁn,kÁ_ÄEÁQgÁC/òÁ5Á' ¥Á=›Á ‰4ÀûÅÅÀáR:ÀÇqÃÀ­áAÀ”Ä\Àx³ÀJNÀP9¿á濎ÑÅ¿~N=LÎx?`?…‰Ù?»‹?è ¤@±©@£ @Ôu@Eè@ñá@ ´@>ç@QO@ žï?õyù?Æø³?Þ°?t`={;Ä¿WX¿Ž˜¿Ý‹jÀîIÀF¼ÒÀuýÀ’}ÉÀ«/ôÀÄ›ØÀÞ^‚Àù,ŒÁ °ÁÂÁ%ÇþÁ3ÖÁB\ÁPhàÁ^å™ÁmxëÁ|Á…nÇÁŒßnÁœ‡Á•9Áî‡Á†°0Á~ìŸÁp‰0Áb7rÁT ÁEÕuÁ7­ŒÁ)ÍÈÁÁgÔÁˆÀç¾ÀÍÀÀ´A˜À›¿OÀƒ…!ÀXõÀ+ÈÀ=Ñ¿°Ã!¿GJ§¾mÎH>¹´?<¾Ó?“hˆ?¾†+?àÂþ?ö(ö@›t@ °@ 9@ ׂ@ –Ñ@=L?ì²¥?Ë«?{u?K2> ¿³¾WEH¿@¾Q¿­é„¿üä¾À(Ñ7ÀU“³Ào À™FðÀ±bMÀÊÕGÀäªFÀÿÁ áŸÁ[ŸÁ(0ZÁ6PœÁD}ÿÁRº|Áa(Áo KÁ~!`Á†a©ÁÅŒÁ§6Á–kŒÁ0ûÁ‡öjÁ€¾]Ás3¦ÁdócÁV¯SÁH‚Á:ŸÁ,âsÁ&‚Á±7ÁqyÀîtôÀÕLÀ¼ ØÀ£¯À‹ÜýÀj1¥À=ÈÀ)¿Ø³ ¿=±¿$罋†L>²?GѶ?Ã0?­ô¡?Äÿ•?Õ¥Ø?àJ?䎲?åã?ã([?Ô®&?¼a?™‹E?Z«å>é’^¼"Cæ¿¤í¿‡ ؿӂÛÀ”¶À;L³Àg7¡À‰«À¡©®À¹üÖÀÒš£Àëþ†Áé‚ÁGÖÁ¹MÁ+L•Á96—ÁGX ÁU†0ÁcÒ”ÁrJôÁ€f”Á‡«–ÁŽûìÁŸ–Á—¾óÁ}Á‰HÜÁ‚)´ÁvÁgä§ÁYÕ@ÁKØÁ=ïwÁ0:;Á"½MÁXÀÁ5æÀö«ÀÝUÇÀÄ¿uÀ¬n²À•šŽÀ}ýmÀS5xÀ)³‹ÀªV¿¼hã¿sob¾òäf¼þÅb>´ò?,Ú?mo?Œç?žlµ?¦ÖA?«èÁ?®=c?ªrh?Æ?„œø?B Þ>ÞcÍ=fm©¾Ç~¿\.’¿®ù\¿ýAEÀ&Ô ÀP±…À|×À“é*À«( ÀÃ&wÀÛ(øÀô8ýÁ2gÁN¯Á!­_Á/8ªÁ<ùÁÁJ½žÁXª®ÁfÑÁu1£ÁØÓÁ‰sÁ]¦Á n¢Á™;Á’jÁŠë0ÁƒÆÁÁyRŸÁkB£Á]F’ÁORÁAÂÁ4ŒÁ&¡ÀÁoÎÁ –¼Àÿ‘åÀæÁhÀÎ…pÀ·vÀ <ÀŠÜÀiËÀA@7ÀÌ¿ñ8ñ¿¯à²¿iŸb¾ú]˽á¾>K*>㎠?!ž3??}Ü?T¼}?]»Ö?`T¾?ZË?@r? ’>—$üç‡R¾ÓóÍ¿Rd¿£¿š¿âZÀÀ>Y¢Àhw–À‰lèÀŸyÀ¶ ‚ÀÍŒÀå£Àþ{‚Á ñ)Á¶—Á%¹qÁ3(­Á@ëbÁN½Á\–Áj„£Áx®sÁƒ†qÁŠÆSÁ’ Á¢ŠÁšìøÁ“ÈÁŒ¬Á…‘ûÁ|ðŠÁnáõÁaMÁSˆÁE÷¦Á8€îÁ+9­Á7ÁV"ÁåËÀñ :ÀÙ;ÁÀÂAÔÀ«»ÍÀ–jÒÀeàÀ\reÀ7 àÀð¿ëL¿²^Ê¿wá&¿´"¾ž ¹½ŒÃ=Ò²)>hr´>š±;>«&á>¯Ê~>¡×è>j±=Á¹¾XÚ¿ ßà¿in•¿¨Œ[¿Ýþ4À šéÀ/rÚÀXw´À€ïTÀ–o£À«ïôÀÂ!õÀÙ:¾„Hü¾²–²¿¸û¿AÉ.¿‰#z¿¹%¿í›UÀ²ÇÀ0”ÀQ ÕÀteÀŽõ§À¤ryÀ¹Ö—Àχ»ÀæX$Àý¤ŸÁ º™ÁqÁ#´.Á0‚þÁ=üÁJ¦ÁWÝ–Áe`LÁs0'Á€òÁ‡©ùÁŽ·¶Á•ÕúÁ¥æÁžÛ"Á—Ô¾ÁÎZÁ‰Ê÷Á‚àoÁx)Ájo¡Á\ÐäÁOl[ÁBièÁ5­àÁ(ü*ÁeÁ]mÁÀñ®ÀÛåÇÀÆèúÀ±íÀžpÀ‹èÆÀtØÀTÄÆÀ7V‡ÀßEÀâ"¿ÚF¿¶nƒ¿šS‘¿ƒÈó¿hÖ¡¿Vúu¿NF}¿Rw®¿]A¿vÊ´¿ú'¿­ûY¿Ó(NÀoÀªDÀ6iýÀTPuÀt…»À‹MÝÀž_À²éÍÀÈ-”ÀÞ YÀô\ôÁž÷Á:kÁqÓÁ)ÂáÁ6QåÁCX#ÁPt\Á]”ÁjÍáÁxR|ÁƒeÁŠªÁ‘¦Á˜( Á¨'jÁ¡½Áš ÓÁ“,ÁŒ:"Á…WûÁ}•Áo¡Ábm«ÁUe{ÁHƒ—Á;¼†Á/ CÁ"ÚfÁ‘Á W'Á#Àê˜7ÀÕËÎÀÁ:À®_ˆÀœÀ‹·êÀxU]À[%0À@+¯À'{ÑÀbêÀqF¿çпҤͿĒU¿»Ïñ¿·|Ø¿¹H¶¿¿9‘¿ÌC³¿àÔ‚¿û:ÀNÀ'eüÀ@^wÀ[÷xÀy€)ÀŒk'ÀÊ5À¯â*ÀÞ`ÀØÐÀík3Á£ŠÁ ù/Án#Á$I}Á0™’Á<ÿaÁI˜ýÁV„ÙÁc}ÓÁpŸ]Á~”Á…ÖVÁŒ·îÁ“§ Áš§ŽÁªŒ¬Á£–BÁœ¡Á•«ðÁŽÁ÷Á‡öTÁMÿÁu?Áh…ÓÁ[~¨ÁN ùÁAüèÁ5ΕÁ)Á”Áë¾Á½Á´ôÀú,4Àå}ÀÑöÁÀ¿tŸÀ­××ÀpÊÀŽzíÀ€CîÀenÎÀN2äÀ:AlÀ)º5ÀîkÀ‘À ­WÀÕ2À¬ÒÀ;ªÀ \TÀ#³ÀÏRÀ'—¿À92ÁÀNºÀgl*À€ö5ÀݰÀŸp À°!éÀÂK‰ÀÔøÚÀèøiÀý½Á ~àÁ¦Áô3Á+žÁ7Ç©ÁCÿ ÁPUrÁ\ðUÁiÛ?ÁvÚ^Áþ´Áˆµ;Á‹Á–j9ÁLûÁ­=ðÁ¦H ÁŸRWÁ˜lÈÁ‘¤ÁŠú»Á„k¯Á{À~ÁnªùÁa¦8ÁTýåÁHÏLÁ<èøÁ1 «Á%Ÿ‰ÁŽ#ÁÅÁÁèÀöŸ¿ÀãÃ9ÀÑUÀÀQ?À°‡óÀ¡£áÀ“êÀ†ÊcÀvnŸÀc{3ÀSV¤ÀEÉ¿À•À· ÜÀƲãÀÖûàÀè"¿Àú.ãÁ›Áv?ÁÒFÁ%]?Á0\eÁ;¥\ÁG#$ÁS ÏÁ_ FÁkBµÁwµäÁ‚/ÙÁˆ¯’ÁBÛÁ•ÜaÁœ„×Á£KTÁ³¥Á¬)ïÁ¥TCÁž—XÁ—ùÄÁ‘|´Á‹¡Á„•cÁ|{Áp5áÁdÂÁX7™ÁL|dÁAÁ69Á+†wÁ! iÁÇÁ ’©Á‡iÀ÷æHÀçCÜÀ×ß2ÀÉаÀ¼²À°vÀÀ¦qÑÀZÀ•€ÀvûÀŠùùÀ‡òÍÀ†œ«À†™À†£À‡´nÀ‹6æÀüåÀ–PÚÀž–À§‰9À²@UÀ½­‘ÀËéÀÛ!$ÀëüÀûÙêÁ¼ËÁÁ¾êÁ#î„Á.c½Á8ûzÁD'rÁOhÌÁ[ÁfýcÁsÇÁMcÁ…ø®ÁŒXGÁ’ÏoÁ™WiÁŸâÁ¦…ÊÁ¶ ‚Á¯SBÁ¨›nÁ¡þrÁ›séÁ”úÏÁŽ•ŠÁˆU¸Á‚+%ÁxªÁkãCÁ`4’ÁTë0ÁI¸ëÁ>íŠÁ4Š÷Á*8…Á ‰Á{ˆÁp÷Á½ÀüG¶ÀíjÑÀßdôÀÒ/HÀÆÑÀ¼ëÃÀ´ UÀ¬ÎúÀ¦Â‰À¢FÆÀŸ­¨ÀêÁÀ˜ãÀžQÀŸ‰©À£‡À§²÷À­ÐÀµ4QÀ¾‚qÀÈuèÀÓðÀà1ÐÀï«ÈÁÕÁAíÁÁÁ#ªÞÁ-wKÁ7ºÉÁB>\ÁM{ÁXF{Ác™æÁoF=Á{MŸÁƒ±ŒÁ‰ØÓÁ)vÁ–‡®ÁœôÁ£{ Áª ÝÁ¹nCÁ²½ŸÁ¬ïÁ¥{àÁžú@Á˜œýÁ’g/ÁŒ>iÁ†ÁÿÓÁt;Áhê…Á]°[ÁR¨ ÁH?vÁ>Á3þgÁ*‚±Á!‹ðÁÒÙÁÈÊÁ eÁ`Àõ­þÀèèØÀÞ9DÀÔ:XÀËãeÀćÉÀ¾ÁîÀº+öÀ·×À¶EÀµýÀ¶kÅÀ·Õ¸À»9À¿óÀÅï2ÀÍ_æÀÖqkÀà<ÓÀëP>À÷TŸÁÃjÁ šÁ³CÁ}fÁ$_OÁ-Å¡Á7\ÉÁAfkÁKž|ÁVVÐÁa6aÁlƒgÁwýOÁÕ Á‡ÚÖÁìÁ”dÁšb¥Á ¹Á§²Á­£sÁ¼á?Á¶;{Á¯ @Á©!£Á¢ÅZÁœŽÉÁ–kòÁI‡ÁŠÀøg¼Á^ÁtÍÁ ýMÁ®ÁIÁ&dÁ.Þ’Á8 ËÁA†ÁKL7ÁU‡Á_ðTÁjŽnÁuƒdÁ€xXÁ†7\ÁŒ°Á’ŠÁ˜*¥ÁžRšÁ¤¡ùÁªü’Á±_¥ÁÀv™Á¹çBÁ³lÁ­ÉÁ¦ËíÁ žcÁš‚4Á”‚_ÁŽŽ°ÁˆÈJÁƒ,ÔÁ{NWÁp„+ÁeñºÁ[ÙœÁR%ÁH‚ÀÁ?”qÁ6ÅÍÁ.“2Á&³ÁaêÁš Á)$Á CÁ ÁHQÀüó—Àõº¬Àð‡ÇÀìs·Àê.ÁÀè¾ÀèGëÀé@“À깚ÀîXxÀò´§Àø æÀþôÁ´›Á‡[Á  ‹Áe`Á2Á Ú«Á(î–Á1%«Á9ÖqÁB¾ÁLÔÁU§8Á_¥qÁiìŒÁtr‹ÁÆÁ…ÁŠÐuÁ‘CÁ–rRÁœz©Á¢‡ìÁ¨°-Á®þ–Áµ]»ÁÄIzÁ½Ò‡Á·kfÁ±ÁªÚ!Á¤ÂøÁžÈæÁ˜ÑòÁ’ÿÁbLÁ‡ÜÆÁ‚gØÁzP•Áp–Áf4–Á\˜°ÁSP,ÁJ‚¼ÁBqÁ: žÁ2B¬Á+X0Á$‰ÁA¢ÁŽ~Á}\ÁïÜÁ 5^ÁßxÁJ ÁTÔÁÿoÁM2ÁC±Á¸ëÁ¨¼Á;ÁRÁ ÉÁ —BÁ†ÔÁžÁ\FÁô½Á%Ë„Á,’ÈÁ4e°Á<ŽUÁDðDÁM´§ÁVß¾Á`>ˆÁjpÁt[Á~c~Á„ƒâÁ‰åÁ|ÈÁ•2EÁšñJÁ ×Á¦âÁ¬þ)Á³+!Á¹t|ÁÈ>ñÁÁÏŸÁ»q«Áµ4uÁ¯êÁ©$dÁ£13ÁX~Á—² Á’&ÁŒ¤ÿÁ‡^eÁ‚JoÁzt–Áp´ËÁgjqÁ^]=ÁUñ¢ÁM·hÁEÉTÁ>iÁ7ÜÁ0¨=Á*©0Á$ù Á !eÁ´#Á²Áø¹Á–YÁ•‚Á]GÁæÁ6Á uÁ |ÁšåÁ¨õÁe Á¸‹Á’\Á!ô­Á'8Á,º2Á2‰wÁ8ïpÁ@8IÁHCÁPVÍÁXÇÏÁaÒ¯ÁkÁt Á~IÁ„A_Á‰}ÁŽØÁÁ”CÚÁ™å¦ÁŸœÁ¥['Á«DÔÁ±X7Á·ƒ¡Á½¶±ÁÌ?ÛÁÅæ+Á¿ª™Á¹‘¾Á³›äÁ­®.Á§ÑÈÁ¢!0ÁœöÁ— hÁ‘²°ÁŒ”zÁ‡jÁ‚„úÁ{°£Ár¤'Áiì'ÁauáÁYsÄÁQß4ÁJ«ÑÁCÍ×Á=AíÁ7e÷Á1çùÁ-#÷Á(ìÓÁ%& Á"HéÁç¨Áä#ÁÊWÁÝÁ3™Á¬Á¢FÁA”Á!LYÁ#ÔsÁ'™Á*¥Á/3Á4,"Á9Œ°Á?TpÁE¹ÝÁL›DÁSè:Á[ñeÁdZ{ÁmÁv3Áq´Á„˜øÁ‰’§ÁŽŸÁ“ê0Á™HwÁž½uÁ¤f,ÁªåÁ¯àµÁµÌçÁ»à†ÁÂKÁÐpáÁÊ8=ÁÄÕÁ¾)ñÁ¸?~Á²[Á¬› Á§aÁ¡„•Áœ)çÁ–÷¬Á‘áGÁŒÜ_ÁˆIÁƒ‡*Á~%ëÁu“Ám:=Áe‹‘Á]þÁW:ÁPFfÁJÁD1Á? •Á:F~Á6K#Á2 Á/§âÁ-aÁÁ+“NÁ*_ˆÁ)Ä“Á)ç"Á*S£Á+}åÁ- Á.öPÁ1}¹Á4Ž-Á8 >Á-Á†Š.Á‹õÁ¥´Á”qÃÁ™pBÁžƒÁ££ÍÁ¨òêÁ®dËÁ³ìNÁ¹‡¿Á¿E7ÁÅ"8ÁË…ÁÙ[ÁÓ[ÞÁÍlðÁÇ€€ÁÁ®_Á¼EÁ¶‰Á±7ðÁ«íûÁ¦³VÁ¡°ÜÁœâÿÁ˜-¶Á“ÁïÁŠèóÁ†ÔöÁ‚öÁ~N¸Áw>ýÁp`3ÁiüWÁc÷Á^mÒÁY‚¼ÁUÁQhhÁMÌÌÁK 4ÁI ÈÁG3åÁF=ÐÁE¡EÁE¿9ÁFAµÁGs_ÁHë½ÁJÝÔÁMc,ÁPOêÁSÄCÁW«åÁ\,jÁa"CÁfRÕÁlPÁrí/ÁyžšÁ€NÞÁ„0 ÁˆD\ÁŒfÜÁÒÕÁ•]¨Á™þ6Ážá±Á£óãÁ©rÁ®*³Á³óÁ¹Á¾ˆ¿ÁÄ"4ÁÉäÝÁÏÌÀÁÝöÁØ ÁÒ(‰ÁÌU:ÁƧZÁÁ#“Á»Ë¸Á¶€\Á±<ÂÁ¬)žÁ§QÁ¢œîÁêdÁ™_ŸÁ•—Áÿ=Á ÒÁ‰1¦Á…‡®Á‚vÁ}fÁwB!ÁqJ?Ál QÁg«Ábí’Á_JÁ[ÃOÁYÂÁWæÁU;,ÁTVðÁSµçÁSÛÂÁTs§ÁU)ÁW%ÁY.dÁ[îÁ^FpÁa¸AÁemÁiï<ÁnшÁsíÛÁy>Á÷\ÁƒGÑÁ†¤~ÁŠXüÁŽ_ˆÁ’s£Á–²²Á›4ÁŸ¿ Á¤vÄÁ©m›Á®—Á³•œÁ¸ÂÜÁ¾"6Áç¿ÁÉ0ýÁÎϘÁÔ•BÁî=uÁèjeÁâ®îÁÝ'Á×}(ÁÒ‚ÁÌ·ŒÁÇyGÁÂLÁ½L’Á¸sQÁ³¸dÁ¯!\Áª½Á¦_Á¢]\ÁžhoÁšÂÅÁ—MÅÁ” éÁ‘ [ÁŽHœÁ‹ÃšÁ‰n7Á‡EÇÁ…zªÁƒÉÅÁ‚e?Á;?Á€P¼Á“Á}ìÁ}MRÁ|û%Á}eLÁ~ èÁÁ€Q£Á]áÁ‚¢aÁ„5ûÁ…÷°ÁˆtÁŠ>ÁŒ¿Á_vÁ’AŠÁ•IfÁ˜k·Á›Ë­ÁŸ Á£VaÁ§LåÁ«{íÁ¯Ï5Á´S0Á¸÷ÔÁ½¶ÁÂßÁǸÁÁÌÿˆÁÒNÊÁײãÁÝ?kÁâñÁér`Áã‘AÁݾ~ÁØÈÁÒmTÁÌÛˆÁÇlçÁÂ(ªÁ¼ölÁ·×mÁ²ÝÁ­þEÁ©QÁ¤ÝnÁ nÁœ]¸Á˜UŽÁ”ÔÁõ-ÁŽìÁЇÁ‡¼>Á…{Á‚¨=Á€}Á}9SÁy²jÁvÚÁÁt‰Ár—ãÁq ŸÁoê;ÁoOjÁorÁo‹ÎÁp=DÁq?fÁrã/Átç$Áw’ÂÁz­&Á~XøÁ/´ÁƒƒÄÁ…ÿÁˆÄ,Á‹½ÁŽÔÏÁ’ [Á•¥wÁ™tqÁOCÁ¡QŒÁ¥”‰ÁªXÁ®·HÁ³^ÏÁ¸4Á½@?ÁÂ~ÄÁÇÏlÁÍ+îÁÒ±­ÁØ_ÁÞ/ÁäÂÚÁÞÔBÁØé€ÁÓðÁÍ_VÁÇÌ7ÁÂGØÁ¼âÁ·¦çÁ²v·Á­iÕÁ¨oÁ£™4ÁŸÒÁš¯Á–dfÁ’L ÁŽxéÁŠÈJÁ‡:ÜÁ„3Á:ÅÁ|ñOÁwÑ´ÁsŠÝÁoÁBÁláÁiÎÁfѳÁd¶5ÁcHÔÁb 7ÁaTsÁa.VÁa²OÁbo ÁcžâÁeWdÁgY”ÁjxÁm4ÁpñÔÁtþÁy¾OÁ~ÂÁ‚AªÁ…@wÁˆÁ‹ëÁ“ÕÁ“m'Á—LfÁ›lBÁŸ×qÁ¤z|Á©$IÁ­æùÁ²âÁ¸œÁ½dÕÁ»ÁÈ90ÁÍàíÁÓ«^ÁÙ~HÁà'‡ÁÚ'"ÁÔ7oÁÎHÔÁÈr]ÁÂÃ>Á½<"Á·ÉHÁ²oZÁ­.KÁ§ÿ½Á£?ÁžÁ™UtÁ”ÞNÁ†ÁŒR_ÁˆfpÁ„·ÿÁ,Á{†Áuƒ„Áoð$Ájœ"Áf(ÍÁb]„Á^º®Á[™þÁY=”ÁW¾ÁU™ZÁTqÁS‹ÙÁScÏÁS×ÁT© ÁV²ÁWÒKÁYú?Á\͸Á`‚Ác¿ÏÁgòaÁl¤¨ÁqÛˆÁw£EÁ}ÊÁ‚IyÁ…ÃÁ‰ŒyÁolÁ‘o°Á•¸éÁšF£ÁžïÁÁ£¯ Á¨¡ŒÁ­Ä„Á³Á¸d£Á½ÙyÁÃz9ÁÉ<>ÁÏ1ÁÔÛÁÛ¼ÐÁÕ™ÕÁÏŽäÁÉ›Áö²Á½æÁ¸<˜Á²À–Á­`ÒÁ¨'Á¢ÅBÁ¤Á˜¸cÁ“ÜúÁ:0ÁŠÝÁ†ŒãÁ‚tÁ}f¢ÁvgÁo62ÁhåNÁc—Á]ļÁY ÁUgÁQxÁNh…ÁK´hÁI¨ˆÁGÿAÁFÊ ÁF×ÁEàVÁFôÁG ÁH‚‚ÁJ]ƒÁLœtÁO^ÁRépÁVºGÁ[¸Á_×ÁeF‡ÁjÿÐÁqoÌÁx+Á_ëÁƒ›®Á‡›ÉÁ‹ÆnÁ.Á”¼.Á™w™ÁžiäÁ£ŠÛÁ¨Ã2Á®ÌÁ³ˆ„Á¹(+Á¾ãxÁÄ¢ÐÁÊsEÁÐh¨Á×€ÀÁÑ@„ÁË|ÁÄû˜Á¿óÁ¹2áÁ³q“Á­ÏKÁ¨[3Á¢þ„Á® Á˜sÆÁ“l[ÁŽ•ÊÁ‰Ð9Á…N7Á€ýLÁyt¥Áq–¡ÁjpÁb÷RÁ\•nÁVŽìÁQH‘ÁL\ÁH?ÁDPTÁAFÁ>^›Á<;ÜÁ: WÁ9c Á8Ü3Á8­SÁ8±!Á9«Á;Á<ÿWÁ?@GÁBWÇÁEÏÛÁIפÁNOYÁSZæÁXâ–Á^ÇáÁeL»Ál»ÁsŸSÁ{\Áã©Á†=‡ÁŠ¥µÁG3Á”2GÁ™T®ÁžbÁ£Ç<Á©7—Á®×°Á´„ÁºOQÁÀ$OÁƹÁÌ-­ÁÓQñÁÍ aÁÆÊ’ÁÀ‘˜ÁºyçÁ´ˆWÁ®¿ÖÁ©OÁ£|ÁýüÁ˜œ5Á“RoÁŽ6‹Á‰UvÁ„‹Á±­ÁvïýÁnTÁeüÁ^W=ÁVù[ÁPeêÁJu·ÁDêvÁ?Ü3Á;mUÁ7w:Á4&Á1_JÁ/KÁ-nŒÁ,YDÁ+ª±Á+–Á+¹šÁ,µrÁ.îÁ/àºÁ2³Á5@ªÁ8ÆÏÁ<õÚÁAŸyÁFð3ÁLÕÁRÈ.ÁYWöÁ`pLÁhÁpûÁx¦Á€»ßÁ…A4ÁŠÁ%Á”I¬Á™}ÁžçAÁ¤‡FÁª@uÁ¯ÿÁµÞÿÁ»Ý{ÁÁ÷{ÁÈ-ŒÁÏRyÁÈñ­Á©5Á¼cbÁ¶(­Á°ÓÁª#Á¤bÁžÈ“Á™3#Á“¦œÁŽ;"Á‰Á„Á~•™ÁuqÁkàBÁcEÏÁZ²ZÁR¢þÁK]ÁD“Á>u"Á8·~Á3kÁ/ÔÁ*ôÈÁ'WÁ$³éÁ"<ñÁ OOÁiEÁ¹Á¾oÁ NÁ Á!^‡Á#(ÅÁ%aíÁ(€ÆÁ,nÁ00¨Á5-BÁ:‘çÁ@wTÁFÎÁM¾|ÁU ÄÁ\”vÁdÝmÁmÊÁv×¥Á€!VÁ…‘ÁŠ37ÁTôÁ”¯±ÁšEÁ "Á¥ÄóÁ«¢jÁ±ªjÁ·ÑÍÁ¾=ÁÄP\ÁË}|ÁÄþÚÁ¾iÁ¸UÁ²wÁ«Ü¸Á¥ÆüÁŸÛßÁš IÁ”†-ÁŽìÉÁ‰XPÁƒõ~Á}²¾Át ¤Áj€EÁaÝÁX/ÓÁO«-ÁGa³Á?ØÁ9-CÁ2§€Á,’KÁ'PÁ"²ÿÁwšÁ 1Á)%Á¬×Á—ŒÁ…ÁþÔÁö)ÁwDÁiLÁÍÒÁ³Á`Á,mÁÚcÁ#ô¬Á(ó2Á.p Á4Y'Á;)ÁBaØÁI½1ÁQ÷ÁZ8­Ác@àÁlŠ´Áv\aÁ€4*Á…V¡ÁŠ£ÂÁ+#Á•åÁ›ªÁ¡‚Á§‡Á­®?Á³Ý¡Áº!#ÁÀƒ/ÁÇÈêÁÁ,SÁº«SÁ´I$Á®Á§ÎÏÁ¡Á›…7Á•š¾Áã;ÁŠIÄÁ„³}Á~\øÁs¾@Ái¼™Á`#ÁVÊÁM;¤ÁDÁMÁ<¢ËÁ4Ë«Á-ÑØÁ'?IÁ Ç­ÁTnÁÅqÁR.ÁÑÅÁ ¥GÁ XÁTÁÁ€³Á¹Á,ÁØðÁKÁ XcÁ ¿gÁ TÁÇçÁM~Á%°Á"¨)Á(«·Á/Î>Á7/ÔÁ>ÌóÁGóÁO¾sÁXØvÁb›ŒÁl~1ÁvÆ+Á€¾ÀÁ†@”Á‹ÚýÁ‘’çÁ—f´ÁiªÁ£ÍÁ©»äÁ¯ù¿Á¶Z¹Á¼ÛOÁÄGÁ½QÁ¶ípÁ°hÁª.Á£ÃÁÆÁ—]¶Á‘CwÁ‹Y¹Á…§Á€QÁu7”ÁjPTÁ_íðÁV)}ÁLŒÁBíÅÁ:7Á2Á* àÁ"°šÁì_Áw¨ÁáTÁ (*ÁwÁîüÀÿ3§ÀúNÑÀö)MÀó™/Àò“ÁÀò¢=ÀóÎèÀõM³Àø+ÀühÁ‚CÁêºÁýÁÁ ¼®Áà<ÁX™Á¢#Á$£ÜÁ,@kÁ49Á<ªjÁE}ÉÁOÓÁXûŽÁcKÁm½zÁxÔ\Á÷Á‡ÁVÁ“T™Á™~ÇÁŸ²Á¥õ>Á¬VšÁ²ØƒÁ¹fÁÀÝGÁº"ÿÁ³pÓÁ¬ÐžÁ¦HäÁŸãLÁ™ŸhÁ“bsÁ(ªÁ‡QÁ-8Áw üÁlÍÁaêÁV[—ÁLE•ÁBŸ2Á8øÝÁ/ÖØÁ'˜¼ÁµÁÂ#ÁùŠÁ gmÁÓÀÿ7/Àö35Àî}‰Àè Àâ¸ÀÞiÀÛ«·ÀÚ£ÅÀÚlÊÀÛ—À݈MÀàÔÀä ÀéŸåÀïú‚ÀøÕáÁ=?ÁºnÁ ŽÁƘÁïÛÁ!{åÁ)»NÁ2ºãÁ;÷¨ÁE©ÁO—{ÁYûÁdøRÁp&íÁ{sáÁƒw²Á‰dæÁ{qÁ•±€ÁœÁ¢u~Á¨óÙÁ¯€Á¶ÝÁ½‹1Á¶»»Á°fÁ©\sÁ¢ÉCÁœ?tÁ•ÕÏÁ‘Á‰RMÁƒÁzäÁnj˜Ác0ÑÁXWÁM ÝÁBˆ‘Á8»0Á/ÃÁ%³ÉÁE3ÁAîÁ cFÁ`çÀÿ¾“ÀóÏÀéJuÀßÑ/À׎aÀÐóŠÀËm¤ÀÇlmÀÄuªÀÂ÷ÔÀ¯XÀÃÂ|ÀÅÓªÀÈpÀÌ·®ÀÒ‡YÀÙŸÀâ#FÀì8ÚÀ÷ŠhÁÞHÁ€ÁØëÁ} Á $Á)%³Á2»ÍÁ~ÁZÂHÁO|CÁD[ Á9qsÁ/=³Á%…ªÁÚPÁ;Á öÎÁ ‘À÷ø_ÀêcäÀÞ9ÀÓµÀÉÆ3ÀÁ³àÀº¬³Àµ5)À°²ÃÀ­žyÀ¬KžÀ¬:À­À®ÎòÀ±¢ÀµvMÀ¼uÀÀÀÌœŠÀÖæÀâðÀï@ÿÀý EÁÁ¥ÁnÁãÀÁ)¶êÁ3©ÅÁ>0ÁI$ÕÁTmÀÁ`ŒÁk¹AÁw –Áû“ÁˆWYÁŽÈ0Á•<3Á›ºµÁ¢XCÁ©nÁ¯âÔÁ·eÁ°~›Á©¡ØÁ¢Ï2Áœ uÁ•i¹ÁŽÓÇÁˆAíÁÓÁw Áj‘éÁ^DËÁRvqÁG¯Á;ÖXÁ0°-Á&1ÁnŽÁ¼Á vJÁJ¾ÀòpAÀãØçÀÖÀÊ ;À¾à’À´±‹À¬{À¥+åÀŸÓÀš9ÓÀ—½ÿÀ•üüÀ– À–ánÀ˜GgÀ›{·ÀŸ À¦3À­Ã„À·ÒÚÀÂS:ÀÎDµÀÚâÀ郤Àù„iÁÐbÁ ¢ÁSÁ!>úÁ+”ßÁ6<ÁAÁJšJÁW°Ác¤˜Áp^EÁ}r'Á…gßÁŒêÁ’ßKÁ™´œÁ œìÁ§–Á¯hÁ¨SSÁ¡CKÁš9Á“DdÁŒlÁ…§yÁ}Õ^Ápm Ác:ØÁVD<ÁI…CÁ=>Á0ÛÁ$Ú5Á"øÁ ø•Á>Àñ\òÀÞTéÀËí¿À»1+À«™À ÀCÒÀ„±Àt<Àa•ÀPm'ÀDžþÀ:RæÀ4¿À0ôÀ/“À1ºÀ5P…À;).ÀGÈÀU¯Ài¢\À~u0ÀІÃÀ˜¹À¦iAÀ¶>ÀÆ_ÀØedÀëûcÁ (Á U=Áý>Á JWÁ, ¸Á8¨ÁDk›ÁPëÉÁ]‘µÁj›åÁwØÛÁ‚’-Á‰QSÁ1MÁ—,ïÁž0ÕÁ¥6yÁ­$Á¥÷7ÁžÛyÁ—ßÁ´QÁ‰»iÁ‚àÁxIŒÁjãÆÁ]‡´ÁPfHÁCMRÁ6zêÁ*'íÁõ¡ÁÂÁí.À÷àÀâj0Àλ À¼ùÀªw}Àš^À‹Ž•À|ëOÀeøÀOÖÀ<ôâÀ,ÆJÀçÀ‘ÀçÀ ^&À È™À ýµÀð¬À%À#ÌÀ42EÀFÕÀ]@dÀvÆÀ‡Â8À–æêÀ§Z„À·üÀÊ÷ÀݹCÀò`mÁ«ºÁd6Áð•Á%ökÁ2pÁ>d6ÁK ÁXÁeQJÁrŽäÁ€Á†àóÁÚ£Á”ØVÁ›×ûÁ¢ìÁªÖšÁ£®,Áœ‹SÁ•jÁŽXgÁ‡ZÄÁ€rÁs1ÓÁe¢ ÁX,ÁJÁdÁ=ÆþÁ0ôNÁ$FåÁþêÁ ÒªÁ,ÎÀê2ýÀÔ)qÀ¿Ð½À¬ò_Àš†Àй†Àv3µÀ[r<ÀC(+À-xÀÔòÀ ýS¿ùO³¿ãÄQ¿Ö"¿ÏJ§¿ÎU«¿ÐoA¿ÙNq¿êBÀç©ÀezÀ'xÀ=½3ÀWÒÀs;®Àˆ¬MÀ˜ýëÀªu±À¼ÔÀÐ55ÀåJÜÀú¥”ÁXÁÏÁ êÁ,$8Á8­°ÁE¯HÁRÜYÁ`³Ám~ÉÁ{3{Á„’Á‹ŒFÁ’ŠíÁ™ dÁ ËÓÁ¨Þ–Á¡§hÁš|#Á“QÀÁŒ)¢Á…±Á|;øÁn{AÁ`ÄúÁS!ðÁE»TÁ8¤[Á+·jÁæÔÁQyÁ*ªÀô~kÀÝJÀǦ À²Ì‰ÀžùÀÀŒú;ÀwµÀYÞÀ=fMÀ$•5À œ¿ôuý¿ÓB©¿¸ n¿¢œ¢¿”šÏ¿ŒÏ½¿‹9!¿ŽÁ-¿–§ø¿ª%¸¿Ç¹P¿êûÀ áÀ"CÀ;…‚ÀXyÀv¨/À‹ólÀž#À°ÀÄ+ÀØÅ¯ÀîoSÁVºÁIsÁ{ºÁ&Û%Á3ÀOÁ@Á:ÁMÉ*Á[ ÓÁhÎKÁv¨Á‚E„Á‰B¯ÁZ*Á—ˆÏÁžÈ–Á¦þÁŸÀ;Á˜“ÿÁ‘kÅÁŠClÁƒÁx"aÁjAÞÁ\póÁN¤îÁAWÁ3ÄäÁ&ÓöÁäüÁ ü)Á—6Àé±=ÀÒ^À¼ ýÀ§±À’qŽÀ€?çÀ^ûÀ=ð}À!ÃnÀqU¿ßÖ(¿¹ž“¿˜Ôº¿v®¿L½û¿/ãK¿Çœ¿Î.¿#Š¿:‰ ¿c¶h¿þ-¿´Ae¿Þ§æÀ3BÀ!äsÀ=Ë"À]ýªÀ~¶ À‘¦À¤OÍÀ¸ÙöÀÍì»Àã=PÀúxLÁ áÁ@ÃÁ!õtÁ.ÿÁ<ÎÁIUÁVñÁd¶íÁr‚—Á€9çÁ‡G€ÁŽgÁ•—sÁœÔýÁ¥^ÛÁžŸÁ–ÎÈÁ›¼Áˆp5ÁGaÁtS3ÁfEVÁX{óÁJÏêÁ=$9Á/±]Á"|Á sÁ¸©ÀøuÖÀàdÀȱâÀ±cèÀœpÀ‡ôîÀikEÀF|cÀ$œ·ÀŸ¯¿Ü…b¿¬‚R¿„!ù¿D=¿ ¾¼|&¾yœ¤¾0áò¾JѾLæ¾›˜¸¾õ#µ¿8i®¿‚=¿«žÑ¿ÝA6À fÀ&9²ÀFEÀg÷›À† YÀ™/ÀÀ­ÀÂŒ*ÀÙuóÀðó[Áa0ÁŠÁN¤Á*máÁ7šÁEöÁRéÁ`ÐmÁn¸‰Á|¥çÁ…_„ÁŒ†Á“ÂüÁ›”Á£Õ®Áœ‡¼Á•:-ÁîñÁ†´ºÁ$AÁqÖÁbý¦ÁTþÁG;ðÁ9$Á,ŸÁÅ£Á»,Á½Àð‰!ÀØiØÀÀQjÀ©pÀ“–"À|YÀU« À1í`ÀX¿æ_|¿¯ö¿}WK¿)H¾ÂÎa¾FH<É>×>aq>|>Ö>Ez¶=°†$½ÒIÿ¾­ç2¿"V ¿{’M¿¬1¿å6ËÀÈãÀ/÷]ÀQByÀvåÁÀŽù'À£T"À¹ ÀÏÆCÀç‡qÀÿÈ®Á p5Á>pÁ&/íÁ3’~ÁA@fÁO!eÁ] ÎÁkùÁyYÁƒ¯iÁŠé²Á’7CÁ™ˆ·Á¢XŽÁ› £Á“»uÁŒtoÁ…=(Á|-áÁn·Á_éÒÁQÝÁCñ%Á6SlÁ(¾;ÁJÛÁMuÁk ÀéV•ÀÑ!#À¹7ÆÀ¡v¨À‹ÅŽÀmª³ÀD¬‰À lê¿ýR.¿¿Ÿn¿‡u.¿(qÞ¾¡‰ä½ ®î>N˜I>Ã+E>þ?H?6?ªÛ? $”>Û¢ý>ƒ>–;êؾ–³9¿%‰¿år¿¸ Ú¿ó×AÀGƒÀ=­ŽÀc52À…vÐÀš¾CÀ°—­ÀÇ×ÀÞý¡À÷à!ÁaÁpÂÁ"µJÁ0tÁ=”4ÁKv<ÁYw§ÁgµÁu¹nÁ‚õÁ‰\EÁ¥öÁ—ðŸÁ æàÁ™š6Á’YÁ‹ Áƒç’ÁykAÁk0ÉÁ]IÁNóÆÁ@ùŒÁ3EÆÁ%×RÁhÁ AmÀý’ÀãdîÀÊãNÀ³À›C½À…“À^ÌÂÀ7toÀÉ[¿ÞQõ¿ž=¿KZ¾ÈGw¼öÃ@>‘UW?Ø8?1ŠŽ?OÓ.?_0_?c'“?UcW?8B? B>¢Yž;çTz¾¥x¿6п‘üO¿ÍV¾ÀÝ¡À+Z5ÀQuSÀyƒÀ’HMÀ¨‰À¿Ã?À×à7ÀðBáÁѾÁÁSXÁ,²åÁ:m{ÁHCÁV-ÁdV¯Ár®_Á€”úÁ‡ßÑÁ,•Á–„mÁŸ¬|Á˜V™Á‘Á‰ßªÁ‚°ÄÁvö›Áh‹TÁZEÁL?øÁ>€4Á0Á‘Á#·Á·fÁ À÷D­ÀÝÛãÀÅ6ÚÀ¬íÀ•–’ÀÀS/‘À*¼À¤¿Á—}¿»b¿[<¾—u>e |? »ÿ?Keó?y…ò?‹¢ˆ?’ª…?‘®m?ŠŠ^?{±ß?Lã?®Û>”ø½^wÁ¾âlZ¿^œ ¿«[%¿ïO9À• ÀBvZÀjçðÀ‹|À¡0‘À¹CÀÑp~Àéè®ÁßjÁëåÁ ìÁ)‘dÁ7|ÁEåÁSƒÈÁa™ÁoÜûÁ~OýÁ†wûÁÙvÁ•@½Áž†…Á—&WÁÖúÁˆ˜×ÁeEÁtl²ÁfHÁWÂ.ÁIBÁ;¡½Á.Á žÁ;ÖÁâlÀñ£ŠÀ؇ À¿Ð³À§Š³À½Às©gÀG¡(ÀÖÀ¿ïZ뿨¡U¿O¹¾±&Œ=ŒŠÁ>åÎb?DûÐ?„H?›nP?ªch?°:?°Eõ?¨/?›*´?†NÕ?Rhà?ó:>:‰À¾PCµ¿%Ì¿Ž±¿Ó¯åÀ^àÀ5Á£À^‡•À…<½À›ÜÔÀ³'fÀËÙ$ÀäµÜÀþ{bÁ K>ÁxÇÁ'XÁ5ÙÁCéÁQ'Á_$yÁmÉÁ|ÚÁ…^äÁŒµÓÁ”JÁ‡_Á–/êÁŽâÁ‡–-Á€IÇÁr¢Ác¾:ÁUŸKÁG–“Á9ÔÁ+ÅŠÁE°ÁÊÖÁfýÀìÇ0ÀÓpËÀºÄ˜À¢>ÎÀŠ÷…ÀhƸÀ= QÀ«Q¿Ú@?¿‘»D¿Ⱦ(X9>‚[s?#E©?w.Õ?{*?µ{?Å/Ë?Ë?ÉÞ?Ã?´Nu?ŸÉ?…ï÷?Er>ÎÏ»’²¾áÿ¿mm·¿»DvÀ<²À*ËpÀTožÀ€CÂÀ–ûrÀ®ƒ]ÀÇ7²ÀàÀù¬/Á ÔkÁ ¸Á$ºLÁ2¬8Á@ªíÁN®8Á\æÄÁkX(Áy÷çÁ„RúÁ‹ªÁ“Áœ©ëÁ•NÁý˜Á†­™Á~¼YÁp)åÁaÆXÁSïÁE¡DÁ7©(Á)Â…Á%·Á¢(ÁIÉÀè´ÒÀÎïÇÀµã ÀØ?À† úÀ^ý.À3>ÈÀ «¿Æœ’¿{ü¾éﯺ½U‡>Ö+Å?Nø©?Žª?°@Œ?É9?Ù”Ÿ?àÍg?߯Ž?Ùl(?ÌÀ“?·OÙ?¥õ?sØõ?h‹>°¾”Œ¿Io‘¿©Ç^¿ôfiÀ"›fÀKåBÀxgEÀ’ÈâÀªnFÀÃÀÛʃÀõmøÁàäÁ´Á"ÅHÁ0Á>oªÁLxÁZ¿Ái>ÁwçÁƒQ=ÁН Á’ ÀÁ›þNÁ”Á0xÁ…ájÁ}8”ÁnÂMÁ`_²ÁR"ÁCúyÁ5ÜÁ'ßzÁA(Á ÔÀÿ1Àå#|ÀËaæÀ²"]Àš1ÊÀ‚[ÀW+ À+£ÐÀ/J¿µûm¿ZÆ7¾§+]> É2?³v?o÷h? Ú8?ÁâÖ?Ûr?ë='?ô#—?ò~%?íÖ?àŽð?ÌÕ?°÷?‹À,?70/>—ld¾" O¿'x¿šÏ?¿ä$£À_ïÀD» Àq@pÀ5rÀ¦æžÀ¿QuÀ×΀Àñ~¾ÁøÁ8ÁÁ ÕŠÁ.£âÁ<…òÁJ±êÁY¥Ág{ÁuýòÁ‚KjÁ‰¨ÜÁ‘µÁ›zÁ” ÁŒ¦šÁ…Q‡Á|"MÁm¹Á_SDÁPö6ÁBÎÁ4ÔMÁ&èOÁ6Á ­’ÀüÒFÀâA–ÀÈf@À¯‚À—)æÀ~†òÀQÇåÀ%ʤ¿öÅË¿©j¿>ôˆ¾hóÎ>‚.J?,ã?†àÑ?¯ „?Ð’L?éÒ/?üVI@†ª@»Î?ýE?ñSk?ݵ?À<0?šÊÍ?[-I>×µC½/š¿ Sû¿Œ˜¿×}\À4À>DùÀj¦QÀŒhÀ£þÀ»©?ÀÔV0ÀîÁC¹Áª-Á!Á,Ê™Á:ܪÁI½ÁWnšÁeÕUÁtiŠÁ‘ ÁˆñrÁZÁ›%ßÁ“ÁOÁŒ^AÁ…7Á{„BÁm ñÁ^çÁP*ÁAù Á4ªÁ&ÃÁKÀÁ ±®ÀúÚqÀàÀÆöñÀ­ëõÀ• À{¯.ÀNÀ Öà¿ïõa¿ ¡9¿,†Ø¾vÅ>­™˜?B“?‘ðÝ?º¾˜?Ü&š?öƒö@ûó@,µ@Sê@èÄ?þÌ®?ëÃ?Í%?§Òs?uzk?Ž0=I1Z¾éÌ¿\¤¿ËаÀaÀ8jÀdÌ?À‰,mÀ ˜ À¸á‘ÀѰ£Àëa±Á°;Á ÁÇZÁ+¡Á9ÁG“`ÁUå%Ádc/ÁsÕÁ€àvÁˆC¸ÁªnÁš÷CÁ“‰_ÁŒ„Á„æÁzùüÁlŽ&Á^*ÁOÎUÁA• Á3ŸTÁ%Þ³Á µÁ vßÀú6Àß÷íÀÆlWÀ­]ÑÀ”“-Àz\ÀLG¦À]Œ¿êõÒ¿›uA¿q˽ÉL³>Îðc?T5?œ0?ÂâÁ?ãFw?þ{µ@½ @ /ð@ W\@ vÉ@ñ4?öVí?Ø£â?³LÄ?…L¬?-,>8ݾÄha¿iš†¿Â#žÀ—À3W<À_,lÀ†ZPÀ¼ÂÀ¶ÀÏd…ÀèøìÁ®=ÁäÁaËÁ*LüÁ8w‘ÁF©¦ÁTÞ#Ác9ÀÁqÇLÁ€?˜Á‡ª”ÁÁšî¡Á“‹ÜÁŒ*Á„ÕyÁ{6ÁlDÁ^7´ÁO÷©ÁA¿ŠÁ3žØÁ%ÏyÁ)ŸÁ ˆmÀú–ÀàttÀÆš>À­‚ZÀ•¬ÀzjÀL½Àp5¿èïè¿™eE¿W½|Od>Ø<?]õ?Ÿã?ÈØ?èôˆ@@ åë@‡ @[@\œ@ )2?ýÇ ?àíä?¼Þ?Ž ¬?- ž>Jú¾È&¿WX’¿·ÞZÀÏÎÀ-šßÀZ,¡À„aÀ›¥ìÀ´AQÀÍguÀç ™ÁnœÁ Û»Á©ßÁ)„ìÁ7jzÁE‰eÁSìnÁbzúÁq qÁ¦¶Á‡0;ÁŽ›"Á›"Á“¡AÁŒG>Á„ùmÁ{eKÁlßmÁ^sÁP:äÁB×Á4 ¿Á&'×Á|Á ãžÀû#²Àá$ÙÀÇ`À®9À•²_À{’ ÀMI©À ³1¿ëu¿™oŸ¿Q½muó>ÚÊÑ?_¿s? d™?É}”?ì @]`@ ²M@÷"@…(@eJ@ ¯@B.?ç¤t?ÁÛ.?˜l?=¸>€a°¾~Å¿L2¿¯ÄWÀEõÀ*cÀVË©À‚^oÀš lÀ²ŸÆÀËZnÀå<ìÀÿÖ¿Á @¡ÁäÁ(¾«Á6ÐŽÁEúÁSP—ÁaËæÁp[çÁ~òDÁ†ÒÁŽ:{Á›>¿Á“âIÁŒmÁ…@ÞÁ{øÁmoÞÁ^÷œÁP¶5ÁB˜ÄÁ4%Á&ŽãÁü?Á ‘qÀüU&Àâ+ÀȇIÀ¯ˆìÀ–·»À}ÎÊÀOjÀ"hµ¿ïyH¿ž‘ª¿#»r½¿uŸ>Θ™?[f?žÑë?È?"?êÔ¸@·@ ºç@¸Ú@ª@ Å@u@n?é§Þ?Ķ?™Q5?Ivè>—úо`hv¿G“ ¿¬ÙS¿ý+èÀ)3§ÀT¤ÀÀ™!À™X%À±äÀË2Àäf ÀþÎoÁ åŠÁ€ŒÁ(Q9Á6pùÁD ¨ÁRÔ”Áa9^ÁoÒJÁ~”´Á†°ÛÁŽ\Á›­ÓÁ”W~Á0Á…«¢Á|®ÎÁnwÁ_Â9ÁQ–>ÁCr.Á5P~Á'kHÁÕÁ QÀýÕåÀãï!ÀÊ1·À±À˜`À€ªÀR´÷À&8w¿öŒ,¿¥½í¿3Ò¾2˜>´¬ ?Nȧ?˜±y?Á¾U?ä/ü@ð@ od@/$@[š@Éa@ *ƒ@Ü…?è=9?ÃG3?š ñ?MXx>œ`S¾l›¿JCÿ°+ü¿ý*ôÀ)+HÀU’áÀ®8À™zùÀ±à#ÀË0MÀäýÀÿ“Á ý‡ÁùÁ(HÁ6BÁDŠGÁRö.ÁacžÁoá Á~†ÃÁ†¤ ÁŽ2Áœ5ôÁ”ÛÁ‚ŒÁ†4Á}ãÁoh¤Áa3ÁRà ÁD¯ÕÁ6˜xÁ(´+Á)Á ‡Á­ÀæTŽÀÌ™4À³”´ÀšÈ;Àƒ!%ÀX‰ÍÀ*÷ˆÀ8Ç¿±A¿¿IŽÀ¾e×o>‰Ë?7P.?cb?·ÿ›?Ùcÿ?óº÷@¢@ Ç_@ T8@ )4@y©?ÿë?ä«?À£ˆ?˜O[?KÕ>ÚŽ¾…‰À¿Rwn¿µÀÀÍ‹À,;ÀWøUÀƒXCÀ›?À³¸7À̃½Àæ7ŒÁ.ÉÁ yTÁ1Á(üÐÁ6ÕyÁDôFÁSO€Áa¸[Áp*]Á~¸Á†·ÅÁŽ%GÁœÜÄÁ•…0ÁŽ5‘Á†ñ¡Á[¹ÁpÜÕÁbŒMÁTo’ÁFZjÁ8ESÁ*^ýÁÂeÁBxÁôFÀé²ÙÀÏÙíÀ· wÀž¨“À†T À_‹À39Àû·¿Á¸(¿g\¾»{º>%3?LR?y¦“?¦Õ?É(‹?áC‹?óú(?ÿƒÈ@%Á@ÕÂ?ý†Î?ñQ?Ø`€?·)‹?‹C´?-Í>Fü’¾¿¾\¿oöS¿ÃëÀÛ0À2À^”mÀ† ‚À•ºÀµã0ÀÏ$Àè”´ÁiÁŽ˜Á ¤Á)ß™Á7ÀÁE»dÁSý­Áb{‡ÁqÁ°ÈÁ‡)ùÁŽŒÁš¯Á–IpÁQÁ‡Ì*Á€–~ÁrÂ"ÁdvÁÁVLÁH!ÖÁ:åÁ,ZÓÁËxÁ@¤ÁÀîÀÔŽ¸À»PÀ£AÀ‹®“ÀhN=À<áòÀ— ¿Õ%Þ¿‹Ù>¿ e½ýd>ÕøB?NŠË??±ë?Ȇ¢?ÙoF?ãOQ?èÀS?éÉ?äOÆ?Ù>î?ÂBø?¢lå?q¬‹?…õ=³m¿h[¿Š`„¿Õ¼0À‹À:u6ÀfñÒÀ‰üÀ¡·ÓÀ¹¬GÀÒ©KÀëÛüÁåÁIÁ±nÁ+a Á9XÁGKôÁU_3Ác±´Ár7úÁ€iAÁ‡¹æÁÁžˆ@Á—?ƒÁ¶ÁˆÎ:Á–¾Át¯Áf€§ÁXqÎÁJkJÁ<ƒ½Á.ÎÞÁ!(ßÁ´_Á†bÀó+wÀÙñçÀÀÐ9À¨£iÀ‘dSÀtÔ ÀHÈÀr ¿ï÷ë¿¥uÿCk¾†á§>@–Æ?Ƙ?dˆA?‘˜ñ?©8ý?¸$?Á‰ã?ÆA?È þ?ÄÈ&?¸? r?"?1š>„¾Nÿ¿;…ö¿¥l ¿î\ÀÔªÀF¾.Àr€·ÀŠ9À¦Ä2À¾ÆÀ×J*Àð·KÁ)Áe“Á¬Á-A Á;ÖÁI&aÁW2ÿÁedÁsÎÁ.Áˆ}ÅÁÓÇÁŸšaÁ˜UyÁ‘!SÁ‰ñçÁ‚ÃîÁwOÁi$RÁZõ‡ÁLîÇÁ?-BÁ1~TÁ#ÜzÁ—‰Á –Àù8|ÀßöcÀÇ{À¯"À˜IHÀªÀXh-À.¹óÀâ¿Ç¨#¿ƒÖ+¿ ڽ׈q>Ž£,?‹¸?W7n?~Ñ-?|è?šnÜ?žcc?ž¦P?žy%?ŒÑ?nŽK?0YŒ>Å'2½''­¿4`¿€Ó§¿Åw À¾¶À.4¥ÀUÅÏÀ€]=À–œ À­(ÔÀÅ9ÀÜþ8ÀöUXÁYÁáÁ"}vÁ/ù+Á=™ ÁKøÁY§vÁgÔÙÁvÕÁ‚DÁ‰}§ÁºÝÁ ÔrÁ™™»Á’__Á‹1†Á„™ÁyçwÁk´ÃÁ]µ“ÁOñ0ÁB4çÁ4ŒñÁ'8ªÁûKÁ ê Á9%ÀçcãÀÏ ƒÀ·<(À vtÀŠ0ÀjØÀA„ÙÀ; ¿î×\¿­ˆ¯¿a5ü¾ãr™½•WŸ>|K!>ð¬«? ˜±?B¤£?Uì??`ù?`?\ï˜?BŸ›?û×>¤åÔ^Y°>° ›>Öˆ>æ‚N>ñ7Ê>áÃ>³­>*}¾½²*À¾Ê½K¿A•Ô¿•ƒµ¿Ñ¥™À ‹ˆÀ,ËüÀSFgÀ{—®À’©qÀ¨«öÀ¾¶”ÀÕñŠÀíó4ÁÁ‹ÃÁlîÁ)†Á6ØÁDIŠÁQæÁ_«OÁm™hÁ{´AÁ„õ­ÁŒ'fÁ“e?Á£ˆ/Áœa´Á•@kÁŽ!DÁ‡ÊÁ€BÁr/‚ÁdD÷ÁV¢[ÁI*Á;¼iÁ.ªÿÁ!ÌÁúÜÁ©‡ÀùÀá~KÀÊkÀ´z‰ÀŸ6yÀŠsŠÀn6pÀIµ³À(|ËÀ»_¿×õ!¿£>ú¿n房!¯û¾ÊR¾qc½ã‚̽*àG¼$¢t:æ| ¼³Â)½â87¾”¤7¿º ¿XÞ뿚„Ê¿Ì ÀÏØÀ!˜ÛÀBMTÀiµZÀ‰ÖÀž)æÀ³ŒyÀÉXÀßÞÀ÷ãÁü´Á(ÎÁ Ø„Á-ÑOÁ:ë_ÁH=ŽÁUÒÁc”ÁqVÁ%gÁ†–kÁ´áÁ”ê>Á¥;tÁž8Á–úæÁâ—ÁˆÙ©Áß$ÁuðÞÁhT¶ÁZÙÀÁMiœÁ@9ÒÁ3G@Á&x<Áÿ'Á «0Á¾MÀìiÁÀÕÈ¿À¿Û,À« iÀ— —À„7Àd?ûÀCî®À%ö§À 9]¿á[¿³h‹¿˜¿e>v¿:ND¿¶J¿ (é¿{¾ÿúÿ쿛˿GŸ•¿‚t°¿ª6¿×•]ÀÄ ÀËÍÀ=i>À\å÷ÀyÀ•…oÀªrYÀ¿¼OÀÕ}=ÀëɧÁqaÁ ?Áw¸Á&Á2ÑÁ?‡øÁL…ØÁYê9Ág£6Áu}iÁ«ÏÁˆ ÖÁ§hÁ–Â,Á¦ÿ%ÁŸæåÁ˜Ñ´Á‘ÁäÁŠÈÁƒí ÁzLjÁlˆÁ_G¨ÁR˜ÁEÖÁ8©Á+¡*ÁKÁ"àÁræÀ÷ÁÀáÖpÀ̽wÀ·×ÉÀ¤É¢À’ÛÀÀaþ ÀE%ûÀ(ÖáÀÙ'¿öŒ¿ÓPc¿¶«—¿¡—V¿“V¿ŠF‘¿…Ô*¿† ¯¿ˆ*y¿‘(©¿©«¿Æ#@¿ë¾ÅÀ GúÀ%9mÀ?ðÇÀZô À{=OÀ޶qÀ¢É À·ƒ|ÀÌè¾ÀâVRÀøvÁÁ+ÕÁ Á+GÁ8N’ÁE ßÁQáWÁ^ö†ÁlN Áyà%ÁƒÑÁŠÇtÁ‘Ì„Á˜Ò6Á¨ÿxÁ¡ø÷Ášó'Á“ùeÁŠÁ†DNÁ~Ý™ÁqC”Ácð›ÁVû&ÁJPŒÁ=¬Á19UÁ%«Á>‰Á ƒ0ÁKºÀï|éÀÚràÀÅߪÀ³/SÀ¡W¾ÀtÀB©Àe×VÀKùÀ2¾&À À %D¿þ†>¿éÍK¿ÛïJ¿Òì¿Î‘Þ¿Ï q¿Ó“²¿ß”;¿ògöÀ4ôÀ2“À/Á©ÀH'ùÀcÐÀOØÀ*ÀŸ§ÑÀ± TÀÅŸÀÛÔÀðŠ5ÁÁP*ÁÚMÁ%ŒÁ1¶ðÁ>àÁJ±‚ÁW˜2Ád¬4ÁqÂLÁ~íÁ†0JÁ Á”GÁ›ÓÁ«:+Á¤5Á;úÁ–[hÁ‡Áˆ´ÁïÁv‰IÁiƒ`Á\½¼ÁPDÁCS Á7Á+FŠÁ†‘ÁiÁ `#ÀýÄ2ÀèåUÀÕG¡ÀÂíÀ±cðÀ¡þÀ’0žÀƒ¹êÀnsQÀVÞ¯ÀBâ~À2½À%4ÜÀÍDÀ“FÀAÀ 9NÀYóÀÒNÀ# À oÀ-=8À?° ÀT¼eÀlÝfÀƒ¸(À’ õÀ¡&EÀ±|µÀ¸ÛÀÕžÀê‡ÀþñkÁ _îÁ^öÁ ËÍÁ,?ÔÁ8&ÁDv8ÁPÏêÁ]w%Áj|½Áw˜éÁ‚ZÁˆùGÁ¶RÁ–êÁ„÷Á­˜1Á¦¤bÁŸ³ÐÁ˜ÔmÁ’*Á‹_WÁ„ËÁ|Ž|ÁoŸÓÁbØ|ÁV pÁIÍ Á=ÎÊÁ2"Á&˜uÁzZÁ½ÎÁd¿ÀøaÀ圎ÀÓYšÀÂÏ’À²å)À¤6ÏÀ–¹À‰o’À|«YÀhó«ÀY$óÀLùÀB[áÀ<À7î„À5ßÿÀ6Ò-À9¸ÊÀ?ÏÀHðëÀU¢èÀg?À{‡šÀ‰œ&À–c0À¤º#À³ÔöÀÃ’:ÀÕ5;ÀçMØÀúܳÁ¨;Á)ÕÁEÁ(;ŽÁ3©Á?ABÁKTÔÁW±WÁd‘ÁpÅKÁ}²€Á…T;Á‹âæÁ’“øÁ™`#Á ?âÁ°¤Á©*Á¢J£Á›†ÏÁ”âYÁŽ[ Á‡×jÁS´Áu¼øÁi ·Á\ÁøÁP´ÛÁD´-Á91¯Á.#\Á#.òÁ§ŠÁXöÁ¯ÀöÊáÀäúîÀÔ˜:ÀÅ)1À¶îeÀ¨ÉèÀœÊwÀ‘w¸ÀˆuÎÀ€ÜˆÀu 7ÀkˆÏÀeÒ¼Àb2À`æÀ`²—Àc˜UÀiĈÀr[ìÀÓ¥Àˆ À‘±À*„ÀªËÀ·¼­ÀÆÛdÀÖµ‘Àç‡ëÀù¶Á(ðÁÛÁmJÁ$üÁ/õ…Á;C+ÁF­‚ÁRœ Á^Ó-Ák ‹ÁwoÁ‚(Áˆ„úÁ·Á••þÁœFÄÁ£¥Á²ÕëÁ«ú)Á¥8°Áž’ŒÁ˜ºÁ‘xIÁŠíÁ„i^Á|ÁoÅäÁcÑcÁWüèÁLKlÁ@ý‡Á6ÏÁ+FHÁ º‚ÁÿÁ –0Á6@À÷v&Àç«ÌÀØ‹]ÀÉÎTÀ¼µÀ°ÑŽÀ¦fHÀëÀ•ɉÀ¢ƒÀŠè¸Àˆ_ÝÀ†µÉÀ†.À†V:À‡Á{ÀŠ”¡À#¿À•S¬ÀO{À¦ƒ[À±¹ÑÀ¾ {ÀËk—ÀÚN-Àê ÎÀúùÁ>Á<ßÁùhÁ"îÇÁ-kaÁ8 |ÁC=rÁN¤.ÁZ1Áf2Ár`ÌÁ~ëÁ…rÁÁ‹ÌÁ’N?Á˜âÚÁŸ}šÁ¦)°ÁµÓ.Á¯ Á¨VœÁ¡»ªÁ›3Á”°¢ÁŽ3ëÁ‡ÔPÁ¢èÁwJ5Ák‡aÁ_Æ&ÁTjÁHåTÁ>9äÁ3°Á)•/Á dÁ“tÁ ÒüÁsÕÀúåÿÀì ÀÝàÖÀÑCDÀÅ-À»nÀ²æDÀ«SdÀ¥‰À¡:¶ÀžsÇÀœèeÀœ‚™Àœ¿"Àž%SÀ ñËÀ¥¸ À«OéÀ³nÀ¼,ÀÆÌ¹ÀÒMãÀß×Àíñ<ÀýëõÁ ÁÁ¿ØÁËlÁ"HÁ,wÁ6^îÁ@äSÁK¯«ÁVí]ÁbOúÁnƒÁyüŠÁƒÞÁ‰*ÚÁf(Á•À×ÁœB<Á¢×¿Á©r'Á¸ã‘Á²,Á«ÒÁ¥¶ÁžœŸÁ˜)Á‘ÑOÁ‹‘Á…„ðÁ¨ÁsRÁg«vÁ\T—ÁQŒªÁGÁ<µ‹Á2Á·Á)D‡Á 56Á˜ÉÁF7ÁOÀÁA¶ÀòïSÀæV÷ÀÛV¶ÀÑz`ÀÉÀÁʸÀ»õ³À·àáÀµ"ÅÀ³×GÀ³SÔÀ³Û´À´á×À¸ öÀ¼fyÀ‹ÖÀÉÁÀÒœ+Àܧ¢ÀçæºÀóÌ)Á¿Á %ÁÁ—[Á"hìÁ+È=Á5fqÁ?y–ÁIì{ÁTloÁ_q3Áj²€ÁvKÁ€ó¿Á†óŽÁŒüÁ“/ÕÁ™øÁŸâWÁ¦]¶Á¬åòÁ¼*”ÁµéÁ¯ 5Á¨ÍÁ¢&WÁ›ÛùÁ•®ŸÁ„kÁ‰k·ÁƒxíÁ{uiÁp7ÜÁeÁZÁP¶ÁEÓ$Á<3Á3%›Á*ÑÁ!nÁ˜2Á žÁ ëãÁ=ÀûäÍÀñÆÔÀçø½Àà ûÀØß¬ÀÓtÞÀÏ1µÀ̽äÀËàÀÊÆ§ÀË+ÀÌ’XÀÏßVÀÔ"ŠÀÙôíÀàåªÀéƒÓÀó†Àþ;Á¾ÖÁ k¯ÁkóÁŸpÁ#ØúÁ,¥äÁ5Ÿ@Á?= ÁHùÍÁS:[Á]²ÀÁhbÓÁs‚:Á~Á¤Á…@Á‹Á‘XÁ—#íÁY-Á£°¢ÁªAÁ°‚#Á¿¥BÁ¹yÁ²ŒÁ¬)´Á¥êªÁŸÀÁ™–·Á“sƒÁx©Á‡³!Á‚†ÁxôÁnbÁcÃÔÁY‡âÁO‘°ÁF+5Á=(šÁ4a&Á,@@Á${NÁäéÁõŸÁu¶Á †vÁ}ÓÀÿ@ À÷¯¿Àðh1Àë9ÀçˆÀäØoÀã\ÑÀãfÀãx[Àä ¤ÀçâoÀìFèÀñã"ÀùdÁ½2ÁkyÁ ¢vÁc…Á¬lÁ&ÿÁ&Á.HfÁ7¶Á?òIÁIRLÁRìvÁ\ç ÁgèÁq·?Á|ƒÄÁƒÖïÁ‰‰¹ÁN<Á•@#Á›JêÁ¡^ÕÁ§“KÁ­æÞÁ´?ÐÁÃ*}Á¼ªbÁ¶HÔÁ° %Á©äãÁ£ÂHÁ¥kÁ—§­Á‘×ÛÁŒ4Á†–ËÁ>Áw©8Áme)Ác_ ÁYƒþÁPX«ÁGœÉÁ>þÿÁ7âÁ/g Á'ÝŒÁ!E‡ÁÝ•ÁF?ÁL]Á ¥Áö×Á{tÁý£ÁÏÀýx-ÀûìÀû‰JÀüG‘ÀýãQÁu·Á‹sÁv4Á©ŽÁ ÌÑÁsSÁˆ¹Á"5Á"O3Á)DÁ1•Á8ñ,ÁA…ÝÁJ`ÁS‘ÀÁ]3ÁfÀlÁpçõÁ{9cÁ‚ðŸÁˆYÒÁþŠÁ“¼-Á™‚ÀÁŸv)Á¥†Á«šÁ±ÎÁ¸!šÁÆé§ÁÀ‰ñÁºFÁ´XÁ­õÁ§åÁ¡êùÁœ 0Á–_!ÁÇÁ‹EsÁ…íÞÁ€«‡ÁwLiÁmk%ÁcíRÁ[©ÁR7DÁIæÇÁBáÁ:ƒïÁ3~ùÁ-tÁ&½þÁ!eüÁO–ÁéÞÁ4ÓÁáñÁd‡Á ’iÁ n1Á ¾°Á yÁ çmÁ §ôÁ PzÁeçÁýÂÁ0‹ÁñÁÆ•Á"¼ëÁ(ÃÁ."Á4›Á<0ÁD1—ÁLn ÁU5‡Á^tÁg‚eÁqîÁz÷ÞÁ‚ŸŽÁ‡Ù¶Á$Á’™ºÁ˜HÁž^Á£ÔÁ©ËpÁ¯×rÁµêÁ¼!ÁÊâ#ÁÄeÁ¾Q†Á¸-LÁ²*]Á¬0¾Á¦G2Á ‹EÁšüýÁ•xÁÁŠÑºÁ…ºÔÁ€ÍÚÁwøÁn»ÞÁeá½Á]QUÁUBAÁM^@ÁF@ßÁ?xÄÁ8ò'Á3 ¯Á-§~Á(ÆüÁ$˜¦Á ãóÁÉÂÁ2^ÁuÑÁCƒÁ¡Á‡ÈÁûîÁÁ"ÁL”ÁPîÁÉ Á"mÁ%ã1Á*-»Á/0†Á4ŒÁ:OÁ@sÜÁG›ËÁO¢áÁWÍÁ`@UÁi`Ár5@Á{¢–Á‚¬²Á‡¯¥ÁŒÔ£Á’·Á—u¾ÁœøìÁ¢©[Á¨g Á®6ôÁ´1Áº=³ÁÀVíÁÎåkÁÈŸ½ÁÂz‡Á¼x$Á¶ûÁ°•¨ÁªÒbÁ¥<{ÁŸ³`Áš?´Á•ÁïÔÁŠç™Á† ¢Á`…Áy¤UÁq#ÁÁháõÁ`×ÔÁY:vÁRM˜ÁKx!ÁEFÁ?Z]Á: ëÁ5\Á1TâÁ-¹¿Á*á€Á(u9Á&±Á%uuÁ$®Á$°Á%$ Á&"Á'–AÁ)hÀÁ,eÁ/8pÁ2ïÊÁ7-Á;ájÁAWkÁFý¶ÁLÝUÁS™ëÁ[4«Ác>æÁk•ÁtPÁ}$‡Áƒ+uÁ‡ížÁŒå-Á‘ä¹Á—þÁœlLÁ¡Í>Á§\‚Á­FÁ²ÆÕÁ¸›9Á¾—óÁİýÁÓZÁÌãÁÆßŸÁÀî!Á»ïÁµ9Á¯›ÒÁª ÉÁ¤NÁŸEÃÁš-@Á•jÁ%ÜÁ‹v}Á†ã=Á‚ƒZÁ|§!Át‚CÁlÆ*ÁesûÁ^ŠÆÁW¶ÊÁQ§×ÁKåùÁF܈ÁB0‹Á>LáÁ:¶ÄÁ8 ûÁ5ÃÒÁ3ôrÁ2ÚKÁ2 [Á2/‚Á2&Á3bÁ5»Á6óÁ9Á<†’Á@ÁD(¡ÁHÜGÁN3?ÁSÃ+ÁY¤µÁ`TÁgB`ÁnÝiÁw ÁoKÁ„¦Áˆ­ÁM€Á’*ÃÁ—%`Áœ,ŠÁ¡lÁÁ¦É•Á¬2•Á±ÊüÁ·jÁ½:†ÁÃñÁÉ\Á×c ÁÑ^†ÁËqMÁŇPÁ¿·ûÁº ¿Á´~/Á®þžÁ©§ÇÁ¤„ºÁŸn³ÁšgÑÁ• Á‘öÁŒœZÁˆQ­Á„sÁ€7ºÁxß±Áq¶¾ÁjçõÁd[ŸÁ^q“ÁXѪÁSø¢ÁOkÁK–-ÁHüÁE|DÁC"PÁAlÁ@JÃÁ?º5Á?ÛxÁ@D®ÁA?0ÁB³’ÁD¥ÁG¡ÁIáeÁMHªÁQWäÁV PÁ[$–Á`‹HÁfrÁlç§ÁsÃlÁzó¯Áb!Á…’ÐÁ‰Ï©ÁŽO`Á’èžÁ—™˜ÁœˆÁ¡^Á¦–¡Á«ã½Á±BpÁ¶³ŸÁ¼RòÁ lÁÇÆBÁÍ¡œÁÛòÁÖÜÁÐlÁÊ>]ÁÄ…¸Á¾ñ¿Á¹|‚Á´%þÁ®ìÁ©ÒÁ¤Ê¿ÁŸî–Á›L¾Á–ÇåÁ’nÁŽ)«ÁŠfÁ†IoÁ‚‡|Á~$+ÁwaÒÁq(£Ák<¬ÁeßEÁaqÁ\ÂÉÁY }ÁU‹!ÁRåBÁPÏÁO-©ÁMü"ÁMzÁM•GÁMï‡ÁOäÁPŽoÁRZqÁT¿QÁW…‘ÁZãNÁ^µ;ÁcL·Áh9GÁmqÁs@Áyº„Á€HØÁƒ·—Á‡tÁ‹ƒrÁ¶¿Á” òÁ˜•QÁ/ÄÁ¡ùˆÁ¦ñÁ«öõÁ±œÁ¶h«Á»Ë^ÁÁJ¯ÁÆådÁÌš9ÁÒaÁà›ÎÁÚ­0ÁÔÉ„ÁÏáÁÉmzÁÃý*Á¾¬üÁ¹dtÁ´6ÂÁ¯3ýÁªXÕÁ¥¡mÁ¡KÁœŒ½Á˜PÅÁ”,PÁC“ÁŒpÏÁˆÌ8Á…aIÁ‚ %Á~ »Áx,«ÁsüÁn@yÁj3FÁfŽ.ÁcUÁ`“·Á^ªÁ\øÁ[ê†Á[fìÁ[y†Á[Õ;Á]ÞÁ^lÊÁ`>ùÁbšÁeqõÁh¿yÁleŠÁpÍ ÁuÍÁz©NÁ€ÁƒF²Á†¦¥ÁŠÊÁ¡¥Á‘’—Á•©êÁ™ßlÁžRÁ¢ÝÁ§€dÁ¬`³Á±g¬Á¶|!Á»Ÿ¥ÁÀí³ÁÆ_ÆÁËæíÁÑzEÁ×-ÙÁðÍZÁë±ÁåW…ÁߎÁÚA ÁÔÜ÷ÁÏ¡MÁÊp`ÁÅZ¥ÁÀ_rÁ»yëÁ¶ËmÁ²Y`Á® JÁ©Î6Á¥Ç×Á¡ûäÁžNiÁšÉšÁ—š”Á”ÁÁ‘ý¯Á]ÁâÁ‹¢Á‰>ÅÁ‡ƒÁ†4PÁ…|Á„»Áƒj–Á‚à.Á‚…:Á‚rgÁ‚²[Áƒ ŽÁƒ‘@Á„[~Á…T)Á†ŽÙÁˆ%Á‰Ç¸Á‹ºKÁå ÁQUÁ’çÁ•ÑÁ˜ÔŸÁœÎÁŸv^Á£´Á¦ê~ÁªÅ@Á®ÍEÁ³ŒÁ·¤·Á¼IÿÁÀôáÁÅÇòÁÊÎqÁФÁÕU¼ÁÚ¬!Áà%ÒÁåÅmÁì5Áæ(µÁà_8ÁÚ¹tÁÕ4@ÁϾ.ÁÊcoÁÅ%³Á¿ôÅÁºîûÁµúÁ±&jÁ¬)Á¨4DÁ£æ¡ÁŸÁÌÁ›è¨Á˜8JÁ”—†Á‘EÂÁŽGõÁ‹{qÁˆÃ;Á†b&Á„huÁ‚‹Á€Æ]Á~ÊÊÁ|ŒßÁz‹`Áy%¤Áx KÁw-#Áw °Áw‰oÁxE…ÁyŒsÁ{1äÁ}6ãÁÈÁfÀÁƒ+‹Á…dÁ‡WƒÁ‰¼FÁŒpÁZÁ’s¨Á•Õ™Á™J×Á ÐÁ ä˜Á¤ÓÁ¨ÿaÁ­p~Á²¥Á¶¿MÁ»‰[ÁÀ€çÁÅ©ÃÁÊøÁÐK©ÁÕ¼¿ÁÛUüÁá±ÁçduÁávpÁÛ”ÀÁÕΙÁÐ.)ÁÊ´¹ÁÅP4Á¿ýêÁº¶ˆÁµŽ Á°—¤Á«±ZÁ¦ó²Á¢w…Áž&¹Á™áûÁ•ã’Á’04ÁŽŠ$Á‹™Á‡óiÁ…7Á‚QÁ£vÁ{(Áw´åÁtRÁqd:ÁoÁmÉÁkwðÁj_åÁi•±ÁimýÁi½WÁjŒ±ÁkþCÁm¬ËÁoÖÁrw^Áu¡Áy=–Á}3gÁ€â±ÁƒNÁ†àÁˆÿÁŒ;`ÁžðÁ“.nÁ— Ášÿ3ÁŸæÁ£`êÁ§åÛÁ¬Š3Á±Q¬Á¶HfÁ»h¸ÁÀªWÁÅü’ÁËháÁÐýUÁÖ´gÁÜvÁâÎäÁÜËQÁÖå‡ÁÑÁËR›ÁŸ§ÁÀIâÁºíäÁµždÁ°\[Á«DñÁ¦`DÁ¡‹ÜÁœè&Á˜†òÁ”5%ÁzÁŒ7’Áˆ…cÁ„û\ÁÅCÁ}fqÁwü¥ÁrÚÝÁnwkÁjpðÁg/EÁd4.Áa|dÁ_œXÁ]öÓÁ\ÝkÁ\HëÁ\ Á\/MÁ] «Á^v¢Á`;«Ábu Áe'•Áh}Ál)ÁpX,Átø(ÁzÁ®ÿÁ‚ÒGÁ†Á‰YÁ61Á‘2Á•6“Á™sNÁØîÁ¢\»Á§Á¬ÏÁ±2sÁ¶aÁ»®JÁÁ/ÁƬoÁÌa¹ÁÒ®Á×äóÁÞiäÁØF9ÁÒB‰ÁÌa¶ÁÆžbÁÀî}Á»\Áµé!Á°‹šÁ«?¦Á¦.Á¡þÁœL—Á—‡rÁ“ÖÁޱ>ÁŠe´Á†]úÁ‚—¹Á}Ö>ÁwAÅÁq)–ÁkŽmÁfe×ÁaÎÊÁ]…ÊÁZŸÁW6ÁTDaÁRRYÁP»)ÁO¢ëÁOóÁNõ ÁNøÁOÜyÁQ3¢ÁRý½ÁUAÁW÷sÁ[ZÁ_<žÁcƒ ÁhXüÁm»ÁsgWÁy ÊÁ€½Áƒ“(Á‡i¼Á‹eÑÁŒ<Á“ìYÁ˜UŠÁœø Á¡ÝØÁ¦üLÁ¬&\Á±`TÁ¶Ç†Á¼[ÁÂaÁÇË­Á͘`ÁÓÁÚ5AÁÓõÈÁÍÑÔÁÇÏ“ÁÁò(Á¼<Á¶ 9Á± 5Á«ŒïÁ¦*Á íGÁ›á¬Á— ;Á’AíÁÁ‰({Á„Þ2Á€¡ÁÁyt´ÁrÁk6cÁe$³Á_WÁZ\ÁUJZÁQ ÁM@FÁJ 4ÁGqjÁE5¾ÁC˜ÝÁBª!ÁAôcÁAô^ÁB# ÁCÓÁDRÏÁFÐÁHCÁK^ÁN^ŒÁR`åÁV¹~Á[èÕÁa]ËÁgAúÁm¦yÁtfîÁ{®£Á¤ÿÁ…«¯ÁŠTÁŽwÁ“Á—ÎEÁœÚ„Á¡ùrÁ§#ÉÁ¬LÁ² –Á·Ä#Á½€òÁÃOÙÁÉBóÁÏPâÁÖ fÁÏÚÁÉ™cÁÃuîÁ½v Á·;Á±ïLÁ¬XÁ¦ÂŸÁ¡69Á›ÔNÁ–­òÁ‘ÅôÁ‘Áˆ8êÁƒ£ÏÁ~¦ÇÁvåÁmä¾Áf~‰Á_£ðÁY7.ÁS?1ÁMÂ?ÁHÚ¼ÁD˜HÁ@¼æÁ=]‰Á:â(Á8cæÁ6˜Á5ºÁ5!TÁ5#Á5wÁ6k4Á7²†Á9w‰Á;†Á>‚1ÁAÕµÁEÅÁJJ5ÁOÁU+ÜÁ[+fÁaÊ0Áhü ÁpJòÁwîÁ€*7Á„¨Á‰0”Áé2Á’ÛhÁ—ðÊÁ Á¢XéÁ§Û™Á­ŽúÁ³QóÁ¹dÁ¿WÁÅ$ŽÁËRÊÁÒlÁËÌJÁÅŠnÁ¿U¦Á¹1¼Á³2²Á­\ˆÁ§²ÊÁ¢aÁœøÁ–õ Á‘£6ÁŒ‘ÓÁ‡¾òÁ‚öÅÁ|sÌÁs‘ƒÁkKÁbÜVÁ[ÁT?ÁMµNÁGMÁAŸ Á<ÑWÁ8E Á4VÁ1 GÁ.U¾Á+æ„Á* ƒÁ(ëUÁ(næÁ(hÁ(äHÁ)ÕyÁ+•Á-õÁ//yÁ22~Á5µ]Á9”Á>HÜÁCb¤ÁIÁO>·ÁVQ§Á]«^ÁeLÁmËÁuÈBÁ~È[Á„ 9Áˆõ‰ÁñÎÁ“Á˜\KÁЦÁ£xÁ©9“Á¯ÙÁ´ð'Á»ÎÁÁ/>ÁÇ`ÁÎ,ÁÇÅkÁÁ}Á»H³ÁµÁ®ð‡Á¨ðÜÁ£šÁv`Á—ÞÙÁ’TÖÁŒÞxÁ‡Ÿ°Á‚¨BÁ{¬¿Ár êÁhÄ=Á`= ÁX%áÁP:oÁIÝÁBN8Á;ÉÁ5ÈuÁ0ìÃÁ,h}Á(ABÁ$ØrÁ!Ø´Á©\ÁÉ$ÁަÁ‘Á„ÁŽ9ÁQçÁ›VÁ ¨WÁ"Ù¦Á&¿Á)ŸœÁ-ÙûÁ2žUÁ7ÎRÁ=eÁCÝBÁKÑÁRsÁZFDÁb¨bÁkRÁtl´Á~+ÅÁ„ Á‰ ÄÁŽv7Á“ñ…Á™€'ÁŸ'ØÁ¤é®ÁªÓŸÁ°çbÁ·Á½@ÄÁƨÁÊyŒÁÃóøÁ½‹eÁ·BÝÁ± $Áª×ÅÁ¤¯§Áž°)Á˜ßŸÁ“B™ÁÁÆÁˆFTÁ‚àTÁ{~”ÁqÄÄÁhÓÁ^‘9ÁUªÁM…pÁE‘?Á=ðQÁ7¢Á0m‡Á*ŠõÁ%Z7Á ÍPÁrÁûþÁÛÏÁ}¿ÁŠ[ÁFÁ×ÁßéÁr)Á3—ÁyÈÁm¢Á£ÁçxÁ¢Á"G*Á'%Á,‹vÁ2O]Á8Ú Á@šÁG¬SÁO¥EÁXI%Áa*ÉÁj©rÁtuÁ~¤ÃÁ„•'ÁŠMÁ£úÁ•4dÁšäœÁ Ç;Á¦ÖïÁ­Á³<@Á¹‡bÁ¿íÁÆÿ·ÁÀcÍÁ¹Ü$Á³r%Á­(ÚÁ¦ê‡Á ­UÁš†Á”‹ÆÁŽÄ@Á‰2ïÁƒ´qÁ|sÓÁqÛaÁgà Á^:XÁT—ßÁKzyÁC)ÖÁ; ñÁ34[Á,0ºÁ%zÁzøÁ',ÁIQÁàdÁ ]Á 7dÁ©¤Áµ[ÁeàÁëÁÊöÁWÁO´Áx"Á^Á ÿÊÁhÁwÁ´ Áç^Á!‰ÕÁ'™Á.ÝÁ5iæÁ=ÂÁEgÀÁNnpÁWªÁaUhÁk8~ÁuzÁ€(;Á…½DÁ‹`+Á‘@Á–å]ÁœâJÁ£qÁ©@[Á¯šaÁ¶ Á¼‹ßÁÜÁ¼îÁ¶]nÁ¯ÓÁ©e6Á£ ÁœÛ¾Á–£HÁ„cÁŠ”ÁÁ„Ú_Á~#ÁsqÁh}ÑÁ^ÁT[ÚÁJ²ÁAY#Á8Ö”Á0ÔHÁ(ÞŽÁ!®ùÁ UÁœ£Á'“Á %UÁ¼QÁÅ+ÀýnÀøK¹ÀôS·Àñ£:Àð.0ÀïëÞÀðä[Àòè’Àõ7hÀùPGÀþç ÁÎúÁß°Á ]žÁëÔÁ¶Á #Á#éCÁ+N™Á3HÁ;Ä«ÁDÚ3ÁNmVÁX§ÁbÃÁl³ÆÁwåÁ¨`Á‡_ªÁ•Á’ÿ~Á™ÔÁŸQ¶Á¥·8Á¬2lÁ²­êÁ¹4 ÁÀ>Á¹…ˆÁ²çåÁ¬WÐÁ¥Ê×ÁŸXÌÁ™ TÁ’ÔªÁŒŸ­Á†nÁ€³xÁvÖÁj×]Á_º<ÁUoÁJíÄÁA6UÁ7ŽêÁ.§™Á&Ž´ÁŒ´ÁPÁ_åÁ ÚÁXðÀþ®±ÀõmÆÀíŒyÀç;Àáê‹ÀÝ“"ÀÚÒéÀÙ‹˜ÀÙyÀÚEïÀÛèÍÀÞ¢RÀâ6öÀè2ÀïQŠÀ÷¼”ÁØEÁÅÁ 7wÁÙÊÁüPÁ!®FÁ)±àÁ254Á;”€ÁEb|ÁOK ÁY­ÁdVÁo³•Á{1–ÁƒkõÁ‰KyÁTÜÁ•;Á›îÁÁ¢_¢Á¨Ô>Á¯SÁµîVÁ½-èÁ¶^ãÁ¯¢ëÁ©ÇÁ¢kÕÁ›Ú>Á•hÁkÁˆ× Á‚£5ÁyCQÁm¸“Ábo=ÁW&}ÁL,ŸÁAØÄÁ8 ïÁ.mhÁ%'\Áâ”ÁÑÁ 8þÁSùÀÿÄTÀô-hÀé˜UÀàVÏÀØPÀÑaÀ˽5ÀÇ7ÀÄÚÀÃ< ÀÃLÀÄÏÀÅeðÀÈvIÀÌŽÀÒ<½ÀÙ=CÀâÂyÀìùkÀønÁ%Áµ«ÁUÁT°Á jüÁ)F[Á2ú°Á<æ¢ÁGÁQ¾_Á\Ágó¸Ás¤™Á[~Á…§ÕÁ‹Õ¯Á’0ÆÁ˜£ÁŸfÁ¥”ŽÁ¬0aÁ²éJÁº,˜Á³aiÁ¬7Á¥Ú}ÁŸ,DÁ˜”ÄÁ’`Á‹ª¡Á…WßÁ~ ŸÁq®´Áe ÁZSŠÁO±ÁCÀ=Á9¼Á/ >Á%\—ÁÕ8ÁK3Á SþÁvëÀùºÀ댣Àà! ÀÕ"…À˧AÀÃf›À¼i9À¶…áÀ²=†À¯y¹À­í3À­_À®-{À¯§HÀ²¨áÀ·NÀ½0[ÀÅ5©ÀεÀØÚÀäÐÇÀñÀþ–ÁÄÁ÷ÁÙ+Á!dÁ*æÁ4Á?!ÖÁIË&ÁUµÁ`§¬Ála7ÁxAÍÁ‚EGÁˆ’ÁŽøCÁ•lÁ›ïµÁ¢“©Á©IºÁ°MÁ·Z=Á°vjÁ©©jÁ¢á<ÁœÛÁ•`(ÁŽÇïÁˆUèÁ‚ÍÁwZ¼ÁjÕÁ^ !ÁRÃ!ÁG,´Á;íGÁ1Á&“TÁÀèÁ€Á  ÁEÀôŽÀåÈÀØ:ÀÌD/ÀÁM À¸ IÀ¯Z†À¨DÀ¢À ÀšO1À™;1À˜ï+À™§§À›1àÀ[žÀ¢±JÀ©c"À±ÐÀº²'ÀŲñÀÑ©òÀß,*Àí‚rÀü#¢Á‚_Á¿nÁýáÁ"âÁ,ÈxÁ7<–ÁB55ÁMÐiÁY—-ÁektÁq¤‚Á~,lÁ…_÷Á‹Ã¤Á’M‡Á˜ùÉÁŸ®ÔÁ¦mÁ­<µÁ´´ðÁ­´ÞÁ¦ËÆÁŸûÊÁ™77Á’ylÁ‹Ä’Á…-•Á}k2ÁpªíÁd<ÁWÖïÁK·®Á?äÿÁ4R†Á)bOÁ²ŽÁGÏÁ ÉMÁ•®Àò@¬Àâ#2ÀÓOÎÀÆ*xÀ¹õRÀ®ÓÌÀ¤À›´hÀ”%SÀŽb"À‰¾åÀ†¥´À…fCÀ„¯ÛÀ…ªiÀ‡]0À‰ï*ÀÒôÀ–5]ÀŸ-^À©S À³Ô*ÀÀìÀÎ^¶ÀܶtÀì]“ÀýB*Á»âÁaÁdÁ%šcÁ01ÔÁ;aLÁG0ÁRÕÿÁ^ó\ÁkiÁwé·Á‚N`ÁˆÔ9ÁvÃÁ–‹ÁœØlÁ£® ÁªžzÁ²@œÁ«*´Á¤&Á9ˆÁ–hKÁ±»ÁˆÿÁ‚RÁw‚4ÁjhZÁ]‰µÁQÒÁDëxÁ8Ö‰Á-GßÁ"4"ÁMÁ §ÁÒáÀó 5Àá)fÀÑgÀÁ{¬À´\ºÀ§èÐÀœrìÀ’vÜÀ‰‰NÀ¡»ÀwLfÀm(hÀg…»ÀdbÀcØ4Àe LÀh{ÀnÂÀz|±À„™•À©À˜FÀ£v­À°0­À½‘¡ÀÍ8RÀÝ™¬Àî+0Á[ŸÁ :Ám£ÁæÇÁ)|ïÁ4¼ÓÁ@¤åÁLÀÁXìÁebÁr§Á!ÉÁ†+YÁŒÈ|Á“~®ÁšT8Á¡EÁ¨BÒÁ¯ç¨Á¨ÎÙÁ¡ÅcÁšÌ-Á“åƒÁ"Á†MäÁöÁqÎýÁdÇ@ÁWÜEÁK7Á>ÃÁ2rÁ&•ÁMÁ@ƒÁPhÀöŸÀãÏÔÀÑW:ÀÁ!À±|cÀ£S§À–(ÀжiÀ€òØÀonnÀ`.¯ÀS®ÎÀIˆƒÀCa@À@D³À?­4À@ñºÀDÝúÀL\hÀW6Àh­ÒÀzmgÀ‡¸…À“ðxÀ é~À®ÝÀ¾µÔÀÏ0þÀà›ÀÀò™§ÁFYÁ Î¥Á]IÁ#H/Á.ÅDÁ:¿ÁFÀ«ÁRðÕÁ_——Ál¥mÁyß.ÁƒEÁŠ<­Á‘ Á—üÕÁžùÆÁ¥ôÁ­¾pÁ¦–»ÁŸzÕÁ˜u‹Á‘Š#ÁНÿÁƒÖšÁzÆÁl«ËÁ_}¦ÁR”øÁEÊÁ9£Á,Ó«Á Ë=Áð‰Á ©ñÀý¸hÀèåÈÀÕÜÀÂòéÀ±óÀ¢I¿À“ÅÀ†í0Àv;DÀa}›ÀNÓŽÀ>fÀ2ZqÀ'ÙÅÀ!±?ÀñçÀiÀµnÀ#À+ À8+¹ÀIsÞÀ\r÷ÀqðÃÀ…(’À’ÕBÀ¡m_À°œœÀÁÁWÀÓfžÀåÐtÀùö´ÁXÁ6úÁ:ÚÁ(à³Á4ð-ÁA"ûÁM¦ÁZ”žÁg—SÁt°ÁXÁ‡ÍÊÁ޹¥Á•®³Áœ§ Á£¯¡Á«ÒÜÁ¤©ïÁ€<Á–f‡ÁdMÁˆxÙÁ’ÁuXCÁgÇÁZŠNÁM—ÂÁ@ªHÁ3¿OÁ'* Á$yÁPËÁ«pÀñ¢VÀܲYÀÇýÀµÊHÀ¤ÊÀ“Á}À…­üÀoʺÀW±ŸÀA»ÚÀ/EgÀ (åÀ›’Àe\Àû%¿ûü-¿ùnî¿ý£NÀh¿À xüÀÍnÀ*úÀ@QBÀVüÒÀoÒôÀ…/HÀ”ÉÀ¤.0ÀµTÀÇGGÀÚDÀîL‘Á®úÁ OYÁ~±Á#iÁ/bÁ;ÚÇÁHµ½ÁUÀêÁbÐÊÁp4Á}=Á…°1ÁŒ”!Á“ƒyÁšŒƒÁ¡©Á©÷ÉÁ¢ÌBÁ› ºÁ”xDÁdkÁ†kÁLÁqVÁcª÷ÁV2RÁI>Á<"VÁ/4%Á"`žÁ ¼Á ?ºÀý}Àæ‚ÀÑšæÀ½NÀ©Ñ À˜c À‡/ ÀqP…ÀU±eÀ<Ø»À&ònÀ~ãÀl¿ì‰9¿Öõº¿ÉÔt¿ÀÃ"¿¾#ò¿ÃFU¿ÏhD¿âÊ>¿ÿÙÈÀá›À$æ À=8¶ÀV±lÀqMÀ‡ëÀ˜³À©@À»VnÀÎoßÀãF€Àø%EÁAÁÈÍÁ˜¿Á*ŸÁ7ÁÁD _ÁQ(ÝÁ^U¶ÁkÏ]ÁyŒ”Áƒ®DÁŠ¢/Á‘™tÁ˜¢ÁŸ»°Á¨CÁ¡¡Á™ÛÝÁ’¼jÁ‹§ïÁ„Ÿ›Á{V©ÁmŸœÁ_ëâÁRO0ÁE RÁ8gÁ*ý ÁBdÁaÁùÀô&¹ÀÝ ÀÇ• À²ü¿ÀŸ:QÀM"ÀxCÉÀYÊ!À= ÀÀ$ 3À çà¿óþh¿Ô!¿¸-¿¢Ü¿’¨T¿‹>ñ¿ˆ!¿Ž¿šÝ²¿±*#¿Ëº¢¿ò À >ðÀ#˜5À=ã&ÀZ¶WÀw÷ÀŒ²CÀâÀ°aVÀÄ4ÀØ&×ÀíKôÁ,šÁ ãäÁÚ Á%ütÁ2¥ÕÁ?›îÁL¬„ÁZnÁgÅWÁu«áÁÊ Áˆ¾¢Á¿[Á–ÓúÁþöÁ¦¼ÁÁŸy*Á˜BˆÁ‘¸ÁŠ ãÁƒ2Áx.Áj!OÁ\~ðÁNò"ÁA}ÄÁ4b›Á'dòÁŠËÁ.;Á©Àì©ÀÔÕŽÀ¿`ZÀª!À•ŨÀƒÚÀedÀEÌcÀ)9‚À>¿îŸˆ¿Å:ο¢û0¿ˆ8¿cÒ¿Fµú¿5µ•¿1¶¿;¶¿Se…¿€²Ä¿žaá¿Àü!¿íQ­À {¾À&èmÀCúøÀb’ÿÀ¶¹À“cÀ¦^À¹Ò.ÀÎç:Àä§$ÀûZÁ kjÁŒÖÁ"¤Á.×ÒÁ;¶¶ÁHômÁVcÁd ‡Áqæ/Áå@Á†öEÁŽ…Á•*ìÁœfKÁ¥J“ÁžÁ–ÓnÁ²¿Áˆ 6ÁŽ ÁuFÁgNÁYZ‚ÁKã±Á>P0Á1 „Á$&‰ÁF'Á ¢ùÀý7ÆÀåP°ÀÍ–:À·ÉYÀ¢ÙÀŽ •ÀvçNÀS€À3õìÀvñ¿ö€¼¿Åâå¿›9†¿r\¿8”"¿ 8|¾ãÁ¾¿‚h¾¸ ¾ÎNI¿º<¿.WÒ¿eíÔ¿—ÆT¿Âæ¿ðõ°ÀŸ‰À.ÚIÀN.ŽÀo¼ŠÀ‰Ó5ÀœÂ+À±dÀÆT¾ÀÜ5¼Àó4çÁ@dÁ‘EÁ Á*ønÁ86šÁE€•ÁRå&Á`›hÁnvòÁ|dÒÁ…9ÞÁŒ[ÏÁ“”†ÁšÝ÷Á£üáÁœÇ&Á•‘—ÁŽ\XÁ‡4Á€²Ár2ÁdD ÁV|aÁHñ=Á;‚uÁ.$<Á!/(ÁqÄÁ½À÷3ÆÀße¿ÀÇ» À±¡èÀ›ÑÛÀ‡¿öÀh¦ÀDª–À$B•À!œ¿Õ¶õ¿£®¿nÇ•¿%1¾Õ4…¾‚›*¾ ý.½¯x¢½¡MH¾~ü¾if¾Ì…Ü¿9#¿gkØ¿œQ¿ÊÀÁÀ2æÀ|ÝÀ;^À\èÀÀÒÀ”% À¨¼ÔÀ¾^hÀÔ“ÀëÒ4ÁèÁ%ÌÁ­ÂÁ'±ëÁ4ßÐÁB."ÁOµ—Á]„CÁkm‹ÁyqÁƒÉÜÁŠîƒÁ’#©Á™fûÁ¢µÑÁ›„3Á”UMÁ&gÁ…òÁ}”ÁozmÁa¡“ÁSí›ÁFKÁ8ÏñÁ+¦ Á›pÁ¡2Á°Àñ¥ÕÀÙ6¤ÀÂ<—À¬,øÀ–¾Àg>À[^îÀ7ÌÀä¿ðw¹¿·Á5¿…Ž%¿0û¶¾ÅѦ¾0~<¼D/>#Õ>2Û>,×=íW<¢o¾Hþ¾³7¿!1ÿ¿uñῨñA¿ÝªˆÀ À+K“ÀN)ÅÀrøÀ1sÀ¡ŠêÀ·F$ÀÍŽ™Àåt:ÀýžÁ þ{Á×Á$ÊþÁ1ÔÅÁ?(>ÁLÛvÁZÏ÷ÁhËÚÁvÌjÁ‚o­Á‰“Á̓Á˜¿Á¡ûÁšI‘Á“ !Á‹Û9Á„´9Á{*ÍÁmtÁ^þÁQDƒÁCÔ6Á6sÁ)Áº“ÁÔÁkÀì•ÀÔ6]À¼¸¨À¦ZóÀVÀw\ãÀP<À*ôçÀ ˜¿Öƒ¿çä¿Ta…¾ðäU¾0"=“Æ@>~&V>¹,Ó>Ï]>ÏðH>®ps>vV5=´á½èsm¾½–¿9«¿‹Å¿À’‡¿üúÀËlÀA1<ÀfÉQÀ‡uÀ›ÖUÀ±ÖƒÀÈŠÝÀßÃàÀøGÈÁhÁ4&Á">~Á/SñÁ<°wÁJkÁXb]ÁfbfÁtd>ÁF¨ÁˆtåÁ¸ýÁ— ±Á Ÿ÷Á™SˆÁ’iÁŠÈ]ÁƒŸfÁy ¡ÁkâÁ]¬ÁO+ÍÁA4Á4BÁ&šÜÁ^YÁ ŽDÀÿâ±Àç6éÀλˆÀ·µ)À¡!À‹ ÜÀl»ŒÀE‰lÀ a¿üx\¿¾¡•¿…±x¿&};¾³r<›sÿ>‡'S>àÚ€?g¸?¦Ù?½-? 1T>àra>¦¸=¸f.¾$!·¾ÿÎß¿fhÝ¿¨ù¿ä¸TÀñÀ5¬cÀ[üÀ‚ ¼À— ¬À­%lÀô ÀÛÆÀóÁÏÁJ9ÁìÁébÁ,üÁ:l/ÁH-üÁV½ÁdTÁrÇÁ€+²Á‡a˜Áެ\Á–%ÁŸÂÁ˜rÁ‘"iÁ‰Û`Á‚©^Áw!iÁi!Á[(éÁM7ëÁ?ˆÓÁ1õÁ$‚FÁm`Á ‰aÀûSÀâ£%ÀÊ´MÀ²×#ÀœSÉÀ†t¢ÀbÙÒÀ< À@Ô¿éu¿ªÀ¿cʾú^¾ á>9ï>ÓNƒ?Ÿ3?6þ*?D¼?B„¹?7âM?k¶>íÑð>‰â¿À¶Q¿×?¿™ô¿ArY¾µ¢Y<:],>œbî? ’?=Ìß?ZP9?j9?g¿{?\ãe?F7¹?!,Y>×Ud>!©Æ¾>Æï¿ÿ½¿„÷q¿ÁÂÀ:À%ùdÀK×ÞÀu£À@ìÀ¥œSÀ¼7IÀÓ·€Àì »Á=ÁÕÁÁûGÁ)=ÄÁ6£bÁDNæÁR¡Á`6ÁnNÌÁ|°0Á…ŠÁŒÄÁ” Áž~=Á—-øÁïKÁˆº&Á…³Át¬FÁf~›ÁX„õÁJ˜öÁ<´¸Á/¥Á!ÌãÁˆuÁSÀõ6ÀÀÜv¢ÀÄ0ÃÀ¬v©À– ÀÀÞÀUXÀ-ðÀÑ´¿ËªM¿Œƒ*¿&W¾mSº=êcD>Ô$*?'¯Á?Y»{?{ð‚?„ì?„"i?|g?eøº?An? ë¬>ˆ˽Œ€É¾ì ø¿ié^¿³ºF¿÷ÊÀ¾NÀEùÀnÆ{ÀŒÏÀ¢`OÀ¹©ÀЄÀè#Á˜GÁ ?#ÁKôÁ' —Á5 ÁB ÁPeLÁ^x¦Ál«Áz÷Á„²ìÁ‹ýåÁ“Y@Áž5;Á–âcÁ ÝÁˆc´Á&áÁsçÁe°¯ÁW¶OÁIÐÞÁ;û©Á.CnÁ ÞœÁ¥qÁeÀóèµÀÚݹÀÂ6^À« À”5QÀ{+ÀQÊÀ*0Àk¿Á೿€ää¿i˾Õ>MÌD>þ%Â?@â[?rNØ?‰_F?ËÇ?‘i®?й?€ÀÆ?[U@?#Œë>ºYd=µi¾·7¿S d¿¨$ô¿êcËÀ$À?GZÀhpÀ‰WÀŸxTÀ¶8"ÀÍ¡ Àå­ ÀþŠïÁ íÁì"Á&ëÁ3åÁAZ@ÁO3æÁ]'bÁkHëÁy•§Á„ÎÁ‹L‚Á’¢•Á÷`Á–¢Á^ÿÁˆ*Á€øOÁs”]ÁeXsÁWUVÁIŒžÁ;Î Á.,Á pÁZAÁPoÀóbÀÚU@ÀÁòÀªj#À“d³ÀyÛrÀO\À'y¿ÿݨ¿»Ü(¿už§¾ÿ‚½·Û>‰8É?Ó?M΃?€ê/?’2?šÊ,?› û?•Õm?г?pÎ?9D)>æzF=ç„`¾’„¿>ýl¿ž‚¿à$wÀ¾jÀ:tÀb1ÎÀ†¸¦Àœ­žÀ³fÀÊÎ'Àâë¥Àü5‚Á È¿ÁÓéÁ% ƒÁ2Z¸Á@ÁMþÇÁ\%ÁjW4Áx:ÁƒxwÁм8Á’FÁžÁ–³ÙÁh"Áˆ*„Á€ÿ Ás¾Áe…ÁW]ËÁIwqÁ;ÍâÁ.(Á ¯¼Á—FÁ‹ÀóspÀÚ€®ÀÂCeÀªc)À“E>ÀyïJÀNdÀ&˜G¿ÿ —¿¸B¿mº:¾ìW8½S®!>š X?PL?Yï?†_š?˜øé?¡??¢ÑB?Ÿ L?“*²?€ ?K—?I>HŠO¾cï¿+š¡¿”•¿×¬°ÀPÀ5MfÀ]ç\ÀƒÛ!ÀšE`À±6ºÀȳãÀá@õÀújÁ ÖìÁªÃÁ#ÝÁ1°Á?Y›ÁM4©Á[®ÁiEìÁw¦ÀÁƒûÁŠa¶Á‘«¥Áž%GÁ–Ø Á‘CÁˆOÁ³ÁsþÁe×ÂÁWÈ,ÁIÔŠÁž7œ?þ6?^Ÿõ?ˆÀ?œÏ?¤@ ?§$M?£§?šî$?ˆÙ?WÙ[?t§>xôÖ¾®¿]U¿Žs]¿Ð}À ó À1ÒÐÀZ5žÀ‚|ËÀ˜•ÝÀ¯­ÀÇ/ÀßœlÀøRøÁÞ&ÁýÁ#iˆÁ0Ö¦Á>Ž­ÁLsñÁZ“?ÁhÊ»Áw©Á‚ÂgÁŠ èÁ‘TmÁžeŽÁ—ÁÙ7Áˆ”àÁYñÁtnQÁfQäÁX;ÁJ;PÁ<гÁ/bÁ!³…ÁVtÁW=ÀõjçÀ܈ÀÃÉBÀ¬7À”Ê À|Ô¼ÀQ¦}À)2®À–鿼Ù¿rq¾öµ÷½f5o>šér?^q?\¬?‡ _?› ?¥ÄÇ?¨_?¥_?ãt?‹ ?]Ò?€¦>‰à¬½Ð²À¿ŸÁ¿‰Z‡¿ÌâÅÀ ùIÀ/Œ$ÀXð4ÀÏáÀ—’¹À®ËmÀƈ¨ÀÞÙ°ÀøhÁ™·ÁÏÁ"÷Á0„ëÁ>)ôÁL½ÁZ5‹Áhe9ÁvššÁ‚~DÁ‰ÆÁ‘!DÁžÕ†Á—€ÒÁ/õÁˆìÁ½ýÁuNÑÁg+ÁYÃÁKcÁ=fÁ/ÖÕÁ"U©Á*tÁG|Àöò„ÀÝêßÀÅk8À­É÷À–…³À€GsÀU#êÀ,Ä·Àl(¿Ã8è¿€°å¿ýK½ãN>‡¤Œ?8ë?Oj%?³?”cä?¡3N?¤ô&?¤Œ?›;Ü?ˆa4?ZÄ›?ÉÒ>‰W‡½»Äð¿›Ã¿‰Œ+¿Î'ÓÀ ç+À1k–ÀXéÖÀ¼IÀ˜‰À®ìiÀÆ”þÀÞ÷ À÷ì%ÁÕßÁÁ Á#¡Á0 êÁ>A\ÁKýxÁZ“ÁhPÁvºCÁ‚“ÙÁ‰Ð¿Á‘RÁŸUÁ˜èÁ¿áÁ‰ƒÓÁ‚ZøÁv‚9ÁhNãÁZ+¦ÁL>ÊÁ>—*Á1Á#~|ÁSÁ tÒÀùEeÀàkSÀÇ©ÏÀ°jÀ™BrÀ‚À[, À1âåÀ I¿Í¿Šéœ¿°¾9T>/ŒR>÷Fþ?:ˆX?nØ?‰?”ÇÖ?™Æ°?™Nñ?*º?à?R; ? Pé>„ƒ)½ã+9¿>m¿‹óÉ¿Ó –À µ@À4r%À[…ÀƒI?À™*¹À°iéÀÈL˜Àà¯FÀùgþÁ rOÁh@Á#OÁ1gÁ>×ðÁL¢½ÁZŒòÁh¶„ÁwäÁ‚½ØÁ‰ô–Á‘7ÇÁŸý0Á˜¹Á‘x ÁжfÄ?¢Í?JYó³7>.„í¾VêË¿&[/¿˜4’¿à˜ÀTÙÀ:»"ÀbuÀ†®ÀœCFÀ³ ¿ÀÊ—÷Àâ© ÀûÀ=Á ‡ÓÁ“µÁ$¹¢Á2ûÁ?ªºÁMiÁ[]ÏÁifŽÁw¬[ÁƒŸÁŠ^8Á‘«›Á Ì±Á™ŒÜÁ’U?Á‹ ´ÁƒüòÁyÏBÁk¦IÁ]ìÁO¸gÁBÁ4‡GÁ'öÁïÁ ØÁp?Àç½@ÀÏÁLÀ¸(À äåÀ‹‹Àk6äÀCY[Àg¿òáu¿¯âÒ¿dÚ$¾õy=½ãóô>L à>Þ|c?÷,?9Íq?NX]?W¤¬?Z^?O•ê?< n?t^>¥>Ù<°þ¾»É¿O ¿¨ïÅ¿ðRöÀåÀC5gÀkÿÀжÀ 1;À¶¯ÃÀÎn™ÀæaÑÀÿ@ÂÁ 5òÁûÁ&8óÁ3žÁA‹ÁNöÁ\íqÁjÞ ÁyãÁƒ¬_ÁŠî´Á’:ÿÁ¡½½Áš†¦Á“P/ÁŒÁ„öðÁ{ÓÁmË™Á_Ò­ÁR‰ÁDo©Á6â“Á)•ìÁdþÁ’ÁÀìÿ+ÀÕóÀ½Ã¨À¦·…ÀµlÀw‡KÀOo‡À)ÏÀÙˆ¿ÊÝJ¿Ž¿2(ù¾¦‚½½e>D+`>º|J>ú|ƒ? ì?,­?§"?sõ>þÈ>¥g¡=¸w¾Pî¿í¿€À¿Å-À–ÌÀ)ÆÀOQÀvÊ Àƒ²À¥—À»ÔJÀÓBÀë¨Á¶üÁo¡Á5«Á(L/Á5 ¡ÁBúƒÁP*Á^ŽoÁl•WÁz¡—Á„mÆÁ‹£TÁ’í]Á¢Ï¶Á›Ÿ5Á”oÊÁJyÁ†4iÁ~A‹Áp-ÐÁbQ÷ÁTŸ ÁFìÁÁ9kYÁ,SÆÁddÁ+ÁõiÀóf<ÀÛ?•ÀÄ&vÀ­£|À—÷+À‚ë—À^·PÀ9ŠEÀAÉ¿ìš[¿±¤á¿sx¿ʾ¡–½À(ä=‚®ª>>>>‡pÀ>“fK>–vo>’´G>K¦¾Á Á¶žÁ%#åÁ1ØuÁ>Á-ÁL°ÁYt!ÁféÍÁt™­ÁDÁˆP-Ág*Á–„ŽÁ¦ËRÁŸ°Á˜—øÁ‘“kÁŠ”ÛÁƒvÁyxçÁkë—Á^sYÁQ"ÁDÁ73?Á*|•Á"ÖÁäOÁoÀõn—ÀÞö“ÀÉ‘üÀ´ÐÈÀ ä¬ÀŽöÀy'áÀYWÀ:ÍDÀœÙÀ£Š¿ár"¿½Ç¢¿ ÝI¿ŽLõ¿~C¿mbç¿dQˆ¿_nB¿f¿|o¿’´…¿¯Ð¿Ö/1À^IÀÀîÀ4³ÔÀSQÀrw&À‹JwÀŸ'£À³SÃÀÈJxÀÝøÀóÞÁD©Á= Á<>Á)UÁ5ø$ÁCÁP#~Á]h4ÁjÛøÁx€oÁƒ!/ÁŠÁþ2Á˜ ¾Á¨fnÁ¡OÁšJ?Á“L6ÁŒPÑÁ…gŸÁ}:5ÁoÆ!Áb\ºÁUC'ÁHmAÁ;›¸Á/¿Á"õ,ÁöòÁ UÀÿÕÁÀéùÙÀÔÓ;ÀÀ=æÀ­6«Àš¶ïÀŠ Às¹qÀV“§À;gÍÀ#)›ÀŒ¿úC}¿ÞÌ¢¿Ê%›¿¼¾“¿²WE¿®{K¿­Ê%¿°À˜&ÀŠy¾Àz¡­Àd\¬ÀOå!À?ÎÀ2ªDÀ(nÀ"$Àœ¸À”èÀ'TÀG-À!á¼À,AnÀ9 ¿ÀI­ÁÀ^ÛŸÀw_ñÀˆ³uÀ–À¤NaÀ´±9ÀÅ˸ÀÙV:Àî(ÊÁÍ”Á £Á8Á"‹ Á.0ÐÁ9ßÁF=ÁRŽÁ_K™Ál ÷ÁxöóÁƒÑÁ‰©£Áf$Á—9Áž'qÁ®YsÁ§jÁ ‘7Á™ºûÁ’äÔÁŒWÁ…v>Á}ð*Áq?¥Ád›/ÁXoÁKÁ7Á?á¸Á4ëÁ(xxÁ™tÁ ÁЦÀüž Àê1aÀØM°ÀÇ-òÀ·±ûÀ©À›bØÀާ-Àƒ‚Àt Àc´]ÀWJìÀM¦ÍÀFèCÀBªùÀ@±–ÀAŒÀC72ÀI<;ÀPß‹À^þÀn…ñÀ©ÌÀ`NÀš-ÊÀ§¯ÚÀ¶:ÀÆ+;ÀÖʹÀèDîÀüv‚ÁäWÁžêÁs‚Á)~@Á4íRÁ@ˆ“ÁLlèÁX³QÁehÁq¸Á~²XÁ…ä6ÁŒoBÁ“ªÁ™¶£Á ‰Á°µÁ©×YÁ£‹Áœ4¡Á•yÁŽÕÜÁˆQÌÁë‰ÁwÁjWgÁ]ð,ÁR]ÁFG—Á:˜¥Á/k¢Á$Í¿ÁOÂÁòñÁ?ÀùóÀÀèhzÀ×õ'ÀÈê ÀºPÀ­ÄÀ ‹ÜÀ–ÀŒ£‡À„êxÀ}@½Às÷Àme Ài?,Àg-ÀhúÀjºÀp“eÀxàñÀ‚­¥ÀŠëÀ”Z™À *BÀ¬“xÀº=ÎÀÈäsÀØ9Àè¶ŒÀú#áÁu©Á£¶Á÷Á%ÄÁ0°°Á;ýdÁGoºÁS ßÁ_)§Ák‚eÁwç°Á‚OûÁˆÑ’Á^»Á•ìëÁœ‹ÄÁ£ELÁ³.JÁ¬V Á¥—¥Ážï´Á˜_tÁ‘Û¾Á‹_ÁÁ„ú9Á}6ÏÁpÉvÁd³SÁXÏ|ÁM'¢ÁAî•Á6×ËÁ,>—Á!å·ÁÇòÁtÑÁR(ÀùèàÀé°ÀÚÛ ÀÌ¥«À¿^“À³nÀ© ÀŸ¿aÀ˜q¹À’ŽtÀ¼ôÀŠõlÀ‰¥ÀˆåÀˆÿÀ‰êeÀŒ¾ÀÈVÀ—†Àž– À¨LõÀ³O«À¿»âÀÍ}ÀÛ}2ÀêîÒÀú×›ÁP Á\ÆÁØÁ#GdÁ-®ÁÁ8€ýÁCІÁNåPÁZ^ÚÁf2TÁrf2Á~ÉÁ…›ºÁ‹ùÁ’pÁ˜éþÁŸwTÁ¦$ÍÁµÖ»Á¯Á¨w¬Á¡ïÌÁ›kêÁ”è4ÁŽm×ÁˆÁÞ’Áw¨!Ákž´Á_Ó‹ÁT’£ÁI‹1Á>°%Á48úÁ)üOÁ cžÁ´ÁûÁàÀûýêÀí˜ÛÀßaÝÀÒŒÙÀÆàÀ¼ÄÀ´ òÀ¬ïÑÀ§)À¢„ÇÀŸüÀžGvÀAVÀ”èÀžóÛÀ¡¸ŒÀ¥Ê¤À¬7À³­À¼^‘ÀÇKtÀÓg¦ÀàS†Àî²sÀýãéÁþçÁwÑÁAÁ!ØšÁ+ÆöÁ5ý7Á@ˆÁKOäÁV’#ÁaãWÁmŽÁy§NÁ‚ïYÁ‰dÁGŽÁ•¤wÁœ¢Á¢žAÁ©-“Á¸ÎÁ²*lÁ«›ÄÁ¥TÁž„ôÁ˜7Á‘âÁ‹fAÁ…^„Á~Þ‡Ás·Ág«Á\d÷ÁQ„NÁFÆÐÁ<]KÁ2¸Á)JßÁìcÁSÌÁgçÁ¹mÁSßÀò¬hÀæ¡ÍÀÛ'úÀÑ¡ÀÈÿ:ÀÁçÀÀ¼`ÈÀ·ÖŒÀµ~À³ïÚÀ³C°À³þÀ´ëÀ·‘»À»µÀÁ‚ÇÀÈØÀѵÀÛþôÀç‰âÀô`ÃÁ»Á§õÁ§¸Áê4Á!ÅQÁ*ðéÁ4£Á>“øÁH÷KÁSŽÁ^†+Áiç‘ÁuS*Á€‡Á†œÁŒ´ŸÁ’Í‹Á™ÁŸccÁ¥æYÁ¬yƒÁ»ípÁµSìÁ®ÌÁ¨HåÁ¡ËÁ›fMÁ•)9Á Á‰1§ÁƒPþÁzâpÁoa°Áde>ÁYÇbÁOD°ÁEF¦Á;´éÁ2I§Á)KÁ!Á0ÁsóÁ FXÁ­AÀûÖÀð+¤ÀæÇˆÀÞ²ÿÀ×ÉRÀÒABÀÎ+ZÀË ÌÀÊ'¬ÀÉæÀÉ÷¿ÀËQºÀÍù7ÀÒE&À×ÝÀÞsGÀç{UÀñHCÀüNËÁY”Á 7ÆÁiÁ’ƒÁ"ÃÛÁ+nPÁ4gÁ=õèÁGÅEÁQë–Á\kiÁg‘Ár;×Á}’`Á„‰ÁŠzÁw­Á–ŠYÁœ´ÆÁ¢ó3Á©S”Á¯ÕôÁ¿(/Á¸©Á²2Á«½¶Á¥^ôÁŸ ÚÁ™àÁ’ÿ ÁÿÁ‡8œÁrcÁw½PÁmÁbªÁXRÁNufÁDöþÁ;ã Á3BÁ*ëRÁ"ÊXÁ›(Á –Á:Á6»Á)üÀüþ5Àô׿Àî@¡Àè¢%ÀäÇÈÀâR¿ÀáãÀà‘"ÀáRÀâ.Àå ÀèýwÀîÜ<Àõh»ÀýÓÁ­¦Á UÁÊ>Á$ÜÁœ€Á$¬ÇÁ,­ˆÁ5D]Á>ÁGu‹ÁQäÁ[ gÁexÊÁoíaÁzÃÁ‚ÿ±Áˆ¢·ÁŽpnÁ”jÁšiÁ ~Á¦ºùÁ­ ±Á³myÁž«Á¼&ÊÁµ¸™Á¯fÁ©2Á£ŽÁœé¿Á–æÁ‘¶Á‹^ Á…ÂÍÁ€JÈÁvÙÁk± Áat™ÁWàZÁNÐÁEdžÁ=&«Á5qÁ-cSÁ&?íÁb´ÁßrÁQÁfÁ ÂeÁQÁ¡mÁ™Àü,pÀùÎÀøXBÀ÷ûÀøU¯Àù­½Àü¹$ÁPRÁ" ÁsÁ H­ÁÁrÁΚÁ¾Á&ß[Á/xÁ7& Á?p!ÁH9åÁQ6ÁZÐ[Ád„6ÁnºÁy2ÁàÆÁ‡_ÁŒþuÁ’¦Á˜}°Áž~TÁ¤ƒïÁªœËÁ°ÜsÁ·9$ÁÆFÁ¿¸ÖÁ¹q5Á³CtÁ­ãÁ¦ïÂÁ â¥Á›ÈÁ•T«Á¹ÁŠ&fÁ„ÌŠÁKhÁu ûÁk*\ÁaÔ#ÁXË”ÁOðÍÁG··Á?ç°Á8DÁ1 ØÁ*ŒÁ$/ùÁåöÁßÁm1ÁÁ2ÁTZÁ å$Á þ»ÁìãÁ:FÁÜÁBxÁÉBÁ _­Á [«ÁTÁhªÁG¶ÁæõÁ»gÁ%\_Á+.|Á1Ú«Á9îÁAœÍÁIÞ'ÁR¬Á[…†ÁdÞöÁn~‚ÁxgÕÁIŸÁ†Œ›Á‹î-Á‘t¶Á—ÁœÒHÁ¢­EÁ¨®«Á®ºþÁ´Ö”Á»SÁÉÐdÁÈæÁ½^ØÁ·;9Á±ËÁ« *Á¥"†ÁŸjÄÁ™Ì´Á”2/ÁŽÅõÁ‰’-Á„tÑÁ~äéÁuõÁkídÁc-ÅÁZ‡‘ÁR‰EÁJÓ ÁC*3Á"žÁ:H¡Á6•ÜÁ3¼_Á1<Á/³JÁ.˜HÁ-û½Á-ÎRÁ.?ÁÁ.íÅÁ0jÁ2`EÁ4ÆÁ7ÃNÁ;LÅÁ?‹úÁDK]ÁIb>ÁNâsÁTáQÁ[_2ÁbβÁjàjÁs èÁ{œ'Á‚6¶Á†ÈÁ‹ƒ“ÁSÒÁ•X{Áš{“ÁŸ»jÁ¥ ‹Áª|ÉÁ° {ÁµÞ‡Á»¢*ÁÁ†ðÁÇbÁÕã³ÁÏÔÁÉÛ:ÁÃäñÁ¾ %Á¸ZµÁ²Ï}Á­I·Á§äöÁ¢­‡Á•HÁ˜š!Á“½PÁZÁŠ€ÆÁ†0’Á‚eÁ|¸Át4'Ám*Áf_ØÁ_¾ÁYÙZÁT; ÁOSÇÁJÈ]ÁGvÁC€Á@ËÕÁ>^ŽÁ<̆Á;&Á:ëÁ:ï=Á;W÷Á<:·Á=›zÁ?\FÁAÕ³ÁD»ÃÁHg_ÁL`xÁPË)ÁVAÁ[{oÁaH»ÁgrRÁn‡ÁvXíÁ~|“ÁƒjÁ‡¹ÀÁŒ<ºÁØÈÁ•™³ÁšŠ¦ÁŸŒåÁ¤´¥ÁªaÁ¯^Á´ÜÁº‡[ÁÀ=ÞÁÆFÁËë•ÁÚ/ÍÁÔ9!ÁÎE¹ÁÈg½Á°©Á½ÆÁ·“NÁ²"QÁ¬äIÁ§ÐÁ¢¿WÁÐçÁ™‚Á”Á‘Á‹ì Á‡ÕcÁƒÜ4Á€!=ÁyRÓÁro·ÁlŠÁf<«Á`¼ Á[ø‹ÁW‹ìÁSÙ«ÁP!ÁMÿÜÁKªeÁJ aÁHómÁH2áÁH8ÁHž8ÁI›åÁJñ[ÁL´ ÁO/¿ÁR ¦ÁU‡>ÁYlÁ]·¸ÁbÙÍÁhR’Án¯Ásù0Áz®'Á£Á„üÍÁ‰ŠÁP6Á‘¶SÁ–N…Ášî§ÁŸÈÁ¤Ã„Á©ÆÁ®ûìÁ´V Á¹¶ºÁ¿?’ÁÄï}ÁÊ¥žÁÐlhÁÞ­eÁؾAÁÒÝcÁÍ! ÁLjÔÁÁùþÁ¼ Á·3’Á²…Á­1Á¨EÁ£:Áž¦eÁš'2Á•ßBÁ‘®ÛÁ±”Á‰ã+Á†?tÁ‚ÊèÁ~ÏîÁx²ÁrèiÁm¨aÁhé>Ád±ŒÁ`ì¤Á]»ÍÁ[PÎÁX÷½ÁWk²ÁVW¤ÁU¼íÁUÕºÁV7HÁW&ÁXoLÁZ]–Á\­BÁ_h“ÁbÁýÁf{ÁjíZÁoÓÁu.eÁzÌ$Á€bÏÁƒ¡ÕÁ‡+ÝÁŠçDÁŽä=Á“Á—X—Á›ÝDÁ v³Á¥'ÈÁª,Á¯hÁ´?Á¹`¢Á¾¾/ÁÄ%ˆÁɶQÁÏiÒÁÕ!:ÁãJLÁÝfxÁןØÁÑúÁÌmDÁÆõâÁÁŸ‘Á¼uòÁ·_êÁ²R|Á­vœÁ¨×ØÁ¤U`ÁŸõåÁ›­\Á—ÆÁ“·ÐÁñEÁŒc‘Á‰ Á…»Á‚¿ÁÉÁzÌdÁv™Ár ÔÁnPÁk&6Áh° Áf|½ÁeGÁcØEÁcbuÁc†›ÁcßßÁdÜyÁf5‚ÁhdÁjS—ÁlåÝÁp*ìÁs¼IÁx+ÊÁ|ìßÁ…ÁƒÈÌÁ†Ê3ÁŠ »ÁwÁ‘¦Á”×°Á˜ùÛÁ/_Á¡Œ>Á¦¦Áª¹ÖÁ¯©Á´w«Á¹ržÁ¾OÁÃÞkÁÉ=%ÁάÁÔC"ÁÙö÷ÁówPÁí»ÕÁè"µÁâªÁÝ@×Á×î„ÁÒªéÁÍ}$ÁÈ}gÁÃXÁ¾¾ØÁº%gÁµÅÔÁ±vŠÁ­F<Á©\(Á¥­RÁ¢)Áž˜oÁ›uœÁ˜„cÁ•ÈéÁ“1ÁûÅÁ.Á=Á‹™OÁŠGðÁ‰(Áˆ<°Á‡:Á†ý0Á†“LÁ†ƒ¼Á†³fÁ‡ÝÁ‡½Áˆ†CÁ‰Š†ÁмÈÁŒ9÷ÁêoÁÉ›Á‘å Á”;Á–¿Á™•Áœ„¡ÁŸÃ+Á£*ØÁ¦²|Áª€ŒÁ®h×Á²f½Á¶UÁ»wÁ¿®àÁÄ\ ÁÉ,ÐÁÎ&ìÁÓHãÁØ‘šÁÝã—ÁãJÕÁè×ÁîÉÁèñaÁã: ÁݦçÁØ9¤ÁÒÝDÁÍŽ'ÁÈGËÁÃ'(Á¾6ÐÁ¹WÜÁ´›7Á°Á«ÈÁ§}ùÁ£ptÁŸªÆÁœgÁ˜{Á•AüÁ’*ñÁg*ÁŒÅÁŠu¬Áˆm¯Á†™ˆÁ…áÁƒ—YÁ‚cìÁ‚AÁ€±(Á€2EÁ¹²ÁÁÁ Á€>îÁ€öÁÃÀÁ‚ÚÁ„ Á…Ÿ^Á‡]®Á‰KÁ‹|yÁÓjÁt Á“FOÁ–KÁ™›oÁœÿÁ ¨|Á¤–*Á¨–QÁ¬´LÁ± EÁµˆ×Áº&wÁ¾õÁÃï[ÁÉ8ÁÎE1ÁÓ•‡ÁØúcÁÞ…KÁä2îÁêxÁä@ÅÁÞ}ÁØÍ ÁÓAÁÍ×ÁÈ{ÁÃ.¢Á½ùOÁ¸îKÁ´­Á¯AtÁªœäÁ¦8<Á¡åêÁ±ÇÁ™Æ4Á–]Á’dËÁšÁ‹üÔÁ‰ãÁ†ƒ¬Á„&ÁñhÁ€1Á|ðôÁyÿ×Áwa,Áu  ÁtíÁs ÕÁrƒ‰ÁrZÁr^UÁs$ÌÁt†)Áv)ZÁxSêÁzÑ~Á~5Á€ÑÁ‚Ú‘Á…IÁ‡‰òÁŠCyÁ†Á<¹Á“…ÚÁ–ý¨ÁšËTÁžÉ9Á¢ÖÛÁ§" Á«…ëÁ°æÁ´Â2Á¹·ÔÁ¾Ú ÁÄyÁÉG‰ÁΪÁÔ4@ÁÙâ–Áßœ›ÁåÁß›yÁÙ˦ÁÔAÁÎwäÁÈë¸ÁÃwPÁ¾¿Á¸ÖlÁ³»Á®ÎÁªjÁ¥>­Á ´@ÁœcôÁ˜ãÁ“ùÁ&tÁŒopÁ‰üÁ…ì‘Á‚þ5Á€SÆÁ{°5ÁwA¥Ás9—ÁoÙÉÁlìÁÁjM¬Áhl¤ÁfäÁeîYÁeTÁÁe>gÁeP§Áf!˜Ágo ÁiaÁkùÁm´ûÁqÕÁt£JÁxÓYÁ}j:ÁRÁ„ØÁ‡^ÁŠ?‹Á‘NÁ‘-gÁ•ÀÁ˜ÿ«Á8Á¡›ÄÁ¦ ’Áª¯ºÁ¯ãÁ´¨5Á¹Î‚Á¾þìÁÄZ¯ÁÉã4ÁÏ’>ÁÕK?ÁÛ Áá4îÁÛ%=ÁÕ6IÁÏjãÁÉÅ-ÁÄ/µÁ¾›ìÁ¹ÿÁ³»õÁ®ÁÁ©ùÁ¤ÀÿÁŸøÀÁ›E•Á–ØöÁ’ŽÝÁŽKÁŠLZÁ†œóÁƒZÁØÁyîdÁt`<Áo6ÁjÐ<Áf´ÄÁc æÁ`šÁ]˜]Á[YÁYÕ‹ÁXúÿÁXP"ÁXXþÁX>ÁYoLÁZ¯•Á\VœÁ^:0Á`özÁd)¤ÁgìcÁl KÁpæÁv8¬Á{õ^ÁhÁ„GµÁ‡Ë»Á‹v€ÁChÁ“X÷Á—º\Áœ7†Á ÇyÁ¥ƒÁª•ÃÁ¯¯°Á´ÒˆÁº!@Á¿ŸÜÁÅJUÁËÒÁÐËÔÁÖ­£ÁÝïÁÖãŽÁÐÕ§ÁÊêÁÅ#¢Á¿‚gÁ¹é*Á´RÁ®ÌPÁ©x/Á¤[ŽÁŸ{ƒÁš¶UÁ•ðÁ‘X)ÁßÁˆÁýÁ„ŸWÁ€ÒÎÁz»ºÁt*?ÁmðÁh0ôÁbýäÁ^n­ÁZ;“ÁV˜lÁS~fÁQ 9ÁNÁLôÁL ïÁKŽ\ÁKˆ°ÁKãìÁLÓÁN —ÁOÆLÁQÀÆÁTóÁWµ.Á[€(Á_¤QÁd¢'ÁiðvÁoÎþÁvÁ|îhÁ‚bÁ…Æ‚Á‰­&ÁëãÁ’l?Á–õèÁ›±Á ž·Á¥®]ÁªÊ@Á° òÁµ|}Á»ÁÀàbÁÆ¥“ÁÌ‚ ÁÒ‚‰ÁÙÁÒÏŠÁÌ¢²ÁÆ“ÏÁÀ¨¶ÁºäÍÁµEþÁ¯¬•ÁªÊÁ¤GÁŸXËÁšPÁ•~AÁ²ûÁ‹õÁ‡~@ÁƒI‹Á~[åÁvvÁoVKÁhÇÁb>àÁ\ ÁVøhÁR`eÁMæûÁJV<ÁG×ÁD}¸ÁB4Á@€ŒÁ?X^Á>èÁ>äKÁ?TŸÁ@B}ÁAn ÁCRèÁEg€ÁH@ÁK”ÿÁO_ÐÁS»ÁX¡€Á^ôÁcÔ¾ÁjTüÁq™«ÁxúòÁ€DˆÁ„U‰Áˆ­Á'úÁ‘ÕÁ–¼áÁ›²Á ÑžÁ¦ïÁ«~ÈÁ±¶Á¶É±Á¼Ž#ÁÂf¶ÁÈe7ÁÎ…›ÁÔ÷øÁΗÁÈÁÂbCÁ¼QúÁ¶ggÁ°¦SÁ« ¡Á¥}eÁŸþ4Áš”Á•dwÁuÁ‹¡xÁ†Ï2Á‚+IÁ{»»Ás©Ák¶8ÁdIóÁ:ß«Á8%LÁ5ú§Á4?’Á3öÁ2“Á2“7Á3îÁ3ÔuÁ4ø Á6øOÁ9{Á<*Á?{ÁCw‡ÁH'ÁMÁR}ðÁXY˜Á_#îÁfmeÁmü[ÁuÈ¥Á~@ÒÁƒtÃÁˆôÁŒàFÁ‘Õ€Á–ãdÁœ.ËÁ¡£ Á§,µÁ¬ÆÁ²xhÁ¸LÁ¾H5ÁÄheÁÊ– ÁÑÛÁÊÆ½ÁÄŒàÁ¾U{Á¸$½Á²Á¬-ÕÁ¦sƒÁ çÞÁ›lPÁ•ñŽÁ Á‹‰#Á†¯÷ÁÜ Áz5ÁqKÁi×Áa·ÁYIöÁRLùÁK ÁET6Á?Ù5Á:úsÁ6k¡Á2sgÁ/Á,.Á)ÔuÁ(€Á&ÈtÁ&fÎÁ&n´Á&üÞÁ'ÀbÁ(êãÁ*ÐÁ,äþÁ/ñöÁ3g™Á7ÖÁ<–HÁAÎLÁGNvÁMi)ÁT…Á[vRÁcÁk8´ÁsíBÁ|ÙÝÁƒ(ëÁˆ®ÁÔÁ’QÑÁ—ÂlÁPÁ¢ß§Á¨9Á®JBÁ´@‹Áº\òÁÀ;ÁÆÉ9ÁÍoŸÁÇ ÁÀ²ZÁºsýÁ´5©Á®ŒÁ§÷ÈÁ¢cÁœg@Á–ßoÁ‘_6Á‹ëˆÁ†°äÁ½™ÁyÕÁp8[Ág†Á^ºðÁV´,ÁN¶ÚÁGjµÁ@ÆŠÁ:TÁ4ÍrÁ/‹JÁ+}Á&ÔôÁ#{ Á lûÁîÁ;éÁú»Á…;ÁaˆÁâÿÁÜ›Áû$Á»hÁ!9PÁ$BíÁ'Ã~Á,DøÁ1)pÁ6°uÁÁ`޲ÁjàÁsÆHÁ}®HÁ„ËÁ‰šMÁHJÁ”ÿ”Áš¹…Á …UÁ¦|ÂÁ¬žRÁ²å°Á¹OÁ¿ÊmÁÆ}ÏÁ¿ìòÁ¹_bÁ²êÄÁ¬—HÁ¦]ÚÁ &{ÁšÁ”ÉÁŽU_Áˆ°²Áƒ×Á{*-ÁpšAÁfžàÁ\ç0ÁSDÁJPëÁB'‰Á:CÁ2¤Á+±Á%ÄÁÁÕÅÁÖnÁ¡±Á ÔôÁ åEÁQRÁ=$ÁàÁeÍÁ\Á¾kÁTÁÕÁŠÁ /Á ³#Á ÙÁFVÁn Á ïÈÁ'pÁÁ.­Á5sÁ=AtÁER†ÁMé´ÁWE{ÁaÁjð¬Áu2Áü­Á…†cÁ‹2 Áþ´Á–ÖÿÁœÄLÁ¢Þ3Á© tÁ¯†)Áµ÷5Á¼lJÁÃ8ýÁ¼™ÕÁ¶ãÁ¯rÁ¨ýäÁ¢«bÁœfqÁ–*3ÁÁŠ3!Á„„Á}¾ÌÁr€¸Ág¶äÁ]„(ÁSÓPÁJÁ@ÙýÁ8xBÁ0k Á(˜Á! ’ÁÙrÁðkÁeÎÁ JôÁ ®Á+ Àý¯!Àør¡ÀôJXÀñö*Àð{¸Àð‹ÀñP0ÀòÀõv{ÀøõtÀþeHÁ¥ÀÁÙ,Á â0ÁÁñWÁFEÁ$ÀÁ+è.Á3ç+Á<ÁDïËÁN¢XÁXŽJÁb¥ËÁm?²Áwù&Á’­Á‡aÕÁ<ÄÁ“µÁ™-ŒÁŸg<Á¥ÇêÁ¬:mÁ²® Á¹+‚ÁÀ.µÁ¹nrÁ²ÃÈÁ¬-Á¥¨NÁŸ>bÁ˜êtÁ’™ÁŒ]Á†PÞÁ€{^Áu¤7ÁjV^Á_.ÔÁTŸÙÁJ¾sÁAªÁ7‹]Á.äøÁ&é¬Áò+ÁÎNÁëoÁ Þ1Á4¢Àÿ÷QÀ÷<¼Àï* Àè’TÀã6Àß áÀ܈OÀÛ BÀÚˆAÀÛK}ÀÜ­­Àßœ:Àã˜õÀéV³Àð¤}Àù5¼ÁŠ_ÁR<Á Z+Á„Á¶~Á" ¯Á*¶:Á3rmÁ<®…ÁF8ÁP'ÁZ¨lÁeDÖÁpB©Á{ÇXÁƒº>Á‰šKÁœÃÁ•ÎØÁœ#ÑÁ¢ŽÒÁ©¸Á¯†+Á¶&†Á½9Á¶qÁ¯ªñÁ¨ö‡Á¢`(Á›ëZÁ•“¢Á@3ÁˆôþÁ‚ÌœÁy™eÁmätÁby‡ÁWTÈÁLˆ„ÁB2ÁÁ8l™Á.Ä(Á%°]ÁŽYÁ“ÏÁõÁ;jÁÖïÀöh¬ÀìbÀãWŒÀÚõïÀÔXÀÎ…ˆÀÊláÀÇc˜ÀÆJ7ÀÅöÀÆ¥ÇÀÈ+ÇÀÊC:ÀÎÖ¯ÀÕ ÀÝBYÀåœtÀï¬ßÀûl=ÁÚ5Á ¼ÁîÁÁƒÁ"ÜÁ+SøÁ4»Á>ëÁHAYÁRº4Á]ÁhÝ7Át ÎÁ€5"Á†.iÁŒZ‘Á’ Á˜ðhÁŸY$Á¥âóÁ¬‹³Á³@¾ÁºV›Á³‹†Á¬ÆûÁ¦kÁŸTÓÁ˜¿`Á’I%Á‹èaÁ…˜óÁ~ÓŠÁrª‘Áf¼ÁZø”ÁOŸ ÁD×ßÁ:+‡Á/êPÁ&hxÁ4ƒÁ¨Á ˜®ÁädÀü¶Àï`wÀãùLÀÙF—ÀÏÄ{ÀÆö×ÀÀIÕÀºuXÀ¶TXÀ³PÜÀ²R‚À±´yÀ²KÀ´¸À¶‘ŽÀ»ÁçÀÂÀÉé%ÀÓ‰2ÀÝì–Àè¿ÀöRyÁU8Á …ÁbÌÁ"Á#L·Á,ÈáÁ6¼Á@ò:ÁKiÒÁVmÁb LÁmÆEÁy¤&Á‚óäÁ‰4®ÁwÅÁ•ØNÁœ_Á£"Á©®fÁ°ceÁ· #Á°½Á©óÜÁ£>ÛÁœŒ#Á•àeÁOÁˆÄ6Á‚QgÁx^Ákä`Á_½ÈÁSé¼ÁH‚CÁ={;Á2±›Á(–ÁJxÁxÁ ÇÁÞ~À÷ÌzÀêCÍÀÝ{=ÀѰ¯ÀÆâ8À½&ãÀ´¡FÀ­OÏÀ§ÄsÀ£[À A‹ÀžËKÀž}ÆÀŸ"çÀ ×2À£[<À©9À¯ À¸{À ÀÌËóÀØŸ!Àå§çÀóâ<ÁÆÓÁ ÷€ÁY-Á»˜Á%Á/ÀdÁ:!ïÁD´^ÁOÃÁ[bÁgn›Ás‹XÁßöÁ†0·ÁŒŽ®Á“_Á™®¹Á JbÁ¦ü}Á­Ê×Áµ3ÈÁ®>Á§ZÎÁ IÁ™Ð*Á“EÁŒs=Á…êÁ~×4ÁrÁe‘ŒÁYSáÁM/×ÁA÷Á6|4Á+| Á µõÁÅmÁ ]FÁýÀ÷§½ÀçäzÀÙ9 ÀËÈÓÀ¿°VÀ´¿ÚÀ«qiÀ¢Î$À›0À•‘%ÀÂDÀŽ’ÀŒ‘¬ÀŒ5®ÀŒè8ÀŽ¢zÀ‘ü½À–´ŠÀž©BÀ§K@À±1ŠÀ¼wÅÀÉÂÀÕêyÀä„LÀôï&Á³|Á aòÁŸÅÁvÁ(üéÁ3ƒæÁ>AÉÁImÁUkJÁamÓÁm…®ÁyÜÒÁƒKWÁ‰Ó×ÁqÁ—°Á»Á¤…}Á«j–Á²ÛŽÁ«â@Á¤ý’Áž#Á—O Á‰ÒÁ‰Ï[Áƒ1ÑÁyx"Ál­RÁ_ómÁS˜AÁG_3Á;nqÁ/ä–Á$ÐGÁïåÁ›fÁüÀùHºÀèÔÀØlEÀÉ À»ìjÀ¯˜ À¤dûÀšÜDÀ‘þÀŠ ÄÀ„‚ÚÀ~)ÀyR°ÀuÈãÀub¶Àv-ÀzØÀoÀ†Q¶ÀŽÞÀ—©›À¡´/À­"Àº)ÀÇçÃÀÖÌÀ愽À÷¾%Á Á ÑiÁtÁ"ƒÁ-6¤Á8,sÁCNÁOÜÁ[˜ðÁgÕ¶Átt;Á€´õÁ‡?6ÁÔ¶Á”zõÁ›@ùÁ¢#œÁ©OÁ°Ã8Á©³éÁ¢ºÚÁ›ÔäÁ”ó ÁŽ¿Á‡U2Á€µãÁtkèÁg~mÁZŸØÁMôzÁA´™Á5ÃÝÁ)Þ{ÁjÀÁÂÃÁ U÷ÀþDÁÀë¼ÀÚqÀÉ”‰ÀºÐ,À¬ñßÀ u§À”§2ÀмàÀÇFÀtÊÀhÎoÀ^FpÀXš*ÀU,´ÀTTÀUòÕÀYÏíÀb éÀnZ·À~š.Àˆ³CÀ“êÀŸRÛÀ¬XÀºCÀÉ`ÀÙmŽÀêè?ÀüèxÁìmÁÁ`VÁ'&QÁ2%êÁ=ÌúÁIïìÁV#8Áb¡lÁo‡TÁ|ˆMÁ„ǪÁ‹eðÁ’'œÁ™ØÁŸðÁ¦Ý[Á®ØGÁ§»ŽÁ ³…Á™Â”Á’Ú;Á‹öÁ…Á|ÂkÁoœ×Áb­UÁU¾aÁHÖ"ÁÁQ}eÁD•ÍÁ7ùèÁ+ÉXÁåFÁ<Á¤ÐÀüP'ÀçÒ5ÀÓË À ûÀ°–À ˆÀ’¨ñÀ…z­ÀrUÀ^øÀJ‘ À<¿ŽÀ/'À%8ÑÀ “ÀîWÀ­ªÀНÀ!?OÀ*OæÀ8 kÀI¢ƒÀ\ªŒÀrÏÀ…°ãÀ’äÕÀ¡NnÀ°ð±ÀÁ’¥ÀÓ(ÀåX‡Àù ÁÂÁC‚ÁßÁ(F\Á4ÝÁ@ ÁL^)ÁY&OÁf<3Ás_áÁ€^1Á‡1ÁŽžÁ•¬ÁœºÁ¢ùÊÁ«S Á¤8fÁ+€Á–&PÁ&ÂÁˆA>Ág–Áu.¬Ág·/ÁZ‘aÁM†êÁ@†ªÁ3íçÁ'ÑIÁÅïÁÍÜÁ[ÏÀó@îÀÞ¾ÀÉïaÀ·ÇSÀ¦$À–H–À‡†ÀtQÀ[>,ÀEç1À2ñøÀ#&YÀ›ÒÀ ô6À-‰À¡¿ýjèÀ À„0ÀÓèÀ `À0á€ÀD®wÀZý‡Àrl1À‡ˆ1À•÷À¥°\À¶A÷ÀÇáÀÛÓÀîШÁ’ÍÁ \ŽÁ½¤Á#_¨Á/vQÁ;¤—ÁHA7ÁUöÁbÞÁoD;Á|ÑfÁ…G@ÁŒ8IÁ“,ÞÁš-Á¡3˜Á©×ôÁ¢µ»Á›¡¾Á”˜ºÁ’[Á†˜lÁw-ÁqæDÁdZ?ÁW ,ÁJ «Á=*Á0`Á$îÁ Á GÁm8ÀëEÒÀÖFÀÁY&À®ÎŽÀœù£ÀŒÕòÀ{cvÀ_­æÀF%ËÀ/IµÀDÀ X­¿ýÝ¿è¯g¿Û$±¿ÒªŒ¿ÐÏC¿Õc¿â ¹¿õÒãÀªÀýÀ.r'ÀE0 À\é’Àx- À‹…À›;À«ÝÀ¾ ÑÀÐÒ·Àå:ÿÀú}´Á"™Á†‰Á#ŠÁ+5üÁ7ÁÁDg‚ÁQ@Á^u”ÁkÀÁy3´ÁƒoÊÁŠdÁ‘diÁ˜hšÁŸ}Á¨uÞÁ¡OÁš:oÁ“)®ÁŒ7Á…’Á|hPÁnä(ÁauHÁSÿ4ÁFèmÁ:Á-?<Á ¿®ÁÆdÁÔÀújÀãîƒÀοRÀº"ŠÀ¦ÍÁÀ”»ÓÀ„^,ÀiØÕÀMe‚À3ÁFÀtkÀl°¿îbÅ¿Òzp¿¿OË¿±Ô›¿ªK¥¿§…R¿­Ö ¿ºõµ¿Ï'…¿êíÀ(ÔÀºÀ0oÀHü‚Àd#þÀ€ãÀ‘X2À¢.¥À´çaÀÇöÀ܉øÀñäÁñ)Á‡”Á>]Á'm•Á3ÏÁ@¦ÁM½bÁ[ *Áh]-Áuç$ÁÙÁˆÃæÁ¹TÁ–ÈÎÁî²Á§;ýÁ Á˜ÖîÁ‘½%ÁŠºõÁƒÉ,ÁyÌöÁl-Á^¡DÁQ;YÁDWÁ7/=Á*qûÁÞNÁ½ÁÖ9Àô:ÀÞ'¾ÀÈTHÀ³ÌÒÀ C^À“ŸÀy–êÀZ6 À=CÀ#O¶À ß¿ì`•¿É¿®ü¿šÜ¿Œ?¿…Ÿ…¿…ÅC¿‹žD¿—†¹¿¬¢e¿ÅÏ‹¿èS,ÀCÀƒÏÀ7g¥ÀR´rÀoÀˆ}îÀ™»NÀ¬©ÓÀÀ .ÀÔÓOÀês.Á@nÁ ÷VÁœÁ$.YÁ0—dÁ=…0ÁJ’\ÁW¼ºÁe}ÁrÇfÁ€XúÁ‡ZdÁŽ\nÁ•iñÁœˆôÁ¥ùlÁžÊ€Á—›ÔÁrøÁ‰^ŸÁ‚e…ÁwÀÁi|Á\•ÁN¥KÁA|ïÁ4p¾Á'ª|ÁHºÁþ ÁÝ4ÀîÕLÀØ´²Àœ À­§,À™øÀ‡YÀlKÀL¶ëÀ/šÀûo¿øáò¿Í&¿©sÊ¿Œ£}¿pž-¿W¯¿L”)¿MŽ‘¿Zï¿rS¤¿ŒÔ1¿¥ë5¿Å¼–¿ïªÀ ÖÀ&}ÀBÍÜÀ`‡#À€ßÀ’f¹À¥‚šÀ¹:¼ÀÍíbÀãÔ¶Àú3ÁÙŸÁëgÁ!.êÁ-ÃýÁ:¾þÁGÆXÁTí´ÁbiïÁp1åÁ~*{Á†ÅÁæÁ”‡Á›EHÁ¤½<Á‰Á–gIÁOÁˆ?ÌÁ;¤Át¡ÝÁg~ÁYÁL< Á>ÜÁ1µQÁ$ú+Áœ½Á GVÁgçÀé[_ÀÒñ:À¼éÀ¨+yÀ”F:À)àÀ`5dÀ@èÀ"É8ÀÒ(¿Þ­3¿²Îš¿Žˆº¿c\¿867¿Ú’¿eÕ¿±0¿!í¬¿;*N¿`l¿‡Æ¿§õ¿ÏóÏ¿ýÕFÀîÀ4ò\ÀSddÀtï»ÀŒ„ÀŸ+À³PÀÈhàÀÞpKÀõ;Á8Ág*ÁÄ|Á+COÁ81ÀÁEEÊÁRqèÁ_ôwÁmÂåÁ{Á¥Á„á2Á‹ã¶Á’û$Áš)Á£ÅÀÁœ‰Á•_íÁŽM€Á‡KÏÁ€JìÁr¡Ádä‚ÁWcTÁIé Á<…íÁ/}CÁ"¸ðÁ*dÁ Ô€ÀûT ÀänÀÍÖÀ·¥¬À¢åäÀãÀx#!ÀU}JÀ4t®À[ã¿øí„¿Ç¿›ÞÖ¿n‹¿47õ¿ *Ä¾Û N¾Â£¾Æø¾àT¿*ˆ¿/'™¿^ï[¿ŒE¿´£¿åÖPÀ ;À)m¬ÀH”ŽÀiÁØÀ‡4Àš„[À®Ï™ÀÃÛ‰ÀÚÀðƒ"ÁÞrÁ)ØÁ“fÁ)òÁ5þ´ÁC ¯ÁPIQÁ]Ù¹Ák¢xÁyƒ§Áƒ¿ÝÁŠÅùÁ‘ä Á™ËÁ¢ë§Á›¨uÁ”v™ÁZçÁ†T Á~¨µÁp²ÁbíÁUXÁGÊÏÁ:ŠÁ-œXÁ »ÑÁòýÁ¿3À÷@Àß«ÀÉ)ÒÀ³S€Àð0ÀŠv‹ÀnįÀKÛpÀ+ŸÀ «g¿äɾ¿²¾i¿ˆ²…¿F7‰¿ ‰½¾Æo%¾ŠYÒ¾`}C¾iV©¾‡j1¾¹Uz¿Í¿1‡H¿oCŽ¿ ^Q¿ÐØÀ{¼À '&À?PéÀaçÀƒÆÀ–M;ÀªêÅÀ¿ºÖÀÖ#&Àì¸eÁVÁHêÁÁ&ÿ#Á3øžÁA+šÁNc‘Á[êÁi¯«Áw{Á‚¯)Á‰½‹Áå Á˜ +Á¢DFÁ›Á“âÁŒ»sÁ…¨ÔÁ}1'ÁoæÁaEkÁS¹›ÁFa¨Á9¸Á+øÄÁ õÁ.ŸÁëÀóþÀÜSíÀÅ«FÀ¯·iÀšˆÉÀ†JÀgE•ÀCÓ›À"ïëÀwJ¿Óo€¿£ªç¿nq¿%Qƒ¾Ûë¾t'œ¾gq½›D‡½«Ø”¾ ‹¾S¾°é°¿ ÊŠ¿K翎HØ¿¿îl¿ö(CÀxÀ7¿FÀZžÂÀ}øÔÀ’ζÀ§mÀ¼4ÀÒž*Àé9®ÁLØÁ j×Á™Á%ùÁ1ÿ Á?GJÁLžßÁZsÁgÈ]Áuž•ÁÕNÁˆö(Á'^Á—V{Á¡Í›Áš—ÿÁ“c6ÁŒ3QÁ…ßÁ|5ÁnIžÁ`^MÁRŸ-ÁE0£Á7ì5Á*ªÁœòÁÛÁ¸ÛÀñ7¡ÀÙª ÀÃ1ŽÀ¬úðÀ—³WÀƒ­†À`Ä À=§ªÀõ ¿üq¿Æ£ˆ¿“ÿq¿S(Ñ¿ ð+¾£Š,¾»vx„="s=¦¼»Ÿ/e½µ«¾a@”¾Ù¿.´V¿ d¿­™˜¿åà¢Àê¯À0ýçÀS°ËÀwp À¢¢À¤FaÀ¹"\ÀÏmvÀæÀýˆGÁ ® Á‚Á#‡mÁ0z/Á=žaÁJýuÁXuHÁf!ðÁt ìÁ »Áˆ 9ÁC.Á–{žÁ¡˜ÁšBoÁ“mÁ‹ÑÕÁ„´ÒÁ{eùÁm‚Á_«ûÁQçCÁD`Á7RÁ)ÞÁö`Ám=Áç¿Àïf<ÀØ>¦ÀÁg¢ÀªÈýÀ•Ì‘ÀõáÀ\M³À8Ë?Àó®¿ñ´f¿»Øå¿‰,¿=¦—¾î®Û¾eëå½%ƒ=¬jH> ßA>\<=º €<ÏJ¾nо¦4远y¿e/(¿¡@'¿ÚéÀ AÀ+‘µÀM—·ÀqùÀŒjÀ ßåÀ¶n†ÀÌŠ‰ÀãCÖÀúª3Á @çÁ°vÁ"4òÁ/(CÁ<<ÁIˆ4ÁWÁdí'ÁrͪÁ€jºÁ‡€mÁޤÁ•ØnÁ¡ASÁš Á’Û“Á‹­NÁ„Ž?Á{ÕÁm:‰Á_{dÁQ½¬ÁD$9Á6ËHÁ)¥*Á¸ØÁ+òÁ§¨ÀîúHÀצEÀÀ¥“Àª-ÄÀ”Ÿ2À€À)ÀYÑ­À5‘ÂÀÿµ¿éøA¿³r¦¿Aο.떾̿¾+¿£<Ö*s>¡>Y£Â>[iê>5ê<=¹u ½1Ù¾zýÇ¿ÑÕ¿R ú¿–ôM¿Ð»!Àm%À&Æ;ÀGø²ÀmLÀ‰ëÀž"À³Å®ÀÉÅÀàq¹À÷éÁí…Áƒ@Á!,Á.¦Á;1.ÁHmŠÁUêÃÁc±æÁq°ÑÁÒ®Á‡aÁŽ!ÙÁ•T(Á¡HëÁš †Á’âJÁ‹ÂCÁ„¥tÁ{Ám(uÁ_r%ÁQÌKÁD3ðÁ6ôSÁ)ã…ÁãGÁ4ŸÁÂ#ÀïnÀ×—þÀÀ†Àª70À”@ÒÀ€>öÀXÛ¸À4ÛÀ‡Z¿èq¿®½Q¿xjÙ¿%Q[¾ºÒ-¾úˆ=‹³>P0>…À<>‹¬û>zÊü> þh3ƒ>’J >œù&>ªì>[©ü=›j¾Ny¾Ä3¾¿3†l¿„²¿¿7Ñ¿ýE!ÀpÀ@¸'ÀdúÜÀ…áºÀšŸÀ¯±äÀÅÆ»ÀÜÁÀô\¢ÁLˆÁ¦›Á8Á,FøÁ9š&ÁFëîÁTuÁb:/Áp-öÁ~VÁ†F¾Ái—Á” Á¡¶(ÁšqèÁ“8¢ÁŒ÷Á…\Á{÷áÁmï´Á`$–ÁR£}ÁEe“˜>˜_i> ¥>•òÀ>våÀ=à”‚½Ñt¾¾ÊÉ¿,9¿ƒä+¿¹Lž¿÷yÍÀgÿÀ?…éÀd ÐÀ„˜À™¥:À¯ïÀÄÓdÀÛý¸ÀóºôÁòïÁw!Á»Á+Õ‰Á9mÁF×ÁT')ÁaÜ$ÁoÑñÁ}úÁ†åÁ0nÁ”`NÁ¢ ÒÁšÉãÁ“›šÁŒƒJÁ…qýÁ|À<Ánº~Á`øAÁSgiÁEØçÁ8tÁ+wÁžNÁêÁj`Àò„ÀÚì›ÀðþÀ­r«À—ŒÀƒU<À^l3À:C'Àµs¿ð|ª¿µ×Û¿„3Ê¿0qz¾Ëw*¾&.¿<×Ù>/G>†?>”Äc>‘á\>`F„=°•ã½åÍ´¾Å’Ö¿/ Y¿‚”Ä¿·'¸¿öW$À6À?ÒýÀe=fÀ…`À™Ÿ5À®âíÀÅ=ªÀÜ+#Àó°8Á Á_îÁ-zÁ,˜Á9,ÎÁF£ÛÁTDLÁaåòÁo¸Á}ËÐÁ† Á?,Á”uäÁ¢ŽžÁ›S¦Á”+ØÁéÁ…ø>Á}ÄfÁoÌÁb;ÁT„ÁFþ Á9›Á,Á¿^ÁaÁ ùÀô¨8ÀÝ +ÀÆ>öÀ¯®gÀšŠ0À…ÛlÀcè’À?(¤Àj¿¿ùŽi¿Áÿ¿Î-¿CºK¾ó/ǾvÝ7½Nù=®"b>0j>U;>R[×> =Le¾"ën¾Õ(ê¿0™§¿„§»¿¸1¿øÀôÀm»ÀBZ^Àg YÀ‡ÀšÓÀ°tðÀÆ^rÀÝ|ÔÀõ]ÈÁØüÁ+nÁɵÁ,µƒÁ9¼ ÁG`ÁT²ñÁb}ÝÁpK®Á~GÎÁ†<ŒÁk$Á”ŸŠÁ£F·Áœ 5Á”ä ÁËõÁ†¿gÁh’Áq`OÁc”qÁV ¾ÁH:Á;?mÁ.$/Á!ÁtIÁ=³Àø±Àà@ŽÀÉ„@À³UóÀGËÀ‰bÀk×çÀFVºÀ$_{À{Ô¿Ï‚ë¿(ä¿a…¿³+¾¹¾7R{½QX<ÎS=•où=TÛ¿Ø4¶À 3ŸÀ,VJÀP€ ÀtŸÀŽ;À¢ûÀ¶ÜÀÍ+Àãe Àû(Á Œ˜ÁìÁ"‚ Á/2‘Á:öÁK‡=ÁXßÁfV`Át\Á ªÁˆ ãÁÁ–2ìÁ¦ÁžñgÁ—×çÁʸÁ‰Å“Á‚Í…Áwß½Áj+VÁ\‡lÁO2;ÁB,ðÁ5> Á(„ÁöxÁ©ÇÁÇ5ÀðIÎÀÙ¢¸ÀÃÔÀ®ÁÂÀšÖÄÀ‡ÃËÀl+ÀJòþÀ+$>ÀOÛ¿ì¿À`©¿‘$¿ƒ Ô¿^1`¿Bãó¿.÷–¿)‘¿&«r¿*>¿>¹¯¿gm῜C¿²í'¿Þ ÙÀ BÀ'´&ÀH¹¡ÀkdGÀ‡³†Àš›gÀ®l‘ÀÂqHÀØlÞÀîÔ#ÁÈsÁ³5Á´dÁ'#×Á3ÙÊÁ@¡êÁMÌ1Á[>Áh»­ÁvZCÁ‚ãÁ‰$åÁ,ÚÁ—B{Á§Z«Á DÁ™+\Á’·Á‹Á„1WÁz±JÁm²Á_+ÁRZ6ÁEWÁ8Y[Á+¤:ÁaKÁ):ÁI”À÷×Àá3lÀËÙŠÀ· /À£KÁÀvÀ~'À]*6À>zËÀ"ÑÝÀ ¥Z¿é ̿ƱO¿¬]t¿™µù¿ŠSþ¿€÷(¿|¿z÷¿{Üí¿‰é¿ŸfÇ¿¹¤¿ÜËVÀpÀÃäÀ;¿öÀ[*WÀ|ß›ÀÄ_À¢™´À¶XƒÀÊ0iÀßà»Àö+ÁN3ÁôÁgÁ*-ŽÁ6ë ÁCÕ¦ÁPÒ|Á^"XÁk„¤ÁyÁÁƒ]žÁŠXüÁ‘iÇÁ˜€yÁ¨®õÁ¡\ÁšyÁ“zŠÁŒ•ÌÁ…·ŸÁ}·âÁp:óÁbù¿ÁU¼ÑÁH°·Á<œÁ/zÁ#%ÓÁ3RÁ _Á%ÀêÔÀÔîÐÀÀ[À­*šÀš²õÀ‰'ÑÀr¶ÀTÃ_À9À ª^À -¿ö¨Ã¿Ý½¿Ê z¿»-¿±â¿­^¿­Ö¾¿­ÝI¿º¾H¿Íß¿éÿ0ÀtuÀÅ»À4%ÀPaØÀoT€À‡è,À™VÜÀ«ÊmÀ¿ž ÀÓu$ÀèµAÀþ¬Á qWÁ$Á"*‹Á.TÁ:¼6ÁGnÁT1ÁaR¥Án¹.Á|$iÁ„Ù‚Á‹ÁáÁ’ƪÁ™Ý$Áª$ Á£ÁœÁ•{ÁŽ8ÝÁ‡^"Á€›•ÁsÒ˜Áf’ÁY|UÁL£yÁ@3Á3¯yÁ'wRÁœ=Á8ÑÁàRÀóížÀß4ÑÀÊÑ¿À¸qÀ¥ÿ°À”ÿXÀ…K›ÀlþýÀR§µÀ:˵À%ÞYÀG@À ¿ÿhÕ¿ðj¿èa¿ät ¿á“W¿å{©¿î’iÀæ„À1xÀ! @À5€?ÀM`ÀgÕÀ‚Ž­À’z†À£N;ÀµñûÀÉ~bÀݱaÀò lÁPiÁU¸Á­ëÁ&¡ÈÁ2¬,Á>ÖÁKdÈÁXG¢Áe[»Ár”žÁ€(Á†¿½Á—XÁ”}*Á›u™Á«½¯Á¤¿2ÁÀ¼Á–É¿Áí“Á‰-Á‚qJÁw‹ÁjˆŸÁ]ªCÁPÖ ÁDdÁ8?~Á,4ÍÁ ‘iÁ%}Á :=Àÿ-¸ÀêjŒÀÖ«Àö‹À²†3À¡êìÀ’™À„8±Àn<ÀW¹ÄÀC´uÀ3-WÀ%èßÀ…›À¤ÇÀr$À¯bÀÝrÀ8vÀ½?À[5À+å…À=à ÀRb}Ài«gÀ3€À(úÀžï%À®kHÀÀÙÀÔ±þÀé Àþ—Á ÁÁ£µÁ¼TÁ+ŒIÁ7–ÁC¡NÁOèlÁ\§qÁi§NÁvÀùÁýPÁˆ¸WÁeÁ–n\ÁOSÁ­‚ŽÁ¦‡#ÁŸšÃÁ˜ÀúÁ‘ü¥Á‹DÁ„‘ÜÁ|°ÁoÆÁbKîÁU¿ÞÁIcðÁ=EØÁ1Œ'Á&~ÁÑÁÖ_ÁkÜÀö€¹ÀãâÀÐÒ¨À¿ãíÀ¯ÂîÀ¡§À’¨À†},Àu%Àb›KÀRpÚÀE›ÛÀ<VÀ5¬SÀ0ßóÀ/*,À.o:À/N¨À3Ì¢À=ÁÀK¹ðÀ[ÕlÀps—ÀƒàgÀ[äÀžfÀ¬¨&À¼U#ÀÍCÒÀàÆÀõ7ÙÁ*Á®äÁ›Á%¬'Á1#ûÁ<ÞHÁHä³ÁU1·ÁaÔLÁn‡´Á{N<Á„# ÁŠÆfÁ‘ŒÓÁ˜oùÁŸ[ Á¯g´Á¨„ÌÁ¡º-Ášõ<Á”3—Á~Á†è2Á€gUÁsá´ÁgPQÁZñÁNŸWÁB¼Á7-wÁ+º’Á ÈñÁ8HÁ ´_Á÷YÀñ;æÀß %ÀÎZ_À¾µÀ°gQÀ¢!6À–2=À‹+ÀŠÊÀs¾Àgˆ›À]×ÄÀWctÀS ÞÀQECÀP¿ãÀQû$ÀVR§À_ì9Àl´À|ÿlÀˆ±ÂÀ”9À \À­²lÀ»/PÀʹêÀÚö ÀíÄÁ)‰Á {UÁ1öÁ òÁ+ÈÁ7/µÁB¾FÁNhwÁZ‘|Ág-æÁsçÙÁ€R0Á†´›Á9Á“âÊÁš¨áÁ¡ƒÁ±¢lÁªÍ(Á£ûÜÁ/Á–p„ÁÒ¾Á‰YÁ‚ùÁyN!ÁlÛÙÁ`ŒÍÁT–fÁHËjÁ=-ÝÁ2lÁ'nÁóÁšpÁ tÀÿtõÀîNºÀÝÞÝÀμeÀÀˆ3À³*À¦ºtÀœD‚À“¡À‹"À…>[À€|ÀÀz²sÀv‚„Àt…ûÀu()Àv„×À{YÀâHÀˆ:¨ÀÌ_À™"âÀ¤ÕÀ±pÀ¾Ê3ÀÌ=ÇÀÛ`NÀëÉ7ÀüégÁCÁgÖÁ'aÁ'ÙrÁ2_Á= pÁI8ÎÁTßÁ`¸àÁlÿÄÁyŒÙÁƒ$PÁ‰ŠdÁiÁ–“¸Á/ŠÁ£âÁ´*Á­3gÁ¦`%ÁŸž<Á˜úüÁ’z›ÁŒZÁ…ÅÒÁ~æ§Ár~€Áf„çÁZ³§ÁNìTÁCšÝÁ8í¿Á.iÁ#æèÁÊvÁšÒÁ¡ÑÀý÷sÀî"VÀßpÆÀÑ;?ÀÄoÄÀ¸„aÀ­ÏÀ¥"òÀÆ´À—´œÀ“3zÀWÀŽÔÀ ÀgÊÀŽRÞÀ‘GžÀ”¾-ÀšØ†À¢„yÀ«µRÀ·@”ÀÂùzÀÐ_ÞÀÞ_,ÀíV‰ÀýNÁùyÁÈ×Á¾ZÁ$ETÁ.ø¹Á9ËõÁD¿ãÁPdÁ[’aÁgF±Ásd^Á¯±Á† ÁŒdøÁ’çEÁ™ryÁŸþ°Á¦‘¶Á¶€+Á¯¹ÒÁ©jÁ¢hLÁ›ã˜Á•y„ÁûÁˆ´HÁ‚s5ÁxÊÄÁmØÁaN,ÁUÒ™ÁJÐãÁ@;[Á5É7Á+zÜÁ!Ú/ÁˆîÁºCÁ‚›Àÿ¤ˆÀð½UÀâõ?ÀÖSiÀÊÁ¬ÀÀÚmÀ·ïÀ°èVÀªýÒÀ¦ëÀ£œÀ¡¢ÜÀ ŸÈÀ ò À¢Q)À¥áÀ¨ÐƒÀ®ßçÀµùWÀ¿OCÀÉõ±ÀÕÿÀâïÐÀðö½Àÿ¾7Á¨ŠÁú?ÁÇsÁ"!‘Á,B‘Á6…0ÁA.4ÁLåÁW3¥Áb¥ôÁn ÁyôÁƒÁ‰I„Áƒ0Á•åyÁœe¼Á¢ñÁ©iÁ¹#—Á²Á«óõÁ¥p?Ážñ(Á˜ˆ5Á’'Á‹çÁ…Ó,Á¢ÅÁs×4ÁheèÁ]D¾ÁR?ŸÁGÆÖÁ=nFÁ3gÁÁ*oÁ ù¾Á…µÁWšÁ•Á¤ñÀõ[‚Àé¢ÀÝÇdÀÓþ×À˨ÀÄ`ÚÀ¿‹Àº^æÀ·ßÀ¶kÀµ×Àµ–èÀ¶øfÀ¹”®À½qÈÀÃWÛÀÊ ÀÓNÙÀÝšìÀé)µÀõøÊÁçgÁ 4êÁmÁ¦Á"£Á+µÁ4´±Á>æÁI=3ÁSòµÁ^ã&Áj'[Áu•0Á€™úÁ†š-ÁŒ½²Á’ðqÁ™-'ÁŸºÁ¦æÁ¬€ Á¼ ¬Áµ…8Á¯kÁ¨|µÁ¡þØÁ›œxÁ•`¥ÁM´Á‰HwÁƒOïÁ{ìÁoúIÁdõ|ÁZ5èÁOÊjÁE¤ÔÁ<½Á2¾Á)´ËÁ!t+Á|uÁ"QÁ *Á7:Àü£ÀñRþÀèþÀà~ÀÙ`ÀÓÍÀÏqÙÀÍÃÀËuäÀÊ{ÛÀÊЄÀÌÒÀΙKÀÒ›wÀØ6œÀß*ÃÀçÁÉÀñŒïÀý ýÁÕÝÁ hÃÁØÁ~ðÁ"£Á+,Á4EÁ=Š'ÁGqùÁQ”îÁ\ÂÁf½ÁqáÁ}0XÁ„QšÁŠBÁYiÁ–uÁœ›€Á¢ÙÁ©:üÁ¯´~Á¿3ÏÁ¸¨^Á²îÁ«—uÁ¥0”ÁžîËÁ˜Ö§Á’âpÁŒùÄÁ‡!qÁoýÁwÎÁmÖÁbK ÁX!ÁNl=ÁDÿŽÁ;¢Á2ñÜÁ*ùçÁ#->ÁÇÁ‚æÁFBÁUYÁ%"ÀüåäÀõ>Àî,EÀéÀäå?Àâ£Àá)ìÀàƒ<ÀàÌÀâúÀ䤻Àèj Àíà1Àôœ×Àý0ÁA›ÁÔRÁàrÁu[Á•øÁ$18Á,J‰Á4‘¤Á=z¾ÁF¥¢ÁPMûÁZ=ŠÁdƒóÁoIÁyãâÁ‚–”ÁˆHØÁŽ2Á” Áš ÈÁ 8ÙÁ¦VªÁ¬—Á²ûÁÂd¡Á»á7Áµb‹Á®ùÂÁ¨³ÅÁ¢”›ÁœŸ´Á–¾éÁÞQÁ‹<Á…`SÁîŒÁuU–ÁjàÁÁ`ùYÁWi“ÁMÿÜÁE+™Á<½šÁ4–lÁ,ç°Á%¡˜ÁÄÝÁöÁ–=Á ¬JÁ EðÁNNÁ&BÀÿDÀû ÀøÍÑÀ÷g|À÷³À÷0]Àø…XÀû ”ÀþÕkÁ5Á*KÁ p\ÁÌÁdÒÁGÁ£TÁ&Œ‚Á.ÌÁ6/ Á>iµÁGÈÁP3bÁY£PÁcnÁm}VÁwò„ÁGËÁ†ÅÁŒj·Á’EÁ—÷0ÁñxÁ£öpÁªgÁ°>ûÁ¶‚µÁÅÈ›Á¿RìÁ¸î³Á²§lÁ¬‚cÁ¦w)Á …2Áš¤:Á”ÍéÁÁ‰šÏÁ„VÚÁ~=éÁsôŒÁj)Á`©ÕÁWêÁNíõÁFmÁ>VOÁ6ô»Á/ðèÁ)X~Á#ŽÁžÊÁ¬)Á]Ád²Á [EÁ ¾4Á×ÐÁÁ\Á&?Áç}Á&xÁ§ÖÁú‹Á áyÁ šÁÀ%ÁœaÁ6'ÁM†Á#ç×Á)Ê.Á0ˆ¨Á8.3Á@:ÔÁHJQÁPòºÁYÉÁc"ôÁl¿0Áv£Á€‚¹Á…¼ Á‹þÁ§ Á–GÊÁ›ýÁ¡ã’Á§à°Á­âgÁ´ÿÁºF!ÁÉKäÁÂòçÁ¼µËÁ¶‹Á°iKÁª]µÁ¤q%Áž¬ŸÁ™ŠÁ“qÁŽ qÁˆÓZÁƒ¢aÁ}§Ás³ÁjzkÁasÆÁXÄ!ÁP¢4ÁHÄþÁA”Á:ŠQÁ4ËÁ-â:Á(ÓsÁ#éÚÁ¬“Á¤ÁÝžÁn Á˜ŽÁoâÁÈbÁ™ÁÀ=Ái¡ÁɽÁªÁKšÁ¿Á „Á$—0Á)kÁ.æ¥Á4 Á:òúÁBeþÁJ£ÁR¬éÁ[»ÁcÓ"ÁlÔNÁvj,Á€ Á…ÁŠXÉÁ—†Á•\ÁšnÁ =ØÁ¥ý¯Á«ë Á±ïZÁ·ö Á¾!ÁÌûÁÆÆîÁÀœ]ÁºqÍÁ´V´Á®b³Á¨šÁ¢ùçÁ^÷Á—ÛÁ’‘ŒÁjÓÁˆKÁƒc\Á}}YÁtrºÁk†ÊÁc0+Á[ULÁS§çÁLl ÁE¤°Á?yÁ9PÿÁ4G:Á/UÁ+[ŸÁ'´öÁ$—…Á"5ºÁ ‚9ÁmÁÆ#Á¤†ÁÈÃÁMoÁ Ð'Á"¦ÛÁ%H"Á(N»Á,LÁ0c Á5 Á:V¶Á@HÁFAÁM'žÁU qÁ]/æÁetNÁnB.ÁwðÁ€6NÁ…XÁ‰ôEÁ EÁ”DÁ™ž ÁŸÁ¤²Áª]FÁ°%ËÁ¶øÁ¼4ÁÂ+NÁÐÜ^Áʶ+ÁÄ‘ÀÁ¾uâÁ¸|¯Á²¬Á­Á§gƒÁ¡×ŒÁœ{¯Á—SâÁ’70Á6?Áˆ\ßÁƒÄÁ~¾ÁÁvlÁmü³Áf?!Á^Ž»ÁWaÁPèÃÁJŽÈÁE (Á@ ÷Á;AkÁ7lÓÁ3Ä–Á0Û4Á.lëÁ,ÌÁ+šFÁ*ÿŠÁ*ÙãÁ+ZÁ+³­Á-øÁ.ѱÁ1Š9Á4‹!Á8!^ÁÃÁAÅÁDNóÁH„ŽÁM6†ÁR6ÁW„"Á]›žÁcóSÁk!vÁrîáÁzÕ·ÁšÁ†zÁŠ€yÁ4`Á“ñÿÁ˜Þ&Áö¦Á£ÿÁ¨l&Á­ÈcÁ³QÇÁ¹¹Á¾Å4ÁÄ’_ÁÊ…xÁØû«ÁÒôÁÌû;ÁÇ©ÁÁYÒÁ»¼.Á¶3ƒÁ°»½Á«jŸÁ¦+«Á¡#ÍÁœ5 Á—_¹Á’ÍÎÁŽbÅÁаÁ…éÕÁú{Á|a‡ÁuN!Án¯ýÁhCåÁbY¤Á]!ÐÁXÍÁSµœÁOú‡ÁLn½ÁIÈHÁGg†ÁFùÁDí¬ÁD[,ÁD‹ÁDƒ™ÁE4‘ÁFjÁH} ÁJÑ™ÁM™ëÁPñÃÁTêdÁY‘žÁ^€íÁc¢³ÁiãÁo¤nÁvw“Á~?ÁƒÁ‡'YÁ‹}žÁå·Á”x!Á™5ÜÁþÞÁ£˜Á¨$ýÁ­[ÛÁ²¤ÉÁ¸ÂÁ½›îÁÃVÁÉmÁÎèSÁÝ:©Á×A?ÁÑU­ÁËŽJÁÅî‚ÁÀiÁºé3ÁµNÁ°V}Á«>Á¦M°Á¡oPÁœÀ½Á˜7lÁ“Ù¦ÁŸsÁ‹œÁ‡©ôÁ„ tÁ€¤TÁz™êÁt\úÁn¦Áid®ÁdgÁ`g|Á\² ÁYVÜÁV¶)ÁT`ÅÁRñÖÁQÝ›ÁQ=ÁQ3TÁQ›eÁRX‘ÁS¢æÁUsÁWÁ ÁZkfÁ]èTÁa½'Áf¯ÁjòÝÁp2MÁuÓVÁ{ÂýÁ"Á„ÉÙÁˆÊSÁŒÝSÁ‘ ÂÁ•iKÁ™ç0Ážˆ„Á£H<Á¨0 Á­5nÁ²YJÁ·1Á¼òõÁÂb×ÁÇþ»Á͵>ÁÓuIÁá–’ÁÛ©ÁÕÜ‚ÁÐ5LÁʪYÁÅ#Á¿¿«ÁºŠáÁµuxÁ°j}Á«‚ÉÁ¦ÍTÁ¢)NÁ»ŽÁ™…°Á•j©Á‘eÌÁ‘™ÁŠÁ†¥sÁƒOdÁ€U¾Áz÷8Áuâ_Áq4’Ám#Ái„4ÁffšÁcÞÍÁa¥lÁ`(¶Á_Á^V`Á^^\Á^¿Á_´ƒÁ`öWÁbŸðÁdé3Ág¡èÁktÁnÈ}ÁràÊÁw—Á|ù3ÁAbÁ„%¦Á‡?¶Áо=ÁŽ”Á’˜VÁ–¾FÁšôQÁŸ`‡Á£øÁ¨™FÁ­n½Á²h›Á·jWÁ¼–&ÁÁêËÁÇFƒÁÌÁQÁÒe\ÁØÜÁæDÁàCœÁÚ–RÁÕsÁÏzGÁÊ æÁÄÊmÁ¿²;ÁºŸµÁµ¢ÑÁ°ÞAÁ¬BJÁ§»^Á£r©ÁŸGjÁ›;Á—VÙÁ“¦[Á.ÞÁŒºûÁ‰‚fÁ†™fÁƒÉ€ÁVÂÁ~ 9ÁzÃÁvsîÁs‹RÁq-UÁnîZÁm{—ÁlqhÁkÇìÁkÒÈÁl-ÚÁm5ÁnQ“Áp°ÁrPòÁu 0ÁxAûÁ{ÛNÁúvÁ‚FþÁ„êzÁ‡§”ÁЇßÁvÁåÁ”îÁ˜gòÁœuäÁ §ÚÁ¤ï2Á©w7Á®“Á²Á¡Á·«rÁ¼¦=ÁÁ¯ÕÁÆé¦ÁÌD©ÁÑ¥)Á×(µÁÜÒ©Áö\Áð²*Áë+ÁåÆTÁàj›ÁÛeÁÕáÁÐÈöÁËÝÌÁÇ ÁÂJÁ½ÆžÁ¹qtÁµ#ŽÁ± xÁ­2EÁ©{«Á¥äAÁ¢–RÁŸpAÁœƒ÷Á™Ý{Á—X}Á•*|Á“!üÁ‘n¥Áë£ÁŽ|­ÁTSÁŒ}¶Á‹³rÁ‹@®ÁŠø ÁŠâ,ÁŠîªÁ‹EAÁ‹õ ÁŒ·¡ÁÉ)ÁŽðèÁnÔÁ’!MÁ”¬Á–„Á˜gŠÁšç×Á©kÁ „Á£®ŒÁ¦ÿ‘Áªr²Á®1ËÁ², Á¶/6Áº\ñÁ¾»TÁÃ.ÌÁÇÉFÁ̘îÁÑ–dÁÖ·ÐÁÛå5Áá.ÌÁæ›ÁìÁñªnÁëõÁæRúÁàÐ6ÁÛdmÁÖ tÁÐÂ(ÁËšÎÁÆ›”ÁÁÄçÁ¼øÁ¸RæÁ³é‡Á¯™ÜÁ«YÂÁ§YëÁ£’ŽÁŸÝ‚ÁœsoÁ™TÁ–UÆÁ“¦^Á‘ÁŽÒgÁŒ®ÁŠæÁÁ‰Z§Á‡éxÁ†²€Á…ÜŒÁ…ÐÁ„¢¦Á„`Á„PáÁ„PLÁ„«5Á…V&Á†Á‡#YÁˆL'Á‰ÝbÁ‹‘¦ÁÁ®ãÁ’Á”±ÀÁ—zËÁšq(Á«ØÁ ø Á¤‹iÁ¨eŠÁ¬`\Á°{ZÁ´ÐÛÁ¹4 Á½¶UÁÂqŠÁÇb6ÁÌ£ÁÑ«¹ÁÖâÁÜ=“Áá¾úÁçc¢Áí_ÁçBóÁáìÁÜ[ÁÖ{dÁѳÁË©VÁÆr´ÁÁdwÁ¼ßÁ·º=Á²õéÁ®hEÁªpÁ¥ÆîÁ¡šmÁµ/Á™ÿ£Á–w$Á“D’ÁNúÁêÁŠâ:Áˆ-Á†eÉÁ„SÁ‚Ó{ÁréÁ€7ÍÁ~ˆÁ}ÿÁ|?Á{™°Á{“Á{µaÁ|u2Á}ºŒÁGíÁ€œ!ÁÌuÁƒbäÁ…xÁ‡ÀÁ‰HÁ‹Ð“ÁŽ€~Á‘_pÁ”k¶Á—¯ŸÁ›xÁžÌ6Á¢ yÁ¦ YÁªæbÁ¯P‘Á³É(Á¸lºÁ½IÈÁÂZ‚ÁÇ|ÁÌ¥¦ÁÑöBÁ×q]ÁÝÏÁâÎÁ與Áâ«ÁÜïÎÁ×T«ÁÑ¿2ÁÌ+¤ÁƬòÁÁWÎÁ¼3Á·@½Á²vÄÁ­¯“Á¨ü,Á¤‰´Á ?YÁ›ùqÁ—êÂÁ”-ÙÁ©jÁX¥ÁŠN°Á‡hßÁ„·Á‚QúÁ€2XÁ||ØÁxìÁv2AÁs¾´ÁqzÁp{ÁoKÝÁnµúÁn½Án÷÷ÁoÒÁq úÁr¥7ÁttóÁvó×ÁzOÁ}“«Á€ÉAÁƒ¼Á…›ÒÁˆVdÁ‹L0ÁŽmqÁ‘Î`Á•jÎÁ™±ÁœëyÁ¡Á¥wÁ©ûÁ®Ž)Á³VšÁ¸S•Á½jþÁ‡”ÁÇËÁÍ;âÁÒÖvÁØ’wÁÞSnÁä=øÁÞBOÁØg”ÁÒ°†ÁÍ›ÁÇ|2ÁÁäCÁ¼lyÁ·$`Á²7Á­3°Á¨l€Á£§VÁŸ Ášµ?Á–z-Á’UÁŽsÁŠê¼Á‡Á„c(Á\nÁ}NGÁxs8ÁtÄÁp†Ál“êÁi§SÁg0ÁdÑDÁc[!ÁbbDÁaý‚Áaô×ÁbPÌÁc@ÁdeˆÁfÁh ÌÁjøÁmµÝÁqOæÁu9ÁyæÁ~ü Á‚LdÁ…>iÁˆ€¼ÁŒPÁ½SÁ“qMÁ—jÁ›²Á /üÁ¤»ªÁ©xíÁ®dªÁ³kðÁ¸ˆÁ½ÁÁÃ%šÁȶ¦ÁÎoºÁÔ4ÏÁÚÃÁàAÁÙüyÁÔxÁÎ'ÁÈs#ÁÂÙ1Á½B÷Á·¸¢Á²LäÁ­`Á¨ÜÁ£AÎÁžtÁ™µÞÁ•:¥Á‘ÀÁŒî!Áˆò#Á…E)ÁëÁ}NÔÁväÿÁqD€Ál‚+ÁgïöÁc¸ŒÁ`ZRÁ]0ÝÁZ·!ÁX…òÁV÷¦ÁUͯÁUi¥ÁUh0ÁU΂ÁV¯ÄÁWÃæÁY¢ÜÁ[°2Á^NÁaŽÁe9äÁiOZÁnæÁs!kÁxÁÚÁ~½0Á‚ÆjÁ†tŸÁŠ(£ÁŽ0Á’ 'Á–våÁšìàÁŸœûÁ¤„:Á©u§Á®.Á³ÒÁ¹3ŽÁ¾¹ÁÄaÁÊÁÏèÁÕÒíÁÜ eÁÕØ­ÁÏ»Áɾ£ÁÃæ¼Á¾7Á¸¦îÁ³$1Á­©DÁ¨NÌÁ£+-ÁžB¿Á™nÆÁ”›ÆÁ÷ìÁ‹¢Á‡–2Áƒœ™ÁïÁxž(ÁqåãÁk®Áe§ÑÁ`»mÁ\:ÀÁWÝÞÁTRàÁPõ+ÁNw0ÁLKýÁJµÿÁIˆeÁIJÁI.ÁI££ÁJ]XÁKcÂÁMNkÁOU¨ÁRÚÁUm„ÁY1LÁ]²NÁbxòÁg¶ŸÁm9¨Ásy¸Ázl÷Á€â‰Á„´!Áˆ¨®ÁŒì¡Á‘CÁ•ÔÁš¬hÁŸ£>Á¤ª%Á©è¾Á¯ViÁ´ÝÁºl»ÁÀ“ÁÅÑûÁ˸ÔÁÑÃIÁØÎÁÑ× ÁË  ÁÅ„Á¿‹%Á¹¹HÁ´GÁ®’LÁ©ÛÁ£¢Áž]Á™TÁ”}ŠÁ©°ÁŠì¦Á†v’Á‚O”Á|œvÁtµ“Ám~«ÁfÁ-Á`9>ÁZÔÁUCSÁPŸÁL èÁHãÁE:CÁB…Á@,Á>†;Á=RÁ<ú#Á<ýÁ=‡“Á>M4Á?gÁA2~ÁC;ÁF 8ÁIT¸ÁMg-ÁR}ÁWáÁ\|;Áb8ÁhûÁofPÁvègÁ~‘«Áƒh«Á‡ÊÁŒE3ÁþuÁ•ð¡ÁšíDÁ  Á¥rPÁªü7Á°‹!Á¶#”Á»Ú#ÁÁº'ÁÇ¿ôÁÍä;ÁÔ=#ÁÍývÁÇ¿!ÁÁ†‰Á»mÁµyjÁ¯¯lÁªÁ¤Œ5ÁŸ ŽÁ™¢²Á”vzÁ‹,ÁЏSÁ…ìíÁaoÁzN4ÁrGgÁj@ÚÁb½FÁ[üæÁUetÁOu"ÁJ ØÁE/¤Á@»yÁ<ãSÁ9¨ÌÁ6´Á4€óÁ2ÄEÁ1‘Á1çÁ0ùVÁ1o,Á2i†Á3„ÐÁ5.Á7„¸Á:rÅÁ=¯˜ÁAêÁFmÁKÚÁQÜÁW·Á]É.ÁdÞ…Ál^0Át0ÎÁ|Ç;Á‚êÅÁ‡ˆ%ÁŒYÖÁ‘?‚Á–IÁ›‘UÁ¡TÁ¦¯ÊÁ¬WëÁ² |Á·ß9Á½ÓÍÁÃæ3ÁʘÁІ´ÁÊ.ÍÁÃî§Á½µŒÁ·„wÁ±t€Á«‹ÅÁ¥ÎwÁ 2ãÁš¢äÁ•ÂÁÃàÁН£Á…ÓÉÁ€üÜÁx¥õÁpæÁgö|Á_ñÎÁX_=ÁQg¸ÁJä‹ÁDšÁ?$cÁ:WÁ5’QÁ1}gÁ. ŽÁ+A Á)½Á'JÁ%ÿ,Á%QëÁ%4WÁ%œÀÁ&‰[Á'¶§Á)SÁ+â¸Á.ðiÁ2ˆüÁ6ÀÉÁ;[IÁ@áÛÁF XÁLâ‰ÁSŠ+ÁZÔŸÁbKFÁjpÂÁs+ØÁ|C3Á‚è5Á‡»õÁŒ¨ÂÁ‘ÙqÁ—HäÁœêÁ¢Ÿ}Á¨WyÁ®VÁ³÷ÜÁ¹ÿÁÁÀ,xÁÆz’ÁÌô±ÁÆ~ ÁÀ%Á¹çUÁ³¯bÁ­†$Á§ƒÁ¡ªƒÁ›ý%Á–YÍÁÈÁ‹T Á†˜Á(Áx˜,ÁnùmÁeýhÁ]ÀóÁU¶ÊÁN/ÁGéÁ@0èÁ9ô½Á4TLÁ/R§Á*‰®Á&ŒØÁ"ÿÐÁ ,ÊÁ¹ÛÁ¹ZÁžLÁÑÁû}ÁYßÁTÁ_¬ÁÁ LÛÁ#½‚Á'q'Á+ÑCÁ0Ò&Á6›Á< ÃÁBª ÁIƒƒÁPò1ÁXÔ¢Á`÷ÜÁiž¬ÁröþÁ|½ŸÁƒL¸Áˆ`—Á¸oÁ“7fÁ˜Ò Áž”ÖÁ¤g0ÁªD¢Á°DÁ¶jÅÁ¼´ÁÁÑÁÉ›ñÁà Á¼”FÁ¶<»Á¯ö†Á©µ=Á£’NÁš/Á—ÑíÁ’,ÁŒ‡5Á†öxÁ¥JÁy2Áo…±ÁeÑãÁ\”ÁTŸÁLŠÁD?Á<í+Á6 OÁ/Ò¼Á* ëÁ$Ç[Áü Áï÷ÁF9ÁÚÁ”uÁ±°Á‰ ÁÝÈÁäýÁCÉÁßÁ;ZÁó¼ÁMŽÁ¸þÁxMÁ!YMÁ&v–Á+Ü•Á1ü>Á8xÂÁ?œÁG{[ÁOyËÁW¨Á`œsÁjJ Át5òÁ~;½Á„`‚Á‰¸žÁ89Á”ñ­ÁšËåÁ ¨Á¦š®Á¬·„Á²úRÁ¹_0Á¿ÑjÁÆ[qÁ¿ÅlÁ¹@]Á²Ó0Á¬} Á¦+àÁŸçaÁ™ÊÕÁ“ÜtÁŽ!^ÁˆzrÁ‚ÔÁz­<ÁpBÎÁfoùÁ\ÀÛÁSA˜ÁJ††ÁBZÁ:~ŽÁ3¿Á,6#Á%² Áý\Á†"Á޳Án¶Á ¨öÁ a ÁóÁþ}ÁËrÁ¨ÁÜÄÁ9žÁãËÁGÉÁ""Á Ñ7Á6žÁAâÁôÐÁHhÁ"7vÁ(KòÁ.³*Á65ŒÁ>3*ÁFQ¢ÁO ÁXKlÁaßKÁkÅ«Áv, Á€dÒÁ…ͶÁ‹vÁ‘IÚÁ—!­Á ËÁ£¾Á©[Á¯·Á¶%uÁ¼™eÁÃ=dÁ¼[ÁµørÁ¯}Á©&7Á¢ÓÁœ‚üÁ–NÁ<žÁŠU²Á„ŽöÁ}Ï?ÁrÁ€Áh Á]×KÁTKÁJlîÁAOÕÁ9zÁ1Á)f¨Á"zÁºÁñÁÁpÊÁ ÀúÁc.ÁxoÁO†Àû1@À÷93ÀôxÀó^¡ÀòýÖÀóªnÀõ&*À÷@aÀû4¥Á€ËÁQÁ„ÑÁ òèÁ¢OÁ 4Áë6Á%áÚÁ-@mÁ5 AÁ=´yÁFê±ÁP'pÁY™ÿÁc½¦Án;öÁxàýÁ‚[Á‡Õ7Á¹òÁ“¡#Á™­-ÁŸäeÁ¦+#Á¬‚­Á²ïPÁ¹xôÁÀVÂÁ¹—˜Á²æåÁ¬RµÁ¥Ü¼ÁŸ{~Á™(ÅÁ’í³ÁŒÒøÁ†ÊžÁ€ãiÁv$ÏÁkcÁ`PDÁU¯vÁK’?ÁB ‰Á8Ó\Á00&Á(ÂÁ ?>Á8jÁ˜Á ‚Á {ÁÀû¾Àò¥^Àì…Àæ¯hÀâëÀà#ûÀß>ÂÀÞ»ÏÀßzàÀàÓ¿ÀãNëÀç°ÛÀíÿJÀõKÐÀþÁÁ„Á UÑÁHÁO;ÁzÁ$°àÁ,¹àÁ5¢¨Á>ÞºÁH?“ÁR‹Á\SÖÁf¹Áq¨$Á}´Á„e¯ÁŠD.ÁEEÁ–uÃÁœ¸×Á¢ÿßÁ©eÁ¯ìòÁ¶áÁ½‚Á¶ËûÁ°CÁ©n¬Á¢ÝÁœU,Á•áÁ’XÁ‰o…Áƒ[¤Ázµ³Áo \ÁcÂxÁXÒ×ÁN#ÁC’¨Á9ÐÁ0‘¹Á'„½ÁOûÁBÁ Á ±'Á‹“Àû¸üÀñVÈÀè/TÀßÛ7ÀÙbrÀÓâ²ÀϱÍÀÌÙßÀË‚)ÀËÀËë<ÀÍŒÀÏÕÚÀÔÎÇÀÛ4ºÀâ|JÀìaÀö°“Á¿WÁó¡Á èÁÁñ~Á%&)Á-Á Á7"ÁARÁKÙÁU]>Á_ìïÁjêÁvS ÁÖÁ‡+Á5jÁ“nÚÁ™±¼Á •Á¦˜2Á­2@Á³ÐÁºÖúÁ´|Á­WuÁ¦¢_Á MÁ™twÁ’ïŒÁŒIÁ†9½Á€ñÁsþPÁh&Á\¿AÁQÀWÁFÇÁ<)GÁ2<~Á(ÓÝÁ—åÁ)ûÁ&JÁ”{ÁØ®Àõ GÀélAÀßnËÀÖ$GÀÎ ºÀÆ’«ÀÁqÀ¼öÇÀºaœÀ¹ìÀ¸ºlÀ¹W’ÀºåQÀ½Ö)À„³ÀÉ@ÐÀÑ˦ÀÚ߯ÀåäFÀñ‹6ÀþI Á© Á ^ÝÁ”<ÁÏ-Á&ŠÌÁ/úúÁ9çÁD8ÁN³yÁYImÁdl€ÁpÁ|UÁ„˜ÁŠ2Ám–Á–ÐÁWMÁ£ònÁªÁ±: Á¸qÁ±—€ÁªËîÁ¤AÁJ¾Á–® Á3Á‰ÈIÁƒgIÁz\ØÁnrÁaø0ÁV?ÏÁKÚÁ?öÄÁ5ŽÁ*ÛrÁ!^IÁñÁ0ÁT—ÀÿûÀñjÀä.˜ÀØ·qÀÎd£ÀŨÀ¼«(ÀµmÀ°TÀ«$ÍÀ¨~ÁÀ§.ãÀ¦òŠÀ§bºÀ©`À¬¤öÀ±]RÀ¹GÀÁÁ/ÀË%ÀÕ‹ŒÀâÀï)|ÀýåÁ1pÁ_ÁòÁ²\Á(òÕÁ3OÁ=¨ºÁH=uÁS&,Á^nkÁj: Áv;'Á!ÉÁ‡L,Á¥Á”&îÁš¹êÁ¡U¢Á§ú£Á®»9Á¶Á¯=•Á¨aÃÁ¡ŒuÁšÏÁ”)þÁ IÁ‡*<Á€ÁŒÁtÊ£ÁhmÁ\OæÁPdqÁD ¶Á9rÁ.ÈÁ$[VÁb·ÁþÈÁ+4Àÿ³´Àð-§Àâ gÀÕÌÀÉ"ÃÀ¾`WÀ´Å¯À¬F‡À¤íÀŸ’Àš¨¯À—ü/À–:sÀ•îþÀ–«ŒÀ˜£gÀœ,À¡&ÉÀ©u#À²'=À¼.YÀÇI›ÀÓn]Àá.ÀïîÀþºñÁˆyÁ[ÁDÔÁ"οÁ,ìEÁ7B¢ÁBÕÁM¿ÁXwÈÁdfÕÁp–aÁ|ÕÄÁ„·Á‹-ÒÁ‘®HÁ˜2!ÁžÏ™Á¥Œ`Á¬dÌÁ´ÝÁ­~Á¦2ÁŸJÁ˜t¾Á‘½ÎÁ‹)­Á„±MÁ|tUÁoˆ4Ábá2ÁV¬±ÁJÕªÁ?Á3šgÁ(΋ÁUÁéùÁ P»Á¤}Àò;ÀáþÅÀÓø«ÀÆ#ÀºÀ®ÇÀ¥VÀ@À•¨ÌÀÌ À‹*FÀˆ?)À†pfÀ…¹²À†ØìÀ‰”À:BÀ’Ô‹ÀšªuÀ£nÒÀ®UËÀ¹Ï£ÀÆEmÀÓ|ßÀâ% Àò)Á;0Á !qÁJæÁù£Á' $Á1®»ÁÁfg ÁröÁÛxÁ†{sÁ ËÁ“º8Áš†áÁ¡h×Á¨U–Á°O=Á©GVÁ¢Q¥Á›sÁ”™GÁÂìÁ‡÷Á€r:ÁsÝ%ÁfÙSÁZ\ÁM«¢ÁA–@Á5Ÿ²Á)ÈÉÁ]ÖÁ±ÜÁ l¤Àþ™dÀì-#ÀÚ¢ÛÀɼ4ÀºÛÀ¬Ñ5À 3ÓÀ”Ç@ÀŠÒêÀÊôÀu‹ ÀhÎÀ_ZÀWÿÁÀTWŒÀS ŠÀUÀ×ÀZè5Àd‚¾Àq]À€±µÀŠFÀ”«òÀ ÏÀ­$¨À»ŒÂÀÊ ÀÚ_4Àë(#Àý Áø¥ÁëÛÁ¶Á&œlÁ1ÿÁ=­»ÁI‡TÁU‡ÌÁaËÄÁn€·Á{w+Á„@ÁŠáüÁ‘§Á˜ŠFÁŸ}‡Á¦q·Á®²KÁ§­Á ¨²Á™µ…Á’Û¦ÁŒ‚Á…K:Á}@ƒÁp.YÁc(°ÁVH!ÁIÆkÁ=¬Á1š’Á%™ÑÁ5Á|¡ÁÔPÀôçÒÀâséÀÐ¥.ÀÀ=…À°ÏÆÀ¢}iÀ•“oÀ‰‘œÀ}æ‚ÀlÄÀ\;ãÀP48ÀF—À?*NÀ;æÇÀ:q{À=&ÀAÿLÀL¼ÀX¾ÚÀiª-À|%’À‰IÞÀ”¹KÀ¡®µÀ°”À¿µÀÏkgÀßñ¤ÀòxÁÁÒnÁ ÖUÁSVÁ",]Á-ÔÁ9ÖÁE'ÁQOÁ]é¦Áj¯ŠÁwˆyÁ‚ZGÁ‰ ƒÁвÁ–¬±Á›Á¤›5Á­?nÁ¦.ÁŸ&tÁ˜(¾Á‘DÁŠ|6Áƒ±EÁyæeÁl¹‰Á_ÒÝÁRñ ÁF;“Á: Á.=Á"Áq5Á •¿ÁÑÀí=ÀÙ÷ÅÀÇÜ—À¶òeÀ§&AÀ˜Î¯À‹\\À}£’ÀhXKÀVD#ÀFCúÀ9ýÀ/ý[À)³šÀ%\ÈÀ$æ[À'/„À-RÀ68üÀC”ÀSnÀgÉÀ|ùYÀŠ8ØÀ–yÀ¥JÀ´dÀÅG1ÀÖUºÀé?ÀüRÁdâÁ ÁñÆÁ)`Á4ëØÁ@äèÁM\6ÁY÷2ÁfÊ…ÁsöãÁ€Ÿ¼Á‡GmÁŽ ºÁ”ð¬Á›â{Á¢ÛFÁ«Ò½Á¤ÁnÁ¶âÁ–¸ÁÉÁˆö±Á‚>QÁwÁiÂ-Á\МÁPöÁCCÁ6áÁ*ñ°ÁsÁAcÁ3Àú¾&Àæ=vÀÒ´žÀÀ†À¯"ÀŸ ZÀOäÀ‚´ÀlB.ÀU÷cÀAÉ„À1Ý…À$„À€NÀ`âÀ[£À(<À+À&À$#\À0xÀ?–ùÀS¦wÀh,ÒÀ€mÀ©À›l£ÀªÿýÀ»™ÀÍ ÀÀà(ÀóBùÁ%ÁßÁíšÁ%ƒ·Á1NæÁ=t¶ÁI² ÁVUÑÁc_KÁp˜Á}æÁ…¥ÿÁŒzmÁ“dyÁšUÁ¡TrÁªŠÁ£bïÁœZÁ•iþÁŽŽ®Á‡¯ŸÁ€àÌÁtVÁgdÁZæÁM/Á@züÁ4rÁ'ã]Áù6Áf"ÁWnÀôÛ6Àßô0ÀÌ3·À¹6–À§»À—foÀˆÓÏÀu-œÀ\&¶ÀE]tÀ0èZÀ  À®•À ÙÀÎÏÀÀêNÀ¨TÀ $À vÀLÀ.x6ÀB>ŸÀWnÀnŸ¡À„öÈÀ“WÀ¢Š`À³w»ÀÅ3CÀØMZÀì$ÁtåÁ CúÁDYÁ" ’Á.!¢Á:8XÁF‰ËÁSYÁ`ehÁmrÎÁz«êÁ„‹ÁŠþÂÁ‘üÏÁ˜þ¨Á ™Á©E:Á¢!ÞÁ› cÁ”ùÁ!¤Á†W†Á9£Áq×Ád|ÁWPŸÁJ^0Á=ÊÁ1nSÁ%&ÃÁ1pÁ ­ÏÁ‘òÀï÷ÀÚyÀÆGÀ²ß™À¡eŒÀé.Àÿ‹ÀgøÀNHéÀ6À"“À æÀÇá¿ô!¨¿ç™ ¿âï‹¿ã,¿éÕ¸¿ôÿ`Àÿ{À‡ŽÀ×À1£2ÀGécÀ_¥˜Àyµ‹À‹¸žÀšðˆÀ¬`uÀ¾:}ÀѺÀår†ÀúÏÁ7>ÁpÁ&Á+ Á7eõÁCÝBÁP³Á]ºdÁjÎfÁxÈÁ‚Ù¼Á‰Å<ÁÂÁ—ÀzÁžÁ³Á¨3Á¡ 'Áš³Á’ýÚÁŒçÁ…/BÁ|àÁohìÁbùÁTÄCÁGÑÁ;1>Á.×øÁ"…rÁ¥Á pÀÿ‹9Àé~ÐÀÔ­ÞÀÀ}ÖÀ­\À›’DÀм3Àw…À[oéÀAZ`À)©2À»ÜÀ‡H¿ì˜ã¿×û¿Ê¿Åò#¿Æèµ¿Í£¿Ùõ¿ël„ÀQÀÝÿÀ! YÀ8¹(ÀQßwÀlI©À… ¯À”‚‡À¦)[À¸˜°ÀËÕ­Àß«ÀõwÁŒÁøbÁÇÁ(«‘Á57ÁAkVÁN6€Á[<)ÁhO½Áu¥ Á£ÐÁˆ•Á“íÁ–“GÁ˜+Á§ ŠÁ  ‚Á™“Á’ \Á‹ØÁ„&îÁz´®Ám8dÁ_ÆYÁR”4ÁEªuÁ8ã°Á,cpÁ %Á@ÁöÀúƒfÀäiÔÀÏnÀ»wÀ¨D­À–PKÀ…s@ÀlÆÀOŠtÀ6gÎÀ©zÀ 3¿ñ¿ÖÉ¿Âad¿´Ä¿®¿¯éË¿µ­è¿Àž ¿ÓQG¿êu¾ÀeÀœÀÀ, [ÀF]%ÀaÀ‰ÞÀãúÀ »'À³’²ÀÇÀÛ”vÀð­fÁt`Á°îÁ9:Á&s-Á2Ü“Á?K&ÁLÁY5ÁfFZÁs¥,Á€¦Á‡‹¹ÁŽyuÁ•uÁœ}ÂÁ¦H™ÁŸ*ÄÁ˜'Á‘2ÁŠ¡Áƒ,•Áx»¸Ák0œÁ]ÃCÁP¯XÁCÐÁ6ó;Á*HÉÁ,±Á5žÁK”ÀöÝÀà@8ÀÊ»$À¶Ý‘À£¿¿À‘°­À€ÓÀbȯÀFœÀ,vÀQvÀ“̿޴C¿Â¾(¿¯,¿ «þ¿š}`¿›™"¿ iÚ¿«ìY¿¼B>¿Ôná¿ñ’ÅÀ ÜRÀ"ƒ¸À<ÀÝÀX€›Àv!ìÀ‹ ²ÀœØÀ¯PLÀÃÞÀ×¾îÀì­ßÁÒÁ ØÁróÁ$¬úÁ0ì'Á=?jÁJ ÁÁW4„Ádf‡Áq»¦ÁZ•Á†’ûÁzðÁ”uéÁ›‰‚Á¥»Áž“ Á—~ŸÁnªÁ‰fÈÁ‚qzÁw8KÁiÔÁ\pÁO7bÁB4äÁ5F Á(ŒÁ`ÀÁrÁ­3Àò·mÀܪ/ÀÇ…ÝÀ²ú_À  ÀìlÀyyMÀ[5À>psÀ$'À öœ¿ðÀž¿Í=¿³„I¿œ>Å¿Žöj¿ˆ°-¿‰ZÐ¿Ž´7¿˜¥Ö¿©)¼¿À¥¿àJ’Àò À„çÀ4ýÀPwdÀnÊéÀ‡Ÿ&À™u:À«XTÀ¿±|ÀÔOßÀé8¨Àÿ Á ‚ÁÇ¿Á"Ó1Á.úÁ;ISÁHýÁUQŒÁb©¾ÁpTÁ}‰§Á… ñÁŒ“Á“ ÒÁšÅ Á¥AÁž‹Á–öEÁòüÁˆý#Á‚#Áv7YÁh¡)Á[PÁNèÁ@ÚÎÁ3ürÁ'Ž_Á9¥Á!-ÁnÕÀðX\ÀÚØÀĽDÀ°cÀÇÀŠáÖÀsÉGÀT£ãÀ8vÀ2À[¿ãq¿Áý¿¥œö¿Žá,¿~'¿sÛÊ¿uú¿¿‰±¿¿šÞ¿²†’¿ÑÆŒ¿÷‹¡À®À+hÀHøÍÀhƒÀ„sØÀ–EÀ¨:æÀ¼„HÀÑ)Àæ*ºÀü{€Á ÔÁHGÁ!!‰Á-v¾Á9àHÁF¶kÁS»§Á`öÁnaÛÁ{ü•Á„áhÁ‹×‘Á’ÜÁ™íÁ¤äÁ°äÁ–’dÁ‹¦Áˆ™“Á®EÁu”(ÁgíÎÁZŠ›ÁMECÁ@&ÏÁ3kÁ&æÁbëÁMÏÁ¹Àî™óÀØUÀµÌÀ®Ü«À›ûÀˆŠHÀo|›ÀN÷ªÀ2«ªÀéøÀ±K¿ØšW¿¶àÞ¿š¿ƒE(¿g£ù¿\³—¿Z:4¿fï¿¿zP0¿Žtô¿¤àé¿Å–¿ëÀ ðÀ%NèÀC/‚Àb‚6ÀˆxÀ’þÄÀ¥½GÀ¹8ÁÀÍÄoÀã…îÀùœ½Á'ÅÁÙ£Á³îÁ,4Á8—ÁEdoÁRuËÁ_¡)ÁmÎÁz­?Á„@Á‹8åÁ’D9Á™\zÁ¤¾×Á‚Á–pyÁf‘Áˆt¯Á”£ÁukÁg¹íÁZKäÁMŠÁ?ó\Á3.!Á&¦ÕÁ&Á´Áq4ÀíæsÀ×nCÀÁ¡ÕÀ­±•À™ÚCÀ†¯ÊÀl£cÀL$À.ËÓÀ{Å¿ø{$¿Ñ9È¿¯få¿‘ð ¿tq¸¿Y½Ù¿HÂw¿Hg¿Pí`¿g—¿ƒxÿ›a†¿ºÂw¿à‚@Àì¾À ûÆÀ>h6À]z]À~KkÀ.üÀ£9fÀ¶œ8ÀË+ÀàÒ¶ÀöÖ ÁÀòÁ‚aÁnÔÁ*à—Á7”ÁDL—ÁQVûÁ^ŽtÁkêÁyŠiÁƒ±ÓÁб€Á‘À~Á˜Ù*Á¤Å“Á¥{Á–ˆnÁpÕÁˆoœÁ‹ÏÁupŽÁgÌÁZ]çÁM@‘Á@/òÁ3DlÁ&³ÉÁKfÁLlÁhÀíÆþÀ×vºÀÁf‰À­1ÈÀ™O!À†|YÀjx—ÀJÉÀ,“CÀ ƒ¿ô´7¿Ìl«¿ª=¿“¿kÏ…¿Jg¿<½æ¿9õ‰¿@Ãë¿VFj¿xg—¿‘_‹¿²†m¿ØD†ÀžeÀ/òÀ9{÷ÀXܺÀy÷ÀŽÈÀ àmÀ´lÀÉ <ÀÞÀô£~ÁÊlÁo3Á Á)ïÁ6|JÁCL4ÁP:]Á]v>Ák DÁxÛ;ÁƒZLÁŠHœÁ‘J=Á˜c'Á¤ß ÁÂ;Á–­ZÁ¢†ÁˆŸÁ¶ÀÁuÁŒÁhœÁZ©>ÁM½Á@‘yÁ3¯*Á&ûJÁŸ¡ÁšƒÁ´ÀîVÛÀØ ŸÀÂóÀ­wcÀ™Y<À†ßÀjV‹ÀJ¡ŒÀ,NÀ‡È¿ôY¿Ë P¿¨)2¿‹I’¿gSC¿E‹¿66¿1Os¿8Šc¿Hp>¿ipW¿ŒÞ¿¬²¿Ò¥¿ütwÀ]÷À6HÀUíÌÀv5òÀŒÏWÀŸ À²Ú ÀÇ)¦ÀÜæýÀòù¶Áù0ÁŶÁÊùÁ)$ Á5£…ÁB„ŠÁOÇÁ]NÁj{2Áx?Á‚ôÁ‰õqÁ‘ aÁ˜(Á¥[Áô Á–äRÁÚ³ÁˆÔxÁåmÁv-ÁhÄ$Á[^ŠÁMýþÁ@àÁ4&¬Á'¬éÁC@ÁÁ2ÀïASÀØã{ÀÂâ.À®ƒ0ÀšIHÀ‡»¤Àlg9ÀKŒ±À-Û5À+§¿õ‰®¿ËÜõ¿¨ W¿‹0°¿km÷¿Dï¿3*&¿/ñ¿4Ëz¿@ª·¿_ׂ¿‰N½¿ª¶î¿ÏÿÊ¿ú½5ÀeÀ3~ÀSi„ÀtµÀŒM8Àž‘+À±¢`ÀÆÒZÀÜ;ýÀò4Á˜Áv Á·Á(í Á5…®ÁB/}ÁO9äÁ\¡ÉÁj-vÁwʬÁ‚ÉÂÁ‰ÊÁßWÁ—÷.Á¥yUÁž^lÁ—NpÁ<‘Á‰4îÁ‚I¾ÁvøœÁih¸Á[ãzÁN­áÁAÌîÁ4öÓÁ([¸ÁßWÁÏãÁŸÀðÜÁÀÚâÀÄœ¡À°HÀœ#À‰tíÀonWÀNÑÀ0“<À¿úZp¿ÒZ¿®…ú¿‘@¿uõ¿Rgj¿<…¾¿5#é¿610¿Fco¿dœï¿‹žò¿¬?¡¿Ñv:¿ùª¢À‰ À2ÐëÀS‚ÀujVÀŒ‡JÀŸIgÀ²âÀÆÉ‡ÀÜ WÀòyÁ´öÁh Á•,Á(×–Á5‹ßÁBjïÁOf)Á\´!ÁjG=Áwç¯Á‚ÉÁ‰ºôÁȼÁ—î:Á¥üëÁžãGÁ—ÊÉÁ´8Á‰±‚Á‚ËáÁxÁj€£Á]ÁOÑ–ÁBç¬Á6 ùÁ)r‹ÁzÁÛ"ÁÝÀó;­ÀÜÏNÀÇhÀ²ÕÀžŽaÀ‹èžÀsôSÀSlŒÀ5ÄDÀúÀ ¿Ûo¿·Ä#¿šûz¿„gØ¿f  ¿Q‹÷¿HïÓ¿I¿YÏï¿r’3¿‘Ø«¿°<é¿Óx1¿û©|Àð}À30:ÀTu±ÀwBNÀ—yÀ T–À³Ë+ÀÇ÷\ÀÝ ¢Àó”ŒÁMÒÁ7·ÁZTÁ)£¨Á6)IÁC 5ÁOÿ=Á]!?ÁjšrÁxXþÁƒåÁ‰ý±Á‘eÁ˜òÁ¦´ðÁŸšÞÁ˜‰Á‘}ñÁŠxòÁƒ‹³ÁyvéÁkõ]Á^‚÷ÁQWaÁDD“Á7VÙÁ*פÁ˜ÃÁiðÁ¤ºÀöwŸÀà5‰ÀÊ7*ÀµéìÀ¢l-Àk\À{¾¾ÀZ¶NÀ<§À!y®À ÓÏ¿èŸÚ¿Å^v¿ªcÔ¿“ þ¿ƒÍ;¿u×ä¿j7È¿k훿xñM¿ˆÛ'¿x`¿·ÖÑ¿Ú5ÀyÐÀ3ÈÀ75ÀYWÀ|õÀ{À£,¿À¶=ÀÊl ÀàxÀö5dÁˆœÁRiÁKƒÁ*£¸Á7"úÁCì‹ÁQbÁ^@ÈÁkßÁy-ŒÁƒ}ŒÁŠf;Á‘Z?Á˜h4Á§€)Á mXÁ™`ðÁ’V\Á‹V÷Á„tnÁ{NøÁm¾>Á`UÛÁS6‰ÁF9\Á9h§Á,ÔôÁ ”5ÁpYÁ˜æÀú‘ÕÀäk’ÀÎÚÀºyûÀ¦òšÀ“è%À‚}ÇÀdÈÀEâˆÀ+¢$ÀÒ„¿ý‰ñ¿ÚÁ ¿¿Wø¿©ÕÆ¿›xÖ¿‘<¿Ž!ª¿`œ¿‘Ëo¿›Ý¯¿®)}¿ÉO*¿ë%¿À !+À$fúÀ@¼ëÀ`TPÀ‚fÜÀ”kòÀ¦»/ÀºŒ0ÀÎ|wÀã¯}ÀùךÁ”Áñ>ÁèÏÁ,7ØÁ8ϽÁEu³ÁRmšÁ_—ÁlâeÁzf Á„öÁ‹Á’êÁ™yÁ¨xËÁ¡c;ÁšO^Á“E4ÁŒS"Á…~žÁ}nÁoâcÁb‘ÁUfFÁHo{Á;ÄÔÁ/5ÂÁ"éùÁ6Á OLÀÿcóÀé ŽÀÔTâÀ¿æ#À¬CÍÀšZÕÀˆÀæÀp¹ÀR9;À7õcÀàÀ io¿ôûw¿Ù´q¿Æ¡Û¿·Ñ÷¿°8¿ª§¸¿ª•¿­Î¿¶_~¿È,¿ã¼ÒÀ%-À=À/ÙÆÀKÇÀlÐÙÀ‡ÌÀ™æXÀ¬sÝÀ¿øUÀÓ‘kÀè3ÀþšIÁ ‹/Á+[Á"pÁ.!ùÁ:«ÉÁG`ˆÁT7ßÁamÜÁnËuÁ|4Á„çÁ‹ÓnÁ’ÑŽÁ™ÐÒÁ©‚Á¢xþÁ›u»Á”w Á’´Á†¸€ÁË•ÁrN…ÁeÁX—ÁK&Á>ŒVÁ1ûÕÁ%¯íÁð!ÁOcÁìâÀïÚÍÀÚ´YÀÆž À³HÊÀ¡ «ÀˆÀ«ÚÀaó¹ÀFïzÀ/*HÀÉrÀ ¿û?@¿èb¿¿ÚöÞ¿Ò¿Îjä¿Ì¦n¿Îë¿Ø¶â¿ëÙÄÀ.$À÷À&BfÀAlnÀ\G¬À|7ùÀ"À øÀ²ëbÀÆ_»ÀÚRðÀî¢^ÁV-Á úÁå~Á$Õ…Á0×|Á=2¶ÁIæßÁV£®Ác¨ ÁpüûÁ~f‘Á…ó0ÁŒÒÁ“ÍÀÁšÓîÁªÐãÁ£»dÁœ± Á•¿'ÁŽäxÁˆ ÅÁÀ8ÀQ]PÀi£À‚›½À‘›åÀ¡%À²A?ÀñRÀÖ»ŠÀê¸ÀþvÁ ï˜ÁDÁ HßÁ+æÁ7ÖÁCñ ÁPUuÁ]ÀÁiÙeÁvÞ…Á‚ØÁˆÊFÁƒþÁ–[äÁO¾Á­ Á¦™ÁŸ¶JÁ˜×øÁ’ Á‹D«Á„¡”Á|ÁnéÁb+³ÁU©ÑÁI<Á=Á18Á%·óÁe5ÁYWÁøFÀõsšÀâ&çÀÏ”ÏÀ¾9À®JÀžž×À~ÀƒºðÀpðÀ]¡ÀNB€ÀA¦ÀÀ8Z×À1‡-À,èÀ+àeÀ+RØÀ,ÁÀ0¨¸À:µ„ÀFªDÀX/ÀkÀ4ÎÀí[ÀœhÀ«¾À¼?*ÀͳÙÀà¤2ÀôIìÁ!ÂÁ³Á¾ Á$½ÈÁ0‡Á<{ÁHE=ÁTsÄÁ`úzÁm³„Áz›ºÁƒâUÁŠ—|Á‘P6Á˜÷Ážô’Á¯=¦Á¨DˆÁ¡^ ÁšÚÁ“ÐÅÁ9Á†xìÁðtÁs·ÁfPŠÁYåñÁM¥„ÁAŠÏÁ5úñÁ*¡PÁwâÁÄžÁ cåÁºÀº–kÀ«žýÀžÀ‘‚À†]„Ày%µÀiâYÀ^2ÀTÀ€ÀNZfÀJ!MÀHÀFÕÓÀH{øÀMAÀUÝÀbø\ÀsküÀƒ›§ÀŽMÀšžÀ¨I˜À·ÌÃÀÇ.À×Ñ7ÀëÉÀÿÁ ¢ÁÁöáÁ)éqÁ5ÍÁ@æØÁLæ ÁXåEÁe$îÁqÔÞÁ~Ý×Á…ü›ÁŒ•Á“J?Áš /Á ä†Á°ùÁª hÁ£5ªÁœwæÁ•½~Á#ÁˆzÁ‚!úÁwp›ÁjÜHÁ^§¡ÁR ÁFÄÁ;#-Á/ÚŸÁ$ùàÁdºÁ ÁFÀùáÉÀèXnÀ×ÉÜÀÇëPÀ¹„¦À«ëÀŸ§ÁÀ•·À‹–“À„,À{æiÀr×mÀl¯÷Àg›cÀfHeÀeßTÀfï#Àj›×ÀttÀ€‘ÑÀˆtÝÀ’_·À9"À©¨?À¶ˆOÀÅQPÀÔ[¢Àäe¯ÀöÔBÁ>EÁnLÁöàÁ$‹7Á/ŽÁ:‰ÁFÁRÁ^5Áj4CÁv­†Á¸JÁˆ,vÁޝ¹Á•HöÁœ‘Á¢Ú’Á²ð¼Á¬#ÄÁ¥`YÁž§\Á—÷™Á‘hvÁŠéÚÁ„~Á|gÁpuÁc­µÁWðÁL?gÁ@ÊwÁ5·`Á*êÉÁ €>ÁkêÁ ÷¸Á1ÀõéÒÀåºèÀÖÉÀÈkKÀ»0£À¯1¡À¤À›ÐÀ“ï)ÀŽ6íÀ‰¥|À†WÀ„‹­Àƒ¯ÀƒTûÀƒÌÒÀ…ö—ÀŠ\ÀšÑÀ˜D À¡õÓÀ¬¶ À¹ÞÀÅͼÀÓœ1ÀâóÀò1jÁª¨Á |aÁÊWÁ 8qÁ*ØMÁ5žNÁ@¥oÁL%ÁW‘TÁcWSÁoÀÁ|§Á„ZÁгÈÁ‘ºÁ—1Áž1ÿÁ¤òàÁµ Á®Z­Á§—JÁ ãÕÁšMüÁ“ÎOÁ]9Á‡ oÁ€ÚþÁu`žÁiKŠÁ]–MÁQúvÁF¤ Á;îÁ1eÁ&öÁDiÁæ+Á Ð4ÁuGÀôâœÀæd4ÀØËÀË •À¿¶HÀµ¼À¬€À¤õûÀŸt=ÀšÚÀ—Ï:À•ÁIÀ”Ê%À”ÚQÀ•:9À—UVÀ›•ËÀ¡ÆÀ©DwÀ²TgÀ½ZÀÉ<üÀÖLÀãugÀñUÁ©ŒÁí ÁGåÁp!Á&ÅFÁ1jWÁ<$DÁFãWÁRÚÁ]«wÁiFBÁu%}Á€»œÁ‡\Áq‚Á“ЩÁš9*Á ¾âÁ§d³Á·mÿÁ°ž4Á©äÁ£GpÁœËâÁ–pmÁ6Á‰ÔËÁƒ§ºÁ{:ƒÁofÈÁc¦—ÁX/äÁMHÁB¿øÁ8?àÁ-òWÁ$eGÁ6MÁ|¥Á 6½Á‘IÀö–¨ÀèåÀÛí ÀÐеÀƧ›À¾=iÀ¶ÓÀ±N|À¬äŽÀ©ÍpÀ§Û­À¦èÇÀ§À§ãEÀªh%À­ÐõÀ³ý†À»-³ÀÃNÍÀ΋GÀÚkÀç}€ÀôàñÁnÈÁ :ÁvÁ~Á#lýÁ-»±Á8{ÍÁC3AÁMéSÁXÛ¢ÁdCÁoçÁ{™›ÁƒÔþÁ‰ÿÑÁFÁ–£;ÁXÁ£–uÁª!Á¹àûÁ³%Á¬„8Á¦QÁŸŸ‹Á™DˆÁ’ì ÁŒ«hÁ†™ˆÁ€°ºÁu˜ÁÁiù5Á^ádÁTOàÁIÑXÁ?VáÁ5WØÁ,óÁ#JÁv«ÁRÁ ð™Á¡åÀú8\Àí¾oÀâ¦ÀØî½ÀÐW±ÀÉ¿…ÀÃÊèÀ¿“ŽÀ¼œÀºÀÀ¹ÅøÀºEÍÀ»3ëÀ½ñÀÁYóÀÆûZÀÍÒ½ÀÖÕÙÀá ºÀìÀ)Àù-áÁ]×Á ›=ÁÝÁ:Á"”ÙÁ+tjÁ5NœÁ?¼ ÁJT^ÁU$iÁ`ËÁkEÂÁv¶?ÁÁ‡¢Á0_Á“V Á™´ÁŸñ¿Á¦uäÁ­Á¼• ÁµûRÁ¯v]Á©Á¢£öÁœ@ÎÁ•õÿÁÖ˜Á‰å+Á„´Á|hÜÁq%îÁf8iÁ[©ÁQHÁG3Á=u^Á4 ìÁ+B=Á#oÁ/Á»ÌÁ ½Á$ÀÿÓÛÀõŒQÀëºiÀã¾÷ÀÜîÀׂJÀÓ)nÀÐ…ŽÀΦ!Àͪ™ÀÍú£ÀÏT<ÀѾýÀÕp#ÀÛ(Àá‰ÂÀêZÀô«ÀÿÅÍÁ ‹Á ¬YÁ×ÚÁZÁ#<®Á+ DÁ4|öÁ=ÐqÁGákÁRuÁ\ÛÁg…¬Ár~‘Á}ÞÁ„¨øÁŠv_ÁxºÁ–£KÁœÓ;Á£½Á©{¬Á¯úŠÁ¿ˆuÁ¹¿Á²ƒšÁ¬0Á¥´PÁŸmSÁ™MÁ“FSÁNMÁ‡|*ÁÝ Áx›Ám¹QÁcTÁXüvÁO ŸÁEÊÁ<¢•Á4ûÁ+ã Á$,Á÷ ÁݱÁbÁ ›ÁEÀÿI˜À÷˜Àð¨ÝÀë¨âÀç8*ÀäÚ Àã+±Àâ#ÁÀâ­ÐÀäfÀækCÀêAñÀï›/Àö#&Àþ^Á WÁ ˆNÁ¦ŽÁ(IÁGÁ$ºÁ,‘qÁ4Ã]Á=»&ÁFȲÁP^4ÁZ…¶ÁdÌÈÁoh…ÁzL…Á‚»Áˆh¹ÁŽ(`Á”èÁšÂÁ IlÁ¦|TÁ¬¿äÁ³&|Á•XÁ¼5ÁµöÁ¯)àÁ¨å¬Á¢Ç…ÁœÁ¼Á–Ã!ÁájÁ‹5ÐÁ…±Á€7 Áu¿iÁk[ÿÁaPžÁWËÜÁNmeÁEWÜÁ=TÁ5 æÁ-…IÁ&[eÁVÈÁ2þÁ\ÀÁB±Á ¹ãÁ áÁ¬úÁA™ÀüxÀú!vÀø¤RÀ÷·UÀø ÀùGËÀû‚ºÀÿuîÁ/³Á¡nÁ ¡6ÁLÁ#ÁŽˆÁùÁ&ËÁ.VíÁ6eÁ>G#ÁFà¬ÁOú½ÁY<ßÁcOÁm2»Áw¥}ÁÚÁ†˜ðÁŒ?Á‘ëLÁ—ÀÁÃÈÁ£ß+Á©û¨Á°'\Á¶kãÁÅ´øÁ¿.÷Á¸Ä…Á²zØÁ¬U†Á¦W%Á jCÁš‡ Á”À!ÁáÁ‰¡ÝÁ„B¯Á}Ù¼Ás°JÁj eÁ`´>ÁWX»ÁN•’ÁF‹çÁ>¬0Á7;[Á/Ú4Á);ªÁ#<›ÁŒkÁÂ6ÁHÝÁœºÁ XµÁ îªÁ RÁâ`Á1ÿÁá§ÁµÁŸºÁܵÁ œ:Á 3JÁ`ÅÁR…ÁÊ3ÁþªÁ#¶Á*TÁ0ÁeÁ8”Á?ÂàÁGí[ÁP=ÁY0cÁbZÉÁkø¹ÁuèžÁ€ Á…RêÁŠ©Á:TÁ•ë‰Á›¢qÁ¡‚ßÁ§ŒÿÁ­¥Á³½[Á¹ãÁÈú8ÁÂŽ>Á¼A:Á¶cÁ°QÁª,ÙÁ¤L<Ážm%Á˜©-Á“Á¼¾Áˆr%ÁƒA1Á|¬ÜÁsWÁi¶Á`×çÁXbµÁP-ÁH\ ÁA¸Á9úKÁ3™•Á-q9Á(ÌÁ#JÞÁ,NÁ`ÁgÛÁêÒÁ ÁýkÁS«Á"àÁ4ÔÁÝ¢ÁSÁļÁ{žÁMzÁ#(Á#¬¥Á(£&Á.%¥Á4+¶Á:ï’ÁAõQÁI¯!ÁQË”ÁZÝÁbËÓÁkç\ÁuP¸ÁâÁ„‹[Á‰½Á ƒÁ”rãÁšŒÁŸ¿²Á¥€ÄÁ«mOÁ±jÌÁ·xüÁ½™PÁÌñÁÆ1ŒÁÀÁ¹ñõÁ³÷Á®1Á¨3UÁ¢hÁœÇÁ—\ Á’*ÁŒèâÁ‡Í‰Á‚îkÁ|\ìÁs>ÊÁjšCÁb5ˆÁYíÁRP@ÁKJGÁDw"Á>#oÁ82Á3jÁ.U¬Á*;Á&†pÁ#–bÁ!2¢ÁSÿÁYYÁÃÁ†‘ÁÂÇÁD$Áq Á!R4Á#Ô Á&ÝÉÁ*gÁ.ÑëÁ3ÕÁ9CÁ>¾@ÁDíÁKþ½ÁSÂèÁ[ÍÃÁcíWÁl¡3Áu{2Á~Ð\Á„6LÁ‰!MÁŽI Á“‚RÁ˜ÍÄÁžNÅÁ£ïHÁ©–fÁ¯e9ÁµZÇÁ»WÁÁbÁÐ<]ÁÊ|ÁÃéèÁ½Ø«Á·ÝûÁ²GÁ¬LsÁ¦©òÁ¡'Á›Ò£Á–GÁ‘lÁŒaùÁ‡ ÁƒjÁ} eÁtgAÁl4sÁd8Á\èQÁUÍÁO%ÝÁHÁ“ÁCAdÁ>V^Á9˜9Á5§$Á2`Á/& Á,ØWÁ+æÁ)ýÀÁ)d£Á)5ÂÁ)WjÁ)þÚÁ+8ÝÁ-¹Á/y[Á2’ïÁ5ÿÁ:ûÁ>ó®ÁDCÁI·‚ÁO ÁVIÁ]øˆÁf>‰Án6ÃÁv¤ŸÁqðÁ„;ÍÁ‰¯ÁÙIÁ’à Á˜ÔÁTªÁ¢¯Á¨>xÁ­Þ«Á³‹•Á¹bìÁ¿^ØÁÅaªÁÔ×ÁÍõGÁÇÑåÁÁÎÁ»ðÁ¶;–Á° =Á«Á¥–2Á Y8Á›0ëÁ–BÁ‘3 ÁŒ“TÁˆ þÁƒ‘ÍÁ~³ÁvÌÁoêÁgÀ3Á`ɽÁZ/ÁSóÁN°~ÁI¯üÁE *ÁAR{Á=´Á:éèÁ8ŽøÁ7Á5î>Á5R½Á510Á5OìÁ5Ø«Á7@£Á9–Á;ìÁ>SWÁAèQÁEåCÁJ•ÏÁOp­ÁU@ÁZÔäÁa:•Áh‚Áp‘bÁx¿gÁ€…]Á„êüÁ‰V<ÁýãÁ’ÑpÁ—µ¥ÁœÊñÁ¢Á§NÁ¬¹þÁ²OíÁ·ðÎÁ½§·ÁÃ…ƒÁÉ…zÁØ »ÁÑêÁÁËâÄÁÅþƒÁÀAFÁº¢±ÁµùÁ¯…[Áª7}Á¥ÆÁŸù§Ášü÷Á–-Á‘”ØÁ(ÁˆÏpÁ„ºÁ€ÕÂÁy÷áÁr›­ÁkñÁe‡ÒÁ_VÁZkZÁUo,ÁQèÁMSÁI¿DÁGŸÁD² ÁC8,ÁB¼ÁA‹gÁAfÁAœÁBäÁCsƒÁEÁG£`ÁJ„oÁNUÁQ÷ÁV1Á[fÁ`Ã*Áf‰·Álº]Ás±ÆÁ{gÈÁ§êÁ…¾cÁŠ2ÁŽŠÅÁ“>Á—×fÁœ«¥Á¡¬/Á¦¼¦Á«ú~Á±[´Á¶Ì–Á¼f¶Á»ÁÇÙ‹ÁÍ·ŽÁÜÁÖÁÐ.ÁÊhéÁÄŰÁ¿'°Á¹œöÁ´@3Á¯ÊÁ©èçÁ¤èDÁŸôÎÁ›<Á–ÇŸÁ’i ÁŽ -ÁŠ&Á†KWÁ‚yyÁ}×Áw`ÁpýæÁkFÈÁf=ÛÁaJ‰Á]ÞÁYwÁVþÁSx ÁQ(ÖÁO¼³ÁNzÁMîÞÁM¶ÁN »ÁNÐùÁPcÁQ³úÁTrÁW 7ÁZ8‘Á^ úÁbž5ÁgvçÁl•RÁrJpÁxtÁ²Áƒ>øÁ‡)/Á‹Á\jÁ“ÉÁ˜C˜ÁœöÎÁ¡³5Á¦™ªÁ««^Á°ÊQÁ¶Á»n£ÁÀè¬ÁÆŽ’ÁÌKóÁÒ %Áà\äÁÚlWÁÔœYÁÎðPÁÉVÁÃÎíÁ¾d?Á¹ Á³â(Á®ß3Á©ì#Á¥'Á ‡)Áœ§Á—ºëÁ“•ÕÁ©GÁ‹ÐÊÁˆ-»Á„ǬÁÚÁ|ßpÁwj+ÁrSÉÁmoƒÁiptÁe½ÁbnÝÁ_æüÁ]ª°Á\\ÊÁ[CZÁZ»ÁZv*ÁZÐ2Á[ŒoÁ\ŨÁ^¡ÓÁ`ÝFÁc‘uÁfÁ,Ája’ÁnëôÁsº…Áx¶}Á~*cÁ‚!Á…L‰Áˆ×ÐÁŒº¹Á¸Á”ÑOÁ™.sÁ˜5Á¢,ÆÁ¦êÁ«°ÑÁ°­ÁµÎ‘Áºü“ÁÀF,ÁÅŸÁË#êÁÐÑhÁÖ‘Áä­>ÁÞÓuÁÙ‹ÁÓ‰VÁÎaÁÈžÁÃ;êÁ½ÿøÁ¸ívÁ´?Á¯!‘ÁªsÁ¥ñ)Á¡Š~ÁCgÁ™<âÁ•G­Á‘{Á޽Áо"Á‡‡¢Á„‘ÁÖ1Á~Ÿ¤ÁyýÁvwÁr` Áo<‹ÁlªÁj€Ái.3Áh.¦Ág˜mÁgyFÁgß8ÁhŒ Ái¶YÁk—žÁmÈ4ÁpGÁs‰¤Áw$£Á{fjÁ€öÁ‚’ÒÁ…9mÁˆ,ÀÁ‹;VÁŽ åÁ’bOÁ–iIÁš|ƒÁž´šÁ£ÕÁ§‘õÁ¬:Á°ø§ÁµÕõÁºÞAÁÀðÁÅ=ÁʉžÁÏî#ÁÕ{ÁÛ,£ÁépÁã]—ÁÝÄ”ÁØ<ìÁÒ½”ÁÍeKÁÈ3ÁÃßÁ¾ZÁ¹5’Á´}*Á¯Ù†Á«fºÁ§!ÛÁ¢ÿðÁžûEÁ›AÁ—~šÁ”äÁ·™Á–>ÁЏŸÁ‡ûÁ…•ÁƒPãÁhÇÁ;bÁ|PîÁyÀ}Áw¯íÁvDvÁu=NÁtÇÁtšÉÁt÷;ÁuÍZÁvûÖÁx©!ÁzÆCÁ}\×Á€C~Á‚ÅÁ„•Á†O%ÁˆßªÁ‹­ÁŽgqÁ‘\åÁ”ž™Á˜:2Áœ&^Á 7Á¤^Á¨žTÁ­ Á±¢{Á¶J5Á»RÁÀÁÅ£ÁÊ8~ÁϲÁÔÛ_ÁÚIkÁßÞâmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/Tests/test.py0000644000175000017500000001525110653444130025115 0ustar debiandebian## Automatically adapted for numpy.oldnumeric Jul 30, 2007 by from os import path import numpy.oldnumeric as Numeric from struct import unpack file = "head65.rawiv" mesher = None display = 0 def readfile(filename): myfile = open(filename, 'rb') #the header header=myfile.read(68) # unpack header following rawiv format,big endian h = unpack('>6f5I6f',header) width=int(h[8]) height=int(h[9]) depth =int(h[10]) nverts = int(h[6]) ncells = int(h[7]) origin = h[11:14] step = h[14:17] size = width*height*depth print "header: ", h print "nverts: ", nverts, "ncells: ", ncells # load the data #l = myfile.read(width*height*depth) l = myfile.read() # read the rest of the file myfile.close() nbytes = len(l) elsize = nbytes/size if elsize == 1: mode = 1 elif elsize == 4: mode = 9 else: print "Error: in ReadRawiv - unsupported data type, size= %d"%elsize return None size = 4 unpackType = 'f' arraytype = Numeric.Float32 frm = ">%i%s"%(width*height*depth, unpackType) data = Numeric.reshape(Numeric.array(unpack(frm, l), arraytype), (width,height,depth)) return [data, width,height,depth, origin, step] def output(mesher, meshtype): from UTpackages.UTmesh import lbiemesher nverts = mesher.getNumVerts() nfaces = mesher.getNumFaces() print "in output: nverts: ", nverts, " nfaces: ", nfaces vertarr = Numeric.zeros((nverts, 3), "f") if meshtype == lbiemesher.SINGLE or meshtype == lbiemesher.DOUBLE : facearr = Numeric.zeros((nfaces, 3), "i") mesher.outTriangle(vertarr, facearr) elif meshtype == lbiemesher.TETRA or meshtype == lbiemesher.TETRA2: facearr = Numeric.zeros((nfaces, 4), "i") mesher.outTetra(vertarr, facearr ) elif meshtype == lbiemesher.HEXA: facearr = Numeric.zeros((nfaces, 8), "i") mesher.outHexa(vertarr, facearr ) elif meshtype == lbiemesher.T_4_H : facearr = Numeric.zeros((nfaces, 4), "i") mesher.outQuad(vertarr, facearr ) return vertarr, facearr def setUpSuite(): from UTpackages.UTmesh import lbiemesher global mesher if not mesher: mesher = lbiemesher.LBIE_Mesher() data, dx, dy, dz, origin, step = readfile(file) nverts = dx * dy * dz ncells = (dx-1) * (dy-1) * (dz-1) print "in setUpSuite: origin:", origin, "stepSize:", step mesher.inputData(data.ravel(), (dx, dy, dz), nverts, ncells, origin, step) def test_01_SingleMesh(): from UTpackages.UTmesh import lbiemesher meshtype = lbiemesher.SINGLE global mesher mesher.setMesh(meshtype) mesher.isovalueChange(0.5) mesher.errorChange(0.2) print "single mesh : isoval = 0.5, error tolerance=0.2 " vertarr, facearr = output(mesher, meshtype) if display: from DejaVu import Viewer from DejaVu.IndexedPolygons import IndexedPolygons vi = Viewer() obj = IndexedPolygons("pol", vertices = vertarr, faces = facearr) vi.AddObject(obj) vi.NormalizeCurrentObject() vi.stopAutoRedraw() vi.OneRedraw() def test_02_HexaMesh(): from UTpackages.UTmesh import lbiemesher meshtype = lbiemesher.HEXA mesher.setMesh(meshtype) mesher.isovalueChange(0.5) mesher.errorChange(0.2) print "Hexa mesh : isoval = 0.5, error tolerance=0.2 " vertarr, facearr = output(mesher, meshtype) if display: from DejaVu import Viewer from DejaVu.IndexedPolygons import IndexedPolygons vi = Viewer() obj = IndexedPolygons("pol", vertices = vertarr, faces = facearr) vi.AddObject(obj) vi.NormalizeCurrentObject() vi.stopAutoRedraw() vi.OneRedraw() def test_03_TetraMesh(): from UTpackages.UTmesh import lbiemesher meshtype = lbiemesher.TETRA mesher.setMesh(meshtype) mesher.isovalueChange(0.5) mesher.errorChange(0.2) print "Tetra mesh : isoval = 0.5, error tolerance=0.2 " vertarr, facearr = output(mesher, meshtype) if display: from DejaVu import Viewer from DejaVu.IndexedPolygons import IndexedPolygons vi = Viewer() obj = IndexedPolygons("pol", vertices = vertarr, faces = facearr) vi.AddObject(obj) vi.NormalizeCurrentObject() vi.stopAutoRedraw() vi.OneRedraw() def test_04_T_4_HMesh(): from UTpackages.UTmesh import lbiemesher meshtype = lbiemesher.T_4_H mesher.setMesh(meshtype) mesher.isovalueChange(0.5) mesher.errorChange(0.2) print "T_4_H mesh : isoval = 0.5, error tolerance=0.2 " vertarr, facearr = output(mesher, meshtype) if display: from DejaVu import Viewer from DejaVu.IndexedPolygons import IndexedPolygons vi = Viewer() obj = IndexedPolygons("pol", vertices = vertarr, faces = facearr) vi.AddObject(obj) vi.NormalizeCurrentObject() vi.stopAutoRedraw() vi.OneRedraw() def test_05_DoubleMesh(): from UTpackages.UTmesh import lbiemesher meshtype = lbiemesher.DOUBLE mesher.setMesh(meshtype) mesher.isovalueChange(0.5) mesher.isovalueChange_in(-0.1) mesher.errorChange(0.2) mesher.errorChange_in(-0.3) print "double mesh : isoval = 0.5, isoval_in = -0.1, error tolerance = 0.2, error_in = -0.3" vertarr, facearr = output(mesher, meshtype) if display: from DejaVu import Viewer from DejaVu.IndexedPolygons import IndexedPolygons vi = Viewer() obj = IndexedPolygons("pol", vertices = vertarr, faces = facearr) vi.AddObject(obj) vi.NormalizeCurrentObject() vi.stopAutoRedraw() vi.OneRedraw() def test_06_Tetra2Mesh(): from UTpackages.UTmesh import lbiemesher meshtype = lbiemesher.TETRA2 mesher.setMesh(meshtype) mesher.isovalueChange(0.5) mesher.isovalueChange_in(-0.1) mesher.errorChange(0.2) mesher.errorChange_in(-0.3) print "tetra2 mesh : isoval = 0.5, isoval_in = -0.1, error tolerance= 0.2, error_in = -0.3" vertarr, facearr = output(mesher, meshtype) if display: from DejaVu import Viewer from DejaVu.IndexedPolygons import IndexedPolygons vi = Viewer() obj = IndexedPolygons("pol", vertices = vertarr, faces = facearr) vi.AddObject(obj) vi.NormalizeCurrentObject() vi.stopAutoRedraw() vi.OneRedraw() mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/UTmesh/__init__.py0000644000175000017500000000001510150464520024560 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/README0000644000175000017500000000271110334442433022132 0ustar debiandebianThis module builds a python extension of LBIE_Mesher library (Level Set Boundary Interior and Exterior Mesher) developed at University of Texas (www.ices.utexas.edu/ccv/software). This is a meshing software that computes adaptive and quality triangular, quadrilateral, tetrahedral and hexahedral meshes from volumetric data. This distribution contains source code of the library (see .src/Mesh-license.txt). Distutils are used to wrap the library with SWIG (version 1.3.20 or higher) and build the python extension (_lbiemesher.so). To build and install the extension: python2.4 setup.py install This will: - compile the source code and place the object files into ./build/temp./src; - generate a python shadow class module lbiemesher.py in ./build/lib./UTpackages/UTmesh - build _lbiemesher.so in ./build/lib./UTpackages/UTmesh; - copy UTmesh package from ./build/lib.UTpackages to sys.exec_prefix/lib/python2.4/site-packages/UTpackages; The install command can be called with the following options: --install-platlib=INSTALL_DIR installs the package in specified INSTALL_DIR --no-compile do not compile .py to .pyc Example: python2.4 setup.py install --install-platlib=/home/myname/myinstalldir To build the extension only: python2.4 setup.py build To build source distribution: python2.4 setup.py sdist To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmeshDIST/MANIFEST.in0000755000175000017500000000040010334442433023004 0ustar debiandebianinclude MANIFEST.in include src/*.h include src/*.cpp include src/Mesh-license.txt include UTmesh/*.i include UTmesh/Tests/head65.rawiv exclude UTmesh/lbiemesher.py include CVS/* include UTmesh/CVS/* include UTmesh/Tests/CVS/* include src/CVS/* mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/0000755000175000017500000000000012146213617023355 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/setup.cfg0000644000175000017500000000003210321054404025157 0ustar debiandebian[build_ext] swig_cpp = 1 mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/0000755000175000017500000000000012146213617024144 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Readme.htm0000644000175000017500000002143110321054404026042 0ustar debiandebian MolDerivatives Library

    MolDerivatives Library

    part of TexMol, CVC, The University of Texas, Austin

    Dependency: Also uses the UsefulMath Library.


    Usage:

    Main object:

        SumOfGaussiansCurvature

    Functions:

    SumOfGaussiansCurvatureint numberOfGaussians, double* gaussianCenters, int numberOfGridDivisions, double maxFunctionError, double blobbiness,
                                                int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector)

        Parameters:

    • numberOfGaussians:      Input the number of Gaussians in the molecule
    • gaussianCenters:            A double array containing the description of the position of the atoms and its radius as: [x1,y1,z1,r1,  x2,y2,z2,r2,  x3,y3,z3,r3 ...... xn,yn,zn,rn], where
                                              n is equal to numberOfGaussians
    • numberOfGridDivisions: The number of divisions in the mesh in which the atoms are embedded to get a space partitioning. This parameter should depend on the memory
                                              available, but generally, just set it to 10. (Higher = more memory, faster)
    • maxFunctionError:        Since the Gaussian is theoretically of infinite extent, we need to chop it somewhere. Use this parameter for controlling the accuracy. For example, set it to
                                             0.01 or 0.001
    • blobbiness:                      Rate of decay for the Gaussians. Say -2.3 to -0.1
    • numberOfPoints:            Number of output points where derivatives are required
    • points:                             The set of output positions, (note these are floats) in the form [x1,y1,z1,  x2,y2,z2,  x3,y3,z3  ... xm,ym,zm], m=numberOfPoints
    • HandK:                           Array of size numberOfPoints*2
    • normals:                          Array of size numberOfPoints*3
    • k1Vector, k2Vector:       Arrays of size numberOfPoints*3

    bool initialize( )

    bool getCurvatures( )

        Call initialize( ) before calling this function. If this function returns true, then the arrays HandK, normals, k1Vector, k2Vector will be filled with the
        [m1,g1,  m2,g2, .... mm,gm], [nx1,ny1,nz1,  nx2,ny2,nz2,  nxm,nym,nzm], [k1x1,k1y1,k1z1, k1x2,k1y2,k1z2,  k1xm,k1ym,k1zm], [k2x1,k2y1,k2z1, k2x2,k2y2,k2z2,  k2xm,k2ym,k2zm]

    Important: if the surface is flat, we return [0,0,0],[0,0,0] for the 2 curvature vectors. You can create any 2 vectors perpendicular to the normal and use them.

    Miscellaneous functions:

    bool write(const char* curvfilename)

        Parameters:

    • curvfilename: Name of file which will be created and the mean, gaussian, normals and curvature vectors will be written to.

    bool read( const char* filename, int* numberOfPoints, double** HandK, double** normals, double** k1Vector, double** k2Vector);

        Parameters:

    • filename:                                                Name of curvature file to read in
    • numberOfPoints:                                   The number of points described in the file is returned
    • HandK, normals, k1Vector, k2Vector: These arrays will be allocated and filled if the read is successful. If any dataset was not present, that pointer will return 0.

     

    Files in library:

    Curvature.cpp
    CurvaturesGridVoxel.cpp
    SumOfGaussiansCurvature.cpp
    Curvature.h
    CurvaturesGridVoxel.h
    SumOfGaussiansCurvature.h

     

    Files in required UsefulMath library :

            UsefulMath::LinearAlgebra.cpp
            UsefulMath::LinearAlgebra.h

           Note: If you have your own eigenvector solver, you can use it in place of this library.

     

    Visualizing curvature and normal vectors:

            The .curv file can be visualized in TexMol. If you create a surface file (type .raw / .rawc / .rawn / .rawnc / .obj ), say a.rawnc and keep the corresponding a.rawnc.curv file in the same directory as the surface file, load up the surface file in TexMol, it will read in the vectors and display them.

     

    Example: For an example showing how to use this, please look at 

             CVC :: TexMol :: Blurmaps :: BlurMapsDataManager :: getCurvatures( )


    - Vinay Siddavanahalli (skvinay@cs.utexas.edu)

    mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/molderivatives-license.txt0000644000175000017500000000615610334444253031371 0ustar debiandebianTERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 1. This software is the copyright of THE UNIVERSITY OF TEXAS AT AUSTIN, 2005. 2. The software is available under multiple licenses. 3. For non commercial educational and non commercial academic use, the software including source code, interface definitions and compile scripts are freely available. Any distribution of code, library or executables which contains any modules from this software should contain, conspicously and appropriately, on each copy, this copyright and license notice and should be freely distributed. 4. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation. 5. For any other purpose, including commercial purposes, please contact The University of Texas at Austin for a different license. 6. Credits: This software has been developed at the Computational and Visualization center under Dr Chandrajit Bajaj, Computational Applied Mathematics Chair in Visualization, Professor of Computer Sciences, Director of Center for Computational Visualization, Department of Computer Sciences & The Institute of Computational Engineering and Sciences , Center for Computational Visualization, 201 East 24th Street, ACES 2.324A, 1 University Station, C0200, Austin, TX 78712-0027. We request that you agree to acknowledge the use of the software that results in any published work, including scientific papers, films and videotapes by citing the references listed below C. Bajaj, V. Siddavanahalli Fast Feature Adaptive Surfaces and Derivatives Computation for Volumetric Particle Data ICES and CS Technical Reports, The University of Texas at Austin, 2005. 7. No warranty 7a. Because the library is licensed free of charge, there is no warranty for the library, to the extent permitted by applicable law. except when otherwise stated in writing the copyright holders and/or other parties provide the library "as is" without warranty of any kind, either expressed or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose. the entire risk as to the quality and performance of the library is with you. should the library prove defective, you assume the cost of all necessary servicing, repair or correction. 7b. In no event unless required by applicable law or agreed to in writing will any copyright holder, or any other party who may modify and/or redistribute the library as permitted above, be liable to you for damages, including any general, special, incidental or consequential damages arising out of the use or inability to use the library (including but not limited to loss of data or data being rendered inaccurate or losses sustained by you or third parties or a failure of the library to operate with any other software), even if such holder or other party has been advised of the possibility of such damages. END OF TERMS AND CONDITIONS mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/0000755000175000017500000000000012146213617026307 5ustar debiandebian././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/CurvaturesGridVoxel.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/CurvaturesGridVoxel.c0000644000175000017500000000773410321054404032443 0ustar debiandebian/*****************************************************************************/ /* */ /* Curvatures: Library used to compute derivatives of Sum of Gaussians */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // CurvaturesGridVoxel.cpp: implementation of the CurvaturesGridVoxel class. // ////////////////////////////////////////////////////////////////////// #include "CurvaturesGridVoxel.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// CurvaturesGridVoxel::CurvaturesGridVoxel() { } CurvaturesGridVoxel::~CurvaturesGridVoxel() { } void CurvaturesGridVoxel::addKernel(Tuple const tuple) { m_Kernels.push_back(tuple); } int CurvaturesGridVoxel::getNumberOfKernels() { return m_Kernels.size(); } Tuple CurvaturesGridVoxel::getKernel(int index) { return m_Kernels.at(index); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/CurvaturesGridVoxel.h0000644000175000017500000000747510321054404032452 0ustar debiandebian/*****************************************************************************/ /* */ /* Curvatures: Library used to compute derivatives of Sum of Gaussians */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // CurvaturesGridVoxel.h: interface for the CurvaturesGridVoxel class. // ////////////////////////////////////////////////////////////////////// #ifndef CCV_CURVATURESGRIDVOXEL_H #define CCV_CURVATURESGRIDVOXEL_H #include "Tuple.h" #include using CCVOpenGLMath::Tuple; class CurvaturesGridVoxel { public: CurvaturesGridVoxel(); virtual ~CurvaturesGridVoxel(); void addKernel(Tuple const tuple); int getNumberOfKernels(); Tuple getKernel(int index); protected: std::vector m_Kernels; }; #endif // CCV_CURVATURESGRIDVOXEL_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/Curvatures.pro0000644000175000017500000000057110321054404031165 0ustar debiandebian# qmake project generated by QMsDev # # General settings TEMPLATE = lib CONFIG += qt warn_off staticlib create_prl TARGET += Curvatures # Input INCLUDEPATH += ../UsefulMath SOURCES = \ Curvature.cpp \ CurvaturesGridVoxel.cpp \ SumOfGaussiansCurvature.cpp HEADERS = \ Curvature.h \ CurvaturesGridVoxel.h \ SumOfGaussiansCurvature.h mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/Curvatures.dsp0000644000175000017500000000644110321054404031155 0ustar debiandebian# Microsoft Developer Studio Project File - Name="Curvatures" - Package Owner=<4> # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=Curvatures - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "Curvatures.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "Curvatures.mak" CFG="Curvatures - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "Curvatures - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "Curvatures - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "Curvatures - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /O2 /I "../UsefulMath" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "Curvatures - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../UsefulMath" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "Curvatures - Win32 Release" # Name "Curvatures - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\Curvature.cpp # End Source File # Begin Source File SOURCE=.\CurvaturesGridVoxel.cpp # End Source File # Begin Source File SOURCE=.\SumOfGaussiansCurvature.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\Curvature.h # End Source File # Begin Source File SOURCE=.\CurvaturesGridVoxel.h # End Source File # Begin Source File SOURCE=.\SumOfGaussiansCurvature.h # End Source File # End Group # Begin Source File SOURCE=.\Curvatures.pro # End Source File # End Target # End Project ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/SumOfGaussiansCurvature.hmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/SumOfGaussiansCurvatu0000644000175000017500000001163210321054404032504 0ustar debiandebian/*****************************************************************************/ /* */ /* Curvatures: Library used to compute derivatives of Sum of Gaussians */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // SumOfGaussiansCurvature.h: interface for the SumOfGaussiansCurvature class. // ////////////////////////////////////////////////////////////////////// #ifndef CCV_SUM_OF_GAUSSIANS_CURVATURE_H #define CCV_SUM_OF_GAUSSIANS_CURVATURE_H #include "Curvature.h" class CurvaturesGridVoxel; class SumOfGaussiansCurvature : public Curvature { public: SumOfGaussiansCurvature( int numberOfGaussians, double* gaussianCenters, int numberOfGridDivisions, double maxFunctionError, double blobbiness, int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector); virtual ~SumOfGaussiansCurvature(); bool initialize(); protected: void getMinMax(); void getIndices( double x, double y, double z, int *gridx, int *gridy, int* gridz ); void populateGrid(double overlapExtent); void createGrid(); inline void evalCurvature( double* phiX, double* phiY, double* phiZ, double* phiXX, double* phiYY, double* phiZZ, double* phiXY, double* phiXZ, double* phiYZ, double x, double y, double z ); inline int getIndex( double x, double y, double z ); inline void evalCurvatureDueToOneAtom( double* phiX, double* phiY, double* phiZ, double* phiXX, double* phiYY, double* phiZZ, double* phiXY, double* phiXZ, double* phiYZ, double xc, double yc, double zc, double rad, double x, double y, double z ); double m_Min[3], m_Max[3]; CurvaturesGridVoxel* m_CurvaturesGridVoxels; int m_NumberOfGaussians; double* m_GaussianCenters; int m_NumberOfGridDivisions; double m_MaxFunctionError; double m_Blobbiness; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/Curvature.cpp0000644000175000017500000003137510321054404030772 0ustar debiandebian/*****************************************************************************/ /* */ /* Curvatures: Library used to compute derivatives of Sum of Gaussians */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Curvature.cpp: implementation of the Curvature class. // ////////////////////////////////////////////////////////////////////// #include #include #include #include #include "Curvature.h" #include "LinearAlgebra.h" ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Curvature::Curvature(int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector ) { m_NumberOfPoints = numberOfPoints; m_Points = points; m_HandK = HandK; m_Normals = normals; m_K1Vector = k1Vector; m_K2Vector = k2Vector; m_Initialized = false; } Curvature::~Curvature() { } bool Curvature::getCurvatures() { if( !m_Initialized ) return false; int i; fprintf( stderr, "Getting curvatures\n"); // for each grid g // for each point p in g // get contribution from each atom in g to p // add contribution to m_HandK at correct index // endfor // endfor for( i=0; i 1e-10 ) { // construct curvature matrix. Find eigenvectors corresponding to k1 and k2. double c11, c12, c13; double c21, c22, c23; double c31, c32, c33; double g3 = g*g*g; double g2 = g*g; c11 = (phiXX*g2 - phiX*(phiX*phiXX + phiY*phiXY + phiZ*phiXZ)) / g3; c12 = (phiXY*g2 - phiX*(phiX*phiXY + phiY*phiYY + phiZ*phiYZ)) / g3; c13 = (phiXZ*g2 - phiX*(phiX*phiXZ + phiY*phiYZ + phiZ*phiZZ)) / g3; c21 = (phiXY*g2 - phiY*(phiX*phiXX + phiY*phiXY + phiZ*phiXZ)) / g3; c22 = (phiYY*g2 - phiY*(phiX*phiXY + phiY*phiYY + phiZ*phiYZ)) / g3; c23 = (phiYZ*g2 - phiY*(phiX*phiXZ + phiY*phiYZ + phiZ*phiZZ)) / g3; c31 = (phiXZ*g2 - phiZ*(phiX*phiXX + phiY*phiXY + phiZ*phiXZ)) / g3; c32 = (phiYZ*g2 - phiZ*(phiX*phiXY + phiY*phiYY + phiZ*phiYZ)) / g3; c33 = (phiZZ*g2 - phiZ*(phiX*phiXZ + phiY*phiYZ + phiZ*phiZZ)) / g3; if( CCVOpenGLMath::LinearAlgebra::solveEigenSystem(c11, c12, c13, c21, c22, c23, c31, c32, c33, tK1Vector, tK2Vector, k1, k2) ) { double d; d = sqrt(tK1Vector[0]*tK1Vector[0] + tK1Vector[1]*tK1Vector[1] + tK1Vector[2]*tK1Vector[2]); tK1Vector[0] /= d; tK1Vector[1] /= d; tK1Vector[2] /= d; d = sqrt(tK2Vector[0]*tK2Vector[0] + tK2Vector[1]*tK2Vector[1] + tK2Vector[2]*tK2Vector[2]); tK2Vector[0] /= d; tK2Vector[1] /= d; tK2Vector[2] /= d; m_K1Vector[i*3+0] = tK1Vector[0]; m_K1Vector[i*3+1] = tK1Vector[1]; m_K1Vector[i*3+2] = tK1Vector[2]; m_K2Vector[i*3+0] = tK2Vector[0]; m_K2Vector[i*3+1] = tK2Vector[1]; m_K2Vector[i*3+2] = tK2Vector[2]; } // check eigenvalue eigenvectors solution { double e1 = (c11-k1)*m_K1Vector[i*3+0] + c12*m_K1Vector[i*3+1] + c13*m_K1Vector[i*3+2]; double e2 = c21*m_K1Vector[i*3+0] + (c22-k1)*m_K1Vector[i*3+1] + c23*m_K1Vector[i*3+2]; double e3 = c31*m_K1Vector[i*3+0] + c32*m_K1Vector[i*3+1] + (c33-k1)*m_K1Vector[i*3+2]; } } if (((i+1) % 20) == 0 || (i+1) == m_NumberOfPoints) { printf("Evaluating functions %2.2f%% done (%012d)\r", 100.0*(i+1)/(float)(m_NumberOfPoints), i+1); } } printf("\n"); return true; } bool Curvature::write(const char* filename) { if( !filename ) return false; if( !m_HandK || !m_Normals || !m_K1Vector || !m_K2Vector || (m_NumberOfPoints < 1) ) return false; FILE* fp = fopen( filename, "w" ); if( !fp ) return false; fprintf( fp, "#\n"); fprintf( fp, "# Curvature file exported from TexMol.\n"); fprintf( fp, "# CVC, The University of Texas at Austin.\n"); fprintf( fp, "#\n"); fprintf( fp, "# Format:\n"); fprintf( fp, "# First see the statement: Number: number of points\n"); fprintf( fp, "# Then, search for one of the following: HandK, Normal, K1Vector, K2Vector\n"); fprintf( fp, "# Any of the above should be followed by the corresponding values with 2, 3, 3, 3 in each line\n"); fprintf( fp, "#\n"); fprintf( fp, "#(All comments start with '#')\n"); fprintf( fp, "#\n"); fprintf(fp, "Number: %d\n", m_NumberOfPoints ); int i; fprintf( fp, "HandK\n"); for( i=0; i 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Curvature.h: interface for the Curvature class. // ////////////////////////////////////////////////////////////////////// #ifndef CCV_CURVATURE_H #define CCV_CURVATURE_H class Curvature { public: Curvature(int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector); virtual ~Curvature(); bool getCurvatures(); bool write(const char* filename); static bool read( const char* filename, int* numberOfPoints, double** HandK, double** normals, double** k1Vector, double** k2Vector); protected: virtual void evalCurvature( double* phiX, double* phiY, double* phiZ, double* phiXX, double* phiYY, double* phiZZ, double* phiXY, double* phiXZ, double* phiYZ, double x, double y, double z ) = 0; static bool read2Values( FILE* fp, int numberOfPoints, double** values ); static bool read3Values( FILE* fp, int numberOfPoints, double** values ); int m_NumberOfPoints; float* m_Points; double* m_HandK; double* m_Normals; double* m_K1Vector; double* m_K2Vector; bool m_Initialized; }; #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/Curvatures.dsw0000644000175000017500000000103710321054404031160 0ustar debiandebianMicrosoft Developer Studio Workspace File, Format Version 6.00 # WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE! ############################################################################### Project: "Curvatures"=.\Curvatures.dsp - Package Owner=<4> Package=<5> {{{ }}} Package=<4> {{{ }}} ############################################################################### Global: Package=<5> {{{ }}} Package=<3> {{{ }}} ############################################################################### ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/SumOfGaussiansCurvature.cppmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/Curvatures/SumOfGaussiansCurvatu0000644000175000017500000002250310330240242032500 0ustar debiandebian/*****************************************************************************/ /* */ /* Curvatures: Library used to compute derivatives of Sum of Gaussians */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // SumOfGaussiansCurvature.cpp: implementation of the SumOfGaussiansCurvature class. // ////////////////////////////////////////////////////////////////////// #include #include #include "SumOfGaussiansCurvature.h" #include "CurvaturesGridVoxel.h" SumOfGaussiansCurvature::SumOfGaussiansCurvature(int numberOfGaussians, double* gaussianCenters, int numberOfGridDivisions, double maxFunctionError, double blobbiness, int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector) : Curvature(numberOfPoints, points, HandK, normals, k1Vector, k2Vector) { m_NumberOfGaussians = numberOfGaussians; m_GaussianCenters = gaussianCenters; m_NumberOfGridDivisions = numberOfGridDivisions; m_MaxFunctionError = maxFunctionError; m_Blobbiness = blobbiness; m_CurvaturesGridVoxels = 0; m_Min[0] = 0; m_Min[1] = 0; m_Min[2] = 0; m_Max[0] = 1; m_Max[1] = 1; m_Max[2] = 1; } SumOfGaussiansCurvature::~SumOfGaussiansCurvature() { if( m_CurvaturesGridVoxels ) { delete []m_CurvaturesGridVoxels; m_CurvaturesGridVoxels = 0; } } void SumOfGaussiansCurvature::getMinMax() { int i; for( i=0; i m_Max[j] ) m_Max[j] = m_Points[3*i+j]; } } } void SumOfGaussiansCurvature::getIndices( double x, double y, double z, int *gridx, int *gridy, int* gridz ) { *gridx = (x-m_Min[0]) / (m_Max[0] - m_Min[0]) * m_NumberOfGridDivisions; if( *gridx < 0 ) *gridx = 0; if( *gridx > m_NumberOfGridDivisions-1 ) *gridx = m_NumberOfGridDivisions-1; *gridy = (y-m_Min[1]) / (m_Max[1] - m_Min[1]) * m_NumberOfGridDivisions; if( *gridy < 0 ) *gridy = 0; if( *gridy > m_NumberOfGridDivisions-1 ) *gridy = m_NumberOfGridDivisions-1; *gridz = (z-m_Min[2]) / (m_Max[2] - m_Min[2]) * m_NumberOfGridDivisions; if( *gridz < 0 ) *gridz = 0; if( *gridz > m_NumberOfGridDivisions-1 ) *gridz = m_NumberOfGridDivisions-1; } void SumOfGaussiansCurvature::populateGrid(double overlapExtent) { unsigned int i; for (i=0; i < m_NumberOfGaussians; i++) { double x = m_GaussianCenters[i*4+0]; double y = m_GaussianCenters[i*4+1]; double z = m_GaussianCenters[i*4+2]; double r = m_GaussianCenters[i*4+3]; int mingridx, mingridy, mingridz; int maxgridx, maxgridy, maxgridz; getIndices( x-overlapExtent, y-overlapExtent, z-overlapExtent, &mingridx, &mingridy, &mingridz ); getIndices( x+overlapExtent, y+overlapExtent, z+overlapExtent, &maxgridx, &maxgridy, &maxgridz ); int j, k, l; for( j=mingridz; j<=maxgridz; j++ ) { for( k=mingridy; k<=maxgridy; k++ ) { for( l=mingridx; l<=maxgridx; l++ ) { int index = j*m_NumberOfGridDivisions*m_NumberOfGridDivisions + k*m_NumberOfGridDivisions + l; Tuple t(x, y, z, r); m_CurvaturesGridVoxels[index].addKernel(t); } } } } } void SumOfGaussiansCurvature::createGrid() { if( m_CurvaturesGridVoxels ) { delete []m_CurvaturesGridVoxels; m_CurvaturesGridVoxels = 0; } int i; for( i=0; i<3; i++ ) { m_Min[i] = 1000000000.0; m_Max[i] = -1000000000.0; } getMinMax(); m_CurvaturesGridVoxels = new CurvaturesGridVoxel[m_NumberOfGridDivisions*m_NumberOfGridDivisions*m_NumberOfGridDivisions]; double maxAtomRadius = 4.0; double overlapExtent = (log(m_MaxFunctionError) + m_Blobbiness) * maxAtomRadius / m_Blobbiness; populateGrid( overlapExtent ); } bool SumOfGaussiansCurvature::initialize() { createGrid(); m_Initialized = true; return true; } inline void SumOfGaussiansCurvature::evalCurvatureDueToOneAtom( double* phiX, double* phiY, double* phiZ, double* phiXX, double* phiYY, double* phiZZ, double* phiXY, double* phiXZ, double* phiYZ, double xc, double yc, double zc, double rad, double x, double y, double z ) { double r = (x-xc)*(x-xc) + (y-yc)*(y-yc) + (z-zc)*(z-zc); //double expval = m_Blobbiness*r/rad - m_Blobbiness; double expval = m_Blobbiness*r/(rad*rad) - m_Blobbiness; double phi = exp(expval); //double f = 2*m_Blobbiness/rad; double f = 2*m_Blobbiness/(rad*rad); //if( phi < 1e-30 ) phi = 0; //if ((fabs(f)>.00001) && phi > 1e-20) if(phi > 1e-20) { *phiX += f*(x-xc)*phi; *phiY += f*(y-yc)*phi; *phiZ += f*(z-zc)*phi; *phiXY += f*f*(x-xc)*(y-yc)*phi; *phiXZ += f*f*(x-xc)*(z-zc)*phi; *phiYZ += f*f*(y-yc)*(z-zc)*phi; *phiXX += f*f*(x-xc)*(x-xc)*phi + f*phi; *phiYY += f*f*(y-yc)*(y-yc)*phi + f*phi; *phiZZ += f*f*(z-zc)*(z-zc)*phi + f*phi; } } inline int SumOfGaussiansCurvature::getIndex( double x, double y, double z ) { int gridx, gridy, gridz; gridx = (x-m_Min[0]) / (m_Max[0] - m_Min[0]) * m_NumberOfGridDivisions; if( gridx < 0 ) gridx = 0; if( gridx > m_NumberOfGridDivisions-1 ) gridx = m_NumberOfGridDivisions-1; gridy = (y-m_Min[1]) / (m_Max[1] - m_Min[1]) * m_NumberOfGridDivisions; if( gridy < 0 ) gridy = 0; if( gridy > m_NumberOfGridDivisions-1 ) gridy = m_NumberOfGridDivisions-1; gridz = (z-m_Min[2]) / (m_Max[2] - m_Min[2]) * m_NumberOfGridDivisions; if( gridz < 0 ) gridz = 0; if( gridz > m_NumberOfGridDivisions-1 ) gridz = m_NumberOfGridDivisions-1; return gridz*m_NumberOfGridDivisions*m_NumberOfGridDivisions + gridy*m_NumberOfGridDivisions + gridx; } inline void SumOfGaussiansCurvature::evalCurvature( double* phiX, double* phiY, double* phiZ, double* phiXX, double* phiYY, double* phiZZ, double* phiXY, double* phiXZ, double* phiYZ, double x, double y, double z ) { int index = getIndex(x, y, z); int numAtoms = m_CurvaturesGridVoxels[index].getNumberOfKernels(); if( numAtoms < 1 ) return; int k; for( k=0; k # Microsoft Developer Studio Generated Build File, Format Version 6.00 # ** DO NOT EDIT ** # TARGTYPE "Win32 (x86) Static Library" 0x0104 CFG=UsefulMath - Win32 Debug !MESSAGE This is not a valid makefile. To build this project using NMAKE, !MESSAGE use the Export Makefile command and run !MESSAGE !MESSAGE NMAKE /f "UsefulMath.mak". !MESSAGE !MESSAGE You can specify a configuration when running NMAKE !MESSAGE by defining the macro CFG on the command line. For example: !MESSAGE !MESSAGE NMAKE /f "UsefulMath.mak" CFG="UsefulMath - Win32 Debug" !MESSAGE !MESSAGE Possible choices for configuration are: !MESSAGE !MESSAGE "UsefulMath - Win32 Release" (based on "Win32 (x86) Static Library") !MESSAGE "UsefulMath - Win32 Debug" (based on "Win32 (x86) Static Library") !MESSAGE # Begin Project # PROP AllowPerConfigDependencies 0 # PROP Scc_ProjName "" # PROP Scc_LocalPath "" CPP=cl.exe RSC=rc.exe !IF "$(CFG)" == "UsefulMath - Win32 Release" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 0 # PROP BASE Output_Dir "Release" # PROP BASE Intermediate_Dir "Release" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 0 # PROP Output_Dir "Release" # PROP Intermediate_Dir "Release" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD CPP /nologo /MD /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c # ADD BASE RSC /l 0x409 /d "NDEBUG" # ADD RSC /l 0x409 /d "NDEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ELSEIF "$(CFG)" == "UsefulMath - Win32 Debug" # PROP BASE Use_MFC 0 # PROP BASE Use_Debug_Libraries 1 # PROP BASE Output_Dir "Debug" # PROP BASE Intermediate_Dir "Debug" # PROP BASE Target_Dir "" # PROP Use_MFC 0 # PROP Use_Debug_Libraries 1 # PROP Output_Dir "Debug" # PROP Intermediate_Dir "Debug" # PROP Target_Dir "" # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c # ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "QT_DLL" /D "QT_THREAD_SUPPORT" /YX /FD /GZ /c # ADD BASE RSC /l 0x409 /d "_DEBUG" # ADD RSC /l 0x409 /d "_DEBUG" BSC32=bscmake.exe # ADD BASE BSC32 /nologo # ADD BSC32 /nologo LIB32=link.exe -lib # ADD BASE LIB32 /nologo # ADD LIB32 /nologo !ENDIF # Begin Target # Name "UsefulMath - Win32 Release" # Name "UsefulMath - Win32 Debug" # Begin Group "Source Files" # PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" # Begin Source File SOURCE=.\AreaVolumes.cpp # End Source File # Begin Source File SOURCE=.\LinearAlgebra.cpp # End Source File # Begin Source File SOURCE=.\Matrix.cpp # End Source File # Begin Source File SOURCE=.\Quaternion.cpp # End Source File # Begin Source File SOURCE=.\Ray.cpp # End Source File # Begin Source File SOURCE=.\TrilinearGrid.cpp # End Source File # Begin Source File SOURCE=.\Tuple.cpp # End Source File # Begin Source File SOURCE=.\Vector.cpp # End Source File # End Group # Begin Group "Header Files" # PROP Default_Filter "h;hpp;hxx;hm;inl" # Begin Source File SOURCE=.\AreaVolumes.h # End Source File # Begin Source File SOURCE=.\LinearAlgebra.h # End Source File # Begin Source File SOURCE=.\Matrix.h # End Source File # Begin Source File SOURCE=.\Quaternion.h # End Source File # Begin Source File SOURCE=.\Ray.h # End Source File # Begin Source File SOURCE=.\TrilinearGrid.h # End Source File # Begin Source File SOURCE=.\Tuple.h # End Source File # Begin Source File SOURCE=.\Vector.h # End Source File # End Group # Begin Source File SOURCE=.\UsefulMath.pro # End Source File # End Target # End Project mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Quaternion.cpp0000644000175000017500000002062410321054404031044 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Quaternion.cpp: implementation of the Quaternion class. // ////////////////////////////////////////////////////////////////////// #include "Quaternion.h" #include "Vector.h" #include "Ray.h" #include "Matrix.h" #include using CCVOpenGLMath::Tuple; using CCVOpenGLMath::Vector; using CCVOpenGLMath::Ray; using CCVOpenGLMath::Quaternion; using CCVOpenGLMath::Matrix; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Quaternion::Quaternion(float w, float x, float y, float z) : Tuple(w,x,y,z) { } Quaternion::Quaternion() : Tuple(1.0, 0.0, 0.0, 0.0) { } Quaternion::Quaternion(const Vector& vec) { p[0] = 0.0f; p[1] = vec[0]; p[2] = vec[1]; p[3] = vec[2]; } Quaternion::~Quaternion() { } Quaternion::Quaternion(const Quaternion& copy): Tuple(copy) { } Quaternion& Quaternion::operator=(const Quaternion& copy) { if (this!=©) { set(copy); } return *this; } Quaternion& Quaternion::set(float w, float x, float y, float z) { Tuple::set(w,x,y,z); return *this; } Quaternion& Quaternion::set(float* array) { Tuple::set(array); return *this; } Quaternion& Quaternion::set(const Quaternion& copy) { Tuple::set(copy); return *this; } Quaternion Quaternion::operator*(const Quaternion& quat) const { return Quaternion( p[0]*quat[0] - p[1]*quat[1] - p[2]*quat[2] - p[3]*quat[3], p[0]*quat[1] + p[1]*quat[0] + p[2]*quat[3] - p[3]*quat[2], p[0]*quat[2] - p[1]*quat[3] + p[2]*quat[0] + p[3]*quat[1], p[0]*quat[3] + p[1]*quat[2] - p[2]*quat[1] + p[3]*quat[0] ); } Quaternion& Quaternion::preMultiply(const Quaternion& quat) { return set(quat*(*this)); } Quaternion& Quaternion::postMultiply(const Quaternion& quat) { return set((*this)*quat); } Quaternion& Quaternion::rotate(float angle, float x, float y, float z) { return preMultiply(rotation(angle, x, y, z)); } Quaternion Quaternion::operator*(float scalar) const { return Quaternion(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]*scalar); } Quaternion& Quaternion::operator*=(float scalar) { return set(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]*scalar); } Quaternion Quaternion::operator/(float scalar) const { return Quaternion(p[0]/scalar, p[1]/scalar, p[2]/scalar, p[3]/scalar); } Quaternion& Quaternion::operator/=(float scalar) { return set(p[0]/scalar, p[1]/scalar, p[2]/scalar, p[3]/scalar); } Quaternion& Quaternion::normalize() { float n = norm(); return (*this)/=n; } Quaternion Quaternion::conjugate() const { return Quaternion(p[0], -p[1], -p[2], -p[3]); } Quaternion Quaternion::inverse() const { return conjugate()/norm(); } float Quaternion::norm() const { return p[0]*p[0]+p[1]*p[1]+p[2]*p[2]+p[3]*p[3]; } Vector Quaternion::applyRotation(const Vector& vec) const { Quaternion result = (*this) * Quaternion(vec) * (conjugate()); return Vector(result[1], result[2], result[3], vec[3]); } Ray Quaternion::applyRotation(const Ray& ray) const { Quaternion origin = (*this) * Quaternion(ray.m_Origin) * (conjugate()); Quaternion dir = (*this) * Quaternion(ray.m_Dir) * (conjugate()); return Ray(Vector(origin[1], origin[2], origin[3], ray.m_Origin[3]), Vector(dir[1], dir[2], dir[3], ray.m_Dir[3])); } Matrix Quaternion::buildMatrix() const { float w = p[0]; float x = p[1]; float y = p[2]; float z = p[3]; return Matrix( 1.0f-2.0f*y*y-2.0f*z*z, 2.0f*x*y-2.0f*w*z, 2.0f*x*z + 2.0f*w*y, 0.0f, 2.0f*x*y + 2.0f*w*z, 1.0f - 2.0f*x*x - 2.0f*z*z, 2.0f*y*z - 2.0f*w*x, 0.0f, 2.0f*x*z - 2.0f*w*y, 2.0f*y*z + 2.0f*w*x, 1.0f - 2.0f*x*x - 2.0f*y*y, 0.0f, 0.0f,0.0f,0.0f,1.0f ); } Quaternion Quaternion::rotation(float angle, float x, float y, float z) { float len = (float)sqrt(x*x+y*y+z*z); if (len!=0.0) { len = (float)(sin(angle/2.0f)/len); return Quaternion((float) cos(angle/2.0f), x*len, y*len, z*len); } else { return Quaternion(); } } Quaternion Quaternion::rotation(float angle, const Vector& axis) { float len = (float)sqrt(axis[0]*axis[0]+axis[1]*axis[1]+axis[2]*axis[2]); if (len!=0.0) { len = (float)(sin(angle/2.0f)/len); return Quaternion((float) cos(angle/2.0f), axis[0]*len, axis[1]*len, axis[2]*len); } else { return Quaternion(); } } Quaternion Quaternion::power( double scalar ) { float Dest[4]; double theta; if (p[0]>=0.9999f) { theta = 0; } else if (p[0]<=-0.9999f) { theta = 2.0*3.1415926535897932384626433832795; } else { theta = acos(p[0]); } double u[3]; double scale = p[1]*p[1]+p[2]*p[2]+p[3]*p[3]; scale = sqrt(scale); if (p[1]==0.0f && p[2]==0.0f && p[3]==0.0f) { u[0] = 0.0; u[1] = 0.0; u[2] = 0.0; } else { u[0] = p[1]/scale; u[1] = p[2]/scale; u[2] = p[3]/scale; } Dest[0] = (float)cos(scalar*theta); Dest[1] = (float)(u[0] * sin(scalar*theta)); Dest[2] = (float)(u[1] * sin(scalar*theta)); Dest[3] = (float)(u[2] * sin(scalar*theta)); return Quaternion( Dest[0], Dest[1], Dest[2], Dest[3] ); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/TrilinearGrid.cpp0000644000175000017500000001346710321054404031465 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Bong-Soo Sohn 2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // TrilinearGrid.cpp: implementation of the TrilinearGrid class. // ////////////////////////////////////////////////////////////////////// #include "TrilinearGrid.h" using CCVOpenGLMath::TrilinearGrid; TrilinearGrid::TrilinearGrid() { } TrilinearGrid::~TrilinearGrid() { } void TrilinearGrid::cell2xyz(int cell_index, int& x, int& y, int& z, unsigned int* gdim) { x = cell_index % (gdim[0]-1); y = (cell_index / (gdim[0]-1)) % (gdim[1]-1); z = cell_index / ( (gdim[0]-1) * (gdim[1]-1) ); } int TrilinearGrid::xyz2cell(int x, int y, int z, unsigned int* gdim) { return x+y*(gdim[0]-1)+z*(gdim[0]-1)*(gdim[1]-1); } void TrilinearGrid::vtx2xyz(int vtx_idx,int& x, int& y, int& z, unsigned int* gdim) { x = vtx_idx % (gdim[0]); y = (vtx_idx / (gdim[0])) % (gdim[1]); z = vtx_idx / ( (gdim[0]) * (gdim[1]) ); } void TrilinearGrid::getCellVertices(int cell_index,int* cellVertexArray,unsigned int* gdim) { int x,y,z; cell2xyz(cell_index,x,y,z,gdim); cellVertexArray[0]=TrilinearGrid::xyz2vtx(x ,y ,z ,gdim); cellVertexArray[1]=TrilinearGrid::xyz2vtx(x+1,y ,z ,gdim); cellVertexArray[2]=TrilinearGrid::xyz2vtx(x ,y+1,z ,gdim); cellVertexArray[3]=TrilinearGrid::xyz2vtx(x+1,y+1,z ,gdim); cellVertexArray[4]=TrilinearGrid::xyz2vtx(x ,y ,z+1,gdim); cellVertexArray[5]=TrilinearGrid::xyz2vtx(x+1,y ,z+1,gdim); cellVertexArray[6]=TrilinearGrid::xyz2vtx(x ,y+1,z+1,gdim); cellVertexArray[7]=TrilinearGrid::xyz2vtx(x+1,y+1,z+1,gdim); } int TrilinearGrid::xyz2vtx(int x, int y, int z, unsigned int* dim) { return x+y*dim[0]+z*dim[0]*dim[1]; } int TrilinearGrid::getNeighbor(int i, int j, int k, int* neighborArray, unsigned int* dim) { int neighborIndex=0; if (i<=0) { neighborArray[neighborIndex++]=xyz2vtx(i+1,j,k,dim); } else if (i>=dim[0]-1) { neighborArray[neighborIndex++]=xyz2vtx(i-1,j,k,dim); } else { neighborArray[neighborIndex++]=xyz2vtx(i-1,j,k,dim); neighborArray[neighborIndex++]=xyz2vtx(i+1,j,k,dim); } if (j<=0) { neighborArray[neighborIndex++]=xyz2vtx(i,j+1,k,dim); } else if (j>=dim[1]-1) { neighborArray[neighborIndex++]=xyz2vtx(i,j-1,k,dim); } else { neighborArray[neighborIndex++]=xyz2vtx(i,j-1,k,dim); neighborArray[neighborIndex++]=xyz2vtx(i,j+1,k,dim); } if (k<=0) { neighborArray[neighborIndex++]=xyz2vtx(i,j,k+1,dim); } else if (k>=dim[2]-1) { neighborArray[neighborIndex++]=xyz2vtx(i,j,k-1,dim); } else { neighborArray[neighborIndex++]=xyz2vtx(i,j,k-1,dim); neighborArray[neighborIndex++]=xyz2vtx(i,j,k+1,dim); } return neighborIndex; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Tuple.cpp0000644000175000017500000001101610321054404030003 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Tuple.cpp: implementation of the Tuple class. // ////////////////////////////////////////////////////////////////////// #include "Tuple.h" using CCVOpenGLMath::Tuple; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Tuple::Tuple(float x, float y, float z, float w) { set(x,y,z,w); } Tuple::Tuple() { set(0.0, 0.0, 0.0, 0.0); } Tuple::~Tuple() { } Tuple::Tuple(const Tuple& copy) { set(copy); } Tuple& Tuple::operator=(const Tuple& copy) { return set(copy); } Tuple& Tuple::set(float x, float y, float z, float w) { p[0] = x; p[1] = y; p[2] = z; p[3] = w; return *this; } Tuple& Tuple::set(float* array) { p[0] = array[0]; p[1] = array[1]; p[2] = array[2]; p[3] = array[3]; return *this; } Tuple& Tuple::set(const Tuple& copy) { if (this!=©) { p[0] = copy.p[0]; p[1] = copy.p[1]; p[2] = copy.p[2]; p[3] = copy.p[3]; } return *this; } float& Tuple::operator[](unsigned int i) { return p[i]; } const float& Tuple::operator[](unsigned int i) const { return p[i]; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Tuple.h0000644000175000017500000001015110321054404027447 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Tuple.h: interface for the Tuple class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_TUPLE_H__5AD4C604_B71A_4924_941A_15A0955C4E4E__INCLUDED_) #define AFX_TUPLE_H__5AD4C604_B71A_4924_941A_15A0955C4E4E__INCLUDED_ namespace CCVOpenGLMath { class Tuple { public: Tuple(float x, float y, float z, float w); Tuple(); virtual ~Tuple(); Tuple(const Tuple& copy); Tuple& operator=(const Tuple& copy); Tuple& set(float x, float y, float z, float w); Tuple& set(float* array); Tuple& set(const Tuple& copy); float& operator[](unsigned int i); const float& operator[](unsigned int i) const; protected: float p[4]; }; }; #endif // !defined(AFX_TUPLE_H__5AD4C604_B71A_4924_941A_15A0955C4E4E__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Quaternion.h0000644000175000017500000001175610321054404030517 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Quaternion.h: interface for the Quaternion class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_QUATERNION_H__4A5485F3_5ADE_437D_A2C9_6D864A63C23B__INCLUDED_) #define AFX_QUATERNION_H__4A5485F3_5ADE_437D_A2C9_6D864A63C23B__INCLUDED_ #include "Tuple.h" namespace CCVOpenGLMath { class Vector; class Matrix; class Ray; class Quaternion : public Tuple { public: Quaternion(); virtual ~Quaternion(); Quaternion(const Quaternion& copy); Quaternion& operator=(const Quaternion& copy); Quaternion(float w, float x, float y, float z); Quaternion& set(float w, float x, float y, float z); Quaternion& set(float* array); Quaternion& set(const Quaternion& copy); Quaternion operator*(const Quaternion& quat) const; Quaternion operator*(float scalar) const; Quaternion& operator*=(float scalar); Quaternion operator/(float scalar) const; Quaternion& operator/=(float scalar); Quaternion& preMultiply(const Quaternion& quat); Quaternion& postMultiply(const Quaternion& quat); Quaternion& rotate(float angle, float x, float y, float z); Quaternion& normalize(); Quaternion conjugate() const; Quaternion inverse() const; float norm() const; Vector applyRotation(const Vector& vec) const; Ray applyRotation(const Ray& ray) const; Matrix buildMatrix() const; Quaternion power(double scalar); static Quaternion rotation(float angle, float x, float y, float z); static Quaternion rotation(float angle, const Vector& axis); protected: explicit Quaternion(const Vector& vec); }; }; #endif // !defined(AFX_QUATERNION_H__4A5485F3_5ADE_437D_A2C9_6D864A63C23B__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/TrilinearGrid.h0000644000175000017500000001212510321054404031120 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Bong-Soo Sohn 2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // TrilinearGrid.h: interface for the TrilinearGrid class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_TRILINEARGRID_H__E1E51C41_6207_4C9F_AC66_FA5385A0E475__INCLUDED_) #define AFX_TRILINEARGRID_H__E1E51C41_6207_4C9F_AC66_FA5385A0E475__INCLUDED_ namespace CCVOpenGLMath { //! Used to go from vertex to grid indices and obtain neighbors. /*! All functions in this class are static members */ class TrilinearGrid { public: /*! There is no need to create these objects as all member functions are static in nature. */ TrilinearGrid(); virtual ~TrilinearGrid(); /*! Given a cell index, we return the indices of the vertex at the first (lowest) corner. The last parameter contains the dimensions. \param cell_index is the index of a cell in a uniform 3d grid \param x, y, z are passed by reference and are returned as the indices of the lowest corner \param gdim is of length 3, containing the dimensions of the grid. */ static void cell2xyz(int cell_index, int& x, int& y, int& z, unsigned int* gdim); static int xyz2cell(int x, int y, int z, unsigned int* gdim); /*! A 1D vertex index is converted to a 3D set of indices \param vtx_idx is the index in 1D of a vertex \param x, y, z are passed by reference and are returned as the 3D indices \param gdim is of length 3, containing the dimensions of the grid. */ static void vtx2xyz(int vtx_idx,int& x, int& y, int& z, unsigned int* gdim); static void getCellVertices(int cell_index,int* cellVertexArray,unsigned int* gdim); static int xyz2vtx(int x, int y, int z, unsigned int* dim); static int getNeighbor(int i, int j, int k, int* neighborArray, unsigned int* dim); }; }; #endif // !defined(AFX_TRILINEARGRID_H__E1E51C41_6207_4C9F_AC66_FA5385A0E475__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/AreaVolumes.cpp0000644000175000017500000000210110321054404031130 0ustar debiandebian// AreaVolumes.cpp: implementation of the AreaVolumes class. // ////////////////////////////////////////////////////////////////////// #include "AreaVolumes.h" #include using CCVOpenGLMath::AreaVolumes; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// AreaVolumes::AreaVolumes() { } AreaVolumes::~AreaVolumes() { } double AreaVolumes::getTriangleArea( double v1x, double v1y, double v1z, double v2x, double v2y, double v2z, double v3x, double v3y, double v3z) { // the area of a triangle with lengths a,b,c is given as // 1/4 sqrt( (a+b+c) (b+c-a) (c+a-b) (a+b-c) ) double a = sqrt((v1x-v2x)*(v1x-v2x) + (v1y-v2y)*(v1y-v2y) + (v1z-v2z)*(v1z-v2z) ); double b = sqrt((v1x-v3x)*(v1x-v3x) + (v1y-v3y)*(v1y-v3y) + (v1z-v3z)*(v1z-v3z) ); double c = sqrt((v3x-v2x)*(v3x-v2x) + (v3y-v2y)*(v3y-v2y) + (v3z-v2z)*(v3z-v2z) ); return 1.0 / 4.0 * sqrt( fabs((a+b+c) * (b+c-a) * (c+a-b) * (a+b-c)) ); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Matrix.h0000644000175000017500000001224510321054404027630 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Matrix.h: interface for the Matrix class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_MATRIX_H__AB7171AD_869D_4D29_A455_5919551F0B67__INCLUDED_) #define AFX_MATRIX_H__AB7171AD_869D_4D29_A455_5919551F0B67__INCLUDED_ namespace CCVOpenGLMath { class Quaternion; class Vector; class Ray; class Matrix { public: Matrix(); Matrix( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ); Matrix(const Quaternion& quat); virtual ~Matrix(); Matrix(const Matrix& copy); Matrix& operator=(const Matrix& copy); Matrix& set ( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ); Matrix& set(const Matrix& copy); Matrix& reset(); inline float get(int row, int column) const; const float* getMatrix() const; Vector operator*(const Vector& vec) const; Ray operator*(const Ray& ray) const; Matrix operator*(const Matrix& mat) const; Matrix& preMultiplication(const Matrix& mat); Matrix& postMultiplication(const Matrix& mat); Matrix inverse() const; Matrix inverseTranspose() const; float determinant() const; static Matrix rotationX(float angle); static Matrix rotationY(float angle); static Matrix rotationZ(float angle); static Matrix translation(float x, float y, float z); static Matrix translation(const Vector& vec); static Matrix scale(float x, float y, float z); protected: float m[16]; }; inline float Matrix::get(int row, int column) const { return m[row + column*4]; } }; #endif // !defined(AFX_MATRIX_H__AB7171AD_869D_4D29_A455_5919551F0B67__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Vector.h0000644000175000017500000001111010321054404027614 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Vector.h: interface for the Vector class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_VECTOR_H__C73C6BDB_2D75_4770_B86A_E3329C07A817__INCLUDED_) #define AFX_VECTOR_H__C73C6BDB_2D75_4770_B86A_E3329C07A817__INCLUDED_ #include "Tuple.h" namespace CCVOpenGLMath { class Vector : public Tuple { public: Vector(float x, float y, float z, float w); Vector(float* array); Vector(); virtual ~Vector(); Vector(const Vector& copy); Vector& operator=(const Vector& copy); Vector& set(float x, float y, float z, float w); Vector& set(float* array); Vector& set(const Vector& copy); Vector cross(const Vector& vec) const; Vector& crossEquals(const Vector& vec); float dot(const Vector& vec) const; Vector operator+(const Vector vec) const; Vector& operator+=(const Vector vec); Vector operator-(const Vector vec) const; Vector& operator-=(const Vector vec); Vector operator*(float scalar) const; Vector& operator*=(float scalar); Vector operator-() const; Vector& normalize(); float norm(); bool isBad(); static Vector badVector(); virtual Vector* clone() const; }; }; #endif // !defined(AFX_VECTOR_H__C73C6BDB_2D75_4770_B86A_E3329C07A817__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Matrix.cpp0000644000175000017500000004006210321054404030161 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Matrix.cpp: implementation of the Matrix class. // ////////////////////////////////////////////////////////////////////// #include "Matrix.h" #include "Vector.h" #include "Ray.h" #include using CCVOpenGLMath::Vector; using CCVOpenGLMath::Ray; //using CCVOpenGLMath::Quaternion; using CCVOpenGLMath::Matrix; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Matrix::Matrix() { set(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix::Matrix( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ) { m[0]=m00; m[1]=m10; m[2]=m20; m[3]=m30; m[4]=m01; m[5]=m11; m[6]=m21; m[7]=m31; m[8]=m02; m[9]=m12; m[10]=m22; m[11]=m32; m[12]=m03; m[13]=m13; m[14]=m23; m[15]=m33; } Matrix::~Matrix() { } Matrix::Matrix(const Matrix& copy) { set(copy); } Matrix& Matrix::operator=(const Matrix& copy) { return set(copy); } Matrix& Matrix::set ( float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20, float m21, float m22, float m23, float m30, float m31, float m32, float m33 ) { m[0]=m00; m[1]=m10; m[2]=m20; m[3]=m30; m[4]=m01; m[5]=m11; m[6]=m21; m[7]=m31; m[8]=m02; m[9]=m12; m[10]=m22; m[11]=m32; m[12]=m03; m[13]=m13; m[14]=m23; m[15]=m33; return *this; } Matrix& Matrix::set(const Matrix& copy) { if (this!=©) { set( copy.m[0], copy.m[4], copy.m[8], copy.m[12], copy.m[1], copy.m[5], copy.m[9], copy.m[13], copy.m[2], copy.m[6], copy.m[10], copy.m[14], copy.m[3], copy.m[7], copy.m[11], copy.m[15] ); } return *this; } Matrix& Matrix::reset() { set( 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0); return *this; } const float* Matrix::getMatrix() const { return m; } Vector Matrix::operator*(const Vector& vec) const { return Vector( m[0]*vec[0]+m[4]*vec[1]+m[8]*vec[2]+m[12]*vec[3], m[1]*vec[0]+m[5]*vec[1]+m[9]*vec[2]+m[13]*vec[3], m[2]*vec[0]+m[6]*vec[1]+m[10]*vec[2]+m[14]*vec[3], m[3]*vec[0]+m[7]*vec[1]+m[11]*vec[2]+m[15]*vec[3] ); } Ray Matrix::operator*(const Ray& ray) const { return Ray((*this)*ray.m_Origin, (*this)*ray.m_Dir); } Matrix Matrix::operator*(const Matrix& mat) const { return Matrix( m[0]*mat.m[0]+m[4]*mat.m[1]+m[8]*mat.m[2]+m[12]*mat.m[3], m[0]*mat.m[4]+m[4]*mat.m[5]+m[8]*mat.m[6]+m[12]*mat.m[7], m[0]*mat.m[8]+m[4]*mat.m[9]+m[8]*mat.m[10]+m[12]*mat.m[11], m[0]*mat.m[12]+m[4]*mat.m[13]+m[8]*mat.m[14]+m[12]*mat.m[15], m[1]*mat.m[0]+m[5]*mat.m[1]+m[9]*mat.m[2]+m[13]*mat.m[3], m[1]*mat.m[4]+m[5]*mat.m[5]+m[9]*mat.m[6]+m[13]*mat.m[7], m[1]*mat.m[8]+m[5]*mat.m[9]+m[9]*mat.m[10]+m[13]*mat.m[11], m[1]*mat.m[12]+m[5]*mat.m[13]+m[9]*mat.m[14]+m[13]*mat.m[15], m[2]*mat.m[0]+m[6]*mat.m[1]+m[10]*mat.m[2]+m[14]*mat.m[3], m[2]*mat.m[4]+m[6]*mat.m[5]+m[10]*mat.m[6]+m[14]*mat.m[7], m[2]*mat.m[8]+m[6]*mat.m[9]+m[10]*mat.m[10]+m[14]*mat.m[11], m[2]*mat.m[12]+m[6]*mat.m[13]+m[10]*mat.m[14]+m[14]*mat.m[15], m[3]*mat.m[0]+m[7]*mat.m[1]+m[11]*mat.m[2]+m[15]*mat.m[3], m[3]*mat.m[4]+m[7]*mat.m[5]+m[11]*mat.m[6]+m[15]*mat.m[7], m[3]*mat.m[8]+m[7]*mat.m[9]+m[11]*mat.m[10]+m[15]*mat.m[11], m[3]*mat.m[12]+m[7]*mat.m[13]+m[11]*mat.m[14]+m[15]*mat.m[15] ); } Matrix& Matrix::preMultiplication(const Matrix& mat) { return set(mat*(*this)); } Matrix& Matrix::postMultiplication(const Matrix& mat) { return set((*this)*mat); } Matrix Matrix::inverse() const { Matrix ret; float det = determinant(); if (det!=0.0) { ret.set( (get(1, 2)*get(2, 3)*get(3, 1) - get(1, 3)*get(2, 2)*get(3, 1) + get(1, 3)*get(2, 1)*get(3, 2) - get(1, 1)*get(2, 3)*get(3, 2) - get(1, 2)*get(2, 1)*get(3, 3) + get(1, 1)*get(2, 2)*get(3, 3))/det, (get(0, 3)*get(2, 2)*get(3, 1) - get(0, 2)*get(2, 3)*get(3, 1) - get(0, 3)*get(2, 1)*get(3, 2) + get(0, 1)*get(2, 3)*get(3, 2) + get(0, 2)*get(2, 1)*get(3, 3) - get(0, 1)*get(2, 2)*get(3, 3))/det, (get(0, 2)*get(1, 3)*get(3, 1) - get(0, 3)*get(1, 2)*get(3, 1) + get(0, 3)*get(1, 1)*get(3, 2) - get(0, 1)*get(1, 3)*get(3, 2) - get(0, 2)*get(1, 1)*get(3, 3) + get(0, 1)*get(1, 2)*get(3, 3))/det, (get(0, 3)*get(1, 2)*get(2, 1) - get(0, 2)*get(1, 3)*get(2, 1) - get(0, 3)*get(1, 1)*get(2, 2) + get(0, 1)*get(1, 3)*get(2, 2) + get(0, 2)*get(1, 1)*get(2, 3) - get(0, 1)*get(1, 2)*get(2, 3))/det, (get(1, 3)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 0)*get(3, 2) + get(1, 0)*get(2, 3)*get(3, 2) + get(1, 2)*get(2, 0)*get(3, 3) - get(1, 0)*get(2, 2)*get(3, 3))/det, (get(0, 2)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 2)*get(3, 0) + get(0, 3)*get(2, 0)*get(3, 2) - get(0, 0)*get(2, 3)*get(3, 2) - get(0, 2)*get(2, 0)*get(3, 3) + get(0, 0)*get(2, 2)*get(3, 3))/det, (get(0, 3)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 0)*get(3, 2) + get(0, 0)*get(1, 3)*get(3, 2) + get(0, 2)*get(1, 0)*get(3, 3) - get(0, 0)*get(1, 2)*get(3, 3))/det, (get(0, 2)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 2)*get(2, 0) + get(0, 3)*get(1, 0)*get(2, 2) - get(0, 0)*get(1, 3)*get(2, 2) - get(0, 2)*get(1, 0)*get(2, 3) + get(0, 0)*get(1, 2)*get(2, 3))/det, (get(1, 1)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 1)*get(3, 0) + get(1, 3)*get(2, 0)*get(3, 1) - get(1, 0)*get(2, 3)*get(3, 1) - get(1, 1)*get(2, 0)*get(3, 3) + get(1, 0)*get(2, 1)*get(3, 3))/det, (get(0, 3)*get(2, 1)*get(3, 0) - get(0, 1)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 0)*get(3, 1) + get(0, 0)*get(2, 3)*get(3, 1) + get(0, 1)*get(2, 0)*get(3, 3) - get(0, 0)*get(2, 1)*get(3, 3))/det, (get(0, 1)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 1)*get(3, 0) + get(0, 3)*get(1, 0)*get(3, 1) - get(0, 0)*get(1, 3)*get(3, 1) - get(0, 1)*get(1, 0)*get(3, 3) + get(0, 0)*get(1, 1)*get(3, 3))/det, (get(0, 3)*get(1, 1)*get(2, 0) - get(0, 1)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 0)*get(2, 1) + get(0, 0)*get(1, 3)*get(2, 1) + get(0, 1)*get(1, 0)*get(2, 3) - get(0, 0)*get(1, 1)*get(2, 3))/det, (get(1, 2)*get(2, 1)*get(3, 0) - get(1, 1)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 0)*get(3, 1) + get(1, 0)*get(2, 2)*get(3, 1) + get(1, 1)*get(2, 0)*get(3, 2) - get(1, 0)*get(2, 1)*get(3, 2))/det, (get(0, 1)*get(2, 2)*get(3, 0) - get(0, 2)*get(2, 1)*get(3, 0) + get(0, 2)*get(2, 0)*get(3, 1) - get(0, 0)*get(2, 2)*get(3, 1) - get(0, 1)*get(2, 0)*get(3, 2) + get(0, 0)*get(2, 1)*get(3, 2))/det, (get(0, 2)*get(1, 1)*get(3, 0) - get(0, 1)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 0)*get(3, 1) + get(0, 0)*get(1, 2)*get(3, 1) + get(0, 1)*get(1, 0)*get(3, 2) - get(0, 0)*get(1, 1)*get(3, 2))/det, (get(0, 1)*get(1, 2)*get(2, 0) - get(0, 2)*get(1, 1)*get(2, 0) + get(0, 2)*get(1, 0)*get(2, 1) - get(0, 0)*get(1, 2)*get(2, 1) - get(0, 1)*get(1, 0)*get(2, 2) + get(0, 0)*get(1, 1)*get(2, 2))/det ); } // if det==0.0, ret will be identity return ret; } Matrix Matrix::inverseTranspose() const { Matrix ret; float det = determinant(); if (det!=0.0) { ret.set( (get(1, 2)*get(2, 3)*get(3, 1) - get(1, 3)*get(2, 2)*get(3, 1) + get(1, 3)*get(2, 1)*get(3, 2) - get(1, 1)*get(2, 3)*get(3, 2) - get(1, 2)*get(2, 1)*get(3, 3) + get(1, 1)*get(2, 2)*get(3, 3))/det, (get(1, 3)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 0)*get(3, 2) + get(1, 0)*get(2, 3)*get(3, 2) + get(1, 2)*get(2, 0)*get(3, 3) - get(1, 0)*get(2, 2)*get(3, 3))/det, (get(1, 1)*get(2, 3)*get(3, 0) - get(1, 3)*get(2, 1)*get(3, 0) + get(1, 3)*get(2, 0)*get(3, 1) - get(1, 0)*get(2, 3)*get(3, 1) - get(1, 1)*get(2, 0)*get(3, 3) + get(1, 0)*get(2, 1)*get(3, 3))/det, (get(1, 2)*get(2, 1)*get(3, 0) - get(1, 1)*get(2, 2)*get(3, 0) - get(1, 2)*get(2, 0)*get(3, 1) + get(1, 0)*get(2, 2)*get(3, 1) + get(1, 1)*get(2, 0)*get(3, 2) - get(1, 0)*get(2, 1)*get(3, 2))/det, (get(0, 3)*get(2, 2)*get(3, 1) - get(0, 2)*get(2, 3)*get(3, 1) - get(0, 3)*get(2, 1)*get(3, 2) + get(0, 1)*get(2, 3)*get(3, 2) + get(0, 2)*get(2, 1)*get(3, 3) - get(0, 1)*get(2, 2)*get(3, 3))/det, (get(0, 2)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 2)*get(3, 0) + get(0, 3)*get(2, 0)*get(3, 2) - get(0, 0)*get(2, 3)*get(3, 2) - get(0, 2)*get(2, 0)*get(3, 3) + get(0, 0)*get(2, 2)*get(3, 3))/det, (get(0, 3)*get(2, 1)*get(3, 0) - get(0, 1)*get(2, 3)*get(3, 0) - get(0, 3)*get(2, 0)*get(3, 1) + get(0, 0)*get(2, 3)*get(3, 1) + get(0, 1)*get(2, 0)*get(3, 3) - get(0, 0)*get(2, 1)*get(3, 3))/det, (get(0, 1)*get(2, 2)*get(3, 0) - get(0, 2)*get(2, 1)*get(3, 0) + get(0, 2)*get(2, 0)*get(3, 1) - get(0, 0)*get(2, 2)*get(3, 1) - get(0, 1)*get(2, 0)*get(3, 2) + get(0, 0)*get(2, 1)*get(3, 2))/det, (get(0, 2)*get(1, 3)*get(3, 1) - get(0, 3)*get(1, 2)*get(3, 1) + get(0, 3)*get(1, 1)*get(3, 2) - get(0, 1)*get(1, 3)*get(3, 2) - get(0, 2)*get(1, 1)*get(3, 3) + get(0, 1)*get(1, 2)*get(3, 3))/det, (get(0, 3)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 0)*get(3, 2) + get(0, 0)*get(1, 3)*get(3, 2) + get(0, 2)*get(1, 0)*get(3, 3) - get(0, 0)*get(1, 2)*get(3, 3))/det, (get(0, 1)*get(1, 3)*get(3, 0) - get(0, 3)*get(1, 1)*get(3, 0) + get(0, 3)*get(1, 0)*get(3, 1) - get(0, 0)*get(1, 3)*get(3, 1) - get(0, 1)*get(1, 0)*get(3, 3) + get(0, 0)*get(1, 1)*get(3, 3))/det, (get(0, 2)*get(1, 1)*get(3, 0) - get(0, 1)*get(1, 2)*get(3, 0) - get(0, 2)*get(1, 0)*get(3, 1) + get(0, 0)*get(1, 2)*get(3, 1) + get(0, 1)*get(1, 0)*get(3, 2) - get(0, 0)*get(1, 1)*get(3, 2))/det, (get(0, 3)*get(1, 2)*get(2, 1) - get(0, 2)*get(1, 3)*get(2, 1) - get(0, 3)*get(1, 1)*get(2, 2) + get(0, 1)*get(1, 3)*get(2, 2) + get(0, 2)*get(1, 1)*get(2, 3) - get(0, 1)*get(1, 2)*get(2, 3))/det, (get(0, 2)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 2)*get(2, 0) + get(0, 3)*get(1, 0)*get(2, 2) - get(0, 0)*get(1, 3)*get(2, 2) - get(0, 2)*get(1, 0)*get(2, 3) + get(0, 0)*get(1, 2)*get(2, 3))/det, (get(0, 3)*get(1, 1)*get(2, 0) - get(0, 1)*get(1, 3)*get(2, 0) - get(0, 3)*get(1, 0)*get(2, 1) + get(0, 0)*get(1, 3)*get(2, 1) + get(0, 1)*get(1, 0)*get(2, 3) - get(0, 0)*get(1, 1)*get(2, 3))/det, (get(0, 1)*get(1, 2)*get(2, 0) - get(0, 2)*get(1, 1)*get(2, 0) + get(0, 2)*get(1, 0)*get(2, 1) - get(0, 0)*get(1, 2)*get(2, 1) - get(0, 1)*get(1, 0)*get(2, 2) + get(0, 0)*get(1, 1)*get(2, 2))/det ); } // if det==0.0, ret will be identity return ret; } float Matrix::determinant() const { double ret; ret = get(0, 3) * get(1, 2) * get(2, 1) * get(3, 0)-get(0, 2) * get(1, 3) * get(2, 1) * get(3, 0)-get(0, 3) * get(1, 1) * get(2, 2) * get(3, 0)+get(0, 1) * get(1, 3) * get(2, 2) * get(3, 0)+ get(0, 2) * get(1, 1) * get(2, 3) * get(3, 0)-get(0, 1) * get(1, 2) * get(2, 3) * get(3, 0)-get(0, 3) * get(1, 2) * get(2, 0) * get(3, 1)+get(0, 2) * get(1, 3) * get(2, 0) * get(3, 1)+ get(0, 3) * get(1, 0) * get(2, 2) * get(3, 1)-get(0, 0) * get(1, 3) * get(2, 2) * get(3, 1)-get(0, 2) * get(1, 0) * get(2, 3) * get(3, 1)+get(0, 0) * get(1, 2) * get(2, 3) * get(3, 1)+ get(0, 3) * get(1, 1) * get(2, 0) * get(3, 2)-get(0, 1) * get(1, 3) * get(2, 0) * get(3, 2)-get(0, 3) * get(1, 0) * get(2, 1) * get(3, 2)+get(0, 0) * get(1, 3) * get(2, 1) * get(3, 2)+ get(0, 1) * get(1, 0) * get(2, 3) * get(3, 2)-get(0, 0) * get(1, 1) * get(2, 3) * get(3, 2)-get(0, 2) * get(1, 1) * get(2, 0) * get(3, 3)+get(0, 1) * get(1, 2) * get(2, 0) * get(3, 3)+ get(0, 2) * get(1, 0) * get(2, 1) * get(3, 3)-get(0, 0) * get(1, 2) * get(2, 1) * get(3, 3)-get(0, 1) * get(1, 0) * get(2, 2) * get(3, 3)+get(0, 0) * get(1, 1) * get(2, 2) * get(3, 3); return (float)ret; } Matrix Matrix::rotationX(float angle) { float ca = (float)cos(angle); float sa = (float)sin(angle); return Matrix(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, ca, sa, 0.0f, 0.0f, -sa, ca, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::rotationY(float angle) { float ca = (float)cos(angle); float sa = (float)sin(angle); return Matrix(ca, 0.0f, -sa, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, sa, 0.0f, ca, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::rotationZ(float angle) { float ca = (float)cos(angle); float sa = (float)sin(angle); return Matrix(ca, sa, 0.0f, 0.0f, -sa, ca, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::translation(float x, float y, float z) { return Matrix(1.0f, 0.0f, 0.0f, x, 0.0f, 1.0f, 0.0f, y, 0.0f, 0.0f, 1.0f, z, 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::translation(const Vector& vec) { return Matrix(1.0f, 0.0f, 0.0f, vec[0], 0.0f, 1.0f, 0.0f, vec[1], 0.0f, 0.0f, 1.0f, vec[2], 0.0f, 0.0f, 0.0f, 1.0f); } Matrix Matrix::scale(float x, float y, float z) { return Matrix(x, 0.0f, 0.0f, 0.0f, 0.0f, y, 0.0f, 0.0f, 0.0f, 0.0f, z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Ray.cpp0000644000175000017500000002004410321054404027446 0ustar debiandebian /*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Ray.cpp: implementation of the Ray class. // ////////////////////////////////////////////////////////////////////// #include "Ray.h" #include using CCVOpenGLMath::Vector; using CCVOpenGLMath::Ray; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// Ray::Ray() : m_Origin(0.0f, 0.0f, 0.0f, 1.0f), m_Dir(0.0f, 0.0f, 1.0f, 0.0f) { } Ray::Ray(const Vector& origin, const Vector& dir) : m_Origin(origin), m_Dir(dir) { } Ray::~Ray() { } Vector Ray::getPointOnRay(float t) const { return m_Origin+m_Dir*t; } float Ray::nearestTOnXAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); float distance = ray.distanceToXAxis(Origin); float t = -(ray.m_Origin[1]*ray.m_Dir[1] + ray.m_Origin[2]*ray.m_Dir[2])/ ((ray.m_Dir[1]*ray.m_Dir[1]+ray.m_Dir[2]*ray.m_Dir[2]) ); return t; } float Ray::nearestTOnYAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); float distance = ray.distanceToYAxis(Origin); float t = -(ray.m_Origin[0]*ray.m_Dir[0] + ray.m_Origin[2]*ray.m_Dir[2])/ ((ray.m_Dir[0]*ray.m_Dir[0]+ray.m_Dir[2]*ray.m_Dir[2])); return t; } float Ray::nearestTOnZAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); float distance = ray.distanceToZAxis(Origin); float t = -(ray.m_Origin[0]*ray.m_Dir[0] + ray.m_Origin[1]*ray.m_Dir[1])/ ((ray.m_Dir[1]*ray.m_Dir[1]+ray.m_Dir[0]*ray.m_Dir[0])); return t; } Vector Ray::nearestPointOnXAxis(Vector Origin) const { Origin[3] = 0; float t = nearestTOnXAxis(Origin); Vector result = getPointOnRay(t); // project to axis result[1] = Origin[1]; result[2] = Origin[2]; //result+=Origin; return result; } Vector Ray::nearestPointOnYAxis(Vector Origin) const { Origin[3] = 0; float t = nearestTOnYAxis(Origin); Vector result = getPointOnRay(t); // project to axis result[0] = Origin[0]; result[2] = Origin[2]; //result+=Origin; return result; } Vector Ray::nearestPointOnZAxis(Vector Origin) const { Origin[3] = 0; float t = nearestTOnZAxis(Origin); Vector result = getPointOnRay(t); // project to axis result[0] = Origin[0]; result[1] = Origin[1]; return result; } float Ray::distanceToXAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); return (float)fabs( ( ray.m_Origin[2]*ray.m_Dir[1]-ray.m_Origin[1]*m_Dir[2] ) / (float)sqrt( ray.m_Dir[2]*ray.m_Dir[2] + ray.m_Dir[1]*ray.m_Dir[1] ) ); } float Ray::distanceToYAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); return (float)fabs( ( ray.m_Origin[2]*ray.m_Dir[0]-ray.m_Origin[0]*m_Dir[2] ) / (float)sqrt( ray.m_Dir[2]*ray.m_Dir[2] + ray.m_Dir[0]*ray.m_Dir[0] ) ); } float Ray::distanceToZAxis(Vector Origin) const { Origin[3] = 0; Ray ray(m_Origin-Origin, m_Dir); return (float)fabs( ( ray.m_Origin[0]*ray.m_Dir[1]-ray.m_Origin[1]*m_Dir[0] ) / (float)sqrt( ray.m_Dir[0]*ray.m_Dir[0] + ray.m_Dir[1]*ray.m_Dir[1] ) ); } /*********************************************************/ /* */ /* Returns false if there is no intersection. */ /* Else, it returns both the points and the values of */ /* the parameter where the intersections took place. */ /* */ /*********************************************************/ bool Ray::intersectSphere( Vector center, float radius, Vector *point1, Vector* point2, float *distance1, float* distance2 ) { if( !point1 || !point2 ) return false; if( radius <= 0 ) return false; /// solve quadratic equation ///// //// A = Xd^2 + Yd^2 + Zd^2 //// B = 2 * (Xd * (X0 - Xc) + Yd * (Y0 - Yc) + Zd * (Z0 - Zc)) //// C = (X0 - Xc)^2 + (Y0 - Yc)^2 + (Z0 - Zc)^2 - Sr^2 /////////////////////////////////// float A = m_Dir[0]*m_Dir[0] + m_Dir[1]*m_Dir[1] + m_Dir[2]*m_Dir[2]; float B = 2* ( m_Dir[0] * (m_Origin[0] - center[0]) + m_Dir[1] * (m_Origin[1] - center[1]) + m_Dir[2] * (m_Origin[2] - center[2]) ); float C = (m_Origin[0] - center[0])*(m_Origin[0] - center[0]) + (m_Origin[1] - center[1])*(m_Origin[1] - center[1]) + (m_Origin[2] - center[2])*(m_Origin[2] - center[2]) - radius*radius; float discriminant = B*B - 4*A*C; if( discriminant < 0 ) return false; *distance1 = (float)(( -B - sqrt( discriminant ) ) / ( 4.0 * A * C )); *distance2 = (float)(( -B + sqrt( discriminant ) ) / ( 4.0 * A * C )); *point1 = m_Origin + m_Dir * (*distance1); *point2 = m_Origin + m_Dir * (*distance2); return true; }mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/UsefulMath.pro0000644000175000017500000000072310321054404031010 0ustar debiandebian# qmake project generated by QMsDev # # General settings TEMPLATE = lib CONFIG += qt warn_off staticlib create_prl TARGET += UsefulMath # Input SOURCES = \ AreaVolumes.cpp \ LinearAlgebra.cpp \ Matrix.cpp \ Quaternion.cpp \ Ray.cpp \ TrilinearGrid.cpp \ Tuple.cpp \ Vector.cpp HEADERS = \ AreaVolumes.h \ LinearAlgebra.h \ Matrix.h \ Quaternion.h \ Ray.h \ TrilinearGrid.h \ Tuple.h \ Vector.h mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/AreaVolumes.h0000644000175000017500000000100010321054404030572 0ustar debiandebian// AreaVolumes.h: interface for the AreaVolumes class. // ////////////////////////////////////////////////////////////////////// #ifndef CCV_AREA_VOLUMES_H #define CCV_AREA_VOLUMES_H namespace CCVOpenGLMath { class AreaVolumes { public: AreaVolumes(); virtual ~AreaVolumes(); static double getTriangleArea( double v1x, double v1y, double v1z, double v2x, double v2y, double v2z, double v3x, double v3y, double v3z); }; }; #endif // CCV_AREA_VOLUMES_H mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/LinearAlgebra.cpp0000644000175000017500000003420210321054404031404 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // LinearAlgebra.cpp: implementation of the LinearAlgebra class. // ////////////////////////////////////////////////////////////////////// #include "LinearAlgebra.h" #include "Vector.h" #include using CCVOpenGLMath::Vector; using CCVOpenGLMath::LinearAlgebra; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// LinearAlgebra::LinearAlgebra() { } LinearAlgebra::~LinearAlgebra() { } bool LinearAlgebra::getCylinderFit( int n, double* x, double* y, double* z, Vector* p1, Vector* p2, double* radius ) { // 1: Get the best fit Lxy on xy projection of points // 2: Get the best fit Lxz on xz projection of points // 3: Combine Lxy, Lxz to get the axis of cylinder // 4. Define the centroid to be a point on the axis // 5. Let radius of cyinder be average of radii of above two fits // 6. Some how get the extent of the axis double m1, m2, c1, c2, radius1, radius2; // step 1: if( !leastSquares( n, x, y, &m1, &c1, &radius1 ) ) return false; // step 2: if( !leastSquares( n, x, z, &m2, &c2, &radius2 ) ) return false; // step 3: // sin t = sqrt( m^2 / ( 1 + m^2 ) ) // cos t = sqrt( 1 / ( 1 + m^2 ) ) // The dcs of line 1 are norm( cos t1, sin t1, 0, 0 ) // The dcs of line 2 are norm( cos t2, 0, sin t2, 0 ) // The DCs are norm( cost1+cos t2, sint1, sin t2, 0 ) double sin_t1 = sqrt( m1*m1 / ( 1.0 + m1*m1) ); double cos_t1 = sqrt( 1 / ( 1.0 + m1*m1 ) ); if( m1 < 0 ) sin_t1 = -1* sin_t1; double sin_t2 = sqrt( m2*m2 / ( 1.0 + m2*m2) ); double cos_t2 = sqrt( 1 / ( 1.0 + m2*m2 ) ); if( m2 < 0 ) sin_t2 = -1*sin_t2; Vector DCs = Vector( (float)(cos_t1+cos_t2), (float)sin_t1, (float)sin_t2, 0 ); DCs.normalize(); // step 4: double x0, y0, z0; // point on axis ( say centroid ) if( !mean( x, n, &x0 ) ) return false; if( !mean( y, n, &y0 ) ) return false; if( !mean( z, n, &z0 ) ) return false; // step 5: *radius = ( radius1 + radius2 ) * 0.5; // step 6: // minLen = maxLen = 0 // for each point P // get norm ( p-p0 ) // compute cos t = dot prod ( axis dcs with prev result ) // len = len( ( p-p0 ) * cos t ) // update minLen, maxLen with len and sign of cos t // end // Endpoints are center + max Len, center - minLen double minLen = 0, maxLen = 0; int i; for( i=0; i maxLen ) maxLen = len; } // Endpoints are center + max Len, center - minLen p1->set((float)(x0+minLen*DCs[0]), (float)(y0+minLen*DCs[1]), (float)(z0+minLen*DCs[2]), 1); p2->set((float)(x0+maxLen*DCs[0]), (float)(y0+maxLen*DCs[1]), (float)(z0+maxLen*DCs[2]), 1); return true; } bool LinearAlgebra::leastSquares( int n, double* x, double* y, double* m, double* c, double* radius ) { if( !x ) return false; if( !y ) return false; if( n < 1 ) return false; double xMean = 0, yMean = 0, xSumSquare = 0, ySumSquare = 0, xDotY = 0; if( !mean( x, n, &xMean ) ) return false; if( !mean( y, n, &yMean ) ) return false; if( !sumOfSquares( x, n, &xSumSquare ) ) return false; if( !sumOfSquares( y, n, &ySumSquare ) ) return false; if( !dotProduct( x, y, n, &xDotY ) ) return false; double denomM = n*xMean*yMean -xDotY; // hope it wont happen ! if( (denomM < 0.000000001) && (denomM > -0.000000001 ) ) return false; // slope is 90 degrees, not really a error ! double M = 0.5*( ySumSquare - n*yMean*yMean - xSumSquare + n*xMean*xMean ) / denomM; // quadratic has two solutions, get the least residual as the answer double m1 = -M + sqrt( M*M+1 ); double m2 = -M - sqrt( M*M+1 ); double c1 = yMean - m1 * xMean; double c2 = yMean - m2 * xMean; double residual1 = 0; double residual2 = 0; int i; double dist1 = 0, dist2 = 0; for( i=0; i 0 ) x[i] = posVal; } return true; } bool LinearAlgebra::correlate( double* x, double* y, int n, double* correlationCoefficient ) { if( !x ) return false; if( !y ) return false; if( n < 1 ) return false; if( !correlationCoefficient ) return false; double dotProd = 0; double norm1 = 0; double norm2 = 0; if( !dotProduct( x, y, n, &dotProd ) ) return false; if( !dotProduct( x, x, n, &norm1 ) ) return false; if( !dotProduct( y, y, n, &norm2 ) ) return false; norm1 = sqrt(norm1); norm2 = sqrt(norm2); double denom = norm1*norm2; if( denom < 0.0000000000000001 ) denom = 0.0000000000000001; *correlationCoefficient = dotProd / denom; return true; } ////////////// // // if usePositiveValues is true, take all positive x values and correlate with corresponding y values. // ////////////// bool LinearAlgebra::selectivelyCorrelate( double* x, int rangeToCorrelate, double* y, int n, double* correlationCoefficient ) { if( !x ) return false; if( !y ) return false; if( n < 1 ) return false; if( !correlationCoefficient ) return false; // find how many significant values are there in x. int nUseful = 0; if( rangeToCorrelate == 0 ) nUseful = n; else { int i; for( i=0; i0) && (x[i]>0) ) nUseful++; else if( (rangeToCorrelate<0) && (x[i]<0) ) nUseful++; } } if( nUseful <= 0 ) return false; double* xUseful = new double[nUseful]; double* yUseful = new double[nUseful]; // fill up above arrays { int c = 0; int i; for( i=0; i0) && (x[i]>0) ) { xUseful[c] = x[i]; yUseful[c] = y[i]; c++; } else if( (rangeToCorrelate<0) && (x[i]<0) ) { xUseful[c] = x[i]; yUseful[c] = y[i]; c++; } } } // correllate *correlationCoefficient = 0; if( !correlate( xUseful, yUseful, nUseful, correlationCoefficient ) ) return false; return true; } bool LinearAlgebra::solveSystem(double a11, double a12, double a13, double a21, double a22, double a23, double a31, double a32, double a33, double b1, double b2, double b3, double* x, double* y, double* z) { double determinant = a11*(a22*a33 - a32*a23) - a12*(a21*a33 - a31*a23) + a13*(a21*a32 - a31*a22); double xdeterminant = b1*(a22*a33 - a32*a23) - a12*(b2 *a33 - b3*a23) + a13*(b2 *a32 - b3 *a22); double ydeterminant = a11*(b2 *a33 - b3 *a23) - b1 *(a21*a33 - a31*a23) + a13*(a21*b3 - a31*b2); double zdeterminant = a11*(a22*b3 - a32*b2) - a12*(a21*b3 - a31*b2 ) + b1 *(a21*a32 - a31*a22); if( fabs(determinant) < 1e-10 ) return false; if( fabs(xdeterminant) < 1e-10 ) return false; if( fabs(ydeterminant) < 1e-10 ) return false; if( fabs(zdeterminant) < 1e-10 ) return false; *x = xdeterminant / determinant; *y = ydeterminant / determinant; *z = zdeterminant / determinant; return true; } bool LinearAlgebra::solve2x2System( double a11, double a12, double b1, double a21, double a22, double b2, double* x, double* y) { double d = a11*a22 - a12*a21; if( fabs(d) < 1e-10 ) return false; *x = (b1*a22 - b2*a12) / d; *y = (b2*a11 - b1*a21) / d; return true; } bool LinearAlgebra::solveDependentEquations( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* vec ) { // try making x as 1, find y and z. { vec[0] = 1; if( solve2x2System( c12, c13, -c11, c22, c23, -c21, &(vec[1]), &(vec[2]) ) ) return true; if( solve2x2System( c12, c13, -c11, c32, c33, -c31, &(vec[1]), &(vec[2]) ) ) return true; if( solve2x2System( c22, c23, -c21, c32, c33, -c31, &(vec[1]), &(vec[2]) ) ) return true; } // try making y as 1, find x and z. { vec[1] = 1; if( solve2x2System( c11, c13, -c12, c21, c23, -c22, &(vec[0]), &(vec[2]) ) ) return true; if( solve2x2System( c11, c13, -c12, c31, c33, -c32, &(vec[0]), &(vec[2]) ) ) return true; if( solve2x2System( c21, c23, -c22, c31, c33, -c32, &(vec[0]), &(vec[2]) ) ) return true; } // try making z as 1, find x and y. { vec[2] = 1; if( solve2x2System( c11, c12, -c13, c21, c22, -c23, &(vec[0]), &(vec[1]) ) ) return true; if( solve2x2System( c11, c12, -c13, c31, c32, -c33, &(vec[0]), &(vec[1]) ) ) return true; if( solve2x2System( c21, c22, -c23, c31, c32, -c33, &(vec[0]), &(vec[1]) ) ) return true; } return false; } bool LinearAlgebra::solveEigenSystem( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* k1Vec, double* k2Vec, double g1, double g2) { if( !solveDependentEquations(c11-g1, c12, c13, c21, c22-g1, c23, c31, c32, c33-g1, k1Vec) ) return false; if( !solveDependentEquations(c11-g2, c12, c13, c21, c22-g2, c23, c31, c32, c33-g2, k2Vec) ) return false; return true; } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Ray.h0000644000175000017500000001133710321054404027120 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Ray.h: interface for the Ray class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_RAY_H__8760CFFE_A656_460F_A893_4C81FF806264__INCLUDED_) #define AFX_RAY_H__8760CFFE_A656_460F_A893_4C81FF806264__INCLUDED_ #include "Vector.h" namespace CCVOpenGLMath { class Ray { public: Ray(); Ray(const Vector& origin, const Vector& dir); virtual ~Ray(); Vector getPointOnRay(float t) const; float nearestTOnXAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float nearestTOnYAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float nearestTOnZAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; Vector nearestPointOnXAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; Vector nearestPointOnYAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; Vector nearestPointOnZAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float distanceToXAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float distanceToYAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; float distanceToZAxis(Vector Origin = Vector(0.0, 0.0, 0.0, 1.0)) const; bool intersectSphere( Vector center, float radius, Vector *point1, Vector* point2, float *distance1, float* distance2 ); Vector m_Origin; Vector m_Dir; }; }; #endif // !defined(AFX_RAY_H__8760CFFE_A656_460F_A893_4C81FF806264__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/LinearAlgebra.h0000644000175000017500000001267210321054404031060 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Author: Vinay Siddavanahalli 2004-2005 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // LinearAlgebra.h: interface for the LinearAlgebra class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_LINEARALGEBRA_H__AD644F94_D742_4858_A926_AC7E6964B1E2__INCLUDED_) #define AFX_LINEARALGEBRA_H__AD644F94_D742_4858_A926_AC7E6964B1E2__INCLUDED_ #include "Vector.h" namespace CCVOpenGLMath { class LinearAlgebra { public: LinearAlgebra(); virtual ~LinearAlgebra(); static bool getCylinderFit( int n, double* x, double* y, double* z, CCVOpenGLMath::Vector* p1, CCVOpenGLMath::Vector* p2, double* radius ); // fit a line y = mx + c minimizing the least squares norm. static bool leastSquares( int n, double* x, double* y, double* m, double* c, double* radius ); static bool mean( double* x, int n, double* mean ); static bool summation( double* x, int n, double* sum ); static bool sumOfSquares( double* x, int n, double* sumSquare ); static bool dotProduct( double* x, double* y, int n, double* dotProd ); static bool correlate( double* x, double* y, int n, double* correlationCoefficient ); static bool selectivelyCorrelate( double* x, int rangeToCorrelate, double* y, int n, double* correlationCoefficient ); static bool discretize( double* x, int n, double posVal, double negVal ); // solve ax=b static bool solveSystem(double a11, double a12, double a13, double a21, double a22, double a23, double a31, double a32, double a33, double b1, double b2, double b3, double* x, double* y, double* z); static bool solve2x2System( double a11, double a12, double b1, double a21, double a22, double b2, double* x, double* y); static bool solveEigenSystem( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* k1Vec, double* k2Vec, double g1, double g2); static bool solveDependentEquations( double c11, double c12, double c13, double c21, double c22, double c23, double c31, double c32, double c33, double* vec ); }; }; #endif // !defined(AFX_LINEARALGEBRA_H__AD644F94_D742_4858_A926_AC7E6964B1E2__INCLUDED_) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/src/UsefulMath/Vector.cpp0000644000175000017500000001436610321054404030167 0ustar debiandebian/*****************************************************************************/ /* */ /* UsefulMath: Some little math routines which dont fit anywhere else. */ /* */ /* Copyright (C) The University of Texas at Austin */ /* */ /* Authors: Vinay Siddavanahalli 2004-2005 */ /* Authors: Anthony Thane 2003-2003 */ /* */ /* Principal Investigator: Chandrajit Bajaj */ /* */ /* Professor of Computer Sciences, */ /* Computational and Applied Mathematics Chair in Visualization, */ /* Director, Computational Visualization Center (CVC), */ /* Institute of Computational Engineering and Sciences (ICES) */ /* The University of Texas at Austin, */ /* 201 East 24th Street, ACES 2.324A, */ /* 1 University Station, C0200 */ /* Austin, TX 78712-0027 */ /* http://www.cs.utexas.edu/~bajaj */ /* */ /* http://www.ices.utexas.edu/CVC */ /* */ /* This library is free software; 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; either */ /* version 2.1 of the License, or (at your option) any later version. */ /* Specifically, this library is free for academic or personal non-profit */ /* use, with due acknowledgement. Any or all personal profit / industrial */ /* use needs to get a proper license approved from us. */ /* */ /* This library 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 */ /* Lesser General Public License for more details. */ /* */ /* You should have received a copy of the GNU Lesser General Public */ /* License along with this library; if not, write to the Free Software */ /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 */ /* USA */ /* */ /*****************************************************************************/ // Vector.cpp: implementation of the Vector class. // ////////////////////////////////////////////////////////////////////// #include "Vector.h" #include using CCVOpenGLMath::Tuple; using CCVOpenGLMath::Vector; ////////////////////////////////////////////////////////////////////// // Construction/Destruction ////////////////////////////////////////////////////////////////////// const float EPS = 0.00001f; Vector::Vector(float x, float y, float z, float w) : Tuple(x,y,z,w) { } Vector::Vector() : Tuple() { } Vector::Vector(float* array) { set(array); } Vector::~Vector() { } Vector::Vector(const Vector& copy): Tuple(copy) { } Vector& Vector::operator=(const Vector& copy) { if (this!=©) { set(copy); } return *this; } Vector& Vector::set(float x, float y, float z, float w) { Tuple::set(x,y,z,w); return *this; } Vector& Vector::set(float* array) { Tuple::set(array); return *this; } Vector& Vector::set(const Vector& copy) { Tuple::set(copy); return *this; } Vector Vector::cross(const Vector& vec) const { return Vector( p[1]*vec[2] - p[2]*vec[1], p[2]*vec[0] - p[0]*vec[2], p[0]*vec[1] - p[1]*vec[0], 0.0f ); } Vector& Vector::crossEquals(const Vector& vec) { return set( p[1]*vec[2] - p[2]*vec[1], p[2]*vec[0] - p[0]*vec[2], p[0]*vec[1] - p[1]*vec[0], 0.0f ); } float Vector::dot(const Vector& vec) const { return p[0]*vec[0] + p[1]*vec[1] + p[2]*vec[2] + p[3]*vec[3]; } Vector Vector::operator+(const Vector vec) const { return Vector( p[0]+vec[0], p[1]+vec[1], p[2]+vec[2], p[3]+vec[3]); } Vector& Vector::operator+=(const Vector vec) { return set( p[0]+vec[0], p[1]+vec[1], p[2]+vec[2], p[3]+vec[3]); } Vector Vector::operator-(const Vector vec) const { return Vector( p[0]-vec[0], p[1]-vec[1], p[2]-vec[2], p[3]-vec[3]); } Vector& Vector::operator-=(const Vector vec) { return set( p[0]-vec[0], p[1]-vec[1], p[2]-vec[2], p[3]-vec[3]); } Vector Vector::operator*(float scalar) const { return Vector(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]); } Vector& Vector::operator*=(float scalar) { return set(p[0]*scalar, p[1]*scalar, p[2]*scalar, p[3]); } Vector Vector::operator-() const { return Vector(-p[0], -p[1], -p[2], p[3]); } Vector& Vector::normalize() { if ((float)fabs(p[3])<=EPS) { float length = (float)sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]); return set(p[0]/length,p[1]/length,p[2]/length,0.0f); } else { return set(p[0]/p[3], p[1]/p[3], p[2]/p[3], 1.0f); } } float Vector::norm() { return (float)sqrt(p[0]*p[0]+p[1]*p[1]+p[2]*p[2]); } bool Vector::isBad() { return (p[0]==0.0f && p[1]==0.0f && p[2]==0.0f && p[3]==0.0f); } Vector Vector::badVector() { return Vector(0.0f, 0.0f, 0.0f, 0.0f); } Vector* Vector::clone() const { return new Vector(*this); } mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/setup.py0000644000175000017500000000774210675046061025103 0ustar debiandebianfrom distutils.core import setup, Extension from distutils.cmd import Command from distutils.command.install_data import install_data from distutils.command.build import build from distutils.command.sdist import sdist from glob import glob from distutils.command.build_ext import build_ext import sys from os import path ##################################################################### # This class overwrites the prune_file_list method of sdist to not # remove automatically the RCS/CVS directory from the distribution. #################################################################### class modified_sdist(sdist): def prune_file_list(self): build = self.get_finalized_command('build') base_dir = self.distribution.get_fullname() self.filelist.exclude_pattern(None, prefix=build.build_base) self.filelist.exclude_pattern(None, prefix=base_dir) ######################################################################## # Overwrite the sub_commands list of the build command so that # the build_py is called after build_clib and build_ext. This way # the python module generated by SWIG ('build_ext' command) will be # installed by 'build_py' command. ######################################################################## class modified_build(build): sub_commands = [('build_clib', build.has_c_libraries), ('build_ext', build.has_ext_modules), ('build_py', build.has_pure_modules), ('build_scripts', build.has_scripts), ] ## Need to use C++ compiler: CC_exe = 'CC' cc_exe = 'cc' platform = sys.platform if platform == "linux2" or platform == "darwin": CC_exe = 'g++' cc_exe = 'gcc' from distutils import sysconfig save_init_posix = sysconfig._init_posix def my_init_posix(): save_init_posix() g = sysconfig._config_vars for n,r in [('LDSHARED',CC_exe),('CC',CC_exe)]: if g[n][:3] == cc_exe: print 'my_init_posix: changing %s = %r'%(n,g[n]), g[n] = r+g[n][3:] print 'to', g[n] if platform in ('sunos5', 'linux2', 'irix6', 'darwin'): sysconfig._init_posix = my_init_posix comp_opts = [] link_opts = [] if platform == "irix6": comp_opts.append( "-LANG:std" ) link_opts.append("-LANG:std") elif platform == "win32": comp_opts.append("/MT") packFullName = "UTpackages.UTmolderivatives" packName = "UTmolderivatives" sources = [] curv_src = ["Curvature.cpp", "CurvaturesGridVoxel.cpp", "SumOfGaussiansCurvature.cpp"] math_src = ["LinearAlgebra.cpp", "AreaVolumes.cpp", "Matrix.cpp","Ray.cpp","Tuple.cpp", "Quaternion.cpp", "TrilinearGrid.cpp", "Vector.cpp"] for f in curv_src: sources.append(path.join("src", "Curvatures", f)) for f in math_src: sources.append(path.join("src", "UsefulMath", f)) sources.append(path.join(packName, "molderivatives.i")) import numpy numpy_include = numpy.get_include() source_include = [path.join("src", "Curvatures"), path.join("src", "UsefulMath"), numpy_include] dist = setup(name=packFullName, version="1.0", description = "MolDerivatives Library, part of TexMol (developed at the University of Texas, Austin)", author = "Molecular Graphics Laboratory", author_email = "mgltools@scripps.edu", download_url = "http://www.scripps.edu/~sanner/python/packager.html", url = '', packages = [packFullName], package_dir = {packFullName: packName}, cmdclass = {'build':modified_build, 'sdist':modified_sdist}, ext_package = packFullName, ext_modules = [Extension ("_molderivatives", sources, include_dirs = source_include, extra_compile_args = comp_opts, extra_link_args = link_opts ) ] ) mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/UTmolderivatives/0000755000175000017500000000000012146213617026663 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/UTmolderivatives/molderivatives.i0000644000175000017500000000743011165205023032066 0ustar debiandebian %module molderivatives %{ #include "SumOfGaussiansCurvature.h" #include void getGaussianCurvature (int numberOfGaussians, double gaussianCenters[][4], int numberOfGridDivisions, double maxFunctionError, double blobbiness, int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector) { SumOfGaussiansCurvature sum(numberOfGaussians, (double *)gaussianCenters, numberOfGridDivisions, maxFunctionError, blobbiness, numberOfPoints, points, HandK, normals, k1Vector, k2Vector); //std::cout << "number of Points: " << numberOfPoints << std::endl; //std::cout << "number of Gaussians: " << numberOfGaussians << std::endl; bool status = sum.initialize(); if (status) sum.getCurvatures(); else std::cerr << "Could not initialize SumOfGaussiansCurvature." << std::endl; } %} %include "numarr.i" %define INPUT_ARRAYPTR(type, pytype) %typemap(in) (int LEN, type ARRAYPTR[][ANY])(PyArrayObject *array=NULL, int expected_dims[2]) %{ expected_dims[0] = 0; expected_dims[1] = $2_dim1; array = contiguous_typed_array($input, pytype,2 , NULL); if (! array) return NULL; $2 = (type (*)[$2_dim1])array->data; $1 = ((PyArrayObject *)(array))->dimensions[0]; %} %typemap(freearg)(int LEN, type ARRAYPTR[][ANY]) %{ if (array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef //INPUT_ARRAYPTR(float, PyArray_FLOAT); INPUT_ARRAYPTR(double, PyArray_DOUBLE); %apply (int LEN, double ARRAYPTR[][ANY]) {(int numberOfGaussians, double gaussianCenters[][4])}; %typemap(arginit) (int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector) %{ PyArrayObject *pts = NULL; PyArrayObject *handk, *norms, *vec1, *vec2; %} %typemap(in) (int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector) %{ //PyArrayObject *pts = NULL; //PyArrayObject *handk, *norms, *vec1, *vec2; pts = contiguous_typed_array($input, PyArray_FLOAT, 2 , NULL); if (! pts) return NULL; $1 = ((PyArrayObject *)(pts))->dimensions[0]; $2 = (float *)pts->data; npy_intp hdims[1], ndims[1]; hdims[0] = $1*2; ndims[0] = $1*3; handk = (PyArrayObject *)PyArray_SimpleNew(1, hdims, PyArray_DOUBLE); if (!handk) { std::cerr << "Failed to create PyArrayObject * handk (HandK)" <data; $4 = (double *)norms->data; $5 = (double *)vec1->data; $6 = (double *)vec2->data; %} %typemap(argout) (double* HandK, double* normals, double* k1Vector, double* k2Vector) %{ $result = Py_BuildValue("(NNNN)", handk, norms, vec1, vec2); %} %typemap(freearg)(int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector) %{ if (pts) Py_DECREF((PyObject *)pts); %} void getGaussianCurvature (int numberOfGaussians, double gaussianCenters[][4], int numberOfGridDivisions, double maxFunctionError, double blobbiness, int numberOfPoints, float* points, double* HandK, double* normals, double* k1Vector, double* k2Vector); mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/UTmolderivatives/numarr.i0000644000175000017500000006575711165234135030363 0ustar debiandebian%init %{ import_array(); /* load the Numeric PyCObjects */ %} %{ #ifdef _MSC_VER #include #define WinVerMajor() LOBYTE(LOWORD(GetVersion())) #endif #include "numpy/arrayobject.h" static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode, int expectnd, int *expectdims) { PyArrayObject *arr; int i, numitems, itemsize; char buf[255]; /* if the shape and type are OK, this function increments the reference count and arr points to obj */ if((arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj, typecode, 0, 10)) == NULL) { sprintf(buf,"Failed to make a contiguous array of type %d\n", typecode); PyErr_SetString(PyExc_ValueError, buf); return NULL; } if(expectnd>0) { if(arr->nd > expectnd + 1 || arr->nd < expectnd) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } if(arr->nd == expectnd + 1) { if(arr->dimensions[arr->nd - 1] != 1) { Py_DECREF((PyObject *)arr); PyErr_SetString(PyExc_ValueError, "Array has wrong number of dimensions"); return NULL; } } if(expectdims) { for(i = 0; i < expectnd; i++) if(expectdims[i]>0) if(expectdims[i] != arr->dimensions[i]) { Py_DECREF((PyObject *)arr); sprintf(buf,"The extent of dimension %d is %d while %d was expected\n", i, arr->dimensions[i], expectdims[i]); PyErr_SetString(PyExc_ValueError, buf); return NULL; } } } return arr; } %} /**********************************************************/ /* OUTPUT */ /**********************************************************/ %{ static PyObject* l_output_helper2(PyObject* target, PyObject* o) { PyObject* o2; PyObject* o3; if (!target) { target = o; } else if (target == Py_None) { Py_DECREF(Py_None); target = o; } else { if (!PyList_Check(target)) { o2 = target; target = PyList_New(0); PyList_Append(target, o2); Py_XDECREF(o2); } PyList_Append(target,o); Py_XDECREF(o); } return target; } %} /**********************************************************/ /* OUTPUT: int VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) int OUT_VECTOR[ANY], int OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) int OUT_VECTOR[ANY] (PyArrayObject *array, npy_intp out_dims[1]) %{ out_dims[0] = $1_dim0; $1 = (int *)malloc($1_dim0*sizeof(int)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_INT, (char *)$1); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif %} %typemap(in, numinputs=0) int OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { int *data = (int *)malloc($1_dim0*$1_dim1*sizeof(int)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_INT, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (int (*)[$1_dim1])data; } /**********************************************************/ /* OUTPUT: float VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) float OUT_VECTOR[ANY], float OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) float OUT_VECTOR[ANY](PyArrayObject *array, npy_intp out_dims[1]) %{ out_dims[0] = $1_dim0; $1= (float *)malloc($1_dim0*sizeof(float)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_FLOAT, (char *)($1)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif %} %typemap(in, numinputs=0) float OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { float *data = (float *)malloc($1_dim0*$1_dim1*sizeof(float)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_FLOAT, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (float (*)[$1_dim1])data; } /**********************************************************/ /* OUTPUT: double VECTOR, ARRAY */ /**********************************************************/ %typemap(argout) double OUT_VECTOR[ANY], double OUT_ARRAY2D[ANY][ANY] { $result = l_output_helper2($result, (PyObject *)array$argnum); } %typemap(in, numinputs=0) double OUT_VECTOR[ANY] (PyArrayObject *array, npy_intp out_dims[1]) { out_dims[0] = $1_dim0; $1= (double *)malloc($1_dim0*sizeof(double)); if ($1 == NULL) { PyErr_SetString(PyExc_ValueError, "failed to allocate memory"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(1, out_dims, PyArray_DOUBLE, (char *)($1)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif } %typemap(in, numinputs=0) double OUT_ARRAY2D[ANY][ANY] (PyArrayObject *array, npy_intp out_dims[2]) { double *data = (double *)malloc($1_dim0*$1_dim1*sizeof(double)); out_dims[0] = $1_dim0; out_dims[1] = $1_dim1; if (!data) { PyErr_SetString(PyExc_ValueError, "failed to allocate data array"); return NULL; } array = (PyArrayObject *)PyArray_SimpleNewFromData(2, out_dims, PyArray_DOUBLE, (char *)(data)); #ifdef _MSC_VER switch ( WinVerMajor() ) { case 6: break; // Vista default: array->flags |= NPY_OWNDATA; } #else // so we'll free this memory when this // array will be garbage collected array->flags |= NPY_OWNDATA; #endif $1 = (double (*)[$1_dim1])data; } /*************************************************************/ /* INPUT */ /*************************************************************/ /*************************************************************/ /* INPUT: u_char VECTOR */ /*************************************************************/ %typemap(in) u_char VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[1] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 1, expected_dims); if (! array) return NULL; $1 = (u_char *)array->data; %} %typemap(freearg) u_char VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: u_char ARRAY2D */ /*************************************************************/ %typemap(in) u_char ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 2, expected_dims); if (! array) return NULL; $1 = (u_char (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) u_char ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: int VECTOR */ /*************************************************************/ %typemap(in) int VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; %} %typemap(freearg) int VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: int ARRAY2D */ /*************************************************************/ %typemap(in) int ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = (int (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) int ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: float VECTOR */ /*************************************************************/ %typemap(in) float VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; %} %typemap(freearg) float VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: float ARRAY2D */ /*************************************************************/ %typemap(in) float ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) float ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*******************************************************/ /** Input: float ARRAY2D_NULL **/ /*******************************************************/ %typemap(in) float ARRAY2D_NULL[ANY][ANY] (PyArrayObject *array , int expected_dims[2]) { if ($input == Py_None) { $1 = NULL; } else { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; } } /*************************************************************/ /* INPUT: double VECTOR */ /*************************************************************/ %typemap(in) double VECTOR[ANY] (PyArrayObject *array, int expected_dims[1]) %{ expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 1, expected_dims); if (! array) return NULL; $1 = (double *)array->data; %} %typemap(freearg) double VECTOR[ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} /*************************************************************/ /* INPUT: double ARRAY2D */ /*************************************************************/ %typemap(in) double ARRAY2D[ANY][ANY](PyArrayObject *array, int expected_dims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_DOUBLE, 2, expected_dims); if (! array) return NULL; $1 = (double (*)[$1_dim1])array->data; } else { array = NULL; $1 = NULL; } %} %typemap(freearg) double ARRAY2D[ANY][ANY] %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %define UCHAR_ARRAY2D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int* DIM, u_char ARRAYNAME##ARRAYSHAPE) (PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 2, expected_dims); if (! array) return NULL; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $1 = intdims; $2 = (u_char (*)[$2_dim1])array->data; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int* DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /*** Macros to generate typemaps for pairs of arguments *******/ /**************************************************************/ /**************************************************************/ /* Input: FLOAT_ARRAY4D */ /**************************************************************/ %define FLOAT_ARRAY4D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, float ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 4, expected_dims); if (! array) return NULL; $2 = (float(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, float ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: SHORT_ARRAY4D */ /**************************************************************/ %define SHORT_ARRAY4D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int *DIM, short ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_SHORT, 4, expected_dims); if (! array) return NULL; $2 = (short(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, short ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: UCHAR_ARRAY4D */ /**************************************************************/ %define UCHAR_ARRAY4D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[4], int intdims[4]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 4, expected_dims); if (! array) return NULL; $2 = (u_char(*)[$2_dim1][$2_dim2][$2_dim3])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef %define SHORT_ARRAY5D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, short ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_SHORT, 5, expected_dims); if (! array) return NULL; $2 = (short(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, short ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: UCHAR_ARRAY5D */ /**************************************************************/ %define UCHAR_ARRAY5D(DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_UBYTE, 5, expected_dims); if (! array) return NULL; $2 = (u_char(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int *DIM, u_char ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_ARRAY5D */ /**************************************************************/ %define FLOAT_ARRAY5D( DIM, ARRAYNAME, ARRAYSHAPE) %typemap(in) ( int* DIM, float ARRAYNAME##ARRAYSHAPE)(PyArrayObject *array, int expected_dims[5], int intdims[5]) %{ if ($input != Py_None) { expected_dims[0] = $2_dim0; expected_dims[1] = $2_dim1; expected_dims[2] = $2_dim2; expected_dims[3] = $2_dim3; expected_dims[4] = $2_dim4; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; if (expected_dims[2]==1) expected_dims[2]=0; if (expected_dims[3]==1) expected_dims[3]=0; if (expected_dims[4]==1) expected_dims[4]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 5, expected_dims); if (! array) return NULL; $2 = (float(*)[$2_dim1][$2_dim2][$2_dim3][$2_dim4])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; intdims[2] = ((PyArrayObject *)(array))->dimensions[2]; intdims[3] = ((PyArrayObject *)(array))->dimensions[3]; intdims[4] = ((PyArrayObject *)(array))->dimensions[4]; $1 = intdims; } else { array = NULL; $2 = NULL; $1 = NULL; } %} %typemap(freearg) (int* DIM, float ARRAYNAME##ARRAYSHAPE) %{ if ( array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: INT_VECTOR */ /**************************************************************/ %define INT_VECTOR( ARRAYNAME, ARRAYSHAPE, LENGTH ) %typemap(in) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_INT, 1, expected_dims); if (! array) return NULL; $1 = (int *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_VECTOR */ /**************************************************************/ %define FLOAT_VECTOR( ARRAYNAME, ARRAYSHAPE, LENGTH ) %typemap(in) (float ARRAYNAME##ARRAYSHAPE, int LENGTH) (PyArrayObject *array, int expected_dims[1]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; if (expected_dims[0]==1) expected_dims[0]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 1, expected_dims); if (! array) return NULL; $1 = (float *)array->data; $2 = ((PyArrayObject *)(array))->dimensions[0]; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int LENGTH) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: INT_ARRAY2D */ /**************************************************************/ %define INT_ARRAY2D( ARRAYNAME, ARRAYSHAPE, DIMENSIONS ) %typemap(in) ( int ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS)(PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_INT, 2, expected_dims); if (! array) return NULL; $1 = (int (*)[$1_dim1])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $2 = intdims; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (int ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS) %{ if (array$argnum) Py_DECREF((PyObject *)array$argnum); %} %enddef /**************************************************************/ /* Input: FLOAT_ARRAY2D */ /**************************************************************/ %define FLOAT_ARRAY2D( ARRAYNAME, ARRAYSHAPE, DIMENSIONS ) %typemap(in) ( float ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS)(PyArrayObject *array, int expected_dims[2], int intdims[2]) %{ if ($input != Py_None) { expected_dims[0] = $1_dim0; expected_dims[1] = $1_dim1; if (expected_dims[0]==1) expected_dims[0]=0; if (expected_dims[1]==1) expected_dims[1]=0; array = contiguous_typed_array($input, PyArray_FLOAT, 2, expected_dims); if (! array) return NULL; $1 = (float (*)[$1_dim1])array->data; intdims[0] = ((PyArrayObject *)(array))->dimensions[0]; intdims[1] = ((PyArrayObject *)(array))->dimensions[1]; $2 = intdims; } else { array = NULL; $1 = NULL; $2 = 0; } %} %typemap(freearg) (float ARRAYNAME##ARRAYSHAPE, int* DIMENSIONS ) %{ if (array$argnum ) Py_DECREF((PyObject *)array$argnum); %} %enddef mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/UTmolderivatives/__init__.py0000644000175000017500000000001510321054404030756 0ustar debiandebian#__init__.py mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/README0000644000175000017500000000233510334445443024241 0ustar debiandebianThis package builds a python extension of the MolDerivatives Library (part of TexMol) developed in Chandrajit Bajaj's group at UT Austin (http://ccvweb.csres.utexas.edu/software). See .src/molderivatives-license.txt for the source code license info. Distutils are used to build and install the extension. SWIG (version swig1.3.20 or higher) is used for generating wrappers. (Currently there is no way to specify the version of swig to be used by Distutils - the default version has to be 1.3.20 or the one that automatically generates python shadow classes). To build the extensions and install the package: python2.4 setup.py install This will: - build _molderivatives.so and molderivatives.py(python shadow classes) in ./build/lib./UTpackages/UTmolderivatives; - install the UTmolderivatives package in sys.exec_prefix/lib/python2.4/site-packages/UTpackages. To specify an installation directory (INSTALL_DIR): python2.4 setup.py install --install-platlib=INSTALL_DIR To build the extension only: python2.4 setup.py build This will create ./build directory and build the extension there. To build source distribution: python2.4 setup.py sdist To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/UTmolderivativesDIST/MANIFEST.in0000644000175000017500000000050510334445443025114 0ustar debiandebianinclude MANIFEST.in include UTmolderivatives/*.i exclude UTmolderivatives/molderivatives.py include src/Curvatures/* include src/UsefulMath/* include src/molderivatives-license.txt include src/Readme.htm include CVS/* include UTmolderivatives/CVS/* include src/CVS/* include src/Curvatures/CVS/* include src/UsefulMath/CVS/*mgltools-utpackages-1.5.7~rc1~cvs.20130519/version.py0000644000175000017500000000002011475262517021421 0ustar debiandebianVERSION="1.5.6" mgltools-utpackages-1.5.7~rc1~cvs.20130519/README0000644000175000017500000000270310260336734020246 0ustar debiandebianThis module builds and installs python extensions of four C++ libraries developed in Chandrajit Bajaj's group at UT Austin (HTTP://WWW.ICES.UTEXAS.EDU/CCV). This distribution contains the following modules: - UTblurDIST(the blurring algorithm extracted from the PDB Blurring software); - UTisocontourDIST (the isocontouring library); - UTUTvolrendDIST (volume rendering library); - UTmeshDIST (Level set Boundary Interior and Exterior Mesher - LBIEMesher). These modules contain "setup.py" scripts to build and install UTblur, UTisocontour, UTvolrend and UTmesh packages into sys.exec_prefix/lib/python2.4/site-packages/UTpackages (or UserSpecifiedDir/UTpackages). Distutils are used to wrap the library with SWIG (version 1.3.20 or higher) and build the python extensions. To build and install the packages: python2.4 setup.py install This will install UTblur, UTisocontour, UTvolrend and UTmesh packages into sys.exec_prefix/lib/python2.4/site-packages/UTpackages. The install command can be called with the following options: --install-platlib=UserSpecifiedDir installs the packages in UserSpecifiedDir/UTpackages --no-compile do not compile .py to .pyc Example: python2.4 setup.py install --install-platlib=/home/myname/myinstalldir To build and install any single package see README file of the package. To build source distribution: python2.4 setup.py sdist To build binary distribution: python2.4 setup.py bdist mgltools-utpackages-1.5.7~rc1~cvs.20130519/MANIFEST.in0000644000175000017500000000015410334434034021114 0ustar debiandebianinclude MANIFEST.in include version.py include UTpackages_license.txt include CVS/* include UTpackages/CVS/*

  • > { }; } // namespace boost #endif // POINTEE_DWA200415_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/nondet_random.hpp0000644000175000017500000000376111344301501031010 0ustar debiandebian/* boost nondet_random.hpp header file * * Copyright Jens Maurer 2000 * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * $Id: nondet_random.hpp,v 1.1.1.1 2010/03/05 22:18:41 annao Exp $ * * Revision history * 2000-02-18 Portability fixes (thanks to Beman Dawes) */ // See http://www.boost.org/libs/random for documentation. #ifndef BOOST_NONDET_RANDOM_HPP #define BOOST_NONDET_RANDOM_HPP #include // std::abs #include // std::min #include #include #include // noncopyable #include // compile-time integral limits namespace boost { // use some OS service to generate non-deterministic random numbers class random_device : private noncopyable { public: typedef unsigned int result_type; BOOST_STATIC_CONSTANT(bool, has_fixed_range = true); BOOST_STATIC_CONSTANT(result_type, min_value = integer_traits::const_min); BOOST_STATIC_CONSTANT(result_type, max_value = integer_traits::const_max); result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return min_value; } result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return max_value; } explicit random_device(const std::string& token = default_token); ~random_device(); double entropy() const; unsigned int operator()(); private: static const char * const default_token; /* * std:5.3.5/5 [expr.delete]: "If the object being deleted has incomplete * class type at the point of deletion and the complete class has a * non-trivial destructor [...], the behavior is undefined". * This disallows the use of scoped_ptr<> with pimpl-like classes * having a non-trivial destructor. */ class impl; impl * pimpl; }; // TODO: put Schneier's Yarrow-160 algorithm here. } // namespace boost #endif /* BOOST_NONDET_RANDOM_HPP */ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/rational.hpp0000644000175000017500000003634111344301501027772 0ustar debiandebian// Boost rational.hpp header file ------------------------------------------// // (C) Copyright Paul Moore 1999. Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or // implied warranty, and with no claim as to its suitability for any purpose. // See http://www.boost.org/libs/rational for documentation. // Credits: // Thanks to the boost mailing list in general for useful comments. // Particular contributions included: // Andrew D Jewell, for reminding me to take care to avoid overflow // Ed Brey, for many comments, including picking up on some dreadful typos // Stephen Silver contributed the test suite and comments on user-defined // IntType // Nickolay Mladenov, for the implementation of operator+= // Revision History // 28 Sep 02 Use _left versions of operators from operators.hpp // 05 Jul 01 Recode gcd(), avoiding std::swap (Helmut Zeisel) // 03 Mar 01 Workarounds for Intel C++ 5.0 (David Abrahams) // 05 Feb 01 Update operator>> to tighten up input syntax // 05 Feb 01 Final tidy up of gcd code prior to the new release // 27 Jan 01 Recode abs() without relying on abs(IntType) // 21 Jan 01 Include Nickolay Mladenov's operator+= algorithm, // tidy up a number of areas, use newer features of operators.hpp // (reduces space overhead to zero), add operator!, // introduce explicit mixed-mode arithmetic operations // 12 Jan 01 Include fixes to handle a user-defined IntType better // 19 Nov 00 Throw on divide by zero in operator /= (John (EBo) David) // 23 Jun 00 Incorporate changes from Mark Rodgers for Borland C++ // 22 Jun 00 Change _MSC_VER to BOOST_MSVC so other compilers are not // affected (Beman Dawes) // 6 Mar 00 Fix operator-= normalization, #include (Jens Maurer) // 14 Dec 99 Modifications based on comments from the boost list // 09 Dec 99 Initial Version (Paul Moore) #ifndef BOOST_RATIONAL_HPP #define BOOST_RATIONAL_HPP #include // for std::istream and std::ostream #include // for std::noskipws #include // for std::domain_error #include // for std::string implicit constructor #include // for boost::addable etc #include // for std::abs #include // for boost::call_traits #include // for BOOST_NO_STDC_NAMESPACE, BOOST_MSVC namespace boost { // Note: We use n and m as temporaries in this function, so there is no value // in using const IntType& as we would only need to make a copy anyway... template IntType gcd(IntType n, IntType m) { // Avoid repeated construction IntType zero(0); // This is abs() - given the existence of broken compilers with Koenig // lookup issues and other problems, I code this explicitly. (Remember, // IntType may be a user-defined type). if (n < zero) n = -n; if (m < zero) m = -m; // As n and m are now positive, we can be sure that %= returns a // positive value (the standard guarantees this for built-in types, // and we require it of user-defined types). for(;;) { if(m == zero) return n; n %= m; if(n == zero) return m; m %= n; } } template IntType lcm(IntType n, IntType m) { // Avoid repeated construction IntType zero(0); if (n == zero || m == zero) return zero; n /= gcd(n, m); n *= m; if (n < zero) n = -n; return n; } class bad_rational : public std::domain_error { public: explicit bad_rational() : std::domain_error("bad rational: zero denominator") {} }; template class rational; template rational abs(const rational& r); template class rational : less_than_comparable < rational, equality_comparable < rational, less_than_comparable2 < rational, IntType, equality_comparable2 < rational, IntType, addable < rational, subtractable < rational, multipliable < rational, dividable < rational, addable2 < rational, IntType, subtractable2 < rational, IntType, subtractable2_left < rational, IntType, multipliable2 < rational, IntType, dividable2 < rational, IntType, dividable2_left < rational, IntType, incrementable < rational, decrementable < rational > > > > > > > > > > > > > > > > { typedef IntType int_type; typedef typename boost::call_traits::param_type param_type; public: rational() : num(0), den(1) {} rational(param_type n) : num(n), den(1) {} rational(param_type n, param_type d) : num(n), den(d) { normalize(); } // Default copy constructor and assignment are fine // Add assignment from IntType rational& operator=(param_type n) { return assign(n, 1); } // Assign in place rational& assign(param_type n, param_type d); // Access to representation IntType numerator() const { return num; } IntType denominator() const { return den; } // Arithmetic assignment operators rational& operator+= (const rational& r); rational& operator-= (const rational& r); rational& operator*= (const rational& r); rational& operator/= (const rational& r); rational& operator+= (param_type i); rational& operator-= (param_type i); rational& operator*= (param_type i); rational& operator/= (param_type i); // Increment and decrement const rational& operator++(); const rational& operator--(); // Operator not bool operator!() const { return !num; } // Comparison operators bool operator< (const rational& r) const; bool operator== (const rational& r) const; bool operator< (param_type i) const; bool operator> (param_type i) const; bool operator== (param_type i) const; private: // Implementation - numerator and denominator (normalized). // Other possibilities - separate whole-part, or sign, fields? IntType num; IntType den; // Representation note: Fractions are kept in normalized form at all // times. normalized form is defined as gcd(num,den) == 1 and den > 0. // In particular, note that the implementation of abs() below relies // on den always being positive. void normalize(); }; // Assign in place template inline rational& rational::assign(param_type n, param_type d) { num = n; den = d; normalize(); return *this; } // Unary plus and minus template inline rational operator+ (const rational& r) { return r; } template inline rational operator- (const rational& r) { return rational(-r.numerator(), r.denominator()); } // Arithmetic assignment operators template rational& rational::operator+= (const rational& r) { // This calculation avoids overflow, and minimises the number of expensive // calculations. Thanks to Nickolay Mladenov for this algorithm. // // Proof: // We have to compute a/b + c/d, where gcd(a,b)=1 and gcd(b,c)=1. // Let g = gcd(b,d), and b = b1*g, d=d1*g. Then gcd(b1,d1)=1 // // The result is (a*d1 + c*b1) / (b1*d1*g). // Now we have to normalize this ratio. // Let's assume h | gcd((a*d1 + c*b1), (b1*d1*g)), and h > 1 // If h | b1 then gcd(h,d1)=1 and hence h|(a*d1+c*b1) => h|a. // But since gcd(a,b1)=1 we have h=1. // Similarly h|d1 leads to h=1. // So we have that h | gcd((a*d1 + c*b1) , (b1*d1*g)) => h|g // Finally we have gcd((a*d1 + c*b1), (b1*d1*g)) = gcd((a*d1 + c*b1), g) // Which proves that instead of normalizing the result, it is better to // divide num and den by gcd((a*d1 + c*b1), g) // Protect against self-modification IntType r_num = r.num; IntType r_den = r.den; IntType g = gcd(den, r_den); den /= g; // = b1 from the calculations above num = num * (r_den / g) + r_num * den; g = gcd(num, g); num /= g; den *= r_den/g; return *this; } template rational& rational::operator-= (const rational& r) { // Protect against self-modification IntType r_num = r.num; IntType r_den = r.den; // This calculation avoids overflow, and minimises the number of expensive // calculations. It corresponds exactly to the += case above IntType g = gcd(den, r_den); den /= g; num = num * (r_den / g) - r_num * den; g = gcd(num, g); num /= g; den *= r_den/g; return *this; } template rational& rational::operator*= (const rational& r) { // Protect against self-modification IntType r_num = r.num; IntType r_den = r.den; // Avoid overflow and preserve normalization IntType gcd1 = gcd(num, r_den); IntType gcd2 = gcd(r_num, den); num = (num/gcd1) * (r_num/gcd2); den = (den/gcd2) * (r_den/gcd1); return *this; } template rational& rational::operator/= (const rational& r) { // Protect against self-modification IntType r_num = r.num; IntType r_den = r.den; // Avoid repeated construction IntType zero(0); // Trap division by zero if (r_num == zero) throw bad_rational(); if (num == zero) return *this; // Avoid overflow and preserve normalization IntType gcd1 = gcd(num, r_num); IntType gcd2 = gcd(r_den, den); num = (num/gcd1) * (r_den/gcd2); den = (den/gcd2) * (r_num/gcd1); if (den < zero) { num = -num; den = -den; } return *this; } // Mixed-mode operators template inline rational& rational::operator+= (param_type i) { return operator+= (rational(i)); } template inline rational& rational::operator-= (param_type i) { return operator-= (rational(i)); } template inline rational& rational::operator*= (param_type i) { return operator*= (rational(i)); } template inline rational& rational::operator/= (param_type i) { return operator/= (rational(i)); } // Increment and decrement template inline const rational& rational::operator++() { // This can never denormalise the fraction num += den; return *this; } template inline const rational& rational::operator--() { // This can never denormalise the fraction num -= den; return *this; } // Comparison operators template bool rational::operator< (const rational& r) const { // Avoid repeated construction IntType zero(0); // If the two values have different signs, we don't need to do the // expensive calculations below. We take advantage here of the fact // that the denominator is always positive. if (num < zero && r.num >= zero) // -ve < +ve return true; if (num >= zero && r.num <= zero) // +ve or zero is not < -ve or zero return false; // Avoid overflow IntType gcd1 = gcd(num, r.num); IntType gcd2 = gcd(r.den, den); return (num/gcd1) * (r.den/gcd2) < (den/gcd2) * (r.num/gcd1); } template bool rational::operator< (param_type i) const { // Avoid repeated construction IntType zero(0); // If the two values have different signs, we don't need to do the // expensive calculations below. We take advantage here of the fact // that the denominator is always positive. if (num < zero && i >= zero) // -ve < +ve return true; if (num >= zero && i <= zero) // +ve or zero is not < -ve or zero return false; // Now, use the fact that n/d truncates towards zero as long as n and d // are both positive. // Divide instead of multiplying to avoid overflow issues. Of course, // division may be slower, but accuracy is more important than speed... if (num > zero) return (num/den) < i; else return -i < (-num/den); } template bool rational::operator> (param_type i) const { // Trap equality first if (num == i && den == IntType(1)) return false; // Otherwise, we can use operator< return !operator<(i); } template inline bool rational::operator== (const rational& r) const { return ((num == r.num) && (den == r.den)); } template inline bool rational::operator== (param_type i) const { return ((den == IntType(1)) && (num == i)); } // Normalisation template void rational::normalize() { // Avoid repeated construction IntType zero(0); if (den == zero) throw bad_rational(); // Handle the case of zero separately, to avoid division by zero if (num == zero) { den = IntType(1); return; } IntType g = gcd(num, den); num /= g; den /= g; // Ensure that the denominator is positive if (den < zero) { num = -num; den = -den; } } namespace detail { // A utility class to reset the format flags for an istream at end // of scope, even in case of exceptions struct resetter { resetter(std::istream& is) : is_(is), f_(is.flags()) {} ~resetter() { is_.flags(f_); } std::istream& is_; std::istream::fmtflags f_; // old GNU c++ lib has no ios_base }; } // Input and output template std::istream& operator>> (std::istream& is, rational& r) { IntType n = IntType(0), d = IntType(1); char c = 0; detail::resetter sentry(is); is >> n; c = is.get(); if (c != '/') is.clear(std::istream::badbit); // old GNU c++ lib has no ios_base #if !defined(__GNUC__) || (defined(__GNUC__) && (__GNUC__ >= 3)) || defined __SGI_STL_PORT is >> std::noskipws; #else is.unsetf(ios::skipws); // compiles, but seems to have no effect. #endif is >> d; if (is) r.assign(n, d); return is; } // Add manipulators for output format? template std::ostream& operator<< (std::ostream& os, const rational& r) { os << r.numerator() << '/' << r.denominator(); return os; } // Type conversion template inline T rational_cast(const rational& src) { return static_cast(src.numerator())/src.denominator(); } // Do not use any abs() defined on IntType - it isn't worth it, given the // difficulties involved (Koenig lookup required, there may not *be* an abs() // defined, etc etc). template inline rational abs(const rational& r) { if (r.numerator() >= IntType(0)) return r; return rational(-r.numerator(), r.denominator()); } } // namespace boost #endif // BOOST_RATIONAL_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/smart_ptr.hpp0000644000175000017500000000133711344301501030171 0ustar debiandebian// // smart_ptr.hpp // // For convenience, this header includes the rest of the smart // pointer library headers. // // Copyright (c) 2003 Peter Dimov Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // http://www.boost.org/libs/smart_ptr/smart_ptr.htm // #include #include #include #include #include #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES) # include # include # include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/function_equal.hpp0000644000175000017500000000133711344301501031172 0ustar debiandebian// Copyright Douglas Gregor 2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org #ifndef BOOST_FUNCTION_EQUAL_HPP #define BOOST_FUNCTION_EQUAL_HPP namespace boost { namespace detail { template bool function_equal_impl(const F& f, const G& g, long) { return f == g; } } // end namespace boost::function template bool function_equal(const F& f, const G& g) { return ::boost::detail::function_equal_impl(f, g, 0); } } // end namespace boost #endif // BOOST_FUNCTION_EQUAL_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/range.hpp0000644000175000017500000000116111344301501027245 0ustar debiandebian// Boost.Range library // // Copyright Thorsten Ottosen 2003-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_HPP_27_07_04 #define BOOST_RANGE_HPP_27_07_04 #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif #include #include #include #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/state_saver.hpp0000644000175000017500000000504011344301501030471 0ustar debiandebian#ifndef BOOST_STATE_SAVER_HPP #define BOOST_STATE_SAVER_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // state_saver.hpp: // (C) Copyright 2003-4 Pavel Vozenilek and Robert Ramey - http://www.rrsd.com. // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. // Inspired by Daryle Walker's iostate_saver concept. This saves the original // value of a variable when a state_saver is constructed and restores // upon destruction. Useful for being sure that state is restored to // variables upon exit from scope. #include #ifndef BOOST_NO_EXCEPTIONS #include #endif #include #include #include #include #include namespace boost { template // T requirements: // - POD or object semantic (cannot be reference, function, ...) // - copy constructor // - operator = (no-throw one preferred) class state_saver : private boost::noncopyable { private: const T previous_value; T & previous_ref; struct restore { static void invoke(T & previous_ref, const T & previous_value){ previous_ref = previous_value; // won't throw } }; struct restore_with_exception { static void invoke(T & previous_ref, const T & previous_value){ #ifndef BOOST_NO_EXCEPTIONS try{ previous_ref = previous_value; } catch(::std::exception &) { // we must ignore it - we are in destructor } #else previous_ref = previous_value; #endif } }; public: state_saver( T & object ) : previous_value(object), previous_ref(object) {} ~state_saver() { typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< has_nothrow_copy, mpl::identity, mpl::identity >::type typex; typex::invoke(previous_ref, previous_value); } }; // state_saver<> } // boost #undef BOOST_TRY #undef BOOST_CATCH #endif //BOOST_STATE_SAVER_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/throw_exception.hpp0000644000175000017500000000156411344301501031401 0ustar debiandebian#ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED #define BOOST_THROW_EXCEPTION_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/throw_exception.hpp // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // http://www.boost.org/libs/utility/throw_exception.html // #include #ifdef BOOST_NO_EXCEPTIONS # include #endif namespace boost { #ifdef BOOST_NO_EXCEPTIONS void throw_exception(std::exception const & e); // user defined #else template inline void throw_exception(E const & e) { throw e; } #endif } // namespace boost #endif // #ifndef BOOST_THROW_EXCEPTION_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/function.hpp0000644000175000017500000000405211344301501030000 0ustar debiandebian// Boost.Function library // Copyright Douglas Gregor 2001-2003. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/function // William Kempf, Jesse Jones and Karl Nelson were all very helpful in the // design of this library. #include #include #ifndef BOOST_FUNCTION_MAX_ARGS # define BOOST_FUNCTION_MAX_ARGS 10 #endif // BOOST_FUNCTION_MAX_ARGS // Include the prologue here so that the use of file-level iteration // in anything that may be included by function_template.hpp doesn't break #include // Visual Age C++ doesn't handle the file iteration well #if BOOST_WORKAROUND(__IBMCPP__, <= 600) # if BOOST_FUNCTION_MAX_ARGS >= 0 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 1 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 2 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 3 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 4 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 5 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 6 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 7 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 8 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 9 # include # endif # if BOOST_FUNCTION_MAX_ARGS >= 10 # include # endif #else // What is the '3' for? # define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_FUNCTION_MAX_ARGS,)) # include BOOST_PP_ITERATE() # undef BOOST_PP_ITERATION_PARAMS_1 #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/integer.hpp0000644000175000017500000001122711344301501027612 0ustar debiandebian// boost integer.hpp header file -------------------------------------------// // Copyright Beman Dawes and Daryle Walker 1999. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/integer for documentation. // Revision History // 22 Sep 01 Added value-based integer templates. (Daryle Walker) // 01 Apr 01 Modified to use new header. (John Maddock) // 30 Jul 00 Add typename syntax fix (Jens Maurer) // 28 Aug 99 Initial version #ifndef BOOST_INTEGER_HPP #define BOOST_INTEGER_HPP #include // self include #include // for boost::integer_traits #include // for std::numeric_limits namespace boost { // Helper templates ------------------------------------------------------// // fast integers from least integers // int_fast_t<> works correctly for unsigned too, in spite of the name. template< typename LeastInt > struct int_fast_t { typedef LeastInt fast; }; // imps may specialize // convert category to type template< int Category > struct int_least_helper {}; // default is empty // specializatons: 1=long, 2=int, 3=short, 4=signed char, // 6=unsigned long, 7=unsigned int, 8=unsigned short, 9=unsigned long // no specializations for 0 and 5: requests for a type > long are in error template<> struct int_least_helper<1> { typedef long least; }; template<> struct int_least_helper<2> { typedef int least; }; template<> struct int_least_helper<3> { typedef short least; }; template<> struct int_least_helper<4> { typedef signed char least; }; template<> struct int_least_helper<6> { typedef unsigned long least; }; template<> struct int_least_helper<7> { typedef unsigned int least; }; template<> struct int_least_helper<8> { typedef unsigned short least; }; template<> struct int_least_helper<9> { typedef unsigned char least; }; // integer templates specifying number of bits ---------------------------// // signed template< int Bits > // bits (including sign) required struct int_t { typedef typename int_least_helper < (Bits-1 <= std::numeric_limits::digits) + (Bits-1 <= std::numeric_limits::digits) + (Bits-1 <= std::numeric_limits::digits) + (Bits-1 <= std::numeric_limits::digits) >::least least; typedef typename int_fast_t::fast fast; }; // unsigned template< int Bits > // bits required struct uint_t { typedef typename int_least_helper < 5 + (Bits <= std::numeric_limits::digits) + (Bits <= std::numeric_limits::digits) + (Bits <= std::numeric_limits::digits) + (Bits <= std::numeric_limits::digits) >::least least; typedef typename int_fast_t::fast fast; // int_fast_t<> works correctly for unsigned too, in spite of the name. }; // integer templates specifying extreme value ----------------------------// // signed template< long MaxValue > // maximum value to require support struct int_max_value_t { typedef typename int_least_helper < (MaxValue <= integer_traits::const_max) + (MaxValue <= integer_traits::const_max) + (MaxValue <= integer_traits::const_max) + (MaxValue <= integer_traits::const_max) >::least least; typedef typename int_fast_t::fast fast; }; template< long MinValue > // minimum value to require support struct int_min_value_t { typedef typename int_least_helper < (MinValue >= integer_traits::const_min) + (MinValue >= integer_traits::const_min) + (MinValue >= integer_traits::const_min) + (MinValue >= integer_traits::const_min) >::least least; typedef typename int_fast_t::fast fast; }; // unsigned template< unsigned long Value > // maximum value to require support struct uint_value_t { typedef typename int_least_helper < 5 + (Value <= integer_traits::const_max) + (Value <= integer_traits::const_max) + (Value <= integer_traits::const_max) + (Value <= integer_traits::const_max) >::least least; typedef typename int_fast_t::fast fast; }; } // namespace boost #endif // BOOST_INTEGER_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/next_prior.hpp0000644000175000017500000000242011344301501030341 0ustar debiandebian// Boost next_prior.hpp header file ---------------------------------------// // (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/utility for documentation. // Revision History // 13 Dec 2003 Added next(x, n) and prior(x, n) (Daniel Walker) #ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED #define BOOST_NEXT_PRIOR_HPP_INCLUDED #include namespace boost { // Helper functions for classes like bidirectional iterators not supporting // operator+ and operator- // // Usage: // const std::list::iterator p = get_some_iterator(); // const std::list::iterator prev = boost::prior(p); // const std::list::iterator next = boost::next(prev, 2); // Contributed by Dave Abrahams template inline T next(T x) { return ++x; } template inline T next(T x, Distance n) { std::advance(x, n); return x; } template inline T prior(T x) { return --x; } template inline T prior(T x, Distance n) { std::advance(x, -n); return x; } } // namespace boost #endif // BOOST_NEXT_PRIOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/iterator.hpp0000644000175000017500000000367211344301501030013 0ustar debiandebian// interator.hpp workarounds for non-conforming standard libraries ---------// // (C) Copyright Beman Dawes 2000. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/utility for documentation. // Revision History // 12 Jan 01 added for std::ptrdiff_t (Jens Maurer) // 28 Jun 00 Workarounds to deal with known MSVC bugs (David Abrahams) // 26 Jun 00 Initial version (Jeremy Siek) #ifndef BOOST_ITERATOR_HPP #define BOOST_ITERATOR_HPP #include #include // std::ptrdiff_t #include namespace boost { # if defined(BOOST_NO_STD_ITERATOR) && !defined(BOOST_MSVC_STD_ITERATOR) template struct iterator { typedef T value_type; typedef Distance difference_type; typedef Pointer pointer; typedef Reference reference; typedef Category iterator_category; }; # else // declare iterator_base in namespace detail to work around MSVC bugs which // prevent derivation from an identically-named class in a different namespace. namespace detail { template # if !defined(BOOST_MSVC_STD_ITERATOR) struct iterator_base : std::iterator {}; # else struct iterator_base : std::iterator { typedef Reference reference; typedef Pointer pointer; typedef Distance difference_type; }; # endif } template struct iterator : detail::iterator_base {}; # endif } // namespace boost #endif // BOOST_ITERATOR_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/iterator_adaptors.hpp0000644000175000017500000000063111344301501031700 0ustar debiandebian// Copyright David Abrahams 2004. Distributed under the Boost // Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef ITERATOR_ADAPTORS_DWA2004725_HPP # define ITERATOR_ADAPTORS_DWA2004725_HPP #define BOOST_ITERATOR_ADAPTORS_VERSION 0x0200 #include #endif // ITERATOR_ADAPTORS_DWA2004725_HPP ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/property_map_iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/property_map_iterator0000644000175000017500000000735711344301501032032 0ustar debiandebian// (C) Copyright Jeremy Siek, 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/property_map for documentation. #ifndef BOOST_PROPERTY_MAP_ITERATOR_HPP #define BOOST_PROPERTY_MAP_ITERATOR_HPP #include #include #include #include namespace boost { //====================================================================== // property iterator, generalized from ideas by François Faure namespace detail { template class lvalue_pmap_iter : public iterator_adaptor< lvalue_pmap_iter< Iterator, LvaluePropertyMap >, Iterator, typename property_traits::value_type, use_default, typename property_traits::reference> { friend class boost::iterator_core_access; typedef iterator_adaptor< lvalue_pmap_iter< Iterator, LvaluePropertyMap >, Iterator, typename property_traits::value_type, use_default, typename property_traits::reference> super_t; public: lvalue_pmap_iter() { } lvalue_pmap_iter(Iterator const& it, LvaluePropertyMap m) : super_t(it), m_map(m) {} private: typename super_t::reference dereference() const { return m_map[*(this->base_reference())]; } LvaluePropertyMap m_map; }; template class readable_pmap_iter : public iterator_adaptor< readable_pmap_iter< Iterator, ReadablePropertyMap >, Iterator, typename property_traits::value_type, use_default, typename property_traits::value_type> { friend class iterator_core_access; typedef iterator_adaptor< readable_pmap_iter< Iterator, ReadablePropertyMap >, Iterator, typename property_traits::value_type, use_default, typename property_traits::value_type> super_t; public: readable_pmap_iter() { } readable_pmap_iter(Iterator const& it, ReadablePropertyMap m) : super_t(it), m_map(m) {} private: typename super_t::reference dereference() const { return get(m_map, *(this->base_reference())); } ReadablePropertyMap m_map; }; } // namespace detail template struct property_map_iterator_generator : mpl::if_< is_same< typename property_traits::category, lvalue_property_map_tag>, detail::lvalue_pmap_iter, detail::readable_pmap_iter > {}; template typename property_map_iterator_generator::type make_property_map_iterator(PropertyMap pmap, Iterator iter) { typedef typename property_map_iterator_generator::type Iter; return Iter(iter, pmap); } } // namespace boost #endif // BOOST_PROPERTY_MAP_ITERATOR_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/strong_typedef.hpp0000644000175000017500000000376311344301501031217 0ustar debiandebian#ifndef BOOST_STRONG_TYPEDEF_HPP #define BOOST_STRONG_TYPEDEF_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // strong_typedef.hpp: // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. // macro used to implement a strong typedef. strong typedef // guarentees that two types are distinguised even though the // share the same underlying implementation. typedef does not create // a new type. BOOST_STRONG_TYPEDEF(T, D) creates a new type named D // that operates as a type T. #include #define BOOST_STRONG_TYPEDEF(T, D) \ struct D \ : boost::totally_ordered1< D \ , boost::totally_ordered2< D, T \ > > \ { \ T t; \ explicit D(const T t_) : t(t_) {}; \ D(){}; \ D(const D & t_) : t(t_.t){} \ D & operator=(const D & rhs) { t = rhs.t; return *this;} \ D & operator=(const T & rhs) { t = rhs; return *this;} \ operator T () const {return t; } \ operator T & () { return t; } \ bool operator==(const D & rhs) const { return t == rhs.t; } \ bool operator<(const D & rhs) const { return t < rhs.t; } \ }; #endif // BOOST_STRONG_TYPEDEF_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/lexical_cast.hpp0000644000175000017500000001311011344301501030601 0ustar debiandebian#ifndef BOOST_LEXICAL_CAST_INCLUDED #define BOOST_LEXICAL_CAST_INCLUDED // Boost lexical_cast.hpp header -------------------------------------------// // // See http://www.boost.org for most recent version including documentation. // See end of this header for rights and permissions. // // what: lexical_cast custom keyword cast // who: contributed by Kevlin Henney, // enhanced with contributions from Terje Slettebø, // with additional fixes and suggestions from Gennaro Prota, // Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov, // and other Boosters // when: November 2000, March 2003 #include #include #include #include #include #include #ifdef BOOST_NO_STRINGSTREAM #include #else #include #endif #if defined(BOOST_NO_STRINGSTREAM) || \ defined(BOOST_NO_STD_WSTRING) || \ defined(BOOST_NO_STD_LOCALE) || \ defined(BOOST_NO_INTRINSIC_WCHAR_T) #define DISABLE_WIDE_CHAR_SUPPORT #endif namespace boost { // exception used to indicate runtime lexical_cast failure class bad_lexical_cast : public std::bad_cast { public: bad_lexical_cast() : source(&typeid(void)), target(&typeid(void)) { } bad_lexical_cast( const std::type_info &s, const std::type_info &t) : source(&s), target(&t) { } const std::type_info &source_type() const { return *source; } const std::type_info &target_type() const { return *target; } virtual const char *what() const throw() { return "bad lexical cast: " "source type value could not be interpreted as target"; } virtual ~bad_lexical_cast() throw() { } private: const std::type_info *source; const std::type_info *target; }; namespace detail // selectors for choosing stream character type { template struct stream_char { typedef char type; }; #ifndef DISABLE_WIDE_CHAR_SUPPORT template<> struct stream_char { typedef wchar_t type; }; template<> struct stream_char { typedef wchar_t type; }; template<> struct stream_char { typedef wchar_t type; }; template<> struct stream_char { typedef wchar_t type; }; #endif template struct widest_char { typedef TargetChar type; }; template<> struct widest_char { typedef wchar_t type; }; } namespace detail // stream wrapper for handling lexical conversions { template class lexical_stream { public: lexical_stream() { stream.unsetf(std::ios::skipws); if(std::numeric_limits::is_specialized) stream.precision(std::numeric_limits::digits10 + 1); else if(std::numeric_limits::is_specialized) stream.precision(std::numeric_limits::digits10 + 1); } ~lexical_stream() { #if defined(BOOST_NO_STRINGSTREAM) stream.freeze(false); #endif } bool operator<<(const Source &input) { return !(stream << input).fail(); } template bool operator>>(InputStreamable &output) { return !is_pointer::value && stream >> output && (stream >> std::ws).eof(); } bool operator>>(std::string &output) { #if defined(BOOST_NO_STRINGSTREAM) stream << '\0'; #endif output = stream.str(); return true; } #ifndef DISABLE_WIDE_CHAR_SUPPORT bool operator>>(std::wstring &output) { output = stream.str(); return true; } #endif private: typedef typename widest_char< typename stream_char::type, typename stream_char::type>::type char_type; #if defined(BOOST_NO_STRINGSTREAM) std::strstream stream; #elif defined(BOOST_NO_STD_LOCALE) std::stringstream stream; #else std::basic_stringstream stream; #endif }; } template Target lexical_cast(Source arg) { detail::lexical_stream interpreter; Target result; if(!(interpreter << arg && interpreter >> result)) throw_exception(bad_lexical_cast(typeid(Target), typeid(Source))); return result; } } // Copyright Kevlin Henney, 2000-2003. All rights reserved. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #undef DISABLE_WIDE_CHAR_SUPPORT #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/progress.hpp0000644000175000017500000001260611344301501030023 0ustar debiandebian// boost progress.hpp header file ------------------------------------------// // Copyright Beman Dawes 1994-99. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/timer for documentation. // Revision History // 1 Dec 01 Add leading progress display strings (suggested by Toon Knapen) // 20 May 01 Introduce several static_casts<> to eliminate warning messages // (Fixed by Beman, reported by Herve Bronnimann) // 12 Jan 01 Change to inline implementation to allow use without library // builds. See docs for more rationale. (Beman Dawes) // 22 Jul 99 Name changed to .hpp // 16 Jul 99 Second beta // 6 Jul 99 Initial boost version #ifndef BOOST_PROGRESS_HPP #define BOOST_PROGRESS_HPP #include #include // for noncopyable #include // for uintmax_t #include // for ostream, cout, etc #include // for string namespace boost { // progress_timer ----------------------------------------------------------// // A progress_timer behaves like a timer except that the destructor displays // an elapsed time message at an appropriate place in an appropriate form. class progress_timer : public timer, private noncopyable { public: explicit progress_timer( std::ostream & os = std::cout ) // os is hint; implementation may ignore, particularly in embedded systems : m_os(os) {} ~progress_timer() { // A) Throwing an exception from a destructor is a Bad Thing. // B) The progress_timer destructor does output which may throw. // C) A progress_timer is usually not critical to the application. // Therefore, wrap the I/O in a try block, catch and ignore all exceptions. try { // use istream instead of ios_base to workaround GNU problem (Greg Chicares) std::istream::fmtflags old_flags = m_os.setf( std::istream::fixed, std::istream::floatfield ); std::streamsize old_prec = m_os.precision( 2 ); m_os << elapsed() << " s\n" // "s" is System International d'Unités std << std::endl; m_os.flags( old_flags ); m_os.precision( old_prec ); } catch (...) {} // eat any exceptions } // ~progress_timer private: std::ostream & m_os; }; // progress_display --------------------------------------------------------// // progress_display displays an appropriate indication of // progress at an appropriate place in an appropriate form. // NOTE: (Jan 12, 2001) Tried to change unsigned long to boost::uintmax_t, but // found some compilers couldn't handle the required conversion to double. // Reverted to unsigned long until the compilers catch up. class progress_display : private noncopyable { public: explicit progress_display( unsigned long expected_count, std::ostream & os = std::cout, const std::string & s1 = "\n", //leading strings const std::string & s2 = "", const std::string & s3 = "" ) // os is hint; implementation may ignore, particularly in embedded systems : m_os(os), m_s1(s1), m_s2(s2), m_s3(s3) { restart(expected_count); } void restart( unsigned long expected_count ) // Effects: display appropriate scale // Postconditions: count()==0, expected_count()==expected_count { _count = _next_tic_count = _tic = 0; _expected_count = expected_count; m_os << m_s1 << "0% 10 20 30 40 50 60 70 80 90 100%\n" << m_s2 << "|----|----|----|----|----|----|----|----|----|----|" << std::endl // endl implies flush, which ensures display << m_s3; if ( !_expected_count ) _expected_count = 1; // prevent divide by zero } // restart unsigned long operator+=( unsigned long increment ) // Effects: Display appropriate progress tic if needed. // Postconditions: count()== original count() + increment // Returns: count(). { if ( (_count += increment) >= _next_tic_count ) { display_tic(); } return _count; } unsigned long operator++() { return operator+=( 1 ); } unsigned long count() const { return _count; } unsigned long expected_count() const { return _expected_count; } private: std::ostream & m_os; // may not be present in all imps const std::string m_s1; // string is more general, safer than const std::string m_s2; // const char *, and efficiency or size are const std::string m_s3; // not issues unsigned long _count, _expected_count, _next_tic_count; unsigned int _tic; void display_tic() { // use of floating point ensures that both large and small counts // work correctly. static_cast<>() is also used several places // to suppress spurious compiler warnings. unsigned int tics_needed = static_cast( (static_cast(_count)/_expected_count)*50.0 ); do { m_os << '*' << std::flush; } while ( ++_tic < tics_needed ); _next_tic_count = static_cast((_tic/50.0)*_expected_count); if ( _count == _expected_count ) { if ( _tic < 51 ) m_os << '*'; m_os << std::endl; } } // display_tic }; } // namespace boost #endif // BOOST_PROGRESS_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/ref.hpp0000644000175000017500000000705211344301501026732 0ustar debiandebian#ifndef BOOST_REF_HPP_INCLUDED #define BOOST_REF_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif #include #include #include // // ref.hpp - ref/cref, useful helper functions // // Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001, 2002 Peter Dimov // Copyright (C) 2002 David Abrahams // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/bind/ref.html for documentation. // namespace boost { template class reference_wrapper { public: typedef T type; #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) explicit reference_wrapper(T& t): t_(&t) {} #else explicit reference_wrapper(T& t): t_(boost::addressof(t)) {} #endif operator T& () const { return *t_; } T& get() const { return *t_; } T* get_pointer() const { return t_; } private: T* t_; }; # if defined(__BORLANDC__) && (__BORLANDC__ <= 0x570) # define BOOST_REF_CONST # else # define BOOST_REF_CONST const # endif template inline reference_wrapper BOOST_REF_CONST ref(T & t) { return reference_wrapper(t); } template inline reference_wrapper BOOST_REF_CONST cref(T const & t) { return reference_wrapper(t); } # undef BOOST_REF_CONST # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template class is_reference_wrapper : public mpl::false_ { }; template class unwrap_reference { public: typedef T type; }; # define AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(X) \ template \ class is_reference_wrapper< X > \ : public mpl::true_ \ { \ }; \ \ template \ class unwrap_reference< X > \ { \ public: \ typedef T type; \ }; \ /**/ AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper) #if !defined(BOOST_NO_CV_SPECIALIZATIONS) AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper const) AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper volatile) AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF(reference_wrapper const volatile) #endif # undef AUX_REFERENCE_WRAPPER_METAFUNCTIONS_DEF # else // no partial specialization } // namespace boost #include namespace boost { namespace detail { typedef char (&yes_reference_wrapper_t)[1]; typedef char (&no_reference_wrapper_t)[2]; no_reference_wrapper_t is_reference_wrapper_test(...); template yes_reference_wrapper_t is_reference_wrapper_test(type< reference_wrapper >); template struct reference_unwrapper { template struct apply { typedef T type; }; }; template<> struct reference_unwrapper { template struct apply { typedef typename T::type type; }; }; } template class is_reference_wrapper { public: BOOST_STATIC_CONSTANT( bool, value = ( sizeof(detail::is_reference_wrapper_test(type())) == sizeof(detail::yes_reference_wrapper_t))); typedef ::boost::mpl::bool_ type; }; template class unwrap_reference : public detail::reference_unwrapper< is_reference_wrapper::value >::template apply {}; # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #endif // #ifndef BOOST_REF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/any.hpp0000644000175000017500000000770111344301501026746 0ustar debiandebian// See http://www.boost.org/libs/any for Documentation. #ifndef BOOST_ANY_INCLUDED #define BOOST_ANY_INCLUDED // what: variant type boost::any // who: contributed by Kevlin Henney, // with features contributed and bugs found by // Ed Brey, Mark Rodgers, Peter Dimov, and James Curran // when: July 2001 // where: tested with BCC 5.5, MSVC 6.0, and g++ 2.95 #include #include #include "boost/config.hpp" #include namespace boost { class any { public: // structors any() : content(0) { } template any(const ValueType & value) : content(new holder(value)) { } any(const any & other) : content(other.content ? other.content->clone() : 0) { } ~any() { delete content; } public: // modifiers any & swap(any & rhs) { std::swap(content, rhs.content); return *this; } template any & operator=(const ValueType & rhs) { any(rhs).swap(*this); return *this; } any & operator=(const any & rhs) { any(rhs).swap(*this); return *this; } public: // queries bool empty() const { return !content; } const std::type_info & type() const { return content ? content->type() : typeid(void); } #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: // types #else public: // types (public so any_cast can be non-friend) #endif class placeholder { public: // structors virtual ~placeholder() { } public: // queries virtual const std::type_info & type() const = 0; virtual placeholder * clone() const = 0; }; template class holder : public placeholder { public: // structors holder(const ValueType & value) : held(value) { } public: // queries virtual const std::type_info & type() const { return typeid(ValueType); } virtual placeholder * clone() const { return new holder(held); } public: // representation ValueType held; }; #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS private: // representation template friend ValueType * any_cast(any *); #else public: // representation (public so any_cast can be non-friend) #endif placeholder * content; }; class bad_any_cast : public std::bad_cast { public: virtual const char * what() const throw() { return "boost::bad_any_cast: " "failed conversion using boost::any_cast"; } }; template ValueType * any_cast(any * operand) { return operand && operand->type() == typeid(ValueType) ? &static_cast *>(operand->content)->held : 0; } template const ValueType * any_cast(const any * operand) { return any_cast(const_cast(operand)); } template ValueType any_cast(const any & operand) { const ValueType * result = any_cast(&operand); if(!result) boost::throw_exception(bad_any_cast()); return *result; } } // Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/random.hpp0000644000175000017500000000572411344301501027442 0ustar debiandebian/* boost random.hpp header file * * Copyright Jens Maurer 2000-2001 * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * See http://www.boost.org/libs/random for documentation. * * $Id: random.hpp,v 1.1.1.1 2010/03/05 22:18:41 annao Exp $ * * Revision history * 2000-02-18 portability fixes (thanks to Beman Dawes) * 2000-02-21 shuffle_output, inversive_congruential_schrage, * generator_iterator, uniform_smallint * 2000-02-23 generic modulus arithmetic helper, removed *_schrage classes, * implemented Streamable and EqualityComparable concepts for * generators, added Bernoulli distribution and Box-Muller * transform * 2000-03-01 cauchy, lognormal, triangle distributions; fixed * uniform_smallint; renamed gaussian to normal distribution * 2000-03-05 implemented iterator syntax for distribution functions * 2000-04-21 removed some optimizations for better BCC/MSVC compatibility * 2000-05-10 adapted to BCC and MSVC * 2000-06-13 incorporated review results * 2000-07-06 moved basic templates from namespace detail to random * 2000-09-23 warning removals and int64 fixes (Ed Brey) * 2000-09-24 added lagged_fibonacci generator (Matthias Troyer) * 2001-02-18 moved to individual header files */ #ifndef BOOST_RANDOM_HPP #define BOOST_RANDOM_HPP // generators #include #include #include #include #include #include #include #include #include namespace boost { typedef random::xor_combine, 0, random::linear_feedback_shift, 0, 0>, 0, random::linear_feedback_shift, 0, 0> taus88; } // namespace boost // misc #include // distributions #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // BOOST_RANDOM_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/assert.hpp0000644000175000017500000000166111344301501027457 0ustar debiandebian// // boost/assert.hpp - BOOST_ASSERT(expr) // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Note: There are no include guards. This is intentional. // // See http://www.boost.org/libs/utility/assert.html for documentation. // #undef BOOST_ASSERT #if defined(BOOST_DISABLE_ASSERTS) # define BOOST_ASSERT(expr) ((void)0) #elif defined(BOOST_ENABLE_ASSERT_HANDLER) #include namespace boost { void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined } // namespace boost #define BOOST_ASSERT(expr) ((expr)? ((void)0): ::boost::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__)) #else # include # define BOOST_ASSERT(expr) assert(expr) #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/math_fwd.hpp0000644000175000017500000000446011344301501027747 0ustar debiandebian// Boost math_fwd.hpp header file ------------------------------------------// // (C) Copyright Hubert Holin and Daryle Walker 2001-2002. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/math for documentation. #ifndef BOOST_MATH_FWD_HPP #define BOOST_MATH_FWD_HPP namespace boost { namespace math { // From ----------------------------------------// template < typename T > class quaternion; template < > class quaternion< float >; template < > class quaternion< double >; template < > class quaternion< long double >; // Also has many function templates (including operators) // From ------------------------------------------// template < typename T > class octonion; template < > class octonion< float >; template < > class octonion< double >; template < > class octonion< long double >; // Also has many function templates (including operators) // From ---------------------------// // Only has function template // From ---------------------------// // Only has function template // From ---------------------------// // Only has function template // From ----------------------------// // Only has function templates // From ---------------------------// // Only has function templates // From -------------------------------------// // Only #includes other headers // From ----------------------------------// template < unsigned long Value1, unsigned long Value2 > struct static_gcd; template < unsigned long Value1, unsigned long Value2 > struct static_lcm; // From ----------------------------------// template < typename IntegerType > class gcd_evaluator; template < typename IntegerType > class lcm_evaluator; // Also has a couple of function templates } // namespace math } // namespace boost #endif // BOOST_MATH_FWD_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/aligned_storage.hpp0000644000175000017500000000562611344301501031312 0ustar debiandebian//----------------------------------------------------------------------------- // boost aligned_storage.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2002-2003 // Eric Friedman, Itay Maman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_ALIGNED_STORAGE_HPP #define BOOST_ALIGNED_STORAGE_HPP #include // for std::size_t #include "boost/config.hpp" #include "boost/detail/workaround.hpp" #include "boost/type_traits/alignment_of.hpp" #include "boost/type_traits/type_with_alignment.hpp" #include "boost/mpl/eval_if.hpp" #include "boost/mpl/identity.hpp" namespace boost { namespace detail { namespace aligned_storage { BOOST_STATIC_CONSTANT( std::size_t , alignment_of_max_align = ::boost::alignment_of::value ); }} // namespace detail::aligned_storage template < std::size_t size_ , std::size_t alignment_ = std::size_t(-1) > class aligned_storage { private: // representation union data_t { char buf[size_]; typename mpl::eval_if_c< alignment_ == std::size_t(-1) , mpl::identity , type_with_alignment >::type align_; } data_; public: // constants BOOST_STATIC_CONSTANT( std::size_t , size = size_ ); BOOST_STATIC_CONSTANT( std::size_t , alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ ) ); #if !BOOST_WORKAROUND(__GNUC__, <= 2) private: // noncopyable aligned_storage(const aligned_storage&); aligned_storage& operator=(const aligned_storage&); #else // gcc2.x public: // _should_ be noncopyable, but GCC compiler emits error aligned_storage(const aligned_storage&); aligned_storage& operator=(const aligned_storage&); #endif // gcc2.x workaround public: // structors aligned_storage() { } ~aligned_storage() { } public: // accessors void* address() { return &data_.buf[0]; } #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200) const void* address() const { return &data_.buf[0]; } #else // MSVC6 const void* address() const; #endif // MSVC6 workaround }; #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) // MSVC6 seems not to like inline functions with const void* returns, so we // declare the following here: template const void* aligned_storage::address() const { return const_cast< aligned_storage* >(this)->address(); } #endif // MSVC6 workaround } // namespace boost #endif // BOOST_ALIGNED_STORAGE_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/checked_delete.hpp0000644000175000017500000000306511344301501031066 0ustar debiandebian#ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED #define BOOST_CHECKED_DELETE_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/checked_delete.hpp // // Copyright (c) 2002, 2003 Peter Dimov // Copyright (c) 2003 Daniel Frey // Copyright (c) 2003 Howard Hinnant // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/utility/checked_delete.html for documentation. // namespace boost { // verify that types are complete for increased safety template inline void checked_delete(T * x) { // intentionally complex - simplification causes regressions typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; (void) sizeof(type_must_be_complete); delete x; } template inline void checked_array_delete(T * x) { typedef char type_must_be_complete[ sizeof(T)? 1: -1 ]; (void) sizeof(type_must_be_complete); delete [] x; } template struct checked_deleter { typedef void result_type; typedef T * argument_type; void operator()(T * x) const { // boost:: disables ADL boost::checked_delete(x); } }; template struct checked_array_deleter { typedef void result_type; typedef T * argument_type; void operator()(T * x) const { boost::checked_array_delete(x); } }; } // namespace boost #endif // #ifndef BOOST_CHECKED_DELETE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/array.hpp0000644000175000017500000001451311344301501027274 0ustar debiandebian/* The following code declares class array, * an STL container (as wrapper) for arrays of constant size. * * See * http://www.josuttis.com/cppcode * for details and the latest version. * See * http://www.boost.org/libs/array for Documentation. * for documentation. * * (C) Copyright Nicolai M. Josuttis 2001. * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * 29 Jan 2004 - c_array() added, BOOST_NO_PRIVATE_IN_AGGREGATE removed (Nico Josuttis) * 23 Aug 2002 - fix for Non-MSVC compilers combined with MSVC libraries. * 05 Aug 2001 - minor update (Nico Josuttis) * 20 Jan 2001 - STLport fix (Beman Dawes) * 29 Sep 2000 - Initial Revision (Nico Josuttis) * * Jan 29, 2004 */ #ifndef BOOST_ARRAY_HPP #define BOOST_ARRAY_HPP #include #include #include // Handles broken standard libraries better than #include #include // FIXES for broken compilers #include namespace boost { template class array { public: T elems[N]; // fixed-size array of elements of type T public: // type definitions typedef T value_type; typedef T* iterator; typedef const T* const_iterator; typedef T& reference; typedef const T& const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; // iterator support iterator begin() { return elems; } const_iterator begin() const { return elems; } iterator end() { return elems+N; } const_iterator end() const { return elems+N; } // reverse iterator support #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; #elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310) // workaround for broken reverse_iterator in VC7 typedef std::reverse_iterator > reverse_iterator; typedef std::reverse_iterator > const_reverse_iterator; #else // workaround for broken reverse_iterator implementations typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; #endif reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } // operator[] reference operator[](size_type i) { BOOST_ASSERT( i < N && "out of range" ); return elems[i]; } const_reference operator[](size_type i) const { BOOST_ASSERT( i < N && "out of range" ); return elems[i]; } // at() with range check reference at(size_type i) { rangecheck(i); return elems[i]; } const_reference at(size_type i) const { rangecheck(i); return elems[i]; } // front() and back() reference front() { return elems[0]; } const_reference front() const { return elems[0]; } reference back() { return elems[N-1]; } const_reference back() const { return elems[N-1]; } // size is constant static size_type size() { return N; } static bool empty() { return false; } static size_type max_size() { return N; } enum { static_size = N }; // swap (note: linear complexity) void swap (array& y) { std::swap_ranges(begin(),end(),y.begin()); } // direct access to data (read-only) const T* data() const { return elems; } // use array as C array (direct read/write access to data) T* c_array() { return elems; } // assignment with type conversion template array& operator= (const array& rhs) { std::copy(rhs.begin(),rhs.end(), begin()); return *this; } // assign one value to all elements void assign (const T& value) { std::fill_n(begin(),size(),value); } // check range (may be private because it is static) static void rangecheck (size_type i) { if (i >= size()) { throw std::range_error("array<>: index out of range"); } } }; // comparisons template bool operator== (const array& x, const array& y) { return std::equal(x.begin(), x.end(), y.begin()); } template bool operator< (const array& x, const array& y) { return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end()); } template bool operator!= (const array& x, const array& y) { return !(x==y); } template bool operator> (const array& x, const array& y) { return y bool operator<= (const array& x, const array& y) { return !(y bool operator>= (const array& x, const array& y) { return !(x inline void swap (array& x, array& y) { x.swap(y); } } /* namespace boost */ #endif /*BOOST_ARRAY_HPP*/ mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/bind.hpp0000644000175000017500000013472611344301501027103 0ustar debiandebian#ifndef BOOST_BIND_HPP_INCLUDED #define BOOST_BIND_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // bind.hpp - binds function objects to arguments // // Copyright (c) 2001-2004 Peter Dimov and Multi Media Ltd. // Copyright (c) 2001 David Abrahams // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/bind/bind.html for documentation. // #include #include #include #include #include #include // Borland-specific bug, visit_each() silently fails to produce code #if defined(__BORLANDC__) # define BOOST_BIND_VISIT_EACH boost::visit_each #else # define BOOST_BIND_VISIT_EACH visit_each #endif #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable: 4512) // assignment operator could not be generated #endif namespace boost { namespace _bi // implementation details { // result_traits template struct result_traits { typedef R type; }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) struct unspecified {}; template struct result_traits { typedef typename F::result_type type; }; template struct result_traits< unspecified, reference_wrapper > { typedef typename F::result_type type; }; #endif // ref_compare template bool ref_compare(T const & a, T const & b, long) { return a == b; } template bool ref_compare(reference_wrapper const & a, reference_wrapper const & b, int) { return a.get_pointer() == b.get_pointer(); } // bind_t forward declaration for listN template class bind_t; // value template class value { public: value(T const & t): t_(t) {} T & get() { return t_; } T const & get() const { return t_; } bool operator==(value const & rhs) const { return t_ == rhs.t_; } private: T t_; }; // type template class type {}; // unwrap template inline F & unwrap(F * f, long) { return *f; } template inline F & unwrap(reference_wrapper * f, int) { return f->get(); } template inline F & unwrap(reference_wrapper const * f, int) { return f->get(); } #if !( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) ) template inline _mfi::dm unwrap(R T::* * pm, int) { return _mfi::dm(*pm); } #if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) // IBM/VisualAge 6.0 is not able to handle this overload. template inline _mfi::dm unwrap(R T::* const * pm, int) { return _mfi::dm(*pm); } #endif #endif // listN class list0 { public: list0() {} template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A &, long) { return unwrap(&f, 0)(); } template R operator()(type, F const & f, A &, long) const { return unwrap(&f, 0)(); } template void operator()(type, F & f, A &, int) { unwrap(&f, 0)(); } template void operator()(type, F const & f, A &, int) const { unwrap(&f, 0)(); } template void accept(V &) const { } bool operator==(list0 const &) const { return true; } }; template class list1 { public: explicit list1(A1 a1): a1_(a1) {} A1 operator[] (boost::arg<1>) const { return a1_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); } bool operator==(list1 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0); } private: A1 a1_; }; template class list2 { public: list2(A1 a1, A2 a2): a1_(a1), a2_(a2) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); } bool operator==(list2 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0); } private: A1 a1_; A2 a2_; }; template class list3 { public: list3(A1 a1, A2 a2, A3 a3): a1_(a1), a2_(a2), a3_(a3) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); } bool operator==(list3 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0); } private: A1 a1_; A2 a2_; A3 a3_; }; template class list4 { public: list4(A1 a1, A2 a2, A3 a3, A4 a4): a1_(a1), a2_(a2), a3_(a3), a4_(a4) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A4 operator[] (boost::arg<4>) const { return a4_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } A4 operator[] (boost::arg<4> (*) ()) const { return a4_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); BOOST_BIND_VISIT_EACH(v, a4_, 0); } bool operator==(list4 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) && ref_compare(a4_, rhs.a4_, 0); } private: A1 a1_; A2 a2_; A3 a3_; A4 a4_; }; template class list5 { public: list5(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A4 operator[] (boost::arg<4>) const { return a4_; } A5 operator[] (boost::arg<5>) const { return a5_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } A4 operator[] (boost::arg<4> (*) ()) const { return a4_; } A5 operator[] (boost::arg<5> (*) ()) const { return a5_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); BOOST_BIND_VISIT_EACH(v, a4_, 0); BOOST_BIND_VISIT_EACH(v, a5_, 0); } bool operator==(list5 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) && ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0); } private: A1 a1_; A2 a2_; A3 a3_; A4 a4_; A5 a5_; }; template class list6 { public: list6(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A4 operator[] (boost::arg<4>) const { return a4_; } A5 operator[] (boost::arg<5>) const { return a5_; } A6 operator[] (boost::arg<6>) const { return a6_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } A4 operator[] (boost::arg<4> (*) ()) const { return a4_; } A5 operator[] (boost::arg<5> (*) ()) const { return a5_; } A6 operator[] (boost::arg<6> (*) ()) const { return a6_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); BOOST_BIND_VISIT_EACH(v, a4_, 0); BOOST_BIND_VISIT_EACH(v, a5_, 0); BOOST_BIND_VISIT_EACH(v, a6_, 0); } bool operator==(list6 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) && ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0); } private: A1 a1_; A2 a2_; A3 a3_; A4 a4_; A5 a5_; A6 a6_; }; template class list7 { public: list7(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A4 operator[] (boost::arg<4>) const { return a4_; } A5 operator[] (boost::arg<5>) const { return a5_; } A6 operator[] (boost::arg<6>) const { return a6_; } A7 operator[] (boost::arg<7>) const { return a7_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } A4 operator[] (boost::arg<4> (*) ()) const { return a4_; } A5 operator[] (boost::arg<5> (*) ()) const { return a5_; } A6 operator[] (boost::arg<6> (*) ()) const { return a6_; } A7 operator[] (boost::arg<7> (*) ()) const { return a7_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); BOOST_BIND_VISIT_EACH(v, a4_, 0); BOOST_BIND_VISIT_EACH(v, a5_, 0); BOOST_BIND_VISIT_EACH(v, a6_, 0); BOOST_BIND_VISIT_EACH(v, a7_, 0); } bool operator==(list7 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) && ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) && ref_compare(a7_, rhs.a7_, 0); } private: A1 a1_; A2 a2_; A3 a3_; A4 a4_; A5 a5_; A6 a6_; A7 a7_; }; template class list8 { public: list8(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A4 operator[] (boost::arg<4>) const { return a4_; } A5 operator[] (boost::arg<5>) const { return a5_; } A6 operator[] (boost::arg<6>) const { return a6_; } A7 operator[] (boost::arg<7>) const { return a7_; } A8 operator[] (boost::arg<8>) const { return a8_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } A4 operator[] (boost::arg<4> (*) ()) const { return a4_; } A5 operator[] (boost::arg<5> (*) ()) const { return a5_; } A6 operator[] (boost::arg<6> (*) ()) const { return a6_; } A7 operator[] (boost::arg<7> (*) ()) const { return a7_; } A8 operator[] (boost::arg<8> (*) ()) const { return a8_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); BOOST_BIND_VISIT_EACH(v, a4_, 0); BOOST_BIND_VISIT_EACH(v, a5_, 0); BOOST_BIND_VISIT_EACH(v, a6_, 0); BOOST_BIND_VISIT_EACH(v, a7_, 0); BOOST_BIND_VISIT_EACH(v, a8_, 0); } bool operator==(list8 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) && ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) && ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0); } private: A1 a1_; A2 a2_; A3 a3_; A4 a4_; A5 a5_; A6 a6_; A7 a7_; A8 a8_; }; template class list9 { public: list9(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9): a1_(a1), a2_(a2), a3_(a3), a4_(a4), a5_(a5), a6_(a6), a7_(a7), a8_(a8), a9_(a9) {} A1 operator[] (boost::arg<1>) const { return a1_; } A2 operator[] (boost::arg<2>) const { return a2_; } A3 operator[] (boost::arg<3>) const { return a3_; } A4 operator[] (boost::arg<4>) const { return a4_; } A5 operator[] (boost::arg<5>) const { return a5_; } A6 operator[] (boost::arg<6>) const { return a6_; } A7 operator[] (boost::arg<7>) const { return a7_; } A8 operator[] (boost::arg<8>) const { return a8_; } A9 operator[] (boost::arg<9>) const { return a9_; } A1 operator[] (boost::arg<1> (*) ()) const { return a1_; } A2 operator[] (boost::arg<2> (*) ()) const { return a2_; } A3 operator[] (boost::arg<3> (*) ()) const { return a3_; } A4 operator[] (boost::arg<4> (*) ()) const { return a4_; } A5 operator[] (boost::arg<5> (*) ()) const { return a5_; } A6 operator[] (boost::arg<6> (*) ()) const { return a6_; } A7 operator[] (boost::arg<7> (*) ()) const { return a7_; } A8 operator[] (boost::arg<8> (*) ()) const { return a8_; } A9 operator[] (boost::arg<9> (*) ()) const { return a9_; } template T & operator[] (value & v) const { return v.get(); } template T const & operator[] (value const & v) const { return v.get(); } template T & operator[] (reference_wrapper const & v) const { return v.get(); } template typename result_traits::type operator[] (bind_t & b) const { return b.eval(*this); } template typename result_traits::type operator[] (bind_t const & b) const { return b.eval(*this); } template R operator()(type, F & f, A & a, long) { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]); } template R operator()(type, F const & f, A & a, long) const { return unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]); } template void operator()(type, F & f, A & a, int) { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]); } template void operator()(type, F const & f, A & a, int) const { unwrap(&f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]); } template void accept(V & v) const { BOOST_BIND_VISIT_EACH(v, a1_, 0); BOOST_BIND_VISIT_EACH(v, a2_, 0); BOOST_BIND_VISIT_EACH(v, a3_, 0); BOOST_BIND_VISIT_EACH(v, a4_, 0); BOOST_BIND_VISIT_EACH(v, a5_, 0); BOOST_BIND_VISIT_EACH(v, a6_, 0); BOOST_BIND_VISIT_EACH(v, a7_, 0); BOOST_BIND_VISIT_EACH(v, a8_, 0); BOOST_BIND_VISIT_EACH(v, a9_, 0); } bool operator==(list9 const & rhs) const { return ref_compare(a1_, rhs.a1_, 0) && ref_compare(a2_, rhs.a2_, 0) && ref_compare(a3_, rhs.a3_, 0) && ref_compare(a4_, rhs.a4_, 0) && ref_compare(a5_, rhs.a5_, 0) && ref_compare(a6_, rhs.a6_, 0) && ref_compare(a7_, rhs.a7_, 0) && ref_compare(a8_, rhs.a8_, 0) && ref_compare(a9_, rhs.a9_, 0); } private: A1 a1_; A2 a2_; A3 a3_; A4 a4_; A5 a5_; A6 a6_; A7 a7_; A8 a8_; A9 a9_; }; // bind_t #ifndef BOOST_NO_VOID_RETURNS template class bind_t { public: typedef bind_t this_type; bind_t(F f, L const & l): f_(f), l_(l) {} #define BOOST_BIND_RETURN return #include #undef BOOST_BIND_RETURN }; #else template struct bind_t_generator { template class implementation { public: typedef implementation this_type; implementation(F f, L const & l): f_(f), l_(l) {} #define BOOST_BIND_RETURN return #include #undef BOOST_BIND_RETURN }; }; template<> struct bind_t_generator { template class implementation { private: typedef void R; public: typedef implementation this_type; implementation(F f, L const & l): f_(f), l_(l) {} #define BOOST_BIND_RETURN #include #undef BOOST_BIND_RETURN }; }; template class bind_t: public bind_t_generator::BOOST_NESTED_TEMPLATE implementation { public: bind_t(F f, L const & l): bind_t_generator::BOOST_NESTED_TEMPLATE implementation(f, l) {} }; #endif // bind_t::operator== template bool operator==(bind_t const & a, bind_t const & b) { return a.compare(b); } template bool operator!=(bind_t const & a, bind_t const & b) { return !a.compare(b); } // add_value #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) || (__SUNPRO_CC >= 0x530) template struct add_value { typedef value type; }; template struct add_value< value > { typedef value type; }; template struct add_value< reference_wrapper > { typedef reference_wrapper type; }; template struct add_value< arg > { typedef boost::arg type; }; template struct add_value< arg (*) () > { typedef boost::arg (*type) (); }; template struct add_value< bind_t > { typedef bind_t type; }; #else template struct _avt_0; template<> struct _avt_0<1> { template struct inner { typedef T type; }; }; template<> struct _avt_0<2> { template struct inner { typedef value type; }; }; typedef char (&_avt_r1) [1]; typedef char (&_avt_r2) [2]; template _avt_r1 _avt_f(value); template _avt_r1 _avt_f(reference_wrapper); template _avt_r1 _avt_f(arg); template _avt_r1 _avt_f(arg (*) ()); template _avt_r1 _avt_f(bind_t); _avt_r2 _avt_f(...); template struct add_value { static T t(); typedef typename _avt_0::template inner::type type; }; #endif // list_av_N template struct list_av_1 { typedef typename add_value::type B1; typedef list1 type; }; template struct list_av_2 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef list2 type; }; template struct list_av_3 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef list3 type; }; template struct list_av_4 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef typename add_value::type B4; typedef list4 type; }; template struct list_av_5 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef typename add_value::type B4; typedef typename add_value::type B5; typedef list5 type; }; template struct list_av_6 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef typename add_value::type B4; typedef typename add_value::type B5; typedef typename add_value::type B6; typedef list6 type; }; template struct list_av_7 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef typename add_value::type B4; typedef typename add_value::type B5; typedef typename add_value::type B6; typedef typename add_value::type B7; typedef list7 type; }; template struct list_av_8 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef typename add_value::type B4; typedef typename add_value::type B5; typedef typename add_value::type B6; typedef typename add_value::type B7; typedef typename add_value::type B8; typedef list8 type; }; template struct list_av_9 { typedef typename add_value::type B1; typedef typename add_value::type B2; typedef typename add_value::type B3; typedef typename add_value::type B4; typedef typename add_value::type B5; typedef typename add_value::type B6; typedef typename add_value::type B7; typedef typename add_value::type B8; typedef typename add_value::type B9; typedef list9 type; }; } // namespace _bi // visit_each template void visit_each(V & v, _bi::value const & t, int) { BOOST_BIND_VISIT_EACH(v, t.get(), 0); } template void visit_each(V & v, _bi::bind_t const & t, int) { t.accept(v); } // bind #ifndef BOOST_BIND #define BOOST_BIND bind #endif // generic function objects template _bi::bind_t BOOST_BIND(F f) { typedef _bi::list0 list_type; return _bi::bind_t (f, list_type()); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1) { typedef typename _bi::list_av_1::type list_type; return _bi::bind_t (f, list_type(a1)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2) { typedef typename _bi::list_av_2::type list_type; return _bi::bind_t (f, list_type(a1, a2)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3) { typedef typename _bi::list_av_3::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4) { typedef typename _bi::list_av_4::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef typename _bi::list_av_5::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef typename _bi::list_av_6::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef typename _bi::list_av_7::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef typename _bi::list_av_8::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); } template _bi::bind_t::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef typename _bi::list_av_9::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); } // generic function objects, alternative syntax template _bi::bind_t BOOST_BIND(boost::type, F f) { typedef _bi::list0 list_type; return _bi::bind_t (f, list_type()); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1) { typedef typename _bi::list_av_1::type list_type; return _bi::bind_t (f, list_type(a1)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2) { typedef typename _bi::list_av_2::type list_type; return _bi::bind_t (f, list_type(a1, a2)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3) { typedef typename _bi::list_av_3::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3, A4 a4) { typedef typename _bi::list_av_4::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef typename _bi::list_av_5::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef typename _bi::list_av_6::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef typename _bi::list_av_7::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef typename _bi::list_av_8::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); } template _bi::bind_t::type> BOOST_BIND(boost::type, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef typename _bi::list_av_9::type list_type; return _bi::bind_t(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); } #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) // adaptable function objects template _bi::bind_t<_bi::unspecified, F, _bi::list0> BOOST_BIND(F f) { typedef _bi::list0 list_type; return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type()); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1::type> BOOST_BIND(F f, A1 a1) { typedef typename _bi::list_av_1::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2::type> BOOST_BIND(F f, A1 a1, A2 a2) { typedef typename _bi::list_av_2::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3) { typedef typename _bi::list_av_3::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4) { typedef typename _bi::list_av_4::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef typename _bi::list_av_5::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef typename _bi::list_av_6::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef typename _bi::list_av_7::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef typename _bi::list_av_8::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8)); } template _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9::type> BOOST_BIND(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef typename _bi::list_av_9::type list_type; return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9)); } #endif // !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) // function pointers #define BOOST_BIND_CC #define BOOST_BIND_ST #include #undef BOOST_BIND_CC #undef BOOST_BIND_ST #ifdef BOOST_BIND_ENABLE_STDCALL #define BOOST_BIND_CC __stdcall #define BOOST_BIND_ST #include #undef BOOST_BIND_CC #undef BOOST_BIND_ST #endif #ifdef BOOST_BIND_ENABLE_FASTCALL #define BOOST_BIND_CC __fastcall #define BOOST_BIND_ST #include #undef BOOST_BIND_CC #undef BOOST_BIND_ST #endif #ifdef BOOST_BIND_ENABLE_PASCAL #define BOOST_BIND_ST pascal #define BOOST_BIND_CC #include #undef BOOST_BIND_ST #undef BOOST_BIND_CC #endif // member function pointers #define BOOST_BIND_MF_NAME(X) X #define BOOST_BIND_MF_CC #include #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC #ifdef BOOST_MEM_FN_ENABLE_STDCALL #define BOOST_BIND_MF_NAME(X) X##_stdcall #define BOOST_BIND_MF_CC __stdcall #include #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC #endif #ifdef BOOST_MEM_FN_ENABLE_FASTCALL #define BOOST_BIND_MF_NAME(X) X##_fastcall #define BOOST_BIND_MF_CC __fastcall #include #undef BOOST_BIND_MF_NAME #undef BOOST_BIND_MF_CC #endif // data member pointers /* #if defined(__GNUC__) && (__GNUC__ == 2) namespace _bi { template struct add_cref { typedef T const & type; }; template struct add_cref< T & > { typedef T const & type; }; template<> struct add_cref { typedef void type; }; } // namespace _bi template _bi::bind_t< typename _bi::add_cref::type, _mfi::dm, typename _bi::list_av_1::type > BOOST_BIND(R T::*f, A1 a1) { typedef _mfi::dm F; typedef typename _bi::list_av_1::type list_type; return _bi::bind_t::type, F, list_type>(F(f), list_type(a1)); } #else template _bi::bind_t< R const &, _mfi::dm, typename _bi::list_av_1::type > BOOST_BIND(R T::*f, A1 a1) { typedef _mfi::dm F; typedef typename _bi::list_av_1::type list_type; return _bi::bind_t(F(f), list_type(a1)); } #endif */ template _bi::bind_t< R, _mfi::dm, typename _bi::list_av_1::type > BOOST_BIND(R T::*f, A1 a1) { typedef _mfi::dm F; typedef typename _bi::list_av_1::type list_type; return _bi::bind_t( F(f), list_type(a1) ); } } // namespace boost #ifndef BOOST_BIND_NO_PLACEHOLDERS # include #endif #ifdef BOOST_MSVC # pragma warning(default: 4512) // assignment operator could not be generated # pragma warning(pop) #endif #endif // #ifndef BOOST_BIND_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/signals.hpp0000644000175000017500000000053111344301501027611 0ustar debiandebian// Boost.Signals library // Copyright Douglas Gregor 2003-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/signals #include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/python.hpp0000644000175000017500000000522111344301501027473 0ustar debiandebian// Copyright David Abrahams 2002. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/python for documentation. #ifndef PYTHON_DWA2002810_HPP # define PYTHON_DWA2002810_HPP # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include #endif // PYTHON_DWA2002810_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/compressed_pair.hpp0000644000175000017500000000144111344301501031331 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/utility for most recent version including documentation. // See boost/detail/compressed_pair.hpp and boost/detail/ob_compressed_pair.hpp // for full copyright notices. #ifndef BOOST_COMPRESSED_PAIR_HPP #define BOOST_COMPRESSED_PAIR_HPP #ifndef BOOST_CONFIG_HPP #include #endif #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #include #else #include #endif #endif // BOOST_COMPRESSED_PAIR_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/blank.hpp0000644000175000017500000000277311344301501027252 0ustar debiandebian//----------------------------------------------------------------------------- // boost blank.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_BLANK_HPP #define BOOST_BLANK_HPP #include "boost/blank_fwd.hpp" #include // for std::basic_ostream forward declare #include "boost/detail/templated_streams.hpp" #include "boost/mpl/bool.hpp" #include "boost/type_traits/is_empty.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/is_stateless.hpp" namespace boost { struct blank { }; // type traits specializations // template <> struct is_pod< blank > : mpl::true_ { }; template <> struct is_empty< blank > : mpl::true_ { }; template <> struct is_stateless< blank > : mpl::true_ { }; // relational operators // inline bool operator==(const blank&, const blank&) { return true; } inline bool operator<(const blank&, const blank&) { return false; } // streaming support // BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<( BOOST_TEMPLATED_STREAM(ostream, E,T)& out , const blank& ) { // (output nothing) return out; } } // namespace boost #endif // BOOST_BLANK_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/spirit.hpp0000644000175000017500000000505111344301501027465 0ustar debiandebian/*============================================================================= Copyright (c) 1998-2003 Joel de Guzman Copyright (c) 2001-2003 Daniel Nuffer Copyright (c) 2001-2003 Hartmut Kaiser Copyright (c) 2002-2003 Martin Wille Copyright (c) 2002 Juan Carlos Arevalo-Baeza Copyright (c) 2002 Raghavendra Satish Copyright (c) 2002 Jeff Westfahl Copyright (c) 2001 Bruce Florman Copyright (c) 2003 Giovanni Bajo Copyright (c) 2003 Vaclav Vesely Copyright (c) 2003 Jonathan de Halleux http://spirit.sourceforge.net/ Use, modification and distribution is subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) =============================================================================*/ #if !defined(SPIRIT_HPP) #define SPIRIT_HPP /////////////////////////////////////////////////////////////////////////////// // // If SPIRIT_DEBUG is defined, the following header includes the // Spirit.Debug layer, otherwise the non-debug Spirit.Core is included. // /////////////////////////////////////////////////////////////////////////////// #include /////////////////////////////////////////////////////////////////////////////// // // Spirit.Meta // /////////////////////////////////////////////////////////////////////////////// #include /////////////////////////////////////////////////////////////////////////////// // // Spirit.ErrorHandling // /////////////////////////////////////////////////////////////////////////////// #include /////////////////////////////////////////////////////////////////////////////// // // Spirit.Iterators // /////////////////////////////////////////////////////////////////////////////// #include /////////////////////////////////////////////////////////////////////////////// // // Spirit.Symbols // /////////////////////////////////////////////////////////////////////////////// #include /////////////////////////////////////////////////////////////////////////////// // // Spirit.Utilities // /////////////////////////////////////////////////////////////////////////////// #include /////////////////////////////////////////////////////////////////////////////// // // Spirit.Attributes // /////////////////////////////////////////////////////////////////////////////// #include #endif // !defined(SPIRIT_HPP) mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/format.hpp0000644000175000017500000000420311344301501027441 0ustar debiandebian// ---------------------------------------------------------------------------- // format.hpp : primary header // ---------------------------------------------------------------------------- // Copyright Samuel Krempp 2003. Use, modification, and distribution are // subject to the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/format for library home page // ---------------------------------------------------------------------------- #ifndef BOOST_FORMAT_HPP #define BOOST_FORMAT_HPP #include #include #include #include #ifndef BOOST_NO_STD_LOCALE #include #endif // *** Compatibility framework #include #ifdef BOOST_NO_LOCALE_ISIDIGIT #include // we'll use the non-locale 's std::isdigit(int) #endif // **** Forward declarations ---------------------------------- #include // basic_format, and other frontends #include // misc forward declarations for internal use // **** Auxiliary structs (stream_format_state , and format_item ) #include // **** Format class interface -------------------------------- #include // **** Exceptions ----------------------------------------------- #include // **** Implementation ------------------------------------------- #include // member functions #include // class for grouping arguments #include // argument-feeding functions #include // format-string parsing (member-)functions // **** Implementation of the free functions ---------------------- #include // *** Undefine 'local' macros : #include #endif // BOOST_FORMAT_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/last_value.hpp0000644000175000017500000000216011344301501030310 0ustar debiandebian// last_value function object (documented as part of Boost.Signals) // Copyright Douglas Gregor 2001-2003. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/signals #ifndef BOOST_LAST_VALUE_HPP #define BOOST_LAST_VALUE_HPP #include namespace boost { template struct last_value { typedef T result_type; template T operator()(InputIterator first, InputIterator last) const { assert(first != last); T value = *first++; while (first != last) value = *first++; return value; } }; template<> struct last_value { struct unusable {}; public: typedef unusable result_type; template result_type operator()(InputIterator first, InputIterator last) const { while (first != last) *first++; return result_type(); } }; } #endif // BOOST_SIGNALS_LAST_VALUE_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/visit_each.hpp0000644000175000017500000000131711344301501030272 0ustar debiandebian// Boost.Signals library // Copyright Douglas Gregor 2001-2003. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/signals #ifndef BOOST_VISIT_EACH_HPP #define BOOST_VISIT_EACH_HPP #include namespace boost { template inline void visit_each(Visitor& visitor, const T& t, long) { visitor(t); } template inline void visit_each(Visitor& visitor, const T& t) { visit_each(visitor, t, 0); } } #endif // BOOST_VISIT_EACH_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/scoped_array.hpp0000644000175000017500000000574211344301501030635 0ustar debiandebian#ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED #define BOOST_SCOPED_ARRAY_HPP_INCLUDED // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. // Copyright (c) 2001, 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // http://www.boost.org/libs/smart_ptr/scoped_array.htm // #include #include #include // in case ptrdiff_t not in std #include #include // for std::ptrdiff_t namespace boost { // Debug hooks #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) void sp_array_constructor_hook(void * p); void sp_array_destructor_hook(void * p); #endif // scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to // is guaranteed, either on destruction of the scoped_array or via an explicit // reset(). Use shared_array or std::vector if your needs are more complex. template class scoped_array // noncopyable { private: T * ptr; scoped_array(scoped_array const &); scoped_array & operator=(scoped_array const &); typedef scoped_array this_type; public: typedef T element_type; explicit scoped_array(T * p = 0) : ptr(p) // never throws { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) boost::sp_array_constructor_hook(ptr); #endif } ~scoped_array() // never throws { #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS) boost::sp_array_destructor_hook(ptr); #endif boost::checked_array_delete(ptr); } void reset(T * p = 0) // never throws { BOOST_ASSERT(p == 0 || p != ptr); // catch self-reset errors this_type(p).swap(*this); } T & operator[](std::ptrdiff_t i) const // never throws { BOOST_ASSERT(ptr != 0); BOOST_ASSERT(i >= 0); return ptr[i]; } T * get() const // never throws { return ptr; } // implicit conversion to "bool" #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) operator bool () const { return ptr != 0; } #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) typedef T * (this_type::*unspecified_bool_type)() const; operator unspecified_bool_type() const // never throws { return ptr == 0? 0: &this_type::get; } #else typedef T * this_type::*unspecified_bool_type; operator unspecified_bool_type() const // never throws { return ptr == 0? 0: &this_type::ptr; } #endif bool operator! () const // never throws { return ptr == 0; } void swap(scoped_array & b) // never throws { T * tmp = b.ptr; b.ptr = ptr; ptr = tmp; } }; template inline void swap(scoped_array & a, scoped_array & b) // never throws { a.swap(b); } } // namespace boost #endif // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mem_fn.hpp0000644000175000017500000001353511344301501027422 0ustar debiandebian#ifndef BOOST_MEM_FN_HPP_INCLUDED #define BOOST_MEM_FN_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // mem_fn.hpp - a generalization of std::mem_fun[_ref] // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // Copyright (c) 2001 David Abrahams // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/bind/mem_fn.html for documentation. // #include #include #include namespace boost { #if defined(BOOST_NO_VOID_RETURNS) #define BOOST_MEM_FN_CLASS_F , class F #define BOOST_MEM_FN_TYPEDEF(X) namespace _mfi // mem_fun_impl { template struct mf { #define BOOST_MEM_FN_RETURN return #define BOOST_MEM_FN_NAME(X) inner_##X #define BOOST_MEM_FN_CC #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #ifdef BOOST_MEM_FN_ENABLE_STDCALL #define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall #define BOOST_MEM_FN_CC __stdcall #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #endif #ifdef BOOST_MEM_FN_ENABLE_FASTCALL #define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall #define BOOST_MEM_FN_CC __fastcall #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #endif #undef BOOST_MEM_FN_RETURN }; // struct mf template<> struct mf { #define BOOST_MEM_FN_RETURN #define BOOST_MEM_FN_NAME(X) inner_##X #define BOOST_MEM_FN_CC #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #ifdef BOOST_MEM_FN_ENABLE_STDCALL #define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall #define BOOST_MEM_FN_CC __stdcall #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #endif #ifdef BOOST_MEM_FN_ENABLE_FASTCALL #define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall #define BOOST_MEM_FN_CC __fastcall #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #endif #undef BOOST_MEM_FN_RETURN }; // struct mf #undef BOOST_MEM_FN_CLASS_F #undef BOOST_MEM_FN_TYPEDEF_F #define BOOST_MEM_FN_NAME(X) X #define BOOST_MEM_FN_NAME2(X) inner_##X #define BOOST_MEM_FN_CC #include #undef BOOST_MEM_FN_NAME #undef BOOST_MEM_FN_NAME2 #undef BOOST_MEM_FN_CC #ifdef BOOST_MEM_FN_ENABLE_STDCALL #define BOOST_MEM_FN_NAME(X) X##_stdcall #define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall #define BOOST_MEM_FN_CC __stdcall #include #undef BOOST_MEM_FN_NAME #undef BOOST_MEM_FN_NAME2 #undef BOOST_MEM_FN_CC #endif #ifdef BOOST_MEM_FN_ENABLE_FASTCALL #define BOOST_MEM_FN_NAME(X) X##_fastcall #define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall #define BOOST_MEM_FN_CC __fastcall #include #undef BOOST_MEM_FN_NAME #undef BOOST_MEM_FN_NAME2 #undef BOOST_MEM_FN_CC #endif } // namespace _mfi #else // #ifdef BOOST_NO_VOID_RETURNS #define BOOST_MEM_FN_CLASS_F #define BOOST_MEM_FN_TYPEDEF(X) typedef X; namespace _mfi { #define BOOST_MEM_FN_RETURN return #define BOOST_MEM_FN_NAME(X) X #define BOOST_MEM_FN_CC #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #ifdef BOOST_MEM_FN_ENABLE_STDCALL #define BOOST_MEM_FN_NAME(X) X##_stdcall #define BOOST_MEM_FN_CC __stdcall #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #endif #ifdef BOOST_MEM_FN_ENABLE_FASTCALL #define BOOST_MEM_FN_NAME(X) X##_fastcall #define BOOST_MEM_FN_CC __fastcall #include #undef BOOST_MEM_FN_CC #undef BOOST_MEM_FN_NAME #endif #undef BOOST_MEM_FN_RETURN } // namespace _mfi #undef BOOST_MEM_FN_CLASS_F #undef BOOST_MEM_FN_TYPEDEF #endif // #ifdef BOOST_NO_VOID_RETURNS #define BOOST_MEM_FN_NAME(X) X #define BOOST_MEM_FN_CC #include #undef BOOST_MEM_FN_NAME #undef BOOST_MEM_FN_CC #ifdef BOOST_MEM_FN_ENABLE_STDCALL #define BOOST_MEM_FN_NAME(X) X##_stdcall #define BOOST_MEM_FN_CC __stdcall #include #undef BOOST_MEM_FN_NAME #undef BOOST_MEM_FN_CC #endif #ifdef BOOST_MEM_FN_ENABLE_FASTCALL #define BOOST_MEM_FN_NAME(X) X##_fastcall #define BOOST_MEM_FN_CC __fastcall #include #undef BOOST_MEM_FN_NAME #undef BOOST_MEM_FN_CC #endif // data member support namespace _mfi { template class dm { public: typedef R const & result_type; typedef T const * argument_type; private: typedef R (T::*F); F f_; template R const & call(U & u, T const *) const { return (u.*f_); } template R & call(U & u, T *) const { return (u.*f_); } template R const & call(U & u, void const *) const { return (get_pointer(u)->*f_); } public: explicit dm(F f): f_(f) {} R & operator()(T * p) const { return (p->*f_); } R const & operator()(T const * p) const { return (p->*f_); } template R const & operator()(U & u) const { return call(u, &u); } #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) R & operator()(T & t) const { return (t.*f_); } #endif R const & operator()(T const & t) const { return (t.*f_); } bool operator==(dm const & rhs) const { return f_ == rhs.f_; } bool operator!=(dm const & rhs) const { return f_ != rhs.f_; } }; } // namespace _mfi template _mfi::dm mem_fn(R T::*f) { return _mfi::dm(f); } } // namespace boost #endif // #ifndef BOOST_MEM_FN_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/function_output_iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/function_output_itera0000644000175000017500000000304611344301501032020 0ustar debiandebian// (C) Copyright Jeremy Siek 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // Revision History: // 27 Feb 2001 Jeremy Siek // Initial checkin. #ifndef BOOST_FUNCTION_OUTPUT_ITERATOR_HPP #define BOOST_FUNCTION_OUTPUT_ITERATOR_HPP #include namespace boost { template class function_output_iterator { typedef function_output_iterator self; public: typedef std::output_iterator_tag iterator_category; typedef void value_type; typedef void difference_type; typedef void pointer; typedef void reference; explicit function_output_iterator() {} explicit function_output_iterator(const UnaryFunction& f) : m_f(f) {} struct output_proxy { output_proxy(UnaryFunction& f) : m_f(f) { } template output_proxy& operator=(const T& value) { m_f(value); return *this; } UnaryFunction& m_f; }; output_proxy operator*() { return output_proxy(m_f); } self& operator++() { return *this; } self& operator++(int) { return *this; } private: UnaryFunction m_f; }; template inline function_output_iterator make_function_output_iterator(const UnaryFunction& f = UnaryFunction()) { return function_output_iterator(f); } } // namespace boost #endif // BOOST_FUNCTION_OUTPUT_ITERATOR_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/tokenizer.hpp0000644000175000017500000000535711344301501030176 0ustar debiandebian// Boost tokenizer.hpp -----------------------------------------------------// // © Copyright Jeremy Siek and John R. Bandela 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/tokenizer for documenation // Revision History: // 03 Jul 2003 John Bandela // Converted to new iterator adapter // 02 Feb 2002 Jeremy Siek // Removed tabs and a little cleanup. #ifndef BOOST_TOKENIZER_JRB070303_HPP_ #define BOOST_TOKENIZER_JRB070303_HPP_ #include #include namespace boost { //=========================================================================== // A container-view of a tokenized "sequence" template < typename TokenizerFunc = char_delimiters_separator, typename Iterator = std::string::const_iterator, typename Type = std::string > class tokenizer { private: typedef token_iterator_generator TGen; // It seems that MSVC does not like the unqualified use of iterator, // Thus we use iter internally when it is used unqualified and // the users of this class will always qualify iterator. typedef typename TGen::type iter; public: typedef iter iterator; typedef iter const_iterator; typedef Type value_type; typedef value_type& reference; typedef const value_type& const_reference; typedef value_type* pointer; typedef const pointer const_pointer; typedef void size_type; typedef void difference_type; tokenizer(Iterator first, Iterator last, const TokenizerFunc& f = TokenizerFunc()) : first_(first), last_(last), f_(f) { } template tokenizer(const Container& c) : first_(c.begin()), last_(c.end()), f_() { } template tokenizer(const Container& c,const TokenizerFunc& f) : first_(c.begin()), last_(c.end()), f_(f) { } void assign(Iterator first, Iterator last){ first_ = first; last_ = last; } void assign(Iterator first, Iterator last, const TokenizerFunc& f){ assign(first,last); f_ = f; } template void assign(const Container& c){ assign(c.begin(),c.end()); } template void assign(const Container& c, const TokenizerFunc& f){ assign(c.begin(),c.end(),f); } iter begin() const { return iter(f_,first_,last_); } iter end() const { return iter(f_,last_,last_); } private: Iterator first_; Iterator last_; TokenizerFunc f_; }; } // namespace boost #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/config.hpp0000644000175000017500000000400211344301501027413 0ustar debiandebian// Boost config.hpp configuration header file ------------------------------// // (C) Copyright John Maddock 2002. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/config for most recent version. // Boost config.hpp policy and rationale documentation has been moved to // http://www.boost.org/libs/config // // CAUTION: This file is intended to be completely stable - // DO NOT MODIFY THIS FILE! // #ifndef BOOST_CONFIG_HPP #define BOOST_CONFIG_HPP // if we don't have a user config, then use the default location: #if !defined(BOOST_USER_CONFIG) && !defined(BOOST_NO_USER_CONFIG) # define BOOST_USER_CONFIG #endif // include it first: #ifdef BOOST_USER_CONFIG # include BOOST_USER_CONFIG #endif // if we don't have a compiler config set, try and find one: #if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG) # include #endif // if we have a compiler config, include it now: #ifdef BOOST_COMPILER_CONFIG # include BOOST_COMPILER_CONFIG #endif // if we don't have a std library config set, try and find one: #if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) # include #endif // if we have a std library config, include it now: #ifdef BOOST_STDLIB_CONFIG # include BOOST_STDLIB_CONFIG #endif // if we don't have a platform config set, try and find one: #if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG) # include #endif // if we have a platform config, include it now: #ifdef BOOST_PLATFORM_CONFIG # include BOOST_PLATFORM_CONFIG #endif // get config suffix code: #include #endif // BOOST_CONFIG_HPP ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utf8_codecvt_facet.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utf8_codecvt_facet.hp0000644000175000017500000001513211344301501031533 0ustar debiandebian#ifndef BOOST_UTF8_CODECVT_FACET_HPP #define BOOST_UTF8_CODECVT_FACET_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // utf8_codecvt_facet.hpp // Copyright © 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). Permission to copy, // use, modify, sell and distribute this software is granted provided this // copyright notice appears in all copies. This software is provided "as is" // without express or implied warranty, and with no claim as to its suitability // for any purpose. // Note:(Robert Ramey). I have made the following alterations in the original // code. // a) Rendered utf8_codecvt with using templates // b) Move longer functions outside class definition to prevent inlining // and make code smaller // c) added on a derived class to permit translation to/from current // locale to utf8 // See http://www.boost.org for updates, documentation, and revision history. // archives stored as text - note these ar templated on the basic // stream templates to accommodate wide (and other?) kind of characters // // note the fact that on libraries without wide characters, ostream is // is not a specialization of basic_ostream which in fact is not defined // in such cases. So we can't use basic_ostream but rather // use two template parameters // // utf8_codecvt_facet // This is an implementation of a std::codecvt facet for translating // from UTF-8 externally to UCS-4. Note that this is not tied to // any specific types in order to allow customization on platforms // where wchar_t is not big enough. // // NOTES: The current implementation jumps through some unpleasant hoops in // order to deal with signed character types. As a std::codecvt_base::result, // it is necessary for the ExternType to be convertible to unsigned char. // I chose not to tie the extern_type explicitly to char. But if any combination // of types other than is used, then std::codecvt must be // specialized on those types for this to work. #include #include // size_t namespace std{ #if defined(__LIBCOMO__) using ::mbstate_t; #elif defined(BOOST_DINKUMWARE_STDLIB) using ::mbstate_t; #elif defined(__SGI_STL_PORT) #elif defined(BOOST_NO_STDC_NAMESPACE) using ::codecvt; using ::mbstate_t; #endif } // namespace std #if !defined(__MSL_CPP__) \ && !defined(__LIBCOMO__) #define BOOST_CODECVT_DO_LENGTH_CONST const #else #define BOOST_CODECVT_DO_LENGTH_CONST #endif #include // maximum lenght of a multibyte string #define MB_LENGTH_MAX 8 struct utf8_codecvt_facet_wchar_t : public std::codecvt { public: explicit utf8_codecvt_facet_wchar_t(std::size_t no_locale_manage = 0) : std::codecvt(no_locale_manage) {} protected: virtual std::codecvt_base::result do_in( std::mbstate_t& state, const char * from, const char * from_end, const char * & from_next, wchar_t * to, wchar_t * to_end, wchar_t*& to_next ) const; virtual std::codecvt_base::result do_out( std::mbstate_t & state, const wchar_t * from, const wchar_t * from_end, const wchar_t* & from_next, char * to, char * to_end, char * & to_next ) const; bool invalid_continuing_octet(unsigned char octet_1) const { return (octet_1 < 0x80|| 0xbf< octet_1); } bool invalid_leading_octet(unsigned char octet_1) const { return (0x7f < octet_1 && octet_1 < 0xc0) || (octet_1 > 0xfd); } // continuing octets = octets except for the leading octet static unsigned int get_cont_octet_count(unsigned char lead_octet) { return get_octet_count(lead_octet) - 1; } static unsigned int get_octet_count(unsigned char lead_octet); // How many "continuing octets" will be needed for this word // == total octets - 1. int get_cont_octet_out_count(wchar_t word) const ; virtual bool do_always_noconv() const throw() { return false; } // UTF-8 isn't really stateful since we rewind on partial conversions virtual std::codecvt_base::result do_unshift( std::mbstate_t&, char * from, char * to, char * & next ) const{ next = from; return ok; } virtual int do_encoding() const throw() { const int variable_byte_external_encoding=0; return variable_byte_external_encoding; } // How many char objects can I process to get <= max_limit // wchar_t objects? virtual int do_length( BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &, const char * from, const char * from_end, std::size_t max_limit ) const throw(); // Largest possible value do_length(state,from,from_end,1) could return. virtual int do_max_length() const throw () { return 6; // largest UTF-8 encoding of a UCS-4 character } }; #if 0 // not used - incorrect in any case // Robert Ramey - use the above to make a code converter from multi-byte // char strings to utf8 encoding struct utf8_codecvt_facet_char : public utf8_codecvt_facet_wchar_t { typedef utf8_codecvt_facet_wchar_t base_class; public: explicit utf8_codecvt_facet_char(std::size_t no_locale_manage=0) : base_class(no_locale_manage) {} protected: virtual std::codecvt_base::result do_in( std::mbstate_t & state, const char * from, const char * from_end, const char * & from_next, char * to, char * to_end, char * & to_next ) const; virtual std::codecvt_base::result do_out( std::mbstate_t & state, const char * from, const char * from_end, const char* & from_next, char * to, char * to_end, char * & to_next ) const; // How many char objects can I process to get <= max_limit // char objects? virtual int do_length( const std::mbstate_t&, const char * from, const char * from_end, std::size_t max_limit ) const; }; #endif template struct utf8_codecvt_facet {}; template<> struct utf8_codecvt_facet : public utf8_codecvt_facet_wchar_t {}; #if 0 template<> struct utf8_codecvt_facet : public utf8_codecvt_facet_char {}; #endif #endif // BOOST_UTF8_CODECVT_FACET_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type.hpp0000644000175000017500000000074111344301501027135 0ustar debiandebian// (C) Copyright David Abrahams 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_TYPE_DWA20010120_HPP # define BOOST_TYPE_DWA20010120_HPP namespace boost { // Just a simple "type envelope". Useful in various contexts, mostly to work // around some MSVC deficiencies. template struct type {}; } #endif // BOOST_TYPE_DWA20010120_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/cstdlib.hpp0000644000175000017500000000331311344301501027576 0ustar debiandebian// boost/cstdlib.hpp header ------------------------------------------------// // Copyright Beman Dawes 2001. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/utility/cstdlib.html for documentation. // Revision History // 26 Feb 01 Initial version (Beman Dawes) #ifndef BOOST_CSTDLIB_HPP #define BOOST_CSTDLIB_HPP #include namespace boost { // The intent is to propose the following for addition to namespace std // in the C++ Standard Library, and to then deprecate EXIT_SUCCESS and // EXIT_FAILURE. As an implementation detail, this header defines the // new constants in terms of EXIT_SUCCESS and EXIT_FAILURE. In a new // standard, the constants would be implementation-defined, although it // might be worthwhile to "suggest" (which a standard is allowed to do) // values of 0 and 1 respectively. // Rationale for having multiple failure values: some environments may // wish to distinguish between different classes of errors. // Rationale for choice of values: programs often use values < 100 for // their own error reporting. Values > 255 are sometimes reserved for // system detected errors. 200/201 were suggested to minimize conflict. const int exit_success = EXIT_SUCCESS; // implementation-defined value const int exit_failure = EXIT_FAILURE; // implementation-defined value const int exit_exception_failure = 200; // otherwise uncaught exception const int exit_test_failure = 201; // report_error or // report_critical_error called. } #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/implicit_cast.hpp0000644000175000017500000000210711344301501030776 0ustar debiandebian// Copyright David Abrahams 2003. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef IMPLICIT_CAST_DWA200356_HPP # define IMPLICIT_CAST_DWA200356_HPP # include namespace boost { // implementation originally suggested by C. Green in // http://lists.boost.org/MailArchives/boost/msg00886.php // The use of identity creates a non-deduced form, so that the // explicit template argument must be supplied template inline T implicit_cast (typename mpl::identity::type x) { return x; } // incomplete return type now is here //template //void implicit_cast (...); // Macro for when you need a constant expression (Gennaro Prota) #define BOOST_IMPLICIT_CAST(dst_type, expr) \ ( sizeof( implicit_cast(expr) ) \ , \ static_cast(expr) \ ) } // namespace boost #endif // IMPLICIT_CAST_DWA200356_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/functional.hpp0000644000175000017500000004543511344301501030327 0ustar debiandebian// ------------------------------------------------------------------------------ // Boost functional.hpp header file // See http://www.boost.org/libs/functional for documentation. // ------------------------------------------------------------------------------ // Copyright (c) 2000 // Cadenza New Zealand Ltd // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without // fee, provided that the above copyright notice appears in all copies // and that both the copyright notice and this permission notice // appear in supporting documentation. Cadenza New Zealand Ltd makes // no representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied // warranty. // ------------------------------------------------------------------------------ // $Id: functional.hpp,v 1.1.1.1 2010/03/05 22:18:41 annao Exp $ // ------------------------------------------------------------------------------ #ifndef BOOST_FUNCTIONAL_HPP #define BOOST_FUNCTIONAL_HPP #include #include #include namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // -------------------------------------------------------------------------- // The following traits classes allow us to avoid the need for ptr_fun // because the types of arguments and the result of a function can be // deduced. // // In addition to the standard types defined in unary_function and // binary_function, we add // // - function_type, the type of the function or function object itself. // // - param_type, the type that should be used for passing the function or // function object as an argument. // -------------------------------------------------------------------------- namespace detail { template struct unary_traits_imp; template struct unary_traits_imp { typedef Operation function_type; typedef const function_type & param_type; typedef typename Operation::result_type result_type; typedef typename Operation::argument_type argument_type; }; template struct unary_traits_imp { typedef R (*function_type)(A); typedef R (*param_type)(A); typedef R result_type; typedef A argument_type; }; template struct binary_traits_imp; template struct binary_traits_imp { typedef Operation function_type; typedef const function_type & param_type; typedef typename Operation::result_type result_type; typedef typename Operation::first_argument_type first_argument_type; typedef typename Operation::second_argument_type second_argument_type; }; template struct binary_traits_imp { typedef R (*function_type)(A1,A2); typedef R (*param_type)(A1,A2); typedef R result_type; typedef A1 first_argument_type; typedef A2 second_argument_type; }; } // namespace detail template struct unary_traits { typedef typename detail::unary_traits_imp::function_type function_type; typedef typename detail::unary_traits_imp::param_type param_type; typedef typename detail::unary_traits_imp::result_type result_type; typedef typename detail::unary_traits_imp::argument_type argument_type; }; template struct unary_traits { typedef R (*function_type)(A); typedef R (*param_type)(A); typedef R result_type; typedef A argument_type; }; template struct binary_traits { typedef typename detail::binary_traits_imp::function_type function_type; typedef typename detail::binary_traits_imp::param_type param_type; typedef typename detail::binary_traits_imp::result_type result_type; typedef typename detail::binary_traits_imp::first_argument_type first_argument_type; typedef typename detail::binary_traits_imp::second_argument_type second_argument_type; }; template struct binary_traits { typedef R (*function_type)(A1,A2); typedef R (*param_type)(A1,A2); typedef R result_type; typedef A1 first_argument_type; typedef A2 second_argument_type; }; #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // -------------------------------------------------------------------------- // If we have no partial specialisation available, decay to a situation // that is no worse than in the Standard, i.e., ptr_fun will be required. // -------------------------------------------------------------------------- template struct unary_traits { typedef Operation function_type; typedef const Operation& param_type; typedef typename Operation::result_type result_type; typedef typename Operation::argument_type argument_type; }; template struct binary_traits { typedef Operation function_type; typedef const Operation & param_type; typedef typename Operation::result_type result_type; typedef typename Operation::first_argument_type first_argument_type; typedef typename Operation::second_argument_type second_argument_type; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // -------------------------------------------------------------------------- // unary_negate, not1 // -------------------------------------------------------------------------- template class unary_negate : public std::unary_function::argument_type,bool> { public: explicit unary_negate(typename unary_traits::param_type x) : pred(x) {} bool operator()(typename call_traits::argument_type>::param_type x) const { return !pred(x); } private: typename unary_traits::function_type pred; }; template unary_negate not1(const Predicate &pred) { // The cast is to placate Borland C++Builder in certain circumstances. // I don't think it should be necessary. return unary_negate((typename unary_traits::param_type)pred); } template unary_negate not1(Predicate &pred) { return unary_negate(pred); } // -------------------------------------------------------------------------- // binary_negate, not2 // -------------------------------------------------------------------------- template class binary_negate : public std::binary_function::first_argument_type, typename binary_traits::second_argument_type, bool> { public: explicit binary_negate(typename binary_traits::param_type x) : pred(x) {} bool operator()(typename call_traits::first_argument_type>::param_type x, typename call_traits::second_argument_type>::param_type y) const { return !pred(x,y); } private: typename binary_traits::function_type pred; }; template binary_negate not2(const Predicate &pred) { // The cast is to placate Borland C++Builder in certain circumstances. // I don't think it should be necessary. return binary_negate((typename binary_traits::param_type)pred); } template binary_negate not2(Predicate &pred) { return binary_negate(pred); } // -------------------------------------------------------------------------- // binder1st, bind1st // -------------------------------------------------------------------------- template class binder1st : public std::unary_function::second_argument_type, typename binary_traits::result_type> { public: binder1st(typename binary_traits::param_type x, typename call_traits::first_argument_type>::param_type y) : op(x), value(y) {} typename binary_traits::result_type operator()(typename call_traits::second_argument_type>::param_type x) const { return op(value, x); } protected: typename binary_traits::function_type op; typename binary_traits::first_argument_type value; }; template inline binder1st bind1st(const Operation &op, typename call_traits< typename binary_traits::first_argument_type >::param_type x) { // The cast is to placate Borland C++Builder in certain circumstances. // I don't think it should be necessary. return binder1st((typename binary_traits::param_type)op, x); } template inline binder1st bind1st(Operation &op, typename call_traits< typename binary_traits::first_argument_type >::param_type x) { return binder1st(op, x); } // -------------------------------------------------------------------------- // binder2nd, bind2nd // -------------------------------------------------------------------------- template class binder2nd : public std::unary_function::first_argument_type, typename binary_traits::result_type> { public: binder2nd(typename binary_traits::param_type x, typename call_traits::second_argument_type>::param_type y) : op(x), value(y) {} typename binary_traits::result_type operator()(typename call_traits::first_argument_type>::param_type x) const { return op(x, value); } protected: typename binary_traits::function_type op; typename binary_traits::second_argument_type value; }; template inline binder2nd bind2nd(const Operation &op, typename call_traits< typename binary_traits::second_argument_type >::param_type x) { // The cast is to placate Borland C++Builder in certain circumstances. // I don't think it should be necessary. return binder2nd((typename binary_traits::param_type)op, x); } template inline binder2nd bind2nd(Operation &op, typename call_traits< typename binary_traits::second_argument_type >::param_type x) { return binder2nd(op, x); } // -------------------------------------------------------------------------- // mem_fun, etc // -------------------------------------------------------------------------- template class mem_fun_t : public std::unary_function { public: explicit mem_fun_t(S (T::*p)()) : ptr(p) {} S operator()(T* p) const { return (p->*ptr)(); } private: S (T::*ptr)(); }; template class mem_fun1_t : public std::binary_function { public: explicit mem_fun1_t(S (T::*p)(A)) : ptr(p) {} S operator()(T* p, typename call_traits::param_type x) const { return (p->*ptr)(x); } private: S (T::*ptr)(A); }; template class const_mem_fun_t : public std::unary_function { public: explicit const_mem_fun_t(S (T::*p)() const) : ptr(p) {} S operator()(const T* p) const { return (p->*ptr)(); } private: S (T::*ptr)() const; }; template class const_mem_fun1_t : public std::binary_function { public: explicit const_mem_fun1_t(S (T::*p)(A) const) : ptr(p) {} S operator()(const T* p, typename call_traits::param_type x) const { return (p->*ptr)(x); } private: S (T::*ptr)(A) const; }; template inline mem_fun_t mem_fun(S (T::*f)()) { return mem_fun_t(f); } template inline mem_fun1_t mem_fun(S (T::*f)(A)) { return mem_fun1_t(f); } #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST template inline const_mem_fun_t mem_fun(S (T::*f)() const) { return const_mem_fun_t(f); } template inline const_mem_fun1_t mem_fun(S (T::*f)(A) const) { return const_mem_fun1_t(f); } #endif // BOOST_NO_POINTER_TO_MEMBER_CONST // -------------------------------------------------------------------------- // mem_fun_ref, etc // -------------------------------------------------------------------------- template class mem_fun_ref_t : public std::unary_function { public: explicit mem_fun_ref_t(S (T::*p)()) : ptr(p) {} S operator()(T& p) const { return (p.*ptr)(); } private: S (T::*ptr)(); }; template class mem_fun1_ref_t : public std::binary_function { public: explicit mem_fun1_ref_t(S (T::*p)(A)) : ptr(p) {} S operator()(T& p, typename call_traits::param_type x) const { return (p.*ptr)(x); } private: S (T::*ptr)(A); }; template class const_mem_fun_ref_t : public std::unary_function { public: explicit const_mem_fun_ref_t(S (T::*p)() const) : ptr(p) {} S operator()(const T &p) const { return (p.*ptr)(); } private: S (T::*ptr)() const; }; template class const_mem_fun1_ref_t : public std::binary_function { public: explicit const_mem_fun1_ref_t(S (T::*p)(A) const) : ptr(p) {} S operator()(const T& p, typename call_traits::param_type x) const { return (p.*ptr)(x); } private: S (T::*ptr)(A) const; }; template inline mem_fun_ref_t mem_fun_ref(S (T::*f)()) { return mem_fun_ref_t(f); } template inline mem_fun1_ref_t mem_fun_ref(S (T::*f)(A)) { return mem_fun1_ref_t(f); } #ifndef BOOST_NO_POINTER_TO_MEMBER_CONST template inline const_mem_fun_ref_t mem_fun_ref(S (T::*f)() const) { return const_mem_fun_ref_t(f); } template inline const_mem_fun1_ref_t mem_fun_ref(S (T::*f)(A) const) { return const_mem_fun1_ref_t(f); } #endif // BOOST_NO_POINTER_TO_MEMBER_CONST // -------------------------------------------------------------------------- // ptr_fun // -------------------------------------------------------------------------- template class pointer_to_unary_function : public std::unary_function { public: explicit pointer_to_unary_function(Result (*f)(Arg)) : func(f) {} Result operator()(typename call_traits::param_type x) const { return func(x); } private: Result (*func)(Arg); }; template inline pointer_to_unary_function ptr_fun(Result (*f)(Arg)) { return pointer_to_unary_function(f); } template class pointer_to_binary_function : public std::binary_function { public: explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)) : func(f) {} Result operator()(typename call_traits::param_type x, typename call_traits::param_type y) const { return func(x,y); } private: Result (*func)(Arg1, Arg2); }; template inline pointer_to_binary_function ptr_fun(Result (*f)(Arg1, Arg2)) { return pointer_to_binary_function(f); } } // namespace boost #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/multi_array.hpp0000644000175000017500000003467611344301501030522 0ustar debiandebian// Copyright 2002 The Trustees of Indiana University. // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // Boost.MultiArray Library // Authors: Ronald Garcia // Jeremy Siek // Andrew Lumsdaine // See http://www.boost.org/libs/multi_array for documentation. #ifndef BOOST_MULTI_ARRAY_RG071801_HPP #define BOOST_MULTI_ARRAY_RG071801_HPP // // multi_array.hpp - contains the multi_array class template // declaration and definition // #include "boost/multi_array/base.hpp" #include "boost/multi_array/collection_concept.hpp" #include "boost/multi_array/copy_array.hpp" #include "boost/multi_array/iterator.hpp" #include "boost/multi_array/subarray.hpp" #include "boost/multi_array/multi_array_ref.hpp" #include "boost/multi_array/algorithm.hpp" #include "boost/array.hpp" #include "boost/mpl/if.hpp" #include "boost/type_traits.hpp" #include #include #include #include #include namespace boost { namespace detail { namespace multi_array { struct populate_index_ranges { multi_array_types::index_range operator()(multi_array_types::index base, multi_array_types::size_type extent) { return multi_array_types::index_range(base,base+extent); } }; #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING // // Compilers that don't support partial ordering may need help to // disambiguate multi_array's templated constructors. Even vc6/7 are // capable of some limited SFINAE, so we take the most-general version // out of the overload set with disable_multi_array_impl. // template char is_multi_array_impl_help(const_multi_array_view&); template char is_multi_array_impl_help(const_sub_array&); template char is_multi_array_impl_help(const_multi_array_ref&); char ( &is_multi_array_impl_help(...) )[2]; template struct is_multi_array_impl { static T x; BOOST_STATIC_CONSTANT(bool, value = sizeof((is_multi_array_impl_help)(x)) == 1); typedef mpl::bool_ type; }; template struct disable_multi_array_impl_impl { typedef int type; }; template <> struct disable_multi_array_impl_impl { // forming a pointer to a reference triggers SFINAE typedef int& type; }; template struct disable_multi_array_impl : disable_multi_array_impl_impl::value> { }; template <> struct disable_multi_array_impl { typedef int type; }; #endif } //namespace multi_array } // namespace detail template class multi_array : public multi_array_ref { typedef multi_array_ref super_type; public: typedef typename super_type::value_type value_type; typedef typename super_type::reference reference; typedef typename super_type::const_reference const_reference; typedef typename super_type::iterator iterator; typedef typename super_type::const_iterator const_iterator; typedef typename super_type::reverse_iterator reverse_iterator; typedef typename super_type::const_reverse_iterator const_reverse_iterator; typedef typename super_type::element element; typedef typename super_type::size_type size_type; typedef typename super_type::difference_type difference_type; typedef typename super_type::index index; typedef typename super_type::extent_range extent_range; template struct const_array_view { typedef boost::detail::multi_array::const_multi_array_view type; }; template struct array_view { typedef boost::detail::multi_array::multi_array_view type; }; explicit multi_array() : super_type((T*)initial_base_,c_storage_order(), /*index_bases=*/0, /*extents=*/0) { allocate_space(); } template explicit multi_array( ExtentList const& extents #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING , typename mpl::if_< detail::multi_array::is_multi_array_impl, int&,int>::type* = 0 #endif ) : super_type((T*)initial_base_,extents) { boost::function_requires< detail::multi_array::CollectionConcept >(); allocate_space(); } template explicit multi_array(ExtentList const& extents, const general_storage_order& so) : super_type((T*)initial_base_,extents,so) { boost::function_requires< detail::multi_array::CollectionConcept >(); allocate_space(); } template explicit multi_array(ExtentList const& extents, const general_storage_order& so, Allocator const& alloc) : super_type((T*)initial_base_,extents,so), allocator_(alloc) { boost::function_requires< detail::multi_array::CollectionConcept >(); allocate_space(); } explicit multi_array(const detail::multi_array ::extent_gen& ranges) : super_type((T*)initial_base_,ranges) { allocate_space(); } explicit multi_array(const detail::multi_array ::extent_gen& ranges, const general_storage_order& so) : super_type((T*)initial_base_,ranges,so) { allocate_space(); } explicit multi_array(const detail::multi_array ::extent_gen& ranges, const general_storage_order& so, Allocator const& alloc) : super_type((T*)initial_base_,ranges,so), allocator_(alloc) { allocate_space(); } multi_array(const multi_array& rhs) : super_type(rhs), allocator_(rhs.allocator_) { allocate_space(); boost::copy_n(rhs.base_,rhs.num_elements(),base_); } // // A multi_array is constructible from any multi_array_ref, subarray, or // array_view object. The following constructors ensure that. // // Due to limited support for partial template ordering, // MSVC 6&7 confuse the following with the most basic ExtentList // constructor. #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING template multi_array(const const_multi_array_ref& rhs, const general_storage_order& so = c_storage_order()) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); // Warning! storage order may change, hence the following copy technique. std::copy(rhs.begin(),rhs.end(),this->begin()); } template multi_array(const detail::multi_array:: const_sub_array& rhs, const general_storage_order& so = c_storage_order()) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } template multi_array(const detail::multi_array:: const_multi_array_view& rhs, const general_storage_order& so = c_storage_order()) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } #else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING // More limited support for MSVC multi_array(const const_multi_array_ref& rhs) : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) { allocate_space(); // Warning! storage order may change, hence the following copy technique. std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const const_multi_array_ref& rhs, const general_storage_order& so) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); // Warning! storage order may change, hence the following copy technique. std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: const_sub_array& rhs) : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: const_sub_array& rhs, const general_storage_order& so) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: const_multi_array_view& rhs) : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: const_multi_array_view& rhs, const general_storage_order& so) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } #endif // !BOOST_NO_FUNCTION_TEMPLATE_ORDERING // Thes constructors are necessary because of more exact template matches. multi_array(const multi_array_ref& rhs) : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) { allocate_space(); // Warning! storage order may change, hence the following copy technique. std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const multi_array_ref& rhs, const general_storage_order& so) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); // Warning! storage order may change, hence the following copy technique. std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: sub_array& rhs) : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: sub_array& rhs, const general_storage_order& so) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: multi_array_view& rhs) : super_type(0,c_storage_order(),rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } multi_array(const detail::multi_array:: multi_array_view& rhs, const general_storage_order& so) : super_type(0,so,rhs.index_bases(),rhs.shape()) { allocate_space(); std::copy(rhs.begin(),rhs.end(),this->begin()); } // Since assignment is a deep copy, multi_array_ref // contains all the necessary code. template multi_array& operator=(const ConstMultiArray& other) { super_type::operator=(other); return *this; } multi_array& operator=(const multi_array& other) { if (&other != this) { super_type::operator=(other); } return *this; } multi_array& resize(const detail::multi_array ::extent_gen& ranges) { // build a multi_array with the specs given multi_array new_array(ranges); // build a view of tmp with the minimum extents // Get the minimum extents of the arrays. boost::array min_extents; const size_type& (*min)(const size_type&, const size_type&) = std::min; std::transform(new_array.extent_list_.begin(),new_array.extent_list_.end(), this->extent_list_.begin(), min_extents.begin(), min); // typedef boost::array index_list; // Build index_gen objects to create views with the same shape // these need to be separate to handle non-zero index bases typedef detail::multi_array::index_gen index_gen; index_gen old_idxes; index_gen new_idxes; std::transform(new_array.index_base_list_.begin(), new_array.index_base_list_.end(), min_extents.begin(),old_idxes.ranges_.begin(), detail::multi_array::populate_index_ranges()); std::transform(this->index_base_list_.begin(), this->index_base_list_.end(), min_extents.begin(),new_idxes.ranges_.begin(), detail::multi_array::populate_index_ranges()); // Build same-shape views of the two arrays typename multi_array::BOOST_NESTED_TEMPLATE array_view::type view_old = (*this)[old_idxes]; typename multi_array::BOOST_NESTED_TEMPLATE array_view::type view_new = new_array[new_idxes]; // Set the right portion of the new array view_new = view_old; using std::swap; // Swap the internals of these arrays. swap(this->super_type::base_,new_array.super_type::base_); swap(this->storage_,new_array.storage_); swap(this->extent_list_,new_array.extent_list_); swap(this->stride_list_,new_array.stride_list_); swap(this->index_base_list_,new_array.index_base_list_); swap(this->origin_offset_,new_array.origin_offset_); swap(this->directional_offset_,new_array.directional_offset_); swap(this->num_elements_,new_array.num_elements_); swap(this->allocator_,new_array.allocator_); swap(this->base_,new_array.base_); swap(this->allocated_elements_,new_array.allocated_elements_); return *this; } ~multi_array() { deallocate_space(); } private: void allocate_space() { typename Allocator::const_pointer no_hint=0; base_ = allocator_.allocate(this->num_elements(),no_hint); this->set_base_ptr(base_); allocated_elements_ = this->num_elements(); std::uninitialized_fill_n(base_,allocated_elements_,T()); } void deallocate_space() { if(base_) { for(T* i = base_; i != base_+allocated_elements_; ++i) allocator_.destroy(i); allocator_.deallocate(base_,allocated_elements_); } } typedef boost::array size_list; typedef boost::array index_list; Allocator allocator_; T* base_; size_type allocated_elements_; enum {initial_base_ = 0}; }; } // namespace boost #endif // BOOST_MULTI_ARRAY_RG071801_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/static_assert.hpp0000644000175000017500000001030611344301501031022 0ustar debiandebian// (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the // Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/static_assert for documentation. /* Revision history: 02 August 2000 Initial version. */ #ifndef BOOST_STATIC_ASSERT_HPP #define BOOST_STATIC_ASSERT_HPP #include #include #ifdef __BORLANDC__ // // workaround for buggy integral-constant expression support: #define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS #endif #if defined(__GNUC__) && (__GNUC__ == 3) && ((__GNUC_MINOR__ == 3) || (__GNUC_MINOR__ == 4)) // gcc 3.3 and 3.4 don't produce good error messages with the default version: # define BOOST_SA_GCC_WORKAROUND #endif namespace boost{ // HP aCC cannot deal with missing names for template value parameters template struct STATIC_ASSERTION_FAILURE; template <> struct STATIC_ASSERTION_FAILURE { enum { value = 1 }; }; // HP aCC cannot deal with missing names for template value parameters template struct static_assert_test{}; } // // Implicit instantiation requires that all member declarations be // instantiated, but that the definitions are *not* instantiated. // // It's not particularly clear how this applies to enum's or typedefs; // both are described as declarations [7.1.3] and [7.2] in the standard, // however some compilers use "delayed evaluation" of one or more of // these when implicitly instantiating templates. We use typedef declarations // by default, but try defining BOOST_USE_ENUM_STATIC_ASSERT if the enum // version gets better results from your compiler... // // Implementation: // Both of these versions rely on sizeof(incomplete_type) generating an error // message containing the name of the incomplete type. We use // "STATIC_ASSERTION_FAILURE" as the type name here to generate // an eye catching error message. The result of the sizeof expression is either // used as an enum initialiser, or as a template argument depending which version // is in use... // Note that the argument to the assert is explicitly cast to bool using old- // style casts: too many compilers currently have problems with static_cast // when used inside integral constant expressions. // #if !defined(BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS) && \ !BOOST_WORKAROUND(__MWERKS__, < 0x3003) #if defined(BOOST_MSVC) && (BOOST_MSVC < 1300) // __LINE__ macro broken when -ZI is used see Q199057 // fortunately MSVC ignores duplicate typedef's. #define BOOST_STATIC_ASSERT( B ) \ typedef ::boost::static_assert_test<\ sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)\ > boost_static_assert_typedef_ #elif defined(BOOST_MSVC) #define BOOST_STATIC_ASSERT( B ) \ typedef ::boost::static_assert_test<\ sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\ BOOST_JOIN(boost_static_assert_typedef_, __COUNTER__) #elif defined(BOOST_INTEL_CXX_VERSION) || defined(BOOST_SA_GCC_WORKAROUND) // agurt 15/sep/02: a special care is needed to force Intel C++ issue an error // instead of warning in case of failure # define BOOST_STATIC_ASSERT( B ) \ typedef char BOOST_JOIN(boost_static_assert_typedef_, __LINE__) \ [ ::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >::value ] #elif defined(__sgi) // special version for SGI MIPSpro compiler #define BOOST_STATIC_ASSERT( B ) \ BOOST_STATIC_CONSTANT(bool, \ BOOST_JOIN(boost_static_assert_test_, __LINE__) = ( B )); \ typedef ::boost::static_assert_test<\ sizeof(::boost::STATIC_ASSERTION_FAILURE< \ BOOST_JOIN(boost_static_assert_test_, __LINE__) >)>\ BOOST_JOIN(boost_static_assert_typedef_, __LINE__) #else // generic version #define BOOST_STATIC_ASSERT( B ) \ typedef ::boost::static_assert_test<\ sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >)>\ BOOST_JOIN(boost_static_assert_typedef_, __LINE__) #endif #else // alternative enum based implementation: #define BOOST_STATIC_ASSERT( B ) \ enum { BOOST_JOIN(boost_static_assert_enum_, __LINE__) \ = sizeof(::boost::STATIC_ASSERTION_FAILURE< (bool)( B ) >) } #endif #endif // BOOST_STATIC_ASSERT_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/regex.hpp0000644000175000017500000000160411344301501027265 0ustar debiandebian/* * * Copyright (c) 1998-2002 * Dr John Maddock * * Use, modification and distribution are subject to the * Boost Software License, Version 1.0. (See accompanying file * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) * */ /* * LOCATION: see http://www.boost.org/libs/regex for documentation. * FILE regex.cpp * VERSION see * DESCRIPTION: Declares boost::reg_expression<> and associated * functions and classes. This header is the main * entry point for the template regex code. */ /* start with C compatibility API */ #ifndef BOOST_RE_REGEX_HPP #define BOOST_RE_REGEX_HPP #ifndef BOOST_REGEX_CONFIG_HPP #include #endif #ifdef BOOST_REGEX_V3 #include #else #include #endif #endif // include mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/0000755000175000017500000000000012146213774027163 5ustar debiandebian././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/value_init.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/value_init.hp0000644000175000017500000000245611344301502031644 0ustar debiandebian// (C) 2002, Fernando Luis Cacciola Carballal. // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // 21 Ago 2002 (Created) Fernando Cacciola // #ifndef BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP #define BOOST_UTILITY_VALUE_INIT_21AGO2002_HPP #include "boost/detail/select_type.hpp" #include "boost/type_traits/cv_traits.hpp" namespace boost { namespace vinit_detail { template class const_T_base { protected : const_T_base() : x() {} T x ; } ; template struct non_const_T_base { protected : non_const_T_base() : x() {} mutable T x ; } ; template struct select_base { typedef typename detail::if_true< ::boost::is_const::value > ::template then< const_T_base, non_const_T_base >::type type ; } ; } // namespace vinit_detail template class value_initialized : private vinit_detail::select_base::type { public : value_initialized() {} operator T&() const { return this->x ; } T& data() const { return this->x ; } } ; template T const& get ( value_initialized const& x ) { return x.data() ; } template T& get ( value_initialized& x ) { return x.data() ; } } // namespace boost #endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/compare_pointees.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/compare_point0000644000175000017500000000416311344301502031733 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP #define BOOST_UTILITY_COMPARE_POINTEES_25AGO2003_HPP #include namespace boost { // template bool equal_pointees(OP const& x, OP const& y); // template struct equal_pointees_t; // // Being OP a model of OptionalPointee (either a pointer or an optional): // // If both x and y have valid pointees, returns the result of (*x == *y) // If only one has a valid pointee, returns false. // If none have valid pointees, returns true. // No-throw template inline bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y ) { return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ; } template struct equal_pointees_t : std::binary_function { bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const { return equal_pointees(x,y) ; } } ; // template bool less_pointees(OP const& x, OP const& y); // template struct less_pointees_t; // // Being OP a model of OptionalPointee (either a pointer or an optional): // // If y has not a valid pointee, returns false. // ElseIf x has not a valid pointee, returns true. // ElseIf both x and y have valid pointees, returns the result of (*x < *y) // No-throw template inline bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y ) { return !y ? false : ( !x ? true : (*x) < (*y) ) ; } template struct less_pointees_t : std::binary_function { bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const { return less_pointees(x,y) ; } } ; } // namespace boost #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/addressof.hpp0000644000175000017500000000204011344301502031624 0ustar debiandebian// Copyright (C) 2002 Brad King (brad.king@kitware.com) // Douglas Gregor (gregod@cs.rpi.edu) // Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org #ifndef BOOST_UTILITY_ADDRESSOF_HPP # define BOOST_UTILITY_ADDRESSOF_HPP # include # include # if BOOST_WORKAROUND(BOOST_MSVC, == 1300) # include # endif namespace boost { // Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov) // VC7 strips const from nested classes unless we add indirection here # if BOOST_WORKAROUND(BOOST_MSVC, == 1300) template typename add_pointer::type # else template T* # endif addressof(T& v) { return reinterpret_cast( &const_cast(reinterpret_cast(v))); } } #endif // BOOST_UTILITY_ADDRESSOF_HPP ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/typed_in_place_factory.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/typed_in_plac0000644000175000017500000000371511344301502031710 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP #define BOOST_UTILITY_TYPED_INPLACE_FACTORY_25AGO2003_HPP #include namespace boost { class typed_in_place_factory_base {} ; #define BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS(z,n,_) \ template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \ class BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) : public typed_in_place_factory_base \ { \ public: \ \ typedef T value_type ; \ \ BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \ : \ BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \ {} \ \ void apply ( void* address ) const \ { \ new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \ } \ \ BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \ } ; \ \ template< class T, BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \ BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T , BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \ in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \ { \ return BOOST_PP_CAT(typed_in_place_factory, BOOST_PP_INC(n) ) < T, BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \ ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \ } ; \ BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_TYPED_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() ) } // namespace boost #include #endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/in_place_factory.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/in_place_fact0000644000175000017500000000366311344301502031647 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP #define BOOST_UTILITY_INPLACE_FACTORY_25AGO2003_HPP #include #include namespace boost { class in_place_factory_base {} ; #define BOOST_DEFINE_INPLACE_FACTORY_CLASS(z,n,_) \ template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \ class BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) : public in_place_factory_base \ { \ public: \ \ BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A,const& a) ) \ : \ BOOST_PP_ENUM( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT, _ ) \ {} \ \ template \ void apply ( void* address BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) ) const \ { \ new ( address ) T ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), m_a ) ) ; \ } \ \ BOOST_PP_REPEAT( BOOST_PP_INC(n), BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL, _) \ } ; \ \ template< BOOST_PP_ENUM_PARAMS(BOOST_PP_INC(n),class A) > \ BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \ in_place ( BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_INC(n),A, const& a) ) \ { \ return BOOST_PP_CAT(in_place_factory, BOOST_PP_INC(n) ) < BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), A ) > \ ( BOOST_PP_ENUM_PARAMS( BOOST_PP_INC(n), a ) ) ; \ } ; \ BOOST_PP_REPEAT( BOOST_MAX_INPLACE_FACTORY_ARITY, BOOST_DEFINE_INPLACE_FACTORY_CLASS, BOOST_PP_EMPTY() ) } // namespace boost #include #endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/base_from_member.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/base_from_mem0000644000175000017500000000563311344301502031672 0ustar debiandebian// boost utility/base_from_member.hpp header file --------------------------// // Copyright 2001, 2003, 2004 Daryle Walker. Use, modification, and // distribution are subject to the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or a copy at // .) // See for the library's home page. #ifndef BOOST_UTILITY_BASE_FROM_MEMBER_HPP #define BOOST_UTILITY_BASE_FROM_MEMBER_HPP #include #include #include #include // Base-from-member arity configuration macro ------------------------------// // The following macro determines how many arguments will be in the largest // constructor template of base_from_member. Constructor templates will be // generated from one argument to this maximum. Code from other files can read // this number if they need to always match the exact maximum base_from_member // uses. The maximum constructor length can be changed by overriding the // #defined constant. Make sure to apply the override, if any, for all source // files during project compiling for consistency. // Contributed by Jonathan Turkanis #ifndef BOOST_BASE_FROM_MEMBER_MAX_ARITY #define BOOST_BASE_FROM_MEMBER_MAX_ARITY 10 #endif // An iteration of a constructor template for base_from_member -------------// // A macro that should expand to: // template < typename T1, ..., typename Tn > // base_from_member( T1 x1, ..., Tn xn ) // : member( x1, ..., xn ) // {} // This macro should only persist within this file. #define BOOST_PRIVATE_CTR_DEF( z, n, data ) \ template < BOOST_PP_ENUM_PARAMS(n, typename T) > \ explicit base_from_member( BOOST_PP_ENUM_BINARY_PARAMS(n, T, x) ) \ : member( BOOST_PP_ENUM_PARAMS(n, x) ) \ {} \ /**/ namespace boost { // Base-from-member class template -----------------------------------------// // Helper to initialize a base object so a derived class can use this // object in the initialization of another base class. Used by // Dietmar Kuehl from ideas by Ron Klatcho to solve the problem of a // base class needing to be initialized by a member. // Contributed by Daryle Walker template < typename MemberType, int UniqueID = 0 > class base_from_member { protected: MemberType member; base_from_member() : member() {} BOOST_PP_REPEAT_FROM_TO( 1, BOOST_PP_INC(BOOST_BASE_FROM_MEMBER_MAX_ARITY), BOOST_PRIVATE_CTR_DEF, _ ) }; // boost::base_from_member } // namespace boost // Undo any private macros #undef BOOST_PRIVATE_CTR_DEF #endif // BOOST_UTILITY_BASE_FROM_MEMBER_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/enable_if.hpp0000644000175000017500000000603411344301502031565 0ustar debiandebian// Boost enable_if library // Copyright 2003 © The Trustees of Indiana University. // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // Authors: Jaakko Järvi (jajarvi at osl.iu.edu) // Jeremiah Willcock (jewillco at osl.iu.edu) // Andrew Lumsdaine (lums at osl.iu.edu) #ifndef BOOST_UTILITY_ENABLE_IF_HPP #define BOOST_UTILITY_ENABLE_IF_HPP #include "boost/config.hpp" // Even the definition of enable_if causes problems on some compilers, // so it's macroed out for all compilers that do not support SFINAE #ifndef BOOST_NO_SFINAE namespace boost { template struct enable_if_c { typedef T type; }; template struct enable_if_c {}; template struct enable_if : public enable_if_c {}; template struct lazy_enable_if_c { typedef typename T::type type; }; template struct lazy_enable_if_c {}; template struct lazy_enable_if : public lazy_enable_if_c {}; template struct disable_if_c { typedef T type; }; template struct disable_if_c {}; template struct disable_if : public disable_if_c {}; template struct lazy_disable_if_c { typedef typename T::type type; }; template struct lazy_disable_if_c {}; template struct lazy_disable_if : public lazy_disable_if_c {}; } // namespace boost #else namespace boost { namespace detail { typedef void enable_if_default_T; } template struct enable_if_does_not_work_on_this_compiler; template struct enable_if_c : enable_if_does_not_work_on_this_compiler { }; template struct disable_if_c : enable_if_does_not_work_on_this_compiler { }; template struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler { }; template struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler { }; template struct enable_if : enable_if_does_not_work_on_this_compiler { }; template struct disable_if : enable_if_does_not_work_on_this_compiler { }; template struct lazy_enable_if : enable_if_does_not_work_on_this_compiler { }; template struct lazy_disable_if : enable_if_does_not_work_on_this_compiler { }; } // namespace boost #endif // BOOST_NO_SFINAE #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/0000755000175000017500000000000012146213774030425 5ustar debiandebian././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/result_of_iterate.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/result0000644000175000017500000000540611344301502031655 0ustar debiandebian// Boost result_of library // Copyright Douglas Gregor 2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/utility #if !defined(BOOST_PP_IS_ITERATING) # error Boost result_of - do not include this file! #endif // CWPro8 requires an argument in a function type specialization #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3002)) && BOOST_PP_ITERATION() == 0 # define BOOST_RESULT_OF_ARGS void #else # define BOOST_RESULT_OF_ARGS BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(),T) #endif #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) template struct result_of : detail::result_of {}; #endif namespace detail { template struct result_of { typedef R type; }; template struct result_of { typedef R type; }; #undef BOOST_RESULT_OF_ARGS #if BOOST_PP_ITERATION() > 1 && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551)) template struct result_of { typedef R type; }; template struct result_of { typedef R type; }; template struct result_of { typedef R type; }; template struct result_of { typedef R type; }; #endif } ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/in_place_factory_prefix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/in_pla0000644000175000017500000000252411344301502031577 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP #define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP #include #include #include #include #include #include #include #include #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT(z,n,_) BOOST_PP_CAT(m_a,n) BOOST_PP_LPAREN() BOOST_PP_CAT(a,n) BOOST_PP_RPAREN() #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL(z,n,_) BOOST_PP_CAT(A,n) const& BOOST_PP_CAT(m_a,n); #define BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG(z,n,_) BOOST_PP_CAT(m_a,n) #define BOOST_MAX_INPLACE_FACTORY_ARITY 10 #undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP #endif ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/in_place_factory_suffix.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/detail/in_pla0000644000175000017500000000144411344301502031577 0ustar debiandebian// Copyright (C) 2003, Fernando Luis Cacciola Carballal. // // Use, modification, and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/lib/optional for documentation. // // You are welcome to contact the author at: // fernando_cacciola@hotmail.com // #ifndef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP #define BOOST_UTILITY_DETAIL_INPLACE_FACTORY_SUFFIX_25AGO2003_HPP #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_INIT #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_DECL #undef BOOST_DEFINE_INPLACE_FACTORY_CLASS_MEMBER_ARG #undef BOOST_MAX_INPLACE_FACTORY_ARITY #undef BOOST_UTILITY_DETAIL_INPLACE_FACTORY_PREFIX_25AGO2003_HPP #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility/result_of.hpp0000644000175000017500000000321311344301502031657 0ustar debiandebian// Boost result_of library // Copyright Douglas Gregor 2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/utility #ifndef BOOST_RESULT_OF_HPP #define BOOST_RESULT_OF_HPP #include #include #include #include #include #include #ifndef BOOST_RESULT_OF_NUM_ARGS # define BOOST_RESULT_OF_NUM_ARGS 10 #endif namespace boost { template struct result_of; #if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace detail { BOOST_MPL_HAS_XXX_TRAIT_DEF(result_type) template struct get_result_of; template struct get_result_of { typedef typename F::result_type type; }; template struct get_result_of { typedef typename F::template result::type type; }; template struct get_result_of { typedef void type; }; template struct result_of : get_result_of::value)> {}; } // end namespace detail #define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,)) #include BOOST_PP_ITERATE() } #else # error Your compiler cannot support class template result_of #endif #endif // BOOST_RESULT_OF_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/limits.hpp0000644000175000017500000001370011344301501027454 0ustar debiandebian // (C) Copyright John maddock 1999. // (C) David Abrahams 2002. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // use this header as a workaround for missing // See http://www.boost.org/libs/utility/limits.html for documentation. #ifndef BOOST_LIMITS #define BOOST_LIMITS #include #ifdef BOOST_NO_LIMITS # include #else # include #endif #if (defined(BOOST_HAS_LONG_LONG) && defined(BOOST_NO_LONG_LONG_NUMERIC_LIMITS)) \ || (defined(BOOST_HAS_MS_INT64) && defined(BOOST_NO_MS_INT64_NUMERIC_LIMITS)) // Add missing specializations for numeric_limits: #ifdef BOOST_HAS_MS_INT64 # define BOOST_LLT __int64 # define BOOST_ULLT unsigned __int64 #else # define BOOST_LLT ::boost::long_long_type # define BOOST_ULLT ::boost::ulong_long_type #endif namespace std { template<> class numeric_limits { public: BOOST_STATIC_CONSTANT(bool, is_specialized = true); #ifdef BOOST_HAS_MS_INT64 static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x8000000000000000i64; } static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0x7FFFFFFFFFFFFFFFi64; } #elif defined(LLONG_MAX) static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MIN; } static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LLONG_MAX; } #elif defined(LONGLONG_MAX) static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MIN; } static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return LONGLONG_MAX; } #else static BOOST_LLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 1LL << (sizeof(BOOST_LLT) * CHAR_BIT - 1); } static BOOST_LLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~(min)(); } #endif BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT -1); BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT) - 1) * 301L / 1000); BOOST_STATIC_CONSTANT(bool, is_signed = true); BOOST_STATIC_CONSTANT(bool, is_integer = true); BOOST_STATIC_CONSTANT(bool, is_exact = true); BOOST_STATIC_CONSTANT(int, radix = 2); static BOOST_LLT epsilon() throw() { return 0; }; static BOOST_LLT round_error() throw() { return 0; }; BOOST_STATIC_CONSTANT(int, min_exponent = 0); BOOST_STATIC_CONSTANT(int, min_exponent10 = 0); BOOST_STATIC_CONSTANT(int, max_exponent = 0); BOOST_STATIC_CONSTANT(int, max_exponent10 = 0); BOOST_STATIC_CONSTANT(bool, has_infinity = false); BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false); BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false); BOOST_STATIC_CONSTANT(bool, has_denorm = false); BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false); static BOOST_LLT infinity() throw() { return 0; }; static BOOST_LLT quiet_NaN() throw() { return 0; }; static BOOST_LLT signaling_NaN() throw() { return 0; }; static BOOST_LLT denorm_min() throw() { return 0; }; BOOST_STATIC_CONSTANT(bool, is_iec559 = false); BOOST_STATIC_CONSTANT(bool, is_bounded = false); BOOST_STATIC_CONSTANT(bool, is_modulo = false); BOOST_STATIC_CONSTANT(bool, traps = false); BOOST_STATIC_CONSTANT(bool, tinyness_before = false); BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero); }; template<> class numeric_limits { public: BOOST_STATIC_CONSTANT(bool, is_specialized = true); #ifdef BOOST_HAS_MS_INT64 static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0ui64; } static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0xFFFFFFFFFFFFFFFFui64; } #elif defined(ULLONG_MAX) && defined(ULLONG_MIN) static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MIN; } static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULLONG_MAX; } #elif defined(ULONGLONG_MAX) && defined(ULONGLONG_MIN) static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MIN; } static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ULONGLONG_MAX; } #else static BOOST_ULLT min BOOST_PREVENT_MACRO_SUBSTITUTION (){ return 0uLL; } static BOOST_ULLT max BOOST_PREVENT_MACRO_SUBSTITUTION (){ return ~0uLL; } #endif BOOST_STATIC_CONSTANT(int, digits = sizeof(BOOST_LLT) * CHAR_BIT); BOOST_STATIC_CONSTANT(int, digits10 = (CHAR_BIT * sizeof (BOOST_LLT)) * 301L / 1000); BOOST_STATIC_CONSTANT(bool, is_signed = false); BOOST_STATIC_CONSTANT(bool, is_integer = true); BOOST_STATIC_CONSTANT(bool, is_exact = true); BOOST_STATIC_CONSTANT(int, radix = 2); static BOOST_ULLT epsilon() throw() { return 0; }; static BOOST_ULLT round_error() throw() { return 0; }; BOOST_STATIC_CONSTANT(int, min_exponent = 0); BOOST_STATIC_CONSTANT(int, min_exponent10 = 0); BOOST_STATIC_CONSTANT(int, max_exponent = 0); BOOST_STATIC_CONSTANT(int, max_exponent10 = 0); BOOST_STATIC_CONSTANT(bool, has_infinity = false); BOOST_STATIC_CONSTANT(bool, has_quiet_NaN = false); BOOST_STATIC_CONSTANT(bool, has_signaling_NaN = false); BOOST_STATIC_CONSTANT(bool, has_denorm = false); BOOST_STATIC_CONSTANT(bool, has_denorm_loss = false); static BOOST_ULLT infinity() throw() { return 0; }; static BOOST_ULLT quiet_NaN() throw() { return 0; }; static BOOST_ULLT signaling_NaN() throw() { return 0; }; static BOOST_ULLT denorm_min() throw() { return 0; }; BOOST_STATIC_CONSTANT(bool, is_iec559 = false); BOOST_STATIC_CONSTANT(bool, is_bounded = false); BOOST_STATIC_CONSTANT(bool, is_modulo = false); BOOST_STATIC_CONSTANT(bool, traps = false); BOOST_STATIC_CONSTANT(bool, tinyness_before = false); BOOST_STATIC_CONSTANT(float_round_style, round_style = round_toward_zero); }; } #endif #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/signal.hpp0000644000175000017500000003072311344301501027434 0ustar debiandebian// Boost.Signals library // Copyright Douglas Gregor 2001-2004. Use, modification and // distribution is subject to the Boost Software License, Version // 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // For more information, see http://www.boost.org/libs/signals #ifndef BOOST_SIGNAL_HPP #define BOOST_SIGNAL_HPP #define BOOST_SIGNALS_MAX_ARGS 10 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_PREFIX #endif namespace boost { #ifndef BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX namespace BOOST_SIGNALS_NAMESPACE { namespace detail { template class real_get_signal_impl; template class real_get_signal_impl<0, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal0 type; }; template class real_get_signal_impl<1, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal1 type; }; template class real_get_signal_impl<2, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal2 type; }; template class real_get_signal_impl<3, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal3 type; }; template class real_get_signal_impl<4, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal4 type; }; template class real_get_signal_impl<5, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal5 type; }; template class real_get_signal_impl<6, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal6 type; }; template class real_get_signal_impl<7, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal7 type; }; template class real_get_signal_impl<8, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal8 type; }; template class real_get_signal_impl<9, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal9 type; }; template class real_get_signal_impl<10, Signature, Combiner, Group, GroupCompare, SlotFunction> { typedef function_traits traits; public: typedef signal10 type; }; template struct get_signal_impl : public real_get_signal_impl<(function_traits::arity), Signature, Combiner, Group, GroupCompare, SlotFunction> { }; } // end namespace detail } // end namespace BOOST_SIGNALS_NAMESPACE // Very lightweight wrapper around the signalN classes that allows signals to // be created where the number of arguments does not need to be part of the // class name. template< typename Signature, // function type R (T1, T2, ..., TN) typename Combiner = last_value::result_type>, typename Group = int, typename GroupCompare = std::less, typename SlotFunction = function > class signal : public BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl::type { typedef typename BOOST_SIGNALS_NAMESPACE::detail::get_signal_impl< Signature, Combiner, Group, GroupCompare, SlotFunction>::type base_type; public: explicit signal(const Combiner& combiner = Combiner(), const GroupCompare& group_compare = GroupCompare()) : base_type(combiner, group_compare) { } }; #endif // ndef BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX } // end namespace boost #ifdef BOOST_HAS_ABI_HEADERS # include BOOST_ABI_SUFFIX #endif #endif // BOOST_SIGNAL_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/token_functions.hpp0000644000175000017500000004301711344301501031367 0ustar debiandebian// Boost token_functions.hpp ------------------------------------------------// // Copyright John R. Bandela 2001. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/tokenizer for documentation. // Revision History: // 01 Oct 2004 Joaquín M López Muñoz // Workaround for a problem with string::assign in msvc-stlport // 06 Apr 2004 John Bandela // Fixed a bug involving using char_delimiter with a true input iterator // 28 Nov 2003 Robert Zeh and John Bandela // Converted into "fast" functions that avoid using += when // the supplied iterator isn't an input_iterator; based on // some work done at Archelon and a version that was checked into // the boost CVS for a short period of time. // 20 Feb 2002 John Maddock // Removed using namespace std declarations and added // workaround for BOOST_NO_STDC_NAMESPACE (the library // can be safely mixed with regex). // 06 Feb 2002 Jeremy Siek // Added char_separator. // 02 Feb 2002 Jeremy Siek // Removed tabs and a little cleanup. #ifndef BOOST_TOKEN_FUNCTIONS_JRB120303_HPP_ #define BOOST_TOKEN_FUNCTIONS_JRB120303_HPP_ #include #include #include #include #include #include // for find_if #include #include #include // // the following must not be macros if we are to prefix them // with std:: (they shouldn't be macros anyway...) // #ifdef ispunct # undef ispunct #endif #ifdef isspace # undef isspace #endif // // fix namespace problems: // #ifdef BOOST_NO_STDC_NAMESPACE namespace std{ using ::ispunct; using ::isspace; } #endif namespace boost{ //=========================================================================== // The escaped_list_separator class. Which is a model of TokenizerFunction // An escaped list is a super-set of what is commonly known as a comma // separated value (csv) list.It is separated into fields by a comma or // other character. If the delimiting character is inside quotes, then it is // counted as a regular character.To allow for embedded quotes in a field, // there can be escape sequences using the \ much like C. // The role of the comma, the quotation mark, and the escape // character (backslash \), can be assigned to other characters. struct escaped_list_error : public std::runtime_error{ escaped_list_error(const std::string& what):std::runtime_error(what) { } }; // The out of the box GCC 2.95 on cygwin does not have a char_traits class. // MSVC does not like the following typename #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 template ::traits_type > #else template ::traits_type > #endif class escaped_list_separator { private: typedef std::basic_string string_type; struct char_eq { Char e_; char_eq(Char e):e_(e) { } bool operator()(Char c) { return Traits::eq(e_,c); } }; string_type escape_; string_type c_; string_type quote_; bool last_; bool is_escape(Char e) { char_eq f(e); return std::find_if(escape_.begin(),escape_.end(),f)!=escape_.end(); } bool is_c(Char e) { char_eq f(e); return std::find_if(c_.begin(),c_.end(),f)!=c_.end(); } bool is_quote(Char e) { char_eq f(e); return std::find_if(quote_.begin(),quote_.end(),f)!=quote_.end(); } template void do_escape(iterator& next,iterator end,Token& tok) { if (++next == end) throw escaped_list_error(std::string("cannot end with escape")); if (Traits::eq(*next,'n')) { tok+='\n'; return; } else if (is_quote(*next)) { tok+=*next; return; } else if (is_c(*next)) { tok+=*next; return; } else if (is_escape(*next)) { tok+=*next; return; } else throw escaped_list_error(std::string("unknown escape sequence")); } public: explicit escaped_list_separator(Char e = '\\', Char c = ',',Char q = '\"') : escape_(1,e), c_(1,c), quote_(1,q), last_(false) { } escaped_list_separator(string_type e, string_type c, string_type q) : escape_(e), c_(c), quote_(q), last_(false) { } void reset() {last_=false;} template bool operator()(InputIterator& next,InputIterator end,Token& tok) { bool bInQuote = false; tok = Token(); if (next == end) { if (last_) { last_ = false; return true; } else return false; } last_ = false; for (;next != end;++next) { if (is_escape(*next)) { do_escape(next,end,tok); } else if (is_c(*next)) { if (!bInQuote) { // If we are not in quote, then we are done ++next; // The last character was a c, that means there is // 1 more blank field last_ = true; return true; } else tok+=*next; } else if (is_quote(*next)) { bInQuote=!bInQuote; } else { tok += *next; } } return true; } }; //=========================================================================== // The classes here are used by offset_separator and char_separator to implement // faster assigning of tokens using assign instead of += namespace tokenizer_detail { // The assign_or_plus_equal struct contains functions that implement // assign, +=, and clearing based on the iterator type. The // generic case does nothing for plus_equal and clearing, while // passing through the call for assign. // // When an input iterator is being used, the situation is reversed. // The assign method does nothing, plus_equal invokes operator +=, // and the clearing method sets the supplied token to the default // token constructor's result. // template struct assign_or_plus_equal { template static void assign(Iterator b, Iterator e, Token &t) { #if BOOST_WORKAROUND(BOOST_MSVC, == 1200) &&\ BOOST_WORKAROUND(__SGI_STL_PORT, < 0x500) &&\ defined(_STLP_DEBUG) &&\ (defined(_STLP_USE_DYNAMIC_LIB) || defined(_DLL)) // Problem with string::assign for msvc-stlport in debug mode: the // linker tries to import the templatized version of this memfun, // which is obviously not exported. // See http://www.stlport.com/dcforum/DCForumID6/1763.html for details. t = Token(); while(b != e) t += *b++; #else t.assign(b, e); #endif } template static void plus_equal(Token &, const Value &) { } // If we are doing an assign, there is no need for the // the clear. // template static void clear(Token &) { } }; template <> struct assign_or_plus_equal { template static void assign(Iterator b, Iterator e, Token &t) { } template static void plus_equal(Token &t, const Value &v) { t += v; } template static void clear(Token &t) { t = Token(); } }; template struct pointer_iterator_category{ typedef std::random_access_iterator_tag type; }; template struct class_iterator_category{ typedef typename Iterator::iterator_category type; }; // This portably gets the iterator_tag without partial template specialization template struct get_iterator_category{ typedef typename mpl::if_, pointer_iterator_category, class_iterator_category >::type cat; typedef typename cat::type iterator_category; }; } //=========================================================================== // The offset_separator class, which is a model of TokenizerFunction. // Offset breaks a string into tokens based on a range of offsets class offset_separator { private: std::vector offsets_; unsigned int current_offset_; bool wrap_offsets_; bool return_partial_last_; public: template offset_separator(Iter begin, Iter end, bool wrap_offsets = true, bool return_partial_last = true) : offsets_(begin,end), current_offset_(0), wrap_offsets_(wrap_offsets), return_partial_last_(return_partial_last) { } offset_separator() : offsets_(1,1), current_offset_(), wrap_offsets_(true), return_partial_last_(true) { } void reset() { current_offset_ = 0; } template bool operator()(InputIterator& next, InputIterator end, Token& tok) { typedef tokenizer_detail::assign_or_plus_equal< #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 typename #endif tokenizer_detail::get_iterator_category< InputIterator>::iterator_category> assigner; assert(!offsets_.empty()); assigner::clear(tok); InputIterator start(next); if (next == end) return false; if (current_offset_ == offsets_.size()) if (wrap_offsets_) current_offset_=0; else return false; int c = offsets_[current_offset_]; int i = 0; for (; i < c; ++i) { if (next == end)break; assigner::plus_equal(tok,*next++); } assigner::assign(start,next,tok); if (!return_partial_last_) if (i < (c-1) ) return false; ++current_offset_; return true; } }; //=========================================================================== // The char_separator class breaks a sequence of characters into // tokens based on the character delimiters (very much like bad old // strtok). A delimiter character can either be kept or dropped. A // kept delimiter shows up as an output token, whereas a dropped // delimiter does not. // This class replaces the char_delimiters_separator class. The // constructor for the char_delimiters_separator class was too // confusing and needed to be deprecated. However, because of the // default arguments to the constructor, adding the new constructor // would cause ambiguity, so instead I deprecated the whole class. // The implementation of the class was also simplified considerably. enum empty_token_policy { drop_empty_tokens, keep_empty_tokens }; // The out of the box GCC 2.95 on cygwin does not have a char_traits class. #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 template ::traits_type > #else template ::traits_type > #endif class char_separator { typedef std::basic_string string_type; public: explicit char_separator(const Char* dropped_delims, const Char* kept_delims = 0, empty_token_policy empty_tokens = drop_empty_tokens) : m_dropped_delims(dropped_delims), m_use_ispunct(false), m_use_isspace(false), m_empty_tokens(empty_tokens), m_output_done(false) { // Borland workaround if (kept_delims) m_kept_delims = kept_delims; } // use ispunct() for kept delimiters and isspace for dropped. explicit char_separator() : m_use_ispunct(true), m_use_isspace(true), m_empty_tokens(drop_empty_tokens) { } void reset() { } template bool operator()(InputIterator& next, InputIterator end, Token& tok) { typedef tokenizer_detail::assign_or_plus_equal< #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 typename #endif tokenizer_detail::get_iterator_category< InputIterator>::iterator_category> assigner; assigner::clear(tok); // skip past all dropped_delims if (m_empty_tokens == drop_empty_tokens) for (; next != end && is_dropped(*next); ++next) { } InputIterator start(next); if (m_empty_tokens == drop_empty_tokens) { if (next == end) return false; // if we are on a kept_delims move past it and stop if (is_kept(*next)) { assigner::plus_equal(tok,*next); ++next; } else // append all the non delim characters for (; next != end && !is_dropped(*next) && !is_kept(*next); ++next) assigner::plus_equal(tok,*next); } else { // m_empty_tokens == keep_empty_tokens // Handle empty token at the end if (next == end) if (m_output_done == false) { m_output_done = true; assigner::assign(start,next,tok); return true; } else return false; if (is_kept(*next)) { if (m_output_done == false) m_output_done = true; else { assigner::plus_equal(tok,*next); ++next; m_output_done = false; } } else if (m_output_done == false && is_dropped(*next)) { m_output_done = true; } else { if (is_dropped(*next)) start=++next; for (; next != end && !is_dropped(*next) && !is_kept(*next); ++next) assigner::plus_equal(tok,*next); m_output_done = true; } } assigner::assign(start,next,tok); return true; } private: string_type m_kept_delims; string_type m_dropped_delims; bool m_use_ispunct; bool m_use_isspace; empty_token_policy m_empty_tokens; bool m_output_done; bool is_kept(Char E) const { if (m_kept_delims.length()) return m_kept_delims.find(E) != string_type::npos; else if (m_use_ispunct) { return std::ispunct(E) != 0; } else return false; } bool is_dropped(Char E) const { if (m_dropped_delims.length()) return m_dropped_delims.find(E) != string_type::npos; else if (m_use_isspace) { return std::isspace(E) != 0; } else return false; } }; //=========================================================================== // The following class is DEPRECATED, use class char_separators instead. // // The char_delimiters_separator class, which is a model of // TokenizerFunction. char_delimiters_separator breaks a string // into tokens based on character delimiters. There are 2 types of // delimiters. returnable delimiters can be returned as // tokens. These are often punctuation. nonreturnable delimiters // cannot be returned as tokens. These are often whitespace // The out of the box GCC 2.95 on cygwin does not have a char_traits class. #if !defined(BOOST_MSVC) || BOOST_MSVC > 1300 template ::traits_type > #else template ::traits_type > #endif class char_delimiters_separator { private: typedef std::basic_string string_type; string_type returnable_; string_type nonreturnable_; bool return_delims_; bool no_ispunct_; bool no_isspace_; bool is_ret(Char E)const { if (returnable_.length()) return returnable_.find(E) != string_type::npos; else{ if (no_ispunct_) {return false;} else{ int r = std::ispunct(E); return r != 0; } } } bool is_nonret(Char E)const { if (nonreturnable_.length()) return nonreturnable_.find(E) != string_type::npos; else{ if (no_isspace_) {return false;} else{ int r = std::isspace(E); return r != 0; } } } public: explicit char_delimiters_separator(bool return_delims = false, const Char* returnable = 0, const Char* nonreturnable = 0) : returnable_(returnable ? returnable : string_type().c_str()), nonreturnable_(nonreturnable ? nonreturnable:string_type().c_str()), return_delims_(return_delims), no_ispunct_(returnable!=0), no_isspace_(nonreturnable!=0) { } void reset() { } public: template bool operator()(InputIterator& next, InputIterator end,Token& tok) { tok = Token(); // skip past all nonreturnable delims // skip past the returnable only if we are not returning delims for (;next!=end && ( is_nonret(*next) || (is_ret(*next) && !return_delims_ ) );++next) { } if (next == end) { return false; } // if we are to return delims and we are one a returnable one // move past it and stop if (is_ret(*next) && return_delims_) { tok+=*next; ++next; } else // append all the non delim characters for (;next!=end && !is_nonret(*next) && !is_ret(*next);++next) tok+=*next; return true; } }; } //namespace boost #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/pfto.hpp0000644000175000017500000000466411344301501027134 0ustar debiandebian#ifndef BOOST_PFTO_HPP #define BOOST_PFTO_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // pfto.hpp: workarounds for compilers which have problems supporting // Partial Function Template Ordering (PFTO). // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org for updates, documentation, and revision history. // PFTO version is used to specify the last argument of certain functions // Function it is used to support compilers that fail to support correct Partial // Template Ordering #include // some compilers can use an exta argument and use function overloading // to choose desired function. This extra argument is long in the default // function implementation and int for the rest. The function is called // with an int argument. This first attempts to match functions with an // int argument before the default one (with a long argument). This is // known to function with VC 6.0. On other compilers this fails (Borland) // or causes other problems (GCC). note: this #if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) #define BOOST_PFTO long #else #define BOOST_PFTO #endif // here's another approach. Rather than use a default function - make sure // there is no default at all by requiring that all function invocations // have a "wrapped" argument type. This solves a problem with VC 6.0 // (and perhaps others) while implementing templated constructors. namespace boost { template struct pfto_wrapper { const T & t; operator const T & (){ return t; } pfto_wrapper (const T & rhs) : t(rhs) {} }; template pfto_wrapper make_pfto_wrapper(const T & t, BOOST_PFTO int){ return pfto_wrapper(t); } template pfto_wrapper make_pfto_wrapper(const pfto_wrapper & t, int){ return t; } } // namespace boost #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING #define BOOST_PFTO_WRAPPER(T) boost::pfto_wrapper #define BOOST_MAKE_PFTO_WRAPPER(t) boost::make_pfto_wrapper(t, 0) #else #define BOOST_PFTO_WRAPPER(T) T #define BOOST_MAKE_PFTO_WRAPPER(t) t #endif #endif // BOOST_PFTO_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/utility.hpp0000644000175000017500000000130111344301501027650 0ustar debiandebian// Boost utility.hpp header file -------------------------------------------// // Copyright 1999-2003 Aleksey Gurtovoy. Use, modification, and distribution are // subject to the Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or a copy at .) // See for the library's home page. #ifndef BOOST_UTILITY_HPP #define BOOST_UTILITY_HPP #include #include #include #include #include #include #endif // BOOST_UTILITY_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/static_warning.hpp0000644000175000017500000001724411344301501031176 0ustar debiandebian#ifndef BOOST_STATIC_WARNING_HPP #define BOOST_STATIC_WARNING_HPP // (C) Copyright Robert Ramey 2003. Jonathan Turkanis 2004. // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/static_assert for documentation. /* Revision history: 15 June 2003 - Initial version. 31 March 2004 - improved diagnostic messages and portability (Jonathan Turkanis) 03 April 2004 - works on VC6 at class and namespace scope - ported to DigitalMars - static warnings disabled by default; when enabled, uses pragmas to enable required compiler warnings on MSVC, Intel, Metrowerks and Borland 5.x. (Jonathan Turkanis) 30 May 2004 - tweaked for msvc 7.1 and gcc 3.3 - static warnings ENabled by default; when enabled, (Robert Ramey) */ #include // // Implementation // Makes use of the following warnings: // 1. GCC prior to 3.3: division by zero. // 2. BCC 6.0 preview: unreferenced local variable. // 3. DigitalMars: returning address of local automatic variable. // 4. VC6: class previously seen as struct (as in 'boost/mpl/print.hpp') // 5. All others: deletion of pointer to incomplete type. // // The trick is to find code which produces warnings containing the name of // a structure or variable. Details, with same numbering as above: // 1. static_warning_impl::value is zero iff B is false, so diving an int // by this value generates a warning iff B is false. // 2. static_warning_impl::type has a constructor iff B is true, so an // unreferenced variable of this type generates a warning iff B is false. // 3. static_warning_impl::type overloads operator& to return a dynamically // allocated int pointer only is B is true, so returning the address of an // automatic variable of this type generates a warning iff B is fasle. // 4. static_warning_impl::STATIC_WARNING is decalred as a struct iff B is // false. // 5. static_warning_impl::type is incomplete iff B is false, so deleting a // pointer to this type generates a warning iff B is false. // //------------------Enable selected warnings----------------------------------// // Enable the warnings relied on by BOOST_STATIC_WARNING, where possible. The // only pragma which is absolutely necessary here is for Borland 5.x, since // W8073 is disabled by default. If enabling selected warnings is considered // unacceptable, this section can be replaced with: // #if defined(__BORLANDC__) && (__BORLANDC__ <= 0x600) // pragma warn +stu // #endif # if defined(BOOST_MSVC) # pragma warning(2:4150) // C4150: deletion of pointer to incomplete type 'type'. # elif defined(BOOST_INTEL) && (defined(__WIN32__) || defined(WIN32)) # pragma warning(2:457) // #457: delete of pointer to incomplete class. # elif defined(__BORLANDC__) && (__BORLANDC__ <= 0x600) # pragma warn +stu // W8073: Undefined structure 'structure'. # elif defined(__MWERKS__) # pragma extended_errorcheck on // Enable 'extended error checking'. # endif //------------------Configure-------------------------------------------------// # if defined(__BORLANDC__) && (__BORLANDC__ >= 0x600) # define BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING # elif defined(__GNUC__) && !defined(BOOST_INTEL) // && (__GNUC__ * 100 + __GNUC_MINOR__ <= 302) # define BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING # elif defined(__DMC__) # define BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING # elif defined(BOOST_MSVC) // && (BOOST_MSVC < 1300) # define BOOST_NO_PREDEFINED_LINE_MACRO # pragma warning(disable:4094) // C4094: untagged 'stuct' declared no symbols #endif //------------------Helper templates------------------------------------------// namespace boost { struct STATIC_WARNING; template struct static_warning_impl; template<> struct static_warning_impl { enum { value = 0 }; #if !defined(BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING) && \ !defined(BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING) typedef boost::STATIC_WARNING type; #else typedef int type; #endif #if defined(BOOST_NO_PREDEFINED_LINE_MACRO) struct STATIC_WARNING { }; #endif }; template<> struct static_warning_impl { enum { value = 1 }; struct type { type() { } int* operator&() { return new int; } }; #if defined(BOOST_NO_PREDEFINED_LINE_MACRO) class STATIC_WARNING { }; #endif }; } // namespace boost //------------------Definition of BOOST_STATIC_WARNING------------------------// #if defined(BOOST_HAS_DESCRIPTIVE_UNREFERENCED_VARIABLE_WARNING) # define BOOST_STATIC_WARNING_IMPL(B) \ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \ void f() { \ ::boost::static_warning_impl<(bool)( B )>::type \ STATIC_WARNING; \ } \ } \ /**/ #elif defined(BOOST_HAS_DESCRIPTIVE_RETURNING_ADDRESS_OF_TEMPORARY_WARNING) # define BOOST_STATIC_WARNING_IMPL(B) \ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \ int* f() { \ ::boost::static_warning_impl<(bool)( B )>::type \ STATIC_WARNING; \ return &STATIC_WARNING; \ } \ } \ /**/ #elif defined(BOOST_HAS_DESCRIPTIVE_DIVIDE_BY_ZERO_WARNING) # define BOOST_STATIC_WARNING_IMPL(B) \ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \ int f() { int STATIC_WARNING = 1; \ return STATIC_WARNING / \ boost::static_warning_impl<(bool)( B )>::value; } \ } \ /**/ #elif defined(BOOST_NO_PREDEFINED_LINE_MACRO) // VC6; __LINE__ macro broken when -ZI is used see Q199057, so // non-conforming workaround is used. # define BOOST_STATIC_WARNING_IMPL(B) \ struct { \ struct S { \ typedef boost::static_warning_impl<(bool)( B )> f; \ friend class f::STATIC_WARNING; \ }; \ } \ /**/ #else // Deletion of pointer to incomplete type. # define BOOST_STATIC_WARNING_IMPL(B) \ struct BOOST_JOIN(STATIC_WARNING, __LINE__) { \ ::boost::static_warning_impl<(bool)( B )>::type* p; \ void f() { delete p; } \ } \ /**/ #endif #ifndef BOOST_DISABLE_STATIC_WARNINGS # define BOOST_STATIC_WARNING(B) BOOST_STATIC_WARNING_IMPL(B) #else // #ifdef BOOST_ENABLE_STATIC_WARNINGS //-------------------------------// # define BOOST_STATIC_WARNING(B) BOOST_STATIC_WARNING_IMPL(true) #endif #endif // BOOST_STATIC_WARNING_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/crc.hpp0000644000175000017500000010015511344301501026723 0ustar debiandebian// Boost CRC library crc.hpp header file -----------------------------------// // Copyright 2001, 2004 Daryle Walker. Use, modification, and distribution are // subject to the Boost Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or a copy at .) // See for the library's home page. #ifndef BOOST_CRC_HPP #define BOOST_CRC_HPP #include // for BOOST_STATIC_CONSTANT, etc. #include // for boost::uint_t #include // for CHAR_BIT, etc. #include // for std::size_t #include // for std::numeric_limits // The type of CRC parameters that can go in a template should be related // on the CRC's bit count. This macro expresses that type in a compact // form, but also allows an alternate type for compilers that don't support // dependent types (in template value-parameters). #if !(defined(BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS) || (defined(BOOST_MSVC) && (BOOST_MSVC <= 1300))) #define BOOST_CRC_PARM_TYPE typename ::boost::uint_t::fast #else #define BOOST_CRC_PARM_TYPE unsigned long #endif // Some compilers [MS VC++ 6] cannot correctly set up several versions of a // function template unless every template argument can be unambiguously // deduced from the function arguments. (The bug is hidden if only one version // is needed.) Since all of the CRC function templates have this problem, the // workaround is to make up a dummy function argument that encodes the template // arguments. Calls to such template functions need all their template // arguments explicitly specified. At least one compiler that needs this // workaround also needs the default value for the dummy argument to be // specified in the definition. #if defined(__GNUC__) || !defined(BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS) #define BOOST_CRC_DUMMY_PARM_TYPE #define BOOST_CRC_DUMMY_INIT #define BOOST_ACRC_DUMMY_PARM_TYPE #define BOOST_ACRC_DUMMY_INIT #else namespace boost { namespace detail { template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > struct dummy_crc_argument { }; } } #define BOOST_CRC_DUMMY_PARM_TYPE , detail::dummy_crc_argument *p_ #define BOOST_CRC_DUMMY_INIT BOOST_CRC_DUMMY_PARM_TYPE = 0 #define BOOST_ACRC_DUMMY_PARM_TYPE , detail::dummy_crc_argument *p_ #define BOOST_ACRC_DUMMY_INIT BOOST_ACRC_DUMMY_PARM_TYPE = 0 #endif namespace boost { // Forward declarations ----------------------------------------------------// template < std::size_t Bits > class crc_basic; template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly = 0u, BOOST_CRC_PARM_TYPE InitRem = 0u, BOOST_CRC_PARM_TYPE FinalXor = 0u, bool ReflectIn = false, bool ReflectRem = false > class crc_optimal; template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > typename uint_t::fast crc( void const *buffer, std::size_t byte_count BOOST_CRC_DUMMY_PARM_TYPE ); template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly > typename uint_t::fast augmented_crc( void const *buffer, std::size_t byte_count, typename uint_t::fast initial_remainder BOOST_ACRC_DUMMY_PARM_TYPE ); template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly > typename uint_t::fast augmented_crc( void const *buffer, std::size_t byte_count BOOST_ACRC_DUMMY_PARM_TYPE ); typedef crc_optimal<16, 0x8005, 0, 0, true, true> crc_16_type; typedef crc_optimal<16, 0x1021, 0xFFFF, 0, false, false> crc_ccitt_type; typedef crc_optimal<16, 0x8408, 0, 0, true, true> crc_xmodem_type; typedef crc_optimal<32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc_32_type; // Forward declarations for implementation detail stuff --------------------// // (Just for the stuff that will be needed for the next two sections) namespace detail { template < std::size_t Bits > struct mask_uint_t; template < > struct mask_uint_t< std::numeric_limits::digits >; #if USHRT_MAX > UCHAR_MAX template < > struct mask_uint_t< std::numeric_limits::digits >; #endif #if UINT_MAX > USHRT_MAX template < > struct mask_uint_t< std::numeric_limits::digits >; #endif #if ULONG_MAX > UINT_MAX template < > struct mask_uint_t< std::numeric_limits::digits >; #endif template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect > struct crc_table_t; template < std::size_t Bits, bool DoReflect > class crc_helper; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template < std::size_t Bits > class crc_helper< Bits, false >; #endif } // namespace detail // Simple cyclic redundancy code (CRC) class declaration -------------------// template < std::size_t Bits > class crc_basic { // Implementation type typedef detail::mask_uint_t masking_type; public: // Type typedef typename masking_type::least value_type; // Constant for the template parameter BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits ); // Constructor explicit crc_basic( value_type truncated_polynominal, value_type initial_remainder = 0, value_type final_xor_value = 0, bool reflect_input = false, bool reflect_remainder = false ); // Internal Operations value_type get_truncated_polynominal() const; value_type get_initial_remainder() const; value_type get_final_xor_value() const; bool get_reflect_input() const; bool get_reflect_remainder() const; value_type get_interim_remainder() const; void reset( value_type new_rem ); void reset(); // External Operations void process_bit( bool bit ); void process_bits( unsigned char bits, std::size_t bit_count ); void process_byte( unsigned char byte ); void process_block( void const *bytes_begin, void const *bytes_end ); void process_bytes( void const *buffer, std::size_t byte_count ); value_type checksum() const; private: // Member data value_type rem_; value_type poly_, init_, final_; // non-const to allow assignability bool rft_in_, rft_out_; // non-const to allow assignability }; // boost::crc_basic // Optimized cyclic redundancy code (CRC) class declaration ----------------// template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > class crc_optimal { // Implementation type typedef detail::mask_uint_t masking_type; public: // Type typedef typename masking_type::fast value_type; // Constants for the template parameters BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits ); BOOST_STATIC_CONSTANT( value_type, truncated_polynominal = TruncPoly ); BOOST_STATIC_CONSTANT( value_type, initial_remainder = InitRem ); BOOST_STATIC_CONSTANT( value_type, final_xor_value = FinalXor ); BOOST_STATIC_CONSTANT( bool, reflect_input = ReflectIn ); BOOST_STATIC_CONSTANT( bool, reflect_remainder = ReflectRem ); // Constructor explicit crc_optimal( value_type init_rem = InitRem ); // Internal Operations value_type get_truncated_polynominal() const; value_type get_initial_remainder() const; value_type get_final_xor_value() const; bool get_reflect_input() const; bool get_reflect_remainder() const; value_type get_interim_remainder() const; void reset( value_type new_rem = InitRem ); // External Operations void process_byte( unsigned char byte ); void process_block( void const *bytes_begin, void const *bytes_end ); void process_bytes( void const *buffer, std::size_t byte_count ); value_type checksum() const; // Operators void operator ()( unsigned char byte ); value_type operator ()() const; private: // The implementation of output reflection depends on both reflect states. BOOST_STATIC_CONSTANT( bool, reflect_output = (ReflectRem != ReflectIn) ); #ifndef __BORLANDC__ #define BOOST_CRC_REF_OUT_VAL reflect_output #else typedef crc_optimal self_type; #define BOOST_CRC_REF_OUT_VAL (self_type::reflect_output) #endif // More implementation types typedef detail::crc_table_t crc_table_type; typedef detail::crc_helper helper_type; typedef detail::crc_helper reflect_out_type; #undef BOOST_CRC_REF_OUT_VAL // Member data value_type rem_; }; // boost::crc_optimal // Implementation detail stuff ---------------------------------------------// namespace detail { // Forward declarations for more implementation details template < std::size_t Bits > struct high_uint_t; template < std::size_t Bits > struct reflector; // Traits class for mask; given the bit number // (1-based), get the mask for that bit by itself. template < std::size_t Bits > struct high_uint_t : boost::uint_t< Bits > { typedef boost::uint_t base_type; typedef typename base_type::least least; typedef typename base_type::fast fast; #if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243 static const least high_bit = 1ul << ( Bits - 1u ); static const fast high_bit_fast = 1ul << ( Bits - 1u ); #else BOOST_STATIC_CONSTANT( least, high_bit = (least( 1u ) << ( Bits - 1u )) ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = (fast( 1u ) << ( Bits - 1u )) ); #endif }; // boost::detail::high_uint_t // Reflection routine class wrapper // (since MS VC++ 6 couldn't handle the unwrapped version) template < std::size_t Bits > struct reflector { typedef typename boost::uint_t::fast value_type; static value_type reflect( value_type x ); }; // boost::detail::reflector // Function that reflects its argument template < std::size_t Bits > typename reflector::value_type reflector::reflect ( typename reflector::value_type x ) { value_type reflection = 0; value_type const one = 1; for ( std::size_t i = 0 ; i < Bits ; ++i, x >>= 1 ) { if ( x & one ) { reflection |= ( one << (Bits - 1u - i) ); } } return reflection; } // Traits class for masks; given the bit number (1-based), // get the mask for that bit and its lower bits. template < std::size_t Bits > struct mask_uint_t : high_uint_t< Bits > { typedef high_uint_t base_type; typedef typename base_type::least least; typedef typename base_type::fast fast; #ifndef __BORLANDC__ using base_type::high_bit; using base_type::high_bit_fast; #else BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast ); #endif #if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243 static const least sig_bits = (~( ~( 0ul ) << Bits )) ; #else BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) ); #endif BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); }; // boost::detail::mask_uint_t template < > struct mask_uint_t< std::numeric_limits::digits > : high_uint_t< std::numeric_limits::digits > { typedef high_uint_t::digits> base_type; typedef base_type::least least; typedef base_type::fast fast; #ifndef __BORLANDC__ using base_type::high_bit; using base_type::high_bit_fast; #else BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast ); #endif BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) ); BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); }; // boost::detail::mask_uint_t #if USHRT_MAX > UCHAR_MAX template < > struct mask_uint_t< std::numeric_limits::digits > : high_uint_t< std::numeric_limits::digits > { typedef high_uint_t::digits> base_type; typedef base_type::least least; typedef base_type::fast fast; #ifndef __BORLANDC__ using base_type::high_bit; using base_type::high_bit_fast; #else BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast ); #endif BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) ); BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); }; // boost::detail::mask_uint_t #endif #if UINT_MAX > USHRT_MAX template < > struct mask_uint_t< std::numeric_limits::digits > : high_uint_t< std::numeric_limits::digits > { typedef high_uint_t::digits> base_type; typedef base_type::least least; typedef base_type::fast fast; #ifndef __BORLANDC__ using base_type::high_bit; using base_type::high_bit_fast; #else BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast ); #endif BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) ); BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); }; // boost::detail::mask_uint_t #endif #if ULONG_MAX > UINT_MAX template < > struct mask_uint_t< std::numeric_limits::digits > : high_uint_t< std::numeric_limits::digits > { typedef high_uint_t::digits> base_type; typedef base_type::least least; typedef base_type::fast fast; #ifndef __BORLANDC__ using base_type::high_bit; using base_type::high_bit_fast; #else BOOST_STATIC_CONSTANT( least, high_bit = base_type::high_bit ); BOOST_STATIC_CONSTANT( fast, high_bit_fast = base_type::high_bit_fast ); #endif BOOST_STATIC_CONSTANT( least, sig_bits = (~( least(0u) )) ); BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) ); }; // boost::detail::mask_uint_t #endif // CRC table generator template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect > struct crc_table_t { BOOST_STATIC_CONSTANT( std::size_t, byte_combos = (1ul << CHAR_BIT) ); typedef mask_uint_t masking_type; typedef typename masking_type::fast value_type; #if defined(__BORLANDC__) && defined(_M_IX86) && (__BORLANDC__ == 0x560) // for some reason Borland's command line compiler (version 0x560) // chokes over this unless we do the calculation for it: typedef value_type table_type[ 0x100 ]; #else typedef value_type table_type[ byte_combos ]; #endif static void init_table(); static table_type table_; }; // boost::detail::crc_table_t // CRC table generator static data member definition // (Some compilers [Borland C++] require the initializer to be present.) template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect > typename crc_table_t::table_type crc_table_t::table_ = { 0 }; // Populate CRC lookup table template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, bool Reflect > void crc_table_t::init_table ( ) { // compute table only on the first run static bool did_init = false; if ( did_init ) return; // factor-out constants to avoid recalculation value_type const fast_hi_bit = masking_type::high_bit_fast; unsigned char const byte_hi_bit = 1u << (CHAR_BIT - 1u); // loop over every possible dividend value unsigned char dividend = 0; do { value_type remainder = 0; // go through all the dividend's bits for ( unsigned char mask = byte_hi_bit ; mask ; mask >>= 1 ) { // check if divisor fits if ( dividend & mask ) { remainder ^= fast_hi_bit; } // do polynominal division if ( remainder & fast_hi_bit ) { remainder <<= 1; remainder ^= TruncPoly; } else { remainder <<= 1; } } table_[ crc_helper::reflect(dividend) ] = crc_helper::reflect( remainder ); } while ( ++dividend ); did_init = true; } #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // Align the msb of the remainder to a byte template < std::size_t Bits, bool RightShift > class remainder { public: typedef typename uint_t::fast value_type; static unsigned char align_msb( value_type rem ) { return rem >> (Bits - CHAR_BIT); } }; // Specialization for the case that the remainder has less // bits than a byte: align the remainder msb to the byte msb template < std::size_t Bits > class remainder< Bits, false > { public: typedef typename uint_t::fast value_type; static unsigned char align_msb( value_type rem ) { return rem << (CHAR_BIT - Bits); } }; #endif // CRC helper routines template < std::size_t Bits, bool DoReflect > class crc_helper { public: // Type typedef typename uint_t::fast value_type; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // Possibly reflect a remainder static value_type reflect( value_type x ) { return detail::reflector::reflect( x ); } // Compare a byte to the remainder's highest byte static unsigned char index( value_type rem, unsigned char x ) { return x ^ rem; } // Shift out the remainder's highest byte static value_type shift( value_type rem ) { return rem >> CHAR_BIT; } #else // Possibly reflect a remainder static value_type reflect( value_type x ) { return DoReflect ? detail::reflector::reflect( x ) : x; } // Compare a byte to the remainder's highest byte static unsigned char index( value_type rem, unsigned char x ) { return x ^ ( DoReflect ? rem : ((Bits>CHAR_BIT)?( rem >> (Bits - CHAR_BIT) ) : ( rem << (CHAR_BIT - Bits) ))); } // Shift out the remainder's highest byte static value_type shift( value_type rem ) { return DoReflect ? rem >> CHAR_BIT : rem << CHAR_BIT; } #endif }; // boost::detail::crc_helper #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template < std::size_t Bits > class crc_helper { public: // Type typedef typename uint_t::fast value_type; // Possibly reflect a remainder static value_type reflect( value_type x ) { return x; } // Compare a byte to the remainder's highest byte static unsigned char index( value_type rem, unsigned char x ) { return x ^ remainderCHAR_BIT)>::align_msb( rem ); } // Shift out the remainder's highest byte static value_type shift( value_type rem ) { return rem << CHAR_BIT; } }; // boost::detail::crc_helper #endif } // namespace detail // Simple CRC class function definitions -----------------------------------// template < std::size_t Bits > inline crc_basic::crc_basic ( typename crc_basic::value_type truncated_polynominal, typename crc_basic::value_type initial_remainder, // = 0 typename crc_basic::value_type final_xor_value, // = 0 bool reflect_input, // = false bool reflect_remainder // = false ) : rem_( initial_remainder ), poly_( truncated_polynominal ) , init_( initial_remainder ), final_( final_xor_value ) , rft_in_( reflect_input ), rft_out_( reflect_remainder ) { } template < std::size_t Bits > inline typename crc_basic::value_type crc_basic::get_truncated_polynominal ( ) const { return poly_; } template < std::size_t Bits > inline typename crc_basic::value_type crc_basic::get_initial_remainder ( ) const { return init_; } template < std::size_t Bits > inline typename crc_basic::value_type crc_basic::get_final_xor_value ( ) const { return final_; } template < std::size_t Bits > inline bool crc_basic::get_reflect_input ( ) const { return rft_in_; } template < std::size_t Bits > inline bool crc_basic::get_reflect_remainder ( ) const { return rft_out_; } template < std::size_t Bits > inline typename crc_basic::value_type crc_basic::get_interim_remainder ( ) const { return rem_ & masking_type::sig_bits; } template < std::size_t Bits > inline void crc_basic::reset ( typename crc_basic::value_type new_rem ) { rem_ = new_rem; } template < std::size_t Bits > inline void crc_basic::reset ( ) { this->reset( this->get_initial_remainder() ); } template < std::size_t Bits > inline void crc_basic::process_bit ( bool bit ) { value_type const high_bit_mask = masking_type::high_bit; // compare the new bit with the remainder's highest rem_ ^= ( bit ? high_bit_mask : 0u ); // a full polynominal division step is done when the highest bit is one bool const do_poly_div = static_cast( rem_ & high_bit_mask ); // shift out the highest bit rem_ <<= 1; // carry out the division, if needed if ( do_poly_div ) { rem_ ^= poly_; } } template < std::size_t Bits > void crc_basic::process_bits ( unsigned char bits, std::size_t bit_count ) { // ignore the bits above the ones we want bits <<= CHAR_BIT - bit_count; // compute the CRC for each bit, starting with the upper ones unsigned char const high_bit_mask = 1u << ( CHAR_BIT - 1u ); for ( std::size_t i = bit_count ; i > 0u ; --i, bits <<= 1u ) { process_bit( static_cast(bits & high_bit_mask) ); } } template < std::size_t Bits > inline void crc_basic::process_byte ( unsigned char byte ) { process_bits( (rft_in_ ? detail::reflector::reflect(byte) : byte), CHAR_BIT ); } template < std::size_t Bits > void crc_basic::process_block ( void const * bytes_begin, void const * bytes_end ) { for ( unsigned char const * p = static_cast(bytes_begin) ; p < bytes_end ; ++p ) { process_byte( *p ); } } template < std::size_t Bits > inline void crc_basic::process_bytes ( void const * buffer, std::size_t byte_count ) { unsigned char const * const b = static_cast( buffer ); process_block( b, b + byte_count ); } template < std::size_t Bits > inline typename crc_basic::value_type crc_basic::checksum ( ) const { return ( (rft_out_ ? detail::reflector::reflect( rem_ ) : rem_) ^ final_ ) & masking_type::sig_bits; } // Optimized CRC class function definitions --------------------------------// // Macro to compact code #define BOOST_CRC_OPTIMAL_NAME crc_optimal template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline BOOST_CRC_OPTIMAL_NAME::crc_optimal ( typename BOOST_CRC_OPTIMAL_NAME::value_type init_rem // = InitRem ) : rem_( helper_type::reflect(init_rem) ) { crc_table_type::init_table(); } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename BOOST_CRC_OPTIMAL_NAME::value_type BOOST_CRC_OPTIMAL_NAME::get_truncated_polynominal ( ) const { return TruncPoly; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename BOOST_CRC_OPTIMAL_NAME::value_type BOOST_CRC_OPTIMAL_NAME::get_initial_remainder ( ) const { return InitRem; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename BOOST_CRC_OPTIMAL_NAME::value_type BOOST_CRC_OPTIMAL_NAME::get_final_xor_value ( ) const { return FinalXor; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline bool BOOST_CRC_OPTIMAL_NAME::get_reflect_input ( ) const { return ReflectIn; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline bool BOOST_CRC_OPTIMAL_NAME::get_reflect_remainder ( ) const { return ReflectRem; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename BOOST_CRC_OPTIMAL_NAME::value_type BOOST_CRC_OPTIMAL_NAME::get_interim_remainder ( ) const { // Interim remainder should be _un_-reflected, so we have to undo it. return helper_type::reflect( rem_ ) & masking_type::sig_bits_fast; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline void BOOST_CRC_OPTIMAL_NAME::reset ( typename BOOST_CRC_OPTIMAL_NAME::value_type new_rem // = InitRem ) { rem_ = helper_type::reflect( new_rem ); } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline void BOOST_CRC_OPTIMAL_NAME::process_byte ( unsigned char byte ) { process_bytes( &byte, sizeof(byte) ); } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > void BOOST_CRC_OPTIMAL_NAME::process_block ( void const * bytes_begin, void const * bytes_end ) { // Recompute the CRC for each byte passed for ( unsigned char const * p = static_cast(bytes_begin) ; p < bytes_end ; ++p ) { // Compare the new byte with the remainder's higher bits to // get the new bits, shift out the remainder's current higher // bits, and update the remainder with the polynominal division // of the new bits. unsigned char const byte_index = helper_type::index( rem_, *p ); rem_ = helper_type::shift( rem_ ); rem_ ^= crc_table_type::table_[ byte_index ]; } } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline void BOOST_CRC_OPTIMAL_NAME::process_bytes ( void const * buffer, std::size_t byte_count ) { unsigned char const * const b = static_cast( buffer ); process_block( b, b + byte_count ); } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename BOOST_CRC_OPTIMAL_NAME::value_type BOOST_CRC_OPTIMAL_NAME::checksum ( ) const { return ( reflect_out_type::reflect(rem_) ^ get_final_xor_value() ) & masking_type::sig_bits_fast; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline void BOOST_CRC_OPTIMAL_NAME::operator () ( unsigned char byte ) { process_byte( byte ); } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename BOOST_CRC_OPTIMAL_NAME::value_type BOOST_CRC_OPTIMAL_NAME::operator () ( ) const { return checksum(); } // CRC computation function definition -------------------------------------// template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly, BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor, bool ReflectIn, bool ReflectRem > inline typename uint_t::fast crc ( void const * buffer, std::size_t byte_count BOOST_CRC_DUMMY_INIT ) { BOOST_CRC_OPTIMAL_NAME computer; computer.process_bytes( buffer, byte_count ); return computer.checksum(); } // Augmented-message CRC computation function definitions ------------------// template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly > typename uint_t::fast augmented_crc ( void const * buffer, std::size_t byte_count, typename uint_t::fast initial_remainder BOOST_ACRC_DUMMY_INIT ) { typedef unsigned char byte_type; typedef detail::mask_uint_t masking_type; typedef detail::crc_table_t crc_table_type; typename masking_type::fast rem = initial_remainder; byte_type const * const b = static_cast( buffer ); byte_type const * const e = b + byte_count; crc_table_type::init_table(); for ( byte_type const * p = b ; p < e ; ++p ) { // Use the current top byte as the table index to the next // "partial product." Shift out that top byte, shifting in // the next augmented-message byte. Complete the division. byte_type const byte_index = rem >> ( Bits - CHAR_BIT ); rem <<= CHAR_BIT; rem |= *p; rem ^= crc_table_type::table_[ byte_index ]; } return rem & masking_type::sig_bits_fast; } template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly > inline typename uint_t::fast augmented_crc ( void const * buffer, std::size_t byte_count BOOST_ACRC_DUMMY_INIT ) { // The last function argument has its type specified so the other version of // augmented_crc will be called. If the cast wasn't in place, and the // BOOST_ACRC_DUMMY_INIT added a third argument (for a workaround), the "0" // would match as that third argument, leading to infinite recursion. return augmented_crc( buffer, byte_count, static_cast::fast>(0) ); } } // namespace boost // Undo header-private macros #undef BOOST_CRC_OPTIMAL_NAME #undef BOOST_ACRC_DUMMY_INIT #undef BOOST_ACRC_DUMMY_PARM_TYPE #undef BOOST_CRC_DUMMY_INIT #undef BOOST_CRC_DUMMY_PARM_TYPE #undef BOOST_CRC_PARM_TYPE #endif // BOOST_CRC_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/intrusive_ptr.hpp0000644000175000017500000001331611344301501031073 0ustar debiandebian#ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED #define BOOST_INTRUSIVE_PTR_HPP_INCLUDED // // intrusive_ptr.hpp // // Copyright (c) 2001, 2002 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation. // #include #ifdef BOOST_MSVC // moved here to work around VC++ compiler crash # pragma warning(push) # pragma warning(disable:4284) // odd return type for operator-> #endif #include #include #include // for std::less #include // for std::basic_ostream namespace boost { // // intrusive_ptr // // A smart pointer that uses intrusive reference counting. // // Relies on unqualified calls to // // void intrusive_ptr_add_ref(T * p); // void intrusive_ptr_release(T * p); // // (p != 0) // // The object is responsible for destroying itself. // template class intrusive_ptr { private: typedef intrusive_ptr this_type; public: typedef T element_type; intrusive_ptr(): p_(0) { } intrusive_ptr(T * p, bool add_ref = true): p_(p) { if(p_ != 0 && add_ref) intrusive_ptr_add_ref(p_); } #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES) template intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.get()) { if(p_ != 0) intrusive_ptr_add_ref(p_); } #endif intrusive_ptr(intrusive_ptr const & rhs): p_(rhs.p_) { if(p_ != 0) intrusive_ptr_add_ref(p_); } ~intrusive_ptr() { if(p_ != 0) intrusive_ptr_release(p_); } #if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES) template intrusive_ptr & operator=(intrusive_ptr const & rhs) { this_type(rhs).swap(*this); return *this; } #endif intrusive_ptr & operator=(intrusive_ptr const & rhs) { this_type(rhs).swap(*this); return *this; } intrusive_ptr & operator=(T * rhs) { this_type(rhs).swap(*this); return *this; } T * get() const { return p_; } T & operator*() const { return *p_; } T * operator->() const { return p_; } #if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530) operator bool () const { return p_ != 0; } #elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) typedef T * (this_type::*unspecified_bool_type)() const; operator unspecified_bool_type() const // never throws { return p_ == 0? 0: &this_type::get; } #else typedef T * this_type::*unspecified_bool_type; operator unspecified_bool_type () const { return p_ == 0? 0: &this_type::p_; } #endif // operator! is a Borland-specific workaround bool operator! () const { return p_ == 0; } void swap(intrusive_ptr & rhs) { T * tmp = p_; p_ = rhs.p_; rhs.p_ = tmp; } private: T * p_; }; template inline bool operator==(intrusive_ptr const & a, intrusive_ptr const & b) { return a.get() == b.get(); } template inline bool operator!=(intrusive_ptr const & a, intrusive_ptr const & b) { return a.get() != b.get(); } template inline bool operator==(intrusive_ptr const & a, T * b) { return a.get() == b; } template inline bool operator!=(intrusive_ptr const & a, T * b) { return a.get() != b; } template inline bool operator==(T * a, intrusive_ptr const & b) { return a == b.get(); } template inline bool operator!=(T * a, intrusive_ptr const & b) { return a != b.get(); } #if __GNUC__ == 2 && __GNUC_MINOR__ <= 96 // Resolve the ambiguity between our op!= and the one in rel_ops template inline bool operator!=(intrusive_ptr const & a, intrusive_ptr const & b) { return a.get() != b.get(); } #endif template inline bool operator<(intrusive_ptr const & a, intrusive_ptr const & b) { return std::less()(a.get(), b.get()); } template void swap(intrusive_ptr & lhs, intrusive_ptr & rhs) { lhs.swap(rhs); } // mem_fn support template T * get_pointer(intrusive_ptr const & p) { return p.get(); } template intrusive_ptr static_pointer_cast(intrusive_ptr const & p) { return static_cast(p.get()); } template intrusive_ptr const_pointer_cast(intrusive_ptr const & p) { return const_cast(p.get()); } template intrusive_ptr dynamic_pointer_cast(intrusive_ptr const & p) { return dynamic_cast(p.get()); } // operator<< #if defined(__GNUC__) && (__GNUC__ < 3) template std::ostream & operator<< (std::ostream & os, intrusive_ptr const & p) { os << p.get(); return os; } #else # if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT) // MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL using std::basic_ostream; template basic_ostream & operator<< (basic_ostream & os, intrusive_ptr const & p) # else template std::basic_ostream & operator<< (std::basic_ostream & os, intrusive_ptr const & p) # endif { os << p.get(); return os; } #endif } // namespace boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #endif // #ifndef BOOST_INTRUSIVE_PTR_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/dynamic_bitset_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/dynamic_bitset_fwd.hp0000644000175000017500000000137411344301501031635 0ustar debiandebian// -------------------------------------------------- // // (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002. // (C) Copyright Gennaro Prota 2003 - 2004. // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // ----------------------------------------------------------- // See http://www.boost.org/libs/dynamic_bitset for documentation. #ifndef BOOST_DYNAMIC_BITSET_FWD_HPP #define BOOST_DYNAMIC_BITSET_FWD_HPP #include namespace boost { template > class dynamic_bitset; } // namespace boost #endif // include guard mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/0000755000175000017500000000000012146213773030026 5ustar debiandebian././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_integral.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_integr0000644000175000017500000000572411344301501031726 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_INTEGRAL_HPP_INCLUDED #define BOOST_TT_IS_INTEGRAL_HPP_INCLUDED #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { //* is a type T an [cv-qualified-] integral type described in the standard (3.9.1p3) // as an extention we include long long, as this is likely to be added to the // standard at a later date BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_integral,T,false) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned char,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned short,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned int,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned long,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed char,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed short,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed int,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,signed long,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,bool,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,char,true) #ifndef BOOST_NO_INTRINSIC_WCHAR_T // If the following line fails to compile and you're using the Intel // compiler, see http://lists.boost.org/MailArchives/boost-users/msg06567.php, // and define BOOST_NO_INTRINSIC_WCHAR_T on the command line. BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,wchar_t,true) #endif #if (defined(BOOST_MSVC) && (BOOST_MSVC == 1200)) \ || (defined(BOOST_INTEL_CXX_VERSION) && defined(_MSC_VER) && (BOOST_INTEL_CXX_VERSION <= 600)) \ || (defined(__BORLANDC__) && (__BORLANDC__ == 0x600) && (_MSC_VER == 1200)) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int8,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int8,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int16,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int16,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int32,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int32,true) #ifdef __BORLANDC__ BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int64,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int64,true) #endif #endif # if defined(BOOST_HAS_LONG_LONG) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral, ::boost::ulong_long_type,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral, ::boost::long_long_type,true) #elif defined(BOOST_HAS_MS_INT64) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,unsigned __int64,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_integral,__int64,true) #endif } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_INTEGRAL_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_reference.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_re0000644000175000017500000000315311344301501031720 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED #define BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED #include "boost/type_traits/broken_compiler_spec.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T&,T) #if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) // these are illegal specialisations; cv-qualifies applied to // references have no effect according to [8.3.2p1], // C++ Builder requires them though as it treats cv-qualified // references as distinct types... BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& volatile,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_reference,T& const volatile,T) #endif #else BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_reference,T,typename detail::remove_reference_impl::type) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_REMOVE_REFERENCE_HPP_INCLUDED ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/type_with_alignment.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/type_with0000644000175000017500000002171611344301501031756 0ustar debiandebian// (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED #define BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED #include "boost/mpl/if.hpp" #include "boost/preprocessor/list/for_each_i.hpp" #include "boost/preprocessor/tuple/to_list.hpp" #include "boost/preprocessor/cat.hpp" #include "boost/preprocessor/list/transform.hpp" #include "boost/preprocessor/list/append.hpp" #include "boost/type_traits/alignment_of.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/static_assert.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" #include #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable: 4121) // alignment is sensitive to packing #endif namespace boost { #ifndef __BORLANDC__ namespace detail { class alignment_dummy; typedef void (*function_ptr)(); typedef int (alignment_dummy::*member_ptr); typedef int (alignment_dummy::*member_function_ptr)(); #ifdef BOOST_HAS_LONG_LONG #define BOOST_TT_ALIGNMENT_BASE_TYPES BOOST_PP_TUPLE_TO_LIST( \ 12, ( \ char, short, int, long, ::boost::long_long_type, float, double, long double \ , void*, function_ptr, member_ptr, member_function_ptr)) #else #define BOOST_TT_ALIGNMENT_BASE_TYPES BOOST_PP_TUPLE_TO_LIST( \ 11, ( \ char, short, int, long, float, double, long double \ , void*, function_ptr, member_ptr, member_function_ptr)) #endif #define BOOST_TT_HAS_ONE_T(D,Data,T) boost::detail::has_one_T< T > #define BOOST_TT_ALIGNMENT_STRUCT_TYPES \ BOOST_PP_LIST_TRANSFORM(BOOST_TT_HAS_ONE_T, \ X, \ BOOST_TT_ALIGNMENT_BASE_TYPES) #define BOOST_TT_ALIGNMENT_TYPES \ BOOST_PP_LIST_APPEND(BOOST_TT_ALIGNMENT_BASE_TYPES, \ BOOST_TT_ALIGNMENT_STRUCT_TYPES) // // lower_alignment_helper -- // // This template gets instantiated a lot, so use partial // specialization when available to reduce the compiler burden. // #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct lower_alignment_helper_impl { template struct apply { typedef char type; enum { value = true }; }; }; template <> struct lower_alignment_helper_impl { template struct apply : mpl::if_c<(alignment_of::value == target), TestType, char> { enum { value = (alignment_of::value == target) }; }; }; template struct lower_alignment_helper : lower_alignment_helper_impl::template apply { }; #else template struct lower_alignment_helper { typedef char type; enum { value = true }; }; template struct lower_alignment_helper { enum { value = (alignment_of::value == target) }; typedef typename mpl::if_c::type type; }; #endif #define BOOST_TT_CHOOSE_MIN_ALIGNMENT(R,P,I,T) \ typename lower_alignment_helper< \ BOOST_PP_CAT(found,I),target,T \ >::type BOOST_PP_CAT(t,I); \ enum { \ BOOST_PP_CAT(found,BOOST_PP_INC(I)) \ = lower_alignment_helper::value \ }; #define BOOST_TT_CHOOSE_T(R,P,I,T) T BOOST_PP_CAT(t,I); template struct has_one_T { T data; }; template union lower_alignment { enum { found0 = false }; BOOST_PP_LIST_FOR_EACH_I( BOOST_TT_CHOOSE_MIN_ALIGNMENT , ignored , BOOST_TT_ALIGNMENT_TYPES ) }; union max_align { BOOST_PP_LIST_FOR_EACH_I( BOOST_TT_CHOOSE_T , ignored , BOOST_TT_ALIGNMENT_TYPES ) }; #undef BOOST_TT_ALIGNMENT_BASE_TYPES #undef BOOST_TT_HAS_ONE_T #undef BOOST_TT_ALIGNMENT_STRUCT_TYPES #undef BOOST_TT_ALIGNMENT_TYPES #undef BOOST_TT_CHOOSE_MIN_ALIGNMENT #undef BOOST_TT_CHOOSE_T template struct is_aligned { BOOST_STATIC_CONSTANT(bool, value = (TAlign >= Align) & (TAlign % Align == 0) ); }; #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::max_align,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<1> ,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<2> ,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<4> ,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<8> ,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<10> ,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<16> ,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::detail::lower_alignment<32> ,true) #endif } // namespace detail #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_pod< ::boost::detail::lower_alignment > { BOOST_STATIC_CONSTANT(std::size_t, value = true); }; #endif // This alignment method originally due to Brian Parker, implemented by David // Abrahams, and then ported here by Doug Gregor. template class type_with_alignment { typedef detail::lower_alignment t1; typedef typename mpl::if_c< ::boost::detail::is_aligned< ::boost::alignment_of::value,Align >::value , t1 , detail::max_align >::type align_t; BOOST_STATIC_CONSTANT(std::size_t, found = alignment_of::value); BOOST_STATIC_ASSERT(found >= Align); BOOST_STATIC_ASSERT(found % Align == 0); public: typedef align_t type; }; #if defined(__GNUC__) namespace align { struct __attribute__((__aligned__(2))) a2 {}; struct __attribute__((__aligned__(4))) a4 {}; struct __attribute__((__aligned__(8))) a8 {}; struct __attribute__((__aligned__(16))) a16 {}; struct __attribute__((__aligned__(32))) a32 {}; } template<> class type_with_alignment<1> { public: typedef char type; }; template<> class type_with_alignment<2> { public: typedef align::a2 type; }; template<> class type_with_alignment<4> { public: typedef align::a4 type; }; template<> class type_with_alignment<8> { public: typedef align::a8 type; }; template<> class type_with_alignment<16> { public: typedef align::a16 type; }; template<> class type_with_alignment<32> { public: typedef align::a32 type; }; namespace detail { BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a32,true) } #endif #else // // Borland specific version, we have this for two reasons: // 1) The version above doesn't always compile (with the new test cases for example) // 2) Because of Borlands #pragma option we can create types with alignments that are // greater that the largest aligned builtin type. namespace align{ #pragma option push -a16 struct a2{ short s; }; struct a4{ int s; }; struct a8{ double s; }; struct a16{ long double s; }; #pragma option pop } namespace detail { typedef ::boost::align::a16 max_align; BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a2,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a4,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a8,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,::boost::align::a16,true) } template struct type_with_alignment { // We should never get to here, but if we do use the maximally // aligned type: // BOOST_STATIC_ASSERT(0); typedef align::a16 type; }; template <> struct type_with_alignment<1>{ typedef char type; }; template <> struct type_with_alignment<2>{ typedef align::a2 type; }; template <> struct type_with_alignment<4>{ typedef align::a4 type; }; template <> struct type_with_alignment<8>{ typedef align::a8 type; }; template <> struct type_with_alignment<16>{ typedef align::a16 type; }; #endif } // namespace boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_TYPE_WITH_ALIGNMENT_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/ice.hpp0000644000175000017500000000140011344301501031254 0ustar debiandebian // (C) Copyright John Maddock and Steve Cleary 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // macros and helpers for working with integral-constant-expressions. #ifndef BOOST_TT_ICE_HPP_INCLUDED #define BOOST_TT_ICE_HPP_INCLUDED #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/detail/ice_not.hpp" #include "boost/type_traits/detail/ice_eq.hpp" #endif // BOOST_TT_ICE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/same_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/same_trai0000644000175000017500000000111211344301501031672 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // defines is_same: #ifndef BOOST_TT_SAME_TRAITS_HPP_INCLUDED #define BOOST_TT_SAME_TRAITS_HPP_INCLUDED #include "boost/type_traits/is_same.hpp" #endif // BOOST_TT_SAME_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_float.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_float.0000644000175000017500000000174511344301501031620 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED #define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { //* is a type T a floating-point type described in the standard (3.9.1p8) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_float,T,false) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,float,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,double,true) BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(is_float,long double,true) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_array.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_array.0000644000175000017500000000604511344301501031627 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Some fixes for is_array are based on a newgroup posting by Jonathan Lundquist. #ifndef BOOST_TT_IS_ARRAY_HPP_INCLUDED #define BOOST_TT_IS_ARRAY_HPP_INCLUDED #include "boost/type_traits/config.hpp" #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/detail/yes_no_type.hpp" # include "boost/type_traits/detail/wrap.hpp" #endif #include // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,false) #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T[N],true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const[N],true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T volatile[N],true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,is_array,T const volatile[N],true) #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T[],true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const[],true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T volatile[],true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_array,T const volatile[],true) #endif #endif #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { using ::boost::type_traits::yes_type; using ::boost::type_traits::no_type; using ::boost::type_traits::wrap; template< typename T > T(* is_array_tester1(wrap) )(wrap); char BOOST_TT_DECL is_array_tester1(...); template< typename T> no_type is_array_tester2(T(*)(wrap)); yes_type BOOST_TT_DECL is_array_tester2(...); template< typename T > struct is_array_impl { BOOST_STATIC_CONSTANT(bool, value = sizeof(::boost::detail::is_array_tester2( ::boost::detail::is_array_tester1( ::boost::type_traits::wrap() ) )) == 1 ); }; #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_array,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_array,T,::boost::detail::is_array_impl::value) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_ARRAY_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_abstract.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_abstra0000644000175000017500000000545111344301501031707 0ustar debiandebian#ifndef BOOST_TT_IS_ABSTRACT_CLASS_HPP #define BOOST_TT_IS_ABSTRACT_CLASS_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // is_abstract_class.hpp: // // (C) Copyright 2002 Rani Sharoni (rani_sharoni@hotmail.com) and Robert Ramey // Use, modification and distribution is subject to the Boost Software // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org for updates, documentation, and revision history. // // Compile type discovery whether given type is abstract class or not. // // Requires DR 337 to be supported by compiler // (http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/cwg_active.html#337). // // // Believed (Jan 2004) to work on: // - GCC 3.4 // - VC++ 7.1 // - compilers with new EDG frontend (Intel C++ 7, Comeau 4.3.2) // // Doesn't work on: // - VC++6, VC++7.0 and less // - GCC 3.3.X and less // - Borland C++ 6 and less // // // History: // - Originally written by Rani Sharoni, see // http://groups.google.com/groups?selm=df893da6.0207110613.75b2fe90%40posting.google.com // At this time supported by EDG (Intel C++ 7, Comeau 4.3.2) and VC7.1. // - Adapted and added into Boost.Serialization library by Robert Ramey // (starting with submission #10). // - Jan 2004: GCC 3.4 fixed to suport DR337 (Giovanni Bajo). // - Jan 2004: modified to be part of Boost.TypeTraits (Pavel Vozenilek). // #include #include #include "boost/type_traits/detail/ice_and.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail{ template struct is_abstract_imp { // Deduction fails if T is void, function type, // reference type (14.8.2/2)or an abstract class type // according to review status issue #337 // template static type_traits::no_type check_sig(U (*)[1]); template static type_traits::yes_type check_sig(...); // GCC2 won't even parse this template if we embed the computation // of s1 in the computation of value. #ifdef __GNUC__ BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(is_abstract_imp::template check_sig(0))); #else BOOST_STATIC_CONSTANT(unsigned, s1 = sizeof(check_sig(0))); #endif BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::is_class::value, (s1 == sizeof(type_traits::yes_type)) >::value)); }; } BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_abstract,T,::boost::detail::is_abstract_imp::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif //BOOST_TT_IS_ABSTRACT_CLASS_HPP ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_pointer.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_pointe0000644000175000017500000001124711344301501031731 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Howard Hinnant and John Maddock 2000. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Fixed is_pointer, is_reference, is_const, is_volatile, is_same, // is_member_pointer based on the Simulated Partial Specialization work // of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or // http://groups.yahoo.com/group/boost/message/5441 // Some workarounds in here use ideas suggested from "Generic: // Mappings between Types and Values" // by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). #ifndef BOOST_TT_IS_POINTER_HPP_INCLUDED #define BOOST_TT_IS_POINTER_HPP_INCLUDED #include "boost/type_traits/is_member_pointer.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/detail/ice_not.hpp" #include "boost/type_traits/config.hpp" #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/detail/is_function_ptr_tester.hpp" # include "boost/type_traits/detail/false_result.hpp" # include "boost/type_traits/detail/ice_or.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { template< typename T > struct is_pointer_helper { BOOST_STATIC_CONSTANT(bool, value = false); }; # define TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(helper,sp,result) \ template< typename T > struct helper \ { \ BOOST_STATIC_CONSTANT(bool, value = result); \ }; \ /**/ TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T*,true) TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T* const,true) TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T* volatile,true) TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC(is_pointer_helper,T* const volatile,true) # undef TT_AUX_BOOL_TRAIT_HELPER_PARTIAL_SPEC template< typename T > struct is_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer::value >::value >::value) ); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl::value) #if defined(__BORLANDC__) && !defined(__COMO__) && (__BORLANDC__ < 0x600) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T&,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& volatile,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_pointer,T& const volatile,false) #endif #else // no partial template specialization namespace detail { struct pointer_helper { pointer_helper(const volatile void*); }; yes_type BOOST_TT_DECL is_pointer_tester(pointer_helper); no_type BOOST_TT_DECL is_pointer_tester(...); template struct is_pointer_select : ::boost::type_traits::false_result { }; template <> struct is_pointer_select { template struct result_ { static T& make_t(); BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< (1 == sizeof(is_pointer_tester(make_t()))), (1 == sizeof(type_traits::is_function_ptr_tester(make_t()))) >::value)); }; }; template struct is_pointer_impl : is_pointer_select< ::boost::type_traits::ice_or< ::boost::is_reference::value , ::boost::is_array::value >::value >::template result_ { }; BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pointer,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pointer,T,::boost::detail::is_pointer_impl::value) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_POINTER_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_void.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_void.h0000644000175000017500000000204511344301501031616 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_VOID_HPP_INCLUDED #define BOOST_TT_IS_VOID_HPP_INCLUDED #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { //* is a type T void - is_void BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_void,T,false) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void,true) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const,true) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void volatile,true) BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_void,void const volatile,true) #endif } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_VOID_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivial_copy.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivi0000644000175000017500000000276211344301501031732 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED #define BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/type_traits/intrinsics.hpp" #include "boost/type_traits/is_volatile.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/type_traits/detail/ice_not.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct has_trivial_copy_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod::value, BOOST_HAS_TRIVIAL_COPY(T) >::value, ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value >::value)); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_copy,T,::boost::detail::has_trivial_copy_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_TRIVIAL_COPY_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_reference.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_refer0000644000175000017500000000447411344301501031657 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ADD_REFERENCE_HPP_INCLUDED #define BOOST_TT_ADD_REFERENCE_HPP_INCLUDED #include "boost/type_traits/is_reference.hpp" #include "boost/detail/workaround.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { namespace detail { #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC6_MEMBER_TEMPLATES) template struct reference_adder { template struct result_ { typedef T& type; }; }; template <> struct reference_adder { template struct result_ { typedef T type; }; }; template struct add_reference_impl { typedef typename reference_adder< ::boost::is_reference::value >::template result_ result; typedef typename result::type type; }; #else template struct add_reference_impl { typedef T& type; }; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) #endif #endif // these full specialisations are always required: BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void,void) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const,void const) BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void volatile,void volatile) BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(add_reference,void const volatile,void const volatile) #endif } // namespace detail BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_reference,T,typename detail::add_reference_impl::type) // agurt, 07/mar/03: workaround Borland's ill-formed sensitivity to an additional // level of indirection, here #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_reference,T&,T&) #endif } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_object.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_object0000644000175000017500000000334111344301501031675 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_OBJECT_HPP_INCLUDED #define BOOST_TT_IS_OBJECT_HPP_INCLUDED #include "boost/type_traits/is_reference.hpp" #include "boost/type_traits/is_void.hpp" #include "boost/type_traits/is_function.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/detail/ice_not.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct is_object_impl { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, ::boost::type_traits::ice_not< ::boost::is_void::value>::value, ::boost::type_traits::ice_not< ::boost::is_function::value>::value >::value)); #else BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, ::boost::type_traits::ice_not< ::boost::is_void::value>::value >::value)); #endif }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_object,T,::boost::detail::is_object_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_OBJECT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_convertible.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_conver0000644000175000017500000002571611344301501031735 0ustar debiandebian // Copyright 2000 John Maddock (john@johnmaddock.co.uk) // Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) // Copyright 1999, 2000 Jaakko J„rvi (jaakko.jarvi@cs.utu.fi) // // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED #define BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/config.hpp" #include "boost/type_traits/is_array.hpp" #include "boost/type_traits/add_reference.hpp" #include "boost/type_traits/ice.hpp" #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) # include "boost/type_traits/is_void.hpp" #endif // should be always the last #include directive #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { // is one type convertable to another? // // there are multiple versions of the is_convertible // template, almost every compiler seems to require its // own version. // // Thanks to Andrei Alexandrescu for the original version of the // conversion detection technique! // namespace detail { // MS specific version: #if defined(BOOST_MSVC) && (BOOST_MSVC <= 1300) // This workaround is necessary to handle when From is void // which is normally taken care of by the partial specialization // of the is_convertible typename. using ::boost::type_traits::yes_type; using ::boost::type_traits::no_type; template< typename From > struct does_conversion_exist { template< typename To > struct result_ { static no_type BOOST_TT_DECL _m_check(...); static yes_type BOOST_TT_DECL _m_check(To); static From _m_from; enum { value = sizeof( _m_check(_m_from) ) == sizeof(yes_type) }; }; }; template<> struct does_conversion_exist { template< typename To > struct result_ { enum { value = ::boost::is_void::value }; }; }; template struct is_convertible_basic_impl : does_conversion_exist::template result_ { }; #elif defined(__BORLANDC__) && (__BORLANDC__ < 0x560) // // special version for Borland compilers // this version breaks when used for some // UDT conversions: // template struct is_convertible_impl { #pragma option push -w-8074 // This workaround for Borland breaks the EDG C++ frontend, // so we only use it for Borland. template struct checker { static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(T); }; static From _m_from; static bool const value = sizeof( checker::_m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type); #pragma option pop }; #elif defined(__GNUC__) || defined(__BORLANDC__) && (__BORLANDC__ < 0x600) // special version for gcc compiler + recent Borland versions // note that this does not pass UDT's through (...) struct any_conversion { template any_conversion(const volatile T&); template any_conversion(T&); }; template struct checker { static boost::type_traits::no_type _m_check(any_conversion ...); static boost::type_traits::yes_type _m_check(T, int); }; template struct is_convertible_basic_impl { static From _m_from; static bool const value = sizeof( detail::checker::_m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type); }; #elif (defined(__EDG_VERSION__) && (__EDG_VERSION__ >= 245) && !defined(__ICL)) \ || defined(__IBMCPP__) // // This is *almost* an ideal world implementation as it doesn't rely // on undefined behaviour by passing UDT's through (...). // Unfortunately it doesn't quite pass all the tests for most compilers (sigh...) // Enable this for your compiler if is_convertible_test.cpp will compile it... // // Note we do not enable this for VC7.1, because even though it passes all the // type_traits tests it is known to cause problems when instantiation occurs // deep within the instantiation tree :-( // struct any_conversion { template any_conversion(const volatile T&); // we need this constructor to catch references to functions // (which can not be cv-qualified): template any_conversion(T&); }; template struct is_convertible_basic_impl { static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion ...); static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int); static From _m_from; BOOST_STATIC_CONSTANT(bool, value = sizeof( _m_check(_m_from, 0) ) == sizeof(::boost::type_traits::yes_type) ); }; #elif defined(__DMC__) struct any_conversion { template any_conversion(const volatile T&); // we need this constructor to catch references to functions // (which can not be cv-qualified): template any_conversion(T&); }; template struct is_convertible_basic_impl { // Using '...' doesn't always work on Digital Mars. This version seems to. template static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(any_conversion, float, T); static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To, int, int); static From _m_from; // Static constants sometime cause the conversion of _m_from to To to be // called. This doesn't happen with an enum. enum { value = sizeof( _m_check(_m_from, 0, 0) ) == sizeof(::boost::type_traits::yes_type) }; }; #else // // This version seems to work pretty well for a wide spectrum of compilers, // however it does rely on undefined behaviour by passing UDT's through (...). // template struct is_convertible_basic_impl { static ::boost::type_traits::no_type BOOST_TT_DECL _m_check(...); static ::boost::type_traits::yes_type BOOST_TT_DECL _m_check(To); static From _m_from; BOOST_STATIC_CONSTANT(bool, value = sizeof( _m_check(_m_from) ) == sizeof(::boost::type_traits::yes_type) ); }; #endif // is_convertible_impl #if defined(__DMC__) // As before, a static constant sometimes causes errors on Digital Mars. template struct is_convertible_impl { typedef typename add_reference::type ref_type; enum { value = ::boost::type_traits::ice_and< ::boost::detail::is_convertible_basic_impl::value, ::boost::type_traits::ice_not< ::boost::is_array::value >::value, >::value }; }; #elif !defined(__BORLANDC__) || __BORLANDC__ > 0x551 template struct is_convertible_impl { typedef typename add_reference::type ref_type; BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::detail::is_convertible_basic_impl::value, ::boost::type_traits::ice_not< ::boost::is_array::value >::value >::value) ); }; #endif // // Now add the full and partial specialisations // for void types, these are common to all the // implementation above: // #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS # define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2,value) \ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const,value) \ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 volatile,value) \ BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,spec1,spec2 const volatile,value) \ /**/ # define TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(trait,spec1,spec2,value) \ TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1,spec2,value) \ TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const,spec2,value) \ TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 volatile,spec2,value) \ TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1(trait,spec1 const volatile,spec2,value) \ /**/ TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2(is_convertible,void,void,true) # undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2 # undef TT_AUX_BOOL_CV_VOID_TRAIT_SPEC2_PART1 #else BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(is_convertible,void,void,true) #endif // BOOST_NO_CV_VOID_SPECIALIZATIONS #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void,To,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const,To,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void volatile,To,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename To,is_convertible,void const volatile,To,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(typename From,is_convertible,From,void const volatile,false) #endif #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_convertible,From,To,(::boost::detail::is_convertible_impl::value)) #if defined(__GNUC__) // Declare specializations of is_convertible for all of the floating // types to all of the integral types. This suppresses some nasty // warnings # define TT_AUX_IS_CONVERTIBLE_SPEC(T1,T2) \ BOOST_TT_AUX_BOOL_TRAIT_SPEC2(is_convertible,T1,T2,true) \ /**/ # define TT_AUX_IS_CONVERTIBLE_SPEC_2(T1,T2) \ TT_AUX_IS_CONVERTIBLE_SPEC(T1,signed T2) \ TT_AUX_IS_CONVERTIBLE_SPEC(T1,unsigned T2) \ /**/ # define TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F) \ TT_AUX_IS_CONVERTIBLE_SPEC(F,char) \ TT_AUX_IS_CONVERTIBLE_SPEC_2(F,char) \ TT_AUX_IS_CONVERTIBLE_SPEC_2(F,short) \ TT_AUX_IS_CONVERTIBLE_SPEC_2(F,int) \ TT_AUX_IS_CONVERTIBLE_SPEC_2(F,long) \ TT_AUX_IS_CONVERTIBLE_SPEC(F,::boost::long_long_type) \ TT_AUX_IS_CONVERTIBLE_SPEC(F,::boost::ulong_long_type) \ /**/ # define TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(F) \ TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F) \ TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F const) \ TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F volatile) \ TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC(F const volatile) \ /**/ TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(float) TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(double) TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC(long double) # undef TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_CV_SPEC # undef TT_AUX_IS_CONVERTIBLE_FROM_FLOAT_SPEC # undef TT_AUX_IS_CONVERTIBLE_SPEC_2 # undef TT_AUX_IS_CONVERTIBLE_SPEC #endif // __GNUC__ } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_CONVERTIBLE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_function.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_functi0000644000175000017500000000425511344301501031724 0ustar debiandebian // Copyright 2000 John Maddock (john@johnmaddock.co.uk) // Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) // // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED #define BOOST_TT_IS_FUNCTION_HPP_INCLUDED #include "boost/type_traits/is_reference.hpp" #include "boost/type_traits/detail/false_result.hpp" #include "boost/config.hpp" #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/detail/is_function_ptr_helper.hpp" #else # include "boost/type_traits/detail/is_function_ptr_tester.hpp" # include "boost/type_traits/detail/yes_no_type.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" // is a type a function? // Please note that this implementation is unnecessarily complex: // we could just use !is_convertible::value, // except that some compilers erroneously allow conversions from // function pointers to void*. namespace boost { namespace detail { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_function_chooser : ::boost::type_traits::false_result { }; template <> struct is_function_chooser { template< typename T > struct result_ : ::boost::type_traits::is_function_ptr_helper { }; }; template struct is_function_impl : is_function_chooser< ::boost::is_reference::value > ::BOOST_NESTED_TEMPLATE result_ { }; #else template struct is_function_impl { static T* t; BOOST_STATIC_CONSTANT( bool, value = sizeof(::boost::type_traits::is_function_ptr_tester(t)) == sizeof(::boost::type_traits::yes_type) ); }; #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_function,T,::boost::detail::is_function_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_empty.0000644000175000017500000001300311344301501031637 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_EMPTY_HPP_INCLUDED #define BOOST_TT_IS_EMPTY_HPP_INCLUDED #include "boost/type_traits/is_convertible.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/type_traits/config.hpp" #include "boost/type_traits/intrinsics.hpp" #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/remove_cv.hpp" # include "boost/type_traits/is_class.hpp" # include "boost/type_traits/add_reference.hpp" #else # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_pointer.hpp" # include "boost/type_traits/is_member_pointer.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/is_void.hpp" # include "boost/type_traits/detail/ice_and.hpp" # include "boost/type_traits/detail/ice_not.hpp" #endif // should be always the last #include directive #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct empty_helper_t1 : public T { empty_helper_t1(); // hh compiler bug workaround int i[256]; }; struct empty_helper_t2 { int i[256]; }; #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) template struct empty_helper { BOOST_STATIC_CONSTANT(bool, value = false); }; template struct empty_helper { BOOST_STATIC_CONSTANT( bool, value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) ); }; template struct is_empty_impl { typedef typename remove_cv::type cvt; BOOST_STATIC_CONSTANT( bool, value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper::value>::value , BOOST_IS_EMPTY(cvt) >::value )); }; #else // __BORLANDC__ template struct empty_helper { BOOST_STATIC_CONSTANT(bool, value = false); }; template struct empty_helper { BOOST_STATIC_CONSTANT(bool, value = ( sizeof(empty_helper_t1) == sizeof(empty_helper_t2) )); }; template struct is_empty_impl { typedef typename remove_cv::type cvt; typedef typename add_reference::type r_type; BOOST_STATIC_CONSTANT( bool, value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper< cvt , ::boost::is_class::value , ::boost::is_convertible< r_type,int>::value >::value , BOOST_IS_EMPTY(cvt) >::value)); }; #endif // __BORLANDC__ #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #ifdef BOOST_MSVC6_MEMBER_TEMPLATES template struct empty_helper_t1 : public T { empty_helper_t1(); int i[256]; }; struct empty_helper_t2 { int i[256]; }; template struct empty_helper_base { enum { value = (sizeof(empty_helper_t1) == sizeof(empty_helper_t2)) }; }; template struct empty_helper_nonbase { enum { value = false }; }; template struct empty_helper_chooser { template struct result_ { typedef empty_helper_nonbase type; }; }; template <> struct empty_helper_chooser { template struct result_ { typedef empty_helper_base type; }; }; template struct is_empty_impl { typedef ::boost::detail::empty_helper_chooser< ::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference::value >::value, ::boost::type_traits::ice_not< ::boost::is_convertible::value >::value, ::boost::type_traits::ice_not< ::boost::is_pointer::value >::value, ::boost::type_traits::ice_not< ::boost::is_member_pointer::value >::value, ::boost::type_traits::ice_not< ::boost::is_array::value >::value, ::boost::type_traits::ice_not< ::boost::is_void::value >::value, ::boost::type_traits::ice_not< ::boost::is_convertible::value >::value >::value > chooser; typedef typename chooser::template result_ result; typedef typename result::type eh_type; BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or::value)); }; #else template struct is_empty_impl { BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_EMPTY(T)); }; #endif // BOOST_MSVC6_MEMBER_TEMPLATES #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // these help when the compiler has no partial specialization support: BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_empty,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_empty,T,::boost::detail::is_empty_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_EMPTY_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_enum.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_enum.h0000644000175000017500000001170111344301501031620 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_ENUM_HPP_INCLUDED #define BOOST_TT_IS_ENUM_HPP_INCLUDED #include "boost/type_traits/add_reference.hpp" #include "boost/type_traits/is_arithmetic.hpp" #include "boost/type_traits/is_reference.hpp" #include "boost/type_traits/is_convertible.hpp" #ifdef __GNUC__ #include #endif #include "boost/type_traits/config.hpp" #if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) # include # include #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #if !(defined(__BORLANDC__) && (__BORLANDC__ <= 0x551)) namespace detail { #if defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) template struct is_class_or_union { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< ::boost::is_class::value , ::boost::is_union::value >::value)); }; #else template struct is_class_or_union { # if BOOST_WORKAROUND(BOOST_MSVC, == 1200) || BOOST_WORKAROUND(__BORLANDC__, <= 0x570)// we simply can't detect it this way. BOOST_STATIC_CONSTANT(bool, value = false); # else template static ::boost::type_traits::yes_type is_class_or_union_tester(void(U::*)(void)); # if BOOST_WORKAROUND(BOOST_MSVC, == 1300) \ || BOOST_WORKAROUND(__MWERKS__, <= 0x3000) // no SFINAE static ::boost::type_traits::no_type is_class_or_union_tester(...); BOOST_STATIC_CONSTANT( bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); # else template static ::boost::type_traits::no_type is_class_or_union_tester(...); BOOST_STATIC_CONSTANT( bool, value = sizeof(is_class_or_union_tester(0)) == sizeof(::boost::type_traits::yes_type)); # endif # endif }; #endif struct int_convertible { int_convertible(int); }; // Don't evaluate convertibility to int_convertible unless the type // is non-arithmetic. This suppresses warnings with GCC. template struct is_enum_helper { template struct type { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template <> struct is_enum_helper { template struct type : ::boost::is_convertible { }; }; template struct is_enum_impl { typedef ::boost::add_reference ar_t; typedef typename ar_t::type r_type; #if defined(__GNUC__) #ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION BOOST_STATIC_CONSTANT(bool, selector = (::boost::type_traits::ice_or< ::boost::is_arithmetic::value , ::boost::is_reference::value , ::boost::is_function::value , is_class_or_union::value >::value)); #else BOOST_STATIC_CONSTANT(bool, selector = (::boost::type_traits::ice_or< ::boost::is_arithmetic::value , ::boost::is_reference::value , ::boost::is_function::value >::value)); #endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION #else BOOST_STATIC_CONSTANT(bool, selector = (::boost::type_traits::ice_or< ::boost::is_arithmetic::value , ::boost::is_reference::value , is_class_or_union::value // However, not doing this on non-conforming compilers prevents // a dependency recursion. >::value)); #endif #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) typedef ::boost::detail::is_enum_helper< ::boost::detail::is_enum_impl::selector > se_t; #else typedef ::boost::detail::is_enum_helper se_t; #endif typedef typename se_t::template type helper; BOOST_STATIC_CONSTANT(bool, value = helper::value); }; // these help on compilers with no partial specialization support: BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_enum,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,::boost::detail::is_enum_impl::value) #else // __BORLANDC__ // // buggy is_convertible prevents working // implementation of is_enum: BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_enum,T,false) #endif } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_ENUM_HPP_INCLUDED ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/broken_compiler_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/broken_co0000644000175000017500000001266111344301501031702 0ustar debiandebian // Copyright 2001-2003 Aleksey Gurtovoy. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED #define BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED #include "boost/mpl/aux_/lambda_support.hpp" #include "boost/config.hpp" // these are needed regardless of BOOST_TT_NO_BROKEN_COMPILER_SPEC #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace boost { namespace detail { template< typename T > struct remove_const_impl { typedef T type; }; template< typename T > struct remove_volatile_impl { typedef T type; }; template< typename T > struct remove_pointer_impl { typedef T type; }; template< typename T > struct remove_reference_impl { typedef T type; }; typedef int invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces; }} #endif // agurt, 27/jun/03: disable the workaround if user defined // BOOST_TT_NO_BROKEN_COMPILER_SPEC #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ || defined(BOOST_TT_NO_BROKEN_COMPILER_SPEC) # define BOOST_TT_BROKEN_COMPILER_SPEC(T) /**/ #else // same as BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 macro, except that it // never gets #undef-ined # define BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(trait,spec,result) \ template<> struct trait##_impl \ { \ typedef result type; \ }; \ /**/ # define BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const,T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_const,T const volatile,T volatile) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T volatile,T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_volatile,T const volatile,T const) \ /**/ # define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*,T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const,T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*volatile,T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_pointer,T*const volatile,T) \ BOOST_TT_AUX_BROKEN_TYPE_TRAIT_SPEC1(remove_reference,T&,T) \ /**/ # define BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \ BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T) \ BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const) \ BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T volatile) \ BOOST_TT_AUX_REMOVE_PTR_REF_RANK_1_SPEC(T const volatile) \ /**/ # define BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \ BOOST_TT_AUX_REMOVE_PTR_REF_RANK_2_SPEC(T) \ BOOST_TT_AUX_REMOVE_CONST_VOLATILE_RANK1_SPEC(T) \ /**/ # define BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \ BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T*) \ BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const*) \ BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T volatile*) \ BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T const volatile*) \ /**/ # define BOOST_TT_BROKEN_COMPILER_SPEC(T) \ namespace boost { namespace detail { \ typedef invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces \ please_invoke_BOOST_TT_BROKEN_COMPILER_SPEC_outside_all_namespaces; \ BOOST_TT_AUX_REMOVE_ALL_RANK_1_SPEC(T) \ BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T) \ BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T*) \ BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const*) \ BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T volatile*) \ BOOST_TT_AUX_REMOVE_ALL_RANK_2_SPEC(T const volatile*) \ }} \ /**/ # include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_BROKEN_COMPILER_SPEC(bool) BOOST_TT_BROKEN_COMPILER_SPEC(char) #ifndef BOOST_NO_INTRINSIC_WCHAR_T BOOST_TT_BROKEN_COMPILER_SPEC(wchar_t) #endif BOOST_TT_BROKEN_COMPILER_SPEC(signed char) BOOST_TT_BROKEN_COMPILER_SPEC(unsigned char) BOOST_TT_BROKEN_COMPILER_SPEC(signed short) BOOST_TT_BROKEN_COMPILER_SPEC(unsigned short) BOOST_TT_BROKEN_COMPILER_SPEC(signed int) BOOST_TT_BROKEN_COMPILER_SPEC(unsigned int) BOOST_TT_BROKEN_COMPILER_SPEC(signed long) BOOST_TT_BROKEN_COMPILER_SPEC(unsigned long) BOOST_TT_BROKEN_COMPILER_SPEC(float) BOOST_TT_BROKEN_COMPILER_SPEC(double) //BOOST_TT_BROKEN_COMPILER_SPEC(long double) // for backward compatibility #define BOOST_BROKEN_COMPILER_TYPE_TRAITS_SPECIALIZATION(T) \ BOOST_TT_BROKEN_COMPILER_SPEC(T) \ /**/ #endif // BOOST_TT_BROKEN_COMPILER_SPEC_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/transform_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/transform0000644000175000017500000000157511344301501031756 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // defines traits classes for transforming one type to another: // remove_reference, add_reference, remove_bounds, remove_pointer. // #ifndef BOOST_TT_TRANSFORM_TRAITS_HPP_INCLUDED #define BOOST_TT_TRANSFORM_TRAITS_HPP_INCLUDED #include "boost/type_traits/add_pointer.hpp" #include "boost/type_traits/add_reference.hpp" #include "boost/type_traits/remove_bounds.hpp" #include "boost/type_traits/remove_pointer.hpp" #include "boost/type_traits/remove_reference.hpp" #endif // BOOST_TT_TRANSFORM_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivial_constructor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivi0000644000175000017500000000237211344301501031727 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED #define BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/type_traits/intrinsics.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/detail/ice_or.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct has_trivial_ctor_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< ::boost::is_pod::value, BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) >::value)); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_constructor,T,::boost::detail::has_trivial_ctor_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_TRIVIAL_CONSTRUCTOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_same.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_same.h0000644000175000017500000000621711344301501031607 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Howard Hinnant and John Maddock 2000. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Fixed is_pointer, is_reference, is_const, is_volatile, is_same, // is_member_pointer based on the Simulated Partial Specialization work // of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or // http://groups.yahoo.com/group/boost/message/5441 // Some workarounds in here use ideas suggested from "Generic: // Mappings between Types and Values" // by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). #ifndef BOOST_TT_IS_SAME_HPP_INCLUDED #define BOOST_TT_IS_SAME_HPP_INCLUDED #include "boost/type_traits/config.hpp" #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/is_reference.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T,T,true) #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) // without this, Borland's compiler gives the wrong answer for // references to arrays: BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(typename T,is_same,T&,T&,true) #endif #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { #ifdef BOOST_MSVC // the following VC6 specific implementation is *NOT* legal // C++, but has the advantage that it works for incomplete // types. template< typename T1 > struct is_same_part_1 { template struct part_2 { enum { value = false }; }; template<> struct part_2 { enum { value = true }; }; }; template< typename T1, typename T2 > struct is_same_impl { enum { value = detail::is_same_part_1::template part_2::value }; }; #else // generic "no-partial-specialization" version template ::boost::type_traits::yes_type BOOST_TT_DECL is_same_tester(T*, T*); ::boost::type_traits::no_type BOOST_TT_DECL is_same_tester(...); template struct is_same_impl { static T t; static U u; BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< (sizeof(type_traits::yes_type) == sizeof(detail::is_same_tester(&t,&u))), (::boost::is_reference::value == ::boost::is_reference::value), (sizeof(T) == sizeof(U)) >::value)); }; #endif // BOOST_MSVC } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF2(is_same,T,U,(::boost::detail::is_same_impl::value)) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_SAME_HPP_INCLUDED ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_member_pointer.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_member0000644000175000017500000000737111344301501031705 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Howard Hinnant and John Maddock 2000. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Fixed is_pointer, is_reference, is_const, is_volatile, is_same, // is_member_pointer based on the Simulated Partial Specialization work // of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or // http://groups.yahoo.com/group/boost/message/5441 // Some workarounds in here use ideas suggested from "Generic: // Mappings between Types and Values" // by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). #ifndef BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED #define BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/detail/workaround.hpp" #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) # include "boost/type_traits/is_member_function_pointer.hpp" #else # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/detail/is_mem_fun_pointer_tester.hpp" # include "boost/type_traits/detail/yes_no_type.hpp" # include "boost/type_traits/detail/false_result.hpp" # include "boost/type_traits/detail/ice_or.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) #elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::is_member_function_pointer::value) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,typename U,is_member_pointer,U T::*,true) #else // no partial template specialization namespace detail { template ::boost::type_traits::yes_type BOOST_TT_DECL is_member_pointer_tester(R T::*); ::boost::type_traits::no_type BOOST_TT_DECL is_member_pointer_tester(...); template struct is_member_pointer_select : ::boost::type_traits::false_result { }; template <> struct is_member_pointer_select { template struct result_ { static T& make_t(); BOOST_STATIC_CONSTANT( bool, value = (::boost::type_traits::ice_or< (1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(make_t()))), (1 == sizeof(is_member_pointer_tester(make_t()))) >::value) ); }; }; template struct is_member_pointer_impl : is_member_pointer_select< ::boost::type_traits::ice_or< ::boost::is_reference::value , ::boost::is_array::value >::value >::template result_ { }; BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_pointer,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_pointer,T,::boost::detail::is_member_pointer_impl::value) #endif // __BORLANDC__ } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_MEMBER_POINTER_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/config.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/config.hp0000644000175000017500000000230511344301501031606 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_CONFIG_HPP_INCLUDED #define BOOST_TT_CONFIG_HPP_INCLUDED #ifndef BOOST_CONFIG_HPP #include "boost/config.hpp" #endif // // whenever we have a conversion function with elipses // it needs to be declared __cdecl to suppress compiler // warnings from MS and Borland compilers (this *must* // appear before we include is_same.hpp below): #if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32)) # define BOOST_TT_DECL __cdecl #else # define BOOST_TT_DECL /**/ #endif # if (defined(__MWERKS__) && __MWERKS__ >= 0x3000) || (defined(BOOST_MSVC) && (BOOST_MSVC > 1301)) || defined(__EDG_VERSION__) || (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__DMC__) || defined(BOOST_NO_COMPILER_CONFIG) # define BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION #endif #endif // BOOST_TT_CONFIG_HPP_INCLUDED ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/transform_traits_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/transform0000644000175000017500000000103711344301501031747 0ustar debiandebian // Copyright 2001 Aleksey Gurtovoy. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP_INCLUDED #define BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP_INCLUDED #include "boost/type_traits/broken_compiler_spec.hpp" #endif // BOOST_TT_TRANSFORM_TRAITS_SPEC_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_compound.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_compou0000644000175000017500000000216011344301501031727 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_COMPOUND_HPP_INCLUDED #define BOOST_TT_IS_COMPOUND_HPP_INCLUDED #include "boost/config.hpp" #include "boost/type_traits/is_fundamental.hpp" #include "boost/type_traits/detail/ice_not.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct is_compound_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_not< ::boost::is_fundamental::value >::value)); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_compound,T,::boost::detail::is_compound_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_COMPOUND_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_reference.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_refere0000644000175000017500000001076011344301501031702 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Howard Hinnant and John Maddock 2000. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Fixed is_pointer, is_reference, is_const, is_volatile, is_same, // is_member_pointer based on the Simulated Partial Specialization work // of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or // http://groups.yahoo.com/group/boost/message/5441 // Some workarounds in here use ideas suggested from "Generic: // Mappings between Types and Values" // by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). #ifndef BOOST_TT_IS_REFERENCE_HPP_INCLUDED #define BOOST_TT_IS_REFERENCE_HPP_INCLUDED #include "boost/type_traits/config.hpp" #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/detail/yes_no_type.hpp" # include "boost/type_traits/detail/wrap.hpp" #endif #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && defined(BOOST_MSVC) # include "boost/type_traits/detail/is_function_type_tester.hpp" # include "boost/type_traits/detail/false_result.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T&,true) #if defined(__BORLANDC__) && !defined(__COMO__) && (__BORLANDC__ < 0x600) // these are illegal specialisations; cv-qualifies applied to // references have no effect according to [8.3.2p1], // C++ Builder requires them though as it treats cv-qualified // references as distinct types... BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& const,true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& volatile,true) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T& const volatile,true) #endif #if defined(__GNUC__) && (__GNUC__ < 3) // these allow us to work around illegally cv-qualified reference // types. BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T const ,::boost::is_reference::value) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T volatile ,::boost::is_reference::value) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_reference,T const volatile ,::boost::is_reference::value) // However, the above specializations confuse gcc 2.96 unless we also // supply these specializations for array types BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,T[N],false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,const T[N],false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,volatile T[N],false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(typename T,unsigned long N,is_reference,const volatile T[N],false) #endif #else #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable: 4181) #endif namespace detail { using ::boost::type_traits::yes_type; using ::boost::type_traits::no_type; using ::boost::type_traits::wrap; template T&(* is_reference_helper1(wrap) )(wrap); char is_reference_helper1(...); template no_type is_reference_helper2(T&(*)(wrap)); yes_type is_reference_helper2(...); template struct is_reference_impl { BOOST_STATIC_CONSTANT( bool, value = sizeof( ::boost::detail::is_reference_helper2( ::boost::detail::is_reference_helper1(::boost::type_traits::wrap()))) == 1 ); }; BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_reference,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_reference,T,::boost::detail::is_reference_impl::value) #ifdef BOOST_MSVC # pragma warning(pop) #endif #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_REFERENCE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_volatile.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_volati0000644000175000017500000000756511344301501031741 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Howard Hinnant and John Maddock 2000. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Fixed is_pointer, is_reference, is_const, is_volatile, is_same, // is_member_pointer based on the Simulated Partial Specialization work // of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or // http://groups.yahoo.com/group/boost/message/5441 // Some workarounds in here use ideas suggested from "Generic: // Mappings between Types and Values" // by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). #ifndef BOOST_TT_IS_VOLATILE_HPP_INCLUDED #define BOOST_TT_IS_VOLATILE_HPP_INCLUDED #include "boost/config.hpp" #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/detail/cv_traits_impl.hpp" #else # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/detail/yes_no_type.hpp" # include "boost/type_traits/detail/false_result.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION //* is a type T declared volatile - is_volatile BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::cv_traits_imp::is_volatile) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T&,false) #if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) // these are illegal specialisations; cv-qualifies applied to // references have no effect according to [8.3.2p1], // C++ Builder requires them though as it treats cv-qualified // references as distinct types... BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& volatile,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_volatile,T& const volatile,false) #endif #else namespace detail { using ::boost::type_traits::yes_type; using ::boost::type_traits::no_type; yes_type is_volatile_tester(void const volatile*); no_type is_volatile_tester(void const*); template struct is_volatile_helper : ::boost::type_traits::false_result { }; template <> struct is_volatile_helper { template struct result_ { static T* t; BOOST_STATIC_CONSTANT(bool, value = ( sizeof(detail::yes_type) == sizeof(detail::is_volatile_tester(t)) )); }; }; template <> struct is_volatile_helper { template struct result_ { static T t; BOOST_STATIC_CONSTANT(bool, value = ( sizeof(detail::yes_type) == sizeof(detail::is_volatile_tester(&t)) )); }; }; template struct is_volatile_impl : is_volatile_helper< is_reference::value , is_array::value >::template result_ { }; BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void volatile,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_volatile,void const volatile,true) #endif } // namespace detail //* is a type T declared volatile - is_volatile BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_volatile,T,::boost::detail::is_volatile_impl::value) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_VOLATILE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_const.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_const.0000644000175000017500000001036211344301501031634 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Howard Hinnant and John Maddock 2000. // (C) Copyright Mat Marcus, Jesse Jones and Adobe Systems Inc 2001 // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // Fixed is_pointer, is_reference, is_const, is_volatile, is_same, // is_member_pointer based on the Simulated Partial Specialization work // of Mat Marcus and Jesse Jones. See http://opensource.adobe.com or // http://groups.yahoo.com/group/boost/message/5441 // Some workarounds in here use ideas suggested from "Generic: // Mappings between Types and Values" // by Andrei Alexandrescu (see http://www.cuj.com/experts/1810/alexandr.html). #ifndef BOOST_TT_IS_CONST_HPP_INCLUDED #define BOOST_TT_IS_CONST_HPP_INCLUDED #include "boost/config.hpp" #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # include "boost/type_traits/detail/cv_traits_impl.hpp" # ifdef __GNUC__ # include # endif #else # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/detail/yes_no_type.hpp" # include "boost/type_traits/detail/false_result.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION //* is a type T declared const - is_const BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::cv_traits_imp::is_const) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T&,false) #if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) // these are illegal specialisations; cv-qualifies applied to // references have no effect according to [8.3.2p1], // C++ Builder requires them though as it treats cv-qualified // references as distinct types... BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& volatile,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T& const volatile,false) #endif #if defined(__GNUC__) && (__GNUC__ < 3) // special case for gcc where illegally cv-qualified reference types can be // generated in some corner cases: BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T const,!(::boost::is_reference::value)) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(typename T,is_const,T volatile const,!(::boost::is_reference::value)) #endif #else namespace detail { using ::boost::type_traits::yes_type; using ::boost::type_traits::no_type; yes_type is_const_tester(const volatile void*); no_type is_const_tester(volatile void *); template struct is_const_helper : ::boost::type_traits::false_result { }; template <> struct is_const_helper { template struct result_ { static T* t; BOOST_STATIC_CONSTANT(bool, value = ( sizeof(detail::yes_type) == sizeof(detail::is_const_tester(t)) )); }; }; template <> struct is_const_helper { template struct result_ { static T t; BOOST_STATIC_CONSTANT(bool, value = ( sizeof(detail::yes_type) == sizeof(detail::is_const_tester(&t)) )); }; }; template struct is_const_impl : is_const_helper< is_reference::value , is_array::value >::template result_ { }; BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_const,void const volatile,true) #endif } // namespace detail //* is a type T declared const - is_const BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_const,T,::boost::detail::is_const_impl::value) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_CONST_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_volatile.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_vo0000644000175000017500000000405111344301501031734 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED #define BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED #include "boost/type_traits/is_const.hpp" #include "boost/type_traits/broken_compiler_spec.hpp" #include "boost/type_traits/detail/cv_traits_impl.hpp" #include "boost/config.hpp" #include // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { template struct remove_volatile_helper { typedef T type; }; template struct remove_volatile_helper { typedef T const type; }; template struct remove_volatile_impl { typedef typename remove_volatile_helper< typename cv_traits_imp::unqualified_type , ::boost::is_const::value >::type type; }; } // namespace detail // * convert a type T to a non-volatile type - remove_volatile BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename detail::remove_volatile_impl::type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_volatile,T&,T&) #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T volatile[N],T type[N]) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_volatile,T const volatile[N],T const type[N]) #endif #else BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_volatile,T,typename detail::remove_volatile_impl::type) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_REMOVE_VOLATILE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_union.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_union.0000644000175000017500000000261711344301501031642 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_UNION_HPP_INCLUDED #define BOOST_TT_IS_UNION_HPP_INCLUDED #include "boost/type_traits/remove_cv.hpp" #include "boost/type_traits/config.hpp" #include "boost/type_traits/intrinsics.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { #ifndef __GNUC__ template struct is_union_impl { typedef typename remove_cv::type cvt; BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(cvt)); }; #else // // using remove_cv here generates a whole load of needless // warnings with gcc, since it doesn't do any good with gcc // in any case (at least at present), just remove it: // template struct is_union_impl { BOOST_STATIC_CONSTANT(bool, value = BOOST_IS_UNION(T)); }; #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_union,T,::boost::detail::is_union_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_UNION_HPP_INCLUDED ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivial_destructor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivi0000644000175000017500000000236511344301501031731 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED #define BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/type_traits/intrinsics.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/detail/ice_or.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct has_trivial_dtor_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< ::boost::is_pod::value, BOOST_HAS_TRIVIAL_DESTRUCTOR(T) >::value)); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_destructor,T,::boost::detail::has_trivial_dtor_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_TRIVIAL_DESTRUCTOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_pointer.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_po0000644000175000017500000000243311344301501031730 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REMOVE_POINTER_HPP_INCLUDED #define BOOST_TT_REMOVE_POINTER_HPP_INCLUDED #include "boost/type_traits/broken_compiler_spec.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T*,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* volatile,T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_pointer,T* const volatile,T) #else BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_pointer,T,typename detail::remove_pointer_impl::type) #endif } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_REMOVE_POINTER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/alignment_of.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/alignment0000644000175000017500000000475111344301501031720 0ustar debiandebian // (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED #define BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED #include "boost/config.hpp" #include // should be the last #include #include "boost/type_traits/detail/size_t_trait_def.hpp" #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable: 4121) // alignment is sensitive to packing #endif #if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) #pragma option push -Vx- -Ve- #endif namespace boost { template struct alignment_of; // get the alignment of some arbitrary type: namespace detail { template struct alignment_of_hack { char c; T t; alignment_of_hack(); }; template struct alignment_logic { BOOST_STATIC_CONSTANT(std::size_t, value = A < S ? A : S); }; template< typename T > struct alignment_of_impl { BOOST_STATIC_CONSTANT(std::size_t, value = (::boost::detail::alignment_logic< sizeof(detail::alignment_of_hack) - sizeof(T), sizeof(T) >::value)); }; } // namespace detail BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl::value) // references have to be treated specially, assume // that a reference is just a special pointer: #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct alignment_of : alignment_of { }; #endif #ifdef __BORLANDC__ // long double gives an incorrect value of 10 (!) // unless we do this... struct long_double_wrapper{ long double ld; }; template<> struct alignment_of : public alignment_of{}; #endif // void has to be treated specially: BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void,0) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const,0) BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void volatile,0) BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(alignment_of,void const volatile,0) #endif } // namespace boost #if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) #pragma option pop #endif #ifdef BOOST_MSVC # pragma warning(pop) #endif #include "boost/type_traits/detail/size_t_trait_undef.hpp" #endif // BOOST_TT_ALIGNMENT_OF_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_class.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_class.0000644000175000017500000001053611344301501031616 0ustar debiandebian// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000-2003. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_CLASS_HPP_INCLUDED #define BOOST_TT_IS_CLASS_HPP_INCLUDED #include "boost/type_traits/config.hpp" # include "boost/type_traits/is_union.hpp" # include "boost/type_traits/detail/ice_and.hpp" # include "boost/type_traits/detail/ice_not.hpp" #ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION # include "boost/type_traits/detail/yes_no_type.hpp" #else # include "boost/type_traits/is_scalar.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_void.hpp" # include "boost/type_traits/is_function.hpp" #endif #ifdef __EDG_VERSION__ # include "boost/type_traits/remove_cv.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { #ifdef BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION // This is actually the conforming implementation which works with // abstract classes. However, enough compilers have trouble with // it that most will use the one in // boost/type_traits/object_traits.hpp. This implementation // actually works with VC7.0, but other interactions seem to fail // when we use it. // is_class<> metafunction due to Paul Mensonides // (leavings@attbi.com). For more details: // http://groups.google.com/groups?hl=en&selm=000001c1cc83%24e154d5e0%247772e50c%40c161550a&rnum=1 #if defined(__GNUC__) && !defined(__EDG_VERSION__) template ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); template ::boost::type_traits::no_type is_class_tester(...); template struct is_class_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type), ::boost::type_traits::ice_not< ::boost::is_union::value >::value >::value) ); }; #else template struct is_class_impl { template static ::boost::type_traits::yes_type is_class_tester(void(U::*)(void)); template static ::boost::type_traits::no_type is_class_tester(...); BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< sizeof(is_class_tester(0)) == sizeof(::boost::type_traits::yes_type), ::boost::type_traits::ice_not< ::boost::is_union::value >::value >::value) ); }; #endif #else template struct is_class_impl { # ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_union::value >::value, ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, ::boost::type_traits::ice_not< ::boost::is_array::value >::value, ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, ::boost::type_traits::ice_not< ::boost::is_void::value >::value, ::boost::type_traits::ice_not< ::boost::is_function::value >::value >::value)); # else BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_union::value >::value, ::boost::type_traits::ice_not< ::boost::is_scalar::value >::value, ::boost::type_traits::ice_not< ::boost::is_array::value >::value, ::boost::type_traits::ice_not< ::boost::is_reference::value>::value, ::boost::type_traits::ice_not< ::boost::is_void::value >::value >::value)); # endif }; # endif // BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION } // namespace detail # ifdef __EDG_VERSION__ BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_class,T, detail::is_class_impl::type>::value) # else BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_class,T,::boost::detail::is_class_impl::value) # endif } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_CLASS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/cv_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/cv_traits0000644000175000017500000000174211344301501031735 0ustar debiandebian// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // defines traits classes for cv-qualified types: // is_const, is_volatile, remove_const, remove_volatile, remove_cv. #ifndef BOOST_TT_CV_TRAITS_HPP_INCLUDED #define BOOST_TT_CV_TRAITS_HPP_INCLUDED #include "boost/type_traits/add_const.hpp" #include "boost/type_traits/add_volatile.hpp" #include "boost/type_traits/add_cv.hpp" #include "boost/type_traits/is_const.hpp" #include "boost/type_traits/is_volatile.hpp" #include "boost/type_traits/remove_const.hpp" #include "boost/type_traits/remove_volatile.hpp" #include "boost/type_traits/remove_cv.hpp" #endif // BOOST_TT_CV_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/composite_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/composite0000644000175000017500000000175111344301501031741 0ustar debiandebian// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // defines traits classes for composite types: // is_array, is_pointer, is_reference, is_member_pointer, is_enum, is_union. // #ifndef BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED #define BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED #include "boost/type_traits/is_array.hpp" #include "boost/type_traits/is_enum.hpp" #include "boost/type_traits/is_member_pointer.hpp" #include "boost/type_traits/is_member_function_pointer.hpp" #include "boost/type_traits/is_pointer.hpp" #include "boost/type_traits/is_reference.hpp" #include "boost/type_traits/is_union.hpp" #endif // BOOST_TT_COMPOSITE_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivial_assign.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_trivi0000644000175000017500000000316511344301501031730 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED #define BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/type_traits/intrinsics.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/is_const.hpp" #include "boost/type_traits/is_volatile.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/type_traits/detail/ice_not.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct has_trivial_assign_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod::value, BOOST_HAS_TRIVIAL_ASSIGN(T) >::value, ::boost::type_traits::ice_not< ::boost::is_const::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile::value >::value >::value)); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_trivial_assign,T,::boost::detail::has_trivial_assign_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_TRIVIAL_ASSIGN_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/function_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/function_0000644000175000017500000001551511344301501031726 0ustar debiandebian // Copyright 2000 John Maddock (john@johnmaddock.co.uk) // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED #define BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED #include #include #include namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { template struct function_traits_helper; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 0); typedef R result_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 1); typedef R result_type; typedef T1 arg1_type; typedef T1 argument_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 2); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T1 first_argument_type; typedef T2 second_argument_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 3); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 4); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 5); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 6); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 7); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 8); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; typedef T8 arg8_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 9); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; typedef T8 arg8_type; typedef T9 arg9_type; }; template struct function_traits_helper { BOOST_STATIC_CONSTANT(int, arity = 10); typedef R result_type; typedef T1 arg1_type; typedef T2 arg2_type; typedef T3 arg3_type; typedef T4 arg4_type; typedef T5 arg5_type; typedef T6 arg6_type; typedef T7 arg7_type; typedef T8 arg8_type; typedef T9 arg9_type; typedef T10 arg10_type; }; } // end namespace detail template struct function_traits : public detail::function_traits_helper::type> { }; #else namespace detail { template struct type_of_size { char elements[N]; }; template type_of_size<1> function_arity_helper(R (*f)()); template type_of_size<2> function_arity_helper(R (*f)(T1)); template type_of_size<3> function_arity_helper(R (*f)(T1, T2)); template type_of_size<4> function_arity_helper(R (*f)(T1, T2, T3)); template type_of_size<5> function_arity_helper(R (*f)(T1, T2, T3, T4)); template type_of_size<6> function_arity_helper(R (*f)(T1, T2, T3, T4, T5)); template type_of_size<7> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6)); template type_of_size<8> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7)); template type_of_size<9> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8)); template type_of_size<10> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, T9)); template type_of_size<11> function_arity_helper(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)); } // end namespace detail // Won't work with references template struct function_traits { BOOST_STATIC_CONSTANT(int, arity = (sizeof(detail::function_arity_helper((Function*)0))-1)); }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } #endif // BOOST_TT_FUNCTION_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothrow_destructor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothr0000644000175000017500000000155411344301501031725 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED #define BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED #include "boost/type_traits/has_trivial_destructor.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_destructor,T,::boost::has_trivial_destructor::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_NOTHROW_DESTRUCTOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_stateless.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_statel0000644000175000017500000000274611344301501031733 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_STATELESS_HPP_INCLUDED #define BOOST_TT_IS_STATELESS_HPP_INCLUDED #include "boost/type_traits/has_trivial_constructor.hpp" #include "boost/type_traits/has_trivial_copy.hpp" #include "boost/type_traits/has_trivial_destructor.hpp" #include "boost/type_traits/is_class.hpp" #include "boost/type_traits/is_empty.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct is_stateless_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor::value, ::boost::has_trivial_copy::value, ::boost::has_trivial_destructor::value, ::boost::is_class::value, ::boost::is_empty::value >::value)); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_stateless,T,::boost::detail::is_stateless_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_STATELESS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_scalar.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_scalar0000644000175000017500000000360111344301501031673 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_SCALAR_HPP_INCLUDED #define BOOST_TT_IS_SCALAR_HPP_INCLUDED #include "boost/type_traits/is_arithmetic.hpp" #include "boost/type_traits/is_enum.hpp" #include "boost/type_traits/is_pointer.hpp" #include "boost/type_traits/is_member_pointer.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct is_scalar_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< ::boost::is_arithmetic::value, ::boost::is_enum::value, ::boost::is_pointer::value, ::boost::is_member_pointer::value >::value)); }; // these specializations are only really needed for compilers // without partial specialization support: template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; template <> struct is_scalar_impl{ BOOST_STATIC_CONSTANT(bool, value = false ); }; #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_scalar,T,::boost::detail::is_scalar_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_SCALAR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_bounds.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_bo0000644000175000017500000000342211344301501031711 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED #define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED #include "boost/config.hpp" #include // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_bounds,T,T) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T[N],T type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const[N],T const type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T volatile[N],T volatile type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_bounds,T const volatile[N],T const volatile type) #if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) && !defined(__IBMCPP__) && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T[],T) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const[],T const) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T volatile[],T volatile) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_bounds,T const volatile[],T const volatile) #endif #endif } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_polymorphic.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_polymo0000644000175000017500000000454611344301501031756 0ustar debiandebian// (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_POLYMORPHIC_HPP #define BOOST_TT_IS_POLYMORPHIC_HPP #include #include // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" #include namespace boost{ namespace detail{ template struct is_polymorphic_imp1 { # if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) // CWPro7 should return false always. typedef char d1, (&d2)[2]; # else typedef typename remove_cv::type ncvT; struct d1 : public ncvT { d1(); # if !defined(__GNUC__) // this raises warnings with some classes, and buys nothing with GCC ~d1()throw(); # endif char padding[256]; }; struct d2 : public ncvT { d2(); virtual ~d2()throw(); # if !defined(BOOST_MSVC) && !defined(__ICL) // for some reason this messes up VC++ when T has virtual bases, // probably likewise for compilers that use the same ABI: struct unique{}; virtual void unique_name_to_boost5487629(unique*); # endif char padding[256]; }; # endif BOOST_STATIC_CONSTANT(bool, value = (sizeof(d2) == sizeof(d1))); }; template struct is_polymorphic_imp2 { BOOST_STATIC_CONSTANT(bool, value = false); }; template struct is_polymorphic_selector { template struct rebind { typedef is_polymorphic_imp2 type; }; }; template <> struct is_polymorphic_selector { template struct rebind { typedef is_polymorphic_imp1 type; }; }; template struct is_polymorphic_imp { typedef is_polymorphic_selector< ::boost::is_class::value> selector; typedef typename selector::template rebind binder; typedef typename binder::type imp_type; BOOST_STATIC_CONSTANT(bool, value = imp_type::value); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_polymorphic,T,::boost::detail::is_polymorphic_imp::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_pointer.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_point0000644000175000017500000000321411344301501031674 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ADD_POINTER_HPP_INCLUDED #define BOOST_TT_ADD_POINTER_HPP_INCLUDED #include "boost/type_traits/remove_reference.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { namespace detail { #if defined(__BORLANDC__) && (__BORLANDC__ < 0x600) // // For some reason this implementation stops Borlands compiler // from dropping cv-qualifiers, it still fails with references // to arrays for some reason though (shrug...) (JM 20021104) // template struct add_pointer_impl { typedef T* type; }; template struct add_pointer_impl { typedef T* type; }; template struct add_pointer_impl { typedef T* type; }; template struct add_pointer_impl { typedef T* type; }; template struct add_pointer_impl { typedef T* type; }; #else template struct add_pointer_impl { typedef typename remove_reference::type no_ref_type; typedef no_ref_type* type; }; #endif } // namespace detail BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_pointer,T,typename detail::add_pointer_impl::type) } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_member_function_pointer.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_member0000644000175000017500000000632511344301501031703 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED #define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/detail/workaround.hpp" #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) # include "boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" #else # include "boost/type_traits/is_reference.hpp" # include "boost/type_traits/is_array.hpp" # include "boost/type_traits/detail/is_mem_fun_pointer_tester.hpp" # include "boost/type_traits/detail/yes_no_type.hpp" # include "boost/type_traits/detail/false_result.hpp" # include "boost/type_traits/detail/ice_or.hpp" #endif // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !BOOST_WORKAROUND(__BORLANDC__, < 0x600) BOOST_TT_AUX_BOOL_TRAIT_DEF1( is_member_function_pointer , T , ::boost::type_traits::is_mem_fun_pointer_impl::value ) #else namespace detail { #ifndef __BORLANDC__ template struct is_mem_fun_pointer_select : ::boost::type_traits::false_result { }; template <> struct is_mem_fun_pointer_select { template struct result_ { static T& make_t; typedef result_ self_type; BOOST_STATIC_CONSTANT( bool, value = ( 1 == sizeof(::boost::type_traits::is_mem_fun_pointer_tester(self_type::make_t)) )); }; }; template struct is_member_function_pointer_impl : is_mem_fun_pointer_select< ::boost::type_traits::ice_or< ::boost::is_reference::value , ::boost::is_array::value >::value >::template result_ { }; #else // Borland C++ template struct is_member_function_pointer_impl { static T& m_t; BOOST_STATIC_CONSTANT( bool, value = (1 == sizeof(type_traits::is_mem_fun_pointer_tester(m_t))) ); }; template struct is_member_function_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = false); }; #endif BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void,false) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void volatile,false) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_member_function_pointer,void const volatile,false) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_member_function_pointer,T,::boost::detail::is_member_function_pointer_impl::value) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_volatile.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_volat0000644000175000017500000000271711344301501031677 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ADD_VOLATILE_HPP_INCLUDED #define BOOST_TT_ADD_VOLATILE_HPP_INCLUDED #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { // * convert a type T to volatile type - add_volatile // this is not required since the result is always // the same as "T volatile", but it does suppress warnings // from some compilers: #if defined(BOOST_MSVC) // This bogus warning will appear when add_volatile is applied to a // const volatile reference because we can't detect const volatile // references with MSVC6. # pragma warning(push) # pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored #endif BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_volatile,T,T volatile) #if defined(BOOST_MSVC) # pragma warning(pop) #endif #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_volatile,T&,T&) #endif } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_fundamental.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_fundam0000644000175000017500000000231011344301501031674 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED #define BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED #include "boost/type_traits/is_arithmetic.hpp" #include "boost/type_traits/is_void.hpp" #include "boost/type_traits/detail/ice_or.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template struct is_fundamental_impl : ::boost::type_traits::ice_or< ::boost::is_arithmetic::value , ::boost::is_void::value > { }; } // namespace detail //* is a type T a fundamental type described in the standard (3.9.1) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_fundamental,T,::boost::detail::is_fundamental_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_FUNDAMENTAL_HPP_INCLUDED ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothrow_constructor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothr0000644000175000017500000000156211344301501031724 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED #define BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED #include "boost/type_traits/has_trivial_constructor.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_constructor,T,::boost::has_trivial_constructor::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_NOTHROW_CONSTRUCTOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/object_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/object_tr0000644000175000017500000000264111344301501031711 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // defines object traits classes: // is_object, is_scalar, is_class, is_compound, is_pod, // has_trivial_constructor, has_trivial_copy, has_trivial_assign, // has_trivial_destructor, is_empty. // #ifndef BOOST_TT_OBJECT_TRAITS_HPP_INLCUDED #define BOOST_TT_OBJECT_TRAITS_HPP_INLCUDED #include "boost/type_traits/has_trivial_assign.hpp" #include "boost/type_traits/has_trivial_constructor.hpp" #include "boost/type_traits/has_trivial_copy.hpp" #include "boost/type_traits/has_trivial_destructor.hpp" #include "boost/type_traits/has_nothrow_constructor.hpp" #include "boost/type_traits/has_nothrow_copy.hpp" #include "boost/type_traits/has_nothrow_assign.hpp" #include "boost/type_traits/is_base_and_derived.hpp" #include "boost/type_traits/is_class.hpp" #include "boost/type_traits/is_compound.hpp" #include "boost/type_traits/is_empty.hpp" #include "boost/type_traits/is_object.hpp" #include "boost/type_traits/is_pod.hpp" #include "boost/type_traits/is_scalar.hpp" #include "boost/type_traits/is_stateless.hpp" #endif // BOOST_TT_OBJECT_TRAITS_HPP_INLCUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothrow_copy.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothr0000644000175000017500000000151011344301501031715 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED #define BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED #include "boost/type_traits/has_trivial_copy.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_copy,T,::boost::has_trivial_copy::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_NOTHROW_COPY_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_pod.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_pod.hp0000644000175000017500000000663211344301501031625 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_POD_HPP_INCLUDED #define BOOST_TT_IS_POD_HPP_INCLUDED #include "boost/type_traits/config.hpp" #include "boost/type_traits/is_void.hpp" #include "boost/type_traits/is_scalar.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/type_traits/intrinsics.hpp" #include // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { // forward declaration, needed by 'is_pod_array_helper' template below template< typename T > struct is_POD; namespace detail { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct is_pod_impl { BOOST_STATIC_CONSTANT( bool, value = (::boost::type_traits::ice_or< ::boost::is_scalar::value, ::boost::is_void::value, BOOST_IS_POD(T) >::value)); }; #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template struct is_pod_impl : is_pod_impl { }; #endif #else template struct is_pod_helper { template struct result_ { BOOST_STATIC_CONSTANT( bool, value = (::boost::type_traits::ice_or< ::boost::is_scalar::value, ::boost::is_void::value, BOOST_IS_POD(T) >::value)); }; }; template struct bool_to_yes_no_type { typedef ::boost::type_traits::no_type type; }; template <> struct bool_to_yes_no_type { typedef ::boost::type_traits::yes_type type; }; template struct is_pod_array_helper { enum { is_pod = ::boost::is_POD::value }; // MSVC workaround typedef typename bool_to_yes_no_type::type type; type instance() const; }; template is_pod_array_helper is_POD_array(T*); template <> struct is_pod_helper { template struct result_ { static T& help(); BOOST_STATIC_CONSTANT(bool, value = sizeof(is_POD_array(help()).instance()) == sizeof(::boost::type_traits::yes_type) ); }; }; template struct is_pod_impl { BOOST_STATIC_CONSTANT( bool, value = ( ::boost::detail::is_pod_helper< ::boost::is_array::value >::template result_::value ) ); }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // the following help compilers without partial specialization support: BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void,true) #ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void const,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void volatile,true) BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(is_pod,void const volatile,true) #endif } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_POD,T,::boost::detail::is_pod_impl::value) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_pod,T,::boost::detail::is_pod_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_POD_HPP_INCLUDED ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothrow_assign.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/has_nothr0000644000175000017500000000152411344301501031722 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED #define BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED #include "boost/type_traits/has_trivial_assign.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { BOOST_TT_AUX_BOOL_TRAIT_DEF1(has_nothrow_assign,T,::boost::has_trivial_assign::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_HAS_NOTHROW_ASSIGN_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/type_traits_test.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/type_trai0000644000175000017500000002651611344301501031745 0ustar debiandebian// (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // common test code for type-traits tests // WARNING: contains code as well as declarations! #ifndef BOOST_TYPE_TRAITS_TEST_HPP #define BOOST_TYPE_TRAITS_TEST_HPP #include "boost/config.hpp" #include "boost/utility.hpp" #include "boost/type_traits/alignment_of.hpp" #include "boost/type_traits/type_with_alignment.hpp" #include "boost/type_traits/ice.hpp" #include #include // // define tests here unsigned failures = 0; unsigned test_count = 0; // // This must get defined within the test file. // All compilers have bugs, set this to the number of // regressions *expected* from a given compiler, // if there are no workarounds for the bugs, *and* // the regressions have been investigated. // extern unsigned int expected_failures; // // proc check_result() // Checks that there were no regressions: // int check_result(int argc, char** argv) { std::cout << test_count << " tests completed, " << failures << " failures found, " << expected_failures << " failures expected from this compiler." << std::endl; if((argc == 2) && (argv[1][0] == '-') && (argv[1][1] == 'a') && (argv[1][2] == 0)) { std::cout << "Press any key to continue..."; std::cin.get(); } return (failures == expected_failures) ? 0 : (failures != 0) ? static_cast(failures) : -1; } // // this one is to verify that a constant is indeed a // constant-integral-expression: // // HP aCC cannot deal with missing names for template value parameters template struct checker { static void check(bool, bool, const char*, bool){ ++test_count; } }; template <> struct checker { static void check(bool o, bool n, const char* name, bool soft) { ++test_count; ++failures; // if this is a soft test, then failure is expected, // or may depend upon factors outside our control // (like compiler options)... if(soft)++expected_failures; std::cout << "checking value of " << name << "...failed" << std::endl; std::cout << "\tfound: " << n << " expected " << o << std::endl; } }; template struct typify{}; template struct type_checker { static void check(const char* TT, const char*, const char* expression) { ++test_count; if(typeid(typify) != typeid(typify)) { ++failures; std::cout << "checking type of " << expression << "...failed" << std::endl; std::cout << " evaluating: type_checker<" << TT << "," << expression << ">" << std::endl; std::cout << " expected: type_checker<" << TT << "," << TT << ">" << std::endl; std::cout << " but got: " << typeid(type_checker).name() << std::endl; } } }; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct type_checker { static void check(const char*, const char*, const char*) { ++test_count; } }; #endif #define value_test(v, x) checker<(v == x)>::check(v, x, #x, false); #define soft_value_test(v, x) checker<(v == x)>::check(v, x, #x, true); #define value_fail(v, x) \ ++test_count; \ ++failures; \ ++expected_failures;\ std::cout << "checking value of " << #x << "...failed" << std::endl; \ std::cout << " " #x " does not compile on this compiler" << std::endl; #define type_test(v, x) type_checker::check(#v, #x, #x); #define type_test3(v, x, z) type_checker::check(#v, #x "," #z, #x "," #z); #ifndef SHORT_TRANSFORM_TEST #define transform_check(name, from_suffix, to_suffix)\ type_test(bool to_suffix, name::type);\ type_test(char to_suffix, name::type);\ type_test(wchar_t to_suffix, name::type);\ type_test(signed char to_suffix, name::type);\ type_test(unsigned char to_suffix, name::type);\ type_test(short to_suffix, name::type);\ type_test(unsigned short to_suffix, name::type);\ type_test(int to_suffix, name::type);\ type_test(unsigned int to_suffix, name::type);\ type_test(long to_suffix, name::type);\ type_test(unsigned long to_suffix, name::type);\ type_test(float to_suffix, name::type);\ type_test(long double to_suffix, name::type);\ type_test(double to_suffix, name::type);\ type_test(UDT to_suffix, name::type);\ type_test(enum1 to_suffix, name::type); #else #define transform_check(name, from_suffix, to_suffix)\ type_test(int to_suffix, name::type);\ type_test(UDT to_suffix, name::type);\ type_test(enum1 to_suffix, name::type); #endif #define boost_dummy_macro_param template struct test_align { struct padded { char c; T t; }; static void do_it() { padded p; unsigned a = reinterpret_cast(&(p.t)) - reinterpret_cast(&p); ++test_count; // only fail if we do not have a multiple of the actual value: if((a > ::boost::alignment_of::value) || (a % ::boost::alignment_of::value)) { ++failures; std::cout << "checking value of " << typeid(boost::alignment_of).name() << "...failed" << std::endl; std::cout << "\tfound: " << boost::alignment_of::value << " expected " << a << std::endl; } // suppress warnings about unused variables: not_unused(p); not_unused(a); } template static void not_unused(U const&) {} }; #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct test_align { static void do_it() { // // we can't do the usual test because we can't take the address // of a reference, so check that the result is the same as for a // pointer type instead: unsigned a = boost::alignment_of::value; ++test_count; if(a != boost::alignment_of::value) { ++failures; std::cout << "checking value of " << typeid(boost::alignment_of).name() << "...failed" << std::endl; std::cout << "\tfound: " << boost::alignment_of::value << " expected " << a << std::endl; } } }; #endif #define align_test(T) test_align::do_it() template struct test_type_with_align { typedef typename boost::type_with_alignment< (boost::alignment_of::value)>::type align_t; static void do_it() { int align = boost::alignment_of::value; int new_align = boost::alignment_of::value; ++test_count; if (new_align % align != 0) { ++failures; std::cerr << "checking for an object with same alignment as " << typeid(T).name() << "...failed" << std::endl; std::cerr << "\tfound: " << typeid(align_t).name() << std::endl; } } }; #define type_with_align_test(T) test_type_with_align::do_it() // // the following code allows us to test that a particular // template functions correctly when instanciated inside another template // (some bugs only show up in that situation). For each template // we declare one NESTED_DECL(classname) that sets up the template class // and multiple NESTED_TEST(classname, template-arg) declarations, to carry // the actual tests: template struct nested_test { typedef nested_test type; bool run_time_value; const char* what; nested_test(bool b2, const char* w) : run_time_value(b2), what(w) { check(); } void check() { ++test_count; if(b != run_time_value) { ++failures; std::cerr << "Mismatch between runtime and compile time values in " << what << std::endl; } } }; #ifndef __SUNPRO_CC #define NESTED_DECL(what)\ template \ struct BOOST_TT_JOIN(nested_tester_,what){\ nested_test< (::boost::type_traits::ice_ne<0, ::boost::what::value>::value)> tester;\ BOOST_TT_JOIN(nested_tester_,what)(const char* s) : tester(::boost::what::value, s){}\ }; #define NESTED_TEST(what, with)\ {BOOST_TT_JOIN(nested_tester_,what) check(#what "<" #with ">"); (void)check;} #else #define NESTED_DECL(what) #define NESTED_TEST(what, with) #endif #define BOOST_TT_JOIN( X, Y ) BOOST_DO_TT_JOIN( X, Y ) #define BOOST_DO_TT_JOIN( X, Y ) X##Y // // define some types to test with: // enum enum_UDT{ one, two, three }; struct UDT { UDT(){}; ~UDT(){}; UDT(const UDT&); UDT& operator=(const UDT&); int i; void f1(); int f2(); int f3(int); int f4(int, float); }; typedef void(*f1)(); typedef int(*f2)(int); typedef int(*f3)(int, bool); typedef void (UDT::*mf1)(); typedef int (UDT::*mf2)(); typedef int (UDT::*mf3)(int); typedef int (UDT::*mf4)(int, float); typedef int (UDT::*mp); typedef int (UDT::*cmf)(int) const; // cv-qualifiers applied to reference types should have no effect // declare these here for later use with is_reference and remove_reference: # ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable: 4181) # elif defined(__ICL) # pragma warning(push) # pragma warning(disable: 21) # endif // // This is intentional: // r_type and cr_type should be the same type // but some compilers wrongly apply cv-qualifiers // to reference types (this may generate a warning // on some compilers): // typedef int& r_type; typedef const r_type cr_type; # ifdef BOOST_MSVC # pragma warning(pop) # elif defined(__ICL) # pragma warning(pop) # pragma warning(disable: 985) // identifier truncated in debug information # endif struct POD_UDT { int x; }; struct empty_UDT { ~empty_UDT(){}; empty_UDT& operator=(const empty_UDT&){ return *this; } bool operator==(const empty_UDT&)const { return true; } }; struct empty_POD_UDT { empty_POD_UDT& operator=(const empty_POD_UDT&){ return *this; } bool operator==(const empty_POD_UDT&)const { return true; } }; union union_UDT { int x; double y; ~union_UDT(); }; union POD_union_UDT { int x; double y; }; union empty_union_UDT { ~empty_union_UDT(); }; union empty_POD_union_UDT{}; class Base { }; class Derived : public Base { }; class NonDerived { }; enum enum1 { one_,two_ }; enum enum2 { three_,four_ }; struct VB { virtual ~VB(){}; }; struct VD : VB { ~VD(){}; }; // // struct non_pointer: // used to verify that is_pointer does not return // true for class types that implement operator void*() // struct non_pointer { operator void*(){return this;} }; struct non_int_pointer { int i; operator int*(){return &i;} }; struct int_constructible { int_constructible(int); }; struct int_convertible { operator int(); }; // // struct non_empty: // used to verify that is_empty does not emit // spurious warnings or errors. // struct non_empty : private boost::noncopyable { int i; }; // // abstract base classes: struct test_abc1 { virtual void foo() = 0; virtual void foo2() = 0; }; struct test_abc2 { virtual void foo() = 0; virtual void foo2() = 0; }; struct incomplete_type; #endif // BOOST_TYPE_TRAITS_TEST_HPP ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_cv.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_cv.hp0000644000175000017500000000270211344301501031562 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ADD_CV_HPP_INCLUDED #define BOOST_TT_ADD_CV_HPP_INCLUDED #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { // * convert a type T to a const volatile type - add_cv // this is not required since the result is always // the same as "T const volatile", but it does suppress warnings // from some compilers: #if defined(BOOST_MSVC) // This bogus warning will appear when add_volatile is applied to a // const volatile reference because we can't detect const volatile // references with MSVC6. # pragma warning(push) # pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored #endif BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_cv,T,T const volatile) #if defined(BOOST_MSVC) # pragma warning(pop) #endif #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_cv,T&,T&) #endif } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_ADD_CV_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/array_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/array_tra0000644000175000017500000000107111344301501031716 0ustar debiandebian// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED #define BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED #include "boost/type_traits/is_array.hpp" #endif // BOOST_TT_ARRAY_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_const.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_co0000644000175000017500000000400011344301501031703 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REMOVE_CONST_HPP_INCLUDED #define BOOST_TT_REMOVE_CONST_HPP_INCLUDED #include "boost/type_traits/is_volatile.hpp" #include "boost/type_traits/broken_compiler_spec.hpp" #include "boost/type_traits/detail/cv_traits_impl.hpp" #include "boost/config.hpp" #include // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace detail { template struct remove_const_helper { typedef T type; }; template struct remove_const_helper { typedef T volatile type; }; template struct remove_const_impl { typedef typename remove_const_helper< typename cv_traits_imp::unqualified_type , ::boost::is_volatile::value >::type type; }; } // namespace detail // * convert a type T to non-const type - remove_const BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename detail::remove_const_impl::type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_const,T&,T&) #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const[N],T type[N]) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_const,T const volatile[N],T volatile type[N]) #endif #else BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_const,T,typename detail::remove_const_impl::type) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_REMOVE_CONST_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_arithmetic.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_arithm0000644000175000017500000000243211344301501031713 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED #define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED #include "boost/type_traits/is_integral.hpp" #include "boost/type_traits/is_float.hpp" #include "boost/type_traits/detail/ice_or.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { template< typename T > struct is_arithmetic_impl { BOOST_STATIC_CONSTANT(bool, value = (::boost::type_traits::ice_or< ::boost::is_integral::value, ::boost::is_float::value >::value)); }; } // namespace detail //* is a type T an arithmetic type described in the standard (3.9.1p8) BOOST_TT_AUX_BOOL_TRAIT_DEF1(is_arithmetic,T,::boost::detail::is_arithmetic_impl::value) } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_cv.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/remove_cv0000644000175000017500000000344111344301501031722 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REMOVE_CV_HPP_INCLUDED #define BOOST_TT_REMOVE_CV_HPP_INCLUDED #include "boost/type_traits/broken_compiler_spec.hpp" #include "boost/type_traits/detail/cv_traits_impl.hpp" #include "boost/config.hpp" #include // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION // convert a type T to a non-cv-qualified type - remove_cv BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename detail::cv_traits_imp::unqualified_type) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,remove_cv,T&,T&) #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const[N],T type[N]) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T volatile[N],T type[N]) BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(typename T,std::size_t N,remove_cv,T const volatile[N],T type[N]) #endif #else namespace detail { template struct remove_cv_impl { typedef typename remove_volatile_impl< typename remove_const_impl::type >::type type; }; } BOOST_TT_AUX_TYPE_TRAIT_DEF1(remove_cv,T,typename detail::remove_cv_impl::type) #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_REMOVE_CV_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/alignment_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/alignment0000644000175000017500000000107511344301501031714 0ustar debiandebian // (C) Copyright John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED #define BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED #include "boost/type_traits/alignment_of.hpp" #include "boost/type_traits/type_with_alignment.hpp" #endif // BOOST_TT_ALIGNMENT_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/intrinsics.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/intrinsic0000644000175000017500000000744611344301501031750 0ustar debiandebian // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_INTRINSICS_HPP_INCLUDED #define BOOST_TT_INTRINSICS_HPP_INCLUDED #ifndef BOOST_TT_CONFIG_HPP_INCLUDED #include "boost/type_traits/config.hpp" #endif // // Helper macros for builtin compiler support. // If your compiler has builtin support for any of the following // traits concepts, then redefine the appropriate macros to pick // up on the compiler support: // // (these should largely ignore cv-qualifiers) // BOOST_IS_UNION(T) should evaluate to true if T is a union type // BOOST_IS_POD(T) should evaluate to true if T is a POD type // BOOST_IS_EMPTY(T) should evaluate to true if T is an empty struct or union // BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) should evaluate to true if "T x;" has no effect // BOOST_HAS_TRIVIAL_COPY(T) should evaluate to true if T(t) <==> memcpy // BOOST_HAS_TRIVIAL_ASSIGN(T) should evaluate to true if t = u <==> memcpy // BOOST_HAS_TRIVIAL_DESTRUCTOR(T) should evaluate to true if ~T() has no effect #ifdef BOOST_HAS_SGI_TYPE_TRAITS // Hook into SGI's __type_traits class, this will pick up user supplied // specializations as well as SGI - compiler supplied specializations. # include "boost/type_traits/is_same.hpp" # include # define BOOST_IS_POD(T) ::boost::is_same< typename ::__type_traits::is_POD_type, ::__true_type>::value # define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_default_constructor, ::__true_type>::value # define BOOST_HAS_TRIVIAL_COPY(T) ::boost::is_same< typename ::__type_traits::has_trivial_copy_constructor, ::__true_type>::value # define BOOST_HAS_TRIVIAL_ASSIGN(T) ::boost::is_same< typename ::__type_traits::has_trivial_assignment_operator, ::__true_type>::value # define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) ::boost::is_same< typename ::__type_traits::has_trivial_destructor, ::__true_type>::value # ifdef __sgi # define BOOST_HAS_TYPE_TRAITS_INTRINSICS # endif #endif #if defined(__MSL_CPP__) && (__MSL_CPP__ >= 0x8000) // Metrowerks compiler is acquiring intrinsic type traits support // post version 8. We hook into the published interface to pick up // user defined specializations as well as compiler intrinsics as // and when they become available: # include # define BOOST_IS_UNION(T) BOOST_STD_EXTENSION_NAMESPACE::is_union::value # define BOOST_IS_POD(T) BOOST_STD_EXTENSION_NAMESPACE::is_POD::value # define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_default_ctor::value # define BOOST_HAS_TRIVIAL_COPY(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_copy_ctor::value # define BOOST_HAS_TRIVIAL_ASSIGN(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_assignment::value # define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) BOOST_STD_EXTENSION_NAMESPACE::has_trivial_dtor::value # define BOOST_HAS_TYPE_TRAITS_INTRINSICS #endif #ifndef BOOST_IS_UNION # define BOOST_IS_UNION(T) false #endif #ifndef BOOST_IS_POD # define BOOST_IS_POD(T) false #endif #ifndef BOOST_IS_EMPTY # define BOOST_IS_EMPTY(T) false #endif #ifndef BOOST_HAS_TRIVIAL_CONSTRUCTOR # define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) false #endif #ifndef BOOST_HAS_TRIVIAL_COPY # define BOOST_HAS_TRIVIAL_COPY(T) false #endif #ifndef BOOST_HAS_TRIVIAL_ASSIGN # define BOOST_HAS_TRIVIAL_ASSIGN(T) false #endif #ifndef BOOST_HAS_TRIVIAL_DESTRUCTOR # define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) false #endif #endif // BOOST_TT_INTRINSICS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_const.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/add_const0000644000175000017500000000266111344301501031676 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_ADD_CONST_HPP_INCLUDED #define BOOST_TT_ADD_CONST_HPP_INCLUDED #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/type_trait_def.hpp" namespace boost { // * convert a type T to const type - add_const // this is not required since the result is always // the same as "T const", but it does suppress warnings // from some compilers: #if defined(BOOST_MSVC) // This bogus warning will appear when add_const is applied to a // const volatile reference because we can't detect const volatile // references with MSVC6. # pragma warning(push) # pragma warning(disable:4181) // warning C4181: qualifier applied to reference type ignored #endif BOOST_TT_AUX_TYPE_TRAIT_DEF1(add_const,T,T const) #if defined(BOOST_MSVC) # pragma warning(pop) #endif #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(typename T,add_const,T&,T&) #endif } // namespace boost #include "boost/type_traits/detail/type_trait_undef.hpp" #endif // BOOST_TT_ADD_CONST_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/0000755000175000017500000000000012146213774031271 5ustar debiandebian././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is_function_type_tester.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is0000644000175000017500000001621411344301501031614 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_TT_DETAIL_IS_FUNCTION_TYPE_TESTER_HPP_INCLUDED #define BOOST_TT_DETAIL_IS_FUNCTION_TYPE_TESTER_HPP_INCLUDED #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/config.hpp" #if defined(BOOST_TT_PREPROCESSING_MODE) # include "boost/preprocessor/iterate.hpp" # include "boost/preprocessor/enum_params.hpp" # include "boost/preprocessor/comma_if.hpp" #endif namespace boost { namespace type_traits { no_type BOOST_TT_DECL is_function_type_tester(...); #if !defined(BOOST_TT_PREPROCESSING_MODE) // preprocessor-generated part, don't edit by hand! template yes_type is_function_type_tester(R f()); template yes_type is_function_type_tester(R f(T0)); template yes_type is_function_type_tester(R f(T0,T1)); template yes_type is_function_type_tester(R f(T0,T1,T2)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)); template yes_type is_function_type_tester(R f(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)); #else #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 25, "boost/type_traits/detail/is_function_type_tester.hpp")) #include BOOST_PP_ITERATE() #endif // BOOST_TT_PREPROCESSING_MODE } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_IS_FUNCTION_TYPE_TESTER_HPP_INCLUDED ///// iteration #else #define i BOOST_PP_FRAME_ITERATION(1) template yes_type is_function_type_tester(R f(BOOST_PP_ENUM_PARAMS(i,T))); #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/type_trait_def.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ty0000644000175000017500000000306411344301501031634 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/type_trait_def.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \ template< typename T > struct trait \ { \ typedef result type; \ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ }; \ \ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ /**/ #define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \ template<> struct trait \ { \ typedef result type; \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ }; \ /**/ #define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \ template<> struct trait##_impl \ { \ typedef result type; \ }; \ /**/ #define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \ template< param > struct trait \ { \ typedef result type; \ }; \ /**/ #define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \ template< param1, param2 > struct trait \ { \ typedef result; \ }; \ /**/ #define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \ template< param > struct trait##_impl \ { \ typedef result type; \ }; \ /**/ ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/wr0000644000175000017500000000107711344301501031632 0ustar debiandebian// (C) Copyright David Abrahams 2002. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_WRAP_HPP_INCLUDED #define BOOST_TT_DETAIL_WRAP_HPP_INCLUDED namespace boost { namespace type_traits { template struct wrap {}; }} // namespace boost::type_traits #endif // BOOST_TT_DETAIL_WRAP_HPP_INCLUDED ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is_function_ptr_tester.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is0000644000175000017500000001627311344301501031621 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED #define BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/config.hpp" #if defined(BOOST_TT_PREPROCESSING_MODE) # include "boost/preprocessor/iterate.hpp" # include "boost/preprocessor/enum_params.hpp" # include "boost/preprocessor/comma_if.hpp" #endif namespace boost { namespace type_traits { no_type BOOST_TT_DECL is_function_ptr_tester(...); #if !defined(BOOST_TT_PREPROCESSING_MODE) // preprocessor-generated part, don't edit by hand! template yes_type is_function_ptr_tester(R (*)()); template yes_type is_function_ptr_tester(R (*)(T0)); template yes_type is_function_ptr_tester(R (*)(T0,T1)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)); template yes_type is_function_ptr_tester(R (*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)); #else #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 25, "boost/type_traits/detail/is_function_ptr_tester.hpp")) #include BOOST_PP_ITERATE() #endif // BOOST_TT_PREPROCESSING_MODE } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_IS_FUNCTION_PTR_TESTER_HPP_INCLUDED ///// iteration #else #define i BOOST_PP_FRAME_ITERATION(1) template yes_type is_function_ptr_tester(R (*)(BOOST_PP_ENUM_PARAMS(i,T))); #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/bool_trait_undef.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/bo0000644000175000017500000000176611344301501031607 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/bool_trait_undef.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #undef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL #undef BOOST_TT_AUX_BOOL_C_BASE #undef BOOST_TT_AUX_BOOL_TRAIT_DEF1 #undef BOOST_TT_AUX_BOOL_TRAIT_DEF2 #undef BOOST_TT_AUX_BOOL_TRAIT_SPEC1 #undef BOOST_TT_AUX_BOOL_TRAIT_SPEC2 #undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1 #undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2 #undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1 #undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2 #undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1 #undef BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2 #undef BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1 #undef BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1 ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ice_not.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ic0000644000175000017500000000141111344301501031565 0ustar debiandebian// (C) Copyright John Maddock and Steve Cleary 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED #define BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED #include "boost/config.hpp" namespace boost { namespace type_traits { template struct ice_not { BOOST_STATIC_CONSTANT(bool, value = true); }; template <> struct ice_not { BOOST_STATIC_CONSTANT(bool, value = false); }; } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_ICE_NOT_HPP_INCLUDED ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is0000644000175000017500000011635211344301501031620 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED #define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED #include "boost/config.hpp" #if defined(BOOST_TT_PREPROCESSING_MODE) # include "boost/preprocessor/iterate.hpp" # include "boost/preprocessor/enum_params.hpp" # include "boost/preprocessor/comma_if.hpp" #endif namespace boost { namespace type_traits { template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = false); }; #if !defined(BOOST_TT_PREPROCESSING_MODE) // preprocessor-generated part, don't edit by hand! template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif #else #undef BOOST_STATIC_CONSTANT #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 25, "boost/type_traits/detail/is_mem_fun_pointer_impl.hpp")) #include BOOST_PP_ITERATE() #endif // BOOST_TT_PREPROCESSING_MODE } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_IMPL_HPP_INCLUDED ///// iteration #else #define i BOOST_PP_FRAME_ITERATION(1) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; // Metrowerks and Visual Age think this creates ambiguities /// #if !((defined(__MWERKS__) && __MWERKS__ < 0x3000) || (defined(__IBMCPP__) && __IBMCPP__ <= 600)) template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; template struct is_mem_fun_pointer_impl { BOOST_STATIC_CONSTANT(bool, value = true); }; /// #endif #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/bool_trait_def.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/bo0000644000175000017500000001243311344301501031600 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/bool_trait_def.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if defined(__SUNPRO_CC) # define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::bool_< C > type; \ enum { value = type::value }; \ /**/ # define BOOST_TT_AUX_BOOL_C_BASE(C) #elif defined(BOOST_MSVC) && BOOST_MSVC <= 1200 # define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::bool_< C > base_; \ using base_::value; \ /**/ #endif #ifndef BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL # define BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) /**/ #endif #ifndef BOOST_TT_AUX_BOOL_C_BASE # define BOOST_TT_AUX_BOOL_C_BASE(C) : BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::bool_< C > #endif #define BOOST_TT_AUX_BOOL_TRAIT_DEF1(trait,T,C) \ template< typename T > struct trait \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ }; \ \ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_DEF2(trait,T1,T2,C) \ template< typename T1, typename T2 > struct trait \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \ }; \ \ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,C) \ template<> struct trait< sp > \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_SPEC2(trait,sp1,sp2,C) \ template<> struct trait< sp1,sp2 > \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \ template<> struct trait##_impl< sp > \ { \ BOOST_STATIC_CONSTANT(bool, value = (C)); \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \ template<> struct trait##_impl< sp1,sp2 > \ { \ BOOST_STATIC_CONSTANT(bool, value = (C)); \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_1(param,trait,sp,C) \ template< param > struct trait< sp > \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,sp,C) \ template< param1, param2 > struct trait< sp > \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \ template< param > struct trait< sp1,sp2 > \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(param1,param2,trait,sp1,sp2,C) \ template< param1, param2 > struct trait< sp1,sp2 > \ BOOST_TT_AUX_BOOL_C_BASE(C) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \ }; \ /**/ #define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \ template< param > struct trait##_impl< sp1,sp2 > \ { \ BOOST_STATIC_CONSTANT(bool, value = (C)); \ }; \ /**/ #ifndef BOOST_NO_CV_SPECIALIZATIONS # define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \ BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \ BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const,value) \ BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp volatile,value) \ BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp const volatile,value) \ /**/ #else # define BOOST_TT_AUX_BOOL_TRAIT_CV_SPEC1(trait,sp,value) \ BOOST_TT_AUX_BOOL_TRAIT_SPEC1(trait,sp,value) \ /**/ #endif #if 0 // there are true_type and false_type already in boost:: // This also induces dependencies which may be undesirable // Let's wait until sometime not just before a release and clean // the whole ct_if mess up. # ifndef BOOST_TT_INTEGRAL_CONSTANT # define BOOST_TT_INTEGRAL_CONSTANT # include // // this is not a TR1 conforming integral_constant, // but it is a first start: // namespace boost{ template struct integral_constant : public BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::integral_c {}; template<> struct integral_constant< bool, true > \ BOOST_TT_AUX_BOOL_C_BASE(true) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,integral_constant,(bool)) \ }; template<> struct integral_constant< bool, false > \ BOOST_TT_AUX_BOOL_C_BASE(false) \ { \ BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(false) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,integral_constant,(bool)) \ }; namespace pending { typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::true_ true_type; typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::false_ false_type; } } # endif #endif ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is_function_ptr_helper.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is0000644000175000017500000002054311344301501031614 0ustar debiandebian // Copyright 2000 John Maddock (john@johnmaddock.co.uk) // Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) // // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED #define BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED #include "boost/type_traits/config.hpp" #if defined(BOOST_TT_PREPROCESSING_MODE) # include "boost/preprocessor/iterate.hpp" # include "boost/preprocessor/enum_params.hpp" # include "boost/preprocessor/comma_if.hpp" #endif namespace boost { namespace type_traits { template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = false); }; #if !defined(BOOST_TT_PREPROCESSING_MODE) // preprocessor-generated part, don't edit by hand! template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool,value = true); }; #else #undef BOOST_STATIC_CONSTANT #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 25, "boost/type_traits/detail/is_function_ptr_helper.hpp")) #include BOOST_PP_ITERATE() #endif // BOOST_TT_PREPROCESSING_MODE } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_IS_FUNCTION_PTR_HELPER_HPP_INCLUDED ///// iteration #else #define i BOOST_PP_FRAME_ITERATION(1) template struct is_function_ptr_helper { BOOST_STATIC_CONSTANT(bool, value = true); }; #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/size_t_trait_def.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/si0000644000175000017500000000271111344301501031611 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/size_t_trait_def.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 # define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/ #else # define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ typedef mpl::size_t< C > base_; \ using base_::value; \ /**/ #endif #define BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(trait,T,C) \ template< typename T > struct trait \ : mpl::size_t< C > \ { \ BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \ }; \ \ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \ /**/ #define BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1(trait,spec,C) \ template<> struct trait \ : mpl::size_t< C > \ { \ BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \ }; \ /**/ #define BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,C) \ template< param > struct trait \ : mpl::size_t< C > \ { \ }; \ /**/ ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/type_trait_undef.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ty0000644000175000017500000000126311344301501031633 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/type_trait_undef.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #undef BOOST_TT_AUX_TYPE_TRAIT_DEF1 #undef BOOST_TT_AUX_TYPE_TRAIT_SPEC1 #undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1 #undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1 #undef BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2 #undef BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1 ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ice_eq.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ic0000644000175000017500000000171411344301501031573 0ustar debiandebian// (C) Copyright John Maddock and Steve Cleary 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED #define BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED #include "boost/config.hpp" namespace boost { namespace type_traits { template struct ice_eq { BOOST_STATIC_CONSTANT(bool, value = (b1 == b2)); }; template struct ice_ne { BOOST_STATIC_CONSTANT(bool, value = (b1 != b2)); }; #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION template bool const ice_eq::value; template bool const ice_ne::value; #endif } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_ICE_EQ_HPP_INCLUDED ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/template_arity_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/te0000644000175000017500000000165211344301501031611 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #include #include #include #include #include #if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ && defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) # define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) \ namespace mpl { namespace aux { \ template< BOOST_MPL_PP_PARAMS(i, typename T) > \ struct template_arity< \ name< BOOST_MPL_PP_PARAMS(i, T) > \ > \ : int_ \ { \ }; \ }} \ /**/ #else # define BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/ #endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/yes_no_type.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ye0000644000175000017500000000132611344301501031614 0ustar debiandebian // (C) Copyright John Maddock and Steve Cleary 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // macros and helpers for working with integral-constant-expressions. #ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED #define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED namespace boost { namespace type_traits { typedef char yes_type; struct no_type { char padding[8]; }; } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ice_or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ic0000644000175000017500000000174711344301501031601 0ustar debiandebian// (C) Copyright John Maddock and Steve Cleary 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED #define BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED #include "boost/config.hpp" namespace boost { namespace type_traits { template struct ice_or; template struct ice_or { BOOST_STATIC_CONSTANT(bool, value = true); }; template <> struct ice_or { BOOST_STATIC_CONSTANT(bool, value = false); }; } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_ICE_OR_HPP_INCLUDED ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is_mem_fun_pointer_tester.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/is0000644000175000017500000006524111344301501031620 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, // Aleksey Gurtovoy, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED #define BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED #include "boost/type_traits/detail/yes_no_type.hpp" #include "boost/type_traits/config.hpp" #if defined(BOOST_TT_PREPROCESSING_MODE) # include "boost/preprocessor/iterate.hpp" # include "boost/preprocessor/enum_params.hpp" # include "boost/preprocessor/comma_if.hpp" #endif namespace boost { namespace type_traits { no_type BOOST_TT_DECL is_mem_fun_pointer_tester(...); #if !defined(BOOST_TT_PREPROCESSING_MODE) // preprocessor-generated part, don't edit by hand! template yes_type is_mem_fun_pointer_tester(R (T::*)()); template yes_type is_mem_fun_pointer_tester(R (T::*)() const); template yes_type is_mem_fun_pointer_tester(R (T::*)() volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)() const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23) const volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24)); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,T23,T24) const volatile); #else #define BOOST_PP_ITERATION_PARAMS_1 \ (3, (0, 25, "boost/type_traits/detail/is_mem_fun_pointer_tester.hpp")) #include BOOST_PP_ITERATE() #endif // BOOST_TT_PREPROCESSING_MODE } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_IS_MEM_FUN_POINTER_TESTER_HPP_INCLUDED ///// iteration #else #define i BOOST_PP_FRAME_ITERATION(1) template yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(i,T))); template yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) const); template yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) volatile); template yes_type is_mem_fun_pointer_tester(R (T::*)(BOOST_PP_ENUM_PARAMS(i,T)) const volatile); #undef i #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/cv_traits_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/cv0000644000175000017500000000313511344301501031607 0ustar debiandebian // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED #define BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED #include "boost/config.hpp" #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION namespace boost { namespace detail { // implementation helper: template struct cv_traits_imp {}; template struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = false); BOOST_STATIC_CONSTANT(bool, is_volatile = false); typedef T unqualified_type; }; template struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = true); BOOST_STATIC_CONSTANT(bool, is_volatile = false); typedef T unqualified_type; }; template struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = false); BOOST_STATIC_CONSTANT(bool, is_volatile = true); typedef T unqualified_type; }; template struct cv_traits_imp { BOOST_STATIC_CONSTANT(bool, is_const = true); BOOST_STATIC_CONSTANT(bool, is_volatile = true); typedef T unqualified_type; }; } // namespace detail } // namespace boost #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_TT_DETAIL_CV_TRAITS_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/false_result.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/fa0000644000175000017500000000137711344301501031573 0ustar debiandebian// Copyright David Abrahams 2002. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED #define BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED #include "boost/config.hpp" namespace boost { namespace type_traits { // Utility class which always "returns" false struct false_result { template struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; }} // namespace boost::type_traits #endif // BOOST_TT_DETAIL_FALSE_RESULT_HPP_INCLUDED ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/size_t_trait_undef.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/si0000644000175000017500000000105611344301501031612 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/size_t_trait_undef.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #undef BOOST_TT_AUX_SIZE_T_TRAIT_DEF1 #undef BOOST_TT_AUX_SIZE_T_TRAIT_SPEC1 #undef BOOST_TT_AUX_SIZE_T_TRAIT_PARTIAL_SPEC1_1 ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ice_and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/detail/ic0000644000175000017500000000174411344301501031576 0ustar debiandebian// (C) Copyright John Maddock and Steve Cleary 2000. // // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED #define BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED #include "boost/config.hpp" namespace boost { namespace type_traits { template struct ice_and; template struct ice_and { BOOST_STATIC_CONSTANT(bool, value = false); }; template <> struct ice_and { BOOST_STATIC_CONSTANT(bool, value = true); }; } // namespace type_traits } // namespace boost #endif // BOOST_TT_DETAIL_ICE_AND_HPP_INCLUDED ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/arithmetic_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/arithmeti0000644000175000017500000000153611344301501031726 0ustar debiandebian// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. // // defines traits classes for arithmetic types: // is_void, is_integral, is_float, is_arithmetic, is_fundamental. #ifndef BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED #define BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED #include "boost/type_traits/is_arithmetic.hpp" #include "boost/type_traits/is_float.hpp" #include "boost/type_traits/is_fundamental.hpp" #include "boost/type_traits/is_integral.hpp" #include "boost/type_traits/is_void.hpp" #endif // BOOST_TT_ARITHMETIC_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_base_and_derived.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/is_base_a0000644000175000017500000001502711344301501031645 0ustar debiandebian // (C) Copyright Rani Sharoni 2003. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED #define BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED #include "boost/type_traits/is_class.hpp" #include "boost/type_traits/is_same.hpp" #include "boost/type_traits/is_convertible.hpp" #include "boost/type_traits/detail/ice_and.hpp" #include "boost/type_traits/remove_cv.hpp" #include "boost/config.hpp" // should be the last #include #include "boost/type_traits/detail/bool_trait_def.hpp" namespace boost { namespace detail { #if !BOOST_WORKAROUND(__BORLANDC__, <= 0x570) \ && !BOOST_WORKAROUND(__SUNPRO_CC , BOOST_TESTED_AT(0x540)) \ && !BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \ && !BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) // The EDG version number is a lower estimate. // It is not currently known which EDG version // exactly fixes the problem. /************************************************************************* This version detects ambiguous base classes and private base classes correctly, and was devised by Rani Sharoni. Explanation by Terje Slettebø and Rani Sharoni. Let's take the multiple base class below as an example, and the following will also show why there's not a problem with private or ambiguous base class: struct B {}; struct B1 : B {}; struct B2 : B {}; struct D : private B1, private B2 {}; is_base_and_derived::value; First, some terminology: SC - Standard conversion UDC - User-defined conversion A user-defined conversion sequence consists of an SC, followed by an UDC, followed by another SC. Either SC may be the identity conversion. When passing the default-constructed Host object to the overloaded check_sig() functions (initialization 8.5/14/4/3), we have several viable implicit conversion sequences: For "static no_type check_sig(B const volatile *, int)" we have the conversion sequences: C -> C const (SC - Qualification Adjustment) -> B const volatile* (UDC) C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> B const volatile* (SC - Conversion) For "static yes_type check_sig(D const volatile *, T)" we have the conversion sequence: C -> D const volatile* (UDC) According to 13.3.3.1/4, in context of user-defined conversion only the standard conversion sequence is considered when selecting the best viable function, so it only considers up to the user-defined conversion. For the first function this means choosing between C -> C const and C -> C, and it chooses the latter, because it's a proper subset (13.3.3.2/3/2) of the former. Therefore, we have: C -> D const volatile* (UDC) -> B1 const volatile* / B2 const volatile* -> B const volatile* (SC - Conversion) C -> D const volatile* (UDC) Here, the principle of the "shortest subsequence" applies again, and it chooses C -> D const volatile*. This shows that it doesn't even need to consider the multiple paths to B, or accessibility, as that possibility is eliminated before it could possibly cause ambiguity or access violation. If D is not derived from B, it has to choose between C -> C const -> B const volatile* for the first function, and C -> D const volatile* for the second function, which are just as good (both requires a UDC, 13.3.3.2), had it not been for the fact that "static no_type check_sig(B const volatile *, int)" is not templated, which makes C -> C const -> B const volatile* the best choice (13.3.3/1/4), resulting in "no". Also, if Host::operator B const volatile* hadn't been const, the two conversion sequences for "static no_type check_sig(B const volatile *, int)", in the case where D is derived from B, would have been ambiguous. See also http://groups.google.com/groups?selm=df893da6.0301280859.522081f7%40posting. google.com and links therein. *************************************************************************/ template struct bd_helper { template static type_traits::yes_type check_sig(D const volatile *, T); static type_traits::no_type check_sig(B const volatile *, int); }; template struct is_base_and_derived_impl2 { struct Host { operator B const volatile *() const; operator D const volatile *(); }; BOOST_STATIC_CONSTANT(bool, value = sizeof(bd_helper::check_sig(Host(), 0)) == sizeof(type_traits::yes_type)); }; #else // // broken version: // template struct is_base_and_derived_impl2 { BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible::value)); }; #define BOOST_BROKEN_IS_BASE_AND_DERIVED #endif template struct is_base_and_derived_impl3 { BOOST_STATIC_CONSTANT(bool, value = false); }; template struct is_base_and_derived_select { template struct rebind { typedef is_base_and_derived_impl3 type; }; }; template <> struct is_base_and_derived_select { template struct rebind { typedef is_base_and_derived_impl2 type; }; }; template struct is_base_and_derived_impl { typedef typename remove_cv::type ncvB; typedef typename remove_cv::type ncvD; typedef is_base_and_derived_select< ::boost::is_class::value, ::boost::is_class::value, ::boost::is_same::value> selector; typedef typename selector::template rebind binder; typedef typename binder::type bound_type; BOOST_STATIC_CONSTANT(bool, value = bound_type::value); }; } // namespace detail BOOST_TT_AUX_BOOL_TRAIT_DEF2( is_base_and_derived , Base , Derived , (::boost::detail::is_base_and_derived_impl::value) ) #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base,Derived&,false) BOOST_TT_AUX_BOOL_TRAIT_PARTIAL_SPEC2_2(typename Base,typename Derived,is_base_and_derived,Base&,Derived&,false) #endif } // namespace boost #include "boost/type_traits/detail/bool_trait_undef.hpp" #endif // BOOST_TT_IS_BASE_AND_DERIVED_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/reference_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/reference0000644000175000017500000000111611344301501031670 0ustar debiandebian// (C) Copyright David Abrahams Steve Cleary, Beman Dawes, Howard // Hinnant & John Maddock 2000-2002. // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_REFERENCE_TRAITS_HPP_INCLUDED #define BOOST_TT_REFERENCE_TRAITS_HPP_INCLUDED #include "boost/type_traits/is_reference.hpp" #endif // BOOST_TT_REFERENCE_TRAITS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/conversion_traits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/type_traits/conversio0000644000175000017500000000122211344301501031737 0ustar debiandebian // Copyright 2000 John Maddock (john@johnmaddock.co.uk) // Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) // Copyright 1999, 2000 Jaakko J„rvi (jaakko.jarvi@cs.utu.fi) // // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED #define BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED #include "boost/type_traits/is_convertible.hpp" #endif // BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/0000755000175000017500000000000012146213772030204 5ustar debiandebian././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_shifted.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_shi0000644000175000017500000000137311344301502031726 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ENUM_SHIFTED_HPP # define BOOST_PREPROCESSOR_ENUM_SHIFTED_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/0000755000175000017500000000000012146213763031272 5ustar debiandebian././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/assert.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/as0000644000175000017500000000253611344301502031612 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DEBUG_ASSERT_HPP # define BOOST_PREPROCESSOR_DEBUG_ASSERT_HPP # # include # include # include # include # include # # /* BOOST_PP_ASSERT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ASSERT BOOST_PP_ASSERT_D # else # define BOOST_PP_ASSERT(cond) BOOST_PP_ASSERT_D(cond) # endif # # define BOOST_PP_ASSERT_D(cond) BOOST_PP_IIF(BOOST_PP_NOT(cond), BOOST_PP_ASSERT_ERROR, BOOST_PP_TUPLE_EAT_1)(...) # define BOOST_PP_ASSERT_ERROR(x, y, z) # # /* BOOST_PP_ASSERT_MSG */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ASSERT_MSG BOOST_PP_ASSERT_MSG_D # else # define BOOST_PP_ASSERT_MSG(cond, msg) BOOST_PP_ASSERT_MSG_D(cond, msg) # endif # # define BOOST_PP_ASSERT_MSG_D(cond, msg) BOOST_PP_EXPR_IIF(BOOST_PP_NOT(cond), msg) # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/line.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/li0000644000175000017500000000322611344301502031610 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DEBUG_LINE_HPP # define BOOST_PREPROCESSOR_DEBUG_LINE_HPP # # include # include # include # include # # /* BOOST_PP_LINE */ # # if BOOST_PP_CONFIG_EXTENDED_LINE_INFO # define BOOST_PP_LINE(line, file) line BOOST_PP_CAT(BOOST_PP_LINE_, BOOST_PP_IS_ITERATING)(file) # define BOOST_PP_LINE_BOOST_PP_IS_ITERATING(file) #file # define BOOST_PP_LINE_1(file) BOOST_PP_STRINGIZE(file BOOST_PP_CAT(BOOST_PP_LINE_I_, BOOST_PP_ITERATION_DEPTH())()) # define BOOST_PP_LINE_I_1() [BOOST_PP_FRAME_ITERATION(1)] # define BOOST_PP_LINE_I_2() BOOST_PP_LINE_I_1()[BOOST_PP_FRAME_ITERATION(2)] # define BOOST_PP_LINE_I_3() BOOST_PP_LINE_I_2()[BOOST_PP_FRAME_ITERATION(3)] # define BOOST_PP_LINE_I_4() BOOST_PP_LINE_I_3()[BOOST_PP_FRAME_ITERATION(4)] # define BOOST_PP_LINE_I_5() BOOST_PP_LINE_I_4()[BOOST_PP_FRAME_ITERATION(5)] # else # define BOOST_PP_LINE(line, file) line __FILE__ # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/error.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug/er0000644000175000017500000000304611344301502031612 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DEBUG_ERROR_HPP # define BOOST_PREPROCESSOR_DEBUG_ERROR_HPP # # include # include # # /* BOOST_PP_ERROR */ # # if BOOST_PP_CONFIG_ERRORS # define BOOST_PP_ERROR(code) BOOST_PP_CAT(BOOST_PP_ERROR_, code) # endif # # define BOOST_PP_ERROR_0x0000 BOOST_PP_ERROR(0x0000, BOOST_PP_INDEX_OUT_OF_BOUNDS) # define BOOST_PP_ERROR_0x0001 BOOST_PP_ERROR(0x0001, BOOST_PP_WHILE_OVERFLOW) # define BOOST_PP_ERROR_0x0002 BOOST_PP_ERROR(0x0002, BOOST_PP_FOR_OVERFLOW) # define BOOST_PP_ERROR_0x0003 BOOST_PP_ERROR(0x0003, BOOST_PP_REPEAT_OVERFLOW) # define BOOST_PP_ERROR_0x0004 BOOST_PP_ERROR(0x0004, BOOST_PP_LIST_FOLD_OVERFLOW) # define BOOST_PP_ERROR_0x0005 BOOST_PP_ERROR(0x0005, BOOST_PP_SEQ_FOLD_OVERFLOW) # define BOOST_PP_ERROR_0x0006 BOOST_PP_ERROR(0x0006, BOOST_PP_ARITHMETIC_OVERFLOW) # define BOOST_PP_ERROR_0x0007 BOOST_PP_ERROR(0x0007, BOOST_PP_DIVISION_BY_ZERO) # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/max.hpp0000644000175000017500000000133711344301502031472 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_MAX_HPP # define BOOST_PREPROCESSOR_MAX_HPP # # include # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/stringize.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/stringiz0000644000175000017500000000151311344301502031764 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_STRINGIZE_HPP # define BOOST_PREPROCESSOR_STRINGIZE_HPP # # include # # /* BOOST_PP_STRINGIZE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_I(text) # else # define BOOST_PP_STRINGIZE(text) BOOST_PP_STRINGIZE_OO((text)) # define BOOST_PP_STRINGIZE_OO(par) BOOST_PP_STRINGIZE_I ## par # endif # # define BOOST_PP_STRINGIZE_I(text) #text # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iterate.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iterate.0000644000175000017500000000135311344301502031630 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ITERATE_HPP # define BOOST_PREPROCESSOR_ITERATE_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000312311344301502031737 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_HPP # define BOOST_PREPROCESSOR_REPETITION_HPP # # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_from_to_3rd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_f0000644000175000017500000000141111344301502031675 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPEAT_FROM_TO_3RD_HPP # define BOOST_PREPROCESSOR_REPEAT_FROM_TO_3RD_HPP # # include # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuation.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuat0000644000175000017500000000163011344301502031756 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_PUNCTUATION_HPP # define BOOST_PREPROCESSOR_PUNCTUATION_HPP # # include # include # include # include # # endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_shifted_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_shi0000644000175000017500000000142011344301502031717 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP # define BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP # # include # # endif ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_params_with_defaults.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_par0000644000175000017500000000144211344301502031722 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_DEFAULTS_HPP # define BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_DEFAULTS_HPP # # include # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000755000175000017500000000000012146213762031741 5ustar debiandebian././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/mod.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000237211344301502031734 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_MOD_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_MOD_HPP # # include # include # include # # /* BOOST_PP_MOD */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MOD(x, y) BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_DIV_BASE(x, y)) # else # define BOOST_PP_MOD(x, y) BOOST_PP_MOD_I(x, y) # define BOOST_PP_MOD_I(x, y) BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_DIV_BASE(x, y)) # endif # # /* BOOST_PP_MOD_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MOD_D(d, x, y) BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_DIV_BASE_D(d, x, y)) # else # define BOOST_PP_MOD_D(d, x, y) BOOST_PP_MOD_D_I(d, x, y) # define BOOST_PP_MOD_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(3, 1, BOOST_PP_DIV_BASE_D(d, x, y)) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/sub.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000342011344301502031727 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_SUB_HPP # # include # include # include # include # # /* BOOST_PP_SUB */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SUB(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) # else # define BOOST_PP_SUB(x, y) BOOST_PP_SUB_I(x, y) # define BOOST_PP_SUB_I(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) # endif # # define BOOST_PP_SUB_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I xy # else # define BOOST_PP_SUB_O(d, xy) BOOST_PP_SUB_O_I(BOOST_PP_TUPLE_ELEM(2, 0, xy), BOOST_PP_TUPLE_ELEM(2, 1, xy)) # endif # # define BOOST_PP_SUB_O_I(x, y) (BOOST_PP_DEC(x), BOOST_PP_DEC(y)) # # /* BOOST_PP_SUB_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SUB_D(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) # else # define BOOST_PP_SUB_D(d, x, y) BOOST_PP_SUB_D_I(d, x, y) # define BOOST_PP_SUB_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_SUB_P, BOOST_PP_SUB_O, (x, y))) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/dec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000002014511344301502031732 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_DEC_HPP # # include # # /* BOOST_PP_DEC */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_DEC(x) BOOST_PP_DEC_I(x) # else # define BOOST_PP_DEC(x) BOOST_PP_DEC_OO((x)) # define BOOST_PP_DEC_OO(par) BOOST_PP_DEC_I ## par # endif # # define BOOST_PP_DEC_I(x) BOOST_PP_DEC_ ## x # # define BOOST_PP_DEC_0 0 # define BOOST_PP_DEC_1 0 # define BOOST_PP_DEC_2 1 # define BOOST_PP_DEC_3 2 # define BOOST_PP_DEC_4 3 # define BOOST_PP_DEC_5 4 # define BOOST_PP_DEC_6 5 # define BOOST_PP_DEC_7 6 # define BOOST_PP_DEC_8 7 # define BOOST_PP_DEC_9 8 # define BOOST_PP_DEC_10 9 # define BOOST_PP_DEC_11 10 # define BOOST_PP_DEC_12 11 # define BOOST_PP_DEC_13 12 # define BOOST_PP_DEC_14 13 # define BOOST_PP_DEC_15 14 # define BOOST_PP_DEC_16 15 # define BOOST_PP_DEC_17 16 # define BOOST_PP_DEC_18 17 # define BOOST_PP_DEC_19 18 # define BOOST_PP_DEC_20 19 # define BOOST_PP_DEC_21 20 # define BOOST_PP_DEC_22 21 # define BOOST_PP_DEC_23 22 # define BOOST_PP_DEC_24 23 # define BOOST_PP_DEC_25 24 # define BOOST_PP_DEC_26 25 # define BOOST_PP_DEC_27 26 # define BOOST_PP_DEC_28 27 # define BOOST_PP_DEC_29 28 # define BOOST_PP_DEC_30 29 # define BOOST_PP_DEC_31 30 # define BOOST_PP_DEC_32 31 # define BOOST_PP_DEC_33 32 # define BOOST_PP_DEC_34 33 # define BOOST_PP_DEC_35 34 # define BOOST_PP_DEC_36 35 # define BOOST_PP_DEC_37 36 # define BOOST_PP_DEC_38 37 # define BOOST_PP_DEC_39 38 # define BOOST_PP_DEC_40 39 # define BOOST_PP_DEC_41 40 # define BOOST_PP_DEC_42 41 # define BOOST_PP_DEC_43 42 # define BOOST_PP_DEC_44 43 # define BOOST_PP_DEC_45 44 # define BOOST_PP_DEC_46 45 # define BOOST_PP_DEC_47 46 # define BOOST_PP_DEC_48 47 # define BOOST_PP_DEC_49 48 # define BOOST_PP_DEC_50 49 # define BOOST_PP_DEC_51 50 # define BOOST_PP_DEC_52 51 # define BOOST_PP_DEC_53 52 # define BOOST_PP_DEC_54 53 # define BOOST_PP_DEC_55 54 # define BOOST_PP_DEC_56 55 # define BOOST_PP_DEC_57 56 # define BOOST_PP_DEC_58 57 # define BOOST_PP_DEC_59 58 # define BOOST_PP_DEC_60 59 # define BOOST_PP_DEC_61 60 # define BOOST_PP_DEC_62 61 # define BOOST_PP_DEC_63 62 # define BOOST_PP_DEC_64 63 # define BOOST_PP_DEC_65 64 # define BOOST_PP_DEC_66 65 # define BOOST_PP_DEC_67 66 # define BOOST_PP_DEC_68 67 # define BOOST_PP_DEC_69 68 # define BOOST_PP_DEC_70 69 # define BOOST_PP_DEC_71 70 # define BOOST_PP_DEC_72 71 # define BOOST_PP_DEC_73 72 # define BOOST_PP_DEC_74 73 # define BOOST_PP_DEC_75 74 # define BOOST_PP_DEC_76 75 # define BOOST_PP_DEC_77 76 # define BOOST_PP_DEC_78 77 # define BOOST_PP_DEC_79 78 # define BOOST_PP_DEC_80 79 # define BOOST_PP_DEC_81 80 # define BOOST_PP_DEC_82 81 # define BOOST_PP_DEC_83 82 # define BOOST_PP_DEC_84 83 # define BOOST_PP_DEC_85 84 # define BOOST_PP_DEC_86 85 # define BOOST_PP_DEC_87 86 # define BOOST_PP_DEC_88 87 # define BOOST_PP_DEC_89 88 # define BOOST_PP_DEC_90 89 # define BOOST_PP_DEC_91 90 # define BOOST_PP_DEC_92 91 # define BOOST_PP_DEC_93 92 # define BOOST_PP_DEC_94 93 # define BOOST_PP_DEC_95 94 # define BOOST_PP_DEC_96 95 # define BOOST_PP_DEC_97 96 # define BOOST_PP_DEC_98 97 # define BOOST_PP_DEC_99 98 # define BOOST_PP_DEC_100 99 # define BOOST_PP_DEC_101 100 # define BOOST_PP_DEC_102 101 # define BOOST_PP_DEC_103 102 # define BOOST_PP_DEC_104 103 # define BOOST_PP_DEC_105 104 # define BOOST_PP_DEC_106 105 # define BOOST_PP_DEC_107 106 # define BOOST_PP_DEC_108 107 # define BOOST_PP_DEC_109 108 # define BOOST_PP_DEC_110 109 # define BOOST_PP_DEC_111 110 # define BOOST_PP_DEC_112 111 # define BOOST_PP_DEC_113 112 # define BOOST_PP_DEC_114 113 # define BOOST_PP_DEC_115 114 # define BOOST_PP_DEC_116 115 # define BOOST_PP_DEC_117 116 # define BOOST_PP_DEC_118 117 # define BOOST_PP_DEC_119 118 # define BOOST_PP_DEC_120 119 # define BOOST_PP_DEC_121 120 # define BOOST_PP_DEC_122 121 # define BOOST_PP_DEC_123 122 # define BOOST_PP_DEC_124 123 # define BOOST_PP_DEC_125 124 # define BOOST_PP_DEC_126 125 # define BOOST_PP_DEC_127 126 # define BOOST_PP_DEC_128 127 # define BOOST_PP_DEC_129 128 # define BOOST_PP_DEC_130 129 # define BOOST_PP_DEC_131 130 # define BOOST_PP_DEC_132 131 # define BOOST_PP_DEC_133 132 # define BOOST_PP_DEC_134 133 # define BOOST_PP_DEC_135 134 # define BOOST_PP_DEC_136 135 # define BOOST_PP_DEC_137 136 # define BOOST_PP_DEC_138 137 # define BOOST_PP_DEC_139 138 # define BOOST_PP_DEC_140 139 # define BOOST_PP_DEC_141 140 # define BOOST_PP_DEC_142 141 # define BOOST_PP_DEC_143 142 # define BOOST_PP_DEC_144 143 # define BOOST_PP_DEC_145 144 # define BOOST_PP_DEC_146 145 # define BOOST_PP_DEC_147 146 # define BOOST_PP_DEC_148 147 # define BOOST_PP_DEC_149 148 # define BOOST_PP_DEC_150 149 # define BOOST_PP_DEC_151 150 # define BOOST_PP_DEC_152 151 # define BOOST_PP_DEC_153 152 # define BOOST_PP_DEC_154 153 # define BOOST_PP_DEC_155 154 # define BOOST_PP_DEC_156 155 # define BOOST_PP_DEC_157 156 # define BOOST_PP_DEC_158 157 # define BOOST_PP_DEC_159 158 # define BOOST_PP_DEC_160 159 # define BOOST_PP_DEC_161 160 # define BOOST_PP_DEC_162 161 # define BOOST_PP_DEC_163 162 # define BOOST_PP_DEC_164 163 # define BOOST_PP_DEC_165 164 # define BOOST_PP_DEC_166 165 # define BOOST_PP_DEC_167 166 # define BOOST_PP_DEC_168 167 # define BOOST_PP_DEC_169 168 # define BOOST_PP_DEC_170 169 # define BOOST_PP_DEC_171 170 # define BOOST_PP_DEC_172 171 # define BOOST_PP_DEC_173 172 # define BOOST_PP_DEC_174 173 # define BOOST_PP_DEC_175 174 # define BOOST_PP_DEC_176 175 # define BOOST_PP_DEC_177 176 # define BOOST_PP_DEC_178 177 # define BOOST_PP_DEC_179 178 # define BOOST_PP_DEC_180 179 # define BOOST_PP_DEC_181 180 # define BOOST_PP_DEC_182 181 # define BOOST_PP_DEC_183 182 # define BOOST_PP_DEC_184 183 # define BOOST_PP_DEC_185 184 # define BOOST_PP_DEC_186 185 # define BOOST_PP_DEC_187 186 # define BOOST_PP_DEC_188 187 # define BOOST_PP_DEC_189 188 # define BOOST_PP_DEC_190 189 # define BOOST_PP_DEC_191 190 # define BOOST_PP_DEC_192 191 # define BOOST_PP_DEC_193 192 # define BOOST_PP_DEC_194 193 # define BOOST_PP_DEC_195 194 # define BOOST_PP_DEC_196 195 # define BOOST_PP_DEC_197 196 # define BOOST_PP_DEC_198 197 # define BOOST_PP_DEC_199 198 # define BOOST_PP_DEC_200 199 # define BOOST_PP_DEC_201 200 # define BOOST_PP_DEC_202 201 # define BOOST_PP_DEC_203 202 # define BOOST_PP_DEC_204 203 # define BOOST_PP_DEC_205 204 # define BOOST_PP_DEC_206 205 # define BOOST_PP_DEC_207 206 # define BOOST_PP_DEC_208 207 # define BOOST_PP_DEC_209 208 # define BOOST_PP_DEC_210 209 # define BOOST_PP_DEC_211 210 # define BOOST_PP_DEC_212 211 # define BOOST_PP_DEC_213 212 # define BOOST_PP_DEC_214 213 # define BOOST_PP_DEC_215 214 # define BOOST_PP_DEC_216 215 # define BOOST_PP_DEC_217 216 # define BOOST_PP_DEC_218 217 # define BOOST_PP_DEC_219 218 # define BOOST_PP_DEC_220 219 # define BOOST_PP_DEC_221 220 # define BOOST_PP_DEC_222 221 # define BOOST_PP_DEC_223 222 # define BOOST_PP_DEC_224 223 # define BOOST_PP_DEC_225 224 # define BOOST_PP_DEC_226 225 # define BOOST_PP_DEC_227 226 # define BOOST_PP_DEC_228 227 # define BOOST_PP_DEC_229 228 # define BOOST_PP_DEC_230 229 # define BOOST_PP_DEC_231 230 # define BOOST_PP_DEC_232 231 # define BOOST_PP_DEC_233 232 # define BOOST_PP_DEC_234 233 # define BOOST_PP_DEC_235 234 # define BOOST_PP_DEC_236 235 # define BOOST_PP_DEC_237 236 # define BOOST_PP_DEC_238 237 # define BOOST_PP_DEC_239 238 # define BOOST_PP_DEC_240 239 # define BOOST_PP_DEC_241 240 # define BOOST_PP_DEC_242 241 # define BOOST_PP_DEC_243 242 # define BOOST_PP_DEC_244 243 # define BOOST_PP_DEC_245 244 # define BOOST_PP_DEC_246 245 # define BOOST_PP_DEC_247 246 # define BOOST_PP_DEC_248 247 # define BOOST_PP_DEC_249 248 # define BOOST_PP_DEC_250 249 # define BOOST_PP_DEC_251 250 # define BOOST_PP_DEC_252 251 # define BOOST_PP_DEC_253 252 # define BOOST_PP_DEC_254 253 # define BOOST_PP_DEC_255 254 # define BOOST_PP_DEC_256 255 # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/mul.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000401611344301502031731 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_MUL_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_MUL_HPP # # include # include # include # include # include # include # # /* BOOST_PP_MUL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MUL(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y))) # else # define BOOST_PP_MUL(x, y) BOOST_PP_MUL_I(x, y) # define BOOST_PP_MUL_I(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y))) # endif # # define BOOST_PP_MUL_P(d, rxy) BOOST_PP_TUPLE_ELEM(3, 2, rxy) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_MUL_O(d, rxy) BOOST_PP_MUL_O_IM(d, BOOST_PP_TUPLE_REM_3 rxy) # define BOOST_PP_MUL_O_IM(d, im) BOOST_PP_MUL_O_I(d, im) # else # define BOOST_PP_MUL_O(d, rxy) BOOST_PP_MUL_O_I(d, BOOST_PP_TUPLE_ELEM(3, 0, rxy), BOOST_PP_TUPLE_ELEM(3, 1, rxy), BOOST_PP_TUPLE_ELEM(3, 2, rxy)) # endif # # define BOOST_PP_MUL_O_I(d, r, x, y) (BOOST_PP_ADD_D(d, r, x), x, BOOST_PP_DEC(y)) # # /* BOOST_PP_MUL_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MUL_D(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y))) # else # define BOOST_PP_MUL_D(d, x, y) BOOST_PP_MUL_D_I(d, x, y) # define BOOST_PP_MUL_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_MUL_P, BOOST_PP_MUL_O, (0, x, y))) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/div.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000237211344301502031734 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_DIV_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_DIV_HPP # # include # include # include # # /* BOOST_PP_DIV */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_DIV(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE(x, y)) # else # define BOOST_PP_DIV(x, y) BOOST_PP_DIV_I(x, y) # define BOOST_PP_DIV_I(x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE(x, y)) # endif # # /* BOOST_PP_DIV_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_DIV_D(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE_D(d, x, y)) # else # define BOOST_PP_DIV_D(d, x, y) BOOST_PP_DIV_D_I(d, x, y) # define BOOST_PP_DIV_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(3, 0, BOOST_PP_DIV_BASE_D(d, x, y)) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/add.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000350211344301502031730 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_ADD_HPP # # include # include # include # include # include # # /* BOOST_PP_ADD */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ADD(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) # else # define BOOST_PP_ADD(x, y) BOOST_PP_ADD_I(x, y) # define BOOST_PP_ADD_I(x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) # endif # # define BOOST_PP_ADD_P(d, xy) BOOST_PP_TUPLE_ELEM(2, 1, xy) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_ADD_O(d, xy) BOOST_PP_ADD_O_I xy # else # define BOOST_PP_ADD_O(d, xy) BOOST_PP_ADD_O_I(BOOST_PP_TUPLE_ELEM(2, 0, xy), BOOST_PP_TUPLE_ELEM(2, 1, xy)) # endif # # define BOOST_PP_ADD_O_I(x, y) (BOOST_PP_INC(x), BOOST_PP_DEC(y)) # # /* BOOST_PP_ADD_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ADD_D(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) # else # define BOOST_PP_ADD_D(d, x, y) BOOST_PP_ADD_D_I(d, x, y) # define BOOST_PP_ADD_D_I(d, x, y) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_ADD_P, BOOST_PP_ADD_O, (x, y))) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/inc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000002015111344301502031727 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_INC_HPP # # include # # /* BOOST_PP_INC */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_INC(x) BOOST_PP_INC_I(x) # else # define BOOST_PP_INC(x) BOOST_PP_INC_OO((x)) # define BOOST_PP_INC_OO(par) BOOST_PP_INC_I ## par # endif # # define BOOST_PP_INC_I(x) BOOST_PP_INC_ ## x # # define BOOST_PP_INC_0 1 # define BOOST_PP_INC_1 2 # define BOOST_PP_INC_2 3 # define BOOST_PP_INC_3 4 # define BOOST_PP_INC_4 5 # define BOOST_PP_INC_5 6 # define BOOST_PP_INC_6 7 # define BOOST_PP_INC_7 8 # define BOOST_PP_INC_8 9 # define BOOST_PP_INC_9 10 # define BOOST_PP_INC_10 11 # define BOOST_PP_INC_11 12 # define BOOST_PP_INC_12 13 # define BOOST_PP_INC_13 14 # define BOOST_PP_INC_14 15 # define BOOST_PP_INC_15 16 # define BOOST_PP_INC_16 17 # define BOOST_PP_INC_17 18 # define BOOST_PP_INC_18 19 # define BOOST_PP_INC_19 20 # define BOOST_PP_INC_20 21 # define BOOST_PP_INC_21 22 # define BOOST_PP_INC_22 23 # define BOOST_PP_INC_23 24 # define BOOST_PP_INC_24 25 # define BOOST_PP_INC_25 26 # define BOOST_PP_INC_26 27 # define BOOST_PP_INC_27 28 # define BOOST_PP_INC_28 29 # define BOOST_PP_INC_29 30 # define BOOST_PP_INC_30 31 # define BOOST_PP_INC_31 32 # define BOOST_PP_INC_32 33 # define BOOST_PP_INC_33 34 # define BOOST_PP_INC_34 35 # define BOOST_PP_INC_35 36 # define BOOST_PP_INC_36 37 # define BOOST_PP_INC_37 38 # define BOOST_PP_INC_38 39 # define BOOST_PP_INC_39 40 # define BOOST_PP_INC_40 41 # define BOOST_PP_INC_41 42 # define BOOST_PP_INC_42 43 # define BOOST_PP_INC_43 44 # define BOOST_PP_INC_44 45 # define BOOST_PP_INC_45 46 # define BOOST_PP_INC_46 47 # define BOOST_PP_INC_47 48 # define BOOST_PP_INC_48 49 # define BOOST_PP_INC_49 50 # define BOOST_PP_INC_50 51 # define BOOST_PP_INC_51 52 # define BOOST_PP_INC_52 53 # define BOOST_PP_INC_53 54 # define BOOST_PP_INC_54 55 # define BOOST_PP_INC_55 56 # define BOOST_PP_INC_56 57 # define BOOST_PP_INC_57 58 # define BOOST_PP_INC_58 59 # define BOOST_PP_INC_59 60 # define BOOST_PP_INC_60 61 # define BOOST_PP_INC_61 62 # define BOOST_PP_INC_62 63 # define BOOST_PP_INC_63 64 # define BOOST_PP_INC_64 65 # define BOOST_PP_INC_65 66 # define BOOST_PP_INC_66 67 # define BOOST_PP_INC_67 68 # define BOOST_PP_INC_68 69 # define BOOST_PP_INC_69 70 # define BOOST_PP_INC_70 71 # define BOOST_PP_INC_71 72 # define BOOST_PP_INC_72 73 # define BOOST_PP_INC_73 74 # define BOOST_PP_INC_74 75 # define BOOST_PP_INC_75 76 # define BOOST_PP_INC_76 77 # define BOOST_PP_INC_77 78 # define BOOST_PP_INC_78 79 # define BOOST_PP_INC_79 80 # define BOOST_PP_INC_80 81 # define BOOST_PP_INC_81 82 # define BOOST_PP_INC_82 83 # define BOOST_PP_INC_83 84 # define BOOST_PP_INC_84 85 # define BOOST_PP_INC_85 86 # define BOOST_PP_INC_86 87 # define BOOST_PP_INC_87 88 # define BOOST_PP_INC_88 89 # define BOOST_PP_INC_89 90 # define BOOST_PP_INC_90 91 # define BOOST_PP_INC_91 92 # define BOOST_PP_INC_92 93 # define BOOST_PP_INC_93 94 # define BOOST_PP_INC_94 95 # define BOOST_PP_INC_95 96 # define BOOST_PP_INC_96 97 # define BOOST_PP_INC_97 98 # define BOOST_PP_INC_98 99 # define BOOST_PP_INC_99 100 # define BOOST_PP_INC_100 101 # define BOOST_PP_INC_101 102 # define BOOST_PP_INC_102 103 # define BOOST_PP_INC_103 104 # define BOOST_PP_INC_104 105 # define BOOST_PP_INC_105 106 # define BOOST_PP_INC_106 107 # define BOOST_PP_INC_107 108 # define BOOST_PP_INC_108 109 # define BOOST_PP_INC_109 110 # define BOOST_PP_INC_110 111 # define BOOST_PP_INC_111 112 # define BOOST_PP_INC_112 113 # define BOOST_PP_INC_113 114 # define BOOST_PP_INC_114 115 # define BOOST_PP_INC_115 116 # define BOOST_PP_INC_116 117 # define BOOST_PP_INC_117 118 # define BOOST_PP_INC_118 119 # define BOOST_PP_INC_119 120 # define BOOST_PP_INC_120 121 # define BOOST_PP_INC_121 122 # define BOOST_PP_INC_122 123 # define BOOST_PP_INC_123 124 # define BOOST_PP_INC_124 125 # define BOOST_PP_INC_125 126 # define BOOST_PP_INC_126 127 # define BOOST_PP_INC_127 128 # define BOOST_PP_INC_128 129 # define BOOST_PP_INC_129 130 # define BOOST_PP_INC_130 131 # define BOOST_PP_INC_131 132 # define BOOST_PP_INC_132 133 # define BOOST_PP_INC_133 134 # define BOOST_PP_INC_134 135 # define BOOST_PP_INC_135 136 # define BOOST_PP_INC_136 137 # define BOOST_PP_INC_137 138 # define BOOST_PP_INC_138 139 # define BOOST_PP_INC_139 140 # define BOOST_PP_INC_140 141 # define BOOST_PP_INC_141 142 # define BOOST_PP_INC_142 143 # define BOOST_PP_INC_143 144 # define BOOST_PP_INC_144 145 # define BOOST_PP_INC_145 146 # define BOOST_PP_INC_146 147 # define BOOST_PP_INC_147 148 # define BOOST_PP_INC_148 149 # define BOOST_PP_INC_149 150 # define BOOST_PP_INC_150 151 # define BOOST_PP_INC_151 152 # define BOOST_PP_INC_152 153 # define BOOST_PP_INC_153 154 # define BOOST_PP_INC_154 155 # define BOOST_PP_INC_155 156 # define BOOST_PP_INC_156 157 # define BOOST_PP_INC_157 158 # define BOOST_PP_INC_158 159 # define BOOST_PP_INC_159 160 # define BOOST_PP_INC_160 161 # define BOOST_PP_INC_161 162 # define BOOST_PP_INC_162 163 # define BOOST_PP_INC_163 164 # define BOOST_PP_INC_164 165 # define BOOST_PP_INC_165 166 # define BOOST_PP_INC_166 167 # define BOOST_PP_INC_167 168 # define BOOST_PP_INC_168 169 # define BOOST_PP_INC_169 170 # define BOOST_PP_INC_170 171 # define BOOST_PP_INC_171 172 # define BOOST_PP_INC_172 173 # define BOOST_PP_INC_173 174 # define BOOST_PP_INC_174 175 # define BOOST_PP_INC_175 176 # define BOOST_PP_INC_176 177 # define BOOST_PP_INC_177 178 # define BOOST_PP_INC_178 179 # define BOOST_PP_INC_179 180 # define BOOST_PP_INC_180 181 # define BOOST_PP_INC_181 182 # define BOOST_PP_INC_182 183 # define BOOST_PP_INC_183 184 # define BOOST_PP_INC_184 185 # define BOOST_PP_INC_185 186 # define BOOST_PP_INC_186 187 # define BOOST_PP_INC_187 188 # define BOOST_PP_INC_188 189 # define BOOST_PP_INC_189 190 # define BOOST_PP_INC_190 191 # define BOOST_PP_INC_191 192 # define BOOST_PP_INC_192 193 # define BOOST_PP_INC_193 194 # define BOOST_PP_INC_194 195 # define BOOST_PP_INC_195 196 # define BOOST_PP_INC_196 197 # define BOOST_PP_INC_197 198 # define BOOST_PP_INC_198 199 # define BOOST_PP_INC_199 200 # define BOOST_PP_INC_200 201 # define BOOST_PP_INC_201 202 # define BOOST_PP_INC_202 203 # define BOOST_PP_INC_203 204 # define BOOST_PP_INC_204 205 # define BOOST_PP_INC_205 206 # define BOOST_PP_INC_206 207 # define BOOST_PP_INC_207 208 # define BOOST_PP_INC_208 209 # define BOOST_PP_INC_209 210 # define BOOST_PP_INC_210 211 # define BOOST_PP_INC_211 212 # define BOOST_PP_INC_212 213 # define BOOST_PP_INC_213 214 # define BOOST_PP_INC_214 215 # define BOOST_PP_INC_215 216 # define BOOST_PP_INC_216 217 # define BOOST_PP_INC_217 218 # define BOOST_PP_INC_218 219 # define BOOST_PP_INC_219 220 # define BOOST_PP_INC_220 221 # define BOOST_PP_INC_221 222 # define BOOST_PP_INC_222 223 # define BOOST_PP_INC_223 224 # define BOOST_PP_INC_224 225 # define BOOST_PP_INC_225 226 # define BOOST_PP_INC_226 227 # define BOOST_PP_INC_227 228 # define BOOST_PP_INC_228 229 # define BOOST_PP_INC_229 230 # define BOOST_PP_INC_230 231 # define BOOST_PP_INC_231 232 # define BOOST_PP_INC_232 233 # define BOOST_PP_INC_233 234 # define BOOST_PP_INC_234 235 # define BOOST_PP_INC_235 236 # define BOOST_PP_INC_236 237 # define BOOST_PP_INC_237 238 # define BOOST_PP_INC_238 239 # define BOOST_PP_INC_239 240 # define BOOST_PP_INC_240 241 # define BOOST_PP_INC_241 242 # define BOOST_PP_INC_242 243 # define BOOST_PP_INC_243 244 # define BOOST_PP_INC_244 245 # define BOOST_PP_INC_245 246 # define BOOST_PP_INC_246 247 # define BOOST_PP_INC_247 248 # define BOOST_PP_INC_248 249 # define BOOST_PP_INC_249 250 # define BOOST_PP_INC_250 251 # define BOOST_PP_INC_251 252 # define BOOST_PP_INC_252 253 # define BOOST_PP_INC_253 254 # define BOOST_PP_INC_254 255 # define BOOST_PP_INC_255 256 # define BOOST_PP_INC_256 256 # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000755000175000017500000000000012146213762031741 5ustar debiandebian././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic/detail/div_base.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000501011344301502031724 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_DETAIL_DIV_BASE_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_DETAIL_DIV_BASE_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_DIV_BASE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_DIV_BASE(x, y) BOOST_PP_WHILE(BOOST_PP_DIV_BASE_P, BOOST_PP_DIV_BASE_O, (0, x, y)) # else # define BOOST_PP_DIV_BASE(x, y) BOOST_PP_DIV_BASE_I(x, y) # define BOOST_PP_DIV_BASE_I(x, y) BOOST_PP_WHILE(BOOST_PP_DIV_BASE_P, BOOST_PP_DIV_BASE_O, (0, x, y)) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_DIV_BASE_P(d, rxy) BOOST_PP_DIV_BASE_P_IM(d, BOOST_PP_TUPLE_REM_3 rxy) # define BOOST_PP_DIV_BASE_P_IM(d, im) BOOST_PP_DIV_BASE_P_I(d, im) # else # define BOOST_PP_DIV_BASE_P(d, rxy) BOOST_PP_DIV_BASE_P_I(d, BOOST_PP_TUPLE_ELEM(3, 0, rxy), BOOST_PP_TUPLE_ELEM(3, 1, rxy), BOOST_PP_TUPLE_ELEM(3, 2, rxy)) # endif # # define BOOST_PP_DIV_BASE_P_I(d, r, x, y) BOOST_PP_LESS_EQUAL_D(d, y, x) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_DIV_BASE_O(d, rxy) BOOST_PP_DIV_BASE_O_IM(d, BOOST_PP_TUPLE_REM_3 rxy) # define BOOST_PP_DIV_BASE_O_IM(d, im) BOOST_PP_DIV_BASE_O_I(d, im) # else # define BOOST_PP_DIV_BASE_O(d, rxy) BOOST_PP_DIV_BASE_O_I(d, BOOST_PP_TUPLE_ELEM(3, 0, rxy), BOOST_PP_TUPLE_ELEM(3, 1, rxy), BOOST_PP_TUPLE_ELEM(3, 2, rxy)) # endif # # define BOOST_PP_DIV_BASE_O_I(d, r, x, y) (BOOST_PP_INC(r), BOOST_PP_SUB_D(d, x, y), y) # # /* BOOST_PP_DIV_BASE_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_DIV_BASE_D(d, x, y) BOOST_PP_WHILE_ ## d(BOOST_PP_DIV_BASE_P, BOOST_PP_DIV_BASE_O, (0, x, y)) # else # define BOOST_PP_DIV_BASE_D(d, x, y) BOOST_PP_DIV_BASE_D_I(d, x, y) # define BOOST_PP_DIV_BASE_D_I(d, x, y) BOOST_PP_WHILE_ ## d(BOOST_PP_DIV_BASE_P, BOOST_PP_DIV_BASE_O, (0, x, y)) # endif # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control.0000644000175000017500000000173711344301502031661 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_HPP # define BOOST_PREPROCESSOR_CONTROL_HPP # # include # include # include # include # include # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000755000175000017500000000000012146213763031664 5ustar debiandebian././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/expr_iif.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000000231011344301502031646 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP # define BOOST_PREPROCESSOR_CONTROL_EXPR_IIF_HPP # # include # # /* BOOST_PP_EXPR_IIF */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_I(bit, expr) # else # define BOOST_PP_EXPR_IIF(bit, expr) BOOST_PP_EXPR_IIF_OO((bit, expr)) # define BOOST_PP_EXPR_IIF_OO(par) BOOST_PP_EXPR_IIF_I ## par # endif # # define BOOST_PP_EXPR_IIF_I(bit, expr) BOOST_PP_EXPR_IIF_ ## bit(expr) # # define BOOST_PP_EXPR_IIF_0(expr) # define BOOST_PP_EXPR_IIF_1(expr) expr # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/expr_if.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000000167411344301502031662 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_EXPR_IF_HPP # define BOOST_PREPROCESSOR_CONTROL_EXPR_IF_HPP # # include # include # include # # /* BOOST_PP_EXPR_IF */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IIF(BOOST_PP_BOOL(cond), expr) # else # define BOOST_PP_EXPR_IF(cond, expr) BOOST_PP_EXPR_IF_I(cond, expr) # define BOOST_PP_EXPR_IF_I(cond, expr) BOOST_PP_EXPR_IIF(BOOST_PP_BOOL(cond), expr) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/while.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000004223111344301502031654 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_WHILE_HPP # define BOOST_PREPROCESSOR_CONTROL_WHILE_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_WHILE */ # # if 0 # define BOOST_PP_WHILE(pred, op, state) # endif # # define BOOST_PP_WHILE BOOST_PP_CAT(BOOST_PP_WHILE_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256)) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_CHECK_, BOOST_PP_LIST_FOLD_RIGHT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL)))) # else # define BOOST_PP_WHILE_P(n) BOOST_PP_BITAND(BOOST_PP_CAT(BOOST_PP_WHILE_CHECK_, BOOST_PP_WHILE_ ## n(BOOST_PP_WHILE_F, BOOST_PP_NIL, BOOST_PP_NIL)), BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_CHECK_, BOOST_PP_LIST_FOLD_LEFT_ ## n(BOOST_PP_NIL, BOOST_PP_NIL, BOOST_PP_NIL))) # endif # # define BOOST_PP_WHILE_F(d, _) 0 # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # include # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # include # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # include # else # include # endif # # define BOOST_PP_WHILE_257(p, o, s) BOOST_PP_ERROR(0x0001) # # define BOOST_PP_WHILE_CHECK_BOOST_PP_NIL 1 # # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_1(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_2(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_3(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_4(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_5(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_6(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_7(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_8(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_9(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_10(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_11(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_12(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_13(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_14(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_15(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_16(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_17(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_18(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_19(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_20(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_21(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_22(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_23(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_24(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_25(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_26(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_27(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_28(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_29(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_30(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_31(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_32(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_33(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_34(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_35(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_36(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_37(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_38(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_39(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_40(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_41(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_42(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_43(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_44(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_45(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_46(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_47(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_48(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_49(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_50(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_51(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_52(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_53(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_54(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_55(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_56(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_57(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_58(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_59(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_60(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_61(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_62(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_63(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_64(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_65(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_66(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_67(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_68(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_69(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_70(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_71(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_72(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_73(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_74(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_75(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_76(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_77(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_78(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_79(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_80(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_81(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_82(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_83(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_84(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_85(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_86(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_87(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_88(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_89(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_90(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_91(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_92(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_93(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_94(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_95(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_96(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_97(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_98(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_99(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_100(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_101(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_102(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_103(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_104(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_105(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_106(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_107(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_108(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_109(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_110(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_111(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_112(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_113(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_114(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_115(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_116(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_117(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_118(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_119(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_120(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_121(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_122(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_123(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_124(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_125(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_126(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_127(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_128(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_129(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_130(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_131(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_132(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_133(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_134(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_135(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_136(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_137(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_138(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_139(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_140(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_141(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_142(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_143(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_144(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_145(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_146(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_147(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_148(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_149(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_150(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_151(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_152(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_153(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_154(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_155(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_156(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_157(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_158(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_159(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_160(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_161(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_162(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_163(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_164(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_165(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_166(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_167(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_168(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_169(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_170(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_171(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_172(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_173(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_174(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_175(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_176(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_177(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_178(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_179(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_180(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_181(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_182(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_183(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_184(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_185(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_186(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_187(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_188(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_189(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_190(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_191(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_192(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_193(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_194(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_195(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_196(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_197(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_198(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_199(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_200(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_201(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_202(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_203(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_204(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_205(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_206(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_207(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_208(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_209(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_210(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_211(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_212(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_213(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_214(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_215(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_216(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_217(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_218(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_219(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_220(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_221(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_222(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_223(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_224(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_225(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_226(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_227(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_228(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_229(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_230(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_231(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_232(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_233(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_234(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_235(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_236(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_237(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_238(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_239(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_240(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_241(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_242(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_243(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_244(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_245(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_246(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_247(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_248(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_249(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_250(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_251(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_252(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_253(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_254(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_255(p, o, s) 0 # define BOOST_PP_WHILE_CHECK_BOOST_PP_WHILE_256(p, o, s) 0 # # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/deduce_d.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000000162011344301502031651 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_DEDUCE_D_HPP # define BOOST_PREPROCESSOR_CONTROL_DEDUCE_D_HPP # # include # include # # /* BOOST_PP_DEDUCE_D */ # # define BOOST_PP_DEDUCE_D() BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256) # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/if.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000000161211344301502031652 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_IF_HPP # define BOOST_PREPROCESSOR_CONTROL_IF_HPP # # include # include # include # # /* BOOST_PP_IF */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_IF(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) # else # define BOOST_PP_IF(cond, t, f) BOOST_PP_IF_I(cond, t, f) # define BOOST_PP_IF_I(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/iif.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000000245511344301502031660 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_IIF_HPP # define BOOST_PREPROCESSOR_CONTROL_IIF_HPP # # include # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_I(bit, t, f) # else # define BOOST_PP_IIF(bit, t, f) BOOST_PP_IIF_OO((bit, t, f)) # define BOOST_PP_IIF_OO(par) BOOST_PP_IIF_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_ ## bit(t, f) # else # define BOOST_PP_IIF_I(bit, t, f) BOOST_PP_IIF_II(BOOST_PP_IIF_ ## bit(t, f)) # define BOOST_PP_IIF_II(id) id # endif # # define BOOST_PP_IIF_0(t, f) f # define BOOST_PP_IIF_1(t, f) t # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000755000175000017500000000000012146213763031664 5ustar debiandebian././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/while.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000020375111344301502031662 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP # define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP # # include # include # include # # define BOOST_PP_WHILE_1(p, o, s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p(2, s)), p, o, s) # define BOOST_PP_WHILE_2(p, o, s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p(3, s)), p, o, s) # define BOOST_PP_WHILE_3(p, o, s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p(4, s)), p, o, s) # define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p(5, s)), p, o, s) # define BOOST_PP_WHILE_5(p, o, s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p(6, s)), p, o, s) # define BOOST_PP_WHILE_6(p, o, s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p(7, s)), p, o, s) # define BOOST_PP_WHILE_7(p, o, s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p(8, s)), p, o, s) # define BOOST_PP_WHILE_8(p, o, s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p(9, s)), p, o, s) # define BOOST_PP_WHILE_9(p, o, s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p(10, s)), p, o, s) # define BOOST_PP_WHILE_10(p, o, s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p(11, s)), p, o, s) # define BOOST_PP_WHILE_11(p, o, s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p(12, s)), p, o, s) # define BOOST_PP_WHILE_12(p, o, s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p(13, s)), p, o, s) # define BOOST_PP_WHILE_13(p, o, s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p(14, s)), p, o, s) # define BOOST_PP_WHILE_14(p, o, s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p(15, s)), p, o, s) # define BOOST_PP_WHILE_15(p, o, s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p(16, s)), p, o, s) # define BOOST_PP_WHILE_16(p, o, s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p(17, s)), p, o, s) # define BOOST_PP_WHILE_17(p, o, s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p(18, s)), p, o, s) # define BOOST_PP_WHILE_18(p, o, s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p(19, s)), p, o, s) # define BOOST_PP_WHILE_19(p, o, s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p(20, s)), p, o, s) # define BOOST_PP_WHILE_20(p, o, s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p(21, s)), p, o, s) # define BOOST_PP_WHILE_21(p, o, s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p(22, s)), p, o, s) # define BOOST_PP_WHILE_22(p, o, s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p(23, s)), p, o, s) # define BOOST_PP_WHILE_23(p, o, s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p(24, s)), p, o, s) # define BOOST_PP_WHILE_24(p, o, s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p(25, s)), p, o, s) # define BOOST_PP_WHILE_25(p, o, s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p(26, s)), p, o, s) # define BOOST_PP_WHILE_26(p, o, s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p(27, s)), p, o, s) # define BOOST_PP_WHILE_27(p, o, s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p(28, s)), p, o, s) # define BOOST_PP_WHILE_28(p, o, s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p(29, s)), p, o, s) # define BOOST_PP_WHILE_29(p, o, s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p(30, s)), p, o, s) # define BOOST_PP_WHILE_30(p, o, s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p(31, s)), p, o, s) # define BOOST_PP_WHILE_31(p, o, s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p(32, s)), p, o, s) # define BOOST_PP_WHILE_32(p, o, s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p(33, s)), p, o, s) # define BOOST_PP_WHILE_33(p, o, s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p(34, s)), p, o, s) # define BOOST_PP_WHILE_34(p, o, s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p(35, s)), p, o, s) # define BOOST_PP_WHILE_35(p, o, s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p(36, s)), p, o, s) # define BOOST_PP_WHILE_36(p, o, s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p(37, s)), p, o, s) # define BOOST_PP_WHILE_37(p, o, s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p(38, s)), p, o, s) # define BOOST_PP_WHILE_38(p, o, s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p(39, s)), p, o, s) # define BOOST_PP_WHILE_39(p, o, s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p(40, s)), p, o, s) # define BOOST_PP_WHILE_40(p, o, s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p(41, s)), p, o, s) # define BOOST_PP_WHILE_41(p, o, s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p(42, s)), p, o, s) # define BOOST_PP_WHILE_42(p, o, s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p(43, s)), p, o, s) # define BOOST_PP_WHILE_43(p, o, s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p(44, s)), p, o, s) # define BOOST_PP_WHILE_44(p, o, s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p(45, s)), p, o, s) # define BOOST_PP_WHILE_45(p, o, s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p(46, s)), p, o, s) # define BOOST_PP_WHILE_46(p, o, s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p(47, s)), p, o, s) # define BOOST_PP_WHILE_47(p, o, s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p(48, s)), p, o, s) # define BOOST_PP_WHILE_48(p, o, s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p(49, s)), p, o, s) # define BOOST_PP_WHILE_49(p, o, s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p(50, s)), p, o, s) # define BOOST_PP_WHILE_50(p, o, s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p(51, s)), p, o, s) # define BOOST_PP_WHILE_51(p, o, s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p(52, s)), p, o, s) # define BOOST_PP_WHILE_52(p, o, s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p(53, s)), p, o, s) # define BOOST_PP_WHILE_53(p, o, s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p(54, s)), p, o, s) # define BOOST_PP_WHILE_54(p, o, s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p(55, s)), p, o, s) # define BOOST_PP_WHILE_55(p, o, s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p(56, s)), p, o, s) # define BOOST_PP_WHILE_56(p, o, s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p(57, s)), p, o, s) # define BOOST_PP_WHILE_57(p, o, s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p(58, s)), p, o, s) # define BOOST_PP_WHILE_58(p, o, s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p(59, s)), p, o, s) # define BOOST_PP_WHILE_59(p, o, s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p(60, s)), p, o, s) # define BOOST_PP_WHILE_60(p, o, s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p(61, s)), p, o, s) # define BOOST_PP_WHILE_61(p, o, s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p(62, s)), p, o, s) # define BOOST_PP_WHILE_62(p, o, s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p(63, s)), p, o, s) # define BOOST_PP_WHILE_63(p, o, s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p(64, s)), p, o, s) # define BOOST_PP_WHILE_64(p, o, s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p(65, s)), p, o, s) # define BOOST_PP_WHILE_65(p, o, s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p(66, s)), p, o, s) # define BOOST_PP_WHILE_66(p, o, s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p(67, s)), p, o, s) # define BOOST_PP_WHILE_67(p, o, s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p(68, s)), p, o, s) # define BOOST_PP_WHILE_68(p, o, s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p(69, s)), p, o, s) # define BOOST_PP_WHILE_69(p, o, s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p(70, s)), p, o, s) # define BOOST_PP_WHILE_70(p, o, s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p(71, s)), p, o, s) # define BOOST_PP_WHILE_71(p, o, s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p(72, s)), p, o, s) # define BOOST_PP_WHILE_72(p, o, s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p(73, s)), p, o, s) # define BOOST_PP_WHILE_73(p, o, s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p(74, s)), p, o, s) # define BOOST_PP_WHILE_74(p, o, s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p(75, s)), p, o, s) # define BOOST_PP_WHILE_75(p, o, s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p(76, s)), p, o, s) # define BOOST_PP_WHILE_76(p, o, s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p(77, s)), p, o, s) # define BOOST_PP_WHILE_77(p, o, s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p(78, s)), p, o, s) # define BOOST_PP_WHILE_78(p, o, s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p(79, s)), p, o, s) # define BOOST_PP_WHILE_79(p, o, s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p(80, s)), p, o, s) # define BOOST_PP_WHILE_80(p, o, s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p(81, s)), p, o, s) # define BOOST_PP_WHILE_81(p, o, s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p(82, s)), p, o, s) # define BOOST_PP_WHILE_82(p, o, s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p(83, s)), p, o, s) # define BOOST_PP_WHILE_83(p, o, s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p(84, s)), p, o, s) # define BOOST_PP_WHILE_84(p, o, s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p(85, s)), p, o, s) # define BOOST_PP_WHILE_85(p, o, s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p(86, s)), p, o, s) # define BOOST_PP_WHILE_86(p, o, s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p(87, s)), p, o, s) # define BOOST_PP_WHILE_87(p, o, s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p(88, s)), p, o, s) # define BOOST_PP_WHILE_88(p, o, s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p(89, s)), p, o, s) # define BOOST_PP_WHILE_89(p, o, s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p(90, s)), p, o, s) # define BOOST_PP_WHILE_90(p, o, s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p(91, s)), p, o, s) # define BOOST_PP_WHILE_91(p, o, s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p(92, s)), p, o, s) # define BOOST_PP_WHILE_92(p, o, s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p(93, s)), p, o, s) # define BOOST_PP_WHILE_93(p, o, s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p(94, s)), p, o, s) # define BOOST_PP_WHILE_94(p, o, s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p(95, s)), p, o, s) # define BOOST_PP_WHILE_95(p, o, s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p(96, s)), p, o, s) # define BOOST_PP_WHILE_96(p, o, s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p(97, s)), p, o, s) # define BOOST_PP_WHILE_97(p, o, s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p(98, s)), p, o, s) # define BOOST_PP_WHILE_98(p, o, s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p(99, s)), p, o, s) # define BOOST_PP_WHILE_99(p, o, s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p(100, s)), p, o, s) # define BOOST_PP_WHILE_100(p, o, s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p(101, s)), p, o, s) # define BOOST_PP_WHILE_101(p, o, s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p(102, s)), p, o, s) # define BOOST_PP_WHILE_102(p, o, s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p(103, s)), p, o, s) # define BOOST_PP_WHILE_103(p, o, s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p(104, s)), p, o, s) # define BOOST_PP_WHILE_104(p, o, s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p(105, s)), p, o, s) # define BOOST_PP_WHILE_105(p, o, s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p(106, s)), p, o, s) # define BOOST_PP_WHILE_106(p, o, s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p(107, s)), p, o, s) # define BOOST_PP_WHILE_107(p, o, s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p(108, s)), p, o, s) # define BOOST_PP_WHILE_108(p, o, s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p(109, s)), p, o, s) # define BOOST_PP_WHILE_109(p, o, s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p(110, s)), p, o, s) # define BOOST_PP_WHILE_110(p, o, s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p(111, s)), p, o, s) # define BOOST_PP_WHILE_111(p, o, s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p(112, s)), p, o, s) # define BOOST_PP_WHILE_112(p, o, s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p(113, s)), p, o, s) # define BOOST_PP_WHILE_113(p, o, s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p(114, s)), p, o, s) # define BOOST_PP_WHILE_114(p, o, s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p(115, s)), p, o, s) # define BOOST_PP_WHILE_115(p, o, s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p(116, s)), p, o, s) # define BOOST_PP_WHILE_116(p, o, s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p(117, s)), p, o, s) # define BOOST_PP_WHILE_117(p, o, s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p(118, s)), p, o, s) # define BOOST_PP_WHILE_118(p, o, s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p(119, s)), p, o, s) # define BOOST_PP_WHILE_119(p, o, s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p(120, s)), p, o, s) # define BOOST_PP_WHILE_120(p, o, s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p(121, s)), p, o, s) # define BOOST_PP_WHILE_121(p, o, s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p(122, s)), p, o, s) # define BOOST_PP_WHILE_122(p, o, s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p(123, s)), p, o, s) # define BOOST_PP_WHILE_123(p, o, s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p(124, s)), p, o, s) # define BOOST_PP_WHILE_124(p, o, s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p(125, s)), p, o, s) # define BOOST_PP_WHILE_125(p, o, s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p(126, s)), p, o, s) # define BOOST_PP_WHILE_126(p, o, s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p(127, s)), p, o, s) # define BOOST_PP_WHILE_127(p, o, s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p(128, s)), p, o, s) # define BOOST_PP_WHILE_128(p, o, s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p(129, s)), p, o, s) # define BOOST_PP_WHILE_129(p, o, s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p(130, s)), p, o, s) # define BOOST_PP_WHILE_130(p, o, s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p(131, s)), p, o, s) # define BOOST_PP_WHILE_131(p, o, s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p(132, s)), p, o, s) # define BOOST_PP_WHILE_132(p, o, s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p(133, s)), p, o, s) # define BOOST_PP_WHILE_133(p, o, s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p(134, s)), p, o, s) # define BOOST_PP_WHILE_134(p, o, s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p(135, s)), p, o, s) # define BOOST_PP_WHILE_135(p, o, s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p(136, s)), p, o, s) # define BOOST_PP_WHILE_136(p, o, s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p(137, s)), p, o, s) # define BOOST_PP_WHILE_137(p, o, s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p(138, s)), p, o, s) # define BOOST_PP_WHILE_138(p, o, s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p(139, s)), p, o, s) # define BOOST_PP_WHILE_139(p, o, s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p(140, s)), p, o, s) # define BOOST_PP_WHILE_140(p, o, s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p(141, s)), p, o, s) # define BOOST_PP_WHILE_141(p, o, s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p(142, s)), p, o, s) # define BOOST_PP_WHILE_142(p, o, s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p(143, s)), p, o, s) # define BOOST_PP_WHILE_143(p, o, s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p(144, s)), p, o, s) # define BOOST_PP_WHILE_144(p, o, s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p(145, s)), p, o, s) # define BOOST_PP_WHILE_145(p, o, s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p(146, s)), p, o, s) # define BOOST_PP_WHILE_146(p, o, s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p(147, s)), p, o, s) # define BOOST_PP_WHILE_147(p, o, s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p(148, s)), p, o, s) # define BOOST_PP_WHILE_148(p, o, s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p(149, s)), p, o, s) # define BOOST_PP_WHILE_149(p, o, s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p(150, s)), p, o, s) # define BOOST_PP_WHILE_150(p, o, s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p(151, s)), p, o, s) # define BOOST_PP_WHILE_151(p, o, s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p(152, s)), p, o, s) # define BOOST_PP_WHILE_152(p, o, s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p(153, s)), p, o, s) # define BOOST_PP_WHILE_153(p, o, s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p(154, s)), p, o, s) # define BOOST_PP_WHILE_154(p, o, s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p(155, s)), p, o, s) # define BOOST_PP_WHILE_155(p, o, s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p(156, s)), p, o, s) # define BOOST_PP_WHILE_156(p, o, s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p(157, s)), p, o, s) # define BOOST_PP_WHILE_157(p, o, s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p(158, s)), p, o, s) # define BOOST_PP_WHILE_158(p, o, s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p(159, s)), p, o, s) # define BOOST_PP_WHILE_159(p, o, s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p(160, s)), p, o, s) # define BOOST_PP_WHILE_160(p, o, s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p(161, s)), p, o, s) # define BOOST_PP_WHILE_161(p, o, s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p(162, s)), p, o, s) # define BOOST_PP_WHILE_162(p, o, s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p(163, s)), p, o, s) # define BOOST_PP_WHILE_163(p, o, s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p(164, s)), p, o, s) # define BOOST_PP_WHILE_164(p, o, s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p(165, s)), p, o, s) # define BOOST_PP_WHILE_165(p, o, s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p(166, s)), p, o, s) # define BOOST_PP_WHILE_166(p, o, s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p(167, s)), p, o, s) # define BOOST_PP_WHILE_167(p, o, s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p(168, s)), p, o, s) # define BOOST_PP_WHILE_168(p, o, s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p(169, s)), p, o, s) # define BOOST_PP_WHILE_169(p, o, s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p(170, s)), p, o, s) # define BOOST_PP_WHILE_170(p, o, s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p(171, s)), p, o, s) # define BOOST_PP_WHILE_171(p, o, s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p(172, s)), p, o, s) # define BOOST_PP_WHILE_172(p, o, s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p(173, s)), p, o, s) # define BOOST_PP_WHILE_173(p, o, s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p(174, s)), p, o, s) # define BOOST_PP_WHILE_174(p, o, s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p(175, s)), p, o, s) # define BOOST_PP_WHILE_175(p, o, s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p(176, s)), p, o, s) # define BOOST_PP_WHILE_176(p, o, s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p(177, s)), p, o, s) # define BOOST_PP_WHILE_177(p, o, s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p(178, s)), p, o, s) # define BOOST_PP_WHILE_178(p, o, s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p(179, s)), p, o, s) # define BOOST_PP_WHILE_179(p, o, s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p(180, s)), p, o, s) # define BOOST_PP_WHILE_180(p, o, s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p(181, s)), p, o, s) # define BOOST_PP_WHILE_181(p, o, s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p(182, s)), p, o, s) # define BOOST_PP_WHILE_182(p, o, s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p(183, s)), p, o, s) # define BOOST_PP_WHILE_183(p, o, s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p(184, s)), p, o, s) # define BOOST_PP_WHILE_184(p, o, s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p(185, s)), p, o, s) # define BOOST_PP_WHILE_185(p, o, s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p(186, s)), p, o, s) # define BOOST_PP_WHILE_186(p, o, s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p(187, s)), p, o, s) # define BOOST_PP_WHILE_187(p, o, s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p(188, s)), p, o, s) # define BOOST_PP_WHILE_188(p, o, s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p(189, s)), p, o, s) # define BOOST_PP_WHILE_189(p, o, s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p(190, s)), p, o, s) # define BOOST_PP_WHILE_190(p, o, s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p(191, s)), p, o, s) # define BOOST_PP_WHILE_191(p, o, s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p(192, s)), p, o, s) # define BOOST_PP_WHILE_192(p, o, s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p(193, s)), p, o, s) # define BOOST_PP_WHILE_193(p, o, s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p(194, s)), p, o, s) # define BOOST_PP_WHILE_194(p, o, s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p(195, s)), p, o, s) # define BOOST_PP_WHILE_195(p, o, s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p(196, s)), p, o, s) # define BOOST_PP_WHILE_196(p, o, s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p(197, s)), p, o, s) # define BOOST_PP_WHILE_197(p, o, s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p(198, s)), p, o, s) # define BOOST_PP_WHILE_198(p, o, s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p(199, s)), p, o, s) # define BOOST_PP_WHILE_199(p, o, s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p(200, s)), p, o, s) # define BOOST_PP_WHILE_200(p, o, s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p(201, s)), p, o, s) # define BOOST_PP_WHILE_201(p, o, s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p(202, s)), p, o, s) # define BOOST_PP_WHILE_202(p, o, s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p(203, s)), p, o, s) # define BOOST_PP_WHILE_203(p, o, s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p(204, s)), p, o, s) # define BOOST_PP_WHILE_204(p, o, s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p(205, s)), p, o, s) # define BOOST_PP_WHILE_205(p, o, s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p(206, s)), p, o, s) # define BOOST_PP_WHILE_206(p, o, s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p(207, s)), p, o, s) # define BOOST_PP_WHILE_207(p, o, s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p(208, s)), p, o, s) # define BOOST_PP_WHILE_208(p, o, s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p(209, s)), p, o, s) # define BOOST_PP_WHILE_209(p, o, s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p(210, s)), p, o, s) # define BOOST_PP_WHILE_210(p, o, s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p(211, s)), p, o, s) # define BOOST_PP_WHILE_211(p, o, s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p(212, s)), p, o, s) # define BOOST_PP_WHILE_212(p, o, s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p(213, s)), p, o, s) # define BOOST_PP_WHILE_213(p, o, s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p(214, s)), p, o, s) # define BOOST_PP_WHILE_214(p, o, s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p(215, s)), p, o, s) # define BOOST_PP_WHILE_215(p, o, s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p(216, s)), p, o, s) # define BOOST_PP_WHILE_216(p, o, s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p(217, s)), p, o, s) # define BOOST_PP_WHILE_217(p, o, s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p(218, s)), p, o, s) # define BOOST_PP_WHILE_218(p, o, s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p(219, s)), p, o, s) # define BOOST_PP_WHILE_219(p, o, s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p(220, s)), p, o, s) # define BOOST_PP_WHILE_220(p, o, s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p(221, s)), p, o, s) # define BOOST_PP_WHILE_221(p, o, s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p(222, s)), p, o, s) # define BOOST_PP_WHILE_222(p, o, s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p(223, s)), p, o, s) # define BOOST_PP_WHILE_223(p, o, s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p(224, s)), p, o, s) # define BOOST_PP_WHILE_224(p, o, s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p(225, s)), p, o, s) # define BOOST_PP_WHILE_225(p, o, s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p(226, s)), p, o, s) # define BOOST_PP_WHILE_226(p, o, s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p(227, s)), p, o, s) # define BOOST_PP_WHILE_227(p, o, s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p(228, s)), p, o, s) # define BOOST_PP_WHILE_228(p, o, s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p(229, s)), p, o, s) # define BOOST_PP_WHILE_229(p, o, s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p(230, s)), p, o, s) # define BOOST_PP_WHILE_230(p, o, s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p(231, s)), p, o, s) # define BOOST_PP_WHILE_231(p, o, s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p(232, s)), p, o, s) # define BOOST_PP_WHILE_232(p, o, s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p(233, s)), p, o, s) # define BOOST_PP_WHILE_233(p, o, s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p(234, s)), p, o, s) # define BOOST_PP_WHILE_234(p, o, s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p(235, s)), p, o, s) # define BOOST_PP_WHILE_235(p, o, s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p(236, s)), p, o, s) # define BOOST_PP_WHILE_236(p, o, s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p(237, s)), p, o, s) # define BOOST_PP_WHILE_237(p, o, s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p(238, s)), p, o, s) # define BOOST_PP_WHILE_238(p, o, s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p(239, s)), p, o, s) # define BOOST_PP_WHILE_239(p, o, s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p(240, s)), p, o, s) # define BOOST_PP_WHILE_240(p, o, s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p(241, s)), p, o, s) # define BOOST_PP_WHILE_241(p, o, s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p(242, s)), p, o, s) # define BOOST_PP_WHILE_242(p, o, s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p(243, s)), p, o, s) # define BOOST_PP_WHILE_243(p, o, s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p(244, s)), p, o, s) # define BOOST_PP_WHILE_244(p, o, s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p(245, s)), p, o, s) # define BOOST_PP_WHILE_245(p, o, s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p(246, s)), p, o, s) # define BOOST_PP_WHILE_246(p, o, s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p(247, s)), p, o, s) # define BOOST_PP_WHILE_247(p, o, s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p(248, s)), p, o, s) # define BOOST_PP_WHILE_248(p, o, s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p(249, s)), p, o, s) # define BOOST_PP_WHILE_249(p, o, s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p(250, s)), p, o, s) # define BOOST_PP_WHILE_250(p, o, s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p(251, s)), p, o, s) # define BOOST_PP_WHILE_251(p, o, s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p(252, s)), p, o, s) # define BOOST_PP_WHILE_252(p, o, s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p(253, s)), p, o, s) # define BOOST_PP_WHILE_253(p, o, s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p(254, s)), p, o, s) # define BOOST_PP_WHILE_254(p, o, s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p(255, s)), p, o, s) # define BOOST_PP_WHILE_255(p, o, s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p(256, s)), p, o, s) # define BOOST_PP_WHILE_256(p, o, s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p(257, s)), p, o, s) # # define BOOST_PP_WHILE_1_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(2, s)) # define BOOST_PP_WHILE_2_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(3, s)) # define BOOST_PP_WHILE_3_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(4, s)) # define BOOST_PP_WHILE_4_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(5, s)) # define BOOST_PP_WHILE_5_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(6, s)) # define BOOST_PP_WHILE_6_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(7, s)) # define BOOST_PP_WHILE_7_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(8, s)) # define BOOST_PP_WHILE_8_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(9, s)) # define BOOST_PP_WHILE_9_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(10, s)) # define BOOST_PP_WHILE_10_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(11, s)) # define BOOST_PP_WHILE_11_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(12, s)) # define BOOST_PP_WHILE_12_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(13, s)) # define BOOST_PP_WHILE_13_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(14, s)) # define BOOST_PP_WHILE_14_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(15, s)) # define BOOST_PP_WHILE_15_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(16, s)) # define BOOST_PP_WHILE_16_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(17, s)) # define BOOST_PP_WHILE_17_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(18, s)) # define BOOST_PP_WHILE_18_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(19, s)) # define BOOST_PP_WHILE_19_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(20, s)) # define BOOST_PP_WHILE_20_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(21, s)) # define BOOST_PP_WHILE_21_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(22, s)) # define BOOST_PP_WHILE_22_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(23, s)) # define BOOST_PP_WHILE_23_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(24, s)) # define BOOST_PP_WHILE_24_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(25, s)) # define BOOST_PP_WHILE_25_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(26, s)) # define BOOST_PP_WHILE_26_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(27, s)) # define BOOST_PP_WHILE_27_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(28, s)) # define BOOST_PP_WHILE_28_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(29, s)) # define BOOST_PP_WHILE_29_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(30, s)) # define BOOST_PP_WHILE_30_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(31, s)) # define BOOST_PP_WHILE_31_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(32, s)) # define BOOST_PP_WHILE_32_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(33, s)) # define BOOST_PP_WHILE_33_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(34, s)) # define BOOST_PP_WHILE_34_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(35, s)) # define BOOST_PP_WHILE_35_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(36, s)) # define BOOST_PP_WHILE_36_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(37, s)) # define BOOST_PP_WHILE_37_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(38, s)) # define BOOST_PP_WHILE_38_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(39, s)) # define BOOST_PP_WHILE_39_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(40, s)) # define BOOST_PP_WHILE_40_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(41, s)) # define BOOST_PP_WHILE_41_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(42, s)) # define BOOST_PP_WHILE_42_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(43, s)) # define BOOST_PP_WHILE_43_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(44, s)) # define BOOST_PP_WHILE_44_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(45, s)) # define BOOST_PP_WHILE_45_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(46, s)) # define BOOST_PP_WHILE_46_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(47, s)) # define BOOST_PP_WHILE_47_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(48, s)) # define BOOST_PP_WHILE_48_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(49, s)) # define BOOST_PP_WHILE_49_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(50, s)) # define BOOST_PP_WHILE_50_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(51, s)) # define BOOST_PP_WHILE_51_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(52, s)) # define BOOST_PP_WHILE_52_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(53, s)) # define BOOST_PP_WHILE_53_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(54, s)) # define BOOST_PP_WHILE_54_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(55, s)) # define BOOST_PP_WHILE_55_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(56, s)) # define BOOST_PP_WHILE_56_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(57, s)) # define BOOST_PP_WHILE_57_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(58, s)) # define BOOST_PP_WHILE_58_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(59, s)) # define BOOST_PP_WHILE_59_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(60, s)) # define BOOST_PP_WHILE_60_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(61, s)) # define BOOST_PP_WHILE_61_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(62, s)) # define BOOST_PP_WHILE_62_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(63, s)) # define BOOST_PP_WHILE_63_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(64, s)) # define BOOST_PP_WHILE_64_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(65, s)) # define BOOST_PP_WHILE_65_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(66, s)) # define BOOST_PP_WHILE_66_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(67, s)) # define BOOST_PP_WHILE_67_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(68, s)) # define BOOST_PP_WHILE_68_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(69, s)) # define BOOST_PP_WHILE_69_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(70, s)) # define BOOST_PP_WHILE_70_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(71, s)) # define BOOST_PP_WHILE_71_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(72, s)) # define BOOST_PP_WHILE_72_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(73, s)) # define BOOST_PP_WHILE_73_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(74, s)) # define BOOST_PP_WHILE_74_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(75, s)) # define BOOST_PP_WHILE_75_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(76, s)) # define BOOST_PP_WHILE_76_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(77, s)) # define BOOST_PP_WHILE_77_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(78, s)) # define BOOST_PP_WHILE_78_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(79, s)) # define BOOST_PP_WHILE_79_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(80, s)) # define BOOST_PP_WHILE_80_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(81, s)) # define BOOST_PP_WHILE_81_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(82, s)) # define BOOST_PP_WHILE_82_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(83, s)) # define BOOST_PP_WHILE_83_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(84, s)) # define BOOST_PP_WHILE_84_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(85, s)) # define BOOST_PP_WHILE_85_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(86, s)) # define BOOST_PP_WHILE_86_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(87, s)) # define BOOST_PP_WHILE_87_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(88, s)) # define BOOST_PP_WHILE_88_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(89, s)) # define BOOST_PP_WHILE_89_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(90, s)) # define BOOST_PP_WHILE_90_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(91, s)) # define BOOST_PP_WHILE_91_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(92, s)) # define BOOST_PP_WHILE_92_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(93, s)) # define BOOST_PP_WHILE_93_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(94, s)) # define BOOST_PP_WHILE_94_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(95, s)) # define BOOST_PP_WHILE_95_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(96, s)) # define BOOST_PP_WHILE_96_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(97, s)) # define BOOST_PP_WHILE_97_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(98, s)) # define BOOST_PP_WHILE_98_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(99, s)) # define BOOST_PP_WHILE_99_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(100, s)) # define BOOST_PP_WHILE_100_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(101, s)) # define BOOST_PP_WHILE_101_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(102, s)) # define BOOST_PP_WHILE_102_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(103, s)) # define BOOST_PP_WHILE_103_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(104, s)) # define BOOST_PP_WHILE_104_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(105, s)) # define BOOST_PP_WHILE_105_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(106, s)) # define BOOST_PP_WHILE_106_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(107, s)) # define BOOST_PP_WHILE_107_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(108, s)) # define BOOST_PP_WHILE_108_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(109, s)) # define BOOST_PP_WHILE_109_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(110, s)) # define BOOST_PP_WHILE_110_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(111, s)) # define BOOST_PP_WHILE_111_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(112, s)) # define BOOST_PP_WHILE_112_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(113, s)) # define BOOST_PP_WHILE_113_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(114, s)) # define BOOST_PP_WHILE_114_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(115, s)) # define BOOST_PP_WHILE_115_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(116, s)) # define BOOST_PP_WHILE_116_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(117, s)) # define BOOST_PP_WHILE_117_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(118, s)) # define BOOST_PP_WHILE_118_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(119, s)) # define BOOST_PP_WHILE_119_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(120, s)) # define BOOST_PP_WHILE_120_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(121, s)) # define BOOST_PP_WHILE_121_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(122, s)) # define BOOST_PP_WHILE_122_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(123, s)) # define BOOST_PP_WHILE_123_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(124, s)) # define BOOST_PP_WHILE_124_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(125, s)) # define BOOST_PP_WHILE_125_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(126, s)) # define BOOST_PP_WHILE_126_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(127, s)) # define BOOST_PP_WHILE_127_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(128, s)) # define BOOST_PP_WHILE_128_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(129, s)) # define BOOST_PP_WHILE_129_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(130, s)) # define BOOST_PP_WHILE_130_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(131, s)) # define BOOST_PP_WHILE_131_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(132, s)) # define BOOST_PP_WHILE_132_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(133, s)) # define BOOST_PP_WHILE_133_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(134, s)) # define BOOST_PP_WHILE_134_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(135, s)) # define BOOST_PP_WHILE_135_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(136, s)) # define BOOST_PP_WHILE_136_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(137, s)) # define BOOST_PP_WHILE_137_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(138, s)) # define BOOST_PP_WHILE_138_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(139, s)) # define BOOST_PP_WHILE_139_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(140, s)) # define BOOST_PP_WHILE_140_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(141, s)) # define BOOST_PP_WHILE_141_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(142, s)) # define BOOST_PP_WHILE_142_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(143, s)) # define BOOST_PP_WHILE_143_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(144, s)) # define BOOST_PP_WHILE_144_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(145, s)) # define BOOST_PP_WHILE_145_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(146, s)) # define BOOST_PP_WHILE_146_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(147, s)) # define BOOST_PP_WHILE_147_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(148, s)) # define BOOST_PP_WHILE_148_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(149, s)) # define BOOST_PP_WHILE_149_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(150, s)) # define BOOST_PP_WHILE_150_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(151, s)) # define BOOST_PP_WHILE_151_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(152, s)) # define BOOST_PP_WHILE_152_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(153, s)) # define BOOST_PP_WHILE_153_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(154, s)) # define BOOST_PP_WHILE_154_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(155, s)) # define BOOST_PP_WHILE_155_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(156, s)) # define BOOST_PP_WHILE_156_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(157, s)) # define BOOST_PP_WHILE_157_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(158, s)) # define BOOST_PP_WHILE_158_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(159, s)) # define BOOST_PP_WHILE_159_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(160, s)) # define BOOST_PP_WHILE_160_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(161, s)) # define BOOST_PP_WHILE_161_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(162, s)) # define BOOST_PP_WHILE_162_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(163, s)) # define BOOST_PP_WHILE_163_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(164, s)) # define BOOST_PP_WHILE_164_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(165, s)) # define BOOST_PP_WHILE_165_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(166, s)) # define BOOST_PP_WHILE_166_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(167, s)) # define BOOST_PP_WHILE_167_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(168, s)) # define BOOST_PP_WHILE_168_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(169, s)) # define BOOST_PP_WHILE_169_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(170, s)) # define BOOST_PP_WHILE_170_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(171, s)) # define BOOST_PP_WHILE_171_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(172, s)) # define BOOST_PP_WHILE_172_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(173, s)) # define BOOST_PP_WHILE_173_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(174, s)) # define BOOST_PP_WHILE_174_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(175, s)) # define BOOST_PP_WHILE_175_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(176, s)) # define BOOST_PP_WHILE_176_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(177, s)) # define BOOST_PP_WHILE_177_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(178, s)) # define BOOST_PP_WHILE_178_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(179, s)) # define BOOST_PP_WHILE_179_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(180, s)) # define BOOST_PP_WHILE_180_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(181, s)) # define BOOST_PP_WHILE_181_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(182, s)) # define BOOST_PP_WHILE_182_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(183, s)) # define BOOST_PP_WHILE_183_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(184, s)) # define BOOST_PP_WHILE_184_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(185, s)) # define BOOST_PP_WHILE_185_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(186, s)) # define BOOST_PP_WHILE_186_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(187, s)) # define BOOST_PP_WHILE_187_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(188, s)) # define BOOST_PP_WHILE_188_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(189, s)) # define BOOST_PP_WHILE_189_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(190, s)) # define BOOST_PP_WHILE_190_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(191, s)) # define BOOST_PP_WHILE_191_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(192, s)) # define BOOST_PP_WHILE_192_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(193, s)) # define BOOST_PP_WHILE_193_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(194, s)) # define BOOST_PP_WHILE_194_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(195, s)) # define BOOST_PP_WHILE_195_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(196, s)) # define BOOST_PP_WHILE_196_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(197, s)) # define BOOST_PP_WHILE_197_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(198, s)) # define BOOST_PP_WHILE_198_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(199, s)) # define BOOST_PP_WHILE_199_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(200, s)) # define BOOST_PP_WHILE_200_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(201, s)) # define BOOST_PP_WHILE_201_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(202, s)) # define BOOST_PP_WHILE_202_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(203, s)) # define BOOST_PP_WHILE_203_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(204, s)) # define BOOST_PP_WHILE_204_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(205, s)) # define BOOST_PP_WHILE_205_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(206, s)) # define BOOST_PP_WHILE_206_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(207, s)) # define BOOST_PP_WHILE_207_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(208, s)) # define BOOST_PP_WHILE_208_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(209, s)) # define BOOST_PP_WHILE_209_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(210, s)) # define BOOST_PP_WHILE_210_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(211, s)) # define BOOST_PP_WHILE_211_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(212, s)) # define BOOST_PP_WHILE_212_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(213, s)) # define BOOST_PP_WHILE_213_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(214, s)) # define BOOST_PP_WHILE_214_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(215, s)) # define BOOST_PP_WHILE_215_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(216, s)) # define BOOST_PP_WHILE_216_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(217, s)) # define BOOST_PP_WHILE_217_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(218, s)) # define BOOST_PP_WHILE_218_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(219, s)) # define BOOST_PP_WHILE_219_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(220, s)) # define BOOST_PP_WHILE_220_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(221, s)) # define BOOST_PP_WHILE_221_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(222, s)) # define BOOST_PP_WHILE_222_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(223, s)) # define BOOST_PP_WHILE_223_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(224, s)) # define BOOST_PP_WHILE_224_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(225, s)) # define BOOST_PP_WHILE_225_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(226, s)) # define BOOST_PP_WHILE_226_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(227, s)) # define BOOST_PP_WHILE_227_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(228, s)) # define BOOST_PP_WHILE_228_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(229, s)) # define BOOST_PP_WHILE_229_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(230, s)) # define BOOST_PP_WHILE_230_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(231, s)) # define BOOST_PP_WHILE_231_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(232, s)) # define BOOST_PP_WHILE_232_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(233, s)) # define BOOST_PP_WHILE_233_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(234, s)) # define BOOST_PP_WHILE_234_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(235, s)) # define BOOST_PP_WHILE_235_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(236, s)) # define BOOST_PP_WHILE_236_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(237, s)) # define BOOST_PP_WHILE_237_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(238, s)) # define BOOST_PP_WHILE_238_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(239, s)) # define BOOST_PP_WHILE_239_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(240, s)) # define BOOST_PP_WHILE_240_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(241, s)) # define BOOST_PP_WHILE_241_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(242, s)) # define BOOST_PP_WHILE_242_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(243, s)) # define BOOST_PP_WHILE_243_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(244, s)) # define BOOST_PP_WHILE_244_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(245, s)) # define BOOST_PP_WHILE_245_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(246, s)) # define BOOST_PP_WHILE_246_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(247, s)) # define BOOST_PP_WHILE_247_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(248, s)) # define BOOST_PP_WHILE_248_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(249, s)) # define BOOST_PP_WHILE_249_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(250, s)) # define BOOST_PP_WHILE_250_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(251, s)) # define BOOST_PP_WHILE_251_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(252, s)) # define BOOST_PP_WHILE_252_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(253, s)) # define BOOST_PP_WHILE_253_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(254, s)) # define BOOST_PP_WHILE_254_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(255, s)) # define BOOST_PP_WHILE_255_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(256, s)) # define BOOST_PP_WHILE_256_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_2)(257, s)) # # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/dmc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000755000175000017500000000000012146213763031664 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/dmc/while.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000020035111344301502031653 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP # define BOOST_PREPROCESSOR_CONTROL_DETAIL_WHILE_HPP # # include # include # include # # define BOOST_PP_WHILE_1(p, o, s) BOOST_PP_WHILE_1_C(BOOST_PP_BOOL(p##(2, s)), p, o, s) # define BOOST_PP_WHILE_2(p, o, s) BOOST_PP_WHILE_2_C(BOOST_PP_BOOL(p##(3, s)), p, o, s) # define BOOST_PP_WHILE_3(p, o, s) BOOST_PP_WHILE_3_C(BOOST_PP_BOOL(p##(4, s)), p, o, s) # define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_WHILE_4_C(BOOST_PP_BOOL(p##(5, s)), p, o, s) # define BOOST_PP_WHILE_5(p, o, s) BOOST_PP_WHILE_5_C(BOOST_PP_BOOL(p##(6, s)), p, o, s) # define BOOST_PP_WHILE_6(p, o, s) BOOST_PP_WHILE_6_C(BOOST_PP_BOOL(p##(7, s)), p, o, s) # define BOOST_PP_WHILE_7(p, o, s) BOOST_PP_WHILE_7_C(BOOST_PP_BOOL(p##(8, s)), p, o, s) # define BOOST_PP_WHILE_8(p, o, s) BOOST_PP_WHILE_8_C(BOOST_PP_BOOL(p##(9, s)), p, o, s) # define BOOST_PP_WHILE_9(p, o, s) BOOST_PP_WHILE_9_C(BOOST_PP_BOOL(p##(10, s)), p, o, s) # define BOOST_PP_WHILE_10(p, o, s) BOOST_PP_WHILE_10_C(BOOST_PP_BOOL(p##(11, s)), p, o, s) # define BOOST_PP_WHILE_11(p, o, s) BOOST_PP_WHILE_11_C(BOOST_PP_BOOL(p##(12, s)), p, o, s) # define BOOST_PP_WHILE_12(p, o, s) BOOST_PP_WHILE_12_C(BOOST_PP_BOOL(p##(13, s)), p, o, s) # define BOOST_PP_WHILE_13(p, o, s) BOOST_PP_WHILE_13_C(BOOST_PP_BOOL(p##(14, s)), p, o, s) # define BOOST_PP_WHILE_14(p, o, s) BOOST_PP_WHILE_14_C(BOOST_PP_BOOL(p##(15, s)), p, o, s) # define BOOST_PP_WHILE_15(p, o, s) BOOST_PP_WHILE_15_C(BOOST_PP_BOOL(p##(16, s)), p, o, s) # define BOOST_PP_WHILE_16(p, o, s) BOOST_PP_WHILE_16_C(BOOST_PP_BOOL(p##(17, s)), p, o, s) # define BOOST_PP_WHILE_17(p, o, s) BOOST_PP_WHILE_17_C(BOOST_PP_BOOL(p##(18, s)), p, o, s) # define BOOST_PP_WHILE_18(p, o, s) BOOST_PP_WHILE_18_C(BOOST_PP_BOOL(p##(19, s)), p, o, s) # define BOOST_PP_WHILE_19(p, o, s) BOOST_PP_WHILE_19_C(BOOST_PP_BOOL(p##(20, s)), p, o, s) # define BOOST_PP_WHILE_20(p, o, s) BOOST_PP_WHILE_20_C(BOOST_PP_BOOL(p##(21, s)), p, o, s) # define BOOST_PP_WHILE_21(p, o, s) BOOST_PP_WHILE_21_C(BOOST_PP_BOOL(p##(22, s)), p, o, s) # define BOOST_PP_WHILE_22(p, o, s) BOOST_PP_WHILE_22_C(BOOST_PP_BOOL(p##(23, s)), p, o, s) # define BOOST_PP_WHILE_23(p, o, s) BOOST_PP_WHILE_23_C(BOOST_PP_BOOL(p##(24, s)), p, o, s) # define BOOST_PP_WHILE_24(p, o, s) BOOST_PP_WHILE_24_C(BOOST_PP_BOOL(p##(25, s)), p, o, s) # define BOOST_PP_WHILE_25(p, o, s) BOOST_PP_WHILE_25_C(BOOST_PP_BOOL(p##(26, s)), p, o, s) # define BOOST_PP_WHILE_26(p, o, s) BOOST_PP_WHILE_26_C(BOOST_PP_BOOL(p##(27, s)), p, o, s) # define BOOST_PP_WHILE_27(p, o, s) BOOST_PP_WHILE_27_C(BOOST_PP_BOOL(p##(28, s)), p, o, s) # define BOOST_PP_WHILE_28(p, o, s) BOOST_PP_WHILE_28_C(BOOST_PP_BOOL(p##(29, s)), p, o, s) # define BOOST_PP_WHILE_29(p, o, s) BOOST_PP_WHILE_29_C(BOOST_PP_BOOL(p##(30, s)), p, o, s) # define BOOST_PP_WHILE_30(p, o, s) BOOST_PP_WHILE_30_C(BOOST_PP_BOOL(p##(31, s)), p, o, s) # define BOOST_PP_WHILE_31(p, o, s) BOOST_PP_WHILE_31_C(BOOST_PP_BOOL(p##(32, s)), p, o, s) # define BOOST_PP_WHILE_32(p, o, s) BOOST_PP_WHILE_32_C(BOOST_PP_BOOL(p##(33, s)), p, o, s) # define BOOST_PP_WHILE_33(p, o, s) BOOST_PP_WHILE_33_C(BOOST_PP_BOOL(p##(34, s)), p, o, s) # define BOOST_PP_WHILE_34(p, o, s) BOOST_PP_WHILE_34_C(BOOST_PP_BOOL(p##(35, s)), p, o, s) # define BOOST_PP_WHILE_35(p, o, s) BOOST_PP_WHILE_35_C(BOOST_PP_BOOL(p##(36, s)), p, o, s) # define BOOST_PP_WHILE_36(p, o, s) BOOST_PP_WHILE_36_C(BOOST_PP_BOOL(p##(37, s)), p, o, s) # define BOOST_PP_WHILE_37(p, o, s) BOOST_PP_WHILE_37_C(BOOST_PP_BOOL(p##(38, s)), p, o, s) # define BOOST_PP_WHILE_38(p, o, s) BOOST_PP_WHILE_38_C(BOOST_PP_BOOL(p##(39, s)), p, o, s) # define BOOST_PP_WHILE_39(p, o, s) BOOST_PP_WHILE_39_C(BOOST_PP_BOOL(p##(40, s)), p, o, s) # define BOOST_PP_WHILE_40(p, o, s) BOOST_PP_WHILE_40_C(BOOST_PP_BOOL(p##(41, s)), p, o, s) # define BOOST_PP_WHILE_41(p, o, s) BOOST_PP_WHILE_41_C(BOOST_PP_BOOL(p##(42, s)), p, o, s) # define BOOST_PP_WHILE_42(p, o, s) BOOST_PP_WHILE_42_C(BOOST_PP_BOOL(p##(43, s)), p, o, s) # define BOOST_PP_WHILE_43(p, o, s) BOOST_PP_WHILE_43_C(BOOST_PP_BOOL(p##(44, s)), p, o, s) # define BOOST_PP_WHILE_44(p, o, s) BOOST_PP_WHILE_44_C(BOOST_PP_BOOL(p##(45, s)), p, o, s) # define BOOST_PP_WHILE_45(p, o, s) BOOST_PP_WHILE_45_C(BOOST_PP_BOOL(p##(46, s)), p, o, s) # define BOOST_PP_WHILE_46(p, o, s) BOOST_PP_WHILE_46_C(BOOST_PP_BOOL(p##(47, s)), p, o, s) # define BOOST_PP_WHILE_47(p, o, s) BOOST_PP_WHILE_47_C(BOOST_PP_BOOL(p##(48, s)), p, o, s) # define BOOST_PP_WHILE_48(p, o, s) BOOST_PP_WHILE_48_C(BOOST_PP_BOOL(p##(49, s)), p, o, s) # define BOOST_PP_WHILE_49(p, o, s) BOOST_PP_WHILE_49_C(BOOST_PP_BOOL(p##(50, s)), p, o, s) # define BOOST_PP_WHILE_50(p, o, s) BOOST_PP_WHILE_50_C(BOOST_PP_BOOL(p##(51, s)), p, o, s) # define BOOST_PP_WHILE_51(p, o, s) BOOST_PP_WHILE_51_C(BOOST_PP_BOOL(p##(52, s)), p, o, s) # define BOOST_PP_WHILE_52(p, o, s) BOOST_PP_WHILE_52_C(BOOST_PP_BOOL(p##(53, s)), p, o, s) # define BOOST_PP_WHILE_53(p, o, s) BOOST_PP_WHILE_53_C(BOOST_PP_BOOL(p##(54, s)), p, o, s) # define BOOST_PP_WHILE_54(p, o, s) BOOST_PP_WHILE_54_C(BOOST_PP_BOOL(p##(55, s)), p, o, s) # define BOOST_PP_WHILE_55(p, o, s) BOOST_PP_WHILE_55_C(BOOST_PP_BOOL(p##(56, s)), p, o, s) # define BOOST_PP_WHILE_56(p, o, s) BOOST_PP_WHILE_56_C(BOOST_PP_BOOL(p##(57, s)), p, o, s) # define BOOST_PP_WHILE_57(p, o, s) BOOST_PP_WHILE_57_C(BOOST_PP_BOOL(p##(58, s)), p, o, s) # define BOOST_PP_WHILE_58(p, o, s) BOOST_PP_WHILE_58_C(BOOST_PP_BOOL(p##(59, s)), p, o, s) # define BOOST_PP_WHILE_59(p, o, s) BOOST_PP_WHILE_59_C(BOOST_PP_BOOL(p##(60, s)), p, o, s) # define BOOST_PP_WHILE_60(p, o, s) BOOST_PP_WHILE_60_C(BOOST_PP_BOOL(p##(61, s)), p, o, s) # define BOOST_PP_WHILE_61(p, o, s) BOOST_PP_WHILE_61_C(BOOST_PP_BOOL(p##(62, s)), p, o, s) # define BOOST_PP_WHILE_62(p, o, s) BOOST_PP_WHILE_62_C(BOOST_PP_BOOL(p##(63, s)), p, o, s) # define BOOST_PP_WHILE_63(p, o, s) BOOST_PP_WHILE_63_C(BOOST_PP_BOOL(p##(64, s)), p, o, s) # define BOOST_PP_WHILE_64(p, o, s) BOOST_PP_WHILE_64_C(BOOST_PP_BOOL(p##(65, s)), p, o, s) # define BOOST_PP_WHILE_65(p, o, s) BOOST_PP_WHILE_65_C(BOOST_PP_BOOL(p##(66, s)), p, o, s) # define BOOST_PP_WHILE_66(p, o, s) BOOST_PP_WHILE_66_C(BOOST_PP_BOOL(p##(67, s)), p, o, s) # define BOOST_PP_WHILE_67(p, o, s) BOOST_PP_WHILE_67_C(BOOST_PP_BOOL(p##(68, s)), p, o, s) # define BOOST_PP_WHILE_68(p, o, s) BOOST_PP_WHILE_68_C(BOOST_PP_BOOL(p##(69, s)), p, o, s) # define BOOST_PP_WHILE_69(p, o, s) BOOST_PP_WHILE_69_C(BOOST_PP_BOOL(p##(70, s)), p, o, s) # define BOOST_PP_WHILE_70(p, o, s) BOOST_PP_WHILE_70_C(BOOST_PP_BOOL(p##(71, s)), p, o, s) # define BOOST_PP_WHILE_71(p, o, s) BOOST_PP_WHILE_71_C(BOOST_PP_BOOL(p##(72, s)), p, o, s) # define BOOST_PP_WHILE_72(p, o, s) BOOST_PP_WHILE_72_C(BOOST_PP_BOOL(p##(73, s)), p, o, s) # define BOOST_PP_WHILE_73(p, o, s) BOOST_PP_WHILE_73_C(BOOST_PP_BOOL(p##(74, s)), p, o, s) # define BOOST_PP_WHILE_74(p, o, s) BOOST_PP_WHILE_74_C(BOOST_PP_BOOL(p##(75, s)), p, o, s) # define BOOST_PP_WHILE_75(p, o, s) BOOST_PP_WHILE_75_C(BOOST_PP_BOOL(p##(76, s)), p, o, s) # define BOOST_PP_WHILE_76(p, o, s) BOOST_PP_WHILE_76_C(BOOST_PP_BOOL(p##(77, s)), p, o, s) # define BOOST_PP_WHILE_77(p, o, s) BOOST_PP_WHILE_77_C(BOOST_PP_BOOL(p##(78, s)), p, o, s) # define BOOST_PP_WHILE_78(p, o, s) BOOST_PP_WHILE_78_C(BOOST_PP_BOOL(p##(79, s)), p, o, s) # define BOOST_PP_WHILE_79(p, o, s) BOOST_PP_WHILE_79_C(BOOST_PP_BOOL(p##(80, s)), p, o, s) # define BOOST_PP_WHILE_80(p, o, s) BOOST_PP_WHILE_80_C(BOOST_PP_BOOL(p##(81, s)), p, o, s) # define BOOST_PP_WHILE_81(p, o, s) BOOST_PP_WHILE_81_C(BOOST_PP_BOOL(p##(82, s)), p, o, s) # define BOOST_PP_WHILE_82(p, o, s) BOOST_PP_WHILE_82_C(BOOST_PP_BOOL(p##(83, s)), p, o, s) # define BOOST_PP_WHILE_83(p, o, s) BOOST_PP_WHILE_83_C(BOOST_PP_BOOL(p##(84, s)), p, o, s) # define BOOST_PP_WHILE_84(p, o, s) BOOST_PP_WHILE_84_C(BOOST_PP_BOOL(p##(85, s)), p, o, s) # define BOOST_PP_WHILE_85(p, o, s) BOOST_PP_WHILE_85_C(BOOST_PP_BOOL(p##(86, s)), p, o, s) # define BOOST_PP_WHILE_86(p, o, s) BOOST_PP_WHILE_86_C(BOOST_PP_BOOL(p##(87, s)), p, o, s) # define BOOST_PP_WHILE_87(p, o, s) BOOST_PP_WHILE_87_C(BOOST_PP_BOOL(p##(88, s)), p, o, s) # define BOOST_PP_WHILE_88(p, o, s) BOOST_PP_WHILE_88_C(BOOST_PP_BOOL(p##(89, s)), p, o, s) # define BOOST_PP_WHILE_89(p, o, s) BOOST_PP_WHILE_89_C(BOOST_PP_BOOL(p##(90, s)), p, o, s) # define BOOST_PP_WHILE_90(p, o, s) BOOST_PP_WHILE_90_C(BOOST_PP_BOOL(p##(91, s)), p, o, s) # define BOOST_PP_WHILE_91(p, o, s) BOOST_PP_WHILE_91_C(BOOST_PP_BOOL(p##(92, s)), p, o, s) # define BOOST_PP_WHILE_92(p, o, s) BOOST_PP_WHILE_92_C(BOOST_PP_BOOL(p##(93, s)), p, o, s) # define BOOST_PP_WHILE_93(p, o, s) BOOST_PP_WHILE_93_C(BOOST_PP_BOOL(p##(94, s)), p, o, s) # define BOOST_PP_WHILE_94(p, o, s) BOOST_PP_WHILE_94_C(BOOST_PP_BOOL(p##(95, s)), p, o, s) # define BOOST_PP_WHILE_95(p, o, s) BOOST_PP_WHILE_95_C(BOOST_PP_BOOL(p##(96, s)), p, o, s) # define BOOST_PP_WHILE_96(p, o, s) BOOST_PP_WHILE_96_C(BOOST_PP_BOOL(p##(97, s)), p, o, s) # define BOOST_PP_WHILE_97(p, o, s) BOOST_PP_WHILE_97_C(BOOST_PP_BOOL(p##(98, s)), p, o, s) # define BOOST_PP_WHILE_98(p, o, s) BOOST_PP_WHILE_98_C(BOOST_PP_BOOL(p##(99, s)), p, o, s) # define BOOST_PP_WHILE_99(p, o, s) BOOST_PP_WHILE_99_C(BOOST_PP_BOOL(p##(100, s)), p, o, s) # define BOOST_PP_WHILE_100(p, o, s) BOOST_PP_WHILE_100_C(BOOST_PP_BOOL(p##(101, s)), p, o, s) # define BOOST_PP_WHILE_101(p, o, s) BOOST_PP_WHILE_101_C(BOOST_PP_BOOL(p##(102, s)), p, o, s) # define BOOST_PP_WHILE_102(p, o, s) BOOST_PP_WHILE_102_C(BOOST_PP_BOOL(p##(103, s)), p, o, s) # define BOOST_PP_WHILE_103(p, o, s) BOOST_PP_WHILE_103_C(BOOST_PP_BOOL(p##(104, s)), p, o, s) # define BOOST_PP_WHILE_104(p, o, s) BOOST_PP_WHILE_104_C(BOOST_PP_BOOL(p##(105, s)), p, o, s) # define BOOST_PP_WHILE_105(p, o, s) BOOST_PP_WHILE_105_C(BOOST_PP_BOOL(p##(106, s)), p, o, s) # define BOOST_PP_WHILE_106(p, o, s) BOOST_PP_WHILE_106_C(BOOST_PP_BOOL(p##(107, s)), p, o, s) # define BOOST_PP_WHILE_107(p, o, s) BOOST_PP_WHILE_107_C(BOOST_PP_BOOL(p##(108, s)), p, o, s) # define BOOST_PP_WHILE_108(p, o, s) BOOST_PP_WHILE_108_C(BOOST_PP_BOOL(p##(109, s)), p, o, s) # define BOOST_PP_WHILE_109(p, o, s) BOOST_PP_WHILE_109_C(BOOST_PP_BOOL(p##(110, s)), p, o, s) # define BOOST_PP_WHILE_110(p, o, s) BOOST_PP_WHILE_110_C(BOOST_PP_BOOL(p##(111, s)), p, o, s) # define BOOST_PP_WHILE_111(p, o, s) BOOST_PP_WHILE_111_C(BOOST_PP_BOOL(p##(112, s)), p, o, s) # define BOOST_PP_WHILE_112(p, o, s) BOOST_PP_WHILE_112_C(BOOST_PP_BOOL(p##(113, s)), p, o, s) # define BOOST_PP_WHILE_113(p, o, s) BOOST_PP_WHILE_113_C(BOOST_PP_BOOL(p##(114, s)), p, o, s) # define BOOST_PP_WHILE_114(p, o, s) BOOST_PP_WHILE_114_C(BOOST_PP_BOOL(p##(115, s)), p, o, s) # define BOOST_PP_WHILE_115(p, o, s) BOOST_PP_WHILE_115_C(BOOST_PP_BOOL(p##(116, s)), p, o, s) # define BOOST_PP_WHILE_116(p, o, s) BOOST_PP_WHILE_116_C(BOOST_PP_BOOL(p##(117, s)), p, o, s) # define BOOST_PP_WHILE_117(p, o, s) BOOST_PP_WHILE_117_C(BOOST_PP_BOOL(p##(118, s)), p, o, s) # define BOOST_PP_WHILE_118(p, o, s) BOOST_PP_WHILE_118_C(BOOST_PP_BOOL(p##(119, s)), p, o, s) # define BOOST_PP_WHILE_119(p, o, s) BOOST_PP_WHILE_119_C(BOOST_PP_BOOL(p##(120, s)), p, o, s) # define BOOST_PP_WHILE_120(p, o, s) BOOST_PP_WHILE_120_C(BOOST_PP_BOOL(p##(121, s)), p, o, s) # define BOOST_PP_WHILE_121(p, o, s) BOOST_PP_WHILE_121_C(BOOST_PP_BOOL(p##(122, s)), p, o, s) # define BOOST_PP_WHILE_122(p, o, s) BOOST_PP_WHILE_122_C(BOOST_PP_BOOL(p##(123, s)), p, o, s) # define BOOST_PP_WHILE_123(p, o, s) BOOST_PP_WHILE_123_C(BOOST_PP_BOOL(p##(124, s)), p, o, s) # define BOOST_PP_WHILE_124(p, o, s) BOOST_PP_WHILE_124_C(BOOST_PP_BOOL(p##(125, s)), p, o, s) # define BOOST_PP_WHILE_125(p, o, s) BOOST_PP_WHILE_125_C(BOOST_PP_BOOL(p##(126, s)), p, o, s) # define BOOST_PP_WHILE_126(p, o, s) BOOST_PP_WHILE_126_C(BOOST_PP_BOOL(p##(127, s)), p, o, s) # define BOOST_PP_WHILE_127(p, o, s) BOOST_PP_WHILE_127_C(BOOST_PP_BOOL(p##(128, s)), p, o, s) # define BOOST_PP_WHILE_128(p, o, s) BOOST_PP_WHILE_128_C(BOOST_PP_BOOL(p##(129, s)), p, o, s) # define BOOST_PP_WHILE_129(p, o, s) BOOST_PP_WHILE_129_C(BOOST_PP_BOOL(p##(130, s)), p, o, s) # define BOOST_PP_WHILE_130(p, o, s) BOOST_PP_WHILE_130_C(BOOST_PP_BOOL(p##(131, s)), p, o, s) # define BOOST_PP_WHILE_131(p, o, s) BOOST_PP_WHILE_131_C(BOOST_PP_BOOL(p##(132, s)), p, o, s) # define BOOST_PP_WHILE_132(p, o, s) BOOST_PP_WHILE_132_C(BOOST_PP_BOOL(p##(133, s)), p, o, s) # define BOOST_PP_WHILE_133(p, o, s) BOOST_PP_WHILE_133_C(BOOST_PP_BOOL(p##(134, s)), p, o, s) # define BOOST_PP_WHILE_134(p, o, s) BOOST_PP_WHILE_134_C(BOOST_PP_BOOL(p##(135, s)), p, o, s) # define BOOST_PP_WHILE_135(p, o, s) BOOST_PP_WHILE_135_C(BOOST_PP_BOOL(p##(136, s)), p, o, s) # define BOOST_PP_WHILE_136(p, o, s) BOOST_PP_WHILE_136_C(BOOST_PP_BOOL(p##(137, s)), p, o, s) # define BOOST_PP_WHILE_137(p, o, s) BOOST_PP_WHILE_137_C(BOOST_PP_BOOL(p##(138, s)), p, o, s) # define BOOST_PP_WHILE_138(p, o, s) BOOST_PP_WHILE_138_C(BOOST_PP_BOOL(p##(139, s)), p, o, s) # define BOOST_PP_WHILE_139(p, o, s) BOOST_PP_WHILE_139_C(BOOST_PP_BOOL(p##(140, s)), p, o, s) # define BOOST_PP_WHILE_140(p, o, s) BOOST_PP_WHILE_140_C(BOOST_PP_BOOL(p##(141, s)), p, o, s) # define BOOST_PP_WHILE_141(p, o, s) BOOST_PP_WHILE_141_C(BOOST_PP_BOOL(p##(142, s)), p, o, s) # define BOOST_PP_WHILE_142(p, o, s) BOOST_PP_WHILE_142_C(BOOST_PP_BOOL(p##(143, s)), p, o, s) # define BOOST_PP_WHILE_143(p, o, s) BOOST_PP_WHILE_143_C(BOOST_PP_BOOL(p##(144, s)), p, o, s) # define BOOST_PP_WHILE_144(p, o, s) BOOST_PP_WHILE_144_C(BOOST_PP_BOOL(p##(145, s)), p, o, s) # define BOOST_PP_WHILE_145(p, o, s) BOOST_PP_WHILE_145_C(BOOST_PP_BOOL(p##(146, s)), p, o, s) # define BOOST_PP_WHILE_146(p, o, s) BOOST_PP_WHILE_146_C(BOOST_PP_BOOL(p##(147, s)), p, o, s) # define BOOST_PP_WHILE_147(p, o, s) BOOST_PP_WHILE_147_C(BOOST_PP_BOOL(p##(148, s)), p, o, s) # define BOOST_PP_WHILE_148(p, o, s) BOOST_PP_WHILE_148_C(BOOST_PP_BOOL(p##(149, s)), p, o, s) # define BOOST_PP_WHILE_149(p, o, s) BOOST_PP_WHILE_149_C(BOOST_PP_BOOL(p##(150, s)), p, o, s) # define BOOST_PP_WHILE_150(p, o, s) BOOST_PP_WHILE_150_C(BOOST_PP_BOOL(p##(151, s)), p, o, s) # define BOOST_PP_WHILE_151(p, o, s) BOOST_PP_WHILE_151_C(BOOST_PP_BOOL(p##(152, s)), p, o, s) # define BOOST_PP_WHILE_152(p, o, s) BOOST_PP_WHILE_152_C(BOOST_PP_BOOL(p##(153, s)), p, o, s) # define BOOST_PP_WHILE_153(p, o, s) BOOST_PP_WHILE_153_C(BOOST_PP_BOOL(p##(154, s)), p, o, s) # define BOOST_PP_WHILE_154(p, o, s) BOOST_PP_WHILE_154_C(BOOST_PP_BOOL(p##(155, s)), p, o, s) # define BOOST_PP_WHILE_155(p, o, s) BOOST_PP_WHILE_155_C(BOOST_PP_BOOL(p##(156, s)), p, o, s) # define BOOST_PP_WHILE_156(p, o, s) BOOST_PP_WHILE_156_C(BOOST_PP_BOOL(p##(157, s)), p, o, s) # define BOOST_PP_WHILE_157(p, o, s) BOOST_PP_WHILE_157_C(BOOST_PP_BOOL(p##(158, s)), p, o, s) # define BOOST_PP_WHILE_158(p, o, s) BOOST_PP_WHILE_158_C(BOOST_PP_BOOL(p##(159, s)), p, o, s) # define BOOST_PP_WHILE_159(p, o, s) BOOST_PP_WHILE_159_C(BOOST_PP_BOOL(p##(160, s)), p, o, s) # define BOOST_PP_WHILE_160(p, o, s) BOOST_PP_WHILE_160_C(BOOST_PP_BOOL(p##(161, s)), p, o, s) # define BOOST_PP_WHILE_161(p, o, s) BOOST_PP_WHILE_161_C(BOOST_PP_BOOL(p##(162, s)), p, o, s) # define BOOST_PP_WHILE_162(p, o, s) BOOST_PP_WHILE_162_C(BOOST_PP_BOOL(p##(163, s)), p, o, s) # define BOOST_PP_WHILE_163(p, o, s) BOOST_PP_WHILE_163_C(BOOST_PP_BOOL(p##(164, s)), p, o, s) # define BOOST_PP_WHILE_164(p, o, s) BOOST_PP_WHILE_164_C(BOOST_PP_BOOL(p##(165, s)), p, o, s) # define BOOST_PP_WHILE_165(p, o, s) BOOST_PP_WHILE_165_C(BOOST_PP_BOOL(p##(166, s)), p, o, s) # define BOOST_PP_WHILE_166(p, o, s) BOOST_PP_WHILE_166_C(BOOST_PP_BOOL(p##(167, s)), p, o, s) # define BOOST_PP_WHILE_167(p, o, s) BOOST_PP_WHILE_167_C(BOOST_PP_BOOL(p##(168, s)), p, o, s) # define BOOST_PP_WHILE_168(p, o, s) BOOST_PP_WHILE_168_C(BOOST_PP_BOOL(p##(169, s)), p, o, s) # define BOOST_PP_WHILE_169(p, o, s) BOOST_PP_WHILE_169_C(BOOST_PP_BOOL(p##(170, s)), p, o, s) # define BOOST_PP_WHILE_170(p, o, s) BOOST_PP_WHILE_170_C(BOOST_PP_BOOL(p##(171, s)), p, o, s) # define BOOST_PP_WHILE_171(p, o, s) BOOST_PP_WHILE_171_C(BOOST_PP_BOOL(p##(172, s)), p, o, s) # define BOOST_PP_WHILE_172(p, o, s) BOOST_PP_WHILE_172_C(BOOST_PP_BOOL(p##(173, s)), p, o, s) # define BOOST_PP_WHILE_173(p, o, s) BOOST_PP_WHILE_173_C(BOOST_PP_BOOL(p##(174, s)), p, o, s) # define BOOST_PP_WHILE_174(p, o, s) BOOST_PP_WHILE_174_C(BOOST_PP_BOOL(p##(175, s)), p, o, s) # define BOOST_PP_WHILE_175(p, o, s) BOOST_PP_WHILE_175_C(BOOST_PP_BOOL(p##(176, s)), p, o, s) # define BOOST_PP_WHILE_176(p, o, s) BOOST_PP_WHILE_176_C(BOOST_PP_BOOL(p##(177, s)), p, o, s) # define BOOST_PP_WHILE_177(p, o, s) BOOST_PP_WHILE_177_C(BOOST_PP_BOOL(p##(178, s)), p, o, s) # define BOOST_PP_WHILE_178(p, o, s) BOOST_PP_WHILE_178_C(BOOST_PP_BOOL(p##(179, s)), p, o, s) # define BOOST_PP_WHILE_179(p, o, s) BOOST_PP_WHILE_179_C(BOOST_PP_BOOL(p##(180, s)), p, o, s) # define BOOST_PP_WHILE_180(p, o, s) BOOST_PP_WHILE_180_C(BOOST_PP_BOOL(p##(181, s)), p, o, s) # define BOOST_PP_WHILE_181(p, o, s) BOOST_PP_WHILE_181_C(BOOST_PP_BOOL(p##(182, s)), p, o, s) # define BOOST_PP_WHILE_182(p, o, s) BOOST_PP_WHILE_182_C(BOOST_PP_BOOL(p##(183, s)), p, o, s) # define BOOST_PP_WHILE_183(p, o, s) BOOST_PP_WHILE_183_C(BOOST_PP_BOOL(p##(184, s)), p, o, s) # define BOOST_PP_WHILE_184(p, o, s) BOOST_PP_WHILE_184_C(BOOST_PP_BOOL(p##(185, s)), p, o, s) # define BOOST_PP_WHILE_185(p, o, s) BOOST_PP_WHILE_185_C(BOOST_PP_BOOL(p##(186, s)), p, o, s) # define BOOST_PP_WHILE_186(p, o, s) BOOST_PP_WHILE_186_C(BOOST_PP_BOOL(p##(187, s)), p, o, s) # define BOOST_PP_WHILE_187(p, o, s) BOOST_PP_WHILE_187_C(BOOST_PP_BOOL(p##(188, s)), p, o, s) # define BOOST_PP_WHILE_188(p, o, s) BOOST_PP_WHILE_188_C(BOOST_PP_BOOL(p##(189, s)), p, o, s) # define BOOST_PP_WHILE_189(p, o, s) BOOST_PP_WHILE_189_C(BOOST_PP_BOOL(p##(190, s)), p, o, s) # define BOOST_PP_WHILE_190(p, o, s) BOOST_PP_WHILE_190_C(BOOST_PP_BOOL(p##(191, s)), p, o, s) # define BOOST_PP_WHILE_191(p, o, s) BOOST_PP_WHILE_191_C(BOOST_PP_BOOL(p##(192, s)), p, o, s) # define BOOST_PP_WHILE_192(p, o, s) BOOST_PP_WHILE_192_C(BOOST_PP_BOOL(p##(193, s)), p, o, s) # define BOOST_PP_WHILE_193(p, o, s) BOOST_PP_WHILE_193_C(BOOST_PP_BOOL(p##(194, s)), p, o, s) # define BOOST_PP_WHILE_194(p, o, s) BOOST_PP_WHILE_194_C(BOOST_PP_BOOL(p##(195, s)), p, o, s) # define BOOST_PP_WHILE_195(p, o, s) BOOST_PP_WHILE_195_C(BOOST_PP_BOOL(p##(196, s)), p, o, s) # define BOOST_PP_WHILE_196(p, o, s) BOOST_PP_WHILE_196_C(BOOST_PP_BOOL(p##(197, s)), p, o, s) # define BOOST_PP_WHILE_197(p, o, s) BOOST_PP_WHILE_197_C(BOOST_PP_BOOL(p##(198, s)), p, o, s) # define BOOST_PP_WHILE_198(p, o, s) BOOST_PP_WHILE_198_C(BOOST_PP_BOOL(p##(199, s)), p, o, s) # define BOOST_PP_WHILE_199(p, o, s) BOOST_PP_WHILE_199_C(BOOST_PP_BOOL(p##(200, s)), p, o, s) # define BOOST_PP_WHILE_200(p, o, s) BOOST_PP_WHILE_200_C(BOOST_PP_BOOL(p##(201, s)), p, o, s) # define BOOST_PP_WHILE_201(p, o, s) BOOST_PP_WHILE_201_C(BOOST_PP_BOOL(p##(202, s)), p, o, s) # define BOOST_PP_WHILE_202(p, o, s) BOOST_PP_WHILE_202_C(BOOST_PP_BOOL(p##(203, s)), p, o, s) # define BOOST_PP_WHILE_203(p, o, s) BOOST_PP_WHILE_203_C(BOOST_PP_BOOL(p##(204, s)), p, o, s) # define BOOST_PP_WHILE_204(p, o, s) BOOST_PP_WHILE_204_C(BOOST_PP_BOOL(p##(205, s)), p, o, s) # define BOOST_PP_WHILE_205(p, o, s) BOOST_PP_WHILE_205_C(BOOST_PP_BOOL(p##(206, s)), p, o, s) # define BOOST_PP_WHILE_206(p, o, s) BOOST_PP_WHILE_206_C(BOOST_PP_BOOL(p##(207, s)), p, o, s) # define BOOST_PP_WHILE_207(p, o, s) BOOST_PP_WHILE_207_C(BOOST_PP_BOOL(p##(208, s)), p, o, s) # define BOOST_PP_WHILE_208(p, o, s) BOOST_PP_WHILE_208_C(BOOST_PP_BOOL(p##(209, s)), p, o, s) # define BOOST_PP_WHILE_209(p, o, s) BOOST_PP_WHILE_209_C(BOOST_PP_BOOL(p##(210, s)), p, o, s) # define BOOST_PP_WHILE_210(p, o, s) BOOST_PP_WHILE_210_C(BOOST_PP_BOOL(p##(211, s)), p, o, s) # define BOOST_PP_WHILE_211(p, o, s) BOOST_PP_WHILE_211_C(BOOST_PP_BOOL(p##(212, s)), p, o, s) # define BOOST_PP_WHILE_212(p, o, s) BOOST_PP_WHILE_212_C(BOOST_PP_BOOL(p##(213, s)), p, o, s) # define BOOST_PP_WHILE_213(p, o, s) BOOST_PP_WHILE_213_C(BOOST_PP_BOOL(p##(214, s)), p, o, s) # define BOOST_PP_WHILE_214(p, o, s) BOOST_PP_WHILE_214_C(BOOST_PP_BOOL(p##(215, s)), p, o, s) # define BOOST_PP_WHILE_215(p, o, s) BOOST_PP_WHILE_215_C(BOOST_PP_BOOL(p##(216, s)), p, o, s) # define BOOST_PP_WHILE_216(p, o, s) BOOST_PP_WHILE_216_C(BOOST_PP_BOOL(p##(217, s)), p, o, s) # define BOOST_PP_WHILE_217(p, o, s) BOOST_PP_WHILE_217_C(BOOST_PP_BOOL(p##(218, s)), p, o, s) # define BOOST_PP_WHILE_218(p, o, s) BOOST_PP_WHILE_218_C(BOOST_PP_BOOL(p##(219, s)), p, o, s) # define BOOST_PP_WHILE_219(p, o, s) BOOST_PP_WHILE_219_C(BOOST_PP_BOOL(p##(220, s)), p, o, s) # define BOOST_PP_WHILE_220(p, o, s) BOOST_PP_WHILE_220_C(BOOST_PP_BOOL(p##(221, s)), p, o, s) # define BOOST_PP_WHILE_221(p, o, s) BOOST_PP_WHILE_221_C(BOOST_PP_BOOL(p##(222, s)), p, o, s) # define BOOST_PP_WHILE_222(p, o, s) BOOST_PP_WHILE_222_C(BOOST_PP_BOOL(p##(223, s)), p, o, s) # define BOOST_PP_WHILE_223(p, o, s) BOOST_PP_WHILE_223_C(BOOST_PP_BOOL(p##(224, s)), p, o, s) # define BOOST_PP_WHILE_224(p, o, s) BOOST_PP_WHILE_224_C(BOOST_PP_BOOL(p##(225, s)), p, o, s) # define BOOST_PP_WHILE_225(p, o, s) BOOST_PP_WHILE_225_C(BOOST_PP_BOOL(p##(226, s)), p, o, s) # define BOOST_PP_WHILE_226(p, o, s) BOOST_PP_WHILE_226_C(BOOST_PP_BOOL(p##(227, s)), p, o, s) # define BOOST_PP_WHILE_227(p, o, s) BOOST_PP_WHILE_227_C(BOOST_PP_BOOL(p##(228, s)), p, o, s) # define BOOST_PP_WHILE_228(p, o, s) BOOST_PP_WHILE_228_C(BOOST_PP_BOOL(p##(229, s)), p, o, s) # define BOOST_PP_WHILE_229(p, o, s) BOOST_PP_WHILE_229_C(BOOST_PP_BOOL(p##(230, s)), p, o, s) # define BOOST_PP_WHILE_230(p, o, s) BOOST_PP_WHILE_230_C(BOOST_PP_BOOL(p##(231, s)), p, o, s) # define BOOST_PP_WHILE_231(p, o, s) BOOST_PP_WHILE_231_C(BOOST_PP_BOOL(p##(232, s)), p, o, s) # define BOOST_PP_WHILE_232(p, o, s) BOOST_PP_WHILE_232_C(BOOST_PP_BOOL(p##(233, s)), p, o, s) # define BOOST_PP_WHILE_233(p, o, s) BOOST_PP_WHILE_233_C(BOOST_PP_BOOL(p##(234, s)), p, o, s) # define BOOST_PP_WHILE_234(p, o, s) BOOST_PP_WHILE_234_C(BOOST_PP_BOOL(p##(235, s)), p, o, s) # define BOOST_PP_WHILE_235(p, o, s) BOOST_PP_WHILE_235_C(BOOST_PP_BOOL(p##(236, s)), p, o, s) # define BOOST_PP_WHILE_236(p, o, s) BOOST_PP_WHILE_236_C(BOOST_PP_BOOL(p##(237, s)), p, o, s) # define BOOST_PP_WHILE_237(p, o, s) BOOST_PP_WHILE_237_C(BOOST_PP_BOOL(p##(238, s)), p, o, s) # define BOOST_PP_WHILE_238(p, o, s) BOOST_PP_WHILE_238_C(BOOST_PP_BOOL(p##(239, s)), p, o, s) # define BOOST_PP_WHILE_239(p, o, s) BOOST_PP_WHILE_239_C(BOOST_PP_BOOL(p##(240, s)), p, o, s) # define BOOST_PP_WHILE_240(p, o, s) BOOST_PP_WHILE_240_C(BOOST_PP_BOOL(p##(241, s)), p, o, s) # define BOOST_PP_WHILE_241(p, o, s) BOOST_PP_WHILE_241_C(BOOST_PP_BOOL(p##(242, s)), p, o, s) # define BOOST_PP_WHILE_242(p, o, s) BOOST_PP_WHILE_242_C(BOOST_PP_BOOL(p##(243, s)), p, o, s) # define BOOST_PP_WHILE_243(p, o, s) BOOST_PP_WHILE_243_C(BOOST_PP_BOOL(p##(244, s)), p, o, s) # define BOOST_PP_WHILE_244(p, o, s) BOOST_PP_WHILE_244_C(BOOST_PP_BOOL(p##(245, s)), p, o, s) # define BOOST_PP_WHILE_245(p, o, s) BOOST_PP_WHILE_245_C(BOOST_PP_BOOL(p##(246, s)), p, o, s) # define BOOST_PP_WHILE_246(p, o, s) BOOST_PP_WHILE_246_C(BOOST_PP_BOOL(p##(247, s)), p, o, s) # define BOOST_PP_WHILE_247(p, o, s) BOOST_PP_WHILE_247_C(BOOST_PP_BOOL(p##(248, s)), p, o, s) # define BOOST_PP_WHILE_248(p, o, s) BOOST_PP_WHILE_248_C(BOOST_PP_BOOL(p##(249, s)), p, o, s) # define BOOST_PP_WHILE_249(p, o, s) BOOST_PP_WHILE_249_C(BOOST_PP_BOOL(p##(250, s)), p, o, s) # define BOOST_PP_WHILE_250(p, o, s) BOOST_PP_WHILE_250_C(BOOST_PP_BOOL(p##(251, s)), p, o, s) # define BOOST_PP_WHILE_251(p, o, s) BOOST_PP_WHILE_251_C(BOOST_PP_BOOL(p##(252, s)), p, o, s) # define BOOST_PP_WHILE_252(p, o, s) BOOST_PP_WHILE_252_C(BOOST_PP_BOOL(p##(253, s)), p, o, s) # define BOOST_PP_WHILE_253(p, o, s) BOOST_PP_WHILE_253_C(BOOST_PP_BOOL(p##(254, s)), p, o, s) # define BOOST_PP_WHILE_254(p, o, s) BOOST_PP_WHILE_254_C(BOOST_PP_BOOL(p##(255, s)), p, o, s) # define BOOST_PP_WHILE_255(p, o, s) BOOST_PP_WHILE_255_C(BOOST_PP_BOOL(p##(256, s)), p, o, s) # define BOOST_PP_WHILE_256(p, o, s) BOOST_PP_WHILE_256_C(BOOST_PP_BOOL(p##(257, s)), p, o, s) # # define BOOST_PP_WHILE_1_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_2, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(2, s)) # define BOOST_PP_WHILE_2_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_3, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(3, s)) # define BOOST_PP_WHILE_3_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_4, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(4, s)) # define BOOST_PP_WHILE_4_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_5, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(5, s)) # define BOOST_PP_WHILE_5_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_6, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(6, s)) # define BOOST_PP_WHILE_6_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_7, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(7, s)) # define BOOST_PP_WHILE_7_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_8, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(8, s)) # define BOOST_PP_WHILE_8_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_9, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(9, s)) # define BOOST_PP_WHILE_9_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_10, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(10, s)) # define BOOST_PP_WHILE_10_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_11, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(11, s)) # define BOOST_PP_WHILE_11_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_12, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(12, s)) # define BOOST_PP_WHILE_12_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_13, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(13, s)) # define BOOST_PP_WHILE_13_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_14, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(14, s)) # define BOOST_PP_WHILE_14_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_15, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(15, s)) # define BOOST_PP_WHILE_15_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_16, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(16, s)) # define BOOST_PP_WHILE_16_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_17, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(17, s)) # define BOOST_PP_WHILE_17_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_18, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(18, s)) # define BOOST_PP_WHILE_18_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_19, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(19, s)) # define BOOST_PP_WHILE_19_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_20, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(20, s)) # define BOOST_PP_WHILE_20_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_21, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(21, s)) # define BOOST_PP_WHILE_21_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_22, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(22, s)) # define BOOST_PP_WHILE_22_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_23, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(23, s)) # define BOOST_PP_WHILE_23_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_24, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(24, s)) # define BOOST_PP_WHILE_24_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_25, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(25, s)) # define BOOST_PP_WHILE_25_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_26, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(26, s)) # define BOOST_PP_WHILE_26_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_27, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(27, s)) # define BOOST_PP_WHILE_27_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_28, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(28, s)) # define BOOST_PP_WHILE_28_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_29, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(29, s)) # define BOOST_PP_WHILE_29_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_30, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(30, s)) # define BOOST_PP_WHILE_30_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_31, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(31, s)) # define BOOST_PP_WHILE_31_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_32, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(32, s)) # define BOOST_PP_WHILE_32_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_33, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(33, s)) # define BOOST_PP_WHILE_33_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_34, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(34, s)) # define BOOST_PP_WHILE_34_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_35, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(35, s)) # define BOOST_PP_WHILE_35_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_36, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(36, s)) # define BOOST_PP_WHILE_36_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_37, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(37, s)) # define BOOST_PP_WHILE_37_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_38, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(38, s)) # define BOOST_PP_WHILE_38_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_39, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(39, s)) # define BOOST_PP_WHILE_39_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_40, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(40, s)) # define BOOST_PP_WHILE_40_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_41, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(41, s)) # define BOOST_PP_WHILE_41_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_42, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(42, s)) # define BOOST_PP_WHILE_42_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_43, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(43, s)) # define BOOST_PP_WHILE_43_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_44, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(44, s)) # define BOOST_PP_WHILE_44_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_45, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(45, s)) # define BOOST_PP_WHILE_45_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_46, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(46, s)) # define BOOST_PP_WHILE_46_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_47, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(47, s)) # define BOOST_PP_WHILE_47_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_48, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(48, s)) # define BOOST_PP_WHILE_48_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_49, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(49, s)) # define BOOST_PP_WHILE_49_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_50, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(50, s)) # define BOOST_PP_WHILE_50_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_51, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(51, s)) # define BOOST_PP_WHILE_51_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_52, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(52, s)) # define BOOST_PP_WHILE_52_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_53, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(53, s)) # define BOOST_PP_WHILE_53_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_54, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(54, s)) # define BOOST_PP_WHILE_54_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_55, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(55, s)) # define BOOST_PP_WHILE_55_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_56, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(56, s)) # define BOOST_PP_WHILE_56_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_57, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(57, s)) # define BOOST_PP_WHILE_57_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_58, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(58, s)) # define BOOST_PP_WHILE_58_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_59, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(59, s)) # define BOOST_PP_WHILE_59_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_60, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(60, s)) # define BOOST_PP_WHILE_60_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_61, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(61, s)) # define BOOST_PP_WHILE_61_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_62, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(62, s)) # define BOOST_PP_WHILE_62_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_63, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(63, s)) # define BOOST_PP_WHILE_63_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_64, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(64, s)) # define BOOST_PP_WHILE_64_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_65, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(65, s)) # define BOOST_PP_WHILE_65_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_66, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(66, s)) # define BOOST_PP_WHILE_66_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_67, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(67, s)) # define BOOST_PP_WHILE_67_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_68, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(68, s)) # define BOOST_PP_WHILE_68_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_69, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(69, s)) # define BOOST_PP_WHILE_69_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_70, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(70, s)) # define BOOST_PP_WHILE_70_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_71, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(71, s)) # define BOOST_PP_WHILE_71_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_72, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(72, s)) # define BOOST_PP_WHILE_72_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_73, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(73, s)) # define BOOST_PP_WHILE_73_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_74, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(74, s)) # define BOOST_PP_WHILE_74_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_75, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(75, s)) # define BOOST_PP_WHILE_75_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_76, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(76, s)) # define BOOST_PP_WHILE_76_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_77, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(77, s)) # define BOOST_PP_WHILE_77_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_78, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(78, s)) # define BOOST_PP_WHILE_78_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_79, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(79, s)) # define BOOST_PP_WHILE_79_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_80, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(80, s)) # define BOOST_PP_WHILE_80_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_81, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(81, s)) # define BOOST_PP_WHILE_81_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_82, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(82, s)) # define BOOST_PP_WHILE_82_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_83, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(83, s)) # define BOOST_PP_WHILE_83_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_84, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(84, s)) # define BOOST_PP_WHILE_84_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_85, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(85, s)) # define BOOST_PP_WHILE_85_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_86, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(86, s)) # define BOOST_PP_WHILE_86_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_87, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(87, s)) # define BOOST_PP_WHILE_87_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_88, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(88, s)) # define BOOST_PP_WHILE_88_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_89, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(89, s)) # define BOOST_PP_WHILE_89_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_90, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(90, s)) # define BOOST_PP_WHILE_90_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_91, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(91, s)) # define BOOST_PP_WHILE_91_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_92, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(92, s)) # define BOOST_PP_WHILE_92_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_93, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(93, s)) # define BOOST_PP_WHILE_93_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_94, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(94, s)) # define BOOST_PP_WHILE_94_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_95, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(95, s)) # define BOOST_PP_WHILE_95_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_96, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(96, s)) # define BOOST_PP_WHILE_96_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_97, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(97, s)) # define BOOST_PP_WHILE_97_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_98, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(98, s)) # define BOOST_PP_WHILE_98_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_99, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(99, s)) # define BOOST_PP_WHILE_99_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_100, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(100, s)) # define BOOST_PP_WHILE_100_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_101, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(101, s)) # define BOOST_PP_WHILE_101_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_102, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(102, s)) # define BOOST_PP_WHILE_102_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_103, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(103, s)) # define BOOST_PP_WHILE_103_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_104, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(104, s)) # define BOOST_PP_WHILE_104_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_105, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(105, s)) # define BOOST_PP_WHILE_105_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_106, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(106, s)) # define BOOST_PP_WHILE_106_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_107, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(107, s)) # define BOOST_PP_WHILE_107_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_108, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(108, s)) # define BOOST_PP_WHILE_108_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_109, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(109, s)) # define BOOST_PP_WHILE_109_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_110, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(110, s)) # define BOOST_PP_WHILE_110_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_111, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(111, s)) # define BOOST_PP_WHILE_111_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_112, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(112, s)) # define BOOST_PP_WHILE_112_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_113, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(113, s)) # define BOOST_PP_WHILE_113_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_114, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(114, s)) # define BOOST_PP_WHILE_114_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_115, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(115, s)) # define BOOST_PP_WHILE_115_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_116, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(116, s)) # define BOOST_PP_WHILE_116_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_117, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(117, s)) # define BOOST_PP_WHILE_117_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_118, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(118, s)) # define BOOST_PP_WHILE_118_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_119, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(119, s)) # define BOOST_PP_WHILE_119_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_120, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(120, s)) # define BOOST_PP_WHILE_120_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_121, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(121, s)) # define BOOST_PP_WHILE_121_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_122, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(122, s)) # define BOOST_PP_WHILE_122_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_123, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(123, s)) # define BOOST_PP_WHILE_123_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_124, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(124, s)) # define BOOST_PP_WHILE_124_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_125, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(125, s)) # define BOOST_PP_WHILE_125_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_126, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(126, s)) # define BOOST_PP_WHILE_126_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_127, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(127, s)) # define BOOST_PP_WHILE_127_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_128, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(128, s)) # define BOOST_PP_WHILE_128_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_129, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(129, s)) # define BOOST_PP_WHILE_129_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_130, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(130, s)) # define BOOST_PP_WHILE_130_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_131, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(131, s)) # define BOOST_PP_WHILE_131_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_132, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(132, s)) # define BOOST_PP_WHILE_132_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_133, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(133, s)) # define BOOST_PP_WHILE_133_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_134, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(134, s)) # define BOOST_PP_WHILE_134_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_135, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(135, s)) # define BOOST_PP_WHILE_135_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_136, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(136, s)) # define BOOST_PP_WHILE_136_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_137, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(137, s)) # define BOOST_PP_WHILE_137_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_138, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(138, s)) # define BOOST_PP_WHILE_138_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_139, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(139, s)) # define BOOST_PP_WHILE_139_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_140, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(140, s)) # define BOOST_PP_WHILE_140_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_141, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(141, s)) # define BOOST_PP_WHILE_141_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_142, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(142, s)) # define BOOST_PP_WHILE_142_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_143, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(143, s)) # define BOOST_PP_WHILE_143_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_144, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(144, s)) # define BOOST_PP_WHILE_144_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_145, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(145, s)) # define BOOST_PP_WHILE_145_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_146, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(146, s)) # define BOOST_PP_WHILE_146_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_147, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(147, s)) # define BOOST_PP_WHILE_147_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_148, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(148, s)) # define BOOST_PP_WHILE_148_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_149, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(149, s)) # define BOOST_PP_WHILE_149_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_150, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(150, s)) # define BOOST_PP_WHILE_150_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_151, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(151, s)) # define BOOST_PP_WHILE_151_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_152, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(152, s)) # define BOOST_PP_WHILE_152_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_153, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(153, s)) # define BOOST_PP_WHILE_153_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_154, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(154, s)) # define BOOST_PP_WHILE_154_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_155, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(155, s)) # define BOOST_PP_WHILE_155_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_156, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(156, s)) # define BOOST_PP_WHILE_156_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_157, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(157, s)) # define BOOST_PP_WHILE_157_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_158, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(158, s)) # define BOOST_PP_WHILE_158_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_159, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(159, s)) # define BOOST_PP_WHILE_159_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_160, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(160, s)) # define BOOST_PP_WHILE_160_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_161, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(161, s)) # define BOOST_PP_WHILE_161_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_162, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(162, s)) # define BOOST_PP_WHILE_162_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_163, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(163, s)) # define BOOST_PP_WHILE_163_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_164, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(164, s)) # define BOOST_PP_WHILE_164_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_165, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(165, s)) # define BOOST_PP_WHILE_165_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_166, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(166, s)) # define BOOST_PP_WHILE_166_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_167, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(167, s)) # define BOOST_PP_WHILE_167_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_168, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(168, s)) # define BOOST_PP_WHILE_168_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_169, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(169, s)) # define BOOST_PP_WHILE_169_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_170, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(170, s)) # define BOOST_PP_WHILE_170_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_171, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(171, s)) # define BOOST_PP_WHILE_171_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_172, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(172, s)) # define BOOST_PP_WHILE_172_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_173, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(173, s)) # define BOOST_PP_WHILE_173_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_174, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(174, s)) # define BOOST_PP_WHILE_174_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_175, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(175, s)) # define BOOST_PP_WHILE_175_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_176, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(176, s)) # define BOOST_PP_WHILE_176_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_177, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(177, s)) # define BOOST_PP_WHILE_177_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_178, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(178, s)) # define BOOST_PP_WHILE_178_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_179, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(179, s)) # define BOOST_PP_WHILE_179_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_180, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(180, s)) # define BOOST_PP_WHILE_180_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_181, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(181, s)) # define BOOST_PP_WHILE_181_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_182, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(182, s)) # define BOOST_PP_WHILE_182_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_183, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(183, s)) # define BOOST_PP_WHILE_183_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_184, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(184, s)) # define BOOST_PP_WHILE_184_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_185, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(185, s)) # define BOOST_PP_WHILE_185_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_186, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(186, s)) # define BOOST_PP_WHILE_186_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_187, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(187, s)) # define BOOST_PP_WHILE_187_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_188, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(188, s)) # define BOOST_PP_WHILE_188_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_189, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(189, s)) # define BOOST_PP_WHILE_189_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_190, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(190, s)) # define BOOST_PP_WHILE_190_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_191, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(191, s)) # define BOOST_PP_WHILE_191_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_192, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(192, s)) # define BOOST_PP_WHILE_192_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_193, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(193, s)) # define BOOST_PP_WHILE_193_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_194, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(194, s)) # define BOOST_PP_WHILE_194_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_195, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(195, s)) # define BOOST_PP_WHILE_195_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_196, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(196, s)) # define BOOST_PP_WHILE_196_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_197, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(197, s)) # define BOOST_PP_WHILE_197_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_198, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(198, s)) # define BOOST_PP_WHILE_198_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_199, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(199, s)) # define BOOST_PP_WHILE_199_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_200, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(200, s)) # define BOOST_PP_WHILE_200_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_201, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(201, s)) # define BOOST_PP_WHILE_201_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_202, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(202, s)) # define BOOST_PP_WHILE_202_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_203, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(203, s)) # define BOOST_PP_WHILE_203_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_204, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(204, s)) # define BOOST_PP_WHILE_204_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_205, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(205, s)) # define BOOST_PP_WHILE_205_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_206, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(206, s)) # define BOOST_PP_WHILE_206_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_207, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(207, s)) # define BOOST_PP_WHILE_207_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_208, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(208, s)) # define BOOST_PP_WHILE_208_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_209, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(209, s)) # define BOOST_PP_WHILE_209_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_210, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(210, s)) # define BOOST_PP_WHILE_210_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_211, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(211, s)) # define BOOST_PP_WHILE_211_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_212, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(212, s)) # define BOOST_PP_WHILE_212_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_213, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(213, s)) # define BOOST_PP_WHILE_213_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_214, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(214, s)) # define BOOST_PP_WHILE_214_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_215, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(215, s)) # define BOOST_PP_WHILE_215_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_216, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(216, s)) # define BOOST_PP_WHILE_216_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_217, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(217, s)) # define BOOST_PP_WHILE_217_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_218, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(218, s)) # define BOOST_PP_WHILE_218_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_219, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(219, s)) # define BOOST_PP_WHILE_219_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_220, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(220, s)) # define BOOST_PP_WHILE_220_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_221, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(221, s)) # define BOOST_PP_WHILE_221_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_222, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(222, s)) # define BOOST_PP_WHILE_222_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_223, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(223, s)) # define BOOST_PP_WHILE_223_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_224, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(224, s)) # define BOOST_PP_WHILE_224_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_225, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(225, s)) # define BOOST_PP_WHILE_225_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_226, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(226, s)) # define BOOST_PP_WHILE_226_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_227, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(227, s)) # define BOOST_PP_WHILE_227_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_228, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(228, s)) # define BOOST_PP_WHILE_228_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_229, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(229, s)) # define BOOST_PP_WHILE_229_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_230, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(230, s)) # define BOOST_PP_WHILE_230_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_231, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(231, s)) # define BOOST_PP_WHILE_231_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_232, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(232, s)) # define BOOST_PP_WHILE_232_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_233, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(233, s)) # define BOOST_PP_WHILE_233_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_234, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(234, s)) # define BOOST_PP_WHILE_234_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_235, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(235, s)) # define BOOST_PP_WHILE_235_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_236, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(236, s)) # define BOOST_PP_WHILE_236_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_237, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(237, s)) # define BOOST_PP_WHILE_237_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_238, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(238, s)) # define BOOST_PP_WHILE_238_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_239, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(239, s)) # define BOOST_PP_WHILE_239_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_240, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(240, s)) # define BOOST_PP_WHILE_240_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_241, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(241, s)) # define BOOST_PP_WHILE_241_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_242, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(242, s)) # define BOOST_PP_WHILE_242_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_243, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(243, s)) # define BOOST_PP_WHILE_243_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_244, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(244, s)) # define BOOST_PP_WHILE_244_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_245, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(245, s)) # define BOOST_PP_WHILE_245_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_246, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(246, s)) # define BOOST_PP_WHILE_246_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_247, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(247, s)) # define BOOST_PP_WHILE_247_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_248, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(248, s)) # define BOOST_PP_WHILE_248_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_249, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(249, s)) # define BOOST_PP_WHILE_249_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_250, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(250, s)) # define BOOST_PP_WHILE_250_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_251, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(251, s)) # define BOOST_PP_WHILE_251_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_252, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(252, s)) # define BOOST_PP_WHILE_252_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_253, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(253, s)) # define BOOST_PP_WHILE_253_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_254, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(254, s)) # define BOOST_PP_WHILE_254_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_255, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(255, s)) # define BOOST_PP_WHILE_255_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_256, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(256, s)) # define BOOST_PP_WHILE_256_C(c, p, o, s) BOOST_PP_IIF(c, BOOST_PP_WHILE_257, BOOST_PP_TUPLE_ELEM_3_2)(p, o, BOOST_PP_IIF(c, o, BOOST_PP_TUPLE_ELEM_2_1)(257, s)) # # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/edg/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000755000175000017500000000000012146213763031664 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/edg/while.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000013667611344301502031675 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_DETAIL_EDG_WHILE_HPP # define BOOST_PREPROCESSOR_CONTROL_DETAIL_EDG_WHILE_HPP # # include # include # # define BOOST_PP_WHILE_1(p, o, s) BOOST_PP_WHILE_1_I(p, o, s) # define BOOST_PP_WHILE_2(p, o, s) BOOST_PP_WHILE_2_I(p, o, s) # define BOOST_PP_WHILE_3(p, o, s) BOOST_PP_WHILE_3_I(p, o, s) # define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_WHILE_4_I(p, o, s) # define BOOST_PP_WHILE_5(p, o, s) BOOST_PP_WHILE_5_I(p, o, s) # define BOOST_PP_WHILE_6(p, o, s) BOOST_PP_WHILE_6_I(p, o, s) # define BOOST_PP_WHILE_7(p, o, s) BOOST_PP_WHILE_7_I(p, o, s) # define BOOST_PP_WHILE_8(p, o, s) BOOST_PP_WHILE_8_I(p, o, s) # define BOOST_PP_WHILE_9(p, o, s) BOOST_PP_WHILE_9_I(p, o, s) # define BOOST_PP_WHILE_10(p, o, s) BOOST_PP_WHILE_10_I(p, o, s) # define BOOST_PP_WHILE_11(p, o, s) BOOST_PP_WHILE_11_I(p, o, s) # define BOOST_PP_WHILE_12(p, o, s) BOOST_PP_WHILE_12_I(p, o, s) # define BOOST_PP_WHILE_13(p, o, s) BOOST_PP_WHILE_13_I(p, o, s) # define BOOST_PP_WHILE_14(p, o, s) BOOST_PP_WHILE_14_I(p, o, s) # define BOOST_PP_WHILE_15(p, o, s) BOOST_PP_WHILE_15_I(p, o, s) # define BOOST_PP_WHILE_16(p, o, s) BOOST_PP_WHILE_16_I(p, o, s) # define BOOST_PP_WHILE_17(p, o, s) BOOST_PP_WHILE_17_I(p, o, s) # define BOOST_PP_WHILE_18(p, o, s) BOOST_PP_WHILE_18_I(p, o, s) # define BOOST_PP_WHILE_19(p, o, s) BOOST_PP_WHILE_19_I(p, o, s) # define BOOST_PP_WHILE_20(p, o, s) BOOST_PP_WHILE_20_I(p, o, s) # define BOOST_PP_WHILE_21(p, o, s) BOOST_PP_WHILE_21_I(p, o, s) # define BOOST_PP_WHILE_22(p, o, s) BOOST_PP_WHILE_22_I(p, o, s) # define BOOST_PP_WHILE_23(p, o, s) BOOST_PP_WHILE_23_I(p, o, s) # define BOOST_PP_WHILE_24(p, o, s) BOOST_PP_WHILE_24_I(p, o, s) # define BOOST_PP_WHILE_25(p, o, s) BOOST_PP_WHILE_25_I(p, o, s) # define BOOST_PP_WHILE_26(p, o, s) BOOST_PP_WHILE_26_I(p, o, s) # define BOOST_PP_WHILE_27(p, o, s) BOOST_PP_WHILE_27_I(p, o, s) # define BOOST_PP_WHILE_28(p, o, s) BOOST_PP_WHILE_28_I(p, o, s) # define BOOST_PP_WHILE_29(p, o, s) BOOST_PP_WHILE_29_I(p, o, s) # define BOOST_PP_WHILE_30(p, o, s) BOOST_PP_WHILE_30_I(p, o, s) # define BOOST_PP_WHILE_31(p, o, s) BOOST_PP_WHILE_31_I(p, o, s) # define BOOST_PP_WHILE_32(p, o, s) BOOST_PP_WHILE_32_I(p, o, s) # define BOOST_PP_WHILE_33(p, o, s) BOOST_PP_WHILE_33_I(p, o, s) # define BOOST_PP_WHILE_34(p, o, s) BOOST_PP_WHILE_34_I(p, o, s) # define BOOST_PP_WHILE_35(p, o, s) BOOST_PP_WHILE_35_I(p, o, s) # define BOOST_PP_WHILE_36(p, o, s) BOOST_PP_WHILE_36_I(p, o, s) # define BOOST_PP_WHILE_37(p, o, s) BOOST_PP_WHILE_37_I(p, o, s) # define BOOST_PP_WHILE_38(p, o, s) BOOST_PP_WHILE_38_I(p, o, s) # define BOOST_PP_WHILE_39(p, o, s) BOOST_PP_WHILE_39_I(p, o, s) # define BOOST_PP_WHILE_40(p, o, s) BOOST_PP_WHILE_40_I(p, o, s) # define BOOST_PP_WHILE_41(p, o, s) BOOST_PP_WHILE_41_I(p, o, s) # define BOOST_PP_WHILE_42(p, o, s) BOOST_PP_WHILE_42_I(p, o, s) # define BOOST_PP_WHILE_43(p, o, s) BOOST_PP_WHILE_43_I(p, o, s) # define BOOST_PP_WHILE_44(p, o, s) BOOST_PP_WHILE_44_I(p, o, s) # define BOOST_PP_WHILE_45(p, o, s) BOOST_PP_WHILE_45_I(p, o, s) # define BOOST_PP_WHILE_46(p, o, s) BOOST_PP_WHILE_46_I(p, o, s) # define BOOST_PP_WHILE_47(p, o, s) BOOST_PP_WHILE_47_I(p, o, s) # define BOOST_PP_WHILE_48(p, o, s) BOOST_PP_WHILE_48_I(p, o, s) # define BOOST_PP_WHILE_49(p, o, s) BOOST_PP_WHILE_49_I(p, o, s) # define BOOST_PP_WHILE_50(p, o, s) BOOST_PP_WHILE_50_I(p, o, s) # define BOOST_PP_WHILE_51(p, o, s) BOOST_PP_WHILE_51_I(p, o, s) # define BOOST_PP_WHILE_52(p, o, s) BOOST_PP_WHILE_52_I(p, o, s) # define BOOST_PP_WHILE_53(p, o, s) BOOST_PP_WHILE_53_I(p, o, s) # define BOOST_PP_WHILE_54(p, o, s) BOOST_PP_WHILE_54_I(p, o, s) # define BOOST_PP_WHILE_55(p, o, s) BOOST_PP_WHILE_55_I(p, o, s) # define BOOST_PP_WHILE_56(p, o, s) BOOST_PP_WHILE_56_I(p, o, s) # define BOOST_PP_WHILE_57(p, o, s) BOOST_PP_WHILE_57_I(p, o, s) # define BOOST_PP_WHILE_58(p, o, s) BOOST_PP_WHILE_58_I(p, o, s) # define BOOST_PP_WHILE_59(p, o, s) BOOST_PP_WHILE_59_I(p, o, s) # define BOOST_PP_WHILE_60(p, o, s) BOOST_PP_WHILE_60_I(p, o, s) # define BOOST_PP_WHILE_61(p, o, s) BOOST_PP_WHILE_61_I(p, o, s) # define BOOST_PP_WHILE_62(p, o, s) BOOST_PP_WHILE_62_I(p, o, s) # define BOOST_PP_WHILE_63(p, o, s) BOOST_PP_WHILE_63_I(p, o, s) # define BOOST_PP_WHILE_64(p, o, s) BOOST_PP_WHILE_64_I(p, o, s) # define BOOST_PP_WHILE_65(p, o, s) BOOST_PP_WHILE_65_I(p, o, s) # define BOOST_PP_WHILE_66(p, o, s) BOOST_PP_WHILE_66_I(p, o, s) # define BOOST_PP_WHILE_67(p, o, s) BOOST_PP_WHILE_67_I(p, o, s) # define BOOST_PP_WHILE_68(p, o, s) BOOST_PP_WHILE_68_I(p, o, s) # define BOOST_PP_WHILE_69(p, o, s) BOOST_PP_WHILE_69_I(p, o, s) # define BOOST_PP_WHILE_70(p, o, s) BOOST_PP_WHILE_70_I(p, o, s) # define BOOST_PP_WHILE_71(p, o, s) BOOST_PP_WHILE_71_I(p, o, s) # define BOOST_PP_WHILE_72(p, o, s) BOOST_PP_WHILE_72_I(p, o, s) # define BOOST_PP_WHILE_73(p, o, s) BOOST_PP_WHILE_73_I(p, o, s) # define BOOST_PP_WHILE_74(p, o, s) BOOST_PP_WHILE_74_I(p, o, s) # define BOOST_PP_WHILE_75(p, o, s) BOOST_PP_WHILE_75_I(p, o, s) # define BOOST_PP_WHILE_76(p, o, s) BOOST_PP_WHILE_76_I(p, o, s) # define BOOST_PP_WHILE_77(p, o, s) BOOST_PP_WHILE_77_I(p, o, s) # define BOOST_PP_WHILE_78(p, o, s) BOOST_PP_WHILE_78_I(p, o, s) # define BOOST_PP_WHILE_79(p, o, s) BOOST_PP_WHILE_79_I(p, o, s) # define BOOST_PP_WHILE_80(p, o, s) BOOST_PP_WHILE_80_I(p, o, s) # define BOOST_PP_WHILE_81(p, o, s) BOOST_PP_WHILE_81_I(p, o, s) # define BOOST_PP_WHILE_82(p, o, s) BOOST_PP_WHILE_82_I(p, o, s) # define BOOST_PP_WHILE_83(p, o, s) BOOST_PP_WHILE_83_I(p, o, s) # define BOOST_PP_WHILE_84(p, o, s) BOOST_PP_WHILE_84_I(p, o, s) # define BOOST_PP_WHILE_85(p, o, s) BOOST_PP_WHILE_85_I(p, o, s) # define BOOST_PP_WHILE_86(p, o, s) BOOST_PP_WHILE_86_I(p, o, s) # define BOOST_PP_WHILE_87(p, o, s) BOOST_PP_WHILE_87_I(p, o, s) # define BOOST_PP_WHILE_88(p, o, s) BOOST_PP_WHILE_88_I(p, o, s) # define BOOST_PP_WHILE_89(p, o, s) BOOST_PP_WHILE_89_I(p, o, s) # define BOOST_PP_WHILE_90(p, o, s) BOOST_PP_WHILE_90_I(p, o, s) # define BOOST_PP_WHILE_91(p, o, s) BOOST_PP_WHILE_91_I(p, o, s) # define BOOST_PP_WHILE_92(p, o, s) BOOST_PP_WHILE_92_I(p, o, s) # define BOOST_PP_WHILE_93(p, o, s) BOOST_PP_WHILE_93_I(p, o, s) # define BOOST_PP_WHILE_94(p, o, s) BOOST_PP_WHILE_94_I(p, o, s) # define BOOST_PP_WHILE_95(p, o, s) BOOST_PP_WHILE_95_I(p, o, s) # define BOOST_PP_WHILE_96(p, o, s) BOOST_PP_WHILE_96_I(p, o, s) # define BOOST_PP_WHILE_97(p, o, s) BOOST_PP_WHILE_97_I(p, o, s) # define BOOST_PP_WHILE_98(p, o, s) BOOST_PP_WHILE_98_I(p, o, s) # define BOOST_PP_WHILE_99(p, o, s) BOOST_PP_WHILE_99_I(p, o, s) # define BOOST_PP_WHILE_100(p, o, s) BOOST_PP_WHILE_100_I(p, o, s) # define BOOST_PP_WHILE_101(p, o, s) BOOST_PP_WHILE_101_I(p, o, s) # define BOOST_PP_WHILE_102(p, o, s) BOOST_PP_WHILE_102_I(p, o, s) # define BOOST_PP_WHILE_103(p, o, s) BOOST_PP_WHILE_103_I(p, o, s) # define BOOST_PP_WHILE_104(p, o, s) BOOST_PP_WHILE_104_I(p, o, s) # define BOOST_PP_WHILE_105(p, o, s) BOOST_PP_WHILE_105_I(p, o, s) # define BOOST_PP_WHILE_106(p, o, s) BOOST_PP_WHILE_106_I(p, o, s) # define BOOST_PP_WHILE_107(p, o, s) BOOST_PP_WHILE_107_I(p, o, s) # define BOOST_PP_WHILE_108(p, o, s) BOOST_PP_WHILE_108_I(p, o, s) # define BOOST_PP_WHILE_109(p, o, s) BOOST_PP_WHILE_109_I(p, o, s) # define BOOST_PP_WHILE_110(p, o, s) BOOST_PP_WHILE_110_I(p, o, s) # define BOOST_PP_WHILE_111(p, o, s) BOOST_PP_WHILE_111_I(p, o, s) # define BOOST_PP_WHILE_112(p, o, s) BOOST_PP_WHILE_112_I(p, o, s) # define BOOST_PP_WHILE_113(p, o, s) BOOST_PP_WHILE_113_I(p, o, s) # define BOOST_PP_WHILE_114(p, o, s) BOOST_PP_WHILE_114_I(p, o, s) # define BOOST_PP_WHILE_115(p, o, s) BOOST_PP_WHILE_115_I(p, o, s) # define BOOST_PP_WHILE_116(p, o, s) BOOST_PP_WHILE_116_I(p, o, s) # define BOOST_PP_WHILE_117(p, o, s) BOOST_PP_WHILE_117_I(p, o, s) # define BOOST_PP_WHILE_118(p, o, s) BOOST_PP_WHILE_118_I(p, o, s) # define BOOST_PP_WHILE_119(p, o, s) BOOST_PP_WHILE_119_I(p, o, s) # define BOOST_PP_WHILE_120(p, o, s) BOOST_PP_WHILE_120_I(p, o, s) # define BOOST_PP_WHILE_121(p, o, s) BOOST_PP_WHILE_121_I(p, o, s) # define BOOST_PP_WHILE_122(p, o, s) BOOST_PP_WHILE_122_I(p, o, s) # define BOOST_PP_WHILE_123(p, o, s) BOOST_PP_WHILE_123_I(p, o, s) # define BOOST_PP_WHILE_124(p, o, s) BOOST_PP_WHILE_124_I(p, o, s) # define BOOST_PP_WHILE_125(p, o, s) BOOST_PP_WHILE_125_I(p, o, s) # define BOOST_PP_WHILE_126(p, o, s) BOOST_PP_WHILE_126_I(p, o, s) # define BOOST_PP_WHILE_127(p, o, s) BOOST_PP_WHILE_127_I(p, o, s) # define BOOST_PP_WHILE_128(p, o, s) BOOST_PP_WHILE_128_I(p, o, s) # define BOOST_PP_WHILE_129(p, o, s) BOOST_PP_WHILE_129_I(p, o, s) # define BOOST_PP_WHILE_130(p, o, s) BOOST_PP_WHILE_130_I(p, o, s) # define BOOST_PP_WHILE_131(p, o, s) BOOST_PP_WHILE_131_I(p, o, s) # define BOOST_PP_WHILE_132(p, o, s) BOOST_PP_WHILE_132_I(p, o, s) # define BOOST_PP_WHILE_133(p, o, s) BOOST_PP_WHILE_133_I(p, o, s) # define BOOST_PP_WHILE_134(p, o, s) BOOST_PP_WHILE_134_I(p, o, s) # define BOOST_PP_WHILE_135(p, o, s) BOOST_PP_WHILE_135_I(p, o, s) # define BOOST_PP_WHILE_136(p, o, s) BOOST_PP_WHILE_136_I(p, o, s) # define BOOST_PP_WHILE_137(p, o, s) BOOST_PP_WHILE_137_I(p, o, s) # define BOOST_PP_WHILE_138(p, o, s) BOOST_PP_WHILE_138_I(p, o, s) # define BOOST_PP_WHILE_139(p, o, s) BOOST_PP_WHILE_139_I(p, o, s) # define BOOST_PP_WHILE_140(p, o, s) BOOST_PP_WHILE_140_I(p, o, s) # define BOOST_PP_WHILE_141(p, o, s) BOOST_PP_WHILE_141_I(p, o, s) # define BOOST_PP_WHILE_142(p, o, s) BOOST_PP_WHILE_142_I(p, o, s) # define BOOST_PP_WHILE_143(p, o, s) BOOST_PP_WHILE_143_I(p, o, s) # define BOOST_PP_WHILE_144(p, o, s) BOOST_PP_WHILE_144_I(p, o, s) # define BOOST_PP_WHILE_145(p, o, s) BOOST_PP_WHILE_145_I(p, o, s) # define BOOST_PP_WHILE_146(p, o, s) BOOST_PP_WHILE_146_I(p, o, s) # define BOOST_PP_WHILE_147(p, o, s) BOOST_PP_WHILE_147_I(p, o, s) # define BOOST_PP_WHILE_148(p, o, s) BOOST_PP_WHILE_148_I(p, o, s) # define BOOST_PP_WHILE_149(p, o, s) BOOST_PP_WHILE_149_I(p, o, s) # define BOOST_PP_WHILE_150(p, o, s) BOOST_PP_WHILE_150_I(p, o, s) # define BOOST_PP_WHILE_151(p, o, s) BOOST_PP_WHILE_151_I(p, o, s) # define BOOST_PP_WHILE_152(p, o, s) BOOST_PP_WHILE_152_I(p, o, s) # define BOOST_PP_WHILE_153(p, o, s) BOOST_PP_WHILE_153_I(p, o, s) # define BOOST_PP_WHILE_154(p, o, s) BOOST_PP_WHILE_154_I(p, o, s) # define BOOST_PP_WHILE_155(p, o, s) BOOST_PP_WHILE_155_I(p, o, s) # define BOOST_PP_WHILE_156(p, o, s) BOOST_PP_WHILE_156_I(p, o, s) # define BOOST_PP_WHILE_157(p, o, s) BOOST_PP_WHILE_157_I(p, o, s) # define BOOST_PP_WHILE_158(p, o, s) BOOST_PP_WHILE_158_I(p, o, s) # define BOOST_PP_WHILE_159(p, o, s) BOOST_PP_WHILE_159_I(p, o, s) # define BOOST_PP_WHILE_160(p, o, s) BOOST_PP_WHILE_160_I(p, o, s) # define BOOST_PP_WHILE_161(p, o, s) BOOST_PP_WHILE_161_I(p, o, s) # define BOOST_PP_WHILE_162(p, o, s) BOOST_PP_WHILE_162_I(p, o, s) # define BOOST_PP_WHILE_163(p, o, s) BOOST_PP_WHILE_163_I(p, o, s) # define BOOST_PP_WHILE_164(p, o, s) BOOST_PP_WHILE_164_I(p, o, s) # define BOOST_PP_WHILE_165(p, o, s) BOOST_PP_WHILE_165_I(p, o, s) # define BOOST_PP_WHILE_166(p, o, s) BOOST_PP_WHILE_166_I(p, o, s) # define BOOST_PP_WHILE_167(p, o, s) BOOST_PP_WHILE_167_I(p, o, s) # define BOOST_PP_WHILE_168(p, o, s) BOOST_PP_WHILE_168_I(p, o, s) # define BOOST_PP_WHILE_169(p, o, s) BOOST_PP_WHILE_169_I(p, o, s) # define BOOST_PP_WHILE_170(p, o, s) BOOST_PP_WHILE_170_I(p, o, s) # define BOOST_PP_WHILE_171(p, o, s) BOOST_PP_WHILE_171_I(p, o, s) # define BOOST_PP_WHILE_172(p, o, s) BOOST_PP_WHILE_172_I(p, o, s) # define BOOST_PP_WHILE_173(p, o, s) BOOST_PP_WHILE_173_I(p, o, s) # define BOOST_PP_WHILE_174(p, o, s) BOOST_PP_WHILE_174_I(p, o, s) # define BOOST_PP_WHILE_175(p, o, s) BOOST_PP_WHILE_175_I(p, o, s) # define BOOST_PP_WHILE_176(p, o, s) BOOST_PP_WHILE_176_I(p, o, s) # define BOOST_PP_WHILE_177(p, o, s) BOOST_PP_WHILE_177_I(p, o, s) # define BOOST_PP_WHILE_178(p, o, s) BOOST_PP_WHILE_178_I(p, o, s) # define BOOST_PP_WHILE_179(p, o, s) BOOST_PP_WHILE_179_I(p, o, s) # define BOOST_PP_WHILE_180(p, o, s) BOOST_PP_WHILE_180_I(p, o, s) # define BOOST_PP_WHILE_181(p, o, s) BOOST_PP_WHILE_181_I(p, o, s) # define BOOST_PP_WHILE_182(p, o, s) BOOST_PP_WHILE_182_I(p, o, s) # define BOOST_PP_WHILE_183(p, o, s) BOOST_PP_WHILE_183_I(p, o, s) # define BOOST_PP_WHILE_184(p, o, s) BOOST_PP_WHILE_184_I(p, o, s) # define BOOST_PP_WHILE_185(p, o, s) BOOST_PP_WHILE_185_I(p, o, s) # define BOOST_PP_WHILE_186(p, o, s) BOOST_PP_WHILE_186_I(p, o, s) # define BOOST_PP_WHILE_187(p, o, s) BOOST_PP_WHILE_187_I(p, o, s) # define BOOST_PP_WHILE_188(p, o, s) BOOST_PP_WHILE_188_I(p, o, s) # define BOOST_PP_WHILE_189(p, o, s) BOOST_PP_WHILE_189_I(p, o, s) # define BOOST_PP_WHILE_190(p, o, s) BOOST_PP_WHILE_190_I(p, o, s) # define BOOST_PP_WHILE_191(p, o, s) BOOST_PP_WHILE_191_I(p, o, s) # define BOOST_PP_WHILE_192(p, o, s) BOOST_PP_WHILE_192_I(p, o, s) # define BOOST_PP_WHILE_193(p, o, s) BOOST_PP_WHILE_193_I(p, o, s) # define BOOST_PP_WHILE_194(p, o, s) BOOST_PP_WHILE_194_I(p, o, s) # define BOOST_PP_WHILE_195(p, o, s) BOOST_PP_WHILE_195_I(p, o, s) # define BOOST_PP_WHILE_196(p, o, s) BOOST_PP_WHILE_196_I(p, o, s) # define BOOST_PP_WHILE_197(p, o, s) BOOST_PP_WHILE_197_I(p, o, s) # define BOOST_PP_WHILE_198(p, o, s) BOOST_PP_WHILE_198_I(p, o, s) # define BOOST_PP_WHILE_199(p, o, s) BOOST_PP_WHILE_199_I(p, o, s) # define BOOST_PP_WHILE_200(p, o, s) BOOST_PP_WHILE_200_I(p, o, s) # define BOOST_PP_WHILE_201(p, o, s) BOOST_PP_WHILE_201_I(p, o, s) # define BOOST_PP_WHILE_202(p, o, s) BOOST_PP_WHILE_202_I(p, o, s) # define BOOST_PP_WHILE_203(p, o, s) BOOST_PP_WHILE_203_I(p, o, s) # define BOOST_PP_WHILE_204(p, o, s) BOOST_PP_WHILE_204_I(p, o, s) # define BOOST_PP_WHILE_205(p, o, s) BOOST_PP_WHILE_205_I(p, o, s) # define BOOST_PP_WHILE_206(p, o, s) BOOST_PP_WHILE_206_I(p, o, s) # define BOOST_PP_WHILE_207(p, o, s) BOOST_PP_WHILE_207_I(p, o, s) # define BOOST_PP_WHILE_208(p, o, s) BOOST_PP_WHILE_208_I(p, o, s) # define BOOST_PP_WHILE_209(p, o, s) BOOST_PP_WHILE_209_I(p, o, s) # define BOOST_PP_WHILE_210(p, o, s) BOOST_PP_WHILE_210_I(p, o, s) # define BOOST_PP_WHILE_211(p, o, s) BOOST_PP_WHILE_211_I(p, o, s) # define BOOST_PP_WHILE_212(p, o, s) BOOST_PP_WHILE_212_I(p, o, s) # define BOOST_PP_WHILE_213(p, o, s) BOOST_PP_WHILE_213_I(p, o, s) # define BOOST_PP_WHILE_214(p, o, s) BOOST_PP_WHILE_214_I(p, o, s) # define BOOST_PP_WHILE_215(p, o, s) BOOST_PP_WHILE_215_I(p, o, s) # define BOOST_PP_WHILE_216(p, o, s) BOOST_PP_WHILE_216_I(p, o, s) # define BOOST_PP_WHILE_217(p, o, s) BOOST_PP_WHILE_217_I(p, o, s) # define BOOST_PP_WHILE_218(p, o, s) BOOST_PP_WHILE_218_I(p, o, s) # define BOOST_PP_WHILE_219(p, o, s) BOOST_PP_WHILE_219_I(p, o, s) # define BOOST_PP_WHILE_220(p, o, s) BOOST_PP_WHILE_220_I(p, o, s) # define BOOST_PP_WHILE_221(p, o, s) BOOST_PP_WHILE_221_I(p, o, s) # define BOOST_PP_WHILE_222(p, o, s) BOOST_PP_WHILE_222_I(p, o, s) # define BOOST_PP_WHILE_223(p, o, s) BOOST_PP_WHILE_223_I(p, o, s) # define BOOST_PP_WHILE_224(p, o, s) BOOST_PP_WHILE_224_I(p, o, s) # define BOOST_PP_WHILE_225(p, o, s) BOOST_PP_WHILE_225_I(p, o, s) # define BOOST_PP_WHILE_226(p, o, s) BOOST_PP_WHILE_226_I(p, o, s) # define BOOST_PP_WHILE_227(p, o, s) BOOST_PP_WHILE_227_I(p, o, s) # define BOOST_PP_WHILE_228(p, o, s) BOOST_PP_WHILE_228_I(p, o, s) # define BOOST_PP_WHILE_229(p, o, s) BOOST_PP_WHILE_229_I(p, o, s) # define BOOST_PP_WHILE_230(p, o, s) BOOST_PP_WHILE_230_I(p, o, s) # define BOOST_PP_WHILE_231(p, o, s) BOOST_PP_WHILE_231_I(p, o, s) # define BOOST_PP_WHILE_232(p, o, s) BOOST_PP_WHILE_232_I(p, o, s) # define BOOST_PP_WHILE_233(p, o, s) BOOST_PP_WHILE_233_I(p, o, s) # define BOOST_PP_WHILE_234(p, o, s) BOOST_PP_WHILE_234_I(p, o, s) # define BOOST_PP_WHILE_235(p, o, s) BOOST_PP_WHILE_235_I(p, o, s) # define BOOST_PP_WHILE_236(p, o, s) BOOST_PP_WHILE_236_I(p, o, s) # define BOOST_PP_WHILE_237(p, o, s) BOOST_PP_WHILE_237_I(p, o, s) # define BOOST_PP_WHILE_238(p, o, s) BOOST_PP_WHILE_238_I(p, o, s) # define BOOST_PP_WHILE_239(p, o, s) BOOST_PP_WHILE_239_I(p, o, s) # define BOOST_PP_WHILE_240(p, o, s) BOOST_PP_WHILE_240_I(p, o, s) # define BOOST_PP_WHILE_241(p, o, s) BOOST_PP_WHILE_241_I(p, o, s) # define BOOST_PP_WHILE_242(p, o, s) BOOST_PP_WHILE_242_I(p, o, s) # define BOOST_PP_WHILE_243(p, o, s) BOOST_PP_WHILE_243_I(p, o, s) # define BOOST_PP_WHILE_244(p, o, s) BOOST_PP_WHILE_244_I(p, o, s) # define BOOST_PP_WHILE_245(p, o, s) BOOST_PP_WHILE_245_I(p, o, s) # define BOOST_PP_WHILE_246(p, o, s) BOOST_PP_WHILE_246_I(p, o, s) # define BOOST_PP_WHILE_247(p, o, s) BOOST_PP_WHILE_247_I(p, o, s) # define BOOST_PP_WHILE_248(p, o, s) BOOST_PP_WHILE_248_I(p, o, s) # define BOOST_PP_WHILE_249(p, o, s) BOOST_PP_WHILE_249_I(p, o, s) # define BOOST_PP_WHILE_250(p, o, s) BOOST_PP_WHILE_250_I(p, o, s) # define BOOST_PP_WHILE_251(p, o, s) BOOST_PP_WHILE_251_I(p, o, s) # define BOOST_PP_WHILE_252(p, o, s) BOOST_PP_WHILE_252_I(p, o, s) # define BOOST_PP_WHILE_253(p, o, s) BOOST_PP_WHILE_253_I(p, o, s) # define BOOST_PP_WHILE_254(p, o, s) BOOST_PP_WHILE_254_I(p, o, s) # define BOOST_PP_WHILE_255(p, o, s) BOOST_PP_WHILE_255_I(p, o, s) # define BOOST_PP_WHILE_256(p, o, s) BOOST_PP_WHILE_256_I(p, o, s) # # define BOOST_PP_WHILE_1_I(p, o, s) BOOST_PP_IF(p(2, s), BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, o(2, s)) # define BOOST_PP_WHILE_2_I(p, o, s) BOOST_PP_IF(p(3, s), BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, o(3, s)) # define BOOST_PP_WHILE_3_I(p, o, s) BOOST_PP_IF(p(4, s), BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, o(4, s)) # define BOOST_PP_WHILE_4_I(p, o, s) BOOST_PP_IF(p(5, s), BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, o(5, s)) # define BOOST_PP_WHILE_5_I(p, o, s) BOOST_PP_IF(p(6, s), BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, o(6, s)) # define BOOST_PP_WHILE_6_I(p, o, s) BOOST_PP_IF(p(7, s), BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, o(7, s)) # define BOOST_PP_WHILE_7_I(p, o, s) BOOST_PP_IF(p(8, s), BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, o(8, s)) # define BOOST_PP_WHILE_8_I(p, o, s) BOOST_PP_IF(p(9, s), BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, o(9, s)) # define BOOST_PP_WHILE_9_I(p, o, s) BOOST_PP_IF(p(10, s), BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, o(10, s)) # define BOOST_PP_WHILE_10_I(p, o, s) BOOST_PP_IF(p(11, s), BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, o(11, s)) # define BOOST_PP_WHILE_11_I(p, o, s) BOOST_PP_IF(p(12, s), BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, o(12, s)) # define BOOST_PP_WHILE_12_I(p, o, s) BOOST_PP_IF(p(13, s), BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, o(13, s)) # define BOOST_PP_WHILE_13_I(p, o, s) BOOST_PP_IF(p(14, s), BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, o(14, s)) # define BOOST_PP_WHILE_14_I(p, o, s) BOOST_PP_IF(p(15, s), BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, o(15, s)) # define BOOST_PP_WHILE_15_I(p, o, s) BOOST_PP_IF(p(16, s), BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, o(16, s)) # define BOOST_PP_WHILE_16_I(p, o, s) BOOST_PP_IF(p(17, s), BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, o(17, s)) # define BOOST_PP_WHILE_17_I(p, o, s) BOOST_PP_IF(p(18, s), BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, o(18, s)) # define BOOST_PP_WHILE_18_I(p, o, s) BOOST_PP_IF(p(19, s), BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, o(19, s)) # define BOOST_PP_WHILE_19_I(p, o, s) BOOST_PP_IF(p(20, s), BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, o(20, s)) # define BOOST_PP_WHILE_20_I(p, o, s) BOOST_PP_IF(p(21, s), BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, o(21, s)) # define BOOST_PP_WHILE_21_I(p, o, s) BOOST_PP_IF(p(22, s), BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, o(22, s)) # define BOOST_PP_WHILE_22_I(p, o, s) BOOST_PP_IF(p(23, s), BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, o(23, s)) # define BOOST_PP_WHILE_23_I(p, o, s) BOOST_PP_IF(p(24, s), BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, o(24, s)) # define BOOST_PP_WHILE_24_I(p, o, s) BOOST_PP_IF(p(25, s), BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, o(25, s)) # define BOOST_PP_WHILE_25_I(p, o, s) BOOST_PP_IF(p(26, s), BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, o(26, s)) # define BOOST_PP_WHILE_26_I(p, o, s) BOOST_PP_IF(p(27, s), BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, o(27, s)) # define BOOST_PP_WHILE_27_I(p, o, s) BOOST_PP_IF(p(28, s), BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, o(28, s)) # define BOOST_PP_WHILE_28_I(p, o, s) BOOST_PP_IF(p(29, s), BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, o(29, s)) # define BOOST_PP_WHILE_29_I(p, o, s) BOOST_PP_IF(p(30, s), BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, o(30, s)) # define BOOST_PP_WHILE_30_I(p, o, s) BOOST_PP_IF(p(31, s), BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, o(31, s)) # define BOOST_PP_WHILE_31_I(p, o, s) BOOST_PP_IF(p(32, s), BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, o(32, s)) # define BOOST_PP_WHILE_32_I(p, o, s) BOOST_PP_IF(p(33, s), BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, o(33, s)) # define BOOST_PP_WHILE_33_I(p, o, s) BOOST_PP_IF(p(34, s), BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, o(34, s)) # define BOOST_PP_WHILE_34_I(p, o, s) BOOST_PP_IF(p(35, s), BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, o(35, s)) # define BOOST_PP_WHILE_35_I(p, o, s) BOOST_PP_IF(p(36, s), BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, o(36, s)) # define BOOST_PP_WHILE_36_I(p, o, s) BOOST_PP_IF(p(37, s), BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, o(37, s)) # define BOOST_PP_WHILE_37_I(p, o, s) BOOST_PP_IF(p(38, s), BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, o(38, s)) # define BOOST_PP_WHILE_38_I(p, o, s) BOOST_PP_IF(p(39, s), BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, o(39, s)) # define BOOST_PP_WHILE_39_I(p, o, s) BOOST_PP_IF(p(40, s), BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, o(40, s)) # define BOOST_PP_WHILE_40_I(p, o, s) BOOST_PP_IF(p(41, s), BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, o(41, s)) # define BOOST_PP_WHILE_41_I(p, o, s) BOOST_PP_IF(p(42, s), BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, o(42, s)) # define BOOST_PP_WHILE_42_I(p, o, s) BOOST_PP_IF(p(43, s), BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, o(43, s)) # define BOOST_PP_WHILE_43_I(p, o, s) BOOST_PP_IF(p(44, s), BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, o(44, s)) # define BOOST_PP_WHILE_44_I(p, o, s) BOOST_PP_IF(p(45, s), BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, o(45, s)) # define BOOST_PP_WHILE_45_I(p, o, s) BOOST_PP_IF(p(46, s), BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, o(46, s)) # define BOOST_PP_WHILE_46_I(p, o, s) BOOST_PP_IF(p(47, s), BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, o(47, s)) # define BOOST_PP_WHILE_47_I(p, o, s) BOOST_PP_IF(p(48, s), BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, o(48, s)) # define BOOST_PP_WHILE_48_I(p, o, s) BOOST_PP_IF(p(49, s), BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, o(49, s)) # define BOOST_PP_WHILE_49_I(p, o, s) BOOST_PP_IF(p(50, s), BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, o(50, s)) # define BOOST_PP_WHILE_50_I(p, o, s) BOOST_PP_IF(p(51, s), BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, o(51, s)) # define BOOST_PP_WHILE_51_I(p, o, s) BOOST_PP_IF(p(52, s), BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, o(52, s)) # define BOOST_PP_WHILE_52_I(p, o, s) BOOST_PP_IF(p(53, s), BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, o(53, s)) # define BOOST_PP_WHILE_53_I(p, o, s) BOOST_PP_IF(p(54, s), BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, o(54, s)) # define BOOST_PP_WHILE_54_I(p, o, s) BOOST_PP_IF(p(55, s), BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, o(55, s)) # define BOOST_PP_WHILE_55_I(p, o, s) BOOST_PP_IF(p(56, s), BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, o(56, s)) # define BOOST_PP_WHILE_56_I(p, o, s) BOOST_PP_IF(p(57, s), BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, o(57, s)) # define BOOST_PP_WHILE_57_I(p, o, s) BOOST_PP_IF(p(58, s), BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, o(58, s)) # define BOOST_PP_WHILE_58_I(p, o, s) BOOST_PP_IF(p(59, s), BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, o(59, s)) # define BOOST_PP_WHILE_59_I(p, o, s) BOOST_PP_IF(p(60, s), BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, o(60, s)) # define BOOST_PP_WHILE_60_I(p, o, s) BOOST_PP_IF(p(61, s), BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, o(61, s)) # define BOOST_PP_WHILE_61_I(p, o, s) BOOST_PP_IF(p(62, s), BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, o(62, s)) # define BOOST_PP_WHILE_62_I(p, o, s) BOOST_PP_IF(p(63, s), BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, o(63, s)) # define BOOST_PP_WHILE_63_I(p, o, s) BOOST_PP_IF(p(64, s), BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, o(64, s)) # define BOOST_PP_WHILE_64_I(p, o, s) BOOST_PP_IF(p(65, s), BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, o(65, s)) # define BOOST_PP_WHILE_65_I(p, o, s) BOOST_PP_IF(p(66, s), BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, o(66, s)) # define BOOST_PP_WHILE_66_I(p, o, s) BOOST_PP_IF(p(67, s), BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, o(67, s)) # define BOOST_PP_WHILE_67_I(p, o, s) BOOST_PP_IF(p(68, s), BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, o(68, s)) # define BOOST_PP_WHILE_68_I(p, o, s) BOOST_PP_IF(p(69, s), BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, o(69, s)) # define BOOST_PP_WHILE_69_I(p, o, s) BOOST_PP_IF(p(70, s), BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, o(70, s)) # define BOOST_PP_WHILE_70_I(p, o, s) BOOST_PP_IF(p(71, s), BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, o(71, s)) # define BOOST_PP_WHILE_71_I(p, o, s) BOOST_PP_IF(p(72, s), BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, o(72, s)) # define BOOST_PP_WHILE_72_I(p, o, s) BOOST_PP_IF(p(73, s), BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, o(73, s)) # define BOOST_PP_WHILE_73_I(p, o, s) BOOST_PP_IF(p(74, s), BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, o(74, s)) # define BOOST_PP_WHILE_74_I(p, o, s) BOOST_PP_IF(p(75, s), BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, o(75, s)) # define BOOST_PP_WHILE_75_I(p, o, s) BOOST_PP_IF(p(76, s), BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, o(76, s)) # define BOOST_PP_WHILE_76_I(p, o, s) BOOST_PP_IF(p(77, s), BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, o(77, s)) # define BOOST_PP_WHILE_77_I(p, o, s) BOOST_PP_IF(p(78, s), BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, o(78, s)) # define BOOST_PP_WHILE_78_I(p, o, s) BOOST_PP_IF(p(79, s), BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, o(79, s)) # define BOOST_PP_WHILE_79_I(p, o, s) BOOST_PP_IF(p(80, s), BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, o(80, s)) # define BOOST_PP_WHILE_80_I(p, o, s) BOOST_PP_IF(p(81, s), BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, o(81, s)) # define BOOST_PP_WHILE_81_I(p, o, s) BOOST_PP_IF(p(82, s), BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, o(82, s)) # define BOOST_PP_WHILE_82_I(p, o, s) BOOST_PP_IF(p(83, s), BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, o(83, s)) # define BOOST_PP_WHILE_83_I(p, o, s) BOOST_PP_IF(p(84, s), BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, o(84, s)) # define BOOST_PP_WHILE_84_I(p, o, s) BOOST_PP_IF(p(85, s), BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, o(85, s)) # define BOOST_PP_WHILE_85_I(p, o, s) BOOST_PP_IF(p(86, s), BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, o(86, s)) # define BOOST_PP_WHILE_86_I(p, o, s) BOOST_PP_IF(p(87, s), BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, o(87, s)) # define BOOST_PP_WHILE_87_I(p, o, s) BOOST_PP_IF(p(88, s), BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, o(88, s)) # define BOOST_PP_WHILE_88_I(p, o, s) BOOST_PP_IF(p(89, s), BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, o(89, s)) # define BOOST_PP_WHILE_89_I(p, o, s) BOOST_PP_IF(p(90, s), BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, o(90, s)) # define BOOST_PP_WHILE_90_I(p, o, s) BOOST_PP_IF(p(91, s), BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, o(91, s)) # define BOOST_PP_WHILE_91_I(p, o, s) BOOST_PP_IF(p(92, s), BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, o(92, s)) # define BOOST_PP_WHILE_92_I(p, o, s) BOOST_PP_IF(p(93, s), BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, o(93, s)) # define BOOST_PP_WHILE_93_I(p, o, s) BOOST_PP_IF(p(94, s), BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, o(94, s)) # define BOOST_PP_WHILE_94_I(p, o, s) BOOST_PP_IF(p(95, s), BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, o(95, s)) # define BOOST_PP_WHILE_95_I(p, o, s) BOOST_PP_IF(p(96, s), BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, o(96, s)) # define BOOST_PP_WHILE_96_I(p, o, s) BOOST_PP_IF(p(97, s), BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, o(97, s)) # define BOOST_PP_WHILE_97_I(p, o, s) BOOST_PP_IF(p(98, s), BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, o(98, s)) # define BOOST_PP_WHILE_98_I(p, o, s) BOOST_PP_IF(p(99, s), BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, o(99, s)) # define BOOST_PP_WHILE_99_I(p, o, s) BOOST_PP_IF(p(100, s), BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, o(100, s)) # define BOOST_PP_WHILE_100_I(p, o, s) BOOST_PP_IF(p(101, s), BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, o(101, s)) # define BOOST_PP_WHILE_101_I(p, o, s) BOOST_PP_IF(p(102, s), BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, o(102, s)) # define BOOST_PP_WHILE_102_I(p, o, s) BOOST_PP_IF(p(103, s), BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, o(103, s)) # define BOOST_PP_WHILE_103_I(p, o, s) BOOST_PP_IF(p(104, s), BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, o(104, s)) # define BOOST_PP_WHILE_104_I(p, o, s) BOOST_PP_IF(p(105, s), BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, o(105, s)) # define BOOST_PP_WHILE_105_I(p, o, s) BOOST_PP_IF(p(106, s), BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, o(106, s)) # define BOOST_PP_WHILE_106_I(p, o, s) BOOST_PP_IF(p(107, s), BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, o(107, s)) # define BOOST_PP_WHILE_107_I(p, o, s) BOOST_PP_IF(p(108, s), BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, o(108, s)) # define BOOST_PP_WHILE_108_I(p, o, s) BOOST_PP_IF(p(109, s), BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, o(109, s)) # define BOOST_PP_WHILE_109_I(p, o, s) BOOST_PP_IF(p(110, s), BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, o(110, s)) # define BOOST_PP_WHILE_110_I(p, o, s) BOOST_PP_IF(p(111, s), BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, o(111, s)) # define BOOST_PP_WHILE_111_I(p, o, s) BOOST_PP_IF(p(112, s), BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, o(112, s)) # define BOOST_PP_WHILE_112_I(p, o, s) BOOST_PP_IF(p(113, s), BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, o(113, s)) # define BOOST_PP_WHILE_113_I(p, o, s) BOOST_PP_IF(p(114, s), BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, o(114, s)) # define BOOST_PP_WHILE_114_I(p, o, s) BOOST_PP_IF(p(115, s), BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, o(115, s)) # define BOOST_PP_WHILE_115_I(p, o, s) BOOST_PP_IF(p(116, s), BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, o(116, s)) # define BOOST_PP_WHILE_116_I(p, o, s) BOOST_PP_IF(p(117, s), BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, o(117, s)) # define BOOST_PP_WHILE_117_I(p, o, s) BOOST_PP_IF(p(118, s), BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, o(118, s)) # define BOOST_PP_WHILE_118_I(p, o, s) BOOST_PP_IF(p(119, s), BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, o(119, s)) # define BOOST_PP_WHILE_119_I(p, o, s) BOOST_PP_IF(p(120, s), BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, o(120, s)) # define BOOST_PP_WHILE_120_I(p, o, s) BOOST_PP_IF(p(121, s), BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, o(121, s)) # define BOOST_PP_WHILE_121_I(p, o, s) BOOST_PP_IF(p(122, s), BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, o(122, s)) # define BOOST_PP_WHILE_122_I(p, o, s) BOOST_PP_IF(p(123, s), BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, o(123, s)) # define BOOST_PP_WHILE_123_I(p, o, s) BOOST_PP_IF(p(124, s), BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, o(124, s)) # define BOOST_PP_WHILE_124_I(p, o, s) BOOST_PP_IF(p(125, s), BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, o(125, s)) # define BOOST_PP_WHILE_125_I(p, o, s) BOOST_PP_IF(p(126, s), BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, o(126, s)) # define BOOST_PP_WHILE_126_I(p, o, s) BOOST_PP_IF(p(127, s), BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, o(127, s)) # define BOOST_PP_WHILE_127_I(p, o, s) BOOST_PP_IF(p(128, s), BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, o(128, s)) # define BOOST_PP_WHILE_128_I(p, o, s) BOOST_PP_IF(p(129, s), BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, o(129, s)) # define BOOST_PP_WHILE_129_I(p, o, s) BOOST_PP_IF(p(130, s), BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, o(130, s)) # define BOOST_PP_WHILE_130_I(p, o, s) BOOST_PP_IF(p(131, s), BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, o(131, s)) # define BOOST_PP_WHILE_131_I(p, o, s) BOOST_PP_IF(p(132, s), BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, o(132, s)) # define BOOST_PP_WHILE_132_I(p, o, s) BOOST_PP_IF(p(133, s), BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, o(133, s)) # define BOOST_PP_WHILE_133_I(p, o, s) BOOST_PP_IF(p(134, s), BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, o(134, s)) # define BOOST_PP_WHILE_134_I(p, o, s) BOOST_PP_IF(p(135, s), BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, o(135, s)) # define BOOST_PP_WHILE_135_I(p, o, s) BOOST_PP_IF(p(136, s), BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, o(136, s)) # define BOOST_PP_WHILE_136_I(p, o, s) BOOST_PP_IF(p(137, s), BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, o(137, s)) # define BOOST_PP_WHILE_137_I(p, o, s) BOOST_PP_IF(p(138, s), BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, o(138, s)) # define BOOST_PP_WHILE_138_I(p, o, s) BOOST_PP_IF(p(139, s), BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, o(139, s)) # define BOOST_PP_WHILE_139_I(p, o, s) BOOST_PP_IF(p(140, s), BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, o(140, s)) # define BOOST_PP_WHILE_140_I(p, o, s) BOOST_PP_IF(p(141, s), BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, o(141, s)) # define BOOST_PP_WHILE_141_I(p, o, s) BOOST_PP_IF(p(142, s), BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, o(142, s)) # define BOOST_PP_WHILE_142_I(p, o, s) BOOST_PP_IF(p(143, s), BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, o(143, s)) # define BOOST_PP_WHILE_143_I(p, o, s) BOOST_PP_IF(p(144, s), BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, o(144, s)) # define BOOST_PP_WHILE_144_I(p, o, s) BOOST_PP_IF(p(145, s), BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, o(145, s)) # define BOOST_PP_WHILE_145_I(p, o, s) BOOST_PP_IF(p(146, s), BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, o(146, s)) # define BOOST_PP_WHILE_146_I(p, o, s) BOOST_PP_IF(p(147, s), BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, o(147, s)) # define BOOST_PP_WHILE_147_I(p, o, s) BOOST_PP_IF(p(148, s), BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, o(148, s)) # define BOOST_PP_WHILE_148_I(p, o, s) BOOST_PP_IF(p(149, s), BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, o(149, s)) # define BOOST_PP_WHILE_149_I(p, o, s) BOOST_PP_IF(p(150, s), BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, o(150, s)) # define BOOST_PP_WHILE_150_I(p, o, s) BOOST_PP_IF(p(151, s), BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, o(151, s)) # define BOOST_PP_WHILE_151_I(p, o, s) BOOST_PP_IF(p(152, s), BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, o(152, s)) # define BOOST_PP_WHILE_152_I(p, o, s) BOOST_PP_IF(p(153, s), BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, o(153, s)) # define BOOST_PP_WHILE_153_I(p, o, s) BOOST_PP_IF(p(154, s), BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, o(154, s)) # define BOOST_PP_WHILE_154_I(p, o, s) BOOST_PP_IF(p(155, s), BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, o(155, s)) # define BOOST_PP_WHILE_155_I(p, o, s) BOOST_PP_IF(p(156, s), BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, o(156, s)) # define BOOST_PP_WHILE_156_I(p, o, s) BOOST_PP_IF(p(157, s), BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, o(157, s)) # define BOOST_PP_WHILE_157_I(p, o, s) BOOST_PP_IF(p(158, s), BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, o(158, s)) # define BOOST_PP_WHILE_158_I(p, o, s) BOOST_PP_IF(p(159, s), BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, o(159, s)) # define BOOST_PP_WHILE_159_I(p, o, s) BOOST_PP_IF(p(160, s), BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, o(160, s)) # define BOOST_PP_WHILE_160_I(p, o, s) BOOST_PP_IF(p(161, s), BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, o(161, s)) # define BOOST_PP_WHILE_161_I(p, o, s) BOOST_PP_IF(p(162, s), BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, o(162, s)) # define BOOST_PP_WHILE_162_I(p, o, s) BOOST_PP_IF(p(163, s), BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, o(163, s)) # define BOOST_PP_WHILE_163_I(p, o, s) BOOST_PP_IF(p(164, s), BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, o(164, s)) # define BOOST_PP_WHILE_164_I(p, o, s) BOOST_PP_IF(p(165, s), BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, o(165, s)) # define BOOST_PP_WHILE_165_I(p, o, s) BOOST_PP_IF(p(166, s), BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, o(166, s)) # define BOOST_PP_WHILE_166_I(p, o, s) BOOST_PP_IF(p(167, s), BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, o(167, s)) # define BOOST_PP_WHILE_167_I(p, o, s) BOOST_PP_IF(p(168, s), BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, o(168, s)) # define BOOST_PP_WHILE_168_I(p, o, s) BOOST_PP_IF(p(169, s), BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, o(169, s)) # define BOOST_PP_WHILE_169_I(p, o, s) BOOST_PP_IF(p(170, s), BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, o(170, s)) # define BOOST_PP_WHILE_170_I(p, o, s) BOOST_PP_IF(p(171, s), BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, o(171, s)) # define BOOST_PP_WHILE_171_I(p, o, s) BOOST_PP_IF(p(172, s), BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, o(172, s)) # define BOOST_PP_WHILE_172_I(p, o, s) BOOST_PP_IF(p(173, s), BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, o(173, s)) # define BOOST_PP_WHILE_173_I(p, o, s) BOOST_PP_IF(p(174, s), BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, o(174, s)) # define BOOST_PP_WHILE_174_I(p, o, s) BOOST_PP_IF(p(175, s), BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, o(175, s)) # define BOOST_PP_WHILE_175_I(p, o, s) BOOST_PP_IF(p(176, s), BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, o(176, s)) # define BOOST_PP_WHILE_176_I(p, o, s) BOOST_PP_IF(p(177, s), BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, o(177, s)) # define BOOST_PP_WHILE_177_I(p, o, s) BOOST_PP_IF(p(178, s), BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, o(178, s)) # define BOOST_PP_WHILE_178_I(p, o, s) BOOST_PP_IF(p(179, s), BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, o(179, s)) # define BOOST_PP_WHILE_179_I(p, o, s) BOOST_PP_IF(p(180, s), BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, o(180, s)) # define BOOST_PP_WHILE_180_I(p, o, s) BOOST_PP_IF(p(181, s), BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, o(181, s)) # define BOOST_PP_WHILE_181_I(p, o, s) BOOST_PP_IF(p(182, s), BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, o(182, s)) # define BOOST_PP_WHILE_182_I(p, o, s) BOOST_PP_IF(p(183, s), BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, o(183, s)) # define BOOST_PP_WHILE_183_I(p, o, s) BOOST_PP_IF(p(184, s), BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, o(184, s)) # define BOOST_PP_WHILE_184_I(p, o, s) BOOST_PP_IF(p(185, s), BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, o(185, s)) # define BOOST_PP_WHILE_185_I(p, o, s) BOOST_PP_IF(p(186, s), BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, o(186, s)) # define BOOST_PP_WHILE_186_I(p, o, s) BOOST_PP_IF(p(187, s), BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, o(187, s)) # define BOOST_PP_WHILE_187_I(p, o, s) BOOST_PP_IF(p(188, s), BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, o(188, s)) # define BOOST_PP_WHILE_188_I(p, o, s) BOOST_PP_IF(p(189, s), BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, o(189, s)) # define BOOST_PP_WHILE_189_I(p, o, s) BOOST_PP_IF(p(190, s), BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, o(190, s)) # define BOOST_PP_WHILE_190_I(p, o, s) BOOST_PP_IF(p(191, s), BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, o(191, s)) # define BOOST_PP_WHILE_191_I(p, o, s) BOOST_PP_IF(p(192, s), BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, o(192, s)) # define BOOST_PP_WHILE_192_I(p, o, s) BOOST_PP_IF(p(193, s), BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, o(193, s)) # define BOOST_PP_WHILE_193_I(p, o, s) BOOST_PP_IF(p(194, s), BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, o(194, s)) # define BOOST_PP_WHILE_194_I(p, o, s) BOOST_PP_IF(p(195, s), BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, o(195, s)) # define BOOST_PP_WHILE_195_I(p, o, s) BOOST_PP_IF(p(196, s), BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, o(196, s)) # define BOOST_PP_WHILE_196_I(p, o, s) BOOST_PP_IF(p(197, s), BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, o(197, s)) # define BOOST_PP_WHILE_197_I(p, o, s) BOOST_PP_IF(p(198, s), BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, o(198, s)) # define BOOST_PP_WHILE_198_I(p, o, s) BOOST_PP_IF(p(199, s), BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, o(199, s)) # define BOOST_PP_WHILE_199_I(p, o, s) BOOST_PP_IF(p(200, s), BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, o(200, s)) # define BOOST_PP_WHILE_200_I(p, o, s) BOOST_PP_IF(p(201, s), BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, o(201, s)) # define BOOST_PP_WHILE_201_I(p, o, s) BOOST_PP_IF(p(202, s), BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, o(202, s)) # define BOOST_PP_WHILE_202_I(p, o, s) BOOST_PP_IF(p(203, s), BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, o(203, s)) # define BOOST_PP_WHILE_203_I(p, o, s) BOOST_PP_IF(p(204, s), BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, o(204, s)) # define BOOST_PP_WHILE_204_I(p, o, s) BOOST_PP_IF(p(205, s), BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, o(205, s)) # define BOOST_PP_WHILE_205_I(p, o, s) BOOST_PP_IF(p(206, s), BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, o(206, s)) # define BOOST_PP_WHILE_206_I(p, o, s) BOOST_PP_IF(p(207, s), BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, o(207, s)) # define BOOST_PP_WHILE_207_I(p, o, s) BOOST_PP_IF(p(208, s), BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, o(208, s)) # define BOOST_PP_WHILE_208_I(p, o, s) BOOST_PP_IF(p(209, s), BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, o(209, s)) # define BOOST_PP_WHILE_209_I(p, o, s) BOOST_PP_IF(p(210, s), BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, o(210, s)) # define BOOST_PP_WHILE_210_I(p, o, s) BOOST_PP_IF(p(211, s), BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, o(211, s)) # define BOOST_PP_WHILE_211_I(p, o, s) BOOST_PP_IF(p(212, s), BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, o(212, s)) # define BOOST_PP_WHILE_212_I(p, o, s) BOOST_PP_IF(p(213, s), BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, o(213, s)) # define BOOST_PP_WHILE_213_I(p, o, s) BOOST_PP_IF(p(214, s), BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, o(214, s)) # define BOOST_PP_WHILE_214_I(p, o, s) BOOST_PP_IF(p(215, s), BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, o(215, s)) # define BOOST_PP_WHILE_215_I(p, o, s) BOOST_PP_IF(p(216, s), BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, o(216, s)) # define BOOST_PP_WHILE_216_I(p, o, s) BOOST_PP_IF(p(217, s), BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, o(217, s)) # define BOOST_PP_WHILE_217_I(p, o, s) BOOST_PP_IF(p(218, s), BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, o(218, s)) # define BOOST_PP_WHILE_218_I(p, o, s) BOOST_PP_IF(p(219, s), BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, o(219, s)) # define BOOST_PP_WHILE_219_I(p, o, s) BOOST_PP_IF(p(220, s), BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, o(220, s)) # define BOOST_PP_WHILE_220_I(p, o, s) BOOST_PP_IF(p(221, s), BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, o(221, s)) # define BOOST_PP_WHILE_221_I(p, o, s) BOOST_PP_IF(p(222, s), BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, o(222, s)) # define BOOST_PP_WHILE_222_I(p, o, s) BOOST_PP_IF(p(223, s), BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, o(223, s)) # define BOOST_PP_WHILE_223_I(p, o, s) BOOST_PP_IF(p(224, s), BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, o(224, s)) # define BOOST_PP_WHILE_224_I(p, o, s) BOOST_PP_IF(p(225, s), BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, o(225, s)) # define BOOST_PP_WHILE_225_I(p, o, s) BOOST_PP_IF(p(226, s), BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, o(226, s)) # define BOOST_PP_WHILE_226_I(p, o, s) BOOST_PP_IF(p(227, s), BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, o(227, s)) # define BOOST_PP_WHILE_227_I(p, o, s) BOOST_PP_IF(p(228, s), BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, o(228, s)) # define BOOST_PP_WHILE_228_I(p, o, s) BOOST_PP_IF(p(229, s), BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, o(229, s)) # define BOOST_PP_WHILE_229_I(p, o, s) BOOST_PP_IF(p(230, s), BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, o(230, s)) # define BOOST_PP_WHILE_230_I(p, o, s) BOOST_PP_IF(p(231, s), BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, o(231, s)) # define BOOST_PP_WHILE_231_I(p, o, s) BOOST_PP_IF(p(232, s), BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, o(232, s)) # define BOOST_PP_WHILE_232_I(p, o, s) BOOST_PP_IF(p(233, s), BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, o(233, s)) # define BOOST_PP_WHILE_233_I(p, o, s) BOOST_PP_IF(p(234, s), BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, o(234, s)) # define BOOST_PP_WHILE_234_I(p, o, s) BOOST_PP_IF(p(235, s), BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, o(235, s)) # define BOOST_PP_WHILE_235_I(p, o, s) BOOST_PP_IF(p(236, s), BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, o(236, s)) # define BOOST_PP_WHILE_236_I(p, o, s) BOOST_PP_IF(p(237, s), BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, o(237, s)) # define BOOST_PP_WHILE_237_I(p, o, s) BOOST_PP_IF(p(238, s), BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, o(238, s)) # define BOOST_PP_WHILE_238_I(p, o, s) BOOST_PP_IF(p(239, s), BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, o(239, s)) # define BOOST_PP_WHILE_239_I(p, o, s) BOOST_PP_IF(p(240, s), BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, o(240, s)) # define BOOST_PP_WHILE_240_I(p, o, s) BOOST_PP_IF(p(241, s), BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, o(241, s)) # define BOOST_PP_WHILE_241_I(p, o, s) BOOST_PP_IF(p(242, s), BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, o(242, s)) # define BOOST_PP_WHILE_242_I(p, o, s) BOOST_PP_IF(p(243, s), BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, o(243, s)) # define BOOST_PP_WHILE_243_I(p, o, s) BOOST_PP_IF(p(244, s), BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, o(244, s)) # define BOOST_PP_WHILE_244_I(p, o, s) BOOST_PP_IF(p(245, s), BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, o(245, s)) # define BOOST_PP_WHILE_245_I(p, o, s) BOOST_PP_IF(p(246, s), BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, o(246, s)) # define BOOST_PP_WHILE_246_I(p, o, s) BOOST_PP_IF(p(247, s), BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, o(247, s)) # define BOOST_PP_WHILE_247_I(p, o, s) BOOST_PP_IF(p(248, s), BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, o(248, s)) # define BOOST_PP_WHILE_248_I(p, o, s) BOOST_PP_IF(p(249, s), BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, o(249, s)) # define BOOST_PP_WHILE_249_I(p, o, s) BOOST_PP_IF(p(250, s), BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, o(250, s)) # define BOOST_PP_WHILE_250_I(p, o, s) BOOST_PP_IF(p(251, s), BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, o(251, s)) # define BOOST_PP_WHILE_251_I(p, o, s) BOOST_PP_IF(p(252, s), BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, o(252, s)) # define BOOST_PP_WHILE_252_I(p, o, s) BOOST_PP_IF(p(253, s), BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, o(253, s)) # define BOOST_PP_WHILE_253_I(p, o, s) BOOST_PP_IF(p(254, s), BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, o(254, s)) # define BOOST_PP_WHILE_254_I(p, o, s) BOOST_PP_IF(p(255, s), BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, o(255, s)) # define BOOST_PP_WHILE_255_I(p, o, s) BOOST_PP_IF(p(256, s), BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, o(256, s)) # define BOOST_PP_WHILE_256_I(p, o, s) BOOST_PP_IF(p(257, s), BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, o(257, s)) # # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/msvc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000755000175000017500000000000012146213763031664 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/detail/msvc/while.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/control/0000644000175000017500000007462611344301502031671 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONTROL_DETAIL_MSVC_WHILE_HPP # define BOOST_PREPROCESSOR_CONTROL_DETAIL_MSVC_WHILE_HPP # # include # include # # define BOOST_PP_WHILE_1(p, o, s) BOOST_PP_IF(p(2, s), BOOST_PP_WHILE_2, s BOOST_PP_TUPLE_EAT_3)(p, o, o(2, s)) # define BOOST_PP_WHILE_2(p, o, s) BOOST_PP_IF(p(3, s), BOOST_PP_WHILE_3, s BOOST_PP_TUPLE_EAT_3)(p, o, o(3, s)) # define BOOST_PP_WHILE_3(p, o, s) BOOST_PP_IF(p(4, s), BOOST_PP_WHILE_4, s BOOST_PP_TUPLE_EAT_3)(p, o, o(4, s)) # define BOOST_PP_WHILE_4(p, o, s) BOOST_PP_IF(p(5, s), BOOST_PP_WHILE_5, s BOOST_PP_TUPLE_EAT_3)(p, o, o(5, s)) # define BOOST_PP_WHILE_5(p, o, s) BOOST_PP_IF(p(6, s), BOOST_PP_WHILE_6, s BOOST_PP_TUPLE_EAT_3)(p, o, o(6, s)) # define BOOST_PP_WHILE_6(p, o, s) BOOST_PP_IF(p(7, s), BOOST_PP_WHILE_7, s BOOST_PP_TUPLE_EAT_3)(p, o, o(7, s)) # define BOOST_PP_WHILE_7(p, o, s) BOOST_PP_IF(p(8, s), BOOST_PP_WHILE_8, s BOOST_PP_TUPLE_EAT_3)(p, o, o(8, s)) # define BOOST_PP_WHILE_8(p, o, s) BOOST_PP_IF(p(9, s), BOOST_PP_WHILE_9, s BOOST_PP_TUPLE_EAT_3)(p, o, o(9, s)) # define BOOST_PP_WHILE_9(p, o, s) BOOST_PP_IF(p(10, s), BOOST_PP_WHILE_10, s BOOST_PP_TUPLE_EAT_3)(p, o, o(10, s)) # define BOOST_PP_WHILE_10(p, o, s) BOOST_PP_IF(p(11, s), BOOST_PP_WHILE_11, s BOOST_PP_TUPLE_EAT_3)(p, o, o(11, s)) # define BOOST_PP_WHILE_11(p, o, s) BOOST_PP_IF(p(12, s), BOOST_PP_WHILE_12, s BOOST_PP_TUPLE_EAT_3)(p, o, o(12, s)) # define BOOST_PP_WHILE_12(p, o, s) BOOST_PP_IF(p(13, s), BOOST_PP_WHILE_13, s BOOST_PP_TUPLE_EAT_3)(p, o, o(13, s)) # define BOOST_PP_WHILE_13(p, o, s) BOOST_PP_IF(p(14, s), BOOST_PP_WHILE_14, s BOOST_PP_TUPLE_EAT_3)(p, o, o(14, s)) # define BOOST_PP_WHILE_14(p, o, s) BOOST_PP_IF(p(15, s), BOOST_PP_WHILE_15, s BOOST_PP_TUPLE_EAT_3)(p, o, o(15, s)) # define BOOST_PP_WHILE_15(p, o, s) BOOST_PP_IF(p(16, s), BOOST_PP_WHILE_16, s BOOST_PP_TUPLE_EAT_3)(p, o, o(16, s)) # define BOOST_PP_WHILE_16(p, o, s) BOOST_PP_IF(p(17, s), BOOST_PP_WHILE_17, s BOOST_PP_TUPLE_EAT_3)(p, o, o(17, s)) # define BOOST_PP_WHILE_17(p, o, s) BOOST_PP_IF(p(18, s), BOOST_PP_WHILE_18, s BOOST_PP_TUPLE_EAT_3)(p, o, o(18, s)) # define BOOST_PP_WHILE_18(p, o, s) BOOST_PP_IF(p(19, s), BOOST_PP_WHILE_19, s BOOST_PP_TUPLE_EAT_3)(p, o, o(19, s)) # define BOOST_PP_WHILE_19(p, o, s) BOOST_PP_IF(p(20, s), BOOST_PP_WHILE_20, s BOOST_PP_TUPLE_EAT_3)(p, o, o(20, s)) # define BOOST_PP_WHILE_20(p, o, s) BOOST_PP_IF(p(21, s), BOOST_PP_WHILE_21, s BOOST_PP_TUPLE_EAT_3)(p, o, o(21, s)) # define BOOST_PP_WHILE_21(p, o, s) BOOST_PP_IF(p(22, s), BOOST_PP_WHILE_22, s BOOST_PP_TUPLE_EAT_3)(p, o, o(22, s)) # define BOOST_PP_WHILE_22(p, o, s) BOOST_PP_IF(p(23, s), BOOST_PP_WHILE_23, s BOOST_PP_TUPLE_EAT_3)(p, o, o(23, s)) # define BOOST_PP_WHILE_23(p, o, s) BOOST_PP_IF(p(24, s), BOOST_PP_WHILE_24, s BOOST_PP_TUPLE_EAT_3)(p, o, o(24, s)) # define BOOST_PP_WHILE_24(p, o, s) BOOST_PP_IF(p(25, s), BOOST_PP_WHILE_25, s BOOST_PP_TUPLE_EAT_3)(p, o, o(25, s)) # define BOOST_PP_WHILE_25(p, o, s) BOOST_PP_IF(p(26, s), BOOST_PP_WHILE_26, s BOOST_PP_TUPLE_EAT_3)(p, o, o(26, s)) # define BOOST_PP_WHILE_26(p, o, s) BOOST_PP_IF(p(27, s), BOOST_PP_WHILE_27, s BOOST_PP_TUPLE_EAT_3)(p, o, o(27, s)) # define BOOST_PP_WHILE_27(p, o, s) BOOST_PP_IF(p(28, s), BOOST_PP_WHILE_28, s BOOST_PP_TUPLE_EAT_3)(p, o, o(28, s)) # define BOOST_PP_WHILE_28(p, o, s) BOOST_PP_IF(p(29, s), BOOST_PP_WHILE_29, s BOOST_PP_TUPLE_EAT_3)(p, o, o(29, s)) # define BOOST_PP_WHILE_29(p, o, s) BOOST_PP_IF(p(30, s), BOOST_PP_WHILE_30, s BOOST_PP_TUPLE_EAT_3)(p, o, o(30, s)) # define BOOST_PP_WHILE_30(p, o, s) BOOST_PP_IF(p(31, s), BOOST_PP_WHILE_31, s BOOST_PP_TUPLE_EAT_3)(p, o, o(31, s)) # define BOOST_PP_WHILE_31(p, o, s) BOOST_PP_IF(p(32, s), BOOST_PP_WHILE_32, s BOOST_PP_TUPLE_EAT_3)(p, o, o(32, s)) # define BOOST_PP_WHILE_32(p, o, s) BOOST_PP_IF(p(33, s), BOOST_PP_WHILE_33, s BOOST_PP_TUPLE_EAT_3)(p, o, o(33, s)) # define BOOST_PP_WHILE_33(p, o, s) BOOST_PP_IF(p(34, s), BOOST_PP_WHILE_34, s BOOST_PP_TUPLE_EAT_3)(p, o, o(34, s)) # define BOOST_PP_WHILE_34(p, o, s) BOOST_PP_IF(p(35, s), BOOST_PP_WHILE_35, s BOOST_PP_TUPLE_EAT_3)(p, o, o(35, s)) # define BOOST_PP_WHILE_35(p, o, s) BOOST_PP_IF(p(36, s), BOOST_PP_WHILE_36, s BOOST_PP_TUPLE_EAT_3)(p, o, o(36, s)) # define BOOST_PP_WHILE_36(p, o, s) BOOST_PP_IF(p(37, s), BOOST_PP_WHILE_37, s BOOST_PP_TUPLE_EAT_3)(p, o, o(37, s)) # define BOOST_PP_WHILE_37(p, o, s) BOOST_PP_IF(p(38, s), BOOST_PP_WHILE_38, s BOOST_PP_TUPLE_EAT_3)(p, o, o(38, s)) # define BOOST_PP_WHILE_38(p, o, s) BOOST_PP_IF(p(39, s), BOOST_PP_WHILE_39, s BOOST_PP_TUPLE_EAT_3)(p, o, o(39, s)) # define BOOST_PP_WHILE_39(p, o, s) BOOST_PP_IF(p(40, s), BOOST_PP_WHILE_40, s BOOST_PP_TUPLE_EAT_3)(p, o, o(40, s)) # define BOOST_PP_WHILE_40(p, o, s) BOOST_PP_IF(p(41, s), BOOST_PP_WHILE_41, s BOOST_PP_TUPLE_EAT_3)(p, o, o(41, s)) # define BOOST_PP_WHILE_41(p, o, s) BOOST_PP_IF(p(42, s), BOOST_PP_WHILE_42, s BOOST_PP_TUPLE_EAT_3)(p, o, o(42, s)) # define BOOST_PP_WHILE_42(p, o, s) BOOST_PP_IF(p(43, s), BOOST_PP_WHILE_43, s BOOST_PP_TUPLE_EAT_3)(p, o, o(43, s)) # define BOOST_PP_WHILE_43(p, o, s) BOOST_PP_IF(p(44, s), BOOST_PP_WHILE_44, s BOOST_PP_TUPLE_EAT_3)(p, o, o(44, s)) # define BOOST_PP_WHILE_44(p, o, s) BOOST_PP_IF(p(45, s), BOOST_PP_WHILE_45, s BOOST_PP_TUPLE_EAT_3)(p, o, o(45, s)) # define BOOST_PP_WHILE_45(p, o, s) BOOST_PP_IF(p(46, s), BOOST_PP_WHILE_46, s BOOST_PP_TUPLE_EAT_3)(p, o, o(46, s)) # define BOOST_PP_WHILE_46(p, o, s) BOOST_PP_IF(p(47, s), BOOST_PP_WHILE_47, s BOOST_PP_TUPLE_EAT_3)(p, o, o(47, s)) # define BOOST_PP_WHILE_47(p, o, s) BOOST_PP_IF(p(48, s), BOOST_PP_WHILE_48, s BOOST_PP_TUPLE_EAT_3)(p, o, o(48, s)) # define BOOST_PP_WHILE_48(p, o, s) BOOST_PP_IF(p(49, s), BOOST_PP_WHILE_49, s BOOST_PP_TUPLE_EAT_3)(p, o, o(49, s)) # define BOOST_PP_WHILE_49(p, o, s) BOOST_PP_IF(p(50, s), BOOST_PP_WHILE_50, s BOOST_PP_TUPLE_EAT_3)(p, o, o(50, s)) # define BOOST_PP_WHILE_50(p, o, s) BOOST_PP_IF(p(51, s), BOOST_PP_WHILE_51, s BOOST_PP_TUPLE_EAT_3)(p, o, o(51, s)) # define BOOST_PP_WHILE_51(p, o, s) BOOST_PP_IF(p(52, s), BOOST_PP_WHILE_52, s BOOST_PP_TUPLE_EAT_3)(p, o, o(52, s)) # define BOOST_PP_WHILE_52(p, o, s) BOOST_PP_IF(p(53, s), BOOST_PP_WHILE_53, s BOOST_PP_TUPLE_EAT_3)(p, o, o(53, s)) # define BOOST_PP_WHILE_53(p, o, s) BOOST_PP_IF(p(54, s), BOOST_PP_WHILE_54, s BOOST_PP_TUPLE_EAT_3)(p, o, o(54, s)) # define BOOST_PP_WHILE_54(p, o, s) BOOST_PP_IF(p(55, s), BOOST_PP_WHILE_55, s BOOST_PP_TUPLE_EAT_3)(p, o, o(55, s)) # define BOOST_PP_WHILE_55(p, o, s) BOOST_PP_IF(p(56, s), BOOST_PP_WHILE_56, s BOOST_PP_TUPLE_EAT_3)(p, o, o(56, s)) # define BOOST_PP_WHILE_56(p, o, s) BOOST_PP_IF(p(57, s), BOOST_PP_WHILE_57, s BOOST_PP_TUPLE_EAT_3)(p, o, o(57, s)) # define BOOST_PP_WHILE_57(p, o, s) BOOST_PP_IF(p(58, s), BOOST_PP_WHILE_58, s BOOST_PP_TUPLE_EAT_3)(p, o, o(58, s)) # define BOOST_PP_WHILE_58(p, o, s) BOOST_PP_IF(p(59, s), BOOST_PP_WHILE_59, s BOOST_PP_TUPLE_EAT_3)(p, o, o(59, s)) # define BOOST_PP_WHILE_59(p, o, s) BOOST_PP_IF(p(60, s), BOOST_PP_WHILE_60, s BOOST_PP_TUPLE_EAT_3)(p, o, o(60, s)) # define BOOST_PP_WHILE_60(p, o, s) BOOST_PP_IF(p(61, s), BOOST_PP_WHILE_61, s BOOST_PP_TUPLE_EAT_3)(p, o, o(61, s)) # define BOOST_PP_WHILE_61(p, o, s) BOOST_PP_IF(p(62, s), BOOST_PP_WHILE_62, s BOOST_PP_TUPLE_EAT_3)(p, o, o(62, s)) # define BOOST_PP_WHILE_62(p, o, s) BOOST_PP_IF(p(63, s), BOOST_PP_WHILE_63, s BOOST_PP_TUPLE_EAT_3)(p, o, o(63, s)) # define BOOST_PP_WHILE_63(p, o, s) BOOST_PP_IF(p(64, s), BOOST_PP_WHILE_64, s BOOST_PP_TUPLE_EAT_3)(p, o, o(64, s)) # define BOOST_PP_WHILE_64(p, o, s) BOOST_PP_IF(p(65, s), BOOST_PP_WHILE_65, s BOOST_PP_TUPLE_EAT_3)(p, o, o(65, s)) # define BOOST_PP_WHILE_65(p, o, s) BOOST_PP_IF(p(66, s), BOOST_PP_WHILE_66, s BOOST_PP_TUPLE_EAT_3)(p, o, o(66, s)) # define BOOST_PP_WHILE_66(p, o, s) BOOST_PP_IF(p(67, s), BOOST_PP_WHILE_67, s BOOST_PP_TUPLE_EAT_3)(p, o, o(67, s)) # define BOOST_PP_WHILE_67(p, o, s) BOOST_PP_IF(p(68, s), BOOST_PP_WHILE_68, s BOOST_PP_TUPLE_EAT_3)(p, o, o(68, s)) # define BOOST_PP_WHILE_68(p, o, s) BOOST_PP_IF(p(69, s), BOOST_PP_WHILE_69, s BOOST_PP_TUPLE_EAT_3)(p, o, o(69, s)) # define BOOST_PP_WHILE_69(p, o, s) BOOST_PP_IF(p(70, s), BOOST_PP_WHILE_70, s BOOST_PP_TUPLE_EAT_3)(p, o, o(70, s)) # define BOOST_PP_WHILE_70(p, o, s) BOOST_PP_IF(p(71, s), BOOST_PP_WHILE_71, s BOOST_PP_TUPLE_EAT_3)(p, o, o(71, s)) # define BOOST_PP_WHILE_71(p, o, s) BOOST_PP_IF(p(72, s), BOOST_PP_WHILE_72, s BOOST_PP_TUPLE_EAT_3)(p, o, o(72, s)) # define BOOST_PP_WHILE_72(p, o, s) BOOST_PP_IF(p(73, s), BOOST_PP_WHILE_73, s BOOST_PP_TUPLE_EAT_3)(p, o, o(73, s)) # define BOOST_PP_WHILE_73(p, o, s) BOOST_PP_IF(p(74, s), BOOST_PP_WHILE_74, s BOOST_PP_TUPLE_EAT_3)(p, o, o(74, s)) # define BOOST_PP_WHILE_74(p, o, s) BOOST_PP_IF(p(75, s), BOOST_PP_WHILE_75, s BOOST_PP_TUPLE_EAT_3)(p, o, o(75, s)) # define BOOST_PP_WHILE_75(p, o, s) BOOST_PP_IF(p(76, s), BOOST_PP_WHILE_76, s BOOST_PP_TUPLE_EAT_3)(p, o, o(76, s)) # define BOOST_PP_WHILE_76(p, o, s) BOOST_PP_IF(p(77, s), BOOST_PP_WHILE_77, s BOOST_PP_TUPLE_EAT_3)(p, o, o(77, s)) # define BOOST_PP_WHILE_77(p, o, s) BOOST_PP_IF(p(78, s), BOOST_PP_WHILE_78, s BOOST_PP_TUPLE_EAT_3)(p, o, o(78, s)) # define BOOST_PP_WHILE_78(p, o, s) BOOST_PP_IF(p(79, s), BOOST_PP_WHILE_79, s BOOST_PP_TUPLE_EAT_3)(p, o, o(79, s)) # define BOOST_PP_WHILE_79(p, o, s) BOOST_PP_IF(p(80, s), BOOST_PP_WHILE_80, s BOOST_PP_TUPLE_EAT_3)(p, o, o(80, s)) # define BOOST_PP_WHILE_80(p, o, s) BOOST_PP_IF(p(81, s), BOOST_PP_WHILE_81, s BOOST_PP_TUPLE_EAT_3)(p, o, o(81, s)) # define BOOST_PP_WHILE_81(p, o, s) BOOST_PP_IF(p(82, s), BOOST_PP_WHILE_82, s BOOST_PP_TUPLE_EAT_3)(p, o, o(82, s)) # define BOOST_PP_WHILE_82(p, o, s) BOOST_PP_IF(p(83, s), BOOST_PP_WHILE_83, s BOOST_PP_TUPLE_EAT_3)(p, o, o(83, s)) # define BOOST_PP_WHILE_83(p, o, s) BOOST_PP_IF(p(84, s), BOOST_PP_WHILE_84, s BOOST_PP_TUPLE_EAT_3)(p, o, o(84, s)) # define BOOST_PP_WHILE_84(p, o, s) BOOST_PP_IF(p(85, s), BOOST_PP_WHILE_85, s BOOST_PP_TUPLE_EAT_3)(p, o, o(85, s)) # define BOOST_PP_WHILE_85(p, o, s) BOOST_PP_IF(p(86, s), BOOST_PP_WHILE_86, s BOOST_PP_TUPLE_EAT_3)(p, o, o(86, s)) # define BOOST_PP_WHILE_86(p, o, s) BOOST_PP_IF(p(87, s), BOOST_PP_WHILE_87, s BOOST_PP_TUPLE_EAT_3)(p, o, o(87, s)) # define BOOST_PP_WHILE_87(p, o, s) BOOST_PP_IF(p(88, s), BOOST_PP_WHILE_88, s BOOST_PP_TUPLE_EAT_3)(p, o, o(88, s)) # define BOOST_PP_WHILE_88(p, o, s) BOOST_PP_IF(p(89, s), BOOST_PP_WHILE_89, s BOOST_PP_TUPLE_EAT_3)(p, o, o(89, s)) # define BOOST_PP_WHILE_89(p, o, s) BOOST_PP_IF(p(90, s), BOOST_PP_WHILE_90, s BOOST_PP_TUPLE_EAT_3)(p, o, o(90, s)) # define BOOST_PP_WHILE_90(p, o, s) BOOST_PP_IF(p(91, s), BOOST_PP_WHILE_91, s BOOST_PP_TUPLE_EAT_3)(p, o, o(91, s)) # define BOOST_PP_WHILE_91(p, o, s) BOOST_PP_IF(p(92, s), BOOST_PP_WHILE_92, s BOOST_PP_TUPLE_EAT_3)(p, o, o(92, s)) # define BOOST_PP_WHILE_92(p, o, s) BOOST_PP_IF(p(93, s), BOOST_PP_WHILE_93, s BOOST_PP_TUPLE_EAT_3)(p, o, o(93, s)) # define BOOST_PP_WHILE_93(p, o, s) BOOST_PP_IF(p(94, s), BOOST_PP_WHILE_94, s BOOST_PP_TUPLE_EAT_3)(p, o, o(94, s)) # define BOOST_PP_WHILE_94(p, o, s) BOOST_PP_IF(p(95, s), BOOST_PP_WHILE_95, s BOOST_PP_TUPLE_EAT_3)(p, o, o(95, s)) # define BOOST_PP_WHILE_95(p, o, s) BOOST_PP_IF(p(96, s), BOOST_PP_WHILE_96, s BOOST_PP_TUPLE_EAT_3)(p, o, o(96, s)) # define BOOST_PP_WHILE_96(p, o, s) BOOST_PP_IF(p(97, s), BOOST_PP_WHILE_97, s BOOST_PP_TUPLE_EAT_3)(p, o, o(97, s)) # define BOOST_PP_WHILE_97(p, o, s) BOOST_PP_IF(p(98, s), BOOST_PP_WHILE_98, s BOOST_PP_TUPLE_EAT_3)(p, o, o(98, s)) # define BOOST_PP_WHILE_98(p, o, s) BOOST_PP_IF(p(99, s), BOOST_PP_WHILE_99, s BOOST_PP_TUPLE_EAT_3)(p, o, o(99, s)) # define BOOST_PP_WHILE_99(p, o, s) BOOST_PP_IF(p(100, s), BOOST_PP_WHILE_100, s BOOST_PP_TUPLE_EAT_3)(p, o, o(100, s)) # define BOOST_PP_WHILE_100(p, o, s) BOOST_PP_IF(p(101, s), BOOST_PP_WHILE_101, s BOOST_PP_TUPLE_EAT_3)(p, o, o(101, s)) # define BOOST_PP_WHILE_101(p, o, s) BOOST_PP_IF(p(102, s), BOOST_PP_WHILE_102, s BOOST_PP_TUPLE_EAT_3)(p, o, o(102, s)) # define BOOST_PP_WHILE_102(p, o, s) BOOST_PP_IF(p(103, s), BOOST_PP_WHILE_103, s BOOST_PP_TUPLE_EAT_3)(p, o, o(103, s)) # define BOOST_PP_WHILE_103(p, o, s) BOOST_PP_IF(p(104, s), BOOST_PP_WHILE_104, s BOOST_PP_TUPLE_EAT_3)(p, o, o(104, s)) # define BOOST_PP_WHILE_104(p, o, s) BOOST_PP_IF(p(105, s), BOOST_PP_WHILE_105, s BOOST_PP_TUPLE_EAT_3)(p, o, o(105, s)) # define BOOST_PP_WHILE_105(p, o, s) BOOST_PP_IF(p(106, s), BOOST_PP_WHILE_106, s BOOST_PP_TUPLE_EAT_3)(p, o, o(106, s)) # define BOOST_PP_WHILE_106(p, o, s) BOOST_PP_IF(p(107, s), BOOST_PP_WHILE_107, s BOOST_PP_TUPLE_EAT_3)(p, o, o(107, s)) # define BOOST_PP_WHILE_107(p, o, s) BOOST_PP_IF(p(108, s), BOOST_PP_WHILE_108, s BOOST_PP_TUPLE_EAT_3)(p, o, o(108, s)) # define BOOST_PP_WHILE_108(p, o, s) BOOST_PP_IF(p(109, s), BOOST_PP_WHILE_109, s BOOST_PP_TUPLE_EAT_3)(p, o, o(109, s)) # define BOOST_PP_WHILE_109(p, o, s) BOOST_PP_IF(p(110, s), BOOST_PP_WHILE_110, s BOOST_PP_TUPLE_EAT_3)(p, o, o(110, s)) # define BOOST_PP_WHILE_110(p, o, s) BOOST_PP_IF(p(111, s), BOOST_PP_WHILE_111, s BOOST_PP_TUPLE_EAT_3)(p, o, o(111, s)) # define BOOST_PP_WHILE_111(p, o, s) BOOST_PP_IF(p(112, s), BOOST_PP_WHILE_112, s BOOST_PP_TUPLE_EAT_3)(p, o, o(112, s)) # define BOOST_PP_WHILE_112(p, o, s) BOOST_PP_IF(p(113, s), BOOST_PP_WHILE_113, s BOOST_PP_TUPLE_EAT_3)(p, o, o(113, s)) # define BOOST_PP_WHILE_113(p, o, s) BOOST_PP_IF(p(114, s), BOOST_PP_WHILE_114, s BOOST_PP_TUPLE_EAT_3)(p, o, o(114, s)) # define BOOST_PP_WHILE_114(p, o, s) BOOST_PP_IF(p(115, s), BOOST_PP_WHILE_115, s BOOST_PP_TUPLE_EAT_3)(p, o, o(115, s)) # define BOOST_PP_WHILE_115(p, o, s) BOOST_PP_IF(p(116, s), BOOST_PP_WHILE_116, s BOOST_PP_TUPLE_EAT_3)(p, o, o(116, s)) # define BOOST_PP_WHILE_116(p, o, s) BOOST_PP_IF(p(117, s), BOOST_PP_WHILE_117, s BOOST_PP_TUPLE_EAT_3)(p, o, o(117, s)) # define BOOST_PP_WHILE_117(p, o, s) BOOST_PP_IF(p(118, s), BOOST_PP_WHILE_118, s BOOST_PP_TUPLE_EAT_3)(p, o, o(118, s)) # define BOOST_PP_WHILE_118(p, o, s) BOOST_PP_IF(p(119, s), BOOST_PP_WHILE_119, s BOOST_PP_TUPLE_EAT_3)(p, o, o(119, s)) # define BOOST_PP_WHILE_119(p, o, s) BOOST_PP_IF(p(120, s), BOOST_PP_WHILE_120, s BOOST_PP_TUPLE_EAT_3)(p, o, o(120, s)) # define BOOST_PP_WHILE_120(p, o, s) BOOST_PP_IF(p(121, s), BOOST_PP_WHILE_121, s BOOST_PP_TUPLE_EAT_3)(p, o, o(121, s)) # define BOOST_PP_WHILE_121(p, o, s) BOOST_PP_IF(p(122, s), BOOST_PP_WHILE_122, s BOOST_PP_TUPLE_EAT_3)(p, o, o(122, s)) # define BOOST_PP_WHILE_122(p, o, s) BOOST_PP_IF(p(123, s), BOOST_PP_WHILE_123, s BOOST_PP_TUPLE_EAT_3)(p, o, o(123, s)) # define BOOST_PP_WHILE_123(p, o, s) BOOST_PP_IF(p(124, s), BOOST_PP_WHILE_124, s BOOST_PP_TUPLE_EAT_3)(p, o, o(124, s)) # define BOOST_PP_WHILE_124(p, o, s) BOOST_PP_IF(p(125, s), BOOST_PP_WHILE_125, s BOOST_PP_TUPLE_EAT_3)(p, o, o(125, s)) # define BOOST_PP_WHILE_125(p, o, s) BOOST_PP_IF(p(126, s), BOOST_PP_WHILE_126, s BOOST_PP_TUPLE_EAT_3)(p, o, o(126, s)) # define BOOST_PP_WHILE_126(p, o, s) BOOST_PP_IF(p(127, s), BOOST_PP_WHILE_127, s BOOST_PP_TUPLE_EAT_3)(p, o, o(127, s)) # define BOOST_PP_WHILE_127(p, o, s) BOOST_PP_IF(p(128, s), BOOST_PP_WHILE_128, s BOOST_PP_TUPLE_EAT_3)(p, o, o(128, s)) # define BOOST_PP_WHILE_128(p, o, s) BOOST_PP_IF(p(129, s), BOOST_PP_WHILE_129, s BOOST_PP_TUPLE_EAT_3)(p, o, o(129, s)) # define BOOST_PP_WHILE_129(p, o, s) BOOST_PP_IF(p(130, s), BOOST_PP_WHILE_130, s BOOST_PP_TUPLE_EAT_3)(p, o, o(130, s)) # define BOOST_PP_WHILE_130(p, o, s) BOOST_PP_IF(p(131, s), BOOST_PP_WHILE_131, s BOOST_PP_TUPLE_EAT_3)(p, o, o(131, s)) # define BOOST_PP_WHILE_131(p, o, s) BOOST_PP_IF(p(132, s), BOOST_PP_WHILE_132, s BOOST_PP_TUPLE_EAT_3)(p, o, o(132, s)) # define BOOST_PP_WHILE_132(p, o, s) BOOST_PP_IF(p(133, s), BOOST_PP_WHILE_133, s BOOST_PP_TUPLE_EAT_3)(p, o, o(133, s)) # define BOOST_PP_WHILE_133(p, o, s) BOOST_PP_IF(p(134, s), BOOST_PP_WHILE_134, s BOOST_PP_TUPLE_EAT_3)(p, o, o(134, s)) # define BOOST_PP_WHILE_134(p, o, s) BOOST_PP_IF(p(135, s), BOOST_PP_WHILE_135, s BOOST_PP_TUPLE_EAT_3)(p, o, o(135, s)) # define BOOST_PP_WHILE_135(p, o, s) BOOST_PP_IF(p(136, s), BOOST_PP_WHILE_136, s BOOST_PP_TUPLE_EAT_3)(p, o, o(136, s)) # define BOOST_PP_WHILE_136(p, o, s) BOOST_PP_IF(p(137, s), BOOST_PP_WHILE_137, s BOOST_PP_TUPLE_EAT_3)(p, o, o(137, s)) # define BOOST_PP_WHILE_137(p, o, s) BOOST_PP_IF(p(138, s), BOOST_PP_WHILE_138, s BOOST_PP_TUPLE_EAT_3)(p, o, o(138, s)) # define BOOST_PP_WHILE_138(p, o, s) BOOST_PP_IF(p(139, s), BOOST_PP_WHILE_139, s BOOST_PP_TUPLE_EAT_3)(p, o, o(139, s)) # define BOOST_PP_WHILE_139(p, o, s) BOOST_PP_IF(p(140, s), BOOST_PP_WHILE_140, s BOOST_PP_TUPLE_EAT_3)(p, o, o(140, s)) # define BOOST_PP_WHILE_140(p, o, s) BOOST_PP_IF(p(141, s), BOOST_PP_WHILE_141, s BOOST_PP_TUPLE_EAT_3)(p, o, o(141, s)) # define BOOST_PP_WHILE_141(p, o, s) BOOST_PP_IF(p(142, s), BOOST_PP_WHILE_142, s BOOST_PP_TUPLE_EAT_3)(p, o, o(142, s)) # define BOOST_PP_WHILE_142(p, o, s) BOOST_PP_IF(p(143, s), BOOST_PP_WHILE_143, s BOOST_PP_TUPLE_EAT_3)(p, o, o(143, s)) # define BOOST_PP_WHILE_143(p, o, s) BOOST_PP_IF(p(144, s), BOOST_PP_WHILE_144, s BOOST_PP_TUPLE_EAT_3)(p, o, o(144, s)) # define BOOST_PP_WHILE_144(p, o, s) BOOST_PP_IF(p(145, s), BOOST_PP_WHILE_145, s BOOST_PP_TUPLE_EAT_3)(p, o, o(145, s)) # define BOOST_PP_WHILE_145(p, o, s) BOOST_PP_IF(p(146, s), BOOST_PP_WHILE_146, s BOOST_PP_TUPLE_EAT_3)(p, o, o(146, s)) # define BOOST_PP_WHILE_146(p, o, s) BOOST_PP_IF(p(147, s), BOOST_PP_WHILE_147, s BOOST_PP_TUPLE_EAT_3)(p, o, o(147, s)) # define BOOST_PP_WHILE_147(p, o, s) BOOST_PP_IF(p(148, s), BOOST_PP_WHILE_148, s BOOST_PP_TUPLE_EAT_3)(p, o, o(148, s)) # define BOOST_PP_WHILE_148(p, o, s) BOOST_PP_IF(p(149, s), BOOST_PP_WHILE_149, s BOOST_PP_TUPLE_EAT_3)(p, o, o(149, s)) # define BOOST_PP_WHILE_149(p, o, s) BOOST_PP_IF(p(150, s), BOOST_PP_WHILE_150, s BOOST_PP_TUPLE_EAT_3)(p, o, o(150, s)) # define BOOST_PP_WHILE_150(p, o, s) BOOST_PP_IF(p(151, s), BOOST_PP_WHILE_151, s BOOST_PP_TUPLE_EAT_3)(p, o, o(151, s)) # define BOOST_PP_WHILE_151(p, o, s) BOOST_PP_IF(p(152, s), BOOST_PP_WHILE_152, s BOOST_PP_TUPLE_EAT_3)(p, o, o(152, s)) # define BOOST_PP_WHILE_152(p, o, s) BOOST_PP_IF(p(153, s), BOOST_PP_WHILE_153, s BOOST_PP_TUPLE_EAT_3)(p, o, o(153, s)) # define BOOST_PP_WHILE_153(p, o, s) BOOST_PP_IF(p(154, s), BOOST_PP_WHILE_154, s BOOST_PP_TUPLE_EAT_3)(p, o, o(154, s)) # define BOOST_PP_WHILE_154(p, o, s) BOOST_PP_IF(p(155, s), BOOST_PP_WHILE_155, s BOOST_PP_TUPLE_EAT_3)(p, o, o(155, s)) # define BOOST_PP_WHILE_155(p, o, s) BOOST_PP_IF(p(156, s), BOOST_PP_WHILE_156, s BOOST_PP_TUPLE_EAT_3)(p, o, o(156, s)) # define BOOST_PP_WHILE_156(p, o, s) BOOST_PP_IF(p(157, s), BOOST_PP_WHILE_157, s BOOST_PP_TUPLE_EAT_3)(p, o, o(157, s)) # define BOOST_PP_WHILE_157(p, o, s) BOOST_PP_IF(p(158, s), BOOST_PP_WHILE_158, s BOOST_PP_TUPLE_EAT_3)(p, o, o(158, s)) # define BOOST_PP_WHILE_158(p, o, s) BOOST_PP_IF(p(159, s), BOOST_PP_WHILE_159, s BOOST_PP_TUPLE_EAT_3)(p, o, o(159, s)) # define BOOST_PP_WHILE_159(p, o, s) BOOST_PP_IF(p(160, s), BOOST_PP_WHILE_160, s BOOST_PP_TUPLE_EAT_3)(p, o, o(160, s)) # define BOOST_PP_WHILE_160(p, o, s) BOOST_PP_IF(p(161, s), BOOST_PP_WHILE_161, s BOOST_PP_TUPLE_EAT_3)(p, o, o(161, s)) # define BOOST_PP_WHILE_161(p, o, s) BOOST_PP_IF(p(162, s), BOOST_PP_WHILE_162, s BOOST_PP_TUPLE_EAT_3)(p, o, o(162, s)) # define BOOST_PP_WHILE_162(p, o, s) BOOST_PP_IF(p(163, s), BOOST_PP_WHILE_163, s BOOST_PP_TUPLE_EAT_3)(p, o, o(163, s)) # define BOOST_PP_WHILE_163(p, o, s) BOOST_PP_IF(p(164, s), BOOST_PP_WHILE_164, s BOOST_PP_TUPLE_EAT_3)(p, o, o(164, s)) # define BOOST_PP_WHILE_164(p, o, s) BOOST_PP_IF(p(165, s), BOOST_PP_WHILE_165, s BOOST_PP_TUPLE_EAT_3)(p, o, o(165, s)) # define BOOST_PP_WHILE_165(p, o, s) BOOST_PP_IF(p(166, s), BOOST_PP_WHILE_166, s BOOST_PP_TUPLE_EAT_3)(p, o, o(166, s)) # define BOOST_PP_WHILE_166(p, o, s) BOOST_PP_IF(p(167, s), BOOST_PP_WHILE_167, s BOOST_PP_TUPLE_EAT_3)(p, o, o(167, s)) # define BOOST_PP_WHILE_167(p, o, s) BOOST_PP_IF(p(168, s), BOOST_PP_WHILE_168, s BOOST_PP_TUPLE_EAT_3)(p, o, o(168, s)) # define BOOST_PP_WHILE_168(p, o, s) BOOST_PP_IF(p(169, s), BOOST_PP_WHILE_169, s BOOST_PP_TUPLE_EAT_3)(p, o, o(169, s)) # define BOOST_PP_WHILE_169(p, o, s) BOOST_PP_IF(p(170, s), BOOST_PP_WHILE_170, s BOOST_PP_TUPLE_EAT_3)(p, o, o(170, s)) # define BOOST_PP_WHILE_170(p, o, s) BOOST_PP_IF(p(171, s), BOOST_PP_WHILE_171, s BOOST_PP_TUPLE_EAT_3)(p, o, o(171, s)) # define BOOST_PP_WHILE_171(p, o, s) BOOST_PP_IF(p(172, s), BOOST_PP_WHILE_172, s BOOST_PP_TUPLE_EAT_3)(p, o, o(172, s)) # define BOOST_PP_WHILE_172(p, o, s) BOOST_PP_IF(p(173, s), BOOST_PP_WHILE_173, s BOOST_PP_TUPLE_EAT_3)(p, o, o(173, s)) # define BOOST_PP_WHILE_173(p, o, s) BOOST_PP_IF(p(174, s), BOOST_PP_WHILE_174, s BOOST_PP_TUPLE_EAT_3)(p, o, o(174, s)) # define BOOST_PP_WHILE_174(p, o, s) BOOST_PP_IF(p(175, s), BOOST_PP_WHILE_175, s BOOST_PP_TUPLE_EAT_3)(p, o, o(175, s)) # define BOOST_PP_WHILE_175(p, o, s) BOOST_PP_IF(p(176, s), BOOST_PP_WHILE_176, s BOOST_PP_TUPLE_EAT_3)(p, o, o(176, s)) # define BOOST_PP_WHILE_176(p, o, s) BOOST_PP_IF(p(177, s), BOOST_PP_WHILE_177, s BOOST_PP_TUPLE_EAT_3)(p, o, o(177, s)) # define BOOST_PP_WHILE_177(p, o, s) BOOST_PP_IF(p(178, s), BOOST_PP_WHILE_178, s BOOST_PP_TUPLE_EAT_3)(p, o, o(178, s)) # define BOOST_PP_WHILE_178(p, o, s) BOOST_PP_IF(p(179, s), BOOST_PP_WHILE_179, s BOOST_PP_TUPLE_EAT_3)(p, o, o(179, s)) # define BOOST_PP_WHILE_179(p, o, s) BOOST_PP_IF(p(180, s), BOOST_PP_WHILE_180, s BOOST_PP_TUPLE_EAT_3)(p, o, o(180, s)) # define BOOST_PP_WHILE_180(p, o, s) BOOST_PP_IF(p(181, s), BOOST_PP_WHILE_181, s BOOST_PP_TUPLE_EAT_3)(p, o, o(181, s)) # define BOOST_PP_WHILE_181(p, o, s) BOOST_PP_IF(p(182, s), BOOST_PP_WHILE_182, s BOOST_PP_TUPLE_EAT_3)(p, o, o(182, s)) # define BOOST_PP_WHILE_182(p, o, s) BOOST_PP_IF(p(183, s), BOOST_PP_WHILE_183, s BOOST_PP_TUPLE_EAT_3)(p, o, o(183, s)) # define BOOST_PP_WHILE_183(p, o, s) BOOST_PP_IF(p(184, s), BOOST_PP_WHILE_184, s BOOST_PP_TUPLE_EAT_3)(p, o, o(184, s)) # define BOOST_PP_WHILE_184(p, o, s) BOOST_PP_IF(p(185, s), BOOST_PP_WHILE_185, s BOOST_PP_TUPLE_EAT_3)(p, o, o(185, s)) # define BOOST_PP_WHILE_185(p, o, s) BOOST_PP_IF(p(186, s), BOOST_PP_WHILE_186, s BOOST_PP_TUPLE_EAT_3)(p, o, o(186, s)) # define BOOST_PP_WHILE_186(p, o, s) BOOST_PP_IF(p(187, s), BOOST_PP_WHILE_187, s BOOST_PP_TUPLE_EAT_3)(p, o, o(187, s)) # define BOOST_PP_WHILE_187(p, o, s) BOOST_PP_IF(p(188, s), BOOST_PP_WHILE_188, s BOOST_PP_TUPLE_EAT_3)(p, o, o(188, s)) # define BOOST_PP_WHILE_188(p, o, s) BOOST_PP_IF(p(189, s), BOOST_PP_WHILE_189, s BOOST_PP_TUPLE_EAT_3)(p, o, o(189, s)) # define BOOST_PP_WHILE_189(p, o, s) BOOST_PP_IF(p(190, s), BOOST_PP_WHILE_190, s BOOST_PP_TUPLE_EAT_3)(p, o, o(190, s)) # define BOOST_PP_WHILE_190(p, o, s) BOOST_PP_IF(p(191, s), BOOST_PP_WHILE_191, s BOOST_PP_TUPLE_EAT_3)(p, o, o(191, s)) # define BOOST_PP_WHILE_191(p, o, s) BOOST_PP_IF(p(192, s), BOOST_PP_WHILE_192, s BOOST_PP_TUPLE_EAT_3)(p, o, o(192, s)) # define BOOST_PP_WHILE_192(p, o, s) BOOST_PP_IF(p(193, s), BOOST_PP_WHILE_193, s BOOST_PP_TUPLE_EAT_3)(p, o, o(193, s)) # define BOOST_PP_WHILE_193(p, o, s) BOOST_PP_IF(p(194, s), BOOST_PP_WHILE_194, s BOOST_PP_TUPLE_EAT_3)(p, o, o(194, s)) # define BOOST_PP_WHILE_194(p, o, s) BOOST_PP_IF(p(195, s), BOOST_PP_WHILE_195, s BOOST_PP_TUPLE_EAT_3)(p, o, o(195, s)) # define BOOST_PP_WHILE_195(p, o, s) BOOST_PP_IF(p(196, s), BOOST_PP_WHILE_196, s BOOST_PP_TUPLE_EAT_3)(p, o, o(196, s)) # define BOOST_PP_WHILE_196(p, o, s) BOOST_PP_IF(p(197, s), BOOST_PP_WHILE_197, s BOOST_PP_TUPLE_EAT_3)(p, o, o(197, s)) # define BOOST_PP_WHILE_197(p, o, s) BOOST_PP_IF(p(198, s), BOOST_PP_WHILE_198, s BOOST_PP_TUPLE_EAT_3)(p, o, o(198, s)) # define BOOST_PP_WHILE_198(p, o, s) BOOST_PP_IF(p(199, s), BOOST_PP_WHILE_199, s BOOST_PP_TUPLE_EAT_3)(p, o, o(199, s)) # define BOOST_PP_WHILE_199(p, o, s) BOOST_PP_IF(p(200, s), BOOST_PP_WHILE_200, s BOOST_PP_TUPLE_EAT_3)(p, o, o(200, s)) # define BOOST_PP_WHILE_200(p, o, s) BOOST_PP_IF(p(201, s), BOOST_PP_WHILE_201, s BOOST_PP_TUPLE_EAT_3)(p, o, o(201, s)) # define BOOST_PP_WHILE_201(p, o, s) BOOST_PP_IF(p(202, s), BOOST_PP_WHILE_202, s BOOST_PP_TUPLE_EAT_3)(p, o, o(202, s)) # define BOOST_PP_WHILE_202(p, o, s) BOOST_PP_IF(p(203, s), BOOST_PP_WHILE_203, s BOOST_PP_TUPLE_EAT_3)(p, o, o(203, s)) # define BOOST_PP_WHILE_203(p, o, s) BOOST_PP_IF(p(204, s), BOOST_PP_WHILE_204, s BOOST_PP_TUPLE_EAT_3)(p, o, o(204, s)) # define BOOST_PP_WHILE_204(p, o, s) BOOST_PP_IF(p(205, s), BOOST_PP_WHILE_205, s BOOST_PP_TUPLE_EAT_3)(p, o, o(205, s)) # define BOOST_PP_WHILE_205(p, o, s) BOOST_PP_IF(p(206, s), BOOST_PP_WHILE_206, s BOOST_PP_TUPLE_EAT_3)(p, o, o(206, s)) # define BOOST_PP_WHILE_206(p, o, s) BOOST_PP_IF(p(207, s), BOOST_PP_WHILE_207, s BOOST_PP_TUPLE_EAT_3)(p, o, o(207, s)) # define BOOST_PP_WHILE_207(p, o, s) BOOST_PP_IF(p(208, s), BOOST_PP_WHILE_208, s BOOST_PP_TUPLE_EAT_3)(p, o, o(208, s)) # define BOOST_PP_WHILE_208(p, o, s) BOOST_PP_IF(p(209, s), BOOST_PP_WHILE_209, s BOOST_PP_TUPLE_EAT_3)(p, o, o(209, s)) # define BOOST_PP_WHILE_209(p, o, s) BOOST_PP_IF(p(210, s), BOOST_PP_WHILE_210, s BOOST_PP_TUPLE_EAT_3)(p, o, o(210, s)) # define BOOST_PP_WHILE_210(p, o, s) BOOST_PP_IF(p(211, s), BOOST_PP_WHILE_211, s BOOST_PP_TUPLE_EAT_3)(p, o, o(211, s)) # define BOOST_PP_WHILE_211(p, o, s) BOOST_PP_IF(p(212, s), BOOST_PP_WHILE_212, s BOOST_PP_TUPLE_EAT_3)(p, o, o(212, s)) # define BOOST_PP_WHILE_212(p, o, s) BOOST_PP_IF(p(213, s), BOOST_PP_WHILE_213, s BOOST_PP_TUPLE_EAT_3)(p, o, o(213, s)) # define BOOST_PP_WHILE_213(p, o, s) BOOST_PP_IF(p(214, s), BOOST_PP_WHILE_214, s BOOST_PP_TUPLE_EAT_3)(p, o, o(214, s)) # define BOOST_PP_WHILE_214(p, o, s) BOOST_PP_IF(p(215, s), BOOST_PP_WHILE_215, s BOOST_PP_TUPLE_EAT_3)(p, o, o(215, s)) # define BOOST_PP_WHILE_215(p, o, s) BOOST_PP_IF(p(216, s), BOOST_PP_WHILE_216, s BOOST_PP_TUPLE_EAT_3)(p, o, o(216, s)) # define BOOST_PP_WHILE_216(p, o, s) BOOST_PP_IF(p(217, s), BOOST_PP_WHILE_217, s BOOST_PP_TUPLE_EAT_3)(p, o, o(217, s)) # define BOOST_PP_WHILE_217(p, o, s) BOOST_PP_IF(p(218, s), BOOST_PP_WHILE_218, s BOOST_PP_TUPLE_EAT_3)(p, o, o(218, s)) # define BOOST_PP_WHILE_218(p, o, s) BOOST_PP_IF(p(219, s), BOOST_PP_WHILE_219, s BOOST_PP_TUPLE_EAT_3)(p, o, o(219, s)) # define BOOST_PP_WHILE_219(p, o, s) BOOST_PP_IF(p(220, s), BOOST_PP_WHILE_220, s BOOST_PP_TUPLE_EAT_3)(p, o, o(220, s)) # define BOOST_PP_WHILE_220(p, o, s) BOOST_PP_IF(p(221, s), BOOST_PP_WHILE_221, s BOOST_PP_TUPLE_EAT_3)(p, o, o(221, s)) # define BOOST_PP_WHILE_221(p, o, s) BOOST_PP_IF(p(222, s), BOOST_PP_WHILE_222, s BOOST_PP_TUPLE_EAT_3)(p, o, o(222, s)) # define BOOST_PP_WHILE_222(p, o, s) BOOST_PP_IF(p(223, s), BOOST_PP_WHILE_223, s BOOST_PP_TUPLE_EAT_3)(p, o, o(223, s)) # define BOOST_PP_WHILE_223(p, o, s) BOOST_PP_IF(p(224, s), BOOST_PP_WHILE_224, s BOOST_PP_TUPLE_EAT_3)(p, o, o(224, s)) # define BOOST_PP_WHILE_224(p, o, s) BOOST_PP_IF(p(225, s), BOOST_PP_WHILE_225, s BOOST_PP_TUPLE_EAT_3)(p, o, o(225, s)) # define BOOST_PP_WHILE_225(p, o, s) BOOST_PP_IF(p(226, s), BOOST_PP_WHILE_226, s BOOST_PP_TUPLE_EAT_3)(p, o, o(226, s)) # define BOOST_PP_WHILE_226(p, o, s) BOOST_PP_IF(p(227, s), BOOST_PP_WHILE_227, s BOOST_PP_TUPLE_EAT_3)(p, o, o(227, s)) # define BOOST_PP_WHILE_227(p, o, s) BOOST_PP_IF(p(228, s), BOOST_PP_WHILE_228, s BOOST_PP_TUPLE_EAT_3)(p, o, o(228, s)) # define BOOST_PP_WHILE_228(p, o, s) BOOST_PP_IF(p(229, s), BOOST_PP_WHILE_229, s BOOST_PP_TUPLE_EAT_3)(p, o, o(229, s)) # define BOOST_PP_WHILE_229(p, o, s) BOOST_PP_IF(p(230, s), BOOST_PP_WHILE_230, s BOOST_PP_TUPLE_EAT_3)(p, o, o(230, s)) # define BOOST_PP_WHILE_230(p, o, s) BOOST_PP_IF(p(231, s), BOOST_PP_WHILE_231, s BOOST_PP_TUPLE_EAT_3)(p, o, o(231, s)) # define BOOST_PP_WHILE_231(p, o, s) BOOST_PP_IF(p(232, s), BOOST_PP_WHILE_232, s BOOST_PP_TUPLE_EAT_3)(p, o, o(232, s)) # define BOOST_PP_WHILE_232(p, o, s) BOOST_PP_IF(p(233, s), BOOST_PP_WHILE_233, s BOOST_PP_TUPLE_EAT_3)(p, o, o(233, s)) # define BOOST_PP_WHILE_233(p, o, s) BOOST_PP_IF(p(234, s), BOOST_PP_WHILE_234, s BOOST_PP_TUPLE_EAT_3)(p, o, o(234, s)) # define BOOST_PP_WHILE_234(p, o, s) BOOST_PP_IF(p(235, s), BOOST_PP_WHILE_235, s BOOST_PP_TUPLE_EAT_3)(p, o, o(235, s)) # define BOOST_PP_WHILE_235(p, o, s) BOOST_PP_IF(p(236, s), BOOST_PP_WHILE_236, s BOOST_PP_TUPLE_EAT_3)(p, o, o(236, s)) # define BOOST_PP_WHILE_236(p, o, s) BOOST_PP_IF(p(237, s), BOOST_PP_WHILE_237, s BOOST_PP_TUPLE_EAT_3)(p, o, o(237, s)) # define BOOST_PP_WHILE_237(p, o, s) BOOST_PP_IF(p(238, s), BOOST_PP_WHILE_238, s BOOST_PP_TUPLE_EAT_3)(p, o, o(238, s)) # define BOOST_PP_WHILE_238(p, o, s) BOOST_PP_IF(p(239, s), BOOST_PP_WHILE_239, s BOOST_PP_TUPLE_EAT_3)(p, o, o(239, s)) # define BOOST_PP_WHILE_239(p, o, s) BOOST_PP_IF(p(240, s), BOOST_PP_WHILE_240, s BOOST_PP_TUPLE_EAT_3)(p, o, o(240, s)) # define BOOST_PP_WHILE_240(p, o, s) BOOST_PP_IF(p(241, s), BOOST_PP_WHILE_241, s BOOST_PP_TUPLE_EAT_3)(p, o, o(241, s)) # define BOOST_PP_WHILE_241(p, o, s) BOOST_PP_IF(p(242, s), BOOST_PP_WHILE_242, s BOOST_PP_TUPLE_EAT_3)(p, o, o(242, s)) # define BOOST_PP_WHILE_242(p, o, s) BOOST_PP_IF(p(243, s), BOOST_PP_WHILE_243, s BOOST_PP_TUPLE_EAT_3)(p, o, o(243, s)) # define BOOST_PP_WHILE_243(p, o, s) BOOST_PP_IF(p(244, s), BOOST_PP_WHILE_244, s BOOST_PP_TUPLE_EAT_3)(p, o, o(244, s)) # define BOOST_PP_WHILE_244(p, o, s) BOOST_PP_IF(p(245, s), BOOST_PP_WHILE_245, s BOOST_PP_TUPLE_EAT_3)(p, o, o(245, s)) # define BOOST_PP_WHILE_245(p, o, s) BOOST_PP_IF(p(246, s), BOOST_PP_WHILE_246, s BOOST_PP_TUPLE_EAT_3)(p, o, o(246, s)) # define BOOST_PP_WHILE_246(p, o, s) BOOST_PP_IF(p(247, s), BOOST_PP_WHILE_247, s BOOST_PP_TUPLE_EAT_3)(p, o, o(247, s)) # define BOOST_PP_WHILE_247(p, o, s) BOOST_PP_IF(p(248, s), BOOST_PP_WHILE_248, s BOOST_PP_TUPLE_EAT_3)(p, o, o(248, s)) # define BOOST_PP_WHILE_248(p, o, s) BOOST_PP_IF(p(249, s), BOOST_PP_WHILE_249, s BOOST_PP_TUPLE_EAT_3)(p, o, o(249, s)) # define BOOST_PP_WHILE_249(p, o, s) BOOST_PP_IF(p(250, s), BOOST_PP_WHILE_250, s BOOST_PP_TUPLE_EAT_3)(p, o, o(250, s)) # define BOOST_PP_WHILE_250(p, o, s) BOOST_PP_IF(p(251, s), BOOST_PP_WHILE_251, s BOOST_PP_TUPLE_EAT_3)(p, o, o(251, s)) # define BOOST_PP_WHILE_251(p, o, s) BOOST_PP_IF(p(252, s), BOOST_PP_WHILE_252, s BOOST_PP_TUPLE_EAT_3)(p, o, o(252, s)) # define BOOST_PP_WHILE_252(p, o, s) BOOST_PP_IF(p(253, s), BOOST_PP_WHILE_253, s BOOST_PP_TUPLE_EAT_3)(p, o, o(253, s)) # define BOOST_PP_WHILE_253(p, o, s) BOOST_PP_IF(p(254, s), BOOST_PP_WHILE_254, s BOOST_PP_TUPLE_EAT_3)(p, o, o(254, s)) # define BOOST_PP_WHILE_254(p, o, s) BOOST_PP_IF(p(255, s), BOOST_PP_WHILE_255, s BOOST_PP_TUPLE_EAT_3)(p, o, o(255, s)) # define BOOST_PP_WHILE_255(p, o, s) BOOST_PP_IF(p(256, s), BOOST_PP_WHILE_256, s BOOST_PP_TUPLE_EAT_3)(p, o, o(256, s)) # define BOOST_PP_WHILE_256(p, o, s) BOOST_PP_IF(p(257, s), BOOST_PP_WHILE_257, s BOOST_PP_TUPLE_EAT_3)(p, o, o(257, s)) # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selection.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selectio0000644000175000017500000000143411344301502031724 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SELECTION_HPP # define BOOST_PREPROCESSOR_SELECTION_HPP # # include # include # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/library.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/library.0000644000175000017500000000270411344301502031640 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIBRARY_HPP # define BOOST_PREPROCESSOR_LIBRARY_HPP # # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq.hpp0000644000175000017500000000351511344301502031475 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_HPP # define BOOST_PREPROCESSOR_SEQ_HPP # # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/cat.hpp0000644000175000017500000000166711344301502031462 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CAT_HPP # define BOOST_PREPROCESSOR_CAT_HPP # # include # # /* BOOST_PP_CAT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b) # else # define BOOST_PP_CAT(a, b) BOOST_PP_CAT_OO((a, b)) # define BOOST_PP_CAT_OO(par) BOOST_PP_CAT_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_CAT_I(a, b) a ## b # else # define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(a ## b) # define BOOST_PP_CAT_II(res) res # endif # # endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array.hp0000644000175000017500000000231211344301502031635 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_HPP # define BOOST_PREPROCESSOR_ARRAY_HPP # # include # include # include # include # include # include # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000171011344301502031676 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_HPP # define BOOST_PREPROCESSOR_FACILITIES_HPP # # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_params_with_a_default.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_par0000644000175000017500000000144511344301502031725 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_A_DEFAULT_HPP # define BOOST_PREPROCESSOR_ENUM_PARAMS_WITH_A_DEFAULT_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmetic.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/arithmet0000644000175000017500000000144311344301502031732 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARITHMETIC_HPP # define BOOST_PREPROCESSOR_ARITHMETIC_HPP # # include # include # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/debug.hp0000644000175000017500000000142011344301502031604 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DEBUG_HPP # define BOOST_PREPROCESSOR_DEBUG_HPP # # include # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot.hpp0000644000175000017500000000133511344301502031664 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SLOT_HPP # define BOOST_PREPROCESSOR_SLOT_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000000141711344301502031733 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_HPP # define BOOST_PREPROCESSOR_COMPARISON_HPP # # include # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/identity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/identity0000644000175000017500000000135711344301502031752 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_IDENTITY_HPP # define BOOST_PREPROCESSOR_IDENTITY_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_3rd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_30000644000175000017500000000136111344301502031616 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPEAT_3RD_HPP # define BOOST_PREPROCESSOR_REPEAT_3RD_HPP # # include # # endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/empty.hp0000644000175000017500000000134611344301502031663 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_EMPTY_HPP # define BOOST_PREPROCESSOR_EMPTY_HPP # # include # # endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comma.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comma.hp0000644000175000017500000000134711344301502031622 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMMA_HPP # define BOOST_PREPROCESSOR_COMMA_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/for.hpp0000644000175000017500000000134011344301502031465 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FOR_HPP # define BOOST_PREPROCESSOR_FOR_HPP # # include # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum_par0000644000175000017500000000137011344301502031722 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ENUM_PARAMS_HPP # define BOOST_PREPROCESSOR_ENUM_PARAMS_HPP # # include # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/expr_if.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/expr_if.0000644000175000017500000000135111344301502031625 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_EXPR_IF_HPP # define BOOST_PREPROCESSOR_EXPR_IF_HPP # # include # # endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_from_to_2nd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_f0000644000175000017500000000141111344301502031675 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPEAT_FROM_TO_2ND_HPP # define BOOST_PREPROCESSOR_REPEAT_FROM_TO_2ND_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/min.hpp0000644000175000017500000000133711344301502031470 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_MIN_HPP # define BOOST_PREPROCESSOR_MIN_HPP # # include # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical.0000644000175000017500000000172111344301502031604 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_HPP # define BOOST_PREPROCESSOR_LOGICAL_HPP # # include # include # include # include # include # include # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/limits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/limits.h0000644000175000017500000000134511344301502031645 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIMITS_HPP # define BOOST_PREPROCESSOR_LIMITS_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/wstringize.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/wstringi0000644000175000017500000000222211344301502031757 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_WSTRINGIZE_HPP # define BOOST_PREPROCESSOR_WSTRINGIZE_HPP # # include # # /* BOOST_PP_WSTRINGIZE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_WSTRINGIZE(text) BOOST_PP_WSTRINGIZE_I(text) # else # define BOOST_PP_WSTRINGIZE(text) BOOST_PP_WSTRINGIZE_OO((text)) # define BOOST_PP_WSTRINGIZE_OO(par) BOOST_PP_WSTRINGIZE_I ## par # endif # # define BOOST_PP_WSTRINGIZE_I(text) BOOST_PP_WSTRINGIZE_II(#text) # define BOOST_PP_WSTRINGIZE_II(str) L ## str # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuation/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuat0000755000175000017500000000000012146213767031774 5ustar debiandebian././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuation/paren_if.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuat0000644000175000017500000000311411344301502031755 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_PUNCTUATION_PAREN_IF_HPP # define BOOST_PREPROCESSOR_PUNCTUATION_PAREN_IF_HPP # # include # include # include # include # # /* BOOST_PP_LPAREN_IF */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LPAREN_IF(cond) BOOST_PP_IF(cond, BOOST_PP_LPAREN, BOOST_PP_EMPTY)() # else # define BOOST_PP_LPAREN_IF(cond) BOOST_PP_LPAREN_IF_I(cond) # define BOOST_PP_LPAREN_IF_I(cond) BOOST_PP_IF(cond, BOOST_PP_LPAREN, BOOST_PP_EMPTY)() # endif # # /* BOOST_PP_RPAREN_IF */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_RPAREN_IF(cond) BOOST_PP_IF(cond, BOOST_PP_RPAREN, BOOST_PP_EMPTY)() # else # define BOOST_PP_RPAREN_IF(cond) BOOST_PP_RPAREN_IF_I(cond) # define BOOST_PP_RPAREN_IF_I(cond) BOOST_PP_IF(cond, BOOST_PP_RPAREN, BOOST_PP_EMPTY)() # endif # # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuation/comma.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuat0000644000175000017500000000101011344301502031746 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP # define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP # # /* BOOST_PP_COMMA */ # # define BOOST_PP_COMMA() , # # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuation/paren.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuat0000644000175000017500000000147211344301502031762 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_PUNCTUATION_PAREN_HPP # define BOOST_PREPROCESSOR_PUNCTUATION_PAREN_HPP # # /* BOOST_PP_LPAREN */ # # define BOOST_PP_LPAREN() ( # # /* BOOST_PP_RPAREN */ # # define BOOST_PP_RPAREN() ) # # endif ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuation/comma_if.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/punctuat0000644000175000017500000000176411344301502031766 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP # define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_IF_HPP # # include # include # include # include # # /* BOOST_PP_COMMA_IF */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() # else # define BOOST_PP_COMMA_IF(cond) BOOST_PP_COMMA_IF_I(cond) # define BOOST_PP_COMMA_IF_I(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)() # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_from_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_f0000644000175000017500000000140111344301502031674 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPEAT_FROM_TO_HPP # define BOOST_PREPROCESSOR_REPEAT_FROM_TO_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/dec.hpp0000644000175000017500000000134011344301502031432 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DEC_HPP # define BOOST_PREPROCESSOR_DEC_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_2nd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat_20000644000175000017500000000136111344301502031615 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPEAT_2ND_HPP # define BOOST_PREPROCESSOR_REPEAT_2ND_HPP # # include # # endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/while.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/while.hp0000644000175000017500000000134311344301502031632 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_WHILE_HPP # define BOOST_PREPROCESSOR_WHILE_HPP # # include # # endif ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple.hp0000644000175000017500000000132511344301502031653 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_HPP # define BOOST_PREPROCESSOR_TUPLE_HPP # # include # include # include # include # include # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list.hpp0000644000175000017500000000235011344301502031654 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_HPP # define BOOST_PREPROCESSOR_LIST_HPP # # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include # # endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repeat.h0000644000175000017500000000135111344301502031621 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPEAT_HPP # define BOOST_PREPROCESSOR_REPEAT_HPP # # include # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000755000175000017500000000000012146213763031742 5ustar debiandebian././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000000365511344301502031741 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_LESS_HPP # define BOOST_PREPROCESSOR_COMPARISON_LESS_HPP # # include # include # include # include # include # include # # /* BOOST_PP_LESS */ # # if BOOST_PP_CONFIG_FLAGS() & (BOOST_PP_CONFIG_MWCC() | BOOST_PP_CONFIG_DMC()) # define BOOST_PP_LESS(x, y) BOOST_PP_BITAND(BOOST_PP_NOT_EQUAL(x, y), BOOST_PP_LESS_EQUAL(x, y)) # elif ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LESS(x, y) BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(x, y), BOOST_PP_LESS_EQUAL, 0 BOOST_PP_TUPLE_EAT_2)(x, y) # else # define BOOST_PP_LESS(x, y) BOOST_PP_LESS_I(x, y) # define BOOST_PP_LESS_I(x, y) BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(x, y), BOOST_PP_LESS_EQUAL, 0 BOOST_PP_TUPLE_EAT_2)(x, y) # endif # # /* BOOST_PP_LESS_D */ # # if BOOST_PP_CONFIG_FLAGS() & (BOOST_PP_CONFIG_MWCC() | BOOST_PP_CONFIG_DMC()) # define BOOST_PP_LESS_D(d, x, y) BOOST_PP_BITAND(BOOST_PP_NOT_EQUAL(x, y), BOOST_PP_LESS_EQUAL_D(d, x, y)) # elif ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LESS_D(d, x, y) BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(x, y), BOOST_PP_LESS_EQUAL_D, 0 BOOST_PP_TUPLE_EAT_3)(d, x, y) # else # define BOOST_PP_LESS_D(d, x, y) BOOST_PP_LESS_D_I(d, x, y) # define BOOST_PP_LESS_D_I(d, x, y) BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(x, y), BOOST_PP_LESS_EQUAL_D, 0 BOOST_PP_TUPLE_EAT_3)(d, x, y) # endif # # endif ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/not_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000017663311344301502031750 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_NOT_EQUAL_HPP # define BOOST_PREPROCESSOR_COMPARISON_NOT_EQUAL_HPP # # include # include # include # # /* BOOST_PP_NOT_EQUAL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_NOT_EQUAL(x, y) BOOST_PP_NOT_EQUAL_I(x, y) # else # define BOOST_PP_NOT_EQUAL(x, y) BOOST_PP_NOT_EQUAL_OO((x, y)) # define BOOST_PP_NOT_EQUAL_OO(par) BOOST_PP_NOT_EQUAL_I ## par # endif # # define BOOST_PP_NOT_EQUAL_I(x, y) BOOST_PP_CAT(BOOST_PP_NOT_EQUAL_CHECK_, BOOST_PP_NOT_EQUAL_ ## x(0, BOOST_PP_NOT_EQUAL_ ## y)) # # /* BOOST_PP_NOT_EQUAL_D */ # # define BOOST_PP_NOT_EQUAL_D(d, x, y) BOOST_PP_NOT_EQUAL(x, y) # # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NIL 1 # # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_0(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_1(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_2(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_3(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_4(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_5(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_6(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_7(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_8(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_9(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_10(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_11(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_12(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_13(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_14(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_15(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_16(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_17(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_18(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_19(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_20(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_21(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_22(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_23(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_24(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_25(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_26(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_27(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_28(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_29(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_30(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_31(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_32(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_33(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_34(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_35(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_36(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_37(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_38(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_39(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_40(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_41(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_42(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_43(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_44(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_45(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_46(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_47(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_48(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_49(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_50(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_51(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_52(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_53(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_54(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_55(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_56(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_57(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_58(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_59(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_60(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_61(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_62(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_63(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_64(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_65(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_66(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_67(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_68(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_69(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_70(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_71(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_72(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_73(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_74(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_75(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_76(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_77(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_78(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_79(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_80(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_81(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_82(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_83(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_84(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_85(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_86(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_87(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_88(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_89(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_90(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_91(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_92(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_93(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_94(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_95(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_96(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_97(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_98(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_99(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_100(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_101(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_102(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_103(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_104(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_105(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_106(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_107(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_108(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_109(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_110(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_111(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_112(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_113(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_114(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_115(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_116(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_117(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_118(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_119(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_120(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_121(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_122(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_123(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_124(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_125(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_126(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_127(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_128(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_129(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_130(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_131(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_132(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_133(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_134(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_135(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_136(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_137(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_138(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_139(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_140(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_141(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_142(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_143(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_144(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_145(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_146(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_147(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_148(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_149(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_150(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_151(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_152(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_153(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_154(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_155(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_156(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_157(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_158(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_159(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_160(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_161(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_162(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_163(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_164(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_165(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_166(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_167(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_168(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_169(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_170(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_171(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_172(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_173(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_174(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_175(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_176(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_177(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_178(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_179(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_180(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_181(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_182(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_183(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_184(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_185(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_186(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_187(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_188(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_189(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_190(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_191(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_192(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_193(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_194(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_195(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_196(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_197(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_198(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_199(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_200(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_201(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_202(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_203(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_204(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_205(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_206(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_207(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_208(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_209(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_210(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_211(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_212(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_213(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_214(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_215(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_216(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_217(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_218(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_219(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_220(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_221(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_222(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_223(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_224(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_225(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_226(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_227(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_228(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_229(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_230(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_231(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_232(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_233(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_234(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_235(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_236(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_237(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_238(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_239(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_240(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_241(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_242(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_243(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_244(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_245(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_246(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_247(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_248(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_249(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_250(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_251(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_252(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_253(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_254(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_255(c, y) 0 # define BOOST_PP_NOT_EQUAL_CHECK_BOOST_PP_NOT_EQUAL_256(c, y) 0 # #if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_NOT_EQUAL_0(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_1(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_2(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_3(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_4(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_5(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_6(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_7(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_8(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_9(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_10(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_11(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_12(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_13(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_14(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_15(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_16(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_17(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_18(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_19(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_20(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_21(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_22(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_23(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_24(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_25(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_26(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_27(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_28(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_29(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_30(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_31(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_32(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_33(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_34(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_35(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_36(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_37(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_38(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_39(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_40(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_41(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_42(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_43(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_44(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_45(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_46(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_47(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_48(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_49(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_50(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_51(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_52(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_53(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_54(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_55(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_56(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_57(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_58(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_59(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_60(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_61(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_62(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_63(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_64(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_65(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_66(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_67(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_68(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_69(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_70(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_71(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_72(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_73(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_74(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_75(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_76(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_77(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_78(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_79(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_80(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_81(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_82(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_83(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_84(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_85(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_86(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_87(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_88(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_89(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_90(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_91(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_92(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_93(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_94(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_95(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_96(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_97(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_98(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_99(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_100(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_101(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_102(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_103(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_104(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_105(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_106(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_107(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_108(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_109(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_110(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_111(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_112(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_113(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_114(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_115(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_116(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_117(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_118(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_119(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_120(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_121(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_122(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_123(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_124(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_125(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_126(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_127(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_128(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_129(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_130(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_131(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_132(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_133(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_134(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_135(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_136(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_137(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_138(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_139(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_140(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_141(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_142(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_143(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_144(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_145(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_146(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_147(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_148(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_149(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_150(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_151(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_152(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_153(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_154(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_155(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_156(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_157(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_158(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_159(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_160(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_161(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_162(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_163(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_164(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_165(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_166(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_167(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_168(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_169(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_170(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_171(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_172(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_173(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_174(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_175(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_176(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_177(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_178(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_179(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_180(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_181(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_182(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_183(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_184(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_185(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_186(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_187(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_188(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_189(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_190(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_191(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_192(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_193(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_194(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_195(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_196(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_197(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_198(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_199(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_200(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_201(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_202(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_203(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_204(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_205(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_206(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_207(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_208(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_209(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_210(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_211(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_212(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_213(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_214(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_215(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_216(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_217(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_218(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_219(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_220(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_221(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_222(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_223(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_224(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_225(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_226(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_227(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_228(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_229(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_230(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_231(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_232(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_233(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_234(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_235(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_236(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_237(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_238(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_239(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_240(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_241(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_242(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_243(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_244(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_245(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_246(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_247(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_248(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_249(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_250(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_251(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_252(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_253(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_254(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_255(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_256(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y(1, BOOST_PP_NIL)) # else # define BOOST_PP_NOT_EQUAL_0(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_1(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_2(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_3(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_4(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_5(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_6(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_7(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_8(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_9(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_10(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_11(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_12(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_13(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_14(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_15(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_16(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_17(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_18(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_19(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_20(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_21(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_22(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_23(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_24(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_25(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_26(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_27(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_28(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_29(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_30(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_31(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_32(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_33(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_34(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_35(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_36(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_37(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_38(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_39(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_40(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_41(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_42(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_43(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_44(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_45(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_46(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_47(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_48(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_49(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_50(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_51(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_52(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_53(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_54(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_55(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_56(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_57(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_58(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_59(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_60(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_61(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_62(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_63(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_64(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_65(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_66(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_67(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_68(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_69(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_70(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_71(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_72(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_73(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_74(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_75(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_76(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_77(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_78(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_79(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_80(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_81(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_82(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_83(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_84(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_85(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_86(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_87(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_88(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_89(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_90(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_91(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_92(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_93(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_94(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_95(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_96(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_97(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_98(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_99(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_100(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_101(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_102(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_103(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_104(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_105(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_106(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_107(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_108(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_109(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_110(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_111(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_112(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_113(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_114(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_115(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_116(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_117(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_118(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_119(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_120(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_121(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_122(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_123(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_124(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_125(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_126(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_127(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_128(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_129(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_130(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_131(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_132(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_133(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_134(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_135(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_136(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_137(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_138(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_139(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_140(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_141(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_142(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_143(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_144(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_145(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_146(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_147(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_148(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_149(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_150(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_151(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_152(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_153(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_154(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_155(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_156(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_157(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_158(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_159(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_160(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_161(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_162(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_163(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_164(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_165(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_166(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_167(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_168(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_169(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_170(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_171(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_172(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_173(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_174(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_175(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_176(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_177(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_178(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_179(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_180(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_181(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_182(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_183(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_184(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_185(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_186(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_187(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_188(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_189(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_190(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_191(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_192(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_193(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_194(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_195(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_196(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_197(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_198(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_199(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_200(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_201(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_202(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_203(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_204(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_205(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_206(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_207(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_208(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_209(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_210(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_211(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_212(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_213(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_214(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_215(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_216(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_217(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_218(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_219(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_220(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_221(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_222(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_223(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_224(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_225(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_226(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_227(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_228(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_229(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_230(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_231(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_232(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_233(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_234(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_235(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_236(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_237(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_238(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_239(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_240(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_241(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_242(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_243(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_244(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_245(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_246(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_247(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_248(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_249(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_250(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_251(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_252(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_253(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_254(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_255(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # define BOOST_PP_NOT_EQUAL_256(c, y) BOOST_PP_IIF(c, BOOST_PP_NIL, y##(1, BOOST_PP_NIL)) # endif # # endif ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000000233311344301502031731 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_GREATER_EQUAL_HPP # define BOOST_PREPROCESSOR_COMPARISON_GREATER_EQUAL_HPP # # include # include # # /* BOOST_PP_GREATER_EQUAL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_GREATER_EQUAL(x, y) BOOST_PP_LESS_EQUAL(y, x) # else # define BOOST_PP_GREATER_EQUAL(x, y) BOOST_PP_GREATER_EQUAL_I(x, y) # define BOOST_PP_GREATER_EQUAL_I(x, y) BOOST_PP_LESS_EQUAL(y, x) # endif # # /* BOOST_PP_GREATER_EQUAL_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_GREATER_EQUAL_D(d, x, y) BOOST_PP_LESS_EQUAL_D(d, y, x) # else # define BOOST_PP_GREATER_EQUAL_D(d, x, y) BOOST_PP_GREATER_EQUAL_D_I(d, x, y) # define BOOST_PP_GREATER_EQUAL_D_I(d, x, y) BOOST_PP_LESS_EQUAL_D(d, y, x) # endif # # endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000000216511344301502031734 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_GREATER_HPP # define BOOST_PREPROCESSOR_COMPARISON_GREATER_HPP # # include # include # # /* BOOST_PP_GREATER */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_GREATER(x, y) BOOST_PP_LESS(y, x) # else # define BOOST_PP_GREATER(x, y) BOOST_PP_GREATER_I(x, y) # define BOOST_PP_GREATER_I(x, y) BOOST_PP_LESS(y, x) # endif # # /* BOOST_PP_GREATER_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_GREATER_D(d, x, y) BOOST_PP_LESS_D(d, y, x) # else # define BOOST_PP_GREATER_D(d, x, y) BOOST_PP_GREATER_D_I(d, x, y) # define BOOST_PP_GREATER_D_I(d, x, y) BOOST_PP_LESS_D(d, y, x) # endif # # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000000175611344301502031741 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_EQUAL_HPP # define BOOST_PREPROCESSOR_COMPARISON_EQUAL_HPP # # include # include # include # # /* BOOST_PP_EQUAL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_EQUAL(x, y) BOOST_PP_COMPL(BOOST_PP_NOT_EQUAL(x, y)) # else # define BOOST_PP_EQUAL(x, y) BOOST_PP_EQUAL_I(x, y) # define BOOST_PP_EQUAL_I(x, y) BOOST_PP_COMPL(BOOST_PP_NOT_EQUAL(x, y)) # endif # # /* BOOST_PP_EQUAL_D */ # # define BOOST_PP_EQUAL_D(d, x, y) BOOST_PP_EQUAL(x, y) # # endif ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparison/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comparis0000644000175000017500000000237311344301502031735 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMPARISON_LESS_EQUAL_HPP # define BOOST_PREPROCESSOR_COMPARISON_LESS_EQUAL_HPP # # include # include # include # # /* BOOST_PP_LESS_EQUAL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LESS_EQUAL(x, y) BOOST_PP_NOT(BOOST_PP_SUB(x, y)) # else # define BOOST_PP_LESS_EQUAL(x, y) BOOST_PP_LESS_EQUAL_I(x, y) # define BOOST_PP_LESS_EQUAL_I(x, y) BOOST_PP_NOT(BOOST_PP_SUB(x, y)) # endif # # /* BOOST_PP_LESS_EQUAL_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LESS_EQUAL_D(d, x, y) BOOST_PP_NOT(BOOST_PP_SUB_D(d, x, y)) # else # define BOOST_PP_LESS_EQUAL_D(d, x, y) BOOST_PP_LESS_EQUAL_D_I(d, x, y) # define BOOST_PP_LESS_EQUAL_D_I(d, x, y) BOOST_PP_NOT(BOOST_PP_SUB_D(d, x, y)) # endif # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/config/0000755000175000017500000000000012146213763031451 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/config/config.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/config/c0000644000175000017500000000425411344301502031607 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP # define BOOST_PREPROCESSOR_CONFIG_CONFIG_HPP # # /* BOOST_PP_CONFIG_FLAGS */ # # define BOOST_PP_CONFIG_STRICT() 0x0001 # define BOOST_PP_CONFIG_IDEAL() 0x0002 # # define BOOST_PP_CONFIG_MSVC() 0x0004 # define BOOST_PP_CONFIG_MWCC() 0x0008 # define BOOST_PP_CONFIG_BCC() 0x0010 # define BOOST_PP_CONFIG_EDG() 0x0020 # define BOOST_PP_CONFIG_DMC() 0x0040 # # ifndef BOOST_PP_CONFIG_FLAGS # if defined(__SPIRIT_PP__) || defined(__MWERKS__) && __MWERKS__ >= 0x3200 # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) # elif defined(__EDG__) || defined(__EDG_VERSION__) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_EDG() | BOOST_PP_CONFIG_STRICT()) # elif defined(__MWERKS__) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MWCC()) # elif defined(__DMC__) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_DMC()) # elif defined(__BORLANDC__) || defined(__IBMC__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_BCC()) # elif defined(_MSC_VER) # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC()) # else # define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT()) # endif # endif # # /* BOOST_PP_CONFIG_EXTENDED_LINE_INFO */ # # ifndef BOOST_PP_CONFIG_EXTENDED_LINE_INFO # define BOOST_PP_CONFIG_EXTENDED_LINE_INFO 0 # endif # # /* BOOST_PP_CONFIG_ERRORS */ # # ifndef BOOST_PP_CONFIG_ERRORS # ifdef NDEBUG # define BOOST_PP_CONFIG_ERRORS 0 # else # define BOOST_PP_CONFIG_ERRORS 1 # endif # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/config/limits.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/config/l0000644000175000017500000000150611344301502031615 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_CONFIG_LIMITS_HPP # define BOOST_PREPROCESSOR_CONFIG_LIMITS_HPP # # define BOOST_PP_LIMIT_MAG 256 # define BOOST_PP_LIMIT_TUPLE 25 # define BOOST_PP_LIMIT_DIM 3 # define BOOST_PP_LIMIT_REPEAT 256 # define BOOST_PP_LIMIT_WHILE 256 # define BOOST_PP_LIMIT_FOR 256 # define BOOST_PP_LIMIT_ITERATION 256 # define BOOST_PP_LIMIT_ITERATION_DIM 3 # define BOOST_PP_LIMIT_SEQ 256 # define BOOST_PP_LIMIT_SLOT_SIG 10 # define BOOST_PP_LIMIT_SLOT_COUNT 5 # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000755000175000017500000000000012146213770031750 5ustar debiandebian././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_shifted.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000706411344301502031747 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_SHIFTED_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_SHIFTED_HPP # # include # include # include # include # include # include # include # include # include # include # # /* BOOST_PP_ENUM_SHIFTED */ # # if 0 # define BOOST_PP_ENUM_SHIFTED(count, macro, data) # endif # # define BOOST_PP_ENUM_SHIFTED BOOST_PP_CAT(BOOST_PP_ENUM_SHIFTED_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_SHIFTED_1(c, m, d) BOOST_PP_REPEAT_1(BOOST_PP_DEC(c), BOOST_PP_ENUM_SHIFTED_M_1, (m, d)) # define BOOST_PP_ENUM_SHIFTED_2(c, m, d) BOOST_PP_REPEAT_2(BOOST_PP_DEC(c), BOOST_PP_ENUM_SHIFTED_M_2, (m, d)) # define BOOST_PP_ENUM_SHIFTED_3(c, m, d) BOOST_PP_REPEAT_3(BOOST_PP_DEC(c), BOOST_PP_ENUM_SHIFTED_M_3, (m, d)) # else # define BOOST_PP_ENUM_SHIFTED_1(c, m, d) BOOST_PP_ENUM_SHIFTED_1_I(c, m, d) # define BOOST_PP_ENUM_SHIFTED_2(c, m, d) BOOST_PP_ENUM_SHIFTED_1_2(c, m, d) # define BOOST_PP_ENUM_SHIFTED_3(c, m, d) BOOST_PP_ENUM_SHIFTED_1_3(c, m, d) # define BOOST_PP_ENUM_SHIFTED_1_I(c, m, d) BOOST_PP_REPEAT_1(BOOST_PP_DEC(c), BOOST_PP_ENUM_SHIFTED_M_1, (m, d)) # define BOOST_PP_ENUM_SHIFTED_2_I(c, m, d) BOOST_PP_REPEAT_2(BOOST_PP_DEC(c), BOOST_PP_ENUM_SHIFTED_M_2, (m, d)) # define BOOST_PP_ENUM_SHIFTED_3_I(c, m, d) BOOST_PP_REPEAT_3(BOOST_PP_DEC(c), BOOST_PP_ENUM_SHIFTED_M_3, (m, d)) # endif # # define BOOST_PP_ENUM_SHIFTED_4(c, m, d) BOOST_PP_ERROR(0x0003) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ENUM_SHIFTED_M_1(z, n, md) BOOST_PP_ENUM_SHIFTED_M_1_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_SHIFTED_M_2(z, n, md) BOOST_PP_ENUM_SHIFTED_M_2_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_SHIFTED_M_3(z, n, md) BOOST_PP_ENUM_SHIFTED_M_3_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_SHIFTED_M_1_IM(z, n, im) BOOST_PP_ENUM_SHIFTED_M_1_I(z, n, im) # define BOOST_PP_ENUM_SHIFTED_M_2_IM(z, n, im) BOOST_PP_ENUM_SHIFTED_M_2_I(z, n, im) # define BOOST_PP_ENUM_SHIFTED_M_3_IM(z, n, im) BOOST_PP_ENUM_SHIFTED_M_3_I(z, n, im) # else # define BOOST_PP_ENUM_SHIFTED_M_1(z, n, md) BOOST_PP_ENUM_SHIFTED_M_1_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # define BOOST_PP_ENUM_SHIFTED_M_2(z, n, md) BOOST_PP_ENUM_SHIFTED_M_2_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # define BOOST_PP_ENUM_SHIFTED_M_3(z, n, md) BOOST_PP_ENUM_SHIFTED_M_3_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # endif # # define BOOST_PP_ENUM_SHIFTED_M_1_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, BOOST_PP_INC(n), d) # define BOOST_PP_ENUM_SHIFTED_M_2_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, BOOST_PP_INC(n), d) # define BOOST_PP_ENUM_SHIFTED_M_3_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, BOOST_PP_INC(n), d) # # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_shifted_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000353511344301502031746 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_SHIFTED_PARAMS_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_SHIFTED_PARAMS_HPP # # include # include # include # include # include # include # # /* BOOST_PP_ENUM_SHIFTED_PARAMS */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_SHIFTED_PARAMS(count, param) BOOST_PP_REPEAT(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_PARAMS_M, param) # else # define BOOST_PP_ENUM_SHIFTED_PARAMS(count, param) BOOST_PP_ENUM_SHIFTED_PARAMS_I(count, param) # define BOOST_PP_ENUM_SHIFTED_PARAMS_I(count, param) BOOST_PP_REPEAT(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_PARAMS_M, param) # endif # # define BOOST_PP_ENUM_SHIFTED_PARAMS_M(z, n, param) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(param, BOOST_PP_INC(n)) # # /* BOOST_PP_ENUM_SHIFTED_PARAMS_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, count, param) BOOST_PP_REPEAT_ ## z(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_PARAMS_M, param) # else # define BOOST_PP_ENUM_SHIFTED_PARAMS_Z(z, count, param) BOOST_PP_ENUM_SHIFTED_PARAMS_Z_I(z, count, param) # define BOOST_PP_ENUM_SHIFTED_PARAMS_Z_I(z, count, param) BOOST_PP_REPEAT_ ## z(BOOST_PP_DEC(count), BOOST_PP_ENUM_SHIFTED_PARAMS_M, param) # endif # # endif ././@LongLink0000000000000000000000000000020500000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_params_with_defaults.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000141211344301502031736 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_DEFAULTS_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_DEFAULTS_HPP # # include # include # # /* BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS */ # # define BOOST_PP_ENUM_PARAMS_WITH_DEFAULTS(count, param, def) BOOST_PP_ENUM_BINARY_PARAMS(count, param, = def) # # endif ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_binary_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000534411344301502031746 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_BINARY_PARAMS_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_BINARY_PARAMS_HPP # # include # include # include # include # include # include # # /* BOOST_PP_ENUM_BINARY_PARAMS */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_BINARY_PARAMS(count, p1, p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) # else # define BOOST_PP_ENUM_BINARY_PARAMS(count, p1, p2) BOOST_PP_ENUM_BINARY_PARAMS_I(count, p1, p2) # define BOOST_PP_ENUM_BINARY_PARAMS_I(count, p1, p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ENUM_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_BINARY_PARAMS_M_IM(z, n, BOOST_PP_TUPLE_REM_2 pp) # define BOOST_PP_ENUM_BINARY_PARAMS_M_IM(z, n, im) BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, im) # else # define BOOST_PP_ENUM_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, pp), BOOST_PP_TUPLE_ELEM(2, 1, pp)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, p1, p2) BOOST_PP_ENUM_BINARY_PARAMS_M_II(z, n, p1, p2) # define BOOST_PP_ENUM_BINARY_PARAMS_M_II(z, n, p1, p2) BOOST_PP_COMMA_IF(n) p1 ## n p2 ## n # else # define BOOST_PP_ENUM_BINARY_PARAMS_M_I(z, n, p1, p2) BOOST_PP_COMMA_IF(n) BOOST_PP_CAT(p1, n) BOOST_PP_CAT(p2, n) # endif # # /* BOOST_PP_ENUM_BINARY_PARAMS_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) # else # define BOOST_PP_ENUM_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_ENUM_BINARY_PARAMS_Z_I(z, count, p1, p2) # define BOOST_PP_ENUM_BINARY_PARAMS_Z_I(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_BINARY_PARAMS_M, (p1, p2)) # endif # # endif ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_params_with_a_default.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000153111344301502031740 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_A_DEFAULT_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_WITH_A_DEFAULT_HPP # # include # include # include # # /* BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT */ # # define BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(count, param, def) BOOST_PP_ENUM_BINARY_PARAMS(count, param, = def BOOST_PP_INTERCEPT) # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/for.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000004030411344301502031741 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_FOR_HPP # define BOOST_PREPROCESSOR_REPETITION_FOR_HPP # # include # include # include # # /* BOOST_PP_FOR */ # # if 0 # define BOOST_PP_FOR(state, pred, op, macro) # endif # # define BOOST_PP_FOR BOOST_PP_CAT(BOOST_PP_FOR_, BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256)) # # define BOOST_PP_FOR_P(n) BOOST_PP_CAT(BOOST_PP_FOR_CHECK_, BOOST_PP_FOR_ ## n(1, BOOST_PP_FOR_SR_P, BOOST_PP_FOR_SR_O, BOOST_PP_FOR_SR_M)) # # define BOOST_PP_FOR_SR_P(r, s) s # define BOOST_PP_FOR_SR_O(r, s) 0 # define BOOST_PP_FOR_SR_M(r, s) BOOST_PP_NIL # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # include # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # include # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # include # else # include # endif # # define BOOST_PP_FOR_257(s, p, o, m) BOOST_PP_ERROR(0x0002) # # define BOOST_PP_FOR_CHECK_BOOST_PP_NIL 1 # # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_1(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_2(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_3(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_4(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_5(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_6(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_7(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_8(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_9(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_10(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_11(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_12(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_13(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_14(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_15(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_16(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_17(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_18(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_19(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_20(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_21(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_22(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_23(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_24(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_25(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_26(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_27(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_28(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_29(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_30(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_31(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_32(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_33(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_34(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_35(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_36(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_37(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_38(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_39(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_40(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_41(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_42(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_43(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_44(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_45(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_46(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_47(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_48(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_49(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_50(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_51(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_52(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_53(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_54(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_55(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_56(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_57(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_58(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_59(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_60(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_61(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_62(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_63(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_64(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_65(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_66(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_67(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_68(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_69(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_70(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_71(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_72(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_73(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_74(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_75(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_76(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_77(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_78(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_79(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_80(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_81(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_82(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_83(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_84(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_85(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_86(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_87(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_88(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_89(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_90(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_91(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_92(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_93(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_94(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_95(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_96(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_97(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_98(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_99(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_100(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_101(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_102(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_103(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_104(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_105(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_106(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_107(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_108(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_109(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_110(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_111(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_112(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_113(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_114(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_115(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_116(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_117(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_118(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_119(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_120(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_121(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_122(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_123(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_124(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_125(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_126(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_127(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_128(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_129(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_130(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_131(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_132(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_133(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_134(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_135(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_136(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_137(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_138(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_139(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_140(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_141(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_142(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_143(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_144(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_145(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_146(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_147(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_148(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_149(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_150(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_151(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_152(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_153(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_154(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_155(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_156(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_157(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_158(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_159(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_160(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_161(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_162(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_163(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_164(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_165(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_166(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_167(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_168(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_169(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_170(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_171(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_172(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_173(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_174(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_175(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_176(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_177(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_178(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_179(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_180(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_181(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_182(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_183(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_184(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_185(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_186(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_187(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_188(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_189(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_190(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_191(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_192(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_193(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_194(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_195(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_196(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_197(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_198(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_199(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_200(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_201(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_202(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_203(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_204(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_205(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_206(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_207(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_208(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_209(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_210(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_211(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_212(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_213(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_214(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_215(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_216(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_217(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_218(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_219(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_220(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_221(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_222(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_223(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_224(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_225(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_226(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_227(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_228(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_229(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_230(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_231(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_232(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_233(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_234(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_235(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_236(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_237(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_238(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_239(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_240(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_241(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_242(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_243(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_244(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_245(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_246(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_247(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_248(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_249(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_250(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_251(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_252(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_253(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_254(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_255(s, p, o, m) 0 # define BOOST_PP_FOR_CHECK_BOOST_PP_FOR_256(s, p, o, m) 0 # # endif ././@LongLink0000000000000000000000000000020700000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_trailing_binary_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000556011344301502031746 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_BINARY_PARAMS_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_BINARY_PARAMS_HPP # # include # include # include # include # include # # /* BOOST_PP_ENUM_TRAILING_BINARY_PARAMS */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(count, p1, p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M, (p1, p2)) # else # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(count, p1, p2) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_I(count, p1, p2) # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_I(count, p1, p2) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M, (p1, p2)) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_IM(z, n, BOOST_PP_TUPLE_REM_2 pp) # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_IM(z, n, im) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_I(z, n, im) # else # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M(z, n, pp) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, pp), BOOST_PP_TUPLE_ELEM(2, 1, pp)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_I(z, n, p1, p2) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_II(z, n, p1, p2) # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_II(z, n, p1, p2) , p1 ## n p2 ## n # else # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M_I(z, n, p1, p2) , BOOST_PP_CAT(p1, n) BOOST_PP_CAT(p2, n) # endif # # /* BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M, (p1, p2)) # else # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, count, p1, p2) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z_I(z, count, p1, p2) # define BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z_I(z, count, p1, p2) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_M, (p1, p2)) # endif # # endif ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000277011344301502031746 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_PARAMS_HPP # # include # include # include # # /* BOOST_PP_ENUM_PARAMS */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_PARAMS(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_PARAMS_M, param) # else # define BOOST_PP_ENUM_PARAMS(count, param) BOOST_PP_ENUM_PARAMS_I(count, param) # define BOOST_PP_ENUM_PARAMS_I(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_PARAMS_M, param) # endif # # define BOOST_PP_ENUM_PARAMS_M(z, n, param) BOOST_PP_COMMA_IF(n) param ## n # # /* BOOST_PP_ENUM_PARAMS_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_PARAMS_Z(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_PARAMS_M, param) # else # define BOOST_PP_ENUM_PARAMS_Z(z, count, param) BOOST_PP_ENUM_PARAMS_Z_I(z, count, param) # define BOOST_PP_ENUM_PARAMS_Z_I(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_PARAMS_M, param) # endif # # endif ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/repeat_from_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000001221211344301502031736 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_REPEAT_FROM_TO_HPP # define BOOST_PREPROCESSOR_REPETITION_REPEAT_FROM_TO_HPP # # include # include # include # include # include # include # include # include # include # include # # /* BOOST_PP_REPEAT_FROM_TO */ # # if 0 # define BOOST_PP_REPEAT_FROM_TO(first, last, macro, data) # endif # # define BOOST_PP_REPEAT_FROM_TO BOOST_PP_CAT(BOOST_PP_REPEAT_FROM_TO_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) # # define BOOST_PP_REPEAT_FROM_TO_1(f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_1(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt) # define BOOST_PP_REPEAT_FROM_TO_2(f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_2(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt) # define BOOST_PP_REPEAT_FROM_TO_3(f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_3(BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256), f, l, m, dt) # define BOOST_PP_REPEAT_FROM_TO_4(f, l, m, dt) BOOST_PP_ERROR(0x0003) # # define BOOST_PP_REPEAT_FROM_TO_1ST BOOST_PP_REPEAT_FROM_TO_1 # define BOOST_PP_REPEAT_FROM_TO_2ND BOOST_PP_REPEAT_FROM_TO_2 # define BOOST_PP_REPEAT_FROM_TO_3RD BOOST_PP_REPEAT_FROM_TO_3 # # /* BOOST_PP_REPEAT_FROM_TO_D */ # # if 0 # define BOOST_PP_REPEAT_FROM_TO_D(d, first, last, macro, data) # endif # # define BOOST_PP_REPEAT_FROM_TO_D BOOST_PP_CAT(BOOST_PP_REPEAT_FROM_TO_D_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_REPEAT_FROM_TO_D_1(d, f, l, m, dt) BOOST_PP_REPEAT_1(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_1, (d, f, m, dt)) # define BOOST_PP_REPEAT_FROM_TO_D_2(d, f, l, m, dt) BOOST_PP_REPEAT_2(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_2, (d, f, m, dt)) # define BOOST_PP_REPEAT_FROM_TO_D_3(d, f, l, m, dt) BOOST_PP_REPEAT_3(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_3, (d, f, m, dt)) # else # define BOOST_PP_REPEAT_FROM_TO_D_1(d, f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_1_I(d, f, l, m, dt) # define BOOST_PP_REPEAT_FROM_TO_D_2(d, f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_2_I(d, f, l, m, dt) # define BOOST_PP_REPEAT_FROM_TO_D_3(d, f, l, m, dt) BOOST_PP_REPEAT_FROM_TO_D_3_I(d, f, l, m, dt) # define BOOST_PP_REPEAT_FROM_TO_D_1_I(d, f, l, m, dt) BOOST_PP_REPEAT_1(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_1, (d, f, m, dt)) # define BOOST_PP_REPEAT_FROM_TO_D_2_I(d, f, l, m, dt) BOOST_PP_REPEAT_2(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_2, (d, f, m, dt)) # define BOOST_PP_REPEAT_FROM_TO_D_3_I(d, f, l, m, dt) BOOST_PP_REPEAT_3(BOOST_PP_SUB_D(d, l, f), BOOST_PP_REPEAT_FROM_TO_M_3, (d, f, m, dt)) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_REPEAT_FROM_TO_M_1(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_1_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd) # define BOOST_PP_REPEAT_FROM_TO_M_2(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_2_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd) # define BOOST_PP_REPEAT_FROM_TO_M_3(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_3_IM(z, n, BOOST_PP_TUPLE_REM_4 dfmd) # define BOOST_PP_REPEAT_FROM_TO_M_1_IM(z, n, im) BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, im) # define BOOST_PP_REPEAT_FROM_TO_M_2_IM(z, n, im) BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, im) # define BOOST_PP_REPEAT_FROM_TO_M_3_IM(z, n, im) BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, im) # else # define BOOST_PP_REPEAT_FROM_TO_M_1(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, BOOST_PP_TUPLE_ELEM(4, 0, dfmd), BOOST_PP_TUPLE_ELEM(4, 1, dfmd), BOOST_PP_TUPLE_ELEM(4, 2, dfmd), BOOST_PP_TUPLE_ELEM(4, 3, dfmd)) # define BOOST_PP_REPEAT_FROM_TO_M_2(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, BOOST_PP_TUPLE_ELEM(4, 0, dfmd), BOOST_PP_TUPLE_ELEM(4, 1, dfmd), BOOST_PP_TUPLE_ELEM(4, 2, dfmd), BOOST_PP_TUPLE_ELEM(4, 3, dfmd)) # define BOOST_PP_REPEAT_FROM_TO_M_3(z, n, dfmd) BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, BOOST_PP_TUPLE_ELEM(4, 0, dfmd), BOOST_PP_TUPLE_ELEM(4, 1, dfmd), BOOST_PP_TUPLE_ELEM(4, 2, dfmd), BOOST_PP_TUPLE_ELEM(4, 3, dfmd)) # endif # # define BOOST_PP_REPEAT_FROM_TO_M_1_I(z, n, d, f, m, dt) BOOST_PP_REPEAT_FROM_TO_M_1_II(z, BOOST_PP_ADD_D(d, n, f), m, dt) # define BOOST_PP_REPEAT_FROM_TO_M_2_I(z, n, d, f, m, dt) BOOST_PP_REPEAT_FROM_TO_M_2_II(z, BOOST_PP_ADD_D(d, n, f), m, dt) # define BOOST_PP_REPEAT_FROM_TO_M_3_I(z, n, d, f, m, dt) BOOST_PP_REPEAT_FROM_TO_M_3_II(z, BOOST_PP_ADD_D(d, n, f), m, dt) # # define BOOST_PP_REPEAT_FROM_TO_M_1_II(z, n, m, dt) m(z, n, dt) # define BOOST_PP_REPEAT_FROM_TO_M_2_II(z, n, m, dt) m(z, n, dt) # define BOOST_PP_REPEAT_FROM_TO_M_3_II(z, n, m, dt) m(z, n, dt) # # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/repeat.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000016662211344301502031755 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP # define BOOST_PREPROCESSOR_REPETITION_REPEAT_HPP # # include # include # include # include # include # # /* BOOST_PP_REPEAT */ # # if 0 # define BOOST_PP_REPEAT(count, macro, data) # endif # # define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) # # define BOOST_PP_REPEAT_P(n) BOOST_PP_CAT(BOOST_PP_REPEAT_CHECK_, BOOST_PP_REPEAT_ ## n(1, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3, BOOST_PP_NIL)) # # define BOOST_PP_REPEAT_CHECK_BOOST_PP_NIL 1 # define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_1(c, m, d) 0 # define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_2(c, m, d) 0 # define BOOST_PP_REPEAT_CHECK_BOOST_PP_REPEAT_3(c, m, d) 0 # # define BOOST_PP_REPEAT_1(c, m, d) BOOST_PP_REPEAT_1_I(c, m, d) # define BOOST_PP_REPEAT_2(c, m, d) BOOST_PP_REPEAT_2_I(c, m, d) # define BOOST_PP_REPEAT_3(c, m, d) BOOST_PP_REPEAT_3_I(c, m, d) # define BOOST_PP_REPEAT_4(c, m, d) BOOST_PP_ERROR(0x0003) # # define BOOST_PP_REPEAT_1_I(c, m, d) BOOST_PP_REPEAT_1_ ## c(m, d) # define BOOST_PP_REPEAT_2_I(c, m, d) BOOST_PP_REPEAT_2_ ## c(m, d) # define BOOST_PP_REPEAT_3_I(c, m, d) BOOST_PP_REPEAT_3_ ## c(m, d) # # define BOOST_PP_REPEAT_1ST BOOST_PP_REPEAT_1 # define BOOST_PP_REPEAT_2ND BOOST_PP_REPEAT_2 # define BOOST_PP_REPEAT_3RD BOOST_PP_REPEAT_3 # # define BOOST_PP_REPEAT_1_0(m, d) # define BOOST_PP_REPEAT_1_1(m, d) m(2, 0, d) # define BOOST_PP_REPEAT_1_2(m, d) BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d) # define BOOST_PP_REPEAT_1_3(m, d) BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d) # define BOOST_PP_REPEAT_1_4(m, d) BOOST_PP_REPEAT_1_3(m, d) m(2, 3, d) # define BOOST_PP_REPEAT_1_5(m, d) BOOST_PP_REPEAT_1_4(m, d) m(2, 4, d) # define BOOST_PP_REPEAT_1_6(m, d) BOOST_PP_REPEAT_1_5(m, d) m(2, 5, d) # define BOOST_PP_REPEAT_1_7(m, d) BOOST_PP_REPEAT_1_6(m, d) m(2, 6, d) # define BOOST_PP_REPEAT_1_8(m, d) BOOST_PP_REPEAT_1_7(m, d) m(2, 7, d) # define BOOST_PP_REPEAT_1_9(m, d) BOOST_PP_REPEAT_1_8(m, d) m(2, 8, d) # define BOOST_PP_REPEAT_1_10(m, d) BOOST_PP_REPEAT_1_9(m, d) m(2, 9, d) # define BOOST_PP_REPEAT_1_11(m, d) BOOST_PP_REPEAT_1_10(m, d) m(2, 10, d) # define BOOST_PP_REPEAT_1_12(m, d) BOOST_PP_REPEAT_1_11(m, d) m(2, 11, d) # define BOOST_PP_REPEAT_1_13(m, d) BOOST_PP_REPEAT_1_12(m, d) m(2, 12, d) # define BOOST_PP_REPEAT_1_14(m, d) BOOST_PP_REPEAT_1_13(m, d) m(2, 13, d) # define BOOST_PP_REPEAT_1_15(m, d) BOOST_PP_REPEAT_1_14(m, d) m(2, 14, d) # define BOOST_PP_REPEAT_1_16(m, d) BOOST_PP_REPEAT_1_15(m, d) m(2, 15, d) # define BOOST_PP_REPEAT_1_17(m, d) BOOST_PP_REPEAT_1_16(m, d) m(2, 16, d) # define BOOST_PP_REPEAT_1_18(m, d) BOOST_PP_REPEAT_1_17(m, d) m(2, 17, d) # define BOOST_PP_REPEAT_1_19(m, d) BOOST_PP_REPEAT_1_18(m, d) m(2, 18, d) # define BOOST_PP_REPEAT_1_20(m, d) BOOST_PP_REPEAT_1_19(m, d) m(2, 19, d) # define BOOST_PP_REPEAT_1_21(m, d) BOOST_PP_REPEAT_1_20(m, d) m(2, 20, d) # define BOOST_PP_REPEAT_1_22(m, d) BOOST_PP_REPEAT_1_21(m, d) m(2, 21, d) # define BOOST_PP_REPEAT_1_23(m, d) BOOST_PP_REPEAT_1_22(m, d) m(2, 22, d) # define BOOST_PP_REPEAT_1_24(m, d) BOOST_PP_REPEAT_1_23(m, d) m(2, 23, d) # define BOOST_PP_REPEAT_1_25(m, d) BOOST_PP_REPEAT_1_24(m, d) m(2, 24, d) # define BOOST_PP_REPEAT_1_26(m, d) BOOST_PP_REPEAT_1_25(m, d) m(2, 25, d) # define BOOST_PP_REPEAT_1_27(m, d) BOOST_PP_REPEAT_1_26(m, d) m(2, 26, d) # define BOOST_PP_REPEAT_1_28(m, d) BOOST_PP_REPEAT_1_27(m, d) m(2, 27, d) # define BOOST_PP_REPEAT_1_29(m, d) BOOST_PP_REPEAT_1_28(m, d) m(2, 28, d) # define BOOST_PP_REPEAT_1_30(m, d) BOOST_PP_REPEAT_1_29(m, d) m(2, 29, d) # define BOOST_PP_REPEAT_1_31(m, d) BOOST_PP_REPEAT_1_30(m, d) m(2, 30, d) # define BOOST_PP_REPEAT_1_32(m, d) BOOST_PP_REPEAT_1_31(m, d) m(2, 31, d) # define BOOST_PP_REPEAT_1_33(m, d) BOOST_PP_REPEAT_1_32(m, d) m(2, 32, d) # define BOOST_PP_REPEAT_1_34(m, d) BOOST_PP_REPEAT_1_33(m, d) m(2, 33, d) # define BOOST_PP_REPEAT_1_35(m, d) BOOST_PP_REPEAT_1_34(m, d) m(2, 34, d) # define BOOST_PP_REPEAT_1_36(m, d) BOOST_PP_REPEAT_1_35(m, d) m(2, 35, d) # define BOOST_PP_REPEAT_1_37(m, d) BOOST_PP_REPEAT_1_36(m, d) m(2, 36, d) # define BOOST_PP_REPEAT_1_38(m, d) BOOST_PP_REPEAT_1_37(m, d) m(2, 37, d) # define BOOST_PP_REPEAT_1_39(m, d) BOOST_PP_REPEAT_1_38(m, d) m(2, 38, d) # define BOOST_PP_REPEAT_1_40(m, d) BOOST_PP_REPEAT_1_39(m, d) m(2, 39, d) # define BOOST_PP_REPEAT_1_41(m, d) BOOST_PP_REPEAT_1_40(m, d) m(2, 40, d) # define BOOST_PP_REPEAT_1_42(m, d) BOOST_PP_REPEAT_1_41(m, d) m(2, 41, d) # define BOOST_PP_REPEAT_1_43(m, d) BOOST_PP_REPEAT_1_42(m, d) m(2, 42, d) # define BOOST_PP_REPEAT_1_44(m, d) BOOST_PP_REPEAT_1_43(m, d) m(2, 43, d) # define BOOST_PP_REPEAT_1_45(m, d) BOOST_PP_REPEAT_1_44(m, d) m(2, 44, d) # define BOOST_PP_REPEAT_1_46(m, d) BOOST_PP_REPEAT_1_45(m, d) m(2, 45, d) # define BOOST_PP_REPEAT_1_47(m, d) BOOST_PP_REPEAT_1_46(m, d) m(2, 46, d) # define BOOST_PP_REPEAT_1_48(m, d) BOOST_PP_REPEAT_1_47(m, d) m(2, 47, d) # define BOOST_PP_REPEAT_1_49(m, d) BOOST_PP_REPEAT_1_48(m, d) m(2, 48, d) # define BOOST_PP_REPEAT_1_50(m, d) BOOST_PP_REPEAT_1_49(m, d) m(2, 49, d) # define BOOST_PP_REPEAT_1_51(m, d) BOOST_PP_REPEAT_1_50(m, d) m(2, 50, d) # define BOOST_PP_REPEAT_1_52(m, d) BOOST_PP_REPEAT_1_51(m, d) m(2, 51, d) # define BOOST_PP_REPEAT_1_53(m, d) BOOST_PP_REPEAT_1_52(m, d) m(2, 52, d) # define BOOST_PP_REPEAT_1_54(m, d) BOOST_PP_REPEAT_1_53(m, d) m(2, 53, d) # define BOOST_PP_REPEAT_1_55(m, d) BOOST_PP_REPEAT_1_54(m, d) m(2, 54, d) # define BOOST_PP_REPEAT_1_56(m, d) BOOST_PP_REPEAT_1_55(m, d) m(2, 55, d) # define BOOST_PP_REPEAT_1_57(m, d) BOOST_PP_REPEAT_1_56(m, d) m(2, 56, d) # define BOOST_PP_REPEAT_1_58(m, d) BOOST_PP_REPEAT_1_57(m, d) m(2, 57, d) # define BOOST_PP_REPEAT_1_59(m, d) BOOST_PP_REPEAT_1_58(m, d) m(2, 58, d) # define BOOST_PP_REPEAT_1_60(m, d) BOOST_PP_REPEAT_1_59(m, d) m(2, 59, d) # define BOOST_PP_REPEAT_1_61(m, d) BOOST_PP_REPEAT_1_60(m, d) m(2, 60, d) # define BOOST_PP_REPEAT_1_62(m, d) BOOST_PP_REPEAT_1_61(m, d) m(2, 61, d) # define BOOST_PP_REPEAT_1_63(m, d) BOOST_PP_REPEAT_1_62(m, d) m(2, 62, d) # define BOOST_PP_REPEAT_1_64(m, d) BOOST_PP_REPEAT_1_63(m, d) m(2, 63, d) # define BOOST_PP_REPEAT_1_65(m, d) BOOST_PP_REPEAT_1_64(m, d) m(2, 64, d) # define BOOST_PP_REPEAT_1_66(m, d) BOOST_PP_REPEAT_1_65(m, d) m(2, 65, d) # define BOOST_PP_REPEAT_1_67(m, d) BOOST_PP_REPEAT_1_66(m, d) m(2, 66, d) # define BOOST_PP_REPEAT_1_68(m, d) BOOST_PP_REPEAT_1_67(m, d) m(2, 67, d) # define BOOST_PP_REPEAT_1_69(m, d) BOOST_PP_REPEAT_1_68(m, d) m(2, 68, d) # define BOOST_PP_REPEAT_1_70(m, d) BOOST_PP_REPEAT_1_69(m, d) m(2, 69, d) # define BOOST_PP_REPEAT_1_71(m, d) BOOST_PP_REPEAT_1_70(m, d) m(2, 70, d) # define BOOST_PP_REPEAT_1_72(m, d) BOOST_PP_REPEAT_1_71(m, d) m(2, 71, d) # define BOOST_PP_REPEAT_1_73(m, d) BOOST_PP_REPEAT_1_72(m, d) m(2, 72, d) # define BOOST_PP_REPEAT_1_74(m, d) BOOST_PP_REPEAT_1_73(m, d) m(2, 73, d) # define BOOST_PP_REPEAT_1_75(m, d) BOOST_PP_REPEAT_1_74(m, d) m(2, 74, d) # define BOOST_PP_REPEAT_1_76(m, d) BOOST_PP_REPEAT_1_75(m, d) m(2, 75, d) # define BOOST_PP_REPEAT_1_77(m, d) BOOST_PP_REPEAT_1_76(m, d) m(2, 76, d) # define BOOST_PP_REPEAT_1_78(m, d) BOOST_PP_REPEAT_1_77(m, d) m(2, 77, d) # define BOOST_PP_REPEAT_1_79(m, d) BOOST_PP_REPEAT_1_78(m, d) m(2, 78, d) # define BOOST_PP_REPEAT_1_80(m, d) BOOST_PP_REPEAT_1_79(m, d) m(2, 79, d) # define BOOST_PP_REPEAT_1_81(m, d) BOOST_PP_REPEAT_1_80(m, d) m(2, 80, d) # define BOOST_PP_REPEAT_1_82(m, d) BOOST_PP_REPEAT_1_81(m, d) m(2, 81, d) # define BOOST_PP_REPEAT_1_83(m, d) BOOST_PP_REPEAT_1_82(m, d) m(2, 82, d) # define BOOST_PP_REPEAT_1_84(m, d) BOOST_PP_REPEAT_1_83(m, d) m(2, 83, d) # define BOOST_PP_REPEAT_1_85(m, d) BOOST_PP_REPEAT_1_84(m, d) m(2, 84, d) # define BOOST_PP_REPEAT_1_86(m, d) BOOST_PP_REPEAT_1_85(m, d) m(2, 85, d) # define BOOST_PP_REPEAT_1_87(m, d) BOOST_PP_REPEAT_1_86(m, d) m(2, 86, d) # define BOOST_PP_REPEAT_1_88(m, d) BOOST_PP_REPEAT_1_87(m, d) m(2, 87, d) # define BOOST_PP_REPEAT_1_89(m, d) BOOST_PP_REPEAT_1_88(m, d) m(2, 88, d) # define BOOST_PP_REPEAT_1_90(m, d) BOOST_PP_REPEAT_1_89(m, d) m(2, 89, d) # define BOOST_PP_REPEAT_1_91(m, d) BOOST_PP_REPEAT_1_90(m, d) m(2, 90, d) # define BOOST_PP_REPEAT_1_92(m, d) BOOST_PP_REPEAT_1_91(m, d) m(2, 91, d) # define BOOST_PP_REPEAT_1_93(m, d) BOOST_PP_REPEAT_1_92(m, d) m(2, 92, d) # define BOOST_PP_REPEAT_1_94(m, d) BOOST_PP_REPEAT_1_93(m, d) m(2, 93, d) # define BOOST_PP_REPEAT_1_95(m, d) BOOST_PP_REPEAT_1_94(m, d) m(2, 94, d) # define BOOST_PP_REPEAT_1_96(m, d) BOOST_PP_REPEAT_1_95(m, d) m(2, 95, d) # define BOOST_PP_REPEAT_1_97(m, d) BOOST_PP_REPEAT_1_96(m, d) m(2, 96, d) # define BOOST_PP_REPEAT_1_98(m, d) BOOST_PP_REPEAT_1_97(m, d) m(2, 97, d) # define BOOST_PP_REPEAT_1_99(m, d) BOOST_PP_REPEAT_1_98(m, d) m(2, 98, d) # define BOOST_PP_REPEAT_1_100(m, d) BOOST_PP_REPEAT_1_99(m, d) m(2, 99, d) # define BOOST_PP_REPEAT_1_101(m, d) BOOST_PP_REPEAT_1_100(m, d) m(2, 100, d) # define BOOST_PP_REPEAT_1_102(m, d) BOOST_PP_REPEAT_1_101(m, d) m(2, 101, d) # define BOOST_PP_REPEAT_1_103(m, d) BOOST_PP_REPEAT_1_102(m, d) m(2, 102, d) # define BOOST_PP_REPEAT_1_104(m, d) BOOST_PP_REPEAT_1_103(m, d) m(2, 103, d) # define BOOST_PP_REPEAT_1_105(m, d) BOOST_PP_REPEAT_1_104(m, d) m(2, 104, d) # define BOOST_PP_REPEAT_1_106(m, d) BOOST_PP_REPEAT_1_105(m, d) m(2, 105, d) # define BOOST_PP_REPEAT_1_107(m, d) BOOST_PP_REPEAT_1_106(m, d) m(2, 106, d) # define BOOST_PP_REPEAT_1_108(m, d) BOOST_PP_REPEAT_1_107(m, d) m(2, 107, d) # define BOOST_PP_REPEAT_1_109(m, d) BOOST_PP_REPEAT_1_108(m, d) m(2, 108, d) # define BOOST_PP_REPEAT_1_110(m, d) BOOST_PP_REPEAT_1_109(m, d) m(2, 109, d) # define BOOST_PP_REPEAT_1_111(m, d) BOOST_PP_REPEAT_1_110(m, d) m(2, 110, d) # define BOOST_PP_REPEAT_1_112(m, d) BOOST_PP_REPEAT_1_111(m, d) m(2, 111, d) # define BOOST_PP_REPEAT_1_113(m, d) BOOST_PP_REPEAT_1_112(m, d) m(2, 112, d) # define BOOST_PP_REPEAT_1_114(m, d) BOOST_PP_REPEAT_1_113(m, d) m(2, 113, d) # define BOOST_PP_REPEAT_1_115(m, d) BOOST_PP_REPEAT_1_114(m, d) m(2, 114, d) # define BOOST_PP_REPEAT_1_116(m, d) BOOST_PP_REPEAT_1_115(m, d) m(2, 115, d) # define BOOST_PP_REPEAT_1_117(m, d) BOOST_PP_REPEAT_1_116(m, d) m(2, 116, d) # define BOOST_PP_REPEAT_1_118(m, d) BOOST_PP_REPEAT_1_117(m, d) m(2, 117, d) # define BOOST_PP_REPEAT_1_119(m, d) BOOST_PP_REPEAT_1_118(m, d) m(2, 118, d) # define BOOST_PP_REPEAT_1_120(m, d) BOOST_PP_REPEAT_1_119(m, d) m(2, 119, d) # define BOOST_PP_REPEAT_1_121(m, d) BOOST_PP_REPEAT_1_120(m, d) m(2, 120, d) # define BOOST_PP_REPEAT_1_122(m, d) BOOST_PP_REPEAT_1_121(m, d) m(2, 121, d) # define BOOST_PP_REPEAT_1_123(m, d) BOOST_PP_REPEAT_1_122(m, d) m(2, 122, d) # define BOOST_PP_REPEAT_1_124(m, d) BOOST_PP_REPEAT_1_123(m, d) m(2, 123, d) # define BOOST_PP_REPEAT_1_125(m, d) BOOST_PP_REPEAT_1_124(m, d) m(2, 124, d) # define BOOST_PP_REPEAT_1_126(m, d) BOOST_PP_REPEAT_1_125(m, d) m(2, 125, d) # define BOOST_PP_REPEAT_1_127(m, d) BOOST_PP_REPEAT_1_126(m, d) m(2, 126, d) # define BOOST_PP_REPEAT_1_128(m, d) BOOST_PP_REPEAT_1_127(m, d) m(2, 127, d) # define BOOST_PP_REPEAT_1_129(m, d) BOOST_PP_REPEAT_1_128(m, d) m(2, 128, d) # define BOOST_PP_REPEAT_1_130(m, d) BOOST_PP_REPEAT_1_129(m, d) m(2, 129, d) # define BOOST_PP_REPEAT_1_131(m, d) BOOST_PP_REPEAT_1_130(m, d) m(2, 130, d) # define BOOST_PP_REPEAT_1_132(m, d) BOOST_PP_REPEAT_1_131(m, d) m(2, 131, d) # define BOOST_PP_REPEAT_1_133(m, d) BOOST_PP_REPEAT_1_132(m, d) m(2, 132, d) # define BOOST_PP_REPEAT_1_134(m, d) BOOST_PP_REPEAT_1_133(m, d) m(2, 133, d) # define BOOST_PP_REPEAT_1_135(m, d) BOOST_PP_REPEAT_1_134(m, d) m(2, 134, d) # define BOOST_PP_REPEAT_1_136(m, d) BOOST_PP_REPEAT_1_135(m, d) m(2, 135, d) # define BOOST_PP_REPEAT_1_137(m, d) BOOST_PP_REPEAT_1_136(m, d) m(2, 136, d) # define BOOST_PP_REPEAT_1_138(m, d) BOOST_PP_REPEAT_1_137(m, d) m(2, 137, d) # define BOOST_PP_REPEAT_1_139(m, d) BOOST_PP_REPEAT_1_138(m, d) m(2, 138, d) # define BOOST_PP_REPEAT_1_140(m, d) BOOST_PP_REPEAT_1_139(m, d) m(2, 139, d) # define BOOST_PP_REPEAT_1_141(m, d) BOOST_PP_REPEAT_1_140(m, d) m(2, 140, d) # define BOOST_PP_REPEAT_1_142(m, d) BOOST_PP_REPEAT_1_141(m, d) m(2, 141, d) # define BOOST_PP_REPEAT_1_143(m, d) BOOST_PP_REPEAT_1_142(m, d) m(2, 142, d) # define BOOST_PP_REPEAT_1_144(m, d) BOOST_PP_REPEAT_1_143(m, d) m(2, 143, d) # define BOOST_PP_REPEAT_1_145(m, d) BOOST_PP_REPEAT_1_144(m, d) m(2, 144, d) # define BOOST_PP_REPEAT_1_146(m, d) BOOST_PP_REPEAT_1_145(m, d) m(2, 145, d) # define BOOST_PP_REPEAT_1_147(m, d) BOOST_PP_REPEAT_1_146(m, d) m(2, 146, d) # define BOOST_PP_REPEAT_1_148(m, d) BOOST_PP_REPEAT_1_147(m, d) m(2, 147, d) # define BOOST_PP_REPEAT_1_149(m, d) BOOST_PP_REPEAT_1_148(m, d) m(2, 148, d) # define BOOST_PP_REPEAT_1_150(m, d) BOOST_PP_REPEAT_1_149(m, d) m(2, 149, d) # define BOOST_PP_REPEAT_1_151(m, d) BOOST_PP_REPEAT_1_150(m, d) m(2, 150, d) # define BOOST_PP_REPEAT_1_152(m, d) BOOST_PP_REPEAT_1_151(m, d) m(2, 151, d) # define BOOST_PP_REPEAT_1_153(m, d) BOOST_PP_REPEAT_1_152(m, d) m(2, 152, d) # define BOOST_PP_REPEAT_1_154(m, d) BOOST_PP_REPEAT_1_153(m, d) m(2, 153, d) # define BOOST_PP_REPEAT_1_155(m, d) BOOST_PP_REPEAT_1_154(m, d) m(2, 154, d) # define BOOST_PP_REPEAT_1_156(m, d) BOOST_PP_REPEAT_1_155(m, d) m(2, 155, d) # define BOOST_PP_REPEAT_1_157(m, d) BOOST_PP_REPEAT_1_156(m, d) m(2, 156, d) # define BOOST_PP_REPEAT_1_158(m, d) BOOST_PP_REPEAT_1_157(m, d) m(2, 157, d) # define BOOST_PP_REPEAT_1_159(m, d) BOOST_PP_REPEAT_1_158(m, d) m(2, 158, d) # define BOOST_PP_REPEAT_1_160(m, d) BOOST_PP_REPEAT_1_159(m, d) m(2, 159, d) # define BOOST_PP_REPEAT_1_161(m, d) BOOST_PP_REPEAT_1_160(m, d) m(2, 160, d) # define BOOST_PP_REPEAT_1_162(m, d) BOOST_PP_REPEAT_1_161(m, d) m(2, 161, d) # define BOOST_PP_REPEAT_1_163(m, d) BOOST_PP_REPEAT_1_162(m, d) m(2, 162, d) # define BOOST_PP_REPEAT_1_164(m, d) BOOST_PP_REPEAT_1_163(m, d) m(2, 163, d) # define BOOST_PP_REPEAT_1_165(m, d) BOOST_PP_REPEAT_1_164(m, d) m(2, 164, d) # define BOOST_PP_REPEAT_1_166(m, d) BOOST_PP_REPEAT_1_165(m, d) m(2, 165, d) # define BOOST_PP_REPEAT_1_167(m, d) BOOST_PP_REPEAT_1_166(m, d) m(2, 166, d) # define BOOST_PP_REPEAT_1_168(m, d) BOOST_PP_REPEAT_1_167(m, d) m(2, 167, d) # define BOOST_PP_REPEAT_1_169(m, d) BOOST_PP_REPEAT_1_168(m, d) m(2, 168, d) # define BOOST_PP_REPEAT_1_170(m, d) BOOST_PP_REPEAT_1_169(m, d) m(2, 169, d) # define BOOST_PP_REPEAT_1_171(m, d) BOOST_PP_REPEAT_1_170(m, d) m(2, 170, d) # define BOOST_PP_REPEAT_1_172(m, d) BOOST_PP_REPEAT_1_171(m, d) m(2, 171, d) # define BOOST_PP_REPEAT_1_173(m, d) BOOST_PP_REPEAT_1_172(m, d) m(2, 172, d) # define BOOST_PP_REPEAT_1_174(m, d) BOOST_PP_REPEAT_1_173(m, d) m(2, 173, d) # define BOOST_PP_REPEAT_1_175(m, d) BOOST_PP_REPEAT_1_174(m, d) m(2, 174, d) # define BOOST_PP_REPEAT_1_176(m, d) BOOST_PP_REPEAT_1_175(m, d) m(2, 175, d) # define BOOST_PP_REPEAT_1_177(m, d) BOOST_PP_REPEAT_1_176(m, d) m(2, 176, d) # define BOOST_PP_REPEAT_1_178(m, d) BOOST_PP_REPEAT_1_177(m, d) m(2, 177, d) # define BOOST_PP_REPEAT_1_179(m, d) BOOST_PP_REPEAT_1_178(m, d) m(2, 178, d) # define BOOST_PP_REPEAT_1_180(m, d) BOOST_PP_REPEAT_1_179(m, d) m(2, 179, d) # define BOOST_PP_REPEAT_1_181(m, d) BOOST_PP_REPEAT_1_180(m, d) m(2, 180, d) # define BOOST_PP_REPEAT_1_182(m, d) BOOST_PP_REPEAT_1_181(m, d) m(2, 181, d) # define BOOST_PP_REPEAT_1_183(m, d) BOOST_PP_REPEAT_1_182(m, d) m(2, 182, d) # define BOOST_PP_REPEAT_1_184(m, d) BOOST_PP_REPEAT_1_183(m, d) m(2, 183, d) # define BOOST_PP_REPEAT_1_185(m, d) BOOST_PP_REPEAT_1_184(m, d) m(2, 184, d) # define BOOST_PP_REPEAT_1_186(m, d) BOOST_PP_REPEAT_1_185(m, d) m(2, 185, d) # define BOOST_PP_REPEAT_1_187(m, d) BOOST_PP_REPEAT_1_186(m, d) m(2, 186, d) # define BOOST_PP_REPEAT_1_188(m, d) BOOST_PP_REPEAT_1_187(m, d) m(2, 187, d) # define BOOST_PP_REPEAT_1_189(m, d) BOOST_PP_REPEAT_1_188(m, d) m(2, 188, d) # define BOOST_PP_REPEAT_1_190(m, d) BOOST_PP_REPEAT_1_189(m, d) m(2, 189, d) # define BOOST_PP_REPEAT_1_191(m, d) BOOST_PP_REPEAT_1_190(m, d) m(2, 190, d) # define BOOST_PP_REPEAT_1_192(m, d) BOOST_PP_REPEAT_1_191(m, d) m(2, 191, d) # define BOOST_PP_REPEAT_1_193(m, d) BOOST_PP_REPEAT_1_192(m, d) m(2, 192, d) # define BOOST_PP_REPEAT_1_194(m, d) BOOST_PP_REPEAT_1_193(m, d) m(2, 193, d) # define BOOST_PP_REPEAT_1_195(m, d) BOOST_PP_REPEAT_1_194(m, d) m(2, 194, d) # define BOOST_PP_REPEAT_1_196(m, d) BOOST_PP_REPEAT_1_195(m, d) m(2, 195, d) # define BOOST_PP_REPEAT_1_197(m, d) BOOST_PP_REPEAT_1_196(m, d) m(2, 196, d) # define BOOST_PP_REPEAT_1_198(m, d) BOOST_PP_REPEAT_1_197(m, d) m(2, 197, d) # define BOOST_PP_REPEAT_1_199(m, d) BOOST_PP_REPEAT_1_198(m, d) m(2, 198, d) # define BOOST_PP_REPEAT_1_200(m, d) BOOST_PP_REPEAT_1_199(m, d) m(2, 199, d) # define BOOST_PP_REPEAT_1_201(m, d) BOOST_PP_REPEAT_1_200(m, d) m(2, 200, d) # define BOOST_PP_REPEAT_1_202(m, d) BOOST_PP_REPEAT_1_201(m, d) m(2, 201, d) # define BOOST_PP_REPEAT_1_203(m, d) BOOST_PP_REPEAT_1_202(m, d) m(2, 202, d) # define BOOST_PP_REPEAT_1_204(m, d) BOOST_PP_REPEAT_1_203(m, d) m(2, 203, d) # define BOOST_PP_REPEAT_1_205(m, d) BOOST_PP_REPEAT_1_204(m, d) m(2, 204, d) # define BOOST_PP_REPEAT_1_206(m, d) BOOST_PP_REPEAT_1_205(m, d) m(2, 205, d) # define BOOST_PP_REPEAT_1_207(m, d) BOOST_PP_REPEAT_1_206(m, d) m(2, 206, d) # define BOOST_PP_REPEAT_1_208(m, d) BOOST_PP_REPEAT_1_207(m, d) m(2, 207, d) # define BOOST_PP_REPEAT_1_209(m, d) BOOST_PP_REPEAT_1_208(m, d) m(2, 208, d) # define BOOST_PP_REPEAT_1_210(m, d) BOOST_PP_REPEAT_1_209(m, d) m(2, 209, d) # define BOOST_PP_REPEAT_1_211(m, d) BOOST_PP_REPEAT_1_210(m, d) m(2, 210, d) # define BOOST_PP_REPEAT_1_212(m, d) BOOST_PP_REPEAT_1_211(m, d) m(2, 211, d) # define BOOST_PP_REPEAT_1_213(m, d) BOOST_PP_REPEAT_1_212(m, d) m(2, 212, d) # define BOOST_PP_REPEAT_1_214(m, d) BOOST_PP_REPEAT_1_213(m, d) m(2, 213, d) # define BOOST_PP_REPEAT_1_215(m, d) BOOST_PP_REPEAT_1_214(m, d) m(2, 214, d) # define BOOST_PP_REPEAT_1_216(m, d) BOOST_PP_REPEAT_1_215(m, d) m(2, 215, d) # define BOOST_PP_REPEAT_1_217(m, d) BOOST_PP_REPEAT_1_216(m, d) m(2, 216, d) # define BOOST_PP_REPEAT_1_218(m, d) BOOST_PP_REPEAT_1_217(m, d) m(2, 217, d) # define BOOST_PP_REPEAT_1_219(m, d) BOOST_PP_REPEAT_1_218(m, d) m(2, 218, d) # define BOOST_PP_REPEAT_1_220(m, d) BOOST_PP_REPEAT_1_219(m, d) m(2, 219, d) # define BOOST_PP_REPEAT_1_221(m, d) BOOST_PP_REPEAT_1_220(m, d) m(2, 220, d) # define BOOST_PP_REPEAT_1_222(m, d) BOOST_PP_REPEAT_1_221(m, d) m(2, 221, d) # define BOOST_PP_REPEAT_1_223(m, d) BOOST_PP_REPEAT_1_222(m, d) m(2, 222, d) # define BOOST_PP_REPEAT_1_224(m, d) BOOST_PP_REPEAT_1_223(m, d) m(2, 223, d) # define BOOST_PP_REPEAT_1_225(m, d) BOOST_PP_REPEAT_1_224(m, d) m(2, 224, d) # define BOOST_PP_REPEAT_1_226(m, d) BOOST_PP_REPEAT_1_225(m, d) m(2, 225, d) # define BOOST_PP_REPEAT_1_227(m, d) BOOST_PP_REPEAT_1_226(m, d) m(2, 226, d) # define BOOST_PP_REPEAT_1_228(m, d) BOOST_PP_REPEAT_1_227(m, d) m(2, 227, d) # define BOOST_PP_REPEAT_1_229(m, d) BOOST_PP_REPEAT_1_228(m, d) m(2, 228, d) # define BOOST_PP_REPEAT_1_230(m, d) BOOST_PP_REPEAT_1_229(m, d) m(2, 229, d) # define BOOST_PP_REPEAT_1_231(m, d) BOOST_PP_REPEAT_1_230(m, d) m(2, 230, d) # define BOOST_PP_REPEAT_1_232(m, d) BOOST_PP_REPEAT_1_231(m, d) m(2, 231, d) # define BOOST_PP_REPEAT_1_233(m, d) BOOST_PP_REPEAT_1_232(m, d) m(2, 232, d) # define BOOST_PP_REPEAT_1_234(m, d) BOOST_PP_REPEAT_1_233(m, d) m(2, 233, d) # define BOOST_PP_REPEAT_1_235(m, d) BOOST_PP_REPEAT_1_234(m, d) m(2, 234, d) # define BOOST_PP_REPEAT_1_236(m, d) BOOST_PP_REPEAT_1_235(m, d) m(2, 235, d) # define BOOST_PP_REPEAT_1_237(m, d) BOOST_PP_REPEAT_1_236(m, d) m(2, 236, d) # define BOOST_PP_REPEAT_1_238(m, d) BOOST_PP_REPEAT_1_237(m, d) m(2, 237, d) # define BOOST_PP_REPEAT_1_239(m, d) BOOST_PP_REPEAT_1_238(m, d) m(2, 238, d) # define BOOST_PP_REPEAT_1_240(m, d) BOOST_PP_REPEAT_1_239(m, d) m(2, 239, d) # define BOOST_PP_REPEAT_1_241(m, d) BOOST_PP_REPEAT_1_240(m, d) m(2, 240, d) # define BOOST_PP_REPEAT_1_242(m, d) BOOST_PP_REPEAT_1_241(m, d) m(2, 241, d) # define BOOST_PP_REPEAT_1_243(m, d) BOOST_PP_REPEAT_1_242(m, d) m(2, 242, d) # define BOOST_PP_REPEAT_1_244(m, d) BOOST_PP_REPEAT_1_243(m, d) m(2, 243, d) # define BOOST_PP_REPEAT_1_245(m, d) BOOST_PP_REPEAT_1_244(m, d) m(2, 244, d) # define BOOST_PP_REPEAT_1_246(m, d) BOOST_PP_REPEAT_1_245(m, d) m(2, 245, d) # define BOOST_PP_REPEAT_1_247(m, d) BOOST_PP_REPEAT_1_246(m, d) m(2, 246, d) # define BOOST_PP_REPEAT_1_248(m, d) BOOST_PP_REPEAT_1_247(m, d) m(2, 247, d) # define BOOST_PP_REPEAT_1_249(m, d) BOOST_PP_REPEAT_1_248(m, d) m(2, 248, d) # define BOOST_PP_REPEAT_1_250(m, d) BOOST_PP_REPEAT_1_249(m, d) m(2, 249, d) # define BOOST_PP_REPEAT_1_251(m, d) BOOST_PP_REPEAT_1_250(m, d) m(2, 250, d) # define BOOST_PP_REPEAT_1_252(m, d) BOOST_PP_REPEAT_1_251(m, d) m(2, 251, d) # define BOOST_PP_REPEAT_1_253(m, d) BOOST_PP_REPEAT_1_252(m, d) m(2, 252, d) # define BOOST_PP_REPEAT_1_254(m, d) BOOST_PP_REPEAT_1_253(m, d) m(2, 253, d) # define BOOST_PP_REPEAT_1_255(m, d) BOOST_PP_REPEAT_1_254(m, d) m(2, 254, d) # define BOOST_PP_REPEAT_1_256(m, d) BOOST_PP_REPEAT_1_255(m, d) m(2, 255, d) # # define BOOST_PP_REPEAT_2_0(m, d) # define BOOST_PP_REPEAT_2_1(m, d) m(3, 0, d) # define BOOST_PP_REPEAT_2_2(m, d) BOOST_PP_REPEAT_2_1(m, d) m(3, 1, d) # define BOOST_PP_REPEAT_2_3(m, d) BOOST_PP_REPEAT_2_2(m, d) m(3, 2, d) # define BOOST_PP_REPEAT_2_4(m, d) BOOST_PP_REPEAT_2_3(m, d) m(3, 3, d) # define BOOST_PP_REPEAT_2_5(m, d) BOOST_PP_REPEAT_2_4(m, d) m(3, 4, d) # define BOOST_PP_REPEAT_2_6(m, d) BOOST_PP_REPEAT_2_5(m, d) m(3, 5, d) # define BOOST_PP_REPEAT_2_7(m, d) BOOST_PP_REPEAT_2_6(m, d) m(3, 6, d) # define BOOST_PP_REPEAT_2_8(m, d) BOOST_PP_REPEAT_2_7(m, d) m(3, 7, d) # define BOOST_PP_REPEAT_2_9(m, d) BOOST_PP_REPEAT_2_8(m, d) m(3, 8, d) # define BOOST_PP_REPEAT_2_10(m, d) BOOST_PP_REPEAT_2_9(m, d) m(3, 9, d) # define BOOST_PP_REPEAT_2_11(m, d) BOOST_PP_REPEAT_2_10(m, d) m(3, 10, d) # define BOOST_PP_REPEAT_2_12(m, d) BOOST_PP_REPEAT_2_11(m, d) m(3, 11, d) # define BOOST_PP_REPEAT_2_13(m, d) BOOST_PP_REPEAT_2_12(m, d) m(3, 12, d) # define BOOST_PP_REPEAT_2_14(m, d) BOOST_PP_REPEAT_2_13(m, d) m(3, 13, d) # define BOOST_PP_REPEAT_2_15(m, d) BOOST_PP_REPEAT_2_14(m, d) m(3, 14, d) # define BOOST_PP_REPEAT_2_16(m, d) BOOST_PP_REPEAT_2_15(m, d) m(3, 15, d) # define BOOST_PP_REPEAT_2_17(m, d) BOOST_PP_REPEAT_2_16(m, d) m(3, 16, d) # define BOOST_PP_REPEAT_2_18(m, d) BOOST_PP_REPEAT_2_17(m, d) m(3, 17, d) # define BOOST_PP_REPEAT_2_19(m, d) BOOST_PP_REPEAT_2_18(m, d) m(3, 18, d) # define BOOST_PP_REPEAT_2_20(m, d) BOOST_PP_REPEAT_2_19(m, d) m(3, 19, d) # define BOOST_PP_REPEAT_2_21(m, d) BOOST_PP_REPEAT_2_20(m, d) m(3, 20, d) # define BOOST_PP_REPEAT_2_22(m, d) BOOST_PP_REPEAT_2_21(m, d) m(3, 21, d) # define BOOST_PP_REPEAT_2_23(m, d) BOOST_PP_REPEAT_2_22(m, d) m(3, 22, d) # define BOOST_PP_REPEAT_2_24(m, d) BOOST_PP_REPEAT_2_23(m, d) m(3, 23, d) # define BOOST_PP_REPEAT_2_25(m, d) BOOST_PP_REPEAT_2_24(m, d) m(3, 24, d) # define BOOST_PP_REPEAT_2_26(m, d) BOOST_PP_REPEAT_2_25(m, d) m(3, 25, d) # define BOOST_PP_REPEAT_2_27(m, d) BOOST_PP_REPEAT_2_26(m, d) m(3, 26, d) # define BOOST_PP_REPEAT_2_28(m, d) BOOST_PP_REPEAT_2_27(m, d) m(3, 27, d) # define BOOST_PP_REPEAT_2_29(m, d) BOOST_PP_REPEAT_2_28(m, d) m(3, 28, d) # define BOOST_PP_REPEAT_2_30(m, d) BOOST_PP_REPEAT_2_29(m, d) m(3, 29, d) # define BOOST_PP_REPEAT_2_31(m, d) BOOST_PP_REPEAT_2_30(m, d) m(3, 30, d) # define BOOST_PP_REPEAT_2_32(m, d) BOOST_PP_REPEAT_2_31(m, d) m(3, 31, d) # define BOOST_PP_REPEAT_2_33(m, d) BOOST_PP_REPEAT_2_32(m, d) m(3, 32, d) # define BOOST_PP_REPEAT_2_34(m, d) BOOST_PP_REPEAT_2_33(m, d) m(3, 33, d) # define BOOST_PP_REPEAT_2_35(m, d) BOOST_PP_REPEAT_2_34(m, d) m(3, 34, d) # define BOOST_PP_REPEAT_2_36(m, d) BOOST_PP_REPEAT_2_35(m, d) m(3, 35, d) # define BOOST_PP_REPEAT_2_37(m, d) BOOST_PP_REPEAT_2_36(m, d) m(3, 36, d) # define BOOST_PP_REPEAT_2_38(m, d) BOOST_PP_REPEAT_2_37(m, d) m(3, 37, d) # define BOOST_PP_REPEAT_2_39(m, d) BOOST_PP_REPEAT_2_38(m, d) m(3, 38, d) # define BOOST_PP_REPEAT_2_40(m, d) BOOST_PP_REPEAT_2_39(m, d) m(3, 39, d) # define BOOST_PP_REPEAT_2_41(m, d) BOOST_PP_REPEAT_2_40(m, d) m(3, 40, d) # define BOOST_PP_REPEAT_2_42(m, d) BOOST_PP_REPEAT_2_41(m, d) m(3, 41, d) # define BOOST_PP_REPEAT_2_43(m, d) BOOST_PP_REPEAT_2_42(m, d) m(3, 42, d) # define BOOST_PP_REPEAT_2_44(m, d) BOOST_PP_REPEAT_2_43(m, d) m(3, 43, d) # define BOOST_PP_REPEAT_2_45(m, d) BOOST_PP_REPEAT_2_44(m, d) m(3, 44, d) # define BOOST_PP_REPEAT_2_46(m, d) BOOST_PP_REPEAT_2_45(m, d) m(3, 45, d) # define BOOST_PP_REPEAT_2_47(m, d) BOOST_PP_REPEAT_2_46(m, d) m(3, 46, d) # define BOOST_PP_REPEAT_2_48(m, d) BOOST_PP_REPEAT_2_47(m, d) m(3, 47, d) # define BOOST_PP_REPEAT_2_49(m, d) BOOST_PP_REPEAT_2_48(m, d) m(3, 48, d) # define BOOST_PP_REPEAT_2_50(m, d) BOOST_PP_REPEAT_2_49(m, d) m(3, 49, d) # define BOOST_PP_REPEAT_2_51(m, d) BOOST_PP_REPEAT_2_50(m, d) m(3, 50, d) # define BOOST_PP_REPEAT_2_52(m, d) BOOST_PP_REPEAT_2_51(m, d) m(3, 51, d) # define BOOST_PP_REPEAT_2_53(m, d) BOOST_PP_REPEAT_2_52(m, d) m(3, 52, d) # define BOOST_PP_REPEAT_2_54(m, d) BOOST_PP_REPEAT_2_53(m, d) m(3, 53, d) # define BOOST_PP_REPEAT_2_55(m, d) BOOST_PP_REPEAT_2_54(m, d) m(3, 54, d) # define BOOST_PP_REPEAT_2_56(m, d) BOOST_PP_REPEAT_2_55(m, d) m(3, 55, d) # define BOOST_PP_REPEAT_2_57(m, d) BOOST_PP_REPEAT_2_56(m, d) m(3, 56, d) # define BOOST_PP_REPEAT_2_58(m, d) BOOST_PP_REPEAT_2_57(m, d) m(3, 57, d) # define BOOST_PP_REPEAT_2_59(m, d) BOOST_PP_REPEAT_2_58(m, d) m(3, 58, d) # define BOOST_PP_REPEAT_2_60(m, d) BOOST_PP_REPEAT_2_59(m, d) m(3, 59, d) # define BOOST_PP_REPEAT_2_61(m, d) BOOST_PP_REPEAT_2_60(m, d) m(3, 60, d) # define BOOST_PP_REPEAT_2_62(m, d) BOOST_PP_REPEAT_2_61(m, d) m(3, 61, d) # define BOOST_PP_REPEAT_2_63(m, d) BOOST_PP_REPEAT_2_62(m, d) m(3, 62, d) # define BOOST_PP_REPEAT_2_64(m, d) BOOST_PP_REPEAT_2_63(m, d) m(3, 63, d) # define BOOST_PP_REPEAT_2_65(m, d) BOOST_PP_REPEAT_2_64(m, d) m(3, 64, d) # define BOOST_PP_REPEAT_2_66(m, d) BOOST_PP_REPEAT_2_65(m, d) m(3, 65, d) # define BOOST_PP_REPEAT_2_67(m, d) BOOST_PP_REPEAT_2_66(m, d) m(3, 66, d) # define BOOST_PP_REPEAT_2_68(m, d) BOOST_PP_REPEAT_2_67(m, d) m(3, 67, d) # define BOOST_PP_REPEAT_2_69(m, d) BOOST_PP_REPEAT_2_68(m, d) m(3, 68, d) # define BOOST_PP_REPEAT_2_70(m, d) BOOST_PP_REPEAT_2_69(m, d) m(3, 69, d) # define BOOST_PP_REPEAT_2_71(m, d) BOOST_PP_REPEAT_2_70(m, d) m(3, 70, d) # define BOOST_PP_REPEAT_2_72(m, d) BOOST_PP_REPEAT_2_71(m, d) m(3, 71, d) # define BOOST_PP_REPEAT_2_73(m, d) BOOST_PP_REPEAT_2_72(m, d) m(3, 72, d) # define BOOST_PP_REPEAT_2_74(m, d) BOOST_PP_REPEAT_2_73(m, d) m(3, 73, d) # define BOOST_PP_REPEAT_2_75(m, d) BOOST_PP_REPEAT_2_74(m, d) m(3, 74, d) # define BOOST_PP_REPEAT_2_76(m, d) BOOST_PP_REPEAT_2_75(m, d) m(3, 75, d) # define BOOST_PP_REPEAT_2_77(m, d) BOOST_PP_REPEAT_2_76(m, d) m(3, 76, d) # define BOOST_PP_REPEAT_2_78(m, d) BOOST_PP_REPEAT_2_77(m, d) m(3, 77, d) # define BOOST_PP_REPEAT_2_79(m, d) BOOST_PP_REPEAT_2_78(m, d) m(3, 78, d) # define BOOST_PP_REPEAT_2_80(m, d) BOOST_PP_REPEAT_2_79(m, d) m(3, 79, d) # define BOOST_PP_REPEAT_2_81(m, d) BOOST_PP_REPEAT_2_80(m, d) m(3, 80, d) # define BOOST_PP_REPEAT_2_82(m, d) BOOST_PP_REPEAT_2_81(m, d) m(3, 81, d) # define BOOST_PP_REPEAT_2_83(m, d) BOOST_PP_REPEAT_2_82(m, d) m(3, 82, d) # define BOOST_PP_REPEAT_2_84(m, d) BOOST_PP_REPEAT_2_83(m, d) m(3, 83, d) # define BOOST_PP_REPEAT_2_85(m, d) BOOST_PP_REPEAT_2_84(m, d) m(3, 84, d) # define BOOST_PP_REPEAT_2_86(m, d) BOOST_PP_REPEAT_2_85(m, d) m(3, 85, d) # define BOOST_PP_REPEAT_2_87(m, d) BOOST_PP_REPEAT_2_86(m, d) m(3, 86, d) # define BOOST_PP_REPEAT_2_88(m, d) BOOST_PP_REPEAT_2_87(m, d) m(3, 87, d) # define BOOST_PP_REPEAT_2_89(m, d) BOOST_PP_REPEAT_2_88(m, d) m(3, 88, d) # define BOOST_PP_REPEAT_2_90(m, d) BOOST_PP_REPEAT_2_89(m, d) m(3, 89, d) # define BOOST_PP_REPEAT_2_91(m, d) BOOST_PP_REPEAT_2_90(m, d) m(3, 90, d) # define BOOST_PP_REPEAT_2_92(m, d) BOOST_PP_REPEAT_2_91(m, d) m(3, 91, d) # define BOOST_PP_REPEAT_2_93(m, d) BOOST_PP_REPEAT_2_92(m, d) m(3, 92, d) # define BOOST_PP_REPEAT_2_94(m, d) BOOST_PP_REPEAT_2_93(m, d) m(3, 93, d) # define BOOST_PP_REPEAT_2_95(m, d) BOOST_PP_REPEAT_2_94(m, d) m(3, 94, d) # define BOOST_PP_REPEAT_2_96(m, d) BOOST_PP_REPEAT_2_95(m, d) m(3, 95, d) # define BOOST_PP_REPEAT_2_97(m, d) BOOST_PP_REPEAT_2_96(m, d) m(3, 96, d) # define BOOST_PP_REPEAT_2_98(m, d) BOOST_PP_REPEAT_2_97(m, d) m(3, 97, d) # define BOOST_PP_REPEAT_2_99(m, d) BOOST_PP_REPEAT_2_98(m, d) m(3, 98, d) # define BOOST_PP_REPEAT_2_100(m, d) BOOST_PP_REPEAT_2_99(m, d) m(3, 99, d) # define BOOST_PP_REPEAT_2_101(m, d) BOOST_PP_REPEAT_2_100(m, d) m(3, 100, d) # define BOOST_PP_REPEAT_2_102(m, d) BOOST_PP_REPEAT_2_101(m, d) m(3, 101, d) # define BOOST_PP_REPEAT_2_103(m, d) BOOST_PP_REPEAT_2_102(m, d) m(3, 102, d) # define BOOST_PP_REPEAT_2_104(m, d) BOOST_PP_REPEAT_2_103(m, d) m(3, 103, d) # define BOOST_PP_REPEAT_2_105(m, d) BOOST_PP_REPEAT_2_104(m, d) m(3, 104, d) # define BOOST_PP_REPEAT_2_106(m, d) BOOST_PP_REPEAT_2_105(m, d) m(3, 105, d) # define BOOST_PP_REPEAT_2_107(m, d) BOOST_PP_REPEAT_2_106(m, d) m(3, 106, d) # define BOOST_PP_REPEAT_2_108(m, d) BOOST_PP_REPEAT_2_107(m, d) m(3, 107, d) # define BOOST_PP_REPEAT_2_109(m, d) BOOST_PP_REPEAT_2_108(m, d) m(3, 108, d) # define BOOST_PP_REPEAT_2_110(m, d) BOOST_PP_REPEAT_2_109(m, d) m(3, 109, d) # define BOOST_PP_REPEAT_2_111(m, d) BOOST_PP_REPEAT_2_110(m, d) m(3, 110, d) # define BOOST_PP_REPEAT_2_112(m, d) BOOST_PP_REPEAT_2_111(m, d) m(3, 111, d) # define BOOST_PP_REPEAT_2_113(m, d) BOOST_PP_REPEAT_2_112(m, d) m(3, 112, d) # define BOOST_PP_REPEAT_2_114(m, d) BOOST_PP_REPEAT_2_113(m, d) m(3, 113, d) # define BOOST_PP_REPEAT_2_115(m, d) BOOST_PP_REPEAT_2_114(m, d) m(3, 114, d) # define BOOST_PP_REPEAT_2_116(m, d) BOOST_PP_REPEAT_2_115(m, d) m(3, 115, d) # define BOOST_PP_REPEAT_2_117(m, d) BOOST_PP_REPEAT_2_116(m, d) m(3, 116, d) # define BOOST_PP_REPEAT_2_118(m, d) BOOST_PP_REPEAT_2_117(m, d) m(3, 117, d) # define BOOST_PP_REPEAT_2_119(m, d) BOOST_PP_REPEAT_2_118(m, d) m(3, 118, d) # define BOOST_PP_REPEAT_2_120(m, d) BOOST_PP_REPEAT_2_119(m, d) m(3, 119, d) # define BOOST_PP_REPEAT_2_121(m, d) BOOST_PP_REPEAT_2_120(m, d) m(3, 120, d) # define BOOST_PP_REPEAT_2_122(m, d) BOOST_PP_REPEAT_2_121(m, d) m(3, 121, d) # define BOOST_PP_REPEAT_2_123(m, d) BOOST_PP_REPEAT_2_122(m, d) m(3, 122, d) # define BOOST_PP_REPEAT_2_124(m, d) BOOST_PP_REPEAT_2_123(m, d) m(3, 123, d) # define BOOST_PP_REPEAT_2_125(m, d) BOOST_PP_REPEAT_2_124(m, d) m(3, 124, d) # define BOOST_PP_REPEAT_2_126(m, d) BOOST_PP_REPEAT_2_125(m, d) m(3, 125, d) # define BOOST_PP_REPEAT_2_127(m, d) BOOST_PP_REPEAT_2_126(m, d) m(3, 126, d) # define BOOST_PP_REPEAT_2_128(m, d) BOOST_PP_REPEAT_2_127(m, d) m(3, 127, d) # define BOOST_PP_REPEAT_2_129(m, d) BOOST_PP_REPEAT_2_128(m, d) m(3, 128, d) # define BOOST_PP_REPEAT_2_130(m, d) BOOST_PP_REPEAT_2_129(m, d) m(3, 129, d) # define BOOST_PP_REPEAT_2_131(m, d) BOOST_PP_REPEAT_2_130(m, d) m(3, 130, d) # define BOOST_PP_REPEAT_2_132(m, d) BOOST_PP_REPEAT_2_131(m, d) m(3, 131, d) # define BOOST_PP_REPEAT_2_133(m, d) BOOST_PP_REPEAT_2_132(m, d) m(3, 132, d) # define BOOST_PP_REPEAT_2_134(m, d) BOOST_PP_REPEAT_2_133(m, d) m(3, 133, d) # define BOOST_PP_REPEAT_2_135(m, d) BOOST_PP_REPEAT_2_134(m, d) m(3, 134, d) # define BOOST_PP_REPEAT_2_136(m, d) BOOST_PP_REPEAT_2_135(m, d) m(3, 135, d) # define BOOST_PP_REPEAT_2_137(m, d) BOOST_PP_REPEAT_2_136(m, d) m(3, 136, d) # define BOOST_PP_REPEAT_2_138(m, d) BOOST_PP_REPEAT_2_137(m, d) m(3, 137, d) # define BOOST_PP_REPEAT_2_139(m, d) BOOST_PP_REPEAT_2_138(m, d) m(3, 138, d) # define BOOST_PP_REPEAT_2_140(m, d) BOOST_PP_REPEAT_2_139(m, d) m(3, 139, d) # define BOOST_PP_REPEAT_2_141(m, d) BOOST_PP_REPEAT_2_140(m, d) m(3, 140, d) # define BOOST_PP_REPEAT_2_142(m, d) BOOST_PP_REPEAT_2_141(m, d) m(3, 141, d) # define BOOST_PP_REPEAT_2_143(m, d) BOOST_PP_REPEAT_2_142(m, d) m(3, 142, d) # define BOOST_PP_REPEAT_2_144(m, d) BOOST_PP_REPEAT_2_143(m, d) m(3, 143, d) # define BOOST_PP_REPEAT_2_145(m, d) BOOST_PP_REPEAT_2_144(m, d) m(3, 144, d) # define BOOST_PP_REPEAT_2_146(m, d) BOOST_PP_REPEAT_2_145(m, d) m(3, 145, d) # define BOOST_PP_REPEAT_2_147(m, d) BOOST_PP_REPEAT_2_146(m, d) m(3, 146, d) # define BOOST_PP_REPEAT_2_148(m, d) BOOST_PP_REPEAT_2_147(m, d) m(3, 147, d) # define BOOST_PP_REPEAT_2_149(m, d) BOOST_PP_REPEAT_2_148(m, d) m(3, 148, d) # define BOOST_PP_REPEAT_2_150(m, d) BOOST_PP_REPEAT_2_149(m, d) m(3, 149, d) # define BOOST_PP_REPEAT_2_151(m, d) BOOST_PP_REPEAT_2_150(m, d) m(3, 150, d) # define BOOST_PP_REPEAT_2_152(m, d) BOOST_PP_REPEAT_2_151(m, d) m(3, 151, d) # define BOOST_PP_REPEAT_2_153(m, d) BOOST_PP_REPEAT_2_152(m, d) m(3, 152, d) # define BOOST_PP_REPEAT_2_154(m, d) BOOST_PP_REPEAT_2_153(m, d) m(3, 153, d) # define BOOST_PP_REPEAT_2_155(m, d) BOOST_PP_REPEAT_2_154(m, d) m(3, 154, d) # define BOOST_PP_REPEAT_2_156(m, d) BOOST_PP_REPEAT_2_155(m, d) m(3, 155, d) # define BOOST_PP_REPEAT_2_157(m, d) BOOST_PP_REPEAT_2_156(m, d) m(3, 156, d) # define BOOST_PP_REPEAT_2_158(m, d) BOOST_PP_REPEAT_2_157(m, d) m(3, 157, d) # define BOOST_PP_REPEAT_2_159(m, d) BOOST_PP_REPEAT_2_158(m, d) m(3, 158, d) # define BOOST_PP_REPEAT_2_160(m, d) BOOST_PP_REPEAT_2_159(m, d) m(3, 159, d) # define BOOST_PP_REPEAT_2_161(m, d) BOOST_PP_REPEAT_2_160(m, d) m(3, 160, d) # define BOOST_PP_REPEAT_2_162(m, d) BOOST_PP_REPEAT_2_161(m, d) m(3, 161, d) # define BOOST_PP_REPEAT_2_163(m, d) BOOST_PP_REPEAT_2_162(m, d) m(3, 162, d) # define BOOST_PP_REPEAT_2_164(m, d) BOOST_PP_REPEAT_2_163(m, d) m(3, 163, d) # define BOOST_PP_REPEAT_2_165(m, d) BOOST_PP_REPEAT_2_164(m, d) m(3, 164, d) # define BOOST_PP_REPEAT_2_166(m, d) BOOST_PP_REPEAT_2_165(m, d) m(3, 165, d) # define BOOST_PP_REPEAT_2_167(m, d) BOOST_PP_REPEAT_2_166(m, d) m(3, 166, d) # define BOOST_PP_REPEAT_2_168(m, d) BOOST_PP_REPEAT_2_167(m, d) m(3, 167, d) # define BOOST_PP_REPEAT_2_169(m, d) BOOST_PP_REPEAT_2_168(m, d) m(3, 168, d) # define BOOST_PP_REPEAT_2_170(m, d) BOOST_PP_REPEAT_2_169(m, d) m(3, 169, d) # define BOOST_PP_REPEAT_2_171(m, d) BOOST_PP_REPEAT_2_170(m, d) m(3, 170, d) # define BOOST_PP_REPEAT_2_172(m, d) BOOST_PP_REPEAT_2_171(m, d) m(3, 171, d) # define BOOST_PP_REPEAT_2_173(m, d) BOOST_PP_REPEAT_2_172(m, d) m(3, 172, d) # define BOOST_PP_REPEAT_2_174(m, d) BOOST_PP_REPEAT_2_173(m, d) m(3, 173, d) # define BOOST_PP_REPEAT_2_175(m, d) BOOST_PP_REPEAT_2_174(m, d) m(3, 174, d) # define BOOST_PP_REPEAT_2_176(m, d) BOOST_PP_REPEAT_2_175(m, d) m(3, 175, d) # define BOOST_PP_REPEAT_2_177(m, d) BOOST_PP_REPEAT_2_176(m, d) m(3, 176, d) # define BOOST_PP_REPEAT_2_178(m, d) BOOST_PP_REPEAT_2_177(m, d) m(3, 177, d) # define BOOST_PP_REPEAT_2_179(m, d) BOOST_PP_REPEAT_2_178(m, d) m(3, 178, d) # define BOOST_PP_REPEAT_2_180(m, d) BOOST_PP_REPEAT_2_179(m, d) m(3, 179, d) # define BOOST_PP_REPEAT_2_181(m, d) BOOST_PP_REPEAT_2_180(m, d) m(3, 180, d) # define BOOST_PP_REPEAT_2_182(m, d) BOOST_PP_REPEAT_2_181(m, d) m(3, 181, d) # define BOOST_PP_REPEAT_2_183(m, d) BOOST_PP_REPEAT_2_182(m, d) m(3, 182, d) # define BOOST_PP_REPEAT_2_184(m, d) BOOST_PP_REPEAT_2_183(m, d) m(3, 183, d) # define BOOST_PP_REPEAT_2_185(m, d) BOOST_PP_REPEAT_2_184(m, d) m(3, 184, d) # define BOOST_PP_REPEAT_2_186(m, d) BOOST_PP_REPEAT_2_185(m, d) m(3, 185, d) # define BOOST_PP_REPEAT_2_187(m, d) BOOST_PP_REPEAT_2_186(m, d) m(3, 186, d) # define BOOST_PP_REPEAT_2_188(m, d) BOOST_PP_REPEAT_2_187(m, d) m(3, 187, d) # define BOOST_PP_REPEAT_2_189(m, d) BOOST_PP_REPEAT_2_188(m, d) m(3, 188, d) # define BOOST_PP_REPEAT_2_190(m, d) BOOST_PP_REPEAT_2_189(m, d) m(3, 189, d) # define BOOST_PP_REPEAT_2_191(m, d) BOOST_PP_REPEAT_2_190(m, d) m(3, 190, d) # define BOOST_PP_REPEAT_2_192(m, d) BOOST_PP_REPEAT_2_191(m, d) m(3, 191, d) # define BOOST_PP_REPEAT_2_193(m, d) BOOST_PP_REPEAT_2_192(m, d) m(3, 192, d) # define BOOST_PP_REPEAT_2_194(m, d) BOOST_PP_REPEAT_2_193(m, d) m(3, 193, d) # define BOOST_PP_REPEAT_2_195(m, d) BOOST_PP_REPEAT_2_194(m, d) m(3, 194, d) # define BOOST_PP_REPEAT_2_196(m, d) BOOST_PP_REPEAT_2_195(m, d) m(3, 195, d) # define BOOST_PP_REPEAT_2_197(m, d) BOOST_PP_REPEAT_2_196(m, d) m(3, 196, d) # define BOOST_PP_REPEAT_2_198(m, d) BOOST_PP_REPEAT_2_197(m, d) m(3, 197, d) # define BOOST_PP_REPEAT_2_199(m, d) BOOST_PP_REPEAT_2_198(m, d) m(3, 198, d) # define BOOST_PP_REPEAT_2_200(m, d) BOOST_PP_REPEAT_2_199(m, d) m(3, 199, d) # define BOOST_PP_REPEAT_2_201(m, d) BOOST_PP_REPEAT_2_200(m, d) m(3, 200, d) # define BOOST_PP_REPEAT_2_202(m, d) BOOST_PP_REPEAT_2_201(m, d) m(3, 201, d) # define BOOST_PP_REPEAT_2_203(m, d) BOOST_PP_REPEAT_2_202(m, d) m(3, 202, d) # define BOOST_PP_REPEAT_2_204(m, d) BOOST_PP_REPEAT_2_203(m, d) m(3, 203, d) # define BOOST_PP_REPEAT_2_205(m, d) BOOST_PP_REPEAT_2_204(m, d) m(3, 204, d) # define BOOST_PP_REPEAT_2_206(m, d) BOOST_PP_REPEAT_2_205(m, d) m(3, 205, d) # define BOOST_PP_REPEAT_2_207(m, d) BOOST_PP_REPEAT_2_206(m, d) m(3, 206, d) # define BOOST_PP_REPEAT_2_208(m, d) BOOST_PP_REPEAT_2_207(m, d) m(3, 207, d) # define BOOST_PP_REPEAT_2_209(m, d) BOOST_PP_REPEAT_2_208(m, d) m(3, 208, d) # define BOOST_PP_REPEAT_2_210(m, d) BOOST_PP_REPEAT_2_209(m, d) m(3, 209, d) # define BOOST_PP_REPEAT_2_211(m, d) BOOST_PP_REPEAT_2_210(m, d) m(3, 210, d) # define BOOST_PP_REPEAT_2_212(m, d) BOOST_PP_REPEAT_2_211(m, d) m(3, 211, d) # define BOOST_PP_REPEAT_2_213(m, d) BOOST_PP_REPEAT_2_212(m, d) m(3, 212, d) # define BOOST_PP_REPEAT_2_214(m, d) BOOST_PP_REPEAT_2_213(m, d) m(3, 213, d) # define BOOST_PP_REPEAT_2_215(m, d) BOOST_PP_REPEAT_2_214(m, d) m(3, 214, d) # define BOOST_PP_REPEAT_2_216(m, d) BOOST_PP_REPEAT_2_215(m, d) m(3, 215, d) # define BOOST_PP_REPEAT_2_217(m, d) BOOST_PP_REPEAT_2_216(m, d) m(3, 216, d) # define BOOST_PP_REPEAT_2_218(m, d) BOOST_PP_REPEAT_2_217(m, d) m(3, 217, d) # define BOOST_PP_REPEAT_2_219(m, d) BOOST_PP_REPEAT_2_218(m, d) m(3, 218, d) # define BOOST_PP_REPEAT_2_220(m, d) BOOST_PP_REPEAT_2_219(m, d) m(3, 219, d) # define BOOST_PP_REPEAT_2_221(m, d) BOOST_PP_REPEAT_2_220(m, d) m(3, 220, d) # define BOOST_PP_REPEAT_2_222(m, d) BOOST_PP_REPEAT_2_221(m, d) m(3, 221, d) # define BOOST_PP_REPEAT_2_223(m, d) BOOST_PP_REPEAT_2_222(m, d) m(3, 222, d) # define BOOST_PP_REPEAT_2_224(m, d) BOOST_PP_REPEAT_2_223(m, d) m(3, 223, d) # define BOOST_PP_REPEAT_2_225(m, d) BOOST_PP_REPEAT_2_224(m, d) m(3, 224, d) # define BOOST_PP_REPEAT_2_226(m, d) BOOST_PP_REPEAT_2_225(m, d) m(3, 225, d) # define BOOST_PP_REPEAT_2_227(m, d) BOOST_PP_REPEAT_2_226(m, d) m(3, 226, d) # define BOOST_PP_REPEAT_2_228(m, d) BOOST_PP_REPEAT_2_227(m, d) m(3, 227, d) # define BOOST_PP_REPEAT_2_229(m, d) BOOST_PP_REPEAT_2_228(m, d) m(3, 228, d) # define BOOST_PP_REPEAT_2_230(m, d) BOOST_PP_REPEAT_2_229(m, d) m(3, 229, d) # define BOOST_PP_REPEAT_2_231(m, d) BOOST_PP_REPEAT_2_230(m, d) m(3, 230, d) # define BOOST_PP_REPEAT_2_232(m, d) BOOST_PP_REPEAT_2_231(m, d) m(3, 231, d) # define BOOST_PP_REPEAT_2_233(m, d) BOOST_PP_REPEAT_2_232(m, d) m(3, 232, d) # define BOOST_PP_REPEAT_2_234(m, d) BOOST_PP_REPEAT_2_233(m, d) m(3, 233, d) # define BOOST_PP_REPEAT_2_235(m, d) BOOST_PP_REPEAT_2_234(m, d) m(3, 234, d) # define BOOST_PP_REPEAT_2_236(m, d) BOOST_PP_REPEAT_2_235(m, d) m(3, 235, d) # define BOOST_PP_REPEAT_2_237(m, d) BOOST_PP_REPEAT_2_236(m, d) m(3, 236, d) # define BOOST_PP_REPEAT_2_238(m, d) BOOST_PP_REPEAT_2_237(m, d) m(3, 237, d) # define BOOST_PP_REPEAT_2_239(m, d) BOOST_PP_REPEAT_2_238(m, d) m(3, 238, d) # define BOOST_PP_REPEAT_2_240(m, d) BOOST_PP_REPEAT_2_239(m, d) m(3, 239, d) # define BOOST_PP_REPEAT_2_241(m, d) BOOST_PP_REPEAT_2_240(m, d) m(3, 240, d) # define BOOST_PP_REPEAT_2_242(m, d) BOOST_PP_REPEAT_2_241(m, d) m(3, 241, d) # define BOOST_PP_REPEAT_2_243(m, d) BOOST_PP_REPEAT_2_242(m, d) m(3, 242, d) # define BOOST_PP_REPEAT_2_244(m, d) BOOST_PP_REPEAT_2_243(m, d) m(3, 243, d) # define BOOST_PP_REPEAT_2_245(m, d) BOOST_PP_REPEAT_2_244(m, d) m(3, 244, d) # define BOOST_PP_REPEAT_2_246(m, d) BOOST_PP_REPEAT_2_245(m, d) m(3, 245, d) # define BOOST_PP_REPEAT_2_247(m, d) BOOST_PP_REPEAT_2_246(m, d) m(3, 246, d) # define BOOST_PP_REPEAT_2_248(m, d) BOOST_PP_REPEAT_2_247(m, d) m(3, 247, d) # define BOOST_PP_REPEAT_2_249(m, d) BOOST_PP_REPEAT_2_248(m, d) m(3, 248, d) # define BOOST_PP_REPEAT_2_250(m, d) BOOST_PP_REPEAT_2_249(m, d) m(3, 249, d) # define BOOST_PP_REPEAT_2_251(m, d) BOOST_PP_REPEAT_2_250(m, d) m(3, 250, d) # define BOOST_PP_REPEAT_2_252(m, d) BOOST_PP_REPEAT_2_251(m, d) m(3, 251, d) # define BOOST_PP_REPEAT_2_253(m, d) BOOST_PP_REPEAT_2_252(m, d) m(3, 252, d) # define BOOST_PP_REPEAT_2_254(m, d) BOOST_PP_REPEAT_2_253(m, d) m(3, 253, d) # define BOOST_PP_REPEAT_2_255(m, d) BOOST_PP_REPEAT_2_254(m, d) m(3, 254, d) # define BOOST_PP_REPEAT_2_256(m, d) BOOST_PP_REPEAT_2_255(m, d) m(3, 255, d) # # define BOOST_PP_REPEAT_3_0(m, d) # define BOOST_PP_REPEAT_3_1(m, d) m(4, 0, d) # define BOOST_PP_REPEAT_3_2(m, d) BOOST_PP_REPEAT_3_1(m, d) m(4, 1, d) # define BOOST_PP_REPEAT_3_3(m, d) BOOST_PP_REPEAT_3_2(m, d) m(4, 2, d) # define BOOST_PP_REPEAT_3_4(m, d) BOOST_PP_REPEAT_3_3(m, d) m(4, 3, d) # define BOOST_PP_REPEAT_3_5(m, d) BOOST_PP_REPEAT_3_4(m, d) m(4, 4, d) # define BOOST_PP_REPEAT_3_6(m, d) BOOST_PP_REPEAT_3_5(m, d) m(4, 5, d) # define BOOST_PP_REPEAT_3_7(m, d) BOOST_PP_REPEAT_3_6(m, d) m(4, 6, d) # define BOOST_PP_REPEAT_3_8(m, d) BOOST_PP_REPEAT_3_7(m, d) m(4, 7, d) # define BOOST_PP_REPEAT_3_9(m, d) BOOST_PP_REPEAT_3_8(m, d) m(4, 8, d) # define BOOST_PP_REPEAT_3_10(m, d) BOOST_PP_REPEAT_3_9(m, d) m(4, 9, d) # define BOOST_PP_REPEAT_3_11(m, d) BOOST_PP_REPEAT_3_10(m, d) m(4, 10, d) # define BOOST_PP_REPEAT_3_12(m, d) BOOST_PP_REPEAT_3_11(m, d) m(4, 11, d) # define BOOST_PP_REPEAT_3_13(m, d) BOOST_PP_REPEAT_3_12(m, d) m(4, 12, d) # define BOOST_PP_REPEAT_3_14(m, d) BOOST_PP_REPEAT_3_13(m, d) m(4, 13, d) # define BOOST_PP_REPEAT_3_15(m, d) BOOST_PP_REPEAT_3_14(m, d) m(4, 14, d) # define BOOST_PP_REPEAT_3_16(m, d) BOOST_PP_REPEAT_3_15(m, d) m(4, 15, d) # define BOOST_PP_REPEAT_3_17(m, d) BOOST_PP_REPEAT_3_16(m, d) m(4, 16, d) # define BOOST_PP_REPEAT_3_18(m, d) BOOST_PP_REPEAT_3_17(m, d) m(4, 17, d) # define BOOST_PP_REPEAT_3_19(m, d) BOOST_PP_REPEAT_3_18(m, d) m(4, 18, d) # define BOOST_PP_REPEAT_3_20(m, d) BOOST_PP_REPEAT_3_19(m, d) m(4, 19, d) # define BOOST_PP_REPEAT_3_21(m, d) BOOST_PP_REPEAT_3_20(m, d) m(4, 20, d) # define BOOST_PP_REPEAT_3_22(m, d) BOOST_PP_REPEAT_3_21(m, d) m(4, 21, d) # define BOOST_PP_REPEAT_3_23(m, d) BOOST_PP_REPEAT_3_22(m, d) m(4, 22, d) # define BOOST_PP_REPEAT_3_24(m, d) BOOST_PP_REPEAT_3_23(m, d) m(4, 23, d) # define BOOST_PP_REPEAT_3_25(m, d) BOOST_PP_REPEAT_3_24(m, d) m(4, 24, d) # define BOOST_PP_REPEAT_3_26(m, d) BOOST_PP_REPEAT_3_25(m, d) m(4, 25, d) # define BOOST_PP_REPEAT_3_27(m, d) BOOST_PP_REPEAT_3_26(m, d) m(4, 26, d) # define BOOST_PP_REPEAT_3_28(m, d) BOOST_PP_REPEAT_3_27(m, d) m(4, 27, d) # define BOOST_PP_REPEAT_3_29(m, d) BOOST_PP_REPEAT_3_28(m, d) m(4, 28, d) # define BOOST_PP_REPEAT_3_30(m, d) BOOST_PP_REPEAT_3_29(m, d) m(4, 29, d) # define BOOST_PP_REPEAT_3_31(m, d) BOOST_PP_REPEAT_3_30(m, d) m(4, 30, d) # define BOOST_PP_REPEAT_3_32(m, d) BOOST_PP_REPEAT_3_31(m, d) m(4, 31, d) # define BOOST_PP_REPEAT_3_33(m, d) BOOST_PP_REPEAT_3_32(m, d) m(4, 32, d) # define BOOST_PP_REPEAT_3_34(m, d) BOOST_PP_REPEAT_3_33(m, d) m(4, 33, d) # define BOOST_PP_REPEAT_3_35(m, d) BOOST_PP_REPEAT_3_34(m, d) m(4, 34, d) # define BOOST_PP_REPEAT_3_36(m, d) BOOST_PP_REPEAT_3_35(m, d) m(4, 35, d) # define BOOST_PP_REPEAT_3_37(m, d) BOOST_PP_REPEAT_3_36(m, d) m(4, 36, d) # define BOOST_PP_REPEAT_3_38(m, d) BOOST_PP_REPEAT_3_37(m, d) m(4, 37, d) # define BOOST_PP_REPEAT_3_39(m, d) BOOST_PP_REPEAT_3_38(m, d) m(4, 38, d) # define BOOST_PP_REPEAT_3_40(m, d) BOOST_PP_REPEAT_3_39(m, d) m(4, 39, d) # define BOOST_PP_REPEAT_3_41(m, d) BOOST_PP_REPEAT_3_40(m, d) m(4, 40, d) # define BOOST_PP_REPEAT_3_42(m, d) BOOST_PP_REPEAT_3_41(m, d) m(4, 41, d) # define BOOST_PP_REPEAT_3_43(m, d) BOOST_PP_REPEAT_3_42(m, d) m(4, 42, d) # define BOOST_PP_REPEAT_3_44(m, d) BOOST_PP_REPEAT_3_43(m, d) m(4, 43, d) # define BOOST_PP_REPEAT_3_45(m, d) BOOST_PP_REPEAT_3_44(m, d) m(4, 44, d) # define BOOST_PP_REPEAT_3_46(m, d) BOOST_PP_REPEAT_3_45(m, d) m(4, 45, d) # define BOOST_PP_REPEAT_3_47(m, d) BOOST_PP_REPEAT_3_46(m, d) m(4, 46, d) # define BOOST_PP_REPEAT_3_48(m, d) BOOST_PP_REPEAT_3_47(m, d) m(4, 47, d) # define BOOST_PP_REPEAT_3_49(m, d) BOOST_PP_REPEAT_3_48(m, d) m(4, 48, d) # define BOOST_PP_REPEAT_3_50(m, d) BOOST_PP_REPEAT_3_49(m, d) m(4, 49, d) # define BOOST_PP_REPEAT_3_51(m, d) BOOST_PP_REPEAT_3_50(m, d) m(4, 50, d) # define BOOST_PP_REPEAT_3_52(m, d) BOOST_PP_REPEAT_3_51(m, d) m(4, 51, d) # define BOOST_PP_REPEAT_3_53(m, d) BOOST_PP_REPEAT_3_52(m, d) m(4, 52, d) # define BOOST_PP_REPEAT_3_54(m, d) BOOST_PP_REPEAT_3_53(m, d) m(4, 53, d) # define BOOST_PP_REPEAT_3_55(m, d) BOOST_PP_REPEAT_3_54(m, d) m(4, 54, d) # define BOOST_PP_REPEAT_3_56(m, d) BOOST_PP_REPEAT_3_55(m, d) m(4, 55, d) # define BOOST_PP_REPEAT_3_57(m, d) BOOST_PP_REPEAT_3_56(m, d) m(4, 56, d) # define BOOST_PP_REPEAT_3_58(m, d) BOOST_PP_REPEAT_3_57(m, d) m(4, 57, d) # define BOOST_PP_REPEAT_3_59(m, d) BOOST_PP_REPEAT_3_58(m, d) m(4, 58, d) # define BOOST_PP_REPEAT_3_60(m, d) BOOST_PP_REPEAT_3_59(m, d) m(4, 59, d) # define BOOST_PP_REPEAT_3_61(m, d) BOOST_PP_REPEAT_3_60(m, d) m(4, 60, d) # define BOOST_PP_REPEAT_3_62(m, d) BOOST_PP_REPEAT_3_61(m, d) m(4, 61, d) # define BOOST_PP_REPEAT_3_63(m, d) BOOST_PP_REPEAT_3_62(m, d) m(4, 62, d) # define BOOST_PP_REPEAT_3_64(m, d) BOOST_PP_REPEAT_3_63(m, d) m(4, 63, d) # define BOOST_PP_REPEAT_3_65(m, d) BOOST_PP_REPEAT_3_64(m, d) m(4, 64, d) # define BOOST_PP_REPEAT_3_66(m, d) BOOST_PP_REPEAT_3_65(m, d) m(4, 65, d) # define BOOST_PP_REPEAT_3_67(m, d) BOOST_PP_REPEAT_3_66(m, d) m(4, 66, d) # define BOOST_PP_REPEAT_3_68(m, d) BOOST_PP_REPEAT_3_67(m, d) m(4, 67, d) # define BOOST_PP_REPEAT_3_69(m, d) BOOST_PP_REPEAT_3_68(m, d) m(4, 68, d) # define BOOST_PP_REPEAT_3_70(m, d) BOOST_PP_REPEAT_3_69(m, d) m(4, 69, d) # define BOOST_PP_REPEAT_3_71(m, d) BOOST_PP_REPEAT_3_70(m, d) m(4, 70, d) # define BOOST_PP_REPEAT_3_72(m, d) BOOST_PP_REPEAT_3_71(m, d) m(4, 71, d) # define BOOST_PP_REPEAT_3_73(m, d) BOOST_PP_REPEAT_3_72(m, d) m(4, 72, d) # define BOOST_PP_REPEAT_3_74(m, d) BOOST_PP_REPEAT_3_73(m, d) m(4, 73, d) # define BOOST_PP_REPEAT_3_75(m, d) BOOST_PP_REPEAT_3_74(m, d) m(4, 74, d) # define BOOST_PP_REPEAT_3_76(m, d) BOOST_PP_REPEAT_3_75(m, d) m(4, 75, d) # define BOOST_PP_REPEAT_3_77(m, d) BOOST_PP_REPEAT_3_76(m, d) m(4, 76, d) # define BOOST_PP_REPEAT_3_78(m, d) BOOST_PP_REPEAT_3_77(m, d) m(4, 77, d) # define BOOST_PP_REPEAT_3_79(m, d) BOOST_PP_REPEAT_3_78(m, d) m(4, 78, d) # define BOOST_PP_REPEAT_3_80(m, d) BOOST_PP_REPEAT_3_79(m, d) m(4, 79, d) # define BOOST_PP_REPEAT_3_81(m, d) BOOST_PP_REPEAT_3_80(m, d) m(4, 80, d) # define BOOST_PP_REPEAT_3_82(m, d) BOOST_PP_REPEAT_3_81(m, d) m(4, 81, d) # define BOOST_PP_REPEAT_3_83(m, d) BOOST_PP_REPEAT_3_82(m, d) m(4, 82, d) # define BOOST_PP_REPEAT_3_84(m, d) BOOST_PP_REPEAT_3_83(m, d) m(4, 83, d) # define BOOST_PP_REPEAT_3_85(m, d) BOOST_PP_REPEAT_3_84(m, d) m(4, 84, d) # define BOOST_PP_REPEAT_3_86(m, d) BOOST_PP_REPEAT_3_85(m, d) m(4, 85, d) # define BOOST_PP_REPEAT_3_87(m, d) BOOST_PP_REPEAT_3_86(m, d) m(4, 86, d) # define BOOST_PP_REPEAT_3_88(m, d) BOOST_PP_REPEAT_3_87(m, d) m(4, 87, d) # define BOOST_PP_REPEAT_3_89(m, d) BOOST_PP_REPEAT_3_88(m, d) m(4, 88, d) # define BOOST_PP_REPEAT_3_90(m, d) BOOST_PP_REPEAT_3_89(m, d) m(4, 89, d) # define BOOST_PP_REPEAT_3_91(m, d) BOOST_PP_REPEAT_3_90(m, d) m(4, 90, d) # define BOOST_PP_REPEAT_3_92(m, d) BOOST_PP_REPEAT_3_91(m, d) m(4, 91, d) # define BOOST_PP_REPEAT_3_93(m, d) BOOST_PP_REPEAT_3_92(m, d) m(4, 92, d) # define BOOST_PP_REPEAT_3_94(m, d) BOOST_PP_REPEAT_3_93(m, d) m(4, 93, d) # define BOOST_PP_REPEAT_3_95(m, d) BOOST_PP_REPEAT_3_94(m, d) m(4, 94, d) # define BOOST_PP_REPEAT_3_96(m, d) BOOST_PP_REPEAT_3_95(m, d) m(4, 95, d) # define BOOST_PP_REPEAT_3_97(m, d) BOOST_PP_REPEAT_3_96(m, d) m(4, 96, d) # define BOOST_PP_REPEAT_3_98(m, d) BOOST_PP_REPEAT_3_97(m, d) m(4, 97, d) # define BOOST_PP_REPEAT_3_99(m, d) BOOST_PP_REPEAT_3_98(m, d) m(4, 98, d) # define BOOST_PP_REPEAT_3_100(m, d) BOOST_PP_REPEAT_3_99(m, d) m(4, 99, d) # define BOOST_PP_REPEAT_3_101(m, d) BOOST_PP_REPEAT_3_100(m, d) m(4, 100, d) # define BOOST_PP_REPEAT_3_102(m, d) BOOST_PP_REPEAT_3_101(m, d) m(4, 101, d) # define BOOST_PP_REPEAT_3_103(m, d) BOOST_PP_REPEAT_3_102(m, d) m(4, 102, d) # define BOOST_PP_REPEAT_3_104(m, d) BOOST_PP_REPEAT_3_103(m, d) m(4, 103, d) # define BOOST_PP_REPEAT_3_105(m, d) BOOST_PP_REPEAT_3_104(m, d) m(4, 104, d) # define BOOST_PP_REPEAT_3_106(m, d) BOOST_PP_REPEAT_3_105(m, d) m(4, 105, d) # define BOOST_PP_REPEAT_3_107(m, d) BOOST_PP_REPEAT_3_106(m, d) m(4, 106, d) # define BOOST_PP_REPEAT_3_108(m, d) BOOST_PP_REPEAT_3_107(m, d) m(4, 107, d) # define BOOST_PP_REPEAT_3_109(m, d) BOOST_PP_REPEAT_3_108(m, d) m(4, 108, d) # define BOOST_PP_REPEAT_3_110(m, d) BOOST_PP_REPEAT_3_109(m, d) m(4, 109, d) # define BOOST_PP_REPEAT_3_111(m, d) BOOST_PP_REPEAT_3_110(m, d) m(4, 110, d) # define BOOST_PP_REPEAT_3_112(m, d) BOOST_PP_REPEAT_3_111(m, d) m(4, 111, d) # define BOOST_PP_REPEAT_3_113(m, d) BOOST_PP_REPEAT_3_112(m, d) m(4, 112, d) # define BOOST_PP_REPEAT_3_114(m, d) BOOST_PP_REPEAT_3_113(m, d) m(4, 113, d) # define BOOST_PP_REPEAT_3_115(m, d) BOOST_PP_REPEAT_3_114(m, d) m(4, 114, d) # define BOOST_PP_REPEAT_3_116(m, d) BOOST_PP_REPEAT_3_115(m, d) m(4, 115, d) # define BOOST_PP_REPEAT_3_117(m, d) BOOST_PP_REPEAT_3_116(m, d) m(4, 116, d) # define BOOST_PP_REPEAT_3_118(m, d) BOOST_PP_REPEAT_3_117(m, d) m(4, 117, d) # define BOOST_PP_REPEAT_3_119(m, d) BOOST_PP_REPEAT_3_118(m, d) m(4, 118, d) # define BOOST_PP_REPEAT_3_120(m, d) BOOST_PP_REPEAT_3_119(m, d) m(4, 119, d) # define BOOST_PP_REPEAT_3_121(m, d) BOOST_PP_REPEAT_3_120(m, d) m(4, 120, d) # define BOOST_PP_REPEAT_3_122(m, d) BOOST_PP_REPEAT_3_121(m, d) m(4, 121, d) # define BOOST_PP_REPEAT_3_123(m, d) BOOST_PP_REPEAT_3_122(m, d) m(4, 122, d) # define BOOST_PP_REPEAT_3_124(m, d) BOOST_PP_REPEAT_3_123(m, d) m(4, 123, d) # define BOOST_PP_REPEAT_3_125(m, d) BOOST_PP_REPEAT_3_124(m, d) m(4, 124, d) # define BOOST_PP_REPEAT_3_126(m, d) BOOST_PP_REPEAT_3_125(m, d) m(4, 125, d) # define BOOST_PP_REPEAT_3_127(m, d) BOOST_PP_REPEAT_3_126(m, d) m(4, 126, d) # define BOOST_PP_REPEAT_3_128(m, d) BOOST_PP_REPEAT_3_127(m, d) m(4, 127, d) # define BOOST_PP_REPEAT_3_129(m, d) BOOST_PP_REPEAT_3_128(m, d) m(4, 128, d) # define BOOST_PP_REPEAT_3_130(m, d) BOOST_PP_REPEAT_3_129(m, d) m(4, 129, d) # define BOOST_PP_REPEAT_3_131(m, d) BOOST_PP_REPEAT_3_130(m, d) m(4, 130, d) # define BOOST_PP_REPEAT_3_132(m, d) BOOST_PP_REPEAT_3_131(m, d) m(4, 131, d) # define BOOST_PP_REPEAT_3_133(m, d) BOOST_PP_REPEAT_3_132(m, d) m(4, 132, d) # define BOOST_PP_REPEAT_3_134(m, d) BOOST_PP_REPEAT_3_133(m, d) m(4, 133, d) # define BOOST_PP_REPEAT_3_135(m, d) BOOST_PP_REPEAT_3_134(m, d) m(4, 134, d) # define BOOST_PP_REPEAT_3_136(m, d) BOOST_PP_REPEAT_3_135(m, d) m(4, 135, d) # define BOOST_PP_REPEAT_3_137(m, d) BOOST_PP_REPEAT_3_136(m, d) m(4, 136, d) # define BOOST_PP_REPEAT_3_138(m, d) BOOST_PP_REPEAT_3_137(m, d) m(4, 137, d) # define BOOST_PP_REPEAT_3_139(m, d) BOOST_PP_REPEAT_3_138(m, d) m(4, 138, d) # define BOOST_PP_REPEAT_3_140(m, d) BOOST_PP_REPEAT_3_139(m, d) m(4, 139, d) # define BOOST_PP_REPEAT_3_141(m, d) BOOST_PP_REPEAT_3_140(m, d) m(4, 140, d) # define BOOST_PP_REPEAT_3_142(m, d) BOOST_PP_REPEAT_3_141(m, d) m(4, 141, d) # define BOOST_PP_REPEAT_3_143(m, d) BOOST_PP_REPEAT_3_142(m, d) m(4, 142, d) # define BOOST_PP_REPEAT_3_144(m, d) BOOST_PP_REPEAT_3_143(m, d) m(4, 143, d) # define BOOST_PP_REPEAT_3_145(m, d) BOOST_PP_REPEAT_3_144(m, d) m(4, 144, d) # define BOOST_PP_REPEAT_3_146(m, d) BOOST_PP_REPEAT_3_145(m, d) m(4, 145, d) # define BOOST_PP_REPEAT_3_147(m, d) BOOST_PP_REPEAT_3_146(m, d) m(4, 146, d) # define BOOST_PP_REPEAT_3_148(m, d) BOOST_PP_REPEAT_3_147(m, d) m(4, 147, d) # define BOOST_PP_REPEAT_3_149(m, d) BOOST_PP_REPEAT_3_148(m, d) m(4, 148, d) # define BOOST_PP_REPEAT_3_150(m, d) BOOST_PP_REPEAT_3_149(m, d) m(4, 149, d) # define BOOST_PP_REPEAT_3_151(m, d) BOOST_PP_REPEAT_3_150(m, d) m(4, 150, d) # define BOOST_PP_REPEAT_3_152(m, d) BOOST_PP_REPEAT_3_151(m, d) m(4, 151, d) # define BOOST_PP_REPEAT_3_153(m, d) BOOST_PP_REPEAT_3_152(m, d) m(4, 152, d) # define BOOST_PP_REPEAT_3_154(m, d) BOOST_PP_REPEAT_3_153(m, d) m(4, 153, d) # define BOOST_PP_REPEAT_3_155(m, d) BOOST_PP_REPEAT_3_154(m, d) m(4, 154, d) # define BOOST_PP_REPEAT_3_156(m, d) BOOST_PP_REPEAT_3_155(m, d) m(4, 155, d) # define BOOST_PP_REPEAT_3_157(m, d) BOOST_PP_REPEAT_3_156(m, d) m(4, 156, d) # define BOOST_PP_REPEAT_3_158(m, d) BOOST_PP_REPEAT_3_157(m, d) m(4, 157, d) # define BOOST_PP_REPEAT_3_159(m, d) BOOST_PP_REPEAT_3_158(m, d) m(4, 158, d) # define BOOST_PP_REPEAT_3_160(m, d) BOOST_PP_REPEAT_3_159(m, d) m(4, 159, d) # define BOOST_PP_REPEAT_3_161(m, d) BOOST_PP_REPEAT_3_160(m, d) m(4, 160, d) # define BOOST_PP_REPEAT_3_162(m, d) BOOST_PP_REPEAT_3_161(m, d) m(4, 161, d) # define BOOST_PP_REPEAT_3_163(m, d) BOOST_PP_REPEAT_3_162(m, d) m(4, 162, d) # define BOOST_PP_REPEAT_3_164(m, d) BOOST_PP_REPEAT_3_163(m, d) m(4, 163, d) # define BOOST_PP_REPEAT_3_165(m, d) BOOST_PP_REPEAT_3_164(m, d) m(4, 164, d) # define BOOST_PP_REPEAT_3_166(m, d) BOOST_PP_REPEAT_3_165(m, d) m(4, 165, d) # define BOOST_PP_REPEAT_3_167(m, d) BOOST_PP_REPEAT_3_166(m, d) m(4, 166, d) # define BOOST_PP_REPEAT_3_168(m, d) BOOST_PP_REPEAT_3_167(m, d) m(4, 167, d) # define BOOST_PP_REPEAT_3_169(m, d) BOOST_PP_REPEAT_3_168(m, d) m(4, 168, d) # define BOOST_PP_REPEAT_3_170(m, d) BOOST_PP_REPEAT_3_169(m, d) m(4, 169, d) # define BOOST_PP_REPEAT_3_171(m, d) BOOST_PP_REPEAT_3_170(m, d) m(4, 170, d) # define BOOST_PP_REPEAT_3_172(m, d) BOOST_PP_REPEAT_3_171(m, d) m(4, 171, d) # define BOOST_PP_REPEAT_3_173(m, d) BOOST_PP_REPEAT_3_172(m, d) m(4, 172, d) # define BOOST_PP_REPEAT_3_174(m, d) BOOST_PP_REPEAT_3_173(m, d) m(4, 173, d) # define BOOST_PP_REPEAT_3_175(m, d) BOOST_PP_REPEAT_3_174(m, d) m(4, 174, d) # define BOOST_PP_REPEAT_3_176(m, d) BOOST_PP_REPEAT_3_175(m, d) m(4, 175, d) # define BOOST_PP_REPEAT_3_177(m, d) BOOST_PP_REPEAT_3_176(m, d) m(4, 176, d) # define BOOST_PP_REPEAT_3_178(m, d) BOOST_PP_REPEAT_3_177(m, d) m(4, 177, d) # define BOOST_PP_REPEAT_3_179(m, d) BOOST_PP_REPEAT_3_178(m, d) m(4, 178, d) # define BOOST_PP_REPEAT_3_180(m, d) BOOST_PP_REPEAT_3_179(m, d) m(4, 179, d) # define BOOST_PP_REPEAT_3_181(m, d) BOOST_PP_REPEAT_3_180(m, d) m(4, 180, d) # define BOOST_PP_REPEAT_3_182(m, d) BOOST_PP_REPEAT_3_181(m, d) m(4, 181, d) # define BOOST_PP_REPEAT_3_183(m, d) BOOST_PP_REPEAT_3_182(m, d) m(4, 182, d) # define BOOST_PP_REPEAT_3_184(m, d) BOOST_PP_REPEAT_3_183(m, d) m(4, 183, d) # define BOOST_PP_REPEAT_3_185(m, d) BOOST_PP_REPEAT_3_184(m, d) m(4, 184, d) # define BOOST_PP_REPEAT_3_186(m, d) BOOST_PP_REPEAT_3_185(m, d) m(4, 185, d) # define BOOST_PP_REPEAT_3_187(m, d) BOOST_PP_REPEAT_3_186(m, d) m(4, 186, d) # define BOOST_PP_REPEAT_3_188(m, d) BOOST_PP_REPEAT_3_187(m, d) m(4, 187, d) # define BOOST_PP_REPEAT_3_189(m, d) BOOST_PP_REPEAT_3_188(m, d) m(4, 188, d) # define BOOST_PP_REPEAT_3_190(m, d) BOOST_PP_REPEAT_3_189(m, d) m(4, 189, d) # define BOOST_PP_REPEAT_3_191(m, d) BOOST_PP_REPEAT_3_190(m, d) m(4, 190, d) # define BOOST_PP_REPEAT_3_192(m, d) BOOST_PP_REPEAT_3_191(m, d) m(4, 191, d) # define BOOST_PP_REPEAT_3_193(m, d) BOOST_PP_REPEAT_3_192(m, d) m(4, 192, d) # define BOOST_PP_REPEAT_3_194(m, d) BOOST_PP_REPEAT_3_193(m, d) m(4, 193, d) # define BOOST_PP_REPEAT_3_195(m, d) BOOST_PP_REPEAT_3_194(m, d) m(4, 194, d) # define BOOST_PP_REPEAT_3_196(m, d) BOOST_PP_REPEAT_3_195(m, d) m(4, 195, d) # define BOOST_PP_REPEAT_3_197(m, d) BOOST_PP_REPEAT_3_196(m, d) m(4, 196, d) # define BOOST_PP_REPEAT_3_198(m, d) BOOST_PP_REPEAT_3_197(m, d) m(4, 197, d) # define BOOST_PP_REPEAT_3_199(m, d) BOOST_PP_REPEAT_3_198(m, d) m(4, 198, d) # define BOOST_PP_REPEAT_3_200(m, d) BOOST_PP_REPEAT_3_199(m, d) m(4, 199, d) # define BOOST_PP_REPEAT_3_201(m, d) BOOST_PP_REPEAT_3_200(m, d) m(4, 200, d) # define BOOST_PP_REPEAT_3_202(m, d) BOOST_PP_REPEAT_3_201(m, d) m(4, 201, d) # define BOOST_PP_REPEAT_3_203(m, d) BOOST_PP_REPEAT_3_202(m, d) m(4, 202, d) # define BOOST_PP_REPEAT_3_204(m, d) BOOST_PP_REPEAT_3_203(m, d) m(4, 203, d) # define BOOST_PP_REPEAT_3_205(m, d) BOOST_PP_REPEAT_3_204(m, d) m(4, 204, d) # define BOOST_PP_REPEAT_3_206(m, d) BOOST_PP_REPEAT_3_205(m, d) m(4, 205, d) # define BOOST_PP_REPEAT_3_207(m, d) BOOST_PP_REPEAT_3_206(m, d) m(4, 206, d) # define BOOST_PP_REPEAT_3_208(m, d) BOOST_PP_REPEAT_3_207(m, d) m(4, 207, d) # define BOOST_PP_REPEAT_3_209(m, d) BOOST_PP_REPEAT_3_208(m, d) m(4, 208, d) # define BOOST_PP_REPEAT_3_210(m, d) BOOST_PP_REPEAT_3_209(m, d) m(4, 209, d) # define BOOST_PP_REPEAT_3_211(m, d) BOOST_PP_REPEAT_3_210(m, d) m(4, 210, d) # define BOOST_PP_REPEAT_3_212(m, d) BOOST_PP_REPEAT_3_211(m, d) m(4, 211, d) # define BOOST_PP_REPEAT_3_213(m, d) BOOST_PP_REPEAT_3_212(m, d) m(4, 212, d) # define BOOST_PP_REPEAT_3_214(m, d) BOOST_PP_REPEAT_3_213(m, d) m(4, 213, d) # define BOOST_PP_REPEAT_3_215(m, d) BOOST_PP_REPEAT_3_214(m, d) m(4, 214, d) # define BOOST_PP_REPEAT_3_216(m, d) BOOST_PP_REPEAT_3_215(m, d) m(4, 215, d) # define BOOST_PP_REPEAT_3_217(m, d) BOOST_PP_REPEAT_3_216(m, d) m(4, 216, d) # define BOOST_PP_REPEAT_3_218(m, d) BOOST_PP_REPEAT_3_217(m, d) m(4, 217, d) # define BOOST_PP_REPEAT_3_219(m, d) BOOST_PP_REPEAT_3_218(m, d) m(4, 218, d) # define BOOST_PP_REPEAT_3_220(m, d) BOOST_PP_REPEAT_3_219(m, d) m(4, 219, d) # define BOOST_PP_REPEAT_3_221(m, d) BOOST_PP_REPEAT_3_220(m, d) m(4, 220, d) # define BOOST_PP_REPEAT_3_222(m, d) BOOST_PP_REPEAT_3_221(m, d) m(4, 221, d) # define BOOST_PP_REPEAT_3_223(m, d) BOOST_PP_REPEAT_3_222(m, d) m(4, 222, d) # define BOOST_PP_REPEAT_3_224(m, d) BOOST_PP_REPEAT_3_223(m, d) m(4, 223, d) # define BOOST_PP_REPEAT_3_225(m, d) BOOST_PP_REPEAT_3_224(m, d) m(4, 224, d) # define BOOST_PP_REPEAT_3_226(m, d) BOOST_PP_REPEAT_3_225(m, d) m(4, 225, d) # define BOOST_PP_REPEAT_3_227(m, d) BOOST_PP_REPEAT_3_226(m, d) m(4, 226, d) # define BOOST_PP_REPEAT_3_228(m, d) BOOST_PP_REPEAT_3_227(m, d) m(4, 227, d) # define BOOST_PP_REPEAT_3_229(m, d) BOOST_PP_REPEAT_3_228(m, d) m(4, 228, d) # define BOOST_PP_REPEAT_3_230(m, d) BOOST_PP_REPEAT_3_229(m, d) m(4, 229, d) # define BOOST_PP_REPEAT_3_231(m, d) BOOST_PP_REPEAT_3_230(m, d) m(4, 230, d) # define BOOST_PP_REPEAT_3_232(m, d) BOOST_PP_REPEAT_3_231(m, d) m(4, 231, d) # define BOOST_PP_REPEAT_3_233(m, d) BOOST_PP_REPEAT_3_232(m, d) m(4, 232, d) # define BOOST_PP_REPEAT_3_234(m, d) BOOST_PP_REPEAT_3_233(m, d) m(4, 233, d) # define BOOST_PP_REPEAT_3_235(m, d) BOOST_PP_REPEAT_3_234(m, d) m(4, 234, d) # define BOOST_PP_REPEAT_3_236(m, d) BOOST_PP_REPEAT_3_235(m, d) m(4, 235, d) # define BOOST_PP_REPEAT_3_237(m, d) BOOST_PP_REPEAT_3_236(m, d) m(4, 236, d) # define BOOST_PP_REPEAT_3_238(m, d) BOOST_PP_REPEAT_3_237(m, d) m(4, 237, d) # define BOOST_PP_REPEAT_3_239(m, d) BOOST_PP_REPEAT_3_238(m, d) m(4, 238, d) # define BOOST_PP_REPEAT_3_240(m, d) BOOST_PP_REPEAT_3_239(m, d) m(4, 239, d) # define BOOST_PP_REPEAT_3_241(m, d) BOOST_PP_REPEAT_3_240(m, d) m(4, 240, d) # define BOOST_PP_REPEAT_3_242(m, d) BOOST_PP_REPEAT_3_241(m, d) m(4, 241, d) # define BOOST_PP_REPEAT_3_243(m, d) BOOST_PP_REPEAT_3_242(m, d) m(4, 242, d) # define BOOST_PP_REPEAT_3_244(m, d) BOOST_PP_REPEAT_3_243(m, d) m(4, 243, d) # define BOOST_PP_REPEAT_3_245(m, d) BOOST_PP_REPEAT_3_244(m, d) m(4, 244, d) # define BOOST_PP_REPEAT_3_246(m, d) BOOST_PP_REPEAT_3_245(m, d) m(4, 245, d) # define BOOST_PP_REPEAT_3_247(m, d) BOOST_PP_REPEAT_3_246(m, d) m(4, 246, d) # define BOOST_PP_REPEAT_3_248(m, d) BOOST_PP_REPEAT_3_247(m, d) m(4, 247, d) # define BOOST_PP_REPEAT_3_249(m, d) BOOST_PP_REPEAT_3_248(m, d) m(4, 248, d) # define BOOST_PP_REPEAT_3_250(m, d) BOOST_PP_REPEAT_3_249(m, d) m(4, 249, d) # define BOOST_PP_REPEAT_3_251(m, d) BOOST_PP_REPEAT_3_250(m, d) m(4, 250, d) # define BOOST_PP_REPEAT_3_252(m, d) BOOST_PP_REPEAT_3_251(m, d) m(4, 251, d) # define BOOST_PP_REPEAT_3_253(m, d) BOOST_PP_REPEAT_3_252(m, d) m(4, 252, d) # define BOOST_PP_REPEAT_3_254(m, d) BOOST_PP_REPEAT_3_253(m, d) m(4, 253, d) # define BOOST_PP_REPEAT_3_255(m, d) BOOST_PP_REPEAT_3_254(m, d) m(4, 254, d) # define BOOST_PP_REPEAT_3_256(m, d) BOOST_PP_REPEAT_3_255(m, d) m(4, 255, d) # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000574211344301502031750 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_HPP # # include # include # include # include # include # include # include # include # # /* BOOST_PP_ENUM */ # # if 0 # define BOOST_PP_ENUM(count, macro, data) # endif # # define BOOST_PP_ENUM BOOST_PP_CAT(BOOST_PP_ENUM_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_1(c, m, d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_M_1, (m, d)) # define BOOST_PP_ENUM_2(c, m, d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_M_2, (m, d)) # define BOOST_PP_ENUM_3(c, m, d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_M_3, (m, d)) # else # define BOOST_PP_ENUM_1(c, m, d) BOOST_PP_ENUM_1_I(c, m, d) # define BOOST_PP_ENUM_2(c, m, d) BOOST_PP_ENUM_2_I(c, m, d) # define BOOST_PP_ENUM_3(c, m, d) BOOST_PP_ENUM_3_I(c, m, d) # define BOOST_PP_ENUM_1_I(c, m, d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_M_1, (m, d)) # define BOOST_PP_ENUM_2_I(c, m, d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_M_2, (m, d)) # define BOOST_PP_ENUM_3_I(c, m, d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_M_3, (m, d)) # endif # # define BOOST_PP_ENUM_4(c, m, d) BOOST_PP_ERROR(0x0003) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ENUM_M_1(z, n, md) BOOST_PP_ENUM_M_1_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_M_2(z, n, md) BOOST_PP_ENUM_M_2_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_M_3(z, n, md) BOOST_PP_ENUM_M_3_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_M_1_IM(z, n, im) BOOST_PP_ENUM_M_1_I(z, n, im) # define BOOST_PP_ENUM_M_2_IM(z, n, im) BOOST_PP_ENUM_M_2_I(z, n, im) # define BOOST_PP_ENUM_M_3_IM(z, n, im) BOOST_PP_ENUM_M_3_I(z, n, im) # else # define BOOST_PP_ENUM_M_1(z, n, md) BOOST_PP_ENUM_M_1_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # define BOOST_PP_ENUM_M_2(z, n, md) BOOST_PP_ENUM_M_2_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # define BOOST_PP_ENUM_M_3(z, n, md) BOOST_PP_ENUM_M_3_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # endif # # define BOOST_PP_ENUM_M_1_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, n, d) # define BOOST_PP_ENUM_M_2_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, n, d) # define BOOST_PP_ENUM_M_3_I(z, n, m, d) BOOST_PP_COMMA_IF(n) m(z, n, d) # # endif ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_trailing_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000347511344301502031751 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_PARAMS_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_PARAMS_HPP # # include # include # # /* BOOST_PP_ENUM_TRAILING_PARAMS */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_TRAILING_PARAMS(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) # else # define BOOST_PP_ENUM_TRAILING_PARAMS(count, param) BOOST_PP_ENUM_TRAILING_PARAMS_I(count, param) # define BOOST_PP_ENUM_TRAILING_PARAMS_I(count, param) BOOST_PP_REPEAT(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) # endif # # define BOOST_PP_ENUM_TRAILING_PARAMS_M(z, n, param) , param ## n # # /* BOOST_PP_ENUM_TRAILING_PARAMS_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) # else # define BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, count, param) BOOST_PP_ENUM_TRAILING_PARAMS_Z_I(z, count, param) # define BOOST_PP_ENUM_TRAILING_PARAMS_Z_I(z, count, param) BOOST_PP_REPEAT_ ## z(count, BOOST_PP_ENUM_TRAILING_PARAMS_M, param) # endif # # endif ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/enum_trailing.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000700611344301502031743 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_HPP # define BOOST_PREPROCESSOR_REPETITION_ENUM_TRAILING_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_ENUM_TRAILING */ # # if 0 # define BOOST_PP_ENUM_TRAILING(count, macro, data) # endif # # define BOOST_PP_ENUM_TRAILING BOOST_PP_CAT(BOOST_PP_ENUM_TRAILING_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4)) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ENUM_TRAILING_1(c, m, d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_TRAILING_M_1, (m, d)) # define BOOST_PP_ENUM_TRAILING_2(c, m, d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_TRAILING_M_2, (m, d)) # define BOOST_PP_ENUM_TRAILING_3(c, m, d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_TRAILING_M_3, (m, d)) # else # define BOOST_PP_ENUM_TRAILING_1(c, m, d) BOOST_PP_ENUM_TRAILING_1_I(c, m, d) # define BOOST_PP_ENUM_TRAILING_2(c, m, d) BOOST_PP_ENUM_TRAILING_2_I(c, m, d) # define BOOST_PP_ENUM_TRAILING_3(c, m, d) BOOST_PP_ENUM_TRAILING_3_I(c, m, d) # define BOOST_PP_ENUM_TRAILING_1_I(c, m, d) BOOST_PP_REPEAT_1(c, BOOST_PP_ENUM_TRAILING_M_1, (m, d)) # define BOOST_PP_ENUM_TRAILING_2_I(c, m, d) BOOST_PP_REPEAT_2(c, BOOST_PP_ENUM_TRAILING_M_2, (m, d)) # define BOOST_PP_ENUM_TRAILING_3_I(c, m, d) BOOST_PP_REPEAT_3(c, BOOST_PP_ENUM_TRAILING_M_3, (m, d)) # endif # # define BOOST_PP_ENUM_TRAILING_4(c, m, d) BOOST_PP_ERROR(0x0003) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ENUM_TRAILING_M_1(z, n, md) BOOST_PP_ENUM_TRAILING_M_1_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_TRAILING_M_2(z, n, md) BOOST_PP_ENUM_TRAILING_M_2_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_TRAILING_M_3(z, n, md) BOOST_PP_ENUM_TRAILING_M_3_IM(z, n, BOOST_PP_TUPLE_REM_2 md) # define BOOST_PP_ENUM_TRAILING_M_1_IM(z, n, im) BOOST_PP_ENUM_TRAILING_M_1_I(z, n, im) # define BOOST_PP_ENUM_TRAILING_M_2_IM(z, n, im) BOOST_PP_ENUM_TRAILING_M_2_I(z, n, im) # define BOOST_PP_ENUM_TRAILING_M_3_IM(z, n, im) BOOST_PP_ENUM_TRAILING_M_3_I(z, n, im) # else # define BOOST_PP_ENUM_TRAILING_M_1(z, n, md) BOOST_PP_ENUM_TRAILING_M_1_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # define BOOST_PP_ENUM_TRAILING_M_2(z, n, md) BOOST_PP_ENUM_TRAILING_M_2_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # define BOOST_PP_ENUM_TRAILING_M_3(z, n, md) BOOST_PP_ENUM_TRAILING_M_3_I(z, n, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md)) # endif # # define BOOST_PP_ENUM_TRAILING_M_1_I(z, n, m, d) , m(z, n, d) # define BOOST_PP_ENUM_TRAILING_M_2_I(z, n, m, d) , m(z, n, d) # define BOOST_PP_ENUM_TRAILING_M_3_I(z, n, m, d) , m(z, n, d) # # endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/deduce_z.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000163111344301502031741 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_DEDUCE_Z_HPP # define BOOST_PREPROCESSOR_REPETITION_DEDUCE_Z_HPP # # include # include # # /* BOOST_PP_DEDUCE_Z */ # # define BOOST_PP_DEDUCE_Z() BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4) # # endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/deduce_r.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000000162511344301502031744 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_DEDUCE_R_HPP # define BOOST_PREPROCESSOR_REPETITION_DEDUCE_R_HPP # # include # include # # /* BOOST_PP_DEDUCE_R */ # # define BOOST_PP_DEDUCE_R() BOOST_PP_AUTO_REC(BOOST_PP_FOR_P, 256) # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000755000175000017500000000000012146213770031750 5ustar debiandebian././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/for.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000021626311344301502031752 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP # define BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP # # include # include # include # include # # define BOOST_PP_FOR_1(s, p, o, m) BOOST_PP_FOR_1_C(BOOST_PP_BOOL(p(2, s)), s, p, o, m) # define BOOST_PP_FOR_2(s, p, o, m) BOOST_PP_FOR_2_C(BOOST_PP_BOOL(p(3, s)), s, p, o, m) # define BOOST_PP_FOR_3(s, p, o, m) BOOST_PP_FOR_3_C(BOOST_PP_BOOL(p(4, s)), s, p, o, m) # define BOOST_PP_FOR_4(s, p, o, m) BOOST_PP_FOR_4_C(BOOST_PP_BOOL(p(5, s)), s, p, o, m) # define BOOST_PP_FOR_5(s, p, o, m) BOOST_PP_FOR_5_C(BOOST_PP_BOOL(p(6, s)), s, p, o, m) # define BOOST_PP_FOR_6(s, p, o, m) BOOST_PP_FOR_6_C(BOOST_PP_BOOL(p(7, s)), s, p, o, m) # define BOOST_PP_FOR_7(s, p, o, m) BOOST_PP_FOR_7_C(BOOST_PP_BOOL(p(8, s)), s, p, o, m) # define BOOST_PP_FOR_8(s, p, o, m) BOOST_PP_FOR_8_C(BOOST_PP_BOOL(p(9, s)), s, p, o, m) # define BOOST_PP_FOR_9(s, p, o, m) BOOST_PP_FOR_9_C(BOOST_PP_BOOL(p(10, s)), s, p, o, m) # define BOOST_PP_FOR_10(s, p, o, m) BOOST_PP_FOR_10_C(BOOST_PP_BOOL(p(11, s)), s, p, o, m) # define BOOST_PP_FOR_11(s, p, o, m) BOOST_PP_FOR_11_C(BOOST_PP_BOOL(p(12, s)), s, p, o, m) # define BOOST_PP_FOR_12(s, p, o, m) BOOST_PP_FOR_12_C(BOOST_PP_BOOL(p(13, s)), s, p, o, m) # define BOOST_PP_FOR_13(s, p, o, m) BOOST_PP_FOR_13_C(BOOST_PP_BOOL(p(14, s)), s, p, o, m) # define BOOST_PP_FOR_14(s, p, o, m) BOOST_PP_FOR_14_C(BOOST_PP_BOOL(p(15, s)), s, p, o, m) # define BOOST_PP_FOR_15(s, p, o, m) BOOST_PP_FOR_15_C(BOOST_PP_BOOL(p(16, s)), s, p, o, m) # define BOOST_PP_FOR_16(s, p, o, m) BOOST_PP_FOR_16_C(BOOST_PP_BOOL(p(17, s)), s, p, o, m) # define BOOST_PP_FOR_17(s, p, o, m) BOOST_PP_FOR_17_C(BOOST_PP_BOOL(p(18, s)), s, p, o, m) # define BOOST_PP_FOR_18(s, p, o, m) BOOST_PP_FOR_18_C(BOOST_PP_BOOL(p(19, s)), s, p, o, m) # define BOOST_PP_FOR_19(s, p, o, m) BOOST_PP_FOR_19_C(BOOST_PP_BOOL(p(20, s)), s, p, o, m) # define BOOST_PP_FOR_20(s, p, o, m) BOOST_PP_FOR_20_C(BOOST_PP_BOOL(p(21, s)), s, p, o, m) # define BOOST_PP_FOR_21(s, p, o, m) BOOST_PP_FOR_21_C(BOOST_PP_BOOL(p(22, s)), s, p, o, m) # define BOOST_PP_FOR_22(s, p, o, m) BOOST_PP_FOR_22_C(BOOST_PP_BOOL(p(23, s)), s, p, o, m) # define BOOST_PP_FOR_23(s, p, o, m) BOOST_PP_FOR_23_C(BOOST_PP_BOOL(p(24, s)), s, p, o, m) # define BOOST_PP_FOR_24(s, p, o, m) BOOST_PP_FOR_24_C(BOOST_PP_BOOL(p(25, s)), s, p, o, m) # define BOOST_PP_FOR_25(s, p, o, m) BOOST_PP_FOR_25_C(BOOST_PP_BOOL(p(26, s)), s, p, o, m) # define BOOST_PP_FOR_26(s, p, o, m) BOOST_PP_FOR_26_C(BOOST_PP_BOOL(p(27, s)), s, p, o, m) # define BOOST_PP_FOR_27(s, p, o, m) BOOST_PP_FOR_27_C(BOOST_PP_BOOL(p(28, s)), s, p, o, m) # define BOOST_PP_FOR_28(s, p, o, m) BOOST_PP_FOR_28_C(BOOST_PP_BOOL(p(29, s)), s, p, o, m) # define BOOST_PP_FOR_29(s, p, o, m) BOOST_PP_FOR_29_C(BOOST_PP_BOOL(p(30, s)), s, p, o, m) # define BOOST_PP_FOR_30(s, p, o, m) BOOST_PP_FOR_30_C(BOOST_PP_BOOL(p(31, s)), s, p, o, m) # define BOOST_PP_FOR_31(s, p, o, m) BOOST_PP_FOR_31_C(BOOST_PP_BOOL(p(32, s)), s, p, o, m) # define BOOST_PP_FOR_32(s, p, o, m) BOOST_PP_FOR_32_C(BOOST_PP_BOOL(p(33, s)), s, p, o, m) # define BOOST_PP_FOR_33(s, p, o, m) BOOST_PP_FOR_33_C(BOOST_PP_BOOL(p(34, s)), s, p, o, m) # define BOOST_PP_FOR_34(s, p, o, m) BOOST_PP_FOR_34_C(BOOST_PP_BOOL(p(35, s)), s, p, o, m) # define BOOST_PP_FOR_35(s, p, o, m) BOOST_PP_FOR_35_C(BOOST_PP_BOOL(p(36, s)), s, p, o, m) # define BOOST_PP_FOR_36(s, p, o, m) BOOST_PP_FOR_36_C(BOOST_PP_BOOL(p(37, s)), s, p, o, m) # define BOOST_PP_FOR_37(s, p, o, m) BOOST_PP_FOR_37_C(BOOST_PP_BOOL(p(38, s)), s, p, o, m) # define BOOST_PP_FOR_38(s, p, o, m) BOOST_PP_FOR_38_C(BOOST_PP_BOOL(p(39, s)), s, p, o, m) # define BOOST_PP_FOR_39(s, p, o, m) BOOST_PP_FOR_39_C(BOOST_PP_BOOL(p(40, s)), s, p, o, m) # define BOOST_PP_FOR_40(s, p, o, m) BOOST_PP_FOR_40_C(BOOST_PP_BOOL(p(41, s)), s, p, o, m) # define BOOST_PP_FOR_41(s, p, o, m) BOOST_PP_FOR_41_C(BOOST_PP_BOOL(p(42, s)), s, p, o, m) # define BOOST_PP_FOR_42(s, p, o, m) BOOST_PP_FOR_42_C(BOOST_PP_BOOL(p(43, s)), s, p, o, m) # define BOOST_PP_FOR_43(s, p, o, m) BOOST_PP_FOR_43_C(BOOST_PP_BOOL(p(44, s)), s, p, o, m) # define BOOST_PP_FOR_44(s, p, o, m) BOOST_PP_FOR_44_C(BOOST_PP_BOOL(p(45, s)), s, p, o, m) # define BOOST_PP_FOR_45(s, p, o, m) BOOST_PP_FOR_45_C(BOOST_PP_BOOL(p(46, s)), s, p, o, m) # define BOOST_PP_FOR_46(s, p, o, m) BOOST_PP_FOR_46_C(BOOST_PP_BOOL(p(47, s)), s, p, o, m) # define BOOST_PP_FOR_47(s, p, o, m) BOOST_PP_FOR_47_C(BOOST_PP_BOOL(p(48, s)), s, p, o, m) # define BOOST_PP_FOR_48(s, p, o, m) BOOST_PP_FOR_48_C(BOOST_PP_BOOL(p(49, s)), s, p, o, m) # define BOOST_PP_FOR_49(s, p, o, m) BOOST_PP_FOR_49_C(BOOST_PP_BOOL(p(50, s)), s, p, o, m) # define BOOST_PP_FOR_50(s, p, o, m) BOOST_PP_FOR_50_C(BOOST_PP_BOOL(p(51, s)), s, p, o, m) # define BOOST_PP_FOR_51(s, p, o, m) BOOST_PP_FOR_51_C(BOOST_PP_BOOL(p(52, s)), s, p, o, m) # define BOOST_PP_FOR_52(s, p, o, m) BOOST_PP_FOR_52_C(BOOST_PP_BOOL(p(53, s)), s, p, o, m) # define BOOST_PP_FOR_53(s, p, o, m) BOOST_PP_FOR_53_C(BOOST_PP_BOOL(p(54, s)), s, p, o, m) # define BOOST_PP_FOR_54(s, p, o, m) BOOST_PP_FOR_54_C(BOOST_PP_BOOL(p(55, s)), s, p, o, m) # define BOOST_PP_FOR_55(s, p, o, m) BOOST_PP_FOR_55_C(BOOST_PP_BOOL(p(56, s)), s, p, o, m) # define BOOST_PP_FOR_56(s, p, o, m) BOOST_PP_FOR_56_C(BOOST_PP_BOOL(p(57, s)), s, p, o, m) # define BOOST_PP_FOR_57(s, p, o, m) BOOST_PP_FOR_57_C(BOOST_PP_BOOL(p(58, s)), s, p, o, m) # define BOOST_PP_FOR_58(s, p, o, m) BOOST_PP_FOR_58_C(BOOST_PP_BOOL(p(59, s)), s, p, o, m) # define BOOST_PP_FOR_59(s, p, o, m) BOOST_PP_FOR_59_C(BOOST_PP_BOOL(p(60, s)), s, p, o, m) # define BOOST_PP_FOR_60(s, p, o, m) BOOST_PP_FOR_60_C(BOOST_PP_BOOL(p(61, s)), s, p, o, m) # define BOOST_PP_FOR_61(s, p, o, m) BOOST_PP_FOR_61_C(BOOST_PP_BOOL(p(62, s)), s, p, o, m) # define BOOST_PP_FOR_62(s, p, o, m) BOOST_PP_FOR_62_C(BOOST_PP_BOOL(p(63, s)), s, p, o, m) # define BOOST_PP_FOR_63(s, p, o, m) BOOST_PP_FOR_63_C(BOOST_PP_BOOL(p(64, s)), s, p, o, m) # define BOOST_PP_FOR_64(s, p, o, m) BOOST_PP_FOR_64_C(BOOST_PP_BOOL(p(65, s)), s, p, o, m) # define BOOST_PP_FOR_65(s, p, o, m) BOOST_PP_FOR_65_C(BOOST_PP_BOOL(p(66, s)), s, p, o, m) # define BOOST_PP_FOR_66(s, p, o, m) BOOST_PP_FOR_66_C(BOOST_PP_BOOL(p(67, s)), s, p, o, m) # define BOOST_PP_FOR_67(s, p, o, m) BOOST_PP_FOR_67_C(BOOST_PP_BOOL(p(68, s)), s, p, o, m) # define BOOST_PP_FOR_68(s, p, o, m) BOOST_PP_FOR_68_C(BOOST_PP_BOOL(p(69, s)), s, p, o, m) # define BOOST_PP_FOR_69(s, p, o, m) BOOST_PP_FOR_69_C(BOOST_PP_BOOL(p(70, s)), s, p, o, m) # define BOOST_PP_FOR_70(s, p, o, m) BOOST_PP_FOR_70_C(BOOST_PP_BOOL(p(71, s)), s, p, o, m) # define BOOST_PP_FOR_71(s, p, o, m) BOOST_PP_FOR_71_C(BOOST_PP_BOOL(p(72, s)), s, p, o, m) # define BOOST_PP_FOR_72(s, p, o, m) BOOST_PP_FOR_72_C(BOOST_PP_BOOL(p(73, s)), s, p, o, m) # define BOOST_PP_FOR_73(s, p, o, m) BOOST_PP_FOR_73_C(BOOST_PP_BOOL(p(74, s)), s, p, o, m) # define BOOST_PP_FOR_74(s, p, o, m) BOOST_PP_FOR_74_C(BOOST_PP_BOOL(p(75, s)), s, p, o, m) # define BOOST_PP_FOR_75(s, p, o, m) BOOST_PP_FOR_75_C(BOOST_PP_BOOL(p(76, s)), s, p, o, m) # define BOOST_PP_FOR_76(s, p, o, m) BOOST_PP_FOR_76_C(BOOST_PP_BOOL(p(77, s)), s, p, o, m) # define BOOST_PP_FOR_77(s, p, o, m) BOOST_PP_FOR_77_C(BOOST_PP_BOOL(p(78, s)), s, p, o, m) # define BOOST_PP_FOR_78(s, p, o, m) BOOST_PP_FOR_78_C(BOOST_PP_BOOL(p(79, s)), s, p, o, m) # define BOOST_PP_FOR_79(s, p, o, m) BOOST_PP_FOR_79_C(BOOST_PP_BOOL(p(80, s)), s, p, o, m) # define BOOST_PP_FOR_80(s, p, o, m) BOOST_PP_FOR_80_C(BOOST_PP_BOOL(p(81, s)), s, p, o, m) # define BOOST_PP_FOR_81(s, p, o, m) BOOST_PP_FOR_81_C(BOOST_PP_BOOL(p(82, s)), s, p, o, m) # define BOOST_PP_FOR_82(s, p, o, m) BOOST_PP_FOR_82_C(BOOST_PP_BOOL(p(83, s)), s, p, o, m) # define BOOST_PP_FOR_83(s, p, o, m) BOOST_PP_FOR_83_C(BOOST_PP_BOOL(p(84, s)), s, p, o, m) # define BOOST_PP_FOR_84(s, p, o, m) BOOST_PP_FOR_84_C(BOOST_PP_BOOL(p(85, s)), s, p, o, m) # define BOOST_PP_FOR_85(s, p, o, m) BOOST_PP_FOR_85_C(BOOST_PP_BOOL(p(86, s)), s, p, o, m) # define BOOST_PP_FOR_86(s, p, o, m) BOOST_PP_FOR_86_C(BOOST_PP_BOOL(p(87, s)), s, p, o, m) # define BOOST_PP_FOR_87(s, p, o, m) BOOST_PP_FOR_87_C(BOOST_PP_BOOL(p(88, s)), s, p, o, m) # define BOOST_PP_FOR_88(s, p, o, m) BOOST_PP_FOR_88_C(BOOST_PP_BOOL(p(89, s)), s, p, o, m) # define BOOST_PP_FOR_89(s, p, o, m) BOOST_PP_FOR_89_C(BOOST_PP_BOOL(p(90, s)), s, p, o, m) # define BOOST_PP_FOR_90(s, p, o, m) BOOST_PP_FOR_90_C(BOOST_PP_BOOL(p(91, s)), s, p, o, m) # define BOOST_PP_FOR_91(s, p, o, m) BOOST_PP_FOR_91_C(BOOST_PP_BOOL(p(92, s)), s, p, o, m) # define BOOST_PP_FOR_92(s, p, o, m) BOOST_PP_FOR_92_C(BOOST_PP_BOOL(p(93, s)), s, p, o, m) # define BOOST_PP_FOR_93(s, p, o, m) BOOST_PP_FOR_93_C(BOOST_PP_BOOL(p(94, s)), s, p, o, m) # define BOOST_PP_FOR_94(s, p, o, m) BOOST_PP_FOR_94_C(BOOST_PP_BOOL(p(95, s)), s, p, o, m) # define BOOST_PP_FOR_95(s, p, o, m) BOOST_PP_FOR_95_C(BOOST_PP_BOOL(p(96, s)), s, p, o, m) # define BOOST_PP_FOR_96(s, p, o, m) BOOST_PP_FOR_96_C(BOOST_PP_BOOL(p(97, s)), s, p, o, m) # define BOOST_PP_FOR_97(s, p, o, m) BOOST_PP_FOR_97_C(BOOST_PP_BOOL(p(98, s)), s, p, o, m) # define BOOST_PP_FOR_98(s, p, o, m) BOOST_PP_FOR_98_C(BOOST_PP_BOOL(p(99, s)), s, p, o, m) # define BOOST_PP_FOR_99(s, p, o, m) BOOST_PP_FOR_99_C(BOOST_PP_BOOL(p(100, s)), s, p, o, m) # define BOOST_PP_FOR_100(s, p, o, m) BOOST_PP_FOR_100_C(BOOST_PP_BOOL(p(101, s)), s, p, o, m) # define BOOST_PP_FOR_101(s, p, o, m) BOOST_PP_FOR_101_C(BOOST_PP_BOOL(p(102, s)), s, p, o, m) # define BOOST_PP_FOR_102(s, p, o, m) BOOST_PP_FOR_102_C(BOOST_PP_BOOL(p(103, s)), s, p, o, m) # define BOOST_PP_FOR_103(s, p, o, m) BOOST_PP_FOR_103_C(BOOST_PP_BOOL(p(104, s)), s, p, o, m) # define BOOST_PP_FOR_104(s, p, o, m) BOOST_PP_FOR_104_C(BOOST_PP_BOOL(p(105, s)), s, p, o, m) # define BOOST_PP_FOR_105(s, p, o, m) BOOST_PP_FOR_105_C(BOOST_PP_BOOL(p(106, s)), s, p, o, m) # define BOOST_PP_FOR_106(s, p, o, m) BOOST_PP_FOR_106_C(BOOST_PP_BOOL(p(107, s)), s, p, o, m) # define BOOST_PP_FOR_107(s, p, o, m) BOOST_PP_FOR_107_C(BOOST_PP_BOOL(p(108, s)), s, p, o, m) # define BOOST_PP_FOR_108(s, p, o, m) BOOST_PP_FOR_108_C(BOOST_PP_BOOL(p(109, s)), s, p, o, m) # define BOOST_PP_FOR_109(s, p, o, m) BOOST_PP_FOR_109_C(BOOST_PP_BOOL(p(110, s)), s, p, o, m) # define BOOST_PP_FOR_110(s, p, o, m) BOOST_PP_FOR_110_C(BOOST_PP_BOOL(p(111, s)), s, p, o, m) # define BOOST_PP_FOR_111(s, p, o, m) BOOST_PP_FOR_111_C(BOOST_PP_BOOL(p(112, s)), s, p, o, m) # define BOOST_PP_FOR_112(s, p, o, m) BOOST_PP_FOR_112_C(BOOST_PP_BOOL(p(113, s)), s, p, o, m) # define BOOST_PP_FOR_113(s, p, o, m) BOOST_PP_FOR_113_C(BOOST_PP_BOOL(p(114, s)), s, p, o, m) # define BOOST_PP_FOR_114(s, p, o, m) BOOST_PP_FOR_114_C(BOOST_PP_BOOL(p(115, s)), s, p, o, m) # define BOOST_PP_FOR_115(s, p, o, m) BOOST_PP_FOR_115_C(BOOST_PP_BOOL(p(116, s)), s, p, o, m) # define BOOST_PP_FOR_116(s, p, o, m) BOOST_PP_FOR_116_C(BOOST_PP_BOOL(p(117, s)), s, p, o, m) # define BOOST_PP_FOR_117(s, p, o, m) BOOST_PP_FOR_117_C(BOOST_PP_BOOL(p(118, s)), s, p, o, m) # define BOOST_PP_FOR_118(s, p, o, m) BOOST_PP_FOR_118_C(BOOST_PP_BOOL(p(119, s)), s, p, o, m) # define BOOST_PP_FOR_119(s, p, o, m) BOOST_PP_FOR_119_C(BOOST_PP_BOOL(p(120, s)), s, p, o, m) # define BOOST_PP_FOR_120(s, p, o, m) BOOST_PP_FOR_120_C(BOOST_PP_BOOL(p(121, s)), s, p, o, m) # define BOOST_PP_FOR_121(s, p, o, m) BOOST_PP_FOR_121_C(BOOST_PP_BOOL(p(122, s)), s, p, o, m) # define BOOST_PP_FOR_122(s, p, o, m) BOOST_PP_FOR_122_C(BOOST_PP_BOOL(p(123, s)), s, p, o, m) # define BOOST_PP_FOR_123(s, p, o, m) BOOST_PP_FOR_123_C(BOOST_PP_BOOL(p(124, s)), s, p, o, m) # define BOOST_PP_FOR_124(s, p, o, m) BOOST_PP_FOR_124_C(BOOST_PP_BOOL(p(125, s)), s, p, o, m) # define BOOST_PP_FOR_125(s, p, o, m) BOOST_PP_FOR_125_C(BOOST_PP_BOOL(p(126, s)), s, p, o, m) # define BOOST_PP_FOR_126(s, p, o, m) BOOST_PP_FOR_126_C(BOOST_PP_BOOL(p(127, s)), s, p, o, m) # define BOOST_PP_FOR_127(s, p, o, m) BOOST_PP_FOR_127_C(BOOST_PP_BOOL(p(128, s)), s, p, o, m) # define BOOST_PP_FOR_128(s, p, o, m) BOOST_PP_FOR_128_C(BOOST_PP_BOOL(p(129, s)), s, p, o, m) # define BOOST_PP_FOR_129(s, p, o, m) BOOST_PP_FOR_129_C(BOOST_PP_BOOL(p(130, s)), s, p, o, m) # define BOOST_PP_FOR_130(s, p, o, m) BOOST_PP_FOR_130_C(BOOST_PP_BOOL(p(131, s)), s, p, o, m) # define BOOST_PP_FOR_131(s, p, o, m) BOOST_PP_FOR_131_C(BOOST_PP_BOOL(p(132, s)), s, p, o, m) # define BOOST_PP_FOR_132(s, p, o, m) BOOST_PP_FOR_132_C(BOOST_PP_BOOL(p(133, s)), s, p, o, m) # define BOOST_PP_FOR_133(s, p, o, m) BOOST_PP_FOR_133_C(BOOST_PP_BOOL(p(134, s)), s, p, o, m) # define BOOST_PP_FOR_134(s, p, o, m) BOOST_PP_FOR_134_C(BOOST_PP_BOOL(p(135, s)), s, p, o, m) # define BOOST_PP_FOR_135(s, p, o, m) BOOST_PP_FOR_135_C(BOOST_PP_BOOL(p(136, s)), s, p, o, m) # define BOOST_PP_FOR_136(s, p, o, m) BOOST_PP_FOR_136_C(BOOST_PP_BOOL(p(137, s)), s, p, o, m) # define BOOST_PP_FOR_137(s, p, o, m) BOOST_PP_FOR_137_C(BOOST_PP_BOOL(p(138, s)), s, p, o, m) # define BOOST_PP_FOR_138(s, p, o, m) BOOST_PP_FOR_138_C(BOOST_PP_BOOL(p(139, s)), s, p, o, m) # define BOOST_PP_FOR_139(s, p, o, m) BOOST_PP_FOR_139_C(BOOST_PP_BOOL(p(140, s)), s, p, o, m) # define BOOST_PP_FOR_140(s, p, o, m) BOOST_PP_FOR_140_C(BOOST_PP_BOOL(p(141, s)), s, p, o, m) # define BOOST_PP_FOR_141(s, p, o, m) BOOST_PP_FOR_141_C(BOOST_PP_BOOL(p(142, s)), s, p, o, m) # define BOOST_PP_FOR_142(s, p, o, m) BOOST_PP_FOR_142_C(BOOST_PP_BOOL(p(143, s)), s, p, o, m) # define BOOST_PP_FOR_143(s, p, o, m) BOOST_PP_FOR_143_C(BOOST_PP_BOOL(p(144, s)), s, p, o, m) # define BOOST_PP_FOR_144(s, p, o, m) BOOST_PP_FOR_144_C(BOOST_PP_BOOL(p(145, s)), s, p, o, m) # define BOOST_PP_FOR_145(s, p, o, m) BOOST_PP_FOR_145_C(BOOST_PP_BOOL(p(146, s)), s, p, o, m) # define BOOST_PP_FOR_146(s, p, o, m) BOOST_PP_FOR_146_C(BOOST_PP_BOOL(p(147, s)), s, p, o, m) # define BOOST_PP_FOR_147(s, p, o, m) BOOST_PP_FOR_147_C(BOOST_PP_BOOL(p(148, s)), s, p, o, m) # define BOOST_PP_FOR_148(s, p, o, m) BOOST_PP_FOR_148_C(BOOST_PP_BOOL(p(149, s)), s, p, o, m) # define BOOST_PP_FOR_149(s, p, o, m) BOOST_PP_FOR_149_C(BOOST_PP_BOOL(p(150, s)), s, p, o, m) # define BOOST_PP_FOR_150(s, p, o, m) BOOST_PP_FOR_150_C(BOOST_PP_BOOL(p(151, s)), s, p, o, m) # define BOOST_PP_FOR_151(s, p, o, m) BOOST_PP_FOR_151_C(BOOST_PP_BOOL(p(152, s)), s, p, o, m) # define BOOST_PP_FOR_152(s, p, o, m) BOOST_PP_FOR_152_C(BOOST_PP_BOOL(p(153, s)), s, p, o, m) # define BOOST_PP_FOR_153(s, p, o, m) BOOST_PP_FOR_153_C(BOOST_PP_BOOL(p(154, s)), s, p, o, m) # define BOOST_PP_FOR_154(s, p, o, m) BOOST_PP_FOR_154_C(BOOST_PP_BOOL(p(155, s)), s, p, o, m) # define BOOST_PP_FOR_155(s, p, o, m) BOOST_PP_FOR_155_C(BOOST_PP_BOOL(p(156, s)), s, p, o, m) # define BOOST_PP_FOR_156(s, p, o, m) BOOST_PP_FOR_156_C(BOOST_PP_BOOL(p(157, s)), s, p, o, m) # define BOOST_PP_FOR_157(s, p, o, m) BOOST_PP_FOR_157_C(BOOST_PP_BOOL(p(158, s)), s, p, o, m) # define BOOST_PP_FOR_158(s, p, o, m) BOOST_PP_FOR_158_C(BOOST_PP_BOOL(p(159, s)), s, p, o, m) # define BOOST_PP_FOR_159(s, p, o, m) BOOST_PP_FOR_159_C(BOOST_PP_BOOL(p(160, s)), s, p, o, m) # define BOOST_PP_FOR_160(s, p, o, m) BOOST_PP_FOR_160_C(BOOST_PP_BOOL(p(161, s)), s, p, o, m) # define BOOST_PP_FOR_161(s, p, o, m) BOOST_PP_FOR_161_C(BOOST_PP_BOOL(p(162, s)), s, p, o, m) # define BOOST_PP_FOR_162(s, p, o, m) BOOST_PP_FOR_162_C(BOOST_PP_BOOL(p(163, s)), s, p, o, m) # define BOOST_PP_FOR_163(s, p, o, m) BOOST_PP_FOR_163_C(BOOST_PP_BOOL(p(164, s)), s, p, o, m) # define BOOST_PP_FOR_164(s, p, o, m) BOOST_PP_FOR_164_C(BOOST_PP_BOOL(p(165, s)), s, p, o, m) # define BOOST_PP_FOR_165(s, p, o, m) BOOST_PP_FOR_165_C(BOOST_PP_BOOL(p(166, s)), s, p, o, m) # define BOOST_PP_FOR_166(s, p, o, m) BOOST_PP_FOR_166_C(BOOST_PP_BOOL(p(167, s)), s, p, o, m) # define BOOST_PP_FOR_167(s, p, o, m) BOOST_PP_FOR_167_C(BOOST_PP_BOOL(p(168, s)), s, p, o, m) # define BOOST_PP_FOR_168(s, p, o, m) BOOST_PP_FOR_168_C(BOOST_PP_BOOL(p(169, s)), s, p, o, m) # define BOOST_PP_FOR_169(s, p, o, m) BOOST_PP_FOR_169_C(BOOST_PP_BOOL(p(170, s)), s, p, o, m) # define BOOST_PP_FOR_170(s, p, o, m) BOOST_PP_FOR_170_C(BOOST_PP_BOOL(p(171, s)), s, p, o, m) # define BOOST_PP_FOR_171(s, p, o, m) BOOST_PP_FOR_171_C(BOOST_PP_BOOL(p(172, s)), s, p, o, m) # define BOOST_PP_FOR_172(s, p, o, m) BOOST_PP_FOR_172_C(BOOST_PP_BOOL(p(173, s)), s, p, o, m) # define BOOST_PP_FOR_173(s, p, o, m) BOOST_PP_FOR_173_C(BOOST_PP_BOOL(p(174, s)), s, p, o, m) # define BOOST_PP_FOR_174(s, p, o, m) BOOST_PP_FOR_174_C(BOOST_PP_BOOL(p(175, s)), s, p, o, m) # define BOOST_PP_FOR_175(s, p, o, m) BOOST_PP_FOR_175_C(BOOST_PP_BOOL(p(176, s)), s, p, o, m) # define BOOST_PP_FOR_176(s, p, o, m) BOOST_PP_FOR_176_C(BOOST_PP_BOOL(p(177, s)), s, p, o, m) # define BOOST_PP_FOR_177(s, p, o, m) BOOST_PP_FOR_177_C(BOOST_PP_BOOL(p(178, s)), s, p, o, m) # define BOOST_PP_FOR_178(s, p, o, m) BOOST_PP_FOR_178_C(BOOST_PP_BOOL(p(179, s)), s, p, o, m) # define BOOST_PP_FOR_179(s, p, o, m) BOOST_PP_FOR_179_C(BOOST_PP_BOOL(p(180, s)), s, p, o, m) # define BOOST_PP_FOR_180(s, p, o, m) BOOST_PP_FOR_180_C(BOOST_PP_BOOL(p(181, s)), s, p, o, m) # define BOOST_PP_FOR_181(s, p, o, m) BOOST_PP_FOR_181_C(BOOST_PP_BOOL(p(182, s)), s, p, o, m) # define BOOST_PP_FOR_182(s, p, o, m) BOOST_PP_FOR_182_C(BOOST_PP_BOOL(p(183, s)), s, p, o, m) # define BOOST_PP_FOR_183(s, p, o, m) BOOST_PP_FOR_183_C(BOOST_PP_BOOL(p(184, s)), s, p, o, m) # define BOOST_PP_FOR_184(s, p, o, m) BOOST_PP_FOR_184_C(BOOST_PP_BOOL(p(185, s)), s, p, o, m) # define BOOST_PP_FOR_185(s, p, o, m) BOOST_PP_FOR_185_C(BOOST_PP_BOOL(p(186, s)), s, p, o, m) # define BOOST_PP_FOR_186(s, p, o, m) BOOST_PP_FOR_186_C(BOOST_PP_BOOL(p(187, s)), s, p, o, m) # define BOOST_PP_FOR_187(s, p, o, m) BOOST_PP_FOR_187_C(BOOST_PP_BOOL(p(188, s)), s, p, o, m) # define BOOST_PP_FOR_188(s, p, o, m) BOOST_PP_FOR_188_C(BOOST_PP_BOOL(p(189, s)), s, p, o, m) # define BOOST_PP_FOR_189(s, p, o, m) BOOST_PP_FOR_189_C(BOOST_PP_BOOL(p(190, s)), s, p, o, m) # define BOOST_PP_FOR_190(s, p, o, m) BOOST_PP_FOR_190_C(BOOST_PP_BOOL(p(191, s)), s, p, o, m) # define BOOST_PP_FOR_191(s, p, o, m) BOOST_PP_FOR_191_C(BOOST_PP_BOOL(p(192, s)), s, p, o, m) # define BOOST_PP_FOR_192(s, p, o, m) BOOST_PP_FOR_192_C(BOOST_PP_BOOL(p(193, s)), s, p, o, m) # define BOOST_PP_FOR_193(s, p, o, m) BOOST_PP_FOR_193_C(BOOST_PP_BOOL(p(194, s)), s, p, o, m) # define BOOST_PP_FOR_194(s, p, o, m) BOOST_PP_FOR_194_C(BOOST_PP_BOOL(p(195, s)), s, p, o, m) # define BOOST_PP_FOR_195(s, p, o, m) BOOST_PP_FOR_195_C(BOOST_PP_BOOL(p(196, s)), s, p, o, m) # define BOOST_PP_FOR_196(s, p, o, m) BOOST_PP_FOR_196_C(BOOST_PP_BOOL(p(197, s)), s, p, o, m) # define BOOST_PP_FOR_197(s, p, o, m) BOOST_PP_FOR_197_C(BOOST_PP_BOOL(p(198, s)), s, p, o, m) # define BOOST_PP_FOR_198(s, p, o, m) BOOST_PP_FOR_198_C(BOOST_PP_BOOL(p(199, s)), s, p, o, m) # define BOOST_PP_FOR_199(s, p, o, m) BOOST_PP_FOR_199_C(BOOST_PP_BOOL(p(200, s)), s, p, o, m) # define BOOST_PP_FOR_200(s, p, o, m) BOOST_PP_FOR_200_C(BOOST_PP_BOOL(p(201, s)), s, p, o, m) # define BOOST_PP_FOR_201(s, p, o, m) BOOST_PP_FOR_201_C(BOOST_PP_BOOL(p(202, s)), s, p, o, m) # define BOOST_PP_FOR_202(s, p, o, m) BOOST_PP_FOR_202_C(BOOST_PP_BOOL(p(203, s)), s, p, o, m) # define BOOST_PP_FOR_203(s, p, o, m) BOOST_PP_FOR_203_C(BOOST_PP_BOOL(p(204, s)), s, p, o, m) # define BOOST_PP_FOR_204(s, p, o, m) BOOST_PP_FOR_204_C(BOOST_PP_BOOL(p(205, s)), s, p, o, m) # define BOOST_PP_FOR_205(s, p, o, m) BOOST_PP_FOR_205_C(BOOST_PP_BOOL(p(206, s)), s, p, o, m) # define BOOST_PP_FOR_206(s, p, o, m) BOOST_PP_FOR_206_C(BOOST_PP_BOOL(p(207, s)), s, p, o, m) # define BOOST_PP_FOR_207(s, p, o, m) BOOST_PP_FOR_207_C(BOOST_PP_BOOL(p(208, s)), s, p, o, m) # define BOOST_PP_FOR_208(s, p, o, m) BOOST_PP_FOR_208_C(BOOST_PP_BOOL(p(209, s)), s, p, o, m) # define BOOST_PP_FOR_209(s, p, o, m) BOOST_PP_FOR_209_C(BOOST_PP_BOOL(p(210, s)), s, p, o, m) # define BOOST_PP_FOR_210(s, p, o, m) BOOST_PP_FOR_210_C(BOOST_PP_BOOL(p(211, s)), s, p, o, m) # define BOOST_PP_FOR_211(s, p, o, m) BOOST_PP_FOR_211_C(BOOST_PP_BOOL(p(212, s)), s, p, o, m) # define BOOST_PP_FOR_212(s, p, o, m) BOOST_PP_FOR_212_C(BOOST_PP_BOOL(p(213, s)), s, p, o, m) # define BOOST_PP_FOR_213(s, p, o, m) BOOST_PP_FOR_213_C(BOOST_PP_BOOL(p(214, s)), s, p, o, m) # define BOOST_PP_FOR_214(s, p, o, m) BOOST_PP_FOR_214_C(BOOST_PP_BOOL(p(215, s)), s, p, o, m) # define BOOST_PP_FOR_215(s, p, o, m) BOOST_PP_FOR_215_C(BOOST_PP_BOOL(p(216, s)), s, p, o, m) # define BOOST_PP_FOR_216(s, p, o, m) BOOST_PP_FOR_216_C(BOOST_PP_BOOL(p(217, s)), s, p, o, m) # define BOOST_PP_FOR_217(s, p, o, m) BOOST_PP_FOR_217_C(BOOST_PP_BOOL(p(218, s)), s, p, o, m) # define BOOST_PP_FOR_218(s, p, o, m) BOOST_PP_FOR_218_C(BOOST_PP_BOOL(p(219, s)), s, p, o, m) # define BOOST_PP_FOR_219(s, p, o, m) BOOST_PP_FOR_219_C(BOOST_PP_BOOL(p(220, s)), s, p, o, m) # define BOOST_PP_FOR_220(s, p, o, m) BOOST_PP_FOR_220_C(BOOST_PP_BOOL(p(221, s)), s, p, o, m) # define BOOST_PP_FOR_221(s, p, o, m) BOOST_PP_FOR_221_C(BOOST_PP_BOOL(p(222, s)), s, p, o, m) # define BOOST_PP_FOR_222(s, p, o, m) BOOST_PP_FOR_222_C(BOOST_PP_BOOL(p(223, s)), s, p, o, m) # define BOOST_PP_FOR_223(s, p, o, m) BOOST_PP_FOR_223_C(BOOST_PP_BOOL(p(224, s)), s, p, o, m) # define BOOST_PP_FOR_224(s, p, o, m) BOOST_PP_FOR_224_C(BOOST_PP_BOOL(p(225, s)), s, p, o, m) # define BOOST_PP_FOR_225(s, p, o, m) BOOST_PP_FOR_225_C(BOOST_PP_BOOL(p(226, s)), s, p, o, m) # define BOOST_PP_FOR_226(s, p, o, m) BOOST_PP_FOR_226_C(BOOST_PP_BOOL(p(227, s)), s, p, o, m) # define BOOST_PP_FOR_227(s, p, o, m) BOOST_PP_FOR_227_C(BOOST_PP_BOOL(p(228, s)), s, p, o, m) # define BOOST_PP_FOR_228(s, p, o, m) BOOST_PP_FOR_228_C(BOOST_PP_BOOL(p(229, s)), s, p, o, m) # define BOOST_PP_FOR_229(s, p, o, m) BOOST_PP_FOR_229_C(BOOST_PP_BOOL(p(230, s)), s, p, o, m) # define BOOST_PP_FOR_230(s, p, o, m) BOOST_PP_FOR_230_C(BOOST_PP_BOOL(p(231, s)), s, p, o, m) # define BOOST_PP_FOR_231(s, p, o, m) BOOST_PP_FOR_231_C(BOOST_PP_BOOL(p(232, s)), s, p, o, m) # define BOOST_PP_FOR_232(s, p, o, m) BOOST_PP_FOR_232_C(BOOST_PP_BOOL(p(233, s)), s, p, o, m) # define BOOST_PP_FOR_233(s, p, o, m) BOOST_PP_FOR_233_C(BOOST_PP_BOOL(p(234, s)), s, p, o, m) # define BOOST_PP_FOR_234(s, p, o, m) BOOST_PP_FOR_234_C(BOOST_PP_BOOL(p(235, s)), s, p, o, m) # define BOOST_PP_FOR_235(s, p, o, m) BOOST_PP_FOR_235_C(BOOST_PP_BOOL(p(236, s)), s, p, o, m) # define BOOST_PP_FOR_236(s, p, o, m) BOOST_PP_FOR_236_C(BOOST_PP_BOOL(p(237, s)), s, p, o, m) # define BOOST_PP_FOR_237(s, p, o, m) BOOST_PP_FOR_237_C(BOOST_PP_BOOL(p(238, s)), s, p, o, m) # define BOOST_PP_FOR_238(s, p, o, m) BOOST_PP_FOR_238_C(BOOST_PP_BOOL(p(239, s)), s, p, o, m) # define BOOST_PP_FOR_239(s, p, o, m) BOOST_PP_FOR_239_C(BOOST_PP_BOOL(p(240, s)), s, p, o, m) # define BOOST_PP_FOR_240(s, p, o, m) BOOST_PP_FOR_240_C(BOOST_PP_BOOL(p(241, s)), s, p, o, m) # define BOOST_PP_FOR_241(s, p, o, m) BOOST_PP_FOR_241_C(BOOST_PP_BOOL(p(242, s)), s, p, o, m) # define BOOST_PP_FOR_242(s, p, o, m) BOOST_PP_FOR_242_C(BOOST_PP_BOOL(p(243, s)), s, p, o, m) # define BOOST_PP_FOR_243(s, p, o, m) BOOST_PP_FOR_243_C(BOOST_PP_BOOL(p(244, s)), s, p, o, m) # define BOOST_PP_FOR_244(s, p, o, m) BOOST_PP_FOR_244_C(BOOST_PP_BOOL(p(245, s)), s, p, o, m) # define BOOST_PP_FOR_245(s, p, o, m) BOOST_PP_FOR_245_C(BOOST_PP_BOOL(p(246, s)), s, p, o, m) # define BOOST_PP_FOR_246(s, p, o, m) BOOST_PP_FOR_246_C(BOOST_PP_BOOL(p(247, s)), s, p, o, m) # define BOOST_PP_FOR_247(s, p, o, m) BOOST_PP_FOR_247_C(BOOST_PP_BOOL(p(248, s)), s, p, o, m) # define BOOST_PP_FOR_248(s, p, o, m) BOOST_PP_FOR_248_C(BOOST_PP_BOOL(p(249, s)), s, p, o, m) # define BOOST_PP_FOR_249(s, p, o, m) BOOST_PP_FOR_249_C(BOOST_PP_BOOL(p(250, s)), s, p, o, m) # define BOOST_PP_FOR_250(s, p, o, m) BOOST_PP_FOR_250_C(BOOST_PP_BOOL(p(251, s)), s, p, o, m) # define BOOST_PP_FOR_251(s, p, o, m) BOOST_PP_FOR_251_C(BOOST_PP_BOOL(p(252, s)), s, p, o, m) # define BOOST_PP_FOR_252(s, p, o, m) BOOST_PP_FOR_252_C(BOOST_PP_BOOL(p(253, s)), s, p, o, m) # define BOOST_PP_FOR_253(s, p, o, m) BOOST_PP_FOR_253_C(BOOST_PP_BOOL(p(254, s)), s, p, o, m) # define BOOST_PP_FOR_254(s, p, o, m) BOOST_PP_FOR_254_C(BOOST_PP_BOOL(p(255, s)), s, p, o, m) # define BOOST_PP_FOR_255(s, p, o, m) BOOST_PP_FOR_255_C(BOOST_PP_BOOL(p(256, s)), s, p, o, m) # define BOOST_PP_FOR_256(s, p, o, m) BOOST_PP_FOR_256_C(BOOST_PP_BOOL(p(257, s)), s, p, o, m) # # define BOOST_PP_FOR_1_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IIF(c, BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(2, s), p, o, m) # define BOOST_PP_FOR_2_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IIF(c, BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(3, s), p, o, m) # define BOOST_PP_FOR_3_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IIF(c, BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(4, s), p, o, m) # define BOOST_PP_FOR_4_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IIF(c, BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(5, s), p, o, m) # define BOOST_PP_FOR_5_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IIF(c, BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(6, s), p, o, m) # define BOOST_PP_FOR_6_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IIF(c, BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(7, s), p, o, m) # define BOOST_PP_FOR_7_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IIF(c, BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(8, s), p, o, m) # define BOOST_PP_FOR_8_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IIF(c, BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(9, s), p, o, m) # define BOOST_PP_FOR_9_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IIF(c, BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(10, s), p, o, m) # define BOOST_PP_FOR_10_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IIF(c, BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(11, s), p, o, m) # define BOOST_PP_FOR_11_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IIF(c, BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(12, s), p, o, m) # define BOOST_PP_FOR_12_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IIF(c, BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(13, s), p, o, m) # define BOOST_PP_FOR_13_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IIF(c, BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(14, s), p, o, m) # define BOOST_PP_FOR_14_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IIF(c, BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(15, s), p, o, m) # define BOOST_PP_FOR_15_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IIF(c, BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(16, s), p, o, m) # define BOOST_PP_FOR_16_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IIF(c, BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(17, s), p, o, m) # define BOOST_PP_FOR_17_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IIF(c, BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(18, s), p, o, m) # define BOOST_PP_FOR_18_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IIF(c, BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(19, s), p, o, m) # define BOOST_PP_FOR_19_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IIF(c, BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(20, s), p, o, m) # define BOOST_PP_FOR_20_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IIF(c, BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(21, s), p, o, m) # define BOOST_PP_FOR_21_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IIF(c, BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(22, s), p, o, m) # define BOOST_PP_FOR_22_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IIF(c, BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(23, s), p, o, m) # define BOOST_PP_FOR_23_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IIF(c, BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(24, s), p, o, m) # define BOOST_PP_FOR_24_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IIF(c, BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(25, s), p, o, m) # define BOOST_PP_FOR_25_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IIF(c, BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(26, s), p, o, m) # define BOOST_PP_FOR_26_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IIF(c, BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(27, s), p, o, m) # define BOOST_PP_FOR_27_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IIF(c, BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(28, s), p, o, m) # define BOOST_PP_FOR_28_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IIF(c, BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(29, s), p, o, m) # define BOOST_PP_FOR_29_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IIF(c, BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(30, s), p, o, m) # define BOOST_PP_FOR_30_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IIF(c, BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(31, s), p, o, m) # define BOOST_PP_FOR_31_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IIF(c, BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(32, s), p, o, m) # define BOOST_PP_FOR_32_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IIF(c, BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(33, s), p, o, m) # define BOOST_PP_FOR_33_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IIF(c, BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(34, s), p, o, m) # define BOOST_PP_FOR_34_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IIF(c, BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(35, s), p, o, m) # define BOOST_PP_FOR_35_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IIF(c, BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(36, s), p, o, m) # define BOOST_PP_FOR_36_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IIF(c, BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(37, s), p, o, m) # define BOOST_PP_FOR_37_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IIF(c, BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(38, s), p, o, m) # define BOOST_PP_FOR_38_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IIF(c, BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(39, s), p, o, m) # define BOOST_PP_FOR_39_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IIF(c, BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(40, s), p, o, m) # define BOOST_PP_FOR_40_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IIF(c, BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(41, s), p, o, m) # define BOOST_PP_FOR_41_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IIF(c, BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(42, s), p, o, m) # define BOOST_PP_FOR_42_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IIF(c, BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(43, s), p, o, m) # define BOOST_PP_FOR_43_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IIF(c, BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(44, s), p, o, m) # define BOOST_PP_FOR_44_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IIF(c, BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(45, s), p, o, m) # define BOOST_PP_FOR_45_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IIF(c, BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(46, s), p, o, m) # define BOOST_PP_FOR_46_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IIF(c, BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(47, s), p, o, m) # define BOOST_PP_FOR_47_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IIF(c, BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(48, s), p, o, m) # define BOOST_PP_FOR_48_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IIF(c, BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(49, s), p, o, m) # define BOOST_PP_FOR_49_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IIF(c, BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(50, s), p, o, m) # define BOOST_PP_FOR_50_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IIF(c, BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(51, s), p, o, m) # define BOOST_PP_FOR_51_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IIF(c, BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(52, s), p, o, m) # define BOOST_PP_FOR_52_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IIF(c, BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(53, s), p, o, m) # define BOOST_PP_FOR_53_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IIF(c, BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(54, s), p, o, m) # define BOOST_PP_FOR_54_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IIF(c, BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(55, s), p, o, m) # define BOOST_PP_FOR_55_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IIF(c, BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(56, s), p, o, m) # define BOOST_PP_FOR_56_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IIF(c, BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(57, s), p, o, m) # define BOOST_PP_FOR_57_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IIF(c, BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(58, s), p, o, m) # define BOOST_PP_FOR_58_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IIF(c, BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(59, s), p, o, m) # define BOOST_PP_FOR_59_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IIF(c, BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(60, s), p, o, m) # define BOOST_PP_FOR_60_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IIF(c, BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(61, s), p, o, m) # define BOOST_PP_FOR_61_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IIF(c, BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(62, s), p, o, m) # define BOOST_PP_FOR_62_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IIF(c, BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(63, s), p, o, m) # define BOOST_PP_FOR_63_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IIF(c, BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(64, s), p, o, m) # define BOOST_PP_FOR_64_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IIF(c, BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(65, s), p, o, m) # define BOOST_PP_FOR_65_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IIF(c, BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(66, s), p, o, m) # define BOOST_PP_FOR_66_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IIF(c, BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(67, s), p, o, m) # define BOOST_PP_FOR_67_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IIF(c, BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(68, s), p, o, m) # define BOOST_PP_FOR_68_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IIF(c, BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(69, s), p, o, m) # define BOOST_PP_FOR_69_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IIF(c, BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(70, s), p, o, m) # define BOOST_PP_FOR_70_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IIF(c, BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(71, s), p, o, m) # define BOOST_PP_FOR_71_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IIF(c, BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(72, s), p, o, m) # define BOOST_PP_FOR_72_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IIF(c, BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(73, s), p, o, m) # define BOOST_PP_FOR_73_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IIF(c, BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(74, s), p, o, m) # define BOOST_PP_FOR_74_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IIF(c, BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(75, s), p, o, m) # define BOOST_PP_FOR_75_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IIF(c, BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(76, s), p, o, m) # define BOOST_PP_FOR_76_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IIF(c, BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(77, s), p, o, m) # define BOOST_PP_FOR_77_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IIF(c, BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(78, s), p, o, m) # define BOOST_PP_FOR_78_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IIF(c, BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(79, s), p, o, m) # define BOOST_PP_FOR_79_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IIF(c, BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(80, s), p, o, m) # define BOOST_PP_FOR_80_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IIF(c, BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(81, s), p, o, m) # define BOOST_PP_FOR_81_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IIF(c, BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(82, s), p, o, m) # define BOOST_PP_FOR_82_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IIF(c, BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(83, s), p, o, m) # define BOOST_PP_FOR_83_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IIF(c, BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(84, s), p, o, m) # define BOOST_PP_FOR_84_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IIF(c, BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(85, s), p, o, m) # define BOOST_PP_FOR_85_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IIF(c, BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(86, s), p, o, m) # define BOOST_PP_FOR_86_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IIF(c, BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(87, s), p, o, m) # define BOOST_PP_FOR_87_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IIF(c, BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(88, s), p, o, m) # define BOOST_PP_FOR_88_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IIF(c, BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(89, s), p, o, m) # define BOOST_PP_FOR_89_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IIF(c, BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(90, s), p, o, m) # define BOOST_PP_FOR_90_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IIF(c, BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(91, s), p, o, m) # define BOOST_PP_FOR_91_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IIF(c, BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(92, s), p, o, m) # define BOOST_PP_FOR_92_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IIF(c, BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(93, s), p, o, m) # define BOOST_PP_FOR_93_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IIF(c, BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(94, s), p, o, m) # define BOOST_PP_FOR_94_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IIF(c, BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(95, s), p, o, m) # define BOOST_PP_FOR_95_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IIF(c, BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(96, s), p, o, m) # define BOOST_PP_FOR_96_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IIF(c, BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(97, s), p, o, m) # define BOOST_PP_FOR_97_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IIF(c, BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(98, s), p, o, m) # define BOOST_PP_FOR_98_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IIF(c, BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(99, s), p, o, m) # define BOOST_PP_FOR_99_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IIF(c, BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(100, s), p, o, m) # define BOOST_PP_FOR_100_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IIF(c, BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(101, s), p, o, m) # define BOOST_PP_FOR_101_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IIF(c, BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(102, s), p, o, m) # define BOOST_PP_FOR_102_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IIF(c, BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(103, s), p, o, m) # define BOOST_PP_FOR_103_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IIF(c, BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(104, s), p, o, m) # define BOOST_PP_FOR_104_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IIF(c, BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(105, s), p, o, m) # define BOOST_PP_FOR_105_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IIF(c, BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(106, s), p, o, m) # define BOOST_PP_FOR_106_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IIF(c, BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(107, s), p, o, m) # define BOOST_PP_FOR_107_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IIF(c, BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(108, s), p, o, m) # define BOOST_PP_FOR_108_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IIF(c, BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(109, s), p, o, m) # define BOOST_PP_FOR_109_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IIF(c, BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(110, s), p, o, m) # define BOOST_PP_FOR_110_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IIF(c, BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(111, s), p, o, m) # define BOOST_PP_FOR_111_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IIF(c, BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(112, s), p, o, m) # define BOOST_PP_FOR_112_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IIF(c, BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(113, s), p, o, m) # define BOOST_PP_FOR_113_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IIF(c, BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(114, s), p, o, m) # define BOOST_PP_FOR_114_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IIF(c, BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(115, s), p, o, m) # define BOOST_PP_FOR_115_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IIF(c, BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(116, s), p, o, m) # define BOOST_PP_FOR_116_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IIF(c, BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(117, s), p, o, m) # define BOOST_PP_FOR_117_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IIF(c, BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(118, s), p, o, m) # define BOOST_PP_FOR_118_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IIF(c, BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(119, s), p, o, m) # define BOOST_PP_FOR_119_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IIF(c, BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(120, s), p, o, m) # define BOOST_PP_FOR_120_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IIF(c, BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(121, s), p, o, m) # define BOOST_PP_FOR_121_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IIF(c, BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(122, s), p, o, m) # define BOOST_PP_FOR_122_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IIF(c, BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(123, s), p, o, m) # define BOOST_PP_FOR_123_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IIF(c, BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(124, s), p, o, m) # define BOOST_PP_FOR_124_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IIF(c, BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(125, s), p, o, m) # define BOOST_PP_FOR_125_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IIF(c, BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(126, s), p, o, m) # define BOOST_PP_FOR_126_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IIF(c, BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(127, s), p, o, m) # define BOOST_PP_FOR_127_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IIF(c, BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(128, s), p, o, m) # define BOOST_PP_FOR_128_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IIF(c, BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(129, s), p, o, m) # define BOOST_PP_FOR_129_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IIF(c, BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(130, s), p, o, m) # define BOOST_PP_FOR_130_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IIF(c, BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(131, s), p, o, m) # define BOOST_PP_FOR_131_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IIF(c, BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(132, s), p, o, m) # define BOOST_PP_FOR_132_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IIF(c, BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(133, s), p, o, m) # define BOOST_PP_FOR_133_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IIF(c, BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(134, s), p, o, m) # define BOOST_PP_FOR_134_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IIF(c, BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(135, s), p, o, m) # define BOOST_PP_FOR_135_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IIF(c, BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(136, s), p, o, m) # define BOOST_PP_FOR_136_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IIF(c, BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(137, s), p, o, m) # define BOOST_PP_FOR_137_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IIF(c, BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(138, s), p, o, m) # define BOOST_PP_FOR_138_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IIF(c, BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(139, s), p, o, m) # define BOOST_PP_FOR_139_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IIF(c, BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(140, s), p, o, m) # define BOOST_PP_FOR_140_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IIF(c, BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(141, s), p, o, m) # define BOOST_PP_FOR_141_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IIF(c, BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(142, s), p, o, m) # define BOOST_PP_FOR_142_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IIF(c, BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(143, s), p, o, m) # define BOOST_PP_FOR_143_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IIF(c, BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(144, s), p, o, m) # define BOOST_PP_FOR_144_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IIF(c, BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(145, s), p, o, m) # define BOOST_PP_FOR_145_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IIF(c, BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(146, s), p, o, m) # define BOOST_PP_FOR_146_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IIF(c, BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(147, s), p, o, m) # define BOOST_PP_FOR_147_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IIF(c, BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(148, s), p, o, m) # define BOOST_PP_FOR_148_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IIF(c, BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(149, s), p, o, m) # define BOOST_PP_FOR_149_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IIF(c, BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(150, s), p, o, m) # define BOOST_PP_FOR_150_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IIF(c, BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(151, s), p, o, m) # define BOOST_PP_FOR_151_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IIF(c, BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(152, s), p, o, m) # define BOOST_PP_FOR_152_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IIF(c, BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(153, s), p, o, m) # define BOOST_PP_FOR_153_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IIF(c, BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(154, s), p, o, m) # define BOOST_PP_FOR_154_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IIF(c, BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(155, s), p, o, m) # define BOOST_PP_FOR_155_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IIF(c, BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(156, s), p, o, m) # define BOOST_PP_FOR_156_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IIF(c, BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(157, s), p, o, m) # define BOOST_PP_FOR_157_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IIF(c, BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(158, s), p, o, m) # define BOOST_PP_FOR_158_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IIF(c, BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(159, s), p, o, m) # define BOOST_PP_FOR_159_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IIF(c, BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(160, s), p, o, m) # define BOOST_PP_FOR_160_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IIF(c, BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(161, s), p, o, m) # define BOOST_PP_FOR_161_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IIF(c, BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(162, s), p, o, m) # define BOOST_PP_FOR_162_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IIF(c, BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(163, s), p, o, m) # define BOOST_PP_FOR_163_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IIF(c, BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(164, s), p, o, m) # define BOOST_PP_FOR_164_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IIF(c, BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(165, s), p, o, m) # define BOOST_PP_FOR_165_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IIF(c, BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(166, s), p, o, m) # define BOOST_PP_FOR_166_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IIF(c, BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(167, s), p, o, m) # define BOOST_PP_FOR_167_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IIF(c, BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(168, s), p, o, m) # define BOOST_PP_FOR_168_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IIF(c, BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(169, s), p, o, m) # define BOOST_PP_FOR_169_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IIF(c, BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(170, s), p, o, m) # define BOOST_PP_FOR_170_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IIF(c, BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(171, s), p, o, m) # define BOOST_PP_FOR_171_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IIF(c, BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(172, s), p, o, m) # define BOOST_PP_FOR_172_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IIF(c, BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(173, s), p, o, m) # define BOOST_PP_FOR_173_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IIF(c, BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(174, s), p, o, m) # define BOOST_PP_FOR_174_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IIF(c, BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(175, s), p, o, m) # define BOOST_PP_FOR_175_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IIF(c, BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(176, s), p, o, m) # define BOOST_PP_FOR_176_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IIF(c, BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(177, s), p, o, m) # define BOOST_PP_FOR_177_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IIF(c, BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(178, s), p, o, m) # define BOOST_PP_FOR_178_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IIF(c, BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(179, s), p, o, m) # define BOOST_PP_FOR_179_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IIF(c, BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(180, s), p, o, m) # define BOOST_PP_FOR_180_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IIF(c, BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(181, s), p, o, m) # define BOOST_PP_FOR_181_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IIF(c, BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(182, s), p, o, m) # define BOOST_PP_FOR_182_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IIF(c, BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(183, s), p, o, m) # define BOOST_PP_FOR_183_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IIF(c, BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(184, s), p, o, m) # define BOOST_PP_FOR_184_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IIF(c, BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(185, s), p, o, m) # define BOOST_PP_FOR_185_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IIF(c, BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(186, s), p, o, m) # define BOOST_PP_FOR_186_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IIF(c, BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(187, s), p, o, m) # define BOOST_PP_FOR_187_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IIF(c, BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(188, s), p, o, m) # define BOOST_PP_FOR_188_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IIF(c, BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(189, s), p, o, m) # define BOOST_PP_FOR_189_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IIF(c, BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(190, s), p, o, m) # define BOOST_PP_FOR_190_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IIF(c, BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(191, s), p, o, m) # define BOOST_PP_FOR_191_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IIF(c, BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(192, s), p, o, m) # define BOOST_PP_FOR_192_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IIF(c, BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(193, s), p, o, m) # define BOOST_PP_FOR_193_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IIF(c, BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(194, s), p, o, m) # define BOOST_PP_FOR_194_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IIF(c, BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(195, s), p, o, m) # define BOOST_PP_FOR_195_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IIF(c, BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(196, s), p, o, m) # define BOOST_PP_FOR_196_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IIF(c, BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(197, s), p, o, m) # define BOOST_PP_FOR_197_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IIF(c, BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(198, s), p, o, m) # define BOOST_PP_FOR_198_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IIF(c, BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(199, s), p, o, m) # define BOOST_PP_FOR_199_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IIF(c, BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(200, s), p, o, m) # define BOOST_PP_FOR_200_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IIF(c, BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(201, s), p, o, m) # define BOOST_PP_FOR_201_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IIF(c, BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(202, s), p, o, m) # define BOOST_PP_FOR_202_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IIF(c, BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(203, s), p, o, m) # define BOOST_PP_FOR_203_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IIF(c, BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(204, s), p, o, m) # define BOOST_PP_FOR_204_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IIF(c, BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(205, s), p, o, m) # define BOOST_PP_FOR_205_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IIF(c, BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(206, s), p, o, m) # define BOOST_PP_FOR_206_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IIF(c, BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(207, s), p, o, m) # define BOOST_PP_FOR_207_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IIF(c, BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(208, s), p, o, m) # define BOOST_PP_FOR_208_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IIF(c, BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(209, s), p, o, m) # define BOOST_PP_FOR_209_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IIF(c, BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(210, s), p, o, m) # define BOOST_PP_FOR_210_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IIF(c, BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(211, s), p, o, m) # define BOOST_PP_FOR_211_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IIF(c, BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(212, s), p, o, m) # define BOOST_PP_FOR_212_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IIF(c, BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(213, s), p, o, m) # define BOOST_PP_FOR_213_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IIF(c, BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(214, s), p, o, m) # define BOOST_PP_FOR_214_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IIF(c, BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(215, s), p, o, m) # define BOOST_PP_FOR_215_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IIF(c, BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(216, s), p, o, m) # define BOOST_PP_FOR_216_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IIF(c, BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(217, s), p, o, m) # define BOOST_PP_FOR_217_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IIF(c, BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(218, s), p, o, m) # define BOOST_PP_FOR_218_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IIF(c, BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(219, s), p, o, m) # define BOOST_PP_FOR_219_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IIF(c, BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(220, s), p, o, m) # define BOOST_PP_FOR_220_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IIF(c, BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(221, s), p, o, m) # define BOOST_PP_FOR_221_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IIF(c, BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(222, s), p, o, m) # define BOOST_PP_FOR_222_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IIF(c, BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(223, s), p, o, m) # define BOOST_PP_FOR_223_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IIF(c, BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(224, s), p, o, m) # define BOOST_PP_FOR_224_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IIF(c, BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(225, s), p, o, m) # define BOOST_PP_FOR_225_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IIF(c, BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(226, s), p, o, m) # define BOOST_PP_FOR_226_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IIF(c, BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(227, s), p, o, m) # define BOOST_PP_FOR_227_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IIF(c, BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(228, s), p, o, m) # define BOOST_PP_FOR_228_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IIF(c, BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(229, s), p, o, m) # define BOOST_PP_FOR_229_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IIF(c, BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(230, s), p, o, m) # define BOOST_PP_FOR_230_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IIF(c, BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(231, s), p, o, m) # define BOOST_PP_FOR_231_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IIF(c, BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(232, s), p, o, m) # define BOOST_PP_FOR_232_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IIF(c, BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(233, s), p, o, m) # define BOOST_PP_FOR_233_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IIF(c, BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(234, s), p, o, m) # define BOOST_PP_FOR_234_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IIF(c, BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(235, s), p, o, m) # define BOOST_PP_FOR_235_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IIF(c, BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(236, s), p, o, m) # define BOOST_PP_FOR_236_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IIF(c, BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(237, s), p, o, m) # define BOOST_PP_FOR_237_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IIF(c, BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(238, s), p, o, m) # define BOOST_PP_FOR_238_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IIF(c, BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(239, s), p, o, m) # define BOOST_PP_FOR_239_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IIF(c, BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(240, s), p, o, m) # define BOOST_PP_FOR_240_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IIF(c, BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(241, s), p, o, m) # define BOOST_PP_FOR_241_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IIF(c, BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(242, s), p, o, m) # define BOOST_PP_FOR_242_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IIF(c, BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(243, s), p, o, m) # define BOOST_PP_FOR_243_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IIF(c, BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(244, s), p, o, m) # define BOOST_PP_FOR_244_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IIF(c, BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(245, s), p, o, m) # define BOOST_PP_FOR_245_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IIF(c, BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(246, s), p, o, m) # define BOOST_PP_FOR_246_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IIF(c, BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(247, s), p, o, m) # define BOOST_PP_FOR_247_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IIF(c, BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(248, s), p, o, m) # define BOOST_PP_FOR_248_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IIF(c, BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(249, s), p, o, m) # define BOOST_PP_FOR_249_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IIF(c, BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(250, s), p, o, m) # define BOOST_PP_FOR_250_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IIF(c, BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(251, s), p, o, m) # define BOOST_PP_FOR_251_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IIF(c, BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(252, s), p, o, m) # define BOOST_PP_FOR_252_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IIF(c, BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(253, s), p, o, m) # define BOOST_PP_FOR_253_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IIF(c, BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(254, s), p, o, m) # define BOOST_PP_FOR_254_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IIF(c, BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(255, s), p, o, m) # define BOOST_PP_FOR_255_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IIF(c, BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(256, s), p, o, m) # define BOOST_PP_FOR_256_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IIF(c, BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(257, s), p, o, m) # # endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/dmc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000755000175000017500000000000012146213770031750 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/dmc/for.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000021726311344301502031753 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP # define BOOST_PREPROCESSOR_REPETITION_DETAIL_FOR_HPP # # include # include # include # include # # define BOOST_PP_FOR_1(s, p, o, m) BOOST_PP_FOR_1_C(BOOST_PP_BOOL(p##(2, s)), s, p, o, m) # define BOOST_PP_FOR_2(s, p, o, m) BOOST_PP_FOR_2_C(BOOST_PP_BOOL(p##(3, s)), s, p, o, m) # define BOOST_PP_FOR_3(s, p, o, m) BOOST_PP_FOR_3_C(BOOST_PP_BOOL(p##(4, s)), s, p, o, m) # define BOOST_PP_FOR_4(s, p, o, m) BOOST_PP_FOR_4_C(BOOST_PP_BOOL(p##(5, s)), s, p, o, m) # define BOOST_PP_FOR_5(s, p, o, m) BOOST_PP_FOR_5_C(BOOST_PP_BOOL(p##(6, s)), s, p, o, m) # define BOOST_PP_FOR_6(s, p, o, m) BOOST_PP_FOR_6_C(BOOST_PP_BOOL(p##(7, s)), s, p, o, m) # define BOOST_PP_FOR_7(s, p, o, m) BOOST_PP_FOR_7_C(BOOST_PP_BOOL(p##(8, s)), s, p, o, m) # define BOOST_PP_FOR_8(s, p, o, m) BOOST_PP_FOR_8_C(BOOST_PP_BOOL(p##(9, s)), s, p, o, m) # define BOOST_PP_FOR_9(s, p, o, m) BOOST_PP_FOR_9_C(BOOST_PP_BOOL(p##(10, s)), s, p, o, m) # define BOOST_PP_FOR_10(s, p, o, m) BOOST_PP_FOR_10_C(BOOST_PP_BOOL(p##(11, s)), s, p, o, m) # define BOOST_PP_FOR_11(s, p, o, m) BOOST_PP_FOR_11_C(BOOST_PP_BOOL(p##(12, s)), s, p, o, m) # define BOOST_PP_FOR_12(s, p, o, m) BOOST_PP_FOR_12_C(BOOST_PP_BOOL(p##(13, s)), s, p, o, m) # define BOOST_PP_FOR_13(s, p, o, m) BOOST_PP_FOR_13_C(BOOST_PP_BOOL(p##(14, s)), s, p, o, m) # define BOOST_PP_FOR_14(s, p, o, m) BOOST_PP_FOR_14_C(BOOST_PP_BOOL(p##(15, s)), s, p, o, m) # define BOOST_PP_FOR_15(s, p, o, m) BOOST_PP_FOR_15_C(BOOST_PP_BOOL(p##(16, s)), s, p, o, m) # define BOOST_PP_FOR_16(s, p, o, m) BOOST_PP_FOR_16_C(BOOST_PP_BOOL(p##(17, s)), s, p, o, m) # define BOOST_PP_FOR_17(s, p, o, m) BOOST_PP_FOR_17_C(BOOST_PP_BOOL(p##(18, s)), s, p, o, m) # define BOOST_PP_FOR_18(s, p, o, m) BOOST_PP_FOR_18_C(BOOST_PP_BOOL(p##(19, s)), s, p, o, m) # define BOOST_PP_FOR_19(s, p, o, m) BOOST_PP_FOR_19_C(BOOST_PP_BOOL(p##(20, s)), s, p, o, m) # define BOOST_PP_FOR_20(s, p, o, m) BOOST_PP_FOR_20_C(BOOST_PP_BOOL(p##(21, s)), s, p, o, m) # define BOOST_PP_FOR_21(s, p, o, m) BOOST_PP_FOR_21_C(BOOST_PP_BOOL(p##(22, s)), s, p, o, m) # define BOOST_PP_FOR_22(s, p, o, m) BOOST_PP_FOR_22_C(BOOST_PP_BOOL(p##(23, s)), s, p, o, m) # define BOOST_PP_FOR_23(s, p, o, m) BOOST_PP_FOR_23_C(BOOST_PP_BOOL(p##(24, s)), s, p, o, m) # define BOOST_PP_FOR_24(s, p, o, m) BOOST_PP_FOR_24_C(BOOST_PP_BOOL(p##(25, s)), s, p, o, m) # define BOOST_PP_FOR_25(s, p, o, m) BOOST_PP_FOR_25_C(BOOST_PP_BOOL(p##(26, s)), s, p, o, m) # define BOOST_PP_FOR_26(s, p, o, m) BOOST_PP_FOR_26_C(BOOST_PP_BOOL(p##(27, s)), s, p, o, m) # define BOOST_PP_FOR_27(s, p, o, m) BOOST_PP_FOR_27_C(BOOST_PP_BOOL(p##(28, s)), s, p, o, m) # define BOOST_PP_FOR_28(s, p, o, m) BOOST_PP_FOR_28_C(BOOST_PP_BOOL(p##(29, s)), s, p, o, m) # define BOOST_PP_FOR_29(s, p, o, m) BOOST_PP_FOR_29_C(BOOST_PP_BOOL(p##(30, s)), s, p, o, m) # define BOOST_PP_FOR_30(s, p, o, m) BOOST_PP_FOR_30_C(BOOST_PP_BOOL(p##(31, s)), s, p, o, m) # define BOOST_PP_FOR_31(s, p, o, m) BOOST_PP_FOR_31_C(BOOST_PP_BOOL(p##(32, s)), s, p, o, m) # define BOOST_PP_FOR_32(s, p, o, m) BOOST_PP_FOR_32_C(BOOST_PP_BOOL(p##(33, s)), s, p, o, m) # define BOOST_PP_FOR_33(s, p, o, m) BOOST_PP_FOR_33_C(BOOST_PP_BOOL(p##(34, s)), s, p, o, m) # define BOOST_PP_FOR_34(s, p, o, m) BOOST_PP_FOR_34_C(BOOST_PP_BOOL(p##(35, s)), s, p, o, m) # define BOOST_PP_FOR_35(s, p, o, m) BOOST_PP_FOR_35_C(BOOST_PP_BOOL(p##(36, s)), s, p, o, m) # define BOOST_PP_FOR_36(s, p, o, m) BOOST_PP_FOR_36_C(BOOST_PP_BOOL(p##(37, s)), s, p, o, m) # define BOOST_PP_FOR_37(s, p, o, m) BOOST_PP_FOR_37_C(BOOST_PP_BOOL(p##(38, s)), s, p, o, m) # define BOOST_PP_FOR_38(s, p, o, m) BOOST_PP_FOR_38_C(BOOST_PP_BOOL(p##(39, s)), s, p, o, m) # define BOOST_PP_FOR_39(s, p, o, m) BOOST_PP_FOR_39_C(BOOST_PP_BOOL(p##(40, s)), s, p, o, m) # define BOOST_PP_FOR_40(s, p, o, m) BOOST_PP_FOR_40_C(BOOST_PP_BOOL(p##(41, s)), s, p, o, m) # define BOOST_PP_FOR_41(s, p, o, m) BOOST_PP_FOR_41_C(BOOST_PP_BOOL(p##(42, s)), s, p, o, m) # define BOOST_PP_FOR_42(s, p, o, m) BOOST_PP_FOR_42_C(BOOST_PP_BOOL(p##(43, s)), s, p, o, m) # define BOOST_PP_FOR_43(s, p, o, m) BOOST_PP_FOR_43_C(BOOST_PP_BOOL(p##(44, s)), s, p, o, m) # define BOOST_PP_FOR_44(s, p, o, m) BOOST_PP_FOR_44_C(BOOST_PP_BOOL(p##(45, s)), s, p, o, m) # define BOOST_PP_FOR_45(s, p, o, m) BOOST_PP_FOR_45_C(BOOST_PP_BOOL(p##(46, s)), s, p, o, m) # define BOOST_PP_FOR_46(s, p, o, m) BOOST_PP_FOR_46_C(BOOST_PP_BOOL(p##(47, s)), s, p, o, m) # define BOOST_PP_FOR_47(s, p, o, m) BOOST_PP_FOR_47_C(BOOST_PP_BOOL(p##(48, s)), s, p, o, m) # define BOOST_PP_FOR_48(s, p, o, m) BOOST_PP_FOR_48_C(BOOST_PP_BOOL(p##(49, s)), s, p, o, m) # define BOOST_PP_FOR_49(s, p, o, m) BOOST_PP_FOR_49_C(BOOST_PP_BOOL(p##(50, s)), s, p, o, m) # define BOOST_PP_FOR_50(s, p, o, m) BOOST_PP_FOR_50_C(BOOST_PP_BOOL(p##(51, s)), s, p, o, m) # define BOOST_PP_FOR_51(s, p, o, m) BOOST_PP_FOR_51_C(BOOST_PP_BOOL(p##(52, s)), s, p, o, m) # define BOOST_PP_FOR_52(s, p, o, m) BOOST_PP_FOR_52_C(BOOST_PP_BOOL(p##(53, s)), s, p, o, m) # define BOOST_PP_FOR_53(s, p, o, m) BOOST_PP_FOR_53_C(BOOST_PP_BOOL(p##(54, s)), s, p, o, m) # define BOOST_PP_FOR_54(s, p, o, m) BOOST_PP_FOR_54_C(BOOST_PP_BOOL(p##(55, s)), s, p, o, m) # define BOOST_PP_FOR_55(s, p, o, m) BOOST_PP_FOR_55_C(BOOST_PP_BOOL(p##(56, s)), s, p, o, m) # define BOOST_PP_FOR_56(s, p, o, m) BOOST_PP_FOR_56_C(BOOST_PP_BOOL(p##(57, s)), s, p, o, m) # define BOOST_PP_FOR_57(s, p, o, m) BOOST_PP_FOR_57_C(BOOST_PP_BOOL(p##(58, s)), s, p, o, m) # define BOOST_PP_FOR_58(s, p, o, m) BOOST_PP_FOR_58_C(BOOST_PP_BOOL(p##(59, s)), s, p, o, m) # define BOOST_PP_FOR_59(s, p, o, m) BOOST_PP_FOR_59_C(BOOST_PP_BOOL(p##(60, s)), s, p, o, m) # define BOOST_PP_FOR_60(s, p, o, m) BOOST_PP_FOR_60_C(BOOST_PP_BOOL(p##(61, s)), s, p, o, m) # define BOOST_PP_FOR_61(s, p, o, m) BOOST_PP_FOR_61_C(BOOST_PP_BOOL(p##(62, s)), s, p, o, m) # define BOOST_PP_FOR_62(s, p, o, m) BOOST_PP_FOR_62_C(BOOST_PP_BOOL(p##(63, s)), s, p, o, m) # define BOOST_PP_FOR_63(s, p, o, m) BOOST_PP_FOR_63_C(BOOST_PP_BOOL(p##(64, s)), s, p, o, m) # define BOOST_PP_FOR_64(s, p, o, m) BOOST_PP_FOR_64_C(BOOST_PP_BOOL(p##(65, s)), s, p, o, m) # define BOOST_PP_FOR_65(s, p, o, m) BOOST_PP_FOR_65_C(BOOST_PP_BOOL(p##(66, s)), s, p, o, m) # define BOOST_PP_FOR_66(s, p, o, m) BOOST_PP_FOR_66_C(BOOST_PP_BOOL(p##(67, s)), s, p, o, m) # define BOOST_PP_FOR_67(s, p, o, m) BOOST_PP_FOR_67_C(BOOST_PP_BOOL(p##(68, s)), s, p, o, m) # define BOOST_PP_FOR_68(s, p, o, m) BOOST_PP_FOR_68_C(BOOST_PP_BOOL(p##(69, s)), s, p, o, m) # define BOOST_PP_FOR_69(s, p, o, m) BOOST_PP_FOR_69_C(BOOST_PP_BOOL(p##(70, s)), s, p, o, m) # define BOOST_PP_FOR_70(s, p, o, m) BOOST_PP_FOR_70_C(BOOST_PP_BOOL(p##(71, s)), s, p, o, m) # define BOOST_PP_FOR_71(s, p, o, m) BOOST_PP_FOR_71_C(BOOST_PP_BOOL(p##(72, s)), s, p, o, m) # define BOOST_PP_FOR_72(s, p, o, m) BOOST_PP_FOR_72_C(BOOST_PP_BOOL(p##(73, s)), s, p, o, m) # define BOOST_PP_FOR_73(s, p, o, m) BOOST_PP_FOR_73_C(BOOST_PP_BOOL(p##(74, s)), s, p, o, m) # define BOOST_PP_FOR_74(s, p, o, m) BOOST_PP_FOR_74_C(BOOST_PP_BOOL(p##(75, s)), s, p, o, m) # define BOOST_PP_FOR_75(s, p, o, m) BOOST_PP_FOR_75_C(BOOST_PP_BOOL(p##(76, s)), s, p, o, m) # define BOOST_PP_FOR_76(s, p, o, m) BOOST_PP_FOR_76_C(BOOST_PP_BOOL(p##(77, s)), s, p, o, m) # define BOOST_PP_FOR_77(s, p, o, m) BOOST_PP_FOR_77_C(BOOST_PP_BOOL(p##(78, s)), s, p, o, m) # define BOOST_PP_FOR_78(s, p, o, m) BOOST_PP_FOR_78_C(BOOST_PP_BOOL(p##(79, s)), s, p, o, m) # define BOOST_PP_FOR_79(s, p, o, m) BOOST_PP_FOR_79_C(BOOST_PP_BOOL(p##(80, s)), s, p, o, m) # define BOOST_PP_FOR_80(s, p, o, m) BOOST_PP_FOR_80_C(BOOST_PP_BOOL(p##(81, s)), s, p, o, m) # define BOOST_PP_FOR_81(s, p, o, m) BOOST_PP_FOR_81_C(BOOST_PP_BOOL(p##(82, s)), s, p, o, m) # define BOOST_PP_FOR_82(s, p, o, m) BOOST_PP_FOR_82_C(BOOST_PP_BOOL(p##(83, s)), s, p, o, m) # define BOOST_PP_FOR_83(s, p, o, m) BOOST_PP_FOR_83_C(BOOST_PP_BOOL(p##(84, s)), s, p, o, m) # define BOOST_PP_FOR_84(s, p, o, m) BOOST_PP_FOR_84_C(BOOST_PP_BOOL(p##(85, s)), s, p, o, m) # define BOOST_PP_FOR_85(s, p, o, m) BOOST_PP_FOR_85_C(BOOST_PP_BOOL(p##(86, s)), s, p, o, m) # define BOOST_PP_FOR_86(s, p, o, m) BOOST_PP_FOR_86_C(BOOST_PP_BOOL(p##(87, s)), s, p, o, m) # define BOOST_PP_FOR_87(s, p, o, m) BOOST_PP_FOR_87_C(BOOST_PP_BOOL(p##(88, s)), s, p, o, m) # define BOOST_PP_FOR_88(s, p, o, m) BOOST_PP_FOR_88_C(BOOST_PP_BOOL(p##(89, s)), s, p, o, m) # define BOOST_PP_FOR_89(s, p, o, m) BOOST_PP_FOR_89_C(BOOST_PP_BOOL(p##(90, s)), s, p, o, m) # define BOOST_PP_FOR_90(s, p, o, m) BOOST_PP_FOR_90_C(BOOST_PP_BOOL(p##(91, s)), s, p, o, m) # define BOOST_PP_FOR_91(s, p, o, m) BOOST_PP_FOR_91_C(BOOST_PP_BOOL(p##(92, s)), s, p, o, m) # define BOOST_PP_FOR_92(s, p, o, m) BOOST_PP_FOR_92_C(BOOST_PP_BOOL(p##(93, s)), s, p, o, m) # define BOOST_PP_FOR_93(s, p, o, m) BOOST_PP_FOR_93_C(BOOST_PP_BOOL(p##(94, s)), s, p, o, m) # define BOOST_PP_FOR_94(s, p, o, m) BOOST_PP_FOR_94_C(BOOST_PP_BOOL(p##(95, s)), s, p, o, m) # define BOOST_PP_FOR_95(s, p, o, m) BOOST_PP_FOR_95_C(BOOST_PP_BOOL(p##(96, s)), s, p, o, m) # define BOOST_PP_FOR_96(s, p, o, m) BOOST_PP_FOR_96_C(BOOST_PP_BOOL(p##(97, s)), s, p, o, m) # define BOOST_PP_FOR_97(s, p, o, m) BOOST_PP_FOR_97_C(BOOST_PP_BOOL(p##(98, s)), s, p, o, m) # define BOOST_PP_FOR_98(s, p, o, m) BOOST_PP_FOR_98_C(BOOST_PP_BOOL(p##(99, s)), s, p, o, m) # define BOOST_PP_FOR_99(s, p, o, m) BOOST_PP_FOR_99_C(BOOST_PP_BOOL(p##(100, s)), s, p, o, m) # define BOOST_PP_FOR_100(s, p, o, m) BOOST_PP_FOR_100_C(BOOST_PP_BOOL(p##(101, s)), s, p, o, m) # define BOOST_PP_FOR_101(s, p, o, m) BOOST_PP_FOR_101_C(BOOST_PP_BOOL(p##(102, s)), s, p, o, m) # define BOOST_PP_FOR_102(s, p, o, m) BOOST_PP_FOR_102_C(BOOST_PP_BOOL(p##(103, s)), s, p, o, m) # define BOOST_PP_FOR_103(s, p, o, m) BOOST_PP_FOR_103_C(BOOST_PP_BOOL(p##(104, s)), s, p, o, m) # define BOOST_PP_FOR_104(s, p, o, m) BOOST_PP_FOR_104_C(BOOST_PP_BOOL(p##(105, s)), s, p, o, m) # define BOOST_PP_FOR_105(s, p, o, m) BOOST_PP_FOR_105_C(BOOST_PP_BOOL(p##(106, s)), s, p, o, m) # define BOOST_PP_FOR_106(s, p, o, m) BOOST_PP_FOR_106_C(BOOST_PP_BOOL(p##(107, s)), s, p, o, m) # define BOOST_PP_FOR_107(s, p, o, m) BOOST_PP_FOR_107_C(BOOST_PP_BOOL(p##(108, s)), s, p, o, m) # define BOOST_PP_FOR_108(s, p, o, m) BOOST_PP_FOR_108_C(BOOST_PP_BOOL(p##(109, s)), s, p, o, m) # define BOOST_PP_FOR_109(s, p, o, m) BOOST_PP_FOR_109_C(BOOST_PP_BOOL(p##(110, s)), s, p, o, m) # define BOOST_PP_FOR_110(s, p, o, m) BOOST_PP_FOR_110_C(BOOST_PP_BOOL(p##(111, s)), s, p, o, m) # define BOOST_PP_FOR_111(s, p, o, m) BOOST_PP_FOR_111_C(BOOST_PP_BOOL(p##(112, s)), s, p, o, m) # define BOOST_PP_FOR_112(s, p, o, m) BOOST_PP_FOR_112_C(BOOST_PP_BOOL(p##(113, s)), s, p, o, m) # define BOOST_PP_FOR_113(s, p, o, m) BOOST_PP_FOR_113_C(BOOST_PP_BOOL(p##(114, s)), s, p, o, m) # define BOOST_PP_FOR_114(s, p, o, m) BOOST_PP_FOR_114_C(BOOST_PP_BOOL(p##(115, s)), s, p, o, m) # define BOOST_PP_FOR_115(s, p, o, m) BOOST_PP_FOR_115_C(BOOST_PP_BOOL(p##(116, s)), s, p, o, m) # define BOOST_PP_FOR_116(s, p, o, m) BOOST_PP_FOR_116_C(BOOST_PP_BOOL(p##(117, s)), s, p, o, m) # define BOOST_PP_FOR_117(s, p, o, m) BOOST_PP_FOR_117_C(BOOST_PP_BOOL(p##(118, s)), s, p, o, m) # define BOOST_PP_FOR_118(s, p, o, m) BOOST_PP_FOR_118_C(BOOST_PP_BOOL(p##(119, s)), s, p, o, m) # define BOOST_PP_FOR_119(s, p, o, m) BOOST_PP_FOR_119_C(BOOST_PP_BOOL(p##(120, s)), s, p, o, m) # define BOOST_PP_FOR_120(s, p, o, m) BOOST_PP_FOR_120_C(BOOST_PP_BOOL(p##(121, s)), s, p, o, m) # define BOOST_PP_FOR_121(s, p, o, m) BOOST_PP_FOR_121_C(BOOST_PP_BOOL(p##(122, s)), s, p, o, m) # define BOOST_PP_FOR_122(s, p, o, m) BOOST_PP_FOR_122_C(BOOST_PP_BOOL(p##(123, s)), s, p, o, m) # define BOOST_PP_FOR_123(s, p, o, m) BOOST_PP_FOR_123_C(BOOST_PP_BOOL(p##(124, s)), s, p, o, m) # define BOOST_PP_FOR_124(s, p, o, m) BOOST_PP_FOR_124_C(BOOST_PP_BOOL(p##(125, s)), s, p, o, m) # define BOOST_PP_FOR_125(s, p, o, m) BOOST_PP_FOR_125_C(BOOST_PP_BOOL(p##(126, s)), s, p, o, m) # define BOOST_PP_FOR_126(s, p, o, m) BOOST_PP_FOR_126_C(BOOST_PP_BOOL(p##(127, s)), s, p, o, m) # define BOOST_PP_FOR_127(s, p, o, m) BOOST_PP_FOR_127_C(BOOST_PP_BOOL(p##(128, s)), s, p, o, m) # define BOOST_PP_FOR_128(s, p, o, m) BOOST_PP_FOR_128_C(BOOST_PP_BOOL(p##(129, s)), s, p, o, m) # define BOOST_PP_FOR_129(s, p, o, m) BOOST_PP_FOR_129_C(BOOST_PP_BOOL(p##(130, s)), s, p, o, m) # define BOOST_PP_FOR_130(s, p, o, m) BOOST_PP_FOR_130_C(BOOST_PP_BOOL(p##(131, s)), s, p, o, m) # define BOOST_PP_FOR_131(s, p, o, m) BOOST_PP_FOR_131_C(BOOST_PP_BOOL(p##(132, s)), s, p, o, m) # define BOOST_PP_FOR_132(s, p, o, m) BOOST_PP_FOR_132_C(BOOST_PP_BOOL(p##(133, s)), s, p, o, m) # define BOOST_PP_FOR_133(s, p, o, m) BOOST_PP_FOR_133_C(BOOST_PP_BOOL(p##(134, s)), s, p, o, m) # define BOOST_PP_FOR_134(s, p, o, m) BOOST_PP_FOR_134_C(BOOST_PP_BOOL(p##(135, s)), s, p, o, m) # define BOOST_PP_FOR_135(s, p, o, m) BOOST_PP_FOR_135_C(BOOST_PP_BOOL(p##(136, s)), s, p, o, m) # define BOOST_PP_FOR_136(s, p, o, m) BOOST_PP_FOR_136_C(BOOST_PP_BOOL(p##(137, s)), s, p, o, m) # define BOOST_PP_FOR_137(s, p, o, m) BOOST_PP_FOR_137_C(BOOST_PP_BOOL(p##(138, s)), s, p, o, m) # define BOOST_PP_FOR_138(s, p, o, m) BOOST_PP_FOR_138_C(BOOST_PP_BOOL(p##(139, s)), s, p, o, m) # define BOOST_PP_FOR_139(s, p, o, m) BOOST_PP_FOR_139_C(BOOST_PP_BOOL(p##(140, s)), s, p, o, m) # define BOOST_PP_FOR_140(s, p, o, m) BOOST_PP_FOR_140_C(BOOST_PP_BOOL(p##(141, s)), s, p, o, m) # define BOOST_PP_FOR_141(s, p, o, m) BOOST_PP_FOR_141_C(BOOST_PP_BOOL(p##(142, s)), s, p, o, m) # define BOOST_PP_FOR_142(s, p, o, m) BOOST_PP_FOR_142_C(BOOST_PP_BOOL(p##(143, s)), s, p, o, m) # define BOOST_PP_FOR_143(s, p, o, m) BOOST_PP_FOR_143_C(BOOST_PP_BOOL(p##(144, s)), s, p, o, m) # define BOOST_PP_FOR_144(s, p, o, m) BOOST_PP_FOR_144_C(BOOST_PP_BOOL(p##(145, s)), s, p, o, m) # define BOOST_PP_FOR_145(s, p, o, m) BOOST_PP_FOR_145_C(BOOST_PP_BOOL(p##(146, s)), s, p, o, m) # define BOOST_PP_FOR_146(s, p, o, m) BOOST_PP_FOR_146_C(BOOST_PP_BOOL(p##(147, s)), s, p, o, m) # define BOOST_PP_FOR_147(s, p, o, m) BOOST_PP_FOR_147_C(BOOST_PP_BOOL(p##(148, s)), s, p, o, m) # define BOOST_PP_FOR_148(s, p, o, m) BOOST_PP_FOR_148_C(BOOST_PP_BOOL(p##(149, s)), s, p, o, m) # define BOOST_PP_FOR_149(s, p, o, m) BOOST_PP_FOR_149_C(BOOST_PP_BOOL(p##(150, s)), s, p, o, m) # define BOOST_PP_FOR_150(s, p, o, m) BOOST_PP_FOR_150_C(BOOST_PP_BOOL(p##(151, s)), s, p, o, m) # define BOOST_PP_FOR_151(s, p, o, m) BOOST_PP_FOR_151_C(BOOST_PP_BOOL(p##(152, s)), s, p, o, m) # define BOOST_PP_FOR_152(s, p, o, m) BOOST_PP_FOR_152_C(BOOST_PP_BOOL(p##(153, s)), s, p, o, m) # define BOOST_PP_FOR_153(s, p, o, m) BOOST_PP_FOR_153_C(BOOST_PP_BOOL(p##(154, s)), s, p, o, m) # define BOOST_PP_FOR_154(s, p, o, m) BOOST_PP_FOR_154_C(BOOST_PP_BOOL(p##(155, s)), s, p, o, m) # define BOOST_PP_FOR_155(s, p, o, m) BOOST_PP_FOR_155_C(BOOST_PP_BOOL(p##(156, s)), s, p, o, m) # define BOOST_PP_FOR_156(s, p, o, m) BOOST_PP_FOR_156_C(BOOST_PP_BOOL(p##(157, s)), s, p, o, m) # define BOOST_PP_FOR_157(s, p, o, m) BOOST_PP_FOR_157_C(BOOST_PP_BOOL(p##(158, s)), s, p, o, m) # define BOOST_PP_FOR_158(s, p, o, m) BOOST_PP_FOR_158_C(BOOST_PP_BOOL(p##(159, s)), s, p, o, m) # define BOOST_PP_FOR_159(s, p, o, m) BOOST_PP_FOR_159_C(BOOST_PP_BOOL(p##(160, s)), s, p, o, m) # define BOOST_PP_FOR_160(s, p, o, m) BOOST_PP_FOR_160_C(BOOST_PP_BOOL(p##(161, s)), s, p, o, m) # define BOOST_PP_FOR_161(s, p, o, m) BOOST_PP_FOR_161_C(BOOST_PP_BOOL(p##(162, s)), s, p, o, m) # define BOOST_PP_FOR_162(s, p, o, m) BOOST_PP_FOR_162_C(BOOST_PP_BOOL(p##(163, s)), s, p, o, m) # define BOOST_PP_FOR_163(s, p, o, m) BOOST_PP_FOR_163_C(BOOST_PP_BOOL(p##(164, s)), s, p, o, m) # define BOOST_PP_FOR_164(s, p, o, m) BOOST_PP_FOR_164_C(BOOST_PP_BOOL(p##(165, s)), s, p, o, m) # define BOOST_PP_FOR_165(s, p, o, m) BOOST_PP_FOR_165_C(BOOST_PP_BOOL(p##(166, s)), s, p, o, m) # define BOOST_PP_FOR_166(s, p, o, m) BOOST_PP_FOR_166_C(BOOST_PP_BOOL(p##(167, s)), s, p, o, m) # define BOOST_PP_FOR_167(s, p, o, m) BOOST_PP_FOR_167_C(BOOST_PP_BOOL(p##(168, s)), s, p, o, m) # define BOOST_PP_FOR_168(s, p, o, m) BOOST_PP_FOR_168_C(BOOST_PP_BOOL(p##(169, s)), s, p, o, m) # define BOOST_PP_FOR_169(s, p, o, m) BOOST_PP_FOR_169_C(BOOST_PP_BOOL(p##(170, s)), s, p, o, m) # define BOOST_PP_FOR_170(s, p, o, m) BOOST_PP_FOR_170_C(BOOST_PP_BOOL(p##(171, s)), s, p, o, m) # define BOOST_PP_FOR_171(s, p, o, m) BOOST_PP_FOR_171_C(BOOST_PP_BOOL(p##(172, s)), s, p, o, m) # define BOOST_PP_FOR_172(s, p, o, m) BOOST_PP_FOR_172_C(BOOST_PP_BOOL(p##(173, s)), s, p, o, m) # define BOOST_PP_FOR_173(s, p, o, m) BOOST_PP_FOR_173_C(BOOST_PP_BOOL(p##(174, s)), s, p, o, m) # define BOOST_PP_FOR_174(s, p, o, m) BOOST_PP_FOR_174_C(BOOST_PP_BOOL(p##(175, s)), s, p, o, m) # define BOOST_PP_FOR_175(s, p, o, m) BOOST_PP_FOR_175_C(BOOST_PP_BOOL(p##(176, s)), s, p, o, m) # define BOOST_PP_FOR_176(s, p, o, m) BOOST_PP_FOR_176_C(BOOST_PP_BOOL(p##(177, s)), s, p, o, m) # define BOOST_PP_FOR_177(s, p, o, m) BOOST_PP_FOR_177_C(BOOST_PP_BOOL(p##(178, s)), s, p, o, m) # define BOOST_PP_FOR_178(s, p, o, m) BOOST_PP_FOR_178_C(BOOST_PP_BOOL(p##(179, s)), s, p, o, m) # define BOOST_PP_FOR_179(s, p, o, m) BOOST_PP_FOR_179_C(BOOST_PP_BOOL(p##(180, s)), s, p, o, m) # define BOOST_PP_FOR_180(s, p, o, m) BOOST_PP_FOR_180_C(BOOST_PP_BOOL(p##(181, s)), s, p, o, m) # define BOOST_PP_FOR_181(s, p, o, m) BOOST_PP_FOR_181_C(BOOST_PP_BOOL(p##(182, s)), s, p, o, m) # define BOOST_PP_FOR_182(s, p, o, m) BOOST_PP_FOR_182_C(BOOST_PP_BOOL(p##(183, s)), s, p, o, m) # define BOOST_PP_FOR_183(s, p, o, m) BOOST_PP_FOR_183_C(BOOST_PP_BOOL(p##(184, s)), s, p, o, m) # define BOOST_PP_FOR_184(s, p, o, m) BOOST_PP_FOR_184_C(BOOST_PP_BOOL(p##(185, s)), s, p, o, m) # define BOOST_PP_FOR_185(s, p, o, m) BOOST_PP_FOR_185_C(BOOST_PP_BOOL(p##(186, s)), s, p, o, m) # define BOOST_PP_FOR_186(s, p, o, m) BOOST_PP_FOR_186_C(BOOST_PP_BOOL(p##(187, s)), s, p, o, m) # define BOOST_PP_FOR_187(s, p, o, m) BOOST_PP_FOR_187_C(BOOST_PP_BOOL(p##(188, s)), s, p, o, m) # define BOOST_PP_FOR_188(s, p, o, m) BOOST_PP_FOR_188_C(BOOST_PP_BOOL(p##(189, s)), s, p, o, m) # define BOOST_PP_FOR_189(s, p, o, m) BOOST_PP_FOR_189_C(BOOST_PP_BOOL(p##(190, s)), s, p, o, m) # define BOOST_PP_FOR_190(s, p, o, m) BOOST_PP_FOR_190_C(BOOST_PP_BOOL(p##(191, s)), s, p, o, m) # define BOOST_PP_FOR_191(s, p, o, m) BOOST_PP_FOR_191_C(BOOST_PP_BOOL(p##(192, s)), s, p, o, m) # define BOOST_PP_FOR_192(s, p, o, m) BOOST_PP_FOR_192_C(BOOST_PP_BOOL(p##(193, s)), s, p, o, m) # define BOOST_PP_FOR_193(s, p, o, m) BOOST_PP_FOR_193_C(BOOST_PP_BOOL(p##(194, s)), s, p, o, m) # define BOOST_PP_FOR_194(s, p, o, m) BOOST_PP_FOR_194_C(BOOST_PP_BOOL(p##(195, s)), s, p, o, m) # define BOOST_PP_FOR_195(s, p, o, m) BOOST_PP_FOR_195_C(BOOST_PP_BOOL(p##(196, s)), s, p, o, m) # define BOOST_PP_FOR_196(s, p, o, m) BOOST_PP_FOR_196_C(BOOST_PP_BOOL(p##(197, s)), s, p, o, m) # define BOOST_PP_FOR_197(s, p, o, m) BOOST_PP_FOR_197_C(BOOST_PP_BOOL(p##(198, s)), s, p, o, m) # define BOOST_PP_FOR_198(s, p, o, m) BOOST_PP_FOR_198_C(BOOST_PP_BOOL(p##(199, s)), s, p, o, m) # define BOOST_PP_FOR_199(s, p, o, m) BOOST_PP_FOR_199_C(BOOST_PP_BOOL(p##(200, s)), s, p, o, m) # define BOOST_PP_FOR_200(s, p, o, m) BOOST_PP_FOR_200_C(BOOST_PP_BOOL(p##(201, s)), s, p, o, m) # define BOOST_PP_FOR_201(s, p, o, m) BOOST_PP_FOR_201_C(BOOST_PP_BOOL(p##(202, s)), s, p, o, m) # define BOOST_PP_FOR_202(s, p, o, m) BOOST_PP_FOR_202_C(BOOST_PP_BOOL(p##(203, s)), s, p, o, m) # define BOOST_PP_FOR_203(s, p, o, m) BOOST_PP_FOR_203_C(BOOST_PP_BOOL(p##(204, s)), s, p, o, m) # define BOOST_PP_FOR_204(s, p, o, m) BOOST_PP_FOR_204_C(BOOST_PP_BOOL(p##(205, s)), s, p, o, m) # define BOOST_PP_FOR_205(s, p, o, m) BOOST_PP_FOR_205_C(BOOST_PP_BOOL(p##(206, s)), s, p, o, m) # define BOOST_PP_FOR_206(s, p, o, m) BOOST_PP_FOR_206_C(BOOST_PP_BOOL(p##(207, s)), s, p, o, m) # define BOOST_PP_FOR_207(s, p, o, m) BOOST_PP_FOR_207_C(BOOST_PP_BOOL(p##(208, s)), s, p, o, m) # define BOOST_PP_FOR_208(s, p, o, m) BOOST_PP_FOR_208_C(BOOST_PP_BOOL(p##(209, s)), s, p, o, m) # define BOOST_PP_FOR_209(s, p, o, m) BOOST_PP_FOR_209_C(BOOST_PP_BOOL(p##(210, s)), s, p, o, m) # define BOOST_PP_FOR_210(s, p, o, m) BOOST_PP_FOR_210_C(BOOST_PP_BOOL(p##(211, s)), s, p, o, m) # define BOOST_PP_FOR_211(s, p, o, m) BOOST_PP_FOR_211_C(BOOST_PP_BOOL(p##(212, s)), s, p, o, m) # define BOOST_PP_FOR_212(s, p, o, m) BOOST_PP_FOR_212_C(BOOST_PP_BOOL(p##(213, s)), s, p, o, m) # define BOOST_PP_FOR_213(s, p, o, m) BOOST_PP_FOR_213_C(BOOST_PP_BOOL(p##(214, s)), s, p, o, m) # define BOOST_PP_FOR_214(s, p, o, m) BOOST_PP_FOR_214_C(BOOST_PP_BOOL(p##(215, s)), s, p, o, m) # define BOOST_PP_FOR_215(s, p, o, m) BOOST_PP_FOR_215_C(BOOST_PP_BOOL(p##(216, s)), s, p, o, m) # define BOOST_PP_FOR_216(s, p, o, m) BOOST_PP_FOR_216_C(BOOST_PP_BOOL(p##(217, s)), s, p, o, m) # define BOOST_PP_FOR_217(s, p, o, m) BOOST_PP_FOR_217_C(BOOST_PP_BOOL(p##(218, s)), s, p, o, m) # define BOOST_PP_FOR_218(s, p, o, m) BOOST_PP_FOR_218_C(BOOST_PP_BOOL(p##(219, s)), s, p, o, m) # define BOOST_PP_FOR_219(s, p, o, m) BOOST_PP_FOR_219_C(BOOST_PP_BOOL(p##(220, s)), s, p, o, m) # define BOOST_PP_FOR_220(s, p, o, m) BOOST_PP_FOR_220_C(BOOST_PP_BOOL(p##(221, s)), s, p, o, m) # define BOOST_PP_FOR_221(s, p, o, m) BOOST_PP_FOR_221_C(BOOST_PP_BOOL(p##(222, s)), s, p, o, m) # define BOOST_PP_FOR_222(s, p, o, m) BOOST_PP_FOR_222_C(BOOST_PP_BOOL(p##(223, s)), s, p, o, m) # define BOOST_PP_FOR_223(s, p, o, m) BOOST_PP_FOR_223_C(BOOST_PP_BOOL(p##(224, s)), s, p, o, m) # define BOOST_PP_FOR_224(s, p, o, m) BOOST_PP_FOR_224_C(BOOST_PP_BOOL(p##(225, s)), s, p, o, m) # define BOOST_PP_FOR_225(s, p, o, m) BOOST_PP_FOR_225_C(BOOST_PP_BOOL(p##(226, s)), s, p, o, m) # define BOOST_PP_FOR_226(s, p, o, m) BOOST_PP_FOR_226_C(BOOST_PP_BOOL(p##(227, s)), s, p, o, m) # define BOOST_PP_FOR_227(s, p, o, m) BOOST_PP_FOR_227_C(BOOST_PP_BOOL(p##(228, s)), s, p, o, m) # define BOOST_PP_FOR_228(s, p, o, m) BOOST_PP_FOR_228_C(BOOST_PP_BOOL(p##(229, s)), s, p, o, m) # define BOOST_PP_FOR_229(s, p, o, m) BOOST_PP_FOR_229_C(BOOST_PP_BOOL(p##(230, s)), s, p, o, m) # define BOOST_PP_FOR_230(s, p, o, m) BOOST_PP_FOR_230_C(BOOST_PP_BOOL(p##(231, s)), s, p, o, m) # define BOOST_PP_FOR_231(s, p, o, m) BOOST_PP_FOR_231_C(BOOST_PP_BOOL(p##(232, s)), s, p, o, m) # define BOOST_PP_FOR_232(s, p, o, m) BOOST_PP_FOR_232_C(BOOST_PP_BOOL(p##(233, s)), s, p, o, m) # define BOOST_PP_FOR_233(s, p, o, m) BOOST_PP_FOR_233_C(BOOST_PP_BOOL(p##(234, s)), s, p, o, m) # define BOOST_PP_FOR_234(s, p, o, m) BOOST_PP_FOR_234_C(BOOST_PP_BOOL(p##(235, s)), s, p, o, m) # define BOOST_PP_FOR_235(s, p, o, m) BOOST_PP_FOR_235_C(BOOST_PP_BOOL(p##(236, s)), s, p, o, m) # define BOOST_PP_FOR_236(s, p, o, m) BOOST_PP_FOR_236_C(BOOST_PP_BOOL(p##(237, s)), s, p, o, m) # define BOOST_PP_FOR_237(s, p, o, m) BOOST_PP_FOR_237_C(BOOST_PP_BOOL(p##(238, s)), s, p, o, m) # define BOOST_PP_FOR_238(s, p, o, m) BOOST_PP_FOR_238_C(BOOST_PP_BOOL(p##(239, s)), s, p, o, m) # define BOOST_PP_FOR_239(s, p, o, m) BOOST_PP_FOR_239_C(BOOST_PP_BOOL(p##(240, s)), s, p, o, m) # define BOOST_PP_FOR_240(s, p, o, m) BOOST_PP_FOR_240_C(BOOST_PP_BOOL(p##(241, s)), s, p, o, m) # define BOOST_PP_FOR_241(s, p, o, m) BOOST_PP_FOR_241_C(BOOST_PP_BOOL(p##(242, s)), s, p, o, m) # define BOOST_PP_FOR_242(s, p, o, m) BOOST_PP_FOR_242_C(BOOST_PP_BOOL(p##(243, s)), s, p, o, m) # define BOOST_PP_FOR_243(s, p, o, m) BOOST_PP_FOR_243_C(BOOST_PP_BOOL(p##(244, s)), s, p, o, m) # define BOOST_PP_FOR_244(s, p, o, m) BOOST_PP_FOR_244_C(BOOST_PP_BOOL(p##(245, s)), s, p, o, m) # define BOOST_PP_FOR_245(s, p, o, m) BOOST_PP_FOR_245_C(BOOST_PP_BOOL(p##(246, s)), s, p, o, m) # define BOOST_PP_FOR_246(s, p, o, m) BOOST_PP_FOR_246_C(BOOST_PP_BOOL(p##(247, s)), s, p, o, m) # define BOOST_PP_FOR_247(s, p, o, m) BOOST_PP_FOR_247_C(BOOST_PP_BOOL(p##(248, s)), s, p, o, m) # define BOOST_PP_FOR_248(s, p, o, m) BOOST_PP_FOR_248_C(BOOST_PP_BOOL(p##(249, s)), s, p, o, m) # define BOOST_PP_FOR_249(s, p, o, m) BOOST_PP_FOR_249_C(BOOST_PP_BOOL(p##(250, s)), s, p, o, m) # define BOOST_PP_FOR_250(s, p, o, m) BOOST_PP_FOR_250_C(BOOST_PP_BOOL(p##(251, s)), s, p, o, m) # define BOOST_PP_FOR_251(s, p, o, m) BOOST_PP_FOR_251_C(BOOST_PP_BOOL(p##(252, s)), s, p, o, m) # define BOOST_PP_FOR_252(s, p, o, m) BOOST_PP_FOR_252_C(BOOST_PP_BOOL(p##(253, s)), s, p, o, m) # define BOOST_PP_FOR_253(s, p, o, m) BOOST_PP_FOR_253_C(BOOST_PP_BOOL(p##(254, s)), s, p, o, m) # define BOOST_PP_FOR_254(s, p, o, m) BOOST_PP_FOR_254_C(BOOST_PP_BOOL(p##(255, s)), s, p, o, m) # define BOOST_PP_FOR_255(s, p, o, m) BOOST_PP_FOR_255_C(BOOST_PP_BOOL(p##(256, s)), s, p, o, m) # define BOOST_PP_FOR_256(s, p, o, m) BOOST_PP_FOR_256_C(BOOST_PP_BOOL(p##(257, s)), s, p, o, m) # # define BOOST_PP_FOR_1_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IIF(c, BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(2, s), p, o, m) # define BOOST_PP_FOR_2_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IIF(c, BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(3, s), p, o, m) # define BOOST_PP_FOR_3_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IIF(c, BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(4, s), p, o, m) # define BOOST_PP_FOR_4_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IIF(c, BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(5, s), p, o, m) # define BOOST_PP_FOR_5_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IIF(c, BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(6, s), p, o, m) # define BOOST_PP_FOR_6_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IIF(c, BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(7, s), p, o, m) # define BOOST_PP_FOR_7_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IIF(c, BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(8, s), p, o, m) # define BOOST_PP_FOR_8_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IIF(c, BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(9, s), p, o, m) # define BOOST_PP_FOR_9_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IIF(c, BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(10, s), p, o, m) # define BOOST_PP_FOR_10_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IIF(c, BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(11, s), p, o, m) # define BOOST_PP_FOR_11_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IIF(c, BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(12, s), p, o, m) # define BOOST_PP_FOR_12_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IIF(c, BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(13, s), p, o, m) # define BOOST_PP_FOR_13_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IIF(c, BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(14, s), p, o, m) # define BOOST_PP_FOR_14_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IIF(c, BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(15, s), p, o, m) # define BOOST_PP_FOR_15_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IIF(c, BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(16, s), p, o, m) # define BOOST_PP_FOR_16_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IIF(c, BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(17, s), p, o, m) # define BOOST_PP_FOR_17_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IIF(c, BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(18, s), p, o, m) # define BOOST_PP_FOR_18_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IIF(c, BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(19, s), p, o, m) # define BOOST_PP_FOR_19_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IIF(c, BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(20, s), p, o, m) # define BOOST_PP_FOR_20_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IIF(c, BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(21, s), p, o, m) # define BOOST_PP_FOR_21_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IIF(c, BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(22, s), p, o, m) # define BOOST_PP_FOR_22_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IIF(c, BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(23, s), p, o, m) # define BOOST_PP_FOR_23_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IIF(c, BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(24, s), p, o, m) # define BOOST_PP_FOR_24_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IIF(c, BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(25, s), p, o, m) # define BOOST_PP_FOR_25_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IIF(c, BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(26, s), p, o, m) # define BOOST_PP_FOR_26_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IIF(c, BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(27, s), p, o, m) # define BOOST_PP_FOR_27_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IIF(c, BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(28, s), p, o, m) # define BOOST_PP_FOR_28_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IIF(c, BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(29, s), p, o, m) # define BOOST_PP_FOR_29_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IIF(c, BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(30, s), p, o, m) # define BOOST_PP_FOR_30_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IIF(c, BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(31, s), p, o, m) # define BOOST_PP_FOR_31_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IIF(c, BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(32, s), p, o, m) # define BOOST_PP_FOR_32_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IIF(c, BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(33, s), p, o, m) # define BOOST_PP_FOR_33_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IIF(c, BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(34, s), p, o, m) # define BOOST_PP_FOR_34_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IIF(c, BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(35, s), p, o, m) # define BOOST_PP_FOR_35_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IIF(c, BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(36, s), p, o, m) # define BOOST_PP_FOR_36_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IIF(c, BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(37, s), p, o, m) # define BOOST_PP_FOR_37_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IIF(c, BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(38, s), p, o, m) # define BOOST_PP_FOR_38_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IIF(c, BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(39, s), p, o, m) # define BOOST_PP_FOR_39_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IIF(c, BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(40, s), p, o, m) # define BOOST_PP_FOR_40_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IIF(c, BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(41, s), p, o, m) # define BOOST_PP_FOR_41_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IIF(c, BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(42, s), p, o, m) # define BOOST_PP_FOR_42_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IIF(c, BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(43, s), p, o, m) # define BOOST_PP_FOR_43_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IIF(c, BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(44, s), p, o, m) # define BOOST_PP_FOR_44_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IIF(c, BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(45, s), p, o, m) # define BOOST_PP_FOR_45_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IIF(c, BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(46, s), p, o, m) # define BOOST_PP_FOR_46_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IIF(c, BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(47, s), p, o, m) # define BOOST_PP_FOR_47_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IIF(c, BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(48, s), p, o, m) # define BOOST_PP_FOR_48_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IIF(c, BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(49, s), p, o, m) # define BOOST_PP_FOR_49_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IIF(c, BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(50, s), p, o, m) # define BOOST_PP_FOR_50_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IIF(c, BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(51, s), p, o, m) # define BOOST_PP_FOR_51_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IIF(c, BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(52, s), p, o, m) # define BOOST_PP_FOR_52_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IIF(c, BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(53, s), p, o, m) # define BOOST_PP_FOR_53_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IIF(c, BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(54, s), p, o, m) # define BOOST_PP_FOR_54_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IIF(c, BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(55, s), p, o, m) # define BOOST_PP_FOR_55_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IIF(c, BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(56, s), p, o, m) # define BOOST_PP_FOR_56_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IIF(c, BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(57, s), p, o, m) # define BOOST_PP_FOR_57_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IIF(c, BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(58, s), p, o, m) # define BOOST_PP_FOR_58_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IIF(c, BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(59, s), p, o, m) # define BOOST_PP_FOR_59_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IIF(c, BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(60, s), p, o, m) # define BOOST_PP_FOR_60_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IIF(c, BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(61, s), p, o, m) # define BOOST_PP_FOR_61_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IIF(c, BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(62, s), p, o, m) # define BOOST_PP_FOR_62_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IIF(c, BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(63, s), p, o, m) # define BOOST_PP_FOR_63_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IIF(c, BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(64, s), p, o, m) # define BOOST_PP_FOR_64_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IIF(c, BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(65, s), p, o, m) # define BOOST_PP_FOR_65_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IIF(c, BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(66, s), p, o, m) # define BOOST_PP_FOR_66_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IIF(c, BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(67, s), p, o, m) # define BOOST_PP_FOR_67_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IIF(c, BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(68, s), p, o, m) # define BOOST_PP_FOR_68_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IIF(c, BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(69, s), p, o, m) # define BOOST_PP_FOR_69_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IIF(c, BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(70, s), p, o, m) # define BOOST_PP_FOR_70_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IIF(c, BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(71, s), p, o, m) # define BOOST_PP_FOR_71_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IIF(c, BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(72, s), p, o, m) # define BOOST_PP_FOR_72_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IIF(c, BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(73, s), p, o, m) # define BOOST_PP_FOR_73_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IIF(c, BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(74, s), p, o, m) # define BOOST_PP_FOR_74_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IIF(c, BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(75, s), p, o, m) # define BOOST_PP_FOR_75_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IIF(c, BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(76, s), p, o, m) # define BOOST_PP_FOR_76_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IIF(c, BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(77, s), p, o, m) # define BOOST_PP_FOR_77_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IIF(c, BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(78, s), p, o, m) # define BOOST_PP_FOR_78_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IIF(c, BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(79, s), p, o, m) # define BOOST_PP_FOR_79_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IIF(c, BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(80, s), p, o, m) # define BOOST_PP_FOR_80_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IIF(c, BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(81, s), p, o, m) # define BOOST_PP_FOR_81_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IIF(c, BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(82, s), p, o, m) # define BOOST_PP_FOR_82_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IIF(c, BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(83, s), p, o, m) # define BOOST_PP_FOR_83_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IIF(c, BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(84, s), p, o, m) # define BOOST_PP_FOR_84_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IIF(c, BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(85, s), p, o, m) # define BOOST_PP_FOR_85_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IIF(c, BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(86, s), p, o, m) # define BOOST_PP_FOR_86_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IIF(c, BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(87, s), p, o, m) # define BOOST_PP_FOR_87_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IIF(c, BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(88, s), p, o, m) # define BOOST_PP_FOR_88_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IIF(c, BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(89, s), p, o, m) # define BOOST_PP_FOR_89_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IIF(c, BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(90, s), p, o, m) # define BOOST_PP_FOR_90_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IIF(c, BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(91, s), p, o, m) # define BOOST_PP_FOR_91_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IIF(c, BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(92, s), p, o, m) # define BOOST_PP_FOR_92_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IIF(c, BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(93, s), p, o, m) # define BOOST_PP_FOR_93_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IIF(c, BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(94, s), p, o, m) # define BOOST_PP_FOR_94_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IIF(c, BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(95, s), p, o, m) # define BOOST_PP_FOR_95_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IIF(c, BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(96, s), p, o, m) # define BOOST_PP_FOR_96_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IIF(c, BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(97, s), p, o, m) # define BOOST_PP_FOR_97_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IIF(c, BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(98, s), p, o, m) # define BOOST_PP_FOR_98_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IIF(c, BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(99, s), p, o, m) # define BOOST_PP_FOR_99_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IIF(c, BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(100, s), p, o, m) # define BOOST_PP_FOR_100_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IIF(c, BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(101, s), p, o, m) # define BOOST_PP_FOR_101_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IIF(c, BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(102, s), p, o, m) # define BOOST_PP_FOR_102_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IIF(c, BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(103, s), p, o, m) # define BOOST_PP_FOR_103_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IIF(c, BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(104, s), p, o, m) # define BOOST_PP_FOR_104_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IIF(c, BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(105, s), p, o, m) # define BOOST_PP_FOR_105_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IIF(c, BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(106, s), p, o, m) # define BOOST_PP_FOR_106_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IIF(c, BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(107, s), p, o, m) # define BOOST_PP_FOR_107_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IIF(c, BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(108, s), p, o, m) # define BOOST_PP_FOR_108_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IIF(c, BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(109, s), p, o, m) # define BOOST_PP_FOR_109_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IIF(c, BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(110, s), p, o, m) # define BOOST_PP_FOR_110_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IIF(c, BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(111, s), p, o, m) # define BOOST_PP_FOR_111_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IIF(c, BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(112, s), p, o, m) # define BOOST_PP_FOR_112_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IIF(c, BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(113, s), p, o, m) # define BOOST_PP_FOR_113_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IIF(c, BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(114, s), p, o, m) # define BOOST_PP_FOR_114_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IIF(c, BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(115, s), p, o, m) # define BOOST_PP_FOR_115_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IIF(c, BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(116, s), p, o, m) # define BOOST_PP_FOR_116_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IIF(c, BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(117, s), p, o, m) # define BOOST_PP_FOR_117_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IIF(c, BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(118, s), p, o, m) # define BOOST_PP_FOR_118_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IIF(c, BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(119, s), p, o, m) # define BOOST_PP_FOR_119_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IIF(c, BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(120, s), p, o, m) # define BOOST_PP_FOR_120_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IIF(c, BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(121, s), p, o, m) # define BOOST_PP_FOR_121_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IIF(c, BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(122, s), p, o, m) # define BOOST_PP_FOR_122_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IIF(c, BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(123, s), p, o, m) # define BOOST_PP_FOR_123_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IIF(c, BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(124, s), p, o, m) # define BOOST_PP_FOR_124_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IIF(c, BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(125, s), p, o, m) # define BOOST_PP_FOR_125_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IIF(c, BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(126, s), p, o, m) # define BOOST_PP_FOR_126_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IIF(c, BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(127, s), p, o, m) # define BOOST_PP_FOR_127_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IIF(c, BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(128, s), p, o, m) # define BOOST_PP_FOR_128_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IIF(c, BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(129, s), p, o, m) # define BOOST_PP_FOR_129_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IIF(c, BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(130, s), p, o, m) # define BOOST_PP_FOR_130_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IIF(c, BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(131, s), p, o, m) # define BOOST_PP_FOR_131_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IIF(c, BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(132, s), p, o, m) # define BOOST_PP_FOR_132_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IIF(c, BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(133, s), p, o, m) # define BOOST_PP_FOR_133_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IIF(c, BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(134, s), p, o, m) # define BOOST_PP_FOR_134_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IIF(c, BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(135, s), p, o, m) # define BOOST_PP_FOR_135_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IIF(c, BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(136, s), p, o, m) # define BOOST_PP_FOR_136_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IIF(c, BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(137, s), p, o, m) # define BOOST_PP_FOR_137_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IIF(c, BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(138, s), p, o, m) # define BOOST_PP_FOR_138_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IIF(c, BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(139, s), p, o, m) # define BOOST_PP_FOR_139_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IIF(c, BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(140, s), p, o, m) # define BOOST_PP_FOR_140_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IIF(c, BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(141, s), p, o, m) # define BOOST_PP_FOR_141_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IIF(c, BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(142, s), p, o, m) # define BOOST_PP_FOR_142_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IIF(c, BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(143, s), p, o, m) # define BOOST_PP_FOR_143_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IIF(c, BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(144, s), p, o, m) # define BOOST_PP_FOR_144_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IIF(c, BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(145, s), p, o, m) # define BOOST_PP_FOR_145_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IIF(c, BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(146, s), p, o, m) # define BOOST_PP_FOR_146_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IIF(c, BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(147, s), p, o, m) # define BOOST_PP_FOR_147_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IIF(c, BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(148, s), p, o, m) # define BOOST_PP_FOR_148_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IIF(c, BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(149, s), p, o, m) # define BOOST_PP_FOR_149_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IIF(c, BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(150, s), p, o, m) # define BOOST_PP_FOR_150_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IIF(c, BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(151, s), p, o, m) # define BOOST_PP_FOR_151_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IIF(c, BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(152, s), p, o, m) # define BOOST_PP_FOR_152_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IIF(c, BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(153, s), p, o, m) # define BOOST_PP_FOR_153_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IIF(c, BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(154, s), p, o, m) # define BOOST_PP_FOR_154_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IIF(c, BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(155, s), p, o, m) # define BOOST_PP_FOR_155_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IIF(c, BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(156, s), p, o, m) # define BOOST_PP_FOR_156_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IIF(c, BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(157, s), p, o, m) # define BOOST_PP_FOR_157_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IIF(c, BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(158, s), p, o, m) # define BOOST_PP_FOR_158_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IIF(c, BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(159, s), p, o, m) # define BOOST_PP_FOR_159_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IIF(c, BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(160, s), p, o, m) # define BOOST_PP_FOR_160_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IIF(c, BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(161, s), p, o, m) # define BOOST_PP_FOR_161_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IIF(c, BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(162, s), p, o, m) # define BOOST_PP_FOR_162_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IIF(c, BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(163, s), p, o, m) # define BOOST_PP_FOR_163_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IIF(c, BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(164, s), p, o, m) # define BOOST_PP_FOR_164_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IIF(c, BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(165, s), p, o, m) # define BOOST_PP_FOR_165_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IIF(c, BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(166, s), p, o, m) # define BOOST_PP_FOR_166_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IIF(c, BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(167, s), p, o, m) # define BOOST_PP_FOR_167_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IIF(c, BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(168, s), p, o, m) # define BOOST_PP_FOR_168_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IIF(c, BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(169, s), p, o, m) # define BOOST_PP_FOR_169_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IIF(c, BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(170, s), p, o, m) # define BOOST_PP_FOR_170_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IIF(c, BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(171, s), p, o, m) # define BOOST_PP_FOR_171_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IIF(c, BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(172, s), p, o, m) # define BOOST_PP_FOR_172_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IIF(c, BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(173, s), p, o, m) # define BOOST_PP_FOR_173_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IIF(c, BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(174, s), p, o, m) # define BOOST_PP_FOR_174_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IIF(c, BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(175, s), p, o, m) # define BOOST_PP_FOR_175_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IIF(c, BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(176, s), p, o, m) # define BOOST_PP_FOR_176_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IIF(c, BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(177, s), p, o, m) # define BOOST_PP_FOR_177_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IIF(c, BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(178, s), p, o, m) # define BOOST_PP_FOR_178_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IIF(c, BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(179, s), p, o, m) # define BOOST_PP_FOR_179_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IIF(c, BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(180, s), p, o, m) # define BOOST_PP_FOR_180_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IIF(c, BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(181, s), p, o, m) # define BOOST_PP_FOR_181_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IIF(c, BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(182, s), p, o, m) # define BOOST_PP_FOR_182_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IIF(c, BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(183, s), p, o, m) # define BOOST_PP_FOR_183_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IIF(c, BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(184, s), p, o, m) # define BOOST_PP_FOR_184_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IIF(c, BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(185, s), p, o, m) # define BOOST_PP_FOR_185_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IIF(c, BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(186, s), p, o, m) # define BOOST_PP_FOR_186_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IIF(c, BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(187, s), p, o, m) # define BOOST_PP_FOR_187_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IIF(c, BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(188, s), p, o, m) # define BOOST_PP_FOR_188_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IIF(c, BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(189, s), p, o, m) # define BOOST_PP_FOR_189_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IIF(c, BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(190, s), p, o, m) # define BOOST_PP_FOR_190_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IIF(c, BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(191, s), p, o, m) # define BOOST_PP_FOR_191_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IIF(c, BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(192, s), p, o, m) # define BOOST_PP_FOR_192_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IIF(c, BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(193, s), p, o, m) # define BOOST_PP_FOR_193_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IIF(c, BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(194, s), p, o, m) # define BOOST_PP_FOR_194_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IIF(c, BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(195, s), p, o, m) # define BOOST_PP_FOR_195_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IIF(c, BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(196, s), p, o, m) # define BOOST_PP_FOR_196_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IIF(c, BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(197, s), p, o, m) # define BOOST_PP_FOR_197_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IIF(c, BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(198, s), p, o, m) # define BOOST_PP_FOR_198_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IIF(c, BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(199, s), p, o, m) # define BOOST_PP_FOR_199_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IIF(c, BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(200, s), p, o, m) # define BOOST_PP_FOR_200_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IIF(c, BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(201, s), p, o, m) # define BOOST_PP_FOR_201_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IIF(c, BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(202, s), p, o, m) # define BOOST_PP_FOR_202_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IIF(c, BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(203, s), p, o, m) # define BOOST_PP_FOR_203_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IIF(c, BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(204, s), p, o, m) # define BOOST_PP_FOR_204_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IIF(c, BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(205, s), p, o, m) # define BOOST_PP_FOR_205_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IIF(c, BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(206, s), p, o, m) # define BOOST_PP_FOR_206_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IIF(c, BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(207, s), p, o, m) # define BOOST_PP_FOR_207_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IIF(c, BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(208, s), p, o, m) # define BOOST_PP_FOR_208_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IIF(c, BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(209, s), p, o, m) # define BOOST_PP_FOR_209_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IIF(c, BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(210, s), p, o, m) # define BOOST_PP_FOR_210_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IIF(c, BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(211, s), p, o, m) # define BOOST_PP_FOR_211_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IIF(c, BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(212, s), p, o, m) # define BOOST_PP_FOR_212_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IIF(c, BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(213, s), p, o, m) # define BOOST_PP_FOR_213_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IIF(c, BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(214, s), p, o, m) # define BOOST_PP_FOR_214_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IIF(c, BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(215, s), p, o, m) # define BOOST_PP_FOR_215_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IIF(c, BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(216, s), p, o, m) # define BOOST_PP_FOR_216_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IIF(c, BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(217, s), p, o, m) # define BOOST_PP_FOR_217_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IIF(c, BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(218, s), p, o, m) # define BOOST_PP_FOR_218_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IIF(c, BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(219, s), p, o, m) # define BOOST_PP_FOR_219_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IIF(c, BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(220, s), p, o, m) # define BOOST_PP_FOR_220_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IIF(c, BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(221, s), p, o, m) # define BOOST_PP_FOR_221_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IIF(c, BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(222, s), p, o, m) # define BOOST_PP_FOR_222_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IIF(c, BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(223, s), p, o, m) # define BOOST_PP_FOR_223_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IIF(c, BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(224, s), p, o, m) # define BOOST_PP_FOR_224_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IIF(c, BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(225, s), p, o, m) # define BOOST_PP_FOR_225_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IIF(c, BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(226, s), p, o, m) # define BOOST_PP_FOR_226_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IIF(c, BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(227, s), p, o, m) # define BOOST_PP_FOR_227_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IIF(c, BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(228, s), p, o, m) # define BOOST_PP_FOR_228_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IIF(c, BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(229, s), p, o, m) # define BOOST_PP_FOR_229_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IIF(c, BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(230, s), p, o, m) # define BOOST_PP_FOR_230_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IIF(c, BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(231, s), p, o, m) # define BOOST_PP_FOR_231_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IIF(c, BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(232, s), p, o, m) # define BOOST_PP_FOR_232_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IIF(c, BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(233, s), p, o, m) # define BOOST_PP_FOR_233_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IIF(c, BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(234, s), p, o, m) # define BOOST_PP_FOR_234_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IIF(c, BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(235, s), p, o, m) # define BOOST_PP_FOR_235_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IIF(c, BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(236, s), p, o, m) # define BOOST_PP_FOR_236_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IIF(c, BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(237, s), p, o, m) # define BOOST_PP_FOR_237_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IIF(c, BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(238, s), p, o, m) # define BOOST_PP_FOR_238_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IIF(c, BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(239, s), p, o, m) # define BOOST_PP_FOR_239_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IIF(c, BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(240, s), p, o, m) # define BOOST_PP_FOR_240_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IIF(c, BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(241, s), p, o, m) # define BOOST_PP_FOR_241_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IIF(c, BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(242, s), p, o, m) # define BOOST_PP_FOR_242_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IIF(c, BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(243, s), p, o, m) # define BOOST_PP_FOR_243_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IIF(c, BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(244, s), p, o, m) # define BOOST_PP_FOR_244_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IIF(c, BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(245, s), p, o, m) # define BOOST_PP_FOR_245_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IIF(c, BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(246, s), p, o, m) # define BOOST_PP_FOR_246_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IIF(c, BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(247, s), p, o, m) # define BOOST_PP_FOR_247_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IIF(c, BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(248, s), p, o, m) # define BOOST_PP_FOR_248_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IIF(c, BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(249, s), p, o, m) # define BOOST_PP_FOR_249_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IIF(c, BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(250, s), p, o, m) # define BOOST_PP_FOR_250_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IIF(c, BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(251, s), p, o, m) # define BOOST_PP_FOR_251_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IIF(c, BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(252, s), p, o, m) # define BOOST_PP_FOR_252_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IIF(c, BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(253, s), p, o, m) # define BOOST_PP_FOR_253_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IIF(c, BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(254, s), p, o, m) # define BOOST_PP_FOR_254_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IIF(c, BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(255, s), p, o, m) # define BOOST_PP_FOR_255_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IIF(c, BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(256, s), p, o, m) # define BOOST_PP_FOR_256_C(c, s, p, o, m) BOOST_PP_IIF(c, m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IIF(c, BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(BOOST_PP_EXPR_IIF(c, o)(257, s), p, o, m) # # endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/edg/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000755000175000017500000000000012146213770031750 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/edg/for.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000017335411344301502031755 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_DETAIL_EDG_FOR_HPP # define BOOST_PREPROCESSOR_REPETITION_DETAIL_EDG_FOR_HPP # # include # include # # define BOOST_PP_FOR_1(s, p, o, m) BOOST_PP_FOR_1_I(s, p, o, m) # define BOOST_PP_FOR_2(s, p, o, m) BOOST_PP_FOR_2_I(s, p, o, m) # define BOOST_PP_FOR_3(s, p, o, m) BOOST_PP_FOR_3_I(s, p, o, m) # define BOOST_PP_FOR_4(s, p, o, m) BOOST_PP_FOR_4_I(s, p, o, m) # define BOOST_PP_FOR_5(s, p, o, m) BOOST_PP_FOR_5_I(s, p, o, m) # define BOOST_PP_FOR_6(s, p, o, m) BOOST_PP_FOR_6_I(s, p, o, m) # define BOOST_PP_FOR_7(s, p, o, m) BOOST_PP_FOR_7_I(s, p, o, m) # define BOOST_PP_FOR_8(s, p, o, m) BOOST_PP_FOR_8_I(s, p, o, m) # define BOOST_PP_FOR_9(s, p, o, m) BOOST_PP_FOR_9_I(s, p, o, m) # define BOOST_PP_FOR_10(s, p, o, m) BOOST_PP_FOR_10_I(s, p, o, m) # define BOOST_PP_FOR_11(s, p, o, m) BOOST_PP_FOR_11_I(s, p, o, m) # define BOOST_PP_FOR_12(s, p, o, m) BOOST_PP_FOR_12_I(s, p, o, m) # define BOOST_PP_FOR_13(s, p, o, m) BOOST_PP_FOR_13_I(s, p, o, m) # define BOOST_PP_FOR_14(s, p, o, m) BOOST_PP_FOR_14_I(s, p, o, m) # define BOOST_PP_FOR_15(s, p, o, m) BOOST_PP_FOR_15_I(s, p, o, m) # define BOOST_PP_FOR_16(s, p, o, m) BOOST_PP_FOR_16_I(s, p, o, m) # define BOOST_PP_FOR_17(s, p, o, m) BOOST_PP_FOR_17_I(s, p, o, m) # define BOOST_PP_FOR_18(s, p, o, m) BOOST_PP_FOR_18_I(s, p, o, m) # define BOOST_PP_FOR_19(s, p, o, m) BOOST_PP_FOR_19_I(s, p, o, m) # define BOOST_PP_FOR_20(s, p, o, m) BOOST_PP_FOR_20_I(s, p, o, m) # define BOOST_PP_FOR_21(s, p, o, m) BOOST_PP_FOR_21_I(s, p, o, m) # define BOOST_PP_FOR_22(s, p, o, m) BOOST_PP_FOR_22_I(s, p, o, m) # define BOOST_PP_FOR_23(s, p, o, m) BOOST_PP_FOR_23_I(s, p, o, m) # define BOOST_PP_FOR_24(s, p, o, m) BOOST_PP_FOR_24_I(s, p, o, m) # define BOOST_PP_FOR_25(s, p, o, m) BOOST_PP_FOR_25_I(s, p, o, m) # define BOOST_PP_FOR_26(s, p, o, m) BOOST_PP_FOR_26_I(s, p, o, m) # define BOOST_PP_FOR_27(s, p, o, m) BOOST_PP_FOR_27_I(s, p, o, m) # define BOOST_PP_FOR_28(s, p, o, m) BOOST_PP_FOR_28_I(s, p, o, m) # define BOOST_PP_FOR_29(s, p, o, m) BOOST_PP_FOR_29_I(s, p, o, m) # define BOOST_PP_FOR_30(s, p, o, m) BOOST_PP_FOR_30_I(s, p, o, m) # define BOOST_PP_FOR_31(s, p, o, m) BOOST_PP_FOR_31_I(s, p, o, m) # define BOOST_PP_FOR_32(s, p, o, m) BOOST_PP_FOR_32_I(s, p, o, m) # define BOOST_PP_FOR_33(s, p, o, m) BOOST_PP_FOR_33_I(s, p, o, m) # define BOOST_PP_FOR_34(s, p, o, m) BOOST_PP_FOR_34_I(s, p, o, m) # define BOOST_PP_FOR_35(s, p, o, m) BOOST_PP_FOR_35_I(s, p, o, m) # define BOOST_PP_FOR_36(s, p, o, m) BOOST_PP_FOR_36_I(s, p, o, m) # define BOOST_PP_FOR_37(s, p, o, m) BOOST_PP_FOR_37_I(s, p, o, m) # define BOOST_PP_FOR_38(s, p, o, m) BOOST_PP_FOR_38_I(s, p, o, m) # define BOOST_PP_FOR_39(s, p, o, m) BOOST_PP_FOR_39_I(s, p, o, m) # define BOOST_PP_FOR_40(s, p, o, m) BOOST_PP_FOR_40_I(s, p, o, m) # define BOOST_PP_FOR_41(s, p, o, m) BOOST_PP_FOR_41_I(s, p, o, m) # define BOOST_PP_FOR_42(s, p, o, m) BOOST_PP_FOR_42_I(s, p, o, m) # define BOOST_PP_FOR_43(s, p, o, m) BOOST_PP_FOR_43_I(s, p, o, m) # define BOOST_PP_FOR_44(s, p, o, m) BOOST_PP_FOR_44_I(s, p, o, m) # define BOOST_PP_FOR_45(s, p, o, m) BOOST_PP_FOR_45_I(s, p, o, m) # define BOOST_PP_FOR_46(s, p, o, m) BOOST_PP_FOR_46_I(s, p, o, m) # define BOOST_PP_FOR_47(s, p, o, m) BOOST_PP_FOR_47_I(s, p, o, m) # define BOOST_PP_FOR_48(s, p, o, m) BOOST_PP_FOR_48_I(s, p, o, m) # define BOOST_PP_FOR_49(s, p, o, m) BOOST_PP_FOR_49_I(s, p, o, m) # define BOOST_PP_FOR_50(s, p, o, m) BOOST_PP_FOR_50_I(s, p, o, m) # define BOOST_PP_FOR_51(s, p, o, m) BOOST_PP_FOR_51_I(s, p, o, m) # define BOOST_PP_FOR_52(s, p, o, m) BOOST_PP_FOR_52_I(s, p, o, m) # define BOOST_PP_FOR_53(s, p, o, m) BOOST_PP_FOR_53_I(s, p, o, m) # define BOOST_PP_FOR_54(s, p, o, m) BOOST_PP_FOR_54_I(s, p, o, m) # define BOOST_PP_FOR_55(s, p, o, m) BOOST_PP_FOR_55_I(s, p, o, m) # define BOOST_PP_FOR_56(s, p, o, m) BOOST_PP_FOR_56_I(s, p, o, m) # define BOOST_PP_FOR_57(s, p, o, m) BOOST_PP_FOR_57_I(s, p, o, m) # define BOOST_PP_FOR_58(s, p, o, m) BOOST_PP_FOR_58_I(s, p, o, m) # define BOOST_PP_FOR_59(s, p, o, m) BOOST_PP_FOR_59_I(s, p, o, m) # define BOOST_PP_FOR_60(s, p, o, m) BOOST_PP_FOR_60_I(s, p, o, m) # define BOOST_PP_FOR_61(s, p, o, m) BOOST_PP_FOR_61_I(s, p, o, m) # define BOOST_PP_FOR_62(s, p, o, m) BOOST_PP_FOR_62_I(s, p, o, m) # define BOOST_PP_FOR_63(s, p, o, m) BOOST_PP_FOR_63_I(s, p, o, m) # define BOOST_PP_FOR_64(s, p, o, m) BOOST_PP_FOR_64_I(s, p, o, m) # define BOOST_PP_FOR_65(s, p, o, m) BOOST_PP_FOR_65_I(s, p, o, m) # define BOOST_PP_FOR_66(s, p, o, m) BOOST_PP_FOR_66_I(s, p, o, m) # define BOOST_PP_FOR_67(s, p, o, m) BOOST_PP_FOR_67_I(s, p, o, m) # define BOOST_PP_FOR_68(s, p, o, m) BOOST_PP_FOR_68_I(s, p, o, m) # define BOOST_PP_FOR_69(s, p, o, m) BOOST_PP_FOR_69_I(s, p, o, m) # define BOOST_PP_FOR_70(s, p, o, m) BOOST_PP_FOR_70_I(s, p, o, m) # define BOOST_PP_FOR_71(s, p, o, m) BOOST_PP_FOR_71_I(s, p, o, m) # define BOOST_PP_FOR_72(s, p, o, m) BOOST_PP_FOR_72_I(s, p, o, m) # define BOOST_PP_FOR_73(s, p, o, m) BOOST_PP_FOR_73_I(s, p, o, m) # define BOOST_PP_FOR_74(s, p, o, m) BOOST_PP_FOR_74_I(s, p, o, m) # define BOOST_PP_FOR_75(s, p, o, m) BOOST_PP_FOR_75_I(s, p, o, m) # define BOOST_PP_FOR_76(s, p, o, m) BOOST_PP_FOR_76_I(s, p, o, m) # define BOOST_PP_FOR_77(s, p, o, m) BOOST_PP_FOR_77_I(s, p, o, m) # define BOOST_PP_FOR_78(s, p, o, m) BOOST_PP_FOR_78_I(s, p, o, m) # define BOOST_PP_FOR_79(s, p, o, m) BOOST_PP_FOR_79_I(s, p, o, m) # define BOOST_PP_FOR_80(s, p, o, m) BOOST_PP_FOR_80_I(s, p, o, m) # define BOOST_PP_FOR_81(s, p, o, m) BOOST_PP_FOR_81_I(s, p, o, m) # define BOOST_PP_FOR_82(s, p, o, m) BOOST_PP_FOR_82_I(s, p, o, m) # define BOOST_PP_FOR_83(s, p, o, m) BOOST_PP_FOR_83_I(s, p, o, m) # define BOOST_PP_FOR_84(s, p, o, m) BOOST_PP_FOR_84_I(s, p, o, m) # define BOOST_PP_FOR_85(s, p, o, m) BOOST_PP_FOR_85_I(s, p, o, m) # define BOOST_PP_FOR_86(s, p, o, m) BOOST_PP_FOR_86_I(s, p, o, m) # define BOOST_PP_FOR_87(s, p, o, m) BOOST_PP_FOR_87_I(s, p, o, m) # define BOOST_PP_FOR_88(s, p, o, m) BOOST_PP_FOR_88_I(s, p, o, m) # define BOOST_PP_FOR_89(s, p, o, m) BOOST_PP_FOR_89_I(s, p, o, m) # define BOOST_PP_FOR_90(s, p, o, m) BOOST_PP_FOR_90_I(s, p, o, m) # define BOOST_PP_FOR_91(s, p, o, m) BOOST_PP_FOR_91_I(s, p, o, m) # define BOOST_PP_FOR_92(s, p, o, m) BOOST_PP_FOR_92_I(s, p, o, m) # define BOOST_PP_FOR_93(s, p, o, m) BOOST_PP_FOR_93_I(s, p, o, m) # define BOOST_PP_FOR_94(s, p, o, m) BOOST_PP_FOR_94_I(s, p, o, m) # define BOOST_PP_FOR_95(s, p, o, m) BOOST_PP_FOR_95_I(s, p, o, m) # define BOOST_PP_FOR_96(s, p, o, m) BOOST_PP_FOR_96_I(s, p, o, m) # define BOOST_PP_FOR_97(s, p, o, m) BOOST_PP_FOR_97_I(s, p, o, m) # define BOOST_PP_FOR_98(s, p, o, m) BOOST_PP_FOR_98_I(s, p, o, m) # define BOOST_PP_FOR_99(s, p, o, m) BOOST_PP_FOR_99_I(s, p, o, m) # define BOOST_PP_FOR_100(s, p, o, m) BOOST_PP_FOR_100_I(s, p, o, m) # define BOOST_PP_FOR_101(s, p, o, m) BOOST_PP_FOR_101_I(s, p, o, m) # define BOOST_PP_FOR_102(s, p, o, m) BOOST_PP_FOR_102_I(s, p, o, m) # define BOOST_PP_FOR_103(s, p, o, m) BOOST_PP_FOR_103_I(s, p, o, m) # define BOOST_PP_FOR_104(s, p, o, m) BOOST_PP_FOR_104_I(s, p, o, m) # define BOOST_PP_FOR_105(s, p, o, m) BOOST_PP_FOR_105_I(s, p, o, m) # define BOOST_PP_FOR_106(s, p, o, m) BOOST_PP_FOR_106_I(s, p, o, m) # define BOOST_PP_FOR_107(s, p, o, m) BOOST_PP_FOR_107_I(s, p, o, m) # define BOOST_PP_FOR_108(s, p, o, m) BOOST_PP_FOR_108_I(s, p, o, m) # define BOOST_PP_FOR_109(s, p, o, m) BOOST_PP_FOR_109_I(s, p, o, m) # define BOOST_PP_FOR_110(s, p, o, m) BOOST_PP_FOR_110_I(s, p, o, m) # define BOOST_PP_FOR_111(s, p, o, m) BOOST_PP_FOR_111_I(s, p, o, m) # define BOOST_PP_FOR_112(s, p, o, m) BOOST_PP_FOR_112_I(s, p, o, m) # define BOOST_PP_FOR_113(s, p, o, m) BOOST_PP_FOR_113_I(s, p, o, m) # define BOOST_PP_FOR_114(s, p, o, m) BOOST_PP_FOR_114_I(s, p, o, m) # define BOOST_PP_FOR_115(s, p, o, m) BOOST_PP_FOR_115_I(s, p, o, m) # define BOOST_PP_FOR_116(s, p, o, m) BOOST_PP_FOR_116_I(s, p, o, m) # define BOOST_PP_FOR_117(s, p, o, m) BOOST_PP_FOR_117_I(s, p, o, m) # define BOOST_PP_FOR_118(s, p, o, m) BOOST_PP_FOR_118_I(s, p, o, m) # define BOOST_PP_FOR_119(s, p, o, m) BOOST_PP_FOR_119_I(s, p, o, m) # define BOOST_PP_FOR_120(s, p, o, m) BOOST_PP_FOR_120_I(s, p, o, m) # define BOOST_PP_FOR_121(s, p, o, m) BOOST_PP_FOR_121_I(s, p, o, m) # define BOOST_PP_FOR_122(s, p, o, m) BOOST_PP_FOR_122_I(s, p, o, m) # define BOOST_PP_FOR_123(s, p, o, m) BOOST_PP_FOR_123_I(s, p, o, m) # define BOOST_PP_FOR_124(s, p, o, m) BOOST_PP_FOR_124_I(s, p, o, m) # define BOOST_PP_FOR_125(s, p, o, m) BOOST_PP_FOR_125_I(s, p, o, m) # define BOOST_PP_FOR_126(s, p, o, m) BOOST_PP_FOR_126_I(s, p, o, m) # define BOOST_PP_FOR_127(s, p, o, m) BOOST_PP_FOR_127_I(s, p, o, m) # define BOOST_PP_FOR_128(s, p, o, m) BOOST_PP_FOR_128_I(s, p, o, m) # define BOOST_PP_FOR_129(s, p, o, m) BOOST_PP_FOR_129_I(s, p, o, m) # define BOOST_PP_FOR_130(s, p, o, m) BOOST_PP_FOR_130_I(s, p, o, m) # define BOOST_PP_FOR_131(s, p, o, m) BOOST_PP_FOR_131_I(s, p, o, m) # define BOOST_PP_FOR_132(s, p, o, m) BOOST_PP_FOR_132_I(s, p, o, m) # define BOOST_PP_FOR_133(s, p, o, m) BOOST_PP_FOR_133_I(s, p, o, m) # define BOOST_PP_FOR_134(s, p, o, m) BOOST_PP_FOR_134_I(s, p, o, m) # define BOOST_PP_FOR_135(s, p, o, m) BOOST_PP_FOR_135_I(s, p, o, m) # define BOOST_PP_FOR_136(s, p, o, m) BOOST_PP_FOR_136_I(s, p, o, m) # define BOOST_PP_FOR_137(s, p, o, m) BOOST_PP_FOR_137_I(s, p, o, m) # define BOOST_PP_FOR_138(s, p, o, m) BOOST_PP_FOR_138_I(s, p, o, m) # define BOOST_PP_FOR_139(s, p, o, m) BOOST_PP_FOR_139_I(s, p, o, m) # define BOOST_PP_FOR_140(s, p, o, m) BOOST_PP_FOR_140_I(s, p, o, m) # define BOOST_PP_FOR_141(s, p, o, m) BOOST_PP_FOR_141_I(s, p, o, m) # define BOOST_PP_FOR_142(s, p, o, m) BOOST_PP_FOR_142_I(s, p, o, m) # define BOOST_PP_FOR_143(s, p, o, m) BOOST_PP_FOR_143_I(s, p, o, m) # define BOOST_PP_FOR_144(s, p, o, m) BOOST_PP_FOR_144_I(s, p, o, m) # define BOOST_PP_FOR_145(s, p, o, m) BOOST_PP_FOR_145_I(s, p, o, m) # define BOOST_PP_FOR_146(s, p, o, m) BOOST_PP_FOR_146_I(s, p, o, m) # define BOOST_PP_FOR_147(s, p, o, m) BOOST_PP_FOR_147_I(s, p, o, m) # define BOOST_PP_FOR_148(s, p, o, m) BOOST_PP_FOR_148_I(s, p, o, m) # define BOOST_PP_FOR_149(s, p, o, m) BOOST_PP_FOR_149_I(s, p, o, m) # define BOOST_PP_FOR_150(s, p, o, m) BOOST_PP_FOR_150_I(s, p, o, m) # define BOOST_PP_FOR_151(s, p, o, m) BOOST_PP_FOR_151_I(s, p, o, m) # define BOOST_PP_FOR_152(s, p, o, m) BOOST_PP_FOR_152_I(s, p, o, m) # define BOOST_PP_FOR_153(s, p, o, m) BOOST_PP_FOR_153_I(s, p, o, m) # define BOOST_PP_FOR_154(s, p, o, m) BOOST_PP_FOR_154_I(s, p, o, m) # define BOOST_PP_FOR_155(s, p, o, m) BOOST_PP_FOR_155_I(s, p, o, m) # define BOOST_PP_FOR_156(s, p, o, m) BOOST_PP_FOR_156_I(s, p, o, m) # define BOOST_PP_FOR_157(s, p, o, m) BOOST_PP_FOR_157_I(s, p, o, m) # define BOOST_PP_FOR_158(s, p, o, m) BOOST_PP_FOR_158_I(s, p, o, m) # define BOOST_PP_FOR_159(s, p, o, m) BOOST_PP_FOR_159_I(s, p, o, m) # define BOOST_PP_FOR_160(s, p, o, m) BOOST_PP_FOR_160_I(s, p, o, m) # define BOOST_PP_FOR_161(s, p, o, m) BOOST_PP_FOR_161_I(s, p, o, m) # define BOOST_PP_FOR_162(s, p, o, m) BOOST_PP_FOR_162_I(s, p, o, m) # define BOOST_PP_FOR_163(s, p, o, m) BOOST_PP_FOR_163_I(s, p, o, m) # define BOOST_PP_FOR_164(s, p, o, m) BOOST_PP_FOR_164_I(s, p, o, m) # define BOOST_PP_FOR_165(s, p, o, m) BOOST_PP_FOR_165_I(s, p, o, m) # define BOOST_PP_FOR_166(s, p, o, m) BOOST_PP_FOR_166_I(s, p, o, m) # define BOOST_PP_FOR_167(s, p, o, m) BOOST_PP_FOR_167_I(s, p, o, m) # define BOOST_PP_FOR_168(s, p, o, m) BOOST_PP_FOR_168_I(s, p, o, m) # define BOOST_PP_FOR_169(s, p, o, m) BOOST_PP_FOR_169_I(s, p, o, m) # define BOOST_PP_FOR_170(s, p, o, m) BOOST_PP_FOR_170_I(s, p, o, m) # define BOOST_PP_FOR_171(s, p, o, m) BOOST_PP_FOR_171_I(s, p, o, m) # define BOOST_PP_FOR_172(s, p, o, m) BOOST_PP_FOR_172_I(s, p, o, m) # define BOOST_PP_FOR_173(s, p, o, m) BOOST_PP_FOR_173_I(s, p, o, m) # define BOOST_PP_FOR_174(s, p, o, m) BOOST_PP_FOR_174_I(s, p, o, m) # define BOOST_PP_FOR_175(s, p, o, m) BOOST_PP_FOR_175_I(s, p, o, m) # define BOOST_PP_FOR_176(s, p, o, m) BOOST_PP_FOR_176_I(s, p, o, m) # define BOOST_PP_FOR_177(s, p, o, m) BOOST_PP_FOR_177_I(s, p, o, m) # define BOOST_PP_FOR_178(s, p, o, m) BOOST_PP_FOR_178_I(s, p, o, m) # define BOOST_PP_FOR_179(s, p, o, m) BOOST_PP_FOR_179_I(s, p, o, m) # define BOOST_PP_FOR_180(s, p, o, m) BOOST_PP_FOR_180_I(s, p, o, m) # define BOOST_PP_FOR_181(s, p, o, m) BOOST_PP_FOR_181_I(s, p, o, m) # define BOOST_PP_FOR_182(s, p, o, m) BOOST_PP_FOR_182_I(s, p, o, m) # define BOOST_PP_FOR_183(s, p, o, m) BOOST_PP_FOR_183_I(s, p, o, m) # define BOOST_PP_FOR_184(s, p, o, m) BOOST_PP_FOR_184_I(s, p, o, m) # define BOOST_PP_FOR_185(s, p, o, m) BOOST_PP_FOR_185_I(s, p, o, m) # define BOOST_PP_FOR_186(s, p, o, m) BOOST_PP_FOR_186_I(s, p, o, m) # define BOOST_PP_FOR_187(s, p, o, m) BOOST_PP_FOR_187_I(s, p, o, m) # define BOOST_PP_FOR_188(s, p, o, m) BOOST_PP_FOR_188_I(s, p, o, m) # define BOOST_PP_FOR_189(s, p, o, m) BOOST_PP_FOR_189_I(s, p, o, m) # define BOOST_PP_FOR_190(s, p, o, m) BOOST_PP_FOR_190_I(s, p, o, m) # define BOOST_PP_FOR_191(s, p, o, m) BOOST_PP_FOR_191_I(s, p, o, m) # define BOOST_PP_FOR_192(s, p, o, m) BOOST_PP_FOR_192_I(s, p, o, m) # define BOOST_PP_FOR_193(s, p, o, m) BOOST_PP_FOR_193_I(s, p, o, m) # define BOOST_PP_FOR_194(s, p, o, m) BOOST_PP_FOR_194_I(s, p, o, m) # define BOOST_PP_FOR_195(s, p, o, m) BOOST_PP_FOR_195_I(s, p, o, m) # define BOOST_PP_FOR_196(s, p, o, m) BOOST_PP_FOR_196_I(s, p, o, m) # define BOOST_PP_FOR_197(s, p, o, m) BOOST_PP_FOR_197_I(s, p, o, m) # define BOOST_PP_FOR_198(s, p, o, m) BOOST_PP_FOR_198_I(s, p, o, m) # define BOOST_PP_FOR_199(s, p, o, m) BOOST_PP_FOR_199_I(s, p, o, m) # define BOOST_PP_FOR_200(s, p, o, m) BOOST_PP_FOR_200_I(s, p, o, m) # define BOOST_PP_FOR_201(s, p, o, m) BOOST_PP_FOR_201_I(s, p, o, m) # define BOOST_PP_FOR_202(s, p, o, m) BOOST_PP_FOR_202_I(s, p, o, m) # define BOOST_PP_FOR_203(s, p, o, m) BOOST_PP_FOR_203_I(s, p, o, m) # define BOOST_PP_FOR_204(s, p, o, m) BOOST_PP_FOR_204_I(s, p, o, m) # define BOOST_PP_FOR_205(s, p, o, m) BOOST_PP_FOR_205_I(s, p, o, m) # define BOOST_PP_FOR_206(s, p, o, m) BOOST_PP_FOR_206_I(s, p, o, m) # define BOOST_PP_FOR_207(s, p, o, m) BOOST_PP_FOR_207_I(s, p, o, m) # define BOOST_PP_FOR_208(s, p, o, m) BOOST_PP_FOR_208_I(s, p, o, m) # define BOOST_PP_FOR_209(s, p, o, m) BOOST_PP_FOR_209_I(s, p, o, m) # define BOOST_PP_FOR_210(s, p, o, m) BOOST_PP_FOR_210_I(s, p, o, m) # define BOOST_PP_FOR_211(s, p, o, m) BOOST_PP_FOR_211_I(s, p, o, m) # define BOOST_PP_FOR_212(s, p, o, m) BOOST_PP_FOR_212_I(s, p, o, m) # define BOOST_PP_FOR_213(s, p, o, m) BOOST_PP_FOR_213_I(s, p, o, m) # define BOOST_PP_FOR_214(s, p, o, m) BOOST_PP_FOR_214_I(s, p, o, m) # define BOOST_PP_FOR_215(s, p, o, m) BOOST_PP_FOR_215_I(s, p, o, m) # define BOOST_PP_FOR_216(s, p, o, m) BOOST_PP_FOR_216_I(s, p, o, m) # define BOOST_PP_FOR_217(s, p, o, m) BOOST_PP_FOR_217_I(s, p, o, m) # define BOOST_PP_FOR_218(s, p, o, m) BOOST_PP_FOR_218_I(s, p, o, m) # define BOOST_PP_FOR_219(s, p, o, m) BOOST_PP_FOR_219_I(s, p, o, m) # define BOOST_PP_FOR_220(s, p, o, m) BOOST_PP_FOR_220_I(s, p, o, m) # define BOOST_PP_FOR_221(s, p, o, m) BOOST_PP_FOR_221_I(s, p, o, m) # define BOOST_PP_FOR_222(s, p, o, m) BOOST_PP_FOR_222_I(s, p, o, m) # define BOOST_PP_FOR_223(s, p, o, m) BOOST_PP_FOR_223_I(s, p, o, m) # define BOOST_PP_FOR_224(s, p, o, m) BOOST_PP_FOR_224_I(s, p, o, m) # define BOOST_PP_FOR_225(s, p, o, m) BOOST_PP_FOR_225_I(s, p, o, m) # define BOOST_PP_FOR_226(s, p, o, m) BOOST_PP_FOR_226_I(s, p, o, m) # define BOOST_PP_FOR_227(s, p, o, m) BOOST_PP_FOR_227_I(s, p, o, m) # define BOOST_PP_FOR_228(s, p, o, m) BOOST_PP_FOR_228_I(s, p, o, m) # define BOOST_PP_FOR_229(s, p, o, m) BOOST_PP_FOR_229_I(s, p, o, m) # define BOOST_PP_FOR_230(s, p, o, m) BOOST_PP_FOR_230_I(s, p, o, m) # define BOOST_PP_FOR_231(s, p, o, m) BOOST_PP_FOR_231_I(s, p, o, m) # define BOOST_PP_FOR_232(s, p, o, m) BOOST_PP_FOR_232_I(s, p, o, m) # define BOOST_PP_FOR_233(s, p, o, m) BOOST_PP_FOR_233_I(s, p, o, m) # define BOOST_PP_FOR_234(s, p, o, m) BOOST_PP_FOR_234_I(s, p, o, m) # define BOOST_PP_FOR_235(s, p, o, m) BOOST_PP_FOR_235_I(s, p, o, m) # define BOOST_PP_FOR_236(s, p, o, m) BOOST_PP_FOR_236_I(s, p, o, m) # define BOOST_PP_FOR_237(s, p, o, m) BOOST_PP_FOR_237_I(s, p, o, m) # define BOOST_PP_FOR_238(s, p, o, m) BOOST_PP_FOR_238_I(s, p, o, m) # define BOOST_PP_FOR_239(s, p, o, m) BOOST_PP_FOR_239_I(s, p, o, m) # define BOOST_PP_FOR_240(s, p, o, m) BOOST_PP_FOR_240_I(s, p, o, m) # define BOOST_PP_FOR_241(s, p, o, m) BOOST_PP_FOR_241_I(s, p, o, m) # define BOOST_PP_FOR_242(s, p, o, m) BOOST_PP_FOR_242_I(s, p, o, m) # define BOOST_PP_FOR_243(s, p, o, m) BOOST_PP_FOR_243_I(s, p, o, m) # define BOOST_PP_FOR_244(s, p, o, m) BOOST_PP_FOR_244_I(s, p, o, m) # define BOOST_PP_FOR_245(s, p, o, m) BOOST_PP_FOR_245_I(s, p, o, m) # define BOOST_PP_FOR_246(s, p, o, m) BOOST_PP_FOR_246_I(s, p, o, m) # define BOOST_PP_FOR_247(s, p, o, m) BOOST_PP_FOR_247_I(s, p, o, m) # define BOOST_PP_FOR_248(s, p, o, m) BOOST_PP_FOR_248_I(s, p, o, m) # define BOOST_PP_FOR_249(s, p, o, m) BOOST_PP_FOR_249_I(s, p, o, m) # define BOOST_PP_FOR_250(s, p, o, m) BOOST_PP_FOR_250_I(s, p, o, m) # define BOOST_PP_FOR_251(s, p, o, m) BOOST_PP_FOR_251_I(s, p, o, m) # define BOOST_PP_FOR_252(s, p, o, m) BOOST_PP_FOR_252_I(s, p, o, m) # define BOOST_PP_FOR_253(s, p, o, m) BOOST_PP_FOR_253_I(s, p, o, m) # define BOOST_PP_FOR_254(s, p, o, m) BOOST_PP_FOR_254_I(s, p, o, m) # define BOOST_PP_FOR_255(s, p, o, m) BOOST_PP_FOR_255_I(s, p, o, m) # define BOOST_PP_FOR_256(s, p, o, m) BOOST_PP_FOR_256_I(s, p, o, m) # # define BOOST_PP_FOR_1_I(s, p, o, m) BOOST_PP_IF(p(2, s), m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IF(p(2, s), BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(o(2, s), p, o, m) # define BOOST_PP_FOR_2_I(s, p, o, m) BOOST_PP_IF(p(3, s), m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IF(p(3, s), BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(o(3, s), p, o, m) # define BOOST_PP_FOR_3_I(s, p, o, m) BOOST_PP_IF(p(4, s), m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IF(p(4, s), BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(o(4, s), p, o, m) # define BOOST_PP_FOR_4_I(s, p, o, m) BOOST_PP_IF(p(5, s), m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IF(p(5, s), BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(o(5, s), p, o, m) # define BOOST_PP_FOR_5_I(s, p, o, m) BOOST_PP_IF(p(6, s), m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IF(p(6, s), BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(o(6, s), p, o, m) # define BOOST_PP_FOR_6_I(s, p, o, m) BOOST_PP_IF(p(7, s), m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IF(p(7, s), BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(o(7, s), p, o, m) # define BOOST_PP_FOR_7_I(s, p, o, m) BOOST_PP_IF(p(8, s), m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IF(p(8, s), BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(o(8, s), p, o, m) # define BOOST_PP_FOR_8_I(s, p, o, m) BOOST_PP_IF(p(9, s), m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IF(p(9, s), BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(o(9, s), p, o, m) # define BOOST_PP_FOR_9_I(s, p, o, m) BOOST_PP_IF(p(10, s), m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IF(p(10, s), BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(o(10, s), p, o, m) # define BOOST_PP_FOR_10_I(s, p, o, m) BOOST_PP_IF(p(11, s), m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IF(p(11, s), BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(o(11, s), p, o, m) # define BOOST_PP_FOR_11_I(s, p, o, m) BOOST_PP_IF(p(12, s), m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IF(p(12, s), BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(o(12, s), p, o, m) # define BOOST_PP_FOR_12_I(s, p, o, m) BOOST_PP_IF(p(13, s), m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IF(p(13, s), BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(o(13, s), p, o, m) # define BOOST_PP_FOR_13_I(s, p, o, m) BOOST_PP_IF(p(14, s), m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IF(p(14, s), BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(o(14, s), p, o, m) # define BOOST_PP_FOR_14_I(s, p, o, m) BOOST_PP_IF(p(15, s), m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IF(p(15, s), BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(o(15, s), p, o, m) # define BOOST_PP_FOR_15_I(s, p, o, m) BOOST_PP_IF(p(16, s), m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IF(p(16, s), BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(o(16, s), p, o, m) # define BOOST_PP_FOR_16_I(s, p, o, m) BOOST_PP_IF(p(17, s), m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IF(p(17, s), BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(o(17, s), p, o, m) # define BOOST_PP_FOR_17_I(s, p, o, m) BOOST_PP_IF(p(18, s), m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IF(p(18, s), BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(o(18, s), p, o, m) # define BOOST_PP_FOR_18_I(s, p, o, m) BOOST_PP_IF(p(19, s), m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IF(p(19, s), BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(o(19, s), p, o, m) # define BOOST_PP_FOR_19_I(s, p, o, m) BOOST_PP_IF(p(20, s), m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IF(p(20, s), BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(o(20, s), p, o, m) # define BOOST_PP_FOR_20_I(s, p, o, m) BOOST_PP_IF(p(21, s), m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IF(p(21, s), BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(o(21, s), p, o, m) # define BOOST_PP_FOR_21_I(s, p, o, m) BOOST_PP_IF(p(22, s), m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IF(p(22, s), BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(o(22, s), p, o, m) # define BOOST_PP_FOR_22_I(s, p, o, m) BOOST_PP_IF(p(23, s), m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IF(p(23, s), BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(o(23, s), p, o, m) # define BOOST_PP_FOR_23_I(s, p, o, m) BOOST_PP_IF(p(24, s), m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IF(p(24, s), BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(o(24, s), p, o, m) # define BOOST_PP_FOR_24_I(s, p, o, m) BOOST_PP_IF(p(25, s), m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IF(p(25, s), BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(o(25, s), p, o, m) # define BOOST_PP_FOR_25_I(s, p, o, m) BOOST_PP_IF(p(26, s), m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IF(p(26, s), BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(o(26, s), p, o, m) # define BOOST_PP_FOR_26_I(s, p, o, m) BOOST_PP_IF(p(27, s), m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IF(p(27, s), BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(o(27, s), p, o, m) # define BOOST_PP_FOR_27_I(s, p, o, m) BOOST_PP_IF(p(28, s), m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IF(p(28, s), BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(o(28, s), p, o, m) # define BOOST_PP_FOR_28_I(s, p, o, m) BOOST_PP_IF(p(29, s), m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IF(p(29, s), BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(o(29, s), p, o, m) # define BOOST_PP_FOR_29_I(s, p, o, m) BOOST_PP_IF(p(30, s), m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IF(p(30, s), BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(o(30, s), p, o, m) # define BOOST_PP_FOR_30_I(s, p, o, m) BOOST_PP_IF(p(31, s), m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IF(p(31, s), BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(o(31, s), p, o, m) # define BOOST_PP_FOR_31_I(s, p, o, m) BOOST_PP_IF(p(32, s), m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IF(p(32, s), BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(o(32, s), p, o, m) # define BOOST_PP_FOR_32_I(s, p, o, m) BOOST_PP_IF(p(33, s), m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IF(p(33, s), BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(o(33, s), p, o, m) # define BOOST_PP_FOR_33_I(s, p, o, m) BOOST_PP_IF(p(34, s), m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IF(p(34, s), BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(o(34, s), p, o, m) # define BOOST_PP_FOR_34_I(s, p, o, m) BOOST_PP_IF(p(35, s), m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IF(p(35, s), BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(o(35, s), p, o, m) # define BOOST_PP_FOR_35_I(s, p, o, m) BOOST_PP_IF(p(36, s), m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IF(p(36, s), BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(o(36, s), p, o, m) # define BOOST_PP_FOR_36_I(s, p, o, m) BOOST_PP_IF(p(37, s), m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IF(p(37, s), BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(o(37, s), p, o, m) # define BOOST_PP_FOR_37_I(s, p, o, m) BOOST_PP_IF(p(38, s), m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IF(p(38, s), BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(o(38, s), p, o, m) # define BOOST_PP_FOR_38_I(s, p, o, m) BOOST_PP_IF(p(39, s), m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IF(p(39, s), BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(o(39, s), p, o, m) # define BOOST_PP_FOR_39_I(s, p, o, m) BOOST_PP_IF(p(40, s), m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IF(p(40, s), BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(o(40, s), p, o, m) # define BOOST_PP_FOR_40_I(s, p, o, m) BOOST_PP_IF(p(41, s), m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IF(p(41, s), BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(o(41, s), p, o, m) # define BOOST_PP_FOR_41_I(s, p, o, m) BOOST_PP_IF(p(42, s), m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IF(p(42, s), BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(o(42, s), p, o, m) # define BOOST_PP_FOR_42_I(s, p, o, m) BOOST_PP_IF(p(43, s), m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IF(p(43, s), BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(o(43, s), p, o, m) # define BOOST_PP_FOR_43_I(s, p, o, m) BOOST_PP_IF(p(44, s), m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IF(p(44, s), BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(o(44, s), p, o, m) # define BOOST_PP_FOR_44_I(s, p, o, m) BOOST_PP_IF(p(45, s), m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IF(p(45, s), BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(o(45, s), p, o, m) # define BOOST_PP_FOR_45_I(s, p, o, m) BOOST_PP_IF(p(46, s), m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IF(p(46, s), BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(o(46, s), p, o, m) # define BOOST_PP_FOR_46_I(s, p, o, m) BOOST_PP_IF(p(47, s), m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IF(p(47, s), BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(o(47, s), p, o, m) # define BOOST_PP_FOR_47_I(s, p, o, m) BOOST_PP_IF(p(48, s), m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IF(p(48, s), BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(o(48, s), p, o, m) # define BOOST_PP_FOR_48_I(s, p, o, m) BOOST_PP_IF(p(49, s), m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IF(p(49, s), BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(o(49, s), p, o, m) # define BOOST_PP_FOR_49_I(s, p, o, m) BOOST_PP_IF(p(50, s), m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IF(p(50, s), BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(o(50, s), p, o, m) # define BOOST_PP_FOR_50_I(s, p, o, m) BOOST_PP_IF(p(51, s), m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IF(p(51, s), BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(o(51, s), p, o, m) # define BOOST_PP_FOR_51_I(s, p, o, m) BOOST_PP_IF(p(52, s), m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IF(p(52, s), BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(o(52, s), p, o, m) # define BOOST_PP_FOR_52_I(s, p, o, m) BOOST_PP_IF(p(53, s), m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IF(p(53, s), BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(o(53, s), p, o, m) # define BOOST_PP_FOR_53_I(s, p, o, m) BOOST_PP_IF(p(54, s), m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IF(p(54, s), BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(o(54, s), p, o, m) # define BOOST_PP_FOR_54_I(s, p, o, m) BOOST_PP_IF(p(55, s), m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IF(p(55, s), BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(o(55, s), p, o, m) # define BOOST_PP_FOR_55_I(s, p, o, m) BOOST_PP_IF(p(56, s), m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IF(p(56, s), BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(o(56, s), p, o, m) # define BOOST_PP_FOR_56_I(s, p, o, m) BOOST_PP_IF(p(57, s), m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IF(p(57, s), BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(o(57, s), p, o, m) # define BOOST_PP_FOR_57_I(s, p, o, m) BOOST_PP_IF(p(58, s), m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IF(p(58, s), BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(o(58, s), p, o, m) # define BOOST_PP_FOR_58_I(s, p, o, m) BOOST_PP_IF(p(59, s), m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IF(p(59, s), BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(o(59, s), p, o, m) # define BOOST_PP_FOR_59_I(s, p, o, m) BOOST_PP_IF(p(60, s), m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IF(p(60, s), BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(o(60, s), p, o, m) # define BOOST_PP_FOR_60_I(s, p, o, m) BOOST_PP_IF(p(61, s), m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IF(p(61, s), BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(o(61, s), p, o, m) # define BOOST_PP_FOR_61_I(s, p, o, m) BOOST_PP_IF(p(62, s), m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IF(p(62, s), BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(o(62, s), p, o, m) # define BOOST_PP_FOR_62_I(s, p, o, m) BOOST_PP_IF(p(63, s), m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IF(p(63, s), BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(o(63, s), p, o, m) # define BOOST_PP_FOR_63_I(s, p, o, m) BOOST_PP_IF(p(64, s), m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IF(p(64, s), BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(o(64, s), p, o, m) # define BOOST_PP_FOR_64_I(s, p, o, m) BOOST_PP_IF(p(65, s), m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IF(p(65, s), BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(o(65, s), p, o, m) # define BOOST_PP_FOR_65_I(s, p, o, m) BOOST_PP_IF(p(66, s), m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IF(p(66, s), BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(o(66, s), p, o, m) # define BOOST_PP_FOR_66_I(s, p, o, m) BOOST_PP_IF(p(67, s), m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IF(p(67, s), BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(o(67, s), p, o, m) # define BOOST_PP_FOR_67_I(s, p, o, m) BOOST_PP_IF(p(68, s), m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IF(p(68, s), BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(o(68, s), p, o, m) # define BOOST_PP_FOR_68_I(s, p, o, m) BOOST_PP_IF(p(69, s), m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IF(p(69, s), BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(o(69, s), p, o, m) # define BOOST_PP_FOR_69_I(s, p, o, m) BOOST_PP_IF(p(70, s), m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IF(p(70, s), BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(o(70, s), p, o, m) # define BOOST_PP_FOR_70_I(s, p, o, m) BOOST_PP_IF(p(71, s), m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IF(p(71, s), BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(o(71, s), p, o, m) # define BOOST_PP_FOR_71_I(s, p, o, m) BOOST_PP_IF(p(72, s), m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IF(p(72, s), BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(o(72, s), p, o, m) # define BOOST_PP_FOR_72_I(s, p, o, m) BOOST_PP_IF(p(73, s), m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IF(p(73, s), BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(o(73, s), p, o, m) # define BOOST_PP_FOR_73_I(s, p, o, m) BOOST_PP_IF(p(74, s), m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IF(p(74, s), BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(o(74, s), p, o, m) # define BOOST_PP_FOR_74_I(s, p, o, m) BOOST_PP_IF(p(75, s), m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IF(p(75, s), BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(o(75, s), p, o, m) # define BOOST_PP_FOR_75_I(s, p, o, m) BOOST_PP_IF(p(76, s), m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IF(p(76, s), BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(o(76, s), p, o, m) # define BOOST_PP_FOR_76_I(s, p, o, m) BOOST_PP_IF(p(77, s), m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IF(p(77, s), BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(o(77, s), p, o, m) # define BOOST_PP_FOR_77_I(s, p, o, m) BOOST_PP_IF(p(78, s), m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IF(p(78, s), BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(o(78, s), p, o, m) # define BOOST_PP_FOR_78_I(s, p, o, m) BOOST_PP_IF(p(79, s), m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IF(p(79, s), BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(o(79, s), p, o, m) # define BOOST_PP_FOR_79_I(s, p, o, m) BOOST_PP_IF(p(80, s), m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IF(p(80, s), BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(o(80, s), p, o, m) # define BOOST_PP_FOR_80_I(s, p, o, m) BOOST_PP_IF(p(81, s), m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IF(p(81, s), BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(o(81, s), p, o, m) # define BOOST_PP_FOR_81_I(s, p, o, m) BOOST_PP_IF(p(82, s), m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IF(p(82, s), BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(o(82, s), p, o, m) # define BOOST_PP_FOR_82_I(s, p, o, m) BOOST_PP_IF(p(83, s), m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IF(p(83, s), BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(o(83, s), p, o, m) # define BOOST_PP_FOR_83_I(s, p, o, m) BOOST_PP_IF(p(84, s), m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IF(p(84, s), BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(o(84, s), p, o, m) # define BOOST_PP_FOR_84_I(s, p, o, m) BOOST_PP_IF(p(85, s), m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IF(p(85, s), BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(o(85, s), p, o, m) # define BOOST_PP_FOR_85_I(s, p, o, m) BOOST_PP_IF(p(86, s), m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IF(p(86, s), BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(o(86, s), p, o, m) # define BOOST_PP_FOR_86_I(s, p, o, m) BOOST_PP_IF(p(87, s), m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IF(p(87, s), BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(o(87, s), p, o, m) # define BOOST_PP_FOR_87_I(s, p, o, m) BOOST_PP_IF(p(88, s), m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IF(p(88, s), BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(o(88, s), p, o, m) # define BOOST_PP_FOR_88_I(s, p, o, m) BOOST_PP_IF(p(89, s), m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IF(p(89, s), BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(o(89, s), p, o, m) # define BOOST_PP_FOR_89_I(s, p, o, m) BOOST_PP_IF(p(90, s), m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IF(p(90, s), BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(o(90, s), p, o, m) # define BOOST_PP_FOR_90_I(s, p, o, m) BOOST_PP_IF(p(91, s), m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IF(p(91, s), BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(o(91, s), p, o, m) # define BOOST_PP_FOR_91_I(s, p, o, m) BOOST_PP_IF(p(92, s), m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IF(p(92, s), BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(o(92, s), p, o, m) # define BOOST_PP_FOR_92_I(s, p, o, m) BOOST_PP_IF(p(93, s), m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IF(p(93, s), BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(o(93, s), p, o, m) # define BOOST_PP_FOR_93_I(s, p, o, m) BOOST_PP_IF(p(94, s), m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IF(p(94, s), BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(o(94, s), p, o, m) # define BOOST_PP_FOR_94_I(s, p, o, m) BOOST_PP_IF(p(95, s), m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IF(p(95, s), BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(o(95, s), p, o, m) # define BOOST_PP_FOR_95_I(s, p, o, m) BOOST_PP_IF(p(96, s), m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IF(p(96, s), BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(o(96, s), p, o, m) # define BOOST_PP_FOR_96_I(s, p, o, m) BOOST_PP_IF(p(97, s), m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IF(p(97, s), BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(o(97, s), p, o, m) # define BOOST_PP_FOR_97_I(s, p, o, m) BOOST_PP_IF(p(98, s), m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IF(p(98, s), BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(o(98, s), p, o, m) # define BOOST_PP_FOR_98_I(s, p, o, m) BOOST_PP_IF(p(99, s), m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IF(p(99, s), BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(o(99, s), p, o, m) # define BOOST_PP_FOR_99_I(s, p, o, m) BOOST_PP_IF(p(100, s), m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IF(p(100, s), BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(o(100, s), p, o, m) # define BOOST_PP_FOR_100_I(s, p, o, m) BOOST_PP_IF(p(101, s), m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IF(p(101, s), BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(o(101, s), p, o, m) # define BOOST_PP_FOR_101_I(s, p, o, m) BOOST_PP_IF(p(102, s), m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IF(p(102, s), BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(o(102, s), p, o, m) # define BOOST_PP_FOR_102_I(s, p, o, m) BOOST_PP_IF(p(103, s), m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IF(p(103, s), BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(o(103, s), p, o, m) # define BOOST_PP_FOR_103_I(s, p, o, m) BOOST_PP_IF(p(104, s), m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IF(p(104, s), BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(o(104, s), p, o, m) # define BOOST_PP_FOR_104_I(s, p, o, m) BOOST_PP_IF(p(105, s), m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IF(p(105, s), BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(o(105, s), p, o, m) # define BOOST_PP_FOR_105_I(s, p, o, m) BOOST_PP_IF(p(106, s), m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IF(p(106, s), BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(o(106, s), p, o, m) # define BOOST_PP_FOR_106_I(s, p, o, m) BOOST_PP_IF(p(107, s), m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IF(p(107, s), BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(o(107, s), p, o, m) # define BOOST_PP_FOR_107_I(s, p, o, m) BOOST_PP_IF(p(108, s), m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IF(p(108, s), BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(o(108, s), p, o, m) # define BOOST_PP_FOR_108_I(s, p, o, m) BOOST_PP_IF(p(109, s), m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IF(p(109, s), BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(o(109, s), p, o, m) # define BOOST_PP_FOR_109_I(s, p, o, m) BOOST_PP_IF(p(110, s), m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IF(p(110, s), BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(o(110, s), p, o, m) # define BOOST_PP_FOR_110_I(s, p, o, m) BOOST_PP_IF(p(111, s), m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IF(p(111, s), BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(o(111, s), p, o, m) # define BOOST_PP_FOR_111_I(s, p, o, m) BOOST_PP_IF(p(112, s), m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IF(p(112, s), BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(o(112, s), p, o, m) # define BOOST_PP_FOR_112_I(s, p, o, m) BOOST_PP_IF(p(113, s), m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IF(p(113, s), BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(o(113, s), p, o, m) # define BOOST_PP_FOR_113_I(s, p, o, m) BOOST_PP_IF(p(114, s), m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IF(p(114, s), BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(o(114, s), p, o, m) # define BOOST_PP_FOR_114_I(s, p, o, m) BOOST_PP_IF(p(115, s), m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IF(p(115, s), BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(o(115, s), p, o, m) # define BOOST_PP_FOR_115_I(s, p, o, m) BOOST_PP_IF(p(116, s), m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IF(p(116, s), BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(o(116, s), p, o, m) # define BOOST_PP_FOR_116_I(s, p, o, m) BOOST_PP_IF(p(117, s), m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IF(p(117, s), BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(o(117, s), p, o, m) # define BOOST_PP_FOR_117_I(s, p, o, m) BOOST_PP_IF(p(118, s), m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IF(p(118, s), BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(o(118, s), p, o, m) # define BOOST_PP_FOR_118_I(s, p, o, m) BOOST_PP_IF(p(119, s), m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IF(p(119, s), BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(o(119, s), p, o, m) # define BOOST_PP_FOR_119_I(s, p, o, m) BOOST_PP_IF(p(120, s), m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IF(p(120, s), BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(o(120, s), p, o, m) # define BOOST_PP_FOR_120_I(s, p, o, m) BOOST_PP_IF(p(121, s), m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IF(p(121, s), BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(o(121, s), p, o, m) # define BOOST_PP_FOR_121_I(s, p, o, m) BOOST_PP_IF(p(122, s), m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IF(p(122, s), BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(o(122, s), p, o, m) # define BOOST_PP_FOR_122_I(s, p, o, m) BOOST_PP_IF(p(123, s), m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IF(p(123, s), BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(o(123, s), p, o, m) # define BOOST_PP_FOR_123_I(s, p, o, m) BOOST_PP_IF(p(124, s), m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IF(p(124, s), BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(o(124, s), p, o, m) # define BOOST_PP_FOR_124_I(s, p, o, m) BOOST_PP_IF(p(125, s), m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IF(p(125, s), BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(o(125, s), p, o, m) # define BOOST_PP_FOR_125_I(s, p, o, m) BOOST_PP_IF(p(126, s), m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IF(p(126, s), BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(o(126, s), p, o, m) # define BOOST_PP_FOR_126_I(s, p, o, m) BOOST_PP_IF(p(127, s), m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IF(p(127, s), BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(o(127, s), p, o, m) # define BOOST_PP_FOR_127_I(s, p, o, m) BOOST_PP_IF(p(128, s), m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IF(p(128, s), BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(o(128, s), p, o, m) # define BOOST_PP_FOR_128_I(s, p, o, m) BOOST_PP_IF(p(129, s), m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IF(p(129, s), BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(o(129, s), p, o, m) # define BOOST_PP_FOR_129_I(s, p, o, m) BOOST_PP_IF(p(130, s), m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IF(p(130, s), BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(o(130, s), p, o, m) # define BOOST_PP_FOR_130_I(s, p, o, m) BOOST_PP_IF(p(131, s), m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IF(p(131, s), BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(o(131, s), p, o, m) # define BOOST_PP_FOR_131_I(s, p, o, m) BOOST_PP_IF(p(132, s), m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IF(p(132, s), BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(o(132, s), p, o, m) # define BOOST_PP_FOR_132_I(s, p, o, m) BOOST_PP_IF(p(133, s), m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IF(p(133, s), BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(o(133, s), p, o, m) # define BOOST_PP_FOR_133_I(s, p, o, m) BOOST_PP_IF(p(134, s), m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IF(p(134, s), BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(o(134, s), p, o, m) # define BOOST_PP_FOR_134_I(s, p, o, m) BOOST_PP_IF(p(135, s), m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IF(p(135, s), BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(o(135, s), p, o, m) # define BOOST_PP_FOR_135_I(s, p, o, m) BOOST_PP_IF(p(136, s), m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IF(p(136, s), BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(o(136, s), p, o, m) # define BOOST_PP_FOR_136_I(s, p, o, m) BOOST_PP_IF(p(137, s), m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IF(p(137, s), BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(o(137, s), p, o, m) # define BOOST_PP_FOR_137_I(s, p, o, m) BOOST_PP_IF(p(138, s), m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IF(p(138, s), BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(o(138, s), p, o, m) # define BOOST_PP_FOR_138_I(s, p, o, m) BOOST_PP_IF(p(139, s), m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IF(p(139, s), BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(o(139, s), p, o, m) # define BOOST_PP_FOR_139_I(s, p, o, m) BOOST_PP_IF(p(140, s), m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IF(p(140, s), BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(o(140, s), p, o, m) # define BOOST_PP_FOR_140_I(s, p, o, m) BOOST_PP_IF(p(141, s), m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IF(p(141, s), BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(o(141, s), p, o, m) # define BOOST_PP_FOR_141_I(s, p, o, m) BOOST_PP_IF(p(142, s), m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IF(p(142, s), BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(o(142, s), p, o, m) # define BOOST_PP_FOR_142_I(s, p, o, m) BOOST_PP_IF(p(143, s), m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IF(p(143, s), BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(o(143, s), p, o, m) # define BOOST_PP_FOR_143_I(s, p, o, m) BOOST_PP_IF(p(144, s), m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IF(p(144, s), BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(o(144, s), p, o, m) # define BOOST_PP_FOR_144_I(s, p, o, m) BOOST_PP_IF(p(145, s), m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IF(p(145, s), BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(o(145, s), p, o, m) # define BOOST_PP_FOR_145_I(s, p, o, m) BOOST_PP_IF(p(146, s), m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IF(p(146, s), BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(o(146, s), p, o, m) # define BOOST_PP_FOR_146_I(s, p, o, m) BOOST_PP_IF(p(147, s), m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IF(p(147, s), BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(o(147, s), p, o, m) # define BOOST_PP_FOR_147_I(s, p, o, m) BOOST_PP_IF(p(148, s), m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IF(p(148, s), BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(o(148, s), p, o, m) # define BOOST_PP_FOR_148_I(s, p, o, m) BOOST_PP_IF(p(149, s), m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IF(p(149, s), BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(o(149, s), p, o, m) # define BOOST_PP_FOR_149_I(s, p, o, m) BOOST_PP_IF(p(150, s), m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IF(p(150, s), BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(o(150, s), p, o, m) # define BOOST_PP_FOR_150_I(s, p, o, m) BOOST_PP_IF(p(151, s), m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IF(p(151, s), BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(o(151, s), p, o, m) # define BOOST_PP_FOR_151_I(s, p, o, m) BOOST_PP_IF(p(152, s), m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IF(p(152, s), BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(o(152, s), p, o, m) # define BOOST_PP_FOR_152_I(s, p, o, m) BOOST_PP_IF(p(153, s), m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IF(p(153, s), BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(o(153, s), p, o, m) # define BOOST_PP_FOR_153_I(s, p, o, m) BOOST_PP_IF(p(154, s), m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IF(p(154, s), BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(o(154, s), p, o, m) # define BOOST_PP_FOR_154_I(s, p, o, m) BOOST_PP_IF(p(155, s), m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IF(p(155, s), BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(o(155, s), p, o, m) # define BOOST_PP_FOR_155_I(s, p, o, m) BOOST_PP_IF(p(156, s), m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IF(p(156, s), BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(o(156, s), p, o, m) # define BOOST_PP_FOR_156_I(s, p, o, m) BOOST_PP_IF(p(157, s), m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IF(p(157, s), BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(o(157, s), p, o, m) # define BOOST_PP_FOR_157_I(s, p, o, m) BOOST_PP_IF(p(158, s), m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IF(p(158, s), BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(o(158, s), p, o, m) # define BOOST_PP_FOR_158_I(s, p, o, m) BOOST_PP_IF(p(159, s), m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IF(p(159, s), BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(o(159, s), p, o, m) # define BOOST_PP_FOR_159_I(s, p, o, m) BOOST_PP_IF(p(160, s), m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IF(p(160, s), BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(o(160, s), p, o, m) # define BOOST_PP_FOR_160_I(s, p, o, m) BOOST_PP_IF(p(161, s), m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IF(p(161, s), BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(o(161, s), p, o, m) # define BOOST_PP_FOR_161_I(s, p, o, m) BOOST_PP_IF(p(162, s), m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IF(p(162, s), BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(o(162, s), p, o, m) # define BOOST_PP_FOR_162_I(s, p, o, m) BOOST_PP_IF(p(163, s), m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IF(p(163, s), BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(o(163, s), p, o, m) # define BOOST_PP_FOR_163_I(s, p, o, m) BOOST_PP_IF(p(164, s), m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IF(p(164, s), BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(o(164, s), p, o, m) # define BOOST_PP_FOR_164_I(s, p, o, m) BOOST_PP_IF(p(165, s), m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IF(p(165, s), BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(o(165, s), p, o, m) # define BOOST_PP_FOR_165_I(s, p, o, m) BOOST_PP_IF(p(166, s), m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IF(p(166, s), BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(o(166, s), p, o, m) # define BOOST_PP_FOR_166_I(s, p, o, m) BOOST_PP_IF(p(167, s), m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IF(p(167, s), BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(o(167, s), p, o, m) # define BOOST_PP_FOR_167_I(s, p, o, m) BOOST_PP_IF(p(168, s), m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IF(p(168, s), BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(o(168, s), p, o, m) # define BOOST_PP_FOR_168_I(s, p, o, m) BOOST_PP_IF(p(169, s), m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IF(p(169, s), BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(o(169, s), p, o, m) # define BOOST_PP_FOR_169_I(s, p, o, m) BOOST_PP_IF(p(170, s), m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IF(p(170, s), BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(o(170, s), p, o, m) # define BOOST_PP_FOR_170_I(s, p, o, m) BOOST_PP_IF(p(171, s), m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IF(p(171, s), BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(o(171, s), p, o, m) # define BOOST_PP_FOR_171_I(s, p, o, m) BOOST_PP_IF(p(172, s), m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IF(p(172, s), BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(o(172, s), p, o, m) # define BOOST_PP_FOR_172_I(s, p, o, m) BOOST_PP_IF(p(173, s), m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IF(p(173, s), BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(o(173, s), p, o, m) # define BOOST_PP_FOR_173_I(s, p, o, m) BOOST_PP_IF(p(174, s), m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IF(p(174, s), BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(o(174, s), p, o, m) # define BOOST_PP_FOR_174_I(s, p, o, m) BOOST_PP_IF(p(175, s), m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IF(p(175, s), BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(o(175, s), p, o, m) # define BOOST_PP_FOR_175_I(s, p, o, m) BOOST_PP_IF(p(176, s), m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IF(p(176, s), BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(o(176, s), p, o, m) # define BOOST_PP_FOR_176_I(s, p, o, m) BOOST_PP_IF(p(177, s), m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IF(p(177, s), BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(o(177, s), p, o, m) # define BOOST_PP_FOR_177_I(s, p, o, m) BOOST_PP_IF(p(178, s), m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IF(p(178, s), BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(o(178, s), p, o, m) # define BOOST_PP_FOR_178_I(s, p, o, m) BOOST_PP_IF(p(179, s), m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IF(p(179, s), BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(o(179, s), p, o, m) # define BOOST_PP_FOR_179_I(s, p, o, m) BOOST_PP_IF(p(180, s), m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IF(p(180, s), BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(o(180, s), p, o, m) # define BOOST_PP_FOR_180_I(s, p, o, m) BOOST_PP_IF(p(181, s), m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IF(p(181, s), BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(o(181, s), p, o, m) # define BOOST_PP_FOR_181_I(s, p, o, m) BOOST_PP_IF(p(182, s), m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IF(p(182, s), BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(o(182, s), p, o, m) # define BOOST_PP_FOR_182_I(s, p, o, m) BOOST_PP_IF(p(183, s), m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IF(p(183, s), BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(o(183, s), p, o, m) # define BOOST_PP_FOR_183_I(s, p, o, m) BOOST_PP_IF(p(184, s), m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IF(p(184, s), BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(o(184, s), p, o, m) # define BOOST_PP_FOR_184_I(s, p, o, m) BOOST_PP_IF(p(185, s), m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IF(p(185, s), BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(o(185, s), p, o, m) # define BOOST_PP_FOR_185_I(s, p, o, m) BOOST_PP_IF(p(186, s), m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IF(p(186, s), BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(o(186, s), p, o, m) # define BOOST_PP_FOR_186_I(s, p, o, m) BOOST_PP_IF(p(187, s), m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IF(p(187, s), BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(o(187, s), p, o, m) # define BOOST_PP_FOR_187_I(s, p, o, m) BOOST_PP_IF(p(188, s), m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IF(p(188, s), BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(o(188, s), p, o, m) # define BOOST_PP_FOR_188_I(s, p, o, m) BOOST_PP_IF(p(189, s), m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IF(p(189, s), BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(o(189, s), p, o, m) # define BOOST_PP_FOR_189_I(s, p, o, m) BOOST_PP_IF(p(190, s), m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IF(p(190, s), BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(o(190, s), p, o, m) # define BOOST_PP_FOR_190_I(s, p, o, m) BOOST_PP_IF(p(191, s), m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IF(p(191, s), BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(o(191, s), p, o, m) # define BOOST_PP_FOR_191_I(s, p, o, m) BOOST_PP_IF(p(192, s), m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IF(p(192, s), BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(o(192, s), p, o, m) # define BOOST_PP_FOR_192_I(s, p, o, m) BOOST_PP_IF(p(193, s), m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IF(p(193, s), BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(o(193, s), p, o, m) # define BOOST_PP_FOR_193_I(s, p, o, m) BOOST_PP_IF(p(194, s), m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IF(p(194, s), BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(o(194, s), p, o, m) # define BOOST_PP_FOR_194_I(s, p, o, m) BOOST_PP_IF(p(195, s), m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IF(p(195, s), BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(o(195, s), p, o, m) # define BOOST_PP_FOR_195_I(s, p, o, m) BOOST_PP_IF(p(196, s), m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IF(p(196, s), BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(o(196, s), p, o, m) # define BOOST_PP_FOR_196_I(s, p, o, m) BOOST_PP_IF(p(197, s), m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IF(p(197, s), BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(o(197, s), p, o, m) # define BOOST_PP_FOR_197_I(s, p, o, m) BOOST_PP_IF(p(198, s), m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IF(p(198, s), BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(o(198, s), p, o, m) # define BOOST_PP_FOR_198_I(s, p, o, m) BOOST_PP_IF(p(199, s), m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IF(p(199, s), BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(o(199, s), p, o, m) # define BOOST_PP_FOR_199_I(s, p, o, m) BOOST_PP_IF(p(200, s), m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IF(p(200, s), BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(o(200, s), p, o, m) # define BOOST_PP_FOR_200_I(s, p, o, m) BOOST_PP_IF(p(201, s), m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IF(p(201, s), BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(o(201, s), p, o, m) # define BOOST_PP_FOR_201_I(s, p, o, m) BOOST_PP_IF(p(202, s), m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IF(p(202, s), BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(o(202, s), p, o, m) # define BOOST_PP_FOR_202_I(s, p, o, m) BOOST_PP_IF(p(203, s), m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IF(p(203, s), BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(o(203, s), p, o, m) # define BOOST_PP_FOR_203_I(s, p, o, m) BOOST_PP_IF(p(204, s), m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IF(p(204, s), BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(o(204, s), p, o, m) # define BOOST_PP_FOR_204_I(s, p, o, m) BOOST_PP_IF(p(205, s), m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IF(p(205, s), BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(o(205, s), p, o, m) # define BOOST_PP_FOR_205_I(s, p, o, m) BOOST_PP_IF(p(206, s), m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IF(p(206, s), BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(o(206, s), p, o, m) # define BOOST_PP_FOR_206_I(s, p, o, m) BOOST_PP_IF(p(207, s), m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IF(p(207, s), BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(o(207, s), p, o, m) # define BOOST_PP_FOR_207_I(s, p, o, m) BOOST_PP_IF(p(208, s), m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IF(p(208, s), BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(o(208, s), p, o, m) # define BOOST_PP_FOR_208_I(s, p, o, m) BOOST_PP_IF(p(209, s), m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IF(p(209, s), BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(o(209, s), p, o, m) # define BOOST_PP_FOR_209_I(s, p, o, m) BOOST_PP_IF(p(210, s), m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IF(p(210, s), BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(o(210, s), p, o, m) # define BOOST_PP_FOR_210_I(s, p, o, m) BOOST_PP_IF(p(211, s), m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IF(p(211, s), BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(o(211, s), p, o, m) # define BOOST_PP_FOR_211_I(s, p, o, m) BOOST_PP_IF(p(212, s), m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IF(p(212, s), BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(o(212, s), p, o, m) # define BOOST_PP_FOR_212_I(s, p, o, m) BOOST_PP_IF(p(213, s), m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IF(p(213, s), BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(o(213, s), p, o, m) # define BOOST_PP_FOR_213_I(s, p, o, m) BOOST_PP_IF(p(214, s), m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IF(p(214, s), BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(o(214, s), p, o, m) # define BOOST_PP_FOR_214_I(s, p, o, m) BOOST_PP_IF(p(215, s), m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IF(p(215, s), BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(o(215, s), p, o, m) # define BOOST_PP_FOR_215_I(s, p, o, m) BOOST_PP_IF(p(216, s), m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IF(p(216, s), BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(o(216, s), p, o, m) # define BOOST_PP_FOR_216_I(s, p, o, m) BOOST_PP_IF(p(217, s), m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IF(p(217, s), BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(o(217, s), p, o, m) # define BOOST_PP_FOR_217_I(s, p, o, m) BOOST_PP_IF(p(218, s), m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IF(p(218, s), BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(o(218, s), p, o, m) # define BOOST_PP_FOR_218_I(s, p, o, m) BOOST_PP_IF(p(219, s), m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IF(p(219, s), BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(o(219, s), p, o, m) # define BOOST_PP_FOR_219_I(s, p, o, m) BOOST_PP_IF(p(220, s), m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IF(p(220, s), BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(o(220, s), p, o, m) # define BOOST_PP_FOR_220_I(s, p, o, m) BOOST_PP_IF(p(221, s), m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IF(p(221, s), BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(o(221, s), p, o, m) # define BOOST_PP_FOR_221_I(s, p, o, m) BOOST_PP_IF(p(222, s), m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IF(p(222, s), BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(o(222, s), p, o, m) # define BOOST_PP_FOR_222_I(s, p, o, m) BOOST_PP_IF(p(223, s), m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IF(p(223, s), BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(o(223, s), p, o, m) # define BOOST_PP_FOR_223_I(s, p, o, m) BOOST_PP_IF(p(224, s), m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IF(p(224, s), BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(o(224, s), p, o, m) # define BOOST_PP_FOR_224_I(s, p, o, m) BOOST_PP_IF(p(225, s), m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IF(p(225, s), BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(o(225, s), p, o, m) # define BOOST_PP_FOR_225_I(s, p, o, m) BOOST_PP_IF(p(226, s), m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IF(p(226, s), BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(o(226, s), p, o, m) # define BOOST_PP_FOR_226_I(s, p, o, m) BOOST_PP_IF(p(227, s), m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IF(p(227, s), BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(o(227, s), p, o, m) # define BOOST_PP_FOR_227_I(s, p, o, m) BOOST_PP_IF(p(228, s), m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IF(p(228, s), BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(o(228, s), p, o, m) # define BOOST_PP_FOR_228_I(s, p, o, m) BOOST_PP_IF(p(229, s), m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IF(p(229, s), BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(o(229, s), p, o, m) # define BOOST_PP_FOR_229_I(s, p, o, m) BOOST_PP_IF(p(230, s), m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IF(p(230, s), BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(o(230, s), p, o, m) # define BOOST_PP_FOR_230_I(s, p, o, m) BOOST_PP_IF(p(231, s), m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IF(p(231, s), BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(o(231, s), p, o, m) # define BOOST_PP_FOR_231_I(s, p, o, m) BOOST_PP_IF(p(232, s), m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IF(p(232, s), BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(o(232, s), p, o, m) # define BOOST_PP_FOR_232_I(s, p, o, m) BOOST_PP_IF(p(233, s), m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IF(p(233, s), BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(o(233, s), p, o, m) # define BOOST_PP_FOR_233_I(s, p, o, m) BOOST_PP_IF(p(234, s), m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IF(p(234, s), BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(o(234, s), p, o, m) # define BOOST_PP_FOR_234_I(s, p, o, m) BOOST_PP_IF(p(235, s), m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IF(p(235, s), BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(o(235, s), p, o, m) # define BOOST_PP_FOR_235_I(s, p, o, m) BOOST_PP_IF(p(236, s), m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IF(p(236, s), BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(o(236, s), p, o, m) # define BOOST_PP_FOR_236_I(s, p, o, m) BOOST_PP_IF(p(237, s), m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IF(p(237, s), BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(o(237, s), p, o, m) # define BOOST_PP_FOR_237_I(s, p, o, m) BOOST_PP_IF(p(238, s), m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IF(p(238, s), BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(o(238, s), p, o, m) # define BOOST_PP_FOR_238_I(s, p, o, m) BOOST_PP_IF(p(239, s), m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IF(p(239, s), BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(o(239, s), p, o, m) # define BOOST_PP_FOR_239_I(s, p, o, m) BOOST_PP_IF(p(240, s), m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IF(p(240, s), BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(o(240, s), p, o, m) # define BOOST_PP_FOR_240_I(s, p, o, m) BOOST_PP_IF(p(241, s), m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IF(p(241, s), BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(o(241, s), p, o, m) # define BOOST_PP_FOR_241_I(s, p, o, m) BOOST_PP_IF(p(242, s), m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IF(p(242, s), BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(o(242, s), p, o, m) # define BOOST_PP_FOR_242_I(s, p, o, m) BOOST_PP_IF(p(243, s), m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IF(p(243, s), BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(o(243, s), p, o, m) # define BOOST_PP_FOR_243_I(s, p, o, m) BOOST_PP_IF(p(244, s), m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IF(p(244, s), BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(o(244, s), p, o, m) # define BOOST_PP_FOR_244_I(s, p, o, m) BOOST_PP_IF(p(245, s), m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IF(p(245, s), BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(o(245, s), p, o, m) # define BOOST_PP_FOR_245_I(s, p, o, m) BOOST_PP_IF(p(246, s), m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IF(p(246, s), BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(o(246, s), p, o, m) # define BOOST_PP_FOR_246_I(s, p, o, m) BOOST_PP_IF(p(247, s), m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IF(p(247, s), BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(o(247, s), p, o, m) # define BOOST_PP_FOR_247_I(s, p, o, m) BOOST_PP_IF(p(248, s), m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IF(p(248, s), BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(o(248, s), p, o, m) # define BOOST_PP_FOR_248_I(s, p, o, m) BOOST_PP_IF(p(249, s), m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IF(p(249, s), BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(o(249, s), p, o, m) # define BOOST_PP_FOR_249_I(s, p, o, m) BOOST_PP_IF(p(250, s), m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IF(p(250, s), BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(o(250, s), p, o, m) # define BOOST_PP_FOR_250_I(s, p, o, m) BOOST_PP_IF(p(251, s), m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IF(p(251, s), BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(o(251, s), p, o, m) # define BOOST_PP_FOR_251_I(s, p, o, m) BOOST_PP_IF(p(252, s), m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IF(p(252, s), BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(o(252, s), p, o, m) # define BOOST_PP_FOR_252_I(s, p, o, m) BOOST_PP_IF(p(253, s), m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IF(p(253, s), BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(o(253, s), p, o, m) # define BOOST_PP_FOR_253_I(s, p, o, m) BOOST_PP_IF(p(254, s), m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IF(p(254, s), BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(o(254, s), p, o, m) # define BOOST_PP_FOR_254_I(s, p, o, m) BOOST_PP_IF(p(255, s), m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IF(p(255, s), BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(o(255, s), p, o, m) # define BOOST_PP_FOR_255_I(s, p, o, m) BOOST_PP_IF(p(256, s), m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IF(p(256, s), BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(o(256, s), p, o, m) # define BOOST_PP_FOR_256_I(s, p, o, m) BOOST_PP_IF(p(257, s), m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IF(p(257, s), BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(o(257, s), p, o, m) # # endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/msvc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000755000175000017500000000000012146213770031750 5ustar debiandebian././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetition/detail/msvc/for.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/repetiti0000644000175000017500000013030411344301502031741 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_REPETITION_DETAIL_MSVC_FOR_HPP # define BOOST_PREPROCESSOR_REPETITION_DETAIL_MSVC_FOR_HPP # # include # include # # define BOOST_PP_FOR_1(s, p, o, m) BOOST_PP_IF(p(2, s), m, BOOST_PP_TUPLE_EAT_2)(2, s) BOOST_PP_IF(p(2, s), BOOST_PP_FOR_2, BOOST_PP_TUPLE_EAT_4)(o(2, s), p, o, m) # define BOOST_PP_FOR_2(s, p, o, m) BOOST_PP_IF(p(3, s), m, BOOST_PP_TUPLE_EAT_2)(3, s) BOOST_PP_IF(p(3, s), BOOST_PP_FOR_3, BOOST_PP_TUPLE_EAT_4)(o(3, s), p, o, m) # define BOOST_PP_FOR_3(s, p, o, m) BOOST_PP_IF(p(4, s), m, BOOST_PP_TUPLE_EAT_2)(4, s) BOOST_PP_IF(p(4, s), BOOST_PP_FOR_4, BOOST_PP_TUPLE_EAT_4)(o(4, s), p, o, m) # define BOOST_PP_FOR_4(s, p, o, m) BOOST_PP_IF(p(5, s), m, BOOST_PP_TUPLE_EAT_2)(5, s) BOOST_PP_IF(p(5, s), BOOST_PP_FOR_5, BOOST_PP_TUPLE_EAT_4)(o(5, s), p, o, m) # define BOOST_PP_FOR_5(s, p, o, m) BOOST_PP_IF(p(6, s), m, BOOST_PP_TUPLE_EAT_2)(6, s) BOOST_PP_IF(p(6, s), BOOST_PP_FOR_6, BOOST_PP_TUPLE_EAT_4)(o(6, s), p, o, m) # define BOOST_PP_FOR_6(s, p, o, m) BOOST_PP_IF(p(7, s), m, BOOST_PP_TUPLE_EAT_2)(7, s) BOOST_PP_IF(p(7, s), BOOST_PP_FOR_7, BOOST_PP_TUPLE_EAT_4)(o(7, s), p, o, m) # define BOOST_PP_FOR_7(s, p, o, m) BOOST_PP_IF(p(8, s), m, BOOST_PP_TUPLE_EAT_2)(8, s) BOOST_PP_IF(p(8, s), BOOST_PP_FOR_8, BOOST_PP_TUPLE_EAT_4)(o(8, s), p, o, m) # define BOOST_PP_FOR_8(s, p, o, m) BOOST_PP_IF(p(9, s), m, BOOST_PP_TUPLE_EAT_2)(9, s) BOOST_PP_IF(p(9, s), BOOST_PP_FOR_9, BOOST_PP_TUPLE_EAT_4)(o(9, s), p, o, m) # define BOOST_PP_FOR_9(s, p, o, m) BOOST_PP_IF(p(10, s), m, BOOST_PP_TUPLE_EAT_2)(10, s) BOOST_PP_IF(p(10, s), BOOST_PP_FOR_10, BOOST_PP_TUPLE_EAT_4)(o(10, s), p, o, m) # define BOOST_PP_FOR_10(s, p, o, m) BOOST_PP_IF(p(11, s), m, BOOST_PP_TUPLE_EAT_2)(11, s) BOOST_PP_IF(p(11, s), BOOST_PP_FOR_11, BOOST_PP_TUPLE_EAT_4)(o(11, s), p, o, m) # define BOOST_PP_FOR_11(s, p, o, m) BOOST_PP_IF(p(12, s), m, BOOST_PP_TUPLE_EAT_2)(12, s) BOOST_PP_IF(p(12, s), BOOST_PP_FOR_12, BOOST_PP_TUPLE_EAT_4)(o(12, s), p, o, m) # define BOOST_PP_FOR_12(s, p, o, m) BOOST_PP_IF(p(13, s), m, BOOST_PP_TUPLE_EAT_2)(13, s) BOOST_PP_IF(p(13, s), BOOST_PP_FOR_13, BOOST_PP_TUPLE_EAT_4)(o(13, s), p, o, m) # define BOOST_PP_FOR_13(s, p, o, m) BOOST_PP_IF(p(14, s), m, BOOST_PP_TUPLE_EAT_2)(14, s) BOOST_PP_IF(p(14, s), BOOST_PP_FOR_14, BOOST_PP_TUPLE_EAT_4)(o(14, s), p, o, m) # define BOOST_PP_FOR_14(s, p, o, m) BOOST_PP_IF(p(15, s), m, BOOST_PP_TUPLE_EAT_2)(15, s) BOOST_PP_IF(p(15, s), BOOST_PP_FOR_15, BOOST_PP_TUPLE_EAT_4)(o(15, s), p, o, m) # define BOOST_PP_FOR_15(s, p, o, m) BOOST_PP_IF(p(16, s), m, BOOST_PP_TUPLE_EAT_2)(16, s) BOOST_PP_IF(p(16, s), BOOST_PP_FOR_16, BOOST_PP_TUPLE_EAT_4)(o(16, s), p, o, m) # define BOOST_PP_FOR_16(s, p, o, m) BOOST_PP_IF(p(17, s), m, BOOST_PP_TUPLE_EAT_2)(17, s) BOOST_PP_IF(p(17, s), BOOST_PP_FOR_17, BOOST_PP_TUPLE_EAT_4)(o(17, s), p, o, m) # define BOOST_PP_FOR_17(s, p, o, m) BOOST_PP_IF(p(18, s), m, BOOST_PP_TUPLE_EAT_2)(18, s) BOOST_PP_IF(p(18, s), BOOST_PP_FOR_18, BOOST_PP_TUPLE_EAT_4)(o(18, s), p, o, m) # define BOOST_PP_FOR_18(s, p, o, m) BOOST_PP_IF(p(19, s), m, BOOST_PP_TUPLE_EAT_2)(19, s) BOOST_PP_IF(p(19, s), BOOST_PP_FOR_19, BOOST_PP_TUPLE_EAT_4)(o(19, s), p, o, m) # define BOOST_PP_FOR_19(s, p, o, m) BOOST_PP_IF(p(20, s), m, BOOST_PP_TUPLE_EAT_2)(20, s) BOOST_PP_IF(p(20, s), BOOST_PP_FOR_20, BOOST_PP_TUPLE_EAT_4)(o(20, s), p, o, m) # define BOOST_PP_FOR_20(s, p, o, m) BOOST_PP_IF(p(21, s), m, BOOST_PP_TUPLE_EAT_2)(21, s) BOOST_PP_IF(p(21, s), BOOST_PP_FOR_21, BOOST_PP_TUPLE_EAT_4)(o(21, s), p, o, m) # define BOOST_PP_FOR_21(s, p, o, m) BOOST_PP_IF(p(22, s), m, BOOST_PP_TUPLE_EAT_2)(22, s) BOOST_PP_IF(p(22, s), BOOST_PP_FOR_22, BOOST_PP_TUPLE_EAT_4)(o(22, s), p, o, m) # define BOOST_PP_FOR_22(s, p, o, m) BOOST_PP_IF(p(23, s), m, BOOST_PP_TUPLE_EAT_2)(23, s) BOOST_PP_IF(p(23, s), BOOST_PP_FOR_23, BOOST_PP_TUPLE_EAT_4)(o(23, s), p, o, m) # define BOOST_PP_FOR_23(s, p, o, m) BOOST_PP_IF(p(24, s), m, BOOST_PP_TUPLE_EAT_2)(24, s) BOOST_PP_IF(p(24, s), BOOST_PP_FOR_24, BOOST_PP_TUPLE_EAT_4)(o(24, s), p, o, m) # define BOOST_PP_FOR_24(s, p, o, m) BOOST_PP_IF(p(25, s), m, BOOST_PP_TUPLE_EAT_2)(25, s) BOOST_PP_IF(p(25, s), BOOST_PP_FOR_25, BOOST_PP_TUPLE_EAT_4)(o(25, s), p, o, m) # define BOOST_PP_FOR_25(s, p, o, m) BOOST_PP_IF(p(26, s), m, BOOST_PP_TUPLE_EAT_2)(26, s) BOOST_PP_IF(p(26, s), BOOST_PP_FOR_26, BOOST_PP_TUPLE_EAT_4)(o(26, s), p, o, m) # define BOOST_PP_FOR_26(s, p, o, m) BOOST_PP_IF(p(27, s), m, BOOST_PP_TUPLE_EAT_2)(27, s) BOOST_PP_IF(p(27, s), BOOST_PP_FOR_27, BOOST_PP_TUPLE_EAT_4)(o(27, s), p, o, m) # define BOOST_PP_FOR_27(s, p, o, m) BOOST_PP_IF(p(28, s), m, BOOST_PP_TUPLE_EAT_2)(28, s) BOOST_PP_IF(p(28, s), BOOST_PP_FOR_28, BOOST_PP_TUPLE_EAT_4)(o(28, s), p, o, m) # define BOOST_PP_FOR_28(s, p, o, m) BOOST_PP_IF(p(29, s), m, BOOST_PP_TUPLE_EAT_2)(29, s) BOOST_PP_IF(p(29, s), BOOST_PP_FOR_29, BOOST_PP_TUPLE_EAT_4)(o(29, s), p, o, m) # define BOOST_PP_FOR_29(s, p, o, m) BOOST_PP_IF(p(30, s), m, BOOST_PP_TUPLE_EAT_2)(30, s) BOOST_PP_IF(p(30, s), BOOST_PP_FOR_30, BOOST_PP_TUPLE_EAT_4)(o(30, s), p, o, m) # define BOOST_PP_FOR_30(s, p, o, m) BOOST_PP_IF(p(31, s), m, BOOST_PP_TUPLE_EAT_2)(31, s) BOOST_PP_IF(p(31, s), BOOST_PP_FOR_31, BOOST_PP_TUPLE_EAT_4)(o(31, s), p, o, m) # define BOOST_PP_FOR_31(s, p, o, m) BOOST_PP_IF(p(32, s), m, BOOST_PP_TUPLE_EAT_2)(32, s) BOOST_PP_IF(p(32, s), BOOST_PP_FOR_32, BOOST_PP_TUPLE_EAT_4)(o(32, s), p, o, m) # define BOOST_PP_FOR_32(s, p, o, m) BOOST_PP_IF(p(33, s), m, BOOST_PP_TUPLE_EAT_2)(33, s) BOOST_PP_IF(p(33, s), BOOST_PP_FOR_33, BOOST_PP_TUPLE_EAT_4)(o(33, s), p, o, m) # define BOOST_PP_FOR_33(s, p, o, m) BOOST_PP_IF(p(34, s), m, BOOST_PP_TUPLE_EAT_2)(34, s) BOOST_PP_IF(p(34, s), BOOST_PP_FOR_34, BOOST_PP_TUPLE_EAT_4)(o(34, s), p, o, m) # define BOOST_PP_FOR_34(s, p, o, m) BOOST_PP_IF(p(35, s), m, BOOST_PP_TUPLE_EAT_2)(35, s) BOOST_PP_IF(p(35, s), BOOST_PP_FOR_35, BOOST_PP_TUPLE_EAT_4)(o(35, s), p, o, m) # define BOOST_PP_FOR_35(s, p, o, m) BOOST_PP_IF(p(36, s), m, BOOST_PP_TUPLE_EAT_2)(36, s) BOOST_PP_IF(p(36, s), BOOST_PP_FOR_36, BOOST_PP_TUPLE_EAT_4)(o(36, s), p, o, m) # define BOOST_PP_FOR_36(s, p, o, m) BOOST_PP_IF(p(37, s), m, BOOST_PP_TUPLE_EAT_2)(37, s) BOOST_PP_IF(p(37, s), BOOST_PP_FOR_37, BOOST_PP_TUPLE_EAT_4)(o(37, s), p, o, m) # define BOOST_PP_FOR_37(s, p, o, m) BOOST_PP_IF(p(38, s), m, BOOST_PP_TUPLE_EAT_2)(38, s) BOOST_PP_IF(p(38, s), BOOST_PP_FOR_38, BOOST_PP_TUPLE_EAT_4)(o(38, s), p, o, m) # define BOOST_PP_FOR_38(s, p, o, m) BOOST_PP_IF(p(39, s), m, BOOST_PP_TUPLE_EAT_2)(39, s) BOOST_PP_IF(p(39, s), BOOST_PP_FOR_39, BOOST_PP_TUPLE_EAT_4)(o(39, s), p, o, m) # define BOOST_PP_FOR_39(s, p, o, m) BOOST_PP_IF(p(40, s), m, BOOST_PP_TUPLE_EAT_2)(40, s) BOOST_PP_IF(p(40, s), BOOST_PP_FOR_40, BOOST_PP_TUPLE_EAT_4)(o(40, s), p, o, m) # define BOOST_PP_FOR_40(s, p, o, m) BOOST_PP_IF(p(41, s), m, BOOST_PP_TUPLE_EAT_2)(41, s) BOOST_PP_IF(p(41, s), BOOST_PP_FOR_41, BOOST_PP_TUPLE_EAT_4)(o(41, s), p, o, m) # define BOOST_PP_FOR_41(s, p, o, m) BOOST_PP_IF(p(42, s), m, BOOST_PP_TUPLE_EAT_2)(42, s) BOOST_PP_IF(p(42, s), BOOST_PP_FOR_42, BOOST_PP_TUPLE_EAT_4)(o(42, s), p, o, m) # define BOOST_PP_FOR_42(s, p, o, m) BOOST_PP_IF(p(43, s), m, BOOST_PP_TUPLE_EAT_2)(43, s) BOOST_PP_IF(p(43, s), BOOST_PP_FOR_43, BOOST_PP_TUPLE_EAT_4)(o(43, s), p, o, m) # define BOOST_PP_FOR_43(s, p, o, m) BOOST_PP_IF(p(44, s), m, BOOST_PP_TUPLE_EAT_2)(44, s) BOOST_PP_IF(p(44, s), BOOST_PP_FOR_44, BOOST_PP_TUPLE_EAT_4)(o(44, s), p, o, m) # define BOOST_PP_FOR_44(s, p, o, m) BOOST_PP_IF(p(45, s), m, BOOST_PP_TUPLE_EAT_2)(45, s) BOOST_PP_IF(p(45, s), BOOST_PP_FOR_45, BOOST_PP_TUPLE_EAT_4)(o(45, s), p, o, m) # define BOOST_PP_FOR_45(s, p, o, m) BOOST_PP_IF(p(46, s), m, BOOST_PP_TUPLE_EAT_2)(46, s) BOOST_PP_IF(p(46, s), BOOST_PP_FOR_46, BOOST_PP_TUPLE_EAT_4)(o(46, s), p, o, m) # define BOOST_PP_FOR_46(s, p, o, m) BOOST_PP_IF(p(47, s), m, BOOST_PP_TUPLE_EAT_2)(47, s) BOOST_PP_IF(p(47, s), BOOST_PP_FOR_47, BOOST_PP_TUPLE_EAT_4)(o(47, s), p, o, m) # define BOOST_PP_FOR_47(s, p, o, m) BOOST_PP_IF(p(48, s), m, BOOST_PP_TUPLE_EAT_2)(48, s) BOOST_PP_IF(p(48, s), BOOST_PP_FOR_48, BOOST_PP_TUPLE_EAT_4)(o(48, s), p, o, m) # define BOOST_PP_FOR_48(s, p, o, m) BOOST_PP_IF(p(49, s), m, BOOST_PP_TUPLE_EAT_2)(49, s) BOOST_PP_IF(p(49, s), BOOST_PP_FOR_49, BOOST_PP_TUPLE_EAT_4)(o(49, s), p, o, m) # define BOOST_PP_FOR_49(s, p, o, m) BOOST_PP_IF(p(50, s), m, BOOST_PP_TUPLE_EAT_2)(50, s) BOOST_PP_IF(p(50, s), BOOST_PP_FOR_50, BOOST_PP_TUPLE_EAT_4)(o(50, s), p, o, m) # define BOOST_PP_FOR_50(s, p, o, m) BOOST_PP_IF(p(51, s), m, BOOST_PP_TUPLE_EAT_2)(51, s) BOOST_PP_IF(p(51, s), BOOST_PP_FOR_51, BOOST_PP_TUPLE_EAT_4)(o(51, s), p, o, m) # define BOOST_PP_FOR_51(s, p, o, m) BOOST_PP_IF(p(52, s), m, BOOST_PP_TUPLE_EAT_2)(52, s) BOOST_PP_IF(p(52, s), BOOST_PP_FOR_52, BOOST_PP_TUPLE_EAT_4)(o(52, s), p, o, m) # define BOOST_PP_FOR_52(s, p, o, m) BOOST_PP_IF(p(53, s), m, BOOST_PP_TUPLE_EAT_2)(53, s) BOOST_PP_IF(p(53, s), BOOST_PP_FOR_53, BOOST_PP_TUPLE_EAT_4)(o(53, s), p, o, m) # define BOOST_PP_FOR_53(s, p, o, m) BOOST_PP_IF(p(54, s), m, BOOST_PP_TUPLE_EAT_2)(54, s) BOOST_PP_IF(p(54, s), BOOST_PP_FOR_54, BOOST_PP_TUPLE_EAT_4)(o(54, s), p, o, m) # define BOOST_PP_FOR_54(s, p, o, m) BOOST_PP_IF(p(55, s), m, BOOST_PP_TUPLE_EAT_2)(55, s) BOOST_PP_IF(p(55, s), BOOST_PP_FOR_55, BOOST_PP_TUPLE_EAT_4)(o(55, s), p, o, m) # define BOOST_PP_FOR_55(s, p, o, m) BOOST_PP_IF(p(56, s), m, BOOST_PP_TUPLE_EAT_2)(56, s) BOOST_PP_IF(p(56, s), BOOST_PP_FOR_56, BOOST_PP_TUPLE_EAT_4)(o(56, s), p, o, m) # define BOOST_PP_FOR_56(s, p, o, m) BOOST_PP_IF(p(57, s), m, BOOST_PP_TUPLE_EAT_2)(57, s) BOOST_PP_IF(p(57, s), BOOST_PP_FOR_57, BOOST_PP_TUPLE_EAT_4)(o(57, s), p, o, m) # define BOOST_PP_FOR_57(s, p, o, m) BOOST_PP_IF(p(58, s), m, BOOST_PP_TUPLE_EAT_2)(58, s) BOOST_PP_IF(p(58, s), BOOST_PP_FOR_58, BOOST_PP_TUPLE_EAT_4)(o(58, s), p, o, m) # define BOOST_PP_FOR_58(s, p, o, m) BOOST_PP_IF(p(59, s), m, BOOST_PP_TUPLE_EAT_2)(59, s) BOOST_PP_IF(p(59, s), BOOST_PP_FOR_59, BOOST_PP_TUPLE_EAT_4)(o(59, s), p, o, m) # define BOOST_PP_FOR_59(s, p, o, m) BOOST_PP_IF(p(60, s), m, BOOST_PP_TUPLE_EAT_2)(60, s) BOOST_PP_IF(p(60, s), BOOST_PP_FOR_60, BOOST_PP_TUPLE_EAT_4)(o(60, s), p, o, m) # define BOOST_PP_FOR_60(s, p, o, m) BOOST_PP_IF(p(61, s), m, BOOST_PP_TUPLE_EAT_2)(61, s) BOOST_PP_IF(p(61, s), BOOST_PP_FOR_61, BOOST_PP_TUPLE_EAT_4)(o(61, s), p, o, m) # define BOOST_PP_FOR_61(s, p, o, m) BOOST_PP_IF(p(62, s), m, BOOST_PP_TUPLE_EAT_2)(62, s) BOOST_PP_IF(p(62, s), BOOST_PP_FOR_62, BOOST_PP_TUPLE_EAT_4)(o(62, s), p, o, m) # define BOOST_PP_FOR_62(s, p, o, m) BOOST_PP_IF(p(63, s), m, BOOST_PP_TUPLE_EAT_2)(63, s) BOOST_PP_IF(p(63, s), BOOST_PP_FOR_63, BOOST_PP_TUPLE_EAT_4)(o(63, s), p, o, m) # define BOOST_PP_FOR_63(s, p, o, m) BOOST_PP_IF(p(64, s), m, BOOST_PP_TUPLE_EAT_2)(64, s) BOOST_PP_IF(p(64, s), BOOST_PP_FOR_64, BOOST_PP_TUPLE_EAT_4)(o(64, s), p, o, m) # define BOOST_PP_FOR_64(s, p, o, m) BOOST_PP_IF(p(65, s), m, BOOST_PP_TUPLE_EAT_2)(65, s) BOOST_PP_IF(p(65, s), BOOST_PP_FOR_65, BOOST_PP_TUPLE_EAT_4)(o(65, s), p, o, m) # define BOOST_PP_FOR_65(s, p, o, m) BOOST_PP_IF(p(66, s), m, BOOST_PP_TUPLE_EAT_2)(66, s) BOOST_PP_IF(p(66, s), BOOST_PP_FOR_66, BOOST_PP_TUPLE_EAT_4)(o(66, s), p, o, m) # define BOOST_PP_FOR_66(s, p, o, m) BOOST_PP_IF(p(67, s), m, BOOST_PP_TUPLE_EAT_2)(67, s) BOOST_PP_IF(p(67, s), BOOST_PP_FOR_67, BOOST_PP_TUPLE_EAT_4)(o(67, s), p, o, m) # define BOOST_PP_FOR_67(s, p, o, m) BOOST_PP_IF(p(68, s), m, BOOST_PP_TUPLE_EAT_2)(68, s) BOOST_PP_IF(p(68, s), BOOST_PP_FOR_68, BOOST_PP_TUPLE_EAT_4)(o(68, s), p, o, m) # define BOOST_PP_FOR_68(s, p, o, m) BOOST_PP_IF(p(69, s), m, BOOST_PP_TUPLE_EAT_2)(69, s) BOOST_PP_IF(p(69, s), BOOST_PP_FOR_69, BOOST_PP_TUPLE_EAT_4)(o(69, s), p, o, m) # define BOOST_PP_FOR_69(s, p, o, m) BOOST_PP_IF(p(70, s), m, BOOST_PP_TUPLE_EAT_2)(70, s) BOOST_PP_IF(p(70, s), BOOST_PP_FOR_70, BOOST_PP_TUPLE_EAT_4)(o(70, s), p, o, m) # define BOOST_PP_FOR_70(s, p, o, m) BOOST_PP_IF(p(71, s), m, BOOST_PP_TUPLE_EAT_2)(71, s) BOOST_PP_IF(p(71, s), BOOST_PP_FOR_71, BOOST_PP_TUPLE_EAT_4)(o(71, s), p, o, m) # define BOOST_PP_FOR_71(s, p, o, m) BOOST_PP_IF(p(72, s), m, BOOST_PP_TUPLE_EAT_2)(72, s) BOOST_PP_IF(p(72, s), BOOST_PP_FOR_72, BOOST_PP_TUPLE_EAT_4)(o(72, s), p, o, m) # define BOOST_PP_FOR_72(s, p, o, m) BOOST_PP_IF(p(73, s), m, BOOST_PP_TUPLE_EAT_2)(73, s) BOOST_PP_IF(p(73, s), BOOST_PP_FOR_73, BOOST_PP_TUPLE_EAT_4)(o(73, s), p, o, m) # define BOOST_PP_FOR_73(s, p, o, m) BOOST_PP_IF(p(74, s), m, BOOST_PP_TUPLE_EAT_2)(74, s) BOOST_PP_IF(p(74, s), BOOST_PP_FOR_74, BOOST_PP_TUPLE_EAT_4)(o(74, s), p, o, m) # define BOOST_PP_FOR_74(s, p, o, m) BOOST_PP_IF(p(75, s), m, BOOST_PP_TUPLE_EAT_2)(75, s) BOOST_PP_IF(p(75, s), BOOST_PP_FOR_75, BOOST_PP_TUPLE_EAT_4)(o(75, s), p, o, m) # define BOOST_PP_FOR_75(s, p, o, m) BOOST_PP_IF(p(76, s), m, BOOST_PP_TUPLE_EAT_2)(76, s) BOOST_PP_IF(p(76, s), BOOST_PP_FOR_76, BOOST_PP_TUPLE_EAT_4)(o(76, s), p, o, m) # define BOOST_PP_FOR_76(s, p, o, m) BOOST_PP_IF(p(77, s), m, BOOST_PP_TUPLE_EAT_2)(77, s) BOOST_PP_IF(p(77, s), BOOST_PP_FOR_77, BOOST_PP_TUPLE_EAT_4)(o(77, s), p, o, m) # define BOOST_PP_FOR_77(s, p, o, m) BOOST_PP_IF(p(78, s), m, BOOST_PP_TUPLE_EAT_2)(78, s) BOOST_PP_IF(p(78, s), BOOST_PP_FOR_78, BOOST_PP_TUPLE_EAT_4)(o(78, s), p, o, m) # define BOOST_PP_FOR_78(s, p, o, m) BOOST_PP_IF(p(79, s), m, BOOST_PP_TUPLE_EAT_2)(79, s) BOOST_PP_IF(p(79, s), BOOST_PP_FOR_79, BOOST_PP_TUPLE_EAT_4)(o(79, s), p, o, m) # define BOOST_PP_FOR_79(s, p, o, m) BOOST_PP_IF(p(80, s), m, BOOST_PP_TUPLE_EAT_2)(80, s) BOOST_PP_IF(p(80, s), BOOST_PP_FOR_80, BOOST_PP_TUPLE_EAT_4)(o(80, s), p, o, m) # define BOOST_PP_FOR_80(s, p, o, m) BOOST_PP_IF(p(81, s), m, BOOST_PP_TUPLE_EAT_2)(81, s) BOOST_PP_IF(p(81, s), BOOST_PP_FOR_81, BOOST_PP_TUPLE_EAT_4)(o(81, s), p, o, m) # define BOOST_PP_FOR_81(s, p, o, m) BOOST_PP_IF(p(82, s), m, BOOST_PP_TUPLE_EAT_2)(82, s) BOOST_PP_IF(p(82, s), BOOST_PP_FOR_82, BOOST_PP_TUPLE_EAT_4)(o(82, s), p, o, m) # define BOOST_PP_FOR_82(s, p, o, m) BOOST_PP_IF(p(83, s), m, BOOST_PP_TUPLE_EAT_2)(83, s) BOOST_PP_IF(p(83, s), BOOST_PP_FOR_83, BOOST_PP_TUPLE_EAT_4)(o(83, s), p, o, m) # define BOOST_PP_FOR_83(s, p, o, m) BOOST_PP_IF(p(84, s), m, BOOST_PP_TUPLE_EAT_2)(84, s) BOOST_PP_IF(p(84, s), BOOST_PP_FOR_84, BOOST_PP_TUPLE_EAT_4)(o(84, s), p, o, m) # define BOOST_PP_FOR_84(s, p, o, m) BOOST_PP_IF(p(85, s), m, BOOST_PP_TUPLE_EAT_2)(85, s) BOOST_PP_IF(p(85, s), BOOST_PP_FOR_85, BOOST_PP_TUPLE_EAT_4)(o(85, s), p, o, m) # define BOOST_PP_FOR_85(s, p, o, m) BOOST_PP_IF(p(86, s), m, BOOST_PP_TUPLE_EAT_2)(86, s) BOOST_PP_IF(p(86, s), BOOST_PP_FOR_86, BOOST_PP_TUPLE_EAT_4)(o(86, s), p, o, m) # define BOOST_PP_FOR_86(s, p, o, m) BOOST_PP_IF(p(87, s), m, BOOST_PP_TUPLE_EAT_2)(87, s) BOOST_PP_IF(p(87, s), BOOST_PP_FOR_87, BOOST_PP_TUPLE_EAT_4)(o(87, s), p, o, m) # define BOOST_PP_FOR_87(s, p, o, m) BOOST_PP_IF(p(88, s), m, BOOST_PP_TUPLE_EAT_2)(88, s) BOOST_PP_IF(p(88, s), BOOST_PP_FOR_88, BOOST_PP_TUPLE_EAT_4)(o(88, s), p, o, m) # define BOOST_PP_FOR_88(s, p, o, m) BOOST_PP_IF(p(89, s), m, BOOST_PP_TUPLE_EAT_2)(89, s) BOOST_PP_IF(p(89, s), BOOST_PP_FOR_89, BOOST_PP_TUPLE_EAT_4)(o(89, s), p, o, m) # define BOOST_PP_FOR_89(s, p, o, m) BOOST_PP_IF(p(90, s), m, BOOST_PP_TUPLE_EAT_2)(90, s) BOOST_PP_IF(p(90, s), BOOST_PP_FOR_90, BOOST_PP_TUPLE_EAT_4)(o(90, s), p, o, m) # define BOOST_PP_FOR_90(s, p, o, m) BOOST_PP_IF(p(91, s), m, BOOST_PP_TUPLE_EAT_2)(91, s) BOOST_PP_IF(p(91, s), BOOST_PP_FOR_91, BOOST_PP_TUPLE_EAT_4)(o(91, s), p, o, m) # define BOOST_PP_FOR_91(s, p, o, m) BOOST_PP_IF(p(92, s), m, BOOST_PP_TUPLE_EAT_2)(92, s) BOOST_PP_IF(p(92, s), BOOST_PP_FOR_92, BOOST_PP_TUPLE_EAT_4)(o(92, s), p, o, m) # define BOOST_PP_FOR_92(s, p, o, m) BOOST_PP_IF(p(93, s), m, BOOST_PP_TUPLE_EAT_2)(93, s) BOOST_PP_IF(p(93, s), BOOST_PP_FOR_93, BOOST_PP_TUPLE_EAT_4)(o(93, s), p, o, m) # define BOOST_PP_FOR_93(s, p, o, m) BOOST_PP_IF(p(94, s), m, BOOST_PP_TUPLE_EAT_2)(94, s) BOOST_PP_IF(p(94, s), BOOST_PP_FOR_94, BOOST_PP_TUPLE_EAT_4)(o(94, s), p, o, m) # define BOOST_PP_FOR_94(s, p, o, m) BOOST_PP_IF(p(95, s), m, BOOST_PP_TUPLE_EAT_2)(95, s) BOOST_PP_IF(p(95, s), BOOST_PP_FOR_95, BOOST_PP_TUPLE_EAT_4)(o(95, s), p, o, m) # define BOOST_PP_FOR_95(s, p, o, m) BOOST_PP_IF(p(96, s), m, BOOST_PP_TUPLE_EAT_2)(96, s) BOOST_PP_IF(p(96, s), BOOST_PP_FOR_96, BOOST_PP_TUPLE_EAT_4)(o(96, s), p, o, m) # define BOOST_PP_FOR_96(s, p, o, m) BOOST_PP_IF(p(97, s), m, BOOST_PP_TUPLE_EAT_2)(97, s) BOOST_PP_IF(p(97, s), BOOST_PP_FOR_97, BOOST_PP_TUPLE_EAT_4)(o(97, s), p, o, m) # define BOOST_PP_FOR_97(s, p, o, m) BOOST_PP_IF(p(98, s), m, BOOST_PP_TUPLE_EAT_2)(98, s) BOOST_PP_IF(p(98, s), BOOST_PP_FOR_98, BOOST_PP_TUPLE_EAT_4)(o(98, s), p, o, m) # define BOOST_PP_FOR_98(s, p, o, m) BOOST_PP_IF(p(99, s), m, BOOST_PP_TUPLE_EAT_2)(99, s) BOOST_PP_IF(p(99, s), BOOST_PP_FOR_99, BOOST_PP_TUPLE_EAT_4)(o(99, s), p, o, m) # define BOOST_PP_FOR_99(s, p, o, m) BOOST_PP_IF(p(100, s), m, BOOST_PP_TUPLE_EAT_2)(100, s) BOOST_PP_IF(p(100, s), BOOST_PP_FOR_100, BOOST_PP_TUPLE_EAT_4)(o(100, s), p, o, m) # define BOOST_PP_FOR_100(s, p, o, m) BOOST_PP_IF(p(101, s), m, BOOST_PP_TUPLE_EAT_2)(101, s) BOOST_PP_IF(p(101, s), BOOST_PP_FOR_101, BOOST_PP_TUPLE_EAT_4)(o(101, s), p, o, m) # define BOOST_PP_FOR_101(s, p, o, m) BOOST_PP_IF(p(102, s), m, BOOST_PP_TUPLE_EAT_2)(102, s) BOOST_PP_IF(p(102, s), BOOST_PP_FOR_102, BOOST_PP_TUPLE_EAT_4)(o(102, s), p, o, m) # define BOOST_PP_FOR_102(s, p, o, m) BOOST_PP_IF(p(103, s), m, BOOST_PP_TUPLE_EAT_2)(103, s) BOOST_PP_IF(p(103, s), BOOST_PP_FOR_103, BOOST_PP_TUPLE_EAT_4)(o(103, s), p, o, m) # define BOOST_PP_FOR_103(s, p, o, m) BOOST_PP_IF(p(104, s), m, BOOST_PP_TUPLE_EAT_2)(104, s) BOOST_PP_IF(p(104, s), BOOST_PP_FOR_104, BOOST_PP_TUPLE_EAT_4)(o(104, s), p, o, m) # define BOOST_PP_FOR_104(s, p, o, m) BOOST_PP_IF(p(105, s), m, BOOST_PP_TUPLE_EAT_2)(105, s) BOOST_PP_IF(p(105, s), BOOST_PP_FOR_105, BOOST_PP_TUPLE_EAT_4)(o(105, s), p, o, m) # define BOOST_PP_FOR_105(s, p, o, m) BOOST_PP_IF(p(106, s), m, BOOST_PP_TUPLE_EAT_2)(106, s) BOOST_PP_IF(p(106, s), BOOST_PP_FOR_106, BOOST_PP_TUPLE_EAT_4)(o(106, s), p, o, m) # define BOOST_PP_FOR_106(s, p, o, m) BOOST_PP_IF(p(107, s), m, BOOST_PP_TUPLE_EAT_2)(107, s) BOOST_PP_IF(p(107, s), BOOST_PP_FOR_107, BOOST_PP_TUPLE_EAT_4)(o(107, s), p, o, m) # define BOOST_PP_FOR_107(s, p, o, m) BOOST_PP_IF(p(108, s), m, BOOST_PP_TUPLE_EAT_2)(108, s) BOOST_PP_IF(p(108, s), BOOST_PP_FOR_108, BOOST_PP_TUPLE_EAT_4)(o(108, s), p, o, m) # define BOOST_PP_FOR_108(s, p, o, m) BOOST_PP_IF(p(109, s), m, BOOST_PP_TUPLE_EAT_2)(109, s) BOOST_PP_IF(p(109, s), BOOST_PP_FOR_109, BOOST_PP_TUPLE_EAT_4)(o(109, s), p, o, m) # define BOOST_PP_FOR_109(s, p, o, m) BOOST_PP_IF(p(110, s), m, BOOST_PP_TUPLE_EAT_2)(110, s) BOOST_PP_IF(p(110, s), BOOST_PP_FOR_110, BOOST_PP_TUPLE_EAT_4)(o(110, s), p, o, m) # define BOOST_PP_FOR_110(s, p, o, m) BOOST_PP_IF(p(111, s), m, BOOST_PP_TUPLE_EAT_2)(111, s) BOOST_PP_IF(p(111, s), BOOST_PP_FOR_111, BOOST_PP_TUPLE_EAT_4)(o(111, s), p, o, m) # define BOOST_PP_FOR_111(s, p, o, m) BOOST_PP_IF(p(112, s), m, BOOST_PP_TUPLE_EAT_2)(112, s) BOOST_PP_IF(p(112, s), BOOST_PP_FOR_112, BOOST_PP_TUPLE_EAT_4)(o(112, s), p, o, m) # define BOOST_PP_FOR_112(s, p, o, m) BOOST_PP_IF(p(113, s), m, BOOST_PP_TUPLE_EAT_2)(113, s) BOOST_PP_IF(p(113, s), BOOST_PP_FOR_113, BOOST_PP_TUPLE_EAT_4)(o(113, s), p, o, m) # define BOOST_PP_FOR_113(s, p, o, m) BOOST_PP_IF(p(114, s), m, BOOST_PP_TUPLE_EAT_2)(114, s) BOOST_PP_IF(p(114, s), BOOST_PP_FOR_114, BOOST_PP_TUPLE_EAT_4)(o(114, s), p, o, m) # define BOOST_PP_FOR_114(s, p, o, m) BOOST_PP_IF(p(115, s), m, BOOST_PP_TUPLE_EAT_2)(115, s) BOOST_PP_IF(p(115, s), BOOST_PP_FOR_115, BOOST_PP_TUPLE_EAT_4)(o(115, s), p, o, m) # define BOOST_PP_FOR_115(s, p, o, m) BOOST_PP_IF(p(116, s), m, BOOST_PP_TUPLE_EAT_2)(116, s) BOOST_PP_IF(p(116, s), BOOST_PP_FOR_116, BOOST_PP_TUPLE_EAT_4)(o(116, s), p, o, m) # define BOOST_PP_FOR_116(s, p, o, m) BOOST_PP_IF(p(117, s), m, BOOST_PP_TUPLE_EAT_2)(117, s) BOOST_PP_IF(p(117, s), BOOST_PP_FOR_117, BOOST_PP_TUPLE_EAT_4)(o(117, s), p, o, m) # define BOOST_PP_FOR_117(s, p, o, m) BOOST_PP_IF(p(118, s), m, BOOST_PP_TUPLE_EAT_2)(118, s) BOOST_PP_IF(p(118, s), BOOST_PP_FOR_118, BOOST_PP_TUPLE_EAT_4)(o(118, s), p, o, m) # define BOOST_PP_FOR_118(s, p, o, m) BOOST_PP_IF(p(119, s), m, BOOST_PP_TUPLE_EAT_2)(119, s) BOOST_PP_IF(p(119, s), BOOST_PP_FOR_119, BOOST_PP_TUPLE_EAT_4)(o(119, s), p, o, m) # define BOOST_PP_FOR_119(s, p, o, m) BOOST_PP_IF(p(120, s), m, BOOST_PP_TUPLE_EAT_2)(120, s) BOOST_PP_IF(p(120, s), BOOST_PP_FOR_120, BOOST_PP_TUPLE_EAT_4)(o(120, s), p, o, m) # define BOOST_PP_FOR_120(s, p, o, m) BOOST_PP_IF(p(121, s), m, BOOST_PP_TUPLE_EAT_2)(121, s) BOOST_PP_IF(p(121, s), BOOST_PP_FOR_121, BOOST_PP_TUPLE_EAT_4)(o(121, s), p, o, m) # define BOOST_PP_FOR_121(s, p, o, m) BOOST_PP_IF(p(122, s), m, BOOST_PP_TUPLE_EAT_2)(122, s) BOOST_PP_IF(p(122, s), BOOST_PP_FOR_122, BOOST_PP_TUPLE_EAT_4)(o(122, s), p, o, m) # define BOOST_PP_FOR_122(s, p, o, m) BOOST_PP_IF(p(123, s), m, BOOST_PP_TUPLE_EAT_2)(123, s) BOOST_PP_IF(p(123, s), BOOST_PP_FOR_123, BOOST_PP_TUPLE_EAT_4)(o(123, s), p, o, m) # define BOOST_PP_FOR_123(s, p, o, m) BOOST_PP_IF(p(124, s), m, BOOST_PP_TUPLE_EAT_2)(124, s) BOOST_PP_IF(p(124, s), BOOST_PP_FOR_124, BOOST_PP_TUPLE_EAT_4)(o(124, s), p, o, m) # define BOOST_PP_FOR_124(s, p, o, m) BOOST_PP_IF(p(125, s), m, BOOST_PP_TUPLE_EAT_2)(125, s) BOOST_PP_IF(p(125, s), BOOST_PP_FOR_125, BOOST_PP_TUPLE_EAT_4)(o(125, s), p, o, m) # define BOOST_PP_FOR_125(s, p, o, m) BOOST_PP_IF(p(126, s), m, BOOST_PP_TUPLE_EAT_2)(126, s) BOOST_PP_IF(p(126, s), BOOST_PP_FOR_126, BOOST_PP_TUPLE_EAT_4)(o(126, s), p, o, m) # define BOOST_PP_FOR_126(s, p, o, m) BOOST_PP_IF(p(127, s), m, BOOST_PP_TUPLE_EAT_2)(127, s) BOOST_PP_IF(p(127, s), BOOST_PP_FOR_127, BOOST_PP_TUPLE_EAT_4)(o(127, s), p, o, m) # define BOOST_PP_FOR_127(s, p, o, m) BOOST_PP_IF(p(128, s), m, BOOST_PP_TUPLE_EAT_2)(128, s) BOOST_PP_IF(p(128, s), BOOST_PP_FOR_128, BOOST_PP_TUPLE_EAT_4)(o(128, s), p, o, m) # define BOOST_PP_FOR_128(s, p, o, m) BOOST_PP_IF(p(129, s), m, BOOST_PP_TUPLE_EAT_2)(129, s) BOOST_PP_IF(p(129, s), BOOST_PP_FOR_129, BOOST_PP_TUPLE_EAT_4)(o(129, s), p, o, m) # define BOOST_PP_FOR_129(s, p, o, m) BOOST_PP_IF(p(130, s), m, BOOST_PP_TUPLE_EAT_2)(130, s) BOOST_PP_IF(p(130, s), BOOST_PP_FOR_130, BOOST_PP_TUPLE_EAT_4)(o(130, s), p, o, m) # define BOOST_PP_FOR_130(s, p, o, m) BOOST_PP_IF(p(131, s), m, BOOST_PP_TUPLE_EAT_2)(131, s) BOOST_PP_IF(p(131, s), BOOST_PP_FOR_131, BOOST_PP_TUPLE_EAT_4)(o(131, s), p, o, m) # define BOOST_PP_FOR_131(s, p, o, m) BOOST_PP_IF(p(132, s), m, BOOST_PP_TUPLE_EAT_2)(132, s) BOOST_PP_IF(p(132, s), BOOST_PP_FOR_132, BOOST_PP_TUPLE_EAT_4)(o(132, s), p, o, m) # define BOOST_PP_FOR_132(s, p, o, m) BOOST_PP_IF(p(133, s), m, BOOST_PP_TUPLE_EAT_2)(133, s) BOOST_PP_IF(p(133, s), BOOST_PP_FOR_133, BOOST_PP_TUPLE_EAT_4)(o(133, s), p, o, m) # define BOOST_PP_FOR_133(s, p, o, m) BOOST_PP_IF(p(134, s), m, BOOST_PP_TUPLE_EAT_2)(134, s) BOOST_PP_IF(p(134, s), BOOST_PP_FOR_134, BOOST_PP_TUPLE_EAT_4)(o(134, s), p, o, m) # define BOOST_PP_FOR_134(s, p, o, m) BOOST_PP_IF(p(135, s), m, BOOST_PP_TUPLE_EAT_2)(135, s) BOOST_PP_IF(p(135, s), BOOST_PP_FOR_135, BOOST_PP_TUPLE_EAT_4)(o(135, s), p, o, m) # define BOOST_PP_FOR_135(s, p, o, m) BOOST_PP_IF(p(136, s), m, BOOST_PP_TUPLE_EAT_2)(136, s) BOOST_PP_IF(p(136, s), BOOST_PP_FOR_136, BOOST_PP_TUPLE_EAT_4)(o(136, s), p, o, m) # define BOOST_PP_FOR_136(s, p, o, m) BOOST_PP_IF(p(137, s), m, BOOST_PP_TUPLE_EAT_2)(137, s) BOOST_PP_IF(p(137, s), BOOST_PP_FOR_137, BOOST_PP_TUPLE_EAT_4)(o(137, s), p, o, m) # define BOOST_PP_FOR_137(s, p, o, m) BOOST_PP_IF(p(138, s), m, BOOST_PP_TUPLE_EAT_2)(138, s) BOOST_PP_IF(p(138, s), BOOST_PP_FOR_138, BOOST_PP_TUPLE_EAT_4)(o(138, s), p, o, m) # define BOOST_PP_FOR_138(s, p, o, m) BOOST_PP_IF(p(139, s), m, BOOST_PP_TUPLE_EAT_2)(139, s) BOOST_PP_IF(p(139, s), BOOST_PP_FOR_139, BOOST_PP_TUPLE_EAT_4)(o(139, s), p, o, m) # define BOOST_PP_FOR_139(s, p, o, m) BOOST_PP_IF(p(140, s), m, BOOST_PP_TUPLE_EAT_2)(140, s) BOOST_PP_IF(p(140, s), BOOST_PP_FOR_140, BOOST_PP_TUPLE_EAT_4)(o(140, s), p, o, m) # define BOOST_PP_FOR_140(s, p, o, m) BOOST_PP_IF(p(141, s), m, BOOST_PP_TUPLE_EAT_2)(141, s) BOOST_PP_IF(p(141, s), BOOST_PP_FOR_141, BOOST_PP_TUPLE_EAT_4)(o(141, s), p, o, m) # define BOOST_PP_FOR_141(s, p, o, m) BOOST_PP_IF(p(142, s), m, BOOST_PP_TUPLE_EAT_2)(142, s) BOOST_PP_IF(p(142, s), BOOST_PP_FOR_142, BOOST_PP_TUPLE_EAT_4)(o(142, s), p, o, m) # define BOOST_PP_FOR_142(s, p, o, m) BOOST_PP_IF(p(143, s), m, BOOST_PP_TUPLE_EAT_2)(143, s) BOOST_PP_IF(p(143, s), BOOST_PP_FOR_143, BOOST_PP_TUPLE_EAT_4)(o(143, s), p, o, m) # define BOOST_PP_FOR_143(s, p, o, m) BOOST_PP_IF(p(144, s), m, BOOST_PP_TUPLE_EAT_2)(144, s) BOOST_PP_IF(p(144, s), BOOST_PP_FOR_144, BOOST_PP_TUPLE_EAT_4)(o(144, s), p, o, m) # define BOOST_PP_FOR_144(s, p, o, m) BOOST_PP_IF(p(145, s), m, BOOST_PP_TUPLE_EAT_2)(145, s) BOOST_PP_IF(p(145, s), BOOST_PP_FOR_145, BOOST_PP_TUPLE_EAT_4)(o(145, s), p, o, m) # define BOOST_PP_FOR_145(s, p, o, m) BOOST_PP_IF(p(146, s), m, BOOST_PP_TUPLE_EAT_2)(146, s) BOOST_PP_IF(p(146, s), BOOST_PP_FOR_146, BOOST_PP_TUPLE_EAT_4)(o(146, s), p, o, m) # define BOOST_PP_FOR_146(s, p, o, m) BOOST_PP_IF(p(147, s), m, BOOST_PP_TUPLE_EAT_2)(147, s) BOOST_PP_IF(p(147, s), BOOST_PP_FOR_147, BOOST_PP_TUPLE_EAT_4)(o(147, s), p, o, m) # define BOOST_PP_FOR_147(s, p, o, m) BOOST_PP_IF(p(148, s), m, BOOST_PP_TUPLE_EAT_2)(148, s) BOOST_PP_IF(p(148, s), BOOST_PP_FOR_148, BOOST_PP_TUPLE_EAT_4)(o(148, s), p, o, m) # define BOOST_PP_FOR_148(s, p, o, m) BOOST_PP_IF(p(149, s), m, BOOST_PP_TUPLE_EAT_2)(149, s) BOOST_PP_IF(p(149, s), BOOST_PP_FOR_149, BOOST_PP_TUPLE_EAT_4)(o(149, s), p, o, m) # define BOOST_PP_FOR_149(s, p, o, m) BOOST_PP_IF(p(150, s), m, BOOST_PP_TUPLE_EAT_2)(150, s) BOOST_PP_IF(p(150, s), BOOST_PP_FOR_150, BOOST_PP_TUPLE_EAT_4)(o(150, s), p, o, m) # define BOOST_PP_FOR_150(s, p, o, m) BOOST_PP_IF(p(151, s), m, BOOST_PP_TUPLE_EAT_2)(151, s) BOOST_PP_IF(p(151, s), BOOST_PP_FOR_151, BOOST_PP_TUPLE_EAT_4)(o(151, s), p, o, m) # define BOOST_PP_FOR_151(s, p, o, m) BOOST_PP_IF(p(152, s), m, BOOST_PP_TUPLE_EAT_2)(152, s) BOOST_PP_IF(p(152, s), BOOST_PP_FOR_152, BOOST_PP_TUPLE_EAT_4)(o(152, s), p, o, m) # define BOOST_PP_FOR_152(s, p, o, m) BOOST_PP_IF(p(153, s), m, BOOST_PP_TUPLE_EAT_2)(153, s) BOOST_PP_IF(p(153, s), BOOST_PP_FOR_153, BOOST_PP_TUPLE_EAT_4)(o(153, s), p, o, m) # define BOOST_PP_FOR_153(s, p, o, m) BOOST_PP_IF(p(154, s), m, BOOST_PP_TUPLE_EAT_2)(154, s) BOOST_PP_IF(p(154, s), BOOST_PP_FOR_154, BOOST_PP_TUPLE_EAT_4)(o(154, s), p, o, m) # define BOOST_PP_FOR_154(s, p, o, m) BOOST_PP_IF(p(155, s), m, BOOST_PP_TUPLE_EAT_2)(155, s) BOOST_PP_IF(p(155, s), BOOST_PP_FOR_155, BOOST_PP_TUPLE_EAT_4)(o(155, s), p, o, m) # define BOOST_PP_FOR_155(s, p, o, m) BOOST_PP_IF(p(156, s), m, BOOST_PP_TUPLE_EAT_2)(156, s) BOOST_PP_IF(p(156, s), BOOST_PP_FOR_156, BOOST_PP_TUPLE_EAT_4)(o(156, s), p, o, m) # define BOOST_PP_FOR_156(s, p, o, m) BOOST_PP_IF(p(157, s), m, BOOST_PP_TUPLE_EAT_2)(157, s) BOOST_PP_IF(p(157, s), BOOST_PP_FOR_157, BOOST_PP_TUPLE_EAT_4)(o(157, s), p, o, m) # define BOOST_PP_FOR_157(s, p, o, m) BOOST_PP_IF(p(158, s), m, BOOST_PP_TUPLE_EAT_2)(158, s) BOOST_PP_IF(p(158, s), BOOST_PP_FOR_158, BOOST_PP_TUPLE_EAT_4)(o(158, s), p, o, m) # define BOOST_PP_FOR_158(s, p, o, m) BOOST_PP_IF(p(159, s), m, BOOST_PP_TUPLE_EAT_2)(159, s) BOOST_PP_IF(p(159, s), BOOST_PP_FOR_159, BOOST_PP_TUPLE_EAT_4)(o(159, s), p, o, m) # define BOOST_PP_FOR_159(s, p, o, m) BOOST_PP_IF(p(160, s), m, BOOST_PP_TUPLE_EAT_2)(160, s) BOOST_PP_IF(p(160, s), BOOST_PP_FOR_160, BOOST_PP_TUPLE_EAT_4)(o(160, s), p, o, m) # define BOOST_PP_FOR_160(s, p, o, m) BOOST_PP_IF(p(161, s), m, BOOST_PP_TUPLE_EAT_2)(161, s) BOOST_PP_IF(p(161, s), BOOST_PP_FOR_161, BOOST_PP_TUPLE_EAT_4)(o(161, s), p, o, m) # define BOOST_PP_FOR_161(s, p, o, m) BOOST_PP_IF(p(162, s), m, BOOST_PP_TUPLE_EAT_2)(162, s) BOOST_PP_IF(p(162, s), BOOST_PP_FOR_162, BOOST_PP_TUPLE_EAT_4)(o(162, s), p, o, m) # define BOOST_PP_FOR_162(s, p, o, m) BOOST_PP_IF(p(163, s), m, BOOST_PP_TUPLE_EAT_2)(163, s) BOOST_PP_IF(p(163, s), BOOST_PP_FOR_163, BOOST_PP_TUPLE_EAT_4)(o(163, s), p, o, m) # define BOOST_PP_FOR_163(s, p, o, m) BOOST_PP_IF(p(164, s), m, BOOST_PP_TUPLE_EAT_2)(164, s) BOOST_PP_IF(p(164, s), BOOST_PP_FOR_164, BOOST_PP_TUPLE_EAT_4)(o(164, s), p, o, m) # define BOOST_PP_FOR_164(s, p, o, m) BOOST_PP_IF(p(165, s), m, BOOST_PP_TUPLE_EAT_2)(165, s) BOOST_PP_IF(p(165, s), BOOST_PP_FOR_165, BOOST_PP_TUPLE_EAT_4)(o(165, s), p, o, m) # define BOOST_PP_FOR_165(s, p, o, m) BOOST_PP_IF(p(166, s), m, BOOST_PP_TUPLE_EAT_2)(166, s) BOOST_PP_IF(p(166, s), BOOST_PP_FOR_166, BOOST_PP_TUPLE_EAT_4)(o(166, s), p, o, m) # define BOOST_PP_FOR_166(s, p, o, m) BOOST_PP_IF(p(167, s), m, BOOST_PP_TUPLE_EAT_2)(167, s) BOOST_PP_IF(p(167, s), BOOST_PP_FOR_167, BOOST_PP_TUPLE_EAT_4)(o(167, s), p, o, m) # define BOOST_PP_FOR_167(s, p, o, m) BOOST_PP_IF(p(168, s), m, BOOST_PP_TUPLE_EAT_2)(168, s) BOOST_PP_IF(p(168, s), BOOST_PP_FOR_168, BOOST_PP_TUPLE_EAT_4)(o(168, s), p, o, m) # define BOOST_PP_FOR_168(s, p, o, m) BOOST_PP_IF(p(169, s), m, BOOST_PP_TUPLE_EAT_2)(169, s) BOOST_PP_IF(p(169, s), BOOST_PP_FOR_169, BOOST_PP_TUPLE_EAT_4)(o(169, s), p, o, m) # define BOOST_PP_FOR_169(s, p, o, m) BOOST_PP_IF(p(170, s), m, BOOST_PP_TUPLE_EAT_2)(170, s) BOOST_PP_IF(p(170, s), BOOST_PP_FOR_170, BOOST_PP_TUPLE_EAT_4)(o(170, s), p, o, m) # define BOOST_PP_FOR_170(s, p, o, m) BOOST_PP_IF(p(171, s), m, BOOST_PP_TUPLE_EAT_2)(171, s) BOOST_PP_IF(p(171, s), BOOST_PP_FOR_171, BOOST_PP_TUPLE_EAT_4)(o(171, s), p, o, m) # define BOOST_PP_FOR_171(s, p, o, m) BOOST_PP_IF(p(172, s), m, BOOST_PP_TUPLE_EAT_2)(172, s) BOOST_PP_IF(p(172, s), BOOST_PP_FOR_172, BOOST_PP_TUPLE_EAT_4)(o(172, s), p, o, m) # define BOOST_PP_FOR_172(s, p, o, m) BOOST_PP_IF(p(173, s), m, BOOST_PP_TUPLE_EAT_2)(173, s) BOOST_PP_IF(p(173, s), BOOST_PP_FOR_173, BOOST_PP_TUPLE_EAT_4)(o(173, s), p, o, m) # define BOOST_PP_FOR_173(s, p, o, m) BOOST_PP_IF(p(174, s), m, BOOST_PP_TUPLE_EAT_2)(174, s) BOOST_PP_IF(p(174, s), BOOST_PP_FOR_174, BOOST_PP_TUPLE_EAT_4)(o(174, s), p, o, m) # define BOOST_PP_FOR_174(s, p, o, m) BOOST_PP_IF(p(175, s), m, BOOST_PP_TUPLE_EAT_2)(175, s) BOOST_PP_IF(p(175, s), BOOST_PP_FOR_175, BOOST_PP_TUPLE_EAT_4)(o(175, s), p, o, m) # define BOOST_PP_FOR_175(s, p, o, m) BOOST_PP_IF(p(176, s), m, BOOST_PP_TUPLE_EAT_2)(176, s) BOOST_PP_IF(p(176, s), BOOST_PP_FOR_176, BOOST_PP_TUPLE_EAT_4)(o(176, s), p, o, m) # define BOOST_PP_FOR_176(s, p, o, m) BOOST_PP_IF(p(177, s), m, BOOST_PP_TUPLE_EAT_2)(177, s) BOOST_PP_IF(p(177, s), BOOST_PP_FOR_177, BOOST_PP_TUPLE_EAT_4)(o(177, s), p, o, m) # define BOOST_PP_FOR_177(s, p, o, m) BOOST_PP_IF(p(178, s), m, BOOST_PP_TUPLE_EAT_2)(178, s) BOOST_PP_IF(p(178, s), BOOST_PP_FOR_178, BOOST_PP_TUPLE_EAT_4)(o(178, s), p, o, m) # define BOOST_PP_FOR_178(s, p, o, m) BOOST_PP_IF(p(179, s), m, BOOST_PP_TUPLE_EAT_2)(179, s) BOOST_PP_IF(p(179, s), BOOST_PP_FOR_179, BOOST_PP_TUPLE_EAT_4)(o(179, s), p, o, m) # define BOOST_PP_FOR_179(s, p, o, m) BOOST_PP_IF(p(180, s), m, BOOST_PP_TUPLE_EAT_2)(180, s) BOOST_PP_IF(p(180, s), BOOST_PP_FOR_180, BOOST_PP_TUPLE_EAT_4)(o(180, s), p, o, m) # define BOOST_PP_FOR_180(s, p, o, m) BOOST_PP_IF(p(181, s), m, BOOST_PP_TUPLE_EAT_2)(181, s) BOOST_PP_IF(p(181, s), BOOST_PP_FOR_181, BOOST_PP_TUPLE_EAT_4)(o(181, s), p, o, m) # define BOOST_PP_FOR_181(s, p, o, m) BOOST_PP_IF(p(182, s), m, BOOST_PP_TUPLE_EAT_2)(182, s) BOOST_PP_IF(p(182, s), BOOST_PP_FOR_182, BOOST_PP_TUPLE_EAT_4)(o(182, s), p, o, m) # define BOOST_PP_FOR_182(s, p, o, m) BOOST_PP_IF(p(183, s), m, BOOST_PP_TUPLE_EAT_2)(183, s) BOOST_PP_IF(p(183, s), BOOST_PP_FOR_183, BOOST_PP_TUPLE_EAT_4)(o(183, s), p, o, m) # define BOOST_PP_FOR_183(s, p, o, m) BOOST_PP_IF(p(184, s), m, BOOST_PP_TUPLE_EAT_2)(184, s) BOOST_PP_IF(p(184, s), BOOST_PP_FOR_184, BOOST_PP_TUPLE_EAT_4)(o(184, s), p, o, m) # define BOOST_PP_FOR_184(s, p, o, m) BOOST_PP_IF(p(185, s), m, BOOST_PP_TUPLE_EAT_2)(185, s) BOOST_PP_IF(p(185, s), BOOST_PP_FOR_185, BOOST_PP_TUPLE_EAT_4)(o(185, s), p, o, m) # define BOOST_PP_FOR_185(s, p, o, m) BOOST_PP_IF(p(186, s), m, BOOST_PP_TUPLE_EAT_2)(186, s) BOOST_PP_IF(p(186, s), BOOST_PP_FOR_186, BOOST_PP_TUPLE_EAT_4)(o(186, s), p, o, m) # define BOOST_PP_FOR_186(s, p, o, m) BOOST_PP_IF(p(187, s), m, BOOST_PP_TUPLE_EAT_2)(187, s) BOOST_PP_IF(p(187, s), BOOST_PP_FOR_187, BOOST_PP_TUPLE_EAT_4)(o(187, s), p, o, m) # define BOOST_PP_FOR_187(s, p, o, m) BOOST_PP_IF(p(188, s), m, BOOST_PP_TUPLE_EAT_2)(188, s) BOOST_PP_IF(p(188, s), BOOST_PP_FOR_188, BOOST_PP_TUPLE_EAT_4)(o(188, s), p, o, m) # define BOOST_PP_FOR_188(s, p, o, m) BOOST_PP_IF(p(189, s), m, BOOST_PP_TUPLE_EAT_2)(189, s) BOOST_PP_IF(p(189, s), BOOST_PP_FOR_189, BOOST_PP_TUPLE_EAT_4)(o(189, s), p, o, m) # define BOOST_PP_FOR_189(s, p, o, m) BOOST_PP_IF(p(190, s), m, BOOST_PP_TUPLE_EAT_2)(190, s) BOOST_PP_IF(p(190, s), BOOST_PP_FOR_190, BOOST_PP_TUPLE_EAT_4)(o(190, s), p, o, m) # define BOOST_PP_FOR_190(s, p, o, m) BOOST_PP_IF(p(191, s), m, BOOST_PP_TUPLE_EAT_2)(191, s) BOOST_PP_IF(p(191, s), BOOST_PP_FOR_191, BOOST_PP_TUPLE_EAT_4)(o(191, s), p, o, m) # define BOOST_PP_FOR_191(s, p, o, m) BOOST_PP_IF(p(192, s), m, BOOST_PP_TUPLE_EAT_2)(192, s) BOOST_PP_IF(p(192, s), BOOST_PP_FOR_192, BOOST_PP_TUPLE_EAT_4)(o(192, s), p, o, m) # define BOOST_PP_FOR_192(s, p, o, m) BOOST_PP_IF(p(193, s), m, BOOST_PP_TUPLE_EAT_2)(193, s) BOOST_PP_IF(p(193, s), BOOST_PP_FOR_193, BOOST_PP_TUPLE_EAT_4)(o(193, s), p, o, m) # define BOOST_PP_FOR_193(s, p, o, m) BOOST_PP_IF(p(194, s), m, BOOST_PP_TUPLE_EAT_2)(194, s) BOOST_PP_IF(p(194, s), BOOST_PP_FOR_194, BOOST_PP_TUPLE_EAT_4)(o(194, s), p, o, m) # define BOOST_PP_FOR_194(s, p, o, m) BOOST_PP_IF(p(195, s), m, BOOST_PP_TUPLE_EAT_2)(195, s) BOOST_PP_IF(p(195, s), BOOST_PP_FOR_195, BOOST_PP_TUPLE_EAT_4)(o(195, s), p, o, m) # define BOOST_PP_FOR_195(s, p, o, m) BOOST_PP_IF(p(196, s), m, BOOST_PP_TUPLE_EAT_2)(196, s) BOOST_PP_IF(p(196, s), BOOST_PP_FOR_196, BOOST_PP_TUPLE_EAT_4)(o(196, s), p, o, m) # define BOOST_PP_FOR_196(s, p, o, m) BOOST_PP_IF(p(197, s), m, BOOST_PP_TUPLE_EAT_2)(197, s) BOOST_PP_IF(p(197, s), BOOST_PP_FOR_197, BOOST_PP_TUPLE_EAT_4)(o(197, s), p, o, m) # define BOOST_PP_FOR_197(s, p, o, m) BOOST_PP_IF(p(198, s), m, BOOST_PP_TUPLE_EAT_2)(198, s) BOOST_PP_IF(p(198, s), BOOST_PP_FOR_198, BOOST_PP_TUPLE_EAT_4)(o(198, s), p, o, m) # define BOOST_PP_FOR_198(s, p, o, m) BOOST_PP_IF(p(199, s), m, BOOST_PP_TUPLE_EAT_2)(199, s) BOOST_PP_IF(p(199, s), BOOST_PP_FOR_199, BOOST_PP_TUPLE_EAT_4)(o(199, s), p, o, m) # define BOOST_PP_FOR_199(s, p, o, m) BOOST_PP_IF(p(200, s), m, BOOST_PP_TUPLE_EAT_2)(200, s) BOOST_PP_IF(p(200, s), BOOST_PP_FOR_200, BOOST_PP_TUPLE_EAT_4)(o(200, s), p, o, m) # define BOOST_PP_FOR_200(s, p, o, m) BOOST_PP_IF(p(201, s), m, BOOST_PP_TUPLE_EAT_2)(201, s) BOOST_PP_IF(p(201, s), BOOST_PP_FOR_201, BOOST_PP_TUPLE_EAT_4)(o(201, s), p, o, m) # define BOOST_PP_FOR_201(s, p, o, m) BOOST_PP_IF(p(202, s), m, BOOST_PP_TUPLE_EAT_2)(202, s) BOOST_PP_IF(p(202, s), BOOST_PP_FOR_202, BOOST_PP_TUPLE_EAT_4)(o(202, s), p, o, m) # define BOOST_PP_FOR_202(s, p, o, m) BOOST_PP_IF(p(203, s), m, BOOST_PP_TUPLE_EAT_2)(203, s) BOOST_PP_IF(p(203, s), BOOST_PP_FOR_203, BOOST_PP_TUPLE_EAT_4)(o(203, s), p, o, m) # define BOOST_PP_FOR_203(s, p, o, m) BOOST_PP_IF(p(204, s), m, BOOST_PP_TUPLE_EAT_2)(204, s) BOOST_PP_IF(p(204, s), BOOST_PP_FOR_204, BOOST_PP_TUPLE_EAT_4)(o(204, s), p, o, m) # define BOOST_PP_FOR_204(s, p, o, m) BOOST_PP_IF(p(205, s), m, BOOST_PP_TUPLE_EAT_2)(205, s) BOOST_PP_IF(p(205, s), BOOST_PP_FOR_205, BOOST_PP_TUPLE_EAT_4)(o(205, s), p, o, m) # define BOOST_PP_FOR_205(s, p, o, m) BOOST_PP_IF(p(206, s), m, BOOST_PP_TUPLE_EAT_2)(206, s) BOOST_PP_IF(p(206, s), BOOST_PP_FOR_206, BOOST_PP_TUPLE_EAT_4)(o(206, s), p, o, m) # define BOOST_PP_FOR_206(s, p, o, m) BOOST_PP_IF(p(207, s), m, BOOST_PP_TUPLE_EAT_2)(207, s) BOOST_PP_IF(p(207, s), BOOST_PP_FOR_207, BOOST_PP_TUPLE_EAT_4)(o(207, s), p, o, m) # define BOOST_PP_FOR_207(s, p, o, m) BOOST_PP_IF(p(208, s), m, BOOST_PP_TUPLE_EAT_2)(208, s) BOOST_PP_IF(p(208, s), BOOST_PP_FOR_208, BOOST_PP_TUPLE_EAT_4)(o(208, s), p, o, m) # define BOOST_PP_FOR_208(s, p, o, m) BOOST_PP_IF(p(209, s), m, BOOST_PP_TUPLE_EAT_2)(209, s) BOOST_PP_IF(p(209, s), BOOST_PP_FOR_209, BOOST_PP_TUPLE_EAT_4)(o(209, s), p, o, m) # define BOOST_PP_FOR_209(s, p, o, m) BOOST_PP_IF(p(210, s), m, BOOST_PP_TUPLE_EAT_2)(210, s) BOOST_PP_IF(p(210, s), BOOST_PP_FOR_210, BOOST_PP_TUPLE_EAT_4)(o(210, s), p, o, m) # define BOOST_PP_FOR_210(s, p, o, m) BOOST_PP_IF(p(211, s), m, BOOST_PP_TUPLE_EAT_2)(211, s) BOOST_PP_IF(p(211, s), BOOST_PP_FOR_211, BOOST_PP_TUPLE_EAT_4)(o(211, s), p, o, m) # define BOOST_PP_FOR_211(s, p, o, m) BOOST_PP_IF(p(212, s), m, BOOST_PP_TUPLE_EAT_2)(212, s) BOOST_PP_IF(p(212, s), BOOST_PP_FOR_212, BOOST_PP_TUPLE_EAT_4)(o(212, s), p, o, m) # define BOOST_PP_FOR_212(s, p, o, m) BOOST_PP_IF(p(213, s), m, BOOST_PP_TUPLE_EAT_2)(213, s) BOOST_PP_IF(p(213, s), BOOST_PP_FOR_213, BOOST_PP_TUPLE_EAT_4)(o(213, s), p, o, m) # define BOOST_PP_FOR_213(s, p, o, m) BOOST_PP_IF(p(214, s), m, BOOST_PP_TUPLE_EAT_2)(214, s) BOOST_PP_IF(p(214, s), BOOST_PP_FOR_214, BOOST_PP_TUPLE_EAT_4)(o(214, s), p, o, m) # define BOOST_PP_FOR_214(s, p, o, m) BOOST_PP_IF(p(215, s), m, BOOST_PP_TUPLE_EAT_2)(215, s) BOOST_PP_IF(p(215, s), BOOST_PP_FOR_215, BOOST_PP_TUPLE_EAT_4)(o(215, s), p, o, m) # define BOOST_PP_FOR_215(s, p, o, m) BOOST_PP_IF(p(216, s), m, BOOST_PP_TUPLE_EAT_2)(216, s) BOOST_PP_IF(p(216, s), BOOST_PP_FOR_216, BOOST_PP_TUPLE_EAT_4)(o(216, s), p, o, m) # define BOOST_PP_FOR_216(s, p, o, m) BOOST_PP_IF(p(217, s), m, BOOST_PP_TUPLE_EAT_2)(217, s) BOOST_PP_IF(p(217, s), BOOST_PP_FOR_217, BOOST_PP_TUPLE_EAT_4)(o(217, s), p, o, m) # define BOOST_PP_FOR_217(s, p, o, m) BOOST_PP_IF(p(218, s), m, BOOST_PP_TUPLE_EAT_2)(218, s) BOOST_PP_IF(p(218, s), BOOST_PP_FOR_218, BOOST_PP_TUPLE_EAT_4)(o(218, s), p, o, m) # define BOOST_PP_FOR_218(s, p, o, m) BOOST_PP_IF(p(219, s), m, BOOST_PP_TUPLE_EAT_2)(219, s) BOOST_PP_IF(p(219, s), BOOST_PP_FOR_219, BOOST_PP_TUPLE_EAT_4)(o(219, s), p, o, m) # define BOOST_PP_FOR_219(s, p, o, m) BOOST_PP_IF(p(220, s), m, BOOST_PP_TUPLE_EAT_2)(220, s) BOOST_PP_IF(p(220, s), BOOST_PP_FOR_220, BOOST_PP_TUPLE_EAT_4)(o(220, s), p, o, m) # define BOOST_PP_FOR_220(s, p, o, m) BOOST_PP_IF(p(221, s), m, BOOST_PP_TUPLE_EAT_2)(221, s) BOOST_PP_IF(p(221, s), BOOST_PP_FOR_221, BOOST_PP_TUPLE_EAT_4)(o(221, s), p, o, m) # define BOOST_PP_FOR_221(s, p, o, m) BOOST_PP_IF(p(222, s), m, BOOST_PP_TUPLE_EAT_2)(222, s) BOOST_PP_IF(p(222, s), BOOST_PP_FOR_222, BOOST_PP_TUPLE_EAT_4)(o(222, s), p, o, m) # define BOOST_PP_FOR_222(s, p, o, m) BOOST_PP_IF(p(223, s), m, BOOST_PP_TUPLE_EAT_2)(223, s) BOOST_PP_IF(p(223, s), BOOST_PP_FOR_223, BOOST_PP_TUPLE_EAT_4)(o(223, s), p, o, m) # define BOOST_PP_FOR_223(s, p, o, m) BOOST_PP_IF(p(224, s), m, BOOST_PP_TUPLE_EAT_2)(224, s) BOOST_PP_IF(p(224, s), BOOST_PP_FOR_224, BOOST_PP_TUPLE_EAT_4)(o(224, s), p, o, m) # define BOOST_PP_FOR_224(s, p, o, m) BOOST_PP_IF(p(225, s), m, BOOST_PP_TUPLE_EAT_2)(225, s) BOOST_PP_IF(p(225, s), BOOST_PP_FOR_225, BOOST_PP_TUPLE_EAT_4)(o(225, s), p, o, m) # define BOOST_PP_FOR_225(s, p, o, m) BOOST_PP_IF(p(226, s), m, BOOST_PP_TUPLE_EAT_2)(226, s) BOOST_PP_IF(p(226, s), BOOST_PP_FOR_226, BOOST_PP_TUPLE_EAT_4)(o(226, s), p, o, m) # define BOOST_PP_FOR_226(s, p, o, m) BOOST_PP_IF(p(227, s), m, BOOST_PP_TUPLE_EAT_2)(227, s) BOOST_PP_IF(p(227, s), BOOST_PP_FOR_227, BOOST_PP_TUPLE_EAT_4)(o(227, s), p, o, m) # define BOOST_PP_FOR_227(s, p, o, m) BOOST_PP_IF(p(228, s), m, BOOST_PP_TUPLE_EAT_2)(228, s) BOOST_PP_IF(p(228, s), BOOST_PP_FOR_228, BOOST_PP_TUPLE_EAT_4)(o(228, s), p, o, m) # define BOOST_PP_FOR_228(s, p, o, m) BOOST_PP_IF(p(229, s), m, BOOST_PP_TUPLE_EAT_2)(229, s) BOOST_PP_IF(p(229, s), BOOST_PP_FOR_229, BOOST_PP_TUPLE_EAT_4)(o(229, s), p, o, m) # define BOOST_PP_FOR_229(s, p, o, m) BOOST_PP_IF(p(230, s), m, BOOST_PP_TUPLE_EAT_2)(230, s) BOOST_PP_IF(p(230, s), BOOST_PP_FOR_230, BOOST_PP_TUPLE_EAT_4)(o(230, s), p, o, m) # define BOOST_PP_FOR_230(s, p, o, m) BOOST_PP_IF(p(231, s), m, BOOST_PP_TUPLE_EAT_2)(231, s) BOOST_PP_IF(p(231, s), BOOST_PP_FOR_231, BOOST_PP_TUPLE_EAT_4)(o(231, s), p, o, m) # define BOOST_PP_FOR_231(s, p, o, m) BOOST_PP_IF(p(232, s), m, BOOST_PP_TUPLE_EAT_2)(232, s) BOOST_PP_IF(p(232, s), BOOST_PP_FOR_232, BOOST_PP_TUPLE_EAT_4)(o(232, s), p, o, m) # define BOOST_PP_FOR_232(s, p, o, m) BOOST_PP_IF(p(233, s), m, BOOST_PP_TUPLE_EAT_2)(233, s) BOOST_PP_IF(p(233, s), BOOST_PP_FOR_233, BOOST_PP_TUPLE_EAT_4)(o(233, s), p, o, m) # define BOOST_PP_FOR_233(s, p, o, m) BOOST_PP_IF(p(234, s), m, BOOST_PP_TUPLE_EAT_2)(234, s) BOOST_PP_IF(p(234, s), BOOST_PP_FOR_234, BOOST_PP_TUPLE_EAT_4)(o(234, s), p, o, m) # define BOOST_PP_FOR_234(s, p, o, m) BOOST_PP_IF(p(235, s), m, BOOST_PP_TUPLE_EAT_2)(235, s) BOOST_PP_IF(p(235, s), BOOST_PP_FOR_235, BOOST_PP_TUPLE_EAT_4)(o(235, s), p, o, m) # define BOOST_PP_FOR_235(s, p, o, m) BOOST_PP_IF(p(236, s), m, BOOST_PP_TUPLE_EAT_2)(236, s) BOOST_PP_IF(p(236, s), BOOST_PP_FOR_236, BOOST_PP_TUPLE_EAT_4)(o(236, s), p, o, m) # define BOOST_PP_FOR_236(s, p, o, m) BOOST_PP_IF(p(237, s), m, BOOST_PP_TUPLE_EAT_2)(237, s) BOOST_PP_IF(p(237, s), BOOST_PP_FOR_237, BOOST_PP_TUPLE_EAT_4)(o(237, s), p, o, m) # define BOOST_PP_FOR_237(s, p, o, m) BOOST_PP_IF(p(238, s), m, BOOST_PP_TUPLE_EAT_2)(238, s) BOOST_PP_IF(p(238, s), BOOST_PP_FOR_238, BOOST_PP_TUPLE_EAT_4)(o(238, s), p, o, m) # define BOOST_PP_FOR_238(s, p, o, m) BOOST_PP_IF(p(239, s), m, BOOST_PP_TUPLE_EAT_2)(239, s) BOOST_PP_IF(p(239, s), BOOST_PP_FOR_239, BOOST_PP_TUPLE_EAT_4)(o(239, s), p, o, m) # define BOOST_PP_FOR_239(s, p, o, m) BOOST_PP_IF(p(240, s), m, BOOST_PP_TUPLE_EAT_2)(240, s) BOOST_PP_IF(p(240, s), BOOST_PP_FOR_240, BOOST_PP_TUPLE_EAT_4)(o(240, s), p, o, m) # define BOOST_PP_FOR_240(s, p, o, m) BOOST_PP_IF(p(241, s), m, BOOST_PP_TUPLE_EAT_2)(241, s) BOOST_PP_IF(p(241, s), BOOST_PP_FOR_241, BOOST_PP_TUPLE_EAT_4)(o(241, s), p, o, m) # define BOOST_PP_FOR_241(s, p, o, m) BOOST_PP_IF(p(242, s), m, BOOST_PP_TUPLE_EAT_2)(242, s) BOOST_PP_IF(p(242, s), BOOST_PP_FOR_242, BOOST_PP_TUPLE_EAT_4)(o(242, s), p, o, m) # define BOOST_PP_FOR_242(s, p, o, m) BOOST_PP_IF(p(243, s), m, BOOST_PP_TUPLE_EAT_2)(243, s) BOOST_PP_IF(p(243, s), BOOST_PP_FOR_243, BOOST_PP_TUPLE_EAT_4)(o(243, s), p, o, m) # define BOOST_PP_FOR_243(s, p, o, m) BOOST_PP_IF(p(244, s), m, BOOST_PP_TUPLE_EAT_2)(244, s) BOOST_PP_IF(p(244, s), BOOST_PP_FOR_244, BOOST_PP_TUPLE_EAT_4)(o(244, s), p, o, m) # define BOOST_PP_FOR_244(s, p, o, m) BOOST_PP_IF(p(245, s), m, BOOST_PP_TUPLE_EAT_2)(245, s) BOOST_PP_IF(p(245, s), BOOST_PP_FOR_245, BOOST_PP_TUPLE_EAT_4)(o(245, s), p, o, m) # define BOOST_PP_FOR_245(s, p, o, m) BOOST_PP_IF(p(246, s), m, BOOST_PP_TUPLE_EAT_2)(246, s) BOOST_PP_IF(p(246, s), BOOST_PP_FOR_246, BOOST_PP_TUPLE_EAT_4)(o(246, s), p, o, m) # define BOOST_PP_FOR_246(s, p, o, m) BOOST_PP_IF(p(247, s), m, BOOST_PP_TUPLE_EAT_2)(247, s) BOOST_PP_IF(p(247, s), BOOST_PP_FOR_247, BOOST_PP_TUPLE_EAT_4)(o(247, s), p, o, m) # define BOOST_PP_FOR_247(s, p, o, m) BOOST_PP_IF(p(248, s), m, BOOST_PP_TUPLE_EAT_2)(248, s) BOOST_PP_IF(p(248, s), BOOST_PP_FOR_248, BOOST_PP_TUPLE_EAT_4)(o(248, s), p, o, m) # define BOOST_PP_FOR_248(s, p, o, m) BOOST_PP_IF(p(249, s), m, BOOST_PP_TUPLE_EAT_2)(249, s) BOOST_PP_IF(p(249, s), BOOST_PP_FOR_249, BOOST_PP_TUPLE_EAT_4)(o(249, s), p, o, m) # define BOOST_PP_FOR_249(s, p, o, m) BOOST_PP_IF(p(250, s), m, BOOST_PP_TUPLE_EAT_2)(250, s) BOOST_PP_IF(p(250, s), BOOST_PP_FOR_250, BOOST_PP_TUPLE_EAT_4)(o(250, s), p, o, m) # define BOOST_PP_FOR_250(s, p, o, m) BOOST_PP_IF(p(251, s), m, BOOST_PP_TUPLE_EAT_2)(251, s) BOOST_PP_IF(p(251, s), BOOST_PP_FOR_251, BOOST_PP_TUPLE_EAT_4)(o(251, s), p, o, m) # define BOOST_PP_FOR_251(s, p, o, m) BOOST_PP_IF(p(252, s), m, BOOST_PP_TUPLE_EAT_2)(252, s) BOOST_PP_IF(p(252, s), BOOST_PP_FOR_252, BOOST_PP_TUPLE_EAT_4)(o(252, s), p, o, m) # define BOOST_PP_FOR_252(s, p, o, m) BOOST_PP_IF(p(253, s), m, BOOST_PP_TUPLE_EAT_2)(253, s) BOOST_PP_IF(p(253, s), BOOST_PP_FOR_253, BOOST_PP_TUPLE_EAT_4)(o(253, s), p, o, m) # define BOOST_PP_FOR_253(s, p, o, m) BOOST_PP_IF(p(254, s), m, BOOST_PP_TUPLE_EAT_2)(254, s) BOOST_PP_IF(p(254, s), BOOST_PP_FOR_254, BOOST_PP_TUPLE_EAT_4)(o(254, s), p, o, m) # define BOOST_PP_FOR_254(s, p, o, m) BOOST_PP_IF(p(255, s), m, BOOST_PP_TUPLE_EAT_2)(255, s) BOOST_PP_IF(p(255, s), BOOST_PP_FOR_255, BOOST_PP_TUPLE_EAT_4)(o(255, s), p, o, m) # define BOOST_PP_FOR_255(s, p, o, m) BOOST_PP_IF(p(256, s), m, BOOST_PP_TUPLE_EAT_2)(256, s) BOOST_PP_IF(p(256, s), BOOST_PP_FOR_256, BOOST_PP_TUPLE_EAT_4)(o(256, s), p, o, m) # define BOOST_PP_FOR_256(s, p, o, m) BOOST_PP_IF(p(257, s), m, BOOST_PP_TUPLE_EAT_2)(257, s) BOOST_PP_IF(p(257, s), BOOST_PP_FOR_257, BOOST_PP_TUPLE_EAT_4)(o(257, s), p, o, m) # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/0000755000175000017500000000000012146213772031335 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/reverse.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/re0000644000175000017500000001004711344301502031654 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_REVERSE_HPP # define BOOST_PREPROCESSOR_TUPLE_REVERSE_HPP # # include # # /* BOOST_PP_TUPLE_REVERSE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_REVERSE(size, tuple) BOOST_PP_TUPLE_REVERSE_I(size, tuple) # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_TUPLE_REVERSE_I(s, t) BOOST_PP_TUPLE_REVERSE_ ## s t # else # define BOOST_PP_TUPLE_REVERSE_I(s, t) BOOST_PP_TUPLE_REVERSE_II(BOOST_PP_TUPLE_REVERSE_ ## s t) # define BOOST_PP_TUPLE_REVERSE_II(res) res # endif # else # define BOOST_PP_TUPLE_REVERSE(size, tuple) BOOST_PP_TUPLE_REVERSE_OO((size, tuple)) # define BOOST_PP_TUPLE_REVERSE_OO(par) BOOST_PP_TUPLE_REVERSE_I ## par # define BOOST_PP_TUPLE_REVERSE_I(s, t) BOOST_PP_TUPLE_REVERSE_ ## s ## t # endif # # define BOOST_PP_TUPLE_REVERSE_0() () # define BOOST_PP_TUPLE_REVERSE_1(a) (a) # define BOOST_PP_TUPLE_REVERSE_2(a, b) (b, a) # define BOOST_PP_TUPLE_REVERSE_3(a, b, c) (c, b, a) # define BOOST_PP_TUPLE_REVERSE_4(a, b, c, d) (d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_5(a, b, c, d, e) (e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_6(a, b, c, d, e, f) (f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_7(a, b, c, d, e, f, g) (g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_8(a, b, c, d, e, f, g, h) (h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_9(a, b, c, d, e, f, g, h, i) (i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_10(a, b, c, d, e, f, g, h, i, j) (j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_11(a, b, c, d, e, f, g, h, i, j, k) (k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_12(a, b, c, d, e, f, g, h, i, j, k, l) (l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_13(a, b, c, d, e, f, g, h, i, j, k, l, m) (m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) (n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) (o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) (p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) (q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) (r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) (s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) (t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) (u, t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) (v, u, t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) (w, v, u, t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) (x, w, v, u, t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # define BOOST_PP_TUPLE_REVERSE_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) (y, x, w, v, u, t, s, r, q, p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a) # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/eat.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/ea0000644000175000017500000000512011344301502031627 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_EAT_HPP # define BOOST_PREPROCESSOR_TUPLE_EAT_HPP # # include # # /* BOOST_PP_TUPLE_EAT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_I(size) # else # define BOOST_PP_TUPLE_EAT(size) BOOST_PP_TUPLE_EAT_OO((size)) # define BOOST_PP_TUPLE_EAT_OO(par) BOOST_PP_TUPLE_EAT_I ## par # endif # # define BOOST_PP_TUPLE_EAT_I(size) BOOST_PP_TUPLE_EAT_ ## size # # define BOOST_PP_TUPLE_EAT_0() # define BOOST_PP_TUPLE_EAT_1(a) # define BOOST_PP_TUPLE_EAT_2(a, b) # define BOOST_PP_TUPLE_EAT_3(a, b, c) # define BOOST_PP_TUPLE_EAT_4(a, b, c, d) # define BOOST_PP_TUPLE_EAT_5(a, b, c, d, e) # define BOOST_PP_TUPLE_EAT_6(a, b, c, d, e, f) # define BOOST_PP_TUPLE_EAT_7(a, b, c, d, e, f, g) # define BOOST_PP_TUPLE_EAT_8(a, b, c, d, e, f, g, h) # define BOOST_PP_TUPLE_EAT_9(a, b, c, d, e, f, g, h, i) # define BOOST_PP_TUPLE_EAT_10(a, b, c, d, e, f, g, h, i, j) # define BOOST_PP_TUPLE_EAT_11(a, b, c, d, e, f, g, h, i, j, k) # define BOOST_PP_TUPLE_EAT_12(a, b, c, d, e, f, g, h, i, j, k, l) # define BOOST_PP_TUPLE_EAT_13(a, b, c, d, e, f, g, h, i, j, k, l, m) # define BOOST_PP_TUPLE_EAT_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) # define BOOST_PP_TUPLE_EAT_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # define BOOST_PP_TUPLE_EAT_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) # define BOOST_PP_TUPLE_EAT_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) # define BOOST_PP_TUPLE_EAT_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) # define BOOST_PP_TUPLE_EAT_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) # define BOOST_PP_TUPLE_EAT_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) # define BOOST_PP_TUPLE_EAT_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) # define BOOST_PP_TUPLE_EAT_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) # define BOOST_PP_TUPLE_EAT_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) # define BOOST_PP_TUPLE_EAT_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) # define BOOST_PP_TUPLE_EAT_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/rem.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/re0000644000175000017500000001100511344301502031647 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_REM_HPP # define BOOST_PREPROCESSOR_TUPLE_REM_HPP # # include # # /* BOOST_PP_TUPLE_REM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_I(size) # else # define BOOST_PP_TUPLE_REM(size) BOOST_PP_TUPLE_REM_OO((size)) # define BOOST_PP_TUPLE_REM_OO(par) BOOST_PP_TUPLE_REM_I ## par # endif # # define BOOST_PP_TUPLE_REM_I(size) BOOST_PP_TUPLE_REM_ ## size # # define BOOST_PP_TUPLE_REM_0() # define BOOST_PP_TUPLE_REM_1(a) a # define BOOST_PP_TUPLE_REM_2(a, b) a, b # define BOOST_PP_TUPLE_REM_3(a, b, c) a, b, c # define BOOST_PP_TUPLE_REM_4(a, b, c, d) a, b, c, d # define BOOST_PP_TUPLE_REM_5(a, b, c, d, e) a, b, c, d, e # define BOOST_PP_TUPLE_REM_6(a, b, c, d, e, f) a, b, c, d, e, f # define BOOST_PP_TUPLE_REM_7(a, b, c, d, e, f, g) a, b, c, d, e, f, g # define BOOST_PP_TUPLE_REM_8(a, b, c, d, e, f, g, h) a, b, c, d, e, f, g, h # define BOOST_PP_TUPLE_REM_9(a, b, c, d, e, f, g, h, i) a, b, c, d, e, f, g, h, i # define BOOST_PP_TUPLE_REM_10(a, b, c, d, e, f, g, h, i, j) a, b, c, d, e, f, g, h, i, j # define BOOST_PP_TUPLE_REM_11(a, b, c, d, e, f, g, h, i, j, k) a, b, c, d, e, f, g, h, i, j, k # define BOOST_PP_TUPLE_REM_12(a, b, c, d, e, f, g, h, i, j, k, l) a, b, c, d, e, f, g, h, i, j, k, l # define BOOST_PP_TUPLE_REM_13(a, b, c, d, e, f, g, h, i, j, k, l, m) a, b, c, d, e, f, g, h, i, j, k, l, m # define BOOST_PP_TUPLE_REM_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) a, b, c, d, e, f, g, h, i, j, k, l, m, n # define BOOST_PP_TUPLE_REM_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o # define BOOST_PP_TUPLE_REM_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p # define BOOST_PP_TUPLE_REM_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q # define BOOST_PP_TUPLE_REM_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r # define BOOST_PP_TUPLE_REM_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s # define BOOST_PP_TUPLE_REM_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t # define BOOST_PP_TUPLE_REM_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u # define BOOST_PP_TUPLE_REM_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v # define BOOST_PP_TUPLE_REM_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w # define BOOST_PP_TUPLE_REM_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x # define BOOST_PP_TUPLE_REM_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y # # /* BOOST_PP_TUPLE_REM_CTOR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_TUPLE_REM_CTOR(size, tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple) # else # define BOOST_PP_TUPLE_REM_CTOR(size, tuple) BOOST_PP_TUPLE_REM_CTOR_D(size, tuple) # define BOOST_PP_TUPLE_REM_CTOR_D(size, tuple) BOOST_PP_TUPLE_REM_CTOR_I(BOOST_PP_TUPLE_REM(size), tuple) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_REM_CTOR_I(ext, tuple) ext tuple # else # define BOOST_PP_TUPLE_REM_CTOR_I(ext, tuple) BOOST_PP_TUPLE_REM_CTOR_OO((ext, tuple)) # define BOOST_PP_TUPLE_REM_CTOR_OO(par) BOOST_PP_TUPLE_REM_CTOR_II ## par # define BOOST_PP_TUPLE_REM_CTOR_II(ext, tuple) ext ## tuple # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/to_seq.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/to0000644000175000017500000001036011344301502031666 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_TO_SEQ_HPP # define BOOST_PREPROCESSOR_TUPLE_TO_SEQ_HPP # # include # # /* BOOST_PP_TUPLE_TO_SEQ */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_TO_SEQ(size, tuple) BOOST_PP_TUPLE_TO_SEQ_I(size, tuple) # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_TUPLE_TO_SEQ_I(s, t) BOOST_PP_TUPLE_TO_SEQ_ ## s t # else # define BOOST_PP_TUPLE_TO_SEQ_I(s, t) BOOST_PP_TUPLE_TO_SEQ_II(BOOST_PP_TUPLE_TO_SEQ_ ## s t) # define BOOST_PP_TUPLE_TO_SEQ_II(res) res # endif # else # define BOOST_PP_TUPLE_TO_SEQ(size, tuple) BOOST_PP_TUPLE_TO_SEQ_OO((size, tuple)) # define BOOST_PP_TUPLE_TO_SEQ_OO(par) BOOST_PP_TUPLE_TO_SEQ_I ## par # define BOOST_PP_TUPLE_TO_SEQ_I(s, t) BOOST_PP_TUPLE_TO_SEQ_ ## s ## t # endif # # define BOOST_PP_TUPLE_TO_SEQ_0() # define BOOST_PP_TUPLE_TO_SEQ_1(a) (a) # define BOOST_PP_TUPLE_TO_SEQ_2(a, b) (a)(b) # define BOOST_PP_TUPLE_TO_SEQ_3(a, b, c) (a)(b)(c) # define BOOST_PP_TUPLE_TO_SEQ_4(a, b, c, d) (a)(b)(c)(d) # define BOOST_PP_TUPLE_TO_SEQ_5(a, b, c, d, e) (a)(b)(c)(d)(e) # define BOOST_PP_TUPLE_TO_SEQ_6(a, b, c, d, e, f) (a)(b)(c)(d)(e)(f) # define BOOST_PP_TUPLE_TO_SEQ_7(a, b, c, d, e, f, g) (a)(b)(c)(d)(e)(f)(g) # define BOOST_PP_TUPLE_TO_SEQ_8(a, b, c, d, e, f, g, h) (a)(b)(c)(d)(e)(f)(g)(h) # define BOOST_PP_TUPLE_TO_SEQ_9(a, b, c, d, e, f, g, h, i) (a)(b)(c)(d)(e)(f)(g)(h)(i) # define BOOST_PP_TUPLE_TO_SEQ_10(a, b, c, d, e, f, g, h, i, j) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j) # define BOOST_PP_TUPLE_TO_SEQ_11(a, b, c, d, e, f, g, h, i, j, k) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k) # define BOOST_PP_TUPLE_TO_SEQ_12(a, b, c, d, e, f, g, h, i, j, k, l) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l) # define BOOST_PP_TUPLE_TO_SEQ_13(a, b, c, d, e, f, g, h, i, j, k, l, m) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m) # define BOOST_PP_TUPLE_TO_SEQ_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n) # define BOOST_PP_TUPLE_TO_SEQ_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o) # define BOOST_PP_TUPLE_TO_SEQ_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p) # define BOOST_PP_TUPLE_TO_SEQ_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q) # define BOOST_PP_TUPLE_TO_SEQ_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r) # define BOOST_PP_TUPLE_TO_SEQ_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s) # define BOOST_PP_TUPLE_TO_SEQ_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t) # define BOOST_PP_TUPLE_TO_SEQ_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u) # define BOOST_PP_TUPLE_TO_SEQ_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v) # define BOOST_PP_TUPLE_TO_SEQ_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v)(w) # define BOOST_PP_TUPLE_TO_SEQ_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v)(w)(x) # define BOOST_PP_TUPLE_TO_SEQ_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) (a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)(l)(m)(n)(o)(p)(q)(r)(s)(t)(u)(v)(w)(x)(y) # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/to_list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/to0000644000175000017500000001174711344301502031700 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP # define BOOST_PREPROCESSOR_TUPLE_TO_LIST_HPP # # include # # /* BOOST_PP_TUPLE_TO_LIST */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_I(size, tuple) # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s t # else # define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_II(BOOST_PP_TUPLE_TO_LIST_ ## s t) # define BOOST_PP_TUPLE_TO_LIST_II(res) res # endif # else # define BOOST_PP_TUPLE_TO_LIST(size, tuple) BOOST_PP_TUPLE_TO_LIST_OO((size, tuple)) # define BOOST_PP_TUPLE_TO_LIST_OO(par) BOOST_PP_TUPLE_TO_LIST_I ## par # define BOOST_PP_TUPLE_TO_LIST_I(s, t) BOOST_PP_TUPLE_TO_LIST_ ## s ## t # endif # # define BOOST_PP_TUPLE_TO_LIST_0() BOOST_PP_NIL # define BOOST_PP_TUPLE_TO_LIST_1(a) (a, BOOST_PP_NIL) # define BOOST_PP_TUPLE_TO_LIST_2(a, b) (a, (b, BOOST_PP_NIL)) # define BOOST_PP_TUPLE_TO_LIST_3(a, b, c) (a, (b, (c, BOOST_PP_NIL))) # define BOOST_PP_TUPLE_TO_LIST_4(a, b, c, d) (a, (b, (c, (d, BOOST_PP_NIL)))) # define BOOST_PP_TUPLE_TO_LIST_5(a, b, c, d, e) (a, (b, (c, (d, (e, BOOST_PP_NIL))))) # define BOOST_PP_TUPLE_TO_LIST_6(a, b, c, d, e, f) (a, (b, (c, (d, (e, (f, BOOST_PP_NIL)))))) # define BOOST_PP_TUPLE_TO_LIST_7(a, b, c, d, e, f, g) (a, (b, (c, (d, (e, (f, (g, BOOST_PP_NIL))))))) # define BOOST_PP_TUPLE_TO_LIST_8(a, b, c, d, e, f, g, h) (a, (b, (c, (d, (e, (f, (g, (h, BOOST_PP_NIL)))))))) # define BOOST_PP_TUPLE_TO_LIST_9(a, b, c, d, e, f, g, h, i) (a, (b, (c, (d, (e, (f, (g, (h, (i, BOOST_PP_NIL))))))))) # define BOOST_PP_TUPLE_TO_LIST_10(a, b, c, d, e, f, g, h, i, j) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, BOOST_PP_NIL)))))))))) # define BOOST_PP_TUPLE_TO_LIST_11(a, b, c, d, e, f, g, h, i, j, k) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, BOOST_PP_NIL))))))))))) # define BOOST_PP_TUPLE_TO_LIST_12(a, b, c, d, e, f, g, h, i, j, k, l) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, BOOST_PP_NIL)))))))))))) # define BOOST_PP_TUPLE_TO_LIST_13(a, b, c, d, e, f, g, h, i, j, k, l, m) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, BOOST_PP_NIL))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, BOOST_PP_NIL)))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, BOOST_PP_NIL))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, BOOST_PP_NIL)))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, BOOST_PP_NIL))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, BOOST_PP_NIL)))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, BOOST_PP_NIL))))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, BOOST_PP_NIL)))))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, BOOST_PP_NIL))))))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, BOOST_PP_NIL)))))))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, BOOST_PP_NIL))))))))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, (x, BOOST_PP_NIL)))))))))))))))))))))))) # define BOOST_PP_TUPLE_TO_LIST_25(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) (a, (b, (c, (d, (e, (f, (g, (h, (i, (j, (k, (l, (m, (n, (o, (p, (q, (r, (s, (t, (u, (v, (w, (x, (y, BOOST_PP_NIL))))))))))))))))))))))))) # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/elem.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/tuple/el0000644000175000017500000007175311344301502031661 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_TUPLE_ELEM_HPP # define BOOST_PREPROCESSOR_TUPLE_ELEM_HPP # # include # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_I(size, index, tuple) # else # define BOOST_PP_TUPLE_ELEM(size, index, tuple) BOOST_PP_TUPLE_ELEM_OO((size, index, tuple)) # define BOOST_PP_TUPLE_ELEM_OO(par) BOOST_PP_TUPLE_ELEM_I ## par # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i ## t # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_II(BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t) # define BOOST_PP_TUPLE_ELEM_II(res) res # else # define BOOST_PP_TUPLE_ELEM_I(s, i, t) BOOST_PP_TUPLE_ELEM_ ## s ## _ ## i t # endif # # define BOOST_PP_TUPLE_ELEM_1_0(a) a # # define BOOST_PP_TUPLE_ELEM_2_0(a, b) a # define BOOST_PP_TUPLE_ELEM_2_1(a, b) b # # define BOOST_PP_TUPLE_ELEM_3_0(a, b, c) a # define BOOST_PP_TUPLE_ELEM_3_1(a, b, c) b # define BOOST_PP_TUPLE_ELEM_3_2(a, b, c) c # # define BOOST_PP_TUPLE_ELEM_4_0(a, b, c, d) a # define BOOST_PP_TUPLE_ELEM_4_1(a, b, c, d) b # define BOOST_PP_TUPLE_ELEM_4_2(a, b, c, d) c # define BOOST_PP_TUPLE_ELEM_4_3(a, b, c, d) d # # define BOOST_PP_TUPLE_ELEM_5_0(a, b, c, d, e) a # define BOOST_PP_TUPLE_ELEM_5_1(a, b, c, d, e) b # define BOOST_PP_TUPLE_ELEM_5_2(a, b, c, d, e) c # define BOOST_PP_TUPLE_ELEM_5_3(a, b, c, d, e) d # define BOOST_PP_TUPLE_ELEM_5_4(a, b, c, d, e) e # # define BOOST_PP_TUPLE_ELEM_6_0(a, b, c, d, e, f) a # define BOOST_PP_TUPLE_ELEM_6_1(a, b, c, d, e, f) b # define BOOST_PP_TUPLE_ELEM_6_2(a, b, c, d, e, f) c # define BOOST_PP_TUPLE_ELEM_6_3(a, b, c, d, e, f) d # define BOOST_PP_TUPLE_ELEM_6_4(a, b, c, d, e, f) e # define BOOST_PP_TUPLE_ELEM_6_5(a, b, c, d, e, f) f # # define BOOST_PP_TUPLE_ELEM_7_0(a, b, c, d, e, f, g) a # define BOOST_PP_TUPLE_ELEM_7_1(a, b, c, d, e, f, g) b # define BOOST_PP_TUPLE_ELEM_7_2(a, b, c, d, e, f, g) c # define BOOST_PP_TUPLE_ELEM_7_3(a, b, c, d, e, f, g) d # define BOOST_PP_TUPLE_ELEM_7_4(a, b, c, d, e, f, g) e # define BOOST_PP_TUPLE_ELEM_7_5(a, b, c, d, e, f, g) f # define BOOST_PP_TUPLE_ELEM_7_6(a, b, c, d, e, f, g) g # # define BOOST_PP_TUPLE_ELEM_8_0(a, b, c, d, e, f, g, h) a # define BOOST_PP_TUPLE_ELEM_8_1(a, b, c, d, e, f, g, h) b # define BOOST_PP_TUPLE_ELEM_8_2(a, b, c, d, e, f, g, h) c # define BOOST_PP_TUPLE_ELEM_8_3(a, b, c, d, e, f, g, h) d # define BOOST_PP_TUPLE_ELEM_8_4(a, b, c, d, e, f, g, h) e # define BOOST_PP_TUPLE_ELEM_8_5(a, b, c, d, e, f, g, h) f # define BOOST_PP_TUPLE_ELEM_8_6(a, b, c, d, e, f, g, h) g # define BOOST_PP_TUPLE_ELEM_8_7(a, b, c, d, e, f, g, h) h # # define BOOST_PP_TUPLE_ELEM_9_0(a, b, c, d, e, f, g, h, i) a # define BOOST_PP_TUPLE_ELEM_9_1(a, b, c, d, e, f, g, h, i) b # define BOOST_PP_TUPLE_ELEM_9_2(a, b, c, d, e, f, g, h, i) c # define BOOST_PP_TUPLE_ELEM_9_3(a, b, c, d, e, f, g, h, i) d # define BOOST_PP_TUPLE_ELEM_9_4(a, b, c, d, e, f, g, h, i) e # define BOOST_PP_TUPLE_ELEM_9_5(a, b, c, d, e, f, g, h, i) f # define BOOST_PP_TUPLE_ELEM_9_6(a, b, c, d, e, f, g, h, i) g # define BOOST_PP_TUPLE_ELEM_9_7(a, b, c, d, e, f, g, h, i) h # define BOOST_PP_TUPLE_ELEM_9_8(a, b, c, d, e, f, g, h, i) i # # define BOOST_PP_TUPLE_ELEM_10_0(a, b, c, d, e, f, g, h, i, j) a # define BOOST_PP_TUPLE_ELEM_10_1(a, b, c, d, e, f, g, h, i, j) b # define BOOST_PP_TUPLE_ELEM_10_2(a, b, c, d, e, f, g, h, i, j) c # define BOOST_PP_TUPLE_ELEM_10_3(a, b, c, d, e, f, g, h, i, j) d # define BOOST_PP_TUPLE_ELEM_10_4(a, b, c, d, e, f, g, h, i, j) e # define BOOST_PP_TUPLE_ELEM_10_5(a, b, c, d, e, f, g, h, i, j) f # define BOOST_PP_TUPLE_ELEM_10_6(a, b, c, d, e, f, g, h, i, j) g # define BOOST_PP_TUPLE_ELEM_10_7(a, b, c, d, e, f, g, h, i, j) h # define BOOST_PP_TUPLE_ELEM_10_8(a, b, c, d, e, f, g, h, i, j) i # define BOOST_PP_TUPLE_ELEM_10_9(a, b, c, d, e, f, g, h, i, j) j # # define BOOST_PP_TUPLE_ELEM_11_0(a, b, c, d, e, f, g, h, i, j, k) a # define BOOST_PP_TUPLE_ELEM_11_1(a, b, c, d, e, f, g, h, i, j, k) b # define BOOST_PP_TUPLE_ELEM_11_2(a, b, c, d, e, f, g, h, i, j, k) c # define BOOST_PP_TUPLE_ELEM_11_3(a, b, c, d, e, f, g, h, i, j, k) d # define BOOST_PP_TUPLE_ELEM_11_4(a, b, c, d, e, f, g, h, i, j, k) e # define BOOST_PP_TUPLE_ELEM_11_5(a, b, c, d, e, f, g, h, i, j, k) f # define BOOST_PP_TUPLE_ELEM_11_6(a, b, c, d, e, f, g, h, i, j, k) g # define BOOST_PP_TUPLE_ELEM_11_7(a, b, c, d, e, f, g, h, i, j, k) h # define BOOST_PP_TUPLE_ELEM_11_8(a, b, c, d, e, f, g, h, i, j, k) i # define BOOST_PP_TUPLE_ELEM_11_9(a, b, c, d, e, f, g, h, i, j, k) j # define BOOST_PP_TUPLE_ELEM_11_10(a, b, c, d, e, f, g, h, i, j, k) k # # define BOOST_PP_TUPLE_ELEM_12_0(a, b, c, d, e, f, g, h, i, j, k, l) a # define BOOST_PP_TUPLE_ELEM_12_1(a, b, c, d, e, f, g, h, i, j, k, l) b # define BOOST_PP_TUPLE_ELEM_12_2(a, b, c, d, e, f, g, h, i, j, k, l) c # define BOOST_PP_TUPLE_ELEM_12_3(a, b, c, d, e, f, g, h, i, j, k, l) d # define BOOST_PP_TUPLE_ELEM_12_4(a, b, c, d, e, f, g, h, i, j, k, l) e # define BOOST_PP_TUPLE_ELEM_12_5(a, b, c, d, e, f, g, h, i, j, k, l) f # define BOOST_PP_TUPLE_ELEM_12_6(a, b, c, d, e, f, g, h, i, j, k, l) g # define BOOST_PP_TUPLE_ELEM_12_7(a, b, c, d, e, f, g, h, i, j, k, l) h # define BOOST_PP_TUPLE_ELEM_12_8(a, b, c, d, e, f, g, h, i, j, k, l) i # define BOOST_PP_TUPLE_ELEM_12_9(a, b, c, d, e, f, g, h, i, j, k, l) j # define BOOST_PP_TUPLE_ELEM_12_10(a, b, c, d, e, f, g, h, i, j, k, l) k # define BOOST_PP_TUPLE_ELEM_12_11(a, b, c, d, e, f, g, h, i, j, k, l) l # # define BOOST_PP_TUPLE_ELEM_13_0(a, b, c, d, e, f, g, h, i, j, k, l, m) a # define BOOST_PP_TUPLE_ELEM_13_1(a, b, c, d, e, f, g, h, i, j, k, l, m) b # define BOOST_PP_TUPLE_ELEM_13_2(a, b, c, d, e, f, g, h, i, j, k, l, m) c # define BOOST_PP_TUPLE_ELEM_13_3(a, b, c, d, e, f, g, h, i, j, k, l, m) d # define BOOST_PP_TUPLE_ELEM_13_4(a, b, c, d, e, f, g, h, i, j, k, l, m) e # define BOOST_PP_TUPLE_ELEM_13_5(a, b, c, d, e, f, g, h, i, j, k, l, m) f # define BOOST_PP_TUPLE_ELEM_13_6(a, b, c, d, e, f, g, h, i, j, k, l, m) g # define BOOST_PP_TUPLE_ELEM_13_7(a, b, c, d, e, f, g, h, i, j, k, l, m) h # define BOOST_PP_TUPLE_ELEM_13_8(a, b, c, d, e, f, g, h, i, j, k, l, m) i # define BOOST_PP_TUPLE_ELEM_13_9(a, b, c, d, e, f, g, h, i, j, k, l, m) j # define BOOST_PP_TUPLE_ELEM_13_10(a, b, c, d, e, f, g, h, i, j, k, l, m) k # define BOOST_PP_TUPLE_ELEM_13_11(a, b, c, d, e, f, g, h, i, j, k, l, m) l # define BOOST_PP_TUPLE_ELEM_13_12(a, b, c, d, e, f, g, h, i, j, k, l, m) m # # define BOOST_PP_TUPLE_ELEM_14_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n) a # define BOOST_PP_TUPLE_ELEM_14_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n) b # define BOOST_PP_TUPLE_ELEM_14_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n) c # define BOOST_PP_TUPLE_ELEM_14_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n) d # define BOOST_PP_TUPLE_ELEM_14_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n) e # define BOOST_PP_TUPLE_ELEM_14_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n) f # define BOOST_PP_TUPLE_ELEM_14_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n) g # define BOOST_PP_TUPLE_ELEM_14_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n) h # define BOOST_PP_TUPLE_ELEM_14_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n) i # define BOOST_PP_TUPLE_ELEM_14_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n) j # define BOOST_PP_TUPLE_ELEM_14_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n) k # define BOOST_PP_TUPLE_ELEM_14_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n) l # define BOOST_PP_TUPLE_ELEM_14_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n) m # define BOOST_PP_TUPLE_ELEM_14_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n) n # # define BOOST_PP_TUPLE_ELEM_15_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) a # define BOOST_PP_TUPLE_ELEM_15_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) b # define BOOST_PP_TUPLE_ELEM_15_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) c # define BOOST_PP_TUPLE_ELEM_15_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) d # define BOOST_PP_TUPLE_ELEM_15_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) e # define BOOST_PP_TUPLE_ELEM_15_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) f # define BOOST_PP_TUPLE_ELEM_15_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) g # define BOOST_PP_TUPLE_ELEM_15_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) h # define BOOST_PP_TUPLE_ELEM_15_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) i # define BOOST_PP_TUPLE_ELEM_15_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) j # define BOOST_PP_TUPLE_ELEM_15_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) k # define BOOST_PP_TUPLE_ELEM_15_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) l # define BOOST_PP_TUPLE_ELEM_15_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) m # define BOOST_PP_TUPLE_ELEM_15_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) n # define BOOST_PP_TUPLE_ELEM_15_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) o # # define BOOST_PP_TUPLE_ELEM_16_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) a # define BOOST_PP_TUPLE_ELEM_16_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) b # define BOOST_PP_TUPLE_ELEM_16_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) c # define BOOST_PP_TUPLE_ELEM_16_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) d # define BOOST_PP_TUPLE_ELEM_16_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) e # define BOOST_PP_TUPLE_ELEM_16_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) f # define BOOST_PP_TUPLE_ELEM_16_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) g # define BOOST_PP_TUPLE_ELEM_16_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) h # define BOOST_PP_TUPLE_ELEM_16_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) i # define BOOST_PP_TUPLE_ELEM_16_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) j # define BOOST_PP_TUPLE_ELEM_16_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) k # define BOOST_PP_TUPLE_ELEM_16_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) l # define BOOST_PP_TUPLE_ELEM_16_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) m # define BOOST_PP_TUPLE_ELEM_16_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) n # define BOOST_PP_TUPLE_ELEM_16_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) o # define BOOST_PP_TUPLE_ELEM_16_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) p # # define BOOST_PP_TUPLE_ELEM_17_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) a # define BOOST_PP_TUPLE_ELEM_17_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) b # define BOOST_PP_TUPLE_ELEM_17_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) c # define BOOST_PP_TUPLE_ELEM_17_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) d # define BOOST_PP_TUPLE_ELEM_17_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) e # define BOOST_PP_TUPLE_ELEM_17_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) f # define BOOST_PP_TUPLE_ELEM_17_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) g # define BOOST_PP_TUPLE_ELEM_17_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) h # define BOOST_PP_TUPLE_ELEM_17_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) i # define BOOST_PP_TUPLE_ELEM_17_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) j # define BOOST_PP_TUPLE_ELEM_17_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) k # define BOOST_PP_TUPLE_ELEM_17_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) l # define BOOST_PP_TUPLE_ELEM_17_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) m # define BOOST_PP_TUPLE_ELEM_17_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) n # define BOOST_PP_TUPLE_ELEM_17_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) o # define BOOST_PP_TUPLE_ELEM_17_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) p # define BOOST_PP_TUPLE_ELEM_17_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) q # # define BOOST_PP_TUPLE_ELEM_18_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) a # define BOOST_PP_TUPLE_ELEM_18_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) b # define BOOST_PP_TUPLE_ELEM_18_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) c # define BOOST_PP_TUPLE_ELEM_18_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) d # define BOOST_PP_TUPLE_ELEM_18_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) e # define BOOST_PP_TUPLE_ELEM_18_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) f # define BOOST_PP_TUPLE_ELEM_18_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) g # define BOOST_PP_TUPLE_ELEM_18_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) h # define BOOST_PP_TUPLE_ELEM_18_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) i # define BOOST_PP_TUPLE_ELEM_18_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) j # define BOOST_PP_TUPLE_ELEM_18_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) k # define BOOST_PP_TUPLE_ELEM_18_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) l # define BOOST_PP_TUPLE_ELEM_18_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) m # define BOOST_PP_TUPLE_ELEM_18_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) n # define BOOST_PP_TUPLE_ELEM_18_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) o # define BOOST_PP_TUPLE_ELEM_18_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) p # define BOOST_PP_TUPLE_ELEM_18_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) q # define BOOST_PP_TUPLE_ELEM_18_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) r # # define BOOST_PP_TUPLE_ELEM_19_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) a # define BOOST_PP_TUPLE_ELEM_19_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) b # define BOOST_PP_TUPLE_ELEM_19_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) c # define BOOST_PP_TUPLE_ELEM_19_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) d # define BOOST_PP_TUPLE_ELEM_19_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) e # define BOOST_PP_TUPLE_ELEM_19_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) f # define BOOST_PP_TUPLE_ELEM_19_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) g # define BOOST_PP_TUPLE_ELEM_19_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) h # define BOOST_PP_TUPLE_ELEM_19_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) i # define BOOST_PP_TUPLE_ELEM_19_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) j # define BOOST_PP_TUPLE_ELEM_19_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) k # define BOOST_PP_TUPLE_ELEM_19_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) l # define BOOST_PP_TUPLE_ELEM_19_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) m # define BOOST_PP_TUPLE_ELEM_19_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) n # define BOOST_PP_TUPLE_ELEM_19_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) o # define BOOST_PP_TUPLE_ELEM_19_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) p # define BOOST_PP_TUPLE_ELEM_19_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) q # define BOOST_PP_TUPLE_ELEM_19_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) r # define BOOST_PP_TUPLE_ELEM_19_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) s # # define BOOST_PP_TUPLE_ELEM_20_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) a # define BOOST_PP_TUPLE_ELEM_20_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) b # define BOOST_PP_TUPLE_ELEM_20_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) c # define BOOST_PP_TUPLE_ELEM_20_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) d # define BOOST_PP_TUPLE_ELEM_20_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) e # define BOOST_PP_TUPLE_ELEM_20_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) f # define BOOST_PP_TUPLE_ELEM_20_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) g # define BOOST_PP_TUPLE_ELEM_20_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) h # define BOOST_PP_TUPLE_ELEM_20_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) i # define BOOST_PP_TUPLE_ELEM_20_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) j # define BOOST_PP_TUPLE_ELEM_20_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) k # define BOOST_PP_TUPLE_ELEM_20_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) l # define BOOST_PP_TUPLE_ELEM_20_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) m # define BOOST_PP_TUPLE_ELEM_20_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) n # define BOOST_PP_TUPLE_ELEM_20_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) o # define BOOST_PP_TUPLE_ELEM_20_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) p # define BOOST_PP_TUPLE_ELEM_20_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) q # define BOOST_PP_TUPLE_ELEM_20_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) r # define BOOST_PP_TUPLE_ELEM_20_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) s # define BOOST_PP_TUPLE_ELEM_20_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) t # # define BOOST_PP_TUPLE_ELEM_21_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) a # define BOOST_PP_TUPLE_ELEM_21_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) b # define BOOST_PP_TUPLE_ELEM_21_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) c # define BOOST_PP_TUPLE_ELEM_21_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) d # define BOOST_PP_TUPLE_ELEM_21_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) e # define BOOST_PP_TUPLE_ELEM_21_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) f # define BOOST_PP_TUPLE_ELEM_21_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) g # define BOOST_PP_TUPLE_ELEM_21_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) h # define BOOST_PP_TUPLE_ELEM_21_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) i # define BOOST_PP_TUPLE_ELEM_21_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) j # define BOOST_PP_TUPLE_ELEM_21_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) k # define BOOST_PP_TUPLE_ELEM_21_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) l # define BOOST_PP_TUPLE_ELEM_21_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) m # define BOOST_PP_TUPLE_ELEM_21_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) n # define BOOST_PP_TUPLE_ELEM_21_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) o # define BOOST_PP_TUPLE_ELEM_21_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) p # define BOOST_PP_TUPLE_ELEM_21_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) q # define BOOST_PP_TUPLE_ELEM_21_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) r # define BOOST_PP_TUPLE_ELEM_21_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) s # define BOOST_PP_TUPLE_ELEM_21_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) t # define BOOST_PP_TUPLE_ELEM_21_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) u # # define BOOST_PP_TUPLE_ELEM_22_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) a # define BOOST_PP_TUPLE_ELEM_22_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) b # define BOOST_PP_TUPLE_ELEM_22_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) c # define BOOST_PP_TUPLE_ELEM_22_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) d # define BOOST_PP_TUPLE_ELEM_22_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) e # define BOOST_PP_TUPLE_ELEM_22_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) f # define BOOST_PP_TUPLE_ELEM_22_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) g # define BOOST_PP_TUPLE_ELEM_22_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) h # define BOOST_PP_TUPLE_ELEM_22_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) i # define BOOST_PP_TUPLE_ELEM_22_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) j # define BOOST_PP_TUPLE_ELEM_22_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) k # define BOOST_PP_TUPLE_ELEM_22_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) l # define BOOST_PP_TUPLE_ELEM_22_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) m # define BOOST_PP_TUPLE_ELEM_22_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) n # define BOOST_PP_TUPLE_ELEM_22_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) o # define BOOST_PP_TUPLE_ELEM_22_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) p # define BOOST_PP_TUPLE_ELEM_22_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) q # define BOOST_PP_TUPLE_ELEM_22_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) r # define BOOST_PP_TUPLE_ELEM_22_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) s # define BOOST_PP_TUPLE_ELEM_22_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) t # define BOOST_PP_TUPLE_ELEM_22_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) u # define BOOST_PP_TUPLE_ELEM_22_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) v # # define BOOST_PP_TUPLE_ELEM_23_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) a # define BOOST_PP_TUPLE_ELEM_23_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) b # define BOOST_PP_TUPLE_ELEM_23_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) c # define BOOST_PP_TUPLE_ELEM_23_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) d # define BOOST_PP_TUPLE_ELEM_23_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) e # define BOOST_PP_TUPLE_ELEM_23_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) f # define BOOST_PP_TUPLE_ELEM_23_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) g # define BOOST_PP_TUPLE_ELEM_23_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) h # define BOOST_PP_TUPLE_ELEM_23_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) i # define BOOST_PP_TUPLE_ELEM_23_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) j # define BOOST_PP_TUPLE_ELEM_23_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) k # define BOOST_PP_TUPLE_ELEM_23_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) l # define BOOST_PP_TUPLE_ELEM_23_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) m # define BOOST_PP_TUPLE_ELEM_23_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) n # define BOOST_PP_TUPLE_ELEM_23_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) o # define BOOST_PP_TUPLE_ELEM_23_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) p # define BOOST_PP_TUPLE_ELEM_23_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) q # define BOOST_PP_TUPLE_ELEM_23_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) r # define BOOST_PP_TUPLE_ELEM_23_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) s # define BOOST_PP_TUPLE_ELEM_23_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) t # define BOOST_PP_TUPLE_ELEM_23_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) u # define BOOST_PP_TUPLE_ELEM_23_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) v # define BOOST_PP_TUPLE_ELEM_23_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) w # # define BOOST_PP_TUPLE_ELEM_24_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) a # define BOOST_PP_TUPLE_ELEM_24_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) b # define BOOST_PP_TUPLE_ELEM_24_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) c # define BOOST_PP_TUPLE_ELEM_24_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) d # define BOOST_PP_TUPLE_ELEM_24_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) e # define BOOST_PP_TUPLE_ELEM_24_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) f # define BOOST_PP_TUPLE_ELEM_24_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) g # define BOOST_PP_TUPLE_ELEM_24_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) h # define BOOST_PP_TUPLE_ELEM_24_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) i # define BOOST_PP_TUPLE_ELEM_24_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) j # define BOOST_PP_TUPLE_ELEM_24_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) k # define BOOST_PP_TUPLE_ELEM_24_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) l # define BOOST_PP_TUPLE_ELEM_24_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) m # define BOOST_PP_TUPLE_ELEM_24_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) n # define BOOST_PP_TUPLE_ELEM_24_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) o # define BOOST_PP_TUPLE_ELEM_24_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) p # define BOOST_PP_TUPLE_ELEM_24_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) q # define BOOST_PP_TUPLE_ELEM_24_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) r # define BOOST_PP_TUPLE_ELEM_24_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) s # define BOOST_PP_TUPLE_ELEM_24_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) t # define BOOST_PP_TUPLE_ELEM_24_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) u # define BOOST_PP_TUPLE_ELEM_24_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) v # define BOOST_PP_TUPLE_ELEM_24_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) w # define BOOST_PP_TUPLE_ELEM_24_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) x # # define BOOST_PP_TUPLE_ELEM_25_0(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) a # define BOOST_PP_TUPLE_ELEM_25_1(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) b # define BOOST_PP_TUPLE_ELEM_25_2(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) c # define BOOST_PP_TUPLE_ELEM_25_3(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) d # define BOOST_PP_TUPLE_ELEM_25_4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) e # define BOOST_PP_TUPLE_ELEM_25_5(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) f # define BOOST_PP_TUPLE_ELEM_25_6(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) g # define BOOST_PP_TUPLE_ELEM_25_7(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) h # define BOOST_PP_TUPLE_ELEM_25_8(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) i # define BOOST_PP_TUPLE_ELEM_25_9(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) j # define BOOST_PP_TUPLE_ELEM_25_10(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) k # define BOOST_PP_TUPLE_ELEM_25_11(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) l # define BOOST_PP_TUPLE_ELEM_25_12(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) m # define BOOST_PP_TUPLE_ELEM_25_13(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) n # define BOOST_PP_TUPLE_ELEM_25_14(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) o # define BOOST_PP_TUPLE_ELEM_25_15(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) p # define BOOST_PP_TUPLE_ELEM_25_16(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) q # define BOOST_PP_TUPLE_ELEM_25_17(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) r # define BOOST_PP_TUPLE_ELEM_25_18(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) s # define BOOST_PP_TUPLE_ELEM_25_19(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) t # define BOOST_PP_TUPLE_ELEM_25_20(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) u # define BOOST_PP_TUPLE_ELEM_25_21(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) v # define BOOST_PP_TUPLE_ELEM_25_22(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) w # define BOOST_PP_TUPLE_ELEM_25_23(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) x # define BOOST_PP_TUPLE_ELEM_25_24(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) y # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000755000175000017500000000000012146213764031712 5ustar debiandebian././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/is_empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000421011344301502031674 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2003. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP # define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP # # include # include # include # include # include # # /* BOOST_PP_IS_EMPTY */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I(x BOOST_PP_IS_EMPTY_HELPER) # define BOOST_PP_IS_EMPTY_I(contents) BOOST_PP_TUPLE_ELEM(2, 1, (BOOST_PP_IS_EMPTY_DEF_ ## contents())) # define BOOST_PP_IS_EMPTY_DEF_BOOST_PP_IS_EMPTY_HELPER 1, 1 BOOST_PP_EMPTY # define BOOST_PP_IS_EMPTY_HELPER() , 0 # else # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I(BOOST_PP_IS_EMPTY_HELPER x ()) # define BOOST_PP_IS_EMPTY_I(test) BOOST_PP_IS_EMPTY_II(BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PP_IS_EMPTY_DEF_, test))) # define BOOST_PP_IS_EMPTY_II(id) id # else # define BOOST_PP_IS_EMPTY(x) BOOST_PP_IS_EMPTY_I((BOOST_PP_IS_EMPTY_HELPER x ())) # define BOOST_PP_IS_EMPTY_I(par) BOOST_PP_IS_EMPTY_II ## par # define BOOST_PP_IS_EMPTY_II(test) BOOST_PP_SPLIT(0, BOOST_PP_CAT(BOOST_PP_IS_EMPTY_DEF_, test)) # endif # define BOOST_PP_IS_EMPTY_HELPER() 1 # define BOOST_PP_IS_EMPTY_DEF_1 1, BOOST_PP_NIL # define BOOST_PP_IS_EMPTY_DEF_BOOST_PP_IS_EMPTY_HELPER 0, BOOST_PP_NIL # endif # # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000270311344301502031701 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_APPLY_HPP # define BOOST_PREPROCESSOR_FACILITIES_APPLY_HPP # # include # include # include # include # # /* BOOST_PP_APPLY */ # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_APPLY(x) BOOST_PP_APPLY_I(x) # define BOOST_PP_APPLY_I(x) BOOST_PP_EXPR_IIF(BOOST_PP_IS_UNARY(x), BOOST_PP_TUPLE_REM_1 x) # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() # define BOOST_PP_APPLY(x) BOOST_PP_APPLY_I(x) # define BOOST_PP_APPLY_I(x) BOOST_PP_APPLY_ ## x # define BOOST_PP_APPLY_(x) x # define BOOST_PP_APPLY_BOOST_PP_NIL # else # define BOOST_PP_APPLY(x) BOOST_PP_EXPR_IIF(BOOST_PP_IS_UNARY(x), BOOST_PP_TUPLE_REM_1 x) # endif # # endif ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/identity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000113611344301502031700 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP # define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP # # include # # /* BOOST_PP_IDENTITY */ # # define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY # # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000100411344301502031672 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP # define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP # # /* BOOST_PP_EMPTY */ # # define BOOST_PP_EMPTY() # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/is_1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000166211344301502031704 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2003. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP # define BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP # # include # include # # /* BOOST_PP_IS_1 */ # # define BOOST_PP_IS_1(x) BOOST_PP_IS_EMPTY(BOOST_PP_CAT(BOOST_PP_IS_1_HELPER_, x)) # define BOOST_PP_IS_1_HELPER_1 # # endif ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/is_empty_or_1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000217211344301502031701 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2003. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_OR_1_HPP # define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_OR_1_HPP # # include # include # include # include # # /* BOOST_PP_IS_EMPTY_OR_1 */ # # define BOOST_PP_IS_EMPTY_OR_1(x) \ BOOST_PP_IIF( \ BOOST_PP_IS_EMPTY(x BOOST_PP_EMPTY()), \ 1 BOOST_PP_EMPTY, \ BOOST_PP_IS_1 \ )(x) \ /**/ # # endif ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/intercept.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000002132111344301502031676 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_INTERCEPT_HPP # define BOOST_PREPROCESSOR_FACILITIES_INTERCEPT_HPP # # /* BOOST_PP_INTERCEPT */ # # define BOOST_PP_INTERCEPT BOOST_PP_INTERCEPT_ # # define BOOST_PP_INTERCEPT_0 # define BOOST_PP_INTERCEPT_1 # define BOOST_PP_INTERCEPT_2 # define BOOST_PP_INTERCEPT_3 # define BOOST_PP_INTERCEPT_4 # define BOOST_PP_INTERCEPT_5 # define BOOST_PP_INTERCEPT_6 # define BOOST_PP_INTERCEPT_7 # define BOOST_PP_INTERCEPT_8 # define BOOST_PP_INTERCEPT_9 # define BOOST_PP_INTERCEPT_10 # define BOOST_PP_INTERCEPT_11 # define BOOST_PP_INTERCEPT_12 # define BOOST_PP_INTERCEPT_13 # define BOOST_PP_INTERCEPT_14 # define BOOST_PP_INTERCEPT_15 # define BOOST_PP_INTERCEPT_16 # define BOOST_PP_INTERCEPT_17 # define BOOST_PP_INTERCEPT_18 # define BOOST_PP_INTERCEPT_19 # define BOOST_PP_INTERCEPT_20 # define BOOST_PP_INTERCEPT_21 # define BOOST_PP_INTERCEPT_22 # define BOOST_PP_INTERCEPT_23 # define BOOST_PP_INTERCEPT_24 # define BOOST_PP_INTERCEPT_25 # define BOOST_PP_INTERCEPT_26 # define BOOST_PP_INTERCEPT_27 # define BOOST_PP_INTERCEPT_28 # define BOOST_PP_INTERCEPT_29 # define BOOST_PP_INTERCEPT_30 # define BOOST_PP_INTERCEPT_31 # define BOOST_PP_INTERCEPT_32 # define BOOST_PP_INTERCEPT_33 # define BOOST_PP_INTERCEPT_34 # define BOOST_PP_INTERCEPT_35 # define BOOST_PP_INTERCEPT_36 # define BOOST_PP_INTERCEPT_37 # define BOOST_PP_INTERCEPT_38 # define BOOST_PP_INTERCEPT_39 # define BOOST_PP_INTERCEPT_40 # define BOOST_PP_INTERCEPT_41 # define BOOST_PP_INTERCEPT_42 # define BOOST_PP_INTERCEPT_43 # define BOOST_PP_INTERCEPT_44 # define BOOST_PP_INTERCEPT_45 # define BOOST_PP_INTERCEPT_46 # define BOOST_PP_INTERCEPT_47 # define BOOST_PP_INTERCEPT_48 # define BOOST_PP_INTERCEPT_49 # define BOOST_PP_INTERCEPT_50 # define BOOST_PP_INTERCEPT_51 # define BOOST_PP_INTERCEPT_52 # define BOOST_PP_INTERCEPT_53 # define BOOST_PP_INTERCEPT_54 # define BOOST_PP_INTERCEPT_55 # define BOOST_PP_INTERCEPT_56 # define BOOST_PP_INTERCEPT_57 # define BOOST_PP_INTERCEPT_58 # define BOOST_PP_INTERCEPT_59 # define BOOST_PP_INTERCEPT_60 # define BOOST_PP_INTERCEPT_61 # define BOOST_PP_INTERCEPT_62 # define BOOST_PP_INTERCEPT_63 # define BOOST_PP_INTERCEPT_64 # define BOOST_PP_INTERCEPT_65 # define BOOST_PP_INTERCEPT_66 # define BOOST_PP_INTERCEPT_67 # define BOOST_PP_INTERCEPT_68 # define BOOST_PP_INTERCEPT_69 # define BOOST_PP_INTERCEPT_70 # define BOOST_PP_INTERCEPT_71 # define BOOST_PP_INTERCEPT_72 # define BOOST_PP_INTERCEPT_73 # define BOOST_PP_INTERCEPT_74 # define BOOST_PP_INTERCEPT_75 # define BOOST_PP_INTERCEPT_76 # define BOOST_PP_INTERCEPT_77 # define BOOST_PP_INTERCEPT_78 # define BOOST_PP_INTERCEPT_79 # define BOOST_PP_INTERCEPT_80 # define BOOST_PP_INTERCEPT_81 # define BOOST_PP_INTERCEPT_82 # define BOOST_PP_INTERCEPT_83 # define BOOST_PP_INTERCEPT_84 # define BOOST_PP_INTERCEPT_85 # define BOOST_PP_INTERCEPT_86 # define BOOST_PP_INTERCEPT_87 # define BOOST_PP_INTERCEPT_88 # define BOOST_PP_INTERCEPT_89 # define BOOST_PP_INTERCEPT_90 # define BOOST_PP_INTERCEPT_91 # define BOOST_PP_INTERCEPT_92 # define BOOST_PP_INTERCEPT_93 # define BOOST_PP_INTERCEPT_94 # define BOOST_PP_INTERCEPT_95 # define BOOST_PP_INTERCEPT_96 # define BOOST_PP_INTERCEPT_97 # define BOOST_PP_INTERCEPT_98 # define BOOST_PP_INTERCEPT_99 # define BOOST_PP_INTERCEPT_100 # define BOOST_PP_INTERCEPT_101 # define BOOST_PP_INTERCEPT_102 # define BOOST_PP_INTERCEPT_103 # define BOOST_PP_INTERCEPT_104 # define BOOST_PP_INTERCEPT_105 # define BOOST_PP_INTERCEPT_106 # define BOOST_PP_INTERCEPT_107 # define BOOST_PP_INTERCEPT_108 # define BOOST_PP_INTERCEPT_109 # define BOOST_PP_INTERCEPT_110 # define BOOST_PP_INTERCEPT_111 # define BOOST_PP_INTERCEPT_112 # define BOOST_PP_INTERCEPT_113 # define BOOST_PP_INTERCEPT_114 # define BOOST_PP_INTERCEPT_115 # define BOOST_PP_INTERCEPT_116 # define BOOST_PP_INTERCEPT_117 # define BOOST_PP_INTERCEPT_118 # define BOOST_PP_INTERCEPT_119 # define BOOST_PP_INTERCEPT_120 # define BOOST_PP_INTERCEPT_121 # define BOOST_PP_INTERCEPT_122 # define BOOST_PP_INTERCEPT_123 # define BOOST_PP_INTERCEPT_124 # define BOOST_PP_INTERCEPT_125 # define BOOST_PP_INTERCEPT_126 # define BOOST_PP_INTERCEPT_127 # define BOOST_PP_INTERCEPT_128 # define BOOST_PP_INTERCEPT_129 # define BOOST_PP_INTERCEPT_130 # define BOOST_PP_INTERCEPT_131 # define BOOST_PP_INTERCEPT_132 # define BOOST_PP_INTERCEPT_133 # define BOOST_PP_INTERCEPT_134 # define BOOST_PP_INTERCEPT_135 # define BOOST_PP_INTERCEPT_136 # define BOOST_PP_INTERCEPT_137 # define BOOST_PP_INTERCEPT_138 # define BOOST_PP_INTERCEPT_139 # define BOOST_PP_INTERCEPT_140 # define BOOST_PP_INTERCEPT_141 # define BOOST_PP_INTERCEPT_142 # define BOOST_PP_INTERCEPT_143 # define BOOST_PP_INTERCEPT_144 # define BOOST_PP_INTERCEPT_145 # define BOOST_PP_INTERCEPT_146 # define BOOST_PP_INTERCEPT_147 # define BOOST_PP_INTERCEPT_148 # define BOOST_PP_INTERCEPT_149 # define BOOST_PP_INTERCEPT_150 # define BOOST_PP_INTERCEPT_151 # define BOOST_PP_INTERCEPT_152 # define BOOST_PP_INTERCEPT_153 # define BOOST_PP_INTERCEPT_154 # define BOOST_PP_INTERCEPT_155 # define BOOST_PP_INTERCEPT_156 # define BOOST_PP_INTERCEPT_157 # define BOOST_PP_INTERCEPT_158 # define BOOST_PP_INTERCEPT_159 # define BOOST_PP_INTERCEPT_160 # define BOOST_PP_INTERCEPT_161 # define BOOST_PP_INTERCEPT_162 # define BOOST_PP_INTERCEPT_163 # define BOOST_PP_INTERCEPT_164 # define BOOST_PP_INTERCEPT_165 # define BOOST_PP_INTERCEPT_166 # define BOOST_PP_INTERCEPT_167 # define BOOST_PP_INTERCEPT_168 # define BOOST_PP_INTERCEPT_169 # define BOOST_PP_INTERCEPT_170 # define BOOST_PP_INTERCEPT_171 # define BOOST_PP_INTERCEPT_172 # define BOOST_PP_INTERCEPT_173 # define BOOST_PP_INTERCEPT_174 # define BOOST_PP_INTERCEPT_175 # define BOOST_PP_INTERCEPT_176 # define BOOST_PP_INTERCEPT_177 # define BOOST_PP_INTERCEPT_178 # define BOOST_PP_INTERCEPT_179 # define BOOST_PP_INTERCEPT_180 # define BOOST_PP_INTERCEPT_181 # define BOOST_PP_INTERCEPT_182 # define BOOST_PP_INTERCEPT_183 # define BOOST_PP_INTERCEPT_184 # define BOOST_PP_INTERCEPT_185 # define BOOST_PP_INTERCEPT_186 # define BOOST_PP_INTERCEPT_187 # define BOOST_PP_INTERCEPT_188 # define BOOST_PP_INTERCEPT_189 # define BOOST_PP_INTERCEPT_190 # define BOOST_PP_INTERCEPT_191 # define BOOST_PP_INTERCEPT_192 # define BOOST_PP_INTERCEPT_193 # define BOOST_PP_INTERCEPT_194 # define BOOST_PP_INTERCEPT_195 # define BOOST_PP_INTERCEPT_196 # define BOOST_PP_INTERCEPT_197 # define BOOST_PP_INTERCEPT_198 # define BOOST_PP_INTERCEPT_199 # define BOOST_PP_INTERCEPT_200 # define BOOST_PP_INTERCEPT_201 # define BOOST_PP_INTERCEPT_202 # define BOOST_PP_INTERCEPT_203 # define BOOST_PP_INTERCEPT_204 # define BOOST_PP_INTERCEPT_205 # define BOOST_PP_INTERCEPT_206 # define BOOST_PP_INTERCEPT_207 # define BOOST_PP_INTERCEPT_208 # define BOOST_PP_INTERCEPT_209 # define BOOST_PP_INTERCEPT_210 # define BOOST_PP_INTERCEPT_211 # define BOOST_PP_INTERCEPT_212 # define BOOST_PP_INTERCEPT_213 # define BOOST_PP_INTERCEPT_214 # define BOOST_PP_INTERCEPT_215 # define BOOST_PP_INTERCEPT_216 # define BOOST_PP_INTERCEPT_217 # define BOOST_PP_INTERCEPT_218 # define BOOST_PP_INTERCEPT_219 # define BOOST_PP_INTERCEPT_220 # define BOOST_PP_INTERCEPT_221 # define BOOST_PP_INTERCEPT_222 # define BOOST_PP_INTERCEPT_223 # define BOOST_PP_INTERCEPT_224 # define BOOST_PP_INTERCEPT_225 # define BOOST_PP_INTERCEPT_226 # define BOOST_PP_INTERCEPT_227 # define BOOST_PP_INTERCEPT_228 # define BOOST_PP_INTERCEPT_229 # define BOOST_PP_INTERCEPT_230 # define BOOST_PP_INTERCEPT_231 # define BOOST_PP_INTERCEPT_232 # define BOOST_PP_INTERCEPT_233 # define BOOST_PP_INTERCEPT_234 # define BOOST_PP_INTERCEPT_235 # define BOOST_PP_INTERCEPT_236 # define BOOST_PP_INTERCEPT_237 # define BOOST_PP_INTERCEPT_238 # define BOOST_PP_INTERCEPT_239 # define BOOST_PP_INTERCEPT_240 # define BOOST_PP_INTERCEPT_241 # define BOOST_PP_INTERCEPT_242 # define BOOST_PP_INTERCEPT_243 # define BOOST_PP_INTERCEPT_244 # define BOOST_PP_INTERCEPT_245 # define BOOST_PP_INTERCEPT_246 # define BOOST_PP_INTERCEPT_247 # define BOOST_PP_INTERCEPT_248 # define BOOST_PP_INTERCEPT_249 # define BOOST_PP_INTERCEPT_250 # define BOOST_PP_INTERCEPT_251 # define BOOST_PP_INTERCEPT_252 # define BOOST_PP_INTERCEPT_253 # define BOOST_PP_INTERCEPT_254 # define BOOST_PP_INTERCEPT_255 # define BOOST_PP_INTERCEPT_256 # # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/facilities/expand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/faciliti0000644000175000017500000000151211344301502031676 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP # define BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP # # include # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_I(x) # else # define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_OO((x)) # define BOOST_PP_EXPAND_OO(par) BOOST_PP_EXPAND_I ## par # endif # # define BOOST_PP_EXPAND_I(x) x # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/enum.hpp0000644000175000017500000000134311344301502031646 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ENUM_HPP # define BOOST_PREPROCESSOR_ENUM_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/0000755000175000017500000000000012146213762031321 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/reverse.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/re0000644000175000017500000000254211344301502031642 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_REVERSE_HPP # define BOOST_PREPROCESSOR_ARRAY_REVERSE_HPP # # include # include # include # include # # /* BOOST_PP_ARRAY_REVERSE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_REVERSE(array) (BOOST_PP_ARRAY_SIZE(array), BOOST_PP_TUPLE_REVERSE(BOOST_PP_ARRAY_SIZE(array), BOOST_PP_ARRAY_DATA(array))) # else # define BOOST_PP_ARRAY_REVERSE(array) BOOST_PP_ARRAY_REVERSE_I(array) # define BOOST_PP_ARRAY_REVERSE_I(array) (BOOST_PP_ARRAY_SIZE(array), BOOST_PP_TUPLE_REVERSE(BOOST_PP_ARRAY_SIZE(array), BOOST_PP_ARRAY_DATA(array))) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/pop_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/po0000644000175000017500000000330411344301502031647 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_POP_BACK_HPP # define BOOST_PREPROCESSOR_ARRAY_POP_BACK_HPP # # include # include # include # include # include # # /* BOOST_PP_ARRAY_POP_BACK */ # # define BOOST_PP_ARRAY_POP_BACK(array) BOOST_PP_ARRAY_POP_BACK_Z(BOOST_PP_DEDUCE_Z(), array) # # /* BOOST_PP_ARRAY_POP_BACK_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_POP_BACK_Z(z, array) BOOST_PP_ARRAY_POP_BACK_I(z, BOOST_PP_ARRAY_SIZE(array), array) # else # define BOOST_PP_ARRAY_POP_BACK_Z(z, array) BOOST_PP_ARRAY_POP_BACK_Z_D(z, array) # define BOOST_PP_ARRAY_POP_BACK_Z_D(z, array) BOOST_PP_ARRAY_POP_BACK_I(z, BOOST_PP_ARRAY_SIZE(array), array) # endif # # define BOOST_PP_ARRAY_POP_BACK_I(z, size, array) (BOOST_PP_DEC(size), (BOOST_PP_ENUM_ ## z(BOOST_PP_DEC(size), BOOST_PP_ARRAY_POP_BACK_M, array))) # define BOOST_PP_ARRAY_POP_BACK_M(z, n, data) BOOST_PP_ARRAY_ELEM(n, data) # # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/push_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/pu0000644000175000017500000000313311344301502031655 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_PUSH_FRONT_HPP # define BOOST_PREPROCESSOR_ARRAY_PUSH_FRONT_HPP # # include # include # include # include # include # include # # /* BOOST_PP_ARRAY_PUSH_FRONT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_PUSH_FRONT(array, elem) BOOST_PP_ARRAY_PUSH_FRONT_I(BOOST_PP_ARRAY_SIZE(array), BOOST_PP_ARRAY_DATA(array), elem) # else # define BOOST_PP_ARRAY_PUSH_FRONT(array, elem) BOOST_PP_ARRAY_PUSH_FRONT_D(array, elem) # define BOOST_PP_ARRAY_PUSH_FRONT_D(array, elem) BOOST_PP_ARRAY_PUSH_FRONT_I(BOOST_PP_ARRAY_SIZE(array), BOOST_PP_ARRAY_DATA(array), elem) # endif # # define BOOST_PP_ARRAY_PUSH_FRONT_I(size, data, elem) (BOOST_PP_INC(size), (elem BOOST_PP_COMMA_IF(size) BOOST_PP_TUPLE_REM(size) data)) # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/push_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/pu0000644000175000017500000000312111344301502031652 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_PUSH_BACK_HPP # define BOOST_PREPROCESSOR_ARRAY_PUSH_BACK_HPP # # include # include # include # include # include # include # # /* BOOST_PP_ARRAY_PUSH_BACK */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_PUSH_BACK(array, elem) BOOST_PP_ARRAY_PUSH_BACK_I(BOOST_PP_ARRAY_SIZE(array), BOOST_PP_ARRAY_DATA(array), elem) # else # define BOOST_PP_ARRAY_PUSH_BACK(array, elem) BOOST_PP_ARRAY_PUSH_BACK_D(array, elem) # define BOOST_PP_ARRAY_PUSH_BACK_D(array, elem) BOOST_PP_ARRAY_PUSH_BACK_I(BOOST_PP_ARRAY_SIZE(array), BOOST_PP_ARRAY_DATA(array), elem) # endif # # define BOOST_PP_ARRAY_PUSH_BACK_I(size, data, elem) (BOOST_PP_INC(size), (BOOST_PP_TUPLE_REM(size) data BOOST_PP_COMMA_IF(size) elem)) # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/replace.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/re0000644000175000017500000000524511344301502031645 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_REPLACE_HPP # define BOOST_PREPROCESSOR_ARRAY_REPLACE_HPP # # include # include # include # include # include # include # include # include # include # # /* BOOST_PP_ARRAY_REPLACE */ # # define BOOST_PP_ARRAY_REPLACE(array, i, elem) BOOST_PP_ARRAY_REPLACE_I(BOOST_PP_DEDUCE_D(), array, i, elem) # define BOOST_PP_ARRAY_REPLACE_I(d, array, i, elem) BOOST_PP_ARRAY_REPLACE_D(d, array, i, elem) # # /* BOOST_PP_ARRAY_REPLACE_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_REPLACE_D(d, array, i, elem) BOOST_PP_TUPLE_ELEM(5, 3, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_REPLACE_P, BOOST_PP_ARRAY_REPLACE_O, (0, i, elem, (0, ()), array))) # else # define BOOST_PP_ARRAY_REPLACE_D(d, array, i, elem) BOOST_PP_ARRAY_REPLACE_D_I(d, array, i, elem) # define BOOST_PP_ARRAY_REPLACE_D_I(d, array, i, elem) BOOST_PP_TUPLE_ELEM(5, 3, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_REPLACE_P, BOOST_PP_ARRAY_REPLACE_O, (0, i, elem, (0, ()), array))) # endif # # define BOOST_PP_ARRAY_REPLACE_P(d, state) BOOST_PP_NOT_EQUAL(BOOST_PP_TUPLE_ELEM(5, 0, state), BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_ELEM(5, 4, state))) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ARRAY_REPLACE_O(d, state) BOOST_PP_ARRAY_REPLACE_O_I state # else # define BOOST_PP_ARRAY_REPLACE_O(d, state) BOOST_PP_ARRAY_REPLACE_O_I(BOOST_PP_TUPLE_ELEM(5, 0, state), BOOST_PP_TUPLE_ELEM(5, 1, state), BOOST_PP_TUPLE_ELEM(5, 2, state), BOOST_PP_TUPLE_ELEM(5, 3, state), BOOST_PP_TUPLE_ELEM(5, 4, state)) # endif # # define BOOST_PP_ARRAY_REPLACE_O_I(n, i, elem, res, arr) (BOOST_PP_INC(n), i, elem, BOOST_PP_ARRAY_PUSH_BACK(res, BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(n, i), BOOST_PP_ARRAY_ELEM(n, arr), elem)), arr) # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/si0000644000175000017500000000220611344301502031644 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_SIZE_HPP # define BOOST_PREPROCESSOR_ARRAY_SIZE_HPP # # include # include # # /* BOOST_PP_ARRAY_SIZE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_TUPLE_ELEM(2, 0, array) # else # define BOOST_PP_ARRAY_SIZE(array) BOOST_PP_ARRAY_SIZE_I(array) # define BOOST_PP_ARRAY_SIZE_I(array) BOOST_PP_ARRAY_SIZE_II array # define BOOST_PP_ARRAY_SIZE_II(size, data) size # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/remove.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/re0000644000175000017500000000553211344301502031644 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_REMOVE_HPP # define BOOST_PREPROCESSOR_ARRAY_REMOVE_HPP # # include # include # include # include # include # include # include # include # include # include # # /* BOOST_PP_ARRAY_REMOVE */ # # define BOOST_PP_ARRAY_REMOVE(array, i) BOOST_PP_ARRAY_REMOVE_I(BOOST_PP_DEDUCE_D(), array, i) # define BOOST_PP_ARRAY_REMOVE_I(d, array, i) BOOST_PP_ARRAY_REMOVE_D(d, array, i) # # /* BOOST_PP_ARRAY_REMOVE_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_REMOVE_D(d, array, i) BOOST_PP_TUPLE_ELEM(4, 2, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_REMOVE_P, BOOST_PP_ARRAY_REMOVE_O, (0, i, (0, ()), array))) # else # define BOOST_PP_ARRAY_REMOVE_D(d, array, i) BOOST_PP_ARRAY_REMOVE_D_I(d, array, i) # define BOOST_PP_ARRAY_REMOVE_D_I(d, array, i) BOOST_PP_TUPLE_ELEM(4, 2, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_REMOVE_P, BOOST_PP_ARRAY_REMOVE_O, (0, i, (0, ()), array))) # endif # # define BOOST_PP_ARRAY_REMOVE_P(d, st) BOOST_PP_NOT_EQUAL(BOOST_PP_TUPLE_ELEM(4, 0, st), BOOST_PP_ARRAY_SIZE(BOOST_PP_TUPLE_ELEM(4, 3, st))) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ARRAY_REMOVE_O(d, st) BOOST_PP_ARRAY_REMOVE_O_I st # else # define BOOST_PP_ARRAY_REMOVE_O(d, st) BOOST_PP_ARRAY_REMOVE_O_I(BOOST_PP_TUPLE_ELEM(4, 0, st), BOOST_PP_TUPLE_ELEM(4, 1, st), BOOST_PP_TUPLE_ELEM(4, 2, st), BOOST_PP_TUPLE_ELEM(4, 3, st)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_ARRAY_REMOVE_O_I(n, i, res, arr) (BOOST_PP_INC(n), i, BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(n, i), BOOST_PP_ARRAY_PUSH_BACK, res BOOST_PP_TUPLE_EAT_2)(res, BOOST_PP_ARRAY_ELEM(n, arr)), arr) # else # define BOOST_PP_ARRAY_REMOVE_O_I(n, i, res, arr) (BOOST_PP_INC(n), i, BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(n, i), BOOST_PP_ARRAY_PUSH_BACK, BOOST_PP_TUPLE_ELEM_2_0)(res, BOOST_PP_ARRAY_ELEM(n, arr)), arr) # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/insert.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/in0000644000175000017500000000602111344301502031636 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_INSERT_HPP # define BOOST_PREPROCESSOR_ARRAY_INSERT_HPP # # include # include # include # include # include # include # include # include # include # # /* BOOST_PP_ARRAY_INSERT */ # # define BOOST_PP_ARRAY_INSERT(array, i, elem) BOOST_PP_ARRAY_INSERT_I(BOOST_PP_DEDUCE_D(), array, i, elem) # define BOOST_PP_ARRAY_INSERT_I(d, array, i, elem) BOOST_PP_ARRAY_INSERT_D(d, array, i, elem) # # /* BOOST_PP_ARRAY_INSERT_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_INSERT_D(d, array, i, elem) BOOST_PP_TUPLE_ELEM(5, 3, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_INSERT_P, BOOST_PP_ARRAY_INSERT_O, (0, i, elem, (0, ()), array))) # else # define BOOST_PP_ARRAY_INSERT_D(d, array, i, elem) BOOST_PP_ARRAY_INSERT_D_I(d, array, i, elem) # define BOOST_PP_ARRAY_INSERT_D_I(d, array, i, elem) BOOST_PP_TUPLE_ELEM(5, 3, BOOST_PP_WHILE_ ## d(BOOST_PP_ARRAY_INSERT_P, BOOST_PP_ARRAY_INSERT_O, (0, i, elem, (0, ()), array))) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ARRAY_INSERT_P(d, state) BOOST_PP_ARRAY_INSERT_P_I state # else # define BOOST_PP_ARRAY_INSERT_P(d, state) BOOST_PP_ARRAY_INSERT_P_I(nil, nil, nil, BOOST_PP_TUPLE_ELEM(5, 3, state), BOOST_PP_TUPLE_ELEM(5, 4, state)) # endif # # define BOOST_PP_ARRAY_INSERT_P_I(_i, _ii, _iii, res, arr) BOOST_PP_NOT_EQUAL(BOOST_PP_ARRAY_SIZE(res), BOOST_PP_INC(BOOST_PP_ARRAY_SIZE(arr))) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_ARRAY_INSERT_O(d, state) BOOST_PP_ARRAY_INSERT_O_I state # else # define BOOST_PP_ARRAY_INSERT_O(d, state) BOOST_PP_ARRAY_INSERT_O_I(BOOST_PP_TUPLE_ELEM(5, 0, state), BOOST_PP_TUPLE_ELEM(5, 1, state), BOOST_PP_TUPLE_ELEM(5, 2, state), BOOST_PP_TUPLE_ELEM(5, 3, state), BOOST_PP_TUPLE_ELEM(5, 4, state)) # endif # # define BOOST_PP_ARRAY_INSERT_O_I(n, i, elem, res, arr) (BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(BOOST_PP_ARRAY_SIZE(res), i), BOOST_PP_INC(n), n), i, elem, BOOST_PP_ARRAY_PUSH_BACK(res, BOOST_PP_IIF(BOOST_PP_NOT_EQUAL(BOOST_PP_ARRAY_SIZE(res), i), BOOST_PP_ARRAY_ELEM(n, arr), elem)), arr) # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/elem.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/el0000644000175000017500000000243211344301502031632 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_ELEM_HPP # define BOOST_PREPROCESSOR_ARRAY_ELEM_HPP # # include # include # include # include # # /* BOOST_PP_ARRAY_ELEM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array)) # else # define BOOST_PP_ARRAY_ELEM(i, array) BOOST_PP_ARRAY_ELEM_I(i, array) # define BOOST_PP_ARRAY_ELEM_I(i, array) BOOST_PP_TUPLE_ELEM(BOOST_PP_ARRAY_SIZE(array), i, BOOST_PP_ARRAY_DATA(array)) # endif # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/data.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/da0000644000175000017500000000220611344301502031615 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_DATA_HPP # define BOOST_PREPROCESSOR_ARRAY_DATA_HPP # # include # include # # /* BOOST_PP_ARRAY_DATA */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_DATA(array) BOOST_PP_TUPLE_ELEM(2, 1, array) # else # define BOOST_PP_ARRAY_DATA(array) BOOST_PP_ARRAY_DATA_I(array) # define BOOST_PP_ARRAY_DATA_I(array) BOOST_PP_ARRAY_DATA_II array # define BOOST_PP_ARRAY_DATA_II(size, data) data # endif # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/pop_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/array/po0000644000175000017500000000342311344301502031651 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ARRAY_POP_FRONT_HPP # define BOOST_PREPROCESSOR_ARRAY_POP_FRONT_HPP # # include # include # include # include # include # include # # /* BOOST_PP_ARRAY_POP_FRONT */ # # define BOOST_PP_ARRAY_POP_FRONT(array) BOOST_PP_ARRAY_POP_FRONT_Z(BOOST_PP_DEDUCE_Z(), array) # # /* BOOST_PP_ARRAY_POP_FRONT_Z */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_ARRAY_POP_FRONT_Z(z, array) BOOST_PP_ARRAY_POP_FRONT_I(z, BOOST_PP_ARRAY_SIZE(array), array) # else # define BOOST_PP_ARRAY_POP_FRONT_Z(z, array) BOOST_PP_ARRAY_POP_FRONT_Z_D(z, array) # define BOOST_PP_ARRAY_POP_FRONT_Z_D(z, array) BOOST_PP_ARRAY_POP_FRONT_I(z, BOOST_PP_ARRAY_SIZE(array), array) # endif # # define BOOST_PP_ARRAY_POP_FRONT_I(z, size, array) (BOOST_PP_DEC(size), (BOOST_PP_ENUM_ ## z(BOOST_PP_DEC(size), BOOST_PP_ARRAY_POP_FRONT_M, array))) # define BOOST_PP_ARRAY_POP_FRONT_M(z, n, data) BOOST_PP_ARRAY_ELEM(BOOST_PP_INC(n), data) # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/if.hpp0000644000175000017500000000133211344301502031276 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_IF_HPP # define BOOST_PREPROCESSOR_IF_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000755000175000017500000000000012146213767031622 5ustar debiandebian././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/bitnor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000260511344301502031607 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_BITNOR_HPP # define BOOST_PREPROCESSOR_LOGICAL_BITNOR_HPP # # include # # /* BOOST_PP_BITNOR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_BITNOR(x, y) BOOST_PP_BITNOR_I(x, y) # else # define BOOST_PP_BITNOR(x, y) BOOST_PP_BITNOR_OO((x, y)) # define BOOST_PP_BITNOR_OO(par) BOOST_PP_BITNOR_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_BITNOR_I(x, y) BOOST_PP_BITNOR_ ## x ## y # else # define BOOST_PP_BITNOR_I(x, y) BOOST_PP_BITNOR_ID(BOOST_PP_BITNOR_ ## x ## y) # define BOOST_PP_BITNOR_ID(id) id # endif # # define BOOST_PP_BITNOR_00 1 # define BOOST_PP_BITNOR_01 0 # define BOOST_PP_BITNOR_10 0 # define BOOST_PP_BITNOR_11 0 # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/xor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000162411344301502031607 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_XOR_HPP # define BOOST_PREPROCESSOR_LOGICAL_XOR_HPP # # include # include # include # # /* BOOST_PP_XOR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_XOR(p, q) BOOST_PP_BITXOR(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # else # define BOOST_PP_XOR(p, q) BOOST_PP_XOR_I(p, q) # define BOOST_PP_XOR_I(p, q) BOOST_PP_BITXOR(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000260711344301502031611 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP # define BOOST_PREPROCESSOR_LOGICAL_BITAND_HPP # # include # # /* BOOST_PP_BITAND */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_BITAND(x, y) BOOST_PP_BITAND_I(x, y) # else # define BOOST_PP_BITAND(x, y) BOOST_PP_BITAND_OO((x, y)) # define BOOST_PP_BITAND_OO(par) BOOST_PP_BITAND_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ ## x ## y # else # define BOOST_PP_BITAND_I(x, y) BOOST_PP_BITAND_ID(BOOST_PP_BITAND_ ## x ## y) # define BOOST_PP_BITAND_ID(res) res # endif # # define BOOST_PP_BITAND_00 0 # define BOOST_PP_BITAND_01 0 # define BOOST_PP_BITAND_10 0 # define BOOST_PP_BITAND_11 1 # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000162411344301502031607 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_AND_HPP # define BOOST_PREPROCESSOR_LOGICAL_AND_HPP # # include # include # include # # /* BOOST_PP_AND */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_AND(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # else # define BOOST_PP_AND(p, q) BOOST_PP_AND_I(p, q) # define BOOST_PP_AND_I(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/not.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000154111344301502031605 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_NOT_HPP # define BOOST_PREPROCESSOR_LOGICAL_NOT_HPP # # include # include # include # # /* BOOST_PP_NOT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_NOT(x) BOOST_PP_COMPL(BOOST_PP_BOOL(x)) # else # define BOOST_PP_NOT(x) BOOST_PP_NOT_I(x) # define BOOST_PP_NOT_I(x) BOOST_PP_COMPL(BOOST_PP_BOOL(x)) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/nor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000162411344301502031607 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_NOR_HPP # define BOOST_PREPROCESSOR_LOGICAL_NOR_HPP # # include # include # include # # /* BOOST_PP_NOR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_NOR(p, q) BOOST_PP_BITNOR(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # else # define BOOST_PP_NOR(p, q) BOOST_PP_NOR_I(p, q) # define BOOST_PP_NOR_I(p, q) BOOST_PP_BITNOR(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000256211344301502031611 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_BITOR_HPP # define BOOST_PREPROCESSOR_LOGICAL_BITOR_HPP # # include # # /* BOOST_PP_BITOR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_BITOR(x, y) BOOST_PP_BITOR_I(x, y) # else # define BOOST_PP_BITOR(x, y) BOOST_PP_BITOR_OO((x, y)) # define BOOST_PP_BITOR_OO(par) BOOST_PP_BITOR_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_BITOR_I(x, y) BOOST_PP_BITOR_ ## x ## y # else # define BOOST_PP_BITOR_I(x, y) BOOST_PP_BITOR_ID(BOOST_PP_BITOR_ ## x ## y) # define BOOST_PP_BITOR_ID(id) id # endif # # define BOOST_PP_BITOR_00 0 # define BOOST_PP_BITOR_01 1 # define BOOST_PP_BITOR_10 1 # define BOOST_PP_BITOR_11 1 # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000161211344301502031604 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_OR_HPP # define BOOST_PREPROCESSOR_LOGICAL_OR_HPP # # include # include # include # # /* BOOST_PP_OR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_OR(p, q) BOOST_PP_BITOR(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # else # define BOOST_PP_OR(p, q) BOOST_PP_OR_I(p, q) # define BOOST_PP_OR_I(p, q) BOOST_PP_BITOR(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/bool.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000001773111344301502031615 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP # define BOOST_PREPROCESSOR_LOGICAL_BOOL_HPP # # include # # /* BOOST_PP_BOOL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_BOOL(x) BOOST_PP_BOOL_I(x) # else # define BOOST_PP_BOOL(x) BOOST_PP_BOOL_OO((x)) # define BOOST_PP_BOOL_OO(par) BOOST_PP_BOOL_I ## par # endif # # define BOOST_PP_BOOL_I(x) BOOST_PP_BOOL_ ## x # # define BOOST_PP_BOOL_0 0 # define BOOST_PP_BOOL_1 1 # define BOOST_PP_BOOL_2 1 # define BOOST_PP_BOOL_3 1 # define BOOST_PP_BOOL_4 1 # define BOOST_PP_BOOL_5 1 # define BOOST_PP_BOOL_6 1 # define BOOST_PP_BOOL_7 1 # define BOOST_PP_BOOL_8 1 # define BOOST_PP_BOOL_9 1 # define BOOST_PP_BOOL_10 1 # define BOOST_PP_BOOL_11 1 # define BOOST_PP_BOOL_12 1 # define BOOST_PP_BOOL_13 1 # define BOOST_PP_BOOL_14 1 # define BOOST_PP_BOOL_15 1 # define BOOST_PP_BOOL_16 1 # define BOOST_PP_BOOL_17 1 # define BOOST_PP_BOOL_18 1 # define BOOST_PP_BOOL_19 1 # define BOOST_PP_BOOL_20 1 # define BOOST_PP_BOOL_21 1 # define BOOST_PP_BOOL_22 1 # define BOOST_PP_BOOL_23 1 # define BOOST_PP_BOOL_24 1 # define BOOST_PP_BOOL_25 1 # define BOOST_PP_BOOL_26 1 # define BOOST_PP_BOOL_27 1 # define BOOST_PP_BOOL_28 1 # define BOOST_PP_BOOL_29 1 # define BOOST_PP_BOOL_30 1 # define BOOST_PP_BOOL_31 1 # define BOOST_PP_BOOL_32 1 # define BOOST_PP_BOOL_33 1 # define BOOST_PP_BOOL_34 1 # define BOOST_PP_BOOL_35 1 # define BOOST_PP_BOOL_36 1 # define BOOST_PP_BOOL_37 1 # define BOOST_PP_BOOL_38 1 # define BOOST_PP_BOOL_39 1 # define BOOST_PP_BOOL_40 1 # define BOOST_PP_BOOL_41 1 # define BOOST_PP_BOOL_42 1 # define BOOST_PP_BOOL_43 1 # define BOOST_PP_BOOL_44 1 # define BOOST_PP_BOOL_45 1 # define BOOST_PP_BOOL_46 1 # define BOOST_PP_BOOL_47 1 # define BOOST_PP_BOOL_48 1 # define BOOST_PP_BOOL_49 1 # define BOOST_PP_BOOL_50 1 # define BOOST_PP_BOOL_51 1 # define BOOST_PP_BOOL_52 1 # define BOOST_PP_BOOL_53 1 # define BOOST_PP_BOOL_54 1 # define BOOST_PP_BOOL_55 1 # define BOOST_PP_BOOL_56 1 # define BOOST_PP_BOOL_57 1 # define BOOST_PP_BOOL_58 1 # define BOOST_PP_BOOL_59 1 # define BOOST_PP_BOOL_60 1 # define BOOST_PP_BOOL_61 1 # define BOOST_PP_BOOL_62 1 # define BOOST_PP_BOOL_63 1 # define BOOST_PP_BOOL_64 1 # define BOOST_PP_BOOL_65 1 # define BOOST_PP_BOOL_66 1 # define BOOST_PP_BOOL_67 1 # define BOOST_PP_BOOL_68 1 # define BOOST_PP_BOOL_69 1 # define BOOST_PP_BOOL_70 1 # define BOOST_PP_BOOL_71 1 # define BOOST_PP_BOOL_72 1 # define BOOST_PP_BOOL_73 1 # define BOOST_PP_BOOL_74 1 # define BOOST_PP_BOOL_75 1 # define BOOST_PP_BOOL_76 1 # define BOOST_PP_BOOL_77 1 # define BOOST_PP_BOOL_78 1 # define BOOST_PP_BOOL_79 1 # define BOOST_PP_BOOL_80 1 # define BOOST_PP_BOOL_81 1 # define BOOST_PP_BOOL_82 1 # define BOOST_PP_BOOL_83 1 # define BOOST_PP_BOOL_84 1 # define BOOST_PP_BOOL_85 1 # define BOOST_PP_BOOL_86 1 # define BOOST_PP_BOOL_87 1 # define BOOST_PP_BOOL_88 1 # define BOOST_PP_BOOL_89 1 # define BOOST_PP_BOOL_90 1 # define BOOST_PP_BOOL_91 1 # define BOOST_PP_BOOL_92 1 # define BOOST_PP_BOOL_93 1 # define BOOST_PP_BOOL_94 1 # define BOOST_PP_BOOL_95 1 # define BOOST_PP_BOOL_96 1 # define BOOST_PP_BOOL_97 1 # define BOOST_PP_BOOL_98 1 # define BOOST_PP_BOOL_99 1 # define BOOST_PP_BOOL_100 1 # define BOOST_PP_BOOL_101 1 # define BOOST_PP_BOOL_102 1 # define BOOST_PP_BOOL_103 1 # define BOOST_PP_BOOL_104 1 # define BOOST_PP_BOOL_105 1 # define BOOST_PP_BOOL_106 1 # define BOOST_PP_BOOL_107 1 # define BOOST_PP_BOOL_108 1 # define BOOST_PP_BOOL_109 1 # define BOOST_PP_BOOL_110 1 # define BOOST_PP_BOOL_111 1 # define BOOST_PP_BOOL_112 1 # define BOOST_PP_BOOL_113 1 # define BOOST_PP_BOOL_114 1 # define BOOST_PP_BOOL_115 1 # define BOOST_PP_BOOL_116 1 # define BOOST_PP_BOOL_117 1 # define BOOST_PP_BOOL_118 1 # define BOOST_PP_BOOL_119 1 # define BOOST_PP_BOOL_120 1 # define BOOST_PP_BOOL_121 1 # define BOOST_PP_BOOL_122 1 # define BOOST_PP_BOOL_123 1 # define BOOST_PP_BOOL_124 1 # define BOOST_PP_BOOL_125 1 # define BOOST_PP_BOOL_126 1 # define BOOST_PP_BOOL_127 1 # define BOOST_PP_BOOL_128 1 # define BOOST_PP_BOOL_129 1 # define BOOST_PP_BOOL_130 1 # define BOOST_PP_BOOL_131 1 # define BOOST_PP_BOOL_132 1 # define BOOST_PP_BOOL_133 1 # define BOOST_PP_BOOL_134 1 # define BOOST_PP_BOOL_135 1 # define BOOST_PP_BOOL_136 1 # define BOOST_PP_BOOL_137 1 # define BOOST_PP_BOOL_138 1 # define BOOST_PP_BOOL_139 1 # define BOOST_PP_BOOL_140 1 # define BOOST_PP_BOOL_141 1 # define BOOST_PP_BOOL_142 1 # define BOOST_PP_BOOL_143 1 # define BOOST_PP_BOOL_144 1 # define BOOST_PP_BOOL_145 1 # define BOOST_PP_BOOL_146 1 # define BOOST_PP_BOOL_147 1 # define BOOST_PP_BOOL_148 1 # define BOOST_PP_BOOL_149 1 # define BOOST_PP_BOOL_150 1 # define BOOST_PP_BOOL_151 1 # define BOOST_PP_BOOL_152 1 # define BOOST_PP_BOOL_153 1 # define BOOST_PP_BOOL_154 1 # define BOOST_PP_BOOL_155 1 # define BOOST_PP_BOOL_156 1 # define BOOST_PP_BOOL_157 1 # define BOOST_PP_BOOL_158 1 # define BOOST_PP_BOOL_159 1 # define BOOST_PP_BOOL_160 1 # define BOOST_PP_BOOL_161 1 # define BOOST_PP_BOOL_162 1 # define BOOST_PP_BOOL_163 1 # define BOOST_PP_BOOL_164 1 # define BOOST_PP_BOOL_165 1 # define BOOST_PP_BOOL_166 1 # define BOOST_PP_BOOL_167 1 # define BOOST_PP_BOOL_168 1 # define BOOST_PP_BOOL_169 1 # define BOOST_PP_BOOL_170 1 # define BOOST_PP_BOOL_171 1 # define BOOST_PP_BOOL_172 1 # define BOOST_PP_BOOL_173 1 # define BOOST_PP_BOOL_174 1 # define BOOST_PP_BOOL_175 1 # define BOOST_PP_BOOL_176 1 # define BOOST_PP_BOOL_177 1 # define BOOST_PP_BOOL_178 1 # define BOOST_PP_BOOL_179 1 # define BOOST_PP_BOOL_180 1 # define BOOST_PP_BOOL_181 1 # define BOOST_PP_BOOL_182 1 # define BOOST_PP_BOOL_183 1 # define BOOST_PP_BOOL_184 1 # define BOOST_PP_BOOL_185 1 # define BOOST_PP_BOOL_186 1 # define BOOST_PP_BOOL_187 1 # define BOOST_PP_BOOL_188 1 # define BOOST_PP_BOOL_189 1 # define BOOST_PP_BOOL_190 1 # define BOOST_PP_BOOL_191 1 # define BOOST_PP_BOOL_192 1 # define BOOST_PP_BOOL_193 1 # define BOOST_PP_BOOL_194 1 # define BOOST_PP_BOOL_195 1 # define BOOST_PP_BOOL_196 1 # define BOOST_PP_BOOL_197 1 # define BOOST_PP_BOOL_198 1 # define BOOST_PP_BOOL_199 1 # define BOOST_PP_BOOL_200 1 # define BOOST_PP_BOOL_201 1 # define BOOST_PP_BOOL_202 1 # define BOOST_PP_BOOL_203 1 # define BOOST_PP_BOOL_204 1 # define BOOST_PP_BOOL_205 1 # define BOOST_PP_BOOL_206 1 # define BOOST_PP_BOOL_207 1 # define BOOST_PP_BOOL_208 1 # define BOOST_PP_BOOL_209 1 # define BOOST_PP_BOOL_210 1 # define BOOST_PP_BOOL_211 1 # define BOOST_PP_BOOL_212 1 # define BOOST_PP_BOOL_213 1 # define BOOST_PP_BOOL_214 1 # define BOOST_PP_BOOL_215 1 # define BOOST_PP_BOOL_216 1 # define BOOST_PP_BOOL_217 1 # define BOOST_PP_BOOL_218 1 # define BOOST_PP_BOOL_219 1 # define BOOST_PP_BOOL_220 1 # define BOOST_PP_BOOL_221 1 # define BOOST_PP_BOOL_222 1 # define BOOST_PP_BOOL_223 1 # define BOOST_PP_BOOL_224 1 # define BOOST_PP_BOOL_225 1 # define BOOST_PP_BOOL_226 1 # define BOOST_PP_BOOL_227 1 # define BOOST_PP_BOOL_228 1 # define BOOST_PP_BOOL_229 1 # define BOOST_PP_BOOL_230 1 # define BOOST_PP_BOOL_231 1 # define BOOST_PP_BOOL_232 1 # define BOOST_PP_BOOL_233 1 # define BOOST_PP_BOOL_234 1 # define BOOST_PP_BOOL_235 1 # define BOOST_PP_BOOL_236 1 # define BOOST_PP_BOOL_237 1 # define BOOST_PP_BOOL_238 1 # define BOOST_PP_BOOL_239 1 # define BOOST_PP_BOOL_240 1 # define BOOST_PP_BOOL_241 1 # define BOOST_PP_BOOL_242 1 # define BOOST_PP_BOOL_243 1 # define BOOST_PP_BOOL_244 1 # define BOOST_PP_BOOL_245 1 # define BOOST_PP_BOOL_246 1 # define BOOST_PP_BOOL_247 1 # define BOOST_PP_BOOL_248 1 # define BOOST_PP_BOOL_249 1 # define BOOST_PP_BOOL_250 1 # define BOOST_PP_BOOL_251 1 # define BOOST_PP_BOOL_252 1 # define BOOST_PP_BOOL_253 1 # define BOOST_PP_BOOL_254 1 # define BOOST_PP_BOOL_255 1 # define BOOST_PP_BOOL_256 1 # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/compl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000243211344301502031605 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP # define BOOST_PREPROCESSOR_LOGICAL_COMPL_HPP # # include # # /* BOOST_PP_COMPL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_COMPL(x) BOOST_PP_COMPL_I(x) # else # define BOOST_PP_COMPL(x) BOOST_PP_COMPL_OO((x)) # define BOOST_PP_COMPL_OO(par) BOOST_PP_COMPL_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ ## x # else # define BOOST_PP_COMPL_I(x) BOOST_PP_COMPL_ID(BOOST_PP_COMPL_ ## x) # define BOOST_PP_COMPL_ID(id) id # endif # # define BOOST_PP_COMPL_0 1 # define BOOST_PP_COMPL_1 0 # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/logical/0000644000175000017500000000260511344301502031607 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LOGICAL_BITXOR_HPP # define BOOST_PREPROCESSOR_LOGICAL_BITXOR_HPP # # include # # /* BOOST_PP_BITXOR */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_BITXOR(x, y) BOOST_PP_BITXOR_I(x, y) # else # define BOOST_PP_BITXOR(x, y) BOOST_PP_BITXOR_OO((x, y)) # define BOOST_PP_BITXOR_OO(par) BOOST_PP_BITXOR_I ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_BITXOR_I(x, y) BOOST_PP_BITXOR_ ## x ## y # else # define BOOST_PP_BITXOR_I(x, y) BOOST_PP_BITXOR_ID(BOOST_PP_BITXOR_ ## x ## y) # define BOOST_PP_BITXOR_ID(id) id # endif # # define BOOST_PP_BITXOR_00 0 # define BOOST_PP_BITXOR_01 1 # define BOOST_PP_BITXOR_10 1 # define BOOST_PP_BITXOR_11 0 # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/0000755000175000017500000000000012146213771030773 5ustar debiandebian././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/reverse.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/reve0000644000175000017500000000327111344301502031647 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_REVERSE_HPP # define BOOST_PREPROCESSOR_SEQ_REVERSE_HPP # # include # include # include # # /* BOOST_PP_SEQ_REVERSE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_REVERSE(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)() # else # define BOOST_PP_SEQ_REVERSE(seq) BOOST_PP_SEQ_REVERSE_I(seq) # define BOOST_PP_SEQ_REVERSE_I(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)() # endif # # define BOOST_PP_SEQ_REVERSE_O(s, state, elem) (elem) state # # /* BOOST_PP_SEQ_REVERSE_S */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_REVERSE_S(s, seq) BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)() # else # define BOOST_PP_SEQ_REVERSE_S(s, seq) BOOST_PP_SEQ_REVERSE_S_I(s, seq) # define BOOST_PP_SEQ_REVERSE_S_I(s, seq) BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_REVERSE_O, BOOST_PP_EMPTY, seq)() # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/to_tuple.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/to_t0000644000175000017500000000211211344301502031644 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_TO_TUPLE_HPP # define BOOST_PREPROCESSOR_SEQ_TO_TUPLE_HPP # # include # include # # /* BOOST_PP_SEQ_TO_TUPLE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_TO_TUPLE(seq) (BOOST_PP_SEQ_ENUM(seq)) # else # define BOOST_PP_SEQ_TO_TUPLE(seq) BOOST_PP_SEQ_TO_TUPLE_I(seq) # define BOOST_PP_SEQ_TO_TUPLE_I(seq) (BOOST_PP_SEQ_ENUM(seq)) # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/pop_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/pop_0000644000175000017500000000237111344301502031643 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_POP_BACK_HPP # define BOOST_PREPROCESSOR_SEQ_POP_BACK_HPP # # include # include # include # include # # /* BOOST_PP_SEQ_POP_BACK */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_POP_BACK(seq) BOOST_PP_SEQ_FIRST_N(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)), seq) # else # define BOOST_PP_SEQ_POP_BACK(seq) BOOST_PP_SEQ_POP_BACK_I(seq) # define BOOST_PP_SEQ_POP_BACK_I(seq) BOOST_PP_SEQ_FIRST_N(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(seq)), seq) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/for_each_i.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/for_0000644000175000017500000000643011344301502031633 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FOR_EACH_I_HPP # define BOOST_PREPROCESSOR_SEQ_FOR_EACH_I_HPP # # include # include # include # include # include # include # include # include # # /* BOOST_PP_SEQ_FOR_EACH_I */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FOR_EACH_I(macro, data, seq) BOOST_PP_FOR((macro, data, seq (nil), 0), BOOST_PP_SEQ_FOR_EACH_I_P, BOOST_PP_SEQ_FOR_EACH_I_O, BOOST_PP_SEQ_FOR_EACH_I_M) # else # define BOOST_PP_SEQ_FOR_EACH_I(macro, data, seq) BOOST_PP_SEQ_FOR_EACH_I_I(macro, data, seq) # define BOOST_PP_SEQ_FOR_EACH_I_I(macro, data, seq) BOOST_PP_FOR((macro, data, seq (nil), 0), BOOST_PP_SEQ_FOR_EACH_I_P, BOOST_PP_SEQ_FOR_EACH_I_O, BOOST_PP_SEQ_FOR_EACH_I_M) # endif # # define BOOST_PP_SEQ_FOR_EACH_I_P(r, x) BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(4, 2, x))) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_FOR_EACH_I_O(r, x) BOOST_PP_SEQ_FOR_EACH_I_O_I x # else # define BOOST_PP_SEQ_FOR_EACH_I_O(r, x) BOOST_PP_SEQ_FOR_EACH_I_O_I(BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_TUPLE_ELEM(4, 2, x), BOOST_PP_TUPLE_ELEM(4, 3, x)) # endif # # define BOOST_PP_SEQ_FOR_EACH_I_O_I(macro, data, seq, i) (macro, data, BOOST_PP_SEQ_TAIL(seq), BOOST_PP_INC(i)) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_FOR_EACH_I_M(r, x) BOOST_PP_SEQ_FOR_EACH_I_M_IM(r, BOOST_PP_TUPLE_REM_4 x) # define BOOST_PP_SEQ_FOR_EACH_I_M_IM(r, im) BOOST_PP_SEQ_FOR_EACH_I_M_I(r, im) # else # define BOOST_PP_SEQ_FOR_EACH_I_M(r, x) BOOST_PP_SEQ_FOR_EACH_I_M_I(r, BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_TUPLE_ELEM(4, 2, x), BOOST_PP_TUPLE_ELEM(4, 3, x)) # endif # # define BOOST_PP_SEQ_FOR_EACH_I_M_I(r, macro, data, seq, i) macro(r, data, i, BOOST_PP_SEQ_HEAD(seq)) # # /* BOOST_PP_SEQ_FOR_EACH_I_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FOR_EACH_I_R(r, macro, data, seq) BOOST_PP_FOR_ ## r((macro, data, seq (nil), 0), BOOST_PP_SEQ_FOR_EACH_I_P, BOOST_PP_SEQ_FOR_EACH_I_O, BOOST_PP_SEQ_FOR_EACH_I_M) # else # define BOOST_PP_SEQ_FOR_EACH_I_R(r, macro, data, seq) BOOST_PP_SEQ_FOR_EACH_I_R_I(r, macro, data, seq) # define BOOST_PP_SEQ_FOR_EACH_I_R_I(r, macro, data, seq) BOOST_PP_FOR_ ## r((macro, data, seq (nil), 0), BOOST_PP_SEQ_FOR_EACH_I_P, BOOST_PP_SEQ_FOR_EACH_I_O, BOOST_PP_SEQ_FOR_EACH_I_M) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/push_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/push0000644000175000017500000000143411344301502031664 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_PUSH_FRONT_HPP # define BOOST_PREPROCESSOR_SEQ_PUSH_FRONT_HPP # # /* BOOST_PP_SEQ_PUSH_FRONT */ # # define BOOST_PP_SEQ_PUSH_FRONT(seq, elem) (elem)seq # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/seq.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/seq.0000644000175000017500000000321011344301502031545 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_SEQ_HPP # define BOOST_PREPROCESSOR_SEQ_SEQ_HPP # # include # include # # /* BOOST_PP_SEQ_HEAD */ # # define BOOST_PP_SEQ_HEAD(seq) BOOST_PP_SEQ_ELEM(0, seq) # # /* BOOST_PP_SEQ_TAIL */ # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_TAIL(seq) BOOST_PP_SEQ_TAIL_1((seq)) # define BOOST_PP_SEQ_TAIL_1(par) BOOST_PP_SEQ_TAIL_2 ## par # define BOOST_PP_SEQ_TAIL_2(seq) BOOST_PP_SEQ_TAIL_I ## seq # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_SEQ_TAIL(seq) BOOST_PP_SEQ_TAIL_ID(BOOST_PP_SEQ_TAIL_I seq) # define BOOST_PP_SEQ_TAIL_ID(id) id # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_TAIL(seq) BOOST_PP_SEQ_TAIL_D(seq) # define BOOST_PP_SEQ_TAIL_D(seq) BOOST_PP_SEQ_TAIL_I seq # else # define BOOST_PP_SEQ_TAIL(seq) BOOST_PP_SEQ_TAIL_I seq # endif # # define BOOST_PP_SEQ_TAIL_I(x) # # /* BOOST_PP_SEQ_NIL */ # # define BOOST_PP_SEQ_NIL(x) (x) # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/cat.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/cat.0000644000175000017500000000341211344301502031530 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_CAT_HPP # define BOOST_PREPROCESSOR_SEQ_CAT_HPP # # include # include # include # # /* BOOST_PP_SEQ_CAT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_CAT(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_CAT_O, BOOST_PP_SEQ_HEAD(seq), BOOST_PP_SEQ_TAIL(seq)) # else # define BOOST_PP_SEQ_CAT(seq) BOOST_PP_SEQ_CAT_I(seq) # define BOOST_PP_SEQ_CAT_I(seq) BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_CAT_O, BOOST_PP_SEQ_HEAD(seq), BOOST_PP_SEQ_TAIL(seq)) # endif # # define BOOST_PP_SEQ_CAT_O(s, st, elem) BOOST_PP_SEQ_CAT_O_I(st, elem) # define BOOST_PP_SEQ_CAT_O_I(a, b) a ## b # # /* BOOST_PP_SEQ_CAT_S */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_CAT_S(s, seq) BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_CAT_O, BOOST_PP_SEQ_HEAD(seq), BOOST_PP_SEQ_TAIL(seq)) # else # define BOOST_PP_SEQ_CAT_S(s, seq) BOOST_PP_SEQ_CAT_S_I(s, seq) # define BOOST_PP_SEQ_CAT_S_I(s, seq) BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_CAT_O, BOOST_PP_SEQ_HEAD(seq), BOOST_PP_SEQ_TAIL(seq)) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/push_back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/push0000644000175000017500000000143011344301502031660 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_PUSH_BACK_HPP # define BOOST_PREPROCESSOR_SEQ_PUSH_BACK_HPP # # /* BOOST_PP_SEQ_PUSH_BACK */ # # define BOOST_PP_SEQ_PUSH_BACK(seq, elem) seq(elem) # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/filter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/filt0000644000175000017500000000550111344301502031642 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FILTER_HPP # define BOOST_PREPROCESSOR_SEQ_FILTER_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_SEQ_FILTER */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FILTER(pred, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_FILTER_O, (pred, data, (nil)), seq))) # else # define BOOST_PP_SEQ_FILTER(pred, data, seq) BOOST_PP_SEQ_FILTER_I(pred, data, seq) # define BOOST_PP_SEQ_FILTER_I(pred, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_FILTER_O, (pred, data, (nil)), seq))) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_FILTER_O(s, st, elem) BOOST_PP_SEQ_FILTER_O_IM(s, BOOST_PP_TUPLE_REM_3 st, elem) # define BOOST_PP_SEQ_FILTER_O_IM(s, im, elem) BOOST_PP_SEQ_FILTER_O_I(s, im, elem) # else # define BOOST_PP_SEQ_FILTER_O(s, st, elem) BOOST_PP_SEQ_FILTER_O_I(s, BOOST_PP_TUPLE_ELEM(3, 0, st), BOOST_PP_TUPLE_ELEM(3, 1, st), BOOST_PP_TUPLE_ELEM(3, 2, st), elem) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_SEQ_FILTER_O_I(s, pred, data, res, elem) (pred, data, res BOOST_PP_EXPR_IF(pred(s, data, elem), (elem))) # else # define BOOST_PP_SEQ_FILTER_O_I(s, pred, data, res, elem) (pred, data, res BOOST_PP_EXPR_IF(pred##(s, data, elem), (elem))) # endif # # /* BOOST_PP_SEQ_FILTER_S */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FILTER_S(s, pred, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_FILTER_O, (pred, data, (nil)), seq))) # else # define BOOST_PP_SEQ_FILTER_S(s, pred, data, seq) BOOST_PP_SEQ_FILTER_S_I(s, pred, data, seq) # define BOOST_PP_SEQ_FILTER_S_I(s, pred, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_FILTER_O, (pred, data, (nil)), seq))) # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/for_each.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/for_0000644000175000017500000000607211344301502031635 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FOR_EACH_HPP # define BOOST_PREPROCESSOR_SEQ_FOR_EACH_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_SEQ_FOR_EACH */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FOR_EACH(macro, data, seq) BOOST_PP_FOR((macro, data, seq (nil)), BOOST_PP_SEQ_FOR_EACH_P, BOOST_PP_SEQ_FOR_EACH_O, BOOST_PP_SEQ_FOR_EACH_M) # else # define BOOST_PP_SEQ_FOR_EACH(macro, data, seq) BOOST_PP_SEQ_FOR_EACH_D(macro, data, seq) # define BOOST_PP_SEQ_FOR_EACH_D(macro, data, seq) BOOST_PP_FOR((macro, data, seq (nil)), BOOST_PP_SEQ_FOR_EACH_P, BOOST_PP_SEQ_FOR_EACH_O, BOOST_PP_SEQ_FOR_EACH_M) # endif # # define BOOST_PP_SEQ_FOR_EACH_P(r, x) BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(3, 2, x))) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_FOR_EACH_O(r, x) BOOST_PP_SEQ_FOR_EACH_O_I x # else # define BOOST_PP_SEQ_FOR_EACH_O(r, x) BOOST_PP_SEQ_FOR_EACH_O_I(BOOST_PP_TUPLE_ELEM(3, 0, x), BOOST_PP_TUPLE_ELEM(3, 1, x), BOOST_PP_TUPLE_ELEM(3, 2, x)) # endif # # define BOOST_PP_SEQ_FOR_EACH_O_I(macro, data, seq) (macro, data, BOOST_PP_SEQ_TAIL(seq)) # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_FOR_EACH_M(r, x) BOOST_PP_SEQ_FOR_EACH_M_IM(r, BOOST_PP_TUPLE_REM_3 x) # define BOOST_PP_SEQ_FOR_EACH_M_IM(r, im) BOOST_PP_SEQ_FOR_EACH_M_I(r, im) # else # define BOOST_PP_SEQ_FOR_EACH_M(r, x) BOOST_PP_SEQ_FOR_EACH_M_I(r, BOOST_PP_TUPLE_ELEM(3, 0, x), BOOST_PP_TUPLE_ELEM(3, 1, x), BOOST_PP_TUPLE_ELEM(3, 2, x)) # endif # # define BOOST_PP_SEQ_FOR_EACH_M_I(r, macro, data, seq) macro(r, data, BOOST_PP_SEQ_HEAD(seq)) # # /* BOOST_PP_SEQ_FOR_EACH_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FOR_EACH_R(r, macro, data, seq) BOOST_PP_FOR_ ## r((macro, data, seq (nil)), BOOST_PP_SEQ_FOR_EACH_P, BOOST_PP_SEQ_FOR_EACH_O, BOOST_PP_SEQ_FOR_EACH_M) # else # define BOOST_PP_SEQ_FOR_EACH_R(r, macro, data, seq) BOOST_PP_SEQ_FOR_EACH_R_I(r, macro, data, seq) # define BOOST_PP_SEQ_FOR_EACH_R_I(r, macro, data, seq) BOOST_PP_FOR_ ## r((macro, data, seq (nil)), BOOST_PP_SEQ_FOR_EACH_P, BOOST_PP_SEQ_FOR_EACH_O, BOOST_PP_SEQ_FOR_EACH_M) # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/fold_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/fold0000644000175000017500000011063211344301502031632 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FOLD_RIGHT_HPP # define BOOST_PREPROCESSOR_SEQ_FOLD_RIGHT_HPP # # include # include # include # include # include # # /* BOOST_PP_SEQ_FOLD_RIGHT */ # # if 0 # define BOOST_PP_SEQ_FOLD_RIGHT(op, state, seq) ... # endif # # define BOOST_PP_SEQ_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_SEQ_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_SEQ_FOLD_LEFT_P, 256)) # # define BOOST_PP_SEQ_FOLD_RIGHT_257(op, st, ss) BOOST_PP_ERROR(0x0005) # # define BOOST_PP_SEQ_FOLD_RIGHT_1(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_1(op, st, BOOST_PP_SEQ_REVERSE_S(2, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_2(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_2(op, st, BOOST_PP_SEQ_REVERSE_S(3, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_3(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_3(op, st, BOOST_PP_SEQ_REVERSE_S(4, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_4(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_4(op, st, BOOST_PP_SEQ_REVERSE_S(5, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_5(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_5(op, st, BOOST_PP_SEQ_REVERSE_S(6, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_6(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_6(op, st, BOOST_PP_SEQ_REVERSE_S(7, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_7(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_7(op, st, BOOST_PP_SEQ_REVERSE_S(8, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_8(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_8(op, st, BOOST_PP_SEQ_REVERSE_S(9, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_9(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_9(op, st, BOOST_PP_SEQ_REVERSE_S(10, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_10(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_10(op, st, BOOST_PP_SEQ_REVERSE_S(11, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_11(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_11(op, st, BOOST_PP_SEQ_REVERSE_S(12, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_12(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_12(op, st, BOOST_PP_SEQ_REVERSE_S(13, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_13(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_13(op, st, BOOST_PP_SEQ_REVERSE_S(14, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_14(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_14(op, st, BOOST_PP_SEQ_REVERSE_S(15, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_15(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_15(op, st, BOOST_PP_SEQ_REVERSE_S(16, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_16(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_16(op, st, BOOST_PP_SEQ_REVERSE_S(17, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_17(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_17(op, st, BOOST_PP_SEQ_REVERSE_S(18, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_18(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_18(op, st, BOOST_PP_SEQ_REVERSE_S(19, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_19(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_19(op, st, BOOST_PP_SEQ_REVERSE_S(20, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_20(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_20(op, st, BOOST_PP_SEQ_REVERSE_S(21, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_21(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_21(op, st, BOOST_PP_SEQ_REVERSE_S(22, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_22(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_22(op, st, BOOST_PP_SEQ_REVERSE_S(23, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_23(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_23(op, st, BOOST_PP_SEQ_REVERSE_S(24, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_24(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_24(op, st, BOOST_PP_SEQ_REVERSE_S(25, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_25(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_25(op, st, BOOST_PP_SEQ_REVERSE_S(26, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_26(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_26(op, st, BOOST_PP_SEQ_REVERSE_S(27, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_27(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_27(op, st, BOOST_PP_SEQ_REVERSE_S(28, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_28(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_28(op, st, BOOST_PP_SEQ_REVERSE_S(29, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_29(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_29(op, st, BOOST_PP_SEQ_REVERSE_S(30, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_30(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_30(op, st, BOOST_PP_SEQ_REVERSE_S(31, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_31(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_31(op, st, BOOST_PP_SEQ_REVERSE_S(32, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_32(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_32(op, st, BOOST_PP_SEQ_REVERSE_S(33, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_33(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_33(op, st, BOOST_PP_SEQ_REVERSE_S(34, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_34(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_34(op, st, BOOST_PP_SEQ_REVERSE_S(35, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_35(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_35(op, st, BOOST_PP_SEQ_REVERSE_S(36, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_36(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_36(op, st, BOOST_PP_SEQ_REVERSE_S(37, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_37(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_37(op, st, BOOST_PP_SEQ_REVERSE_S(38, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_38(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_38(op, st, BOOST_PP_SEQ_REVERSE_S(39, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_39(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_39(op, st, BOOST_PP_SEQ_REVERSE_S(40, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_40(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_40(op, st, BOOST_PP_SEQ_REVERSE_S(41, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_41(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_41(op, st, BOOST_PP_SEQ_REVERSE_S(42, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_42(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_42(op, st, BOOST_PP_SEQ_REVERSE_S(43, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_43(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_43(op, st, BOOST_PP_SEQ_REVERSE_S(44, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_44(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_44(op, st, BOOST_PP_SEQ_REVERSE_S(45, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_45(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_45(op, st, BOOST_PP_SEQ_REVERSE_S(46, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_46(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_46(op, st, BOOST_PP_SEQ_REVERSE_S(47, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_47(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_47(op, st, BOOST_PP_SEQ_REVERSE_S(48, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_48(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_48(op, st, BOOST_PP_SEQ_REVERSE_S(49, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_49(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_49(op, st, BOOST_PP_SEQ_REVERSE_S(50, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_50(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_50(op, st, BOOST_PP_SEQ_REVERSE_S(51, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_51(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_51(op, st, BOOST_PP_SEQ_REVERSE_S(52, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_52(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_52(op, st, BOOST_PP_SEQ_REVERSE_S(53, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_53(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_53(op, st, BOOST_PP_SEQ_REVERSE_S(54, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_54(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_54(op, st, BOOST_PP_SEQ_REVERSE_S(55, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_55(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_55(op, st, BOOST_PP_SEQ_REVERSE_S(56, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_56(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_56(op, st, BOOST_PP_SEQ_REVERSE_S(57, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_57(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_57(op, st, BOOST_PP_SEQ_REVERSE_S(58, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_58(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_58(op, st, BOOST_PP_SEQ_REVERSE_S(59, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_59(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_59(op, st, BOOST_PP_SEQ_REVERSE_S(60, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_60(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_60(op, st, BOOST_PP_SEQ_REVERSE_S(61, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_61(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_61(op, st, BOOST_PP_SEQ_REVERSE_S(62, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_62(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_62(op, st, BOOST_PP_SEQ_REVERSE_S(63, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_63(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_63(op, st, BOOST_PP_SEQ_REVERSE_S(64, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_64(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_64(op, st, BOOST_PP_SEQ_REVERSE_S(65, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_65(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_65(op, st, BOOST_PP_SEQ_REVERSE_S(66, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_66(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_66(op, st, BOOST_PP_SEQ_REVERSE_S(67, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_67(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_67(op, st, BOOST_PP_SEQ_REVERSE_S(68, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_68(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_68(op, st, BOOST_PP_SEQ_REVERSE_S(69, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_69(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_69(op, st, BOOST_PP_SEQ_REVERSE_S(70, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_70(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_70(op, st, BOOST_PP_SEQ_REVERSE_S(71, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_71(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_71(op, st, BOOST_PP_SEQ_REVERSE_S(72, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_72(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_72(op, st, BOOST_PP_SEQ_REVERSE_S(73, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_73(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_73(op, st, BOOST_PP_SEQ_REVERSE_S(74, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_74(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_74(op, st, BOOST_PP_SEQ_REVERSE_S(75, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_75(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_75(op, st, BOOST_PP_SEQ_REVERSE_S(76, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_76(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_76(op, st, BOOST_PP_SEQ_REVERSE_S(77, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_77(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_77(op, st, BOOST_PP_SEQ_REVERSE_S(78, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_78(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_78(op, st, BOOST_PP_SEQ_REVERSE_S(79, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_79(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_79(op, st, BOOST_PP_SEQ_REVERSE_S(80, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_80(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_80(op, st, BOOST_PP_SEQ_REVERSE_S(81, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_81(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_81(op, st, BOOST_PP_SEQ_REVERSE_S(82, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_82(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_82(op, st, BOOST_PP_SEQ_REVERSE_S(83, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_83(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_83(op, st, BOOST_PP_SEQ_REVERSE_S(84, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_84(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_84(op, st, BOOST_PP_SEQ_REVERSE_S(85, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_85(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_85(op, st, BOOST_PP_SEQ_REVERSE_S(86, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_86(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_86(op, st, BOOST_PP_SEQ_REVERSE_S(87, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_87(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_87(op, st, BOOST_PP_SEQ_REVERSE_S(88, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_88(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_88(op, st, BOOST_PP_SEQ_REVERSE_S(89, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_89(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_89(op, st, BOOST_PP_SEQ_REVERSE_S(90, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_90(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_90(op, st, BOOST_PP_SEQ_REVERSE_S(91, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_91(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_91(op, st, BOOST_PP_SEQ_REVERSE_S(92, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_92(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_92(op, st, BOOST_PP_SEQ_REVERSE_S(93, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_93(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_93(op, st, BOOST_PP_SEQ_REVERSE_S(94, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_94(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_94(op, st, BOOST_PP_SEQ_REVERSE_S(95, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_95(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_95(op, st, BOOST_PP_SEQ_REVERSE_S(96, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_96(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_96(op, st, BOOST_PP_SEQ_REVERSE_S(97, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_97(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_97(op, st, BOOST_PP_SEQ_REVERSE_S(98, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_98(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_98(op, st, BOOST_PP_SEQ_REVERSE_S(99, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_99(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_99(op, st, BOOST_PP_SEQ_REVERSE_S(100, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_100(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_100(op, st, BOOST_PP_SEQ_REVERSE_S(101, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_101(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_101(op, st, BOOST_PP_SEQ_REVERSE_S(102, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_102(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_102(op, st, BOOST_PP_SEQ_REVERSE_S(103, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_103(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_103(op, st, BOOST_PP_SEQ_REVERSE_S(104, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_104(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_104(op, st, BOOST_PP_SEQ_REVERSE_S(105, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_105(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_105(op, st, BOOST_PP_SEQ_REVERSE_S(106, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_106(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_106(op, st, BOOST_PP_SEQ_REVERSE_S(107, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_107(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_107(op, st, BOOST_PP_SEQ_REVERSE_S(108, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_108(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_108(op, st, BOOST_PP_SEQ_REVERSE_S(109, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_109(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_109(op, st, BOOST_PP_SEQ_REVERSE_S(110, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_110(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_110(op, st, BOOST_PP_SEQ_REVERSE_S(111, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_111(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_111(op, st, BOOST_PP_SEQ_REVERSE_S(112, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_112(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_112(op, st, BOOST_PP_SEQ_REVERSE_S(113, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_113(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_113(op, st, BOOST_PP_SEQ_REVERSE_S(114, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_114(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_114(op, st, BOOST_PP_SEQ_REVERSE_S(115, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_115(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_115(op, st, BOOST_PP_SEQ_REVERSE_S(116, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_116(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_116(op, st, BOOST_PP_SEQ_REVERSE_S(117, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_117(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_117(op, st, BOOST_PP_SEQ_REVERSE_S(118, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_118(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_118(op, st, BOOST_PP_SEQ_REVERSE_S(119, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_119(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_119(op, st, BOOST_PP_SEQ_REVERSE_S(120, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_120(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_120(op, st, BOOST_PP_SEQ_REVERSE_S(121, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_121(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_121(op, st, BOOST_PP_SEQ_REVERSE_S(122, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_122(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_122(op, st, BOOST_PP_SEQ_REVERSE_S(123, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_123(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_123(op, st, BOOST_PP_SEQ_REVERSE_S(124, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_124(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_124(op, st, BOOST_PP_SEQ_REVERSE_S(125, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_125(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_125(op, st, BOOST_PP_SEQ_REVERSE_S(126, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_126(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_126(op, st, BOOST_PP_SEQ_REVERSE_S(127, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_127(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_127(op, st, BOOST_PP_SEQ_REVERSE_S(128, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_128(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_128(op, st, BOOST_PP_SEQ_REVERSE_S(129, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_129(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_129(op, st, BOOST_PP_SEQ_REVERSE_S(130, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_130(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_130(op, st, BOOST_PP_SEQ_REVERSE_S(131, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_131(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_131(op, st, BOOST_PP_SEQ_REVERSE_S(132, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_132(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_132(op, st, BOOST_PP_SEQ_REVERSE_S(133, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_133(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_133(op, st, BOOST_PP_SEQ_REVERSE_S(134, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_134(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_134(op, st, BOOST_PP_SEQ_REVERSE_S(135, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_135(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_135(op, st, BOOST_PP_SEQ_REVERSE_S(136, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_136(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_136(op, st, BOOST_PP_SEQ_REVERSE_S(137, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_137(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_137(op, st, BOOST_PP_SEQ_REVERSE_S(138, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_138(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_138(op, st, BOOST_PP_SEQ_REVERSE_S(139, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_139(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_139(op, st, BOOST_PP_SEQ_REVERSE_S(140, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_140(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_140(op, st, BOOST_PP_SEQ_REVERSE_S(141, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_141(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_141(op, st, BOOST_PP_SEQ_REVERSE_S(142, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_142(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_142(op, st, BOOST_PP_SEQ_REVERSE_S(143, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_143(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_143(op, st, BOOST_PP_SEQ_REVERSE_S(144, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_144(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_144(op, st, BOOST_PP_SEQ_REVERSE_S(145, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_145(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_145(op, st, BOOST_PP_SEQ_REVERSE_S(146, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_146(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_146(op, st, BOOST_PP_SEQ_REVERSE_S(147, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_147(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_147(op, st, BOOST_PP_SEQ_REVERSE_S(148, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_148(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_148(op, st, BOOST_PP_SEQ_REVERSE_S(149, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_149(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_149(op, st, BOOST_PP_SEQ_REVERSE_S(150, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_150(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_150(op, st, BOOST_PP_SEQ_REVERSE_S(151, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_151(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_151(op, st, BOOST_PP_SEQ_REVERSE_S(152, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_152(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_152(op, st, BOOST_PP_SEQ_REVERSE_S(153, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_153(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_153(op, st, BOOST_PP_SEQ_REVERSE_S(154, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_154(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_154(op, st, BOOST_PP_SEQ_REVERSE_S(155, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_155(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_155(op, st, BOOST_PP_SEQ_REVERSE_S(156, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_156(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_156(op, st, BOOST_PP_SEQ_REVERSE_S(157, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_157(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_157(op, st, BOOST_PP_SEQ_REVERSE_S(158, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_158(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_158(op, st, BOOST_PP_SEQ_REVERSE_S(159, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_159(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_159(op, st, BOOST_PP_SEQ_REVERSE_S(160, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_160(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_160(op, st, BOOST_PP_SEQ_REVERSE_S(161, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_161(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_161(op, st, BOOST_PP_SEQ_REVERSE_S(162, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_162(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_162(op, st, BOOST_PP_SEQ_REVERSE_S(163, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_163(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_163(op, st, BOOST_PP_SEQ_REVERSE_S(164, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_164(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_164(op, st, BOOST_PP_SEQ_REVERSE_S(165, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_165(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_165(op, st, BOOST_PP_SEQ_REVERSE_S(166, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_166(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_166(op, st, BOOST_PP_SEQ_REVERSE_S(167, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_167(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_167(op, st, BOOST_PP_SEQ_REVERSE_S(168, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_168(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_168(op, st, BOOST_PP_SEQ_REVERSE_S(169, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_169(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_169(op, st, BOOST_PP_SEQ_REVERSE_S(170, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_170(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_170(op, st, BOOST_PP_SEQ_REVERSE_S(171, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_171(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_171(op, st, BOOST_PP_SEQ_REVERSE_S(172, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_172(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_172(op, st, BOOST_PP_SEQ_REVERSE_S(173, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_173(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_173(op, st, BOOST_PP_SEQ_REVERSE_S(174, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_174(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_174(op, st, BOOST_PP_SEQ_REVERSE_S(175, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_175(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_175(op, st, BOOST_PP_SEQ_REVERSE_S(176, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_176(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_176(op, st, BOOST_PP_SEQ_REVERSE_S(177, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_177(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_177(op, st, BOOST_PP_SEQ_REVERSE_S(178, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_178(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_178(op, st, BOOST_PP_SEQ_REVERSE_S(179, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_179(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_179(op, st, BOOST_PP_SEQ_REVERSE_S(180, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_180(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_180(op, st, BOOST_PP_SEQ_REVERSE_S(181, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_181(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_181(op, st, BOOST_PP_SEQ_REVERSE_S(182, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_182(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_182(op, st, BOOST_PP_SEQ_REVERSE_S(183, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_183(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_183(op, st, BOOST_PP_SEQ_REVERSE_S(184, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_184(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_184(op, st, BOOST_PP_SEQ_REVERSE_S(185, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_185(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_185(op, st, BOOST_PP_SEQ_REVERSE_S(186, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_186(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_186(op, st, BOOST_PP_SEQ_REVERSE_S(187, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_187(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_187(op, st, BOOST_PP_SEQ_REVERSE_S(188, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_188(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_188(op, st, BOOST_PP_SEQ_REVERSE_S(189, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_189(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_189(op, st, BOOST_PP_SEQ_REVERSE_S(190, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_190(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_190(op, st, BOOST_PP_SEQ_REVERSE_S(191, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_191(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_191(op, st, BOOST_PP_SEQ_REVERSE_S(192, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_192(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_192(op, st, BOOST_PP_SEQ_REVERSE_S(193, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_193(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_193(op, st, BOOST_PP_SEQ_REVERSE_S(194, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_194(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_194(op, st, BOOST_PP_SEQ_REVERSE_S(195, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_195(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_195(op, st, BOOST_PP_SEQ_REVERSE_S(196, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_196(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_196(op, st, BOOST_PP_SEQ_REVERSE_S(197, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_197(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_197(op, st, BOOST_PP_SEQ_REVERSE_S(198, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_198(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_198(op, st, BOOST_PP_SEQ_REVERSE_S(199, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_199(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_199(op, st, BOOST_PP_SEQ_REVERSE_S(200, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_200(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_200(op, st, BOOST_PP_SEQ_REVERSE_S(201, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_201(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_201(op, st, BOOST_PP_SEQ_REVERSE_S(202, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_202(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_202(op, st, BOOST_PP_SEQ_REVERSE_S(203, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_203(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_203(op, st, BOOST_PP_SEQ_REVERSE_S(204, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_204(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_204(op, st, BOOST_PP_SEQ_REVERSE_S(205, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_205(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_205(op, st, BOOST_PP_SEQ_REVERSE_S(206, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_206(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_206(op, st, BOOST_PP_SEQ_REVERSE_S(207, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_207(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_207(op, st, BOOST_PP_SEQ_REVERSE_S(208, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_208(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_208(op, st, BOOST_PP_SEQ_REVERSE_S(209, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_209(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_209(op, st, BOOST_PP_SEQ_REVERSE_S(210, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_210(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_210(op, st, BOOST_PP_SEQ_REVERSE_S(211, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_211(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_211(op, st, BOOST_PP_SEQ_REVERSE_S(212, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_212(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_212(op, st, BOOST_PP_SEQ_REVERSE_S(213, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_213(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_213(op, st, BOOST_PP_SEQ_REVERSE_S(214, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_214(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_214(op, st, BOOST_PP_SEQ_REVERSE_S(215, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_215(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_215(op, st, BOOST_PP_SEQ_REVERSE_S(216, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_216(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_216(op, st, BOOST_PP_SEQ_REVERSE_S(217, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_217(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_217(op, st, BOOST_PP_SEQ_REVERSE_S(218, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_218(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_218(op, st, BOOST_PP_SEQ_REVERSE_S(219, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_219(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_219(op, st, BOOST_PP_SEQ_REVERSE_S(220, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_220(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_220(op, st, BOOST_PP_SEQ_REVERSE_S(221, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_221(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_221(op, st, BOOST_PP_SEQ_REVERSE_S(222, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_222(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_222(op, st, BOOST_PP_SEQ_REVERSE_S(223, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_223(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_223(op, st, BOOST_PP_SEQ_REVERSE_S(224, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_224(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_224(op, st, BOOST_PP_SEQ_REVERSE_S(225, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_225(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_225(op, st, BOOST_PP_SEQ_REVERSE_S(226, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_226(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_226(op, st, BOOST_PP_SEQ_REVERSE_S(227, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_227(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_227(op, st, BOOST_PP_SEQ_REVERSE_S(228, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_228(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_228(op, st, BOOST_PP_SEQ_REVERSE_S(229, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_229(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_229(op, st, BOOST_PP_SEQ_REVERSE_S(230, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_230(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_230(op, st, BOOST_PP_SEQ_REVERSE_S(231, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_231(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_231(op, st, BOOST_PP_SEQ_REVERSE_S(232, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_232(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_232(op, st, BOOST_PP_SEQ_REVERSE_S(233, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_233(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_233(op, st, BOOST_PP_SEQ_REVERSE_S(234, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_234(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_234(op, st, BOOST_PP_SEQ_REVERSE_S(235, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_235(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_235(op, st, BOOST_PP_SEQ_REVERSE_S(236, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_236(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_236(op, st, BOOST_PP_SEQ_REVERSE_S(237, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_237(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_237(op, st, BOOST_PP_SEQ_REVERSE_S(238, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_238(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_238(op, st, BOOST_PP_SEQ_REVERSE_S(239, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_239(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_239(op, st, BOOST_PP_SEQ_REVERSE_S(240, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_240(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_240(op, st, BOOST_PP_SEQ_REVERSE_S(241, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_241(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_241(op, st, BOOST_PP_SEQ_REVERSE_S(242, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_242(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_242(op, st, BOOST_PP_SEQ_REVERSE_S(243, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_243(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_243(op, st, BOOST_PP_SEQ_REVERSE_S(244, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_244(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_244(op, st, BOOST_PP_SEQ_REVERSE_S(245, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_245(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_245(op, st, BOOST_PP_SEQ_REVERSE_S(246, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_246(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_246(op, st, BOOST_PP_SEQ_REVERSE_S(247, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_247(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_247(op, st, BOOST_PP_SEQ_REVERSE_S(248, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_248(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_248(op, st, BOOST_PP_SEQ_REVERSE_S(249, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_249(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_249(op, st, BOOST_PP_SEQ_REVERSE_S(250, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_250(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_250(op, st, BOOST_PP_SEQ_REVERSE_S(251, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_251(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_251(op, st, BOOST_PP_SEQ_REVERSE_S(252, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_252(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_252(op, st, BOOST_PP_SEQ_REVERSE_S(253, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_253(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_253(op, st, BOOST_PP_SEQ_REVERSE_S(254, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_254(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_254(op, st, BOOST_PP_SEQ_REVERSE_S(255, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_255(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_255(op, st, BOOST_PP_SEQ_REVERSE_S(256, ss), BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_RIGHT_256(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, BOOST_PP_SEQ_REVERSE_S(257, ss), BOOST_PP_SEQ_SIZE(ss)) # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/fold_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/fold0000644000175000017500000050510211344301502031632 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FOLD_LEFT_HPP # define BOOST_PREPROCESSOR_SEQ_FOLD_LEFT_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_SEQ_FOLD_LEFT */ # # if 0 # define BOOST_PP_SEQ_FOLD_LEFT(op, state, seq) ... # endif # # define BOOST_PP_SEQ_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_SEQ_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_SEQ_FOLD_LEFT_P, 256)) # define BOOST_PP_SEQ_FOLD_LEFT_P(n) BOOST_PP_CAT(BOOST_PP_SEQ_FOLD_LEFT_CHECK_, BOOST_PP_SEQ_FOLD_LEFT_I_ ## n(BOOST_PP_SEQ_FOLD_LEFT_O, BOOST_PP_NIL, (nil), 1)) # define BOOST_PP_SEQ_FOLD_LEFT_O(s, st, _) st # # define BOOST_PP_SEQ_FOLD_LEFT_257(op, st, ss) BOOST_PP_ERROR(0x0005) # define BOOST_PP_SEQ_FOLD_LEFT_I_257(op, st, ss, sz) BOOST_PP_ERROR(0x0005) # # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_NIL 1 # # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_1(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_2(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_3(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_4(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_5(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_6(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_7(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_8(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_9(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_10(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_11(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_12(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_13(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_14(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_15(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_16(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_17(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_18(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_19(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_20(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_21(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_22(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_23(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_24(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_25(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_26(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_27(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_28(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_29(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_30(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_31(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_32(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_33(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_34(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_35(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_36(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_37(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_38(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_39(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_40(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_41(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_42(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_43(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_44(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_45(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_46(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_47(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_48(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_49(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_50(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_51(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_52(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_53(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_54(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_55(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_56(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_57(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_58(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_59(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_60(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_61(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_62(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_63(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_64(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_65(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_66(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_67(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_68(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_69(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_70(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_71(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_72(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_73(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_74(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_75(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_76(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_77(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_78(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_79(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_80(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_81(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_82(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_83(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_84(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_85(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_86(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_87(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_88(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_89(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_90(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_91(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_92(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_93(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_94(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_95(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_96(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_97(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_98(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_99(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_100(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_101(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_102(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_103(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_104(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_105(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_106(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_107(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_108(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_109(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_110(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_111(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_112(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_113(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_114(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_115(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_116(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_117(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_118(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_119(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_120(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_121(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_122(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_123(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_124(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_125(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_126(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_127(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_128(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_129(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_130(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_131(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_132(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_133(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_134(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_135(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_136(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_137(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_138(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_139(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_140(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_141(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_142(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_143(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_144(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_145(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_146(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_147(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_148(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_149(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_150(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_151(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_152(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_153(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_154(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_155(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_156(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_157(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_158(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_159(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_160(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_161(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_162(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_163(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_164(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_165(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_166(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_167(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_168(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_169(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_170(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_171(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_172(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_173(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_174(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_175(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_176(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_177(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_178(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_179(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_180(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_181(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_182(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_183(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_184(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_185(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_186(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_187(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_188(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_189(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_190(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_191(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_192(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_193(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_194(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_195(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_196(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_197(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_198(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_199(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_200(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_201(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_202(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_203(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_204(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_205(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_206(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_207(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_208(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_209(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_210(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_211(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_212(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_213(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_214(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_215(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_216(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_217(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_218(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_219(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_220(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_221(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_222(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_223(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_224(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_225(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_226(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_227(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_228(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_229(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_230(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_231(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_232(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_233(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_234(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_235(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_236(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_237(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_238(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_239(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_240(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_241(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_242(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_243(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_244(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_245(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_246(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_247(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_248(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_249(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_250(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_251(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_252(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_253(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_254(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_255(op, st, ss, sz) 0 # define BOOST_PP_SEQ_FOLD_LEFT_CHECK_BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, ss, sz) 0 # # define BOOST_PP_SEQ_FOLD_LEFT_F(op, st, ss, sz) st # # define BOOST_PP_SEQ_FOLD_LEFT_1(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_1(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_2(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_2(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_3(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_3(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_4(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_4(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_5(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_5(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_6(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_6(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_7(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_7(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_8(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_8(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_9(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_9(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_10(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_10(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_11(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_11(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_12(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_12(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_13(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_13(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_14(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_14(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_15(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_15(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_16(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_16(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_17(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_17(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_18(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_18(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_19(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_19(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_20(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_20(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_21(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_21(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_22(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_22(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_23(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_23(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_24(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_24(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_25(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_25(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_26(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_26(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_27(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_27(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_28(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_28(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_29(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_29(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_30(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_30(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_31(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_31(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_32(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_32(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_33(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_33(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_34(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_34(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_35(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_35(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_36(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_36(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_37(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_37(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_38(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_38(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_39(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_39(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_40(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_40(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_41(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_41(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_42(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_42(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_43(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_43(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_44(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_44(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_45(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_45(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_46(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_46(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_47(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_47(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_48(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_48(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_49(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_49(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_50(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_50(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_51(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_51(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_52(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_52(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_53(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_53(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_54(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_54(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_55(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_55(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_56(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_56(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_57(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_57(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_58(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_58(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_59(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_59(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_60(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_60(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_61(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_61(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_62(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_62(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_63(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_63(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_64(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_64(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_65(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_65(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_66(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_66(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_67(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_67(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_68(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_68(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_69(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_69(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_70(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_70(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_71(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_71(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_72(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_72(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_73(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_73(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_74(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_74(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_75(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_75(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_76(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_76(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_77(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_77(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_78(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_78(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_79(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_79(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_80(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_80(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_81(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_81(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_82(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_82(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_83(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_83(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_84(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_84(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_85(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_85(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_86(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_86(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_87(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_87(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_88(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_88(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_89(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_89(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_90(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_90(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_91(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_91(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_92(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_92(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_93(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_93(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_94(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_94(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_95(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_95(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_96(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_96(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_97(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_97(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_98(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_98(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_99(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_99(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_100(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_100(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_101(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_101(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_102(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_102(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_103(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_103(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_104(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_104(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_105(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_105(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_106(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_106(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_107(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_107(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_108(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_108(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_109(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_109(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_110(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_110(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_111(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_111(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_112(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_112(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_113(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_113(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_114(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_114(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_115(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_115(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_116(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_116(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_117(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_117(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_118(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_118(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_119(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_119(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_120(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_120(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_121(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_121(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_122(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_122(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_123(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_123(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_124(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_124(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_125(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_125(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_126(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_126(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_127(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_127(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_128(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_128(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_129(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_129(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_130(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_130(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_131(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_131(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_132(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_132(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_133(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_133(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_134(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_134(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_135(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_135(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_136(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_136(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_137(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_137(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_138(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_138(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_139(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_139(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_140(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_140(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_141(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_141(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_142(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_142(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_143(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_143(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_144(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_144(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_145(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_145(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_146(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_146(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_147(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_147(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_148(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_148(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_149(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_149(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_150(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_150(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_151(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_151(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_152(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_152(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_153(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_153(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_154(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_154(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_155(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_155(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_156(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_156(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_157(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_157(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_158(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_158(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_159(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_159(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_160(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_160(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_161(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_161(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_162(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_162(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_163(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_163(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_164(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_164(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_165(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_165(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_166(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_166(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_167(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_167(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_168(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_168(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_169(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_169(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_170(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_170(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_171(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_171(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_172(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_172(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_173(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_173(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_174(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_174(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_175(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_175(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_176(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_176(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_177(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_177(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_178(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_178(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_179(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_179(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_180(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_180(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_181(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_181(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_182(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_182(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_183(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_183(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_184(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_184(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_185(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_185(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_186(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_186(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_187(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_187(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_188(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_188(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_189(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_189(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_190(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_190(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_191(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_191(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_192(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_192(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_193(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_193(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_194(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_194(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_195(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_195(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_196(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_196(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_197(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_197(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_198(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_198(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_199(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_199(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_200(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_200(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_201(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_201(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_202(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_202(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_203(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_203(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_204(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_204(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_205(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_205(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_206(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_206(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_207(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_207(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_208(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_208(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_209(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_209(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_210(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_210(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_211(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_211(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_212(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_212(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_213(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_213(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_214(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_214(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_215(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_215(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_216(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_216(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_217(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_217(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_218(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_218(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_219(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_219(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_220(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_220(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_221(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_221(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_222(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_222(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_223(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_223(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_224(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_224(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_225(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_225(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_226(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_226(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_227(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_227(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_228(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_228(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_229(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_229(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_230(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_230(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_231(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_231(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_232(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_232(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_233(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_233(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_234(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_234(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_235(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_235(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_236(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_236(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_237(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_237(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_238(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_238(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_239(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_239(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_240(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_240(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_241(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_241(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_242(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_242(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_243(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_243(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_244(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_244(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_245(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_245(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_246(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_246(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_247(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_247(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_248(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_248(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_249(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_249(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_250(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_250(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_251(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_251(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_252(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_252(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_253(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_253(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_254(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_254(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_255(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_255(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # define BOOST_PP_SEQ_FOLD_LEFT_256(op, st, ss) BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, ss, BOOST_PP_SEQ_SIZE(ss)) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_SEQ_FOLD_LEFT_I_1(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_2, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(2, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_2(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_3, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(3, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_3(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_4, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(4, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_4(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_5, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(5, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_5(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_6, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(6, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_6(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_7, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(7, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_7(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_8, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(8, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_8(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_9, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(9, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_9(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_10, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(10, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_10(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_11, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(11, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_11(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_12, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(12, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_12(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_13, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(13, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_13(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_14, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(14, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_14(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_15, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(15, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_15(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_16, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(16, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_16(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_17, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(17, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_17(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_18, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(18, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_18(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_19, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(19, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_19(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_20, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(20, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_20(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_21, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(21, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_21(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_22, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(22, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_22(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_23, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(23, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_23(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_24, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(24, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_24(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_25, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(25, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_25(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_26, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(26, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_26(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_27, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(27, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_27(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_28, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(28, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_28(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_29, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(29, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_29(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_30, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(30, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_30(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_31, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(31, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_31(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_32, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(32, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_32(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_33, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(33, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_33(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_34, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(34, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_34(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_35, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(35, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_35(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_36, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(36, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_36(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_37, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(37, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_37(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_38, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(38, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_38(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_39, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(39, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_39(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_40, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(40, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_40(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_41, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(41, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_41(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_42, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(42, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_42(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_43, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(43, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_43(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_44, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(44, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_44(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_45, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(45, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_45(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_46, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(46, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_46(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_47, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(47, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_47(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_48, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(48, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_48(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_49, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(49, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_49(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_50, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(50, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_50(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_51, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(51, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_51(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_52, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(52, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_52(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_53, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(53, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_53(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_54, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(54, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_54(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_55, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(55, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_55(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_56, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(56, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_56(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_57, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(57, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_57(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_58, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(58, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_58(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_59, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(59, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_59(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_60, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(60, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_60(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_61, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(61, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_61(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_62, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(62, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_62(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_63, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(63, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_63(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_64, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(64, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_64(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_65, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(65, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_65(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_66, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(66, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_66(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_67, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(67, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_67(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_68, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(68, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_68(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_69, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(69, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_69(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_70, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(70, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_70(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_71, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(71, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_71(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_72, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(72, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_72(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_73, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(73, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_73(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_74, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(74, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_74(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_75, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(75, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_75(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_76, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(76, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_76(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_77, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(77, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_77(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_78, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(78, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_78(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_79, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(79, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_79(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_80, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(80, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_80(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_81, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(81, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_81(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_82, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(82, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_82(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_83, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(83, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_83(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_84, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(84, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_84(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_85, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(85, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_85(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_86, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(86, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_86(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_87, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(87, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_87(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_88, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(88, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_88(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_89, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(89, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_89(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_90, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(90, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_90(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_91, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(91, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_91(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_92, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(92, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_92(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_93, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(93, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_93(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_94, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(94, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_94(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_95, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(95, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_95(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_96, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(96, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_96(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_97, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(97, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_97(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_98, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(98, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_98(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_99, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(99, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_99(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_100, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(100, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_100(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_101, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(101, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_101(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_102, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(102, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_102(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_103, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(103, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_103(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_104, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(104, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_104(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_105, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(105, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_105(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_106, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(106, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_106(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_107, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(107, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_107(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_108, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(108, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_108(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_109, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(109, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_109(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_110, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(110, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_110(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_111, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(111, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_111(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_112, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(112, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_112(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_113, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(113, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_113(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_114, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(114, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_114(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_115, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(115, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_115(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_116, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(116, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_116(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_117, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(117, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_117(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_118, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(118, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_118(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_119, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(119, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_119(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_120, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(120, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_120(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_121, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(121, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_121(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_122, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(122, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_122(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_123, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(123, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_123(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_124, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(124, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_124(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_125, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(125, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_125(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_126, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(126, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_126(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_127, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(127, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_127(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_128, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(128, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_128(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_129, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(129, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_129(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_130, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(130, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_130(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_131, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(131, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_131(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_132, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(132, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_132(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_133, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(133, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_133(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_134, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(134, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_134(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_135, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(135, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_135(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_136, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(136, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_136(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_137, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(137, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_137(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_138, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(138, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_138(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_139, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(139, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_139(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_140, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(140, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_140(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_141, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(141, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_141(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_142, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(142, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_142(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_143, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(143, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_143(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_144, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(144, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_144(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_145, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(145, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_145(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_146, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(146, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_146(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_147, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(147, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_147(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_148, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(148, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_148(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_149, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(149, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_149(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_150, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(150, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_150(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_151, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(151, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_151(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_152, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(152, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_152(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_153, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(153, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_153(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_154, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(154, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_154(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_155, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(155, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_155(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_156, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(156, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_156(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_157, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(157, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_157(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_158, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(158, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_158(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_159, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(159, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_159(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_160, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(160, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_160(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_161, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(161, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_161(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_162, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(162, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_162(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_163, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(163, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_163(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_164, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(164, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_164(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_165, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(165, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_165(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_166, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(166, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_166(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_167, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(167, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_167(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_168, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(168, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_168(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_169, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(169, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_169(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_170, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(170, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_170(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_171, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(171, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_171(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_172, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(172, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_172(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_173, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(173, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_173(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_174, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(174, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_174(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_175, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(175, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_175(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_176, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(176, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_176(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_177, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(177, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_177(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_178, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(178, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_178(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_179, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(179, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_179(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_180, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(180, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_180(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_181, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(181, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_181(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_182, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(182, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_182(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_183, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(183, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_183(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_184, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(184, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_184(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_185, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(185, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_185(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_186, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(186, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_186(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_187, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(187, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_187(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_188, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(188, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_188(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_189, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(189, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_189(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_190, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(190, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_190(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_191, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(191, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_191(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_192, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(192, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_192(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_193, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(193, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_193(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_194, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(194, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_194(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_195, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(195, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_195(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_196, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(196, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_196(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_197, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(197, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_197(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_198, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(198, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_198(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_199, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(199, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_199(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_200, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(200, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_200(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_201, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(201, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_201(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_202, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(202, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_202(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_203, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(203, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_203(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_204, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(204, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_204(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_205, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(205, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_205(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_206, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(206, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_206(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_207, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(207, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_207(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_208, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(208, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_208(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_209, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(209, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_209(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_210, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(210, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_210(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_211, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(211, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_211(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_212, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(212, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_212(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_213, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(213, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_213(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_214, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(214, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_214(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_215, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(215, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_215(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_216, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(216, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_216(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_217, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(217, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_217(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_218, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(218, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_218(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_219, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(219, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_219(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_220, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(220, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_220(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_221, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(221, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_221(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_222, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(222, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_222(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_223, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(223, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_223(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_224, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(224, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_224(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_225, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(225, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_225(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_226, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(226, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_226(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_227, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(227, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_227(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_228, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(228, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_228(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_229, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(229, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_229(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_230, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(230, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_230(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_231, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(231, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_231(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_232, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(232, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_232(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_233, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(233, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_233(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_234, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(234, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_234(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_235, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(235, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_235(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_236, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(236, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_236(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_237, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(237, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_237(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_238, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(238, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_238(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_239, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(239, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_239(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_240, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(240, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_240(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_241, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(241, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_241(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_242, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(242, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_242(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_243, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(243, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_243(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_244, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(244, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_244(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_245, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(245, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_245(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_246, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(246, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_246(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_247, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(247, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_247(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_248, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(248, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_248(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_249, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(249, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_249(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_250, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(250, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_250(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_251, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(251, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_251(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_252, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(252, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_252(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_253, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(253, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_253(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_254, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(254, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_254(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_255, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(255, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_255(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_256, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(256, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_257, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op(257, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # else # define BOOST_PP_SEQ_FOLD_LEFT_I_1(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_2, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(2, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_2(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_3, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(3, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_3(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_4, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(4, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_4(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_5, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(5, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_5(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_6, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(6, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_6(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_7, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(7, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_7(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_8, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(8, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_8(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_9, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(9, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_9(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_10, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(10, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_10(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_11, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(11, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_11(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_12, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(12, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_12(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_13, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(13, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_13(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_14, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(14, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_14(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_15, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(15, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_15(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_16, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(16, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_16(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_17, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(17, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_17(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_18, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(18, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_18(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_19, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(19, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_19(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_20, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(20, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_20(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_21, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(21, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_21(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_22, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(22, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_22(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_23, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(23, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_23(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_24, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(24, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_24(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_25, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(25, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_25(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_26, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(26, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_26(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_27, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(27, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_27(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_28, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(28, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_28(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_29, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(29, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_29(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_30, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(30, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_30(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_31, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(31, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_31(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_32, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(32, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_32(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_33, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(33, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_33(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_34, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(34, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_34(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_35, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(35, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_35(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_36, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(36, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_36(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_37, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(37, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_37(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_38, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(38, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_38(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_39, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(39, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_39(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_40, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(40, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_40(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_41, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(41, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_41(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_42, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(42, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_42(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_43, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(43, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_43(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_44, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(44, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_44(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_45, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(45, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_45(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_46, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(46, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_46(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_47, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(47, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_47(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_48, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(48, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_48(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_49, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(49, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_49(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_50, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(50, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_50(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_51, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(51, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_51(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_52, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(52, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_52(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_53, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(53, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_53(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_54, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(54, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_54(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_55, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(55, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_55(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_56, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(56, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_56(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_57, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(57, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_57(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_58, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(58, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_58(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_59, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(59, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_59(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_60, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(60, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_60(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_61, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(61, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_61(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_62, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(62, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_62(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_63, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(63, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_63(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_64, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(64, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_64(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_65, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(65, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_65(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_66, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(66, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_66(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_67, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(67, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_67(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_68, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(68, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_68(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_69, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(69, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_69(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_70, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(70, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_70(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_71, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(71, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_71(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_72, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(72, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_72(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_73, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(73, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_73(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_74, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(74, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_74(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_75, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(75, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_75(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_76, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(76, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_76(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_77, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(77, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_77(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_78, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(78, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_78(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_79, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(79, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_79(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_80, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(80, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_80(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_81, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(81, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_81(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_82, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(82, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_82(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_83, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(83, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_83(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_84, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(84, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_84(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_85, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(85, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_85(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_86, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(86, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_86(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_87, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(87, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_87(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_88, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(88, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_88(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_89, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(89, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_89(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_90, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(90, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_90(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_91, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(91, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_91(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_92, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(92, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_92(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_93, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(93, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_93(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_94, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(94, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_94(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_95, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(95, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_95(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_96, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(96, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_96(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_97, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(97, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_97(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_98, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(98, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_98(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_99, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(99, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_99(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_100, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(100, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_100(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_101, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(101, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_101(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_102, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(102, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_102(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_103, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(103, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_103(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_104, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(104, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_104(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_105, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(105, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_105(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_106, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(106, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_106(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_107, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(107, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_107(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_108, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(108, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_108(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_109, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(109, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_109(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_110, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(110, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_110(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_111, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(111, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_111(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_112, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(112, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_112(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_113, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(113, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_113(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_114, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(114, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_114(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_115, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(115, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_115(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_116, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(116, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_116(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_117, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(117, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_117(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_118, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(118, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_118(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_119, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(119, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_119(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_120, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(120, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_120(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_121, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(121, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_121(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_122, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(122, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_122(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_123, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(123, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_123(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_124, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(124, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_124(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_125, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(125, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_125(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_126, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(126, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_126(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_127, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(127, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_127(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_128, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(128, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_128(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_129, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(129, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_129(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_130, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(130, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_130(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_131, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(131, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_131(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_132, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(132, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_132(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_133, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(133, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_133(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_134, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(134, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_134(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_135, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(135, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_135(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_136, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(136, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_136(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_137, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(137, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_137(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_138, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(138, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_138(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_139, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(139, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_139(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_140, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(140, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_140(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_141, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(141, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_141(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_142, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(142, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_142(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_143, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(143, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_143(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_144, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(144, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_144(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_145, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(145, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_145(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_146, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(146, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_146(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_147, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(147, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_147(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_148, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(148, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_148(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_149, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(149, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_149(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_150, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(150, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_150(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_151, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(151, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_151(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_152, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(152, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_152(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_153, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(153, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_153(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_154, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(154, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_154(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_155, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(155, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_155(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_156, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(156, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_156(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_157, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(157, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_157(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_158, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(158, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_158(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_159, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(159, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_159(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_160, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(160, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_160(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_161, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(161, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_161(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_162, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(162, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_162(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_163, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(163, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_163(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_164, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(164, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_164(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_165, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(165, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_165(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_166, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(166, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_166(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_167, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(167, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_167(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_168, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(168, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_168(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_169, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(169, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_169(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_170, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(170, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_170(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_171, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(171, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_171(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_172, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(172, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_172(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_173, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(173, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_173(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_174, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(174, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_174(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_175, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(175, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_175(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_176, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(176, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_176(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_177, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(177, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_177(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_178, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(178, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_178(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_179, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(179, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_179(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_180, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(180, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_180(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_181, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(181, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_181(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_182, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(182, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_182(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_183, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(183, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_183(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_184, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(184, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_184(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_185, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(185, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_185(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_186, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(186, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_186(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_187, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(187, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_187(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_188, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(188, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_188(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_189, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(189, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_189(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_190, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(190, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_190(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_191, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(191, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_191(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_192, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(192, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_192(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_193, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(193, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_193(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_194, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(194, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_194(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_195, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(195, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_195(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_196, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(196, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_196(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_197, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(197, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_197(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_198, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(198, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_198(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_199, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(199, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_199(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_200, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(200, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_200(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_201, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(201, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_201(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_202, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(202, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_202(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_203, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(203, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_203(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_204, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(204, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_204(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_205, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(205, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_205(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_206, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(206, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_206(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_207, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(207, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_207(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_208, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(208, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_208(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_209, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(209, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_209(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_210, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(210, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_210(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_211, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(211, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_211(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_212, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(212, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_212(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_213, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(213, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_213(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_214, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(214, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_214(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_215, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(215, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_215(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_216, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(216, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_216(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_217, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(217, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_217(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_218, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(218, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_218(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_219, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(219, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_219(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_220, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(220, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_220(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_221, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(221, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_221(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_222, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(222, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_222(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_223, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(223, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_223(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_224, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(224, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_224(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_225, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(225, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_225(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_226, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(226, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_226(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_227, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(227, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_227(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_228, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(228, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_228(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_229, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(229, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_229(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_230, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(230, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_230(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_231, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(231, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_231(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_232, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(232, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_232(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_233, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(233, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_233(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_234, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(234, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_234(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_235, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(235, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_235(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_236, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(236, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_236(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_237, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(237, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_237(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_238, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(238, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_238(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_239, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(239, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_239(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_240, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(240, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_240(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_241, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(241, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_241(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_242, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(242, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_242(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_243, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(243, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_243(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_244, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(244, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_244(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_245, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(245, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_245(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_246, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(246, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_246(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_247, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(247, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_247(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_248, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(248, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_248(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_249, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(249, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_249(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_250, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(250, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_250(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_251, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(251, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_251(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_252, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(252, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_252(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_253, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(253, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_253(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_254, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(254, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_254(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_255, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(255, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_255(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_256, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(256, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # define BOOST_PP_SEQ_FOLD_LEFT_I_256(op, st, ss, sz) BOOST_PP_IF(BOOST_PP_DEC(sz), BOOST_PP_SEQ_FOLD_LEFT_I_257, BOOST_PP_SEQ_FOLD_LEFT_F)(op, op##(257, st, BOOST_PP_SEQ_HEAD(ss)), BOOST_PP_SEQ_TAIL(ss), BOOST_PP_DEC(sz)) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/replace.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/repl0000644000175000017500000000246411344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_REPLACE_HPP # define BOOST_PREPROCESSOR_SEQ_REPLACE_HPP # # include # include # include # include # # /* BOOST_PP_SEQ_REPLACE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_REPLACE(seq, i, elem) BOOST_PP_SEQ_FIRST_N(i, seq) (elem) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq) # else # define BOOST_PP_SEQ_REPLACE(seq, i, elem) BOOST_PP_SEQ_REPLACE_I(seq, i, elem) # define BOOST_PP_SEQ_REPLACE_I(seq, i, elem) BOOST_PP_SEQ_FIRST_N(i, seq) (elem) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq) # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/size0000644000175000017500000007060411344301502031664 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_SIZE_HPP # define BOOST_PREPROCESSOR_SEQ_SIZE_HPP # # include # include # include # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_SIZE(seq) BOOST_PP_SEQ_SIZE_I((seq)) # define BOOST_PP_SEQ_SIZE_I(par) BOOST_PP_SEQ_SIZE_II ## par # define BOOST_PP_SEQ_SIZE_II(seq) BOOST_PP_CAT(BOOST_PP_SEQ_SIZE_, BOOST_PP_SEQ_SIZE_0 ## seq) # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() || BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_SEQ_SIZE(seq) BOOST_PP_SEQ_SIZE_I(seq) # define BOOST_PP_SEQ_SIZE_I(seq) BOOST_PP_CAT(BOOST_PP_SEQ_SIZE_, BOOST_PP_SEQ_SIZE_0 seq) # else # define BOOST_PP_SEQ_SIZE(seq) BOOST_PP_CAT(BOOST_PP_SEQ_SIZE_, BOOST_PP_SEQ_SIZE_0 seq) # endif # # define BOOST_PP_SEQ_SIZE_0(_) BOOST_PP_SEQ_SIZE_1 # define BOOST_PP_SEQ_SIZE_1(_) BOOST_PP_SEQ_SIZE_2 # define BOOST_PP_SEQ_SIZE_2(_) BOOST_PP_SEQ_SIZE_3 # define BOOST_PP_SEQ_SIZE_3(_) BOOST_PP_SEQ_SIZE_4 # define BOOST_PP_SEQ_SIZE_4(_) BOOST_PP_SEQ_SIZE_5 # define BOOST_PP_SEQ_SIZE_5(_) BOOST_PP_SEQ_SIZE_6 # define BOOST_PP_SEQ_SIZE_6(_) BOOST_PP_SEQ_SIZE_7 # define BOOST_PP_SEQ_SIZE_7(_) BOOST_PP_SEQ_SIZE_8 # define BOOST_PP_SEQ_SIZE_8(_) BOOST_PP_SEQ_SIZE_9 # define BOOST_PP_SEQ_SIZE_9(_) BOOST_PP_SEQ_SIZE_10 # define BOOST_PP_SEQ_SIZE_10(_) BOOST_PP_SEQ_SIZE_11 # define BOOST_PP_SEQ_SIZE_11(_) BOOST_PP_SEQ_SIZE_12 # define BOOST_PP_SEQ_SIZE_12(_) BOOST_PP_SEQ_SIZE_13 # define BOOST_PP_SEQ_SIZE_13(_) BOOST_PP_SEQ_SIZE_14 # define BOOST_PP_SEQ_SIZE_14(_) BOOST_PP_SEQ_SIZE_15 # define BOOST_PP_SEQ_SIZE_15(_) BOOST_PP_SEQ_SIZE_16 # define BOOST_PP_SEQ_SIZE_16(_) BOOST_PP_SEQ_SIZE_17 # define BOOST_PP_SEQ_SIZE_17(_) BOOST_PP_SEQ_SIZE_18 # define BOOST_PP_SEQ_SIZE_18(_) BOOST_PP_SEQ_SIZE_19 # define BOOST_PP_SEQ_SIZE_19(_) BOOST_PP_SEQ_SIZE_20 # define BOOST_PP_SEQ_SIZE_20(_) BOOST_PP_SEQ_SIZE_21 # define BOOST_PP_SEQ_SIZE_21(_) BOOST_PP_SEQ_SIZE_22 # define BOOST_PP_SEQ_SIZE_22(_) BOOST_PP_SEQ_SIZE_23 # define BOOST_PP_SEQ_SIZE_23(_) BOOST_PP_SEQ_SIZE_24 # define BOOST_PP_SEQ_SIZE_24(_) BOOST_PP_SEQ_SIZE_25 # define BOOST_PP_SEQ_SIZE_25(_) BOOST_PP_SEQ_SIZE_26 # define BOOST_PP_SEQ_SIZE_26(_) BOOST_PP_SEQ_SIZE_27 # define BOOST_PP_SEQ_SIZE_27(_) BOOST_PP_SEQ_SIZE_28 # define BOOST_PP_SEQ_SIZE_28(_) BOOST_PP_SEQ_SIZE_29 # define BOOST_PP_SEQ_SIZE_29(_) BOOST_PP_SEQ_SIZE_30 # define BOOST_PP_SEQ_SIZE_30(_) BOOST_PP_SEQ_SIZE_31 # define BOOST_PP_SEQ_SIZE_31(_) BOOST_PP_SEQ_SIZE_32 # define BOOST_PP_SEQ_SIZE_32(_) BOOST_PP_SEQ_SIZE_33 # define BOOST_PP_SEQ_SIZE_33(_) BOOST_PP_SEQ_SIZE_34 # define BOOST_PP_SEQ_SIZE_34(_) BOOST_PP_SEQ_SIZE_35 # define BOOST_PP_SEQ_SIZE_35(_) BOOST_PP_SEQ_SIZE_36 # define BOOST_PP_SEQ_SIZE_36(_) BOOST_PP_SEQ_SIZE_37 # define BOOST_PP_SEQ_SIZE_37(_) BOOST_PP_SEQ_SIZE_38 # define BOOST_PP_SEQ_SIZE_38(_) BOOST_PP_SEQ_SIZE_39 # define BOOST_PP_SEQ_SIZE_39(_) BOOST_PP_SEQ_SIZE_40 # define BOOST_PP_SEQ_SIZE_40(_) BOOST_PP_SEQ_SIZE_41 # define BOOST_PP_SEQ_SIZE_41(_) BOOST_PP_SEQ_SIZE_42 # define BOOST_PP_SEQ_SIZE_42(_) BOOST_PP_SEQ_SIZE_43 # define BOOST_PP_SEQ_SIZE_43(_) BOOST_PP_SEQ_SIZE_44 # define BOOST_PP_SEQ_SIZE_44(_) BOOST_PP_SEQ_SIZE_45 # define BOOST_PP_SEQ_SIZE_45(_) BOOST_PP_SEQ_SIZE_46 # define BOOST_PP_SEQ_SIZE_46(_) BOOST_PP_SEQ_SIZE_47 # define BOOST_PP_SEQ_SIZE_47(_) BOOST_PP_SEQ_SIZE_48 # define BOOST_PP_SEQ_SIZE_48(_) BOOST_PP_SEQ_SIZE_49 # define BOOST_PP_SEQ_SIZE_49(_) BOOST_PP_SEQ_SIZE_50 # define BOOST_PP_SEQ_SIZE_50(_) BOOST_PP_SEQ_SIZE_51 # define BOOST_PP_SEQ_SIZE_51(_) BOOST_PP_SEQ_SIZE_52 # define BOOST_PP_SEQ_SIZE_52(_) BOOST_PP_SEQ_SIZE_53 # define BOOST_PP_SEQ_SIZE_53(_) BOOST_PP_SEQ_SIZE_54 # define BOOST_PP_SEQ_SIZE_54(_) BOOST_PP_SEQ_SIZE_55 # define BOOST_PP_SEQ_SIZE_55(_) BOOST_PP_SEQ_SIZE_56 # define BOOST_PP_SEQ_SIZE_56(_) BOOST_PP_SEQ_SIZE_57 # define BOOST_PP_SEQ_SIZE_57(_) BOOST_PP_SEQ_SIZE_58 # define BOOST_PP_SEQ_SIZE_58(_) BOOST_PP_SEQ_SIZE_59 # define BOOST_PP_SEQ_SIZE_59(_) BOOST_PP_SEQ_SIZE_60 # define BOOST_PP_SEQ_SIZE_60(_) BOOST_PP_SEQ_SIZE_61 # define BOOST_PP_SEQ_SIZE_61(_) BOOST_PP_SEQ_SIZE_62 # define BOOST_PP_SEQ_SIZE_62(_) BOOST_PP_SEQ_SIZE_63 # define BOOST_PP_SEQ_SIZE_63(_) BOOST_PP_SEQ_SIZE_64 # define BOOST_PP_SEQ_SIZE_64(_) BOOST_PP_SEQ_SIZE_65 # define BOOST_PP_SEQ_SIZE_65(_) BOOST_PP_SEQ_SIZE_66 # define BOOST_PP_SEQ_SIZE_66(_) BOOST_PP_SEQ_SIZE_67 # define BOOST_PP_SEQ_SIZE_67(_) BOOST_PP_SEQ_SIZE_68 # define BOOST_PP_SEQ_SIZE_68(_) BOOST_PP_SEQ_SIZE_69 # define BOOST_PP_SEQ_SIZE_69(_) BOOST_PP_SEQ_SIZE_70 # define BOOST_PP_SEQ_SIZE_70(_) BOOST_PP_SEQ_SIZE_71 # define BOOST_PP_SEQ_SIZE_71(_) BOOST_PP_SEQ_SIZE_72 # define BOOST_PP_SEQ_SIZE_72(_) BOOST_PP_SEQ_SIZE_73 # define BOOST_PP_SEQ_SIZE_73(_) BOOST_PP_SEQ_SIZE_74 # define BOOST_PP_SEQ_SIZE_74(_) BOOST_PP_SEQ_SIZE_75 # define BOOST_PP_SEQ_SIZE_75(_) BOOST_PP_SEQ_SIZE_76 # define BOOST_PP_SEQ_SIZE_76(_) BOOST_PP_SEQ_SIZE_77 # define BOOST_PP_SEQ_SIZE_77(_) BOOST_PP_SEQ_SIZE_78 # define BOOST_PP_SEQ_SIZE_78(_) BOOST_PP_SEQ_SIZE_79 # define BOOST_PP_SEQ_SIZE_79(_) BOOST_PP_SEQ_SIZE_80 # define BOOST_PP_SEQ_SIZE_80(_) BOOST_PP_SEQ_SIZE_81 # define BOOST_PP_SEQ_SIZE_81(_) BOOST_PP_SEQ_SIZE_82 # define BOOST_PP_SEQ_SIZE_82(_) BOOST_PP_SEQ_SIZE_83 # define BOOST_PP_SEQ_SIZE_83(_) BOOST_PP_SEQ_SIZE_84 # define BOOST_PP_SEQ_SIZE_84(_) BOOST_PP_SEQ_SIZE_85 # define BOOST_PP_SEQ_SIZE_85(_) BOOST_PP_SEQ_SIZE_86 # define BOOST_PP_SEQ_SIZE_86(_) BOOST_PP_SEQ_SIZE_87 # define BOOST_PP_SEQ_SIZE_87(_) BOOST_PP_SEQ_SIZE_88 # define BOOST_PP_SEQ_SIZE_88(_) BOOST_PP_SEQ_SIZE_89 # define BOOST_PP_SEQ_SIZE_89(_) BOOST_PP_SEQ_SIZE_90 # define BOOST_PP_SEQ_SIZE_90(_) BOOST_PP_SEQ_SIZE_91 # define BOOST_PP_SEQ_SIZE_91(_) BOOST_PP_SEQ_SIZE_92 # define BOOST_PP_SEQ_SIZE_92(_) BOOST_PP_SEQ_SIZE_93 # define BOOST_PP_SEQ_SIZE_93(_) BOOST_PP_SEQ_SIZE_94 # define BOOST_PP_SEQ_SIZE_94(_) BOOST_PP_SEQ_SIZE_95 # define BOOST_PP_SEQ_SIZE_95(_) BOOST_PP_SEQ_SIZE_96 # define BOOST_PP_SEQ_SIZE_96(_) BOOST_PP_SEQ_SIZE_97 # define BOOST_PP_SEQ_SIZE_97(_) BOOST_PP_SEQ_SIZE_98 # define BOOST_PP_SEQ_SIZE_98(_) BOOST_PP_SEQ_SIZE_99 # define BOOST_PP_SEQ_SIZE_99(_) BOOST_PP_SEQ_SIZE_100 # define BOOST_PP_SEQ_SIZE_100(_) BOOST_PP_SEQ_SIZE_101 # define BOOST_PP_SEQ_SIZE_101(_) BOOST_PP_SEQ_SIZE_102 # define BOOST_PP_SEQ_SIZE_102(_) BOOST_PP_SEQ_SIZE_103 # define BOOST_PP_SEQ_SIZE_103(_) BOOST_PP_SEQ_SIZE_104 # define BOOST_PP_SEQ_SIZE_104(_) BOOST_PP_SEQ_SIZE_105 # define BOOST_PP_SEQ_SIZE_105(_) BOOST_PP_SEQ_SIZE_106 # define BOOST_PP_SEQ_SIZE_106(_) BOOST_PP_SEQ_SIZE_107 # define BOOST_PP_SEQ_SIZE_107(_) BOOST_PP_SEQ_SIZE_108 # define BOOST_PP_SEQ_SIZE_108(_) BOOST_PP_SEQ_SIZE_109 # define BOOST_PP_SEQ_SIZE_109(_) BOOST_PP_SEQ_SIZE_110 # define BOOST_PP_SEQ_SIZE_110(_) BOOST_PP_SEQ_SIZE_111 # define BOOST_PP_SEQ_SIZE_111(_) BOOST_PP_SEQ_SIZE_112 # define BOOST_PP_SEQ_SIZE_112(_) BOOST_PP_SEQ_SIZE_113 # define BOOST_PP_SEQ_SIZE_113(_) BOOST_PP_SEQ_SIZE_114 # define BOOST_PP_SEQ_SIZE_114(_) BOOST_PP_SEQ_SIZE_115 # define BOOST_PP_SEQ_SIZE_115(_) BOOST_PP_SEQ_SIZE_116 # define BOOST_PP_SEQ_SIZE_116(_) BOOST_PP_SEQ_SIZE_117 # define BOOST_PP_SEQ_SIZE_117(_) BOOST_PP_SEQ_SIZE_118 # define BOOST_PP_SEQ_SIZE_118(_) BOOST_PP_SEQ_SIZE_119 # define BOOST_PP_SEQ_SIZE_119(_) BOOST_PP_SEQ_SIZE_120 # define BOOST_PP_SEQ_SIZE_120(_) BOOST_PP_SEQ_SIZE_121 # define BOOST_PP_SEQ_SIZE_121(_) BOOST_PP_SEQ_SIZE_122 # define BOOST_PP_SEQ_SIZE_122(_) BOOST_PP_SEQ_SIZE_123 # define BOOST_PP_SEQ_SIZE_123(_) BOOST_PP_SEQ_SIZE_124 # define BOOST_PP_SEQ_SIZE_124(_) BOOST_PP_SEQ_SIZE_125 # define BOOST_PP_SEQ_SIZE_125(_) BOOST_PP_SEQ_SIZE_126 # define BOOST_PP_SEQ_SIZE_126(_) BOOST_PP_SEQ_SIZE_127 # define BOOST_PP_SEQ_SIZE_127(_) BOOST_PP_SEQ_SIZE_128 # define BOOST_PP_SEQ_SIZE_128(_) BOOST_PP_SEQ_SIZE_129 # define BOOST_PP_SEQ_SIZE_129(_) BOOST_PP_SEQ_SIZE_130 # define BOOST_PP_SEQ_SIZE_130(_) BOOST_PP_SEQ_SIZE_131 # define BOOST_PP_SEQ_SIZE_131(_) BOOST_PP_SEQ_SIZE_132 # define BOOST_PP_SEQ_SIZE_132(_) BOOST_PP_SEQ_SIZE_133 # define BOOST_PP_SEQ_SIZE_133(_) BOOST_PP_SEQ_SIZE_134 # define BOOST_PP_SEQ_SIZE_134(_) BOOST_PP_SEQ_SIZE_135 # define BOOST_PP_SEQ_SIZE_135(_) BOOST_PP_SEQ_SIZE_136 # define BOOST_PP_SEQ_SIZE_136(_) BOOST_PP_SEQ_SIZE_137 # define BOOST_PP_SEQ_SIZE_137(_) BOOST_PP_SEQ_SIZE_138 # define BOOST_PP_SEQ_SIZE_138(_) BOOST_PP_SEQ_SIZE_139 # define BOOST_PP_SEQ_SIZE_139(_) BOOST_PP_SEQ_SIZE_140 # define BOOST_PP_SEQ_SIZE_140(_) BOOST_PP_SEQ_SIZE_141 # define BOOST_PP_SEQ_SIZE_141(_) BOOST_PP_SEQ_SIZE_142 # define BOOST_PP_SEQ_SIZE_142(_) BOOST_PP_SEQ_SIZE_143 # define BOOST_PP_SEQ_SIZE_143(_) BOOST_PP_SEQ_SIZE_144 # define BOOST_PP_SEQ_SIZE_144(_) BOOST_PP_SEQ_SIZE_145 # define BOOST_PP_SEQ_SIZE_145(_) BOOST_PP_SEQ_SIZE_146 # define BOOST_PP_SEQ_SIZE_146(_) BOOST_PP_SEQ_SIZE_147 # define BOOST_PP_SEQ_SIZE_147(_) BOOST_PP_SEQ_SIZE_148 # define BOOST_PP_SEQ_SIZE_148(_) BOOST_PP_SEQ_SIZE_149 # define BOOST_PP_SEQ_SIZE_149(_) BOOST_PP_SEQ_SIZE_150 # define BOOST_PP_SEQ_SIZE_150(_) BOOST_PP_SEQ_SIZE_151 # define BOOST_PP_SEQ_SIZE_151(_) BOOST_PP_SEQ_SIZE_152 # define BOOST_PP_SEQ_SIZE_152(_) BOOST_PP_SEQ_SIZE_153 # define BOOST_PP_SEQ_SIZE_153(_) BOOST_PP_SEQ_SIZE_154 # define BOOST_PP_SEQ_SIZE_154(_) BOOST_PP_SEQ_SIZE_155 # define BOOST_PP_SEQ_SIZE_155(_) BOOST_PP_SEQ_SIZE_156 # define BOOST_PP_SEQ_SIZE_156(_) BOOST_PP_SEQ_SIZE_157 # define BOOST_PP_SEQ_SIZE_157(_) BOOST_PP_SEQ_SIZE_158 # define BOOST_PP_SEQ_SIZE_158(_) BOOST_PP_SEQ_SIZE_159 # define BOOST_PP_SEQ_SIZE_159(_) BOOST_PP_SEQ_SIZE_160 # define BOOST_PP_SEQ_SIZE_160(_) BOOST_PP_SEQ_SIZE_161 # define BOOST_PP_SEQ_SIZE_161(_) BOOST_PP_SEQ_SIZE_162 # define BOOST_PP_SEQ_SIZE_162(_) BOOST_PP_SEQ_SIZE_163 # define BOOST_PP_SEQ_SIZE_163(_) BOOST_PP_SEQ_SIZE_164 # define BOOST_PP_SEQ_SIZE_164(_) BOOST_PP_SEQ_SIZE_165 # define BOOST_PP_SEQ_SIZE_165(_) BOOST_PP_SEQ_SIZE_166 # define BOOST_PP_SEQ_SIZE_166(_) BOOST_PP_SEQ_SIZE_167 # define BOOST_PP_SEQ_SIZE_167(_) BOOST_PP_SEQ_SIZE_168 # define BOOST_PP_SEQ_SIZE_168(_) BOOST_PP_SEQ_SIZE_169 # define BOOST_PP_SEQ_SIZE_169(_) BOOST_PP_SEQ_SIZE_170 # define BOOST_PP_SEQ_SIZE_170(_) BOOST_PP_SEQ_SIZE_171 # define BOOST_PP_SEQ_SIZE_171(_) BOOST_PP_SEQ_SIZE_172 # define BOOST_PP_SEQ_SIZE_172(_) BOOST_PP_SEQ_SIZE_173 # define BOOST_PP_SEQ_SIZE_173(_) BOOST_PP_SEQ_SIZE_174 # define BOOST_PP_SEQ_SIZE_174(_) BOOST_PP_SEQ_SIZE_175 # define BOOST_PP_SEQ_SIZE_175(_) BOOST_PP_SEQ_SIZE_176 # define BOOST_PP_SEQ_SIZE_176(_) BOOST_PP_SEQ_SIZE_177 # define BOOST_PP_SEQ_SIZE_177(_) BOOST_PP_SEQ_SIZE_178 # define BOOST_PP_SEQ_SIZE_178(_) BOOST_PP_SEQ_SIZE_179 # define BOOST_PP_SEQ_SIZE_179(_) BOOST_PP_SEQ_SIZE_180 # define BOOST_PP_SEQ_SIZE_180(_) BOOST_PP_SEQ_SIZE_181 # define BOOST_PP_SEQ_SIZE_181(_) BOOST_PP_SEQ_SIZE_182 # define BOOST_PP_SEQ_SIZE_182(_) BOOST_PP_SEQ_SIZE_183 # define BOOST_PP_SEQ_SIZE_183(_) BOOST_PP_SEQ_SIZE_184 # define BOOST_PP_SEQ_SIZE_184(_) BOOST_PP_SEQ_SIZE_185 # define BOOST_PP_SEQ_SIZE_185(_) BOOST_PP_SEQ_SIZE_186 # define BOOST_PP_SEQ_SIZE_186(_) BOOST_PP_SEQ_SIZE_187 # define BOOST_PP_SEQ_SIZE_187(_) BOOST_PP_SEQ_SIZE_188 # define BOOST_PP_SEQ_SIZE_188(_) BOOST_PP_SEQ_SIZE_189 # define BOOST_PP_SEQ_SIZE_189(_) BOOST_PP_SEQ_SIZE_190 # define BOOST_PP_SEQ_SIZE_190(_) BOOST_PP_SEQ_SIZE_191 # define BOOST_PP_SEQ_SIZE_191(_) BOOST_PP_SEQ_SIZE_192 # define BOOST_PP_SEQ_SIZE_192(_) BOOST_PP_SEQ_SIZE_193 # define BOOST_PP_SEQ_SIZE_193(_) BOOST_PP_SEQ_SIZE_194 # define BOOST_PP_SEQ_SIZE_194(_) BOOST_PP_SEQ_SIZE_195 # define BOOST_PP_SEQ_SIZE_195(_) BOOST_PP_SEQ_SIZE_196 # define BOOST_PP_SEQ_SIZE_196(_) BOOST_PP_SEQ_SIZE_197 # define BOOST_PP_SEQ_SIZE_197(_) BOOST_PP_SEQ_SIZE_198 # define BOOST_PP_SEQ_SIZE_198(_) BOOST_PP_SEQ_SIZE_199 # define BOOST_PP_SEQ_SIZE_199(_) BOOST_PP_SEQ_SIZE_200 # define BOOST_PP_SEQ_SIZE_200(_) BOOST_PP_SEQ_SIZE_201 # define BOOST_PP_SEQ_SIZE_201(_) BOOST_PP_SEQ_SIZE_202 # define BOOST_PP_SEQ_SIZE_202(_) BOOST_PP_SEQ_SIZE_203 # define BOOST_PP_SEQ_SIZE_203(_) BOOST_PP_SEQ_SIZE_204 # define BOOST_PP_SEQ_SIZE_204(_) BOOST_PP_SEQ_SIZE_205 # define BOOST_PP_SEQ_SIZE_205(_) BOOST_PP_SEQ_SIZE_206 # define BOOST_PP_SEQ_SIZE_206(_) BOOST_PP_SEQ_SIZE_207 # define BOOST_PP_SEQ_SIZE_207(_) BOOST_PP_SEQ_SIZE_208 # define BOOST_PP_SEQ_SIZE_208(_) BOOST_PP_SEQ_SIZE_209 # define BOOST_PP_SEQ_SIZE_209(_) BOOST_PP_SEQ_SIZE_210 # define BOOST_PP_SEQ_SIZE_210(_) BOOST_PP_SEQ_SIZE_211 # define BOOST_PP_SEQ_SIZE_211(_) BOOST_PP_SEQ_SIZE_212 # define BOOST_PP_SEQ_SIZE_212(_) BOOST_PP_SEQ_SIZE_213 # define BOOST_PP_SEQ_SIZE_213(_) BOOST_PP_SEQ_SIZE_214 # define BOOST_PP_SEQ_SIZE_214(_) BOOST_PP_SEQ_SIZE_215 # define BOOST_PP_SEQ_SIZE_215(_) BOOST_PP_SEQ_SIZE_216 # define BOOST_PP_SEQ_SIZE_216(_) BOOST_PP_SEQ_SIZE_217 # define BOOST_PP_SEQ_SIZE_217(_) BOOST_PP_SEQ_SIZE_218 # define BOOST_PP_SEQ_SIZE_218(_) BOOST_PP_SEQ_SIZE_219 # define BOOST_PP_SEQ_SIZE_219(_) BOOST_PP_SEQ_SIZE_220 # define BOOST_PP_SEQ_SIZE_220(_) BOOST_PP_SEQ_SIZE_221 # define BOOST_PP_SEQ_SIZE_221(_) BOOST_PP_SEQ_SIZE_222 # define BOOST_PP_SEQ_SIZE_222(_) BOOST_PP_SEQ_SIZE_223 # define BOOST_PP_SEQ_SIZE_223(_) BOOST_PP_SEQ_SIZE_224 # define BOOST_PP_SEQ_SIZE_224(_) BOOST_PP_SEQ_SIZE_225 # define BOOST_PP_SEQ_SIZE_225(_) BOOST_PP_SEQ_SIZE_226 # define BOOST_PP_SEQ_SIZE_226(_) BOOST_PP_SEQ_SIZE_227 # define BOOST_PP_SEQ_SIZE_227(_) BOOST_PP_SEQ_SIZE_228 # define BOOST_PP_SEQ_SIZE_228(_) BOOST_PP_SEQ_SIZE_229 # define BOOST_PP_SEQ_SIZE_229(_) BOOST_PP_SEQ_SIZE_230 # define BOOST_PP_SEQ_SIZE_230(_) BOOST_PP_SEQ_SIZE_231 # define BOOST_PP_SEQ_SIZE_231(_) BOOST_PP_SEQ_SIZE_232 # define BOOST_PP_SEQ_SIZE_232(_) BOOST_PP_SEQ_SIZE_233 # define BOOST_PP_SEQ_SIZE_233(_) BOOST_PP_SEQ_SIZE_234 # define BOOST_PP_SEQ_SIZE_234(_) BOOST_PP_SEQ_SIZE_235 # define BOOST_PP_SEQ_SIZE_235(_) BOOST_PP_SEQ_SIZE_236 # define BOOST_PP_SEQ_SIZE_236(_) BOOST_PP_SEQ_SIZE_237 # define BOOST_PP_SEQ_SIZE_237(_) BOOST_PP_SEQ_SIZE_238 # define BOOST_PP_SEQ_SIZE_238(_) BOOST_PP_SEQ_SIZE_239 # define BOOST_PP_SEQ_SIZE_239(_) BOOST_PP_SEQ_SIZE_240 # define BOOST_PP_SEQ_SIZE_240(_) BOOST_PP_SEQ_SIZE_241 # define BOOST_PP_SEQ_SIZE_241(_) BOOST_PP_SEQ_SIZE_242 # define BOOST_PP_SEQ_SIZE_242(_) BOOST_PP_SEQ_SIZE_243 # define BOOST_PP_SEQ_SIZE_243(_) BOOST_PP_SEQ_SIZE_244 # define BOOST_PP_SEQ_SIZE_244(_) BOOST_PP_SEQ_SIZE_245 # define BOOST_PP_SEQ_SIZE_245(_) BOOST_PP_SEQ_SIZE_246 # define BOOST_PP_SEQ_SIZE_246(_) BOOST_PP_SEQ_SIZE_247 # define BOOST_PP_SEQ_SIZE_247(_) BOOST_PP_SEQ_SIZE_248 # define BOOST_PP_SEQ_SIZE_248(_) BOOST_PP_SEQ_SIZE_249 # define BOOST_PP_SEQ_SIZE_249(_) BOOST_PP_SEQ_SIZE_250 # define BOOST_PP_SEQ_SIZE_250(_) BOOST_PP_SEQ_SIZE_251 # define BOOST_PP_SEQ_SIZE_251(_) BOOST_PP_SEQ_SIZE_252 # define BOOST_PP_SEQ_SIZE_252(_) BOOST_PP_SEQ_SIZE_253 # define BOOST_PP_SEQ_SIZE_253(_) BOOST_PP_SEQ_SIZE_254 # define BOOST_PP_SEQ_SIZE_254(_) BOOST_PP_SEQ_SIZE_255 # define BOOST_PP_SEQ_SIZE_255(_) BOOST_PP_SEQ_SIZE_256 # define BOOST_PP_SEQ_SIZE_256(_) BOOST_PP_SEQ_SIZE_257 # # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_0 0 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_1 1 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_2 2 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_3 3 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_4 4 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_5 5 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_6 6 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_7 7 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_8 8 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_9 9 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_10 10 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_11 11 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_12 12 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_13 13 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_14 14 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_15 15 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_16 16 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_17 17 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_18 18 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_19 19 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_20 20 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_21 21 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_22 22 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_23 23 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_24 24 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_25 25 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_26 26 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_27 27 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_28 28 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_29 29 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_30 30 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_31 31 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_32 32 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_33 33 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_34 34 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_35 35 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_36 36 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_37 37 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_38 38 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_39 39 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_40 40 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_41 41 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_42 42 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_43 43 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_44 44 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_45 45 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_46 46 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_47 47 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_48 48 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_49 49 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_50 50 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_51 51 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_52 52 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_53 53 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_54 54 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_55 55 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_56 56 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_57 57 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_58 58 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_59 59 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_60 60 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_61 61 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_62 62 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_63 63 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_64 64 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_65 65 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_66 66 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_67 67 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_68 68 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_69 69 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_70 70 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_71 71 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_72 72 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_73 73 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_74 74 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_75 75 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_76 76 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_77 77 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_78 78 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_79 79 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_80 80 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_81 81 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_82 82 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_83 83 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_84 84 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_85 85 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_86 86 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_87 87 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_88 88 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_89 89 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_90 90 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_91 91 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_92 92 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_93 93 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_94 94 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_95 95 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_96 96 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_97 97 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_98 98 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_99 99 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_100 100 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_101 101 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_102 102 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_103 103 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_104 104 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_105 105 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_106 106 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_107 107 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_108 108 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_109 109 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_110 110 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_111 111 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_112 112 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_113 113 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_114 114 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_115 115 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_116 116 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_117 117 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_118 118 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_119 119 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_120 120 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_121 121 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_122 122 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_123 123 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_124 124 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_125 125 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_126 126 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_127 127 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_128 128 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_129 129 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_130 130 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_131 131 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_132 132 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_133 133 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_134 134 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_135 135 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_136 136 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_137 137 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_138 138 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_139 139 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_140 140 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_141 141 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_142 142 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_143 143 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_144 144 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_145 145 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_146 146 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_147 147 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_148 148 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_149 149 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_150 150 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_151 151 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_152 152 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_153 153 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_154 154 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_155 155 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_156 156 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_157 157 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_158 158 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_159 159 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_160 160 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_161 161 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_162 162 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_163 163 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_164 164 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_165 165 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_166 166 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_167 167 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_168 168 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_169 169 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_170 170 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_171 171 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_172 172 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_173 173 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_174 174 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_175 175 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_176 176 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_177 177 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_178 178 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_179 179 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_180 180 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_181 181 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_182 182 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_183 183 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_184 184 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_185 185 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_186 186 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_187 187 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_188 188 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_189 189 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_190 190 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_191 191 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_192 192 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_193 193 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_194 194 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_195 195 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_196 196 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_197 197 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_198 198 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_199 199 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_200 200 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_201 201 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_202 202 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_203 203 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_204 204 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_205 205 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_206 206 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_207 207 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_208 208 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_209 209 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_210 210 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_211 211 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_212 212 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_213 213 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_214 214 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_215 215 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_216 216 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_217 217 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_218 218 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_219 219 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_220 220 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_221 221 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_222 222 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_223 223 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_224 224 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_225 225 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_226 226 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_227 227 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_228 228 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_229 229 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_230 230 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_231 231 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_232 232 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_233 233 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_234 234 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_235 235 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_236 236 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_237 237 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_238 238 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_239 239 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_240 240 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_241 241 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_242 242 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_243 243 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_244 244 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_245 245 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_246 246 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_247 247 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_248 248 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_249 249 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_250 250 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_251 251 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_252 252 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_253 253 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_254 254 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_255 255 # define BOOST_PP_SEQ_SIZE_BOOST_PP_SEQ_SIZE_256 256 # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/remove.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/remo0000644000175000017500000000240711344301502031650 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_REMOVE_HPP # define BOOST_PREPROCESSOR_SEQ_REMOVE_HPP # # include # include # include # include # # /* BOOST_PP_SEQ_REMOVE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_REMOVE(seq, i) BOOST_PP_SEQ_FIRST_N(i, seq) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq) # else # define BOOST_PP_SEQ_REMOVE(seq, i) BOOST_PP_SEQ_REMOVE_I(seq, i) # define BOOST_PP_SEQ_REMOVE_I(seq, i) BOOST_PP_SEQ_FIRST_N(i, seq) BOOST_PP_SEQ_REST_N(BOOST_PP_INC(i), seq) # endif # # endif ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/for_each_product.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/for_0000644000175000017500000003040711344301502031634 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FOR_EACH_PRODUCT_HPP # define BOOST_PREPROCESSOR_SEQ_FOR_EACH_PRODUCT_HPP # # include # include # include # include # include # include # include # include # # /* BOOST_PP_SEQ_FOR_EACH_PRODUCT */ # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT(macro, sets) BOOST_PP_SEQ_FOR_EACH_PRODUCT_E(BOOST_PP_FOR, macro, sets) # # /* BOOST_PP_SEQ_FOR_EACH_PRODUCT_R */ # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_R(r, macro, sets) BOOST_PP_SEQ_FOR_EACH_PRODUCT_E(BOOST_PP_FOR_ ## r, macro, sets) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_E(impl, macro, sets) impl((BOOST_PP_SEQ_HEAD(sets)(nil), BOOST_PP_SEQ_TAIL(sets)(nil), (nil), macro), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_0) # else # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_E(impl, macro, sets) BOOST_PP_SEQ_FOR_EACH_PRODUCT_E_I(impl, macro, sets) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_E_I(impl, macro, sets) impl((BOOST_PP_SEQ_HEAD(sets)(nil), BOOST_PP_SEQ_TAIL(sets)(nil), (nil), macro), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_0) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_P(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_P_I data # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_P_I(cset, rset, res, macro) BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(cset)) # else # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_P(r, data) BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(4, 0, data))) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_O(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_O_I data # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_O_I(cset, rset, res, macro) (BOOST_PP_SEQ_TAIL(cset), rset, res, macro) # else # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_O(r, data) (BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(4, 0, data)), BOOST_PP_TUPLE_ELEM(4, 1, data), BOOST_PP_TUPLE_ELEM(4, 2, data), BOOST_PP_TUPLE_ELEM(4, 3, data)) # endif # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, i) BOOST_PP_IF(BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(BOOST_PP_TUPLE_ELEM(4, 1, data))), BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_ ## i, BOOST_PP_SEQ_FOR_EACH_PRODUCT_I) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_I(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_I_I(r, BOOST_PP_TUPLE_ELEM(4, 0, data), BOOST_PP_TUPLE_ELEM(4, 1, data), BOOST_PP_TUPLE_ELEM(4, 2, data), BOOST_PP_TUPLE_ELEM(4, 3, data)) # else # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_I(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_I_IM(r, BOOST_PP_TUPLE_REM_4 data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_I_IM(r, im) BOOST_PP_SEQ_FOR_EACH_PRODUCT_I_I(r, im) # endif # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_I_I(r, cset, rset, res, macro) macro(r, BOOST_PP_SEQ_TAIL(res (BOOST_PP_SEQ_HEAD(cset)))) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_H_I data # else # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_H_I(BOOST_PP_TUPLE_ELEM(4, 0, data), BOOST_PP_TUPLE_ELEM(4, 1, data), BOOST_PP_TUPLE_ELEM(4, 2, data), BOOST_PP_TUPLE_ELEM(4, 3, data)) # endif # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_H_I(cset, rset, res, macro) (BOOST_PP_SEQ_HEAD(rset)(nil), BOOST_PP_SEQ_TAIL(rset), res (BOOST_PP_SEQ_HEAD(cset)), macro) # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_0(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 0)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_1(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 1)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_2(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 2)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_3(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 3)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_4(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 4)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_5(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 5)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_6(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 6)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_7(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 7)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_8(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 8)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_9(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 9)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_10(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 10)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_11(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 11)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_12(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 12)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_13(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 13)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_14(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 14)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_15(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 15)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_16(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 16)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_17(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 17)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_18(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 18)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_19(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 19)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_20(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 20)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_21(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 21)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_22(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 22)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_23(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 23)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_24(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 24)(r, data) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_25(r, data) BOOST_PP_SEQ_FOR_EACH_PRODUCT_C(data, 25)(r, data) # # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_0(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_1) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_1(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_2) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_2(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_3) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_3(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_4) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_4(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_5) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_5(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_6) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_6(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_7) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_7(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_8) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_8(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_9) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_9(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_10) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_10(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_11) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_11(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_12) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_12(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_13) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_13(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_14) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_14(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_15) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_15(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_16) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_16(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_17) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_17(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_18) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_18(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_19) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_19(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_20) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_20(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_21) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_21(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_22) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_22(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_23) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_23(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_24) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_24(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_25) # define BOOST_PP_SEQ_FOR_EACH_PRODUCT_N_25(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_SEQ_FOR_EACH_PRODUCT_H(data), BOOST_PP_SEQ_FOR_EACH_PRODUCT_P, BOOST_PP_SEQ_FOR_EACH_PRODUCT_O, BOOST_PP_SEQ_FOR_EACH_PRODUCT_M_26) # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/transform.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/tran0000644000175000017500000000506511344301502031655 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_TRANSFORM_HPP # define BOOST_PREPROCESSOR_SEQ_TRANSFORM_HPP # # include # include # include # include # include # # /* BOOST_PP_SEQ_TRANSFORM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_TRANSFORM(op, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_TRANSFORM_O, (op, data, (nil)), seq))) # else # define BOOST_PP_SEQ_TRANSFORM(op, data, seq) BOOST_PP_SEQ_TRANSFORM_I(op, data, seq) # define BOOST_PP_SEQ_TRANSFORM_I(op, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT(BOOST_PP_SEQ_TRANSFORM_O, (op, data, (nil)), seq))) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_SEQ_TRANSFORM_O(s, state, elem) BOOST_PP_SEQ_TRANSFORM_O_IM(s, BOOST_PP_TUPLE_REM_3 state, elem) # define BOOST_PP_SEQ_TRANSFORM_O_IM(s, im, elem) BOOST_PP_SEQ_TRANSFORM_O_I(s, im, elem) # else # define BOOST_PP_SEQ_TRANSFORM_O(s, state, elem) BOOST_PP_SEQ_TRANSFORM_O_I(s, BOOST_PP_TUPLE_ELEM(3, 0, state), BOOST_PP_TUPLE_ELEM(3, 1, state), BOOST_PP_TUPLE_ELEM(3, 2, state), elem) # endif # # define BOOST_PP_SEQ_TRANSFORM_O_I(s, op, data, res, elem) (op, data, res (op(s, data, elem))) # # /* BOOST_PP_SEQ_TRANSFORM_S */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_TRANSFORM_S(s, op, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_TRANSFORM_O, (op, data, (nil)), seq))) # else # define BOOST_PP_SEQ_TRANSFORM_S(s, op, data, seq) BOOST_PP_SEQ_TRANSFORM_S_I(s, op, data, seq) # define BOOST_PP_SEQ_TRANSFORM_S_I(s, op, data, seq) BOOST_PP_SEQ_TAIL(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_SEQ_FOLD_LEFT_ ## s(BOOST_PP_SEQ_TRANSFORM_O, (op, data, (nil)), seq))) # endif # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/insert.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/inse0000644000175000017500000000233711344301502031646 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_INSERT_HPP # define BOOST_PREPROCESSOR_SEQ_INSERT_HPP # # include # include # include # # /* BOOST_PP_SEQ_INSERT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_INSERT(seq, i, elem) BOOST_PP_SEQ_FIRST_N(i, seq) (elem) BOOST_PP_SEQ_REST_N(i, seq) # else # define BOOST_PP_SEQ_INSERT(seq, i, elem) BOOST_PP_SEQ_INSERT_I(seq, i, elem) # define BOOST_PP_SEQ_INSERT_I(seq, i, elem) BOOST_PP_SEQ_FIRST_N(i, seq) (elem) BOOST_PP_SEQ_REST_N(i, seq) # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/elem.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/elem0000644000175000017500000003720411344301502031633 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_ELEM_HPP # define BOOST_PREPROCESSOR_SEQ_ELEM_HPP # # include # include # # /* BOOST_PP_SEQ_ELEM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_ELEM(i, seq) BOOST_PP_SEQ_ELEM_I(i, seq) # else # define BOOST_PP_SEQ_ELEM(i, seq) BOOST_PP_SEQ_ELEM_I((i, seq)) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_SEQ_ELEM_I(i, seq) BOOST_PP_SEQ_ELEM_II((BOOST_PP_SEQ_ELEM_ ## i seq)) # define BOOST_PP_SEQ_ELEM_II(res) BOOST_PP_SEQ_ELEM_IV(BOOST_PP_SEQ_ELEM_III res) # define BOOST_PP_SEQ_ELEM_III(x, _) x BOOST_PP_EMPTY() # define BOOST_PP_SEQ_ELEM_IV(x) x # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_ELEM_I(par) BOOST_PP_SEQ_ELEM_II ## par # define BOOST_PP_SEQ_ELEM_II(i, seq) BOOST_PP_SEQ_ELEM_III(BOOST_PP_SEQ_ELEM_ ## i ## seq) # define BOOST_PP_SEQ_ELEM_III(im) BOOST_PP_SEQ_ELEM_IV(im) # define BOOST_PP_SEQ_ELEM_IV(x, _) x # else # define BOOST_PP_SEQ_ELEM_I(i, seq) BOOST_PP_SEQ_ELEM_II(BOOST_PP_SEQ_ELEM_ ## i seq) # define BOOST_PP_SEQ_ELEM_II(im) BOOST_PP_SEQ_ELEM_III(im) # define BOOST_PP_SEQ_ELEM_III(x, _) x # endif # # define BOOST_PP_SEQ_ELEM_0(x) x, BOOST_PP_NIL # define BOOST_PP_SEQ_ELEM_1(_) BOOST_PP_SEQ_ELEM_0 # define BOOST_PP_SEQ_ELEM_2(_) BOOST_PP_SEQ_ELEM_1 # define BOOST_PP_SEQ_ELEM_3(_) BOOST_PP_SEQ_ELEM_2 # define BOOST_PP_SEQ_ELEM_4(_) BOOST_PP_SEQ_ELEM_3 # define BOOST_PP_SEQ_ELEM_5(_) BOOST_PP_SEQ_ELEM_4 # define BOOST_PP_SEQ_ELEM_6(_) BOOST_PP_SEQ_ELEM_5 # define BOOST_PP_SEQ_ELEM_7(_) BOOST_PP_SEQ_ELEM_6 # define BOOST_PP_SEQ_ELEM_8(_) BOOST_PP_SEQ_ELEM_7 # define BOOST_PP_SEQ_ELEM_9(_) BOOST_PP_SEQ_ELEM_8 # define BOOST_PP_SEQ_ELEM_10(_) BOOST_PP_SEQ_ELEM_9 # define BOOST_PP_SEQ_ELEM_11(_) BOOST_PP_SEQ_ELEM_10 # define BOOST_PP_SEQ_ELEM_12(_) BOOST_PP_SEQ_ELEM_11 # define BOOST_PP_SEQ_ELEM_13(_) BOOST_PP_SEQ_ELEM_12 # define BOOST_PP_SEQ_ELEM_14(_) BOOST_PP_SEQ_ELEM_13 # define BOOST_PP_SEQ_ELEM_15(_) BOOST_PP_SEQ_ELEM_14 # define BOOST_PP_SEQ_ELEM_16(_) BOOST_PP_SEQ_ELEM_15 # define BOOST_PP_SEQ_ELEM_17(_) BOOST_PP_SEQ_ELEM_16 # define BOOST_PP_SEQ_ELEM_18(_) BOOST_PP_SEQ_ELEM_17 # define BOOST_PP_SEQ_ELEM_19(_) BOOST_PP_SEQ_ELEM_18 # define BOOST_PP_SEQ_ELEM_20(_) BOOST_PP_SEQ_ELEM_19 # define BOOST_PP_SEQ_ELEM_21(_) BOOST_PP_SEQ_ELEM_20 # define BOOST_PP_SEQ_ELEM_22(_) BOOST_PP_SEQ_ELEM_21 # define BOOST_PP_SEQ_ELEM_23(_) BOOST_PP_SEQ_ELEM_22 # define BOOST_PP_SEQ_ELEM_24(_) BOOST_PP_SEQ_ELEM_23 # define BOOST_PP_SEQ_ELEM_25(_) BOOST_PP_SEQ_ELEM_24 # define BOOST_PP_SEQ_ELEM_26(_) BOOST_PP_SEQ_ELEM_25 # define BOOST_PP_SEQ_ELEM_27(_) BOOST_PP_SEQ_ELEM_26 # define BOOST_PP_SEQ_ELEM_28(_) BOOST_PP_SEQ_ELEM_27 # define BOOST_PP_SEQ_ELEM_29(_) BOOST_PP_SEQ_ELEM_28 # define BOOST_PP_SEQ_ELEM_30(_) BOOST_PP_SEQ_ELEM_29 # define BOOST_PP_SEQ_ELEM_31(_) BOOST_PP_SEQ_ELEM_30 # define BOOST_PP_SEQ_ELEM_32(_) BOOST_PP_SEQ_ELEM_31 # define BOOST_PP_SEQ_ELEM_33(_) BOOST_PP_SEQ_ELEM_32 # define BOOST_PP_SEQ_ELEM_34(_) BOOST_PP_SEQ_ELEM_33 # define BOOST_PP_SEQ_ELEM_35(_) BOOST_PP_SEQ_ELEM_34 # define BOOST_PP_SEQ_ELEM_36(_) BOOST_PP_SEQ_ELEM_35 # define BOOST_PP_SEQ_ELEM_37(_) BOOST_PP_SEQ_ELEM_36 # define BOOST_PP_SEQ_ELEM_38(_) BOOST_PP_SEQ_ELEM_37 # define BOOST_PP_SEQ_ELEM_39(_) BOOST_PP_SEQ_ELEM_38 # define BOOST_PP_SEQ_ELEM_40(_) BOOST_PP_SEQ_ELEM_39 # define BOOST_PP_SEQ_ELEM_41(_) BOOST_PP_SEQ_ELEM_40 # define BOOST_PP_SEQ_ELEM_42(_) BOOST_PP_SEQ_ELEM_41 # define BOOST_PP_SEQ_ELEM_43(_) BOOST_PP_SEQ_ELEM_42 # define BOOST_PP_SEQ_ELEM_44(_) BOOST_PP_SEQ_ELEM_43 # define BOOST_PP_SEQ_ELEM_45(_) BOOST_PP_SEQ_ELEM_44 # define BOOST_PP_SEQ_ELEM_46(_) BOOST_PP_SEQ_ELEM_45 # define BOOST_PP_SEQ_ELEM_47(_) BOOST_PP_SEQ_ELEM_46 # define BOOST_PP_SEQ_ELEM_48(_) BOOST_PP_SEQ_ELEM_47 # define BOOST_PP_SEQ_ELEM_49(_) BOOST_PP_SEQ_ELEM_48 # define BOOST_PP_SEQ_ELEM_50(_) BOOST_PP_SEQ_ELEM_49 # define BOOST_PP_SEQ_ELEM_51(_) BOOST_PP_SEQ_ELEM_50 # define BOOST_PP_SEQ_ELEM_52(_) BOOST_PP_SEQ_ELEM_51 # define BOOST_PP_SEQ_ELEM_53(_) BOOST_PP_SEQ_ELEM_52 # define BOOST_PP_SEQ_ELEM_54(_) BOOST_PP_SEQ_ELEM_53 # define BOOST_PP_SEQ_ELEM_55(_) BOOST_PP_SEQ_ELEM_54 # define BOOST_PP_SEQ_ELEM_56(_) BOOST_PP_SEQ_ELEM_55 # define BOOST_PP_SEQ_ELEM_57(_) BOOST_PP_SEQ_ELEM_56 # define BOOST_PP_SEQ_ELEM_58(_) BOOST_PP_SEQ_ELEM_57 # define BOOST_PP_SEQ_ELEM_59(_) BOOST_PP_SEQ_ELEM_58 # define BOOST_PP_SEQ_ELEM_60(_) BOOST_PP_SEQ_ELEM_59 # define BOOST_PP_SEQ_ELEM_61(_) BOOST_PP_SEQ_ELEM_60 # define BOOST_PP_SEQ_ELEM_62(_) BOOST_PP_SEQ_ELEM_61 # define BOOST_PP_SEQ_ELEM_63(_) BOOST_PP_SEQ_ELEM_62 # define BOOST_PP_SEQ_ELEM_64(_) BOOST_PP_SEQ_ELEM_63 # define BOOST_PP_SEQ_ELEM_65(_) BOOST_PP_SEQ_ELEM_64 # define BOOST_PP_SEQ_ELEM_66(_) BOOST_PP_SEQ_ELEM_65 # define BOOST_PP_SEQ_ELEM_67(_) BOOST_PP_SEQ_ELEM_66 # define BOOST_PP_SEQ_ELEM_68(_) BOOST_PP_SEQ_ELEM_67 # define BOOST_PP_SEQ_ELEM_69(_) BOOST_PP_SEQ_ELEM_68 # define BOOST_PP_SEQ_ELEM_70(_) BOOST_PP_SEQ_ELEM_69 # define BOOST_PP_SEQ_ELEM_71(_) BOOST_PP_SEQ_ELEM_70 # define BOOST_PP_SEQ_ELEM_72(_) BOOST_PP_SEQ_ELEM_71 # define BOOST_PP_SEQ_ELEM_73(_) BOOST_PP_SEQ_ELEM_72 # define BOOST_PP_SEQ_ELEM_74(_) BOOST_PP_SEQ_ELEM_73 # define BOOST_PP_SEQ_ELEM_75(_) BOOST_PP_SEQ_ELEM_74 # define BOOST_PP_SEQ_ELEM_76(_) BOOST_PP_SEQ_ELEM_75 # define BOOST_PP_SEQ_ELEM_77(_) BOOST_PP_SEQ_ELEM_76 # define BOOST_PP_SEQ_ELEM_78(_) BOOST_PP_SEQ_ELEM_77 # define BOOST_PP_SEQ_ELEM_79(_) BOOST_PP_SEQ_ELEM_78 # define BOOST_PP_SEQ_ELEM_80(_) BOOST_PP_SEQ_ELEM_79 # define BOOST_PP_SEQ_ELEM_81(_) BOOST_PP_SEQ_ELEM_80 # define BOOST_PP_SEQ_ELEM_82(_) BOOST_PP_SEQ_ELEM_81 # define BOOST_PP_SEQ_ELEM_83(_) BOOST_PP_SEQ_ELEM_82 # define BOOST_PP_SEQ_ELEM_84(_) BOOST_PP_SEQ_ELEM_83 # define BOOST_PP_SEQ_ELEM_85(_) BOOST_PP_SEQ_ELEM_84 # define BOOST_PP_SEQ_ELEM_86(_) BOOST_PP_SEQ_ELEM_85 # define BOOST_PP_SEQ_ELEM_87(_) BOOST_PP_SEQ_ELEM_86 # define BOOST_PP_SEQ_ELEM_88(_) BOOST_PP_SEQ_ELEM_87 # define BOOST_PP_SEQ_ELEM_89(_) BOOST_PP_SEQ_ELEM_88 # define BOOST_PP_SEQ_ELEM_90(_) BOOST_PP_SEQ_ELEM_89 # define BOOST_PP_SEQ_ELEM_91(_) BOOST_PP_SEQ_ELEM_90 # define BOOST_PP_SEQ_ELEM_92(_) BOOST_PP_SEQ_ELEM_91 # define BOOST_PP_SEQ_ELEM_93(_) BOOST_PP_SEQ_ELEM_92 # define BOOST_PP_SEQ_ELEM_94(_) BOOST_PP_SEQ_ELEM_93 # define BOOST_PP_SEQ_ELEM_95(_) BOOST_PP_SEQ_ELEM_94 # define BOOST_PP_SEQ_ELEM_96(_) BOOST_PP_SEQ_ELEM_95 # define BOOST_PP_SEQ_ELEM_97(_) BOOST_PP_SEQ_ELEM_96 # define BOOST_PP_SEQ_ELEM_98(_) BOOST_PP_SEQ_ELEM_97 # define BOOST_PP_SEQ_ELEM_99(_) BOOST_PP_SEQ_ELEM_98 # define BOOST_PP_SEQ_ELEM_100(_) BOOST_PP_SEQ_ELEM_99 # define BOOST_PP_SEQ_ELEM_101(_) BOOST_PP_SEQ_ELEM_100 # define BOOST_PP_SEQ_ELEM_102(_) BOOST_PP_SEQ_ELEM_101 # define BOOST_PP_SEQ_ELEM_103(_) BOOST_PP_SEQ_ELEM_102 # define BOOST_PP_SEQ_ELEM_104(_) BOOST_PP_SEQ_ELEM_103 # define BOOST_PP_SEQ_ELEM_105(_) BOOST_PP_SEQ_ELEM_104 # define BOOST_PP_SEQ_ELEM_106(_) BOOST_PP_SEQ_ELEM_105 # define BOOST_PP_SEQ_ELEM_107(_) BOOST_PP_SEQ_ELEM_106 # define BOOST_PP_SEQ_ELEM_108(_) BOOST_PP_SEQ_ELEM_107 # define BOOST_PP_SEQ_ELEM_109(_) BOOST_PP_SEQ_ELEM_108 # define BOOST_PP_SEQ_ELEM_110(_) BOOST_PP_SEQ_ELEM_109 # define BOOST_PP_SEQ_ELEM_111(_) BOOST_PP_SEQ_ELEM_110 # define BOOST_PP_SEQ_ELEM_112(_) BOOST_PP_SEQ_ELEM_111 # define BOOST_PP_SEQ_ELEM_113(_) BOOST_PP_SEQ_ELEM_112 # define BOOST_PP_SEQ_ELEM_114(_) BOOST_PP_SEQ_ELEM_113 # define BOOST_PP_SEQ_ELEM_115(_) BOOST_PP_SEQ_ELEM_114 # define BOOST_PP_SEQ_ELEM_116(_) BOOST_PP_SEQ_ELEM_115 # define BOOST_PP_SEQ_ELEM_117(_) BOOST_PP_SEQ_ELEM_116 # define BOOST_PP_SEQ_ELEM_118(_) BOOST_PP_SEQ_ELEM_117 # define BOOST_PP_SEQ_ELEM_119(_) BOOST_PP_SEQ_ELEM_118 # define BOOST_PP_SEQ_ELEM_120(_) BOOST_PP_SEQ_ELEM_119 # define BOOST_PP_SEQ_ELEM_121(_) BOOST_PP_SEQ_ELEM_120 # define BOOST_PP_SEQ_ELEM_122(_) BOOST_PP_SEQ_ELEM_121 # define BOOST_PP_SEQ_ELEM_123(_) BOOST_PP_SEQ_ELEM_122 # define BOOST_PP_SEQ_ELEM_124(_) BOOST_PP_SEQ_ELEM_123 # define BOOST_PP_SEQ_ELEM_125(_) BOOST_PP_SEQ_ELEM_124 # define BOOST_PP_SEQ_ELEM_126(_) BOOST_PP_SEQ_ELEM_125 # define BOOST_PP_SEQ_ELEM_127(_) BOOST_PP_SEQ_ELEM_126 # define BOOST_PP_SEQ_ELEM_128(_) BOOST_PP_SEQ_ELEM_127 # define BOOST_PP_SEQ_ELEM_129(_) BOOST_PP_SEQ_ELEM_128 # define BOOST_PP_SEQ_ELEM_130(_) BOOST_PP_SEQ_ELEM_129 # define BOOST_PP_SEQ_ELEM_131(_) BOOST_PP_SEQ_ELEM_130 # define BOOST_PP_SEQ_ELEM_132(_) BOOST_PP_SEQ_ELEM_131 # define BOOST_PP_SEQ_ELEM_133(_) BOOST_PP_SEQ_ELEM_132 # define BOOST_PP_SEQ_ELEM_134(_) BOOST_PP_SEQ_ELEM_133 # define BOOST_PP_SEQ_ELEM_135(_) BOOST_PP_SEQ_ELEM_134 # define BOOST_PP_SEQ_ELEM_136(_) BOOST_PP_SEQ_ELEM_135 # define BOOST_PP_SEQ_ELEM_137(_) BOOST_PP_SEQ_ELEM_136 # define BOOST_PP_SEQ_ELEM_138(_) BOOST_PP_SEQ_ELEM_137 # define BOOST_PP_SEQ_ELEM_139(_) BOOST_PP_SEQ_ELEM_138 # define BOOST_PP_SEQ_ELEM_140(_) BOOST_PP_SEQ_ELEM_139 # define BOOST_PP_SEQ_ELEM_141(_) BOOST_PP_SEQ_ELEM_140 # define BOOST_PP_SEQ_ELEM_142(_) BOOST_PP_SEQ_ELEM_141 # define BOOST_PP_SEQ_ELEM_143(_) BOOST_PP_SEQ_ELEM_142 # define BOOST_PP_SEQ_ELEM_144(_) BOOST_PP_SEQ_ELEM_143 # define BOOST_PP_SEQ_ELEM_145(_) BOOST_PP_SEQ_ELEM_144 # define BOOST_PP_SEQ_ELEM_146(_) BOOST_PP_SEQ_ELEM_145 # define BOOST_PP_SEQ_ELEM_147(_) BOOST_PP_SEQ_ELEM_146 # define BOOST_PP_SEQ_ELEM_148(_) BOOST_PP_SEQ_ELEM_147 # define BOOST_PP_SEQ_ELEM_149(_) BOOST_PP_SEQ_ELEM_148 # define BOOST_PP_SEQ_ELEM_150(_) BOOST_PP_SEQ_ELEM_149 # define BOOST_PP_SEQ_ELEM_151(_) BOOST_PP_SEQ_ELEM_150 # define BOOST_PP_SEQ_ELEM_152(_) BOOST_PP_SEQ_ELEM_151 # define BOOST_PP_SEQ_ELEM_153(_) BOOST_PP_SEQ_ELEM_152 # define BOOST_PP_SEQ_ELEM_154(_) BOOST_PP_SEQ_ELEM_153 # define BOOST_PP_SEQ_ELEM_155(_) BOOST_PP_SEQ_ELEM_154 # define BOOST_PP_SEQ_ELEM_156(_) BOOST_PP_SEQ_ELEM_155 # define BOOST_PP_SEQ_ELEM_157(_) BOOST_PP_SEQ_ELEM_156 # define BOOST_PP_SEQ_ELEM_158(_) BOOST_PP_SEQ_ELEM_157 # define BOOST_PP_SEQ_ELEM_159(_) BOOST_PP_SEQ_ELEM_158 # define BOOST_PP_SEQ_ELEM_160(_) BOOST_PP_SEQ_ELEM_159 # define BOOST_PP_SEQ_ELEM_161(_) BOOST_PP_SEQ_ELEM_160 # define BOOST_PP_SEQ_ELEM_162(_) BOOST_PP_SEQ_ELEM_161 # define BOOST_PP_SEQ_ELEM_163(_) BOOST_PP_SEQ_ELEM_162 # define BOOST_PP_SEQ_ELEM_164(_) BOOST_PP_SEQ_ELEM_163 # define BOOST_PP_SEQ_ELEM_165(_) BOOST_PP_SEQ_ELEM_164 # define BOOST_PP_SEQ_ELEM_166(_) BOOST_PP_SEQ_ELEM_165 # define BOOST_PP_SEQ_ELEM_167(_) BOOST_PP_SEQ_ELEM_166 # define BOOST_PP_SEQ_ELEM_168(_) BOOST_PP_SEQ_ELEM_167 # define BOOST_PP_SEQ_ELEM_169(_) BOOST_PP_SEQ_ELEM_168 # define BOOST_PP_SEQ_ELEM_170(_) BOOST_PP_SEQ_ELEM_169 # define BOOST_PP_SEQ_ELEM_171(_) BOOST_PP_SEQ_ELEM_170 # define BOOST_PP_SEQ_ELEM_172(_) BOOST_PP_SEQ_ELEM_171 # define BOOST_PP_SEQ_ELEM_173(_) BOOST_PP_SEQ_ELEM_172 # define BOOST_PP_SEQ_ELEM_174(_) BOOST_PP_SEQ_ELEM_173 # define BOOST_PP_SEQ_ELEM_175(_) BOOST_PP_SEQ_ELEM_174 # define BOOST_PP_SEQ_ELEM_176(_) BOOST_PP_SEQ_ELEM_175 # define BOOST_PP_SEQ_ELEM_177(_) BOOST_PP_SEQ_ELEM_176 # define BOOST_PP_SEQ_ELEM_178(_) BOOST_PP_SEQ_ELEM_177 # define BOOST_PP_SEQ_ELEM_179(_) BOOST_PP_SEQ_ELEM_178 # define BOOST_PP_SEQ_ELEM_180(_) BOOST_PP_SEQ_ELEM_179 # define BOOST_PP_SEQ_ELEM_181(_) BOOST_PP_SEQ_ELEM_180 # define BOOST_PP_SEQ_ELEM_182(_) BOOST_PP_SEQ_ELEM_181 # define BOOST_PP_SEQ_ELEM_183(_) BOOST_PP_SEQ_ELEM_182 # define BOOST_PP_SEQ_ELEM_184(_) BOOST_PP_SEQ_ELEM_183 # define BOOST_PP_SEQ_ELEM_185(_) BOOST_PP_SEQ_ELEM_184 # define BOOST_PP_SEQ_ELEM_186(_) BOOST_PP_SEQ_ELEM_185 # define BOOST_PP_SEQ_ELEM_187(_) BOOST_PP_SEQ_ELEM_186 # define BOOST_PP_SEQ_ELEM_188(_) BOOST_PP_SEQ_ELEM_187 # define BOOST_PP_SEQ_ELEM_189(_) BOOST_PP_SEQ_ELEM_188 # define BOOST_PP_SEQ_ELEM_190(_) BOOST_PP_SEQ_ELEM_189 # define BOOST_PP_SEQ_ELEM_191(_) BOOST_PP_SEQ_ELEM_190 # define BOOST_PP_SEQ_ELEM_192(_) BOOST_PP_SEQ_ELEM_191 # define BOOST_PP_SEQ_ELEM_193(_) BOOST_PP_SEQ_ELEM_192 # define BOOST_PP_SEQ_ELEM_194(_) BOOST_PP_SEQ_ELEM_193 # define BOOST_PP_SEQ_ELEM_195(_) BOOST_PP_SEQ_ELEM_194 # define BOOST_PP_SEQ_ELEM_196(_) BOOST_PP_SEQ_ELEM_195 # define BOOST_PP_SEQ_ELEM_197(_) BOOST_PP_SEQ_ELEM_196 # define BOOST_PP_SEQ_ELEM_198(_) BOOST_PP_SEQ_ELEM_197 # define BOOST_PP_SEQ_ELEM_199(_) BOOST_PP_SEQ_ELEM_198 # define BOOST_PP_SEQ_ELEM_200(_) BOOST_PP_SEQ_ELEM_199 # define BOOST_PP_SEQ_ELEM_201(_) BOOST_PP_SEQ_ELEM_200 # define BOOST_PP_SEQ_ELEM_202(_) BOOST_PP_SEQ_ELEM_201 # define BOOST_PP_SEQ_ELEM_203(_) BOOST_PP_SEQ_ELEM_202 # define BOOST_PP_SEQ_ELEM_204(_) BOOST_PP_SEQ_ELEM_203 # define BOOST_PP_SEQ_ELEM_205(_) BOOST_PP_SEQ_ELEM_204 # define BOOST_PP_SEQ_ELEM_206(_) BOOST_PP_SEQ_ELEM_205 # define BOOST_PP_SEQ_ELEM_207(_) BOOST_PP_SEQ_ELEM_206 # define BOOST_PP_SEQ_ELEM_208(_) BOOST_PP_SEQ_ELEM_207 # define BOOST_PP_SEQ_ELEM_209(_) BOOST_PP_SEQ_ELEM_208 # define BOOST_PP_SEQ_ELEM_210(_) BOOST_PP_SEQ_ELEM_209 # define BOOST_PP_SEQ_ELEM_211(_) BOOST_PP_SEQ_ELEM_210 # define BOOST_PP_SEQ_ELEM_212(_) BOOST_PP_SEQ_ELEM_211 # define BOOST_PP_SEQ_ELEM_213(_) BOOST_PP_SEQ_ELEM_212 # define BOOST_PP_SEQ_ELEM_214(_) BOOST_PP_SEQ_ELEM_213 # define BOOST_PP_SEQ_ELEM_215(_) BOOST_PP_SEQ_ELEM_214 # define BOOST_PP_SEQ_ELEM_216(_) BOOST_PP_SEQ_ELEM_215 # define BOOST_PP_SEQ_ELEM_217(_) BOOST_PP_SEQ_ELEM_216 # define BOOST_PP_SEQ_ELEM_218(_) BOOST_PP_SEQ_ELEM_217 # define BOOST_PP_SEQ_ELEM_219(_) BOOST_PP_SEQ_ELEM_218 # define BOOST_PP_SEQ_ELEM_220(_) BOOST_PP_SEQ_ELEM_219 # define BOOST_PP_SEQ_ELEM_221(_) BOOST_PP_SEQ_ELEM_220 # define BOOST_PP_SEQ_ELEM_222(_) BOOST_PP_SEQ_ELEM_221 # define BOOST_PP_SEQ_ELEM_223(_) BOOST_PP_SEQ_ELEM_222 # define BOOST_PP_SEQ_ELEM_224(_) BOOST_PP_SEQ_ELEM_223 # define BOOST_PP_SEQ_ELEM_225(_) BOOST_PP_SEQ_ELEM_224 # define BOOST_PP_SEQ_ELEM_226(_) BOOST_PP_SEQ_ELEM_225 # define BOOST_PP_SEQ_ELEM_227(_) BOOST_PP_SEQ_ELEM_226 # define BOOST_PP_SEQ_ELEM_228(_) BOOST_PP_SEQ_ELEM_227 # define BOOST_PP_SEQ_ELEM_229(_) BOOST_PP_SEQ_ELEM_228 # define BOOST_PP_SEQ_ELEM_230(_) BOOST_PP_SEQ_ELEM_229 # define BOOST_PP_SEQ_ELEM_231(_) BOOST_PP_SEQ_ELEM_230 # define BOOST_PP_SEQ_ELEM_232(_) BOOST_PP_SEQ_ELEM_231 # define BOOST_PP_SEQ_ELEM_233(_) BOOST_PP_SEQ_ELEM_232 # define BOOST_PP_SEQ_ELEM_234(_) BOOST_PP_SEQ_ELEM_233 # define BOOST_PP_SEQ_ELEM_235(_) BOOST_PP_SEQ_ELEM_234 # define BOOST_PP_SEQ_ELEM_236(_) BOOST_PP_SEQ_ELEM_235 # define BOOST_PP_SEQ_ELEM_237(_) BOOST_PP_SEQ_ELEM_236 # define BOOST_PP_SEQ_ELEM_238(_) BOOST_PP_SEQ_ELEM_237 # define BOOST_PP_SEQ_ELEM_239(_) BOOST_PP_SEQ_ELEM_238 # define BOOST_PP_SEQ_ELEM_240(_) BOOST_PP_SEQ_ELEM_239 # define BOOST_PP_SEQ_ELEM_241(_) BOOST_PP_SEQ_ELEM_240 # define BOOST_PP_SEQ_ELEM_242(_) BOOST_PP_SEQ_ELEM_241 # define BOOST_PP_SEQ_ELEM_243(_) BOOST_PP_SEQ_ELEM_242 # define BOOST_PP_SEQ_ELEM_244(_) BOOST_PP_SEQ_ELEM_243 # define BOOST_PP_SEQ_ELEM_245(_) BOOST_PP_SEQ_ELEM_244 # define BOOST_PP_SEQ_ELEM_246(_) BOOST_PP_SEQ_ELEM_245 # define BOOST_PP_SEQ_ELEM_247(_) BOOST_PP_SEQ_ELEM_246 # define BOOST_PP_SEQ_ELEM_248(_) BOOST_PP_SEQ_ELEM_247 # define BOOST_PP_SEQ_ELEM_249(_) BOOST_PP_SEQ_ELEM_248 # define BOOST_PP_SEQ_ELEM_250(_) BOOST_PP_SEQ_ELEM_249 # define BOOST_PP_SEQ_ELEM_251(_) BOOST_PP_SEQ_ELEM_250 # define BOOST_PP_SEQ_ELEM_252(_) BOOST_PP_SEQ_ELEM_251 # define BOOST_PP_SEQ_ELEM_253(_) BOOST_PP_SEQ_ELEM_252 # define BOOST_PP_SEQ_ELEM_254(_) BOOST_PP_SEQ_ELEM_253 # define BOOST_PP_SEQ_ELEM_255(_) BOOST_PP_SEQ_ELEM_254 # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/to_array.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/to_a0000644000175000017500000000225211344301502031626 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_TO_ARRAY_HPP # define BOOST_PREPROCESSOR_SEQ_TO_ARRAY_HPP # # include # include # include # # /* BOOST_PP_SEQ_TO_ARRAY */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_TO_ARRAY(seq) (BOOST_PP_SEQ_SIZE(seq), (BOOST_PP_SEQ_ENUM(seq))) # else # define BOOST_PP_SEQ_TO_ARRAY(seq) BOOST_PP_SEQ_TO_ARRAY_I(seq) # define BOOST_PP_SEQ_TO_ARRAY_I(seq) (BOOST_PP_SEQ_SIZE(seq), (BOOST_PP_SEQ_ENUM(seq))) # endif # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/rest_n.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/rest0000644000175000017500000000255011344301502031662 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_REST_N_HPP # define BOOST_PREPROCESSOR_SEQ_REST_N_HPP # # include # include # include # include # include # # /* BOOST_PP_SEQ_REST_N */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_REST_N(n, seq) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), (nil) seq BOOST_PP_EMPTY))() # else # define BOOST_PP_SEQ_REST_N(n, seq) BOOST_PP_SEQ_REST_N_I(n, seq) # define BOOST_PP_SEQ_REST_N_I(n, seq) BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_SEQ_SPLIT(BOOST_PP_INC(n), (nil) seq BOOST_PP_EMPTY))() # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/enum.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/enum0000644000175000017500000003726011344301502031657 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_ENUM_HPP # define BOOST_PREPROCESSOR_SEQ_ENUM_HPP # # include # include # include # # /* BOOST_PP_SEQ_ENUM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_ENUM(seq) BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, BOOST_PP_SEQ_SIZE(seq)) seq # else # define BOOST_PP_SEQ_ENUM(seq) BOOST_PP_SEQ_ENUM_I(seq) # define BOOST_PP_SEQ_ENUM_I(seq) BOOST_PP_CAT(BOOST_PP_SEQ_ENUM_, BOOST_PP_SEQ_SIZE(seq)) seq # endif # # define BOOST_PP_SEQ_ENUM_1(x) x # define BOOST_PP_SEQ_ENUM_2(x) x, BOOST_PP_SEQ_ENUM_1 # define BOOST_PP_SEQ_ENUM_3(x) x, BOOST_PP_SEQ_ENUM_2 # define BOOST_PP_SEQ_ENUM_4(x) x, BOOST_PP_SEQ_ENUM_3 # define BOOST_PP_SEQ_ENUM_5(x) x, BOOST_PP_SEQ_ENUM_4 # define BOOST_PP_SEQ_ENUM_6(x) x, BOOST_PP_SEQ_ENUM_5 # define BOOST_PP_SEQ_ENUM_7(x) x, BOOST_PP_SEQ_ENUM_6 # define BOOST_PP_SEQ_ENUM_8(x) x, BOOST_PP_SEQ_ENUM_7 # define BOOST_PP_SEQ_ENUM_9(x) x, BOOST_PP_SEQ_ENUM_8 # define BOOST_PP_SEQ_ENUM_10(x) x, BOOST_PP_SEQ_ENUM_9 # define BOOST_PP_SEQ_ENUM_11(x) x, BOOST_PP_SEQ_ENUM_10 # define BOOST_PP_SEQ_ENUM_12(x) x, BOOST_PP_SEQ_ENUM_11 # define BOOST_PP_SEQ_ENUM_13(x) x, BOOST_PP_SEQ_ENUM_12 # define BOOST_PP_SEQ_ENUM_14(x) x, BOOST_PP_SEQ_ENUM_13 # define BOOST_PP_SEQ_ENUM_15(x) x, BOOST_PP_SEQ_ENUM_14 # define BOOST_PP_SEQ_ENUM_16(x) x, BOOST_PP_SEQ_ENUM_15 # define BOOST_PP_SEQ_ENUM_17(x) x, BOOST_PP_SEQ_ENUM_16 # define BOOST_PP_SEQ_ENUM_18(x) x, BOOST_PP_SEQ_ENUM_17 # define BOOST_PP_SEQ_ENUM_19(x) x, BOOST_PP_SEQ_ENUM_18 # define BOOST_PP_SEQ_ENUM_20(x) x, BOOST_PP_SEQ_ENUM_19 # define BOOST_PP_SEQ_ENUM_21(x) x, BOOST_PP_SEQ_ENUM_20 # define BOOST_PP_SEQ_ENUM_22(x) x, BOOST_PP_SEQ_ENUM_21 # define BOOST_PP_SEQ_ENUM_23(x) x, BOOST_PP_SEQ_ENUM_22 # define BOOST_PP_SEQ_ENUM_24(x) x, BOOST_PP_SEQ_ENUM_23 # define BOOST_PP_SEQ_ENUM_25(x) x, BOOST_PP_SEQ_ENUM_24 # define BOOST_PP_SEQ_ENUM_26(x) x, BOOST_PP_SEQ_ENUM_25 # define BOOST_PP_SEQ_ENUM_27(x) x, BOOST_PP_SEQ_ENUM_26 # define BOOST_PP_SEQ_ENUM_28(x) x, BOOST_PP_SEQ_ENUM_27 # define BOOST_PP_SEQ_ENUM_29(x) x, BOOST_PP_SEQ_ENUM_28 # define BOOST_PP_SEQ_ENUM_30(x) x, BOOST_PP_SEQ_ENUM_29 # define BOOST_PP_SEQ_ENUM_31(x) x, BOOST_PP_SEQ_ENUM_30 # define BOOST_PP_SEQ_ENUM_32(x) x, BOOST_PP_SEQ_ENUM_31 # define BOOST_PP_SEQ_ENUM_33(x) x, BOOST_PP_SEQ_ENUM_32 # define BOOST_PP_SEQ_ENUM_34(x) x, BOOST_PP_SEQ_ENUM_33 # define BOOST_PP_SEQ_ENUM_35(x) x, BOOST_PP_SEQ_ENUM_34 # define BOOST_PP_SEQ_ENUM_36(x) x, BOOST_PP_SEQ_ENUM_35 # define BOOST_PP_SEQ_ENUM_37(x) x, BOOST_PP_SEQ_ENUM_36 # define BOOST_PP_SEQ_ENUM_38(x) x, BOOST_PP_SEQ_ENUM_37 # define BOOST_PP_SEQ_ENUM_39(x) x, BOOST_PP_SEQ_ENUM_38 # define BOOST_PP_SEQ_ENUM_40(x) x, BOOST_PP_SEQ_ENUM_39 # define BOOST_PP_SEQ_ENUM_41(x) x, BOOST_PP_SEQ_ENUM_40 # define BOOST_PP_SEQ_ENUM_42(x) x, BOOST_PP_SEQ_ENUM_41 # define BOOST_PP_SEQ_ENUM_43(x) x, BOOST_PP_SEQ_ENUM_42 # define BOOST_PP_SEQ_ENUM_44(x) x, BOOST_PP_SEQ_ENUM_43 # define BOOST_PP_SEQ_ENUM_45(x) x, BOOST_PP_SEQ_ENUM_44 # define BOOST_PP_SEQ_ENUM_46(x) x, BOOST_PP_SEQ_ENUM_45 # define BOOST_PP_SEQ_ENUM_47(x) x, BOOST_PP_SEQ_ENUM_46 # define BOOST_PP_SEQ_ENUM_48(x) x, BOOST_PP_SEQ_ENUM_47 # define BOOST_PP_SEQ_ENUM_49(x) x, BOOST_PP_SEQ_ENUM_48 # define BOOST_PP_SEQ_ENUM_50(x) x, BOOST_PP_SEQ_ENUM_49 # define BOOST_PP_SEQ_ENUM_51(x) x, BOOST_PP_SEQ_ENUM_50 # define BOOST_PP_SEQ_ENUM_52(x) x, BOOST_PP_SEQ_ENUM_51 # define BOOST_PP_SEQ_ENUM_53(x) x, BOOST_PP_SEQ_ENUM_52 # define BOOST_PP_SEQ_ENUM_54(x) x, BOOST_PP_SEQ_ENUM_53 # define BOOST_PP_SEQ_ENUM_55(x) x, BOOST_PP_SEQ_ENUM_54 # define BOOST_PP_SEQ_ENUM_56(x) x, BOOST_PP_SEQ_ENUM_55 # define BOOST_PP_SEQ_ENUM_57(x) x, BOOST_PP_SEQ_ENUM_56 # define BOOST_PP_SEQ_ENUM_58(x) x, BOOST_PP_SEQ_ENUM_57 # define BOOST_PP_SEQ_ENUM_59(x) x, BOOST_PP_SEQ_ENUM_58 # define BOOST_PP_SEQ_ENUM_60(x) x, BOOST_PP_SEQ_ENUM_59 # define BOOST_PP_SEQ_ENUM_61(x) x, BOOST_PP_SEQ_ENUM_60 # define BOOST_PP_SEQ_ENUM_62(x) x, BOOST_PP_SEQ_ENUM_61 # define BOOST_PP_SEQ_ENUM_63(x) x, BOOST_PP_SEQ_ENUM_62 # define BOOST_PP_SEQ_ENUM_64(x) x, BOOST_PP_SEQ_ENUM_63 # define BOOST_PP_SEQ_ENUM_65(x) x, BOOST_PP_SEQ_ENUM_64 # define BOOST_PP_SEQ_ENUM_66(x) x, BOOST_PP_SEQ_ENUM_65 # define BOOST_PP_SEQ_ENUM_67(x) x, BOOST_PP_SEQ_ENUM_66 # define BOOST_PP_SEQ_ENUM_68(x) x, BOOST_PP_SEQ_ENUM_67 # define BOOST_PP_SEQ_ENUM_69(x) x, BOOST_PP_SEQ_ENUM_68 # define BOOST_PP_SEQ_ENUM_70(x) x, BOOST_PP_SEQ_ENUM_69 # define BOOST_PP_SEQ_ENUM_71(x) x, BOOST_PP_SEQ_ENUM_70 # define BOOST_PP_SEQ_ENUM_72(x) x, BOOST_PP_SEQ_ENUM_71 # define BOOST_PP_SEQ_ENUM_73(x) x, BOOST_PP_SEQ_ENUM_72 # define BOOST_PP_SEQ_ENUM_74(x) x, BOOST_PP_SEQ_ENUM_73 # define BOOST_PP_SEQ_ENUM_75(x) x, BOOST_PP_SEQ_ENUM_74 # define BOOST_PP_SEQ_ENUM_76(x) x, BOOST_PP_SEQ_ENUM_75 # define BOOST_PP_SEQ_ENUM_77(x) x, BOOST_PP_SEQ_ENUM_76 # define BOOST_PP_SEQ_ENUM_78(x) x, BOOST_PP_SEQ_ENUM_77 # define BOOST_PP_SEQ_ENUM_79(x) x, BOOST_PP_SEQ_ENUM_78 # define BOOST_PP_SEQ_ENUM_80(x) x, BOOST_PP_SEQ_ENUM_79 # define BOOST_PP_SEQ_ENUM_81(x) x, BOOST_PP_SEQ_ENUM_80 # define BOOST_PP_SEQ_ENUM_82(x) x, BOOST_PP_SEQ_ENUM_81 # define BOOST_PP_SEQ_ENUM_83(x) x, BOOST_PP_SEQ_ENUM_82 # define BOOST_PP_SEQ_ENUM_84(x) x, BOOST_PP_SEQ_ENUM_83 # define BOOST_PP_SEQ_ENUM_85(x) x, BOOST_PP_SEQ_ENUM_84 # define BOOST_PP_SEQ_ENUM_86(x) x, BOOST_PP_SEQ_ENUM_85 # define BOOST_PP_SEQ_ENUM_87(x) x, BOOST_PP_SEQ_ENUM_86 # define BOOST_PP_SEQ_ENUM_88(x) x, BOOST_PP_SEQ_ENUM_87 # define BOOST_PP_SEQ_ENUM_89(x) x, BOOST_PP_SEQ_ENUM_88 # define BOOST_PP_SEQ_ENUM_90(x) x, BOOST_PP_SEQ_ENUM_89 # define BOOST_PP_SEQ_ENUM_91(x) x, BOOST_PP_SEQ_ENUM_90 # define BOOST_PP_SEQ_ENUM_92(x) x, BOOST_PP_SEQ_ENUM_91 # define BOOST_PP_SEQ_ENUM_93(x) x, BOOST_PP_SEQ_ENUM_92 # define BOOST_PP_SEQ_ENUM_94(x) x, BOOST_PP_SEQ_ENUM_93 # define BOOST_PP_SEQ_ENUM_95(x) x, BOOST_PP_SEQ_ENUM_94 # define BOOST_PP_SEQ_ENUM_96(x) x, BOOST_PP_SEQ_ENUM_95 # define BOOST_PP_SEQ_ENUM_97(x) x, BOOST_PP_SEQ_ENUM_96 # define BOOST_PP_SEQ_ENUM_98(x) x, BOOST_PP_SEQ_ENUM_97 # define BOOST_PP_SEQ_ENUM_99(x) x, BOOST_PP_SEQ_ENUM_98 # define BOOST_PP_SEQ_ENUM_100(x) x, BOOST_PP_SEQ_ENUM_99 # define BOOST_PP_SEQ_ENUM_101(x) x, BOOST_PP_SEQ_ENUM_100 # define BOOST_PP_SEQ_ENUM_102(x) x, BOOST_PP_SEQ_ENUM_101 # define BOOST_PP_SEQ_ENUM_103(x) x, BOOST_PP_SEQ_ENUM_102 # define BOOST_PP_SEQ_ENUM_104(x) x, BOOST_PP_SEQ_ENUM_103 # define BOOST_PP_SEQ_ENUM_105(x) x, BOOST_PP_SEQ_ENUM_104 # define BOOST_PP_SEQ_ENUM_106(x) x, BOOST_PP_SEQ_ENUM_105 # define BOOST_PP_SEQ_ENUM_107(x) x, BOOST_PP_SEQ_ENUM_106 # define BOOST_PP_SEQ_ENUM_108(x) x, BOOST_PP_SEQ_ENUM_107 # define BOOST_PP_SEQ_ENUM_109(x) x, BOOST_PP_SEQ_ENUM_108 # define BOOST_PP_SEQ_ENUM_110(x) x, BOOST_PP_SEQ_ENUM_109 # define BOOST_PP_SEQ_ENUM_111(x) x, BOOST_PP_SEQ_ENUM_110 # define BOOST_PP_SEQ_ENUM_112(x) x, BOOST_PP_SEQ_ENUM_111 # define BOOST_PP_SEQ_ENUM_113(x) x, BOOST_PP_SEQ_ENUM_112 # define BOOST_PP_SEQ_ENUM_114(x) x, BOOST_PP_SEQ_ENUM_113 # define BOOST_PP_SEQ_ENUM_115(x) x, BOOST_PP_SEQ_ENUM_114 # define BOOST_PP_SEQ_ENUM_116(x) x, BOOST_PP_SEQ_ENUM_115 # define BOOST_PP_SEQ_ENUM_117(x) x, BOOST_PP_SEQ_ENUM_116 # define BOOST_PP_SEQ_ENUM_118(x) x, BOOST_PP_SEQ_ENUM_117 # define BOOST_PP_SEQ_ENUM_119(x) x, BOOST_PP_SEQ_ENUM_118 # define BOOST_PP_SEQ_ENUM_120(x) x, BOOST_PP_SEQ_ENUM_119 # define BOOST_PP_SEQ_ENUM_121(x) x, BOOST_PP_SEQ_ENUM_120 # define BOOST_PP_SEQ_ENUM_122(x) x, BOOST_PP_SEQ_ENUM_121 # define BOOST_PP_SEQ_ENUM_123(x) x, BOOST_PP_SEQ_ENUM_122 # define BOOST_PP_SEQ_ENUM_124(x) x, BOOST_PP_SEQ_ENUM_123 # define BOOST_PP_SEQ_ENUM_125(x) x, BOOST_PP_SEQ_ENUM_124 # define BOOST_PP_SEQ_ENUM_126(x) x, BOOST_PP_SEQ_ENUM_125 # define BOOST_PP_SEQ_ENUM_127(x) x, BOOST_PP_SEQ_ENUM_126 # define BOOST_PP_SEQ_ENUM_128(x) x, BOOST_PP_SEQ_ENUM_127 # define BOOST_PP_SEQ_ENUM_129(x) x, BOOST_PP_SEQ_ENUM_128 # define BOOST_PP_SEQ_ENUM_130(x) x, BOOST_PP_SEQ_ENUM_129 # define BOOST_PP_SEQ_ENUM_131(x) x, BOOST_PP_SEQ_ENUM_130 # define BOOST_PP_SEQ_ENUM_132(x) x, BOOST_PP_SEQ_ENUM_131 # define BOOST_PP_SEQ_ENUM_133(x) x, BOOST_PP_SEQ_ENUM_132 # define BOOST_PP_SEQ_ENUM_134(x) x, BOOST_PP_SEQ_ENUM_133 # define BOOST_PP_SEQ_ENUM_135(x) x, BOOST_PP_SEQ_ENUM_134 # define BOOST_PP_SEQ_ENUM_136(x) x, BOOST_PP_SEQ_ENUM_135 # define BOOST_PP_SEQ_ENUM_137(x) x, BOOST_PP_SEQ_ENUM_136 # define BOOST_PP_SEQ_ENUM_138(x) x, BOOST_PP_SEQ_ENUM_137 # define BOOST_PP_SEQ_ENUM_139(x) x, BOOST_PP_SEQ_ENUM_138 # define BOOST_PP_SEQ_ENUM_140(x) x, BOOST_PP_SEQ_ENUM_139 # define BOOST_PP_SEQ_ENUM_141(x) x, BOOST_PP_SEQ_ENUM_140 # define BOOST_PP_SEQ_ENUM_142(x) x, BOOST_PP_SEQ_ENUM_141 # define BOOST_PP_SEQ_ENUM_143(x) x, BOOST_PP_SEQ_ENUM_142 # define BOOST_PP_SEQ_ENUM_144(x) x, BOOST_PP_SEQ_ENUM_143 # define BOOST_PP_SEQ_ENUM_145(x) x, BOOST_PP_SEQ_ENUM_144 # define BOOST_PP_SEQ_ENUM_146(x) x, BOOST_PP_SEQ_ENUM_145 # define BOOST_PP_SEQ_ENUM_147(x) x, BOOST_PP_SEQ_ENUM_146 # define BOOST_PP_SEQ_ENUM_148(x) x, BOOST_PP_SEQ_ENUM_147 # define BOOST_PP_SEQ_ENUM_149(x) x, BOOST_PP_SEQ_ENUM_148 # define BOOST_PP_SEQ_ENUM_150(x) x, BOOST_PP_SEQ_ENUM_149 # define BOOST_PP_SEQ_ENUM_151(x) x, BOOST_PP_SEQ_ENUM_150 # define BOOST_PP_SEQ_ENUM_152(x) x, BOOST_PP_SEQ_ENUM_151 # define BOOST_PP_SEQ_ENUM_153(x) x, BOOST_PP_SEQ_ENUM_152 # define BOOST_PP_SEQ_ENUM_154(x) x, BOOST_PP_SEQ_ENUM_153 # define BOOST_PP_SEQ_ENUM_155(x) x, BOOST_PP_SEQ_ENUM_154 # define BOOST_PP_SEQ_ENUM_156(x) x, BOOST_PP_SEQ_ENUM_155 # define BOOST_PP_SEQ_ENUM_157(x) x, BOOST_PP_SEQ_ENUM_156 # define BOOST_PP_SEQ_ENUM_158(x) x, BOOST_PP_SEQ_ENUM_157 # define BOOST_PP_SEQ_ENUM_159(x) x, BOOST_PP_SEQ_ENUM_158 # define BOOST_PP_SEQ_ENUM_160(x) x, BOOST_PP_SEQ_ENUM_159 # define BOOST_PP_SEQ_ENUM_161(x) x, BOOST_PP_SEQ_ENUM_160 # define BOOST_PP_SEQ_ENUM_162(x) x, BOOST_PP_SEQ_ENUM_161 # define BOOST_PP_SEQ_ENUM_163(x) x, BOOST_PP_SEQ_ENUM_162 # define BOOST_PP_SEQ_ENUM_164(x) x, BOOST_PP_SEQ_ENUM_163 # define BOOST_PP_SEQ_ENUM_165(x) x, BOOST_PP_SEQ_ENUM_164 # define BOOST_PP_SEQ_ENUM_166(x) x, BOOST_PP_SEQ_ENUM_165 # define BOOST_PP_SEQ_ENUM_167(x) x, BOOST_PP_SEQ_ENUM_166 # define BOOST_PP_SEQ_ENUM_168(x) x, BOOST_PP_SEQ_ENUM_167 # define BOOST_PP_SEQ_ENUM_169(x) x, BOOST_PP_SEQ_ENUM_168 # define BOOST_PP_SEQ_ENUM_170(x) x, BOOST_PP_SEQ_ENUM_169 # define BOOST_PP_SEQ_ENUM_171(x) x, BOOST_PP_SEQ_ENUM_170 # define BOOST_PP_SEQ_ENUM_172(x) x, BOOST_PP_SEQ_ENUM_171 # define BOOST_PP_SEQ_ENUM_173(x) x, BOOST_PP_SEQ_ENUM_172 # define BOOST_PP_SEQ_ENUM_174(x) x, BOOST_PP_SEQ_ENUM_173 # define BOOST_PP_SEQ_ENUM_175(x) x, BOOST_PP_SEQ_ENUM_174 # define BOOST_PP_SEQ_ENUM_176(x) x, BOOST_PP_SEQ_ENUM_175 # define BOOST_PP_SEQ_ENUM_177(x) x, BOOST_PP_SEQ_ENUM_176 # define BOOST_PP_SEQ_ENUM_178(x) x, BOOST_PP_SEQ_ENUM_177 # define BOOST_PP_SEQ_ENUM_179(x) x, BOOST_PP_SEQ_ENUM_178 # define BOOST_PP_SEQ_ENUM_180(x) x, BOOST_PP_SEQ_ENUM_179 # define BOOST_PP_SEQ_ENUM_181(x) x, BOOST_PP_SEQ_ENUM_180 # define BOOST_PP_SEQ_ENUM_182(x) x, BOOST_PP_SEQ_ENUM_181 # define BOOST_PP_SEQ_ENUM_183(x) x, BOOST_PP_SEQ_ENUM_182 # define BOOST_PP_SEQ_ENUM_184(x) x, BOOST_PP_SEQ_ENUM_183 # define BOOST_PP_SEQ_ENUM_185(x) x, BOOST_PP_SEQ_ENUM_184 # define BOOST_PP_SEQ_ENUM_186(x) x, BOOST_PP_SEQ_ENUM_185 # define BOOST_PP_SEQ_ENUM_187(x) x, BOOST_PP_SEQ_ENUM_186 # define BOOST_PP_SEQ_ENUM_188(x) x, BOOST_PP_SEQ_ENUM_187 # define BOOST_PP_SEQ_ENUM_189(x) x, BOOST_PP_SEQ_ENUM_188 # define BOOST_PP_SEQ_ENUM_190(x) x, BOOST_PP_SEQ_ENUM_189 # define BOOST_PP_SEQ_ENUM_191(x) x, BOOST_PP_SEQ_ENUM_190 # define BOOST_PP_SEQ_ENUM_192(x) x, BOOST_PP_SEQ_ENUM_191 # define BOOST_PP_SEQ_ENUM_193(x) x, BOOST_PP_SEQ_ENUM_192 # define BOOST_PP_SEQ_ENUM_194(x) x, BOOST_PP_SEQ_ENUM_193 # define BOOST_PP_SEQ_ENUM_195(x) x, BOOST_PP_SEQ_ENUM_194 # define BOOST_PP_SEQ_ENUM_196(x) x, BOOST_PP_SEQ_ENUM_195 # define BOOST_PP_SEQ_ENUM_197(x) x, BOOST_PP_SEQ_ENUM_196 # define BOOST_PP_SEQ_ENUM_198(x) x, BOOST_PP_SEQ_ENUM_197 # define BOOST_PP_SEQ_ENUM_199(x) x, BOOST_PP_SEQ_ENUM_198 # define BOOST_PP_SEQ_ENUM_200(x) x, BOOST_PP_SEQ_ENUM_199 # define BOOST_PP_SEQ_ENUM_201(x) x, BOOST_PP_SEQ_ENUM_200 # define BOOST_PP_SEQ_ENUM_202(x) x, BOOST_PP_SEQ_ENUM_201 # define BOOST_PP_SEQ_ENUM_203(x) x, BOOST_PP_SEQ_ENUM_202 # define BOOST_PP_SEQ_ENUM_204(x) x, BOOST_PP_SEQ_ENUM_203 # define BOOST_PP_SEQ_ENUM_205(x) x, BOOST_PP_SEQ_ENUM_204 # define BOOST_PP_SEQ_ENUM_206(x) x, BOOST_PP_SEQ_ENUM_205 # define BOOST_PP_SEQ_ENUM_207(x) x, BOOST_PP_SEQ_ENUM_206 # define BOOST_PP_SEQ_ENUM_208(x) x, BOOST_PP_SEQ_ENUM_207 # define BOOST_PP_SEQ_ENUM_209(x) x, BOOST_PP_SEQ_ENUM_208 # define BOOST_PP_SEQ_ENUM_210(x) x, BOOST_PP_SEQ_ENUM_209 # define BOOST_PP_SEQ_ENUM_211(x) x, BOOST_PP_SEQ_ENUM_210 # define BOOST_PP_SEQ_ENUM_212(x) x, BOOST_PP_SEQ_ENUM_211 # define BOOST_PP_SEQ_ENUM_213(x) x, BOOST_PP_SEQ_ENUM_212 # define BOOST_PP_SEQ_ENUM_214(x) x, BOOST_PP_SEQ_ENUM_213 # define BOOST_PP_SEQ_ENUM_215(x) x, BOOST_PP_SEQ_ENUM_214 # define BOOST_PP_SEQ_ENUM_216(x) x, BOOST_PP_SEQ_ENUM_215 # define BOOST_PP_SEQ_ENUM_217(x) x, BOOST_PP_SEQ_ENUM_216 # define BOOST_PP_SEQ_ENUM_218(x) x, BOOST_PP_SEQ_ENUM_217 # define BOOST_PP_SEQ_ENUM_219(x) x, BOOST_PP_SEQ_ENUM_218 # define BOOST_PP_SEQ_ENUM_220(x) x, BOOST_PP_SEQ_ENUM_219 # define BOOST_PP_SEQ_ENUM_221(x) x, BOOST_PP_SEQ_ENUM_220 # define BOOST_PP_SEQ_ENUM_222(x) x, BOOST_PP_SEQ_ENUM_221 # define BOOST_PP_SEQ_ENUM_223(x) x, BOOST_PP_SEQ_ENUM_222 # define BOOST_PP_SEQ_ENUM_224(x) x, BOOST_PP_SEQ_ENUM_223 # define BOOST_PP_SEQ_ENUM_225(x) x, BOOST_PP_SEQ_ENUM_224 # define BOOST_PP_SEQ_ENUM_226(x) x, BOOST_PP_SEQ_ENUM_225 # define BOOST_PP_SEQ_ENUM_227(x) x, BOOST_PP_SEQ_ENUM_226 # define BOOST_PP_SEQ_ENUM_228(x) x, BOOST_PP_SEQ_ENUM_227 # define BOOST_PP_SEQ_ENUM_229(x) x, BOOST_PP_SEQ_ENUM_228 # define BOOST_PP_SEQ_ENUM_230(x) x, BOOST_PP_SEQ_ENUM_229 # define BOOST_PP_SEQ_ENUM_231(x) x, BOOST_PP_SEQ_ENUM_230 # define BOOST_PP_SEQ_ENUM_232(x) x, BOOST_PP_SEQ_ENUM_231 # define BOOST_PP_SEQ_ENUM_233(x) x, BOOST_PP_SEQ_ENUM_232 # define BOOST_PP_SEQ_ENUM_234(x) x, BOOST_PP_SEQ_ENUM_233 # define BOOST_PP_SEQ_ENUM_235(x) x, BOOST_PP_SEQ_ENUM_234 # define BOOST_PP_SEQ_ENUM_236(x) x, BOOST_PP_SEQ_ENUM_235 # define BOOST_PP_SEQ_ENUM_237(x) x, BOOST_PP_SEQ_ENUM_236 # define BOOST_PP_SEQ_ENUM_238(x) x, BOOST_PP_SEQ_ENUM_237 # define BOOST_PP_SEQ_ENUM_239(x) x, BOOST_PP_SEQ_ENUM_238 # define BOOST_PP_SEQ_ENUM_240(x) x, BOOST_PP_SEQ_ENUM_239 # define BOOST_PP_SEQ_ENUM_241(x) x, BOOST_PP_SEQ_ENUM_240 # define BOOST_PP_SEQ_ENUM_242(x) x, BOOST_PP_SEQ_ENUM_241 # define BOOST_PP_SEQ_ENUM_243(x) x, BOOST_PP_SEQ_ENUM_242 # define BOOST_PP_SEQ_ENUM_244(x) x, BOOST_PP_SEQ_ENUM_243 # define BOOST_PP_SEQ_ENUM_245(x) x, BOOST_PP_SEQ_ENUM_244 # define BOOST_PP_SEQ_ENUM_246(x) x, BOOST_PP_SEQ_ENUM_245 # define BOOST_PP_SEQ_ENUM_247(x) x, BOOST_PP_SEQ_ENUM_246 # define BOOST_PP_SEQ_ENUM_248(x) x, BOOST_PP_SEQ_ENUM_247 # define BOOST_PP_SEQ_ENUM_249(x) x, BOOST_PP_SEQ_ENUM_248 # define BOOST_PP_SEQ_ENUM_250(x) x, BOOST_PP_SEQ_ENUM_249 # define BOOST_PP_SEQ_ENUM_251(x) x, BOOST_PP_SEQ_ENUM_250 # define BOOST_PP_SEQ_ENUM_252(x) x, BOOST_PP_SEQ_ENUM_251 # define BOOST_PP_SEQ_ENUM_253(x) x, BOOST_PP_SEQ_ENUM_252 # define BOOST_PP_SEQ_ENUM_254(x) x, BOOST_PP_SEQ_ENUM_253 # define BOOST_PP_SEQ_ENUM_255(x) x, BOOST_PP_SEQ_ENUM_254 # define BOOST_PP_SEQ_ENUM_256(x) x, BOOST_PP_SEQ_ENUM_255 # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/first_n.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/firs0000644000175000017500000000256211344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_FIRST_N_HPP # define BOOST_PREPROCESSOR_SEQ_FIRST_N_HPP # # include # include # include # include # include # # /* BOOST_PP_SEQ_FIRST_N */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_FIRST_N(n, seq) BOOST_PP_IF(n, BOOST_PP_TUPLE_ELEM, BOOST_PP_TUPLE_EAT_3)(2, 0, BOOST_PP_SEQ_SPLIT(n, seq (nil))) # else # define BOOST_PP_SEQ_FIRST_N(n, seq) BOOST_PP_SEQ_FIRST_N_I(n, seq) # define BOOST_PP_SEQ_FIRST_N_I(n, seq) BOOST_PP_IF(n, BOOST_PP_TUPLE_ELEM, BOOST_PP_TUPLE_EAT_3)(2, 0, BOOST_PP_SEQ_SPLIT(n, seq (nil))) # endif # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/deta0000755000175000017500000000000012146213771031631 5ustar debiandebian././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/detail/split.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/deta0000644000175000017500000004051011344301502031620 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_DETAIL_SPLIT_HPP # define BOOST_PREPROCESSOR_SEQ_DETAIL_SPLIT_HPP # # include # # /* BOOST_PP_SEQ_SPLIT */ # # define BOOST_PP_SEQ_SPLIT(n, seq) BOOST_PP_SEQ_SPLIT_D(n, seq) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SEQ_SPLIT_D(n, seq) (BOOST_PP_SEQ_SPLIT_ ## n seq) # else # define BOOST_PP_SEQ_SPLIT_D(n, seq) (BOOST_PP_SEQ_SPLIT_ ## n ## seq) # endif # # define BOOST_PP_SEQ_SPLIT_1(x) (x), # define BOOST_PP_SEQ_SPLIT_2(x) (x) BOOST_PP_SEQ_SPLIT_1 # define BOOST_PP_SEQ_SPLIT_3(x) (x) BOOST_PP_SEQ_SPLIT_2 # define BOOST_PP_SEQ_SPLIT_4(x) (x) BOOST_PP_SEQ_SPLIT_3 # define BOOST_PP_SEQ_SPLIT_5(x) (x) BOOST_PP_SEQ_SPLIT_4 # define BOOST_PP_SEQ_SPLIT_6(x) (x) BOOST_PP_SEQ_SPLIT_5 # define BOOST_PP_SEQ_SPLIT_7(x) (x) BOOST_PP_SEQ_SPLIT_6 # define BOOST_PP_SEQ_SPLIT_8(x) (x) BOOST_PP_SEQ_SPLIT_7 # define BOOST_PP_SEQ_SPLIT_9(x) (x) BOOST_PP_SEQ_SPLIT_8 # define BOOST_PP_SEQ_SPLIT_10(x) (x) BOOST_PP_SEQ_SPLIT_9 # define BOOST_PP_SEQ_SPLIT_11(x) (x) BOOST_PP_SEQ_SPLIT_10 # define BOOST_PP_SEQ_SPLIT_12(x) (x) BOOST_PP_SEQ_SPLIT_11 # define BOOST_PP_SEQ_SPLIT_13(x) (x) BOOST_PP_SEQ_SPLIT_12 # define BOOST_PP_SEQ_SPLIT_14(x) (x) BOOST_PP_SEQ_SPLIT_13 # define BOOST_PP_SEQ_SPLIT_15(x) (x) BOOST_PP_SEQ_SPLIT_14 # define BOOST_PP_SEQ_SPLIT_16(x) (x) BOOST_PP_SEQ_SPLIT_15 # define BOOST_PP_SEQ_SPLIT_17(x) (x) BOOST_PP_SEQ_SPLIT_16 # define BOOST_PP_SEQ_SPLIT_18(x) (x) BOOST_PP_SEQ_SPLIT_17 # define BOOST_PP_SEQ_SPLIT_19(x) (x) BOOST_PP_SEQ_SPLIT_18 # define BOOST_PP_SEQ_SPLIT_20(x) (x) BOOST_PP_SEQ_SPLIT_19 # define BOOST_PP_SEQ_SPLIT_21(x) (x) BOOST_PP_SEQ_SPLIT_20 # define BOOST_PP_SEQ_SPLIT_22(x) (x) BOOST_PP_SEQ_SPLIT_21 # define BOOST_PP_SEQ_SPLIT_23(x) (x) BOOST_PP_SEQ_SPLIT_22 # define BOOST_PP_SEQ_SPLIT_24(x) (x) BOOST_PP_SEQ_SPLIT_23 # define BOOST_PP_SEQ_SPLIT_25(x) (x) BOOST_PP_SEQ_SPLIT_24 # define BOOST_PP_SEQ_SPLIT_26(x) (x) BOOST_PP_SEQ_SPLIT_25 # define BOOST_PP_SEQ_SPLIT_27(x) (x) BOOST_PP_SEQ_SPLIT_26 # define BOOST_PP_SEQ_SPLIT_28(x) (x) BOOST_PP_SEQ_SPLIT_27 # define BOOST_PP_SEQ_SPLIT_29(x) (x) BOOST_PP_SEQ_SPLIT_28 # define BOOST_PP_SEQ_SPLIT_30(x) (x) BOOST_PP_SEQ_SPLIT_29 # define BOOST_PP_SEQ_SPLIT_31(x) (x) BOOST_PP_SEQ_SPLIT_30 # define BOOST_PP_SEQ_SPLIT_32(x) (x) BOOST_PP_SEQ_SPLIT_31 # define BOOST_PP_SEQ_SPLIT_33(x) (x) BOOST_PP_SEQ_SPLIT_32 # define BOOST_PP_SEQ_SPLIT_34(x) (x) BOOST_PP_SEQ_SPLIT_33 # define BOOST_PP_SEQ_SPLIT_35(x) (x) BOOST_PP_SEQ_SPLIT_34 # define BOOST_PP_SEQ_SPLIT_36(x) (x) BOOST_PP_SEQ_SPLIT_35 # define BOOST_PP_SEQ_SPLIT_37(x) (x) BOOST_PP_SEQ_SPLIT_36 # define BOOST_PP_SEQ_SPLIT_38(x) (x) BOOST_PP_SEQ_SPLIT_37 # define BOOST_PP_SEQ_SPLIT_39(x) (x) BOOST_PP_SEQ_SPLIT_38 # define BOOST_PP_SEQ_SPLIT_40(x) (x) BOOST_PP_SEQ_SPLIT_39 # define BOOST_PP_SEQ_SPLIT_41(x) (x) BOOST_PP_SEQ_SPLIT_40 # define BOOST_PP_SEQ_SPLIT_42(x) (x) BOOST_PP_SEQ_SPLIT_41 # define BOOST_PP_SEQ_SPLIT_43(x) (x) BOOST_PP_SEQ_SPLIT_42 # define BOOST_PP_SEQ_SPLIT_44(x) (x) BOOST_PP_SEQ_SPLIT_43 # define BOOST_PP_SEQ_SPLIT_45(x) (x) BOOST_PP_SEQ_SPLIT_44 # define BOOST_PP_SEQ_SPLIT_46(x) (x) BOOST_PP_SEQ_SPLIT_45 # define BOOST_PP_SEQ_SPLIT_47(x) (x) BOOST_PP_SEQ_SPLIT_46 # define BOOST_PP_SEQ_SPLIT_48(x) (x) BOOST_PP_SEQ_SPLIT_47 # define BOOST_PP_SEQ_SPLIT_49(x) (x) BOOST_PP_SEQ_SPLIT_48 # define BOOST_PP_SEQ_SPLIT_50(x) (x) BOOST_PP_SEQ_SPLIT_49 # define BOOST_PP_SEQ_SPLIT_51(x) (x) BOOST_PP_SEQ_SPLIT_50 # define BOOST_PP_SEQ_SPLIT_52(x) (x) BOOST_PP_SEQ_SPLIT_51 # define BOOST_PP_SEQ_SPLIT_53(x) (x) BOOST_PP_SEQ_SPLIT_52 # define BOOST_PP_SEQ_SPLIT_54(x) (x) BOOST_PP_SEQ_SPLIT_53 # define BOOST_PP_SEQ_SPLIT_55(x) (x) BOOST_PP_SEQ_SPLIT_54 # define BOOST_PP_SEQ_SPLIT_56(x) (x) BOOST_PP_SEQ_SPLIT_55 # define BOOST_PP_SEQ_SPLIT_57(x) (x) BOOST_PP_SEQ_SPLIT_56 # define BOOST_PP_SEQ_SPLIT_58(x) (x) BOOST_PP_SEQ_SPLIT_57 # define BOOST_PP_SEQ_SPLIT_59(x) (x) BOOST_PP_SEQ_SPLIT_58 # define BOOST_PP_SEQ_SPLIT_60(x) (x) BOOST_PP_SEQ_SPLIT_59 # define BOOST_PP_SEQ_SPLIT_61(x) (x) BOOST_PP_SEQ_SPLIT_60 # define BOOST_PP_SEQ_SPLIT_62(x) (x) BOOST_PP_SEQ_SPLIT_61 # define BOOST_PP_SEQ_SPLIT_63(x) (x) BOOST_PP_SEQ_SPLIT_62 # define BOOST_PP_SEQ_SPLIT_64(x) (x) BOOST_PP_SEQ_SPLIT_63 # define BOOST_PP_SEQ_SPLIT_65(x) (x) BOOST_PP_SEQ_SPLIT_64 # define BOOST_PP_SEQ_SPLIT_66(x) (x) BOOST_PP_SEQ_SPLIT_65 # define BOOST_PP_SEQ_SPLIT_67(x) (x) BOOST_PP_SEQ_SPLIT_66 # define BOOST_PP_SEQ_SPLIT_68(x) (x) BOOST_PP_SEQ_SPLIT_67 # define BOOST_PP_SEQ_SPLIT_69(x) (x) BOOST_PP_SEQ_SPLIT_68 # define BOOST_PP_SEQ_SPLIT_70(x) (x) BOOST_PP_SEQ_SPLIT_69 # define BOOST_PP_SEQ_SPLIT_71(x) (x) BOOST_PP_SEQ_SPLIT_70 # define BOOST_PP_SEQ_SPLIT_72(x) (x) BOOST_PP_SEQ_SPLIT_71 # define BOOST_PP_SEQ_SPLIT_73(x) (x) BOOST_PP_SEQ_SPLIT_72 # define BOOST_PP_SEQ_SPLIT_74(x) (x) BOOST_PP_SEQ_SPLIT_73 # define BOOST_PP_SEQ_SPLIT_75(x) (x) BOOST_PP_SEQ_SPLIT_74 # define BOOST_PP_SEQ_SPLIT_76(x) (x) BOOST_PP_SEQ_SPLIT_75 # define BOOST_PP_SEQ_SPLIT_77(x) (x) BOOST_PP_SEQ_SPLIT_76 # define BOOST_PP_SEQ_SPLIT_78(x) (x) BOOST_PP_SEQ_SPLIT_77 # define BOOST_PP_SEQ_SPLIT_79(x) (x) BOOST_PP_SEQ_SPLIT_78 # define BOOST_PP_SEQ_SPLIT_80(x) (x) BOOST_PP_SEQ_SPLIT_79 # define BOOST_PP_SEQ_SPLIT_81(x) (x) BOOST_PP_SEQ_SPLIT_80 # define BOOST_PP_SEQ_SPLIT_82(x) (x) BOOST_PP_SEQ_SPLIT_81 # define BOOST_PP_SEQ_SPLIT_83(x) (x) BOOST_PP_SEQ_SPLIT_82 # define BOOST_PP_SEQ_SPLIT_84(x) (x) BOOST_PP_SEQ_SPLIT_83 # define BOOST_PP_SEQ_SPLIT_85(x) (x) BOOST_PP_SEQ_SPLIT_84 # define BOOST_PP_SEQ_SPLIT_86(x) (x) BOOST_PP_SEQ_SPLIT_85 # define BOOST_PP_SEQ_SPLIT_87(x) (x) BOOST_PP_SEQ_SPLIT_86 # define BOOST_PP_SEQ_SPLIT_88(x) (x) BOOST_PP_SEQ_SPLIT_87 # define BOOST_PP_SEQ_SPLIT_89(x) (x) BOOST_PP_SEQ_SPLIT_88 # define BOOST_PP_SEQ_SPLIT_90(x) (x) BOOST_PP_SEQ_SPLIT_89 # define BOOST_PP_SEQ_SPLIT_91(x) (x) BOOST_PP_SEQ_SPLIT_90 # define BOOST_PP_SEQ_SPLIT_92(x) (x) BOOST_PP_SEQ_SPLIT_91 # define BOOST_PP_SEQ_SPLIT_93(x) (x) BOOST_PP_SEQ_SPLIT_92 # define BOOST_PP_SEQ_SPLIT_94(x) (x) BOOST_PP_SEQ_SPLIT_93 # define BOOST_PP_SEQ_SPLIT_95(x) (x) BOOST_PP_SEQ_SPLIT_94 # define BOOST_PP_SEQ_SPLIT_96(x) (x) BOOST_PP_SEQ_SPLIT_95 # define BOOST_PP_SEQ_SPLIT_97(x) (x) BOOST_PP_SEQ_SPLIT_96 # define BOOST_PP_SEQ_SPLIT_98(x) (x) BOOST_PP_SEQ_SPLIT_97 # define BOOST_PP_SEQ_SPLIT_99(x) (x) BOOST_PP_SEQ_SPLIT_98 # define BOOST_PP_SEQ_SPLIT_100(x) (x) BOOST_PP_SEQ_SPLIT_99 # define BOOST_PP_SEQ_SPLIT_101(x) (x) BOOST_PP_SEQ_SPLIT_100 # define BOOST_PP_SEQ_SPLIT_102(x) (x) BOOST_PP_SEQ_SPLIT_101 # define BOOST_PP_SEQ_SPLIT_103(x) (x) BOOST_PP_SEQ_SPLIT_102 # define BOOST_PP_SEQ_SPLIT_104(x) (x) BOOST_PP_SEQ_SPLIT_103 # define BOOST_PP_SEQ_SPLIT_105(x) (x) BOOST_PP_SEQ_SPLIT_104 # define BOOST_PP_SEQ_SPLIT_106(x) (x) BOOST_PP_SEQ_SPLIT_105 # define BOOST_PP_SEQ_SPLIT_107(x) (x) BOOST_PP_SEQ_SPLIT_106 # define BOOST_PP_SEQ_SPLIT_108(x) (x) BOOST_PP_SEQ_SPLIT_107 # define BOOST_PP_SEQ_SPLIT_109(x) (x) BOOST_PP_SEQ_SPLIT_108 # define BOOST_PP_SEQ_SPLIT_110(x) (x) BOOST_PP_SEQ_SPLIT_109 # define BOOST_PP_SEQ_SPLIT_111(x) (x) BOOST_PP_SEQ_SPLIT_110 # define BOOST_PP_SEQ_SPLIT_112(x) (x) BOOST_PP_SEQ_SPLIT_111 # define BOOST_PP_SEQ_SPLIT_113(x) (x) BOOST_PP_SEQ_SPLIT_112 # define BOOST_PP_SEQ_SPLIT_114(x) (x) BOOST_PP_SEQ_SPLIT_113 # define BOOST_PP_SEQ_SPLIT_115(x) (x) BOOST_PP_SEQ_SPLIT_114 # define BOOST_PP_SEQ_SPLIT_116(x) (x) BOOST_PP_SEQ_SPLIT_115 # define BOOST_PP_SEQ_SPLIT_117(x) (x) BOOST_PP_SEQ_SPLIT_116 # define BOOST_PP_SEQ_SPLIT_118(x) (x) BOOST_PP_SEQ_SPLIT_117 # define BOOST_PP_SEQ_SPLIT_119(x) (x) BOOST_PP_SEQ_SPLIT_118 # define BOOST_PP_SEQ_SPLIT_120(x) (x) BOOST_PP_SEQ_SPLIT_119 # define BOOST_PP_SEQ_SPLIT_121(x) (x) BOOST_PP_SEQ_SPLIT_120 # define BOOST_PP_SEQ_SPLIT_122(x) (x) BOOST_PP_SEQ_SPLIT_121 # define BOOST_PP_SEQ_SPLIT_123(x) (x) BOOST_PP_SEQ_SPLIT_122 # define BOOST_PP_SEQ_SPLIT_124(x) (x) BOOST_PP_SEQ_SPLIT_123 # define BOOST_PP_SEQ_SPLIT_125(x) (x) BOOST_PP_SEQ_SPLIT_124 # define BOOST_PP_SEQ_SPLIT_126(x) (x) BOOST_PP_SEQ_SPLIT_125 # define BOOST_PP_SEQ_SPLIT_127(x) (x) BOOST_PP_SEQ_SPLIT_126 # define BOOST_PP_SEQ_SPLIT_128(x) (x) BOOST_PP_SEQ_SPLIT_127 # define BOOST_PP_SEQ_SPLIT_129(x) (x) BOOST_PP_SEQ_SPLIT_128 # define BOOST_PP_SEQ_SPLIT_130(x) (x) BOOST_PP_SEQ_SPLIT_129 # define BOOST_PP_SEQ_SPLIT_131(x) (x) BOOST_PP_SEQ_SPLIT_130 # define BOOST_PP_SEQ_SPLIT_132(x) (x) BOOST_PP_SEQ_SPLIT_131 # define BOOST_PP_SEQ_SPLIT_133(x) (x) BOOST_PP_SEQ_SPLIT_132 # define BOOST_PP_SEQ_SPLIT_134(x) (x) BOOST_PP_SEQ_SPLIT_133 # define BOOST_PP_SEQ_SPLIT_135(x) (x) BOOST_PP_SEQ_SPLIT_134 # define BOOST_PP_SEQ_SPLIT_136(x) (x) BOOST_PP_SEQ_SPLIT_135 # define BOOST_PP_SEQ_SPLIT_137(x) (x) BOOST_PP_SEQ_SPLIT_136 # define BOOST_PP_SEQ_SPLIT_138(x) (x) BOOST_PP_SEQ_SPLIT_137 # define BOOST_PP_SEQ_SPLIT_139(x) (x) BOOST_PP_SEQ_SPLIT_138 # define BOOST_PP_SEQ_SPLIT_140(x) (x) BOOST_PP_SEQ_SPLIT_139 # define BOOST_PP_SEQ_SPLIT_141(x) (x) BOOST_PP_SEQ_SPLIT_140 # define BOOST_PP_SEQ_SPLIT_142(x) (x) BOOST_PP_SEQ_SPLIT_141 # define BOOST_PP_SEQ_SPLIT_143(x) (x) BOOST_PP_SEQ_SPLIT_142 # define BOOST_PP_SEQ_SPLIT_144(x) (x) BOOST_PP_SEQ_SPLIT_143 # define BOOST_PP_SEQ_SPLIT_145(x) (x) BOOST_PP_SEQ_SPLIT_144 # define BOOST_PP_SEQ_SPLIT_146(x) (x) BOOST_PP_SEQ_SPLIT_145 # define BOOST_PP_SEQ_SPLIT_147(x) (x) BOOST_PP_SEQ_SPLIT_146 # define BOOST_PP_SEQ_SPLIT_148(x) (x) BOOST_PP_SEQ_SPLIT_147 # define BOOST_PP_SEQ_SPLIT_149(x) (x) BOOST_PP_SEQ_SPLIT_148 # define BOOST_PP_SEQ_SPLIT_150(x) (x) BOOST_PP_SEQ_SPLIT_149 # define BOOST_PP_SEQ_SPLIT_151(x) (x) BOOST_PP_SEQ_SPLIT_150 # define BOOST_PP_SEQ_SPLIT_152(x) (x) BOOST_PP_SEQ_SPLIT_151 # define BOOST_PP_SEQ_SPLIT_153(x) (x) BOOST_PP_SEQ_SPLIT_152 # define BOOST_PP_SEQ_SPLIT_154(x) (x) BOOST_PP_SEQ_SPLIT_153 # define BOOST_PP_SEQ_SPLIT_155(x) (x) BOOST_PP_SEQ_SPLIT_154 # define BOOST_PP_SEQ_SPLIT_156(x) (x) BOOST_PP_SEQ_SPLIT_155 # define BOOST_PP_SEQ_SPLIT_157(x) (x) BOOST_PP_SEQ_SPLIT_156 # define BOOST_PP_SEQ_SPLIT_158(x) (x) BOOST_PP_SEQ_SPLIT_157 # define BOOST_PP_SEQ_SPLIT_159(x) (x) BOOST_PP_SEQ_SPLIT_158 # define BOOST_PP_SEQ_SPLIT_160(x) (x) BOOST_PP_SEQ_SPLIT_159 # define BOOST_PP_SEQ_SPLIT_161(x) (x) BOOST_PP_SEQ_SPLIT_160 # define BOOST_PP_SEQ_SPLIT_162(x) (x) BOOST_PP_SEQ_SPLIT_161 # define BOOST_PP_SEQ_SPLIT_163(x) (x) BOOST_PP_SEQ_SPLIT_162 # define BOOST_PP_SEQ_SPLIT_164(x) (x) BOOST_PP_SEQ_SPLIT_163 # define BOOST_PP_SEQ_SPLIT_165(x) (x) BOOST_PP_SEQ_SPLIT_164 # define BOOST_PP_SEQ_SPLIT_166(x) (x) BOOST_PP_SEQ_SPLIT_165 # define BOOST_PP_SEQ_SPLIT_167(x) (x) BOOST_PP_SEQ_SPLIT_166 # define BOOST_PP_SEQ_SPLIT_168(x) (x) BOOST_PP_SEQ_SPLIT_167 # define BOOST_PP_SEQ_SPLIT_169(x) (x) BOOST_PP_SEQ_SPLIT_168 # define BOOST_PP_SEQ_SPLIT_170(x) (x) BOOST_PP_SEQ_SPLIT_169 # define BOOST_PP_SEQ_SPLIT_171(x) (x) BOOST_PP_SEQ_SPLIT_170 # define BOOST_PP_SEQ_SPLIT_172(x) (x) BOOST_PP_SEQ_SPLIT_171 # define BOOST_PP_SEQ_SPLIT_173(x) (x) BOOST_PP_SEQ_SPLIT_172 # define BOOST_PP_SEQ_SPLIT_174(x) (x) BOOST_PP_SEQ_SPLIT_173 # define BOOST_PP_SEQ_SPLIT_175(x) (x) BOOST_PP_SEQ_SPLIT_174 # define BOOST_PP_SEQ_SPLIT_176(x) (x) BOOST_PP_SEQ_SPLIT_175 # define BOOST_PP_SEQ_SPLIT_177(x) (x) BOOST_PP_SEQ_SPLIT_176 # define BOOST_PP_SEQ_SPLIT_178(x) (x) BOOST_PP_SEQ_SPLIT_177 # define BOOST_PP_SEQ_SPLIT_179(x) (x) BOOST_PP_SEQ_SPLIT_178 # define BOOST_PP_SEQ_SPLIT_180(x) (x) BOOST_PP_SEQ_SPLIT_179 # define BOOST_PP_SEQ_SPLIT_181(x) (x) BOOST_PP_SEQ_SPLIT_180 # define BOOST_PP_SEQ_SPLIT_182(x) (x) BOOST_PP_SEQ_SPLIT_181 # define BOOST_PP_SEQ_SPLIT_183(x) (x) BOOST_PP_SEQ_SPLIT_182 # define BOOST_PP_SEQ_SPLIT_184(x) (x) BOOST_PP_SEQ_SPLIT_183 # define BOOST_PP_SEQ_SPLIT_185(x) (x) BOOST_PP_SEQ_SPLIT_184 # define BOOST_PP_SEQ_SPLIT_186(x) (x) BOOST_PP_SEQ_SPLIT_185 # define BOOST_PP_SEQ_SPLIT_187(x) (x) BOOST_PP_SEQ_SPLIT_186 # define BOOST_PP_SEQ_SPLIT_188(x) (x) BOOST_PP_SEQ_SPLIT_187 # define BOOST_PP_SEQ_SPLIT_189(x) (x) BOOST_PP_SEQ_SPLIT_188 # define BOOST_PP_SEQ_SPLIT_190(x) (x) BOOST_PP_SEQ_SPLIT_189 # define BOOST_PP_SEQ_SPLIT_191(x) (x) BOOST_PP_SEQ_SPLIT_190 # define BOOST_PP_SEQ_SPLIT_192(x) (x) BOOST_PP_SEQ_SPLIT_191 # define BOOST_PP_SEQ_SPLIT_193(x) (x) BOOST_PP_SEQ_SPLIT_192 # define BOOST_PP_SEQ_SPLIT_194(x) (x) BOOST_PP_SEQ_SPLIT_193 # define BOOST_PP_SEQ_SPLIT_195(x) (x) BOOST_PP_SEQ_SPLIT_194 # define BOOST_PP_SEQ_SPLIT_196(x) (x) BOOST_PP_SEQ_SPLIT_195 # define BOOST_PP_SEQ_SPLIT_197(x) (x) BOOST_PP_SEQ_SPLIT_196 # define BOOST_PP_SEQ_SPLIT_198(x) (x) BOOST_PP_SEQ_SPLIT_197 # define BOOST_PP_SEQ_SPLIT_199(x) (x) BOOST_PP_SEQ_SPLIT_198 # define BOOST_PP_SEQ_SPLIT_200(x) (x) BOOST_PP_SEQ_SPLIT_199 # define BOOST_PP_SEQ_SPLIT_201(x) (x) BOOST_PP_SEQ_SPLIT_200 # define BOOST_PP_SEQ_SPLIT_202(x) (x) BOOST_PP_SEQ_SPLIT_201 # define BOOST_PP_SEQ_SPLIT_203(x) (x) BOOST_PP_SEQ_SPLIT_202 # define BOOST_PP_SEQ_SPLIT_204(x) (x) BOOST_PP_SEQ_SPLIT_203 # define BOOST_PP_SEQ_SPLIT_205(x) (x) BOOST_PP_SEQ_SPLIT_204 # define BOOST_PP_SEQ_SPLIT_206(x) (x) BOOST_PP_SEQ_SPLIT_205 # define BOOST_PP_SEQ_SPLIT_207(x) (x) BOOST_PP_SEQ_SPLIT_206 # define BOOST_PP_SEQ_SPLIT_208(x) (x) BOOST_PP_SEQ_SPLIT_207 # define BOOST_PP_SEQ_SPLIT_209(x) (x) BOOST_PP_SEQ_SPLIT_208 # define BOOST_PP_SEQ_SPLIT_210(x) (x) BOOST_PP_SEQ_SPLIT_209 # define BOOST_PP_SEQ_SPLIT_211(x) (x) BOOST_PP_SEQ_SPLIT_210 # define BOOST_PP_SEQ_SPLIT_212(x) (x) BOOST_PP_SEQ_SPLIT_211 # define BOOST_PP_SEQ_SPLIT_213(x) (x) BOOST_PP_SEQ_SPLIT_212 # define BOOST_PP_SEQ_SPLIT_214(x) (x) BOOST_PP_SEQ_SPLIT_213 # define BOOST_PP_SEQ_SPLIT_215(x) (x) BOOST_PP_SEQ_SPLIT_214 # define BOOST_PP_SEQ_SPLIT_216(x) (x) BOOST_PP_SEQ_SPLIT_215 # define BOOST_PP_SEQ_SPLIT_217(x) (x) BOOST_PP_SEQ_SPLIT_216 # define BOOST_PP_SEQ_SPLIT_218(x) (x) BOOST_PP_SEQ_SPLIT_217 # define BOOST_PP_SEQ_SPLIT_219(x) (x) BOOST_PP_SEQ_SPLIT_218 # define BOOST_PP_SEQ_SPLIT_220(x) (x) BOOST_PP_SEQ_SPLIT_219 # define BOOST_PP_SEQ_SPLIT_221(x) (x) BOOST_PP_SEQ_SPLIT_220 # define BOOST_PP_SEQ_SPLIT_222(x) (x) BOOST_PP_SEQ_SPLIT_221 # define BOOST_PP_SEQ_SPLIT_223(x) (x) BOOST_PP_SEQ_SPLIT_222 # define BOOST_PP_SEQ_SPLIT_224(x) (x) BOOST_PP_SEQ_SPLIT_223 # define BOOST_PP_SEQ_SPLIT_225(x) (x) BOOST_PP_SEQ_SPLIT_224 # define BOOST_PP_SEQ_SPLIT_226(x) (x) BOOST_PP_SEQ_SPLIT_225 # define BOOST_PP_SEQ_SPLIT_227(x) (x) BOOST_PP_SEQ_SPLIT_226 # define BOOST_PP_SEQ_SPLIT_228(x) (x) BOOST_PP_SEQ_SPLIT_227 # define BOOST_PP_SEQ_SPLIT_229(x) (x) BOOST_PP_SEQ_SPLIT_228 # define BOOST_PP_SEQ_SPLIT_230(x) (x) BOOST_PP_SEQ_SPLIT_229 # define BOOST_PP_SEQ_SPLIT_231(x) (x) BOOST_PP_SEQ_SPLIT_230 # define BOOST_PP_SEQ_SPLIT_232(x) (x) BOOST_PP_SEQ_SPLIT_231 # define BOOST_PP_SEQ_SPLIT_233(x) (x) BOOST_PP_SEQ_SPLIT_232 # define BOOST_PP_SEQ_SPLIT_234(x) (x) BOOST_PP_SEQ_SPLIT_233 # define BOOST_PP_SEQ_SPLIT_235(x) (x) BOOST_PP_SEQ_SPLIT_234 # define BOOST_PP_SEQ_SPLIT_236(x) (x) BOOST_PP_SEQ_SPLIT_235 # define BOOST_PP_SEQ_SPLIT_237(x) (x) BOOST_PP_SEQ_SPLIT_236 # define BOOST_PP_SEQ_SPLIT_238(x) (x) BOOST_PP_SEQ_SPLIT_237 # define BOOST_PP_SEQ_SPLIT_239(x) (x) BOOST_PP_SEQ_SPLIT_238 # define BOOST_PP_SEQ_SPLIT_240(x) (x) BOOST_PP_SEQ_SPLIT_239 # define BOOST_PP_SEQ_SPLIT_241(x) (x) BOOST_PP_SEQ_SPLIT_240 # define BOOST_PP_SEQ_SPLIT_242(x) (x) BOOST_PP_SEQ_SPLIT_241 # define BOOST_PP_SEQ_SPLIT_243(x) (x) BOOST_PP_SEQ_SPLIT_242 # define BOOST_PP_SEQ_SPLIT_244(x) (x) BOOST_PP_SEQ_SPLIT_243 # define BOOST_PP_SEQ_SPLIT_245(x) (x) BOOST_PP_SEQ_SPLIT_244 # define BOOST_PP_SEQ_SPLIT_246(x) (x) BOOST_PP_SEQ_SPLIT_245 # define BOOST_PP_SEQ_SPLIT_247(x) (x) BOOST_PP_SEQ_SPLIT_246 # define BOOST_PP_SEQ_SPLIT_248(x) (x) BOOST_PP_SEQ_SPLIT_247 # define BOOST_PP_SEQ_SPLIT_249(x) (x) BOOST_PP_SEQ_SPLIT_248 # define BOOST_PP_SEQ_SPLIT_250(x) (x) BOOST_PP_SEQ_SPLIT_249 # define BOOST_PP_SEQ_SPLIT_251(x) (x) BOOST_PP_SEQ_SPLIT_250 # define BOOST_PP_SEQ_SPLIT_252(x) (x) BOOST_PP_SEQ_SPLIT_251 # define BOOST_PP_SEQ_SPLIT_253(x) (x) BOOST_PP_SEQ_SPLIT_252 # define BOOST_PP_SEQ_SPLIT_254(x) (x) BOOST_PP_SEQ_SPLIT_253 # define BOOST_PP_SEQ_SPLIT_255(x) (x) BOOST_PP_SEQ_SPLIT_254 # define BOOST_PP_SEQ_SPLIT_256(x) (x) BOOST_PP_SEQ_SPLIT_255 # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/subseq.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/subs0000644000175000017500000000231111344301502031654 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_SUBSEQ_HPP # define BOOST_PREPROCESSOR_SEQ_SUBSEQ_HPP # # include # include # include # # /* BOOST_PP_SEQ_SUBSEQ */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_SUBSEQ(seq, i, len) BOOST_PP_SEQ_FIRST_N(len, BOOST_PP_SEQ_REST_N(i, seq)) # else # define BOOST_PP_SEQ_SUBSEQ(seq, i, len) BOOST_PP_SEQ_SUBSEQ_I(seq, i, len) # define BOOST_PP_SEQ_SUBSEQ_I(seq, i, len) BOOST_PP_SEQ_FIRST_N(len, BOOST_PP_SEQ_REST_N(i, seq)) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/pop_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/seq/pop_0000644000175000017500000000211411344301502031636 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SEQ_POP_FRONT_HPP # define BOOST_PREPROCESSOR_SEQ_POP_FRONT_HPP # # include # include # # /* BOOST_PP_SEQ_POP_FRONT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_SEQ_POP_FRONT(seq) BOOST_PP_SEQ_TAIL(seq) # else # define BOOST_PP_SEQ_POP_FRONT(seq) BOOST_PP_SEQ_POP_FRONT_I(seq) # define BOOST_PP_SEQ_POP_FRONT_I(seq) BOOST_PP_SEQ_TAIL(seq) # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comma_if.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/comma_if0000644000175000017500000000136011344301502031665 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_COMMA_IF_HPP # define BOOST_PREPROCESSOR_COMMA_IF_HPP # # include # # endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000755000175000017500000000000012146213764031746 5ustar debiandebian././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/self.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000146411344301502031740 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ITERATION_SELF_HPP # define BOOST_PREPROCESSOR_ITERATION_SELF_HPP # # /* BOOST_PP_INCLUDE_SELF */ # # define BOOST_PP_INCLUDE_SELF() # # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/iterate.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000716411344301502031743 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ITERATION_ITERATE_HPP # define BOOST_PREPROCESSOR_ITERATION_ITERATE_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_ITERATION_DEPTH */ # # define BOOST_PP_ITERATION_DEPTH() 0 # # /* BOOST_PP_ITERATION */ # # define BOOST_PP_ITERATION() BOOST_PP_CAT(BOOST_PP_ITERATION_, BOOST_PP_ITERATION_DEPTH()) # # /* BOOST_PP_ITERATION_START && BOOST_PP_ITERATION_FINISH */ # # define BOOST_PP_ITERATION_START() BOOST_PP_CAT(BOOST_PP_ITERATION_START_, BOOST_PP_ITERATION_DEPTH()) # define BOOST_PP_ITERATION_FINISH() BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, BOOST_PP_ITERATION_DEPTH()) # # /* BOOST_PP_ITERATION_FLAGS */ # # define BOOST_PP_ITERATION_FLAGS() (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, BOOST_PP_ITERATION_DEPTH())) # # /* BOOST_PP_FRAME_ITERATION */ # # define BOOST_PP_FRAME_ITERATION(i) BOOST_PP_CAT(BOOST_PP_ITERATION_, i) # # /* BOOST_PP_FRAME_START && BOOST_PP_FRAME_FINISH */ # # define BOOST_PP_FRAME_START(i) BOOST_PP_CAT(BOOST_PP_ITERATION_START_, i) # define BOOST_PP_FRAME_FINISH(i) BOOST_PP_CAT(BOOST_PP_ITERATION_FINISH_, i) # # /* BOOST_PP_FRAME_FLAGS */ # # define BOOST_PP_FRAME_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_ITERATION_FLAGS_, i)) # # /* BOOST_PP_RELATIVE_ITERATION */ # # define BOOST_PP_RELATIVE_ITERATION(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_) # # define BOOST_PP_RELATIVE_0(m) BOOST_PP_CAT(m, BOOST_PP_ITERATION_DEPTH()) # define BOOST_PP_RELATIVE_1(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())) # define BOOST_PP_RELATIVE_2(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))) # define BOOST_PP_RELATIVE_3(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH())))) # define BOOST_PP_RELATIVE_4(m) BOOST_PP_CAT(m, BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_DEC(BOOST_PP_ITERATION_DEPTH()))))) # # /* BOOST_PP_RELATIVE_START && BOOST_PP_RELATIVE_FINISH */ # # define BOOST_PP_RELATIVE_START(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_START_) # define BOOST_PP_RELATIVE_FINISH(i) BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FINISH_) # # /* BOOST_PP_RELATIVE_FLAGS */ # # define BOOST_PP_RELATIVE_FLAGS(i) (BOOST_PP_CAT(BOOST_PP_RELATIVE_, i)(BOOST_PP_ITERATION_FLAGS_)) # # /* BOOST_PP_ITERATE */ # # define BOOST_PP_ITERATE() BOOST_PP_CAT(BOOST_PP_ITERATE_, BOOST_PP_INC(BOOST_PP_ITERATION_DEPTH())) # # define BOOST_PP_ITERATE_1 # define BOOST_PP_ITERATE_2 # define BOOST_PP_ITERATE_3 # define BOOST_PP_ITERATE_4 # define BOOST_PP_ITERATE_5 # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/local.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000215111344301502031732 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ITERATION_LOCAL_HPP # define BOOST_PREPROCESSOR_ITERATION_LOCAL_HPP # # include # include # include # # /* BOOST_PP_LOCAL_ITERATE */ # # define BOOST_PP_LOCAL_ITERATE() # # define BOOST_PP_LOCAL_C(n) (BOOST_PP_LOCAL_S) <= n && (BOOST_PP_LOCAL_F) >= n # define BOOST_PP_LOCAL_R(n) (BOOST_PP_LOCAL_F) <= n && (BOOST_PP_LOCAL_S) >= n # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000755000175000017500000000000012146213764031746 5ustar debiandebian././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/self.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000150111344301502031730 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if !defined(BOOST_PP_INDIRECT_SELF) # error BOOST_PP_ERROR: no indirect file to include # endif # # define BOOST_PP_IS_SELFISH 1 # # include BOOST_PP_INDIRECT_SELF # # undef BOOST_PP_IS_SELFISH # undef BOOST_PP_INDIRECT_SELF ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000755000175000017500000000000012146213765031747 5ustar debiandebian././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/reverse2.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000013631311344301502031742 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if BOOST_PP_ITERATION_FINISH_2 <= 256 && BOOST_PP_ITERATION_START_2 >= 256 # define BOOST_PP_ITERATION_2 256 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 255 && BOOST_PP_ITERATION_START_2 >= 255 # define BOOST_PP_ITERATION_2 255 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 254 && BOOST_PP_ITERATION_START_2 >= 254 # define BOOST_PP_ITERATION_2 254 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 253 && BOOST_PP_ITERATION_START_2 >= 253 # define BOOST_PP_ITERATION_2 253 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 252 && BOOST_PP_ITERATION_START_2 >= 252 # define BOOST_PP_ITERATION_2 252 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 251 && BOOST_PP_ITERATION_START_2 >= 251 # define BOOST_PP_ITERATION_2 251 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 250 && BOOST_PP_ITERATION_START_2 >= 250 # define BOOST_PP_ITERATION_2 250 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 249 && BOOST_PP_ITERATION_START_2 >= 249 # define BOOST_PP_ITERATION_2 249 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 248 && BOOST_PP_ITERATION_START_2 >= 248 # define BOOST_PP_ITERATION_2 248 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 247 && BOOST_PP_ITERATION_START_2 >= 247 # define BOOST_PP_ITERATION_2 247 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 246 && BOOST_PP_ITERATION_START_2 >= 246 # define BOOST_PP_ITERATION_2 246 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 245 && BOOST_PP_ITERATION_START_2 >= 245 # define BOOST_PP_ITERATION_2 245 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 244 && BOOST_PP_ITERATION_START_2 >= 244 # define BOOST_PP_ITERATION_2 244 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 243 && BOOST_PP_ITERATION_START_2 >= 243 # define BOOST_PP_ITERATION_2 243 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 242 && BOOST_PP_ITERATION_START_2 >= 242 # define BOOST_PP_ITERATION_2 242 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 241 && BOOST_PP_ITERATION_START_2 >= 241 # define BOOST_PP_ITERATION_2 241 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 240 && BOOST_PP_ITERATION_START_2 >= 240 # define BOOST_PP_ITERATION_2 240 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 239 && BOOST_PP_ITERATION_START_2 >= 239 # define BOOST_PP_ITERATION_2 239 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 238 && BOOST_PP_ITERATION_START_2 >= 238 # define BOOST_PP_ITERATION_2 238 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 237 && BOOST_PP_ITERATION_START_2 >= 237 # define BOOST_PP_ITERATION_2 237 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 236 && BOOST_PP_ITERATION_START_2 >= 236 # define BOOST_PP_ITERATION_2 236 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 235 && BOOST_PP_ITERATION_START_2 >= 235 # define BOOST_PP_ITERATION_2 235 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 234 && BOOST_PP_ITERATION_START_2 >= 234 # define BOOST_PP_ITERATION_2 234 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 233 && BOOST_PP_ITERATION_START_2 >= 233 # define BOOST_PP_ITERATION_2 233 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 232 && BOOST_PP_ITERATION_START_2 >= 232 # define BOOST_PP_ITERATION_2 232 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 231 && BOOST_PP_ITERATION_START_2 >= 231 # define BOOST_PP_ITERATION_2 231 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 230 && BOOST_PP_ITERATION_START_2 >= 230 # define BOOST_PP_ITERATION_2 230 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 229 && BOOST_PP_ITERATION_START_2 >= 229 # define BOOST_PP_ITERATION_2 229 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 228 && BOOST_PP_ITERATION_START_2 >= 228 # define BOOST_PP_ITERATION_2 228 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 227 && BOOST_PP_ITERATION_START_2 >= 227 # define BOOST_PP_ITERATION_2 227 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 226 && BOOST_PP_ITERATION_START_2 >= 226 # define BOOST_PP_ITERATION_2 226 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 225 && BOOST_PP_ITERATION_START_2 >= 225 # define BOOST_PP_ITERATION_2 225 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 224 && BOOST_PP_ITERATION_START_2 >= 224 # define BOOST_PP_ITERATION_2 224 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 223 && BOOST_PP_ITERATION_START_2 >= 223 # define BOOST_PP_ITERATION_2 223 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 222 && BOOST_PP_ITERATION_START_2 >= 222 # define BOOST_PP_ITERATION_2 222 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 221 && BOOST_PP_ITERATION_START_2 >= 221 # define BOOST_PP_ITERATION_2 221 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 220 && BOOST_PP_ITERATION_START_2 >= 220 # define BOOST_PP_ITERATION_2 220 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 219 && BOOST_PP_ITERATION_START_2 >= 219 # define BOOST_PP_ITERATION_2 219 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 218 && BOOST_PP_ITERATION_START_2 >= 218 # define BOOST_PP_ITERATION_2 218 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 217 && BOOST_PP_ITERATION_START_2 >= 217 # define BOOST_PP_ITERATION_2 217 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 216 && BOOST_PP_ITERATION_START_2 >= 216 # define BOOST_PP_ITERATION_2 216 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 215 && BOOST_PP_ITERATION_START_2 >= 215 # define BOOST_PP_ITERATION_2 215 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 214 && BOOST_PP_ITERATION_START_2 >= 214 # define BOOST_PP_ITERATION_2 214 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 213 && BOOST_PP_ITERATION_START_2 >= 213 # define BOOST_PP_ITERATION_2 213 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 212 && BOOST_PP_ITERATION_START_2 >= 212 # define BOOST_PP_ITERATION_2 212 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 211 && BOOST_PP_ITERATION_START_2 >= 211 # define BOOST_PP_ITERATION_2 211 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 210 && BOOST_PP_ITERATION_START_2 >= 210 # define BOOST_PP_ITERATION_2 210 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 209 && BOOST_PP_ITERATION_START_2 >= 209 # define BOOST_PP_ITERATION_2 209 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 208 && BOOST_PP_ITERATION_START_2 >= 208 # define BOOST_PP_ITERATION_2 208 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 207 && BOOST_PP_ITERATION_START_2 >= 207 # define BOOST_PP_ITERATION_2 207 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 206 && BOOST_PP_ITERATION_START_2 >= 206 # define BOOST_PP_ITERATION_2 206 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 205 && BOOST_PP_ITERATION_START_2 >= 205 # define BOOST_PP_ITERATION_2 205 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 204 && BOOST_PP_ITERATION_START_2 >= 204 # define BOOST_PP_ITERATION_2 204 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 203 && BOOST_PP_ITERATION_START_2 >= 203 # define BOOST_PP_ITERATION_2 203 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 202 && BOOST_PP_ITERATION_START_2 >= 202 # define BOOST_PP_ITERATION_2 202 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 201 && BOOST_PP_ITERATION_START_2 >= 201 # define BOOST_PP_ITERATION_2 201 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 200 && BOOST_PP_ITERATION_START_2 >= 200 # define BOOST_PP_ITERATION_2 200 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 199 && BOOST_PP_ITERATION_START_2 >= 199 # define BOOST_PP_ITERATION_2 199 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 198 && BOOST_PP_ITERATION_START_2 >= 198 # define BOOST_PP_ITERATION_2 198 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 197 && BOOST_PP_ITERATION_START_2 >= 197 # define BOOST_PP_ITERATION_2 197 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 196 && BOOST_PP_ITERATION_START_2 >= 196 # define BOOST_PP_ITERATION_2 196 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 195 && BOOST_PP_ITERATION_START_2 >= 195 # define BOOST_PP_ITERATION_2 195 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 194 && BOOST_PP_ITERATION_START_2 >= 194 # define BOOST_PP_ITERATION_2 194 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 193 && BOOST_PP_ITERATION_START_2 >= 193 # define BOOST_PP_ITERATION_2 193 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 192 && BOOST_PP_ITERATION_START_2 >= 192 # define BOOST_PP_ITERATION_2 192 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 191 && BOOST_PP_ITERATION_START_2 >= 191 # define BOOST_PP_ITERATION_2 191 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 190 && BOOST_PP_ITERATION_START_2 >= 190 # define BOOST_PP_ITERATION_2 190 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 189 && BOOST_PP_ITERATION_START_2 >= 189 # define BOOST_PP_ITERATION_2 189 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 188 && BOOST_PP_ITERATION_START_2 >= 188 # define BOOST_PP_ITERATION_2 188 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 187 && BOOST_PP_ITERATION_START_2 >= 187 # define BOOST_PP_ITERATION_2 187 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 186 && BOOST_PP_ITERATION_START_2 >= 186 # define BOOST_PP_ITERATION_2 186 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 185 && BOOST_PP_ITERATION_START_2 >= 185 # define BOOST_PP_ITERATION_2 185 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 184 && BOOST_PP_ITERATION_START_2 >= 184 # define BOOST_PP_ITERATION_2 184 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 183 && BOOST_PP_ITERATION_START_2 >= 183 # define BOOST_PP_ITERATION_2 183 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 182 && BOOST_PP_ITERATION_START_2 >= 182 # define BOOST_PP_ITERATION_2 182 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 181 && BOOST_PP_ITERATION_START_2 >= 181 # define BOOST_PP_ITERATION_2 181 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 180 && BOOST_PP_ITERATION_START_2 >= 180 # define BOOST_PP_ITERATION_2 180 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 179 && BOOST_PP_ITERATION_START_2 >= 179 # define BOOST_PP_ITERATION_2 179 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 178 && BOOST_PP_ITERATION_START_2 >= 178 # define BOOST_PP_ITERATION_2 178 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 177 && BOOST_PP_ITERATION_START_2 >= 177 # define BOOST_PP_ITERATION_2 177 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 176 && BOOST_PP_ITERATION_START_2 >= 176 # define BOOST_PP_ITERATION_2 176 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 175 && BOOST_PP_ITERATION_START_2 >= 175 # define BOOST_PP_ITERATION_2 175 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 174 && BOOST_PP_ITERATION_START_2 >= 174 # define BOOST_PP_ITERATION_2 174 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 173 && BOOST_PP_ITERATION_START_2 >= 173 # define BOOST_PP_ITERATION_2 173 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 172 && BOOST_PP_ITERATION_START_2 >= 172 # define BOOST_PP_ITERATION_2 172 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 171 && BOOST_PP_ITERATION_START_2 >= 171 # define BOOST_PP_ITERATION_2 171 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 170 && BOOST_PP_ITERATION_START_2 >= 170 # define BOOST_PP_ITERATION_2 170 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 169 && BOOST_PP_ITERATION_START_2 >= 169 # define BOOST_PP_ITERATION_2 169 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 168 && BOOST_PP_ITERATION_START_2 >= 168 # define BOOST_PP_ITERATION_2 168 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 167 && BOOST_PP_ITERATION_START_2 >= 167 # define BOOST_PP_ITERATION_2 167 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 166 && BOOST_PP_ITERATION_START_2 >= 166 # define BOOST_PP_ITERATION_2 166 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 165 && BOOST_PP_ITERATION_START_2 >= 165 # define BOOST_PP_ITERATION_2 165 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 164 && BOOST_PP_ITERATION_START_2 >= 164 # define BOOST_PP_ITERATION_2 164 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 163 && BOOST_PP_ITERATION_START_2 >= 163 # define BOOST_PP_ITERATION_2 163 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 162 && BOOST_PP_ITERATION_START_2 >= 162 # define BOOST_PP_ITERATION_2 162 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 161 && BOOST_PP_ITERATION_START_2 >= 161 # define BOOST_PP_ITERATION_2 161 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 160 && BOOST_PP_ITERATION_START_2 >= 160 # define BOOST_PP_ITERATION_2 160 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 159 && BOOST_PP_ITERATION_START_2 >= 159 # define BOOST_PP_ITERATION_2 159 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 158 && BOOST_PP_ITERATION_START_2 >= 158 # define BOOST_PP_ITERATION_2 158 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 157 && BOOST_PP_ITERATION_START_2 >= 157 # define BOOST_PP_ITERATION_2 157 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 156 && BOOST_PP_ITERATION_START_2 >= 156 # define BOOST_PP_ITERATION_2 156 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 155 && BOOST_PP_ITERATION_START_2 >= 155 # define BOOST_PP_ITERATION_2 155 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 154 && BOOST_PP_ITERATION_START_2 >= 154 # define BOOST_PP_ITERATION_2 154 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 153 && BOOST_PP_ITERATION_START_2 >= 153 # define BOOST_PP_ITERATION_2 153 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 152 && BOOST_PP_ITERATION_START_2 >= 152 # define BOOST_PP_ITERATION_2 152 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 151 && BOOST_PP_ITERATION_START_2 >= 151 # define BOOST_PP_ITERATION_2 151 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 150 && BOOST_PP_ITERATION_START_2 >= 150 # define BOOST_PP_ITERATION_2 150 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 149 && BOOST_PP_ITERATION_START_2 >= 149 # define BOOST_PP_ITERATION_2 149 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 148 && BOOST_PP_ITERATION_START_2 >= 148 # define BOOST_PP_ITERATION_2 148 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 147 && BOOST_PP_ITERATION_START_2 >= 147 # define BOOST_PP_ITERATION_2 147 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 146 && BOOST_PP_ITERATION_START_2 >= 146 # define BOOST_PP_ITERATION_2 146 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 145 && BOOST_PP_ITERATION_START_2 >= 145 # define BOOST_PP_ITERATION_2 145 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 144 && BOOST_PP_ITERATION_START_2 >= 144 # define BOOST_PP_ITERATION_2 144 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 143 && BOOST_PP_ITERATION_START_2 >= 143 # define BOOST_PP_ITERATION_2 143 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 142 && BOOST_PP_ITERATION_START_2 >= 142 # define BOOST_PP_ITERATION_2 142 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 141 && BOOST_PP_ITERATION_START_2 >= 141 # define BOOST_PP_ITERATION_2 141 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 140 && BOOST_PP_ITERATION_START_2 >= 140 # define BOOST_PP_ITERATION_2 140 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 139 && BOOST_PP_ITERATION_START_2 >= 139 # define BOOST_PP_ITERATION_2 139 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 138 && BOOST_PP_ITERATION_START_2 >= 138 # define BOOST_PP_ITERATION_2 138 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 137 && BOOST_PP_ITERATION_START_2 >= 137 # define BOOST_PP_ITERATION_2 137 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 136 && BOOST_PP_ITERATION_START_2 >= 136 # define BOOST_PP_ITERATION_2 136 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 135 && BOOST_PP_ITERATION_START_2 >= 135 # define BOOST_PP_ITERATION_2 135 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 134 && BOOST_PP_ITERATION_START_2 >= 134 # define BOOST_PP_ITERATION_2 134 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 133 && BOOST_PP_ITERATION_START_2 >= 133 # define BOOST_PP_ITERATION_2 133 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 132 && BOOST_PP_ITERATION_START_2 >= 132 # define BOOST_PP_ITERATION_2 132 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 131 && BOOST_PP_ITERATION_START_2 >= 131 # define BOOST_PP_ITERATION_2 131 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 130 && BOOST_PP_ITERATION_START_2 >= 130 # define BOOST_PP_ITERATION_2 130 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 129 && BOOST_PP_ITERATION_START_2 >= 129 # define BOOST_PP_ITERATION_2 129 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 128 && BOOST_PP_ITERATION_START_2 >= 128 # define BOOST_PP_ITERATION_2 128 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 127 && BOOST_PP_ITERATION_START_2 >= 127 # define BOOST_PP_ITERATION_2 127 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 126 && BOOST_PP_ITERATION_START_2 >= 126 # define BOOST_PP_ITERATION_2 126 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 125 && BOOST_PP_ITERATION_START_2 >= 125 # define BOOST_PP_ITERATION_2 125 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 124 && BOOST_PP_ITERATION_START_2 >= 124 # define BOOST_PP_ITERATION_2 124 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 123 && BOOST_PP_ITERATION_START_2 >= 123 # define BOOST_PP_ITERATION_2 123 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 122 && BOOST_PP_ITERATION_START_2 >= 122 # define BOOST_PP_ITERATION_2 122 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 121 && BOOST_PP_ITERATION_START_2 >= 121 # define BOOST_PP_ITERATION_2 121 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 120 && BOOST_PP_ITERATION_START_2 >= 120 # define BOOST_PP_ITERATION_2 120 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 119 && BOOST_PP_ITERATION_START_2 >= 119 # define BOOST_PP_ITERATION_2 119 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 118 && BOOST_PP_ITERATION_START_2 >= 118 # define BOOST_PP_ITERATION_2 118 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 117 && BOOST_PP_ITERATION_START_2 >= 117 # define BOOST_PP_ITERATION_2 117 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 116 && BOOST_PP_ITERATION_START_2 >= 116 # define BOOST_PP_ITERATION_2 116 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 115 && BOOST_PP_ITERATION_START_2 >= 115 # define BOOST_PP_ITERATION_2 115 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 114 && BOOST_PP_ITERATION_START_2 >= 114 # define BOOST_PP_ITERATION_2 114 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 113 && BOOST_PP_ITERATION_START_2 >= 113 # define BOOST_PP_ITERATION_2 113 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 112 && BOOST_PP_ITERATION_START_2 >= 112 # define BOOST_PP_ITERATION_2 112 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 111 && BOOST_PP_ITERATION_START_2 >= 111 # define BOOST_PP_ITERATION_2 111 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 110 && BOOST_PP_ITERATION_START_2 >= 110 # define BOOST_PP_ITERATION_2 110 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 109 && BOOST_PP_ITERATION_START_2 >= 109 # define BOOST_PP_ITERATION_2 109 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 108 && BOOST_PP_ITERATION_START_2 >= 108 # define BOOST_PP_ITERATION_2 108 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 107 && BOOST_PP_ITERATION_START_2 >= 107 # define BOOST_PP_ITERATION_2 107 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 106 && BOOST_PP_ITERATION_START_2 >= 106 # define BOOST_PP_ITERATION_2 106 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 105 && BOOST_PP_ITERATION_START_2 >= 105 # define BOOST_PP_ITERATION_2 105 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 104 && BOOST_PP_ITERATION_START_2 >= 104 # define BOOST_PP_ITERATION_2 104 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 103 && BOOST_PP_ITERATION_START_2 >= 103 # define BOOST_PP_ITERATION_2 103 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 102 && BOOST_PP_ITERATION_START_2 >= 102 # define BOOST_PP_ITERATION_2 102 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 101 && BOOST_PP_ITERATION_START_2 >= 101 # define BOOST_PP_ITERATION_2 101 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 100 && BOOST_PP_ITERATION_START_2 >= 100 # define BOOST_PP_ITERATION_2 100 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 99 && BOOST_PP_ITERATION_START_2 >= 99 # define BOOST_PP_ITERATION_2 99 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 98 && BOOST_PP_ITERATION_START_2 >= 98 # define BOOST_PP_ITERATION_2 98 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 97 && BOOST_PP_ITERATION_START_2 >= 97 # define BOOST_PP_ITERATION_2 97 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 96 && BOOST_PP_ITERATION_START_2 >= 96 # define BOOST_PP_ITERATION_2 96 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 95 && BOOST_PP_ITERATION_START_2 >= 95 # define BOOST_PP_ITERATION_2 95 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 94 && BOOST_PP_ITERATION_START_2 >= 94 # define BOOST_PP_ITERATION_2 94 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 93 && BOOST_PP_ITERATION_START_2 >= 93 # define BOOST_PP_ITERATION_2 93 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 92 && BOOST_PP_ITERATION_START_2 >= 92 # define BOOST_PP_ITERATION_2 92 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 91 && BOOST_PP_ITERATION_START_2 >= 91 # define BOOST_PP_ITERATION_2 91 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 90 && BOOST_PP_ITERATION_START_2 >= 90 # define BOOST_PP_ITERATION_2 90 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 89 && BOOST_PP_ITERATION_START_2 >= 89 # define BOOST_PP_ITERATION_2 89 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 88 && BOOST_PP_ITERATION_START_2 >= 88 # define BOOST_PP_ITERATION_2 88 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 87 && BOOST_PP_ITERATION_START_2 >= 87 # define BOOST_PP_ITERATION_2 87 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 86 && BOOST_PP_ITERATION_START_2 >= 86 # define BOOST_PP_ITERATION_2 86 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 85 && BOOST_PP_ITERATION_START_2 >= 85 # define BOOST_PP_ITERATION_2 85 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 84 && BOOST_PP_ITERATION_START_2 >= 84 # define BOOST_PP_ITERATION_2 84 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 83 && BOOST_PP_ITERATION_START_2 >= 83 # define BOOST_PP_ITERATION_2 83 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 82 && BOOST_PP_ITERATION_START_2 >= 82 # define BOOST_PP_ITERATION_2 82 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 81 && BOOST_PP_ITERATION_START_2 >= 81 # define BOOST_PP_ITERATION_2 81 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 80 && BOOST_PP_ITERATION_START_2 >= 80 # define BOOST_PP_ITERATION_2 80 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 79 && BOOST_PP_ITERATION_START_2 >= 79 # define BOOST_PP_ITERATION_2 79 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 78 && BOOST_PP_ITERATION_START_2 >= 78 # define BOOST_PP_ITERATION_2 78 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 77 && BOOST_PP_ITERATION_START_2 >= 77 # define BOOST_PP_ITERATION_2 77 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 76 && BOOST_PP_ITERATION_START_2 >= 76 # define BOOST_PP_ITERATION_2 76 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 75 && BOOST_PP_ITERATION_START_2 >= 75 # define BOOST_PP_ITERATION_2 75 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 74 && BOOST_PP_ITERATION_START_2 >= 74 # define BOOST_PP_ITERATION_2 74 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 73 && BOOST_PP_ITERATION_START_2 >= 73 # define BOOST_PP_ITERATION_2 73 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 72 && BOOST_PP_ITERATION_START_2 >= 72 # define BOOST_PP_ITERATION_2 72 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 71 && BOOST_PP_ITERATION_START_2 >= 71 # define BOOST_PP_ITERATION_2 71 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 70 && BOOST_PP_ITERATION_START_2 >= 70 # define BOOST_PP_ITERATION_2 70 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 69 && BOOST_PP_ITERATION_START_2 >= 69 # define BOOST_PP_ITERATION_2 69 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 68 && BOOST_PP_ITERATION_START_2 >= 68 # define BOOST_PP_ITERATION_2 68 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 67 && BOOST_PP_ITERATION_START_2 >= 67 # define BOOST_PP_ITERATION_2 67 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 66 && BOOST_PP_ITERATION_START_2 >= 66 # define BOOST_PP_ITERATION_2 66 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 65 && BOOST_PP_ITERATION_START_2 >= 65 # define BOOST_PP_ITERATION_2 65 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 64 && BOOST_PP_ITERATION_START_2 >= 64 # define BOOST_PP_ITERATION_2 64 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 63 && BOOST_PP_ITERATION_START_2 >= 63 # define BOOST_PP_ITERATION_2 63 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 62 && BOOST_PP_ITERATION_START_2 >= 62 # define BOOST_PP_ITERATION_2 62 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 61 && BOOST_PP_ITERATION_START_2 >= 61 # define BOOST_PP_ITERATION_2 61 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 60 && BOOST_PP_ITERATION_START_2 >= 60 # define BOOST_PP_ITERATION_2 60 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 59 && BOOST_PP_ITERATION_START_2 >= 59 # define BOOST_PP_ITERATION_2 59 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 58 && BOOST_PP_ITERATION_START_2 >= 58 # define BOOST_PP_ITERATION_2 58 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 57 && BOOST_PP_ITERATION_START_2 >= 57 # define BOOST_PP_ITERATION_2 57 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 56 && BOOST_PP_ITERATION_START_2 >= 56 # define BOOST_PP_ITERATION_2 56 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 55 && BOOST_PP_ITERATION_START_2 >= 55 # define BOOST_PP_ITERATION_2 55 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 54 && BOOST_PP_ITERATION_START_2 >= 54 # define BOOST_PP_ITERATION_2 54 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 53 && BOOST_PP_ITERATION_START_2 >= 53 # define BOOST_PP_ITERATION_2 53 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 52 && BOOST_PP_ITERATION_START_2 >= 52 # define BOOST_PP_ITERATION_2 52 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 51 && BOOST_PP_ITERATION_START_2 >= 51 # define BOOST_PP_ITERATION_2 51 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 50 && BOOST_PP_ITERATION_START_2 >= 50 # define BOOST_PP_ITERATION_2 50 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 49 && BOOST_PP_ITERATION_START_2 >= 49 # define BOOST_PP_ITERATION_2 49 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 48 && BOOST_PP_ITERATION_START_2 >= 48 # define BOOST_PP_ITERATION_2 48 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 47 && BOOST_PP_ITERATION_START_2 >= 47 # define BOOST_PP_ITERATION_2 47 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 46 && BOOST_PP_ITERATION_START_2 >= 46 # define BOOST_PP_ITERATION_2 46 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 45 && BOOST_PP_ITERATION_START_2 >= 45 # define BOOST_PP_ITERATION_2 45 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 44 && BOOST_PP_ITERATION_START_2 >= 44 # define BOOST_PP_ITERATION_2 44 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 43 && BOOST_PP_ITERATION_START_2 >= 43 # define BOOST_PP_ITERATION_2 43 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 42 && BOOST_PP_ITERATION_START_2 >= 42 # define BOOST_PP_ITERATION_2 42 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 41 && BOOST_PP_ITERATION_START_2 >= 41 # define BOOST_PP_ITERATION_2 41 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 40 && BOOST_PP_ITERATION_START_2 >= 40 # define BOOST_PP_ITERATION_2 40 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 39 && BOOST_PP_ITERATION_START_2 >= 39 # define BOOST_PP_ITERATION_2 39 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 38 && BOOST_PP_ITERATION_START_2 >= 38 # define BOOST_PP_ITERATION_2 38 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 37 && BOOST_PP_ITERATION_START_2 >= 37 # define BOOST_PP_ITERATION_2 37 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 36 && BOOST_PP_ITERATION_START_2 >= 36 # define BOOST_PP_ITERATION_2 36 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 35 && BOOST_PP_ITERATION_START_2 >= 35 # define BOOST_PP_ITERATION_2 35 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 34 && BOOST_PP_ITERATION_START_2 >= 34 # define BOOST_PP_ITERATION_2 34 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 33 && BOOST_PP_ITERATION_START_2 >= 33 # define BOOST_PP_ITERATION_2 33 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 32 && BOOST_PP_ITERATION_START_2 >= 32 # define BOOST_PP_ITERATION_2 32 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 31 && BOOST_PP_ITERATION_START_2 >= 31 # define BOOST_PP_ITERATION_2 31 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 30 && BOOST_PP_ITERATION_START_2 >= 30 # define BOOST_PP_ITERATION_2 30 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 29 && BOOST_PP_ITERATION_START_2 >= 29 # define BOOST_PP_ITERATION_2 29 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 28 && BOOST_PP_ITERATION_START_2 >= 28 # define BOOST_PP_ITERATION_2 28 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 27 && BOOST_PP_ITERATION_START_2 >= 27 # define BOOST_PP_ITERATION_2 27 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 26 && BOOST_PP_ITERATION_START_2 >= 26 # define BOOST_PP_ITERATION_2 26 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 25 && BOOST_PP_ITERATION_START_2 >= 25 # define BOOST_PP_ITERATION_2 25 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 24 && BOOST_PP_ITERATION_START_2 >= 24 # define BOOST_PP_ITERATION_2 24 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 23 && BOOST_PP_ITERATION_START_2 >= 23 # define BOOST_PP_ITERATION_2 23 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 22 && BOOST_PP_ITERATION_START_2 >= 22 # define BOOST_PP_ITERATION_2 22 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 21 && BOOST_PP_ITERATION_START_2 >= 21 # define BOOST_PP_ITERATION_2 21 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 20 && BOOST_PP_ITERATION_START_2 >= 20 # define BOOST_PP_ITERATION_2 20 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 19 && BOOST_PP_ITERATION_START_2 >= 19 # define BOOST_PP_ITERATION_2 19 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 18 && BOOST_PP_ITERATION_START_2 >= 18 # define BOOST_PP_ITERATION_2 18 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 17 && BOOST_PP_ITERATION_START_2 >= 17 # define BOOST_PP_ITERATION_2 17 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 16 && BOOST_PP_ITERATION_START_2 >= 16 # define BOOST_PP_ITERATION_2 16 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 15 && BOOST_PP_ITERATION_START_2 >= 15 # define BOOST_PP_ITERATION_2 15 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 14 && BOOST_PP_ITERATION_START_2 >= 14 # define BOOST_PP_ITERATION_2 14 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 13 && BOOST_PP_ITERATION_START_2 >= 13 # define BOOST_PP_ITERATION_2 13 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 12 && BOOST_PP_ITERATION_START_2 >= 12 # define BOOST_PP_ITERATION_2 12 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 11 && BOOST_PP_ITERATION_START_2 >= 11 # define BOOST_PP_ITERATION_2 11 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 10 && BOOST_PP_ITERATION_START_2 >= 10 # define BOOST_PP_ITERATION_2 10 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 9 && BOOST_PP_ITERATION_START_2 >= 9 # define BOOST_PP_ITERATION_2 9 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 8 && BOOST_PP_ITERATION_START_2 >= 8 # define BOOST_PP_ITERATION_2 8 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 7 && BOOST_PP_ITERATION_START_2 >= 7 # define BOOST_PP_ITERATION_2 7 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 6 && BOOST_PP_ITERATION_START_2 >= 6 # define BOOST_PP_ITERATION_2 6 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 5 && BOOST_PP_ITERATION_START_2 >= 5 # define BOOST_PP_ITERATION_2 5 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 4 && BOOST_PP_ITERATION_START_2 >= 4 # define BOOST_PP_ITERATION_2 4 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 3 && BOOST_PP_ITERATION_START_2 >= 3 # define BOOST_PP_ITERATION_2 3 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 2 && BOOST_PP_ITERATION_START_2 >= 2 # define BOOST_PP_ITERATION_2 2 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 1 && BOOST_PP_ITERATION_START_2 >= 1 # define BOOST_PP_ITERATION_2 1 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_FINISH_2 <= 0 && BOOST_PP_ITERATION_START_2 >= 0 # define BOOST_PP_ITERATION_2 0 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/forward2.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000015265711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if defined(BOOST_PP_ITERATION_LIMITS) # if !defined(BOOST_PP_FILENAME_2) # error BOOST_PP_ERROR: depth #2 filename is not defined # endif # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_ITERATION_FLAGS_2 0 # undef BOOST_PP_ITERATION_LIMITS # elif defined(BOOST_PP_ITERATION_PARAMS_2) # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_2) # include # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_2) # include # define BOOST_PP_FILENAME_2 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_2) # if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_2) >= 4 # define BOOST_PP_ITERATION_FLAGS_2 BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_2) # else # define BOOST_PP_ITERATION_FLAGS_2 0 # endif # else # error BOOST_PP_ERROR: depth #2 iteration boundaries or filename not defined # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 2 # # if (BOOST_PP_ITERATION_START_2) > (BOOST_PP_ITERATION_FINISH_2) # include # else # if BOOST_PP_ITERATION_START_2 <= 0 && BOOST_PP_ITERATION_FINISH_2 >= 0 # define BOOST_PP_ITERATION_2 0 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 1 && BOOST_PP_ITERATION_FINISH_2 >= 1 # define BOOST_PP_ITERATION_2 1 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 2 && BOOST_PP_ITERATION_FINISH_2 >= 2 # define BOOST_PP_ITERATION_2 2 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 3 && BOOST_PP_ITERATION_FINISH_2 >= 3 # define BOOST_PP_ITERATION_2 3 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 4 && BOOST_PP_ITERATION_FINISH_2 >= 4 # define BOOST_PP_ITERATION_2 4 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 5 && BOOST_PP_ITERATION_FINISH_2 >= 5 # define BOOST_PP_ITERATION_2 5 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 6 && BOOST_PP_ITERATION_FINISH_2 >= 6 # define BOOST_PP_ITERATION_2 6 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 7 && BOOST_PP_ITERATION_FINISH_2 >= 7 # define BOOST_PP_ITERATION_2 7 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 8 && BOOST_PP_ITERATION_FINISH_2 >= 8 # define BOOST_PP_ITERATION_2 8 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 9 && BOOST_PP_ITERATION_FINISH_2 >= 9 # define BOOST_PP_ITERATION_2 9 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 10 && BOOST_PP_ITERATION_FINISH_2 >= 10 # define BOOST_PP_ITERATION_2 10 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 11 && BOOST_PP_ITERATION_FINISH_2 >= 11 # define BOOST_PP_ITERATION_2 11 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 12 && BOOST_PP_ITERATION_FINISH_2 >= 12 # define BOOST_PP_ITERATION_2 12 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 13 && BOOST_PP_ITERATION_FINISH_2 >= 13 # define BOOST_PP_ITERATION_2 13 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 14 && BOOST_PP_ITERATION_FINISH_2 >= 14 # define BOOST_PP_ITERATION_2 14 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 15 && BOOST_PP_ITERATION_FINISH_2 >= 15 # define BOOST_PP_ITERATION_2 15 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 16 && BOOST_PP_ITERATION_FINISH_2 >= 16 # define BOOST_PP_ITERATION_2 16 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 17 && BOOST_PP_ITERATION_FINISH_2 >= 17 # define BOOST_PP_ITERATION_2 17 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 18 && BOOST_PP_ITERATION_FINISH_2 >= 18 # define BOOST_PP_ITERATION_2 18 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 19 && BOOST_PP_ITERATION_FINISH_2 >= 19 # define BOOST_PP_ITERATION_2 19 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 20 && BOOST_PP_ITERATION_FINISH_2 >= 20 # define BOOST_PP_ITERATION_2 20 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 21 && BOOST_PP_ITERATION_FINISH_2 >= 21 # define BOOST_PP_ITERATION_2 21 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 22 && BOOST_PP_ITERATION_FINISH_2 >= 22 # define BOOST_PP_ITERATION_2 22 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 23 && BOOST_PP_ITERATION_FINISH_2 >= 23 # define BOOST_PP_ITERATION_2 23 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 24 && BOOST_PP_ITERATION_FINISH_2 >= 24 # define BOOST_PP_ITERATION_2 24 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 25 && BOOST_PP_ITERATION_FINISH_2 >= 25 # define BOOST_PP_ITERATION_2 25 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 26 && BOOST_PP_ITERATION_FINISH_2 >= 26 # define BOOST_PP_ITERATION_2 26 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 27 && BOOST_PP_ITERATION_FINISH_2 >= 27 # define BOOST_PP_ITERATION_2 27 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 28 && BOOST_PP_ITERATION_FINISH_2 >= 28 # define BOOST_PP_ITERATION_2 28 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 29 && BOOST_PP_ITERATION_FINISH_2 >= 29 # define BOOST_PP_ITERATION_2 29 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 30 && BOOST_PP_ITERATION_FINISH_2 >= 30 # define BOOST_PP_ITERATION_2 30 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 31 && BOOST_PP_ITERATION_FINISH_2 >= 31 # define BOOST_PP_ITERATION_2 31 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 32 && BOOST_PP_ITERATION_FINISH_2 >= 32 # define BOOST_PP_ITERATION_2 32 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 33 && BOOST_PP_ITERATION_FINISH_2 >= 33 # define BOOST_PP_ITERATION_2 33 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 34 && BOOST_PP_ITERATION_FINISH_2 >= 34 # define BOOST_PP_ITERATION_2 34 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 35 && BOOST_PP_ITERATION_FINISH_2 >= 35 # define BOOST_PP_ITERATION_2 35 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 36 && BOOST_PP_ITERATION_FINISH_2 >= 36 # define BOOST_PP_ITERATION_2 36 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 37 && BOOST_PP_ITERATION_FINISH_2 >= 37 # define BOOST_PP_ITERATION_2 37 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 38 && BOOST_PP_ITERATION_FINISH_2 >= 38 # define BOOST_PP_ITERATION_2 38 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 39 && BOOST_PP_ITERATION_FINISH_2 >= 39 # define BOOST_PP_ITERATION_2 39 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 40 && BOOST_PP_ITERATION_FINISH_2 >= 40 # define BOOST_PP_ITERATION_2 40 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 41 && BOOST_PP_ITERATION_FINISH_2 >= 41 # define BOOST_PP_ITERATION_2 41 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 42 && BOOST_PP_ITERATION_FINISH_2 >= 42 # define BOOST_PP_ITERATION_2 42 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 43 && BOOST_PP_ITERATION_FINISH_2 >= 43 # define BOOST_PP_ITERATION_2 43 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 44 && BOOST_PP_ITERATION_FINISH_2 >= 44 # define BOOST_PP_ITERATION_2 44 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 45 && BOOST_PP_ITERATION_FINISH_2 >= 45 # define BOOST_PP_ITERATION_2 45 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 46 && BOOST_PP_ITERATION_FINISH_2 >= 46 # define BOOST_PP_ITERATION_2 46 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 47 && BOOST_PP_ITERATION_FINISH_2 >= 47 # define BOOST_PP_ITERATION_2 47 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 48 && BOOST_PP_ITERATION_FINISH_2 >= 48 # define BOOST_PP_ITERATION_2 48 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 49 && BOOST_PP_ITERATION_FINISH_2 >= 49 # define BOOST_PP_ITERATION_2 49 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 50 && BOOST_PP_ITERATION_FINISH_2 >= 50 # define BOOST_PP_ITERATION_2 50 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 51 && BOOST_PP_ITERATION_FINISH_2 >= 51 # define BOOST_PP_ITERATION_2 51 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 52 && BOOST_PP_ITERATION_FINISH_2 >= 52 # define BOOST_PP_ITERATION_2 52 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 53 && BOOST_PP_ITERATION_FINISH_2 >= 53 # define BOOST_PP_ITERATION_2 53 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 54 && BOOST_PP_ITERATION_FINISH_2 >= 54 # define BOOST_PP_ITERATION_2 54 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 55 && BOOST_PP_ITERATION_FINISH_2 >= 55 # define BOOST_PP_ITERATION_2 55 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 56 && BOOST_PP_ITERATION_FINISH_2 >= 56 # define BOOST_PP_ITERATION_2 56 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 57 && BOOST_PP_ITERATION_FINISH_2 >= 57 # define BOOST_PP_ITERATION_2 57 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 58 && BOOST_PP_ITERATION_FINISH_2 >= 58 # define BOOST_PP_ITERATION_2 58 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 59 && BOOST_PP_ITERATION_FINISH_2 >= 59 # define BOOST_PP_ITERATION_2 59 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 60 && BOOST_PP_ITERATION_FINISH_2 >= 60 # define BOOST_PP_ITERATION_2 60 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 61 && BOOST_PP_ITERATION_FINISH_2 >= 61 # define BOOST_PP_ITERATION_2 61 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 62 && BOOST_PP_ITERATION_FINISH_2 >= 62 # define BOOST_PP_ITERATION_2 62 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 63 && BOOST_PP_ITERATION_FINISH_2 >= 63 # define BOOST_PP_ITERATION_2 63 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 64 && BOOST_PP_ITERATION_FINISH_2 >= 64 # define BOOST_PP_ITERATION_2 64 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 65 && BOOST_PP_ITERATION_FINISH_2 >= 65 # define BOOST_PP_ITERATION_2 65 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 66 && BOOST_PP_ITERATION_FINISH_2 >= 66 # define BOOST_PP_ITERATION_2 66 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 67 && BOOST_PP_ITERATION_FINISH_2 >= 67 # define BOOST_PP_ITERATION_2 67 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 68 && BOOST_PP_ITERATION_FINISH_2 >= 68 # define BOOST_PP_ITERATION_2 68 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 69 && BOOST_PP_ITERATION_FINISH_2 >= 69 # define BOOST_PP_ITERATION_2 69 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 70 && BOOST_PP_ITERATION_FINISH_2 >= 70 # define BOOST_PP_ITERATION_2 70 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 71 && BOOST_PP_ITERATION_FINISH_2 >= 71 # define BOOST_PP_ITERATION_2 71 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 72 && BOOST_PP_ITERATION_FINISH_2 >= 72 # define BOOST_PP_ITERATION_2 72 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 73 && BOOST_PP_ITERATION_FINISH_2 >= 73 # define BOOST_PP_ITERATION_2 73 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 74 && BOOST_PP_ITERATION_FINISH_2 >= 74 # define BOOST_PP_ITERATION_2 74 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 75 && BOOST_PP_ITERATION_FINISH_2 >= 75 # define BOOST_PP_ITERATION_2 75 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 76 && BOOST_PP_ITERATION_FINISH_2 >= 76 # define BOOST_PP_ITERATION_2 76 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 77 && BOOST_PP_ITERATION_FINISH_2 >= 77 # define BOOST_PP_ITERATION_2 77 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 78 && BOOST_PP_ITERATION_FINISH_2 >= 78 # define BOOST_PP_ITERATION_2 78 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 79 && BOOST_PP_ITERATION_FINISH_2 >= 79 # define BOOST_PP_ITERATION_2 79 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 80 && BOOST_PP_ITERATION_FINISH_2 >= 80 # define BOOST_PP_ITERATION_2 80 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 81 && BOOST_PP_ITERATION_FINISH_2 >= 81 # define BOOST_PP_ITERATION_2 81 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 82 && BOOST_PP_ITERATION_FINISH_2 >= 82 # define BOOST_PP_ITERATION_2 82 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 83 && BOOST_PP_ITERATION_FINISH_2 >= 83 # define BOOST_PP_ITERATION_2 83 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 84 && BOOST_PP_ITERATION_FINISH_2 >= 84 # define BOOST_PP_ITERATION_2 84 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 85 && BOOST_PP_ITERATION_FINISH_2 >= 85 # define BOOST_PP_ITERATION_2 85 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 86 && BOOST_PP_ITERATION_FINISH_2 >= 86 # define BOOST_PP_ITERATION_2 86 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 87 && BOOST_PP_ITERATION_FINISH_2 >= 87 # define BOOST_PP_ITERATION_2 87 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 88 && BOOST_PP_ITERATION_FINISH_2 >= 88 # define BOOST_PP_ITERATION_2 88 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 89 && BOOST_PP_ITERATION_FINISH_2 >= 89 # define BOOST_PP_ITERATION_2 89 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 90 && BOOST_PP_ITERATION_FINISH_2 >= 90 # define BOOST_PP_ITERATION_2 90 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 91 && BOOST_PP_ITERATION_FINISH_2 >= 91 # define BOOST_PP_ITERATION_2 91 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 92 && BOOST_PP_ITERATION_FINISH_2 >= 92 # define BOOST_PP_ITERATION_2 92 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 93 && BOOST_PP_ITERATION_FINISH_2 >= 93 # define BOOST_PP_ITERATION_2 93 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 94 && BOOST_PP_ITERATION_FINISH_2 >= 94 # define BOOST_PP_ITERATION_2 94 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 95 && BOOST_PP_ITERATION_FINISH_2 >= 95 # define BOOST_PP_ITERATION_2 95 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 96 && BOOST_PP_ITERATION_FINISH_2 >= 96 # define BOOST_PP_ITERATION_2 96 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 97 && BOOST_PP_ITERATION_FINISH_2 >= 97 # define BOOST_PP_ITERATION_2 97 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 98 && BOOST_PP_ITERATION_FINISH_2 >= 98 # define BOOST_PP_ITERATION_2 98 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 99 && BOOST_PP_ITERATION_FINISH_2 >= 99 # define BOOST_PP_ITERATION_2 99 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 100 && BOOST_PP_ITERATION_FINISH_2 >= 100 # define BOOST_PP_ITERATION_2 100 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 101 && BOOST_PP_ITERATION_FINISH_2 >= 101 # define BOOST_PP_ITERATION_2 101 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 102 && BOOST_PP_ITERATION_FINISH_2 >= 102 # define BOOST_PP_ITERATION_2 102 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 103 && BOOST_PP_ITERATION_FINISH_2 >= 103 # define BOOST_PP_ITERATION_2 103 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 104 && BOOST_PP_ITERATION_FINISH_2 >= 104 # define BOOST_PP_ITERATION_2 104 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 105 && BOOST_PP_ITERATION_FINISH_2 >= 105 # define BOOST_PP_ITERATION_2 105 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 106 && BOOST_PP_ITERATION_FINISH_2 >= 106 # define BOOST_PP_ITERATION_2 106 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 107 && BOOST_PP_ITERATION_FINISH_2 >= 107 # define BOOST_PP_ITERATION_2 107 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 108 && BOOST_PP_ITERATION_FINISH_2 >= 108 # define BOOST_PP_ITERATION_2 108 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 109 && BOOST_PP_ITERATION_FINISH_2 >= 109 # define BOOST_PP_ITERATION_2 109 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 110 && BOOST_PP_ITERATION_FINISH_2 >= 110 # define BOOST_PP_ITERATION_2 110 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 111 && BOOST_PP_ITERATION_FINISH_2 >= 111 # define BOOST_PP_ITERATION_2 111 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 112 && BOOST_PP_ITERATION_FINISH_2 >= 112 # define BOOST_PP_ITERATION_2 112 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 113 && BOOST_PP_ITERATION_FINISH_2 >= 113 # define BOOST_PP_ITERATION_2 113 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 114 && BOOST_PP_ITERATION_FINISH_2 >= 114 # define BOOST_PP_ITERATION_2 114 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 115 && BOOST_PP_ITERATION_FINISH_2 >= 115 # define BOOST_PP_ITERATION_2 115 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 116 && BOOST_PP_ITERATION_FINISH_2 >= 116 # define BOOST_PP_ITERATION_2 116 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 117 && BOOST_PP_ITERATION_FINISH_2 >= 117 # define BOOST_PP_ITERATION_2 117 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 118 && BOOST_PP_ITERATION_FINISH_2 >= 118 # define BOOST_PP_ITERATION_2 118 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 119 && BOOST_PP_ITERATION_FINISH_2 >= 119 # define BOOST_PP_ITERATION_2 119 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 120 && BOOST_PP_ITERATION_FINISH_2 >= 120 # define BOOST_PP_ITERATION_2 120 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 121 && BOOST_PP_ITERATION_FINISH_2 >= 121 # define BOOST_PP_ITERATION_2 121 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 122 && BOOST_PP_ITERATION_FINISH_2 >= 122 # define BOOST_PP_ITERATION_2 122 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 123 && BOOST_PP_ITERATION_FINISH_2 >= 123 # define BOOST_PP_ITERATION_2 123 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 124 && BOOST_PP_ITERATION_FINISH_2 >= 124 # define BOOST_PP_ITERATION_2 124 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 125 && BOOST_PP_ITERATION_FINISH_2 >= 125 # define BOOST_PP_ITERATION_2 125 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 126 && BOOST_PP_ITERATION_FINISH_2 >= 126 # define BOOST_PP_ITERATION_2 126 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 127 && BOOST_PP_ITERATION_FINISH_2 >= 127 # define BOOST_PP_ITERATION_2 127 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 128 && BOOST_PP_ITERATION_FINISH_2 >= 128 # define BOOST_PP_ITERATION_2 128 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 129 && BOOST_PP_ITERATION_FINISH_2 >= 129 # define BOOST_PP_ITERATION_2 129 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 130 && BOOST_PP_ITERATION_FINISH_2 >= 130 # define BOOST_PP_ITERATION_2 130 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 131 && BOOST_PP_ITERATION_FINISH_2 >= 131 # define BOOST_PP_ITERATION_2 131 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 132 && BOOST_PP_ITERATION_FINISH_2 >= 132 # define BOOST_PP_ITERATION_2 132 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 133 && BOOST_PP_ITERATION_FINISH_2 >= 133 # define BOOST_PP_ITERATION_2 133 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 134 && BOOST_PP_ITERATION_FINISH_2 >= 134 # define BOOST_PP_ITERATION_2 134 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 135 && BOOST_PP_ITERATION_FINISH_2 >= 135 # define BOOST_PP_ITERATION_2 135 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 136 && BOOST_PP_ITERATION_FINISH_2 >= 136 # define BOOST_PP_ITERATION_2 136 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 137 && BOOST_PP_ITERATION_FINISH_2 >= 137 # define BOOST_PP_ITERATION_2 137 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 138 && BOOST_PP_ITERATION_FINISH_2 >= 138 # define BOOST_PP_ITERATION_2 138 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 139 && BOOST_PP_ITERATION_FINISH_2 >= 139 # define BOOST_PP_ITERATION_2 139 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 140 && BOOST_PP_ITERATION_FINISH_2 >= 140 # define BOOST_PP_ITERATION_2 140 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 141 && BOOST_PP_ITERATION_FINISH_2 >= 141 # define BOOST_PP_ITERATION_2 141 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 142 && BOOST_PP_ITERATION_FINISH_2 >= 142 # define BOOST_PP_ITERATION_2 142 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 143 && BOOST_PP_ITERATION_FINISH_2 >= 143 # define BOOST_PP_ITERATION_2 143 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 144 && BOOST_PP_ITERATION_FINISH_2 >= 144 # define BOOST_PP_ITERATION_2 144 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 145 && BOOST_PP_ITERATION_FINISH_2 >= 145 # define BOOST_PP_ITERATION_2 145 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 146 && BOOST_PP_ITERATION_FINISH_2 >= 146 # define BOOST_PP_ITERATION_2 146 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 147 && BOOST_PP_ITERATION_FINISH_2 >= 147 # define BOOST_PP_ITERATION_2 147 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 148 && BOOST_PP_ITERATION_FINISH_2 >= 148 # define BOOST_PP_ITERATION_2 148 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 149 && BOOST_PP_ITERATION_FINISH_2 >= 149 # define BOOST_PP_ITERATION_2 149 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 150 && BOOST_PP_ITERATION_FINISH_2 >= 150 # define BOOST_PP_ITERATION_2 150 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 151 && BOOST_PP_ITERATION_FINISH_2 >= 151 # define BOOST_PP_ITERATION_2 151 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 152 && BOOST_PP_ITERATION_FINISH_2 >= 152 # define BOOST_PP_ITERATION_2 152 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 153 && BOOST_PP_ITERATION_FINISH_2 >= 153 # define BOOST_PP_ITERATION_2 153 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 154 && BOOST_PP_ITERATION_FINISH_2 >= 154 # define BOOST_PP_ITERATION_2 154 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 155 && BOOST_PP_ITERATION_FINISH_2 >= 155 # define BOOST_PP_ITERATION_2 155 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 156 && BOOST_PP_ITERATION_FINISH_2 >= 156 # define BOOST_PP_ITERATION_2 156 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 157 && BOOST_PP_ITERATION_FINISH_2 >= 157 # define BOOST_PP_ITERATION_2 157 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 158 && BOOST_PP_ITERATION_FINISH_2 >= 158 # define BOOST_PP_ITERATION_2 158 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 159 && BOOST_PP_ITERATION_FINISH_2 >= 159 # define BOOST_PP_ITERATION_2 159 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 160 && BOOST_PP_ITERATION_FINISH_2 >= 160 # define BOOST_PP_ITERATION_2 160 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 161 && BOOST_PP_ITERATION_FINISH_2 >= 161 # define BOOST_PP_ITERATION_2 161 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 162 && BOOST_PP_ITERATION_FINISH_2 >= 162 # define BOOST_PP_ITERATION_2 162 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 163 && BOOST_PP_ITERATION_FINISH_2 >= 163 # define BOOST_PP_ITERATION_2 163 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 164 && BOOST_PP_ITERATION_FINISH_2 >= 164 # define BOOST_PP_ITERATION_2 164 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 165 && BOOST_PP_ITERATION_FINISH_2 >= 165 # define BOOST_PP_ITERATION_2 165 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 166 && BOOST_PP_ITERATION_FINISH_2 >= 166 # define BOOST_PP_ITERATION_2 166 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 167 && BOOST_PP_ITERATION_FINISH_2 >= 167 # define BOOST_PP_ITERATION_2 167 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 168 && BOOST_PP_ITERATION_FINISH_2 >= 168 # define BOOST_PP_ITERATION_2 168 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 169 && BOOST_PP_ITERATION_FINISH_2 >= 169 # define BOOST_PP_ITERATION_2 169 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 170 && BOOST_PP_ITERATION_FINISH_2 >= 170 # define BOOST_PP_ITERATION_2 170 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 171 && BOOST_PP_ITERATION_FINISH_2 >= 171 # define BOOST_PP_ITERATION_2 171 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 172 && BOOST_PP_ITERATION_FINISH_2 >= 172 # define BOOST_PP_ITERATION_2 172 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 173 && BOOST_PP_ITERATION_FINISH_2 >= 173 # define BOOST_PP_ITERATION_2 173 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 174 && BOOST_PP_ITERATION_FINISH_2 >= 174 # define BOOST_PP_ITERATION_2 174 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 175 && BOOST_PP_ITERATION_FINISH_2 >= 175 # define BOOST_PP_ITERATION_2 175 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 176 && BOOST_PP_ITERATION_FINISH_2 >= 176 # define BOOST_PP_ITERATION_2 176 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 177 && BOOST_PP_ITERATION_FINISH_2 >= 177 # define BOOST_PP_ITERATION_2 177 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 178 && BOOST_PP_ITERATION_FINISH_2 >= 178 # define BOOST_PP_ITERATION_2 178 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 179 && BOOST_PP_ITERATION_FINISH_2 >= 179 # define BOOST_PP_ITERATION_2 179 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 180 && BOOST_PP_ITERATION_FINISH_2 >= 180 # define BOOST_PP_ITERATION_2 180 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 181 && BOOST_PP_ITERATION_FINISH_2 >= 181 # define BOOST_PP_ITERATION_2 181 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 182 && BOOST_PP_ITERATION_FINISH_2 >= 182 # define BOOST_PP_ITERATION_2 182 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 183 && BOOST_PP_ITERATION_FINISH_2 >= 183 # define BOOST_PP_ITERATION_2 183 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 184 && BOOST_PP_ITERATION_FINISH_2 >= 184 # define BOOST_PP_ITERATION_2 184 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 185 && BOOST_PP_ITERATION_FINISH_2 >= 185 # define BOOST_PP_ITERATION_2 185 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 186 && BOOST_PP_ITERATION_FINISH_2 >= 186 # define BOOST_PP_ITERATION_2 186 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 187 && BOOST_PP_ITERATION_FINISH_2 >= 187 # define BOOST_PP_ITERATION_2 187 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 188 && BOOST_PP_ITERATION_FINISH_2 >= 188 # define BOOST_PP_ITERATION_2 188 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 189 && BOOST_PP_ITERATION_FINISH_2 >= 189 # define BOOST_PP_ITERATION_2 189 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 190 && BOOST_PP_ITERATION_FINISH_2 >= 190 # define BOOST_PP_ITERATION_2 190 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 191 && BOOST_PP_ITERATION_FINISH_2 >= 191 # define BOOST_PP_ITERATION_2 191 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 192 && BOOST_PP_ITERATION_FINISH_2 >= 192 # define BOOST_PP_ITERATION_2 192 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 193 && BOOST_PP_ITERATION_FINISH_2 >= 193 # define BOOST_PP_ITERATION_2 193 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 194 && BOOST_PP_ITERATION_FINISH_2 >= 194 # define BOOST_PP_ITERATION_2 194 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 195 && BOOST_PP_ITERATION_FINISH_2 >= 195 # define BOOST_PP_ITERATION_2 195 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 196 && BOOST_PP_ITERATION_FINISH_2 >= 196 # define BOOST_PP_ITERATION_2 196 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 197 && BOOST_PP_ITERATION_FINISH_2 >= 197 # define BOOST_PP_ITERATION_2 197 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 198 && BOOST_PP_ITERATION_FINISH_2 >= 198 # define BOOST_PP_ITERATION_2 198 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 199 && BOOST_PP_ITERATION_FINISH_2 >= 199 # define BOOST_PP_ITERATION_2 199 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 200 && BOOST_PP_ITERATION_FINISH_2 >= 200 # define BOOST_PP_ITERATION_2 200 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 201 && BOOST_PP_ITERATION_FINISH_2 >= 201 # define BOOST_PP_ITERATION_2 201 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 202 && BOOST_PP_ITERATION_FINISH_2 >= 202 # define BOOST_PP_ITERATION_2 202 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 203 && BOOST_PP_ITERATION_FINISH_2 >= 203 # define BOOST_PP_ITERATION_2 203 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 204 && BOOST_PP_ITERATION_FINISH_2 >= 204 # define BOOST_PP_ITERATION_2 204 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 205 && BOOST_PP_ITERATION_FINISH_2 >= 205 # define BOOST_PP_ITERATION_2 205 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 206 && BOOST_PP_ITERATION_FINISH_2 >= 206 # define BOOST_PP_ITERATION_2 206 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 207 && BOOST_PP_ITERATION_FINISH_2 >= 207 # define BOOST_PP_ITERATION_2 207 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 208 && BOOST_PP_ITERATION_FINISH_2 >= 208 # define BOOST_PP_ITERATION_2 208 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 209 && BOOST_PP_ITERATION_FINISH_2 >= 209 # define BOOST_PP_ITERATION_2 209 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 210 && BOOST_PP_ITERATION_FINISH_2 >= 210 # define BOOST_PP_ITERATION_2 210 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 211 && BOOST_PP_ITERATION_FINISH_2 >= 211 # define BOOST_PP_ITERATION_2 211 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 212 && BOOST_PP_ITERATION_FINISH_2 >= 212 # define BOOST_PP_ITERATION_2 212 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 213 && BOOST_PP_ITERATION_FINISH_2 >= 213 # define BOOST_PP_ITERATION_2 213 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 214 && BOOST_PP_ITERATION_FINISH_2 >= 214 # define BOOST_PP_ITERATION_2 214 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 215 && BOOST_PP_ITERATION_FINISH_2 >= 215 # define BOOST_PP_ITERATION_2 215 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 216 && BOOST_PP_ITERATION_FINISH_2 >= 216 # define BOOST_PP_ITERATION_2 216 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 217 && BOOST_PP_ITERATION_FINISH_2 >= 217 # define BOOST_PP_ITERATION_2 217 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 218 && BOOST_PP_ITERATION_FINISH_2 >= 218 # define BOOST_PP_ITERATION_2 218 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 219 && BOOST_PP_ITERATION_FINISH_2 >= 219 # define BOOST_PP_ITERATION_2 219 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 220 && BOOST_PP_ITERATION_FINISH_2 >= 220 # define BOOST_PP_ITERATION_2 220 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 221 && BOOST_PP_ITERATION_FINISH_2 >= 221 # define BOOST_PP_ITERATION_2 221 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 222 && BOOST_PP_ITERATION_FINISH_2 >= 222 # define BOOST_PP_ITERATION_2 222 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 223 && BOOST_PP_ITERATION_FINISH_2 >= 223 # define BOOST_PP_ITERATION_2 223 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 224 && BOOST_PP_ITERATION_FINISH_2 >= 224 # define BOOST_PP_ITERATION_2 224 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 225 && BOOST_PP_ITERATION_FINISH_2 >= 225 # define BOOST_PP_ITERATION_2 225 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 226 && BOOST_PP_ITERATION_FINISH_2 >= 226 # define BOOST_PP_ITERATION_2 226 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 227 && BOOST_PP_ITERATION_FINISH_2 >= 227 # define BOOST_PP_ITERATION_2 227 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 228 && BOOST_PP_ITERATION_FINISH_2 >= 228 # define BOOST_PP_ITERATION_2 228 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 229 && BOOST_PP_ITERATION_FINISH_2 >= 229 # define BOOST_PP_ITERATION_2 229 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 230 && BOOST_PP_ITERATION_FINISH_2 >= 230 # define BOOST_PP_ITERATION_2 230 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 231 && BOOST_PP_ITERATION_FINISH_2 >= 231 # define BOOST_PP_ITERATION_2 231 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 232 && BOOST_PP_ITERATION_FINISH_2 >= 232 # define BOOST_PP_ITERATION_2 232 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 233 && BOOST_PP_ITERATION_FINISH_2 >= 233 # define BOOST_PP_ITERATION_2 233 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 234 && BOOST_PP_ITERATION_FINISH_2 >= 234 # define BOOST_PP_ITERATION_2 234 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 235 && BOOST_PP_ITERATION_FINISH_2 >= 235 # define BOOST_PP_ITERATION_2 235 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 236 && BOOST_PP_ITERATION_FINISH_2 >= 236 # define BOOST_PP_ITERATION_2 236 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 237 && BOOST_PP_ITERATION_FINISH_2 >= 237 # define BOOST_PP_ITERATION_2 237 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 238 && BOOST_PP_ITERATION_FINISH_2 >= 238 # define BOOST_PP_ITERATION_2 238 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 239 && BOOST_PP_ITERATION_FINISH_2 >= 239 # define BOOST_PP_ITERATION_2 239 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 240 && BOOST_PP_ITERATION_FINISH_2 >= 240 # define BOOST_PP_ITERATION_2 240 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 241 && BOOST_PP_ITERATION_FINISH_2 >= 241 # define BOOST_PP_ITERATION_2 241 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 242 && BOOST_PP_ITERATION_FINISH_2 >= 242 # define BOOST_PP_ITERATION_2 242 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 243 && BOOST_PP_ITERATION_FINISH_2 >= 243 # define BOOST_PP_ITERATION_2 243 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 244 && BOOST_PP_ITERATION_FINISH_2 >= 244 # define BOOST_PP_ITERATION_2 244 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 245 && BOOST_PP_ITERATION_FINISH_2 >= 245 # define BOOST_PP_ITERATION_2 245 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 246 && BOOST_PP_ITERATION_FINISH_2 >= 246 # define BOOST_PP_ITERATION_2 246 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 247 && BOOST_PP_ITERATION_FINISH_2 >= 247 # define BOOST_PP_ITERATION_2 247 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 248 && BOOST_PP_ITERATION_FINISH_2 >= 248 # define BOOST_PP_ITERATION_2 248 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 249 && BOOST_PP_ITERATION_FINISH_2 >= 249 # define BOOST_PP_ITERATION_2 249 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 250 && BOOST_PP_ITERATION_FINISH_2 >= 250 # define BOOST_PP_ITERATION_2 250 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 251 && BOOST_PP_ITERATION_FINISH_2 >= 251 # define BOOST_PP_ITERATION_2 251 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 252 && BOOST_PP_ITERATION_FINISH_2 >= 252 # define BOOST_PP_ITERATION_2 252 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 253 && BOOST_PP_ITERATION_FINISH_2 >= 253 # define BOOST_PP_ITERATION_2 253 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 254 && BOOST_PP_ITERATION_FINISH_2 >= 254 # define BOOST_PP_ITERATION_2 254 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 255 && BOOST_PP_ITERATION_FINISH_2 >= 255 # define BOOST_PP_ITERATION_2 255 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # if BOOST_PP_ITERATION_START_2 <= 256 && BOOST_PP_ITERATION_FINISH_2 >= 256 # define BOOST_PP_ITERATION_2 256 # include BOOST_PP_FILENAME_2 # undef BOOST_PP_ITERATION_2 # endif # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 1 # # undef BOOST_PP_ITERATION_START_2 # undef BOOST_PP_ITERATION_FINISH_2 # undef BOOST_PP_FILENAME_2 # # undef BOOST_PP_ITERATION_FLAGS_2 # undef BOOST_PP_ITERATION_PARAMS_2 ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/reverse5.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000013631311344301502031742 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if BOOST_PP_ITERATION_FINISH_5 <= 256 && BOOST_PP_ITERATION_START_5 >= 256 # define BOOST_PP_ITERATION_5 256 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 255 && BOOST_PP_ITERATION_START_5 >= 255 # define BOOST_PP_ITERATION_5 255 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 254 && BOOST_PP_ITERATION_START_5 >= 254 # define BOOST_PP_ITERATION_5 254 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 253 && BOOST_PP_ITERATION_START_5 >= 253 # define BOOST_PP_ITERATION_5 253 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 252 && BOOST_PP_ITERATION_START_5 >= 252 # define BOOST_PP_ITERATION_5 252 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 251 && BOOST_PP_ITERATION_START_5 >= 251 # define BOOST_PP_ITERATION_5 251 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 250 && BOOST_PP_ITERATION_START_5 >= 250 # define BOOST_PP_ITERATION_5 250 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 249 && BOOST_PP_ITERATION_START_5 >= 249 # define BOOST_PP_ITERATION_5 249 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 248 && BOOST_PP_ITERATION_START_5 >= 248 # define BOOST_PP_ITERATION_5 248 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 247 && BOOST_PP_ITERATION_START_5 >= 247 # define BOOST_PP_ITERATION_5 247 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 246 && BOOST_PP_ITERATION_START_5 >= 246 # define BOOST_PP_ITERATION_5 246 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 245 && BOOST_PP_ITERATION_START_5 >= 245 # define BOOST_PP_ITERATION_5 245 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 244 && BOOST_PP_ITERATION_START_5 >= 244 # define BOOST_PP_ITERATION_5 244 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 243 && BOOST_PP_ITERATION_START_5 >= 243 # define BOOST_PP_ITERATION_5 243 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 242 && BOOST_PP_ITERATION_START_5 >= 242 # define BOOST_PP_ITERATION_5 242 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 241 && BOOST_PP_ITERATION_START_5 >= 241 # define BOOST_PP_ITERATION_5 241 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 240 && BOOST_PP_ITERATION_START_5 >= 240 # define BOOST_PP_ITERATION_5 240 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 239 && BOOST_PP_ITERATION_START_5 >= 239 # define BOOST_PP_ITERATION_5 239 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 238 && BOOST_PP_ITERATION_START_5 >= 238 # define BOOST_PP_ITERATION_5 238 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 237 && BOOST_PP_ITERATION_START_5 >= 237 # define BOOST_PP_ITERATION_5 237 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 236 && BOOST_PP_ITERATION_START_5 >= 236 # define BOOST_PP_ITERATION_5 236 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 235 && BOOST_PP_ITERATION_START_5 >= 235 # define BOOST_PP_ITERATION_5 235 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 234 && BOOST_PP_ITERATION_START_5 >= 234 # define BOOST_PP_ITERATION_5 234 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 233 && BOOST_PP_ITERATION_START_5 >= 233 # define BOOST_PP_ITERATION_5 233 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 232 && BOOST_PP_ITERATION_START_5 >= 232 # define BOOST_PP_ITERATION_5 232 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 231 && BOOST_PP_ITERATION_START_5 >= 231 # define BOOST_PP_ITERATION_5 231 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 230 && BOOST_PP_ITERATION_START_5 >= 230 # define BOOST_PP_ITERATION_5 230 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 229 && BOOST_PP_ITERATION_START_5 >= 229 # define BOOST_PP_ITERATION_5 229 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 228 && BOOST_PP_ITERATION_START_5 >= 228 # define BOOST_PP_ITERATION_5 228 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 227 && BOOST_PP_ITERATION_START_5 >= 227 # define BOOST_PP_ITERATION_5 227 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 226 && BOOST_PP_ITERATION_START_5 >= 226 # define BOOST_PP_ITERATION_5 226 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 225 && BOOST_PP_ITERATION_START_5 >= 225 # define BOOST_PP_ITERATION_5 225 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 224 && BOOST_PP_ITERATION_START_5 >= 224 # define BOOST_PP_ITERATION_5 224 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 223 && BOOST_PP_ITERATION_START_5 >= 223 # define BOOST_PP_ITERATION_5 223 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 222 && BOOST_PP_ITERATION_START_5 >= 222 # define BOOST_PP_ITERATION_5 222 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 221 && BOOST_PP_ITERATION_START_5 >= 221 # define BOOST_PP_ITERATION_5 221 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 220 && BOOST_PP_ITERATION_START_5 >= 220 # define BOOST_PP_ITERATION_5 220 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 219 && BOOST_PP_ITERATION_START_5 >= 219 # define BOOST_PP_ITERATION_5 219 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 218 && BOOST_PP_ITERATION_START_5 >= 218 # define BOOST_PP_ITERATION_5 218 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 217 && BOOST_PP_ITERATION_START_5 >= 217 # define BOOST_PP_ITERATION_5 217 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 216 && BOOST_PP_ITERATION_START_5 >= 216 # define BOOST_PP_ITERATION_5 216 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 215 && BOOST_PP_ITERATION_START_5 >= 215 # define BOOST_PP_ITERATION_5 215 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 214 && BOOST_PP_ITERATION_START_5 >= 214 # define BOOST_PP_ITERATION_5 214 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 213 && BOOST_PP_ITERATION_START_5 >= 213 # define BOOST_PP_ITERATION_5 213 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 212 && BOOST_PP_ITERATION_START_5 >= 212 # define BOOST_PP_ITERATION_5 212 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 211 && BOOST_PP_ITERATION_START_5 >= 211 # define BOOST_PP_ITERATION_5 211 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 210 && BOOST_PP_ITERATION_START_5 >= 210 # define BOOST_PP_ITERATION_5 210 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 209 && BOOST_PP_ITERATION_START_5 >= 209 # define BOOST_PP_ITERATION_5 209 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 208 && BOOST_PP_ITERATION_START_5 >= 208 # define BOOST_PP_ITERATION_5 208 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 207 && BOOST_PP_ITERATION_START_5 >= 207 # define BOOST_PP_ITERATION_5 207 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 206 && BOOST_PP_ITERATION_START_5 >= 206 # define BOOST_PP_ITERATION_5 206 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 205 && BOOST_PP_ITERATION_START_5 >= 205 # define BOOST_PP_ITERATION_5 205 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 204 && BOOST_PP_ITERATION_START_5 >= 204 # define BOOST_PP_ITERATION_5 204 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 203 && BOOST_PP_ITERATION_START_5 >= 203 # define BOOST_PP_ITERATION_5 203 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 202 && BOOST_PP_ITERATION_START_5 >= 202 # define BOOST_PP_ITERATION_5 202 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 201 && BOOST_PP_ITERATION_START_5 >= 201 # define BOOST_PP_ITERATION_5 201 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 200 && BOOST_PP_ITERATION_START_5 >= 200 # define BOOST_PP_ITERATION_5 200 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 199 && BOOST_PP_ITERATION_START_5 >= 199 # define BOOST_PP_ITERATION_5 199 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 198 && BOOST_PP_ITERATION_START_5 >= 198 # define BOOST_PP_ITERATION_5 198 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 197 && BOOST_PP_ITERATION_START_5 >= 197 # define BOOST_PP_ITERATION_5 197 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 196 && BOOST_PP_ITERATION_START_5 >= 196 # define BOOST_PP_ITERATION_5 196 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 195 && BOOST_PP_ITERATION_START_5 >= 195 # define BOOST_PP_ITERATION_5 195 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 194 && BOOST_PP_ITERATION_START_5 >= 194 # define BOOST_PP_ITERATION_5 194 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 193 && BOOST_PP_ITERATION_START_5 >= 193 # define BOOST_PP_ITERATION_5 193 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 192 && BOOST_PP_ITERATION_START_5 >= 192 # define BOOST_PP_ITERATION_5 192 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 191 && BOOST_PP_ITERATION_START_5 >= 191 # define BOOST_PP_ITERATION_5 191 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 190 && BOOST_PP_ITERATION_START_5 >= 190 # define BOOST_PP_ITERATION_5 190 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 189 && BOOST_PP_ITERATION_START_5 >= 189 # define BOOST_PP_ITERATION_5 189 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 188 && BOOST_PP_ITERATION_START_5 >= 188 # define BOOST_PP_ITERATION_5 188 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 187 && BOOST_PP_ITERATION_START_5 >= 187 # define BOOST_PP_ITERATION_5 187 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 186 && BOOST_PP_ITERATION_START_5 >= 186 # define BOOST_PP_ITERATION_5 186 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 185 && BOOST_PP_ITERATION_START_5 >= 185 # define BOOST_PP_ITERATION_5 185 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 184 && BOOST_PP_ITERATION_START_5 >= 184 # define BOOST_PP_ITERATION_5 184 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 183 && BOOST_PP_ITERATION_START_5 >= 183 # define BOOST_PP_ITERATION_5 183 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 182 && BOOST_PP_ITERATION_START_5 >= 182 # define BOOST_PP_ITERATION_5 182 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 181 && BOOST_PP_ITERATION_START_5 >= 181 # define BOOST_PP_ITERATION_5 181 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 180 && BOOST_PP_ITERATION_START_5 >= 180 # define BOOST_PP_ITERATION_5 180 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 179 && BOOST_PP_ITERATION_START_5 >= 179 # define BOOST_PP_ITERATION_5 179 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 178 && BOOST_PP_ITERATION_START_5 >= 178 # define BOOST_PP_ITERATION_5 178 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 177 && BOOST_PP_ITERATION_START_5 >= 177 # define BOOST_PP_ITERATION_5 177 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 176 && BOOST_PP_ITERATION_START_5 >= 176 # define BOOST_PP_ITERATION_5 176 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 175 && BOOST_PP_ITERATION_START_5 >= 175 # define BOOST_PP_ITERATION_5 175 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 174 && BOOST_PP_ITERATION_START_5 >= 174 # define BOOST_PP_ITERATION_5 174 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 173 && BOOST_PP_ITERATION_START_5 >= 173 # define BOOST_PP_ITERATION_5 173 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 172 && BOOST_PP_ITERATION_START_5 >= 172 # define BOOST_PP_ITERATION_5 172 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 171 && BOOST_PP_ITERATION_START_5 >= 171 # define BOOST_PP_ITERATION_5 171 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 170 && BOOST_PP_ITERATION_START_5 >= 170 # define BOOST_PP_ITERATION_5 170 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 169 && BOOST_PP_ITERATION_START_5 >= 169 # define BOOST_PP_ITERATION_5 169 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 168 && BOOST_PP_ITERATION_START_5 >= 168 # define BOOST_PP_ITERATION_5 168 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 167 && BOOST_PP_ITERATION_START_5 >= 167 # define BOOST_PP_ITERATION_5 167 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 166 && BOOST_PP_ITERATION_START_5 >= 166 # define BOOST_PP_ITERATION_5 166 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 165 && BOOST_PP_ITERATION_START_5 >= 165 # define BOOST_PP_ITERATION_5 165 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 164 && BOOST_PP_ITERATION_START_5 >= 164 # define BOOST_PP_ITERATION_5 164 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 163 && BOOST_PP_ITERATION_START_5 >= 163 # define BOOST_PP_ITERATION_5 163 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 162 && BOOST_PP_ITERATION_START_5 >= 162 # define BOOST_PP_ITERATION_5 162 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 161 && BOOST_PP_ITERATION_START_5 >= 161 # define BOOST_PP_ITERATION_5 161 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 160 && BOOST_PP_ITERATION_START_5 >= 160 # define BOOST_PP_ITERATION_5 160 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 159 && BOOST_PP_ITERATION_START_5 >= 159 # define BOOST_PP_ITERATION_5 159 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 158 && BOOST_PP_ITERATION_START_5 >= 158 # define BOOST_PP_ITERATION_5 158 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 157 && BOOST_PP_ITERATION_START_5 >= 157 # define BOOST_PP_ITERATION_5 157 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 156 && BOOST_PP_ITERATION_START_5 >= 156 # define BOOST_PP_ITERATION_5 156 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 155 && BOOST_PP_ITERATION_START_5 >= 155 # define BOOST_PP_ITERATION_5 155 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 154 && BOOST_PP_ITERATION_START_5 >= 154 # define BOOST_PP_ITERATION_5 154 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 153 && BOOST_PP_ITERATION_START_5 >= 153 # define BOOST_PP_ITERATION_5 153 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 152 && BOOST_PP_ITERATION_START_5 >= 152 # define BOOST_PP_ITERATION_5 152 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 151 && BOOST_PP_ITERATION_START_5 >= 151 # define BOOST_PP_ITERATION_5 151 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 150 && BOOST_PP_ITERATION_START_5 >= 150 # define BOOST_PP_ITERATION_5 150 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 149 && BOOST_PP_ITERATION_START_5 >= 149 # define BOOST_PP_ITERATION_5 149 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 148 && BOOST_PP_ITERATION_START_5 >= 148 # define BOOST_PP_ITERATION_5 148 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 147 && BOOST_PP_ITERATION_START_5 >= 147 # define BOOST_PP_ITERATION_5 147 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 146 && BOOST_PP_ITERATION_START_5 >= 146 # define BOOST_PP_ITERATION_5 146 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 145 && BOOST_PP_ITERATION_START_5 >= 145 # define BOOST_PP_ITERATION_5 145 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 144 && BOOST_PP_ITERATION_START_5 >= 144 # define BOOST_PP_ITERATION_5 144 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 143 && BOOST_PP_ITERATION_START_5 >= 143 # define BOOST_PP_ITERATION_5 143 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 142 && BOOST_PP_ITERATION_START_5 >= 142 # define BOOST_PP_ITERATION_5 142 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 141 && BOOST_PP_ITERATION_START_5 >= 141 # define BOOST_PP_ITERATION_5 141 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 140 && BOOST_PP_ITERATION_START_5 >= 140 # define BOOST_PP_ITERATION_5 140 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 139 && BOOST_PP_ITERATION_START_5 >= 139 # define BOOST_PP_ITERATION_5 139 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 138 && BOOST_PP_ITERATION_START_5 >= 138 # define BOOST_PP_ITERATION_5 138 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 137 && BOOST_PP_ITERATION_START_5 >= 137 # define BOOST_PP_ITERATION_5 137 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 136 && BOOST_PP_ITERATION_START_5 >= 136 # define BOOST_PP_ITERATION_5 136 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 135 && BOOST_PP_ITERATION_START_5 >= 135 # define BOOST_PP_ITERATION_5 135 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 134 && BOOST_PP_ITERATION_START_5 >= 134 # define BOOST_PP_ITERATION_5 134 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 133 && BOOST_PP_ITERATION_START_5 >= 133 # define BOOST_PP_ITERATION_5 133 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 132 && BOOST_PP_ITERATION_START_5 >= 132 # define BOOST_PP_ITERATION_5 132 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 131 && BOOST_PP_ITERATION_START_5 >= 131 # define BOOST_PP_ITERATION_5 131 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 130 && BOOST_PP_ITERATION_START_5 >= 130 # define BOOST_PP_ITERATION_5 130 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 129 && BOOST_PP_ITERATION_START_5 >= 129 # define BOOST_PP_ITERATION_5 129 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 128 && BOOST_PP_ITERATION_START_5 >= 128 # define BOOST_PP_ITERATION_5 128 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 127 && BOOST_PP_ITERATION_START_5 >= 127 # define BOOST_PP_ITERATION_5 127 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 126 && BOOST_PP_ITERATION_START_5 >= 126 # define BOOST_PP_ITERATION_5 126 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 125 && BOOST_PP_ITERATION_START_5 >= 125 # define BOOST_PP_ITERATION_5 125 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 124 && BOOST_PP_ITERATION_START_5 >= 124 # define BOOST_PP_ITERATION_5 124 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 123 && BOOST_PP_ITERATION_START_5 >= 123 # define BOOST_PP_ITERATION_5 123 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 122 && BOOST_PP_ITERATION_START_5 >= 122 # define BOOST_PP_ITERATION_5 122 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 121 && BOOST_PP_ITERATION_START_5 >= 121 # define BOOST_PP_ITERATION_5 121 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 120 && BOOST_PP_ITERATION_START_5 >= 120 # define BOOST_PP_ITERATION_5 120 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 119 && BOOST_PP_ITERATION_START_5 >= 119 # define BOOST_PP_ITERATION_5 119 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 118 && BOOST_PP_ITERATION_START_5 >= 118 # define BOOST_PP_ITERATION_5 118 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 117 && BOOST_PP_ITERATION_START_5 >= 117 # define BOOST_PP_ITERATION_5 117 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 116 && BOOST_PP_ITERATION_START_5 >= 116 # define BOOST_PP_ITERATION_5 116 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 115 && BOOST_PP_ITERATION_START_5 >= 115 # define BOOST_PP_ITERATION_5 115 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 114 && BOOST_PP_ITERATION_START_5 >= 114 # define BOOST_PP_ITERATION_5 114 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 113 && BOOST_PP_ITERATION_START_5 >= 113 # define BOOST_PP_ITERATION_5 113 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 112 && BOOST_PP_ITERATION_START_5 >= 112 # define BOOST_PP_ITERATION_5 112 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 111 && BOOST_PP_ITERATION_START_5 >= 111 # define BOOST_PP_ITERATION_5 111 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 110 && BOOST_PP_ITERATION_START_5 >= 110 # define BOOST_PP_ITERATION_5 110 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 109 && BOOST_PP_ITERATION_START_5 >= 109 # define BOOST_PP_ITERATION_5 109 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 108 && BOOST_PP_ITERATION_START_5 >= 108 # define BOOST_PP_ITERATION_5 108 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 107 && BOOST_PP_ITERATION_START_5 >= 107 # define BOOST_PP_ITERATION_5 107 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 106 && BOOST_PP_ITERATION_START_5 >= 106 # define BOOST_PP_ITERATION_5 106 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 105 && BOOST_PP_ITERATION_START_5 >= 105 # define BOOST_PP_ITERATION_5 105 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 104 && BOOST_PP_ITERATION_START_5 >= 104 # define BOOST_PP_ITERATION_5 104 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 103 && BOOST_PP_ITERATION_START_5 >= 103 # define BOOST_PP_ITERATION_5 103 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 102 && BOOST_PP_ITERATION_START_5 >= 102 # define BOOST_PP_ITERATION_5 102 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 101 && BOOST_PP_ITERATION_START_5 >= 101 # define BOOST_PP_ITERATION_5 101 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 100 && BOOST_PP_ITERATION_START_5 >= 100 # define BOOST_PP_ITERATION_5 100 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 99 && BOOST_PP_ITERATION_START_5 >= 99 # define BOOST_PP_ITERATION_5 99 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 98 && BOOST_PP_ITERATION_START_5 >= 98 # define BOOST_PP_ITERATION_5 98 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 97 && BOOST_PP_ITERATION_START_5 >= 97 # define BOOST_PP_ITERATION_5 97 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 96 && BOOST_PP_ITERATION_START_5 >= 96 # define BOOST_PP_ITERATION_5 96 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 95 && BOOST_PP_ITERATION_START_5 >= 95 # define BOOST_PP_ITERATION_5 95 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 94 && BOOST_PP_ITERATION_START_5 >= 94 # define BOOST_PP_ITERATION_5 94 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 93 && BOOST_PP_ITERATION_START_5 >= 93 # define BOOST_PP_ITERATION_5 93 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 92 && BOOST_PP_ITERATION_START_5 >= 92 # define BOOST_PP_ITERATION_5 92 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 91 && BOOST_PP_ITERATION_START_5 >= 91 # define BOOST_PP_ITERATION_5 91 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 90 && BOOST_PP_ITERATION_START_5 >= 90 # define BOOST_PP_ITERATION_5 90 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 89 && BOOST_PP_ITERATION_START_5 >= 89 # define BOOST_PP_ITERATION_5 89 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 88 && BOOST_PP_ITERATION_START_5 >= 88 # define BOOST_PP_ITERATION_5 88 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 87 && BOOST_PP_ITERATION_START_5 >= 87 # define BOOST_PP_ITERATION_5 87 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 86 && BOOST_PP_ITERATION_START_5 >= 86 # define BOOST_PP_ITERATION_5 86 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 85 && BOOST_PP_ITERATION_START_5 >= 85 # define BOOST_PP_ITERATION_5 85 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 84 && BOOST_PP_ITERATION_START_5 >= 84 # define BOOST_PP_ITERATION_5 84 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 83 && BOOST_PP_ITERATION_START_5 >= 83 # define BOOST_PP_ITERATION_5 83 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 82 && BOOST_PP_ITERATION_START_5 >= 82 # define BOOST_PP_ITERATION_5 82 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 81 && BOOST_PP_ITERATION_START_5 >= 81 # define BOOST_PP_ITERATION_5 81 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 80 && BOOST_PP_ITERATION_START_5 >= 80 # define BOOST_PP_ITERATION_5 80 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 79 && BOOST_PP_ITERATION_START_5 >= 79 # define BOOST_PP_ITERATION_5 79 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 78 && BOOST_PP_ITERATION_START_5 >= 78 # define BOOST_PP_ITERATION_5 78 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 77 && BOOST_PP_ITERATION_START_5 >= 77 # define BOOST_PP_ITERATION_5 77 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 76 && BOOST_PP_ITERATION_START_5 >= 76 # define BOOST_PP_ITERATION_5 76 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 75 && BOOST_PP_ITERATION_START_5 >= 75 # define BOOST_PP_ITERATION_5 75 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 74 && BOOST_PP_ITERATION_START_5 >= 74 # define BOOST_PP_ITERATION_5 74 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 73 && BOOST_PP_ITERATION_START_5 >= 73 # define BOOST_PP_ITERATION_5 73 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 72 && BOOST_PP_ITERATION_START_5 >= 72 # define BOOST_PP_ITERATION_5 72 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 71 && BOOST_PP_ITERATION_START_5 >= 71 # define BOOST_PP_ITERATION_5 71 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 70 && BOOST_PP_ITERATION_START_5 >= 70 # define BOOST_PP_ITERATION_5 70 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 69 && BOOST_PP_ITERATION_START_5 >= 69 # define BOOST_PP_ITERATION_5 69 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 68 && BOOST_PP_ITERATION_START_5 >= 68 # define BOOST_PP_ITERATION_5 68 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 67 && BOOST_PP_ITERATION_START_5 >= 67 # define BOOST_PP_ITERATION_5 67 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 66 && BOOST_PP_ITERATION_START_5 >= 66 # define BOOST_PP_ITERATION_5 66 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 65 && BOOST_PP_ITERATION_START_5 >= 65 # define BOOST_PP_ITERATION_5 65 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 64 && BOOST_PP_ITERATION_START_5 >= 64 # define BOOST_PP_ITERATION_5 64 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 63 && BOOST_PP_ITERATION_START_5 >= 63 # define BOOST_PP_ITERATION_5 63 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 62 && BOOST_PP_ITERATION_START_5 >= 62 # define BOOST_PP_ITERATION_5 62 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 61 && BOOST_PP_ITERATION_START_5 >= 61 # define BOOST_PP_ITERATION_5 61 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 60 && BOOST_PP_ITERATION_START_5 >= 60 # define BOOST_PP_ITERATION_5 60 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 59 && BOOST_PP_ITERATION_START_5 >= 59 # define BOOST_PP_ITERATION_5 59 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 58 && BOOST_PP_ITERATION_START_5 >= 58 # define BOOST_PP_ITERATION_5 58 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 57 && BOOST_PP_ITERATION_START_5 >= 57 # define BOOST_PP_ITERATION_5 57 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 56 && BOOST_PP_ITERATION_START_5 >= 56 # define BOOST_PP_ITERATION_5 56 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 55 && BOOST_PP_ITERATION_START_5 >= 55 # define BOOST_PP_ITERATION_5 55 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 54 && BOOST_PP_ITERATION_START_5 >= 54 # define BOOST_PP_ITERATION_5 54 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 53 && BOOST_PP_ITERATION_START_5 >= 53 # define BOOST_PP_ITERATION_5 53 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 52 && BOOST_PP_ITERATION_START_5 >= 52 # define BOOST_PP_ITERATION_5 52 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 51 && BOOST_PP_ITERATION_START_5 >= 51 # define BOOST_PP_ITERATION_5 51 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 50 && BOOST_PP_ITERATION_START_5 >= 50 # define BOOST_PP_ITERATION_5 50 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 49 && BOOST_PP_ITERATION_START_5 >= 49 # define BOOST_PP_ITERATION_5 49 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 48 && BOOST_PP_ITERATION_START_5 >= 48 # define BOOST_PP_ITERATION_5 48 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 47 && BOOST_PP_ITERATION_START_5 >= 47 # define BOOST_PP_ITERATION_5 47 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 46 && BOOST_PP_ITERATION_START_5 >= 46 # define BOOST_PP_ITERATION_5 46 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 45 && BOOST_PP_ITERATION_START_5 >= 45 # define BOOST_PP_ITERATION_5 45 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 44 && BOOST_PP_ITERATION_START_5 >= 44 # define BOOST_PP_ITERATION_5 44 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 43 && BOOST_PP_ITERATION_START_5 >= 43 # define BOOST_PP_ITERATION_5 43 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 42 && BOOST_PP_ITERATION_START_5 >= 42 # define BOOST_PP_ITERATION_5 42 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 41 && BOOST_PP_ITERATION_START_5 >= 41 # define BOOST_PP_ITERATION_5 41 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 40 && BOOST_PP_ITERATION_START_5 >= 40 # define BOOST_PP_ITERATION_5 40 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 39 && BOOST_PP_ITERATION_START_5 >= 39 # define BOOST_PP_ITERATION_5 39 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 38 && BOOST_PP_ITERATION_START_5 >= 38 # define BOOST_PP_ITERATION_5 38 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 37 && BOOST_PP_ITERATION_START_5 >= 37 # define BOOST_PP_ITERATION_5 37 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 36 && BOOST_PP_ITERATION_START_5 >= 36 # define BOOST_PP_ITERATION_5 36 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 35 && BOOST_PP_ITERATION_START_5 >= 35 # define BOOST_PP_ITERATION_5 35 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 34 && BOOST_PP_ITERATION_START_5 >= 34 # define BOOST_PP_ITERATION_5 34 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 33 && BOOST_PP_ITERATION_START_5 >= 33 # define BOOST_PP_ITERATION_5 33 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 32 && BOOST_PP_ITERATION_START_5 >= 32 # define BOOST_PP_ITERATION_5 32 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 31 && BOOST_PP_ITERATION_START_5 >= 31 # define BOOST_PP_ITERATION_5 31 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 30 && BOOST_PP_ITERATION_START_5 >= 30 # define BOOST_PP_ITERATION_5 30 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 29 && BOOST_PP_ITERATION_START_5 >= 29 # define BOOST_PP_ITERATION_5 29 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 28 && BOOST_PP_ITERATION_START_5 >= 28 # define BOOST_PP_ITERATION_5 28 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 27 && BOOST_PP_ITERATION_START_5 >= 27 # define BOOST_PP_ITERATION_5 27 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 26 && BOOST_PP_ITERATION_START_5 >= 26 # define BOOST_PP_ITERATION_5 26 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 25 && BOOST_PP_ITERATION_START_5 >= 25 # define BOOST_PP_ITERATION_5 25 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 24 && BOOST_PP_ITERATION_START_5 >= 24 # define BOOST_PP_ITERATION_5 24 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 23 && BOOST_PP_ITERATION_START_5 >= 23 # define BOOST_PP_ITERATION_5 23 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 22 && BOOST_PP_ITERATION_START_5 >= 22 # define BOOST_PP_ITERATION_5 22 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 21 && BOOST_PP_ITERATION_START_5 >= 21 # define BOOST_PP_ITERATION_5 21 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 20 && BOOST_PP_ITERATION_START_5 >= 20 # define BOOST_PP_ITERATION_5 20 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 19 && BOOST_PP_ITERATION_START_5 >= 19 # define BOOST_PP_ITERATION_5 19 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 18 && BOOST_PP_ITERATION_START_5 >= 18 # define BOOST_PP_ITERATION_5 18 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 17 && BOOST_PP_ITERATION_START_5 >= 17 # define BOOST_PP_ITERATION_5 17 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 16 && BOOST_PP_ITERATION_START_5 >= 16 # define BOOST_PP_ITERATION_5 16 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 15 && BOOST_PP_ITERATION_START_5 >= 15 # define BOOST_PP_ITERATION_5 15 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 14 && BOOST_PP_ITERATION_START_5 >= 14 # define BOOST_PP_ITERATION_5 14 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 13 && BOOST_PP_ITERATION_START_5 >= 13 # define BOOST_PP_ITERATION_5 13 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 12 && BOOST_PP_ITERATION_START_5 >= 12 # define BOOST_PP_ITERATION_5 12 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 11 && BOOST_PP_ITERATION_START_5 >= 11 # define BOOST_PP_ITERATION_5 11 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 10 && BOOST_PP_ITERATION_START_5 >= 10 # define BOOST_PP_ITERATION_5 10 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 9 && BOOST_PP_ITERATION_START_5 >= 9 # define BOOST_PP_ITERATION_5 9 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 8 && BOOST_PP_ITERATION_START_5 >= 8 # define BOOST_PP_ITERATION_5 8 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 7 && BOOST_PP_ITERATION_START_5 >= 7 # define BOOST_PP_ITERATION_5 7 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 6 && BOOST_PP_ITERATION_START_5 >= 6 # define BOOST_PP_ITERATION_5 6 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 5 && BOOST_PP_ITERATION_START_5 >= 5 # define BOOST_PP_ITERATION_5 5 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 4 && BOOST_PP_ITERATION_START_5 >= 4 # define BOOST_PP_ITERATION_5 4 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 3 && BOOST_PP_ITERATION_START_5 >= 3 # define BOOST_PP_ITERATION_5 3 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 2 && BOOST_PP_ITERATION_START_5 >= 2 # define BOOST_PP_ITERATION_5 2 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 1 && BOOST_PP_ITERATION_START_5 >= 1 # define BOOST_PP_ITERATION_5 1 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_FINISH_5 <= 0 && BOOST_PP_ITERATION_START_5 >= 0 # define BOOST_PP_ITERATION_5 0 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/reverse4.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000013631311344301502031742 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if BOOST_PP_ITERATION_FINISH_4 <= 256 && BOOST_PP_ITERATION_START_4 >= 256 # define BOOST_PP_ITERATION_4 256 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 255 && BOOST_PP_ITERATION_START_4 >= 255 # define BOOST_PP_ITERATION_4 255 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 254 && BOOST_PP_ITERATION_START_4 >= 254 # define BOOST_PP_ITERATION_4 254 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 253 && BOOST_PP_ITERATION_START_4 >= 253 # define BOOST_PP_ITERATION_4 253 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 252 && BOOST_PP_ITERATION_START_4 >= 252 # define BOOST_PP_ITERATION_4 252 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 251 && BOOST_PP_ITERATION_START_4 >= 251 # define BOOST_PP_ITERATION_4 251 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 250 && BOOST_PP_ITERATION_START_4 >= 250 # define BOOST_PP_ITERATION_4 250 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 249 && BOOST_PP_ITERATION_START_4 >= 249 # define BOOST_PP_ITERATION_4 249 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 248 && BOOST_PP_ITERATION_START_4 >= 248 # define BOOST_PP_ITERATION_4 248 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 247 && BOOST_PP_ITERATION_START_4 >= 247 # define BOOST_PP_ITERATION_4 247 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 246 && BOOST_PP_ITERATION_START_4 >= 246 # define BOOST_PP_ITERATION_4 246 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 245 && BOOST_PP_ITERATION_START_4 >= 245 # define BOOST_PP_ITERATION_4 245 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 244 && BOOST_PP_ITERATION_START_4 >= 244 # define BOOST_PP_ITERATION_4 244 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 243 && BOOST_PP_ITERATION_START_4 >= 243 # define BOOST_PP_ITERATION_4 243 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 242 && BOOST_PP_ITERATION_START_4 >= 242 # define BOOST_PP_ITERATION_4 242 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 241 && BOOST_PP_ITERATION_START_4 >= 241 # define BOOST_PP_ITERATION_4 241 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 240 && BOOST_PP_ITERATION_START_4 >= 240 # define BOOST_PP_ITERATION_4 240 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 239 && BOOST_PP_ITERATION_START_4 >= 239 # define BOOST_PP_ITERATION_4 239 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 238 && BOOST_PP_ITERATION_START_4 >= 238 # define BOOST_PP_ITERATION_4 238 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 237 && BOOST_PP_ITERATION_START_4 >= 237 # define BOOST_PP_ITERATION_4 237 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 236 && BOOST_PP_ITERATION_START_4 >= 236 # define BOOST_PP_ITERATION_4 236 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 235 && BOOST_PP_ITERATION_START_4 >= 235 # define BOOST_PP_ITERATION_4 235 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 234 && BOOST_PP_ITERATION_START_4 >= 234 # define BOOST_PP_ITERATION_4 234 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 233 && BOOST_PP_ITERATION_START_4 >= 233 # define BOOST_PP_ITERATION_4 233 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 232 && BOOST_PP_ITERATION_START_4 >= 232 # define BOOST_PP_ITERATION_4 232 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 231 && BOOST_PP_ITERATION_START_4 >= 231 # define BOOST_PP_ITERATION_4 231 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 230 && BOOST_PP_ITERATION_START_4 >= 230 # define BOOST_PP_ITERATION_4 230 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 229 && BOOST_PP_ITERATION_START_4 >= 229 # define BOOST_PP_ITERATION_4 229 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 228 && BOOST_PP_ITERATION_START_4 >= 228 # define BOOST_PP_ITERATION_4 228 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 227 && BOOST_PP_ITERATION_START_4 >= 227 # define BOOST_PP_ITERATION_4 227 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 226 && BOOST_PP_ITERATION_START_4 >= 226 # define BOOST_PP_ITERATION_4 226 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 225 && BOOST_PP_ITERATION_START_4 >= 225 # define BOOST_PP_ITERATION_4 225 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 224 && BOOST_PP_ITERATION_START_4 >= 224 # define BOOST_PP_ITERATION_4 224 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 223 && BOOST_PP_ITERATION_START_4 >= 223 # define BOOST_PP_ITERATION_4 223 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 222 && BOOST_PP_ITERATION_START_4 >= 222 # define BOOST_PP_ITERATION_4 222 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 221 && BOOST_PP_ITERATION_START_4 >= 221 # define BOOST_PP_ITERATION_4 221 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 220 && BOOST_PP_ITERATION_START_4 >= 220 # define BOOST_PP_ITERATION_4 220 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 219 && BOOST_PP_ITERATION_START_4 >= 219 # define BOOST_PP_ITERATION_4 219 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 218 && BOOST_PP_ITERATION_START_4 >= 218 # define BOOST_PP_ITERATION_4 218 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 217 && BOOST_PP_ITERATION_START_4 >= 217 # define BOOST_PP_ITERATION_4 217 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 216 && BOOST_PP_ITERATION_START_4 >= 216 # define BOOST_PP_ITERATION_4 216 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 215 && BOOST_PP_ITERATION_START_4 >= 215 # define BOOST_PP_ITERATION_4 215 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 214 && BOOST_PP_ITERATION_START_4 >= 214 # define BOOST_PP_ITERATION_4 214 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 213 && BOOST_PP_ITERATION_START_4 >= 213 # define BOOST_PP_ITERATION_4 213 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 212 && BOOST_PP_ITERATION_START_4 >= 212 # define BOOST_PP_ITERATION_4 212 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 211 && BOOST_PP_ITERATION_START_4 >= 211 # define BOOST_PP_ITERATION_4 211 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 210 && BOOST_PP_ITERATION_START_4 >= 210 # define BOOST_PP_ITERATION_4 210 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 209 && BOOST_PP_ITERATION_START_4 >= 209 # define BOOST_PP_ITERATION_4 209 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 208 && BOOST_PP_ITERATION_START_4 >= 208 # define BOOST_PP_ITERATION_4 208 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 207 && BOOST_PP_ITERATION_START_4 >= 207 # define BOOST_PP_ITERATION_4 207 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 206 && BOOST_PP_ITERATION_START_4 >= 206 # define BOOST_PP_ITERATION_4 206 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 205 && BOOST_PP_ITERATION_START_4 >= 205 # define BOOST_PP_ITERATION_4 205 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 204 && BOOST_PP_ITERATION_START_4 >= 204 # define BOOST_PP_ITERATION_4 204 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 203 && BOOST_PP_ITERATION_START_4 >= 203 # define BOOST_PP_ITERATION_4 203 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 202 && BOOST_PP_ITERATION_START_4 >= 202 # define BOOST_PP_ITERATION_4 202 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 201 && BOOST_PP_ITERATION_START_4 >= 201 # define BOOST_PP_ITERATION_4 201 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 200 && BOOST_PP_ITERATION_START_4 >= 200 # define BOOST_PP_ITERATION_4 200 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 199 && BOOST_PP_ITERATION_START_4 >= 199 # define BOOST_PP_ITERATION_4 199 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 198 && BOOST_PP_ITERATION_START_4 >= 198 # define BOOST_PP_ITERATION_4 198 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 197 && BOOST_PP_ITERATION_START_4 >= 197 # define BOOST_PP_ITERATION_4 197 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 196 && BOOST_PP_ITERATION_START_4 >= 196 # define BOOST_PP_ITERATION_4 196 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 195 && BOOST_PP_ITERATION_START_4 >= 195 # define BOOST_PP_ITERATION_4 195 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 194 && BOOST_PP_ITERATION_START_4 >= 194 # define BOOST_PP_ITERATION_4 194 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 193 && BOOST_PP_ITERATION_START_4 >= 193 # define BOOST_PP_ITERATION_4 193 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 192 && BOOST_PP_ITERATION_START_4 >= 192 # define BOOST_PP_ITERATION_4 192 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 191 && BOOST_PP_ITERATION_START_4 >= 191 # define BOOST_PP_ITERATION_4 191 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 190 && BOOST_PP_ITERATION_START_4 >= 190 # define BOOST_PP_ITERATION_4 190 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 189 && BOOST_PP_ITERATION_START_4 >= 189 # define BOOST_PP_ITERATION_4 189 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 188 && BOOST_PP_ITERATION_START_4 >= 188 # define BOOST_PP_ITERATION_4 188 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 187 && BOOST_PP_ITERATION_START_4 >= 187 # define BOOST_PP_ITERATION_4 187 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 186 && BOOST_PP_ITERATION_START_4 >= 186 # define BOOST_PP_ITERATION_4 186 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 185 && BOOST_PP_ITERATION_START_4 >= 185 # define BOOST_PP_ITERATION_4 185 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 184 && BOOST_PP_ITERATION_START_4 >= 184 # define BOOST_PP_ITERATION_4 184 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 183 && BOOST_PP_ITERATION_START_4 >= 183 # define BOOST_PP_ITERATION_4 183 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 182 && BOOST_PP_ITERATION_START_4 >= 182 # define BOOST_PP_ITERATION_4 182 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 181 && BOOST_PP_ITERATION_START_4 >= 181 # define BOOST_PP_ITERATION_4 181 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 180 && BOOST_PP_ITERATION_START_4 >= 180 # define BOOST_PP_ITERATION_4 180 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 179 && BOOST_PP_ITERATION_START_4 >= 179 # define BOOST_PP_ITERATION_4 179 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 178 && BOOST_PP_ITERATION_START_4 >= 178 # define BOOST_PP_ITERATION_4 178 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 177 && BOOST_PP_ITERATION_START_4 >= 177 # define BOOST_PP_ITERATION_4 177 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 176 && BOOST_PP_ITERATION_START_4 >= 176 # define BOOST_PP_ITERATION_4 176 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 175 && BOOST_PP_ITERATION_START_4 >= 175 # define BOOST_PP_ITERATION_4 175 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 174 && BOOST_PP_ITERATION_START_4 >= 174 # define BOOST_PP_ITERATION_4 174 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 173 && BOOST_PP_ITERATION_START_4 >= 173 # define BOOST_PP_ITERATION_4 173 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 172 && BOOST_PP_ITERATION_START_4 >= 172 # define BOOST_PP_ITERATION_4 172 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 171 && BOOST_PP_ITERATION_START_4 >= 171 # define BOOST_PP_ITERATION_4 171 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 170 && BOOST_PP_ITERATION_START_4 >= 170 # define BOOST_PP_ITERATION_4 170 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 169 && BOOST_PP_ITERATION_START_4 >= 169 # define BOOST_PP_ITERATION_4 169 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 168 && BOOST_PP_ITERATION_START_4 >= 168 # define BOOST_PP_ITERATION_4 168 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 167 && BOOST_PP_ITERATION_START_4 >= 167 # define BOOST_PP_ITERATION_4 167 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 166 && BOOST_PP_ITERATION_START_4 >= 166 # define BOOST_PP_ITERATION_4 166 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 165 && BOOST_PP_ITERATION_START_4 >= 165 # define BOOST_PP_ITERATION_4 165 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 164 && BOOST_PP_ITERATION_START_4 >= 164 # define BOOST_PP_ITERATION_4 164 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 163 && BOOST_PP_ITERATION_START_4 >= 163 # define BOOST_PP_ITERATION_4 163 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 162 && BOOST_PP_ITERATION_START_4 >= 162 # define BOOST_PP_ITERATION_4 162 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 161 && BOOST_PP_ITERATION_START_4 >= 161 # define BOOST_PP_ITERATION_4 161 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 160 && BOOST_PP_ITERATION_START_4 >= 160 # define BOOST_PP_ITERATION_4 160 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 159 && BOOST_PP_ITERATION_START_4 >= 159 # define BOOST_PP_ITERATION_4 159 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 158 && BOOST_PP_ITERATION_START_4 >= 158 # define BOOST_PP_ITERATION_4 158 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 157 && BOOST_PP_ITERATION_START_4 >= 157 # define BOOST_PP_ITERATION_4 157 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 156 && BOOST_PP_ITERATION_START_4 >= 156 # define BOOST_PP_ITERATION_4 156 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 155 && BOOST_PP_ITERATION_START_4 >= 155 # define BOOST_PP_ITERATION_4 155 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 154 && BOOST_PP_ITERATION_START_4 >= 154 # define BOOST_PP_ITERATION_4 154 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 153 && BOOST_PP_ITERATION_START_4 >= 153 # define BOOST_PP_ITERATION_4 153 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 152 && BOOST_PP_ITERATION_START_4 >= 152 # define BOOST_PP_ITERATION_4 152 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 151 && BOOST_PP_ITERATION_START_4 >= 151 # define BOOST_PP_ITERATION_4 151 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 150 && BOOST_PP_ITERATION_START_4 >= 150 # define BOOST_PP_ITERATION_4 150 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 149 && BOOST_PP_ITERATION_START_4 >= 149 # define BOOST_PP_ITERATION_4 149 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 148 && BOOST_PP_ITERATION_START_4 >= 148 # define BOOST_PP_ITERATION_4 148 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 147 && BOOST_PP_ITERATION_START_4 >= 147 # define BOOST_PP_ITERATION_4 147 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 146 && BOOST_PP_ITERATION_START_4 >= 146 # define BOOST_PP_ITERATION_4 146 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 145 && BOOST_PP_ITERATION_START_4 >= 145 # define BOOST_PP_ITERATION_4 145 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 144 && BOOST_PP_ITERATION_START_4 >= 144 # define BOOST_PP_ITERATION_4 144 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 143 && BOOST_PP_ITERATION_START_4 >= 143 # define BOOST_PP_ITERATION_4 143 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 142 && BOOST_PP_ITERATION_START_4 >= 142 # define BOOST_PP_ITERATION_4 142 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 141 && BOOST_PP_ITERATION_START_4 >= 141 # define BOOST_PP_ITERATION_4 141 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 140 && BOOST_PP_ITERATION_START_4 >= 140 # define BOOST_PP_ITERATION_4 140 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 139 && BOOST_PP_ITERATION_START_4 >= 139 # define BOOST_PP_ITERATION_4 139 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 138 && BOOST_PP_ITERATION_START_4 >= 138 # define BOOST_PP_ITERATION_4 138 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 137 && BOOST_PP_ITERATION_START_4 >= 137 # define BOOST_PP_ITERATION_4 137 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 136 && BOOST_PP_ITERATION_START_4 >= 136 # define BOOST_PP_ITERATION_4 136 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 135 && BOOST_PP_ITERATION_START_4 >= 135 # define BOOST_PP_ITERATION_4 135 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 134 && BOOST_PP_ITERATION_START_4 >= 134 # define BOOST_PP_ITERATION_4 134 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 133 && BOOST_PP_ITERATION_START_4 >= 133 # define BOOST_PP_ITERATION_4 133 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 132 && BOOST_PP_ITERATION_START_4 >= 132 # define BOOST_PP_ITERATION_4 132 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 131 && BOOST_PP_ITERATION_START_4 >= 131 # define BOOST_PP_ITERATION_4 131 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 130 && BOOST_PP_ITERATION_START_4 >= 130 # define BOOST_PP_ITERATION_4 130 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 129 && BOOST_PP_ITERATION_START_4 >= 129 # define BOOST_PP_ITERATION_4 129 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 128 && BOOST_PP_ITERATION_START_4 >= 128 # define BOOST_PP_ITERATION_4 128 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 127 && BOOST_PP_ITERATION_START_4 >= 127 # define BOOST_PP_ITERATION_4 127 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 126 && BOOST_PP_ITERATION_START_4 >= 126 # define BOOST_PP_ITERATION_4 126 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 125 && BOOST_PP_ITERATION_START_4 >= 125 # define BOOST_PP_ITERATION_4 125 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 124 && BOOST_PP_ITERATION_START_4 >= 124 # define BOOST_PP_ITERATION_4 124 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 123 && BOOST_PP_ITERATION_START_4 >= 123 # define BOOST_PP_ITERATION_4 123 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 122 && BOOST_PP_ITERATION_START_4 >= 122 # define BOOST_PP_ITERATION_4 122 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 121 && BOOST_PP_ITERATION_START_4 >= 121 # define BOOST_PP_ITERATION_4 121 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 120 && BOOST_PP_ITERATION_START_4 >= 120 # define BOOST_PP_ITERATION_4 120 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 119 && BOOST_PP_ITERATION_START_4 >= 119 # define BOOST_PP_ITERATION_4 119 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 118 && BOOST_PP_ITERATION_START_4 >= 118 # define BOOST_PP_ITERATION_4 118 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 117 && BOOST_PP_ITERATION_START_4 >= 117 # define BOOST_PP_ITERATION_4 117 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 116 && BOOST_PP_ITERATION_START_4 >= 116 # define BOOST_PP_ITERATION_4 116 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 115 && BOOST_PP_ITERATION_START_4 >= 115 # define BOOST_PP_ITERATION_4 115 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 114 && BOOST_PP_ITERATION_START_4 >= 114 # define BOOST_PP_ITERATION_4 114 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 113 && BOOST_PP_ITERATION_START_4 >= 113 # define BOOST_PP_ITERATION_4 113 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 112 && BOOST_PP_ITERATION_START_4 >= 112 # define BOOST_PP_ITERATION_4 112 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 111 && BOOST_PP_ITERATION_START_4 >= 111 # define BOOST_PP_ITERATION_4 111 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 110 && BOOST_PP_ITERATION_START_4 >= 110 # define BOOST_PP_ITERATION_4 110 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 109 && BOOST_PP_ITERATION_START_4 >= 109 # define BOOST_PP_ITERATION_4 109 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 108 && BOOST_PP_ITERATION_START_4 >= 108 # define BOOST_PP_ITERATION_4 108 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 107 && BOOST_PP_ITERATION_START_4 >= 107 # define BOOST_PP_ITERATION_4 107 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 106 && BOOST_PP_ITERATION_START_4 >= 106 # define BOOST_PP_ITERATION_4 106 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 105 && BOOST_PP_ITERATION_START_4 >= 105 # define BOOST_PP_ITERATION_4 105 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 104 && BOOST_PP_ITERATION_START_4 >= 104 # define BOOST_PP_ITERATION_4 104 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 103 && BOOST_PP_ITERATION_START_4 >= 103 # define BOOST_PP_ITERATION_4 103 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 102 && BOOST_PP_ITERATION_START_4 >= 102 # define BOOST_PP_ITERATION_4 102 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 101 && BOOST_PP_ITERATION_START_4 >= 101 # define BOOST_PP_ITERATION_4 101 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 100 && BOOST_PP_ITERATION_START_4 >= 100 # define BOOST_PP_ITERATION_4 100 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 99 && BOOST_PP_ITERATION_START_4 >= 99 # define BOOST_PP_ITERATION_4 99 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 98 && BOOST_PP_ITERATION_START_4 >= 98 # define BOOST_PP_ITERATION_4 98 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 97 && BOOST_PP_ITERATION_START_4 >= 97 # define BOOST_PP_ITERATION_4 97 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 96 && BOOST_PP_ITERATION_START_4 >= 96 # define BOOST_PP_ITERATION_4 96 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 95 && BOOST_PP_ITERATION_START_4 >= 95 # define BOOST_PP_ITERATION_4 95 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 94 && BOOST_PP_ITERATION_START_4 >= 94 # define BOOST_PP_ITERATION_4 94 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 93 && BOOST_PP_ITERATION_START_4 >= 93 # define BOOST_PP_ITERATION_4 93 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 92 && BOOST_PP_ITERATION_START_4 >= 92 # define BOOST_PP_ITERATION_4 92 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 91 && BOOST_PP_ITERATION_START_4 >= 91 # define BOOST_PP_ITERATION_4 91 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 90 && BOOST_PP_ITERATION_START_4 >= 90 # define BOOST_PP_ITERATION_4 90 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 89 && BOOST_PP_ITERATION_START_4 >= 89 # define BOOST_PP_ITERATION_4 89 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 88 && BOOST_PP_ITERATION_START_4 >= 88 # define BOOST_PP_ITERATION_4 88 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 87 && BOOST_PP_ITERATION_START_4 >= 87 # define BOOST_PP_ITERATION_4 87 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 86 && BOOST_PP_ITERATION_START_4 >= 86 # define BOOST_PP_ITERATION_4 86 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 85 && BOOST_PP_ITERATION_START_4 >= 85 # define BOOST_PP_ITERATION_4 85 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 84 && BOOST_PP_ITERATION_START_4 >= 84 # define BOOST_PP_ITERATION_4 84 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 83 && BOOST_PP_ITERATION_START_4 >= 83 # define BOOST_PP_ITERATION_4 83 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 82 && BOOST_PP_ITERATION_START_4 >= 82 # define BOOST_PP_ITERATION_4 82 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 81 && BOOST_PP_ITERATION_START_4 >= 81 # define BOOST_PP_ITERATION_4 81 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 80 && BOOST_PP_ITERATION_START_4 >= 80 # define BOOST_PP_ITERATION_4 80 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 79 && BOOST_PP_ITERATION_START_4 >= 79 # define BOOST_PP_ITERATION_4 79 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 78 && BOOST_PP_ITERATION_START_4 >= 78 # define BOOST_PP_ITERATION_4 78 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 77 && BOOST_PP_ITERATION_START_4 >= 77 # define BOOST_PP_ITERATION_4 77 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 76 && BOOST_PP_ITERATION_START_4 >= 76 # define BOOST_PP_ITERATION_4 76 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 75 && BOOST_PP_ITERATION_START_4 >= 75 # define BOOST_PP_ITERATION_4 75 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 74 && BOOST_PP_ITERATION_START_4 >= 74 # define BOOST_PP_ITERATION_4 74 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 73 && BOOST_PP_ITERATION_START_4 >= 73 # define BOOST_PP_ITERATION_4 73 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 72 && BOOST_PP_ITERATION_START_4 >= 72 # define BOOST_PP_ITERATION_4 72 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 71 && BOOST_PP_ITERATION_START_4 >= 71 # define BOOST_PP_ITERATION_4 71 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 70 && BOOST_PP_ITERATION_START_4 >= 70 # define BOOST_PP_ITERATION_4 70 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 69 && BOOST_PP_ITERATION_START_4 >= 69 # define BOOST_PP_ITERATION_4 69 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 68 && BOOST_PP_ITERATION_START_4 >= 68 # define BOOST_PP_ITERATION_4 68 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 67 && BOOST_PP_ITERATION_START_4 >= 67 # define BOOST_PP_ITERATION_4 67 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 66 && BOOST_PP_ITERATION_START_4 >= 66 # define BOOST_PP_ITERATION_4 66 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 65 && BOOST_PP_ITERATION_START_4 >= 65 # define BOOST_PP_ITERATION_4 65 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 64 && BOOST_PP_ITERATION_START_4 >= 64 # define BOOST_PP_ITERATION_4 64 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 63 && BOOST_PP_ITERATION_START_4 >= 63 # define BOOST_PP_ITERATION_4 63 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 62 && BOOST_PP_ITERATION_START_4 >= 62 # define BOOST_PP_ITERATION_4 62 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 61 && BOOST_PP_ITERATION_START_4 >= 61 # define BOOST_PP_ITERATION_4 61 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 60 && BOOST_PP_ITERATION_START_4 >= 60 # define BOOST_PP_ITERATION_4 60 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 59 && BOOST_PP_ITERATION_START_4 >= 59 # define BOOST_PP_ITERATION_4 59 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 58 && BOOST_PP_ITERATION_START_4 >= 58 # define BOOST_PP_ITERATION_4 58 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 57 && BOOST_PP_ITERATION_START_4 >= 57 # define BOOST_PP_ITERATION_4 57 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 56 && BOOST_PP_ITERATION_START_4 >= 56 # define BOOST_PP_ITERATION_4 56 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 55 && BOOST_PP_ITERATION_START_4 >= 55 # define BOOST_PP_ITERATION_4 55 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 54 && BOOST_PP_ITERATION_START_4 >= 54 # define BOOST_PP_ITERATION_4 54 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 53 && BOOST_PP_ITERATION_START_4 >= 53 # define BOOST_PP_ITERATION_4 53 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 52 && BOOST_PP_ITERATION_START_4 >= 52 # define BOOST_PP_ITERATION_4 52 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 51 && BOOST_PP_ITERATION_START_4 >= 51 # define BOOST_PP_ITERATION_4 51 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 50 && BOOST_PP_ITERATION_START_4 >= 50 # define BOOST_PP_ITERATION_4 50 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 49 && BOOST_PP_ITERATION_START_4 >= 49 # define BOOST_PP_ITERATION_4 49 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 48 && BOOST_PP_ITERATION_START_4 >= 48 # define BOOST_PP_ITERATION_4 48 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 47 && BOOST_PP_ITERATION_START_4 >= 47 # define BOOST_PP_ITERATION_4 47 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 46 && BOOST_PP_ITERATION_START_4 >= 46 # define BOOST_PP_ITERATION_4 46 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 45 && BOOST_PP_ITERATION_START_4 >= 45 # define BOOST_PP_ITERATION_4 45 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 44 && BOOST_PP_ITERATION_START_4 >= 44 # define BOOST_PP_ITERATION_4 44 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 43 && BOOST_PP_ITERATION_START_4 >= 43 # define BOOST_PP_ITERATION_4 43 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 42 && BOOST_PP_ITERATION_START_4 >= 42 # define BOOST_PP_ITERATION_4 42 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 41 && BOOST_PP_ITERATION_START_4 >= 41 # define BOOST_PP_ITERATION_4 41 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 40 && BOOST_PP_ITERATION_START_4 >= 40 # define BOOST_PP_ITERATION_4 40 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 39 && BOOST_PP_ITERATION_START_4 >= 39 # define BOOST_PP_ITERATION_4 39 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 38 && BOOST_PP_ITERATION_START_4 >= 38 # define BOOST_PP_ITERATION_4 38 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 37 && BOOST_PP_ITERATION_START_4 >= 37 # define BOOST_PP_ITERATION_4 37 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 36 && BOOST_PP_ITERATION_START_4 >= 36 # define BOOST_PP_ITERATION_4 36 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 35 && BOOST_PP_ITERATION_START_4 >= 35 # define BOOST_PP_ITERATION_4 35 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 34 && BOOST_PP_ITERATION_START_4 >= 34 # define BOOST_PP_ITERATION_4 34 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 33 && BOOST_PP_ITERATION_START_4 >= 33 # define BOOST_PP_ITERATION_4 33 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 32 && BOOST_PP_ITERATION_START_4 >= 32 # define BOOST_PP_ITERATION_4 32 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 31 && BOOST_PP_ITERATION_START_4 >= 31 # define BOOST_PP_ITERATION_4 31 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 30 && BOOST_PP_ITERATION_START_4 >= 30 # define BOOST_PP_ITERATION_4 30 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 29 && BOOST_PP_ITERATION_START_4 >= 29 # define BOOST_PP_ITERATION_4 29 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 28 && BOOST_PP_ITERATION_START_4 >= 28 # define BOOST_PP_ITERATION_4 28 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 27 && BOOST_PP_ITERATION_START_4 >= 27 # define BOOST_PP_ITERATION_4 27 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 26 && BOOST_PP_ITERATION_START_4 >= 26 # define BOOST_PP_ITERATION_4 26 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 25 && BOOST_PP_ITERATION_START_4 >= 25 # define BOOST_PP_ITERATION_4 25 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 24 && BOOST_PP_ITERATION_START_4 >= 24 # define BOOST_PP_ITERATION_4 24 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 23 && BOOST_PP_ITERATION_START_4 >= 23 # define BOOST_PP_ITERATION_4 23 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 22 && BOOST_PP_ITERATION_START_4 >= 22 # define BOOST_PP_ITERATION_4 22 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 21 && BOOST_PP_ITERATION_START_4 >= 21 # define BOOST_PP_ITERATION_4 21 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 20 && BOOST_PP_ITERATION_START_4 >= 20 # define BOOST_PP_ITERATION_4 20 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 19 && BOOST_PP_ITERATION_START_4 >= 19 # define BOOST_PP_ITERATION_4 19 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 18 && BOOST_PP_ITERATION_START_4 >= 18 # define BOOST_PP_ITERATION_4 18 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 17 && BOOST_PP_ITERATION_START_4 >= 17 # define BOOST_PP_ITERATION_4 17 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 16 && BOOST_PP_ITERATION_START_4 >= 16 # define BOOST_PP_ITERATION_4 16 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 15 && BOOST_PP_ITERATION_START_4 >= 15 # define BOOST_PP_ITERATION_4 15 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 14 && BOOST_PP_ITERATION_START_4 >= 14 # define BOOST_PP_ITERATION_4 14 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 13 && BOOST_PP_ITERATION_START_4 >= 13 # define BOOST_PP_ITERATION_4 13 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 12 && BOOST_PP_ITERATION_START_4 >= 12 # define BOOST_PP_ITERATION_4 12 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 11 && BOOST_PP_ITERATION_START_4 >= 11 # define BOOST_PP_ITERATION_4 11 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 10 && BOOST_PP_ITERATION_START_4 >= 10 # define BOOST_PP_ITERATION_4 10 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 9 && BOOST_PP_ITERATION_START_4 >= 9 # define BOOST_PP_ITERATION_4 9 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 8 && BOOST_PP_ITERATION_START_4 >= 8 # define BOOST_PP_ITERATION_4 8 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 7 && BOOST_PP_ITERATION_START_4 >= 7 # define BOOST_PP_ITERATION_4 7 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 6 && BOOST_PP_ITERATION_START_4 >= 6 # define BOOST_PP_ITERATION_4 6 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 5 && BOOST_PP_ITERATION_START_4 >= 5 # define BOOST_PP_ITERATION_4 5 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 4 && BOOST_PP_ITERATION_START_4 >= 4 # define BOOST_PP_ITERATION_4 4 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 3 && BOOST_PP_ITERATION_START_4 >= 3 # define BOOST_PP_ITERATION_4 3 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 2 && BOOST_PP_ITERATION_START_4 >= 2 # define BOOST_PP_ITERATION_4 2 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 1 && BOOST_PP_ITERATION_START_4 >= 1 # define BOOST_PP_ITERATION_4 1 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_FINISH_4 <= 0 && BOOST_PP_ITERATION_START_4 >= 0 # define BOOST_PP_ITERATION_4 0 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/forward5.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000015265711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if defined(BOOST_PP_ITERATION_LIMITS) # if !defined(BOOST_PP_FILENAME_5) # error BOOST_PP_ERROR: depth #5 filename is not defined # endif # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_ITERATION_FLAGS_5 0 # undef BOOST_PP_ITERATION_LIMITS # elif defined(BOOST_PP_ITERATION_PARAMS_5) # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_5) # include # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_5) # include # define BOOST_PP_FILENAME_5 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_5) # if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_5) >= 4 # define BOOST_PP_ITERATION_FLAGS_5 BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_5) # else # define BOOST_PP_ITERATION_FLAGS_5 0 # endif # else # error BOOST_PP_ERROR: depth #5 iteration boundaries or filename not defined # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 5 # # if (BOOST_PP_ITERATION_START_5) > (BOOST_PP_ITERATION_FINISH_5) # include # else # if BOOST_PP_ITERATION_START_5 <= 0 && BOOST_PP_ITERATION_FINISH_5 >= 0 # define BOOST_PP_ITERATION_5 0 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 1 && BOOST_PP_ITERATION_FINISH_5 >= 1 # define BOOST_PP_ITERATION_5 1 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 2 && BOOST_PP_ITERATION_FINISH_5 >= 2 # define BOOST_PP_ITERATION_5 2 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 3 && BOOST_PP_ITERATION_FINISH_5 >= 3 # define BOOST_PP_ITERATION_5 3 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 4 && BOOST_PP_ITERATION_FINISH_5 >= 4 # define BOOST_PP_ITERATION_5 4 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 5 && BOOST_PP_ITERATION_FINISH_5 >= 5 # define BOOST_PP_ITERATION_5 5 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 6 && BOOST_PP_ITERATION_FINISH_5 >= 6 # define BOOST_PP_ITERATION_5 6 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 7 && BOOST_PP_ITERATION_FINISH_5 >= 7 # define BOOST_PP_ITERATION_5 7 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 8 && BOOST_PP_ITERATION_FINISH_5 >= 8 # define BOOST_PP_ITERATION_5 8 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 9 && BOOST_PP_ITERATION_FINISH_5 >= 9 # define BOOST_PP_ITERATION_5 9 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 10 && BOOST_PP_ITERATION_FINISH_5 >= 10 # define BOOST_PP_ITERATION_5 10 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 11 && BOOST_PP_ITERATION_FINISH_5 >= 11 # define BOOST_PP_ITERATION_5 11 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 12 && BOOST_PP_ITERATION_FINISH_5 >= 12 # define BOOST_PP_ITERATION_5 12 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 13 && BOOST_PP_ITERATION_FINISH_5 >= 13 # define BOOST_PP_ITERATION_5 13 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 14 && BOOST_PP_ITERATION_FINISH_5 >= 14 # define BOOST_PP_ITERATION_5 14 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 15 && BOOST_PP_ITERATION_FINISH_5 >= 15 # define BOOST_PP_ITERATION_5 15 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 16 && BOOST_PP_ITERATION_FINISH_5 >= 16 # define BOOST_PP_ITERATION_5 16 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 17 && BOOST_PP_ITERATION_FINISH_5 >= 17 # define BOOST_PP_ITERATION_5 17 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 18 && BOOST_PP_ITERATION_FINISH_5 >= 18 # define BOOST_PP_ITERATION_5 18 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 19 && BOOST_PP_ITERATION_FINISH_5 >= 19 # define BOOST_PP_ITERATION_5 19 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 20 && BOOST_PP_ITERATION_FINISH_5 >= 20 # define BOOST_PP_ITERATION_5 20 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 21 && BOOST_PP_ITERATION_FINISH_5 >= 21 # define BOOST_PP_ITERATION_5 21 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 22 && BOOST_PP_ITERATION_FINISH_5 >= 22 # define BOOST_PP_ITERATION_5 22 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 23 && BOOST_PP_ITERATION_FINISH_5 >= 23 # define BOOST_PP_ITERATION_5 23 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 24 && BOOST_PP_ITERATION_FINISH_5 >= 24 # define BOOST_PP_ITERATION_5 24 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 25 && BOOST_PP_ITERATION_FINISH_5 >= 25 # define BOOST_PP_ITERATION_5 25 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 26 && BOOST_PP_ITERATION_FINISH_5 >= 26 # define BOOST_PP_ITERATION_5 26 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 27 && BOOST_PP_ITERATION_FINISH_5 >= 27 # define BOOST_PP_ITERATION_5 27 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 28 && BOOST_PP_ITERATION_FINISH_5 >= 28 # define BOOST_PP_ITERATION_5 28 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 29 && BOOST_PP_ITERATION_FINISH_5 >= 29 # define BOOST_PP_ITERATION_5 29 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 30 && BOOST_PP_ITERATION_FINISH_5 >= 30 # define BOOST_PP_ITERATION_5 30 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 31 && BOOST_PP_ITERATION_FINISH_5 >= 31 # define BOOST_PP_ITERATION_5 31 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 32 && BOOST_PP_ITERATION_FINISH_5 >= 32 # define BOOST_PP_ITERATION_5 32 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 33 && BOOST_PP_ITERATION_FINISH_5 >= 33 # define BOOST_PP_ITERATION_5 33 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 34 && BOOST_PP_ITERATION_FINISH_5 >= 34 # define BOOST_PP_ITERATION_5 34 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 35 && BOOST_PP_ITERATION_FINISH_5 >= 35 # define BOOST_PP_ITERATION_5 35 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 36 && BOOST_PP_ITERATION_FINISH_5 >= 36 # define BOOST_PP_ITERATION_5 36 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 37 && BOOST_PP_ITERATION_FINISH_5 >= 37 # define BOOST_PP_ITERATION_5 37 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 38 && BOOST_PP_ITERATION_FINISH_5 >= 38 # define BOOST_PP_ITERATION_5 38 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 39 && BOOST_PP_ITERATION_FINISH_5 >= 39 # define BOOST_PP_ITERATION_5 39 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 40 && BOOST_PP_ITERATION_FINISH_5 >= 40 # define BOOST_PP_ITERATION_5 40 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 41 && BOOST_PP_ITERATION_FINISH_5 >= 41 # define BOOST_PP_ITERATION_5 41 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 42 && BOOST_PP_ITERATION_FINISH_5 >= 42 # define BOOST_PP_ITERATION_5 42 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 43 && BOOST_PP_ITERATION_FINISH_5 >= 43 # define BOOST_PP_ITERATION_5 43 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 44 && BOOST_PP_ITERATION_FINISH_5 >= 44 # define BOOST_PP_ITERATION_5 44 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 45 && BOOST_PP_ITERATION_FINISH_5 >= 45 # define BOOST_PP_ITERATION_5 45 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 46 && BOOST_PP_ITERATION_FINISH_5 >= 46 # define BOOST_PP_ITERATION_5 46 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 47 && BOOST_PP_ITERATION_FINISH_5 >= 47 # define BOOST_PP_ITERATION_5 47 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 48 && BOOST_PP_ITERATION_FINISH_5 >= 48 # define BOOST_PP_ITERATION_5 48 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 49 && BOOST_PP_ITERATION_FINISH_5 >= 49 # define BOOST_PP_ITERATION_5 49 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 50 && BOOST_PP_ITERATION_FINISH_5 >= 50 # define BOOST_PP_ITERATION_5 50 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 51 && BOOST_PP_ITERATION_FINISH_5 >= 51 # define BOOST_PP_ITERATION_5 51 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 52 && BOOST_PP_ITERATION_FINISH_5 >= 52 # define BOOST_PP_ITERATION_5 52 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 53 && BOOST_PP_ITERATION_FINISH_5 >= 53 # define BOOST_PP_ITERATION_5 53 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 54 && BOOST_PP_ITERATION_FINISH_5 >= 54 # define BOOST_PP_ITERATION_5 54 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 55 && BOOST_PP_ITERATION_FINISH_5 >= 55 # define BOOST_PP_ITERATION_5 55 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 56 && BOOST_PP_ITERATION_FINISH_5 >= 56 # define BOOST_PP_ITERATION_5 56 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 57 && BOOST_PP_ITERATION_FINISH_5 >= 57 # define BOOST_PP_ITERATION_5 57 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 58 && BOOST_PP_ITERATION_FINISH_5 >= 58 # define BOOST_PP_ITERATION_5 58 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 59 && BOOST_PP_ITERATION_FINISH_5 >= 59 # define BOOST_PP_ITERATION_5 59 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 60 && BOOST_PP_ITERATION_FINISH_5 >= 60 # define BOOST_PP_ITERATION_5 60 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 61 && BOOST_PP_ITERATION_FINISH_5 >= 61 # define BOOST_PP_ITERATION_5 61 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 62 && BOOST_PP_ITERATION_FINISH_5 >= 62 # define BOOST_PP_ITERATION_5 62 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 63 && BOOST_PP_ITERATION_FINISH_5 >= 63 # define BOOST_PP_ITERATION_5 63 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 64 && BOOST_PP_ITERATION_FINISH_5 >= 64 # define BOOST_PP_ITERATION_5 64 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 65 && BOOST_PP_ITERATION_FINISH_5 >= 65 # define BOOST_PP_ITERATION_5 65 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 66 && BOOST_PP_ITERATION_FINISH_5 >= 66 # define BOOST_PP_ITERATION_5 66 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 67 && BOOST_PP_ITERATION_FINISH_5 >= 67 # define BOOST_PP_ITERATION_5 67 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 68 && BOOST_PP_ITERATION_FINISH_5 >= 68 # define BOOST_PP_ITERATION_5 68 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 69 && BOOST_PP_ITERATION_FINISH_5 >= 69 # define BOOST_PP_ITERATION_5 69 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 70 && BOOST_PP_ITERATION_FINISH_5 >= 70 # define BOOST_PP_ITERATION_5 70 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 71 && BOOST_PP_ITERATION_FINISH_5 >= 71 # define BOOST_PP_ITERATION_5 71 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 72 && BOOST_PP_ITERATION_FINISH_5 >= 72 # define BOOST_PP_ITERATION_5 72 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 73 && BOOST_PP_ITERATION_FINISH_5 >= 73 # define BOOST_PP_ITERATION_5 73 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 74 && BOOST_PP_ITERATION_FINISH_5 >= 74 # define BOOST_PP_ITERATION_5 74 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 75 && BOOST_PP_ITERATION_FINISH_5 >= 75 # define BOOST_PP_ITERATION_5 75 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 76 && BOOST_PP_ITERATION_FINISH_5 >= 76 # define BOOST_PP_ITERATION_5 76 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 77 && BOOST_PP_ITERATION_FINISH_5 >= 77 # define BOOST_PP_ITERATION_5 77 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 78 && BOOST_PP_ITERATION_FINISH_5 >= 78 # define BOOST_PP_ITERATION_5 78 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 79 && BOOST_PP_ITERATION_FINISH_5 >= 79 # define BOOST_PP_ITERATION_5 79 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 80 && BOOST_PP_ITERATION_FINISH_5 >= 80 # define BOOST_PP_ITERATION_5 80 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 81 && BOOST_PP_ITERATION_FINISH_5 >= 81 # define BOOST_PP_ITERATION_5 81 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 82 && BOOST_PP_ITERATION_FINISH_5 >= 82 # define BOOST_PP_ITERATION_5 82 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 83 && BOOST_PP_ITERATION_FINISH_5 >= 83 # define BOOST_PP_ITERATION_5 83 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 84 && BOOST_PP_ITERATION_FINISH_5 >= 84 # define BOOST_PP_ITERATION_5 84 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 85 && BOOST_PP_ITERATION_FINISH_5 >= 85 # define BOOST_PP_ITERATION_5 85 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 86 && BOOST_PP_ITERATION_FINISH_5 >= 86 # define BOOST_PP_ITERATION_5 86 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 87 && BOOST_PP_ITERATION_FINISH_5 >= 87 # define BOOST_PP_ITERATION_5 87 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 88 && BOOST_PP_ITERATION_FINISH_5 >= 88 # define BOOST_PP_ITERATION_5 88 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 89 && BOOST_PP_ITERATION_FINISH_5 >= 89 # define BOOST_PP_ITERATION_5 89 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 90 && BOOST_PP_ITERATION_FINISH_5 >= 90 # define BOOST_PP_ITERATION_5 90 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 91 && BOOST_PP_ITERATION_FINISH_5 >= 91 # define BOOST_PP_ITERATION_5 91 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 92 && BOOST_PP_ITERATION_FINISH_5 >= 92 # define BOOST_PP_ITERATION_5 92 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 93 && BOOST_PP_ITERATION_FINISH_5 >= 93 # define BOOST_PP_ITERATION_5 93 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 94 && BOOST_PP_ITERATION_FINISH_5 >= 94 # define BOOST_PP_ITERATION_5 94 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 95 && BOOST_PP_ITERATION_FINISH_5 >= 95 # define BOOST_PP_ITERATION_5 95 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 96 && BOOST_PP_ITERATION_FINISH_5 >= 96 # define BOOST_PP_ITERATION_5 96 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 97 && BOOST_PP_ITERATION_FINISH_5 >= 97 # define BOOST_PP_ITERATION_5 97 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 98 && BOOST_PP_ITERATION_FINISH_5 >= 98 # define BOOST_PP_ITERATION_5 98 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 99 && BOOST_PP_ITERATION_FINISH_5 >= 99 # define BOOST_PP_ITERATION_5 99 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 100 && BOOST_PP_ITERATION_FINISH_5 >= 100 # define BOOST_PP_ITERATION_5 100 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 101 && BOOST_PP_ITERATION_FINISH_5 >= 101 # define BOOST_PP_ITERATION_5 101 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 102 && BOOST_PP_ITERATION_FINISH_5 >= 102 # define BOOST_PP_ITERATION_5 102 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 103 && BOOST_PP_ITERATION_FINISH_5 >= 103 # define BOOST_PP_ITERATION_5 103 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 104 && BOOST_PP_ITERATION_FINISH_5 >= 104 # define BOOST_PP_ITERATION_5 104 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 105 && BOOST_PP_ITERATION_FINISH_5 >= 105 # define BOOST_PP_ITERATION_5 105 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 106 && BOOST_PP_ITERATION_FINISH_5 >= 106 # define BOOST_PP_ITERATION_5 106 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 107 && BOOST_PP_ITERATION_FINISH_5 >= 107 # define BOOST_PP_ITERATION_5 107 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 108 && BOOST_PP_ITERATION_FINISH_5 >= 108 # define BOOST_PP_ITERATION_5 108 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 109 && BOOST_PP_ITERATION_FINISH_5 >= 109 # define BOOST_PP_ITERATION_5 109 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 110 && BOOST_PP_ITERATION_FINISH_5 >= 110 # define BOOST_PP_ITERATION_5 110 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 111 && BOOST_PP_ITERATION_FINISH_5 >= 111 # define BOOST_PP_ITERATION_5 111 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 112 && BOOST_PP_ITERATION_FINISH_5 >= 112 # define BOOST_PP_ITERATION_5 112 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 113 && BOOST_PP_ITERATION_FINISH_5 >= 113 # define BOOST_PP_ITERATION_5 113 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 114 && BOOST_PP_ITERATION_FINISH_5 >= 114 # define BOOST_PP_ITERATION_5 114 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 115 && BOOST_PP_ITERATION_FINISH_5 >= 115 # define BOOST_PP_ITERATION_5 115 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 116 && BOOST_PP_ITERATION_FINISH_5 >= 116 # define BOOST_PP_ITERATION_5 116 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 117 && BOOST_PP_ITERATION_FINISH_5 >= 117 # define BOOST_PP_ITERATION_5 117 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 118 && BOOST_PP_ITERATION_FINISH_5 >= 118 # define BOOST_PP_ITERATION_5 118 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 119 && BOOST_PP_ITERATION_FINISH_5 >= 119 # define BOOST_PP_ITERATION_5 119 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 120 && BOOST_PP_ITERATION_FINISH_5 >= 120 # define BOOST_PP_ITERATION_5 120 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 121 && BOOST_PP_ITERATION_FINISH_5 >= 121 # define BOOST_PP_ITERATION_5 121 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 122 && BOOST_PP_ITERATION_FINISH_5 >= 122 # define BOOST_PP_ITERATION_5 122 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 123 && BOOST_PP_ITERATION_FINISH_5 >= 123 # define BOOST_PP_ITERATION_5 123 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 124 && BOOST_PP_ITERATION_FINISH_5 >= 124 # define BOOST_PP_ITERATION_5 124 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 125 && BOOST_PP_ITERATION_FINISH_5 >= 125 # define BOOST_PP_ITERATION_5 125 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 126 && BOOST_PP_ITERATION_FINISH_5 >= 126 # define BOOST_PP_ITERATION_5 126 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 127 && BOOST_PP_ITERATION_FINISH_5 >= 127 # define BOOST_PP_ITERATION_5 127 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 128 && BOOST_PP_ITERATION_FINISH_5 >= 128 # define BOOST_PP_ITERATION_5 128 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 129 && BOOST_PP_ITERATION_FINISH_5 >= 129 # define BOOST_PP_ITERATION_5 129 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 130 && BOOST_PP_ITERATION_FINISH_5 >= 130 # define BOOST_PP_ITERATION_5 130 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 131 && BOOST_PP_ITERATION_FINISH_5 >= 131 # define BOOST_PP_ITERATION_5 131 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 132 && BOOST_PP_ITERATION_FINISH_5 >= 132 # define BOOST_PP_ITERATION_5 132 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 133 && BOOST_PP_ITERATION_FINISH_5 >= 133 # define BOOST_PP_ITERATION_5 133 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 134 && BOOST_PP_ITERATION_FINISH_5 >= 134 # define BOOST_PP_ITERATION_5 134 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 135 && BOOST_PP_ITERATION_FINISH_5 >= 135 # define BOOST_PP_ITERATION_5 135 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 136 && BOOST_PP_ITERATION_FINISH_5 >= 136 # define BOOST_PP_ITERATION_5 136 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 137 && BOOST_PP_ITERATION_FINISH_5 >= 137 # define BOOST_PP_ITERATION_5 137 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 138 && BOOST_PP_ITERATION_FINISH_5 >= 138 # define BOOST_PP_ITERATION_5 138 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 139 && BOOST_PP_ITERATION_FINISH_5 >= 139 # define BOOST_PP_ITERATION_5 139 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 140 && BOOST_PP_ITERATION_FINISH_5 >= 140 # define BOOST_PP_ITERATION_5 140 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 141 && BOOST_PP_ITERATION_FINISH_5 >= 141 # define BOOST_PP_ITERATION_5 141 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 142 && BOOST_PP_ITERATION_FINISH_5 >= 142 # define BOOST_PP_ITERATION_5 142 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 143 && BOOST_PP_ITERATION_FINISH_5 >= 143 # define BOOST_PP_ITERATION_5 143 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 144 && BOOST_PP_ITERATION_FINISH_5 >= 144 # define BOOST_PP_ITERATION_5 144 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 145 && BOOST_PP_ITERATION_FINISH_5 >= 145 # define BOOST_PP_ITERATION_5 145 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 146 && BOOST_PP_ITERATION_FINISH_5 >= 146 # define BOOST_PP_ITERATION_5 146 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 147 && BOOST_PP_ITERATION_FINISH_5 >= 147 # define BOOST_PP_ITERATION_5 147 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 148 && BOOST_PP_ITERATION_FINISH_5 >= 148 # define BOOST_PP_ITERATION_5 148 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 149 && BOOST_PP_ITERATION_FINISH_5 >= 149 # define BOOST_PP_ITERATION_5 149 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 150 && BOOST_PP_ITERATION_FINISH_5 >= 150 # define BOOST_PP_ITERATION_5 150 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 151 && BOOST_PP_ITERATION_FINISH_5 >= 151 # define BOOST_PP_ITERATION_5 151 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 152 && BOOST_PP_ITERATION_FINISH_5 >= 152 # define BOOST_PP_ITERATION_5 152 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 153 && BOOST_PP_ITERATION_FINISH_5 >= 153 # define BOOST_PP_ITERATION_5 153 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 154 && BOOST_PP_ITERATION_FINISH_5 >= 154 # define BOOST_PP_ITERATION_5 154 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 155 && BOOST_PP_ITERATION_FINISH_5 >= 155 # define BOOST_PP_ITERATION_5 155 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 156 && BOOST_PP_ITERATION_FINISH_5 >= 156 # define BOOST_PP_ITERATION_5 156 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 157 && BOOST_PP_ITERATION_FINISH_5 >= 157 # define BOOST_PP_ITERATION_5 157 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 158 && BOOST_PP_ITERATION_FINISH_5 >= 158 # define BOOST_PP_ITERATION_5 158 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 159 && BOOST_PP_ITERATION_FINISH_5 >= 159 # define BOOST_PP_ITERATION_5 159 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 160 && BOOST_PP_ITERATION_FINISH_5 >= 160 # define BOOST_PP_ITERATION_5 160 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 161 && BOOST_PP_ITERATION_FINISH_5 >= 161 # define BOOST_PP_ITERATION_5 161 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 162 && BOOST_PP_ITERATION_FINISH_5 >= 162 # define BOOST_PP_ITERATION_5 162 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 163 && BOOST_PP_ITERATION_FINISH_5 >= 163 # define BOOST_PP_ITERATION_5 163 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 164 && BOOST_PP_ITERATION_FINISH_5 >= 164 # define BOOST_PP_ITERATION_5 164 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 165 && BOOST_PP_ITERATION_FINISH_5 >= 165 # define BOOST_PP_ITERATION_5 165 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 166 && BOOST_PP_ITERATION_FINISH_5 >= 166 # define BOOST_PP_ITERATION_5 166 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 167 && BOOST_PP_ITERATION_FINISH_5 >= 167 # define BOOST_PP_ITERATION_5 167 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 168 && BOOST_PP_ITERATION_FINISH_5 >= 168 # define BOOST_PP_ITERATION_5 168 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 169 && BOOST_PP_ITERATION_FINISH_5 >= 169 # define BOOST_PP_ITERATION_5 169 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 170 && BOOST_PP_ITERATION_FINISH_5 >= 170 # define BOOST_PP_ITERATION_5 170 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 171 && BOOST_PP_ITERATION_FINISH_5 >= 171 # define BOOST_PP_ITERATION_5 171 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 172 && BOOST_PP_ITERATION_FINISH_5 >= 172 # define BOOST_PP_ITERATION_5 172 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 173 && BOOST_PP_ITERATION_FINISH_5 >= 173 # define BOOST_PP_ITERATION_5 173 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 174 && BOOST_PP_ITERATION_FINISH_5 >= 174 # define BOOST_PP_ITERATION_5 174 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 175 && BOOST_PP_ITERATION_FINISH_5 >= 175 # define BOOST_PP_ITERATION_5 175 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 176 && BOOST_PP_ITERATION_FINISH_5 >= 176 # define BOOST_PP_ITERATION_5 176 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 177 && BOOST_PP_ITERATION_FINISH_5 >= 177 # define BOOST_PP_ITERATION_5 177 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 178 && BOOST_PP_ITERATION_FINISH_5 >= 178 # define BOOST_PP_ITERATION_5 178 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 179 && BOOST_PP_ITERATION_FINISH_5 >= 179 # define BOOST_PP_ITERATION_5 179 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 180 && BOOST_PP_ITERATION_FINISH_5 >= 180 # define BOOST_PP_ITERATION_5 180 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 181 && BOOST_PP_ITERATION_FINISH_5 >= 181 # define BOOST_PP_ITERATION_5 181 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 182 && BOOST_PP_ITERATION_FINISH_5 >= 182 # define BOOST_PP_ITERATION_5 182 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 183 && BOOST_PP_ITERATION_FINISH_5 >= 183 # define BOOST_PP_ITERATION_5 183 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 184 && BOOST_PP_ITERATION_FINISH_5 >= 184 # define BOOST_PP_ITERATION_5 184 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 185 && BOOST_PP_ITERATION_FINISH_5 >= 185 # define BOOST_PP_ITERATION_5 185 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 186 && BOOST_PP_ITERATION_FINISH_5 >= 186 # define BOOST_PP_ITERATION_5 186 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 187 && BOOST_PP_ITERATION_FINISH_5 >= 187 # define BOOST_PP_ITERATION_5 187 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 188 && BOOST_PP_ITERATION_FINISH_5 >= 188 # define BOOST_PP_ITERATION_5 188 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 189 && BOOST_PP_ITERATION_FINISH_5 >= 189 # define BOOST_PP_ITERATION_5 189 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 190 && BOOST_PP_ITERATION_FINISH_5 >= 190 # define BOOST_PP_ITERATION_5 190 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 191 && BOOST_PP_ITERATION_FINISH_5 >= 191 # define BOOST_PP_ITERATION_5 191 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 192 && BOOST_PP_ITERATION_FINISH_5 >= 192 # define BOOST_PP_ITERATION_5 192 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 193 && BOOST_PP_ITERATION_FINISH_5 >= 193 # define BOOST_PP_ITERATION_5 193 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 194 && BOOST_PP_ITERATION_FINISH_5 >= 194 # define BOOST_PP_ITERATION_5 194 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 195 && BOOST_PP_ITERATION_FINISH_5 >= 195 # define BOOST_PP_ITERATION_5 195 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 196 && BOOST_PP_ITERATION_FINISH_5 >= 196 # define BOOST_PP_ITERATION_5 196 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 197 && BOOST_PP_ITERATION_FINISH_5 >= 197 # define BOOST_PP_ITERATION_5 197 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 198 && BOOST_PP_ITERATION_FINISH_5 >= 198 # define BOOST_PP_ITERATION_5 198 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 199 && BOOST_PP_ITERATION_FINISH_5 >= 199 # define BOOST_PP_ITERATION_5 199 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 200 && BOOST_PP_ITERATION_FINISH_5 >= 200 # define BOOST_PP_ITERATION_5 200 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 201 && BOOST_PP_ITERATION_FINISH_5 >= 201 # define BOOST_PP_ITERATION_5 201 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 202 && BOOST_PP_ITERATION_FINISH_5 >= 202 # define BOOST_PP_ITERATION_5 202 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 203 && BOOST_PP_ITERATION_FINISH_5 >= 203 # define BOOST_PP_ITERATION_5 203 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 204 && BOOST_PP_ITERATION_FINISH_5 >= 204 # define BOOST_PP_ITERATION_5 204 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 205 && BOOST_PP_ITERATION_FINISH_5 >= 205 # define BOOST_PP_ITERATION_5 205 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 206 && BOOST_PP_ITERATION_FINISH_5 >= 206 # define BOOST_PP_ITERATION_5 206 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 207 && BOOST_PP_ITERATION_FINISH_5 >= 207 # define BOOST_PP_ITERATION_5 207 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 208 && BOOST_PP_ITERATION_FINISH_5 >= 208 # define BOOST_PP_ITERATION_5 208 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 209 && BOOST_PP_ITERATION_FINISH_5 >= 209 # define BOOST_PP_ITERATION_5 209 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 210 && BOOST_PP_ITERATION_FINISH_5 >= 210 # define BOOST_PP_ITERATION_5 210 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 211 && BOOST_PP_ITERATION_FINISH_5 >= 211 # define BOOST_PP_ITERATION_5 211 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 212 && BOOST_PP_ITERATION_FINISH_5 >= 212 # define BOOST_PP_ITERATION_5 212 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 213 && BOOST_PP_ITERATION_FINISH_5 >= 213 # define BOOST_PP_ITERATION_5 213 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 214 && BOOST_PP_ITERATION_FINISH_5 >= 214 # define BOOST_PP_ITERATION_5 214 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 215 && BOOST_PP_ITERATION_FINISH_5 >= 215 # define BOOST_PP_ITERATION_5 215 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 216 && BOOST_PP_ITERATION_FINISH_5 >= 216 # define BOOST_PP_ITERATION_5 216 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 217 && BOOST_PP_ITERATION_FINISH_5 >= 217 # define BOOST_PP_ITERATION_5 217 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 218 && BOOST_PP_ITERATION_FINISH_5 >= 218 # define BOOST_PP_ITERATION_5 218 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 219 && BOOST_PP_ITERATION_FINISH_5 >= 219 # define BOOST_PP_ITERATION_5 219 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 220 && BOOST_PP_ITERATION_FINISH_5 >= 220 # define BOOST_PP_ITERATION_5 220 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 221 && BOOST_PP_ITERATION_FINISH_5 >= 221 # define BOOST_PP_ITERATION_5 221 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 222 && BOOST_PP_ITERATION_FINISH_5 >= 222 # define BOOST_PP_ITERATION_5 222 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 223 && BOOST_PP_ITERATION_FINISH_5 >= 223 # define BOOST_PP_ITERATION_5 223 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 224 && BOOST_PP_ITERATION_FINISH_5 >= 224 # define BOOST_PP_ITERATION_5 224 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 225 && BOOST_PP_ITERATION_FINISH_5 >= 225 # define BOOST_PP_ITERATION_5 225 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 226 && BOOST_PP_ITERATION_FINISH_5 >= 226 # define BOOST_PP_ITERATION_5 226 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 227 && BOOST_PP_ITERATION_FINISH_5 >= 227 # define BOOST_PP_ITERATION_5 227 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 228 && BOOST_PP_ITERATION_FINISH_5 >= 228 # define BOOST_PP_ITERATION_5 228 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 229 && BOOST_PP_ITERATION_FINISH_5 >= 229 # define BOOST_PP_ITERATION_5 229 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 230 && BOOST_PP_ITERATION_FINISH_5 >= 230 # define BOOST_PP_ITERATION_5 230 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 231 && BOOST_PP_ITERATION_FINISH_5 >= 231 # define BOOST_PP_ITERATION_5 231 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 232 && BOOST_PP_ITERATION_FINISH_5 >= 232 # define BOOST_PP_ITERATION_5 232 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 233 && BOOST_PP_ITERATION_FINISH_5 >= 233 # define BOOST_PP_ITERATION_5 233 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 234 && BOOST_PP_ITERATION_FINISH_5 >= 234 # define BOOST_PP_ITERATION_5 234 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 235 && BOOST_PP_ITERATION_FINISH_5 >= 235 # define BOOST_PP_ITERATION_5 235 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 236 && BOOST_PP_ITERATION_FINISH_5 >= 236 # define BOOST_PP_ITERATION_5 236 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 237 && BOOST_PP_ITERATION_FINISH_5 >= 237 # define BOOST_PP_ITERATION_5 237 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 238 && BOOST_PP_ITERATION_FINISH_5 >= 238 # define BOOST_PP_ITERATION_5 238 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 239 && BOOST_PP_ITERATION_FINISH_5 >= 239 # define BOOST_PP_ITERATION_5 239 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 240 && BOOST_PP_ITERATION_FINISH_5 >= 240 # define BOOST_PP_ITERATION_5 240 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 241 && BOOST_PP_ITERATION_FINISH_5 >= 241 # define BOOST_PP_ITERATION_5 241 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 242 && BOOST_PP_ITERATION_FINISH_5 >= 242 # define BOOST_PP_ITERATION_5 242 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 243 && BOOST_PP_ITERATION_FINISH_5 >= 243 # define BOOST_PP_ITERATION_5 243 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 244 && BOOST_PP_ITERATION_FINISH_5 >= 244 # define BOOST_PP_ITERATION_5 244 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 245 && BOOST_PP_ITERATION_FINISH_5 >= 245 # define BOOST_PP_ITERATION_5 245 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 246 && BOOST_PP_ITERATION_FINISH_5 >= 246 # define BOOST_PP_ITERATION_5 246 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 247 && BOOST_PP_ITERATION_FINISH_5 >= 247 # define BOOST_PP_ITERATION_5 247 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 248 && BOOST_PP_ITERATION_FINISH_5 >= 248 # define BOOST_PP_ITERATION_5 248 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 249 && BOOST_PP_ITERATION_FINISH_5 >= 249 # define BOOST_PP_ITERATION_5 249 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 250 && BOOST_PP_ITERATION_FINISH_5 >= 250 # define BOOST_PP_ITERATION_5 250 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 251 && BOOST_PP_ITERATION_FINISH_5 >= 251 # define BOOST_PP_ITERATION_5 251 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 252 && BOOST_PP_ITERATION_FINISH_5 >= 252 # define BOOST_PP_ITERATION_5 252 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 253 && BOOST_PP_ITERATION_FINISH_5 >= 253 # define BOOST_PP_ITERATION_5 253 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 254 && BOOST_PP_ITERATION_FINISH_5 >= 254 # define BOOST_PP_ITERATION_5 254 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 255 && BOOST_PP_ITERATION_FINISH_5 >= 255 # define BOOST_PP_ITERATION_5 255 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # if BOOST_PP_ITERATION_START_5 <= 256 && BOOST_PP_ITERATION_FINISH_5 >= 256 # define BOOST_PP_ITERATION_5 256 # include BOOST_PP_FILENAME_5 # undef BOOST_PP_ITERATION_5 # endif # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 4 # # undef BOOST_PP_ITERATION_START_5 # undef BOOST_PP_ITERATION_FINISH_5 # undef BOOST_PP_FILENAME_5 # # undef BOOST_PP_ITERATION_FLAGS_5 # undef BOOST_PP_ITERATION_PARAMS_5 ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/forward1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000015276211344301502031750 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if defined(BOOST_PP_ITERATION_LIMITS) # if !defined(BOOST_PP_FILENAME_1) # error BOOST_PP_ERROR: depth #1 filename is not defined # endif # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_ITERATION_FLAGS_1 0 # undef BOOST_PP_ITERATION_LIMITS # elif defined(BOOST_PP_ITERATION_PARAMS_1) # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_1) # include # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_1) # include # define BOOST_PP_FILENAME_1 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_1) # if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_1) >= 4 # define BOOST_PP_ITERATION_FLAGS_1 BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_1) # else # define BOOST_PP_ITERATION_FLAGS_1 0 # endif # else # error BOOST_PP_ERROR: depth #1 iteration boundaries or filename not defined # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 1 # # define BOOST_PP_IS_ITERATING 1 # # if (BOOST_PP_ITERATION_START_1) > (BOOST_PP_ITERATION_FINISH_1) # include # else # if BOOST_PP_ITERATION_START_1 <= 0 && BOOST_PP_ITERATION_FINISH_1 >= 0 # define BOOST_PP_ITERATION_1 0 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 1 && BOOST_PP_ITERATION_FINISH_1 >= 1 # define BOOST_PP_ITERATION_1 1 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 2 && BOOST_PP_ITERATION_FINISH_1 >= 2 # define BOOST_PP_ITERATION_1 2 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 3 && BOOST_PP_ITERATION_FINISH_1 >= 3 # define BOOST_PP_ITERATION_1 3 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 4 && BOOST_PP_ITERATION_FINISH_1 >= 4 # define BOOST_PP_ITERATION_1 4 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 5 && BOOST_PP_ITERATION_FINISH_1 >= 5 # define BOOST_PP_ITERATION_1 5 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 6 && BOOST_PP_ITERATION_FINISH_1 >= 6 # define BOOST_PP_ITERATION_1 6 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 7 && BOOST_PP_ITERATION_FINISH_1 >= 7 # define BOOST_PP_ITERATION_1 7 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 8 && BOOST_PP_ITERATION_FINISH_1 >= 8 # define BOOST_PP_ITERATION_1 8 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 9 && BOOST_PP_ITERATION_FINISH_1 >= 9 # define BOOST_PP_ITERATION_1 9 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 10 && BOOST_PP_ITERATION_FINISH_1 >= 10 # define BOOST_PP_ITERATION_1 10 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 11 && BOOST_PP_ITERATION_FINISH_1 >= 11 # define BOOST_PP_ITERATION_1 11 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 12 && BOOST_PP_ITERATION_FINISH_1 >= 12 # define BOOST_PP_ITERATION_1 12 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 13 && BOOST_PP_ITERATION_FINISH_1 >= 13 # define BOOST_PP_ITERATION_1 13 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 14 && BOOST_PP_ITERATION_FINISH_1 >= 14 # define BOOST_PP_ITERATION_1 14 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 15 && BOOST_PP_ITERATION_FINISH_1 >= 15 # define BOOST_PP_ITERATION_1 15 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 16 && BOOST_PP_ITERATION_FINISH_1 >= 16 # define BOOST_PP_ITERATION_1 16 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 17 && BOOST_PP_ITERATION_FINISH_1 >= 17 # define BOOST_PP_ITERATION_1 17 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 18 && BOOST_PP_ITERATION_FINISH_1 >= 18 # define BOOST_PP_ITERATION_1 18 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 19 && BOOST_PP_ITERATION_FINISH_1 >= 19 # define BOOST_PP_ITERATION_1 19 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 20 && BOOST_PP_ITERATION_FINISH_1 >= 20 # define BOOST_PP_ITERATION_1 20 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 21 && BOOST_PP_ITERATION_FINISH_1 >= 21 # define BOOST_PP_ITERATION_1 21 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 22 && BOOST_PP_ITERATION_FINISH_1 >= 22 # define BOOST_PP_ITERATION_1 22 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 23 && BOOST_PP_ITERATION_FINISH_1 >= 23 # define BOOST_PP_ITERATION_1 23 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 24 && BOOST_PP_ITERATION_FINISH_1 >= 24 # define BOOST_PP_ITERATION_1 24 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 25 && BOOST_PP_ITERATION_FINISH_1 >= 25 # define BOOST_PP_ITERATION_1 25 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 26 && BOOST_PP_ITERATION_FINISH_1 >= 26 # define BOOST_PP_ITERATION_1 26 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 27 && BOOST_PP_ITERATION_FINISH_1 >= 27 # define BOOST_PP_ITERATION_1 27 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 28 && BOOST_PP_ITERATION_FINISH_1 >= 28 # define BOOST_PP_ITERATION_1 28 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 29 && BOOST_PP_ITERATION_FINISH_1 >= 29 # define BOOST_PP_ITERATION_1 29 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 30 && BOOST_PP_ITERATION_FINISH_1 >= 30 # define BOOST_PP_ITERATION_1 30 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 31 && BOOST_PP_ITERATION_FINISH_1 >= 31 # define BOOST_PP_ITERATION_1 31 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 32 && BOOST_PP_ITERATION_FINISH_1 >= 32 # define BOOST_PP_ITERATION_1 32 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 33 && BOOST_PP_ITERATION_FINISH_1 >= 33 # define BOOST_PP_ITERATION_1 33 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 34 && BOOST_PP_ITERATION_FINISH_1 >= 34 # define BOOST_PP_ITERATION_1 34 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 35 && BOOST_PP_ITERATION_FINISH_1 >= 35 # define BOOST_PP_ITERATION_1 35 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 36 && BOOST_PP_ITERATION_FINISH_1 >= 36 # define BOOST_PP_ITERATION_1 36 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 37 && BOOST_PP_ITERATION_FINISH_1 >= 37 # define BOOST_PP_ITERATION_1 37 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 38 && BOOST_PP_ITERATION_FINISH_1 >= 38 # define BOOST_PP_ITERATION_1 38 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 39 && BOOST_PP_ITERATION_FINISH_1 >= 39 # define BOOST_PP_ITERATION_1 39 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 40 && BOOST_PP_ITERATION_FINISH_1 >= 40 # define BOOST_PP_ITERATION_1 40 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 41 && BOOST_PP_ITERATION_FINISH_1 >= 41 # define BOOST_PP_ITERATION_1 41 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 42 && BOOST_PP_ITERATION_FINISH_1 >= 42 # define BOOST_PP_ITERATION_1 42 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 43 && BOOST_PP_ITERATION_FINISH_1 >= 43 # define BOOST_PP_ITERATION_1 43 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 44 && BOOST_PP_ITERATION_FINISH_1 >= 44 # define BOOST_PP_ITERATION_1 44 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 45 && BOOST_PP_ITERATION_FINISH_1 >= 45 # define BOOST_PP_ITERATION_1 45 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 46 && BOOST_PP_ITERATION_FINISH_1 >= 46 # define BOOST_PP_ITERATION_1 46 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 47 && BOOST_PP_ITERATION_FINISH_1 >= 47 # define BOOST_PP_ITERATION_1 47 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 48 && BOOST_PP_ITERATION_FINISH_1 >= 48 # define BOOST_PP_ITERATION_1 48 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 49 && BOOST_PP_ITERATION_FINISH_1 >= 49 # define BOOST_PP_ITERATION_1 49 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 50 && BOOST_PP_ITERATION_FINISH_1 >= 50 # define BOOST_PP_ITERATION_1 50 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 51 && BOOST_PP_ITERATION_FINISH_1 >= 51 # define BOOST_PP_ITERATION_1 51 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 52 && BOOST_PP_ITERATION_FINISH_1 >= 52 # define BOOST_PP_ITERATION_1 52 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 53 && BOOST_PP_ITERATION_FINISH_1 >= 53 # define BOOST_PP_ITERATION_1 53 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 54 && BOOST_PP_ITERATION_FINISH_1 >= 54 # define BOOST_PP_ITERATION_1 54 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 55 && BOOST_PP_ITERATION_FINISH_1 >= 55 # define BOOST_PP_ITERATION_1 55 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 56 && BOOST_PP_ITERATION_FINISH_1 >= 56 # define BOOST_PP_ITERATION_1 56 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 57 && BOOST_PP_ITERATION_FINISH_1 >= 57 # define BOOST_PP_ITERATION_1 57 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 58 && BOOST_PP_ITERATION_FINISH_1 >= 58 # define BOOST_PP_ITERATION_1 58 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 59 && BOOST_PP_ITERATION_FINISH_1 >= 59 # define BOOST_PP_ITERATION_1 59 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 60 && BOOST_PP_ITERATION_FINISH_1 >= 60 # define BOOST_PP_ITERATION_1 60 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 61 && BOOST_PP_ITERATION_FINISH_1 >= 61 # define BOOST_PP_ITERATION_1 61 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 62 && BOOST_PP_ITERATION_FINISH_1 >= 62 # define BOOST_PP_ITERATION_1 62 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 63 && BOOST_PP_ITERATION_FINISH_1 >= 63 # define BOOST_PP_ITERATION_1 63 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 64 && BOOST_PP_ITERATION_FINISH_1 >= 64 # define BOOST_PP_ITERATION_1 64 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 65 && BOOST_PP_ITERATION_FINISH_1 >= 65 # define BOOST_PP_ITERATION_1 65 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 66 && BOOST_PP_ITERATION_FINISH_1 >= 66 # define BOOST_PP_ITERATION_1 66 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 67 && BOOST_PP_ITERATION_FINISH_1 >= 67 # define BOOST_PP_ITERATION_1 67 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 68 && BOOST_PP_ITERATION_FINISH_1 >= 68 # define BOOST_PP_ITERATION_1 68 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 69 && BOOST_PP_ITERATION_FINISH_1 >= 69 # define BOOST_PP_ITERATION_1 69 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 70 && BOOST_PP_ITERATION_FINISH_1 >= 70 # define BOOST_PP_ITERATION_1 70 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 71 && BOOST_PP_ITERATION_FINISH_1 >= 71 # define BOOST_PP_ITERATION_1 71 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 72 && BOOST_PP_ITERATION_FINISH_1 >= 72 # define BOOST_PP_ITERATION_1 72 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 73 && BOOST_PP_ITERATION_FINISH_1 >= 73 # define BOOST_PP_ITERATION_1 73 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 74 && BOOST_PP_ITERATION_FINISH_1 >= 74 # define BOOST_PP_ITERATION_1 74 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 75 && BOOST_PP_ITERATION_FINISH_1 >= 75 # define BOOST_PP_ITERATION_1 75 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 76 && BOOST_PP_ITERATION_FINISH_1 >= 76 # define BOOST_PP_ITERATION_1 76 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 77 && BOOST_PP_ITERATION_FINISH_1 >= 77 # define BOOST_PP_ITERATION_1 77 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 78 && BOOST_PP_ITERATION_FINISH_1 >= 78 # define BOOST_PP_ITERATION_1 78 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 79 && BOOST_PP_ITERATION_FINISH_1 >= 79 # define BOOST_PP_ITERATION_1 79 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 80 && BOOST_PP_ITERATION_FINISH_1 >= 80 # define BOOST_PP_ITERATION_1 80 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 81 && BOOST_PP_ITERATION_FINISH_1 >= 81 # define BOOST_PP_ITERATION_1 81 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 82 && BOOST_PP_ITERATION_FINISH_1 >= 82 # define BOOST_PP_ITERATION_1 82 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 83 && BOOST_PP_ITERATION_FINISH_1 >= 83 # define BOOST_PP_ITERATION_1 83 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 84 && BOOST_PP_ITERATION_FINISH_1 >= 84 # define BOOST_PP_ITERATION_1 84 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 85 && BOOST_PP_ITERATION_FINISH_1 >= 85 # define BOOST_PP_ITERATION_1 85 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 86 && BOOST_PP_ITERATION_FINISH_1 >= 86 # define BOOST_PP_ITERATION_1 86 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 87 && BOOST_PP_ITERATION_FINISH_1 >= 87 # define BOOST_PP_ITERATION_1 87 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 88 && BOOST_PP_ITERATION_FINISH_1 >= 88 # define BOOST_PP_ITERATION_1 88 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 89 && BOOST_PP_ITERATION_FINISH_1 >= 89 # define BOOST_PP_ITERATION_1 89 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 90 && BOOST_PP_ITERATION_FINISH_1 >= 90 # define BOOST_PP_ITERATION_1 90 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 91 && BOOST_PP_ITERATION_FINISH_1 >= 91 # define BOOST_PP_ITERATION_1 91 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 92 && BOOST_PP_ITERATION_FINISH_1 >= 92 # define BOOST_PP_ITERATION_1 92 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 93 && BOOST_PP_ITERATION_FINISH_1 >= 93 # define BOOST_PP_ITERATION_1 93 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 94 && BOOST_PP_ITERATION_FINISH_1 >= 94 # define BOOST_PP_ITERATION_1 94 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 95 && BOOST_PP_ITERATION_FINISH_1 >= 95 # define BOOST_PP_ITERATION_1 95 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 96 && BOOST_PP_ITERATION_FINISH_1 >= 96 # define BOOST_PP_ITERATION_1 96 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 97 && BOOST_PP_ITERATION_FINISH_1 >= 97 # define BOOST_PP_ITERATION_1 97 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 98 && BOOST_PP_ITERATION_FINISH_1 >= 98 # define BOOST_PP_ITERATION_1 98 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 99 && BOOST_PP_ITERATION_FINISH_1 >= 99 # define BOOST_PP_ITERATION_1 99 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 100 && BOOST_PP_ITERATION_FINISH_1 >= 100 # define BOOST_PP_ITERATION_1 100 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 101 && BOOST_PP_ITERATION_FINISH_1 >= 101 # define BOOST_PP_ITERATION_1 101 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 102 && BOOST_PP_ITERATION_FINISH_1 >= 102 # define BOOST_PP_ITERATION_1 102 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 103 && BOOST_PP_ITERATION_FINISH_1 >= 103 # define BOOST_PP_ITERATION_1 103 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 104 && BOOST_PP_ITERATION_FINISH_1 >= 104 # define BOOST_PP_ITERATION_1 104 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 105 && BOOST_PP_ITERATION_FINISH_1 >= 105 # define BOOST_PP_ITERATION_1 105 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 106 && BOOST_PP_ITERATION_FINISH_1 >= 106 # define BOOST_PP_ITERATION_1 106 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 107 && BOOST_PP_ITERATION_FINISH_1 >= 107 # define BOOST_PP_ITERATION_1 107 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 108 && BOOST_PP_ITERATION_FINISH_1 >= 108 # define BOOST_PP_ITERATION_1 108 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 109 && BOOST_PP_ITERATION_FINISH_1 >= 109 # define BOOST_PP_ITERATION_1 109 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 110 && BOOST_PP_ITERATION_FINISH_1 >= 110 # define BOOST_PP_ITERATION_1 110 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 111 && BOOST_PP_ITERATION_FINISH_1 >= 111 # define BOOST_PP_ITERATION_1 111 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 112 && BOOST_PP_ITERATION_FINISH_1 >= 112 # define BOOST_PP_ITERATION_1 112 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 113 && BOOST_PP_ITERATION_FINISH_1 >= 113 # define BOOST_PP_ITERATION_1 113 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 114 && BOOST_PP_ITERATION_FINISH_1 >= 114 # define BOOST_PP_ITERATION_1 114 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 115 && BOOST_PP_ITERATION_FINISH_1 >= 115 # define BOOST_PP_ITERATION_1 115 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 116 && BOOST_PP_ITERATION_FINISH_1 >= 116 # define BOOST_PP_ITERATION_1 116 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 117 && BOOST_PP_ITERATION_FINISH_1 >= 117 # define BOOST_PP_ITERATION_1 117 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 118 && BOOST_PP_ITERATION_FINISH_1 >= 118 # define BOOST_PP_ITERATION_1 118 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 119 && BOOST_PP_ITERATION_FINISH_1 >= 119 # define BOOST_PP_ITERATION_1 119 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 120 && BOOST_PP_ITERATION_FINISH_1 >= 120 # define BOOST_PP_ITERATION_1 120 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 121 && BOOST_PP_ITERATION_FINISH_1 >= 121 # define BOOST_PP_ITERATION_1 121 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 122 && BOOST_PP_ITERATION_FINISH_1 >= 122 # define BOOST_PP_ITERATION_1 122 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 123 && BOOST_PP_ITERATION_FINISH_1 >= 123 # define BOOST_PP_ITERATION_1 123 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 124 && BOOST_PP_ITERATION_FINISH_1 >= 124 # define BOOST_PP_ITERATION_1 124 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 125 && BOOST_PP_ITERATION_FINISH_1 >= 125 # define BOOST_PP_ITERATION_1 125 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 126 && BOOST_PP_ITERATION_FINISH_1 >= 126 # define BOOST_PP_ITERATION_1 126 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 127 && BOOST_PP_ITERATION_FINISH_1 >= 127 # define BOOST_PP_ITERATION_1 127 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 128 && BOOST_PP_ITERATION_FINISH_1 >= 128 # define BOOST_PP_ITERATION_1 128 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 129 && BOOST_PP_ITERATION_FINISH_1 >= 129 # define BOOST_PP_ITERATION_1 129 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 130 && BOOST_PP_ITERATION_FINISH_1 >= 130 # define BOOST_PP_ITERATION_1 130 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 131 && BOOST_PP_ITERATION_FINISH_1 >= 131 # define BOOST_PP_ITERATION_1 131 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 132 && BOOST_PP_ITERATION_FINISH_1 >= 132 # define BOOST_PP_ITERATION_1 132 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 133 && BOOST_PP_ITERATION_FINISH_1 >= 133 # define BOOST_PP_ITERATION_1 133 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 134 && BOOST_PP_ITERATION_FINISH_1 >= 134 # define BOOST_PP_ITERATION_1 134 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 135 && BOOST_PP_ITERATION_FINISH_1 >= 135 # define BOOST_PP_ITERATION_1 135 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 136 && BOOST_PP_ITERATION_FINISH_1 >= 136 # define BOOST_PP_ITERATION_1 136 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 137 && BOOST_PP_ITERATION_FINISH_1 >= 137 # define BOOST_PP_ITERATION_1 137 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 138 && BOOST_PP_ITERATION_FINISH_1 >= 138 # define BOOST_PP_ITERATION_1 138 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 139 && BOOST_PP_ITERATION_FINISH_1 >= 139 # define BOOST_PP_ITERATION_1 139 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 140 && BOOST_PP_ITERATION_FINISH_1 >= 140 # define BOOST_PP_ITERATION_1 140 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 141 && BOOST_PP_ITERATION_FINISH_1 >= 141 # define BOOST_PP_ITERATION_1 141 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 142 && BOOST_PP_ITERATION_FINISH_1 >= 142 # define BOOST_PP_ITERATION_1 142 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 143 && BOOST_PP_ITERATION_FINISH_1 >= 143 # define BOOST_PP_ITERATION_1 143 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 144 && BOOST_PP_ITERATION_FINISH_1 >= 144 # define BOOST_PP_ITERATION_1 144 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 145 && BOOST_PP_ITERATION_FINISH_1 >= 145 # define BOOST_PP_ITERATION_1 145 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 146 && BOOST_PP_ITERATION_FINISH_1 >= 146 # define BOOST_PP_ITERATION_1 146 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 147 && BOOST_PP_ITERATION_FINISH_1 >= 147 # define BOOST_PP_ITERATION_1 147 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 148 && BOOST_PP_ITERATION_FINISH_1 >= 148 # define BOOST_PP_ITERATION_1 148 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 149 && BOOST_PP_ITERATION_FINISH_1 >= 149 # define BOOST_PP_ITERATION_1 149 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 150 && BOOST_PP_ITERATION_FINISH_1 >= 150 # define BOOST_PP_ITERATION_1 150 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 151 && BOOST_PP_ITERATION_FINISH_1 >= 151 # define BOOST_PP_ITERATION_1 151 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 152 && BOOST_PP_ITERATION_FINISH_1 >= 152 # define BOOST_PP_ITERATION_1 152 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 153 && BOOST_PP_ITERATION_FINISH_1 >= 153 # define BOOST_PP_ITERATION_1 153 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 154 && BOOST_PP_ITERATION_FINISH_1 >= 154 # define BOOST_PP_ITERATION_1 154 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 155 && BOOST_PP_ITERATION_FINISH_1 >= 155 # define BOOST_PP_ITERATION_1 155 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 156 && BOOST_PP_ITERATION_FINISH_1 >= 156 # define BOOST_PP_ITERATION_1 156 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 157 && BOOST_PP_ITERATION_FINISH_1 >= 157 # define BOOST_PP_ITERATION_1 157 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 158 && BOOST_PP_ITERATION_FINISH_1 >= 158 # define BOOST_PP_ITERATION_1 158 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 159 && BOOST_PP_ITERATION_FINISH_1 >= 159 # define BOOST_PP_ITERATION_1 159 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 160 && BOOST_PP_ITERATION_FINISH_1 >= 160 # define BOOST_PP_ITERATION_1 160 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 161 && BOOST_PP_ITERATION_FINISH_1 >= 161 # define BOOST_PP_ITERATION_1 161 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 162 && BOOST_PP_ITERATION_FINISH_1 >= 162 # define BOOST_PP_ITERATION_1 162 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 163 && BOOST_PP_ITERATION_FINISH_1 >= 163 # define BOOST_PP_ITERATION_1 163 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 164 && BOOST_PP_ITERATION_FINISH_1 >= 164 # define BOOST_PP_ITERATION_1 164 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 165 && BOOST_PP_ITERATION_FINISH_1 >= 165 # define BOOST_PP_ITERATION_1 165 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 166 && BOOST_PP_ITERATION_FINISH_1 >= 166 # define BOOST_PP_ITERATION_1 166 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 167 && BOOST_PP_ITERATION_FINISH_1 >= 167 # define BOOST_PP_ITERATION_1 167 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 168 && BOOST_PP_ITERATION_FINISH_1 >= 168 # define BOOST_PP_ITERATION_1 168 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 169 && BOOST_PP_ITERATION_FINISH_1 >= 169 # define BOOST_PP_ITERATION_1 169 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 170 && BOOST_PP_ITERATION_FINISH_1 >= 170 # define BOOST_PP_ITERATION_1 170 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 171 && BOOST_PP_ITERATION_FINISH_1 >= 171 # define BOOST_PP_ITERATION_1 171 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 172 && BOOST_PP_ITERATION_FINISH_1 >= 172 # define BOOST_PP_ITERATION_1 172 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 173 && BOOST_PP_ITERATION_FINISH_1 >= 173 # define BOOST_PP_ITERATION_1 173 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 174 && BOOST_PP_ITERATION_FINISH_1 >= 174 # define BOOST_PP_ITERATION_1 174 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 175 && BOOST_PP_ITERATION_FINISH_1 >= 175 # define BOOST_PP_ITERATION_1 175 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 176 && BOOST_PP_ITERATION_FINISH_1 >= 176 # define BOOST_PP_ITERATION_1 176 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 177 && BOOST_PP_ITERATION_FINISH_1 >= 177 # define BOOST_PP_ITERATION_1 177 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 178 && BOOST_PP_ITERATION_FINISH_1 >= 178 # define BOOST_PP_ITERATION_1 178 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 179 && BOOST_PP_ITERATION_FINISH_1 >= 179 # define BOOST_PP_ITERATION_1 179 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 180 && BOOST_PP_ITERATION_FINISH_1 >= 180 # define BOOST_PP_ITERATION_1 180 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 181 && BOOST_PP_ITERATION_FINISH_1 >= 181 # define BOOST_PP_ITERATION_1 181 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 182 && BOOST_PP_ITERATION_FINISH_1 >= 182 # define BOOST_PP_ITERATION_1 182 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 183 && BOOST_PP_ITERATION_FINISH_1 >= 183 # define BOOST_PP_ITERATION_1 183 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 184 && BOOST_PP_ITERATION_FINISH_1 >= 184 # define BOOST_PP_ITERATION_1 184 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 185 && BOOST_PP_ITERATION_FINISH_1 >= 185 # define BOOST_PP_ITERATION_1 185 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 186 && BOOST_PP_ITERATION_FINISH_1 >= 186 # define BOOST_PP_ITERATION_1 186 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 187 && BOOST_PP_ITERATION_FINISH_1 >= 187 # define BOOST_PP_ITERATION_1 187 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 188 && BOOST_PP_ITERATION_FINISH_1 >= 188 # define BOOST_PP_ITERATION_1 188 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 189 && BOOST_PP_ITERATION_FINISH_1 >= 189 # define BOOST_PP_ITERATION_1 189 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 190 && BOOST_PP_ITERATION_FINISH_1 >= 190 # define BOOST_PP_ITERATION_1 190 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 191 && BOOST_PP_ITERATION_FINISH_1 >= 191 # define BOOST_PP_ITERATION_1 191 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 192 && BOOST_PP_ITERATION_FINISH_1 >= 192 # define BOOST_PP_ITERATION_1 192 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 193 && BOOST_PP_ITERATION_FINISH_1 >= 193 # define BOOST_PP_ITERATION_1 193 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 194 && BOOST_PP_ITERATION_FINISH_1 >= 194 # define BOOST_PP_ITERATION_1 194 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 195 && BOOST_PP_ITERATION_FINISH_1 >= 195 # define BOOST_PP_ITERATION_1 195 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 196 && BOOST_PP_ITERATION_FINISH_1 >= 196 # define BOOST_PP_ITERATION_1 196 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 197 && BOOST_PP_ITERATION_FINISH_1 >= 197 # define BOOST_PP_ITERATION_1 197 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 198 && BOOST_PP_ITERATION_FINISH_1 >= 198 # define BOOST_PP_ITERATION_1 198 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 199 && BOOST_PP_ITERATION_FINISH_1 >= 199 # define BOOST_PP_ITERATION_1 199 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 200 && BOOST_PP_ITERATION_FINISH_1 >= 200 # define BOOST_PP_ITERATION_1 200 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 201 && BOOST_PP_ITERATION_FINISH_1 >= 201 # define BOOST_PP_ITERATION_1 201 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 202 && BOOST_PP_ITERATION_FINISH_1 >= 202 # define BOOST_PP_ITERATION_1 202 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 203 && BOOST_PP_ITERATION_FINISH_1 >= 203 # define BOOST_PP_ITERATION_1 203 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 204 && BOOST_PP_ITERATION_FINISH_1 >= 204 # define BOOST_PP_ITERATION_1 204 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 205 && BOOST_PP_ITERATION_FINISH_1 >= 205 # define BOOST_PP_ITERATION_1 205 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 206 && BOOST_PP_ITERATION_FINISH_1 >= 206 # define BOOST_PP_ITERATION_1 206 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 207 && BOOST_PP_ITERATION_FINISH_1 >= 207 # define BOOST_PP_ITERATION_1 207 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 208 && BOOST_PP_ITERATION_FINISH_1 >= 208 # define BOOST_PP_ITERATION_1 208 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 209 && BOOST_PP_ITERATION_FINISH_1 >= 209 # define BOOST_PP_ITERATION_1 209 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 210 && BOOST_PP_ITERATION_FINISH_1 >= 210 # define BOOST_PP_ITERATION_1 210 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 211 && BOOST_PP_ITERATION_FINISH_1 >= 211 # define BOOST_PP_ITERATION_1 211 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 212 && BOOST_PP_ITERATION_FINISH_1 >= 212 # define BOOST_PP_ITERATION_1 212 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 213 && BOOST_PP_ITERATION_FINISH_1 >= 213 # define BOOST_PP_ITERATION_1 213 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 214 && BOOST_PP_ITERATION_FINISH_1 >= 214 # define BOOST_PP_ITERATION_1 214 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 215 && BOOST_PP_ITERATION_FINISH_1 >= 215 # define BOOST_PP_ITERATION_1 215 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 216 && BOOST_PP_ITERATION_FINISH_1 >= 216 # define BOOST_PP_ITERATION_1 216 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 217 && BOOST_PP_ITERATION_FINISH_1 >= 217 # define BOOST_PP_ITERATION_1 217 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 218 && BOOST_PP_ITERATION_FINISH_1 >= 218 # define BOOST_PP_ITERATION_1 218 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 219 && BOOST_PP_ITERATION_FINISH_1 >= 219 # define BOOST_PP_ITERATION_1 219 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 220 && BOOST_PP_ITERATION_FINISH_1 >= 220 # define BOOST_PP_ITERATION_1 220 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 221 && BOOST_PP_ITERATION_FINISH_1 >= 221 # define BOOST_PP_ITERATION_1 221 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 222 && BOOST_PP_ITERATION_FINISH_1 >= 222 # define BOOST_PP_ITERATION_1 222 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 223 && BOOST_PP_ITERATION_FINISH_1 >= 223 # define BOOST_PP_ITERATION_1 223 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 224 && BOOST_PP_ITERATION_FINISH_1 >= 224 # define BOOST_PP_ITERATION_1 224 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 225 && BOOST_PP_ITERATION_FINISH_1 >= 225 # define BOOST_PP_ITERATION_1 225 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 226 && BOOST_PP_ITERATION_FINISH_1 >= 226 # define BOOST_PP_ITERATION_1 226 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 227 && BOOST_PP_ITERATION_FINISH_1 >= 227 # define BOOST_PP_ITERATION_1 227 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 228 && BOOST_PP_ITERATION_FINISH_1 >= 228 # define BOOST_PP_ITERATION_1 228 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 229 && BOOST_PP_ITERATION_FINISH_1 >= 229 # define BOOST_PP_ITERATION_1 229 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 230 && BOOST_PP_ITERATION_FINISH_1 >= 230 # define BOOST_PP_ITERATION_1 230 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 231 && BOOST_PP_ITERATION_FINISH_1 >= 231 # define BOOST_PP_ITERATION_1 231 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 232 && BOOST_PP_ITERATION_FINISH_1 >= 232 # define BOOST_PP_ITERATION_1 232 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 233 && BOOST_PP_ITERATION_FINISH_1 >= 233 # define BOOST_PP_ITERATION_1 233 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 234 && BOOST_PP_ITERATION_FINISH_1 >= 234 # define BOOST_PP_ITERATION_1 234 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 235 && BOOST_PP_ITERATION_FINISH_1 >= 235 # define BOOST_PP_ITERATION_1 235 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 236 && BOOST_PP_ITERATION_FINISH_1 >= 236 # define BOOST_PP_ITERATION_1 236 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 237 && BOOST_PP_ITERATION_FINISH_1 >= 237 # define BOOST_PP_ITERATION_1 237 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 238 && BOOST_PP_ITERATION_FINISH_1 >= 238 # define BOOST_PP_ITERATION_1 238 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 239 && BOOST_PP_ITERATION_FINISH_1 >= 239 # define BOOST_PP_ITERATION_1 239 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 240 && BOOST_PP_ITERATION_FINISH_1 >= 240 # define BOOST_PP_ITERATION_1 240 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 241 && BOOST_PP_ITERATION_FINISH_1 >= 241 # define BOOST_PP_ITERATION_1 241 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 242 && BOOST_PP_ITERATION_FINISH_1 >= 242 # define BOOST_PP_ITERATION_1 242 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 243 && BOOST_PP_ITERATION_FINISH_1 >= 243 # define BOOST_PP_ITERATION_1 243 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 244 && BOOST_PP_ITERATION_FINISH_1 >= 244 # define BOOST_PP_ITERATION_1 244 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 245 && BOOST_PP_ITERATION_FINISH_1 >= 245 # define BOOST_PP_ITERATION_1 245 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 246 && BOOST_PP_ITERATION_FINISH_1 >= 246 # define BOOST_PP_ITERATION_1 246 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 247 && BOOST_PP_ITERATION_FINISH_1 >= 247 # define BOOST_PP_ITERATION_1 247 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 248 && BOOST_PP_ITERATION_FINISH_1 >= 248 # define BOOST_PP_ITERATION_1 248 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 249 && BOOST_PP_ITERATION_FINISH_1 >= 249 # define BOOST_PP_ITERATION_1 249 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 250 && BOOST_PP_ITERATION_FINISH_1 >= 250 # define BOOST_PP_ITERATION_1 250 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 251 && BOOST_PP_ITERATION_FINISH_1 >= 251 # define BOOST_PP_ITERATION_1 251 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 252 && BOOST_PP_ITERATION_FINISH_1 >= 252 # define BOOST_PP_ITERATION_1 252 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 253 && BOOST_PP_ITERATION_FINISH_1 >= 253 # define BOOST_PP_ITERATION_1 253 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 254 && BOOST_PP_ITERATION_FINISH_1 >= 254 # define BOOST_PP_ITERATION_1 254 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 255 && BOOST_PP_ITERATION_FINISH_1 >= 255 # define BOOST_PP_ITERATION_1 255 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_START_1 <= 256 && BOOST_PP_ITERATION_FINISH_1 >= 256 # define BOOST_PP_ITERATION_1 256 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # endif # # undef BOOST_PP_IS_ITERATING # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 0 # # undef BOOST_PP_ITERATION_START_1 # undef BOOST_PP_ITERATION_FINISH_1 # undef BOOST_PP_FILENAME_1 # # undef BOOST_PP_ITERATION_FLAGS_1 # undef BOOST_PP_ITERATION_PARAMS_1 ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/forward4.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000015265711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if defined(BOOST_PP_ITERATION_LIMITS) # if !defined(BOOST_PP_FILENAME_4) # error BOOST_PP_ERROR: depth #4 filename is not defined # endif # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_ITERATION_FLAGS_4 0 # undef BOOST_PP_ITERATION_LIMITS # elif defined(BOOST_PP_ITERATION_PARAMS_4) # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_4) # include # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_4) # include # define BOOST_PP_FILENAME_4 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_4) # if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_4) >= 4 # define BOOST_PP_ITERATION_FLAGS_4 BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_4) # else # define BOOST_PP_ITERATION_FLAGS_4 0 # endif # else # error BOOST_PP_ERROR: depth #4 iteration boundaries or filename not defined # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 4 # # if (BOOST_PP_ITERATION_START_4) > (BOOST_PP_ITERATION_FINISH_4) # include # else # if BOOST_PP_ITERATION_START_4 <= 0 && BOOST_PP_ITERATION_FINISH_4 >= 0 # define BOOST_PP_ITERATION_4 0 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 1 && BOOST_PP_ITERATION_FINISH_4 >= 1 # define BOOST_PP_ITERATION_4 1 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 2 && BOOST_PP_ITERATION_FINISH_4 >= 2 # define BOOST_PP_ITERATION_4 2 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 3 && BOOST_PP_ITERATION_FINISH_4 >= 3 # define BOOST_PP_ITERATION_4 3 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 4 && BOOST_PP_ITERATION_FINISH_4 >= 4 # define BOOST_PP_ITERATION_4 4 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 5 && BOOST_PP_ITERATION_FINISH_4 >= 5 # define BOOST_PP_ITERATION_4 5 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 6 && BOOST_PP_ITERATION_FINISH_4 >= 6 # define BOOST_PP_ITERATION_4 6 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 7 && BOOST_PP_ITERATION_FINISH_4 >= 7 # define BOOST_PP_ITERATION_4 7 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 8 && BOOST_PP_ITERATION_FINISH_4 >= 8 # define BOOST_PP_ITERATION_4 8 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 9 && BOOST_PP_ITERATION_FINISH_4 >= 9 # define BOOST_PP_ITERATION_4 9 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 10 && BOOST_PP_ITERATION_FINISH_4 >= 10 # define BOOST_PP_ITERATION_4 10 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 11 && BOOST_PP_ITERATION_FINISH_4 >= 11 # define BOOST_PP_ITERATION_4 11 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 12 && BOOST_PP_ITERATION_FINISH_4 >= 12 # define BOOST_PP_ITERATION_4 12 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 13 && BOOST_PP_ITERATION_FINISH_4 >= 13 # define BOOST_PP_ITERATION_4 13 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 14 && BOOST_PP_ITERATION_FINISH_4 >= 14 # define BOOST_PP_ITERATION_4 14 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 15 && BOOST_PP_ITERATION_FINISH_4 >= 15 # define BOOST_PP_ITERATION_4 15 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 16 && BOOST_PP_ITERATION_FINISH_4 >= 16 # define BOOST_PP_ITERATION_4 16 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 17 && BOOST_PP_ITERATION_FINISH_4 >= 17 # define BOOST_PP_ITERATION_4 17 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 18 && BOOST_PP_ITERATION_FINISH_4 >= 18 # define BOOST_PP_ITERATION_4 18 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 19 && BOOST_PP_ITERATION_FINISH_4 >= 19 # define BOOST_PP_ITERATION_4 19 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 20 && BOOST_PP_ITERATION_FINISH_4 >= 20 # define BOOST_PP_ITERATION_4 20 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 21 && BOOST_PP_ITERATION_FINISH_4 >= 21 # define BOOST_PP_ITERATION_4 21 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 22 && BOOST_PP_ITERATION_FINISH_4 >= 22 # define BOOST_PP_ITERATION_4 22 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 23 && BOOST_PP_ITERATION_FINISH_4 >= 23 # define BOOST_PP_ITERATION_4 23 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 24 && BOOST_PP_ITERATION_FINISH_4 >= 24 # define BOOST_PP_ITERATION_4 24 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 25 && BOOST_PP_ITERATION_FINISH_4 >= 25 # define BOOST_PP_ITERATION_4 25 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 26 && BOOST_PP_ITERATION_FINISH_4 >= 26 # define BOOST_PP_ITERATION_4 26 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 27 && BOOST_PP_ITERATION_FINISH_4 >= 27 # define BOOST_PP_ITERATION_4 27 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 28 && BOOST_PP_ITERATION_FINISH_4 >= 28 # define BOOST_PP_ITERATION_4 28 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 29 && BOOST_PP_ITERATION_FINISH_4 >= 29 # define BOOST_PP_ITERATION_4 29 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 30 && BOOST_PP_ITERATION_FINISH_4 >= 30 # define BOOST_PP_ITERATION_4 30 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 31 && BOOST_PP_ITERATION_FINISH_4 >= 31 # define BOOST_PP_ITERATION_4 31 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 32 && BOOST_PP_ITERATION_FINISH_4 >= 32 # define BOOST_PP_ITERATION_4 32 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 33 && BOOST_PP_ITERATION_FINISH_4 >= 33 # define BOOST_PP_ITERATION_4 33 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 34 && BOOST_PP_ITERATION_FINISH_4 >= 34 # define BOOST_PP_ITERATION_4 34 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 35 && BOOST_PP_ITERATION_FINISH_4 >= 35 # define BOOST_PP_ITERATION_4 35 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 36 && BOOST_PP_ITERATION_FINISH_4 >= 36 # define BOOST_PP_ITERATION_4 36 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 37 && BOOST_PP_ITERATION_FINISH_4 >= 37 # define BOOST_PP_ITERATION_4 37 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 38 && BOOST_PP_ITERATION_FINISH_4 >= 38 # define BOOST_PP_ITERATION_4 38 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 39 && BOOST_PP_ITERATION_FINISH_4 >= 39 # define BOOST_PP_ITERATION_4 39 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 40 && BOOST_PP_ITERATION_FINISH_4 >= 40 # define BOOST_PP_ITERATION_4 40 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 41 && BOOST_PP_ITERATION_FINISH_4 >= 41 # define BOOST_PP_ITERATION_4 41 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 42 && BOOST_PP_ITERATION_FINISH_4 >= 42 # define BOOST_PP_ITERATION_4 42 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 43 && BOOST_PP_ITERATION_FINISH_4 >= 43 # define BOOST_PP_ITERATION_4 43 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 44 && BOOST_PP_ITERATION_FINISH_4 >= 44 # define BOOST_PP_ITERATION_4 44 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 45 && BOOST_PP_ITERATION_FINISH_4 >= 45 # define BOOST_PP_ITERATION_4 45 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 46 && BOOST_PP_ITERATION_FINISH_4 >= 46 # define BOOST_PP_ITERATION_4 46 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 47 && BOOST_PP_ITERATION_FINISH_4 >= 47 # define BOOST_PP_ITERATION_4 47 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 48 && BOOST_PP_ITERATION_FINISH_4 >= 48 # define BOOST_PP_ITERATION_4 48 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 49 && BOOST_PP_ITERATION_FINISH_4 >= 49 # define BOOST_PP_ITERATION_4 49 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 50 && BOOST_PP_ITERATION_FINISH_4 >= 50 # define BOOST_PP_ITERATION_4 50 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 51 && BOOST_PP_ITERATION_FINISH_4 >= 51 # define BOOST_PP_ITERATION_4 51 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 52 && BOOST_PP_ITERATION_FINISH_4 >= 52 # define BOOST_PP_ITERATION_4 52 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 53 && BOOST_PP_ITERATION_FINISH_4 >= 53 # define BOOST_PP_ITERATION_4 53 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 54 && BOOST_PP_ITERATION_FINISH_4 >= 54 # define BOOST_PP_ITERATION_4 54 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 55 && BOOST_PP_ITERATION_FINISH_4 >= 55 # define BOOST_PP_ITERATION_4 55 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 56 && BOOST_PP_ITERATION_FINISH_4 >= 56 # define BOOST_PP_ITERATION_4 56 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 57 && BOOST_PP_ITERATION_FINISH_4 >= 57 # define BOOST_PP_ITERATION_4 57 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 58 && BOOST_PP_ITERATION_FINISH_4 >= 58 # define BOOST_PP_ITERATION_4 58 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 59 && BOOST_PP_ITERATION_FINISH_4 >= 59 # define BOOST_PP_ITERATION_4 59 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 60 && BOOST_PP_ITERATION_FINISH_4 >= 60 # define BOOST_PP_ITERATION_4 60 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 61 && BOOST_PP_ITERATION_FINISH_4 >= 61 # define BOOST_PP_ITERATION_4 61 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 62 && BOOST_PP_ITERATION_FINISH_4 >= 62 # define BOOST_PP_ITERATION_4 62 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 63 && BOOST_PP_ITERATION_FINISH_4 >= 63 # define BOOST_PP_ITERATION_4 63 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 64 && BOOST_PP_ITERATION_FINISH_4 >= 64 # define BOOST_PP_ITERATION_4 64 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 65 && BOOST_PP_ITERATION_FINISH_4 >= 65 # define BOOST_PP_ITERATION_4 65 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 66 && BOOST_PP_ITERATION_FINISH_4 >= 66 # define BOOST_PP_ITERATION_4 66 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 67 && BOOST_PP_ITERATION_FINISH_4 >= 67 # define BOOST_PP_ITERATION_4 67 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 68 && BOOST_PP_ITERATION_FINISH_4 >= 68 # define BOOST_PP_ITERATION_4 68 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 69 && BOOST_PP_ITERATION_FINISH_4 >= 69 # define BOOST_PP_ITERATION_4 69 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 70 && BOOST_PP_ITERATION_FINISH_4 >= 70 # define BOOST_PP_ITERATION_4 70 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 71 && BOOST_PP_ITERATION_FINISH_4 >= 71 # define BOOST_PP_ITERATION_4 71 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 72 && BOOST_PP_ITERATION_FINISH_4 >= 72 # define BOOST_PP_ITERATION_4 72 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 73 && BOOST_PP_ITERATION_FINISH_4 >= 73 # define BOOST_PP_ITERATION_4 73 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 74 && BOOST_PP_ITERATION_FINISH_4 >= 74 # define BOOST_PP_ITERATION_4 74 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 75 && BOOST_PP_ITERATION_FINISH_4 >= 75 # define BOOST_PP_ITERATION_4 75 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 76 && BOOST_PP_ITERATION_FINISH_4 >= 76 # define BOOST_PP_ITERATION_4 76 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 77 && BOOST_PP_ITERATION_FINISH_4 >= 77 # define BOOST_PP_ITERATION_4 77 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 78 && BOOST_PP_ITERATION_FINISH_4 >= 78 # define BOOST_PP_ITERATION_4 78 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 79 && BOOST_PP_ITERATION_FINISH_4 >= 79 # define BOOST_PP_ITERATION_4 79 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 80 && BOOST_PP_ITERATION_FINISH_4 >= 80 # define BOOST_PP_ITERATION_4 80 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 81 && BOOST_PP_ITERATION_FINISH_4 >= 81 # define BOOST_PP_ITERATION_4 81 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 82 && BOOST_PP_ITERATION_FINISH_4 >= 82 # define BOOST_PP_ITERATION_4 82 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 83 && BOOST_PP_ITERATION_FINISH_4 >= 83 # define BOOST_PP_ITERATION_4 83 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 84 && BOOST_PP_ITERATION_FINISH_4 >= 84 # define BOOST_PP_ITERATION_4 84 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 85 && BOOST_PP_ITERATION_FINISH_4 >= 85 # define BOOST_PP_ITERATION_4 85 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 86 && BOOST_PP_ITERATION_FINISH_4 >= 86 # define BOOST_PP_ITERATION_4 86 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 87 && BOOST_PP_ITERATION_FINISH_4 >= 87 # define BOOST_PP_ITERATION_4 87 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 88 && BOOST_PP_ITERATION_FINISH_4 >= 88 # define BOOST_PP_ITERATION_4 88 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 89 && BOOST_PP_ITERATION_FINISH_4 >= 89 # define BOOST_PP_ITERATION_4 89 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 90 && BOOST_PP_ITERATION_FINISH_4 >= 90 # define BOOST_PP_ITERATION_4 90 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 91 && BOOST_PP_ITERATION_FINISH_4 >= 91 # define BOOST_PP_ITERATION_4 91 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 92 && BOOST_PP_ITERATION_FINISH_4 >= 92 # define BOOST_PP_ITERATION_4 92 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 93 && BOOST_PP_ITERATION_FINISH_4 >= 93 # define BOOST_PP_ITERATION_4 93 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 94 && BOOST_PP_ITERATION_FINISH_4 >= 94 # define BOOST_PP_ITERATION_4 94 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 95 && BOOST_PP_ITERATION_FINISH_4 >= 95 # define BOOST_PP_ITERATION_4 95 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 96 && BOOST_PP_ITERATION_FINISH_4 >= 96 # define BOOST_PP_ITERATION_4 96 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 97 && BOOST_PP_ITERATION_FINISH_4 >= 97 # define BOOST_PP_ITERATION_4 97 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 98 && BOOST_PP_ITERATION_FINISH_4 >= 98 # define BOOST_PP_ITERATION_4 98 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 99 && BOOST_PP_ITERATION_FINISH_4 >= 99 # define BOOST_PP_ITERATION_4 99 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 100 && BOOST_PP_ITERATION_FINISH_4 >= 100 # define BOOST_PP_ITERATION_4 100 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 101 && BOOST_PP_ITERATION_FINISH_4 >= 101 # define BOOST_PP_ITERATION_4 101 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 102 && BOOST_PP_ITERATION_FINISH_4 >= 102 # define BOOST_PP_ITERATION_4 102 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 103 && BOOST_PP_ITERATION_FINISH_4 >= 103 # define BOOST_PP_ITERATION_4 103 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 104 && BOOST_PP_ITERATION_FINISH_4 >= 104 # define BOOST_PP_ITERATION_4 104 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 105 && BOOST_PP_ITERATION_FINISH_4 >= 105 # define BOOST_PP_ITERATION_4 105 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 106 && BOOST_PP_ITERATION_FINISH_4 >= 106 # define BOOST_PP_ITERATION_4 106 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 107 && BOOST_PP_ITERATION_FINISH_4 >= 107 # define BOOST_PP_ITERATION_4 107 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 108 && BOOST_PP_ITERATION_FINISH_4 >= 108 # define BOOST_PP_ITERATION_4 108 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 109 && BOOST_PP_ITERATION_FINISH_4 >= 109 # define BOOST_PP_ITERATION_4 109 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 110 && BOOST_PP_ITERATION_FINISH_4 >= 110 # define BOOST_PP_ITERATION_4 110 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 111 && BOOST_PP_ITERATION_FINISH_4 >= 111 # define BOOST_PP_ITERATION_4 111 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 112 && BOOST_PP_ITERATION_FINISH_4 >= 112 # define BOOST_PP_ITERATION_4 112 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 113 && BOOST_PP_ITERATION_FINISH_4 >= 113 # define BOOST_PP_ITERATION_4 113 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 114 && BOOST_PP_ITERATION_FINISH_4 >= 114 # define BOOST_PP_ITERATION_4 114 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 115 && BOOST_PP_ITERATION_FINISH_4 >= 115 # define BOOST_PP_ITERATION_4 115 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 116 && BOOST_PP_ITERATION_FINISH_4 >= 116 # define BOOST_PP_ITERATION_4 116 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 117 && BOOST_PP_ITERATION_FINISH_4 >= 117 # define BOOST_PP_ITERATION_4 117 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 118 && BOOST_PP_ITERATION_FINISH_4 >= 118 # define BOOST_PP_ITERATION_4 118 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 119 && BOOST_PP_ITERATION_FINISH_4 >= 119 # define BOOST_PP_ITERATION_4 119 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 120 && BOOST_PP_ITERATION_FINISH_4 >= 120 # define BOOST_PP_ITERATION_4 120 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 121 && BOOST_PP_ITERATION_FINISH_4 >= 121 # define BOOST_PP_ITERATION_4 121 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 122 && BOOST_PP_ITERATION_FINISH_4 >= 122 # define BOOST_PP_ITERATION_4 122 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 123 && BOOST_PP_ITERATION_FINISH_4 >= 123 # define BOOST_PP_ITERATION_4 123 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 124 && BOOST_PP_ITERATION_FINISH_4 >= 124 # define BOOST_PP_ITERATION_4 124 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 125 && BOOST_PP_ITERATION_FINISH_4 >= 125 # define BOOST_PP_ITERATION_4 125 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 126 && BOOST_PP_ITERATION_FINISH_4 >= 126 # define BOOST_PP_ITERATION_4 126 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 127 && BOOST_PP_ITERATION_FINISH_4 >= 127 # define BOOST_PP_ITERATION_4 127 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 128 && BOOST_PP_ITERATION_FINISH_4 >= 128 # define BOOST_PP_ITERATION_4 128 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 129 && BOOST_PP_ITERATION_FINISH_4 >= 129 # define BOOST_PP_ITERATION_4 129 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 130 && BOOST_PP_ITERATION_FINISH_4 >= 130 # define BOOST_PP_ITERATION_4 130 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 131 && BOOST_PP_ITERATION_FINISH_4 >= 131 # define BOOST_PP_ITERATION_4 131 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 132 && BOOST_PP_ITERATION_FINISH_4 >= 132 # define BOOST_PP_ITERATION_4 132 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 133 && BOOST_PP_ITERATION_FINISH_4 >= 133 # define BOOST_PP_ITERATION_4 133 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 134 && BOOST_PP_ITERATION_FINISH_4 >= 134 # define BOOST_PP_ITERATION_4 134 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 135 && BOOST_PP_ITERATION_FINISH_4 >= 135 # define BOOST_PP_ITERATION_4 135 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 136 && BOOST_PP_ITERATION_FINISH_4 >= 136 # define BOOST_PP_ITERATION_4 136 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 137 && BOOST_PP_ITERATION_FINISH_4 >= 137 # define BOOST_PP_ITERATION_4 137 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 138 && BOOST_PP_ITERATION_FINISH_4 >= 138 # define BOOST_PP_ITERATION_4 138 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 139 && BOOST_PP_ITERATION_FINISH_4 >= 139 # define BOOST_PP_ITERATION_4 139 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 140 && BOOST_PP_ITERATION_FINISH_4 >= 140 # define BOOST_PP_ITERATION_4 140 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 141 && BOOST_PP_ITERATION_FINISH_4 >= 141 # define BOOST_PP_ITERATION_4 141 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 142 && BOOST_PP_ITERATION_FINISH_4 >= 142 # define BOOST_PP_ITERATION_4 142 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 143 && BOOST_PP_ITERATION_FINISH_4 >= 143 # define BOOST_PP_ITERATION_4 143 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 144 && BOOST_PP_ITERATION_FINISH_4 >= 144 # define BOOST_PP_ITERATION_4 144 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 145 && BOOST_PP_ITERATION_FINISH_4 >= 145 # define BOOST_PP_ITERATION_4 145 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 146 && BOOST_PP_ITERATION_FINISH_4 >= 146 # define BOOST_PP_ITERATION_4 146 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 147 && BOOST_PP_ITERATION_FINISH_4 >= 147 # define BOOST_PP_ITERATION_4 147 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 148 && BOOST_PP_ITERATION_FINISH_4 >= 148 # define BOOST_PP_ITERATION_4 148 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 149 && BOOST_PP_ITERATION_FINISH_4 >= 149 # define BOOST_PP_ITERATION_4 149 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 150 && BOOST_PP_ITERATION_FINISH_4 >= 150 # define BOOST_PP_ITERATION_4 150 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 151 && BOOST_PP_ITERATION_FINISH_4 >= 151 # define BOOST_PP_ITERATION_4 151 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 152 && BOOST_PP_ITERATION_FINISH_4 >= 152 # define BOOST_PP_ITERATION_4 152 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 153 && BOOST_PP_ITERATION_FINISH_4 >= 153 # define BOOST_PP_ITERATION_4 153 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 154 && BOOST_PP_ITERATION_FINISH_4 >= 154 # define BOOST_PP_ITERATION_4 154 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 155 && BOOST_PP_ITERATION_FINISH_4 >= 155 # define BOOST_PP_ITERATION_4 155 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 156 && BOOST_PP_ITERATION_FINISH_4 >= 156 # define BOOST_PP_ITERATION_4 156 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 157 && BOOST_PP_ITERATION_FINISH_4 >= 157 # define BOOST_PP_ITERATION_4 157 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 158 && BOOST_PP_ITERATION_FINISH_4 >= 158 # define BOOST_PP_ITERATION_4 158 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 159 && BOOST_PP_ITERATION_FINISH_4 >= 159 # define BOOST_PP_ITERATION_4 159 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 160 && BOOST_PP_ITERATION_FINISH_4 >= 160 # define BOOST_PP_ITERATION_4 160 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 161 && BOOST_PP_ITERATION_FINISH_4 >= 161 # define BOOST_PP_ITERATION_4 161 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 162 && BOOST_PP_ITERATION_FINISH_4 >= 162 # define BOOST_PP_ITERATION_4 162 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 163 && BOOST_PP_ITERATION_FINISH_4 >= 163 # define BOOST_PP_ITERATION_4 163 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 164 && BOOST_PP_ITERATION_FINISH_4 >= 164 # define BOOST_PP_ITERATION_4 164 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 165 && BOOST_PP_ITERATION_FINISH_4 >= 165 # define BOOST_PP_ITERATION_4 165 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 166 && BOOST_PP_ITERATION_FINISH_4 >= 166 # define BOOST_PP_ITERATION_4 166 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 167 && BOOST_PP_ITERATION_FINISH_4 >= 167 # define BOOST_PP_ITERATION_4 167 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 168 && BOOST_PP_ITERATION_FINISH_4 >= 168 # define BOOST_PP_ITERATION_4 168 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 169 && BOOST_PP_ITERATION_FINISH_4 >= 169 # define BOOST_PP_ITERATION_4 169 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 170 && BOOST_PP_ITERATION_FINISH_4 >= 170 # define BOOST_PP_ITERATION_4 170 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 171 && BOOST_PP_ITERATION_FINISH_4 >= 171 # define BOOST_PP_ITERATION_4 171 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 172 && BOOST_PP_ITERATION_FINISH_4 >= 172 # define BOOST_PP_ITERATION_4 172 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 173 && BOOST_PP_ITERATION_FINISH_4 >= 173 # define BOOST_PP_ITERATION_4 173 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 174 && BOOST_PP_ITERATION_FINISH_4 >= 174 # define BOOST_PP_ITERATION_4 174 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 175 && BOOST_PP_ITERATION_FINISH_4 >= 175 # define BOOST_PP_ITERATION_4 175 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 176 && BOOST_PP_ITERATION_FINISH_4 >= 176 # define BOOST_PP_ITERATION_4 176 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 177 && BOOST_PP_ITERATION_FINISH_4 >= 177 # define BOOST_PP_ITERATION_4 177 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 178 && BOOST_PP_ITERATION_FINISH_4 >= 178 # define BOOST_PP_ITERATION_4 178 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 179 && BOOST_PP_ITERATION_FINISH_4 >= 179 # define BOOST_PP_ITERATION_4 179 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 180 && BOOST_PP_ITERATION_FINISH_4 >= 180 # define BOOST_PP_ITERATION_4 180 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 181 && BOOST_PP_ITERATION_FINISH_4 >= 181 # define BOOST_PP_ITERATION_4 181 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 182 && BOOST_PP_ITERATION_FINISH_4 >= 182 # define BOOST_PP_ITERATION_4 182 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 183 && BOOST_PP_ITERATION_FINISH_4 >= 183 # define BOOST_PP_ITERATION_4 183 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 184 && BOOST_PP_ITERATION_FINISH_4 >= 184 # define BOOST_PP_ITERATION_4 184 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 185 && BOOST_PP_ITERATION_FINISH_4 >= 185 # define BOOST_PP_ITERATION_4 185 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 186 && BOOST_PP_ITERATION_FINISH_4 >= 186 # define BOOST_PP_ITERATION_4 186 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 187 && BOOST_PP_ITERATION_FINISH_4 >= 187 # define BOOST_PP_ITERATION_4 187 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 188 && BOOST_PP_ITERATION_FINISH_4 >= 188 # define BOOST_PP_ITERATION_4 188 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 189 && BOOST_PP_ITERATION_FINISH_4 >= 189 # define BOOST_PP_ITERATION_4 189 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 190 && BOOST_PP_ITERATION_FINISH_4 >= 190 # define BOOST_PP_ITERATION_4 190 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 191 && BOOST_PP_ITERATION_FINISH_4 >= 191 # define BOOST_PP_ITERATION_4 191 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 192 && BOOST_PP_ITERATION_FINISH_4 >= 192 # define BOOST_PP_ITERATION_4 192 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 193 && BOOST_PP_ITERATION_FINISH_4 >= 193 # define BOOST_PP_ITERATION_4 193 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 194 && BOOST_PP_ITERATION_FINISH_4 >= 194 # define BOOST_PP_ITERATION_4 194 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 195 && BOOST_PP_ITERATION_FINISH_4 >= 195 # define BOOST_PP_ITERATION_4 195 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 196 && BOOST_PP_ITERATION_FINISH_4 >= 196 # define BOOST_PP_ITERATION_4 196 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 197 && BOOST_PP_ITERATION_FINISH_4 >= 197 # define BOOST_PP_ITERATION_4 197 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 198 && BOOST_PP_ITERATION_FINISH_4 >= 198 # define BOOST_PP_ITERATION_4 198 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 199 && BOOST_PP_ITERATION_FINISH_4 >= 199 # define BOOST_PP_ITERATION_4 199 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 200 && BOOST_PP_ITERATION_FINISH_4 >= 200 # define BOOST_PP_ITERATION_4 200 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 201 && BOOST_PP_ITERATION_FINISH_4 >= 201 # define BOOST_PP_ITERATION_4 201 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 202 && BOOST_PP_ITERATION_FINISH_4 >= 202 # define BOOST_PP_ITERATION_4 202 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 203 && BOOST_PP_ITERATION_FINISH_4 >= 203 # define BOOST_PP_ITERATION_4 203 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 204 && BOOST_PP_ITERATION_FINISH_4 >= 204 # define BOOST_PP_ITERATION_4 204 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 205 && BOOST_PP_ITERATION_FINISH_4 >= 205 # define BOOST_PP_ITERATION_4 205 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 206 && BOOST_PP_ITERATION_FINISH_4 >= 206 # define BOOST_PP_ITERATION_4 206 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 207 && BOOST_PP_ITERATION_FINISH_4 >= 207 # define BOOST_PP_ITERATION_4 207 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 208 && BOOST_PP_ITERATION_FINISH_4 >= 208 # define BOOST_PP_ITERATION_4 208 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 209 && BOOST_PP_ITERATION_FINISH_4 >= 209 # define BOOST_PP_ITERATION_4 209 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 210 && BOOST_PP_ITERATION_FINISH_4 >= 210 # define BOOST_PP_ITERATION_4 210 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 211 && BOOST_PP_ITERATION_FINISH_4 >= 211 # define BOOST_PP_ITERATION_4 211 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 212 && BOOST_PP_ITERATION_FINISH_4 >= 212 # define BOOST_PP_ITERATION_4 212 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 213 && BOOST_PP_ITERATION_FINISH_4 >= 213 # define BOOST_PP_ITERATION_4 213 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 214 && BOOST_PP_ITERATION_FINISH_4 >= 214 # define BOOST_PP_ITERATION_4 214 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 215 && BOOST_PP_ITERATION_FINISH_4 >= 215 # define BOOST_PP_ITERATION_4 215 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 216 && BOOST_PP_ITERATION_FINISH_4 >= 216 # define BOOST_PP_ITERATION_4 216 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 217 && BOOST_PP_ITERATION_FINISH_4 >= 217 # define BOOST_PP_ITERATION_4 217 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 218 && BOOST_PP_ITERATION_FINISH_4 >= 218 # define BOOST_PP_ITERATION_4 218 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 219 && BOOST_PP_ITERATION_FINISH_4 >= 219 # define BOOST_PP_ITERATION_4 219 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 220 && BOOST_PP_ITERATION_FINISH_4 >= 220 # define BOOST_PP_ITERATION_4 220 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 221 && BOOST_PP_ITERATION_FINISH_4 >= 221 # define BOOST_PP_ITERATION_4 221 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 222 && BOOST_PP_ITERATION_FINISH_4 >= 222 # define BOOST_PP_ITERATION_4 222 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 223 && BOOST_PP_ITERATION_FINISH_4 >= 223 # define BOOST_PP_ITERATION_4 223 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 224 && BOOST_PP_ITERATION_FINISH_4 >= 224 # define BOOST_PP_ITERATION_4 224 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 225 && BOOST_PP_ITERATION_FINISH_4 >= 225 # define BOOST_PP_ITERATION_4 225 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 226 && BOOST_PP_ITERATION_FINISH_4 >= 226 # define BOOST_PP_ITERATION_4 226 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 227 && BOOST_PP_ITERATION_FINISH_4 >= 227 # define BOOST_PP_ITERATION_4 227 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 228 && BOOST_PP_ITERATION_FINISH_4 >= 228 # define BOOST_PP_ITERATION_4 228 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 229 && BOOST_PP_ITERATION_FINISH_4 >= 229 # define BOOST_PP_ITERATION_4 229 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 230 && BOOST_PP_ITERATION_FINISH_4 >= 230 # define BOOST_PP_ITERATION_4 230 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 231 && BOOST_PP_ITERATION_FINISH_4 >= 231 # define BOOST_PP_ITERATION_4 231 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 232 && BOOST_PP_ITERATION_FINISH_4 >= 232 # define BOOST_PP_ITERATION_4 232 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 233 && BOOST_PP_ITERATION_FINISH_4 >= 233 # define BOOST_PP_ITERATION_4 233 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 234 && BOOST_PP_ITERATION_FINISH_4 >= 234 # define BOOST_PP_ITERATION_4 234 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 235 && BOOST_PP_ITERATION_FINISH_4 >= 235 # define BOOST_PP_ITERATION_4 235 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 236 && BOOST_PP_ITERATION_FINISH_4 >= 236 # define BOOST_PP_ITERATION_4 236 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 237 && BOOST_PP_ITERATION_FINISH_4 >= 237 # define BOOST_PP_ITERATION_4 237 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 238 && BOOST_PP_ITERATION_FINISH_4 >= 238 # define BOOST_PP_ITERATION_4 238 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 239 && BOOST_PP_ITERATION_FINISH_4 >= 239 # define BOOST_PP_ITERATION_4 239 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 240 && BOOST_PP_ITERATION_FINISH_4 >= 240 # define BOOST_PP_ITERATION_4 240 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 241 && BOOST_PP_ITERATION_FINISH_4 >= 241 # define BOOST_PP_ITERATION_4 241 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 242 && BOOST_PP_ITERATION_FINISH_4 >= 242 # define BOOST_PP_ITERATION_4 242 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 243 && BOOST_PP_ITERATION_FINISH_4 >= 243 # define BOOST_PP_ITERATION_4 243 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 244 && BOOST_PP_ITERATION_FINISH_4 >= 244 # define BOOST_PP_ITERATION_4 244 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 245 && BOOST_PP_ITERATION_FINISH_4 >= 245 # define BOOST_PP_ITERATION_4 245 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 246 && BOOST_PP_ITERATION_FINISH_4 >= 246 # define BOOST_PP_ITERATION_4 246 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 247 && BOOST_PP_ITERATION_FINISH_4 >= 247 # define BOOST_PP_ITERATION_4 247 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 248 && BOOST_PP_ITERATION_FINISH_4 >= 248 # define BOOST_PP_ITERATION_4 248 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 249 && BOOST_PP_ITERATION_FINISH_4 >= 249 # define BOOST_PP_ITERATION_4 249 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 250 && BOOST_PP_ITERATION_FINISH_4 >= 250 # define BOOST_PP_ITERATION_4 250 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 251 && BOOST_PP_ITERATION_FINISH_4 >= 251 # define BOOST_PP_ITERATION_4 251 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 252 && BOOST_PP_ITERATION_FINISH_4 >= 252 # define BOOST_PP_ITERATION_4 252 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 253 && BOOST_PP_ITERATION_FINISH_4 >= 253 # define BOOST_PP_ITERATION_4 253 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 254 && BOOST_PP_ITERATION_FINISH_4 >= 254 # define BOOST_PP_ITERATION_4 254 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 255 && BOOST_PP_ITERATION_FINISH_4 >= 255 # define BOOST_PP_ITERATION_4 255 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # if BOOST_PP_ITERATION_START_4 <= 256 && BOOST_PP_ITERATION_FINISH_4 >= 256 # define BOOST_PP_ITERATION_4 256 # include BOOST_PP_FILENAME_4 # undef BOOST_PP_ITERATION_4 # endif # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 3 # # undef BOOST_PP_ITERATION_START_4 # undef BOOST_PP_ITERATION_FINISH_4 # undef BOOST_PP_FILENAME_4 # # undef BOOST_PP_ITERATION_FLAGS_4 # undef BOOST_PP_ITERATION_PARAMS_4 ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/reverse3.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000013631311344301502031742 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if BOOST_PP_ITERATION_FINISH_3 <= 256 && BOOST_PP_ITERATION_START_3 >= 256 # define BOOST_PP_ITERATION_3 256 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 255 && BOOST_PP_ITERATION_START_3 >= 255 # define BOOST_PP_ITERATION_3 255 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 254 && BOOST_PP_ITERATION_START_3 >= 254 # define BOOST_PP_ITERATION_3 254 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 253 && BOOST_PP_ITERATION_START_3 >= 253 # define BOOST_PP_ITERATION_3 253 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 252 && BOOST_PP_ITERATION_START_3 >= 252 # define BOOST_PP_ITERATION_3 252 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 251 && BOOST_PP_ITERATION_START_3 >= 251 # define BOOST_PP_ITERATION_3 251 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 250 && BOOST_PP_ITERATION_START_3 >= 250 # define BOOST_PP_ITERATION_3 250 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 249 && BOOST_PP_ITERATION_START_3 >= 249 # define BOOST_PP_ITERATION_3 249 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 248 && BOOST_PP_ITERATION_START_3 >= 248 # define BOOST_PP_ITERATION_3 248 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 247 && BOOST_PP_ITERATION_START_3 >= 247 # define BOOST_PP_ITERATION_3 247 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 246 && BOOST_PP_ITERATION_START_3 >= 246 # define BOOST_PP_ITERATION_3 246 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 245 && BOOST_PP_ITERATION_START_3 >= 245 # define BOOST_PP_ITERATION_3 245 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 244 && BOOST_PP_ITERATION_START_3 >= 244 # define BOOST_PP_ITERATION_3 244 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 243 && BOOST_PP_ITERATION_START_3 >= 243 # define BOOST_PP_ITERATION_3 243 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 242 && BOOST_PP_ITERATION_START_3 >= 242 # define BOOST_PP_ITERATION_3 242 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 241 && BOOST_PP_ITERATION_START_3 >= 241 # define BOOST_PP_ITERATION_3 241 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 240 && BOOST_PP_ITERATION_START_3 >= 240 # define BOOST_PP_ITERATION_3 240 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 239 && BOOST_PP_ITERATION_START_3 >= 239 # define BOOST_PP_ITERATION_3 239 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 238 && BOOST_PP_ITERATION_START_3 >= 238 # define BOOST_PP_ITERATION_3 238 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 237 && BOOST_PP_ITERATION_START_3 >= 237 # define BOOST_PP_ITERATION_3 237 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 236 && BOOST_PP_ITERATION_START_3 >= 236 # define BOOST_PP_ITERATION_3 236 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 235 && BOOST_PP_ITERATION_START_3 >= 235 # define BOOST_PP_ITERATION_3 235 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 234 && BOOST_PP_ITERATION_START_3 >= 234 # define BOOST_PP_ITERATION_3 234 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 233 && BOOST_PP_ITERATION_START_3 >= 233 # define BOOST_PP_ITERATION_3 233 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 232 && BOOST_PP_ITERATION_START_3 >= 232 # define BOOST_PP_ITERATION_3 232 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 231 && BOOST_PP_ITERATION_START_3 >= 231 # define BOOST_PP_ITERATION_3 231 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 230 && BOOST_PP_ITERATION_START_3 >= 230 # define BOOST_PP_ITERATION_3 230 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 229 && BOOST_PP_ITERATION_START_3 >= 229 # define BOOST_PP_ITERATION_3 229 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 228 && BOOST_PP_ITERATION_START_3 >= 228 # define BOOST_PP_ITERATION_3 228 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 227 && BOOST_PP_ITERATION_START_3 >= 227 # define BOOST_PP_ITERATION_3 227 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 226 && BOOST_PP_ITERATION_START_3 >= 226 # define BOOST_PP_ITERATION_3 226 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 225 && BOOST_PP_ITERATION_START_3 >= 225 # define BOOST_PP_ITERATION_3 225 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 224 && BOOST_PP_ITERATION_START_3 >= 224 # define BOOST_PP_ITERATION_3 224 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 223 && BOOST_PP_ITERATION_START_3 >= 223 # define BOOST_PP_ITERATION_3 223 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 222 && BOOST_PP_ITERATION_START_3 >= 222 # define BOOST_PP_ITERATION_3 222 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 221 && BOOST_PP_ITERATION_START_3 >= 221 # define BOOST_PP_ITERATION_3 221 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 220 && BOOST_PP_ITERATION_START_3 >= 220 # define BOOST_PP_ITERATION_3 220 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 219 && BOOST_PP_ITERATION_START_3 >= 219 # define BOOST_PP_ITERATION_3 219 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 218 && BOOST_PP_ITERATION_START_3 >= 218 # define BOOST_PP_ITERATION_3 218 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 217 && BOOST_PP_ITERATION_START_3 >= 217 # define BOOST_PP_ITERATION_3 217 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 216 && BOOST_PP_ITERATION_START_3 >= 216 # define BOOST_PP_ITERATION_3 216 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 215 && BOOST_PP_ITERATION_START_3 >= 215 # define BOOST_PP_ITERATION_3 215 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 214 && BOOST_PP_ITERATION_START_3 >= 214 # define BOOST_PP_ITERATION_3 214 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 213 && BOOST_PP_ITERATION_START_3 >= 213 # define BOOST_PP_ITERATION_3 213 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 212 && BOOST_PP_ITERATION_START_3 >= 212 # define BOOST_PP_ITERATION_3 212 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 211 && BOOST_PP_ITERATION_START_3 >= 211 # define BOOST_PP_ITERATION_3 211 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 210 && BOOST_PP_ITERATION_START_3 >= 210 # define BOOST_PP_ITERATION_3 210 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 209 && BOOST_PP_ITERATION_START_3 >= 209 # define BOOST_PP_ITERATION_3 209 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 208 && BOOST_PP_ITERATION_START_3 >= 208 # define BOOST_PP_ITERATION_3 208 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 207 && BOOST_PP_ITERATION_START_3 >= 207 # define BOOST_PP_ITERATION_3 207 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 206 && BOOST_PP_ITERATION_START_3 >= 206 # define BOOST_PP_ITERATION_3 206 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 205 && BOOST_PP_ITERATION_START_3 >= 205 # define BOOST_PP_ITERATION_3 205 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 204 && BOOST_PP_ITERATION_START_3 >= 204 # define BOOST_PP_ITERATION_3 204 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 203 && BOOST_PP_ITERATION_START_3 >= 203 # define BOOST_PP_ITERATION_3 203 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 202 && BOOST_PP_ITERATION_START_3 >= 202 # define BOOST_PP_ITERATION_3 202 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 201 && BOOST_PP_ITERATION_START_3 >= 201 # define BOOST_PP_ITERATION_3 201 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 200 && BOOST_PP_ITERATION_START_3 >= 200 # define BOOST_PP_ITERATION_3 200 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 199 && BOOST_PP_ITERATION_START_3 >= 199 # define BOOST_PP_ITERATION_3 199 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 198 && BOOST_PP_ITERATION_START_3 >= 198 # define BOOST_PP_ITERATION_3 198 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 197 && BOOST_PP_ITERATION_START_3 >= 197 # define BOOST_PP_ITERATION_3 197 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 196 && BOOST_PP_ITERATION_START_3 >= 196 # define BOOST_PP_ITERATION_3 196 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 195 && BOOST_PP_ITERATION_START_3 >= 195 # define BOOST_PP_ITERATION_3 195 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 194 && BOOST_PP_ITERATION_START_3 >= 194 # define BOOST_PP_ITERATION_3 194 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 193 && BOOST_PP_ITERATION_START_3 >= 193 # define BOOST_PP_ITERATION_3 193 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 192 && BOOST_PP_ITERATION_START_3 >= 192 # define BOOST_PP_ITERATION_3 192 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 191 && BOOST_PP_ITERATION_START_3 >= 191 # define BOOST_PP_ITERATION_3 191 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 190 && BOOST_PP_ITERATION_START_3 >= 190 # define BOOST_PP_ITERATION_3 190 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 189 && BOOST_PP_ITERATION_START_3 >= 189 # define BOOST_PP_ITERATION_3 189 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 188 && BOOST_PP_ITERATION_START_3 >= 188 # define BOOST_PP_ITERATION_3 188 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 187 && BOOST_PP_ITERATION_START_3 >= 187 # define BOOST_PP_ITERATION_3 187 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 186 && BOOST_PP_ITERATION_START_3 >= 186 # define BOOST_PP_ITERATION_3 186 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 185 && BOOST_PP_ITERATION_START_3 >= 185 # define BOOST_PP_ITERATION_3 185 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 184 && BOOST_PP_ITERATION_START_3 >= 184 # define BOOST_PP_ITERATION_3 184 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 183 && BOOST_PP_ITERATION_START_3 >= 183 # define BOOST_PP_ITERATION_3 183 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 182 && BOOST_PP_ITERATION_START_3 >= 182 # define BOOST_PP_ITERATION_3 182 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 181 && BOOST_PP_ITERATION_START_3 >= 181 # define BOOST_PP_ITERATION_3 181 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 180 && BOOST_PP_ITERATION_START_3 >= 180 # define BOOST_PP_ITERATION_3 180 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 179 && BOOST_PP_ITERATION_START_3 >= 179 # define BOOST_PP_ITERATION_3 179 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 178 && BOOST_PP_ITERATION_START_3 >= 178 # define BOOST_PP_ITERATION_3 178 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 177 && BOOST_PP_ITERATION_START_3 >= 177 # define BOOST_PP_ITERATION_3 177 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 176 && BOOST_PP_ITERATION_START_3 >= 176 # define BOOST_PP_ITERATION_3 176 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 175 && BOOST_PP_ITERATION_START_3 >= 175 # define BOOST_PP_ITERATION_3 175 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 174 && BOOST_PP_ITERATION_START_3 >= 174 # define BOOST_PP_ITERATION_3 174 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 173 && BOOST_PP_ITERATION_START_3 >= 173 # define BOOST_PP_ITERATION_3 173 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 172 && BOOST_PP_ITERATION_START_3 >= 172 # define BOOST_PP_ITERATION_3 172 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 171 && BOOST_PP_ITERATION_START_3 >= 171 # define BOOST_PP_ITERATION_3 171 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 170 && BOOST_PP_ITERATION_START_3 >= 170 # define BOOST_PP_ITERATION_3 170 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 169 && BOOST_PP_ITERATION_START_3 >= 169 # define BOOST_PP_ITERATION_3 169 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 168 && BOOST_PP_ITERATION_START_3 >= 168 # define BOOST_PP_ITERATION_3 168 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 167 && BOOST_PP_ITERATION_START_3 >= 167 # define BOOST_PP_ITERATION_3 167 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 166 && BOOST_PP_ITERATION_START_3 >= 166 # define BOOST_PP_ITERATION_3 166 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 165 && BOOST_PP_ITERATION_START_3 >= 165 # define BOOST_PP_ITERATION_3 165 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 164 && BOOST_PP_ITERATION_START_3 >= 164 # define BOOST_PP_ITERATION_3 164 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 163 && BOOST_PP_ITERATION_START_3 >= 163 # define BOOST_PP_ITERATION_3 163 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 162 && BOOST_PP_ITERATION_START_3 >= 162 # define BOOST_PP_ITERATION_3 162 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 161 && BOOST_PP_ITERATION_START_3 >= 161 # define BOOST_PP_ITERATION_3 161 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 160 && BOOST_PP_ITERATION_START_3 >= 160 # define BOOST_PP_ITERATION_3 160 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 159 && BOOST_PP_ITERATION_START_3 >= 159 # define BOOST_PP_ITERATION_3 159 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 158 && BOOST_PP_ITERATION_START_3 >= 158 # define BOOST_PP_ITERATION_3 158 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 157 && BOOST_PP_ITERATION_START_3 >= 157 # define BOOST_PP_ITERATION_3 157 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 156 && BOOST_PP_ITERATION_START_3 >= 156 # define BOOST_PP_ITERATION_3 156 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 155 && BOOST_PP_ITERATION_START_3 >= 155 # define BOOST_PP_ITERATION_3 155 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 154 && BOOST_PP_ITERATION_START_3 >= 154 # define BOOST_PP_ITERATION_3 154 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 153 && BOOST_PP_ITERATION_START_3 >= 153 # define BOOST_PP_ITERATION_3 153 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 152 && BOOST_PP_ITERATION_START_3 >= 152 # define BOOST_PP_ITERATION_3 152 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 151 && BOOST_PP_ITERATION_START_3 >= 151 # define BOOST_PP_ITERATION_3 151 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 150 && BOOST_PP_ITERATION_START_3 >= 150 # define BOOST_PP_ITERATION_3 150 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 149 && BOOST_PP_ITERATION_START_3 >= 149 # define BOOST_PP_ITERATION_3 149 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 148 && BOOST_PP_ITERATION_START_3 >= 148 # define BOOST_PP_ITERATION_3 148 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 147 && BOOST_PP_ITERATION_START_3 >= 147 # define BOOST_PP_ITERATION_3 147 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 146 && BOOST_PP_ITERATION_START_3 >= 146 # define BOOST_PP_ITERATION_3 146 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 145 && BOOST_PP_ITERATION_START_3 >= 145 # define BOOST_PP_ITERATION_3 145 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 144 && BOOST_PP_ITERATION_START_3 >= 144 # define BOOST_PP_ITERATION_3 144 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 143 && BOOST_PP_ITERATION_START_3 >= 143 # define BOOST_PP_ITERATION_3 143 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 142 && BOOST_PP_ITERATION_START_3 >= 142 # define BOOST_PP_ITERATION_3 142 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 141 && BOOST_PP_ITERATION_START_3 >= 141 # define BOOST_PP_ITERATION_3 141 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 140 && BOOST_PP_ITERATION_START_3 >= 140 # define BOOST_PP_ITERATION_3 140 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 139 && BOOST_PP_ITERATION_START_3 >= 139 # define BOOST_PP_ITERATION_3 139 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 138 && BOOST_PP_ITERATION_START_3 >= 138 # define BOOST_PP_ITERATION_3 138 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 137 && BOOST_PP_ITERATION_START_3 >= 137 # define BOOST_PP_ITERATION_3 137 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 136 && BOOST_PP_ITERATION_START_3 >= 136 # define BOOST_PP_ITERATION_3 136 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 135 && BOOST_PP_ITERATION_START_3 >= 135 # define BOOST_PP_ITERATION_3 135 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 134 && BOOST_PP_ITERATION_START_3 >= 134 # define BOOST_PP_ITERATION_3 134 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 133 && BOOST_PP_ITERATION_START_3 >= 133 # define BOOST_PP_ITERATION_3 133 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 132 && BOOST_PP_ITERATION_START_3 >= 132 # define BOOST_PP_ITERATION_3 132 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 131 && BOOST_PP_ITERATION_START_3 >= 131 # define BOOST_PP_ITERATION_3 131 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 130 && BOOST_PP_ITERATION_START_3 >= 130 # define BOOST_PP_ITERATION_3 130 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 129 && BOOST_PP_ITERATION_START_3 >= 129 # define BOOST_PP_ITERATION_3 129 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 128 && BOOST_PP_ITERATION_START_3 >= 128 # define BOOST_PP_ITERATION_3 128 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 127 && BOOST_PP_ITERATION_START_3 >= 127 # define BOOST_PP_ITERATION_3 127 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 126 && BOOST_PP_ITERATION_START_3 >= 126 # define BOOST_PP_ITERATION_3 126 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 125 && BOOST_PP_ITERATION_START_3 >= 125 # define BOOST_PP_ITERATION_3 125 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 124 && BOOST_PP_ITERATION_START_3 >= 124 # define BOOST_PP_ITERATION_3 124 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 123 && BOOST_PP_ITERATION_START_3 >= 123 # define BOOST_PP_ITERATION_3 123 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 122 && BOOST_PP_ITERATION_START_3 >= 122 # define BOOST_PP_ITERATION_3 122 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 121 && BOOST_PP_ITERATION_START_3 >= 121 # define BOOST_PP_ITERATION_3 121 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 120 && BOOST_PP_ITERATION_START_3 >= 120 # define BOOST_PP_ITERATION_3 120 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 119 && BOOST_PP_ITERATION_START_3 >= 119 # define BOOST_PP_ITERATION_3 119 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 118 && BOOST_PP_ITERATION_START_3 >= 118 # define BOOST_PP_ITERATION_3 118 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 117 && BOOST_PP_ITERATION_START_3 >= 117 # define BOOST_PP_ITERATION_3 117 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 116 && BOOST_PP_ITERATION_START_3 >= 116 # define BOOST_PP_ITERATION_3 116 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 115 && BOOST_PP_ITERATION_START_3 >= 115 # define BOOST_PP_ITERATION_3 115 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 114 && BOOST_PP_ITERATION_START_3 >= 114 # define BOOST_PP_ITERATION_3 114 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 113 && BOOST_PP_ITERATION_START_3 >= 113 # define BOOST_PP_ITERATION_3 113 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 112 && BOOST_PP_ITERATION_START_3 >= 112 # define BOOST_PP_ITERATION_3 112 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 111 && BOOST_PP_ITERATION_START_3 >= 111 # define BOOST_PP_ITERATION_3 111 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 110 && BOOST_PP_ITERATION_START_3 >= 110 # define BOOST_PP_ITERATION_3 110 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 109 && BOOST_PP_ITERATION_START_3 >= 109 # define BOOST_PP_ITERATION_3 109 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 108 && BOOST_PP_ITERATION_START_3 >= 108 # define BOOST_PP_ITERATION_3 108 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 107 && BOOST_PP_ITERATION_START_3 >= 107 # define BOOST_PP_ITERATION_3 107 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 106 && BOOST_PP_ITERATION_START_3 >= 106 # define BOOST_PP_ITERATION_3 106 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 105 && BOOST_PP_ITERATION_START_3 >= 105 # define BOOST_PP_ITERATION_3 105 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 104 && BOOST_PP_ITERATION_START_3 >= 104 # define BOOST_PP_ITERATION_3 104 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 103 && BOOST_PP_ITERATION_START_3 >= 103 # define BOOST_PP_ITERATION_3 103 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 102 && BOOST_PP_ITERATION_START_3 >= 102 # define BOOST_PP_ITERATION_3 102 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 101 && BOOST_PP_ITERATION_START_3 >= 101 # define BOOST_PP_ITERATION_3 101 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 100 && BOOST_PP_ITERATION_START_3 >= 100 # define BOOST_PP_ITERATION_3 100 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 99 && BOOST_PP_ITERATION_START_3 >= 99 # define BOOST_PP_ITERATION_3 99 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 98 && BOOST_PP_ITERATION_START_3 >= 98 # define BOOST_PP_ITERATION_3 98 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 97 && BOOST_PP_ITERATION_START_3 >= 97 # define BOOST_PP_ITERATION_3 97 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 96 && BOOST_PP_ITERATION_START_3 >= 96 # define BOOST_PP_ITERATION_3 96 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 95 && BOOST_PP_ITERATION_START_3 >= 95 # define BOOST_PP_ITERATION_3 95 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 94 && BOOST_PP_ITERATION_START_3 >= 94 # define BOOST_PP_ITERATION_3 94 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 93 && BOOST_PP_ITERATION_START_3 >= 93 # define BOOST_PP_ITERATION_3 93 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 92 && BOOST_PP_ITERATION_START_3 >= 92 # define BOOST_PP_ITERATION_3 92 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 91 && BOOST_PP_ITERATION_START_3 >= 91 # define BOOST_PP_ITERATION_3 91 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 90 && BOOST_PP_ITERATION_START_3 >= 90 # define BOOST_PP_ITERATION_3 90 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 89 && BOOST_PP_ITERATION_START_3 >= 89 # define BOOST_PP_ITERATION_3 89 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 88 && BOOST_PP_ITERATION_START_3 >= 88 # define BOOST_PP_ITERATION_3 88 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 87 && BOOST_PP_ITERATION_START_3 >= 87 # define BOOST_PP_ITERATION_3 87 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 86 && BOOST_PP_ITERATION_START_3 >= 86 # define BOOST_PP_ITERATION_3 86 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 85 && BOOST_PP_ITERATION_START_3 >= 85 # define BOOST_PP_ITERATION_3 85 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 84 && BOOST_PP_ITERATION_START_3 >= 84 # define BOOST_PP_ITERATION_3 84 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 83 && BOOST_PP_ITERATION_START_3 >= 83 # define BOOST_PP_ITERATION_3 83 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 82 && BOOST_PP_ITERATION_START_3 >= 82 # define BOOST_PP_ITERATION_3 82 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 81 && BOOST_PP_ITERATION_START_3 >= 81 # define BOOST_PP_ITERATION_3 81 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 80 && BOOST_PP_ITERATION_START_3 >= 80 # define BOOST_PP_ITERATION_3 80 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 79 && BOOST_PP_ITERATION_START_3 >= 79 # define BOOST_PP_ITERATION_3 79 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 78 && BOOST_PP_ITERATION_START_3 >= 78 # define BOOST_PP_ITERATION_3 78 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 77 && BOOST_PP_ITERATION_START_3 >= 77 # define BOOST_PP_ITERATION_3 77 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 76 && BOOST_PP_ITERATION_START_3 >= 76 # define BOOST_PP_ITERATION_3 76 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 75 && BOOST_PP_ITERATION_START_3 >= 75 # define BOOST_PP_ITERATION_3 75 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 74 && BOOST_PP_ITERATION_START_3 >= 74 # define BOOST_PP_ITERATION_3 74 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 73 && BOOST_PP_ITERATION_START_3 >= 73 # define BOOST_PP_ITERATION_3 73 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 72 && BOOST_PP_ITERATION_START_3 >= 72 # define BOOST_PP_ITERATION_3 72 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 71 && BOOST_PP_ITERATION_START_3 >= 71 # define BOOST_PP_ITERATION_3 71 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 70 && BOOST_PP_ITERATION_START_3 >= 70 # define BOOST_PP_ITERATION_3 70 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 69 && BOOST_PP_ITERATION_START_3 >= 69 # define BOOST_PP_ITERATION_3 69 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 68 && BOOST_PP_ITERATION_START_3 >= 68 # define BOOST_PP_ITERATION_3 68 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 67 && BOOST_PP_ITERATION_START_3 >= 67 # define BOOST_PP_ITERATION_3 67 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 66 && BOOST_PP_ITERATION_START_3 >= 66 # define BOOST_PP_ITERATION_3 66 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 65 && BOOST_PP_ITERATION_START_3 >= 65 # define BOOST_PP_ITERATION_3 65 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 64 && BOOST_PP_ITERATION_START_3 >= 64 # define BOOST_PP_ITERATION_3 64 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 63 && BOOST_PP_ITERATION_START_3 >= 63 # define BOOST_PP_ITERATION_3 63 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 62 && BOOST_PP_ITERATION_START_3 >= 62 # define BOOST_PP_ITERATION_3 62 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 61 && BOOST_PP_ITERATION_START_3 >= 61 # define BOOST_PP_ITERATION_3 61 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 60 && BOOST_PP_ITERATION_START_3 >= 60 # define BOOST_PP_ITERATION_3 60 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 59 && BOOST_PP_ITERATION_START_3 >= 59 # define BOOST_PP_ITERATION_3 59 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 58 && BOOST_PP_ITERATION_START_3 >= 58 # define BOOST_PP_ITERATION_3 58 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 57 && BOOST_PP_ITERATION_START_3 >= 57 # define BOOST_PP_ITERATION_3 57 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 56 && BOOST_PP_ITERATION_START_3 >= 56 # define BOOST_PP_ITERATION_3 56 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 55 && BOOST_PP_ITERATION_START_3 >= 55 # define BOOST_PP_ITERATION_3 55 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 54 && BOOST_PP_ITERATION_START_3 >= 54 # define BOOST_PP_ITERATION_3 54 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 53 && BOOST_PP_ITERATION_START_3 >= 53 # define BOOST_PP_ITERATION_3 53 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 52 && BOOST_PP_ITERATION_START_3 >= 52 # define BOOST_PP_ITERATION_3 52 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 51 && BOOST_PP_ITERATION_START_3 >= 51 # define BOOST_PP_ITERATION_3 51 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 50 && BOOST_PP_ITERATION_START_3 >= 50 # define BOOST_PP_ITERATION_3 50 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 49 && BOOST_PP_ITERATION_START_3 >= 49 # define BOOST_PP_ITERATION_3 49 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 48 && BOOST_PP_ITERATION_START_3 >= 48 # define BOOST_PP_ITERATION_3 48 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 47 && BOOST_PP_ITERATION_START_3 >= 47 # define BOOST_PP_ITERATION_3 47 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 46 && BOOST_PP_ITERATION_START_3 >= 46 # define BOOST_PP_ITERATION_3 46 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 45 && BOOST_PP_ITERATION_START_3 >= 45 # define BOOST_PP_ITERATION_3 45 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 44 && BOOST_PP_ITERATION_START_3 >= 44 # define BOOST_PP_ITERATION_3 44 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 43 && BOOST_PP_ITERATION_START_3 >= 43 # define BOOST_PP_ITERATION_3 43 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 42 && BOOST_PP_ITERATION_START_3 >= 42 # define BOOST_PP_ITERATION_3 42 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 41 && BOOST_PP_ITERATION_START_3 >= 41 # define BOOST_PP_ITERATION_3 41 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 40 && BOOST_PP_ITERATION_START_3 >= 40 # define BOOST_PP_ITERATION_3 40 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 39 && BOOST_PP_ITERATION_START_3 >= 39 # define BOOST_PP_ITERATION_3 39 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 38 && BOOST_PP_ITERATION_START_3 >= 38 # define BOOST_PP_ITERATION_3 38 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 37 && BOOST_PP_ITERATION_START_3 >= 37 # define BOOST_PP_ITERATION_3 37 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 36 && BOOST_PP_ITERATION_START_3 >= 36 # define BOOST_PP_ITERATION_3 36 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 35 && BOOST_PP_ITERATION_START_3 >= 35 # define BOOST_PP_ITERATION_3 35 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 34 && BOOST_PP_ITERATION_START_3 >= 34 # define BOOST_PP_ITERATION_3 34 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 33 && BOOST_PP_ITERATION_START_3 >= 33 # define BOOST_PP_ITERATION_3 33 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 32 && BOOST_PP_ITERATION_START_3 >= 32 # define BOOST_PP_ITERATION_3 32 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 31 && BOOST_PP_ITERATION_START_3 >= 31 # define BOOST_PP_ITERATION_3 31 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 30 && BOOST_PP_ITERATION_START_3 >= 30 # define BOOST_PP_ITERATION_3 30 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 29 && BOOST_PP_ITERATION_START_3 >= 29 # define BOOST_PP_ITERATION_3 29 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 28 && BOOST_PP_ITERATION_START_3 >= 28 # define BOOST_PP_ITERATION_3 28 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 27 && BOOST_PP_ITERATION_START_3 >= 27 # define BOOST_PP_ITERATION_3 27 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 26 && BOOST_PP_ITERATION_START_3 >= 26 # define BOOST_PP_ITERATION_3 26 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 25 && BOOST_PP_ITERATION_START_3 >= 25 # define BOOST_PP_ITERATION_3 25 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 24 && BOOST_PP_ITERATION_START_3 >= 24 # define BOOST_PP_ITERATION_3 24 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 23 && BOOST_PP_ITERATION_START_3 >= 23 # define BOOST_PP_ITERATION_3 23 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 22 && BOOST_PP_ITERATION_START_3 >= 22 # define BOOST_PP_ITERATION_3 22 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 21 && BOOST_PP_ITERATION_START_3 >= 21 # define BOOST_PP_ITERATION_3 21 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 20 && BOOST_PP_ITERATION_START_3 >= 20 # define BOOST_PP_ITERATION_3 20 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 19 && BOOST_PP_ITERATION_START_3 >= 19 # define BOOST_PP_ITERATION_3 19 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 18 && BOOST_PP_ITERATION_START_3 >= 18 # define BOOST_PP_ITERATION_3 18 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 17 && BOOST_PP_ITERATION_START_3 >= 17 # define BOOST_PP_ITERATION_3 17 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 16 && BOOST_PP_ITERATION_START_3 >= 16 # define BOOST_PP_ITERATION_3 16 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 15 && BOOST_PP_ITERATION_START_3 >= 15 # define BOOST_PP_ITERATION_3 15 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 14 && BOOST_PP_ITERATION_START_3 >= 14 # define BOOST_PP_ITERATION_3 14 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 13 && BOOST_PP_ITERATION_START_3 >= 13 # define BOOST_PP_ITERATION_3 13 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 12 && BOOST_PP_ITERATION_START_3 >= 12 # define BOOST_PP_ITERATION_3 12 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 11 && BOOST_PP_ITERATION_START_3 >= 11 # define BOOST_PP_ITERATION_3 11 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 10 && BOOST_PP_ITERATION_START_3 >= 10 # define BOOST_PP_ITERATION_3 10 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 9 && BOOST_PP_ITERATION_START_3 >= 9 # define BOOST_PP_ITERATION_3 9 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 8 && BOOST_PP_ITERATION_START_3 >= 8 # define BOOST_PP_ITERATION_3 8 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 7 && BOOST_PP_ITERATION_START_3 >= 7 # define BOOST_PP_ITERATION_3 7 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 6 && BOOST_PP_ITERATION_START_3 >= 6 # define BOOST_PP_ITERATION_3 6 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 5 && BOOST_PP_ITERATION_START_3 >= 5 # define BOOST_PP_ITERATION_3 5 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 4 && BOOST_PP_ITERATION_START_3 >= 4 # define BOOST_PP_ITERATION_3 4 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 3 && BOOST_PP_ITERATION_START_3 >= 3 # define BOOST_PP_ITERATION_3 3 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 2 && BOOST_PP_ITERATION_START_3 >= 2 # define BOOST_PP_ITERATION_3 2 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 1 && BOOST_PP_ITERATION_START_3 >= 1 # define BOOST_PP_ITERATION_3 1 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_FINISH_3 <= 0 && BOOST_PP_ITERATION_START_3 >= 0 # define BOOST_PP_ITERATION_3 0 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/reverse1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000013631311344301502031742 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if BOOST_PP_ITERATION_FINISH_1 <= 256 && BOOST_PP_ITERATION_START_1 >= 256 # define BOOST_PP_ITERATION_1 256 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 255 && BOOST_PP_ITERATION_START_1 >= 255 # define BOOST_PP_ITERATION_1 255 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 254 && BOOST_PP_ITERATION_START_1 >= 254 # define BOOST_PP_ITERATION_1 254 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 253 && BOOST_PP_ITERATION_START_1 >= 253 # define BOOST_PP_ITERATION_1 253 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 252 && BOOST_PP_ITERATION_START_1 >= 252 # define BOOST_PP_ITERATION_1 252 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 251 && BOOST_PP_ITERATION_START_1 >= 251 # define BOOST_PP_ITERATION_1 251 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 250 && BOOST_PP_ITERATION_START_1 >= 250 # define BOOST_PP_ITERATION_1 250 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 249 && BOOST_PP_ITERATION_START_1 >= 249 # define BOOST_PP_ITERATION_1 249 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 248 && BOOST_PP_ITERATION_START_1 >= 248 # define BOOST_PP_ITERATION_1 248 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 247 && BOOST_PP_ITERATION_START_1 >= 247 # define BOOST_PP_ITERATION_1 247 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 246 && BOOST_PP_ITERATION_START_1 >= 246 # define BOOST_PP_ITERATION_1 246 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 245 && BOOST_PP_ITERATION_START_1 >= 245 # define BOOST_PP_ITERATION_1 245 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 244 && BOOST_PP_ITERATION_START_1 >= 244 # define BOOST_PP_ITERATION_1 244 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 243 && BOOST_PP_ITERATION_START_1 >= 243 # define BOOST_PP_ITERATION_1 243 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 242 && BOOST_PP_ITERATION_START_1 >= 242 # define BOOST_PP_ITERATION_1 242 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 241 && BOOST_PP_ITERATION_START_1 >= 241 # define BOOST_PP_ITERATION_1 241 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 240 && BOOST_PP_ITERATION_START_1 >= 240 # define BOOST_PP_ITERATION_1 240 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 239 && BOOST_PP_ITERATION_START_1 >= 239 # define BOOST_PP_ITERATION_1 239 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 238 && BOOST_PP_ITERATION_START_1 >= 238 # define BOOST_PP_ITERATION_1 238 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 237 && BOOST_PP_ITERATION_START_1 >= 237 # define BOOST_PP_ITERATION_1 237 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 236 && BOOST_PP_ITERATION_START_1 >= 236 # define BOOST_PP_ITERATION_1 236 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 235 && BOOST_PP_ITERATION_START_1 >= 235 # define BOOST_PP_ITERATION_1 235 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 234 && BOOST_PP_ITERATION_START_1 >= 234 # define BOOST_PP_ITERATION_1 234 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 233 && BOOST_PP_ITERATION_START_1 >= 233 # define BOOST_PP_ITERATION_1 233 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 232 && BOOST_PP_ITERATION_START_1 >= 232 # define BOOST_PP_ITERATION_1 232 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 231 && BOOST_PP_ITERATION_START_1 >= 231 # define BOOST_PP_ITERATION_1 231 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 230 && BOOST_PP_ITERATION_START_1 >= 230 # define BOOST_PP_ITERATION_1 230 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 229 && BOOST_PP_ITERATION_START_1 >= 229 # define BOOST_PP_ITERATION_1 229 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 228 && BOOST_PP_ITERATION_START_1 >= 228 # define BOOST_PP_ITERATION_1 228 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 227 && BOOST_PP_ITERATION_START_1 >= 227 # define BOOST_PP_ITERATION_1 227 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 226 && BOOST_PP_ITERATION_START_1 >= 226 # define BOOST_PP_ITERATION_1 226 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 225 && BOOST_PP_ITERATION_START_1 >= 225 # define BOOST_PP_ITERATION_1 225 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 224 && BOOST_PP_ITERATION_START_1 >= 224 # define BOOST_PP_ITERATION_1 224 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 223 && BOOST_PP_ITERATION_START_1 >= 223 # define BOOST_PP_ITERATION_1 223 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 222 && BOOST_PP_ITERATION_START_1 >= 222 # define BOOST_PP_ITERATION_1 222 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 221 && BOOST_PP_ITERATION_START_1 >= 221 # define BOOST_PP_ITERATION_1 221 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 220 && BOOST_PP_ITERATION_START_1 >= 220 # define BOOST_PP_ITERATION_1 220 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 219 && BOOST_PP_ITERATION_START_1 >= 219 # define BOOST_PP_ITERATION_1 219 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 218 && BOOST_PP_ITERATION_START_1 >= 218 # define BOOST_PP_ITERATION_1 218 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 217 && BOOST_PP_ITERATION_START_1 >= 217 # define BOOST_PP_ITERATION_1 217 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 216 && BOOST_PP_ITERATION_START_1 >= 216 # define BOOST_PP_ITERATION_1 216 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 215 && BOOST_PP_ITERATION_START_1 >= 215 # define BOOST_PP_ITERATION_1 215 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 214 && BOOST_PP_ITERATION_START_1 >= 214 # define BOOST_PP_ITERATION_1 214 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 213 && BOOST_PP_ITERATION_START_1 >= 213 # define BOOST_PP_ITERATION_1 213 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 212 && BOOST_PP_ITERATION_START_1 >= 212 # define BOOST_PP_ITERATION_1 212 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 211 && BOOST_PP_ITERATION_START_1 >= 211 # define BOOST_PP_ITERATION_1 211 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 210 && BOOST_PP_ITERATION_START_1 >= 210 # define BOOST_PP_ITERATION_1 210 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 209 && BOOST_PP_ITERATION_START_1 >= 209 # define BOOST_PP_ITERATION_1 209 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 208 && BOOST_PP_ITERATION_START_1 >= 208 # define BOOST_PP_ITERATION_1 208 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 207 && BOOST_PP_ITERATION_START_1 >= 207 # define BOOST_PP_ITERATION_1 207 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 206 && BOOST_PP_ITERATION_START_1 >= 206 # define BOOST_PP_ITERATION_1 206 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 205 && BOOST_PP_ITERATION_START_1 >= 205 # define BOOST_PP_ITERATION_1 205 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 204 && BOOST_PP_ITERATION_START_1 >= 204 # define BOOST_PP_ITERATION_1 204 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 203 && BOOST_PP_ITERATION_START_1 >= 203 # define BOOST_PP_ITERATION_1 203 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 202 && BOOST_PP_ITERATION_START_1 >= 202 # define BOOST_PP_ITERATION_1 202 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 201 && BOOST_PP_ITERATION_START_1 >= 201 # define BOOST_PP_ITERATION_1 201 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 200 && BOOST_PP_ITERATION_START_1 >= 200 # define BOOST_PP_ITERATION_1 200 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 199 && BOOST_PP_ITERATION_START_1 >= 199 # define BOOST_PP_ITERATION_1 199 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 198 && BOOST_PP_ITERATION_START_1 >= 198 # define BOOST_PP_ITERATION_1 198 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 197 && BOOST_PP_ITERATION_START_1 >= 197 # define BOOST_PP_ITERATION_1 197 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 196 && BOOST_PP_ITERATION_START_1 >= 196 # define BOOST_PP_ITERATION_1 196 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 195 && BOOST_PP_ITERATION_START_1 >= 195 # define BOOST_PP_ITERATION_1 195 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 194 && BOOST_PP_ITERATION_START_1 >= 194 # define BOOST_PP_ITERATION_1 194 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 193 && BOOST_PP_ITERATION_START_1 >= 193 # define BOOST_PP_ITERATION_1 193 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 192 && BOOST_PP_ITERATION_START_1 >= 192 # define BOOST_PP_ITERATION_1 192 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 191 && BOOST_PP_ITERATION_START_1 >= 191 # define BOOST_PP_ITERATION_1 191 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 190 && BOOST_PP_ITERATION_START_1 >= 190 # define BOOST_PP_ITERATION_1 190 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 189 && BOOST_PP_ITERATION_START_1 >= 189 # define BOOST_PP_ITERATION_1 189 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 188 && BOOST_PP_ITERATION_START_1 >= 188 # define BOOST_PP_ITERATION_1 188 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 187 && BOOST_PP_ITERATION_START_1 >= 187 # define BOOST_PP_ITERATION_1 187 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 186 && BOOST_PP_ITERATION_START_1 >= 186 # define BOOST_PP_ITERATION_1 186 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 185 && BOOST_PP_ITERATION_START_1 >= 185 # define BOOST_PP_ITERATION_1 185 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 184 && BOOST_PP_ITERATION_START_1 >= 184 # define BOOST_PP_ITERATION_1 184 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 183 && BOOST_PP_ITERATION_START_1 >= 183 # define BOOST_PP_ITERATION_1 183 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 182 && BOOST_PP_ITERATION_START_1 >= 182 # define BOOST_PP_ITERATION_1 182 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 181 && BOOST_PP_ITERATION_START_1 >= 181 # define BOOST_PP_ITERATION_1 181 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 180 && BOOST_PP_ITERATION_START_1 >= 180 # define BOOST_PP_ITERATION_1 180 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 179 && BOOST_PP_ITERATION_START_1 >= 179 # define BOOST_PP_ITERATION_1 179 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 178 && BOOST_PP_ITERATION_START_1 >= 178 # define BOOST_PP_ITERATION_1 178 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 177 && BOOST_PP_ITERATION_START_1 >= 177 # define BOOST_PP_ITERATION_1 177 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 176 && BOOST_PP_ITERATION_START_1 >= 176 # define BOOST_PP_ITERATION_1 176 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 175 && BOOST_PP_ITERATION_START_1 >= 175 # define BOOST_PP_ITERATION_1 175 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 174 && BOOST_PP_ITERATION_START_1 >= 174 # define BOOST_PP_ITERATION_1 174 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 173 && BOOST_PP_ITERATION_START_1 >= 173 # define BOOST_PP_ITERATION_1 173 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 172 && BOOST_PP_ITERATION_START_1 >= 172 # define BOOST_PP_ITERATION_1 172 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 171 && BOOST_PP_ITERATION_START_1 >= 171 # define BOOST_PP_ITERATION_1 171 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 170 && BOOST_PP_ITERATION_START_1 >= 170 # define BOOST_PP_ITERATION_1 170 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 169 && BOOST_PP_ITERATION_START_1 >= 169 # define BOOST_PP_ITERATION_1 169 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 168 && BOOST_PP_ITERATION_START_1 >= 168 # define BOOST_PP_ITERATION_1 168 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 167 && BOOST_PP_ITERATION_START_1 >= 167 # define BOOST_PP_ITERATION_1 167 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 166 && BOOST_PP_ITERATION_START_1 >= 166 # define BOOST_PP_ITERATION_1 166 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 165 && BOOST_PP_ITERATION_START_1 >= 165 # define BOOST_PP_ITERATION_1 165 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 164 && BOOST_PP_ITERATION_START_1 >= 164 # define BOOST_PP_ITERATION_1 164 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 163 && BOOST_PP_ITERATION_START_1 >= 163 # define BOOST_PP_ITERATION_1 163 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 162 && BOOST_PP_ITERATION_START_1 >= 162 # define BOOST_PP_ITERATION_1 162 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 161 && BOOST_PP_ITERATION_START_1 >= 161 # define BOOST_PP_ITERATION_1 161 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 160 && BOOST_PP_ITERATION_START_1 >= 160 # define BOOST_PP_ITERATION_1 160 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 159 && BOOST_PP_ITERATION_START_1 >= 159 # define BOOST_PP_ITERATION_1 159 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 158 && BOOST_PP_ITERATION_START_1 >= 158 # define BOOST_PP_ITERATION_1 158 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 157 && BOOST_PP_ITERATION_START_1 >= 157 # define BOOST_PP_ITERATION_1 157 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 156 && BOOST_PP_ITERATION_START_1 >= 156 # define BOOST_PP_ITERATION_1 156 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 155 && BOOST_PP_ITERATION_START_1 >= 155 # define BOOST_PP_ITERATION_1 155 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 154 && BOOST_PP_ITERATION_START_1 >= 154 # define BOOST_PP_ITERATION_1 154 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 153 && BOOST_PP_ITERATION_START_1 >= 153 # define BOOST_PP_ITERATION_1 153 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 152 && BOOST_PP_ITERATION_START_1 >= 152 # define BOOST_PP_ITERATION_1 152 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 151 && BOOST_PP_ITERATION_START_1 >= 151 # define BOOST_PP_ITERATION_1 151 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 150 && BOOST_PP_ITERATION_START_1 >= 150 # define BOOST_PP_ITERATION_1 150 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 149 && BOOST_PP_ITERATION_START_1 >= 149 # define BOOST_PP_ITERATION_1 149 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 148 && BOOST_PP_ITERATION_START_1 >= 148 # define BOOST_PP_ITERATION_1 148 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 147 && BOOST_PP_ITERATION_START_1 >= 147 # define BOOST_PP_ITERATION_1 147 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 146 && BOOST_PP_ITERATION_START_1 >= 146 # define BOOST_PP_ITERATION_1 146 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 145 && BOOST_PP_ITERATION_START_1 >= 145 # define BOOST_PP_ITERATION_1 145 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 144 && BOOST_PP_ITERATION_START_1 >= 144 # define BOOST_PP_ITERATION_1 144 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 143 && BOOST_PP_ITERATION_START_1 >= 143 # define BOOST_PP_ITERATION_1 143 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 142 && BOOST_PP_ITERATION_START_1 >= 142 # define BOOST_PP_ITERATION_1 142 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 141 && BOOST_PP_ITERATION_START_1 >= 141 # define BOOST_PP_ITERATION_1 141 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 140 && BOOST_PP_ITERATION_START_1 >= 140 # define BOOST_PP_ITERATION_1 140 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 139 && BOOST_PP_ITERATION_START_1 >= 139 # define BOOST_PP_ITERATION_1 139 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 138 && BOOST_PP_ITERATION_START_1 >= 138 # define BOOST_PP_ITERATION_1 138 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 137 && BOOST_PP_ITERATION_START_1 >= 137 # define BOOST_PP_ITERATION_1 137 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 136 && BOOST_PP_ITERATION_START_1 >= 136 # define BOOST_PP_ITERATION_1 136 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 135 && BOOST_PP_ITERATION_START_1 >= 135 # define BOOST_PP_ITERATION_1 135 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 134 && BOOST_PP_ITERATION_START_1 >= 134 # define BOOST_PP_ITERATION_1 134 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 133 && BOOST_PP_ITERATION_START_1 >= 133 # define BOOST_PP_ITERATION_1 133 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 132 && BOOST_PP_ITERATION_START_1 >= 132 # define BOOST_PP_ITERATION_1 132 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 131 && BOOST_PP_ITERATION_START_1 >= 131 # define BOOST_PP_ITERATION_1 131 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 130 && BOOST_PP_ITERATION_START_1 >= 130 # define BOOST_PP_ITERATION_1 130 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 129 && BOOST_PP_ITERATION_START_1 >= 129 # define BOOST_PP_ITERATION_1 129 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 128 && BOOST_PP_ITERATION_START_1 >= 128 # define BOOST_PP_ITERATION_1 128 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 127 && BOOST_PP_ITERATION_START_1 >= 127 # define BOOST_PP_ITERATION_1 127 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 126 && BOOST_PP_ITERATION_START_1 >= 126 # define BOOST_PP_ITERATION_1 126 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 125 && BOOST_PP_ITERATION_START_1 >= 125 # define BOOST_PP_ITERATION_1 125 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 124 && BOOST_PP_ITERATION_START_1 >= 124 # define BOOST_PP_ITERATION_1 124 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 123 && BOOST_PP_ITERATION_START_1 >= 123 # define BOOST_PP_ITERATION_1 123 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 122 && BOOST_PP_ITERATION_START_1 >= 122 # define BOOST_PP_ITERATION_1 122 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 121 && BOOST_PP_ITERATION_START_1 >= 121 # define BOOST_PP_ITERATION_1 121 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 120 && BOOST_PP_ITERATION_START_1 >= 120 # define BOOST_PP_ITERATION_1 120 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 119 && BOOST_PP_ITERATION_START_1 >= 119 # define BOOST_PP_ITERATION_1 119 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 118 && BOOST_PP_ITERATION_START_1 >= 118 # define BOOST_PP_ITERATION_1 118 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 117 && BOOST_PP_ITERATION_START_1 >= 117 # define BOOST_PP_ITERATION_1 117 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 116 && BOOST_PP_ITERATION_START_1 >= 116 # define BOOST_PP_ITERATION_1 116 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 115 && BOOST_PP_ITERATION_START_1 >= 115 # define BOOST_PP_ITERATION_1 115 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 114 && BOOST_PP_ITERATION_START_1 >= 114 # define BOOST_PP_ITERATION_1 114 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 113 && BOOST_PP_ITERATION_START_1 >= 113 # define BOOST_PP_ITERATION_1 113 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 112 && BOOST_PP_ITERATION_START_1 >= 112 # define BOOST_PP_ITERATION_1 112 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 111 && BOOST_PP_ITERATION_START_1 >= 111 # define BOOST_PP_ITERATION_1 111 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 110 && BOOST_PP_ITERATION_START_1 >= 110 # define BOOST_PP_ITERATION_1 110 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 109 && BOOST_PP_ITERATION_START_1 >= 109 # define BOOST_PP_ITERATION_1 109 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 108 && BOOST_PP_ITERATION_START_1 >= 108 # define BOOST_PP_ITERATION_1 108 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 107 && BOOST_PP_ITERATION_START_1 >= 107 # define BOOST_PP_ITERATION_1 107 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 106 && BOOST_PP_ITERATION_START_1 >= 106 # define BOOST_PP_ITERATION_1 106 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 105 && BOOST_PP_ITERATION_START_1 >= 105 # define BOOST_PP_ITERATION_1 105 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 104 && BOOST_PP_ITERATION_START_1 >= 104 # define BOOST_PP_ITERATION_1 104 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 103 && BOOST_PP_ITERATION_START_1 >= 103 # define BOOST_PP_ITERATION_1 103 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 102 && BOOST_PP_ITERATION_START_1 >= 102 # define BOOST_PP_ITERATION_1 102 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 101 && BOOST_PP_ITERATION_START_1 >= 101 # define BOOST_PP_ITERATION_1 101 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 100 && BOOST_PP_ITERATION_START_1 >= 100 # define BOOST_PP_ITERATION_1 100 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 99 && BOOST_PP_ITERATION_START_1 >= 99 # define BOOST_PP_ITERATION_1 99 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 98 && BOOST_PP_ITERATION_START_1 >= 98 # define BOOST_PP_ITERATION_1 98 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 97 && BOOST_PP_ITERATION_START_1 >= 97 # define BOOST_PP_ITERATION_1 97 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 96 && BOOST_PP_ITERATION_START_1 >= 96 # define BOOST_PP_ITERATION_1 96 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 95 && BOOST_PP_ITERATION_START_1 >= 95 # define BOOST_PP_ITERATION_1 95 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 94 && BOOST_PP_ITERATION_START_1 >= 94 # define BOOST_PP_ITERATION_1 94 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 93 && BOOST_PP_ITERATION_START_1 >= 93 # define BOOST_PP_ITERATION_1 93 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 92 && BOOST_PP_ITERATION_START_1 >= 92 # define BOOST_PP_ITERATION_1 92 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 91 && BOOST_PP_ITERATION_START_1 >= 91 # define BOOST_PP_ITERATION_1 91 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 90 && BOOST_PP_ITERATION_START_1 >= 90 # define BOOST_PP_ITERATION_1 90 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 89 && BOOST_PP_ITERATION_START_1 >= 89 # define BOOST_PP_ITERATION_1 89 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 88 && BOOST_PP_ITERATION_START_1 >= 88 # define BOOST_PP_ITERATION_1 88 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 87 && BOOST_PP_ITERATION_START_1 >= 87 # define BOOST_PP_ITERATION_1 87 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 86 && BOOST_PP_ITERATION_START_1 >= 86 # define BOOST_PP_ITERATION_1 86 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 85 && BOOST_PP_ITERATION_START_1 >= 85 # define BOOST_PP_ITERATION_1 85 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 84 && BOOST_PP_ITERATION_START_1 >= 84 # define BOOST_PP_ITERATION_1 84 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 83 && BOOST_PP_ITERATION_START_1 >= 83 # define BOOST_PP_ITERATION_1 83 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 82 && BOOST_PP_ITERATION_START_1 >= 82 # define BOOST_PP_ITERATION_1 82 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 81 && BOOST_PP_ITERATION_START_1 >= 81 # define BOOST_PP_ITERATION_1 81 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 80 && BOOST_PP_ITERATION_START_1 >= 80 # define BOOST_PP_ITERATION_1 80 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 79 && BOOST_PP_ITERATION_START_1 >= 79 # define BOOST_PP_ITERATION_1 79 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 78 && BOOST_PP_ITERATION_START_1 >= 78 # define BOOST_PP_ITERATION_1 78 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 77 && BOOST_PP_ITERATION_START_1 >= 77 # define BOOST_PP_ITERATION_1 77 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 76 && BOOST_PP_ITERATION_START_1 >= 76 # define BOOST_PP_ITERATION_1 76 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 75 && BOOST_PP_ITERATION_START_1 >= 75 # define BOOST_PP_ITERATION_1 75 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 74 && BOOST_PP_ITERATION_START_1 >= 74 # define BOOST_PP_ITERATION_1 74 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 73 && BOOST_PP_ITERATION_START_1 >= 73 # define BOOST_PP_ITERATION_1 73 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 72 && BOOST_PP_ITERATION_START_1 >= 72 # define BOOST_PP_ITERATION_1 72 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 71 && BOOST_PP_ITERATION_START_1 >= 71 # define BOOST_PP_ITERATION_1 71 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 70 && BOOST_PP_ITERATION_START_1 >= 70 # define BOOST_PP_ITERATION_1 70 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 69 && BOOST_PP_ITERATION_START_1 >= 69 # define BOOST_PP_ITERATION_1 69 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 68 && BOOST_PP_ITERATION_START_1 >= 68 # define BOOST_PP_ITERATION_1 68 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 67 && BOOST_PP_ITERATION_START_1 >= 67 # define BOOST_PP_ITERATION_1 67 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 66 && BOOST_PP_ITERATION_START_1 >= 66 # define BOOST_PP_ITERATION_1 66 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 65 && BOOST_PP_ITERATION_START_1 >= 65 # define BOOST_PP_ITERATION_1 65 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 64 && BOOST_PP_ITERATION_START_1 >= 64 # define BOOST_PP_ITERATION_1 64 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 63 && BOOST_PP_ITERATION_START_1 >= 63 # define BOOST_PP_ITERATION_1 63 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 62 && BOOST_PP_ITERATION_START_1 >= 62 # define BOOST_PP_ITERATION_1 62 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 61 && BOOST_PP_ITERATION_START_1 >= 61 # define BOOST_PP_ITERATION_1 61 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 60 && BOOST_PP_ITERATION_START_1 >= 60 # define BOOST_PP_ITERATION_1 60 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 59 && BOOST_PP_ITERATION_START_1 >= 59 # define BOOST_PP_ITERATION_1 59 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 58 && BOOST_PP_ITERATION_START_1 >= 58 # define BOOST_PP_ITERATION_1 58 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 57 && BOOST_PP_ITERATION_START_1 >= 57 # define BOOST_PP_ITERATION_1 57 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 56 && BOOST_PP_ITERATION_START_1 >= 56 # define BOOST_PP_ITERATION_1 56 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 55 && BOOST_PP_ITERATION_START_1 >= 55 # define BOOST_PP_ITERATION_1 55 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 54 && BOOST_PP_ITERATION_START_1 >= 54 # define BOOST_PP_ITERATION_1 54 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 53 && BOOST_PP_ITERATION_START_1 >= 53 # define BOOST_PP_ITERATION_1 53 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 52 && BOOST_PP_ITERATION_START_1 >= 52 # define BOOST_PP_ITERATION_1 52 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 51 && BOOST_PP_ITERATION_START_1 >= 51 # define BOOST_PP_ITERATION_1 51 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 50 && BOOST_PP_ITERATION_START_1 >= 50 # define BOOST_PP_ITERATION_1 50 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 49 && BOOST_PP_ITERATION_START_1 >= 49 # define BOOST_PP_ITERATION_1 49 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 48 && BOOST_PP_ITERATION_START_1 >= 48 # define BOOST_PP_ITERATION_1 48 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 47 && BOOST_PP_ITERATION_START_1 >= 47 # define BOOST_PP_ITERATION_1 47 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 46 && BOOST_PP_ITERATION_START_1 >= 46 # define BOOST_PP_ITERATION_1 46 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 45 && BOOST_PP_ITERATION_START_1 >= 45 # define BOOST_PP_ITERATION_1 45 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 44 && BOOST_PP_ITERATION_START_1 >= 44 # define BOOST_PP_ITERATION_1 44 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 43 && BOOST_PP_ITERATION_START_1 >= 43 # define BOOST_PP_ITERATION_1 43 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 42 && BOOST_PP_ITERATION_START_1 >= 42 # define BOOST_PP_ITERATION_1 42 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 41 && BOOST_PP_ITERATION_START_1 >= 41 # define BOOST_PP_ITERATION_1 41 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 40 && BOOST_PP_ITERATION_START_1 >= 40 # define BOOST_PP_ITERATION_1 40 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 39 && BOOST_PP_ITERATION_START_1 >= 39 # define BOOST_PP_ITERATION_1 39 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 38 && BOOST_PP_ITERATION_START_1 >= 38 # define BOOST_PP_ITERATION_1 38 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 37 && BOOST_PP_ITERATION_START_1 >= 37 # define BOOST_PP_ITERATION_1 37 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 36 && BOOST_PP_ITERATION_START_1 >= 36 # define BOOST_PP_ITERATION_1 36 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 35 && BOOST_PP_ITERATION_START_1 >= 35 # define BOOST_PP_ITERATION_1 35 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 34 && BOOST_PP_ITERATION_START_1 >= 34 # define BOOST_PP_ITERATION_1 34 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 33 && BOOST_PP_ITERATION_START_1 >= 33 # define BOOST_PP_ITERATION_1 33 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 32 && BOOST_PP_ITERATION_START_1 >= 32 # define BOOST_PP_ITERATION_1 32 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 31 && BOOST_PP_ITERATION_START_1 >= 31 # define BOOST_PP_ITERATION_1 31 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 30 && BOOST_PP_ITERATION_START_1 >= 30 # define BOOST_PP_ITERATION_1 30 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 29 && BOOST_PP_ITERATION_START_1 >= 29 # define BOOST_PP_ITERATION_1 29 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 28 && BOOST_PP_ITERATION_START_1 >= 28 # define BOOST_PP_ITERATION_1 28 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 27 && BOOST_PP_ITERATION_START_1 >= 27 # define BOOST_PP_ITERATION_1 27 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 26 && BOOST_PP_ITERATION_START_1 >= 26 # define BOOST_PP_ITERATION_1 26 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 25 && BOOST_PP_ITERATION_START_1 >= 25 # define BOOST_PP_ITERATION_1 25 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 24 && BOOST_PP_ITERATION_START_1 >= 24 # define BOOST_PP_ITERATION_1 24 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 23 && BOOST_PP_ITERATION_START_1 >= 23 # define BOOST_PP_ITERATION_1 23 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 22 && BOOST_PP_ITERATION_START_1 >= 22 # define BOOST_PP_ITERATION_1 22 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 21 && BOOST_PP_ITERATION_START_1 >= 21 # define BOOST_PP_ITERATION_1 21 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 20 && BOOST_PP_ITERATION_START_1 >= 20 # define BOOST_PP_ITERATION_1 20 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 19 && BOOST_PP_ITERATION_START_1 >= 19 # define BOOST_PP_ITERATION_1 19 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 18 && BOOST_PP_ITERATION_START_1 >= 18 # define BOOST_PP_ITERATION_1 18 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 17 && BOOST_PP_ITERATION_START_1 >= 17 # define BOOST_PP_ITERATION_1 17 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 16 && BOOST_PP_ITERATION_START_1 >= 16 # define BOOST_PP_ITERATION_1 16 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 15 && BOOST_PP_ITERATION_START_1 >= 15 # define BOOST_PP_ITERATION_1 15 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 14 && BOOST_PP_ITERATION_START_1 >= 14 # define BOOST_PP_ITERATION_1 14 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 13 && BOOST_PP_ITERATION_START_1 >= 13 # define BOOST_PP_ITERATION_1 13 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 12 && BOOST_PP_ITERATION_START_1 >= 12 # define BOOST_PP_ITERATION_1 12 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 11 && BOOST_PP_ITERATION_START_1 >= 11 # define BOOST_PP_ITERATION_1 11 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 10 && BOOST_PP_ITERATION_START_1 >= 10 # define BOOST_PP_ITERATION_1 10 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 9 && BOOST_PP_ITERATION_START_1 >= 9 # define BOOST_PP_ITERATION_1 9 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 8 && BOOST_PP_ITERATION_START_1 >= 8 # define BOOST_PP_ITERATION_1 8 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 7 && BOOST_PP_ITERATION_START_1 >= 7 # define BOOST_PP_ITERATION_1 7 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 6 && BOOST_PP_ITERATION_START_1 >= 6 # define BOOST_PP_ITERATION_1 6 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 5 && BOOST_PP_ITERATION_START_1 >= 5 # define BOOST_PP_ITERATION_1 5 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 4 && BOOST_PP_ITERATION_START_1 >= 4 # define BOOST_PP_ITERATION_1 4 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 3 && BOOST_PP_ITERATION_START_1 >= 3 # define BOOST_PP_ITERATION_1 3 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 2 && BOOST_PP_ITERATION_START_1 >= 2 # define BOOST_PP_ITERATION_1 2 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 1 && BOOST_PP_ITERATION_START_1 >= 1 # define BOOST_PP_ITERATION_1 1 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif # if BOOST_PP_ITERATION_FINISH_1 <= 0 && BOOST_PP_ITERATION_START_1 >= 0 # define BOOST_PP_ITERATION_1 0 # include BOOST_PP_FILENAME_1 # undef BOOST_PP_ITERATION_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/iter/forward3.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000015265711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if defined(BOOST_PP_ITERATION_LIMITS) # if !defined(BOOST_PP_FILENAME_3) # error BOOST_PP_ERROR: depth #3 filename is not defined # endif # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_ITERATION_LIMITS) # include # define BOOST_PP_ITERATION_FLAGS_3 0 # undef BOOST_PP_ITERATION_LIMITS # elif defined(BOOST_PP_ITERATION_PARAMS_3) # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(0, BOOST_PP_ITERATION_PARAMS_3) # include # define BOOST_PP_VALUE BOOST_PP_ARRAY_ELEM(1, BOOST_PP_ITERATION_PARAMS_3) # include # define BOOST_PP_FILENAME_3 BOOST_PP_ARRAY_ELEM(2, BOOST_PP_ITERATION_PARAMS_3) # if BOOST_PP_ARRAY_SIZE(BOOST_PP_ITERATION_PARAMS_3) >= 4 # define BOOST_PP_ITERATION_FLAGS_3 BOOST_PP_ARRAY_ELEM(3, BOOST_PP_ITERATION_PARAMS_3) # else # define BOOST_PP_ITERATION_FLAGS_3 0 # endif # else # error BOOST_PP_ERROR: depth #3 iteration boundaries or filename not defined # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 3 # # if (BOOST_PP_ITERATION_START_3) > (BOOST_PP_ITERATION_FINISH_3) # include # else # if BOOST_PP_ITERATION_START_3 <= 0 && BOOST_PP_ITERATION_FINISH_3 >= 0 # define BOOST_PP_ITERATION_3 0 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 1 && BOOST_PP_ITERATION_FINISH_3 >= 1 # define BOOST_PP_ITERATION_3 1 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 2 && BOOST_PP_ITERATION_FINISH_3 >= 2 # define BOOST_PP_ITERATION_3 2 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 3 && BOOST_PP_ITERATION_FINISH_3 >= 3 # define BOOST_PP_ITERATION_3 3 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 4 && BOOST_PP_ITERATION_FINISH_3 >= 4 # define BOOST_PP_ITERATION_3 4 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 5 && BOOST_PP_ITERATION_FINISH_3 >= 5 # define BOOST_PP_ITERATION_3 5 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 6 && BOOST_PP_ITERATION_FINISH_3 >= 6 # define BOOST_PP_ITERATION_3 6 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 7 && BOOST_PP_ITERATION_FINISH_3 >= 7 # define BOOST_PP_ITERATION_3 7 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 8 && BOOST_PP_ITERATION_FINISH_3 >= 8 # define BOOST_PP_ITERATION_3 8 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 9 && BOOST_PP_ITERATION_FINISH_3 >= 9 # define BOOST_PP_ITERATION_3 9 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 10 && BOOST_PP_ITERATION_FINISH_3 >= 10 # define BOOST_PP_ITERATION_3 10 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 11 && BOOST_PP_ITERATION_FINISH_3 >= 11 # define BOOST_PP_ITERATION_3 11 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 12 && BOOST_PP_ITERATION_FINISH_3 >= 12 # define BOOST_PP_ITERATION_3 12 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 13 && BOOST_PP_ITERATION_FINISH_3 >= 13 # define BOOST_PP_ITERATION_3 13 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 14 && BOOST_PP_ITERATION_FINISH_3 >= 14 # define BOOST_PP_ITERATION_3 14 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 15 && BOOST_PP_ITERATION_FINISH_3 >= 15 # define BOOST_PP_ITERATION_3 15 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 16 && BOOST_PP_ITERATION_FINISH_3 >= 16 # define BOOST_PP_ITERATION_3 16 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 17 && BOOST_PP_ITERATION_FINISH_3 >= 17 # define BOOST_PP_ITERATION_3 17 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 18 && BOOST_PP_ITERATION_FINISH_3 >= 18 # define BOOST_PP_ITERATION_3 18 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 19 && BOOST_PP_ITERATION_FINISH_3 >= 19 # define BOOST_PP_ITERATION_3 19 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 20 && BOOST_PP_ITERATION_FINISH_3 >= 20 # define BOOST_PP_ITERATION_3 20 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 21 && BOOST_PP_ITERATION_FINISH_3 >= 21 # define BOOST_PP_ITERATION_3 21 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 22 && BOOST_PP_ITERATION_FINISH_3 >= 22 # define BOOST_PP_ITERATION_3 22 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 23 && BOOST_PP_ITERATION_FINISH_3 >= 23 # define BOOST_PP_ITERATION_3 23 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 24 && BOOST_PP_ITERATION_FINISH_3 >= 24 # define BOOST_PP_ITERATION_3 24 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 25 && BOOST_PP_ITERATION_FINISH_3 >= 25 # define BOOST_PP_ITERATION_3 25 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 26 && BOOST_PP_ITERATION_FINISH_3 >= 26 # define BOOST_PP_ITERATION_3 26 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 27 && BOOST_PP_ITERATION_FINISH_3 >= 27 # define BOOST_PP_ITERATION_3 27 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 28 && BOOST_PP_ITERATION_FINISH_3 >= 28 # define BOOST_PP_ITERATION_3 28 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 29 && BOOST_PP_ITERATION_FINISH_3 >= 29 # define BOOST_PP_ITERATION_3 29 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 30 && BOOST_PP_ITERATION_FINISH_3 >= 30 # define BOOST_PP_ITERATION_3 30 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 31 && BOOST_PP_ITERATION_FINISH_3 >= 31 # define BOOST_PP_ITERATION_3 31 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 32 && BOOST_PP_ITERATION_FINISH_3 >= 32 # define BOOST_PP_ITERATION_3 32 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 33 && BOOST_PP_ITERATION_FINISH_3 >= 33 # define BOOST_PP_ITERATION_3 33 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 34 && BOOST_PP_ITERATION_FINISH_3 >= 34 # define BOOST_PP_ITERATION_3 34 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 35 && BOOST_PP_ITERATION_FINISH_3 >= 35 # define BOOST_PP_ITERATION_3 35 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 36 && BOOST_PP_ITERATION_FINISH_3 >= 36 # define BOOST_PP_ITERATION_3 36 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 37 && BOOST_PP_ITERATION_FINISH_3 >= 37 # define BOOST_PP_ITERATION_3 37 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 38 && BOOST_PP_ITERATION_FINISH_3 >= 38 # define BOOST_PP_ITERATION_3 38 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 39 && BOOST_PP_ITERATION_FINISH_3 >= 39 # define BOOST_PP_ITERATION_3 39 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 40 && BOOST_PP_ITERATION_FINISH_3 >= 40 # define BOOST_PP_ITERATION_3 40 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 41 && BOOST_PP_ITERATION_FINISH_3 >= 41 # define BOOST_PP_ITERATION_3 41 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 42 && BOOST_PP_ITERATION_FINISH_3 >= 42 # define BOOST_PP_ITERATION_3 42 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 43 && BOOST_PP_ITERATION_FINISH_3 >= 43 # define BOOST_PP_ITERATION_3 43 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 44 && BOOST_PP_ITERATION_FINISH_3 >= 44 # define BOOST_PP_ITERATION_3 44 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 45 && BOOST_PP_ITERATION_FINISH_3 >= 45 # define BOOST_PP_ITERATION_3 45 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 46 && BOOST_PP_ITERATION_FINISH_3 >= 46 # define BOOST_PP_ITERATION_3 46 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 47 && BOOST_PP_ITERATION_FINISH_3 >= 47 # define BOOST_PP_ITERATION_3 47 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 48 && BOOST_PP_ITERATION_FINISH_3 >= 48 # define BOOST_PP_ITERATION_3 48 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 49 && BOOST_PP_ITERATION_FINISH_3 >= 49 # define BOOST_PP_ITERATION_3 49 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 50 && BOOST_PP_ITERATION_FINISH_3 >= 50 # define BOOST_PP_ITERATION_3 50 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 51 && BOOST_PP_ITERATION_FINISH_3 >= 51 # define BOOST_PP_ITERATION_3 51 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 52 && BOOST_PP_ITERATION_FINISH_3 >= 52 # define BOOST_PP_ITERATION_3 52 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 53 && BOOST_PP_ITERATION_FINISH_3 >= 53 # define BOOST_PP_ITERATION_3 53 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 54 && BOOST_PP_ITERATION_FINISH_3 >= 54 # define BOOST_PP_ITERATION_3 54 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 55 && BOOST_PP_ITERATION_FINISH_3 >= 55 # define BOOST_PP_ITERATION_3 55 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 56 && BOOST_PP_ITERATION_FINISH_3 >= 56 # define BOOST_PP_ITERATION_3 56 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 57 && BOOST_PP_ITERATION_FINISH_3 >= 57 # define BOOST_PP_ITERATION_3 57 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 58 && BOOST_PP_ITERATION_FINISH_3 >= 58 # define BOOST_PP_ITERATION_3 58 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 59 && BOOST_PP_ITERATION_FINISH_3 >= 59 # define BOOST_PP_ITERATION_3 59 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 60 && BOOST_PP_ITERATION_FINISH_3 >= 60 # define BOOST_PP_ITERATION_3 60 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 61 && BOOST_PP_ITERATION_FINISH_3 >= 61 # define BOOST_PP_ITERATION_3 61 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 62 && BOOST_PP_ITERATION_FINISH_3 >= 62 # define BOOST_PP_ITERATION_3 62 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 63 && BOOST_PP_ITERATION_FINISH_3 >= 63 # define BOOST_PP_ITERATION_3 63 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 64 && BOOST_PP_ITERATION_FINISH_3 >= 64 # define BOOST_PP_ITERATION_3 64 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 65 && BOOST_PP_ITERATION_FINISH_3 >= 65 # define BOOST_PP_ITERATION_3 65 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 66 && BOOST_PP_ITERATION_FINISH_3 >= 66 # define BOOST_PP_ITERATION_3 66 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 67 && BOOST_PP_ITERATION_FINISH_3 >= 67 # define BOOST_PP_ITERATION_3 67 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 68 && BOOST_PP_ITERATION_FINISH_3 >= 68 # define BOOST_PP_ITERATION_3 68 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 69 && BOOST_PP_ITERATION_FINISH_3 >= 69 # define BOOST_PP_ITERATION_3 69 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 70 && BOOST_PP_ITERATION_FINISH_3 >= 70 # define BOOST_PP_ITERATION_3 70 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 71 && BOOST_PP_ITERATION_FINISH_3 >= 71 # define BOOST_PP_ITERATION_3 71 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 72 && BOOST_PP_ITERATION_FINISH_3 >= 72 # define BOOST_PP_ITERATION_3 72 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 73 && BOOST_PP_ITERATION_FINISH_3 >= 73 # define BOOST_PP_ITERATION_3 73 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 74 && BOOST_PP_ITERATION_FINISH_3 >= 74 # define BOOST_PP_ITERATION_3 74 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 75 && BOOST_PP_ITERATION_FINISH_3 >= 75 # define BOOST_PP_ITERATION_3 75 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 76 && BOOST_PP_ITERATION_FINISH_3 >= 76 # define BOOST_PP_ITERATION_3 76 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 77 && BOOST_PP_ITERATION_FINISH_3 >= 77 # define BOOST_PP_ITERATION_3 77 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 78 && BOOST_PP_ITERATION_FINISH_3 >= 78 # define BOOST_PP_ITERATION_3 78 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 79 && BOOST_PP_ITERATION_FINISH_3 >= 79 # define BOOST_PP_ITERATION_3 79 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 80 && BOOST_PP_ITERATION_FINISH_3 >= 80 # define BOOST_PP_ITERATION_3 80 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 81 && BOOST_PP_ITERATION_FINISH_3 >= 81 # define BOOST_PP_ITERATION_3 81 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 82 && BOOST_PP_ITERATION_FINISH_3 >= 82 # define BOOST_PP_ITERATION_3 82 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 83 && BOOST_PP_ITERATION_FINISH_3 >= 83 # define BOOST_PP_ITERATION_3 83 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 84 && BOOST_PP_ITERATION_FINISH_3 >= 84 # define BOOST_PP_ITERATION_3 84 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 85 && BOOST_PP_ITERATION_FINISH_3 >= 85 # define BOOST_PP_ITERATION_3 85 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 86 && BOOST_PP_ITERATION_FINISH_3 >= 86 # define BOOST_PP_ITERATION_3 86 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 87 && BOOST_PP_ITERATION_FINISH_3 >= 87 # define BOOST_PP_ITERATION_3 87 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 88 && BOOST_PP_ITERATION_FINISH_3 >= 88 # define BOOST_PP_ITERATION_3 88 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 89 && BOOST_PP_ITERATION_FINISH_3 >= 89 # define BOOST_PP_ITERATION_3 89 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 90 && BOOST_PP_ITERATION_FINISH_3 >= 90 # define BOOST_PP_ITERATION_3 90 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 91 && BOOST_PP_ITERATION_FINISH_3 >= 91 # define BOOST_PP_ITERATION_3 91 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 92 && BOOST_PP_ITERATION_FINISH_3 >= 92 # define BOOST_PP_ITERATION_3 92 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 93 && BOOST_PP_ITERATION_FINISH_3 >= 93 # define BOOST_PP_ITERATION_3 93 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 94 && BOOST_PP_ITERATION_FINISH_3 >= 94 # define BOOST_PP_ITERATION_3 94 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 95 && BOOST_PP_ITERATION_FINISH_3 >= 95 # define BOOST_PP_ITERATION_3 95 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 96 && BOOST_PP_ITERATION_FINISH_3 >= 96 # define BOOST_PP_ITERATION_3 96 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 97 && BOOST_PP_ITERATION_FINISH_3 >= 97 # define BOOST_PP_ITERATION_3 97 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 98 && BOOST_PP_ITERATION_FINISH_3 >= 98 # define BOOST_PP_ITERATION_3 98 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 99 && BOOST_PP_ITERATION_FINISH_3 >= 99 # define BOOST_PP_ITERATION_3 99 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 100 && BOOST_PP_ITERATION_FINISH_3 >= 100 # define BOOST_PP_ITERATION_3 100 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 101 && BOOST_PP_ITERATION_FINISH_3 >= 101 # define BOOST_PP_ITERATION_3 101 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 102 && BOOST_PP_ITERATION_FINISH_3 >= 102 # define BOOST_PP_ITERATION_3 102 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 103 && BOOST_PP_ITERATION_FINISH_3 >= 103 # define BOOST_PP_ITERATION_3 103 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 104 && BOOST_PP_ITERATION_FINISH_3 >= 104 # define BOOST_PP_ITERATION_3 104 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 105 && BOOST_PP_ITERATION_FINISH_3 >= 105 # define BOOST_PP_ITERATION_3 105 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 106 && BOOST_PP_ITERATION_FINISH_3 >= 106 # define BOOST_PP_ITERATION_3 106 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 107 && BOOST_PP_ITERATION_FINISH_3 >= 107 # define BOOST_PP_ITERATION_3 107 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 108 && BOOST_PP_ITERATION_FINISH_3 >= 108 # define BOOST_PP_ITERATION_3 108 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 109 && BOOST_PP_ITERATION_FINISH_3 >= 109 # define BOOST_PP_ITERATION_3 109 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 110 && BOOST_PP_ITERATION_FINISH_3 >= 110 # define BOOST_PP_ITERATION_3 110 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 111 && BOOST_PP_ITERATION_FINISH_3 >= 111 # define BOOST_PP_ITERATION_3 111 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 112 && BOOST_PP_ITERATION_FINISH_3 >= 112 # define BOOST_PP_ITERATION_3 112 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 113 && BOOST_PP_ITERATION_FINISH_3 >= 113 # define BOOST_PP_ITERATION_3 113 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 114 && BOOST_PP_ITERATION_FINISH_3 >= 114 # define BOOST_PP_ITERATION_3 114 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 115 && BOOST_PP_ITERATION_FINISH_3 >= 115 # define BOOST_PP_ITERATION_3 115 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 116 && BOOST_PP_ITERATION_FINISH_3 >= 116 # define BOOST_PP_ITERATION_3 116 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 117 && BOOST_PP_ITERATION_FINISH_3 >= 117 # define BOOST_PP_ITERATION_3 117 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 118 && BOOST_PP_ITERATION_FINISH_3 >= 118 # define BOOST_PP_ITERATION_3 118 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 119 && BOOST_PP_ITERATION_FINISH_3 >= 119 # define BOOST_PP_ITERATION_3 119 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 120 && BOOST_PP_ITERATION_FINISH_3 >= 120 # define BOOST_PP_ITERATION_3 120 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 121 && BOOST_PP_ITERATION_FINISH_3 >= 121 # define BOOST_PP_ITERATION_3 121 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 122 && BOOST_PP_ITERATION_FINISH_3 >= 122 # define BOOST_PP_ITERATION_3 122 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 123 && BOOST_PP_ITERATION_FINISH_3 >= 123 # define BOOST_PP_ITERATION_3 123 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 124 && BOOST_PP_ITERATION_FINISH_3 >= 124 # define BOOST_PP_ITERATION_3 124 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 125 && BOOST_PP_ITERATION_FINISH_3 >= 125 # define BOOST_PP_ITERATION_3 125 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 126 && BOOST_PP_ITERATION_FINISH_3 >= 126 # define BOOST_PP_ITERATION_3 126 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 127 && BOOST_PP_ITERATION_FINISH_3 >= 127 # define BOOST_PP_ITERATION_3 127 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 128 && BOOST_PP_ITERATION_FINISH_3 >= 128 # define BOOST_PP_ITERATION_3 128 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 129 && BOOST_PP_ITERATION_FINISH_3 >= 129 # define BOOST_PP_ITERATION_3 129 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 130 && BOOST_PP_ITERATION_FINISH_3 >= 130 # define BOOST_PP_ITERATION_3 130 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 131 && BOOST_PP_ITERATION_FINISH_3 >= 131 # define BOOST_PP_ITERATION_3 131 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 132 && BOOST_PP_ITERATION_FINISH_3 >= 132 # define BOOST_PP_ITERATION_3 132 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 133 && BOOST_PP_ITERATION_FINISH_3 >= 133 # define BOOST_PP_ITERATION_3 133 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 134 && BOOST_PP_ITERATION_FINISH_3 >= 134 # define BOOST_PP_ITERATION_3 134 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 135 && BOOST_PP_ITERATION_FINISH_3 >= 135 # define BOOST_PP_ITERATION_3 135 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 136 && BOOST_PP_ITERATION_FINISH_3 >= 136 # define BOOST_PP_ITERATION_3 136 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 137 && BOOST_PP_ITERATION_FINISH_3 >= 137 # define BOOST_PP_ITERATION_3 137 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 138 && BOOST_PP_ITERATION_FINISH_3 >= 138 # define BOOST_PP_ITERATION_3 138 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 139 && BOOST_PP_ITERATION_FINISH_3 >= 139 # define BOOST_PP_ITERATION_3 139 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 140 && BOOST_PP_ITERATION_FINISH_3 >= 140 # define BOOST_PP_ITERATION_3 140 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 141 && BOOST_PP_ITERATION_FINISH_3 >= 141 # define BOOST_PP_ITERATION_3 141 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 142 && BOOST_PP_ITERATION_FINISH_3 >= 142 # define BOOST_PP_ITERATION_3 142 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 143 && BOOST_PP_ITERATION_FINISH_3 >= 143 # define BOOST_PP_ITERATION_3 143 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 144 && BOOST_PP_ITERATION_FINISH_3 >= 144 # define BOOST_PP_ITERATION_3 144 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 145 && BOOST_PP_ITERATION_FINISH_3 >= 145 # define BOOST_PP_ITERATION_3 145 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 146 && BOOST_PP_ITERATION_FINISH_3 >= 146 # define BOOST_PP_ITERATION_3 146 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 147 && BOOST_PP_ITERATION_FINISH_3 >= 147 # define BOOST_PP_ITERATION_3 147 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 148 && BOOST_PP_ITERATION_FINISH_3 >= 148 # define BOOST_PP_ITERATION_3 148 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 149 && BOOST_PP_ITERATION_FINISH_3 >= 149 # define BOOST_PP_ITERATION_3 149 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 150 && BOOST_PP_ITERATION_FINISH_3 >= 150 # define BOOST_PP_ITERATION_3 150 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 151 && BOOST_PP_ITERATION_FINISH_3 >= 151 # define BOOST_PP_ITERATION_3 151 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 152 && BOOST_PP_ITERATION_FINISH_3 >= 152 # define BOOST_PP_ITERATION_3 152 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 153 && BOOST_PP_ITERATION_FINISH_3 >= 153 # define BOOST_PP_ITERATION_3 153 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 154 && BOOST_PP_ITERATION_FINISH_3 >= 154 # define BOOST_PP_ITERATION_3 154 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 155 && BOOST_PP_ITERATION_FINISH_3 >= 155 # define BOOST_PP_ITERATION_3 155 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 156 && BOOST_PP_ITERATION_FINISH_3 >= 156 # define BOOST_PP_ITERATION_3 156 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 157 && BOOST_PP_ITERATION_FINISH_3 >= 157 # define BOOST_PP_ITERATION_3 157 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 158 && BOOST_PP_ITERATION_FINISH_3 >= 158 # define BOOST_PP_ITERATION_3 158 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 159 && BOOST_PP_ITERATION_FINISH_3 >= 159 # define BOOST_PP_ITERATION_3 159 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 160 && BOOST_PP_ITERATION_FINISH_3 >= 160 # define BOOST_PP_ITERATION_3 160 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 161 && BOOST_PP_ITERATION_FINISH_3 >= 161 # define BOOST_PP_ITERATION_3 161 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 162 && BOOST_PP_ITERATION_FINISH_3 >= 162 # define BOOST_PP_ITERATION_3 162 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 163 && BOOST_PP_ITERATION_FINISH_3 >= 163 # define BOOST_PP_ITERATION_3 163 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 164 && BOOST_PP_ITERATION_FINISH_3 >= 164 # define BOOST_PP_ITERATION_3 164 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 165 && BOOST_PP_ITERATION_FINISH_3 >= 165 # define BOOST_PP_ITERATION_3 165 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 166 && BOOST_PP_ITERATION_FINISH_3 >= 166 # define BOOST_PP_ITERATION_3 166 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 167 && BOOST_PP_ITERATION_FINISH_3 >= 167 # define BOOST_PP_ITERATION_3 167 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 168 && BOOST_PP_ITERATION_FINISH_3 >= 168 # define BOOST_PP_ITERATION_3 168 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 169 && BOOST_PP_ITERATION_FINISH_3 >= 169 # define BOOST_PP_ITERATION_3 169 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 170 && BOOST_PP_ITERATION_FINISH_3 >= 170 # define BOOST_PP_ITERATION_3 170 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 171 && BOOST_PP_ITERATION_FINISH_3 >= 171 # define BOOST_PP_ITERATION_3 171 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 172 && BOOST_PP_ITERATION_FINISH_3 >= 172 # define BOOST_PP_ITERATION_3 172 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 173 && BOOST_PP_ITERATION_FINISH_3 >= 173 # define BOOST_PP_ITERATION_3 173 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 174 && BOOST_PP_ITERATION_FINISH_3 >= 174 # define BOOST_PP_ITERATION_3 174 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 175 && BOOST_PP_ITERATION_FINISH_3 >= 175 # define BOOST_PP_ITERATION_3 175 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 176 && BOOST_PP_ITERATION_FINISH_3 >= 176 # define BOOST_PP_ITERATION_3 176 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 177 && BOOST_PP_ITERATION_FINISH_3 >= 177 # define BOOST_PP_ITERATION_3 177 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 178 && BOOST_PP_ITERATION_FINISH_3 >= 178 # define BOOST_PP_ITERATION_3 178 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 179 && BOOST_PP_ITERATION_FINISH_3 >= 179 # define BOOST_PP_ITERATION_3 179 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 180 && BOOST_PP_ITERATION_FINISH_3 >= 180 # define BOOST_PP_ITERATION_3 180 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 181 && BOOST_PP_ITERATION_FINISH_3 >= 181 # define BOOST_PP_ITERATION_3 181 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 182 && BOOST_PP_ITERATION_FINISH_3 >= 182 # define BOOST_PP_ITERATION_3 182 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 183 && BOOST_PP_ITERATION_FINISH_3 >= 183 # define BOOST_PP_ITERATION_3 183 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 184 && BOOST_PP_ITERATION_FINISH_3 >= 184 # define BOOST_PP_ITERATION_3 184 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 185 && BOOST_PP_ITERATION_FINISH_3 >= 185 # define BOOST_PP_ITERATION_3 185 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 186 && BOOST_PP_ITERATION_FINISH_3 >= 186 # define BOOST_PP_ITERATION_3 186 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 187 && BOOST_PP_ITERATION_FINISH_3 >= 187 # define BOOST_PP_ITERATION_3 187 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 188 && BOOST_PP_ITERATION_FINISH_3 >= 188 # define BOOST_PP_ITERATION_3 188 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 189 && BOOST_PP_ITERATION_FINISH_3 >= 189 # define BOOST_PP_ITERATION_3 189 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 190 && BOOST_PP_ITERATION_FINISH_3 >= 190 # define BOOST_PP_ITERATION_3 190 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 191 && BOOST_PP_ITERATION_FINISH_3 >= 191 # define BOOST_PP_ITERATION_3 191 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 192 && BOOST_PP_ITERATION_FINISH_3 >= 192 # define BOOST_PP_ITERATION_3 192 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 193 && BOOST_PP_ITERATION_FINISH_3 >= 193 # define BOOST_PP_ITERATION_3 193 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 194 && BOOST_PP_ITERATION_FINISH_3 >= 194 # define BOOST_PP_ITERATION_3 194 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 195 && BOOST_PP_ITERATION_FINISH_3 >= 195 # define BOOST_PP_ITERATION_3 195 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 196 && BOOST_PP_ITERATION_FINISH_3 >= 196 # define BOOST_PP_ITERATION_3 196 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 197 && BOOST_PP_ITERATION_FINISH_3 >= 197 # define BOOST_PP_ITERATION_3 197 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 198 && BOOST_PP_ITERATION_FINISH_3 >= 198 # define BOOST_PP_ITERATION_3 198 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 199 && BOOST_PP_ITERATION_FINISH_3 >= 199 # define BOOST_PP_ITERATION_3 199 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 200 && BOOST_PP_ITERATION_FINISH_3 >= 200 # define BOOST_PP_ITERATION_3 200 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 201 && BOOST_PP_ITERATION_FINISH_3 >= 201 # define BOOST_PP_ITERATION_3 201 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 202 && BOOST_PP_ITERATION_FINISH_3 >= 202 # define BOOST_PP_ITERATION_3 202 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 203 && BOOST_PP_ITERATION_FINISH_3 >= 203 # define BOOST_PP_ITERATION_3 203 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 204 && BOOST_PP_ITERATION_FINISH_3 >= 204 # define BOOST_PP_ITERATION_3 204 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 205 && BOOST_PP_ITERATION_FINISH_3 >= 205 # define BOOST_PP_ITERATION_3 205 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 206 && BOOST_PP_ITERATION_FINISH_3 >= 206 # define BOOST_PP_ITERATION_3 206 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 207 && BOOST_PP_ITERATION_FINISH_3 >= 207 # define BOOST_PP_ITERATION_3 207 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 208 && BOOST_PP_ITERATION_FINISH_3 >= 208 # define BOOST_PP_ITERATION_3 208 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 209 && BOOST_PP_ITERATION_FINISH_3 >= 209 # define BOOST_PP_ITERATION_3 209 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 210 && BOOST_PP_ITERATION_FINISH_3 >= 210 # define BOOST_PP_ITERATION_3 210 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 211 && BOOST_PP_ITERATION_FINISH_3 >= 211 # define BOOST_PP_ITERATION_3 211 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 212 && BOOST_PP_ITERATION_FINISH_3 >= 212 # define BOOST_PP_ITERATION_3 212 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 213 && BOOST_PP_ITERATION_FINISH_3 >= 213 # define BOOST_PP_ITERATION_3 213 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 214 && BOOST_PP_ITERATION_FINISH_3 >= 214 # define BOOST_PP_ITERATION_3 214 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 215 && BOOST_PP_ITERATION_FINISH_3 >= 215 # define BOOST_PP_ITERATION_3 215 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 216 && BOOST_PP_ITERATION_FINISH_3 >= 216 # define BOOST_PP_ITERATION_3 216 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 217 && BOOST_PP_ITERATION_FINISH_3 >= 217 # define BOOST_PP_ITERATION_3 217 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 218 && BOOST_PP_ITERATION_FINISH_3 >= 218 # define BOOST_PP_ITERATION_3 218 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 219 && BOOST_PP_ITERATION_FINISH_3 >= 219 # define BOOST_PP_ITERATION_3 219 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 220 && BOOST_PP_ITERATION_FINISH_3 >= 220 # define BOOST_PP_ITERATION_3 220 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 221 && BOOST_PP_ITERATION_FINISH_3 >= 221 # define BOOST_PP_ITERATION_3 221 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 222 && BOOST_PP_ITERATION_FINISH_3 >= 222 # define BOOST_PP_ITERATION_3 222 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 223 && BOOST_PP_ITERATION_FINISH_3 >= 223 # define BOOST_PP_ITERATION_3 223 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 224 && BOOST_PP_ITERATION_FINISH_3 >= 224 # define BOOST_PP_ITERATION_3 224 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 225 && BOOST_PP_ITERATION_FINISH_3 >= 225 # define BOOST_PP_ITERATION_3 225 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 226 && BOOST_PP_ITERATION_FINISH_3 >= 226 # define BOOST_PP_ITERATION_3 226 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 227 && BOOST_PP_ITERATION_FINISH_3 >= 227 # define BOOST_PP_ITERATION_3 227 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 228 && BOOST_PP_ITERATION_FINISH_3 >= 228 # define BOOST_PP_ITERATION_3 228 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 229 && BOOST_PP_ITERATION_FINISH_3 >= 229 # define BOOST_PP_ITERATION_3 229 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 230 && BOOST_PP_ITERATION_FINISH_3 >= 230 # define BOOST_PP_ITERATION_3 230 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 231 && BOOST_PP_ITERATION_FINISH_3 >= 231 # define BOOST_PP_ITERATION_3 231 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 232 && BOOST_PP_ITERATION_FINISH_3 >= 232 # define BOOST_PP_ITERATION_3 232 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 233 && BOOST_PP_ITERATION_FINISH_3 >= 233 # define BOOST_PP_ITERATION_3 233 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 234 && BOOST_PP_ITERATION_FINISH_3 >= 234 # define BOOST_PP_ITERATION_3 234 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 235 && BOOST_PP_ITERATION_FINISH_3 >= 235 # define BOOST_PP_ITERATION_3 235 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 236 && BOOST_PP_ITERATION_FINISH_3 >= 236 # define BOOST_PP_ITERATION_3 236 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 237 && BOOST_PP_ITERATION_FINISH_3 >= 237 # define BOOST_PP_ITERATION_3 237 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 238 && BOOST_PP_ITERATION_FINISH_3 >= 238 # define BOOST_PP_ITERATION_3 238 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 239 && BOOST_PP_ITERATION_FINISH_3 >= 239 # define BOOST_PP_ITERATION_3 239 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 240 && BOOST_PP_ITERATION_FINISH_3 >= 240 # define BOOST_PP_ITERATION_3 240 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 241 && BOOST_PP_ITERATION_FINISH_3 >= 241 # define BOOST_PP_ITERATION_3 241 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 242 && BOOST_PP_ITERATION_FINISH_3 >= 242 # define BOOST_PP_ITERATION_3 242 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 243 && BOOST_PP_ITERATION_FINISH_3 >= 243 # define BOOST_PP_ITERATION_3 243 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 244 && BOOST_PP_ITERATION_FINISH_3 >= 244 # define BOOST_PP_ITERATION_3 244 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 245 && BOOST_PP_ITERATION_FINISH_3 >= 245 # define BOOST_PP_ITERATION_3 245 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 246 && BOOST_PP_ITERATION_FINISH_3 >= 246 # define BOOST_PP_ITERATION_3 246 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 247 && BOOST_PP_ITERATION_FINISH_3 >= 247 # define BOOST_PP_ITERATION_3 247 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 248 && BOOST_PP_ITERATION_FINISH_3 >= 248 # define BOOST_PP_ITERATION_3 248 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 249 && BOOST_PP_ITERATION_FINISH_3 >= 249 # define BOOST_PP_ITERATION_3 249 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 250 && BOOST_PP_ITERATION_FINISH_3 >= 250 # define BOOST_PP_ITERATION_3 250 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 251 && BOOST_PP_ITERATION_FINISH_3 >= 251 # define BOOST_PP_ITERATION_3 251 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 252 && BOOST_PP_ITERATION_FINISH_3 >= 252 # define BOOST_PP_ITERATION_3 252 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 253 && BOOST_PP_ITERATION_FINISH_3 >= 253 # define BOOST_PP_ITERATION_3 253 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 254 && BOOST_PP_ITERATION_FINISH_3 >= 254 # define BOOST_PP_ITERATION_3 254 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 255 && BOOST_PP_ITERATION_FINISH_3 >= 255 # define BOOST_PP_ITERATION_3 255 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # if BOOST_PP_ITERATION_START_3 <= 256 && BOOST_PP_ITERATION_FINISH_3 >= 256 # define BOOST_PP_ITERATION_3 256 # include BOOST_PP_FILENAME_3 # undef BOOST_PP_ITERATION_3 # endif # endif # # undef BOOST_PP_ITERATION_DEPTH # define BOOST_PP_ITERATION_DEPTH() 2 # # undef BOOST_PP_ITERATION_START_3 # undef BOOST_PP_ITERATION_FINISH_3 # undef BOOST_PP_FILENAME_3 # # undef BOOST_PP_ITERATION_FLAGS_3 # undef BOOST_PP_ITERATION_PARAMS_3 ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000755000175000017500000000000012146213764031746 5ustar debiandebian././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/lower4.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000775711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_START_4 # # undef BOOST_PP_ITERATION_START_4_DIGIT_1 # undef BOOST_PP_ITERATION_START_4_DIGIT_2 # undef BOOST_PP_ITERATION_START_4_DIGIT_3 # undef BOOST_PP_ITERATION_START_4_DIGIT_4 # undef BOOST_PP_ITERATION_START_4_DIGIT_5 # undef BOOST_PP_ITERATION_START_4_DIGIT_6 # undef BOOST_PP_ITERATION_START_4_DIGIT_7 # undef BOOST_PP_ITERATION_START_4_DIGIT_8 # undef BOOST_PP_ITERATION_START_4_DIGIT_9 # undef BOOST_PP_ITERATION_START_4_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_START_4_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_START_4_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_START_4_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_START_4_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_START_4_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_START_4_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_START_4_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_START_4_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_START_4_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_START_4_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_START_4_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_START_4_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_START_4_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_START_4_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_START_4_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_START_4_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_START_4_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_START_4_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_START_4_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_START_4_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_START_4_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_START_4_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_START_4_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_START_4_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_START_4_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_START_4_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_START_4_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_START_4_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_START_4_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_START_4_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_START_4_DIGIT_3 # define BOOST_PP_ITERATION_START_4 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_START_4_DIGIT_3, BOOST_PP_ITERATION_START_4_DIGIT_2, BOOST_PP_ITERATION_START_4_DIGIT_1) # elif BOOST_PP_ITERATION_START_4_DIGIT_2 # define BOOST_PP_ITERATION_START_4 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_START_4_DIGIT_2, BOOST_PP_ITERATION_START_4_DIGIT_1) # else # define BOOST_PP_ITERATION_START_4 BOOST_PP_ITERATION_START_4_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/upper2.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000001004311344301502031731 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_FINISH_2 # # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_1 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_2 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_3 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_4 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_5 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_6 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_7 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_8 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_9 # undef BOOST_PP_ITERATION_FINISH_2_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_FINISH_2_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_FINISH_2_DIGIT_3 # define BOOST_PP_ITERATION_FINISH_2 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_FINISH_2_DIGIT_3, BOOST_PP_ITERATION_FINISH_2_DIGIT_2, BOOST_PP_ITERATION_FINISH_2_DIGIT_1) # elif BOOST_PP_ITERATION_FINISH_2_DIGIT_2 # define BOOST_PP_ITERATION_FINISH_2 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_2_DIGIT_2, BOOST_PP_ITERATION_FINISH_2_DIGIT_1) # else # define BOOST_PP_ITERATION_FINISH_2 BOOST_PP_ITERATION_FINISH_2_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/lower3.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000775711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_START_3 # # undef BOOST_PP_ITERATION_START_3_DIGIT_1 # undef BOOST_PP_ITERATION_START_3_DIGIT_2 # undef BOOST_PP_ITERATION_START_3_DIGIT_3 # undef BOOST_PP_ITERATION_START_3_DIGIT_4 # undef BOOST_PP_ITERATION_START_3_DIGIT_5 # undef BOOST_PP_ITERATION_START_3_DIGIT_6 # undef BOOST_PP_ITERATION_START_3_DIGIT_7 # undef BOOST_PP_ITERATION_START_3_DIGIT_8 # undef BOOST_PP_ITERATION_START_3_DIGIT_9 # undef BOOST_PP_ITERATION_START_3_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_START_3_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_START_3_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_START_3_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_START_3_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_START_3_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_START_3_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_START_3_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_START_3_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_START_3_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_START_3_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_START_3_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_START_3_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_START_3_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_START_3_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_START_3_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_START_3_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_START_3_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_START_3_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_START_3_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_START_3_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_START_3_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_START_3_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_START_3_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_START_3_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_START_3_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_START_3_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_START_3_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_START_3_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_START_3_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_START_3_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_START_3_DIGIT_3 # define BOOST_PP_ITERATION_START_3 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_START_3_DIGIT_3, BOOST_PP_ITERATION_START_3_DIGIT_2, BOOST_PP_ITERATION_START_3_DIGIT_1) # elif BOOST_PP_ITERATION_START_3_DIGIT_2 # define BOOST_PP_ITERATION_START_3 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_START_3_DIGIT_2, BOOST_PP_ITERATION_START_3_DIGIT_1) # else # define BOOST_PP_ITERATION_START_3 BOOST_PP_ITERATION_START_3_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/upper1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000001004311344301502031731 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_FINISH_1 # # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_1 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_2 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_3 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_4 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_5 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_6 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_7 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_8 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_9 # undef BOOST_PP_ITERATION_FINISH_1_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_FINISH_1_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_FINISH_1_DIGIT_3 # define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_FINISH_1_DIGIT_3, BOOST_PP_ITERATION_FINISH_1_DIGIT_2, BOOST_PP_ITERATION_FINISH_1_DIGIT_1) # elif BOOST_PP_ITERATION_FINISH_1_DIGIT_2 # define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_1_DIGIT_2, BOOST_PP_ITERATION_FINISH_1_DIGIT_1) # else # define BOOST_PP_ITERATION_FINISH_1 BOOST_PP_ITERATION_FINISH_1_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/lower2.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000775711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_START_2 # # undef BOOST_PP_ITERATION_START_2_DIGIT_1 # undef BOOST_PP_ITERATION_START_2_DIGIT_2 # undef BOOST_PP_ITERATION_START_2_DIGIT_3 # undef BOOST_PP_ITERATION_START_2_DIGIT_4 # undef BOOST_PP_ITERATION_START_2_DIGIT_5 # undef BOOST_PP_ITERATION_START_2_DIGIT_6 # undef BOOST_PP_ITERATION_START_2_DIGIT_7 # undef BOOST_PP_ITERATION_START_2_DIGIT_8 # undef BOOST_PP_ITERATION_START_2_DIGIT_9 # undef BOOST_PP_ITERATION_START_2_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_START_2_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_START_2_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_START_2_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_START_2_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_START_2_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_START_2_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_START_2_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_START_2_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_START_2_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_START_2_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_START_2_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_START_2_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_START_2_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_START_2_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_START_2_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_START_2_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_START_2_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_START_2_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_START_2_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_START_2_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_START_2_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_START_2_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_START_2_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_START_2_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_START_2_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_START_2_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_START_2_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_START_2_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_START_2_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_START_2_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_START_2_DIGIT_3 # define BOOST_PP_ITERATION_START_2 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_START_2_DIGIT_3, BOOST_PP_ITERATION_START_2_DIGIT_2, BOOST_PP_ITERATION_START_2_DIGIT_1) # elif BOOST_PP_ITERATION_START_2_DIGIT_2 # define BOOST_PP_ITERATION_START_2 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_START_2_DIGIT_2, BOOST_PP_ITERATION_START_2_DIGIT_1) # else # define BOOST_PP_ITERATION_START_2 BOOST_PP_ITERATION_START_2_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/lower1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000775711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_START_1 # # undef BOOST_PP_ITERATION_START_1_DIGIT_1 # undef BOOST_PP_ITERATION_START_1_DIGIT_2 # undef BOOST_PP_ITERATION_START_1_DIGIT_3 # undef BOOST_PP_ITERATION_START_1_DIGIT_4 # undef BOOST_PP_ITERATION_START_1_DIGIT_5 # undef BOOST_PP_ITERATION_START_1_DIGIT_6 # undef BOOST_PP_ITERATION_START_1_DIGIT_7 # undef BOOST_PP_ITERATION_START_1_DIGIT_8 # undef BOOST_PP_ITERATION_START_1_DIGIT_9 # undef BOOST_PP_ITERATION_START_1_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_START_1_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_START_1_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_START_1_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_START_1_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_START_1_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_START_1_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_START_1_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_START_1_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_START_1_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_START_1_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_START_1_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_START_1_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_START_1_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_START_1_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_START_1_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_START_1_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_START_1_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_START_1_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_START_1_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_START_1_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_START_1_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_START_1_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_START_1_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_START_1_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_START_1_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_START_1_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_START_1_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_START_1_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_START_1_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_START_1_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_START_1_DIGIT_3 # define BOOST_PP_ITERATION_START_1 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_START_1_DIGIT_3, BOOST_PP_ITERATION_START_1_DIGIT_2, BOOST_PP_ITERATION_START_1_DIGIT_1) # elif BOOST_PP_ITERATION_START_1_DIGIT_2 # define BOOST_PP_ITERATION_START_1 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_START_1_DIGIT_2, BOOST_PP_ITERATION_START_1_DIGIT_1) # else # define BOOST_PP_ITERATION_START_1 BOOST_PP_ITERATION_START_1_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/lower5.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000775711344301502031753 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_START_5 # # undef BOOST_PP_ITERATION_START_5_DIGIT_1 # undef BOOST_PP_ITERATION_START_5_DIGIT_2 # undef BOOST_PP_ITERATION_START_5_DIGIT_3 # undef BOOST_PP_ITERATION_START_5_DIGIT_4 # undef BOOST_PP_ITERATION_START_5_DIGIT_5 # undef BOOST_PP_ITERATION_START_5_DIGIT_6 # undef BOOST_PP_ITERATION_START_5_DIGIT_7 # undef BOOST_PP_ITERATION_START_5_DIGIT_8 # undef BOOST_PP_ITERATION_START_5_DIGIT_9 # undef BOOST_PP_ITERATION_START_5_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_START_5_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_START_5_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_START_5_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_START_5_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_START_5_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_START_5_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_START_5_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_START_5_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_START_5_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_START_5_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_START_5_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_START_5_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_START_5_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_START_5_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_START_5_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_START_5_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_START_5_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_START_5_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_START_5_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_START_5_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_START_5_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_START_5_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_START_5_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_START_5_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_START_5_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_START_5_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_START_5_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_START_5_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_START_5_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_START_5_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_START_5_DIGIT_3 # define BOOST_PP_ITERATION_START_5 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_START_5_DIGIT_3, BOOST_PP_ITERATION_START_5_DIGIT_2, BOOST_PP_ITERATION_START_5_DIGIT_1) # elif BOOST_PP_ITERATION_START_5_DIGIT_2 # define BOOST_PP_ITERATION_START_5 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_START_5_DIGIT_2, BOOST_PP_ITERATION_START_5_DIGIT_1) # else # define BOOST_PP_ITERATION_START_5 BOOST_PP_ITERATION_START_5_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/upper4.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000001004311344301502031731 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_FINISH_4 # # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_1 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_2 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_3 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_4 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_5 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_6 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_7 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_8 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_9 # undef BOOST_PP_ITERATION_FINISH_4_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_FINISH_4_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_FINISH_4_DIGIT_3 # define BOOST_PP_ITERATION_FINISH_4 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_FINISH_4_DIGIT_3, BOOST_PP_ITERATION_FINISH_4_DIGIT_2, BOOST_PP_ITERATION_FINISH_4_DIGIT_1) # elif BOOST_PP_ITERATION_FINISH_4_DIGIT_2 # define BOOST_PP_ITERATION_FINISH_4 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_4_DIGIT_2, BOOST_PP_ITERATION_FINISH_4_DIGIT_1) # else # define BOOST_PP_ITERATION_FINISH_4 BOOST_PP_ITERATION_FINISH_4_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/upper3.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000001004311344301502031731 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_FINISH_3 # # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_1 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_2 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_3 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_4 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_5 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_6 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_7 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_8 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_9 # undef BOOST_PP_ITERATION_FINISH_3_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_FINISH_3_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_FINISH_3_DIGIT_3 # define BOOST_PP_ITERATION_FINISH_3 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_FINISH_3_DIGIT_3, BOOST_PP_ITERATION_FINISH_3_DIGIT_2, BOOST_PP_ITERATION_FINISH_3_DIGIT_1) # elif BOOST_PP_ITERATION_FINISH_3_DIGIT_2 # define BOOST_PP_ITERATION_FINISH_3 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_3_DIGIT_2, BOOST_PP_ITERATION_FINISH_3_DIGIT_1) # else # define BOOST_PP_ITERATION_FINISH_3 BOOST_PP_ITERATION_FINISH_3_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/bounds/upper5.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000001004311344301502031731 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_ITERATION_FINISH_5 # # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_1 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_2 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_3 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_4 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_5 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_6 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_7 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_8 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_9 # undef BOOST_PP_ITERATION_FINISH_5_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_ITERATION_FINISH_5_DIGIT_1 9 # endif # # if BOOST_PP_ITERATION_FINISH_5_DIGIT_3 # define BOOST_PP_ITERATION_FINISH_5 BOOST_PP_SLOT_CC_3(BOOST_PP_ITERATION_FINISH_5_DIGIT_3, BOOST_PP_ITERATION_FINISH_5_DIGIT_2, BOOST_PP_ITERATION_FINISH_5_DIGIT_1) # elif BOOST_PP_ITERATION_FINISH_5_DIGIT_2 # define BOOST_PP_ITERATION_FINISH_5 BOOST_PP_SLOT_CC_2(BOOST_PP_ITERATION_FINISH_5_DIGIT_2, BOOST_PP_ITERATION_FINISH_5_DIGIT_1) # else # define BOOST_PP_ITERATION_FINISH_5 BOOST_PP_ITERATION_FINISH_5_DIGIT_1 # endif ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/local.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000005044111344301502031737 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if !defined(BOOST_PP_LOCAL_LIMITS) # error BOOST_PP_ERROR: local iteration boundaries are not defined # elif !defined(BOOST_PP_LOCAL_MACRO) # error BOOST_PP_ERROR: local iteration target macro is not defined # else # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LOCAL_S BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_LOCAL_LIMITS) # define BOOST_PP_LOCAL_F BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_LOCAL_LIMITS) # else # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_LOCAL_LIMITS) # include # define BOOST_PP_VALUE BOOST_PP_TUPLE_ELEM(2, 1, BOOST_PP_LOCAL_LIMITS) # include # define BOOST_PP_LOCAL_S BOOST_PP_LOCAL_SE() # define BOOST_PP_LOCAL_F BOOST_PP_LOCAL_FE() # endif # endif # # if (BOOST_PP_LOCAL_S) > (BOOST_PP_LOCAL_F) # include # else # if BOOST_PP_LOCAL_C(0) BOOST_PP_LOCAL_MACRO(0) # endif # if BOOST_PP_LOCAL_C(1) BOOST_PP_LOCAL_MACRO(1) # endif # if BOOST_PP_LOCAL_C(2) BOOST_PP_LOCAL_MACRO(2) # endif # if BOOST_PP_LOCAL_C(3) BOOST_PP_LOCAL_MACRO(3) # endif # if BOOST_PP_LOCAL_C(4) BOOST_PP_LOCAL_MACRO(4) # endif # if BOOST_PP_LOCAL_C(5) BOOST_PP_LOCAL_MACRO(5) # endif # if BOOST_PP_LOCAL_C(6) BOOST_PP_LOCAL_MACRO(6) # endif # if BOOST_PP_LOCAL_C(7) BOOST_PP_LOCAL_MACRO(7) # endif # if BOOST_PP_LOCAL_C(8) BOOST_PP_LOCAL_MACRO(8) # endif # if BOOST_PP_LOCAL_C(9) BOOST_PP_LOCAL_MACRO(9) # endif # if BOOST_PP_LOCAL_C(10) BOOST_PP_LOCAL_MACRO(10) # endif # if BOOST_PP_LOCAL_C(11) BOOST_PP_LOCAL_MACRO(11) # endif # if BOOST_PP_LOCAL_C(12) BOOST_PP_LOCAL_MACRO(12) # endif # if BOOST_PP_LOCAL_C(13) BOOST_PP_LOCAL_MACRO(13) # endif # if BOOST_PP_LOCAL_C(14) BOOST_PP_LOCAL_MACRO(14) # endif # if BOOST_PP_LOCAL_C(15) BOOST_PP_LOCAL_MACRO(15) # endif # if BOOST_PP_LOCAL_C(16) BOOST_PP_LOCAL_MACRO(16) # endif # if BOOST_PP_LOCAL_C(17) BOOST_PP_LOCAL_MACRO(17) # endif # if BOOST_PP_LOCAL_C(18) BOOST_PP_LOCAL_MACRO(18) # endif # if BOOST_PP_LOCAL_C(19) BOOST_PP_LOCAL_MACRO(19) # endif # if BOOST_PP_LOCAL_C(20) BOOST_PP_LOCAL_MACRO(20) # endif # if BOOST_PP_LOCAL_C(21) BOOST_PP_LOCAL_MACRO(21) # endif # if BOOST_PP_LOCAL_C(22) BOOST_PP_LOCAL_MACRO(22) # endif # if BOOST_PP_LOCAL_C(23) BOOST_PP_LOCAL_MACRO(23) # endif # if BOOST_PP_LOCAL_C(24) BOOST_PP_LOCAL_MACRO(24) # endif # if BOOST_PP_LOCAL_C(25) BOOST_PP_LOCAL_MACRO(25) # endif # if BOOST_PP_LOCAL_C(26) BOOST_PP_LOCAL_MACRO(26) # endif # if BOOST_PP_LOCAL_C(27) BOOST_PP_LOCAL_MACRO(27) # endif # if BOOST_PP_LOCAL_C(28) BOOST_PP_LOCAL_MACRO(28) # endif # if BOOST_PP_LOCAL_C(29) BOOST_PP_LOCAL_MACRO(29) # endif # if BOOST_PP_LOCAL_C(30) BOOST_PP_LOCAL_MACRO(30) # endif # if BOOST_PP_LOCAL_C(31) BOOST_PP_LOCAL_MACRO(31) # endif # if BOOST_PP_LOCAL_C(32) BOOST_PP_LOCAL_MACRO(32) # endif # if BOOST_PP_LOCAL_C(33) BOOST_PP_LOCAL_MACRO(33) # endif # if BOOST_PP_LOCAL_C(34) BOOST_PP_LOCAL_MACRO(34) # endif # if BOOST_PP_LOCAL_C(35) BOOST_PP_LOCAL_MACRO(35) # endif # if BOOST_PP_LOCAL_C(36) BOOST_PP_LOCAL_MACRO(36) # endif # if BOOST_PP_LOCAL_C(37) BOOST_PP_LOCAL_MACRO(37) # endif # if BOOST_PP_LOCAL_C(38) BOOST_PP_LOCAL_MACRO(38) # endif # if BOOST_PP_LOCAL_C(39) BOOST_PP_LOCAL_MACRO(39) # endif # if BOOST_PP_LOCAL_C(40) BOOST_PP_LOCAL_MACRO(40) # endif # if BOOST_PP_LOCAL_C(41) BOOST_PP_LOCAL_MACRO(41) # endif # if BOOST_PP_LOCAL_C(42) BOOST_PP_LOCAL_MACRO(42) # endif # if BOOST_PP_LOCAL_C(43) BOOST_PP_LOCAL_MACRO(43) # endif # if BOOST_PP_LOCAL_C(44) BOOST_PP_LOCAL_MACRO(44) # endif # if BOOST_PP_LOCAL_C(45) BOOST_PP_LOCAL_MACRO(45) # endif # if BOOST_PP_LOCAL_C(46) BOOST_PP_LOCAL_MACRO(46) # endif # if BOOST_PP_LOCAL_C(47) BOOST_PP_LOCAL_MACRO(47) # endif # if BOOST_PP_LOCAL_C(48) BOOST_PP_LOCAL_MACRO(48) # endif # if BOOST_PP_LOCAL_C(49) BOOST_PP_LOCAL_MACRO(49) # endif # if BOOST_PP_LOCAL_C(50) BOOST_PP_LOCAL_MACRO(50) # endif # if BOOST_PP_LOCAL_C(51) BOOST_PP_LOCAL_MACRO(51) # endif # if BOOST_PP_LOCAL_C(52) BOOST_PP_LOCAL_MACRO(52) # endif # if BOOST_PP_LOCAL_C(53) BOOST_PP_LOCAL_MACRO(53) # endif # if BOOST_PP_LOCAL_C(54) BOOST_PP_LOCAL_MACRO(54) # endif # if BOOST_PP_LOCAL_C(55) BOOST_PP_LOCAL_MACRO(55) # endif # if BOOST_PP_LOCAL_C(56) BOOST_PP_LOCAL_MACRO(56) # endif # if BOOST_PP_LOCAL_C(57) BOOST_PP_LOCAL_MACRO(57) # endif # if BOOST_PP_LOCAL_C(58) BOOST_PP_LOCAL_MACRO(58) # endif # if BOOST_PP_LOCAL_C(59) BOOST_PP_LOCAL_MACRO(59) # endif # if BOOST_PP_LOCAL_C(60) BOOST_PP_LOCAL_MACRO(60) # endif # if BOOST_PP_LOCAL_C(61) BOOST_PP_LOCAL_MACRO(61) # endif # if BOOST_PP_LOCAL_C(62) BOOST_PP_LOCAL_MACRO(62) # endif # if BOOST_PP_LOCAL_C(63) BOOST_PP_LOCAL_MACRO(63) # endif # if BOOST_PP_LOCAL_C(64) BOOST_PP_LOCAL_MACRO(64) # endif # if BOOST_PP_LOCAL_C(65) BOOST_PP_LOCAL_MACRO(65) # endif # if BOOST_PP_LOCAL_C(66) BOOST_PP_LOCAL_MACRO(66) # endif # if BOOST_PP_LOCAL_C(67) BOOST_PP_LOCAL_MACRO(67) # endif # if BOOST_PP_LOCAL_C(68) BOOST_PP_LOCAL_MACRO(68) # endif # if BOOST_PP_LOCAL_C(69) BOOST_PP_LOCAL_MACRO(69) # endif # if BOOST_PP_LOCAL_C(70) BOOST_PP_LOCAL_MACRO(70) # endif # if BOOST_PP_LOCAL_C(71) BOOST_PP_LOCAL_MACRO(71) # endif # if BOOST_PP_LOCAL_C(72) BOOST_PP_LOCAL_MACRO(72) # endif # if BOOST_PP_LOCAL_C(73) BOOST_PP_LOCAL_MACRO(73) # endif # if BOOST_PP_LOCAL_C(74) BOOST_PP_LOCAL_MACRO(74) # endif # if BOOST_PP_LOCAL_C(75) BOOST_PP_LOCAL_MACRO(75) # endif # if BOOST_PP_LOCAL_C(76) BOOST_PP_LOCAL_MACRO(76) # endif # if BOOST_PP_LOCAL_C(77) BOOST_PP_LOCAL_MACRO(77) # endif # if BOOST_PP_LOCAL_C(78) BOOST_PP_LOCAL_MACRO(78) # endif # if BOOST_PP_LOCAL_C(79) BOOST_PP_LOCAL_MACRO(79) # endif # if BOOST_PP_LOCAL_C(80) BOOST_PP_LOCAL_MACRO(80) # endif # if BOOST_PP_LOCAL_C(81) BOOST_PP_LOCAL_MACRO(81) # endif # if BOOST_PP_LOCAL_C(82) BOOST_PP_LOCAL_MACRO(82) # endif # if BOOST_PP_LOCAL_C(83) BOOST_PP_LOCAL_MACRO(83) # endif # if BOOST_PP_LOCAL_C(84) BOOST_PP_LOCAL_MACRO(84) # endif # if BOOST_PP_LOCAL_C(85) BOOST_PP_LOCAL_MACRO(85) # endif # if BOOST_PP_LOCAL_C(86) BOOST_PP_LOCAL_MACRO(86) # endif # if BOOST_PP_LOCAL_C(87) BOOST_PP_LOCAL_MACRO(87) # endif # if BOOST_PP_LOCAL_C(88) BOOST_PP_LOCAL_MACRO(88) # endif # if BOOST_PP_LOCAL_C(89) BOOST_PP_LOCAL_MACRO(89) # endif # if BOOST_PP_LOCAL_C(90) BOOST_PP_LOCAL_MACRO(90) # endif # if BOOST_PP_LOCAL_C(91) BOOST_PP_LOCAL_MACRO(91) # endif # if BOOST_PP_LOCAL_C(92) BOOST_PP_LOCAL_MACRO(92) # endif # if BOOST_PP_LOCAL_C(93) BOOST_PP_LOCAL_MACRO(93) # endif # if BOOST_PP_LOCAL_C(94) BOOST_PP_LOCAL_MACRO(94) # endif # if BOOST_PP_LOCAL_C(95) BOOST_PP_LOCAL_MACRO(95) # endif # if BOOST_PP_LOCAL_C(96) BOOST_PP_LOCAL_MACRO(96) # endif # if BOOST_PP_LOCAL_C(97) BOOST_PP_LOCAL_MACRO(97) # endif # if BOOST_PP_LOCAL_C(98) BOOST_PP_LOCAL_MACRO(98) # endif # if BOOST_PP_LOCAL_C(99) BOOST_PP_LOCAL_MACRO(99) # endif # if BOOST_PP_LOCAL_C(100) BOOST_PP_LOCAL_MACRO(100) # endif # if BOOST_PP_LOCAL_C(101) BOOST_PP_LOCAL_MACRO(101) # endif # if BOOST_PP_LOCAL_C(102) BOOST_PP_LOCAL_MACRO(102) # endif # if BOOST_PP_LOCAL_C(103) BOOST_PP_LOCAL_MACRO(103) # endif # if BOOST_PP_LOCAL_C(104) BOOST_PP_LOCAL_MACRO(104) # endif # if BOOST_PP_LOCAL_C(105) BOOST_PP_LOCAL_MACRO(105) # endif # if BOOST_PP_LOCAL_C(106) BOOST_PP_LOCAL_MACRO(106) # endif # if BOOST_PP_LOCAL_C(107) BOOST_PP_LOCAL_MACRO(107) # endif # if BOOST_PP_LOCAL_C(108) BOOST_PP_LOCAL_MACRO(108) # endif # if BOOST_PP_LOCAL_C(109) BOOST_PP_LOCAL_MACRO(109) # endif # if BOOST_PP_LOCAL_C(110) BOOST_PP_LOCAL_MACRO(110) # endif # if BOOST_PP_LOCAL_C(111) BOOST_PP_LOCAL_MACRO(111) # endif # if BOOST_PP_LOCAL_C(112) BOOST_PP_LOCAL_MACRO(112) # endif # if BOOST_PP_LOCAL_C(113) BOOST_PP_LOCAL_MACRO(113) # endif # if BOOST_PP_LOCAL_C(114) BOOST_PP_LOCAL_MACRO(114) # endif # if BOOST_PP_LOCAL_C(115) BOOST_PP_LOCAL_MACRO(115) # endif # if BOOST_PP_LOCAL_C(116) BOOST_PP_LOCAL_MACRO(116) # endif # if BOOST_PP_LOCAL_C(117) BOOST_PP_LOCAL_MACRO(117) # endif # if BOOST_PP_LOCAL_C(118) BOOST_PP_LOCAL_MACRO(118) # endif # if BOOST_PP_LOCAL_C(119) BOOST_PP_LOCAL_MACRO(119) # endif # if BOOST_PP_LOCAL_C(120) BOOST_PP_LOCAL_MACRO(120) # endif # if BOOST_PP_LOCAL_C(121) BOOST_PP_LOCAL_MACRO(121) # endif # if BOOST_PP_LOCAL_C(122) BOOST_PP_LOCAL_MACRO(122) # endif # if BOOST_PP_LOCAL_C(123) BOOST_PP_LOCAL_MACRO(123) # endif # if BOOST_PP_LOCAL_C(124) BOOST_PP_LOCAL_MACRO(124) # endif # if BOOST_PP_LOCAL_C(125) BOOST_PP_LOCAL_MACRO(125) # endif # if BOOST_PP_LOCAL_C(126) BOOST_PP_LOCAL_MACRO(126) # endif # if BOOST_PP_LOCAL_C(127) BOOST_PP_LOCAL_MACRO(127) # endif # if BOOST_PP_LOCAL_C(128) BOOST_PP_LOCAL_MACRO(128) # endif # if BOOST_PP_LOCAL_C(129) BOOST_PP_LOCAL_MACRO(129) # endif # if BOOST_PP_LOCAL_C(130) BOOST_PP_LOCAL_MACRO(130) # endif # if BOOST_PP_LOCAL_C(131) BOOST_PP_LOCAL_MACRO(131) # endif # if BOOST_PP_LOCAL_C(132) BOOST_PP_LOCAL_MACRO(132) # endif # if BOOST_PP_LOCAL_C(133) BOOST_PP_LOCAL_MACRO(133) # endif # if BOOST_PP_LOCAL_C(134) BOOST_PP_LOCAL_MACRO(134) # endif # if BOOST_PP_LOCAL_C(135) BOOST_PP_LOCAL_MACRO(135) # endif # if BOOST_PP_LOCAL_C(136) BOOST_PP_LOCAL_MACRO(136) # endif # if BOOST_PP_LOCAL_C(137) BOOST_PP_LOCAL_MACRO(137) # endif # if BOOST_PP_LOCAL_C(138) BOOST_PP_LOCAL_MACRO(138) # endif # if BOOST_PP_LOCAL_C(139) BOOST_PP_LOCAL_MACRO(139) # endif # if BOOST_PP_LOCAL_C(140) BOOST_PP_LOCAL_MACRO(140) # endif # if BOOST_PP_LOCAL_C(141) BOOST_PP_LOCAL_MACRO(141) # endif # if BOOST_PP_LOCAL_C(142) BOOST_PP_LOCAL_MACRO(142) # endif # if BOOST_PP_LOCAL_C(143) BOOST_PP_LOCAL_MACRO(143) # endif # if BOOST_PP_LOCAL_C(144) BOOST_PP_LOCAL_MACRO(144) # endif # if BOOST_PP_LOCAL_C(145) BOOST_PP_LOCAL_MACRO(145) # endif # if BOOST_PP_LOCAL_C(146) BOOST_PP_LOCAL_MACRO(146) # endif # if BOOST_PP_LOCAL_C(147) BOOST_PP_LOCAL_MACRO(147) # endif # if BOOST_PP_LOCAL_C(148) BOOST_PP_LOCAL_MACRO(148) # endif # if BOOST_PP_LOCAL_C(149) BOOST_PP_LOCAL_MACRO(149) # endif # if BOOST_PP_LOCAL_C(150) BOOST_PP_LOCAL_MACRO(150) # endif # if BOOST_PP_LOCAL_C(151) BOOST_PP_LOCAL_MACRO(151) # endif # if BOOST_PP_LOCAL_C(152) BOOST_PP_LOCAL_MACRO(152) # endif # if BOOST_PP_LOCAL_C(153) BOOST_PP_LOCAL_MACRO(153) # endif # if BOOST_PP_LOCAL_C(154) BOOST_PP_LOCAL_MACRO(154) # endif # if BOOST_PP_LOCAL_C(155) BOOST_PP_LOCAL_MACRO(155) # endif # if BOOST_PP_LOCAL_C(156) BOOST_PP_LOCAL_MACRO(156) # endif # if BOOST_PP_LOCAL_C(157) BOOST_PP_LOCAL_MACRO(157) # endif # if BOOST_PP_LOCAL_C(158) BOOST_PP_LOCAL_MACRO(158) # endif # if BOOST_PP_LOCAL_C(159) BOOST_PP_LOCAL_MACRO(159) # endif # if BOOST_PP_LOCAL_C(160) BOOST_PP_LOCAL_MACRO(160) # endif # if BOOST_PP_LOCAL_C(161) BOOST_PP_LOCAL_MACRO(161) # endif # if BOOST_PP_LOCAL_C(162) BOOST_PP_LOCAL_MACRO(162) # endif # if BOOST_PP_LOCAL_C(163) BOOST_PP_LOCAL_MACRO(163) # endif # if BOOST_PP_LOCAL_C(164) BOOST_PP_LOCAL_MACRO(164) # endif # if BOOST_PP_LOCAL_C(165) BOOST_PP_LOCAL_MACRO(165) # endif # if BOOST_PP_LOCAL_C(166) BOOST_PP_LOCAL_MACRO(166) # endif # if BOOST_PP_LOCAL_C(167) BOOST_PP_LOCAL_MACRO(167) # endif # if BOOST_PP_LOCAL_C(168) BOOST_PP_LOCAL_MACRO(168) # endif # if BOOST_PP_LOCAL_C(169) BOOST_PP_LOCAL_MACRO(169) # endif # if BOOST_PP_LOCAL_C(170) BOOST_PP_LOCAL_MACRO(170) # endif # if BOOST_PP_LOCAL_C(171) BOOST_PP_LOCAL_MACRO(171) # endif # if BOOST_PP_LOCAL_C(172) BOOST_PP_LOCAL_MACRO(172) # endif # if BOOST_PP_LOCAL_C(173) BOOST_PP_LOCAL_MACRO(173) # endif # if BOOST_PP_LOCAL_C(174) BOOST_PP_LOCAL_MACRO(174) # endif # if BOOST_PP_LOCAL_C(175) BOOST_PP_LOCAL_MACRO(175) # endif # if BOOST_PP_LOCAL_C(176) BOOST_PP_LOCAL_MACRO(176) # endif # if BOOST_PP_LOCAL_C(177) BOOST_PP_LOCAL_MACRO(177) # endif # if BOOST_PP_LOCAL_C(178) BOOST_PP_LOCAL_MACRO(178) # endif # if BOOST_PP_LOCAL_C(179) BOOST_PP_LOCAL_MACRO(179) # endif # if BOOST_PP_LOCAL_C(180) BOOST_PP_LOCAL_MACRO(180) # endif # if BOOST_PP_LOCAL_C(181) BOOST_PP_LOCAL_MACRO(181) # endif # if BOOST_PP_LOCAL_C(182) BOOST_PP_LOCAL_MACRO(182) # endif # if BOOST_PP_LOCAL_C(183) BOOST_PP_LOCAL_MACRO(183) # endif # if BOOST_PP_LOCAL_C(184) BOOST_PP_LOCAL_MACRO(184) # endif # if BOOST_PP_LOCAL_C(185) BOOST_PP_LOCAL_MACRO(185) # endif # if BOOST_PP_LOCAL_C(186) BOOST_PP_LOCAL_MACRO(186) # endif # if BOOST_PP_LOCAL_C(187) BOOST_PP_LOCAL_MACRO(187) # endif # if BOOST_PP_LOCAL_C(188) BOOST_PP_LOCAL_MACRO(188) # endif # if BOOST_PP_LOCAL_C(189) BOOST_PP_LOCAL_MACRO(189) # endif # if BOOST_PP_LOCAL_C(190) BOOST_PP_LOCAL_MACRO(190) # endif # if BOOST_PP_LOCAL_C(191) BOOST_PP_LOCAL_MACRO(191) # endif # if BOOST_PP_LOCAL_C(192) BOOST_PP_LOCAL_MACRO(192) # endif # if BOOST_PP_LOCAL_C(193) BOOST_PP_LOCAL_MACRO(193) # endif # if BOOST_PP_LOCAL_C(194) BOOST_PP_LOCAL_MACRO(194) # endif # if BOOST_PP_LOCAL_C(195) BOOST_PP_LOCAL_MACRO(195) # endif # if BOOST_PP_LOCAL_C(196) BOOST_PP_LOCAL_MACRO(196) # endif # if BOOST_PP_LOCAL_C(197) BOOST_PP_LOCAL_MACRO(197) # endif # if BOOST_PP_LOCAL_C(198) BOOST_PP_LOCAL_MACRO(198) # endif # if BOOST_PP_LOCAL_C(199) BOOST_PP_LOCAL_MACRO(199) # endif # if BOOST_PP_LOCAL_C(200) BOOST_PP_LOCAL_MACRO(200) # endif # if BOOST_PP_LOCAL_C(201) BOOST_PP_LOCAL_MACRO(201) # endif # if BOOST_PP_LOCAL_C(202) BOOST_PP_LOCAL_MACRO(202) # endif # if BOOST_PP_LOCAL_C(203) BOOST_PP_LOCAL_MACRO(203) # endif # if BOOST_PP_LOCAL_C(204) BOOST_PP_LOCAL_MACRO(204) # endif # if BOOST_PP_LOCAL_C(205) BOOST_PP_LOCAL_MACRO(205) # endif # if BOOST_PP_LOCAL_C(206) BOOST_PP_LOCAL_MACRO(206) # endif # if BOOST_PP_LOCAL_C(207) BOOST_PP_LOCAL_MACRO(207) # endif # if BOOST_PP_LOCAL_C(208) BOOST_PP_LOCAL_MACRO(208) # endif # if BOOST_PP_LOCAL_C(209) BOOST_PP_LOCAL_MACRO(209) # endif # if BOOST_PP_LOCAL_C(210) BOOST_PP_LOCAL_MACRO(210) # endif # if BOOST_PP_LOCAL_C(211) BOOST_PP_LOCAL_MACRO(211) # endif # if BOOST_PP_LOCAL_C(212) BOOST_PP_LOCAL_MACRO(212) # endif # if BOOST_PP_LOCAL_C(213) BOOST_PP_LOCAL_MACRO(213) # endif # if BOOST_PP_LOCAL_C(214) BOOST_PP_LOCAL_MACRO(214) # endif # if BOOST_PP_LOCAL_C(215) BOOST_PP_LOCAL_MACRO(215) # endif # if BOOST_PP_LOCAL_C(216) BOOST_PP_LOCAL_MACRO(216) # endif # if BOOST_PP_LOCAL_C(217) BOOST_PP_LOCAL_MACRO(217) # endif # if BOOST_PP_LOCAL_C(218) BOOST_PP_LOCAL_MACRO(218) # endif # if BOOST_PP_LOCAL_C(219) BOOST_PP_LOCAL_MACRO(219) # endif # if BOOST_PP_LOCAL_C(220) BOOST_PP_LOCAL_MACRO(220) # endif # if BOOST_PP_LOCAL_C(221) BOOST_PP_LOCAL_MACRO(221) # endif # if BOOST_PP_LOCAL_C(222) BOOST_PP_LOCAL_MACRO(222) # endif # if BOOST_PP_LOCAL_C(223) BOOST_PP_LOCAL_MACRO(223) # endif # if BOOST_PP_LOCAL_C(224) BOOST_PP_LOCAL_MACRO(224) # endif # if BOOST_PP_LOCAL_C(225) BOOST_PP_LOCAL_MACRO(225) # endif # if BOOST_PP_LOCAL_C(226) BOOST_PP_LOCAL_MACRO(226) # endif # if BOOST_PP_LOCAL_C(227) BOOST_PP_LOCAL_MACRO(227) # endif # if BOOST_PP_LOCAL_C(228) BOOST_PP_LOCAL_MACRO(228) # endif # if BOOST_PP_LOCAL_C(229) BOOST_PP_LOCAL_MACRO(229) # endif # if BOOST_PP_LOCAL_C(230) BOOST_PP_LOCAL_MACRO(230) # endif # if BOOST_PP_LOCAL_C(231) BOOST_PP_LOCAL_MACRO(231) # endif # if BOOST_PP_LOCAL_C(232) BOOST_PP_LOCAL_MACRO(232) # endif # if BOOST_PP_LOCAL_C(233) BOOST_PP_LOCAL_MACRO(233) # endif # if BOOST_PP_LOCAL_C(234) BOOST_PP_LOCAL_MACRO(234) # endif # if BOOST_PP_LOCAL_C(235) BOOST_PP_LOCAL_MACRO(235) # endif # if BOOST_PP_LOCAL_C(236) BOOST_PP_LOCAL_MACRO(236) # endif # if BOOST_PP_LOCAL_C(237) BOOST_PP_LOCAL_MACRO(237) # endif # if BOOST_PP_LOCAL_C(238) BOOST_PP_LOCAL_MACRO(238) # endif # if BOOST_PP_LOCAL_C(239) BOOST_PP_LOCAL_MACRO(239) # endif # if BOOST_PP_LOCAL_C(240) BOOST_PP_LOCAL_MACRO(240) # endif # if BOOST_PP_LOCAL_C(241) BOOST_PP_LOCAL_MACRO(241) # endif # if BOOST_PP_LOCAL_C(242) BOOST_PP_LOCAL_MACRO(242) # endif # if BOOST_PP_LOCAL_C(243) BOOST_PP_LOCAL_MACRO(243) # endif # if BOOST_PP_LOCAL_C(244) BOOST_PP_LOCAL_MACRO(244) # endif # if BOOST_PP_LOCAL_C(245) BOOST_PP_LOCAL_MACRO(245) # endif # if BOOST_PP_LOCAL_C(246) BOOST_PP_LOCAL_MACRO(246) # endif # if BOOST_PP_LOCAL_C(247) BOOST_PP_LOCAL_MACRO(247) # endif # if BOOST_PP_LOCAL_C(248) BOOST_PP_LOCAL_MACRO(248) # endif # if BOOST_PP_LOCAL_C(249) BOOST_PP_LOCAL_MACRO(249) # endif # if BOOST_PP_LOCAL_C(250) BOOST_PP_LOCAL_MACRO(250) # endif # if BOOST_PP_LOCAL_C(251) BOOST_PP_LOCAL_MACRO(251) # endif # if BOOST_PP_LOCAL_C(252) BOOST_PP_LOCAL_MACRO(252) # endif # if BOOST_PP_LOCAL_C(253) BOOST_PP_LOCAL_MACRO(253) # endif # if BOOST_PP_LOCAL_C(254) BOOST_PP_LOCAL_MACRO(254) # endif # if BOOST_PP_LOCAL_C(255) BOOST_PP_LOCAL_MACRO(255) # endif # if BOOST_PP_LOCAL_C(256) BOOST_PP_LOCAL_MACRO(256) # endif # endif # # undef BOOST_PP_LOCAL_LIMITS # # undef BOOST_PP_LOCAL_S # undef BOOST_PP_LOCAL_F # # undef BOOST_PP_LOCAL_MACRO ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/finish.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000704111344301502031735 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_LOCAL_FE # # undef BOOST_PP_LOCAL_FE_DIGIT_1 # undef BOOST_PP_LOCAL_FE_DIGIT_2 # undef BOOST_PP_LOCAL_FE_DIGIT_3 # undef BOOST_PP_LOCAL_FE_DIGIT_4 # undef BOOST_PP_LOCAL_FE_DIGIT_5 # undef BOOST_PP_LOCAL_FE_DIGIT_6 # undef BOOST_PP_LOCAL_FE_DIGIT_7 # undef BOOST_PP_LOCAL_FE_DIGIT_8 # undef BOOST_PP_LOCAL_FE_DIGIT_9 # undef BOOST_PP_LOCAL_FE_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_LOCAL_FE_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_LOCAL_FE_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_LOCAL_FE_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_LOCAL_FE_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_LOCAL_FE_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_LOCAL_FE_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_LOCAL_FE_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_LOCAL_FE_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_LOCAL_FE_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_LOCAL_FE_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_LOCAL_FE_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_LOCAL_FE_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_LOCAL_FE_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_LOCAL_FE_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_LOCAL_FE_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_LOCAL_FE_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_LOCAL_FE_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_LOCAL_FE_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_LOCAL_FE_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_LOCAL_FE_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_LOCAL_FE_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_LOCAL_FE_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_LOCAL_FE_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_LOCAL_FE_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_LOCAL_FE_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_LOCAL_FE_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_LOCAL_FE_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_LOCAL_FE_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_LOCAL_FE_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_LOCAL_FE_DIGIT_1 9 # endif # # if BOOST_PP_LOCAL_FE_DIGIT_3 # define BOOST_PP_LOCAL_FE() BOOST_PP_SLOT_CC_3(BOOST_PP_LOCAL_FE_DIGIT_3, BOOST_PP_LOCAL_FE_DIGIT_2, BOOST_PP_LOCAL_FE_DIGIT_1) # elif BOOST_PP_LOCAL_FE_DIGIT_2 # define BOOST_PP_LOCAL_FE() BOOST_PP_SLOT_CC_2(BOOST_PP_LOCAL_FE_DIGIT_2, BOOST_PP_LOCAL_FE_DIGIT_1) # else # define BOOST_PP_LOCAL_FE() BOOST_PP_LOCAL_FE_DIGIT_1 # endif ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/start.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000704111344301502031735 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_LOCAL_SE # # undef BOOST_PP_LOCAL_SE_DIGIT_1 # undef BOOST_PP_LOCAL_SE_DIGIT_2 # undef BOOST_PP_LOCAL_SE_DIGIT_3 # undef BOOST_PP_LOCAL_SE_DIGIT_4 # undef BOOST_PP_LOCAL_SE_DIGIT_5 # undef BOOST_PP_LOCAL_SE_DIGIT_6 # undef BOOST_PP_LOCAL_SE_DIGIT_7 # undef BOOST_PP_LOCAL_SE_DIGIT_8 # undef BOOST_PP_LOCAL_SE_DIGIT_9 # undef BOOST_PP_LOCAL_SE_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_LOCAL_SE_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_LOCAL_SE_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_LOCAL_SE_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_LOCAL_SE_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_LOCAL_SE_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_LOCAL_SE_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_LOCAL_SE_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_LOCAL_SE_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_LOCAL_SE_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_LOCAL_SE_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_LOCAL_SE_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_LOCAL_SE_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_LOCAL_SE_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_LOCAL_SE_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_LOCAL_SE_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_LOCAL_SE_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_LOCAL_SE_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_LOCAL_SE_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_LOCAL_SE_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_LOCAL_SE_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_LOCAL_SE_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_LOCAL_SE_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_LOCAL_SE_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_LOCAL_SE_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_LOCAL_SE_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_LOCAL_SE_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_LOCAL_SE_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_LOCAL_SE_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_LOCAL_SE_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_LOCAL_SE_DIGIT_1 9 # endif # # if BOOST_PP_LOCAL_SE_DIGIT_3 # define BOOST_PP_LOCAL_SE() BOOST_PP_SLOT_CC_3(BOOST_PP_LOCAL_SE_DIGIT_3, BOOST_PP_LOCAL_SE_DIGIT_2, BOOST_PP_LOCAL_SE_DIGIT_1) # elif BOOST_PP_LOCAL_SE_DIGIT_2 # define BOOST_PP_LOCAL_SE() BOOST_PP_SLOT_CC_2(BOOST_PP_LOCAL_SE_DIGIT_2, BOOST_PP_LOCAL_SE_DIGIT_1) # else # define BOOST_PP_LOCAL_SE() BOOST_PP_LOCAL_SE_DIGIT_1 # endif ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration/detail/rlocal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000004127711344301502031746 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # if BOOST_PP_LOCAL_R(256) BOOST_PP_LOCAL_MACRO(256) # endif # if BOOST_PP_LOCAL_R(255) BOOST_PP_LOCAL_MACRO(255) # endif # if BOOST_PP_LOCAL_R(254) BOOST_PP_LOCAL_MACRO(254) # endif # if BOOST_PP_LOCAL_R(253) BOOST_PP_LOCAL_MACRO(253) # endif # if BOOST_PP_LOCAL_R(252) BOOST_PP_LOCAL_MACRO(252) # endif # if BOOST_PP_LOCAL_R(251) BOOST_PP_LOCAL_MACRO(251) # endif # if BOOST_PP_LOCAL_R(250) BOOST_PP_LOCAL_MACRO(250) # endif # if BOOST_PP_LOCAL_R(249) BOOST_PP_LOCAL_MACRO(249) # endif # if BOOST_PP_LOCAL_R(248) BOOST_PP_LOCAL_MACRO(248) # endif # if BOOST_PP_LOCAL_R(247) BOOST_PP_LOCAL_MACRO(247) # endif # if BOOST_PP_LOCAL_R(246) BOOST_PP_LOCAL_MACRO(246) # endif # if BOOST_PP_LOCAL_R(245) BOOST_PP_LOCAL_MACRO(245) # endif # if BOOST_PP_LOCAL_R(244) BOOST_PP_LOCAL_MACRO(244) # endif # if BOOST_PP_LOCAL_R(243) BOOST_PP_LOCAL_MACRO(243) # endif # if BOOST_PP_LOCAL_R(242) BOOST_PP_LOCAL_MACRO(242) # endif # if BOOST_PP_LOCAL_R(241) BOOST_PP_LOCAL_MACRO(241) # endif # if BOOST_PP_LOCAL_R(240) BOOST_PP_LOCAL_MACRO(240) # endif # if BOOST_PP_LOCAL_R(239) BOOST_PP_LOCAL_MACRO(239) # endif # if BOOST_PP_LOCAL_R(238) BOOST_PP_LOCAL_MACRO(238) # endif # if BOOST_PP_LOCAL_R(237) BOOST_PP_LOCAL_MACRO(237) # endif # if BOOST_PP_LOCAL_R(236) BOOST_PP_LOCAL_MACRO(236) # endif # if BOOST_PP_LOCAL_R(235) BOOST_PP_LOCAL_MACRO(235) # endif # if BOOST_PP_LOCAL_R(234) BOOST_PP_LOCAL_MACRO(234) # endif # if BOOST_PP_LOCAL_R(233) BOOST_PP_LOCAL_MACRO(233) # endif # if BOOST_PP_LOCAL_R(232) BOOST_PP_LOCAL_MACRO(232) # endif # if BOOST_PP_LOCAL_R(231) BOOST_PP_LOCAL_MACRO(231) # endif # if BOOST_PP_LOCAL_R(230) BOOST_PP_LOCAL_MACRO(230) # endif # if BOOST_PP_LOCAL_R(229) BOOST_PP_LOCAL_MACRO(229) # endif # if BOOST_PP_LOCAL_R(228) BOOST_PP_LOCAL_MACRO(228) # endif # if BOOST_PP_LOCAL_R(227) BOOST_PP_LOCAL_MACRO(227) # endif # if BOOST_PP_LOCAL_R(226) BOOST_PP_LOCAL_MACRO(226) # endif # if BOOST_PP_LOCAL_R(225) BOOST_PP_LOCAL_MACRO(225) # endif # if BOOST_PP_LOCAL_R(224) BOOST_PP_LOCAL_MACRO(224) # endif # if BOOST_PP_LOCAL_R(223) BOOST_PP_LOCAL_MACRO(223) # endif # if BOOST_PP_LOCAL_R(222) BOOST_PP_LOCAL_MACRO(222) # endif # if BOOST_PP_LOCAL_R(221) BOOST_PP_LOCAL_MACRO(221) # endif # if BOOST_PP_LOCAL_R(220) BOOST_PP_LOCAL_MACRO(220) # endif # if BOOST_PP_LOCAL_R(219) BOOST_PP_LOCAL_MACRO(219) # endif # if BOOST_PP_LOCAL_R(218) BOOST_PP_LOCAL_MACRO(218) # endif # if BOOST_PP_LOCAL_R(217) BOOST_PP_LOCAL_MACRO(217) # endif # if BOOST_PP_LOCAL_R(216) BOOST_PP_LOCAL_MACRO(216) # endif # if BOOST_PP_LOCAL_R(215) BOOST_PP_LOCAL_MACRO(215) # endif # if BOOST_PP_LOCAL_R(214) BOOST_PP_LOCAL_MACRO(214) # endif # if BOOST_PP_LOCAL_R(213) BOOST_PP_LOCAL_MACRO(213) # endif # if BOOST_PP_LOCAL_R(212) BOOST_PP_LOCAL_MACRO(212) # endif # if BOOST_PP_LOCAL_R(211) BOOST_PP_LOCAL_MACRO(211) # endif # if BOOST_PP_LOCAL_R(210) BOOST_PP_LOCAL_MACRO(210) # endif # if BOOST_PP_LOCAL_R(209) BOOST_PP_LOCAL_MACRO(209) # endif # if BOOST_PP_LOCAL_R(208) BOOST_PP_LOCAL_MACRO(208) # endif # if BOOST_PP_LOCAL_R(207) BOOST_PP_LOCAL_MACRO(207) # endif # if BOOST_PP_LOCAL_R(206) BOOST_PP_LOCAL_MACRO(206) # endif # if BOOST_PP_LOCAL_R(205) BOOST_PP_LOCAL_MACRO(205) # endif # if BOOST_PP_LOCAL_R(204) BOOST_PP_LOCAL_MACRO(204) # endif # if BOOST_PP_LOCAL_R(203) BOOST_PP_LOCAL_MACRO(203) # endif # if BOOST_PP_LOCAL_R(202) BOOST_PP_LOCAL_MACRO(202) # endif # if BOOST_PP_LOCAL_R(201) BOOST_PP_LOCAL_MACRO(201) # endif # if BOOST_PP_LOCAL_R(200) BOOST_PP_LOCAL_MACRO(200) # endif # if BOOST_PP_LOCAL_R(199) BOOST_PP_LOCAL_MACRO(199) # endif # if BOOST_PP_LOCAL_R(198) BOOST_PP_LOCAL_MACRO(198) # endif # if BOOST_PP_LOCAL_R(197) BOOST_PP_LOCAL_MACRO(197) # endif # if BOOST_PP_LOCAL_R(196) BOOST_PP_LOCAL_MACRO(196) # endif # if BOOST_PP_LOCAL_R(195) BOOST_PP_LOCAL_MACRO(195) # endif # if BOOST_PP_LOCAL_R(194) BOOST_PP_LOCAL_MACRO(194) # endif # if BOOST_PP_LOCAL_R(193) BOOST_PP_LOCAL_MACRO(193) # endif # if BOOST_PP_LOCAL_R(192) BOOST_PP_LOCAL_MACRO(192) # endif # if BOOST_PP_LOCAL_R(191) BOOST_PP_LOCAL_MACRO(191) # endif # if BOOST_PP_LOCAL_R(190) BOOST_PP_LOCAL_MACRO(190) # endif # if BOOST_PP_LOCAL_R(189) BOOST_PP_LOCAL_MACRO(189) # endif # if BOOST_PP_LOCAL_R(188) BOOST_PP_LOCAL_MACRO(188) # endif # if BOOST_PP_LOCAL_R(187) BOOST_PP_LOCAL_MACRO(187) # endif # if BOOST_PP_LOCAL_R(186) BOOST_PP_LOCAL_MACRO(186) # endif # if BOOST_PP_LOCAL_R(185) BOOST_PP_LOCAL_MACRO(185) # endif # if BOOST_PP_LOCAL_R(184) BOOST_PP_LOCAL_MACRO(184) # endif # if BOOST_PP_LOCAL_R(183) BOOST_PP_LOCAL_MACRO(183) # endif # if BOOST_PP_LOCAL_R(182) BOOST_PP_LOCAL_MACRO(182) # endif # if BOOST_PP_LOCAL_R(181) BOOST_PP_LOCAL_MACRO(181) # endif # if BOOST_PP_LOCAL_R(180) BOOST_PP_LOCAL_MACRO(180) # endif # if BOOST_PP_LOCAL_R(179) BOOST_PP_LOCAL_MACRO(179) # endif # if BOOST_PP_LOCAL_R(178) BOOST_PP_LOCAL_MACRO(178) # endif # if BOOST_PP_LOCAL_R(177) BOOST_PP_LOCAL_MACRO(177) # endif # if BOOST_PP_LOCAL_R(176) BOOST_PP_LOCAL_MACRO(176) # endif # if BOOST_PP_LOCAL_R(175) BOOST_PP_LOCAL_MACRO(175) # endif # if BOOST_PP_LOCAL_R(174) BOOST_PP_LOCAL_MACRO(174) # endif # if BOOST_PP_LOCAL_R(173) BOOST_PP_LOCAL_MACRO(173) # endif # if BOOST_PP_LOCAL_R(172) BOOST_PP_LOCAL_MACRO(172) # endif # if BOOST_PP_LOCAL_R(171) BOOST_PP_LOCAL_MACRO(171) # endif # if BOOST_PP_LOCAL_R(170) BOOST_PP_LOCAL_MACRO(170) # endif # if BOOST_PP_LOCAL_R(169) BOOST_PP_LOCAL_MACRO(169) # endif # if BOOST_PP_LOCAL_R(168) BOOST_PP_LOCAL_MACRO(168) # endif # if BOOST_PP_LOCAL_R(167) BOOST_PP_LOCAL_MACRO(167) # endif # if BOOST_PP_LOCAL_R(166) BOOST_PP_LOCAL_MACRO(166) # endif # if BOOST_PP_LOCAL_R(165) BOOST_PP_LOCAL_MACRO(165) # endif # if BOOST_PP_LOCAL_R(164) BOOST_PP_LOCAL_MACRO(164) # endif # if BOOST_PP_LOCAL_R(163) BOOST_PP_LOCAL_MACRO(163) # endif # if BOOST_PP_LOCAL_R(162) BOOST_PP_LOCAL_MACRO(162) # endif # if BOOST_PP_LOCAL_R(161) BOOST_PP_LOCAL_MACRO(161) # endif # if BOOST_PP_LOCAL_R(160) BOOST_PP_LOCAL_MACRO(160) # endif # if BOOST_PP_LOCAL_R(159) BOOST_PP_LOCAL_MACRO(159) # endif # if BOOST_PP_LOCAL_R(158) BOOST_PP_LOCAL_MACRO(158) # endif # if BOOST_PP_LOCAL_R(157) BOOST_PP_LOCAL_MACRO(157) # endif # if BOOST_PP_LOCAL_R(156) BOOST_PP_LOCAL_MACRO(156) # endif # if BOOST_PP_LOCAL_R(155) BOOST_PP_LOCAL_MACRO(155) # endif # if BOOST_PP_LOCAL_R(154) BOOST_PP_LOCAL_MACRO(154) # endif # if BOOST_PP_LOCAL_R(153) BOOST_PP_LOCAL_MACRO(153) # endif # if BOOST_PP_LOCAL_R(152) BOOST_PP_LOCAL_MACRO(152) # endif # if BOOST_PP_LOCAL_R(151) BOOST_PP_LOCAL_MACRO(151) # endif # if BOOST_PP_LOCAL_R(150) BOOST_PP_LOCAL_MACRO(150) # endif # if BOOST_PP_LOCAL_R(149) BOOST_PP_LOCAL_MACRO(149) # endif # if BOOST_PP_LOCAL_R(148) BOOST_PP_LOCAL_MACRO(148) # endif # if BOOST_PP_LOCAL_R(147) BOOST_PP_LOCAL_MACRO(147) # endif # if BOOST_PP_LOCAL_R(146) BOOST_PP_LOCAL_MACRO(146) # endif # if BOOST_PP_LOCAL_R(145) BOOST_PP_LOCAL_MACRO(145) # endif # if BOOST_PP_LOCAL_R(144) BOOST_PP_LOCAL_MACRO(144) # endif # if BOOST_PP_LOCAL_R(143) BOOST_PP_LOCAL_MACRO(143) # endif # if BOOST_PP_LOCAL_R(142) BOOST_PP_LOCAL_MACRO(142) # endif # if BOOST_PP_LOCAL_R(141) BOOST_PP_LOCAL_MACRO(141) # endif # if BOOST_PP_LOCAL_R(140) BOOST_PP_LOCAL_MACRO(140) # endif # if BOOST_PP_LOCAL_R(139) BOOST_PP_LOCAL_MACRO(139) # endif # if BOOST_PP_LOCAL_R(138) BOOST_PP_LOCAL_MACRO(138) # endif # if BOOST_PP_LOCAL_R(137) BOOST_PP_LOCAL_MACRO(137) # endif # if BOOST_PP_LOCAL_R(136) BOOST_PP_LOCAL_MACRO(136) # endif # if BOOST_PP_LOCAL_R(135) BOOST_PP_LOCAL_MACRO(135) # endif # if BOOST_PP_LOCAL_R(134) BOOST_PP_LOCAL_MACRO(134) # endif # if BOOST_PP_LOCAL_R(133) BOOST_PP_LOCAL_MACRO(133) # endif # if BOOST_PP_LOCAL_R(132) BOOST_PP_LOCAL_MACRO(132) # endif # if BOOST_PP_LOCAL_R(131) BOOST_PP_LOCAL_MACRO(131) # endif # if BOOST_PP_LOCAL_R(130) BOOST_PP_LOCAL_MACRO(130) # endif # if BOOST_PP_LOCAL_R(129) BOOST_PP_LOCAL_MACRO(129) # endif # if BOOST_PP_LOCAL_R(128) BOOST_PP_LOCAL_MACRO(128) # endif # if BOOST_PP_LOCAL_R(127) BOOST_PP_LOCAL_MACRO(127) # endif # if BOOST_PP_LOCAL_R(126) BOOST_PP_LOCAL_MACRO(126) # endif # if BOOST_PP_LOCAL_R(125) BOOST_PP_LOCAL_MACRO(125) # endif # if BOOST_PP_LOCAL_R(124) BOOST_PP_LOCAL_MACRO(124) # endif # if BOOST_PP_LOCAL_R(123) BOOST_PP_LOCAL_MACRO(123) # endif # if BOOST_PP_LOCAL_R(122) BOOST_PP_LOCAL_MACRO(122) # endif # if BOOST_PP_LOCAL_R(121) BOOST_PP_LOCAL_MACRO(121) # endif # if BOOST_PP_LOCAL_R(120) BOOST_PP_LOCAL_MACRO(120) # endif # if BOOST_PP_LOCAL_R(119) BOOST_PP_LOCAL_MACRO(119) # endif # if BOOST_PP_LOCAL_R(118) BOOST_PP_LOCAL_MACRO(118) # endif # if BOOST_PP_LOCAL_R(117) BOOST_PP_LOCAL_MACRO(117) # endif # if BOOST_PP_LOCAL_R(116) BOOST_PP_LOCAL_MACRO(116) # endif # if BOOST_PP_LOCAL_R(115) BOOST_PP_LOCAL_MACRO(115) # endif # if BOOST_PP_LOCAL_R(114) BOOST_PP_LOCAL_MACRO(114) # endif # if BOOST_PP_LOCAL_R(113) BOOST_PP_LOCAL_MACRO(113) # endif # if BOOST_PP_LOCAL_R(112) BOOST_PP_LOCAL_MACRO(112) # endif # if BOOST_PP_LOCAL_R(111) BOOST_PP_LOCAL_MACRO(111) # endif # if BOOST_PP_LOCAL_R(110) BOOST_PP_LOCAL_MACRO(110) # endif # if BOOST_PP_LOCAL_R(109) BOOST_PP_LOCAL_MACRO(109) # endif # if BOOST_PP_LOCAL_R(108) BOOST_PP_LOCAL_MACRO(108) # endif # if BOOST_PP_LOCAL_R(107) BOOST_PP_LOCAL_MACRO(107) # endif # if BOOST_PP_LOCAL_R(106) BOOST_PP_LOCAL_MACRO(106) # endif # if BOOST_PP_LOCAL_R(105) BOOST_PP_LOCAL_MACRO(105) # endif # if BOOST_PP_LOCAL_R(104) BOOST_PP_LOCAL_MACRO(104) # endif # if BOOST_PP_LOCAL_R(103) BOOST_PP_LOCAL_MACRO(103) # endif # if BOOST_PP_LOCAL_R(102) BOOST_PP_LOCAL_MACRO(102) # endif # if BOOST_PP_LOCAL_R(101) BOOST_PP_LOCAL_MACRO(101) # endif # if BOOST_PP_LOCAL_R(100) BOOST_PP_LOCAL_MACRO(100) # endif # if BOOST_PP_LOCAL_R(99) BOOST_PP_LOCAL_MACRO(99) # endif # if BOOST_PP_LOCAL_R(98) BOOST_PP_LOCAL_MACRO(98) # endif # if BOOST_PP_LOCAL_R(97) BOOST_PP_LOCAL_MACRO(97) # endif # if BOOST_PP_LOCAL_R(96) BOOST_PP_LOCAL_MACRO(96) # endif # if BOOST_PP_LOCAL_R(95) BOOST_PP_LOCAL_MACRO(95) # endif # if BOOST_PP_LOCAL_R(94) BOOST_PP_LOCAL_MACRO(94) # endif # if BOOST_PP_LOCAL_R(93) BOOST_PP_LOCAL_MACRO(93) # endif # if BOOST_PP_LOCAL_R(92) BOOST_PP_LOCAL_MACRO(92) # endif # if BOOST_PP_LOCAL_R(91) BOOST_PP_LOCAL_MACRO(91) # endif # if BOOST_PP_LOCAL_R(90) BOOST_PP_LOCAL_MACRO(90) # endif # if BOOST_PP_LOCAL_R(89) BOOST_PP_LOCAL_MACRO(89) # endif # if BOOST_PP_LOCAL_R(88) BOOST_PP_LOCAL_MACRO(88) # endif # if BOOST_PP_LOCAL_R(87) BOOST_PP_LOCAL_MACRO(87) # endif # if BOOST_PP_LOCAL_R(86) BOOST_PP_LOCAL_MACRO(86) # endif # if BOOST_PP_LOCAL_R(85) BOOST_PP_LOCAL_MACRO(85) # endif # if BOOST_PP_LOCAL_R(84) BOOST_PP_LOCAL_MACRO(84) # endif # if BOOST_PP_LOCAL_R(83) BOOST_PP_LOCAL_MACRO(83) # endif # if BOOST_PP_LOCAL_R(82) BOOST_PP_LOCAL_MACRO(82) # endif # if BOOST_PP_LOCAL_R(81) BOOST_PP_LOCAL_MACRO(81) # endif # if BOOST_PP_LOCAL_R(80) BOOST_PP_LOCAL_MACRO(80) # endif # if BOOST_PP_LOCAL_R(79) BOOST_PP_LOCAL_MACRO(79) # endif # if BOOST_PP_LOCAL_R(78) BOOST_PP_LOCAL_MACRO(78) # endif # if BOOST_PP_LOCAL_R(77) BOOST_PP_LOCAL_MACRO(77) # endif # if BOOST_PP_LOCAL_R(76) BOOST_PP_LOCAL_MACRO(76) # endif # if BOOST_PP_LOCAL_R(75) BOOST_PP_LOCAL_MACRO(75) # endif # if BOOST_PP_LOCAL_R(74) BOOST_PP_LOCAL_MACRO(74) # endif # if BOOST_PP_LOCAL_R(73) BOOST_PP_LOCAL_MACRO(73) # endif # if BOOST_PP_LOCAL_R(72) BOOST_PP_LOCAL_MACRO(72) # endif # if BOOST_PP_LOCAL_R(71) BOOST_PP_LOCAL_MACRO(71) # endif # if BOOST_PP_LOCAL_R(70) BOOST_PP_LOCAL_MACRO(70) # endif # if BOOST_PP_LOCAL_R(69) BOOST_PP_LOCAL_MACRO(69) # endif # if BOOST_PP_LOCAL_R(68) BOOST_PP_LOCAL_MACRO(68) # endif # if BOOST_PP_LOCAL_R(67) BOOST_PP_LOCAL_MACRO(67) # endif # if BOOST_PP_LOCAL_R(66) BOOST_PP_LOCAL_MACRO(66) # endif # if BOOST_PP_LOCAL_R(65) BOOST_PP_LOCAL_MACRO(65) # endif # if BOOST_PP_LOCAL_R(64) BOOST_PP_LOCAL_MACRO(64) # endif # if BOOST_PP_LOCAL_R(63) BOOST_PP_LOCAL_MACRO(63) # endif # if BOOST_PP_LOCAL_R(62) BOOST_PP_LOCAL_MACRO(62) # endif # if BOOST_PP_LOCAL_R(61) BOOST_PP_LOCAL_MACRO(61) # endif # if BOOST_PP_LOCAL_R(60) BOOST_PP_LOCAL_MACRO(60) # endif # if BOOST_PP_LOCAL_R(59) BOOST_PP_LOCAL_MACRO(59) # endif # if BOOST_PP_LOCAL_R(58) BOOST_PP_LOCAL_MACRO(58) # endif # if BOOST_PP_LOCAL_R(57) BOOST_PP_LOCAL_MACRO(57) # endif # if BOOST_PP_LOCAL_R(56) BOOST_PP_LOCAL_MACRO(56) # endif # if BOOST_PP_LOCAL_R(55) BOOST_PP_LOCAL_MACRO(55) # endif # if BOOST_PP_LOCAL_R(54) BOOST_PP_LOCAL_MACRO(54) # endif # if BOOST_PP_LOCAL_R(53) BOOST_PP_LOCAL_MACRO(53) # endif # if BOOST_PP_LOCAL_R(52) BOOST_PP_LOCAL_MACRO(52) # endif # if BOOST_PP_LOCAL_R(51) BOOST_PP_LOCAL_MACRO(51) # endif # if BOOST_PP_LOCAL_R(50) BOOST_PP_LOCAL_MACRO(50) # endif # if BOOST_PP_LOCAL_R(49) BOOST_PP_LOCAL_MACRO(49) # endif # if BOOST_PP_LOCAL_R(48) BOOST_PP_LOCAL_MACRO(48) # endif # if BOOST_PP_LOCAL_R(47) BOOST_PP_LOCAL_MACRO(47) # endif # if BOOST_PP_LOCAL_R(46) BOOST_PP_LOCAL_MACRO(46) # endif # if BOOST_PP_LOCAL_R(45) BOOST_PP_LOCAL_MACRO(45) # endif # if BOOST_PP_LOCAL_R(44) BOOST_PP_LOCAL_MACRO(44) # endif # if BOOST_PP_LOCAL_R(43) BOOST_PP_LOCAL_MACRO(43) # endif # if BOOST_PP_LOCAL_R(42) BOOST_PP_LOCAL_MACRO(42) # endif # if BOOST_PP_LOCAL_R(41) BOOST_PP_LOCAL_MACRO(41) # endif # if BOOST_PP_LOCAL_R(40) BOOST_PP_LOCAL_MACRO(40) # endif # if BOOST_PP_LOCAL_R(39) BOOST_PP_LOCAL_MACRO(39) # endif # if BOOST_PP_LOCAL_R(38) BOOST_PP_LOCAL_MACRO(38) # endif # if BOOST_PP_LOCAL_R(37) BOOST_PP_LOCAL_MACRO(37) # endif # if BOOST_PP_LOCAL_R(36) BOOST_PP_LOCAL_MACRO(36) # endif # if BOOST_PP_LOCAL_R(35) BOOST_PP_LOCAL_MACRO(35) # endif # if BOOST_PP_LOCAL_R(34) BOOST_PP_LOCAL_MACRO(34) # endif # if BOOST_PP_LOCAL_R(33) BOOST_PP_LOCAL_MACRO(33) # endif # if BOOST_PP_LOCAL_R(32) BOOST_PP_LOCAL_MACRO(32) # endif # if BOOST_PP_LOCAL_R(31) BOOST_PP_LOCAL_MACRO(31) # endif # if BOOST_PP_LOCAL_R(30) BOOST_PP_LOCAL_MACRO(30) # endif # if BOOST_PP_LOCAL_R(29) BOOST_PP_LOCAL_MACRO(29) # endif # if BOOST_PP_LOCAL_R(28) BOOST_PP_LOCAL_MACRO(28) # endif # if BOOST_PP_LOCAL_R(27) BOOST_PP_LOCAL_MACRO(27) # endif # if BOOST_PP_LOCAL_R(26) BOOST_PP_LOCAL_MACRO(26) # endif # if BOOST_PP_LOCAL_R(25) BOOST_PP_LOCAL_MACRO(25) # endif # if BOOST_PP_LOCAL_R(24) BOOST_PP_LOCAL_MACRO(24) # endif # if BOOST_PP_LOCAL_R(23) BOOST_PP_LOCAL_MACRO(23) # endif # if BOOST_PP_LOCAL_R(22) BOOST_PP_LOCAL_MACRO(22) # endif # if BOOST_PP_LOCAL_R(21) BOOST_PP_LOCAL_MACRO(21) # endif # if BOOST_PP_LOCAL_R(20) BOOST_PP_LOCAL_MACRO(20) # endif # if BOOST_PP_LOCAL_R(19) BOOST_PP_LOCAL_MACRO(19) # endif # if BOOST_PP_LOCAL_R(18) BOOST_PP_LOCAL_MACRO(18) # endif # if BOOST_PP_LOCAL_R(17) BOOST_PP_LOCAL_MACRO(17) # endif # if BOOST_PP_LOCAL_R(16) BOOST_PP_LOCAL_MACRO(16) # endif # if BOOST_PP_LOCAL_R(15) BOOST_PP_LOCAL_MACRO(15) # endif # if BOOST_PP_LOCAL_R(14) BOOST_PP_LOCAL_MACRO(14) # endif # if BOOST_PP_LOCAL_R(13) BOOST_PP_LOCAL_MACRO(13) # endif # if BOOST_PP_LOCAL_R(12) BOOST_PP_LOCAL_MACRO(12) # endif # if BOOST_PP_LOCAL_R(11) BOOST_PP_LOCAL_MACRO(11) # endif # if BOOST_PP_LOCAL_R(10) BOOST_PP_LOCAL_MACRO(10) # endif # if BOOST_PP_LOCAL_R(9) BOOST_PP_LOCAL_MACRO(9) # endif # if BOOST_PP_LOCAL_R(8) BOOST_PP_LOCAL_MACRO(8) # endif # if BOOST_PP_LOCAL_R(7) BOOST_PP_LOCAL_MACRO(7) # endif # if BOOST_PP_LOCAL_R(6) BOOST_PP_LOCAL_MACRO(6) # endif # if BOOST_PP_LOCAL_R(5) BOOST_PP_LOCAL_MACRO(5) # endif # if BOOST_PP_LOCAL_R(4) BOOST_PP_LOCAL_MACRO(4) # endif # if BOOST_PP_LOCAL_R(3) BOOST_PP_LOCAL_MACRO(3) # endif # if BOOST_PP_LOCAL_R(2) BOOST_PP_LOCAL_MACRO(2) # endif # if BOOST_PP_LOCAL_R(1) BOOST_PP_LOCAL_MACRO(1) # endif # if BOOST_PP_LOCAL_R(0) BOOST_PP_LOCAL_MACRO(0) # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/inc.hpp0000644000175000017500000000134011344301502031450 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_INC_HPP # define BOOST_PREPROCESSOR_INC_HPP # # include # # endif ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/assert_msg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/assert_m0000644000175000017500000000135411344301502031733 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ASSERT_MSG_HPP # define BOOST_PREPROCESSOR_ASSERT_MSG_HPP # # include # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteration.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/iteratio0000644000175000017500000000152411344301502031735 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_ITERATION_HPP # define BOOST_PREPROCESSOR_ITERATION_HPP # # include # include # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/0000755000175000017500000000000012146213764031447 5ustar debiandebian././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/split.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/s0000644000175000017500000000277111344301502031626 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # ifndef BOOST_PREPROCESSOR_DETAIL_SPLIT_HPP # define BOOST_PREPROCESSOR_DETAIL_SPLIT_HPP # # include # # /* BOOST_PP_SPLIT */ # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_SPLIT(n, im) BOOST_PP_SPLIT_I((n, im)) # define BOOST_PP_SPLIT_I(par) BOOST_PP_SPLIT_II ## par # define BOOST_PP_SPLIT_II(n, a, b) BOOST_PP_SPLIT_ ## n(a, b) # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_SPLIT(n, im) BOOST_PP_SPLIT_I(n((im))) # define BOOST_PP_SPLIT_I(n) BOOST_PP_SPLIT_ID(BOOST_PP_SPLIT_II_ ## n) # define BOOST_PP_SPLIT_II_0(s) BOOST_PP_SPLIT_ID(BOOST_PP_SPLIT_0 s) # define BOOST_PP_SPLIT_II_1(s) BOOST_PP_SPLIT_ID(BOOST_PP_SPLIT_1 s) # define BOOST_PP_SPLIT_ID(id) id # else # define BOOST_PP_SPLIT(n, im) BOOST_PP_SPLIT_I(n)(im) # define BOOST_PP_SPLIT_I(n) BOOST_PP_SPLIT_ ## n # endif # # define BOOST_PP_SPLIT_0(a, b) a # define BOOST_PP_SPLIT_1(a, b) b # # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/is_nullary.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/i0000644000175000017500000000234011344301502031604 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DETAIL_IS_NULLARY_HPP # define BOOST_PREPROCESSOR_DETAIL_IS_NULLARY_HPP # # include # include # # /* BOOST_PP_IS_NULLARY */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_IS_NULLARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_NULLARY_CHECK) # else # define BOOST_PP_IS_NULLARY(x) BOOST_PP_IS_NULLARY_I(x) # define BOOST_PP_IS_NULLARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_NULLARY_CHECK) # endif # # define BOOST_PP_IS_NULLARY_CHECK() 1 # define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_NULLARY_CHECK 0, BOOST_PP_NIL # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/is_unary.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/i0000644000175000017500000000231311344301502031604 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DETAIL_IS_UNARY_HPP # define BOOST_PREPROCESSOR_DETAIL_IS_UNARY_HPP # # include # include # # /* BOOST_PP_IS_UNARY */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_IS_UNARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_UNARY_CHECK) # else # define BOOST_PP_IS_UNARY(x) BOOST_PP_IS_UNARY_I(x) # define BOOST_PP_IS_UNARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_UNARY_CHECK) # endif # # define BOOST_PP_IS_UNARY_CHECK(a) 1 # define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_UNARY_CHECK 0, BOOST_PP_NIL # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/null.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/n0000644000175000017500000000132111344301502031607 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DETAIL_NULL_HPP # define BOOST_PREPROCESSOR_DETAIL_NULL_HPP # # /* empty file */ # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/auto_rec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/a0000644000175000017500000006303011344301502031577 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # include # else # # ifndef BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP # define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP # # include # # /* BOOST_PP_AUTO_REC */ # # define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred) # # define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p) # define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p) # define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p) # # define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192) # define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96) # define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48) # define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24) # define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12) # define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6) # define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3) # define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p(1), 1, 2) # define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p(3), 3, 4) # define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7) # define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p(5), 5, 6) # define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p(7), 7, 8) # define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14) # define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11) # define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p(9), 9, 10) # define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p(11), 11, 12) # define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15) # define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p(13), 13, 14) # define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p(15), 15, 16) # define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28) # define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22) # define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19) # define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p(17), 17, 18) # define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p(19), 19, 20) # define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23) # define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p(21), 21, 22) # define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p(23), 23, 24) # define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30) # define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27) # define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p(25), 25, 26) # define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p(27), 27, 28) # define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31) # define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p(29), 29, 30) # define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p(31), 31, 32) # define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56) # define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44) # define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38) # define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35) # define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p(33), 33, 34) # define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p(35), 35, 36) # define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39) # define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p(37), 37, 38) # define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p(39), 39, 40) # define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46) # define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43) # define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p(41), 41, 42) # define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p(43), 43, 44) # define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47) # define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p(45), 45, 46) # define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p(47), 47, 48) # define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60) # define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54) # define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51) # define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p(49), 49, 50) # define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p(51), 51, 52) # define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55) # define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p(53), 53, 54) # define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p(55), 55, 56) # define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62) # define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59) # define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p(57), 57, 58) # define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p(59), 59, 60) # define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63) # define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p(61), 61, 62) # define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p(63), 63, 64) # define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112) # define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88) # define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76) # define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70) # define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67) # define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p(65), 65, 66) # define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p(67), 67, 68) # define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71) # define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p(69), 69, 70) # define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p(71), 71, 72) # define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78) # define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75) # define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p(73), 73, 74) # define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p(75), 75, 76) # define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79) # define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p(77), 77, 78) # define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p(79), 79, 80) # define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92) # define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86) # define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83) # define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p(81), 81, 82) # define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p(83), 83, 84) # define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87) # define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p(85), 85, 86) # define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p(87), 87, 88) # define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94) # define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91) # define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p(89), 89, 90) # define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p(91), 91, 92) # define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95) # define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p(93), 93, 94) # define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p(95), 95, 96) # define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120) # define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108) # define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102) # define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99) # define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p(97), 97, 98) # define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p(99), 99, 100) # define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103) # define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p(101), 101, 102) # define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p(103), 103, 104) # define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110) # define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107) # define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p(105), 105, 106) # define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p(107), 107, 108) # define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111) # define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p(109), 109, 110) # define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p(111), 111, 112) # define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124) # define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118) # define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115) # define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p(113), 113, 114) # define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p(115), 115, 116) # define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119) # define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p(117), 117, 118) # define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p(119), 119, 120) # define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126) # define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123) # define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p(121), 121, 122) # define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p(123), 123, 124) # define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127) # define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p(125), 125, 126) # define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p(127), 127, 128) # define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224) # define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176) # define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152) # define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140) # define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134) # define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131) # define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p(129), 129, 130) # define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p(131), 131, 132) # define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135) # define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p(133), 133, 134) # define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p(135), 135, 136) # define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142) # define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139) # define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p(137), 137, 138) # define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p(139), 139, 140) # define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143) # define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p(141), 141, 142) # define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p(143), 143, 144) # define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156) # define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150) # define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147) # define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p(145), 145, 146) # define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p(147), 147, 148) # define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151) # define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p(149), 149, 150) # define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p(151), 151, 152) # define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158) # define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155) # define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p(153), 153, 154) # define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p(155), 155, 156) # define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159) # define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p(157), 157, 158) # define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p(159), 159, 160) # define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184) # define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172) # define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166) # define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163) # define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p(161), 161, 162) # define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p(163), 163, 164) # define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167) # define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p(165), 165, 166) # define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p(167), 167, 168) # define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174) # define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171) # define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p(169), 169, 170) # define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p(171), 171, 172) # define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175) # define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p(173), 173, 174) # define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p(175), 175, 176) # define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188) # define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182) # define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179) # define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p(177), 177, 178) # define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p(179), 179, 180) # define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183) # define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p(181), 181, 182) # define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p(183), 183, 184) # define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190) # define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187) # define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p(185), 185, 186) # define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p(187), 187, 188) # define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191) # define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p(189), 189, 190) # define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p(191), 191, 192) # define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240) # define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216) # define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204) # define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198) # define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195) # define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p(193), 193, 194) # define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p(195), 195, 196) # define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199) # define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p(197), 197, 198) # define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p(199), 199, 200) # define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206) # define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203) # define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p(201), 201, 202) # define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p(203), 203, 204) # define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207) # define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p(205), 205, 206) # define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p(207), 207, 208) # define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220) # define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214) # define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211) # define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p(209), 209, 210) # define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p(211), 211, 212) # define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215) # define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p(213), 213, 214) # define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p(215), 215, 216) # define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222) # define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219) # define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p(217), 217, 218) # define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p(219), 219, 220) # define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223) # define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p(221), 221, 222) # define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p(223), 223, 224) # define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248) # define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236) # define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230) # define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227) # define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p(225), 225, 226) # define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p(227), 227, 228) # define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231) # define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p(229), 229, 230) # define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p(231), 231, 232) # define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238) # define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235) # define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p(233), 233, 234) # define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p(235), 235, 236) # define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239) # define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p(237), 237, 238) # define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p(239), 239, 240) # define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252) # define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246) # define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243) # define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p(241), 241, 242) # define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p(243), 243, 244) # define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247) # define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p(245), 245, 246) # define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p(247), 247, 248) # define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254) # define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251) # define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p(249), 249, 250) # define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p(251), 251, 252) # define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255) # define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p(253), 253, 254) # define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p(255), 255, 256) # # endif # endif ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/is_binary.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/i0000644000175000017500000000233111344301502031604 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP # define BOOST_PREPROCESSOR_DETAIL_IS_BINARY_HPP # # include # include # # /* BOOST_PP_IS_BINARY */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_IS_BINARY(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) # else # define BOOST_PP_IS_BINARY(x) BOOST_PP_IS_BINARY_I(x) # define BOOST_PP_IS_BINARY_I(x) BOOST_PP_CHECK(x, BOOST_PP_IS_BINARY_CHECK) # endif # # define BOOST_PP_IS_BINARY_CHECK(a, b) 1 # define BOOST_PP_CHECK_RESULT_BOOST_PP_IS_BINARY_CHECK 0, BOOST_PP_NIL # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/dmc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/d0000755000175000017500000000000012146213764031613 5ustar debiandebian././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/dmc/auto_rec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/d0000644000175000017500000006354211344301502031612 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP # define BOOST_PREPROCESSOR_DETAIL_AUTO_REC_HPP # # include # # /* BOOST_PP_AUTO_REC */ # # define BOOST_PP_AUTO_REC(pred, n) BOOST_PP_NODE_ENTRY_ ## n(pred) # # define BOOST_PP_NODE_ENTRY_256(p) BOOST_PP_NODE_128(p)(p)(p)(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_128(p) BOOST_PP_NODE_64(p)(p)(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_64(p) BOOST_PP_NODE_32(p)(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_32(p) BOOST_PP_NODE_16(p)(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_16(p) BOOST_PP_NODE_8(p)(p)(p)(p) # define BOOST_PP_NODE_ENTRY_8(p) BOOST_PP_NODE_4(p)(p)(p) # define BOOST_PP_NODE_ENTRY_4(p) BOOST_PP_NODE_2(p)(p) # define BOOST_PP_NODE_ENTRY_2(p) BOOST_PP_NODE_1(p) # # define BOOST_PP_NODE_128(p) BOOST_PP_IIF(p##(128), BOOST_PP_NODE_64, BOOST_PP_NODE_192) # define BOOST_PP_NODE_64(p) BOOST_PP_IIF(p##(64), BOOST_PP_NODE_32, BOOST_PP_NODE_96) # define BOOST_PP_NODE_32(p) BOOST_PP_IIF(p##(32), BOOST_PP_NODE_16, BOOST_PP_NODE_48) # define BOOST_PP_NODE_16(p) BOOST_PP_IIF(p##(16), BOOST_PP_NODE_8, BOOST_PP_NODE_24) # define BOOST_PP_NODE_8(p) BOOST_PP_IIF(p##(8), BOOST_PP_NODE_4, BOOST_PP_NODE_12) # define BOOST_PP_NODE_4(p) BOOST_PP_IIF(p##(4), BOOST_PP_NODE_2, BOOST_PP_NODE_6) # define BOOST_PP_NODE_2(p) BOOST_PP_IIF(p##(2), BOOST_PP_NODE_1, BOOST_PP_NODE_3) # define BOOST_PP_NODE_1(p) BOOST_PP_IIF(p##(1), 1, 2) # define BOOST_PP_NODE_3(p) BOOST_PP_IIF(p##(3), 3, 4) # define BOOST_PP_NODE_6(p) BOOST_PP_IIF(p##(6), BOOST_PP_NODE_5, BOOST_PP_NODE_7) # define BOOST_PP_NODE_5(p) BOOST_PP_IIF(p##(5), 5, 6) # define BOOST_PP_NODE_7(p) BOOST_PP_IIF(p##(7), 7, 8) # define BOOST_PP_NODE_12(p) BOOST_PP_IIF(p##(12), BOOST_PP_NODE_10, BOOST_PP_NODE_14) # define BOOST_PP_NODE_10(p) BOOST_PP_IIF(p##(10), BOOST_PP_NODE_9, BOOST_PP_NODE_11) # define BOOST_PP_NODE_9(p) BOOST_PP_IIF(p##(9), 9, 10) # define BOOST_PP_NODE_11(p) BOOST_PP_IIF(p##(11), 11, 12) # define BOOST_PP_NODE_14(p) BOOST_PP_IIF(p##(14), BOOST_PP_NODE_13, BOOST_PP_NODE_15) # define BOOST_PP_NODE_13(p) BOOST_PP_IIF(p##(13), 13, 14) # define BOOST_PP_NODE_15(p) BOOST_PP_IIF(p##(15), 15, 16) # define BOOST_PP_NODE_24(p) BOOST_PP_IIF(p##(24), BOOST_PP_NODE_20, BOOST_PP_NODE_28) # define BOOST_PP_NODE_20(p) BOOST_PP_IIF(p##(20), BOOST_PP_NODE_18, BOOST_PP_NODE_22) # define BOOST_PP_NODE_18(p) BOOST_PP_IIF(p##(18), BOOST_PP_NODE_17, BOOST_PP_NODE_19) # define BOOST_PP_NODE_17(p) BOOST_PP_IIF(p##(17), 17, 18) # define BOOST_PP_NODE_19(p) BOOST_PP_IIF(p##(19), 19, 20) # define BOOST_PP_NODE_22(p) BOOST_PP_IIF(p##(22), BOOST_PP_NODE_21, BOOST_PP_NODE_23) # define BOOST_PP_NODE_21(p) BOOST_PP_IIF(p##(21), 21, 22) # define BOOST_PP_NODE_23(p) BOOST_PP_IIF(p##(23), 23, 24) # define BOOST_PP_NODE_28(p) BOOST_PP_IIF(p##(28), BOOST_PP_NODE_26, BOOST_PP_NODE_30) # define BOOST_PP_NODE_26(p) BOOST_PP_IIF(p##(26), BOOST_PP_NODE_25, BOOST_PP_NODE_27) # define BOOST_PP_NODE_25(p) BOOST_PP_IIF(p##(25), 25, 26) # define BOOST_PP_NODE_27(p) BOOST_PP_IIF(p##(27), 27, 28) # define BOOST_PP_NODE_30(p) BOOST_PP_IIF(p##(30), BOOST_PP_NODE_29, BOOST_PP_NODE_31) # define BOOST_PP_NODE_29(p) BOOST_PP_IIF(p##(29), 29, 30) # define BOOST_PP_NODE_31(p) BOOST_PP_IIF(p##(31), 31, 32) # define BOOST_PP_NODE_48(p) BOOST_PP_IIF(p##(48), BOOST_PP_NODE_40, BOOST_PP_NODE_56) # define BOOST_PP_NODE_40(p) BOOST_PP_IIF(p##(40), BOOST_PP_NODE_36, BOOST_PP_NODE_44) # define BOOST_PP_NODE_36(p) BOOST_PP_IIF(p##(36), BOOST_PP_NODE_34, BOOST_PP_NODE_38) # define BOOST_PP_NODE_34(p) BOOST_PP_IIF(p##(34), BOOST_PP_NODE_33, BOOST_PP_NODE_35) # define BOOST_PP_NODE_33(p) BOOST_PP_IIF(p##(33), 33, 34) # define BOOST_PP_NODE_35(p) BOOST_PP_IIF(p##(35), 35, 36) # define BOOST_PP_NODE_38(p) BOOST_PP_IIF(p##(38), BOOST_PP_NODE_37, BOOST_PP_NODE_39) # define BOOST_PP_NODE_37(p) BOOST_PP_IIF(p##(37), 37, 38) # define BOOST_PP_NODE_39(p) BOOST_PP_IIF(p##(39), 39, 40) # define BOOST_PP_NODE_44(p) BOOST_PP_IIF(p##(44), BOOST_PP_NODE_42, BOOST_PP_NODE_46) # define BOOST_PP_NODE_42(p) BOOST_PP_IIF(p##(42), BOOST_PP_NODE_41, BOOST_PP_NODE_43) # define BOOST_PP_NODE_41(p) BOOST_PP_IIF(p##(41), 41, 42) # define BOOST_PP_NODE_43(p) BOOST_PP_IIF(p##(43), 43, 44) # define BOOST_PP_NODE_46(p) BOOST_PP_IIF(p##(46), BOOST_PP_NODE_45, BOOST_PP_NODE_47) # define BOOST_PP_NODE_45(p) BOOST_PP_IIF(p##(45), 45, 46) # define BOOST_PP_NODE_47(p) BOOST_PP_IIF(p##(47), 47, 48) # define BOOST_PP_NODE_56(p) BOOST_PP_IIF(p##(56), BOOST_PP_NODE_52, BOOST_PP_NODE_60) # define BOOST_PP_NODE_52(p) BOOST_PP_IIF(p##(52), BOOST_PP_NODE_50, BOOST_PP_NODE_54) # define BOOST_PP_NODE_50(p) BOOST_PP_IIF(p##(50), BOOST_PP_NODE_49, BOOST_PP_NODE_51) # define BOOST_PP_NODE_49(p) BOOST_PP_IIF(p##(49), 49, 50) # define BOOST_PP_NODE_51(p) BOOST_PP_IIF(p##(51), 51, 52) # define BOOST_PP_NODE_54(p) BOOST_PP_IIF(p##(54), BOOST_PP_NODE_53, BOOST_PP_NODE_55) # define BOOST_PP_NODE_53(p) BOOST_PP_IIF(p##(53), 53, 54) # define BOOST_PP_NODE_55(p) BOOST_PP_IIF(p##(55), 55, 56) # define BOOST_PP_NODE_60(p) BOOST_PP_IIF(p##(60), BOOST_PP_NODE_58, BOOST_PP_NODE_62) # define BOOST_PP_NODE_58(p) BOOST_PP_IIF(p##(58), BOOST_PP_NODE_57, BOOST_PP_NODE_59) # define BOOST_PP_NODE_57(p) BOOST_PP_IIF(p##(57), 57, 58) # define BOOST_PP_NODE_59(p) BOOST_PP_IIF(p##(59), 59, 60) # define BOOST_PP_NODE_62(p) BOOST_PP_IIF(p##(62), BOOST_PP_NODE_61, BOOST_PP_NODE_63) # define BOOST_PP_NODE_61(p) BOOST_PP_IIF(p##(61), 61, 62) # define BOOST_PP_NODE_63(p) BOOST_PP_IIF(p##(63), 63, 64) # define BOOST_PP_NODE_96(p) BOOST_PP_IIF(p##(96), BOOST_PP_NODE_80, BOOST_PP_NODE_112) # define BOOST_PP_NODE_80(p) BOOST_PP_IIF(p##(80), BOOST_PP_NODE_72, BOOST_PP_NODE_88) # define BOOST_PP_NODE_72(p) BOOST_PP_IIF(p##(72), BOOST_PP_NODE_68, BOOST_PP_NODE_76) # define BOOST_PP_NODE_68(p) BOOST_PP_IIF(p##(68), BOOST_PP_NODE_66, BOOST_PP_NODE_70) # define BOOST_PP_NODE_66(p) BOOST_PP_IIF(p##(66), BOOST_PP_NODE_65, BOOST_PP_NODE_67) # define BOOST_PP_NODE_65(p) BOOST_PP_IIF(p##(65), 65, 66) # define BOOST_PP_NODE_67(p) BOOST_PP_IIF(p##(67), 67, 68) # define BOOST_PP_NODE_70(p) BOOST_PP_IIF(p##(70), BOOST_PP_NODE_69, BOOST_PP_NODE_71) # define BOOST_PP_NODE_69(p) BOOST_PP_IIF(p##(69), 69, 70) # define BOOST_PP_NODE_71(p) BOOST_PP_IIF(p##(71), 71, 72) # define BOOST_PP_NODE_76(p) BOOST_PP_IIF(p##(76), BOOST_PP_NODE_74, BOOST_PP_NODE_78) # define BOOST_PP_NODE_74(p) BOOST_PP_IIF(p##(74), BOOST_PP_NODE_73, BOOST_PP_NODE_75) # define BOOST_PP_NODE_73(p) BOOST_PP_IIF(p##(73), 73, 74) # define BOOST_PP_NODE_75(p) BOOST_PP_IIF(p##(75), 75, 76) # define BOOST_PP_NODE_78(p) BOOST_PP_IIF(p##(78), BOOST_PP_NODE_77, BOOST_PP_NODE_79) # define BOOST_PP_NODE_77(p) BOOST_PP_IIF(p##(77), 77, 78) # define BOOST_PP_NODE_79(p) BOOST_PP_IIF(p##(79), 79, 80) # define BOOST_PP_NODE_88(p) BOOST_PP_IIF(p##(88), BOOST_PP_NODE_84, BOOST_PP_NODE_92) # define BOOST_PP_NODE_84(p) BOOST_PP_IIF(p##(84), BOOST_PP_NODE_82, BOOST_PP_NODE_86) # define BOOST_PP_NODE_82(p) BOOST_PP_IIF(p##(82), BOOST_PP_NODE_81, BOOST_PP_NODE_83) # define BOOST_PP_NODE_81(p) BOOST_PP_IIF(p##(81), 81, 82) # define BOOST_PP_NODE_83(p) BOOST_PP_IIF(p##(83), 83, 84) # define BOOST_PP_NODE_86(p) BOOST_PP_IIF(p##(86), BOOST_PP_NODE_85, BOOST_PP_NODE_87) # define BOOST_PP_NODE_85(p) BOOST_PP_IIF(p##(85), 85, 86) # define BOOST_PP_NODE_87(p) BOOST_PP_IIF(p##(87), 87, 88) # define BOOST_PP_NODE_92(p) BOOST_PP_IIF(p##(92), BOOST_PP_NODE_90, BOOST_PP_NODE_94) # define BOOST_PP_NODE_90(p) BOOST_PP_IIF(p##(90), BOOST_PP_NODE_89, BOOST_PP_NODE_91) # define BOOST_PP_NODE_89(p) BOOST_PP_IIF(p##(89), 89, 90) # define BOOST_PP_NODE_91(p) BOOST_PP_IIF(p##(91), 91, 92) # define BOOST_PP_NODE_94(p) BOOST_PP_IIF(p##(94), BOOST_PP_NODE_93, BOOST_PP_NODE_95) # define BOOST_PP_NODE_93(p) BOOST_PP_IIF(p##(93), 93, 94) # define BOOST_PP_NODE_95(p) BOOST_PP_IIF(p##(95), 95, 96) # define BOOST_PP_NODE_112(p) BOOST_PP_IIF(p##(112), BOOST_PP_NODE_104, BOOST_PP_NODE_120) # define BOOST_PP_NODE_104(p) BOOST_PP_IIF(p##(104), BOOST_PP_NODE_100, BOOST_PP_NODE_108) # define BOOST_PP_NODE_100(p) BOOST_PP_IIF(p##(100), BOOST_PP_NODE_98, BOOST_PP_NODE_102) # define BOOST_PP_NODE_98(p) BOOST_PP_IIF(p##(98), BOOST_PP_NODE_97, BOOST_PP_NODE_99) # define BOOST_PP_NODE_97(p) BOOST_PP_IIF(p##(97), 97, 98) # define BOOST_PP_NODE_99(p) BOOST_PP_IIF(p##(99), 99, 100) # define BOOST_PP_NODE_102(p) BOOST_PP_IIF(p##(102), BOOST_PP_NODE_101, BOOST_PP_NODE_103) # define BOOST_PP_NODE_101(p) BOOST_PP_IIF(p##(101), 101, 102) # define BOOST_PP_NODE_103(p) BOOST_PP_IIF(p##(103), 103, 104) # define BOOST_PP_NODE_108(p) BOOST_PP_IIF(p##(108), BOOST_PP_NODE_106, BOOST_PP_NODE_110) # define BOOST_PP_NODE_106(p) BOOST_PP_IIF(p##(106), BOOST_PP_NODE_105, BOOST_PP_NODE_107) # define BOOST_PP_NODE_105(p) BOOST_PP_IIF(p##(105), 105, 106) # define BOOST_PP_NODE_107(p) BOOST_PP_IIF(p##(107), 107, 108) # define BOOST_PP_NODE_110(p) BOOST_PP_IIF(p##(110), BOOST_PP_NODE_109, BOOST_PP_NODE_111) # define BOOST_PP_NODE_109(p) BOOST_PP_IIF(p##(109), 109, 110) # define BOOST_PP_NODE_111(p) BOOST_PP_IIF(p##(111), 111, 112) # define BOOST_PP_NODE_120(p) BOOST_PP_IIF(p##(120), BOOST_PP_NODE_116, BOOST_PP_NODE_124) # define BOOST_PP_NODE_116(p) BOOST_PP_IIF(p##(116), BOOST_PP_NODE_114, BOOST_PP_NODE_118) # define BOOST_PP_NODE_114(p) BOOST_PP_IIF(p##(114), BOOST_PP_NODE_113, BOOST_PP_NODE_115) # define BOOST_PP_NODE_113(p) BOOST_PP_IIF(p##(113), 113, 114) # define BOOST_PP_NODE_115(p) BOOST_PP_IIF(p##(115), 115, 116) # define BOOST_PP_NODE_118(p) BOOST_PP_IIF(p##(118), BOOST_PP_NODE_117, BOOST_PP_NODE_119) # define BOOST_PP_NODE_117(p) BOOST_PP_IIF(p##(117), 117, 118) # define BOOST_PP_NODE_119(p) BOOST_PP_IIF(p##(119), 119, 120) # define BOOST_PP_NODE_124(p) BOOST_PP_IIF(p##(124), BOOST_PP_NODE_122, BOOST_PP_NODE_126) # define BOOST_PP_NODE_122(p) BOOST_PP_IIF(p##(122), BOOST_PP_NODE_121, BOOST_PP_NODE_123) # define BOOST_PP_NODE_121(p) BOOST_PP_IIF(p##(121), 121, 122) # define BOOST_PP_NODE_123(p) BOOST_PP_IIF(p##(123), 123, 124) # define BOOST_PP_NODE_126(p) BOOST_PP_IIF(p##(126), BOOST_PP_NODE_125, BOOST_PP_NODE_127) # define BOOST_PP_NODE_125(p) BOOST_PP_IIF(p##(125), 125, 126) # define BOOST_PP_NODE_127(p) BOOST_PP_IIF(p##(127), 127, 128) # define BOOST_PP_NODE_192(p) BOOST_PP_IIF(p##(192), BOOST_PP_NODE_160, BOOST_PP_NODE_224) # define BOOST_PP_NODE_160(p) BOOST_PP_IIF(p##(160), BOOST_PP_NODE_144, BOOST_PP_NODE_176) # define BOOST_PP_NODE_144(p) BOOST_PP_IIF(p##(144), BOOST_PP_NODE_136, BOOST_PP_NODE_152) # define BOOST_PP_NODE_136(p) BOOST_PP_IIF(p##(136), BOOST_PP_NODE_132, BOOST_PP_NODE_140) # define BOOST_PP_NODE_132(p) BOOST_PP_IIF(p##(132), BOOST_PP_NODE_130, BOOST_PP_NODE_134) # define BOOST_PP_NODE_130(p) BOOST_PP_IIF(p##(130), BOOST_PP_NODE_129, BOOST_PP_NODE_131) # define BOOST_PP_NODE_129(p) BOOST_PP_IIF(p##(129), 129, 130) # define BOOST_PP_NODE_131(p) BOOST_PP_IIF(p##(131), 131, 132) # define BOOST_PP_NODE_134(p) BOOST_PP_IIF(p##(134), BOOST_PP_NODE_133, BOOST_PP_NODE_135) # define BOOST_PP_NODE_133(p) BOOST_PP_IIF(p##(133), 133, 134) # define BOOST_PP_NODE_135(p) BOOST_PP_IIF(p##(135), 135, 136) # define BOOST_PP_NODE_140(p) BOOST_PP_IIF(p##(140), BOOST_PP_NODE_138, BOOST_PP_NODE_142) # define BOOST_PP_NODE_138(p) BOOST_PP_IIF(p##(138), BOOST_PP_NODE_137, BOOST_PP_NODE_139) # define BOOST_PP_NODE_137(p) BOOST_PP_IIF(p##(137), 137, 138) # define BOOST_PP_NODE_139(p) BOOST_PP_IIF(p##(139), 139, 140) # define BOOST_PP_NODE_142(p) BOOST_PP_IIF(p##(142), BOOST_PP_NODE_141, BOOST_PP_NODE_143) # define BOOST_PP_NODE_141(p) BOOST_PP_IIF(p##(141), 141, 142) # define BOOST_PP_NODE_143(p) BOOST_PP_IIF(p##(143), 143, 144) # define BOOST_PP_NODE_152(p) BOOST_PP_IIF(p##(152), BOOST_PP_NODE_148, BOOST_PP_NODE_156) # define BOOST_PP_NODE_148(p) BOOST_PP_IIF(p##(148), BOOST_PP_NODE_146, BOOST_PP_NODE_150) # define BOOST_PP_NODE_146(p) BOOST_PP_IIF(p##(146), BOOST_PP_NODE_145, BOOST_PP_NODE_147) # define BOOST_PP_NODE_145(p) BOOST_PP_IIF(p##(145), 145, 146) # define BOOST_PP_NODE_147(p) BOOST_PP_IIF(p##(147), 147, 148) # define BOOST_PP_NODE_150(p) BOOST_PP_IIF(p##(150), BOOST_PP_NODE_149, BOOST_PP_NODE_151) # define BOOST_PP_NODE_149(p) BOOST_PP_IIF(p##(149), 149, 150) # define BOOST_PP_NODE_151(p) BOOST_PP_IIF(p##(151), 151, 152) # define BOOST_PP_NODE_156(p) BOOST_PP_IIF(p##(156), BOOST_PP_NODE_154, BOOST_PP_NODE_158) # define BOOST_PP_NODE_154(p) BOOST_PP_IIF(p##(154), BOOST_PP_NODE_153, BOOST_PP_NODE_155) # define BOOST_PP_NODE_153(p) BOOST_PP_IIF(p##(153), 153, 154) # define BOOST_PP_NODE_155(p) BOOST_PP_IIF(p##(155), 155, 156) # define BOOST_PP_NODE_158(p) BOOST_PP_IIF(p##(158), BOOST_PP_NODE_157, BOOST_PP_NODE_159) # define BOOST_PP_NODE_157(p) BOOST_PP_IIF(p##(157), 157, 158) # define BOOST_PP_NODE_159(p) BOOST_PP_IIF(p##(159), 159, 160) # define BOOST_PP_NODE_176(p) BOOST_PP_IIF(p##(176), BOOST_PP_NODE_168, BOOST_PP_NODE_184) # define BOOST_PP_NODE_168(p) BOOST_PP_IIF(p##(168), BOOST_PP_NODE_164, BOOST_PP_NODE_172) # define BOOST_PP_NODE_164(p) BOOST_PP_IIF(p##(164), BOOST_PP_NODE_162, BOOST_PP_NODE_166) # define BOOST_PP_NODE_162(p) BOOST_PP_IIF(p##(162), BOOST_PP_NODE_161, BOOST_PP_NODE_163) # define BOOST_PP_NODE_161(p) BOOST_PP_IIF(p##(161), 161, 162) # define BOOST_PP_NODE_163(p) BOOST_PP_IIF(p##(163), 163, 164) # define BOOST_PP_NODE_166(p) BOOST_PP_IIF(p##(166), BOOST_PP_NODE_165, BOOST_PP_NODE_167) # define BOOST_PP_NODE_165(p) BOOST_PP_IIF(p##(165), 165, 166) # define BOOST_PP_NODE_167(p) BOOST_PP_IIF(p##(167), 167, 168) # define BOOST_PP_NODE_172(p) BOOST_PP_IIF(p##(172), BOOST_PP_NODE_170, BOOST_PP_NODE_174) # define BOOST_PP_NODE_170(p) BOOST_PP_IIF(p##(170), BOOST_PP_NODE_169, BOOST_PP_NODE_171) # define BOOST_PP_NODE_169(p) BOOST_PP_IIF(p##(169), 169, 170) # define BOOST_PP_NODE_171(p) BOOST_PP_IIF(p##(171), 171, 172) # define BOOST_PP_NODE_174(p) BOOST_PP_IIF(p##(174), BOOST_PP_NODE_173, BOOST_PP_NODE_175) # define BOOST_PP_NODE_173(p) BOOST_PP_IIF(p##(173), 173, 174) # define BOOST_PP_NODE_175(p) BOOST_PP_IIF(p##(175), 175, 176) # define BOOST_PP_NODE_184(p) BOOST_PP_IIF(p##(184), BOOST_PP_NODE_180, BOOST_PP_NODE_188) # define BOOST_PP_NODE_180(p) BOOST_PP_IIF(p##(180), BOOST_PP_NODE_178, BOOST_PP_NODE_182) # define BOOST_PP_NODE_178(p) BOOST_PP_IIF(p##(178), BOOST_PP_NODE_177, BOOST_PP_NODE_179) # define BOOST_PP_NODE_177(p) BOOST_PP_IIF(p##(177), 177, 178) # define BOOST_PP_NODE_179(p) BOOST_PP_IIF(p##(179), 179, 180) # define BOOST_PP_NODE_182(p) BOOST_PP_IIF(p##(182), BOOST_PP_NODE_181, BOOST_PP_NODE_183) # define BOOST_PP_NODE_181(p) BOOST_PP_IIF(p##(181), 181, 182) # define BOOST_PP_NODE_183(p) BOOST_PP_IIF(p##(183), 183, 184) # define BOOST_PP_NODE_188(p) BOOST_PP_IIF(p##(188), BOOST_PP_NODE_186, BOOST_PP_NODE_190) # define BOOST_PP_NODE_186(p) BOOST_PP_IIF(p##(186), BOOST_PP_NODE_185, BOOST_PP_NODE_187) # define BOOST_PP_NODE_185(p) BOOST_PP_IIF(p##(185), 185, 186) # define BOOST_PP_NODE_187(p) BOOST_PP_IIF(p##(187), 187, 188) # define BOOST_PP_NODE_190(p) BOOST_PP_IIF(p##(190), BOOST_PP_NODE_189, BOOST_PP_NODE_191) # define BOOST_PP_NODE_189(p) BOOST_PP_IIF(p##(189), 189, 190) # define BOOST_PP_NODE_191(p) BOOST_PP_IIF(p##(191), 191, 192) # define BOOST_PP_NODE_224(p) BOOST_PP_IIF(p##(224), BOOST_PP_NODE_208, BOOST_PP_NODE_240) # define BOOST_PP_NODE_208(p) BOOST_PP_IIF(p##(208), BOOST_PP_NODE_200, BOOST_PP_NODE_216) # define BOOST_PP_NODE_200(p) BOOST_PP_IIF(p##(200), BOOST_PP_NODE_196, BOOST_PP_NODE_204) # define BOOST_PP_NODE_196(p) BOOST_PP_IIF(p##(196), BOOST_PP_NODE_194, BOOST_PP_NODE_198) # define BOOST_PP_NODE_194(p) BOOST_PP_IIF(p##(194), BOOST_PP_NODE_193, BOOST_PP_NODE_195) # define BOOST_PP_NODE_193(p) BOOST_PP_IIF(p##(193), 193, 194) # define BOOST_PP_NODE_195(p) BOOST_PP_IIF(p##(195), 195, 196) # define BOOST_PP_NODE_198(p) BOOST_PP_IIF(p##(198), BOOST_PP_NODE_197, BOOST_PP_NODE_199) # define BOOST_PP_NODE_197(p) BOOST_PP_IIF(p##(197), 197, 198) # define BOOST_PP_NODE_199(p) BOOST_PP_IIF(p##(199), 199, 200) # define BOOST_PP_NODE_204(p) BOOST_PP_IIF(p##(204), BOOST_PP_NODE_202, BOOST_PP_NODE_206) # define BOOST_PP_NODE_202(p) BOOST_PP_IIF(p##(202), BOOST_PP_NODE_201, BOOST_PP_NODE_203) # define BOOST_PP_NODE_201(p) BOOST_PP_IIF(p##(201), 201, 202) # define BOOST_PP_NODE_203(p) BOOST_PP_IIF(p##(203), 203, 204) # define BOOST_PP_NODE_206(p) BOOST_PP_IIF(p##(206), BOOST_PP_NODE_205, BOOST_PP_NODE_207) # define BOOST_PP_NODE_205(p) BOOST_PP_IIF(p##(205), 205, 206) # define BOOST_PP_NODE_207(p) BOOST_PP_IIF(p##(207), 207, 208) # define BOOST_PP_NODE_216(p) BOOST_PP_IIF(p##(216), BOOST_PP_NODE_212, BOOST_PP_NODE_220) # define BOOST_PP_NODE_212(p) BOOST_PP_IIF(p##(212), BOOST_PP_NODE_210, BOOST_PP_NODE_214) # define BOOST_PP_NODE_210(p) BOOST_PP_IIF(p##(210), BOOST_PP_NODE_209, BOOST_PP_NODE_211) # define BOOST_PP_NODE_209(p) BOOST_PP_IIF(p##(209), 209, 210) # define BOOST_PP_NODE_211(p) BOOST_PP_IIF(p##(211), 211, 212) # define BOOST_PP_NODE_214(p) BOOST_PP_IIF(p##(214), BOOST_PP_NODE_213, BOOST_PP_NODE_215) # define BOOST_PP_NODE_213(p) BOOST_PP_IIF(p##(213), 213, 214) # define BOOST_PP_NODE_215(p) BOOST_PP_IIF(p##(215), 215, 216) # define BOOST_PP_NODE_220(p) BOOST_PP_IIF(p##(220), BOOST_PP_NODE_218, BOOST_PP_NODE_222) # define BOOST_PP_NODE_218(p) BOOST_PP_IIF(p##(218), BOOST_PP_NODE_217, BOOST_PP_NODE_219) # define BOOST_PP_NODE_217(p) BOOST_PP_IIF(p##(217), 217, 218) # define BOOST_PP_NODE_219(p) BOOST_PP_IIF(p##(219), 219, 220) # define BOOST_PP_NODE_222(p) BOOST_PP_IIF(p##(222), BOOST_PP_NODE_221, BOOST_PP_NODE_223) # define BOOST_PP_NODE_221(p) BOOST_PP_IIF(p##(221), 221, 222) # define BOOST_PP_NODE_223(p) BOOST_PP_IIF(p##(223), 223, 224) # define BOOST_PP_NODE_240(p) BOOST_PP_IIF(p##(240), BOOST_PP_NODE_232, BOOST_PP_NODE_248) # define BOOST_PP_NODE_232(p) BOOST_PP_IIF(p##(232), BOOST_PP_NODE_228, BOOST_PP_NODE_236) # define BOOST_PP_NODE_228(p) BOOST_PP_IIF(p##(228), BOOST_PP_NODE_226, BOOST_PP_NODE_230) # define BOOST_PP_NODE_226(p) BOOST_PP_IIF(p##(226), BOOST_PP_NODE_225, BOOST_PP_NODE_227) # define BOOST_PP_NODE_225(p) BOOST_PP_IIF(p##(225), 225, 226) # define BOOST_PP_NODE_227(p) BOOST_PP_IIF(p##(227), 227, 228) # define BOOST_PP_NODE_230(p) BOOST_PP_IIF(p##(230), BOOST_PP_NODE_229, BOOST_PP_NODE_231) # define BOOST_PP_NODE_229(p) BOOST_PP_IIF(p##(229), 229, 230) # define BOOST_PP_NODE_231(p) BOOST_PP_IIF(p##(231), 231, 232) # define BOOST_PP_NODE_236(p) BOOST_PP_IIF(p##(236), BOOST_PP_NODE_234, BOOST_PP_NODE_238) # define BOOST_PP_NODE_234(p) BOOST_PP_IIF(p##(234), BOOST_PP_NODE_233, BOOST_PP_NODE_235) # define BOOST_PP_NODE_233(p) BOOST_PP_IIF(p##(233), 233, 234) # define BOOST_PP_NODE_235(p) BOOST_PP_IIF(p##(235), 235, 236) # define BOOST_PP_NODE_238(p) BOOST_PP_IIF(p##(238), BOOST_PP_NODE_237, BOOST_PP_NODE_239) # define BOOST_PP_NODE_237(p) BOOST_PP_IIF(p##(237), 237, 238) # define BOOST_PP_NODE_239(p) BOOST_PP_IIF(p##(239), 239, 240) # define BOOST_PP_NODE_248(p) BOOST_PP_IIF(p##(248), BOOST_PP_NODE_244, BOOST_PP_NODE_252) # define BOOST_PP_NODE_244(p) BOOST_PP_IIF(p##(244), BOOST_PP_NODE_242, BOOST_PP_NODE_246) # define BOOST_PP_NODE_242(p) BOOST_PP_IIF(p##(242), BOOST_PP_NODE_241, BOOST_PP_NODE_243) # define BOOST_PP_NODE_241(p) BOOST_PP_IIF(p##(241), 241, 242) # define BOOST_PP_NODE_243(p) BOOST_PP_IIF(p##(243), 243, 244) # define BOOST_PP_NODE_246(p) BOOST_PP_IIF(p##(246), BOOST_PP_NODE_245, BOOST_PP_NODE_247) # define BOOST_PP_NODE_245(p) BOOST_PP_IIF(p##(245), 245, 246) # define BOOST_PP_NODE_247(p) BOOST_PP_IIF(p##(247), 247, 248) # define BOOST_PP_NODE_252(p) BOOST_PP_IIF(p##(252), BOOST_PP_NODE_250, BOOST_PP_NODE_254) # define BOOST_PP_NODE_250(p) BOOST_PP_IIF(p##(250), BOOST_PP_NODE_249, BOOST_PP_NODE_251) # define BOOST_PP_NODE_249(p) BOOST_PP_IIF(p##(249), 249, 250) # define BOOST_PP_NODE_251(p) BOOST_PP_IIF(p##(251), 251, 252) # define BOOST_PP_NODE_254(p) BOOST_PP_IIF(p##(254), BOOST_PP_NODE_253, BOOST_PP_NODE_255) # define BOOST_PP_NODE_253(p) BOOST_PP_IIF(p##(253), 253, 254) # define BOOST_PP_NODE_255(p) BOOST_PP_IIF(p##(255), 255, 256) # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/check.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/detail/c0000644000175000017500000000420411344301502031577 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_DETAIL_CHECK_HPP # define BOOST_PREPROCESSOR_DETAIL_CHECK_HPP # # include # include # # /* BOOST_PP_CHECK */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_D(x, type) # else # define BOOST_PP_CHECK(x, type) BOOST_PP_CHECK_OO((x, type)) # define BOOST_PP_CHECK_OO(par) BOOST_PP_CHECK_D ## par # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, type x)) # define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) # define BOOST_PP_CHECK_2(res, _) res # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_1(type x) # define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) # define BOOST_PP_CHECK_2(chk) BOOST_PP_CHECK_3((BOOST_PP_CHECK_RESULT_ ## chk)) # define BOOST_PP_CHECK_3(im) BOOST_PP_CHECK_5(BOOST_PP_CHECK_4 im) # define BOOST_PP_CHECK_4(res, _) res # define BOOST_PP_CHECK_5(res) res # else // DMC # define BOOST_PP_CHECK_D(x, type) BOOST_PP_CHECK_OO((type x)) # define BOOST_PP_CHECK_OO(par) BOOST_PP_CHECK_0 ## par # define BOOST_PP_CHECK_0(chk) BOOST_PP_CHECK_1(BOOST_PP_CAT(BOOST_PP_CHECK_RESULT_, chk)) # define BOOST_PP_CHECK_1(chk) BOOST_PP_CHECK_2(chk) # define BOOST_PP_CHECK_2(res, _) res # endif # # define BOOST_PP_CHECK_RESULT_1 1, BOOST_PP_NIL # # endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selection/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selectio0000755000175000017500000000000012146213770031732 5ustar debiandebian././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selection/max.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selectio0000644000175000017500000000234011344301502031721 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SELECTION_MAX_HPP # define BOOST_PREPROCESSOR_SELECTION_MAX_HPP # # include # include # include # # /* BOOST_PP_MAX */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MAX(x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL(x, y), y, x) # else # define BOOST_PP_MAX(x, y) BOOST_PP_MAX_I(x, y) # define BOOST_PP_MAX_I(x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL(x, y), y, x) # endif # # /* BOOST_PP_MAX_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MAX_D(d, x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL_D(d, x, y), y, x) # else # define BOOST_PP_MAX_D(d, x, y) BOOST_PP_MAX_D_I(d, x, y) # define BOOST_PP_MAX_D_I(d, x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL_D(d, x, y), y, x) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selection/min.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/selectio0000644000175000017500000000234011344301502031721 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SELECTION_MIN_HPP # define BOOST_PREPROCESSOR_SELECTION_MIN_HPP # # include # include # include # # /* BOOST_PP_MIN */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MIN(x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL(y, x), y, x) # else # define BOOST_PP_MIN(x, y) BOOST_PP_MIN_I(x, y) # define BOOST_PP_MIN_I(x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL(y, x), y, x) # endif # # /* BOOST_PP_MIN_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_MIN_D(d, x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL_D(d, y, x), y, x) # else # define BOOST_PP_MIN_D(d, x, y) BOOST_PP_MIN_D_I(d, x, y) # define BOOST_PP_MIN_D_I(d, x, y) BOOST_PP_IIF(BOOST_PP_LESS_EQUAL_D(d, y, x), y, x) # endif # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/0000755000175000017500000000000012146213766031162 5ustar debiandebian././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/reverse.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/rev0000644000175000017500000000262311344301502031665 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_REVERSE_HPP # define BOOST_PREPROCESSOR_LIST_REVERSE_HPP # # include # include # # /* BOOST_PP_LIST_REVERSE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) # else # define BOOST_PP_LIST_REVERSE(list) BOOST_PP_LIST_REVERSE_I(list) # define BOOST_PP_LIST_REVERSE_I(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) # endif # # define BOOST_PP_LIST_REVERSE_O(d, s, x) (x, s) # # /* BOOST_PP_LIST_REVERSE_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_REVERSE_D(d, list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) # else # define BOOST_PP_LIST_REVERSE_D(d, list) BOOST_PP_LIST_REVERSE_D_I(d, list) # define BOOST_PP_LIST_REVERSE_D_I(d, list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_REVERSE_O, BOOST_PP_NIL, list) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/to_tuple.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/to_0000644000175000017500000000227511344301502031655 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_TO_TUPLE_HPP # define BOOST_PREPROCESSOR_LIST_TO_TUPLE_HPP # # include # include # # /* BOOST_PP_LIST_TO_TUPLE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_TO_TUPLE(list) (BOOST_PP_LIST_ENUM(list)) # else # define BOOST_PP_LIST_TO_TUPLE(list) BOOST_PP_LIST_TO_TUPLE_I(list) # define BOOST_PP_LIST_TO_TUPLE_I(list) (BOOST_PP_LIST_ENUM(list)) # endif # # /* BOOST_PP_LIST_TO_TUPLE_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_TO_TUPLE_R(r, list) (BOOST_PP_LIST_ENUM_R(r, list)) # else # define BOOST_PP_LIST_TO_TUPLE_R(r, list) BOOST_PP_LIST_TO_TUPLE_R_I(r, list) # define BOOST_PP_LIST_TO_TUPLE_R_I(r, list) (BOOST_PP_LIST_ENUM_R(r, list)) # endif # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/for_each_i.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/for0000644000175000017500000000633111344301502031657 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP # define BOOST_PREPROCESSOR_LIST_LIST_FOR_EACH_I_HPP # # include # include # include # include # include # include # # /* BOOST_PP_LIST_FOR_EACH_I */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC() # define BOOST_PP_LIST_FOR_EACH_I(macro, data, list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) # else # define BOOST_PP_LIST_FOR_EACH_I(macro, data, list) BOOST_PP_LIST_FOR_EACH_I_I(macro, data, list) # define BOOST_PP_LIST_FOR_EACH_I_I(macro, data, list) BOOST_PP_FOR((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_LIST_FOR_EACH_I_P(r, x) BOOST_PP_LIST_FOR_EACH_I_P_D x # define BOOST_PP_LIST_FOR_EACH_I_P_D(m, d, l, i) BOOST_PP_LIST_IS_CONS(l) # else # define BOOST_PP_LIST_FOR_EACH_I_P(r, x) BOOST_PP_LIST_IS_CONS(BOOST_PP_TUPLE_ELEM(4, 2, x)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_LIST_FOR_EACH_I_O(r, x) BOOST_PP_LIST_FOR_EACH_I_O_D x # define BOOST_PP_LIST_FOR_EACH_I_O_D(m, d, l, i) (m, d, BOOST_PP_LIST_REST(l), BOOST_PP_INC(i)) # else # define BOOST_PP_LIST_FOR_EACH_I_O(r, x) (BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(4, 2, x)), BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(4, 3, x))) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_I_M(r, x) BOOST_PP_LIST_FOR_EACH_I_M_D(r, BOOST_PP_TUPLE_ELEM(4, 0, x), BOOST_PP_TUPLE_ELEM(4, 1, x), BOOST_PP_TUPLE_ELEM(4, 2, x), BOOST_PP_TUPLE_ELEM(4, 3, x)) # else # define BOOST_PP_LIST_FOR_EACH_I_M(r, x) BOOST_PP_LIST_FOR_EACH_I_M_I(r, BOOST_PP_TUPLE_REM_4 x) # define BOOST_PP_LIST_FOR_EACH_I_M_I(r, x_e) BOOST_PP_LIST_FOR_EACH_I_M_D(r, x_e) # endif # # define BOOST_PP_LIST_FOR_EACH_I_M_D(r, m, d, l, i) m(r, d, i, BOOST_PP_LIST_FIRST(l)) # # /* BOOST_PP_LIST_FOR_EACH_I_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_I_R(r, macro, data, list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) # else # define BOOST_PP_LIST_FOR_EACH_I_R(r, macro, data, list) BOOST_PP_LIST_FOR_EACH_I_R_I(r, macro, data, list) # define BOOST_PP_LIST_FOR_EACH_I_R_I(r, macro, data, list) BOOST_PP_FOR_ ## r((macro, data, list, 0), BOOST_PP_LIST_FOR_EACH_I_P, BOOST_PP_LIST_FOR_EACH_I_O, BOOST_PP_LIST_FOR_EACH_I_M) # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/cat.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/cat0000644000175000017500000000306211344301502031636 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_CAT_HPP # define BOOST_PREPROCESSOR_LIST_CAT_HPP # # include # include # include # include # # /* BOOST_PP_LIST_CAT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_CAT(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_CAT_O, BOOST_PP_LIST_FIRST(list), BOOST_PP_LIST_REST(list)) # else # define BOOST_PP_LIST_CAT(list) BOOST_PP_LIST_CAT_I(list) # define BOOST_PP_LIST_CAT_I(list) BOOST_PP_LIST_FOLD_LEFT(BOOST_PP_LIST_CAT_O, BOOST_PP_LIST_FIRST(list), BOOST_PP_LIST_REST(list)) # endif # # define BOOST_PP_LIST_CAT_O(d, s, x) BOOST_PP_CAT(s, x) # # /* BOOST_PP_LIST_CAT_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_CAT_D(d, list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_CAT_O, BOOST_PP_LIST_FIRST(list), BOOST_PP_LIST_REST(list)) # else # define BOOST_PP_LIST_CAT_D(d, list) BOOST_PP_LIST_CAT_D_I(d, list) # define BOOST_PP_LIST_CAT_D_I(d, list) BOOST_PP_LIST_FOLD_LEFT_ ## d(BOOST_PP_LIST_CAT_O, BOOST_PP_LIST_FIRST(list), BOOST_PP_LIST_REST(list)) # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/adt.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/adt0000644000175000017500000000417311344301502031643 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * # * See http://www.boost.org for most recent version. # */ # # /* Revised by Paul Mensonides (2002) */ # # ifndef BOOST_PREPROCESSOR_LIST_ADT_HPP # define BOOST_PREPROCESSOR_LIST_ADT_HPP # # include # include # include # include # # /* BOOST_PP_LIST_CONS */ # # define BOOST_PP_LIST_CONS(head, tail) (head, tail) # # /* BOOST_PP_LIST_NIL */ # # define BOOST_PP_LIST_NIL BOOST_PP_NIL # # /* BOOST_PP_LIST_FIRST */ # # define BOOST_PP_LIST_FIRST(list) BOOST_PP_LIST_FIRST_D(list) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I list # else # define BOOST_PP_LIST_FIRST_D(list) BOOST_PP_LIST_FIRST_I ## list # endif # # define BOOST_PP_LIST_FIRST_I(head, tail) head # # /* BOOST_PP_LIST_REST */ # # define BOOST_PP_LIST_REST(list) BOOST_PP_LIST_REST_D(list) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I list # else # define BOOST_PP_LIST_REST_D(list) BOOST_PP_LIST_REST_I ## list # endif # # define BOOST_PP_LIST_REST_I(head, tail) tail # # /* BOOST_PP_LIST_IS_CONS */ # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() # define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_LIST_IS_CONS_D(list) # define BOOST_PP_LIST_IS_CONS_D(list) BOOST_PP_LIST_IS_CONS_ ## list # define BOOST_PP_LIST_IS_CONS_(head, tail) 1 # define BOOST_PP_LIST_IS_CONS_BOOST_PP_NIL 0 # else # define BOOST_PP_LIST_IS_CONS(list) BOOST_PP_IS_BINARY(list) # endif # # /* BOOST_PP_LIST_IS_NIL */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() # define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_IS_BINARY(list)) # else # define BOOST_PP_LIST_IS_NIL(list) BOOST_PP_COMPL(BOOST_PP_LIST_IS_CONS(list)) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/filter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/fil0000644000175000017500000000475211344301502031650 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_FILTER_HPP # define BOOST_PREPROCESSOR_LIST_FILTER_HPP # # include # include # include # include # include # # /* BOOST_PP_LIST_FILTER */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FILTER(pred, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_FILTER_O, (pred, data, BOOST_PP_NIL), list)) # else # define BOOST_PP_LIST_FILTER(pred, data, list) BOOST_PP_LIST_FILTER_I(pred, data, list) # define BOOST_PP_LIST_FILTER_I(pred, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_FILTER_O, (pred, data, BOOST_PP_NIL), list)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FILTER_O(d, pdr, elem) BOOST_PP_LIST_FILTER_O_D(d, BOOST_PP_TUPLE_ELEM(3, 0, pdr), BOOST_PP_TUPLE_ELEM(3, 1, pdr), BOOST_PP_TUPLE_ELEM(3, 2, pdr), elem) # else # define BOOST_PP_LIST_FILTER_O(d, pdr, elem) BOOST_PP_LIST_FILTER_O_I(d, BOOST_PP_TUPLE_REM_3 pdr, elem) # define BOOST_PP_LIST_FILTER_O_I(d, im, elem) BOOST_PP_LIST_FILTER_O_D(d, im, elem) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # define BOOST_PP_LIST_FILTER_O_D(d, pred, data, res, elem) (pred, data, BOOST_PP_IF(pred(d, data, elem), (elem, res), res)) # else # define BOOST_PP_LIST_FILTER_O_D(d, pred, data, res, elem) (pred, data, BOOST_PP_IF(pred##(d, data, elem), (elem, res), res)) # endif # # /* BOOST_PP_LIST_FILTER_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FILTER_D(d, pred, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_FILTER_O, (pred, data, BOOST_PP_NIL), list)) # else # define BOOST_PP_LIST_FILTER_D(d, pred, data, list) BOOST_PP_LIST_FILTER_D_I(d, pred, data, list) # define BOOST_PP_LIST_FILTER_D_I(d, pred, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_FILTER_O, (pred, data, BOOST_PP_NIL), list)) # endif # # endif ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/for_each.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/for0000644000175000017500000000405111344301502031654 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_FOR_EACH_HPP # define BOOST_PREPROCESSOR_LIST_FOR_EACH_HPP # # include # include # include # include # # /* BOOST_PP_LIST_FOR_EACH */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH(macro, data, list) BOOST_PP_LIST_FOR_EACH_I(BOOST_PP_LIST_FOR_EACH_O, (macro, data), list) # else # define BOOST_PP_LIST_FOR_EACH(macro, data, list) BOOST_PP_LIST_FOR_EACH_X(macro, data, list) # define BOOST_PP_LIST_FOR_EACH_X(macro, data, list) BOOST_PP_LIST_FOR_EACH_I(BOOST_PP_LIST_FOR_EACH_O, (macro, data), list) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_O(r, md, i, elem) BOOST_PP_LIST_FOR_EACH_O_D(r, BOOST_PP_TUPLE_ELEM(2, 0, md), BOOST_PP_TUPLE_ELEM(2, 1, md), elem) # else # define BOOST_PP_LIST_FOR_EACH_O(r, md, i, elem) BOOST_PP_LIST_FOR_EACH_O_I(r, BOOST_PP_TUPLE_REM_2 md, elem) # define BOOST_PP_LIST_FOR_EACH_O_I(r, im, elem) BOOST_PP_LIST_FOR_EACH_O_D(r, im, elem) # endif # # define BOOST_PP_LIST_FOR_EACH_O_D(r, m, d, elem) m(r, d, elem) # # /* BOOST_PP_LIST_FOR_EACH_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_R(r, macro, data, list) BOOST_PP_LIST_FOR_EACH_I_R(r, BOOST_PP_LIST_FOR_EACH_O, (macro, data), list) # else # define BOOST_PP_LIST_FOR_EACH_R(r, macro, data, list) BOOST_PP_LIST_FOR_EACH_R_X(r, macro, data, list) # define BOOST_PP_LIST_FOR_EACH_R_X(r, macro, data, list) BOOST_PP_LIST_FOR_EACH_I_R(r, BOOST_PP_LIST_FOR_EACH_O, (macro, data), list) # endif # # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/fold_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/fol0000644000175000017500000000245611344301502031655 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP # define BOOST_PREPROCESSOR_LIST_FOLD_RIGHT_HPP # # include # include # include # include # # if 0 # define BOOST_PP_LIST_FOLD_RIGHT(op, state, list) # endif # # define BOOST_PP_LIST_FOLD_RIGHT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_RIGHT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256)) # # define BOOST_PP_LIST_FOLD_RIGHT_257(o, s, l) BOOST_PP_ERROR(0x0004) # # define BOOST_PP_LIST_FOLD_RIGHT_D(d, o, s, l) BOOST_PP_LIST_FOLD_RIGHT_ ## d(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_2ND BOOST_PP_LIST_FOLD_RIGHT # define BOOST_PP_LIST_FOLD_RIGHT_2ND_D BOOST_PP_LIST_FOLD_RIGHT_D # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # include # else # include # endif # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/fold_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/fol0000644000175000017500000005160711344301502031657 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP # define BOOST_PREPROCESSOR_LIST_FOLD_LEFT_HPP # # include # include # include # include # # /* BOOST_PP_LIST_FOLD_LEFT */ # # if 0 # define BOOST_PP_LIST_FOLD_LEFT(op, state, list) # endif # # define BOOST_PP_LIST_FOLD_LEFT BOOST_PP_CAT(BOOST_PP_LIST_FOLD_LEFT_, BOOST_PP_AUTO_REC(BOOST_PP_WHILE_P, 256)) # # define BOOST_PP_LIST_FOLD_LEFT_257(o, s, l) BOOST_PP_ERROR(0x0004) # # define BOOST_PP_LIST_FOLD_LEFT_D(d, o, s, l) BOOST_PP_LIST_FOLD_LEFT_ ## d(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_2ND BOOST_PP_LIST_FOLD_LEFT # define BOOST_PP_LIST_FOLD_LEFT_2ND_D BOOST_PP_LIST_FOLD_LEFT_D # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # include # elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() # include # else # include # endif # # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_NIL 1 # # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_1(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_2(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_3(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_4(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_5(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_6(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_7(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_8(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_9(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_10(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_11(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_12(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_13(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_14(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_15(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_16(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_17(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_18(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_19(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_20(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_21(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_22(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_23(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_24(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_25(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_26(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_27(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_28(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_29(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_30(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_31(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_32(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_33(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_34(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_35(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_36(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_37(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_38(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_39(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_40(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_41(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_42(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_43(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_44(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_45(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_46(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_47(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_48(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_49(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_50(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_51(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_52(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_53(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_54(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_55(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_56(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_57(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_58(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_59(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_60(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_61(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_62(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_63(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_64(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_65(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_66(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_67(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_68(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_69(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_70(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_71(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_72(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_73(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_74(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_75(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_76(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_77(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_78(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_79(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_80(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_81(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_82(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_83(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_84(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_85(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_86(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_87(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_88(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_89(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_90(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_91(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_92(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_93(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_94(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_95(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_96(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_97(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_98(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_99(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_100(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_101(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_102(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_103(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_104(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_105(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_106(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_107(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_108(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_109(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_110(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_111(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_112(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_113(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_114(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_115(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_116(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_117(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_118(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_119(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_120(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_121(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_122(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_123(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_124(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_125(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_126(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_127(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_129(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_130(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_131(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_132(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_133(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_134(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_135(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_136(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_137(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_138(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_139(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_140(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_141(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_142(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_143(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_144(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_145(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_146(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_147(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_148(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_149(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_150(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_151(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_152(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_153(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_154(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_155(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_156(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_157(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_158(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_159(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_160(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_161(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_162(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_163(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_164(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_165(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_166(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_167(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_168(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_169(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_170(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_171(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_172(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_173(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_174(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_175(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_176(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_177(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_178(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_179(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_180(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_181(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_182(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_183(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_184(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_185(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_186(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_187(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_188(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_189(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_190(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_191(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_192(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_193(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_194(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_195(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_196(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_197(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_198(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_199(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_200(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_201(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_202(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_203(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_204(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_205(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_206(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_207(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_208(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_209(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_210(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_211(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_212(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_213(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_214(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_215(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_216(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_217(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_218(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_219(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_220(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_221(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_222(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_223(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_224(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_225(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_226(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_227(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_228(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_229(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_230(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_231(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_232(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_233(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_234(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_235(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_236(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_237(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_238(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_239(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_240(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_241(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_242(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_243(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_244(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_245(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_246(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_247(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_248(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_249(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_250(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_251(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_252(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_253(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_254(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_255(o, s, l) 0 # define BOOST_PP_LIST_FOLD_LEFT_CHECK_BOOST_PP_LIST_FOLD_LEFT_256(o, s, l) 0 # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/siz0000644000175000017500000000464411344301502031703 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_SIZE_HPP # define BOOST_PREPROCESSOR_LIST_SIZE_HPP # # include # include # include # include # include # include # # /* BOOST_PP_LIST_SIZE */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_SIZE(list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_LIST_SIZE_P, BOOST_PP_LIST_SIZE_O, (0, list))) # else # define BOOST_PP_LIST_SIZE(list) BOOST_PP_LIST_SIZE_I(list) # define BOOST_PP_LIST_SIZE_I(list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_LIST_SIZE_P, BOOST_PP_LIST_SIZE_O, (0, list))) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_SIZE_P(d, rl) BOOST_PP_LIST_IS_CONS(BOOST_PP_TUPLE_ELEM(2, 1, rl)) # else # define BOOST_PP_LIST_SIZE_P(d, rl) BOOST_PP_LIST_SIZE_P_I(BOOST_PP_TUPLE_REM_2 rl) # define BOOST_PP_LIST_SIZE_P_I(im) BOOST_PP_LIST_SIZE_P_II(im) # define BOOST_PP_LIST_SIZE_P_II(r, l) BOOST_PP_LIST_IS_CONS(l) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_SIZE_O(d, rl) (BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(2, 0, rl)), BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(2, 1, rl))) # else # define BOOST_PP_LIST_SIZE_O(d, rl) BOOST_PP_LIST_SIZE_O_I(BOOST_PP_TUPLE_REM_2 rl) # define BOOST_PP_LIST_SIZE_O_I(im) BOOST_PP_LIST_SIZE_O_II(im) # define BOOST_PP_LIST_SIZE_O_II(r, l) (BOOST_PP_INC(r), BOOST_PP_LIST_REST(l)) # endif # # /* BOOST_PP_LIST_SIZE_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_SIZE_D(d, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_SIZE_P, BOOST_PP_LIST_SIZE_O, (0, list))) # else # define BOOST_PP_LIST_SIZE_D(d, list) BOOST_PP_LIST_SIZE_D_I(d, list) # define BOOST_PP_LIST_SIZE_D_I(d, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_SIZE_P, BOOST_PP_LIST_SIZE_O, (0, list))) # endif # # endif ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/for_each_product.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/for0000644000175000017500000003274611344301502031670 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_FOR_EACH_PRODUCT_HPP # define BOOST_PREPROCESSOR_LIST_FOR_EACH_PRODUCT_HPP # # include # include # include # include # include # include # include # include # include # # /* BOOST_PP_LIST_FOR_EACH_PRODUCT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_PRODUCT(macro, size, tuple) BOOST_PP_LIST_FOR_EACH_PRODUCT_E(BOOST_PP_FOR, macro, size, BOOST_PP_TUPLE_TO_LIST(size, tuple)) # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT(macro, size, tuple) BOOST_PP_LIST_FOR_EACH_PRODUCT_Q(macro, size, tuple) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_Q(macro, size, tuple) BOOST_PP_LIST_FOR_EACH_PRODUCT_E(BOOST_PP_FOR, macro, size, BOOST_PP_TUPLE_TO_LIST(size, tuple)) # endif # # /* BOOST_PP_LIST_FOR_EACH_PRODUCT_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_PRODUCT_R(r, macro, size, tuple) BOOST_PP_LIST_FOR_EACH_PRODUCT_E(BOOST_PP_FOR_ ## r, macro, size, BOOST_PP_TUPLE_TO_LIST(size, tuple)) # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT_R(r, macro, size, tuple) BOOST_PP_LIST_FOR_EACH_PRODUCT_R_Q(r, macro, size, tuple) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_R_Q(r, macro, size, tuple) BOOST_PP_LIST_FOR_EACH_PRODUCT_E(BOOST_PP_FOR_ ## r, macro, size, BOOST_PP_TUPLE_TO_LIST(size, tuple)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_PRODUCT_E(impl, macro, size, lists) impl((BOOST_PP_LIST_FIRST(lists), BOOST_PP_LIST_REST(lists), BOOST_PP_NIL, macro, size), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_0) # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT_E(impl, macro, size, lists) BOOST_PP_LIST_FOR_EACH_PRODUCT_E_D(impl, macro, size, lists) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_E_D(impl, macro, size, lists) impl((BOOST_PP_LIST_FIRST(lists), BOOST_PP_LIST_REST(lists), BOOST_PP_NIL, macro, size), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_0) # endif # # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_STRICT() # define BOOST_PP_LIST_FOR_EACH_PRODUCT_P(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_P_I data # define BOOST_PP_LIST_FOR_EACH_PRODUCT_P_I(a, b, res, macro, size) BOOST_PP_LIST_IS_CONS(a) # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT_P(r, data) BOOST_PP_LIST_IS_CONS(BOOST_PP_TUPLE_ELEM(5, 0, data)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_LIST_FOR_EACH_PRODUCT_O(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_O_I data # define BOOST_PP_LIST_FOR_EACH_PRODUCT_O_I(a, b, res, macro, size) (BOOST_PP_LIST_REST(a), b, res, macro, size) # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT_O(r, data) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(5, 0, data)), BOOST_PP_TUPLE_ELEM(5, 1, data), BOOST_PP_TUPLE_ELEM(5, 2, data), BOOST_PP_TUPLE_ELEM(5, 3, data), BOOST_PP_TUPLE_ELEM(5, 4, data)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_I(r, BOOST_PP_TUPLE_ELEM(5, 0, data), BOOST_PP_TUPLE_ELEM(5, 1, data), BOOST_PP_TUPLE_ELEM(5, 2, data), BOOST_PP_TUPLE_ELEM(5, 3, data), BOOST_PP_TUPLE_ELEM(5, 4, data)) # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT_I(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_D(r, BOOST_PP_TUPLE_REM_5 data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_D(r, data_e) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_I(r, data_e) # endif # # define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_I(r, a, b, res, macro, size) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_II(r, macro, BOOST_PP_LIST_TO_TUPLE_R(r, (BOOST_PP_LIST_FIRST(a), res)), size) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_II(r, macro, args, size) BOOST_PP_LIST_FOR_EACH_PRODUCT_I_III(r, macro, args, size) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_I_III(r, macro, args, size) macro(r, BOOST_PP_TUPLE_REVERSE(size, args)) # # define BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, i) BOOST_PP_IF(BOOST_PP_LIST_IS_CONS(BOOST_PP_TUPLE_ELEM(5, 1, data)), BOOST_PP_LIST_FOR_EACH_PRODUCT_N_ ## i, BOOST_PP_LIST_FOR_EACH_PRODUCT_I) # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data) BOOST_PP_LIST_FOR_EACH_PRODUCT_H_I data # else # define BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data) BOOST_PP_LIST_FOR_EACH_PRODUCT_H_I(BOOST_PP_TUPLE_ELEM(5, 0, data), BOOST_PP_TUPLE_ELEM(5, 1, data), BOOST_PP_TUPLE_ELEM(5, 2, data), BOOST_PP_TUPLE_ELEM(5, 3, data), BOOST_PP_TUPLE_ELEM(5, 4, data)) # endif # # define BOOST_PP_LIST_FOR_EACH_PRODUCT_H_I(a, b, res, macro, size) (BOOST_PP_LIST_FIRST(b), BOOST_PP_LIST_REST(b), (BOOST_PP_LIST_FIRST(a), res), macro, size) # # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_0(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 0)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_1(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 1)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_2(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 2)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_3(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 3)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_4(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 4)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_5(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 5)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_6(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 6)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_7(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 7)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_8(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 8)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_9(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 9)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_10(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 10)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_11(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 11)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_12(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 12)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_13(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 13)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_14(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 14)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_15(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 15)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_16(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 16)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_17(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 17)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_18(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 18)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_19(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 19)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_20(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 20)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_21(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 21)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_22(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 22)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_23(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 23)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_24(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 24)(r, data) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_M_25(r, data) BOOST_PP_LIST_FOR_EACH_PRODUCT_C(data, 25)(r, data) # # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_0(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_1) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_1(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_2) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_2(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_3) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_3(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_4) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_4(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_5) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_5(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_6) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_6(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_7) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_7(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_8) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_8(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_9) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_9(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_10) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_10(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_11) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_11(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_12) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_12(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_13) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_13(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_14) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_14(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_15) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_15(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_16) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_16(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_17) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_17(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_18) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_18(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_19) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_19(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_20) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_20(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_21) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_21(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_22) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_22(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_23) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_23(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_24) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_24(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_25) # define BOOST_PP_LIST_FOR_EACH_PRODUCT_N_25(r, data) BOOST_PP_FOR_ ## r(BOOST_PP_LIST_FOR_EACH_PRODUCT_H(data), BOOST_PP_LIST_FOR_EACH_PRODUCT_P, BOOST_PP_LIST_FOR_EACH_PRODUCT_O, BOOST_PP_LIST_FOR_EACH_PRODUCT_M_26) # # endif ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/transform.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/tra0000644000175000017500000000440111344301502031653 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP # define BOOST_PREPROCESSOR_LIST_TRANSFORM_HPP # # include # include # include # include # # /* BOOST_PP_LIST_TRANSFORM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_TRANSFORM(op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) # else # define BOOST_PP_LIST_TRANSFORM(op, data, list) BOOST_PP_LIST_TRANSFORM_I(op, data, list) # define BOOST_PP_LIST_TRANSFORM_I(op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_TRANSFORM_O(d, odr, elem) BOOST_PP_LIST_TRANSFORM_O_D(d, BOOST_PP_TUPLE_ELEM(3, 0, odr), BOOST_PP_TUPLE_ELEM(3, 1, odr), BOOST_PP_TUPLE_ELEM(3, 2, odr), elem) # else # define BOOST_PP_LIST_TRANSFORM_O(d, odr, elem) BOOST_PP_LIST_TRANSFORM_O_I(d, BOOST_PP_TUPLE_REM_3 odr, elem) # define BOOST_PP_LIST_TRANSFORM_O_I(d, im, elem) BOOST_PP_LIST_TRANSFORM_O_D(d, im, elem) # endif # # define BOOST_PP_LIST_TRANSFORM_O_D(d, op, data, res, elem) (op, data, (op(d, data, elem), res)) # # /* BOOST_PP_LIST_TRANSFORM_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_TRANSFORM_D(d, op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) # else # define BOOST_PP_LIST_TRANSFORM_D(d, op, data, list) BOOST_PP_LIST_TRANSFORM_D_I(d, op, data, list) # define BOOST_PP_LIST_TRANSFORM_D_I(d, op, data, list) BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_TRANSFORM_O, (op, data, BOOST_PP_NIL), list)) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/rest_n.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/res0000644000175000017500000000445611344301502031670 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_REST_N_HPP # define BOOST_PREPROCESSOR_LIST_REST_N_HPP # # include # include # include # include # include # # /* BOOST_PP_LIST_REST_N */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_REST_N(count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count))) # else # define BOOST_PP_LIST_REST_N(count, list) BOOST_PP_LIST_REST_N_I(count, list) # define BOOST_PP_LIST_REST_N_I(count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count))) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_REST_N_P(d, lc) BOOST_PP_TUPLE_ELEM(2, 1, lc) # else # define BOOST_PP_LIST_REST_N_P(d, lc) BOOST_PP_LIST_REST_N_P_I lc # define BOOST_PP_LIST_REST_N_P_I(list, count) count # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_REST_N_O(d, lc) (BOOST_PP_LIST_REST(BOOST_PP_TUPLE_ELEM(2, 0, lc)), BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(2, 1, lc))) # else # define BOOST_PP_LIST_REST_N_O(d, lc) BOOST_PP_LIST_REST_N_O_I lc # define BOOST_PP_LIST_REST_N_O_I(list, count) (BOOST_PP_LIST_REST(list), BOOST_PP_DEC(count)) # endif # # /* BOOST_PP_LIST_REST_N_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_REST_N_D(d, count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count))) # else # define BOOST_PP_LIST_REST_N_D(d, count, list) BOOST_PP_LIST_REST_N_D_I(d, count, list) # define BOOST_PP_LIST_REST_N_D_I(d, count, list) BOOST_PP_TUPLE_ELEM(2, 0, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_REST_N_P, BOOST_PP_LIST_REST_N_O, (list, count))) # endif # # endif ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/enum.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/enu0000644000175000017500000000266411344301502031665 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_ENUM_HPP # define BOOST_PREPROCESSOR_LIST_ENUM_HPP # # include # include # include # # /* BOOST_PP_LIST_ENUM */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_ENUM(list) BOOST_PP_LIST_FOR_EACH_I(BOOST_PP_LIST_ENUM_O, BOOST_PP_NIL, list) # else # define BOOST_PP_LIST_ENUM(list) BOOST_PP_LIST_ENUM_I(list) # define BOOST_PP_LIST_ENUM_I(list) BOOST_PP_LIST_FOR_EACH_I(BOOST_PP_LIST_ENUM_O, BOOST_PP_NIL, list) # endif # # define BOOST_PP_LIST_ENUM_O(r, _, i, elem) BOOST_PP_COMMA_IF(i) elem # # /* BOOST_PP_LIST_ENUM_R */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_ENUM_R(r, list) BOOST_PP_LIST_FOR_EACH_I_R(r, BOOST_PP_LIST_ENUM_O, BOOST_PP_NIL, list) # else # define BOOST_PP_LIST_ENUM_R(r, list) BOOST_PP_LIST_ENUM_R_I(r, list) # define BOOST_PP_LIST_ENUM_R_I(r, list) BOOST_PP_LIST_FOR_EACH_I_R(r, BOOST_PP_LIST_ENUM_O, BOOST_PP_NIL, list) # endif # # endif ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/at.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/at.0000644000175000017500000000251311344301502031551 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_AT_HPP # define BOOST_PREPROCESSOR_LIST_AT_HPP # # include # include # include # # /* BOOST_PP_LIST_AT */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_AT(list, index) BOOST_PP_LIST_FIRST(BOOST_PP_LIST_REST_N(index, list)) # else # define BOOST_PP_LIST_AT(list, index) BOOST_PP_LIST_AT_I(list, index) # define BOOST_PP_LIST_AT_I(list, index) BOOST_PP_LIST_FIRST(BOOST_PP_LIST_REST_N(index, list)) # endif # # /* BOOST_PP_LIST_AT_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_AT_D(d, list, index) BOOST_PP_LIST_FIRST(BOOST_PP_LIST_REST_N_D(d, index, list)) # else # define BOOST_PP_LIST_AT_D(d, list, index) BOOST_PP_LIST_AT_D_I(d, list, index) # define BOOST_PP_LIST_AT_D_I(d, list, index) BOOST_PP_LIST_FIRST(BOOST_PP_LIST_REST_N_D(d, index, list)) # endif # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/first_n.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/fir0000644000175000017500000000517411344301502031655 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_FIRST_N_HPP # define BOOST_PREPROCESSOR_LIST_FIRST_N_HPP # # include # include # include # include # include # include # include # # /* BOOST_PP_LIST_FIRST_N */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FIRST_N(count, list) BOOST_PP_LIST_REVERSE(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_WHILE(BOOST_PP_LIST_FIRST_N_P, BOOST_PP_LIST_FIRST_N_O, (count, list, BOOST_PP_NIL)))) # else # define BOOST_PP_LIST_FIRST_N(count, list) BOOST_PP_LIST_FIRST_N_I(count, list) # define BOOST_PP_LIST_FIRST_N_I(count, list) BOOST_PP_LIST_REVERSE(BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_WHILE(BOOST_PP_LIST_FIRST_N_P, BOOST_PP_LIST_FIRST_N_O, (count, list, BOOST_PP_NIL)))) # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FIRST_N_P(d, data) BOOST_PP_TUPLE_ELEM(3, 0, data) # else # define BOOST_PP_LIST_FIRST_N_P(d, data) BOOST_PP_LIST_FIRST_N_P_I data # define BOOST_PP_LIST_FIRST_N_P_I(c, l, nl) c # endif # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_PP_LIST_FIRST_N_O(d, data) BOOST_PP_LIST_FIRST_N_O_D data # else # define BOOST_PP_LIST_FIRST_N_O(d, data) BOOST_PP_LIST_FIRST_N_O_D(BOOST_PP_TUPLE_ELEM(3, 0, data), BOOST_PP_TUPLE_ELEM(3, 1, data), BOOST_PP_TUPLE_ELEM(3, 2, data)) # endif # # define BOOST_PP_LIST_FIRST_N_O_D(c, l, nl) (BOOST_PP_DEC(c), BOOST_PP_LIST_REST(l), (BOOST_PP_LIST_FIRST(l), nl)) # # /* BOOST_PP_LIST_FIRST_N_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_FIRST_N_D(d, count, list) BOOST_PP_LIST_REVERSE_D(d, BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_FIRST_N_P, BOOST_PP_LIST_FIRST_N_O, (count, list, BOOST_PP_NIL)))) # else # define BOOST_PP_LIST_FIRST_N_D(d, count, list) BOOST_PP_LIST_FIRST_N_D_I(d, count, list) # define BOOST_PP_LIST_FIRST_N_D_I(d, count, list) BOOST_PP_LIST_REVERSE_D(d, BOOST_PP_TUPLE_ELEM(3, 2, BOOST_PP_WHILE_ ## d(BOOST_PP_LIST_FIRST_N_P, BOOST_PP_LIST_FIRST_N_O, (count, list, BOOST_PP_NIL)))) # endif # # endif ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/append.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/app0000644000175000017500000000251711344301502031653 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_APPEND_HPP # define BOOST_PREPROCESSOR_LIST_APPEND_HPP # # include # include # # /* BOOST_PP_LIST_APPEND */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_APPEND(a, b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a) # else # define BOOST_PP_LIST_APPEND(a, b) BOOST_PP_LIST_APPEND_I(a, b) # define BOOST_PP_LIST_APPEND_I(a, b) BOOST_PP_LIST_FOLD_RIGHT(BOOST_PP_LIST_APPEND_O, b, a) # endif # # define BOOST_PP_LIST_APPEND_O(d, s, x) (x, s) # # /* BOOST_PP_LIST_APPEND_D */ # # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() # define BOOST_PP_LIST_APPEND_D(d, a, b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a) # else # define BOOST_PP_LIST_APPEND_D(d, a, b) BOOST_PP_LIST_APPEND_D_I(d, a, b) # define BOOST_PP_LIST_APPEND_D_I(d, a, b) BOOST_PP_LIST_FOLD_RIGHT_ ## d(BOOST_PP_LIST_APPEND_O, b, a) # endif # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000755000175000017500000000000012146213766031657 5ustar debiandebian././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/fold_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000644000175000017500000007137511344301502031657 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP # define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_RIGHT_HPP # # include # include # # define BOOST_PP_LIST_FOLD_RIGHT_1(o, s, l) BOOST_PP_LIST_FOLD_LEFT_1(o, s, BOOST_PP_LIST_REVERSE_D(1, l)) # define BOOST_PP_LIST_FOLD_RIGHT_2(o, s, l) BOOST_PP_LIST_FOLD_LEFT_2(o, s, BOOST_PP_LIST_REVERSE_D(2, l)) # define BOOST_PP_LIST_FOLD_RIGHT_3(o, s, l) BOOST_PP_LIST_FOLD_LEFT_3(o, s, BOOST_PP_LIST_REVERSE_D(3, l)) # define BOOST_PP_LIST_FOLD_RIGHT_4(o, s, l) BOOST_PP_LIST_FOLD_LEFT_4(o, s, BOOST_PP_LIST_REVERSE_D(4, l)) # define BOOST_PP_LIST_FOLD_RIGHT_5(o, s, l) BOOST_PP_LIST_FOLD_LEFT_5(o, s, BOOST_PP_LIST_REVERSE_D(5, l)) # define BOOST_PP_LIST_FOLD_RIGHT_6(o, s, l) BOOST_PP_LIST_FOLD_LEFT_6(o, s, BOOST_PP_LIST_REVERSE_D(6, l)) # define BOOST_PP_LIST_FOLD_RIGHT_7(o, s, l) BOOST_PP_LIST_FOLD_LEFT_7(o, s, BOOST_PP_LIST_REVERSE_D(7, l)) # define BOOST_PP_LIST_FOLD_RIGHT_8(o, s, l) BOOST_PP_LIST_FOLD_LEFT_8(o, s, BOOST_PP_LIST_REVERSE_D(8, l)) # define BOOST_PP_LIST_FOLD_RIGHT_9(o, s, l) BOOST_PP_LIST_FOLD_LEFT_9(o, s, BOOST_PP_LIST_REVERSE_D(9, l)) # define BOOST_PP_LIST_FOLD_RIGHT_10(o, s, l) BOOST_PP_LIST_FOLD_LEFT_10(o, s, BOOST_PP_LIST_REVERSE_D(10, l)) # define BOOST_PP_LIST_FOLD_RIGHT_11(o, s, l) BOOST_PP_LIST_FOLD_LEFT_11(o, s, BOOST_PP_LIST_REVERSE_D(11, l)) # define BOOST_PP_LIST_FOLD_RIGHT_12(o, s, l) BOOST_PP_LIST_FOLD_LEFT_12(o, s, BOOST_PP_LIST_REVERSE_D(12, l)) # define BOOST_PP_LIST_FOLD_RIGHT_13(o, s, l) BOOST_PP_LIST_FOLD_LEFT_13(o, s, BOOST_PP_LIST_REVERSE_D(13, l)) # define BOOST_PP_LIST_FOLD_RIGHT_14(o, s, l) BOOST_PP_LIST_FOLD_LEFT_14(o, s, BOOST_PP_LIST_REVERSE_D(14, l)) # define BOOST_PP_LIST_FOLD_RIGHT_15(o, s, l) BOOST_PP_LIST_FOLD_LEFT_15(o, s, BOOST_PP_LIST_REVERSE_D(15, l)) # define BOOST_PP_LIST_FOLD_RIGHT_16(o, s, l) BOOST_PP_LIST_FOLD_LEFT_16(o, s, BOOST_PP_LIST_REVERSE_D(16, l)) # define BOOST_PP_LIST_FOLD_RIGHT_17(o, s, l) BOOST_PP_LIST_FOLD_LEFT_17(o, s, BOOST_PP_LIST_REVERSE_D(17, l)) # define BOOST_PP_LIST_FOLD_RIGHT_18(o, s, l) BOOST_PP_LIST_FOLD_LEFT_18(o, s, BOOST_PP_LIST_REVERSE_D(18, l)) # define BOOST_PP_LIST_FOLD_RIGHT_19(o, s, l) BOOST_PP_LIST_FOLD_LEFT_19(o, s, BOOST_PP_LIST_REVERSE_D(19, l)) # define BOOST_PP_LIST_FOLD_RIGHT_20(o, s, l) BOOST_PP_LIST_FOLD_LEFT_20(o, s, BOOST_PP_LIST_REVERSE_D(20, l)) # define BOOST_PP_LIST_FOLD_RIGHT_21(o, s, l) BOOST_PP_LIST_FOLD_LEFT_21(o, s, BOOST_PP_LIST_REVERSE_D(21, l)) # define BOOST_PP_LIST_FOLD_RIGHT_22(o, s, l) BOOST_PP_LIST_FOLD_LEFT_22(o, s, BOOST_PP_LIST_REVERSE_D(22, l)) # define BOOST_PP_LIST_FOLD_RIGHT_23(o, s, l) BOOST_PP_LIST_FOLD_LEFT_23(o, s, BOOST_PP_LIST_REVERSE_D(23, l)) # define BOOST_PP_LIST_FOLD_RIGHT_24(o, s, l) BOOST_PP_LIST_FOLD_LEFT_24(o, s, BOOST_PP_LIST_REVERSE_D(24, l)) # define BOOST_PP_LIST_FOLD_RIGHT_25(o, s, l) BOOST_PP_LIST_FOLD_LEFT_25(o, s, BOOST_PP_LIST_REVERSE_D(25, l)) # define BOOST_PP_LIST_FOLD_RIGHT_26(o, s, l) BOOST_PP_LIST_FOLD_LEFT_26(o, s, BOOST_PP_LIST_REVERSE_D(26, l)) # define BOOST_PP_LIST_FOLD_RIGHT_27(o, s, l) BOOST_PP_LIST_FOLD_LEFT_27(o, s, BOOST_PP_LIST_REVERSE_D(27, l)) # define BOOST_PP_LIST_FOLD_RIGHT_28(o, s, l) BOOST_PP_LIST_FOLD_LEFT_28(o, s, BOOST_PP_LIST_REVERSE_D(28, l)) # define BOOST_PP_LIST_FOLD_RIGHT_29(o, s, l) BOOST_PP_LIST_FOLD_LEFT_29(o, s, BOOST_PP_LIST_REVERSE_D(29, l)) # define BOOST_PP_LIST_FOLD_RIGHT_30(o, s, l) BOOST_PP_LIST_FOLD_LEFT_30(o, s, BOOST_PP_LIST_REVERSE_D(30, l)) # define BOOST_PP_LIST_FOLD_RIGHT_31(o, s, l) BOOST_PP_LIST_FOLD_LEFT_31(o, s, BOOST_PP_LIST_REVERSE_D(31, l)) # define BOOST_PP_LIST_FOLD_RIGHT_32(o, s, l) BOOST_PP_LIST_FOLD_LEFT_32(o, s, BOOST_PP_LIST_REVERSE_D(32, l)) # define BOOST_PP_LIST_FOLD_RIGHT_33(o, s, l) BOOST_PP_LIST_FOLD_LEFT_33(o, s, BOOST_PP_LIST_REVERSE_D(33, l)) # define BOOST_PP_LIST_FOLD_RIGHT_34(o, s, l) BOOST_PP_LIST_FOLD_LEFT_34(o, s, BOOST_PP_LIST_REVERSE_D(34, l)) # define BOOST_PP_LIST_FOLD_RIGHT_35(o, s, l) BOOST_PP_LIST_FOLD_LEFT_35(o, s, BOOST_PP_LIST_REVERSE_D(35, l)) # define BOOST_PP_LIST_FOLD_RIGHT_36(o, s, l) BOOST_PP_LIST_FOLD_LEFT_36(o, s, BOOST_PP_LIST_REVERSE_D(36, l)) # define BOOST_PP_LIST_FOLD_RIGHT_37(o, s, l) BOOST_PP_LIST_FOLD_LEFT_37(o, s, BOOST_PP_LIST_REVERSE_D(37, l)) # define BOOST_PP_LIST_FOLD_RIGHT_38(o, s, l) BOOST_PP_LIST_FOLD_LEFT_38(o, s, BOOST_PP_LIST_REVERSE_D(38, l)) # define BOOST_PP_LIST_FOLD_RIGHT_39(o, s, l) BOOST_PP_LIST_FOLD_LEFT_39(o, s, BOOST_PP_LIST_REVERSE_D(39, l)) # define BOOST_PP_LIST_FOLD_RIGHT_40(o, s, l) BOOST_PP_LIST_FOLD_LEFT_40(o, s, BOOST_PP_LIST_REVERSE_D(40, l)) # define BOOST_PP_LIST_FOLD_RIGHT_41(o, s, l) BOOST_PP_LIST_FOLD_LEFT_41(o, s, BOOST_PP_LIST_REVERSE_D(41, l)) # define BOOST_PP_LIST_FOLD_RIGHT_42(o, s, l) BOOST_PP_LIST_FOLD_LEFT_42(o, s, BOOST_PP_LIST_REVERSE_D(42, l)) # define BOOST_PP_LIST_FOLD_RIGHT_43(o, s, l) BOOST_PP_LIST_FOLD_LEFT_43(o, s, BOOST_PP_LIST_REVERSE_D(43, l)) # define BOOST_PP_LIST_FOLD_RIGHT_44(o, s, l) BOOST_PP_LIST_FOLD_LEFT_44(o, s, BOOST_PP_LIST_REVERSE_D(44, l)) # define BOOST_PP_LIST_FOLD_RIGHT_45(o, s, l) BOOST_PP_LIST_FOLD_LEFT_45(o, s, BOOST_PP_LIST_REVERSE_D(45, l)) # define BOOST_PP_LIST_FOLD_RIGHT_46(o, s, l) BOOST_PP_LIST_FOLD_LEFT_46(o, s, BOOST_PP_LIST_REVERSE_D(46, l)) # define BOOST_PP_LIST_FOLD_RIGHT_47(o, s, l) BOOST_PP_LIST_FOLD_LEFT_47(o, s, BOOST_PP_LIST_REVERSE_D(47, l)) # define BOOST_PP_LIST_FOLD_RIGHT_48(o, s, l) BOOST_PP_LIST_FOLD_LEFT_48(o, s, BOOST_PP_LIST_REVERSE_D(48, l)) # define BOOST_PP_LIST_FOLD_RIGHT_49(o, s, l) BOOST_PP_LIST_FOLD_LEFT_49(o, s, BOOST_PP_LIST_REVERSE_D(49, l)) # define BOOST_PP_LIST_FOLD_RIGHT_50(o, s, l) BOOST_PP_LIST_FOLD_LEFT_50(o, s, BOOST_PP_LIST_REVERSE_D(50, l)) # define BOOST_PP_LIST_FOLD_RIGHT_51(o, s, l) BOOST_PP_LIST_FOLD_LEFT_51(o, s, BOOST_PP_LIST_REVERSE_D(51, l)) # define BOOST_PP_LIST_FOLD_RIGHT_52(o, s, l) BOOST_PP_LIST_FOLD_LEFT_52(o, s, BOOST_PP_LIST_REVERSE_D(52, l)) # define BOOST_PP_LIST_FOLD_RIGHT_53(o, s, l) BOOST_PP_LIST_FOLD_LEFT_53(o, s, BOOST_PP_LIST_REVERSE_D(53, l)) # define BOOST_PP_LIST_FOLD_RIGHT_54(o, s, l) BOOST_PP_LIST_FOLD_LEFT_54(o, s, BOOST_PP_LIST_REVERSE_D(54, l)) # define BOOST_PP_LIST_FOLD_RIGHT_55(o, s, l) BOOST_PP_LIST_FOLD_LEFT_55(o, s, BOOST_PP_LIST_REVERSE_D(55, l)) # define BOOST_PP_LIST_FOLD_RIGHT_56(o, s, l) BOOST_PP_LIST_FOLD_LEFT_56(o, s, BOOST_PP_LIST_REVERSE_D(56, l)) # define BOOST_PP_LIST_FOLD_RIGHT_57(o, s, l) BOOST_PP_LIST_FOLD_LEFT_57(o, s, BOOST_PP_LIST_REVERSE_D(57, l)) # define BOOST_PP_LIST_FOLD_RIGHT_58(o, s, l) BOOST_PP_LIST_FOLD_LEFT_58(o, s, BOOST_PP_LIST_REVERSE_D(58, l)) # define BOOST_PP_LIST_FOLD_RIGHT_59(o, s, l) BOOST_PP_LIST_FOLD_LEFT_59(o, s, BOOST_PP_LIST_REVERSE_D(59, l)) # define BOOST_PP_LIST_FOLD_RIGHT_60(o, s, l) BOOST_PP_LIST_FOLD_LEFT_60(o, s, BOOST_PP_LIST_REVERSE_D(60, l)) # define BOOST_PP_LIST_FOLD_RIGHT_61(o, s, l) BOOST_PP_LIST_FOLD_LEFT_61(o, s, BOOST_PP_LIST_REVERSE_D(61, l)) # define BOOST_PP_LIST_FOLD_RIGHT_62(o, s, l) BOOST_PP_LIST_FOLD_LEFT_62(o, s, BOOST_PP_LIST_REVERSE_D(62, l)) # define BOOST_PP_LIST_FOLD_RIGHT_63(o, s, l) BOOST_PP_LIST_FOLD_LEFT_63(o, s, BOOST_PP_LIST_REVERSE_D(63, l)) # define BOOST_PP_LIST_FOLD_RIGHT_64(o, s, l) BOOST_PP_LIST_FOLD_LEFT_64(o, s, BOOST_PP_LIST_REVERSE_D(64, l)) # define BOOST_PP_LIST_FOLD_RIGHT_65(o, s, l) BOOST_PP_LIST_FOLD_LEFT_65(o, s, BOOST_PP_LIST_REVERSE_D(65, l)) # define BOOST_PP_LIST_FOLD_RIGHT_66(o, s, l) BOOST_PP_LIST_FOLD_LEFT_66(o, s, BOOST_PP_LIST_REVERSE_D(66, l)) # define BOOST_PP_LIST_FOLD_RIGHT_67(o, s, l) BOOST_PP_LIST_FOLD_LEFT_67(o, s, BOOST_PP_LIST_REVERSE_D(67, l)) # define BOOST_PP_LIST_FOLD_RIGHT_68(o, s, l) BOOST_PP_LIST_FOLD_LEFT_68(o, s, BOOST_PP_LIST_REVERSE_D(68, l)) # define BOOST_PP_LIST_FOLD_RIGHT_69(o, s, l) BOOST_PP_LIST_FOLD_LEFT_69(o, s, BOOST_PP_LIST_REVERSE_D(69, l)) # define BOOST_PP_LIST_FOLD_RIGHT_70(o, s, l) BOOST_PP_LIST_FOLD_LEFT_70(o, s, BOOST_PP_LIST_REVERSE_D(70, l)) # define BOOST_PP_LIST_FOLD_RIGHT_71(o, s, l) BOOST_PP_LIST_FOLD_LEFT_71(o, s, BOOST_PP_LIST_REVERSE_D(71, l)) # define BOOST_PP_LIST_FOLD_RIGHT_72(o, s, l) BOOST_PP_LIST_FOLD_LEFT_72(o, s, BOOST_PP_LIST_REVERSE_D(72, l)) # define BOOST_PP_LIST_FOLD_RIGHT_73(o, s, l) BOOST_PP_LIST_FOLD_LEFT_73(o, s, BOOST_PP_LIST_REVERSE_D(73, l)) # define BOOST_PP_LIST_FOLD_RIGHT_74(o, s, l) BOOST_PP_LIST_FOLD_LEFT_74(o, s, BOOST_PP_LIST_REVERSE_D(74, l)) # define BOOST_PP_LIST_FOLD_RIGHT_75(o, s, l) BOOST_PP_LIST_FOLD_LEFT_75(o, s, BOOST_PP_LIST_REVERSE_D(75, l)) # define BOOST_PP_LIST_FOLD_RIGHT_76(o, s, l) BOOST_PP_LIST_FOLD_LEFT_76(o, s, BOOST_PP_LIST_REVERSE_D(76, l)) # define BOOST_PP_LIST_FOLD_RIGHT_77(o, s, l) BOOST_PP_LIST_FOLD_LEFT_77(o, s, BOOST_PP_LIST_REVERSE_D(77, l)) # define BOOST_PP_LIST_FOLD_RIGHT_78(o, s, l) BOOST_PP_LIST_FOLD_LEFT_78(o, s, BOOST_PP_LIST_REVERSE_D(78, l)) # define BOOST_PP_LIST_FOLD_RIGHT_79(o, s, l) BOOST_PP_LIST_FOLD_LEFT_79(o, s, BOOST_PP_LIST_REVERSE_D(79, l)) # define BOOST_PP_LIST_FOLD_RIGHT_80(o, s, l) BOOST_PP_LIST_FOLD_LEFT_80(o, s, BOOST_PP_LIST_REVERSE_D(80, l)) # define BOOST_PP_LIST_FOLD_RIGHT_81(o, s, l) BOOST_PP_LIST_FOLD_LEFT_81(o, s, BOOST_PP_LIST_REVERSE_D(81, l)) # define BOOST_PP_LIST_FOLD_RIGHT_82(o, s, l) BOOST_PP_LIST_FOLD_LEFT_82(o, s, BOOST_PP_LIST_REVERSE_D(82, l)) # define BOOST_PP_LIST_FOLD_RIGHT_83(o, s, l) BOOST_PP_LIST_FOLD_LEFT_83(o, s, BOOST_PP_LIST_REVERSE_D(83, l)) # define BOOST_PP_LIST_FOLD_RIGHT_84(o, s, l) BOOST_PP_LIST_FOLD_LEFT_84(o, s, BOOST_PP_LIST_REVERSE_D(84, l)) # define BOOST_PP_LIST_FOLD_RIGHT_85(o, s, l) BOOST_PP_LIST_FOLD_LEFT_85(o, s, BOOST_PP_LIST_REVERSE_D(85, l)) # define BOOST_PP_LIST_FOLD_RIGHT_86(o, s, l) BOOST_PP_LIST_FOLD_LEFT_86(o, s, BOOST_PP_LIST_REVERSE_D(86, l)) # define BOOST_PP_LIST_FOLD_RIGHT_87(o, s, l) BOOST_PP_LIST_FOLD_LEFT_87(o, s, BOOST_PP_LIST_REVERSE_D(87, l)) # define BOOST_PP_LIST_FOLD_RIGHT_88(o, s, l) BOOST_PP_LIST_FOLD_LEFT_88(o, s, BOOST_PP_LIST_REVERSE_D(88, l)) # define BOOST_PP_LIST_FOLD_RIGHT_89(o, s, l) BOOST_PP_LIST_FOLD_LEFT_89(o, s, BOOST_PP_LIST_REVERSE_D(89, l)) # define BOOST_PP_LIST_FOLD_RIGHT_90(o, s, l) BOOST_PP_LIST_FOLD_LEFT_90(o, s, BOOST_PP_LIST_REVERSE_D(90, l)) # define BOOST_PP_LIST_FOLD_RIGHT_91(o, s, l) BOOST_PP_LIST_FOLD_LEFT_91(o, s, BOOST_PP_LIST_REVERSE_D(91, l)) # define BOOST_PP_LIST_FOLD_RIGHT_92(o, s, l) BOOST_PP_LIST_FOLD_LEFT_92(o, s, BOOST_PP_LIST_REVERSE_D(92, l)) # define BOOST_PP_LIST_FOLD_RIGHT_93(o, s, l) BOOST_PP_LIST_FOLD_LEFT_93(o, s, BOOST_PP_LIST_REVERSE_D(93, l)) # define BOOST_PP_LIST_FOLD_RIGHT_94(o, s, l) BOOST_PP_LIST_FOLD_LEFT_94(o, s, BOOST_PP_LIST_REVERSE_D(94, l)) # define BOOST_PP_LIST_FOLD_RIGHT_95(o, s, l) BOOST_PP_LIST_FOLD_LEFT_95(o, s, BOOST_PP_LIST_REVERSE_D(95, l)) # define BOOST_PP_LIST_FOLD_RIGHT_96(o, s, l) BOOST_PP_LIST_FOLD_LEFT_96(o, s, BOOST_PP_LIST_REVERSE_D(96, l)) # define BOOST_PP_LIST_FOLD_RIGHT_97(o, s, l) BOOST_PP_LIST_FOLD_LEFT_97(o, s, BOOST_PP_LIST_REVERSE_D(97, l)) # define BOOST_PP_LIST_FOLD_RIGHT_98(o, s, l) BOOST_PP_LIST_FOLD_LEFT_98(o, s, BOOST_PP_LIST_REVERSE_D(98, l)) # define BOOST_PP_LIST_FOLD_RIGHT_99(o, s, l) BOOST_PP_LIST_FOLD_LEFT_99(o, s, BOOST_PP_LIST_REVERSE_D(99, l)) # define BOOST_PP_LIST_FOLD_RIGHT_100(o, s, l) BOOST_PP_LIST_FOLD_LEFT_100(o, s, BOOST_PP_LIST_REVERSE_D(100, l)) # define BOOST_PP_LIST_FOLD_RIGHT_101(o, s, l) BOOST_PP_LIST_FOLD_LEFT_101(o, s, BOOST_PP_LIST_REVERSE_D(101, l)) # define BOOST_PP_LIST_FOLD_RIGHT_102(o, s, l) BOOST_PP_LIST_FOLD_LEFT_102(o, s, BOOST_PP_LIST_REVERSE_D(102, l)) # define BOOST_PP_LIST_FOLD_RIGHT_103(o, s, l) BOOST_PP_LIST_FOLD_LEFT_103(o, s, BOOST_PP_LIST_REVERSE_D(103, l)) # define BOOST_PP_LIST_FOLD_RIGHT_104(o, s, l) BOOST_PP_LIST_FOLD_LEFT_104(o, s, BOOST_PP_LIST_REVERSE_D(104, l)) # define BOOST_PP_LIST_FOLD_RIGHT_105(o, s, l) BOOST_PP_LIST_FOLD_LEFT_105(o, s, BOOST_PP_LIST_REVERSE_D(105, l)) # define BOOST_PP_LIST_FOLD_RIGHT_106(o, s, l) BOOST_PP_LIST_FOLD_LEFT_106(o, s, BOOST_PP_LIST_REVERSE_D(106, l)) # define BOOST_PP_LIST_FOLD_RIGHT_107(o, s, l) BOOST_PP_LIST_FOLD_LEFT_107(o, s, BOOST_PP_LIST_REVERSE_D(107, l)) # define BOOST_PP_LIST_FOLD_RIGHT_108(o, s, l) BOOST_PP_LIST_FOLD_LEFT_108(o, s, BOOST_PP_LIST_REVERSE_D(108, l)) # define BOOST_PP_LIST_FOLD_RIGHT_109(o, s, l) BOOST_PP_LIST_FOLD_LEFT_109(o, s, BOOST_PP_LIST_REVERSE_D(109, l)) # define BOOST_PP_LIST_FOLD_RIGHT_110(o, s, l) BOOST_PP_LIST_FOLD_LEFT_110(o, s, BOOST_PP_LIST_REVERSE_D(110, l)) # define BOOST_PP_LIST_FOLD_RIGHT_111(o, s, l) BOOST_PP_LIST_FOLD_LEFT_111(o, s, BOOST_PP_LIST_REVERSE_D(111, l)) # define BOOST_PP_LIST_FOLD_RIGHT_112(o, s, l) BOOST_PP_LIST_FOLD_LEFT_112(o, s, BOOST_PP_LIST_REVERSE_D(112, l)) # define BOOST_PP_LIST_FOLD_RIGHT_113(o, s, l) BOOST_PP_LIST_FOLD_LEFT_113(o, s, BOOST_PP_LIST_REVERSE_D(113, l)) # define BOOST_PP_LIST_FOLD_RIGHT_114(o, s, l) BOOST_PP_LIST_FOLD_LEFT_114(o, s, BOOST_PP_LIST_REVERSE_D(114, l)) # define BOOST_PP_LIST_FOLD_RIGHT_115(o, s, l) BOOST_PP_LIST_FOLD_LEFT_115(o, s, BOOST_PP_LIST_REVERSE_D(115, l)) # define BOOST_PP_LIST_FOLD_RIGHT_116(o, s, l) BOOST_PP_LIST_FOLD_LEFT_116(o, s, BOOST_PP_LIST_REVERSE_D(116, l)) # define BOOST_PP_LIST_FOLD_RIGHT_117(o, s, l) BOOST_PP_LIST_FOLD_LEFT_117(o, s, BOOST_PP_LIST_REVERSE_D(117, l)) # define BOOST_PP_LIST_FOLD_RIGHT_118(o, s, l) BOOST_PP_LIST_FOLD_LEFT_118(o, s, BOOST_PP_LIST_REVERSE_D(118, l)) # define BOOST_PP_LIST_FOLD_RIGHT_119(o, s, l) BOOST_PP_LIST_FOLD_LEFT_119(o, s, BOOST_PP_LIST_REVERSE_D(119, l)) # define BOOST_PP_LIST_FOLD_RIGHT_120(o, s, l) BOOST_PP_LIST_FOLD_LEFT_120(o, s, BOOST_PP_LIST_REVERSE_D(120, l)) # define BOOST_PP_LIST_FOLD_RIGHT_121(o, s, l) BOOST_PP_LIST_FOLD_LEFT_121(o, s, BOOST_PP_LIST_REVERSE_D(121, l)) # define BOOST_PP_LIST_FOLD_RIGHT_122(o, s, l) BOOST_PP_LIST_FOLD_LEFT_122(o, s, BOOST_PP_LIST_REVERSE_D(122, l)) # define BOOST_PP_LIST_FOLD_RIGHT_123(o, s, l) BOOST_PP_LIST_FOLD_LEFT_123(o, s, BOOST_PP_LIST_REVERSE_D(123, l)) # define BOOST_PP_LIST_FOLD_RIGHT_124(o, s, l) BOOST_PP_LIST_FOLD_LEFT_124(o, s, BOOST_PP_LIST_REVERSE_D(124, l)) # define BOOST_PP_LIST_FOLD_RIGHT_125(o, s, l) BOOST_PP_LIST_FOLD_LEFT_125(o, s, BOOST_PP_LIST_REVERSE_D(125, l)) # define BOOST_PP_LIST_FOLD_RIGHT_126(o, s, l) BOOST_PP_LIST_FOLD_LEFT_126(o, s, BOOST_PP_LIST_REVERSE_D(126, l)) # define BOOST_PP_LIST_FOLD_RIGHT_127(o, s, l) BOOST_PP_LIST_FOLD_LEFT_127(o, s, BOOST_PP_LIST_REVERSE_D(127, l)) # define BOOST_PP_LIST_FOLD_RIGHT_128(o, s, l) BOOST_PP_LIST_FOLD_LEFT_128(o, s, BOOST_PP_LIST_REVERSE_D(128, l)) # define BOOST_PP_LIST_FOLD_RIGHT_129(o, s, l) BOOST_PP_LIST_FOLD_LEFT_129(o, s, BOOST_PP_LIST_REVERSE_D(129, l)) # define BOOST_PP_LIST_FOLD_RIGHT_130(o, s, l) BOOST_PP_LIST_FOLD_LEFT_130(o, s, BOOST_PP_LIST_REVERSE_D(130, l)) # define BOOST_PP_LIST_FOLD_RIGHT_131(o, s, l) BOOST_PP_LIST_FOLD_LEFT_131(o, s, BOOST_PP_LIST_REVERSE_D(131, l)) # define BOOST_PP_LIST_FOLD_RIGHT_132(o, s, l) BOOST_PP_LIST_FOLD_LEFT_132(o, s, BOOST_PP_LIST_REVERSE_D(132, l)) # define BOOST_PP_LIST_FOLD_RIGHT_133(o, s, l) BOOST_PP_LIST_FOLD_LEFT_133(o, s, BOOST_PP_LIST_REVERSE_D(133, l)) # define BOOST_PP_LIST_FOLD_RIGHT_134(o, s, l) BOOST_PP_LIST_FOLD_LEFT_134(o, s, BOOST_PP_LIST_REVERSE_D(134, l)) # define BOOST_PP_LIST_FOLD_RIGHT_135(o, s, l) BOOST_PP_LIST_FOLD_LEFT_135(o, s, BOOST_PP_LIST_REVERSE_D(135, l)) # define BOOST_PP_LIST_FOLD_RIGHT_136(o, s, l) BOOST_PP_LIST_FOLD_LEFT_136(o, s, BOOST_PP_LIST_REVERSE_D(136, l)) # define BOOST_PP_LIST_FOLD_RIGHT_137(o, s, l) BOOST_PP_LIST_FOLD_LEFT_137(o, s, BOOST_PP_LIST_REVERSE_D(137, l)) # define BOOST_PP_LIST_FOLD_RIGHT_138(o, s, l) BOOST_PP_LIST_FOLD_LEFT_138(o, s, BOOST_PP_LIST_REVERSE_D(138, l)) # define BOOST_PP_LIST_FOLD_RIGHT_139(o, s, l) BOOST_PP_LIST_FOLD_LEFT_139(o, s, BOOST_PP_LIST_REVERSE_D(139, l)) # define BOOST_PP_LIST_FOLD_RIGHT_140(o, s, l) BOOST_PP_LIST_FOLD_LEFT_140(o, s, BOOST_PP_LIST_REVERSE_D(140, l)) # define BOOST_PP_LIST_FOLD_RIGHT_141(o, s, l) BOOST_PP_LIST_FOLD_LEFT_141(o, s, BOOST_PP_LIST_REVERSE_D(141, l)) # define BOOST_PP_LIST_FOLD_RIGHT_142(o, s, l) BOOST_PP_LIST_FOLD_LEFT_142(o, s, BOOST_PP_LIST_REVERSE_D(142, l)) # define BOOST_PP_LIST_FOLD_RIGHT_143(o, s, l) BOOST_PP_LIST_FOLD_LEFT_143(o, s, BOOST_PP_LIST_REVERSE_D(143, l)) # define BOOST_PP_LIST_FOLD_RIGHT_144(o, s, l) BOOST_PP_LIST_FOLD_LEFT_144(o, s, BOOST_PP_LIST_REVERSE_D(144, l)) # define BOOST_PP_LIST_FOLD_RIGHT_145(o, s, l) BOOST_PP_LIST_FOLD_LEFT_145(o, s, BOOST_PP_LIST_REVERSE_D(145, l)) # define BOOST_PP_LIST_FOLD_RIGHT_146(o, s, l) BOOST_PP_LIST_FOLD_LEFT_146(o, s, BOOST_PP_LIST_REVERSE_D(146, l)) # define BOOST_PP_LIST_FOLD_RIGHT_147(o, s, l) BOOST_PP_LIST_FOLD_LEFT_147(o, s, BOOST_PP_LIST_REVERSE_D(147, l)) # define BOOST_PP_LIST_FOLD_RIGHT_148(o, s, l) BOOST_PP_LIST_FOLD_LEFT_148(o, s, BOOST_PP_LIST_REVERSE_D(148, l)) # define BOOST_PP_LIST_FOLD_RIGHT_149(o, s, l) BOOST_PP_LIST_FOLD_LEFT_149(o, s, BOOST_PP_LIST_REVERSE_D(149, l)) # define BOOST_PP_LIST_FOLD_RIGHT_150(o, s, l) BOOST_PP_LIST_FOLD_LEFT_150(o, s, BOOST_PP_LIST_REVERSE_D(150, l)) # define BOOST_PP_LIST_FOLD_RIGHT_151(o, s, l) BOOST_PP_LIST_FOLD_LEFT_151(o, s, BOOST_PP_LIST_REVERSE_D(151, l)) # define BOOST_PP_LIST_FOLD_RIGHT_152(o, s, l) BOOST_PP_LIST_FOLD_LEFT_152(o, s, BOOST_PP_LIST_REVERSE_D(152, l)) # define BOOST_PP_LIST_FOLD_RIGHT_153(o, s, l) BOOST_PP_LIST_FOLD_LEFT_153(o, s, BOOST_PP_LIST_REVERSE_D(153, l)) # define BOOST_PP_LIST_FOLD_RIGHT_154(o, s, l) BOOST_PP_LIST_FOLD_LEFT_154(o, s, BOOST_PP_LIST_REVERSE_D(154, l)) # define BOOST_PP_LIST_FOLD_RIGHT_155(o, s, l) BOOST_PP_LIST_FOLD_LEFT_155(o, s, BOOST_PP_LIST_REVERSE_D(155, l)) # define BOOST_PP_LIST_FOLD_RIGHT_156(o, s, l) BOOST_PP_LIST_FOLD_LEFT_156(o, s, BOOST_PP_LIST_REVERSE_D(156, l)) # define BOOST_PP_LIST_FOLD_RIGHT_157(o, s, l) BOOST_PP_LIST_FOLD_LEFT_157(o, s, BOOST_PP_LIST_REVERSE_D(157, l)) # define BOOST_PP_LIST_FOLD_RIGHT_158(o, s, l) BOOST_PP_LIST_FOLD_LEFT_158(o, s, BOOST_PP_LIST_REVERSE_D(158, l)) # define BOOST_PP_LIST_FOLD_RIGHT_159(o, s, l) BOOST_PP_LIST_FOLD_LEFT_159(o, s, BOOST_PP_LIST_REVERSE_D(159, l)) # define BOOST_PP_LIST_FOLD_RIGHT_160(o, s, l) BOOST_PP_LIST_FOLD_LEFT_160(o, s, BOOST_PP_LIST_REVERSE_D(160, l)) # define BOOST_PP_LIST_FOLD_RIGHT_161(o, s, l) BOOST_PP_LIST_FOLD_LEFT_161(o, s, BOOST_PP_LIST_REVERSE_D(161, l)) # define BOOST_PP_LIST_FOLD_RIGHT_162(o, s, l) BOOST_PP_LIST_FOLD_LEFT_162(o, s, BOOST_PP_LIST_REVERSE_D(162, l)) # define BOOST_PP_LIST_FOLD_RIGHT_163(o, s, l) BOOST_PP_LIST_FOLD_LEFT_163(o, s, BOOST_PP_LIST_REVERSE_D(163, l)) # define BOOST_PP_LIST_FOLD_RIGHT_164(o, s, l) BOOST_PP_LIST_FOLD_LEFT_164(o, s, BOOST_PP_LIST_REVERSE_D(164, l)) # define BOOST_PP_LIST_FOLD_RIGHT_165(o, s, l) BOOST_PP_LIST_FOLD_LEFT_165(o, s, BOOST_PP_LIST_REVERSE_D(165, l)) # define BOOST_PP_LIST_FOLD_RIGHT_166(o, s, l) BOOST_PP_LIST_FOLD_LEFT_166(o, s, BOOST_PP_LIST_REVERSE_D(166, l)) # define BOOST_PP_LIST_FOLD_RIGHT_167(o, s, l) BOOST_PP_LIST_FOLD_LEFT_167(o, s, BOOST_PP_LIST_REVERSE_D(167, l)) # define BOOST_PP_LIST_FOLD_RIGHT_168(o, s, l) BOOST_PP_LIST_FOLD_LEFT_168(o, s, BOOST_PP_LIST_REVERSE_D(168, l)) # define BOOST_PP_LIST_FOLD_RIGHT_169(o, s, l) BOOST_PP_LIST_FOLD_LEFT_169(o, s, BOOST_PP_LIST_REVERSE_D(169, l)) # define BOOST_PP_LIST_FOLD_RIGHT_170(o, s, l) BOOST_PP_LIST_FOLD_LEFT_170(o, s, BOOST_PP_LIST_REVERSE_D(170, l)) # define BOOST_PP_LIST_FOLD_RIGHT_171(o, s, l) BOOST_PP_LIST_FOLD_LEFT_171(o, s, BOOST_PP_LIST_REVERSE_D(171, l)) # define BOOST_PP_LIST_FOLD_RIGHT_172(o, s, l) BOOST_PP_LIST_FOLD_LEFT_172(o, s, BOOST_PP_LIST_REVERSE_D(172, l)) # define BOOST_PP_LIST_FOLD_RIGHT_173(o, s, l) BOOST_PP_LIST_FOLD_LEFT_173(o, s, BOOST_PP_LIST_REVERSE_D(173, l)) # define BOOST_PP_LIST_FOLD_RIGHT_174(o, s, l) BOOST_PP_LIST_FOLD_LEFT_174(o, s, BOOST_PP_LIST_REVERSE_D(174, l)) # define BOOST_PP_LIST_FOLD_RIGHT_175(o, s, l) BOOST_PP_LIST_FOLD_LEFT_175(o, s, BOOST_PP_LIST_REVERSE_D(175, l)) # define BOOST_PP_LIST_FOLD_RIGHT_176(o, s, l) BOOST_PP_LIST_FOLD_LEFT_176(o, s, BOOST_PP_LIST_REVERSE_D(176, l)) # define BOOST_PP_LIST_FOLD_RIGHT_177(o, s, l) BOOST_PP_LIST_FOLD_LEFT_177(o, s, BOOST_PP_LIST_REVERSE_D(177, l)) # define BOOST_PP_LIST_FOLD_RIGHT_178(o, s, l) BOOST_PP_LIST_FOLD_LEFT_178(o, s, BOOST_PP_LIST_REVERSE_D(178, l)) # define BOOST_PP_LIST_FOLD_RIGHT_179(o, s, l) BOOST_PP_LIST_FOLD_LEFT_179(o, s, BOOST_PP_LIST_REVERSE_D(179, l)) # define BOOST_PP_LIST_FOLD_RIGHT_180(o, s, l) BOOST_PP_LIST_FOLD_LEFT_180(o, s, BOOST_PP_LIST_REVERSE_D(180, l)) # define BOOST_PP_LIST_FOLD_RIGHT_181(o, s, l) BOOST_PP_LIST_FOLD_LEFT_181(o, s, BOOST_PP_LIST_REVERSE_D(181, l)) # define BOOST_PP_LIST_FOLD_RIGHT_182(o, s, l) BOOST_PP_LIST_FOLD_LEFT_182(o, s, BOOST_PP_LIST_REVERSE_D(182, l)) # define BOOST_PP_LIST_FOLD_RIGHT_183(o, s, l) BOOST_PP_LIST_FOLD_LEFT_183(o, s, BOOST_PP_LIST_REVERSE_D(183, l)) # define BOOST_PP_LIST_FOLD_RIGHT_184(o, s, l) BOOST_PP_LIST_FOLD_LEFT_184(o, s, BOOST_PP_LIST_REVERSE_D(184, l)) # define BOOST_PP_LIST_FOLD_RIGHT_185(o, s, l) BOOST_PP_LIST_FOLD_LEFT_185(o, s, BOOST_PP_LIST_REVERSE_D(185, l)) # define BOOST_PP_LIST_FOLD_RIGHT_186(o, s, l) BOOST_PP_LIST_FOLD_LEFT_186(o, s, BOOST_PP_LIST_REVERSE_D(186, l)) # define BOOST_PP_LIST_FOLD_RIGHT_187(o, s, l) BOOST_PP_LIST_FOLD_LEFT_187(o, s, BOOST_PP_LIST_REVERSE_D(187, l)) # define BOOST_PP_LIST_FOLD_RIGHT_188(o, s, l) BOOST_PP_LIST_FOLD_LEFT_188(o, s, BOOST_PP_LIST_REVERSE_D(188, l)) # define BOOST_PP_LIST_FOLD_RIGHT_189(o, s, l) BOOST_PP_LIST_FOLD_LEFT_189(o, s, BOOST_PP_LIST_REVERSE_D(189, l)) # define BOOST_PP_LIST_FOLD_RIGHT_190(o, s, l) BOOST_PP_LIST_FOLD_LEFT_190(o, s, BOOST_PP_LIST_REVERSE_D(190, l)) # define BOOST_PP_LIST_FOLD_RIGHT_191(o, s, l) BOOST_PP_LIST_FOLD_LEFT_191(o, s, BOOST_PP_LIST_REVERSE_D(191, l)) # define BOOST_PP_LIST_FOLD_RIGHT_192(o, s, l) BOOST_PP_LIST_FOLD_LEFT_192(o, s, BOOST_PP_LIST_REVERSE_D(192, l)) # define BOOST_PP_LIST_FOLD_RIGHT_193(o, s, l) BOOST_PP_LIST_FOLD_LEFT_193(o, s, BOOST_PP_LIST_REVERSE_D(193, l)) # define BOOST_PP_LIST_FOLD_RIGHT_194(o, s, l) BOOST_PP_LIST_FOLD_LEFT_194(o, s, BOOST_PP_LIST_REVERSE_D(194, l)) # define BOOST_PP_LIST_FOLD_RIGHT_195(o, s, l) BOOST_PP_LIST_FOLD_LEFT_195(o, s, BOOST_PP_LIST_REVERSE_D(195, l)) # define BOOST_PP_LIST_FOLD_RIGHT_196(o, s, l) BOOST_PP_LIST_FOLD_LEFT_196(o, s, BOOST_PP_LIST_REVERSE_D(196, l)) # define BOOST_PP_LIST_FOLD_RIGHT_197(o, s, l) BOOST_PP_LIST_FOLD_LEFT_197(o, s, BOOST_PP_LIST_REVERSE_D(197, l)) # define BOOST_PP_LIST_FOLD_RIGHT_198(o, s, l) BOOST_PP_LIST_FOLD_LEFT_198(o, s, BOOST_PP_LIST_REVERSE_D(198, l)) # define BOOST_PP_LIST_FOLD_RIGHT_199(o, s, l) BOOST_PP_LIST_FOLD_LEFT_199(o, s, BOOST_PP_LIST_REVERSE_D(199, l)) # define BOOST_PP_LIST_FOLD_RIGHT_200(o, s, l) BOOST_PP_LIST_FOLD_LEFT_200(o, s, BOOST_PP_LIST_REVERSE_D(200, l)) # define BOOST_PP_LIST_FOLD_RIGHT_201(o, s, l) BOOST_PP_LIST_FOLD_LEFT_201(o, s, BOOST_PP_LIST_REVERSE_D(201, l)) # define BOOST_PP_LIST_FOLD_RIGHT_202(o, s, l) BOOST_PP_LIST_FOLD_LEFT_202(o, s, BOOST_PP_LIST_REVERSE_D(202, l)) # define BOOST_PP_LIST_FOLD_RIGHT_203(o, s, l) BOOST_PP_LIST_FOLD_LEFT_203(o, s, BOOST_PP_LIST_REVERSE_D(203, l)) # define BOOST_PP_LIST_FOLD_RIGHT_204(o, s, l) BOOST_PP_LIST_FOLD_LEFT_204(o, s, BOOST_PP_LIST_REVERSE_D(204, l)) # define BOOST_PP_LIST_FOLD_RIGHT_205(o, s, l) BOOST_PP_LIST_FOLD_LEFT_205(o, s, BOOST_PP_LIST_REVERSE_D(205, l)) # define BOOST_PP_LIST_FOLD_RIGHT_206(o, s, l) BOOST_PP_LIST_FOLD_LEFT_206(o, s, BOOST_PP_LIST_REVERSE_D(206, l)) # define BOOST_PP_LIST_FOLD_RIGHT_207(o, s, l) BOOST_PP_LIST_FOLD_LEFT_207(o, s, BOOST_PP_LIST_REVERSE_D(207, l)) # define BOOST_PP_LIST_FOLD_RIGHT_208(o, s, l) BOOST_PP_LIST_FOLD_LEFT_208(o, s, BOOST_PP_LIST_REVERSE_D(208, l)) # define BOOST_PP_LIST_FOLD_RIGHT_209(o, s, l) BOOST_PP_LIST_FOLD_LEFT_209(o, s, BOOST_PP_LIST_REVERSE_D(209, l)) # define BOOST_PP_LIST_FOLD_RIGHT_210(o, s, l) BOOST_PP_LIST_FOLD_LEFT_210(o, s, BOOST_PP_LIST_REVERSE_D(210, l)) # define BOOST_PP_LIST_FOLD_RIGHT_211(o, s, l) BOOST_PP_LIST_FOLD_LEFT_211(o, s, BOOST_PP_LIST_REVERSE_D(211, l)) # define BOOST_PP_LIST_FOLD_RIGHT_212(o, s, l) BOOST_PP_LIST_FOLD_LEFT_212(o, s, BOOST_PP_LIST_REVERSE_D(212, l)) # define BOOST_PP_LIST_FOLD_RIGHT_213(o, s, l) BOOST_PP_LIST_FOLD_LEFT_213(o, s, BOOST_PP_LIST_REVERSE_D(213, l)) # define BOOST_PP_LIST_FOLD_RIGHT_214(o, s, l) BOOST_PP_LIST_FOLD_LEFT_214(o, s, BOOST_PP_LIST_REVERSE_D(214, l)) # define BOOST_PP_LIST_FOLD_RIGHT_215(o, s, l) BOOST_PP_LIST_FOLD_LEFT_215(o, s, BOOST_PP_LIST_REVERSE_D(215, l)) # define BOOST_PP_LIST_FOLD_RIGHT_216(o, s, l) BOOST_PP_LIST_FOLD_LEFT_216(o, s, BOOST_PP_LIST_REVERSE_D(216, l)) # define BOOST_PP_LIST_FOLD_RIGHT_217(o, s, l) BOOST_PP_LIST_FOLD_LEFT_217(o, s, BOOST_PP_LIST_REVERSE_D(217, l)) # define BOOST_PP_LIST_FOLD_RIGHT_218(o, s, l) BOOST_PP_LIST_FOLD_LEFT_218(o, s, BOOST_PP_LIST_REVERSE_D(218, l)) # define BOOST_PP_LIST_FOLD_RIGHT_219(o, s, l) BOOST_PP_LIST_FOLD_LEFT_219(o, s, BOOST_PP_LIST_REVERSE_D(219, l)) # define BOOST_PP_LIST_FOLD_RIGHT_220(o, s, l) BOOST_PP_LIST_FOLD_LEFT_220(o, s, BOOST_PP_LIST_REVERSE_D(220, l)) # define BOOST_PP_LIST_FOLD_RIGHT_221(o, s, l) BOOST_PP_LIST_FOLD_LEFT_221(o, s, BOOST_PP_LIST_REVERSE_D(221, l)) # define BOOST_PP_LIST_FOLD_RIGHT_222(o, s, l) BOOST_PP_LIST_FOLD_LEFT_222(o, s, BOOST_PP_LIST_REVERSE_D(222, l)) # define BOOST_PP_LIST_FOLD_RIGHT_223(o, s, l) BOOST_PP_LIST_FOLD_LEFT_223(o, s, BOOST_PP_LIST_REVERSE_D(223, l)) # define BOOST_PP_LIST_FOLD_RIGHT_224(o, s, l) BOOST_PP_LIST_FOLD_LEFT_224(o, s, BOOST_PP_LIST_REVERSE_D(224, l)) # define BOOST_PP_LIST_FOLD_RIGHT_225(o, s, l) BOOST_PP_LIST_FOLD_LEFT_225(o, s, BOOST_PP_LIST_REVERSE_D(225, l)) # define BOOST_PP_LIST_FOLD_RIGHT_226(o, s, l) BOOST_PP_LIST_FOLD_LEFT_226(o, s, BOOST_PP_LIST_REVERSE_D(226, l)) # define BOOST_PP_LIST_FOLD_RIGHT_227(o, s, l) BOOST_PP_LIST_FOLD_LEFT_227(o, s, BOOST_PP_LIST_REVERSE_D(227, l)) # define BOOST_PP_LIST_FOLD_RIGHT_228(o, s, l) BOOST_PP_LIST_FOLD_LEFT_228(o, s, BOOST_PP_LIST_REVERSE_D(228, l)) # define BOOST_PP_LIST_FOLD_RIGHT_229(o, s, l) BOOST_PP_LIST_FOLD_LEFT_229(o, s, BOOST_PP_LIST_REVERSE_D(229, l)) # define BOOST_PP_LIST_FOLD_RIGHT_230(o, s, l) BOOST_PP_LIST_FOLD_LEFT_230(o, s, BOOST_PP_LIST_REVERSE_D(230, l)) # define BOOST_PP_LIST_FOLD_RIGHT_231(o, s, l) BOOST_PP_LIST_FOLD_LEFT_231(o, s, BOOST_PP_LIST_REVERSE_D(231, l)) # define BOOST_PP_LIST_FOLD_RIGHT_232(o, s, l) BOOST_PP_LIST_FOLD_LEFT_232(o, s, BOOST_PP_LIST_REVERSE_D(232, l)) # define BOOST_PP_LIST_FOLD_RIGHT_233(o, s, l) BOOST_PP_LIST_FOLD_LEFT_233(o, s, BOOST_PP_LIST_REVERSE_D(233, l)) # define BOOST_PP_LIST_FOLD_RIGHT_234(o, s, l) BOOST_PP_LIST_FOLD_LEFT_234(o, s, BOOST_PP_LIST_REVERSE_D(234, l)) # define BOOST_PP_LIST_FOLD_RIGHT_235(o, s, l) BOOST_PP_LIST_FOLD_LEFT_235(o, s, BOOST_PP_LIST_REVERSE_D(235, l)) # define BOOST_PP_LIST_FOLD_RIGHT_236(o, s, l) BOOST_PP_LIST_FOLD_LEFT_236(o, s, BOOST_PP_LIST_REVERSE_D(236, l)) # define BOOST_PP_LIST_FOLD_RIGHT_237(o, s, l) BOOST_PP_LIST_FOLD_LEFT_237(o, s, BOOST_PP_LIST_REVERSE_D(237, l)) # define BOOST_PP_LIST_FOLD_RIGHT_238(o, s, l) BOOST_PP_LIST_FOLD_LEFT_238(o, s, BOOST_PP_LIST_REVERSE_D(238, l)) # define BOOST_PP_LIST_FOLD_RIGHT_239(o, s, l) BOOST_PP_LIST_FOLD_LEFT_239(o, s, BOOST_PP_LIST_REVERSE_D(239, l)) # define BOOST_PP_LIST_FOLD_RIGHT_240(o, s, l) BOOST_PP_LIST_FOLD_LEFT_240(o, s, BOOST_PP_LIST_REVERSE_D(240, l)) # define BOOST_PP_LIST_FOLD_RIGHT_241(o, s, l) BOOST_PP_LIST_FOLD_LEFT_241(o, s, BOOST_PP_LIST_REVERSE_D(241, l)) # define BOOST_PP_LIST_FOLD_RIGHT_242(o, s, l) BOOST_PP_LIST_FOLD_LEFT_242(o, s, BOOST_PP_LIST_REVERSE_D(242, l)) # define BOOST_PP_LIST_FOLD_RIGHT_243(o, s, l) BOOST_PP_LIST_FOLD_LEFT_243(o, s, BOOST_PP_LIST_REVERSE_D(243, l)) # define BOOST_PP_LIST_FOLD_RIGHT_244(o, s, l) BOOST_PP_LIST_FOLD_LEFT_244(o, s, BOOST_PP_LIST_REVERSE_D(244, l)) # define BOOST_PP_LIST_FOLD_RIGHT_245(o, s, l) BOOST_PP_LIST_FOLD_LEFT_245(o, s, BOOST_PP_LIST_REVERSE_D(245, l)) # define BOOST_PP_LIST_FOLD_RIGHT_246(o, s, l) BOOST_PP_LIST_FOLD_LEFT_246(o, s, BOOST_PP_LIST_REVERSE_D(246, l)) # define BOOST_PP_LIST_FOLD_RIGHT_247(o, s, l) BOOST_PP_LIST_FOLD_LEFT_247(o, s, BOOST_PP_LIST_REVERSE_D(247, l)) # define BOOST_PP_LIST_FOLD_RIGHT_248(o, s, l) BOOST_PP_LIST_FOLD_LEFT_248(o, s, BOOST_PP_LIST_REVERSE_D(248, l)) # define BOOST_PP_LIST_FOLD_RIGHT_249(o, s, l) BOOST_PP_LIST_FOLD_LEFT_249(o, s, BOOST_PP_LIST_REVERSE_D(249, l)) # define BOOST_PP_LIST_FOLD_RIGHT_250(o, s, l) BOOST_PP_LIST_FOLD_LEFT_250(o, s, BOOST_PP_LIST_REVERSE_D(250, l)) # define BOOST_PP_LIST_FOLD_RIGHT_251(o, s, l) BOOST_PP_LIST_FOLD_LEFT_251(o, s, BOOST_PP_LIST_REVERSE_D(251, l)) # define BOOST_PP_LIST_FOLD_RIGHT_252(o, s, l) BOOST_PP_LIST_FOLD_LEFT_252(o, s, BOOST_PP_LIST_REVERSE_D(252, l)) # define BOOST_PP_LIST_FOLD_RIGHT_253(o, s, l) BOOST_PP_LIST_FOLD_LEFT_253(o, s, BOOST_PP_LIST_REVERSE_D(253, l)) # define BOOST_PP_LIST_FOLD_RIGHT_254(o, s, l) BOOST_PP_LIST_FOLD_LEFT_254(o, s, BOOST_PP_LIST_REVERSE_D(254, l)) # define BOOST_PP_LIST_FOLD_RIGHT_255(o, s, l) BOOST_PP_LIST_FOLD_LEFT_255(o, s, BOOST_PP_LIST_REVERSE_D(255, l)) # define BOOST_PP_LIST_FOLD_RIGHT_256(o, s, l) BOOST_PP_LIST_FOLD_LEFT_256(o, s, BOOST_PP_LIST_REVERSE_D(256, l)) # # endif ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/fold_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000644000175000017500000017253111344301502031653 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP # define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP # # include # include # include # include # # define BOOST_PP_LIST_FOLD_LEFT_1(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_2(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_3(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_4(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_5(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_6(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_7(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_8(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_9(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_10(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_11(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_12(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_13(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_14(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_15(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_16(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_17(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_18(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_19(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_20(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_21(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_22(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_23(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_24(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_25(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_26(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_27(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_28(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_29(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_30(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_31(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_32(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_33(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_34(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_35(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_36(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_37(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_38(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_39(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_40(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_41(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_42(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_43(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_44(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_45(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_46(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_47(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_48(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_49(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_50(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_51(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_52(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_53(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_54(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_55(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_56(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_57(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_58(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_59(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_60(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_61(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_62(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_63(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_64(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_65(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_66(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_67(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_68(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_69(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_70(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_71(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_72(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_73(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_74(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_75(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_76(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_77(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_78(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_79(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_80(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_81(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_82(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_83(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_84(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_85(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_86(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_87(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_88(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_89(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_90(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_91(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_92(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_93(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_94(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_95(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_96(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_97(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_98(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_99(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_100(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_101(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_102(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_103(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_104(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_105(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_106(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_107(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_108(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_109(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_110(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_111(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_112(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_113(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_114(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_115(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_116(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_117(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_118(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_119(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_120(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_121(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_122(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_123(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_124(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_125(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_126(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_127(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_129(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_130(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_131(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_132(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_133(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_134(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_135(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_136(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_137(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_138(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_139(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_140(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_141(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_142(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_143(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_144(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_145(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_146(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_147(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_148(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_149(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_150(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_151(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_152(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_153(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_154(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_155(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_156(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_157(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_158(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_159(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_160(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_161(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_162(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_163(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_164(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_165(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_166(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_167(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_168(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_169(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_170(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_171(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_172(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_173(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_174(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_175(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_176(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_177(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_178(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_179(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_180(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_181(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_182(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_183(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_184(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_185(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_186(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_187(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_188(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_189(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_190(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_191(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_192(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_193(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_194(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_195(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_196(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_197(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_198(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_199(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_200(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_201(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_202(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_203(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_204(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_205(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_206(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_207(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_208(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_209(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_210(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_211(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_212(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_213(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_214(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_215(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_216(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_217(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_218(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_219(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_220(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_221(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_222(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_223(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_224(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_225(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_226(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_227(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_228(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_229(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_230(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_231(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_232(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_233(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_234(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_235(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_236(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_237(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_238(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_239(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_240(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_241(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_242(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_243(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_244(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_245(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_246(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_247(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_248(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_249(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_250(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_251(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_252(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_253(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_254(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_255(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_256(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/dmc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000755000175000017500000000000012146213766031657 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/dmc/fold_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000644000175000017500000020513211344301502031645 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP # define BOOST_PREPROCESSOR_LIST_DETAIL_FOLD_LEFT_HPP # # include # include # include # include # # define BOOST_PP_LIST_FOLD_LEFT_1(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_2(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_3(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_4(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_5(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_6(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_7(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_8(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_9(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_10(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_11(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_12(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_13(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_14(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_15(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_16(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_17(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_18(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_19(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_20(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_21(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_22(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_23(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_24(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_25(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_26(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_27(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_28(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_29(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_30(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_31(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_32(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_33(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_34(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_35(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_36(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_37(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_38(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_39(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_40(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_41(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_42(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_43(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_44(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_45(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_46(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_47(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_48(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_49(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_50(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_51(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_52(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_53(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_54(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_55(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_56(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_57(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_58(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_59(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_60(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_61(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_62(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_63(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_64(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_65(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_66(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_67(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_68(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_69(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_70(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_71(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_72(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_73(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_74(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_75(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_76(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_77(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_78(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_79(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_80(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_81(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_82(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_83(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_84(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_85(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_86(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_87(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_88(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_89(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_90(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_91(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_92(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_93(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_94(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_95(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_96(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_97(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_98(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_99(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_100(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_101(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_102(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_103(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_104(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_105(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_106(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_107(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_108(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_109(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_110(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_111(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_112(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_113(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_114(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_115(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_116(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_117(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_118(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_119(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_120(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_121(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_122(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_123(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_124(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_125(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_126(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_127(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_129(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_130(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_131(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_132(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_133(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_134(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_135(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_136(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_137(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_138(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_139(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_140(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_141(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_142(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_143(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_144(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_145(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_146(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_147(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_148(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_149(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_150(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_151(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_152(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_153(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_154(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_155(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_156(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_157(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_158(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_159(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_160(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_161(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_162(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_163(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_164(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_165(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_166(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_167(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_168(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_169(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_170(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_171(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_172(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_173(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_174(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_175(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_176(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_177(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_178(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_179(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_180(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_181(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_182(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_183(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_184(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_185(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_186(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_187(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_188(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_189(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_190(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_191(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_192(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_193(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_194(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_195(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_196(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_197(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_198(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_199(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_200(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_201(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_202(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_203(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_204(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_205(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_206(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_207(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_208(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_209(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_210(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_211(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_212(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_213(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_214(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_215(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_216(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_217(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_218(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_219(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_220(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_221(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_222(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_223(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_224(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_225(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_226(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_227(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_228(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_229(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_230(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_231(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_232(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_233(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_234(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_235(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_236(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_237(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_238(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_239(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_240(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_241(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_242(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_243(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_244(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_245(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_246(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_247(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_248(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_249(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_250(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_251(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_252(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_253(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_254(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_255(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_256(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, BOOST_PP_TUPLE_ELEM_3_1)(o, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, BOOST_PP_TUPLE_ELEM_3_1)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # # endif ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/edg/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000755000175000017500000000000012146213767031660 5ustar debiandebian././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/edg/fold_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000644000175000017500000033645011344301502031655 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_DETAIL_EDG_FOLD_RIGHT_HPP # define BOOST_PREPROCESSOR_LIST_DETAIL_EDG_FOLD_RIGHT_HPP # # include # include # include # # define BOOST_PP_LIST_FOLD_RIGHT_1(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_1_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_2(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_2_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_3(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_3_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_4(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_4_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_5(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_5_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_6(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_6_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_7(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_7_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_8(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_8_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_9(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_9_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_10(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_10_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_11(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_11_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_12(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_12_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_13(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_13_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_14(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_14_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_15(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_15_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_16(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_16_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_17(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_17_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_18(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_18_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_19(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_19_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_20(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_20_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_21(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_21_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_22(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_22_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_23(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_23_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_24(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_24_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_25(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_25_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_26(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_26_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_27(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_27_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_28(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_28_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_29(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_29_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_30(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_30_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_31(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_31_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_32(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_32_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_33(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_33_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_34(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_34_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_35(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_35_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_36(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_36_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_37(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_37_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_38(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_38_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_39(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_39_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_40(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_40_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_41(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_41_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_42(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_42_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_43(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_43_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_44(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_44_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_45(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_45_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_46(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_46_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_47(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_47_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_48(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_48_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_49(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_49_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_50(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_50_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_51(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_51_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_52(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_52_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_53(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_53_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_54(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_54_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_55(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_55_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_56(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_56_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_57(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_57_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_58(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_58_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_59(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_59_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_60(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_60_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_61(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_61_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_62(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_62_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_63(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_63_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_64(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_64_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_65(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_65_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_66(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_66_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_67(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_67_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_68(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_68_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_69(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_69_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_70(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_70_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_71(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_71_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_72(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_72_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_73(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_73_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_74(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_74_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_75(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_75_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_76(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_76_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_77(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_77_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_78(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_78_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_79(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_79_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_80(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_80_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_81(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_81_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_82(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_82_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_83(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_83_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_84(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_84_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_85(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_85_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_86(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_86_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_87(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_87_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_88(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_88_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_89(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_89_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_90(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_90_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_91(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_91_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_92(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_92_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_93(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_93_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_94(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_94_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_95(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_95_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_96(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_96_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_97(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_97_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_98(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_98_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_99(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_99_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_100(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_100_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_101(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_101_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_102(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_102_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_103(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_103_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_104(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_104_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_105(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_105_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_106(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_106_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_107(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_107_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_108(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_108_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_109(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_109_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_110(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_110_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_111(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_111_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_112(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_112_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_113(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_113_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_114(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_114_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_115(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_115_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_116(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_116_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_117(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_117_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_118(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_118_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_119(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_119_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_120(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_120_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_121(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_121_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_122(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_122_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_123(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_123_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_124(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_124_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_125(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_125_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_126(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_126_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_127(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_127_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_128(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_128_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_129(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_129_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_130(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_130_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_131(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_131_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_132(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_132_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_133(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_133_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_134(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_134_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_135(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_135_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_136(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_136_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_137(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_137_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_138(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_138_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_139(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_139_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_140(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_140_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_141(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_141_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_142(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_142_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_143(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_143_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_144(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_144_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_145(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_145_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_146(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_146_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_147(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_147_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_148(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_148_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_149(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_149_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_150(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_150_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_151(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_151_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_152(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_152_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_153(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_153_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_154(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_154_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_155(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_155_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_156(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_156_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_157(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_157_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_158(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_158_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_159(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_159_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_160(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_160_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_161(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_161_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_162(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_162_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_163(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_163_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_164(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_164_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_165(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_165_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_166(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_166_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_167(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_167_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_168(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_168_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_169(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_169_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_170(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_170_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_171(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_171_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_172(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_172_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_173(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_173_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_174(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_174_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_175(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_175_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_176(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_176_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_177(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_177_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_178(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_178_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_179(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_179_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_180(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_180_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_181(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_181_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_182(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_182_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_183(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_183_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_184(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_184_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_185(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_185_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_186(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_186_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_187(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_187_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_188(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_188_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_189(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_189_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_190(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_190_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_191(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_191_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_192(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_192_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_193(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_193_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_194(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_194_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_195(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_195_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_196(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_196_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_197(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_197_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_198(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_198_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_199(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_199_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_200(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_200_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_201(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_201_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_202(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_202_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_203(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_203_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_204(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_204_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_205(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_205_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_206(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_206_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_207(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_207_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_208(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_208_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_209(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_209_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_210(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_210_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_211(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_211_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_212(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_212_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_213(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_213_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_214(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_214_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_215(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_215_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_216(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_216_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_217(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_217_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_218(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_218_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_219(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_219_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_220(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_220_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_221(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_221_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_222(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_222_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_223(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_223_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_224(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_224_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_225(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_225_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_226(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_226_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_227(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_227_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_228(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_228_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_229(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_229_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_230(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_230_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_231(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_231_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_232(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_232_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_233(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_233_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_234(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_234_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_235(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_235_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_236(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_236_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_237(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_237_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_238(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_238_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_239(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_239_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_240(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_240_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_241(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_241_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_242(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_242_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_243(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_243_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_244(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_244_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_245(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_245_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_246(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_246_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_247(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_247_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_248(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_248_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_249(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_249_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_250(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_250_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_251(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_251_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_252(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_252_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_253(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_253_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_254(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_254_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_255(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_255_D(o, s, l) # define BOOST_PP_LIST_FOLD_RIGHT_256(o, s, l) BOOST_PP_LIST_FOLD_RIGHT_256_D(o, s, l) # # define BOOST_PP_LIST_FOLD_RIGHT_1_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(2, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_2, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_2_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(3, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_3, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_3_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(4, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_4, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_4_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(5, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_5, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_5_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(6, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_6, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_6_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(7, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_7, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_7_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(8, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_8, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_8_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(9, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_9, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_9_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(10, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_10, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_10_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(11, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_11, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_11_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(12, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_12, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_12_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(13, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_13, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_13_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(14, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_14, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_14_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(15, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_15, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_15_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(16, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_16, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_16_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(17, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_17, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_17_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(18, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_18, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_18_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(19, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_19, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_19_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(20, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_20, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_20_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(21, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_21, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_21_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(22, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_22, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_22_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(23, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_23, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_23_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(24, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_24, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_24_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(25, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_25, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_25_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(26, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_26, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_26_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(27, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_27, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_27_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(28, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_28, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_28_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(29, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_29, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_29_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(30, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_30, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_30_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(31, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_31, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_31_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(32, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_32, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_32_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(33, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_33, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_33_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(34, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_34, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_34_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(35, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_35, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_35_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(36, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_36, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_36_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(37, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_37, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_37_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(38, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_38, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_38_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(39, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_39, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_39_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(40, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_40, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_40_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(41, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_41, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_41_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(42, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_42, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_42_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(43, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_43, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_43_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(44, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_44, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_44_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(45, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_45, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_45_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(46, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_46, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_46_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(47, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_47, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_47_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(48, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_48, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_48_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(49, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_49, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_49_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(50, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_50, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_50_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(51, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_51, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_51_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(52, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_52, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_52_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(53, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_53, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_53_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(54, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_54, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_54_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(55, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_55, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_55_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(56, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_56, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_56_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(57, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_57, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_57_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(58, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_58, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_58_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(59, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_59, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_59_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(60, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_60, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_60_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(61, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_61, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_61_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(62, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_62, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_62_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(63, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_63, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_63_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(64, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_64, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_64_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(65, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_65, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_65_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(66, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_66, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_66_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(67, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_67, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_67_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(68, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_68, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_68_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(69, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_69, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_69_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(70, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_70, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_70_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(71, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_71, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_71_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(72, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_72, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_72_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(73, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_73, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_73_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(74, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_74, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_74_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(75, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_75, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_75_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(76, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_76, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_76_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(77, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_77, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_77_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(78, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_78, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_78_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(79, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_79, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_79_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(80, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_80, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_80_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(81, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_81, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_81_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(82, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_82, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_82_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(83, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_83, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_83_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(84, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_84, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_84_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(85, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_85, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_85_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(86, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_86, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_86_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(87, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_87, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_87_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(88, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_88, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_88_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(89, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_89, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_89_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(90, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_90, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_90_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(91, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_91, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_91_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(92, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_92, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_92_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(93, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_93, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_93_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(94, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_94, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_94_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(95, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_95, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_95_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(96, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_96, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_96_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(97, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_97, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_97_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(98, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_98, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_98_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(99, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_99, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_99_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(100, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_100, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_100_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(101, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_101, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_101_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(102, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_102, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_102_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(103, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_103, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_103_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(104, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_104, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_104_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(105, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_105, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_105_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(106, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_106, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_106_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(107, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_107, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_107_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(108, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_108, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_108_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(109, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_109, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_109_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(110, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_110, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_110_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(111, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_111, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_111_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(112, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_112, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_112_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(113, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_113, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_113_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(114, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_114, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_114_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(115, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_115, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_115_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(116, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_116, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_116_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(117, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_117, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_117_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(118, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_118, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_118_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(119, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_119, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_119_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(120, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_120, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_120_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(121, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_121, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_121_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(122, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_122, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_122_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(123, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_123, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_123_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(124, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_124, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_124_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(125, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_125, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_125_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(126, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_126, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_126_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(127, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_127, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_127_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(128, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_128, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_128_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(129, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_129, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_129_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(130, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_130, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_130_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(131, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_131, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_131_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(132, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_132, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_132_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(133, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_133, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_133_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(134, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_134, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_134_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(135, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_135, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_135_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(136, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_136, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_136_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(137, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_137, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_137_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(138, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_138, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_138_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(139, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_139, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_139_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(140, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_140, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_140_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(141, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_141, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_141_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(142, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_142, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_142_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(143, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_143, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_143_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(144, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_144, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_144_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(145, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_145, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_145_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(146, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_146, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_146_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(147, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_147, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_147_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(148, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_148, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_148_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(149, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_149, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_149_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(150, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_150, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_150_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(151, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_151, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_151_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(152, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_152, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_152_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(153, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_153, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_153_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(154, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_154, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_154_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(155, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_155, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_155_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(156, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_156, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_156_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(157, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_157, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_157_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(158, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_158, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_158_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(159, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_159, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_159_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(160, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_160, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_160_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(161, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_161, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_161_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(162, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_162, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_162_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(163, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_163, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_163_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(164, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_164, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_164_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(165, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_165, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_165_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(166, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_166, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_166_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(167, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_167, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_167_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(168, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_168, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_168_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(169, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_169, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_169_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(170, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_170, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_170_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(171, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_171, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_171_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(172, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_172, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_172_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(173, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_173, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_173_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(174, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_174, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_174_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(175, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_175, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_175_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(176, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_176, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_176_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(177, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_177, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_177_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(178, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_178, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_178_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(179, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_179, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_179_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(180, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_180, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_180_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(181, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_181, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_181_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(182, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_182, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_182_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(183, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_183, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_183_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(184, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_184, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_184_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(185, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_185, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_185_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(186, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_186, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_186_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(187, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_187, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_187_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(188, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_188, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_188_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(189, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_189, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_189_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(190, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_190, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_190_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(191, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_191, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_191_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(192, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_192, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_192_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(193, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_193, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_193_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(194, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_194, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_194_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(195, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_195, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_195_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(196, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_196, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_196_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(197, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_197, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_197_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(198, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_198, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_198_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(199, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_199, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_199_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(200, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_200, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_200_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(201, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_201, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_201_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(202, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_202, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_202_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(203, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_203, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_203_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(204, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_204, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_204_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(205, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_205, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_205_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(206, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_206, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_206_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(207, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_207, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_207_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(208, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_208, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_208_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(209, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_209, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_209_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(210, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_210, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_210_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(211, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_211, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_211_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(212, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_212, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_212_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(213, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_213, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_213_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(214, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_214, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_214_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(215, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_215, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_215_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(216, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_216, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_216_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(217, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_217, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_217_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(218, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_218, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_218_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(219, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_219, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_219_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(220, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_220, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_220_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(221, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_221, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_221_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(222, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_222, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_222_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(223, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_223, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_223_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(224, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_224, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_224_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(225, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_225, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_225_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(226, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_226, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_226_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(227, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_227, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_227_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(228, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_228, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_228_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(229, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_229, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_229_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(230, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_230, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_230_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(231, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_231, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_231_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(232, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_232, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_232_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(233, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_233, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_233_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(234, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_234, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_234_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(235, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_235, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_235_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(236, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_236, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_236_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(237, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_237, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_237_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(238, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_238, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_238_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(239, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_239, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_239_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(240, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_240, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_240_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(241, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_241, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_241_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(242, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_242, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_242_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(243, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_243, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_243_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(244, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_244, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_244_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(245, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_245, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_245_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(246, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_246, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_246_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(247, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_247, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_247_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(248, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_248, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_248_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(249, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_249, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_249_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(250, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_250, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_250_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(251, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_251, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_251_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(252, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_252, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_252_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(253, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_253, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_253_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(254, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_254, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_254_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(255, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_255, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_255_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(256, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_256, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # define BOOST_PP_LIST_FOLD_RIGHT_256_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), o, s BOOST_PP_TUPLE_EAT_3)(257, BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_RIGHT_257, BOOST_PP_NIL BOOST_PP_TUPLE_EAT_3)(o, s, BOOST_PP_LIST_REST(l)), BOOST_PP_LIST_FIRST(l)) # # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_NIL 1 # # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_1(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_2(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_3(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_4(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_5(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_6(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_7(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_8(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_9(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_10(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_11(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_12(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_13(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_14(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_15(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_16(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_17(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_18(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_19(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_20(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_21(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_22(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_23(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_24(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_25(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_26(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_27(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_28(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_29(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_30(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_31(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_32(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_33(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_34(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_35(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_36(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_37(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_38(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_39(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_40(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_41(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_42(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_43(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_44(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_45(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_46(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_47(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_48(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_49(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_50(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_51(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_52(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_53(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_54(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_55(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_56(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_57(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_58(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_59(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_60(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_61(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_62(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_63(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_64(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_65(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_66(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_67(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_68(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_69(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_70(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_71(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_72(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_73(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_74(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_75(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_76(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_77(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_78(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_79(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_80(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_81(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_82(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_83(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_84(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_85(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_86(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_87(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_88(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_89(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_90(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_91(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_92(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_93(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_94(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_95(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_96(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_97(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_98(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_99(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_100(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_101(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_102(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_103(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_104(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_105(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_106(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_107(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_108(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_109(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_110(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_111(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_112(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_113(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_114(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_115(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_116(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_117(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_118(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_119(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_120(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_121(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_122(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_123(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_124(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_125(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_126(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_127(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_128(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_129(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_130(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_131(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_132(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_133(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_134(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_135(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_136(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_137(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_138(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_139(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_140(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_141(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_142(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_143(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_144(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_145(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_146(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_147(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_148(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_149(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_150(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_151(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_152(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_153(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_154(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_155(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_156(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_157(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_158(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_159(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_160(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_161(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_162(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_163(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_164(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_165(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_166(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_167(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_168(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_169(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_170(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_171(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_172(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_173(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_174(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_175(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_176(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_177(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_178(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_179(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_180(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_181(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_182(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_183(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_184(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_185(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_186(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_187(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_188(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_189(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_190(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_191(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_192(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_193(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_194(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_195(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_196(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_197(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_198(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_199(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_200(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_201(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_202(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_203(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_204(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_205(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_206(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_207(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_208(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_209(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_210(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_211(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_212(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_213(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_214(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_215(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_216(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_217(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_218(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_219(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_220(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_221(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_222(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_223(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_224(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_225(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_226(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_227(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_228(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_229(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_230(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_231(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_232(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_233(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_234(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_235(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_236(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_237(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_238(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_239(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_240(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_241(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_242(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_243(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_244(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_245(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_246(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_247(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_248(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_249(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_250(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_251(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_252(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_253(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_254(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_255(o, s, l) 0 # define BOOST_PP_LIST_FOLD_RIGHT_CHECK_BOOST_PP_LIST_FOLD_RIGHT_256(o, s, l) 0 # # endif ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/detail/edg/fold_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/list/det0000644000175000017500000024561311344301502031655 0ustar debiandebian# /* Copyright (C) 2001 # * Housemarque Oy # * http://www.housemarque.com # * # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # */ # # /* Revised by Paul Mensonides (2002) */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_LIST_DETAIL_EDG_FOLD_LEFT_HPP # define BOOST_PREPROCESSOR_LIST_DETAIL_EDG_FOLD_LEFT_HPP # # include # include # include # include # # define BOOST_PP_LIST_FOLD_LEFT_1(o, s, l) BOOST_PP_LIST_FOLD_LEFT_1_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_2(o, s, l) BOOST_PP_LIST_FOLD_LEFT_2_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_3(o, s, l) BOOST_PP_LIST_FOLD_LEFT_3_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_4(o, s, l) BOOST_PP_LIST_FOLD_LEFT_4_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_5(o, s, l) BOOST_PP_LIST_FOLD_LEFT_5_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_6(o, s, l) BOOST_PP_LIST_FOLD_LEFT_6_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_7(o, s, l) BOOST_PP_LIST_FOLD_LEFT_7_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_8(o, s, l) BOOST_PP_LIST_FOLD_LEFT_8_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_9(o, s, l) BOOST_PP_LIST_FOLD_LEFT_9_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_10(o, s, l) BOOST_PP_LIST_FOLD_LEFT_10_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_11(o, s, l) BOOST_PP_LIST_FOLD_LEFT_11_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_12(o, s, l) BOOST_PP_LIST_FOLD_LEFT_12_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_13(o, s, l) BOOST_PP_LIST_FOLD_LEFT_13_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_14(o, s, l) BOOST_PP_LIST_FOLD_LEFT_14_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_15(o, s, l) BOOST_PP_LIST_FOLD_LEFT_15_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_16(o, s, l) BOOST_PP_LIST_FOLD_LEFT_16_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_17(o, s, l) BOOST_PP_LIST_FOLD_LEFT_17_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_18(o, s, l) BOOST_PP_LIST_FOLD_LEFT_18_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_19(o, s, l) BOOST_PP_LIST_FOLD_LEFT_19_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_20(o, s, l) BOOST_PP_LIST_FOLD_LEFT_20_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_21(o, s, l) BOOST_PP_LIST_FOLD_LEFT_21_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_22(o, s, l) BOOST_PP_LIST_FOLD_LEFT_22_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_23(o, s, l) BOOST_PP_LIST_FOLD_LEFT_23_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_24(o, s, l) BOOST_PP_LIST_FOLD_LEFT_24_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_25(o, s, l) BOOST_PP_LIST_FOLD_LEFT_25_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_26(o, s, l) BOOST_PP_LIST_FOLD_LEFT_26_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_27(o, s, l) BOOST_PP_LIST_FOLD_LEFT_27_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_28(o, s, l) BOOST_PP_LIST_FOLD_LEFT_28_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_29(o, s, l) BOOST_PP_LIST_FOLD_LEFT_29_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_30(o, s, l) BOOST_PP_LIST_FOLD_LEFT_30_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_31(o, s, l) BOOST_PP_LIST_FOLD_LEFT_31_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_32(o, s, l) BOOST_PP_LIST_FOLD_LEFT_32_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_33(o, s, l) BOOST_PP_LIST_FOLD_LEFT_33_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_34(o, s, l) BOOST_PP_LIST_FOLD_LEFT_34_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_35(o, s, l) BOOST_PP_LIST_FOLD_LEFT_35_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_36(o, s, l) BOOST_PP_LIST_FOLD_LEFT_36_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_37(o, s, l) BOOST_PP_LIST_FOLD_LEFT_37_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_38(o, s, l) BOOST_PP_LIST_FOLD_LEFT_38_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_39(o, s, l) BOOST_PP_LIST_FOLD_LEFT_39_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_40(o, s, l) BOOST_PP_LIST_FOLD_LEFT_40_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_41(o, s, l) BOOST_PP_LIST_FOLD_LEFT_41_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_42(o, s, l) BOOST_PP_LIST_FOLD_LEFT_42_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_43(o, s, l) BOOST_PP_LIST_FOLD_LEFT_43_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_44(o, s, l) BOOST_PP_LIST_FOLD_LEFT_44_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_45(o, s, l) BOOST_PP_LIST_FOLD_LEFT_45_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_46(o, s, l) BOOST_PP_LIST_FOLD_LEFT_46_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_47(o, s, l) BOOST_PP_LIST_FOLD_LEFT_47_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_48(o, s, l) BOOST_PP_LIST_FOLD_LEFT_48_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_49(o, s, l) BOOST_PP_LIST_FOLD_LEFT_49_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_50(o, s, l) BOOST_PP_LIST_FOLD_LEFT_50_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_51(o, s, l) BOOST_PP_LIST_FOLD_LEFT_51_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_52(o, s, l) BOOST_PP_LIST_FOLD_LEFT_52_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_53(o, s, l) BOOST_PP_LIST_FOLD_LEFT_53_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_54(o, s, l) BOOST_PP_LIST_FOLD_LEFT_54_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_55(o, s, l) BOOST_PP_LIST_FOLD_LEFT_55_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_56(o, s, l) BOOST_PP_LIST_FOLD_LEFT_56_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_57(o, s, l) BOOST_PP_LIST_FOLD_LEFT_57_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_58(o, s, l) BOOST_PP_LIST_FOLD_LEFT_58_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_59(o, s, l) BOOST_PP_LIST_FOLD_LEFT_59_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_60(o, s, l) BOOST_PP_LIST_FOLD_LEFT_60_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_61(o, s, l) BOOST_PP_LIST_FOLD_LEFT_61_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_62(o, s, l) BOOST_PP_LIST_FOLD_LEFT_62_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_63(o, s, l) BOOST_PP_LIST_FOLD_LEFT_63_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_64(o, s, l) BOOST_PP_LIST_FOLD_LEFT_64_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_65(o, s, l) BOOST_PP_LIST_FOLD_LEFT_65_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_66(o, s, l) BOOST_PP_LIST_FOLD_LEFT_66_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_67(o, s, l) BOOST_PP_LIST_FOLD_LEFT_67_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_68(o, s, l) BOOST_PP_LIST_FOLD_LEFT_68_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_69(o, s, l) BOOST_PP_LIST_FOLD_LEFT_69_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_70(o, s, l) BOOST_PP_LIST_FOLD_LEFT_70_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_71(o, s, l) BOOST_PP_LIST_FOLD_LEFT_71_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_72(o, s, l) BOOST_PP_LIST_FOLD_LEFT_72_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_73(o, s, l) BOOST_PP_LIST_FOLD_LEFT_73_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_74(o, s, l) BOOST_PP_LIST_FOLD_LEFT_74_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_75(o, s, l) BOOST_PP_LIST_FOLD_LEFT_75_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_76(o, s, l) BOOST_PP_LIST_FOLD_LEFT_76_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_77(o, s, l) BOOST_PP_LIST_FOLD_LEFT_77_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_78(o, s, l) BOOST_PP_LIST_FOLD_LEFT_78_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_79(o, s, l) BOOST_PP_LIST_FOLD_LEFT_79_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_80(o, s, l) BOOST_PP_LIST_FOLD_LEFT_80_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_81(o, s, l) BOOST_PP_LIST_FOLD_LEFT_81_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_82(o, s, l) BOOST_PP_LIST_FOLD_LEFT_82_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_83(o, s, l) BOOST_PP_LIST_FOLD_LEFT_83_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_84(o, s, l) BOOST_PP_LIST_FOLD_LEFT_84_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_85(o, s, l) BOOST_PP_LIST_FOLD_LEFT_85_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_86(o, s, l) BOOST_PP_LIST_FOLD_LEFT_86_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_87(o, s, l) BOOST_PP_LIST_FOLD_LEFT_87_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_88(o, s, l) BOOST_PP_LIST_FOLD_LEFT_88_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_89(o, s, l) BOOST_PP_LIST_FOLD_LEFT_89_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_90(o, s, l) BOOST_PP_LIST_FOLD_LEFT_90_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_91(o, s, l) BOOST_PP_LIST_FOLD_LEFT_91_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_92(o, s, l) BOOST_PP_LIST_FOLD_LEFT_92_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_93(o, s, l) BOOST_PP_LIST_FOLD_LEFT_93_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_94(o, s, l) BOOST_PP_LIST_FOLD_LEFT_94_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_95(o, s, l) BOOST_PP_LIST_FOLD_LEFT_95_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_96(o, s, l) BOOST_PP_LIST_FOLD_LEFT_96_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_97(o, s, l) BOOST_PP_LIST_FOLD_LEFT_97_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_98(o, s, l) BOOST_PP_LIST_FOLD_LEFT_98_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_99(o, s, l) BOOST_PP_LIST_FOLD_LEFT_99_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_100(o, s, l) BOOST_PP_LIST_FOLD_LEFT_100_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_101(o, s, l) BOOST_PP_LIST_FOLD_LEFT_101_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_102(o, s, l) BOOST_PP_LIST_FOLD_LEFT_102_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_103(o, s, l) BOOST_PP_LIST_FOLD_LEFT_103_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_104(o, s, l) BOOST_PP_LIST_FOLD_LEFT_104_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_105(o, s, l) BOOST_PP_LIST_FOLD_LEFT_105_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_106(o, s, l) BOOST_PP_LIST_FOLD_LEFT_106_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_107(o, s, l) BOOST_PP_LIST_FOLD_LEFT_107_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_108(o, s, l) BOOST_PP_LIST_FOLD_LEFT_108_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_109(o, s, l) BOOST_PP_LIST_FOLD_LEFT_109_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_110(o, s, l) BOOST_PP_LIST_FOLD_LEFT_110_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_111(o, s, l) BOOST_PP_LIST_FOLD_LEFT_111_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_112(o, s, l) BOOST_PP_LIST_FOLD_LEFT_112_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_113(o, s, l) BOOST_PP_LIST_FOLD_LEFT_113_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_114(o, s, l) BOOST_PP_LIST_FOLD_LEFT_114_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_115(o, s, l) BOOST_PP_LIST_FOLD_LEFT_115_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_116(o, s, l) BOOST_PP_LIST_FOLD_LEFT_116_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_117(o, s, l) BOOST_PP_LIST_FOLD_LEFT_117_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_118(o, s, l) BOOST_PP_LIST_FOLD_LEFT_118_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_119(o, s, l) BOOST_PP_LIST_FOLD_LEFT_119_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_120(o, s, l) BOOST_PP_LIST_FOLD_LEFT_120_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_121(o, s, l) BOOST_PP_LIST_FOLD_LEFT_121_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_122(o, s, l) BOOST_PP_LIST_FOLD_LEFT_122_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_123(o, s, l) BOOST_PP_LIST_FOLD_LEFT_123_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_124(o, s, l) BOOST_PP_LIST_FOLD_LEFT_124_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_125(o, s, l) BOOST_PP_LIST_FOLD_LEFT_125_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_126(o, s, l) BOOST_PP_LIST_FOLD_LEFT_126_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_127(o, s, l) BOOST_PP_LIST_FOLD_LEFT_127_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_128(o, s, l) BOOST_PP_LIST_FOLD_LEFT_128_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_129(o, s, l) BOOST_PP_LIST_FOLD_LEFT_129_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_130(o, s, l) BOOST_PP_LIST_FOLD_LEFT_130_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_131(o, s, l) BOOST_PP_LIST_FOLD_LEFT_131_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_132(o, s, l) BOOST_PP_LIST_FOLD_LEFT_132_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_133(o, s, l) BOOST_PP_LIST_FOLD_LEFT_133_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_134(o, s, l) BOOST_PP_LIST_FOLD_LEFT_134_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_135(o, s, l) BOOST_PP_LIST_FOLD_LEFT_135_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_136(o, s, l) BOOST_PP_LIST_FOLD_LEFT_136_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_137(o, s, l) BOOST_PP_LIST_FOLD_LEFT_137_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_138(o, s, l) BOOST_PP_LIST_FOLD_LEFT_138_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_139(o, s, l) BOOST_PP_LIST_FOLD_LEFT_139_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_140(o, s, l) BOOST_PP_LIST_FOLD_LEFT_140_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_141(o, s, l) BOOST_PP_LIST_FOLD_LEFT_141_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_142(o, s, l) BOOST_PP_LIST_FOLD_LEFT_142_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_143(o, s, l) BOOST_PP_LIST_FOLD_LEFT_143_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_144(o, s, l) BOOST_PP_LIST_FOLD_LEFT_144_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_145(o, s, l) BOOST_PP_LIST_FOLD_LEFT_145_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_146(o, s, l) BOOST_PP_LIST_FOLD_LEFT_146_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_147(o, s, l) BOOST_PP_LIST_FOLD_LEFT_147_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_148(o, s, l) BOOST_PP_LIST_FOLD_LEFT_148_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_149(o, s, l) BOOST_PP_LIST_FOLD_LEFT_149_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_150(o, s, l) BOOST_PP_LIST_FOLD_LEFT_150_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_151(o, s, l) BOOST_PP_LIST_FOLD_LEFT_151_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_152(o, s, l) BOOST_PP_LIST_FOLD_LEFT_152_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_153(o, s, l) BOOST_PP_LIST_FOLD_LEFT_153_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_154(o, s, l) BOOST_PP_LIST_FOLD_LEFT_154_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_155(o, s, l) BOOST_PP_LIST_FOLD_LEFT_155_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_156(o, s, l) BOOST_PP_LIST_FOLD_LEFT_156_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_157(o, s, l) BOOST_PP_LIST_FOLD_LEFT_157_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_158(o, s, l) BOOST_PP_LIST_FOLD_LEFT_158_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_159(o, s, l) BOOST_PP_LIST_FOLD_LEFT_159_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_160(o, s, l) BOOST_PP_LIST_FOLD_LEFT_160_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_161(o, s, l) BOOST_PP_LIST_FOLD_LEFT_161_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_162(o, s, l) BOOST_PP_LIST_FOLD_LEFT_162_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_163(o, s, l) BOOST_PP_LIST_FOLD_LEFT_163_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_164(o, s, l) BOOST_PP_LIST_FOLD_LEFT_164_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_165(o, s, l) BOOST_PP_LIST_FOLD_LEFT_165_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_166(o, s, l) BOOST_PP_LIST_FOLD_LEFT_166_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_167(o, s, l) BOOST_PP_LIST_FOLD_LEFT_167_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_168(o, s, l) BOOST_PP_LIST_FOLD_LEFT_168_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_169(o, s, l) BOOST_PP_LIST_FOLD_LEFT_169_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_170(o, s, l) BOOST_PP_LIST_FOLD_LEFT_170_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_171(o, s, l) BOOST_PP_LIST_FOLD_LEFT_171_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_172(o, s, l) BOOST_PP_LIST_FOLD_LEFT_172_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_173(o, s, l) BOOST_PP_LIST_FOLD_LEFT_173_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_174(o, s, l) BOOST_PP_LIST_FOLD_LEFT_174_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_175(o, s, l) BOOST_PP_LIST_FOLD_LEFT_175_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_176(o, s, l) BOOST_PP_LIST_FOLD_LEFT_176_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_177(o, s, l) BOOST_PP_LIST_FOLD_LEFT_177_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_178(o, s, l) BOOST_PP_LIST_FOLD_LEFT_178_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_179(o, s, l) BOOST_PP_LIST_FOLD_LEFT_179_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_180(o, s, l) BOOST_PP_LIST_FOLD_LEFT_180_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_181(o, s, l) BOOST_PP_LIST_FOLD_LEFT_181_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_182(o, s, l) BOOST_PP_LIST_FOLD_LEFT_182_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_183(o, s, l) BOOST_PP_LIST_FOLD_LEFT_183_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_184(o, s, l) BOOST_PP_LIST_FOLD_LEFT_184_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_185(o, s, l) BOOST_PP_LIST_FOLD_LEFT_185_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_186(o, s, l) BOOST_PP_LIST_FOLD_LEFT_186_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_187(o, s, l) BOOST_PP_LIST_FOLD_LEFT_187_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_188(o, s, l) BOOST_PP_LIST_FOLD_LEFT_188_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_189(o, s, l) BOOST_PP_LIST_FOLD_LEFT_189_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_190(o, s, l) BOOST_PP_LIST_FOLD_LEFT_190_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_191(o, s, l) BOOST_PP_LIST_FOLD_LEFT_191_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_192(o, s, l) BOOST_PP_LIST_FOLD_LEFT_192_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_193(o, s, l) BOOST_PP_LIST_FOLD_LEFT_193_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_194(o, s, l) BOOST_PP_LIST_FOLD_LEFT_194_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_195(o, s, l) BOOST_PP_LIST_FOLD_LEFT_195_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_196(o, s, l) BOOST_PP_LIST_FOLD_LEFT_196_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_197(o, s, l) BOOST_PP_LIST_FOLD_LEFT_197_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_198(o, s, l) BOOST_PP_LIST_FOLD_LEFT_198_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_199(o, s, l) BOOST_PP_LIST_FOLD_LEFT_199_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_200(o, s, l) BOOST_PP_LIST_FOLD_LEFT_200_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_201(o, s, l) BOOST_PP_LIST_FOLD_LEFT_201_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_202(o, s, l) BOOST_PP_LIST_FOLD_LEFT_202_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_203(o, s, l) BOOST_PP_LIST_FOLD_LEFT_203_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_204(o, s, l) BOOST_PP_LIST_FOLD_LEFT_204_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_205(o, s, l) BOOST_PP_LIST_FOLD_LEFT_205_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_206(o, s, l) BOOST_PP_LIST_FOLD_LEFT_206_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_207(o, s, l) BOOST_PP_LIST_FOLD_LEFT_207_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_208(o, s, l) BOOST_PP_LIST_FOLD_LEFT_208_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_209(o, s, l) BOOST_PP_LIST_FOLD_LEFT_209_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_210(o, s, l) BOOST_PP_LIST_FOLD_LEFT_210_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_211(o, s, l) BOOST_PP_LIST_FOLD_LEFT_211_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_212(o, s, l) BOOST_PP_LIST_FOLD_LEFT_212_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_213(o, s, l) BOOST_PP_LIST_FOLD_LEFT_213_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_214(o, s, l) BOOST_PP_LIST_FOLD_LEFT_214_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_215(o, s, l) BOOST_PP_LIST_FOLD_LEFT_215_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_216(o, s, l) BOOST_PP_LIST_FOLD_LEFT_216_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_217(o, s, l) BOOST_PP_LIST_FOLD_LEFT_217_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_218(o, s, l) BOOST_PP_LIST_FOLD_LEFT_218_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_219(o, s, l) BOOST_PP_LIST_FOLD_LEFT_219_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_220(o, s, l) BOOST_PP_LIST_FOLD_LEFT_220_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_221(o, s, l) BOOST_PP_LIST_FOLD_LEFT_221_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_222(o, s, l) BOOST_PP_LIST_FOLD_LEFT_222_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_223(o, s, l) BOOST_PP_LIST_FOLD_LEFT_223_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_224(o, s, l) BOOST_PP_LIST_FOLD_LEFT_224_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_225(o, s, l) BOOST_PP_LIST_FOLD_LEFT_225_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_226(o, s, l) BOOST_PP_LIST_FOLD_LEFT_226_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_227(o, s, l) BOOST_PP_LIST_FOLD_LEFT_227_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_228(o, s, l) BOOST_PP_LIST_FOLD_LEFT_228_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_229(o, s, l) BOOST_PP_LIST_FOLD_LEFT_229_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_230(o, s, l) BOOST_PP_LIST_FOLD_LEFT_230_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_231(o, s, l) BOOST_PP_LIST_FOLD_LEFT_231_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_232(o, s, l) BOOST_PP_LIST_FOLD_LEFT_232_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_233(o, s, l) BOOST_PP_LIST_FOLD_LEFT_233_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_234(o, s, l) BOOST_PP_LIST_FOLD_LEFT_234_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_235(o, s, l) BOOST_PP_LIST_FOLD_LEFT_235_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_236(o, s, l) BOOST_PP_LIST_FOLD_LEFT_236_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_237(o, s, l) BOOST_PP_LIST_FOLD_LEFT_237_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_238(o, s, l) BOOST_PP_LIST_FOLD_LEFT_238_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_239(o, s, l) BOOST_PP_LIST_FOLD_LEFT_239_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_240(o, s, l) BOOST_PP_LIST_FOLD_LEFT_240_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_241(o, s, l) BOOST_PP_LIST_FOLD_LEFT_241_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_242(o, s, l) BOOST_PP_LIST_FOLD_LEFT_242_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_243(o, s, l) BOOST_PP_LIST_FOLD_LEFT_243_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_244(o, s, l) BOOST_PP_LIST_FOLD_LEFT_244_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_245(o, s, l) BOOST_PP_LIST_FOLD_LEFT_245_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_246(o, s, l) BOOST_PP_LIST_FOLD_LEFT_246_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_247(o, s, l) BOOST_PP_LIST_FOLD_LEFT_247_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_248(o, s, l) BOOST_PP_LIST_FOLD_LEFT_248_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_249(o, s, l) BOOST_PP_LIST_FOLD_LEFT_249_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_250(o, s, l) BOOST_PP_LIST_FOLD_LEFT_250_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_251(o, s, l) BOOST_PP_LIST_FOLD_LEFT_251_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_252(o, s, l) BOOST_PP_LIST_FOLD_LEFT_252_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_253(o, s, l) BOOST_PP_LIST_FOLD_LEFT_253_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_254(o, s, l) BOOST_PP_LIST_FOLD_LEFT_254_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_255(o, s, l) BOOST_PP_LIST_FOLD_LEFT_255_D(o, s, l) # define BOOST_PP_LIST_FOLD_LEFT_256(o, s, l) BOOST_PP_LIST_FOLD_LEFT_256_D(o, s, l) # # define BOOST_PP_LIST_FOLD_LEFT_1_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_2, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(2, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_2_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_3, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(3, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_3_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_4, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(4, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_4_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_5, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(5, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_5_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_6, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(6, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_6_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_7, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(7, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_7_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_8, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(8, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_8_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_9, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(9, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_9_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_10, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(10, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_10_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_11, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(11, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_11_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_12, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(12, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_12_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_13, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(13, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_13_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_14, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(14, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_14_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_15, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(15, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_15_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_16, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(16, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_16_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_17, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(17, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_17_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_18, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(18, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_18_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_19, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(19, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_19_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_20, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(20, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_20_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_21, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(21, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_21_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_22, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(22, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_22_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_23, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(23, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_23_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_24, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(24, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_24_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_25, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(25, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_25_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_26, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(26, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_26_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_27, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(27, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_27_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_28, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(28, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_28_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_29, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(29, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_29_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_30, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(30, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_30_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_31, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(31, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_31_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_32, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(32, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_32_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_33, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(33, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_33_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_34, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(34, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_34_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_35, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(35, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_35_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_36, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(36, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_36_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_37, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(37, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_37_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_38, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(38, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_38_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_39, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(39, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_39_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_40, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(40, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_40_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_41, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(41, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_41_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_42, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(42, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_42_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_43, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(43, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_43_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_44, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(44, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_44_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_45, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(45, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_45_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_46, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(46, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_46_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_47, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(47, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_47_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_48, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(48, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_48_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_49, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(49, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_49_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_50, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(50, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_50_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_51, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(51, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_51_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_52, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(52, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_52_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_53, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(53, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_53_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_54, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(54, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_54_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_55, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(55, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_55_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_56, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(56, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_56_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_57, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(57, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_57_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_58, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(58, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_58_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_59, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(59, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_59_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_60, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(60, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_60_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_61, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(61, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_61_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_62, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(62, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_62_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_63, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(63, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_63_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_64, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(64, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_64_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_65, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(65, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_65_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_66, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(66, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_66_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_67, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(67, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_67_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_68, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(68, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_68_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_69, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(69, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_69_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_70, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(70, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_70_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_71, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(71, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_71_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_72, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(72, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_72_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_73, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(73, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_73_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_74, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(74, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_74_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_75, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(75, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_75_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_76, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(76, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_76_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_77, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(77, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_77_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_78, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(78, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_78_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_79, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(79, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_79_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_80, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(80, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_80_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_81, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(81, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_81_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_82, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(82, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_82_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_83, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(83, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_83_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_84, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(84, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_84_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_85, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(85, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_85_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_86, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(86, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_86_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_87, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(87, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_87_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_88, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(88, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_88_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_89, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(89, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_89_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_90, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(90, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_90_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_91, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(91, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_91_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_92, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(92, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_92_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_93, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(93, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_93_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_94, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(94, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_94_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_95, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(95, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_95_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_96, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(96, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_96_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_97, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(97, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_97_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_98, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(98, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_98_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_99, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(99, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_99_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_100, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(100, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_100_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_101, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(101, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_101_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_102, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(102, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_102_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_103, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(103, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_103_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_104, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(104, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_104_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_105, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(105, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_105_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_106, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(106, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_106_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_107, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(107, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_107_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_108, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(108, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_108_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_109, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(109, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_109_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_110, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(110, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_110_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_111, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(111, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_111_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_112, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(112, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_112_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_113, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(113, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_113_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_114, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(114, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_114_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_115, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(115, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_115_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_116, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(116, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_116_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_117, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(117, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_117_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_118, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(118, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_118_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_119, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(119, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_119_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_120, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(120, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_120_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_121, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(121, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_121_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_122, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(122, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_122_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_123, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(123, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_123_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_124, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(124, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_124_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_125, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(125, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_125_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_126, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(126, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_126_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_127, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(127, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_127_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_128, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(128, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_128_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_129, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(129, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_129_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_130, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(130, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_130_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_131, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(131, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_131_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_132, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(132, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_132_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_133, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(133, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_133_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_134, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(134, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_134_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_135, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(135, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_135_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_136, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(136, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_136_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_137, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(137, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_137_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_138, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(138, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_138_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_139, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(139, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_139_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_140, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(140, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_140_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_141, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(141, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_141_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_142, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(142, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_142_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_143, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(143, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_143_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_144, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(144, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_144_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_145, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(145, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_145_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_146, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(146, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_146_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_147, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(147, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_147_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_148, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(148, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_148_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_149, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(149, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_149_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_150, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(150, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_150_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_151, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(151, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_151_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_152, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(152, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_152_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_153, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(153, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_153_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_154, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(154, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_154_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_155, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(155, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_155_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_156, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(156, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_156_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_157, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(157, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_157_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_158, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(158, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_158_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_159, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(159, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_159_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_160, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(160, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_160_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_161, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(161, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_161_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_162, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(162, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_162_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_163, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(163, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_163_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_164, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(164, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_164_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_165, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(165, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_165_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_166, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(166, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_166_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_167, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(167, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_167_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_168, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(168, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_168_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_169, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(169, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_169_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_170, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(170, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_170_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_171, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(171, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_171_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_172, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(172, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_172_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_173, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(173, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_173_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_174, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(174, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_174_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_175, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(175, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_175_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_176, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(176, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_176_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_177, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(177, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_177_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_178, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(178, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_178_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_179, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(179, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_179_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_180, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(180, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_180_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_181, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(181, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_181_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_182, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(182, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_182_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_183, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(183, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_183_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_184, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(184, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_184_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_185, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(185, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_185_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_186, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(186, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_186_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_187, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(187, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_187_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_188, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(188, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_188_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_189, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(189, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_189_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_190, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(190, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_190_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_191, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(191, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_191_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_192, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(192, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_192_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_193, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(193, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_193_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_194, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(194, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_194_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_195, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(195, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_195_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_196, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(196, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_196_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_197, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(197, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_197_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_198, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(198, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_198_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_199, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(199, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_199_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_200, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(200, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_200_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_201, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(201, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_201_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_202, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(202, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_202_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_203, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(203, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_203_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_204, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(204, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_204_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_205, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(205, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_205_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_206, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(206, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_206_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_207, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(207, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_207_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_208, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(208, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_208_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_209, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(209, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_209_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_210, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(210, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_210_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_211, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(211, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_211_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_212, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(212, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_212_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_213, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(213, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_213_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_214, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(214, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_214_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_215, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(215, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_215_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_216, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(216, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_216_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_217, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(217, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_217_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_218, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(218, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_218_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_219, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(219, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_219_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_220, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(220, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_220_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_221, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(221, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_221_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_222, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(222, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_222_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_223, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(223, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_223_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_224, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(224, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_224_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_225, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(225, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_225_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_226, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(226, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_226_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_227, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(227, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_227_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_228, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(228, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_228_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_229, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(229, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_229_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_230, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(230, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_230_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_231, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(231, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_231_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_232, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(232, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_232_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_233, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(233, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_233_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_234, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(234, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_234_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_235, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(235, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_235_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_236, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(236, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_236_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_237, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(237, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_237_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_238, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(238, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_238_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_239, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(239, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_239_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_240, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(240, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_240_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_241, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(241, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_241_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_242, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(242, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_242_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_243, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(243, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_243_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_244, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(244, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_244_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_245, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(245, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_245_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_246, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(246, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_246_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_247, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(247, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_247_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_248, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(248, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_248_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_249, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(249, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_249_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_250, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(250, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_250_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_251, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(251, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_251_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_252, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(252, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_252_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_253, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(253, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_253_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_254, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(254, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_254_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_255, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(255, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_255_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_256, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(256, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # define BOOST_PP_LIST_FOLD_LEFT_256_D(o, s, l) BOOST_PP_IIF(BOOST_PP_LIST_IS_CONS(l), BOOST_PP_LIST_FOLD_LEFT_257, s BOOST_PP_TUPLE_EAT_3)(o, BOOST_PP_EXPR_IIF(BOOST_PP_LIST_IS_CONS(l), o)(257, s, BOOST_PP_LIST_FIRST(l)), BOOST_PP_LIST_REST(l)) # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/0000755000175000017500000000000012146213771031164 5ustar debiandebian././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/slot.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/slo0000644000175000017500000000251411344301502031673 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SLOT_SLOT_HPP # define BOOST_PREPROCESSOR_SLOT_SLOT_HPP # # include # include # # /* BOOST_PP_ASSIGN_SLOT */ # # define BOOST_PP_ASSIGN_SLOT(i) BOOST_PP_CAT(BOOST_PP_ASSIGN_SLOT_, i) # # define BOOST_PP_ASSIGN_SLOT_1 # define BOOST_PP_ASSIGN_SLOT_2 # define BOOST_PP_ASSIGN_SLOT_3 # define BOOST_PP_ASSIGN_SLOT_4 # define BOOST_PP_ASSIGN_SLOT_5 # # /* BOOST_PP_SLOT */ # # define BOOST_PP_SLOT(i) BOOST_PP_CAT(BOOST_PP_SLOT_, i)() # # endif ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000755000175000017500000000000012146213771031661 5ustar debiandebian././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/slot2.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000002415111344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_SLOT_2 # # undef BOOST_PP_SLOT_2_DIGIT_1 # undef BOOST_PP_SLOT_2_DIGIT_2 # undef BOOST_PP_SLOT_2_DIGIT_3 # undef BOOST_PP_SLOT_2_DIGIT_4 # undef BOOST_PP_SLOT_2_DIGIT_5 # undef BOOST_PP_SLOT_2_DIGIT_6 # undef BOOST_PP_SLOT_2_DIGIT_7 # undef BOOST_PP_SLOT_2_DIGIT_8 # undef BOOST_PP_SLOT_2_DIGIT_9 # undef BOOST_PP_SLOT_2_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_10 == 0 # define BOOST_PP_SLOT_2_DIGIT_10 0 # elif BOOST_PP_SLOT_TEMP_10 == 1 # define BOOST_PP_SLOT_2_DIGIT_10 1 # elif BOOST_PP_SLOT_TEMP_10 == 2 # define BOOST_PP_SLOT_2_DIGIT_10 2 # elif BOOST_PP_SLOT_TEMP_10 == 3 # define BOOST_PP_SLOT_2_DIGIT_10 3 # elif BOOST_PP_SLOT_TEMP_10 == 4 # define BOOST_PP_SLOT_2_DIGIT_10 4 # elif BOOST_PP_SLOT_TEMP_10 == 5 # define BOOST_PP_SLOT_2_DIGIT_10 5 # elif BOOST_PP_SLOT_TEMP_10 == 6 # define BOOST_PP_SLOT_2_DIGIT_10 6 # elif BOOST_PP_SLOT_TEMP_10 == 7 # define BOOST_PP_SLOT_2_DIGIT_10 7 # elif BOOST_PP_SLOT_TEMP_10 == 8 # define BOOST_PP_SLOT_2_DIGIT_10 8 # elif BOOST_PP_SLOT_TEMP_10 == 9 # define BOOST_PP_SLOT_2_DIGIT_10 9 # endif # # if BOOST_PP_SLOT_TEMP_9 == 0 # define BOOST_PP_SLOT_2_DIGIT_9 0 # elif BOOST_PP_SLOT_TEMP_9 == 1 # define BOOST_PP_SLOT_2_DIGIT_9 1 # elif BOOST_PP_SLOT_TEMP_9 == 2 # define BOOST_PP_SLOT_2_DIGIT_9 2 # elif BOOST_PP_SLOT_TEMP_9 == 3 # define BOOST_PP_SLOT_2_DIGIT_9 3 # elif BOOST_PP_SLOT_TEMP_9 == 4 # define BOOST_PP_SLOT_2_DIGIT_9 4 # elif BOOST_PP_SLOT_TEMP_9 == 5 # define BOOST_PP_SLOT_2_DIGIT_9 5 # elif BOOST_PP_SLOT_TEMP_9 == 6 # define BOOST_PP_SLOT_2_DIGIT_9 6 # elif BOOST_PP_SLOT_TEMP_9 == 7 # define BOOST_PP_SLOT_2_DIGIT_9 7 # elif BOOST_PP_SLOT_TEMP_9 == 8 # define BOOST_PP_SLOT_2_DIGIT_9 8 # elif BOOST_PP_SLOT_TEMP_9 == 9 # define BOOST_PP_SLOT_2_DIGIT_9 9 # endif # # if BOOST_PP_SLOT_TEMP_8 == 0 # define BOOST_PP_SLOT_2_DIGIT_8 0 # elif BOOST_PP_SLOT_TEMP_8 == 1 # define BOOST_PP_SLOT_2_DIGIT_8 1 # elif BOOST_PP_SLOT_TEMP_8 == 2 # define BOOST_PP_SLOT_2_DIGIT_8 2 # elif BOOST_PP_SLOT_TEMP_8 == 3 # define BOOST_PP_SLOT_2_DIGIT_8 3 # elif BOOST_PP_SLOT_TEMP_8 == 4 # define BOOST_PP_SLOT_2_DIGIT_8 4 # elif BOOST_PP_SLOT_TEMP_8 == 5 # define BOOST_PP_SLOT_2_DIGIT_8 5 # elif BOOST_PP_SLOT_TEMP_8 == 6 # define BOOST_PP_SLOT_2_DIGIT_8 6 # elif BOOST_PP_SLOT_TEMP_8 == 7 # define BOOST_PP_SLOT_2_DIGIT_8 7 # elif BOOST_PP_SLOT_TEMP_8 == 8 # define BOOST_PP_SLOT_2_DIGIT_8 8 # elif BOOST_PP_SLOT_TEMP_8 == 9 # define BOOST_PP_SLOT_2_DIGIT_8 9 # endif # # if BOOST_PP_SLOT_TEMP_7 == 0 # define BOOST_PP_SLOT_2_DIGIT_7 0 # elif BOOST_PP_SLOT_TEMP_7 == 1 # define BOOST_PP_SLOT_2_DIGIT_7 1 # elif BOOST_PP_SLOT_TEMP_7 == 2 # define BOOST_PP_SLOT_2_DIGIT_7 2 # elif BOOST_PP_SLOT_TEMP_7 == 3 # define BOOST_PP_SLOT_2_DIGIT_7 3 # elif BOOST_PP_SLOT_TEMP_7 == 4 # define BOOST_PP_SLOT_2_DIGIT_7 4 # elif BOOST_PP_SLOT_TEMP_7 == 5 # define BOOST_PP_SLOT_2_DIGIT_7 5 # elif BOOST_PP_SLOT_TEMP_7 == 6 # define BOOST_PP_SLOT_2_DIGIT_7 6 # elif BOOST_PP_SLOT_TEMP_7 == 7 # define BOOST_PP_SLOT_2_DIGIT_7 7 # elif BOOST_PP_SLOT_TEMP_7 == 8 # define BOOST_PP_SLOT_2_DIGIT_7 8 # elif BOOST_PP_SLOT_TEMP_7 == 9 # define BOOST_PP_SLOT_2_DIGIT_7 9 # endif # # if BOOST_PP_SLOT_TEMP_6 == 0 # define BOOST_PP_SLOT_2_DIGIT_6 0 # elif BOOST_PP_SLOT_TEMP_6 == 1 # define BOOST_PP_SLOT_2_DIGIT_6 1 # elif BOOST_PP_SLOT_TEMP_6 == 2 # define BOOST_PP_SLOT_2_DIGIT_6 2 # elif BOOST_PP_SLOT_TEMP_6 == 3 # define BOOST_PP_SLOT_2_DIGIT_6 3 # elif BOOST_PP_SLOT_TEMP_6 == 4 # define BOOST_PP_SLOT_2_DIGIT_6 4 # elif BOOST_PP_SLOT_TEMP_6 == 5 # define BOOST_PP_SLOT_2_DIGIT_6 5 # elif BOOST_PP_SLOT_TEMP_6 == 6 # define BOOST_PP_SLOT_2_DIGIT_6 6 # elif BOOST_PP_SLOT_TEMP_6 == 7 # define BOOST_PP_SLOT_2_DIGIT_6 7 # elif BOOST_PP_SLOT_TEMP_6 == 8 # define BOOST_PP_SLOT_2_DIGIT_6 8 # elif BOOST_PP_SLOT_TEMP_6 == 9 # define BOOST_PP_SLOT_2_DIGIT_6 9 # endif # # if BOOST_PP_SLOT_TEMP_5 == 0 # define BOOST_PP_SLOT_2_DIGIT_5 0 # elif BOOST_PP_SLOT_TEMP_5 == 1 # define BOOST_PP_SLOT_2_DIGIT_5 1 # elif BOOST_PP_SLOT_TEMP_5 == 2 # define BOOST_PP_SLOT_2_DIGIT_5 2 # elif BOOST_PP_SLOT_TEMP_5 == 3 # define BOOST_PP_SLOT_2_DIGIT_5 3 # elif BOOST_PP_SLOT_TEMP_5 == 4 # define BOOST_PP_SLOT_2_DIGIT_5 4 # elif BOOST_PP_SLOT_TEMP_5 == 5 # define BOOST_PP_SLOT_2_DIGIT_5 5 # elif BOOST_PP_SLOT_TEMP_5 == 6 # define BOOST_PP_SLOT_2_DIGIT_5 6 # elif BOOST_PP_SLOT_TEMP_5 == 7 # define BOOST_PP_SLOT_2_DIGIT_5 7 # elif BOOST_PP_SLOT_TEMP_5 == 8 # define BOOST_PP_SLOT_2_DIGIT_5 8 # elif BOOST_PP_SLOT_TEMP_5 == 9 # define BOOST_PP_SLOT_2_DIGIT_5 9 # endif # # if BOOST_PP_SLOT_TEMP_4 == 0 # define BOOST_PP_SLOT_2_DIGIT_4 0 # elif BOOST_PP_SLOT_TEMP_4 == 1 # define BOOST_PP_SLOT_2_DIGIT_4 1 # elif BOOST_PP_SLOT_TEMP_4 == 2 # define BOOST_PP_SLOT_2_DIGIT_4 2 # elif BOOST_PP_SLOT_TEMP_4 == 3 # define BOOST_PP_SLOT_2_DIGIT_4 3 # elif BOOST_PP_SLOT_TEMP_4 == 4 # define BOOST_PP_SLOT_2_DIGIT_4 4 # elif BOOST_PP_SLOT_TEMP_4 == 5 # define BOOST_PP_SLOT_2_DIGIT_4 5 # elif BOOST_PP_SLOT_TEMP_4 == 6 # define BOOST_PP_SLOT_2_DIGIT_4 6 # elif BOOST_PP_SLOT_TEMP_4 == 7 # define BOOST_PP_SLOT_2_DIGIT_4 7 # elif BOOST_PP_SLOT_TEMP_4 == 8 # define BOOST_PP_SLOT_2_DIGIT_4 8 # elif BOOST_PP_SLOT_TEMP_4 == 9 # define BOOST_PP_SLOT_2_DIGIT_4 9 # endif # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_SLOT_2_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_SLOT_2_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_SLOT_2_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_SLOT_2_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_SLOT_2_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_SLOT_2_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_SLOT_2_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_SLOT_2_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_SLOT_2_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_SLOT_2_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_SLOT_2_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_SLOT_2_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_SLOT_2_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_SLOT_2_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_SLOT_2_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_SLOT_2_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_SLOT_2_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_SLOT_2_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_SLOT_2_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_SLOT_2_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_SLOT_2_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_SLOT_2_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_SLOT_2_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_SLOT_2_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_SLOT_2_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_SLOT_2_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_SLOT_2_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_SLOT_2_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_SLOT_2_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_SLOT_2_DIGIT_1 9 # endif # # if BOOST_PP_SLOT_2_DIGIT_10 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_10(BOOST_PP_SLOT_2_DIGIT_10, BOOST_PP_SLOT_2_DIGIT_9, BOOST_PP_SLOT_2_DIGIT_8, BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_9 # define BOOST_PP_SLOT_2 BOOST_PP_SLOT_CC_9(BOOST_PP_SLOT_2_DIGIT_9, BOOST_PP_SLOT_2_DIGIT_8, BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_8 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_8(BOOST_PP_SLOT_2_DIGIT_8, BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_7 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_7(BOOST_PP_SLOT_2_DIGIT_7, BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_6 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_6(BOOST_PP_SLOT_2_DIGIT_6, BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_5 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_5(BOOST_PP_SLOT_2_DIGIT_5, BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_4 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_4(BOOST_PP_SLOT_2_DIGIT_4, BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_3 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_3(BOOST_PP_SLOT_2_DIGIT_3, BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # elif BOOST_PP_SLOT_2_DIGIT_2 # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_CC_2(BOOST_PP_SLOT_2_DIGIT_2, BOOST_PP_SLOT_2_DIGIT_1) # else # define BOOST_PP_SLOT_2() BOOST_PP_SLOT_2_DIGIT_1 # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/slot5.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000002415111344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_SLOT_5 # # undef BOOST_PP_SLOT_5_DIGIT_1 # undef BOOST_PP_SLOT_5_DIGIT_2 # undef BOOST_PP_SLOT_5_DIGIT_3 # undef BOOST_PP_SLOT_5_DIGIT_4 # undef BOOST_PP_SLOT_5_DIGIT_5 # undef BOOST_PP_SLOT_5_DIGIT_6 # undef BOOST_PP_SLOT_5_DIGIT_7 # undef BOOST_PP_SLOT_5_DIGIT_8 # undef BOOST_PP_SLOT_5_DIGIT_9 # undef BOOST_PP_SLOT_5_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_10 == 0 # define BOOST_PP_SLOT_5_DIGIT_10 0 # elif BOOST_PP_SLOT_TEMP_10 == 1 # define BOOST_PP_SLOT_5_DIGIT_10 1 # elif BOOST_PP_SLOT_TEMP_10 == 2 # define BOOST_PP_SLOT_5_DIGIT_10 2 # elif BOOST_PP_SLOT_TEMP_10 == 3 # define BOOST_PP_SLOT_5_DIGIT_10 3 # elif BOOST_PP_SLOT_TEMP_10 == 4 # define BOOST_PP_SLOT_5_DIGIT_10 4 # elif BOOST_PP_SLOT_TEMP_10 == 5 # define BOOST_PP_SLOT_5_DIGIT_10 5 # elif BOOST_PP_SLOT_TEMP_10 == 6 # define BOOST_PP_SLOT_5_DIGIT_10 6 # elif BOOST_PP_SLOT_TEMP_10 == 7 # define BOOST_PP_SLOT_5_DIGIT_10 7 # elif BOOST_PP_SLOT_TEMP_10 == 8 # define BOOST_PP_SLOT_5_DIGIT_10 8 # elif BOOST_PP_SLOT_TEMP_10 == 9 # define BOOST_PP_SLOT_5_DIGIT_10 9 # endif # # if BOOST_PP_SLOT_TEMP_9 == 0 # define BOOST_PP_SLOT_5_DIGIT_9 0 # elif BOOST_PP_SLOT_TEMP_9 == 1 # define BOOST_PP_SLOT_5_DIGIT_9 1 # elif BOOST_PP_SLOT_TEMP_9 == 2 # define BOOST_PP_SLOT_5_DIGIT_9 2 # elif BOOST_PP_SLOT_TEMP_9 == 3 # define BOOST_PP_SLOT_5_DIGIT_9 3 # elif BOOST_PP_SLOT_TEMP_9 == 4 # define BOOST_PP_SLOT_5_DIGIT_9 4 # elif BOOST_PP_SLOT_TEMP_9 == 5 # define BOOST_PP_SLOT_5_DIGIT_9 5 # elif BOOST_PP_SLOT_TEMP_9 == 6 # define BOOST_PP_SLOT_5_DIGIT_9 6 # elif BOOST_PP_SLOT_TEMP_9 == 7 # define BOOST_PP_SLOT_5_DIGIT_9 7 # elif BOOST_PP_SLOT_TEMP_9 == 8 # define BOOST_PP_SLOT_5_DIGIT_9 8 # elif BOOST_PP_SLOT_TEMP_9 == 9 # define BOOST_PP_SLOT_5_DIGIT_9 9 # endif # # if BOOST_PP_SLOT_TEMP_8 == 0 # define BOOST_PP_SLOT_5_DIGIT_8 0 # elif BOOST_PP_SLOT_TEMP_8 == 1 # define BOOST_PP_SLOT_5_DIGIT_8 1 # elif BOOST_PP_SLOT_TEMP_8 == 2 # define BOOST_PP_SLOT_5_DIGIT_8 2 # elif BOOST_PP_SLOT_TEMP_8 == 3 # define BOOST_PP_SLOT_5_DIGIT_8 3 # elif BOOST_PP_SLOT_TEMP_8 == 4 # define BOOST_PP_SLOT_5_DIGIT_8 4 # elif BOOST_PP_SLOT_TEMP_8 == 5 # define BOOST_PP_SLOT_5_DIGIT_8 5 # elif BOOST_PP_SLOT_TEMP_8 == 6 # define BOOST_PP_SLOT_5_DIGIT_8 6 # elif BOOST_PP_SLOT_TEMP_8 == 7 # define BOOST_PP_SLOT_5_DIGIT_8 7 # elif BOOST_PP_SLOT_TEMP_8 == 8 # define BOOST_PP_SLOT_5_DIGIT_8 8 # elif BOOST_PP_SLOT_TEMP_8 == 9 # define BOOST_PP_SLOT_5_DIGIT_8 9 # endif # # if BOOST_PP_SLOT_TEMP_7 == 0 # define BOOST_PP_SLOT_5_DIGIT_7 0 # elif BOOST_PP_SLOT_TEMP_7 == 1 # define BOOST_PP_SLOT_5_DIGIT_7 1 # elif BOOST_PP_SLOT_TEMP_7 == 2 # define BOOST_PP_SLOT_5_DIGIT_7 2 # elif BOOST_PP_SLOT_TEMP_7 == 3 # define BOOST_PP_SLOT_5_DIGIT_7 3 # elif BOOST_PP_SLOT_TEMP_7 == 4 # define BOOST_PP_SLOT_5_DIGIT_7 4 # elif BOOST_PP_SLOT_TEMP_7 == 5 # define BOOST_PP_SLOT_5_DIGIT_7 5 # elif BOOST_PP_SLOT_TEMP_7 == 6 # define BOOST_PP_SLOT_5_DIGIT_7 6 # elif BOOST_PP_SLOT_TEMP_7 == 7 # define BOOST_PP_SLOT_5_DIGIT_7 7 # elif BOOST_PP_SLOT_TEMP_7 == 8 # define BOOST_PP_SLOT_5_DIGIT_7 8 # elif BOOST_PP_SLOT_TEMP_7 == 9 # define BOOST_PP_SLOT_5_DIGIT_7 9 # endif # # if BOOST_PP_SLOT_TEMP_6 == 0 # define BOOST_PP_SLOT_5_DIGIT_6 0 # elif BOOST_PP_SLOT_TEMP_6 == 1 # define BOOST_PP_SLOT_5_DIGIT_6 1 # elif BOOST_PP_SLOT_TEMP_6 == 2 # define BOOST_PP_SLOT_5_DIGIT_6 2 # elif BOOST_PP_SLOT_TEMP_6 == 3 # define BOOST_PP_SLOT_5_DIGIT_6 3 # elif BOOST_PP_SLOT_TEMP_6 == 4 # define BOOST_PP_SLOT_5_DIGIT_6 4 # elif BOOST_PP_SLOT_TEMP_6 == 5 # define BOOST_PP_SLOT_5_DIGIT_6 5 # elif BOOST_PP_SLOT_TEMP_6 == 6 # define BOOST_PP_SLOT_5_DIGIT_6 6 # elif BOOST_PP_SLOT_TEMP_6 == 7 # define BOOST_PP_SLOT_5_DIGIT_6 7 # elif BOOST_PP_SLOT_TEMP_6 == 8 # define BOOST_PP_SLOT_5_DIGIT_6 8 # elif BOOST_PP_SLOT_TEMP_6 == 9 # define BOOST_PP_SLOT_5_DIGIT_6 9 # endif # # if BOOST_PP_SLOT_TEMP_5 == 0 # define BOOST_PP_SLOT_5_DIGIT_5 0 # elif BOOST_PP_SLOT_TEMP_5 == 1 # define BOOST_PP_SLOT_5_DIGIT_5 1 # elif BOOST_PP_SLOT_TEMP_5 == 2 # define BOOST_PP_SLOT_5_DIGIT_5 2 # elif BOOST_PP_SLOT_TEMP_5 == 3 # define BOOST_PP_SLOT_5_DIGIT_5 3 # elif BOOST_PP_SLOT_TEMP_5 == 4 # define BOOST_PP_SLOT_5_DIGIT_5 4 # elif BOOST_PP_SLOT_TEMP_5 == 5 # define BOOST_PP_SLOT_5_DIGIT_5 5 # elif BOOST_PP_SLOT_TEMP_5 == 6 # define BOOST_PP_SLOT_5_DIGIT_5 6 # elif BOOST_PP_SLOT_TEMP_5 == 7 # define BOOST_PP_SLOT_5_DIGIT_5 7 # elif BOOST_PP_SLOT_TEMP_5 == 8 # define BOOST_PP_SLOT_5_DIGIT_5 8 # elif BOOST_PP_SLOT_TEMP_5 == 9 # define BOOST_PP_SLOT_5_DIGIT_5 9 # endif # # if BOOST_PP_SLOT_TEMP_4 == 0 # define BOOST_PP_SLOT_5_DIGIT_4 0 # elif BOOST_PP_SLOT_TEMP_4 == 1 # define BOOST_PP_SLOT_5_DIGIT_4 1 # elif BOOST_PP_SLOT_TEMP_4 == 2 # define BOOST_PP_SLOT_5_DIGIT_4 2 # elif BOOST_PP_SLOT_TEMP_4 == 3 # define BOOST_PP_SLOT_5_DIGIT_4 3 # elif BOOST_PP_SLOT_TEMP_4 == 4 # define BOOST_PP_SLOT_5_DIGIT_4 4 # elif BOOST_PP_SLOT_TEMP_4 == 5 # define BOOST_PP_SLOT_5_DIGIT_4 5 # elif BOOST_PP_SLOT_TEMP_4 == 6 # define BOOST_PP_SLOT_5_DIGIT_4 6 # elif BOOST_PP_SLOT_TEMP_4 == 7 # define BOOST_PP_SLOT_5_DIGIT_4 7 # elif BOOST_PP_SLOT_TEMP_4 == 8 # define BOOST_PP_SLOT_5_DIGIT_4 8 # elif BOOST_PP_SLOT_TEMP_4 == 9 # define BOOST_PP_SLOT_5_DIGIT_4 9 # endif # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_SLOT_5_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_SLOT_5_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_SLOT_5_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_SLOT_5_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_SLOT_5_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_SLOT_5_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_SLOT_5_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_SLOT_5_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_SLOT_5_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_SLOT_5_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_SLOT_5_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_SLOT_5_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_SLOT_5_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_SLOT_5_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_SLOT_5_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_SLOT_5_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_SLOT_5_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_SLOT_5_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_SLOT_5_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_SLOT_5_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_SLOT_5_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_SLOT_5_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_SLOT_5_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_SLOT_5_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_SLOT_5_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_SLOT_5_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_SLOT_5_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_SLOT_5_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_SLOT_5_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_SLOT_5_DIGIT_1 9 # endif # # if BOOST_PP_SLOT_5_DIGIT_10 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_10(BOOST_PP_SLOT_5_DIGIT_10, BOOST_PP_SLOT_5_DIGIT_9, BOOST_PP_SLOT_5_DIGIT_8, BOOST_PP_SLOT_5_DIGIT_7, BOOST_PP_SLOT_5_DIGIT_6, BOOST_PP_SLOT_5_DIGIT_5, BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_9 # define BOOST_PP_SLOT_5 BOOST_PP_SLOT_CC_9(BOOST_PP_SLOT_5_DIGIT_9, BOOST_PP_SLOT_5_DIGIT_8, BOOST_PP_SLOT_5_DIGIT_7, BOOST_PP_SLOT_5_DIGIT_6, BOOST_PP_SLOT_5_DIGIT_5, BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_8 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_8(BOOST_PP_SLOT_5_DIGIT_8, BOOST_PP_SLOT_5_DIGIT_7, BOOST_PP_SLOT_5_DIGIT_6, BOOST_PP_SLOT_5_DIGIT_5, BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_7 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_7(BOOST_PP_SLOT_5_DIGIT_7, BOOST_PP_SLOT_5_DIGIT_6, BOOST_PP_SLOT_5_DIGIT_5, BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_6 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_6(BOOST_PP_SLOT_5_DIGIT_6, BOOST_PP_SLOT_5_DIGIT_5, BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_5 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_5(BOOST_PP_SLOT_5_DIGIT_5, BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_4 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_4(BOOST_PP_SLOT_5_DIGIT_4, BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_3 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_3(BOOST_PP_SLOT_5_DIGIT_3, BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # elif BOOST_PP_SLOT_5_DIGIT_2 # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_CC_2(BOOST_PP_SLOT_5_DIGIT_2, BOOST_PP_SLOT_5_DIGIT_1) # else # define BOOST_PP_SLOT_5() BOOST_PP_SLOT_5_DIGIT_1 # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/slot3.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000002415111344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_SLOT_3 # # undef BOOST_PP_SLOT_3_DIGIT_1 # undef BOOST_PP_SLOT_3_DIGIT_2 # undef BOOST_PP_SLOT_3_DIGIT_3 # undef BOOST_PP_SLOT_3_DIGIT_4 # undef BOOST_PP_SLOT_3_DIGIT_5 # undef BOOST_PP_SLOT_3_DIGIT_6 # undef BOOST_PP_SLOT_3_DIGIT_7 # undef BOOST_PP_SLOT_3_DIGIT_8 # undef BOOST_PP_SLOT_3_DIGIT_9 # undef BOOST_PP_SLOT_3_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_10 == 0 # define BOOST_PP_SLOT_3_DIGIT_10 0 # elif BOOST_PP_SLOT_TEMP_10 == 1 # define BOOST_PP_SLOT_3_DIGIT_10 1 # elif BOOST_PP_SLOT_TEMP_10 == 2 # define BOOST_PP_SLOT_3_DIGIT_10 2 # elif BOOST_PP_SLOT_TEMP_10 == 3 # define BOOST_PP_SLOT_3_DIGIT_10 3 # elif BOOST_PP_SLOT_TEMP_10 == 4 # define BOOST_PP_SLOT_3_DIGIT_10 4 # elif BOOST_PP_SLOT_TEMP_10 == 5 # define BOOST_PP_SLOT_3_DIGIT_10 5 # elif BOOST_PP_SLOT_TEMP_10 == 6 # define BOOST_PP_SLOT_3_DIGIT_10 6 # elif BOOST_PP_SLOT_TEMP_10 == 7 # define BOOST_PP_SLOT_3_DIGIT_10 7 # elif BOOST_PP_SLOT_TEMP_10 == 8 # define BOOST_PP_SLOT_3_DIGIT_10 8 # elif BOOST_PP_SLOT_TEMP_10 == 9 # define BOOST_PP_SLOT_3_DIGIT_10 9 # endif # # if BOOST_PP_SLOT_TEMP_9 == 0 # define BOOST_PP_SLOT_3_DIGIT_9 0 # elif BOOST_PP_SLOT_TEMP_9 == 1 # define BOOST_PP_SLOT_3_DIGIT_9 1 # elif BOOST_PP_SLOT_TEMP_9 == 2 # define BOOST_PP_SLOT_3_DIGIT_9 2 # elif BOOST_PP_SLOT_TEMP_9 == 3 # define BOOST_PP_SLOT_3_DIGIT_9 3 # elif BOOST_PP_SLOT_TEMP_9 == 4 # define BOOST_PP_SLOT_3_DIGIT_9 4 # elif BOOST_PP_SLOT_TEMP_9 == 5 # define BOOST_PP_SLOT_3_DIGIT_9 5 # elif BOOST_PP_SLOT_TEMP_9 == 6 # define BOOST_PP_SLOT_3_DIGIT_9 6 # elif BOOST_PP_SLOT_TEMP_9 == 7 # define BOOST_PP_SLOT_3_DIGIT_9 7 # elif BOOST_PP_SLOT_TEMP_9 == 8 # define BOOST_PP_SLOT_3_DIGIT_9 8 # elif BOOST_PP_SLOT_TEMP_9 == 9 # define BOOST_PP_SLOT_3_DIGIT_9 9 # endif # # if BOOST_PP_SLOT_TEMP_8 == 0 # define BOOST_PP_SLOT_3_DIGIT_8 0 # elif BOOST_PP_SLOT_TEMP_8 == 1 # define BOOST_PP_SLOT_3_DIGIT_8 1 # elif BOOST_PP_SLOT_TEMP_8 == 2 # define BOOST_PP_SLOT_3_DIGIT_8 2 # elif BOOST_PP_SLOT_TEMP_8 == 3 # define BOOST_PP_SLOT_3_DIGIT_8 3 # elif BOOST_PP_SLOT_TEMP_8 == 4 # define BOOST_PP_SLOT_3_DIGIT_8 4 # elif BOOST_PP_SLOT_TEMP_8 == 5 # define BOOST_PP_SLOT_3_DIGIT_8 5 # elif BOOST_PP_SLOT_TEMP_8 == 6 # define BOOST_PP_SLOT_3_DIGIT_8 6 # elif BOOST_PP_SLOT_TEMP_8 == 7 # define BOOST_PP_SLOT_3_DIGIT_8 7 # elif BOOST_PP_SLOT_TEMP_8 == 8 # define BOOST_PP_SLOT_3_DIGIT_8 8 # elif BOOST_PP_SLOT_TEMP_8 == 9 # define BOOST_PP_SLOT_3_DIGIT_8 9 # endif # # if BOOST_PP_SLOT_TEMP_7 == 0 # define BOOST_PP_SLOT_3_DIGIT_7 0 # elif BOOST_PP_SLOT_TEMP_7 == 1 # define BOOST_PP_SLOT_3_DIGIT_7 1 # elif BOOST_PP_SLOT_TEMP_7 == 2 # define BOOST_PP_SLOT_3_DIGIT_7 2 # elif BOOST_PP_SLOT_TEMP_7 == 3 # define BOOST_PP_SLOT_3_DIGIT_7 3 # elif BOOST_PP_SLOT_TEMP_7 == 4 # define BOOST_PP_SLOT_3_DIGIT_7 4 # elif BOOST_PP_SLOT_TEMP_7 == 5 # define BOOST_PP_SLOT_3_DIGIT_7 5 # elif BOOST_PP_SLOT_TEMP_7 == 6 # define BOOST_PP_SLOT_3_DIGIT_7 6 # elif BOOST_PP_SLOT_TEMP_7 == 7 # define BOOST_PP_SLOT_3_DIGIT_7 7 # elif BOOST_PP_SLOT_TEMP_7 == 8 # define BOOST_PP_SLOT_3_DIGIT_7 8 # elif BOOST_PP_SLOT_TEMP_7 == 9 # define BOOST_PP_SLOT_3_DIGIT_7 9 # endif # # if BOOST_PP_SLOT_TEMP_6 == 0 # define BOOST_PP_SLOT_3_DIGIT_6 0 # elif BOOST_PP_SLOT_TEMP_6 == 1 # define BOOST_PP_SLOT_3_DIGIT_6 1 # elif BOOST_PP_SLOT_TEMP_6 == 2 # define BOOST_PP_SLOT_3_DIGIT_6 2 # elif BOOST_PP_SLOT_TEMP_6 == 3 # define BOOST_PP_SLOT_3_DIGIT_6 3 # elif BOOST_PP_SLOT_TEMP_6 == 4 # define BOOST_PP_SLOT_3_DIGIT_6 4 # elif BOOST_PP_SLOT_TEMP_6 == 5 # define BOOST_PP_SLOT_3_DIGIT_6 5 # elif BOOST_PP_SLOT_TEMP_6 == 6 # define BOOST_PP_SLOT_3_DIGIT_6 6 # elif BOOST_PP_SLOT_TEMP_6 == 7 # define BOOST_PP_SLOT_3_DIGIT_6 7 # elif BOOST_PP_SLOT_TEMP_6 == 8 # define BOOST_PP_SLOT_3_DIGIT_6 8 # elif BOOST_PP_SLOT_TEMP_6 == 9 # define BOOST_PP_SLOT_3_DIGIT_6 9 # endif # # if BOOST_PP_SLOT_TEMP_5 == 0 # define BOOST_PP_SLOT_3_DIGIT_5 0 # elif BOOST_PP_SLOT_TEMP_5 == 1 # define BOOST_PP_SLOT_3_DIGIT_5 1 # elif BOOST_PP_SLOT_TEMP_5 == 2 # define BOOST_PP_SLOT_3_DIGIT_5 2 # elif BOOST_PP_SLOT_TEMP_5 == 3 # define BOOST_PP_SLOT_3_DIGIT_5 3 # elif BOOST_PP_SLOT_TEMP_5 == 4 # define BOOST_PP_SLOT_3_DIGIT_5 4 # elif BOOST_PP_SLOT_TEMP_5 == 5 # define BOOST_PP_SLOT_3_DIGIT_5 5 # elif BOOST_PP_SLOT_TEMP_5 == 6 # define BOOST_PP_SLOT_3_DIGIT_5 6 # elif BOOST_PP_SLOT_TEMP_5 == 7 # define BOOST_PP_SLOT_3_DIGIT_5 7 # elif BOOST_PP_SLOT_TEMP_5 == 8 # define BOOST_PP_SLOT_3_DIGIT_5 8 # elif BOOST_PP_SLOT_TEMP_5 == 9 # define BOOST_PP_SLOT_3_DIGIT_5 9 # endif # # if BOOST_PP_SLOT_TEMP_4 == 0 # define BOOST_PP_SLOT_3_DIGIT_4 0 # elif BOOST_PP_SLOT_TEMP_4 == 1 # define BOOST_PP_SLOT_3_DIGIT_4 1 # elif BOOST_PP_SLOT_TEMP_4 == 2 # define BOOST_PP_SLOT_3_DIGIT_4 2 # elif BOOST_PP_SLOT_TEMP_4 == 3 # define BOOST_PP_SLOT_3_DIGIT_4 3 # elif BOOST_PP_SLOT_TEMP_4 == 4 # define BOOST_PP_SLOT_3_DIGIT_4 4 # elif BOOST_PP_SLOT_TEMP_4 == 5 # define BOOST_PP_SLOT_3_DIGIT_4 5 # elif BOOST_PP_SLOT_TEMP_4 == 6 # define BOOST_PP_SLOT_3_DIGIT_4 6 # elif BOOST_PP_SLOT_TEMP_4 == 7 # define BOOST_PP_SLOT_3_DIGIT_4 7 # elif BOOST_PP_SLOT_TEMP_4 == 8 # define BOOST_PP_SLOT_3_DIGIT_4 8 # elif BOOST_PP_SLOT_TEMP_4 == 9 # define BOOST_PP_SLOT_3_DIGIT_4 9 # endif # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_SLOT_3_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_SLOT_3_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_SLOT_3_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_SLOT_3_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_SLOT_3_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_SLOT_3_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_SLOT_3_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_SLOT_3_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_SLOT_3_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_SLOT_3_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_SLOT_3_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_SLOT_3_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_SLOT_3_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_SLOT_3_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_SLOT_3_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_SLOT_3_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_SLOT_3_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_SLOT_3_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_SLOT_3_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_SLOT_3_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_SLOT_3_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_SLOT_3_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_SLOT_3_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_SLOT_3_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_SLOT_3_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_SLOT_3_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_SLOT_3_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_SLOT_3_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_SLOT_3_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_SLOT_3_DIGIT_1 9 # endif # # if BOOST_PP_SLOT_3_DIGIT_10 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_10(BOOST_PP_SLOT_3_DIGIT_10, BOOST_PP_SLOT_3_DIGIT_9, BOOST_PP_SLOT_3_DIGIT_8, BOOST_PP_SLOT_3_DIGIT_7, BOOST_PP_SLOT_3_DIGIT_6, BOOST_PP_SLOT_3_DIGIT_5, BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_9 # define BOOST_PP_SLOT_3 BOOST_PP_SLOT_CC_9(BOOST_PP_SLOT_3_DIGIT_9, BOOST_PP_SLOT_3_DIGIT_8, BOOST_PP_SLOT_3_DIGIT_7, BOOST_PP_SLOT_3_DIGIT_6, BOOST_PP_SLOT_3_DIGIT_5, BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_8 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_8(BOOST_PP_SLOT_3_DIGIT_8, BOOST_PP_SLOT_3_DIGIT_7, BOOST_PP_SLOT_3_DIGIT_6, BOOST_PP_SLOT_3_DIGIT_5, BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_7 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_7(BOOST_PP_SLOT_3_DIGIT_7, BOOST_PP_SLOT_3_DIGIT_6, BOOST_PP_SLOT_3_DIGIT_5, BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_6 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_6(BOOST_PP_SLOT_3_DIGIT_6, BOOST_PP_SLOT_3_DIGIT_5, BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_5 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_5(BOOST_PP_SLOT_3_DIGIT_5, BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_4 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_4(BOOST_PP_SLOT_3_DIGIT_4, BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_3 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_3(BOOST_PP_SLOT_3_DIGIT_3, BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # elif BOOST_PP_SLOT_3_DIGIT_2 # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_CC_2(BOOST_PP_SLOT_3_DIGIT_2, BOOST_PP_SLOT_3_DIGIT_1) # else # define BOOST_PP_SLOT_3() BOOST_PP_SLOT_3_DIGIT_1 # endif ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/slot1.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000002415111344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_SLOT_1 # # undef BOOST_PP_SLOT_1_DIGIT_1 # undef BOOST_PP_SLOT_1_DIGIT_2 # undef BOOST_PP_SLOT_1_DIGIT_3 # undef BOOST_PP_SLOT_1_DIGIT_4 # undef BOOST_PP_SLOT_1_DIGIT_5 # undef BOOST_PP_SLOT_1_DIGIT_6 # undef BOOST_PP_SLOT_1_DIGIT_7 # undef BOOST_PP_SLOT_1_DIGIT_8 # undef BOOST_PP_SLOT_1_DIGIT_9 # undef BOOST_PP_SLOT_1_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_10 == 0 # define BOOST_PP_SLOT_1_DIGIT_10 0 # elif BOOST_PP_SLOT_TEMP_10 == 1 # define BOOST_PP_SLOT_1_DIGIT_10 1 # elif BOOST_PP_SLOT_TEMP_10 == 2 # define BOOST_PP_SLOT_1_DIGIT_10 2 # elif BOOST_PP_SLOT_TEMP_10 == 3 # define BOOST_PP_SLOT_1_DIGIT_10 3 # elif BOOST_PP_SLOT_TEMP_10 == 4 # define BOOST_PP_SLOT_1_DIGIT_10 4 # elif BOOST_PP_SLOT_TEMP_10 == 5 # define BOOST_PP_SLOT_1_DIGIT_10 5 # elif BOOST_PP_SLOT_TEMP_10 == 6 # define BOOST_PP_SLOT_1_DIGIT_10 6 # elif BOOST_PP_SLOT_TEMP_10 == 7 # define BOOST_PP_SLOT_1_DIGIT_10 7 # elif BOOST_PP_SLOT_TEMP_10 == 8 # define BOOST_PP_SLOT_1_DIGIT_10 8 # elif BOOST_PP_SLOT_TEMP_10 == 9 # define BOOST_PP_SLOT_1_DIGIT_10 9 # endif # # if BOOST_PP_SLOT_TEMP_9 == 0 # define BOOST_PP_SLOT_1_DIGIT_9 0 # elif BOOST_PP_SLOT_TEMP_9 == 1 # define BOOST_PP_SLOT_1_DIGIT_9 1 # elif BOOST_PP_SLOT_TEMP_9 == 2 # define BOOST_PP_SLOT_1_DIGIT_9 2 # elif BOOST_PP_SLOT_TEMP_9 == 3 # define BOOST_PP_SLOT_1_DIGIT_9 3 # elif BOOST_PP_SLOT_TEMP_9 == 4 # define BOOST_PP_SLOT_1_DIGIT_9 4 # elif BOOST_PP_SLOT_TEMP_9 == 5 # define BOOST_PP_SLOT_1_DIGIT_9 5 # elif BOOST_PP_SLOT_TEMP_9 == 6 # define BOOST_PP_SLOT_1_DIGIT_9 6 # elif BOOST_PP_SLOT_TEMP_9 == 7 # define BOOST_PP_SLOT_1_DIGIT_9 7 # elif BOOST_PP_SLOT_TEMP_9 == 8 # define BOOST_PP_SLOT_1_DIGIT_9 8 # elif BOOST_PP_SLOT_TEMP_9 == 9 # define BOOST_PP_SLOT_1_DIGIT_9 9 # endif # # if BOOST_PP_SLOT_TEMP_8 == 0 # define BOOST_PP_SLOT_1_DIGIT_8 0 # elif BOOST_PP_SLOT_TEMP_8 == 1 # define BOOST_PP_SLOT_1_DIGIT_8 1 # elif BOOST_PP_SLOT_TEMP_8 == 2 # define BOOST_PP_SLOT_1_DIGIT_8 2 # elif BOOST_PP_SLOT_TEMP_8 == 3 # define BOOST_PP_SLOT_1_DIGIT_8 3 # elif BOOST_PP_SLOT_TEMP_8 == 4 # define BOOST_PP_SLOT_1_DIGIT_8 4 # elif BOOST_PP_SLOT_TEMP_8 == 5 # define BOOST_PP_SLOT_1_DIGIT_8 5 # elif BOOST_PP_SLOT_TEMP_8 == 6 # define BOOST_PP_SLOT_1_DIGIT_8 6 # elif BOOST_PP_SLOT_TEMP_8 == 7 # define BOOST_PP_SLOT_1_DIGIT_8 7 # elif BOOST_PP_SLOT_TEMP_8 == 8 # define BOOST_PP_SLOT_1_DIGIT_8 8 # elif BOOST_PP_SLOT_TEMP_8 == 9 # define BOOST_PP_SLOT_1_DIGIT_8 9 # endif # # if BOOST_PP_SLOT_TEMP_7 == 0 # define BOOST_PP_SLOT_1_DIGIT_7 0 # elif BOOST_PP_SLOT_TEMP_7 == 1 # define BOOST_PP_SLOT_1_DIGIT_7 1 # elif BOOST_PP_SLOT_TEMP_7 == 2 # define BOOST_PP_SLOT_1_DIGIT_7 2 # elif BOOST_PP_SLOT_TEMP_7 == 3 # define BOOST_PP_SLOT_1_DIGIT_7 3 # elif BOOST_PP_SLOT_TEMP_7 == 4 # define BOOST_PP_SLOT_1_DIGIT_7 4 # elif BOOST_PP_SLOT_TEMP_7 == 5 # define BOOST_PP_SLOT_1_DIGIT_7 5 # elif BOOST_PP_SLOT_TEMP_7 == 6 # define BOOST_PP_SLOT_1_DIGIT_7 6 # elif BOOST_PP_SLOT_TEMP_7 == 7 # define BOOST_PP_SLOT_1_DIGIT_7 7 # elif BOOST_PP_SLOT_TEMP_7 == 8 # define BOOST_PP_SLOT_1_DIGIT_7 8 # elif BOOST_PP_SLOT_TEMP_7 == 9 # define BOOST_PP_SLOT_1_DIGIT_7 9 # endif # # if BOOST_PP_SLOT_TEMP_6 == 0 # define BOOST_PP_SLOT_1_DIGIT_6 0 # elif BOOST_PP_SLOT_TEMP_6 == 1 # define BOOST_PP_SLOT_1_DIGIT_6 1 # elif BOOST_PP_SLOT_TEMP_6 == 2 # define BOOST_PP_SLOT_1_DIGIT_6 2 # elif BOOST_PP_SLOT_TEMP_6 == 3 # define BOOST_PP_SLOT_1_DIGIT_6 3 # elif BOOST_PP_SLOT_TEMP_6 == 4 # define BOOST_PP_SLOT_1_DIGIT_6 4 # elif BOOST_PP_SLOT_TEMP_6 == 5 # define BOOST_PP_SLOT_1_DIGIT_6 5 # elif BOOST_PP_SLOT_TEMP_6 == 6 # define BOOST_PP_SLOT_1_DIGIT_6 6 # elif BOOST_PP_SLOT_TEMP_6 == 7 # define BOOST_PP_SLOT_1_DIGIT_6 7 # elif BOOST_PP_SLOT_TEMP_6 == 8 # define BOOST_PP_SLOT_1_DIGIT_6 8 # elif BOOST_PP_SLOT_TEMP_6 == 9 # define BOOST_PP_SLOT_1_DIGIT_6 9 # endif # # if BOOST_PP_SLOT_TEMP_5 == 0 # define BOOST_PP_SLOT_1_DIGIT_5 0 # elif BOOST_PP_SLOT_TEMP_5 == 1 # define BOOST_PP_SLOT_1_DIGIT_5 1 # elif BOOST_PP_SLOT_TEMP_5 == 2 # define BOOST_PP_SLOT_1_DIGIT_5 2 # elif BOOST_PP_SLOT_TEMP_5 == 3 # define BOOST_PP_SLOT_1_DIGIT_5 3 # elif BOOST_PP_SLOT_TEMP_5 == 4 # define BOOST_PP_SLOT_1_DIGIT_5 4 # elif BOOST_PP_SLOT_TEMP_5 == 5 # define BOOST_PP_SLOT_1_DIGIT_5 5 # elif BOOST_PP_SLOT_TEMP_5 == 6 # define BOOST_PP_SLOT_1_DIGIT_5 6 # elif BOOST_PP_SLOT_TEMP_5 == 7 # define BOOST_PP_SLOT_1_DIGIT_5 7 # elif BOOST_PP_SLOT_TEMP_5 == 8 # define BOOST_PP_SLOT_1_DIGIT_5 8 # elif BOOST_PP_SLOT_TEMP_5 == 9 # define BOOST_PP_SLOT_1_DIGIT_5 9 # endif # # if BOOST_PP_SLOT_TEMP_4 == 0 # define BOOST_PP_SLOT_1_DIGIT_4 0 # elif BOOST_PP_SLOT_TEMP_4 == 1 # define BOOST_PP_SLOT_1_DIGIT_4 1 # elif BOOST_PP_SLOT_TEMP_4 == 2 # define BOOST_PP_SLOT_1_DIGIT_4 2 # elif BOOST_PP_SLOT_TEMP_4 == 3 # define BOOST_PP_SLOT_1_DIGIT_4 3 # elif BOOST_PP_SLOT_TEMP_4 == 4 # define BOOST_PP_SLOT_1_DIGIT_4 4 # elif BOOST_PP_SLOT_TEMP_4 == 5 # define BOOST_PP_SLOT_1_DIGIT_4 5 # elif BOOST_PP_SLOT_TEMP_4 == 6 # define BOOST_PP_SLOT_1_DIGIT_4 6 # elif BOOST_PP_SLOT_TEMP_4 == 7 # define BOOST_PP_SLOT_1_DIGIT_4 7 # elif BOOST_PP_SLOT_TEMP_4 == 8 # define BOOST_PP_SLOT_1_DIGIT_4 8 # elif BOOST_PP_SLOT_TEMP_4 == 9 # define BOOST_PP_SLOT_1_DIGIT_4 9 # endif # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_SLOT_1_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_SLOT_1_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_SLOT_1_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_SLOT_1_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_SLOT_1_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_SLOT_1_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_SLOT_1_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_SLOT_1_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_SLOT_1_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_SLOT_1_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_SLOT_1_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_SLOT_1_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_SLOT_1_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_SLOT_1_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_SLOT_1_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_SLOT_1_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_SLOT_1_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_SLOT_1_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_SLOT_1_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_SLOT_1_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_SLOT_1_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_SLOT_1_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_SLOT_1_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_SLOT_1_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_SLOT_1_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_SLOT_1_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_SLOT_1_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_SLOT_1_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_SLOT_1_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_SLOT_1_DIGIT_1 9 # endif # # if BOOST_PP_SLOT_1_DIGIT_10 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_10(BOOST_PP_SLOT_1_DIGIT_10, BOOST_PP_SLOT_1_DIGIT_9, BOOST_PP_SLOT_1_DIGIT_8, BOOST_PP_SLOT_1_DIGIT_7, BOOST_PP_SLOT_1_DIGIT_6, BOOST_PP_SLOT_1_DIGIT_5, BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_9 # define BOOST_PP_SLOT_1 BOOST_PP_SLOT_CC_9(BOOST_PP_SLOT_1_DIGIT_9, BOOST_PP_SLOT_1_DIGIT_8, BOOST_PP_SLOT_1_DIGIT_7, BOOST_PP_SLOT_1_DIGIT_6, BOOST_PP_SLOT_1_DIGIT_5, BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_8 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_8(BOOST_PP_SLOT_1_DIGIT_8, BOOST_PP_SLOT_1_DIGIT_7, BOOST_PP_SLOT_1_DIGIT_6, BOOST_PP_SLOT_1_DIGIT_5, BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_7 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_7(BOOST_PP_SLOT_1_DIGIT_7, BOOST_PP_SLOT_1_DIGIT_6, BOOST_PP_SLOT_1_DIGIT_5, BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_6 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_6(BOOST_PP_SLOT_1_DIGIT_6, BOOST_PP_SLOT_1_DIGIT_5, BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_5 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_5(BOOST_PP_SLOT_1_DIGIT_5, BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_4 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_4(BOOST_PP_SLOT_1_DIGIT_4, BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_3 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_3(BOOST_PP_SLOT_1_DIGIT_3, BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # elif BOOST_PP_SLOT_1_DIGIT_2 # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_CC_2(BOOST_PP_SLOT_1_DIGIT_2, BOOST_PP_SLOT_1_DIGIT_1) # else # define BOOST_PP_SLOT_1() BOOST_PP_SLOT_1_DIGIT_1 # endif ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/def.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000000543711344301502031661 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_SLOT_DETAIL_DEF_HPP # define BOOST_PREPROCESSOR_SLOT_DETAIL_DEF_HPP # # /* BOOST_PP_SLOT_OFFSET_x */ # # define BOOST_PP_SLOT_OFFSET_10(x) (x) % 1000000000UL # define BOOST_PP_SLOT_OFFSET_9(x) BOOST_PP_SLOT_OFFSET_10(x) % 100000000UL # define BOOST_PP_SLOT_OFFSET_8(x) BOOST_PP_SLOT_OFFSET_9(x) % 10000000UL # define BOOST_PP_SLOT_OFFSET_7(x) BOOST_PP_SLOT_OFFSET_8(x) % 1000000UL # define BOOST_PP_SLOT_OFFSET_6(x) BOOST_PP_SLOT_OFFSET_7(x) % 100000UL # define BOOST_PP_SLOT_OFFSET_5(x) BOOST_PP_SLOT_OFFSET_6(x) % 10000UL # define BOOST_PP_SLOT_OFFSET_4(x) BOOST_PP_SLOT_OFFSET_5(x) % 1000UL # define BOOST_PP_SLOT_OFFSET_3(x) BOOST_PP_SLOT_OFFSET_4(x) % 100UL # define BOOST_PP_SLOT_OFFSET_2(x) BOOST_PP_SLOT_OFFSET_3(x) % 10UL # # /* BOOST_PP_SLOT_CC_x */ # # define BOOST_PP_SLOT_CC_2(a, b) BOOST_PP_SLOT_CC_2_D(a, b) # define BOOST_PP_SLOT_CC_3(a, b, c) BOOST_PP_SLOT_CC_3_D(a, b, c) # define BOOST_PP_SLOT_CC_4(a, b, c, d) BOOST_PP_SLOT_CC_4_D(a, b, c, d) # define BOOST_PP_SLOT_CC_5(a, b, c, d, e) BOOST_PP_SLOT_CC_5_D(a, b, c, d, e) # define BOOST_PP_SLOT_CC_6(a, b, c, d, e, f) BOOST_PP_SLOT_CC_6_D(a, b, c, d, e, f) # define BOOST_PP_SLOT_CC_7(a, b, c, d, e, f, g) BOOST_PP_SLOT_CC_7_D(a, b, c, d, e, f, g) # define BOOST_PP_SLOT_CC_8(a, b, c, d, e, f, g, h) BOOST_PP_SLOT_CC_8_D(a, b, c, d, e, f, g, h) # define BOOST_PP_SLOT_CC_9(a, b, c, d, e, f, g, h, i) BOOST_PP_SLOT_CC_9_D(a, b, c, d, e, f, g, h, i) # define BOOST_PP_SLOT_CC_10(a, b, c, d, e, f, g, h, i, j) BOOST_PP_SLOT_CC_10_D(a, b, c, d, e, f, g, h, i, j) # # define BOOST_PP_SLOT_CC_2_D(a, b) a ## b # define BOOST_PP_SLOT_CC_3_D(a, b, c) a ## b ## c # define BOOST_PP_SLOT_CC_4_D(a, b, c, d) a ## b ## c ## d # define BOOST_PP_SLOT_CC_5_D(a, b, c, d, e) a ## b ## c ## d ## e # define BOOST_PP_SLOT_CC_6_D(a, b, c, d, e, f) a ## b ## c ## d ## e ## f # define BOOST_PP_SLOT_CC_7_D(a, b, c, d, e, f, g) a ## b ## c ## d ## e ## f ## g # define BOOST_PP_SLOT_CC_8_D(a, b, c, d, e, f, g, h) a ## b ## c ## d ## e ## f ## g ## h # define BOOST_PP_SLOT_CC_9_D(a, b, c, d, e, f, g, h, i) a ## b ## c ## d ## e ## f ## g ## h ## i # define BOOST_PP_SLOT_CC_10_D(a, b, c, d, e, f, g, h, i, j) a ## b ## c ## d ## e ## f ## g ## h ## i ## j # # endif ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/shared.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000002436011344301502031655 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PP_VALUE # error BOOST_PP_ERROR: BOOST_PP_VALUE is not defined # endif # # undef BOOST_PP_SLOT_TEMP_1 # undef BOOST_PP_SLOT_TEMP_2 # undef BOOST_PP_SLOT_TEMP_3 # undef BOOST_PP_SLOT_TEMP_4 # undef BOOST_PP_SLOT_TEMP_5 # undef BOOST_PP_SLOT_TEMP_6 # undef BOOST_PP_SLOT_TEMP_7 # undef BOOST_PP_SLOT_TEMP_8 # undef BOOST_PP_SLOT_TEMP_9 # undef BOOST_PP_SLOT_TEMP_10 # # if (BOOST_PP_VALUE) / 1000000000UL == 0 # define BOOST_PP_SLOT_TEMP_10 0 # elif (BOOST_PP_VALUE) / 1000000000UL == 1 # define BOOST_PP_SLOT_TEMP_10 1 # elif (BOOST_PP_VALUE) / 1000000000UL == 2 # define BOOST_PP_SLOT_TEMP_10 2 # elif (BOOST_PP_VALUE) / 1000000000UL == 3 # define BOOST_PP_SLOT_TEMP_10 3 # elif (BOOST_PP_VALUE) / 1000000000UL == 4 # define BOOST_PP_SLOT_TEMP_10 4 # elif (BOOST_PP_VALUE) / 1000000000UL == 5 # define BOOST_PP_SLOT_TEMP_10 5 # elif (BOOST_PP_VALUE) / 1000000000UL == 6 # define BOOST_PP_SLOT_TEMP_10 6 # elif (BOOST_PP_VALUE) / 1000000000UL == 7 # define BOOST_PP_SLOT_TEMP_10 7 # elif (BOOST_PP_VALUE) / 1000000000UL == 8 # define BOOST_PP_SLOT_TEMP_10 8 # elif (BOOST_PP_VALUE) / 1000000000UL == 9 # define BOOST_PP_SLOT_TEMP_10 9 # endif # # if BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 0 # define BOOST_PP_SLOT_TEMP_9 0 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 1 # define BOOST_PP_SLOT_TEMP_9 1 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 2 # define BOOST_PP_SLOT_TEMP_9 2 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 3 # define BOOST_PP_SLOT_TEMP_9 3 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 4 # define BOOST_PP_SLOT_TEMP_9 4 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 5 # define BOOST_PP_SLOT_TEMP_9 5 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 6 # define BOOST_PP_SLOT_TEMP_9 6 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 7 # define BOOST_PP_SLOT_TEMP_9 7 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 8 # define BOOST_PP_SLOT_TEMP_9 8 # elif BOOST_PP_SLOT_OFFSET_10(BOOST_PP_VALUE) / 100000000UL == 9 # define BOOST_PP_SLOT_TEMP_9 9 # endif # # if BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 0 # define BOOST_PP_SLOT_TEMP_8 0 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 1 # define BOOST_PP_SLOT_TEMP_8 1 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 2 # define BOOST_PP_SLOT_TEMP_8 2 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 3 # define BOOST_PP_SLOT_TEMP_8 3 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 4 # define BOOST_PP_SLOT_TEMP_8 4 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 5 # define BOOST_PP_SLOT_TEMP_8 5 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 6 # define BOOST_PP_SLOT_TEMP_8 6 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 7 # define BOOST_PP_SLOT_TEMP_8 7 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 8 # define BOOST_PP_SLOT_TEMP_8 8 # elif BOOST_PP_SLOT_OFFSET_9(BOOST_PP_VALUE) / 10000000UL == 9 # define BOOST_PP_SLOT_TEMP_8 9 # endif # # if BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 0 # define BOOST_PP_SLOT_TEMP_7 0 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 1 # define BOOST_PP_SLOT_TEMP_7 1 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 2 # define BOOST_PP_SLOT_TEMP_7 2 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 3 # define BOOST_PP_SLOT_TEMP_7 3 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 4 # define BOOST_PP_SLOT_TEMP_7 4 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 5 # define BOOST_PP_SLOT_TEMP_7 5 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 6 # define BOOST_PP_SLOT_TEMP_7 6 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 7 # define BOOST_PP_SLOT_TEMP_7 7 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 8 # define BOOST_PP_SLOT_TEMP_7 8 # elif BOOST_PP_SLOT_OFFSET_8(BOOST_PP_VALUE) / 1000000UL == 9 # define BOOST_PP_SLOT_TEMP_7 9 # endif # # if BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 0 # define BOOST_PP_SLOT_TEMP_6 0 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 1 # define BOOST_PP_SLOT_TEMP_6 1 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 2 # define BOOST_PP_SLOT_TEMP_6 2 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 3 # define BOOST_PP_SLOT_TEMP_6 3 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 4 # define BOOST_PP_SLOT_TEMP_6 4 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 5 # define BOOST_PP_SLOT_TEMP_6 5 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 6 # define BOOST_PP_SLOT_TEMP_6 6 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 7 # define BOOST_PP_SLOT_TEMP_6 7 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 8 # define BOOST_PP_SLOT_TEMP_6 8 # elif BOOST_PP_SLOT_OFFSET_7(BOOST_PP_VALUE) / 100000UL == 9 # define BOOST_PP_SLOT_TEMP_6 9 # endif # # if BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 0 # define BOOST_PP_SLOT_TEMP_5 0 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 1 # define BOOST_PP_SLOT_TEMP_5 1 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 2 # define BOOST_PP_SLOT_TEMP_5 2 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 3 # define BOOST_PP_SLOT_TEMP_5 3 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 4 # define BOOST_PP_SLOT_TEMP_5 4 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 5 # define BOOST_PP_SLOT_TEMP_5 5 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 6 # define BOOST_PP_SLOT_TEMP_5 6 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 7 # define BOOST_PP_SLOT_TEMP_5 7 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 8 # define BOOST_PP_SLOT_TEMP_5 8 # elif BOOST_PP_SLOT_OFFSET_6(BOOST_PP_VALUE) / 10000UL == 9 # define BOOST_PP_SLOT_TEMP_5 9 # endif # # if BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 0 # define BOOST_PP_SLOT_TEMP_4 0 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 1 # define BOOST_PP_SLOT_TEMP_4 1 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 2 # define BOOST_PP_SLOT_TEMP_4 2 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 3 # define BOOST_PP_SLOT_TEMP_4 3 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 4 # define BOOST_PP_SLOT_TEMP_4 4 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 5 # define BOOST_PP_SLOT_TEMP_4 5 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 6 # define BOOST_PP_SLOT_TEMP_4 6 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 7 # define BOOST_PP_SLOT_TEMP_4 7 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 8 # define BOOST_PP_SLOT_TEMP_4 8 # elif BOOST_PP_SLOT_OFFSET_5(BOOST_PP_VALUE) / 1000UL == 9 # define BOOST_PP_SLOT_TEMP_4 9 # endif # # if BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 0 # define BOOST_PP_SLOT_TEMP_3 0 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 1 # define BOOST_PP_SLOT_TEMP_3 1 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 2 # define BOOST_PP_SLOT_TEMP_3 2 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 3 # define BOOST_PP_SLOT_TEMP_3 3 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 4 # define BOOST_PP_SLOT_TEMP_3 4 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 5 # define BOOST_PP_SLOT_TEMP_3 5 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 6 # define BOOST_PP_SLOT_TEMP_3 6 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 7 # define BOOST_PP_SLOT_TEMP_3 7 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 8 # define BOOST_PP_SLOT_TEMP_3 8 # elif BOOST_PP_SLOT_OFFSET_4(BOOST_PP_VALUE) / 100UL == 9 # define BOOST_PP_SLOT_TEMP_3 9 # endif # # if BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 0 # define BOOST_PP_SLOT_TEMP_2 0 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 1 # define BOOST_PP_SLOT_TEMP_2 1 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 2 # define BOOST_PP_SLOT_TEMP_2 2 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 3 # define BOOST_PP_SLOT_TEMP_2 3 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 4 # define BOOST_PP_SLOT_TEMP_2 4 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 5 # define BOOST_PP_SLOT_TEMP_2 5 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 6 # define BOOST_PP_SLOT_TEMP_2 6 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 7 # define BOOST_PP_SLOT_TEMP_2 7 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 8 # define BOOST_PP_SLOT_TEMP_2 8 # elif BOOST_PP_SLOT_OFFSET_3(BOOST_PP_VALUE) / 10UL == 9 # define BOOST_PP_SLOT_TEMP_2 9 # endif # # if BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 0 # define BOOST_PP_SLOT_TEMP_1 0 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 1 # define BOOST_PP_SLOT_TEMP_1 1 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 2 # define BOOST_PP_SLOT_TEMP_1 2 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 3 # define BOOST_PP_SLOT_TEMP_1 3 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 4 # define BOOST_PP_SLOT_TEMP_1 4 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 5 # define BOOST_PP_SLOT_TEMP_1 5 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 6 # define BOOST_PP_SLOT_TEMP_1 6 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 7 # define BOOST_PP_SLOT_TEMP_1 7 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 8 # define BOOST_PP_SLOT_TEMP_1 8 # elif BOOST_PP_SLOT_OFFSET_2(BOOST_PP_VALUE) == 9 # define BOOST_PP_SLOT_TEMP_1 9 # endif # # undef BOOST_PP_VALUE ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/detail/slot4.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/slot/det0000644000175000017500000002415111344301502031653 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # include # # undef BOOST_PP_SLOT_4 # # undef BOOST_PP_SLOT_4_DIGIT_1 # undef BOOST_PP_SLOT_4_DIGIT_2 # undef BOOST_PP_SLOT_4_DIGIT_3 # undef BOOST_PP_SLOT_4_DIGIT_4 # undef BOOST_PP_SLOT_4_DIGIT_5 # undef BOOST_PP_SLOT_4_DIGIT_6 # undef BOOST_PP_SLOT_4_DIGIT_7 # undef BOOST_PP_SLOT_4_DIGIT_8 # undef BOOST_PP_SLOT_4_DIGIT_9 # undef BOOST_PP_SLOT_4_DIGIT_10 # # if BOOST_PP_SLOT_TEMP_10 == 0 # define BOOST_PP_SLOT_4_DIGIT_10 0 # elif BOOST_PP_SLOT_TEMP_10 == 1 # define BOOST_PP_SLOT_4_DIGIT_10 1 # elif BOOST_PP_SLOT_TEMP_10 == 2 # define BOOST_PP_SLOT_4_DIGIT_10 2 # elif BOOST_PP_SLOT_TEMP_10 == 3 # define BOOST_PP_SLOT_4_DIGIT_10 3 # elif BOOST_PP_SLOT_TEMP_10 == 4 # define BOOST_PP_SLOT_4_DIGIT_10 4 # elif BOOST_PP_SLOT_TEMP_10 == 5 # define BOOST_PP_SLOT_4_DIGIT_10 5 # elif BOOST_PP_SLOT_TEMP_10 == 6 # define BOOST_PP_SLOT_4_DIGIT_10 6 # elif BOOST_PP_SLOT_TEMP_10 == 7 # define BOOST_PP_SLOT_4_DIGIT_10 7 # elif BOOST_PP_SLOT_TEMP_10 == 8 # define BOOST_PP_SLOT_4_DIGIT_10 8 # elif BOOST_PP_SLOT_TEMP_10 == 9 # define BOOST_PP_SLOT_4_DIGIT_10 9 # endif # # if BOOST_PP_SLOT_TEMP_9 == 0 # define BOOST_PP_SLOT_4_DIGIT_9 0 # elif BOOST_PP_SLOT_TEMP_9 == 1 # define BOOST_PP_SLOT_4_DIGIT_9 1 # elif BOOST_PP_SLOT_TEMP_9 == 2 # define BOOST_PP_SLOT_4_DIGIT_9 2 # elif BOOST_PP_SLOT_TEMP_9 == 3 # define BOOST_PP_SLOT_4_DIGIT_9 3 # elif BOOST_PP_SLOT_TEMP_9 == 4 # define BOOST_PP_SLOT_4_DIGIT_9 4 # elif BOOST_PP_SLOT_TEMP_9 == 5 # define BOOST_PP_SLOT_4_DIGIT_9 5 # elif BOOST_PP_SLOT_TEMP_9 == 6 # define BOOST_PP_SLOT_4_DIGIT_9 6 # elif BOOST_PP_SLOT_TEMP_9 == 7 # define BOOST_PP_SLOT_4_DIGIT_9 7 # elif BOOST_PP_SLOT_TEMP_9 == 8 # define BOOST_PP_SLOT_4_DIGIT_9 8 # elif BOOST_PP_SLOT_TEMP_9 == 9 # define BOOST_PP_SLOT_4_DIGIT_9 9 # endif # # if BOOST_PP_SLOT_TEMP_8 == 0 # define BOOST_PP_SLOT_4_DIGIT_8 0 # elif BOOST_PP_SLOT_TEMP_8 == 1 # define BOOST_PP_SLOT_4_DIGIT_8 1 # elif BOOST_PP_SLOT_TEMP_8 == 2 # define BOOST_PP_SLOT_4_DIGIT_8 2 # elif BOOST_PP_SLOT_TEMP_8 == 3 # define BOOST_PP_SLOT_4_DIGIT_8 3 # elif BOOST_PP_SLOT_TEMP_8 == 4 # define BOOST_PP_SLOT_4_DIGIT_8 4 # elif BOOST_PP_SLOT_TEMP_8 == 5 # define BOOST_PP_SLOT_4_DIGIT_8 5 # elif BOOST_PP_SLOT_TEMP_8 == 6 # define BOOST_PP_SLOT_4_DIGIT_8 6 # elif BOOST_PP_SLOT_TEMP_8 == 7 # define BOOST_PP_SLOT_4_DIGIT_8 7 # elif BOOST_PP_SLOT_TEMP_8 == 8 # define BOOST_PP_SLOT_4_DIGIT_8 8 # elif BOOST_PP_SLOT_TEMP_8 == 9 # define BOOST_PP_SLOT_4_DIGIT_8 9 # endif # # if BOOST_PP_SLOT_TEMP_7 == 0 # define BOOST_PP_SLOT_4_DIGIT_7 0 # elif BOOST_PP_SLOT_TEMP_7 == 1 # define BOOST_PP_SLOT_4_DIGIT_7 1 # elif BOOST_PP_SLOT_TEMP_7 == 2 # define BOOST_PP_SLOT_4_DIGIT_7 2 # elif BOOST_PP_SLOT_TEMP_7 == 3 # define BOOST_PP_SLOT_4_DIGIT_7 3 # elif BOOST_PP_SLOT_TEMP_7 == 4 # define BOOST_PP_SLOT_4_DIGIT_7 4 # elif BOOST_PP_SLOT_TEMP_7 == 5 # define BOOST_PP_SLOT_4_DIGIT_7 5 # elif BOOST_PP_SLOT_TEMP_7 == 6 # define BOOST_PP_SLOT_4_DIGIT_7 6 # elif BOOST_PP_SLOT_TEMP_7 == 7 # define BOOST_PP_SLOT_4_DIGIT_7 7 # elif BOOST_PP_SLOT_TEMP_7 == 8 # define BOOST_PP_SLOT_4_DIGIT_7 8 # elif BOOST_PP_SLOT_TEMP_7 == 9 # define BOOST_PP_SLOT_4_DIGIT_7 9 # endif # # if BOOST_PP_SLOT_TEMP_6 == 0 # define BOOST_PP_SLOT_4_DIGIT_6 0 # elif BOOST_PP_SLOT_TEMP_6 == 1 # define BOOST_PP_SLOT_4_DIGIT_6 1 # elif BOOST_PP_SLOT_TEMP_6 == 2 # define BOOST_PP_SLOT_4_DIGIT_6 2 # elif BOOST_PP_SLOT_TEMP_6 == 3 # define BOOST_PP_SLOT_4_DIGIT_6 3 # elif BOOST_PP_SLOT_TEMP_6 == 4 # define BOOST_PP_SLOT_4_DIGIT_6 4 # elif BOOST_PP_SLOT_TEMP_6 == 5 # define BOOST_PP_SLOT_4_DIGIT_6 5 # elif BOOST_PP_SLOT_TEMP_6 == 6 # define BOOST_PP_SLOT_4_DIGIT_6 6 # elif BOOST_PP_SLOT_TEMP_6 == 7 # define BOOST_PP_SLOT_4_DIGIT_6 7 # elif BOOST_PP_SLOT_TEMP_6 == 8 # define BOOST_PP_SLOT_4_DIGIT_6 8 # elif BOOST_PP_SLOT_TEMP_6 == 9 # define BOOST_PP_SLOT_4_DIGIT_6 9 # endif # # if BOOST_PP_SLOT_TEMP_5 == 0 # define BOOST_PP_SLOT_4_DIGIT_5 0 # elif BOOST_PP_SLOT_TEMP_5 == 1 # define BOOST_PP_SLOT_4_DIGIT_5 1 # elif BOOST_PP_SLOT_TEMP_5 == 2 # define BOOST_PP_SLOT_4_DIGIT_5 2 # elif BOOST_PP_SLOT_TEMP_5 == 3 # define BOOST_PP_SLOT_4_DIGIT_5 3 # elif BOOST_PP_SLOT_TEMP_5 == 4 # define BOOST_PP_SLOT_4_DIGIT_5 4 # elif BOOST_PP_SLOT_TEMP_5 == 5 # define BOOST_PP_SLOT_4_DIGIT_5 5 # elif BOOST_PP_SLOT_TEMP_5 == 6 # define BOOST_PP_SLOT_4_DIGIT_5 6 # elif BOOST_PP_SLOT_TEMP_5 == 7 # define BOOST_PP_SLOT_4_DIGIT_5 7 # elif BOOST_PP_SLOT_TEMP_5 == 8 # define BOOST_PP_SLOT_4_DIGIT_5 8 # elif BOOST_PP_SLOT_TEMP_5 == 9 # define BOOST_PP_SLOT_4_DIGIT_5 9 # endif # # if BOOST_PP_SLOT_TEMP_4 == 0 # define BOOST_PP_SLOT_4_DIGIT_4 0 # elif BOOST_PP_SLOT_TEMP_4 == 1 # define BOOST_PP_SLOT_4_DIGIT_4 1 # elif BOOST_PP_SLOT_TEMP_4 == 2 # define BOOST_PP_SLOT_4_DIGIT_4 2 # elif BOOST_PP_SLOT_TEMP_4 == 3 # define BOOST_PP_SLOT_4_DIGIT_4 3 # elif BOOST_PP_SLOT_TEMP_4 == 4 # define BOOST_PP_SLOT_4_DIGIT_4 4 # elif BOOST_PP_SLOT_TEMP_4 == 5 # define BOOST_PP_SLOT_4_DIGIT_4 5 # elif BOOST_PP_SLOT_TEMP_4 == 6 # define BOOST_PP_SLOT_4_DIGIT_4 6 # elif BOOST_PP_SLOT_TEMP_4 == 7 # define BOOST_PP_SLOT_4_DIGIT_4 7 # elif BOOST_PP_SLOT_TEMP_4 == 8 # define BOOST_PP_SLOT_4_DIGIT_4 8 # elif BOOST_PP_SLOT_TEMP_4 == 9 # define BOOST_PP_SLOT_4_DIGIT_4 9 # endif # # if BOOST_PP_SLOT_TEMP_3 == 0 # define BOOST_PP_SLOT_4_DIGIT_3 0 # elif BOOST_PP_SLOT_TEMP_3 == 1 # define BOOST_PP_SLOT_4_DIGIT_3 1 # elif BOOST_PP_SLOT_TEMP_3 == 2 # define BOOST_PP_SLOT_4_DIGIT_3 2 # elif BOOST_PP_SLOT_TEMP_3 == 3 # define BOOST_PP_SLOT_4_DIGIT_3 3 # elif BOOST_PP_SLOT_TEMP_3 == 4 # define BOOST_PP_SLOT_4_DIGIT_3 4 # elif BOOST_PP_SLOT_TEMP_3 == 5 # define BOOST_PP_SLOT_4_DIGIT_3 5 # elif BOOST_PP_SLOT_TEMP_3 == 6 # define BOOST_PP_SLOT_4_DIGIT_3 6 # elif BOOST_PP_SLOT_TEMP_3 == 7 # define BOOST_PP_SLOT_4_DIGIT_3 7 # elif BOOST_PP_SLOT_TEMP_3 == 8 # define BOOST_PP_SLOT_4_DIGIT_3 8 # elif BOOST_PP_SLOT_TEMP_3 == 9 # define BOOST_PP_SLOT_4_DIGIT_3 9 # endif # # if BOOST_PP_SLOT_TEMP_2 == 0 # define BOOST_PP_SLOT_4_DIGIT_2 0 # elif BOOST_PP_SLOT_TEMP_2 == 1 # define BOOST_PP_SLOT_4_DIGIT_2 1 # elif BOOST_PP_SLOT_TEMP_2 == 2 # define BOOST_PP_SLOT_4_DIGIT_2 2 # elif BOOST_PP_SLOT_TEMP_2 == 3 # define BOOST_PP_SLOT_4_DIGIT_2 3 # elif BOOST_PP_SLOT_TEMP_2 == 4 # define BOOST_PP_SLOT_4_DIGIT_2 4 # elif BOOST_PP_SLOT_TEMP_2 == 5 # define BOOST_PP_SLOT_4_DIGIT_2 5 # elif BOOST_PP_SLOT_TEMP_2 == 6 # define BOOST_PP_SLOT_4_DIGIT_2 6 # elif BOOST_PP_SLOT_TEMP_2 == 7 # define BOOST_PP_SLOT_4_DIGIT_2 7 # elif BOOST_PP_SLOT_TEMP_2 == 8 # define BOOST_PP_SLOT_4_DIGIT_2 8 # elif BOOST_PP_SLOT_TEMP_2 == 9 # define BOOST_PP_SLOT_4_DIGIT_2 9 # endif # # if BOOST_PP_SLOT_TEMP_1 == 0 # define BOOST_PP_SLOT_4_DIGIT_1 0 # elif BOOST_PP_SLOT_TEMP_1 == 1 # define BOOST_PP_SLOT_4_DIGIT_1 1 # elif BOOST_PP_SLOT_TEMP_1 == 2 # define BOOST_PP_SLOT_4_DIGIT_1 2 # elif BOOST_PP_SLOT_TEMP_1 == 3 # define BOOST_PP_SLOT_4_DIGIT_1 3 # elif BOOST_PP_SLOT_TEMP_1 == 4 # define BOOST_PP_SLOT_4_DIGIT_1 4 # elif BOOST_PP_SLOT_TEMP_1 == 5 # define BOOST_PP_SLOT_4_DIGIT_1 5 # elif BOOST_PP_SLOT_TEMP_1 == 6 # define BOOST_PP_SLOT_4_DIGIT_1 6 # elif BOOST_PP_SLOT_TEMP_1 == 7 # define BOOST_PP_SLOT_4_DIGIT_1 7 # elif BOOST_PP_SLOT_TEMP_1 == 8 # define BOOST_PP_SLOT_4_DIGIT_1 8 # elif BOOST_PP_SLOT_TEMP_1 == 9 # define BOOST_PP_SLOT_4_DIGIT_1 9 # endif # # if BOOST_PP_SLOT_4_DIGIT_10 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_10(BOOST_PP_SLOT_4_DIGIT_10, BOOST_PP_SLOT_4_DIGIT_9, BOOST_PP_SLOT_4_DIGIT_8, BOOST_PP_SLOT_4_DIGIT_7, BOOST_PP_SLOT_4_DIGIT_6, BOOST_PP_SLOT_4_DIGIT_5, BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_9 # define BOOST_PP_SLOT_4 BOOST_PP_SLOT_CC_9(BOOST_PP_SLOT_4_DIGIT_9, BOOST_PP_SLOT_4_DIGIT_8, BOOST_PP_SLOT_4_DIGIT_7, BOOST_PP_SLOT_4_DIGIT_6, BOOST_PP_SLOT_4_DIGIT_5, BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_8 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_8(BOOST_PP_SLOT_4_DIGIT_8, BOOST_PP_SLOT_4_DIGIT_7, BOOST_PP_SLOT_4_DIGIT_6, BOOST_PP_SLOT_4_DIGIT_5, BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_7 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_7(BOOST_PP_SLOT_4_DIGIT_7, BOOST_PP_SLOT_4_DIGIT_6, BOOST_PP_SLOT_4_DIGIT_5, BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_6 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_6(BOOST_PP_SLOT_4_DIGIT_6, BOOST_PP_SLOT_4_DIGIT_5, BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_5 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_5(BOOST_PP_SLOT_4_DIGIT_5, BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_4 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_4(BOOST_PP_SLOT_4_DIGIT_4, BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_3 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_3(BOOST_PP_SLOT_4_DIGIT_3, BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # elif BOOST_PP_SLOT_4_DIGIT_2 # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_CC_2(BOOST_PP_SLOT_4_DIGIT_2, BOOST_PP_SLOT_4_DIGIT_1) # else # define BOOST_PP_SLOT_4() BOOST_PP_SLOT_4_DIGIT_1 # endif ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/expand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/preprocessor/expand.h0000644000175000017500000000135111344301502031620 0ustar debiandebian# /* ************************************************************************** # * * # * (C) Copyright Paul Mensonides 2002. # * Distributed under the Boost Software License, Version 1.0. (See # * accompanying file LICENSE_1_0.txt or copy at # * http://www.boost.org/LICENSE_1_0.txt) # * * # ************************************************************************** */ # # /* See http://www.boost.org for most recent version. */ # # ifndef BOOST_PREPROCESSOR_EXPAND_HPP # define BOOST_PREPROCESSOR_EXPAND_HPP # # include # # endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/timer.hpp0000644000175000017500000000514711344301501027301 0ustar debiandebian// boost timer.hpp header file ---------------------------------------------// // Copyright Beman Dawes 1994-99. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // See http://www.boost.org/libs/timer for documentation. // Revision History // 01 Apr 01 Modified to use new header. (JMaddock) // 12 Jan 01 Change to inline implementation to allow use without library // builds. See docs for more rationale. (Beman Dawes) // 25 Sep 99 elapsed_max() and elapsed_min() added (John Maddock) // 16 Jul 99 Second beta // 6 Jul 99 Initial boost version #ifndef BOOST_TIMER_HPP #define BOOST_TIMER_HPP #include #include #include # ifdef BOOST_NO_STDC_NAMESPACE namespace std { using ::clock_t; using ::clock; } # endif namespace boost { // timer -------------------------------------------------------------------// // A timer object measures elapsed time. // It is recommended that implementations measure wall clock rather than CPU // time since the intended use is performance measurement on systems where // total elapsed time is more important than just process or CPU time. // Warnings: The maximum measurable elapsed time may well be only 596.5+ hours // due to implementation limitations. The accuracy of timings depends on the // accuracy of timing information provided by the underlying platform, and // this varies a great deal from platform to platform. class timer { public: timer() { _start_time = std::clock(); } // postcondition: elapsed()==0 // timer( const timer& src ); // post: elapsed()==src.elapsed() // ~timer(){} // timer& operator=( const timer& src ); // post: elapsed()==src.elapsed() void restart() { _start_time = std::clock(); } // post: elapsed()==0 double elapsed() const // return elapsed time in seconds { return double(std::clock() - _start_time) / CLOCKS_PER_SEC; } double elapsed_max() const // return estimated maximum value for elapsed() // Portability warning: elapsed_max() may return too high a value on systems // where std::clock_t overflows or resets at surprising values. { return (double((std::numeric_limits::max)()) - double(_start_time)) / double(CLOCKS_PER_SEC); } double elapsed_min() const // return minimum value for elapsed() { return double(1)/double(CLOCKS_PER_SEC); } private: std::clock_t _start_time; }; // timer } // namespace boost #endif // BOOST_TIMER_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/blank_fwd.hpp0000644000175000017500000000115211344301501030100 0ustar debiandebian//----------------------------------------------------------------------------- // boost blank_fwd.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_BLANK_FWD_HPP #define BOOST_BLANK_FWD_HPP namespace boost { struct blank; } // namespace boost #endif // BOOST_BLANK_FWD_HPP mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/thread.hpp0000644000175000017500000000161211344301501027421 0ustar debiandebian// Copyright (C) 2001-2003 // William E. Kempf // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. William E. Kempf makes no representations // about the suitability of this software for any purpose. // It is provided "as is" without express or implied warranty. #if !defined(BOOST_THREAD_WEK01082003_HPP) #define BOOST_THREAD_WEK01082003_HPP #include #include #include #include #include #include #include #include #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/concept_check.hpp0000644000175000017500000010252211344301501030744 0ustar debiandebian// // (C) Copyright Jeremy Siek 2000. // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Revision History: // 05 May 2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek) // 02 April 2001: Removed limits header altogether. (Jeremy Siek) // 01 April 2001: Modified to use new header. (JMaddock) // // See http://www.boost.org/libs/concept_check for documentation. #ifndef BOOST_CONCEPT_CHECKS_HPP #define BOOST_CONCEPT_CHECKS_HPP #include #include #include #include #include #include #include #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__BORLANDC__) #define BOOST_FPTR #else #define BOOST_FPTR & #endif namespace boost { /* "inline" is used for ignore_unused_variable_warning() and function_requires() to make sure there is no overhead with g++. */ template inline void ignore_unused_variable_warning(const T&) { } // the unused, defaulted parameter is a workaround for MSVC and Compaq C++ template inline void function_requires(mpl::identity* = 0) { #if !defined(NDEBUG) void (Concept::*x)() = BOOST_FPTR Concept::constraints; ignore_unused_variable_warning(x); #endif } #define BOOST_CLASS_REQUIRE(type_var, ns, concept) \ typedef void (ns::concept ::* func##type_var##concept)(); \ template \ struct concept_checking_##type_var##concept { }; \ typedef concept_checking_##type_var##concept< \ BOOST_FPTR ns::concept::constraints> \ concept_checking_typedef_##type_var##concept #define BOOST_CLASS_REQUIRE2(type_var1, type_var2, ns, concept) \ typedef void (ns::concept ::* \ func##type_var1##type_var2##concept)(); \ template \ struct concept_checking_##type_var1##type_var2##concept { }; \ typedef concept_checking_##type_var1##type_var2##concept< \ BOOST_FPTR ns::concept::constraints> \ concept_checking_typedef_##type_var1##type_var2##concept #define BOOST_CLASS_REQUIRE3(tv1, tv2, tv3, ns, concept) \ typedef void (ns::concept ::* \ func##tv1##tv2##tv3##concept)(); \ template \ struct concept_checking_##tv1##tv2##tv3##concept { }; \ typedef concept_checking_##tv1##tv2##tv3##concept< \ BOOST_FPTR ns::concept::constraints> \ concept_checking_typedef_##tv1##tv2##tv3##concept #define BOOST_CLASS_REQUIRE4(tv1, tv2, tv3, tv4, ns, concept) \ typedef void (ns::concept ::* \ func##tv1##tv2##tv3##tv4##concept)(); \ template \ struct concept_checking_##tv1##tv2##tv3##tv4##concept { }; \ typedef concept_checking_##tv1##tv2##tv3##tv4##concept< \ BOOST_FPTR ns::concept::constraints> \ concept_checking_typedef_##tv1##tv2##tv3##tv4##concept // NOTE: The BOOST_CLASS_REQUIRES (with an 'S' at the end) is deprecated. // The BOOST_CLASS_REQUIRES macros use function pointers as // template parameters, which VC++ does not support. #if defined(BOOST_NO_FUNCTION_PTR_TEMPLATE_PARAMETERS) #define BOOST_CLASS_REQUIRES(type_var, concept) #define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) #define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) #define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) #else #define BOOST_CLASS_REQUIRES(type_var, concept) \ typedef void (concept ::* func##type_var##concept)(); \ template \ struct concept_checking_##type_var##concept { }; \ typedef concept_checking_##type_var##concept< \ BOOST_FPTR concept ::constraints> \ concept_checking_typedef_##type_var##concept #define BOOST_CLASS_REQUIRES2(type_var1, type_var2, concept) \ typedef void (concept ::* func##type_var1##type_var2##concept)(); \ template \ struct concept_checking_##type_var1##type_var2##concept { }; \ typedef concept_checking_##type_var1##type_var2##concept< \ BOOST_FPTR concept ::constraints> \ concept_checking_typedef_##type_var1##type_var2##concept #define BOOST_CLASS_REQUIRES3(type_var1, type_var2, type_var3, concept) \ typedef void (concept ::* func##type_var1##type_var2##type_var3##concept)(); \ template \ struct concept_checking_##type_var1##type_var2##type_var3##concept { }; \ typedef concept_checking_##type_var1##type_var2##type_var3##concept< \ BOOST_FPTR concept ::constraints> \ concept_checking_typedef_##type_var1##type_var2##type_var3##concept #define BOOST_CLASS_REQUIRES4(type_var1, type_var2, type_var3, type_var4, concept) \ typedef void (concept ::* func##type_var1##type_var2##type_var3##type_var4##concept)(); \ template \ struct concept_checking_##type_var1##type_var2##type_var3##type_var4##concept { }; \ typedef concept_checking_##type_var1##type_var2##type_var3##type_var4##concept< \ BOOST_FPTR concept ::constraints> \ concept_checking_typedef_##type_var1##type_var2##type_var3##type_var4##concept #endif #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct require_same { }; template struct require_same { typedef T type; }; #else // This version does not perform checking, but will not do any harm. template struct require_same { typedef T type; }; #endif template struct IntegerConcept { void constraints() { #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION x.error_type_must_be_an_integer_type(); #endif } T x; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <> struct IntegerConcept { void constraints() {} }; template <> struct IntegerConcept { void constraints() {} }; template <> struct IntegerConcept { void constraints() {} }; template <> struct IntegerConcept { void constraints() {} }; template <> struct IntegerConcept { void constraints() {} }; template <> struct IntegerConcept { void constraints() {} }; // etc. #endif template struct SignedIntegerConcept { void constraints() { #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION x.error_type_must_be_a_signed_integer_type(); #endif } T x; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <> struct SignedIntegerConcept { void constraints() {} }; template <> struct SignedIntegerConcept { void constraints() {} }; template <> struct SignedIntegerConcept { void constraints() {} }; # if defined(BOOST_HAS_LONG_LONG) template <> struct SignedIntegerConcept< ::boost::long_long_type> { void constraints() {} }; # endif // etc. #endif template struct UnsignedIntegerConcept { void constraints() { #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION x.error_type_must_be_an_unsigned_integer_type(); #endif } T x; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template <> struct UnsignedIntegerConcept { void constraints() {} }; template <> struct UnsignedIntegerConcept { void constraints() {} }; template <> struct UnsignedIntegerConcept { void constraints() {} }; // etc. #endif //=========================================================================== // Basic Concepts template struct DefaultConstructibleConcept { void constraints() { TT a; // require default constructor ignore_unused_variable_warning(a); } }; template struct AssignableConcept { void constraints() { #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL a = a; // require assignment operator #endif const_constraints(a); } void const_constraints(const TT& b) { #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL a = b; // const required for argument to assignment #endif } TT a; }; template struct CopyConstructibleConcept { void constraints() { TT a(b); // require copy constructor TT* ptr = &a; // require address of operator const_constraints(a); ignore_unused_variable_warning(ptr); } void const_constraints(const TT& a) { TT c(a); // require const copy constructor const TT* ptr = &a; // require const address of operator ignore_unused_variable_warning(c); ignore_unused_variable_warning(ptr); } TT b; }; // The SGI STL version of Assignable requires copy constructor and operator= template struct SGIAssignableConcept { void constraints() { TT b(a); #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL a = a; // require assignment operator #endif const_constraints(a); ignore_unused_variable_warning(b); } void const_constraints(const TT& b) { TT c(b); #if !defined(_ITERATOR_) // back_insert_iterator broken for VC++ STL a = b; // const required for argument to assignment #endif ignore_unused_variable_warning(c); } TT a; }; template struct ConvertibleConcept { void constraints() { Y y = x; ignore_unused_variable_warning(y); } X x; }; // The C++ standard requirements for many concepts talk about return // types that must be "convertible to bool". The problem with this // requirement is that it leaves the door open for evil proxies that // define things like operator|| with strange return types. Two // possible solutions are: // 1) require the return type to be exactly bool // 2) stay with convertible to bool, and also // specify stuff about all the logical operators. // For now we just test for convertible to bool. template void require_boolean_expr(const TT& t) { bool x = t; ignore_unused_variable_warning(x); } template struct EqualityComparableConcept { void constraints() { require_boolean_expr(a == b); require_boolean_expr(a != b); } TT a, b; }; template struct LessThanComparableConcept { void constraints() { require_boolean_expr(a < b); } TT a, b; }; // This is equivalent to SGI STL's LessThanComparable. template struct ComparableConcept { void constraints() { require_boolean_expr(a < b); require_boolean_expr(a > b); require_boolean_expr(a <= b); require_boolean_expr(a >= b); } TT a, b; }; #define BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \ template \ struct NAME { \ void constraints() { (void)constraints_(); } \ bool constraints_() { \ return a OP b; \ } \ First a; \ Second b; \ } #define BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(OP,NAME) \ template \ struct NAME { \ void constraints() { (void)constraints_(); } \ Ret constraints_() { \ return a OP b; \ } \ First a; \ Second b; \ } BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept); BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(!=, NotEqualOpConcept); BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<, LessThanOpConcept); BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(<=, LessEqualOpConcept); BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>, GreaterThanOpConcept); BOOST_DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(>=, GreaterEqualOpConcept); BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(+, PlusOpConcept); BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(*, TimesOpConcept); BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(/, DivideOpConcept); BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(-, SubtractOpConcept); BOOST_DEFINE_BINARY_OPERATOR_CONSTRAINT(%, ModOpConcept); //=========================================================================== // Function Object Concepts template struct GeneratorConcept { void constraints() { const Return& r = f(); // require operator() member function ignore_unused_variable_warning(r); } Func f; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct GeneratorConcept { void constraints() { f(); // require operator() member function } Func f; }; #endif template struct UnaryFunctionConcept { // required in case any of our template args are const-qualified: UnaryFunctionConcept(); void constraints() { r = f(arg); // require operator() } Func f; Arg arg; Return r; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct UnaryFunctionConcept { void constraints() { f(arg); // require operator() } Func f; Arg arg; }; #endif template struct BinaryFunctionConcept { void constraints() { r = f(first, second); // require operator() } Func f; First first; Second second; Return r; }; #if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template struct BinaryFunctionConcept { void constraints() { f(first, second); // require operator() } Func f; First first; Second second; }; #endif template struct UnaryPredicateConcept { void constraints() { require_boolean_expr(f(arg)); // require operator() returning bool } Func f; Arg arg; }; template struct BinaryPredicateConcept { void constraints() { require_boolean_expr(f(a, b)); // require operator() returning bool } Func f; First a; Second b; }; // use this when functor is used inside a container class like std::set template struct Const_BinaryPredicateConcept { void constraints() { const_constraints(f); } void const_constraints(const Func& fun) { function_requires >(); // operator() must be a const member function require_boolean_expr(fun(a, b)); } Func f; First a; Second b; }; template struct AdaptableGeneratorConcept { void constraints() { typedef typename Func::result_type result_type; BOOST_STATIC_ASSERT((is_convertible::value)); function_requires< GeneratorConcept >(); } }; template struct AdaptableUnaryFunctionConcept { void constraints() { typedef typename Func::argument_type argument_type; typedef typename Func::result_type result_type; BOOST_STATIC_ASSERT((is_convertible::value)); BOOST_STATIC_ASSERT((is_convertible::value)); function_requires< UnaryFunctionConcept >(); } }; template struct AdaptableBinaryFunctionConcept { void constraints() { typedef typename Func::first_argument_type first_argument_type; typedef typename Func::second_argument_type second_argument_type; typedef typename Func::result_type result_type; BOOST_STATIC_ASSERT((is_convertible::value)); BOOST_STATIC_ASSERT((is_convertible::value)); BOOST_STATIC_ASSERT((is_convertible::value)); function_requires< BinaryFunctionConcept >(); } }; template struct AdaptablePredicateConcept { void constraints() { function_requires< UnaryPredicateConcept >(); function_requires< AdaptableUnaryFunctionConcept >(); } }; template struct AdaptableBinaryPredicateConcept { void constraints() { function_requires< BinaryPredicateConcept >(); function_requires< AdaptableBinaryFunctionConcept >(); } }; //=========================================================================== // Iterator Concepts template struct InputIteratorConcept { void constraints() { function_requires< AssignableConcept >(); function_requires< EqualityComparableConcept >(); TT j(i); (void)*i; // require dereference operator #ifndef BOOST_NO_STD_ITERATOR_TRAITS // require iterator_traits typedef's typedef typename std::iterator_traits::difference_type D; // Hmm, the following is a bit fragile //function_requires< SignedIntegerConcept >(); typedef typename std::iterator_traits::reference R; typedef typename std::iterator_traits::pointer P; typedef typename std::iterator_traits::iterator_category C; function_requires< ConvertibleConcept >(); #endif ++j; // require preincrement operator i++; // require postincrement operator } TT i; }; template struct OutputIteratorConcept { void constraints() { function_requires< AssignableConcept >(); ++i; // require preincrement operator i++; // require postincrement operator *i++ = t; // require postincrement and assignment } TT i, j; ValueT t; }; template struct ForwardIteratorConcept { void constraints() { function_requires< InputIteratorConcept >(); #ifndef BOOST_NO_STD_ITERATOR_TRAITS typedef typename std::iterator_traits::iterator_category C; function_requires< ConvertibleConcept >(); typedef typename std::iterator_traits::reference reference; reference r = *i; ignore_unused_variable_warning(r); #endif } TT i; }; template struct Mutable_ForwardIteratorConcept { void constraints() { function_requires< ForwardIteratorConcept >(); *i++ = *i; // require postincrement and assignment } TT i; }; template struct BidirectionalIteratorConcept { void constraints() { function_requires< ForwardIteratorConcept >(); #ifndef BOOST_NO_STD_ITERATOR_TRAITS typedef typename std::iterator_traits::iterator_category C; function_requires< ConvertibleConcept >(); #endif --i; // require predecrement operator i--; // require postdecrement operator } TT i; }; template struct Mutable_BidirectionalIteratorConcept { void constraints() { function_requires< BidirectionalIteratorConcept >(); function_requires< Mutable_ForwardIteratorConcept >(); *i-- = *i; // require postdecrement and assignment } TT i; }; template struct RandomAccessIteratorConcept { void constraints() { function_requires< BidirectionalIteratorConcept >(); function_requires< ComparableConcept >(); #ifndef BOOST_NO_STD_ITERATOR_TRAITS typedef typename std::iterator_traits::iterator_category C; function_requires< ConvertibleConcept< C, std::random_access_iterator_tag> >(); typedef typename std::iterator_traits::reference R; #endif i += n; // require assignment addition operator i = i + n; i = n + i; // require addition with difference type i -= n; // require assignment subtraction operator i = i - n; // require subtraction with difference type n = i - j; // require difference operator (void)i[n]; // require element access operator } TT a, b; TT i, j; #ifndef BOOST_NO_STD_ITERATOR_TRAITS typename std::iterator_traits::difference_type n; #else std::ptrdiff_t n; #endif }; template struct Mutable_RandomAccessIteratorConcept { void constraints() { function_requires< RandomAccessIteratorConcept >(); function_requires< Mutable_BidirectionalIteratorConcept >(); i[n] = *i; // require element access and assignment } TT i; #ifndef BOOST_NO_STD_ITERATOR_TRAITS typename std::iterator_traits::difference_type n; #else std::ptrdiff_t n; #endif }; //=========================================================================== // Container Concepts template struct ContainerConcept { typedef typename Container::value_type value_type; typedef typename Container::difference_type difference_type; typedef typename Container::size_type size_type; typedef typename Container::const_reference const_reference; typedef typename Container::const_pointer const_pointer; typedef typename Container::const_iterator const_iterator; void constraints() { function_requires< InputIteratorConcept >(); function_requires< AssignableConcept >(); const_constraints(c); } void const_constraints(const Container& c) { i = c.begin(); i = c.end(); n = c.size(); n = c.max_size(); b = c.empty(); } Container c; bool b; const_iterator i; size_type n; }; template struct Mutable_ContainerConcept { typedef typename Container::value_type value_type; typedef typename Container::reference reference; typedef typename Container::iterator iterator; typedef typename Container::pointer pointer; void constraints() { function_requires< ContainerConcept >(); function_requires< AssignableConcept >(); function_requires< InputIteratorConcept >(); i = c.begin(); i = c.end(); c.swap(c2); } iterator i; Container c, c2; }; template struct ForwardContainerConcept { void constraints() { function_requires< ContainerConcept >(); typedef typename ForwardContainer::const_iterator const_iterator; function_requires< ForwardIteratorConcept >(); } }; template struct Mutable_ForwardContainerConcept { void constraints() { function_requires< ForwardContainerConcept >(); function_requires< Mutable_ContainerConcept >(); typedef typename ForwardContainer::iterator iterator; function_requires< Mutable_ForwardIteratorConcept >(); } }; template struct ReversibleContainerConcept { typedef typename ReversibleContainer::const_iterator const_iterator; typedef typename ReversibleContainer::const_reverse_iterator const_reverse_iterator; void constraints() { function_requires< ForwardContainerConcept >(); function_requires< BidirectionalIteratorConcept >(); function_requires< BidirectionalIteratorConcept >(); const_constraints(c); } void const_constraints(const ReversibleContainer& c) { const_reverse_iterator i = c.rbegin(); i = c.rend(); } ReversibleContainer c; }; template struct Mutable_ReversibleContainerConcept { typedef typename ReversibleContainer::iterator iterator; typedef typename ReversibleContainer::reverse_iterator reverse_iterator; void constraints() { function_requires< ReversibleContainerConcept >(); function_requires< Mutable_ForwardContainerConcept >(); function_requires< Mutable_BidirectionalIteratorConcept >(); function_requires< Mutable_BidirectionalIteratorConcept >(); reverse_iterator i = c.rbegin(); i = c.rend(); } ReversibleContainer c; }; template struct RandomAccessContainerConcept { typedef typename RandomAccessContainer::size_type size_type; typedef typename RandomAccessContainer::const_reference const_reference; typedef typename RandomAccessContainer::const_iterator const_iterator; typedef typename RandomAccessContainer::const_reverse_iterator const_reverse_iterator; void constraints() { function_requires< ReversibleContainerConcept >(); function_requires< RandomAccessIteratorConcept >(); function_requires< RandomAccessIteratorConcept >(); const_constraints(c); } void const_constraints(const RandomAccessContainer& c) { const_reference r = c[n]; ignore_unused_variable_warning(r); } RandomAccessContainer c; size_type n; }; template struct Mutable_RandomAccessContainerConcept { typedef typename RandomAccessContainer::size_type size_type; typedef typename RandomAccessContainer::reference reference; typedef typename RandomAccessContainer::iterator iterator; typedef typename RandomAccessContainer::reverse_iterator reverse_iterator; void constraints() { function_requires< RandomAccessContainerConcept >(); function_requires< Mutable_ReversibleContainerConcept >(); function_requires< Mutable_RandomAccessIteratorConcept >(); function_requires< Mutable_RandomAccessIteratorConcept >(); reference r = c[i]; ignore_unused_variable_warning(r); } size_type i; RandomAccessContainer c; }; // A Sequence is inherently mutable template struct SequenceConcept { typedef typename Sequence::reference reference; typedef typename Sequence::const_reference const_reference; void constraints() { // Matt Austern's book puts DefaultConstructible here, the C++ // standard places it in Container // function_requires< DefaultConstructible >(); function_requires< Mutable_ForwardContainerConcept >(); function_requires< DefaultConstructibleConcept >(); Sequence c(n), c2(n, t), c3(first, last); c.insert(p, t); c.insert(p, n, t); c.insert(p, first, last); c.erase(p); c.erase(p, q); reference r = c.front(); ignore_unused_variable_warning(c); ignore_unused_variable_warning(c2); ignore_unused_variable_warning(c3); ignore_unused_variable_warning(r); const_constraints(c); } void const_constraints(const Sequence& c) { const_reference r = c.front(); ignore_unused_variable_warning(r); } typename Sequence::value_type t; typename Sequence::size_type n; typename Sequence::value_type* first, *last; typename Sequence::iterator p, q; }; template struct FrontInsertionSequenceConcept { void constraints() { function_requires< SequenceConcept >(); c.push_front(t); c.pop_front(); } FrontInsertionSequence c; typename FrontInsertionSequence::value_type t; }; template struct BackInsertionSequenceConcept { typedef typename BackInsertionSequence::reference reference; typedef typename BackInsertionSequence::const_reference const_reference; void constraints() { function_requires< SequenceConcept >(); c.push_back(t); c.pop_back(); reference r = c.back(); ignore_unused_variable_warning(r); } void const_constraints(const BackInsertionSequence& c) { const_reference r = c.back(); ignore_unused_variable_warning(r); }; BackInsertionSequence c; typename BackInsertionSequence::value_type t; }; template struct AssociativeContainerConcept { void constraints() { function_requires< ForwardContainerConcept >(); function_requires< DefaultConstructibleConcept >(); i = c.find(k); r = c.equal_range(k); c.erase(k); c.erase(i); c.erase(r.first, r.second); const_constraints(c); } void const_constraints(const AssociativeContainer& c) { ci = c.find(k); n = c.count(k); cr = c.equal_range(k); } typedef typename AssociativeContainer::iterator iterator; typedef typename AssociativeContainer::const_iterator const_iterator; AssociativeContainer c; iterator i; std::pair r; const_iterator ci; std::pair cr; typename AssociativeContainer::key_type k; typename AssociativeContainer::size_type n; }; template struct UniqueAssociativeContainerConcept { void constraints() { function_requires< AssociativeContainerConcept >(); UniqueAssociativeContainer c(first, last); pos_flag = c.insert(t); c.insert(first, last); ignore_unused_variable_warning(c); } std::pair pos_flag; typename UniqueAssociativeContainer::value_type t; typename UniqueAssociativeContainer::value_type* first, *last; }; template struct MultipleAssociativeContainerConcept { void constraints() { function_requires< AssociativeContainerConcept >(); MultipleAssociativeContainer c(first, last); pos = c.insert(t); c.insert(first, last); ignore_unused_variable_warning(c); ignore_unused_variable_warning(pos); } typename MultipleAssociativeContainer::iterator pos; typename MultipleAssociativeContainer::value_type t; typename MultipleAssociativeContainer::value_type* first, *last; }; template struct SimpleAssociativeContainerConcept { void constraints() { function_requires< AssociativeContainerConcept >(); typedef typename SimpleAssociativeContainer::key_type key_type; typedef typename SimpleAssociativeContainer::value_type value_type; typedef typename require_same::type req; } }; template struct PairAssociativeContainerConcept { void constraints() { function_requires< AssociativeContainerConcept >(); typedef typename SimpleAssociativeContainer::key_type key_type; typedef typename SimpleAssociativeContainer::value_type value_type; typedef typename SimpleAssociativeContainer::mapped_type mapped_type; typedef std::pair required_value_type; typedef typename require_same::type req; } }; template struct SortedAssociativeContainerConcept { void constraints() { function_requires< AssociativeContainerConcept >(); function_requires< ReversibleContainerConcept >(); SortedAssociativeContainer c(kc), c2(first, last), c3(first, last, kc); p = c.upper_bound(k); p = c.lower_bound(k); r = c.equal_range(k); c.insert(p, t); ignore_unused_variable_warning(c); ignore_unused_variable_warning(c2); ignore_unused_variable_warning(c3); } void const_constraints(const SortedAssociativeContainer& c) { kc = c.key_comp(); vc = c.value_comp(); cp = c.upper_bound(k); cp = c.lower_bound(k); cr = c.equal_range(k); } typename SortedAssociativeContainer::key_compare kc; typename SortedAssociativeContainer::value_compare vc; typename SortedAssociativeContainer::value_type t; typename SortedAssociativeContainer::key_type k; typedef typename SortedAssociativeContainer::iterator iterator; typedef typename SortedAssociativeContainer::const_iterator const_iterator; iterator p; const_iterator cp; std::pair r; std::pair cr; typename SortedAssociativeContainer::value_type* first, *last; }; // HashedAssociativeContainer } // namespace boost #endif // BOOST_CONCEPT_CHECKS_HPP ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/multi_index_container_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/multi_index_container0000644000175000017500000000722511344301501031755 0ustar debiandebian/* Copyright 2003-2004 Joaquín M López Muñoz. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * * See http://www.boost.org/libs/multi_index for library home page. */ #ifndef BOOST_MULTI_INDEX_FWD_HPP #define BOOST_MULTI_INDEX_FWD_HPP #include /* keep it first to prevent nasty warns in MSVC */ #include #include #include #include namespace boost{ namespace multi_index{ /* Default value for IndexSpecifierList specifies a container * equivalent to std::set. */ template< typename Value, typename IndexSpecifierList=indexed_by > >, typename Allocator=std::allocator > class multi_index_container; template struct nth_index; template struct index; template struct nth_index_iterator; template struct nth_index_const_iterator; template struct index_iterator; template struct index_const_iterator; /* get and project functions not fwd declared due to problems * with dependent typenames */ template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator==( const multi_index_container& x, const multi_index_container& y); template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator<( const multi_index_container& x, const multi_index_container& y); template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator!=( const multi_index_container& x, const multi_index_container& y); template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator>( const multi_index_container& x, const multi_index_container& y); template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator>=( const multi_index_container& x, const multi_index_container& y); template< typename Value1,typename IndexSpecifierList1,typename Allocator1, typename Value2,typename IndexSpecifierList2,typename Allocator2 > bool operator<=( const multi_index_container& x, const multi_index_container& y); template void swap( multi_index_container& x, multi_index_container& y); } /* namespace multi_index */ /* multi_index_container, being the main type of this library, is promoted to * namespace boost. */ using multi_index::multi_index_container; } /* namespace boost */ #endif mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/0000755000175000017500000000000012146213761026244 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/shift_right.hpp0000644000175000017500000000123511344301501031255 0ustar debiandebian #ifndef BOOST_MPL_SHIFT_RIGHT_HPP_INCLUDED #define BOOST_MPL_SHIFT_RIGHT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/shift_right.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME shift_right #define AUX778076_OP_TOKEN >> #include #endif // BOOST_MPL_SHIFT_RIGHT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_fwd.hpp0000644000175000017500000000126111344301501031106 0ustar debiandebian #ifndef BOOST_MPL_INSERT_FWD_HPP_INCLUDED #define BOOST_MPL_INSERT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/insert_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct insert_impl; template< typename Sequence, typename Pos_or_T, typename T > struct insert; }} #endif // BOOST_MPL_INSERT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/apply_fwd.hpp0000644000175000017500000000531711344301501030735 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_APPLY_FWD_HPP_INCLUDED #define BOOST_MPL_APPLY_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/apply_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER apply_fwd.hpp # include #else # include # include # include # include # include # include # include # include // agurt, 15/jan/02: top-level 'apply' template gives an ICE on MSVC // (for known reasons) #if BOOST_WORKAROUND(BOOST_MSVC, <= 1200) # define BOOST_MPL_CFG_NO_APPLY_TEMPLATE #endif namespace boost { namespace mpl { // local macro, #undef-ined at the end of the header # define AUX778076_APPLY_DEF_PARAMS(param, value) \ BOOST_MPL_PP_DEFAULT_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ , value \ ) \ /**/ # define AUX778076_APPLY_N_COMMA_PARAMS(n, param) \ BOOST_PP_COMMA_IF(n) \ BOOST_MPL_PP_PARAMS(n, param) \ /**/ # if !defined(BOOST_MPL_CFG_NO_APPLY_TEMPLATE) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) // forward declaration template< typename F, AUX778076_APPLY_DEF_PARAMS(typename T, na) > struct apply; #else namespace aux { template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser; } #endif # endif // BOOST_MPL_CFG_NO_APPLY_TEMPLATE #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() # undef AUX778076_APPLY_N_COMMA_PARAMS # undef AUX778076_APPLY_DEF_PARAMS }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_APPLY_FWD_HPP_INCLUDED ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) template< typename F AUX778076_APPLY_N_COMMA_PARAMS(i_, typename T) > struct BOOST_PP_CAT(apply,i_); #undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse.hpp0000644000175000017500000000153411344301501030420 0ustar debiandebian #ifndef BOOST_MPL_REVERSE_HPP_INCLUDED #define BOOST_MPL_REVERSE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/reverse.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(Inserter) > struct reverse : reverse_copy< Sequence , Inserter > { }; BOOST_MPL_AUX_NA_SPEC(1, reverse) }} #endif // BOOST_MPL_REVERSE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/contains_fwd.hpp0000644000175000017500000000130511344301501031417 0ustar debiandebian #ifndef BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED #define BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED // Copyright Eric Friedman 2002 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/contains_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct contains_impl; template< typename Sequence, typename T > struct contains; }} #endif // BOOST_MPL_CONTAINS_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/0000755000175000017500000000000012146213760027020 5ustar debiandebianmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/0000755000175000017500000000000012146213760027754 5ustar debiandebian././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/iterator0000644000175000017500000000370711344301502031526 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_ITERATOR_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_ITERATOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/iterator.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Map , long order , long max_order > struct next_order : if_< is_void_< typename item_by_order::type > , next_order , long_ >::type { }; template< typename Map , long max_order > struct next_order : long_ { }; template< typename Map, long order, long max_order > struct m_iter { typedef forward_iterator_tag category; typedef typename item_by_order::type type; }; template< typename Map, long max_order > struct m_iter { typedef forward_iterator_tag category; }; template< typename Map, long order, long max_order > struct next< m_iter > { typedef m_iter< Map , next_order::value , max_order > type; }; template< typename Map, long max_order > struct next< m_iter > { }; }} #endif // BOOST_MPL_MAP_AUX_ITERATOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/include_preprocessed.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/include_0000644000175000017500000000261111344301502031450 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/include_preprocessed.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! #include #include #include #include #include #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # define AUX778076_INCLUDE_DIR typeof_based #elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # define AUX778076_INCLUDE_DIR no_ctps #else # define AUX778076_INCLUDE_DIR plain #endif #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX778076_HEADER \ AUX778076_INCLUDE_DIR/BOOST_MPL_PREPROCESSED_HEADER \ /**/ #else # define AUX778076_HEADER \ BOOST_PP_CAT(AUX778076_INCLUDE_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/map/aux_/preprocessed/AUX778076_HEADER) # undef AUX778076_HEADER # undef AUX778076_INCLUDE_DIR #undef BOOST_MPL_PREPROCESSED_HEADER ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/erase_key_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/erase_ke0000644000175000017500000000257211344301502031452 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_ERASE_KEY_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_ERASE_KEY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/erase_key_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template<> struct erase_key_impl< aux::map_tag > { template< typename Map , typename Key > struct apply : eval_if< has_key_impl::apply , eval_if< is_same< Key,typename Map::key_ > , base , identity< m_mask > > , identity > { }; }; }} #endif // BOOST_MPL_MAP_AUX_ERASE_KEY_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/item.hpp0000644000175000017500000000700711344301502031416 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_ITEM_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_ITEM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/item.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template< typename Key, typename T, typename Base > struct m_item : Base { typedef Key key_; typedef pair item; typedef Base base; typedef typename next< typename Base::size >::type size; typedef typename next< typename Base::order >::type order; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) typedef typename aux::weighted_tag::type order_tag_; #else typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value]; #endif BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, VALUE_BY_KEY, m_item, aux::type_wrapper* ); BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, ITEM_BY_ORDER, m_item, order* ); BOOST_MPL_AUX_MAP_OVERLOAD( order_tag_, ORDER_BY_KEY, m_item, aux::type_wrapper* ); }; template< typename Key, typename Base > struct m_mask : Base { typedef void_ key_; typedef Base base; typedef typename prior< typename Base::size >::type size; typedef typename x_order_impl::type key_order_; BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, VALUE_BY_KEY, m_mask, aux::type_wrapper* ); BOOST_MPL_AUX_MAP_OVERLOAD( aux::type_wrapper, ITEM_BY_ORDER, m_mask, key_order_* ); }; #else // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES template< long n, typename Key, typename T, typename Base > struct m_item; template< typename Key, typename T, typename Base > struct m_item_ : Base { typedef Key key_; typedef Base base; typedef m_item_ type; typedef typename next< typename Base::size >::type size; typedef typename next< typename Base::order >::type order; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) typedef typename aux::weighted_tag::type order_tag_; #else typedef char (&order_tag_)[BOOST_MPL_AUX_MSVC_VALUE_WKND(order)::value]; #endif BOOST_MPL_AUX_MAP_OVERLOAD( order_tag_, ORDER_BY_KEY, m_item_, aux::type_wrapper* ); }; template< typename Key, typename Base > struct m_mask : Base { typedef void_ key_; typedef Base base; typedef typename prior< typename Base::size >::type size; typedef typename x_order_impl::type key_order_; BOOST_MPL_AUX_MAP_OVERLOAD( aux::no_tag, ORDER_BY_KEY, m_mask, aux::type_wrapper* ); BOOST_MPL_AUX_MAP_OVERLOAD( aux::yes_tag, IS_MASKED, m_mask, key_order_* ); }; #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES }} #endif // BOOST_MPL_MAP_AUX_ITEM_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000755000175000017500000000000012146213760031514 5ustar debiandebian././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/typeof_based/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000755000175000017500000000000012146213760031514 5ustar debiandebian././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000001060711344301502031511 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10 > struct map11 : m_item< typename P10::first , typename P10::second , map10< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11 > struct map12 : m_item< typename P11::first , typename P11::second , map11< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12 > struct map13 : m_item< typename P12::first , typename P12::second , map12< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13 > struct map14 : m_item< typename P13::first , typename P13::second , map13< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 > struct map15 : m_item< typename P14::first , typename P14::second , map14< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15 > struct map16 : m_item< typename P15::first , typename P15::second , map15< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16 > struct map17 : m_item< typename P16::first , typename P16::second , map16< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17 > struct map18 : m_item< typename P17::first , typename P17::second , map17< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18 > struct map19 : m_item< typename P18::first , typename P18::second , map18< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 > struct map20 : m_item< typename P19::first , typename P19::second , map19< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18 > > { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000002013711344301502031510 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30 > struct map31 : m_item< typename P30::first , typename P30::second , map30< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31 > struct map32 : m_item< typename P31::first , typename P31::second , map31< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32 > struct map33 : m_item< typename P32::first , typename P32::second , map32< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33 > struct map34 : m_item< typename P33::first , typename P33::second , map33< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 > struct map35 : m_item< typename P34::first , typename P34::second , map34< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35 > struct map36 : m_item< typename P35::first , typename P35::second , map35< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36 > struct map37 : m_item< typename P36::first , typename P36::second , map36< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37 > struct map38 : m_item< typename P37::first , typename P37::second , map37< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38 > struct map39 : m_item< typename P38::first , typename P38::second , map38< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 > struct map40 : m_item< typename P39::first , typename P39::second , map39< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38 > > { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000001436311344301502031514 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20 > struct map21 : m_item< typename P20::first , typename P20::second , map20< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21 > struct map22 : m_item< typename P21::first , typename P21::second , map21< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22 > struct map23 : m_item< typename P22::first , typename P22::second , map22< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23 > struct map24 : m_item< typename P23::first , typename P23::second , map23< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 > struct map25 : m_item< typename P24::first , typename P24::second , map24< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25 > struct map26 : m_item< typename P25::first , typename P25::second , map25< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26 > struct map27 : m_item< typename P26::first , typename P26::second , map26< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27 > struct map28 : m_item< typename P27::first , typename P27::second , map27< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28 > struct map29 : m_item< typename P28::first , typename P28::second , map28< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 > struct map30 : m_item< typename P29::first , typename P29::second , map29< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28 > > { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000002371311344301502031513 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40 > struct map41 : m_item< typename P40::first , typename P40::second , map40< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41 > struct map42 : m_item< typename P41::first , typename P41::second , map41< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42 > struct map43 : m_item< typename P42::first , typename P42::second , map42< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43 > struct map44 : m_item< typename P43::first , typename P43::second , map43< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 > struct map45 : m_item< typename P44::first , typename P44::second , map44< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45 > struct map46 : m_item< typename P45::first , typename P45::second , map45< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46 > struct map47 : m_item< typename P46::first , typename P46::second , map46< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46, typename P47 > struct map48 : m_item< typename P47::first , typename P47::second , map47< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46, typename P47, typename P48 > struct map49 : m_item< typename P48::first , typename P48::second , map48< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46, typename P47, typename P48, typename P49 > struct map50 : m_item< typename P49::first , typename P49::second , map49< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47,P48 > > { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000000512711344301502031512 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename P0 > struct map1 : m_item< typename P0::first , typename P0::second , map0< > > { }; template< typename P0, typename P1 > struct map2 : m_item< typename P1::first , typename P1::second , map1 > { }; template< typename P0, typename P1, typename P2 > struct map3 : m_item< typename P2::first , typename P2::second , map2< P0,P1 > > { }; template< typename P0, typename P1, typename P2, typename P3 > struct map4 : m_item< typename P3::first , typename P3::second , map3< P0,P1,P2 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 > struct map5 : m_item< typename P4::first , typename P4::second , map4< P0,P1,P2,P3 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5 > struct map6 : m_item< typename P5::first , typename P5::second , map5< P0,P1,P2,P3,P4 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6 > struct map7 : m_item< typename P6::first , typename P6::second , map6< P0,P1,P2,P3,P4,P5 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7 > struct map8 : m_item< typename P7::first , typename P7::second , map7< P0,P1,P2,P3,P4,P5,P6 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8 > struct map9 : m_item< typename P8::first , typename P8::second , map8< P0,P1,P2,P3,P4,P5,P6,P7 > > { }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 > struct map10 : m_item< typename P9::first , typename P9::second , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 > > { }; }} ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/plain/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000755000175000017500000000000012146213760031514 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/plain/map20.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000001557511344301502031522 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map20.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Map> struct m_at< Map,10 > { typedef typename Map::item10 type; }; template< typename Key, typename T, typename Base > struct m_item< 11,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item10; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10 > struct map11 : m_item< 11 , typename P10::first , typename P10::second , map10< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9 > > { }; template< typename Map> struct m_at< Map,11 > { typedef typename Map::item11 type; }; template< typename Key, typename T, typename Base > struct m_item< 12,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item11; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11 > struct map12 : m_item< 12 , typename P11::first , typename P11::second , map11< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10 > > { }; template< typename Map> struct m_at< Map,12 > { typedef typename Map::item12 type; }; template< typename Key, typename T, typename Base > struct m_item< 13,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item12; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12 > struct map13 : m_item< 13 , typename P12::first , typename P12::second , map12< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11 > > { }; template< typename Map> struct m_at< Map,13 > { typedef typename Map::item13 type; }; template< typename Key, typename T, typename Base > struct m_item< 14,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item13; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13 > struct map14 : m_item< 14 , typename P13::first , typename P13::second , map13< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12 > > { }; template< typename Map> struct m_at< Map,14 > { typedef typename Map::item14 type; }; template< typename Key, typename T, typename Base > struct m_item< 15,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item14; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 > struct map15 : m_item< 15 , typename P14::first , typename P14::second , map14< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13 > > { }; template< typename Map> struct m_at< Map,15 > { typedef typename Map::item15 type; }; template< typename Key, typename T, typename Base > struct m_item< 16,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item15; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15 > struct map16 : m_item< 16 , typename P15::first , typename P15::second , map15< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14 > > { }; template< typename Map> struct m_at< Map,16 > { typedef typename Map::item16 type; }; template< typename Key, typename T, typename Base > struct m_item< 17,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item16; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16 > struct map17 : m_item< 17 , typename P16::first , typename P16::second , map16< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15 > > { }; template< typename Map> struct m_at< Map,17 > { typedef typename Map::item17 type; }; template< typename Key, typename T, typename Base > struct m_item< 18,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item17; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17 > struct map18 : m_item< 18 , typename P17::first , typename P17::second , map17< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16 > > { }; template< typename Map> struct m_at< Map,18 > { typedef typename Map::item18 type; }; template< typename Key, typename T, typename Base > struct m_item< 19,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item18; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18 > struct map19 : m_item< 19 , typename P18::first , typename P18::second , map18< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17 > > { }; template< typename Map> struct m_at< Map,19 > { typedef typename Map::item19 type; }; template< typename Key, typename T, typename Base > struct m_item< 20,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item19; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 > struct map20 : m_item< 20 , typename P19::first , typename P19::second , map19< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18 > > { }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/plain/map40.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000002512511344301502031512 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map40.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Map> struct m_at< Map,30 > { typedef typename Map::item30 type; }; template< typename Key, typename T, typename Base > struct m_item< 31,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item30; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30 > struct map31 : m_item< 31 , typename P30::first , typename P30::second , map30< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29 > > { }; template< typename Map> struct m_at< Map,31 > { typedef typename Map::item31 type; }; template< typename Key, typename T, typename Base > struct m_item< 32,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item31; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31 > struct map32 : m_item< 32 , typename P31::first , typename P31::second , map31< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30 > > { }; template< typename Map> struct m_at< Map,32 > { typedef typename Map::item32 type; }; template< typename Key, typename T, typename Base > struct m_item< 33,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item32; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32 > struct map33 : m_item< 33 , typename P32::first , typename P32::second , map32< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31 > > { }; template< typename Map> struct m_at< Map,33 > { typedef typename Map::item33 type; }; template< typename Key, typename T, typename Base > struct m_item< 34,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item33; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33 > struct map34 : m_item< 34 , typename P33::first , typename P33::second , map33< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32 > > { }; template< typename Map> struct m_at< Map,34 > { typedef typename Map::item34 type; }; template< typename Key, typename T, typename Base > struct m_item< 35,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item34; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 > struct map35 : m_item< 35 , typename P34::first , typename P34::second , map34< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33 > > { }; template< typename Map> struct m_at< Map,35 > { typedef typename Map::item35 type; }; template< typename Key, typename T, typename Base > struct m_item< 36,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item35; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35 > struct map36 : m_item< 36 , typename P35::first , typename P35::second , map35< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34 > > { }; template< typename Map> struct m_at< Map,36 > { typedef typename Map::item36 type; }; template< typename Key, typename T, typename Base > struct m_item< 37,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item36; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36 > struct map37 : m_item< 37 , typename P36::first , typename P36::second , map36< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35 > > { }; template< typename Map> struct m_at< Map,37 > { typedef typename Map::item37 type; }; template< typename Key, typename T, typename Base > struct m_item< 38,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item37; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37 > struct map38 : m_item< 38 , typename P37::first , typename P37::second , map37< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36 > > { }; template< typename Map> struct m_at< Map,38 > { typedef typename Map::item38 type; }; template< typename Key, typename T, typename Base > struct m_item< 39,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item38; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38 > struct map39 : m_item< 39 , typename P38::first , typename P38::second , map38< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37 > > { }; template< typename Map> struct m_at< Map,39 > { typedef typename Map::item39 type; }; template< typename Key, typename T, typename Base > struct m_item< 40,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item39; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 > struct map40 : m_item< 40 , typename P39::first , typename P39::second , map39< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38 > > { }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/plain/map30.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000002135111344301502031507 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map30.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Map> struct m_at< Map,20 > { typedef typename Map::item20 type; }; template< typename Key, typename T, typename Base > struct m_item< 21,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item20; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20 > struct map21 : m_item< 21 , typename P20::first , typename P20::second , map20< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19 > > { }; template< typename Map> struct m_at< Map,21 > { typedef typename Map::item21 type; }; template< typename Key, typename T, typename Base > struct m_item< 22,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item21; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21 > struct map22 : m_item< 22 , typename P21::first , typename P21::second , map21< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20 > > { }; template< typename Map> struct m_at< Map,22 > { typedef typename Map::item22 type; }; template< typename Key, typename T, typename Base > struct m_item< 23,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item22; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22 > struct map23 : m_item< 23 , typename P22::first , typename P22::second , map22< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21 > > { }; template< typename Map> struct m_at< Map,23 > { typedef typename Map::item23 type; }; template< typename Key, typename T, typename Base > struct m_item< 24,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item23; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23 > struct map24 : m_item< 24 , typename P23::first , typename P23::second , map23< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22 > > { }; template< typename Map> struct m_at< Map,24 > { typedef typename Map::item24 type; }; template< typename Key, typename T, typename Base > struct m_item< 25,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item24; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 > struct map25 : m_item< 25 , typename P24::first , typename P24::second , map24< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23 > > { }; template< typename Map> struct m_at< Map,25 > { typedef typename Map::item25 type; }; template< typename Key, typename T, typename Base > struct m_item< 26,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item25; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25 > struct map26 : m_item< 26 , typename P25::first , typename P25::second , map25< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24 > > { }; template< typename Map> struct m_at< Map,26 > { typedef typename Map::item26 type; }; template< typename Key, typename T, typename Base > struct m_item< 27,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item26; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26 > struct map27 : m_item< 27 , typename P26::first , typename P26::second , map26< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25 > > { }; template< typename Map> struct m_at< Map,27 > { typedef typename Map::item27 type; }; template< typename Key, typename T, typename Base > struct m_item< 28,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item27; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27 > struct map28 : m_item< 28 , typename P27::first , typename P27::second , map27< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26 > > { }; template< typename Map> struct m_at< Map,28 > { typedef typename Map::item28 type; }; template< typename Key, typename T, typename Base > struct m_item< 29,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item28; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28 > struct map29 : m_item< 29 , typename P28::first , typename P28::second , map28< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27 > > { }; template< typename Map> struct m_at< Map,29 > { typedef typename Map::item29 type; }; template< typename Key, typename T, typename Base > struct m_item< 30,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item29; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 > struct map30 : m_item< 30 , typename P29::first , typename P29::second , map29< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28 > > { }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/plain/map50.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000003070111344301502031506 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map50.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Map> struct m_at< Map,40 > { typedef typename Map::item40 type; }; template< typename Key, typename T, typename Base > struct m_item< 41,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item40; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40 > struct map41 : m_item< 41 , typename P40::first , typename P40::second , map40< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39 > > { }; template< typename Map> struct m_at< Map,41 > { typedef typename Map::item41 type; }; template< typename Key, typename T, typename Base > struct m_item< 42,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item41; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41 > struct map42 : m_item< 42 , typename P41::first , typename P41::second , map41< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40 > > { }; template< typename Map> struct m_at< Map,42 > { typedef typename Map::item42 type; }; template< typename Key, typename T, typename Base > struct m_item< 43,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item42; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42 > struct map43 : m_item< 43 , typename P42::first , typename P42::second , map42< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41 > > { }; template< typename Map> struct m_at< Map,43 > { typedef typename Map::item43 type; }; template< typename Key, typename T, typename Base > struct m_item< 44,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item43; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43 > struct map44 : m_item< 44 , typename P43::first , typename P43::second , map43< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42 > > { }; template< typename Map> struct m_at< Map,44 > { typedef typename Map::item44 type; }; template< typename Key, typename T, typename Base > struct m_item< 45,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item44; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 > struct map45 : m_item< 45 , typename P44::first , typename P44::second , map44< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43 > > { }; template< typename Map> struct m_at< Map,45 > { typedef typename Map::item45 type; }; template< typename Key, typename T, typename Base > struct m_item< 46,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item45; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45 > struct map46 : m_item< 46 , typename P45::first , typename P45::second , map45< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44 > > { }; template< typename Map> struct m_at< Map,46 > { typedef typename Map::item46 type; }; template< typename Key, typename T, typename Base > struct m_item< 47,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item46; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46 > struct map47 : m_item< 47 , typename P46::first , typename P46::second , map46< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45 > > { }; template< typename Map> struct m_at< Map,47 > { typedef typename Map::item47 type; }; template< typename Key, typename T, typename Base > struct m_item< 48,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item47; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46, typename P47 > struct map48 : m_item< 48 , typename P47::first , typename P47::second , map47< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46 > > { }; template< typename Map> struct m_at< Map,48 > { typedef typename Map::item48 type; }; template< typename Key, typename T, typename Base > struct m_item< 49,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item48; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46, typename P47, typename P48 > struct map49 : m_item< 49 , typename P48::first , typename P48::second , map48< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47 > > { }; template< typename Map> struct m_at< Map,49 > { typedef typename Map::item49 type; }; template< typename Key, typename T, typename Base > struct m_item< 50,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item49; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 , typename P10, typename P11, typename P12, typename P13, typename P14 , typename P15, typename P16, typename P17, typename P18, typename P19 , typename P20, typename P21, typename P22, typename P23, typename P24 , typename P25, typename P26, typename P27, typename P28, typename P29 , typename P30, typename P31, typename P32, typename P33, typename P34 , typename P35, typename P36, typename P37, typename P38, typename P39 , typename P40, typename P41, typename P42, typename P43, typename P44 , typename P45, typename P46, typename P47, typename P48, typename P49 > struct map50 : m_item< 50 , typename P49::first , typename P49::second , map49< P0,P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20,P21,P22,P23,P24,P25,P26,P27,P28,P29,P30,P31,P32,P33,P34,P35,P36,P37,P38,P39,P40,P41,P42,P43,P44,P45,P46,P47,P48 > > { }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preprocessed/plain/map10.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/preproce0000644000175000017500000001203511344301502031506 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map/map10.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Map> struct m_at< Map,0 > { typedef typename Map::item0 type; }; template< typename Key, typename T, typename Base > struct m_item< 1,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item0; }; template< typename P0 > struct map1 : m_item< 1 , typename P0::first , typename P0::second , map0< > > { }; template< typename Map> struct m_at< Map,1 > { typedef typename Map::item1 type; }; template< typename Key, typename T, typename Base > struct m_item< 2,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item1; }; template< typename P0, typename P1 > struct map2 : m_item< 2 , typename P1::first , typename P1::second , map1 > { }; template< typename Map> struct m_at< Map,2 > { typedef typename Map::item2 type; }; template< typename Key, typename T, typename Base > struct m_item< 3,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item2; }; template< typename P0, typename P1, typename P2 > struct map3 : m_item< 3 , typename P2::first , typename P2::second , map2< P0,P1 > > { }; template< typename Map> struct m_at< Map,3 > { typedef typename Map::item3 type; }; template< typename Key, typename T, typename Base > struct m_item< 4,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item3; }; template< typename P0, typename P1, typename P2, typename P3 > struct map4 : m_item< 4 , typename P3::first , typename P3::second , map3< P0,P1,P2 > > { }; template< typename Map> struct m_at< Map,4 > { typedef typename Map::item4 type; }; template< typename Key, typename T, typename Base > struct m_item< 5,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item4; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 > struct map5 : m_item< 5 , typename P4::first , typename P4::second , map4< P0,P1,P2,P3 > > { }; template< typename Map> struct m_at< Map,5 > { typedef typename Map::item5 type; }; template< typename Key, typename T, typename Base > struct m_item< 6,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item5; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5 > struct map6 : m_item< 6 , typename P5::first , typename P5::second , map5< P0,P1,P2,P3,P4 > > { }; template< typename Map> struct m_at< Map,6 > { typedef typename Map::item6 type; }; template< typename Key, typename T, typename Base > struct m_item< 7,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item6; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6 > struct map7 : m_item< 7 , typename P6::first , typename P6::second , map6< P0,P1,P2,P3,P4,P5 > > { }; template< typename Map> struct m_at< Map,7 > { typedef typename Map::item7 type; }; template< typename Key, typename T, typename Base > struct m_item< 8,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item7; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7 > struct map8 : m_item< 8 , typename P7::first , typename P7::second , map7< P0,P1,P2,P3,P4,P5,P6 > > { }; template< typename Map> struct m_at< Map,8 > { typedef typename Map::item8 type; }; template< typename Key, typename T, typename Base > struct m_item< 9,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item8; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8 > struct map9 : m_item< 9 , typename P8::first , typename P8::second , map8< P0,P1,P2,P3,P4,P5,P6,P7 > > { }; template< typename Map> struct m_at< Map,9 > { typedef typename Map::item9 type; }; template< typename Key, typename T, typename Base > struct m_item< 10,Key,T,Base > : m_item_< Key,T,Base > { typedef pair< Key,T > item9; }; template< typename P0, typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6, typename P7, typename P8, typename P9 > struct map10 : m_item< 10 , typename P9::first , typename P9::second , map9< P0,P1,P2,P3,P4,P5,P6,P7,P8 > > { }; }} ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/key_type_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/key_type0000644000175000017500000000160111344301502031515 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_KEY_TYPE_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_KEY_TYPE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/key_type_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct key_type_impl< aux::map_tag > { template< typename Map, typename T > struct apply : first { }; }; }} #endif // BOOST_MPL_MAP_AUX_KEY_TYPE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/empty_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/empty_im0000644000175000017500000000151611344301502031514 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_EMPTY_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_EMPTY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/empty_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct empty_impl< aux::map_tag > { template< typename Map > struct apply : not_< typename Map::size > { }; }; }} #endif // BOOST_MPL_MAP_AUX_EMPTY_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/contains_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/contains0000644000175000017500000000215511344301502031507 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_CONTAINS_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_CONTAINS_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/contains_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template<> struct contains_impl< aux::map_tag > { template< typename Map, typename Pair > struct apply : is_same< typename at_impl::apply< Map , typename Pair::first >::type , typename Pair::second > { }; }; }} #endif // BOOST_MPL_MAP_AUX_CONTAINS_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/tag.hpp0000644000175000017500000000120411344301502031224 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/tag.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { namespace aux { struct map_tag; }}} #endif // BOOST_MPL_MAP_AUX_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/numbered.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/numbered0000644000175000017500000000366111344301502031475 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if !defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/numbered.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #else #include #include #include #include #define i_ BOOST_PP_FRAME_ITERATION(1) # define AUX778076_MAP_TAIL(map, i_, P) \ BOOST_PP_CAT(map,i_)< \ BOOST_PP_ENUM_PARAMS(i_, P) \ > \ /**/ #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template< BOOST_PP_ENUM_PARAMS(i_, typename P) > struct BOOST_PP_CAT(map,i_) : m_item< typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::first , typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::second , AUX778076_MAP_TAIL(map,BOOST_PP_DEC(i_),P) > { }; #else // "brute force" implementation template< typename Map> struct m_at { typedef typename Map::BOOST_PP_CAT(item,BOOST_PP_DEC(i_)) type; }; template< typename Key, typename T, typename Base > struct m_item : m_item_ { typedef pair BOOST_PP_CAT(item,BOOST_PP_DEC(i_)); }; template< BOOST_PP_ENUM_PARAMS(i_, typename P) > struct BOOST_PP_CAT(map,i_) : m_item< i_ , typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::first , typename BOOST_PP_CAT(P,BOOST_PP_DEC(i_))::second , AUX778076_MAP_TAIL(map,BOOST_PP_DEC(i_),P) > { }; #endif // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES # undef AUX778076_MAP_TAIL #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/value_type_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/value_ty0000644000175000017500000000161611344301502031522 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/value_type_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct value_type_impl< aux::map_tag > { template< typename Map, typename T > struct apply : second { }; }; }} #endif // BOOST_MPL_MAP_AUX_VALUE_TYPE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/has_key_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/has_key_0000644000175000017500000000226211344301502031452 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_HAS_KEY_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_HAS_KEY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/has_key_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template<> struct has_key_impl< aux::map_tag > { template< typename Map, typename Key > struct apply #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) : is_not_void_< typename at_impl ::apply::type > #else : bool_< ( x_order_impl::value > 1 ) > #endif { }; }; }} #endif // BOOST_MPL_MAP_AUX_HAS_KEY_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/erase_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/erase_im0000644000175000017500000000200711344301502031451 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_ERASE_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_ERASE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/erase_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct erase_impl< aux::map_tag > { template< typename Map , typename Pos , typename unused_ > struct apply : erase_key_impl ::apply { }; }; }} #endif // BOOST_MPL_MAP_AUX_ERASE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/begin_end_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/begin_en0000644000175000017500000000250411344301502031435 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_BEGIN_END_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_BEGIN_END_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/begin_end_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct begin_impl< aux::map_tag > { template< typename Map > struct apply { typedef typename next< typename Map::order >::type max_order_; typedef m_iter< Map , next_order::value , max_order_::value > type; }; }; template<> struct end_impl< aux::map_tag > { template< typename Map > struct apply { typedef typename next< typename Map::order >::type max_order_; typedef m_iter< Map,max_order_::value,max_order_::value > type; }; }; }} #endif // BOOST_MPL_MAP_AUX_BEGIN_END_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/map0.hpp0000644000175000017500000000432611344301502031316 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_MAP0_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_MAP0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/map0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) # define BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T) \ friend R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ /**/ # define BOOST_MPL_AUX_MAP_OVERLOAD(R, f, X, T) \ BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T) \ /**/ #else # define BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T) \ static R BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f)(X const&, T) \ /**/ # define BOOST_MPL_AUX_MAP_OVERLOAD(R, f, X, T) \ BOOST_MPL_AUX_MAP0_OVERLOAD(R, f, X, T); \ using Base::BOOST_PP_CAT(BOOST_MPL_AUX_OVERLOAD_,f) \ /**/ #endif template< typename Dummy = na > struct map0 { typedef map0 type; typedef aux::map_tag tag; typedef void_ key_; typedef long_<1> order; typedef long_<0> size; #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) BOOST_MPL_AUX_MAP0_OVERLOAD( aux::type_wrapper, VALUE_BY_KEY, map0<>, void const volatile* ); BOOST_MPL_AUX_MAP0_OVERLOAD( aux::type_wrapper, ITEM_BY_ORDER, map0<>, long_<1>* ); BOOST_MPL_AUX_MAP0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, map0<>, void const volatile* ); #else BOOST_MPL_AUX_MAP0_OVERLOAD( aux::no_tag, ORDER_BY_KEY, map0<>, void const volatile* ); BOOST_MPL_AUX_MAP0_OVERLOAD( aux::no_tag, IS_MASKED, map0<>, void const volatile* ); #endif }; }} #endif // BOOST_MPL_MAP_AUX_MAP0_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/clear_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/clear_im0000644000175000017500000000156611344301502031451 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_CLEAR_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_CLEAR_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/clear_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct clear_impl< aux::map_tag > { template< typename Map > struct apply { typedef map0<> type; }; }; }} #endif // BOOST_MPL_MAP_AUX_CLEAR_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/at_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/at_impl.0000644000175000017500000000610411344301502031372 0ustar debiandebian #ifndef BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED #define BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/at_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #if !defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) # include # include # include # include #endif namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) template< typename Map, typename Key > struct m_at { typedef aux::type_wrapper key_; typedef __typeof__( BOOST_MPL_AUX_OVERLOAD_CALL_VALUE_BY_KEY( Map , BOOST_MPL_AUX_STATIC_CAST(key_*, 0) ) ) type; }; template<> struct at_impl< aux::map_tag > { template< typename Map, typename Key > struct apply : aux::wrapped_type< typename m_at< Map , Key >::type > { }; }; // agurt 31/jan/04: two-step implementation for the sake of GCC 3.x template< typename Map, long order > struct item_by_order_impl { typedef __typeof__( BOOST_MPL_AUX_OVERLOAD_CALL_ITEM_BY_ORDER( Map , BOOST_MPL_AUX_STATIC_CAST(long_*, 0) ) ) type; }; template< typename Map, long order > struct item_by_order : aux::wrapped_type< typename item_by_order_impl::type > { }; #else // BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES template< typename Map, long n > struct m_at { typedef void_ type; }; template<> struct at_impl< aux::map_tag > { template< typename Map, typename Key > struct apply { typedef typename m_at< Map, (x_order_impl::value - 2) >::type item_; typedef typename eval_if< is_void_ , void_ , second >::type type; }; }; template< typename Map, long order > struct is_item_masked { BOOST_STATIC_CONSTANT(bool, value = sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED( Map , BOOST_MPL_AUX_STATIC_CAST(long_*, 0) ) ) == sizeof(aux::yes_tag) ); }; template< typename Map, long order > struct item_by_order { typedef typename eval_if_c< is_item_masked::value , void_ , m_at >::type type; }; #endif }} #endif // BOOST_MPL_SET_AUX_AT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/size_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/size_imp0000644000175000017500000000143211344301502031505 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_SIZE_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_SIZE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/size_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct size_impl< aux::map_tag > { template< typename Map > struct apply : Map::size { }; }; }} #endif // BOOST_MPL_MAP_AUX_SIZE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/insert_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/insert_i0000644000175000017500000000325311344301502031505 0ustar debiandebian #ifndef BOOST_MPL_MAP_AUX_INSERT_IMPL_HPP_INCLUDED #define BOOST_MPL_MAP_AUX_INSERT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/aux_/insert_impl.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Map, typename Pair > struct map_insert_impl : if_< contains_impl::apply , Map #if defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) , m_item< typename Pair::first , typename Pair::second , Map > #else , m_item< ( Map::size::value + 1 ) , typename Pair::first , typename Pair::second , Map > #endif > { }; } template<> struct insert_impl< aux::map_tag > { template< typename Map , typename PosOrKey , typename KeyOrNA > struct apply : aux::map_insert_impl< Map , typename if_na::type > { }; }; }} #endif // BOOST_MPL_MAP_AUX_INSERT_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map20.hpp0000644000175000017500000000223711344301502030443 0ustar debiandebian #ifndef BOOST_MPL_MAP_MAP20_HPP_INCLUDED #define BOOST_MPL_MAP_MAP20_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map20.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER map20.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(11, 20, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_MAP_MAP20_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map40.hpp0000644000175000017500000000223711344301502030445 0ustar debiandebian #ifndef BOOST_MPL_MAP_MAP40_HPP_INCLUDED #define BOOST_MPL_MAP_MAP40_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map40.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER map40.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(31, 40, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_MAP_MAP40_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map0.hpp0000644000175000017500000000245011344301502030356 0ustar debiandebian #ifndef BOOST_MPL_MAP_MAP0_HPP_INCLUDED #define BOOST_MPL_MAP_MAP0_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map0.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include //#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #endif // BOOST_MPL_MAP_MAP0_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map30.hpp0000644000175000017500000000223711344301502030444 0ustar debiandebian #ifndef BOOST_MPL_MAP_MAP30_HPP_INCLUDED #define BOOST_MPL_MAP_MAP30_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map30.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER map30.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(21, 30, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_MAP_MAP30_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map50.hpp0000644000175000017500000000223711344301502030446 0ustar debiandebian #ifndef BOOST_MPL_MAP_MAP50_HPP_INCLUDED #define BOOST_MPL_MAP_MAP50_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map50.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER map50.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(41, 50, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_MAP_MAP50_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map10.hpp0000644000175000017500000000223511344301502030440 0ustar debiandebian #ifndef BOOST_MPL_MAP_MAP10_HPP_INCLUDED #define BOOST_MPL_MAP_MAP10_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/map/map10.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER map10.hpp # include #else # include namespace boost { namespace mpl { # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, 10, )) # include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_MAP_MAP10_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/less.hpp0000644000175000017500000000114111344301501027705 0ustar debiandebian #ifndef BOOST_MPL_LESS_HPP_INCLUDED #define BOOST_MPL_LESS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/less.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME less #define AUX778076_OP_TOKEN < #include #endif // BOOST_MPL_LESS_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/size_t.hpp0000644000175000017500000000131511344301501030237 0ustar debiandebian #ifndef BOOST_MPL_SIZE_T_HPP_INCLUDED #define BOOST_MPL_SIZE_T_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/size_t.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #define AUX_WRAPPER_VALUE_TYPE std::size_t #define AUX_WRAPPER_NAME size_t #define AUX_WRAPPER_PARAMS(N) std::size_t N #include #endif // BOOST_MPL_SIZE_T_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/max.hpp0000644000175000017500000000102111344301501027521 0ustar debiandebian #ifndef BOOST_MPL_MAX_HPP_INCLUDED #define BOOST_MPL_MAX_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/max.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_MAX_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/min_element.hpp0000644000175000017500000000163011344301501031236 0ustar debiandebian #ifndef BOOST_MPL_MIN_ELEMENT_HPP_INCLUDED #define BOOST_MPL_MIN_ELEMENT_HPP_INCLUDED // Copyright David Abrahams 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/min_element.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { BOOST_MPL_AUX_COMMON_NAME_WKND(min_element) template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename Predicate = less<_,_> > struct min_element : max_element< Sequence , mpl::not_ > { }; BOOST_MPL_AUX_NA_SPEC(1, min_element) }} #endif // BOOST_MPL_MIN_ELEMENT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/count.hpp0000644000175000017500000000203411344301501030071 0ustar debiandebian #ifndef BOOST_MPL_COUNT_HPP_INCLUDED #define BOOST_MPL_COUNT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/count.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) > struct count : count_impl< typename sequence_tag::type > ::template apply { BOOST_MPL_AUX_LAMBDA_SUPPORT(2,count,(Sequence,T)) }; BOOST_MPL_AUX_NA_SPEC(2, count) }} #endif // BOOST_MPL_COUNT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/long_fwd.hpp0000644000175000017500000000142211344301501030540 0ustar debiandebian #ifndef BOOST_MPL_LONG_FWD_HPP_INCLUDED #define BOOST_MPL_LONG_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/long_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct long_; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(long_) #endif // BOOST_MPL_LONG_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/void.hpp0000644000175000017500000000325211344301501027705 0ustar debiandebian #ifndef BOOST_MPL_VOID_HPP_INCLUDED #define BOOST_MPL_VOID_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/void.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN // [JDG Feb-4-2003] made void_ a complete type to allow it to be // instantiated so that it can be passed in as an object that can be // used to select an overloaded function. Possible use includes signaling // a zero arity functor evaluation call. struct void_ { typedef void_ type; }; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { template< typename T > struct is_void_ : false_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using false_::value; #endif }; template<> struct is_void_ : true_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using true_::value; #endif }; template< typename T > struct is_not_void_ : true_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using true_::value; #endif }; template<> struct is_not_void_ : false_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using false_::value; #endif }; BOOST_MPL_AUX_NA_SPEC(1, is_void_) BOOST_MPL_AUX_NA_SPEC(1, is_not_void_) }} #endif // BOOST_MPL_VOID_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/copy_if.hpp0000644000175000017500000000421211344301501030371 0ustar debiandebian #ifndef BOOST_MPL_COPY_IF_HPP_INCLUDED #define BOOST_MPL_COPY_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/copy_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Operation , typename Predicate > struct copy_if_op { template< typename Sequence, typename T > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : eval_if< typename apply1::type , apply2 , identity > { #else { typedef typename eval_if< typename apply1::type , apply2 , identity >::type type; #endif }; }; template< typename Sequence , typename Predicate , typename Inserter > struct copy_if_impl : fold< Sequence , typename Inserter::state , protect< aux::copy_if_op< typename Inserter::operation , Predicate > > > { }; template< typename Sequence , typename Predicate , typename Inserter > struct reverse_copy_if_impl : reverse_fold< Sequence , typename Inserter::state , protect< aux::copy_if_op< typename Inserter::operation , Predicate > > > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(3, copy_if) }} #endif // BOOST_MPL_COPY_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/0000755000175000017500000000000012146213760027177 5ustar debiandebian././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_apply.hp0000644000175000017500000000155311344301501031502 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_apply.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { #if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false) #else template< typename T, typename fallback_ = false_ > struct has_apply : fallback_ { }; #endif }}} #endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_dtw.hpp0000644000175000017500000000347111344301501031531 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_dtw.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! #include // local macros, #undef-ined at the end of the header #define AUX778076_DTW_PARAMS(param) \ BOOST_MPL_PP_PARAMS(AUX778076_MSVC_DTW_ARITY, param) \ /**/ #define AUX778076_DTW_ORIGINAL_NAME \ AUX778076_MSVC_DTW_ORIGINAL_NAME \ /**/ // warning: not a well-formed C++ // workaround for MSVC 6.5's "dependent template typedef bug" template< typename F> struct AUX778076_MSVC_DTW_NAME { template< bool > struct f_ : F {}; template<> struct f_ { #if AUX778076_MSVC_DTW_ARITY > 0 template< AUX778076_DTW_PARAMS(typename P) > struct AUX778076_DTW_ORIGINAL_NAME { typedef int type; }; }; template< AUX778076_DTW_PARAMS(typename T) > struct result_ : f_< aux::msvc_never_true::value > ::template AUX778076_DTW_ORIGINAL_NAME< AUX778076_DTW_PARAMS(T) > { }; #else template< typename P = int > struct AUX778076_DTW_ORIGINAL_NAME { typedef int type; }; }; template< typename T = int > struct result_ : f_< aux::msvc_never_true::value > ::template AUX778076_DTW_ORIGINAL_NAME<> { }; #endif }; #undef AUX778076_DTW_ORIGINAL_NAME #undef AUX778076_DTW_PARAMS #undef AUX778076_MSVC_DTW_NAME #undef AUX778076_MSVC_DTW_ORIGINAL_NAME #undef AUX778076_MSVC_DTW_ARITY ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arithmetic_op.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arithmetic_o0000644000175000017500000000477111344301501031570 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arithmetic_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include #endif #if !defined(AUX778076_OP_PREFIX) # define AUX778076_OP_PREFIX AUX778076_OP_NAME #endif #include #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp # include #else # include # include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) namespace aux { template< typename T, T n1, T n2 > struct BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd) { BOOST_STATIC_CONSTANT(T, value = (n1 AUX778076_OP_TOKEN n2)); typedef integral_c type; }; } #endif template<> struct AUX778076_OP_IMPL_NAME { template< typename N1, typename N2 > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > #else : aux::BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type #endif { }; }; }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #undef AUX778076_OP_TAG_NAME #undef AUX778076_OP_IMPL_NAME #undef AUX778076_OP_ARITY #undef AUX778076_OP_PREFIX #undef AUX778076_OP_NAME #undef AUX778076_OP_TOKEN ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_support.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_suppo0000644000175000017500000001252311344301501031561 0ustar debiandebian #ifndef BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED #define BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_support.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) /**/ # define BOOST_MPL_AUX_LAMBDA_SUPPORT(i,name,params) /**/ #else # include # include # include # include # include # include # include # include # include # include # include # define BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC(R,typedef_,i,param) \ typedef_ param BOOST_PP_CAT(arg,BOOST_PP_INC(i)); \ /**/ // agurt, 07/mar/03: restore an old revision for the sake of SGI MIPSpro C++ #if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) # define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_ arity; \ BOOST_PP_LIST_FOR_EACH_I_R( \ 1 \ , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ , typedef \ , BOOST_PP_TUPLE_TO_LIST(i,params) \ ) \ struct rebind \ { \ template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ : name< BOOST_MPL_PP_PARAMS(i,U) > \ { \ }; \ }; \ /**/ # define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ /**/ #elif BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) // agurt, 18/jan/03: old EDG-based compilers actually enforce 11.4 para 9 // (in strict mode), so we have to provide an alternative to the // MSVC-optimized implementation # define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_ arity; \ BOOST_PP_LIST_FOR_EACH_I_R( \ 1 \ , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ , typedef \ , BOOST_PP_TUPLE_TO_LIST(i,params) \ ) \ struct rebind; \ /**/ # define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ }; \ template< BOOST_MPL_PP_PARAMS(i,typename T) > \ struct name::rebind \ { \ template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ : name< BOOST_MPL_PP_PARAMS(i,U) > \ { \ }; \ /**/ #else // __EDG_VERSION__ namespace boost { namespace mpl { namespace aux { template< typename T > struct has_rebind_tag; }}} # define BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ typedef BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::int_ arity; \ BOOST_PP_LIST_FOR_EACH_I_R( \ 1 \ , BOOST_MPL_AUX_LAMBDA_SUPPORT_ARG_TYPEDEF_FUNC \ , typedef \ , BOOST_PP_TUPLE_TO_LIST(i,params) \ ) \ friend class BOOST_PP_CAT(name,_rebind); \ typedef BOOST_PP_CAT(name,_rebind) rebind; \ /**/ #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ template< BOOST_MPL_PP_PARAMS(i,typename T) > \ ::boost::mpl::aux::yes_tag operator|( \ ::boost::mpl::aux::has_rebind_tag \ , name* \ ); \ ::boost::mpl::aux::no_tag operator|( \ ::boost::mpl::aux::has_rebind_tag \ , name< BOOST_MPL_PP_ENUM(i,::boost::mpl::na) >* \ ); \ /**/ #elif !BOOST_WORKAROUND(BOOST_MSVC, <= 1200) # define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ template< BOOST_MPL_PP_PARAMS(i,typename T) > \ ::boost::mpl::aux::yes_tag operator|( \ ::boost::mpl::aux::has_rebind_tag \ , ::boost::mpl::aux::has_rebind_tag< name >* \ ); \ /**/ #else # define BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) /**/ #endif # if !defined(__BORLANDC__) # define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ }; \ BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ class BOOST_PP_CAT(name,_rebind) \ { \ public: \ template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ : name< BOOST_MPL_PP_PARAMS(i,U) > \ { \ }; \ /**/ # else # define BOOST_MPL_AUX_LAMBDA_SUPPORT(i, name, params) \ BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(i, name, params) \ }; \ BOOST_MPL_AUX_LAMBDA_SUPPORT_HAS_REBIND(i, name, params) \ class BOOST_PP_CAT(name,_rebind) \ { \ public: \ template< BOOST_MPL_PP_PARAMS(i,typename U) > struct apply \ { \ typedef typename name< BOOST_MPL_PP_PARAMS(i,U) >::type type; \ }; \ /**/ # endif // __BORLANDC__ #endif // __EDG_VERSION__ #endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT #endif // BOOST_MPL_AUX_LAMBDA_SUPPORT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/pop_front_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/pop_front_im0000644000175000017500000000224711344301501031610 0ustar debiandebian #ifndef BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/pop_front_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { // no default implementation; the definition is needed to make MSVC happy template< typename Tag > struct pop_front_impl { template< typename Sequence > struct apply // conservatively placed, but maybe should go outside surrounding // braces. #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) { typedef int type; } #endif ; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, pop_front_impl) }} #endif // BOOST_MPL_AUX_POP_FRONT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/value_wknd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/value_wknd.h0000644000175000017500000000352211344301501031477 0ustar debiandebian #ifndef BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED #define BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/value_wknd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \ || defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) # include namespace boost { namespace mpl { namespace aux { template< typename C_ > struct value_wknd : C_ { }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) template<> struct value_wknd : int_<1> { using int_<1>::value; }; #endif }}} #if !defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) # define BOOST_MPL_AUX_VALUE_WKND(C) \ ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::aux::value_wknd< C > \ /**/ # define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) BOOST_MPL_AUX_VALUE_WKND(C) #else # define BOOST_MPL_AUX_VALUE_WKND(C) C # define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) \ ::boost::mpl::aux::value_wknd< C > \ /**/ #endif #else // BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS # define BOOST_MPL_AUX_VALUE_WKND(C) C # define BOOST_MPL_AUX_MSVC_VALUE_WKND(C) C #endif #if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) # define BOOST_MPL_AUX_NESTED_VALUE_WKND(T, C) \ BOOST_MPL_AUX_STATIC_CAST(T, C::value) \ /**/ #else # define BOOST_MPL_AUX_NESTED_VALUE_WKND(T, C) \ BOOST_MPL_AUX_VALUE_WKND(C)::value \ /**/ #endif #endif // BOOST_MPL_AUX_VALUE_WKND_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/ptr_to_ref.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/ptr_to_ref.h0000644000175000017500000000212111344301501031475 0ustar debiandebian #ifndef BOOST_MPL_AUX_PTR_TO_REF_HPP_INCLUDED #define BOOST_MPL_AUX_PTR_TO_REF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/ptr_to_ref.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) # define BOOST_MPL_AUX_PTR_TO_REF(X) \ *BOOST_MPL_AUX_STATIC_CAST(X*, 0) \ /**/ #else # define BOOST_MPL_AUX_PTR_TO_REF(X) \ aux::ptr_to_ref(BOOST_MPL_AUX_STATIC_CAST(X*, 0)) \ /**/ #endif namespace boost { namespace mpl { namespace aux { template< typename T > static T const& ptr_to_ref(T*); }}} #endif // BOOST_MPL_AUX_PTR_TO_REF_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/adl_barrier.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/adl_barrier.0000644000175000017500000000320511344301501031434 0ustar debiandebian #ifndef BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED #define BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/adl_barrier.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) # define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE mpl_ # define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace mpl_ { # define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE } # define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) \ namespace boost { namespace mpl { \ using ::BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::type; \ } } \ /**/ #if !defined(BOOST_MPL_PREPROCESSING_MODE) namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE { namespace aux {} } namespace boost { namespace mpl { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE; namespace aux { using namespace BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::aux; } }} #endif #else // BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE # define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE boost::mpl # define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN namespace boost { namespace mpl { # define BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE }} # define BOOST_MPL_AUX_ADL_BARRIER_DECL(type) /**/ #endif #endif // BOOST_MPL_AUX_ADL_BARRIER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_impl_body.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_impl_bo0000644000175000017500000002153311344301501031541 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if !defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_impl_body.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ # include # include # include # include # include # include # include # include # include // local macros, #undef-ined at the end of the header # define AUX778076_ITER_FOLD_STEP(unused, i, unused2) \ typedef typename apply2< \ ForwardOp \ , BOOST_PP_CAT(state,i) \ , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,i)) \ >::type BOOST_PP_CAT(state,BOOST_PP_INC(i)); \ typedef typename mpl::next::type \ BOOST_PP_CAT(iter,BOOST_PP_INC(i)); \ /**/ # define AUX778076_FOLD_IMPL_NAME \ BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \ /**/ # define AUX778076_FOLD_CHUNK_NAME \ BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \ /**/ namespace boost { namespace mpl { namespace aux { /// forward declaration template< BOOST_MPL_AUX_NTTP_DECL(int, N) , typename First , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) # include BOOST_PP_ITERATE() // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING template< BOOST_MPL_AUX_NTTP_DECL(int, N) , typename First , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME { typedef AUX778076_FOLD_IMPL_NAME< BOOST_MPL_LIMIT_UNROLLING , First , Last , State , ForwardOp > chunk_; typedef AUX778076_FOLD_IMPL_NAME< ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; // fallback implementation for sequences of unknown size template< typename First , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,ForwardOp> : AUX778076_FOLD_IMPL_NAME< -1 , typename mpl::next::type , Last , typename apply2::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,ForwardOp> { typedef State state; typedef Last iterator; }; # else // BOOST_WORKAROUND(__BORLANDC__, < 0x600) // Borland have some serious problems with the unrolled version, so // we always use a basic implementation template< BOOST_MPL_AUX_NTTP_DECL(int, N) , typename First , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME { typedef AUX778076_FOLD_IMPL_NAME< -1 , typename mpl::next::type , Last , typename apply2::type , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; typedef state type; }; template< BOOST_MPL_AUX_NTTP_DECL(int, N) , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME { typedef State state; typedef Last iterator; typedef state type; }; # endif // BOOST_WORKAROUND(__BORLANDC__, < 0x600) #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct AUX778076_FOLD_CHUNK_NAME; # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) # include BOOST_PP_ITERATE() // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct AUX778076_FOLD_CHUNK_NAME { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef AUX778076_FOLD_IMPL_NAME< BOOST_MPL_LIMIT_UNROLLING , First , Last , State , ForwardOp > chunk_; typedef AUX778076_FOLD_IMPL_NAME< ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; // fallback implementation for sequences of unknown size template< typename First , typename Last , typename State , typename ForwardOp > struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step); template< typename Last , typename State > struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) { typedef Last iterator; typedef State state; }; template<> struct AUX778076_FOLD_CHUNK_NAME<-1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same::type , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) /// ETI workaround template<> struct result_ { typedef int state; typedef int iterator; }; #endif }; template< typename First , typename Last , typename State , typename ForwardOp > struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) { // can't inherit here - it breaks MSVC 7.0 typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_< typename mpl::next::type , Last , typename apply2::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< BOOST_MPL_AUX_NTTP_DECL(int, N) , typename First , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME : AUX778076_FOLD_CHUNK_NAME ::template result_ { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION }}} # undef AUX778076_FOLD_IMPL_NAME # undef AUX778076_FOLD_CHUNK_NAME # undef AUX778076_ITER_FOLD_STEP #undef AUX778076_FOLD_IMPL_OP #undef AUX778076_FOLD_IMPL_NAME_PREFIX ///// iteration #else # define n_ BOOST_PP_FRAME_ITERATION(1) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename First , typename Last , typename State , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME { typedef First iter0; typedef State state0; BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused) typedef BOOST_PP_CAT(state,n_) state; typedef BOOST_PP_CAT(iter,n_) iterator; }; #else template<> struct AUX778076_FOLD_CHUNK_NAME { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; BOOST_MPL_PP_REPEAT(n_, AUX778076_ITER_FOLD_STEP, unused) typedef BOOST_PP_CAT(state,n_) state; typedef BOOST_PP_CAT(iter,n_) iterator; }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) /// ETI workaround template<> struct result_ { typedef int state; typedef int iterator; }; #endif }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # undef n_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/push_back_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/push_back_im0000644000175000017500000000310711344301501031535 0ustar debiandebian #ifndef BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/push_back_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { // agurt 05/feb/04: no default implementation; the stub definition is needed // to enable the default 'has_push_back' implementation below template< typename Tag > struct push_back_impl { template< typename Sequence, typename T > struct apply {}; }; template< typename Tag > struct has_push_back_impl { template< typename Seq > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : aux::has_type< push_back > { #else { typedef aux::has_type< push_back > type; BOOST_STATIC_CONSTANT(bool, value = (aux::has_type< push_back >::value) ); #endif }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, push_back_impl) BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, has_push_back_impl) }} #endif // BOOST_MPL_AUX_PUSH_BACK_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/integral_wrapper.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/integral_wra0000644000175000017500000000700611344301501031571 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/integral_wrapper.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! #include #include #include #include #include #include #if !defined(AUX_WRAPPER_NAME) # define AUX_WRAPPER_NAME BOOST_PP_CAT(AUX_WRAPPER_VALUE_TYPE,_) #endif #if !defined(AUX_WRAPPER_PARAMS) # define AUX_WRAPPER_PARAMS(N) BOOST_MPL_AUX_NTTP_DECL(AUX_WRAPPER_VALUE_TYPE, N) #endif #if !defined(AUX_WRAPPER_INST) # if BOOST_WORKAROUND(__MWERKS__, <= 0x2407) # define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< value > # else # define AUX_WRAPPER_INST(value) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::AUX_WRAPPER_NAME< value > # endif #endif BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template< AUX_WRAPPER_PARAMS(N) > struct AUX_WRAPPER_NAME { BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, value = N); // agurt, 08/mar/03: SGI MIPSpro C++ workaround, have to #ifdef because some // other compilers (e.g. MSVC) are not particulary happy about it #if BOOST_WORKAROUND(__EDG_VERSION__, <= 238) typedef struct AUX_WRAPPER_NAME type; #else typedef AUX_WRAPPER_NAME type; #endif typedef AUX_WRAPPER_VALUE_TYPE value_type; typedef integral_c_tag tag; // have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC), // while some other don't like 'value + 1' (Borland), and some don't like // either #if BOOST_WORKAROUND(__EDG_VERSION__, <= 243) private: BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1))); BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1))); public: typedef AUX_WRAPPER_INST(next_value) next; typedef AUX_WRAPPER_INST(prior_value) prior; #elif BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \ || BOOST_WORKAROUND(__HP_aCC, BOOST_TESTED_AT(53800)) typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)) ) next; typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)) ) prior; #else typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value + 1)) ) next; typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior; #endif // enables uniform function call syntax for families of overloaded // functions that return objects of both arithmetic ('int', 'long', // 'double', etc.) and wrapped integral types (for an example, see // "mpl/example/power.cpp") operator AUX_WRAPPER_VALUE_TYPE() const { return static_cast(this->value); } }; #if !defined(BOOST_NO_INCLASS_MEMBER_INITIALIZATION) template< AUX_WRAPPER_PARAMS(N) > AUX_WRAPPER_VALUE_TYPE const AUX_WRAPPER_INST(N)::value; #endif BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE #undef AUX_WRAPPER_NAME #undef AUX_WRAPPER_PARAMS #undef AUX_WRAPPER_INST #undef AUX_WRAPPER_VALUE_TYPE ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/numeric_op.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/numeric_op.h0000644000175000017500000001573511344301501031511 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/numeric_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include # include # include # include # include # include # include #endif #include #if defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ || defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include # include # include # include # include # include # include # include # include # include #if !defined(AUX778076_OP_ARITY) # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # define AUX778076_OP_ARITY BOOST_MPL_LIMIT_METAFUNCTION_ARITY # else # define AUX778076_OP_ARITY 2 # endif #endif #if !defined(AUX778076_OP_IMPL_NAME) # define AUX778076_OP_IMPL_NAME BOOST_PP_CAT(AUX778076_OP_PREFIX,_impl) #endif #if !defined(AUX778076_OP_TAG_NAME) # define AUX778076_OP_TAG_NAME BOOST_PP_CAT(AUX778076_OP_PREFIX,_tag) #endif namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct AUX778076_OP_IMPL_NAME : if_c< ( tag1_ > tag2_ ) #else > struct AUX778076_OP_IMPL_NAME : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) #endif , aux::cast2nd_impl< AUX778076_OP_IMPL_NAME,Tag1,Tag2 > , aux::cast1st_impl< AUX778076_OP_IMPL_NAME,Tag1,Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct AUX778076_OP_IMPL_NAME { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Tag > struct AUX778076_OP_IMPL_NAME { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct AUX778076_OP_IMPL_NAME { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; #else template<> struct AUX778076_OP_IMPL_NAME { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct AUX778076_OP_IMPL_NAME { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; #endif #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && BOOST_WORKAROUND(BOOST_MSVC, != 1200) template< typename T > struct AUX778076_OP_TAG_NAME : tag { }; #else template< typename T > struct AUX778076_OP_TAG_NAME { typedef typename T::tag type; }; #endif #if AUX778076_OP_ARITY == 2 template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct AUX778076_OP_NAME #else # define AUX778076_OP_RIGHT_OPERAND(unused, i, N) , BOOST_PP_CAT(N, BOOST_MPL_PP_ADD(i, 2))> # define AUX778076_OP_N_CALLS(i, N) \ BOOST_MPL_PP_REPEAT( BOOST_PP_DEC(i), BOOST_MPL_PP_REPEAT_IDENTITY_FUNC, AUX778076_OP_NAME< ) \ N1 BOOST_MPL_PP_REPEAT( BOOST_MPL_PP_SUB(i, 1), AUX778076_OP_RIGHT_OPERAND, N ) \ /**/ template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename N, na) > struct AUX778076_OP_NAME : AUX778076_OP_N_CALLS(AUX778076_OP_ARITY, N) { BOOST_MPL_AUX_LAMBDA_SUPPORT( AUX778076_OP_ARITY , AUX778076_OP_NAME , ( BOOST_MPL_PP_PARAMS(AUX778076_OP_ARITY, N) ) ) }; #define BOOST_PP_ITERATION_PARAMS_1 \ (3,( BOOST_PP_DEC(AUX778076_OP_ARITY), 2, )) #include BOOST_PP_ITERATE() # undef AUX778076_OP_N_CALLS # undef AUX778076_OP_RIGHT_OPERAND #endif // AUX778076_OP_ARITY == 2 #if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) : AUX778076_OP_IMPL_NAME< typename AUX778076_OP_TAG_NAME::type , typename AUX778076_OP_TAG_NAME::type >::template apply::type #else : aux::msvc_eti_base< typename apply_wrap2< AUX778076_OP_IMPL_NAME< typename AUX778076_OP_TAG_NAME::type , typename AUX778076_OP_TAG_NAME::type > , N1 , N2 >::type >::type #endif { #if AUX778076_OP_ARITY == 2 BOOST_MPL_AUX_LAMBDA_SUPPORT(2, AUX778076_OP_NAME, (N1, N2)) #else BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( AUX778076_OP_ARITY , AUX778076_OP_NAME , ( BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(2, N, na) ) ) #endif }; BOOST_MPL_AUX_NA_SPEC2(2, AUX778076_OP_ARITY, AUX778076_OP_NAME) }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 # define i_ BOOST_PP_FRAME_ITERATION(1) template< BOOST_MPL_PP_PARAMS(i_, typename N) > struct AUX778076_OP_NAME #if i_ != 2 : AUX778076_OP_N_CALLS(i_, N) { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( AUX778076_OP_ARITY , AUX778076_OP_NAME , ( BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(i_, N, na) ) ) }; #endif # undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/include_preprocessed.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/include_prep0000644000175000017500000000214511344301501031563 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/include_preprocessed.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) # define AUX_PREPROCESSED_HEADER \ BOOST_MPL_CFG_COMPILER_DIR/BOOST_MPL_PREPROCESSED_HEADER \ /**/ #else # define AUX_PREPROCESSED_HEADER \ BOOST_PP_CAT(BOOST_MPL_CFG_COMPILER_DIR,/)##BOOST_MPL_PREPROCESSED_HEADER \ /**/ #endif # include BOOST_PP_STRINGIZE(boost/mpl/aux_/preprocessed/AUX_PREPROCESSED_HEADER) # undef AUX_PREPROCESSED_HEADER #undef BOOST_MPL_PREPROCESSED_HEADER ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/traits_lambda_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/traits_lambd0000644000175000017500000000265511344301501031565 0ustar debiandebian #ifndef BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED #define BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/traits_lambda_spec.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait) /**/ #elif !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) # define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait) \ template<> struct trait \ { \ template< BOOST_MPL_PP_PARAMS(i, typename T) > struct apply \ { \ }; \ }; \ /**/ #else # define BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(i, trait) \ template<> struct trait \ { \ template< BOOST_MPL_PP_PARAMS(i, typename T) > struct apply \ { \ }; \ }; \ template<> struct trait \ { \ template< BOOST_MPL_PP_PARAMS(i, typename T) > struct apply \ { \ typedef int type; \ }; \ }; \ /**/ #endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT #endif // BOOST_MPL_AUX_TRAITS_LAMBDA_SPEC_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/erase_key_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/erase_key_im0000644000175000017500000000153611344301501031551 0ustar debiandebian #ifndef BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/erase_key_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename Tag > struct erase_key_impl { template< typename Sequence, typename Key > struct apply; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, erase_key_impl) }} #endif // BOOST_MPL_AUX_ERASE_KEY_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/common_name_wknd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/common_name_0000644000175000017500000000173411344301501031544 0ustar debiandebian #ifndef BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED #define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/common_name_wknd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if BOOST_WORKAROUND(__BORLANDC__, < 0x561) // agurt, 12/nov/02: to suppress the bogus "Cannot have both a template class // and function named 'xxx'" diagnostic # define BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ namespace name_##wknd { \ template< typename > void name(); \ } \ /**/ #else # define BOOST_MPL_AUX_COMMON_NAME_WKND(name) /**/ #endif // __BORLANDC__ #endif // BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/shift_op.hpp0000644000175000017500000000446111344301501031516 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/shift_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #if !defined(AUX778076_OP_PREFIX) # define AUX778076_OP_PREFIX AUX778076_OP_NAME #endif #define AUX778076_OP_ARITY 2 #include #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp # include #else # include # include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) namespace aux { template< typename T, typename Shift, T n, Shift s > struct BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd) { BOOST_STATIC_CONSTANT(T, value = (n AUX778076_OP_TOKEN s)); typedef integral_c type; }; } #endif template<> struct AUX778076_OP_IMPL_NAME { template< typename N, typename S > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(S)::value ) > #else : aux::BOOST_PP_CAT(AUX778076_OP_PREFIX,_wknd)< typename N::value_type , typename S::value_type , N::value , S::value >::type #endif { }; }; }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #undef AUX778076_OP_TAG_NAME #undef AUX778076_OP_IMPL_NAME #undef AUX778076_OP_ARITY #undef AUX778076_OP_PREFIX #undef AUX778076_OP_NAME #undef AUX778076_OP_TOKEN ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213757031624 5ustar debiandebian././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213755031622 5ustar debiandebian././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000433211344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000376211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421311344301502031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, bool has_type_ > struct quote_impl : T { }; template< typename T > struct quote_impl< T,false > { typedef T type; }; template< template< typename P1 > class F , typename Tag = void_ > struct quote1 { template< typename U1 > struct apply : quote_impl< F , aux::has_type< F >::value > { }; }; template< template< typename P1, typename P2 > class F , typename Tag = void_ > struct quote2 { template< typename U1, typename U2 > struct apply : quote_impl< F< U1,U2 > , aux::has_type< F< U1,U2 > >::value > { }; }; template< template< typename P1, typename P2, typename P3 > class F , typename Tag = void_ > struct quote3 { template< typename U1, typename U2, typename U3 > struct apply : quote_impl< F< U1,U2,U3 > , aux::has_type< F< U1,U2,U3 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename Tag = void_ > struct quote4 { template< typename U1, typename U2, typename U3, typename U4 > struct apply : quote_impl< F< U1,U2,U3,U4 > , aux::has_type< F< U1,U2,U3,U4 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename Tag = void_ > struct quote5 { template< typename U1, typename U2, typename U3, typename U4 , typename U5 > struct apply : quote_impl< F< U1,U2,U3,U4,U5 > , aux::has_type< F< U1,U2,U3,U4,U5 > >::value > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000431311344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000415311344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000542011344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitand_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003411111344301501031606 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct eval_if; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< eval_if,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename eval_if< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , times , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002402411344301501031610 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct eval_if; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< eval_if,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename eval_if< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301501031602 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000615211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000417211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002571711344301501031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001545411344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< int N, typename F > struct apply_wrap_impl0; template< typename F > struct apply_wrap_impl0< 0 , F > { typedef typename F::template apply< /// since the defaults are "lost", we have to pass *something* even for nullary /// metafunction classes na > type; }; template< typename F > struct apply_wrap_impl0< 1 , F > { typedef typename F::template apply< na > type; }; template< typename F > struct apply_wrap_impl0< 2 , F > { typedef typename F::template apply< na, na > type; }; template< typename F > struct apply_wrap_impl0< 3 , F > { typedef typename F::template apply< na, na, na > type; }; template< typename F > struct apply_wrap_impl0< 4 , F > { typedef typename F::template apply< na, na, na, na > type; }; template< typename F > struct apply_wrap_impl0< 5 , F > { typedef typename F::template apply< na, na, na, na, na > type; }; template< typename F > struct apply_wrap0 : apply_wrap_impl0< ::boost::mpl::aux::arity< F,0 >::value , F >::type { }; template< int N, typename F, typename T1 > struct apply_wrap_impl1; template< typename F, typename T1 > struct apply_wrap_impl1< 1 , F , T1 > { typedef typename F::template apply< T1 > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 2 , F , T1 > { typedef typename F::template apply< T1 , na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 3 , F , T1 > { typedef typename F::template apply< T1 , na, na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 4 , F , T1 > { typedef typename F::template apply< T1 , na, na, na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 5 , F , T1 > { typedef typename F::template apply< T1 , na, na, na, na > type; }; template< typename F, typename T1 > struct apply_wrap1 : apply_wrap_impl1< ::boost::mpl::aux::arity< F,1 >::value , F , T1 >::type { }; template< int N, typename F, typename T1, typename T2 > struct apply_wrap_impl2; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 2 , F , T1, T2 > { typedef typename F::template apply< T1, T2 > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 3 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 4 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na, na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 5 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na, na, na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : apply_wrap_impl2< ::boost::mpl::aux::arity< F,2 >::value , F , T1, T2 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 3 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 4 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 , na > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 5 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 , na, na > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : apply_wrap_impl3< ::boost::mpl::aux::arity< F,3 >::value , F , T1, T2, T3 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4< 4 , F , T1, T2, T3, T4 > { typedef typename F::template apply< T1, T2, T3, T4 > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4< 5 , F , T1, T2, T3, T4 > { typedef typename F::template apply< T1, T2, T3, T4 , na > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : apply_wrap_impl4< ::boost::mpl::aux::arity< F,4 >::value , F , T1, T2, T3, T4 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap_impl5; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap_impl5< 5 , F , T1, T2, T3, T4, T5 > { typedef typename F::template apply< T1, T2, T3, T4, T5 > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : apply_wrap_impl5< ::boost::mpl::aux::arity< F,5 >::value , F , T1, T2, T3, T4, T5 >::type { }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235211344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000616711344301501031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , divides , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000046211344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000356211344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value,F, Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitxor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000170411344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct bind; template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000403711344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , minus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436411344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001631411344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000020500000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001507511344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000411511344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , plus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/mwcw/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000406011344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213750031615 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000433211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000376211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000044411344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000431311344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000415311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527511344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1, typename T2, typename T3, typename T4, typename T5 > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitand_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002426311344301501031615 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , times , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001572211344301501031615 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301501031602 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000615211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000417211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002636611344301501031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag , typename Arity > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg,Tag, int_< -1 > > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag , int_<1> > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag , int_<1> > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag , int_<2> > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag , int_<2> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag , int_<3> > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag , int_<3> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag , int_<4> > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag , int_<4> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag , int_<5> > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag , int_<5> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag , int_<6> > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect,Tag, int_<1> > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag , int_<6> > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; template< typename F , typename Tag1 , typename Tag2 , typename Arity > struct lambda< lambda< F,Tag1,Arity > , Tag2 , int_<3> > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef bind1< quote1, typename l1::result_ > arity_; typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3; typedef aux::le_result3 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001545411344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< int N, typename F > struct apply_wrap_impl0; template< typename F > struct apply_wrap_impl0< 0 , F > { typedef typename F::template apply< /// since the defaults are "lost", we have to pass *something* even for nullary /// metafunction classes na > type; }; template< typename F > struct apply_wrap_impl0< 1 , F > { typedef typename F::template apply< na > type; }; template< typename F > struct apply_wrap_impl0< 2 , F > { typedef typename F::template apply< na, na > type; }; template< typename F > struct apply_wrap_impl0< 3 , F > { typedef typename F::template apply< na, na, na > type; }; template< typename F > struct apply_wrap_impl0< 4 , F > { typedef typename F::template apply< na, na, na, na > type; }; template< typename F > struct apply_wrap_impl0< 5 , F > { typedef typename F::template apply< na, na, na, na, na > type; }; template< typename F > struct apply_wrap0 : apply_wrap_impl0< ::boost::mpl::aux::arity< F,0 >::value , F >::type { }; template< int N, typename F, typename T1 > struct apply_wrap_impl1; template< typename F, typename T1 > struct apply_wrap_impl1< 1 , F , T1 > { typedef typename F::template apply< T1 > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 2 , F , T1 > { typedef typename F::template apply< T1 , na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 3 , F , T1 > { typedef typename F::template apply< T1 , na, na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 4 , F , T1 > { typedef typename F::template apply< T1 , na, na, na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 5 , F , T1 > { typedef typename F::template apply< T1 , na, na, na, na > type; }; template< typename F, typename T1 > struct apply_wrap1 : apply_wrap_impl1< ::boost::mpl::aux::arity< F,1 >::value , F , T1 >::type { }; template< int N, typename F, typename T1, typename T2 > struct apply_wrap_impl2; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 2 , F , T1, T2 > { typedef typename F::template apply< T1, T2 > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 3 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 4 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na, na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 5 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na, na, na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : apply_wrap_impl2< ::boost::mpl::aux::arity< F,2 >::value , F , T1, T2 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 3 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 4 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 , na > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 5 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 , na, na > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : apply_wrap_impl3< ::boost::mpl::aux::arity< F,3 >::value , F , T1, T2, T3 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4< 4 , F , T1, T2, T3, T4 > { typedef typename F::template apply< T1, T2, T3, T4 > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4< 5 , F , T1, T2, T3, T4 > { typedef typename F::template apply< T1, T2, T3, T4 , na > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : apply_wrap_impl4< ::boost::mpl::aux::arity< F,4 >::value , F , T1, T2, T3, T4 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap_impl5; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap_impl5< 5 , F , T1, T2, T3, T4, T5 > { typedef typename F::template apply< T1, T2, T3, T4, T5 > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : apply_wrap_impl5< ::boost::mpl::aux::arity< F,5 >::value , F , T1, T2, T3, T4, T5 >::type { }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000520111344301501031604 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1, typename U2, typename U3, typename U4, typename U5 > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000616711344301501031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , divides , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000137711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_< -1 > { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; }}} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000370111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply { typedef typename aux::unpack_args_impl< size::value , F , Args >::type type; }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitxor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000146611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000403711344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , minus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436411344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002124611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< long N > struct reverse_fold_chunk; template<> struct reverse_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step; template< typename Last , typename State > struct reverse_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_fold_null_step< Last,State > , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step { typedef reverse_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl : reverse_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000020400000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002007211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< long N > struct reverse_iter_fold_chunk; template<> struct reverse_iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_iter_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step; template< typename Last , typename State > struct reverse_iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_iter_fold_null_step< Last,State > , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step { typedef reverse_iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl : reverse_iter_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000411511344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , plus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000406011344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213756031623 5ustar debiandebian././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000432411344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_right_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_right_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000162311344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< BOOST_AUX_NTTP_DECL(int, arity_) > struct apply_chooser; } template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000375411344301502031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000427411344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< bool > struct quote_impl { template< typename T > struct result_ : T { }; }; template<> struct quote_impl { template< typename T > struct result_ { typedef T type; }; }; template< template< typename P1 > class F , typename Tag = void_ > struct quote1 { template< typename U1 > struct apply : quote_impl< aux::has_type< F >::value > ::template result_< F > { }; }; template< template< typename P1, typename P2 > class F , typename Tag = void_ > struct quote2 { template< typename U1, typename U2 > struct apply : quote_impl< aux::has_type< F< U1,U2 > >::value > ::template result_< F< U1,U2 > > { }; }; template< template< typename P1, typename P2, typename P3 > class F , typename Tag = void_ > struct quote3 { template< typename U1, typename U2, typename U3 > struct apply : quote_impl< aux::has_type< F< U1,U2,U3 > >::value > ::template result_< F< U1,U2,U3 > > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename Tag = void_ > struct quote4 { template< typename U1, typename U2, typename U3, typename U4 > struct apply : quote_impl< aux::has_type< F< U1,U2,U3,U4 > >::value > ::template result_< F< U1,U2,U3,U4 > > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename Tag = void_ > struct quote5 { template< typename U1, typename U2, typename U3, typename U4 , typename U5 > struct apply : quote_impl< aux::has_type< F< U1,U2,U3,U4,U5 > >::value > ::template result_< F< U1,U2,U3,U4,U5 > > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000430511344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_left_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_left_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000414511344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct not_equal_to_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct not_equal_to_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000630111344301502031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1, bool C2 > struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ : T1, T2 { typedef Derived type_; }; }; template<> struct inherit2_impl< false,true > { template< typename Derived, typename T1, typename T2 > struct result_ : T1 { typedef T1 type_; }; }; template<> struct inherit2_impl< true,false > { template< typename Derived, typename T1, typename T2 > struct result_ : T2 { typedef T2 type_; }; }; template<> struct inherit2_impl< true,true > { template< typename Derived, typename T1, typename T2 > struct result_ { typedef T1 type_; }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : aux::inherit2_impl< is_empty_base::value , is_empty_base::value >::template result_< inherit2< T1,T2 >,T1, T2 > { typedef typename inherit2::type_ type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000437711344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitand_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitand_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitand_ : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitand_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000254711344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_ > struct and_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : false_ { }; }; template<> struct and_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,true_ > { }; }; template<> struct and_impl ::result_< true_,true_,true_,true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003233111344301502031611 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef typename apply_wrap5< T , U1, U2, U3, U4, U5 >::type type; }; }; template< typename T > struct is_bind_template; template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,U1,U2,U3,U4,U5 > { }; template< typename T > struct replace_unnamed_arg_impl { template< typename Arg > struct result_ { typedef Arg next; typedef T type; }; }; template<> struct replace_unnamed_arg_impl< arg< -1 > > { template< typename Arg > struct result_ { typedef typename next::type next; typedef Arg type; }; }; template< typename T, typename Arg > struct replace_unnamed_arg : replace_unnamed_arg_impl::template result_ { }; template< int arity_ > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind< F,T1,T2,T3,T4,T5 >*); template< int N > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F > aux::yes_tag is_bind_helper(bind0*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) namespace aux { template<> struct bind_chooser<0> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind0 type; }; }; } // namespace aux template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1 > aux::yes_tag is_bind_helper(bind1< F,T1 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) namespace aux { template<> struct bind_chooser<1> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind1< F,T1 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2 > aux::yes_tag is_bind_helper(bind2< F,T1,T2 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) namespace aux { template<> struct bind_chooser<2> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind2< F,T1,T2 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3 > aux::yes_tag is_bind_helper(bind3< F,T1,T2,T3 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) namespace aux { template<> struct bind_chooser<3> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind3< F,T1,T2,T3 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 > aux::yes_tag is_bind_helper(bind4< F,T1,T2,T3,T4 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) namespace aux { template<> struct bind_chooser<4> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind4< F,T1,T2,T3,T4 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) namespace aux { template<> struct bind_chooser<5> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind5< F,T1,T2,T3,T4,T5 > type; }; }; } // namespace aux namespace aux { template< typename T > struct is_bind_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_bind_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 > struct bind_count_args { BOOST_STATIC_CONSTANT(int, value = is_bind_arg::value + is_bind_arg::value + is_bind_arg::value + is_bind_arg::value + is_bind_arg::value ); }; } template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : aux::bind_chooser< aux::bind_count_args< T1,T2,T3,T4,T5 >::value >::template result_< F,T1,T2,T3,T4,T5 >::type { }; BOOST_MPL_AUX_ARITY_SPEC( 6 , bind ) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC( 6 , bind ) }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000432011344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct times_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct times_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct times : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, times, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002344111344301502031613 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef typename apply_wrap5< T , U1, U2, U3, U4, U5 >::type type; }; }; template< typename T > struct is_bind_template; template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,U1,U2,U3,U4,U5 > { }; template< int arity_ > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind< F,T1,T2,T3,T4,T5 >*); template< int N > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F > aux::yes_tag is_bind_helper(bind0*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) namespace aux { template<> struct bind_chooser<0> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind0 type; }; }; } // namespace aux template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1 > aux::yes_tag is_bind_helper(bind1< F,T1 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) namespace aux { template<> struct bind_chooser<1> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind1< F,T1 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2 > aux::yes_tag is_bind_helper(bind2< F,T1,T2 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) namespace aux { template<> struct bind_chooser<2> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind2< F,T1,T2 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3 > aux::yes_tag is_bind_helper(bind3< F,T1,T2,T3 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) namespace aux { template<> struct bind_chooser<3> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind3< F,T1,T2,T3 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 > aux::yes_tag is_bind_helper(bind4< F,T1,T2,T3,T4 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) namespace aux { template<> struct bind_chooser<4> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind4< F,T1,T2,T3,T4 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) namespace aux { template<> struct bind_chooser<5> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef bind5< F,T1,T2,T3,T4,T5 > type; }; }; } // namespace aux namespace aux { template< typename T > struct is_bind_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_bind_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 > struct bind_count_args { BOOST_STATIC_CONSTANT(int, value = is_bind_arg::value + is_bind_arg::value + is_bind_arg::value + is_bind_arg::value + is_bind_arg::value ); }; } template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : aux::bind_chooser< aux::bind_count_args< T1,T2,T3,T4,T5 >::value >::template result_< F,T1,T2,T3,T4,T5 >::type { }; BOOST_MPL_AUX_ARITY_SPEC( 6 , bind ) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC( 6 , bind ) }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003173311344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct vector_c_chooser; } namespace aux { template<> struct vector_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_vector_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_vector_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct vector_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c_impl { typedef aux::vector_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::vector_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c : aux::vector_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::vector_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003460011344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct deque_chooser; } namespace aux { template<> struct deque_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef vector0< >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_deque_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_deque_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct deque_count_args { BOOST_STATIC_CONSTANT(int, value = is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque_impl { typedef aux::deque_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::deque_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque : aux::deque_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::deque_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436011344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitor_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitor_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitor_ : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitor_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001057211344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; namespace aux { template<> struct apply_chooser<0> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef apply0< F > type; }; }; } // namespace aux template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; namespace aux { template<> struct apply_chooser<1> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef apply1< F, T1 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; namespace aux { template<> struct apply_chooser<2> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef apply2< F, T1, T2 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; namespace aux { template<> struct apply_chooser<3> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef apply3< F, T1, T2, T3 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; namespace aux { template<> struct apply_chooser<4> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef apply4< F, T1, T2, T3, T4 > type; }; }; } // namespace aux template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; namespace aux { template<> struct apply_chooser<5> { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ { typedef apply5< F, T1, T2, T3, T4, T5 > type; }; }; } // namespace aux namespace aux { template< typename T > struct is_apply_arg { static bool const value = true; }; template<> struct is_apply_arg { static bool const value = false; }; template< typename T1, typename T2, typename T3, typename T4, typename T5 > struct apply_count_args { static int const value = is_apply_arg::value + is_apply_arg::value + is_apply_arg::value + is_apply_arg::value + is_apply_arg::value; }; } template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply : aux::apply_chooser< aux::apply_count_args< T1,T2,T3,T4,T5 >::value >::template result_< F,T1,T2,T3,T4,T5 >::type { }; }} ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000416411344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_equal_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_equal_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002571711344301502031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000221411344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F , typename has_apply_ = typename aux::has_apply::type > struct apply_wrap0 : F::template apply< > { }; template< typename F, typename T1 > struct apply_wrap1 : F::template apply { }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : F::template apply< T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : F::template apply< T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : F::template apply< T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : F::template apply< T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003140611344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct set_c_chooser; } namespace aux { template<> struct set_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_set_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_set_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct set_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c_impl { typedef aux::set_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::set_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c : aux::set_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::set_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000255011344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_ > struct or_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : true_ { }; }; template<> struct or_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,false_ > { }; }; template<> struct or_impl ::result_< false_,false_,false_,false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001273511344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< int N > struct iter_fold_chunk; template<> struct iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; }; template<> struct iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; }; template<> struct iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; }; template<> struct iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; }; template<> struct iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; }; template< int N > struct iter_fold_chunk { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_step; template< typename Last , typename State > struct iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , iter_fold_null_step< Last,State > , iter_fold_step< First,Last,State,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_step { typedef iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl : iter_fold_chunk ::template result_< First,Last,State,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301502031615 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000435611344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct divides_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct divides_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct divides : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, divides, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000137711344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_< -1 > { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; }}} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000437011344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl { template< typename F, typename Args > struct apply; }; template<> struct unpack_args_impl<0> { template< typename F, typename Args > struct apply : apply0< F > { }; }; template<> struct unpack_args_impl<1> { template< typename F, typename Args > struct apply : apply1< F , typename at_c< Args,0 >::type > { }; }; template<> struct unpack_args_impl<2> { template< typename F, typename Args > struct apply : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; }; template<> struct unpack_args_impl<3> { template< typename F, typename Args > struct apply : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; }; template<> struct unpack_args_impl<4> { template< typename F, typename Args > struct apply : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; }; template<> struct unpack_args_impl<5> { template< typename F, typename Args > struct apply : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value > ::template apply< F,Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000437711344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitxor_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitxor_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitxor_ : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitxor_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000170411344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct bind; template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000403111344301502031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001317611344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< int N > struct fold_chunk; template<> struct fold_chunk<0> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; }; template<> struct fold_chunk<1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; }; template<> struct fold_chunk<2> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; }; template<> struct fold_chunk<3> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; }; template<> struct fold_chunk<4> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; }; template< int N > struct fold_chunk { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_step; template< typename Last , typename State > struct fold_null_step { typedef Last iterator; typedef State state; }; template<> struct fold_chunk< -1 > { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , fold_null_step< Last,State > , fold_step< First,Last,State,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_step { typedef fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl : fold_chunk ::template result_< First,Last,State,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003443411344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct list_chooser; } namespace aux { template<> struct list_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef list0< >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_list_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_list_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct list_count_args { BOOST_STATIC_CONSTANT(int, value = is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list_impl { typedef aux::list_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::list_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list : aux::list_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::list_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000432011344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct minus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct minus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct minus : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000435611344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct modulus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct modulus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003432311344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct map_chooser; } namespace aux { template<> struct map_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef map0< >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_map_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_map_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct map_count_args { BOOST_STATIC_CONSTANT(int, value = is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map_impl { typedef aux::map_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::map_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map : aux::map_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::map_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003432311344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct set_chooser; } namespace aux { template<> struct set_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef set0< >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_set_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_set_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct set_count_args { BOOST_STATIC_CONSTANT(int, value = is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set_impl { typedef aux::set_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::set_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set : aux::set_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::set_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020300000000000011560 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002124611344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< long N > struct reverse_fold_chunk; template<> struct reverse_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step; template< typename Last , typename State > struct reverse_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_fold_null_step< Last,State > , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step { typedef reverse_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl : reverse_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000021000000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002007211344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< long N > struct reverse_iter_fold_chunk; template<> struct reverse_iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_iter_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step; template< typename Last , typename State > struct reverse_iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_iter_fold_null_step< Last,State > , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step { typedef reverse_iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl : reverse_iter_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003465611344301502031625 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct vector_chooser; } namespace aux { template<> struct vector_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef vector0< >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_vector_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_vector_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct vector_count_args { BOOST_STATIC_CONSTANT(int, value = is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector_impl { typedef aux::vector_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::vector_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector : aux::vector_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::vector_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003151111344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct list_c_chooser; } namespace aux { template<> struct list_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_list_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_list_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct list_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c_impl { typedef aux::list_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::list_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c : aux::list_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::list_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000410711344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_equal_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_equal_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000430111344301502031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct plus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct plus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct plus : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, plus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000405211344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct equal_to_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct equal_to_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213752031617 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000433211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000376211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421311344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, bool has_type_ > struct quote_impl : T { }; template< typename T > struct quote_impl< T,false > { typedef T type; }; template< template< typename P1 > class F , typename Tag = void_ > struct quote1 { template< typename U1 > struct apply : quote_impl< F , aux::has_type< F >::value > { }; }; template< template< typename P1, typename P2 > class F , typename Tag = void_ > struct quote2 { template< typename U1, typename U2 > struct apply : quote_impl< F< U1,U2 > , aux::has_type< F< U1,U2 > >::value > { }; }; template< template< typename P1, typename P2, typename P3 > class F , typename Tag = void_ > struct quote3 { template< typename U1, typename U2, typename U3 > struct apply : quote_impl< F< U1,U2,U3 > , aux::has_type< F< U1,U2,U3 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename Tag = void_ > struct quote4 { template< typename U1, typename U2, typename U3, typename U4 > struct apply : quote_impl< F< U1,U2,U3,U4 > , aux::has_type< F< U1,U2,U3,U4 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename Tag = void_ > struct quote5 { template< typename U1, typename U2, typename U3, typename U4 , typename U5 > struct apply : quote_impl< F< U1,U2,U3,U4,U5 > , aux::has_type< F< U1,U2,U3,U4,U5 > >::value > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000431311344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000415311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000542011344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitand_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003170511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F, int dummy_ > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, int dummy_ > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1, int dummy_ > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, int dummy_ > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2, int dummy_ > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, int dummy_ > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3, int dummy_ > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, int dummy_ > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , int dummy_ > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , int dummy_ > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, int dummy_ > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, int dummy_ > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , times , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002247211344301501031615 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F, int dummy_ > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, int dummy_ > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1, int dummy_ > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, int dummy_ > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2, int dummy_ > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, int dummy_ > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3, int dummy_ > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, int dummy_ > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , int dummy_ > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , int dummy_ > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, int dummy_ > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, int dummy_ > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301501031602 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000615211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000417211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002475011344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000232611344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F , typename has_apply_ = typename aux::has_apply::type > struct apply_wrap0 : F::template apply< > { }; template< typename F > struct apply_wrap0< F,true_ > : F::apply { }; template< typename F, typename T1 > struct apply_wrap1 : F::template apply { }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : F::template apply< T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : F::template apply< T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : F::template apply< T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : F::template apply< T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000616711344301501031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , divides , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000046211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000356211344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value,F, Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitxor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000207111344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, int dummy_ = 0 > struct bind; template< typename F, int dummy_ = 0 > struct bind0; template< typename F, typename T1, int dummy_ = 0 > struct bind1; template< typename F, typename T1, typename T2, int dummy_ = 0 > struct bind2; template< typename F, typename T1, typename T2, typename T3, int dummy_ = 0 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 , int dummy_ = 0 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, int dummy_ = 0 > struct bind5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000403711344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , minus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436411344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001631411344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000020400000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001507511344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000411511344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , plus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/dmc/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000406011344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213757031624 5ustar debiandebian././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000367511344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421311344301502031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, bool has_type_ > struct quote_impl : T { }; template< typename T > struct quote_impl< T,false > { typedef T type; }; template< template< typename P1 > class F , typename Tag = void_ > struct quote1 { template< typename U1 > struct apply : quote_impl< F , aux::has_type< F >::value > { }; }; template< template< typename P1, typename P2 > class F , typename Tag = void_ > struct quote2 { template< typename U1, typename U2 > struct apply : quote_impl< F< U1,U2 > , aux::has_type< F< U1,U2 > >::value > { }; }; template< template< typename P1, typename P2, typename P3 > class F , typename Tag = void_ > struct quote3 { template< typename U1, typename U2, typename U3 > struct apply : quote_impl< F< U1,U2,U3 > , aux::has_type< F< U1,U2,U3 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename Tag = void_ > struct quote4 { template< typename U1, typename U2, typename U3, typename U4 > struct apply : quote_impl< F< U1,U2,U3,U4 > , aux::has_type< F< U1,U2,U3,U4 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename Tag = void_ > struct quote5 { template< typename U1, typename U2, typename U3, typename U4 , typename U5 > struct apply : quote_impl< F< U1,U2,U3,U4,U5 > , aux::has_type< F< U1,U2,U3,U4,U5 > >::value > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000422011344301502031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000405611344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000464311344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000220211344301502031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003411111344301502031607 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct eval_if; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< eval_if,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename eval_if< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000572211344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002402411344301502031611 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct eval_if; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< eval_if,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename eval_if< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301502031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000600011344301502031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000416111344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000407411344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002571711344301502031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000232611344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F , typename has_apply_ = typename aux::has_apply::type > struct apply_wrap0 : F::template apply< > { }; template< typename F > struct apply_wrap0< F,true_ > : F::apply { }; template< typename F, typename T1 > struct apply_wrap1 : F::template apply { }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : F::template apply< T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : F::template apply< T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : F::template apply< T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : F::template apply< T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000220411344301502031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301502031615 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000601411344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000046211344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000356211344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value,F, Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000170411344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct bind; template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000374711344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301502031604 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000572211344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000427411344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001631411344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000020600000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001507511344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001441611344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000402211344301502031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000566511344301502031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/plain/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000376711344301502031624 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213751031616 5ustar debiandebian././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000433211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000376211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000044411344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000431311344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000415311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000542011344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitand_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002457711344301501031625 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , times , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001623611344301501031616 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301501031602 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000615211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000417211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002636611344301501031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag , typename Arity > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg,Tag, int_< -1 > > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag , int_<1> > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag , int_<1> > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag , int_<2> > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag , int_<2> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag , int_<3> > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag , int_<3> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag , int_<4> > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag , int_<4> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag , int_<5> > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag , int_<5> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag , int_<6> > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect,Tag, int_<1> > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag , int_<6> > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; template< typename F , typename Tag1 , typename Tag2 , typename Arity > struct lambda< lambda< F,Tag1,Arity > , Tag2 , int_<3> > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef bind1< quote1, typename l1::result_ > arity_; typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3; typedef aux::le_result3 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001545411344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< int N, typename F > struct apply_wrap_impl0; template< typename F > struct apply_wrap_impl0< 0 , F > { typedef typename F::template apply< /// since the defaults are "lost", we have to pass *something* even for nullary /// metafunction classes na > type; }; template< typename F > struct apply_wrap_impl0< 1 , F > { typedef typename F::template apply< na > type; }; template< typename F > struct apply_wrap_impl0< 2 , F > { typedef typename F::template apply< na, na > type; }; template< typename F > struct apply_wrap_impl0< 3 , F > { typedef typename F::template apply< na, na, na > type; }; template< typename F > struct apply_wrap_impl0< 4 , F > { typedef typename F::template apply< na, na, na, na > type; }; template< typename F > struct apply_wrap_impl0< 5 , F > { typedef typename F::template apply< na, na, na, na, na > type; }; template< typename F > struct apply_wrap0 : apply_wrap_impl0< ::boost::mpl::aux::arity< F,0 >::value , F >::type { }; template< int N, typename F, typename T1 > struct apply_wrap_impl1; template< typename F, typename T1 > struct apply_wrap_impl1< 1 , F , T1 > { typedef typename F::template apply< T1 > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 2 , F , T1 > { typedef typename F::template apply< T1 , na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 3 , F , T1 > { typedef typename F::template apply< T1 , na, na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 4 , F , T1 > { typedef typename F::template apply< T1 , na, na, na > type; }; template< typename F, typename T1 > struct apply_wrap_impl1< 5 , F , T1 > { typedef typename F::template apply< T1 , na, na, na, na > type; }; template< typename F, typename T1 > struct apply_wrap1 : apply_wrap_impl1< ::boost::mpl::aux::arity< F,1 >::value , F , T1 >::type { }; template< int N, typename F, typename T1, typename T2 > struct apply_wrap_impl2; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 2 , F , T1, T2 > { typedef typename F::template apply< T1, T2 > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 3 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 4 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na, na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap_impl2< 5 , F , T1, T2 > { typedef typename F::template apply< T1, T2 , na, na, na > type; }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : apply_wrap_impl2< ::boost::mpl::aux::arity< F,2 >::value , F , T1, T2 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 3 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 4 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 , na > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap_impl3< 5 , F , T1, T2, T3 > { typedef typename F::template apply< T1, T2, T3 , na, na > type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : apply_wrap_impl3< ::boost::mpl::aux::arity< F,3 >::value , F , T1, T2, T3 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4< 4 , F , T1, T2, T3, T4 > { typedef typename F::template apply< T1, T2, T3, T4 > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap_impl4< 5 , F , T1, T2, T3, T4 > { typedef typename F::template apply< T1, T2, T3, T4 , na > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : apply_wrap_impl4< ::boost::mpl::aux::arity< F,4 >::value , F , T1, T2, T3, T4 >::type { }; template< int N, typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap_impl5; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap_impl5< 5 , F , T1, T2, T3, T4, T5 > { typedef typename F::template apply< T1, T2, T3, T4, T5 > type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : apply_wrap_impl5< ::boost::mpl::aux::arity< F,5 >::value , F , T1, T2, T3, T4, T5 >::type { }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000616711344301501031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , divides , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000137711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_< -1 > { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; }}} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000370111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply { typedef typename aux::unpack_args_impl< size::value , F , Args >::type type; }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitxor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000146611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000403711344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , minus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436411344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002124611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< long N > struct reverse_fold_chunk; template<> struct reverse_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step; template< typename Last , typename State > struct reverse_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_fold_null_step< Last,State > , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step { typedef reverse_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl : reverse_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000020700000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002007211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< long N > struct reverse_iter_fold_chunk; template<> struct reverse_iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_iter_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step; template< typename Last , typename State > struct reverse_iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_iter_fold_null_step< Last,State > , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step { typedef reverse_iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl : reverse_iter_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000411511344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , plus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/bcc551/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000406011344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213754031621 5ustar debiandebian././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000501311344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct shift_right_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_right_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_right_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : aux::msvc_eti_base< typename apply_wrap2< shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { namespace aux { template< typename T, typename Shift, T n, Shift s > struct shift_right_wknd { BOOST_STATIC_CONSTANT(T, value = (n >> s)); typedef integral_c< T,value > type; }; } template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : aux::shift_right_wknd< typename N::value_type , typename S::value_type , N::value , S::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000147511344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000434111344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct less_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : aux::msvc_eti_base< typename apply_wrap2< less_impl< typename less_tag::type , typename less_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000427411344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< bool > struct quote_impl { template< typename T > struct result_ : T { }; }; template<> struct quote_impl { template< typename T > struct result_ { typedef T type; }; }; template< template< typename P1 > class F , typename Tag = void_ > struct quote1 { template< typename U1 > struct apply : quote_impl< aux::has_type< F >::value > ::template result_< F > { }; }; template< template< typename P1, typename P2 > class F , typename Tag = void_ > struct quote2 { template< typename U1, typename U2 > struct apply : quote_impl< aux::has_type< F< U1,U2 > >::value > ::template result_< F< U1,U2 > > { }; }; template< template< typename P1, typename P2, typename P3 > class F , typename Tag = void_ > struct quote3 { template< typename U1, typename U2, typename U3 > struct apply : quote_impl< aux::has_type< F< U1,U2,U3 > >::value > ::template result_< F< U1,U2,U3 > > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename Tag = void_ > struct quote4 { template< typename U1, typename U2, typename U3, typename U4 > struct apply : quote_impl< aux::has_type< F< U1,U2,U3,U4 > >::value > ::template result_< F< U1,U2,U3,U4 > > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename Tag = void_ > struct quote5 { template< typename U1, typename U2, typename U3, typename U4 , typename U5 > struct apply : quote_impl< aux::has_type< F< U1,U2,U3,U4,U5 > >::value > ::template result_< F< U1,U2,U3,U4,U5 > > { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000477211344301501031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct shift_left_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_left_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_left_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : aux::msvc_eti_base< typename apply_wrap2< shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { namespace aux { template< typename T, typename Shift, T n, Shift s > struct shift_left_wknd { BOOST_STATIC_CONSTANT(T, value = (n << s)); typedef integral_c< T,value > type; }; } template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : aux::shift_left_wknd< typename N::value_type , typename S::value_type , N::value , S::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000453211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct not_equal_to_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct not_equal_to_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct not_equal_to_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : aux::msvc_eti_base< typename apply_wrap2< not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000630111344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1, bool C2 > struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ : T1, T2 { typedef Derived type_; }; }; template<> struct inherit2_impl< false,true > { template< typename Derived, typename T1, typename T2 > struct result_ : T1 { typedef T1 type_; }; }; template<> struct inherit2_impl< true,false > { template< typename Derived, typename T1, typename T2 > struct result_ : T2 { typedef T2 type_; }; }; template<> struct inherit2_impl< true,true > { template< typename Derived, typename T1, typename T2 > struct result_ { typedef T1 type_; }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : aux::inherit2_impl< is_empty_base::value , is_empty_base::value >::template result_< inherit2< T1,T2 >,T1, T2 > { typedef typename inherit2::type_ type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000476711344301501031624 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct bitand_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitand_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitand_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitand_ : aux::msvc_eti_base< typename apply_wrap2< bitand_impl< typename bitand_tag::type , typename bitand_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitand_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitand_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitand_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 & n2)); typedef integral_c< T,value > type; }; } template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitand_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000253611344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_ > struct and_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : false_ { }; }; template<> struct and_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,true_ > { }; template<> struct result_< true_,true_,true_,true_ > : true_ { }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002516511344301501031617 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef typename apply_wrap5< T , U1, U2, U3, U4, U5 >::type type; }; }; template< typename T > struct is_bind_template; template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,U1,U2,U3,U4,U5 > { }; template< typename T > struct replace_unnamed_arg_impl { template< typename Arg > struct result_ { typedef Arg next; typedef T type; }; }; template<> struct replace_unnamed_arg_impl< arg< -1 > > { template< typename Arg > struct result_ { typedef typename next::type next; typedef Arg type; }; }; template< typename T, typename Arg > struct replace_unnamed_arg : replace_unnamed_arg_impl::template result_ { }; template< int arity_ > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); template< int N > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F > aux::yes_tag is_bind_helper(bind0*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1 > aux::yes_tag is_bind_helper(bind1< F,T1 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2 > aux::yes_tag is_bind_helper(bind2< F,T1,T2 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3 > aux::yes_tag is_bind_helper(bind3< F,T1,T2,T3 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 > aux::yes_tag is_bind_helper(bind4< F,T1,T2,T3,T4 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000470611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct times_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct times_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct times_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct times : aux::msvc_eti_base< typename apply_wrap2< times_impl< typename times_tag::type , typename times_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, times, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, times) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct times_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 * n2)); typedef integral_c< T,value > type; }; } template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::times_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001627511344301501031621 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef typename apply_wrap5< T , U1, U2, U3, U4, U5 >::type type; }; }; template< typename T > struct is_bind_template; template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,U1,U2,U3,U4,U5 > { }; template< int arity_ > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); template< int N > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F > aux::yes_tag is_bind_helper(bind0*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1 > aux::yes_tag is_bind_helper(bind1< F,T1 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2 > aux::yes_tag is_bind_helper(bind2< F,T1,T2 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3 > aux::yes_tag is_bind_helper(bind3< F,T1,T2,T3 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 > aux::yes_tag is_bind_helper(bind4< F,T1,T2,T3,T4 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003173311344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct vector_c_chooser; } namespace aux { template<> struct vector_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_vector_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_vector_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct vector_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c_impl { typedef aux::vector_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::vector_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c : aux::vector_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::vector_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003460011344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct deque_chooser; } namespace aux { template<> struct deque_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef vector0< >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_deque_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_deque_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct deque_count_args { BOOST_STATIC_CONSTANT(int, value = is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque_impl { typedef aux::deque_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::deque_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque : aux::deque_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::deque_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000474611344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct bitor_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitor_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitor_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitor_ : aux::msvc_eti_base< typename apply_wrap2< bitor_impl< typename bitor_tag::type , typename bitor_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitor_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitor_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitor_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 | n2)); typedef integral_c< T,value > type; }; } template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitor_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000472311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; /// workaround for ETI bug template<> struct apply0 { typedef int type; }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; /// workaround for ETI bug template<> struct apply1< int,int > { typedef int type; }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; /// workaround for ETI bug template<> struct apply2< int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; /// workaround for ETI bug template<> struct apply3< int,int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; /// workaround for ETI bug template<> struct apply4< int,int,int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// workaround for ETI bug template<> struct apply5< int,int,int,int,int,int > { typedef int type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000455111344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct greater_equal_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_equal_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_equal_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : aux::msvc_eti_base< typename apply_wrap2< greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002571711344301501031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000400711344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F , typename has_apply_ = typename aux::has_apply::type > struct apply_wrap0 { typedef typename F::template apply< >::type type; }; /// workaround for ETI bug template<> struct apply_wrap0 { typedef int type; }; template< typename F, typename T1 > struct apply_wrap1 { typedef typename F::template apply< T1 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap1< int,int > { typedef int type; }; template< typename F, typename T1, typename T2 > struct apply_wrap2 { typedef typename F::template apply< T1, T2 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap2< int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 { typedef typename F::template apply< T1, T2, T3 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap3< int,int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 { typedef typename F::template apply< T1, T2, T3, T4 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap4< int,int,int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 { typedef typename F::template apply< T1, T2, T3, T4, T5 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap5< int,int,int,int,int,int > { typedef int type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003140611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct set_c_chooser; } namespace aux { template<> struct set_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_set_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_set_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct set_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c_impl { typedef aux::set_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::set_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c : aux::set_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::set_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000253711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_ > struct or_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : true_ { }; }; template<> struct or_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,false_ > { }; template<> struct result_< false_,false_,false_,false_ > : false_ { }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001273511344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< int N > struct iter_fold_chunk; template<> struct iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; }; template<> struct iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; }; template<> struct iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; }; template<> struct iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; }; template<> struct iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; }; template< int N > struct iter_fold_chunk { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_step; template< typename Last , typename State > struct iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , iter_fold_null_step< Last,State > , iter_fold_step< First,Last,State,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_step { typedef iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl : iter_fold_chunk ::template result_< First,Last,State,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000475011344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct divides_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct divides_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct divides_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct divides : aux::msvc_eti_base< typename apply_wrap2< divides_impl< typename divides_tag::type , typename divides_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, divides, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, divides) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct divides_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 / n2)); typedef integral_c< T,value > type; }; } template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::divides_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000150111344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_< -1 > { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; template<> struct template_arity : mpl::int_< -1 > { }; }}} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000437011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl { template< typename F, typename Args > struct apply; }; template<> struct unpack_args_impl<0> { template< typename F, typename Args > struct apply : apply0< F > { }; }; template<> struct unpack_args_impl<1> { template< typename F, typename Args > struct apply : apply1< F , typename at_c< Args,0 >::type > { }; }; template<> struct unpack_args_impl<2> { template< typename F, typename Args > struct apply : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; }; template<> struct unpack_args_impl<3> { template< typename F, typename Args > struct apply : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; }; template<> struct unpack_args_impl<4> { template< typename F, typename Args > struct apply : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; }; template<> struct unpack_args_impl<5> { template< typename F, typename Args > struct apply : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value > ::template apply< F,Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000476711344301501031624 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct bitxor_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitxor_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitxor_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitxor_ : aux::msvc_eti_base< typename apply_wrap2< bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitxor_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitxor_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitxor_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 ^ n2)); typedef integral_c< T,value > type; }; } template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitxor_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000146611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000441611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct greater_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : aux::msvc_eti_base< typename apply_wrap2< greater_impl< typename greater_tag::type , typename greater_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001317611344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< int N > struct fold_chunk; template<> struct fold_chunk<0> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; }; template<> struct fold_chunk<1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; }; template<> struct fold_chunk<2> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; }; template<> struct fold_chunk<3> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; }; template<> struct fold_chunk<4> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; }; template< int N > struct fold_chunk { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_step; template< typename Last , typename State > struct fold_null_step { typedef Last iterator; typedef State state; }; template<> struct fold_chunk< -1 > { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , fold_null_step< Last,State > , fold_step< First,Last,State,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_step { typedef fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl : fold_chunk ::template result_< First,Last,State,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003443411344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct list_chooser; } namespace aux { template<> struct list_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef list0< >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_list_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_list_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct list_count_args { BOOST_STATIC_CONSTANT(int, value = is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list_impl { typedef aux::list_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::list_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list : aux::list_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::list_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000470611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct minus_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct minus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct minus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct minus : aux::msvc_eti_base< typename apply_wrap2< minus_impl< typename minus_tag::type , typename minus_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, minus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct minus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 - n2)); typedef integral_c< T,value > type; }; } template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::minus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000475011344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct modulus_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct modulus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct modulus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : aux::msvc_eti_base< typename apply_wrap2< modulus_impl< typename modulus_tag::type , typename modulus_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct modulus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 % n2)); typedef integral_c< T,value > type; }; } template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::modulus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003432311344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct map_chooser; } namespace aux { template<> struct map_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef map0< >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_map_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_map_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct map_count_args { BOOST_STATIC_CONSTANT(int, value = is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map_impl { typedef aux::map_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::map_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map : aux::map_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::map_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003432311344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct set_chooser; } namespace aux { template<> struct set_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef set0< >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_set_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_set_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct set_count_args { BOOST_STATIC_CONSTANT(int, value = is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set_impl { typedef aux::set_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::set_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set : aux::set_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::set_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002124611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< long N > struct reverse_fold_chunk; template<> struct reverse_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step; template< typename Last , typename State > struct reverse_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_fold_null_step< Last,State > , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step { typedef reverse_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl : reverse_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000020700000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002007211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< long N > struct reverse_iter_fold_chunk; template<> struct reverse_iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; }; template<> struct reverse_iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; }; template<> struct reverse_iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; }; template<> struct reverse_iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; }; template<> struct reverse_iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; }; template< long N > struct reverse_iter_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step; template< typename Last , typename State > struct reverse_iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_iter_fold_null_step< Last,State > , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step { typedef reverse_iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl : reverse_iter_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003465611344301501031624 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct vector_chooser; } namespace aux { template<> struct vector_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef vector0< >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_vector_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_vector_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct vector_count_args { BOOST_STATIC_CONSTANT(int, value = is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector_impl { typedef aux::vector_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::vector_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector : aux::vector_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::vector_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003151111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct list_c_chooser; } namespace aux { template<> struct list_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_list_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_list_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct list_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c_impl { typedef aux::list_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::list_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c : aux::list_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::list_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000447411344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct less_equal_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_equal_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_equal_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : aux::msvc_eti_base< typename apply_wrap2< less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000466511344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct plus_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct plus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct plus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct plus : aux::msvc_eti_base< typename apply_wrap2< plus_impl< typename plus_tag::type , typename plus_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, plus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, plus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct plus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 + n2)); typedef integral_c< T,value > type; }; } template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::plus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc70/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000443611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct equal_to_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct equal_to_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct equal_to_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag : tag< T,na > { }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : aux::msvc_eti_base< typename apply_wrap2< equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213753031620 5ustar debiandebian././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000503311344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct shift_right_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_right_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_right_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : aux::msvc_eti_base< typename apply_wrap2< shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { namespace aux { template< typename T, typename Shift, T n, Shift s > struct shift_right_wknd { BOOST_STATIC_CONSTANT(T, value = (n >> s)); typedef integral_c< T,value > type; }; } template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : aux::shift_right_wknd< typename N::value_type , typename S::value_type , N::value , S::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000147511344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436111344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct less_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : aux::msvc_eti_base< typename apply_wrap2< less_impl< typename less_tag::type , typename less_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000044411344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000501211344301501031604 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct shift_left_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_left_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct shift_left_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : aux::msvc_eti_base< typename apply_wrap2< shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { namespace aux { template< typename T, typename Shift, T n, Shift s > struct shift_left_wknd { BOOST_STATIC_CONSTANT(T, value = (n << s)); typedef integral_c< T,value > type; }; } template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : aux::shift_left_wknd< typename N::value_type , typename S::value_type , N::value , S::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000455211344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct not_equal_to_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct not_equal_to_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct not_equal_to_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : aux::msvc_eti_base< typename apply_wrap2< not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000630111344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1, bool C2 > struct inherit2_impl { template< typename Derived, typename T1, typename T2 > struct result_ : T1, T2 { typedef Derived type_; }; }; template<> struct inherit2_impl< false,true > { template< typename Derived, typename T1, typename T2 > struct result_ : T1 { typedef T1 type_; }; }; template<> struct inherit2_impl< true,false > { template< typename Derived, typename T1, typename T2 > struct result_ : T2 { typedef T2 type_; }; }; template<> struct inherit2_impl< true,true > { template< typename Derived, typename T1, typename T2 > struct result_ { typedef T1 type_; }; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : aux::inherit2_impl< is_empty_base::value , is_empty_base::value >::template result_< inherit2< T1,T2 >,T1, T2 > { typedef typename inherit2::type_ type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000500711344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct bitand_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitand_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitand_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitand_ : aux::msvc_eti_base< typename apply_wrap2< bitand_impl< typename bitand_tag::type , typename bitand_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitand_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitand_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitand_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 & n2)); typedef integral_c< T,value > type; }; } template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitand_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000254711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_ > struct and_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : false_ { }; }; template<> struct and_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,true_ > { }; }; template<> struct and_impl ::result_< true_,true_,true_,true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002516511344301501031617 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef typename apply_wrap5< T , U1, U2, U3, U4, U5 >::type type; }; }; template< typename T > struct is_bind_template; template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,U1,U2,U3,U4,U5 > { }; template< typename T > struct replace_unnamed_arg_impl { template< typename Arg > struct result_ { typedef Arg next; typedef T type; }; }; template<> struct replace_unnamed_arg_impl< arg< -1 > > { template< typename Arg > struct result_ { typedef typename next::type next; typedef Arg type; }; }; template< typename T, typename Arg > struct replace_unnamed_arg : replace_unnamed_arg_impl::template result_ { }; template< int arity_ > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); template< int N > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F > aux::yes_tag is_bind_helper(bind0*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1 > aux::yes_tag is_bind_helper(bind1< F,T1 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2 > aux::yes_tag is_bind_helper(bind2< F,T1,T2 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3 > aux::yes_tag is_bind_helper(bind3< F,T1,T2,T3 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 > aux::yes_tag is_bind_helper(bind4< F,T1,T2,T3,T4 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000472611344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct times_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct times_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct times_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct times : aux::msvc_eti_base< typename apply_wrap2< times_impl< typename times_tag::type , typename times_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, times, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, times) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct times_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 * n2)); typedef integral_c< T,value > type; }; } template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::times_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001627511344301501031621 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef T type; }; }; template<> struct resolve_arg_impl { template< typename T, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct result_ { typedef typename apply_wrap5< T , U1, U2, U3, U4, U5 >::type type; }; }; template< typename T > struct is_bind_template; template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg : resolve_arg_impl< is_bind_template::value > ::template result_< T,U1,U2,U3,U4,U5 > { }; template< int arity_ > struct bind_chooser; aux::no_tag is_bind_helper(...); template< typename T > aux::no_tag is_bind_helper(protect*); template< int N > aux::yes_tag is_bind_helper(arg*); template< bool is_ref_ = true > struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = false); }; }; template<> struct is_bind_template_impl { template< typename T > struct result_ { BOOST_STATIC_CONSTANT(bool, value = sizeof(aux::is_bind_helper(static_cast(0))) == sizeof(aux::yes_tag) ); }; }; template< typename T > struct is_bind_template : is_bind_template_impl< ::boost::detail::is_reference_impl::value > ::template result_ { }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F > aux::yes_tag is_bind_helper(bind0*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1 > aux::yes_tag is_bind_helper(bind1< F,T1 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2 > aux::yes_tag is_bind_helper(bind2< F,T1,T2 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3 > aux::yes_tag is_bind_helper(bind3< F,T1,T2,T3 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 > aux::yes_tag is_bind_helper(bind4< F,T1,T2,T3,T4 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > aux::yes_tag is_bind_helper(bind5< F,T1,T2,T3,T4,T5 >*); } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003173311344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct vector_c_chooser; } namespace aux { template<> struct vector_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_vector_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_vector_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct vector_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value + is_vector_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c_impl { typedef aux::vector_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::vector_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c : aux::vector_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::vector_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003460011344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct deque_chooser; } namespace aux { template<> struct deque_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef vector0< >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct deque_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_deque_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_deque_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct deque_count_args { BOOST_STATIC_CONSTANT(int, value = is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value + is_deque_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque_impl { typedef aux::deque_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::deque_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque : aux::deque_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::deque_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000476611344301501031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct bitor_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitor_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitor_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitor_ : aux::msvc_eti_base< typename apply_wrap2< bitor_impl< typename bitor_tag::type , typename bitor_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitor_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitor_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitor_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 | n2)); typedef integral_c< T,value > type; }; } template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitor_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000517311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 { typedef typename apply_wrap0< typename lambda::type >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; /// workaround for ETI bug template<> struct apply0 { typedef int type; }; template< typename F, typename T1 > struct apply1 { typedef typename apply_wrap1< typename lambda::type , T1 >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; /// workaround for ETI bug template<> struct apply1< int,int > { typedef int type; }; template< typename F, typename T1, typename T2 > struct apply2 { typedef typename apply_wrap2< typename lambda::type , T1, T2 >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; /// workaround for ETI bug template<> struct apply2< int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 { typedef typename apply_wrap3< typename lambda::type , T1, T2, T3 >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; /// workaround for ETI bug template<> struct apply3< int,int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 { typedef typename apply_wrap4< typename lambda::type , T1, T2, T3, T4 >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; /// workaround for ETI bug template<> struct apply4< int,int,int,int,int > { typedef int type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 { typedef typename apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 >::type type; BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// workaround for ETI bug template<> struct apply5< int,int,int,int,int,int > { typedef int type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000457111344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct greater_equal_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_equal_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_equal_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : aux::msvc_eti_base< typename apply_wrap2< greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002571711344301501031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001112411344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F> struct msvc_apply0 { template< bool > struct f_ : F {}; template<> struct f_ { template< typename P = int > struct apply { typedef int type; }; }; template< typename T = int > struct result_ : f_< aux::msvc_never_true::value > ::template apply<> { }; }; template< typename F > struct apply_wrap0 { typedef typename msvc_apply0::template result_< >::type type; }; /// workaround for ETI bug template<> struct apply_wrap0 { typedef int type; }; template< typename F> struct msvc_apply1 { template< bool > struct f_ : F {}; template<> struct f_ { template< typename P1 > struct apply { typedef int type; }; }; template< typename T1 > struct result_ : f_< aux::msvc_never_true::value > ::template apply { }; }; template< typename F, typename T1 > struct apply_wrap1 { typedef typename msvc_apply1::template result_< T1 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap1< int,int > { typedef int type; }; template< typename F> struct msvc_apply2 { template< bool > struct f_ : F {}; template<> struct f_ { template< typename P1, typename P2 > struct apply { typedef int type; }; }; template< typename T1, typename T2 > struct result_ : f_< aux::msvc_never_true::value > ::template apply< T1,T2 > { }; }; template< typename F, typename T1, typename T2 > struct apply_wrap2 { typedef typename msvc_apply2::template result_< T1, T2 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap2< int,int,int > { typedef int type; }; template< typename F> struct msvc_apply3 { template< bool > struct f_ : F {}; template<> struct f_ { template< typename P1, typename P2, typename P3 > struct apply { typedef int type; }; }; template< typename T1, typename T2, typename T3 > struct result_ : f_< aux::msvc_never_true::value > ::template apply< T1,T2,T3 > { }; }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 { typedef typename msvc_apply3::template result_< T1, T2, T3 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap3< int,int,int,int > { typedef int type; }; template< typename F> struct msvc_apply4 { template< bool > struct f_ : F {}; template<> struct f_ { template< typename P1, typename P2, typename P3, typename P4 > struct apply { typedef int type; }; }; template< typename T1, typename T2, typename T3, typename T4 > struct result_ : f_< aux::msvc_never_true::value > ::template apply< T1,T2,T3,T4 > { }; }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 { typedef typename msvc_apply4::template result_< T1, T2, T3, T4 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap4< int,int,int,int,int > { typedef int type; }; template< typename F> struct msvc_apply5 { template< bool > struct f_ : F {}; template<> struct f_ { template< typename P1, typename P2, typename P3, typename P4 , typename P5 > struct apply { typedef int type; }; }; template< typename T1, typename T2, typename T3, typename T4 , typename T5 > struct result_ : f_< aux::msvc_never_true::value > ::template apply< T1,T2,T3,T4,T5 > { }; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 { typedef typename msvc_apply5::template result_< T1, T2, T3, T4, T5 >::type type; }; /// workaround for ETI bug template<> struct apply_wrap5< int,int,int,int,int,int > { typedef int type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003140611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct set_c_chooser; } namespace aux { template<> struct set_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_set_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_set_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct set_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value + is_set_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c_impl { typedef aux::set_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::set_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c : aux::set_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::set_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000255011344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_ > struct or_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : true_ { }; }; template<> struct or_impl { template< typename T1, typename T2, typename T3, typename T4 > struct result_ : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,false_ > { }; }; template<> struct or_impl ::result_< false_,false_,false_,false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< T2,T3,T4,T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001447511344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< int N > struct iter_fold_chunk; template<> struct iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template< int N > struct iter_fold_chunk { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_step; template< typename Last , typename State > struct iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , iter_fold_null_step< Last,State > , iter_fold_step< First,Last,State,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_step { typedef iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl : iter_fold_chunk ::template result_< First,Last,State,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000477011344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct divides_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct divides_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct divides_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct divides : aux::msvc_eti_base< typename apply_wrap2< divides_impl< typename divides_tag::type , typename divides_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, divides, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, divides) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct divides_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 / n2)); typedef integral_c< T,value > type; }; } template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::divides_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000150111344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_< -1 > { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; template<> struct template_arity : mpl::int_< -1 > { }; }}} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000437011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(int, size) > struct unpack_args_impl { template< typename F, typename Args > struct apply; }; template<> struct unpack_args_impl<0> { template< typename F, typename Args > struct apply : apply0< F > { }; }; template<> struct unpack_args_impl<1> { template< typename F, typename Args > struct apply : apply1< F , typename at_c< Args,0 >::type > { }; }; template<> struct unpack_args_impl<2> { template< typename F, typename Args > struct apply : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; }; template<> struct unpack_args_impl<3> { template< typename F, typename Args > struct apply : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; }; template<> struct unpack_args_impl<4> { template< typename F, typename Args > struct apply : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; }; template<> struct unpack_args_impl<5> { template< typename F, typename Args > struct apply : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value > ::template apply< F,Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000500711344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct bitxor_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitxor_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct bitxor_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct bitxor_ : aux::msvc_eti_base< typename apply_wrap2< bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, bitxor_, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, bitxor_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitxor_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 ^ n2)); typedef integral_c< T,value > type; }; } template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitxor_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000146611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000443611344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct greater_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct greater_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : aux::msvc_eti_base< typename apply_wrap2< greater_impl< typename greater_tag::type , typename greater_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001473611344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< int N > struct fold_chunk; template<> struct fold_chunk<0> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct fold_chunk<1> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct fold_chunk<2> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct fold_chunk<3> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct fold_chunk<4> { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template< int N > struct fold_chunk { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_step; template< typename Last , typename State > struct fold_null_step { typedef Last iterator; typedef State state; }; template<> struct fold_chunk< -1 > { template< typename First , typename Last , typename State , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , fold_null_step< Last,State > , fold_step< First,Last,State,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; /// ETI workaround template<> struct result_< int,int,int,int > { typedef int state; typedef int iterator; }; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_step { typedef fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > chunk_; typedef typename chunk_::state state; typedef typename chunk_::iterator iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl : fold_chunk ::template result_< First,Last,State,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003443411344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct list_chooser; } namespace aux { template<> struct list_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef list0< >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_list_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_list_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct list_count_args { BOOST_STATIC_CONSTANT(int, value = is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value + is_list_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list_impl { typedef aux::list_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::list_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list : aux::list_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::list_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000520311344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000472611344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct minus_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct minus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct minus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct minus : aux::msvc_eti_base< typename apply_wrap2< minus_impl< typename minus_tag::type , typename minus_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, minus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, minus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct minus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 - n2)); typedef integral_c< T,value > type; }; } template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::minus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000477011344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct modulus_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct modulus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct modulus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : aux::msvc_eti_base< typename apply_wrap2< modulus_impl< typename modulus_tag::type , typename modulus_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct modulus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 % n2)); typedef integral_c< T,value > type; }; } template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::modulus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003432311344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct map_chooser; } namespace aux { template<> struct map_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef map0< >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct map_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_map_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_map_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct map_count_args { BOOST_STATIC_CONSTANT(int, value = is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value + is_map_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map_impl { typedef aux::map_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::map_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map : aux::map_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::map_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003432311344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct set_chooser; } namespace aux { template<> struct set_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef set0< >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct set_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_set_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_set_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct set_count_args { BOOST_STATIC_CONSTANT(int, value = is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value + is_set_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set_impl { typedef aux::set_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::set_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set : aux::set_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::set_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002303611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< long N > struct reverse_fold_chunk; template<> struct reverse_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template< long N > struct reverse_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step; template< typename Last , typename State > struct reverse_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_fold_null_step< Last,State > , reverse_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_step { typedef reverse_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl : reverse_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000020700000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002166211344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< long N > struct reverse_iter_fold_chunk; template<> struct reverse_iter_fold_chunk<0> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_iter_fold_chunk<1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_iter_fold_chunk<2> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_iter_fold_chunk<3> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template<> struct reverse_iter_fold_chunk<4> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template< long N > struct reverse_iter_fold_chunk { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step; template< typename Last , typename State > struct reverse_iter_fold_null_step { typedef Last iterator; typedef State state; }; template<> struct reverse_iter_fold_chunk< -1 > { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same< First,Last >::type , reverse_iter_fold_null_step< Last,State > , reverse_iter_fold_step< First,Last,State,BackwardOp,ForwardOp > >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; /// ETI workaround template<> struct result_< int,int,int,int,int > { typedef int state; typedef int iterator; }; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_step { typedef reverse_iter_fold_chunk< -1 >::template result_< typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl : reverse_iter_fold_chunk ::template result_< First,Last,State,BackwardOp,ForwardOp > { }; }}} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003465611344301501031624 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct vector_chooser; } namespace aux { template<> struct vector_chooser<0> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef vector0< >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<1> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector1< T0 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<2> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector2< T0, T1 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<3> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector3< T0, T1, T2 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<4> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector4< T0, T1, T2, T3 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<5> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector5< T0, T1, T2, T3, T4 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<6> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector6< T0, T1, T2, T3, T4, T5 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<7> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector7< T0, T1, T2, T3, T4, T5, T6 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<8> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector8< T0, T1, T2, T3, T4, T5, T6, T7 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<9> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector9< T0, T1, T2, T3, T4, T5, T6, T7, T8 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<10> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector10< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<11> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector11< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<12> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector12< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<13> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector13< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<14> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector14< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<15> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<16> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<17> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<18> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<19> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 >::type type; }; }; } // namespace aux namespace aux { template<> struct vector_chooser<20> { template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct result_ { typedef typename vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }; } // namespace aux namespace aux { template< typename T > struct is_vector_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_vector_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6, typename T7, typename T8, typename T9, typename T10 , typename T11, typename T12, typename T13, typename T14, typename T15 , typename T16, typename T17, typename T18, typename T19, typename T20 > struct vector_count_args { BOOST_STATIC_CONSTANT(int, value = is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value + is_vector_arg::value ); }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector_impl { typedef aux::vector_count_args< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 > arg_num_; typedef typename aux::vector_chooser< arg_num_::value > ::template result_< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; } // namespace aux template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector : aux::vector_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type { typedef typename aux::vector_impl< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003151111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct list_c_chooser; } namespace aux { template<> struct list_c_chooser<0> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list0_c< T >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<1> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list1_c< T, C0 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<2> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list2_c< T, C0, C1 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<3> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list3_c< T, C0, C1, C2 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<4> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list4_c< T, C0, C1, C2, C3 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<5> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list5_c< T, C0, C1, C2, C3, C4 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<6> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list6_c< T, C0, C1, C2, C3, C4, C5 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<7> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list7_c< T, C0, C1, C2, C3, C4, C5, C6 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<8> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list8_c< T, C0, C1, C2, C3, C4, C5, C6, C7 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<9> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list9_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<10> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list10_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<11> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list11_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<12> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list12_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<13> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list13_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<14> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<15> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<16> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<17> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<18> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<19> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18 >::type type; }; }; } // namespace aux namespace aux { template<> struct list_c_chooser<20> { template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct result_ { typedef typename list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }; } // namespace aux namespace aux { template< long C > struct is_list_c_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct is_list_c_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; template< long C1, long C2, long C3, long C4, long C5, long C6, long C7, long C8 , long C9, long C10, long C11, long C12, long C13, long C14, long C15 , long C16, long C17, long C18, long C19, long C20 > struct list_c_count_args { BOOST_STATIC_CONSTANT(int, value = is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value + is_list_c_arg::value ); }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c_impl { typedef aux::list_c_count_args< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 > arg_num_; typedef typename aux::list_c_chooser< arg_num_::value > ::template result_< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; } // namespace aux template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c : aux::list_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type { typedef typename aux::list_c_impl< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14, C15, C16, C17, C18, C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000515711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; /// ETI workaround template<> struct apply { typedef int type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000451411344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct less_equal_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_equal_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct less_equal_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : aux::msvc_eti_base< typename apply_wrap2< less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000470511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct plus_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct plus_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct plus_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct plus : aux::msvc_eti_base< typename apply_wrap2< plus_impl< typename plus_tag::type , typename plus_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, plus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, plus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct plus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 + n2)); typedef integral_c< T,value > type; }; } template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::plus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/msvc60/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000445611344301501031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 , BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value , BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value > struct equal_to_impl : if_c< ( tag1_ > tag2_ ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct equal_to_impl< na,integral_c_tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template<> struct equal_to_impl< integral_c_tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : aux::msvc_eti_base< typename apply_wrap2< equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type > , N1 , N2 >::type >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213757031624 5ustar debiandebian././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000460111344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { namespace aux { template< typename T, typename Shift, T n, Shift s > struct shift_right_wknd { BOOST_STATIC_CONSTANT(T, value = (n >> s)); typedef integral_c< T,value > type; }; } template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : aux::shift_right_wknd< typename N::value_type , typename S::value_type , N::value , S::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000412711344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000044411344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000456011344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { namespace aux { template< typename T, typename Shift, T n, Shift s > struct shift_left_wknd { BOOST_STATIC_CONSTANT(T, value = (n << s)); typedef integral_c< T,value > type; }; } template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : aux::shift_left_wknd< typename N::value_type , typename S::value_type , N::value , S::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000432011344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000542011344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000636011344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitand_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitand_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 & n2)); typedef integral_c< T,value > type; }; } template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitand_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235111344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002700311344301502031611 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000624111344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , times , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct times_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 * n2)); typedef integral_c< T,value > type; }; } template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::times_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002044211344301502031611 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301502031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000632011344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitor_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 | n2)); typedef integral_c< T,value > type; }; } template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitor_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527011344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301502031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000433711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002571711344301502031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg, Tag > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect, Tag > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC(2, lambda) }} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000232611344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F , typename has_apply_ = typename aux::has_apply::type > struct apply_wrap0 : F::template apply< > { }; template< typename F > struct apply_wrap0< F,true_ > : F::apply { }; template< typename F, typename T1 > struct apply_wrap1 : F::template apply { }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : F::template apply< T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : F::template apply< T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : F::template apply< T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : F::template apply< T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235211344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301502031615 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000634111344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , divides , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct divides_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 / n2)); typedef integral_c< T,value > type; }; } template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::divides_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000137711344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_< -1 > { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; }}} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000356211344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value,F, Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000636011344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitxor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct bitxor_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 ^ n2)); typedef integral_c< T,value > type; }; } template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::bitxor_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000170411344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct bind; template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000420411344301502031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301502031604 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020100000000000011556 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000624111344301502031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , minus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct minus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 - n2)); typedef integral_c< T,value > type; }; } template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::minus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000453611344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct modulus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 % n2)); typedef integral_c< T,value > type; }; } template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::modulus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301502031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000020200000000000011557 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001631411344301502031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000020700000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001507511344301502031617 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301502031622 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301502031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000020000000000000011555 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000426211344301502031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000620111344301502031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , plus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { namespace aux { template< typename T, T n1, T n2 > struct plus_wknd { BOOST_STATIC_CONSTANT(T, value = (n1 + n2)); typedef integral_c< T,value > type; }; } template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : aux::plus_wknd< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , N1::value , N2::value >::type { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000422411344301502031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply { BOOST_STATIC_CONSTANT(bool, value = ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) ); typedef bool_ type; }; }; }} ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000755000175000017500000000000012146213753031620 5ustar debiandebian././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/shift_right.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000433211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_right.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_right_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_right_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_right_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_right_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_right : shift_right_impl< typename shift_right_tag::type , typename shift_right_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right) }} namespace boost { namespace mpl { template<> struct shift_right_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value >> BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000171411344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct apply; template< typename F > struct apply0; template< typename F, typename T1 > struct apply1; template< typename F, typename T1, typename T2 > struct apply2; template< typename F, typename T1, typename T2, typename T3 > struct apply3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/less.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000376211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less : less_impl< typename less_tag::type , typename less_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less) }} namespace boost { namespace mpl { template<> struct less_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/quote.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421311344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/quote.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, bool has_type_ > struct quote_impl : T { }; template< typename T > struct quote_impl< T,false > { typedef T type; }; template< template< typename P1 > class F , typename Tag = void_ > struct quote1 { template< typename U1 > struct apply : quote_impl< F , aux::has_type< F >::value > { }; }; template< template< typename P1, typename P2 > class F , typename Tag = void_ > struct quote2 { template< typename U1, typename U2 > struct apply : quote_impl< F< U1,U2 > , aux::has_type< F< U1,U2 > >::value > { }; }; template< template< typename P1, typename P2, typename P3 > class F , typename Tag = void_ > struct quote3 { template< typename U1, typename U2, typename U3 > struct apply : quote_impl< F< U1,U2,U3 > , aux::has_type< F< U1,U2,U3 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename Tag = void_ > struct quote4 { template< typename U1, typename U2, typename U3, typename U4 > struct apply : quote_impl< F< U1,U2,U3,U4 > , aux::has_type< F< U1,U2,U3,U4 > >::value > { }; }; template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename Tag = void_ > struct quote5 { template< typename U1, typename U2, typename U3, typename U4 , typename U5 > struct apply : quote_impl< F< U1,U2,U3,U4,U5 > , aux::has_type< F< U1,U2,U3,U4,U5 > >::value > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/shift_left.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000431311344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/shift_left.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct shift_left_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< shift_left_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< shift_left_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct shift_left_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct shift_left_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct shift_left_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct shift_left : shift_left_impl< typename shift_left_tag::type , typename shift_left_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_left, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_left) }} namespace boost { namespace mpl { template<> struct shift_left_impl< integral_c_tag,integral_c_tag > { template< typename N, typename S > struct apply : integral_c< typename N::value_type , ( BOOST_MPL_AUX_VALUE_WKND(N)::value << BOOST_MPL_AUX_VALUE_WKND(S)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000415311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/not_equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct not_equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< not_equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< not_equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct not_equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct not_equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct not_equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct not_equal_to : not_equal_to_impl< typename not_equal_to_tag::type , typename not_equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, not_equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, not_equal_to) }} namespace boost { namespace mpl { template<> struct not_equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value != BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/inherit.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000542011344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/inherit.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) > struct inherit2 : T1, T2 { typedef inherit2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2)) }; template< typename T1 > struct inherit2< T1,empty_base > { typedef T1 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base)) }; template< typename T2 > struct inherit2< empty_base,T2 > { typedef T2 type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2)) }; template<> struct inherit2< empty_base,empty_base > { typedef empty_base type; BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base)) }; BOOST_MPL_AUX_NA_SPEC(2, inherit2) template< typename T1 = na, typename T2 = na, typename T3 = na > struct inherit3 : inherit2< typename inherit2< T1, T2 >::type , T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , inherit3 , ( T1, T2, T3) ) }; BOOST_MPL_AUX_NA_SPEC(3, inherit3) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na > struct inherit4 : inherit2< typename inherit3< T1, T2, T3 >::type , T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , inherit4 , ( T1, T2, T3, T4) ) }; BOOST_MPL_AUX_NA_SPEC(4, inherit4) template< typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na , typename T5 = na > struct inherit5 : inherit2< typename inherit4< T1, T2, T3, T4 >::type , T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , inherit5 , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC(5, inherit5) /// primary template template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct inherit : inherit5< T1,T2,T3,T4,T5 > { }; template<> struct inherit< na,na,na,na,na > { template< typename T1 = empty_base, typename T2 = empty_base , typename T3 = empty_base, typename T4 = empty_base , typename T5 = empty_base > struct apply : inherit< T1,T2,T3,T4,T5 > { }; }; BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit) BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit) BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/bitand.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitand.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitand_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitand_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitand_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitand_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitand_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitand_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitand_ : bitand_< bitand_< bitand_< bitand_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitand_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitand_< N1,N2,N3,N4,na > : bitand_< bitand_< bitand_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitand_< N1,N2,N3,na,na > : bitand_< bitand_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitand_< N1,N2,na,na,na > : bitand_impl< typename bitand_tag::type , typename bitand_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitand_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitand_) }} namespace boost { namespace mpl { template<> struct bitand_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value & BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/and.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235111344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/and.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct and_impl : false_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct and_impl< true,T1,T2,T3,T4 > : and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , true_ > { }; template<> struct and_impl< true , true_, true_, true_, true_ > : true_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = true_, typename T4 = true_, typename T5 = true_ > struct and_ : aux::and_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , and_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , and_ ) }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000003411111344301501031606 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< typename T , typename Arg > struct replace_unnamed_arg { typedef Arg next; typedef T type; }; template< typename Arg > struct replace_unnamed_arg< arg< -1 >, Arg > { typedef typename Arg::next next; typedef Arg type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0; typedef typename r0::type a0; typedef typename r0::next n1; typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_; /// typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef aux::replace_unnamed_arg< T4,n4 > r4; typedef typename r4::type a4; typedef typename r4::next n5; typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4; /// typedef aux::replace_unnamed_arg< T5,n5 > r5; typedef typename r5::type a5; typedef typename r5::next n6; typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5; /// public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct eval_if; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< eval_if,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::replace_unnamed_arg< T1,n1 > r1; typedef typename r1::type a1; typedef typename r1::next n2; typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1; /// typedef aux::replace_unnamed_arg< T2,n2 > r2; typedef typename r2::type a2; typedef typename r2::next n3; typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2; /// typedef aux::replace_unnamed_arg< T3,n3 > r3; typedef typename r3::type a3; typedef typename r3::next n4; typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3; /// typedef typename eval_if< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000017200000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000424311344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright Peter Dimov 2001-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/placeholders.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg< -1 > _; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_; } }} /// agurt, 17/mar/02: one more placeholder for the last 'apply#' /// specialization BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<1> _1; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_1) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_1; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<2> _2; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_2) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_2; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<3> _3; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_3) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_3; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<4> _4; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_4) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_4; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<5> _5; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_5) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_5; } }} BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN typedef arg<6> _6; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE namespace boost { namespace mpl { BOOST_MPL_AUX_ARG_ADL_BARRIER_DECL(_6) namespace placeholders { using BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE::_6; } }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/times.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/times.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct times_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct times_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct times_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct times_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct times : times< times< times< times< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , times , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct times< N1,N2,N3,N4,na > : times< times< times< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct times< N1,N2,N3,na,na > : times< times< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct times< N1,N2,na,na,na > : times_impl< typename times_tag::type , typename times_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , times , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, times) }} namespace boost { namespace mpl { template<> struct times_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value * BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002402411344301501031610 0ustar debiandebian // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/basic_bind.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename T, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg { typedef T type; }; template< int N, typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< arg, U1, U2, U3, U4, U5 > { typedef typename apply_wrap5, U1, U2, U3, U4, U5>::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux template< typename F > struct bind0 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; public: typedef typename apply_wrap0< f_ >::type type; }; }; namespace aux { template< typename F, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind0, U1, U2, U3, U4, U5 > { typedef bind0 f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(1, bind0) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(1, bind0) template< typename F > struct bind< F,na,na,na,na,na > : bind0 { }; template< typename F, typename T1 > struct bind1 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; public: typedef typename apply_wrap1< f_ , typename t1::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename U1, typename U2, typename U3 , typename U4, typename U5 > struct resolve_bind_arg< bind1< F,T1 >, U1, U2, U3, U4, U5 > { typedef bind1< F,T1 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(2, bind1) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(2, bind1) template< typename F, typename T1 > struct bind< F,T1,na,na,na,na > : bind1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct bind2 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; public: typedef typename apply_wrap2< f_ , typename t1::type, typename t2::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename U1, typename U2 , typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind2< F,T1,T2 >, U1, U2, U3, U4, U5 > { typedef bind2< F,T1,T2 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(3, bind2) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(3, bind2) template< typename F, typename T1, typename T2 > struct bind< F,T1,T2,na,na,na > : bind2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct bind3 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; public: typedef typename apply_wrap3< f_ , typename t1::type, typename t2::type, typename t3::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename U1 , typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5 > { typedef bind3< F,T1,T2,T3 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(4, bind3) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(4, bind3) template< typename F, typename T1, typename T2, typename T3 > struct bind< F,T1,T2,T3,na,na > : bind3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; public: typedef typename apply_wrap4< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename U1, typename U2, typename U3, typename U4, typename U5 > struct resolve_bind_arg< bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5 > { typedef bind4< F,T1,T2,T3,T4 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(5, bind4) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(5, bind4) template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind< F,T1,T2,T3,T4,na > : bind4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5 { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef typename aux::resolve_bind_arg< F,U1,U2,U3,U4,U5 >::type f_; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef aux::resolve_bind_arg< T4,U1,U2,U3,U4,U5 > t4; typedef aux::resolve_bind_arg< T5,U1,U2,U3,U4,U5 > t5; public: typedef typename apply_wrap5< f_ , typename t1::type, typename t2::type, typename t3::type , typename t4::type, typename t5::type >::type type; }; }; namespace aux { template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5, typename U1, typename U2, typename U3, typename U4 , typename U5 > struct resolve_bind_arg< bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 > { typedef bind5< F,T1,T2,T3,T4,T5 > f_; typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type; }; } // namespace aux BOOST_MPL_AUX_ARITY_SPEC(6, bind5) BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(6, bind5) /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind : bind5< F,T1,T2,T3,T4,T5 > { }; /// if_/eval_if specializations template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct if_; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< if_,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename if_< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; template< template< typename T1, typename T2, typename T3 > class F, typename Tag > struct quote3; template< typename T1, typename T2, typename T3 > struct eval_if; template< typename Tag, typename T1, typename T2, typename T3 > struct bind3< quote3< eval_if,Tag > , T1, T2, T3 > { template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { private: typedef mpl::arg<1> n1; typedef aux::resolve_bind_arg< T1,U1,U2,U3,U4,U5 > t1; typedef aux::resolve_bind_arg< T2,U1,U2,U3,U4,U5 > t2; typedef aux::resolve_bind_arg< T3,U1,U2,U3,U4,U5 > t3; typedef typename eval_if< typename t1::type , t2, t3 >::type f_; public: typedef typename f_::type type; }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/vector_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002513711344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct vector_c; template< typename T > struct vector_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector0_c { typedef typename vector0_c::type type; }; template< typename T, long C0 > struct vector_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector1_c< T,C0 > { typedef typename vector1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct vector_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector2_c< T,C0,C1 > { typedef typename vector2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct vector_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector3_c< T,C0,C1,C2 > { typedef typename vector3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct vector_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector4_c< T,C0,C1,C2,C3 > { typedef typename vector4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct vector_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector5_c< T,C0,C1,C2,C3,C4 > { typedef typename vector5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct vector_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename vector6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : vector7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename vector7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename vector8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename vector9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename vector10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename vector11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename vector12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename vector13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename vector14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename vector15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : vector16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename vector16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : vector17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename vector17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : vector18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename vector18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct vector_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : vector19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename vector19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct vector_c : vector20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename vector20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/deque.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002300111344301501031602 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/deque.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct deque; template< > struct deque< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct deque< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct deque< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct deque< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct deque< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct deque< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct deque< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct deque< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct deque< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct deque : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/bitor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000615211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitor_ : bitor_< bitor_< bitor_< bitor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitor_< N1,N2,N3,N4,na > : bitor_< bitor_< bitor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitor_< N1,N2,N3,na,na > : bitor_< bitor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitor_< N1,N2,na,na,na > : bitor_impl< typename bitor_tag::type , typename bitor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitor_) }} namespace boost { namespace mpl { template<> struct bitor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value | BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000527011344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F > struct apply0 : apply_wrap0< typename lambda::type > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 1 , apply0 , (F ) ) }; template< typename F > struct apply< F,na,na,na,na,na > : apply0 { }; template< typename F, typename T1 > struct apply1 : apply_wrap1< typename lambda::type , T1 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 2 , apply1 , (F, T1) ) }; template< typename F, typename T1 > struct apply< F,T1,na,na,na,na > : apply1< F,T1 > { }; template< typename F, typename T1, typename T2 > struct apply2 : apply_wrap2< typename lambda::type , T1, T2 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 3 , apply2 , (F, T1, T2) ) }; template< typename F, typename T1, typename T2 > struct apply< F,T1,T2,na,na,na > : apply2< F,T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply3 : apply_wrap3< typename lambda::type , T1, T2, T3 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 4 , apply3 , (F, T1, T2, T3) ) }; template< typename F, typename T1, typename T2, typename T3 > struct apply< F,T1,T2,T3,na,na > : apply3< F,T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply4 : apply_wrap4< typename lambda::type , T1, T2, T3, T4 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , apply4 , (F, T1, T2, T3, T4) ) }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply< F,T1,T2,T3,T4,na > : apply4< F,T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply5 : apply_wrap5< typename lambda::type , T1, T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 6 , apply5 , (F, T1, T2, T3, T4, T5) ) }; /// primary template (not a specialization!) template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply : apply5< F,T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001026211344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_if_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2< StateOp,State,Iterator >::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp, mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2< Predicate,State,Iterator >::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp, identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step< Iterator,State > forward_step0; typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1; typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2; typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3; typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4; typedef typename if_< typename forward_step4::not_last , iter_fold_if_impl< typename forward_step4::iterator , typename forward_step4::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename forward_step4::iterator , typename forward_step4::state > >::type backward_step4; typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3; typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2; typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1; typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0; public: typedef typename backward_step0::state state; typedef typename backward_step4::iterator iterator; }; }}} ././@LongLink0000000000000000000000000000017300000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000417211344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater_equal : greater_equal_impl< typename greater_equal_tag::type , typename greater_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater_equal) }} namespace boost { namespace mpl { template<> struct greater_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value >= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002636611344301501031623 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/full_lambda.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; } // namespace aux template< typename T , typename Tag , typename Arity > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg,Tag, int_< -1 > > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; template< typename F , typename Tag > struct lambda< bind0 , Tag , int_<1> > { typedef false_ is_le; typedef bind0< F > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1 > class F , typename L1 > struct le_result1 { typedef F< typename L1::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1 > class F , typename L1 > struct le_result1< true_,Tag,F,L1 > { typedef bind1< quote1< F,Tag > , typename L1::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1 > class F , typename T1 , typename Tag > struct lambda< F , Tag , int_<1> > { typedef lambda< T1,Tag > l1; typedef typename l1::is_le is_le1; typedef typename aux::lambda_or< is_le1::value >::type is_le; typedef aux::le_result1< is_le, Tag, F, l1 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1 , typename Tag > struct lambda< bind1< F,T1 > , Tag , int_<2> > { typedef false_ is_le; typedef bind1< F , T1 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2 { typedef F< typename L1::type, typename L2::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2 > class F , typename L1, typename L2 > struct le_result2< true_,Tag,F,L1,L2 > { typedef bind2< quote2< F,Tag > , typename L1::result_, typename L2::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2 > class F , typename T1, typename T2 , typename Tag > struct lambda< F< T1,T2 > , Tag , int_<2> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename aux::lambda_or< is_le1::value, is_le2::value >::type is_le; typedef aux::le_result2< is_le, Tag, F, l1, l2 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2 , typename Tag > struct lambda< bind2< F,T1,T2 > , Tag , int_<3> > { typedef false_ is_le; typedef bind2< F , T1, T2 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3 { typedef F< typename L1::type, typename L2::type, typename L3::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3 > class F , typename L1, typename L2, typename L3 > struct le_result3< true_,Tag,F,L1,L2,L3 > { typedef bind3< quote3< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 , typename Tag > struct lambda< F< T1,T2,T3 > , Tag , int_<3> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value >::type is_le; typedef aux::le_result3< is_le, Tag, F, l1, l2, l3 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3 , typename Tag > struct lambda< bind3< F,T1,T2,T3 > , Tag , int_<4> > { typedef false_ is_le; typedef bind3< F , T1, T2, T3 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4 > class F , typename L1, typename L2, typename L3, typename L4 > struct le_result4< true_,Tag,F,L1,L2,L3,L4 > { typedef bind4< quote4< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< F< T1,T2,T3,T4 > , Tag , int_<4> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value >::type is_le; typedef aux::le_result4< is_le, Tag, F, l1, l2, l3, l4 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename Tag > struct lambda< bind4< F,T1,T2,T3,T4 > , Tag , int_<5> > { typedef false_ is_le; typedef bind4< F , T1, T2, T3, T4 > result_; typedef result_ type; }; namespace aux { template< typename IsLE, typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5 { typedef F< typename L1::type, typename L2::type, typename L3::type , typename L4::type, typename L5::type > result_; typedef result_ type; }; template< typename Tag , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F , typename L1, typename L2, typename L3, typename L4, typename L5 > struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 > { typedef bind5< quote5< F,Tag > , typename L1::result_, typename L2::result_, typename L3::result_ , typename L4::result_, typename L5::result_ > result_; typedef mpl::protect type; }; } // namespace aux template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename Tag > struct lambda< F< T1,T2,T3,T4,T5 > , Tag , int_<5> > { typedef lambda< T1,Tag > l1; typedef lambda< T2,Tag > l2; typedef lambda< T3,Tag > l3; typedef lambda< T4,Tag > l4; typedef lambda< T5,Tag > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef typename aux::lambda_or< is_le1::value, is_le2::value, is_le3::value, is_le4::value , is_le5::value >::type is_le; typedef aux::le_result5< is_le, Tag, F, l1, l2, l3, l4, l5 > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind5< F,T1,T2,T3,T4,T5 > , Tag , int_<6> > { typedef false_ is_le; typedef bind5< F , T1, T2, T3, T4, T5 > result_; typedef result_ type; }; /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect,Tag, int_<1> > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 , typename Tag > struct lambda< bind< F,T1,T2,T3,T4,T5 > , Tag , int_<6> > { typedef false_ is_le; typedef bind< F,T1,T2,T3,T4,T5 > result_; typedef result_ type; }; template< typename F , typename Tag1 , typename Tag2 , typename Arity > struct lambda< lambda< F,Tag1,Arity > , Tag2 , int_<3> > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef bind1< quote1, typename l1::result_ > arity_; typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3; typedef aux::le_result3 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) }} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000232611344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/apply_wrap.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F , typename has_apply_ = typename aux::has_apply::type > struct apply_wrap0 : F::template apply< > { }; template< typename F > struct apply_wrap0< F,true_ > : F::apply { }; template< typename F, typename T1 > struct apply_wrap1 : F::template apply { }; template< typename F, typename T1, typename T2 > struct apply_wrap2 : F::template apply< T1,T2 > { }; template< typename F, typename T1, typename T2, typename T3 > struct apply_wrap3 : F::template apply< T1,T2,T3 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct apply_wrap4 : F::template apply< T1,T2,T3,T4 > { }; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct apply_wrap5 : F::template apply< T1,T2,T3,T4,T5 > { }; }} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/set_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002464211344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/Attic/set_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct set_c; template< typename T > struct set_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set0_c { typedef typename set0_c::type type; }; template< typename T, long C0 > struct set_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set1_c< T,C0 > { typedef typename set1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct set_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set2_c< T,C0,C1 > { typedef typename set2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct set_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set3_c< T,C0,C1,C2 > { typedef typename set3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct set_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set4_c< T,C0,C1,C2,C3 > { typedef typename set4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct set_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set5_c< T,C0,C1,C2,C3,C4 > { typedef typename set5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct set_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename set6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : set7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename set7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename set8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename set9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename set10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename set11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename set12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename set13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename set14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename set15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : set16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename set16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : set17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename set17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : set18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename set18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct set_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : set19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename set19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct set_c : set20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename set20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/or.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000235211344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/or.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C_, typename T1, typename T2, typename T3, typename T4 > struct or_impl : true_ { }; template< typename T1, typename T2, typename T3, typename T4 > struct or_impl< false,T1,T2,T3,T4 > : or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4 , false_ > { }; template<> struct or_impl< false , false_, false_, false_, false_ > : false_ { }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) , typename T3 = false_, typename T4 = false_, typename T5 = false_ > struct or_ : aux::or_impl< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , T2, T3, T4, T5 > { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , or_ , ( T1, T2, T3, T4, T5) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , 5 , or_ ) }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001007611344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp,state0,iter0 >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,state1,iter1 >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,state2,iter2 >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,state3,iter3 >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl { typedef iter_fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,First,Last,State,ForwardOp > : iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct iter_fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000551511344301501031614 0ustar debiandebian // Copyright Peter Dimov 2001-2002 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/arg.hpp" header // -- DO NOT modify by hand! BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN template<> struct arg< -1 > { BOOST_STATIC_CONSTANT(int, value = -1); BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<1> { BOOST_STATIC_CONSTANT(int, value = 1); typedef arg<2> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U1 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<2> { BOOST_STATIC_CONSTANT(int, value = 2); typedef arg<3> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U2 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<3> { BOOST_STATIC_CONSTANT(int, value = 3); typedef arg<4> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U3 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<4> { BOOST_STATIC_CONSTANT(int, value = 4); typedef arg<5> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U4 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; template<> struct arg<5> { BOOST_STATIC_CONSTANT(int, value = 5); typedef arg<6> next; BOOST_MPL_AUX_ARG_TYPEDEF(na, tag) BOOST_MPL_AUX_ARG_TYPEDEF(na, type) template< typename U1 = na, typename U2 = na, typename U3 = na , typename U4 = na, typename U5 = na > struct apply { typedef U5 type; BOOST_MPL_AUX_ASSERT_NOT_NA(type); }; }; BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(1,int, arg) BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/divides.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000616711344301501031620 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/divides.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct divides_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< divides_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< divides_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct divides_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct divides_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct divides_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct divides : divides< divides< divides< divides< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , divides , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct divides< N1,N2,N3,N4,na > : divides< divides< divides< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct divides< N1,N2,N3,na,na > : divides< divides< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct divides< N1,N2,na,na,na > : divides_impl< typename divides_tag::type , typename divides_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , divides , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, divides) }} namespace boost { namespace mpl { template<> struct divides_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value / BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000525111344301501031611 0ustar debiandebian // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int N > struct arity_tag { typedef char (&type)[N + 1]; }; template< int C1, int C2, int C3, int C4, int C5, int C6 > struct max_arity { BOOST_STATIC_CONSTANT(int, value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) ) ); }; arity_tag<0>::type arity_helper(...); template< template< typename P1 > class F , typename T1 > typename arity_tag<1>::type arity_helper(type_wrapper< F >, arity_tag<1>); template< template< typename P1, typename P2 > class F , typename T1, typename T2 > typename arity_tag<2>::type arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>); template< template< typename P1, typename P2, typename P3 > class F , typename T1, typename T2, typename T3 > typename arity_tag<3>::type arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>); template< template< typename P1, typename P2, typename P3, typename P4 > class F , typename T1, typename T2, typename T3, typename T4 > typename arity_tag<4>::type arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>); template< template< typename P1, typename P2, typename P3, typename P4 , typename P5 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 > typename arity_tag<5>::type arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>); template< template< typename P1, typename P2, typename P3, typename P4 , typename P5, typename P6 > class F , typename T1, typename T2, typename T3, typename T4, typename T5 , typename T6 > typename arity_tag<6>::type arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>); template< typename F, int N > struct template_arity_impl { BOOST_STATIC_CONSTANT(int, value = sizeof(arity_helper(type_wrapper(), arity_tag())) - 1 ); }; template< typename F > struct template_arity { BOOST_STATIC_CONSTANT(int, value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )); typedef mpl::int_ type; }; }}} ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/unpack_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000356211344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/unpack_args.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< int size, typename F, typename Args > struct unpack_args_impl; template< typename F, typename Args > struct unpack_args_impl< 0,F,Args > : apply0< F > { }; template< typename F, typename Args > struct unpack_args_impl< 1,F,Args > : apply1< F , typename at_c< Args,0 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 2,F,Args > : apply2< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 3,F,Args > : apply3< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 4,F,Args > : apply4< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type > { }; template< typename F, typename Args > struct unpack_args_impl< 5,F,Args > : apply5< F , typename at_c< Args,0 >::type, typename at_c< Args,1 >::type , typename at_c< Args,2 >::type, typename at_c< Args,3 >::type , typename at_c< Args,4 >::type > { }; } template< typename F > struct unpack_args { template< typename Args > struct apply : aux::unpack_args_impl< size::value,F, Args > { }; }; BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(1, unpack_args) }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/bitxor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000621011344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bitxor.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct bitxor_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< bitxor_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< bitxor_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct bitxor_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct bitxor_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct bitxor_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct bitxor_ : bitxor_< bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , bitxor_ , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct bitxor_< N1,N2,N3,N4,na > : bitxor_< bitxor_< bitxor_< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct bitxor_< N1,N2,N3,na,na > : bitxor_< bitxor_< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct bitxor_< N1,N2,na,na,na > : bitxor_impl< typename bitxor_tag::type , typename bitxor_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , bitxor_ , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, bitxor_) }} namespace boost { namespace mpl { template<> struct bitxor_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value ^ BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000170411344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/bind_fwd.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename F, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na > struct bind; template< typename F > struct bind0; template< typename F, typename T1 > struct bind1; template< typename F, typename T1, typename T2 > struct bind2; template< typename F, typename T1, typename T2, typename T3 > struct bind3; template< typename F, typename T1, typename T2, typename T3, typename T4 > struct bind4; template< typename F, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct bind5; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/greater.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000403711344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/greater.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct greater_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< greater_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< greater_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct greater_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct greater_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct greater_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct greater : greater_impl< typename greater_tag::type , typename greater_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, greater, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, greater) }} namespace boost { namespace mpl { template<> struct greater_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value > BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001040211344301501031603 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 0,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 1,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef state1 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 2,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef state2 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 3,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef state3 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< 4,First,Last,State,ForwardOp > { typedef First iter0; typedef State state0; typedef typename apply2< ForwardOp, state0, typename deref::type >::type state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, state1, typename deref::type >::type state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, state2, typename deref::type >::type state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, state3, typename deref::type >::type state4; typedef typename mpl::next::type iter4; typedef state4 state; typedef iter4 iterator; }; template< int N , typename First , typename Last , typename State , typename ForwardOp > struct fold_impl { typedef fold_impl< 4 , First , Last , State , ForwardOp > chunk_; typedef fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , typename chunk_::iterator , Last , typename chunk_::state , ForwardOp > res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; template< typename First , typename Last , typename State , typename ForwardOp > struct fold_impl< -1,First,Last,State,ForwardOp > : fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , ForwardOp > { }; template< typename Last , typename State , typename ForwardOp > struct fold_impl< -1,Last,Last,State,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/list.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002262011344301501031610 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct list; template< > struct list< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list0< > { typedef list0< >::type type; }; template< typename T0 > struct list< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list1 { typedef typename list1::type type; }; template< typename T0, typename T1 > struct list< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list2< T0,T1 > { typedef typename list2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct list< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list3< T0,T1,T2 > { typedef typename list3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct list< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list4< T0,T1,T2,T3 > { typedef typename list4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct list< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list5< T0,T1,T2,T3,T4 > { typedef typename list5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct list< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : list6< T0,T1,T2,T3,T4,T5 > { typedef typename list6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct list< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : list7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename list7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : list8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename list8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename list9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename list10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename list11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename list12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename list13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename list14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : list15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename list15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : list16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename list16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : list17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename list17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : list18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename list18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct list< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : list19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename list19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct list : list20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename list20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017600000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000423611344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_backward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_backward; template<> struct advance_backward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_backward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef iter1 type; }; }; template<> struct advance_backward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef iter2 type; }; }; template<> struct advance_backward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef iter3 type; }; }; template<> struct advance_backward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename prior::type iter1; typedef typename prior::type iter2; typedef typename prior::type iter3; typedef typename prior::type iter4; typedef iter4 type; }; }; template< long N > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/minus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000607311344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/minus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct minus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct minus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct minus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct minus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct minus : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , minus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct minus< N1,N2,N3,N4,na > : minus< minus< minus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct minus< N1,N2,N3,na,na > : minus< minus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct minus< N1,N2,na,na,na > : minus_impl< typename minus_tag::type , typename minus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , minus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, minus) }} namespace boost { namespace mpl { template<> struct minus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value - BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/modulus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000436411344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/modulus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct modulus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< modulus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< modulus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct modulus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct modulus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct modulus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct modulus : modulus_impl< typename modulus_tag::type , typename modulus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, modulus, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, modulus) }} namespace boost { namespace mpl { template<> struct modulus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value % BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/map.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/map.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct map; template< > struct map< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map0< > { typedef map0< >::type type; }; template< typename T0 > struct map< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map1 { typedef typename map1::type type; }; template< typename T0, typename T1 > struct map< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map2< T0,T1 > { typedef typename map2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct map< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map3< T0,T1,T2 > { typedef typename map3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct map< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map4< T0,T1,T2,T3 > { typedef typename map4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct map< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map5< T0,T1,T2,T3,T4 > { typedef typename map5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct map< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : map6< T0,T1,T2,T3,T4,T5 > { typedef typename map6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct map< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : map7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename map7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : map8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename map8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename map9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename map10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename map11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename map12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename map13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename map14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : map15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename map15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : map16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename map16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : map17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename map17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : map18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename map18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct map< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : map19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename map19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct map : map20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename map20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/set.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002251711344301501031615 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/set.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct set; template< > struct set< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set0< > { typedef set0< >::type type; }; template< typename T0 > struct set< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set1 { typedef typename set1::type type; }; template< typename T0, typename T1 > struct set< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set2< T0,T1 > { typedef typename set2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct set< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set3< T0,T1,T2 > { typedef typename set3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct set< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set4< T0,T1,T2,T3 > { typedef typename set4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct set< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set5< T0,T1,T2,T3,T4 > { typedef typename set5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct set< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : set6< T0,T1,T2,T3,T4,T5 > { typedef typename set6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct set< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : set7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename set7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : set8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename set8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename set9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename set10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename set11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename set12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename set13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename set14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : set15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename set15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : set16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename set16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : set17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename set17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : set18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename set18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct set< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : set19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename set19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct set : set20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename set20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000017700000000000011572 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001631411344301501031613 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp, fwd_state0, typename deref::type >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp, fwd_state1, typename deref::type >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp, fwd_state2, typename deref::type >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp, fwd_state3, typename deref::type >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp, bkwd_state4, typename deref::type >::type bkwd_state3; typedef typename apply2< BackwardOp, bkwd_state3, typename deref::type >::type bkwd_state2; typedef typename apply2< BackwardOp, bkwd_state2, typename deref::type >::type bkwd_state1; typedef typename apply2< BackwardOp, bkwd_state1, typename deref::type >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_fold_impl< -1 , typename mpl::next::type , Last , typename apply2::type>::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , typename deref::type >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000020400000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001507511344301501031616 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/reverse_iter_fold_impl.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { /// forward declaration template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 0,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef fwd_state0 bkwd_state0; typedef bkwd_state0 state; typedef iter0 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef fwd_state1 bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter1 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef fwd_state2 bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter2 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef fwd_state3 bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter3 iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp > { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef fwd_state4 bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef iter4 iterator; }; template< long N , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl { typedef First iter0; typedef State fwd_state0; typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1; typedef typename mpl::next::type iter1; typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2; typedef typename mpl::next::type iter2; typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3; typedef typename mpl::next::type iter3; typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4; typedef typename mpl::next::type iter4; typedef reverse_iter_fold_impl< ( (N - 4) < 0 ? 0 : N - 4 ) , iter4 , Last , fwd_state4 , BackwardOp , ForwardOp > nested_chunk; typedef typename nested_chunk::state bkwd_state4; typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3; typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2; typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1; typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0; typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp > { typedef reverse_iter_fold_impl< -1 , typename mpl::next::type , Last , typename apply2< ForwardOp,State,First >::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , First >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp > { typedef State state; typedef Last iterator; }; }}} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/vector.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002302211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/vector.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T0 = na, typename T1 = na, typename T2 = na, typename T3 = na , typename T4 = na, typename T5 = na, typename T6 = na, typename T7 = na , typename T8 = na, typename T9 = na, typename T10 = na, typename T11 = na , typename T12 = na, typename T13 = na, typename T14 = na , typename T15 = na, typename T16 = na, typename T17 = na , typename T18 = na, typename T19 = na > struct vector; template< > struct vector< na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector0< > { typedef vector0< >::type type; }; template< typename T0 > struct vector< T0, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector1 { typedef typename vector1::type type; }; template< typename T0, typename T1 > struct vector< T0, T1, na, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector2< T0,T1 > { typedef typename vector2< T0,T1 >::type type; }; template< typename T0, typename T1, typename T2 > struct vector< T0, T1, T2, na, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector3< T0,T1,T2 > { typedef typename vector3< T0,T1,T2 >::type type; }; template< typename T0, typename T1, typename T2, typename T3 > struct vector< T0, T1, T2, T3, na, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector4< T0,T1,T2,T3 > { typedef typename vector4< T0,T1,T2,T3 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector< T0, T1, T2, T3, T4, na, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector5< T0,T1,T2,T3,T4 > { typedef typename vector5< T0,T1,T2,T3,T4 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector< T0, T1, T2, T3, T4, T5, na, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector6< T0,T1,T2,T3,T4,T5 > { typedef typename vector6< T0,T1,T2,T3,T4,T5 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector< T0, T1, T2, T3, T4, T5, T6, na, na, na, na, na, na, na, na, na, na , na, na, na > : vector7< T0,T1,T2,T3,T4,T5,T6 > { typedef typename vector7< T0,T1,T2,T3,T4,T5,T6 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, na, na, na, na, na, na, na, na, na , na, na, na > : vector8< T0,T1,T2,T3,T4,T5,T6,T7 > { typedef typename vector8< T0,T1,T2,T3,T4,T5,T6,T7 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, na, na, na, na, na, na, na, na , na, na, na > : vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 > { typedef typename vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, na, na, na, na, na, na, na , na, na, na > : vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 > { typedef typename vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, na, na, na, na, na, na , na, na, na > : vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 > { typedef typename vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, na, na, na, na , na, na, na, na > : vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 > { typedef typename vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, na, na, na , na, na, na, na > : vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 > { typedef typename vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, na, na , na, na, na, na > : vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 > { typedef typename vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, na , na, na, na, na > : vector15< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 > { typedef typename vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, na, na, na, na > : vector16< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15 > { typedef typename vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, na, na, na > : vector17< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16 > { typedef typename vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, na, na > : vector18< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17 > { typedef typename vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >::type type; }; template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18 > struct vector< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, na > : vector19< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18 > { typedef typename vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >::type type; }; /// primary template (not a specialization!) template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8, typename T9 , typename T10, typename T11, typename T12, typename T13, typename T14 , typename T15, typename T16, typename T17, typename T18, typename T19 > struct vector : vector20< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 , T15, T16, T17, T18, T19 > { typedef typename vector20< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19 >::type type; }; }} ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/list_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000002473511344301501031621 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/list_c.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename T, long C0 = LONG_MAX, long C1 = LONG_MAX, long C2 = LONG_MAX , long C3 = LONG_MAX, long C4 = LONG_MAX, long C5 = LONG_MAX , long C6 = LONG_MAX, long C7 = LONG_MAX, long C8 = LONG_MAX , long C9 = LONG_MAX, long C10 = LONG_MAX, long C11 = LONG_MAX , long C12 = LONG_MAX, long C13 = LONG_MAX, long C14 = LONG_MAX , long C15 = LONG_MAX, long C16 = LONG_MAX, long C17 = LONG_MAX , long C18 = LONG_MAX, long C19 = LONG_MAX > struct list_c; template< typename T > struct list_c< T, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list0_c { typedef typename list0_c::type type; }; template< typename T, long C0 > struct list_c< T, C0, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list1_c< T,C0 > { typedef typename list1_c< T,C0 >::type type; }; template< typename T, long C0, long C1 > struct list_c< T, C0, C1, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list2_c< T,C0,C1 > { typedef typename list2_c< T,C0,C1 >::type type; }; template< typename T, long C0, long C1, long C2 > struct list_c< T, C0, C1, C2, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list3_c< T,C0,C1,C2 > { typedef typename list3_c< T,C0,C1,C2 >::type type; }; template< typename T, long C0, long C1, long C2, long C3 > struct list_c< T, C0, C1, C2, C3, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list4_c< T,C0,C1,C2,C3 > { typedef typename list4_c< T,C0,C1,C2,C3 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4 > struct list_c< T, C0, C1, C2, C3, C4, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list5_c< T,C0,C1,C2,C3,C4 > { typedef typename list5_c< T,C0,C1,C2,C3,C4 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 > struct list_c< T, C0, C1, C2, C3, C4, C5, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list6_c< T,C0,C1,C2,C3,C4,C5 > { typedef typename list6_c< T,C0,C1,C2,C3,C4,C5 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX > : list7_c< T,C0,C1,C2,C3,C4,C5,C6 > { typedef typename list7_c< T,C0,C1,C2,C3,C4,C5,C6 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX > : list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 > { typedef typename list8_c< T,C0,C1,C2,C3,C4,C5,C6,C7 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 > { typedef typename list9_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX , LONG_MAX > : list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 > { typedef typename list10_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, LONG_MAX, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 > { typedef typename list11_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 > { typedef typename list12_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, LONG_MAX , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 > { typedef typename list13_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list14_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13 > { typedef typename list14_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list15_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 > { typedef typename list15_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, LONG_MAX, LONG_MAX, LONG_MAX, LONG_MAX > : list16_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15 > { typedef typename list16_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, LONG_MAX, LONG_MAX, LONG_MAX > : list17_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16 > { typedef typename list17_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, LONG_MAX, LONG_MAX > : list18_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17 > { typedef typename list18_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17 >::type type; }; template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18 > struct list_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, LONG_MAX > : list19_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18 > { typedef typename list19_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18 >::type type; }; /// primary template (not a specialization!) template< typename T, long C0, long C1, long C2, long C3, long C4, long C5 , long C6, long C7, long C8, long C9, long C10, long C11, long C12 , long C13, long C14, long C15, long C16, long C17, long C18, long C19 > struct list_c : list20_c< T, C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11, C12, C13, C14 , C15, C16, C17, C18, C19 > { typedef typename list20_c< T,C0,C1,C2,C3,C4,C5,C6,C7,C8,C9,C10,C11,C12,C13,C14,C15,C16,C17,C18,C19 >::type type; }; }} ././@LongLink0000000000000000000000000000017400000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000001451511344301501031614 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/lambda_no_ctps.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false , bool C5 = false > struct lambda_or : true_ { }; template<> struct lambda_or< false,false,false,false,false > : false_ { }; template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; template<> struct lambda_impl< int_<1> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef typename l1::is_le is_le1; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value > is_le; typedef bind1< typename F::rebind , typename l1::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<2> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value > is_le; typedef bind2< typename F::rebind , typename l1::type, typename l2::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<3> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value > is_le; typedef bind3< typename F::rebind , typename l1::type, typename l2::type, typename l3::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<4> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value > is_le; typedef bind4< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; template<> struct lambda_impl< int_<5> > { template< typename F, typename Tag, typename Protect > struct result_ { typedef lambda< typename F::arg1, Tag, false_ > l1; typedef lambda< typename F::arg2, Tag, false_ > l2; typedef lambda< typename F::arg3, Tag, false_ > l3; typedef lambda< typename F::arg4, Tag, false_ > l4; typedef lambda< typename F::arg5, Tag, false_ > l5; typedef typename l1::is_le is_le1; typedef typename l2::is_le is_le2; typedef typename l3::is_le is_le3; typedef typename l4::is_le is_le4; typedef typename l5::is_le is_le5; typedef aux::lambda_or< BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le1)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le2)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le3)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le4)::value, BOOST_MPL_AUX_MSVC_VALUE_WKND(is_le5)::value > is_le; typedef bind5< typename F::rebind , typename l1::type, typename l2::type, typename l3::type , typename l4::type, typename l5::type > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; }} ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000421211344301501031605 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/aux_/advance_forward.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { namespace aux { template< long N > struct advance_forward; template<> struct advance_forward<0> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef iter0 type; }; }; template<> struct advance_forward<1> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef iter1 type; }; }; template<> struct advance_forward<2> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef iter2 type; }; }; template<> struct advance_forward<3> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef iter3 type; }; }; template<> struct advance_forward<4> { template< typename Iterator > struct apply { typedef Iterator iter0; typedef typename next::type iter1; typedef typename next::type iter2; typedef typename next::type iter3; typedef typename next::type iter4; typedef iter4 type; }; }; template< long N > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward<4> , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - 4) < 0 ? 0 : N - 4 )> , chunk_result_ >::type type; }; }; }}} ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000411511344301501031607 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/less_equal.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct less_equal_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< less_equal_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< less_equal_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct less_equal_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct less_equal_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct less_equal_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct less_equal : less_equal_impl< typename less_equal_tag::type , typename less_equal_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, less_equal, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, less_equal) }} namespace boost { namespace mpl { template<> struct less_equal_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value <= BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/plus.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000603511344301501031612 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/plus.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct plus_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct plus_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct plus_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct plus_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) , typename N3 = na, typename N4 = na, typename N5 = na > struct plus : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5> { BOOST_MPL_AUX_LAMBDA_SUPPORT( 5 , plus , ( N1, N2, N3, N4, N5 ) ) }; template< typename N1, typename N2, typename N3, typename N4 > struct plus< N1,N2,N3,N4,na > : plus< plus< plus< N1,N2 >, N3>, N4> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, N4, na ) ) }; template< typename N1, typename N2, typename N3 > struct plus< N1,N2,N3,na,na > : plus< plus< N1,N2 >, N3> { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, N3, na, na ) ) }; template< typename N1, typename N2 > struct plus< N1,N2,na,na,na > : plus_impl< typename plus_tag::type , typename plus_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC( 5 , plus , ( N1, N2, na, na, na ) ) }; BOOST_MPL_AUX_NA_SPEC2(2, 5, plus) }} namespace boost { namespace mpl { template<> struct plus_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : integral_c< typename aux::largest_int< typename N1::value_type , typename N2::value_type >::type , ( BOOST_MPL_AUX_VALUE_WKND(N1)::value + BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessed0000644000175000017500000000406011344301501031606 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // Preprocessed version of "boost/mpl/equal_to.hpp" header // -- DO NOT modify by hand! namespace boost { namespace mpl { template< typename Tag1 , typename Tag2 > struct equal_to_impl : if_c< ( BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag1) > BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Tag2) ) , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 > , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 > >::type { }; /// for Digital Mars C++/compilers with no CTPS/TTP support template<> struct equal_to_impl< na,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< na,Tag > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename Tag > struct equal_to_impl< Tag,na > { template< typename U1, typename U2 > struct apply { typedef apply type; BOOST_STATIC_CONSTANT(int, value = 0); }; }; template< typename T > struct equal_to_tag { typedef typename T::tag type; }; template< typename BOOST_MPL_AUX_NA_PARAM(N1) , typename BOOST_MPL_AUX_NA_PARAM(N2) > struct equal_to : equal_to_impl< typename equal_to_tag::type , typename equal_to_tag::type >::template apply< N1,N2 >::type { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2)) }; BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to) }} namespace boost { namespace mpl { template<> struct equal_to_impl< integral_c_tag,integral_c_tag > { template< typename N1, typename N2 > struct apply : bool_< ( BOOST_MPL_AUX_VALUE_WKND(N1)::value == BOOST_MPL_AUX_VALUE_WKND(N2)::value ) > { }; }; }} ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/apply_1st.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/apply_1st.hp0000644000175000017500000000150711344301501031435 0ustar debiandebian #ifndef BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED #define BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/apply_1st.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { struct apply_1st { template< typename Pair, typename T > struct apply : apply2< typename Pair::first , typename Pair::second , T > { }; }; }}} #endif // BOOST_MPL_AUX_APPLY_1ST_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/filter_iter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/filter_iter.0000644000175000017500000000606711344301501031507 0ustar debiandebian #ifndef BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED #define BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/filter_iter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Iterator , typename LastIterator , typename Predicate > struct filter_iter; template< typename Iterator , typename LastIterator , typename Predicate > struct next_filter_iter { typedef typename find_if< iterator_range , Predicate >::type base_iter_; typedef filter_iter type; }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Iterator , typename LastIterator , typename Predicate > struct filter_iter { typedef Iterator base; typedef forward_iterator_tag category; typedef typename aux::next_filter_iter< typename mpl::next::type , LastIterator , Predicate >::type next; typedef typename deref::type type; }; template< typename LastIterator , typename Predicate > struct filter_iter< LastIterator,LastIterator,Predicate > { typedef LastIterator base; typedef forward_iterator_tag category; }; #else template< bool > struct filter_iter_impl { template< typename Iterator , typename LastIterator , typename Predicate > struct result_ { typedef Iterator base; typedef forward_iterator_tag category; typedef typename next_filter_iter< typename mpl::next::type , LastIterator , Predicate >::type next; typedef typename deref::type type; }; }; template<> struct filter_iter_impl< true > { template< typename Iterator , typename LastIterator , typename Predicate > struct result_ { typedef Iterator base; typedef forward_iterator_tag category; }; }; template< typename Iterator , typename LastIterator , typename Predicate > struct filter_iter : filter_iter_impl< ::boost::is_same::value >::template result_< Iterator,LastIterator,Predicate > { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace aux BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::filter_iter) }} #endif // BOOST_MPL_AUX_FILTER_ITER_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/basic_bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/basic_bind.h0000644000175000017500000000122311344301501031411 0ustar debiandebian #ifndef BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED #define BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED // Copyright Peter Dimov 2001 // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/basic_bind.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT #include #endif // BOOST_MPL_AUX_BASIC_BIND_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/type_wrapper.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/type_wrapper0000644000175000017500000000241411344301501031632 0ustar debiandebian #ifndef BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED #define BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Peter Dimov 2000-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/type_wrapper.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { template< typename T > struct type_wrapper { typedef T type; }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) // agurt 08/may/03: a complicated way to extract the wrapped type; need it // mostly for the sake of GCC (3.2.x), which ICEs if you try to extract the // nested 'type' from 'type_wrapper' when the latter was the result of a // 'typeof' expression template< typename T > struct wrapped_type; template< typename T > struct wrapped_type< type_wrapper > { typedef T type; }; #else template< typename W > struct wrapped_type { typedef typename W::type type; }; #endif }}} #endif // BOOST_MPL_AUX_TYPE_WRAPPER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/numeric_cast_utils.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/numeric_cast0000644000175000017500000000353011344301501031565 0ustar debiandebian #ifndef BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED #define BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/numeric_cast_utils.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { namespace aux { template< typename F , typename Tag1 , typename Tag2 > struct cast1st_impl { template< typename N1, typename N2 > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : apply_wrap2< F , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N1 >::type , N2 > { #else { typedef typename apply_wrap2< F , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N1 >::type , N2 >::type type; #endif }; }; template< typename F , typename Tag1 , typename Tag2 > struct cast2nd_impl { template< typename N1, typename N2 > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : apply_wrap2< F , N1 , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N2 >::type > { #else { typedef typename apply_wrap2< F , N1 , typename apply_wrap1< BOOST_MPL_AUX_NUMERIC_CAST,N2 >::type >::type type; #endif }; }; }}} #endif // BOOST_MPL_AUX_NUMERIC_CAST_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_fold_if_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_fold_if0000644000175000017500000001351411344301501031541 0ustar debiandebian #ifndef BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // Copyright David Abrahams 2001-2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_fold_if_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER iter_fold_if_impl.hpp # include #else # include # include # include # include # include # include namespace boost { namespace mpl { namespace aux { template< typename Iterator, typename State > struct iter_fold_if_null_step { typedef State state; typedef Iterator iterator; }; template< bool > struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef typename apply2::type state; typedef typename IteratorOp::type iterator; }; }; template<> struct iter_fold_if_step_impl { template< typename Iterator , typename State , typename StateOp , typename IteratorOp > struct result_ { typedef State state; typedef Iterator iterator; }; }; // agurt, 25/jun/02: MSVC 6.5 workaround, had to get rid of inheritance // here and in 'iter_fold_if_backward_step', because sometimes it interfered // with the "early template instantiation bug" in _really_ ugly ways template< typename Iterator , typename State , typename ForwardOp , typename Predicate > struct iter_fold_if_forward_step { typedef typename apply2::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,ForwardOp,mpl::next > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; template< typename Iterator , typename State , typename BackwardOp , typename Predicate > struct iter_fold_if_backward_step { typedef typename apply2::type not_last; typedef typename iter_fold_if_step_impl< BOOST_MPL_AUX_MSVC_VALUE_WKND(not_last)::value >::template result_< Iterator,State,BackwardOp,identity > impl_; typedef typename impl_::state state; typedef typename impl_::iterator iterator; }; // local macros, #undef-ined at the end of the header # define AUX_ITER_FOLD_FORWARD_STEP(unused, i, unused2) \ typedef iter_fold_if_forward_step< \ typename BOOST_PP_CAT(forward_step,i)::iterator \ , typename BOOST_PP_CAT(forward_step,i)::state \ , ForwardOp \ , ForwardPredicate \ > BOOST_PP_CAT(forward_step, BOOST_PP_INC(i)); \ /**/ # define AUX_ITER_FOLD_BACKWARD_STEP_FUNC(i) \ typedef iter_fold_if_backward_step< \ typename BOOST_PP_CAT(forward_step,BOOST_PP_DEC(i))::iterator \ , typename BOOST_PP_CAT(backward_step,i)::state \ , BackwardOp \ , BackwardPredicate \ > BOOST_PP_CAT(backward_step,BOOST_PP_DEC(i)); \ /**/ # define AUX_ITER_FOLD_BACKWARD_STEP(unused, i, unused2) \ AUX_ITER_FOLD_BACKWARD_STEP_FUNC( \ BOOST_PP_SUB_D(1,BOOST_MPL_LIMIT_UNROLLING,i) \ ) \ /**/ # define AUX_LAST_FORWARD_STEP \ BOOST_PP_CAT(forward_step, BOOST_MPL_LIMIT_UNROLLING) \ /**/ # define AUX_LAST_BACKWARD_STEP \ BOOST_PP_CAT(backward_step, BOOST_MPL_LIMIT_UNROLLING) \ /**/ template< typename Iterator , typename State , typename ForwardOp , typename ForwardPredicate , typename BackwardOp , typename BackwardPredicate > struct iter_fold_if_impl { private: typedef iter_fold_if_null_step forward_step0; BOOST_PP_REPEAT( BOOST_MPL_LIMIT_UNROLLING , AUX_ITER_FOLD_FORWARD_STEP , unused ) typedef typename if_< typename AUX_LAST_FORWARD_STEP::not_last , iter_fold_if_impl< typename AUX_LAST_FORWARD_STEP::iterator , typename AUX_LAST_FORWARD_STEP::state , ForwardOp , ForwardPredicate , BackwardOp , BackwardPredicate > , iter_fold_if_null_step< typename AUX_LAST_FORWARD_STEP::iterator , typename AUX_LAST_FORWARD_STEP::state > >::type AUX_LAST_BACKWARD_STEP; BOOST_PP_REPEAT( BOOST_MPL_LIMIT_UNROLLING , AUX_ITER_FOLD_BACKWARD_STEP , unused ) public: typedef typename backward_step0::state state; typedef typename AUX_LAST_BACKWARD_STEP::iterator iterator; }; # undef AUX_LAST_BACKWARD_STEP # undef AUX_LAST_FORWARD_STEP # undef AUX_ITER_FOLD_BACKWARD_STEP # undef AUX_ITER_FOLD_BACKWARD_STEP_FUNC # undef AUX_ITER_FOLD_FORWARD_STEP }}} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_ITER_FOLD_IF_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/nested_type_wknd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/nested_type_0000644000175000017500000000254311344301501031576 0ustar debiandebian #ifndef BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED #define BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/nested_type_wknd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x530)) \ || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) namespace boost { namespace mpl { namespace aux { template< typename T > struct nested_type_wknd : T::type { }; }}} #if BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) # define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \ aux::nested_type_wknd \ /**/ #else # define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) \ ::boost::mpl::aux::nested_type_wknd \ /**/ #endif #else // !BOOST_MPL_CFG_GCC et al. # define BOOST_MPL_AUX_NESTED_TYPE_WKND(T) T::type #endif #endif // BOOST_MPL_AUX_NESTED_TYPE_WKND_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_is_class.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_is_clas0000644000175000017500000000307511344301501031562 0ustar debiandebian #ifndef BOOST_MPL_AUX_MSVC_IS_CLASS_HPP_INCLUDED #define BOOST_MPL_AUX_MSVC_IS_CLASS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_is_class.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename T > struct is_class_helper { typedef int (T::* type)(); }; // MSVC 6.x-specific lightweight 'is_class' implementation; // Distinguishing feature: does not instantiate the type being tested. template< typename T > struct msvc_is_class_impl { template< typename U> static yes_tag test(type_wrapper*, /*typename*/ is_class_helper::type = 0); static no_tag test(void const volatile*, ...); enum { value = sizeof(test((type_wrapper*)0)) == sizeof(yes_tag) }; typedef bool_ type; }; // agurt, 17/sep/04: have to check for 'is_reference' upfront to avoid ICEs in // complex metaprograms template< typename T > struct msvc_is_class : if_< is_reference , false_ , msvc_is_class_impl >::type { }; }}} #endif // BOOST_MPL_AUX_MSVC_IS_CLASS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/full_lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/full_lambda.0000644000175000017500000002103511344301501031431 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED #define BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/full_lambda.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include # include # include # include # include # if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) # include # endif #endif #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER full_lambda.hpp # include #else # include # include # include # include # include # include # include # include # include # include namespace boost { namespace mpl { // local macros, #undef-ined at the end of the header # define AUX778076_LAMBDA_PARAMS(i_, param) \ BOOST_MPL_PP_PARAMS(i_, param) \ /**/ # define AUX778076_BIND_PARAMS(param) \ BOOST_MPL_PP_PARAMS( \ BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ , param \ ) \ /**/ # define AUX778076_BIND_N_PARAMS(i_, param) \ BOOST_PP_COMMA_IF(i_) \ BOOST_MPL_PP_PARAMS(i_, param) \ /**/ # define AUX778076_ARITY_PARAM(param) \ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) \ /**/ #define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY namespace aux { template< BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false) > struct lambda_or : true_ { }; template<> struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) > : false_ { }; } // namespace aux #undef n_ template< typename T , typename Tag AUX778076_ARITY_PARAM(typename Arity) > struct lambda { typedef false_ is_le; typedef T result_; typedef T type; }; template< typename T > struct is_lambda_expression : lambda::is_le { }; template< int N, typename Tag > struct lambda< arg,Tag AUX778076_ARITY_PARAM(int_<-1>) > { typedef true_ is_le; typedef mpl::arg result_; // qualified for the sake of MIPSpro 7.41 typedef mpl::protect type; }; #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() /// special case for 'protect' template< typename T, typename Tag > struct lambda< mpl::protect,Tag AUX778076_ARITY_PARAM(int_<1>) > { typedef false_ is_le; typedef mpl::protect result_; typedef result_ type; }; /// specializations for the main 'bind' form template< typename F, AUX778076_BIND_PARAMS(typename T) , typename Tag > struct lambda< bind , Tag AUX778076_ARITY_PARAM(int_) > { typedef false_ is_le; typedef bind result_; typedef result_ type; }; #if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) template< typename F , typename Tag1 , typename Tag2 , typename Arity > struct lambda< lambda , Tag2 , int_<3> > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef bind1< quote1, typename l1::result_ > arity_; typedef lambda< typename if_::type,Tag2 > l3; typedef aux::le_result3 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; #elif !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) /// workaround for MWCW 8.3+/EDG < 303, leads to ambiguity on Digital Mars template< typename F, typename Tag1, typename Tag2 > struct lambda< lambda< F,Tag1 > , Tag2 > { typedef lambda< F,Tag2 > l1; typedef lambda< Tag1,Tag2 > l2; typedef typename l1::is_le is_le; typedef aux::le_result2 le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; #endif # undef AUX778076_ARITY_PARAM # undef AUX778076_BIND_N_PARAMS # undef AUX778076_BIND_PARAMS # undef AUX778076_LAMBDA_PARAMS #if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) BOOST_MPL_AUX_NA_SPEC(2, lambda) #else BOOST_MPL_AUX_NA_SPEC2(2, 3, lambda) #endif }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_FULL_LAMBDA_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 #define i_ BOOST_PP_FRAME_ITERATION(1) #if i_ > 0 namespace aux { # define AUX778076_RESULT(unused, i_, T) \ BOOST_PP_COMMA_IF(i_) \ typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::result_ \ /**/ # define AUX778076_TYPE(unused, i_, T) \ BOOST_PP_COMMA_IF(i_) \ typename BOOST_PP_CAT(T, BOOST_PP_INC(i_))::type \ /**/ template< typename IsLE, typename Tag , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F , AUX778076_LAMBDA_PARAMS(i_, typename L) > struct BOOST_PP_CAT(le_result,i_) { typedef F< BOOST_MPL_PP_REPEAT(i_, AUX778076_TYPE, L) > result_; typedef result_ type; }; template< typename Tag , template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F , AUX778076_LAMBDA_PARAMS(i_, typename L) > struct BOOST_PP_CAT(le_result,i_)< true_,Tag,F,AUX778076_LAMBDA_PARAMS(i_, L) > { typedef BOOST_PP_CAT(bind,i_)< BOOST_PP_CAT(quote,i_) , BOOST_MPL_PP_REPEAT(i_, AUX778076_RESULT, L) > result_; typedef mpl::protect type; }; # undef AUX778076_TYPE # undef AUX778076_RESULT } // namespace aux # define AUX778076_LAMBDA_TYPEDEF(unused, i_, T) \ typedef lambda< BOOST_PP_CAT(T, BOOST_PP_INC(i_)), Tag > \ BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \ /**/ # define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \ typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \ BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \ /**/ # define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \ BOOST_PP_COMMA_IF(i_) \ BOOST_PP_CAT(is_le,BOOST_PP_INC(i_))::value \ /**/ template< template< AUX778076_LAMBDA_PARAMS(i_, typename P) > class F , AUX778076_LAMBDA_PARAMS(i_, typename T) , typename Tag > struct lambda< F , Tag AUX778076_ARITY_PARAM(int_) > { BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, T) BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused) typedef typename aux::lambda_or< BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused) >::type is_le; typedef aux::BOOST_PP_CAT(le_result,i_)< is_le, Tag, F, AUX778076_LAMBDA_PARAMS(i_, l) > le_result_; typedef typename le_result_::result_ result_; typedef typename le_result_::type type; }; # undef AUX778076_IS_LAMBDA_EXPR # undef AUX778076_IS_LE_TYPEDEF # undef AUX778076_LAMBDA_TYPEDEF #endif // i_ > 0 template< typename F AUX778076_BIND_N_PARAMS(i_, typename T) , typename Tag > struct lambda< BOOST_PP_CAT(bind,i_) , Tag AUX778076_ARITY_PARAM(int_) > { typedef false_ is_le; typedef BOOST_PP_CAT(bind,i_)< F AUX778076_BIND_N_PARAMS(i_, T) > result_; typedef result_ type; }; #undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arity.hpp0000644000175000017500000000225711344301501031034 0ustar debiandebian #ifndef BOOST_MPL_AUX_ARITY_HPP_INCLUDED #define BOOST_MPL_AUX_ARITY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arity.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # include # include namespace boost { namespace mpl { namespace aux { // agurt, 15/mar/02: it's possible to implement the template so that it will // "just work" and do not require any specialization, but not on the compilers // that require the arity workaround in the first place template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arity { BOOST_STATIC_CONSTANT(int, value = N); }; }}} #endif // BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES #endif // BOOST_MPL_AUX_ARITY_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/logical_op.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/logical_op.h0000644000175000017500000001104411344301501031446 0ustar debiandebian // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/logical_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include #endif #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { # define AUX778076_PARAMS(param, sub) \ BOOST_MPL_PP_PARAMS( \ BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, sub) \ , param \ ) \ /**/ # define AUX778076_SHIFTED_PARAMS(param, sub) \ BOOST_MPL_PP_EXT_PARAMS( \ 2, BOOST_MPL_PP_SUB(BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY), sub) \ , param \ ) \ /**/ # define AUX778076_SPEC_PARAMS(param) \ BOOST_MPL_PP_ENUM( \ BOOST_PP_DEC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) \ , param \ ) \ /**/ namespace aux { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< bool C_, AUX778076_PARAMS(typename T, 1) > struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) : BOOST_PP_CAT(AUX778076_OP_VALUE1,_) { }; template< AUX778076_PARAMS(typename T, 1) > struct BOOST_PP_CAT(AUX778076_OP_NAME,impl)< AUX778076_OP_VALUE2,AUX778076_PARAMS(T, 1) > : BOOST_PP_CAT(AUX778076_OP_NAME,impl)< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , AUX778076_SHIFTED_PARAMS(T, 1) , BOOST_PP_CAT(AUX778076_OP_VALUE2,_) > { }; template<> struct BOOST_PP_CAT(AUX778076_OP_NAME,impl)< AUX778076_OP_VALUE2 , AUX778076_SPEC_PARAMS(BOOST_PP_CAT(AUX778076_OP_VALUE2,_)) > : BOOST_PP_CAT(AUX778076_OP_VALUE2,_) { }; #else template< bool C_ > struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) { template< AUX778076_PARAMS(typename T, 1) > struct result_ : BOOST_PP_CAT(AUX778076_OP_VALUE1,_) { }; }; template<> struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) { template< AUX778076_PARAMS(typename T, 1) > struct result_ : BOOST_PP_CAT(AUX778076_OP_NAME,impl)< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< AUX778076_SHIFTED_PARAMS(T,1),BOOST_PP_CAT(AUX778076_OP_VALUE2,_) > { }; #if BOOST_WORKAROUND(BOOST_MSVC, == 1300) template<> struct result_ : BOOST_PP_CAT(AUX778076_OP_VALUE2,_) { }; }; #else }; template<> struct BOOST_PP_CAT(AUX778076_OP_NAME,impl) ::result_< AUX778076_SPEC_PARAMS(BOOST_PP_CAT(AUX778076_OP_VALUE2,_)) > : BOOST_PP_CAT(AUX778076_OP_VALUE2,_) { }; #endif // BOOST_MSVC == 1300 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(T1) , typename BOOST_MPL_AUX_NA_PARAM(T2) BOOST_MPL_PP_DEF_PARAMS_TAIL(2, typename T, BOOST_PP_CAT(AUX778076_OP_VALUE2,_)) > struct AUX778076_OP_NAME #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) : aux::BOOST_PP_CAT(AUX778076_OP_NAME,impl)< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value , AUX778076_SHIFTED_PARAMS(T,0) > #else : aux::BOOST_PP_CAT(AUX778076_OP_NAME,impl)< BOOST_MPL_AUX_NESTED_TYPE_WKND(T1)::value >::template result_< AUX778076_SHIFTED_PARAMS(T,0) > #endif { BOOST_MPL_AUX_LAMBDA_SUPPORT( BOOST_MPL_LIMIT_METAFUNCTION_ARITY , AUX778076_OP_NAME , (AUX778076_PARAMS(T, 0)) ) }; BOOST_MPL_AUX_NA_SPEC2( 2 , BOOST_MPL_LIMIT_METAFUNCTION_ARITY , AUX778076_OP_NAME ) }} #undef AUX778076_SPEC_PARAMS #undef AUX778076_SHIFTED_PARAMS #undef AUX778076_PARAMS #undef AUX778076_OP_NAME #undef AUX778076_OP_VALUE1 #undef AUX778076_OP_VALUE2 ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/transform_iter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/transform_it0000644000175000017500000000527511344301501031630 0ustar debiandebian #ifndef BOOST_MPL_AUX_TRANSFORM_ITER_HPP_INCLUDED #define BOOST_MPL_AUX_TRANSFORM_ITER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/transform_iter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Iterator , typename LastIterator , typename F > struct transform_iter { typedef Iterator base; typedef forward_iterator_tag category; typedef transform_iter< typename mpl::next::type,LastIterator,F > next; typedef typename apply1< F , typename deref::type >::type type; }; template< typename LastIterator , typename F > struct transform_iter< LastIterator,LastIterator,F > { typedef LastIterator base; typedef forward_iterator_tag category; }; #else template< typename Iterator , typename LastIterator , typename F > struct transform_iter; template< bool > struct transform_iter_impl { template< typename Iterator , typename LastIterator , typename F > struct result_ { typedef Iterator base; typedef forward_iterator_tag category; typedef transform_iter< typename mpl::next::type,LastIterator,F > next; typedef typename apply1< F , typename deref::type >::type type; }; }; template<> struct transform_iter_impl { template< typename Iterator , typename LastIterator , typename F > struct result_ { typedef Iterator base; typedef forward_iterator_tag category; }; }; template< typename Iterator , typename LastIterator , typename F > struct transform_iter : transform_iter_impl< ::boost::is_same::value >::template result_< Iterator,LastIterator,F > { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION } // namespace aux BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::transform_iter) }} #endif // BOOST_MPL_AUX_TRANSFORM_ITER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_push_front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_push_fr0000644000175000017500000000156511344301501031610 0ustar debiandebian #ifndef BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED #define BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_push_front.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { template< typename Sequence , typename Iterator > struct iter_push_front { typedef typename push_front< Sequence , typename deref::type >::type type; }; }}} #endif // BOOST_MPL_ITER_PUSH_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/largest_int.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/largest_int.0000644000175000017500000000405111344301501031501 0ustar debiandebian #ifndef BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED #define BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/largest_int.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename T > struct integral_rank; template<> struct integral_rank : int_<1> {}; template<> struct integral_rank : int_<2> {}; template<> struct integral_rank : int_<3> {}; template<> struct integral_rank : int_<4> {}; #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) template<> struct integral_rank : int_<5> {}; #endif template<> struct integral_rank : int_<6> {}; template<> struct integral_rank : int_<7> {}; template<> struct integral_rank : int_<8> {}; template<> struct integral_rank : int_<9> {}; template<> struct integral_rank : int_<10> {}; template<> struct integral_rank : int_<11> {}; #if defined(BOOST_HAS_LONG_LONG) template<> struct integral_rank : int_<12> {}; template<> struct integral_rank: int_<13> {}; #endif template< typename T1, typename T2 > struct largest_int #if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) : if_c< ( integral_rank::value >= integral_rank::value ) , T1 , T2 > { #else { enum { rank1 = integral_rank::value }; enum { rank2 = integral_rank::value }; typedef typename if_c< (rank1 >= rank2),T1,T2 >::type type; #endif }; }}} #endif // BOOST_MPL_AUX_LARGEST_INT_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/front_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/front_impl.h0000644000175000017500000000216511344301501031513 0ustar debiandebian #ifndef BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/front_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'front_impl' or the primary 'front' template template< typename Tag > struct front_impl { template< typename Sequence > struct apply { typedef typename begin::type iter_; typedef typename deref::type type; }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,front_impl) }} #endif // BOOST_MPL_AUX_FRONT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_fold_im0000644000175000017500000000251111344301501031543 0ustar debiandebian #ifndef BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_fold_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include # include # endif #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER iter_fold_impl.hpp # include #else # define AUX778076_FOLD_IMPL_OP(iter) iter # define AUX778076_FOLD_IMPL_NAME_PREFIX iter_fold # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_ITER_FOLD_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/template_arity_fwd.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/template_ari0000644000175000017500000000125011344301501031554 0ustar debiandebian #ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED #define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/template_arity_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { namespace aux { template< typename F > struct template_arity; }}} #endif // BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_pred.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_pred.hp0000644000175000017500000000155011344301501031455 0ustar debiandebian #ifndef BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED #define BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_pred.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { template< typename Last > struct fold_pred { template< typename State , typename Iterator > struct apply : not_same_as::template apply { }; }; }}} #endif // BOOST_MPL_AUX_FOLD_PRED_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/0000755000175000017500000000000012146213760030156 5ustar debiandebian././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/assert.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/assert.0000644000175000017500000000177411344301502031460 0ustar debiandebian #ifndef BOOST_MPL_AUX_TEST_ASSERT_HPP_INCLUDED #define BOOST_MPL_AUX_TEST_ASSERT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/assert.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #define MPL_ASSERT(pred) BOOST_MPL_ASSERT(pred) #define MPL_ASSERT_NOT(pred) BOOST_MPL_ASSERT_NOT(pred) #define MPL_ASSERT_MSG(c, msg, types) BOOST_MPL_ASSERT_MSG(c, msg, types) #define MPL_ASSERT_RELATION(x, rel, y) BOOST_MPL_ASSERT_RELATION(x, rel, y) #define MPL_ASSERT_INSTANTIATION(x) \ enum { BOOST_PP_CAT(instantiation_test, __LINE__) = sizeof( x ) } \ /**/ #endif // BOOST_MPL_AUX_TEST_ASSERT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/test_case.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/test_ca0000644000175000017500000000122411344301502031511 0ustar debiandebian #ifndef BOOST_MPL_AUX_TEST_TEST_CASE_HPP_INCLUDED #define BOOST_MPL_AUX_TEST_TEST_CASE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/test_case.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #define MPL_TEST_CASE() void BOOST_PP_CAT(test,__LINE__)() #endif // BOOST_MPL_AUX_TEST_TEST_CASE_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/data.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/data.hp0000644000175000017500000000130011344301502031401 0ustar debiandebian #ifndef BOOST_MPL_AUX_TEST_DATA_HPP_INCLUDED #define BOOST_MPL_AUX_TEST_DATA_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test/data.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include enum enum_ {}; struct UDT {}; struct incomplete; class abstract { public: virtual ~abstract() = 0; }; using boost::noncopyable; #endif // BOOST_MPL_AUX_TEST_DATA_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/unwrap.hpp0000644000175000017500000000162311344301501031214 0ustar debiandebian #ifndef BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED #define BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED // Copyright Peter Dimov and Multi Media Ltd 2001, 2002 // Copyright David Abrahams 2001 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/unwrap.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { template< typename F > inline F& unwrap(F& f, long) { return f; } template< typename F > inline F& unwrap(reference_wrapper& f, int) { return f; } template< typename F > inline F& unwrap(reference_wrapper const& f, int) { return f; } }}} #endif // BOOST_MPL_AUX_UNWRAP_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arity_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arity_spec.h0000644000175000017500000000362511344301501031506 0ustar debiandebian #ifndef BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED #define BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arity_spec.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) \ namespace aux { \ template< BOOST_MPL_AUX_NTTP_DECL(int, N), BOOST_MPL_PP_PARAMS(i,type T) > \ struct arity< \ name< BOOST_MPL_PP_PARAMS(i,T) > \ , N \ > \ { \ BOOST_STATIC_CONSTANT(int \ , value = BOOST_MPL_LIMIT_METAFUNCTION_ARITY \ ); \ }; \ } \ /**/ #else # define BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,type,name) /**/ #endif # define BOOST_MPL_AUX_ARITY_SPEC(i,name) \ BOOST_MPL_AUX_NONTYPE_ARITY_SPEC(i,typename,name) \ /**/ #if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ && !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) \ namespace aux { \ template< BOOST_MPL_PP_PARAMS(i,typename T) > \ struct template_arity< name > \ : int_ \ { \ }; \ } \ /**/ #else # define BOOST_MPL_AUX_TEMPLATE_ARITY_SPEC(i, name) /**/ #endif #endif // BOOST_MPL_AUX_ARITY_SPEC_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_type.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_type.hp0000644000175000017500000000244311344301501031532 0ustar debiandebian #ifndef BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED #define BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_type.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { #if defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) template< bool > struct msvc_type_impl { template< typename T > struct result_ { typedef typename T::type type; }; }; template<> struct msvc_type_impl { template< typename T > struct result_ { typedef result_ type; }; }; template< typename T > struct msvc_type : msvc_type_impl< is_msvc_eti_arg::value > ::template result_ { }; #else // BOOST_MPL_CFG_MSVC_70_ETI_BUG template< typename T > struct msvc_type { typedef typename T::type type; }; template<> struct msvc_type { typedef int type; }; #endif }}} #endif // BOOST_MPL_AUX_MSVC_TYPE_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/empty_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/empty_impl.h0000644000175000017500000000222011344301501031511 0ustar debiandebian #ifndef BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/empty_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'empty_impl' or the primary 'empty' template template< typename Tag > struct empty_impl { template< typename Sequence > struct apply : is_same< typename begin::type , typename end::type > { }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,empty_impl) }} #endif // BOOST_MPL_AUX_EMPTY_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/nttp_decl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/nttp_decl.hp0000644000175000017500000000154411344301501031476 0ustar debiandebian #ifndef BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED #define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/nttp_decl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if defined(BOOST_MPL_CFG_NTTP_BUG) typedef int _mpl_nttp_int; typedef long _mpl_nttp_long; # include # define BOOST_MPL_AUX_NTTP_DECL(T, x) BOOST_PP_CAT(_mpl_nttp_,T) x /**/ #else # define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/ #endif #endif // BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/back_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/back_impl.hp0000644000175000017500000000231511344301501031440 0ustar debiandebian #ifndef BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/back_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { // default implementation, requires at least bi-directional iterators; // conrete sequences might override it by specializing either the // 'back_impl' or the primary 'back' template template< typename Tag > struct back_impl { template< typename Sequence > struct apply { typedef typename end::type end_; typedef typename prior::type last_; typedef typename deref::type type; }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, back_impl) }} #endif // BOOST_MPL_AUX_BACK_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/yes_no.hpp0000644000175000017500000000240611344301501031174 0ustar debiandebian #ifndef BOOST_MPL_AUX_YES_NO_HPP_INCLUDED #define BOOST_MPL_AUX_YES_NO_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/yes_no.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { namespace aux { typedef char (&no_tag)[1]; typedef char (&yes_tag)[2]; template< bool C_ > struct yes_no_tag { typedef no_tag type; }; template<> struct yes_no_tag { typedef yes_tag type; }; template< BOOST_MPL_AUX_NTTP_DECL(long, n) > struct weighted_tag { #if !BOOST_WORKAROUND(BOOST_MSVC, == 1200) typedef char (&type)[n]; #else char buf[n]; typedef weighted_tag type; #endif }; #if defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) template<> struct weighted_tag<0> { typedef char (&type)[1]; }; #endif }}} #endif // BOOST_MPL_AUX_YES_NO_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_never_true.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_never_t0000644000175000017500000000153111344301501031602 0ustar debiandebian #ifndef BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED #define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_never_true.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) namespace boost { namespace mpl { namespace aux { template< typename T > struct msvc_never_true { enum { value = false }; }; }}} #endif // BOOST_MSVC #endif // BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_begin.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_begin.hp0000644000175000017500000000126011344301501031434 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_begin.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_begin, begin, true) }}} #endif // BOOST_MPL_AUX_HAS_BEGIN_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/contains_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/contains_imp0000644000175000017500000000322411344301501031574 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED // Copyright Eric Friedman 2002 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/contains_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Tag > struct contains_impl { template< typename Sequence, typename T > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : not_< is_same< typename find::type , typename end::type > > { #else { typedef not_< is_same< typename find::type , typename end::type > > type; BOOST_STATIC_CONSTANT(bool, value = (not_< is_same< typename find::type , typename end::type > >::value) ); #endif }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,contains_impl) }} #endif // BOOST_MPL_AUX_CONTAINS_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test.hpp0000644000175000017500000000137611344301501030664 0ustar debiandebian #ifndef BOOST_MPL_AUX_TEST_HPP_INCLUDED #define BOOST_MPL_AUX_TEST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/test.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include int main() { return 0; } using namespace boost; using namespace mpl; #endif // BOOST_MPL_AUX_TEST_HPP_INCLUDED ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_fold_impl_body.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_fold0000644000175000017500000002474011344301501031576 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION! #if !defined(BOOST_PP_IS_ITERATING) // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_fold_impl_body.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ # include # include # include # include # include # include # include # include # include // local macros, #undef-ined at the end of the header # define AUX778076_ITER_FOLD_FORWARD_STEP(unused, n_, unused2) \ typedef typename apply2< \ ForwardOp \ , BOOST_PP_CAT(fwd_state,n_) \ , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,n_)) \ >::type BOOST_PP_CAT(fwd_state,BOOST_PP_INC(n_)); \ typedef typename mpl::next::type \ BOOST_PP_CAT(iter,BOOST_PP_INC(n_)); \ /**/ # define AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC(n_) \ typedef typename apply2< \ BackwardOp \ , BOOST_PP_CAT(bkwd_state,n_) \ , AUX778076_FOLD_IMPL_OP(BOOST_PP_CAT(iter,BOOST_PP_DEC(n_))) \ >::type BOOST_PP_CAT(bkwd_state,BOOST_PP_DEC(n_)); \ /**/ # define AUX778076_ITER_FOLD_BACKWARD_STEP(unused, n_, j) \ AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC( \ BOOST_PP_SUB_D(1,j,n_) \ ) \ /**/ # define AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(n_) \ typedef typename nested_chunk::state BOOST_PP_CAT(bkwd_state,n_); /**/ # define AUX778076_FOLD_IMPL_NAME \ BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_impl) \ /**/ # define AUX778076_FOLD_CHUNK_NAME \ BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_chunk) \ /**/ namespace boost { namespace mpl { namespace aux { /// forward declaration template< BOOST_MPL_AUX_NTTP_DECL(long, N) , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) # include BOOST_PP_ITERATE() // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING template< BOOST_MPL_AUX_NTTP_DECL(long, N) , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME { typedef First iter0; typedef State fwd_state0; BOOST_MPL_PP_REPEAT( BOOST_MPL_LIMIT_UNROLLING , AUX778076_ITER_FOLD_FORWARD_STEP , unused ) typedef AUX778076_FOLD_IMPL_NAME< ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) , BOOST_PP_CAT(iter,BOOST_MPL_LIMIT_UNROLLING) , Last , BOOST_PP_CAT(fwd_state,BOOST_MPL_LIMIT_UNROLLING) , BackwardOp , ForwardOp > nested_chunk; AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(BOOST_MPL_LIMIT_UNROLLING) BOOST_MPL_PP_REPEAT( BOOST_MPL_LIMIT_UNROLLING , AUX778076_ITER_FOLD_BACKWARD_STEP , BOOST_MPL_LIMIT_UNROLLING ) typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; // fallback implementation for sequences of unknown size template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME<-1,First,Last,State,BackwardOp,ForwardOp> { typedef AUX778076_FOLD_IMPL_NAME< -1 , typename mpl::next::type , Last , typename apply2::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , AUX778076_FOLD_IMPL_OP(First) >::type state; typedef typename nested_step::iterator iterator; }; template< typename Last , typename State , typename BackwardOp , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME<-1,Last,Last,State,BackwardOp,ForwardOp> { typedef State state; typedef Last iterator; }; #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct AUX778076_FOLD_CHUNK_NAME; # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) # include BOOST_PP_ITERATE() // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct AUX778076_FOLD_CHUNK_NAME { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; BOOST_MPL_PP_REPEAT( BOOST_MPL_LIMIT_UNROLLING , AUX778076_ITER_FOLD_FORWARD_STEP , unused ) typedef AUX778076_FOLD_IMPL_NAME< ( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING ) , BOOST_PP_CAT(iter,BOOST_MPL_LIMIT_UNROLLING) , Last , BOOST_PP_CAT(fwd_state,BOOST_MPL_LIMIT_UNROLLING) , BackwardOp , ForwardOp > nested_chunk; AUX778076_FIRST_BACKWARD_STATE_TYPEDEF(BOOST_MPL_LIMIT_UNROLLING) BOOST_MPL_PP_REPEAT( BOOST_MPL_LIMIT_UNROLLING , AUX778076_ITER_FOLD_BACKWARD_STEP , BOOST_MPL_LIMIT_UNROLLING ) typedef bkwd_state0 state; typedef typename nested_chunk::iterator iterator; }; }; // fallback implementation for sequences of unknown size template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step); template< typename Last , typename State > struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) { typedef Last iterator; typedef State state; }; template<> struct AUX778076_FOLD_CHUNK_NAME<-1> { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef typename if_< typename is_same::type , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_null_step) , BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) >::type res_; typedef typename res_::state state; typedef typename res_::iterator iterator; }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) /// ETI workaround template<> struct result_ { typedef int state; typedef int iterator; }; #endif }; template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct BOOST_PP_CAT(AUX778076_FOLD_IMPL_NAME_PREFIX,_step) { typedef AUX778076_FOLD_CHUNK_NAME<-1>::template result_< typename mpl::next::type , Last , typename apply2::type , BackwardOp , ForwardOp > nested_step; typedef typename apply2< BackwardOp , typename nested_step::state , AUX778076_FOLD_IMPL_OP(First) >::type state; typedef typename nested_step::iterator iterator; }; template< BOOST_MPL_AUX_NTTP_DECL(long, N) , typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME : AUX778076_FOLD_CHUNK_NAME ::template result_ { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION }}} # undef AUX778076_FIRST_BACKWARD_STATE_TYPEDEF # undef AUX778076_ITER_FOLD_BACKWARD_STEP # undef AUX778076_ITER_FOLD_BACKWARD_STEP_FUNC # undef AUX778076_ITER_FOLD_FORWARD_STEP #undef AUX778076_FOLD_IMPL_OP #undef AUX778076_FOLD_IMPL_NAME_PREFIX ///// iteration #else # define n_ BOOST_PP_FRAME_ITERATION(1) #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ && !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct AUX778076_FOLD_IMPL_NAME { typedef First iter0; typedef State fwd_state0; BOOST_MPL_PP_REPEAT( n_ , AUX778076_ITER_FOLD_FORWARD_STEP , unused ) typedef BOOST_PP_CAT(fwd_state,n_) BOOST_PP_CAT(bkwd_state,n_); BOOST_MPL_PP_REPEAT( n_ , AUX778076_ITER_FOLD_BACKWARD_STEP , n_ ) typedef bkwd_state0 state; typedef BOOST_PP_CAT(iter,n_) iterator; }; #else template<> struct AUX778076_FOLD_CHUNK_NAME { template< typename First , typename Last , typename State , typename BackwardOp , typename ForwardOp > struct result_ { typedef First iter0; typedef State fwd_state0; BOOST_MPL_PP_REPEAT( n_ , AUX778076_ITER_FOLD_FORWARD_STEP , unused ) typedef BOOST_PP_CAT(fwd_state,n_) BOOST_PP_CAT(bkwd_state,n_); BOOST_MPL_PP_REPEAT( n_ , AUX778076_ITER_FOLD_BACKWARD_STEP , n_ ) typedef bkwd_state0 state; typedef BOOST_PP_CAT(iter,n_) iterator; }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) /// ETI workaround template<> struct result_ { typedef int state; typedef int iterator; }; #endif }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # undef n_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_type.hpp0000644000175000017500000000125211344301501031512 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_type.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_type, type, true) }}} #endif // BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/template_arity.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/template_ari0000644000175000017500000001133511344301501031561 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED #define BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/template_arity.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) # include # endif # else # include # endif #endif #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER template_arity.hpp # include #else # if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) # include # include # include # include # include # include # include # include # include # include # define AUX778076_ARITY BOOST_PP_INC(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) namespace boost { namespace mpl { namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arity_tag { typedef char (&type)[N + 1]; }; # define AUX778076_MAX_ARITY_OP(unused, state, i_) \ ( BOOST_PP_CAT(C,i_) > 0 ? BOOST_PP_CAT(C,i_) : state ) \ /**/ template< BOOST_MPL_PP_PARAMS(AUX778076_ARITY, BOOST_MPL_AUX_NTTP_DECL(int, C)) > struct max_arity { BOOST_STATIC_CONSTANT(int, value = BOOST_PP_SEQ_FOLD_LEFT( AUX778076_MAX_ARITY_OP , -1 , BOOST_MPL_PP_RANGE(1, AUX778076_ARITY) ) ); }; # undef AUX778076_MAX_ARITY_OP arity_tag<0>::type arity_helper(...); # define BOOST_PP_ITERATION_LIMITS (1, AUX778076_ARITY) # define BOOST_PP_FILENAME_1 # include BOOST_PP_ITERATE() template< typename F, BOOST_MPL_AUX_NTTP_DECL(int, N) > struct template_arity_impl { BOOST_STATIC_CONSTANT(int, value = sizeof(arity_helper(type_wrapper(),arity_tag())) - 1 ); }; # define AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION(unused, i_, F) \ BOOST_PP_COMMA_IF(i_) template_arity_impl::value \ /**/ template< typename F > struct template_arity { BOOST_STATIC_CONSTANT(int, value = ( max_arity< BOOST_MPL_PP_REPEAT( AUX778076_ARITY , AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION , F ) >::value )); typedef mpl::int_ type; }; # undef AUX778076_TEMPLATE_ARITY_IMPL_INVOCATION # undef AUX778076_ARITY }}} # endif // BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING # else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT # include namespace boost { namespace mpl { namespace aux { template< bool > struct template_arity_impl { template< typename F > struct result_ : mpl::int_<-1> { }; }; template<> struct template_arity_impl { template< typename F > struct result_ : F::arity { }; }; template< typename F > struct template_arity : template_arity_impl< ::boost::mpl::aux::has_rebind::value > ::template result_ { }; #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) template<> struct template_arity : mpl::int_<-1> { }; #endif }}} # endif // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_TEMPLATE_ARITY_HPP_INCLUDED ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) template< template< BOOST_MPL_PP_PARAMS(i_, typename P) > class F , BOOST_MPL_PP_PARAMS(i_, typename T) > typename arity_tag::type arity_helper(type_wrapper< F >, arity_tag); #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_rebind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_rebind.h0000644000175000017500000000512411344301501031436 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_rebind.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) # include #elif BOOST_WORKAROUND(BOOST_MSVC, <= 1200) # include # include # include # include #elif BOOST_WORKAROUND(__BORLANDC__, < 0x600) # include # include # include # include # include #else # include # include # include #endif namespace boost { namespace mpl { namespace aux { #if BOOST_WORKAROUND(__EDG_VERSION__, <= 244) && !defined(BOOST_INTEL_CXX_VERSION) BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_rebind, rebind, false) #elif BOOST_WORKAROUND(BOOST_MSVC, <= 1200) BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_rebind_impl, rebind, false) template< typename T > struct has_rebind : if_< msvc_is_class , has_rebind_impl , bool_ >::type { }; #else // the rest template< typename T > struct has_rebind_tag {}; no_tag operator|(has_rebind_tag, void const volatile*); # if !BOOST_WORKAROUND(__BORLANDC__, < 0x600) template< typename T > struct has_rebind { static has_rebind_tag* get(); BOOST_STATIC_CONSTANT(bool, value = sizeof(has_rebind_tag() | get()) == sizeof(yes_tag) ); }; # else // __BORLANDC__ template< typename T > struct has_rebind_impl { static T* get(); BOOST_STATIC_CONSTANT(bool, value = sizeof(has_rebind_tag() | get()) == sizeof(yes_tag) ); }; template< typename T > struct has_rebind : if_< is_class , has_rebind_impl , bool_ >::type { }; # endif // __BORLANDC__ #endif }}} #endif // BOOST_MPL_AUX_HAS_REBIND_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000755000175000017500000000000012146213760031646 5ustar debiandebian././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/range.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000135211344301502031640 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/range.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #define BOOST_MPL_PP_RANGE(first, length) \ BOOST_PP_SEQ_SUBSEQ((0)(1)(2)(3)(4)(5)(6)(7)(8)(9), first, length) \ /**/ #endif // BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED ././@LongLink0000000000000000000000000000016500000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/token_equal.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000374411344301502031647 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_TOKEN_EQUAL_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_TOKEN_EQUAL_HPP_INCLUDED // Copyright Paul Mensonides 2003 // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/token_equal.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include // compares tokens 'a' and 'b' for equality: // // #define BOOST_MPL_PP_TOKEN_EQUAL_apple(x) x // #define BOOST_MPL_PP_TOKEN_EQUAL_orange(x) x // // BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_TOKEN_EQUAL(apple, abc) ) ) // BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_TOKEN_EQUAL(abc, apple) ) ) // BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_TOKEN_EQUAL(apple, orange) ) ) // BOOST_PP_ASSERT( BOOST_MPL_PP_TOKEN_EQUAL(apple, apple) ) // BOOST_PP_ASSERT( BOOST_MPL_PP_TOKEN_EQUAL(orange, orange) ) #define BOOST_MPL_PP_TOKEN_EQUAL(a, b) \ BOOST_PP_IIF( \ BOOST_PP_BITAND( \ BOOST_MPL_PP_IS_SEQ( BOOST_PP_CAT(BOOST_MPL_PP_TOKEN_EQUAL_, a)((unused)) ) \ , BOOST_MPL_PP_IS_SEQ( BOOST_PP_CAT(BOOST_MPL_PP_TOKEN_EQUAL_, b)((unused)) ) \ ) \ , BOOST_MPL_PP_TOKEN_EQUAL_I \ , 0 BOOST_PP_TUPLE_EAT(2) \ )(a, b) \ /**/ #define BOOST_MPL_PP_TOKEN_EQUAL_I(a, b) \ BOOST_PP_COMPL(BOOST_MPL_PP_IS_SEQ( \ BOOST_MPL_PP_TOKEN_EQUAL_ ## a( \ BOOST_MPL_PP_TOKEN_EQUAL_ ## b \ )((unused)) \ )) \ /**/ #endif // BOOST_MPL_AUX_PREPROCESSOR_TOKEN_EQUAL_HPP_INCLUDED ././@LongLink0000000000000000000000000000017100000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/def_params_tail.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000001077011344301502031644 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include // BOOST_MPL_PP_DEF_PARAMS_TAIL(1,T,value): , T1 = value, .., Tn = value // BOOST_MPL_PP_DEF_PARAMS_TAIL(2,T,value): , T2 = value, .., Tn = value // BOOST_MPL_PP_DEF_PARAMS_TAIL(n,T,value): #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include # include # define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, value_func) \ BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_1( \ i \ , BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,i) \ , param \ , value_func \ ) \ /**/ # define BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_1(i, n, param, value_func) \ BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_2(i,n,param,value_func) \ /**/ # define BOOST_MPL_PP_DEF_PARAMS_TAIL_DELAY_2(i, n, param, value_func) \ BOOST_PP_COMMA_IF(BOOST_PP_AND(i,n)) \ BOOST_MPL_PP_DEF_PARAMS_TAIL_##i(n,param,value_func) \ /**/ # define BOOST_MPL_PP_DEF_PARAMS_TAIL_0(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##1 v(),p##2 v(),p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v()) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_1(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##2 v(),p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_2(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##3 v(),p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_3(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##4 v(),p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_4(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##5 v(),p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_5(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##6 v(),p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4,p5) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_6(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##7 v(),p##8 v(),p##9 v(),p1,p2,p3,p4,p5,p6) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_7(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##8 v(),p##9 v(),p1,p2,p3,p4,p5,p6,p7) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_8(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p##9 v(),p1,p2,p3,p4,p5,p6,p7,p8) # define BOOST_MPL_PP_DEF_PARAMS_TAIL_9(i,p,v) BOOST_MPL_PP_FILTER_PARAMS_##i(p1,p2,p3,p4,p5,p6,p7,p8,p9) #else # include # include # include # include # include # include # define BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC(unused, i, op) \ , BOOST_PP_CAT( \ BOOST_PP_TUPLE_ELEM(3, 1, op) \ , BOOST_PP_ADD_D(1, i, BOOST_PP_INC(BOOST_PP_TUPLE_ELEM(3, 0, op))) \ ) BOOST_PP_TUPLE_ELEM(3, 2, op)() \ /**/ # define BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, value_func) \ BOOST_PP_REPEAT( \ BOOST_PP_SUB_D(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, i) \ , BOOST_MPL_PP_AUX_TAIL_PARAM_FUNC \ , (i, param, value_func) \ ) \ /**/ #endif // BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES #define BOOST_MPL_PP_DEF_PARAMS_TAIL(i, param, value) \ BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value)) \ /**/ #if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, param, value) \ BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_IDENTITY(=value)) \ /**/ #else # define BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, param, value) \ BOOST_MPL_PP_DEF_PARAMS_TAIL_IMPL(i, param, BOOST_PP_EMPTY) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_DEF_PARAMS_TAIL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/sub.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000364611344301502031650 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_SUB_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_SUB_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/sub.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include #if defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) # include # define BOOST_MPL_PP_SUB(i,j) \ BOOST_MPL_PP_SUB_DELAY(i,j) \ /**/ # define BOOST_MPL_PP_SUB_DELAY(i,j) \ BOOST_PP_CAT(BOOST_MPL_PP_TUPLE_11_ELEM_##i,BOOST_MPL_PP_SUB_##j) \ /**/ #else # define BOOST_MPL_PP_SUB(i,j) \ BOOST_MPL_PP_SUB_DELAY(i,j) \ /**/ # define BOOST_MPL_PP_SUB_DELAY(i,j) \ BOOST_MPL_PP_TUPLE_11_ELEM_##i BOOST_MPL_PP_SUB_##j \ /**/ #endif # define BOOST_MPL_PP_SUB_0 (0,1,2,3,4,5,6,7,8,9,10) # define BOOST_MPL_PP_SUB_1 (0,0,1,2,3,4,5,6,7,8,9) # define BOOST_MPL_PP_SUB_2 (0,0,0,1,2,3,4,5,6,7,8) # define BOOST_MPL_PP_SUB_3 (0,0,0,0,1,2,3,4,5,6,7) # define BOOST_MPL_PP_SUB_4 (0,0,0,0,0,1,2,3,4,5,6) # define BOOST_MPL_PP_SUB_5 (0,0,0,0,0,0,1,2,3,4,5) # define BOOST_MPL_PP_SUB_6 (0,0,0,0,0,0,0,1,2,3,4) # define BOOST_MPL_PP_SUB_7 (0,0,0,0,0,0,0,0,1,2,3) # define BOOST_MPL_PP_SUB_8 (0,0,0,0,0,0,0,0,0,1,2) # define BOOST_MPL_PP_SUB_9 (0,0,0,0,0,0,0,0,0,0,1) # define BOOST_MPL_PP_SUB_10 (0,0,0,0,0,0,0,0,0,0,0) #else # include # define BOOST_MPL_PP_SUB(i,j) \ BOOST_PP_SUB(i,j) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_SUB_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/tuple.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000257511344301502031650 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/tuple.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #define BOOST_MPL_PP_TUPLE_11_ELEM_0(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e0 #define BOOST_MPL_PP_TUPLE_11_ELEM_1(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e1 #define BOOST_MPL_PP_TUPLE_11_ELEM_2(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e2 #define BOOST_MPL_PP_TUPLE_11_ELEM_3(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e3 #define BOOST_MPL_PP_TUPLE_11_ELEM_4(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e4 #define BOOST_MPL_PP_TUPLE_11_ELEM_5(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e5 #define BOOST_MPL_PP_TUPLE_11_ELEM_6(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e6 #define BOOST_MPL_PP_TUPLE_11_ELEM_7(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e7 #define BOOST_MPL_PP_TUPLE_11_ELEM_8(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e8 #define BOOST_MPL_PP_TUPLE_11_ELEM_9(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e9 #define BOOST_MPL_PP_TUPLE_11_ELEM_10(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10) e10 #endif // BOOST_MPL_AUX_PREPROCESSOR_TUPLE_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000377411344301502031652 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/params.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include // BOOST_MPL_PP_PARAMS(0,T): // BOOST_MPL_PP_PARAMS(1,T): T1 // BOOST_MPL_PP_PARAMS(2,T): T1, T2 // BOOST_MPL_PP_PARAMS(n,T): T1, T2, .., Tn #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include # define BOOST_MPL_PP_PARAMS(n,p) \ BOOST_PP_CAT(BOOST_MPL_PP_PARAMS_,n)(p) \ /**/ # define BOOST_MPL_PP_PARAMS_0(p) # define BOOST_MPL_PP_PARAMS_1(p) p##1 # define BOOST_MPL_PP_PARAMS_2(p) p##1,p##2 # define BOOST_MPL_PP_PARAMS_3(p) p##1,p##2,p##3 # define BOOST_MPL_PP_PARAMS_4(p) p##1,p##2,p##3,p##4 # define BOOST_MPL_PP_PARAMS_5(p) p##1,p##2,p##3,p##4,p##5 # define BOOST_MPL_PP_PARAMS_6(p) p##1,p##2,p##3,p##4,p##5,p##6 # define BOOST_MPL_PP_PARAMS_7(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7 # define BOOST_MPL_PP_PARAMS_8(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8 # define BOOST_MPL_PP_PARAMS_9(p) p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9 #else # include # include # include # include # define BOOST_MPL_PP_AUX_PARAM_FUNC(unused, i, param) \ BOOST_PP_COMMA_IF(i) \ BOOST_PP_CAT(param, BOOST_PP_INC(i)) \ /**/ # define BOOST_MPL_PP_PARAMS(n, param) \ BOOST_PP_REPEAT( \ n \ , BOOST_MPL_PP_AUX_PARAM_FUNC \ , param \ ) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_PARAMS_HPP_INCLUDED ././@LongLink0000000000000000000000000000017000000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/default_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000473111344301502031644 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/default_params.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include // BOOST_MPL_PP_DEFAULT_PARAMS(0,T,int): // BOOST_MPL_PP_DEFAULT_PARAMS(1,T,int): T1 = int // BOOST_MPL_PP_DEFAULT_PARAMS(2,T,int): T1 = int, T2 = int // BOOST_MPL_PP_DEFAULT_PARAMS(n,T,int): T1 = int, T2 = int, .., Tn = int #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include # define BOOST_MPL_PP_DEFAULT_PARAMS(n,p,v) \ BOOST_PP_CAT(BOOST_MPL_PP_DEFAULT_PARAMS_,n)(p,v) \ /**/ # define BOOST_MPL_PP_DEFAULT_PARAMS_0(p,v) # define BOOST_MPL_PP_DEFAULT_PARAMS_1(p,v) p##1=v # define BOOST_MPL_PP_DEFAULT_PARAMS_2(p,v) p##1=v,p##2=v # define BOOST_MPL_PP_DEFAULT_PARAMS_3(p,v) p##1=v,p##2=v,p##3=v # define BOOST_MPL_PP_DEFAULT_PARAMS_4(p,v) p##1=v,p##2=v,p##3=v,p##4=v # define BOOST_MPL_PP_DEFAULT_PARAMS_5(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v # define BOOST_MPL_PP_DEFAULT_PARAMS_6(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v # define BOOST_MPL_PP_DEFAULT_PARAMS_7(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v # define BOOST_MPL_PP_DEFAULT_PARAMS_8(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v,p##8=v # define BOOST_MPL_PP_DEFAULT_PARAMS_9(p,v) p##1=v,p##2=v,p##3=v,p##4=v,p##5=v,p##6=v,p##7=v,p##8=v,p##9=v #else # include # include # include # include # include # define BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC(unused, i, pv) \ BOOST_PP_COMMA_IF(i) \ BOOST_PP_CAT( BOOST_PP_TUPLE_ELEM(2,0,pv), BOOST_PP_INC(i) ) \ = BOOST_PP_TUPLE_ELEM(2,1,pv) \ /**/ # define BOOST_MPL_PP_DEFAULT_PARAMS(n, param, value) \ BOOST_PP_REPEAT( \ n \ , BOOST_MPL_PP_AUX_DEFAULT_PARAM_FUNC \ , (param,value) \ ) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_DEFAULT_PARAMS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/is_seq.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000410011344301502031632 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_IS_SEQ_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_IS_SEQ_HPP_INCLUDED // Copyright Paul Mensonides 2003 // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/is_seq.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include // returns 1 if 'seq' is a PP-sequence, 0 otherwise: // // BOOST_PP_ASSERT( BOOST_PP_NOT( BOOST_MPL_PP_IS_SEQ( int ) ) ) // BOOST_PP_ASSERT( BOOST_MPL_PP_IS_SEQ( (int) ) ) // BOOST_PP_ASSERT( BOOST_MPL_PP_IS_SEQ( (1)(2) ) ) #if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC() # define BOOST_MPL_PP_IS_SEQ(seq) BOOST_PP_DEC( BOOST_PP_SEQ_SIZE( BOOST_MPL_PP_IS_SEQ_(seq) ) ) # define BOOST_MPL_PP_IS_SEQ_(seq) BOOST_MPL_PP_IS_SEQ_SEQ_( BOOST_MPL_PP_IS_SEQ_SPLIT_ seq ) # define BOOST_MPL_PP_IS_SEQ_SEQ_(x) (x) # define BOOST_MPL_PP_IS_SEQ_SPLIT_(unused) unused)((unused) #else # if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() # define BOOST_MPL_PP_IS_SEQ(seq) BOOST_MPL_PP_IS_SEQ_MWCC_((seq)) # define BOOST_MPL_PP_IS_SEQ_MWCC_(args) BOOST_MPL_PP_IS_SEQ_ ## args # else # define BOOST_MPL_PP_IS_SEQ(seq) BOOST_MPL_PP_IS_SEQ_(seq) # endif # define BOOST_MPL_PP_IS_SEQ_(seq) BOOST_PP_CAT(BOOST_MPL_PP_IS_SEQ_, BOOST_MPL_PP_IS_SEQ_0 seq BOOST_PP_RPAREN()) # define BOOST_MPL_PP_IS_SEQ_0(x) BOOST_MPL_PP_IS_SEQ_1(x # define BOOST_MPL_PP_IS_SEQ_ALWAYS_0(unused) 0 # define BOOST_MPL_PP_IS_SEQ_BOOST_MPL_PP_IS_SEQ_0 BOOST_MPL_PP_IS_SEQ_ALWAYS_0( # define BOOST_MPL_PP_IS_SEQ_BOOST_MPL_PP_IS_SEQ_1(unused) 1 #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_IS_SEQ_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/repeat.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000365411344301502031647 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_REPEAT_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_REPEAT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/repeat.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include # define BOOST_MPL_PP_REPEAT(n,f,param) \ BOOST_PP_CAT(BOOST_MPL_PP_REPEAT_,n)(f,param) \ /**/ # define BOOST_MPL_PP_REPEAT_0(f,p) # define BOOST_MPL_PP_REPEAT_1(f,p) f(0,0,p) # define BOOST_MPL_PP_REPEAT_2(f,p) f(0,0,p) f(0,1,p) # define BOOST_MPL_PP_REPEAT_3(f,p) f(0,0,p) f(0,1,p) f(0,2,p) # define BOOST_MPL_PP_REPEAT_4(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) # define BOOST_MPL_PP_REPEAT_5(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) # define BOOST_MPL_PP_REPEAT_6(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) # define BOOST_MPL_PP_REPEAT_7(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) # define BOOST_MPL_PP_REPEAT_8(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) f(0,7,p) # define BOOST_MPL_PP_REPEAT_9(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) f(0,7,p) f(0,8,p) # define BOOST_MPL_PP_REPEAT_10(f,p) f(0,0,p) f(0,1,p) f(0,2,p) f(0,3,p) f(0,4,p) f(0,5,p) f(0,6,p) f(0,7,p) f(0,8,p) f(0,9,p) #else # include # define BOOST_MPL_PP_REPEAT(n,f,param) \ BOOST_PP_REPEAT(n,f,param) \ /**/ #endif #define BOOST_MPL_PP_REPEAT_IDENTITY_FUNC(unused1, unused2, x) x #endif // BOOST_MPL_AUX_PREPROCESSOR_REPEAT_HPP_INCLUDED ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/filter_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000256411344301502031646 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/filter_params.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #define BOOST_MPL_PP_FILTER_PARAMS_0(p1,p2,p3,p4,p5,p6,p7,p8,p9) #define BOOST_MPL_PP_FILTER_PARAMS_1(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1 #define BOOST_MPL_PP_FILTER_PARAMS_2(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2 #define BOOST_MPL_PP_FILTER_PARAMS_3(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3 #define BOOST_MPL_PP_FILTER_PARAMS_4(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4 #define BOOST_MPL_PP_FILTER_PARAMS_5(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5 #define BOOST_MPL_PP_FILTER_PARAMS_6(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6 #define BOOST_MPL_PP_FILTER_PARAMS_7(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7 #define BOOST_MPL_PP_FILTER_PARAMS_8(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7,p8 #define BOOST_MPL_PP_FILTER_PARAMS_9(p1,p2,p3,p4,p5,p6,p7,p8,p9) p1,p2,p3,p4,p5,p6,p7,p8,p9 #endif // BOOST_MPL_AUX_PREPROCESSOR_FILTER_PARAMS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/ext_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000573711344301502031653 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_EXT_PARAMS_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_EXT_PARAMS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/ext_params.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include // BOOST_MPL_PP_EXT_PARAMS(2,2,T): // BOOST_MPL_PP_EXT_PARAMS(2,3,T): T2 // BOOST_MPL_PP_EXT_PARAMS(2,4,T): T2, T3 // BOOST_MPL_PP_EXT_PARAMS(2,n,T): T2, T3, .., Tn-1 #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include # include # define BOOST_MPL_PP_EXT_PARAMS(i,j,p) \ BOOST_MPL_PP_EXT_PARAMS_DELAY_1(i,BOOST_MPL_PP_SUB(j,i),p) \ /**/ # define BOOST_MPL_PP_EXT_PARAMS_DELAY_1(i,n,p) \ BOOST_MPL_PP_EXT_PARAMS_DELAY_2(i,n,p) \ /**/ # define BOOST_MPL_PP_EXT_PARAMS_DELAY_2(i,n,p) \ BOOST_MPL_PP_EXT_PARAMS_##i(n,p) \ /**/ # define BOOST_MPL_PP_EXT_PARAMS_1(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##1,p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9) # define BOOST_MPL_PP_EXT_PARAMS_2(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##2,p##3,p##4,p##5,p##6,p##7,p##8,p##9,p1) # define BOOST_MPL_PP_EXT_PARAMS_3(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##3,p##4,p##5,p##6,p##7,p##8,p##9,p1,p2) # define BOOST_MPL_PP_EXT_PARAMS_4(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##4,p##5,p##6,p##7,p##8,p##9,p1,p2,p3) # define BOOST_MPL_PP_EXT_PARAMS_5(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##5,p##6,p##7,p##8,p##9,p1,p2,p3,p4) # define BOOST_MPL_PP_EXT_PARAMS_6(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##6,p##7,p##8,p##9,p1,p2,p3,p4,p5) # define BOOST_MPL_PP_EXT_PARAMS_7(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##7,p##8,p##9,p1,p2,p3,p4,p5,p6) # define BOOST_MPL_PP_EXT_PARAMS_8(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##8,p##9,p1,p2,p3,p4,p5,p6,p7) # define BOOST_MPL_PP_EXT_PARAMS_9(i,p) BOOST_MPL_PP_FILTER_PARAMS_##i(p##9,p1,p2,p3,p4,p5,p6,p7,p8) #else # include # include # include # include # include # include # define BOOST_MPL_PP_AUX_EXT_PARAM_FUNC(unused, i, op) \ BOOST_PP_COMMA_IF(i) \ BOOST_PP_CAT( \ BOOST_PP_TUPLE_ELEM(2,1,op) \ , BOOST_PP_ADD_D(1, i, BOOST_PP_TUPLE_ELEM(2,0,op)) \ ) \ /**/ # define BOOST_MPL_PP_EXT_PARAMS(i, j, param) \ BOOST_PP_REPEAT( \ BOOST_PP_SUB_D(1,j,i) \ , BOOST_MPL_PP_AUX_EXT_PARAM_FUNC \ , (i,param) \ ) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_EXT_PARAMS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/enum.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000335411344301502031644 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/enum.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include // BOOST_MPL_PP_ENUM(0,int): // BOOST_MPL_PP_ENUM(1,int): int // BOOST_MPL_PP_ENUM(2,int): int, int // BOOST_MPL_PP_ENUM(n,int): int, int, .., int #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include # define BOOST_MPL_PP_ENUM(n, param) \ BOOST_PP_CAT(BOOST_MPL_PP_ENUM_,n)(param) \ /**/ # define BOOST_MPL_PP_ENUM_0(p) # define BOOST_MPL_PP_ENUM_1(p) p # define BOOST_MPL_PP_ENUM_2(p) p,p # define BOOST_MPL_PP_ENUM_3(p) p,p,p # define BOOST_MPL_PP_ENUM_4(p) p,p,p,p # define BOOST_MPL_PP_ENUM_5(p) p,p,p,p,p # define BOOST_MPL_PP_ENUM_6(p) p,p,p,p,p,p # define BOOST_MPL_PP_ENUM_7(p) p,p,p,p,p,p,p # define BOOST_MPL_PP_ENUM_8(p) p,p,p,p,p,p,p,p # define BOOST_MPL_PP_ENUM_9(p) p,p,p,p,p,p,p,p,p #else # include # include # define BOOST_MPL_PP_AUX_ENUM_FUNC(unused, i, param) \ BOOST_PP_COMMA_IF(i) param \ /**/ # define BOOST_MPL_PP_ENUM(n, param) \ BOOST_PP_REPEAT( \ n \ , BOOST_MPL_PP_AUX_ENUM_FUNC \ , param \ ) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_ENUM_HPP_INCLUDED ././@LongLink0000000000000000000000000000017500000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/partial_spec_params.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000216011344301502031636 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/partial_spec_params.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #define BOOST_MPL_PP_PARTIAL_SPEC_PARAMS(n, param, def) \ BOOST_MPL_PP_PARAMS(n, param) \ BOOST_PP_COMMA_IF(BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,n)) \ BOOST_MPL_PP_ENUM( \ BOOST_MPL_PP_SUB(BOOST_MPL_LIMIT_METAFUNCTION_ARITY,n) \ , def \ ) \ /**/ #endif // BOOST_MPL_AUX_PREPROCESSOR_PARTIAL_SPEC_PARAMS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/add.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor0000644000175000017500000000366111344301502031645 0ustar debiandebian #ifndef BOOST_MPL_AUX_PREPROCESSOR_ADD_HPP_INCLUDED #define BOOST_MPL_AUX_PREPROCESSOR_ADD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/preprocessor/add.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # include #if defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) # include # define BOOST_MPL_PP_ADD(i,j) \ BOOST_MPL_PP_ADD_DELAY(i,j) \ /**/ # define BOOST_MPL_PP_ADD_DELAY(i,j) \ BOOST_PP_CAT(BOOST_MPL_PP_TUPLE_11_ELEM_##i,BOOST_MPL_PP_ADD_##j) \ /**/ #else # define BOOST_MPL_PP_ADD(i,j) \ BOOST_MPL_PP_ADD_DELAY(i,j) \ /**/ # define BOOST_MPL_PP_ADD_DELAY(i,j) \ BOOST_MPL_PP_TUPLE_11_ELEM_##i BOOST_MPL_PP_ADD_##j \ /**/ #endif # define BOOST_MPL_PP_ADD_0 (0,1,2,3,4,5,6,7,8,9,10) # define BOOST_MPL_PP_ADD_1 (1,2,3,4,5,6,7,8,9,10,0) # define BOOST_MPL_PP_ADD_2 (2,3,4,5,6,7,8,9,10,0,0) # define BOOST_MPL_PP_ADD_3 (3,4,5,6,7,8,9,10,0,0,0) # define BOOST_MPL_PP_ADD_4 (4,5,6,7,8,9,10,0,0,0,0) # define BOOST_MPL_PP_ADD_5 (5,6,7,8,9,10,0,0,0,0,0) # define BOOST_MPL_PP_ADD_6 (6,7,8,9,10,0,0,0,0,0,0) # define BOOST_MPL_PP_ADD_7 (7,8,9,10,0,0,0,0,0,0,0) # define BOOST_MPL_PP_ADD_8 (8,9,10,0,0,0,0,0,0,0,0) # define BOOST_MPL_PP_ADD_9 (9,10,0,0,0,0,0,0,0,0,0) # define BOOST_MPL_PP_ADD_10 (10,0,0,0,0,0,0,0,0,0,0) #else # include # define BOOST_MPL_PP_ADD(i,j) \ BOOST_PP_ADD(i,j) \ /**/ #endif #endif // BOOST_MPL_AUX_PREPROCESSOR_ADD_HPP_INCLUDED ././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/single_element_iter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/single_eleme0000644000175000017500000000553311344301501031546 0ustar debiandebian #ifndef BOOST_MPL_AUX_SINGLE_ELEMENT_ITER_HPP_INCLUDED #define BOOST_MPL_AUX_SINGLE_ELEMENT_ITER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/single_element_iter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace aux { template< typename T, BOOST_MPL_AUX_NTTP_DECL(int, is_last_) > struct sel_iter; template< typename T > struct sel_iter { typedef random_access_iterator_tag category; typedef sel_iter next; typedef T type; }; template< typename T > struct sel_iter { typedef random_access_iterator_tag category; typedef sel_iter prior; }; } // namespace aux template< typename T, BOOST_MPL_AUX_NTTP_DECL(int, is_last_), typename Distance > struct advance< aux::sel_iter,Distance> { typedef aux::sel_iter< T , ( is_last_ + BOOST_MPL_AUX_NESTED_VALUE_WKND(int, Distance) ) > type; }; template< typename T , BOOST_MPL_AUX_NTTP_DECL(int, l1) , BOOST_MPL_AUX_NTTP_DECL(int, l2) > struct distance< aux::sel_iter, aux::sel_iter > : int_<( l2 - l1 )> { }; #else namespace aux { struct sel_iter_tag; template< typename T, BOOST_MPL_AUX_NTTP_DECL(int, is_last_) > struct sel_iter { enum { pos_ = is_last_ }; typedef aux::sel_iter_tag tag; typedef random_access_iterator_tag category; typedef sel_iter next; typedef sel_iter prior; typedef T type; }; } // namespace aux template<> struct advance_impl { template< typename Iterator, typename N > struct apply { enum { pos_ = Iterator::pos_, n_ = N::value }; typedef aux::sel_iter< typename Iterator::type , (pos_ + n_) > type; }; }; template<> struct distance_impl { template< typename Iter1, typename Iter2 > struct apply { enum { pos1_ = Iter1::pos_, pos2_ = Iter2::pos_ }; typedef int_<( pos2_ - pos1_ )> type; BOOST_STATIC_CONSTANT(int, value = ( pos2_ - pos1_ )); }; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION }} #endif // BOOST_MPL_AUX_SINGLE_ELEMENT_ITER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/sequence_wrapper.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/sequence_wra0000644000175000017500000001761611344301501031604 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION #if !defined(BOOST_PP_IS_ITERATING) ///// header body // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/sequence_wrapper.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ # include # include # include # include # include # include # include # include # include # include # include #if defined(BOOST_MPL_PREPROCESSING_MODE) # undef LONG_MAX #endif namespace boost { namespace mpl { #if !defined(AUX778076_SEQUENCE_BASE_NAME) # define AUX778076_SEQUENCE_BASE_NAME AUX778076_SEQUENCE_NAME #endif #if !defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER) # define AUX778076_SEQUENCE_PARAM_NAME T # define AUX778076_SEQUENCE_TEMPLATE_PARAM typename T # define AUX778076_SEQUENCE_DEFAULT na # define AUX778076_SEQUENCE_NAME_N(n) \ BOOST_PP_CAT(AUX778076_SEQUENCE_BASE_NAME,n) \ /**/ # define AUX778076_SEQUENCE_PARAMS() \ BOOST_PP_ENUM_PARAMS( \ AUX778076_SEQUENCE_LIMIT \ , AUX778076_SEQUENCE_TEMPLATE_PARAM \ ) \ /**/ # define AUX778076_SEQUENCE_ARGS() \ BOOST_PP_ENUM_PARAMS( \ AUX778076_SEQUENCE_LIMIT \ , T \ ) \ /**/ # define AUX778076_SEQUENCE_DEFAULT_PARAMS() \ BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \ AUX778076_SEQUENCE_LIMIT \ , AUX778076_SEQUENCE_TEMPLATE_PARAM \ , AUX778076_SEQUENCE_DEFAULT \ ) \ /**/ # define AUX778076_SEQUENCE_N_PARAMS(n) \ BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) \ /**/ # define AUX778076_SEQUENCE_N_ARGS(n) \ BOOST_PP_ENUM_PARAMS(n, T) \ /**/ # define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) \ BOOST_PP_ENUM_PARAMS(n, T) \ BOOST_PP_COMMA_IF(n) \ BOOST_PP_ENUM( \ BOOST_PP_SUB_D(1,AUX778076_SEQUENCE_LIMIT,n) \ , BOOST_PP_TUPLE_ELEM_3_2 \ , AUX778076_SEQUENCE_DEFAULT \ ) \ /**/ #else // AUX778076_SEQUENCE_INTEGRAL_WRAPPER # define AUX778076_SEQUENCE_PARAM_NAME C # define AUX778076_SEQUENCE_TEMPLATE_PARAM BOOST_MPL_AUX_NTTP_DECL(long, C) # define AUX778076_SEQUENCE_DEFAULT LONG_MAX # define AUX778076_SEQUENCE_PARAMS() \ typename T, BOOST_PP_ENUM_PARAMS( \ AUX778076_SEQUENCE_LIMIT \ , AUX778076_SEQUENCE_TEMPLATE_PARAM \ ) \ /**/ # define AUX778076_SEQUENCE_ARGS() \ T, BOOST_PP_ENUM_PARAMS( \ AUX778076_SEQUENCE_LIMIT \ , C \ ) \ /**/ # define AUX778076_SEQUENCE_DEFAULT_PARAMS() \ typename T, \ BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT( \ AUX778076_SEQUENCE_LIMIT \ , AUX778076_SEQUENCE_TEMPLATE_PARAM \ , AUX778076_SEQUENCE_DEFAULT \ ) \ /**/ # define AUX778076_SEQUENCE_N_PARAMS(n) \ typename T BOOST_PP_COMMA_IF(n) \ BOOST_PP_ENUM_PARAMS(n, AUX778076_SEQUENCE_TEMPLATE_PARAM) \ /**/ # define AUX778076_SEQUENCE_N_ARGS(n) \ T BOOST_PP_COMMA_IF(n) \ BOOST_PP_ENUM_PARAMS(n, C) \ /**/ # define AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(n) \ T, BOOST_PP_ENUM_PARAMS(n, C) \ BOOST_PP_COMMA_IF(n) \ BOOST_PP_ENUM( \ BOOST_PP_SUB_D(1,AUX778076_SEQUENCE_LIMIT,n) \ , BOOST_PP_TUPLE_ELEM_3_2 \ , AUX778076_SEQUENCE_DEFAULT \ ) \ /**/ #endif // AUX778076_SEQUENCE_INTEGRAL_WRAPPER #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) // forward declaration template< AUX778076_SEQUENCE_DEFAULT_PARAMS() > struct AUX778076_SEQUENCE_NAME; #else namespace aux { template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser); } #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, AUX778076_SEQUENCE_LIMIT, )) #include BOOST_PP_ITERATE() // real C++ version is already taken care of #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) namespace aux { // ???_count_args #define AUX778076_COUNT_ARGS_PREFIX AUX778076_SEQUENCE_NAME #define AUX778076_COUNT_ARGS_DEFAULT AUX778076_SEQUENCE_DEFAULT #define AUX778076_COUNT_ARGS_PARAM_NAME AUX778076_SEQUENCE_PARAM_NAME #define AUX778076_COUNT_ARGS_TEMPLATE_PARAM AUX778076_SEQUENCE_TEMPLATE_PARAM #define AUX778076_COUNT_ARGS_ARITY AUX778076_SEQUENCE_LIMIT #define AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES #include template< AUX778076_SEQUENCE_PARAMS() > struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl) { typedef aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_count_args)< BOOST_PP_ENUM_PARAMS(AUX778076_SEQUENCE_LIMIT, AUX778076_SEQUENCE_PARAM_NAME) > arg_num_; typedef typename aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser)< arg_num_::value > ::template result_< AUX778076_SEQUENCE_ARGS() >::type type; }; } // namespace aux template< AUX778076_SEQUENCE_DEFAULT_PARAMS() > struct AUX778076_SEQUENCE_NAME : aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)< AUX778076_SEQUENCE_ARGS() >::type { typedef typename aux::BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_impl)< AUX778076_SEQUENCE_ARGS() >::type type; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION # undef AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS # undef AUX778076_SEQUENCE_N_ARGS # undef AUX778076_SEQUENCE_N_PARAMS # undef AUX778076_SEQUENCE_DEFAULT_PARAMS # undef AUX778076_SEQUENCE_ARGS # undef AUX778076_SEQUENCE_PARAMS # undef AUX778076_SEQUENCE_NAME_N # undef AUX778076_SEQUENCE_DEFAULT # undef AUX778076_SEQUENCE_TEMPLATE_PARAM # undef AUX778076_SEQUENCE_PARAM_NAME # undef AUX778076_SEQUENCE_LIMIT # undef AUX778076_SEQUENCE_BASE_NAME # undef AUX778076_SEQUENCE_NAME # undef AUX778076_SEQUENCE_INTEGRAL_WRAPPER }} ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) # if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) #if i_ == AUX778076_SEQUENCE_LIMIT /// primary template (not a specialization!) template< AUX778076_SEQUENCE_N_PARAMS(i_) > struct AUX778076_SEQUENCE_NAME : AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) > { typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; }; #else template< AUX778076_SEQUENCE_N_PARAMS(i_) > struct AUX778076_SEQUENCE_NAME< AUX778076_SEQUENCE_N_PARTIAL_SPEC_ARGS(i_) > : AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) > { #if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER) typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; #else typedef AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; #endif }; #endif // i_ == AUX778076_SEQUENCE_LIMIT # else namespace aux { template<> struct BOOST_PP_CAT(AUX778076_SEQUENCE_NAME,_chooser) { template< AUX778076_SEQUENCE_PARAMS() > struct result_ { #if i_ > 0 || defined(AUX778076_SEQUENCE_INTEGRAL_WRAPPER) typedef typename AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; #else typedef AUX778076_SEQUENCE_NAME_N(i_)< AUX778076_SEQUENCE_N_ARGS(i_) >::type type; #endif }; }; } // namespace aux # endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/comparison_op.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/comparison_o0000644000175000017500000000433111344301501031601 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/comparison_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #if !defined(AUX778076_OP_PREFIX) # define AUX778076_OP_PREFIX AUX778076_OP_NAME #endif #define AUX778076_OP_ARITY 2 #include #include #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER AUX778076_OP_PREFIX.hpp # include #else # include # include namespace boost { namespace mpl { // MSVC workaround: implement less in terms of greater #if 0 AUX778076_OP_TOKEN 1 && !(1 AUX778076_OP_TOKEN 0) && !(0 AUX778076_OP_TOKEN 0) # define AUX778076_OP(N1, N2) \ ( BOOST_MPL_AUX_VALUE_WKND(N2)::value > BOOST_MPL_AUX_VALUE_WKND(N1)::value ) \ /**/ #else # define AUX778076_OP(N1, N2) \ ( BOOST_MPL_AUX_VALUE_WKND(N1)::value \ AUX778076_OP_TOKEN BOOST_MPL_AUX_VALUE_WKND(N2)::value \ ) \ /**/ #endif template<> struct AUX778076_OP_IMPL_NAME { template< typename N1, typename N2 > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) : bool_< AUX778076_OP(N1, N2) > { #else { BOOST_STATIC_CONSTANT(bool, value = AUX778076_OP(N1, N2)); typedef bool_ type; #endif }; }; #undef AUX778076_OP }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #undef AUX778076_OP_TAG_NAME #undef AUX778076_OP_IMPL_NAME #undef AUX778076_OP_ARITY #undef AUX778076_OP_PREFIX #undef AUX778076_OP_NAME #undef AUX778076_OP_TOKEN mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/0000755000175000017500000000000012146213760030575 5ustar debiandebian././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/iterator.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/iter0000644000175000017500000000503211344301502031452 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_ITERATOR_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_ITERATOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/iterator.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // theoretically will work on any discrete numeric type template< typename N > struct r_iter { typedef aux::r_iter_tag tag; typedef random_access_iterator_tag category; typedef N type; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) typedef r_iter< typename mpl::next::type > next; typedef r_iter< typename mpl::prior::type > prior; #endif }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename N > struct next< r_iter > { typedef r_iter< typename mpl::next::type > type; }; template< typename N > struct prior< r_iter > { typedef r_iter< typename mpl::prior::type > type; }; #endif template<> struct advance_impl { template< typename Iter, typename Dist > struct apply { typedef typename Iter::type n_; typedef typename plus::type m_; // agurt, 10/nov/04: to be generic, the code have to do something along // the lines below... // // typedef typename apply_wrap1< // numeric_cast< typename m_::tag, typename n_::tag > // , m_ // >::type result_; // // ... meanwhile: typedef integral_c< typename n_::value_type , BOOST_MPL_AUX_VALUE_WKND(m_)::value > result_; typedef r_iter type; }; }; template<> struct distance_impl { template< typename Iter1, typename Iter2 > struct apply : minus< typename Iter2::type , typename Iter1::type > { }; }; }} #endif // BOOST_MPL_AUX_RANGE_C_ITERATOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/empty.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/empt0000644000175000017500000000164711344301502031464 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_EMPTY_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_EMPTY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/empty.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct empty_impl< aux::half_open_range_tag > { template< typename Range > struct apply : equal_to< typename Range::start , typename Range::finish > { }; }; }} #endif // BOOST_MPL_AUX_RANGE_C_EMPTY_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/size0000644000175000017500000000163311344301502031464 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_SIZE_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/size.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct size_impl< aux::half_open_range_tag > { template< typename Range > struct apply : minus< typename Range::finish , typename Range::start > { }; }; }} #endif // BOOST_MPL_AUX_RANGE_C_SIZE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/back.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/back0000644000175000017500000000157011344301502031412 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_BACK_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/back.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct back_impl< aux::half_open_range_tag > { template< typename Range > struct apply { typedef typename prior< typename Range::finish >::type type; }; }; }} #endif // BOOST_MPL_AUX_RANGE_C_BACK_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/tag.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/tag.0000644000175000017500000000121511344301502031337 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_TAG_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/tag.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { namespace aux { struct half_open_range_tag; struct r_iter_tag; }}} #endif // BOOST_MPL_AUX_RANGE_C_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/O1_size.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/O1_s0000644000175000017500000000150411344301502031310 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/O1_size.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { template<> struct O1_size_impl< aux::half_open_range_tag > : size_impl< aux::half_open_range_tag > { }; }} #endif // BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/front.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/fron0000644000175000017500000000150611344301502031455 0ustar debiandebian #ifndef BOOST_MPL_AUX_RANGE_C_FRONT_HPP_INCLUDED #define BOOST_MPL_AUX_RANGE_C_FRONT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/range_c/front.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template<> struct front_impl< aux::half_open_range_tag > { template< typename Range > struct apply { typedef typename Range::start type; }; }; }} #endif // BOOST_MPL_AUX_RANGE_C_FRONT_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/pop_back_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/pop_back_imp0000644000175000017500000000162411344301501031536 0ustar debiandebian #ifndef BOOST_MPL_AUX_POP_BACK_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_POP_BACK_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/pop_back_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { // no default implementation; the definition is needed to make MSVC happy template< typename Tag > struct pop_back_impl { template< typename Sequence > struct apply; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, pop_back_impl) }} #endif // BOOST_MPL_AUX_POP_BACK_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/is_msvc_eti_arg.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/is_msvc_eti_0000644000175000017500000000263011344301501031554 0ustar debiandebian #ifndef BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED #define BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/is_msvc_eti_arg.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { namespace aux { #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) template< typename T > struct is_msvc_eti_arg { BOOST_STATIC_CONSTANT(bool, value = false); }; #else // BOOST_MPL_CFG_MSVC_60_ETI_BUG struct eti_int_convertible { eti_int_convertible(int); }; template< typename T > struct is_msvc_eti_arg { static no_tag test(...); static yes_tag test(eti_int_convertible); static T& get(); BOOST_STATIC_CONSTANT(bool, value = sizeof(test(get())) == sizeof(yes_tag) ); }; #endif template<> struct is_msvc_eti_arg { BOOST_STATIC_CONSTANT(bool, value = true); }; #endif // BOOST_MPL_CFG_MSVC_ETI_BUG }}} #endif // BOOST_MPL_AUX_IS_MSVC_ETI_ARG_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_fwd.hpp0000644000175000017500000000141211344301501031132 0ustar debiandebian #ifndef BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED #define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN // n.a. == not available struct na { typedef na type; enum { value = 0 }; }; BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE BOOST_MPL_AUX_ADL_BARRIER_DECL(na) #endif // BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_op.hpp0000644000175000017500000000164011344301501031321 0ustar debiandebian #ifndef BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED #define BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { // hand-written version is more efficient than bind/lambda expression template< typename Op > struct fold_op { template< typename T1, typename T2 > struct apply { typedef typename apply2< Op , T1 , typename T2::type >::type type; }; }; }}} #endif // BOOST_MPL_AUX_FOLD_OP_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_assert.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_assert.hp0000644000175000017500000000175211344301501031502 0ustar debiandebian #ifndef BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED #define BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_assert.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) # include # define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ BOOST_MPL_ASSERT_NOT((boost::mpl::is_na)) \ /**/ #else # include # define BOOST_MPL_AUX_ASSERT_NOT_NA(x) \ BOOST_STATIC_ASSERT(!boost::mpl::is_na::value) \ /**/ #endif #endif // BOOST_MPL_AUX_NA_ASSERT_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_impl.hp0000644000175000017500000000254311344301501031467 0ustar debiandebian #ifndef BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/fold_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include # include # endif #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER fold_impl.hpp # include #else # define AUX778076_FOLD_IMPL_OP(iter) typename deref::type # define AUX778076_FOLD_IMPL_NAME_PREFIX fold # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_FOLD_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/push_front_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/push_front_i0000644000175000017500000000312511344301501031610 0ustar debiandebian #ifndef BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/push_front_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { // agurt 05/feb/04: no default implementation; the stub definition is needed // to enable the default 'has_push_front' implementation below template< typename Tag > struct push_front_impl { template< typename Sequence, typename T > struct apply {}; }; template< typename Tag > struct has_push_front_impl { template< typename Seq > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : aux::has_type< push_front > { #else { typedef aux::has_type< push_front > type; BOOST_STATIC_CONSTANT(bool, value = (aux::has_type< push_front >::value) ); #endif }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, push_front_impl) BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, has_push_front_impl) }} #endif // BOOST_MPL_AUX_PUSH_FRONT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_key_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_key_impl0000644000175000017500000000170711344301501031561 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // Copyright David Abrahams 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_key_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { // no default implementation; the definition is needed to make MSVC happy template< typename Tag > struct has_key_impl { template< typename AssociativeSequence, typename Key > struct apply; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,has_key_impl) }} #endif // BOOST_MPL_AUX_HAS_KEY_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/O1_size_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/O1_size_impl0000644000175000017500000000424711344301501031451 0ustar debiandebian #ifndef BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED #define BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/O1_size_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation - returns 'Sequence::size' if sequence has a 'size' // member, and -1 otherwise; conrete sequences might override it by // specializing either the 'O1_size_impl' or the primary 'O1_size' template # if !BOOST_WORKAROUND(BOOST_MSVC, < 1300) \ && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003)) namespace aux { template< typename Sequence > struct O1_size_impl : Sequence::size { }; } template< typename Tag > struct O1_size_impl { template< typename Sequence > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : if_< aux::has_size , aux::O1_size_impl , long_<-1> >::type { #else { typedef typename if_< aux::has_size , aux::O1_size_impl , long_<-1> >::type type; BOOST_STATIC_CONSTANT(long, value = (if_< aux::has_size , aux::O1_size_impl , long_<-1> >::type::value) ); #endif }; }; # else // BOOST_MSVC template< typename Tag > struct O1_size_impl { template< typename Sequence > struct apply : long_<-1> { }; }; # endif }} #endif // BOOST_MPL_O1_SIZE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/static_cast.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/static_cast.0000644000175000017500000000155611344301501031476 0ustar debiandebian #ifndef BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED #define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/static_cast.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ || BOOST_WORKAROUND(__GNUC__, < 3) \ || BOOST_WORKAROUND(__MWERKS__, <= 0x3001) # define BOOST_MPL_AUX_STATIC_CAST(T, expr) (T)(expr) #else # define BOOST_MPL_AUX_STATIC_CAST(T, expr) static_cast(expr) #endif #endif // BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/0000755000175000017500000000000012146213747030451 5ustar debiandebian././@LongLink0000000000000000000000000000016000000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/preprocessor.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/prepr0000644000175000017500000000233211344301501031505 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/preprocessor.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION) \ && ( BOOST_WORKAROUND(__MWERKS__, <= 0x3003) \ || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) \ || BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(502)) \ ) # define BOOST_MPL_CFG_BROKEN_PP_MACRO_EXPANSION #endif #if !defined(BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES) # define BOOST_MPL_CFG_NO_OWN_PP_PRIMITIVES #endif #if !defined(BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING) \ && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) # define BOOST_NEEDS_TOKEN_PASTING_OP_FOR_TOKENS_JUXTAPOSING #endif #endif // BOOST_MPL_AUX_CONFIG_PREPROCESSOR_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/has_apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/has_a0000644000175000017500000000177411344301501031441 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/has_apply.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) \ && ( defined(BOOST_MPL_CFG_NO_HAS_XXX) \ || BOOST_WORKAROUND(__EDG_VERSION__, < 300) \ || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ ) # define BOOST_MPL_CFG_NO_HAS_APPLY #endif #endif // BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED ././@LongLink0000000000000000000000000000016700000000000011571 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/overload_resolution.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/overl0000644000175000017500000000165711344301501031515 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/overload_resolution.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ || BOOST_WORKAROUND(__MWERKS__, < 0x3001) \ ) # define BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION #endif #endif // BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/nttp.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/nttp.0000644000175000017500000000213711344301501031423 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/nttp.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // MSVC 6.5 ICE-s on the code as simple as this (see "aux_/nttp_decl.hpp" // for a workaround): // // namespace std { // template< typename Char > struct string; // } // // void foo(std::string); // // namespace boost { namespace mpl { // template< int > struct arg; // }} #if !defined(BOOST_MPL_CFG_NTTP_BUG) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(BOOST_MSVC, < 1300) # define BOOST_MPL_CFG_NTTP_BUG #endif #endif // BOOST_MPL_AUX_CONFIG_NTTP_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/gcc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/gcc.h0000644000175000017500000000127411344301501031343 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/gcc.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if defined(__GNUC__) && !defined(__EDG_VERSION__) # define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__) #else # define BOOST_MPL_CFG_GCC 0 #endif #endif // BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/eti.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/eti.h0000644000175000017500000000250011344301501031361 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/eti.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // flags for MSVC 6.5's so-called "early template instantiation bug" #if !defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(BOOST_MSVC, < 1300) # define BOOST_MPL_CFG_MSVC_60_ETI_BUG #endif #if !defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(BOOST_MSVC, == 1300) # define BOOST_MPL_CFG_MSVC_70_ETI_BUG #endif #if !defined(BOOST_MPL_CFG_MSVC_ETI_BUG) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) \ || defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) \ ) # define BOOST_MPL_CFG_MSVC_ETI_BUG #endif #endif // BOOST_MPL_AUX_CONFIG_ETI_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/forwarding.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/forwa0000644000175000017500000000146611344301501031502 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/forwarding.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_CFG_NO_NESTED_FORWARDING #endif #endif // BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/typeof.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/typeo0000644000175000017500000000206111344301501031514 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/typeof.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_HAS_TYPEOF) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( defined(BOOST_MPL_CFG_GCC) && BOOST_MPL_CFG_GCC >= 0x0302 \ || defined(__MWERKS__) && __MWERKS__ >= 0x3000 \ ) # define BOOST_MPL_CFG_HAS_TYPEOF #endif #if !defined(BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && defined(BOOST_MPL_CFG_HAS_TYPEOF) # define BOOST_MPL_CFG_TYPEOF_BASED_SEQUENCES #endif #endif // BOOST_MPL_AUX_CONFIG_TYPEOF_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/bind.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/bind.0000644000175000017500000000174111344301501031352 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED // Copyright David Abrahams 2002 // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/bind.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ ) # define BOOST_MPL_CFG_NO_BIND_TEMPLATE #endif //#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT #endif // BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/lambda.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/lambd0000644000175000017500000000177611344301501031447 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/lambda.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // agurt, 15/jan/02: full-fledged implementation requires both // template template parameters _and_ partial specialization #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ && ( defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ ) # define BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT #endif #endif // BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/intel.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/intel0000644000175000017500000000115611344301501031473 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/intel.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ // BOOST_INTEL_CXX_VERSION is defined here: #include #endif // BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED ././@LongLink0000000000000000000000000000016100000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/msvc_typename.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/msvc_0000644000175000017500000000144311344301501031466 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/msvc_typename.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) # define BOOST_MSVC_TYPENAME #else # define BOOST_MSVC_TYPENAME typename #endif #endif // BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED ././@LongLink0000000000000000000000000000016200000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dependent_nttp.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/depen0000644000175000017500000000234211344301501031451 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dependent_nttp.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // GCC and EDG-based compilers incorrectly reject the following code: // template< typename T, T n > struct a; // template< typename T > struct b; // template< typename T, T n > struct b< a > {}; #if !defined(BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(300)) \ || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ ) # define BOOST_MPL_CFG_NO_DEPENDENT_NONTYPE_PARAMETER_IN_PARTIAL_SPEC #endif #endif // BOOST_MPL_AUX_CONFIG_DEPENDENT_NTTP_HPP_INCLUDED ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/arrays.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/array0000644000175000017500000000163611344301501031501 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/arrays.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ ) # define BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES #endif #endif // BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/workaround.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/worka0000644000175000017500000000114511344301501031501 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/workaround.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED ././@LongLink0000000000000000000000000000016600000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dmc_ambiguous_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dmc_a0000644000175000017500000000153411344301501031423 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) # define BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS #endif #endif // BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/static_constant.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/stati0000644000175000017500000000144111344301501031501 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/static_constant.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) // BOOST_STATIC_CONSTANT is defined here: # include #else // undef the macro for the preprocessing mode # undef BOOST_STATIC_CONSTANT #endif #endif // BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/ttp.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/ttp.h0000644000175000017500000000223411344301501031413 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/ttp.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ && defined(BOOST_NO_TEMPLATE_TEMPLATES) # define BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS #endif #if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0302)) \ || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ ) # define BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING #endif #endif // BOOST_MPL_AUX_CONFIG_TTP_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/integral.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/integ0000644000175000017500000000217011344301501031463 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/integral.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if !defined(BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_CFG_BCC_INTEGRAL_CONSTANTS #endif #if !defined(BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \ ) # define BOOST_MPL_CFG_NO_NESTED_VALUE_ARITHMETIC #endif #endif // BOOST_MPL_AUX_CONFIG_INTEGRAL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/has_xxx.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/has_x0000644000175000017500000000202111344301501031452 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // Copyright David Abrahams 2002-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/has_xxx.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include // agurt, 11/jan/03: signals a stub-only 'has_xxx' implementation #if !defined(BOOST_MPL_CFG_NO_HAS_XXX) \ && ( defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ || BOOST_WORKAROUND(__GNUC__, <= 2) \ || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ ) # define BOOST_MPL_CFG_NO_HAS_XXX #endif #endif // BOOST_MPL_AUX_CONFIG_HAS_XXX_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/adl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/adl.h0000644000175000017500000000274611344301501031354 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/adl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include // agurt, 25/apr/04: technically, the ADL workaround is only needed for GCC, // but putting everything expect public, user-specializable metafunctions into // a separate global namespace has a nice side effect of reducing the length // of template instantiation symbols, so we apply the workaround on all // platforms that can handle it #if !defined(BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE) \ && ( BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) \ || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ || BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, BOOST_TESTED_AT(810)) \ ) # define BOOST_MPL_CFG_NO_ADL_BARRIER_NAMESPACE #endif #endif // BOOST_MPL_AUX_CONFIG_ADL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/compiler.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/compi0000644000175000017500000000411211344301501031462 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/compiler.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_CFG_COMPILER_DIR) # include # include # include # include # include # include # if BOOST_WORKAROUND(BOOST_MSVC, < 1300) # define BOOST_MPL_CFG_COMPILER_DIR msvc60 # elif BOOST_WORKAROUND(BOOST_MSVC, == 1300) # define BOOST_MPL_CFG_COMPILER_DIR msvc70 # elif BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) # define BOOST_MPL_CFG_COMPILER_DIR gcc # elif BOOST_WORKAROUND(__BORLANDC__, < 0x600) # if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define BOOST_MPL_CFG_COMPILER_DIR bcc551 # else # define BOOST_MPL_CFG_COMPILER_DIR bcc # endif # elif BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) # define BOOST_MPL_CFG_COMPILER_DIR dmc # elif defined(__MWERKS__) # if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define BOOST_MPL_CFG_COMPILER_DIR mwcw # else # define BOOST_MPL_CFG_COMPILER_DIR plain # endif # elif defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # define BOOST_MPL_CFG_COMPILER_DIR no_ctps # elif defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) # define BOOST_MPL_CFG_COMPILER_DIR no_ttp # else # define BOOST_MPL_CFG_COMPILER_DIR plain # endif #endif // BOOST_MPL_CFG_COMPILER_DIR #endif // BOOST_MPL_AUX_CONFIG_COMPILER_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/ctps.0000644000175000017500000000164611344301501031413 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/ctps.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined in #endif // BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/operators.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/opera0000644000175000017500000000202611344301501031463 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/operators.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) \ && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ || BOOST_WORKAROUND(__BORLANDC__, <= 0x600) \ || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) \ || BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, <= 0x0295) \ ) # define BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING #endif #endif // BOOST_MPL_AUX_CONFIG_OPERATORS_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/msvc.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/msvc.0000644000175000017500000000114211344301501031401 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/msvc.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ // BOOST_MSVC is defined here: #include #endif // BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dtp.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dtp.h0000644000175000017500000000316211344301501031374 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/dtp.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include // MWCW 7.x-8.0 "losts" default template parameters of nested class // templates when their owner classes are passed as arguments to other // templates; Borland 5.5.1 "forgets" them from the very beginning (if // the owner class is a class template), and Borland 5.6 isn't even // able to compile a definition of nested class template with DTP #if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && BOOST_WORKAROUND(__BORLANDC__, >= 0x560) \ && BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES #endif #if !defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) \ && ( BOOST_WORKAROUND(__MWERKS__, <= 0x3001) \ || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ || defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) \ ) # define BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES #endif #endif // BOOST_MPL_AUX_CONFIG_DTP_HPP_INCLUDED ././@LongLink0000000000000000000000000000016400000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/use_preprocessed.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/use_p0000644000175000017500000000120711344301501031470 0ustar debiandebian #ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED #define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/config/use_preprocessed.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ // #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/order_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/order_impl.h0000644000175000017500000000415111344301501031473 0ustar debiandebian #ifndef BOOST_MPL_AUX_ORDER_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_ORDER_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/order_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation; requires 'Seq' to provide corresponding overloads // of BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY template< typename Seq, typename Key > struct x_order_impl #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400)) \ || BOOST_WORKAROUND(__EDG_VERSION__, <= 245) { BOOST_STATIC_CONSTANT(long, value = sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY( Seq , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) ) ) ); typedef long_ type; #else // ISO98 C++ : long_< sizeof( BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY( Seq , BOOST_MPL_AUX_STATIC_CAST(aux::type_wrapper*, 0) ) ) > { #endif }; template< typename Tag > struct order_impl { template< typename Seq, typename Key > struct apply : if_< typename has_key_impl::template apply , x_order_impl , void_ >::type { }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,order_impl) }} #endif // BOOST_MPL_AUX_ORDER_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015500000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/advance_backward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/advance_back0000644000175000017500000000644111344301501031476 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED #define BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/advance_backward.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER advance_backward.hpp # include #else # include # include # include # include # include # include namespace boost { namespace mpl { namespace aux { // forward declaration template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_backward; # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) # include BOOST_PP_ITERATE() // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_backward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_backward , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_backward<( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )> , chunk_result_ >::type type; }; }; }}} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX778076_ADVANCE_BACKWARD_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 #define i_ BOOST_PP_FRAME_ITERATION(1) template<> struct advance_backward< BOOST_PP_FRAME_ITERATION(1) > { template< typename Iterator > struct apply { typedef Iterator iter0; #if i_ > 0 # define BOOST_PP_ITERATION_PARAMS_2 \ (3,(1, BOOST_PP_FRAME_ITERATION(1), )) # include BOOST_PP_ITERATE() #endif typedef BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(1)) type; }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) /// ETI workaround template<> struct apply { typedef int type; }; #endif }; #undef i_ ///// iteration, depth == 2 #elif BOOST_PP_ITERATION_DEPTH() == 2 # define AUX778076_ITER_0 BOOST_PP_CAT(iter,BOOST_PP_DEC(BOOST_PP_FRAME_ITERATION(2))) # define AUX778076_ITER_1 BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(2)) typedef typename prior::type AUX778076_ITER_1; # undef AUX778076_ITER_1 # undef AUX778076_ITER_0 #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_spec.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_spec.0000644000175000017500000000241511344301501031422 0ustar debiandebian #ifndef BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED #define BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_spec.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i, name) \ template< \ BOOST_MPL_PP_PARAMS(i, typename T) \ , typename Tag \ > \ struct lambda< \ name< BOOST_MPL_PP_PARAMS(i, T) > \ , Tag \ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_) \ > \ { \ typedef false_ is_le; \ typedef name< BOOST_MPL_PP_PARAMS(i, T) > type; \ }; \ /**/ #else # define BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(i, name) /**/ #endif #endif // BOOST_MPL_AUX_LAMBDA_SPEC_HPP_INCLUDED ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_arity_param.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_arity0000644000175000017500000000145511344301501031545 0ustar debiandebian #ifndef BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED #define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_arity_param.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) # define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) #else # define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param #endif #endif // BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/erase_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/erase_impl.h0000644000175000017500000000352411344301501031462 0ustar debiandebian #ifndef BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/erase_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'erase_impl' or the primary 'erase' template template< typename Tag > struct erase_impl { template< typename Sequence , typename First , typename Last > struct apply { typedef typename if_na< Last,typename next::type >::type last_; // 1st half: [begin, first) typedef iterator_range< typename begin::type , First > first_half_; // 2nd half: [last, end) ... that is, [last + 1, end) typedef iterator_range< last_ , typename end::type > second_half_; typedef typename reverse_fold< second_half_ , typename clear::type , push_front<_,_> >::type half_sequence_; typedef typename reverse_fold< first_half_ , half_sequence_ , push_front<_,_> >::type type; }; }; }} #endif // BOOST_MPL_AUX_ERASE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/count_args.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/count_args.h0000644000175000017500000000574611344301501031516 0ustar debiandebian // NO INCLUDE GUARDS, THE HEADER IS INTENDED FOR MULTIPLE INCLUSION // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/count_args.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(AUX778076_COUNT_ARGS_PARAM_NAME) # define AUX778076_COUNT_ARGS_PARAM_NAME T #endif #if !defined(AUX778076_COUNT_ARGS_TEMPLATE_PARAM) # define AUX778076_COUNT_ARGS_TEMPLATE_PARAM typename AUX778076_COUNT_ARGS_PARAM_NAME #endif // local macros, #undef-ined at the end of the header #if !defined(AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES) # include # include # define AUX778076_COUNT_ARGS_REPEAT BOOST_MPL_PP_REPEAT # define AUX778076_COUNT_ARGS_PARAMS(param) \ BOOST_MPL_PP_PARAMS( \ AUX778076_COUNT_ARGS_ARITY \ , param \ ) \ /**/ #else # include # include # include # define AUX778076_COUNT_ARGS_REPEAT BOOST_PP_REPEAT # define AUX778076_COUNT_ARGS_PARAMS(param) \ BOOST_PP_ENUM_SHIFTED_PARAMS( \ BOOST_PP_INC(AUX778076_COUNT_ARGS_ARITY) \ , param \ ) \ /**/ #endif // AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES #define AUX778076_IS_ARG_TEMPLATE_NAME \ BOOST_PP_CAT(is_,BOOST_PP_CAT(AUX778076_COUNT_ARGS_PREFIX,_arg)) \ /**/ #define AUX778076_COUNT_ARGS_FUNC(unused, i, param) \ BOOST_PP_EXPR_IF(i, +) \ AUX778076_IS_ARG_TEMPLATE_NAME::value \ /**/ // is__arg template< AUX778076_COUNT_ARGS_TEMPLATE_PARAM > struct AUX778076_IS_ARG_TEMPLATE_NAME { BOOST_STATIC_CONSTANT(bool, value = true); }; template<> struct AUX778076_IS_ARG_TEMPLATE_NAME { BOOST_STATIC_CONSTANT(bool, value = false); }; // _count_args template< AUX778076_COUNT_ARGS_PARAMS(AUX778076_COUNT_ARGS_TEMPLATE_PARAM) > struct BOOST_PP_CAT(AUX778076_COUNT_ARGS_PREFIX,_count_args) { BOOST_STATIC_CONSTANT(int, value = AUX778076_COUNT_ARGS_REPEAT( AUX778076_COUNT_ARGS_ARITY , AUX778076_COUNT_ARGS_FUNC , AUX778076_COUNT_ARGS_PARAM_NAME )); }; #undef AUX778076_COUNT_ARGS_FUNC #undef AUX778076_IS_ARG_TEMPLATE_NAME #undef AUX778076_COUNT_ARGS_PARAMS #undef AUX778076_COUNT_ARGS_REPEAT #undef AUX778076_COUNT_ARGS_ARITY #undef AUX778076_COUNT_ARGS_DEFAULT #undef AUX778076_COUNT_ARGS_PREFIX #undef AUX778076_COUNT_ARGS_USE_STANDARD_PP_PRIMITIVES #undef AUX778076_COUNT_ARGS_TEMPLATE_PARAM #undef AUX778076_COUNT_ARGS_PARAM_NAME ././@LongLink0000000000000000000000000000015200000000000011563 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_eti_base.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_eti_bas0000644000175000017500000000336411344301501031554 0ustar debiandebian #ifndef BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED #define BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/msvc_eti_base.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { namespace aux { #if defined(BOOST_MPL_CFG_MSVC_70_ETI_BUG) template< bool > struct msvc_eti_base_impl { template< typename T > struct result_ : T { typedef T type; }; }; template<> struct msvc_eti_base_impl { template< typename T > struct result_ { typedef result_ type; typedef result_ first; typedef result_ second; typedef result_ tag; enum { value = 0 }; }; }; template< typename T > struct msvc_eti_base : msvc_eti_base_impl< is_msvc_eti_arg::value > ::template result_ { }; #else // !BOOST_MPL_CFG_MSVC_70_ETI_BUG template< typename T > struct msvc_eti_base : T { #if BOOST_WORKAROUND(BOOST_MPL_CFG_GCC, BOOST_TESTED_AT(0x0304)) msvc_eti_base(); #endif typedef T type; }; #endif template<> struct msvc_eti_base { typedef msvc_eti_base type; typedef msvc_eti_base first; typedef msvc_eti_base second; typedef msvc_eti_base tag; enum { value = 0 }; }; }}} #endif // BOOST_MPL_AUX_MSVC_ETI_BASE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/begin_end_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/begin_end_im0000644000175000017500000000432311344301501031511 0ustar debiandebian #ifndef BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/begin_end_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'begin_impl/end_impl' or the primary // 'begin/end' templates template< typename Tag > struct begin_impl { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; }; template< typename Tag > struct end_impl { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; }; // specialize 'begin_trait/end_trait' for two pre-defined tags # define AUX778076_IMPL_SPEC(name, tag, result) \ template<> \ struct name##_impl \ { \ template< typename Sequence > struct apply \ { \ typedef result type; \ }; \ }; \ /**/ // a sequence with nested 'begin/end' typedefs; just query them AUX778076_IMPL_SPEC(begin, nested_begin_end_tag, typename Sequence::begin) AUX778076_IMPL_SPEC(end, nested_begin_end_tag, typename Sequence::end) // if a type 'T' does not contain 'begin/end' or 'tag' members // and doesn't specialize either 'begin/end' or 'begin_impl/end_impl' // templates, then we end up here AUX778076_IMPL_SPEC(begin, non_sequence_tag, void_) AUX778076_IMPL_SPEC(end, non_sequence_tag, void_) AUX778076_IMPL_SPEC(begin, na, void_) AUX778076_IMPL_SPEC(end, na, void_) # undef AUX778076_IMPL_SPEC BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,begin_impl) BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1,end_impl) }} #endif // BOOST_MPL_AUX_BEGIN_END_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_apply.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_apply.h0000644000175000017500000000176311344301501031515 0ustar debiandebian #ifndef BOOST_MPL_ITER_APPLY_HPP_INCLUDED #define BOOST_MPL_ITER_APPLY_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/iter_apply.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { namespace aux { template< typename F , typename Iterator > struct iter_apply1 : apply1< F,typename deref::type > { }; template< typename F , typename Iterator1 , typename Iterator2 > struct iter_apply2 : apply2< F , typename deref::type , typename deref::type > { }; }}} #endif // BOOST_MPL_ITER_APPLY_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/overload_names.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/overload_nam0000644000175000017500000000413611344301501031562 0ustar debiandebian #ifndef BOOST_MPL_AUX_OVERLOAD_NAMES_HPP_INCLUDED #define BOOST_MPL_AUX_OVERLOAD_NAMES_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/overload_names.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if defined(BOOST_MPL_CFG_USE_OPERATORS_OVERLOADING) # include # define BOOST_MPL_AUX_OVERLOAD_VALUE_BY_KEY operator/ # define BOOST_MPL_AUX_OVERLOAD_ITEM_BY_ORDER operator| # define BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY operator|| # define BOOST_MPL_AUX_OVERLOAD_IS_MASKED operator% # define BOOST_MPL_AUX_OVERLOAD_CALL_VALUE_BY_KEY(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) / x # define BOOST_MPL_AUX_OVERLOAD_CALL_ITEM_BY_ORDER(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) | x # define BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) || x # define BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED(T, x) BOOST_MPL_AUX_PTR_TO_REF(T) % x #else # define BOOST_MPL_AUX_OVERLOAD_VALUE_BY_KEY value_by_key_ # define BOOST_MPL_AUX_OVERLOAD_ITEM_BY_ORDER item_by_order_ # define BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY order_by_key_ # define BOOST_MPL_AUX_OVERLOAD_IS_MASKED is_masked_ # define BOOST_MPL_AUX_OVERLOAD_CALL_VALUE_BY_KEY(T, x) T::BOOST_MPL_AUX_OVERLOAD_VALUE_BY_KEY( BOOST_MPL_AUX_PTR_TO_REF(T), x ) # define BOOST_MPL_AUX_OVERLOAD_CALL_ITEM_BY_ORDER(T, x) T::BOOST_MPL_AUX_OVERLOAD_ITEM_BY_ORDER( BOOST_MPL_AUX_PTR_TO_REF(T), x ) # define BOOST_MPL_AUX_OVERLOAD_CALL_ORDER_BY_KEY(T, x) T::BOOST_MPL_AUX_OVERLOAD_ORDER_BY_KEY( BOOST_MPL_AUX_PTR_TO_REF(T), x ) # define BOOST_MPL_AUX_OVERLOAD_CALL_IS_MASKED(T, x) T::BOOST_MPL_AUX_OVERLOAD_IS_MASKED( BOOST_MPL_AUX_PTR_TO_REF(T), x ) #endif #endif // BOOST_MPL_AUX_OVERLOAD_NAMES_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/joint_iter.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/joint_iter.h0000644000175000017500000000565211344301501031514 0ustar debiandebian #ifndef BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED #define BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/joint_iter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # include #endif namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Iterator1 , typename LastIterator1 , typename Iterator2 > struct joint_iter { typedef Iterator1 base; typedef forward_iterator_tag category; }; template< typename LastIterator1 , typename Iterator2 > struct joint_iter { typedef Iterator2 base; typedef forward_iterator_tag category; }; template< typename I1, typename L1, typename I2 > struct deref< joint_iter > { typedef typename joint_iter::base base_; typedef typename deref::type type; }; template< typename I1, typename L1, typename I2 > struct next< joint_iter > { typedef joint_iter< typename mpl::next::type,L1,I2 > type; }; template< typename L1, typename I2 > struct next< joint_iter > { typedef joint_iter< L1,L1,typename mpl::next::type > type; }; #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template< typename Iterator1 , typename LastIterator1 , typename Iterator2 > struct joint_iter; template< bool > struct joint_iter_impl { template< typename I1, typename L1, typename I2 > struct result_ { typedef I1 base; typedef forward_iterator_tag category; typedef joint_iter< typename mpl::next::type,L1,I2 > next; typedef typename deref::type type; }; }; template<> struct joint_iter_impl { template< typename I1, typename L1, typename I2 > struct result_ { typedef I2 base; typedef forward_iterator_tag category; typedef joint_iter< L1,L1,typename mpl::next::type > next; typedef typename deref::type type; }; }; template< typename Iterator1 , typename LastIterator1 , typename Iterator2 > struct joint_iter : joint_iter_impl< is_same::value > ::template result_ { }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, joint_iter) }} #endif // BOOST_MPL_AUX_JOINT_ITER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na.hpp0000644000175000017500000000332211344301501030274 0ustar debiandebian #ifndef BOOST_MPL_AUX_NA_HPP_INCLUDED #define BOOST_MPL_AUX_NA_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { template< typename T > struct is_na : false_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using false_::value; #endif }; template<> struct is_na : true_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using true_::value; #endif }; template< typename T > struct is_not_na : true_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using true_::value; #endif }; template<> struct is_not_na : false_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using false_::value; #endif }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename T, typename U > struct if_na { typedef T type; }; template< typename U > struct if_na { typedef U type; }; #else template< typename T > struct if_na_impl { template< typename U > struct apply { typedef T type; }; }; template<> struct if_na_impl { template< typename U > struct apply { typedef U type; }; }; template< typename T, typename U > struct if_na : if_na_impl::template apply { }; #endif }} #endif // BOOST_MPL_AUX_NA_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_fold0000644000175000017500000000273411344301501031575 0ustar debiandebian #ifndef BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_fold_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ || defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) # include # include # endif #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER reverse_fold_impl.hpp # include #else # define AUX778076_FOLD_IMPL_OP(iter) typename deref::type # define AUX778076_FOLD_IMPL_NAME_PREFIX reverse_fold # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_REVERSE_FOLD_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000016300000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_iter_fold_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_iter0000644000175000017500000000270511344301501031612 0ustar debiandebian #ifndef BOOST_MPL_AUX_ITER_FOLD_BACKWARD_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_ITER_FOLD_BACKWARD_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ || defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) # include # include # endif #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER reverse_iter_fold_impl.hpp # include #else # define AUX778076_FOLD_IMPL_OP(iter) iter # define AUX778076_FOLD_IMPL_NAME_PREFIX reverse_iter_fold # include #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_ITER_FOLD_BACKWARD_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/find_if_pred.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/find_if_pred0000644000175000017500000000136411344301501031524 0ustar debiandebian #ifndef BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED #define BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Eric Friedman 2002 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. #include #include namespace boost { namespace mpl { namespace aux { template< typename Predicate > struct find_if_pred { template< typename Iterator > struct apply { typedef not_< aux::iter_apply1 > type; }; }; }}} #endif // BOOST_MPL_AUX_FIND_IF_PRED_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_spec.hpp0000644000175000017500000001071311344301501031310 0ustar debiandebian #ifndef BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED #define BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/na_spec.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include #endif #include #include #include #include #include #include #include #include #include #include #define BOOST_MPL_AUX_NA_PARAMS(i) \ BOOST_MPL_PP_ENUM(i, na) \ /**/ #if defined(BOOST_MPL_CFG_BROKEN_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) # define BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \ namespace aux { \ template< BOOST_MPL_AUX_NTTP_DECL(int, N) > \ struct arity< \ name< BOOST_MPL_AUX_NA_PARAMS(i) > \ , N \ > \ : int_< BOOST_MPL_LIMIT_METAFUNCTION_ARITY > \ { \ }; \ } \ /**/ #else # define BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) /**/ #endif #define BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \ template<> \ struct name< BOOST_MPL_AUX_NA_PARAMS(i) > \ { \ template< \ BOOST_MPL_PP_PARAMS(i, typename T) \ BOOST_MPL_PP_NESTED_DEF_PARAMS_TAIL(i, typename T, na) \ > \ struct apply \ : name< BOOST_MPL_PP_PARAMS(i, T) > \ { \ }; \ }; \ /**/ #if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ template<> \ struct lambda< \ name< BOOST_MPL_AUX_NA_PARAMS(i) > \ , void_ \ , true_ \ > \ { \ typedef false_ is_le; \ typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \ }; \ template<> \ struct lambda< \ name< BOOST_MPL_AUX_NA_PARAMS(i) > \ , void_ \ , false_ \ > \ { \ typedef false_ is_le; \ typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \ }; \ /**/ #else # define BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ template< typename Tag > \ struct lambda< \ name< BOOST_MPL_AUX_NA_PARAMS(i) > \ , Tag \ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(int_<-1>) \ > \ { \ typedef false_ is_le; \ typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > result_; \ typedef name< BOOST_MPL_AUX_NA_PARAMS(i) > type; \ }; \ /**/ #endif #if defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) \ || defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ && defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) # define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) \ namespace aux { \ template< BOOST_MPL_PP_PARAMS(j, typename T) > \ struct template_arity< \ name< BOOST_MPL_PP_PARAMS(j, T) > \ > \ : int_ \ { \ }; \ \ template<> \ struct template_arity< \ name< BOOST_MPL_PP_ENUM(i, na) > \ > \ : int_<-1> \ { \ }; \ } \ /**/ #else # define BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) /**/ #endif #if defined(BOOST_MPL_CFG_MSVC_ETI_BUG) # define BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \ template<> \ struct name< BOOST_MPL_PP_ENUM(i, int) > \ { \ typedef int type; \ enum { value = 0 }; \ }; \ /**/ #else # define BOOST_MPL_AUX_NA_SPEC_ETI(i, name) /**/ #endif #define BOOST_MPL_AUX_NA_PARAM(param) param = na #define BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) \ BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \ BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \ BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, i, name) \ /**/ #define BOOST_MPL_AUX_NA_SPEC(i, name) \ BOOST_MPL_AUX_NA_SPEC_NO_ETI(i, name) \ BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \ /**/ #define BOOST_MPL_AUX_NA_SPEC2(i, j, name) \ BOOST_MPL_AUX_NA_SPEC_MAIN(i, name) \ BOOST_MPL_AUX_NA_SPEC_ETI(i, name) \ BOOST_MPL_AUX_NA_SPEC_LAMBDA(i, name) \ BOOST_MPL_AUX_NA_SPEC_ARITY(i, name) \ BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(i, j, name) \ /**/ #endif // BOOST_MPL_AUX_NA_SPEC_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/clear_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/clear_impl.h0000644000175000017500000000165011344301501031447 0ustar debiandebian #ifndef BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/clear_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { // no default implementation; the definition is needed to make MSVC happy template< typename Tag > struct clear_impl { template< typename Sequence > struct apply; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, clear_impl) }} #endif // BOOST_MPL_AUX_CLEAR_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/at_impl.hpp0000644000175000017500000000225511344301501031327 0ustar debiandebian #ifndef BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/at_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'at_impl' or the primary 'at' template template< typename Tag > struct at_impl { template< typename Sequence, typename N > struct apply { typedef typename advance< typename begin::type , N >::type iter_; typedef typename deref::type type; }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2, at_impl) }} #endif // BOOST_MPL_AUX_AT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/sort_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/sort_impl.hp0000644000175000017500000000565111344301501031535 0ustar debiandebian #ifndef BOOST_MPL_AUX_SORT_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_SORT_IMPL_HPP_INCLUDED // Copyright Eric Friedman 2002-2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/sort_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Seq, typename Pred > struct quick_sort; // agurt, 10/nov/04: for the sake of deficeint compilers template< typename Pred, typename Pivot > struct quick_sort_pred { template< typename T > struct apply { typedef typename apply2::type type; }; }; template< typename Seq , typename Pred > struct quick_sort_impl { typedef typename begin::type pivot; typedef typename partition< iterator_range< typename next::type , typename end::type > , protect< aux::quick_sort_pred< Pred, typename deref::type > > , back_inserter< vector<> > , back_inserter< vector<> > >::type partitioned; typedef typename quick_sort< typename partitioned::first, Pred >::type part1; typedef typename quick_sort< typename partitioned::second, Pred >::type part2; typedef joint_view< joint_view< part1, single_view< typename deref::type > > , part2 > type; }; template< typename Seq , typename Pred > struct quick_sort : eval_if< empty , identity , quick_sort_impl > { }; template < typename Sequence , typename Pred , typename In > struct sort_impl { typedef typename quick_sort< Sequence , typename if_na >::type >::type result_; typedef typename copy::type type; }; template < typename Sequence , typename Pred , typename In > struct reverse_sort_impl { typedef typename quick_sort< Sequence , typename if_na >::type >::type result_; typedef typename reverse_copy::type type; }; }}} #endif // BOOST_MPL_AUX_SORT_IMPL_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_size.hpp0000644000175000017500000000122411344301501031502 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_size.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { BOOST_MPL_HAS_XXX_TRAIT_DEF(size) }}} #endif // BOOST_MPL_AUX_HAS_SIZE_HPP_INCLUDED ././@LongLink0000000000000000000000000000015300000000000011564 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_no_ctps.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_no_ct0000644000175000017500000001167611344301501031525 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED #define BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/lambda_no_ctps.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include # include # include # include # include # include # include # include # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER lambda_no_ctps.hpp # include #else # include # include # include # include # include # include # include # include # include # include # include namespace boost { namespace mpl { # define AUX778076_LAMBDA_PARAMS(i_, param) \ BOOST_MPL_PP_PARAMS(i_, param) \ /**/ namespace aux { #define n_ BOOST_MPL_LIMIT_METAFUNCTION_ARITY template< BOOST_MPL_PP_DEFAULT_PARAMS(n_,bool C,false) > struct lambda_or : true_ { }; template<> struct lambda_or< BOOST_MPL_PP_ENUM(n_,false) > : false_ { }; #undef n_ template< typename Arity > struct lambda_impl { template< typename T, typename Tag, typename Protect > struct result_ { typedef T type; typedef is_placeholder is_le; }; }; #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() } // namespace aux template< typename T , typename Tag , typename Protect > struct lambda { /// Metafunction forwarding confuses MSVC 6.x typedef typename aux::template_arity::type arity_; typedef typename aux::lambda_impl ::template result_< T,Tag,Protect > l_; typedef typename l_::type type; typedef typename l_::is_le is_le; BOOST_MPL_AUX_LAMBDA_SUPPORT(3, lambda, (T, Tag, Protect)) }; BOOST_MPL_AUX_NA_SPEC2(1, 3, lambda) template< typename T > struct is_lambda_expression : lambda::is_le { }; # undef AUX778076_LAMBDA_PARAMS }} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_LAMBDA_NO_CTPS_HPP_INCLUDED ///// iteration, depth == 1 #else #define i_ BOOST_PP_FRAME_ITERATION(1) # define AUX778076_LAMBDA_TYPEDEF(unused, i_, F) \ typedef lambda< \ typename F::BOOST_PP_CAT(arg,BOOST_PP_INC(i_)) \ , Tag \ , false_ \ > BOOST_PP_CAT(l,BOOST_PP_INC(i_)); \ /**/ # define AUX778076_IS_LE_TYPEDEF(unused, i_, unused2) \ typedef typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::is_le \ BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)); \ /**/ # define AUX778076_IS_LAMBDA_EXPR(unused, i_, unused2) \ BOOST_PP_COMMA_IF(i_) \ BOOST_MPL_AUX_MSVC_VALUE_WKND(BOOST_PP_CAT(is_le,BOOST_PP_INC(i_)))::value \ /**/ # define AUX778076_LAMBDA_RESULT(unused, i_, unused2) \ , typename BOOST_PP_CAT(l,BOOST_PP_INC(i_))::type \ /**/ template<> struct lambda_impl< int_ > { template< typename F, typename Tag, typename Protect > struct result_ { BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_TYPEDEF, F) BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LE_TYPEDEF, unused) typedef aux::lambda_or< BOOST_MPL_PP_REPEAT(i_, AUX778076_IS_LAMBDA_EXPR, unused) > is_le; typedef BOOST_PP_CAT(bind,i_)< typename F::rebind BOOST_MPL_PP_REPEAT(i_, AUX778076_LAMBDA_RESULT, unused) > bind_; typedef typename if_< is_le , if_< Protect, mpl::protect, bind_ > , identity >::type type_; typedef typename type_::type type; }; }; # undef AUX778076_LAMBDA_RESULT # undef AUX778076_IS_LAMBDA_EXPR # undef AUX778076_IS_LE_TYPEDEF # undef AUX778076_LAMBDA_TYPEDEF #undef i_ #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015700000000000011570 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/inserter_algorithm.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/inserter_alg0000644000175000017500000001145611344301501031575 0ustar debiandebian #ifndef BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED #define BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/inserter_algorithm.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) # define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity, name) \ BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ template< \ BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ > \ struct name \ : aux::name##_impl \ { \ }; \ \ template< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ > \ struct name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > \ : if_< has_push_back \ , aux::name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , back_inserter< typename clear::type > \ > \ , aux::reverse_##name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , front_inserter< typename clear::type > \ > \ >::type \ { \ }; \ \ template< \ BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ > \ struct reverse_##name \ : aux::reverse_##name##_impl \ { \ }; \ \ template< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ > \ struct reverse_##name< BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P),na > \ : if_< has_push_back \ , aux::reverse_##name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , back_inserter< typename clear::type > \ > \ , aux::name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , front_inserter< typename clear::type > \ > \ >::type \ { \ }; \ BOOST_MPL_AUX_NA_SPEC(arity, name) \ BOOST_MPL_AUX_NA_SPEC(arity, reverse_##name) \ /**/ #else # define BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(arity, name) \ BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ template< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ > \ struct def_##name##_impl \ : if_< has_push_back \ , aux::name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , back_inserter< typename clear::type > \ > \ , aux::reverse_##name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , front_inserter< typename clear::type > \ > \ >::type \ { \ }; \ \ template< \ BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ > \ struct name \ { \ typedef typename eval_if< \ is_na \ , def_##name##_impl \ , aux::name##_impl \ >::type type; \ }; \ \ template< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), typename P) \ > \ struct def_reverse_##name##_impl \ : if_< has_push_back \ , aux::reverse_##name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , back_inserter< typename clear::type > \ > \ , aux::name##_impl< \ BOOST_MPL_PP_PARAMS(BOOST_PP_DEC(arity), P) \ , front_inserter< typename clear::type > \ > \ >::type \ { \ }; \ template< \ BOOST_MPL_PP_DEFAULT_PARAMS(arity, typename P, na) \ > \ struct reverse_##name \ { \ typedef typename eval_if< \ is_na \ , def_reverse_##name##_impl \ , aux::reverse_##name##_impl \ >::type type; \ }; \ BOOST_MPL_AUX_NA_SPEC(arity, name) \ BOOST_MPL_AUX_NA_SPEC(arity, reverse_##name) \ /**/ #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION #endif // BOOST_MPL_AUX_INSERTER_ALGORITHM_HPP_INCLUDED ././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/count_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/count_impl.h0000644000175000017500000000240211344301501031505 0ustar debiandebian #ifndef BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/count_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { template< typename Tag > struct count_impl { template< typename Sequence, typename T > struct apply #if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x561)) { typedef typename count_if< Sequence,same_as >::type type; BOOST_STATIC_CONSTANT(int, value = BOOST_MPL_AUX_VALUE_WKND(type)::value); #else : count_if< Sequence,same_as > { #endif }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(2,count_impl) }} #endif // BOOST_MPL_AUX_COUNT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000014600000000000011566 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/size_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/size_impl.hp0000644000175000017500000000262611344301501031517 0ustar debiandebian #ifndef BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/size_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'size_impl' or the primary 'size' template template< typename Tag > struct size_impl { template< typename Sequence > struct apply #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x561)) : distance< typename begin::type , typename end::type > { #else { typedef typename distance< typename begin::type , typename end::type >::type type; #endif }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(1, size_impl) }} #endif // BOOST_MPL_AUX_SIZE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015400000000000011565 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/advance_forward.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/advance_forw0000644000175000017500000000631711344301501031555 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED #define BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/advance_forward.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER advance_forward.hpp # include #else # include # include # include # include # include # include namespace boost { namespace mpl { namespace aux { // forward declaration template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_forward; # define BOOST_PP_ITERATION_PARAMS_1 \ (3,(0, BOOST_MPL_LIMIT_UNROLLING, )) # include BOOST_PP_ITERATE() // implementation for N that exceeds BOOST_MPL_LIMIT_UNROLLING template< BOOST_MPL_AUX_NTTP_DECL(long, N) > struct advance_forward { template< typename Iterator > struct apply { typedef typename apply_wrap1< advance_forward , Iterator >::type chunk_result_; typedef typename apply_wrap1< advance_forward<( (N - BOOST_MPL_LIMIT_UNROLLING) < 0 ? 0 : N - BOOST_MPL_LIMIT_UNROLLING )> , chunk_result_ >::type type; }; }; }}} #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_AUX_ADVANCE_FORWARD_HPP_INCLUDED ///// iteration, depth == 1 #elif BOOST_PP_ITERATION_DEPTH() == 1 #define i_ BOOST_PP_FRAME_ITERATION(1) template<> struct advance_forward< BOOST_PP_FRAME_ITERATION(1) > { template< typename Iterator > struct apply { typedef Iterator iter0; #if i_ > 0 # define BOOST_PP_ITERATION_PARAMS_2 \ (3,(1, i_, )) # include BOOST_PP_ITERATE() #endif typedef BOOST_PP_CAT(iter,i_) type; }; #if defined(BOOST_MPL_CFG_MSVC_60_ETI_BUG) /// ETI workaround template<> struct apply { typedef int type; }; #endif }; #undef i_ ///// iteration, depth == 2 #elif BOOST_PP_ITERATION_DEPTH() == 2 # define AUX778076_ITER_0 BOOST_PP_CAT(iter,BOOST_PP_DEC(BOOST_PP_FRAME_ITERATION(2))) # define AUX778076_ITER_1 BOOST_PP_CAT(iter,BOOST_PP_FRAME_ITERATION(2)) typedef typename next::type AUX778076_ITER_1; # undef AUX778076_ITER_1 # undef AUX778076_ITER_0 #endif // BOOST_PP_IS_ITERATING ././@LongLink0000000000000000000000000000015100000000000011562 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/partition_op.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/partition_op0000644000175000017500000000273511344301501031626 0ustar debiandebian #ifndef BOOST_MPL_AUX_PARTITION_OP_HPP_INCLUDED #define BOOST_MPL_AUX_PARTITION_OP_HPP_INCLUDED // Copyright Eric Friedman 2003 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/partition_op.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Pred, typename In1Op, typename In2Op > struct partition_op { template< typename State, typename T > struct apply { typedef typename State::first first_; typedef typename State::second second_; typedef typename apply1< Pred,T >::type pred_; typedef typename eval_if< pred_ , apply2 , apply2 >::type result_; typedef typename if_< pred_ , pair< result_,second_ > , pair< first_,result_ > >::type type; }; }; } // namespace aux BOOST_MPL_AUX_PASS_THROUGH_LAMBDA_SPEC(3, aux::partition_op) }} #endif // BOOST_MPL_AUX_PARTITION_OP_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_tag.hpp0000644000175000017500000000124511344301501031306 0ustar debiandebian #ifndef BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED #define BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2002-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/has_tag.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { namespace aux { BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_tag, tag, false) }}} #endif // BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED ././@LongLink0000000000000000000000000000015600000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/insert_range_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/insert_range0000644000175000017500000000431311344301501031571 0ustar debiandebian #ifndef BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED #define BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/insert_range_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'insert_range_impl' or the primary // 'insert_range' template template< typename Tag > struct insert_range_impl { template< typename Sequence , typename Pos , typename Range > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : reverse_copy< joint_view< iterator_range::type,Pos> , joint_view< Range , iterator_range::type> > > , front_inserter< typename clear::type > > { #else { typedef typename reverse_copy< joint_view< iterator_range::type,Pos> , joint_view< Range , iterator_range::type> > > , front_inserter< typename clear::type > >::type type; #endif }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_range_impl) }} #endif // BOOST_MPL_AUX_INSERT_RANGE_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/insert_impl.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/insert_impl.0000644000175000017500000000344011344301501031514 0ustar debiandebian #ifndef BOOST_MPL_INSERT_IMPL_HPP_INCLUDED #define BOOST_MPL_INSERT_IMPL_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/insert_impl.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation; conrete sequences might override it by // specializing either the 'insert_impl' or the primary 'insert' template template< typename Tag > struct insert_impl { template< typename Sequence , typename Pos , typename T > struct apply { typedef iterator_range< typename begin::type , Pos > first_half_; typedef iterator_range< Pos , typename end::type > second_half_; typedef typename reverse_fold< second_half_ , typename clear::type , push_front<_,_> >::type half_sequence_; typedef typename reverse_fold< first_half_ , typename push_front::type , push_front<_,_> >::type type; }; }; BOOST_MPL_ALGORITM_TRAITS_LAMBDA_SPEC(3,insert_impl) }} #endif // BOOST_MPL_INSERT_IMPL_HPP_INCLUDED ././@LongLink0000000000000000000000000000015000000000000011561 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arg_typedef.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arg_typedef.0000644000175000017500000000156611344301501031467 0ustar debiandebian #ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED #define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/aux_/arg_typedef.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) # define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) typedef T name; #else # define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) /**/ #endif #endif // BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/distance.hpp0000644000175000017500000000410311344301501030532 0ustar debiandebian #ifndef BOOST_MPL_DISTANCE_HPP_INCLUDED #define BOOST_MPL_DISTANCE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/distance.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { // default implementation for forward/bidirectional iterators template< typename Tag > struct distance_impl { template< typename First, typename Last > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : aux::msvc_eti_base< typename iter_fold< iterator_range , long_<0> , next<> >::type > { #else { typedef typename iter_fold< iterator_range , long_<0> , next<> >::type type; BOOST_STATIC_CONSTANT(long, value = (iter_fold< iterator_range , long_<0> , next<> >::type::value) ); #endif }; }; template< typename BOOST_MPL_AUX_NA_PARAM(First) , typename BOOST_MPL_AUX_NA_PARAM(Last) > struct distance : distance_impl< typename tag::type > ::template apply { BOOST_MPL_AUX_LAMBDA_SUPPORT(2, distance, (First, Last)) }; BOOST_MPL_AUX_NA_SPEC(2, distance) }} #endif // BOOST_MPL_DISTANCE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/math/0000755000175000017500000000000012146213760027174 5ustar debiandebian././@LongLink0000000000000000000000000000014700000000000011567 Lustar rootrootmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/math/rational_c.hppmgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/math/rational_c.h0000644000175000017500000000163011344301502031447 0ustar debiandebian #ifndef BOOST_MPL_RATIONAL_C_HPP_INCLUDED #define BOOST_MPL_RATIONAL_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/math/rational_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { template< typename IntegerType , IntegerType N , IntegerType D = 1 > struct rational_c { BOOST_STATIC_CONSTANT(IntegerType, numerator = N); BOOST_STATIC_CONSTANT(IntegerType, denominator = D); typedef rational_c type; rational_c() {} }; }} #endif // BOOST_MPL_RATIONAL_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/math/is_even.hpp0000644000175000017500000000235211344301502031326 0ustar debiandebian #ifndef BOOST_MPL_MATH_IS_EVEN_HPP_INCLUDED #define BOOST_MPL_MATH_IS_EVEN_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/math/is_even.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) namespace aux { template struct is_even_base { enum { value = (N::value % 2) == 0 }; typedef bool_ type; }; } #endif template< typename BOOST_MPL_AUX_NA_PARAM(N) > struct is_even #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) : aux::is_even_base::type #else : bool_<((N::value % 2) == 0)> #endif { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_even,(N)) }; BOOST_MPL_AUX_NA_SPEC(1, is_even) }} #endif // BOOST_MPL_MATH_IS_EVEN_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/math/fixed_c.hpp0000644000175000017500000000162311344301502031277 0ustar debiandebian #ifndef BOOST_MPL_FIXED_C_HPP_INCLUDED #define BOOST_MPL_FIXED_C_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/math/fixed_c.hpp,v $ // $Date: 2010/03/05 22:18:42 $ // $Revision: 1.1.1.1 $ #include namespace boost { namespace mpl { template< long IntegerPart , unsigned long FractionPart > struct fixed_c { BOOST_STATIC_CONSTANT(long, integer_part = IntegerPart); BOOST_STATIC_CONSTANT(unsigned long, fraction_part = FractionPart); typedef fixed_c type; fixed_c() {} }; }} #endif // BOOST_MPL_FIXED_C_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/pair_view.hpp0000644000175000017500000001055211344301501030732 0ustar debiandebian #ifndef BOOST_MPL_PAIR_VIEW_HPP_INCLUDED #define BOOST_MPL_PAIR_VIEW_HPP_INCLUDED // Copyright David Abrahams 2003-2004 // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/pair_view.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace mpl { namespace aux { struct pair_iter_tag; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Iter1, typename Iter2, typename Category > struct pair_iter; template< typename Category > struct prior_pair_iter { template< typename Iter1, typename Iter2 > struct apply { typedef typename mpl::prior::type i1_; typedef typename mpl::prior::type i2_; typedef pair_iter type; }; }; template<> struct prior_pair_iter { template< typename Iter1, typename Iter2 > struct apply { typedef pair_iter type; }; }; #endif } template< typename Iter1 , typename Iter2 , typename Category > struct pair_iter { typedef aux::pair_iter_tag tag; typedef Category category; typedef Iter1 first; typedef Iter2 second; #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) typedef pair< typename deref::type , typename deref::type > type; typedef typename mpl::next::type i1_; typedef typename mpl::next::type i2_; typedef pair_iter next; typedef apply_wrap2< aux::prior_pair_iter,Iter1,Iter2 >::type prior; #endif }; #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename Iter1, typename Iter2, typename C > struct deref< pair_iter > { typedef pair< typename deref::type , typename deref::type > type; }; template< typename Iter1, typename Iter2, typename C > struct next< pair_iter > { typedef typename mpl::next::type i1_; typedef typename mpl::next::type i2_; typedef pair_iter type; }; template< typename Iter1, typename Iter2, typename C > struct prior< pair_iter > { typedef typename mpl::prior::type i1_; typedef typename mpl::prior::type i2_; typedef pair_iter type; }; #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template<> struct advance_impl { template< typename Iter, typename D > struct apply { typedef typename mpl::advance< typename Iter::first,D >::type i1_; typedef typename mpl::advance< typename Iter::second,D >::type i2_; typedef pair_iter type; }; }; template<> struct distance_impl { template< typename Iter1, typename Iter2 > struct apply { // agurt, 10/nov/04: MSVC 6.5 ICE-s on forwarding typedef typename mpl::distance< typename first::type , typename first::type >::type type; }; }; template< typename BOOST_MPL_AUX_NA_PARAM(Sequence1) , typename BOOST_MPL_AUX_NA_PARAM(Sequence2) > struct pair_view { typedef nested_begin_end_tag tag; typedef typename begin::type iter1_; typedef typename begin::type iter2_; typedef typename min< typename iterator_category::type , typename iterator_category::type >::type category_; typedef pair_iter begin; typedef pair_iter< typename end::type , typename end::type , category_ > end; }; BOOST_MPL_AUX_NA_SPEC(2, pair_view) }} #endif // BOOST_MPL_PAIR_VIEW_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/quote.hpp0000644000175000017500000000574011344301501030105 0ustar debiandebian #if !defined(BOOST_PP_IS_ITERATING) ///// header body #ifndef BOOST_MPL_QUOTE_HPP_INCLUDED #define BOOST_MPL_QUOTE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/quote.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #if !defined(BOOST_MPL_PREPROCESSING_MODE) # include # include #endif #include #if defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) # define BOOST_MPL_CFG_NO_QUOTE_TEMPLATE #endif #if !defined(BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS) \ && defined(BOOST_MPL_CFG_NO_HAS_XXX) # define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS #endif #include #if !defined(BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS) \ && !defined(BOOST_MPL_PREPROCESSING_MODE) # define BOOST_MPL_PREPROCESSED_HEADER quote.hpp # include #else # include # include # include # include # include # include #if !defined(BOOST_MPL_CFG_NO_QUOTE_TEMPLATE) namespace boost { namespace mpl { #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< typename T, bool has_type_ > struct quote_impl : T { }; template< typename T > struct quote_impl { typedef T type; }; #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION template< bool > struct quote_impl { template< typename T > struct result_ : T { }; }; template<> struct quote_impl { template< typename T > struct result_ { typedef T type; }; }; #endif #define BOOST_PP_ITERATION_PARAMS_1 \ (3,(1, BOOST_MPL_LIMIT_METAFUNCTION_ARITY, )) #include BOOST_PP_ITERATE() }} #endif // BOOST_MPL_CFG_NO_QUOTE_TEMPLATE #endif // BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS #endif // BOOST_MPL_QUOTE_HPP_INCLUDED ///// iteration #else #define i_ BOOST_PP_FRAME_ITERATION(1) template< template< BOOST_MPL_PP_PARAMS(i_, typename P) > class F , typename Tag = void_ > struct BOOST_PP_CAT(quote,i_) { template< BOOST_MPL_PP_PARAMS(i_, typename U) > struct apply #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) : quote_impl< F< BOOST_MPL_PP_PARAMS(i_, U) > , aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value > #else : quote_impl< aux::has_type< F< BOOST_MPL_PP_PARAMS(i_, U) > >::value > ::template result_< F< BOOST_MPL_PP_PARAMS(i_, U) > > #endif { }; }; #undef i_ #endif // BOOST_PP_IS_ITERATING mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_back.hpp0000644000175000017500000000201711344301501030520 0ustar debiandebian #ifndef BOOST_MPL_POP_BACK_HPP_INCLUDED #define BOOST_MPL_POP_BACK_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/pop_back.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) > struct pop_back : pop_back_impl< typename sequence_tag::type > ::template apply< Sequence > { BOOST_MPL_AUX_LAMBDA_SUPPORT(1,pop_back,(Sequence)) }; BOOST_MPL_AUX_NA_SPEC(1, pop_back) }} #endif // BOOST_MPL_POP_BACK_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/next_prior.hpp0000644000175000017500000000217711344301501031142 0ustar debiandebian #ifndef BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED #define BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/next_prior.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include namespace boost { namespace mpl { BOOST_MPL_AUX_COMMON_NAME_WKND(next) BOOST_MPL_AUX_COMMON_NAME_WKND(prior) template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct next { typedef typename T::next type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,next,(T)) }; template< typename BOOST_MPL_AUX_NA_PARAM(T) > struct prior { typedef typename T::prior type; BOOST_MPL_AUX_LAMBDA_SUPPORT(1,prior,(T)) }; BOOST_MPL_AUX_NA_SPEC(1, next) BOOST_MPL_AUX_NA_SPEC(1, prior) }} #endif // BOOST_MPL_NEXT_PRIOR_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/lambda_fwd.hpp0000644000175000017500000000243111344301501031022 0ustar debiandebian #ifndef BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED #define BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/lambda_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) # include # include # include namespace boost { namespace mpl { template< typename T = na , typename Tag = void_ BOOST_MPL_AUX_LAMBDA_ARITY_PARAM( typename Arity = int_< aux::template_arity::value > ) > struct lambda; }} #else // BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT # include namespace boost { namespace mpl { template< typename T = na , typename Tag = void_ , typename Protect = true_ > struct lambda; }} #endif #endif // BOOST_MPL_LAMBDA_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/upper_bound.hpp0000644000175000017500000000707511344301501031275 0ustar debiandebian #ifndef BOOST_MPL_UPPER_BOUND_HPP_INCLUDED #define BOOST_MPL_UPPER_BOUND_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/upper_bound.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #if BOOST_WORKAROUND(__BORLANDC__, < 0x600) # define BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL #endif #if !defined(BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL) # include # include # include # include # include # include # include # include # include # include # include #else # include # include #endif #include namespace boost { namespace mpl { #if defined(BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL) // agurt 23/oct/02: has a wrong complexity etc., but at least it works; // feel free to contribute a better implementation! template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) , typename Predicate = less<> , typename pred_ = typename lambda::type > struct upper_bound : find_if< Sequence, bind2 > { }; #else namespace aux { template< typename Distance , typename Predicate , typename T , typename DeferredIterator > struct upper_bound_step_impl; template< typename Distance , typename Predicate , typename T , typename DeferredIterator > struct upper_bound_step { typedef typename eval_if< Distance , upper_bound_step_impl , DeferredIterator >::type type; }; template< typename Distance , typename Predicate , typename T , typename DeferredIterator > struct upper_bound_step_impl { typedef typename divides< Distance, long_<2> >::type offset_; typedef typename DeferredIterator::type iter_; typedef typename advance< iter_,offset_ >::type middle_; typedef typename apply2< Predicate , T , typename deref::type >::type cond_; typedef typename prior< minus< Distance, offset_ > >::type step_; typedef upper_bound_step< offset_,Predicate,T,DeferredIterator > step_forward_; typedef upper_bound_step< step_,Predicate,T,next > step_backward_; typedef typename eval_if< cond_ , step_forward_ , step_backward_ >::type type; }; } // namespace aux template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(T) , typename Predicate = less<> > struct upper_bound { private: typedef typename lambda::type pred_; typedef typename size::type size_; public: typedef typename aux::upper_bound_step< size_,pred_,T,begin >::type type; }; #endif // BOOST_MPL_CFG_STRIPPED_DOWN_UPPER_BOUND_IMPL BOOST_MPL_AUX_NA_SPEC(2, upper_bound) }} #endif // BOOST_MPL_UPPER_BOUND_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/shift_left.hpp0000644000175000017500000000123011344301501031065 0ustar debiandebian #ifndef BOOST_MPL_SHIFT_LEFT_HPP_INCLUDED #define BOOST_MPL_SHIFT_LEFT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright Jaap Suter 2003 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/shift_left.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME shift_left #define AUX778076_OP_TOKEN << #include #endif // BOOST_MPL_SHIFT_LEFT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/next.hpp0000644000175000017500000000103011344301501027712 0ustar debiandebian #ifndef BOOST_MPL_NEXT_HPP_INCLUDED #define BOOST_MPL_NEXT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/next.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #endif // BOOST_MPL_NEXT_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/count_fwd.hpp0000644000175000017500000000123011344301501030726 0ustar debiandebian #ifndef BOOST_MPL_COUNT_FWD_HPP_INCLUDED #define BOOST_MPL_COUNT_FWD_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/count_fwd.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ namespace boost { namespace mpl { template< typename Tag > struct count_impl; template< typename Sequence, typename T > struct count; }} #endif // BOOST_MPL_COUNT_FWD_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/back_inserter.hpp0000644000175000017500000000143111344301501031554 0ustar debiandebian #ifndef BOOST_MPL_BACK_INSERTER_HPP_INCLUDED #define BOOST_MPL_BACK_INSERTER_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2003-2004 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/back_inserter.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include namespace boost { namespace mpl { template< typename Sequence > struct back_inserter : inserter< Sequence,push_back<> > { }; }} #endif // BOOST_MPL_BACK_INSERTER_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/erase.hpp0000644000175000017500000000222211344301501030037 0ustar debiandebian #ifndef BOOST_MPL_ERASE_HPP_INCLUDED #define BOOST_MPL_ERASE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/erase.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include namespace boost { namespace mpl { template< typename BOOST_MPL_AUX_NA_PARAM(Sequence) , typename BOOST_MPL_AUX_NA_PARAM(First) , typename BOOST_MPL_AUX_NA_PARAM(Last) > struct erase : erase_impl< typename sequence_tag::type > ::template apply< Sequence,First,Last > { BOOST_MPL_AUX_LAMBDA_SUPPORT(3,erase,(Sequence,First,Last)) }; BOOST_MPL_AUX_NA_SPEC(3,erase) }} #endif // BOOST_MPL_ERASE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/not_equal_to.hpp0000644000175000017500000000121211344301501031427 0ustar debiandebian #ifndef BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED #define BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/not_equal_to.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #define AUX778076_OP_NAME not_equal_to #define AUX778076_OP_TOKEN != #include #endif // BOOST_MPL_NOT_EQUAL_TO_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/replace_if.hpp0000644000175000017500000000355311344301501031041 0ustar debiandebian #ifndef BOOST_MPL_REPLACE_IF_HPP_INCLUDED #define BOOST_MPL_REPLACE_IF_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // Copyright John R. Bandela 2000-2002 // Copyright David Abrahams 2003-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/replace_if.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include namespace boost { namespace mpl { namespace aux { template< typename Predicate, typename T > struct replace_if_op { template< typename U > struct apply #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) : if_< typename apply1::type , T , U > { #else { typedef typename if_< typename apply1::type , T , U >::type type; #endif }; }; template< typename Sequence , typename Predicate , typename T , typename Inserter > struct replace_if_impl : transform1_impl< Sequence , protect< aux::replace_if_op > , Inserter > { }; template< typename Sequence , typename Predicate , typename T , typename Inserter > struct reverse_replace_if_impl : reverse_transform1_impl< Sequence , protect< aux::replace_if_op > , Inserter > { }; } // namespace aux BOOST_MPL_AUX_INSERTER_ALGORITHM_DEF(4, replace_if) }} #endif // BOOST_MPL_REPLACE_IF_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_base.hpp0000644000175000017500000000265411344301501031101 0ustar debiandebian #ifndef BOOST_MPL_EMPTY_BASE_HPP_INCLUDED #define BOOST_MPL_EMPTY_BASE_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2001-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/empty_base.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include // should be always the last #include directive #include namespace boost { namespace mpl { // empty base class, guaranteed to have no members; inheritance from // 'empty_base' through the 'inherit' metafunction is a no-op - see // "mpl/inherit.hpp> header for the details struct empty_base {}; template< typename T > struct is_empty_base : false_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using false_::value; #endif }; template<> struct is_empty_base : true_ { #if BOOST_WORKAROUND(BOOST_MSVC, < 1300) using true_::value; #endif }; }} namespace boost { BOOST_TT_AUX_BOOL_TRAIT_SPEC1(is_empty, mpl::empty_base, true) } #include #endif // BOOST_MPL_EMPTY_BASE_HPP_INCLUDED mgltools-utpackages-1.5.7~rc1~cvs.20130519/multisdfDIST/CGAL-3.1/include/boost/mpl/assert.hpp0000644000175000017500000002451511344301501030252 0ustar debiandebian #ifndef BOOST_MPL_ASSERT_HPP_INCLUDED #define BOOST_MPL_ASSERT_HPP_INCLUDED // Copyright Aleksey Gurtovoy 2000-2004 // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org/libs/mpl for documentation. // $Source: /opt/cvs/multisdfDIST/CGAL-3.1/include/boost/mpl/assert.hpp,v $ // $Date: 2010/03/05 22:18:41 $ // $Revision: 1.1.1.1 $ #include #include #include #include #include #include #include #include #include #include #include #include #if BOOST_WORKAROUND(__BORLANDC__, >= 0x560) && BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ || (BOOST_MPL_CFG_GCC != 0) # define BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES #endif #if BOOST_WORKAROUND(__MWERKS__, < 0x3202) \ || BOOST_WORKAROUND(__EDG_VERSION__, <= 238) \ || BOOST_WORKAROUND(__BORLANDC__, < 0x600) \ || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) # define BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER #endif BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN struct failed {}; // agurt, 24/aug/04: MSVC 7.1 workaround here and below: return/accept // 'assert' by reference; can't apply it unconditionally -- apparently it // degrades quality of GCC diagnostics #if BOOST_WORKAROUND(BOOST_MSVC, == 1310) # define AUX778076_ASSERT_ARG(x) x& #else # define AUX778076_ASSERT_ARG(x) x #endif template< bool C > struct assert { typedef void* type; }; template<> struct assert { typedef AUX778076_ASSERT_ARG(assert) type; }; template< bool C > int assertion_failed( typename assert::type ); template< bool C > struct assertion { static int failed( assert ); }; template<> struct assertion { static int failed( void* ); }; struct assert_ { #if !defined(BOOST_MPL_CFG_NO_DEFAULT_PARAMETERS_IN_NESTED_TEMPLATES) template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {}; #endif static assert_ const arg; enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal }; }; #if !defined(BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES) bool operator==( failed, failed ); bool operator!=( failed, failed ); bool operator>( failed, failed ); bool operator>=( failed, failed ); bool operator<( failed, failed ); bool operator<=( failed, failed ); #if defined(__EDG_VERSION__) template< bool (*)(failed, failed), long x, long y > struct assert_relation {}; # define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation #else template< BOOST_MPL_AUX_NTTP_DECL(long, x), BOOST_MPL_AUX_NTTP_DECL(long, y), bool (*)(failed, failed) > struct assert_relation {}; # define BOOST_MPL_AUX_ASSERT_RELATION(x, y, r) assert_relation #endif #else // BOOST_MPL_CFG_ASSERT_USE_RELATION_NAMES boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ ); boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ ); boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ ); boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ ); boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ ); boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ ); template< assert_::relations r, long x, long y > struct assert_relation {}; #endif #if !defined(BOOST_MPL_CFG_ASSERT_BROKEN_POINTER_TO_POINTER_TO_MEMBER) template< bool > struct assert_arg_pred_impl { typedef int type; }; template<> struct assert_arg_pred_impl { typedef void* type; }; template< typename P > struct assert_arg_pred { typedef typename P::type p_type; typedef typename assert_arg_pred_impl< p_type::value >::type type; }; template< typename P > struct assert_arg_pred_not { typedef typename P::type p_type; enum { p = !p_type::value }; typedef typename assert_arg_pred_impl